小迷糊与数据库连接池的相遇

最新推荐文章于 2024-07-25 13:40:37 发布
最新推荐文章于 2024-07-25 13:40:37 发布
阅读量120 收藏
点赞数
分类专栏： JAVA 理论学习 数据库理论知识学习 文章标签： java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaomihu6666/article/details/115055642
版权

文章目录

数据库连接池

什么是数据库连接池？

  • 什么是数据库连接池
    实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，为了解决此类性能问题，通常情况我们
    采用连接池技术，来共享连接Connection。这样我们就不需要每次都创建连接、释放连接了，这些操作都交
    给了连接池.***（总结起来就是一句话，为了节省系统资源，将连接和关闭操作放入连接池中，共享连接）***

  • 连接池的好处？
    用池来管理Connection，这样可以重复使用Connection。 当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。

JDBC方式与连接池方式

  • 普通连接方式
  • 连接池方式

如何使用数据库连接池

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

  • 常见的连接池： DBCP连接池, C3P0连接池, Druid连接池,。

数据准备：

#创建数据库
CREATE DATABASE db5 CHARACTER SET utf8;
#使用数据库
USE db5;
#创建员工表
CREATE TABLE employee (
eid INT PRIMARY KEY AUTO_INCREMENT ,
ename VARCHAR (20), -- 员工姓名
age INT , -- 员工年龄
sex VARCHAR (6), -- 员工性别
salary DOUBLE , -- 薪水
empdate DATE -- 入职日期
);
#插入数据
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李清
照',22,'女',4000,'2018-11-12');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'林黛
玉',20,'女',5000,'2019-03-14');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'杜
甫',40,'男',6000,'2020-01-01');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李白',25,'男',3000,'2017-10-01');

DBCP连接池

DBCP也是一个开源的连接池，是Apache成员之一，在企业开发中也比较常见，tomcat内置的连接池。

创建项目 导入jar包
  • 将这两个 jar包添加到 myJar文件夹中
  • 添加myJar库 到项目的依赖中
编写工具类
  • 连接数据库表的工具类, 采用DBCP连接池的方式来完成。
    • Java中提供了一个连接池的规则接口 ： DataSource , 它是java中提供的连接池。
    • 在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池 BasicDataSource 类。

案例：

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);
}

//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();
}
}
}
}

测试：
查询所有员工的姓名

public class TestDBCP {
/*
* 测试DBCP连接池
* */
public static void main(String[] args) throws SQLException {
//1.从DBCP连接池中拿到连接
Connection con = DBCPUtils.getConnection();
//2.获取Statement对象
Statement statement = con.createStatement();
//3.查询所有员工的姓名
String sql = "select ename from employee";
ResultSet resultSet = statement.executeQuery(sql);
//4.处理结果集
while(resultSet.next()){
String ename = resultSet.getString("ename");
System.out.println("员工姓名: " + ename);
} /
/5.释放资源
DBCPUtils.close(con,statement,resultSet);
}
}
  • 常用的配置项
    DBCP连接池常用配置项

C3P0连接池

C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。

导入jar包及配置文件
  • 将jar包 复制到myJar文件夹即可,IDEA会自动导入
  • 导入配置文件 c3p0-config.xml
    • c3p0-config.xml 文件名不可更改
    • 直接放到src下,也可以放到到资源文件夹中
    • 配置文件示例：（HTML标记语言）
<c3p0-config>
<!--默认配置-->
<default-config>
<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>
<!-- 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</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>
  • 在项目下创建一个resource文件夹专门用来存放资源文件
  • 选择文件夹，右键，将resource文件夹指定为资源文件夹
  • 将文件放在resource目录下即可,创建连接池对象的时候会去加载这个配置文件
编写C3P0工具类

  • C3P0提供的核心工具类, ComboPooledDataSource , 如果想使用连接池,就必须创建该类的对象

    • new ComboPooledDataSource(); 使用 默认配置
    • new ComboPooledDataSource(“mysql”); 使用命名配置

    工具类编写：

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();
}
}
}
}

