JDBC基础

最新推荐文章于 2023-07-20 18:59:52 发布

凤凰AI

最新推荐文章于 2023-07-20 18:59:52 发布

阅读量693

点赞数 1

分类专栏：数据库文章标签： java 数据库 mysql

本文链接：https://blog.csdn.net/Daniel_Singularity/article/details/130579642

版权

数据库专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、JDBC概述

在开发中使用的是java语言，那么势必要通过java语言操作数据库中的数据。这就是接下来要学习的JDBC。

1.1 JDBC概念

JDBC 就是使用Java语言操作关系型数据库的一套API

全称：( Java DataBase Connectivity ) Java 数据库连接

我们开发的同一套Java代码是无法操作不同的关系型数据库，因为每一个关系型数据库的底层实现细节都不一样。如果这样，问题就很大了，在公司中可以在开发阶段使用的是MySQL数据库，而上线时公司最终选用oracle数据库，我们就需要对代码进行大批量修改，这显然并不是我们想看到的。我们要做到的是同一套Java代码操作不同的关系型数据库，而此时sun公司就指定了一套标准接口（JDBC），JDBC中定义了所有操作关系型数据库的规则。众所周知接口是无法直接使用的，我们需要使用接口的实现类，而这套实现类（称之为：驱动）就由各自的数据库厂商给出。

1.2 JDBC本质

官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口
各个数据库厂商去实现这套接口，提供数据库驱动jar包
我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

1.3 JDBC好处

各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
可随时替换底层数据库，访问数据库的Java代码基本不变

以后编写操作数据库的代码只需要面向JDBC（接口），操作哪儿个关系型数据库就需要导入该数据库的驱动包，如需要操作MySQL数据库，就需要再项目中导入MySQL数据库的驱动包。如下图就是MySQL驱动包

2、JDBC快速入门

先来看看通过Java操作数据库的流程

第一步：编写Java代码
第二步：Java代码将SQL发送到MySQL服务端
第三步：MySQL服务端接收到SQL语句并执行该SQL语句
第四步：将SQL语句执行的结果返回给Java代码

2.1 步骤分析

2.2 环境搭建

创建一个新工程：day03-jdbc

定义项目的名称，并指定位置，工程名称规范一些，时间长了不好管理的。

对项目进行设置，JDK版本、编译版本

导入驱动包：将mysql的驱动包放在工程下的lib目录（随意命名，建议用lib）下，并将该jar包添加为库文件

在添加为库文件的时候，有如下三个选项，选 Project Library。这个区别不大
- Global Library ：全局有效
- Project Library : 项目有效
- Module Library ：模块有效

在 src 下创建 com.itheima.jdbc.JdbcDemo1 类

2.3 完整代码

package com.itheima.jdbc;

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

/**
 * JDBC入门案例 步骤：
 * ***** 1.注册驱动，告诉程序使用哪个jar包
 * ***** 2.获取连接
 * ***** 3.获取执行SQL语句的执行者对象
 * ***** 4.执行SQL语句
 * ***** 5.处理结果
 * ***** 6.释放资源
 */
public class JdbcDemo01 {

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

        //2 获取连接
        String url = "jdbc:mysql://localhost:3306/db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("update account set money=1000 where id=1");

        //4 执行SQL语句
        int count = ps.executeUpdate();

        //5 处理结果
        System.out.println("影响的行数 " + count);

        //6 释放资源
        ps.close();
        conn.close();
    }
}

3、JDBC API详解

3.1 DriverManager 对象

DriverManager（驱动管理类）

3.1.1 作用一：注册驱动

registerDriver方法是用于注册驱动的，但是我们之前做的入门案例并不是这样写的。而是如下实现

Class.forName("com.mysql.jdbc.Driver");

我们查询MySQL提供的Driver类，看它是如何实现的，源码如下：

在该类中的静态代码块中已经执行了 DriverManager 对象的 registerDriver() 方法进行驱动的注册了，那么我们只需要加载 Driver 类，该静态代码块就会执行。而 Class.forName("com.mysql.jdbc.Driver"); 就可以加载 Driver 类。

==提示：==

MySQL 5之后的驱动包，可以省略注册驱动的步骤

自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类

3.1.2 作用二：获取数据库连接

参数说明：

url ：连接路径

语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…

示例：jdbc:mysql://127.0.0.1:3306/db1

==细节：==

如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对

配置 useSSL=false 参数，禁用安全连接方式，解决警告提示

user ：用户名

poassword ：密码

3.1.3 代码实现

package com.itheima.jdbc;

