未创建索引

创建索引后

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

7.3 索引原则

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

索引的数据结构

Hash 类型的索引

Btree：INNODB的默认数据结构

8、权限管理和备份

8.1 用户管理

Navicat 可视化管理

SQL命令操作

用户表：mysql.user

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

-- 创建用户 CREATE USER 用户名 IDENTIFIED BY '密码'CREATE USER xiaoshu IDENTIFIED BY '123456'-- 修改密码(修改当前用户密码)SET PASSWORD=PASSWORD('123456')-- 修改密码(修改指定用户密码)SET PASSWORD FOR xiaoshu = PASSWORD('123456')-- 重命名 RENAME USER 原名字 TO 新名字RENAME USER xiaoshu TO XIAOSHU-- 用户授权  ALL PRIVILEGES：全部的权限，库.表;除了给别人授权，其他都能干GRANT ALL PRIVILEGES ON *.* TO XIAOSHU-- 查看权限SHOW GRANTS FOR XIAOSHU  -- GRANT ALL PRIVILEGES ON *.* TO 'XIAOSHU'@'%'  查看指定用户的权限SHOW GRANTS FOR root@localhost   -- GRANT PROXY ON ''@'' TO 'root'@'localhost' WITH GRANT OPTION   root用户的权限-- 撤销权限 REVOKE  撤销哪些权限，在哪个库撤销，给谁撤销REVOKE ALL PRIVILEGES ON *.* FROM XIAOSHU-- 删除用户DROP USER XIAOSHU

8.2 MySQL备份

为什么要备份：

• 保证重要的数据不丢失
• 数据转移 A——>B

MySQL数据库备份的方式：

• 直接拷贝物理文件

• 在可视化工具中转储SQL文件

• 使用命令行导出 mysqldump cmd命令行中使用

  # mysqldump -h主机 -u用户名 -p密码 数据库 表名 >物理磁盘位置/文件名.sql     -- 备份一张表C:\Users\kevin>mysqldump -hlocalhost -uroot -p123456 school student >D:a.sqlmysqldump: [Warning] Using a password on the command line interface can be insecure.# mysqldump -h主机 -u用户名 -p密码 数据库 表1 表2 表3 >物理磁盘位置/文件名.sql    -- 备份多张表# mysqldump -h主机 -u用户名 -p密码 数据库 >物理磁盘位置/文件名.sql    -- 备份数据库#导入数据库#在登录的情况下，切换到指定的数据库#source 备份文件source D:/a.sql

作用：

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

• 把数据库给朋友，直接给sql文件即可！

9、规范数据库设计

9.1 如何设计一个项目的数据库

为什么需要设计

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

糟糕的数据库设计

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

良好的数据库设计

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

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

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

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

• 收集信息，分析需求
  • 用户表（用户登录注销，用户的个人信息，写博客，创建分类）
  • 分类表（文章分类，谁创建的）
  • 文章表（文章信息）
  • 评论表
  • 友链表（友情链接信息）
  • 自定义表（系统信息，某个关键的字，或者一些主字段） key:value
  • 关注表(粉丝数)
  • 说说表（发表心情， id…content…create_time）
• 标识实体（把需求落到每个字段）
• 标识实体之间的关系
  • 写博客：user --> blog
  • 创建分类：user --> category
  • 关注：user --> user
  • 友链：links
  • 评论：user --> user --> blog

(bbs / crm)

前端组件：element UI、Ant Design Pro（适合个人博客）

9.2 数据库三大范式

为什么需要数据规范化？

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

三大范式

第一范式（1NF）

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

第二范式（2NF）

前提：满足第一范式

第二范式需要确保数据库表中的每一列都和主键相关，而不能只与主键的某一部分相关（主要针对联合主键而言）。

每张表只描述一件事情

第三范式（3NF）

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

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

规范数据库的设计

规范性和性能的问题

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

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

10、JDBC

10.1 数据库驱动

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

10.2 JDBC

SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（java操作数据库的）规范，俗称JDBC；Java数据库连接，（Java Database Connectivity，简称JDBC）。

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

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

需要的包：

java.sql包

javax.sql包

还需要导入一个数据库驱动包 mysql-connector-java-5.1.47.jar

10.3 第一个JDBC程序

创建测试数据库

-- 创建学习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,'张三','123456','zs@sina.com','1980-12-04'),(2,'李四','123456','lisi@sina.com','1981-12-04'),(3,'王五','123456','wangwu@sina.com','1982-12-04');

1. 创建一个普通项目
2. 导入数据库驱动（jar包）

