数据库进阶及一些开源工具包的使用

1、在我们实际应用开发中，我们通常将数据库层和其它模块分离开来，这样有利于维护，故在此我给出一个操作数据工具包DBUtils类：

DBUtils

　　该类返回一个连接对象，有利于后面我们对数据库进行层删改查

2、关闭资源的工具类

 1 package cn.itcast.jdbcutil;
 2 /*
 3  *  实现JDBC的工具类
 4  *  定义方法,直接返回数据库的连接对象
 5  *  
 6  *  写关闭方法
 7  */
 8 
 9 import java.sql.Connection;
10 import java.sql.DriverManager;
11 import java.sql.ResultSet;
12 import java.sql.SQLException;
13 import java.sql.Statement;
14 
15 public class JDBCUtils {
16     private JDBCUtils(){}
17     private static Connection con ;
18     
19     static{
20         try{
21             Class.forName("com.mysql.jdbc.Driver");
22             String url = "jdbc:mysql://localhost:3306/mybase";
23             String username="root";
24             String password="123";
25             con = DriverManager.getConnection(url, username, password);
26         }catch(Exception ex){
27             throw new RuntimeException(ex+"数据库连接失败");
28         }
29     }
30     
31     /*
32      * 定义静态方法,返回数据库的连接对象
33      */
34     public static Connection getConnection(){
35         return con;
36     }
37     
38     
39     public static void close(Connection con,Statement stat){
40          
41          if(stat!=null){
42              try{
43                  stat.close();
44              }catch(SQLException ex){}
45          }
46          
47          if(con!=null){
48              try{
49                  con.close();
50              }catch(SQLException ex){}
51          }
52          
53     }
54     
55     
56     public static void close(Connection con,Statement stat , ResultSet rs){
57          if(rs!=null){
58              try{
59                  rs.close();
60              }catch(SQLException ex){}
61          }
62          
63          if(stat!=null){
64              try{
65                  stat.close();
66              }catch(SQLException ex){}
67          }
68          
69          if(con!=null){
70              try{
71                  con.close();
72              }catch(SQLException ex){}
73          }
74          
75     }
76 }
View Code

