Java模块 -- Tomcat JDBC Connection pool

最新推荐文章于 2024-06-27 09:00:00 发布
最新推荐文章于 2024-06-27 09:00:00 发布
阅读量2.6k 收藏 2
点赞数 1
分类专栏： JAVA 模块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simba_cheng/article/details/72593763
版权

Tomcat从7.0之后使用他自己的连接池,不在使用Commons-dbcp


Commons-dbcp的缺点:
1. 单线程,为了保证线程安全会锁整个连接池
2. 性能不佳
3. 太复杂,超过60个类
4. dbcp使用静态接口,
5.发展滞后 (似乎不太更新了??)


Tomcat JDBC Pool 特点
1. 近乎兼容dbcp , 性能更高.
2. 异步方式获取连接  ??
3. 使用 javax.sql.PooledConnection接口来获取连接.
4. 支持高并发应用环境
5. 简单,核心文件只有8个.
6.更好的空闲连接处理机制


官方文档地址:Apache Tomcat8 JDBC Connection Pool

这里的例子,是将Tomcat JDBC Connection Pool组件拿出来,单独使用

在工作中,可以将这个组件放到需要的项目中单独使用


代码以及jar包:Tomcat JDBC Connection Pool 代码以及Jar包


公共方法

public class CommonUtils {


    /**
     * 判断是否是windows操作系统
     *
     * @return
     */
    public static boolean isWindowsOS() {
        boolean isWindowsOS = false;
        String osName = System.getProperty("os.name");
        if (osName.toLowerCase().indexOf("windows") > -1) {
            isWindowsOS = true;
        }
        return isWindowsOS;
    }

    /**
     * 判断相对路径根路径(区分./和../)
     */
    static {
        if (isWindowsOS()) {
            systemRootPath = "./";
        } else {
            systemRootPath = "../";
        }
    }

    /**
     * 相对路径的根路径
     */
    public static String systemRootPath;

    /**
     * tomcat_jdbc_pool 配置文件
     */
    public static final String TOMCATJDBCPOOLPROFILEPATH = systemRootPath+"conf/tomcat_jdbc_pool.properties";

}

tomcat_jdbc_pool.properties配置文件

#数据库URL
URL=jdbc:mysql://localhost:3306/test

#数据库驱动
DRIVER=com.mysql.jdbc.Driver

#用户名
USERNAME=root

#密码
PASSWORD=123456

#初始化创建连接数
INITIALSIZE=10

#连接池最大连接数
MAXACTIVE=100

#最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被释放。设为0表示无限制
MAXIDLE=50

#最小空闲连接:连接池中容许保持空闲状态的最小连接数量,低于这个数量将创建新的连接
MINIDLE=10

#最大建立连接等待时间
MAXWAIT=500

#超过removeAbandonedTimeout时间后，是否进行没用连接（废弃）的回收（默认为false，调整为true)
REMOVEABANDONED=true

#超过时间限制，回收没有用(废弃)的连接（默认为300秒，调整为180）
REMOVEABANDONEDTIMEOUT=180


本地logger日志,只在控制台打印,不需要配置文件

public class Local_Logger {

    static {
        String pattern = "%d{yyyy-MM-dd HH:mm:ss} %l - %m%n";
        Logger rootLogger = Logger.getRootLogger();
        rootLogger.setLevel(Level.DEBUG);
        rootLogger.addAppender(new ConsoleAppender((new PatternLayout(pattern))));
    }

}

常量key 

public class TomcatJdbcPool_Constants {

