超详细的JDBC总结

淡淡的烟草味﹌ 2023-07-13 15:04 68阅读 0赞

### 文章目录 ###

*  一 、JDBC概述
 *   *  1.1JDBC的理解
     *  1.2使用JDBC操作数据库的步骤
 *  二 、 获取数据库连接
 *   *  2.1Driver 接口
     *   *   *  2.2DriverManager 接口
             *   *  Connection 的常用方法:
         *  2.3连接mysql数据库
         *  2.4使用配置文件
 *  三 、操作数据库
 *   *   *   *  ①Statement接口
             *  ②PreparedStatement 接口
         *  3.4PreparedStatement 对比 Statement
         *   *  Java与SQL对应数据类型转换表
         *  3.5使用PreparedStatement实现通用的增、删、改操作,针对不同表
         *  3.6 ResultSet
         *   *  3.7ResultSetMetaData
         *  3.8资源的释放
         *  3.9 JDBC API小结
         *  3.10使用PreparedStatement实现通用表的查询操作
         *   *  ③CallableStatement接口
 *  四 、JDBCUtils
 *  五 、操作BLOB类型字段数据
 *   *  4.1 MySQL BLOB类型
     *   *  4.2 向数据表中插入大数据类型
     *  4.3修改数据表中的Blob类型字段
     *   *  4.4 从数据表中读取大数据类型
 *  六、批量插入
 *   *   *  6.1批量执行sql语句
         *  6.2批量插入数据
         *   *  方式一:
             *  方式二:
             *  方式三:
             *  方式四:
 *  七、JDBC事务处理
 *   *   *  7.1数据库事务介绍
         *  7.2事务的性质(ACDI)
         *  7.3JDBC事务
         *  7.4更新JDBCUtils的update方法
 *  八、未完待续

# 一 、JDBC概述 #

## 1.1JDBC的理解 ##

**JDBC简介**:JDBC是java数据库连接技术的简称,提供各种常用数据库的能力。全称是 Java Database Connectivity,它是一种可用于执行sql语句的 Java API(Application Programming Interface , 应用程序设计接口)。

**JDBC本质**：是sun公司定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5NzAzOQ_size_16_color_FFFFFF_t_70]  
**好处:**

从开发程序员的角度：不需要关注具体的数据库的细节句。

数据库厂商：只需要提供标准的具体实现。

**JDBC并不能直接访问数据库,必须依赖数据库厂商提供的JDBC驱动程序**

我们需要导入驱动jar包 mysql-connector-java-5.1.37-bin.jar

1. 在Java工程中新建一个lib文件夹，复制mysql-connector-java-5.1.37-bin.jar到项目的lib目录下

2.右键–>Add As Library  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5NzAzOQ_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][20200317143123577.png]

**注册驱动后会有三角符号标识**

## 1.2使用JDBC操作数据库的步骤 ##

![img][]

①加载驱动程序 —Class.forName(“com.mysql.jdbc.Driver”);

② 获取数据库连接对象 --DriverManager类 Connection接口

③获取执行语句对象 --Statement接口 --PreparedStatement接口 --CallableSt atement接口

④执行sql语句,有结果返回处理结果 --ResultsSet接口

⑤关闭连接 ,释放资源–conn.close() stmt.close()

# 二 、 获取数据库连接 #

## 2.1Driver 接口 ##

由数据库厂家提供,在编程中要连接数据库,必须先封装特定厂商的驱动程序,不同的数据库有不同的装载方法。

在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。

#### 2.2DriverManager 接口 ####

DriverManager 是JDBC的管理层,作用于用户和驱动程序之间,DriverManager 跟踪可用的驱动程序,并在数据库和相应的驱动程序之间建立连接。

1.  注册驱动：加载哪一个数据库驱动jar包
    
    第一个基本信息 com.mysql.jdbc.Driver
    
        Class.forName("com.mysql.jdbc.Driver");
    
    查看源码发现,在com.mysql.jdbc.Driver类中存在静态代码块中,存在静态代码块:
    
        static { 
                try { 
                    java.sql.DriverManager.registerDriver(new Driver());
                } catch (SQLException E) { 
                    throw new RuntimeException("Can't register driver!");
                }
            }
    
    所以可以省略注册驱动的步骤。
2.  获取数据库连接
    
    static Connection getConnection(String url, String user, String password)
    
    使用getConnection方法可以建立数据库的连接getConnection,需要传三个参数
