JDBC数据源连接池的配置

最新推荐文章于 2023-10-24 11:38:25 发布
最新推荐文章于 2023-10-24 11:38:25 发布
阅读量2.7k 收藏 4
点赞数
分类专栏： java Android 文章标签： 数据库连接池
Android 同时被 2 个专栏收录
52 篇文章 0 订阅
订阅专栏
java
16 篇文章 0 订阅
订阅专栏

使用JDBC建立数据库连接的两种方式:
1.在代码中使用DriverManager获得数据库连接。这种方式效率低，并且其性能、可靠性和稳定性随着用户访问量得增加逐渐下降。
2.使用配置数据源的方式连接数据库，该方式其实质就是在上述方法的基础上增加了数据库连接池，这种方式效率高。

数据源连接池的方式连接数据库与在代码中使用DriverManager获得数据库连接存在如下差别：
1）数据源连接池的方式连接数据库是在程序中,通过向一个JNDI(Java Naming and Directory Interface)服务器查询,即调用Context接口的lookup()方法,来得到DataSource对象,然后调用DataSource对象的getConnection()方法建立连接
2）为了能重复利用数据库连接对象,提高对请求的响应时间和服务器的性能,采用连接池技术.连接池技术预先建立多个数据库连接对象,然后将连接对象保存到连接池中,当客户请求到来时,从池中取出一个连接对象为客户服务,当请求完成时,客户程序调用close()方法,将连接对象放回池中.
3）在代码中使用DriverManager获得数据库连接的方式中,客户程序得到的连接对象是物理连接,调用连接对象的close()方法将关闭连接,而采用连接池技术,客户程序得到的连接对象是连接池中物理连接的一个句柄,调用连接对象的close()方法,物理连接并没有关闭,数据源的实现只是删除了客户程序中的连接对象和池中的连接对象之间的联系.

为了测试方便可以在数据库（这里以mysql 5为例）中建立一个USER表：

CREATE TABLE `user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`),
);

导入数据库的驱动的jar包到tomcat的lib目录下（这里以mysql5为例，所用到的jar包为：mysql-connector-java-5.0.8-bin.jar）。

1.在代码中使用DriverManager获得数据库连接。这种方式效率低，并且其性能、可靠性和稳定性随着用户访问量得增加逐渐下降。
oracle数据库连接的Java代码如下：

import java.sql.Connection;
import java.sql.DriverManager;
/**
 * 获取数据库连接
 */
public class DBConnection {

    /** Oracle数据库连接URL*/
    private final static String DB_URL = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";

    /** Oracle数据库连接驱动*/
    private final static String DB_DRIVER = "oracle.jdbc.driver.OracleDriver";

    /** 数据库用户名*/
    private final static String DB_USERNAME = "root";

    /** 数据库密码*/
    private final static String DB_PASSWORD = "admin";

