首页 > 代码库 > java socket客户端连接池

java socket客户端连接池

最近因项目需要,需要使用socket长连接服务器,但是在网上查资料发现都是服务器的连接池,于是自己动手写了个客户端socket连接池,记之,仅供参考,里面的意义变量请自行替换,废话少说,上代码。


1.   socet信息类

    

package cn.richinfo.cloudp.dm.common.util;

import java.net.Socket;

/**
 * @Crop 深圳市xxx科技有限公司
 * @author liuxingmi 
 * @QQ 63972012
 * @DateTime 2014-8-25 下午3:21:19 
 * @Desc 名字服务器连接信息
 */
public class SocketInfo {

	/**
	 * socket
	 */
	private Socket socket;
	/**
	 * 是否空闲 (是:true  否:false)
	 */
	private boolean isFree;
	/**
	 * socket id
	 */
	private Integer socketId;
	
	/**
	 * 是否为可关闭链接 (是:true  否:false)
	 */
	private boolean isClosed;

	public Socket getSocket() {
		return socket;
	}

	public void setSocket(Socket socket) {
		this.socket = socket;
	}

	public boolean isFree() {
		return isFree;
	}

	public void setFree(boolean isFree) {
		this.isFree = isFree;
	}

	public Integer getSocketId() {
		return socketId;
	}

	public void setSocketId(Integer socketId) {
		this.socketId = socketId;
	}

	public boolean isClosed() {
		return isClosed;
	}

	public void setClosed(boolean isClosed) {
		this.isClosed = isClosed;
	}

}

2.  链接池工具

package cn.richinfo.cloudp.dm.common.util;

import java.io.IOException;
import java.net.Socket;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import cn.richinfo.cloudp.common.config.CloudpConfigUtil;
import cn.richinfo.cloudp.common.constant.ConfigConst;
import cn.richinfo.cloudp.common.log.DMLogger;

/**
 * @Crop 深圳市xxxx有限公司
 * @author liuxingmi
 * @QQ 63972012
 * @DateTime 2014-8-25 下午3:18:18 
 * @Desc 分布式名字服务器socket链接池
 */
public class SocketPool {
	
	private static DMLogger logger = DMLogger.getInstance();//日志类
	
	/**
	 * socketMap
	 */
	public static ConcurrentHashMap<Integer, SocketInfo> socketMap = new ConcurrentHashMap<Integer, SocketInfo>();
	
	private static SocketPool instance = new SocketPool();
	
	private SocketPool(){}
	
	public static SocketPool getInstance(){
		if(instance == null){
			synchronized (SocketPool.class) {
				if(instance == null){
					instance = new SocketPool();
				}
			}
		}
		return instance;
	}
	
	static {
		instance.initSocket(true);
	}
	
	/**
	 * @DateTime 2014-8-25 下午3:18:52
	 * @User liuxingmi  
	 * @Desc 初始化链接池
	 * @param isAllReInit  是否全部重新初始化
	 * @return void
	 */
	public  void initSocket(boolean isAllReInit){
		int defaultCount = Integer.parseInt(ConfigConst.SOCKET_DEFAULT_COUNT);
		logger.info("nameserver:initSocket", DMLogger.RESULT_OK, "开始初始化分布式名字服务器连接数:" + defaultCount);
		for (int i = 0; i < defaultCount; i++) {					
			
			if(isAllReInit){
				socketMap.put(i, setSocketInfo( i, true, false));
			} else {
				if(socketMap.get(i) == null || socketMap.get(i).isClosed()){
					socketMap.put(i, setSocketInfo( i, true, false));
				}
			}	
		}
		
		logger.info("nameserver:initSocket", DMLogger.RESULT_OK, "完成初始化分布式名字服务器连接数");
		new CheckSocketThread().start();
		
	}
	
	/**
	 * @DateTime 2014-8-26 上午10:06:13
	 * @User liuxingmi  
	 * @Desc 设置socketInfo值
	 * @param socket
	 * @param key
	 * @param isFree
	 * @param isClosed
	 * @return SocketInfo
	 */
	private static SocketInfo setSocketInfo(Integer key, boolean isFree, boolean isClosed){
		SocketInfo socketInfo = new SocketInfo();
		Socket socket = createSocket();
		socketInfo.setFree(isFree);
		socketInfo.setSocket(socket);
		socketInfo.setSocketId(key);
		socketInfo.setClosed(isClosed);		
		return socketInfo;
	}
	
	/**
	 * @DateTime 2014-8-25 下午3:19:06
	 * @User liuxingmi  
	 * @Desc 获取名字服务器链接
	 * @return
	 * SocketInfo
	 */
	public  SocketInfo getSocketInfo(){
		
		SocketInfo socketInfo = null;
		
		if(socketMap.size() < Integer.parseInt(ConfigConst.SOCKET_DEFAULT_COUNT)){
			initSocket(false);
		}		
	
		if(socketMap.size() > 0){
			for (Map.Entry<Integer, SocketInfo> entry : socketMap.entrySet()) {
				socketInfo = entry.getValue();
				if(socketInfo.isFree() && ! socketInfo.getSocket().isClosed()){
					socketInfo.setFree(false);
					return socketInfo;
				}
			}
		} else {
			logger.info("nameserver:socketInfo", DMLogger.RESULT_FAIL, "名字服务器socket连接池数量为零。");
			return null;
		} 
		
		logger.info("nameserver:socketInfo", DMLogger.RESULT_OK, "所有名字服务器socket链接都忙,创建临时链接。");
				
		socketInfo = setSocketInfo(-1, true, true);
		logger.info("nameserver:socketInfo", DMLogger.RESULT_OK, "成功创建服务器socket临时链接。");	
		return socketInfo;

	}
	
