网络编程 -- RPC实现原理 -- Netty -- 迭代版本V2 -- 对象传输

2023-07-20 23:33:58

　　啦啦啦

V2——Netty -- 使用序列化和反序列化在网络上传输对象：需要实现 java.io.Serializable 接口

　只能传输（　ByteBuf, FileRegion　）两种类型，因此必须将对象在发送之前进行序列化，放进ByteBuf中，客户端接收到ByteBuf时，将字节码取出，反序列化成对象。

　　Class ： Server

package lime.pri.limeNio.netty.netty02.exercise;

import java.net.InetSocketAddress;

import java.util.Date;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.serializer.SerializerFeature;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.buffer.ByteBuf;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelFutureListener;

import io.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelPipeline;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.util.CharsetUtil;

import lime.pri.limeNio.netty.netty03.entity.User;

public class Server {

    public static void main(String[] args) throws Exception {

        ServerBootstrap serverBootstrap = new ServerBootstrap();

        EventLoopGroup boss = new NioEventLoopGroup();

        EventLoopGroup worker = new NioEventLoopGroup();

        serverBootstrap.group(boss, worker);

        serverBootstrap.channel(NioServerSocketChannel.class);

        serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {

            @Override

            protected void initChannel(SocketChannel ch) throws Exception {

                ChannelPipeline pipeline = ch.pipeline();

                pipeline.addLast(new ChannelHandlerAdapter(){

                    @Override

                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

                        ByteBuf byteBuf = (ByteBuf) msg;

                        String request = byteBuf.toString(CharsetUtil.UTF_8);

                        System.out.println("客户端请求数据：" + request);

                        String response = JSON.toJSONString("请求参数不正确",SerializerFeature.WriteClassName);

                        if("Query Date".equalsIgnoreCase(request)){

                            response = JSON.toJSONString("当前系统时间：" + new Date().toString(),SerializerFeature.WriteClassName);

                        }else if("Query User".equalsIgnoreCase(request)){

                            response = JSON.toJSONString(new User(1,"lime",new Date()), SerializerFeature.WriteClassName);

                        }

                        byteBuf.clear();

                        byteBuf.writeBytes(response.getBytes(CharsetUtil.UTF_8));

                        ChannelFuture channelFuture = ctx.writeAndFlush(byteBuf);

                        channelFuture.addListener(ChannelFutureListener.CLOSE);

                    }

                });

            }

        });

        ChannelFuture channelFuture = serverBootstrap.bind(new InetSocketAddress(9999)).sync();

        channelFuture.channel().closeFuture().sync();

        boss.close();

        worker.close();

    }

}

　　Class ： Client

package lime.pri.limeNio.netty.netty02.exercise;

import java.net.InetSocketAddress;

import com.alibaba.fastjson.JSON;

import io.netty.bootstrap.Bootstrap;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelPipeline;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import io.netty.util.CharsetUtil;

public class Client {

    public static void main(String[] args) throws Exception {

        for (int i = 0; i < 10; i++) {

            new Thread() {

                {

                    setDaemon(false);

                }

                public void run() {

                    try {

                        client();

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                };

            }.start();

        }

    }

    private static void client() throws Exception {

        Bootstrap bootstrap = new Bootstrap();

        EventLoopGroup worker = new NioEventLoopGroup();

        bootstrap.group(worker);

        bootstrap.channel(NioSocketChannel.class);

        bootstrap.handler(new ChannelInitializer<SocketChannel>() {

            @Override

            protected void initChannel(SocketChannel ch) throws Exception {

                ChannelPipeline pipeline = ch.pipeline();

                pipeline.addLast(new ChannelHandlerAdapter() {

                    /**

                     * 默认只捕获网络连接异常

                     */

                    @Override

                    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

                        System.out.println(cause);

                    }

                    @Override

                    public void channelActive(ChannelHandlerContext ctx) throws Exception {

                        String request = null;

                        switch ((int) (Math.random() * 10) % 3) {

                        case 0:

                            request = "Query Date";

                            break;

                        case 1:

                            request = "Query User";

                            break;

                        default:

                            request = "Query What?";

                            break;

                        }

                        ctx.writeAndFlush(Unpooled.buffer().writeBytes(request.getBytes(CharsetUtil.UTF_8)));

                    }

                    @Override

                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

                        ByteBuf byteBuf = (ByteBuf) msg;

                        System.out.println("服务端响应数据 --> " + JSON.parse(byteBuf.toString(CharsetUtil.UTF_8)));

                    }

                });

            }

        });

        ChannelFuture channelFuture;

        channelFuture = bootstrap.connect(new InetSocketAddress(9999)).sync();

        channelFuture.channel().closeFuture().sync();

        worker.close();

    }

}

　　Console ： Server

客户端请求数据：Query What?

客户端请求数据：Query User

客户端请求数据：Query User

客户端请求数据：Query Date

客户端请求数据：Query Date

客户端请求数据：Query What?

客户端请求数据：Query Date

客户端请求数据：Query Date

客户端请求数据：Query User

客户端请求数据：Query User

　　Console ： Client

服务端响应数据 --> 当前系统时间：Sat Jun 24 18:21:40 CST 2017

服务端响应数据 --> 请求参数不正确

服务端响应数据 --> 当前系统时间：Sat Jun 24 18:21:40 CST 2017

服务端响应数据 --> 请求参数不正确

服务端响应数据 --> 当前系统时间：Sat Jun 24 18:21:40 CST 2017

服务端响应数据 --> 当前系统时间：Sat Jun 24 18:21:40 CST 2017

服务端响应数据 --> User [id=1, name=lime, birth=Sat Jun 24 18:21:40 CST 2017]

服务端响应数据 --> User [id=1, name=lime, birth=Sat Jun 24 18:21:40 CST 2017]

服务端响应数据 --> User [id=1, name=lime, birth=Sat Jun 24 18:21:40 CST 2017]

服务端响应数据 --> User [id=1, name=lime, birth=Sat Jun 24 18:21:40 CST 2017]

啦啦啦

码农公寓

相关文章