import com.mysql.jdbc.Driver;

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

/**
 * DriverManager 对象详解
 */
public class JdbcDemo02_DriverManager {

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存
        DriverManager.registerDriver(new Driver());   //会注册两次

        //2 获取连接
        //String url="jdbc:mysql://localhost:3306/d2?useSSL=false";
        //连接本地数据库，url可以简写，省略localhost:3306
        String url = "jdbc:mysql:///db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("update account set money=1000 where id=1");

        //4 执行SQL语句
        int count = ps.executeUpdate();

        //5 处理结果
        System.out.println("影响的行数 " + count);

        //6 释放资源
        ps.close();
        conn.close();
    }
}

3.2 Connection 对象

Connection（数据库连接对象）

3.2.1 作用一：获取执行SQL对象

普通执行SQL对象
```
Statement createStatement()
```

预编译SQL的执行SQL对象：防止SQL注入
```
PreparedStatement  prepareStatement(sql)
```
通过这种方式获取的 PreparedStatement SQL语句执行对象是我们重点要进行讲解的，它可以防止SQL注入。

执行存储过程的对象

CallableStatement prepareCall(sql)

通过这种方式获取的 CallableStatement 执行对象是用来执行存储过程的，而存储过程在MySQL中不常用，所以这个我们将不进行讲解。

3.2.2 作用二：事务管理

先回顾一下MySQL事务管理的操作：

开启事务： BEGIN; 或者 START TRANSACTION;
提交事务： COMMIT;
回滚事务： ROLLBACK;

MySQL默认是自动提交事务

接下来学习JDBC事务管理的方法。Connection几口中定义了3个对应的方法：

开启事务

- 参与autoCommit 表示是否自动提交事务，true表示自动提交事务，false表示手动提交事务。而开启事务需要将该参数设为为false。
提交事务

回滚事务

3.2.3 代码实现

package com.itheima.jdbc;

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

/**
 * Connection 对象详解
 */
public class JdbcDemo03_Connection {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

        //2 获取连接
        String url = "jdbc:mysql://localhost:3306/db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);
        PreparedStatement ps1 = null;
        PreparedStatement ps2 = null;
        //ctrl+alt+t
        try {
            // ============开启事务==========
            conn.setAutoCommit(false);
            //需求：事务管理：  张三向李四借500元
            //3 获取执行SQL语句的执行者对象
            ps1 = conn.prepareStatement("update account set money=money-500 where id=2");
            ps2 = conn.prepareStatement("update account set money=money+500 where id=1");
            //4 执行SQL语句
            ps1.executeUpdate();
            int i = 1 / 0;  //制造异常
            ps2.executeUpdate();
            // ============提交事务==========
            //程序运行到此处，说明没有出现任何问题，则需求提交事务
            conn.commit();
        } catch (Exception ex) {   //出现任何异常都要回滚
            ex.printStackTrace();
            // ============回滚事务==========
            //程序在出现异常时会执行到这个地方，此时就需要回滚事务
            conn.rollback();
        }
        //5 释放资源
        ps1.close();
        ps2.close();
        conn.close();
    }
}

3.3 PreparedStatement 对象

PreparedStatement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。

3.3.1 作用一：执行DML语句

3.3.2 作用二：执行DQL语句

该方法涉及到了 ResultSet 对象，而这个对象我们还没有学习，一会再重点讲解。

3.3.3 PreparedStatement 动态传参

获取 PreparedStatement 对象

// SQL语句中的参数值，使用？占位符替代
String sql = "select * from user where username = ? and password = ?";
// 通过Connection对象获取，并传入对应的sql语句
PreparedStatement pstmt = conn.prepareStatement(sql);

设置参数值

上面的sql语句中参数使用 ? 进行占位，在之前之前肯定要设置这些 ? 的值。
PreparedStatement对象：setXxx(参数1，参数2)：给 ? 赋值
- Xxx：数据类型；如 setInt (参数1，参数2)
- 参数：
  - 参数1：？的位置编号，从1 开始
  - 参数2：？的值
执行SQL语句

executeUpdate(); 执行DDL语句和DML语句

executeQuery(); 执行DQL语句

==注意：==调用这两个方法时不需要传递SQL语句，因为获取SQL语句执行对象时已经对SQL语句进行预编译了。

3.3.4 代码实现

package com.itheima.jdbc;

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

/**
 * PreparedStatement 对象详解
 */
public class JdbcDemo04_PreparedStatement {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

