目录
jdbc的jar包：
java的数据库存储技术：
- JDBC直接访问数据库
- JDO (Java Data Object )技术
- 第三方O/R工具，如Hibernate, Mybatis等
JDBC是什么？
- JDBC（Java DataBase Connectivity：java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系型数据库提供统一访问，它是由一组用Java语言编写的类和接口组成的。
- JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。
JDBC有什么用？
- 可以通过java代码操作数据库
- java程序员使用JDBC，可以连接任何提供了JDBC驱动程序的数据库系统，从而完成对数据的各种操作，大大简化和加快了开发过程。
JDBC体系结构：（两层）
- 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
- 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用，不同数据库厂商提供不同的实现。
JDBC API是什么？
JDBC API是一系列的接口，它统一和规范了应用程序与数据库的连接、执行SQL语句，并得到返回结果等各类操作，相关类和接口在java.sql与javax.sql包中
JDBC程序编写步骤：
获取数据库连接：
- 创建Driver接口实现类的对象
- Oracle的驱动：oracle.jdbc.driver.OracleDriver
- mySql的驱动：com.mysql.jdbc.Driver
- 通过URL选择正确的驱动程序，从而建立到数据库的连接。
- url格式：
- 协议+子协议+子名称（主机名+商品号+数据库名）
- 设置用户名和密码
- 建立连接
JDBC程序编写步骤：
- 注册驱动——加载Driver类
- 获取连接——得到Connection
- 执行增删改查——发送SQL给mysql执行
- 释放资源——关闭相关连接
package com.hspedu.jdbc;
import com.mysql.jdbc.Driver;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* 第一个JDBC程序，完成简单的操作
*/
@SuppressWarnings({"all"})
public class Jdbc01 {
public static void main(String[] args) throws SQLException {
//1、注册驱动
Driver driver = new Driver();//创建driver对象
//2、得到连接
//(1)jdbc:mysql// 规定好的，表示协议，通过jdbc的方式连接mysql
//(2)localhost 表示主机，可以是ip地址
//(3)3306 表示mysql监听的端口
//(4)hsp_db05 表示连接到mysql dbms的哪个数据库
//mysql的连接本质就是前面学过的socket连接
String url="jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8";
//Thu Jan 05 12:03:59 CST 2023 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
//周四 1月 05 12：03：59 CST 2023 WARN：不建议在没有服务器身份验证的情况下建立 SSL 连接。根据 MySQL 5.5.45+、5.6.26+ 和 5.7.6+ 要求，如果未设置显式选项，则必须默认建立 SSL 连接。为了符合不使用 SSL 的现有应用程序，验证服务器证书属性设置为“false”。您需要通过设置 useSSL=false 来显式禁用 SSL，或者设置 useSSL=true 并为服务器证书验证提供信任库。
//出现中文乱码，所以url后面加上了"?useSSL=true&characterEncoding=utf8"
//将用户名和密码放入到Properties对象
//user和password是规定好的，后面的值根据实际情况写
Properties properties = new Properties();
properties.setProperty("user","root");//用户
properties.setProperty("password","123456");//密码
Connection connect = driver.connect(url,properties);
//3、执行连接
//String sql="insert into actor values(null,'刘德华','男','1970-11-11','110')";
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();
}
}
2、获取数据库连接的5种方式（方式4使用最多，推荐使用）
package com.hspedu.jdbc;
import com.mysql.jdbc.Driver;
import org.junit.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/**
* 分析java连接mysql的5种方式
*/
public class JdbcConn {
@Test
public void connect01() throws SQLException {
//1.提供java.sgl.Driver接口实现类的对象
Driver driver = new Driver();
//2.提供ur1，指明具体操作的数据
String url="jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8";
//3.提供Properties的对象，指明用户名和密码
Properties properties = new Properties();
properties.setProperty("user","root");//用户
properties.setProperty("password","123456");//密码
//4.调用driver的connect，获取连接
Connection connect = driver.connect(url,properties);
System.out.println("方式1："+connect);
//方式1：com.mysql.jdbc.JDBC4Connection@59906517
}
@Test
public void connect02() throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
//使用反射加载Driver类，动态加载，更加灵活，减少依赖性
Class<?> aClass=Class.forName("com.mysql.jdbc.Driver");
Driver driver=(Driver)aClass.newInstance();
String url="jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8";
Properties properties = new Properties();
properties.setProperty("user","root");//用户
properties.setProperty("password","123456");//密码
Connection connect = driver.connect(url,properties);
System.out.println("方式2："+connect);
//方式2：com.mysql.jdbc.JDBC4Connection@59906517
}
@Test
//使用DriverManager替代driver进行统一管理
public void connect03() throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
//使用反射加载Driver类
Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver) aClass.newInstance();
String url = "jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8";
String user="root";
String password="123456";
DriverManager.registerDriver(driver);//注册Driver驱动
Connection connection = DriverManager.getConnection(url, user, password);
System.out.println("方式3："+connection);
//方式3：com.mysql.jdbc.JDBC4Connection@77f99a05
}
@Test
//使用Class.forName自动完成注册驱动，简化代码
public void connect04() throws ClassNotFoundException, SQLException {
//使用反射加载Driver类
//在加载Driver类时，完成注册
Class.forName("com.mysql.jdbc.Driver");
//com.mysql.jdbc.Driver追源码：
/*
//静态代码块，在类加载时，会执行一次
static {
try {
//注册
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
*/
String url = "jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8";
String user="root";
String password="123456";
Connection connection = DriverManager.getConnection(url, user, password);
System.out.println("方式4："+connection);
//方式4：com.mysql.jdbc.JDBC4Connection@77ec78b9
}
@Test
//在方式4的基础上改进，增加配置文件，让连接mysql更加灵活
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);
//方式5：com.mysql.jdbc.JDBC4Connection@77ec78b9
}
}
操作和访问数据库：
在java.sql包中有3个接口分别定义了对数据库的调用的不同方式：
- Statement：用于执行静态SQL语句并返回它所生成结果的对象。
- PrepatedStatement：SQL语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
- CallableStatement：用于执行SQL存储过程
1、ResultSet [结果集]
（1）基本介绍：
- 查询需要调用Preparedstatement的executeQueryO方法，查询结果是一个ResultSet对象
- Resultset对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet接口由数据库厂商提供实现Resultset返回的实际上就是一张数据表。
- ResultSet对象维护了一个指向当前数据行的光标。最初，光标位于第一行之前
- next方法将光标移动到下一行，并且由于在ResultSet对象中没有更多行时返回false，因此可以在while循环中使用循环来遍历结果集
- 当指针指向一行时，可以通过调用getxxx（int index）或getxxx（int columnName）获取每一列的值（java与数据库交互涉及到的相关java API中的索引都从1开始）
得到结果集后，如何知道该结果集中有哪些列？列名是什么？
- 需要使用一个描述ResultSet的对象，即ResultSetMetaData
关于ResultsetMetaData：
- ResultSetMetaData meta = rs.getMetaData() ；
- getColumnName（int column)：获取指定列的名称
- getColumnLabel（int column)：获取指定列的别名
- getColumnCount()：返回当前Resultset对象中的列数
- getColumnTypeName（int column）：检索指定列的数据库特定的类型名称
- getColumnDisplaySize（int column）：指示指定列的最大标准宽度，以字符为单位。
- isNullable（int column）：指示指定列中的值是否可以为null
- isAutolncrement（int column）：指示是否自动为指定列进行编号，这样这些列仍然是只读的
package com.hspedu.jdbc;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
@SuppressWarnings({"all"})
public class ResultSet_ {
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);
//得到statement
Statement statement = connection.createStatement();
//组织sql
String sql="select id,name,sex,borndate from actor";
//执行给定的sql语句，该语句返回单个ResultSet对象
ResultSet resultSet = statement.executeQuery(sql);
//使用while取出数据
while(resultSet.next()){//让光标向后移动，如果没有更多行，则返回false
int id=resultSet.getInt(1);//获取该行的第1列
String name=resultSet.getString(2);//获取该行的第2列
String sex=resultSet.getString(3);
Date date=resultSet.getDate(4);
System.out.println(id+"\t"+name+"\t"+sex+"\t"+date);
}
//关闭连接
resultSet.close();
statement.close();
connection.close();
}
}
/*
10 林黛玉 男 2000-01-01
11 贾宝玉 男 2000-01-01
12 贾宝玉 男 2000-01-01
13 贾宝玉 男 2000-01-01
*/
2、Statement
（1）基本介绍：
- Statement对象用于执行静态SQL语句并返回其生成的结果的对象
- 在连接建立后， 需要对数据库进行访问，执行命名或是SQL语句， 可以通过 Statement [存在SQL注入] PreparedStatement [预处理] Callabletatement [存储过程]
- Statement接口中定义了下列方法用于执行SQL语句：
- int excuteUpdate(String sql); //执行更新操作INSERT, UPDATE, DELETE
- ResultSet executeQuery(String sql); //执行查询操作SELECT
- Statement对象执行SQL语句，存在SQL注入风险
- SQL注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的SQL语句段或命令，恶意攻击数据库。
- 要防范SQL注入，只要用Preparedstatement（Statement扩展而来）取代Statement就可以了
package com.hspedu.jdbc;
/**
* 用java程序演示sql注入
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;
@SuppressWarnings({"all"})
public class Statement_{
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
Scanner scanner = new Scanner(System.in);
//让用户输入管理员名和密码
System.out.println("请输入管理员的名字：");
String admin_name=scanner.nextLine();//next()遇到空格或单引号结束；nextLine()遇到回车结束;
System.out.println("请输入管理员的密码：");
String admin_pwd=scanner.nextLine();
//通过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);
//得到statement
Statement statement = connection.createStatement();
//组织sql
String sql="select name,pwd from admin where name= '"
+admin_name+"' and pwd='"+admin_pwd+"'";
ResultSet resultSet = statement.executeQuery(sql);
if(resultSet.next()){
System.out.println("恭喜，登录成功");
}else{
System.out.println("对不起，登录失败");
}
//关闭连接
resultSet.close();
statement.close();
connection.close();
}
}
/*
请输入管理员的名字：
tom
请输入管理员的密码：
123
恭喜，登录成功
---------------
请输入管理员的名字：
1' or
请输入管理员的密码：
or '1'='1
恭喜，登录成功
*/
3、PreparedStatement
（1）基本介绍：
- Preparedstatement接口是Statement的子接口，它表示一条预编译过的SQL语句
- Preparedstatement执行的SQL语句中的参数用问号（？）来表示，调用Preparedstatement对象的setXxx()方法来设置这些参数。setXxx()方法有两个参数，第一个参数是要设置的SQL语句中的参数的索引（从1开始），第二个是设置的SQL语句中的参数的值
- 可以通过调用Connection对象的preparedstatement(string sql）方法获取Preparedstatement对象
- 调用executeQuery()，返回ResultSet对象
- 调用executeUpdate()：执行更新，包括增、删、修改
（2）预处理好处
- 不再使用＋拼接sql语句，减少语法错误
- 有效的解决了sql注入问题！
- 大大减少了编译次数，效率较高
- （下次调用相同的预编译语句时，只需要将参数传入编译过语句中再执行即可）
package com.hspedu.jdbc.preparedStatement_;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;
/**
* 演示使用PreparedStatement对数据库进行查询操作
*/
@SuppressWarnings({"all"})
public class PreparedStatement_ {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
//让用户输入管理员名和密码
System.out.println("请输入管理员的名字：");
String admin_name=scanner.nextLine();//next()遇到空格或单引号结束；nextLine()遇到回车结束;
System.out.println("请输入管理员的密码：");
String admin_pwd=scanner.nextLine();
//通过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);
//得到PreparedStatement
//组织sql
//1、语句中的"?"是占位符
String sql="select name,pwd from admin where name =? and pwd =?";
//2、preparedStatement对象实现了PreparedStatement接口的实现类的对象
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//3、给？赋值
preparedStatement.setString(1,admin_name);
preparedStatement.setString(2,admin_pwd);
//执行select 语句使用 executeQuery
//执行dml(updqte, insert, delete) 使用 excuteUpdate()
//执行excuteUpdate()时，（）里不用再写sql
ResultSet resultSet = preparedStatement.executeQuery();
if(resultSet.next()){//如果查询到一条记录，则说明该管理存在
System.out.println("恭喜，登录成功");
}else{
System.out.println("对不起，登录失败");
}
//关闭连接
resultSet.close();
preparedStatement.close();
connection.close();
}
}
//请输入管理员的名字：
//1' or
//请输入管理员的密码：
//or '1'='1
//对不起，登录失败
/*万能密码失效，成功解决sql注入问题*/
package com.hspedu.jdbc.preparedStatement_;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;
/**
* 演示使用PreparedStatement对数据库进行增、删、改操作
*/
@SuppressWarnings({"all"})
public class PreparedStatement_ {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
//让用户输入管理员名和密码
System.out.println("请输入管理员的名字：");
String admin_name=scanner.nextLine();//next()遇到空格或单引号结束；nextLine()遇到回车结束;
System.out.println("请输入管理员的密码：");
String admin_pwd=scanner.nextLine();
//通过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);
//得到PreparedStatement
//组织sql
//1、语句中的"?"是点位符
//添加记录
String sql="insert into admin values(?,?)";
//修改记录
//String sql="update admin set pwd = ? where name = ?";
//下面两句的顺序也要修改
//preparedStatement.setString(1,admin_name);
//preparedStatement.setString(2,admin_pwd);
//删除记录
//String sql="delete from admin where name = ?";
//1、下面两句保留第一句
//preparedStatement.setString(1,admin_name);
//preparedStatement.setString(2,admin_pwd);
//2、删掉
//System.out.println("请输入管理员的密码：");
//String admin_pwd=scanner.nextLine();
//2、preparedStatement对象实现了PreparedStatement接口的实现类的对象
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//3、给？赋值
preparedStatement.setString(1,admin_name);
preparedStatement.setString(2,admin_pwd);
//执行dml(updqte, insert, delete) 使用 excuteUpdate()
int rows=preparedStatement.executeUpdate();
System.out.println(rows > 0 ? "执行成功":"执行失败");
//关闭连接
preparedStatement.close();
connection.close();
}
}
小结：
四、封闭JDBCUtils
1、基本介绍：（把工具装箱，要用直接拎走用）
在jdbc 操作中，获取连接和释放资源是经常使用到可以将其封装JDBC连接的工具类JDBCUtils
package com.hspedu.jdbc.utils_;
import com.mysql.jdbc.Connection;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JDBCUtils {
//定义相关的属性（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 (Connection) 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);
}
}
}
package com.hspedu.jdbc.utils_;
import org.junit.Test;
import java.sql.Date;
import java.sql.PreparedStatement;
import com.mysql.jdbc.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
@SuppressWarnings({"all"})
public class JDBCUtils_Use {
@Test
public void testDML(){//insert, update, delete
//1、得到连接
Connection connection =null;
//2、组织一个sql
String sql="update actor set name=? where id=?";
PreparedStatement preparedStatement=null;
//3、创建PreparedStatement对象
try {
connection= JDBCUtils.getConnection();
preparedStatement=connection.prepareStatement(sql);
//给占位符赋值
preparedStatement.setString(1,"周星驰");
preparedStatement.setInt(2,10);
//执行
preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtils.close(null,preparedStatement,connection);
}
}
@Test
public void testSelect(){
Connection connection =null;
String sql="select * from actor where id=?";
PreparedStatement preparedStatement=null;
ResultSet set= null;
try {
connection= JDBCUtils.getConnection();
preparedStatement=connection.prepareStatement(sql);
preparedStatement.setInt(1,13);//给？号赋值
//执行，得到结果集
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+"\t");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.close(set,preparedStatement,connection);
}
}
/*
10 周星驰 男 2000-01-01 119
11 贾宝玉 男 2000-01-01 119
12 贾宝玉 男 2000-01-01 119
13 贾宝玉 男 2000-01-01 119
*/
}
五、事务
什么是事务？
- 一组逻辑操作单元,使数据从一种状态变换到另一种状态。
事务处理：
- JDBC程序中当一个Connection对象创建时，默认情况下是自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，提交后不能回滚了。
- JDBC程序中为了让多个SQL 语句作为一个整体执行，需要使用事务
- 调用 Connection的 setAutoCommit（false）可以取消自动提交事务
- 在所有的SQL语句都成功执行后，调用 commit（）；方法提交事务
- 在其中某个操作失败或出现异常时，调用 rollback（）；方法回滚事务
事务的ACID属性：
- 原子性（Atomicity）：原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
- 一致性（consistency）：事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
- 隔离性（Isolation）：事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰
- 持久性（Durability）：持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。
数据库的并发问题：
- 对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题（脏读、不可重复读、幻读）
- 隔离级别越高, 数据一致性就越好, 但并发性越弱（四种隔离级别）
模拟经典的转账业务
剖析问题：
package com.hspedu.jdbc.transaction_;
import com.hspedu.jdbc.utils_.JDBCUtils;
import com.mysql.jdbc.Connection;
import org.junit.Test;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 演示jdbc中如何使用事务
*/
@SuppressWarnings({"all"})
public class Transaction_ {
@Test
public void noTransaction(){
//操作转账的业务
//1、得到连接
Connection connection =null;
//2、组织一个sql
String sql="update account set money = money - 100 where id =1";
String sql2="update account set money = money + 100 where id =2";
PreparedStatement preparedStatement=null;
//3、创建PreparedStatement对象
try {
connection= JDBCUtils.getConnection();//在默认情况下，connection是默认自动提交
preparedStatement=connection.prepareStatement(sql);
preparedStatement.executeUpdate();//执行第一条sql语句
int i=1/0;//此处抛出异常后，下面的语句不再执行，所以使用事务来解决这个问题
preparedStatement=connection.prepareStatement(sql2);
preparedStatement.executeUpdate();//执行第二条sql语句
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtils.close(null,preparedStatement,connection);
}
}
}
使用事务解决问题：
package com.hspedu.jdbc.transaction_;
import com.hspedu.jdbc.utils_.JDBCUtils;
import com.mysql.jdbc.Connection;
import org.junit.Test;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 演示jdbc中如何使用事务
*/
@SuppressWarnings({"all"})
public class Transaction_ {
@Test
public void noTransaction(){
//操作转账的业务
//1、得到连接
Connection connection =null;
//2、组织一个sql
String sql="update account set money = money - 100 where id =1";
String sql2="update account set money = money + 100 where id =2";
PreparedStatement preparedStatement=null;
//3、创建PreparedStatement对象
try {
connection= JDBCUtils.getConnection();//在默认情况下，connection是默认自动提交
//将connection设置为不自动提交
connection.setAutoCommit(false);//开启了事务
preparedStatement=connection.prepareStatement(sql);
preparedStatement.executeUpdate();//执行第一条sql语句
//int i=1/0;//此处抛出异常后，上面的语句执行了，但下面的语句不再执行，所以使用事务来解决这个问题
preparedStatement=connection.prepareStatement(sql2);
preparedStatement.executeUpdate();//执行第二条sql语句
//提交事务
connection.commit();
} catch (SQLException e) {
//这里进行回滚
//默认回滚到事务开始的状态
System.out.println("执行发生了异常，撤销执行的sql");
try {
connection.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
e.printStackTrace();
} finally {
//关闭资源
JDBCUtils.close(null,preparedStatement,connection);
}
}
}
六、批处理
1、基本介绍
- 当需要成批插入或者更新记录时。可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率。
JDBC的批量处理语句包括下面方法：
addBatch（）：添加需要批量处理的SQL语句或参数
executeBatch（）：执行批量处理语句
clearBatch（）：清空批处理包的语句
- JDBC连接MySQL时，如果要使用批处理功能，请在url中加参数？rewriteBatchedStatements＝true
- 批处理往往和PreparedStatement一起搭配使用，既可以减少编译次数，又减少运行次数，效率大大提高
2、演示
package com.hspedu.jdbc.batch_;
import com.hspedu.jdbc.utils_.JDBCUtils;
import com.mysql.jdbc.Connection;
import org.junit.Test;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 演示java的批处理
*/
@SuppressWarnings({"all"})
public class Batch_ {
//传统方法，添加5000条数据到admin2
@Test
public void noBatch() throws SQLException {
Connection connection = JDBCUtils.getConnection();
String sql="insert into admin2 values(null,?,?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
System.out.println("开始执行");
long start=System.currentTimeMillis();//开始时间
for(int i=0;i<5000;i++){
preparedStatement.setString(1,"jack"+i);
preparedStatement.setString(2,"666");
preparedStatement.executeUpdate();
}
long end=System.currentTimeMillis();//结束时间
System.out.println("传统方式耗时："+(end-start));
//关闭连接
JDBCUtils.close(null,preparedStatement,connection);
}
@Test
//使用批量方式添加数据
public void batch() throws SQLException {
Connection connection = JDBCUtils.getConnection();
String sql="insert into admin2 values (null,?,?)";//values后面要加空格，再加()
PreparedStatement preparedStatement = connection.prepareStatement(sql);
System.out.println("开始执行");
long start=System.currentTimeMillis();//开始时间
for(int i=0;i<5000;i++){
preparedStatement.setString(1,"jack"+i);
preparedStatement.setString(2,"666");
//将sql语句加入到批处理包中
preparedStatement.addBatch();
//当有1000条记录时，再批量执行
if((i+1)%1000==0){
preparedStatement.executeBatch();
//清空
preparedStatement.clearBatch();
}
}
long end=System.currentTimeMillis();//结束时间
System.out.println("批处理方式耗时："+(end-start));
//关闭连接
JDBCUtils.close(null,preparedStatement,connection);
//配置文件后面加上rewriteBatchedStatements=true
//即为：url=jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8&rewriteBatchedStatements=true
}
}
//开始执行
//传统方式耗时：16500
//开始执行
//批处理方式耗时：94
*追源码：
package com.hspedu.jdbc.batch_;
import com.hspedu.jdbc.utils_.JDBCUtils;
import com.mysql.jdbc.Connection;
import org.junit.Test;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 追批处理的源码
*/
@SuppressWarnings({"all"})
public class Batch_ {
@Test
//使用批量方式添加数据
public void batch() throws SQLException {
Connection connection = JDBCUtils.getConnection();
String sql="insert into admin2 values (null,?,?)";//values后面要加空格，再加()
PreparedStatement preparedStatement = connection.prepareStatement(sql);
System.out.println("开始执行");
long start=System.currentTimeMillis();//开始时间
for(int i=0;i<5000;i++){
preparedStatement.setString(1,"jack"+i);
preparedStatement.setString(2,"666");
/*
1、第一就创建ArrayList - elementDta ==> Object[]
2、elementDta ==> Object[] 就会存放我们预处理的sql语句
3、当elementData满后，就按照1.5倍扩容
4、当添加到指定的值后，就executeBatch
5、批量处理会减少我们发送sql语句的网络开销，而且减少编译次数，提高了效率
public void addBatch() throws SQLException {
synchronized(this.checkClosed().getConnectionMutex()) {
if (this.batchedArgs == null) {
this.batchedArgs = new ArrayList();
}
for(int i = 0; i < this.parameterValues.length; ++i) {
this.checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
}
this.batchedArgs.add(new BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
}
}
*/
preparedStatement.addBatch();
//当有1000条记录时，再批量执行
if((i+1)%1000==0){
preparedStatement.executeBatch();
//清空
preparedStatement.clearBatch();
}
}
long end=System.currentTimeMillis();//结束时间
System.out.println("批处理方式耗时："+(end-start));
//关闭连接
JDBCUtils.close(null,preparedStatement,connection);
}
}
*批处理和事务的区别：事务消耗数据库内存，批处理消耗客户端内存
七、数据库连接池
1、传统获取Connection问题分析
- 传统的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection 加载到内存中，再验证IP地址，用户名和密码（0.05s～1s时间）。需要数据库连接的时候，就向数据库要求一个，频繁的进行数据库连接操作将占用很多的系统资源，容易造成服务器崩溃。
- 每一次数据库连接，使用完后都得断开，如果程序出现异常而未能关闭，将导致数据库内存泄漏，最终将导致重启数据库。
- 传统获取连接的方式，不能控制创建的连接数量，如连接过多，也可能导致内存泄漏，MySQL崩溃。
- 解决传统开发中的数据库连接问题，可以采用数据库连接池技术(connection pool).
package com.hspedu.jdbc.datasource;
import com.hspedu.jdbc.utils_.JDBCUtils;
import com.mysql.jdbc.Connection;
import org.junit.Test;
public class ConQuestion {
//连接mysql 5000次
@Test
public void testCon(){
//使用传统的jdbc方式，得到连接
long start=System.currentTimeMillis();
for(int i=0;i<5000;i++){
Connection connection = JDBCUtils.getConnection();
//做一些工作，比如得到PreparedStatement，发送sql
//......
//关闭
JDBCUtils.close(null,null,connection);
}
long end=System.currentTimeMillis();
System.out.println("传统方式5000次耗时："+(end-start));
//传统方式5000次耗时：19011
}
}
2、数据库连接池基本介绍
- 预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
- 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
- 当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中
类似于去门房大爷那拿钥匙来开门后再还回去
3、数据库连接池示意图
4、数据库连接池种类
- JDBC的数据库连接池使用 javax.sql.DataSource来表示，DataSource 只是一个接口，该接口通常由第三方提供实现，下载c3p0的jar包：http://t.csdn.cn/d3zii
http://t.csdn.cn/d3zii - C3P0数据库连接池，速度相对较慢，稳定性不错（hibernate，spring） DBCP数据库连接池，速度相对c3p0较快，但不稳定
- Proxool数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点BoneCP数据库连接池，速度快
- Druid（德鲁伊）是阿里提供的数据库连接池，集DBCP、C3P0、Proxool 优点于一身的数据库连接池
（1） c3p0数据库连接池：
c3p0的使用方法1：
package com.hspedu.jdbc.datasource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import java.beans.PropertyVetoException;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
/**
*演示c3p0的使用
*方式1：相关参数，在程序中指定user, url, password等
*/
@SuppressWarnings({"all"})
public class C3P0_ {
@Test
public void testC3P0_01() throws IOException, PropertyVetoException, SQLException {
//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();
System.out.println("c3p0 5000次连接mysql耗时："+(end-start));
//c3p0 5000次连接mysql耗时：649
}
}
//用的是9.5.2版本的c3p0，把解压出来的jar包中c3p0-0.9.5.2.jar
//和mchange-commons-java-0.2.12.jar都添加到根目录libs下面，然后右键，“添加到库”即可
c3p0的使用方法2：
jar包里的c3p0-config.xml配置文件（修改前）：
<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
<property name="user">root</property>
<property name="password">root</property>
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">10</property>
<property name="checkoutTimeout">3000</property>
</default-config>
<named-config name="otherc3p0">
</named-config>
</c3p0-config>修改后（修改了url和password两行，并且适当增大了initialPoolSize（初始连接数）和maxPoolSize（最大连接数））：
<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="initialPoolSize">10</property>
<property name="maxPoolSize">50</property>
<property name="checkoutTimeout">3000</property>
</default-config>
<named-config name="hsp_edu">
</named-config>
</c3p0-config>老师版详细说明（修改后）：
<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
<default-config>
<!--驱动类-->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<!--url，其中的&使用转义字符&-->
<property name="jdbcUrl">jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8</property>
<!--用户名-->
<property name="user">root</property>
<!--密码-->
<property name="password">123456</property>
<!--每次增长的连接数 -->
<property name="acquireIncrement">5</property>
<!--初始的连接数-->
<property name="initialPoolSize">10</property>
<!--最小连接数，如果连接太多空余的，就关掉一部分，这是底线-->
<property name="minPoolSize">5</property>
<!--最大连接数-->
<property name="maxPoolSize">50</property>
<!--可连接的最多命令对象数-->
<property name="maxStatementsPerConnection">5</property>
<!--每个对象可连接的最多的命令对象数，默认为2-->
<property name="maxStatementPerConnection">2</property>
<property name="checkoutTimeout">3000</property>
</default-config>
<!--数据源名称代表连接池-->
<named-config name="hsp_edu">
</named-config>
</c3p0-config>package com.hspedu.jdbc.datasource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import java.sql.Connection;
import java.sql.SQLException;
/**
* 演示c3p0的使用，方式2：使用配置文件模板来完成
*/
@SuppressWarnings({"all"})
public class C3P0_ {
@Test
//1、将c3p0提供的c3p0.config.xml 拷贝到src目录下
//2、该文件指定了连接数据库和连接池的相关参数
public void testc3p0_02() throws SQLException {
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("hps_db05");
//测试5000次连接mysql
long start=System.currentTimeMillis();
for(int i=0;i<5000;i++) {
Connection connection = comboPooledDataSource.getConnection();
//System.out.println("连接OK");
connection.close();
}
long end=System.currentTimeMillis();
System.out.println("c3p0第二种使用方式耗时："+(end-start));
//c3p0第二种使用方式耗时：718
}
}
（2）druid数据库连接池
1）演示druid的使用
druid的jar包里的druid.properties配置文件修改前：
#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/girls?rewriteBatchedStatements=true
#url=jdbc:mysql://localhost:3306/girls
username=root
password=root
#initial connection Size
initialSize=10
#min idle connection size
minIdle=5
#max active connection size
maxActive=20
#max wait time(5000 mil seconds)
maxWait=5000修改后（只修改了url和password这两行）：
#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/hsp_db05?useSSL=true&characterEncoding=utf8&rewriteBatchedStatements=true
#url=jdbc:mysql://localhost:3306/girls
username=root
password=123456
#initial connection Size
initialSize=10
#min idle connection size
minIdle=5
#max active connection size
maxActive=20
#max wait time(5000 mil seconds)
maxWait=5000package com.hspedu.jdbc.datasource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;
/**
* 演示druid的使用
*/
public class Druid_ {
@Test
public void testDruid() throws Exception {
//1、加入Druid jar包
//2、加入配置文件druid.properties，将该文件拷贝到项目的src目录下
//3、创建Properties对象，读取配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\\druid.properties"));
//4、创建一个指定参数的数据库连接池
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
long start=System.currentTimeMillis();
for(int i=1;i<500000;i++) {
Connection connection = dataSource.getConnection();
//System.out.println("连接成功");
connection.close();
}
long end=System.currentTimeMillis();
System.out.println("druid连接池操作500000次耗时："+(end-start));
//比较druid和c3p0的性能：
//druid连接池操作5000次耗时：995
//c3p0方式二操作5000次耗时：584
//druid连接池操作500000次耗时：774
//c3p0方式二操作500000次耗时：2094
}
}
2）注意：
- druid操作大型数据库的速度快于c3p0的，c3p0较老，平时开发建议使用druid。
- 数据源只是帮我们管理了数据库的连接，所以仍然要使用到驱动
- druid的jar的官网下载链接：
https://repo1.maven.org/maven2/com/alibaba/druid/http:// https://repo1.maven.org/maven2/com/alibaba/druid/
3）将JDBCUtils工具类改成Druid实现
通过Druid数据库连接池获取连接对象
package com.hspedu.jdbc.datasource;
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;
/**
* 基于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);
}
}
}
package com.hspedu.jdbc.datasource;
import org.junit.Test;
import java.sql.*;
/**
* 测试JDBCUtilsByDruid的使用
*/
@SuppressWarnings({"all"})
public class JDBCUtilsByDruid_Use {
@Test
public void testSelect() {
System.out.println("使用druid方式完成");
Connection connection = null;
String sql = "select * from actor where id=?";
PreparedStatement preparedStatement = null;
ResultSet set = null;
try {
connection = JDBCUtilsByDruid.getConnection();
System.out.println("connection的运行类型："+connection.getClass());
//connection的运行类型：class com.alibaba.druid.pool.DruidPooledConnection
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 12);//给？号赋值
//执行，得到结果集
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 + "\t");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtilsByDruid.close(set, preparedStatement, connection);
}
}
}
/*注意：
在使用JDBCUtilsByDruid工具类时，注意引入的Connection类要和JDBCUtilsByDruid里引入的Connection类类型一致
*/八、Apache—DBUtils
1、引入
2、基本介绍
- commons—dbutils是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的封装，使用dbutils能极大简化jdbc编码的工作量。
- DbUtils类
- QueryRunner类：该类封装了SQL的执行，是线程安全的。可以实现增、删、改、查、批处理
- 使用QueryRunner类实现查询
- ResultSetHandler接口：该接口用于处理 java.sql.ResultSet，将数据按要求转换为另—种形式
- ArrayHandler：把结果集中的第一行数据转成对象数组。
- ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
- BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
- BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
- ColumnListHandler：将结果集中某一列的数据存放到List中。
- KeyedHandler（name）：将结果集中的每行数据都封装到Map里，再把这些map再存到一个map里，其key为指定的key。
- MapHHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
- MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
3、演示
（1）土方法：
package com.hspedu.jdbc.datasource;
import org.junit.Test;
import java.sql.*;
import java.util.ArrayList;
/**
* 使用土方法把ResultSet封装到ArrayList里
*/
@SuppressWarnings({"all"})
public class JDBCUtilsByDruid_Use {
@Test
public ArrayList<Actor> testSelect() {
Connection connection = null;
String sql = "select * from actor where id>=?";
PreparedStatement preparedStatement = null;
ResultSet set = null;
ArrayList<Actor> list = new ArrayList<>();//创建ArrayList对象，存放actor对象
try {
connection = JDBCUtilsByDruid.getConnection();
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 12);//给？号赋值
//执行，得到结果集
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");
//把得到的resultset的记录，封闭到Actor对象，放入到list集合
list.add(new Actor(id,name,sex,borndate,phone));
}
System.out.println("list集合数据："+list);
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtilsByDruid.close(set, preparedStatement, connection);
}
//因为ArrayList和connection没有任何关联，所以关闭连接后，该集合仍然可以复用
return list;
}
}
//list集合数据：[
//Actor{id=12, name='贾宝玉', sex='男', borndate=2000-01-01, phone='119'},
//Actor{id=13, name='贾宝玉', sex='男', borndate=2000-01-01, phone='119'}]package com.hspedu.jdbc.datasource;
import java.util.Date;
/**
* Actor对象和actor表的记录对应
*/
@SuppressWarnings({"all"})
public class Actor {
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 + '\'' +
'}';
}
}
（2）使用DBUtils+数据连接池（druid）方式，完成对表的crud
package com.hspedu.jdbc.datasource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.junit.Test;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
public class DBUtils_Use {
@Test
//使用apache-DBUtils工具类+druid完成对表的crud操作
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 >=?";
//查询部分列
//String sql="select 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
/**
* 分析queryRunner.query方法：
* private <T> T query(Connection conn, boolean closeConn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
* if (conn == null) {
* throw new SQLException("Null connection");
* } else if (sql == null) {
* if (closeConn) {
* this.close(conn);
* }
*
* throw new SQLException("Null SQL statement");
* } else if (rsh == null) {
* if (closeConn) {
* this.close(conn);
* }
*
* throw new SQLException("Null ResultSetHandler");
* } else {
* PreparedStatement stmt = null;//定义PreparedStatement
* ResultSet rs = null;//接收返回的ResultSet
* T 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 [使用到反射，对传入的class对象进行处理 ]
* } catch (SQLException var33) {
* this.rethrow(var33, sql, params);
* } finally {
* try {
* this.close(rs);//关闭resultset
* } finally {
* this.close(stmt);//关闭PreparedStatement对象
* if (closeConn) {
* this.close(conn);
* }
*
* }
* }
*
* return result;
* }
* }
*/
List<Actor> list=
queryRunner.query(connection,sql,new BeanListHandler<>(Actor.class),1);
System.out.println("输出集合的信息");
for(Actor actor:list){
System.out.print(actor);
}
//释放资源
//（7）底层得到的resultSet，会在query关闭，同时也会关闭PreparedStatement
JDBCUtilsByDruid.close(null,null,connection);
}
}
//输出集合的信息
//
//Actor{id=10, name='周星驰', sex='男', borndate=2000-01-01 00:00:00.0, phone='119'}
//Actor{id=11, name='贾宝玉', sex='男', borndate=2000-01-01 00:00:00.0, phone='119'}
//Actor{id=12, name='贾宝玉', sex='男', borndate=2000-01-01 00:00:00.0, phone='119'}
//Actor{id=13, name='贾宝玉', sex='男', borndate=2000-01-01 00:00:00.0, phone='119'}
package com.hspedu.jdbc.datasource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;
import java.sql.Connection;
import java.sql.SQLException;
@SuppressWarnings({"all"})
public class DBUtils_Use {
@Test
/**
* 演示apache-dbutils + druid 完成返回的结果是单行记录（单个对象）
*/
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=?";
//解读：
//因为我们返回单行记录/单个对象，则使用的Handler是BeanHandler
Actor actor = queryRunner.query(connection, sql, new BeanHandler<>(Actor.class), 4);
System.out.println(actor);
//null
//释放资源
JDBCUtilsByDruid.close(null,null,connection);
}
@Test
/**
*演示apache-dbutils + druid 完成查询结果是单行单列-返回的就是object
*/
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(), 13);
System.out.println(obj);
//贾宝玉
//释放资源
JDBCUtilsByDruid.close(null,null,connection);
}
@Test
/**
* 演示apache-dbutils + druid 完成 dml(update,insert,delete)
*/
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=?";
//解读：
//（1）执行dml操作是queryRunner.update，无论是update还是insert, delete
//（2）返回的是受影响的行数
int affectedRow=queryRunner.update(connection,sql,"张三丰",13);
System.out.println(affectedRow>0?"执行成功":"执行没有影响列表");
//释放资源
JDBCUtilsByDruid.close(null,null,connection);
}
}
4、表和JavaBean的类型映射关系
九、DAO和增删改查通用方法-BasicDao
1、分析问题
2、基本说明
- DAO：data access object数据访问对象
- 这样的通用类，称为 BasicDao，是专门和数据库交互的，即完成对数据库（表）的crud操作。
- 在BaiscDao的基础上，实现一张表 对应一个Dao，更好的完成功能，比如Customer表—Customer.java类（javabean）-CustomerDao.java
package com.hspedu.dao_.dao;
import com.hspedu.jdbc.datasource.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的父类
*/
@SuppressWarnings({"all"})
public class BasicDAO<T> {//泛型指定具体类型
private QueryRunner qr=new QueryRunner();
/**
* 开发通用的dml方法，针对任意的表
* @param sql
* @param parameters
* @return
*/
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 可以有？
* @param clazz 传入一个类的Class对象，比如Actor.class
* @param parameters 传入？的具体的值，可以是多个（可变参数）
* @return 根据Actor.class返回对应的 ArrayList 集合
*/
public List<T> queryMulti(String sql,Class<T> clazz,Object...parameters){
Connection connection=null;
try {
connection= JDBCUtilsByDruid.getConnection();
return qr.query(connection,sql,new BeanListHandler<T>(clazz),parameters);
} catch (SQLException e) {
throw new RuntimeException(e);//将编译异常——》运行异常，抛出
} finally {
JDBCUtilsByDruid.close(null,null,connection);
}
}
/**
* 查询单行结果的通用方法
*/
public T querySingle(String sql,Class<T> clazz,Object...parameters){
Connection connection=null;
try {
connection= JDBCUtilsByDruid.getConnection();
return qr.query(connection,sql,new BeanHandler<T>(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 com.hspedu.dao_.dao;
import com.hspedu.dao_.domain.Actor;
public class ActorDAO extends BasicDAO<Actor> {
//1、就有BasicDAO的方法
//2、根据业务需求，可以编写特有的方法
}
package com.hspedu.dao_.domain;
import java.util.Date;
/**
* Actor对象和actor表的记录对应
*/
@SuppressWarnings({"all"})
public class Actor {
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 + '\'' +
'}';
}
}
1114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
