JDBC精湛秘方QueryRunner

By admin in 4858.com on 2019年8月11日

JavaWeb基础之JdbcUtils工具类final,javawebjdbcutils

JdbcUtils工具类3.0最终版,增添了业务相关功效和刑释链接。最后版本可以直接打成jar包,在前面包车型客车基本项目都会采取该工具类

1. JdbcUtils代码

 1 /**
 2  * 最终版
 3  * @author hui.zhang
 4  *
 5  */
 6 public class JdbcUtils {
 7         // 配置文件的默认配置,必须给出c3p0-config.xml
 8         private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
 9         
10         //事务专用连接
11         private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
12         /**
13          * 使用连接池返回一个连接对象
14          * @return
15          * @throws SQLException
16          */
17         public static Connection getConnection() throws SQLException {
18             Connection con = tl.get();
19             //当con比等于null,说明已经开启了事务
20             if(con != null) return con;
21             return dataSource.getConnection();
22         }
23 
24         /**
25          * 返回连接池对象
26          * @return
27          */
28         public static DataSource getDataSource() {
29             return dataSource;
30         }
31         
32         /**
33          * 开启事务
34          * 1. 获取一个Connection,设置它的setAutoCommit(false)
35          * 2. 要保证dao中使用的连接是我们刚刚创建的
36          * @throws SQLException 
37          */
38         public static void beginTransaction() throws SQLException{
39             Connection con = tl.get();
40             if(con != null) throw new SQLException("已经开启了事务,请不要重复开启!");
41             con = getConnection();
42             con.setAutoCommit(false);
43             tl.set(con);
44         }
45         
46         /**
47          * 提交事务
48          * 1. 获取beginTransaction提供的Connection,然后调用commit方法
49          * @throws SQLException 
50          */
51         public static void commitTransaction() throws SQLException{
52             Connection con = tl.get();
53             if(con == null) throw new SQLException("还没有开启事务,不能提交!");
54             con.commit();
55             con.close();
56             tl.remove();
57         }
58         
59         /**
60          * 回滚事务
61          * 1. 获取beginTransaction提供的Connection,然后调用rollback方法
62          * @throws SQLException 
63          */
64         public static void rollbackTransaction() throws SQLException{
65             Connection con = tl.get();
66             if(con == null) throw new SQLException("还没有开启事务,不能回滚!");
67             con.rollback();
68             con.close();
69             tl.remove();
70         }
71         
72         /**
73          * 释放连接
74          * @param connection
75          * @throws SQLException 
76          */
77         public static void releaseConnection(Connection connection) throws SQLException{
78             Connection con = tl.get();
79             //判断是不是事务专用连接,如果是不用关
80             if(con == null)
81                 connection.close();
82             //如果con != null,说明有事务,需要判断参数连接是否与con相同
83             //不同 说明不是事务专用链接
84             if(con != connection)
85                 connection.close();
86         }
87 }

2. 在src下给出c3p0-config.xml配备文件

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!-- 默认配置信息 -->
    <default-config>
    <!-- 连接四大参数 -->
        <property name="user">root</property>
        <property name="password">123</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///mydb</property>

    <!-- 池参数配置 -->
    <property name="acquireIncrement">3</property> 
    <property name="initialPoolSize">10</property> 
    <property name="minPoolSize">2</property> 
    <property name="maxPoolSize">10</property>
    </default-config>
</c3p0-config> 

3. 总结

  从第一个核心版本1.0到到场连接池2.0再到现行反革命的事情,切实地工作。每一个版本都应该留给。。。温故而知新!!!

JdbcUtils工具类3.0最后版,加多了事情相关职能和刑释解教链接。最后版本能够平昔打成jar包,在后…

JdbcUtils工具类3.0最后版,增多了事情相关效率和刑满释放解除劳教链接。最后版本能够直接打成jar包,在前边的主干项目都会选取该工具类

JdbcUtils工具类3.0最后版,增加了政工相关职能和释放链接。最后版本能够一贯打成jar包,在后头的中坚类型都会动用该工具类


1. JdbcUtils代码

1. JdbcUtils代码

目录:

 1 /**
 2  * 最终版
 3  * @author hui.zhang
 4  *
 5  */
 6 public class JdbcUtils {
 7         // 配置文件的默认配置,必须给出c3p0-config.xml
 8         private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
 9         
10         //事务专用连接
11         private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
12         /**
13          * 使用连接池返回一个连接对象
14          * @return
15          * @throws SQLException
16          */
17         public static Connection getConnection() throws SQLException {
18             Connection con = tl.get();
19             //当con比等于null,说明已经开启了事务
20             if(con != null) return con;
21             return dataSource.getConnection();
22         }
23 
24         /**
25          * 返回连接池对象
26          * @return
27          */
28         public static DataSource getDataSource() {
29             return dataSource;
30         }
31         
32         /**
33          * 开启事务
34          * 1. 获取一个Connection,设置它的setAutoCommit(false)
35          * 2. 要保证dao中使用的连接是我们刚刚创建的
36          * @throws SQLException 
37          */
38         public static void beginTransaction() throws SQLException{
39             Connection con = tl.get();
40             if(con != null) throw new SQLException("已经开启了事务,请不要重复开启!");
41             con = getConnection();
42             con.setAutoCommit(false);
43             tl.set(con);
44         }
45         
46         /**
47          * 提交事务
48          * 1. 获取beginTransaction提供的Connection,然后调用commit方法
49          * @throws SQLException 
50          */
51         public static void commitTransaction() throws SQLException{
52             Connection con = tl.get();
53             if(con == null) throw new SQLException("还没有开启事务,不能提交!");
54             con.commit();
55             con.close();
56             tl.remove();
57         }
58         
59         /**
60          * 回滚事务
61          * 1. 获取beginTransaction提供的Connection,然后调用rollback方法
62          * @throws SQLException 
63          */
64         public static void rollbackTransaction() throws SQLException{
65             Connection con = tl.get();
66             if(con == null) throw new SQLException("还没有开启事务,不能回滚!");
67             con.rollback();
68             con.close();
69             tl.remove();
70         }
71         
72         /**
73          * 释放连接
74          * @param connection
75          * @throws SQLException 
76          */
77         public static void releaseConnection(Connection connection) throws SQLException{
78             Connection con = tl.get();
79             //判断是不是事务专用连接,如果是不用关
80             if(con == null)
81                 connection.close();
82             //如果con != null,说明有事务,需要判断参数连接是否与con相同
83             //不同 说明不是事务专用链接
84             if(con != connection)
85                 connection.close();
86         }
87 }
 1 /**
 2  * 最终版
 3  * @author hui.zhang
 4  *
 5  */
 6 public class JdbcUtils {
 7         // 配置文件的默认配置,必须给出c3p0-config.xml
 8         private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
 9         
10         //事务专用连接
11         private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
12         /**
13          * 使用连接池返回一个连接对象
14          * @return
15          * @throws SQLException
16          */
17         public static Connection getConnection() throws SQLException {
18             Connection con = tl.get();
19             //当con比等于null,说明已经开启了事务
20             if(con != null) return con;
21             return dataSource.getConnection();
22         }
23 
24         /**
25          * 返回连接池对象
26          * @return
27          */
28         public static DataSource getDataSource() {
29             return dataSource;
30         }
31         
32         /**
33          * 开启事务
34          * 1. 获取一个Connection,设置它的setAutoCommit(false)
35          * 2. 要保证dao中使用的连接是我们刚刚创建的
36          * @throws SQLException 
37          */
38         public static void beginTransaction() throws SQLException{
39             Connection con = tl.get();
40             if(con != null) throw new SQLException("已经开启了事务,请不要重复开启!");
41             con = getConnection();
42             con.setAutoCommit(false);
43             tl.set(con);
44         }
45         
46         /**
47          * 提交事务
48          * 1. 获取beginTransaction提供的Connection,然后调用commit方法
49          * @throws SQLException 
50          */
51         public static void commitTransaction() throws SQLException{
52             Connection con = tl.get();
53             if(con == null) throw new SQLException("还没有开启事务,不能提交!");
54             con.commit();
55             con.close();
56             tl.remove();
57         }
58         
59         /**
60          * 回滚事务
61          * 1. 获取beginTransaction提供的Connection,然后调用rollback方法
62          * @throws SQLException 
63          */
64         public static void rollbackTransaction() throws SQLException{
65             Connection con = tl.get();
66             if(con == null) throw new SQLException("还没有开启事务,不能回滚!");
67             con.rollback();
68             con.close();
69             tl.remove();
70         }
71         
72         /**
73          * 释放连接
74          * @param connection
75          * @throws SQLException 
76          */
77         public static void releaseConnection(Connection connection) throws SQLException{
78             Connection con = tl.get();
79             //判断是不是事务专用连接,如果是不用关
80             if(con == null)
81                 connection.close();
82             //如果con != null,说明有事务,需要判断参数连接是否与con相同
83             //不同 说明不是事务专用链接
84             if(con != connection)
85                 connection.close();
86         }
87 }

基础篇_功能分别回看

2. 在src下给出c3p0-config.xml布局文件

2. 在src下给出c3p0-config.xml安插文件

       
 JDBC基础代码回想(使用JdbcUtils工具简化)
                                                                 

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!-- 默认配置信息 -->
    <default-config>
    <!-- 连接四大参数 -->
        <property name="user">root</property>
        <property name="password">123</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///mydb</property>

    <!-- 池参数配置 -->
    <property name="acquireIncrement">3</property> 
    <property name="initialPoolSize">10</property> 
    <property name="minPoolSize">2</property> 
    <property name="maxPoolSize">10</property>
    </default-config>