        //2 获取连接
        String url = "jdbc:mysql://localhost:3306/db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3 获取执行SQL语句的执行者对象
        //3.1 在SQL语句中使用?作为参数的占位符
        PreparedStatement ps = conn.prepareStatement("update account set money=? where id=?");
        //3.2 给SQL中的？设置参数值
        ps.setDouble(1, 3000);  //参数1表示第几个?。参数2表示给?设置的值
        ps.setInt(2, 2);

        //4 执行SQL语句
        int count = ps.executeUpdate();
        System.out.println("影响的行数 " + count);

        //6 释放资源
        ps.close();
        conn.close();
    }
}

3.4 ResultSet 对象

ResultSet（结果集对象）作用：封装了SQL查询语句的结果。而执行了DQL语句后就会返回该对象，对应执行DQL语句的方法如下：

ResultSet  executeQuery(sql)：执行DQL 语句，返回 ResultSet 对象

那么我们就需要从 ResultSet 对象中获取我们想要的数据。ResultSet 对象提供了操作查询结果数据的方法。

3.4.1 作用一：获取下一行数据

boolean next()

将光标从当前位置向前移动一行

判断当前行是否为有效行

方法返回值说明：

true ：有效航，当前行有数据

false ：无效行，当前行没有数据

3.4.2 作用二：获取某一列的值

xxx getXxx(参数)：获取数据

xxx : 数据类型；如： int getInt(参数) ；String getString(参数)

参数

int类型的参数：列的编号，从1开始

String类型的参数：列的名称

如下图为执行SQL语句后的结果

一开始光标指定于第一行前，如图所示红色箭头指向于表头行。当我们调用了 next() 方法后，光标就下移到第一行数据，并且方法返回true，此时就可以通过 getInt("id") 获取当前行id字段的值，也可以通过 getString("name") 获取当前行name字段的值。如果想获取下一行的数据，继续调用 next() 方法，以此类推。

3.4.2 代码实现

package com.itheima.jdbc;

import java.sql.*;

/**
 * ResultSet 对象详解
 */
public class JdbcDemo05_ResultSet {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

        //2 获取连接
        String url = "jdbc:mysql://localhost:3306/db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("select * from account");

        //4 执行SQL语句
        ResultSet rs = ps.executeQuery();   //结果集

        //5 处理结果，遍历获取结果
        while (rs.next()) {  //返回true表示有数据
            //获取每一行的数据
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");
            System.out.println(id + "," + name + "," + money);
        }

        //6 释放资源
        ps.close();
        conn.close();
        rs.close();
    }
}

4、JDBC练习

4.1 需求：商品品牌管理

完成商品品牌数据的增删改查操作

查询：查询所有数据

添加：添加品牌

修改：根据id修改

删除：根据id删除

4.2 案例功能实现

4.2.1 环境准备

数据库 db2

create database if not exists db2;

数据库表 tb_brand

use db2;
-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand (
    -- id 主键
    id int primary key auto_increment,
    -- 品牌名称
    brand_name varchar(20),
    -- 企业名称
    company_name varchar(20),
    -- 排序字段
    ordered int,
    -- 描述信息
    description varchar(100),
    -- 状态：0：禁用  1：启用
    status int
);
-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);

在 com.itheima.pojo 包下实体类 Brand

为什么要创建一个实体Brand类？因为将来要操作tb_brand表，数据封装会方便一些。

package com.itheima.pojo;

/**
 * 品牌
 * alt + 鼠标左键：整列编辑
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
public class Brand {

    private int id; //主键
    private String brandName; //品牌名称
    private String companyName; //公司名称
    private int ordered; //排序
    private String description; //描述
    private int status; //状态

    //省略 set、get方法
}

4.2.2 查询所有品牌

我们需要先创建一个 BrandDao 的类，后续在类中添加增删改查的方法

4.2.2.1 编写BrandDao的selectAll方法

/**
 * dao：表示数据访问层，这一层的代码将来都是和数据库打交道的。
 * 也就是说，这个类中将来会提供很多方法，这些方法都是做增删改查的。
 * 其他类调用方式如下：
 *      BrandDao brandDao=new BrandDao();
 *      brandDao.xxxx方法(参数);
 */
public class BrandDao {

