01-JDBC概述
-
数据的持久化:
持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。 -
JDBC的理解：
JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API）
简单理解为：JDBC，是SUN提供的一套 API，使用这套API可以实现对具体数据库的操作（获取连接、关闭连接、DML、DDL、DCL)
3.图示理解：
好处：
面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用
从开发程序员的角度：不需要关注具体的数据库的细节
数据库厂商：只需要提供标准的具体实现。
4.数据库的驱动：
数据库厂商针对于JDBC这套接口，提供的具体实现类的集合。
5.面向接口编程的思想：
JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。
不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。
02-数据库的连接
方式一、方式二、方式三、方式四：作为过程存在，了解即可
public void getConnection() throws Exception {
/*方式5(final版)：将获取数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式
获取连接
好处：1.实现了数据（4个基本信息）和代码的分离。实现了解耦
2.如果需要重新修改配置文件信息，就可以避免工程重新打包（修改了代码就需要重新打包）
*/
//读取配置文件中的4个基本信息
//如果是部署到Tomcat服务器上，就要用第一种，因为类加载器不同。ConnectionTest：当前类
//(1)InputStream inputStream=ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
//使用系统类加载器的getSystemClassLoader（）方法中文件的相对路径为
//相对于类路径来说的，也就是src目录
//这里是用得到系统类加载器（应用加载器）ClassLoader.getSystemClassLoader
Properties properties = new Properties();
//用properties去加载这个inputStream,从中读取属性列表（键和元素对）
properties.load(inputStream);
String URL = properties.getProperty("URL");
String USER = properties.getProperty("USER");
String PASSWORD = properties.getProperty("PASSWORD");
String DRIVER = properties.getProperty("DRIVER");
//加载驱动（就是将MySQL实现的驱动，也就是Driver接口的实现导入）
Class.forName(DRIVER);
//获取连接
Connection connection = DriverManager.getConnection(URL,USER,PASSWORD);
System.out.println(connection);
}
}
其中，配置文件【jdbc.properties】：此配置文件声明在工程的src下
这是mysql-connector-java-8.0.19的jar包，低于8.0版本的可能有不同，还有8.0版本必须要设置时区，字符集也顺便设置，DRIVER的位置也可能不同，具体百度
# jdbc 配置文件
URL=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=UTF-8&rewriteBatchedStatements=true
USER=root
PASSWORD=123456
DRIVER=com.mysql.cj.jdbc.Driver
JDBCUtils.java
public static Connection getConnection() throws Exception {
/*
*@Author zcq
*@Description //TOdO 获取数据库来连接
*@Param
*@Return 数据库连接
*@Author zcq
*@Date 2020-10-5
*/
InputStream inputStream= ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
Properties properties = new Properties();
//用properties去加载这个inputStream
properties.load(inputStream);
String URL = properties.getProperty("URL");
String USER = properties.getProperty("USER");
String PASSWORD = properties.getProperty("PASSWORD");
String DRIVER = properties.getProperty("DRIVER");
//加载驱动
Class.forName(DRIVER);
//获取连接
return DriverManager.getConnection(URL,USER,PASSWORD);
}
public static void closeResource(Connection connection, Statement ps){
try {
//这里是防止得到ps对象是抛出异常，导致ps对象为空，这样就不能执行close了
if (ps != null) {
ps.close();
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
if (connection != null) {
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
public static void closeResource(Connection connection, Statement ps, ResultSet rs){
try {
//这里是防止得到ps对象是抛出异常，导致ps对象为空，这样就不能执行close了
if (ps != null) {
ps.close();
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
try {
if (rs != null) {
ps.close();
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
if (connection != null) {
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
03-Statement接口实现CRUD操作（了解）
增、删、改； 查询
/*
* 实现对数据表中数据的增删改操作
*/
public void update(String sql){
Connection conn = null;
Statement st = null;
try {
//1.获取数据库的连接
conn = JDBCUtils.getConnection();
//2.创建一个Statement的实例
st = conn.createStatement();
//3.根据提供的sql语句，执行
st.execute(sql);
} catch (Exception e) {
e.printStackTrace();
}finally{
//4.资源的关闭
JDBCUtils.close(conn, st);
}
}
/*
* 实现对数据表的查询操作。需要使用结果集：ResultSet
*
*/
public <T> T get(String sql, Class<T> clazz) {// (sql, Customer.class)
T t = null;
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
st = conn.createStatement();
rs = st.executeQuery(sql);
// 获取结果集的元数据
ResultSetMetaData rsmd = rs.getMetaData();
// 获取结果集的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) {
// //1. 获取列的名称
// String columnName = rsmd.getColumnName(i+1);
// 1. 获取列的别名
// 注意：获取结果集中（相当于数据表）列的名称（别名）
String columnName = rsmd.getColumnLabel(i + 1);
// 2. 根据列名获取对应数据表中的数据
Object columnVal = rs.getObject(columnName);
// 3. 将数据表中得到的数据，封装进对象
// 注意：反射根据Java中类的属性获取Field对象
Field field = clazz.getDeclaredField(columnName);
field.setAccessible(true);
field.set(t, columnVal);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭资源
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (st != null) {
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return null;
}
Statement使用的弊端
弊端：
但是使用Statement操作数据表存在弊端：
问题一：存在拼串操作，繁琐
问题二：存在SQL注入问题
SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：SELECT user, password FROM user_table WHERE user=‘a‘ OR 1 = ‘ AND password = ‘ OR ‘1‘ = ‘1‘) ，从而利用系统的 SQL 引擎完成恶意行为的做法。
Scanner scan = new Scanner(System.in);
String name = scan.next();
....
拼串
String sql = "insert into customers(name,email,birth)values(‘" + name +"‘,‘"+email+"‘,‘"+birth+"‘)";
说实话，一下子是真的很难看出来
SQL注入：
SELECT user,password FROM user_table WHERE user = ‘1‘ or ‘ AND password = ‘=1 or ‘1‘ = ‘1‘
其他问题：
Statement没办法操作Blob类型变量
Statement实现批量插入时，效率较低
04-PreparedStatement替换Statement实现CRUD操作
1.PreparedStatement的理解：
① PreparedStatement 是Statement的子接口
② An object that represents a precompiled SQL statement. （预编译sql语句）
③ 可以解决Statement的sql注入问题，拼串问题
2.使用PreparedStatement实现通用的增、删、改的方法：version 1.0
//通用的增删改操作
public void update(String sql,Object ...args){//sql中占位符的个数与可变形参的长度相同！
Connection conn = null;
PreparedStatement ps = null;
try {
//1.获取数据库的连接
conn = JDBCUtils.getConnection();
//2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
//3.填充占位符
for(int i = 0;i < args.length;i++){
ps.setObject(i + 1, args[i]);//小心参数声明错误！！
}
//4.执行
ps.execute();
} catch (Exception e) {
e.printStackTrace();
}finally{
//5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
}
3.使用PreparedStatement实现通用的查询操作：version 1.0
public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
public <T> List<T> getForList(Class<T> clazz,String sql, Object... args){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
//创建集合对象
ArrayList<T> list = new ArrayList<T>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
【总结】
两种思想：
面向接口编程的思想
ORM编程思想：（object relational mapping）
- 一个数据表对应一个java类
- 表中的一条记录对应java类的一个对象
- 表中的一个字段对应java类的一个属性
两种技术：
1.使用结果集的元数据：ResultSetMetaData
getColumnCount():获取列数
getColumnLabel():获取列的别名
说明：如果sql中没给字段其别名，getColumnLabel()获取的就是列名
2. 反射的使用（①创建对应的运行时类的对象 ② 在运行时，动态的调用指定的运行时类的属性、方法）
05-PreparedStatement操作Blob类型的变量
PreparedStatement可以操作Blob类型的变量。
写入操作的方法：setBlob(InputStream is);
读取操作的方法：
Blob blob = getBlob(int index);
InputStream is = blob.getBinaryStream();
具体的insert:
//向数据表customers中插入Blob类型的字段
@Test
public void testInsert() throws Exception{
Connection conn = JDBCUtils.getConnection();
String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setObject(1,"袁浩");
ps.setObject(2, "yuan@qq.com");
ps.setObject(3,"1992-09-08");
FileInputStream is = new FileInputStream(new File("girl.jpg"));
ps.setBlob(4, is);
ps.execute();
JDBCUtils.closeResource(conn, ps);
}
具体的query:
//查询数据表customers中Blob类型的字段
@Test
public void testQuery(){
Connection conn = null;
PreparedStatement ps = null;
InputStream is = null;
FileOutputStream fos = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
String sql = "select id,name,email,birth,photo from customers where id = ?";
ps = conn.prepareStatement(sql);
ps.setInt(1, 21);
rs = ps.executeQuery();
if(rs.next()){
// 方式一：
// int id = rs.getInt(1);
// String name = rs.getString(2);
// String email = rs.getString(3);
// Date birth = rs.getDate(4);
//方式二：
int id = rs.getInt("id");
String name = rs.getString("name");
String email = rs.getString("email");
Date birth = rs.getDate("birth");
Customer cust = new Customer(id, name, email, birth);
System.out.println(cust);
//将Blob类型的字段下载下来，以文件的方式保存在本地
Blob photo = rs.getBlob("photo");
is = photo.getBinaryStream();
fos = new FileOutputStream("zhangyuhao.jpg");
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
fos.write(buffer, 0, len);
}
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
if(is != null)
is.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
JDBCUtils.closeResource(conn, ps, rs);
}
}
06-PreparedStatement实现高效的批量插入
层次一：使用Statement实现
* Connection conn = JDBCUtils.getConnection();
* Statement st = conn.createStatement();
* for(int i = 1;i <= 20000;i++){
* String sql = "insert into goods(name)values(‘name_" + i + "‘)";
* st.execute(sql);
* }
层次二：使用PreparedStatement替换Statement
public void testBash() {
Connection con=null;
PreparedStatement pst = null;
try {
long start=System.currentTimeMillis();
con= JdbcUtils.getConnection();
String sql="insert into goods(NAME)values(?)";
pst = con.prepareStatement(sql);
for(int i = 1; i <=20000;i++){
pst.setObject(1,"name_"+i);
pst.execute();
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为："+(end - start));
//20000:14683
} catch (Exception exception) {
exception.printStackTrace();
}finally {
JdbcUtils.closeResource(con,pst);
}
}
层次三：
1.addBatch()、executeBatch()、clearBatch()
2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。?rewriteBatchedStatements=true 写在配置文件的url后面
3.使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar以上
public void testBash1() {
Connection con = null;
PreparedStatement pst = null;
try {
long start = System.currentTimeMillis();
con = JdbcUtils.getConnection();
String sql = "insert into goods(NAME)values(?)";
pst = con.prepareStatement(sql);
for (int i = 1; i <= 1000000; i++) {
pst.setObject(1, "name_" + i);
// 1.攒sql
pst.addBatch();
if (i % 500 == 0) {
//每攒500执行sql
pst.executeBatch();
//清空，继续下一次
pst.clearBatch();
}
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));
// 20000:565
//1000000:5380
} catch (Exception exception) {
exception.printStackTrace();
} finally {
JdbcUtils.closeResource(con, pst);
}
}
层次四：设置连接不允许自动提交数据
最终版的代码体现：
public void testBash2() {
Connection con = null;
PreparedStatement pst = null;
try {
long start = System.currentTimeMillis();
con = JdbcUtils.getConnection();
//设置不允许自动提交数据
con.setAutoCommit(false);
String sql = "insert into goods(NAME)values(?)";
pst = con.prepareStatement(sql);
for (int i = 1; i <= 20000; i++) {
pst.setObject(1, "name_" + i);
// 1.攒sql
pst.addBatch();
if (i % 500 == 0) {
//每攒500执行sql
pst.executeBatch();
//清空，继续下一次
pst.clearBatch();
}
}
con.commit();
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));
// 20000:565->400
//1000000:5380->4165
} catch (Exception exception) {
exception.printStackTrace();
} finally {
JdbcUtils.closeResource(con, pst);
}
}
总结：PreparedStatement与Statement的异同？
① 指出二者的关系？ 接口 与 子接口的关系
② 开发中，PreparedStatement替换Statement
③ An object that represents a precompiled SQL statement.
07-数据库的事务
1.事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
-
> 一组逻辑操作单元：一个或多个DML操作。
2.事务处理的原则：
保证所事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。
当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存
下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
说明：
1.数据一旦提交，就不可回滚
*
2.哪些操作会导致数据的自动提交？
-
>DDL操作一旦执行，都会自动提交。 -
>set autocommit = false 对DDL操作失效 -
>DML默认情况下，一旦执行，就会自动提交。 -
>我们可以通过set autocommit = false的方式取消DML操作的自动提交。 -
>默认在关闭连接时，会自动的提交数据
3.代码的体现：
```
public void testUpdateWithTx() {
Connection conn = null;
try {
conn = JDBCUtils.getConnection();
System.out.println(conn.getAutoCommit());//true
//1.取消数据的自动提交
conn.setAutoCommit(false);
String sql1 = "update user_table set balance = balance - 100 where user = ?";
update(conn,sql1, "AA");
//模拟网络异常
System.out.println(10 / 0);
String sql2 = "update user_table set balance = balance + 100 where user = ?";
update(conn,sql2, "BB");
System.out.println("转账成功");
//2.提交数据
conn.commit();
} catch (Exception e) {
e.printStackTrace();
//3.回滚数据
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}finally{
//修改其为自动提交数据
//主要针对于使用数据库连接池的使用
try {
conn.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
}
JDBCUtils.closeResource(conn, null);
}
}
4.考虑到事务以后，实现的通用的增删改操作： version 2.0
**把连接传进去，里面不用关闭连接，2次操作用的都是同一个连接**
通用的增删改操作---version 2.0 （考虑上事务）
public int update(Connection conn,String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
PreparedStatement ps = null;
try {
// 1.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 2.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
}
// 3.执行
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 4.资源的关闭
JDBCUtils.closeResource(null, ps);
}
return 0;
}
考虑到事务以后，实现的通用的查询： version 2.0
通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
public <T> T getInstance(Connection conn,Class<T> clazz,String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
事务的属性
四大属性：ACID ---BAT ----BBA ---TMD
-
原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 -
一致性（Consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。 -
隔离性（Isolation）
事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。 -
持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。
对一种性的理解应用系统从一个正确的状态到另外一个正确的状态，而ACID就是说事务能够通过AID来保证这个c的过程，c是目的，AID都是手段
数据操作过程中可能出现的问题：(针对隔离性)
对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
数据库的四种隔离级别：(一致性和并发性：一致性越好，并发性越差)
如何查看并设置隔离级别：
08-DAO及其子类(重点）
BaseDao（第一版）
/*
* DAO: data(base) access object
* 封装了针对于数据表的通用的操作
*/
public abstract class BaseDAO<T> {
private Class<T> clazz = null;
// public BaseDAO(){
//
// }
{
//获取当前BaseDAO的子类继承的父类中的泛型
Type genericSuperclass = this.getClass().getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
Type[] typeArguments = paramType.getActualTypeArguments();//获取了父类的泛型参数
clazz = (Class<T>) typeArguments[0];//泛型的第一个参数
}
// 通用的增删改操作---version 2.0 （考虑上事务
public int update(Connection conn, String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
PreparedStatement ps = null;
try {
// 1.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 2.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
}
// 3.执行
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 4.资源的关闭
JDBCUtils.closeResource(null, ps);
}
return 0;
}
// 通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务
public T getInstance(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
// 通用的查询操作，用于返回数据表中的多条记录构成的集合（version 2.0：考虑上事务
public List<T> getForList(Connection conn, String sql, Object... args) {
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
// 创建集合对象
ArrayList<T> list = new ArrayList<T>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
//用于查询特殊值的通用的方法
public <E> E getValue(Connection conn,String sql,Object...args){
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
for(int i = 0;i < args.length;i++){
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
if(rs.next()){
return (E) rs.getObject(1);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
JDBCUtils.closeResource(null, ps, rs);
}
return null;
}
}
BaseDao（第2版）
public abstract class BaseDao<T> {
private QueryRunner queryRunner = new QueryRunner();
// 定义一个变量来接收泛型的类型
private Class<T> type;
// 获取T的Class对象，获取泛型的类型，泛型是在被子类继承时才确定
public BaseDao() {
// 获取子类的类型
Class clazz = this.getClass();
// 获取父类的类型
// getGenericSuperclass()用来获取当前类的父类的类型
// ParameterizedType表示的是带泛型的类型
ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
// 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型
// 这个方法会返回一个Type的数组
Type[] types = parameterizedType.getActualTypeArguments();
// 获取具体的泛型的类型·
this.type = (Class<T>) types[0];
}
/**
* 通用的增删改操作
*
* @param sql
* @param params
* @return
*/
public int update(Connection conn,String sql, Object... params) {
int count = 0;
try {
count = queryRunner.update(conn, sql, params);
} catch (SQLException e) {
e.printStackTrace();
}
return count;
}
/**
* 获取一个对象
*
* @param sql
* @param params
* @return
*/
public T getBean(Connection conn,String sql, Object... params) {
T t = null;
try {
t = queryRunner.query(conn, sql, new BeanHandler<T>(type), params);
} catch (SQLException e) {
e.printStackTrace();
}
return t;
}
/**
* 获取所有对象
*
* @param sql
* @param params
* @return
*/
public List<T> getBeanList(Connection conn,String sql, Object... params) {
List<T> list = null;
try {
list = queryRunner.query(conn, sql, new BeanListHandler<T>(type), params);
} catch (SQLException e) {
e.printStackTrace();
}
return list;
}
/**
* 获取一个但一值得方法，专门用来执行像 select count(*)...这样的sql语句
*
* @param sql
* @param params
* @return
*/
public Object getValue(Connection conn,String sql, Object... params) {
Object count = null;
try {
// 调用queryRunner的query方法获取一个单一的值。
//如果确实知道类型就用泛型，就可以避免强制装换,比如：ScalarHandler<Long> handler=new ScalarHandler<>();
count = queryRunner.query(conn, sql, new ScalarHandler<>(), params);
} catch (SQLException e) {
e.printStackTrace();
}
return count;
}
}
CustomerDAO
public interface CustomersDao {
//将customers对象添加到表中
void insert(Connection connection, Customers customers);
//根据id删除
void deleteById(Connection connection,int id);
//根据customers对象的id更新
void updateById(Connection connection, Customers customers);
//根据指定id查询到对应得customers对象
Customers getCustomersById(Connection connection,int id);
//查询表中所有记录构成的集合
List<Customers> getAll(Connection connection);
//查询表中有几条记录
long getCount(Connection connection);
//得到最大生日
Date getMaxDate(Connection connection);
}
CustomerDAOImpl
这里面用的BaseDao是第一版的BaseDao
public class CustomerDAOImpl extends BaseDAO
@Override
public void insert(Connection conn, Customer cust) {
String sql = "insert into customers(name,email,birth)values(?,?,?)";
update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth());
}
@Override
public void deleteById(Connection conn, int id) {
String sql = "delete from customers where id = ?";
update(conn, sql, id);
}
@Override
public void update(Connection conn, Customer cust) {
String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth(),cust.getId());
}
@Override
public Customer getCustomerById(Connection conn, int id) {
String sql = "select id,name,email,birth from customers where id = ?";
Customer customer = getInstance(conn, sql,id);
return customer;
}
@Override
public List<Customer> getAll(Connection conn) {
String sql = "select id,name,email,birth from customers";
List<Customer> list = getForList(conn, sql);
return list;
}
@Override
public Long getCount(Connection conn) {
String sql = "select count(*) from customers";
return getValue(conn, sql);
}
@Override
public Date getMaxBirth(Connection conn) {
String sql = "select max(birth) from customers";
return getValue(conn, sql);
}
}
总结：考虑到事务以后的数据库操作(重点)
1.获取数据库的连接
Connection conn = JDBCUtils.getConnection(); //方式1：手动获取连接 方式2:数据库连接池
conn.setAutoCommit(false); //体现事务
2.如下的多个DML操作，作为一个事务出现：
操作1：需要使用通用的增删改查操作 //通用的增删改查操作如何实现？
//方式1：手动使用PreparedStatement实现
操作2：需要使用通用的增删改查操作 //方式2：使用dbutils.jar中QueryRunner类
操作3：需要使用通用的增删改查操作
conn.commit();
3.如果出现异常，则：
conn.rollback();
4.关闭资源
JDBCUtils.closeResource(..,...,...); //方式1：手动关闭资源 方式2：DbUtils类的关闭方法
09-数据库连接池
1.传统连接的问题：
2.如何解决传统开发中的数据库连接问题:使用数据库连接池
3.使用数据库连接池的好处：
或自己组织语言：
1.提高程序的响应速度(减少了创建连接相应的时间)
2.降低资源的消耗(可以重复使用已经提供好的连接)
3.便于连接的管理
4.实现的方式：
C3P0
导入jar包：
不知道是不是版本的原因，这里需要2个jar包
测试连接的代码：
private static ComboPooledDataSource cpds = new ComboPooledDataSource("hellc3p0");
public static Connection getConnection1() throws SQLException{
Connection conn = cpds.getConnection();
return conn;
}
其中，配置文件定义在src下。名为：c3p0-config.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<c3p0-config>
<named-config name="helloC3p0">
<!-- 获取连接的4个基本信息 -->
<property name="user">root</property>
<property name="password">123456</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=UTF-8&rewriteBatchedStatements=true</property>
<property name="driverClass">com.mysql.cj.jdbc.Driver</property>
<!-- 涉及到数据库连接池的管理的相关属性的设置 -->
<!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
<property name="acquireIncrement">5</property>
<!-- 初始化数据库连接池时连接的数量 -->
<property name="initialPoolSize">5</property>
<!-- 数据库连接池中的最小的数据库连接数 -->
<property name="minPoolSize">5</property>
<!-- 数据库连接池中的最大的数据库连接数 -->
<property name="maxPoolSize">17</property>
<!-- C3P0 数据库连接池可以维护的 Statement 的个数 -->
<property name="maxStatements">20</property>
<!-- 每个连接同时可以使用的 Statement 对象的个数 -->
<property name="maxStatementsPerConnection">5</property>
</named-config>
</c3p0-config>
其实C3P0好像也可以用.proproperties这种形式的配置文件
DBCP
导入jar包：
测试连接的代码：
private static DataSource source;
static{
try {
Properties pros = new Properties();
FileInputStream is = new FileInputStream(new File("src/dbcp.properties"));
pros.load(is);
source = BasicDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection2() throws Exception{
Connection conn = source.getConnection();
return conn;
}
其中，配置文件定义在src下：dbcp.properties
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///test
username=root
password=abc123
initialSize=10
Druid
导入jar包：
测试连接的代码：
/**
* 使用Druid数据库连接池技术
*/
private static DataSource source1;
static{
try {
Properties pros = new Properties();
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
pros.load(is);
source1 = DruidDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection3() throws SQLException{
Connection conn = source1.getConnection();
return conn;
}
其中，配置文件定义在src下：druid.properties
url=jdbc:mysql:///test
username=root
password=abc123
driverClassName=com.mysql.jdbc.Driver
initialSize=10
maxActive=10
数据库配置文件总结
其实大多数配置文件都是一样，比如Druid和DBCP配置文件主要属性基本相同
10-DBUtils提供的jar包实现CRUD操作
导入jar包：
使用现成的jar中的QueryRunner测试增、删、改的操作:
public void testInsert(){
Connection conn = null;
try{
QueryRunner queryRunner = new QueryRunner();
conn= JdbcUtils.getConnection3();
String sql="insert into customers(name,email,birth)values(?,?,?)";
int insertCount=queryRunner.update(conn,sql,"蔡徐坤","caixukun@126.com","1997-09-18");
System.out.println("添加了"+insertCount+"条记录");
} catch (Exception exception) {
exception.printStackTrace();
}finally {
JdbcUtils.closeResource(conn,null);
}
}
使用现成的jar中的QueryRunner测试查询的操作:
public void testQuery1(){
//BeanHandler是封装了一个映射表中的一条记录的类的对象
Connection conn = null;
try{
QueryRunner queryRunner = new QueryRunner();
conn= JdbcUtils.getConnection3();
String sql="select id,email,birth from customers where id=?";
BeanHandler<Customers> handler = new BeanHandler<> (Customers.class);
Customers customers= queryRunner.query(conn,sql,handler,23);
System.out.println(customers);
} catch (Exception exception) {
exception.printStackTrace();
}finally {
JdbcUtils.closeResource(conn,null);
}
}
public void testQuery2(){
//BeanListHandler:是ResultSetHandler接口的实现类，用于封装表中的多条记录构成的集合
Connection conn = null;
try{
QueryRunner queryRunner = new QueryRunner();
conn= JdbcUtils.getConnection3();
String sql="select id,name,email,birth from customers where id<?";
BeanListHandler<Customers> handler = new BeanListHandler<>(Customers.class) ;
List<Customers> customersList= queryRunner.query(conn,sql,handler,23);
customersList.forEach(System.out::println);
} catch (Exception exception) {
exception.printStackTrace();
}finally {
JdbcUtils.closeResource(conn,null);
}
}
/*
* MapHander:是ResultSetHandler接口的实现类，对应表中的一条记录。
* 将字段及相应字段的值作为map中的key和value
*/
public void testQuery3(){
//MapHandler用于封装表中的一条记录
//将字段和字段的值封装成map的key和value
Connection conn = null;
try{
QueryRunner queryRunner = new QueryRunner();
conn= JdbcUtils.getConnection3();
String sql="select id,name,email,birth from customers where id=?";
MapHandler handler=new MapHandler();
Map<String, Object> map = queryRunner.query(conn,sql,handler,23);
System.out.println(map);
} catch (Exception exception) {
exception.printStackTrace();
}finally {
JdbcUtils.closeResource(conn,null);
}
}
/*
* MapListHander:是ResultSetHandler接口的实现类，对应表中的多条记录。
* 将字段及相应字段的值作为map中的key和value。将这些map添加到List中
*/
@Test
public void testQuery4(){
Connection conn = null;
try {
QueryRunner runner = new QueryRunner();
conn = JDBCUtils.getConnection3();
String sql = "select id,name,email,birth from customers where id < ?";
MapListHandler handler = new MapListHandler();
List<Map<String, Object>> list = runner.query(conn, sql, handler, 23);
list.forEach(System.out::println);
} catch (SQLException e) {
e.printStackTrace();
}finally{
JDBCUtils.closeResource(conn, null);
}
}
/*
* ScalarHandler:用于查询特殊值
*/
@Test
public void testQuery5(){
Connection conn = null;
try {
QueryRunner runner = new QueryRunner();
conn = JDBCUtils.getConnection3();
String sql = "select count(*) from customers";
ScalarHandler handler = new ScalarHandler();
//ScalarHandler<Long> handler=new ScalarHandler<>();
//用泛型就不用强转
Long count = (Long) runner.query(conn, sql, handler);
System.out.println(count);
} catch (SQLException e) {
e.printStackTrace();
}finally{
JDBCUtils.closeResource(conn, null);
}
}
public void testQuery6(){
Connection conn = null;
try {
QueryRunner runner = new QueryRunner();
conn = JDBCUtils.getConnection3();
String sql = "select max(birth) from customers";
ScalarHandler handler = new ScalarHandler();
Date maxBirth = (Date) runner.query(conn, sql, handler);
System.out.println(maxBirth);
} catch (SQLException e) {
e.printStackTrace();
}finally{
JDBCUtils.closeResource(conn, null);
}
}
/*
* 自定义ResultSetHandler的实现类
*/
public void testQuery7(){
Connection conn = null;
try{
QueryRunner queryRunner = new QueryRunner();
conn= JdbcUtils.getConnection3();
String sql="select id,name,email,birth from customers where id=?";
ResultSetHandler<Customers> handler=new ResultSetHandler<Customers>() {
@Override
public Customers handle(ResultSet resultSet) throws SQLException {
if(resultSet.next()){
int id=resultSet.getInt("id");
String name=resultSet.getString("name");
String email = resultSet.getString("email");
Date birth = resultSet.getDate("birth");
return new Customers(id,name,email,birth);
}
return null;
}
};
Customers customers = queryRunner.query(conn,sql,handler,23);
System.out.println(customers);
} catch (Exception exception) {
exception.printStackTrace();
}finally {
JdbcUtils.closeResource(conn,null);
}
}
使用dbutils.jar包中的DbUtils工具类实现连接等资源的关闭：
public static void closeResource1(Connection connection, Statement ps, ResultSet rs) {
/*
try {
DbUtils.close(connection);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
try {
DbUtils.close(ps);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
try {
DbUtils.close(rs);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
*/
DbUtils.closeQuietly(connection);
DbUtils.closeQuietly(ps);
DbUtils.closeQuietly(rs);
}