3. 编写测试代码

//jdbc程序public class jdbcdemo1 {    public static void main(String[] args) throws ClassNotFoundException, SQLException {        //1.加载驱动        Class.forName("com.mysql.cj.jdbc.Driver");   //固定写法，加载驱动        //2、用户信息和url  useSSL=true:使用安全连接  serverTimezone=UTC:设置时区，不然会报时区错误        //String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTC";        String username = "root";        String password = "123456";        //3、连接成功，返回数据库对象  Connection：代表数据库        Connection connection = DriverManager.getConnection(url, username, password);        //4.执行SQL的对象  Statement:执行SQL的对象        Statement statement = connection.createStatement();        //5.使用  执行SQL的对象  去执行SQL，可能存在结果，查看返回结果        String sql = "select * from users";        //查询：executeQuery()   更新：executeUpdate()    所有的删除和插入都叫更新：executeUpdate()        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("pwd ="+resultSet.getObject("password"));            System.out.println("email ="+resultSet.getObject("email"));            System.out.println("birthday ="+resultSet.getObject("birthday"));            System.out.println("========================================");        }        //6.释放连接        resultSet.close();        statement.close();        connection.close();    }}

步骤总结：

1. 加载驱动
2. 连接数据库DriverManager
3. 获取执行SQL的对象 Statement
4. 获得返回的结果集
5. 释放连接

10.4 名词解释

DriverManager

//1.加载驱动//DriverManager.registerDriver(new com.mysql.jdbc.Driver());//推荐这种写法加载驱动Class.forName("com.mysql.cj.jdbc.Driver");Connection connection = DriverManager.getConnection(url, userName, passWord);// connection代表数据库// 数据库设置自动提交// 事务提交// 事务回滚connection.setAutoCommit(true);connection.commit();connection.rollback();

URL

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

Statement 执行sql对象 、 PreparedStatement 执行sql对象

String sql = "SELECT * FROM users";//编写SQLstatement.executeQuery();//执行查询 返回ResultSetstatement.executeUpdate();//新增，删除，修改，都用这个，返回受影响的行数statement.execute();//执行任何SQL

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

获得指定的数据类型

//在不知道列类型的情况下使用resultSet.getObject();//如果知道列类型，就使用指定的类型resultSet.getString();resultSet.getInt();resultSet.getDouble();resultSet.getBigDecimal();resultSet.getFloat();resultSet.getDate();//...

遍历，指针

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

释放资源

resultSet.close();statement.close();connection.close();//不关闭则会占用内存，消耗资源

10.5 statement对象

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

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的SQL语句，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

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

CRUD操作-update

Statement statement = connection.createStatement();String sql = "update user set name='' where name =''";int num = statement.executeUpdate(sql);if (num > 0) {    System.out.println("修改成功~");}

CRUD操作-read