    /**
       * 查询所有
       * 1. SQL：select * from tb_brand;
       * 2. 参数：不需要
       * 3. 结果：List<Brand>
       */
    public List<Brand> selectAll() throws Exception {
        //1 注册驱动，获取连接对象 Connection
        Class.forName("com.mysql.jdbc.Driver");
        String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
        String username="root";
        String password="root";
        Connection conn = DriverManager.getConnection(url,username,password);
        //2 定义SQL
        String sql="select * from tb_brand";
        //3 获取PreparedStatement对象，预编译SQL
        PreparedStatement pstmt = conn.prepareStatement(sql);
        //4 如果SQL用有？占位符，就设置参数
        //5 执行SQL，获取结果
        ResultSet rs = pstmt.executeQuery();
        //6 处理结果
        List<Brand> brands=new ArrayList<>();
        while (rs.next()){
            //6.1 获取每一行数据
            int id = rs.getInt("id");
            String brandName = rs.getString("brand_name");
            String companyName = rs.getString("company_name");
            int ordered = rs.getInt("ordered");
            String description = rs.getString("description");
            int status = rs.getInt("status");
            //6.2 封装成Brand对象
            Brand brand=new Brand();
            brand.setId(id);
            brand.setBrandName(brandName);
            brand.setCompanyName(companyName);
            brand.setOrdered(ordered);
            brand.setDescription(description);
            brand.setStatus(status);
            //6.3 保存到List集合中
            brands.add(brand);
        }
        //7 释放资源
        rs.close();
        pstmt.close();
        conn.close();
        //返回结果
        return brands;
    } 
}

4.2.2.2 编写测试类方法

/**
 * 测试品牌的增删改查操作
 */
public class BrandTest {

    /**
     * 测试查询所有品牌信息
     */
    @Test
    public void testSelectAll() throws Exception {
        //1 创建BrandDao对象
        BrandDao brandDao = new BrandDao();
        //2 调用方法，获取结果
        List<Brand> brandList = brandDao.selectAll();
        //3 打印结果
        brandList.forEach(brand -> System.out.println(brand));
    }
}

4.2.3 添加数据

4.2.3.1 编写BrandDao的add方法

/**
     * 添加品牌信息
     SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
     * @param brand 要添加的品牌对象
     * @return true表示添加成功，false表示添加失败
     */
public boolean add(Brand brand) throws Exception {
    //1 注册驱动，获取连接对象 Connection
    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
    String username="root";
    String password="root";
    Connection conn = DriverManager.getConnection(url,username,password);
    //2 定义SQL
    String sql="insert into tb_brand values(null,?,?,?,?,?)";
    //3 获取PreparedStatement对象，预编译SQL
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4 如果SQL用有？占位符，就设置参数
    pstmt.setString(1,brand.getBrandName());
    pstmt.setString(2,brand.getCompanyName());
    pstmt.setInt(3,brand.getOrdered());
    pstmt.setString(4,brand.getDescription());
    pstmt.setInt(5,brand.getStatus());
    //5 执行SQL，获取结果
    int count = pstmt.executeUpdate();
    //6 处理结果
    //boolean flag=count>0;
    //7 释放资源
    pstmt.close();
    conn.close();
    //返回结果
    return count>0;
}

4.2.3.2 编写测试类方法

@Test
public void testAdd() throws Exception {
    //1 创建BrandDao对象
    BrandDao brandDao = new BrandDao();
    //2 调用add方法
    Brand brand = new Brand();
    brand.setBrandName("鸿星尔克");
    brand.setCompanyName("鸿星尔克有限公司");
    brand.setOrdered(100);
    brand.setDescription("to be No.1");
    brand.setStatus(1);
    boolean flag = brandDao.add(brand);
    //3 打印结果
    System.out.println(flag ? "添加成功~" : "添加失败~");
}

4.2.4 修改数据

4.2.4.1 编写BrandDao的update方法

/**
     * 修改品牌信息
     SQL： update tb_brand
             set brand_name  = ?,
             company_name= ?,
             ordered     = ?,
             description = ?,
             status      = ?
         where id = ?
     * @param brand 要修改的品牌对象
     * @return true表示修改成功，false表示修改失败
     */
public boolean update(Brand brand) throws Exception {
    //1 注册驱动，获取连接对象 Connection
    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
    String username="root";
    String password="root";
    Connection conn = DriverManager.getConnection(url,username,password);
    //2 定义SQL
    String sql="update tb_brand set brand_name= ?,company_name=?,ordered= ?,description = ?,status= ? where id=?";
    //3 获取PreparedStatement对象，预编译SQL
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4 如果SQL用有？占位符，就设置参数
    pstmt.setString(1,brand.getBrandName());
    pstmt.setString(2,brand.getCompanyName());
    pstmt.setInt(3,brand.getOrdered());
    pstmt.setString(4,brand.getDescription());
    pstmt.setInt(5,brand.getStatus());
    pstmt.setInt(6,brand.getId());
    //5 执行SQL，获取结果
    int count = pstmt.executeUpdate();
    //6 处理结果
    //boolean flag=count>0;
    //7 释放资源
    pstmt.close();
    conn.close();
    //返回结果
    return count>0;
}

