您当前的位置:首页 > 计算机 > 软件应用 > 数据库 > 其它数据库

深入理解JDBC(理论+实操)

时间:07-14来源:作者:点击数:

JDBC概述

如果没有JDBC,应用程序在操作数据库的时候,可能因为数据库的不同,写多个版本的数据库语言,如下图所示:

img

有了JDBC后,仅编写一次JDBC就可以操作多种数据库,如下图所示:

img
什么是JDBC

​ JDBC(java database connectivity): sun公司为了简化和统一java连接数据库,定义的一套规范(API,接口).

JDBC和驱动的关系

​ 接口(JDBC)与实现(驱动jar包)的关系

小结

  1. 为什么要学习JDBC? 为了java连接/操作数据库更加的简单方便, 学习成本减低
  2. JDBC和驱动关系?
    Jdbc 规范(大量接口,少量的类)
    驱动 实现

案例-JDBC快速入门

准备工作
create database hashnode;

use hashnode;

create table user(
	id int primary key auto_increment,
	username varchar(20),
	password varchar(20),
	nickname varchar(20)
);

INSERT INTO `USER` VALUES(null,'zs','123456','老张');
INSERT INTO `USER` VALUES(null,'ls','123456','老李');
INSERT INTO `USER` VALUES(null,'wangwu','123','东方不败');

需求

​ 查询所有的用户, 输出到控制台

步骤
  1. 创建Java工程, 拷贝驱动jar包
  2. 加载驱动
  3. 获得连接
  4. 创建执行sql语句对象
  5. 执行sql语句, 处理结果
  6. 释放资源
代码实现
  1. 驱动jar包导入项目
image-20220512102052802
image-20220512102308846
image-20220512102413127
  1. 代码实现
package com.hashnode;

import com.mysql.jdbc.Driver;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) throws Exception{
        // 	需求:查询所有的用户, 输出到控制台
        // 分析:
        // 1.创建项目,拷贝驱动jar包到模块下,并添加到classpath路径中
        // 2.注册驱动
        DriverManager.registerDriver(new Driver());

        // 3.获得连接
        String url = "jdbc:mysql://localhost:3306/hashnode";
        String username = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url,username,password);

        // 4.创建执行sql的对象
        Statement statement = connection.createStatement();

        // 5.执行sql语句,处理结果
        String sql = "select * from user";
        ResultSet resultSet = statement.executeQuery(sql);
        while (resultSet.next()) {
            // 取出来
            //System.out.print(resultSet.getObject("id")+" ");
            //System.out.print(resultSet.getObject("username")+" ");
            //System.out.print(resultSet.getObject("password")+" ");
            //System.out.println(resultSet.getObject("nickname"));
            System.out.print(resultSet.getObject(1)+"  ");
            System.out.print(resultSet.getObject(2)+"  ");
            System.out.print(resultSet.getObject(3)+"  ");
            System.out.println(resultSet.getObject(4));
            System.out.println("------------------------------------------------");
        }

        // 6.释放资源
        if (resultSet != null){
            resultSet.close();
        }

        if (statement != null){
            statement.close();
        }

        if (connection != null){
            connection.close();
        }
    }
}

小结

  1. 加载\注册驱动
  2. 获得连接
  3. 创建执行sql语句对象
  4. 执行sql语句 处理结果
  5. 释放资源

JDBC API详解

img

API-Drivermanager类

1.registerDriver(Driver driver) ;注册驱动

static {
	try {
		java.sql.DriverManager.registerDriver(new Driver());
	} catch (SQLException E) {
		throw new RuntimeException("Can't register driver!");
	}
}
image-20220528173458081

翻阅源码发现,通过API的方式注册驱动,Driver会new两次,所有推荐这种写法:

Class.forName("com.mysql.jdbc.Driver");  //当前就理解成 可以让com.mysql.jdbc.Driver里面的静态代码块执行
  1. getConnection(String url, String user, String password) ; 与数据库建立连接
    img

