kj_ythglpt_tcp连接编程（strust2+hibernate+spring）

序言

通过TCP建立可靠通讯信道

为了对应TCP协议里的客户端和服务器端，Socket包提供了Socket类和ServerSocket类。

一、tcp客户端类的创建

表格：

1	项目	科江、一体化
2	开发环境（表格）-包括版本
3	开发技术（表格）-包括版本	jdk 1.8
4	服务器
5	数据库
6	名词解释
7	系统业务流程（应用场景）
8	具体功能点1，及操作流程

 

二、tcp客户端类的应用场景、实例化方式、使用方法

1、案例1：下发协议指令（向服务器发送请求，服务器IP地址和服务器的端口号）

/**
*
* @Title: doExecute
* @Description: 下发协议指令
* @param @param
* xml 指令协议
* @param @param
* ip 通信IP地址
* @param @param
* port 通信端口
* @param @return
* 参数
* @return String 返回类型
* @date 2017年5月26日 上午9:54:09
*/

public String doExecute(String xml, String ip, Integer port) {
    Socket socket = null;
    BufferedWriter out = null;
    PrintWriter pw = null;
    try {
            //第一步：创建Socket对象
            socket = new Socket();

            //第二步：设置服务器的ip和端口
            SocketAddress socketAddress = new InetSocketAddress(ip, port);

            // 第三步：根据服务器的ip端口，建立连接。如果连不上的5秒后断掉连接。
            socket.connect(socketAddress, 5000);

            // 第四步：设置响应阻塞超时
            socket.setSoTimeout(5000);

            //第五步：返回此套接字（Socket）的输出流
            out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "GB2312"));

            //第六步： 转换为打印流，刷新缓存，向服务器端输出信息
            pw = new PrintWriter(out);
            pw.write(xml);
            pw.flush();

            //第七步：关闭输出流
            socket.shutdownOutput();

            //第八步：关闭其它资源
            pw.close();
            out.close();
            socket.close();
            return "";

            //第九步：异常处理
    } catch (ConnectException e) {
            log.error("服务端连接拒绝！" + "IP：" + ip + "端口：" + port);
            return "服务端连接拒绝！";
    } catch (SocketTimeoutException e) {
            log.error("连接超时！" + "IP：" + ip + "端口：" + port);
            return "连接超时！";
    } catch (UnknownHostException e) {// 客户端不能建立网络连接
            log.error("客户端和服务端不能建立网络连接！" + "IP：" + ip + "端口：" + port);
            return "客户端和服务端不能建立网络连接！";
    } catch (IOException e) {
            log.error("IO流异常！" + "IP：" + ip + "端口：" + port, e);
            return "异常";
    } catch (Exception e) {
            log.error("Socket客户端异常！" + "IP：" + ip + "端口：" + port, e);
            return "Socket客户端异常！";
    } finally {//第十步：关闭资源
            try {
                    if (socket != null) {
                        socket.close();
                    }
                    if (pw != null) {
                        pw.close();
                    }
                    if (out != null) {
                        out.close();
                    }
            } catch (IOException e) {
                    log.error("socket关闭异常！" + "IP：" + ip + "端口：" + port, e);

            }  
    }
}

2、案例2：下发协议指令,跟板卡进行socke通讯（向服务器发送请求，服务器IP地址和服务器的端口号）

/**
* @Title: doSenAndReceive
* @Description: 下发协议指令,跟板卡进行socke通讯
* @param xml 指令协议
* @param ip 通信IP地址
* @param port 通信端口
* @param type 类型
* @return String 前端板卡返回数据
* @date 2017年10月27日 下午1:17:49
*/