</c3p0-config> 
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!-- 默认配置信息 -->
    <default-config>
    <!-- 连接四大参数 -->
        <property name="user">root</property>
        <property name="password">123</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///mydb</property>

    <!-- 池参数配置 -->
    <property name="acquireIncrement">3</property> 
    <property name="initialPoolSize">10</property> 
    <property name="minPoolSize">2</property> 
    <property name="maxPoolSize">10</property>
    </default-config>
</c3p0-config> 

       
 c3p0数据库连接池的应用(使用JdbcUtils工具简化)

3. 总结

3. 总结

       
 大额的插入(使用c3p0+JdbcUtils工具简化)

4858.com ,  从第三个基本版本1.0到出席连接池2.0再到前几日的事情,一步一个脚踏过的痕迹。各种版本都应当留给。。。温故而知新!!!

  从第三个焦点版本1.0到参预连接池2.0再到现行反革命的作业,切实地工作。各个版本都应有留给。。。温故而知新!!!

       
 批管理操作(使用c3p0+JdbcUtils工具简化)

       
 数据库中的事务管理(使用c3p0+JdbcUtils工具简化)

       
八线程的产出调控

进阶篇_迈向标准支付
       
友善编排dbutils工具( QueryRunner 、TxQueryRunner和JdbcUtils) 
 (本文主旨)

       
 封装成jar包后的正经支付–common-dbutisl和itcast-tools 
 JDBC精湛秘方QueryRunner。 (本文大旨)


 

数据库使用MySQL数据库,使用的表结构 :

4858.com 14858.com 2

1 CREATE TABLE tab_bin(
2     id     INT     PRIMARY KEY AUTO_INCREMENT,
3     filename    VARCHAR(100),
4     data     MEDIUMBLOB
5 );

tab_bin

4858.com 34858.com 4

1 CREATE TABLE t_user (
2   username varchar(50) DEFAULT NULL,
3   password varchar(50) DEFAULT NULL,
4   age int(11) DEFAULT NULL,
5   gender varchar(20) DEFAULT NULL
6 );

t_user

4858.com 54858.com 6

1 CREATE TABLE account (
2    id int(11) NOT NULL AUTO_INCREMENT,
3    NAME varchar(30) DEFAULT NULL,
4    balance decimal(10,0) DEFAULT NULL,
5    PRIMARY KEY (id)
6 ) ;

account

4858.com 74858.com 8

1 CREATE TABLE t_customer (
2   username VARCHAR(50) DEFAULT NULL,
3   age INT(11) DEFAULT NULL,
4   balance DOUBLE(20,5) DEFAULT NULL
5 );

t_customer

 


 

JDBC基础代码回想

JDBC第四次全国代表大会主导指标: 全部来自   java.sql    包下

DriverManager 注册驱动,获取Connection对象
Connection   连接对象,获取preparedStatement
PreparedStatement sql语句发送器,执行更新、查询操作
ResultSet 结果集,通过next()获取结果

 

 

 

 

品类src文件下编写制定dbconfig.properties配置文件:

name value
driverClassName com.mysql.jdbc.Driver
url jdbc:mysql://localhost:3306/jdbc_test01
username root
password 123456

 

 

 

 

 

 @演示

4858.com 94858.com 10

 1 package cn.kmust.jdbc.demo3.utils.version1;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.sql.Connection;
 6 import java.sql.DriverManager;
 7 import java.sql.SQLException;
 8 import java.util.Properties;
 9 /**
10  * JdbcUtils工具类
11  * @功能 从dbconfig.properties配置文件中获取四大参数,加载驱动类,完成连接数据库
12  *        返回Connection对象
13  *      
14  * @author ZHAOYUQIANG
15  *
16  */
17 public class JdbcUtils {
18     private static Properties props = null ;
19     /**
20      * 这些代码都是只执行一次的,在JdbcUtils类被加载时执行
21      */
22     static{        
23         try{
24             /*
25              * 1. 加载dbconfig.properties配置文件里面的内容到props中    
26              */
27             InputStream in= JdbcUtils.class.getClassLoader()
28                     .getResourceAsStream("dbconfig.properties");
29             props = new Properties();
30             props.load(in);    
31         }catch(IOException e){
32             throw new RuntimeException(e);
33         }
34         try{
35             /*
36              * 2. 加载驱动类
37              */
38             Class.forName(props.getProperty("driverClassName"));
39         }catch(ClassNotFoundException e){
40             throw new RuntimeException(e);
41         }
42     }
43     public static Connection getConnection() throws  SQLException{                    
44         /**
45          * 这些代码可以被反复调用,因为获取数据库连接可能需要多次获取
46          */
47         /*
48          * 3. 调用DriverManager.getConnection()得到Connection
49          */
50         return DriverManager.getConnection(
51                 props.getProperty("url"),
52                 props.getProperty("username"),
53                 props.getProperty("password"));                        
54     }
55 }

JdbcUtils类_简化代码小工具

4858.com 114858.com 12

  1 package cn.kmust.jdbc.demo3.utils.version1;
  2 
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
  5 import java.sql.ResultSet;
  6 import java.sql.SQLException;
  7 import java.sql.PreparedStatement;
  8 
  9 import org.junit.Test;
 10 /**
 11  * 对数据库的操作
 12  * @功能 更新操作 和 查询操作 以及 测试
 13  *
 14  * @author ZHAOYUQIANG
 15  *
 16  */
 17 public class Demo {
 18      /**
 19       * 增、删、改
 20       * @param username
 21       * @param password
 22       * @return
 23       */
 24      public void fun1(String username,String password,int age,String gender)   {
 25            Connection con = null ; 
 26            PreparedStatement pstmt = null ;
 27    
 28             try {
 29                 /*
 30                    * 1. 连接数据库,给con赋值
 31                    * 2. 准备SQL语句
 32                    * 3. 调用 Connection对象的方法来得到PrepareStatement对象
 33                    * 4. 使用PrepareStatement对象给sql参数赋值
 34                    * 5. 使用PrepareStatement对象向数据库发送sql语句,并且返回影响记录的行数
 35                    * 6. 关闭资源。 后创建的先关闭
 36                    */                   
 37                    con = JdbcUtils.getConnection();
 38                    String sql ="INSERT INTO t_user VALUES (?,?,?,?)" ;  //sql语句中不加分号
 39 //                   String sql ="UPDATE t_user SET password=? WHERE username=?";
 40 //                   String sql ="DELETE FROM stu WHERE username=?";
 41                     pstmt = con.prepareStatement(sql);
 42                     pstmt.setString(1, username);
 43                     pstmt.setString(2, password);
 44                     pstmt.setInt(3, age);
 45                     pstmt.setString(4, gender);
 46                     int r = pstmt.executeUpdate();
 47                     System.out.println(r);    //输出影响记录的行数
 48             } catch (Exception e) {
 49                 throw new RuntimeException(e);            
 50             } finally{                
 51                 if (pstmt !=null) 
 52                     try{ pstmt.close();}catch (Exception e){throw new RuntimeException(e);}
 53                 if (con != null) 
 54                     try{ con.close();}catch (Exception e){throw new RuntimeException(e);}
 55             }                           
 56      }
 57      /**
 58       * 查询数据库
 59       */
 60       @Test
 61      public void  fun2() {
 62         Connection con = null ; 
 63         PreparedStatement pstmt = null ;
 64         ResultSet rs = null ;   
 65        try {
 66            /*
 67             * 1. 连接数据库,给con赋值
 68             * 2. 准备SQL语句
 69             * 3. 调用 Connection对象的方法来得到PrepareStatement对象
 70             * 4. 使用PrepareStatement对象给sql参数赋值
 71             * 5. 使用PrepareStatement对象向数据库发送sql语句,并且返回ResultSet对象的结果集(就是一个表)
 72             * 6. 调用ResultSet的boolean next()方法 遍历结果集的每行记录,方法返回的true和false代表光标指针所指的这一行有没有记录
 73             * 7. 调用ResultSet的getXXX(第几列)/getXXX("列名字")方法  返回当前行记录的列数据。其中,getObject和getString 能够获得所有的类型       
 74             * 8. 关闭资源。 后创建的先关闭
 75             */
 76             con = JdbcUtils.getConnection(); 
 77             String sql = "select * from t_user where username=? and password=? " ;
 78             pstmt = con.prepareStatement(sql);
 79             pstmt.setString(1, "zhaoLiu");
 80             pstmt.setString(2, "123456");                      
 81             rs=pstmt.executeQuery();
 82             while(rs.next()){        
 83                 String name = rs.getString(2);//可以用列名字 : String name = rs.getString("sname");
 84                 String password = rs.getString("password");    
 85                 int age = rs.getInt("age");
 86                 String gender = rs.getString("gender");
 87                 System.out.println("名字"+name+",密码"+password+",年龄"+age+",性别"+gender);
 88            }
 89         } catch (Exception e) {
 90             throw new RuntimeException(e);
 91         } finally{
 92             if (rs != null)
 93                 try{ rs.close();}catch (Exception e){throw new RuntimeException(e);}
 94             if (pstmt !=null) 
 95                 try{ pstmt.close();}catch (Exception e){throw new RuntimeException(e);}
 96             if (con != null) 
 97                 try{ con.close();}catch (Exception e){throw new RuntimeException(e);}
 98        }        
 99       }
100 
101       /**
102        *  测试增删改 
103        */
104       @Test
105       public void fun1Test(){
106           String username="zhaoLiu" ;
107           String password ="123456";
108           int age = 12 ;
109           String gender = "男";
110           fun1(username,password,age,gender);
111       }    
112 }