    /**
     * 数据库URL
     */
    public static final String URL = "URL";
    /**
     * 数据库驱动
     */
    public static final String DRIVER = "DRIVER";
    /**
     * 用户名
     */
    public static final String USERNAME = "USERNAME";
    /**
     * 密码
     */
    public static final String PASSWORD = "PASSWORD";
    /**
     * 初始化创建连接数
     */
    public static final String INITIALSIZE = "INITIALSIZE";
    /**
     * 连接池最大连接数
     */
    public static final String MAXACTIVE = "MAXACTIVE";
    /**
     * 最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被释放。设为0表示无限制
     */
    public static final String MAXIDLE = "MAXIDLE";
    /**
     * 最小空闲连接:连接池中容许保持空闲状态的最小连接数量,低于这个数量将创建新的连接
     */
    public static final String MINIDLE = "MINIDLE";
    /**
     * 最大建立连接等待时间
     */
    public static final String MAXWAIT = "MAXWAIT";
    /**
     * 超过removeAbandonedTimeout时间后，是否进行没用连接（废弃）的回收（默认为false，调整为true)
     */
    public static final String REMOVEABANDONED = "REMOVEABANDONED";
    /**
     * 超过时间限制，回收没有用(废弃)的连接（默认为300秒，调整为180）
     */
    public static final String REMOVEABANDONEDTIMEOUT = "REMOVEABANDONEDTIMEOUT";
}

Tomcat JDBC Connection Pool连接池实现代码 

public class T_JDBC_Pool {

    public static final Logger logger = Logger.getLogger(T_JDBC_Pool.class);

    private static DataSource dataSource = new DataSource();

    private static String url;
    private static String driver;
    private static String username;
    private static String password;
    private static int initialSize;
    private static int maxActive;
    private static int maxIdle;
    private static int minIdle;
    private static int maxWait;
    private static boolean removeAbandoned;
    private static int removeAbandonedTimeout;

