数据库连接池两种配置方式详解

数据库连接池:
   负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏；
数据库连接池原理:
   连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立、断开都由连接池自身来管理。同时，还可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等；
分类：
1.Tomcat数据源连接池，依赖于web容器tomcat服务器，采用java的JNDI获取DataSource对象；
2.C3P0是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布,包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象；
3.DBCP DBCP是一个依赖commons-pool对象池机制的数据库连接池，DBCP可以直接的在应用程序用使用；
方式：

一传统方式：
tomcat数据库连接池配置：
1）首先将连接数据库jar包拷贝到tomcat下的lib文件夹下；
2）更改tomcat/conf/context.xml文件，加入数据源配置；

<Resource name="myshop" auth="Container" type="javax.sql.DataSource" maxActive="25" maxIdle="3" maxWait="10000"
    username="sa" password="sa" driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver"
    url="jdbc:sqlserver://localhost:1433;databaseName=yun4jbook"    />

首先利用tomcat的web管理配置数据源，resource配置项中属性说明：  

 name：数据源连接池命名  

url：连接数据库的URL

driverClassName： 数据库驱动类
username：数据库的用户名 
password：是数据库的密码 

maxActive : 最大的活动连接数 

maxIdle：最大的空闲连接数

maxWait： 最大的等待时间，毫秒为单位
type：resource所属的java类名
auth:指定由谁管理数据源

Container表示由容器管理
3）打开项目的web.xml加入数据源的配置；

<resource-ref>
        <!-- name属性必须放在第一位 -->
        <res-ref-name>myshop</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>

4）编写dao代码，使用JNDI（java naming and Directory Interface）技术取得数据源以数据源的形式操作数据库；

package com.jinzhi.db;

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

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

/**
 * 2017-5-9
 * @author lin
 *
 */
public class DBManager {
	//上下文关系对象
	private static Context context;
	//数据源
	private static DataSource ds;
	//数据库连接对象
	private Connection conn;
	//数据库sql语句预编译对象
	private PreparedStatement ps; 
	//查询结果集
	protected ResultSet rs;
	/**
	 * 连接池负责连接数据库
	 */
	static{
		try {
			context = new InitialContext();
			ds = (DataSource) context.lookup("java:comp/env/myshop");
		} catch (NamingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	{
		System.out.println("aa");
	}
	
	/**
	 * 获得connection对象
	 * @return
	 */
	public Connection getConn(){
//		try {
//			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
//			conn = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;dataBaseName=yun4jbook", "sa", "sa");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (SQLException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		try {
			conn = ds.getConnection();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}
	/**
	 * 关闭数据库方法
	 */
	public void closeAll(){
		
		try {
			if(null!=rs){
				rs.close();
			}
			if(null!=ps){
				ps.close();
			}
			if(null!=conn){
				conn.close();
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 查询结果集
	 * 注意：查询结果集时不能关闭数据库连接，否则拿不到连接
	 * @param sql
	 * @param obj
	 * @return
	 */
	public ResultSet query(String sql,Object [] obj){
		conn = getConn();
		try {
			ps = conn.prepareStatement(sql);
			if(obj!=null&&obj.length>0){
				for (int i = 0; i < obj.length; i++) {
					ps.setObject(i+1, obj[i]);
				}
				
			}
			rs = ps.executeQuery();
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return rs;
	}
	
	/**
	 * 更新数据的方法
	 * 注意：更新数据后应该关闭数据库连接
	 * @param sql
	 * @param obj
	 * @return
	 */
	public int update(String sql,Object [] obj){
		conn = getConn();
		int count = 0;
		try {
			ps = conn.prepareStatement(sql);
			if(obj!=null&&obj.length>0){
				for (int i = 0; i < obj.length; i++) {
					ps.setObject(i+1, obj[i]);
				}
			}
			count = ps.executeUpdate();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			closeAll();
		}
		return count;
	}
	
	/**
	 * 重写了connection方法
	 * @param conn
	 * @param sql
	 * @param obj
	 * @return
	 * @throws SQLException
	 */
	public ResultSet queryNotClose(Connection conn,String sql,Object [] obj) throws SQLException{
		
		ps = conn.prepareStatement(sql);
		if(obj!=null&&obj.length>0){
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i+1, obj[i]);
			}
			
		}
		rs = ps.executeQuery();
		return rs;
	}
	
	/**
	 * 为后期保证操作在一个事务中，重写了update方法，添加了connection
	 * @param conn
	 * @param sql
	 * @param obj
	 * @return
	 * @throws SQLException
	 */
	public int updateNotClose(Connection conn,String sql,Object [] obj) throws SQLException{
		int count = 0;
		ps = conn.prepareStatement(sql);
		if(obj!=null&&obj.length>0){
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i+1, obj[i]);
			}
		}
		count = ps.executeUpdate();
		return count;
	}
	
	/**
	 * 测试方法
	 * @param args
	 */
	public static void main(String[] args) {
		DBManager db = new DBManager();
		System.out.println(db.getConn());
	}
}

 二.Druid方式：
1.druid-0.2.15.jar包
2.编写一个xx.properties文件

下面是一个oracle的配置文件

url = jdbc:oracle:thin:@127.0.0.1:1521/orcl
username = detection1
password = detection1
initialSize = 5
maxActive = 10
minIdle = 3
maxWait = 60000
removeAbandoned = true
removeAbandonedTimeout = 180
timeBetweenEvictionRunsMillis = 60000
minEvictableIdleTimeMillis = 300000
testWhileIdle = true 
testOnBorrow = false
testOnReturn = false
poolPreparedStatements = true
maxPoolPreparedStatementPerConnectionSize = 50
filters = stat

3.连接数据库

package testDruid;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;

public class OracleDB {

	private static DataSource ds = null;	
	
	private PreparedStatement ps;
	
	private ResultSet rs;
	
	private Connection conn;
	
	
	static {
		try{
				//读取配置文件oracle.properties
			InputStream in = OracleDB.class.getClassLoader()
					               .getResourceAsStream("oracle.properties");
            Properties props = new Properties();
       //加载配置文件
			props.load(in);
			//创建数据源
			ds = DruidDataSourceFactory.createDataSource(props);
		}catch(Exception ex){
			ex.printStackTrace();
		}
	}
	//得到数据库连接对象
	public Connection openConnection() throws SQLException{
		return ds.getConnection();
	}	

	//得到查询结果集
	public ResultSet find(String sql,Object...objects){
		try {
			conn = ds.getConnection();
			ps = conn.prepareStatement(sql);
			if(objects!=null&&objects.length>0){
				for (int i = 0; i < objects.length; i++) {
					ps.setObject(i+1, objects[i]);
				}
			}
			rs = ps.executeQuery();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return rs;
	}
	//进行数据更新
	public int update(String sql,Object...objects){
		int count = 0;
		try {
			conn = ds.getConnection();
			ps = conn.prepareStatement(sql);
			if(objects!=null&&objects.length>0){
				for (int i = 0; i < objects.length; i++) {
					ps.setObject(i+1, objects[i]);
				}
			}
			count = ps.executeUpdate();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return count;
	}
	//关闭数据库连接
	public void close(){
		try {
			if(rs!=null){
				rs.close();
			}
			if(ps!=null){
				ps.close();
			}
			if(conn!=null){
				conn.close();
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

 

转载于:https://www.cnblogs.com/julinhuitianxia/p/6832593.html