socket 客户端连接池实现

本文参考：http://cache.baidu.com/c?m=9f65cb4a8c8507ed4fece76310508a24420597634b86914323c3933fcf331d5c017be3b925251204d3c561640ab24859e1fa3c77341420c0c18ed714c9fecf6879877f67344f9141639244fe921163d620e14d99db0e96cce742e3b9a1d6c85523dd23016df1809c5b7003bb6ce76740f4d6ef5f635e07bb9d2715fe4e0123&p=8b2a9f1fce934eac59eace2c5f408c&newp=b46cc64adc9a02ff57ee9579420885231610db2151d0d74c3c&user=baidu&fm=sc&query=java+Socket+%BF%CD%BB%A7%B6%CB%C1%AC%BD%D3%B3%D8&qid=b594b3745708111f&p1=9

 

并对此文代码稍作修改，未经测试，只作参考。

 

自定义socket连接：

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

import org.apache.log4j.Logger;

/**
 * <p>
 * Title: socket连接的简单实现
 * </p>
 * 
 * <p>
 * Description: 
 * </p>
 * 
 * <p>
 * Copyright: 融博技术有限公司 2012
 * </p>
 * 
 * @author 袁泉锋HO174959
 * @version 1.0
 * @date Oct 15, 2012
 *
 */
public class SocketConnection extends Socket {
	private static final Logger logger = Logger.getLogger("FrameLog");
	/**
	 * status false 繁忙 true 空闲
	 */
	private boolean status = true;

	/** 
	  *   默认的构造函数 
	  */
	public SocketConnection() {
		super();
	}

	/**
	 * ConnectionAdapter constructor
	 */
	public SocketConnection(String host, int port)
			throws UnknownHostException, IOException {
		super(host, port);
	}

	/**
	 * <Description>判断此连接是否空闲 
	 *
	 * @since Oct 15, 2012
	 * @return <Description>空闲返回ture,否则false 
	 *
	 */
	public boolean isFree() {
		return status;
	}

	/**
	 * <Description> 当使用此连接的时候设置状态为false（忙碌）
	 *
	 * @since Oct 15, 2012 <Description>
	 *
	 */
	public void setBusy() {
		this.status = false;
	}

	/**
	 * <Description>当客户端关闭连接的时候状态设置为true(空闲）,放回连接池
	 *
	 * @since Oct 15, 2012 <Description>
	 *
	 */
	public void close() {
		logger.info("ConnectionAdapter Close : set   the   status   is   free");
		status = true;
	}
	
	/**
	 * <Description>销毁连接
	 * @throws IOException 
	 *
	 * @since Oct 15, 2012 <Description>
	 *
	 */
	public void destroy() throws IOException {
		//Close   socket   connection
		super.close();
		logger.info("ConnectionAdapter destroy!");
		// System.out.println( "Close   success   "   ); 
	}
}

 

 

连接池接口：

 

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * <p>
 * Title: 定义的抽象类，所有的子类必须单子模式去实现
 * </p>
 *    统一方法为public   ConnectionProvider   newInstance(); 
  *   连接提供器的抽象接口，每一个实现它的子类最好都是JAVABEAN， 
  *   这样它的方法就可以是被外界控制 
 * <p>
 * Description: 
 * </p>
 * 
 * <p>
 * Copyright: 融博技术有限公司 2012
 * </p>
 * 
 * @author 袁泉锋HO174959
 * @version 1.0
 * @date Oct 15, 2012
 *
 */
public interface SocketConnectionPoolInterface {
	public static final String SERVER_IP = "SERVER_IP_ADDRESS";
	public static final String SERVER_PORT = "SERVER_IP_PORT";
	public static final String MAX_SIZE = "MAX_SIZE";
	public static final String MIN_SIZE = "MIN_SIZE";
	/** 
	  *判断连接池内是否有连接 
	  *   @return   true   有连接返回true,否则返回false 
	  */
	public boolean isPooled();
	/** 
	  *   当此方法被调用的时候提供一个   socket 
	  *   @see   Socket 
	  *   @return   Socket   a   Connection   object. 
	  */
	public SocketConnection getConnection() throws java.net.SocketException;
	/** 
	  *   连接池初始化 
	  */
	public void init() throws UnknownHostException, IOException;
	/** 
	  *   连接池重新启动 
	  */
	public void restart() throws UnknownHostException, IOException;
	/** 
	  *   注销连接池 
	  */
	public void destroy();
}

 

连接池接口实现：

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Properties;

import org.apache.log4j.Logger;


/**
 * <p>
 * Title: 这是一个连接管理器的简单实现
 * </p>
 * 
 * <p>
 * Description: 
 * </p>
 * 
 * <p>
 * Copyright: 融博技术有限公司 2012
 * </p>
 * 
 * @author 袁泉锋HO174959
 * @version 1.0
 * @date Oct 15, 2012
 *
 */