C3P0：利用配置文件，解决了DBPC的耦合问题，将一些信息都写在配置文件中。

测试工具类
  • 测试：查询姓名为 李白的员工信息
p
ublic class TestC3P0 {
//需求 查询姓名为李白的 记录
public static void main(String[] args) throws SQLException {
//1.获取连接
Connection con = C3P0Utils.getConnection();
//2.获取预处理对象
String sql = "select * from employee where ename = ?";
PreparedStatement ps = con.prepareStatement(sql);
//3.设置占位符的值
ps.setString(1,"李白");
ResultSet resultSet = ps.executeQuery();
//4.处理结果集
while(resultSet.next()){
int eid = resultSet.getInt("eid");
String ename = resultSet.getString("ename");
int age = resultSet.getInt("age");
String sex = resultSet.getString("sex");
double salary = resultSet.getDouble("salary");
Date date = resultSet.getDate("empdate");
System.out.println(eid +" " + ename + " " + age +" " + sex +" " + salary +" "
+date);
} /
/5.释放资源
C3P0Utils.close(con,ps,resultSet);
}
}
常见配置

C3P0连接池的配置

Druid连接池

Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池**，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。**

导入jar包以及配置文件
  • 导入 jar包
  • 导入配置文件
    • 是properties形式的
    • 可以叫任意名称，可以放在任意目录下,我们统一放到 resources资源目录在这里插入图片描述
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000
编写Druid工具类
  • 获取数据库连接池对象
    • 通过工厂来来获取 DruidDataSourceFactory类的createDataSource方法
    • createDataSource(Properties p) 方法参数可以是一个属性集对象
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();
}
}
}
}
测试工具类
  • 查询薪资在3000 - 5000元之间的员工姓名
public class TestDruid {
// 需求 查询 薪资在3000 到 5000之间的员工的姓名
public static void main(String[] args) throws SQLException {
//1.获取连接
Connection con = DruidUtils.getConnection();
//2.获取Statement对象
Statement statement = con.createStatement();
//3.执行查询
ResultSet resultSet = statement.executeQuery("select ename from employee where salary
between 3000 and 5000");
//4.处理结果集
while(resultSet.next()){
String ename = resultSet.getString("ename");
System.out.println(ename);
} /
/5.释放资源
DruidUtils.close(con,statement,resultSet);
}
}

DBUtils工具类

DBUtils简介

  • 使用JDBC我们发现冗余的代码太多了,为了简化开发 我们选择使用 DbUtils Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。
  • 使用方式: DBUtils就是JDBC的简化开发工具包。需要项目导入 commons-dbutils-1.6.jar。
Dbutils核心功能介绍
  1. QueryRunner 中提供对sql语句操作的API.
  2. ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
  3. DbUtils类,他就是一个工具类,定义了关闭资源与事务处理相关方法.

案例相关知识（表与类的关系/javaBean组件）

表和类之间的关系
  • 整个表可以看做是一个类
  • 表中的一行记录,对应一个类的实例(对象)
  • 表中的一列,对应类中的一个成员属性
    表与类的对应关系
JavaBean组件
  • JavaBean 就是一个类, 开发中通常用于封装数据,有以下特点
    • 需要实现 序列化接口, Serializable (暂时可以省略)
    • 提供私有字段: private 类型 变量名;
    • 提供 getter 和 setter
    • 提供 空参构造
  • 创建Employee类和数据库的employee表对应
    • 我们可以创建一个 entity包,专门用来存放 JavaBean类专门用来存放javabean类
    • 代码示例：
import java.io.Serializable;
import java.util.Date;

/**
 * JavaBean类
 *      用来存储数据 成员变量私有 提供get set 提供空参  实现序列化接口
 *
 * Employee类 就是对应了 数据库中Employee表
 *   `eid` INT(11) NOT NULL AUTO_INCREMENT,
 *   `ename` VARCHAR(20) DEFAULT NULL,
 *   `age` INT(11) DEFAULT NULL,
 *   `sex` VARCHAR(6) DEFAULT NULL,
 *   `salary` DOUBLE DEFAULT NULL,
 *   `empdate` DATE DEFAULT NULL,
 *
 */
public class Employee implements Serializable {

