JDBC

1、JDBC概念与原理

　   概念：

　　　　JDBC是java访问数据库的标准规范，是一种用于执行SQL语句的Java API，可以为 多种关系数据库提供统一访问，

　　　　它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范

　　原理：

　　　　JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需

　　　　要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供

　　总结：

　　　　 JDBC就是由sun公司定义的一套操作所有关系型数据库的规则(接口)，而数据库厂商需要实现这套接口,提供数据库

　　　　驱动jar包, 我们可以使用这套接口编程,真正执行的代码是对应驱动包中的实现类

　　

2、JDBC 开发

 配置：

　　1、下载MySQL驱动包，并且创建一个jar包仓库文件

　　2、在ider中配置jar包仓库的位置

　　

 　　3、创建一个新的项目，然后配置jar包就可以使用 api了

　　

---

 API使用: 1.注册驱动　

　　1、API使用: 注册驱动　

　　　　- JDBC规范定义驱动接口： java.sql.Driver

　　　　- Mysql驱动包提供了实现类：com.mysql.jdbc.Driver

　　　   加载注册驱动的方式　　　　　　　　　　描述

　　　　Class.forName(数据库驱动实现类） 　　 加载和注册数据库驱动，数据库驱动由数据库厂商MySql提供

　　　　　　　　　　　　　　　　　　　　　　　"com.mysql.jdbc.Driver"

　　

　　2、代码示例

　　　　1）注册驱动

　　　　

public  class JDBCDemo1{

　　　　　　　public static void main(String[] agrs) throws ClassNotFoundException{

　　　　　　　　　　//1.注册驱动

　　　　　　　　　　// forName 方法执行将类进行初始化

　　　　　　　　　　Class.forName("com.mysql.jdbc.Driver");

　　　　　　　　}

　　　　　　}　

　　　　2）为什么这样可以注册驱动?

　　　　     Class类的forName方法可以将一个类初始化，看看下面的源码

　　　// Driver类是MySql提供的数据库驱动类, 实现了JDBC的Driver接口 java.sql.Driver

　　 public class Driver extends NonRegisteringDriver implements java.sql.Driver {

　　　　// 空参构造

　　　　public Driver() throws SQLException {

　　　　}

　　　　//静态代码块,Class类的 forName()方法将Driver类 加载到内存, static代码块会自动执行

　　　　static {

　　　　　　try {

　　　　　　　　 /* DriverManager 驱动管理类

　　　　　　　　　　registerDriver(new Driver) 注册驱动的方法

　　　　　　　　　　注册数据库驱动

　　　　　　　　*/

　　　　　　　　DriverManager.registerDriver(new Driver());

　　　　　　} catch (SQLException var1) {

　　　　　　　　throw new RuntimeException("Can't register driver!"); 

　　　　　　}

　　　　 }

　　　}

　　   注意： 从 JDBC3 开始，目前已经普遍使用的版本。可以不用注册驱动而直接使用。 Class.forName 这句话可以省略

---

 API使用: 2.获得连接　　　　

　　1.Connection接口：

　　 　　-  Connection 接口，代表一个连接对象，具体的实现类由数据库的厂商实现

　　 　　-  使用 DriverManager类的静态方法，getConnection可以获取数据库的连接

　　 　　-  获取连接的静态方法　　　　　　　　　　　　　　　　　　　　　　　　说明

　　　 　　Connection getConnection(String url,String user,String password)　　　通过连接字符串和用户名以及密码来获取数据库连接对象

　　2.getConnection方法3个连接参数说明：

　　　　连接参数 　　　　　　　　说明

　　　　user　　　　　　　　　　 登录用户名

　　　　password　　　　　　　　登录密码

　　　　url 　　　　　　　　　　　mysql URL的格式： jdbc:mysql://localhost:3306/数据库名

　　     

　　　　对URL的详细说明：

　　　　　　举例：jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8

　　　　

 　　　3、代码示例

　　 　　publi class JDBCDemo{

　　　　　　public static void main(String[] args) thows Exception{

　　　　　　　　　//1.注册驱动

　　　　　　　　　Class.forName("com.mysql.jdbc.Driver");

　　　　　　　　　//2.获取连接 url、用户名、密码

　　　　　　　　　String url = "jdbc:mysql://localhost:3306/db4";

　　　　　　　　   Connection con = DriverManager.getConnection(url, "root", "123456");

　　　　　　　　

　　　　　　　　  //com.mysql.jdbc.JDBC4Connection@2e3fc542

　　　　　　　　  System.out.println(con);　

　　　　　　}

　　　　}

---

　API 使用: 3.获取语句执行平台

　　1、通过Connection 的 createStatement方法 获取sql语句执行对象

　　　　Connection接口中的方法　　　　　　　　说明

　　　　Statement createStreamenet()　　　　　创建SQL语句执行对象　

　　2、Statement：代表一条语句对象，用于发送SQL语句给服务器，用于执行静态SQL语句并返回生成结果的对象

　　　　Statement 类的常用方法　　　　　　　　说明

　　　　int executeUpdate(String sql); 　　　　   执行insert update delete语句.返回int类型,代表受影响的行数

　　　　ResultSet executeQuery(String sql); 　　 执行select语句, 返回ResultSet结果集对象

　　　　

　　　　代码示例：　　

　　　　public  calss JDBCDemo{

　　　　　　public statci void main(String[] args) throws Exception{

　　　　　　　　//1.注册驱动

　　　　　　　　Class.forName("com.mysql.jdbc.Driver");

　　　　　　　　

　　　　　　　　//2.获取连接url、用户名、密码

　　　　　　　　String url = "jdbc:mysql://localhost:3306/db1";

　　　　　　　　Connection con = DriverManager.getConnection(url,"root","123456");

　　　　　　　　//3.获取 Statement 对象

　　　　　　　　Statement statement = con.createStatement();

　　　　　　　　//4.执行创建表操作

　　　　　　　　String sql = "create table tests01(id int, name varchar(20), age int);";

　　　　　　　　

　　　　　　　　//5.增删改操作 使用executeUpdate 增加一张表 

　　　　　　　　int  i = statement.executeUpdate(sql);

　　　　　　　　

　　　　　　　　//6.返回值是受影响的函数

　　　　　　　　System.out.println(i);

　　　　　　　　

　　　　　　　　//7.关闭流

　　　　　　　　statement.close();

　　　　　　      con.close();

　　　　　　}　　

　　　　}　　

---

　 API 使用: 4.处理结果集

　　　　- 只有在进行查询操作的时候，才会处理结果集

　　　　- ResultSet接口

　　　　　作用： 封装数据库查询的结果集，对结果集进行遍历，取出每一条记录

　　　　　ResultSet接口方法：　　　　　　说明：

　　　　   boolean next()　　　　　　　　   1) 游标向下一行

