JDBC是什么？

Java DataBase Connectivity(Java语言连接数据库)

JDBC本质是什么？

JDBC是SUN公司制定的一套接口（interface）
java.sql.*;（这个软件包下有很多接口。）

接口都有调用者和实现者。
面向接口调用、面向接口写实现类，这都属于面向接口编程。

为什么要面向接口编程？
解耦合：降低程序的耦合度，提高程序的扩展力。
多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）。
建议：
Animal a = new Cat();
Animal a = new Dog();
//喂养的方法
public void feed(Animal a){//面向父类型编程。

}
不建议：
Dog d = new Dog();
Cat c = new Cat();

为什么SUN制定一套IDBC接口呢？
因为每一个数据库的底层实现原理都不一样。
Oracle数据库有自己的原理。
MySQL数据库也有自己的原理。
MS SqlServer数据库也有自己的原理。
......
每一个数据库产品都有自己独特的实现原理。

JDBC本质.png

JDBC本质到底是啥？
一套接口。

模拟JDBC的本质

SUN公司角色

/*
SUN公司负责制定这套JDBC接口。
*/

public interface JDBC{
    /*
        连接数据库的方法。
    */
    void getConnection();
}

MySQL数据库厂家

/*
    MySQL的数据库厂家负责编写JDBC接口的实现类
*/
public class MySQL implements JDBC{

    public void getConnection(){
        //具体这里的代码怎么写，对于我们Java程序员来说没关系，
        //这段代码涉及到mysql底层数据库的实现原理。
        System.out.println("连接MySQL数据库成功");
    }
}
//实现类被称为驱动。（MySQL驱动）

Oracle的数据库厂家

/*
    Oracle的数据库厂家负责编写JDBC接口的实现类
*/
public class Oracle implements JDBC{

    public void getConnection(){
        //具体这里的代码怎么写，对于我们Java程序员来说没关系，
        //这段代码涉及到mysql底层数据库的实现原理。
        System.out.println("连接Oracle数据库成功");
    }
}
//实现类被称为驱动。（Oracle驱动）

SqlServer的数据库

/*
    SqlServer的数据库厂家负责编写JDBC接口的实现类
*/
public class SqlServer implements JDBC{

    public void getConnection(){
        //具体这里的代码怎么写，对于我们Java程序员来说没关系，
        //这段代码涉及到mysql底层数据库的实现原理。
        System.out.println("连接SqlServer数据库成功");
    }
}
//实现类被称为驱动。（sqlserver驱动）
//xxx.jar 当中有很多.class，都是对JDBC接口进行的实现。

jdbc.properties配置文件

className=Oracle

Java程序员角色

/*
    Java程序员角色。
    不需要关心具体是哪个品牌的数据库，只需要面向JDBC接口写代码。
    面向接口编程，面向抽象编程，不要面向具体编程。
*/
import java.util.*;

public class JavaProgrammer{
    public static void main(String[] args) throws Exception{
        //JDBC jdbc = new MySQL();
        //JDBC jdbc = new Oracle();
        //JDBC jdbc = new SqlServer();

        //创建对象可以通过反射机制。
        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String className = bundle.getString("className");
        Class c = Class.forName(className);
        JDBC jdbc = (JDBC)c.newInstance();

        //以下代码都是面向接口调用方法，不需要修改
        jdbc.getConnection();
    }
}

以后如果想要修改，直接修改配置文件即可，代码不需要动。

JDBC开发前的准备

JDBC开发前的准备工作，先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中。
classpath=.;jar包路径
以上的配置是针对于文本编辑器的方式开发，使用IDEA工具的时候，不需要配置以上的环境变量。
IDEA有自己的配置方式。

JDBC编程六步

第一步：注册驱动（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）

第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道）
String url = "jdbc:mysql://IP地址:端口号/数据库名";
String user = "用户名";通常是root
String password = "密码";登录mysql的密码
Connection conn = DriverManager.getConnection(url,user,password);