Dao类_操作/测量检验数据库

c3p0数据库连接池的选取

c3p0数据库连接池 :  
数据库的重重总是对象都放在池中被管制着,什么人用哪个人去租,用完还给就行了。
c3p0正是二个相比不利的池塘 。

DataSource对象也在 java.sql  包下

项目src文件下编写c3p0-config.xml配备文件(文件中也交给了oracle的布署模版):(@注意:配置文件的称号c3p0-config.xml是叁个法定给定的标准,不是随机起的名字)

@演示

4858.com 134858.com 14

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <c3p0-config>
 3     <default-config><!-- 这是默认的配置信息 -->
 4         <!-- 连接四大参数配置 -->
 5         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc_test01</property>
 6         <property name="driverClass">com.mysql.jdbc.Driver</property>
 7         <property name="user">root</property>
 8         <property name="password">123456</property>
 9         <!-- 池本身的参数配置 -->
10         <property name="acquireIncrement">3</property>
11         <property name="initialPoolSize">10</property>
12         <property name="minPoolSize">2</property>
13         <property name="maxPoolSize">10</property>
14     </default-config>
15     
16     <!-- 专门为oracle准备的配置信息 -->
17     <!-- 这也是命名配置信息,在JDBC中创建连接池对象的时候要加 oracle-config这个参数-->
18     <named-config name="oracle-config">
19         <property name="jdbcUrl">  oracle的url   </property>
20         <property name="driverClass">  oracle的驱动   </property>
21         <property name="user">    oracle的用户 </property>
22         <property name="password">    密码</property>
23         <property name="acquireIncrement">3</property>
24         <property name="initialPoolSize">10</property>
25         <property name="minPoolSize">2</property>
26         <property name="maxPoolSize">10</property>
27     </named-config>
28     
29 </c3p0-config>

c3p0-config.xml

4858.com 154858.com 16

 1 package cn.kmust.jdbc.demo9.c3p0Pool.utils.version2;
 2 
 3 import java.sql.Connection;
 4 import java.sql.SQLException;
 5 
 6 import javax.sql.DataSource;
 7 
 8 import com.mchange.v2.c3p0.ComboPooledDataSource;
 9 /**
10  * JdbcUtils工具类     [c3p0数据库连接池专用工具类]
11  *   需要编写c3p0-config.xml配置文件
12  * @功能 利用c3p0-config.xml配置文件获取连接对象并且返回 。 连接池对象也返回
13  * @c3p0说明   借用池中的Connection对象,用完归还
14  *           需要编写c3p0-config.xml文件,里面有四大连接参数和池子本身的参数配置
15  *           文件不需要说明在什么位置,因为在创建连接池对象时,这个对象会自动加载配置文件
16  * @author ZHAOYUQIANG
17  *
18  */
19 public class JdbcUtils {
20     /*
21      * 1. 创建连接池对象
22      *      创建时自动加载c3p0-config.xml配置文件
23      *      如果是配置文件中是命名配置,如oracle,那么构造器的参数指定命名配置为元素的名称,也就是说代码要变成如下形式:
24      *            ComboPooledDataSource dataSource = new ComboPooledDataSource("oracle-config");
25      */
26     private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
27     /**
28      * 使用连接池返回一个连接对象
29      * @return
30      * @throws SQLException
31      */
32     public static Connection getConnection() throws SQLException{
33         return dataSource.getConnection();
34     }
35     /**
36      * 返回池对象
37      * @return
38      */
39     public static DataSource getDataSource(){
40         return dataSource;
41     }
42 }

JdbcUtis工具类_c3p0版本

4858.com 174858.com 18

 1 package cn.kmust.jdbc.demo9.c3p0Pool.utils.version2;
 2 
 3 import java.beans.PropertyVetoException;
 4 import java.sql.Connection;
 5 import java.sql.SQLException;
 6 
 7 import org.junit.Test;
 8 
 9 import com.mchange.v2.c3p0.ComboPooledDataSource;
10 
11 /**
12  * Test
13  * @功能  通过JdbcUtils工具获取池子中的一个连接对象,并且输出这个连接,查看是否获取到了
14  *
15  * @author ZHAOYUQIANG
16  *
17  */
18 public class Demo01 {
19     @Test
20     public void fun() throws SQLException {
21         /*
22          * 1. 通过c3p0专属的JdbcUtils工具[版本2]直接获取连接
23          * 2. 把连接归还给池子
24          */
25         Connection con = JdbcUtils.getConnection();
26         /**
27          * 此处代码进行sql的操作,本次省略。
28          */
29         System.out.println(con);
30         con.close();
31     }
32 }

Test类_翻开获取的一而再

大数目标插入(使用c3p0+JdbcUtls简化代码)

 @化解的标题 怎么着向mysql中插入一部10M左右的.DVD文件 ???

MySQL中提供仓库储存大数指标花色如下:(@注意
标准SQL中提供的等级次序并不是如下类型,请自行百度)

类型  长度
tinytext 28-1 B(256B)
text 216-1B(64K)
mediumtext 224-1B(16M)
longtext 232-1B(4G)

 

 

 

 

 

待插入文件地方 : D:\十年.mp3

待下载文件地方: E:\十年.mp3

@使用 c3p0数据库连接池的选拔
中的c3p0-config.xml 和JdbcUtils工具

@演示 

4858.com 194858.com 20

 1 package cn.kmust.jdbc.demo4.bigData;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.InputStream;
 6 import java.io.OutputStream;
 7 import java.sql.Blob;
 8 import java.sql.Connection;
 9 import java.sql.PreparedStatement;
10 import java.sql.ResultSet;
11 
12 import javax.sql.rowset.serial.SerialBlob;
13 
14 import org.apache.commons.io.IOUtils;
15 import org.junit.Test;
16 
17 import cn.kmust.jdbc.demo3.utils.version1.JdbcUtils;
18 
19 /**
20  * 大数据,把mp3保存到mysql数据库的表中
21  *
22  * @author ZHAOYUQIANG
23  *
24  */
25 public class BigData{
26     /**
27      * 把tmp3保存到数据库中
28      */
29     @Test
30     public void fun1(){
31         Connection con = null ; 
32         PreparedStatement pstmt = null ;
33         try{
34             con = JdbcUtils.getConnection();
35             String sql = "insert into tab_bin values(?,?,?)";
36             pstmt =con.prepareStatement(sql);
37             pstmt.setInt(1, 1);
38             pstmt.setString(2,"十年.mp3");
39             /**
40              * 向数据库中存入mp3音乐
41              *    数据库中存储音乐的类型是要用大小是0~16MB的Blob类型
42              *    要做的事情是把硬盘中.mp3文件变成Blob类型,然后存入到数据库中
43              */
44             /*
45              * 1. 将流文件变成字节数组
46              *      导入小工具包: Commons-io.jar
47              * 2. 使用字节数组创建Blob对象
48              */
49             byte[] bytes = IOUtils.toByteArray(new FileInputStream("D:/十年.mp3"));    
50             Blob blob = new SerialBlob(bytes) ; 
51             pstmt.setBlob(3, blob);
52             pstmt.executeUpdate();
53         }catch(Exception e){
54             throw new RuntimeException(e);
55         }finally{
56             if (pstmt !=null) 
57                 try{ pstmt.close();}catch (Exception e){throw new RuntimeException(e);}
58             if (con != null) 
59                 try{ con.close();}catch (Exception e){throw new RuntimeException(e);}        
60         }
61         
62     }
63     /**
64      * 从数据库读取mp3
65      *    抛异常的语句简写
66      */
67     @Test
68     public void fun2()throws Exception{
69         Connection con = null ;
70         PreparedStatement pstmt = null ;
71         ResultSet rs =null ;
72         con = JdbcUtils.getConnection();
73         String sql = "select * from tab_bin";
74         pstmt = con.prepareStatement(sql);
75         rs = pstmt.executeQuery();
76         /**
77          * 获取rs中名为data的列数据,也就是获取MP3
78          *    先取到数据库中的Blob类型,然后把Blob变成硬盘上的文件
79          */
80         System.out.println(rs);
81         if(rs.next()){            
82             /*
83              * 1. 获取数据库中的Blob类型
84              * 2. 通过Blob得到输入流对象
85              * 3. 自己创建输出流对象
86              * 4. 把输入流的数据写入到输出流中
87              */
88             Blob blob =  rs.getBlob("data");
89             InputStream in = blob.getBinaryStream();
90             OutputStream out =new FileOutputStream("E:/十年.mp3");
91             IOUtils.copy(in, out);
92             con.close();
93         }                
94     }
95 }

BigData类_操作大额

@或者出现谬误  
若是出现以下错误提醒,请张开MySQL对于插入数据大小的限量。具体操作 :
在MySQL\MySQL Server 5.5\my.ini  文件中增添  max_allowed_packet = 16M     

1 java.lang.RuntimeException: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (8498624 > 1048576). You can change this value on the server by setting the max_allowed_packet' variable.

批处理操作(使用c3p0+JdbcUtls简化代码)

 批处理的情趣是: PreparedStatement对象能够大批判的发送SQL语句给服务器施行,对象中有集聚。