Statement statement = connection.createStatement();String sql = "SELECT * FROM users";ResultSet resultSet = statement.executeQuery(sql);while (resultSet.next()) {    //根据获取列的数据类型，分别调用resultSet的相应方法映射到java对象中}

代码实现

1. 提取工具类

   import java.io.IOException;import java.io.InputStream;import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;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");            //驱动只用加载一次            Class.forName(driver);        } catch (IOException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        }    }        public static Connection getConnection() throws SQLException {        return DriverManager.getConnection(url, username, password);    }        public static void release(Connection con, 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 (con != null) {            try {                con.close();            } catch (SQLException e) {                e.printStackTrace();            }        }    }}

   driver=com.mysql.cj.jdbc.Driverurl=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTCusername=rootpassword=123456

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

   import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class TestInsert {    public static void main(String[] args) {        Connection con = null;        Statement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            st = con.createStatement();            String sql = "INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`)\n" +                    "VALUES (5,'钱七','123456','qianqi@sina.com','1988-12-04')";            int num = st.executeUpdate(sql);            if (num > 0) {                System.out.println("插入成功！");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils.release(con, st, rs);        }    }}

   import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class TestDelete {    public static void main(String[] args) {        Connection con = null;        Statement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            st = con.createStatement();            String sql = "DELETE FROM users WHERE `id`=5";            int num = st.executeUpdate(sql);            if (num > 0) {                System.out.println("删除成功！");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils.release(con, st, rs);        }    }}

   import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class TestUpdate {    public static void main(String[] args) {        Connection con = null;        Statement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            st = con.createStatement();            String sql = "UPDATE users SET birthday='1990-12-01' WHERE id=1";            int num = st.executeUpdate(sql);            if (num > 0) {                System.out.println("更新成功！");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils.release(con, st, rs);        }    }}

3. 查询

   import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class TestQuery {    public static void main(String[] args) {        Connection con = null;        Statement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            st = con.createStatement();            String sql = "SELECT * FROM users WHERE id=1";            rs = st.executeQuery(sql);            while (rs.next()) {                System.out.println("id="+rs.getInt("id"));                System.out.println("name="+rs.getString("name"));            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils.release(con, st, rs);        }    }}

10.6 SQL注入

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

import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;//SQL注入public class SQLInjection {    public static void main(String[] args) {        //正常登录        //login("张三","123456");        //SQL注入        login(" 'or '1=1"," ' or '1=1");   //技巧    }    //登录业务    public static void login(String username,String password){        Connection con = null;        Statement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            st = con.createStatement();            //SELECT * FROM users WHERE `name`='张三' AND `password`='123456';            //SELECT * FROM users WHERE `name`=' ' or '1=1' AND `password`='' or '1=1';  `name`=' ' or '1=1':name为空或者1=1永远为true            String sql = "SELECT * FROM users WHERE name ='"+username+"' AND `password`='"+password+"'";            rs = st.executeQuery(sql);            while (rs.next()) {                System.out.println("name="+rs.getString("name"));                System.out.println("password="+rs.getString("password"));                System.out.println("===================================");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils.release(con, st, rs);        }    }}

10.7 PreparedStatement对象

PreparedStatement可以防止SQL注入，并且效率更高！

1. 新增

package com.kmu.shu.preparedstatement;import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.Date;import java.sql.PreparedStatement;import java.sql.SQLException;public class TestInsert {    public static void main(String[] args) {        Connection coon = null;        PreparedStatement st = null;        try {            coon = JDBCUtils.getConnection();            //区别:使用 ？ 占位符代替参数            String sql = "INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`) VALUES(?,?,?,?,?)";            st = coon.prepareStatement(sql);   //预编译SQL，先写sql然后不执行            //手动给参数赋值            st.setInt(1,4);  //id            st.setString(2,"小舒");  //name            st.setString(3,"123456");  //password            st.setString(4,"666666@qq.com");  //email            //注意：new java.sql.Date(new java.util.Date().getTime())                        st.setDate(5,new Date(new java.util.Date().getTime()));  //birthday            //执行            int i = st.executeUpdate();            if(i>0){                System.out.println("插入成功！");            }        } catch (SQLException throwables) {            throwables.printStackTrace();        } finally {            JDBCUtils.release(coon,st,null);        }    }}

2. 删除

package com.kmu.shu.preparedstatement;import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;public class TestDelete {    public static void main(String[] args) {        Connection coon = null;        PreparedStatement st = null;        try {            coon = JDBCUtils.getConnection();            //区别:使用 ？ 占位符代替参数            String sql = "delete from users where id=?";            st = coon.prepareStatement(sql);   //预编译SQL，先写sql然后不执行            //手动给参数赋值            st.setInt(1,4);            //执行            int i = st.executeUpdate();            if(i>0){                System.out.println("删除成功！");            }        } catch (SQLException throwables) {            throwables.printStackTrace();        } finally {            JDBCUtils.release(coon,st,null);        }    }}

3. 更新

package com.kmu.shu.preparedstatement;import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;public class TestUpdate {    public static void main(String[] args) {        Connection coon = null;        PreparedStatement st = null;        try {            coon = JDBCUtils.getConnection();            //区别:使用 ？ 占位符代替参数            String sql = "update users set `name` = ?  where id =? ;";            st = coon.prepareStatement(sql);   //预编译SQL，先写sql然后不执行            //手动给参数赋值            st.setString(1,"小舒");            st.setString(2,"1");            //执行            int i = st.executeUpdate();            if(i>0){                System.out.println("更新成功！");            }        } catch (SQLException throwables) {            throwables.printStackTrace();        } finally {            JDBCUtils.release(coon,st,null);        }    }}

4. 查询

package com.kmu.shu.preparedstatement;import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class TestQuery {    public static void main(String[] args) {        Connection coon = null;        PreparedStatement st = null;        ResultSet rs = null;        try {             coon = JDBCUtils.getConnection();             String sql = "select * from users where id=?";             st = coon.prepareStatement(sql);             st.setInt(1,1);            rs = st.executeQuery();            if(rs.next()){                System.out.println(rs.getString("name"));            }        } catch (SQLException throwables) {            throwables.printStackTrace();        }finally {            JDBCUtils.release(coon,st,rs);        }    }}

5. 防止SQL注入

package com.kmu.shu.preparedstatement;import com.kmu.shu.utils.JDBCUtils;import java.sql.*;//SQL注入public class SQLInjection {    public static void main(String[] args) {        //正常登录        //login("李四","123456");        //SQL注入        login("'' or 1=1","123456");   //技巧    }    //登录业务    public static void login(String username,String password){        Connection coon = null;        PreparedStatement st = null;        ResultSet rs = null;        try {            coon = JDBCUtils.getConnection();            //PreparedStatement 防止SQL注入的本质，传递进来的参数当做字符            //假设其中存在转义字符就直接忽略，比如说 ' 会被直接转义            String sql = "SELECT * FROM users WHERE `name` =? and password =?";            st = coon.prepareStatement(sql);            st.setString(1,username);            st.setString(2,password);            rs = st.executeQuery();            while (rs.next()) {                System.out.println("name="+rs.getString("name"));                System.out.println("password="+rs.getString("password"));                System.out.println("===================================");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils.release(coon, st, rs);        }    }}

11、使用IDEA连接数据库

1. 打开IDEA

   

2. 点击测试连接

   

3. 出现成功即可

   

   4. 成功后可以选择数据源

      

   5. 编写SQL

      

   6. 切换数据库

      

   7. 执行SQL

      -- 创建账户表create table account(    id    int primary key auto_increment,    name  varchar(40),    money float);insert into account(name, money)values ('A', 1000),       ('B', 1000),       ('C', 1000);

   8. 注意：若测试连接不成功，则可能是没有导入mysql-connector-java-8.0.11.jar包

      

   9. 驱动程序尽量不要去改，如果版本不对则修改为数据库对应的版本驱动

      

12、JDBC操作事务

要么都成功，要么都失败

ACID原则

原子性：要么全部成功，要么全部失败

一致性：总数不变

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

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

隔离性的问题：

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

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

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

代码实现

1. 开启事务con.setAutoCommit(false);

2. 一组业务执行完毕，提交事务

3. 可以在catch语句中显示的定义回滚语句，但是默认失败就会回滚

• 正常情况

  import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class TestTransaction1 {    public static void main(String[] args) {        Connection con = null;        PreparedStatement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            //关闭自动提交 自动会开启事务            con.setAutoCommit(false);//开启事务            // A 转 B 100元            String sql1 = "update account set money=money-100 where name='A'";            st = con.prepareStatement(sql1);            st.executeUpdate();            String sql2 = "update account set money=money+100 where name='B'";            st = con.prepareStatement(sql2);            st.executeUpdate();            //业务完毕，提交事务            con.commit();            System.out.println("A 转 B 100元 成功！");        } catch (SQLException e) {            e.printStackTrace();            try {                con.rollback();   //如果失败就回滚事务            } catch (SQLException ex) {                ex.printStackTrace();            }        } finally {            JDBCUtils.release(con, st, rs);        }    }}

• 异常情况

  import com.kmu.shu.utils.JDBCUtils;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class TestTransaction2 {    public static void main(String[] args) {        Connection con = null;        PreparedStatement st = null;        ResultSet rs = null;        try {            con = JDBCUtils.getConnection();            //关闭自动提交 自动会开启事务            con.setAutoCommit(false);//开启事务            // A 转 B 100元            String sql1 = "update account set money=money-100 where name='A'";            st = con.prepareStatement(sql1);            st.executeUpdate();            //int x=1/0;   //报错            String sql2 = "update account set money=money+100 where name='B'";            st = con.prepareStatement(sql2);            st.executeUpdate();            //业务完毕，提交事务            con.commit();            System.out.println("A 转 B 100元 成功！");        } catch (SQLException e) {            //如果失败则会默认回滚            e.printStackTrace();                    } finally {            JDBCUtils.release(con, st, rs);        }    }}

13、数据库连接池

数据库连接 – 执行完毕 – 释放

连接-- 释放 是十分浪费系统资源的

池化技术：准备一些预先的资源，过来就连接预先准备好的

最小连接数：10(常用连接)

最大连接数：100 （业务最高承载上线）

等待超时：100ms

编写连接池，实现一个接口DataSource

开源数据源实现

DBCP

C3p0

Druid:阿里巴巴

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

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

DBCP

需要用到的jar包

commons-dbcp-1.4

commons-pool-1.6

1. 配置文件dbcp.properties

   #连接设置driverClassName=com.mysql.cj.jdbc.Driverurl=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTCusername=rootpassword=123456#初始化连接initialSize=10#最大连接数量maxActive=50#最大空闲连接maxIdle=20#最小空闲连接minIdle=5#超时等待时间以毫秒为单位 6000毫秒/1000等于60秒maxWait=60000#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】#注意：user 与 password 两个属性会被明确地传递，因此这里不需要包含他们。connectionProperties=useUnicode=true;characterEncoding=UTF8#指定由连接池所创建的连接的自动提交（auto-commit）状态。defaultAutoCommit=true#driver default 指定由连接池所创建的连接的只读（read-only）状态。#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）defaultReadOnly=#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLEdefaultTransactionIsolation=READ_COMMITTED

2. 编写工具类

   import org.apache.commons.dbcp.BasicDataSourceFactory;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 JDBCUtils_DBCP {    private static DataSource dataSource = null;    static {        try {            InputStream in = JDBCUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcp.properties");            Properties properties = new Properties();            properties.load(in);            //创建数据源 工厂模式            dataSource = BasicDataSourceFactory.createDataSource(properties);        } catch (IOException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        } catch (Exception e) {            e.printStackTrace();        }    }        public static Connection getConnection() throws SQLException {        //从数据源中获取连接        return dataSource.getConnection();    }        public static void release(Connection con, 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 (con != null) {            try {                con.close();            } catch (SQLException e) {                e.printStackTrace();            }        }    }}

3. 编写测试类

import com.kmu.shu.utils.JDBCUtils_DBCP;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class TestDBCP {    public static void main(String[] args) {        Connection con = null;        PreparedStatement st = null;        ResultSet rs = null;        try {            con = JDBCUtils_DBCP.getConnection();            //使用?占位符代替参数            String sql = "delete from users where id=?";            //预编译SQL，先写SQL，然后不执行            st = con.prepareStatement(sql);            //手动给参数赋值            st.setInt(1, 4);            int num = st.executeUpdate();            if (num > 0) {                System.out.println("删除成功！");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils_DBCP.release(con, st, rs);        }    }}

C3P0

需要用到的jar包

c3p0-0.9.5.5.jar

mchange-commons-java-0.2.19.jar

1. 配置文件c3p0-config.xml（文件名必须为:c3p0-config.xml，否则测试类将运行不成功！）

                   com.mysql.cj.jdbc.Driver        jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTC        root        123456        5        10        5        20                com.mysql.cj.jdbc.Driver        jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTC        root        123456        5        10        5        20    

2. 编写工具类

   import com.mchange.v2.c3p0.ComboPooledDataSource;import javax.sql.DataSource;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class JDBCUtils_C3P0 {    private static DataSource dataSource =null;    //private static ComboPooledDataSource dataSource = null;    static {        try {            //代码的方式配置//            dataSource = new ComboPooledDataSource();//            dataSource.setDriverClass();//            dataSource.setJdbcUrl();//            dataSource.setUser();//            dataSource.setPassword();//            dataSource.setMaxPoolSize();//            dataSource.setMinPoolSize();            //配置文件写法            dataSource = new ComboPooledDataSource();        } catch (Exception e) {            e.printStackTrace();        }    }        public static Connection getConnection() throws SQLException {        //从数据源中获取连接        return dataSource.getConnection();    }        public static void release(Connection con, 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 (con != null) {            try {                con.close();            } catch (SQLException e) {                e.printStackTrace();            }        }    }}

3. 编写测试类

   import com.kmu.shu.utils.JDBCUtils_C3P0;import java.sql.*;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class TestC3P0 {    public static void main(String[] args) {        Connection con = null;        PreparedStatement st = null;        ResultSet rs = null;        try {            con = JDBCUtils_C3P0.getConnection();            //使用?占位符代替参数            String sql = "INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`) VALUES (?,?,?,?,?)";            //预编译SQL，先写SQL，然后不执行            st = con.prepareStatement(sql);            //手动给参数赋值            st.setInt(1, 3);            st.setString(2, "刘八");            st.setString(3, "123456");            st.setString(4, "liuba@sina.com");            st.setDate(5, new Date(new java.util.Date().getTime()));            int num = st.executeUpdate();            if (num > 0) {                System.out.println("插入成功！");            }        } catch (SQLException e) {            e.printStackTrace();        } finally {            JDBCUtils_C3P0.release(con, st, rs);        }    }}

总结

无论用什么数据源，本质还是一样的，DataSource接口不会变，方法就不会变

来源地址：https://blog.csdn.net/weixin_51497502/article/details/126076346