MySQL（下）

引言

紧接上次，MySQL（上）后，继续学习了MySQL，并进行了整理。

6、事务

6.1 什么是事务（ACID）

要么都成功，要么都失败

1. SQL执行， A给B转账 A 1000–> 200 B200
2. SQL 执行， B收到A的钱 A800 — B400

将一组SQL放在一个批次中执行

事务原则 ： ACID原则 原子性，一致性，隔离性，持久性 （脏读，幻读…）

原子性（Atomicity）

要么都成功，要么都失败

一致性（Consistency）

事务前后的数据完整性要保持一致

持久性（Durability）–事务提交

事务一旦提交就不可逆转，被持久化到数据库中

隔离性

事务产生多并发时，互不干扰

隔离产生的问题

脏读：

指一个事务读取了另外一个事务未提交的数据。

不可重复读：

在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）

虚读(幻读)

是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
（一般是行影响，多了一行）

执行事务

-- mysql 自动开启事务提交
SET autocommit=0 -- 关闭
SET autocommit=1 -- 开启（默认的）

-- 手动处理事务
SET autocommit =0 -- 关闭自动提交

-- 事务开启

START TRANSACTION -- 标记一个事务的开始，从这个之后的SQP都在同一个事务内

INSERT XX
INSERT XX

-- 提交 ： 持久化(成功)
COMMIT 
-- 回滚：  回到原来的样子（失败）
ROLLBACK
-- 事务结束
SET autocommit = 1 -- 开启自动提交
-- 了解
SAVEPOINT 保存点名称 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT 保存点名 -- 回滚到保存点
RELEASE SAVEPOINT 保存点 -- 删除保存点

模拟场景

CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ciUSE shopCREATE TABLE `account`(`id` INT(3) NOT NULL AUTO_INCREMENT,`name` VARCHAR(30) NOT NULL,`money` DECIMAL(9,2) NOT NULL,PRIMARY KEY (`id`))ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO account(`name`,`money`)VALUES('A',2000),('B',10000)-- 模拟转账：事务SET autocommit = 0; -- 关闭自动提交START TRANSACTION -- 开启事务（一组事务）UPDATE account SET money = money-500 WHERE `name` = 'A' -- A 转账给BUPDATE account SET money = money+500 WHERE `name` = 'B' -- B 收到钱COMMIT ; -- 提交事务ROLLBACK ; -- 回滚SET autocommit=1 -- 恢复默认值

7、索引

MySQL索引的建立对于MySQL的高效运行是很重要的，索引可以大大提高MySQL的检索速度。

7.1索引的分类

在一个表中，主键索引只能有一个，唯一索引可以有多个

• 主键索引 （PRIMARY KEY）
  • 唯一的标识，主键不可重复，只能有一个列作为主键
• 唯一索引 （UNIQUE KEY）
  • 避免重复的列出现，唯一索引可以重复，多个列都可以标识唯一索引
• 常规索引（KEY/INDEX）
  • 默认的，index,key关键字来设置
• 全文索引（FULLTEXT）
  • 在特点的数据库引擎下才有，MyISAM
  • 快速定位数据

-- 索引的使用
-- 1.在创建表的时候给字段增加索引
-- 2.创建完毕后，增加索引

-- 显示所有的索引信息
SHOW INDEX FROM 表

-- 增加一个索引
ALTER TABLE 表 ADD FULLTEXT INDEX 索引名（字段名）

-- EXPLAIN 分析sql执行状况
EXPLAIN SELECT * FROM student -- 非全文索引

7.2 测试索引sql

