C3P0和Druid数据库连接池

最新推荐文章于 2021-12-08 15:30:13 发布
最新推荐文章于 2021-12-08 15:30:13 发布
阅读量190 收藏
点赞数
分类专栏： JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linzeliang1222/article/details/108571195
版权

文章目录

C3P0连接池

步骤：

  1. 导c3p0的jar包
  2. 创建配置文件并配置
  3. 创建核心对象 ComboPooledDataSource
  4. 获取连接 getConnection

C3P0初始化：

  • 先导入两个包：（MySQL的驱动要确保已经导入，否则用不了）

    • c3p0-0.9.5.2.jar
    • mchange-commons-java-0.2.12.jar

  • 创建配置文件：

    • 在src目录下直接创建C3P0的配置文件，文件可以是c3p0-config.xml或c3p0.properties**（文件名及扩展名一定要一样，否则识别不了）**使用这两种方式进行配置时，只要将配置好的文件放入classpath文件夹下即可，在java代码当中不用显示的给出访问配置方式的代码，c3p0会自动识别

    • c3p0-config.xml：

      <?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <!-- 使用默认的配置读取连接池对象 -->
    <default-config>
        <!-- 连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/databaseName</property>
        <property name="user">root</property>
        <property name="password">admin</property>
        <!-- 连接池参数 -->
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数-->
		<property name="acquireIncrement">3</property>
        <!-- 关闭自动提交 -->
        <property name="autoCommitOnClose">false</property>
        <property name="initialPoolSize">5</property>
        <property name="minPoolSize">2</property>
        <property name="maxPoolSize">10</property>   
		<!-- 最大等待时间 -->
        <property name="checkoutTimeout">3000</property>
        <!-- 最大空闲回收时间 -->
        <property name="maxIdleTime">1000</property>
    </default-config>
    
    <!-- 使用自定义的配置读取连接池对象,如果要使用named-config里面配置初始化数据源，则只要使用一个带参数的ComboPooledDataSource构造器就可以了 -->
    <named-config name="oracle">
        <!-- 连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/databaseName</property>
        <property name="user">root</property>
        <property name="password">admin</property>

        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">8</property>
        <property name="checkoutTimeout">1000</property>
    </named-config>
</c3p0-config>

    • c3p0.properties：

      #连接参数
c3p0.jdbcUrl=jdbc:mysql://localhost:3306/databaseName
c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.user=root
c3p0.password=admin
#连接池参数
c3p0.acquireIncrement=3
c3p0.autoCommitOnClose=false
c3p0.initialPoolSize=5
c3p0.minPoolSize=2
c3p0.maxPoolSize=10
c3p0.checkoutTimeout=3000
c3p0.maxIdleTime=1000

    • 通过setters方法一个个地设置各个配置项（不推荐）：

      ComboPooledDataSource cpds = new ComboPooledDataSource();    
cpds.setDriverClass("com.mysql.jdbc.Driver");    
cpds.setJdbcUrl("jdbc:mysql:///users");    
cpds.setUser("root");    
cpds.setPassword("admin");

创建C3P0工具类：

package top.linzeliang.web.dataSource.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class C3P0Util {

    private static DataSource ds = null;

    static {
        //仅仅在类被加载时系统创建一个连接池，自动识别配置文件
        ds = new ComboPooledDataSource();
    }

    public static Connection getConnection() {
        try {
            //获取一个连接，已经存在的
            return ds.getConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            System.out.println("获取连接失败！");
            return null;
        }
    }

    public static void closeConnection(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();
            }
        }
    }
}

创建C3P0测试类：

package top.linzeliang.web.dataSource.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.*;

public class C3P0Demo {

    @Test
    public void test() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        String sql = "CREATE TABLE user(id INT NOT NULL, username VARCHAR(18) NOT NULL, password VARCHAR(16) NOT NULL, PRIMARY KEY (id))";

        try {
            conn = C3P0Util.getConnection();
            pstmt = conn.prepareStatement(sql);
            int count = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            C3P0Util.closeConnection(pstmt, conn);
        }
    }
}

好了，这就是C3P0的基本使用了

Druid连接池（由阿里巴巴提供的数据库连接池实现技术）

