连接池简介

1、连接池是创建和管理一个连接的缓冲池的技术，这些连接准备好被任何需要它们的线程使用。
　　作用：避免频繁地创建与消毁，给服务器减压力。
2、数据库的弊端：
　　1.当用户群体少服务器可以支撑，如果群体比较大万级别服务器直接死机。数据库默认的并发访问50.
　　2.每一个用完数据库之后直接关闭，不能重复利用太浪费资源。
3、设计连接池：
　　1.在池子中创建出多个连接供使用。
　　2.当用户需要操作数据库时直接从池子中获取连接即可。
　　3.当用户使用完毕之后把连接归还给连接池，可以达到重复使用。
　　4.可以设定池子的最大容器。比如50个连接，当第51个人访问的时候，需要等待。
　　5.其它用户释放资源的时候，可以使用。

4、手动实现连接池

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

public class JDBCTool {
    private static Connection conn;
    private static String driverName;
    private static String username;
    private static String url;
    private static String password;
    static {
        InputStream is = JDBCTool.class.getClassLoader().getResourceAsStream("qq.properties");
        Properties prop = new Properties();
        try {
            prop.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        driverName = (String)prop.get("driverClassName");
        username = (String)prop.get("username");
        url = (String)prop.get("url");
        password = (String)prop.get("password");
        
        try {
            Class.forName(driverName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
    
    public static Connection getConn() {
        try {
            conn = DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
    
    public static void close(Connection conn,PreparedStatement ps,ResultSet rs) {
        if(conn!=null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(ps!=null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(rs!=null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        
    }
}

手动实现连接池第一步

import java.sql.Connection;
import java.util.ArrayList;
import java.util.List;

public class MyJDBCPool {
    /* 1.定义一个容器  集合
     2.初始化连接，并放在池子中。
     3.创建一个从容器中获取连接的方法
     4.创建一个归还连接的方法。*/
    private static List<Connection> pool = new ArrayList<>();
    private static int List_size = 3;
    static {
        for(int i=0;i<List_size;i++) {
            Connection conn=null;
            conn = JDBCTool.getConn();
            pool.add(conn);
            System.out.println("当前存放连接为："+conn+"，当前池子中剩余连接数为："+pool.size());
            
        }
        System.out.println("=====================");
    }
    
    //取出一个连接 要判断是否为空
    public static Connection getConn() throws NullPointerException{
        if(pool.isEmpty()) {
            System.out.println("请等待");
            throw new NullPointerException("已经空了，别拿了");
        }
        Connection conn = pool.remove(0);
        System.out.println("当前取出的连接为："+conn+"，当前剩余连接数为："+pool.size());
        return conn;
    }
    
    //归还连接 要判断是否为真正的连接
    public static void returnConn(Connection conn) {
        if(conn==null) {
            System.out.println("你玩我？");
            return;
        }
        pool.add(conn);
        System.out.println("当前存入的连接为："+conn+"，当前剩余连接数为："+pool.size());
    }
}

手动实现连接池第二步

import java.sql.Connection;

public class Test1 {

    public static void main(String[] args) {
        Connection conn = MyJDBCPool.getConn();
        Connection conn1 = MyJDBCPool.getConn();
        Connection conn2 = MyJDBCPool.getConn();
        
        MyJDBCPool.returnConn(conn2);
        MyJDBCPool.returnConn(conn1);
        MyJDBCPool.returnConn(conn);
        
    }

}

手动连接池的测试

　　注：这里涉及到一个properties文件，文件内容是key =value形式存在的，先使用类加载器（或输入流）将文件加载进来，然后使用properties对象处理文件，使用get()方法获取内容。

常用连接池

1、导入连接池的步骤

　　导包 buildpath

　　配置文件 properties

　　加载文件流，使用properties处理文件

　　使用连接池的API读取prop对象，创建连接池

　　getConnection获取连接

　　返回连接的引用　

2、dbcp连接池开源连接池，效率高，但安全性不强

　　工具包下载地址：http://commons.apache.org/proper/commons-pool/download_pool.cgi

　　　　http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi

　　导包 commons-dbcp 和commons-pool mysql-connection

　　配置文件导入*.properties 建议放在src根目录

import java.sql.Connection;

import org.apache.commons.dbcp.BasicDataSource;

public class Test1{
    
    public static void main(String[] args) throws Exception{
        
        BasicDataSource bds = new BasicDataSource();
        
        // 4个必须设置的属性
        bds.setDriverClassName("com.mysql.jdbc.Driver");
        bds.setUrl("jdbc:mysql:///db0619");
        bds.setUsername("root");
        bds.setPassword("root");
        
        
        //其他属性，都是可选属性
        bds.setInitialSize(100);  // 初始创建100个连接
        bds.setMaxActive(50);  // 最大活动数
        bds.setMaxIdle(20);    // 最大空闲数
        bds.setMinIdle(10);    // 最小空闲数
        bds.setMaxWait(-1);  // 最大等待时间
        
        
        Connection conn = bds.getConnection();
        System.out.println(conn);
        Connection conn2 = bds.getConnection();
        System.out.println(conn2);
        
        
    }

}

手动创建DBCP连接池

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

public class DBCPUtil {
    
    private static DataSource ds;
    
    static{
        
        try {
             Properties p = new Properties();
             InputStream is = new FileInputStream("src/db.properties");
             p.load(is);
             ds = BasicDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
            
            e.printStackTrace();
        }
        
    }
    
    
    public static DataSource getDataSource(){
        
        return ds;
    }
    
    
    public static Connection getConnection(){
        Connection conn = null;
        try {
            conn = ds.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
    

}

使用配置文件自动创建DBCP连接池，工具类

3、c3p0连接池

　　工具包:https://sourceforge.net/projects/c3p0/

　　导包 c3p0-0.9.5.2.jar mchange-commons-java... mysql-connection...

　　配置文件名称：c3p0-config.xml　　 c3p0.properties

import java.sql.Connection;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class Test1{
    
    public static void main(String[] args) throws Exception{
        
        ComboPooledDataSource cds = new ComboPooledDataSource();
        
        //4 个基本设置
        cds.setDriverClass("com.mysql.jdbc.Driver");
        cds.setJdbcUrl("jdbc:mysql:///db0619");
        cds.setUser("root");
        cds.setPassword("root");
        
        
        Connection conn = cds.getConnection();
        System.out.println(conn);
    }

}

手动设置c3p0连接池

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

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Util {
    
    private static DataSource ds;
    
    static{
        //ds = new ComboPooledDataSource();//加载src/c3p0-config.xml，并使用配置文件中默认的配置配置<default-config>
        ds = new ComboPooledDataSource("offcn"); //加载src/c3p0-config.xml，并使用名字为offcn的配置配置
    }
    
    public static DataSource getDataSource(){
        
        return ds;
    }
    
    
    public static Connection getConnection(){
        
        Connection conn = null;
        
        try {
            conn= ds.getConnection();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn;
    }

}

使用xml文件自动创建c3p0，工具类

4、druid连接池

　　工具包：

　　导包：druid-1....jar mysql-connection...

　　配置文件名称 druid.properties

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DruidUtils {
    private static DataSource ds;
    private static Connection conn;
    static{
        try {
            InputStream is = MyJDBC.class.getClassLoader().getResourceAsStream("druid.properties");
            Properties prop = new Properties();
            prop.load(is);
            ds = DruidDataSourceFactory.createDataSource(prop);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() {
        try {
            conn = ds.getConnection();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn;
    }
    public static DataSource getDataSource() {
        return ds;
    }
}

使用配置文件自动创建Druid连接池，工具类

DBUTils工具类

来源：https://www.cnblogs.com/xfdhh/p/11372229.html

标签

大数据

数据库连接池

数据库