1. public class AppServerSocket {
2. private Integer port;
3. private static ServerSocket serverSocket;
6. public AppServerSocket(Integer port) {
7. this.port = port;
8. try {
9. start();
10. } catch (IOException e) {
11. e.printStackTrace();
12. }
13. }
15. /**
16. * 接受连接
17. */
18. public void start() throws IOException {
19. serverSocket = new ServerSocket(port);
20. new Thread(new Runnable() {
21. @Override
22. public void run() {
23. while (true) {
24. try {
25. Socket socket = serverSocket.accept();
26. handleSocket(socket);
27. } catch (IOException e) {
28. e.printStackTrace();
29. }
30. }
31. }
32. }).start();
33. }
35. /**
36. * 处理连接
37. * @param socket
38. */
39. public static void handleSocket(Socket socket) {
40. new Thread(new Runnable() {
41. @Override
42. public void run() {
43. try {
45. MessageHandler.sendMessage(socket.getOutputStream(), “test”, new HashMap<>());
47. String message = MessageHandler.parseMessage(socket.getInputStream());
49. if (isNotEmpty(appIdMessageDto)) {
50. if (appIdMessageDto.isSuccess()) {
51. //添加到SocketPools中
53. SocketHandler.addScoket(appId, socket);
54. }
55. }
56. } catch (IOException e) {
57. e.printStackTrace();
58. } catch (Exception e) {
59. System.out.println(“—————-” + e.getMessage());
60. }
61. }
62. }).start();
63. }
66. }

