基于Mina实现的一个简单数据采集中间件

一、前言
该数据据采集中间件需要实现与多个终端的长连接，并定时给所有终端发送指令，终端在接收到相关指令后，返回相关信息给中间件。中间件需要一直监测所有终端的在线状态，并一直监听、接收所有终端的消息，并启动多个定时任务给在线终端发送相关指令。

二、网络通信的相关概念和基础知识
长连接的基本概念：
* 与Http短连接相反，通过某种方式与服务器一直保持连接就叫长连接

长连接的基本原理
* 底层都是基于TCP/IP协议
* 通过Socket、ServerSocket与服务器保持连接
* 服务端一般使用ServerSocket建立监听，监听客户端与之连接
* 客户端使用Socket，指定端口和IP地址，与服务端进行连接

长连接的意义：
* 通过长连接，可以实现服务器主动向客户端推送消息
* 通过长连接，可以减少客户端对服务器的轮询，减小服务器压力
* 通信效率要远高于http

心跳：在TCP网络通信中，经常会出现客户端和服务器之间的非正常断开，需要实时检测查询链接状态。常用的解决方法就是在程序中加入心跳机制。

三、代码实现

SessionBean.java

/**
 * IoSession连接信息
 */
public class SessionBean {
   

    /** IoSession 对象 */
    private IoSession session;

    /** 最后一次请求时间 */
    private Long lastTime;

    /** ip地址 */
    private String ip;

    /** 端口号 */
    private Integer port;


}

ClientSessionUtil.java

package com.che.utils;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.mina.core.session.IoSession;

import com.ym.bean.SessionBean;

/**
 * 客户端IoSession管理类
 */
public class ClientSessionUtil {
   

    /** 用于保存所有客户端的连接状态 */
    private static Map<Long, SessionBean> clientMap = null;

    private ClientSessionUtil(){

    }

    private static synchronized Map<Long, SessionBean> getClientMap(){
        if(clientMap == null){
            clientMap = new HashMap<Long, SessionBean>();
        }
        return clientMap;
    }

    /**
     * 获取某个客户端连接的最后一次请求时间
     * @param sessionId
     * @return
     */
    public static Long getLastTime(Long sessionId){
        SessionBean sessionBean = getClientMap().get(sessionId);
        if(sessionBean != null){
            return sessionBean.getLastTime();
        }
        return null;
    }

    /**
     * 根据sessionId获取客户端的IoSession对象
     * @param sessionId
     * @return
     */
    public static IoSession getIoSession(Long sessionId){
        SessionBean sessionBean = getClientMap().get(sessionId);
        if(sessionBean != null){
            return sessionBean.getSession();
        }
        return null;
    }

    /**
     * 新增一个客户端IoSession
     * @param session
     */
    public static void addSesssion(IoSession session){
        SessionBean sessionBean = new SessionBean();
        sessionBean.setSession(session);
        //设置当前的请求时间
        sessionBean.setLastTime(System.currentTimeMillis());
        //获取客户端的ip及端口
        String address = session.getRemoteAddress().toString();
        if(address != null && !address.equals("")){
            String[] addArr = address.split(":");
            if(addArr != null && addArr.length == 2){
                sessionBean.setIp(addArr[0]);
                sessionBean.setPort(Integer.parseInt(addArr[1]));
            }
        }
        getClientMap().put(session.getId(), sessionBean);
    }

    /**
     * 获取当前客户端连接数量
     * @return
     */
    public static int getSessionCount(){
        return getClientMap().size();
    }

    /**
     * 断开某个客户端连接
     * @param session
     */
    public static void removeSession(IoSession session){
        getClientMap().remove(session.getId());
    }

    /**
     * 获取当前所有在线的客户端连接IoSession集合
     * @return
     */
    public static Set<IoSession> getAllSession(){
        Set<IoSession> sessions = new HashSet<IoSession>();
        Set<Long> idSet = ClientSessionUtil.getClientMap().keySet();
        for (Long id : idSet) {
            System.out.println("---000--" + id);
            IoSession session = ClientSessionUtil.getIoSession(id);
            sessions.add(session);
        }
        return sessions;
    }

    public static SessionBean getSessionBeanBySessionId(Long sessionId){
        if(getClientMap().values() != null && getClientMap().values().size() > 0){
            for(SessionBean sessionBean : getClientMap().values()){
                if(sessionBean.getSessionId() == sessionId){
                    return sessionBean;
                }
            }
        }

        return null;
    }

    public static String getMId(Long sessionId){
        SessionBean sessionBean = getSessionBeanBySessionId(sessionId);
        if(sessionBean != null){
            return sessionBean.getMId();
        }
        return null;
    }

}

PropertiesUtil.java

package com.che.utils;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * 配制参数读取工具类
 */
public class PropertiesUtil {
   

    /** 服务器端口 */
    public static final String PORT = "port";

    /** 缓冲区大小 */
    public static final String READ_BUFFER_SIZE = "readBufferSize";

    /** 心跳时间 */
    public static final String HEARTBEAT_OUT_TIME = "heartbeatOutTime";

    private static PropertiesUtil propertiesUtil = null;

    private  static Properties prop;

    private PropertiesUtil(){

    }

    public static PropertiesUtil getInstance(){
        if(propertiesUtil == null){
            propertiesUtil = new PropertiesUtil();
            prop = new Properties();
            try {
                prop.load(new FileInputStream("config.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return propertiesUtil;
    }

    /**
     * 获取某项配置参数
     * @param key
     * @return
     */
    public static int getProperty(String key){
        Object obj = prop.get(key);
        return Integer.parseInt(obj + "");
    }

}

配制参数文件：config.properties

#服务器端口
port=8002
#缓冲区大小
readBufferSize=102048
#心跳时间
heartbeatOutTime=30000

定时任务管理类：TaskUtils.java

package com.che.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;

/**
 * 定时任务管理类
 * 
 */
public class TaskUtils {
   

    @SuppressWarnings