特别是在向数据库中插入很非常多目时,开启了批处理后,1万记录只供给不到半秒,若无开启,则要求7秒钟。

MySQL中打开批管理需求在url上丰硕参数,即:
jdbc:mysql://localhost:3306/jdbc_test01?rewriteBatchedStatements=true

@演示

4858.com 214858.com 22

 1                       /**
 2              * 批处理sql语句
 3              *     pstmt对象中有集合
 4              *     用循环向psmt中添加sql参数,然后调用执行,完成向数据库发送
 5              */
 6             for(int i = 0 ;i<10000 ;i++){
 7                 /*
 8                  * 一条记录的4个列参数
 9                  */
10                 pstmt.setString(1, "name"+i);
11                 pstmt.setString(2,"password"+i+1);
12                 pstmt.setInt(3, i+2);
13                 pstmt.setString(4, i%2==0?"男":"女");
14                 /*
15                  * 添加批
16                  *    将4个列参数添加到pstmt中,经过循环,把100行记录,400个列参数都添加到pstmt中
17                  */
18                 pstmt.addBatch();
19             }
20             /*
21              * 执行批
22              */
23             pstmt.executeBatch();

批管理的JDBC代码

数据库中的事务(使用c3p0+JdbcUtls简化代码)

转载功用: A向B转账100元,数据库操作是 : 1. A缩减100元,2. B日增100。
若A减弱100元,硬件崩溃,则B并不曾扩充100元,那是非常的,应该回滚到A还不曾滑坡100的时候 。 那就必要工作。

同四个事务中的三个操作,要么完全成功交付,要么完全失利回滚到原点,不可能存在成功百分之五十的情景,具备原子性、一致性、隔绝性、漫长性。
所以能够将以上的两步操作放到一个作业中。

JDBC中与业务相关的指标是Connection 对象,该对象有四个章程来操作工作:

setAutoCommit(boolean) false表示开启事务
commit() 提交事务
rollback() 回滚事务

 

 

 

@注意 
如出一辙业务的有着操作,使用的是同三个Connection对象

 @使用 c3p0数据库连接池的利用 中的c3p0-config.xml
和JdbcUtils工具

@演示

4858.com 234858.com 24

 1 package cn.kmust.jdbc.demo6.routine;
 2 
 3 import java.sql.Connection;
 4 import java.sql.SQLException;
 5 import org.junit.Test;
 6 import cn.kmust.jdbc.demo3.utils.version1.JdbcUtils;
 7 
 8 /**
 9  * service层
10  * @功能  演示转账业务  
11  *       演示事务
12  * @缺陷  同一个事务必须用同一个Connection,所以所有对Connection的管理都转移到了service中了,
13  *        污染了Service层,犯了大忌!!! 问题的解决要到TxQueryRunner类中解决
14  *        
15  * @author ZHAOYUQIANG
16  *
17  */
18 public class Demo01 {
19     /**
20      * 转账的方法
21      * @param from 从谁那儿转
22      * @param to   转给谁
23      * @param money  转多少钱
24      */
25     public void transfer(String from,String to,double money){
26         Connection con = null ;
27         try{
28             con = JdbcUtils.getConnection();
29             /*
30              * 1. 开启事务
31              * 2. 调用方法进行转账
32              *     转账有两步,要么两步都成功,要么都失败
33              * 3. 提交事务
34              * 4. 回滚事务
35              * 5. 关闭连接
36              */
37             con.setAutoCommit(false);
38             AccountDao dao = new AccountDao();
39             dao.updateBalance(con,from, -money);
40             /*
41              * 中间故意设置异常,测试事务回滚
42              */
43 //            if(true){
44 //                throw new RuntimeException("对不起,操作失败!");
45 //            }
46             dao.updateBalance(con,to, money);
47             con.commit();
48         }catch(Exception  e){
49             try{con.rollback();}catch(SQLException e1){ throw new RuntimeException(e);}
50             throw new RuntimeException(e);
51         }finally{
52             try{con.close();}catch(Exception e){ throw new RuntimeException(e);}
53         }        
54     }
55     /**
56      * 测试方法
57      */
58     @Test
59     public void test(){
60         /*
61          * zs给ls转账100元
62          */
63         transfer("zs", "ls", 100);                
64     }
65 }

AccountService类_转折业务/测量试验

4858.com 254858.com 26

 1 package cn.kmust.jdbc.demo6.routine;
 2 
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import cn.kmust.jdbc.demo3.utils.version1.JdbcUtils;
 6 
 7 /**
 8  * Dao层 操作数据库
 9  * @功能  转账: 完成对数据库的操作(A用户减少100,B用户增加增加100。)
10  * 
11  * @author ZHAOYUQIANG
12  *
13  */
14 public class AccountDao {
15     /**
16      * 修改指定用户的余额
17      * @param name
18      * @param balance
19      */
20     public void updateBalance(Connection con ,String name , double balance){        
21         PreparedStatement pstmt = null ;
22         try{        
23             String sql = "update account set balance=balance+? where name=?";
24             pstmt = con.prepareStatement(sql);
25             pstmt.setDouble(1,balance);
26             pstmt.setString(2, name);
27             pstmt.executeUpdate();
28         }catch(Exception e){
29             throw new RuntimeException(e);
30         }
31     }
32 }

AccountDao_sql操作

@事务并发的弱点 
七个事情并发实施时,因为与此同一时候调用Connection对象而引发严重难题,产生脏读、不可重复读、虚读的要紧难点。
要求开始展览二十四线程并发调节

多线程并发调整的操作 

@java中的并发难点  借使四个线程同不日常候做客同叁个数量的时候,线程争夺临界能源数量引发问题。 多少个线程可呈报为多个职务,比如:
同贰个帐号在分歧ATM机上取钱,那是七个职分(也是八个线程),多个线程都要调用
  Class 取钱{ private String 帐号 ; public void fun1()
{}  public void fun2() {} ….  }
  中的帐号变量(成员变量),就汇合世读写标题。
一般的话,l临界能源都以类中的成员变量,而非方法中的局地变量

JDBC操作中,因为几个业务同一时间调用Connection对象,会唤起并发难点。

@消除难点  化解的情势能够用synchrozined{}同步块 ,
可是此法耗费时间严重。选取功效能增高150倍的ThreadLocal比较好。ThreadLocal类是三个泛型类,@观念 将逼近能源给各种线程都分配一份,来减轻八个线程争夺同贰个能源而引发的难点。

ThreadLocal类java.lang包下已经写好的封装类,间接调用就可以 。 有八个法子:
分别是set()、get()和remove() 。
以下是谐和编辑的模拟类,为了越来越好的精晓该类的最底层是怎么落到实处的

4858.com 274858.com 28

 1 /**
 2  * ThreadLocal类的核心代码分析
 3  * @功能  存取删功能
 4  *        一个线程只能存一个数据,所以同一个线程存入多个数据,后一个数据会覆盖掉前一个数据
 5  * @分析   用当前线程存,用当前线程取 ,只能删除当前线程的数据
 6  *           所以当前线程存的东西,其他线程是取不出来的,也删除不掉
 7  *      
 8  * @author ZHAOYUQIANG
 9  *
10  * @param <T>
11  */
12 class ThreadLocal<T>{
13     /*
14      * 线程作为key,T作为value
15      *    T是自己指定的泛型类型
16      */
17     private Map<Thread,T> map = new HashMap<Thread,T>();
18     /**
19      * 存储数据data
20      *    使用当前线程做key   
21      * @param data
22      */
23     public void set(T data){
24         map.put(Thread.currentThread(),data);
25     }
26     /**
27      * 获取数据
28      *    获取当前线程的数据
29      * @return
30      */
31     public T get(){
32         return map.get(Thread.currentThread());        
33     }
34     /**
35      * 移除
36      *    删除当前线程的数据
37      */
38     public void remove(){
39         map.remove(Thread.currentThread());
40     }
41 }

ThreadLocal类 核心成效

@演示
使用当中类模拟八线程并发争夺临界财富来演示ThreadLocal的效应

4858.com 294858.com 30

 1 /**
 2  * 多线程的测试
 3  * @功能  用内部类模拟多线程竞争临界资源
 4  *         结论是:当前线程存入的值只有当前线程能取出来,其他线程取不出来,
 5  *           ThreadLocal给每个线程分配一个临界资源,解决了并发问题 
 6  *   
 7  * @author ZHAOYUQIANG
 8  *
 9  */
10 public class TlTestDemo {
11     @Test
12     public void fun(){
13         /*
14          * 以为a1要被内部类使用,所以加上final关键字
15          */
16         final ThreadLocal<Integer> a1 = new ThreadLocal<Integer>();
17         a1.set(2);
18         System.out.println(a1.get()); //会输出2 , 当前线程的值
19         /**
20          * 内部类
21          *    尾部加上.start ,
22          *      意味着程序无需等待内部类中的run()方法执行完即可向下执行 ,
23          *        实现了块的多线程并发性
24          */
25         new Thread(){
26             public void run(){
27                 System.out.println("我是内部类"+a1.get()); //输出null,说明此线程不能获取当前线程的数据
28             }
29         }.start();       
30 //        a1.remove();
31     }
32 }

ThreadLocal的测试

 用ThreadLocal类化解JDBC浙江中华南理管理大学程公司作的出现难题置于TxQueryRunner类中解决