第三步：获取数据库操作对象（专门执行sql语句的对象）

第四步：执行SQL语句（DQL DML.....）

第五步：处理查询结果集(只有当第四步执行的是select语句的时候，才有这第五步处理查询结果集。)

第六步：释放资源（使用完资源之后，一定要关闭资源。Java和数据库属于进程间的通信，开启之后一定要关闭。）

url:统一资源定位符（网络中某个资源的绝对路径）
https://www.baidu.com/这就是URL。
URL包括哪几部分？
协议
IP
PORT
资源名

https://182.61.200.7:80/index.html
http:// 通信协议
182.61.200.7 服务器IP地址
80 服务器上软件的端口
index.html 是服务器上某个资源名

jdbc:mysql://127.0.0.1:3306/lianxi
jdbc:mysql:// 协议
/127.0.0.1 IP地址
3306 mysql数据库端口号
lianxi 具体的数据库实例名。

说明：locahost和127.0.0.1都是本机IP地址。

什么是通信协议，有什么用？
通信协议是通信之前就提前定好的数据传送格式。
数据包具体怎么传数据，格式提前定好的。

Oracle的URL：
jdbc:oracle:thin:@localhost:1521:orcl

/*
    JDBC编程六步
*/
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.*;

public class JDBCTest01{
    public static void main(String[] args){
        Connection conn = null;
        Statement stmt = null;
        try{
            //1.注册驱动
            Driver driver = new com.mysql.jdbc.Driver();//多态，父类型引用指向子类型对象。
            //Driver driver = new oracle.jdbc.driver.OracleDriver();//oracle的驱动。
            DriverManager.registerDriver(driver);
            //2.获取连接
            /*
                url:统一资源定位符（网络中某个资源的绝对路径）
                https://www.baidu.com/这就是URL。
                URL包括哪几部分？
                协议
                IP
                PORT
                资源名

                https://182.61.200.7:80/index.html
                    http:// 通信协议
                    182.61.200.7 服务器IP地址
                    80 服务器上软件的端口
                    index.html 是服务器上某个资源名
                
                jdbc:mysql://127.0.0.1:3306/lianxi
                    jdbc:mysql:// 协议
                    /127.0.0.1 IP地址
                    3306 mysql数据库端口号
                    lianxi 具体的数据库实例名。

                说明：locahost和127.0.0.1都是本机IP地址。

                什么是通信协议，有什么用？
                    通信协议是通信之前就提前定好的数据传送格式。
                    数据包具体怎么传数据，格式提前定好的。

                Oracle的URL：
                jdbc:oracle:thin:@localhost:1521:orcl
            */
            String url = "jdbc:mysql://127.0.0.1:3306/lianxi?useSSL=false";
            String user = "root";
            String password = "123";
            conn = DriverManager.getConnection(url,user,password);
            System.out.println("数据库连接对象 = " + conn );

            //3.获取数据库操作对象(Statement专门执行sql语句的)
            stmt = conn.createStatement();

            //4.执行sql
            String sql = "insert into dept(deptno,dname,loc) values(50,'人事部','北京')";
            //专门执行DML语句的（insert delete update）
            //返回值是“影响数据库中的记录条数”
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "保存成功" : "保存失败");

            //5.处理查询结果集
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            //6.释放资源
            //为了保证资源一定释放，在finally语句块中关闭资源
            //并且要遵循从小到大依次关闭
            //分别对其try...catch
            try{
                if(stmt != null){
                stmt.close();
                }
            }catch(SQLException e){
                e.printStackTrace();
            }
            
            try{
                if(conn != null){
                conn.close();
                }
            }catch(SQLException e){
                e.printStackTrace();
            }

        }
    }
}

JDBC执行删除和更新

/*
    JDBC完成 delete update
*/
import java.sql.*;

