用上自己的线程池，实现自己的RPC框架

package github.com.AllenDuke.rpc.customer;

import github.com.AllenDuke.rpc.netty.NettyClient;
import github.com.AllenDuke.rpc.publicSource.Calculator;
import github.com.AllenDuke.rpc.publicSource.HelloService;

/**
 * @description 客户端启动类，从NettyClient处获取代理对象，发起RPC
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class ClientBootstrap {

    //netty消费者
    private static final NettyClient customer = new NettyClient();

    //自定义的消息协议为： #interfaceName#methodName#2#arg1#arg2
    //这里用了fastjson

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

        //创建代理对象
        HelloService service = (HelloService) customer.getServiceImpl(HelloService.class);
        String res = service.hello("Allen","Duke",2);
        Calculator calculator=(Calculator) customer.getServiceImpl(Calculator.class);
        calculator.add(1,2);
        calculator.multipy(3,6);
    }
}

package github.com.AllenDuke.rpc.netty;

import com.alibaba.fastjson.JSON;
import github.com.AllenDuke.concurrentTest.threadPoolTest.ThreadPoolService;
import github.com.AllenDuke.rpc.publicSource.Message;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.lang.reflect.Proxy;
import java.util.concurrent.FutureTask;

/**
 * @description netty消费者
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class NettyClient {

    //创建自己的线程池
    private static ThreadPoolService executor = new ThreadPoolService();

    public static NettyClientHandler clientHandler;

    /**
     * @description: 返回一个代理对象，其中该代理类中的InvokeHandler中的invoke方法(jdk动态代理的知识)的作用是，
     * 将调用信息封装成任务，提交到线程池，任务的返回值为 netty线程接收到的返回值
     * @param serivceClass 要实现的接口
     * @return: java.lang.Object
     * @date: 2020/2/12
     */
    public Object getServiceImpl(final Class<?> serivceClass) {
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{serivceClass}, (proxy, method, args) -> {
                    //lamda表达式，匿名内部类实现InvokeInhandler接口，重写invoke方法

                    if(method.getName().equals("toString")) {
                        return "这是代理类的toString方法,避免递归调用";
                    }
                    if(clientHandler==null) init();//懒加载
                    String className = serivceClass.getName();
                    className=className.substring(className.lastIndexOf(".")+1)+"Impl";//去掉包名

//                    //自定义消息协议
//                    String msg=className+"#"+method.getName()+"#"+args.length;
//                    for (Object arg : args) {
//                        if(arg!=null) msg+="#"+arg;
//                    }

                    //利用fastjson
                    Message message=new Message(className,method.getName(),args);
                    FutureTask<Object> task=new FutureTask<Object>(message);
                    executor.execute(task);
                    Object result=task.get();//主线程在这阻塞，等待结果
                    return JSON.parseObject((String) result,method.getReturnType());//将json文本转为对象
                });
    }

    //初始化netty客户端
    private static void init() {
        clientHandler=new NettyClientHandler();
        //创建EventLoopGroup
        NioEventLoopGroup group = new NioEventLoopGroup();
        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());//inbound编码器
                                pipeline.addLast(new StringEncoder());//outbound解码器
                                pipeline.addLast(clientHandler);//业务处理器
                            }
                        }
                );

        try {
            bootstrap.connect("127.0.0.1", 7000).sync();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package github.com.AllenDuke.rpc.netty;

import com.alibaba.fastjson.JSON;
import github.com.AllenDuke.rpc.publicSource.Message;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * @description netty消费者的业务处理器
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter{

    private ChannelHandlerContext context;

    private Object result;

    //与服务器的连接创建后，就会被调用, 这个方法是第一个被调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        this.context=ctx;
    }

    //netty线程收到消息，调用handler的chaanneltRead方法，唤醒线程池中的工作线程
    @Override
    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        result = msg;
        notify(); //唤醒等待的工作线程
    }

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

    public synchronized void sendMsg(Message message) throws InterruptedException {
        context.writeAndFlush(JSON.toJSONString(message));//netty线程发送json文本
        wait(); //工作线程阻塞wait,等待channelRead方法获取到服务器的结果后，唤醒
        System.out.println("服务端返回结果："+result);
    }

    public Object getResult(){
        return result;
    }

}

package github.com.AllenDuke.rpc.provider;

import github.com.AllenDuke.rpc.netty.NettyServer;

