自己动手写struts笔记3

连接池的接口类:

 

 

package com.gd.jdbc;

 

import java.sql.Connection;

import java.sql.SQLException;

 

//连接池   接口编程

public interface DbConnectionPool {

 

/**

 * 设定连接池中存放连接的数目

 * @param numConnections

 */

public void setMaxConns(int numConnections);

/**

 * 设定打开或者关闭连接池

 * @param onOrOff

 * @throws Exception

 */

public void setConnWitch(String onOrOff)throws Exception;

/**

 * 产生连接池

 * @throws SQLException

 */

public void initConnPool()throws SQLException;

/**

 * 从连接池中获取连接

 * @return

 * @throws SQLException

 */

public Connection getConnection()throws SQLException;

/**

 * 将连接返回给连接池

 * @throws SQLException

 */

public void returnConnection()throws SQLException;

/**

 * 销毁连接池

 * @throws SQLException

 */

public void destroyConnPool()throws SQLException;

}

 

 

 

 

连接池的接口实现类:

package com.gd.jdbc.impl;

 

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

import com.gd.jdbc.DbConnectionPool;

 

//连接池的具体实现方式

 

public class GdDbConnectionPool implements DbConnectionPool {

 

private String DB_DRIVER="com.mysql.jdbc.Driver";

private String DB_User="root";

private String DB_PASSWD="shaokai";

private String DATASRC_URL="jdbc:mysql://localhost:3306/myApp";

 

static final int defaultMaxConnections=10;//默认的连接池的大小

private List freeConnections;//存放目前空闲的连接,空闲池

private Map busyConnections;//存放目前正在使用的连接,繁忙池

private int maxConnections;//设定连接池的大小

/**

 * 构造函数

 * @param numConnections

 */

public GdDbConnectionPool(int numConnections){

maxConnections=numConnections;

freeConnections=null;

busyConnections=null;

}

/**

 * 构造函数

 */

public GdDbConnectionPool(){

maxConnections=defaultMaxConnections;

freeConnections=null;

busyConnections=null;

}

public void destroyConnPool()throws SQLException{

//假如还有正在使用的连接

if(busyConnections!=null){

Set set=busyConnections.entrySet();

Iterator iterator=set.iterator();

//销毁正在使用的连接

while(iterator.hasNext()){

Map.Entry map=(Map.Entry)iterator.next();

Connection conn=(Connection)map.getValue();

conn.close();

}

busyConnections=null;

}

//假如还有空闲的连接

if(freeConnections!=null){

//销毁空闲的连接

for(int i=0;freeConnections.size()>i;i++){

Connection conn=(Connection)freeConnections.get(i);

conn.close();

}

freeConnections=null;

}

}

public synchronized Connection getConnection()throws SQLException{

if(freeConnections==null){

throw new SQLException("连接池还没有创建");

}

try{

//表示没有空闲的连接

if(freeConnections.size()==0)

wait();

}catch(InterruptedException e){

e.printStackTrace();

}

//获取空闲池的连接

Connection conn=(Connection)freeConnections.get(0);

freeConnections.remove(0);//在空闲池里销毁已经获取的连接

busyConnections.put(Thread.currentThread(), conn);//将已经获取的连接放在繁忙池里

System.out.println("getConnection后:===========================================================");

System.out.println("freeConnections空闲连接有:"+freeConnections.size());

System.out.println("busyConnections繁忙连接有:"+busyConnections.size());

return conn;

}

public void initConnPool()throws SQLException{

try{

freeConnections=new ArrayList(maxConnections);

busyConnections=new HashMap(maxConnections);

//创建连接,并放在连接池中

Class.forName(DB_DRIVER);

// conn=DriverManager.getConnection(DATASRC_URL,DB_User,DB_PASSWD);

// GdDbConnection con=new GdDbConnection(this);

for(int i=0;i<maxConnections;i++){

freeConnections.add(DriverManager.getConnection(DATASRC_URL,DB_User,DB_PASSWD));

}

}catch(Exception e){

freeConnections=null;

busyConnections=null;

throw new SQLException(e.toString());

}

System.out.println("初始化ConnPool后:===========================================================");

System.out.println("freeConnections空闲连接有:"+freeConnections.size());

System.out.println("busyConnections繁忙连接有:"+busyConnections.size());

}

public synchronized void returnConnection()throws SQLException{

//从繁忙池中销毁已经返回的连接

Connection conn=(Connection)busyConnections.get(Thread.currentThread());

if(conn==null)

throw new SQLException("没有发现繁忙池中有连接");

busyConnections.remove(Thread.currentThread());

//将已经返回的连接池重新放回空闲池

freeConnections.add(conn);

System.out.println("returnConnection后:===========================================================");

System.out.println("freeConnections空闲连接有:"+freeConnections.size());

System.out.println("busyConnections繁忙连接有:"+busyConnections.size());

notify();

}

public void setConnWitch(String onOrOff)throws Exception{

try{

//假如为ON,则表示初始化连接池

if("ON".equalsIgnoreCase(onOrOff)){

initConnPool();

//假如为OFF,则表示销毁连接池

}else if("OFF".equalsIgnoreCase(onOrOff)){

destroyConnPool();

}

}catch(Exception e){

e.printStackTrace();

}

}

public void setMaxConns(int numConnections){

maxConnections=numConnections;

}

 

}

 

 

 

 

