一站式的消息管理器

于 2023-03-28 10:50:35 发布
阅读量206 收藏 1
点赞数 2
分类专栏： java 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45060540/article/details/129811362
版权
该文章介绍了一个Java实现的一站式消息管理器，它支持JDK、ProtoStuff和JSON的序列化/反序列化，提供了AES、RSA、MD5加密和Base64编码。此外，还支持自定义序列化器、加密器和解密器，以及消息构造和流程化的发送器和接收器。示例代码展示了如何使用这些功能。
摘要由CSDN通过智能技术生成

一站式的消息管理器

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

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

首先需要引入依赖:

<dependency>
      <groupId>io.protostuff</groupId>
      <artifactId>protostuff-core</artifactId>
      <version>1.6.0</version>
</dependency>
<dependency>
      <groupId>io.protostuff</groupId>
      <artifactId>protostuff-runtime</artifactId>
      <version>1.6.0</version>
</dependency>
<dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
</dependency>

然后直接拷贝源码

import com.google.gson.*;
import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 提供一站式的消息处理
 *
 * @author JingGe(* ^ ▽ ^ *)
 * @date 2023-03-24 15:53
 * @email 1158055613@qq.com
 */
public class MessageManager {
    /*=================消息序列化/反序列化器=================>*/
    private static final Gson GSON = new GsonBuilder()
            .enableComplexMapKeySerialization()
            .setDateFormat("yyyy-MM-dd HH:mm:ss")
            .registerTypeAdapter(Class.class, new ClassCodec())
            .create();
    public static final MessageSerializer<String> JSON_SERIALIZER = GSON::toJson;
    public static final MessageDeserializer<Object> JSON_DESERIALIZER = (source, type) -> GSON.fromJson(new String(source, StandardCharsets.UTF_8), type);
    public static final MessageSerializer<byte[]> PROTO_STUFF_SERIALIZER = ProtoStuffUtil::serialize;
    public static final MessageDeserializer<Object> PROTO_STUFF_DESERIALIZER = ProtoStuffUtil::deserialize;
    public static final MessageSerializer<byte[]> JDK_SERIALIZER = source -> {
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(stream);
            outputStream.writeObject(source);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return stream.toByteArray();
    };
    public static final MessageDeserializer<Object> JDK_DESERIALIZER = (source, type) -> {
        ByteArrayInputStream stream = new ByteArrayInputStream(source);
        try {
            ObjectInputStream inputStream = new ObjectInputStream(stream);
            return (Serializable) inputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    };

    public interface MessageSerializer<T> {
        T serialize(Object source);
    }

    public interface MessageDeserializer<T> {
        T deserialize(byte[] source, Class<T> type);
    }
    /*=======================Finished======================<*/

    /*=================加密/解密器=================>*/
    public static final Encryptor<Object> NO_ENCRYPTOR = (source, key) -> source;
    public static final Decipher<Object> NO_DECIPHER = (source, key) -> source;
    public static final Encryptor<byte[]> AES_ENCRYPTOR = (source, key) -> {
        try {
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(bytes(key, Charset.defaultCharset(), "密钥只能是byte array或者String"), "AES"));
            return cipher.doFinal(source);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    };
    public static final Decipher<byte[]> AES_DECIPHER = (source, key) -> {
        try {
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(bytes(key, Charset.defaultCharset(), "密钥只能是byte array或者String"), "AES"));
            return cipher.doFinal(source);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    };
    public static final RSAEncryptor RSA_ENCRYPTOR = new RSAEncryptor();
    public static final RSADecipher RSA_DECIPHER = new RSADecipher();

    public static final MD5Encryptor MD5_ENCRYPTOR = new MD5Encryptor();

    public static final Encryptor<String> BASE64_ENCRYPTOR = (source, key) -> {
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(source);
    };
    public static final Decipher<byte[]> BASE64_DECIPHER = (source, key) -> {
        try {
            BASE64Decoder decoder = new BASE64Decoder();
            return decoder.decodeBuffer(new String(source));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    };

    public static class RSAEncryptor implements Encryptor<byte[]> {

        @Override
        public byte[] encrypt(byte[] source, Object publicKey) {
            try {
                PublicKey key = null;
                if (publicKey instanceof PublicKey) {
                    key = (PublicKey) publicKey;
                } else {
                    byte[] content = bytes(publicKey, Charset.defaultCharset(), "密钥格式异常：" + publicKey
                            .getClass()
                            .getName());
                    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(content);
                    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                    key = keyFactory.generatePublic(keySpec);
                    ;
                }
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                return cipher.doFinal(source);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

        public KeyPair generateKeyPair(int keySize) {
            try {
                keySize = keySize <= 0 ? 2048 : keySize;
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                keyPairGenerator.initialize(keySize);
                return keyPairGenerator.generateKeyPair();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }


    }

    public static class RSADecipher implements Decipher<byte[]> {
        @Override
        public byte[] decrypt(byte[] source, Object privateKey) {
            try {
                PrivateKey key = null;
                if (privateKey instanceof PrivateKey) {
                    key = (PrivateKey) privateKey;
                } else {
                    byte[] content = bytes(privateKey, Charset.defaultCharset(), "密钥格式异常：" + privateKey
                            .getClass()
                            .getName());
                    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(content);
                    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                    key = keyFactory.generatePrivate(keySpec);
                }
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.DECRYPT_MODE, key);
                return cipher.doFinal(source);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    public static class MD5Encryptor implements Encryptor<String> {
        @Override
        public String encrypt(byte[] source, Object saltKey) {
            byte[] key = bytes(saltKey, Charset.defaultCharset(), "密钥只能是String或byte array");
            byte[] content = new byte[source.length + key.length];
            System.arraycopy(source, 0, content, 0, source.length);
            System.arraycopy(key, 0, content, source.length, key.length);
            byte[] res;
            try {
                MessageDigest messageDigest = MessageDigest.getInstance("md5");
                res = messageDigest.digest(messageDigest.digest(content));
                if (res != null) {
                    StringBuilder md5code = new StringBuilder(new BigInteger(1, res).toString(16));
                    for (int i = 0; i < 32 - md5code.length(); i++) {
                        md5code.insert(0, "0");
                    }
                    return md5code.toString();
                }
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    public interface Encryptor<T> {
        T encrypt(byte[] source, Object key);
    }

    public interface Decipher<T> {
        T decrypt(byte[] source, Object key);
    }
    /*=======================Finished======================<*/

    /*=================消息格式化器=================>*/


    public interface MessageFormatter<T> {
        void format(T msg);
    }
    /*=======================Finished======================<*/

    public static MessageBuilder newMessageBuilder() {
        return new MessageBuilder();
    }

    public static <T> MessageSenderWrapper<T> newMessageSenderWrapper(MessageSender<T> sender) {
        return new MessageSenderWrapper<>(sender);
    }

    public static <T> MessageReceiverWrapper<T> newMessageReceiverBuilder(MessageReceiver<T> receiver) {
        return new MessageReceiverWrapper<>(receiver);
    }

    public static <R> R getMessage(Object msg, MessageSerializer<R> serializer) {
        return serializer.serialize(msg);
    }

    public static <R> R encryptMessage(byte[] msg, byte[] key, Encryptor<R> encryptor) {
        return encryptor.encrypt(msg, key);
    }

    public static <R> R decryptMessage(byte[] msg, byte[] key, Decipher<R> decipher) {
        return decipher.decrypt(msg, key);
    }

    public static String convert2Base64(byte[] msg) {
        return BASE64_ENCRYPTOR.encrypt(msg, null);
    }

    public static byte[] base642Bytes(String base64) {
        return BASE64_DECIPHER.decrypt(base64.getBytes(), null);
    }

    @SuppressWarnings("unchecked")
    public static <T> T fromMessage(byte[] msg, Class<T> type, MessageDeserializer<Object> deserializer) {
        return (T) deserializer.deserialize(msg, (Class<Object>) type);
    }

    public static Map<String, Object> wrapper2Map(Code code, String message, Object data) {
        Map<String, Object> msg = new HashMap<>();
        msg.put("code", code.flag);
        msg.put("message", message);
        msg.put("data", data);
        return msg;
    }

    public static String getJsonMessage(Code code, String message, Object data) {
        return getMessage(wrapper2Map(code, message, data), JSON_SERIALIZER);
    }

    public static String getJsonMessage(Code code, String message) {
        return getMessage(wrapper2Map(code, message, null), JSON_SERIALIZER);
    }

    public static byte[] getProtoStuffMessage(Code code, String message, Object data) {
        return getMessage(wrapper2Map(code, message, data), PROTO_STUFF_SERIALIZER);
    }

    public static byte[] getProtoStuffMessage(Code code, String message) {
        return getMessage(wrapper2Map(code, message, null), PROTO_STUFF_SERIALIZER);
    }

    public static byte[] getJDKMessage(Code code, String message, Object data) {
        return getMessage(wrapper2Map(code, message, data), JDK_SERIALIZER);
    }

    public static byte[] getJDKMessage(Code code, String message) {
        return getMessage(wrapper2Map(code, message, null), JDK_SERIALIZER);
    }

    public static class MessageBuilder {
        private final Map<String, Object> container = new ConcurrentHashMap<>();
        private MessageSerializer<?> serializer;

        private MessageBuilder() {
        }

        public MessageBuilder addMsg(String title, Object content) {
            container.put(title, content);
            return this;
        }

        public MessageBuilder addAllMsg(Map<String, Object> msg) {
            container.putAll(msg);
            return this;
        }

        public MessageBuilder code(Code code) {
            container.put("code", code.flag);
            return this;
        }

        public MessageBuilder message(String message) {
            container.put("message", message);
            return this;
        }

        public MessageBuilder data(Object data) {
            container.put("data", data);
            return this;
        }

        public MessageBuilder setSerializer(MessageSerializer<?> serializer) {
            this.serializer = serializer;
            return this;
        }

        public void clear() {
            container.clear();
        }

        @SuppressWarnings("unchecked")
        public <T> T getFinalMessage() {
            return (T) (serializer == null ? JSON_SERIALIZER : serializer).serialize(container);
        }
    }

    public static class MessageSender<T> implements Serializable, MessageHandler<T> {
        private final List<MessageFormatter<Object>> formatters = new ArrayList<>();
        private MessageSerializer<?> serializer;
        private Encryptor<?> encryptor;
        private Object key;
        private Charset charset;
        private boolean encode2Base64WhenEncrypted;

        public MessageSender() {
        }

        @Override
        @SuppressWarnings("unchecked")
        public T getFinalMessage(Object msg) {
            if (msg == null) {
                return null;
            }
            for (MessageFormatter<Object> formatter : formatters) {
                if (formatter != null) {
                    formatter.format(msg);
                }
            }
            Object ser = serializer == null ? msg : serializer.serialize(msg);
            byte[] content = bytes(ser, charset, "序列化后的消息只能是String或者byte array");
            if (encryptor != null) {
                if (encode2Base64WhenEncrypted) {
                    return (T) convert2Base64(bytes(encryptor.encrypt(content, key), charset, "加密后的消息只能是String或者byte array"));
                }
                return (T) encryptor.encrypt(content, key);
            }
            return (T) ser;
        }

        @SuppressWarnings("unchecked")
        public static <T> MessageSender<T> fromBytes(byte[] source, MessageDeserializer<Object> deserializer) {
            return (MessageSender<T>) fromMessage(source, MessageSender.class, deserializer);
        }
    }

    public static class MessageReceiver<T> implements Serializable, MessageHandler<T> {
        private final List<MessageFormatter<Object>> formatters = new ArrayList<>();
        private MessageDeserializer<Object> deserializer;
        private Decipher<?> decipher;
        private Class<T> type;
        private Object key;
        private Charset charset;
        private boolean decode2Base64BeforeDecrypt;

        public MessageReceiver() {
        }

        @Override
        @SuppressWarnings("unchecked")
        public T getFinalMessage(Object msg) {
            byte[] content = null;
            if (decode2Base64BeforeDecrypt) {
                if (msg instanceof String) {
                    content = base642Bytes((String) msg);
                } else {
                    throw new UnsupportedOperationException("消息不是String类型，无法进行Base64解码");
                }
            }
            Object des = content == null ? msg : content;
            if (decipher != null) {
                des = decipher.decrypt(content == null ? bytes(msg, charset, "如果消息需要解密，则消息必须是byte array") : content, key);
            }
            T ser = (T) des;
            if (deserializer != null) {
                ser = (T) deserializer.deserialize(bytes(des, charset, "解密后的结果必须是String或者byte array"), (Class<Object>) type);
            }
            for (MessageFormatter<Object> formatter : formatters) {
                if (formatter != null) {
                    formatter.format(ser);
                }
            }
            return (T) ser;
        }

        @SuppressWarnings("unchecked")
        public static <T> MessageReceiver<T> fromBytes(byte[] source, MessageDeserializer<Object> deserializer) {
            return (MessageReceiver<T>) fromMessage(source, MessageReceiver.class, deserializer);
        }
    }

    public interface MessageHandler<T> {
        T getFinalMessage(Object msg);
    }

    private static byte[] bytes(Object src, Charset charset, String errorMsg) {
        if (src instanceof byte[]) {
            return (byte[]) src;
        } else if (src instanceof String) {
            return charset == null ? ((String) src).getBytes() : ((String) src).getBytes(charset);
        }
        throw new UnsupportedOperationException(errorMsg);
    }

    public static class MessageSenderWrapper<T> {
        private final MessageSender<T> sender;

        private MessageSenderWrapper(MessageSender<T> sender) {
            this.sender = sender;
        }

        public MessageSenderWrapper<T> addFormatter(MessageFormatter<Object> formatter) {
            sender.formatters.add(formatter);
            return this;
        }

        public MessageSenderWrapper<T> setSerializer(MessageSerializer<?> serializer) {
            sender.serializer = serializer;
            return this;
        }

        public MessageSenderWrapper<T> setEncryptor(Encryptor<?> encryptor, Object key, Charset charset, boolean encode2Base64) {
            if (encryptor == null || key == null) {
                throw new IllegalArgumentException("加密器和密钥不能为空");
            }
            sender.encryptor = encryptor;
            sender.key = key;
            sender.charset = charset;
            sender.encode2Base64WhenEncrypted = encode2Base64;
            return this;
        }

        public MessageSender<T> wrap() {
            return sender;
        }
    }

    public static class MessageReceiverWrapper<T> {
        private final MessageReceiver<T> receiver;

        public MessageReceiverWrapper(MessageReceiver<T> receiver) {
            this.receiver = receiver;
        }

        public MessageReceiverWrapper<T> addFormatter(MessageFormatter<Object> formatter) {
            receiver.formatters.add(formatter);
            return this;
        }

        public MessageReceiverWrapper<T> setDeserializer(MessageDeserializer<Object> deserializer, Class<T> type) {
            receiver.deserializer = deserializer;
            receiver.type = type;
            return this;
        }

        public MessageReceiverWrapper<T> setDecipher(Decipher<?> decipher, Object key, Charset charset, boolean decodeBase642ByteArray) {
            if (decipher == null || key == null) {
                throw new IllegalArgumentException("解密器和密钥不能为空");
            }
            receiver.decipher = decipher;
            receiver.key = key;
            receiver.charset = charset;
            receiver.decode2Base64BeforeDecrypt = decodeBase642ByteArray;
            return this;
        }

        public MessageReceiver<T> wrap() {
            return receiver;
        }
    }

    /**
     * 状态枚举，支持枚举标识修改
     *
     * @author Huang Yongxiang
     * @date 2021/9/30 9:25
     */
    public enum Code {
        /**
         * 请求成功
         */
        OK("success", 200),
        /**
         * 服务器内部错误
         */
        ERROR("error", 500),
        /**
         * 客户端请求的语法错误，服务器无法理解
         */
        BAD_REQUEST("bad request", 400),
        /**
         * 服务器理解请求客户端的请求，但是拒绝执行此请求
         */
        FORBIDDEN("Forbidden", 403),
        /**
         * 超时
         */
        TIME_OUT("time out", 408),
        /**
         * 服务器无法根据客户端请求的内容特性完成请求
         */
        NOT_ACCEPTABLE("Not Acceptable", 406),
        /**
         * 服务器不支持请求的功能，无法完成请求
         */
        NOT_SUPPORT("Not Implemented", 501),
        /**
         * 已接受。已经接受请求，但未处理完成
         */
        ACCEPTED("Accepted", 202);
        private String message;
        private Integer flag;

        Code(String message, Integer flag) {
            this.message = message;
            this.flag = flag;
        }

        public String getMessage() {
            return message;
        }

        public Code setMessage(String message) {
            this.message = message;
            return this;
        }

        public Integer getFlag() {
            return flag;
        }

        public Code setFlag(Integer flag) {
            this.flag = flag;
            return this;
        }

        @Override
        public String toString() {
            return "Code{" + "message='" + message + '\'' + ", flag=" + flag + '}';
        }
    }

    private static class ClassCodec implements JsonSerializer<Class<?>>, JsonDeserializer<Class<?>> {
        @Override
        public Class<?> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
            try {
                String str = json.getAsString();
                return Class.forName(str);
            } catch (ClassNotFoundException e) {
                throw new JsonParseException(e);
            }
        }

        @Override
        public JsonElement serialize(Class<?> src, Type typeOfSrc, JsonSerializationContext context) {
            return new JsonPrimitive(src.getName());
        }
    }

    private static class ProtoStuffUtil {
        private static final ThreadLocal<LinkedBuffer> threadSafeBuffer = new ThreadLocal<>();
        private static final Map<Class<?>, Schema<?>> schemaMap = new ConcurrentHashMap<>();

        @SuppressWarnings("unchecked")
        public static <T> byte[] serialize(T source) {
            if (source == null) {
                return null;
            }
            Class<T> clazz = (Class<T>) source.getClass();
            Schema<T> schema = getSchema(clazz);
            if (schema == null) {
                throw new NullPointerException("无法获取" + clazz + "的模式");
            }
            try {
                if (threadSafeBuffer.get() == null) {
                    threadSafeBuffer.set(LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
                }
                return ProtostuffIOUtil.toByteArray(source, schema, threadSafeBuffer.get());
            } finally {
                threadSafeBuffer
                        .get()
                        .clear();
            }
        }

        public static <T> T deserialize(byte[] data, Class<T> type) {
            if (data == null || data.length == 0) {
                return null;
            }
            Schema<T> schema = getSchema(type);
            if (schema == null) {
                throw new NullPointerException("无法获取" + type + "的模式");
            }
            T source = schema.newMessage();
            ProtostuffIOUtil.mergeFrom(data, source, schema);
            return source;
        }

        @SuppressWarnings("unchecked")
        private static <T> Schema<T> getSchema(Class<T> clazz) {
            Schema<T> schema = (Schema<T>) schemaMap.get(clazz);
            if (schema == null) {
                schema = RuntimeSchema.getSchema(clazz);
                schemaMap.put(clazz, schema);
            }
            return schema;
        }
    }

可以增加一个main方法测试

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<String> sender = newMessageSenderWrapper(new MessageSender<String>())
                //可以尝试使用其他序列化器
                .setSerializer(PROTO_STUFF_SERIALIZER)
                //可以尝试使用其他加密器
                .setEncryptor(RSA_ENCRYPTOR, keyPair.getPublic(), Charset.defaultCharset(), true)
                .wrap();


        MessageReceiver<String> receiver = newMessageReceiverBuilder(new MessageReceiver<String>())
                //必须和发送器序列化器对应
                .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======================<*/");

        System.out.println("/*=================对发送器/接收器进行序列化保存=================>*/");
        //序列化
        byte[] senderContent = getMessage(sender, PROTO_STUFF_SERIALIZER);
        byte[] receiverContent = getMessage(receiver, PROTO_STUFF_SERIALIZER);

        //反序列化
        MessageSender<String> savedSender = MessageSender.fromBytes(senderContent, PROTO_STUFF_DESERIALIZER);

        MessageReceiver<String> 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======================<*/");
    }
}

{"code":200,"message":"请求成功"}
{"code":0,"totalNum":1000,"message":"成功"}
加密后：PXDEasQsDfG4Ca0WLdO4Sg==
解密后：你好世界
/*=================创建可以复用的消息发送器和接收器=================>*/
YeKSWWdYPu4BK9gAehP5cYLhBcRPaGFN4qlC8mtieRCSNjBuqj9uLb2B4ca/FmYGOxHTYgikUZ2w
/ANc04Vrgz3isKF9VuA03hiW1oWpP3yIIROSji+ribhc6U0ihhelpqimrTQaaVi3mZ8AqrdPKGmM
KSrc/DaHZq/xMzCm1jlucPixm5Nss8Qk9u0lZltKzx8X6vjhaWmLonF7RXL76fiIq6dA45C6JbEG
33R87VMO0xYwIWenvPfwrELrJ/1fqoWFZIBCJWmrqIkulNW7REZqSkFd2pVwF+NH9abN5HH/QOl0
Y3kwRuazZtydkchw0s80WyP1CZ9lC/RK5HKQpQ==
你好世界
/*=======================Finished======================<*/
/*=================对发送器/接收器进行序列化保存=================>*/
lDUZdBYoU86AKilWY1ZdQR9SS/ud1xxnKyUDaKgoMRFLEQqEd2lnD7LDROSfqRNSGwG8ubQ37Db+
2FjiCYsZMoU9B41m5nhm96lu5sWJrhhVLN7zvjdW5G3i6xWuzQrI9S3RiXUCK2zYBh9r2CIm9iAM
mQ9VMZJKYewjKDJYta+hKGcKVg7/lJnX+lu8EmXLuKeCKymXycXHY3VMeURJZQrgLsz9qrQYw/4u
l1nREc2LsL9/TVP3un98XpjUJxTkeyYJ74iLti5FPP3WD+ObR3OTzEZ/9sZndTEKZYFOYlanqavR
hotfSDDTah108C9gNsnnxYUnUasNqF3xOgMETw==
你好世界
/*=======================Finished======================<*/

Process finished with exit code 0

如果对你有帮助，谢谢点赞、收藏、Star

鲸歌
关注
专栏目录
一个监听器模式的消息管理器实现
dadalan的专栏
10-22 3752
消息管理器是用来在各个实体对象和功能模块之间进行数据通信的.一个好的消息管理器可以最大限度的实现解藕操作,使得模块具有"热插拔"特性,这是我们所希望达到效果.但是在实现的过程中有几点细节实现需要仔细斟酌,比如消息管理与分发的方式,如何实现一个通用的支持动态更新的消息管理器.下面是我学习根据自身经验实现的一个消息管理器,希望能够抛砖引玉,共同提高 :) 基本思路: 1. 面向接口编程: 实现一个IMsgListener抽象接口类,所有需要消息处理的类都需要从该接口类
java序列化工具 protoStuff的使用
lucky_ly的博客
12-27 4340
1.前言 在互联网快速发展的今天，互联网架构也在不断的升级。而数据的传输和存贮是互联网系统中不可或缺的一部分。举个简单的例子，目前微服务已经很普及了，就拿dubbo来说，不管用jdk自带的序列化，还是dubbo的序列化，效果都不尽然人意。市面上高性能的序列化工具也有例如kryo,pb。但是kryo虽然序列化出来的体积小，传输快，但是不支持前后兼容。（例如序列化前和序列化后，对象的字段必须是一样的，不能多也不能少，否则就会报错），pb整体都不错，体积小，传输快，前后兼容。 但是要自己编写pb文件，使用门槛高。
简易消息管理器EventCenter
张大满的博客
09-20 2583
/* * 日期：2017年7月4日 * 功能说明：消息中心，添加侦听，移除侦听，消息分发 * */ using System; using System.Collections; using System.Collections.Generic; using UnityEngine; namespace BOFramework { /// ///
android 消息管理器,腾讯TIM消息管理器在哪 腾讯TIM打开消息管理器的教程
weixin_31773159的博客
05-26 957
腾讯TIM最新简介tim最新版主要是在“日程”方面进行了改进，比如在聊天界面点击日程时，可以新建日程和分享我的日程、日程界面支持周视图展示等。另外，更新还精简代码，缩减安装包大小，屏蔽了送礼物等功能和动画。腾讯TIM和腾讯QQ的区别区别主要有以下两点：TIM，轻聊的QQ，办公更方便。还支持高效的多人协作文档，可以在线编辑Word、Excel文档。支持免费的音频、视频通话。也继承了QQ的超快传文件体...
Java序列化框架的比较（JDK、FastJson、Hessian、Hessian2、Protostuff）
张井天的博客
03-23 1799
概念： 序列化：将Java对象转化为字节数组 反序列化：将字节数组转化为Ｊava对象 在RPC应用中，进行跨进程远程调用的时候，需要使用特定的序列化技术，需要对进行网络传输的对象进行序列化和反序列化。 影响序列化选择有两个因素： 序列化之后码流的大小，如果太大，那么将会影响网络传输的性能。 序列化和反序列化过程的性能 常用的序列化框架性能比较 序列化框架对比测试： JDK FastJson Hessian Hessian2 Protostuff 准备 需要序列化的对象，这是一个复杂的对象。 Net
一站式智慧校园移动平台.pdf
06-16
"一站式智慧校园移动平台"是锐捷网络推出的一款专门针对高等教育机构的综合移动服务解决方案，旨在打造一个统一、便捷的校园信息化环境。该平台的核心是微哨APP，它集成了微哨、微信企业号、QQ校园号和PC版等多个...
微信小程序源码-腾讯云小程序一站式解决方案.zip
04-20
在这个“微信小程序源码-腾讯云小程序一站式解决方案.zip”压缩包中，包含了腾讯云提供的小程序开发所需的一整套资源和模板代码，旨在帮助开发者快速构建自己的小程序。 首先，我们要理解什么是微信小程序。它是一...
腾讯云微信小程序一站式解决方案客户端示例
12-20
腾讯云微信小程序一站式解决方案客户端示例是一套完整的开发工具包，旨在帮助开发者高效地构建和部署微信小程序。这个解决方案融合了腾讯云的强大云计算能力与微信小程序的便捷用户体验，为开发者提供了一个从开发到...
完结26章国家级认证 信息系统项目管理师(软高）一站式通关课程
最新发布
03-15
信息系统项目管理师是属于计算机技术与软件专业技术资格（水平）考试（即软考）高级资格考试里面的一项考试。通过该考试的合格人员能够掌握信息系统项目管理的知识体系，具备管理大型、复杂信息系统项目和多项目的...
论文研究-一站式行政审批系统研究与设计.pdf
07-22
本文标题为《论文研究-一站式行政审批系统研究与设计》，所涉及的主要知识点集中在电子政务领域，特别是行政审批领域中的重要组成部分——一站式行政审批系统。文章首先提出了该系统的总体体系结构，随后详细研究并...
protostuff-所依赖所有jar包.
11-27
protostuff-所依赖所有jar包.
netty结合Protostuff传输对象案例，单机压测秒级接收35万个对象
tianyaleixiaowu的专栏
07-31 2429
单纯netty结合protostuff进行rpc对象传输的demo网上有很多，大部分都是一个模子刻出来的，一开始我也是抄了一个，本地测试畅通无阻，未发生任何异常。部署预发环境，进行压测后，问题巨多，各种报错层出不穷。当然，压测时我用的数据量大、发送请求非常密集，单机是每秒前100ms发送2万个对象，其他900ms歇息，死循环发送，共计40台机器作为客户端，同时往2台netty Server服务器发送对象，那么平均每个server每秒大概要接收40万个对象，由于后面还有业务逻辑，逻辑每秒只能处理35万实测。
Protostuff序列化和反序列化使用说明
热门推荐
zhglance的专栏
02-20 2万+
google原生的protobuffer使用起来相当麻烦，首先要写.proto文件，然后编译.proto文件，生成对应的.java文件，鄙人试了一次，发现真的很麻烦。而protostuff的官方网站(http://www.protostuff.io/documentation/runtime-schema/)，对于智商比较低的小编来说也略显生涩，于是鄙人就根据项目中用到的protostuff，撰写此文，以方便自己和他人加深印象和学习。
Protostuff 序列化工具类
zhouzhiwengang的专栏
06-18 1412
Protostuff 简介 Protostuff是一个序列化库，支持一下序列化格式： protobuf protostuff(本地) graph json smile xml yaml kvp pom.xml 文件添加protostuff 序列化包依赖 <!--引入protostuff依赖--> <dependency> ...
String和StringBuffer、ArrayList和LinkedList、HashMap和HashTable的特点及区别。
Over_wang的博客
06-05 1861
String和StringBuffer、ArrayList和LinkedList、HashMap和HashTable的特点及区别。   String 对象的长度一旦定义就固定就不可以改变，对于已经存在的String对象的修改都是创建一个新的对象，然后把新的值存进去,String类不能被继承。StringBuffer是一个可变对象，当对它进行修改的时候不会像String那样重新建立对象。它只能通
简单的使用protobuf和protostuff
眼前一座山，踏平它
12-20 1万+
在我们的开发过程中，序列化是经常需要处理的问题，比如在做分布式访问数据时，或者是在做redis缓存存储数据时，如果我们涉及的知识面不够广的话，可能会简单的使用JDK的序列化，也即在需要序列化的类上implements Serializable接口去实现序列化，我想说的是这种方式在小系统中尚且可以用一用，如果是并发很大的系统会受到严重影响，这是由于JDK自带的序列化效率很低，不论是时间上还是空间上。
Protostuff序列化分析
xiaomin1991222的专栏
08-05 470
前言最近项目中需要将业务对象直接序列化，然后存数据库；考虑到序列化、反序列化的时间以及生产文件的大小觉得Protobuf是一个很好的选择，但是Protobuf有的问题就是需要有一个.proto的描述文件，而且由Protobuf生成的对象用来作为业务对象并不是特别友好，往往业务对象和Protobuf对象存在一个互相转换的过程；考虑到我们仅仅是将业务对象直接序列化到数据库，发现Protobuf在这...
即时响应场景下java序列化框架的性能测试
不动明王1984的博客
01-05 886
简介 序列化就是将对象转化为字节序列的过程，反序列化则是将字节序列转化为对象的过程。序列化框架广泛的应用在分布式系统通信、存储等相关场景中。例如在网络通信中， 不同的计算机进行相互通信主要的方式就是将数据流从一台机器传输给另外一台计算机，当客户端将需要请求的数据封装好了之后就需要进行转换为二进制格式再转换 为流进行传输，当服务端接收到流之后再将数据解析为二进制格式的内容，再按照约定好的协议进行处理解析。最常见的场景就是rpc远程调用的时候，对发送数据和 接收数据时候的处理。常见的序列化和反序列化方式
hive删除分区部分数据
大数据同盟会的博客
02-25 1万+
insert overwrite table t_finance_tax_bill partition (importdate='20220218') select bill_id , apply_emp_id , bill_type_name , apply_emp_name , reimbursement_name , bill_apply_date
一站式数据库管理解决方案
- Redis：是一种支持键值存储、具有高性能和灵活数据结构的数据结构服务器，常用于缓存和消息队列。 3. 单一工具管理多数据库的优势： - 统一界面：用户可以在一个界面内管理和操作不同的数据库，无需切换多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值