一、JDBC基本概念

（1）什么是JDBC?

Java Data Base Connectivity) 是 Java 访问数据库的标准规范.是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范.

（2）JDBC原理

JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供。
JDBC概述.png
总结：
JDBC就是由sun公司定义的一套操作所有关系型数据库的规则(接口)，而数据库厂商需要实现这套接口,提供数据库驱动jar包, 我们可以使用这套接口编程,真正执行的代码是对应驱动包中的实现类。

（3）开发准备

（1）创建一个数据库表，并插入数据

-- 创建 jdbc_user表 
CREATE TABLE jdbc_user 
( 
  id INT PRIMARY KEY AUTO_INCREMENT ,
  username VARCHAR(50), 
  PASSWORD VARCHAR(50),
  birthday DATE );
-- 添加数据 
INSERT INTO jdbc_user (username, PASSWORD,birthday) VALUES
('admin1', '123','1991/12/24'), 
('admin2','123','1995/12/24'), 
('test1', '123','1998/12/24'), 
('test2', '123','2000/12/24');

（2）在IDEA中导入包，先创建一个jar库使用

选择存放了jarB包的文件

最后在提示中选择你要把库放在的位置（项目）

二、代码实现JDBC操作

（1）注册驱动

//1,注册驱动，加载驱动程序 ,通过Class的静态方法，注册mysql驱动(JDBC3开始可以省略)
        Class.forName("com.mysql.jdbc.Driver");

所以我们导入包后，通过Class的静态方法就实现了驱动的注册。

/*
原理：
JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需 
要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供
*/

（2）获取连接和创建sqL语句执行平台

2.1连接的获取

Connection 接口，代表一个连接对象 ,具体的实现类由数据库的厂商实现
使用 DriverManager类的静态方法,getConnection可以获取数据库的连接

2.2url详解

2.3资源的关闭

1) 需要释放的对象：ResultSet 结果集，Statement 语句，Connection 连接
2) 释放原则：先开的后关，后开的先关。ResultSet ==> Statement ==> Connection
3) 放在哪个代码块中：finally 块
与IO流一样，使用后的东西都需要关闭！关闭的顺序是先开后关, 先得到的后关闭，后得到的先关闭
释放资源.jpg

2.3代码实现

package JDBCTest;

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

public class InsertTest {
    public static void main(String[] args) throws Exception {
        //1,注册驱动，加载驱动程序 ,通过Class的静态方法，注册mysql驱动
        Class.forName("com.mysql.jdbc.Driver");

        //2，获取连接Connection对象
        String url="jdbc:mysql://localhost:3306/db_neu?characterEncoding=utf-8";
        Connection con = DriverManager.getConnection(url, "root", "root");

        //打印连接对象，测试由谁提供  com.mysql.jdbc.JDBC4Connection@4b9af9a9
        System.out.println(con);

        //3，获取语句执行平台对象 Statement
        Statement stt = con.createStatement();
        //3.1通过executeUpdate()方法,创建一张表
        String sql="INSERT INTO jdbc_user(id,username,PASSWORD,birthday) VALUES (6,'test4','456','199-02-03')";
        int rows= stt.executeUpdate(sql);
        if (rows>0){
            System.out.println("插入成功！");

        }
        //关闭流  先开后关
        stt.close();
        con.close();
    }

}

(3)JDBC最简单的基本实现

步骤分析：
（1）先导入包
（2）使用Class的静态方法，加载驱动，jdbc3开始可以不用加载驱动
（3）创建连接，实现类是DriverManager,方法是getConnection()方法
（4）创建执行sqL语句的平台，创建Statement对象
（5）使用平台执行语句
（6）关闭语句

简略：
步骤总结
1. 获取驱动(可以省略)
2. 获取连接
3. 获取Statement对象
4. 处理结果集(只在查询时处理)
5. 释放资源

区分执行语句：
更新操作一般return函数
查询操作返回ResultSet

package JDBCTest;

import Task13.User;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.sql.*;


public class InsertTest {
    public static void main(String[] args)  {
        InsertTest i1=new InsertTest();
        //i1.insert();
        //i1.select();
        i1.delete();
    }