public String doSenAndReceive(String xml, String ip, Integer port,int type) {

        Socket socket = null;
        OutputStream out = null;
        PrintWriter pw = null;
        InputStream in = null;
        // 返回值
        try {

                //1、第一步：根据ip和端口建立socket链接
                socket = new Socket(ip, port);

                // 2、第二步：设置等待超时为5秒
                socket.setSoTimeout(5*1000);

                //3、第三步：获取套接字（Socket）的输出流
                out = socket.getOutputStream();
                pw = new PrintWriter(out);

                //4、第四步：向服务器端写入请求数据
                pw.write(xml);
                pw.flush();

                //5、第五步： 关闭资源
                pw.close();
                out.close();

                //6、第六步：套接字（Socket)中获取输入流，接收服务端信息，处理服务器返回的数据
                InputStream in = socket.getInputStream();
                byte[] bt = new byte[28];
                List<Map<String, String>> spectrumList = new ArrayList<>();
                while(in.read(bt) > 0){
                    String flag = ByteUtils.subBytesToString(bt, 6, 10, "gb2312");
                    if(flag.equals("RRSU")){
                        。。。。。。。
                    }
                }
                return "";
                //7、第七步：异常处理
        } catch (UnknownHostException e) {
                log.error("socket的连接异常："+e.getMessage());
                return e.getMessage();
        }catch(SocketTimeoutException e){
                log.error("等待接收数据超时，断开socket连接！");
                return e.getMessage();
        } catch (IOException e) {
                log.error("socket的TCP异常："+e.getMessage());
                return e.getMessage();
        } finally {//中关闭资源
                try {
                        if (socket != null) {
                            socket.close();
                        }
                        if(in != null){
                            in.close();
                        }
                        if (pw != null) {
                            pw.close();
                        }
                        if (out != null) {
                            out.close();
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
}

 

3、案例3：短信模块接口

/**

* 描述: 发送并且获取返回的数据

*

* @Param: [ip, port, code 发送的协议, endCode 返回的数据是否携带结束符 如果数据量大则需要]

* @return: java.lang.String

* Created By Wy on 2020/2/10

*/

public static String sendAndGetData(String ip, int port, String code, String endCode) throws MyException {
    Socket socket = null;
    InputStream inputStream = null;
    OutputStream outputStream = null;
    StringBuilder res = new StringBuilder();
    try {

            // 1、第一步：根据ip地址和端口，创建Socket实例
            socket = new Socket();
            SocketAddress socketAddress = new InetSocketAddress(ip, port);
            socket.connect(socketAddress, 2000);// 连不上的2秒后断掉连接

            //2、第二步：设置响应阻塞超时的时间
            socket.setSoTimeout(SO_TIMEOUT);// 响应阻塞超时

            // 3、第三步：获取输出流,向服务器发送数据
            outputStream = socket.getOutputStream(); // 向服务端写入数据
            outputStream.write(code.getBytes(DEF_CHARSET)); // 获取输入流,获取服务器的响应
            outputStream.flush();// 刷新缓存，向服务器端输出信息

            //4、第四步：获取输入流，从服务器获取响应
            inputStream = socket.getInputStream();
            byte[] buff = new byte[1024];
            // 循环接收服务端返回数据
            while (inputStream.read(buff) > 0) {
                String temp_str = new String(buff, Charset.forName(DEF_CHARSET)).trim();
                // 短数据，不需要结束符
                if (endCode == null) {
                    res.append(temp_str);
                    break;
                } else {
                //长数据,如果包含结束符，则停止接收
                    if (temp_str.contains(endCode)) {
                        temp_str = temp_str.replace(endCode, "");
                        res.append(temp_str);
                        break;
                    }
                    res.append(temp_str);
                }
            }
    //5、第五步：异常处理
    } catch (ConnectException e) {
        log.error("短信设置-连接异常！" + "IP：" + ip + "端口：" + port, e);
        throw new MyException(ApiResultCode.CARD_CONN_ERROR);
    } catch (SocketTimeoutException e) {
        log.error("短信设置-接收服务端数据超时！" + "IP：" + ip + "端口：" + port, e);
        throw new MyException(ApiResultCode.CARD_TIMEOUT_ERROR);
    } catch (Exception e) {
        log.error("短信设置-异常！" + "IP：" + ip + "端口：" + port, e);
        throw new MyException(ApiResultCode.UNKNOW_ERROR);
    } finally {
            //6、第六步：释放资源
            try {
                    if (!StringUtil.isEmpty(inputStream)) {
                        inputStream.close();
                    }
                    if (!StringUtil.isEmpty(outputStream)) {
                        outputStream.close();
                    }
                    if (!StringUtil.isEmpty(socket)) {
                        socket.close();
                    }
            } catch (IOException e) {
                    e.printStackTrace();
            }
    }
    String str = res.toString();
    log.info("收到[" + ip + ":" + port + "]返回的数据：" + str);
    str = str.replaceAll("isNull", "");
    return str;
}

 

三、tcp服务端类的创建

表格：

1	项目	科江、一体化
2	开发环境（表格）-包括版本
3	开发技术（表格）-包括版本	jdk 1.8
4	服务器
5	数据库
6	名词解释
7	系统业务流程（应用场景）
8	具体功能点1，及操作流程

四、tcp服务端类的应用场景、实例化方式、使用方法

1、第一步：创建ServerSocket对象，设置监听端口

/*
*ServerSocket.java
*此类实现服务器套接字。
*服务器套接字等待请求通过网络传入。
*它基于该请求执行某些操作，然后可能向请求者返回结果。
*服务器套接字的实际工作由 SocketImpl 类的实例执行。
*应用程序可以更改创建套接字实现的套接字工厂来配置它自身，
*从而创建适合本地防火墙的套接字。
*/
//实例化ServerSocket对象，设置监听的端口，让服务器端程序开始监听来自端口的客户端请求
//这里的端口是自己本机的端口（如果使用本机做为服务器接收请求的话），如8080端口等。
//服务器套接字已经创建成功，开启服务端。
ServerSocket socket = new ServerSocket(port);

2、第二步：服务器无穷的循环等待客户端的请求，并设置超时时间

/*
*Socket.java
*此类实现客户端套接字（也可以就叫“套接字”）。
*套接字是两台机器间通信的端点。
*套接字的实际工作由 SocketImpl 类的实例执行。
*应用程序通过更改创建套接字实现的套接字工厂可以配置它自身，
*以创建适合本地防火墙的套接字。
*/
// 让服务器无穷的循环等待客户端的请求
Socket socket = null;
try {
    //侦听并接受到此套接字的连接。
    //此方法在连接传入之前一直阻塞。
    //SocketTimeoutException - 如果以前使用 setSoTimeout 设置了超时并且已到达超时值
    /*
    * accept()方法会在等待用户的socket连接时闲置着，当用户链接上来时，
    * 此方法会返回一个socket(在不同的端口上)以便与客户端通信。
    * Socket与ServerSocket的端口不同，因此ServerSocket可以空闲出来等待其他客户端的请求
    */
    // 这个方法会停下来等待，当请求到达之后再继续
    socket = serverSocket.accept();
    socket.setSoTimeout(5000);

 

3、第三步：接收实时监测端口接收到的数据

/**
* 实时监测
* 接收实时监测端口数据
* @param socket 参数
* @return void 返回类型
* new RealtimeSocket().doExecute(socket);
* @date 2017年4月27日 上午9:48:20
*/

//数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。
//应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
//DataInputStream 对于多线程访问不一定是安全的。
//线程安全是可选的，它由此类方法的使用者负责。
DataInputStream dis = null;

//socket.getInputStream()返回此套接字的输入流。
dis = new DataInputStream(socket.getInputStream());

//从输入流中读取数据，进行处理
String content;
String line = null;//接受到的数据
while ((line = dis.readLine()) != null && !"".equals(line)) {
    byte[] buf = new byte[2048];
    int c = dis.read();
    buf[size++] = (byte) c;
    content = new String(buf, "GB2312").trim();
    Document documentIn;
    try {
        HttpClientUtil.httpOkResponse(socket.getOutputStream());
        documentIn = DocumentHelper.parseText(content);
        //System.out.println("========" + DateFormatUtil.getStringDate(new Date())+         "========接受到的测试xml内容:" + content);
        String ip = socket.getInetAddress().getHostAddress();
        readXML(documentIn,ip);
    } catch (DocumentException e) {
        log.error("XML格式异常！", e);
        e.printStackTrace();
    }

    /**
      * 解决该Software caused connection abort: recv failed异常
      * 如果available()的返回值为0,说明没有响应数据,可能是对方已经断开连接,
      * 如果available()的返回值大于0,说明有响应数据. 每次读完判断TCP/IP是否连接正常，如果对方断开就跳出循环
      * 不在读取数据 以免报recv failed异常
      */
    if (dis.available() == 0) {
       break;
    }
 }

 //关闭流
 if (dis != null){
   dis.close();
 }

 

4、第四步：服务器向客户端回数据，字节输出流，通过客户端套接字对象获取字节输出流

/**注：代码来源于网上
*OutputStream out=socket.getOutputStream();
*out.write("收到，谢谢".getBytes());
*out.close();
*/
} catch (IOException e) {
    log.error("选择监测数据解析连接超时", e);
}catch (Exception e) {
    e.printStackTrace();
} finally {
    if (socket != null) {
        try {
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

完整代码：

package cn.com.jc.socket.tcp;

import java.io.Serializable;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import cn.com.jc.bean.WisdomAlarmDataBean;
import cn.com.jc.common.spring.ApplicationContext;
import cn.com.jc.common.spring.SpringInstance;
import cn.com.jc.quartz.HdtvScannScheduler;
import cn.com.jc.service.dataManager.IAttendantWorkingTimeService;
import cn.com.jc.service.wisdom.IWisdomHandle;
import cn.com.jc.socket.tcp.privateport.AnalysisCardHeartbeat;
import cn.com.jc.socket.tcp.privateport.OneKeyConfigAnalysis;
import cn.com.jc.socket.tcp.servicemonitoring.AlarmInformationSocket;
import cn.com.jc.socket.tcp.servicemonitoring.DataManageSocket;
import cn.com.jc.socket.tcp.servicemonitoring.EquipmentMonitorSocket;
import cn.com.jc.socket.tcp.servicemonitoring.HistoryPlaySocket;
import cn.com.jc.socket.tcp.servicemonitoring.OtherMonitorlSocket;
import cn.com.jc.socket.tcp.servicemonitoring.ParamconfigSocket;
import cn.com.jc.socket.tcp.servicemonitoring.RealtimeSocket;
import cn.com.jc.socket.tcp.servicemonitoring.SecurityDetectionSocket;
import cn.com.jc.socket.tcp.servicemonitoring.SecurityDetectionSocketAHXD;
import cn.com.jc.socket.tcp.servicemonitoring.SelectMonitoringDataAnalysis;
import cn.com.jc.socket.tcp.servicemonitoring.SocketDataAnalysis;
import cn.com.jc.socket.tcp.servicemonitoring.SpecialWarmHandle;
import cn.com.jc.socket.tcp.servicemonitoring.alram.SpecialAlarmWarmHandle;
import cn.com.jc.socket.udp.UdpServerSocket;
import cn.com.jc.socket.udp.sms.SmsUdpService;
import cn.com.jc.util.properties.PropertiesUtil;
import cn.com.jc.util.string.StringUtil;
import cn.com.jc.util.xmlCon.respond.realtimeMonitor.UDPEquipmentMonitorParse;
import cn.com.jc.util.xmlCon.respond.realtimeMonitor.UDPQualityRealtimeParse;
import cn.com.jc.util.xmlCon.respond.safetyMonitor.EquipmentAddressMonitor;

/**
 * 
 * @Package cn.com.jc.socket.tcp
 * @ClassName: StartTcpServerThread
 * @Description: Socket服务端口监听处理
 * @author 作者: l_navy24_7
 * @date 创建时间: 2017年4月18日 上午10:51:06
 * @version V1.0
 * @since JDK 1.7
 *
 */
public class StartTcpServerThread implements ServletContextListener, Serializable {

	private static final long serialVersionUID = -7539544590697815412L;

	protected static final Log log = LogFactory.getLog(Object.class);

	private static ThreadPoolTaskExecutor taskExecutor;

	static {
		taskExecutor = (ThreadPoolTaskExecutor) SpringInstance.getInstance().getBean("taskExecutor");
	}

	@Override
	public void contextDestroyed(ServletContextEvent arg0) {
		// if (serverSocket != null)
		// try {
		// serverSocket.close();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }
	}

	@Override
	public void contextInitialized(ServletContextEvent arg0) {
		String port = "";
		String errorFlag = PropertiesUtil.getInstance().getProperties("tcporudp.error.flag");
		// TCP实时报警监测
		if (errorFlag.equals("1") || errorFlag.equals("3")) {
			String errorort = PropertiesUtil.getInstance().getProperties("tcpserver.error.port");
			System.out.println("创建报警信息上报端口:" + errorort);
			taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(errorort), 1));
		}
		// 实时监测(自动录像设置、指标参数、实时视频URL等)
		port = PropertiesUtil.getInstance().getProperties("ssjc.port");
		System.out.println("创建实时监测端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 2));
		// 数据处理
		port = PropertiesUtil.getInstance().getProperties("data.processing.port");
		System.out.println("创建数据处理端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 3));
		// 安全监测
		port = PropertiesUtil.getInstance().getProperties("safety.monitoring.port");
		System.out.println("创建安全监测端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 4));
		// 安全监测(安徽现代)
		port = PropertiesUtil.getInstance().getProperties("safety.monitoring.port.ahxd");
		System.out.println("创建安全监测-安徽现代端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 44));
		// 内容监测
		port = PropertiesUtil.getInstance().getProperties("content.monitoring.port");
		System.out.println("创建内容监测端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 5));
		// 其它监测
		port = PropertiesUtil.getInstance().getProperties("other.monitoring.port");
		System.out.println("创建其它监测端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 6));
		// 选择监测
		port = PropertiesUtil.getInstance().getProperties("selective.monitoring.port");
		System.out.println("创建选择监测端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 7));
		// 参数配置
		port = PropertiesUtil.getInstance().getProperties("Parameter.config.port");
		System.out.println("创建参数配置端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 8));
		// 数据分析
		port = PropertiesUtil.getInstance().getProperties("data.analysis.port");
		System.out.println("创建数据分析端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 9));
		// 视频回看
		port = PropertiesUtil.getInstance().getProperties("history.play.port");
		System.out.println("创建视频回看端口:" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 10));

		// UDP实时报警监测
		String udpHost = PropertiesUtil.getInstance().getProperties("tcpserver.host");
		if (errorFlag.equals("2") || errorFlag.equals("3")) {
			port = PropertiesUtil.getInstance().getProperties("udpserver.error.port");
			System.out.println("UDP实时报警监测端口:" + port);
			taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), udpHost, 1));
		}
		/***************************** 设备监控Start ******************************/
		port = PropertiesUtil.getInstance().getProperties("equipment.monitor.port");
		System.out.println("创建设备监控端口(总局):" + port);
		taskExecutor.execute(new TcpThreadCreat(Integer.parseInt(port), 11));

//		port = PropertiesUtil.getInstance().getProperties("equipment.monitor.callsc.port");
//		System.out.println("UDP设备监测端口(主查询):" + port);
//		taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), udpHost,2));

		port = PropertiesUtil.getInstance().getProperties("equipment.card.first.port");
		System.out.println("UDP设备监测端口(第一查询端):" + port);
		taskExecutor.execute(new UdpEquipmentThreadCreat(Integer.parseInt(port), udpHost, 2));

		port = PropertiesUtil.getInstance().getProperties("equipment.card.two.port");
		System.out.println("UDP设备监测端口(第二查询端):" + port);
		taskExecutor.execute(new UdpEquipmentThreadCreat(Integer.parseInt(port), udpHost, 2));

		port = PropertiesUtil.getInstance().getProperties("equipment.card.fm.port");
		System.out.println("UDP设备监测端口(广播):" + port);
		taskExecutor.execute(new UdpEquipmentThreadCreat(Integer.parseInt(port), udpHost, 2));

		/***************************** 设备监控End ******************************/

		/***************************** sms udp心跳监控start ******************************/
		String heartBeatServerOnOrOff = PropertiesUtil.getInstance().getProperties("sms.heartBeat.server.onOrOff");
		if (!StringUtil.isEmpty(heartBeatServerOnOrOff) && "true".equals(heartBeatServerOnOrOff)) {
			udpHost = PropertiesUtil.getInstance().getProperties("sms.heartBeat.server.host");
			port = PropertiesUtil.getInstance().getProperties("sms.heartBeat.server.port");
			System.out.println("短信平台监测端口:" + port);
			taskExecutor.execute(new UdpSmsThreadCreat(Integer.parseInt(port), udpHost, 3));
		}
		/***************************** sms udp心跳监控end ******************************/

		// UDP高清频道扫描监听端口
		port = PropertiesUtil.getInstance().getProperties("hdtv.scann.port");
		System.out.println("UDP高清频道扫描监听端口:" + port);
		taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), udpHost, 3));

		port = PropertiesUtil.getInstance().getProperties("timing.listen.port");
		System.out.println("电视心跳包监听端口:" + port);
		taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), udpHost, 4));
		port = PropertiesUtil.getInstance().getProperties("gb.timing.listen.port");
		System.out.println("广播心跳包监听端口:" + port);
		taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), udpHost, 5));

		// 一键配置模块开关
		String oneKeyOnOff = PropertiesUtil.getInstance().getProperties("oneKey.onoff");
		if ("1".equals(oneKeyOnOff)) {
			port = PropertiesUtil.getInstance().getProperties("oneKey.config.system.post");
			System.out.println("板卡一键配置监听端口:" + port);
			taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), udpHost, 6));
		}

		// UPD监控乡镇采集点IP（4G信号） 无需开启IP监听
		port = PropertiesUtil.getInstance().getProperties("udp.equipment.ip.monitor.port");
		System.out.println("创建UPD监控乡镇采集点IP（4G信号）:" + port);
		taskExecutor.execute(new UdpThreadCreat(Integer.parseInt(port), "", 12));

		// 处理特殊的异常报警信息
		//taskExecutor.execute(new SpecialWarmThreadCreat());
		// 心跳包处理
		taskExecutor.execute(new SpecialHandleThread());

		// 智慧模块开关
		String wisdomOnOff = PropertiesUtil.getInstance().getProperties("wisdom.onoff");
		if ("1".equals(wisdomOnOff)) {
			// 智慧处理模块每秒取一下队列数据
			taskExecutor.execute(new WisdomHandleThread());
			// 智慧处理模块每秒对保存的报警数据进行判断，便于及时结束报警处理
			taskExecutor.execute(new WisdomDbHandleThread());
		}

		// 值班员自动同步开关
