自定义JDBC数据库连接池小例子

最新推荐文章于 2023-12-05 16:02:33 发布
最新推荐文章于 2023-12-05 16:02:33 发布
阅读量174 收藏
点赞数
文章标签： 数据库 java
原文链接：https://yq.aliyun.com/articles/83767
版权

上篇文章中写了一个JDBC的小例子，这篇文章写个数据库连接池的小例子吧。

package com.zkn.newlearn.jdbc.mysql.third;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Properties;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by wb-zhangkenan on 2017/5/3.
 *
 * @date 2017/05/03
 */
public class DataSourcePoolNew {
    /**
     * 最大连接数
     */
    private static final int COUNT = 10;
    /**
     * 存放数据库
     */
    private static final LinkedList<Connection> connections = new LinkedList<>();
    /**
     * 创建锁
     */
    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition notEmpty = lock.newCondition();
    private static final Condition notFull = lock.newCondition();
    /**
     * 数据库连接
     */
    private static String URL;
    /**
     * 用户名
     */
    private static String USER_NAME;
    /**
     * 密码
     */
    private static String PASS_WORD;
    /**
     * 驱动类型
     */
    private static String DRIVER_CLASS_NAME;
    /**
     * 存放属性信息
     */
    private static Properties properties = new Properties();

    /**
     * 初始化信息
     */
    static {
        InputStream is = DataSourcePoolNew.class.getResourceAsStream("driver.properties");
        try {
            properties.load(is);
            URL = (String) properties.get("url");
            USER_NAME = (String) properties.get("userName");
            PASS_WORD = (String) properties.get("passWord");
            DRIVER_CLASS_NAME = (String) properties.get("driverClassName");
            //加载驱动
            Class.forName(DRIVER_CLASS_NAME);
            Connection connection = null;
            for (int i = 0; i < 10; i++) {
                connection = DriverManager.getConnection(URL, USER_NAME, PASS_WORD);
                connections.add(connection);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Connection
     */
    public static Connection getConnection() {
        final ReentrantLock reentrantLock = lock;
        reentrantLock.lock();
        try {
            //如果没有连接了，则等待着新放入的连接
            if (connections.isEmpty()) {
                notEmpty.await();
            }
            Connection connection = connections.removeFirst();
            notFull.signalAll();
            return connection;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
        return null;
    }

    /**
     * 释放连接
     *
     * @param connection
     */
    public static void release(Connection connection) {
        final ReentrantLock reentrantLock = lock;
        reentrantLock.lock();
        try {
            if (connections.size() == COUNT) {
                notFull.await();
            }
            if (connection == null || connection.isClosed()) {
                connections.add(DriverManager.getConnection(URL, USER_NAME, PASS_WORD));
                notEmpty.signalAll();
                return;
            }
            //恢复默认值
            if (connection.getAutoCommit() == false) {
                connection.setAutoCommit(true);
            }
            connections.add(connection);
            notEmpty.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

}
CloseUtils： 

package com.zkn.newlearn.jdbc.mysql.second;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by wb-zhangkenan on 2017/5/3.
 *
 * @date 2017/05/03
 */
public final class CloseUtils {

    private static Logger log = LoggerFactory.getLogger(CloseUtils.class);

    /**
     * 关闭ResultSet
     *
     * @param resultSet
     */
    public static void close(ResultSet resultSet) {
        if (resultSet != null) {
            try {
                log.info("关闭了");
                resultSet.close();
            } catch (SQLException e) {
                log.error("关闭resultSet出现异常!!!");
            }
        }
    }

    /**
     * 关闭statement
     *
     * @param statement
     */
    public static void close(Statement statement) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                log.error("关闭statement出现异常!!!");
            }
        }
    }

    /**
     * 关闭preparedStatement
     *
     * @param preparedStatement
     */
    public static void close(PreparedStatement preparedStatement) {
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                log.error("关闭preparedStatement出现异常!!!");
            }
        }
    }

    /**
     * 关闭connection
     * @param connection
     */
    public static void close(Connection connection) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                log.error("关闭connection出现异常!!!");
            }
        }
    }
}
DEMO： 

package com.zkn.newlearn.jdbc.mysql.third;

import com.zkn.newlearn.jdbc.mysql.second.CloseUtils;
import org.junit.Test;
import java.sql.*;

/**
 * Created by zkn on 2017/5/3.
 */
public class JDBCPoolTest {


