一站式消息管理器

一站式的消息管理器

在网络应用中，消息处理是必不可少的，该文章主要简单介绍一款简单的消息管理器的实现，其具备以下功能：

• 提供多种消息序列化和反序列化方式，目前支持JDK、ProtoStuff以及JSON，提供其他自定义的序列化/反序列化器插口。
  
• 提供多种消息加密/解密，目前支持对称加密：AES、不对称加密：RSA、不可逆散列加密：MD5以及Base64的转化并且提供自定义的加密/解密器插口。
  
• 提供简单方便的消息构造，支持链式构造。
  
• 支持创建可复用的流程化消息发送器和接收器、可以完成从消息发布、消息格式化、消息序列化/反序列化，消息加密/解密的流程处理，并且发送器和接收器支持序列化保存。
  

首先需要引入依赖:

1. <dependency>
2.       <groupId>io.protostuff</groupId>
3.       protostuff-core</artifactId>
4.       <version>1.6.0</version>
5. </dependency>
6. <dependency>
7.       <groupId>io.protostuff</groupId>
8.       protostuff-runtime</artifactId>
9.       <version>1.6.0</version>
10. </dependency>
11. <dependency>
12.       <groupId>com.google.code.gson</groupId>
13.       gson</artifactId>
14.       <version>2.8.5</version>
15. </dependency>

复制代码

然后直接拷贝源码