public class JDBCTest02{
    public static void main(String[] args){
        Connection conn = null;
        Statement stmt = null;
        try{
            //1、注册驱动
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            //2、获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","123");
            //3、获取数据库操作对象
            stmt = conn.createStatement();
            //4、执行SQL语句
            //JDBC中的sql语句不需要提供分号结尾
            //String sql = "delete from dept where deptno = 50";
            String sql = "update dept set dname = '销售部',loc = '天津' where deptno = 20";
            int count = stmt.executeUpdate(sql);
            //System.out.println(count == 1 ? "删除成功" : "删除失败");
            System.out.println(count == 1 ? "更改成功" : "更改失败");
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            //6、释放资源
            if(stmt != null){
                try{
                    stmt.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }

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

    }
}

类加载的方式注册驱动（常用）

为什么这种方式常用？因为参数是一个字符串，字符串可以写到xxx.properties文件中。

/*
    注册驱动的另一种形式（这种方式常用）
*/
import java.sql.*;

public class JDBCTest03{
    public static void main(String[] args){
        try{
        //1、注册驱动
        //这是注册驱动的第一种写法。
        //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        //注册驱动的第二种方式：常用的。
        //为什么这种方式常用？因为参数是一个字符串，字符串可以写到xxx.properties文件中。
        //以下方法不需要接收返回值，因为我们只想用它的类加载动作。
        Class.forName("com.mysql.jdbc.Driver");
        //2、获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","buzhidao");
        //com.mysql.jdbc.JDBC4Connection@21b8d17c
        System.out.println(conn);

        }catch(SQLException e){
            e.printStackTrace();
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
    }
    
}

从属性资源文件中读取连接数据库信息

/*
    将连接数据库的所有信息配置到配置文件中
    实际开发中，不建议把连接数据库的信息写死到java程序中。
*/
import java.sql.*;
import java.util.*;

public class JDBCTest04{
    public static void main(String[] args){
        
        //使用资源绑定器绑定属性配置文件
        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");

        Connection conn = null;
        Statement stmt = null;
        try{
            //1、注册驱动
            Class.forName(driver);
            //2、获取连接
            conn = DriverManager.getConnection(url,user,password);
            //3、获取数据库操作对象
            stmt = conn.createStatement();
            //4、执行SQL语句
            //JDBC中的sql语句不需要提供分号结尾
            String sql = "delete from dept where deptno = 50";
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "删除成功" : "删除失败");
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //6、释放资源
            if(stmt != null){
                try{
                    stmt.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }

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

    }
}

jdbc.properties配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/lianxi?useSSL=false
user=root
password=123

处理查询结果集

遍历结果集.png

/*
    处理查询结果集（遍历结果集）
*/

import java.sql.*;

public class JDBCTest05{
    public static void main(String[] args){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            //1、注册驱动
            Class.forName("cm.mysql.jdbc.Driver");
            //2、获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","123");
            //3、获取数据库操作对象
            stmt = conn.createStatement();
            //4、执行SQL语句
            String sql = "select empno,ename,sal from emp";
            //int executeUpdate(insert delete update)
            //ResultSet executeQuery(select)
            rs = stmt.executeQuery(sql);//专门执行DQL语句的方法。
            //5、处理查询结果集
            while(rs.next()){
                //光标指向的的行有数据
                //取数据
                //getString()方法的特点是：不管数据库中的数据类型是什么，都以String的形式取出
                //以下程序的1，2，3 指的是第几列

                /*
                String empno = rs.getString(1);//JDBC中所有下标从1开始。不是从0开始。
                String ename = rs.getString(2);
                String sal = rs.getString(3);
                System.out.println(empno + "," + ename + "," + sal);
                */
                
                /*
                //这个不是以列的下标获取，是以列的名字获取
                //重点注意：列名称不是表中的列名称，是查询结果集的列名称
                String empno = rs.getString("empno");。
                String ename = rs.getString("ename");
                String sal = rs.getString("sal");
                System.out.println(empno + "," + ename + "," + sal);
                */
                
                //除了可以以String类型取出之外，还可以以特定的类型取出。
                /*
                int empno = rs.getInt(1);
                String ename = rs.getString(2);
                double sal = rs.getDouble(3);
                System.out.println(empno + "," + ename + "," + (sal + 100));
                */

                //这样也是可以的
                int empno = rs.getInt("empno");
                String ename = rs.getString("ename");
                double sal = rs.getDouble("sal");
                System.out.println(empno + "," + ename + "," + (sal + 200));
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }finally{
            //6、释放资源
            if(rs != null){
                try{
                    rs.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }

            if(stmt != null){
                try{
                    stmt.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }

            if(conn != null){
                try{
                    conn.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

使用IDEA开发JDBC代码配置驱动

首先新建一个空的工程
然后新建一个模块module
在模块上右键选择Open Module Settings
然后点Libraries
然后点“+”，选择Java
然后找jar包
选择模块
然后点击ok
然后点击apply
然后点击ok

小练习

实现功能：
1、需求：模拟用户登录功能的实现。
2、业务描述：
程序运行的时候，提供一个输入的入口，可以让用户输入用户名和密码，用户输入用户名和密码之后，提交信息，java程序收集到用户信息，java程序连接数据库验证用户名和密码是否合法
合法：显示登录成功
不合法：显示登录失败
3、数据的准备：
在实际开发中，表的设计会使用专业的建模工具，我们使用PowerDesigner，使用PD工具来进行数据库表的设计。(参见user-login.sql脚本)

user-login.sql脚本

drop table if exists t_user;

/*==============================================================*/
/* Table: t_user                                                */
/*==============================================================*/
create table t_user
(
   id                   bigint auto_increment,
   loginName            varchar(255),
   loginPwd             varchar(255),
   realName             varchar(255),
   primary key (id)
);

insert into t_user(loginName,loginPwd,realName) values('zhangsan','123','张三');
insert into t_user(loginName,loginPwd,realName) values('jack','123','杰克');

commit;
select * from t_user;

实现功能

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class JDBCTest06 {
    public static void main(String[] args) {
        //初始化一个界面
        Map<String,String> userLoginInfo = initUI();
        //验证用户名和密码
        boolean loginSuccess = login(userLoginInfo);
        //最后输出结果
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }

    /**
     * 用户登录
     * @param userLoginInfo 用户登录信息
     * @return false表示失败，true表示成功
     */
    private static boolean login(Map<String, String> userLoginInfo) {
        //要有打标记的意识
        boolean loginSuccess = false;

        //单独定义变量
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");

        //JDBC代码
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","123");
            //3.获取数据库操作对象
            stmt = conn.createStatement();
            //4.执行sql语句
            //String sql = "select * from t_user where loginName = '"+userLoginInfo.get("loginName")+"' and loginPwd = '"+userLoginInfo.get("loginPwd")+"'";
            String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd = '"+loginPwd+"'";
            rs = stmt.executeQuery(sql);
            //5.处理查询结果集
            //这里不需要while循环，判断即可
            if (rs.next()){
                //登录成功
                loginSuccess = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //6.释放资源
            if (rs != null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

        return loginSuccess;
    }

    /**
     * 初始化用户界面
     * @return 用户输入的用户名和密码等登录信息
     */
    private static Map<String, String> initUI() {
        Scanner s = new Scanner(System.in);

        System.out.print("请输入用户名：");
        String loginName = s.nextLine();

        System.out.print("请输入密码：");
        String loginPwd = s.nextLine();

        //创建一个Map集合来保存用户输入的用户名和密码
        Map<String,String> userLoginInfo = new HashMap<>();
        //把数据存到Map集合里面
        userLoginInfo.put("loginName",loginName);
        userLoginInfo.put("loginPwd",loginPwd);

        return userLoginInfo;
    }
}

SQL注入现象

以上的程序存在的问题：
请输入用户名：fdsa
请输入密码：fdsa' or '1'='1
登录成功
这种现象被称为SQL注入。（安全隐患）（黑客经常使用）

导致SQL注入的根本原因是什么？
用户输入的信息中含有sql语句的关键字，并且这些关键字参与sql语句的编译过程，导致sql语句的原意被扭曲，进而达到sql注入。

如何解决SQL注入问题？
只要用户提供的信息不参与SQL语句的编译过程，问题就解决了。
即使用户提供的信息中含有SQL语句的关键字，但是没有参与编译，不起作用。
要想用户信息不参与SQL语句的编译，那么必须使用java.sql.
PreparedStatement
PreparedStatement接口继承了java.sql.Statement
PreparedStatement是属于预编译的数据库操作对象。
PreparedStatement的原理是：预先对SQL语句的框架进行编译，然后再给SQL语句传“值”。

解决SQL注入的关键是什么？
用户提供的信息中即使含有sql语句的关键字，但是这些关键字并没有参与编译，不起作用。

/*
    解决SQL注入问题
 */

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class JDBCTest07 {
    public static void main(String[] args) {
        //初始化一个界面
        Map<String,String> userLoginInfo = initUI();
        //验证用户名和密码
        boolean loginSuccess = login(userLoginInfo);
        //最后输出结果
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }

    /**
     * 用户登录
     * @param userLoginInfo 用户登录信息
     * @return false表示失败，true表示成功
     */
    private static boolean login(Map<String, String> userLoginInfo) {
        //要有打标记的意识
        boolean loginSuccess = false;

        //单独定义变量
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");

        //JDBC代码
        Connection conn = null;
        PreparedStatement ps = null;//这里使用PreparedStatement（预编译的数据库操作对象）
        ResultSet rs = null;

        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","123");
            //3.获取预编译的数据库操作对象
            //SQL语句的框子，其中一个?，表示一个占位符，一个?将来接收一个“值”，注意：占位符不能用单引号括起来。
            String sql = "select * from t_user where loginName = ? and loginPwd = ?";
            //程序执行到此处，会发送sql语句框子给DBMS，然后DBMS进行sql语句的预先编译。
            ps = conn.prepareStatement(sql);
            //给占位符?传值（第1个问号下标是1，第2个问号下标是2。JDBC中所有下标从1开始。）
            ps.setString(1,loginName);
            ps.setString(2,loginPwd);
            //4.执行sql语句
            rs = ps.executeQuery();
            //5.处理查询结果集
            //这里不需要while循环，判断即可
            if (rs.next()){
                //登录成功
                loginSuccess = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //6.释放资源
            if (rs != null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

        return loginSuccess;
    }

    /**
     * 初始化用户界面
     * @return 用户输入的用户名和密码等登录信息
     */
    private static Map<String, String> initUI() {
        Scanner s = new Scanner(System.in);

        System.out.print("请输入用户名：");
        String loginName = s.nextLine();

        System.out.print("请输入密码：");
        String loginPwd = s.nextLine();

        //创建一个Map集合来保存用户输入的用户名和密码
        Map<String,String> userLoginInfo = new HashMap<>();
        //把数据存到Map集合里面
        userLoginInfo.put("loginName",loginName);
        userLoginInfo.put("loginPwd",loginPwd);

        return userLoginInfo;
    }
}

Statement和PreparedStatement

Statement存在SQL诸如问题，PreparedStatement解决了SQL注入问题。
Statement是编译依一次执行一次。PreparedStatement是编译一次，可执行N次。PreparedStatement效率较高一些。
PreparedStatement会在编译阶段做类型的安全检查。

综上所述：PreparedStatement使用较多，只有极少数的情况下需要使用Statement

Statement的用途

什么情况下必须使用Statement呢？
业务要求必须支持SQL注入的时候。

Statement支持SQL注入，凡是业务方面要求是需要进行SQL语句拼接的，必须使用Statement。

import java.sql.*;
import java.util.Scanner;

public class JDBCTest08 {
    public static void main(String[] args) {
        //用户在控制台输入desc就是降序，输入asc就是升序
        Scanner s = new Scanner(System.in);
        System.out.println("请输入desc或asc，desc表示降序，asc表示升序");
        System.out.print("请输入：");
        String keyWords = s.nextLine();

        //执行SQL
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","123");
            //获取数据库操作对象
            stmt = conn.createStatement();
            //执行SQL
            String sql = "select ename from emp order by ename " + keyWords;
            rs = stmt.executeQuery(sql);
            //遍历结果集
            while (rs.next()){
                System.out.println(rs.getString("ename"));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

PreparedStatement完成增删改

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCTest09 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:33306/lianxi?useSSL=false","root","buzhidao");
            //获取预编译的数据库操作对象

            
            //insert 增
            String sql = "insert into dept(deptno,dname,loc) values(?,?,?)";
            ps = conn.prepareStatement(sql);
            ps.setInt(1,60);
            ps.setString(2,"销售部");
            ps.setString(3,"上海");
            

            /*
            //update 改
            String sql = "update dept set dname = ?,loc = ? where deptno = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"研发一部");
            ps.setString(2,"北京");
            ps.setInt(3,60);
             */

            /*
            //delete 删
            String sql = "delete from dept where deptno = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1,60);
             */
            
            //执行sql语句
            int count = ps.executeUpdate();
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

JDBC的事务自动提交机制

JDBC中的事务时自动提交的，什么是自动提交？
只要执行任意一条DML语句，则自动提交一次，这是JDBC默认的事务行为。
但是在实际的业务当中，通常欧式N条DML语句共同联合才能完成的，必须保证他们这些DML语句在同一个事务中同时成功或者同时失败。

/*
    验证JDBC的事务是否是自动提交机制。
    测试结果：JDBC中只要执行任意一条DML语句，就提交一次。
 */
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCTest10 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:33306/lianxi?useSSL=false","root","buzhidao");
            //3、获取预编译的数据库操作对象
            String sql = "select dept set dname = ? where deptno = ?";
            ps = conn.prepareStatement(sql);
            //第一次给占位符赋值
            ps.setString(1,"x部门");
            ps.setInt(2,20);
            int count = ps.executeUpdate();//执行第一条update语句
            System.out.println(count);
            //重新给占位符赋值
            ps.setString(1,"y部门");
            ps.setInt(2,30);
            count = ps.executeUpdate();//执行第二条update语句
            System.out.println(count);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //6、释放资源
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

账户转账演示事务

t_act.aql脚本

drop table if exists t_act;                                     
create table t_act(                                             
    actno int,                                                  
    balance double(7,2)
);                                                              
insert into t_act(actno,balance) values(111,20000);             
insert into t_act(actno,balance) values(222,0);                 
commit;                                                         
select * from t_act;                                            

注意：这里没加主键。double中的参数，7表示有效数字的个数，2表示小数位的个数

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCTest11 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:33306/lianxi?useSSL=false","root","buzhidao");
            //3、获取预编译的数据库操作对象
            String sql = "update t_act set balance = ? where actno = ?";
            ps = conn.prepareStatement(sql);

            //给?传值
            ps.setDouble(1,10000);
            ps.setInt(2,111);
            int count = ps.executeUpdate();

            //给个异常
            String s = null;
            s.toString();

            //给?传值
            ps.setDouble(1,10000);
            ps.setInt(2,222);
            count += ps.executeUpdate();

            System.out.println(count == 2 ? "转账成功" : "转账失败");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //6、释放资源
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

自动提交机制，这样会出现错误，111账户丢1w块钱。
怎么解决这个问题？
重点的三行代码
conn.setAutoCommit(false);//开启事务
conn.commit();//提交事务
conn.rollback();//回滚事务

就是拿到连接对象之后，赶紧把自动提交机制关掉，然后sql执行，再然后你觉得哪里应该提交就提交，遇到异常就回滚，保证数据的安全性。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCTest11 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:33306/lianxi?useSSL=false","root","buzhidao");
            //将自动提交机制修改为手动提交
            conn.setAutoCommit(false);//开启事务
            //3、获取预编译的数据库操作对象
            String sql = "update t_act set balance = ? where actno = ?";
            ps = conn.prepareStatement(sql);

            //给?传值
            ps.setDouble(1,10000);
            ps.setInt(2,111);
            int count = ps.executeUpdate();

            //给个异常
            //String s = null;
            //s.toString();

            //给?传值
            ps.setDouble(1,10000);
            ps.setInt(2,222);
            count += ps.executeUpdate();

            System.out.println(count == 2 ? "转账成功" : "转账失败");

            //程序能够走到这里说明以上程序没有异常，事务结束，手动提交数据
            conn.commit();//提交事务
        } catch (Exception e) {
            //回滚事务
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            e.printStackTrace();
        } finally {
            //6、释放资源
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

JDBC工具类的封装

import java.sql.*;

/**
 * JDBC工具类，简化JDBC编程
 */
public class DBUtil {
    /**
     * 工具类中的构造方法都是私有的
     * 因为工具类当中的方法都是静态的，不需要new对象，直接采用类名调用
     * 编程技巧：为了防止别人new对象，五所以把构造方法私有了，这样就new不了了，只能采用类名调用
     */
    private DBUtil(){
    }

    //静态代码块在类加载时执行，并且只执行一次
    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据库连接对象
     *
     * @return 连接对象
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/lianxi?useSSL=false","root","buzhidao");
    }

    /**
     * 关闭资源
     *
     * @param conn 连接对象
     * @param ps 数据库操作对象
     * @param rs 结果集
     */
    public static void close(Connection conn , Statement ps , ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

JDBC实现模糊查询

以下例子，试用一下刚刚封装的DBUtil工具类是否好用。
把工具类放在了自己新建的util包下，使用时得导包。

import util.DBUtil;

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

public class JDBCTest12 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = DBUtil.getConnection();
            //获取预编译的数据库操作对象
            String sql = "select ename from enp where like ? ";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"_A%");
            rs = ps.executeQuery();
            while (rs.next()){
                System.out.println(rs.getString("ename"));
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        } finally {
            //释放资源
            DBUtil.close(conn,ps,rs);
        }
    }
}

悲观锁（行级锁）和乐观锁

image.png

在select语句后面加上 for update 之后，就表示，job为MANAGER的这一行记录谁都不能动。指的是下面表的job为MANAGER的一行记录。

emp表.png

乐观锁就是多线程并发，都可以对这一行数据进行修改，只不过在这条记录上，他有一个版本号，多个线程可以根据版本号，可以知道，数据有没有变化。

悲观锁（行级锁 for update）和乐观锁机制.png

演示行级锁

import util.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 这个程序开启一个事务，这个事务专门进行查询，并且使用行级锁/悲观锁，锁住相关的记录
 */
public class JDBCTest13 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = DBUtil.getConnection();
            //开启事务
            conn.setAutoCommit(false);

            String sql = "select ename,job,sal from emp where job = ? for update";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"MANAGER");

            rs = ps.executeQuery();
            while (rs.next()){
                System.out.println(rs.getString("ename") + "," + rs.getString("job") + "," + rs.getDouble("sal"));
            }
            //提交事务（事务结束）
            conn.commit();
        } catch (Exception throwables) {
            //回滚事务（事务结束）
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            throwables.printStackTrace();
        } finally {
            //释放资源
            DBUtil.close(conn,ps,rs);
        }
    }
}

import util.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 *这个程序负责修改被锁定的记录。
 */
public class JDBCTest14 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = DBUtil.getConnection();
            conn.setAutoCommit(false);

            String sql = "update emp set sall = sal * 1.1 where job = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"MANAGER");
            int count = ps.executeUpdate();
            System.out.println(count);
            conn.commit();
        } catch (SQLException throwables) {
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            throwables.printStackTrace();
        } finally {
            DBUtil.close(conn,ps,null);
        }
    }
}

在第一个的提交位置设置断点，然后debug运行，之后取运行第二代码，发现根本没有输出，锁住了，只有第一个程序执行结束之后，第二个程序才有输出。