1. public class MessageHandler {
3. private static final String key = “***********************”;
5. private static final Logger LOGGER = LoggerFactory.getLogger(MessageHandler.class);
8. //发送数据到客户端
9. public static void sendMessage(OutputStream os, String command, Map<String, String> data) {
10. try {
11. Map<String, Object> params = new HashMap<>();
12. params.put(“command”, command);

1.       //签名
2. String sign = getSign(data);
3. params.put(“sign”, sign);
4. LOGGER.debug(“——-send—-sign——–” + sign);
5. if (isNotEmpty(data)) {
6. params.put(“data”, JSON.toJSONString(data));
7. } else {
8. params.put(“data”, “”);
9. }
10. DataOutputStream out = new DataOutputStream(os);
11. StringBuilder str = new StringBuilder();
13. out.writeUTF(JSON.toJSONString(params ));
14. } catch (IOException e) {
15. e.printStackTrace();
16. }
17. }
19. public static void sendMessage(String appId, String command, Map<String, String> data) {
20. Socket socket = SocketHandler.getSocket(appId);
21. if (isEmpty(socket)) {
22. throw new MonkeyException(“socket is empty”);
23. }
24. try {
25. sendMessage(socket.getOutputStream(), command, data);
26. } catch (IOException e) {
27. e.printStackTrace();
28. }
29. }
32. //获取客户端返回的消息
33. public static String parseMessage(String appId) throws Exception {
34. Socket socket = SocketHandler.getSocket(appId);
35. DataInputStream in = new DataInputStream(socket.getInputStream());
36. String message = in.readUTF();
37. String messageString = checkMessageString(message);
38. if (!resultCheckSign(messageString)) {
39. throw new Exception(“sign error”);
40. }
41. return messageString;
42. }
44. public static String checkMessageString(String message) {
45. if (isNotEmpty(message)) {
46. if (message.startsWith(“***”) && message.endsWith(“***”)) {
47. int start = message.indexOf(“{“);
48. int end = message.lastIndexOf(“}”);
49. String substring = message.substring(start, end + 1);
50. return substring;
51. }
52. }
53. throw new Exception(“返回的消息不完整”);
54. }
56. public static String parseMessage(InputStream inputStream) throws Exception {
57. DataInputStream in = new DataInputStream(inputStream);
58. String message = in.readUTF();
59. String messageString = checkMessageString(message);
60. if (!resultCheckSign(messageString)) {
61. throw new Exception(“sign error”);
62. }
63. return messageString;
64. }
66. public static Boolean resultCheckSign(String message) {
67. JSONObject jsonObject = JSON.parseObject(message);
68. if (isNotEmpty(jsonObject)) {
69. String sign = jsonObject.getString(“sign”);
70. LOGGER.debug(“——–return–sign——–” + sign);
71. String dataStr = jsonObject.getString(“data”);
72. if (isNotEmpty(dataStr)) {
74. return SignUtils.checkRoadGateSign(dataStr, key, sign);
75. } else {
76. return SignUtils.checkRoadGateSign(“”, key, sign);
77. }
79. }
80. return false;
81. }
84. public static String getSign(Map<String, String> data) {
85. String preStr = “”;
86. if (isNotEmpty(data)) {
87. preStr = JSON.toJSONString(data);
88. String sign = MD5.sign(preStr, “&salt=” + key, “utf-8″);
89. return sign;
90. }

1. public class SocketHandler {
3. private static ConcurrentMap<String, Socket> socketPools = new ConcurrentHashMap<>();
5. public static void addScoket(String appId, Socket socket) {
6. socketPools.put(appId, socket);
7. }
8. //这里是保证线程同步
9. public static synchronized Socket getSocket(String appId) {
10. return socketPools.get(appId);
11. }
13. }

1. public class SignUtils {
3. /**
4. * <一句话功能简述>
5. * <功能详细描述>验证返回参数
6. *
7. * @param params
8. * @param key
9. * @return
10. * @see [类、类#方法、类#成员]
11. */
12. public static boolean checkParam(Map<String, String> params, String key) {
13. boolean result = false;
14. if (params.containsKey(“sign”)) {
15. String sign = params.get(“sign”);
16. params.remove(“sign”);
17. StringBuilder buf = new StringBuilder((params.size() + 1) * 10);
18. SignUtils.buildPayParams(buf, params, false);
19. String preStr = buf.toString();
20. String signRecieve = MD5.sign(preStr, “&key=” + key, “utf-8″);
21. result = sign.equalsIgnoreCase(signRecieve);
22. }
23. return result;
24. }
26. public static boolean checkRoadGateSign(String params, String key, String sign) {
27. boolean result = false;
28. if (params != null && params != “” && params.length() > 0) {
29. String signRecieve = MD5.sign(params, “&salt=” + key, “utf-8″);
30. return sign.equalsIgnoreCase(signRecieve);
31. }
32. String signRecieve = MD5.sign(“”, “salt=” + key, “utf-8″);
33. result = sign.equalsIgnoreCase(signRecieve);
34. return result;
35. }
37. /**
38. * 过滤参数
39. *
40. * @param sArray
41. * @return
42. * @author
43. */
44. public static Map<String, String> paraFilter(Map<String, String> sArray) {
45. Map<String, String> result = new HashMap<>(sArray.size());
46. if (sArray.size() <= 0) {
47. return result;
48. }
49. for (String key : sArray.keySet()) {
50. String value = sArray.get(key);
51. if (value == null || value.equals(“”) || key.equalsIgnoreCase(“sign”) || key.equalsIgnoreCase(“access_token”)) {
52. continue;
53. }
54. result.put(key, value);
55. }
56. return result;
57. }
59. /**
60. * <一句话功能简述>
61. * <功能详细描述>将map转成String
62. *
63. * @param payParams
64. * @return
65. * @see [类、类#方法、类#成员]
66. */
67. public static String payParamsToString(Map<String, String> payParams) {
68. return payParamsToString(payParams, false);
69. }
71. public static String payParamsToString(Map<String, String> payParams, boolean encoding) {
72. return payParamsToString(new StringBuilder(), payParams, encoding);
73. }
75. /**
76. * @param payParams
77. * @return
78. * @author
79. */
80. public static String payParamsToString(StringBuilder sb, Map<String, String> payParams, boolean encoding) {
81. buildPayParams(sb, payParams, encoding);
82. return sb.toString();
83. }
85. /**
86. * @param payParams
87. * @return
88. * @author
89. */
90. public static void buildPayParams(StringBuilder sb, Map<String, String> payParams, boolean encoding) {
91. List<String> keys = new ArrayList<String>(payParams.keySet());
92. Collections.sort(keys);
93. for (String key : keys) {
94. sb.append(key).append(“=”);
95. if (encoding) {
96. sb.append(urlEncode(payParams.get(key)));
97. } else {
98. sb.append(payParams.get(key));
99. }
100. sb.append(“&”);
101. }
102. sb.setLength(sb.length() – 1);
103. }
105. public static String urlEncode(String str) {
106. try {
107. return URLEncoder.encode(str, “UTF-8″);
108. } catch (Throwable e) {
109. return str;
110. }
111. }
114. public static Element readerXml(String body, String encode) throws DocumentException {
115. SAXReader reader = new SAXReader(false);
116. InputSource source = new InputSource(new StringReader(body));
117. source.setEncoding(encode);
118. Document doc = reader.read(source);
119. Element element = doc.getRootElement();
120. return element;
121. }
123. public static String sortMapKey(Map<String, String> map) {
124. List<Map.Entry<String, String>> infoIds = new ArrayList(map.entrySet());
125. infoIds.sort(Comparator.comparing((o) -> {
126. return (String) o.getKey();
127. }));
128. StringBuilder buf = new StringBuilder();
129. Iterator var3 = infoIds.iterator();
131. while (var3.hasNext()) {
132. Map.Entry<String, String> item = (Map.Entry) var3.next();
133. if (StringUtils.isNotBlank((CharSequence) item.getKey())) {
134. String key = (String) item.getKey();
135. String val = (String) item.getValue();
136. buf.append(key).append(“=”).append(val);
137. buf.append(“&”);
138. }
139. }
141. String buff = buf.toString();
142. if (!buff.isEmpty()) {
143. buff = buff.substring(0, buff.length() – 1);
144. }
146. return buff;
147. }

}

1. public class MD5 {
4. /**
5. * 签名字符串
6. * @param text 需要签名的字符串
7. * @param key 密钥
8. * @param input_charset 编码格式
9. * @return 签名结果
10. */
11. public static String sign(String text, String key, String input_charset) {
12. text = text + key;
13. return DigestUtils.md5Hex(getContentBytes(text, input_charset));
14. }
16. /**
17. * 签名字符串
18. * @param text 需要签名的字符串
19. * @param sign 签名结果
20. * @param key 密钥
21. * @param input_charset 编码格式
22. * @return 签名结果
23. */
24. public static boolean verify(String text, String sign, String key, String input_charset) {
25. text = text + key;
26. String mysign = DigestUtils.md5Hex(getContentBytes(text, input_charset));
27. if(mysign.equals(sign)) {
28. return true;
29. }
30. else {
31. return false;
32. }
33. }
35. /**
36. * @param content
37. * @param charset
38. * @return
39. * @throws SignatureException
40. * @throws UnsupportedEncodingException
41. */
42. private static byte[] getContentBytes(String content, String charset) {
43. if (charset == null || “”.equals(charset)) {
44. return content.getBytes();
45. }
46. try {
47. return content.getBytes(charset);
48. } catch (UnsupportedEncodingException e) {
49. throw new RuntimeException(“MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:” + charset);
50. }
51. }
53.  }