    /**
     * 查询操作
     */
    @Test
    public void testStatementQuery() {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = DataSourcePoolNew.getConnection();
            if(connection == null){
                return;
            }
            //获取sql的声明
            statement = connection.createStatement();
            //执行查询的操作
            resultSet = statement.executeQuery("SELECT * FROM province_china");
            //取出查询出来的数据
            StringBuilder sb = new StringBuilder();
            while (resultSet.next()) {
                sb.append(resultSet.getLong("id")).append("  ");
                //这里需要注意的是下标是从1开始的，不是从0开始的
                sb.append(resultSet.getString(2)).append("  ");
                sb.append(resultSet.getString("cname")).append("  ");
                System.out.println(sb.toString());
                //清空原来的数据
                sb.delete(0, sb.length());
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            CloseUtils.close(resultSet);
            CloseUtils.close(statement);
            DataSourcePoolNew.release(connection);
        }
    }

    /**
     * 预编译查询
     */
    @Test
    public void testPreparedStatement() {
        Connection connection = null;
        PreparedStatement pst = null;
        ResultSet resultSet = null;
        try {
            //获取连接
            connection = DataSourcePoolNew.getConnection();
            if(connection == null){
                return;
            }
            String sql = "SELECT * FROM TABLE_NAME WHERE EMPID = ?";
            //获取sql声明
            pst = connection.prepareStatement(sql);
            //pst.setLong(1,2);
            //封装查询条件
            pst.setString(1, "32151");
            //执行sql的操作
            resultSet = pst.executeQuery();
            StringBuilder sb = new StringBuilder();
            while (resultSet.next()) {
                sb.append(resultSet.getLong("id")).append(" ");
                sb.append(resultSet.getString(2));
                System.out.println(sb.toString());
                //清空原来的数据
                sb.delete(0, sb.length());
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeResource(connection,pst,resultSet);
        }
    }

    /**
     * 单条插入
     */
    @Test
    public void testInsert() {
        Connection connection = null;
        PreparedStatement pst = null;
        ResultSet resultSet = null;
        try {
            //获取连接
            connection = DataSourcePoolNew.getConnection();
            if(connection == null){
                return;
            }
            //自动提交为false
            connection.setAutoCommit(false);
            //创建sql声明
            pst = connection.prepareStatement(
                    "INSERT INTO TABLE_NAME (NAME,EMPID,ORG_ID,ORG_CODE,IS_ADMIN,GMT_CREATE,GMT_MODIFIED) VALUES (?,"
                            + "?,?,?,?,now(),now())",
                    Statement.RETURN_GENERATED_KEYS);
            pst.setString(1, "张三");
            pst.setString(2, "784550");
            pst.setLong(3, 2);
            pst.setString(4, "0.1.2");
            pst.setInt(5, 1);
            //执行插入操作
            int count = pst.executeUpdate();
            if (count > 0) {
                System.out.println("插入成功!");
            } else {
                System.out.println("插入失败!");
            }
            resultSet = pst.getGeneratedKeys();
            while (resultSet.next()) {
                System.out.println(String.format("主键值为%d", resultSet.getLong(1)));
            }
            //提交操作
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            //异常回滚
            try {
                connection.rollback();
            } catch (SQLException ee) {
                ee.printStackTrace();
            }
        } finally {
            closeResource(connection,pst,resultSet);
        }
    }

    /**
     * 批量插入 需要设置 rewriteBatchedStatements=true
     */
    @Test
    public void testBatchInsert() {
        Connection connection = null;
        PreparedStatement pst = null;
        ResultSet resultSet = null;
        try {
            //获取连接
            connection = DataSourcePoolNew.getConnection();
            if(connection == null){
                return;
            }
            //自动提交为false
            connection.setAutoCommit(false);
            //创建sql声明
            pst = connection.prepareStatement(
                    "INSERT INTO TABLE_NAME (NAME,EMPID,ORG_ID,ORG_CODE,IS_ADMIN,GMT_CREATE,GMT_MODIFIED) VALUES (?,"
                            + "?,?,?,?,now(),now())",
                    Statement.RETURN_GENERATED_KEYS);
            for (int i = 0; i < 10; i++) {
                pst.setString(1, "张三");
                pst.setString(2, "784550");
                pst.setLong(3, 2);
                pst.setString(4, "0.1.2");
                pst.setInt(5, 1);
                pst.addBatch();
            }
            int[] count = pst.executeBatch();
            if (count != null && count.length > 0) {
                System.out.println("插入成功!");
            } else {
                System.out.println("插入失败!");
            }
            resultSet = pst.getGeneratedKeys();
            while (resultSet.next()) {
                System.out.println(String.format("主键值为%d", resultSet.getLong(1)));
            }
            //提交操作
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            //异常回滚
            try {
                connection.rollback();
            } catch (SQLException ee) {
                ee.printStackTrace();
            }
        } finally {
            closeResource(connection,pst,resultSet);
        }
    }

    /**
     * 测试更新操作
     */
    @Test
    public void testUpdate() {
        Connection connection = null;
        PreparedStatement pst = null;
        try {
            //获取连接
            connection = DataSourcePoolNew.getConnection();
            if(connection == null){
                return;
            }
            //自动提交为false
            connection.setAutoCommit(false);
            //创建sql声明
            pst = connection.prepareStatement("update TABLE_NAME set name = ? where id >=? and id <= ? ");
            pst.setString(1, "李思思");
            pst.setLong(2, 1972);
            pst.setLong(3, 1995);
            int count = pst.executeUpdate();
            if (count > 0) {
                System.out.println("更新成功!");
            } else {
                System.out.println("更新失败");
                return;
            }
            //提交操作
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            //异常回滚
            try {
                connection.rollback();
            } catch (SQLException ee) {
                ee.printStackTrace();
            }
        } finally {
            closeResource(connection,pst);
        }
    }

    /**
     * 测试删除操作
     */
    @Test
    public void testDelete() {
        Connection connection = null;
        PreparedStatement pst = null;
        try {
            //获取连接
            connection = DataSourcePoolNew.getConnection();
            if(connection == null){
                return;
            }
            //自动提交为false
            connection.setAutoCommit(false);
            //创建sql的声明
            pst = connection.prepareStatement("DELETE FROM TABLE_NAME WHERE ID >=? AND ID <=? ");
            pst.setLong(1, 1972);
            pst.setLong(2, 1995);
            //执行sql
            pst.executeUpdate();
            //提交
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            //异常回滚
            try {
                connection.rollback();
            } catch (SQLException ee) {
                ee.printStackTrace();
            }
        } finally {
            closeResource(connection,pst);
        }
    }

    private void closeResource(Connection connection, PreparedStatement statement, ResultSet resultSet) {
        CloseUtils.close(resultSet);
        closeResource(connection, statement);
    }

    private void closeResource(Connection connection, PreparedStatement statement) {
        CloseUtils.close(statement);
        DataSourcePoolNew.release(connection);
    }

}


weixin_33809981
关注
JDBC（The end）—— 数据库连接池示例 （与线程池梦幻联动）
yooppa的博客
12-10 783
写在之前： 不管以后对于那种类型的池 都需要List接口利用多态的写法来对一系列集合框架类进行实例化对象 以此该对象调用add方法 来装多个此种类型的实例化对象。 数据库连接池的设计思路比线程池简单易懂 以下是示例： 和之前线程池的设计思想相同之处是（也不是说和线程池设计思路一致 放在其他的类的池设计 也是如此） 都是在其无参构造或者有参构造法里初始化一些数据 比如具体池的大小 以具体大小来实例化该类对象的个数 配合示例代码——线程池和数据库连接池在构造方法里的不同点： 1、线程池 在构造方法里的实例化对象
java 线程池 数据库连接池_线程池配置与数据库连接池最大连接数配置
weixin_39976382的博客
02-15 1631
线程池 相关配置，不仅平时经常用到，而且面试也会经常问到。如何设置线程池大小？CPU 密集型任务：这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N(CPU 核心数)+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。I/O 密...
完美的java jdbc连接池实例
12-14
java jdbc 连接池实例 项目只要配数据源就可以直接启用， 也可以整合到你个项目里面, 可oracle、mysql、sqlserver自由切换方言。
JDBC连接池案例
一点博客
07-04 396
连接池概念： 其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 C3P0：数据库连接池技术 步骤 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ， 不要忘记导入数据库驱动ja...
JDBC创建一个数据连接连接池的实例
toby1123yjh的博客
03-27 332
直接铺代码吧，jdbc工具类很工程化的东西都是这样写import javax.sql.DataSource;import org.apache.commons.dbcp.BasicDataSource;//获取数据库连接的工具类//实现连接池,dbcppublic class JDBCUtils {     //创建BasicDataSource private static BasicDataS...
javaJDBC自定义数据库连接池
OnlyloveCuracao的博客
10-24 606
在JDBC连接数据库的时候，一般情况下DiverManager.getConnection获得连接对象，每次都这么做，十分的耗费资源。 为了解决这个问题，于是出现连接池。跟线程池的概念差不多。 线程池： 多个Connection对象被创建了，然后放在池子里面，用的时候直接从池子里面去拿，用完了再放回去。 后面的程序如果没有抓到对象，就处于等待状态。 我们在不使用dbcp、C3P0等开源的数据...
一个Demo小例子让你了解数据库连接池实现的4种方式
07-17
在Java开发中，有多种实现数据库连接池的方式，本篇文章将通过一个Demo小例子来详细介绍JdbcPool、JdbcTomcat、JdbcUtilC3P0和JdbcUtilDBCP这四种常见数据库连接池的实现。 1. **JdbcPool**：这是一个简单的自定义...
durid数据库连接池的使用方式，定义了工具类，可以通过durid方式访问数据库，实现对数据库的添加
10-02
Durid，全称为 Distributed Universal JDBC，是阿里巴巴开源的一个高性能、分布式、可扩展的数据库连接池组件。它在设计上借鉴了C3P0、DBCP等成熟的数据源管理方案，并在此基础上进行了优化和增强，提供了更强大的...
数据库连接池和DBUtils使用1
08-04
数据库连接池是数据库管理中的一个重要概念，它解决了传统JDBC操作数据库时频繁创建和关闭连接导致的性能问题。在Java编程中，数据库连接池的使用可以显著提升应用程序的效率，因为它实现了数据库连接的复用，避免了...
druid连接池例子
林高禄
06-26 9754
先导入jia包 驱动jar包 druid的Jar包 写配置文件 定义配置文件（手动加载） 名称：自定义 路径：自定义 封装工具类代码 package com.lingaolu.dataSource; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import java.io.IOException; import...
JAVA JDBC小例子
01-19
用的是mysql数据库，实现的是jdbc简单crud的实现，需要自己建数据库，不懂问我
sqljdbc.jar连接实例
12-12
sqljdbc.jar用于数据库连接，主要给java调用现成的api
自定义实现jdbc数据库连接池
qq_34898847的博客
03-26 847
连接池作用 达到资源的复用 提高响应速度(不必要的连接与关闭) 资源的分配策略,可以统一管理 连接池的大致实现思路 核心参数: 空闲连接数: 没有使用的连接数 活动连接数: 正在使用的连接数 最大连接数: 最多允许存在的连接数 初始化连接池(用容器封装:比如Vecotr sql包下) 实现获取Connection的方法: (1) 判断当前连接数(countPool) 是否小于 最大连接数 ...
自定义数据库连接池
qiumin的博客
06-07 353
​数据库连接池、动态代理
自定义一个简单的JDBC连接池实现方法（附代码演示）
最新发布
Jin_Xiang123的博客
12-05 1967
本篇文章主要介绍自定义一个简单的JDBC连接池实现方法以及部分理论知识，附有代码详细讲解演示
JDBC（二）：数据库连接池使用以及自定义连接池
zmysn_a的博客
11-30 363
数据库连接池 文章目录数据库连接池1. 概述1.2 连接池解决问题的原理1.3 数据库连接池接口2. 常见的连接池2.1 介绍2.2 C3P0使用2.4 Druid使用3. Druid连接池工具类3.1 工具类实现3.2 工具类使用4. 自定义连接池4.1 步骤4.2 实现 1. 概述 ####1.1 连接对象的使用问题 数据库创建连接通常需要消耗相对较多的资源，创建时间也较长，而每次操作都要...
JDBC实现java数据库连接（附完整例子+超详细注解）
BookSea的博客
05-06 9373
注重版权，转载请注明原作者和原文链接 作者：码农BookSea 原文链接：https://editor.csdn.net/md?articleId=105959128 本人刚写博客不久，是个新人，望大家能给予一些鼓励。 您的一个赞或者是评论区的一句话都将是对我最大的激励。 简单一句话先来了解下JDBC： JDBC(Java Data Base Connectivity,java数据库连接...
JDBC连接池
hanhanhanfei的博客
05-17 530
1.为什么使用连接池？ 数据库连接是一种关键的有限的昂贵的资源，传统数据库连接每发出一个请求都要创建一个连接对象，使用完直接关闭不能重复利用； 关闭资源需要手动完成，一旦忘记会造成内存溢出； 请求过于频繁的时候，创建连接极其消耗内存； 而且一旦高并发访问数据库，有可能会造成系统崩溃。 为了解决这些问题，我们可以使用连接池。 2.传统JDBC的缺点 用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。 假设网站一天10万访问...
Java JDBC连接SQLite数据库实战
"这是一个关于Java JDBC基础使用的示例代码，展示了如何连接SQLite数据库并执行SQL查询。" 在Java中，Java ...对于大型应用，可能还会使用PreparedStatement以防止SQL注入，或使用Connection池管理数据库连接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值