    //添加数据的基本方法实现
public  void insert(){

    Connection con=null;
    Statement stt=null;
    try {
        //1,注册驱动，加载驱动程序 ,通过Class的静态方法，注册mysql驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2，获取连接Connection对象
        String url="jdbc:mysql://localhost:3306/db_neu?characterEncoding=utf-8";
         con = DriverManager.getConnection(url, "root", "root");

        //打印连接对象，测试由谁提供  com.mysql.jdbc.JDBC4Connection@4b9af9a9
        System.out.println(con);

        //3，获取语句执行平台对象 Statement
        stt = con.createStatement();
        //3.1通过executeUpdate()方法,创建一张表
        String sql="INSERT INTO jdbc_user(id,username,PASSWORD,birthday) VALUES (6,'test4','456','199-02-03')";
        int rows= stt.executeUpdate(sql);
        if (rows>0){
            System.out.println("插入成功！");

        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        /*** 
        开启顺序: 
        connection ==> statement => resultSet * 
        关闭顺序:
        resultSet ==> statement ==> connection */
        //关闭流  先开后关
        try {
            if (stt!=null){
            stt.close();}
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        try {
            if (null!=con){
            con.close();}
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}
//--------------------------------------------------->
    //查询方法
public  void select(){

        Connection conn=null;
        Statement stt =null;
        ResultSet resultSet =null;
        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //建立连接
            String url="jdbc:mysql://localhost:3306/db_neu?characterEncoding=utf-8";
            conn = DriverManager.getConnection(url, "root", "root");
            //创建执行语句的平台
            String sql="select * from jdbc_user where id=2 ";
            stt=conn.createStatement();
            resultSet= stt.executeQuery(sql);
            while (resultSet.next()){
//                int id=resultSet.getInt(1);
//                System.out.println(id);
//                String  name=resultSet.getString(2);
//                System.out.println(name);
                Integer id=resultSet.getInt("id");
                String name=resultSet.getString("username");
                String PASSWORD=resultSet.getString("PASSWORD");
                String birthday=resultSet.getString("birthday");
                user u1=new user(id,name,PASSWORD,birthday);
                System.out.println(u1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭连接
            try {
                resultSet.close();
                stt.close();
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }

        }
    }
//----------------------------------->
//删除方法
    public  void delete(){
        Connection conn =null;
        Statement stt =null;
        try {
            //1,加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2,创建连接对象
            String url="jdbc:mysql://localhost:3306/db_neu?characterEnconding";
            conn = DriverManager.getConnection(url, "root", "root");
            //3,创建执行语句的平台
            stt = conn.createStatement();
            //4，执行语句
            //删除语句
            String sql="delete from jdbc_user where id=5 ";
            //执行
            int i = stt.executeUpdate(sql);
            if (i>0){
                System.out.println("删除成功!");

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

            //5，关闭流
            try {
                stt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    }
}

三、封装JDBCUtil（工具类）

1、配置数据库信息文件

driverClassname=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db_neu?characterEnconding=utf-8
user=root
password=root

2、创建DButils类

package JDBCTest;

//JDBC工具类
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class DButils {
    //设置共用属性，只需要使用一次，并且随着DButils类的加载就加载完成
    public  static  String url2;
    public  static  String user2;
    public  static  String password2;
    //获取属性文件的数据
    static {
        //1，使用Properties工具类加载数据
        Properties properties=new Properties();
        //2，获取文件数据
        InputStream ins = DButils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        try {
            //3，加载数据
            properties.load(ins);
            //4-1，以下几步为获取数据
            String driverClassName=properties.getProperty("driverClassname");
            //加载驱动程序
            Class.forName(driverClassName);
            //4-2获取url、user、password属性
            DButils.url2=properties.getProperty("url");
            DButils.user2=properties.getProperty("user");
            DButils.password2=properties.getProperty("password");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取连接的方法，创建连接
    public static Connection connection(){
        Connection conn=null;
        try {
            conn = DriverManager.getConnection(url2,user2,password2);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return  conn;
    }


    //关闭的方法
    public static void close(Connection conn, Statement stt){
        try {
            if (null!=stt){
            stt.close();
            }
            if (null!=conn){
            conn.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    //关闭方法----重载
    public  static void close(Connection conn, Statement stt, ResultSet rs){
        try {
            if (null!=rs){
                rs.close();
            }
            if (null!=stt){
                stt.close();
            }
            if (null!=conn){
                conn.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

}

3、测试类

对比以前连接数据，接下来连接数据库和关闭数据库由DBUtils类中的方法完成(看insert部分)

package JDBCTest;

import Task13.User;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.sql.*;


public class InsertTest {
    public static void main(String[] args)  {
        InsertTest i1=new InsertTest();
        i1.insert();
        //i1.select();
       // i1.delete();
    }

    //添加数据的基本方法实现
public  void insert(){

    Connection con=null;
    Statement stt=null;
    try {

        /*//1,注册驱动，加载驱动程序 ,通过Class的静态方法，注册mysql驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2，获取连接Connection对象
        String url="jdbc:mysql://localhost:3306/db_neu?characterEncoding=utf-8";
         con = DriverManager.getConnection(url, "root", "root");
        //打印连接对象，测试由谁提供  com.mysql.jdbc.JDBC4Connection@4b9af9a9
        System.out.println(con);
        //3，获取语句执行平台对象 Statement
        stt = con.createStatement();*/

        con= DButils.connection();
        stt = con.createStatement();
        //3.1通过executeUpdate()方法,创建一张表
        String sql="INSERT INTO jdbc_user(id,username,PASSWORD,birthday) VALUES (7,'test4','456','199-02-03')";
        int rows= stt.executeUpdate(sql);
        if (rows>0){
            System.out.println("插入成功！");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally {

       /* //关闭流  先开后关
        try {
            if (stt!=null){
            stt.close();}
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        try {
            if (null!=con){
            con.close();}*/

        DButils.close(con,stt);
        }
    }



//--------------------------------------------------->
    //查询方法
public  void select(){

        Connection conn=null;
        Statement stt =null;
        ResultSet resultSet =null;
        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //建立连接
            String url="jdbc:mysql://localhost:3306/db_neu?characterEncoding=utf-8";
            conn = DriverManager.getConnection(url, "root", "root");
            //创建执行语句的平台
            String sql="select * from jdbc_user where id=2 ";
            stt=conn.createStatement();
            resultSet= stt.executeQuery(sql);
            while (resultSet.next()){
//                int id=resultSet.getInt(1);
//                System.out.println(id);
//                String  name=resultSet.getString(2);
//                System.out.println(name);
                Integer id=resultSet.getInt("id");
                String name=resultSet.getString("username");
                String PASSWORD=resultSet.getString("PASSWORD");
                String birthday=resultSet.getString("birthday");
                user u1=new user(id,name,PASSWORD,birthday);
                System.out.println(u1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭连接
            try {
                resultSet.close();
                stt.close();
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }

        }
    }
//----------------------------------->
//删除方法
    public  void delete(){
        Connection conn =null;
        Statement stt =null;
        try {
            //1,加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2,创建连接对象
            String url="jdbc:mysql://localhost:3306/db_neu?characterEnconding";
             conn = DriverManager.getConnection(url, "root", "root");
            //3,创建执行语句的平台
            stt = conn.createStatement();
            //4，执行语句
            //删除语句
            String sql="delete from jdbc_user where id=5 ";
            //执行
            int i = stt.executeUpdate(sql);
            if (i>0){
                System.out.println("删除成功!");

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

            //5，关闭流
            try {
                stt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    }
}

四、sql注入

（1）sql注入的概念

SQL注入即是指web应用程序对用户输入数据的合法性没有判断或过滤不严，攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句，在管理员不知情的情况下实现非法操作，以此来实现欺骗数据库服务器执行非授权的任意查询，从而进一步得到相应的数据信息。
（我们让用户输入的密码和 SQL 语句进行字符串拼接。用户输入的内容作为了 SQL 语句语法的一部分，改变了原有SQL 真正的意义）

# SQL注入演示 -- 填写一个错误的密码
SELECT * FROM 
jdbc_user
WHERE username = 'tom' AND PASSWORD = '123' OR '1' = '1';

如果这是一个登陆操作，那用户就登陆成功了，那就非法输入从而进入系统，获取系统地数据了。

（2）用户登录案例

package JDBCTest;
//用户登录案例
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

public class LoginTest {
    public static void main(String[] args) {
        try {
            //获取连接
            Connection conn = DButils.connection();
            //创建执行sql的平台
            Statement stt = conn.createStatement();

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

            //写sql语句
            String sql="select * from jdbc_user where username="
                    +"'"+s+"'"+" and password="+"'"+pass+"'"+"or 1=1";
            ResultSet resultSet = stt.executeQuery(sql);
            if(resultSet.next()){
                System.out.println("登录成功！");
            }
            else {
                System.out.println("登录失败!");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

    }
}

对字符串进行非法拼接，就登陆成功，就非法获取数据。
主要的原因：
使用的是拼接的sqL语句！！！

五、使用预处理对象解决防范sqL注入

（1） PreparedStatement 接口介绍

PreparedStatement 是 Statement 接口的子接口，继承于父接口中所有的方法。它是一个预编译的 SQL 语句对象.
预编译: 是指SQL 语句被预编译,并存储在 PreparedStatement 对象中。然后可以使用此对象多次高效地执行该语句。

（2）PreparedStatement 特点
因为有预先编译的功能，提高 SQL 的执行效率。
可以有效的防止 SQL 注入的问题，安全性更高
（3）获取PreparedStatement对象
通过Connection创建PreparedStatement对象

（4） PreparedStatement接口常用方法
```java package com.lagou.jdbc03;

import com.lagou.utils.JDBCUtils;

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

public class TestLogin02 {

/*
* SQL注入
*   用户输入的用户名和密码 与我们编写的SQL进行了拼接,用户输入的内容成为了SQL语法的一部分,
*   用户会利用这里漏洞 输入一些其他的字符串,改变SQL原有的意思
*
* 如果解决
*   要解决SQL注入 就不能让用户输入的数据和我们的SQL进行直接的拼接
*
* 预处理对象 PrepareStatement 他是 Statement接口的子接口
*   使用预处理对象 他有预编译的功能,提高SQL的执行效率
*   使用预处理对象 通过占位符的方式 设置参数 可以有效的防止SQL注入
*
*
* */
public static void main(String[] args) throws SQLException {

    //1.获取连接
    Connection con = JDBCUtils.getConnection();

    //2.获取PrepareStatement 预处理对象
    //使用 ? 占位符的方式来设置参数
    String sql = "select * from jdbc_user where username = ? and password = ?";
    PreparedStatement ps = con.prepareStatement(sql);

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

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

    //4.设置参数 使用setXXX(占位符的位置(整数),要设置的值)的方法设置占位符的参数
    ps.setString(1,name); // 设置第一个问号值 为 name
    ps.setString(2,pass);

    //5.执行查询
    ResultSet resultSet = ps.executeQuery();

    //6.处理结果集
    //6.处理结果集
    if(resultSet.next()){

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

        System.out.println("登录失败! ");
    }

    //7.关闭流
    JDBCUtils.close(con,ps,resultSet);
}

}

<a name="Q4GpD"></a>
## (5) PreparedStatement的执行原理
5.1先上代码~
```java
package com.lagou.jdbc03;

import com.lagou.utils.JDBCUtils;

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

public class TestPS {

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

        Connection connection = JDBCUtils.getConnection();

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

        //向数据库插入两条数据
        statement.executeUpdate("insert into jdbc_user values(null,'张三','123456','2000/12/26')");
        statement.executeUpdate("insert into jdbc_user values(null,'李四','654321','1900/12/26')");

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

        //先插入第一条数据
        ps.setObject(1,null);
        ps.setString(2,"小斌");
        ps.setString(3,"qwer");
        ps.setString(4,"1999/11/11");
        //执行插入
        ps.executeUpdate();

        //插入第二条数据
        ps.setObject(1,null);
        ps.setString(2,"长海");
        ps.setString(3,"asdf");
        ps.setString(4,"2000/11/11");
        //执行插入
        ps.executeUpdate();

        //释放资源
        statement.close();
        ps.close();
        connection.close();
    }

}

预处理对象执行原理.jpg
？占位符的方式，传入的参数就不再当成是sql语句的一部分了。

（6）Statement 与 PreparedStatement的区别?

Statement用于执行静态SQL语句，在执行时，必须指定一个事先准备好的SQL语句
2. PrepareStatement是预编译的SQL语句对象，语句中可以包含动态参数“?”，在执行时可以为 “?”动态设置参数值。
3. PrepareStatement可以减少编译次数提高数据库性能。
六、JDBC控制事务
（1） JDBC 控制事务
之前我们是使用 MySQL 的命令来操作事务。接下来我们使用 JDBC 来操作银行转账的事务
（2）数据准备
```
-- 创建账户表 CREATE 
TABLE account
( -- 主键 id INT PRIMARY KEY AUTO_INCREMENT,
-- 姓名 NAME VARCHAR(10),
-- 转账金额 money DOUBLE );
-- 添加两个用户
INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);
```
(3)事务相关API
我们使用 Connection中的方法实现事务管理

(4)开发步骤
获取连接
2. 开启事务
3. 获取到 PreparedStatement , 执行两次更新操作
4. 正常情况下提交事务
5. 出现异常回滚事务
6. 最后关闭资源 ```java package com.lagou.jdbc04;

import com.lagou.utils.JDBCUtils;

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

public class TestJDBCTransaction {

//使用JDBC操作事务
public static void main(String[] args) {

    Connection con = null;
    PreparedStatement ps = null;

    try {
        //1.获取连接
        con = JDBCUtils.getConnection();

        //2.开启事务
        con.setAutoCommit(false);  //手动提交事务

        //3.获取预处理对象 执行SQL (两次修改操作)
        //3.1 tom账户 - 500
        ps = con.prepareStatement("update account set money = money - ? where name = ?");
        ps.setDouble(1,500.0);
        ps.setString(2,"tom");
        ps.executeUpdate();

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

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

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

    } catch (SQLException e) {
        e.printStackTrace();
        //5.出现异常就回滚事务
        try {
            con.rollback();
        } catch (SQLException ex) {
            ex.printStackTrace();
        }

    } finally {
        //6.释放资源
        JDBCUtils.close(con,ps);
    }

}

}

``` 如果在事务中间出现异常，则进行回滚操作！
这样数据库就不会再被更改！

2-Mysql数据库

#JDBC

一、JDBC基本概念

（1）什么是JDBC?

（2）JDBC原理

（3）开发准备

二、代码实现JDBC操作

（1）注册驱动

（2）获取连接和创建sqL语句执行平台

2.1连接的获取

2.2url详解

2.3资源的关闭

2.3代码实现

(3)JDBC最简单的基本实现

三、封装JDBCUtil（工具类）

1、配置数据库信息文件

2、创建DButils类

3、测试类

四、sql注入

（1）sql注入的概念

（2）用户登录案例

五、使用预处理对象解决防范sqL注入

（1） PreparedStatement 接口介绍

（2）PreparedStatement 特点

（3）获取PreparedStatement对象

（4） PreparedStatement接口常用方法

（6）Statement 与 PreparedStatement的区别?

六、JDBC控制事务

（1） JDBC 控制事务

（2）数据准备

(3)事务相关API

(4)开发步骤

#JDBC

一、JDBC基本概念

（1）什么是JDBC?

（2）JDBC原理

（3）开发准备

二、代码实现JDBC操作

（1）注册驱动

（2）获取连接和创建sqL语句执行平台

2.1连接的获取

2.2url详解

2.3资源的关闭

2.3代码实现

(3)JDBC最简单的基本实现

三、封装JDBCUtil（工具类）

1、配置数据库信息文件

2、创建DButils类

3、测试类

四、sql注入

（1）sql注入的概念

（2）用户登录案例

五、使用预处理对象解决防范sqL注入

（1） PreparedStatement 接口介绍

（2）PreparedStatement 特点

（3） 获取PreparedStatement对象

（4） PreparedStatement接口常用方法

（6）Statement 与 PreparedStatement的区别?

六、JDBC控制事务

（1） JDBC 控制事务

（2）数据准备

(3)事务相关API

(4)开发步骤

（3）获取PreparedStatement对象