    public static void init() {

        //加载本地logger
        new Local_Logger();

        Properties properties = null;

        try {

            properties = new Properties();
            properties.load(new FileInputStream(new File(CommonUtils.TOMCATJDBCPOOLPROFILEPATH)));

            url = properties.getProperty(TomcatJdbcPool_Constants.URL);
            driver = properties.getProperty(TomcatJdbcPool_Constants.DRIVER);
            username = properties.getProperty(TomcatJdbcPool_Constants.USERNAME);
            password = properties.getProperty(TomcatJdbcPool_Constants.PASSWORD);
            initialSize = Integer.valueOf(properties.getProperty(TomcatJdbcPool_Constants.INITIALSIZE));
            maxActive = Integer.valueOf(properties.getProperty(TomcatJdbcPool_Constants.MAXACTIVE));
            maxIdle = Integer.valueOf(properties.getProperty(TomcatJdbcPool_Constants.MAXIDLE));
            minIdle = Integer.valueOf(properties.getProperty(TomcatJdbcPool_Constants.MINIDLE));
            maxWait = Integer.valueOf(properties.getProperty(TomcatJdbcPool_Constants.MAXWAIT));
            removeAbandoned = Boolean.valueOf(properties.getProperty(TomcatJdbcPool_Constants.REMOVEABANDONED));
            removeAbandonedTimeout = Integer.valueOf(properties.getProperty(TomcatJdbcPool_Constants.REMOVEABANDONEDTIMEOUT));

            logger.debug("url : " + url);
            logger.debug("driver : " + driver);
            logger.debug("username : " + username);
            logger.debug("password : " + password);
            logger.debug("initialSize : " + initialSize);
            logger.debug("maxActive : " + maxActive);
            logger.debug("maxIdle : " + maxIdle);
            logger.debug("minIdle : " + minIdle);
            logger.debug("maxWait : " + maxWait);
            logger.debug("removeAbandoned : " + removeAbandoned);
            logger.debug("removeAbandonedTimeout : " + removeAbandonedTimeout);


        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

        PoolProperties poolProperties = null;
        try {
            poolProperties = new PoolProperties();
            poolProperties.setUrl(url);
            poolProperties.setDriverClassName(driver);
            poolProperties.setUsername(username);
            poolProperties.setPassword(password);
            poolProperties.setInitialSize(initialSize);
            poolProperties.setMaxActive(maxActive);
            poolProperties.setMaxIdle(maxIdle);
            poolProperties.setMaxWait(maxWait);
            poolProperties.setRemoveAbandoned(removeAbandoned);
            poolProperties.setRemoveAbandonedTimeout(removeAbandonedTimeout);

            dataSource.setPoolProperties(poolProperties);

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

    }

    /**
     * 获取连接
     *
     * @return
     */
    public static Connection getConnection() {
        Connection connection = null;
        try {

            connection = dataSource.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
}

测试调用类 

public class Test_jdbc_pool {

    /**
     * 调用一次
     */
    @Test
    public void testQueryDataSource() {

        String querySql = "SELECT * FROM STUDENT";

        T_JDBC_Pool.init();
        Connection connection = T_JDBC_Pool.getConnection();

        Statement statement = null;
        ResultSet resultSet = null;

        try {
            statement = connection.createStatement();

            resultSet = statement.executeQuery(querySql);

            while (resultSet.next()) {
                System.out.print(resultSet.getString("studentId") + " ");
                System.out.print(resultSet.getString("studentName") + " ");
                System.out.print(resultSet.getString("studentAge") + " ");
                System.out.println(resultSet.getString("studentPhone"));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                connection.close();
                statement.close();
                resultSet.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 测试并发调用
     * @param args
     */
    public static void main(String[] args) {
        Test_jdbc_pool t = new Test_jdbc_pool();
        t.ConcurrentTest();
    }

    public void ConcurrentTest() {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {

                while (true) {
                    testQueryDataSource();
                }

            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    testQueryDataSource();
                }
            }
        });
        thread2.start();
    }

}

这里哦一直有个疑问

从连接池取出一个连接,用完之后,datasource没有将 连接 返还至连接池的方法....

后来去官方提供的Demo中看了下,官方Demo也仅仅是close了连接,没有将连接返还至连接池....


等有空的时候,翻翻源码...后面再补上



Simba_cheng
关注
专栏目录
tomcat jdbc-pool 的使用
广东妃子笑科技
07-01 1万+
最近使用c3p0遇到了很大的问题，有个商品闪购的系统调用库存dubbo接口，单个调用用junit测试花个几毫秒的样子，但是500个并发压力测试时发现非常的慢。我特意在库存接口调用数据库的地方打执行时间日志，发现有些SQL执行的时间非常长。但是查看mysql查询日志，又没有任何时间长的查询。所以初步怀疑所耗费的时间是在等待数据库连接，也就是数据库连接沲的问题。查看资料，得知dbcp和c3p0都是单线
tomcat jdbc pool 配置
gorunbu的专栏
07-31 751
tomcat jdbc pool 配置环境：tomcat7; jdk1.8; MySQL-5.7.17 Community Server (GPL); Oxygen Release (4.7.0)当跑jndi项目时抛出：org.apache.tomcat.dbcp.dbcp.SQLNestedException: Cannot create JDBC driver of class ” for co
JDBC Connection Pool org.apache.tomcat.jdbc.pool
03-18
apache出品，用来取代老旧的dbcp
Tomcat 中的 JDBC Pool
weixin_33871366的博客
01-22 295
什么是连接池 什么是 Connection Pool -- 连接池呢？ 我就不解释了。不太清楚的看这篇文章 [生产级别Nodejs开发实践-使用连接池]（这篇文章的前半部分讲述了什么是连接池） Tomcat中的jdbc连接池 它的英文文档在：[The Tomcat JDBC Connection Pool] Tomcat 不仅是...
如何在JDBC中开启和提交事务？
最新发布
m0_46552684的博客
06-27 742
请注意，上述示例代码中的数据库URL、用户名、密码以及SQL语句都是示例值，你需要根据实际情况进行替换。此外，为了简化示例，我没有包含错误处理和资源管理的完整代码（如关闭连接和语句），但在实际应用中你应该始终确保正确处理异常并关闭资源。在执行SQL语句的过程中，如果发生任何异常，你需要捕获这些异常并进行适当的处理。如果在执行SQL语句的过程中发生异常，或者由于其他原因需要撤销事务中的更改，你可以通过调用。这将撤销事务中的所有未提交的更改，并将数据库恢复到事务开始之前的状态。首先，你需要获取一个数据库连接（
Tomcat JDBC Connection Pool
286
08-06 257
       Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。        Tomcat Jdbc Pool 类似于我们常用的数据库连接池c3p0 ,Proxool 等，Tomcat Jdbc Pool有如下优点：  ...
tomcat.jdbc.pool（数据库连接池）
weixin_34388207的博客
04-20 132
1.获取 可以在tomcatLibrary中找到，也可以用Maven。 <dependency> <span style="white-space:pre"> </span><groupId>org.apache.tomcat</groupId> <artifactId>tom...
The Tomcat JDBC Connection Pool
BLOG域名:programb.blog.csdn.net
04-24 588
Tomcat Home The Apache Software Foundation Apache Tomcat 9 Version 9.0.34, Apr 3 2020 Links Docs Home FAQ User Comments User Guide 1) Introduction 2) Setup 3) First webapp 4) Deployer 5) Manager 6) H...
java监控tomcat jdbc_Tomcat 的 JDBC 连接池
weixin_35953155的博客
02-16 890
简介JDBC 连接池org.apache.tomcat.jdbc.pool是Apache Commons DBCP连接池的一种替换或备选方案。那究竟为何需要一个新的连接池？原因如下：Commons DBCP 1.x 是单线程。为了线程安全，在对象分配或对象返回的短期内，Commons 锁定了全部池。但注意这并不适用于 Commons DBCP 2.x。Commons DBCP 1.x 可能...
记一次使用hive-jdbc+tomcat-jdbc连接(Connection)中断的处理过程
Cmainlove的专栏
12-24 3431
现象描述 Hive环境一个数据库，拥有表8000+，业务代码需要挨个desc {tableName}来获取表信息。当程序运行到4000+左右，开始出现获取信息失败。 查找原因 通过查看日志发现是连接已断开，具体如下： 【INFO】org.apache.ibatis.exceptions.PersistenceException: ### Error querying database. Cau...
JDBC----数据库连接池（connection pool）
Bertrand
05-16 1085
•数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。 •数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。 •数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。
tomcat-jdbc.jar
10-31
用于web项目连接jdbc时所需要的jar包，如果没有该jar包没有办法连接数据库
Tomcat jdbc-pool参数详解
11-25
Tomcat , jdbc参数详解 ..
tomcat-jdbc-notes:Tomcat自带数据库连接池源码阅读
03-23
Tomcat JDBC，又称为Apache Tomcat JDBC Connection Pool，是Tomcat服务器内置的高效、灵活的数据库连接池实现。作为一个专业的IT从业者，理解其源码不仅可以帮助我们更好地优化数据库操作，还能提升我们的系统性能...
Tomcat-Jdbc-Pool连接池参数说明
折腾java的博客
03-10 933
介绍 Tomcat 在 7.0 以前的版本都是使用commons-dbcp做为连接池的实现，但是DBCP存在一些问题： DBCP 是单线程的，为了保证线程安全会锁整个连接池 DBCP 性能不佳 DBCP 太复杂，超过60个类，发展滞后。 因此，通常J2EE中还会使用其它的高性能连接池，如C3P0，还有阿里系的druid等。为此，Tomcat 从 7.0 开始引入一个新的模块： Tomcat Jdbc Pool。Tomcat Jdbc Pool 近乎兼容 DBCP，性能更高 异步方式获取连接 使用 ja
要配置Tomcat JDBC Connection池的属性，你需要在应用程序的配置文件中设置相应的属性
BLOG域名:programb.blog.csdn.net
05-19 492
随着逻辑CPU数量的增加以及尝试借用或返回对象的并发线程的数量增加，性能会受到影响。配置完这些属性后，你的应用程序将使用Tomcat JDBC Connection池来管理数据库连接。Tomcat jdbc池是Tomcat模块，它依赖于Tomcat JULI（Tomcat中使用的简化日志记录框架）。如果池为空，并且线程正在等待连接，则返回连接时，池将唤醒正确的线程等待。要配置Tomcat JDBC Connection池的属性，你需要在应用程序的配置文件中设置相应的属性。的数据源，并设置了相应的属性。
JDBC Connection Pool
java专栏
05-21 477
google_ad_client = "pub-8800625213955058";/* 336x280, 创建于 07-11-21 */google_ad_slot = "0989131976";google_ad_width = 336;google_ad_height = 280;//<script type="text/java
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值