持久层技术
一：Dbutils是什么？（当我们很难理解一个东西的官方解释的时候，就让我们记住它的作用）
Dbutils：主要是封装了JDBC的代码，简化dao层的操作。
作用：帮助java程序员，开发Dao层代码的简单框架。
框架的作用：帮助程序员，提高程序的开发效率。
出生：Dbutils是由Apache公司提供。
二：为什么需要Dbutils ？
在使用Dbutils 之前，我们Dao层使用的技术是JDBC，那么分析一下JDBC的弊端：
（1）数据库链接对象、sql语句操作对象，封装结果集对象，这三大对象会重复定义
（2）封装数据的代码重复，而且操作复杂，代码量大
（3）释放资源的代码重复
结果：（1）程序员在开发的时候，有大量的重复劳动。（2）开发的周期长，效率低
三：Dbutils三个核心类介绍：
1：DbUtils：连接数据库对象----jdbc辅助方法的集合类，线程安全
构造方法：DbUtils()
作用：控制连接，控制书屋，控制驱动加载额一个类。
2：QueryRunner：SQL语句的操作对象，可以设置查询结果集的封装策略，线程安全。
构造方法：
（1）QueryRunner()：创建一个与数据库无关的QueryRunner对象，后期再操作数据库的会后，需要手动给一个Connection对象，它可以手动控制事务。
Connection.setAutoCommit(false); 设置手动管理事务
Connection.commit(); 提交事务
（2）QueryRunner(DataSource ds)：创建一个与数据库关联的queryRunner对象，后期再操作数据库的时候，不需要Connection对象，自动管理事务。
DataSource：数据库连接池对象。
构造函数与增删改查方法的组合：
QueryRunner()
update(Connection conn, String sql, Object... params)
query(Connection conn, String sql, ResultSetHandler
QueryRunner(DataSource ds)
update(String sql, Object... params)
query(String sql, ResultSetHandler
（3）ResultSetHandle：封装数据的策略对象------将封装结果集中的数据，转换到另一个对象
策略：封装数据到对象的方式（示例：将数据库保存在User、保存到数组、保存到集合）
方法介绍：handle（ResultSet rs）
备注：详解参考ResultSetHandle实现类
四：Dbutils快速入门
使用Dbutils注意事项：
（1）需要导入的jar包：①MySql驱动 ②c3p0包 ③DbUtils包
（2）添加c3p0配置文件
（3）可以自行添加一个JDBCUtils工具类：用来获取c3p0连接池对象
c3p0-config.xml
1
2 < c3p0-config>
3
4 < default-config>
5
6 < property name ="driverClass" > com.mysql.jdbc.Driver
7 < property name ="jdbcUrl" > jdbc:mysql:///数据库名
8 < property name ="user" > 数据库用户名
9 < property name ="password" > 数据库密码
10
11
JDBCUtils. java
1 package cn.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 public class JDBCUtils {
11
12 // 获得c3p0连接池对象
13 private static ComboPooledDataSource ds = new ComboPooledDataSource();
14
15 /**
16 * 获得数据库连接对象
17 *
18 * @return
19 * @throws SQLException
20 */
21 public static Connection getConnection() throws SQLException {
22 return ds.getConnection();
23 }
24
25 /**
26 * 获得c3p0连接池对象
27 * @return
28 */
29 public static DataSource getDataSource() {
30 return ds;
31 }
32 }
案例一：使用queryRunner对象完成增删改操作：
1：数据表
1 drop database if exists jdbc;
2 CREATE DATABASE IF NOT EXISTS jdbc;
3 USE jdbc;
4
5 drop table if exists user ;
6 CREATE TABLE IF NOT EXISTS `user ` (
7 `id` int(11) NOT NULL AUTO_INCREMENT,
8 ` name` varchar(50) DEFAULT NULL ,
9 `pwd` varchar(50) DEFAULT NULL ,
10 PRIMARY KEY (`id`)
11 ) ;
12 #数据初始化
13 insert into user values (null ,'zhangsan' ,'123456' );
14 insert into user values (null ,'lisi' ,'123456' );
2：演示代码
1 //需求：向user表插入一条数据
2
3 @Test
4
5 public void test1(){
6
7 //第一步：创建queryRunner对象，用来操作sql语句
8
9 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
10
11 //第二步：创建sql语句
12
13 String sql = "insert into user values(null,?,?)";
14
15 //第三步：执行sql语句,params:是sql语句的参数
16
17 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
18
19 try {
20
21 int update = qr.update(sql, "狗蛋","123456");
22
23 System.out.println(update);
24
25 } catch (SQLException e) {
26
27 e.printStackTrace();
28
29 }
30
31 }
32
33 //需求：修改id==7的数据
34
35 @Test
36
37 public void test2(){
38
39 //第一步：创建queryRunner对象，用来操作sql语句
40
41 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
42
43 //第二步：创建sql语句
44
45 String sql = "update user set name = ? where id = ?";
46
47 //第三步：执行sql语句,params:是sql语句的参数
48
49 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
50
51 try {
52
53 int update = qr.update(sql, "柳岩",7);
54
55 System.out.println(update);
56
57 } catch (SQLException e) {
58
59 e.printStackTrace();
60
61 }
62
63 }
64
65 //需求：删除id==7的数据
66
67 @Test
68
69 public void test3(){
70
71 //第一步：创建queryRunner对象，用来操作sql语句
72
73 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
74
75 //第二步：创建sql语句
76
77 String sql = "delete from user where id = ?";
78
79 //第三步：执行sql语句,params:是sql语句的参数
80
81 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
82
83 try {
84
85 int update = qr.update(sql, 7);
86
87 System.out.println(update);
88
89 } catch (SQLException e) {
90
91 e.printStackTrace();
92
93 }
94
95 }
96
案例二：QueryRunner的query方法和ResultSetHandler接口的使用
1：数据库表
同上一案例User表
2：自定义实现ResultSetHandler封装查询结果集
自定义策略
1 package cn.handler;
2
3 import java.sql.ResultSet;
4 import java.sql.SQLException;
5 import java.util.ArrayList;
6 import java.util.List;
7
8 import org.apache.commons.dbutils.ResultSetHandler;
9
10 import cn.itcast.domain.User;
11 // ResultSetHandler,表示封装结果的类型
12 //MyHandler 是自定义的ResultSetHandler封装结果集策略对象
13 public class MyHandler implements ResultSetHandler>{
14
15 @Override
16 public List handle(ResultSet rs) throws SQLException {
17 // 封装数据，数据从 Resultset 中获取
18 List list = new ArrayList();
19 while(rs.next()){
20 User u = new User();
21 u.setId(rs.getInt( "id"));
22 u.setName(rs.getString( "name"));
23 u.setPwd(rs.getString( "pwd"));
24
25 list.add(u);
26 }
27 return list;
28 }
29
30 }
31
3：测试代码
1 //需求：获取user表中所有的数据
2
3 @Test
4
5 public void test4(){
6
7 //第一步：创建queryRunner对象，用来操作sql语句
8
9 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
10
11 //第二步：创建sql语句
12
13 String sql = "select * from user";
14
15 //第三步：执行sql语句,params:是sql语句的参数
16
17 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
18
19 try {
20
21 List list = qr.query(sql, new MyHandler());
22
23 System.out.println(list);
24
25 } catch (SQLException e) {
26
27 e.printStackTrace();
28
29 }
30
31 }
案例三：ResultSetHandler实现类介绍（由DbUtils框架提供）
备注：DbUtils给我们提供了10个ResultSetHandler实现类，分别是：
①ArrayHandler： 将查询结果的第一行数据，保存到Object数组中
②ArrayListHandler 将查询的结果，每一行先封装到Object数组中，然后将数据存入List集合
③BeanHandler 将查询结果的第一行数据，封装到user对象
④BeanListHandler 将查询结果的每一行封装到user对象，然后再存入List集合
⑤ColumnListHandler 将查询结果的指定列的数据封装到List集合中
⑥MapHandler 将查询结果的第一行数据封装到map结合（key==列名，value==列值）
⑦MapListHandler 将查询结果的每一行封装到map集合（key==列名，value==列值），再将map集合存入List集合
⑧BeanMapHandler 将查询结果的每一行数据，封装到User对象，再存入mao集合中（key==列名，value==列值）
⑨KeyedHandler 将查询的结果的每一行数据，封装到map1（key==列名，value==列值 ），然后将map1集合（有多个）存入map2集合（只有一个）
⑩ScalarHandler 封装类似count、avg、max、min、sum......函数的执行结果
以上10个ResultSetHandler实现类，常用的是BeanHandler、BeanListHandler和ScalarHandler，下面将对这三个实现类，写测试类
一： 测试BeanHandler策略
1 //需求：测试BeanHandler策略
2
3 //BeanHandler:将查询结果的第一行数据，封装到user对象
4
5 @Test
6
7 public void test7(){
8
9 //第一步：创建queryRunner对象，用来操作sql语句
10
11 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
12
13 //第二步：创建sql语句
14
15 String sql = "select * from user";
16
17 //第三步：执行sql语句,params:是sql语句的参数
18
19 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
20
21 try {
22
23 User user = qr.query(sql, new BeanHandler(User.class));
24
25 System.out.println(user);
26
27 } catch (SQLException e) {
28
29 e.printStackTrace();
30
31 }
32
33 }
二：测试BeanListHandler策略
1 //需求：测试BeanListHandler策略
2
3 //BeanListHandler:将查询结果的每一行封装到user对象，然后，再存入list集合
4
5 @Test
6
7 public void test8(){
8
9 //第一步：创建queryRunner对象，用来操作sql语句
10
11 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
12
13 //第二步：创建sql语句
14
15 String sql = "select * from user";
16
17 //第三步：执行sql语句,params:是sql语句的参数
18
19 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
20
21 try {
22
23 List list = qr.query(sql, new BeanListHandler(User.class));
24
25 System.out.println(list);
26
27 } catch (SQLException e) {
28
29 e.printStackTrace();
30
31 }
32
33 }
34
三：测试ScalarHandler策略
1 //需求：测试ScalarHandler策略
2
3 //ScalarHandler:封装类似count、avg、max、min、sum。。。。函数的执行结果
4
5 @Test
6
7 public void test14(){
8
9 //第一步：创建queryRunner对象，用来操作sql语句
10
11 QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
12
13 //第二步：创建sql语句
14
15 String sql = "select count(*) from user";
16
17 //第三步：执行sql语句,params:是sql语句的参数
18
19 //注意，给sql语句设置参数的时候，按照user表中字段的顺序
20
21 try {
22
23 Object object = qr.query(sql, new ScalarHandler());
24
25 System.out.println(object);
26
27 } catch (SQLException e) {
28
29 e.printStackTrace();
30
31 }
32
33 }
以上三个有测试案例的ResultSetHandler策略为常用实现类。
JAVA 访问数据库的技术:
Jdbc是一种Java连接数据库技术(Java database connectity), 它是 Java 提供的一些接口,这些接口大部分是数据库厂商提供的(jar包),我们要做的,是连接数据库以后,如何使用Java代码从数据库中存取数据!
Jdbc开发步骤
1. 引包:
2. 开启MySQL服务,
如何没有开启会报错:
3.准备好数据库
4.进入开发阶段
4.1注册数据库驱动
//MySQL驱动固定写法!注意是”MySQL数据库的驱动”
Class.forName("com.mysql.jdbc.Driver");
4.2和数据库建立连接
连接数据库必要的参数:
URL: 访问数据库的地址:写法:
jdbc:mysql://数据库所在Ip地址:数据库端口/数据库的名字
name : 要连接的数据库的账户名
password : 要连接数据库的用户密码
//找到本机的数据库应用,3306是数据库的默认端口 8080是tomkat的默认端口
-
String url = "jdbc:mysql://localhost:3306/student"; -
String name = "root";//将要连接数据库的账户 -
String password = "root";//将要连接数据库的密码 -
Connection connection = DriverManager.getConnection(url,name,password);
4.3获得执行sql语句的对象
用于执行SQL语句
PreparedStatement接口继承了Statement,
Statement(固定),和 PreparedStatement(可变参数) 是SQL语句的两种执行方式
1.在遇到要执行的SQL语句是带可变参数的时候,就用PreparedStatement对象,应为PreparedStatement可以用占位符将SQL语句加入可变参数!:
-
String sql = "insert into user(sno,name,age)values(?,?,?)";//定义一个要执行的SQL语句 -
PreparedStatement ps = connection.prepareStatement(sql); -
ps.setString(1,student.getSno());//设置SQL语句的第一个参数 -
ps.setString(2,student.getName());//设置SQL语句的第二个参数 -
ps.setInt(3,student.getAge());//设置SQL语句的第三个参数
2.当要执行的SQL语句的是不带可变参数的时(就是SQL语句不变时!):
-
String sql = "SELECT * FROM user"; -
Statement statement = connection.createStatement();//sql语句的执行对象 -
ResultSet row = statement.executeQuery(sql);//执行SQL语句
PreparedStatement 和Statement的区别:
PreparedStatement:用户通过你系统输入变量时,变量将加入你的SQL语句,这样就能在不知道你的用户输入的情况下,获取信息
4.4执行SQL语句
两种语句:
1).不用返回数据库信息:
增,删,改
exexuteUpdate() 方法 : 返回一个整形(对数据库影响的行数)
2).需要返回数据库信息:
查
exexuteQuery() 方法 : 返回一个结果集对象(Resultest 在数据库中查到的一条数据)
读取返回对象集中的数据的方法: (就是集合的迭代器)
Resultest.next()能够返回给你还有没有记录,
getObjeck方法,读取一条记录里面字段所对应的值
4.5处理执行后的结果
调用Dao的方法后返回一个结果给servlet 让servlet进行处理!:如:
-
int row = UserDAD.insert(student); -
if (row==1){ -
jsonObject.put("code",1); -
jsonObject.put("msg","添加成功"); -
jsonObject.put("data",student); -
}else { -
jsonObject.put("code",2); -
jsonObject.put("msg","添加失败"); -
}
4.6 释放资源
将用到的传输有关的对象再传输完成后统统释放! 如:
-
ps.close(); -
connection.close();