3、使用apache的DBUtils工具包操作数据库

  1 package cn.itcast.demo2;
  2 
  3 import java.sql.Connection;
  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.handlers.ArrayHandler;
 10 import org.apache.commons.dbutils.handlers.ArrayListHandler;
 11 import org.apache.commons.dbutils.handlers.BeanHandler;
 12 import org.apache.commons.dbutils.handlers.BeanListHandler;
 13 import org.apache.commons.dbutils.handlers.ColumnListHandler;
 14 import org.apache.commons.dbutils.handlers.MapHandler;
 15 import org.apache.commons.dbutils.handlers.MapListHandler;
 16 import org.apache.commons.dbutils.handlers.ScalarHandler;
 17 
 18 import cn.itcast.domain.Sort;
 19 import cn.itcast.jdbcutil.JDBCUtilsConfig;
 20 
 21 /*
 22  * QueryRunner数据查询操作:
 23  *   调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r, Object..params)
 24  *   ResultSetHandler r 结果集的处理方式,传递ResultSetHandler接口实现类
 25  *   Object..params SQL语句中的?占位符
 26  *   
 27  *   注意: query方法返回值,返回的是T 泛型, 具体返回值类型,跟随结果集处理方式变化
 28  */
 29 public class QueryRunnerDemo1 {
 30     private static Connection con = JDBCUtilsConfig.getConnection();
 31     public static void main(String[] args) throws SQLException{
 32 //        arrayHandler();
 33 //        arrayListHandler();
 34 //        beanHandler();
 35 //        beanListHander();
 36 //        columnListHandler();
 37 //        scalarHandler();
 38 //        mapHandler();
 39 //        mapListHandler();
 40     }
 41     /*
 42      *  结果集第八种处理方法,MapListHandler
 43      *  将结果集每一行存储到Map集合,键:列名,值:数据
 44      *  Map集合过多,存储到List集合
 45      */
 46     public static void mapListHandler()throws SQLException{
 47         QueryRunner qr = new QueryRunner();
 48         String sql = "SELECT  * FROM sort";
 49         //调用方法query,传递结果集实现类MapListHandler
 50         //返回值List集合, 存储的是Map集合
 51         List<Map<String,Object>> list = qr.query(con, sql, new MapListHandler());
 52         //遍历集合list
 53         for( Map<String,Object> map : list ){
 54             for(String key : map.keySet()){
 55                 System.out.print(key+"..."+map.get(key));
 56             }
 57             System.out.println();
 58         }
 59         
 60     }
 61     
 62     /*
 63      *  结果集第七种处理方法,MapHandler
 64      *  将结果集第一行数据,封装到Map集合中
 65      *  Map<键,值> 键:列名  值:这列的数据
 66      */
 67     public static void mapHandler()throws SQLException{
 68         QueryRunner qr = new QueryRunner();
 69         String sql = "SELECT  * FROM sort";
 70         //调用方法query,传递结果集实现类MapHandler
 71         //返回值: Map集合,Map接口实现类, 泛型
 72         Map<String,Object> map = qr.query(con, sql, new MapHandler());
 73         //遍历Map集合
 74         for(String key : map.keySet()){
 75             System.out.println(key+".."+map.get(key));
 76         }
 77     }
 78     
 79     
 80     /*
 81      *  结果集第六种处理方法,ScalarHandler
 82      *  对于查询后,只有1个结果
 83      */
 84     public static void scalarHandler()throws SQLException{
 85         QueryRunner qr = new QueryRunner();
 86         String sql = "SELECT COUNT(*) FROM sort";
 87         //调用方法query,传递结果集处理实现类ScalarHandler
 88         long count = qr.query(con, sql, new ScalarHandler<Long>());
 89         System.out.println(count);
 90     }
 91     
 92     /*
 93      *  结果集第五种处理方法,ColumnListHandler
 94      *  结果集,指定列的数据,存储到List集合
 95      *  List<Object> 每个列数据类型不同
 96      */
 97     public static void columnListHandler()throws SQLException{
 98         QueryRunner qr = new QueryRunner();
 99         String sql = "SELECT * FROM sort ";        
100         //调用方法 query,传递结果集实现类ColumnListHandler
101         //实现类构造方法中,使用字符串的列名
102         List<Object> list = qr.query(con, sql, new ColumnListHandler<Object>("sname"));
103         for(Object obj : list){
104             System.out.println(obj);
105         }
106     }
107     
108     /*
109      *  结果集第四种处理方法, BeanListHandler
110      *  结果集每一行数据,封装JavaBean对象
111      *  多个JavaBean对象,存储到List集合
112      */
113     public static void beanListHander()throws SQLException{
114         QueryRunner qr = new QueryRunner();
115         String sql = "SELECT * FROM sort ";
116         //调用方法query,传递结果集处理实现类BeanListHandler
117         List<Sort> list = qr.query(con, sql, new BeanListHandler<Sort>(Sort.class));
118         for(Sort s : list){
119             System.out.println(s);
120         }
121     }
122     
123     /*
124      *  结果集第三种处理方法,BeanHandler
125      *  将结果集的第一行数据,封装成JavaBean对象
126      *  注意: 被封装成数据到JavaBean对象, Sort类必须有空参数构造
127      */
128     public static void beanHandler()throws SQLException{
129         QueryRunner qr = new QueryRunner();
130         String sql = "SELECT * FROM sort ";
131         //调用方法,传递结果集实现类BeanHandler
132         //BeanHandler(Class<T> type) 
133         Sort s = qr.query(con, sql, new BeanHandler<Sort>(Sort.class));
134         System.out.println(s);
135     }
136     
137     /*
138      *  结果集第二种处理方法,ArrayListHandler
139      *  将结果集的每一行,封装到对象数组中, 出现很多对象数组
140      *  对象数组存储到List集合
141      */
142     public static void arrayListHandler()throws SQLException{
143         QueryRunner qr = new QueryRunner();
144         String sql = "SELECT * FROM sort";        
145         //调用query方法,结果集处理的参数上,传递实现类ArrayListHandler
146         //方法返回值 每行是一个对象数组,存储到List
147         List<Object[]> result=  qr.query(con, sql, new ArrayListHandler());
148         
149         //集合的遍历
150         for( Object[] objs  : result){
151             //遍历对象数组
152             for(Object obj : objs){
153                 System.out.print(obj+"  ");
154             }
155             System.out.println();
156         }
157     }
158     
159     /*
160      *  结果集第一种处理方法, ArrayHandler
161      *  将结果集的第一行存储到对象数组中  Object[]
162      */
163     public static void arrayHandler()throws SQLException{
164         QueryRunner qr = new QueryRunner();
165         String sql = "SELECT * FROM sort";
166         //调用方法query执行查询,传递连接对象,SQL语句,结果集处理方式的实现类
167         //返回对象数组
168         Object[] result = qr.query(con, sql, new ArrayHandler());
169         for(Object obj : result){
170             System.out.print(obj);
171         }
172     }    
173 }
View Code