	/**
	 * 释放socket
	 * @param socketId
	 */
	public static void distorySocket(Integer socketId){
		
		logger.debug("nameserver:distorySocket", DMLogger.RESULT_OK, "释放名字服务器socket链接。");
		SocketInfo socketInfo = socketMap.get(socketId);
		socketInfo.setFree(true);
		
	}
	
	/**
	 * @DateTime 2014-8-25 下午3:19:42
	 * @User liuxingmi  
	 * @Desc 释放socket
	 * @param socketInfo
	 * void
	 */
	public static void distorySocket(SocketInfo socketInfo){
	   
		if(socketInfo == null) return;
		
		if( ! socketInfo.isClosed()){
			logger.debug("nameserver:distorySocket", DMLogger.RESULT_OK, "链接池socket,释放资源。");
			distorySocket(socketInfo.getSocketId());
			return;
		}
		
		logger.debug("nameserver:distorySocket", DMLogger.RESULT_OK, "可关闭临时链接,关闭socket");
		try {
			if(socketInfo.getSocket() != null){
				socketInfo.getSocket().close();
			}
		} catch (IOException e) {
			logger.error("nameserver:distorySocket", DMLogger.RESULT_FAIL, "关闭名字服务器socket链接失败", e);
		}
		socketInfo = null;
		
	}
	
	/**
	 * @DateTime 2014-8-25 下午3:19:51
	 * @User liuxingmi  
	 * @Desc 创建socket
	 * @return
	 * Socket
	 */
	public static Socket createSocket(){
		
		String nameServerip1 = CloudpConfigUtil.DM_CONFIG.getNameSerIP1();
		int namServerport1 = CloudpConfigUtil.DM_CONFIG.getNameSerPort1();
		String nameServerip2 =  CloudpConfigUtil.DM_CONFIG.getNameSerIP2();
		int namServerport2 = CloudpConfigUtil.DM_CONFIG.getNameSerPort2();
		Socket socket = null;
		
		
		try {// 尝试通过ip1第一次建立连接
			socket = new Socket(nameServerip1, namServerport1);
			logger.info("nameserver:login", DMLogger.RESULT_OK, "nameServerip1:" + nameServerip1 + ", namServerport1:" + namServerport1);
		} catch (IOException e) {			
			logger.error("nameserver:login", DMLogger.RESULT_FAIL, "first link fail nameServerip1:" + nameServerip1 + ", namServerport1:" + namServerport1, e);
		  try {
			  // 如果第一次通过ip1建立连接失败,则进行第二次连接
			  socket = new Socket(nameServerip2, namServerport2);
			  logger.info("nameserver:login", DMLogger.RESULT_OK, "nameServerip2:" + nameServerip2 + ", namServerport2:" + namServerport2);
		     } catch (IOException e1) {
		    	logger.error("nameserver:login", DMLogger.RESULT_FAIL, "second link fail nameServerip2:" + nameServerip2 + ", namServerport2:" + namServerport2, e);
		    	return null;
		     }
		}
		return socket;
	}
	
	class CheckSocketThread extends Thread{
		@Override
		public void run() {
			while (true) {
				logger.debug("nameserver:checkSocket", DMLogger.RESULT_OK, "开始检测分布式链接状态。");
				if(socketMap.size() < Integer.parseInt(ConfigConst.SOCKET_DEFAULT_COUNT)){
				    logger.info("nameserver:checkSocket", DMLogger.RESULT_OK, "分布式名字服务器socket链接小于默认链接数,增加socket链接。");
					initSocket(false);
				}
				
				for (Map.Entry<Integer, SocketInfo> entry : socketMap.entrySet() ) {
					SocketInfo socketInfo = entry.getValue();
					if(socketInfo.getSocket() == null || socketInfo.isClosed()){
						logger.error("nameserver:checkSocket", DMLogger.RESULT_FAIL, "第"+ entry.getKey()+"个socket链接已关闭,重新连接分布式。",null);
						socketInfo.setSocket(createSocket());
					} else {
						if(socketInfo.isFree()){
							boolean flag = NameServerUtils.getInstance().checkHeartbeat(socketInfo);
							if( ! flag ){
								logger.error("nameserver:checkSocket", DMLogger.RESULT_FAIL, "第"+ entry.getKey()+"个socket链接失败,重新连接分布式。",null);
								socketInfo.setSocket(createSocket());
								continue;
							}
						}
						logger.debug("nameserver:checkSocket", DMLogger.RESULT_OK, "第"+ entry.getKey()+"个socket链接正常。");
					}
				}
				
				try {
					sleep(Long.valueOf(ConfigConst.SOCKET_CHECK_TIME));
				} catch (Exception e) {
				} 
			}
		}
	}
	
}


java socket客户端连接池