1. import com.google.gson.*;
2. import io.protostuff.LinkedBuffer;
3. import io.protostuff.ProtostuffIOUtil;
4. import io.protostuff.Schema;
5. import io.protostuff.runtime.RuntimeSchema;
6. import sun.misc.BASE64Decoder;
7. import sun.misc.BASE64Encoder;
9. import javax.crypto.Cipher;
10. import javax.crypto.spec.SecretKeySpec;
11. import java.io.*;
12. import java.lang.reflect.Type;
13. import java.math.BigInteger;
14. import java.nio.charset.Charset;
15. import java.nio.charset.StandardCharsets;
16. import java.security.*;
17. import java.security.spec.PKCS8EncodedKeySpec;
18. import java.security.spec.X509EncodedKeySpec;
19. import java.util.*;
20. import java.util.concurrent.ConcurrentHashMap;
22. /**
23. * 提供一站式的消息处理
24. *
25. * @author JingGe(* ^ ▽ ^ *)
26. * @date 2023-03-24 15:53
27. * @email 1158055613@qq.com
28. */
29. public class MessageManager {
30.     /*=================消息序列化/反序列化器=================>*/
31.     private static final Gson GSON = new GsonBuilder()
32.             .enableComplexMapKeySerialization()
33.             .setDateFormat("yyyy-MM-dd HH:mm:ss")
34.             .registerTypeAdapter(Class.class, new ClassCodec())
35.             .create();
36.     public static final MessageSerializer<String> JSON_SERIALIZER = GSON::toJson;
37.     public static final MessageDeserializer<Object> JSON_DESERIALIZER = (source, type) -> GSON.fromJson(new String(source, StandardCharsets.UTF_8), type);
38.     public static final MessageSerializer<byte[]> PROTO_STUFF_SERIALIZER = ProtoStuffUtil::serialize;
39.     public static final MessageDeserializer<Object> PROTO_STUFF_DESERIALIZER = ProtoStuffUtil::deserialize;
40.     public static final MessageSerializer<byte[]> JDK_SERIALIZER = source -> {
41.         ByteArrayOutputStream stream = new ByteArrayOutputStream();
42.         try {
43.             ObjectOutputStream outputStream = new ObjectOutputStream(stream);
44.             outputStream.writeObject(source);
45.         } catch (IOException e) {
46.             e.printStackTrace();
47.         }
49.         return stream.toByteArray();
50.     };
51.     public static final MessageDeserializer<Object> JDK_DESERIALIZER = (source, type) -> {
52.         ByteArrayInputStream stream = new ByteArrayInputStream(source);
53.         try {
54.             ObjectInputStream inputStream = new ObjectInputStream(stream);
55.             return (Serializable) inputStream.readObject();
56.         } catch (IOException | ClassNotFoundException e) {
57.             e.printStackTrace();
58.         }
59.         return null;
60.     };
62.     public interface MessageSerializer<T> {
63.         T serialize(Object source);
64.     }
66.     public interface MessageDeserializer<T> {
67.         T deserialize(byte[] source, Class<T> type);
68.     }
69.     /*=======================Finished======================<*/
71.     /*=================加密/解密器=================>*/
72.     public static final Encryptor<Object> NO_ENCRYPTOR = (source, key) -> source;
73.     public static final Decipher<Object> NO_DECIPHER = (source, key) -> source;
74.     public static final Encryptor<byte[]> AES_ENCRYPTOR = (source, key) -> {
75.         try {
76.             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
77.             cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(bytes(key, Charset.defaultCharset(), "密钥只能是byte array或者String"), "AES"));
78.             return cipher.doFinal(source);
79.         } catch (Exception e) {
80.             e.printStackTrace();
81.         }
82.         return null;
83.     };
84.     public static final Decipher<byte[]> AES_DECIPHER = (source, key) -> {
85.         try {
86.             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
87.             cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(bytes(key, Charset.defaultCharset(), "密钥只能是byte array或者String"), "AES"));
88.             return cipher.doFinal(source);
89.         } catch (Exception e) {
90.             e.printStackTrace();
91.         }
92.         return null;
93.     };
94.     public static final RSAEncryptor RSA_ENCRYPTOR = new RSAEncryptor();
95.     public static final RSADecipher RSA_DECIPHER = new RSADecipher();
97.     public static final MD5Encryptor MD5_ENCRYPTOR = new MD5Encryptor();
99.     public static final Encryptor<String> BASE64_ENCRYPTOR = (source, key) -> {
100.         BASE64Encoder encoder = new BASE64Encoder();
101.         return encoder.encode(source);
102.     };
103.     public static final Decipher<byte[]> BASE64_DECIPHER = (source, key) -> {
104.         try {
105.             BASE64Decoder decoder = new BASE64Decoder();
106.             return decoder.decodeBuffer(new String(source));
107.         } catch (Exception e) {
108.             e.printStackTrace();
109.         }
110.         return null;
111.     };
113.     public static class RSAEncryptor implements Encryptor<byte[]> {
115.         @Override
116.         public byte[] encrypt(byte[] source, Object publicKey) {
117.             try {
118.                 PublicKey key = null;
119.                 if (publicKey instanceof PublicKey) {
120.                     key = (PublicKey) publicKey;
121.                 } else {
122.                     byte[] content = bytes(publicKey, Charset.defaultCharset(), "密钥格式异常：" + publicKey
123.                             .getClass()
124.                             .getName());
125.                     X509EncodedKeySpec keySpec = new X509EncodedKeySpec(content);
126.                     KeyFactory keyFactory = KeyFactory.getInstance("RSA");
127.                     key = keyFactory.generatePublic(keySpec);
128.                     ;
129.                 }
130.                 Cipher cipher = Cipher.getInstance("RSA");
131.                 cipher.init(Cipher.ENCRYPT_MODE, key);
132.                 return cipher.doFinal(source);
133.             } catch (Exception e) {
134.                 e.printStackTrace();
135.             }
136.             return null;
137.         }
139.         public KeyPair generateKeyPair(int keySize) {
140.             try {
141.                 keySize = keySize <= 0 ? 2048 : keySize;
142.                 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
143.                 keyPairGenerator.initialize(keySize);
144.                 return keyPairGenerator.generateKeyPair();
145.             } catch (Exception e) {
146.                 e.printStackTrace();
147.             }
148.             return null;
149.         }
152.     }
154.     public static class RSADecipher implements Decipher<byte[]> {
155.         @Override
156.         public byte[] decrypt(byte[] source, Object privateKey) {
157.             try {
158.                 PrivateKey key = null;
159.                 if (privateKey instanceof PrivateKey) {
160.                     key = (PrivateKey) privateKey;
161.                 } else {
162.                     byte[] content = bytes(privateKey, Charset.defaultCharset(), "密钥格式异常：" + privateKey
163.                             .getClass()
164.                             .getName());
165.                     PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(content);
166.                     KeyFactory keyFactory = KeyFactory.getInstance("RSA");
167.                     key = keyFactory.generatePrivate(keySpec);
168.                 }
169.                 Cipher cipher = Cipher.getInstance("RSA");
170.                 cipher.init(Cipher.DECRYPT_MODE, key);
171.                 return cipher.doFinal(source);
172.             } catch (Exception e) {
173.                 e.printStackTrace();
174.             }
175.             return null;
176.         }
177.     }
179.     public static class MD5Encryptor implements Encryptor<String> {
180.         @Override
181.         public String encrypt(byte[] source, Object saltKey) {
182.             byte[] key = bytes(saltKey, Charset.defaultCharset(), "密钥只能是String或byte array");
183.             byte[] content = new byte[source.length + key.length];
184.             System.arraycopy(source, 0, content, 0, source.length);
185.             System.arraycopy(key, 0, content, source.length, key.length);
186.             byte[] res;
187.             try {
188.                 MessageDigest messageDigest = MessageDigest.getInstance("md5");
189.                 res = messageDigest.digest(messageDigest.digest(content));
190.                 if (res != null) {
191.                     StringBuilder md5code = new StringBuilder(new BigInteger(1, res).toString(16));
192.                     for (int i = 0; i < 32 - md5code.length(); i++) {
193.                         md5code.insert(0, "0");
194.                     }
195.                     return md5code.toString();
196.                 }
197.             } catch (NoSuchAlgorithmException e) {
198.                 e.printStackTrace();
199.             }
200.             return null;
201.         }
202.     }
204.     public interface Encryptor<T> {
205.         T encrypt(byte[] source, Object key);
206.     }
208.     public interface Decipher<T> {
209.         T decrypt(byte[] source, Object key);
210.     }
211.     /*=======================Finished======================<*/
213.     /*=================消息格式化器=================>*/
216.     public interface MessageFormatter<T> {
217.         void format(T msg);
218.     }
219.     /*=======================Finished======================<*/
221.     public static MessageBuilder newMessageBuilder() {
222.         return new MessageBuilder();
223.     }
225.     public static <T> MessageSenderWrapper<T> newMessageSenderWrapper(MessageSender<T> sender) {
226.         return new MessageSenderWrapper<>(sender);
227.     }
229.     public static <T> MessageReceiverWrapper<T> newMessageReceiverBuilder(MessageReceiver<T> receiver) {
230.         return new MessageReceiverWrapper<>(receiver);
231.     }
233.     public static <R> R getMessage(Object msg, MessageSerializer<R> serializer) {
234.         return serializer.serialize(msg);
235.     }
237.     public static <R> R encryptMessage(byte[] msg, byte[] key, Encryptor<R> encryptor) {
238.         return encryptor.encrypt(msg, key);
239.     }
241.     public static <R> R decryptMessage(byte[] msg, byte[] key, Decipher<R> decipher) {
242.         return decipher.decrypt(msg, key);
243.     }
245.     public static String convert2Base64(byte[] msg) {
246.         return BASE64_ENCRYPTOR.encrypt(msg, null);
247.     }
249.     public static byte[] base642Bytes(String base64) {
250.         return BASE64_DECIPHER.decrypt(base64.getBytes(), null);
251.     }
253.     @SuppressWarnings("unchecked")
254.     public static <T> T fromMessage(byte[] msg, Class<T> type, MessageDeserializer<Object> deserializer) {
255.         return (T) deserializer.deserialize(msg, (Class<Object>) type);
256.     }
258.     public static Map<String, Object> wrapper2Map(Code code, String message, Object data) {
259.         Map<String, Object> msg = new HashMap<>();
260.         msg.put("code", code.flag);
261.         msg.put("message", message);
262.         msg.put("data", data);
263.         return msg;
264.     }
266.     public static String getJsonMessage(Code code, String message, Object data) {
267.         return getMessage(wrapper2Map(code, message, data), JSON_SERIALIZER);
268.     }
270.     public static String getJsonMessage(Code code, String message) {
271.         return getMessage(wrapper2Map(code, message, null), JSON_SERIALIZER);
272.     }
274.     public static byte[] getProtoStuffMessage(Code code, String message, Object data) {
275.         return getMessage(wrapper2Map(code, message, data), PROTO_STUFF_SERIALIZER);
276.     }
278.     public static byte[] getProtoStuffMessage(Code code, String message) {
279.         return getMessage(wrapper2Map(code, message, null), PROTO_STUFF_SERIALIZER);
280.     }
282.     public static byte[] getJDKMessage(Code code, String message, Object data) {
283.         return getMessage(wrapper2Map(code, message, data), JDK_SERIALIZER);
284.     }
286.     public static byte[] getJDKMessage(Code code, String message) {
287.         return getMessage(wrapper2Map(code, message, null), JDK_SERIALIZER);
288.     }
290.     public static class MessageBuilder {
291.         private final Map<String, Object> container = new ConcurrentHashMap<>();
292.         private MessageSerializer<?> serializer;
294.         private MessageBuilder() {
295.         }
297.         public MessageBuilder addMsg(String title, Object content) {
298.             container.put(title, content);
299.             return this;
300.         }
302.         public MessageBuilder addAllMsg(Map<String, Object> msg) {
303.             container.putAll(msg);
304.             return this;
305.         }
307.         public MessageBuilder code(Code code) {
308.             container.put("code", code.flag);
309.             return this;
310.         }
312.         public MessageBuilder message(String message) {
313.             container.put("message", message);
314.             return this;
315.         }
317.         public MessageBuilder data(Object data) {
318.             container.put("data", data);
319.             return this;
320.         }
322.         public MessageBuilder setSerializer(MessageSerializer<?> serializer) {
323.             this.serializer = serializer;
324.             return this;
325.         }
327.         public void clear() {
328.             container.clear();
329.         }
331.         @SuppressWarnings("unchecked")
332.         public <T> T getFinalMessage() {
333.             return (T) (serializer == null ? JSON_SERIALIZER : serializer).serialize(container);
334.         }
335.     }
337.     public static class MessageSender<T> implements Serializable, MessageHandler<T> {
338.         private final List<MessageFormatter<Object>> formatters = new ArrayList<>();
339.         private MessageSerializer<?> serializer;
340.         private Encryptor<?> encryptor;
341.         private Object key;
342.         private Charset charset;
343.         private boolean encode2Base64WhenEncrypted;
345.         public MessageSender() {
346.         }
348.         @Override
349.         @SuppressWarnings("unchecked")
350.         public T getFinalMessage(Object msg) {
351.             if (msg == null) {
352.                 return null;
353.             }
354.             for (MessageFormatter<Object> formatter : formatters) {
355.                 if (formatter != null) {
356.                     formatter.format(msg);
357.                 }
358.             }
359.             Object ser = serializer == null ? msg : serializer.serialize(msg);
360.             byte[] content = bytes(ser, charset, "序列化后的消息只能是String或者byte array");
361.             if (encryptor != null) {
362.                 if (encode2Base64WhenEncrypted) {
363.                     return (T) convert2Base64(bytes(encryptor.encrypt(content, key), charset, "加密后的消息只能是String或者byte array"));
364.                 }
365.                 return (T) encryptor.encrypt(content, key);
366.             }
367.             return (T) ser;
368.         }
370.         @SuppressWarnings("unchecked")
371.         public static <T> MessageSender<T> fromBytes(byte[] source, MessageDeserializer<Object> deserializer) {
372.             return (MessageSender<T>) fromMessage(source, MessageSender.class, deserializer);
373.         }
374.     }
376.     public static class MessageReceiver<T> implements Serializable, MessageHandler<T> {
377.         private final List<MessageFormatter<Object>> formatters = new ArrayList<>();
378.         private MessageDeserializer<Object> deserializer;
379.         private Decipher<?> decipher;
380.         private Class<T> type;
381.         private Object key;
382.         private Charset charset;
383.         private boolean decode2Base64BeforeDecrypt;
385.         public MessageReceiver() {
386.         }
388.         @Override
389.         @SuppressWarnings("unchecked")
390.         public T getFinalMessage(Object msg) {
391.             byte[] content = null;
392.             if (decode2Base64BeforeDecrypt) {
393.                 if (msg instanceof String) {
394.                     content = base642Bytes((String) msg);
395.                 } else {
396.                     throw new UnsupportedOperationException("消息不是String类型，无法进行Base64解码");
397.                 }
398.             }
399.             Object des = content == null ? msg : content;
400.             if (decipher != null) {
401.                 des = decipher.decrypt(content == null ? bytes(msg, charset, "如果消息需要解密，则消息必须是byte array") : content, key);
402.             }
403.             T ser = (T) des;
404.             if (deserializer != null) {
405.                 ser = (T) deserializer.deserialize(bytes(des, charset, "解密后的结果必须是String或者byte array"), (Class<Object>) type);
406.             }
407.             for (MessageFormatter<Object> formatter : formatters) {
408.                 if (formatter != null) {
409.                     formatter.format(ser);
410.                 }
411.             }
412.             return (T) ser;
413.         }
415.         @SuppressWarnings("unchecked")
416.         public static <T> MessageReceiver<T> fromBytes(byte[] source, MessageDeserializer<Object> deserializer) {
417.             return (MessageReceiver<T>) fromMessage(source, MessageReceiver.class, deserializer);
418.         }
419.     }
421.     public interface MessageHandler<T> {
422.         T getFinalMessage(Object msg);
423.     }
425.     private static byte[] bytes(Object src, Charset charset, String errorMsg) {
426.         if (src instanceof byte[]) {
427.             return (byte[]) src;
428.         } else if (src instanceof String) {
429.             return charset == null ? ((String) src).getBytes() : ((String) src).getBytes(charset);
430.         }
431.         throw new UnsupportedOperationException(errorMsg);
432.     }
434.     public static class MessageSenderWrapper<T> {
435.         private final MessageSender<T> sender;
437.         private MessageSenderWrapper(MessageSender<T> sender) {
438.             this.sender = sender;
439.         }
441.         public MessageSenderWrapper<T> addFormatter(MessageFormatter<Object> formatter) {
442.             sender.formatters.add(formatter);
443.             return this;
444.         }
446.         public MessageSenderWrapper<T> setSerializer(MessageSerializer<?> serializer) {
447.             sender.serializer = serializer;
448.             return this;
449.         }
451.         public MessageSenderWrapper<T> setEncryptor(Encryptor<?> encryptor, Object key, Charset charset, boolean encode2Base64) {
452.             if (encryptor == null || key == null) {
453.                 throw new IllegalArgumentException("加密器和密钥不能为空");
454.             }
455.             sender.encryptor = encryptor;
456.             sender.key = key;
457.             sender.charset = charset;
458.             sender.encode2Base64WhenEncrypted = encode2Base64;
459.             return this;
460.         }
462.         public MessageSender<T> wrap() {
463.             return sender;
464.         }
465.     }
467.     public static class MessageReceiverWrapper<T> {
468.         private final MessageReceiver<T> receiver;
470.         public MessageReceiverWrapper(MessageReceiver<T> receiver) {
471.             this.receiver = receiver;
472.         }
474.         public MessageReceiverWrapper<T> addFormatter(MessageFormatter<Object> formatter) {
475.             receiver.formatters.add(formatter);
476.             return this;
477.         }
479.         public MessageReceiverWrapper<T> setDeserializer(MessageDeserializer<Object> deserializer, Class<T> type) {
480.             receiver.deserializer = deserializer;
481.             receiver.type = type;
482.             return this;
483.         }
485.         public MessageReceiverWrapper<T> setDecipher(Decipher<?> decipher, Object key, Charset charset, boolean decodeBase642ByteArray) {
486.             if (decipher == null || key == null) {
487.                 throw new IllegalArgumentException("解密器和密钥不能为空");
488.             }
489.             receiver.decipher = decipher;
490.             receiver.key = key;
491.             receiver.charset = charset;
492.             receiver.decode2Base64BeforeDecrypt = decodeBase642ByteArray;
493.             return this;
494.         }
496.         public MessageReceiver<T> wrap() {
497.             return receiver;
498.         }
499.     }
501.     /**
502.      * 状态枚举，支持枚举标识修改
503.      *
504.      * @author Huang Yongxiang
505.      * @date 2021/9/30 9:25
506.      */
507.     public enum Code {
508.         /**
509.          * 请求成功
510.          */
511.         OK("success", 200),
512.         /**
513.          * 服务器内部错误
514.          */
515.         ERROR("error", 500),
516.         /**
517.          * 客户端请求的语法错误，服务器无法理解
518.          */
519.         BAD_REQUEST("bad request", 400),
520.         /**
521.          * 服务器理解请求客户端的请求，但是拒绝执行此请求
522.          */
523.         FORBIDDEN("Forbidden", 403),
524.         /**
525.          * 超时
526.          */
527.         TIME_OUT("time out", 408),
528.         /**
529.          * 服务器无法根据客户端请求的内容特性完成请求
530.          */
531.         NOT_ACCEPTABLE("Not Acceptable", 406),
532.         /**
533.          * 服务器不支持请求的功能，无法完成请求
534.          */
535.         NOT_SUPPORT("Not Implemented", 501),
536.         /**
537.          * 已接受。已经接受请求，但未处理完成
538.          */
539.         ACCEPTED("Accepted", 202);
540.         private String message;
541.         private Integer flag;
543.         Code(String message, Integer flag) {
544.             this.message = message;
545.             this.flag = flag;
546.         }
548.         public String getMessage() {
549.             return message;
550.         }
552.         public Code setMessage(String message) {
553.             this.message = message;
554.             return this;
555.         }
557.         public Integer getFlag() {
558.             return flag;
559.         }
561.         public Code setFlag(Integer flag) {
562.             this.flag = flag;
563.             return this;
564.         }
566.         @Override
567.         public String toString() {
568.             return "Code{" + "message='" + message + '\'' + ", flag=" + flag + '}';
569.         }
570.     }
572.     private static class ClassCodec implements JsonSerializer<Class<?>>, JsonDeserializer<Class<?>> {
573.         @Override
574.         public Class<?> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
575.             try {
576.                 String str = json.getAsString();
577.                 return Class.forName(str);
578.             } catch (ClassNotFoundException e) {
579.                 throw new JsonParseException(e);
580.             }
581.         }
583.         @Override
584.         public JsonElement serialize(Class<?> src, Type typeOfSrc, JsonSerializationContext context) {
585.             return new JsonPrimitive(src.getName());
586.         }
587.     }
589.     private static class ProtoStuffUtil {
590.         private static final ThreadLocal<LinkedBuffer> threadSafeBuffer = new ThreadLocal<>();
591.         private static final Map<Class<?>, Schema<?>> schemaMap = new ConcurrentHashMap<>();
593.         @SuppressWarnings("unchecked")
594.         public static <T> byte[] serialize(T source) {
595.             if (source == null) {
596.                 return null;
597.             }
598.             Class<T> clazz = (Class<T>) source.getClass();
599.             Schema<T> schema = getSchema(clazz);
600.             if (schema == null) {
601.                 throw new NullPointerException("无法获取" + clazz + "的模式");
602.             }
603.             try {
604.                 if (threadSafeBuffer.get() == null) {
605.                     threadSafeBuffer.set(LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
606.                 }
607.                 return ProtostuffIOUtil.toByteArray(source, schema, threadSafeBuffer.get());
608.             } finally {
609.                 threadSafeBuffer
610.                         .get()
611.                         .clear();
612.             }
613.         }
615.         public static <T> T deserialize(byte[] data, Class<T> type) {
616.             if (data == null || data.length == 0) {
617.                 return null;
618.             }
619.             Schema<T> schema = getSchema(type);
620.             if (schema == null) {
621.                 throw new NullPointerException("无法获取" + type + "的模式");
622.             }
623.             T source = schema.newMessage();
624.             ProtostuffIOUtil.mergeFrom(data, source, schema);
625.             return source;
626.         }
628.         @SuppressWarnings("unchecked")
629.         private static <T> Schema<T> getSchema(Class<T> clazz) {
630.             Schema<T> schema = (Schema<T>) schemaMap.get(clazz);
631.             if (schema == null) {
632.                 schema = RuntimeSchema.getSchema(clazz);
633.                 schemaMap.put(clazz, schema);
634.             }
635.             return schema;
636.         }
637.     }

复制代码

可以增加一个main方法测试
[code]public static void main(String[] args) {        //直接获取消息        System.out.println(getJsonMessage(Code.OK, "请求成功"));        //构建更加复杂的消息        System.out.println((String) newMessageBuilder()                //修改默认Code的标识                .code(Code.OK.setFlag(0))                .message("成功")                .addMsg("totalNum", 1000)                .getFinalMessage());        //对消息加密        String message = "你好世界";        String en = BASE64_ENCRYPTOR.encrypt(AES_ENCRYPTOR.encrypt(message.getBytes(), "autoJob!@#=123.?"), null);        System.out.println("加密后：" + en);        System.out.println("解密后：" + new String(AES_DECIPHER.decrypt(BASE64_DECIPHER.decrypt(en.getBytes(), null), "autoJob!@#=123.?")));        System.out.println("/*=================创建可以复用的消息发送器和接收器=================>*/");        //创建使用RSA加/解密的发送/接收器        KeyPair keyPair = RSA_ENCRYPTOR.generateKeyPair(2048);        MessageSender sender = newMessageSenderWrapper(new MessageSender())                //可以尝试使用其他序列化器                .setSerializer(PROTO_STUFF_SERIALIZER)                //可以尝试使用其他加密器                .setEncryptor(RSA_ENCRYPTOR, keyPair.getPublic(), Charset.defaultCharset(), true)                .wrap();        MessageReceiver receiver = newMessageReceiverBuilder(new MessageReceiver())                //必须和发送器序列化器对应                .setDeserializer(PROTO_STUFF_DESERIALIZER, String.class)                //必须和发送器加密器对应                .setDecipher(RSA_DECIPHER, keyPair.getPrivate(), Charset.defaultCharset(), true)                .wrap();        String msg = sender.getFinalMessage("你好世界");        System.out.println(msg);        System.out.println(receiver.getFinalMessage(msg));        System.out.println("/*=======================Finished======================*/");        //序列化        byte[] senderContent = getMessage(sender, PROTO_STUFF_SERIALIZER);        byte[] receiverContent = getMessage(receiver, PROTO_STUFF_SERIALIZER);        //反序列化        MessageSender savedSender = MessageSender.fromBytes(senderContent, PROTO_STUFF_DESERIALIZER);        MessageReceiver savedReceiver = MessageReceiver.fromBytes(receiverContent, PROTO_STUFF_DESERIALIZER);        //反序列化后发送消息        String sMsg = savedSender.getFinalMessage("你好世界");        System.out.println(sMsg);        System.out.println(savedReceiver.getFinalMessage(sMsg));        System.out.println("/*=======================Finished======================