    //成员变量的名称 与 表中的列要一样
    private int eid;

    private String ename;

    private int age;

    private String sex;

    private double salary;

    private Date empdate;

    public Employee() {
    }

    public Employee(int eid, String ename, int age, String sex, double salary, Date empdate) {
        this.eid = eid;
        this.ename = ename;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
        this.empdate = empdate;
    }

    public int getEid() {
        return eid;
    }

    public void setEid(int eid) {
        this.eid = eid;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Date getEmpdate() {
        return empdate;
    }

    public void setEmpdate(Date empdate) {
        this.empdate = empdate;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "eid=" + eid +
                ", ename='" + ename + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", salary=" + salary +
                ", empdate=" + empdate +
                '}';
    }
}

DBUtils完成 CRUD

QueryRunner核心类
  • 构造方法
    • QueryRunner()
    • QueryRunner(DataSource ds) ,提供数据源（连接池），DBUtils底层自动维护连接connection
  • 常用方法
    • update(Connection conn, String sql, Object… params) ，用来完成表数据的增加、删除、更新操
      作。
    • query(Connection conn, String sql, ResultSetHandler rsh, Object… params) ，用来完成表数据的查询操作
QueryRunner的创建
  • 手动模式：
//手动方式 创建QueryRunner对象
QueryRunner qr = new QueryRunner();
  • 自动模式
//自动创建 传入数据库连接池对象
QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());
  • 自动模式需要传入连接池对象
//获取连接池对象
public static DataSource getDataSource(){
return dataSource;
}
QueryRunner实现增、删、改操作
  • 核心方法：update(Connection conn, String sql, Object… params)
  • 参数说明：参数说明
  • 步骤：
    • 创建QueryRunner(手动或自动)
    • 占位符方式 编写SQL
    • 设置占位符参数
    • 执行
  • 添加：
@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);
}
  • 修改：
