MySQL-Java的连接媒介----JDBC
目录
1.简介
1.1概述：
1.2 学习的目的
1.3原理示意图
1.4 JDBC API
1.4.1JDBC程序编写步骤
1.4.2 JDBC的入门
1.4.2 DriverManager：驱动管理类
1.4.3 Connection：与数据库连接对象
1.4.5ResultSet：结果集
1.4.5jdbc的五种连接方式
1.4.6 jdbc的PreparedStatement（DML）
API总结
编辑
2.DBUtils
2.1DBUtils的好处
2.2DBUtils的静态方法
2.3DBUtils的调用
3.事务
3.1基本介绍：
3.2环境适配
3.2.1没有事务的案例
3.2.2拥有事务的案例
4.批处理
4.1基本介绍
4.1批处理基本使用
4.3 批量插入(使用PreparedStatement)
5.数据库连接池
5.1 传统获取 Connection 问题分析
5.2 什么是连接池
5.3学习连接池大的目的
5.4连接池原理编辑
编辑
5.5数据库连接池种类
5.6 C3P0的两种方式
5.7Druid--德鲁伊的使用
一
二
5.8 德鲁伊工具类
5.8.1使用
6.Apache—DBUtils
6.1为何使用：
分析：
6.2基本介绍
6.3应用
6.3.1Apache 的crud操作和单行and单列单行和dml
7.DAO类（数据库操作对象）
7.1DAO的引入
7.2基本说明
7.3应用实例
1.util工具类
2.domain javabean
3.dao 存放 actorDao和BasicDao
4.test 写测试类
1.简介
1.1概述：
JDBC是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组 用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。（java程序员使用JDBC，可以连接任何提供了JDBC驱动程序的数据库系统，从而完成对数据库的各种操作）
1.2 学习的目的
没有JDBC的时候，如果现在要开发一套系统，使用Java连接MySQL数据库，那么这时候Java程序员需要了解MySQL驱动API，如果使用Java连接Oracle数据库，那么这个时候Java程序员需要了解Oracle数据库驱动API。SUN公司提供一套统一的规范（接口）。然后各个数据库生产商提供这套接口的实现。这套接口规范就是JDBC的规范。
1.3原理示意图
驱动：两个设备（应用）之间通信的桥梁。
1.4 JDBC API
1.4.1JDBC程序编写步骤
-
注册驱动--加载Driver类
-
获取连接--得到Connection
-
执行增删改查--发送SQL给MySQL执行
-
释放资源
1.4.2 JDBC的入门
package MySQL;
import com.mysql.jdbc.Driver;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* JDBC的入门程序
*/
public class Jdbc01 {
/**
* JDBC的入门
*/
public static void main(String[] args) throws SQLException {
//前置工作： 在项目下创建一个文件夹比如 libs
// 将 mysql.jar 拷贝到该目录下，点击 add to project ..加入到项目中
// 1. 注册驱动
Driver driver = new Driver(); //创建 driver 对象
// 2. 得到连接
// 老师解读
// (1) jdbc:mysql:
// 规定好表示协议，通过 jdbc 的方式连接 mysql
// (2) localhost 主机，可以是 ip 地址
// (3) 3306 表示 mysql 监听的端口
// (4) hsp_db02 连接到 mysql dbms 的哪个数据库
// (5) mysql 的连接本质就是前面学过的 socket 连接
String url = "jdbc:mysql://localhost:3306/db1";
//将 用户名和密码放入到 Properties 对象
Properties properties = new Properties();
// 说明 user 和 password 是规定好，后面的值根据实际情况写
properties.setProperty("user", "root");// 用户
properties.setProperty("password", "hong"); //密码
Connection connect = driver.connect(url, properties);//根据给定的url去连接数据库
//3. 执行 sql
String sql = "insert into dept values(41,'项目实战w')";
//String sql = "update actor set name='周星驰' where id = 1";
//String sql = "delete from actor where id = 1";
//statement 用于执行静态 SQL 语句并返回其生成的结果的对象
Statement statement = connect.createStatement();
int rows = statement.executeUpdate(sql); // 如果是 dml 语句，返回的就是影响行数
System.out.println(rows > 0 ? "成功" : "失败");
//4. 关闭连接资源
statement.close();
connect.close();
}
}1.4.2 DriverManager：驱动管理类
作用一：注册驱动
这个方法可以完成驱动的注册，但是实际开发中一般不会使用这个方法完成驱动的注册！！！
原因：
如果需要注册驱动，就会使用DriverManager.registerDriver(new Driver());，但是查看源代码发现，在代码中有一段静态代码块，静态代码块已经调用了注册驱动的方法。
如果再手动调用该方法注册驱动，就会导致驱动被注册两次。
实际开发中一般会采用：
1.1.1.2 *作用二：获得连接*
这个方法就是用来获得与数据库连接的方法：这个方法中有三个参数：
url ：与数据库连接的路径
user ：与数据库连接的用户名
password ：与数据库连接的密码
主要关注的是url的写法：
jdbc:mysql://localhost:3306/web_test3
jdbc :连接数据库的协议
mysql :是jdbc的子协议
localhost :连接的MySQL数据库服务器的主机地址。（连接是本机就可以写成localhost），如果连接不是本机的，就需要写上连接主机的IP地址。
3306 :MySQL数据库服务器的端口号
web_test3 :数据库名称
url如果连接的是本机的路径，可以简化为如下格式：
jdbc:mysql:///web_test3
1.4.3 Connection：与数据库连接对象
作用一：创建执行SQL语句的对象执行SQL语句对象:Statement :执行SQL
CallableStatement :执行数据库中存储过程
PreparedStatement :执行SQL.对SQL进行预处理。解决SQL注入漏洞。
作用二：管理事务
1.4.4 Statement(SQL注入)：执行SQL
-- 演示 sql 注入
-- 创建一张表
CREATE TABLE admin ( -- 管理员表
NAME VARCHAR(32) NOT NULL UNIQUE,
pwd VARCHAR(32) NOT NULL DEFAULT '') CHARACTER SET utf8;
-- 添加数据
INSERT INTO admin VALUES('tom', '123');
-- 查找某个管理是否存在
SELECT * FROM admin WHERE NAME = 'tom' AND pwd = '123'
-- SQL
-- 输入用户名 为 1' or
-- 输入万能密码 为 or '1'= '1
SELECT * FROM admin
WHERE NAME = '1' OR' AND pwd = 'OR '1'= '1' SELECT * FROM admin可以使用PreparedStatement限制
1.4.5ResultSet：结果集
通过select语句的查询结果。
1.1.1.1 *结果集的遍历*
结果集遍历原理
代码实现
1.1.1.2 *结果集的获取*
结果集获取可以使用结果集中的:
getXXX();方法通常都会有一个重载的方法。
getXXX(int columnIndex);
getXXX(String columnName);
package MySQL;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class Jdbctext01 {
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
Class.forName(driver);
Connection connection = DriverManager.getConnection(url, user, password);
//3. 得到 Statement
Statement statement = connection.createStatement();
//4. 组织 SqL
String sql = "select did, dname from dept";
ResultSet resultSet = statement.executeQuery(sql);
//5. 使用 while 取出数据
while (resultSet.next()) { // 让光标向后移动，如果没有更多行，则返回 false
int id = resultSet.getInt(1); //获取该行的第 1 列
String name = resultSet.getString(2);//获取该行的第 2 列
System.out.println(id+"\t"+name);
}
//6. 关闭连接
resultSet.close();
statement.close();
connection.close();
}
}
1.4.5jdbc的五种连接方式
建议使用第五种：
简洁并且可以修改内容
user=root
password=hong
url=jdbc:mysql://localhost:3306/db1
driver=com.mysql.jdbc.Driverpackage MySQL;
import com.mysql.jdbc.Driver;
import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.sql.SQLException;
import java.util.Properties;
public class JdbcConn {
@Test
//方式1
public void connect01() throws SQLException {
Driver dr01 = new Driver();
String url = "jdbc:mysql://localhost:3306/db1";
Properties properties = new Properties();
properties.setProperty("user", "root");// 用户
properties.setProperty("password", "hong"); //密码
Connection connect = dr01.connect(url, properties);//根据给定的url去连接数据库
}
@Test
//方式2 反射
public void connect02() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
//使用反射加载Driver类，动态加载，更加灵活，减少依赖性
Class aClass = Class.forName("com.mysql.jdbc.Driver");
Driver o = (Driver) aClass.newInstance();
Driver dr01 = new Driver();
String url = "jdbc:mysql://localhost:3306/db1";
Properties properties = new Properties();
properties.setProperty("user", "root");// 用户
properties.setProperty("password", "hong"); //密码
Connection connect = o.connect(url, properties);
System.out.println("反射：" + connect);
}
@Test
//方式 3 使用 DriverManager 替代 driver 进行统一管理
public void connect03() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
//使用反射加载river
Class aClass = Class.forName("com.mysql.jdbc.Driver");
Driver o = (Driver) aClass.newInstance();
//创建url，和user，password
String url = "jdbc:mysql://localhost:3306/db1";
String user = "root";
String password = "hong";
DriverManager.registerDriver(o);//注册driver驱动
Connection con = DriverManager.getConnection(url, user, password);
System.out.println("第三种：" + con);
}
//方式 4: 使用 Class.forName 自动完成注册驱动，简化代码
// 这种方式获取连接是使用的最多，推荐使用
@Test
public void connect04() throws ClassNotFoundException, SQLException {
//使用反射加载了 Driver 类，可以不用写
// 在加载 Driver 类时，完成注册
Class.forName("com.mysql.jdbc.Driver");
//创建url，和user，password
String url = "jdbc:mysql://localhost:3306/db1";
String user = "root";
String password = "hong";
Connection con = DriverManager.getConnection(url, user, password);
System.out.println("第 4 种方式~ " + con);
}
//方式 5 , 在方式 4 的基础上改进，增加配置文件，让连接 mysql 更加灵活
@Test
public void connect05() throws IOException, ClassNotFoundException, SQLException {
//通过 Properties 对象获取配置文件的信息
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//获取相应的值
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
Class.forName(driver);//建议写上,更加明确，假如驱动变化，里面有多个驱动，那么驱动就会混乱
Connection connection = DriverManager.getConnection(url, user, password);
System.out.println("方式 5 " + connection);
}
}
1.4.6 jdbc的PreparedStatement（DML）
配置环境
CREATE DATABASE web_test3;
USE web_test3;
CREATE TABLE USER(
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(20),
PASSWORD VARCHAR(20),
nickname VARCHAR(20),
age INT
)CHARACTER SET utf8;
INSERT INTO USER VALUES (NULL,'aaa','123','小丽',34);
INSERT INTO USER VALUES (NULL,'bbb','123','大王',32);
INSERT INTO USER VALUES (NULL,'ccc','123','小明',28);
INSERT INTO USER VALUES (NULL,'ddd','123','大黄',21);package MySQL;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class Jdbctext03 {
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
Class.forName(driver);
Connection connection = DriverManager.getConnection(url, user, password);
//4. 组织 SqL
//删除
//String sql = "delete from user where id = ?";
//添加
//String sql = "insert into user values (null,?,?,?,?)";
//查询
String sql = "select * from user";
//修改
//String sql = "update user set username = ?,password =?,nickname=?,age = ? where id = ?";
PreparedStatement pstmt=connection.prepareStatement(sql);
//修改
// pstmt.setString(1, "abc");
// pstmt.setString(2, "1234");
// pstmt.setString(3, "旺旺");
// pstmt.setInt(4, 23);
// pstmt.setInt(5, 6);
//删除
//pstmt.setInt(1, 4);
//添加
// pstmt.setString(1, "eee");
// pstmt.setString(2, "abc");
// pstmt.setString(3, "旺财");
// pstmt.setInt(4, 32);
//查询
ResultSet rs = pstmt.executeQuery(sql);
while(rs.next()){
System.out.println(rs.getInt("id")+" "+rs.getString("username")+" "+rs.getString("password")+" "+rs.getString("nickname"));
}
int num = pstmt.executeUpdate();
if(num > 0){
System.out.println("修改成功！");
}
else
System.out.println("修改失败");
//6. 关闭连接
pstmt.close();
connection.close();
}
}
API总结
2.DBUtils
2.1DBUtils的好处
1.是一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时不会影响程序的性能。
2.因为JDBC手写比较麻烦，而且有非常多的代码是类似的。比如获得连接，预编译SQL，释放资源等..那么可以将这些代码抽取出来放到工具类中。将类似的代码进行抽取。大大简化JDBC的编程。
2.2DBUtils的静态方法
package MySQL;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
/***
* 这是一个工具类，完成 mysql 的连接和关闭资源
*/
public class Jdbctext04 {
//定义相关的属性(4个), 因为只需要一份，因此，我们做出static
private static String user; //用户名
private static String password; //密码
private static String url; //url
private static String driver; //驱动名
//在static代码块去初始化
static {
try {
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//读取相关的属性值
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
} catch (IOException e) {
//在实际开发中，我们可以这样处理
//1. 将编译异常转成 运行异常
//2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便.
throw new RuntimeException(e);
}
}
//连接数据库, 返回Connection
public static Connection getConnection() {
try {
return DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
//1. 将编译异常转成 运行异常
//2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便.
throw new RuntimeException(e);
}
}
//关闭相关资源
/*
1. ResultSet 结果集
2. Statement 或者 PreparedStatement
3. Connection
4. 如果需要关闭资源，就传入对象，否则传入 null
*/
public static void close(ResultSet set, Statement statement, Connection connection) {
//判断是否为null
try {
if (set != null) {
set.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
//将编译异常转成运行异常抛出
throw new RuntimeException(e);
}
}
}
2.3DBUtils的调用
package MySQL;
import org.junit.Test;
import java.sql.*;
public class Text04_use {
@Test
public void testSelect() {
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "select * from actor where id = ?";
PreparedStatement preparedStatement = null;
ResultSet set = null;
//3. 创建PreparedStatement 对象
try {
connection = Jdbctext04.getConnection();
System.out.println(connection.getClass()); //com.mysql.jdbc.JDBC4Connection
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 5);//给?号赋值
//执行, 得到结果集
set = preparedStatement.executeQuery();
//遍历该结果集
while (set.next()) {
int id = set.getInt("id");
String name = set.getString("name");
String sex = set.getString("sex");
Date borndate = set.getDate("borndate");
String phone = set.getString("phone");
System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
Jdbctext04.close(set, preparedStatement, connection);
}
}
@Test
public void testDML() {//insert , update, delete
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "update actor set name = ? where id = ?";
// 测试 delete 和 insert ,自己玩.
PreparedStatement preparedStatement = null;
//3. 创建PreparedStatement 对象
try {
connection = Jdbctext04.getConnection();
preparedStatement = connection.prepareStatement(sql);
//给占位符赋值
preparedStatement.setString(1, "周星驰");
preparedStatement.setInt(2, 4);
//执行
preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
Jdbctext04.close(null, preparedStatement, connection);
}
}
}3.事务
3.1基本介绍：
-
JDBC程序中当一个Connection对象创建时，默认情况下时自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，二不能回滚。
-
JDBC程序中为了让多个SQL语句作为一个整体执行，需要使用事务
-
调用Connection 的setAutoCommit（false）可以取消自动提交事务
-
在所以的SQL语句都成功执行后，调用Connection的commit（）；方法提交事务
-
在其中某个操作失败或出现异常时，调用Connection的rollback；方法回滚事务
3.2环境适配
create database web_test4;
use web_test4;
create table account(
id int primary key auto_increment,
name varchar(20),
money double
);
insert into account values (null,'aaa',10000);
insert into account values (null,'bbb',10000);
insert into account values (null,'ccc',10000);在默认情况下，connection时默认自动提交，执行一句就提交，执行一句就提交，就会提交到数据库里面去了，但是如果成功转账但是没有执行后面的语句就会出现没有收到钱，但是却转出的问题
3.2.1没有事务的案例
@Test
/**
* 完成转账的案例
*/
public void demo1(){
Connection conn = null;
PreparedStatement pstmt = null;
try{
/**
* 完成转账代码：
* * 扣除某个账号的钱
* * 给另外一个账号加钱
*/
// 获得连接：
conn = JDBCUtils.getConnection();
// 编写SQL语句：
String sql = "update account set money = money + ? where name = ?";
// 预编译SQL:
pstmt = conn.prepareStatement(sql);
// 设置参数:
// 用aaa账号给bbb账号转1000元
pstmt.setDouble(1, -1000);
pstmt.setString(2, "aaa");
// 执行SQL：扣除aaa账号1000元
pstmt.executeUpdate();
// int i = 1 / 0;
// 给bbb账号加1000
pstmt.setDouble(1, 1000);
pstmt.setString(2, "bbb");
pstmt.executeUpdate();
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(pstmt, conn);
}
}在转账中没有添加事务的管理，出现aaa账号的钱被转丢了，但是bbb账号的钱没有任何变化。需要给转账的功能添加事务的管理。
3.2.2拥有事务的案例
@Test
/**
* 完成转账的案例
*/
public void demo1(){
Connection conn = null;
PreparedStatement pstmt = null;
try{
/**
* 完成转账代码：
* * 扣除某个账号的钱
* * 给另外一个账号加钱
*/
// 获得连接：
conn = JDBCUtils.getConnection();
// 开启事务
conn.setAutoCommit(false);
// 编写SQL语句：
String sql = "update account set money = money + ? where name = ?";
// 预编译SQL:
pstmt = conn.prepareStatement(sql);
// 设置参数:
// 用aaa账号给bbb账号转1000元
pstmt.setDouble(1, -1000);
pstmt.setString(2, "aaa");
// 执行SQL：扣除aaa账号1000元
pstmt.executeUpdate();
int i = 1 / 0;
// 给bbb账号加1000
pstmt.setDouble(1, 1000);
pstmt.setString(2, "bbb");
pstmt.executeUpdate();
// 提交事务:
conn.commit();
}catch(Exception e){
// 回滚事务:
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally{
JDBCUtils.release(pstmt, conn);
}
}4.批处理
4.1基本介绍
1．当需要成批插入或者更新记录时。可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率。
2.JDBC的批量处理语句包括下面方法:
addBatch():添加需要批量处理的SQL语句或参数
executeBatch():执行批量处理语句;
clearBatch():清空批处理包的语句 3.JDBC连接MySQL时,如果要使用批处理功能，请再url中加参 数?
rewriteBatchedStatements=true 4批处理往往和PreparedStatement一起搭配使用，可以既减少编译次数，又减 少运行次数，效率大大提高
4.1批处理基本使用
@Test
/**
* 批处理基本操作
*/
public void demo1(){
Connection conn = null;
Statement stmt = null;
try{
// 获得连接:
conn = JDBCUtils.getConnection();
// 创建执行批处理对象:
stmt = conn.createStatement();
// 编写一批SQL语句：
String sql1 = "create database test1";
String sql2 = "use test1";
String sql3 = "create table user(id int primary key auto_increment,name varchar(20))";
String sql4 = "insert into user values (null,'aaa')";
String sql5 = "insert into user values (null,'bbb')";
String sql6 = "insert into user values (null,'ccc')";
String sql7 = "update user set name = 'mmm' where id = 2";
String sql8 = "delete from user where id = 1";
// 添加到批处理
stmt.addBatch(sql1);
stmt.addBatch(sql2);
stmt.addBatch(sql3);
stmt.addBatch(sql4);
stmt.addBatch(sql5);
stmt.addBatch(sql6);
stmt.addBatch(sql7);
stmt.addBatch(sql8);
// 执行批处理:
stmt.executeBatch();
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(stmt, conn);
}
}4.3 批量插入(使用PreparedStatement)
@Test
/**
* 批量插入记录:
* * 默认情况下MySQL批处理没有开启的，需要在url后面拼接一个参数即可。
*/
public void demo2(){
// 记录开始时间:
long begin = System.currentTimeMillis();
Connection conn = null;
PreparedStatement pstmt = null;
try{
// 获得连接:
conn = JDBCUtils.getConnection();
// 编写SQL语句：
String sql = "insert into user values (null,?)";
// 预编译SQL:
pstmt = conn.prepareStatement(sql);
for(int i=1;i<=10000;i++){
pstmt.setString(1, "name"+i);
// 添加到批处理
pstmt.addBatch();
// 注意问题：
// 执行批处理
if(i % 1000 == 0){
// 执行批处理:
pstmt.executeBatch();
// 清空批处理:
pstmt.clearBatch();
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(pstmt, conn);
}
long end = System.currentTimeMillis();
System.out.println((end-begin));
}将sql 语句加入到批处理包中 -> 看源码
-
第一就创建 ArrayList - elementData => Object[]
-
elementData => Object[] 就会存放我们预处理的sql语句 3. 当elementData满后,就按照1.5扩容 44. 当添加到指定的值后，就executeBatch 5. 批量处理会减少我们发送sql语句的网络开销，而且减少编译次数，因此效率提高
-
5.数据库连接池
5.1 传统获取 Connection 问题分析
-
传统的JDBC数据库连接使用DriverManager来获取，么此向数据库建立连接的时候都要将Connection加载到内存中，在验证ip地址，用户名和密码（0.5~1s时间）。需要数据库连接的时候，就向数据库要求一个，频繁的进行数据库操作将占有很多的系统资源，容易造成服务器崩溃。
-
每一次数据库连接，使用完后都得断开，如果出现出现异常二未能关闭，将导致数据库内存泄漏，最终导致重启数据库。
-
传统获取连接的方式，不能控制创建的连接数量，如果连接过多，也可能导致内存泄漏，MySQL崩溃。
-
解决传统开发中的数据库连接问题，可以采用数据库连接池技术（connection pool）。
5.2 什么是连接池
连接池是装有连接的容器，使用连接的话，可以从连接池中进行获取，使用完成之后将连接归还给连接池。
-
预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕后在放回去。
-
数据库连接池负责分配，管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
-
当应用程序向连接池请求的连接数量超过最大连接数量时，这些请求将被加入到等待队列中
5.3学习连接池大的目的
连接对象创建和销毁是需要耗费时间的，在服务器初始化的时候就初始化一些连接。把这些连接放入到内存中，使用的时候可以从内存中获取，使用完成之后将连接放入连接池中。从内存中获取和归还的效率要远远高于创建和销毁的效率。（提升性能）。
5.4连接池原理
5.5数据库连接池种类
-
JDBC的数据库连接池使用javax.DayeSource来表示，DataSource只是一个接口，该接口通常由第三方提供[提供.jar]
-
C3P0 数据库连接池，速度相对较慢 ，稳定性不错（hibernate，spring）
-
DBCP数据库连接池，速度相对于C3P0较快，但不稳定
-
Proxool数据库连接池，有监控连接池状态的功能，稳定性叫C3P0差一点
-
Bonecp数据库连接池，速度快
-
Druid（德鲁伊）是阿里提供的数据库连接池，集DBCP,C3P0,Proxool有点于一身的数据库连接池
5.6 C3P0的两种方式
package MySQL;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
public class C3P0_ {
//方式 1： 相关参数，在程序中指定 user, url , password 等
@Test
public void testC3P0_01() throws Exception {
//1. 创建一个数据源对象
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
//2. 通过配置文件 mysql.properties 获取相关连接的信息
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties")); //读取相关的属性值
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String url = properties.getProperty("url");
String driver = properties.getProperty("driver");
//给数据源 comboPooledDataSource 设置相关的参数
// 注意：连接管理是由 comboPooledDataSource 来管理
comboPooledDataSource.setDriverClass(driver);
comboPooledDataSource.setJdbcUrl(url);
comboPooledDataSource.setUser(user);
comboPooledDataSource.setPassword(password);
//设置初始化连接数
comboPooledDataSource.setInitialPoolSize(10);
//最大连接数
comboPooledDataSource.setMaxPoolSize(50);
//测试连接池的效率, 测试对 mysql 5000 次操作
long start = System.currentTimeMillis();
for (int i = 0; i < 5000; i++) {
Connection connection = comboPooledDataSource.getConnection(); //这个方法就是从 DataSource 接口 实现的
// System.out.println("连接 OK");
connection.close();
}
long end = System.currentTimeMillis();
//c3p0 5000 连接 mysql 耗时=391
System.out.println("c3p0 5000 连接 mysql 耗时=" + (end - start));
}
//第二种方式 使用配置文件模板来完成
// 1. 将 c3p0 提供的 c3p0.config.xml 拷贝到 src 目录下
// 2. 该文件指定了连接数据库和连接池的相关参数
@Test
public void testC3P0_02() throws SQLException {
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("hsp_edu");
//测试 5000 次连接 mysql
long start = System.currentTimeMillis();
System.out.println("开始执行....");
for (int i = 0; i < 500000; i++) {
Connection connection = comboPooledDataSource.getConnection();
//System.out.println("连接 OK~");
connection.close();
}
long end = System.currentTimeMillis();
//c3p0 的第二种方式 耗时=413
System.out.println("c3p0 的第二种方式(500000) 耗时=" + (end - start));//1917 }
}
}5.7Druid--德鲁伊的使用
Druid阿里旗下开源连接池产品，使用非常简单，可以与Spring框架进行快速整合。
一
@Test
/**
* Druid的使用:
* * 手动设置参数的方式
*/
public void demo1(){
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try{
// 使用连接池：
DruidDataSource dataSource = new DruidDataSource();
// 手动设置数据库连接的参数:
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///web_test4");
dataSource.setUsername("root");
dataSource.setPassword("abc");
// 获得连接：
// conn = JDBCUtils.getConnection();
conn = dataSource.getConnection();
// 编写SQL:
String sql = "select * from account";
// 预编译SQL:
pstmt = conn.prepareStatement(sql);
// 设置参数:
// 执行SQL:
rs = pstmt.executeQuery();
while(rs.next()){
System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
}
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(rs, pstmt, conn);
}
}二
@Test
/**
* Druid的使用:
* * 配置方式设置参数
* Druid配置方式可以使用属性文件配置的。
* * 文件名称没有规定但是属性文件中的key要一定的。
*/
public void demo2(){
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try{
// 使用连接池：
// 从属性文件中获取：
Properties properties = new Properties();
properties.load(new FileInputStream("src/druid.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
// 获得连接：
// conn = JDBCUtils.getConnection();
conn = dataSource.getConnection();
// 编写SQL:
String sql = "select * from account";
// 预编译SQL:
pstmt = conn.prepareStatement(sql);
// 设置参数:
// 执行SQL:
rs = pstmt.executeQuery();
while(rs.next()){
System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
}
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(rs, pstmt, conn);
}
}5.8 德鲁伊工具类
package com.hspedu.jdbc.datasource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* 基于druid数据库连接池的工具类
*/
public class JDBCUtilsByDruid {
private static DataSource ds;
//在静态代码块完成 ds初始化
static {
Properties properties = new Properties();
try {
properties.load(new FileInputStream("src\\druid.properties"));
ds = DruidDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}
//编写getConnection方法
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
//关闭连接, 老师再次强调： 在数据库连接池技术中，close 不是真的断掉连接
//而是把使用的Connection对象放回连接池
public static void close(ResultSet resultSet, Statement statement, Connection connection) {
try {
if (resultSet != null) {
resultSet.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}5.8.1使用
package com.hspedu.jdbc.datasource;
import org.junit.jupiter.api.Test;
import java.sql.*;
import java.util.ArrayList;
/**
* @author 韩顺平
* @version 1.0
*/
@SuppressWarnings({"all"})
public class JDBCUtilsByDruid_USE {
@Test
public void testSelect() {
System.out.println("使用 druid方式完成");
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "select * from actor where id >= ?";
PreparedStatement preparedStatement = null;
ResultSet set = null;
//3. 创建PreparedStatement 对象
try {
connection = JDBCUtilsByDruid.getConnection();
System.out.println(connection.getClass());//运行类型 com.alibaba.druid.pool.DruidPooledConnection
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 1);//给?号赋值
//执行, 得到结果集
set = preparedStatement.executeQuery();
//遍历该结果集
while (set.next()) {
int id = set.getInt("id");
String name = set.getString("name");//getName()
String sex = set.getString("sex");//getSex()
Date borndate = set.getDate("borndate");
String phone = set.getString("phone");
System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtilsByDruid.close(set, preparedStatement, connection);
}
}
//使用老师的土方法来解决ResultSet =封装=> Arraylist
@Test
public ArrayList testSelectToArrayList() {
System.out.println("使用 druid方式完成");
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "select * from actor where id >= ?";
PreparedStatement preparedStatement = null;
ResultSet set = null;
ArrayList list = new ArrayList<>();//创建ArrayList对象,存放actor对象
//3. 创建PreparedStatement 对象
try {
connection = JDBCUtilsByDruid.getConnection();
System.out.println(connection.getClass());//运行类型 com.alibaba.druid.pool.DruidPooledConnection
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 1);//给?号赋值
//执行, 得到结果集
set = preparedStatement.executeQuery();
//遍历该结果集
while (set.next()) {
int id = set.getInt("id");
String name = set.getString("name");//getName()
String sex = set.getString("sex");//getSex()
Date borndate = set.getDate("borndate");
String phone = set.getString("phone");
//把得到的resultset 的记录，封装到 Actor对象，放入到list集合
list.add(new Actor(id, name, sex, borndate, phone));
}
System.out.println("list集合数据=" + list);
for(Actor actor : list) {
System.out.println("id=" + actor.getId() + "\t" + actor.getName());
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtilsByDruid.close(set, preparedStatement, connection);
}
//因为ArrayList 和 connection 没有任何关联，所以该集合可以复用.
return list;
}
} 6.Apache—DBUtils
6.1为何使用：
-
关闭connection后，result结果集无法使用
-
result不利于数据的管理
-
示意图：
分析：
就是将数据库数据存储大一个集合之中，一个表的数据全部转移到一个集合之中，就是表里面的所以数据和集合关联起来了
6.2基本介绍
1.commons-dbutils是Apache 组织提供的一个开源JDBC工具类库，它是对JDBC的封装, 使用dbutils能极大简化jdbc编码的工作量[真的]。 ·DbUtils类
1.QueryRunner类:该类封装了SQL的执行，是线程安全的。可以实现增、删、 改、查、批处理
2.使用QueryRunner类实现查询
3.ResultSetHandler接口:该接口用于处理java.sql.ResultSet,将数据按要求转换为另一种形式,
ArrayHandler:把结果集中的第一行数据转成对象数组。 ArrayListHandler:把结果集中的每一行数据都转成一个数组，再存放到List中。BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中。 BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。ColumnListHandler:将结果集中某一列的数据存放到List中。 KeyedHandler(name):将结果集中的每行数据都封装到Map里，再把这些map再存到一个map里, 其key为指定的key。 MapHandler:将结果集中的第一行数据封装到一个Map里，key是列名,value就是对应的值。 MapListHandler:将结果集中的每一行数据都封装到一个Map里，然后再存放到List
6.3应用
package MySQL;
import java.util.Date;
/**
* Actor 对象和 actor表的记录对应
*
*/
public class Actor { //Javabean, POJO, Domain对象
private Integer id;
private String name;
private String sex;
private Date borndate;
private String phone;
public Actor() { //一定要给一个无参构造器[反射需要]
}
public Actor(Integer id, String name, String sex, Date borndate, String phone) {
this.id = id;
this.name = name;
this.sex = sex;
this.borndate = borndate;
this.phone = phone;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBorndate() {
return borndate;
}
public void setBorndate(Date borndate) {
this.borndate = borndate;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
@Override
public String toString() {
return "\nActor{" +
"id=" + id +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
", borndate=" + borndate +
", phone='" + phone + '\'' +
'}';
}
}6.3.1Apache 的crud操作和单行and单列单行和dml
package MySQL;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.jupiter.api.Test;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* @version 1.0
*/
@SuppressWarnings({"all"})
public class DBUtils_USE {
//使用apache-DBUtils 工具类 + druid 完成对表的crud操作
@Test
public void testQueryMany() throws SQLException { //返回结果是多行的情况
//1. 得到 连接 (druid)
Connection connection = JDBCUtilsByDruid.getConnection();
//2. 使用 DBUtils 类和接口 , 先引入DBUtils 相关的jar , 加入到本Project
//3. 创建 QueryRunner
QueryRunner queryRunner = new QueryRunner();
//4. 就可以执行相关的方法，返回ArrayList 结果集
//String sql = "select * from actor where id >= ?";
// 注意: sql 语句也可以查询部分列
String sql = "select id, name from actor where id >= ?";
// 解读
//(1) query 方法就是执行sql 语句，得到resultset ---封装到 --> ArrayList 集合中
//(2) 返回集合
//(3) connection: 连接
//(4) sql : 执行的sql语句
//(5) new BeanListHandler<>(Actor.class): 在将resultset -> Actor 对象 -> 封装到 ArrayList
// 底层使用反射机制 去获取Actor 类的属性，然后进行封装
//(6) 1 就是给 sql 语句中的? 赋值，可以有多个值，因为是可变参数Object... params
//(7) 底层得到的resultset ,会在query 关闭, 关闭PreparedStatment
/**
* 分析 queryRunner.query方法:
* public T query(Connection conn, String sql, ResultSetHandler rsh, Object... params) throws SQLException {
* PreparedStatement stmt = null;//定义PreparedStatement
* ResultSet rs = null;//接收返回的 ResultSet
* Object result = null;//返回ArrayList
*
* try {
* stmt = this.prepareStatement(conn, sql);//创建PreparedStatement
* this.fillStatement(stmt, params);//对sql 进行 ? 赋值
* rs = this.wrap(stmt.executeQuery());//执行sql,返回resultset
* result = rsh.handle(rs);//返回的resultset --> arrayList[result] [使用到反射，对传入class对象处理]
* } catch (SQLException var33) {
* this.rethrow(var33, sql, params);
* } finally {
* try {
* this.close(rs);//关闭resultset
* } finally {
* this.close((Statement)stmt);//关闭preparedstatement对象
* }
* }
*
* return result;
* }
*/
List list =
queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);
System.out.println("输出集合的信息");
for (Actor actor : list) {
System.out.print(actor);
}
//释放资源
JDBCUtilsByDruid.close(null, null, connection);
}
//演示 apache-dbutils + druid 完成 返回的结果是单行记录(单个对象)
@Test
public void testQuerySingle() throws SQLException {
//1. 得到 连接 (druid)
Connection connection = JDBCUtilsByDruid.getConnection();
//2. 使用 DBUtils 类和接口 , 先引入DBUtils 相关的jar , 加入到本Project
//3. 创建 QueryRunner
QueryRunner queryRunner = new QueryRunner();
//4. 就可以执行相关的方法，返回单个对象
String sql = "select * from actor where id = ?";
// 老韩解读
// 因为我们返回的单行记录<--->单个对象 , 使用的Hander 是 BeanHandler
Actor actor = queryRunner.query(connection, sql, new BeanHandler<>(Actor.class), 10);
System.out.println(actor);
// 释放资源
JDBCUtilsByDruid.close(null, null, connection);
}
//演示apache-dbutils + druid 完成查询结果是单行单列-返回的就是object
@Test
public void testScalar() throws SQLException {
//1. 得到 连接 (druid)
Connection connection = JDBCUtilsByDruid.getConnection();
//2. 使用 DBUtils 类和接口 , 先引入DBUtils 相关的jar , 加入到本Project
//3. 创建 QueryRunner
QueryRunner queryRunner = new QueryRunner();
//4. 就可以执行相关的方法，返回单行单列 , 返回的就是Object
String sql = "select name from actor where id = ?";
//老师解读： 因为返回的是一个对象, 使用的handler 就是 ScalarHandler
Object obj = queryRunner.query(connection, sql, new ScalarHandler(), 4);
System.out.println(obj);
// 释放资源
JDBCUtilsByDruid.close(null, null, connection);
}
//演示apache-dbutils + druid 完成 dml (update, insert ,delete)
@Test
public void testDML() throws SQLException {
//1. 得到 连接 (druid)
Connection connection = JDBCUtilsByDruid.getConnection();
//2. 使用 DBUtils 类和接口 , 先引入DBUtils 相关的jar , 加入到本Project
//3. 创建 QueryRunner
QueryRunner queryRunner = new QueryRunner();
//4. 这里组织sql 完成 update, insert delete
//String sql = "update actor set name = ? where id = ?";
//String sql = "insert into actor values(null, ?, ?, ?, ?)";
String sql = "delete from actor where id = ?";
//老韩解读
//(1) 执行dml 操作是 queryRunner.update()
//(2) 返回的值是受影响的行数 (affected: 受影响)
//int affectedRow = queryRunner.update(connection, sql, "林青霞", "女", "1966-10-10", "116");
int affectedRow = queryRunner.update(connection, sql, 1000 );
System.out.println(affectedRow > 0 ? "执行成功" : "执行没有影响到表");
// 释放资源
JDBCUtilsByDruid.close(null, null, connection);
}
} 7.DAO类（数据库操作对象）
7.1DAO的引入
apache—dbutils+Druid简化了JDBC开发，但还有不足：
-
SQL语句是固定的，不能通过参数传入，通用性不好，需要进行改进，更方便执行增删改查
-
对于select操作，如果有返回值，返回类型不好固定，需要使用泛型
-
将来的表更多，业务需求复杂，不可能只靠一个java类完成
7.2基本说明
-
DAO：data access object数据访问对象
-
这样的通用类，称为BasicDAO，是专门和数据库交互的，即完成对数据库（表）的crud（增删改查）操作
-
在BasicDao的基础上，实现一张表对应一个DAO，更好的完成功能，比如Customer表-Customer.java类（javabean）-CustomerDao.java
-
7.3应用实例
一个简单的设计
1.util工具类
2.domain javabean
3.dao 存放 xxxDao和BasicDao
4.test 写测试类
1.util工具类
package MySQL.dao_.utils; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import java.io.FileInputStream; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.Properties; /** * @version 1.0 * 基于druid数据库连接池的工具类 */ public class JDBCUtilsByDruid { private static DataSource ds; //在静态代码块完成 ds初始化 static { Properties properties = new Properties(); try { properties.load(new FileInputStream("src\\druid.properties")); ds = DruidDataSourceFactory.createDataSource(properties); } catch (Exception e) { e.printStackTrace(); } } //编写getConnection方法 public static Connection getConnection() throws SQLException { return ds.getConnection(); } //关闭连接, 老师再次强调： 在数据库连接池技术中，close 不是真的断掉连接 //而是把使用的Connection对象放回连接池 public static void close(ResultSet resultSet, Statement statement, Connection connection) { try { if (resultSet != null) { resultSet.close(); } if (statement != null) { statement.close(); } if (connection != null) { connection.close(); } } catch (SQLException e) { throw new RuntimeException(e); } } }
-
2.domain javabean
package MySQL.dao_.domain; import java.util.Date; /** * Actor 对象和 actor表的记录对应 * */ public class Actor { //Javabean, POJO, Domain对象 private Integer id; private String name; private String sex; private Date borndate; private String phone; public Actor() { //一定要给一个无参构造器[反射需要] } public Actor(Integer id, String name, String sex, Date borndate, String phone) { this.id = id; this.name = name; this.sex = sex; this.borndate = borndate; this.phone = phone; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Date getBorndate() { return borndate; } public void setBorndate(Date borndate) { this.borndate = borndate; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } @Override public String toString() { return "\nActor{" + "id=" + id + ", name='" + name + '\'' + ", sex='" + sex + '\'' + ", borndate=" + borndate + ", phone='" + phone + '\'' + '}'; } } 3.dao 存放 actorDao和BasicDao
package MySQL.dao_.dao; import MySQL.dao_.utils.JDBCUtilsByDruid; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.BeanHandler; import org.apache.commons.dbutils.handlers.BeanListHandler; import org.apache.commons.dbutils.handlers.ScalarHandler; import java.sql.Connection; import java.sql.SQLException; import java.util.List; /** * 开发BasicDAO , 是其他DAO的父类 */ public class BasicDAO{ //泛型指定具体类型 private QueryRunner qr = new QueryRunner(); //开发通用的dml方法, 针对任意的表 public int update(String sql, Object... parameters) { Connection connection = null; try { connection = JDBCUtilsByDruid.getConnection(); int update = qr.update(connection, sql, parameters); return update; } catch (SQLException e) { throw new RuntimeException(e); //将编译异常->运行异常 ,抛出 } finally { JDBCUtilsByDruid.close(null, null, connection); } } //返回多个对象(即查询的结果是多行), 针对任意表 /** * * @param sql sql 语句，可以有 ? * @param clazz 传入一个类的Class对象 比如 Actor.class * @param parameters 传入 ? 的具体的值，可以是多个 * @return 根据Actor.class 返回对应的 ArrayList 集合 */ public List queryMulti(String sql, Class clazz, Object... parameters) { Connection connection = null; try { connection = JDBCUtilsByDruid.getConnection(); return qr.query(connection, sql, new BeanListHandler (clazz), parameters); } catch (SQLException e) { throw new RuntimeException(e); //将编译异常->运行异常 ,抛出 } finally { JDBCUtilsByDruid.close(null, null, connection); } } //查询单行结果 的通用方法 public T querySingle(String sql, Class clazz, Object... parameters) { Connection connection = null; try { connection = JDBCUtilsByDruid.getConnection(); return qr.query(connection, sql, new BeanHandler (clazz), parameters); } catch (SQLException e) { throw new RuntimeException(e); //将编译异常->运行异常 ,抛出 } finally { JDBCUtilsByDruid.close(null, null, connection); } } //查询单行单列的方法,即返回单值的方法 public Object queryScalar(String sql, Object... parameters) { Connection connection = null; try { connection = JDBCUtilsByDruid.getConnection(); return qr.query(connection, sql, new ScalarHandler(), parameters); } catch (SQLException e) { throw new RuntimeException(e); //将编译异常->运行异常 ,抛出 } finally { JDBCUtilsByDruid.close(null, null, connection); } } } package MySQL.dao_.dao; import MySQL.dao_.domain.Actor; /** * @version 1.0 */ public class ActorDAO extends BasicDAO { //1. 就有 BasicDAO 的方法 //2. 根据业务需求，可以编写特有的方法. } 4.test 写测试类
package MySQL.dao_.test; import MySQL.dao_.dao.ActorDAO; import MySQL.dao_.domain.Actor; import org.junit.Test; import java.util.List; public class TestDAO { //测试ActorDAO 对actor表crud操作 @Test public void testActorDAO() { ActorDAO actorDAO = new ActorDAO(); //1. 查询 Listactors = actorDAO.queryMulti("select * from actor where id >= ?", Actor.class, 1); System.out.println("===查询结果==="); for (Actor actor : actors) { System.out.println(actor); } //2. 查询单行记录 Actor actor = actorDAO.querySingle("select * from actor where id = ?", Actor.class, 6); System.out.println("====查询单行结果===="); System.out.println(actor); //3. 查询单行单列 Object o = actorDAO.queryScalar("select name from actor where id = ?", 6); System.out.println("====查询单行单列值==="); System.out.println(o); //4. dml操作 insert ,update, delete int update = actorDAO.update("insert into actor values(null, ?, ?, ?, ?)", "张无忌", "男", "2000-11-11", "999"); System.out.println(update > 0 ? "执行成功" : "执行没有影响表"); } }