步骤：

  1. 导包
  2. 创建定义配置文件
  3. 加载配置文件
  4. 获取数据库连接池对象，通过工厂来获取DruidDataSourceFactory
  5. 获取连接 getConnection

Druid初始化：

  • 同样，先导入包：（MySQL的驱动也要确保导入）

    • druid-1.1.23.jar

  • 创建配置文件：

    • 要以properties后缀名结尾，我的是 druid.properties

      • druid.properties

        driverClassName=com.mysql.jdbc.Driver //驱动加载
url=jdbc:mysql://127.0.0.1:3306/student?characterEncoding=utf-8 //注册驱动
username=root //连接数据库的用户名
password=admin //连接数据库的密码。
filters=stat //属性类型的字符串，通过别名的方式配置扩展插件， 监控统计用的stat 日志用log4j 防御sql注入:wall
initialSize=2 //初始化时池中建立的物理连接个数。
maxActive=300 //最大的可活跃的连接池数量
maxWait=60000 //获取连接时最大等待时间，单位毫秒，超过连接就会失效。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降， 如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
timeBetweenEvictionRunsMillis=60000 // 连接回收器的运行周期时间，时间到了清理池中空闲的连接，testWhileIdle根据这个判断
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1 //用来检测连接是否有效的sql，要求是一个查询语句。
testWhileIdle=true //建议配置为true，不影响性能，并且保证安全性。 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis， 执行validationQuery检测连接是否有效。
testOnBorrow=false //申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。设置为false
testOnReturn=false //归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能,设置为flase
poolPreparedStatements=false //是否缓存preparedStatement，也就是PSCache。
maxPoolPreparedStatementPerConnectionSize=200 // 池中能够缓冲的preparedStatements语句数量

    • 可以放在任意位置（通过反射来获取该文件）

    • 加载配置文件：

      //加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//获取连接对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//获取连接
Connection conn = ds.getConnection();

创建Druid工具类：

package top.linzeliang.web.dataSource.druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

public class DruidUtil {
    private static DataSource ds = null;
    static {
        try {
            //加载配置文件
            Properties pro = new Properties();
            InputStream is = DruidUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);
            //获取连接对象
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {
        try {
            return ds.getConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            System.out.println("获取连接失败");
            return null;
        }
    }

    public static void closeConnection(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();
            }
        }
    }
}

创建Druid测试类：

package top.linzeliang.web.dataSource.druid;

import org.junit.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DruidDemo {

    @Test
    public void test() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        String sql = "UPDATE product SET product_name=? WHERE product_id=?";

        try {
            conn = DruidUtil.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "6666");
            pstmt.setString(2, "0009");
            int count = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            DruidUtil.closeConnection(pstmt, conn);
        }
    }
}

Spring JDBC

Spring JDBC：Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

步骤：

  1. 导包：
    • commons-logging-1.2.jar
    • spring-beans-5.1.5.RELEASE.jar
    • spring-core-5.1.5.RELEASE.jar
    • spring-jdbc-5.1.5.RELEASE.jar
    • spring-tx-5.1.5.RELEASE.jar
  2. 创建JdbcTemplate对象（依赖于DataSource对象）：
    • JdbcTemplate template = new JdbcTemplate(dataSource)
  3. 调用JdbcTemplate的方法来完成CRUD操作

常用方法：

  • update()：执行DML语句，及对数据的增、删、改（查是DQL语句）

  • queryForMap()：将列名作为key、值作为value将这条记录封装为一个Map集合**（这个方法查询的结果只能有一条记录，如果出现了两条就会报错）**

  • queryForList()：将结果集封装为List集合**（一个Map对应一个记录，List将这些Map装起来）**

  • query()：将结果封装为JavaBean对象

    • query的参数：RowMapper

      package top.linzeliang.web.dataSource.SpringJDBC;

import java.util.Date;

public class Product {
    private String product_id;
    private String product_name;
    private String product_type;
    private Integer sale_price;
    private Integer purchase_price;
    private Date regist_date;

    public String getProduct_id() {
        return product_id;
    }

    public void setProduct_id(String product_id) {
        this.product_id = product_id;
    }

    public String getProduct_name() {
        return product_name;
    }

    public void setProduct_name(String product_name) {
        this.product_name = product_name;
    }

    public String getProduct_type() {
        return product_type;
    }

    public void setProduct_type(String product_type) {
        this.product_type = product_type;
    }