4、使用apache的连接池操作数据库

 1 package cn.itcast.demo;
 2 
 3 import java.sql.Connection;
 4 import java.sql.SQLException;
 5 
 6 import org.apache.commons.dbcp.BasicDataSource;
 7 
 8 /*
 9  *  连接池jar包中,定义好一个类 BasicDataSource
10  *  实现类数据源的规范接口 javax.sql.DataSource
11  */
12 public class DataSoruceDemo {
13     public static void main(String[] args) {
14         //创建DataSource接口的实现类对象
15         //实现类, org.apache.commons.dbcp
16         BasicDataSource dataSource = new BasicDataSource();
17         //连接数据库的4个最基本信息,通过对象方法setXXX设置进来
18         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
19         dataSource.setUrl("jdbc:mysql://localhost:3306/mybase");
20         dataSource.setUsername("root");
21         dataSource.setPassword("123");
22         
23         try{
24         //调用对象方法getConnection获取数据库的连接
25             Connection con = dataSource.getConnection();
26             System.out.println(con);
27         }catch(SQLException ex){
28 //            System.out.println(ex);
29             throw new RuntimeException("数据库连接失败");
30         }
31     }
32 }
DataSoruceDemo
 1 package cn.itcast.demo;
 2 /*
 3  *  测试写好的工具类,
 4  *  提供的是一个DataSource接口的数据源
 5  *  QueryRunner类构造方法,接收DataSource接口的实现类
 6  *  后面,调用方法update,query,无需传递他们Connection连接对象
 7  */
 8 
 9 import java.sql.SQLException;
10 import java.util.List;
11 
12 import org.apache.commons.dbutils.QueryRunner;
13 import org.apache.commons.dbutils.handlers.ArrayListHandler;
14 
15 import cn.itcast.jdbcutils.JDBCUtils;
16 public class QueryRunnerDemo{
17     public static void main(String[] args) {
18         select();
19     }
20     //定义2个方法,实现数据表的添加,数据表查询
21     //QueryRunner类对象,写在类成员位置
22     private static QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource()); 
23     
24     //数据表查询
25     public static void select(){
26         String sql = "SELECT * FROM sort";
27         try{
28         List<Object[]> list = qr.query(sql, new ArrayListHandler());
29         for(Object[] objs : list){
30             for(Object obj : objs){
31                 System.out.print(obj+"	");
32             }
33             System.out.println();
34         }
35         }catch(SQLException ex){
36             throw new RuntimeException("数据查询失败");
37         }
38     }
39     
40     //数据表添加数据
41     public static void insert(){
42         String sql = "INSERT INTO sort (sname,sprice,sdesc)VALUES(?,?,?)";
43         Object[] params = {"水果",100.12,"刚刚上市的核桃"};
44         try{
45             int row = qr.update(sql, params);
46             System.out.println(row);
47         }catch(SQLException ex){
48             throw new RuntimeException("数据添加失败");
49         }
50     }
51     
52 }
QueryRunnerDemo
 1 package cn.itcast.jdbcutils;
 2 /*
 3  *  使用DBCP实现数据库的连接池
 4  *  连接池配置,自定义类,
 5  *  最基本四项完整
 6  *  对于数据库连接池其他配置,自定义
 7  */
 8 
 9 import javax.sql.DataSource;
10 
11 import org.apache.commons.dbcp.BasicDataSource;
12 public class JDBCUtils{
13     //创建出BasicDataSource类对象
14     private static BasicDataSource datasource = new BasicDataSource();
15     
16     //静态代码块,对象BasicDataSource对象中的配置,自定义
17     static{
18         //数据库连接信息,必须的
19         datasource.setDriverClassName("com.mysql.jdbc.Driver");
20         datasource.setUrl("jdbc:mysql://localhost:3306/day33_user");
21         datasource.setUsername("root");
22         datasource.setPassword("123");
23         //对象连接池中的连接数量配置,可选的
24         datasource.setInitialSize(10);//初始化的连接数
25         datasource.setMaxActive(8);//最大连接数量
26         datasource.setMaxIdle(5);//最大空闲数
27         datasource.setMinIdle(1);//最小空闲
28     }
29     
30     
31     //定义静态方法,返回BasicDataSource类的对象
32     public static DataSource getDataSource(){
33         return datasource;
34     }
35 }
JDBCUtils

以上代码，仅供参考，具体问题还要具体分析

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/medal-li/p/7481360.html