3.  **url**：指定连接的路径
    
     *  语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数=值&参数=值
     *  例子：jdbc:mysql://localhost:3306/db1? ***useUnicode=true&characterEncoding=utf-8*** (如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集)
     *  如果连接的是本机mysql服务器，mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
4.  **user**：用户名
5.  **password**：密码

`我们连接数据库的四个基本信息是 com.mysql.jdbc.Driver, url, user, password`

##### Connection 的常用方法: #####

createStatement()    //创建Statement对象
    PreparedStatement()   //创建预处理对象 PreparedStatement
    preparedCall(String sql)  //创建一个CallableStatement 对象来调用数据库存储过程
    commit()   //是所有上一次提交/回滚后进行的更改为持久更改,并释放此Connection对象当前持有的所有数据库锁
    roolback()  //取消在当前事务中的所有更改,并释放此Connection对象当前持有的所有数据库锁
    close()   //立即释放此Connection对象的数据库和JDBC资源,而不是等待他们自动释放

### 2.3连接mysql数据库 ###

package com.hanker.demo9;
    //注意:导入的包是 java.sql下的包
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    public class Test { 
        public static void main(String[] args) { 
            	Connection conn = 	null;
            try { 
                //1.加载驱动类
                Class.forName("com.mysql.jdbc.Driver");
                long start = System.currentTimeMillis(); //记录开始时间
                //2.获取数据库连接对象,建立连接
               conn =	DriverManager.getConnection("jdbc:mysql://localhost:3306/db1","root","1111");  
                long end = System.currentTimeMillis();//记录结束时间
                System.out.println("建立连接,用时"+(end-start));
                System.out.println(conn);
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }catch (SQLException e) { 
                e.printStackTrace();
            }finally{ 
                //关闭连接
                conn.close();
            }
        }
    }

上面的代码可以获取连接,但是耦合性差,如果要修改基本信息,还需要重新打包程序

### 2.4使用配置文件 ###

我们可以将数据库连接的4个基本信息申明在配置文件中,通过读取配置文件的方式,获得连接

在java项目的src目录下建一个 properties 配置文件,写入连接Mysql数据库的四个基本信息,在代码中加载配置文件。

url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
    user=root
    password=1111
    driver=com.mysql.jdbc.Driver

**使用配置文件的好处：**

> ①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码  
> ②如果修改了配置信息，省去重新编译的过程。

public class ConnectionTest { 
        @Test
        public void GetConnection() throws Exception { 
            //通过当前类的加载器获得一个输入流
            InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(is);
    
            //1.获得四个基本信息
            String user = properties.getProperty("user");
            String password = properties.getProperty("password");
            String url = properties.getProperty("url");
            String driver = properties.getProperty("driver");
    
            //2.加载驱动
            Class.forName(driver);
    
            //3.获得连接
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println(conn);
        }
    }

# 三 、操作数据库 #

**3.1在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式:**

#### ①Statement接口 ####

Statement接口用于在已经建立的基础上向数据库发送SQL语句

用于执行静态sql语句并返回产生的结果的对象

Statement 接口中定义了下列方法用于执行 SQL 语句：

execute(String sql)  //执行静态的SQL语句,该语句可能返回多个结果集
    executeQuery(String sql)  //执行给定的的sql语句,该语句返回单个ResultSet对象
    clearbatch()  //清空此Statement对象的当前sql命令列表
    executeBatch() //将一批命令提交给数据库执行,如果命令执行成功,则返回有更新计数组成的数组.数组元素的排序与sql语句的添加顺序对应
    close() //释放Statement实例占用的数据库和JDBC资源

**3.2SQL注入问题**：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题。用户输入数据中注入非法的 SQL 语句段或命令。

public static Connection getConnection() throws Exception { 
            //通过当前类的加载器获得一个输入流
            InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(is);
    
            //1.获得四个基本信息
            String user = properties.getProperty("user");
            String password = properties.getProperty("password");
            String url = properties.getProperty("url");
            String driver = properties.getProperty("driver");
    
            //2.加载驱动
            Class.forName(driver);
    
            //3.获得连接
            Connection conn = DriverManager.getConnection(url, user, password);
            return conn;
        }
    
        public static void main(String[] args) throws Exception { 
            Scanner input = new Scanner(System.in);
            System.out.print("用户名：");
            String userName = input.nextLine();
            System.out.print("密码：");
            String password = input.nextLine();
            //获得连接
            Connection conn = getConnection();
            //sql语句
            String sql = "select user,password FROM user_table WHERE user = '" + userName + "' AND password = '" + password + "'";
            //获得语句对象
            Statement stmt = conn.createStatement();
            //结果集
            ResultSet rs = stmt.executeQuery(sql);
            if (rs.next()) { 
                System.out.println("登陆成功!");
            } else { 
                System.out.println("用户名或密码错误！");
            }
        }
    }