//		String attendantWorkingTimeOnOff = PropertiesUtil.getInstance().getProperties("attendantWorkingTime.onoff");
//		if("1".equals(attendantWorkingTimeOnOff)){
//			
//			taskExecutor.execute(new AttendantSchedualThreadSZDS());
//			taskExecutor.execute(new AttendantSchedualThreadOthers());
//		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: SpecialWarmThreadCreat
	 * @Description: 处理报警信息
	 * @author 作者: huliu
	 * @date 创建时间: 2019年9月23日 下午8:43:44
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
//	class SpecialWarmThreadCreat implements Runnable {
//
//		@Override
//		public void run() {
//			while (true) {
//				try {
//					// 休眠一秒
//					Thread.sleep(1000);
//					// 处理数据
//					new SpecialWarmHandle().warmDataHandle();
//
//					// 新逻辑报警测试
//					// new SpecialAlarmWarmHandle().warmDataHandle();
//				} catch (InterruptedException e) {
//					log.error(e.getMessage(), e);
//				}
//			}
//		}
//	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: SpecialHandleThread
	 * @Description: 心跳包处理
	 * @author 作者: huliu
	 * @date 创建时间: 2019年10月4日 上午9:11:27
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class SpecialHandleThread implements Runnable {
		@Override
		public void run() {
			while (true) {
				// 休眠一秒
				try {
					Thread.sleep(1000);
					// 网络判断
					AnalysisCardHeartbeat.analysisNetwrok();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: Thread1
	 * @Description: TCP监听线程创建
	 * @author 作者: l_navy24_7
	 * @date 创建时间: 2017年4月18日 上午10:51:17
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class TcpThreadCreat implements Runnable {
		private int port; // 端口
		private int type; // 类型

		public TcpThreadCreat(int port, int type) {
			this.port = port;
			this.type = type;
		}

		@Override
		public void run() {
			try {
				// 让服务器端程序开始监听来自端口的客户端请求
				ServerSocket socket = new ServerSocket(port);
				while (true) {
					readTcpClientData(socket, type);
				}
			} catch (Exception e) {
				log.error("创建端口(" + this.port + ")失败！", e);
			}
		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: UdpThreadCreat
	 * @Description: UDP监测线程创建
	 * @author 作者: l_navy24_7
	 * @date 创建时间: 2017年12月13日 下午2:43:10
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class UdpThreadCreat implements Runnable {
		private int port; // 端口
		private String host; // 主机ip
		private int type;// 类型

		public UdpThreadCreat(int port, String host, int type) {
			this.port = port;
			this.host = host;
			this.type = type;
		}

		@Override
		public void run() {
			UdpServerSocket udpServerSocket = null;
			try {
				udpServerSocket = new UdpServerSocket(host, port);
			} catch (Exception e) {
				log.error("UDP端口(" + this.port + ")监听失败！", e);
			}
			while (true) {
				try {
					String updclientdata = udpServerSocket.receive();
					if (!StringUtil.isEmpty(updclientdata)) {
						// 客户端IP
						String ip = udpServerSocket.getResponseAddress().getHostAddress();
						taskExecutor.execute(new udpAnalysisWarnDataThread(updclientdata, ip, type));
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: UdpThreadCreat
	 * @Description: UDP监测设备状态心跳数据
	 * @author 作者: l_navy24_7
	 * @date 创建时间: 2017年12月13日 下午2:43:10
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class UdpEquipmentThreadCreat implements Runnable {
		private int port; // 端口
		private String host; // 主机ip
		private int type;// 类型

		public UdpEquipmentThreadCreat(int port, String host, int type) {
			this.port = port;
			this.host = host;
			this.type = type;
		}

		@Override
		public void run() {
			UdpServerSocket udpServerSocket = null;
			try {
				udpServerSocket = new UdpServerSocket(host, port);
			} catch (Exception e) {
				log.error("UDP端口(" + this.port + ")监听失败！", e);
			}
			while (true) {
				try {
					String updclientdata = udpServerSocket.receive();
					if (!StringUtil.isEmpty(updclientdata)) {
						// 客户端IP
						String ip = udpServerSocket.getResponseAddress().getHostAddress();
						// 设备监控
						UDPEquipmentMonitorParse.parse(updclientdata, ip);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: UdpSmsThreadCreat
	 * @Description: 短信平台UDP心跳数据监视
	 * @author 作者: panshengbo
	 * @date 创建时间: 2020年09月10日 上午9:58:10
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class UdpSmsThreadCreat implements Runnable {
		private int port; // 端口
		private String host; // 主机ip
		private int type;// 类型

		public UdpSmsThreadCreat(int port, String host, int type) {
			this.port = port;
			this.host = host;
			this.type = type;
		}

		@Override
		public void run() {
			UdpServerSocket udpServerSocket = null;
			try {
				udpServerSocket = new UdpServerSocket(host, port);
			} catch (Exception e) {
				log.error("UDP端口(" + this.port + ")监听失败！", e);
			}
			while (true) {
				try {
					String updclientdata = udpServerSocket.receive();
					if (!StringUtil.isEmpty(updclientdata)) {
						// 客户端IP
						// String ip = udpServerSocket.getResponseAddress().getHostAddress();
						// sms udp心跳包监控
						SmsUdpService.doExecuteHeartBeat(updclientdata);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: udpAnalysisWarnDataThread
	 * @Description: 多线程处理数据
	 * @author 作者: huliu
	 * @date 创建时间: 2019年10月1日 下午6:31:33
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class udpAnalysisWarnDataThread implements Runnable {
		private int type;
		private String updclientdata;
		private String ip;

		public udpAnalysisWarnDataThread(String updclientdata, String ip, int type) {
			this.ip = ip;
			this.type = type;
			this.updclientdata = updclientdata;
		}

		@Override
		public void run() {
			switch (this.type) {
			case 1:// UDP实时报警监测
				log.info(updclientdata);
				UDPQualityRealtimeParse udpRealtime = new UDPQualityRealtimeParse();
				udpRealtime.parse(updclientdata);
				break;
			case 3:// 高清频道扫描监听
				hdtvParse(updclientdata);
				break;
			case 4:// 电视心跳包服务
				AnalysisCardHeartbeat.cardHeartbeatAnalysis(ip, updclientdata, "3");
				break;
			case 5:// 广播心跳包服务
				AnalysisCardHeartbeat.cardHeartbeatAnalysis(ip, updclientdata, "1");
				break;
			case 6:// 板卡一键配置
				OneKeyConfigAnalysis.oneKeyConfigAnalysis(updclientdata);
				break;
			case 12:// 乡镇心跳
				EquipmentAddressMonitor.parse(ip, updclientdata);
				break;
			default:
				break;
			}
		}
	}

	/**
	 * 
	 * @Title: readTcpClientData
	 * @Description: TCP端口监听处理
	 * @param @param port
	 * @param @param type 参数
	 * @return void 返回类型
	 * @date 2017年4月18日 上午11:01:29
	 */
	private void readTcpClientData(ServerSocket serverSocket, int type) {
		// 让服务器无穷的循环等待客户端的请求
		Socket socket = null;
		try {
			/*
			 * accept()方法会在等待用户的socket连接时闲置着，当用户链接上来时， 此方法会返回一个socket(在不同的端口上)以便与客户端通信。
			 * Socket与ServerSocket的端口不同，因此ServerSocket可以 空闲出来等待其他客户端
			 */
			// 这个方法会停下来等待要求到达之后再继续
			socket = serverSocket.accept();
			socket.setSoTimeout(5000);
			switch (type) {
			case 1:// 实施报警
				new AlarmInformationSocket().doExecute(socket);
				break;
			case 2:// 实时监测
				new RealtimeSocket().doExecute(socket);
				break;
			case 3:// 数据处理
				new DataManageSocket().doExecute(socket);
				break;
			case 4:// 安全监测
				new SecurityDetectionSocket().doExecute(socket);
				break;
			case 44:// 安全监测
				new SecurityDetectionSocketAHXD().doExecute(socket);
				break;
			case 5:// 内容监测
				break;
			case 6:// 其它监测
				new OtherMonitorlSocket().doExecute(socket);
				break;
			case 7:// 选择监测
				new SelectMonitoringDataAnalysis().doExecute(socket);
				break;
			case 8:// 参数配置
				new ParamconfigSocket().doExecute(socket);
				break;
			case 9:// 数据分析
				new SocketDataAnalysis().doExecute(socket);
				break;
			case 10:// 视频回看(历史记录)
				new HistoryPlaySocket().doExecute(socket);
				break;
			case 11:// 设备监控
				new EquipmentMonitorSocket().doExecute(socket);
				break;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: WisdomHandleThread
	 * @Description: 智慧处理模块
	 * @author 作者: huliu
	 * @date 创建时间: 2020年4月14日 上午9:38:38
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class WisdomHandleThread implements Runnable {

		IWisdomHandle wisdomHandle;

		public WisdomHandleThread() {
			wisdomHandle = (IWisdomHandle) ApplicationContext.getBean("wisdomHandle");
		}

		public void run() {
			while (true) {
				try {
					WisdomAlarmDataBean wisomBean = wisdomHandle.getQueueData();
					if (!StringUtil.isEmpty(wisomBean)) {
						wisdomHandle.saveTeamAlarmDataToRedis(wisomBean.getChannelInfo(), wisomBean.getAlarmData(),
								wisomBean.getType(), wisomBean.getAlarmHeader());
					} else {
						Thread.sleep(1000);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 
	 * @Package cn.com.jc.socket.tcp
	 * @ClassName: WisdomHandleThread
	 * @Description: 智慧处理数据库模块
	 * @author 作者: huliu
	 * @date 创建时间: 2020年4月14日 上午9:38:38
	 * @version V1.0
	 * @since JDK 1.7
	 *
	 */
	class WisdomDbHandleThread implements Runnable {

		IWisdomHandle wisdomHandle;

		public WisdomDbHandleThread() {
			wisdomHandle = (IWisdomHandle) ApplicationContext.getBean("wisdomHandle");
		}

		public void run() {
			while (true) {
				try {
					Thread.sleep(1000);
					wisdomHandle.wisdomHandleAlarmDB("");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 
	 * @Title: hdtvParse
	 * @Description: 处理高清频道扫描的结果
	 * @author 作者: huliu
	 * @param @param fileName 参数
	 * @return void 返回类型
	 * @date 2018年10月25日 上午11:20:32
	 */
	private void hdtvParse(String fileName) {
		HdtvScannScheduler.doExecute(fileName);
	}

	// 根据值班员上班时间，自动同步报警数据,数字电视按照值班员上班时间前四十分钟-下班时间前半小时区间同步
	class AttendantSchedualThreadSZDS implements Runnable {

		IAttendantWorkingTimeService attendantWorkingTimeService;

		public AttendantSchedualThreadSZDS() {
			attendantWorkingTimeService = (IAttendantWorkingTimeService) ApplicationContext
					.getBean("attendantWorkingTimeServiceImpl");
		}

		public void run() {
			while (true) {
				try {
					String time = attendantWorkingTimeService.isExecuteTime();
					if (!time.equals("-1")) {
						String[] timeArr = time.split("\\*");
						String startTime = timeArr[0];
						String endTime = timeArr[1];
						SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
						String dateString = formatter.format(new Date());

						Date startDate = simpleDateFormat.parse(dateString + " " + startTime);

						// 取上班时间之前40分钟为同步时间，避免遗漏
						startDate = new Date(startDate.getTime() - 40 * 60 * 1000);
						List<Integer> list = new ArrayList<Integer>();
						list.add(3);
						attendantWorkingTimeService.scheduleSyncAlarm(simpleDateFormat.format(startDate),
								dateString + " " + endTime, list);
						Thread.sleep(1000 * 60 * 60 * 3);
					} else {
						Thread.sleep(1000 * 60);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	// 根据值班员上班时间，自动同步报警数据，广播和模拟电视每半小时同步一次
	class AttendantSchedualThreadOthers implements Runnable {

		IAttendantWorkingTimeService attendantWorkingTimeService;

		public AttendantSchedualThreadOthers() {
			attendantWorkingTimeService = (IAttendantWorkingTimeService) ApplicationContext
					.getBean("attendantWorkingTimeServiceImpl");
		}

		public void run() {
			while (true) {
				try {

					SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
					String endDateStr = simpleDateFormat.format(new Date());

					// 取结束时间之前50分钟为同步时间，避免遗漏
					String startDateStr = simpleDateFormat.format(new Date(new Date().getTime() - 50 * 60 * 1000));
					List<Integer> list = new ArrayList<Integer>();
					list.add(1);
					// list.add(2);
					attendantWorkingTimeService.scheduleSyncAlarm(startDateStr, endDateStr, list);
					Thread.sleep(1000 * 60 * 30);

				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
}