API-Connection接口

  1. 概述
    接口的实现在数据库驱动中。所有与数据库交互都是基于连接对象的。
  2. 作用
    createStatement() ;创建执行sql语句对象
    prepareStatement(String sql) ;创建预编译执行sql语句的对象

小结

  1. Connection代表连接对象, 是一个接口, 实现在驱动jar包; 操作数据库都是基于Connection的
  2. 作用:
    • connection.createStatement(); 创建执行sql语句对象

API-Statement接口

  1. 概述
    接口的实现在数据库驱动中. 用来操作sql语句(增删改查),并返回相应结果对象
  2. 作用
    ResultSet executeQuery(String sql) 根据查询语句返回结果集。只能执行select语句。
    int executeUpdate(String sql) 根据执行的DML(insert update delete)语句,返回受影响的行数。
    boolean execute(String sql) 此方法可以执行任意sql语句。返回boolean值.
    true: 执行select有查询的结果
    false: 执行insert, delete,update, 执行select没有查询的结果

小结

  1. statement 作用用来执行sql语句
  2. 执行查询
ResultSet excuteQuery(String sql);    //返回值是结果集
  1. 执行增删改
int excuteUpdate(String sql);  //返回值是受影响的行数

API-ResultSet接口

  1. 封装结果集,查询结果表的对象;
    提供一个游标,默认游标指向结果集第一行之前。
    调用一次next(),游标向下移动一行。
    提供一些get方法。
  2. ResultSet接口常用API
    • boolean next();将光标从当前位置向下移动一行
    • int getInt(int colIndex)以int形式获取ResultSet结果集当前行指定列号值
    • int getInt(String colLabel)以int形式获取ResultSet结果集当前行指定列名值
    • float getFloat(int colIndex)以float形式获取ResultSet结果集当前行指定列号值
    • float getFloat(String colLabel)以float形式获取ResultSet结果集当前行指定列名值
    • String getString(int colIndex)以String 形式获取ResultSet结果集当前行指定列号值
    • String getString(String colLabel)以String形式获取ResultSet结果集当前行指定列名值
    • Date getDate(int columnIndex); 以Date 形式获取ResultSet结果集当前行指定列号值
    • Date getDate(String columnName);以Date形式获取ResultSet结果集当前行指定列名值
    • void close()关闭ResultSet 对象
    • Object getObject(int columnIndex) ;获取ResultSet结果集当前行指定列号值

图解如下

image-20191202110340587
封装
  • 定义一个User类
package com.itheima.bean;

/**
 * @Description: user实体类, 封装数据的
 */
public class User {

    private int id;
    private String username;
    private String password;
    private String nickname;

    //提供get/set方法 Alt+Insert


    public User() {
    }

    public User(int id, String username, String password, String nickname) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.nickname = nickname;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

  • 封装
List<User> list = new ArrayList<User>();

while (resultSet.next()) {
    //每遍历一次, 就是1条记录, 就封装成一个User对象
    User user = new User(resultSet.getInt("id"),
    resultSet.getString("username"),
    resultSet.getString("password"),
    resultSet.getString("nickname"));
	list.add(user);
}

API-总结

API
  1. DriverManager:驱动管理器
    • 注册驱动
    • 获得连接
  2. Connection: 代表连接对象
    • 创建执行sql语句对象
    • 创建预编译sql语句对象
  3. Statement: 执行sql语句对象
    • 执行查询 Result executeQuery(String sql) 返回结果集
    • 执行增删改 int excuteUpdate(String sql) 返回受影响的行数
  4. ResultSet: 结果集
    • boolen next() 每调用一次, 光标就向下移动一行; 这个行有数据, 返回true; 没有数据, 返回false
    • get类型(String 列名); 根据列名 获得当前列的数据
注意事项
  • 包名
1556265529056

JDBC操作数据库练习

单元测试介绍和使用

JUnit介绍

​ JUnit是一个Java语言的单元测试jar。属于第三方工具,一般情况下需要导入jar包,不过,多数Java开发环境已经集成了JUnit作为单元测试工具.编写测试类,简单理解可以用于取代java的main方法

使用
  • 在测试类方法上添加注解@Test
  • 注解修饰的方法要求:public void 方法名() {…} ,方法名自定义,没有参数
img
  • 添加IDEA中集成的Junit库,使用快捷键“Alt+Enter”,点击“Add Junit …”
img
  • 使用:选中方法右键,执行当前方法或者选中类名右键,执行类中所有方法(方法必须标记@Test)
img

小结