4.2.4.2 编写测试类代码

@Test
public void testUpdate() throws Exception {
    //1 创建BrandDao对象
    BrandDao brandDao = new BrandDao();
    //2 调用update方法
    Brand brand = new Brand();
    brand.setId(4);
    brand.setBrandName("海澜之家");
    brand.setCompanyName("海澜之家有限公司");
    brand.setOrdered(100);
    brand.setDescription("男人的衣柜");
    brand.setStatus(2);
    boolean flag = brandDao.update(brand);
    //3 打印结果
    System.out.println(flag ? "修改成功~" : "修改失败~");
}

4.2.5 删除数据

4.2.5.1 编写BrandDao的delete方法

/**
     * 删除品牌信息
     SQL：delete from tb_brand where id = ?
     * @param id 要删除的品牌id
     * @return true表示删除成功，false表示删除失败
     */
public boolean delete(int id) throws Exception {
    //1 注册驱动，获取连接对象 Connection
    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
    String username="root";
    String password="root";
    Connection conn = DriverManager.getConnection(url,username,password);
    //2 定义SQL
    String sql="delete from tb_brand where id=?";
    //3 获取PreparedStatement对象，预编译SQL
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4 如果SQL用有？占位符，就设置参数
    pstmt.setInt(1,id);
    //5 执行SQL，获取结果
    int count = pstmt.executeUpdate();
    //6 处理结果
    //boolean flag=count>0;
    //7 释放资源
    pstmt.close();
    conn.close();
    //返回结果
    return count>0;
}

4.2.5.2 编写测试类代码

@Test
public void testDelete() throws Exception {
    //1 创建BrandDao对象
    BrandDao brandDao = new BrandDao();
    //2 调用delete方法
    boolean flag = brandDao.delete(4);
    //3 打印结果
    System.out.println(flag ? "删除成功~" : "删除失败~");
}

5、数据库连接池

5.1 数据库连接池简介

数据库连接池是个容器，负责分配、管理数据库连接(Connection)

它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；

资源重用

提升系统响应速度

之前我们代码中使用连接是没有使用都创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。
而数据库使用了数据库连接池后，就能达到Connection对象的复用，如下图

连接池是在一开始就创建好了一些连接（Connection）对象存储起来。用户需要连接数据库时，不需要自己创建连接，而只需要从连接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连接池；这样就可以起到资源重用，也节省了频繁创建连接销毁连接所花费的时间，从而提升了系统响应的速度。

5.2 数据库连接池实现

标准接口：==DataSource==
- 官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能：
- 那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象。
```
Connection getConnection()
```
常见的数据库连接池，我们现在使用更多的是Druid，它的性能比其他两个会好一些。
- DBCP
- C3P0
- Druid
Druid（德鲁伊）
- Druid连接池是阿里巴巴开源的数据库连接池项目
- 功能强大，性能优秀，是Java语言最好的数据库连接池之一

5.3 Driud使用

导入jar包 druid-1.1.12.jar

定义配置文件

加载配置文件

获取数据库连接池对象

获取连接

现在通过代码实现，首先需要先将druid的jar包放到项目下的lib下并添加为库文件

项目结构如下：

在 src 目录下，创建配置文件 druid.properties ，如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db2?useSSL=false&useServerPrepStmts=true
username=root
password=root
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

使用druid的代码如下：

package com.itheima.druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;

/**
 * Druid数据库连接池演示
 */
public class DruidDemo {

    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3. 加载配置文件
        Properties properties = new Properties();
        //读取文件，得到inputStream输入流
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        //加载数据
        properties.load(is);
        //4. 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

        //5. 获取数据库连接 Connection
        Connection conn = dataSource.getConnection();

        //6. 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("update account set money=1000 where id=1");

        //7. 执行SQL语句
        int count = ps.executeUpdate();

        //8. 处理结果
        System.out.println("影响的行数 " + count);

        //9. 归还连接到连接池
        ps.close();
        conn.close();
    }
}

凤凰AI

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
JDBC基础

在开发中使用的是java语言，那么势必要通过java语言操作数据库中的数据。这就是接下来要学习的JDBC。数据库连接池是个容器，负责分配、管理数据库连接(Connection)它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；资源重用提升系统响应速度之前我们代码中使用连接是没有使用都创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。而数据库使用了数据库连接池后，就能达到Connection对象的复用，如下图。
复制链接

扫一扫