/**
 * @description 服务端启动类，启动netty服务提供者
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class ServerBootstrap {

    public static void main(String[] args) {

        NettyServer.startServer("127.0.0.1", 7000);
    }
}

package github.com.AllenDuke.rpc.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
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.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * @description netty服务提供者
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class NettyServer {

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

    private static void startServer0(String hostname, int port) {

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup 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());//inbound编码器
                                          pipeline.addLast(new StringEncoder());//outbound解码器
                                          pipeline.addLast(new NettyServerHandler());//业务处理器
                                      }
                                  }

                    );

            ChannelFuture channelFuture = serverBootstrap.bind(hostname, port).sync();
            System.out.println("服务提供方开始提供服务~~");
            channelFuture.channel().closeFuture().sync();//同步方法，直到有结果才往下执行
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

package github.com.AllenDuke.rpc.netty;

import com.alibaba.fastjson.JSON;
import github.com.AllenDuke.rpc.publicSource.Message;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * @description netty服务提供者的业务处理器
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    //实现类所在的包名，可把类都先加载到一个HashMap中
    private static String packageName = "github.com.AllenDuke.rpc.serviceImpl.";

    //key为实现方法的全限定名
    private static final Map<String, Method> serviceMap = new HashMap<>();

    //key为实现类的全限定名
    private static final Map<String, Class> classMap = new HashMap<>();

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发送的消息，并调用服务
        System.out.println("服务器收到信息：" + msg + " 准备解码，调用服务");
        //将json文本转换为对象
        Message message=JSON.parseObject((String) msg, Message.class);

//        //解析自定义消息协议
//        StringBuilder message = new StringBuilder(msg.toString());
//        //解析类名
//        int classIndex = message.indexOf("#");
//        String className = message.substring(0, classIndex) + "Impl";
//        message.delete(0, classIndex + 1);
//        //解析方法名
//        int methodIndex = message.indexOf("#");
//        String methodName = message.substring(0, methodIndex);
//        message.delete(0, methodIndex + 1);
//        //解析参数个数
//        int argNumIndex = message.indexOf("#");
//        int argNum=Integer.valueOf(message.substring(0,argNumIndex));
//        message.delete(0,argNumIndex+1);
//        Object[] args=new Object[argNum];
//        //解析参数，类型转换？
//        for (int i = 0; i < argNum; i++) {
//            if(i==argNum-1) args[i]=message.toString();
//            else{
//                int argIndex=message.indexOf("#");
//                args[i]=message.substring(0,argIndex);
//                message.delete(0,argIndex+1);
//            }
//        }

        String className=message.getClassName();
        String methodName=message.getMethodName();
        Object[] args=message.getArgs();
        Object result = null;//返回结果

        Class serviceImpl = classMap.get(packageName + className);
        //这里forName去寻找类，也可以一开始就把包下的类都加载进来
        if(serviceImpl==null) serviceImpl= Class.forName(packageName + className);
        //类中对应的方法
        Method service = serviceMap.get(packageName + className + "." + methodName);
        if (service == null)
            for (Method method : serviceImpl.getMethods()) {
                if (method.getName().equals(methodName)) {
                    service=method;
                    serviceMap.put(packageName + className + "." + methodName, method);//找到后加入hashMap
                    break;
                }

            }
        result = service.invoke(serviceImpl.newInstance(), args );//serviceImpl无参构造要public
        ctx.writeAndFlush(JSON.toJSONString(result));//转换为json文本
    }

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

package github.com.AllenDuke.rpc.publicSource;

import github.com.AllenDuke.rpc.netty.NettyClient;
import github.com.AllenDuke.rpc.netty.NettyClientHandler;

import java.util.concurrent.Callable;

/**
 * @description 消息体
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class Message implements Callable {

    private static NettyClientHandler handler= NettyClient.clientHandler;

    private String className;//要调用的类名
    private String methodName;//要调用的方法名
    private Object[] args;//方法的参数

    public Message(String className,String methodName,Object[] args){
        this.className=className;
        this.methodName=methodName;
        this.args=args;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Object[] getArgs() {
        return args;
    }

    public void setArgs(Object[] args) {
        this.args = args;
    }

    //封装成任务后，由线程池的工作线程调用
    public Object call() throws Exception {
        handler.sendMsg(this);
        return handler.getResult();
    }

}

package github.com.AllenDuke.rpc.publicSource;

/**
 * @description sayHello服务
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public interface HelloService {

    String hello(String name1,String name2,Integer num);
}

package github.com.AllenDuke.rpc.publicSource;

/**
 * @description 计算器服务
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public interface Calculator {

    int add(int a,int b);
    int multipy(int a,int b);
}

package github.com.AllenDuke.rpc.serviceImpl;

import github.com.AllenDuke.rpc.publicSource.Calculator;

/**
 * @description 计算器服务实现
 * @contact AllenDuke@163.com
 * @since 2020/2/11
 */
public class CalculatorImpl implements Calculator {

    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public int multipy(int a, int b) {
        return a*b;
    }
}

线程池的代码在前两篇文章中。

总结：

此次实现总体上看难度不大，但有三个点可能不容易想到。

1.动态代理，这里要站在框架使用者的角度思考，应该做到用户无感知，像是Mybatis的getMapper，还要注意invoke方法的实现。

2.一条消息也是一个任务，工作线程既是执行任务也是发送消息。将消息封装成一个任务，要从接口方法的有返回值来思考。

3.使用fastjson，一开始是自定义消息协议，然后解析，参数还要类型转换，而fastjson刚好可以做到。

当然，实现的方法有千百种，但在可以实现了的条件下，应该考虑怎样的设计看起来更合理，更容易理解，本次模拟实现肯定有很多不妥的地方，还望朋友不吝赐教，共同进步。