QueryRunner、TxQueryRunner和JdbcUtils(重点、本文宗旨)

 QueryRunner的构思是:
把java中对数据库的拍卖代码写到单独的类QueryRunner中,Dao层只提供SQL模版和sql参数,而TxQueryRunner肩负继承QueryRunner类支持专门的学问的处理。JdbcUtils起到了着实的工具作                                          
    用,担当连接,事务等 

@演示  

@使用 c3p0数据库连接池的行使 中的c3p0-config.xml 

4858.com 314858.com 32

 1 package cn.kmust.jdbcDemo.domain;
 2 /**
 3  * 实体类
 4  *    变量名字最好与数据库中对应字段名一样,便于封装操作
 5  * @author ZHAOYUQIANG
 6  *
 7  */
 8 public class Customer {
 9     private String username ; //用户
10     private int age ;  //年龄
11     private double balance ; //资金
12     public String getUsername() {
13         return username;
14     }
15     public void setUsername(String username) {
16         this.username = username;
17     }
18     public int getAge() {
19         return age;
20     }
21     public void setAge(int age) {
22         this.age = age;
23     }
24     public double getBalance() {
25         return balance;
26     }
27     public void setBalance(double balance) {
28         this.balance = balance;
29     }
30     @Override
31     public String toString() {
32         return "Customer [username=" + username + ", age=" + age + ", balance="
33                 + balance + "]";
34     }
35     public Customer(String username, int age, double balance) {
36         super();
37         this.username = username;
38         this.age = age;
39         this.balance = balance;
40     }
41     public Customer() {
42         super();
43         // TODO Auto-generated constructor stub
44     }
45     
46     
47     
48 
49 }

Customer

4858.com 334858.com 34

 1 package cn.kmust.jdbcDemo.service;
 2 
 3 import java.sql.SQLException;
 4 
 5 import cn.kmust.jdbcDemo.dao.CustomerDao;
 6 import cn.kmust.jdbcDemo.domain.Customer;
 7 import cn.kmust.jdbcDemo.utils.JdbcUtils;
 8 
 9 /**
10  * service 层   处理业务
11  * @功能  1. 增加新客户
12  *       2. 查询客户信息(根据客户的username)
13  *       3. 转账操作  需要事务
14  * @author ZHAOYUQIANG
15  *
16  */
17 public class CustomerService {
18     /*
19      * 依赖CustomerDao
20      */
21     CustomerDao cstmDao = new CustomerDao();
22     /**
23      * 增加新客户
24      * @param cstm
25      * @throws SQLException 
26      */
27     public void add(Customer cstm) throws SQLException{
28         cstmDao.add(cstm);
29     }
30     /**
31      * 查询客户信息(根据用户名字)
32      * @param name
33      * @return
34      * @throws SQLException 
35      */
36     public Customer query(String name) throws SQLException{
37         Customer cstm = cstmDao.query(name);
38         return cstm ;
39     }
40     /**
41      * 转账
42      *   A用户转给B用户money钱
43      * @param nameA
44      * @param nameB
45      * @param money
46      * @throws Exception 
47      */
48     public void transfer(String nameA,String nameB,double money) throws Exception{
49         try{
50             /*
51              * 1. 事务1 : 开启事务
52              * 2. 处理业务
53              * 3. 事务2: 提交事务
54              * 4. 事务3 :回滚事务
55              */
56             JdbcUtils.beginTransaction();
57             cstmDao.transfer(nameA,-money);
58             cstmDao.transfer(nameB,money);
59             JdbcUtils.commitTransaction();
60         }catch(Exception e){
61             try{
62                 JdbcUtils.rollbackTransaction();
63             }catch(SQLException e1){        
64             }
65             throw e;
66         }        
67     }
68 }

CustomerService

4858.com 354858.com 36

 1 package cn.kmust.jdbcDemo.dao;
 2 
 3 import java.sql.ResultSet;
 4 import java.sql.SQLException;
 5 
 6 import cn.kmust.jdbcDemo.domain.Customer;
 7 import cn.kmust.jdbcDemo.utils.QueryRunner;
 8 import cn.kmust.jdbcDemo.utils.ResultSetHandler;
 9 import cn.kmust.jdbcDemo.utils.TxQueryRunner;
10 
11 /**
12  *dao层  
13  *    对数据库的操作 
14  * @author ZHAOYUQIANG
15  *
16  */
17 public class CustomerDao {
18     /**
19      * 添加新客户
20      * @param cstm
21      * @throws SQLException 
22      */
23     public void add(Customer cstm) throws SQLException {
24         /*
25          * 1. 创建TxQueryRunner对象 
26          * 2. 准备SQL模版     
27          * 3. 将参数存入参数数组 
28          * 4. 调用TxQueryRunner类中update方法  进行插入操作
29          */
30         QueryRunner qr =  new TxQueryRunner();
31         String sql ="insert into t_customer values(?,?,?)";
32         Object[] params = {cstm.getUsername(),
33                            cstm.getAge(),
34                            cstm.getBalance()};
35         qr.update(sql, params);                    
36     }
37     /**
38      * 转账 
39      * @param nameA
40      * @param d
41      * @throws SQLException 
42      */
43     public void transfer(String name, double money) throws SQLException {
44         /*
45          * 1. 创建TxQueryRunner对象 
46          * 2. 准备SQL模版     
47          * 3. 将参数存入参数数组 
48          * 4. 调用TxQueryRunner类中update方法  进行更改操作
49          */
50         QueryRunner qr = new TxQueryRunner();
51         String sql = "update t_customer set balance=balance+? where username=?";
52         Object[] params = {money,name};
53         qr.update(sql,params);        
54     }
55     /**
56      * 查询
57      * @param name
58      * @return
59      * @throws SQLException 
60      */
61     public Customer query(String name) throws SQLException {
62         /*
63          * 1. 创建TxQueryRunner对象 
64          * 2. 准备SQL模版     
65          * 3. 将参数存入参数数组 
66          * 4. 编写ResultSetHandler接口的实现,把查询结果封装到Customer对象中
67          * 5. 调用TxQueryRunner类中query方法  进行查询操作,并且返回查询出的对象
68          */
69         QueryRunner qr = new TxQueryRunner();
70         String sql ="select * from t_customer where username=?";
71         Object[] params = {name} ;
72         /**
73          * 内部类  _结果集处理器的实现类              
74          *  @功能  实现ResultSetHandler接口
75          *          把查询到的结果集封装到实体类对象中,并且返回这个实体类,供给其他类使用
76          */
77         ResultSetHandler<Customer> rsh = new ResultSetHandler<Customer>() {            
78             public Customer handle(ResultSet rs) throws SQLException {
79                 //查询不到,返回null
80                 if(!rs.next())
81                     return null ;
82                 Customer cstm = new Customer();
83                 /*
84                  * 把查询到的内容封装到Customer对象中,并且返回
85                  */
86                  cstm.setUsername(rs.getString("username"));
87                  cstm.setAge(rs.getInt("age"));
88                  cstm.setBalance(rs.getDouble("balance"));
89                 return cstm;
90             }
91         };                
92         return (Customer)qr.query(sql,rsh,params);
93     }   
94 }

CustomerDao