　　　　　　　　　　　　　　　　　　　　  2) 返回 boolean 类型，如果还有下一条记录，返回 true，否则返回 false

　　　　   xxx getXxx(String or int )　　　　 1) 通过列名，参数是 String 类型。返回不同的类型

　　　　　　　　　　　　　　　　　　　　　2) 通过列号，参数是整数，从 1 开始。返回不同的类型

　　　　　　　　　　　　　　　　　　　　　ps:列名和列号的理解

　　　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　 　　id、username、password、birthday都是列名 

　　　　　　　　　　　　　　　　　　　　　　 列号1对应的就是id 、列号2对应的就是username 

　　　　　　　　　　　　　　　　　　　　　　

　　　　   

　　　　 　　　　

 　　　　- 示例

　　　　public  calss JDBCDemo{

　　　　　　public statci void main(String[] args) throws Exception{

　　　　　　　　//1.注册驱动

　　　　　　　　Class.forName("com.mysql.jdbc.Driver");

　　　　　　　　//2.获取连接url、用户名、密码

　　　　　　　　String url = "jdbc:mysql://localhost:3306/db1";

　　　　　　　　Connection con = DriverManager.getConnection(url,"root","123456");

　　　　　　　　//3.获取 Statement 对象

　　　　　　　　Statement statement = con.createStatement();

　　　　　　　　//4.查询语句 

　　　　　　　　String sql = "select * from jdbc_user";

　　　　　　　   //执行查询操作,返回的是一个 ResultSet 结果对象

　　　　　　　　ResultSet resultSet = statement.executeQuery(sql);

　　　　　　　　//5.处理结果集的方式1

　　　　　　　　// next 方法判断是否还有下一条数据

　　　　　　　　boolean next = resultSet.next();

　　　　　　　　System.out.println(next);

　　　　　　　　//getXXX 方法获取数据 两种方式

　　　　　　　　int id = resultSet.getInt("id");//列名

　　　　　　　　System.out.println(id);

　　　　　　　　int anInt = resultSet.getInt(1);//列号　　

　　　　　　　　System.out.println(anInt);

　　　　　　　　//5.处理结果集的方式2

　　　　　　　　while(resultSet.next()){

　　　　　　　　　　//获取id

　　　　　　　　　　int id = resultSet.getInt("id");

　　　　　　　　　　//获取姓名

　　　　　　　　　　String username = resultSet.getString("username");

　　　　　　　　　　//获取生日

　　　　　　　　　　Date birthday = resultSet.getDate("birthday");

　　　　　　　　　　System.out.println(id + " = " +username + " : " + birthday);

　　　　　　　　}

　　　　　　　　// 关闭连接

　　　　　　　　resultSet.close();

　　　　　　　　statement.close();

　　　　　　　　con.close();

　　　　　　}　　

　　　　}　　

　　　　