    public Integer getSale_price() {
        return sale_price;
    }

    public void setSale_price(Integer sale_price) {
        this.sale_price = sale_price;
    }

    public Integer getPurchase_price() {
        return purchase_price;
    }

    public void setPurchase_price(Integer purchase_price) {
        this.purchase_price = purchase_price;
    }

    public Date getRegist_date() {
        return regist_date;
    }

    public void setRegist_date(Date regist_date) {
        this.regist_date = regist_date;
    }

    @Override
    public String toString() {
        return "Product{" +
                "product_id='" + product_id + '\'' +
                ", product_name='" + product_name + '\'' +
                ", product_type='" + product_type + '\'' +
                ", sale_price=" + sale_price +
                ", purchase_price=" + purchase_price +
                ", regist_date=" + regist_date +
                '}';
    }
}

      然后：

      package top.linzeliang.web.dataSource.SpringJDBC;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import top.linzeliang.web.util.DruidUtil;

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

public class JDBCTemplate {

    @Test
    public void test() {
        JdbcTemplate template = new JdbcTemplate(DruidUtil.getDateSource());
        String sql = "SELECT * FROM product";
        //使用匿名内部类，重写mapRow方法
        List<Product> list = template.query(sql, new RowMapper<Product>() {
            @Override
            public Product mapRow(ResultSet rs, int i) throws SQLException {
                Product product = new Product();
                product.setProduct_id(rs.getString(1));
                product.setProduct_name(rs.getString(2));
                product.setProduct_type(rs.getString(3));
                product.setSale_price(rs.getInt(4));
                product.setPurchase_price(rs.getInt(5));
                product.setRegist_date(rs.getDate(6));
                return product;
            }
        });

        for (Product p : list) {
            System.out.println(p);
        }
    }
}

结果：
九月 14, 2020 12:33:40 上午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
Product{product_id='0001', product_name='T恤衫', product_type='衣服', sale_price=1000, purchase_price=500, regist_date=2009-09-20}
Product{product_id='0002', product_name='打孔器', product_type='办公用品', sale_price=500, purchase_price=320, regist_date=2009-09-11}
Product{product_id='0003', product_name='运动T恤', product_type='衣服', sale_price=4000, purchase_price=2800, regist_date=null}
Product{product_id='0004', product_name='菜刀', product_type='厨房用具', sale_price=3000, purchase_price=2800, regist_date=2009-09-20}
Product{product_id='0005', product_name='高压锅', product_type='厨房用具', sale_price=6800, purchase_price=5000, regist_date=2009-01-15}
Product{product_id='0006', product_name='叉子', product_type='厨房用具', sale_price=500, purchase_price=0, regist_date=2009-09-20}
Product{product_id='0007', product_name='擦菜板', product_type='厨房用具', sale_price=880, purchase_price=790, regist_date=2008-04-28}
Product{product_id='0008', product_name='圆珠笔', product_type='办公用品', sale_price=100, purchase_price=0, regist_date=2009-11-11}
Product{product_id='0009', product_name='123456789', product_type='2', sale_price=3, purchase_price=4, regist_date=null}

      • 但是这样子写有没有感觉还是太繁琐了，所以一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装，同样，可得到一样的结果

      • new BeanPropertyRowMapper<类型>(类型.class)

        package top.linzeliang.web.dataSource.SpringJDBC;

import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import top.linzeliang.web.util.DruidUtil;
import java.util.List;

public class JDBCTemplate {

    @Test
    public void test() {
        JdbcTemplate template = new JdbcTemplate(DruidUtil.getDateSource());
        String sql = "SELECT * FROM product";
        List<Product> list = template.query(sql, new BeanPropertyRowMapper<Product>(Product.class));

        for (Product p : list) {
            System.out.println(p);
        }
    }
}

  • queryForObject()：将聚合查询结果封装为指定类型的对象（一般用于聚合函数的查询）

    package top.linzeliang.web.dataSource.SpringJDBC;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import top.linzeliang.web.util.DruidUtil;

public class JDBCTemplate {