4858.com 374858.com 38

  1 package cn.kmust.jdbcDemo.utils;
  2 
  3 import java.sql.Connection;
  4 import java.sql.SQLException;
  5 
  6 import javax.sql.DataSource;
  7 
  8 import com.mchange.v2.c3p0.ComboPooledDataSource;
  9 
 10 /**
 11  * JdbcUtisl工具类
 12  * @功能  1. 返回数据库连接对象 和 数据库连接池对象
 13  *       2. 事务的开启、提交、关闭
 14  *       3. 释放数据库连接对象
 15  * 
 16  * @author ZHAOYUQIANG
 17  *
 18  */
 19 public class JdbcUtils {
 20     /*
 21      * 创建连接池对象
 22      *    创建时自动加载c3p0-config.xml配置文件
 23      */
 24     private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
 25     /*
 26      * 提供一个事务专用的连接
 27      *    事务专用连接 :  service层开启事务的时候创建连接,
 28      *         在该事务结束(提交和回滚)之前的所有操作中都使用这同一个连接对象
 29      *    防止多个事务产生并发问题,用ThreadLocal加以控制
 30      */
 31     private static ThreadLocal<Connection> t1 = new ThreadLocal<Connection>();
 32     /**
 33      * 使用连接池返回一个数据库连接对象
 34      * @return
 35      * @throws SQLException
 36      */
 37     public static Connection getConnection() throws SQLException{
 38         /*
 39          * 1. 取出当前线程的连接
 40          * 2. 当con != null时,说明已经调用过本类的beginTransaction()方法了,
 41          *        正是该方法给con赋的值,  表示开启了事务,所以把这个事务专用con返回,保证是同一个连接
 42          * 3. 如果con = null ,说明没有调用过本类的beginTransaction()方法,
 43          *        说明并没有开启事务,接下来的操作也不需要使用同一个连接对象,所以返回一个新的非事务专用的连接对象
 44          */
 45         Connection con = t1.get();
 46         if(con != null)
 47             return con ;
 48         return dataSource.getConnection();
 49     }
 50     /**
 51      * 返回池对象
 52      * @return
 53      */
 54     public static DataSource getDataSource(){
 55         return dataSource;
 56     }
 57     /**
 58      * 事务处理一: 开启事务
 59      *   获取一个新的Connection对象,设置setAutoCommit(false)开启事务
 60      *     这个Connection对象将会一直贯穿被该事务所包裹的所有操作,直到提交或者回滚才会关闭
 61      * @throws SQLException 
 62      */
 63     public static void beginTransaction() throws SQLException{
 64         /*
 65          * 1. 取出当前线程的连接
 66          * 2. 防止重复开启
 67          * 3. 给con赋值,并且设con为手动提交,
 68          *       这个con对象是事务专用的连接对象,以后进行的事务提交、回滚和在该事务中的操作所用的连接
 69          *            全是这同一个连接
 70          * 4. 把当前线程的连接保存起来,供给下面的提交和回滚以及开启事务的多个类使用
 71          *        这样就能保证同一个事务中的多个操作用的连接对象都是这一个对象,是同一个
 72          */
 73         Connection con = t1.get();
 74         if(con != null )
 75             throw new SQLException("已经开启事务,就不要重复开启!");
 76         con = getConnection();
 77         con.setAutoCommit(false);
 78         t1.set(con);
 79     }
 80     /**
 81      * 事务处理二:提交事务
 82      *   获取beginTransaction提供的Connection ,调用commit
 83      * @throws SQLException 
 84      */
 85     public static void commitTransaction() throws SQLException{
 86         /*
 87          * 1. 获取当前线程的连接
 88          * 2. 防止还没有开启事务就调用提交事务的方法,判断的依据是如果开启事务,con一定有值
 89          * 3. 提交事务
 90          * 4. 提交事务后整个事务结束,贯穿整个事务操作的连接 走到了最后,所以需要 关闭连接
 91          * 5. 但是con.close后,con中还是有值,防止其他类开启了事务后得到这个连接对象吗,
 92          *       需要把多线程中的值移除
 93          */
 94         Connection con = t1.get();
 95         if(con == null )
 96             throw new SQLException("还没开启事务,不能提交!");        
 97         con.commit();
 98         con.close();
 99         t1.remove() ;
100     }
101     /**
102      * 事务处理三:回滚事务
103      *    获取beginTransaction提供的Connection ,调用rollback
104      * @throws SQLException 
105      */
106     public static void rollbackTransaction() throws SQLException{
107         /*
108          * 1. 获取当前线程的连接
109          * 2. 防止还没有开启事务就调用回滚事务的方法
110          * 3. 回滚事务
111          * 4. 提交事务后整个事务结束,贯穿整个事务操作的连接 走到了最后,所以需要 关闭连接
112          * 5. 但是con.close后,con中还是有值,防止其他类开启了事务后得到这个连接对象吗,
113          *       需要把多线程中的值移除
114          */
115         Connection con = t1.get();
116         if(con == null )
117             throw new SQLException("还没开启事务,不能回滚!");
118         con.rollback();
119         con.close();
120         t1.remove() ;        
121     }
122     /**
123      * 释放连接
124      *  所有Connection对象连接的关闭都要调用该方法
125      *  如果是事务专用的连接: 则不能关闭,被事务包裹的所有操作都得用同一个连接,所以其他操作还要用
126      *  如果不是事务专用,则需要关闭
127      *      
128      * @param connection
129      * @throws SQLException 
130      */
131     public static void releaseConnection(Connection connection) throws SQLException{
132         /*
133          * 1. 获取当前线程的连接
134          * 2. 本类的con==null 说明一定不是事务专用的,可以直接关闭,并不需要保存起来给别的操作用
135          * 3. 如果con!=null,说明有事务,但是不一定是同一个连接
136          *       所以判断,
137          *          1. 如果本类的连接和传递过来的连接是同一个连接,说明是同一个事务的连接,这个连接还不能关闭,
138          *               因为同事务中的其他操作还要用,事务的提交和回滚也需要用
139          *          2. 如果不是同一个连接,说明不是事务专用连接,也得关闭 
140          */
141         Connection con = t1.get();
142         if(con == null )
143             connection.close();
144         if(con != connection)
145             connection.close();
146     }
147 }

JdbcUtils_工具类

4858.com 394858.com 40

  1 package cn.kmust.jdbcDemo.utils;
  2 
  3 import java.sql.Connection;
  4 import java.sql.PreparedStatement;
  5 import java.sql.ResultSet;
  6 import java.sql.SQLException;
  7 
  8 import javax.sql.DataSource;
  9 
 10 
 11 
 12 /**
 13  * QueryRunner工具类  
 14  *    对数据库操作的辅助类
 15  * @功能   1.插入、删除、编辑
 16  *            SQL模版所需要的参数来自Dao层,获取的参数通过initParams()给SQL中的参数赋值
 17  *        2. 查询
 18  *             SQL模版所需要的参数来自Dao层,获取的参数通过initParams()给SQL中的参数赋值
 19  *             查询出的结果集封装成JavaBean返回,封装的方法是在Dao层中实现本类的 
 20  *                  ResultSetHandler<T>接口
 21  * @注意 方法都有一个没有连接对象参数的,一个有的。
 22  *            没有的方法是为了Dao层中调用不用自己添加con参数,而是通过TxQueryRunner类来添加,
 23  *                   采用 TxQueryRunner类的目的也是为了同一事务中的操作必须得用相同的连接对象                
 24  * @author ZHAOYUQIANG
 25  *
 26  */
 27 public class QueryRunner<T> {
 28     /*
 29      * 创建DataSource类型的变量 
 30      *    该与数据库连接池的池对象有关
 31      */
 32     private DataSource dataSource ;
 33     /**
 34      * 提供有参和无参的构造器
 35      *    目的是获取外界传递过来的池,赋给本类的dataSource。
 36      */
 37 
 38     public QueryRunner(DataSource dataSource) {
 39         this.dataSource = dataSource;
 40     }
 41     public QueryRunner() {
 42         super();
 43     }
 44     /**
 45      * 插入 、更改、删除   
 46      *   为了Dao层调用时不用加con参数
 47      * @param sql
 48      * @param params
 49      * @return
 50      * @throws SQLException 
 51      */
 52     public int update(String sql ,Object...params) throws SQLException{
 53         /*
 54          * 在TxQueryRunner类中复写该方法
 55          */
 56         return 0 ;
 57     }
 58     /**
 59      * 插入 、更改、删除   
 60      *    params是一个Object类型的数组
 61      * @param sql
 62      * @param params
 63      * @return
 64      * @throws SQLException 
 65      */
 66     public int update(Connection conn,String sql ,Object...params) throws SQLException{
 67         Connection con = null ;
 68         PreparedStatement pstmt = null ;    
 69         try{
 70             /*
 71              * 1. 把传递过来的连接对象赋给con,保证是同一个连接对象             
 72              * 2. 用sql来创建pstmt对象 
 73              * 3. 调用initParams给sql中的参数赋值 
 74              * 4. 执行并且返回影响的数据库表记录的行数   
 75              */
 76             con = conn;    
 77             pstmt = con.prepareStatement(sql);
 78             initParams(pstmt,params);
 79             return pstmt.executeUpdate();
 80         }catch(Exception e){
 81             throw new RuntimeException(e);
 82         }        
 83     }
 84     
 85     /**
 86      * 查询
 87      *       为了Dao层调用时不用加con参数
 88      * @param sql
 89      * @return
 90      * @throws SQLException 
 91      */
 92     public T query(String sql,ResultSetHandler<T> rsh,Object...params) throws SQLException{
 93         /*
 94          * 在TxQueryRunner类中复写该方法
 95          */
 96         return null ;
 97     }
 98     /**
 99      * 查询
100      *    通过sql和params得到一个结果集,然后把结果集给RsHandler对象的handle()方法处理。
101      *    handle()方法的作用就是把结果集(rs)变成一个对象
102      *       
103      * @param sql
104      * @return
105      */
106     public T query(Connection conn,String sql,ResultSetHandler<T> rsh,Object...params){
107         Connection con = null ;
108         PreparedStatement pstmt = null ;
109         ResultSet rs = null ;
110         try{
111             /*
112              * 1. 把传递过来的连接对象赋给con,保证是同一个连接对象
113              * 2. 用sql来创建pstmt对象     
114              * 3. 调用initParams给sql中的参数赋值
115              * 4. 执行并返回结果集的行指针
116              * 5. 调用接口的handle()方法,该结果集处理器会把rs变成一个javaBean对象
117              *       并且返回      
118              */
119             con = conn;    
120             pstmt = con.prepareStatement(sql);
121             initParams(pstmt,params);
122             rs = pstmt.executeQuery();
123             return rsh.handle(rs);
124         }catch(Exception e){
125             throw new RuntimeException(e);
126         }
127     }
128         
129     /**
130      * 用pstmt对象给sql中的参数赋值
131      *      params中存放着外界传递过来的参数
132      * @param pstmt
133      * @param params
134      * @throws SQLException 
135      */
136     public void initParams(PreparedStatement pstmt,Object...params) throws SQLException{
137         for(int i=0;i<params.length;i++){
138             pstmt.setObject(i+1, params[i]);
139         }
140     }        
141 }

QueryRunner_工具类