---

　API 使用: 5.释放资源

　　　　- 需要释放的对象： ResultSet结果集，Statement语句，Connection连接

　　　　- 释放原则： 先开的后关，后开的先关 ResultSet ==> Statement ==> Connection

　　　　- 放在哪个代码块中：

　　　　　　finally 块 与IO流一样，使用后的东西都需要关闭！关闭的顺序是先开后关, 先得到的后关闭，后得到的先关闭

             

 　　　代码示例：　　

　　　　public  class   JDBCDemo{

　　　　　　public static void main(String[] args){

　　　　　　　　Connection connection = null;

　　　　　　　　Statement statement = null;

　　　　　　　　ResultSet resultSet = null;

　　　　　　　　

　　　　　　　　try{

　　　　　　　　　　//1.注册驱动（省略）

　　　　　　　　　　//2.获取连接

　　　　　　　　　　String  url = "jdbc:mysql://localhost:3306/db3";

　　　　　　　　　　connection = DriverManager.getConnection(url,"root","123456");　　

　　　　　　　　　　

　　　　　　　　　　//3.获取 Statement 对象

　　　　　　　　　　statement = connection.createStatemenet();　　

　　　　　　　　　　

　　　　　　　　　　String sql = "select * from jdbc_user";

　　　　　　　　　　resultSet = statement.executeQuery(sql);　　

　　　　　　　　}catch(SQLException e){

　　　　　　　　　　e.printStackTrace();

　　　　　　　　}finally{

　　　　　　　　　　/**

　　　　　　　　　　　　* 开启顺序: connection ==> statement => resultSet

　　　　　　　　　　　　* 关闭顺序: resultSet ==> statement ==> connection

　　　　　　　　　　*/

　　　　　　　　　　try {

　　　　　　　　　　　　connection.close();

　　　　　　　　　　　　resultSet.close();

　　　　　　　　　　　　statement.close();

　　　　　　　　　　} catch (SQLException e) {

　　　　　　　　　　　　e.printStackTrace();

　　　　　　　　　　}　　

　　　　　　　　}

　　　　　　}

　　　　}

---

  总结步骤：

　　1.获取驱动（可以省略）

　   2.获取数据库连接对象 Connection 

　　3.获取数据库语句执行对象 Statement

　　4.处理结果集（只在查询时处理）ResultSet

　　5.释放资源 先开后关原则

---

二、JDBC 通过JDBC工具类实现增删该查

　　-什么时候需要创建工具类

 　　  如果一个功能需要经常用到，我们坚毅吧这个功能做成一个工具类，可以在不同的地方重用

　　- 插入记录遇到中文乱码问题：

　　　jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8

