JDBC核心技术 - 下篇
2024-07-03 09:14:18
文章目录
- 6.数据库事务
- 6.1 数据库事务介绍
- 6.2 JDBC事务处理
- 6.3 事务的ACID属性
- 6.3.1 数据库的并发问题
- 6.3.2 四种隔离级别
- 6.3.3 在MySql中设置隔离级别
- 7.DAO及相关实现类
- 7.1 BaseDao.java
- 7.2 Customer.java
- 7.3 CustomerDAO.java
- 7.4 CustomerDAOImpl.java
- 7.5 CustomerDAOImplTest.java
- 8.数据库连接池
- 8.1 JDBC数据库连接池的必要性
- 8.2 数据库连接池技术
- 8.3 多种开源的数据库连接池
- 8.3.1 C3P0数据库连接池
- 8.3.2 DBCP数据库连接池
- 8.3.3 Druid（德鲁伊）数据库连接池
- 9.Apache-DBUtils实现CRUD操作
- 9.1 Apache-DBUtils简介
- 9.2 主要API的使用
- 9.2.1 DBUtils
- 9.2.2 QueryRunner类
- JDBC总结
6.数据库事务
6.1 数据库事务介绍
- 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
- 事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务**回滚(rollback)**到最初状态。
- 为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。
6.2 JDBC事务处理
- 数据一旦提交，就不可回滚。
- 数据什么时候意味着提交？
- 当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
- **关闭数据库连接，数据就会自动的提交。**如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
- JDBC程序中为了让多个 SQL 语句作为一个事务执行：
- 调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
- 在所有的 SQL 语句都成功执行后，调用 commit( ); 方法提交事务
- 在出现异常时，调用 rollback( ); 方法回滚事务
若此时 Connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态 setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close( )方法前，建议恢复自动提交状态。
/*** 1.什么叫数据库事务?* 事务:一组逻辑操作单元,使数据从一种状态变换到另一种状态。* > 一组逻辑操作单元:一个或多个DML操作。** 2.事务处理的原则:保证所有事务都作为一个工作单元来执行,即使出现了故障,都不能改变这种执行方式。* 当在一个事务中执行多个操作时,要么所有的事务都被提交(commit),那么这些修改就永久地保存* 下来;要么数据库管理系统将放弃所作的所有修改,整个事务回滚(rollback)到最初状态。** 3.数据一旦提交,就不可回滚** 4.哪些操作会导致数据的自动提交？* >DDL操作一旦执行,都会自动提交。* >set autocommit = false 对DDL操作失效* >DML默认情况下,一旦执行,就会自动提交。* >我们可以通过set autocommit = false的方式取消DML操作的自动提交。* >默认在关闭连接时,会自动的提交数据* @author xiexu* @create 2020-12-03 10:21 上午*/
public class TransactionTest {/** 未考虑数据库事务情况下的转账操作 针对于数据表user_table来说:* AA用户给BB用户转账100** update user_table set balance = balance - 100 where user = 'AA';* update user_table set balance = balance + 100 where user = 'BB';*/@Testpublic void testUpdate() {String sql = "update user_table set balance = balance - 100 where user = ?";update(sql, "AA");// 模拟网络异常
// System.out.println(10 / 0);String sql2 = "update user_table set balance = balance + 100 where user = ?";update(sql2, "BB");System.out.println("转账成功!");}//通用的增删改操作public int update(String sql, Object... args) {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.执行操作return ps.executeUpdate();} catch (Exception e) {e.printStackTrace();} finally {//5.关闭资源JDBCUtils.closeResource(conn, ps);}return 0;}//-------------考虑数据库事务后的转账操作---------------通用的增删改操作(考虑事务)public int update(Connection conn,String sql, Object... args) {PreparedStatement ps = null;try {// 2.预编译sql语句,返回PreparedStatement的实例ps = conn.prepareStatement(sql);// 3.填充占位符for (int i = 0; i < args.length; i++) {ps.setObject(i + 1, args[i]);}// 4.执行return ps.executeUpdate();} catch (Exception e) {e.printStackTrace();} finally {// 5.关闭资源JDBCUtils.closeResource(null, ps);}return 0;}@Testpublic void testUpdateWithTx() {Connection conn = null;try {conn = JDBCUtils.getConnection();System.out.println(conn.getAutoCommit()); //true//1.取消数据的自动提交conn.setAutoCommit(false);String sql = "update user_table set balance = balance - 100 where user = ?";update(conn,sql, "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 e2) {e2.printStackTrace();}}finally{//执行close()方法前，建议恢复自动提交状态try {conn.setAutoCommit(true);} catch (SQLException throwables) {throwables.printStackTrace();}//关闭资源JDBCUtils.closeResource(conn, null);}}}
6.3 事务的ACID属性
- 原子性（Atomicity）
- 原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
- 一致性（Consistency）
- 事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
- 隔离性（Isolation）
- 事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
- 持久性（Durability）
- 持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。
6.3.1 数据库的并发问题
- 对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
- 脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
- 不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
- 幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
- 数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
- 一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
6.3.2 四种隔离级别
- 数据库提供的4种事务隔离级别：
- Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE。 Oracle 默认的事务隔离级别为: READ COMMITED 。
- Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: REPEATABLE READ。
6.3.3 在MySql中设置隔离级别
- 每启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx_isolation, 表示当前的事务隔离级别。
- 查看当前的隔离级别:
SELECT @@tx_isolation;
- 设置当前 mySQL 连接的隔离级别:
set transaction isolation level read committed;
- 设置数据库系统的全局的隔离级别:
set global transaction isolation level read committed;
补充操作：
创建mysql数据库用户：
create user tom identified by 'abc123';
授予权限
#授予通过网络方式登录的tom用户，对所有库所有表的全部权限，密码设为abc123.
grant all privileges on *.* to tom@'%' identified by 'abc123'; #给tom用户使用本地命令行方式，授予atguigudb这个库下的所有表的插删改查的权限。
grant select,insert,update,delete on test.* to tom@localhost identified by 'abc123';
在Java代码中演示数据库的隔离级别
- User类
public class User {private String user;private String password;private int balance;public User() {super();}public User(String user, String password, int balance) {super();this.user = user;this.password = password;this.balance = balance;}@Overridepublic String toString() {return "User [user=" + user + ", password=" + password + ", balance=" + balance + "]";}public String getUser() {return user;}public void setUser(String user) {this.user = user;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public int getBalance() {return balance;}public void setBalance(int balance) {this.balance = balance;}
}
- 测试类
public class TransactionTest {//-------------考虑数据库事务后的转账操作---------------//通用的增删改操作(考虑事务)public int update(Connection conn,String sql, Object... args) {PreparedStatement ps = null;try {// 2.预编译sql语句,返回PreparedStatement的实例ps = conn.prepareStatement(sql);// 3.填充占位符for (int i = 0; i < args.length; i++) {ps.setObject(i + 1, args[i]);}// 4.执行return ps.executeUpdate();} catch (Exception e) {e.printStackTrace();} finally {// 5.关闭资源JDBCUtils.closeResource(null, ps);}return 0;}@Testpublic void testTransactionSelect() throws Exception{Connection conn = JDBCUtils.getConnection();//获取当前连接的隔离级别System.out.println(conn.getTransactionIsolation());//设置数据库的隔离级别：conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);//取消自动提交数据conn.setAutoCommit(false);String sql = "select user,password,balance from user_table where user = ?";User user = getInstance(conn, User.class, sql, "CC");System.out.println(user);}@Testpublic void testTransactionUpdate() throws Exception{Connection conn = JDBCUtils.getConnection();//取消自动提交数据conn.setAutoCommit(false);String sql = "update user_table set balance = ? where user = ?";update(conn, sql, 5000,"CC");Thread.sleep(10000);conn.commit();System.out.println("修改结束");}//通用的查询操作,用于返回数据表中的一条记录(考虑事务)public <T> T getInstance(Connection conn,Class<T> clazz, String sql, Object... args) {PreparedStatement ps = null;ResultSet rs = 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.执行，并返回结果集rs = ps.executeQuery();//5.获取结果集的元数据ResultSetMetaData rsmd = rs.getMetaData();//通过ResultSetMetaData获取结果集中的列数int columnCount = rsmd.getColumnCount();//处理结果集if (rs.next()) { //next( ):判断结果集的下一条是否有数据，如果有数据则返回true，并且指针下移；如果没有数据则返回false，并且指针不会下移T t = clazz.newInstance();//处理结果集一行数据的每一个列：给t对象指定的属性赋值for (int i = 0; i < columnCount; i++) {//获取每个列值:通过ResultSetObject value = rs.getObject(i + 1);//获取列的别名:通过ResultSetMetaData的getColumnLabel()String columnLabel = rsmd.getColumnLabel(i + 1);//通过反射,给t对象指定的columnLabel属性，赋值为valueField field = clazz.getDeclaredField(columnLabel);field.setAccessible(true);field.set(t, value);}return t;}} catch (Exception e) {e.printStackTrace();} finally {//关闭资源JDBCUtils.closeResource(null, ps, rs);}return null;}}
7.DAO及相关实现类
- DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
- 作用：为了实现功能的模块化，更有利于代码的维护和升级。
- 下面是DAO使用的体现：
7.1 BaseDao.java
/*** 封装了针对于数据表的通用的操作** @author xiexu* @create 2020-12-03 3:37 下午*/
public abstract class BaseDao {//通用的增删改操作(考虑事务)public int update(Connection conn, String sql, Object... args) {PreparedStatement ps = null;try {// 2.预编译sql语句,返回PreparedStatement的实例ps = conn.prepareStatement(sql);// 3.填充占位符for (int i = 0; i < args.length; i++) {ps.setObject(i + 1, args[i]);}// 4.执行return ps.executeUpdate();} catch (Exception e) {e.printStackTrace();} finally {// 5.关闭资源JDBCUtils.closeResource(null, ps);}return 0;}//通用的查询操作,用于返回数据表中的一条记录(考虑事务)public <T> T getInstance(Connection conn, Class<T> clazz, String sql, Object... args) {PreparedStatement ps = null;ResultSet rs = 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.执行，并返回结果集rs = ps.executeQuery();//5.获取结果集的元数据ResultSetMetaData rsmd = rs.getMetaData();//通过ResultSetMetaData获取结果集中的列数int columnCount = rsmd.getColumnCount();//处理结果集if (rs.next()) { //next( ):判断结果集的下一条是否有数据，如果有数据则返回true，并且指针下移；如果没有数据则返回false，并且指针不会下移T t = clazz.newInstance();//处理结果集一行数据的每一个列：给t对象指定的属性赋值for (int i = 0; i < columnCount; i++) {//获取每个列值:通过ResultSetObject value = rs.getObject(i + 1);//获取列的别名:通过ResultSetMetaData的getColumnLabel()String columnLabel = rsmd.getColumnLabel(i + 1);//通过反射,给t对象指定的columnLabel属性，赋值为valueField field = clazz.getDeclaredField(columnLabel);field.setAccessible(true);field.set(t, value);}return t;}} catch (Exception e) {e.printStackTrace();} finally {//关闭资源JDBCUtils.closeResource(null, ps, rs);}return null;}//通用的查询操作,用于返回数据表中的多条记录构成的集合(考虑事务)public <T> List<T> getForList(Connection conn, Class<T> clazz, String sql, Object... args) {PreparedStatement ps = null;ResultSet rs = 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.执行，并返回结果集rs = ps.executeQuery();//5.获取结果集的元数据ResultSetMetaData rsmd = rs.getMetaData();//通过ResultSetMetaData获取结果集中的列数int columnCount = rsmd.getColumnCount();//创建集合对象ArrayList<T> list = new ArrayList<>();//处理结果集while (rs.next()) { //next( ):判断结果集的下一条是否有数据，如果有数据则返回true，并且指针下移；如果没有数据则返回false，并且指针不会下移T t = clazz.newInstance();//循环处理结果集中每一行数据的每一个列：给t对象指定的属性赋值for (int i = 0; i < columnCount; i++) {//获取每个列值:通过ResultSetObject value = rs.getObject(i + 1);//获取列的别名:通过ResultSetMetaData的getColumnLabel()String columnLabel = rsmd.getColumnLabel(i + 1);//通过反射,给t对象指定的columnLabel属性，赋值为valueField field = clazz.getDeclaredField(columnLabel);field.setAccessible(true);field.set(t, value);}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);}return null;} catch (SQLException e) {e.printStackTrace();} finally {JDBCUtils.closeResource(null, ps, rs);}return null;}}
7.2 Customer.java
/** ORM编程思想 (object relational mapping)* 一个数据表对应一个java类* 表中的一条记录对应java类的一个对象* 表中的一个字段对应java类的一个属性*/
public class Customer {private int id;private String name;private String email;private Date birth;public Customer() {}public Customer(int id, String name, String email, Date birth) {super();this.id = id;this.name = name;this.email = email;this.birth = birth;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public Date getBirth() {return birth;}public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {return "Customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";}
}
7.3 CustomerDAO.java
/*** 此接口用于规范针对于customers表的常用操作* @author xiexu* @create 2020-12-03 3:49 下午*/
public interface CustomerDao {//将cust对象添加到数据库中void insert(Connection conn, Customer cust);//针对指定的id,删除表中的一条记录void deleteById(Connection conn,int id);//针对内存中的cust对象,去修改数据表中指定的记录void update(Connection conn,Customer cust);//针对指定的id查询得到对应的Customer对象Customer getCustomerById(Connection conn,int id);//查询表中的所有记录构成的集合List<Customer> getAll(Connection conn);//返回数据表中的数据的条目数Long getCount(Connection conn);//返回数据表中最大的生日Date getMaxBirth(Connection conn);}
7.4 CustomerDAOImpl.java
public class CustomerDAOImpl extends BaseDao implements CustomerDao {@Overridepublic void insert(Connection conn, Customer cust) {String sql = "insert into customers(name,email,birth)values(?,?,?)";update(conn, sql, cust.getName(), cust.getEmail(), cust.getBirth());}@Overridepublic void deleteById(Connection conn, int id) {String sql = "delete from customers where id = ?";update(conn, sql, id);}@Overridepublic 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());}@Overridepublic Customer getCustomerById(Connection conn, int id) {String sql = "select id,name,email,birth from customers where id = ?";Customer customer = getInstance(conn, Customer.class, sql, id);return customer;}@Overridepublic List<Customer> getAll(Connection conn) {String sql = "select id,name,email,birth from customers";List<Customer> list = getForList(conn, Customer.class, sql);return list;}@Overridepublic Long getCount(Connection conn) {String sql = "select count(*) from customers";return getValue(conn, sql);}@Overridepublic Date getMaxBirth(Connection conn) {String sql = "select max(birth) from customers";return getValue(conn, sql);}
}
7.5 CustomerDAOImplTest.java
/*** @author xiexu* @create 2020-12-03 4:08 下午*/
public class CustomerDAOImplTest {private CustomerDAOImpl dao = new CustomerDAOImpl();@Testpublic void testInsert() {Connection conn = null;try {conn = JDBCUtils.getConnection();Customer cust = new Customer(1, "马里奥", "maliao@126.com", new Date(43534646435L));dao.insert(conn, cust);System.out.println("添加成功!");} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}@Testpublic void testDeleteById() {Connection conn = null;try {conn = JDBCUtils.getConnection();dao.deleteById(conn, 13);System.out.println("删除成功!");} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}@Testpublic void testUpdateConnectionCustomer() {Connection conn = null;try {conn = JDBCUtils.getConnection();Customer cust = new Customer(18, "火金", "huojin@126.com", new Date(453465656L));dao.update(conn, cust);System.out.println("修改成功!");} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}@Testpublic void testGetCustomerById() {Connection conn = null;try {conn = JDBCUtils.getConnection();Customer cust = dao.getCustomerById(conn, 19);System.out.println(cust);} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}@Testpublic void testGetAll() {Connection conn = null;try {conn = JDBCUtils.getConnection();List<Customer> list = dao.getAll(conn);list.forEach(System.out::println);System.out.println("");} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}@Testpublic void testGetCount() {Connection conn = null;try {conn = JDBCUtils.getConnection();Long count = dao.getCount(conn);System.out.println("表中的记录数为:" + count);} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}@Testpublic void testGetMaxBirth() {Connection conn = null;try {conn = JDBCUtils.getConnection();Date maxBirth = dao.getMaxBirth(conn);System.out.println("最大的生日为:" + maxBirth);} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}
}
8.数据库连接池
8.1 JDBC数据库连接池的必要性
- 在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：
- 在主程序（如servlet、beans）中建立数据库连接
- 进行sql操作
- 断开数据库连接
- 这种模式开发，存在的问题：
- 普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection 加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
- 对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。（回忆：何为Java的内存泄漏？）
- 这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。
8.2 数据库连接池技术
- 为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。
- 数据库连接池的基本思想：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
- 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
- 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
- 工作原理：
数据库连接池技术的优点
- 资源重用
- 由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
- 更快的系统反应速度
- 数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间
- 新的资源分配手段
- 对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源
- 统一的连接管理，避免数据库连接泄漏
- 在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露
8.3 多种开源的数据库连接池
- JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：
- DBCP 是Apache提供的数据库连接池。tomcat 服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。
- C3P0 是一个开源组织提供的一个数据库连接池，**速度相对较慢，稳定性还可以。**hibernate官方推荐使用
- Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
- BoneCP 是一个开源组织提供的数据库连接池，速度快
- Druid 是阿里提供的数据库连接池，据说是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池，但是速度不确定是否有BoneCP快
- DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池
- DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。
- 特别注意：
- 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
- 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close( ); 但conn.close( )并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。
8.3.1 C3P0数据库连接池
获取连接方式一
/*** @author xiexu* @create 2020-12-04 9:04 上午*/
public class C3P0Test {@Testpublic void testGetConnection() throws Exception{// 获取c3p0数据库连接池ComboPooledDataSource cpds = new ComboPooledDataSource();cpds.setDriverClass("com.mysql.jdbc.Driver");cpds.setJdbcUrl("jdbc:mysql://localhost:3306/test");cpds.setUser("root");cpds.setPassword("283619");// 通过设置相关的参数,对数据库连接池进行管理：// 设置初始时数据库连接池中的连接数cpds.setInitialPoolSize(10);Connection conn = cpds.getConnection();System.out.println(conn);// 销毁c3p0数据库连接池// DataSources.destroy( cpds );}
}
获取连接方式二
// 方式二:使用配置文件@Testpublic void testGetConnection2() throws Exception {ComboPooledDataSource cpds = new ComboPooledDataSource("helloc3p0");Connection conn = cpds.getConnection();System.out.println(conn);}
- resources目录下的配置文件：c3p0-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config><named-config name="helloc3p0"><!-- 获取连接的4个基本信息 --><property name="user">root</property><property name="password">283619</property><property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property><property name="driverClass">com.mysql.jdbc.Driver</property><!-- 进行数据库连接池管理的基本信息 --><!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 --><property name="acquireIncrement">5</property><!-- 初始化数据库连接池时连接的数量 --><property name="initialPoolSize">5</property><!-- 数据库连接池中的最小的数据库连接数 --><property name="minPoolSize">5</property><!-- 数据库连接池中的最大的数据库连接数 --><property name="maxPoolSize">10</property><!-- C3P0 数据库连接池可以维护的 Statement 的个数 --><property name="maxStatements">20</property><!-- 每个连接同时可以使用的 Statement 对象的个数 --><property name="maxStatementsPerConnection">5</property></named-config>
</c3p0-config>
8.3.2 DBCP数据库连接池
- DBCP 是 Apache 软件基金组织下的开源连接池实现，该连接池依赖该组织下的另一个开源系统：Common-pool。如需使用该连接池实现，应在系统中增加如下两个 jar 文件：
- Commons-dbcp.jar：连接池的实现
- Commons-pool.jar：连接池实现的依赖库
- **Tomcat 的连接池正是采用该连接池来实现的。**该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。
- 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
- 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但上面的代码并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。
- 配置属性说明
| 属性 | 默认值 | 说明 |
|---|---|---|
| initialSize | 0 | 连接池启动时创建的初始化连接数量 |
| maxActive | 8 | 连接池中可同时连接的最大的连接数 |
| maxIdle | 8 | 连接池中最大的空闲的连接数，超过的空闲连接将被释放，如果设置为负数表示不限制 |
| minIdle | 0 | 连接池中最小的空闲的连接数，低于这个数量会被创建新的连接。该参数越接近maxIdle，性能越好，因为连接的创建和销毁，都是需要消耗资源的；但是不能太大。 |
| maxWait | 无限制 | 最大等待时间，当没有可用连接时，连接池等待连接释放的最大时间，超过该时间限制会抛出异常，如果设置-1表示无限等待 |
| poolPreparedStatements | false | 开启池的Statement是否prepared |
| maxOpenPreparedStatements | 无限制 | 开启池的prepared 后的同时最大连接数 |
| minEvictableIdleTimeMillis | 连接池中连接，在时间段内一直空闲， 被逐出连接池的时间 | |
| removeAbandonedTimeout | 300 | 超过时间限制，回收没有用(废弃)的连接 |
| removeAbandoned | false | 超过removeAbandonedTimeout时间后，是否进 行没用连接（废弃）的回收 |
获取连接方式一
/*** @author xiexu* @create 2020-12-04 9:32 上午*/
public class DBCPTest {/*** 测试DBCP的数据库连接池技术* 方式一:不推荐* @throws Exception*/@Testpublic void testGetConnection() throws Exception {// 创建了DBCP的数据库连接池BasicDataSource source = new BasicDataSource();// 设置基本信息source.setDriverClassName("com.mysql.jdbc.Driver");source.setUrl("jdbc:mysql://localhost:3306/test");source.setUsername("root");source.setPassword("283619");// 还可以设置其他涉及数据库连接池管理的相关属性:source.setInitialSize(10);Connection conn = source.getConnection();System.out.println(conn);}
}
获取连接方式二
//方式二：使用配置文件@Testpublic void testGetConnection2() throws Exception{Properties pros = new Properties();// 方式1:// InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("dbcp.properties");// 方式2:FileInputStream is = new FileInputStream(new File("src/main/resources/dbcp.properties"));pros.load(is);BasicDataSource source = BasicDataSourceFactory.createDataSource(pros);Connection conn = source.getConnection();System.out.println(conn);}
- resources目录下的配置文件：dbcp.properties
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=283619initialSize=10
8.3.3 Druid（德鲁伊）数据库连接池
Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的连接池之一。
/*** @author xiexu* @create 2020-12-04 10:50 上午*/
public class DruidTest {@Testpublic void getConnection() throws Exception{Properties pros = new Properties();InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");pros.load(is);DataSource source = DruidDataSourceFactory.createDataSource(pros);Connection conn = source.getConnection();System.out.println(conn);}}
- resources目录下的配置文件：druid.properties
url=jdbc:mysql://localhost:3306/test
username=root
password=283619
driverClassName=com.mysql.jdbc.DriverinitialSize=10
maxActive=10
- 详细配置参数：
| 配置 | 缺省 | 说明 |
|---|---|---|
| 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，是组合关系，并非替换关系 |
9.Apache-DBUtils实现CRUD操作
9.1 Apache-DBUtils简介
- commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。
- API介绍：
- org.apache.commons.dbutils.QueryRunner
- org.apache.commons.dbutils.ResultSetHandler
- 工具类：org.apache.commons.dbutils.DbUtils
- API包说明：
9.2 主要API的使用
9.2.1 DBUtils
DbUtils ：提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：
- public static void close(…) throws java.sql.SQLException： DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和ResultSet。
- public static void closeQuietly(…): 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
- public static void commitAndClose(Connection conn)throws SQLException： 用来提交连接的事务，然后关闭连接
- public static void commitAndCloseQuietly(Connection conn)： 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。
- public static void rollback(Connection conn)throws SQLException：允许conn为null，因为方法内部做了判断
- public static void rollbackAndClose(Connection conn)throws SQLException
- rollbackAndCloseQuietly(Connection)
- public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。
9.2.2 QueryRunner类
该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
QueryRunner类提供了两个构造器：
- 默认的构造器
- 需要一个 javax.sql.DataSource 来作参数的构造器
QueryRunner类的主要方法：
- 更新
- public int update(Connection conn, String sql, Object… params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
- …
- 插入
- public T insert(Connection conn,String sql,ResultSetHandler rsh, Object… params) throws SQLException：只支持INSERT语句，其中 rsh - The handler used to create the result object from the ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自动生成的键值
- …
- 批处理
- public int[ ] batch(Connection conn,String sql,Object[][] params)throws SQLException： INSERT, UPDATE, or DELETE语句
- public T insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object[][] params)throws SQLException：只支持INSERT语句
- …
- 查询
- public Object query(Connection conn, String sql, ResultSetHandler rsh,Object… params) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。
- …
代码测试
- JDBCUtils类
/*** 操作数据库的工具类** @author xiexu* @create 2020-11-30 10:58 下午*/
public class JDBCUtils {/*** 使用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;}/**** @Description 使用dbutils.jar中提供的DbUtils工具类，实现资源的关闭* @param conn* @param ps* @param rs*/public static void closeResource1(Connection conn,Statement ps,ResultSet rs){// try {// DbUtils.close(conn);
// } catch (SQLException e) {// e.printStackTrace();
// }
// try {// DbUtils.close(ps);
// } catch (SQLException e) {// e.printStackTrace();
// }
// try {// DbUtils.close(rs);
// } catch (SQLException e) {// e.printStackTrace();
// }DbUtils.closeQuietly(conn);DbUtils.closeQuietly(ps);DbUtils.closeQuietly(rs);}}
- 测试类
//commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,封装了针对于数据库的增删改查操作
public class QueryRunnerTest {//测试插入@Testpublic void testInsert() {Connection conn = null;try {QueryRunner runner = new QueryRunner();conn = JDBCUtils.getConnection3();String sql = "insert into customers(name,email,birth)values(?,?,?)";int insertCount = runner.update(conn, sql, "蔡徐坤", "liming@163.com", "1998-07-08");System.out.println("添加了" + insertCount + "条记录");} catch (SQLException e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}//测试查询/** BeanHander:是ResultSetHandler接口的实现类，用于封装表中的一条记录。*/@Testpublic void testQuery1(){Connection conn = null;try {QueryRunner runner = new QueryRunner();conn = JDBCUtils.getConnection3();String sql = "select id,name,email,birth from customers where id = ?";BeanHandler<Customer> handler = new BeanHandler<>(Customer.class);Customer customer = runner.query(conn, sql, handler, 23);System.out.println(customer);} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{JDBCUtils.closeResource(conn, null);}}// BeanListHandler:是ResultSetHandler接口的实现类,用于封装表中的多条记录构成的集合。@Testpublic void QueryTest2() {Connection conn = null;try {QueryRunner runner = new QueryRunner();conn = JDBCUtils.getConnection3();String sql = "select id,name,email,birth from customers where id < ?";BeanListHandler<Customer> handler = new BeanListHandler<>(Customer.class);List<Customer> list = runner.query(conn, sql, handler, 25);list.forEach(System.out::println);} catch (SQLException e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}// MapHander:是ResultSetHandler接口的实现类，对应表中的一条记录。// 将字段及相应字段的值作为map中的key和value@Testpublic void QueryTest3() {Connection conn = null;try {QueryRunner runner = new QueryRunner();conn = JDBCUtils.getConnection3();String sql = "select id,name,email,birth from customers where id = ?";MapHandler handler = new MapHandler();Map<String, Object> map = runner.query(conn, sql, handler, 20);System.out.println(map);} catch (SQLException e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}// MapListHander:是ResultSetHandler接口的实现类,对应表中的多条记录。// 将字段及相应字段的值作为map中的key和value。将这些map添加到List中@Testpublic void QueryTest4() {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:用于查询特殊值@Testpublic void QueryTest5() {Connection conn = null;try {QueryRunner runner = new QueryRunner();conn = JDBCUtils.getConnection3();String sql = "select count(*) from customers";ScalarHandler 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);}}@Testpublic void QueryTest6() {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的实现类@Testpublic void QueryTest7() {Connection conn = null;try {QueryRunner runner = new QueryRunner();conn = JDBCUtils.getConnection3();String sql = "select id,name,email,birth from customers where id = ?";ResultSetHandler<Customer> handler = new ResultSetHandler<Customer>() {@Overridepublic Customer handle(ResultSet rs) throws SQLException {// System.out.println("handle");// return null;// return new Customer(12, "勾芒", "goumang@163.com", new// Date(234324234324L));if (rs.next()) {int id = rs.getInt("id");String name = rs.getString("name");String email = rs.getString("email");Date birth = rs.getDate("birth");Customer customer = new Customer(id, name, email, birth);return customer;}return null;}};Customer customer = runner.query(conn, sql, handler, 20);System.out.println(customer);} catch (SQLException e) {e.printStackTrace();} finally {JDBCUtils.closeResource(conn, null);}}}
JDBC总结
总结
@Test
public void testUpdateWithTx() {Connection conn = null;try {//1.获取连接的操作（//① 手写的连接：JDBCUtils.getConnection();//② 使用数据库连接池：C3P0;DBCP;Druid//2.对数据表进行一系列CRUD操作//① 使用PreparedStatement实现通用的增删改、查询操作（version 1.0 \ version 2.0)
//version2.0的增删改public void update(Connection conn,String sql,Object ... args){}
//version2.0的查询 public <T> T getInstance(Connection conn,Class<T> clazz,String sql,Object ... args){}//② 使用dbutils提供的jar包中提供的QueryRunner类//提交数据conn.commit(); } catch (Exception e) {e.printStackTrace();try {//回滚数据conn.rollback();} catch (SQLException e1) {e1.printStackTrace();}}finally{//3.关闭连接等操作//① JDBCUtils.closeResource();//② 使用dbutils提供的jar包中提供的DbUtils类提供了关闭的相关操作 }
}
JDBC核心技术 - 下篇相关推荐
- 深入浅出JDBC核心技术
文章目录 JDBC核心技术--课程笔记 第1章:JDBC概述 1.1 数据的持久化 1.2 Java中的数据存储技术 1.3 JDBC介绍 1.4 JDBC体系结构 1.5 JDBC程序编写步骤 第2 ...
- JDBC核心技术六（数据库连接池）
系列笔记目录 JDBC核心技术一(概述) JDBC核心技术二(获取数据库连接) JDBC核心技术三(PreparedStatement) JDBC核心技术四(Blob字段和批量插入) JDBC核心技术 ...
- JDBC核心技术学习
JDBC核心技术 作者:kuikui 文章目录 JDBC核心技术 第1章:JDBC概述 1.1 数据的持久化 1.2 Java中的数据存储技术 1.3 JDBC介绍 1.4 JDBC体系结构 1.5 ...
- JDBC核心技术(下)
文章目录 JDBC核心技术 第6章: 数据库事务 6.1 数据库事务介绍 6.2 JDBC事务处理 6.3 事务的ACID属性 6.3.1 数据库的并发问题 6.3.2 四种隔离级别 6.3.3 在M ...
- Java，JDBC核心技术，线程池，事务
文章目录 JDBC核心技术 一.概述 1. 数据的持久化 2. Java中的数据存储技术 3. JDBC介绍 4. JDBC体系结构 5. JDBC程序编写步骤 二.获取数据库连接 三.Prepare ...
- Java基础篇：JDBC核心技术
文章目录 第1章:JDBC概述 1.1 数据的持久化 1.2 JDBC介绍 1.3 JDBC程序编写步骤 第2章:获取数据库连接 2.1 要素一:Driver接口实现类 2.1.1 Driver接口介 ...
- 第25章 JDBC核心技术第3节
第3节:实现CRUD操作 3.1 操作和访问数据库 数据库连接被用于向数据库服务器发送命令和 SQL 语句,并接受数据库服务器返回的结果.其实一个数据库连接就是一个Socket连接. 在 java.s ...
- 【JDBC - 核心技术】01 JDBC概述
第01章 JDBC概述 创作日期:2021-12-05 1.1 数据的持久化 持久化(persistence):把数据保存到可掉电式存储设备中以供之后使用.大多数情况下,特别是企业级应用,数据持久化意 ...
- 第25章 JDBC核心技术第4节：操作BLOB类型字段
4.1 MySQL BLOB类型 MySQL中,BLOB是一个二进制大型对象,是一个可以存储大量数据的容器,它能容纳不同大小的数据. 插入BLOB类型的数据必须使用PreparedStatement, ...
最新文章
- js正则表达式的使用详解
- B站《一天学会 MySQL 数据库》学习笔记
- (转载)不一样的冒泡排序
- 常见宽带路由器配置及口令清除技巧
- linux显示存储与标定不符,找到了linux分区顺序错乱修复方法
- GDCM：CryptographicMessageSyntax的测试程序
- Vue——this.$nextTick()
- Excel中找出两列中相同的值
- Cloudera Manager安装之Cloudera Manager 5.3.X安装（三）（tar方式、rpm方式和yum方式）...
- CSDN如何上传文件
- 投影机拼接融合技术--UE4拼接
- Swift GYB 简易教程
- javascript数组
- Derek Sivers：我是一个慢思考者（译）
- KV杀毒软件创始人离世
- 线程池及其原理和使用
- z590和b550 哪个好
- xlsx文件的多表读取与写入
- 安全事件日志事件编号与描述
- 微信php背景音乐,微信公众平台添加背景音乐