CREATE TABLE `app_user` (
`id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(50) DEFAULT '',
`email` VARCHAR(50) NOT NULL,
`phone` VARCHAR(20) DEFAULT '',
`gender` TINYINT(4) UNSIGNED DEFAULT '0',
`password` VARCHAR(100) NOT NULL DEFAULT '',
`age` TINYINT(4) DEFAULT NULL,
`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
`update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

-- 插入100万数据
DELIMITER $$ --  写函数之前必写
CREATE FUNCTION mock_data()
RETURNS INT 
BEGIN
DECLARE num INT DEFAULT 1000000;
DECLARE i INT DEFAULT 0;

WHILE i<num DO
-- 插入语句
INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
VALUE(CONCAT('用户',i),'534240118@qq.com',FLOOR (CONCAT('18',RAND()*9999999)),FLOOR (RAND()*2),
UUID(),FLOOR (RAND()*100));

SET i = i+1;
END WHILE;
RETURN i;


END;

INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
VALUE(CONCAT('用户',i),'534240118@qq.com',FLOOR (CONCAT('18',RAND()*9999999)),FLOOR (RAND()*2),
UUID(),FLOOR (RAND()*100))


SELECT mock_data();

SELECT * FROM app_user WHERE `name`='用户9999' -- 接近半秒

EXPLAIN SELECT * FROM app_user WHERE `name`='用户9999'  -- 查询99999条记录

-- id _ 表名_字段名
-- create index on 字段
CREATE INDEX id_app_user_name ON app_user(`name`); -- 0.001 s
EXPLAIN SELECT * FROM app_user WHERE `name`='用户9999'  -- 查询一条记录

索引在小数据的时候，用处不大，但是在大数据的时候，区别十分明显

7.3 索引原则

索引不是越多越好

• 不要对经常变动的数据加索引
• 小数据量的表不需要加索引
• 索引一般加在常用来查询的字段上

索引的数据结构

Hash 类型的索引

Btree: 默认innodb 的数据结构

阅读：http://blog.codinglabs.org/articles/theory-of-mysql-index.html

8、权限管理和备份

8.1用户管理

SQLyog 可视化管理

SQL命令操作

用户表：mysql.user

本质：对这张表进行，增删改查

-- 创建用户  CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER sanjin IDENTIFIED BY '123456'

-- 修改密码（修改当前密码）
SET PASSWORD = PASSWORD('111111')


-- 修改密码（修改指定用户密码）

SET PASSWORD FOR sanjin = PASSWORD('111111')


-- 重命名  rename user 原名字 to 新名字
RENAME USER sanjin TO sanjin2

-- 用户授权   ALL PRIVILEGES 全部的权限   库，表
-- ALL PRIVILEGES 除了给别人授权，其他都能干
GRANT ALL PRIVILEGES ON *.* TO sanjin2

-- 查询权限
SHOW GRANTS FOR sanjin2  -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost


-- 撤销权限 REVOKE 哪些权限，在哪个库撤销，给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM sanjin2

-- 删除用户
DROP USER sanjin2

8.2 MySQL备份

为什么备份：

保证重要数据不丢失

• 数据转移

MySQL数据库备份的方式

• 直接拷贝物理文件
• 在SQLyog这种可视化工具中手动导出
  • 在想要导出的表或者库中，右键选择备份和导出

假设你要备份数据库，防止数据丢失。

把数据给朋友

9、规范数据库设计

当数据库比较复杂的时候，我们就需要设计了

糟糕的数据库设计：

• 数据冗余，浪费空间
• 数据库插入和删除都会麻烦，异常【屏蔽使用物理外键】
• 程序的性能差

良好的数据库设计：

• 节省内存空间
• 保证数据库的完整性
• 方便我们开发系统

软件开发中，关于数据库的设计

• 分析需求：分析业务和需要处理的数据库的需求
• 概要设计：设计关系图 E-R图

设计数据库的步骤（个人博客）

1、收集信息，分析需求

• 用户表（用户登录注销，用户的个人信息，写博客，创建分类）
• 分类表（文章分类，谁创建的）
• 文章表（文章的信息）
• 友链表（友链信息）
• 自定义表（系统信息，某个关键的字，或者某些主字段）
• 说说表（发表心情…id ,content ,time）

2、标识实体（把需求落地到每个字段）

3、 标识实体之间的关系

• 写博客 user–>blog
• 创建分类 user–>category
• 关注 user–>user
• 友链–>links
• 评论 user–>user

9.2三大范式

为什么需要数据规范化？

• 信息重复
• 更新异常
• 插入异常
• 删除异常
  • 无法正常显示异常
• 删除异常
  • 丢失有效的信息

三大范式

第一范式（1NF）

原子性：保证每一列不可再分

第二范式（2NF）

前提：满足第一范式

每张表只描述一件事情

第三范式（3NF）

前提：满足第一范式和第二范式

第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

（规范数据库的设计）

规范性和性能的问题

关联查询的表，不得超过三张表

• 考虑商业化的需求和目标（成本和用户体验） 数据库的性能更加重要
• 再规范性能的问题的时候，需要适当的考虑一下，规范性
• 故意给某些表加一些冗余的字段（从多表，变成单表）
• 故意增加一些计算列（从大数据量降低为小数据量的查询：索引）

10、JDBC(重点)

10.1 数据库驱动

驱动：声卡，显卡，数据库

，

我们的程序会通过数据库驱动，和数据库打交道！

10.2 JDBC

SUN 公司为了简化开发人员的（对数据库的统一）操作，提供了一个(Java操作数据库的)规范，JDBC

这些规范的实现由具体的厂商去做

对于开发人员来说，我们只需要掌握JDBC的接口操作即可

java.sql

javax.sql

还需要导入数据库驱动包

10.3 第一个JDBC程序

创建测试数据库

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;

USE jdbcStudy;

CREATE TABLE `users`(
id INT PRIMARY KEY,
NAME VARCHAR(40),
PASSWORD VARCHAR(40),
email VARCHAR(60),
birthday DATE
);

INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04')

1.创建一个普通项目

2.导入数据库驱动

3.编写测试代码

package com.kuang.lesson01;
//我的第一个JDBC程序

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class JdbcFirstDemo {
    public static void main(String[] args) throws Exception {
        //1. 加载驱动
        Class.forName("com.mysql.jdbc.Driver");//固定写法
        //2. 用户信息和url
        //useUnicode=true&characterEncoding=utf8&&useSSL=true
        String url ="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=false";
        String name = "root";
        String password = "123456";

        //3. 连接成功，返回数据库对象  connection代表数据库
        Connection connection= DriverManager.getConnection(url,name,password);
        //4. 执行SQL的对象 statement 执行SQL的对象
        Statement statement = connection.createStatement();

        //5. 执行SQL的对象 去执行SQL   可能存在结果，查看返回结果
        String sql="SELECT * FROM users";
        ResultSet resultSet = statement.executeQuery(sql);//返回的结果集,结果集中封装了我们全部查询的结果
        while(resultSet.next()){
            System.out.println("id+"+resultSet.getObject("id"));
            System.out.println("name+"+resultSet.getObject("NAME"));
            System.out.println("password+"+resultSet.getObject("PASSWORD"));
            System.out.println("email+"+resultSet.getObject("email"));
            System.out.println("birthday+"+resultSet.getObject("birthday"));
        }
        //6. 释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

步骤总结：
1.加载驱动

2.连接数据库 DriverManager

3.获取执行SQL的对象 Statement

4.获得返回的结果集

5.释放连接

DriverManager

//DriverManager.registerDriver(new com.mysql.jdbc.Driver());Class.forName("com.mysql.jdbc.Driver");//固定写法Connection connection= DriverManager.getConnection(url,name,password);//connection代表数据库//数据库设置自动提交//事务提交//事务回滚connection.rollback();connection.commit();connection.setAutoCommit();

URL

String url ="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=false";//mysql 默认3306//协议://主机地址:端口号/数据库名？参数1&参数2&参数3//Oracle   1521//jdbc:oralce:thin:@localhost:1521:sid

statement 执行SQL的对象 pPrepareStatement 执行SQL的对象

String sql="SELECT * FROM users";//编写Sql

statement.executeQuery();
statement.execute();
statement.executeUpdate();//更新，插入，删除，返回一个受影响的行数

ResultSet 查询的结果集，封装了所以的查询结果

获得指定的数据类型

ResultSet resultSet = statement.executeQuery(sql);//返回的结果集,结果集中封装了我们全部查询的结果
        resultSet.getObject();//在不知道列类型下使用
        resultSet.getString();//如果知道则指定使用
        resultSet.getInt();
        

遍历,指针

    resultSet.next(); //移动到下一个
    resultSet.afterLast();//移动到最后
    resultSet.beforeFirst();//移动到最前面
    resultSet.previous();//移动到前一行
    resultSet.absolute(row);//移动到指定行

释放内存

//6. 释放连接
        resultSet.close();
        statement.close();
        connection.close();//耗资源

10.4 statement对象

Jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sq|语句， executeUpdate执行完后， 将会返回一个整数(即增删改语句导致了数据库几行数据发生了变化)。

Statement.executeQuery方法用于向数据库发生查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate(String sql)方法完成数据添加操作，示例操作：

 Statement statement = connection.createStatement();
        String sql = "insert into user(...) values(...)";
        int num = statement.executeUpdate(sql);
        if(num>0){
            System.out.println("插入成功");
        }

CRUD操作-delete

使用executeUpdate(String sql)方法完成数据删除操作，示例操作：

Statement statement = connection.createStatement();
        String sql = "delete from user where id =1";
        int num = statement.executeUpdate(sql);
        if(num>0){
            System.out.println("删除成功");
        }

CURD操作-read

使用executeUpdate(String sql)方法完成数据查询操作，示例操作：

Statement statement = connection.createStatement();
        String sql = "select * from  user where id =1";
        ResultSet rs= statement.executeQuery(sql);
        if(rs.next()){
            System.out.println("");
        }

代码实现

1.提取工具类

package com.kuang.lesson02.utils;import java.io.IOException;import java.io.InputStream;import java.sql.*;import java.util.Properties;public class JdbcUtils {    private static String driver = null;    private static String url = null;    private static String username = null;    private static String password = null;    static {        try{            InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");            Properties properties = new Properties();            properties.load(in);            driver=properties.getProperty("driver");            url=properties.getProperty("url");            username=properties.getProperty("username");            password=properties.getProperty("password");            //1.驱动只用加载一次            Class.forName(driver);        } catch (IOException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        }    }    //2.获取连接    public static Connection getConnection() throws Exception{        return DriverManager.getConnection(url, username, password);    }    //3.释放资源    public static void release(Connection conn, Statement st, ResultSet rs) throws SQLException {        if(rs!=null){            rs.close();        }        if (st!=null){            st.close();        }        if(conn!=null){            conn.close();        }    }}

2.编写增删改的方法，exectueUpdate

package com.kuang.lesson02.utils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import static com.kuang.lesson02.utils.JdbcUtils.*;

public class TestInnsert {
    public static void main(String[] args){
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;



        try {
             conn = getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象
            String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(5,'sanjin','123456','233223@qq.com','2020-01-01')";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功");
            }
        JdbcUtils.release(conn,st,rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

3.查询 executeQuery

package com.kuang.lesson02.utils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import static com.kuang.lesson02.utils.JdbcUtils.*;

public class TestInnsert {
    public static void main(String[] args) throws SQLException {
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;



        try {
             conn = getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象
            String sql = "select * from users";
            rs=st.executeQuery(sql);//查询完毕返回结果集

            while (rs.next()){
                System.out.println(rs.getString("NAME"));
            }
        JdbcUtils.release(conn,st,rs);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }

}

SQL注入问题

sql存在漏洞，会被攻击导致数据泄露 SQL会被拼接 or

package com.thb.study2;

/**
 * @Author 天红
 * @Date 2021/7/23 16:31
 * @Version 1.0
 */

import com.thb.study2.Utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import static com.thb.study2.Utils.JdbcUtils.getConnection;

public class SQL {
    public static void main(String[] args) {


        //SQL注入
        login("' or '1=1","' or '1=1");
    }
    public static void login(String name,String password){


        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;



        try {
            conn = getConnection();//获取连接

            st = conn.createStatement();//获取SQL执行对象
            String sql = "select * from users where `NAME`='"+ name +"'  AND `PASSWORD`='"+ password +"'" ;
            rs=st.executeQuery(sql);//查询完毕返回结果集

            while (rs.next()){
                System.out.println(rs.getString("NAME"));
                System.out.println(rs.getString("password"));
                System.out.println("==========================================");
            }
            JdbcUtils.release(conn,st,rs);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

10.5 PreparedStatement对象

(防止SQL注入本质，传递字符 带有“ ”，转义字符会被转义)

PreparedStatement 可以防止SQL注入 ，效率更高。

更新都一样

1. 新增
2. 删除
3. 查询

package com.thb.study2;

import com.thb.study2.Utils.JdbcUtils;

import java.sql.*;

/**
 * @Author 天红
 * @Date 2021/7/23 20:30
 * @Version 1.0
 */
public class TestInsert02 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)";
            ps = conn.prepareStatement(sql);

            ps.setInt(1, 6);
            ps.setString(2, "无言");
            ps.setString(3, "999");
            ps.setString(4, "th@hhh.com");
            ps.setDate(5, new Date(new java.util.Date().getTime()));

            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功o(*▽*)q");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, ps, rs);
        }

    }
}

查询

package com.thb.study2;

/**
 * @Author 天红
 * @Date 2021/7/23 16:31
 * @Version 1.0
 */

import com.thb.study2.Utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

import static com.thb.study2.Utils.JdbcUtils.getConnection;

public class TestQuary03 {
    public static void main(String[] args) {
        
        login("苏苏", "222");
    }

    public static void login(String name, String password) {

        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;


        try {
            conn = getConnection();//获取连接
            String sql = "SELECT * FROM users WHERE `NAME`=? and `PASSWORD`=?";
            st = conn.prepareStatement(sql);//获取SQL执行对象

            st.setString(1, name);
            st.setString(2, password);

            rs = st.executeQuery();//查询完毕返回结果集

            while (rs.next()) {
                System.out.println(rs.getString("NAME"));
                System.out.println(rs.getString("password"));
                System.out.println("==========================================");
            }
            JdbcUtils.release(conn, st, rs);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

防止SQL注入本质，传递字符 带有“ ”，转义字符会被转义

10.6 使用IDEA连接数据库

连接成功后，可以选择数据库,选择mysql

双击数据库

更新数据、

编写sql代码的地方

10.7 JDBC事务

要么都成功，要么都失败

ACID原则

原子性：要么全部完成，要么都不完成

一致性：结果总数不变

隔离性：多个进程互不干扰

持久性：一旦提交不可逆，持久化到数据库了

隔离性的问题：

脏读： 一个事务读取了另一个没有提交的事务

不可重复读：在同一个事务内，重复读取表中的数据，表发生了改变

虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致

代码实现

1. 开启事务conn.setAutoCommit(false);
2. 一组业务执行完毕，提交事务
3. 可以在catch语句中显示的定义回滚，但是默认失败会回滚

package com.thb.study3;

import com.thb.study2.Utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @Author 天红
 * @Date 2021/7/24 13:54
 * @Version 1.0
 */
public class Test03 {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            connection = JdbcUtils.getConnection();
            connection.setAutoCommit(false);

            String sql = "update account set money=money-100 where `name`='A'";
            ps = connection.prepareStatement(sql);
            ps.executeUpdate();
            
            String sql2 = "update account set money=money+100 where `name`='B'";
            ps = connection.prepareStatement(sql2);
            ps.executeUpdate();

            connection.commit();
            System.out.println("成功d=====(￣▽￣*)b");


        } catch (SQLException e) {
            //默认失败会回滚
            e.printStackTrace();
        }finally {
            JdbcUtils.release(connection,ps,null);
        }
    }
}

10.8数据库连接池

数据库连接–执行完毕–释放
连接–释放 十分浪费资源
池化技术： 准备一些预先的资源，过来就连接预先准备好的
常用连接数 100
最少连接数：100
最大连接数 ： 120 业务最高承载上限
排队等待，
等待超时：100ms
编写连接池，实现一个接口 DateSource

简单看一下结构

开源数据源实现(拿来即用)

• DBCP
• C3P0
• Druid: 阿里巴巴

使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了

DBCP

需要用到的jar包 看上图–> dbcp和pool（还有个logging）

• dbcpconfig.properties

#连接设置,这里面的名字是DBCP数据源中定义好的
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=utf8useSSL=false

username=root
password=root
#<!-- 初始化连接-->
initialSize=10

#最大连接数量
maxActive=50

#最大空闲连接
maxIdle=20

#最小空闲连接
minIdle=5

#超时等待时间以毫秒为单位/s
maxWait=60000

#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
#注意：“user” 与 “password” 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=utf8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

• JdbcUtils_DBCP工具类

package com.thb.study4.utils;

import org.apache.commons.dbcp2.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * @Author 天红
 * @Date 2021/7/23 14:28
 * @Version 1.0
 */
public class JdbcUtils_DBCP {
    private static DataSource dataSource=null;

    static {
        try {
            InputStream is = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(is);

            //创建数据源 工厂模式-->创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);
            

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    //2.获取连接
    public static Connection getConnection() throws SQLException {

            return dataSource.getConnection();//从数据源中获取连接

    }

    //3.释放资源
    public static void release(Connection conn, Statement st, ResultSet rs)  {
        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();
            }
        }
    }

}

• DBCP测试代码

package com.thb.study4;

import com.thb.study2.Utils.JdbcUtils;
import com.thb.study4.utils.JdbcUtils_DBCP;

import java.sql.*;

/**
 * @Author 天红
 * @Date 2021/7/24 21:33
 * @Version 1.0
 */
public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils_DBCP.getConnection();
            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)";
            ps = conn.prepareStatement(sql);

            ps.setInt(1, 24);
            ps.setString(2, "无言");
            ps.setString(3, "999");
            ps.setString(4, "th@hhh.com");
            ps.setDate(5, new Date(new java.util.Date().getTime()));

            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功o(*▽*)q");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(conn, ps, rs);
        }


    }
}

C3P0

jar包看上图 --> c3p0和mchange开头的

• c3p0-config.xml配置文件（名字不要变）

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <default-config>
<!--
C3P0的缺省（默认）配置，
如果在代码中是    ComboPooledDataSource cp = new ComboPooledDataSource();  这样写是default-config的配置
        -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/student?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <property name="user">root</property>
        <property name="password">root</property>


        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
        <property name="acquireIncrement">3</property>

        <!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 10 这些都是自己定义 -->
        <property name="initialPoolSize">10</property>

        <!-- 连接的最大空闲时间，default: 30  -->
        <property name="maxIdleTime">30</property>

             <!--连接池中保留的最大连接数。Default: 100 -->
        <property name="maxPoolSize">100</property>

        <!--连接池中保留的最小连接数。Default: 15 -->
        <property name="minPoolSize">15</property>
    </default-config>



<!--
C3P0的命名配置，
如果在代码中是    ComboPooledDataSource cp = new ComboPooledDataSource("MySQL");  这样写是default-config的配置
-->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/student?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <property name="user">root</property>
        <property name="root">root</property>

        <property name="acquireIncrement">3</property>
        <property name="initialPoolSize">10</property>
        <property name="maxIdleTime">30</property>
        <property name="maxPoolSize">100</property>
        <property name="minPoolSize">10</property>
    </named-config>


<!-- 所以下面想什么配置就写什么配置   -->
</c3p0-config>

• 工具类

package com.thb.study4.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @Author 天红
 * @Date 2021/7/23 14:28
 * @Version 1.0
 */
public class JdbcUtils_C3P0 {
    private static ComboPooledDataSource dataSource=null;

    static {
        try {

/*            //代码配置，麻烦不用
           dataSource = new ComboPooledDataSource();
           dataSource.setDriverClass("com.mysql.jdbc.Driver");
           dataSource.setUser("root");
           dataSource.setPassword("root");

           dataSource.setMaxPoolSize(100);
           dataSource.setMinPoolSize(10);*/

//      配置文件的配法，我们只要导入xml文件，写个一句就好了
      dataSource= new ComboPooledDataSource("MySQL");




        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    //2.获取连接
    public static Connection getConnection() throws SQLException {

            return dataSource.getConnection();//从数据源中获取连接

    }

    //3.释放资源
    public static void release(Connection conn, Statement st, ResultSet rs)  {
        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();
            }
        }
    }

}

• 测试C3P0类

package com.thb.study4;

import com.thb.study4.utils.JdbcUtils_C3P0;
import com.thb.study4.utils.JdbcUtils_DBCP;

import java.sql.*;

/**
 * @Author 天红
 * @Date 2021/7/24 21:33
 * @Version 1.0
 */
public class TestC3P0 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils_C3P0.getConnection();
            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)";
            ps = conn.prepareStatement(sql);

            ps.setInt(1, 27);
            ps.setString(2, "我爱你");
            ps.setString(3, "1314");
            ps.setString(4, "804328977@qq.com");
            ps.setDate(5, new Date(new java.util.Date().getTime()));

            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功o(*▽*)q");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(conn, ps, rs);
        }


    }
}

结论

无论使用什么数据源，本质是不变的，DateSource接口不会变，方法就不会变