　　　characterEncoding=UTF-8 指定字符的编码、解码格式。

　　

/*
    JDBC工具类
 */
public class JDBCUtil {

    //1. 将连接信息定义为 字符串常量
    public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8";
    public static final String USER = "root";
    public static final String PASSWORD = "root";

    //2.静态代码块
    static {
        try {
            //1.注册驱动
            Class.forName(DRIVERNAME);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }


    //3.获取连接的静态方法
    public static Connection getConnection(){
        //获取连接对象 并返回
        try {
            Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
            return  connection;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            return null;
        }
    }

    //4.关闭资源的方法
    public static void close(Connection con, Statement statement) throws Exception {
        if(statement != null){
            statement.close();
        }
        
        if(con != null){
            con.close();
        }
    }

    public static void close(Connection con, Statement statement, ResultSet resultSet)throws Exception{
        if(resultSet != null){
            try {
                resultSet.close();
               
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        con.close();

    }

}

　　案例：

　public class TestDML {

    /**
     * 添加数据
     */
    @Test
    public void  testInsert() throws Exception {
        //1.通过JDBCUtils工具类获取连接
        Connection connection = JDBCUtil.getConnection();

        //2. 获取Statement对象
        Statement statement = connection.createStatement();

        //2.1 编写SQL
        String  sql = "insert into jdbc_user values(null,'铁柱','123','2020/11/11')";

        //2.2 执行sql
        int i = statement.executeUpdate(sql);
        System.out.println(i);

        //3.关闭流
        JDBCUtil.close(connection,statement);
    }

    /**
     * 更新操作 根据ID修改用户名
     */
    @Test
    public void testUpdate() throws  Exception{
        Connection connection = JDBCUtil.getConnection();

        Statement statement = connection.createStatement();

        String sql = "update jdbc_user set username = '二丫' where id = 1";

        int i = statement.executeUpdate(sql);
        System.out.println(i);

        JDBCUtil.close(connection,statement);

    }


    /**
     * 删除操作  根据名字删除
     */
    @Test
    public void testDelete() throws Exception{
        Connection connection = JDBCUtil.getConnection();
        Statement statement = connection.createStatement();
        String sql = "delete from jdbc_user where username in('admin2','test1','test2')";
        statement.executeUpdate(sql);
        JDBCUtil.close(connection,statement);
    }
}　　

　　

public class TestDQL {

    @Test
    public static void main(String[] args) throws Exception{
        //1.获取连接对象
        Connection connection = JDBCUtil.getConnection();

        //2.获取Statement对象
        Statement statement = connection.createStatement();

        //3.编写SQL
        String sql = "SELECT * FROM jdbc_user WHERE username = '二丫';";
        ResultSet resultSet = statement.executeQuery(sql);

        //4.处理结果集
        while(resultSet.next()){
            //通过列名 获取字段信息
            int id = resultSet.getInt("id");
            String username = resultSet.getString("username");
            String password = resultSet.getString("password");
            String birthday = resultSet.getString("birthday");
            System.out.println(id+" "+username+" " + password +" " + birthday);
        }
        //4.释放资源
            JDBCUtil.close(connection,statement,resultSet);
        }
}

---

三、SQL注入问题

　　- SQL注入案例：用户登陆

　　

public class TestLogin01 {
    /**
     * 用户登录案例
     * 使用 Statement字符串拼接的方式完成查询
     * @param args
     */

    public static  void main(String[] args) throws Exception{
        //1.获取连接
        Connection connection = JDBCUtil.getConnection();

        //2.获取Statement
        Statement statement = connection.createStatement();

        //3.获取用户输入的用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名： ");
        String name = sc.nextLine();

        System.out.println("请输入密码： ");
        String pass = sc.nextLine();
        System.out.println(pass);

        //4.拼接SQL执行查询
        String sql = "select * from jdbc_user " +
                     "where username = " + " '" + name +"'" + " and password = " + " '" + pass + "'";

        System.out.println(sql);
        ResultSet resultSet = statement.executeQuery(sql);

        //5.处理结果集,判断结果集是否为空
        if(resultSet.next()){
            System.out.println("登录成功! 欢迎您: " + name);
        }else {
            System.out.println("登录失败!");
        }
        //释放资源
        JDBCUtil.close(connection,statement,resultSet);

    }
}

　　

　　1、什么是SQL注入？

　　　　我们让用户输入的密码和 SQL 语句进行字符串拼接。用户输入的内容作为了 SQL 语句语法的一部分，

　　　　改变了 原有 SQL 真正的意义，以上问题称为 SQL 注入 

　　　　上面案例中当填写密码为：123' or '1'=’1 就会形成sql注入

　　　　拼接之后的语句：

　　　　select * from jdbc_user where username = 'abc' and password = 'abc' or '1'='1'

　　　　　　　　username='abc' and password='abc' 为假 '1'='1' 真

　　　　　　　　相当于 select * from user where true=true; 查询了所有记录

　　　　要解决SQL注入就是不能让用户输入的密码和我们的SQL语句进行 简单的字符串拼接

---

四、预处理对象

　　1、PreparedStatement 接口的介绍

　　　 PreparedStatement 是 Statement 接口的子接口，继承于父接口种所有的方法，它是一个预编译的SQL语句对象

　　　 预编译是指SQL语句被预编译，并存储在PerparedStatement对象种，然后可以使用此对象多次高效的执行该语句

　　2、PreparedStatement 接口的特点

　　　  因为有预先编译的功能，提高 SQL 的执行效率。

　　　  可以有效的防止 SQL 注入的问题，安全性更高

　　3、获取PerparedStatement对象 

　　　　通过Connection创建PreparedStatement对象

　　　　Connection接口中的方法　　　　　　　　　　　　　说明

　　　　PreparedStatement prepareStatement(String sql) 　指定预编译的 SQL 语句，SQL 语句中使用占位符 ? 创建一个语句对象

　　4、PreparedStatement接口常用方法

　　　　常用方法　　　　　　　　　　  说明

　　　　int executeUpdate(); 　　　　  执行insert update delete语句.

　　　　ResultSet executeQuery(); 　　执行select语句. 返回结果集对象 Resulet

　　5、使用PreparedStatement的步骤

　　　　1) 编写 SQL 语句，未知内容使用?占位：

　　　　　"SELECT * FROM jdbc_user WHERE username=? AND password=?";　

　　　　2) 获得 PreparedStatement 对象

　　　　3) 设置实际参数：setXxx( 占位符的位置, 真实的值)