执行结果:  
![在这里插入图片描述][20200317143309617.png]  
![在这里插入图片描述][20200317143326205.png]

**使用Statement操作数据表存在的弊端：**

> 1.存在拼串操作，繁琐

> 2.存在SQL注入问题

#### ②PreparedStatement 接口 ####

PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句,用于发送含有一个或多个输入参数的sql语句,执行sql的对象

PreparedStatement 常用方法:

setInt(int index,int k)  //将指定位置的参数设置为int值
    setFloat(int index,float f)  //将指定位置的参数设置为float值
    setLong(int index,Long l)  //将指定位置的参数设置为long值
    setDouble(int index,double d)  //将指定位置的参数设置为double值
    setBoolean(int index,boolean b)  //将指定位置的参数设置为boolean值
    setDate(int index,Date date)  //将指定位置的参数设置为date值
    setString(int index,String s)  //将指定位置的参数设置为String值
    executeQuery()  // 在此PreparedStatement对象中执行sql查询,并返回该查询生成的ResultSet对象
    executeUpdate()  //执行前面包含的参数的动态INSERT,UPDATE,DELETE语句淘

*  可以通过调用 Connection 对象的 **preparedStatement(String sql)** 方法获取 PreparedStatement 对象
 *  PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

**3.3要防范 SQL 注入**，只要用 PreparedStatement取代 Statement 就可以了

示例:

public static void main(String[] args) { 
            Connection conn = null;
            PreparedStatement ps = null;
            Scanner input = new Scanner(System.in);
            System.out.print("用户名：");
            String userName = input.nextLine();
            System.out.print("密码：");
            String password = input.nextLine();
            //获得连接
            try { 
                conn = getConnection();
                //sql语句
                String sql = "select user,password FROM user_table WHERE user = ? AND password = ?";
                //获得语句对象,传入要预编译的sql
                ps = conn.prepareStatement(sql);
                //返回的是数据库执行sql语句影响的行数
                int rows = 0;
                rows = ps.executeUpdate();
                //结果集
                if (rows > 0) { 
                    System.out.println("登陆成功!");
                } else { 
                    System.out.println("用户名或密码错误！");
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                // 关闭资源
    
                if (ps != null) { 
                    try { 
                        ps.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
    
                if (conn != null) { 
                    try { 
                        conn.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
            }
        }

执行效果:![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5NzAzOQ_size_16_color_FFFFFF_t_70 2]  
使用PreparedStatement 会保一个SQLException  
注意: 关闭资源要遵循先开后关的原则

### 3.4PreparedStatement 对比 Statement ###

1.  PreparedStatement代码的可读性和可维护性。PreparedStatement 使用已经编译过及定义好的执行计划，这种预处理语句查询比普通的查询运行速度更快。 (语法检查，语义检查，翻译成二进制命令，缓存)
2.  PreparedStatement可以防止SQL注入。
3.  在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样 每执行一次都要对传入的语句编译一次。
4.  PreparedStatement与java.sql.Connection对象是关联的，关闭了connection，PreparedStatement也没法使用了。

#### Java与SQL对应数据类型转换表 ####

<table> 
 <thead> 
  <tr> 
   <th>Java类型</th> 
   <th>SQL类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>BIT</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>TINYINT</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>SMALLINT</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>INTEGER</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>BIGINT</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>CHAR,VARCHAR,LONGVARCHAR</td> 
  </tr> 
  <tr> 
   <td>byte array</td> 
   <td>BINARY , VAR BINARY</td> 
  </tr> 
  <tr> 
   <td>java.sql.Date</td> 
   <td>DATE</td> 
  </tr> 
  <tr> 
   <td>java.sql.Time</td> 
   <td>TIME</td> 
  </tr> 
  <tr> 
   <td>java.sql.Timestamp</td> 
   <td>TIMESTAMP</td> 
  </tr> 
 </tbody> 
</table>

### 3.5使用PreparedStatement实现通用的增、删、改操作,针对不同表 ###

public void update(String sql,Object ... args){ 
    		Connection conn = null;
    		PreparedStatement ps = null;
    		try { 
    			//1.获取数据库的连接
    			conn = JDBCUtils.getConnection();
    			//2.获取PreparedStatement的实例 (或：预编译sql语句)
    			ps = conn.prepareStatement(sql);
    			//3.填充占位符
    			for(int i = 0;i < args.length;i++){ 
    				ps.setObject(i + 1, args[i]);
    			}
    			ps.execute();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally{ 
    			//5.关闭资源
    			JDBCUtils.closeResource(conn, ps);
    		}
    	}

### 3.6 ResultSet ###

1.  查询调用PreparedStatement 的 executeQuery() 方法，返回一个ResultSet 对象
2.  ResultSet 对象维护了一个指向当前数据行的**游标**，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
3.  当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。例如: getInt(1), getString(“name”)

#### 3.7ResultSetMetaData ####

*  可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
 *  ResultSetMetaData meta = rs.getMetaData();
    
     *  **getColumnName**(int column)：获取指定列的名称
     *  **getColumnLabel**(int column)：获取指定列的别名
     *  **getColumnCount**()：返回当前 ResultSet 对象中的列数。
     *  getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
     *  getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
     *  **isNullable**(int column)：指示指定列中的值是否可以为 null。
     *  isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

**问题1：得到结果集后, 如何知道该结果集中有哪些列 ？ 列名是什么？**

需要使用一个描述 ResultSet 的对象， 即 ResultSetMetaData

**问题2：关于ResultSetMetaData**

1.  **如何获取 ResultSetMetaData**： 调用 ResultSet 的 getMetaData() 方法即可
2.  **获取 ResultSet 中有多少列**：调用 ResultSetMetaData 的 getColumnCount() 方法
3.  **获取 ResultSet 每一列的列的别名是什么**：调用 ResultSetMetaData 的getColumnLabel() 方法

### 3.8资源的释放 ###

*  释放ResultSet, Statement,Connection。
 *  数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是**尽量晚创建，尽量早的释放。**
 *  在finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭。

### 3.9 JDBC API小结 ###

*  两种思想
    
     *  面向接口编程的思想
     *  ORM思想(object relational mapping)
        
         *  一个数据表对应一个java类
         *  表中的一条记录对应java类的一个对象
         *  表中的一个字段对应java类的一个属性
    
    > sql是需要结合列名和表的属性名来写。注意起别名。
 *  两种技术
    
     *  JDBC结果集的元数据：ResultSetMetaData
        
         *  获取列数：getColumnCount()
         *  获取列的别名：getColumnLabel()
     *  通过反射，创建指定类的对象，获取指定的属性并赋值

### 3.10使用PreparedStatement实现通用表的查询操作 ###

// 通用的针对于不同表的查询:返回一个对象 (version 1.0)
    	public <T> T getInstance(Class<T> clazz, String sql, Object... args) { 
    		Connection conn = null;
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		try { 
    			// 1.获取数据库连接
    			conn = JDBCUtils.getConnection();
    			// 2.预编译sql语句，得到PreparedStatement对象
    			ps = conn.prepareStatement(sql);
    			// 3.填充占位符
    			for (int i = 0; i < args.length; i++) { 
    				ps.setObject(i + 1, args[i]);
    			}
    			// 4.执行executeQuery(),得到结果集：ResultSet
    			rs = ps.executeQuery();
    			// 5.得到结果集的元数据：ResultSetMetaData
    			ResultSetMetaData rsmd = rs.getMetaData();
    			// 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
    			int columnCount = rsmd.getColumnCount();
    			if (rs.next()) { 
    				T t = clazz.newInstance();
    				for (int i = 0; i < columnCount; i++) { // 遍历每一个列
    					// 获取列值
    					Object columnVal = rs.getObject(i + 1);
    					// 获取列的别名:列的别名，使用类的属性名充当
    					String columnLabel = rsmd.getColumnLabel(i + 1);
    					// 6.2使用反射，给对象的相应属性赋值
    					Field field = clazz.getDeclaredField(columnLabel);
    					field.setAccessible(true);
    					field.set(t, columnVal);
    
    				}
    				return t;
    			}
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			// 7.关闭资源
    			JDBCUtils.closeResource(conn, ps, rs);
    		}
    		return null;
    	}

#### ③CallableStatement接口 ####

继承子PreparedStatement.由方法prePareCall创建,用于调用存储过程

*  方法：static Connection getConnection(String url, String user, String password)

# 四 、JDBCUtils #

package com.hanker.JDBCUtils;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.lang.reflect.Field;
    import java.sql.*;
    import java.util.Properties;
    
    public class JDBCUtils { 
        /* * 获取连接的方法 * */
        public static Connection getConnection() throws Exception { 
            Connection conn = null;
            InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
            Properties pro = new Properties();
            pro.load(is);
            String url = pro.getProperty("url");
            String user = pro.getProperty("user");
            String password = pro.getProperty("password");
            String driver = pro.getProperty("driver");
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            return conn;
        }
    
        /* * 关闭资源的方法 * */
        public static void close(ResultSet rs, Statement stmt, Connection conn) { 
            try { 
                if (rs != null) { 
                    rs.close();
                }
            } catch (SQLException e) { 
                e.printStackTrace();
            }
    
            try { 
                if (stmt != null) { 
                    stmt.close();
                }
            } catch (SQLException e) { 
                e.printStackTrace();
            }
    
            try { 
                if (conn != null) { 
                    conn.close();
                }
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
    
        /* * * */
    
        public static void close(Statement stmt, Connection conn) { 
            JDBCUtils.close(null, stmt, conn);
        }
    
        /* * 通用的增删改的方法 * */
    
        public static int update(String sql, Object... args) { 
            Connection conn = null;
            PreparedStatement ps = null;
            int rows = 0;
            try { 
                //1.获取数据库的连接
                conn = JDBCUtils.getConnection();
                //2.获取PreparedStatement的实例 (或：预编译sql语句)
                ps = conn.prepareStatement(sql);
                //3.填充占位符
                for (int i = 0; i < args.length; i++) { 
                    ps.setObject(i + 1, args[i]);
                }
                //3.填充占位符
                rows = ps.executeUpdate();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(ps, conn);
            }
            return rows;
        }
    
        /* * 通用的查询方法,针对不同表 * */
    
        // 通用的针对于不同表的查询:返回一个对象 (version 1.0)
        public <T> T QueryInstance(Class<T> clazz, String sql, Object... args) { 
            Connection conn = null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            try { 
                // 1.获取数据库连接
                conn = JDBCUtils.getConnection();
                // 2.预编译sql语句，得到PreparedStatement对象
                ps = conn.prepareStatement(sql);
                // 3.填充占位符
                for (int i = 0; i < args.length; i++) { 
                    ps.setObject(i + 1, args[i]);
                }
                // 4.执行executeQuery(),得到结果集：ResultSet
                rs = ps.executeQuery();
                // 5.得到结果集的元数据：ResultSetMetaData
                ResultSetMetaData rsmd = rs.getMetaData();
                // 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
                int columnCount = rsmd.getColumnCount();
                if (rs.next()) { 
                    T t = clazz.newInstance();
                    for (int i = 0; i < columnCount; i++) { // 遍历每一个列
                        // 获取列值
                        Object columnVal = rs.getObject(i + 1);
                        // 获取列的别名:列的别名，使用类的属性名充当
                        String columnLabel = rsmd.getColumnLabel(i + 1);
                        // 6.2使用反射，给对象的相应属性赋值
                        Field field = clazz.getDeclaredField(columnLabel);
                        field.setAccessible(true);
                        field.set(t, columnVal);
                    }
                    return t;
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                // 7.关闭资源
                JDBCUtils.close(rs, ps, conn);
            }
            return null;
        }
    }

# 五 、操作BLOB类型字段数据 #

## 4.1 MySQL BLOB类型 ##

*  MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。
 *  插入BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。
 *  MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>大小</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>TinyBlob</td> 
   <td>最大 255 bit</td> 
  </tr> 
  <tr> 
   <td>Blob</td> 
   <td>最大 65k</td> 
  </tr> 
  <tr> 
   <td>MediumBolb</td> 
   <td>最大 16M</td> 
  </tr> 
  <tr> 
   <td>LongBlob</td> 
   <td>最大 4G</td> 
  </tr> 
 </tbody> 
</table>

*  实际使用中根据需要存入的数据大小定义不同的BLOB类型。
 *  需要注意的是：如果存储的文件过大，数据库的性能会下降。

### 4.2 向数据表中插入大数据类型 ###

public static void main(String[] args) { 
            Connection conn = null;
            PreparedStatement ps = null;
            try { 
                //获取连接
                conn = JDBCUtils.getConnection();
                String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
                ps = conn.prepareStatement(sql);
                // 填充占位符
                ps.setString(1, "杨少");
                ps.setString(2, "yyss@163.com");
                ps.setDate(3, new Date(new java.util.Date().getTime()));
                // 操作Blob类型的变量
                FileInputStream fis = new FileInputStream("girl.jpg");
                ps.setBlob(4, fis);
                //执行
                ps.execute();
                fis.close();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(ps, conn);
            }
        }

Connection conn = JDBCUtils.getConnection();

## 4.3修改数据表中的Blob类型字段 ##

Connection conn = JDBCUtils.getConnection();
    String sql = "update customers set photo = ? where id = ?";
    PreparedStatement ps = conn.prepareStatement(sql);
    
    // 填充占位符
    // 操作Blob类型的变量
    FileInputStream fis = new FileInputStream("boy.png");
    ps.setBlob(1, fis);
    ps.setInt(2, 25);
    ps.execute();
    fis.close();
    JDBCUtils.closeResource(conn, ps);

### 4.4 从数据表中读取大数据类型 ###

String sql = "SELECT id, name, email, birth, photo FROM customer WHERE id = ?";
    conn = getConnection();
    ps = conn.prepareStatement(sql);
    ps.setInt(1, 8);
    rs = ps.executeQuery();
    if(rs.next()){ 
    	Integer id = rs.getInt(1);
        String name = rs.getString(2);
    	String email = rs.getString(3);
        Date birth = rs.getDate(4);
    	Customer cust = new Customer(id, name, email, birth);
        System.out.println(cust); 
        //读取Blob类型的字段
    	Blob photo = rs.getBlob(5);
    	InputStream is = photo.getBinaryStream();
    	OutputStream os = new FileOutputStream("c.jpg");
    	byte [] buffer = new byte[1024];
    	int len = 0;
    	while((len = is.read(buffer)) != -1){ 
    		os.write(buffer, 0, len);
    	}
        JDBCUtils.closeResource(conn, ps, rs);	
    	if(is != null){ 
    		is.close();
    	}	
    	if(os !=  null){ 
    		os.close();
    	}
    }

# 六、批量插入 #

### 6.1批量执行sql语句 ###

当我们需要成批插入或者更新数据时，可以采用Java的批量处理渔具,允许多条语句一次性提交给数据库批量处理。这种方式一般比单独提交处理更有效率

用以下三个方法来处理批量语句:

*  **addBatch(String)：添加需要批量处理的SQL语句或是参数；**
 *  **executeBatch()：执行批量处理语句；**
 *  **clearBatch():清空缓存的数据**

### 6.2批量插入数据 ###

在数据库中建立一个child表:

CREATE TABLE child (
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR (50)
    );

#### 方式一: ####

@Test
        public void testInsert1() { 
            Connection conn = null;
            Statement stmt = null;
            try { 
                conn = JDBCUtils.getConnection();
                stmt = conn.createStatement();
                long start = System.currentTimeMillis();
                for (int i = 0; i < 20000; i++) { 
                    String sql = "insert into child(name) values('name" + i + "')";
                    stmt.executeUpdate(sql);
                }
                long end = System.currentTimeMillis();
                System.out.println("花费的时间:" + (end - start));
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(stmt, conn);
            }
        }

执行结果:  
![在这里插入图片描述][20200318122453108.png]

#### 方式二: ####

清空表,用方式二插入

TRUNCATE TABLE child;

@Test
        public void TestInsert2() { 
            Connection conn = null;
            PreparedStatement ps = null;
            try { 
                conn = JDBCUtils.getConnection();
                long start = System.currentTimeMillis();
                String sql = "insert into child(name)values(?)";
                ps = conn.prepareStatement(sql);
                for (int i = 1; i <= 20000; i++) { 
                    ps.setString(1, "name_" + i);
                    ps.executeUpdate();
                }
                long end = System.currentTimeMillis();
                System.out.println("花费的时间为：" + (end - start));
                JDBCUtils.close(ps, conn);
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(ps, conn);
            }
        }

执行结果:  
![在这里插入图片描述][2020031812250738.png]

通过对比,发现方式一和方式二执行效率相差不大,但还是prepareStatement稍微快一点

因为方式一每次都需要把sql语句加载到内存中,再执行sql语句,每一次的sql语句都不一样。而方式二是 内存中只有一个sql语句,只是每次循环去替换了占位符而已,预编译了sql语句。

#### 方式三: ####

在方式二的基础上进行优化,方式二中,exeecute方法在for循环中,所以它一直在和数据库进行交互

*  修改1： 使用 addBatch() / executeBatch() / clearBatch()
 *  修改2：mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。将 **?rewriteBatchedStatements=true** 写在配置文件的url后面
 *  修改3：使用mysql 驱动：mysql-connector-java-5.1.37-bin.jar

@Test
        public void testInsert3() { 
            Connection conn = null;
            PreparedStatement ps = null;
            try { 
                long start = System.currentTimeMillis();
                conn = JDBCUtils.getConnection();
                String sql = "insert into child(name)values(?)";
                ps = conn.prepareStatement(sql);
                for (int i = 1; i <= 20000; i++) { 
                    ps.setString(1, "name_" + i);
                    ps.addBatch();
                    if (i % 500 == 0) { 
                        ps.executeBatch();
                        ps.clearBatch();
                    }
                }
                long end = System.currentTimeMillis();
                System.out.println("花费的时间为：" + (end - start));
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(ps, conn);
            }
        }

url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true&useUnicode=true&characterEncoding=utf-8
    user=root
    password=1111
    driver=com.mysql.jdbc.Driver

执行结果:

未开启批处理:

开启批处理之后:  
![在这里插入图片描述][2020031812260224.png]

#### 方式四: ####

在方式三的基础上迭代, 使用Connection 的 setAutoCommit(false) 设置为手动提交 / commit()

@Test
        public void testInsert4() { 
            Connection conn = null;
            PreparedStatement ps = null;
            try { 
                long start = System.currentTimeMillis();
                conn = JDBCUtils.getConnection();
                //1.设置为不自动提交数据
                conn.setAutoCommit(false);
                String sql = "insert into child(name)values(?)";
                ps = conn.prepareStatement(sql);
                for (int i = 1; i <= 20000; i++) { 
                    ps.setString(1, "name_" + i);
                    ps.addBatch();
                    if (i % 500 == 0) { 
                        //2.执行
                        ps.executeBatch();
                        ps.clearBatch();
                    }
                }
                //2.提交
                conn.commit();
                long end = System.currentTimeMillis();
                System.out.println("花费的时间为：" + (end - start));
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(ps, conn);
            }
        }

执行结果:  
![在这里插入图片描述][20200318122619533.png]

# 七、JDBC事务处理 #

### 7.1数据库事务介绍 ###

[数据库][Link 1]事务( transaction)是访问并可能操作各种[数据项][Link 2]的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。 ---------百度百科

### 7.2事务的性质(ACDI) ###

① **原子性**(Atomicity)：事务中的全部操作在数据库中是不可分割的，要么全部完成，要么全部不执行。

② **一致性**(Consistency)：几个并行执行的事务，其执行结果必须与按某一顺序 串行执行的结果相一致。

③ **隔离性**(Isolation)：事务的执行不受其他事务的干扰，事务执行的中间结果对其他事务必须是透明的。

④ **持久性**(Durability):对于任意已提交事务，系统必须保证该事务对数据库的改变不被丢失，即使数据库出现故障。

### 7.3JDBC事务 ###

在JDBC中,是通过Connection的方法处理事务的, **同一事务中所有的操作，都在使用同一个Connection对象。**

Connection与事务有关的三个方法:

### 7.4更新JDBCUtils的update方法 ###

public static int update(Connection conn, String sql, Object... args) { 
            PreparedStatement ps = null;
            int rows = 0;
            try { 
                //1.获取数据库的连接
                conn = JDBCUtils.getConnection();
                //2.获取PreparedStatement的实例 (或：预编译sql语句)
                ps = conn.prepareStatement(sql);
                //3.填充占位符
                for (int i = 0; i < args.length; i++) { 
                    ps.setObject(i + 1, args[i]);
                }
                //3.填充占位符
                rows = ps.executeUpdate();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                JDBCUtils.close(ps, conn);
            }
            return rows;
        }

案例 : 模拟转账操作

@Test
        public void test1() { 
            Connection conn = null;
            try { 
                // 1.获取连接对象
                conn = JDBCUtils.getConnection();
                // 2.执行sql语句
                String sql1 = "update user_1 set balance = balance - 5000 where id = ?";
                JDBCUtils.update(conn,sql1, 1);
                //设置异常
               //int a = 10 / 0;
                String sql2 = "update user_1 set balance = balance + 5000 where id = ?";
                JDBCUtils.update(conn,sql2, 2);
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                //3.关闭连接
                JDBCUtils.close(null, null, conn);
            }
        }

正常的转账操作:

![在这里插入图片描述][20200318122658229.png]

我们将表的balance都重新设置为10000,并在执行sql1语句后加一个算数异常之后  
![在这里插入图片描述][2020031812273446.png]  
![在这里插入图片描述][20200318122755266.png]

发现 sql2语句没有执行,数据不完整

@Test
        public void test1() { 
            Connection conn = null;
            try { 
                // 1.获取数据库连接
                conn = JDBCUtils.getConnection();
                // 2.开启事务
                conn.setAutoCommit(false);
                // 3.进行数据库操作
                String sql1 = "update user_1 set balance = balance - 100 where id = ?";
                JDBCUtils.update(conn, sql1,  1);
                int  a = 10/ 0;
                String sql2 = "update user_1 set balance = balance + 100 where id = ?";
                JDBCUtils.update(conn, sql2, 2);
                // 4.若没有异常，则提交事务
                conn.commit();
            } catch (Exception e) { 
                e.printStackTrace();
                // 5.回滚事务
                try { 
                    conn.rollback();
                } catch (SQLException e1) { 
                    e1.printStackTrace();
                }
            } finally { 
                try { 
                    //6.恢复自动提交功能
                    conn.setAutoCommit(true);
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
                //7.关闭连接
                JDBCUtils.close(null, null, conn);
            }
        }

出异常之后,回滚事务:  
![在这里插入图片描述][20200318122808196.png]

# 八、未完待续 #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5NzAzOQ_size_16_color_FFFFFF_t_70]: /images/20230529/9066f1ac3c5640e6a71aaf42d26d9b24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5NzAzOQ_size_16_color_FFFFFF_t_70 1]: /images/20230529/07af1562d86f4df3a7b015fb24d95d10.png
[20200317143123577.png]: /images/20230529/26202948dfd6454c921df9b198ababb1.png
[img]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly90aW1nc2EuYmFpZHUuY29tL3RpbWc_aW1hZ2UmcXVhbGl0eT04MCZzaXplPWI5OTk5XzEwMDAwJnNlYz0xNTg0NDE5NDMzNzQyJmRpPWY1MTM0MDkwNjcyYzU1NzM2OTAyMjE1ZGU0MGIyYjJmJmltZ3R5cGU9anBnJnNyYz1odHRwJTNBJTJGJTJGaC5oaXBob3Rvcy5iYWlkdS5jb20lMkZ6aGlkYW8lMkZwaWMlMkZpdGVtJTJGYjk5OWE5MDE0YzA4NmUwNjZhNDhhYjkzMDUwODdiZjQwYmQxY2IwMi5qcGc?x-oss-process=image/format,png
[20200317143309617.png]: /images/20230529/03d8cfb0a90d4dff856dcbd594d8dfef.png
[20200317143326205.png]: /images/20230529/8fc06655c2c045dbbdc1599a93a0247c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5NzAzOQ_size_16_color_FFFFFF_t_70 2]: /images/20230529/578d508db9bc41dfa898991ee78e5d08.png
[20200318122453108.png]: /images/20230529/b82b1143d6204f66be5c7599baa284be.png
[2020031812250738.png]: /images/20230529/aa78f2809cd249098e51889f1b468836.png
[2020031812260224.png]: /images/20230529/7be384e3483f40c4bd500e7a63a70ad5.png
[20200318122619533.png]: /images/20230529/955e3a2c117a43e08f0c2ab33b81c77a.png
[Link 1]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%BA%93/103728
[Link 2]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E9%A1%B9/3227309
[20200318122658229.png]: /images/20230529/ce25b109db0f4e088e966e7ca380e513.png
[2020031812273446.png]: /images/20230529/a8f64b2292ca4be6ae8ef91a4cbd9235.png
[20200318122755266.png]: /images/20230529/92d398101b4d4df3b8d684ff54c29b8f.png
[20200318122808196.png]: /images/20230529/009d4656c9384ec4ba57091fbfa1225b.png