    /**
     * 获取数据库连接
     * @return
     */
    public Connection getConnection(){
        /** 声明Connection连接对象*/
        Connection conn = null;
        try{
            /** 使用Class.forName()方法自动创建这个驱动程序的实例且自动调用DriverManager来注册它*/
            Class.forName(DB_DRIVER);
            /** 通过DriverManager的getConnection()方法获取数据库连接*/
            conn = DriverManager.getConnection(DB_URL,DB_USERNAME,DB_PASSWORD);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return conn;
    }

    /**
     * 关闭数据库连接
     * 
     * @param connect
     */
    public void closeConnection(Connection conn){
        try{
            if(conn!=null){
                /** 判断当前连接连接对象如果没有被关闭就调用关闭方法*/
                if(!conn.isClosed()){
                    conn.close();
                }
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }

}

mysql数据库连接的JSP代码如下：

<%@page import="java.sql.*, com.mysql.jdbc.Driver"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>  
    <%
    //com.mysql.jdbc.Driver
    Class.forName(Driver.class.getName()).newInstance();
    String url = "jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF8";
    String user = "root";
    String password = "123";

    Connection conn = DriverManager.getConnection(url, user, password);
    Statement stmt = conn.createStatement();

    String sql = "select * from user";
    ResultSet rs = stmt.executeQuery(sql);

    while(rs.next()) {
        out.print("<br />" + "====================" + "<br />");
        out.print(rs.getLong("id") + "   ");
        out.print(rs.getString("username") + "   ");
        out.print(rs.getString("password") + "   ");
        out.print(rs.getString("email") + "   ");
    }
    %>
</body>
</html>

2.使用配置数据源的方式连接数据库，该方式其实质就是在上述方法的基础上增加了数据库连接池，这种方式效率高。
1）mysql数据库数据源连接池的JSP代码如下：

<%@page import="java.sql.*, javax.naming.*, javax.sql.DataSource"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>
    <%
    Context initCtx = new InitialContext();
    DataSource ds = (DataSource)initCtx.lookup("java:comp/env/jdbc/demoDB");
    Connection conn = ds.getConnection();

    Statement stmt = conn.createStatement();

    String sql = "select * from user";
    ResultSet rs = stmt.executeQuery(sql);

    while(rs.next()) {
        out.print("<br />" + "====================" + "<br />");
        out.print(rs.getLong("id") + "   ");
        out.print(rs.getString("username") + "   ");
        out.print(rs.getString("password") + "   ");
        out.print(rs.getString("email") + "   ");
    }
    %>
</body>
</html>

2） 添加如下代码到tomcat的conf目录下的server.xml中：

<Context> 
    <Resource name="jdbc/demoDB" auth="Container" 
    type="javax.sql.DataSource"
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/demo"
    username="root"
    password="123"
    maxActive="50"
    maxIdle="30"
    maxWait="10000" />
</Context>

3）在web工程目录下的web.xml的根节点下配置如下内容：

<resource-ref>
    <description>mysqlDB Connection</description>
    <res-ref-name>jdbc/demoDB</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
</resource-ref>

完成上述步骤数据源的连接池配置已经完成，但是为了提高项目的可移植性，最好将上述第二步的内容放入到工程的META-INF目录的context.xml中（这个文件需要自行建立）：

<?xml version="1.0" encoding="UTF-8"?>
<Context>
      <Resource name="jdbc/demoDB" auth="Container" 
      type="javax.sql.DataSource"
      driverClassName="com.mysql.jdbc.Driver"
      url="jdbc:mysql://localhost:3306/demo"
      username="root"
      password="123"
      maxActive="50"
      maxIdle="30"
      maxWait="10000" />
</Context>

3.使用配置数据源的数据库连接池时的数据库操作工具类
代码如下：

package db.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.naming.InitialContext;
import javax.sql.DataSource;

//import org.apache.log4j.Logger;

/**
 * 数据库操作辅助类
 */
public class DbUtils {

    //private static Logger logger = Logger.getLogger("DbUtils");

    /**
     * 该语句必须是一个 SQL INSERT、UPDATE 或 DELETE 语句
     * @param sql
     * @param paramList：参数，与SQL语句中的占位符一一对应
     * @return
     * @throws Exception
     */
    public int execute(String sql, List<Object> paramList) throws Exception {
        if(sql == null || sql.trim().equals("")) {
            //logger.info("parameter is valid!");
        }

        Connection conn = null;
        PreparedStatement pstmt = null;
        int result = 0;
        try {
            conn = getConnection();
            pstmt = DbUtils.getPreparedStatement(conn, sql);
            setPreparedStatementParam(pstmt, paramList);
            if(pstmt == null) {
                return -1;
            }
            result = pstmt.executeUpdate();
        } catch (Exception e) {
            //logger.info(e.getMessage());
            throw new Exception(e);
        } finally {
            closeStatement(pstmt);
            closeConn(conn);
        }

        return result;
    }

    /**
     * 将查询数据库获得的结果集转换为Map对象
     * @param sql：查询语句
     * @param paramList：参数
     * @return
     */
    public List<Map<String, Object>> getQueryList(String sql, List<Object> paramList) throws Exception {
        if(sql == null || sql.trim().equals("")) {
            //logger.info("parameter is valid!");
            return null;
        }

        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        List<Map<String, Object>> queryList = null;
        try {
            conn = getConnection();
            pstmt = DbUtils.getPreparedStatement(conn, sql);
            setPreparedStatementParam(pstmt, paramList);
            if(pstmt == null) {
                return null;
            }
            rs = getResultSet(pstmt);
            queryList = getQueryList(rs);
        } catch (RuntimeException e) {
            //logger.info(e.getMessage());
            System.out.println("parameter is valid!");
            throw new Exception(e);
        } finally {
            closeResultSet(rs);
            closeStatement(pstmt);
            closeConn(conn);
        }
        return queryList;
    }

    private void setPreparedStatementParam(PreparedStatement pstmt, List<Object> paramList) throws Exception {
        if(pstmt == null || paramList == null || paramList.isEmpty()) {
            return;
        }
        DateFormat df = DateFormat.getDateTimeInstance();
        for (int i = 0; i < paramList.size(); i++) {
            if(paramList.get(i) instanceof Integer) {
                int paramValue = ((Integer)paramList.get(i)).intValue();
                pstmt.setInt(i+1, paramValue);
            } else if(paramList.get(i) instanceof Float) {
                float paramValue = ((Float)paramList.get(i)).floatValue();
                pstmt.setFloat(i+1, paramValue);
            } else if(paramList.get(i) instanceof Double) {
                double paramValue = ((Double)paramList.get(i)).doubleValue();
                pstmt.setDouble(i+1, paramValue);
            } else if(paramList.get(i) instanceof Date) {
                pstmt.setString(i+1, df.format((Date)paramList.get(i)));
            } else if(paramList.get(i) instanceof Long) {
                long paramValue = ((Long)paramList.get(i)).longValue();
                pstmt.setLong(i+1, paramValue);
            } else if(paramList.get(i) instanceof String) {
                pstmt.setString(i+1, (String)paramList.get(i));
            }
        }
        return;
    }

    /**
     * 获得数据库连接
     * @return
     * @throws Exception
     */
    private Connection getConnection() throws Exception {
        InitialContext cxt = new InitialContext();
        DataSource ds = (DataSource) cxt.lookup(jndiName);
        if ( ds == null ) {
           throw new Exception("Data source not found!");
        }

        return ds.getConnection();
    }

    private static PreparedStatement getPreparedStatement(Connection conn, String sql) throws Exception {
        if(conn == null || sql == null || sql.trim().equals("")) {
            return null;
        }
        PreparedStatement pstmt = conn.prepareStatement(sql.trim());
        return pstmt;
    }

    /**
     * 获得数据库查询结果集
     * @param pstmt
     * @return
     * @throws Exception
     */
    private ResultSet getResultSet(PreparedStatement pstmt) throws Exception {
        if(pstmt == null) {
            return null;
        }
        ResultSet rs = pstmt.executeQuery();
        return rs;
    }

    /**
     * @param rs
     * @return
     * @throws Exception
     */
    private List<Map<String, Object>> getQueryList(ResultSet rs) throws Exception {
        if(rs == null) {
            return null;
        }
        ResultSetMetaData rsMetaData = rs.getMetaData();
        int columnCount = rsMetaData.getColumnCount();
        List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();
        while (rs.next()) {
            Map<String, Object> dataMap = new HashMap<String, Object>();
            for (int i = 0; i < columnCount; i++) {
                dataMap.put(rsMetaData.getColumnName(i+1), rs.getObject(i+1));
            }
            dataList.add(dataMap);
        }
        return dataList;
    }

    /**
     * 关闭数据库连接
     * @param conn
     */
    private void closeConn(Connection conn) {
        if(conn == null) {
            return;
        }
        try {
            conn.close();
        } catch (SQLException e) {
            //logger.info(e.getMessage());
        }
    }

    /**
     * 关闭
     * @param stmt
     */
    private void closeStatement(Statement stmt) {
        if(stmt == null) {
            return;
        }
        try {
            stmt.close();
        } catch (SQLException e) {
            //logger.info(e.getMessage());
        }
    }

    /**
     * 关闭
     * @param rs
     */
    private void closeResultSet(ResultSet rs) {
        if(rs == null) {
            return;
        }
        try {
            rs.close();
        } catch (SQLException e) {
            //logger.info(e.getMessage());
        }
    }


    private String jndiName = "java:/comp/env/jdbc/demoDB";

    public void setJndiName(String jndiName) {
        this.jndiName = jndiName;
    }
}
强者用结果说话
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC 连接池的配置
为学日益 为道日损
03-16 562
jdbc java database connectivity 是java编程语言数据库连接技术的简称。是一组java类和接口的集合，对Java程序员而言是API， 可以通过一组代码完成对不同数据库的连接，减少了代码量，提高开发效率，易于维护。对数据库厂商而言是接口规范，他们根据该 接口规范提供针对不同数据库的具体实现——JDBC 驱动。 连接池技术： 问题：每次处理对
JDBC的数据连接池
Bingdworld的博客
03-13 190
数据库连接池 池参数（所有池参数都有默认值）： 初始大小：10个 最小空闲连接数：3个 增量：一次创建的最小单位（5个） 最大空闲连接数：12个 最大连接数：20个 最大的等待时间：1000毫秒 四大连接参数 连接池也是使用四大连接参数来完成创建连接对象！ 实现的接口 连接池必须实现：javax.sql.DataSource接口！ 连接池返回的Connection对象，它的c...
JDBC数据源连接池配置及应用
09-02
主要介绍JDBC建立数据库连接的两种方式，使用配置数据源的方式连接数据库，效率更高，推荐使用，希望能给大家做一个参考。
JDBC的连接和参数详解
NeymarTG的博客
04-28 3725
JDBC的概念: jdbc:Java DataBase Connectivity. Java 数据库连接 java语言操作数据库 JDBC的本质: 是官方(sun公司)定以的一套操作所有关系型数据库的规则,即接口.各个数据库厂商去实现这套接口,提供数据库驱动jar包.我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的驱动类. 快速入门： 步骤： 1. 导入驱动jar...
JDBC参数配置
10-19
JDBC参数配置JDBC参数配置JDBC参数配置JDBC参数配置
JDBC常用参数解析
大道至简
10-24 5842
Druid 基本配置 name 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是："DataSource-" + System.identityHashCode(this)； jdbcUrl：连接地址，如：mysql : jdbc:mysql://127.0.0.1:3306/test-db； username：用户名； pa...
JDBC核心技术（获取数据库链接、数据库事务、数据库链接池）
SixFeet Under的博客
05-22 1741
文章目录前言数据的持久化Java数据存储技术JDBC介绍JDBC体系结构获取数据库链接Driver接口加载注册JDBC驱动获取数据库链接数据库链接方式（实例）方式一：代码中显示出现了第三方数据库API（不推荐）方式二：代码中不体现第三方数据库API（推荐）PreparedStatement实现CRUD操作两种技术PreparedStatement介绍使用Statement操作数据表的弊端（不推荐）PreparedStatement的使用PreparedStatement介绍PreparedStatement
JDBC连接参数配置
weixin_40017062的博客
10-24 3675
JDBC连接参数配置
JDBC详解
weixin_48373085的博客
01-12 3959
JDBC详解
JDBC数据源连接池的配置和使用示例
04-03
**JDBC数据源连接池配置与使用详解** 在Java Web应用中，数据库连接的管理是至关重要的。为了提高性能和资源利用率，开发人员通常会使用数据源连接池。本篇文章将详细讲解JDBC数据源连接池的配置和使用，以帮助你更...
JSP Servelet 数据源连接池的配置
01-08
1.配置Context.xml文件 代码如下:<Resource name=”jdbc/books” //引用名可以自定义 auth=”Container” //指定管理DataSource的Manager type=”javax.sql.DataSource” //指定包名 maxActive=”100″ //最大可...
Tongweb5中配置JDBC连接池
10-13
总的来说，Tongweb5中的JDBC连接池配置是一项关键的系统优化工作，通过合理的配置和使用，可以显著提升Web应用的性能和稳定性。在实践中，开发者需要根据具体的应用场景和负载情况，进行细致的调整和测试，以达到...
Spring 数据库连接池（JDBC）详解
08-30
2. c3p0：Hibernate 开发组推荐使用的数据库连接池，它实现了数据源和 JNDI 的绑定。 3. Proxool：Proxool 的口碑较好，没什么负面评价（比如 dbcp 就是因为 Hibernate 认为它 BUG 太多 Hibernate 才不推荐使用的）...
JDBC 参数
热门推荐
dingxingmei的专栏
12-16 1万+
JDBC连接池参数：     jdbc.initialSize=0       //初始化连接     jdbc.maxActive=30     //连接池的最大数据库连接数，设为0表示无限制     jdbc.maxIdle=20        //没有人用连接的时候，最大闲置的连接个数，设置为0时，表示没有限制。     jdbc.maxWait=1000    //超时等待时间以毫
JDBC部分参数讲解
jiaona_chen123的博客
03-18 670
JDBC部分参数讲解 问题描述 benchmarksql配置文件 db=mysql driver=com.mysql.jdbc.Driver conn=jdbc:mysql://172.16.130.48:3306/benchmarksql user=root password=greatdb warehouses=1 loadWorkers=4 terminals=1 //To run specified transactions per terminal- runMins must equal z
MySQL-JDBC连接池基本使用和配置
L_xs_123的博客
07-31 1112
连接池 因为使用JDBC连接数据库->执行完毕->施放 这个过程非常浪费资源,所以需要数据库连接池 连接池就是预先准备好一些连接好的对象 需要就拿出来 不用了就放回去 编写连接池需要实现DataSource接口 DBCP连接池 要先导入对应的jar包 这里用下maven 用的是commons-dbcp-1.4和commons-pool-1.6 <!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp --&g
JDBC 连接池 详解（通俗易懂）
Cyan_RA9的博客
06-11 6569
JDBC 第五节 详解连接池 通俗易懂！
JDBC小记——连接池
m0_63138660的博客
06-26 1149
由于建立数据库连接是一种非常耗时、耗资源的行为，所以预先通过连接池创建一些连接，放在内存中，当程序需要建立数据库连接时，直接在连接池中申请一个，使用完毕再还回去。连接池就跟线程池一样，使用时申请，使用结束归还。数据库连接由连接池分配、管理、和释放，一个程序能重复使用一个连接池中的连接，而不用重复创建，还可以设置连接池的初始连接数，最大最小连接数等。
【Datawhale AI 夏令营第三期学习笔记Taks1】 跑通baseline #Datawhale AI 夏令营
最新发布
07-28
【Datawhale AI 夏令营第三期学习笔记Taks1】 跑通baseline #Datawhale AI 夏令营
JDBC数据库访问：配置数据源与连接池详解
通过JDBC，可以设计一个系统架构，将数据源连接、数据操作和结果处理模块化，确保代码的可维护性和性能优化。 4.4 数据源与连接池技术 连接池是提高数据库性能的关键技术，它预先创建并管理一定数量的数据库连接，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值