zoukankan      html  css  js  c++  java

  • JDBC连接池和DBUtils

    C3P0连接池

    创建C3P0连接池的工具类
    * 连接的规范接口:
    * javax.sql.DataSource接口
    * 接口的实现类对象
    * ComboPooledDataSource
    * 成员位置创建ComboPooledDataSource对象
    * 使用静态代码块给ComboPooledDataSource设置4大数据量连接信息
    * 创建一个静态方法返回Connection对象
    * 创建一个静态方法释放资源

     1 public class C3P0Utils {
 2     //成员位置创建ComboPooledDataSource对象
 3     private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
 4     
 5     //使用静态代码块给ComboPooledDataSource设置4大数据量连接信息
 6     static{
 7         try {
 8             dataSource.setDriverClass("com.mysql.jdbc.Driver");
 9             dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mybase4");
10             dataSource.setUser("root");
11             dataSource.setPassword("root");
12         } catch (Exception e) {
13             throw new RuntimeException("设置连接信息失败!");
14         }
15     }
16     
17     //创建一个静态方法返回Connection对象
18     public static Connection getConnection(){
19         try {
20             return dataSource.getConnection();
21         } catch (SQLException e) {
22             throw new RuntimeException("获取数据库连接信息失败!");
23         }
24     }
25     
26     //定义一个释放资源的方法
27         public static void close(ResultSet rs,Statement stat,Connection conn){
28             if(rs!=null){
29                 try {
30                     rs.close();
31                 } catch (SQLException e) {
32                     e.printStackTrace();
33                 }
34             }
35             if(stat !=null){
36                 try {
37                     stat.close();
38                 } catch (SQLException e) {
39                     e.printStackTrace();
40                 }
41             }
42             if(conn != null){
43                 try {
44                     conn.close();
45                 } catch (SQLException e) {
46                     e.printStackTrace();
47                 }
48             }
49         }
50 }

    创建读取XML配置文件的C3P0工具类

     1 public class C3P0UtilsReadXML {
 2     //成员位置创建ComboPooledDataSource对象
 3     private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
 4     
 5     //使用静态代码块给ComboPooledDataSource设置4大数据量连接信息
 6     /*static{
 7         try {
 8             dataSource.setDriverClass("com.mysql.jdbc.Driver");
 9             dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mybase4");
10             dataSource.setUser("root");
11             dataSource.setPassword("root");
12         } catch (Exception e) {
13             throw new RuntimeException("设置连接信息失败!");
14         }
15     }*/
16     
17     //创建一个返回ComboPooledDataSource的方法
18     public static DataSource getDataSource(){
19         return dataSource;
20     }
21     
22     //创建一个静态方法返回Connection对象
23     public static Connection getConnection(){
24         try {
25             return dataSource.getConnection();
26         } catch (SQLException e) {
27             throw new RuntimeException("获取数据库连接信息失败!");
28         }
29     }
30     
31     //定义一个释放资源的方法
32         public static void close(ResultSet rs,Statement stat,Connection conn){
33             if(rs!=null){
34                 try {
35                     rs.close();
36                 } catch (SQLException e) {
37                     e.printStackTrace();
38                 }
39             }
40             if(stat !=null){
41                 try {
42                     stat.close();
43                 } catch (SQLException e) {
44                     e.printStackTrace();
45                 }
46             }
47             if(conn != null){
48                 try {
49                     conn.close();
50                 } catch (SQLException e) {
51                     e.printStackTrace();
52                 }
53             }
54         }
55 }

    DBCP连接池

    创建DBCP连接池的工具类
    * 连接的规范接口:
    * javax.sql.DataSource接口
    * 接口的实现类对象
    * BasicDataSource
    * 重写getConnection方法

     1 public class DBCPUtils {
 2     //创建连接池的实现类对象
 3     private static BasicDataSource dataSource = new BasicDataSource();
 4     
 5     //设置连接数据库的4大变量,使用BasicDataSource中的set方法设置
 6     static{
 7         //设置注册的驱动信息
 8         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
 9         //设置Url
10         dataSource.setUrl("jdbc:mysql://localhost:3306/mybase4");
11         //设置用户名
12         dataSource.setUsername("root");
13         //设置密码
14         dataSource.setPassword("root");
15         //可选信息
16         //dataSource.setInitialSize(100);
17         //dataSource.setMaxActive(1000);
18     }
19     
20     //创建获取数据库连接对象的方法
21     public static Connection getConnection(){
22         try {
23             return dataSource.getConnection();
24         } catch (SQLException e) {
25             throw new RuntimeException("获取数据库连接对象失败");
26         }
27     }
28     
29     //定义一个释放资源的方法
30     public static void  close(ResultSet rs,Statement stat,Connection conn){
31         if(rs!=null){
32             try {
33                 rs.close();
34             } catch (SQLException e) {
35                 e.printStackTrace();
36             }
37         }
38         if(stat !=null){
39             try {
40                 stat.close();
41             } catch (SQLException e) {
42                 e.printStackTrace();
43             }
44         }
45         if(conn != null){
46             try {
47                 conn.close();
48             } catch (SQLException e) {
49                 e.printStackTrace();
50             }
51         }
52     }
53 }

    读取配置文件的方式

     1 /*
 2  * 创建DBCP连接池工具类
 3  * 使用读取配置文件的方式
 4  * DBCP中有一个工厂类BasicDataSourceFactory
 5  * 工厂类中有一个静态方法
 6  * static DataSource createDataSource(Properties prop)
 7  * 此方法返回的就是DataSource接口的实现类对象BasicDataSource
 8  * 
 9  * 创建Propertis集合+IO技术读取配置文件
10  * 把配置文件传入BasicDataSourceFactory静态方法createDataSource中
11  */
12 public class DBCPUtilsReadConfig {
13     //创建DataSource变量
14     private static DataSource dataSource;
15     
16     static{
17         try {
18             //创建Propertis集合+IO技术读取配置文件
19             //使用类加载器,扫描包下的文件
20             InputStream is = DBCPUtilsReadConfig.class.getClassLoader()
21                     .getResourceAsStream("dbcpconfig.properties");
22             //创建Propertis集合
23             Properties prop = new Properties();
24             prop.load(is);
25             //把配置文件传入BasicDataSourceFactory静态方法createDataSource中
26             dataSource = BasicDataSourceFactory.createDataSource(prop);
27         } catch (Exception e) {
28             throw new RuntimeException("读取配置文件失败");
29         }
30     }
31     
32     //创建获取数据库连接对象的方法
33     public static Connection getConnection(){
34         try {
35             return dataSource.getConnection();
36         } catch (SQLException e) {
37             throw new RuntimeException("获取数据库连接对象失败");
38         }
39     }
40     
41     //定义一个释放资源的方法
42     public static void  close(ResultSet rs,Statement stat,Connection conn){
43         if(rs!=null){
44             try {
45                 rs.close();
46             } catch (SQLException e) {
47                 e.printStackTrace();
48             }
49         }
50         if(stat !=null){
51             try {
52                 stat.close();
53             } catch (SQLException e) {
54                 e.printStackTrace();
55             }
56         }
57         if(conn != null){
58             try {
59                 conn.close();
60             } catch (SQLException e) {
61                 e.printStackTrace();
62             }
63         }
64     }
65 }


    * 使用DBUtils工具类对数据库表进行增删改查
    * DBUtils工具类作用:简化JDBC的开发(6步)
    *
    * DBUtils有3个核心类
    * 1.QueryRunner:使用QueryRunner中的方法对数据库进行增删改查
    * 2.DbUtils:提供了大量的释放资源的方法
    * 3.ResultSetHandler接口:提供了处理查询结果集的方法
    *
    * QueryRunner类
    * 构造方法:
    * QueryRunner() 空参数构造方法
    * 调用更新和查询方法的时候,需要传入Connection对象
    * QueryRunner(DataSource ds) 带DataSource数据库连接池的构造方法
    * 调用更新和查询方法的时候QueryRunner会自动从DataSource实现类对象中获取数据库连接对象,使用完毕会自动归还
    * 成员方法:
    * 执行执行增删改的成员方法
    * int update(Connection conn, String sql, Object... params)用来执行增删改的SQL
    * int update(String sql, Object... params) 用来执行增删改的SQL
    * 参数:
    * Connection conn:数据库连接对象
    * String sql:拼接的sql语句,可以使用?占位符
    * Object... params:?占位符的实际参数,可以使用Object[]
    * 返回值:
    * int:执行的有效行数
    * 执行执行查询的成员方法
    * <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
    * <T> T query(String sql, ResultSetHandler<T> rsh, Object... params)
    * 参数:
    * Connection conn:数据库连接对象
    * String sql:拼接的sql语句,可以使用?占位符
    * Object... params:?占位符的实际参数,可以使用Object[]
    * ResultSetHandler<T> rsh:用来存储查询之后的结果集,可以传入ResultSetHandler9种实现类对象
    * 返回值:
    * <T> T:传入的ResultSetHandler实现类不同,返回的结果集也不同,使用泛型,传入什么结果集,就返回对应的类型

     1 public class Demo01DBUtils {
 2     //创建QueryRunner对象,构造方法中传入连接池的实现类对象
 3     QueryRunner qr = new QueryRunner(C3P0UtilsReadXML.getDataSource());
 4     
 5     /*
 6      * 使用QueryRunner,对数据库表进行删除数据
 7      */
 8     @Test
 9     public void delete(){
10         try {
11             //拼接增加的sql语句
12             String sql = "DELETE FROM category WHERE cid=?";
13             //调用QueryRunner中update方法执行sql语句
14             //创建对象数据,储存?占位符的实际参数
15             //Object[] parmars = {"洗",10};
16             int row = qr.update(sql, 7);
17             System.out.println(row);
18         } catch (Exception e) {
19             System.out.println(e);
20         }
21     }
22     
23     /*
24      * 使用QueryRunner,对数据库表进行修改数据
25      */
26     @Test
27     public void update(){
28         try {
29             //拼接增加的sql语句
30             String sql = "UPDATE category SET cname=? WHERE cid=?";
31             //调用QueryRunner中update方法执行sql语句
32             //创建对象数据,储存?占位符的实际参数
33             Object[] parmars = {"洗",10};
34             int row = qr.update(sql, parmars);
35             System.out.println(row);
36         } catch (Exception e) {
37             System.out.println(e);
38         }
39     }
40     
41     /*
42      * 使用QueryRunner,对数据库表进行增加(插入)数据
43      */
44     @Test
45     public void insert(){
46         try {
47             //拼接增加的sql语句
48             String sql = "INSERT INTO category(cname) VALUES(?)";
49             //调用QueryRunner中update方法执行sql语句
50             int row = qr.update(sql, "玩具");
51             System.out.println(row);
52         } catch (Exception e) {
53             System.out.println(e);
54         }
55     }
56 }

    使用QueryRunner对数据库表进行查询的九种查询方式

      1 /*
  2  * 使用QueryRunner对数据库表进行查询
  3  * <T> T query(String sql, ResultSetHandler<T> rsh, Object... params)    
  4  */
  5 public class Demo02DBUtils {
  6     //创建QueryRunner对象,构造方法中传入数据库连接池的实现类
  7     QueryRunner qr = new QueryRunner(C3P0UtilsReadXML.getDataSource());
  8     
  9     /*
 10      * 第九种查询方式:使用KeyedHandler(Map嵌套Map)
 11      * KeyedHandler会把结果集的每一行数据封装到Map集合中
 12      *     key:字符串类型列名
 13      *     value:列名对应的值(不同的列,数据类型不同,value使用Object类型)
 14      * 多个Map集合存储到另外一个Map集合中
 15      *     key:指定的字符串列名,不指定则默认使用第一列
 16      *     value:传入存储每行数据的Map集合
 17      * 
 18      * 构造方法:
 19      *     KeyedHandler() 不指定列名
 20      *     KeyedHandler(int columnIndex) 指定列号1,2,3,4
 21      *     KeyedHandler(String columnName) 指定字符串格式列名
 22      */
 23     @Test
 24     public void keyedHandler(){
 25         try {
 26             //拼接sql语句
 27             String sql = "SELECT * FROM category";
 28             //调用QueryRunner中的query方法,结果集使用KeyedHandler
 29             //Map<Object,Map<String,Object>> mapmap = qr.query(sql, new KeyedHandler("cid"));
 30             Map<Object,Map<String,Object>> mapmap = qr.query(sql, new KeyedHandler("cname"));
 31             //遍历Map集合取出存储每一行数据的Map集合
 32             for (Object obj: mapmap.keySet()) {
 33                 //根据key取出值存储每一行数据的Map集合
 34                 Map<String,Object> map = mapmap.get(obj);
 35                 //遍历Map集合
 36                 for(String key : map.keySet()){
 37                     System.out.print(obj+":"+key+"..."+map.get(key)+"	");
 38                 }
 39                 //打印完每一行数据之后换行
 40                 System.out.println();
 41             }
 42         } catch (Exception e) {
 43             System.out.println(e);
 44         }
 45     }
 46     
 47     /*
 48      * 第八种查询方式:使用ScalarHandler(重点)
 49      * ScalarHandler用于执行返回单个数据的sql语句
 50      * 使用聚合函数查询的结果都是单个数据
 51      * 或者查询某一行的某一个字段
 52      */
 53     @Test
 54     public void scalarHandler(){
 55         try {
 56             //拼接sql语句
 57             String sql = "SELECT SUM(cid) FROM category";
 58             sql = "SELECT cname FROM category WHERE cid=?";
 59             //调用QueryRunner中的query方法,结果集使用ScalarHander
 60             //返回的值的数据类型不确定,使用Object类型
 61             Object obj = qr.query(sql, new ScalarHandler(),2);
 62             System.out.println(obj);
 63         } catch (Exception e) {
 64             System.out.println(e);
 65         }
 66     }
 67     
 68     /*
 69      * 第七种查询方式:使用MapListHandler
 70      * 1.MapListHandler会把多条数据,存储到多个Map集合中
 71      *     key:字符串类型列名
 72      *     value:列名对应的值(不同的列,数据类型不同,value使用Object类型)
 73      * 2.会把多个Map集合存储List集合中
 74      */
 75     @Test
 76     public void mapListHandler(){
 77         try {
 78             //拼接查询sql语句
 79             String sql = "SELECT * FROM category";
 80             //调用QueryRunner中的query方法执行查询sql语句,结果集传入MapListHandler
 81             List<Map<String,Object>> list = qr.query(sql, new MapListHandler());
 82             //遍历List集合,取出Map集合
 83             for (Map<String, Object> map : list) {
 84                 //遍历Map集合
 85                 for(String key: map.keySet()){
 86                     System.out.print(key+"..."+map.get(key)+"	");
 87                 }
 88                 System.out.println();//打印完每行数据之后换行
 89             }
 90         } catch (Exception e) {
 91             System.out.println(e);
 92         }
 93     }
 94     
 95     /*
 96      * 第六种查询方式:使用MapHandler
 97      * MapHandler把结果集的第一行数据存储Map集合中
 98      *     key:字符串类型列名
 99      *     value:列名对应的值(不同的列,数据类型不同,value使用Object类型)
100      */
101     @Test
102     public void mapHandler(){
103         try {
104             //拼接查询sql语句
105             String sql = "SELECT * FROM category";
106             //调用QueryRunner中的query方法执行查询sql语句,结果集传入MapHandler
107             Map<String,Object> map = qr.query(sql, new MapHandler());
108             //使用keySet遍历Map集合
109             Set<String> set = map.keySet();
110             for (String key : set) {
111                 //通过key使用get方法获取value
112                 Object value = map.get(key);
113                 System.out.print(key+"..."+value+" ");
114             }
115         } catch (Exception e) {
116             System.out.println(e);
117         }
118     }
119     
120 
121     /*
122      * 第五种查询方式:使用ColumnListHandler
123      * ColumnListHandler会把结果集中指定列的数据封装到一个List集合中
124      * 如果不指定列,则默认使用第一列数据存储到List集合中
125      * ColumnListHandler() 
126      * ColumnListHandler(int columnIndex) 列号1,2,3,4
127      * ColumnListHandler(String columnName) 列名
128      */
129     @Test
130     public void columnListHandler(){
131         try {
132             //拼接查询sql语句
133             String sql = "SELECT * FROM category";
134             //调用QueryRunner中的query方法执行查询sql语句,结果集传入ColumnListHandler
135             //返回一个List集合,因为列的数据类型不同,所有元素使用Object类型
136             List<Object> list = qr.query(sql, new ColumnListHandler("cname"));
137             for (Object object : list) {
138                 System.out.println(object);
139             }
140         } catch (Exception e) {
141             System.out.println(e);
142         }
143     }
144     
145     /*
146      * 第四种查询方式:使用BeanListHandler(重点)
147      * BeanListHandler会把多个条数据封装到多个JavaBean对象中
148      * 多个JavaBean对象存储到List集合中
149      * 
150      * 注意:
151      *      JavaBean中必须有空参数构造方法
152      */
153     @Test
154     public void beanListHandler(){
155         try {
156             //拼接查询sql语句
157             String sql = "SELECT * FROM category";
158             //调用QueryRunner中的query方法执行查询sql语句,结果集传入BeanListHandler
159             List<Category> list = qr.query(sql, new BeanListHandler<>(Category.class));
160             //遍历存储Category的list集合
161             for (Category category : list) {
162                 System.out.println(category);
163             }
164         } catch (Exception e) {
165             System.out.println(e);
166         }
167     }
168     
169     /*
170      * 第三种查询方式:使用BeanHandler(重点)
171      * BeanHandler会把结果集的第一条数据,封装到指定的JavaBean对象中
172      * 构造方法:
173      *     BeanHandler(Class<T> type) 传递JavaBean对象的class文件对象
174      *         BeanHandler内部会根据传递的class文件对象使用反射技术创建JavaBean对象,把查询的结果集中第一行数据存储到JavaBean中
175      *     相当于
176      *         Category c = new Category();
177      *         c.setXXX(xxx);
178      *         c.setXXX(xxx);
179      *         c.setXXX(xxx);
180      *  注意:
181      *      JavaBean中必须有空参数构造方法
182      */
183     @Test
184     public void beanHandler(){
185         try {
186             //拼接查询sql语句
187             String sql = "SELECT * FROM category";
188             //调用QueryRunner中的query方法执行查询sql语句,结果集传入BeanHandler
189             Category cate = qr.query(sql, new BeanHandler<>(Category.class));
190             System.out.println(cate);
191         } catch (Exception e) {
192             System.out.println(e);
193         }
194     }
195     
196     /*
197      * 第二种查询方式:使用ArrayListHandler
198      * ArrayListHandler中会把多条结果封装到多个对象数组中
199      * 一个对象数组封装一行数据
200      * 多个对象数组需要存储到list集合中
201      */
202     @Test
203     public void arrrayListHandler(){
204         try {
205             //拼接查询sql语句
206             String sql = "SELECT * FROM category where cid = ?";
207             sql = "SELECT * FROM category where cid in(?,?)";
208             //调用QueryRunner中的query方法执行查询sql语句,传入ArrayListHandler结果集
209             List<Object[]> list = qr.query(sql, new ArrayListHandler(), 1,3);
210             //遍历集合
211             for (Object[] objects : list) {
212                 //遍历对象数组
213                 for (Object obj : objects) {
214                     System.out.print(obj+" ");
215                 }
216                 System.out.println();//换行
217             }
218         } catch (Exception e) {
219             System.out.println(e);
220         }
221     }
222     
223     /*
224      * 第一种查询方式:使用ArrayHandler
225      * ArrayHandler会把结果集第一条数据封装到一个对象(Object)数组中
226      * 数组中的每一个元素,就是第一条数据数据的每一列的值
227      */
228     @Test
229     public void arrayHandler(){
230         try {
231             //拼接查询sql语句
232             String sql = "SELECT * FROM category";
233             //调用QueryRunner中的query方法执行查询sql语句,传入ArrayHandler结果集
234             Object[] objs = qr.query(sql, new ArrayHandler());
235             //遍历数组
236             for (Object obj : objs) {
237                 System.out.print(obj+" ");
238             }
239         } catch (Exception e) {
240             System.out.println(e);
241         }
242     }
243 }
  • 相关阅读:
    赫尔维茨公式
    从解析几何的角度分析二次型
    Struts 1 Struts 2
    记一次服务器被入侵的调查取证
    契约式设计 契约式编程 Design by contract
    lsblk df
    Linux Find Out Last System Reboot Time and Date Command 登录安全 开关机 记录 帐号审计 历史记录命令条数
    Infrastructure for container projects.
    更新文档 版本控制 多版本并发控制
    Building Microservices: Using an API Gateway
  • 原文地址：https://www.cnblogs.com/caigq/p/7049258.html
Copyright © 2011-2022 走看看