  1. 常见使用错误,如果没有添加“@Test”,使用“Junit Test”进行运行,将抛异常
  2. 单元测试需要注意的地方:
img

案例-增删改查练习

需求
  • 使用JDBC完成增删改查练习
步骤
  1. 注册驱动
  2. 获得连接
  3. 创建执行sql语句对象
  4. 执行sql语句, 处理结果
  5. 释放资源
实现
package com.hashnode.test;

import com.hashnode.pojo.User;
import org.junit.Test;

import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;


public class Demo {

    @Test
    // 往hashnode数据库的user表中添加一条记录
    public void insert() throws Exception{
        // 1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 2.获得连接
        String url = "jdbc:mysql://localhost:3306/hashnode";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);

        // 3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        // 4.执行sql语句,处理结果
        String sql = "insert into user values(null,'zl','123456','赵六')";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数:"+rows);

        // 5.释放资源
        if (statement != null){
            statement.close();
        }

        if (connection != null){
            connection.close();
        }
    }

    @Test
    // 修改hashnode数据库的user表中wangwu的密码为123456
    public void update()throws Exception{
        // 1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 2.获得连接
        String url = "jdbc:mysql://localhost:3306/hashnode";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);

        // 3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        // 4.执行sql语句,处理结果
        String sql = "update user set password = '123456' where username = 'wangwu'";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数:"+rows);

        // 5.释放资源
        if (statement != null){
            statement.close();
        }

        if (connection != null){
            connection.close();
        }
    }

    @Test
    // 删除hashnode数据库的user表中id为3的记录
    public void delete() throws Exception{
        // 1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 2.获得连接
        String url = "jdbc:mysql://localhost:3306/hashnode";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);

        // 3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        // 4.执行sql语句,处理结果
        String sql = "delete from user where id = 3";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数:"+rows);

        // 5.释放资源
        if (statement != null){
            statement.close();
        }

        if (connection != null){
            connection.close();
        }
    }

    @Test
    // 查询hashnode数据库的user表中所有记录
    public void select1() throws Exception{
        // 1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 2.获得连接
        String url = "jdbc:mysql://localhost:3306/hashnode";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);

        // 3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        // 4.执行sql语句,处理结果
        String sql = "select * from user";
        ResultSet resultSet = statement.executeQuery(sql);

        // 创建ArrayList集合,限制集合元素类型为User
        ArrayList<User> list = new ArrayList<>();

        while (resultSet.next()) {
            // 创建一个User对象,用来封装记录的列数据
            User use = new User();
            // 封装数据
            use.setId(resultSet.getInt("id"));
            use.setUsername(resultSet.getString("username"));
            use.setPassword(resultSet.getString("password"));
            use.setNickname(resultSet.getString("nickname"));

            // 添加对象到集合
            list.add(use);
        }

        // 5.释放资源
        if (resultSet != null){
            resultSet.close();
        }

        if (statement != null){
            statement.close();
        }

        if (connection != null){
            connection.close();
        }

        //...
        for (User user1 : list) {
            System.out.println(user1);
        }
    }

    @Test
    // 查询hashnode数据库的user表中姓名为zs并且密码为123456的记录
    public void select2() throws Exception{
        // 1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 2.获得连接
        String url = "jdbc:mysql://localhost:3306/hashnode";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url, user, password);

        // 3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        // 4.执行sql语句,处理结果
        String sql = "select * from user where username = 'zs' and password = '123456'";
        ResultSet resultSet = statement.executeQuery(sql);

        User use = null;

        while (resultSet.next()) {
            // 创建一个User对象,用来封装记录的列数据
            use = new User();

            // 封装数据
            use.setId(resultSet.getInt("id"));
            use.setUsername(resultSet.getString("username"));
            use.setPassword(resultSet.getString("password"));
            use.setNickname(resultSet.getString("nickname"));
        }
        // 5.释放资源
        if (resultSet != null){
            resultSet.close();
        }

        if (statement != null){
            statement.close();
        }

        if (connection != null){
            connection.close();
        }
        // ...
        if (use == null){
            System.out.println("失败");
        }else{
            System.out.println("成功");
        }
    }

}