    @Test
    public void test() {
        JdbcTemplate template = new JdbcTemplate(DruidUtil.getDateSource());
        String sql = "SELECT COUNT(*) FROM product";
        int count = template.queryForObject(sql, Integer.class); /*这里填写的Integer.class是将来你的结果封装的类型，因为我们COUNT(*)查询结果是整数，所以我们使用Integer类型*/
        System.out.println(count);
    }
}
星归
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
替代Websocket的解决方案：GoEasy
程序萌部落
11-11 1307
写在前面GoEasy这个库的适用场景：同Websocket的场景在后台使用例如Java进行逻辑处理后将变量的值传入前台，前台不用发起请求即可接收后台发布的数据，整个流程与Redis的Pub和Sub过程类似整个交互类似Socket的长连接，前台首次调用不需要请求后台。非常适合监控后台参数等场景； 但是：GoEasy最大的问题：传输数据大小有限制，大概...
C3P0连接池初始化过程分析之一
iteye_69的博客
10-25 393
先把上一节的时序图拿来，强化一下印象，然后顺着图往下捋： Created with Raphaël 2.1.0C3P0连接池初始化过程UserUserComboPooledDataSourceComboPooledDataSourceC3P0PooledConnectionPoolManagerC3P0PooledConnectionPoolManagerC3P0PooledConnect...
C3P0连接池初始化设置
林妹妹的后花园
07-17 2161
1：配置web.xml文件，将初始化文件config_db.properties放进ServletContext, 监听器将从ServletContext调用初始化文件，对SQL进行初始化，这个过程随服务器开启而开启，随服务器停用而销毁。 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-app xmlns:xsi="http://www...
C3P0初始化物理数据库连接时机
XCMercy
08-03 294
存放数据库物理连接的容器 C3P0PooledConnectionPoolManager.getPool() -&amp;amp;gt; C3P0PooledConnectionPool -&amp;amp;gt; ResourcePool(BasicResourcePool) rp -&amp;amp;gt; HashMap managed 存放数据库物理连接的容器其本质是BasicResourcePool对象中的managed属性，类...
长连接/websocket/SSE等主流服务器推送技术比较
omnispace的博客
05-20 7708
最近做的某个项目有个需求，需要实时提醒client端有线上订单消息。所以保持客户端和服务器端的信息同步是关键要素，对此我们了解了可实现的方式。本文将介绍web常用的几种方式，希望给需要服务器端推送消息的同学在选型上有一点启发。一、推送技术常用的集中实现的实现方式1.1 短连接轮询：前端用定时器，每间隔一段时间发送请求来获取数据是否更新，这种方式可兼容ie和支持高级浏览器。通常采取setInterv...
3 替代websocket_WebSocket基础讲解(2)
weixin_31742467的博客
01-12 209
0.引言本篇文章主要讲解如何在服务端使用websocket。如果在服务端使用websocket，那就需要使用Node.js，就需要安装nodejs-websocket。也可以参考前面的文章进行学习:WebSocket基础讲解(1) nodejs入门的学习教程:https://www.runoob.com/nodejs/nodejs-tutorial.html1.NodeJs简述Node.js 是一...
websocket
xuguokun1986的博客
04-21 802
偶然在知乎上看到一篇回帖，瞬间觉得之前看的那么多资料都不及这一篇回帖让我对websocket 的认识深刻有木有。所以转到我博客里，分享一下。比较喜欢看这种博客，读起来很轻松，不枯燥，没有布道师的阵仗，纯粹为分享。废话这么多了，最后再赞一个~ 一、websocket与http WebSocket是html5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连
WebSocket
学习学习学习学习
12-08 324
WebSocket 文章目录WebSocket一. Http通信协议1.概念2.缺陷3.http解决只能由客户端发起的3种方法二. WebSocket通信协议1.概念简介2.Websocket和Http的请求响应图信息对比2.1.Http协议2.2Websocket协议 一. Http通信协议 1.概念 Http协议 半双工协议，在同一时刻，数据信息流向是单向的，只能由客户端发起。 2.缺陷 需要双向通信，增加编程的复杂度，一个用来处理server传输到client的数据，另一个处理clinet端传输
C3P0 DriverManagerDataSource初始化
Donald_Draper
12-08 464
WeakHashMap:[url]http://mikewang.blog.51cto.com/3826268/880775/[/url] WeakReference ：[url]http://blog.csdn.net/matrix_xu/article/details/8424038[/url] C3P0 ComboPooledDataSource初始化：[url]http://dona...
tomcat 将http协议改为https协议，Websocket请求ws协议修改为wss协议
weixin_44021888的博客
07-31 3837
tomcat 将http协议改为https协议，Websocket请求ws协议修改为wss协议 一、 说明 WS协议和WSS协议两个均是WebSocket协议的SCHEM，两者一个是非安全的，一个是安全的，也是统一的资源标志符。就好比HTTP协议和HTTPS协议的差别。非安全的没有证书，安全的需要SSL证书。（SSL是Netscape所研发，用来保障网络中数据传输的安全性，主要是运用数据加密的技术，能够避免数据在传输过程被不被窃取或者监听。）其中WSS表示在TLS之上的WebSocket。WS一般默认是8
替代Websocket的解决方案：GoEasy.docx
10-26
替代Websocket的解决方案：GoEasy.docx
WebSocket的原理与优缺点
热门推荐
小强会编码
08-07 2万+
一、websocket与httpWebSocket是HTML5中的协议，支持持久连接；而Http协议不支持持久连接。首先HTMl5指的是一系列新的API,或者说新规范，新技术。WebSocket是HTML5中新协议、新API.跟HTTP协议基本没有关系。Http协议本身只有1.0和1.1，也就是所谓的Keep-alive，把多个Http请求合并为一个。 二、Websocket是什么样的协议，具体有什
WebSocket 和socket、HTTP的区别和联系
SL_ideas的博客
06-23 2万+
上一篇介绍了WebSocket的原理和使用，这一篇介绍一下它和socket、http的区别及联系。一、WebSocket 是什么？ WebSocket是HTML5中的协议。HTML5 Web Sockets规范定义了Web Sockets API，支持页面使用Web Socket协议与远程主机进行全双工的通信。它引入了WebSocket接口并且定义了一个全双工的通信通道，通过一个单一的套接字在We
刨根问底HTTP和WebSocket协议
冷月宫主的专栏
06-11 4179
HTTP vs WebSocket那天和boss聊天，不经意间提到了Meteor，然后聊到了WebSocket，然后就有了以下对话，不得不说，看问题的方式不同，看到的东西也会大不相同。A：Meteor是一个很新的开发框架，我觉得它设计得十分巧妙。B：怎么个巧妙之处？A：它的前后端全部使用JS，做到了真正的前后端统一；前端浏览器里存有一份后台开放出来的数据库的拷贝，快；使用WebSocket协议来做...
线程池c3p0和dbcp2的配置初始化实例
weixin_34368949的博客
03-21 98
一、c3p0 public class ConnectionManager { public static ComboPooledDataSource dataSource; static { try { dataSource = new ComboPooledDataSource(); dataSource.se...
http与websocket的相同点和不同点
xiongyk的博客
09-14 2080
http与websocket的相同点和不同点
刨根问底HTTP和WebSocket协议(二）
weixin_34203832的博客
08-22 185
上篇介绍了HTTP1.1协议的基本内容，这篇文章将继续分析WebSocket协议，然后对这两个进行简单的比较。 WebSocket WebSocket协议还很年轻，RFC文档相比HTTP的发布时间也很短，它的诞生是为了创建一种「双向通信」的协议，来作为HTTP协议的一个替代者。那么首先看一下它和HTTP（或者HTTP的长连接）的区别。 为什么要用WebSocket来替代HTTP 上一篇中提到We...
WebSocket 和HTTP的区别
Yoke
09-01 2175
WebSocket 和HTTP的有什么区别呢？ http链接分为短链接，长链接，短链接是每次请求都要三次握手才能发送自己的信息。即每一个request对应一个response。长链接是在一定的期限内保持链接。保持TCP连接不断开。客户端与服务器通信，必须要有客户端发起然后服务器返回结果。客户端是主动的，服务器是被动的。 WebSocket他是为了解决客户端发起多个http请求到服务器资源浏览器必...
常用数据库连接池 (DBCP、c3p0、Druid) 配置说明
最新发布
06-01
好的，我会回答你的问题，以下是常用数据库连接池 DBCP、c3p0、Druid 的配置说明： 1. DBCP (Apache Commons DBCP) DBCP 是 Apache Commons 项目中的一个子项目，它是一个纯 Java 实现的数据库连接池。DBCP 的使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值