Java全栈（三）数据库技术：3.数据库之JDBC上
第一章 JDBC概述
之前我们学习了JavaSE，编写了Java程序，数据保存在变量、数组、集合等中，无法持久化，后来学习了IO流可以将数据写入文件，但不方便管理数据以及维护数据的关系；
后来我们学习了数据库管理软件MySQL，可以方便的管理数据。
那么如何将它俩结合起来呢？即Java程序<==>MySQL，实现数据的存储和处理。
那么就可以使用JDBC技术。
1.1 JDBC概述
JDBC：Java Database Connectivity，它是代表一组独立于任何数据库管理系统（DBMS）的API，声明在java.sql与javax.sql包中，是SUN(现在Oracle)提供的一组接口规范。由各个数据库厂商来提供实现类，这些实现类的集合构成了数据库驱动jar。
即JDBC技术包含两个部分：
（1）java.sql包和javax.sql包中的API
因为为了项目代码的可移植性，可维护性，SUN公司从最初就制定了Java程序连接各种数据库的统一接口规范。这样的话，不管是连接哪一种DBMS软件，Java代码可以保持一致性。
（2）各个数据库厂商提供的jar
因为各个数据库厂商的DBMS软件各有不同，那么内部如何通过sql实现增、删、改、查等管理数据，只有这个数据库厂商自己更清楚，因此把接口规范的实现交给各个数据库厂商自己实现。
1.2 JDBC使用步骤
代码编写步骤：
JDBC访问数据库步骤
1：注册一个Driver驱动
```
三部曲：
（1）将DBMS数据库管理软件的驱动jar拷贝到项目的libs目录中
例如：mysql-connector-java-5.1.36-bin.jar
（2）把驱动jar添加到项目的build path中。（IDEA中右键点击驱动jar包》点击add as library）
（3）将驱动类(DriverManager)加载到内存中，DriverManager可以用于创建命令发送器。来执行sql语句
DriverManager.registerDriver(new Driver()); # 方式1
Class.forName("com.mysql.cj.jdbc.Driver"); # 方式2。不同版本的mysql驱动包Driver类路径可能不同
```
两种加载驱动类DriverManager的方式：
DriverManager.registerDriver(new Driver());：注册一个Driver实例Class.forName("com.mysql.cj.jdbc.Driver")：初始化Driver类。package com.mysql.cj.jdbc; import java.sql.DriverManager; import java.sql.SQLException; public class Driver extends NonRegisteringDriver implements java.sql.Driver { public Driver() throws SQLException { } // 本质上是初始化Driver类时，会执行该静态代码块，完成Driver实例对象的创建。跟方式1一样 static { try { DriverManager.registerDriver(new Driver()); } catch (SQLException var1) { throw new RuntimeException("Can't register driver!"); } } }
2：创建数据库连接（Connection）
Connection conn = DriverManager.getConnection(url,username,password);
// mysql的url：jdbc:mysql://ip:端口/数据库名?参数名=参数值
// 例如：jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf8
（如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
3：创建SQL命令发送器Statement
// 创建Statement或PreparedStatement对象
// 创建statement对象
Connection connection = DriverManager.getConnection(url, "root", "xxx");
Statement statement = connection.createStatement();
4：通过Statement发送SQL命令并得到结果
// 注意：sql语句中的字符串只能用单引号括起来，因为外层是java中的字符串必须使用双引号，不能冲突
// executeUpdate用于提交增删改操作的sql，返回int数据。大于0表示执行成功
int res = statement.executeUpdate("insert into employ3 values(41,'西门庆','男',14000.22,1)");
// executeQuery用于执行查询操作的sql，返回ResultSet 对象。其中储存了sql查询的结果
ResultSet resultSet = statement.executeQuery("select * from employ3");
5：处理结果（select语句需要）
6：关闭数据库资源ResultSet Statement Connection
statement.close(); // 关闭命令发射器
connection.close(); // 关闭连接
相关的API：
1、DriverManager：驱动管理类
2、Connection：代表数据库连接
3、Statement和PreparedStatement：用来执行sql
执行增、删、改：int executeUpate()
执行查询：ResultSet executeQuery()
4、如何遍历ResultSet ？
（0）ResultSet可以使用迭代来查询
（1）boolean next()：判断是否还有下一行
（2）getString(字段名或序号)：获取字符串类型字段的数据内容。注意如果使用序号，mysql中是以1开始的
（3）getInt(字段名或序号)：获取整数类型字段的数据内容。注意如果使用序号，mysql中是以1开始的
（4）getObject(字段名或序号)：获取任意类型字段的数据内容。注意如果使用序号，mysql中是以1开始的
示例代码1：增、删、改
public class TestJDBC {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//1、注册驱动
// (1)方式一：Class.forName("驱动类的全名称")
Class.forName("com.mysql.jdbc.Driver");
// (2)创建驱动类的对象
// new com.mysql.jdbc.Driver();//硬编码
//(3)通过DriverManager注册驱动
// DriverManager.registerDriver(new com.mysql.jdbc.Driver());//硬编码
//2、获取连接，连接数据库
//TCP/IP协议编程，需要服务器的IP地址和端口号
//mysql的url格式：jdbc协议:子协议://主机名:端口号/要连接的数据库名
String url = "jdbc:mysql://localhost:3306/test";//其中test是数据库名
String user = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, user, password);
//3、执行sql
//添加一个部门到数据库的t_department表中
//(1)编写sql
String sql = "insert into t_department values(null,'计算部2','计算钞票2')";
/*
* 回忆： TCP/IP程序时
* Socket代表连接
* socket.getOutputStream()来发送数据，
* socket.getInputStream()来接收数据
*
* 可以把Connection比喻成Socket
* 把Statement比喻成OutputStream
*/
//(2)获取Statement对象
Statement st = conn.createStatement();
//(3)执行sql
int len = st.executeUpdate(sql);
//(4)处理结果
System.out.println(len>0?"成功":"失败");
//4、关闭
st.close();
conn.close();
}
}
示例代码2：查询
public class TestSelect {
public static void main(String[] args) throws Exception{
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、连接数据库
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
// 3、执行sql
String sql = "SELECT * FROM t_department";
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery(sql);//ResultSet看成InputStream
// 4、处理结果
while(rs.next()){//next()表示是否还有下一行
Object did = rs.getObject(1);//获取第n列的值
Object dname = rs.getObject(2);
Object desc = rs.getObject(3);
/*
int did = rs.getInt("did");//也可以根据列名称，并且可以按照数据类型获取
String dname = rs.getString("dname");
String desc = rs.getString("description");
*/
System.out.println(did +"\t" + dname + "\t"+ desc);
}
// 5、关闭
rs.close();
st.close();
conn.close();
}
}
1.3 使用statement的一些问题
1.3.1 sql拼接问题
案例：我们希望键盘输入用户名，密码保存到sql的用户表中
class Demo2{
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
// 创建命令发射器
Statement statement = connection.createStatement();
// 准备sql
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String user = scanner.nextLine();
System.out.println("请输入密码：");
int password = scanner.nextInt();
// 这种拼接是错误的，因为user和password是sql中的字符串，本身就需要引号括起来
// String sql = "insert into user(user,password) values(" + user + "," + password + ")"; // 等价于"insert into user(user,password) values(张三,123456)"是错误的sql语句
// 等价于 insert into user(user,password) values(' + 张三 + ',' + 123456 + ')
// 拼接的sql是：insert into user(user,password) values('张三','123456') 是正确的sql
String sql = "insert into user(user,password) values('" + user + "','" + password + "')";
// 执行sql
int res = statement.executeUpdate(sql);
// 获取结果
System.out.println(res>0?"注册成功":"注册失败");
// 关闭资源
scanner.close();
statement.close();
connection.close();
}
}
可以发现，statement要动态拼接sql非常麻烦。
1.3.2 sql注入
案例：键盘输入用户名密码，然后查询user表是否存在该用户名密码，如果存在则提示登录成功，否则登录失败
class Demo3{
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
// 创建命令发射器
Statement statement = connection.createStatement();
// 准备sql
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String user = scanner.nextLine();
System.out.println("请输入密码：");
String password = scanner.nextLine();
String sql = "select * from user where (user='"+user+"'and password='"+password+"')";
System.out.println("sql = " + sql);
// 执行sql
ResultSet res = statement.executeQuery(sql);
// 获取结果
String resUser = null;
String resPassword = null;
while (res.next()){
resUser = res.getString("user");
resPassword = res.getString("password");
}
if (resUser != null && resPassword != null){
System.out.println("登录成功");
}else {
System.out.println("登陆失败");
}
// 关闭资源
scanner.close();
statement.close();
connection.close();
}
}
然后我们来运行代码，实现sql注入：
请输入用户名：
张三
请输入密码：
123' or '1'='1
sql = select * from user where (user='张三'and password='123' or '1'='1')
登录成功
可以看到我们使用sql注入，即使输入错误的密码也登录成功了。
第二章 使用PreparedStatement处理CRUD
2.1 通过PreparedStatement来解决Statement的问题
Statement的问题：
（1）sql拼接
String sql = "insert into t_employee(ename,tel,gender,salary) values('" + ename + "','" + tel + "','" + gender + "'," + salary +")";
Statement st = conn.createStatement();
int len = st.executeUpdate(sql);
（2）sql注入
String sql = "SELECT * FROM t_employee where ename='" + ename + "'";
//如果我此时从键盘输入ename值的时候，输入：张三' or '1'= '1
//结果会把所有数据都查询出来
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery(sql);
（3）无法处理blob等类型的数据（图片，文件等）
创建含有Blob字段类型的表 测试插入
String sql = "insert into user(username,photo) values('zs', 图片字节流)";
//此时photo是blob类型的数据时，无法在sql中直接拼接
PreparedStatement解决问题：
避免sql拼接
class Demo2{
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
// 准备sql
String sql = "insert into user(user,password) values(?,?)"; //使用？来占用一个位置
// 创建命令发射器
PreparedStatement statement = connection.prepareStatement(sql);// 在创建发射器时，要传带？的sql，这样mysql端就会对这个sql进行预编译
// 填充sql
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String user = scanner.nextLine();
System.out.println("请输入密码：");
int password = scanner.nextInt();
statement.setObject(1,user); // 给第一个？赋值
statement.setObject(2,password); // 给第2个？赋值
// 执行sql
int res = statement.executeUpdate(); // 因为sql在创建发射器时已经编译完成，不需要再次传入sql
// 获取结果
System.out.println(res>0?"注册成功":"注册失败");
// 关闭资源
scanner.close();
statement.close();
connection.close();
}
}
解决sql注入
class Demo3 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
// 准备sql
String sql = "select * from user where (user=? and password=?)";
// 创建命令发射器
PreparedStatement statement = connection.prepareStatement(sql);
// 填充sql
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String user = scanner.nextLine();
System.out.println("请输入密码：");
String password = scanner.nextLine();
statement.setObject(1,user);
statement.setObject(2,password);
// 执行sql
ResultSet res = statement.executeQuery();
// 获取结果
String resUser = null;
String resPassword = null;
while (res.next()) {
resUser = res.getString("user");
resPassword = res.getString("password");
}
if (resUser != null && resPassword != null) {
System.out.println("登录成功");
} else {
System.out.println("登陆失败");
}
// 关闭资源
scanner.close();
statement.close();
connection.close();
}
}
运行一下代码。看看sql注入能否成功：
请输入用户名：
张三
请输入密码：
123 or 1==1 # 注入失败了，因为现在会将输入的所有内容作为密码进行校验
登陆失败
处理blob类型的数据（图片，文件等）
String sql = "insert into user(username,photo) values(?,?)";
PreparedStatement pst = conn.prepareStatement(sql);
//设置？的值
pst.setObject(1, "zs");
FileInputStream fis = new FileInputStream("D:/QMDownload/img/美女/15.jpg");
pst.setBlob(2, fis);
int len = pst.executeUpdate();
System.out.println(len>0?"成功":"失败");
-
注意两个问题：
①my.ini关于上传的字节流文件有大小限制，可以在my.ini中配置变量
max_allowed_packet=16M
②mysql中使用tinyblob、blob、mediumblob、longblob四种数据类型来以二进制的形式储存图片，文件等数据。
③mysql中每一种blob有各自大小限制：
tinyblob:255字节、blob:65k、mediumblob:16M、longblob:4G
练习：
新建一个img表，向表中储存图片，读取图片
①：新建img表
create table img(
id int primary key auto_increment,
img mediumblob,
iname char(20)
);
②：向表中插入数据
class Demo2 {
public static void main(String[] args) throws ClassNotFoundException, SQLException, FileNotFoundException {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
// 准备sql
String sql = "insert into img(img,iname) values(?,?),(?,?)"; //使用？来占用一个位置
// 创建命令发射器
PreparedStatement statement = connection.prepareStatement(sql);// 在创建发射器时，要传带？的sql，这样mysql端就会对这个sql进行预编译
// 填充sql
FileInputStream file1 = new FileInputStream("E:\\hehe\\0K0xGPu9gU.jpeg");
FileInputStream file2 = new FileInputStream("E:\\hehe\\4c024fcb172f8e3c4614747deff0b80e.jpg");
statement.setObject(1, file1); // 给第一个？赋值 // blob类型的数据，要求传入一个InputStream类型的数据
statement.setObject(2, "img1"); // 给第2个？赋值
statement.setObject(3, file2); // 给第3个？赋值 // blob类型的数据，要求传入一个InputStream类型的数据
statement.setObject(4, "img2"); // 给第4个？赋值
// 执行sql
int res = statement.executeUpdate(); // 因为sql在创建发射器时已经编译完成，不需要再次传入sql
// 获取结果
System.out.println(res > 0 ? "保存成功" : "保存失败");
// 关闭资源
statement.close();
connection.close();
}
}
查看数据库表，数据添加成功：
③：获取图片
class Demo3 {
public static void main(String[] args) throws ClassNotFoundException, SQLException, IOException {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
// 准备sql
String sql = "select * from img where (id=1)";
// 创建命令发射器
PreparedStatement statement = connection.prepareStatement(sql);
// 执行sql
ResultSet res = statement.executeQuery();
// 获取结果
String resUser = null;
String resPassword = null;
while (res.next()) {
Blob img = res.getBlob("img"); // 返回的是一个blob对象
// 将读取到的blob数据内容保存到文件中
InputStream binaryStream = img.getBinaryStream();// 将blob对象转化为InputStream对象
byte[] bytes = new byte[8];
int len;
FileOutputStream fileOutputStream = new FileOutputStream("D:ss.jpg");
while ((len = binaryStream.read(bytes)) != -1) {
fileOutputStream.write(bytes,0,len);
}
}
// 关闭资源
statement.close();
connection.close();
}
}
运行代码，图片保存成功了：
2.2 获取自增长键值
实际开发中，我们往往将id字段设置为主键并自动增长，那么当我们update一条数据时，获取到它的id就非常关键
/*
* 我们通过JDBC往数据库的表格中添加一条记录，其中有一个字段是自增的，那么在JDBC这边怎么在添加之后直接获取到这个自增的值
* PreparedStatement是Statement的子接口。
* Statement接口中有一些常量值：
* （1）Statement.RETURN_GENERATED_KEYS
*
* 要先添加后获取到自增的key值：
* （1）PreparedStatement pst = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
* （2）添加sql执行完成后,通过PreparedStatement的对象调用getGeneratedKeys()方法来获取自增长键值，遍历结果集
* ResultSet rs = pst.getGeneratedKeys();
*/
public class TestAutoIncrement {
public static void main(String[] args) throws Exception{
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
//3、执行sql
String sql = "insert into t_department values(null,?,?)";
/*
* 这里在创建PreparedStatement对象时，传入第二个参数的作用，就是告知服务器端
* 当执行完sql后，把自增的key值返回来。
*/
PreparedStatement pst = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
//设置？的值
pst.setObject(1, "测试部");
pst.setObject(2, "测试项目数据");
//执行sql
int len = pst.executeUpdate();//返回影响的记录数
if(len>0){
//从pst中获取到服务器端返回的键值
ResultSet rs = pst.getGeneratedKeys();
//因为这里的key值可能多个，因为insert语句可以同时添加多行，所以用ResultSet封装
//这里因为只添加一条，所以用if判断
if(rs.next()){
Object key = rs.getObject(1); // 这里用1去获取自增值，不要跟查询语句返回的结果集搞混了
System.out.println("自增的key值did =" + key);
}
}
//4、关闭
pst.close();
conn.close();
}
}
2.3 批处理
需要在url的末尾添加此参数：rewriteBatchedStatements=true
/*
* 批处理：
* 批量处理sql
*
* 例如：
* （1）订单明细表的多条记录的添加
* （2）批量添加模拟数据
* ...
*
* 不用批处理，和用批处理有什么不同？
* 批处理的效率很多
*
* 如何进行批处理操作？
* （1）在url中要加一个参数
* rewriteBatchedStatements=true
* 那么我们的url就变成了 jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
* 这里的?，表示?后面是客户端给服务器端传的参数，多个参数直接使用&分割
* （2）调用方法不同
* pst.addBatch();
* int[] all = pst.executeBatch();
*
* 注意：如果批量添加时，insert使用values,不要使用value
*/
public class TestBatch {
public static void main(String[] args) throws Exception{
long start = System.currentTimeMillis();
//例如：在部门表t_department中添加1000条模拟数据
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true", "root", "123456");
//3、执行sql
String sql = "insert into t_department values(null,?,?)";
PreparedStatement pst = conn.prepareStatement(sql);
//设置？的值
for (int i = 1; i <=1000; i++) {
pst.setObject(1, "模拟部门"+i);
pst.setObject(2, "模拟部门的简介"+i);
pst.addBatch();//添加到批处理一组操作中，攒一块处理
/* if(i % 500 == 0){//有时候也攒一部分，执行一部分
//2.执行
pst.executeBatch();
//3.清空
pst.clearBatch();
}*/
}
pst.executeBatch(); // 执行批处理
//4、关闭
pst.close();
conn.close();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end - start));//耗时：821
}
}
2.4 事务
/*
* mysql默认每一个连接是自动提交事务的。
* 那么当我们在JDBC这段，如果有多条语句想要组成一个事务一起执行的话，那么在JDBC这边怎么设置手动提交事务呢？
* (1)在执行之前，设置手动提交事务
* Connection的对象.setAutoCommit(false)
* (2)成功：
* Connection的对象.commit();
* 失败：
* Connection的对象.rollback();
*
* 补充说明：
* 为了大家养成要的习惯，在关闭Connection的对象之前，把连接对象设置回自动提交
* (3)Connection的对象.setAutoCommit(true)
*
* 因为我们现在的连接是建立新的连接，那么如果没有还原为自动提交，没有影响。
* 但是我们后面实际开发中，每次获取的连接，不一定是新的连接，而是从连接池中获取的旧的连接，而且你关闭也不是真关闭，而是还给连接池，供别人接着用。以防别人拿到后，以为是自动提交的，而没有commit，最终数据没有成功。
*/
public class TestTransaction {
public static void main(String[] args) throws Exception{
/*
* 一般涉及到事务处理的话，那么业务逻辑都会比较复杂。
* 例如：购物车结算时：
* （1）在订单表中添加一条记录
* （2）在订单明细表中添加多条订单明细的记录（表示该订单买了什么东西）
* （3）修改商品表的销量和库存量
* ...
* 那么我们今天为了大家关注事务的操作，而不会因为复杂的业务逻辑的影响导致我们的理解，那么我们这里故意
* 用两条修改语句来模拟组成一个简单的事务。
* update t_department set description = 'xx' where did = 2;
* update t_department set description = 'yy' where did = 3;
*
* 我希望这两天语句要么一起成功，要么一起回滚
* 为了制造失败，我故意把第二条语句写错
* update t_department set description = 'yy' （少了where） did = 3;
*/
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
//设置手动提交事务
conn.setAutoCommit(false);
//3、执行sql
String sql1 = "update t_department set description = 'xx' where did = 2";
String sql2 = "update t_department set description = 'yy' did = 3";//这是错的
//使用prepareStatement的sql也可以不带?
PreparedStatement pst = null;
try {
pst = conn.prepareStatement(sql1);
int len = pst.executeUpdate();
System.out.println("第一条：" + (len>0?"成功":"失败"));
pst = conn.prepareStatement(sql2);
len = pst.executeUpdate();
System.out.println("第二条：" + (len>0?"成功":"失败"));
//都成功了，就提交事务
System.out.println("提交");
conn.commit();
} catch (Exception e) {
System.out.println("回滚");
//失败要回滚
conn.rollback();
}
//4、关闭
pst.close();
conn.setAutoCommit(true);//还原为自动提交
conn.close();
}
}
2.5 封装PreparedStatement
（1）封装的意义
- 我们前面的代码都是直接编码的，没有任何封装。这会导致我们每一次访问数据库都需要写一大堆代码。
- 我们可以将访问数据库的代码封装为一个util类，这样我们想访问数据库只需要实例化该util类对象即可
（2）使用properties文件存放数据库相关的配置信息
像前面代码那样将数据库的url、用户名、密码等直接硬编码到代码中是不合适的，我们可以使用配置文件来储存。
①properties文件
properties是一种配置文件，以key=value的形式来存放数据。
现在我们在模块的src目录下去创建properties对象，用来储存我们的数据库配置信息
②Properties类介绍
Properties类是Hashtable的子类，也是一种集合，以[key，value]的形式储存数据。- Properties可以很方便的去操作properties文件
- 常用API
public synchronized Object setProperty(String key, String value)：将【key,value】储存到Properties集合中 public String getProperty(String key)：通过key获取value的值 public void store(OutputStream out, String comments)：将集合中的数据持久化保存到文件中，comments是对该文件的描述 public synchronized void load(InputStream inStream)：从文件中的数据读取到集合中 - 练习
// 向集合中添加读取数据 class Demo6{ public static void main(String[] args) { Properties properties = new Properties(); properties.setProperty("1", "哈哈"); // 储存数据到集合中 properties.setProperty("2", "嘿嘿"); properties.setProperty("3", "嘻嘻"); String res = properties.getProperty("1");// 获取"1"对应的value值 System.out.println("res = " + res); } }// 将集合中的数据保存到文件中 class Demo4{ public static void main(String[] args) throws IOException { Properties properties = new Properties(); properties.setProperty("1", "哈哈"); properties.setProperty("2", "嘿嘿"); properties.setProperty("3", "嘻嘻"); OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("E:\\Java全栈\\code\\JavaSE\\src\\jdbc.properties"),"UTF-8"); properties.store(outputStreamWriter,"this is a properties file"); // 将集合中的数据保存到文件jdbc.properties中 } }class Demo5{ // 读取文件中的数据到集合中 public static void main(String[] args) throws IOException { Properties properties = new Properties(); InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("E:\\Java全栈\\code\\JavaSE\\src\\jdbc.properties"), "UTF-8"); properties.load(inputStreamReader); // 读取文件中的数据到集合中 System.out.println("properties.getProperty(\"1\") = " + properties.getProperty("1")); } }
③实现配置信息读取的封装
package com.oy.jdbctest.jdbcutils;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class MyJdbcUtils{
private static String user;
private static String password;
private static String url;
private static String driver;
// 读取配置文件的内容，最好放到静态代码块中。这样只会在初始化类时，加载一次
// 而不会每生成一个实例化对象都调用一次，减少IO操作
static {
try {
Properties properties = new Properties();
//properties.load(new FileInputStream("E:\\Java全栈\\code\\JavaSE\\src\\jdbc.properties")); // 使用配置文件的绝对路径
properties.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties")); // 使用反射来使用配置文件的相对路径
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
System.out.println(url+"\t"+user+"\t"+password+"\t"+driver);
} catch (IOException e) {
e.printStackTrace();
}
}
}
（3）数据库连接的封装
我们可以将数据库连接封装为一个方法。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
public class MyJdbcUtils{
private static String user;
private static String password;
private static String url;
private static String driver;
// 读取配置文件的内容，最好放到静态代码块中。这样只会在初始化类时，加载一次
// 而不会每生成一个实例化对象都调用一次，减少IO操作
static {
try {
Properties properties = new Properties();
//properties.load(new FileInputStream("E:\\Java全栈\\code\\JavaSE\\src\\jdbc.properties")); // 使用配置文件的绝对路径
properties.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties")); // 使用反射来使用配置文件的相对路径
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
System.out.println(url+"\t"+user+"\t"+password+"\t"+driver);
} catch (IOException e) {
e.printStackTrace();
}
}
// 连接数据库
public Connection getConnect(){
try {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
return connection;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return null;
}
}
（4）资源关闭的封装
连接数据库后，会有一大堆东西需要关闭。我们也可以给他包装成一个方法
package com.oy.jdbctest.jdbcutils;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class MyJdbcUtils{
private static String user;
private static String password;
private static String url;
private static String driver;
// 读取配置文件的内容，最好放到静态代码块中。这样只会在初始化类时，加载一次
// 而不会每生成一个实例化对象都调用一次，减少IO操作
static {
try {
Properties properties = new Properties();
//properties.load(new FileInputStream("E:\\Java全栈\\code\\JavaSE\\src\\jdbc.properties")); // 使用配置文件的绝对路径
properties.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties")); // 使用反射来使用配置文件的相对路径
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
System.out.println(url+"\t"+user+"\t"+password+"\t"+driver);
} catch (IOException e) {
e.printStackTrace();
}
}
// 连接数据库
public static Connection getConnect(){
try {
// 创建驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://localhost:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "xxx");
return connection;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return null;
}
// 关闭资源
public static void closeConnect(Connection connection, Statement statement, ResultSet resultSet){
if (connection != null){
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (statement!=null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (resultSet!=null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
（5）测试：使用封装的工具类完成数据库的访问
class Demo7{
public static void main(String[] args) throws SQLException {
// 获取连接
Connection connect = MyJdbcUtils.getConnect();
// 生成sql命令发射器
PreparedStatement preparedStatement = connect.prepareStatement("select * from employ3");
// 执行sql
ResultSet resultSet = preparedStatement.executeQuery();
// 获取结果
while (resultSet.next()){
String name = resultSet.getString("ename");
String salary = resultSet.getString("salary");
System.out.println("姓名："+name+"\t薪资："+salary);
}
// 如果每这么多资源需要关闭，直接填null就行
JdbcUtils.closeConnect(connect,preparedStatement,resultSet);
}
}
2.65 查询结果封装为对象(使用元数据)
实际开发者，一张数据表往往对应Java中的一个类，表字段对应类的成员属性。所有我们获取到数据表中的数据时，需要将它们封装为该类的一个对象。
如下是一张accout表，我们获取到表中的数据后将每一条记录封装为一个Account对象。
①：创建Account类
package com.oy.jdbctest.accouttest;
public class Account {
private int id;
private String aname;
private double money;
public Account(int id, String aname, double money) {
this.id = id;
this.aname = aname;
this.money = money;
}
public Account() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getAname() {
return aname;
}
public void setAname(String aname) {
this.aname = aname;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", aname='" + aname + '\'' +
", money=" + money +
'}';
}
}
②：获取数据表account中的所有数据，并封装为Account类对象
package com.oy.jdbctest.accouttest;
import com.oy.jdbctest.jdbcutils.JdbcUtils;
import java.lang.reflect.Field;
import java.sql.*;
class Test {
public static void main(String[] args) {
try {
// 1.获取连接
Connection connect = MyJdbcUtils.getConnect();
// 2.生成发射器
PreparedStatement pst = connect.prepareStatement("select * from acount");
// 3.执行sql
ResultSet resultSet = pst.executeQuery();
// 4.处理结果，将读取的数据封装为对象
// getMetaData()方法可以获取结果集resultSet的元数据
// 数据就是描述结果集中的数据的数据，例如：列数，列名称, 列别名等
/*
* 元数据.getColumnCount(); 获取列数
* 元数据.getColumnLabel(n); 获取第n列字段的别名，从1开始计算
* 元数据.getColumnClassName(n); 获取第n列字段的字段名（别名不起作用）
*/
ResultSetMetaData metaData = resultSet.getMetaData();
int len = metaData.getColumnCount();
while (resultSet.next()){
Account account = new Account(); // 每一条记录创建一个对象
Class<? extends Account> aClass = account.getClass(); // 获取class对象，使用反射给属性赋值
// 遍历所有字段，并将值赋给对象的属性
for (int i = 1; i <= len; i++) {
String key = metaData.getColumnLabel(i); // 获取字段
Object value = resultSet.getObject(key); // 获取该条记录字段的值
Field declaredField = aClass.getDeclaredField(key); // 获取属性对象
declaredField.setAccessible(true); // 将私有属性设置为可访问
declaredField.set(account,value); // 给属性赋值
}
System.out.println(account); // 打印一下对象
}
} catch (SQLException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
第三章 增删改查通用方法封装
前面我们将数据库的连接，释放操作进行了封装。但是还不够，我们可以将数据库的增删改查操作进行封装，这样我们在想要操作数据库时，只需要使用相关方法即可，不需要去关心数据库的连接，释放操作。
1.增删改方法封装
package com.oy.jdbctest.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class BasiDao1 {
/**
* /通用的增删改操作
* @param sql: 需要执行的sql
* @param args：需要传入的参数
* @return int: 本次操作影响的记录数
*/
public int basUpdate(String sql,Object... args) throws SQLException {
// 1.获取连接
Connection connect = MyJdbcUtils.getConnect();
// 2.创建命令发射器
PreparedStatement preparedStatement = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
preparedStatement.setObject(i,args[i-1]);
}
// 4.执行sql
int i = preparedStatement.executeUpdate();
return i;
}
}
测试一下：
class Demo10 {
public static void main(String[] args) {
try {
BasiDao1 basiDao1 = new BasiDao1();
int res = basiDao1.basUpdate("insert into user values(null,?,?)", "王麻子", "123456");
System.out.println(res > 0 ? "添加成功" : "添加失败");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
结果如下：数据添加成功
2.通用的查询方法封装
（1）有实体类对象的查询
查询的方法会返回一个结果集，需要将结果集中的数据封装为对应的Java类对象。前面我们已经讲过通过元数据和反射来实现，但是现在我们要实现通用的查询方法，也就是改方法来能适用于任何的类（满足JavaBean）。那么我们需要使用泛型来实现
package com.oy.jdbctest.jdbcutils;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
public class BasiDao1 {
/**
* /通用的增删改操作
* @param sql: 需要执行的sql
* @param args：需要传入的参数
* @return int: 本次操作影响的记录数
*/
public int basUpdate(String sql,Object... args) throws SQLException {
// 1.获取连接
Connection connect = MyJdbcUtils.getConnect();
// 2.创建命令发射器
PreparedStatement preparedStatement = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
preparedStatement.setObject(i,args[i-1]);
}
// 4.执行sql
int i = preparedStatement.executeUpdate();
// 关闭资源
MyJdbcUtils.closeConnect(connect,preparedStatement,null);
return i;
}
/**
* 通用的查询方法，适用于多个JavaBean类对象
* @param clazz：数据表对应的Java类的class对象
* @param sql：需要执行的sql语句
* @param args：需要传入的参数
* @param ：对象类型
* @return Arraylist: 对象列表
*/
public <T> ArrayList<T> getAll(Class<T> clazz,String sql, Object... args) throws Exception {
// 1.创建连接
Connection connect = MyJdbcUtils.getConnect();
// 2.生成命令发射器
PreparedStatement pst = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
pst.setObject(i,args[i-1]);
}
// 4.执行sql
ResultSet resultSet = pst.executeQuery();
// 5.处理结果，将其封装为对应的对象
ResultSetMetaData metaData = resultSet.getMetaData(); //获取结果集中的元数据
int count = metaData.getColumnCount(); // 获取字段列数
ArrayList<T> lists = new ArrayList<>(); // 生成一个列表，用于存放对象
while (resultSet.next()){ // 获取到结果中的每一行记录
T t = clazz.newInstance(); // 获取JavaBean的实例对象
for (int i = 0; i < count; i++) {
String columnLabel = metaData.getColumnLabel(i + 1); // 获取字段名
Object value = resultSet.getObject(columnLabel); // 获取记录中对应字段的数据值
// 使用反射将数据值保存JavaBean实例对象的属性中
Field declaredField = clazz.getDeclaredField(columnLabel);
declaredField.setAccessible(true);
declaredField.set(t,value);
}
lists.add(t); // 将对象添加到集合中
}
MyJdbcUtils.closeConnect(connect,pst,resultSet);
return lists;
}
}
测试一下：
class Demo11{
public static void main(String[] args) throws Exception {
BasiDao1 basiDao1 = new BasiDao1();
ArrayList lists = basiDao1.getAll(Account.class,"select * from acount");
lists.forEach(System.out::println);
}
}
效果如下：
Account{id=1, aname='张三', money=2500.0}
Account{id=2, aname='李四', money=1500.0}
（2）没有实体类对象的查询
- 还存在这种情况，我们的查询sql中有分组函数（COUNT，SUM等）会导致字段改变，这样我们Java类就对象不上查询结果了。这种没有实体类对象的查询该如何封装呢
- 解决办法：使用Map来储存数据，然后将Map储存在List中
package com.oy.jdbctest.jdbcutils;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class BasiDao1 {
/**
* /通用的增删改操作
* @param sql: 需要执行的sql
* @param args：需要传入的参数
* @return int: 本次操作影响的记录数
*/
public int basUpdate(String sql,Object... args) throws SQLException {
// 1.获取连接
Connection connect = MyJdbcUtils.getConnect();
// 2.创建命令发射器
PreparedStatement preparedStatement = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
preparedStatement.setObject(i,args[i-1]);
}
// 4.执行sql
int i = preparedStatement.executeUpdate();
// 关闭资源
MyJdbcUtils.closeConnect(connect,preparedStatement,null);
return i;
}
/**
* 通用的查询方法，适用于多个JavaBean类对象
* @param clazz：数据表对应的Java类的class对象
* @param sql：需要执行的sql语句
* @param args：需要传入的参数
* @param ：对象类型
* @return Arraylist: 对象列表
*/
public <T> ArrayList<T> getAll(Class<T> clazz,String sql, Object... args) throws Exception {
// 1.创建连接
Connection connect = MyJdbcUtils.getConnect();
// 2.生成命令发射器
PreparedStatement pst = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
pst.setObject(i,args[i-1]);
}
// 4.执行sql
ResultSet resultSet = pst.executeQuery();
// 5.处理结果，将其封装为对应的对象
ResultSetMetaData metaData = resultSet.getMetaData(); //获取结果集中的元数据
int count = metaData.getColumnCount(); // 获取字段列数
ArrayList<T> lists = new ArrayList<>(); // 生成一个列表，用于存放对象
while (resultSet.next()){ // 获取到结果中的每一行记录
T t = clazz.newInstance(); // 获取JavaBean的实例对象
for (int i = 0; i < count; i++) {
String columnLabel = metaData.getColumnLabel(i + 1); // 获取字段名
Object value = resultSet.getObject(columnLabel); // 获取记录中对应字段的数据值
// 使用反射将数据值保存JavaBean实例对象的属性中
Field declaredField = clazz.getDeclaredField(columnLabel);
declaredField.setAccessible(true);
declaredField.set(t,value);
}
lists.add(t); // 将对象添加到集合中
}
MyJdbcUtils.closeConnect(connect,pst,resultSet);
return lists;
}
/**
* 通用的查询方法，适用于没有实体类的查询
* @param sql：待执行的sql
* @param args：传入的参数
* @return ArrayList: Map对象列表
*/
public ArrayList<Map> getAllToMap(String sql,Object... args) throws Exception{
// 1.获取连接
Connection connect = MyJdbcUtils.getConnect();
// 2.生成命令发射器
PreparedStatement pst = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
pst.setObject(i,args[i-1]);
}
// 4.执行sql
ResultSet resultSet = pst.executeQuery();
// 5.处理结果
ResultSetMetaData metaData = resultSet.getMetaData(); // 获取元数据
int count = metaData.getColumnCount(); // 获取字段列数
ArrayList<Map> lists = new ArrayList<>();
while (resultSet.next()){ // 获取每一条记录，进行处理
HashMap<String, Object> hashMap = new HashMap<>();
for (int i = 0; i < count; i++) {
String key = metaData.getColumnLabel(i + 1); // 获取字段名
Object value = resultSet.getObject(key); // 获取对应字段名的值
hashMap.put(key,value);
}
lists.add(hashMap);
}
MyJdbcUtils.closeConnect(connect,pst,resultSet);
return lists;
}
}
测试一下：
{avg(salary)=17258.22375, e_pid=1}
{avg(salary)=20250.29, e_pid=2}
{avg(salary)=15282.34, e_pid=3}
{avg(salary)=13644.253333, e_pid=4}
{avg(salary)=13932.08, e_pid=5}
{avg(salary)=8752.66, e_pid=6}
{avg(salary)=10256.3, e_pid=7}
{avg(salary)=7855.44, e_pid=8}
{avg(salary)=15466.88, e_pid=9}
{avg(salary)=3400.22, e_pid=10}
{avg(salary)=4000.33, e_pid=11}
3.使用ThreadLocal实现事务处理
- 前面我们对增删查改方法进行了封装，但是有一个问题。那就是无法实现事务处理。如下所示：我们的事务操作虽然是在同一个线程下完成的，但开启事务和执行sql的不是同一个连接，所以事务是无法生效的
Connection connect = null; try { connect = MyJdbcUtils.getConnect(); // 连接1 // 开启事务 connect.setAutoCommit(false); // 执行sql BasiDao1 basiDao1 = new BasiDao1(); basiDao1.basUpdate("update acount set money = money-500 where id = 1"); // 连接2 basiDao1.basUpdate("update acount set money = money+500 where id = 2"); // 连接3 connect.commit(); } catch (SQLException e) { try { connect.rollback(); // 失败就回滚 } catch (SQLException ex) { ex.printStackTrace(); } e.printStackTrace(); } - 解决办法：就是要保证在同一个线程下，无论创建几次连接，它们都要是同一个连接。可以使用多线程中的ThreadLocal类来实现
- ThreadLocal简介：
ThreadLocal用于保存某个线程共享变量，原因是在Java中，每一个线程对象中都有一个ThreadLocalMap - 实现原理：
1.我们在调用getConnect时，不直接分配一个新的连接。而是使用ThreadLocal.get方法检查当前线程中的共享变量是否存在。
2.如果为null表明当前线程中还没有数据库连接。则创建一个新连接。并使用ThreadLocal.set方法把该连接对象设置为线程共
享变量
3.再次调用getConnect时，那么ThreadLocal.get方法返回的就不是null了。这时我们则不新建连接，而是将ThreadLocal
中的共享对象返回
4.当调用closeConnect释放连接时，将ThreadLocal中的共享对象也释放掉
我们在MyJdbcUtils 类中引入ThreadLocal
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class MyJdbcUtils {
private static String user;
private static String password;
private static String url;
private static String driver;
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
// 读取配置文件的内容，最好放到静态代码块中。这样只会在初始化类时，加载一次
// 而不会每生成一个实例化对象都调用一次，减少IO操作
static {
try {
Properties properties = new Properties();
//properties.load(new FileInputStream("E:\\Java全栈\\code\\JavaSE\\src\\jdbc.properties")); // 使用配置文件的绝对路径
properties.load(MyJdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties")); // 使用反射来使用配置文件的相对路径
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
System.out.println(url+"\t"+user+"\t"+password+"\t"+driver);
} catch (IOException e) {
e.printStackTrace();
}
}
// 连接数据库
public static Connection getConnect(){
try {
// 创建驱动
if (threadLocal.get() != null){
// 表示该线程已经有连接了
return threadLocal.get();
}else {
// 表示该线程还没有连接
Class.forName("com.mysql.cj.jdbc.Driver");
// 创建连接
String url = "jdbc:mysql://81.71.84.102:3306/test2";
Connection connection = DriverManager.getConnection(url, "root", "ouyi1994");
threadLocal.set(connection);
return connection;
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return null;
}
// 关闭资源
public static void closeConnect(Connection connection, Statement statement, ResultSet resultSet){
if (connection != null){
try {
threadLocal.remove(); // 清除共享数据
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (statement!=null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (resultSet!=null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
注意：现在的增删查改方法中就不能直接关闭connect了，只能在事务完成后关闭、
public int basUpdate(String sql,Object... args) throws SQLException {
// 1.获取连接
Connection connect = MyJdbcUtils.getConnect();
// 2.创建命令发射器
PreparedStatement preparedStatement = connect.prepareStatement(sql);
// 3.填充sql
for (int i = 1; i < args.length+1; i++) {
//设置？的值
//因为不知道sql中是否有?，以及？设置为什么值，通过形参来传入
//Object... args可变形参，可以传入0~n个值
//如果没有传入，说明没有？需要设置
//如果传入了n个值，那么说明sql中有n个？需要设置
// sql中的？是从1开始，而args的下标是从0开始
preparedStatement.setObject(i,args[i-1]);
}
// 4.执行sql
int i = preparedStatement.executeUpdate();
// 关闭资源
MyJdbcUtils.closeConnect(null,preparedStatement,null); // 这里就不能关闭connect了，因为事务可能还需要使用
return i;
}
测试代码：
class Demo13{
public static void main(String[] args){
Connection connect = null;
try {
connect = MyJdbcUtils.getConnect();
// 开启事务
connect.setAutoCommit(false);
// 执行sql
BasiDao1 basiDao1 = new BasiDao1();
basiDao1.basUpdate("update acount set money = money-500 where id = 1");
basiDao1.basUpdate("update acount set money = money-500 where id = 2");
connect.commit();
} catch (SQLException e) {
try {
connect.rollback(); // 失败就回滚
} catch (SQLException ex) {
ex.printStackTrace();
}
e.printStackTrace();
}finally {
MyJdbcUtils.closeConnect(connect,null,null); // 需要关闭连接
}
}
}
第四章 数据库连接池
1、什么是数据库连池
连接对象的缓冲区。负责申请，分配管理，释放连接的操作。
2、为什么要使用数据库连接池
Connection对象在每次执行DML和DQL的过程中都要创建一次,DML和DQL执行完毕后,connection对象都会被销毁. connection对象是可以反复使用的,没有必要每次都创建新的.该对象的创建和销毁都是比较消耗系统资源的,如何实现connection对象的反复使用呢?使用连接池技术实现。
3.连接池的优势
- 预先准备一些链接对象,放入连接池中,当多个线程并发执行时,可以避免短时间内一次性大量创建链接对象,减少计算机单位时间内的运算压力,提高程序的响应速度
- 实现链接对象的反复使用,可以大大减少链接对象的创建次数,减少资源的消耗
4、市面上有很多现成的数据库连接池技术：
- JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口（通常被称为数据源），该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：
- DBCP 是Apache提供的数据库连接池，速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持
- C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以
- Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
- BoneCP 是一个开源组织提供的数据库连接池，速度快
- Druid 是阿里提供的数据库连接池，据说是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池
5、阿里的德鲁伊连接池技术(Druid)
（1）加入jar包
例如：druid-1.1.10.jar
（2）代码步骤
第一步：建立一个数据库连接池
第二步：设置连接池的参数
第三步：获取连接
public class TestPool {
public static void main(String[] args) throws SQLException {
//1、创建数据源（数据库连接池）对象
DruidDataSource ds =new DruidDataSource();
//2、设置参数
//(1)设置基本参数
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql://localhost:3306/test");
ds.setUsername("root");
ds.setPassword("123456");
//(2)设置连接数等参数
ds.setInitialSize(5);//一开始提前申请好5个连接，不够了，重写申请
ds.setMaxActive(10);//最多不超过10个，如果10都用完了，还没还回来，就会出现等待
ds.setMaxWait(1000);//用户最多等1000毫秒，如果1000毫秒还没有人还回来，就异常了
//3、获取连接
for (int i = 1; i <=15; i++) {
Connection conn = ds.getConnection();
System.out.println("第"+i+"个：" + conn);
//如果这里没有关闭，就相当于没有还
conn.close();#这里关闭，是还回池中
}
}
}
| 配置 | 缺省 | 说明 |
|---|---|---|
| name | 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。 如果没有配置，将会生成一个名字，格式是：”DataSource-” + System.identityHashCode(this) | |
| url | 连接数据库的url，不同数据库不一样。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto | |
| username | 连接数据库的用户名 | |
| password | 连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/使用ConfigFilter | |
| driverClassName | 根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下) | |
| initialSize | 0 | 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时 |
| maxActive | 8 | 最大连接池数量 |
| maxIdle | 8 | 已经不再使用，配置了也没效果 |
| minIdle | 最小连接池数量 | |
| maxWait | 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。 | |
| poolPreparedStatements | false | 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。 |
| maxOpenPreparedStatements | -1 | 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100 |
| validationQuery | 用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。 | |
| testOnBorrow | true | 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 |
| testOnReturn | false | 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能 |
| testWhileIdle | false | 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 |
| timeBetweenEvictionRunsMillis | 有两个含义： 1)Destroy线程会检测连接的间隔时间2)testWhileIdle的判断依据，详细看testWhileIdle属性的说明 | |
| numTestsPerEvictionRun | 不再使用，一个DruidDataSource只支持一个EvictionRun | |
| minEvictableIdleTimeMillis | ||
| connectionInitSqls | 物理连接初始化的时候执行的sql | |
| exceptionSorter | 根据dbType自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接 | |
| filters | 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall | |
| proxyFilters | 类型是List，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系 |