　　　　4) 执行参数化 SQL 语句

　　　　5) 关闭资源

　　　　

  使用 PreparedStatement 预处理对象,可以有效的避免SQL注入 案例：

public class TestLogin02 {

    /**
     * 使用预编译对象 PrepareStatement 完成登录案例
     * @param args
     * @throws SQLException
     */
   public static void main(String[] args) throws Exception {
       //1.获取连接
       Connection connection = JDBCUtil.getConnection();

       //2.获取Statement
       Statement statement = connection.createStatement();

       //3.获取用户输入的用户名和密码
       Scanner sc = new Scanner(System.in);
       System.out.println("请输入用户名： ");
       String name = sc.nextLine();

       System.out.println("请输入密码： ");
       String pass = sc.nextLine();
       System.out.println(pass);

       //4.获取 PrepareStatement 预编译对象
       //4.1 编写SQL 使用 ？占位符方式
       String sql = "select * from jdbc_user where username = ? and password = ?";
       PreparedStatement ps = connection.prepareStatement(sql);

       //4.2 设置占位符参数
       ps.setString(1,name);
       ps.setString(2,pass);

       //5. 执行查询 处理结果集
       ResultSet resultSet = ps.executeQuery();

       if(resultSet.next()){
           System.out.println("登录成功! 欢迎您: " + name);
       }else{
           System.out.println("登录失败!");
       }

       //6.释放资源
       JDBCUtil.close(connection,statement,resultSet);

   }
}

　　

　　分别使用 Statement对象 和 PreparedStatement对象进行插入操作:

　　

public class TestPs {

