Netty 编解码器-蒲公英云

Netty 编解码器

梦里梦外; 2022-11-05 06:24 324阅读 0赞

Netty 编解码

在网络中数据是以字节码二进制的形式传输的，所以我们在使用 Netty 传输数据的时候，需要将我们传输的数据转换为 二进制的形式 进行传输，所以不管是我们要传输字符串，还是对象，都需要将其序列化成二进制的形式。而使用编解码器可以省去我们每次传输数据手动进行编码和解码的步骤。

编解码器

编解码器同样也属于 ChannelHandler 的一员，编码器继承实现 ChannelOutboundHandler，解码器继承实现 ChannelInboundHandler 其关键作用就是省去我们自行手动转换二进制字节流的过程。处理出站 tail -> head 最后编码，处理入站 head->tail 需要先解码，所以在 pipline 中需要先 add 编解码器后再添加你需要处理业务逻辑的 handler ，。

Netty 提供的编解码器：
编解码字符串 StringEncoder 和 StringDecoder
编解码对象 ObjectEncoder 和 ObjectDecoder

在实际开发中为了实现更加高效的编解码我们会选择使用 protobuf 是由谷歌开发出品的一种数据传输格式。
但是 protobuf 需要维护大量的 proto 文件比较麻烦，推荐可以使用 protostuff。
protostuff 是一个基于 protobuf 实现的序列化方法，它较于 protobuf 最明显的好处是，在几乎不损耗性能的情况下做到了不用我们写 .proto 文件来实现序列化。

使用前先引入 maven 依赖

<dependency>
    <groupId>com.dyuproject.protostuff</groupId>
    <artifactId>protostuff-api</artifactId>
    <version>1.0.10</version>
</dependency>
<dependency>
    <groupId>com.dyuproject.protostuff</groupId>
    <artifactId>protostuff-core</artifactId>
    <version>1.0.10</version>
</dependency>
<dependency>
    <groupId>com.dyuproject.protostuff</groupId>
    <artifactId>protostuff-runtime</artifactId>
    <version>1.0.10</version>
</dependency>
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/** * protostuff 序列化工具类，基于protobuf封装 */
public class ProtostuffUtil { 
    private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();
    private static <T> Schema<T> getSchema(Class<T> clazz) { 
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>) cachedSchema.get(clazz);
        if (schema == null) { 
            schema = RuntimeSchema.getSchema(clazz);
            if (schema != null) { 
                cachedSchema.put(clazz, schema);
            }
        }
        return schema;
    }
    /** * 序列化 * * @param obj * @return */
    public static <T> byte[] serializer(T obj) { 
        @SuppressWarnings("unchecked")
        Class<T> clazz = (Class<T>) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try { 
            Schema<T> schema = getSchema(clazz);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } catch (Exception e) { 
            throw new IllegalStateException(e.getMessage(), e);
        } finally { 
            buffer.clear();
        }
    }
    /** * 反序列化 * * @param data * @param clazz * @return */
    public static <T> T deserializer(byte[] data, Class<T> clazz) { 
        try { 
            T obj = clazz.newInstance();
            Schema<T> schema = getSchema(clazz);
            ProtostuffIOUtil.mergeFrom(data, obj, schema);
            return obj;
        } catch (Exception e) { 
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
    public static void main(String[] args) { 
        byte[] userBytes = ProtostuffUtil.serializer(new User(1998, "dyingGQ"));
        User user = ProtostuffUtil.deserializer(userBytes, User.class);
        System.out.println(user);
    }
}