public class SocketConnectionPool implements SocketConnectionPoolInterface {
	private static final Logger logger = Logger.getLogger("FrameLog");
	private Properties pro = null;
	private static SocketConnectionPoolInterface provider = null;
	private static Object object_lock = new Object();
	private String ip;
	private String port;
	/** 
	  *   默认的最大连接数 
	  */
	private int max_size = 20;
	/** 
	  *   默认的最小连接数 
	  */
	private int min_size = 10;
	/** 
	  *   Socket   connection池数组 
	  */
	private SocketConnection[] socketpool = null;
	/** 
	  *   构造对象的时候初始化连接池 
	  *   @throws   UnknownHostException   未知的主机异常 
	  *   @throws   IOException 
	  */
	private SocketConnectionPool(Properties pro) throws UnknownHostException,
			IOException {
		ip = pro.getProperty(SERVER_IP);
		port = pro.getProperty(SERVER_PORT);
		String max_size_s = pro.getProperty(MAX_SIZE);
		String min_size_s = pro.getProperty(MIN_SIZE);
		if (max_size_s != null) {
			max_size = Integer.parseInt(max_size_s);
		}
		if (min_size_s != null) {
			min_size = Integer.parseInt(min_size_s);
		}
		init(); //构造对象的时候初始化连接池 
	}

	/** 
	  *   判断是否已经池化 
	  *   @return   boolean   如果池化返回ture,反之返回false 
	  */
	public boolean isPooled() {
		if (socketpool != null) {
			return true;
		} else {
			return false;
		}
	}

	/** 
	  *返回一个连接 
	  *   @return   a   Connection   object. 
	  */
	public SocketConnection getConnection() {
		SocketConnection s = null;
		for (int i = 0; i < socketpool.length; i++) {
			if (socketpool[i] != null) {
				//如果有空闲的连接，返回一个空闲连接，如果没有，继续循环 
				if (socketpool[i].isFree()) {
					s = socketpool[i];
				} else {
					continue;
				}
			} else { //如果连接为空，证明小于最小连接数，重新生成连接 
				try {
					s = socketpool[i] = new SocketConnection(ip, Integer
							.parseInt(port));
				} catch (Exception e) {
					logger.error(e.getMessage());
					//never   throw 
				}
			}
		}
		/*//TODO 如果连接仍旧为空的话，则超过了最大连接数 
		if (s == null) {
			try { //生成普通连接，由客户端自行关闭，释放资源，不再由连接池管理 
				s = new Socket(ip, Integer.parseInt(port));
			} catch (Exception e) { //此异常永远不会抛出 
			}
		}*/
		//TODO 如果连接仍旧为空的话，等待一会继续获取
		while(s == null){
			try {
				Thread.sleep(1000);
				s = this.getConnection();
			} catch (InterruptedException e) {
				e.printStackTrace();
				logger.error(e.getMessage());
			}
		}
		s.setBusy();
		return s;
	}

	/** 
	  *   初始化连接池 
	  *   @throws   UnknownHostException   主机ip找不到 
	  *   @throws   IOException   此端口号上无server监听 
	  */
	public void init() throws UnknownHostException, IOException {
		socketpool = new SocketConnection[max_size];
		for (int i = 0; i < min_size; i++) {
			socketpool[i] = new SocketConnection(ip, Integer.parseInt(port));
			logger.info(" . ");
		}
		logger.info("socketPool   init   success!");
	}

	/** 
	  *   重新启动连接池 
	  *   @throws   UnknownHostException 
	  *   @throws   IOException 
	  */
	public void restart() throws UnknownHostException, IOException {
		destroy();
		init();
	}

	/** 
	  *   注销此连接池 
	  */
	public void destroy() {
		for (int i = 0; i < socketpool.length; i++) {
			if (socketpool[i] != null) {
				SocketConnection adapter = (SocketConnection) socketpool[i];
				try {
					adapter.destroy();
				} catch (IOException e) {
					logger.error(e.getMessage());
					e.printStackTrace();
				}
				logger.info(" . ");
				socketpool[i] = null;
			}
		}
		logger.info("SocketPool Destory   success!");
	}

	/** 
	  *   静态方法，生成此连接池实现的对象 
	  *   @param   pro   Properties   此连接池所需要的所有参数的封装 
	  *   @throws   UnknownHostException   主机无法找到 
	  *   @throws   IOException   与服务器无法建立连接 
	  *   @return   ConnectionProvider   返回父类ConnectionProvider 
	  */
	public static SocketConnectionPoolInterface newInstance(java.util.Properties pro)
			throws UnknownHostException, IOException {
		if (provider == null) {
			synchronized (object_lock) {
				if (provider == null) {
					provider = new SocketConnectionPool(pro);
				}
			}
		}
		return provider;
	}

