socket客户端A发送报文给Socket服务端B，服务端B将报文转发给Socket服务端C，服务端C回复报文给B，B再将报文回复给A，A和C之间没有直连，只能通过B做中转，A、B、C使用netty实现的代码

在Netty框架中，你可以使用事件驱动的方式实现这样的多层代理通信。首先，我们需要创建三个Netty服务器（A、B 和 C），每个服务器都有各自的ServerBootstrap实例。

对于客户端A:

public class Client {
    private EventLoopGroup group = new NioEventLoopGroup();
    private Channel channel;

    public void connectToProxy(ServerAddress address) throws Exception {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
            .channel(NioSocketChannel.class)
            // 设置连接地址
            .handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new TextLineHandler(B.getPipeline()));
                }
            });
        
        channel = bootstrap.connect(address).sync().channel();
        // 发送数据到B
        String message = "Message to be forwarded";
        channel.writeAndFlush(message);
    }

    public static void main(String[] args) {
        try (Client client = new Client()) {
            client.connectToProxy(B.getAddress());
        } finally {
            group.shutdownGracefully();
        }
    }
}

这里，`TextLineHandler`是一个自定义处理器，它会接收到B的服务端的数据并转发给C。

服务端B:

public class ServerB extends SimpleServerBootstrap {
    public final static ServerAddress ADDRESS = new InetSocketAddress(8081);

    @Override
    protected void initialize() throws Exception {
        pipeline().addLast(new ForwardingHandler(C.getAddress()));
    }
}

class ForwardingHandler extends ChannelInboundHandlerAdapter {
    private final Address target;

    public ForwardingHandler(Address target) {
        this.target = target;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ctx.writeAndFlush(msg, target);
    }
}

服务端C类似地设置：

public class ServerC extends SimpleServerBootstrap {
    public final static ServerAddress ADDRESS = new InetSocketAddress(8082);

    @Override
    protected void initialize() throws Exception {
        pipeline().addLast(new LoggingHandler()); // 自定义日志处理器
    }
}

当A向B发送消息后，B将消息转发给C，然后C处理完后返回消息给B，B再将回复转发回A。注意，这里假设了网络环境允许B作为中介，并且A和C之间的通信不会直接进行，因为它们没有直连。