1. DButils工具类的介绍个三个核心类
A: DButils工具类的介绍个三个核心类
a: 概述
DBUtils是java编程中的数据库操作实用工具，小巧简单实用。
DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。
DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。
b: Dbutils三个核心功能介绍
QueryRunner中提供对sql语句操作的API.
update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法
2. QueryRunner类的update方法介绍
a: 方法介绍
update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
使用QueryRunner类,实现对数据表的insert delete update
调用QueryRunner类的方法 update (Connection con,String sql,Object...param)
Object...param 可变参数,Object类型,SQL语句会出现?占位符
数据库连接对象,自定义的工具类传递
b. 代码实现
1 /**
2 * QueryRunner类
3 * update(Connection conn, String sql, Object... params)
4 * 实现表中数据的增、删、改
5 * @author vanguard
6 *
7 */
8 public class QueryRunnerDemo {
9 //获取数据库连接
10 private static Connection conn = JDBCUtils.getConnection();
11
12 public static void main(String[] args) throws SQLException {
13 //insert();
14 //delete();
15 //update();
16 }
17 /**
18 * 使用QueryRunner类中的update方法，实现更新数据
19 * @throws SQLException
20 */
21 private static void update() throws SQLException {
22 //创建QueryRunner类对象
23 QueryRunner qr = new QueryRunner();
24 //定义更新的sql语句
25 String sql = "UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";
26 ////将四个?占位符的实际参数写在数组中
27 Object[] params = {"家居产品", 9000, "涨价了", 2};
28 ////调用QueryRunner类的方法update执行SQL语句
29 int row = qr.update(conn, sql, params);
30 System.out.println(row);
31 DbUtils.closeQuietly(conn);
32 }
33 /**
34 * 使用QueryRunner类中的update方法，实现添加数据
35 * @throws SQLException
36 */
37 private static void delete() throws SQLException {
38 //创建QueryRunner类对象
39 QueryRunner qr = new QueryRunner();
40 String sql = "DELETE FROM sort WHERE sid=?";
41 //调用QueryRunner类的方法update执行SQL语句
42 int row = qr.update(conn, sql, 7);
43 System.out.println(row);
44 DbUtils.closeQuietly(conn);
45 }
46
47 /**
48 * 使用Q ueryRunner类中的update方法，实现添加数据
49 * @throws SQLException
50 */
51 private static void insert() throws SQLException {
52 //创建QueryRunner类对象
53 QueryRunner qr = new QueryRunner();
54 String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
55 //将三个?占位符的实际参数写在数组中
56 Object[] params = {"体育用品", 200.98, "购买体育用品"};
57 //调用QueryRunner类的方法update执行SQL语句
58 int row = qr.update(conn, sql, params);
59 System.out.println(row);
60 DbUtils.closeQuietly(conn);
61 }
62 }
3. DBUtils工具类结果集处理的方式
a: QueryRunner实现查询操作
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
b: ResultSetHandler结果集处理类
ArrayHandler将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
ArrayListHandler将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
BeanHandler将结果集中第一条记录封装到一个指定的javaBean中。
BeanListHandler将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
ColumnListHandler将结果集中指定的列的字段值，封装到一个List集合中
ScalarHandler它是用于单数据。例如select count(*) from 表操作。
MapHandler将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
MapListHandler将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
4. QueryRunner类的方法query
a: QueryRunner类的方法query数据查询操作
调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r, Object..params)
ResultSetHandler r 结果集的处理方式,传递ResultSetHandler接口实现类
Object..params SQL语句中的?占位符
注意: query方法返回值,返回的是T 泛型, 具体返回值类型,跟随结果集处理方式变化
b:代码实现：
1 /**
2 * 使用QueryRunner类中的
3 * query(Connection conn, String sql, ResultSetHandler<T> rsh,
4 * Object... params)
5 * 完成对数据的查询操作
6 * ResultSetHandler结果集处理类 8中处理结果集的方式
7 * ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
8 * ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
9 * BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中。
10 * BeanListHandler 将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
11 * ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中
12 * ScalarHandler 它是用于单数据。例如select count(*) from 表操作。
13 * MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
14 * MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
15 * @author vanguard
16 *
17 */
18 public class QueryRunnerDmoe01 {
19 private static Connection conn = JDBCUtils.getConnection();
20
21 public static void main(String[] args) throws SQLException {
22 //arrayHandler();
23 //arrayListHandler();
24 //beanHandler();
25 //beanListHandler();
26 //columnListHandler();
27 //scalarHandler();
28 //mapHandler();
29 mapListHandler();
30 }
31
32 /**
33 * 结果集处理的第八种方式MapListHandler
34 * 将结果集的每一行结果封装到Map集合中，Key 列名，Value 该列的数据
35 * 将Map集合放到List集合中
36 * @throws SQLException
37 */
38 private static void mapListHandler() throws SQLException {
39 //创建QueryRunner类对象
40 QueryRunner qr = new QueryRunner();
41 //定义查询的sql语句
42 String sql = "SELECT * FROM sort";
43 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
44 List<Map<String, Object>> list = qr.query(conn, sql, new MapListHandler());
45 //遍历List集合
46 for(Map<String, Object> map : list) {
47 for(String row : map.keySet()) {
48 System.out.print(row + ":" + map.get(row) + "\t");
49 }
50 System.out.println();
51 }
52 }
53
54 /**
55 * 结果集处理的第七种方式MapHandler
56 * 将结果集的第一行数据封装到Map集合中 Key 列名 Value 该列数据
57 * @throws SQLException
58 */
59 private static void mapHandler() throws SQLException {
60 //创建QueryRunner类对象
61 QueryRunner qr = new QueryRunner();
62 //定义查询的sql语句
63 String sql = "SELECT * FROM sort";
64 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
65 Map<String, Object> map = qr.query(conn, sql, new MapHandler());
66 for(String row : map.keySet()) {
67 System.out.print(row + ":" + map.get(row) + " ");
68 }
69 }
70
71 /**
72 * 结果集处理的第六种方式ScalarHandler
73 * 它用于单数据，对于查询后只有一个结果
74 * @throws SQLException
75 */
76 private static void scalarHandler() throws SQLException {
77 //创建QueryRunner类对象
78 QueryRunner qr = new QueryRunner();
79 //定义查询的sql语句
80 String sql = "SELECT COUNT(*) FROM sort";
81 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
82 long count = qr.query(conn, sql, new ScalarHandler<Long>());
83 System.out.println(count);
84 }
85
86 /**
87 * 结果集处理的第五种方式ColumnListHandler
88 * 将结果集中指定列的字段值封装到list集合中
89 * @throws SQLException
90 */
91 private static void columnListHandler() throws SQLException {
92 //创建QueryRunner类对象
93 QueryRunner qr = new QueryRunner();
94 //定义查询的sql语句
95 String sql = "SELECT * FROM sort";
96 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
97 List<String> list = qr.query(conn, sql, new ColumnListHandler<String>("sname"));
98 for(String name : list) {
99 System.out.println(name);
100 }
101 }
102
103 /**
104 * 结果集处理的第四种方式BeanListHandler
105 * 将结果集中每一条数据封装到JavaBean对象中
106 * 将这些JavaBean对象放到list集合中
107 * @throws SQLException
108 */
109 private static void beanListHandler() throws SQLException {
110 //创建QueryRunner类对象
111 QueryRunner qr = new QueryRunner();
112 //定义查询的sql语句
113 String sql = "SELECT * FROM sort";
114 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
115 List<Sort> list = qr.query(conn, sql, new BeanListHandler<Sort>(Sort.class));
116 //遍历list集合
117 for(Sort s : list) {
118 System.out.println(s);
119 }
120 }
121
122 /**
123 * 结果集处理的第三种方式BeanHandler
124 * 将结果集中的第一条数据封装到JavaBean对象中
125 * 注意：被封装成数据到JavaBean对象，Sort类中必须有空参构造
126 * @throws SQLException
127 */
128 private static void beanHandler() throws SQLException {
129 //创建QueryRunner类对象
130 QueryRunner qr = new QueryRunner();
131 //定义查询的sql语句
132 String sql = "SELECT * FROM sort";
133 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
134 Sort s = qr.query(conn, sql, new BeanHandler<Sort>(Sort.class));
135 System.out.println(s);
136 }
137
138 /**
139 * 结果集处理的第二种方式ArrayListHandler
140 * 将结果集的每一行封装到Object[]数组中
141 * 将这些数组放到list集合中
142 * @throws SQLException
143 */
144 private static void arrayListHandler() throws SQLException {
145 //创建QueryRunner类对象
146 QueryRunner qr = new QueryRunner();
147 //定义查询的sql语句
148 String sql = "SELECT * FROM sort";
149 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
150 List<Object[]> list = qr.query(conn, sql, new ArrayListHandler());
151 for(Object[] objs : list) {
152 for(Object obj : objs) {
153 System.out.print(obj + "\t\t");
154 }
155 System.out.println();
156 }
157 }
158
159 /**
160 * 结果集处理的第一种方式ArrayHandler
161 * 将结果集的第一行封装到Object[]数组中
162 * @throws SQLException
163 */
164 private static void arrayHandler() throws SQLException {
165 //创建QueryRunner类对象
166 QueryRunner qr = new QueryRunner();
167 //定义查询的sql语句
168 String sql = "SELECT * FROM sort";
169 //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
170 Object[] objects = qr.query(conn, sql, new ArrayHandler());
171 //遍历数组
172 for(Object obj : objects) {
173 System.out.print(obj + " ");
174 }
175 }
176 }
1 public class Sort {
2 private int sid;
3 private String sname;
4 private int sprice;
5 private String sdesc;
6
7 public Sort() {}
8
9 public Sort(int sid, String sname, int sprice, String sdesc) {
10 super();
11 this.sid = sid;
12 this.sname = sname;
13 this.sprice = sprice;
14 this.sdesc = sdesc;
15 }
16
17 public int getSid() {
18 return sid;
19 }
20
21 public void setSid(int sid) {
22 this.sid = sid;
23 }
24
25 public String getSname() {
26 return sname;
27 }
28
29 public void setSname(String sname) {
30 this.sname = sname;
31 }
32
33 public int getSprice() {
34 return sprice;
35 }
36
37 public void setSprice(int sprice) {
38 this.sprice = sprice;
39 }
40
41 public String getSdesc() {
42 return sdesc;
43 }
44
45 public void setSdesc(String sdesc) {
46 this.sdesc = sdesc;
47 }
48
49 @Override
50 public String toString() {
51 return "Sort [sid=" + sid + ", sname=" + sname + ", sprice=" + sprice
52 + ", sdesc=" + sdesc + "]";
53 }
54
55
56 }
5. 连接池介绍
1）: 连接池介绍
a: 连接池介绍
实际上就是存放连接的池子(容器)
在开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程
为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。
这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池
2）: 连接池概念规范和DataSource接口
a: 连接池概念规范
用池来管理Connection，这样可以重复使用Connection。
不用自己来创建Connection，而是通过池来获取Connection对象
使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池
连接池技术可以完成Connection对象的再次利用
b: DataSource接口
Java为数据库连接池提供了公共的接口：javax.sql.DataSource
各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池
常见的连接池：DBCP、C3P0
3）: DBCP连接池介绍
a: DBCP连接池介绍
DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池
4）: 导入jar包
a: jar包介绍
mysql-connector-java-5.1.37-bin.jar：数据库驱动
commons-dbutils-1.6.jar：提供QueryRunner类方便进行增删改查操作
commons-dbcp-1.4.jar：
commons-pool-1.5.6.jar：提供高效的数据库连接池技术
b: 导入jar包
在项目根路径下建立文件夹lib
拷贝以上jar包，选定拷贝的jar包/右键/Build Path/Add to Build Path
5）: BasicDataSource类的使用
a: 案例代码
1 /**
2 * 连接池
3 * 连接池jar包中定义好了一个类DataSource
4 * 实现该类数据源的规范接口 javax.sql.DataSource
5 * @author vanguard
6 *
7 */
8 public class DataSourceDemo {
9 public static void main(String[] args) {
10 //创建DataSource类接口的实现类对象
11 BasicDataSource datasource = new BasicDataSource();
12 //连接数据库的四个基本信息可以通过setXXX方法设置
13 datasource.setDriverClassName("com.mysql.jdbc.Driver");
14 datasource.setUrl("jdbc:mysql://localhost:3306/mybase");
15 datasource.setUsername("root");
16 datasource.setPassword("root");
17
18 //调用对象的方法获取数据库连接
19 try {
20 Connection conn = datasource.getConnection();
21 System.out.println(conn);
22 } catch (SQLException e) {
23 e.printStackTrace();
24 throw new RuntimeException("数据库连接失败");
25 }
26 }
27 }
6）: BasicDataSource类的常见配置
a: 常见配置
分类属性描述
必须项
driverClassName数据库驱动名称
url数据库的地址
username用户名
password密码
基本项（扩展）
maxActive最大连接数量
minIdle最小空闲连接
maxIdle 最大空闲连接
initialSize初始化连接
7）: 实现数据库连接池工具类
a: 案例代码
1 /**
2 * 使用DBCP实现数据库的连接池
3 * 连接池配置,自定义类,
4 * 最基本四项完整
5 * 对于数据库连接池其他配置,自定义
6 * @author vanguard
7 *
8 */
9 public class JDBCPoolUtils {
10 //创建出BasicDataSource类对象
11 private static BasicDataSource datasource = new BasicDataSource();
12
13 //静态代码块，对BasicDataSource类进行配置
14 static {
15 //数据库连接信息，必须的
16 datasource.setDriverClassName("com.mysql.jdbc.Driver");
17 datasource.setUrl("jdbc:mysql://localhost:3306/stdb");
18 datasource.setUsername("root");
19 datasource.setPassword("root");
20 //对象连接池中的连接数量配置，可选
21 datasource.setInitialSize(10);//初始化的连接数
22 datasource.setMaxActive(8);//最大的连接数
23 datasource.setMaxIdle(5);//最大空闲数
24 datasource.setMinIdle(2);//最小空闲数
25 }
26 /**
27 * 返回BasicDataSource类对象
28 * @return
29 */
30 public static DataSource getDataSource() {
31 return datasource;
32 }
33 }
8）: 工具类的测试
a: 案例代码
1 /**
2 * 测试写好的工具类
3 * 提供的是一个DataSource接口的数据源
4 * QueryRunner类构造方法,接收DataSource接口的实现类
5 * 后面,调用方法update,query,无需传递他们Connection连接对象
6 * @author vanguard
7 *
8 */
9 public class QueryRunnerDemo {
10 private static QueryRunner qr = new QueryRunner(JDBCPoolUtils.getDataSource());
11
12 public static void main(String[] args) {
13 //insert();
14 select();
15 }
16 /**
17 * 定义查询数据的方法
18 */
19 private static void select() {
20 String sql = "SELECT * FROM sort";
21 try {
22 List<Object[]> list = qr.query(sql, new ArrayListHandler());
23 for(Object[] objs : list) {
24 for(Object obj : objs) {
25 System.out.print(obj + "\t");
26 }
27 System.out.println();
28 }
29 } catch (SQLException e) {
30
31 e.printStackTrace();
32 throw new RuntimeException("数据库查询失败");
33 }
34 }
35
36 /**
37 * 定义添加数据的方法
38 */
39 private static void insert() {
40 String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
41 Object[] params = {"水果", 20.5, "桃子便宜了"};
42 try {
43 int row = qr.update(sql, params);
44 System.out.println(row);
45 } catch (SQLException e) {
46
47 e.printStackTrace();
48 throw new RuntimeException("数据添加失败");
49 }
50 }
51 }