Netty 中如何实现Json类型数据的编解码处理

Netty 中如何实现Json类型数据的编解码处理

本文将详细介绍如何在 Netty 中实现 JSON 数据的编解码处理。

一、什么是 JSON 编解码？

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛用于网络通信中。在 Java 应用中，我们经常需要将 Java 对象转换为 JSON 字符串（编码），以及将 JSON 字符串还原为 Java 对象（解码）。这个过程称为 JSON 编解码。

在 Netty 中，我们可以利用其强大的编解码器机制，自定义适用于各种 Java 类型的编解码器，从而实现灵活的数据传输。

二、Netty 中的编解码机制

Netty 提供了丰富的编解码器（Encoder/Decoder）机制，可以方便地对各种类型的数据进行编解码。

为了支持 JSON 编解码，我们需要自定义两个类：GenericJsonEncoder 和 GenericJsonDecoder，用于处理任意类型的 Java 对象。

三、实现通用 JSON 编解码器

3.1 引入依赖

为了处理 JSON 数据，我们需要一个 JSON 库，例如 Jackson 或 Gson。这里我们以 Jackson 为例：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.16.1</version> 
</dependency>

3.2 定义 Java 对象（示例）

定义一个简单的 User 类作为示例对象：

public class User {
    private String name;
    private int age;
    private String email;

    // 构造函数、getter 和 setter
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

3.3 实现通用 JSON 编码器（GenericJsonEncoder）

GenericJsonEncoder 继承自 MessageToByteBufEncoder，用于将任意 Java 对象转换为 JSON 字符串并写入 ByteBuf。

import com.fasterxml.jackson.databind.ObjectMapper;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteBufEncoder;

import java.io.IOException;

/**
 * 通用 JSON 编码器，支持任意 Java 类型。
 */
public class GenericJsonEncoder<T> extends MessageToByteBufEncoder<T> {

    private final ObjectMapper objectMapper;
    private final Class<T> type;

    /**
     * 构造函数，传入目标类类型。
     *
     * @param type 要编码的目标类类型
     */
    public GenericJsonEncoder(Class<T> type) {
        this.objectMapper = new ObjectMapper();
        this.type = type;
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, T msg, ByteBuf out) throws IOException {
        String json = objectMapper.writeValueAsString(msg);
        out.writeBytes(json.getBytes());
    }
}

3.4 实现通用 JSON 解码器（GenericJsonDecoder）

GenericJsonDecoder 继承自 ByteBufToMessageDecoder，用于从 ByteBuf 中读取 JSON 字符串，并将其反序列化为任意 Java 对象。

import com.fasterxml.jackson.databind.ObjectMapper;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteBufToMessageDecoder;

import java.util.List;

/**
 * 通用 JSON 解码器
 */
public class GenericJsonDecoder<T> extends ByteBufToMessageDecoder {

    private final ObjectMapper objectMapper;
    private final Class<T> type;

    /**
     * 构造函数，传入目标类类型。
     *
     * @param type 要解码的目标类类型
     */
    public GenericJsonDecoder(Class<T> type) {
        this.objectMapper = new ObjectMapper();
        this.type = type;
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in.readableBytes() == 0) {
            return;
        }

        byte[] bytes = new byte[in.readableBytes()];
        in.readBytes(bytes);

        String json = new String(bytes);
        T obj = objectMapper.readValue(json, type);
        out.add(obj);
    }
}

四、编写 Netty 服务器和客户端

4.1 服务器端代码

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class GenericJsonServer {

    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     ChannelPipeline pipeline = ch.pipeline();
                     // 使用泛型解码器，指定 User 类型
                     pipeline.addLast(new GenericJsonDecoder<>(User.class));
                     // 使用泛型编码器，指定 User 类型
                     pipeline.addLast(new GenericJsonEncoder<>(User.class));
                     pipeline.addLast(new ServerHandler());
                 }
             });

            ChannelFuture f = b.bind(8080).sync();
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

4.2 服务器处理器（ServerHandler）

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class ServerHandler extends SimpleChannelInboundHandler<User> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, User user) {
        System.out.println("Received: " + user.getName() + ", " + user.getAge() + ", " + user.getEmail());
        ctx.writeAndFlush(user); // 回复客户端
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

4.3 客户端代码

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class GenericJsonClient {

    public static void main(String[] args) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
             .handler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     ChannelPipeline pipeline = ch.pipeline();
                     // 使用泛型解码器，指定 User 类型
                     pipeline.addLast(new GenericJsonDecoder<>(User.class));
                     // 使用泛型编码器，指定 User 类型
                     pipeline.addLast(new GenericJsonEncoder<>(User.class));
                     pipeline.addLast(new ClientHandler());
                 }
             });

            Channel ch = b.connect("localhost", 8080).sync().channel();
            User user = new User("Bob", 30, "bob@example.com");
            ch.writeAndFlush(user);
            ch.closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

4.4 客户端处理器（ClientHandler）

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class ClientHandler extends SimpleChannelInboundHandler<User> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, User user) {
        System.out.println("Response from server: " + user.getName() + ", " + user.getAge() + ", " + user.getEmail());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

五、验证过程

5.1 启动服务器

运行 GenericJsonServer 类，启动 Netty 服务器，监听端口 8080。

5.2 运行客户端

运行 GenericJsonClient 类，客户端会发送一个 User 对象到服务器。

5.3 查看输出

• 服务器控制台：

  Received: Bob, 30, bob@example.com
  

• 客户端控制台：

  Response from server: Bob, 30, bob@example.com
  

JSON 数据成功被编解码并传输。

至此，大功告成！