连接池的管理类:

 

package com.gd.jdbc;

 

import java.sql.Connection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

 

import com.gd.jdbc.impl.GdDbConnectionPool;

 

//实现连接池的管理类

 

 

public class DbConnectionManager {

 

static private DbConnectionManager instance;//单例模式

private static Map connPool=new HashMap();

/**

 * 返回唯一实例,如果是第一次调用此方法,则创建实例

 * @return

 */

static synchronized public DbConnectionManager getInstance(){

if(instance==null)

instance=new DbConnectionManager();

return instance;

}

/**

 * 防止其他对象创建本类的实例  private 

 */

private DbConnectionManager(){

init();

}

/**

 * 根据名称从Map中获取连接

 * @param names

 * @return

 */

public static Connection getConnection(String names){

Connection conn=null;

try{

//从连接池中获取连接  先获取连接池

DbConnectionPool pool=(GdDbConnectionPool)connPool.get(names);

if(pool!=null)

conn=pool.getConnection();

}catch(Exception e){

e.printStackTrace();

}finally{

return conn;

}

}

/**

 * 将连接返回给连接池

 * @param name

 * @param conn

 */

public static void returnConnection(String name,Connection conn){

try{

DbConnectionPool pool=(GdDbConnectionPool)connPool.get(name);

if(pool!=null)

pool.returnConnection();

}catch(Exception e){

e.printStackTrace();

}

}

/**

 * 关闭所有连接

 */

public synchronized void release(){

try{

Set set=connPool.entrySet();

Iterator iterator=set.iterator();

while(iterator.hasNext()){

Map.Entry map=(Map.Entry)iterator.next();

DbConnectionPool pool=(GdDbConnectionPool)map.getValue();

//关闭连接池

pool.setConnWitch("OFF");

}

connPool=null;

}catch(Exception e){

e.printStackTrace();

}

}

/**

 * 创建连接池

 */

private void createPools(){

DbConnectionPool pool=new GdDbConnectionPool();

//设定连接池的大小

pool.setMaxConns(10);

try{

//表示创建连接池

pool.setConnWitch("ON");

//将创建后的连接池放入Map中,用mysql表示是用于连接MySQL数据库

connPool.put("mysql", pool);

}catch(Exception e){

e.printStackTrace();

}

}

/**

 * 初始化

 */

private void init(){

//创建连接池

createPools();

}

}