小结

  1. 步骤
    • 注册驱动
    • 获得连接
    • 创建执行sql语句对象
    • 执行sql语句, 处理结果
    • 释放资源
  2. 发现练习里面的代码大部分都是重复的, 所以应该抽取

案例-JDBC工具类的抽取

步骤

  1. 在src目录下,创建配置文件
  2. 定义JdbcUtils类
  3. 定义getConnection()方法
  4. 定义release()方法

实现

  • 创建配置文件,配置文件在src目录下,扩展名是properties
    image-20220528180310427
    配置文件:
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/hashnode
username=root
password=root
  • 工具类实现
package com.hashnode.utils;

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;


public class JDBCUtils {

    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    static {
        try {
            // 使用Properties对象加载配置文件
            // 创建Properties对象
            Properties pro = new Properties();

            // 读取配置文件中的数据
            //pro.load(new FileInputStream("my-code\\src\\db.properties"));
            // 返回的输入流的路径默认到src路径
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            pro.load(is);

            // 通过pro对象给属性赋值
            url = pro.getProperty("url");
            user = pro.getProperty("username");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            // 1.加载驱动
            Class.forName(driver);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获得连接
     *
     * @return 连接
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        // 2.获得连接
        Connection connection = DriverManager.getConnection(url, user, password);

        return connection;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}


小结

  1. 注意事项
    • 配置文件建议定义在src目录
    • 使用的getProperty()方法里面的参数应该和配置文件里面的key一致, 加""
    1556269458575

PreparedStatement

需求

​ 在控制台输入用户名和密码,查询数据库,如果数据库存在当前用户,显示登录成功!

​ 如果数据库不存在当前用户,显示登录失败!

img
登录是做什么
  • 登录说白了就是根据用户名和密码查询数据库, 如果能查询出来就是登录成功, 查询不出来就是登录失败

思路分析

image-20191202144713867
代码实现
  • LoginTest.java
package com.hashnode.test;


import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Scanner;


public class LoginTest {
    public static void main(String[] args) throws Exception{
        /*
            需求:
                在控制台输入用户名和密码,查询数据库,如果数据库存在当前用户,显示登录成功!
                如果数据库不存在当前用户,显示登录失败!
         */
        // 0.获取控制台输入的用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = sc.nextLine();
        System.out.println("请输入密码:");
        String password = sc.nextLine();

        // 1.注册驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建执行sql语句对象
        Statement statement = connection.createStatement();

        // 3.执行sql语句,处理结果  select * from user where username = 'zs' and password = '123456';
        String sql = "select * from user where  username = '"+username+"' and password = '"+password+"'";
        ResultSet resultSet = statement.executeQuery(sql);
        // 创建User对象,封装数据
        User user = null;
        while (resultSet.next()) {
            user = new User();// 查询到了就new对象
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        // 4.释放资源
        JDBCUtils.release(resultSet,statement,connection);
        // 5.判断结果,显示信息(判断user对象是否为null,如果为null说明就没有查询到数据,否则就查询到了)
        if (user == null){
            // 没有查询到
            System.out.println("登录失败!");
        }else{
            // 查询到
            System.out.println("登录成功,欢迎回来!");
        }

    }
}

小结

登录思路

  • 登录说白了就是根据用户名和密码查询数据库
  • 登录思路
    • 获得用户输入的用户名和密码
    • 使用Jdbc根据用户名和密码查询数据库 封装成User对象
    • 判断是否登录成功(判断User是否为null)
      • 登录成功 打印 ‘登录成功’
      • 登录失败 打印 登录失败’
SQL注入问题出现

当输入的密码 ' or '' = ' , 发现永远登录成功

SQL注入问题分析
  • 输入的密码 ’ or ‘’ = ', 语句如下
SELECT * FROM user WHERE username ='zs' AND password = '' or '' = ''
SELECT * FROM user WHERE username ='zs' AND password = '' or true
SELECT * FROM user WHERE  true
SELECT * FROM user 
  • 发现语句出现了sql注入问题
    把用户输入的 or 当成关键词注入到了sql语句里面了

案例-登录中SQL注入问题解决

目标

​ 能够完成PreparedStatement改造登录案例, 解决SQL注入问题

preparedStatement概述

预编译SQL语句对象, 是Statemen接口的子接口。

特点:

  • 性能要比Statement高
  • 会把sql语句先编译,格式固定好,
  • sql语句中的参数会发生变化,过滤掉用户输入的关键字(eg: or)
用法
通过connection对象创建
  • connection.prepareStatement(String sql) ;创建prepareStatement对象
  • sql表示预编译的sql语句,如果sql语句有参数通过?来占位
    SELECT * FROM user WHERE username = ? AND password = ?
    
设置参数
  • prepareStatement.set类型(int i,Object obj);参数1 i 指的就是问号的索引(指第几个问号,从1开始),参数2就是值 eg: setString(1,“zs”); setString(2,“123456”);
执行
ResultSet executeQuery(); 执行查询语句
int executeUpdate();执行增删改语句
实现
package com.hashnode.test;


import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Scanner;


public class LoginTestPrepare {
    public static void main(String[] args) throws Exception{
         /*
            需求:
                在控制台输入用户名和密码,查询数据库,如果数据库存在当前用户,显示登录成功!
                如果数据库不存在当前用户,显示登录失败!
         */
        // 0.获取控制台输入的用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = sc.nextLine();
        System.out.println("请输入密码:");
        String password = sc.nextLine();

        // 1.注册驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建预编译sql语句对象
        String sql = "select * from user where  username = ? and password = ?";
        PreparedStatement ps = connection.prepareStatement(sql);// 固定sql语句的格式

        // 3.设置参数值
        ps.setString(1,username);
        ps.setString(2,password);

        // 3.执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();// 注意: 这里不需要传sql语句

        // 创建User对象,封装数据
        User user = null;
        while (resultSet.next()) {
            user = new User();// 查询到了就new对象
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        // 4.释放资源
        JDBCUtils.release(resultSet,ps,connection);

        // 5.判断结果,显示信息(判断user对象是否为null,如果为null说明就没有查询到数据,否则就查询到了)
        if (user == null){
            // 没有查询到
            System.out.println("登录失败!");
        }else{
            // 查询到
            System.out.println("登录成功,欢迎回来!");
        }
    }
}

小结

  1. 注册驱动
  2. 获得连接
  3. 创建预编译SQL语句对象
  4. 设置参数
  5. 执行sql语句
  6. 释放资源

案例-使用preparedStatement完成CRUD

需求

​ 通过PreparedStatement完成增、删、改、查

分析

  1. 注册驱动
  2. 获得连接
  3. 创建预编译sql语句对象
  4. 设置参数 执行
  5. 释放资源

实现

package com.hashnode.test;
import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;
import org.junit.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;

public class DemoCRUD {
    @Test
    // 往hashnode数据库的user表中插入一条记录
    public void insert() throws Exception{
        // 1.加载驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建预编译sql语句对象
        String sql = "insert into user values(null,?,?,?)";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 3.设置参数
        ps.setString(1,"tq" );
        ps.setString(2,"123456" );
        ps.setString(3,"田七" );

        // 4.执行sql语句
        int rows = ps.executeUpdate();
        System.out.println("受影响的行数:"+rows);

        // 5.释放资源
        JDBCUtils.release(null, ps, connection);
    }

    @Test
    // 修改hashnode数据库的user表中的id为7的密码为abcdef
    public void update() throws Exception{
        // 1.加载驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建预编译sql语句对象
        String sql = "update user set password = ? where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 3.设置参数
        ps.setString(1,"abcdef" );
        ps.setInt(2,7 );

        // 4.执行sql语句
        int rows = ps.executeUpdate();
        System.out.println("受影响的行数:"+rows);

        // 5.释放资源
        JDBCUtils.release(null, ps, connection);
    }

    @Test
    // 删除hashnode数据库的user表中的id为5
    public void delete() throws Exception{
        // 1.加载驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建预编译sql语句对象
        String sql = "delete from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 3.设置参数
        ps.setInt(1,5 );

        // 4.执行sql语句
        int rows = ps.executeUpdate();
        System.out.println("受影响的行数:"+rows);

        // 5.释放资源
        JDBCUtils.release(null, ps, connection);
    }

    @Test
    // 查询hashnode数据库的user表中的所有数据
    public void select1() throws Exception{
        // 1.注册驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建预编译sql语句对象
        String sql = "select * from user";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 3.设置参数(不需要,因为sql语句没有参数)

        // 4.执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        // 创建ArrayList集合,限制集合元素类型为User
        ArrayList<User> list = new ArrayList<User>();
        while (resultSet.next()) {
            // 创建User对象
            User user = new User();
            // 给属性赋值
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
            // 添加到集合中
            list.add(user);
        }

        // 5.释放资源
        JDBCUtils.release(resultSet, ps, connection);

        for (User user : list) {
            System.out.println(user);
        }
    }


    @Test
    // 查询hashnode数据库的user表中姓名为zs
    public void select2() throws Exception{
        // 1.注册驱动,获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.创建预编译sql语句对象
        String sql = "select * from user where username = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 3.设置参数
        ps.setString(1,"zs" );

        // 4.执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();

        User user = null;

        while (resultSet.next()) {
            // 创建User对象
            user = new User();
            // 给属性赋值
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }

        // 5.释放资源
        JDBCUtils.release(resultSet, ps, connection);

        System.out.println(user);
    }

}


小结

步骤

  1. 注册驱动
  2. 获得连接
  3. 创建预编译sql语句对象
  4. 设置参数,
  5. 执行sql语句
  6. 释放资源

创建预编译sql语句对象:

connection.prepareStatement(String sql); //sql里面有参数, 先用?代替,进行占位

设置参数:

prepareStatement.set类型(int 第几个问号,Object 值);

执行

Result result = prepareStatement.excuteQuery();  //执行查询 不传sql语句
int rows  = prepareStatement.excuteUpdate();  //执行增删改 不传sql语句

注意事项

  1. ?只能占参数,说白了就是列的值
  2. ?从1开始计
  3. 执行的时候不要传入sql语句

JDBC事务的处理

JDBC事务介绍

之前我们是使用MySQL的命令来操作事务。接下来我们使用JDBC来操作事务. 先来学习下相关的API

讲解
Connection中与事务有关的方法 说明
setAutoCommit(boolean autoCommit) 参数是true或false 如果设置为false,表示关闭自动提交,相当于开启事务; 类似sql里面的 start transaction;
void commit() 提交事务; 类似sql里面的 commit;
void rollback() 回滚事务; 类似sql里面的 rollback;

代码演示:

public class Test {
    public static void main(String[] args) throws Exception{
        /*
            Connection接口:
                  setAutoCommit(boolean autoCommit)	参数是true或false  如果设置为false,表示关闭自动提交,相当于开启事务; 类似sql里面的 start transaction;
                  void commit()                    	提交事务; 类似sql里面的 commit;
                  void rollback()                  	回滚事务; 类似sql里面的 rollback;
         */
        // 1.注册驱动获得连接
        Connection connection = JDBCUtils.getConnection();

        // 2.开启事务
        connection.setAutoCommit(false);

        // 3.执行sql语句
        String sql = "update user set password = ? where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 设置参数
        ps.setString(1, "666666");
        ps.setInt(2,6);

        // 执行sql语句
        int rows = ps.executeUpdate();
        System.out.println("受影响的行数:"+rows);

        // 4.提交或者回滚事务
        //connection.commit();

        connection.rollback();

        // 5.释放资源
        JDBCUtils.release(null,ps,connection);
    }
}

public class Test {
    public static void main(String[] args) {
        /*
            Connection接口:
                  setAutoCommit(boolean autoCommit)	参数是true或false  如果设置为false,表示关闭自动提交,相当于开启事务; 类似sql里面的 start transaction;
                  void commit()                    	提交事务; 类似sql里面的 commit;
                  void rollback()                  	回滚事务; 类似sql里面的 rollback;
         */
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            // 1.注册驱动获得连接
            connection = JDBCUtils.getConnection();

            // 2.开启事务
            connection.setAutoCommit(false);

            // 3.执行sql语句
            String sql = "update user set password = ? where id = ?";
            ps = connection.prepareStatement(sql);

            // 设置参数
            ps.setString(1, "666666");
            ps.setInt(2, 6);

            // 执行sql语句
            int rows = ps.executeUpdate();
            System.out.println("受影响的行数:" + rows);

            System.out.println(1/0);// 出现异常

            // 4.提交或者回滚事务
            connection.commit();

        } catch (Exception e) {
            e.printStackTrace();
            // 如果有异常,就回滚事务
            try {
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {

            // 5.释放资源
            JDBCUtils.release(null, ps, connection);
        }
    }
}
小结
connection.setAutoCommit(false); 开启事务
connection.commit();提交事务
connection.rollback();回顾事务

案例-转账案例

  • 案例的准备工作
create table account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);

insert into account values (null,'zs',1000);
insert into account values (null,'ls',1000);
insert into account values (null,'ww',1000);

需求

​ zs给ls转100, 使用事务进行控制

分析

image-20191202161110453

实现

  • 代码实现
public class Test {
    public static void main(String[] args) {
        // 需求: zs给ls转100, 使用事务进行控制
        Connection connection = null;
        PreparedStatement ps1 = null;
        PreparedStatement ps2 = null;
        try {
            // 1.注册驱动,获得连接
            connection = JDBCUtils.getConnection();

            // 2.***************开启事务***********************
            connection.setAutoCommit(false);

            // 3.书写sql语句,预编译sql语句,得到预编译对象
            String sql1 = "update account set money = money - ? where name = ?";
            String sql2 = "update account set money = money + ? where name = ?";
            ps1 = connection.prepareStatement(sql1);
            ps2 = connection.prepareStatement(sql2);

            // 4.设置参数,执行sql语句
            // zs账户-100
            ps1.setDouble(1,100);
            ps1.setString(2,"zs");
            ps1.executeUpdate();

            // 模拟张三-100之后,李四还没+100就出现异常
            System.out.println(1/0);

            // ls账户+100
            ps2.setDouble(1,100);
            ps2.setString(2,"ls");
            ps2.executeUpdate();

            // 5.***********************如果成功,就提交事务;******************
            connection.commit();
        } catch (Exception e) {
            e.printStackTrace();
            // 5.*********************如果失败,就回滚;**********************
            try {
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            // 6.释放资源
            JDBCUtils.release(null,ps1,connection);
            JDBCUtils.release(null,ps2,null);
        }
    }
}

小结

  1. 涉及到两个写的操作,我们一般通过手动事务去控制
  2. JDBC操作事务API
connection.setAutoCommit(fasle);  //开启事务
connection.commit();              //提交事务
connection.rollback();            //回滚事务
方便获取更多学习、工作、生活信息请关注本站微信公众号城东书院 微信服务号城东书院 微信订阅号
推荐内容
相关内容
栏目更新
栏目热门
本栏推荐