Netty学习——实战篇9 实现dubbo RPC 备份

 1 需求说明

        模仿dubbo，消费者和提供者约定接口和协议，消费者远程调用提供者，提供者返回一个字符串，消费者打印提供者返回的数据。底层网络通信使用 Netty 4.X

2 设计说明

        1、创建一个接口，定义抽象方法。用于消费者和提供者之间的约定。

        2、创建一个提供者，该类需要监听消费者的请求，并按照约定返回数据。

        3、创建一个消费者，该类需要透明的调用自已不存在的方法，内部需要使用Netty请求提供者返回数据。

        设计图如下：

3 编码

        目录结构如下：

public interface HelloService {
    String hello(String message);
}

@Slf4j
public class HelloServiceImpl implements HelloService {

    private int count = 0;
    //当有调用方调用该方法时，就返回一个结果
    @Override
    public String hello(String message) {
        log.info("收到客户端的消息:{}",message);
        if(message != null){
            return "你好客户端, 我已经收到你的消息 [" + message + "] 第" + (++count) + " 次";
        }else {
            return "你好客户端, 我已经收到你的消息 ";
        }
    }
}

@Slf4j
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发的消息，并调用服务
        log.info("NettyServerHandler 获取客户端的消息:{}",msg);
        //客户端在调用服务器的api 时，我们需要定义一个协议
        //比如我们要求 每次发消息是都必须以某个字符串开头 "HelloService#hello#你好"
        if(msg.toString().startsWith(NettyClientBootstrap.providerName)) {

            String result = new HelloServiceImpl().hello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
            ctx.writeAndFlush(result);
        }
    }

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

@Slf4j
public class NettyServer {

    public static void startServer(String host,int port){
        startServer0(host,port);
    }

    private static void startServer0(String host,int port){
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(host, port).sync();
            log.info("服务端已启动");
            channelFuture.channel().closeFuture().sync();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

@Slf4j
public class NettyClientHandler extends ChannelInboundHandlerAdapter implements Callable {

    //上下文
    private ChannelHandlerContext content;
    //返回结果
    private String result;
    //客户端调用时，传递的参数
    private String param;

    //与服务器的连接创建后，就会被调用, 被调用的顺序是：1
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("NettyClientHandlerd 的 channelActive 被调用");
        content = ctx;
    }

    //设置传入的参数，被调用的顺序是：2
    void setParam(String param){
        this.param = param;
    }
    //被代理对象调用, 发送数据给服务器，-> wait -> 等待被唤醒(channelRead) -> 返回结果 ；被调用的顺序是3和5
    @Override
    public synchronized  Object call() throws Exception {
        log.info("call 第一次被调用");
        content.writeAndFlush(param);
        //等待channelRead 方法获取到服务器的结果后，唤醒
        wait();
        log.info("call 第二次被调用");
        return result;
    }

    //收到服务器的数据后，调用这个方法。被调用的顺序是：4
    @Override
    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info("NettyClientHandlerd的channelRead被调用");
        result = msg.toString();
        //唤醒等待的线程
        notify();
    }

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


}

@Slf4j
public class NettyClient {
    private static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    private static NettyClientHandler client;
    private int count;

    //使用代理模式，获取代理对象
    public Object getBean(final Class<?> serviceClass,final String providerName){
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{serviceClass},(proxy,method,args) ->{
                    log.info(",(proxy,method,args) 执行...{}，次",(++count));
                    if(client == null){
                        initClient();
                    }
                    //设置要发给服务器端的信息
                    //providerName 协议头 args[0] 就是客户端调用api hello(???), 参数
                    client.setParam(providerName + args[0]);
                    return executorService.submit(client).get();
                });

    }

    //初始化客户端
    private static void initClient(){
        client = new NettyClientHandler();
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY,true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(client);
                        }
                    });
            bootstrap.connect("127.0.0.1", 8000).sync();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            group.shutdownGracefully();
        }
    }
}

public class NettyServerBootsrap {
    public static void main(String[] args) {
        NettyServer.startServer("127.0.0.1",8000);
    }
}

@Slf4j
public class NettyClientBootstrap {
    //定义协议头
    public static final String providerName = "HelloService#hello#";

    public static void main(String[] args) throws InterruptedException {
        //创建一个消费者
        NettyClient client = new NettyClient();
        //创建一个代理对象
        HelloService service = (HelloService)client.getBean(HelloService.class, providerName);
        for (; ; ) {
            Thread.sleep(2 * 1000);
            String result = service.hello("你好，dubbo");
            log.info("调用的结果，res:{}",result);
        }
    }
}