	/** 
	  *设置系统属性   通过封装系统properties对象来封装所需要的不同值 
	  *   SERVER_IP，SERVER_PORT，MAX_SIZE,MIN_SIZE等父类定义的不同的参数 
	  *   @param   pro   Properties   传进来的系统属性 
	  */
	public void setProperties(Properties pro) {
		this.pro = pro;
	}
}

 

连接池管理器：

import java.lang.reflect.*;
import java.util.Properties;

import org.apache.log4j.Logger;

/**
 * <p>
 * Title: 连接管理器
 * </p>
 * 
 * <p>
 * Description: 
 * </p>
 * 
 * <p>
 * Copyright: 融博技术有限公司 2012
 * </p>
 * 
 * @author 袁泉锋HO174959
 * @version 1.0
 * @date Oct 15, 2012
 *
 */
public class SocketConnectionManager {
	private static final Logger logger = Logger.getLogger("FrameLog");
	//测试程序默认的连接池实现类 
	public static final String PROVIDER_CLASS = "com.rb.socketpool.MyConnectionProvider";
	//测试程序的默认ip 
	public static final String HOST = "127.0.0.1";
	//测试程序的默认端口号 
	public static final String PORT = "9880";
	/** 
	  *   注册钩子程序的静态匿名块,jvm退出的前一刻，调用ShutdownThread线程
	  */
	static {
		Runtime runtime = Runtime.getRuntime();
		Class c = runtime.getClass();
		try {
			Method m = c.getMethod("addShutdownHook",
					new Class[] { Thread.class });
			m.invoke(runtime, new Object[] { new ShutdownThread() });
		} catch (NoSuchMethodException e) {
			logger.error(e.getMessage());
			e.fillInStackTrace();
		} catch (Exception e) {
			logger.error(e.getMessage());
			e.printStackTrace();
		}
	}

	/** 
	  *   默认的构造函数 
	  */
	public SocketConnectionManager() {
	}

	/**
	 * <Description> 得到并初始化一个连接池 
	  *   连接池的实现类通过系统参数来传递进来，通过命令行-DConnectionProvider=YourImplClass 
	  *   如果没有指定的实现的话，则采用系统默认的实现类 
	  *   通过命令行传入的参数列表如下 
	  *   对方主机名-DHost=192.168.0.200 
	  *   对方端口号　-DPort=9880 
	  *   最小连接数     -DMax_size=10 
	  *   最大连结数　-DMin_size=20 
	  *   以上的值可以改变，但是参数不能改变， 
	  *   最大连结数和最小连接数可以省略，默认值分别为２０和１０ 
	 *
	 * @since Oct 15, 2012
	 * @return
	 * @throws Exception <Description>
	 *
	 */
	public static SocketConnectionPoolInterface getConnectionProvider() throws Exception {
		String provider_class = System.getProperty("ConnectionProvider");
		if (provider_class == null){
			provider_class = PROVIDER_CLASS;
		}
		String host = System.getProperty("Host");
		if (host == null){
			host = HOST;
		}
		String port = System.getProperty("port");
		if (port == null){
			port = PORT;
		}
		String max_size = System.getProperty("Max_size");
		String min_size = System.getProperty("Min_size");

		Properties pro = new Properties();
		pro.setProperty(SocketConnectionPoolInterface.SERVER_IP, host);
		pro.setProperty(SocketConnectionPoolInterface.SERVER_PORT, port);
		if (max_size != null) {
			pro.setProperty(SocketConnectionPoolInterface.MAX_SIZE, max_size);
		}
		if (min_size != null) {
			pro.setProperty(SocketConnectionPoolInterface.MIN_SIZE, min_size);
		}
		//通过反射得到实现类 
		logger.info("Provider_class:" + provider_class);
		Class provider_impl = Class.forName(provider_class);
		//由于是单子模式，采用静态方法回调 
		Method m = provider_impl.getMethod("newInstance",
				new Class[] { java.util.Properties.class });
		SocketConnectionPoolInterface provider = null;
		try {
			provider = (SocketConnectionPoolInterface) m.invoke(provider_impl,
					new Object[] { pro });
		} catch (Exception e) {
			logger.error(e.getMessage());
			e.printStackTrace();
		}
		return provider;
	}

	/** 
	  * 
	  *   <p> 一个钩子的线程:   在程序结束的时候调用注销连接池 </p> 
	  *   <p> Description:   </p> 
	  *   <p> Copyright:   Copyright   Tarena(c)   2005 </p> 
	  *   <p> Company:   Tarena </p> 
	  *   @author   chengxing 
	  *   @version   1.0 
	  */
	private static class ShutdownThread extends Thread {
		public void run() {
			try {
				SocketConnectionPoolInterface provider = SocketConnectionManager
						.getConnectionProvider();
				if (provider != null) {
					provider.destroy();
				}
			} catch (Exception e) {
				logger.error(e.getMessage());
				e.printStackTrace();
			}
		}
	}

}