4858.com 414858.com 42

 1 package cn.kmust.jdbcDemo.utils;
 2 
 3 import java.sql.Connection;
 4 import java.sql.SQLException;
 5 
 6 import cn.kmust.jdbcDemo.domain.Customer;
 7 
 8 /**
 9  * TxQueryRunner工具类
10  *     继承QueryRunner,完善QueryRunner
11  * @功能  1. 重写父类中不带Connection参数的方法
12  *       2. 添加获取数据库连接对象  和 关闭连接 的功能
13  * @author ZHAOYUQIANG
14  *
15  */
16 public class TxQueryRunner extends QueryRunner {
17 
18     /**
19      * 重写父类的update方法
20      *   添加获取数据库连接对象  和 关闭连接 的功能
21      * @throws SQLException 
22      * 
23      */
24     public int update(String sql, Object... params) throws SQLException {
25         /*
26          * 1. 通过JdbcUtils直接得到连接
27          *      如果已经开启了事务,获得的这个连接就是事务开启的时创建的那个连接
28          *      如果没有开启事务,获得的这个连接就是新创建的连接
29          * 2. 执行父类方法,传递该连接对象,
30          *        因为同一个事务的多个操作必须使用相同的连接对象
31          * 3. 调用JdbcUtils的releaseConnection()释放连接
32          *        如果是事务专用连接,不会关闭
33          *        如果不是事务专用,则会关闭
34          * 4. 返回值
35          */
36         Connection con = JdbcUtils.getConnection();
37         int result = super.update(con,sql,params);        
38         JdbcUtils.releaseConnection(con);
39         return result;
40     }
41 
42     /**
43      * 重写父类的query方法
44      *   添加获取数据库连接对象  和 关闭连接 的功能
45      * @throws SQLException 
46      */
47     public Object query(String sql, ResultSetHandler rsh, Object... params) throws SQLException {
48         /*
49          * 1. 通过JdbcUtils直接得到连接
50          *      如果已经开启了事务,获得的这个连接就是事务开启的时创建的那个连接
51          *      如果没有开启事务,获得的这个连接就是新创建的连接
52          * 2. 执行父类方法,传递该连接对象,
53          *        因为同一个事务的多个操作必须使用相同的连接对象
54          * 3. 调用JdbcUtils的releaseConnection()释放连接
55          *        如果是事务专用连接,不会关闭
56          *        如果不是事务专用,则会关闭
57          * 4. 返回值
58          */
59         Connection con = JdbcUtils.getConnection();        
60         Customer result = (Customer)super.query(con,sql,rsh, params);
61         JdbcUtils.releaseConnection(con);
62         return result;
63     }
64 }

TxQueryRunner_工具类

4858.com 434858.com 44

 1 package cn.kmust.jdbcDemo.utils;
 2 
 3 import java.sql.ResultSet;
 4 import java.sql.SQLException;
 5 
 6 /**
 7  * 接口——结果集处理器  [查询的辅助方法]    
 8  * @功能   用来把结果集转换成需要的对象类型,即把查询到的结果封装到实体类对象中
 9  *          由rs---->javaBean的转换
10  *   接口的实现原则是 : 谁调用谁提供handle方法的实现
11  * @author ZHAOYUQIANG
12  * @author ZHAOYUQIANG
13  *
14  * @param <T>
15  */
16 public interface ResultSetHandler<T> {
17     public T handle(ResultSet rs)throws SQLException;
18 
19 }

ResultSetHandler_工具类

@download
项目下载

打包后的专门的工作支付——-common-dbutils.jar和itcast-tools.jar(重视、本文焦点)

commons-dbutils 是 Apache 组织提供的四个开源 JDBC
工具类库,上述自身写的QueryRunner工具类也是本身对此官方的工具类库做了多少个简单的骨干职能的抽取,当然官方的工具类库功用特别丰富。 从此今后,大家付出不必要团结编排工具类,而是导入common-dbutils.jar
来直接使用就能够 . @注意 官方网站提供的 工具类库
不包蕴TxQueryRunner和JdbcUtils工具,那多个工具依然还索要我们通力合作下手实现,不过也可以有不法提供的封装包,如传智的itcast-tools.jar
。  能够拿来平昔运用

@结果集计算机 common-dbutils包中提供了五颜六色的结果集Computer,可以管理查询到的结果集,如封装成实体类对象等。有如下的各个结果集计算机

BeanHandler 结果集为单行 构造器需要一个Class类型的参数,用来把查询到的一行结果集转换成指定类型的javaBean对象 常用 
BeanListHandler 结果集为多行 构造器也是需要一个Class类型的参数,用来把查询到的多行记录一个记录转成一个javaBean对象,多个JavaBean构成转List对象 常用
MapHandler 结果集为单行 把一行结果集转换Map对象 不常用
MapListHandler 结果集为多行 把一行记录转换成一个Map,多行就是多个Map 不常用
ScalarHandler 结果集是单行单列 它返回一个Object,多用在求一共有多少个记录上 常用

 

 

 

 

 

 

 

 

@演示 导入common-dbutils.jar 和
itcast-tools.jar(jar包在档期的顺序中,可以下载该项目找到),仍旧@使用 c3p0数据库连接池的运用 中的c3p0-config.xml 

4858.com 454858.com 46

 1 package cn.kmust.jdbc.commons.domain;
 2 /**
 3  * 实体类
 4  *    变量名字最好与数据库中对应字段名一样,便于封装操作
 5  * @author ZHAOYUQIANG
 6  *
 7  */
 8 public class Customer {
 9     private String username ; //用户
10     private int age ;  //年龄
11     private double balance ; //资金
12     public String getUsername() {
13         return username;
14     }
15     public void setUsername(String username) {
16         this.username = username;
17     }
18     public int getAge() {
19         return age;
20     }
21     public void setAge(int age) {
22         this.age = age;
23     }
24     public double getBalance() {
25         return balance;
26     }
27     public void setBalance(double balance) {
28         this.balance = balance;
29     }
30     @Override
31     public String toString() {
32         return "Customer [username=" + username + ", age=" + age + ", balance="
33                 + balance + "]";
34     }
35     public Customer(String username, int age, double balance) {
36         super();
37         this.username = username;
38         this.age = age;
39         this.balance = balance;
40     }
41     public Customer() {
42         super();
43         // TODO Auto-generated constructor stub
44     }
45     
46     
47     
48 
49 }

Customer

4858.com 474858.com 48

 1 package cn.kmust.jdbc.commons.service;
 2 
 3 import java.sql.SQLException;
 4 import java.util.List;
 5 
 6 import cn.itcast.jdbc.JdbcUtils;
 7 import cn.kmust.jdbc.commons.dao.CustomerDao;
 8 import cn.kmust.jdbc.commons.domain.Customer;
 9 
10 
11 /**
12  * service 层   处理业务
13  * @功能  1. 增加新客户
14  *       2. 转账操作  需要事务
15  *       3. 查询  BeanHandler(根据客户的username)
16  *       4. 查询  BeanListHandler 
17  *       7. 查询  ScalarHandler
18  *  关于Map的结果集处理器不常用,就不再演示
19  * @author ZHAOYUQIANG
20  *
21  */
22 public class CustomerService {
23     /*
24      * 依赖CustomerDao
25      */
26     CustomerDao cstmDao = new CustomerDao();
27     /**
28      * 增加新客户
29      * @param cstm
30      * @throws SQLException 
31      */
32     public void add(Customer cstm) throws SQLException{
33         cstmDao.add(cstm);
34     }
35 
36     /**
37      * 转账
38      *   A用户转给B用户money钱
39      * @param nameA
40      * @param nameB
41      * @param money
42      * @throws Exception 
43      */
44     public void transfer(String nameA,String nameB,double money) throws Exception{
45         try{
46             /*
47              * 1. 事务1 : 开启事务
48              * 2. 处理业务
49              * 3. 事务2: 提交事务
50              * 4. 事务3 :回滚事务
51              */
52             JdbcUtils.beginTransaction();
53             cstmDao.transfer(nameA,-money);
54             cstmDao.transfer(nameB,money);
55             JdbcUtils.commitTransaction();
56         }catch(Exception e){
57             try{
58                 JdbcUtils.rollbackTransaction();
59             }catch(SQLException e1){        
60             }
61             throw e;
62         }        
63     }
64     /**
65      * 查询  BeanHandler(根据客户的username)
66      * @param name
67      * @return
68      * @throws SQLException 
69      */
70     public Customer query(String name) throws SQLException{
71         Customer cstm = cstmDao.query01(name);
72         return cstm ;
73         
74     }
75     /**
76      * 查询   BeanListHandler 
77      * @return
78      * @throws SQLException
79      */
80     public List<Customer> queryAll() throws SQLException{
81         List<Customer> cstmList= cstmDao.queryAll02();
82         return cstmList;
83     } 
84     /**
85      * 查询  ScalarHandler
86      * @return
87      * @throws SQLException
88      */
89     public Number queryAllNum() throws SQLException{
90         Number cnt= cstmDao.queryAllNum();
91         return cnt ;
92     }
93     
94 }

CustomerService