/
/修改操作 修改姓名为张百万的员工工资
@Test
public void testUpdate() throws SQLException {
//1.创建QueryRunner对象 自动模式,传入数据库连接池
QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
//2.编写SQL
String sql = "update employee set salary = ? where ename = ?";
//3.设置占位符参数
Object[] param = {0,"张百万"};
//4.执行update, 不需要传入连接对象
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结果集进行处理，达到一些业务上的需求。
ResultSetHandIer结果集处理类
  • 本例展示的是使用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 表操作。
ResultSetHandIer常用实现类测试
  • QueryRunner的查询方法
  • query方法的返回值都是泛型,具体的返回值类型,会根据结果集的处理方式,发生变化。
  • 参数说明：
    参数说明
  • 创建一个测试类，对ResultSetHandler接口的几个常见实现类进行测试
    • 查询id为5的记录,封装到数组中
/*
* 查询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));
//这里使用Arrays工具类打印数组中元素
  • 查询所有数据,封装到List集合中
/**
* 查询所有数据,封装到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为5的记录,封装到指定JavaBean中
/
**
* 查询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);
}

注意：
BeanHandIer传递参数时注意事项

  • 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
/
*
* 查询薪资大于 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集合中；
/
*
* 查询姓名是 张百万的员工信息,将结果封装到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的批处理方式：

  1. 要用到的方法

    • void addBatch()
      • 将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。
      • 通过调用方法 executeBatch 可以批量执行此列表中的命令
    • int[] executeBatch()
      • 每次提交一批命令到数据库中执行，如果所有的命令都成功执行了，那么返回一个数组，这个数组是说明每条命令所影响的行数。

  2. mysql 批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加。
    rewriteBatchedStatements=true
    例如: url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF8&rewriteBatchedStatements=true

  3. 创建一张表

CREATE TABLE testBatch (
id INT PRIMARY KEY AUTO_INCREMENT,
uname VARCHAR(50)
)
  1. 测试向表中插入1万条数据
public class TestBatch {
//使用批处理,向表中添加 1万条数据
public static void main(String[] args) {
try {
//1.获取连接
Connection con = DruidUtils.getConnection();
//2.获取预处理对象
String sql ="insert into testBatch(uname) values(?)";
PreparedStatement ps = con.prepareStatement(sql);
//3.创建 for循环 来设置占位符参数
for (int i = 0; i < 10000 ; i++) {
ps.setString(1,"小强"+i);
//将SQL添加到批处理 列表
ps.addBatch();
} /
/添加时间戳 测试执行效率
long start = System.currentTimeMillis();
//统一 批量执行
ps.executeBatch();
long end = System.currentTimeMillis();
System.out.println("插入10000条数据使用: " +(end - start) +" 毫秒!");
} catch (SQLException e) {
e.printStackTrace();
}
}
}

MySQL元数据

什么是元数据

  • 除了表之外的数据都是元数据,可以分为三类
    • 查询结果信息： UPDATE 或 DELETE语句 受影响的记录数。
    • 数据库和数据表的信息： 包含了数据库及数据表的结构信息。
    • MySQL服务器信息： 包含了数据库服务器的当前状态，版本号等。

常用命令

– 1.查看服务器当前状态
show status; 查看服务器的状态信息
– 2.查看MySQl的版本信息
select version(); 获取mysql服务器的版本信息
– 3.查询表中的详细信息
show columns from table_name; 显示表的字段信息等，和desc table_name一样
– 4.显示数据表的详细索引信息
show index from table_name; 显示数据表的详细索引信息，包括PRIMARY KEY（主键）
– 5.列出所有数据库
show databases:列出所有数据库
show tables : 显示当前数据库的所有表
select database(): 获取当前的数据库名

使用JDBC获取元数据

通过JDBC 也可以获取到元数据,比如数据库的相关信息,或者当我们使用程序查询一个不熟悉的表时, 我们可以通过获取元素据信息,了解表中有多少个字段,字段的名称 和 字段的类型.

常用类介绍
  • JDBC中描述元数据的类
    • DatabaseMetaData 描述数据库的元数据对象
    • ResultSetMetaData 描述结果集的元数据对象
  • 获取元数据对象的方法 : getMetaData ()
    • connection 连接对象, 调用 getMetaData () 方法,获取的是DatabaseMetaData 数据库元数据对象
    • PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象
  • DatabaseMetaData的常用方法
    • getURL() : 获取数据库的URL
    • getUserName(): 获取当前数据库的用户名
    • getDatabaseProductName(): 获取数据库的产品名称
    • getDatabaseProductVersion(): 获取数据的版本号
    • getDriverName(): 返回驱动程序的名称
    • isReadOnly(): 判断数据库是否只允许只读 true 代表只读
  • ResultSetMetaData的常用方法
    • getColumnCount() : 当前结果集共有多少列；
    • getColumnName(int i) : 获取指定列号的列名, 参数是整数 从1开始；
    • getColumnTypeName(int i): 获取指定列号列的类型, 参数是整数 从1开始；
代码解释
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("不是只读数据库");
} c
onnection.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);
}
}
xiaomihu6666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小迷糊与JDBC的初相逢
xiaomihu6666的博客
03-19 95
文章目录JDBC概述客户端操作服务器的方式什么是JDBC？JDBC原理（由驱动实现）JDBC开发准备一组数据MySql驱动包API使用：注册驱动获取连接获取语句执行对象处理结果集释放资源步骤总结JDBC实现增删改查JDBC工具类什么时候自己创建工具类？工具类包含的内容JDBC实现DML操作SQL注入注入的演示（便于理解注入问题）注入案例问题分析预处理对象PreparedStatement 接口介绍PreparedStatement 特点获取PreparedStatement对象PreparedStateme
走进数据库连接池
菩提小猿的博客
05-17 318
1. 前言 “池”(Pool)技术在一定程度上可以明显优化服务器应用程序的性能，提高程序执行效率和降低系统资源开销。此“池”是一种广义上的池，如：数据库连接池、线程池、内存池。此处只涉及到数据库连接池 2. 数据库连接池 2.1 什么是数据库连接池？ 那么，什么是数据库连接池呢？数据库连接池就是一个创建和管理数据库连接的缓冲池技术，这些连接随时会被需要它们的线程调用。 2.2 java中常用的数据库连接池 在java语言中，一些常用的数据库连接池有：C3P0、DBCP、Proxool以及阿里巴巴的Druid
JDBC编程实例（带注释，详细）
threelifeadv的博客
03-06 1333
JDBC编程过程中，主要经历了如下几个阶段： 1、加载数据库驱动（Driver）； 2、创建数据库连接（Connection）； 3、创建Statement对象（Statement，PreparedStatement）； 4、执行SQL语句（execute,executeUpdate,executeQuery）; 5、释放资源。 在之前的文章中，详细的介绍了JDBC编程的每...
配置数据库连接池
一个大龄码农的专栏
07-26 76
1) 你可在每个web工程目录下的META-INF\context.xml文件中. context.xml文件中的内容可以这样写: &lt;Context&gt; &lt;Resource name="jdbc/mingri" type="javax.sql.DataSource" auth="Container" driverClassName="com.microsoft.jdb...
JDBC与数据库连接池
热门推荐
lonelymanontheway的博客
10-24 3万+
JDBC简介，driver类型，JDBC连接，使用技巧； 连接，短连接，长连接，连接池； 池化思想； 配置，基本配置，关键配置，性能配置； 连接池工具； druid； HikariCP； flexy-pool；
Java实现数据库连接池简易教程
09-02
Java实现数据库连接池简易教程主要涉及了如何在Java应用程序中创建并管理数据库连接池。数据库连接池是一种优化数据库操作的技术，通过复用已存在的数据库连接，减少频繁创建和关闭连接带来的性能开销。本文将介绍一...
druid1.2.8 下载 数据库连接池
05-22
Druid是阿里巴巴开源的一个高性能、多功能的数据库连接池组件，它在Java开发中广泛应用于各种项目的数据库管理。在1.2.8版本中，Druid提供了一系列优化和改进，旨在提高数据库访问性能，增强监控能力，并简化数据库...
Java实现数据库连接池的方法
09-03
Java数据库连接池是一种管理数据库连接的技术，通过复用已存在的数据库连接来提高应用程序的性能，减少新连接的创建和释放带来的开销。在Java中，实现数据库连接池主要有以下步骤： 1. **配置数据库连接参数**： `...
c# mysql数据库连接池实现
03-24
数据库连接池是一种资源管理技术，它预先创建并维护一定数量的数据库连接，当应用需要时，可以从池中获取连接，使用完毕后归还而不是直接关闭，从而减少了频繁创建和销毁连接的开销。在.NET Core中，对于MySQL数据库...
Qt 多线程连接数据库——数据库连接池
09-07
* 数据库连接池特点: * 获取连接时不需要了解连接的名字，连接池内部维护连接的名字 * 支持多线程，保证获取到的连接一定是没有被其他线程正在使用 * 按需创建连接,可以创建多个连接,可以控制连接的数量 * 连接...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1209
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 502
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 800
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 275
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2166
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1354
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 1006
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
最新发布
Sakurapaid的博客
07-25 269
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值