自定义serverSocket线程池，处理并发链接

public class AppServerSocket {
    private Integer port;
    private static ServerSocket serverSocket;


    public AppServerSocket(Integer port) {
        this.port = port;
        try {
            start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 接受连接
     */
    public void start() throws IOException {
        serverSocket = new ServerSocket(port);
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Socket socket = serverSocket.accept();
                        handleSocket(socket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    /**
     * 处理连接
     * @param socket
     */
    public static void handleSocket(Socket socket) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                  
                    MessageHandler.sendMessage(socket.getOutputStream(), "GetAppId", new HashMap<>());
                 
                    String message = MessageHandler.parseMessage(socket.getInputStream());
                
                    if (isNotEmpty(appIdMessageDto)) {
                        if (appIdMessageDto.isSuccess()) {
                            //添加到SocketPools中
                           
                            SocketHandler.addScoket(appId, socket);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    System.out.println("----------------" + e.getMessage());
                }
            }
        }).start();
    }


}

public class MessageHandler {

    private static final String key = "***********************";

    private static final Logger LOGGER = LoggerFactory.getLogger(MessageHandler.class);


    //发送数据到客户端
    public static void sendMessage(OutputStream os, String command, Map<String, String> data) {
        try {
            Map<String, Object> params = new HashMap<>();
            params.put("command", command);

       //签名
            String sign = getSign(data);
            params.put("sign", sign);
            LOGGER.debug("-------send----sign--------" + sign);
            if (isNotEmpty(data)) {
                params.put("data", JSON.toJSONString(data));
            } else {
                params.put("data", "");
            }
            DataOutputStream out = new DataOutputStream(os);
            StringBuilder str = new StringBuilder();
            
            out.writeUTF(JSON.toJSONString(params ));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void sendMessage(String appId, String command, Map<String, String> data) {
        Socket socket = SocketHandler.getSocket(appId);
        if (isEmpty(socket)) {
            throw new MonkeyException("socket is empty");
        }
        try {
            sendMessage(socket.getOutputStream(), command, data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    //获取客户端返回的消息
    public static String parseMessage(String appId) throws Exception {
        Socket socket = SocketHandler.getSocket(appId);
        DataInputStream in = new DataInputStream(socket.getInputStream());
        String message = in.readUTF();
        String messageString = checkMessageString(message);
        if (!resultCheckSign(messageString)) {
            throw new Exception("sign error");
        }
        return messageString;
    }

    public static String checkMessageString(String message) {
        if (isNotEmpty(message)) {
            if (message.startsWith("***") && message.endsWith("***")) {
                int start = message.indexOf("{");
                int end = message.lastIndexOf("}");
                String substring = message.substring(start, end + 1);
                return substring;
            }
        }
        throw new MonkeyException("返回的消息不完整");
    }

    public static String parseMessage(InputStream inputStream) throws Exception {
        DataInputStream in = new DataInputStream(inputStream);
        String message = in.readUTF();
        String messageString = checkMessageString(message);
        if (!resultCheckSign(messageString)) {
            throw new Exception("sign error");
        }
        return messageString;
    }

    public static Boolean resultCheckSign(String message) {
        JSONObject jsonObject = JSON.parseObject(message);
        if (isNotEmpty(jsonObject)) {
            String sign = jsonObject.getString("sign");
            LOGGER.debug("--------return--sign--------" + sign);
            String dataStr = jsonObject.getString("data");
            if (isNotEmpty(dataStr)) {

                return SignUtils.checkRoadGateSign(dataStr, key, sign);
            } else {
                return SignUtils.checkRoadGateSign("", key, sign);
            }

        }
        return false;
    }


    public static String getSign(Map<String, String> data) {
        String preStr = "";
        if (MonkeyUtils.isNotEmpty(data)) {
            preStr = JSON.toJSONString(data);
            String sign = MD5.sign(preStr, "&salt=" + key, "utf-8");
            return sign;
        }

public class MD5 {
    public static void main(String[] args) {
        String str = "appId=wx8632a91376b81e24&callback_url=http://u.shdplan.com/usr/details.html?paySuc=true&awaId=AID201508100946430003&money=1.99&nonceStr=1441076469693&package=prepay_id=wx2015090111010993f0dd52c80787614418&signType=MD5&status=0&timeStamp=1441076469693";
        System.out.println(MD5.sign(str, "&key=8748fd966d0ffc47abd59e97", "utf-8"));

    }

    /**
     * 签名字符串
     * @param text 需要签名的字符串
     * @param key 密钥
     * @param input_charset 编码格式
     * @return 签名结果
     */
    public static String sign(String text, String key, String input_charset) {
       text = text + key;
        return DigestUtils.md5Hex(getContentBytes(text, input_charset));
    }

    /**
     * 签名字符串
     * @param text 需要签名的字符串
     * @param sign 签名结果
     * @param key 密钥
     * @param input_charset 编码格式
     * @return 签名结果
     */
    public static boolean verify(String text, String sign, String key, String input_charset) {
       text = text + key;
       String mysign = DigestUtils.md5Hex(getContentBytes(text, input_charset));
       if(mysign.equals(sign)) {
          return true;
       }
       else {
          return false;
       }
    }

    /**
     * @param content
     * @param charset
     * @return
     * @throws SignatureException
     * @throws UnsupportedEncodingException
     */
    private static byte[] getContentBytes(String content, String charset) {
        if (charset == null || "".equals(charset)) {
            return content.getBytes();
        }
        try {
            return content.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
        }
    }

}

return MD5. sign( preStr, "salt=" + key, "utf-8"); }}

public class SocketHandler {

    private static ConcurrentMap<String, Socket> socketPools = new ConcurrentHashMap<>();

    public static void addScoket(String appId, Socket socket) {
        socketPools.put(appId, socket);
    }
//这里是保证线程同步
    public static synchronized Socket getSocket(String appId) {
        return socketPools.get(appId);
    }

}

public class SignUtils {

    /**
     * <一句话功能简述>
     * <功能详细描述>验证返回参数
     *
     * @param params
     * @param key
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static boolean checkParam(Map<String, String> params, String key) {
        boolean result = false;
        if (params.containsKey("sign")) {
            String sign = params.get("sign");
            params.remove("sign");
            StringBuilder buf = new StringBuilder((params.size() + 1) * 10);
            SignUtils.buildPayParams(buf, params, false);
            String preStr = buf.toString();
            String signRecieve = MD5.sign(preStr, "&key=" + key, "utf-8");
            result = sign.equalsIgnoreCase(signRecieve);
        }
        return result;
    }

    public static boolean checkRoadGateSign(String params, String key, String sign) {
        boolean result = false;
        if (params != null && params != "" && params.length() > 0) {
            String signRecieve = MD5.sign(params, "&salt=" + key, "utf-8");
            return sign.equalsIgnoreCase(signRecieve);
        }
        String signRecieve = MD5.sign("", "salt=" + key, "utf-8");
        result = sign.equalsIgnoreCase(signRecieve);
        return result;
    }

    /**
     * 过滤参数
     *
     * @param sArray
     * @return
     * @author
     */
    public static Map<String, String> paraFilter(Map<String, String> sArray) {
        Map<String, String> result = new HashMap<>(sArray.size());
        if (sArray.size() <= 0) {
            return result;
        }
        for (String key : sArray.keySet()) {
            String value = sArray.get(key);
            if (value == null || value.equals("") || key.equalsIgnoreCase("sign") || key.equalsIgnoreCase("access_token")) {
                continue;
            }
            result.put(key, value);
        }
        return result;
    }

    /**
     * <一句话功能简述>
     * <功能详细描述>将map转成String
     *
     * @param payParams
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static String payParamsToString(Map<String, String> payParams) {
        return payParamsToString(payParams, false);
    }

    public static String payParamsToString(Map<String, String> payParams, boolean encoding) {
        return payParamsToString(new StringBuilder(), payParams, encoding);
    }

    /**
     * @param payParams
     * @return
     * @author
     */
    public static String payParamsToString(StringBuilder sb, Map<String, String> payParams, boolean encoding) {
        buildPayParams(sb, payParams, encoding);
        return sb.toString();
    }

    /**
     * @param payParams
     * @return
     * @author
     */
    public static void buildPayParams(StringBuilder sb, Map<String, String> payParams, boolean encoding) {
        List<String> keys = new ArrayList<String>(payParams.keySet());
        Collections.sort(keys);
        for (String key : keys) {
            sb.append(key).append("=");
            if (encoding) {
                sb.append(urlEncode(payParams.get(key)));
            } else {
                sb.append(payParams.get(key));
            }
            sb.append("&");
        }
        sb.setLength(sb.length() - 1);
    }

    public static String urlEncode(String str) {
        try {
            return URLEncoder.encode(str, "UTF-8");
        } catch (Throwable e) {
            return str;
        }
    }


    public static Element readerXml(String body, String encode) throws DocumentException {
        SAXReader reader = new SAXReader(false);
        InputSource source = new InputSource(new StringReader(body));
        source.setEncoding(encode);
        Document doc = reader.read(source);
        Element element = doc.getRootElement();
        return element;
    }

    public static String sortMapKey(Map<String, String> map) {
        List<Map.Entry<String, String>> infoIds = new ArrayList(map.entrySet());
        infoIds.sort(Comparator.comparing((o) -> {
            return (String) o.getKey();
        }));
        StringBuilder buf = new StringBuilder();
        Iterator var3 = infoIds.iterator();

        while (var3.hasNext()) {
            Map.Entry<String, String> item = (Map.Entry) var3.next();
            if (StringUtils.isNotBlank((CharSequence) item.getKey())) {
                String key = (String) item.getKey();
                String val = (String) item.getValue();
                buf.append(key).append("=").append(val);
                buf.append("&");
            }
        }

        String buff = buf.toString();
        if (!buff.isEmpty()) {
            buff = buff.substring(0, buff.length() - 1);
        }

        return buff;
    }

}

public class MD5 {
 

    /**
     * 签名字符串
     * @param text 需要签名的字符串
     * @param key 密钥
     * @param input_charset 编码格式
     * @return 签名结果
     */
    public static String sign(String text, String key, String input_charset) {
       text = text + key;
        return DigestUtils.md5Hex(getContentBytes(text, input_charset));
    }

    /**
     * 签名字符串
     * @param text 需要签名的字符串
     * @param sign 签名结果
     * @param key 密钥
     * @param input_charset 编码格式
     * @return 签名结果
     */
    public static boolean verify(String text, String sign, String key, String input_charset) {
       text = text + key;
       String mysign = DigestUtils.md5Hex(getContentBytes(text, input_charset));
       if(mysign.equals(sign)) {
          return true;
       }
       else {
          return false;
       }
    }

    /**
     * @param content
     * @param charset
     * @return
     * @throws SignatureException
     * @throws UnsupportedEncodingException
     */
    private static byte[] getContentBytes(String content, String charset) {
        if (charset == null || "".equals(charset)) {
            return content.getBytes();
        }
        try {
            return content.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
        }
    }

}