数据库连接池

Posted 2022-12-04 超霸霸

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据库连接池相关的知识，希望对你有一定的参考价值。

数据库连接池

一、简介

概念：数据库连接池就是一个容器（集合），存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器
好处：
1. 节约资源
2. 用户访问高效
实现：
1. 标准接口：DataSource（javax.sql包下的）
  - 获取连接：getConnection()
  - 归还连接：Connection.close()，如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了，而是归还连接
2. 一般我们不去实现它，由数据库厂商来实现
  - C3P0：数据库连接池技术
  - Druid：数据库连接池实现技术，由阿里巴巴提供

二、C3P0：数据库连接池技术

步骤：
1. 导入jar包（两个）：c3p0-0.9.5.2.jar，mchange-commons-java-0.2.12.jar
  不要忘记导入数据库驱动jar包
2. 定义配置文件：
  - 名称：c3p0.properties 或者 c3p0.config.xml
  - 路径：直接将文件放在src目录下即可
3. 创建核心对象：数据库连接池对象 ComboPooledDataSource
4. 获取连接：getConnection

案例：

package cn.chao.web.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class c3p0Demo1 
    public static void main(String[] args) throws SQLException 
        //1.创建数据库连接池对象
        DataSource ds=new ComboPooledDataSource();
        //2.获取连接对象
        Connection connection=ds.getConnection();
        //3.打印
        System.out.println(connection);

三、Druid

步骤
1. 导入jar包：druid-1.0.9.jar
2. 定义配置文件
  - 是properties形式的
  - 可以叫任意名称，可以放在任意目录下
3. 加载配置文件Properti
4. 获取数据库连接池对象：通过工厂来获取对象，DruidDataSourceFactory
5. 获取连接：getConnection

案例：

package cn.chao.web.druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

public class druidDemo1 
    public static void main(String[] args) throws Exception 
        //1.导入jar包
        //2.打定配置文件
        //3.加载配置文件
        Properties pro=new Properties();
        InputStream is=druidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //5.获取连接
        Connection connection=ds.getConnection();
        System.out.println(connection);

四、druid工具类

定义工具类
1. 定义一个类JDBCUtils
2. 提供静态代码块加载配置文件，初始化连接池对象
3. 提供方法
  - 获取连接方法：提供数据库连接池获取连接
  - 释放资源
  - 获取连接池的方法

案例：
JDBCUtils2：

package cn.chao.web.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;


/**
 * JDBC工具类
 */
public class JDBCUtils2 

    //1.定义成员变量DataSource
    private static DataSource ds;

    static 
        try 
            //1.加载配置文件
            Properties pro=new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2.获取DataSource
            ds= DruidDataSourceFactory.createDataSource(pro);
         catch (IOException e) 
            e.printStackTrace();
         catch (Exception e) 
            e.printStackTrace();
        
    

    /**
     * 获取连接
     * @return
     */
    public static Connection getConnection() throws SQLException 
        return ds.getConnection();
    

    /**
     * 释放资源
     */
    public static void close(Statement stmt,Connection conn)
        if(stmt!=null)
            try 
                stmt.close();
             catch (SQLException throwables) 
                throwables.printStackTrace();
            
        
        if(conn!=null)
            try 
                conn.close();//归还连接
             catch (SQLException throwables) 
                throwables.printStackTrace();
            
        
    

    public static void close(ResultSet rs,Statement stmt, Connection conn) 
        if(rs!=null)
            try 
                rs.close();
             catch (SQLException throwables) 
                throwables.printStackTrace();
            
        

        if(stmt!=null)
            try 
                stmt.close();
             catch (SQLException throwables) 
                throwables.printStackTrace();
            
        
        if(conn!=null)
            try 
                conn.close();//归还连接
             catch (SQLException throwables) 
                throwables.printStackTrace();
            
        
    

    /**
     * 获取连接池方法
     */
    public static DataSource getDataSource()
        return ds;

druidDemo2：

package cn.chao.web.druid;

import cn.chao.web.utils.JDBCUtils2;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class druidDemo2 
    public static void main(String[] args) 
        Connection connection=null;
        PreparedStatement pstmt=null;
        try
            //1.获取连接
            connection= JDBCUtils2.getConnection();
            //2.定义sql
            String sql="insert into user values(null,?,?)";
            //3.获取pstmt对象
            pstmt=connection.prepareStatement(sql);
            //4.给?赋值
            pstmt.setString(1,"Wang");
            pstmt.setInt(2,222);
            //5.执行sql
            int cnt=pstmt.executeUpdate();
            System.out.println(cnt);

        catch (SQLException e)
            e.printStackTrace();
        finally 
            //释放资源
            JDBCUtils2.close(pstmt,connection);

