JDBC数据源连接池配置及应用_java

使用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;
 }
}

总结：使用配置数据源的方式连接数据库，这种方式效率高且性能稳定，推荐使用。

查看更多Java的语法，大家可以关注：《Thinking in Java 中文手册》、《JDK 1.7 参考手册官方英文版》、《JDK 1.6 API java 中文参考手册》、《JDK 1.5 API java 中文参考手册》，也希望大家多多支持。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索tomcat
， mysql
， jdbc
， 连接池
， 数据源
DriverManager
配置高并发jdbc连接池、jdbc连接池配置、jdbc数据库连接池配置、tomcat配置jdbc连接池、jdbc c3p0连接池配置，以便于您获取更多的相关知识。

时间： 2025-01-27 07:16:18

JDBC数据源连接池配置及应用_java的相关文章

Spring的JNDI数据源连接池配置示例及Spring对JNDI实现分析

在使用 Tomcat服务器 + SpringFramework 进行JavaEE项目的开发部署的时候可以在Tomcat的配置文件中进行JDBC数据源的配置,具体步骤如下(这里省略了工程的建立步骤):   1) 添加如下代码到tomcat的conf目录下的server.xml中: Xml代码   <Context>        <Resource name="jdbc/demoDB" auth="Container"        type=&qu

Spring的JNDI数据源连接池配置时产生的疑问

问题描述 在进行Spring的数据源连接池的配置的时候,不能理解以下问题:运行如下代码:public static void main(String[] args) {org.springframework.jndi.JndiObjectFactoryBean jofb = new org.springframework.jndi.JndiObjectFactoryBean();javax.sql.DataSource ds = (javax.sql.DataSource)jofb;org.sp

tomcat 几种连接池配置代码（包括tomcat5.0,tomcat5.5x,tomcat6.0）_Tomcat

Tomcat6.0连接池配置 1.配置tomcat下的conf下的context.xml文件,在之间添加连接池配置: 复制代码 代码如下: <Resource name="jdbc/oracle" auth="Container" type="javax.sql.DataSource" driverClassName="oracle.jdbc.driver.OracleDriver" url=" jdbc:or

spring-Spring与JDBC整合连接池问题

问题描述 Spring与JDBC整合连接池问题 使用的是Spring4.0, beans.xml如下 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="com.mysql.jdbc.D

Birt报表使用连接池配置

现阶段我们在开发报表的时候,是使用jdbc链接数据库的,为提高报表的运行效率和稳定性,使用连接池进行管理.比较简便和低耦合的解决办法,使用jndi连接池. jdbc和jndi的区别 JDBC -最基本的连接数据库的方式, 每次对数据库打交道的时候 ,连接数据库是需要实例下你实现连接数据库的方法或者类. JNDI DataSource 英文全称是:Java Naming and Directory Interface java 命明接口,当服务启动时 事先把连接数据库的已经连好多条,具体多少条你可

使用Spring管理数据源连接池

问题描述 不管通过何种持久化技术,都必须通过数据连接访问数据库,在Spring中,数据连接是通过数据源获得的.在以往的应用中,数据源一般是Web应用服务器提供的.在Spring中,你不但可以通过JNDI获取应用服务器的数据源,也可以直接在Spring容器中配置数据源,此外,你还可以通过代码的方式创建一个数据源,以便进行无依赖的单元测试.配置一个数据源Spring在第三方依赖包中包含了两个数据源的实现类包,其一是Apache的DBCP,其二是C3P0.在此重点讲讲C3P0的配置:此后会更新DBCP

websphere连接池配置

问题描述 websphere配置DB2v7.2的连接池,不知哪位高手可以帮帮我如何设置呢?急!! 解决方案 解决方案二:你说说出现什么问题了?关键点在于驱动的配置路径上解决方案三:系统是Linux前面jdbc提供程序那里因为db2是7.2版本不支持jcc我选用的是用户自定义.然后添加连接池的时候,找不到设置connecturl的地方,定制属性不知道该如何命名.希望能得到帮助!解决方案四:1.jdbc提供者创建一个DB2连接池数据源或者XA数据源(如果没有的话就自己配置)2.J2C认证数据条目上创

Tomcat+SQL Server2000连接池配置

server|server2000|sql 终于解决了困扰多天的连接池的问题,写下这编文章与大家一起分享.我是在tomcat5.5.9下配置的,tomcat5.5.X和以前的版本有一些差别,所以配置上也有差别.我就说一下在tomcat5.5.9配置的基本步骤:(确定你以安装好tomcat5.5.9.sql2000) 1.把数据库JDBC驱动拷贝到%TOMCAT_HOME%/common/lib和%TOMCAT_HOME%/webapps/yourweb/WEB-INF/lib下(我的web文件夹

Tomcat+SQL Server 2000连接池配置

终于解决了困扰多天的连接池的问题,写下这编文章与大家一起分享.我是在tomcat5.5.9下配置的,tomcat5.5.X和以前的版本有一些差别,所以配置上也有差别.我就说一下在tomcat5.5.9配置的基本步骤:(确定你以安装好tomcat5.5.9.sql2000) 1.把数据库JDBC驱动拷贝到%TOMCAT_HOME%/common/lib和%TOMCAT_HOME%/webapps/yourweb/WEB-INF/lib下(我的web文件夹名字叫quickstart) 这一步大家都知