4858.com 494858.com 50

  1 package cn.kmust.jdbc.commons.dao;
  2 
  3 import java.sql.ResultSet;
  4 import java.sql.SQLException;
  5 import java.util.List;
  6 import java.util.Map;
  7 
  8 import org.apache.commons.dbutils.QueryRunner;
  9 import org.apache.commons.dbutils.ResultSetHandler;
 10 import org.apache.commons.dbutils.handlers.BeanHandler;
 11 import org.apache.commons.dbutils.handlers.BeanListHandler;
 12 import org.apache.commons.dbutils.handlers.MapHandler;
 13 import org.apache.commons.dbutils.handlers.MapListHandler;
 14 import org.apache.commons.dbutils.handlers.ScalarHandler;
 15 
 16 import cn.itcast.jdbc.TxQueryRunner;
 17 import cn.kmust.jdbc.commons.domain.Customer;
 18 
 19 
 20 /**
 21  *dao层  
 22  *    对数据库的操作 
 23  * @author ZHAOYUQIANG
 24  *
 25  */
 26 public class CustomerDao {
 27     /*
 28      * QueryRunner类是已经写好的类,里面有对数据库的操作方法,如query、update、delete等
 29      *    TxQueryRunner继承了QueryRunner类,添加了Dao层对con的关闭
 30      */
 31     private QueryRunner qr = new TxQueryRunner();
 32     /**
 33      * 添加新客户
 34      * @param cstm
 35      * @throws SQLException 
 36      */
 37     public void add(Customer cstm) throws SQLException {
 38         /*
 39          * 1. 创建TxQueryRunner对象 
 40          * 2. 准备SQL模版     
 41          * 3. 将参数存入参数数组 
 42          * 4. 调用TxQueryRunner类中update方法  进行插入操作
 43          */
 44         
 45         String sql ="insert into t_customer values(?,?,?)";
 46         Object[] params = {cstm.getUsername(),
 47                            cstm.getAge(),
 48                            cstm.getBalance()};
 49         qr.update(sql, params);                    
 50     }
 51     /**
 52      * 转账 
 53      * @param nameA
 54      * @param d
 55      * @throws SQLException 
 56      */
 57     public void transfer(String name, double money) throws SQLException {
 58         /*
 59          * 1. 创建TxQueryRunner对象 
 60          * 2. 准备SQL模版     
 61          * 3. 将参数存入参数数组 
 62          * 4. 调用TxQueryRunner类中update方法  进行更改操作
 63          */
 64         String sql = "update t_customer set balance=balance+? where username=?";
 65         Object[] params = {money,name};
 66         qr.update(sql,params);        
 67     }
 68     /**
 69      * 查询  (按照username查询) 
 70      * 结果集处理器1.  BeanHandler演示  查询结果是一个记录 
 71      *      结果集处理器把返回的查询结果封装成JavaBean
 72      * @param name
 73      * @return  
 74      * @throws SQLException 
 75      */
 76     public Customer query01(String name) throws SQLException {
 77         /*
 78          * 1. 创建TxQueryRunner对象 
 79          * 2. 准备SQL模版     
 80          * 3. 将参数存入参数数组 
 81          * 4. 调用query(sql,BeanHandler,params),并且把查询结果封装到Customer对象中
 82          * 5. 返回对象
 83          */
 84         String sql ="select * from t_customer where username=?";
 85         Object[] params = {name} ;
 86         Customer cstm =qr.query(sql,
 87                  new BeanHandler<Customer>(Customer.class),params);
 88         return cstm ;
 89     }   
 90     /**
 91      * 查询  (查询所有用户,查询结果返回的是多个记录)
 92      *  结果集处理器2.  BeanListHandler演示  
 93      *     使用封装好的结果集处理器把返回的结果一条封装成一个Customer对象,多个对象构成List集合
 94      * @param name
 95      * @return 
 96      * @throws SQLException 
 97      */
 98     public List<Customer> queryAll02() throws SQLException {
 99         /*
100          * 1. 创建TxQueryRunner对象 
101          * 2. 准备SQL模版     
102          * 3. 将参数存入参数数组 
103          * 4. 调用query(sql,BeanListHandler),
104          *        并且把查询结果一条记录封装到一个对象中,多个对象构成一个List集合
105          * 5. 返回对象集合
106          */
107         String sql ="select * from t_customer ";        
108         List<Customer> cstmList =  qr.query(sql,
109                  new BeanListHandler<Customer>(Customer.class));
110         return cstmList ;
111     } 
112     /**
113      * 查询  按照username查询 (查询结果是一个记录)
114      *  结果集处理器3.   MapHandler演示  
115      *     使用封装好的结果集处理器把返回的一条记录封装成一个Map
116      * @param name
117      * @return
118      * @throws SQLException 
119      */
120     public Map query03(String name) throws SQLException {
121         /*
122          * 1. 创建TxQueryRunner对象 
123          * 2. 准备SQL模版     
124          * 3. 将参数存入参数数组 
125          * 4. 调用query(sql,Map,params),并且把查询结果封装到一个map中
126          * 5. 返回Map对象
127          */
128         String sql ="select * from t_customer where username=?";
129         Object[] params = {name} ;
130         Map cstmMap =qr.query(sql,
131                 new MapHandler(),params);
132         return cstmMap ;
133     }
134     /**
135      * 查询   所有记录 (查询结果返回的是多个记录)
136      * 结果集处理器4.   MapListHandler演示  
137      *   使用封装好的结果集处理器把返回的结果一条封装成一个Map,多个Map构成List集合
138      * @param name
139      * @return
140      * @throws SQLException 
141      */
142     public List<Map<String,Object>> queryAll04() throws SQLException {
143         /*
144          * 1. 创建TxQueryRunner对象 
145          * 2. 准备SQL模版     
146          * 3. 将参数存入参数数组 
147          * 4. 调用query(sql,MapListHandler),并且把查询结果一条封装到一个map,多个map构成一个List集合
148          * 5. 返回MapList对象
149          */
150         String sql ="select * from t_customer";
151         List<Map<String,Object>> cstmMapList =qr.query(sql,
152                 new MapListHandler());
153         return cstmMapList ;
154     }
155     /**
156      * 查询 所有记录的行数    (返回的是一个数)
157      * 
158      * 结果集处理器5.   ScalarHandler演示  
159      *    
160      * @param name
161      * @return
162      * @throws SQLException 
163      */
164     public Number queryAllNum() throws SQLException {
165         /*
166          * 1. 创建TxQueryRunner对象 
167          * 2. 准备SQL模版     
168          * 3. 将参数存入参数数组 
169          * 4. 调用query(sql,ScalarHandler)
170          *       查询的结果先放在Number中,转成int
171          * 5. 返回Number对象
172          */
173         String sql ="select count(*) from t_customer";
174         Number cnt =(Number)qr.query(sql,
175                 new ScalarHandler());
176         int c = cnt.intValue();
177 //        long c= cnt.longValue();
178         return c;
179     }
180 }

CustomerDao

4858.com 514858.com 52

 1 package cn.kmust.jdbc.commons.Test;
 2 
 3 import java.sql.SQLException;
 4 import java.util.List;
 5 
 6 import org.junit.Test;
 7 
 8 import cn.kmust.jdbc.commons.domain.Customer;
 9 import cn.kmust.jdbc.commons.service.CustomerService;
10 
11 /**
12  * 测试类
13  * @功能 1. 测试添加
14  *      2. 测试查找(条件查找、全部查找、查找所有记录行数)
15  *      3. 测试转账(事务)
16  * @author ZHAOYUQIANG
17  *
18  */
19 public class TestDemo {
20     /*
21      * 依赖Service
22      */
23     CustomerService cstmService = new CustomerService();
24     /**
25      * 测试   添加新客户
26      * @throws SQLException
27      */
28     @Test
29     public void test1() throws SQLException{
30         Customer cstm1 = new Customer("王五",18,1000.000);
31         Customer cstm2 = new Customer("赵六",98,1000.000);
32         cstmService.add(cstm1);
33         cstmService.add(cstm2);
34     }
35     /**
36      * 测试  转账
37      * @throws Exception
38      */
39     @Test
40     public void test2() throws Exception{
41         cstmService.transfer("张三", "李四", 100.00);
42     }
43     /**
44      * 测试 条件查询
45      * @throws SQLException
46      */
47     @Test
48     public void test3() throws SQLException{
49         Customer cstm = cstmService.query("张三");
50         System.out.println(cstm.toString());
51 
52     }
53     /**
54      * 测试 全部查询
55      * @throws SQLException
56      */
57     @Test
58     public void test4() throws SQLException{
59         List<Customer> cstmList = cstmService.queryAll();
60         for(int i =0 ;i<cstmList.size();i++){
61             System.out.println(cstmList.get(i).toString());
62         }
63 
64     }
65     /**
66      * 测试 查询记录数
67      * @throws SQLException
68      */
69     @Test
70     public void test5() throws SQLException{
71         Number num = cstmService.queryAllNum();
72         System.out.println(num);
73 
74     }
75 
76 }

TestDemo

 

也足以批量丰裕数据

 1 private QueryRunner qr = new TxQueryRunner();
 2     /**
 3      * 添加新客户
 4      *   批处理
 5      * @param cstm,num是批量插入记录的行数
 6      * @throws SQLException 
 7      */
 8     public void add(Customer cstm , int num) throws SQLException {
 9         /*
10          * 1. 创建TxQueryRunner对象 
11          * 2. 准备SQL模版     
12          * 3. 将参数存入参数数组 
13          * 4. 调用TxQueryRunner类中batch方法  进行插入操作
14          */
15         String sql ="insert into t_customer values(?,?,?)";
16         Object[][] params = new Object[num][];
17         for(int i=0;i<params.length;i++){
18             params[i]=new Object[]{cstm.getUsername()+i,
19                                    cstm.getAge()+i,
20                                    cstm.getBalance()};
21         }
22 //        Object[] params = {cstm.getUsername(),
23 //                           cstm.getAge(),
24 //                           cstm.getBalance()};
25         qr.batch(sql, params);                    
26     }

 

 

@download 项目下载

 


 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有