    public static void main(String[] args) throws  Exception{

        Connection con = JDBCUtil.getConnection();
        //获取 Sql语句执行对象
        Statement st = con.createStatement();

        //插入两条数据
        st.executeUpdate("insert into jdbc_user values(null,'张三','123','1992/12/26')");
        st.executeUpdate("insert into jdbc_user values(null,'李四','123','1992/12/26')");

        //获取预处理对象
        PreparedStatement ps = con.prepareStatement("insert into jdbc_user values(?,?,?,?)");

        //第一条数 设置占位符对应的参数
        ps.setString(1,null);
        ps.setString(2,"长海");
        ps.setString(3,"qwer");
        ps.setString(4,"1990/1/10");

        //执行插入
        ps.executeUpdate();

        //第二条数据
        ps.setString(1,null);
        ps.setString(2,"小斌");
        ps.setString(3,"1122");
        ps.setString(4,"1990/1/10");

        //执行插入
        ps.executeUpdate();

        //释放资源
        st.close();
        ps.close();
        con.close();
    }
}

　　 分析：

　　　　

 　　6、 Statement 与 PreparedStatement的区别?

　　　　1、Statement 用于执行静态的SQL语句，在执行时，必须指定一个事先准备好的SQL语句

　　　　2、PrepareStatement是预编译的SQL语句对象，语句中可以包含动态参数“?”，在执行时可以为“?”动态设置参数 值。

　　　　3、PrepareStatement可以减少编译次数提高数据库性能。

---

五、JDBC 控制事务

　　1、数据准备

　　　　-- 创建账户表

　　　　CREATE TABLE account(

　　　　　　-- 主键

　　　　　　id INT PRIMARY KEY AUTO_INCREMENT,

　　　　　　-- 姓名

　　　　　　NAME VARCHAR(10),

　　　　　　-- 转账金额

　　　　　　money DOUBLE

　　　　);

　　　　-- 添加两个用户

　　　　INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);

　　2、事务相关API

　　

  

　　3、开发步骤

　　　　1. 获取连接

　　　　2. 开启事务

　　　　3. 获取到 PreparedStatement , 执行两次更新操作

　　　　4. 正常情况下提交事务

　　　　5. 出现异常回滚事务

　　　　6. 最后关闭资源 

　　　　

　　4、代码示例

1、　　　　

　　-- 创建账户表
　　CREATE TABLE account(
　　　　-- 主键
　　　　id INT PRIMARY KEY AUTO_INCREMENT,
　　　　-- 姓名
　　　　name VARCHAR(10),
　　　　-- 转账金额
　　　　money DOUBLE
　　);

　　-- 添加两个用户

　　INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);

2、开发步骤

　　1.获取连接

　　2.开启事务

　　3.获取到 PerparedStatement, 执行两次更新操作

　　4.正常情况下提交事务

　　5.出现异常回滚事务

　　6.最后关闭资源

　

3、案例

public class JDBCTransaction {

    //JDBC 操作事务
    public static void main(String[] args) throws Exception {
        //1.数据库连接驱动对象 connection
        Connection connection = null;

        //2.SQL预处理对象 preparedStatement
        PreparedStatement preparedStatement = null;

        try{
            //1.获取连接
            connection = JDBCUtil.getConnection();

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

            //3.获取到preparedStatement 执行两次更新操作
            //3.1 tom 账户 -500
            preparedStatement = connection.prepareStatement("update account set money = money - ? where name = ? ");
            preparedStatement.setDouble(1,500.0);
            preparedStatement.setString(2,"tom");
            preparedStatement.executeUpdate();

            //模拟tom转账后 出现异常
            System.out.println(1/0);

            //3.2 jack账户 + 500
            preparedStatement = connection.prepareStatement("update account set money = money + ? where name = ?");
            preparedStatement.setDouble(1,500.0);
            preparedStatement.setString(2,"jack");
            preparedStatement.executeUpdate();

            //4.正常情况下提交事务
            connection.commit();
            System.out.println("转账成功！");

        }catch (Exception e){
            e.printStackTrace();
            try {
                //5.出现异常回滚事务
                connection.rollback();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }finally {
            //6.最后关闭资源
            JDBCUtil.close(connection,preparedStatement);
        }
    }
}

　　本章详情