修改时间:2021年1月21日
作者:pp_x
邮箱:pp_x12138@163.com
文章目录
数据库连接池
什么是数据库连接池
- 采用数据库连接池避免开发中频繁的创建连接和销毁链接过程,提高性能,数据库连接池可以共享连接,创建连接和释放连接交给了连接池
连接池的好处
- 用池来管理连接,可以重复使用连接对象,当使用完后,调用Connection的
close()
方法也不会真的关闭Connection,而是把Connection“归还”给池。
如何使用数据库连接池
- Java为数据库连接池提供了公共的接口:
javax.sql.DataSource
,各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池! - 常见的连接池有:DBCP连接池、C3P0连接池,Druid连接池
DBCP连接池
- DBCP是一个开源的连接池,是
Apache
成员之一,在企业开发中也比较常见,tomcat内置的连接池
需要用到的jar
编写工具类
- Java中提供了一个连接池的规则接口 :
DataSource
, 它是java中提供的连接池 - 在DBCP包中提供了
DataSource
接口的实现类,我们要用的具体的连接池BasicDataSource
类 - 代码示例
package com.lagou.utils;
import org.apache.commons.dbcp.BasicDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class DBCPUtils {
//1.定义常量 保存数据库连接的相关信息
public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
public static final String USERNAME = "root";
public static final String PASSWORD = "123456";
//2.创建连接池对象 (有DBCP提供的实现类)
public static BasicDataSource dataSource = new BasicDataSource();
//3.使用静态代码块进行配置
static{
dataSource.setDriverClassName(DRIVERNAME);
dataSource.setUrl(URL);
dataSource.setUsername(USERNAME);
dataSource.setPassword(PASSWORD);
dataSource.setMaxActive(20);
}
//4.获取连接的方法
public static Connection getConnection() throws SQLException {
//从连接池中获取连接
Connection connection = dataSource.getConnection();
return connection;
}
//5.释放资源方法
public static void close(Connection con, Statement statement){
if(con != null && statement != null){
try {
statement.close();
//归还连接
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet){
if(con != null && statement != null && resultSet != null){
try {
resultSet.close();
statement.close();
//归还连接
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
常见的配置项
C3P0连接池
- C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有
Hibernate
、Spring
等
需要的jar包
需要的配置文件
c3p0-config.xml
文件名不可更改- 文件内容示例
<c3p0-config>
<!--默认配置-->
<default-config>
<!-- initialPoolSize:初始化时获取三个连接,
取值应在minPoolSize与maxPoolSize之间。 -->
<property name="initialPoolSize">3</property>
<!-- maxIdleTime:最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
<property name="maxIdleTime">60</property>
<!-- maxPoolSize:连接池中保留的最大连接数 -->
<property name="maxPoolSize">100</property>
<!-- minPoolSize: 连接池中保留的最小连接数 -->
<property name="minPoolSize">10</property>
</default-config>
<!--配置连接池mysql-->
<named-config name="mysql">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
</named-config>
<!--配置连接池2,可以配置多个-->
</c3p0-config>
编写工具类
- C3P0提供的核心工具类,
ComboPooledDataSource
new ComboPooledDataSource();
使用 默认配置new ComboPooledDataSource("mysql");
使用命名配置- 代码示例
package com.lagou.utils;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class C3P0Utils {
//1.创建连接池对象 C3P0对DataSource接口的实现类
//使用的配置是 配置文件中的默认配置
//public static ComboPooledDataSource dataSource = new ComboPooledDataSource();
//使用指定的配置 创建对象
public static ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");
//获取连接的方法
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();
}
//释放资源
public static void close(Connection con, Statement statement){
if(con != null && statement != null){
try {
statement.close();
//归还连接
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet){
if(con != null && statement != null && resultSet != null){
try {
resultSet.close();
statement.close();
//归还连接
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
常见配置
Druid连接池
- Druid(德鲁伊)是阿里巴巴开发的号称为监控而生的数据库连接池,Druid是目前最好的数据库连接池。在功能、性能、扩展性方面,都超过其他数据库连接池,同时加入了日志监控,可以很好的监控DB池连接和SQL的执行情况。
需要的jar包
需要的配置文件
- 可以叫任意名称,可以放在任意目录下,是
properties
形式 - 配置文件示例
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
编写工具类
- 获取数据库连接池对象:通过
DruidDataSourceFactory
类的createDataSource
方法 createDataSource(Properties p)
方法参数可以是一个属性集对象- 代码示例
package com.lagou.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class DruidUtils {
//1.定义成员变量
public static DataSource dataSource;
//2.静态代码块
static{
try {
//3.创建属性集对象
Properties p = new Properties();
//4.加载配置文件 Druid 连接池不能够主动加载配置文件 ,需要指定文件
InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
//5. 使用Properties对象的 load方法 从字节流中读取配置信息
p.load(inputStream);
//6. 通过工厂类获取连接池对象
dataSource = DruidDataSourceFactory.createDataSource(p);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接的方法
public static Connection getConnection(){
try {
return dataSource.getConnection();
} catch (SQLException e) {
e.printStackTrace();
return null;
}
}
//获取Druid连接池对象的方法
public static DataSource getDataSource(){
return dataSource;
}
//释放资源
public static void close(Connection con, Statement statement){
if(con != null && statement != null){
try {
statement.close();
//归还连接
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet){
if(con != null && statement != null && resultSet != null){
try {
resultSet.close();
statement.close();
//归还连接
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
DBUtils工具类
DBUtils简介
- 使用JDBC我们发现冗余的代码太多了,为了简化开发 我们选择使用 DbUtils
Commons DbUtils
是Apache组织提供的一个对JDBC进行简单封装的开源工具类库,使用它能够简化JDBC应用程序的开发,同时也不会影响程序的性能。
需要的jar包
DBUtils核心功能
QueryRunner
中提供对sql语句操作的APIResultSetHandler
接口,用于定义select操作后,怎样封装结果集DbUtils
类,他就是一个工具类,定义了关闭资源与事务处理相关方法
QueryRunner核心类
- 构造方法
QueryRunner()
QueryRunner(DataSource ds)
,提供数据源(连接池),DBUtils底层自动维护连接connection
- 常用方法
update(Connection conn, String sql, Object... params)
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
QueryRunner的创建
- 手动模式
//手动方式 创建QueryRunner对象
QueryRunner qr = new QueryRunner();
- 自动模式
//自动创建 传入数据库连接池对象
QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());
QueryRunner实现增删改
update(Connection conn, String sql, Object... params)
Connection conn
:数据库连接对象, 自动模式创建QueryRun 可以不传 ,手动模式必须传递String sql
:占位符形式的SQL ,使用 ? 号占位符Object... param
:Object类型的 可变参,用来设置占位符上的参数
- 代码示例
package com.lagou.testDBUtils;
import com.lagou.utils.DBCPUtils;
import com.lagou.utils.DruidUtils;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;
import java.sql.Connection;
import java.sql.SQLException;
/*
* 使用QueryRunner对象 完成增删改
* update(Connection con,String sql,Object... param) 方法
*
* */
public class DBUtilsDemo02 {
//插入操作
@Test
public void testInsert() throws SQLException {
//1.创建 QueryRunner 手动模式创建
QueryRunner qr = new QueryRunner();
//2.编写 占位符方式 SQL
String sql = "insert into employee values(?,?,?,?,?,?)";
//3.设置占位符的参数
Object[] param = {null,"张百万",20,"女",10000,"1990-12-26"};
//4.执行 update方法
Connection con = DruidUtils.getConnection();
int i = qr.update(con, sql, param);
//5.释放资源
DbUtils.closeQuietly(con);
}
//修改操作 修改姓名为 张百万的员工的工资为 15000
@Test
public void testUpdate() throws SQLException {
//1.创建 核心类 自动模式 需要传递 数据库连接池对象
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
//2.编写SQl
String sql = "update employee set salary = ? where ename = ?";
//3.设置占位符的参数
Object[] param = {15000,"张百万"};
//4.执行修改操作 自动模式不需要传入connection对象
qr.update(sql,param);
}
//删除操作 删除id为1的 记录
@Test
public void testDelete() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "delete from employee where eid = ?";
//如果只有一个参数的话 不需要创建数组
qr.update(sql,1);
}
}
QueryRunner实现查询
ResultSetHandler接口简介
ResultSetHandler
可以对查询出来的ResultSet结果集进行处理
ResultSetHandler接口实现类
ResultSetHandler接口实现类 | 说明 |
---|---|
ArrayHandler | 将结果集中的第一条记录封装到Object[]数组中,数组中的每个元素就是这条记录的每一个字段的值 |
ArrayListHandler | 将结果集中的每一条记录都封装到一个Object[]数组中,将这些数组在封装到List集合中。 |
BeanHandler | 将结果集中第一条记录封装到一个指定的javaBean中. |
BeanListHandler | 将结果集中每一条记录封装到指定的javaBean中,再将这些javaBean在封装到List集合中 |
ColumnListHandler | 将结果集中指定的列的字段值,封装到一个List集合中 |
KeyedHandler | 将结果集中每一条记录封装到Map<String,Object>,在将这个map集合做为另一个Map的value,另一个Map集合的key是指定的字段的值。 |
MapHandler | 将结果集中第一条记录封装到了Map<String,Object>集合中,key就是字段名称,value就是字段值 |
MapListHandler | 将结果集中每一条记录封装到了Map<String,Object>集合中,key就是字段名称,value就是字段值,在将这些Map封装到List集合中。 |
ScalarHandler | 它是用于封装单个数据。例如 select count(*) from 表操作 |
QueryRunner的查询方法
- query方法的返回值都是泛型,具体的返回值类型,会根据结果集的处理方式,发生变化
- 代码示例
package com.lagou.testDBUtils;
import com.lagou.entity.Employee;
import com.lagou.utils.DruidUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class DBUtilsDemo03 {
/*
* 查询id为5的记录,封装到数组中
* ArrayHandler 将结果集的第一条数据封装到数组中
* */
@Test
public void testFindById() throws SQLException {
//1.创建QueryRunner
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
//2.编写SQL
String sql = "select * from employee where eid = ?";
//3.执行查询
Object[] query = qr.query(sql, new ArrayHandler(), 5);
//4.获取数据
System.out.println(Arrays.toString(query));
}
/**
* 查询所有数据,封装到List集合中
* ArrayListHandler可以将每条数据先封装到数组中, 再将数组封装到集合中
*
*/
@Test
public void testFindAll() throws SQLException {
//1.创建QueryRunner
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
//2.编写SQL
String sql = "select * from employee";
//3.执行查询
List<Object[]> query = qr.query(sql, new ArrayListHandler());
//4.遍历集合获取数据
for (Object[] objects : query) {
System.out.println(Arrays.toString(objects));
}
}
/**
* 查询id为3的记录,封装到指定JavaBean中
* BeanHandler 将结果集的第一条数据封装到 javaBean中
*
**/
@Test
public void testFindByIdJavaBean() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where eid = ?";
Employee employee = qr.query(sql, new BeanHandler<Employee>(Employee.class), 3);
System.out.println(employee);
}
/*
* 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
* BeanListHandler 将结果集的每一条和数据封装到 JavaBean中 再将JavaBean 放到list集合中
* */
@Test
public void testFindBySalary() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where salary > ?";
List<Employee> list = qr.query(sql, new BeanListHandler<Employee>(Employee.class), 3000);
for (Employee employee : list) {
System.out.println(employee);
}
}
/*
* 查询姓名是 张百万的员工信息,将结果封装到Map集合中
* MapHandler 将结果集的第一条记录封装到 Map<String,Object>中
* key对应的是 列名 value对应的是 列的值
* */
@Test
public void testFindByName() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select * from employee where ename = ?";
Map<String, Object> map = qr.query(sql, new MapHandler(), "李白 ");
Set<Map.Entry<String, Object>> entries = map.entrySet();
for (Map.Entry<String, Object> entry : entries) {
//打印结果
System.out.println(entry.getKey() +" = " +entry.getValue());
}
}
/*
* 查询所有员工的薪资总额
* ScalarHandler 用于封装单个的数据
* */
@Test
public void testGetSum() throws SQLException {
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
String sql = "select sum(salary) from employee";
Double sum = (Double)qr.query(sql, new ScalarHandler<>());
System.out.println("员工薪资总额: " + sum);
}
}
批处理
什么是批处理
- 批处理(batch) 操作数据库
- 批处理指的是一次操作中执行多条SQL语句,批处理相比于一次一次执行效率会提高很多。
- 当向数据库中添加大量的数据时,需要用到批处理。
实现批处理
Statement
和PreparedStatement
都支持批处理操作- 以 PreparedStatement为例
开启批处理
- mysql 批处理是默认关闭的,所以需要加一个参数才打开mysql 数据库批处理,在url中添加
rewriteBatchedStatements=true
例如:
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true
- 代码示例
package com.lagou.testbatch;
import com.lagou.utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class BatchInsert {
//使用批处理 向表中添加 10000条数据
public static void main(String[] args) throws SQLException {
//1.获取连接
Connection connection = DruidUtils.getConnection();
//2.获取预处理对象
PreparedStatement ps = connection.prepareStatement("insert into testBatch(uname) values(?)");
//3.执行批量插入操作
for (int i = 0; i < 10000 ; i++){
ps.setString(1,"小强" + i);
//将SQL添加到批处理列表
ps.addBatch();
}
//添加时间戳 测试执行效率
long start = System.currentTimeMillis();
//4.统一执行 批量插入操作
ps.executeBatch();
long end = System.currentTimeMillis();
System.out.println("插入10000条数据需要使用: " + (end - start) + " 毫秒!");
//5.关闭连接
DruidUtils.close(connection,ps);
}
}
MySQL元数据
什么是元数据
- 除了表之外的数据都是元数据,可以分为三类
- 查询结果信息: UPDATE 或 DELETE语句 受影响的记录数
- 数据库和数据表的信息: 包含了数据库及数据表的结构信息
- MySQL服务器信息: 包含了数据库服务器的当前状态,版本号等。
命令
select version()
: 获取mysql服务器的版本信息show status
: 查看服务器的状态信息show columns from table_name
: 显示表的字段信息等,和desc table_name一样show index from table_name
: 显示数据表的详细索引信息,包括PRIMARY KEY(主键)show databases
:列出所有数据库show tables
:显示当前数据库的所有表select database()
:获取当前的数据库名
使用JDBC获取元数据
常用类介绍
DatabaseMetaData
: 描述数据库的元数据对象ResultSetMetaData
:描述结果集的元数据对象- 获取元数据的方法:
getMetaData ()
- connection 连接对象, 调用
getMetaData ()
方法,获取的是DatabaseMetaData
数据库元数据对象 - PrepareStatement 预处理对象调用
getMetaData ()
, 获取的是ResultSetMetaData
, 结果集元数据对象
- connection 连接对象, 调用
DatabaseMetaData的常用方法
ResultSetMetaData常用方法
package com.lagou.testmetadata;
import com.lagou.utils.DruidUtils;
import org.junit.Test;
import java.sql.*;
public class TestMetaData {
//1.获取数据库相关的元数据信息 使用DatabaseMetaData
@Test
public void testDataBaseMetaData() throws SQLException {
//1.获取数据库连接对象 connection
Connection connection = DruidUtils.getConnection();
//2.获取代表数据库的 元数据对象 DatabaseMetaData
DatabaseMetaData metaData = connection.getMetaData();
//3.获取数据库相关的元数据信息
String url = metaData.getURL();
System.out.println("数据库URL: " + url);
String userName = metaData.getUserName();
System.out.println("当前用户: " + userName );
String productName = metaData.getDatabaseProductName();
System.out.println("数据库产品名: " + productName);
String version = metaData.getDatabaseProductVersion();
System.out.println("数据库版本: " + version);
String driverName = metaData.getDriverName();
System.out.println("驱动名称: " + driverName);
//判断当前数据库是否只允许只读
boolean b = metaData.isReadOnly(); //如果是 true 就表示 只读
if(b){
System.out.println("当前数据库只允许读操作!");
}else{
System.out.println("不是只读数据库");
}
connection.close();
}
//获取结果集中的元数据信息
@Test
public void testResultSetMetaData() throws SQLException {
//1.获取连接
Connection con = DruidUtils.getConnection();
//2.获取预处理对象
PreparedStatement ps = con.prepareStatement("select * from employee");
ResultSet resultSet = ps.executeQuery();
//3.获取结果集元素据对象
ResultSetMetaData metaData = ps.getMetaData();
//1.获取当前结果集 共有多少列
int count = metaData.getColumnCount();
System.out.println("当前结果集中共有: " + count + " 列");
//2.获结果集中 列的名称 和 类型
for (int i = 1; i <= count; i++) {
String columnName = metaData.getColumnName(i);
System.out.println("列名: "+ columnName);
String columnTypeName = metaData.getColumnTypeName(i);
System.out.println("类型: " +columnTypeName);
}
//释放资源
DruidUtils.close(con,ps,resultSet);
}
}