五、Spring JDBC

概念：Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
1. 导入jar包
2. 创建JDBCTemplate对象，依赖于数据源DataSource
  - JDBCTemplate template =new JDBCTemplate(ds)
3. 调用JDBCTemplate的方法来完成CRUD的操作
  - update()：执行DML语句
  - queryForMap()：查询结果将结果集封装为map集合
    1. 将列名作为key，值作为value，将这条记录封装为一个map集合
    2. 这个方法查询的结果集长度只能是1
  - queryForList()：查询结果将结果封装为list集合
    1. 将每一条记录封装为一个map集合，再将map集合封装到list集合中
  - query()：查询结果，将结果封装为JavaBean对象
    1. 参数：RowMapper，一般我们使用BeanPropertyRowMapper实现类，可以完成数据到JavaBean的自动封装
    2. BeanPropertyRowMapper<类型>(类型.class)
  - queryForObject()：查询结果，将结果封装为对象
    1. 一般用于聚合函数的查询

案例：

修改表中的一条数据
添加一条记录
删除记录
查询数据并将其封装为Map集合
查询所有记录并将其封装为List
查询所有记录并将其封装为Emp对象的List集合
查询总记录数

package cn.chao.web.jdbctemplate;

import cn.chao.web.domain.person;
import cn.chao.web.utils.JDBCUtils2;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class jdbctemplateDemo2 
    private JdbcTemplate template=new JdbcTemplate(JDBCUtils2.getDataSource());
    //Junit单元测试，可以让方法独立执行

    /**
     * 修改数据
     */
    @Test
    public void f1()
        //2.定义sql
        String sql="update user set password = '123' where id = 2";
        //3.执行sql
        int cnt=template.update(sql);
        System.out.println(cnt);
    

    /**
     * 添加数据
     */
    @Test
    public void f2()
        //2.定义sql
        String sql="insert into user values(null,?,?)";
        //3.执行sql
        template.update(sql,"Qian","123");
    

    /**
     * 删除数据
     */
    @Test
    public void f3()

        //2.定义sql
        String sql="delete from user where username = ?";
        //3.执行sql
        template.update(sql,"Qian");
    

    /**
     * 查询数据并将其封装为Map集合
     */
    @Test
    public void f4()
        //2.定义sql
        String sql="select * from user where id = ?";
        //3.执行sql
        Map<String, Object> map = template.queryForMap(sql, 1);
        System.out.println(map);
    

    /**
     * 查询所有记录并将其封装为List
     */
    @Test
    public void f5()
        //2.定义sql
        String sql="select * from user";
        //3.执行sql
        List<Map<String, Object>> list = template.queryForList(sql);
        for(Map<String, Object> map :list)
            System.out.println(map);
        
    

    /**
     * 查询结果，将结果封装为JavaBean对象
     */
    @Test
    public void f6()
        //2.定义sql
        String sql="select * from user";
        //3.执行sql
        List<person> list=template.query(sql, new RowMapper<person>() 
            @Override
            public person mapRow(ResultSet resultSet, int i) throws SQLException 
                person p=new person();
                int id=resultSet.getInt("id");
                String username=resultSet.getString("username");
                String password=resultSet.getString("password");

                p.setId(id);
                p.setUsername(username);
                p.setPassword(password);
                return p;
            
        );

        for(person p:list)
            System.out.println(p);
        
    

    /**
     * 查询结果，将结果封装为JavaBean对象
     */
    @Test
    public void f6_2()
        //2.定义sql
        String sql="select * from user";
        //3.执行sql
        List<person> list=template.query(sql, new BeanPropertyRowMapper<person>(person.class));

        for(person p:list)
            System.out.println(p);
        
    

    /**
     * 查询总记录数
     */
    @Test
    public void f7()
        //2.定义sql
        String sql="select count(id) from user";
        //3.执行sql
        Long total = template.queryForObject(sql, Long.class);
        System.out.println(total);

以上是关于数据库连接池的主要内容，如果未能解决你的问题，请参考以下文章

连接池的基本原理？以及使用连接池的好处？

数据库连接池原理详解与自定义连接池实现

Node.js实现MySQL数据库连接池

面试题：数据库连接池原理详解与自定义连接池实现

数据库连接池之Druid

spring连接池配置详解