RPC又称远程过程调用，我们所知的远程调用分为两种，现在在服务间通信的方式也太多已这两种为主

1.是基于HTTP的restful形式的广义远程调用，以springboot的feign和restTemplate为代表，由于采用的协议是HTTP的7层调用协议，并且协议的参数和响应序列化基本以JSON格式和XML格式为主。

2.是基于TCP的狭义的RPC远程调用，以阿里的Dubbo为代表，主要通过netty来实现4层网络协议，NIO来异步传输，序列化也可以是JSON或者hessian2以及ava自带的序列化等，可以配置。

接下来我们主要以第二种的RPC远程调用来自己实现

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

开始

创建一个公共的接口项目和类以及方法，用于消费者和提供者之间的约定。
创建一个提供者，该类需要监听消费者的请求，并按照约定返回数据。
创建一个消费者，该类需要透明的调用自己不存在的方法，内部需要使用 Netty 请求提供者返回数据。

项目

结构如图所示：start_rpc_consumer和start_rpc_provider都引入了

1    <dependencies>
2        <dependency>
3            <groupId>io.netty</groupId>
4            <artifactId>netty-all</artifactId>
5            <version>4.1.16.Final</version>
6        </dependency>
7
8        <dependency>
9            <groupId>cn.chinotan</groupId>
10            <artifactId>start_interface</artifactId>
11            <version>1.0.0</version>
12        </dependency>
13    </dependencies>

这样提供者来实现接口并且提供网络调用，消费者直接通过接口来进行TCP通信及一定的协议定制获取提供者的实现返回值

接口的定义

1package cn.chinotan;
2
3/**
4 * @program: test
5 * @description: 用户相关接口
6 * @author: xingcheng
7 * @create: 2018-12-29 19:50
8 **/
9public interface UserService {
10
11    /**
12     * 礼貌用语
13     * @param word
14     * @return
15     */
16    String sayHello(String word);
17    
18}
19

只是一个普通的接口，参数是支持序列化的String类型，返回值同理

提供者的实现

首先是接口的实现，这一点和普通接口实现是一样的

1package cn.chinotan;
2
3import io.netty.bootstrap.ServerBootstrap;
4import io.netty.channel.ChannelInitializer;
5import io.netty.channel.ChannelPipeline;
6import io.netty.channel.nio.NioEventLoopGroup;
7import io.netty.channel.socket.SocketChannel;
8import io.netty.channel.socket.nio.NioServerSocketChannel;
9import io.netty.handler.codec.string.StringDecoder;
10import io.netty.handler.codec.string.StringEncoder;
11
12/**
13 * @program: test
14 * @description: 用户相关接口实现
15 * @author: xingcheng
16 * @create: 2018-12-30 19:34
17 **/
18public class UserServiceImpl implements UserService {
19
20    @Override
21    public String sayHello(String word) {
22        System.out.println("调用成功--参数：" + word);
23        return "调用成功--参数：" + word;
24    }
25
26    public static void startServer(String hostName, int port) {
27        try {
28            ServerBootstrap bootstrap = new ServerBootstrap();
29            NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup();
30            bootstrap.group(eventLoopGroup)
31                    .channel(NioServerSocketChannel.class)
32                    .childHandler(new ChannelInitializer<SocketChannel>() {
33                        @Override
34                        protected void initChannel(SocketChannel ch) throws Exception {
35                            ChannelPipeline p = ch.pipeline();
36                            p.addLast(new StringDecoder());
37                            p.addLast(new StringEncoder());
38                            p.addLast(new UserServerHandler());
39                        }
40                    });
41            bootstrap.bind(hostName, port).sync();
42        } catch (InterruptedException e) {
43            e.printStackTrace();
44        }
45    }
46}
47

我们在实现中加入了netty的服务器启动程序，上面的代码中添加了 String类型的编解码 handler，添加了一个自定义 handler。

自定义 handler 逻辑如下：

1package cn.chinotan;
2
3import io.netty.channel.ChannelHandlerContext;
4import io.netty.channel.ChannelInboundHandlerAdapter;
5
6/**
7 * @program: test
8 * @description: 自定义 handler 逻辑
9 * @author: xingcheng
10 * @create: 2018-12-30 19:45
11 **/
12public class UserServerHandler extends ChannelInboundHandlerAdapter {
13
14    @Override
15    public void channelRead(ChannelHandlerContext ctx, Object msg) {
16        // 如何符合约定，则调用本地方法，返回数据
17        if (msg.toString().startsWith("UserService")) {
18            String result = new UserServiceImpl()
19                    .sayHello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
20            ctx.writeAndFlush(result);
21        }
22    }
23    
24}
25

这里显示判断了是否符合约定（并没有使用复杂的协议，只是一个字符串判断），然后创建一个具体实现类，并调用方法写回客户端。

还需要一个启动类：

1package cn.chinotan;
2
3/**
4 * @program: test
5 * @description: 启动类
6 * @author: xingcheng
7 * @create: 2018-12-30 19:52
8 **/
9public class ServerBootstrap {
10
11    public static void main(String[] args) {
12        UserServiceImpl.startServer("localhost", 8990);
13    }
14    
15}
16

关于提供者的代码就写完了，主要就是创建一个 netty 服务端，实现一个自定义的 handler，自定义 handler 判断是否符合之间的约定（协议），如果符合，就创建一个接口的实现类，并调用他的方法返回字符串。

消费者相关实现

消费者有一个需要注意的地方，就是调用需要透明，也就是说，框架使用者不用关心底层的网络实现。这里我们可以使用 JDK 的动态代理来实现这个目的。

思路：客户端调用代理方法，返回一个实现了 HelloService 接口的代理对象，调用代理对象的方法，返回结果。

我们需要在代理中做手脚，当调用代理方法的时候，我们需要初始化 Netty 客户端，还需要向服务端请求数据，并返回数据。

首先创建代理相关的类：

1package cn.chinotan;
2
3import io.netty.bootstrap.Bootstrap;
4import io.netty.channel.ChannelInitializer;
5import io.netty.channel.ChannelOption;
6import io.netty.channel.ChannelPipeline;
7import io.netty.channel.EventLoopGroup;
8import io.netty.channel.nio.NioEventLoopGroup;
9import io.netty.channel.socket.SocketChannel;
10import io.netty.channel.socket.nio.NioSocketChannel;
11import io.netty.handler.codec.string.StringDecoder;
12import io.netty.handler.codec.string.StringEncoder;
13
14import java.lang.reflect.Proxy;
15import java.util.concurrent.ExecutorService;
16import java.util.concurrent.Executors;
17
18/**
19 * @program: test
20 * @description: 创建代理相关的类
21 * @author: xingcheng
22 * @create: 2018-12-30 19:57
23 **/
24public class RpcConsumer {
25
26    private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
27
28    private static UserClientHandler client;
29
30    /**
31     * 创建一个代理对象
32     */
33    public Object createProxy(final Class<?> serviceClass, final String providerName) {
34        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
35                new Class<?>[]{serviceClass}, (proxy, method, args) -> {
36                    if (client == null) {
37                        initClient();
38                    }
39                    // 设置参数
40                    client.setPara(providerName + args[0]);
41                    return executor.submit(client).get();
42                });
43    }
44
45    /**
46     * 初始化客户端
47     */
48    private static void initClient() {
49        client = new UserClientHandler();
50        EventLoopGroup group = new NioEventLoopGroup();
51        Bootstrap b = new Bootstrap();
52        b.group(group)
53                .channel(NioSocketChannel.class)
54                .option(ChannelOption.TCP_NODELAY, true)
55                .handler(new ChannelInitializer<SocketChannel>() {
56                    @Override
57                    public void initChannel(SocketChannel ch) throws Exception {
58                        ChannelPipeline p = ch.pipeline();
59                        p.addLast(new StringDecoder());
60                        p.addLast(new StringEncoder());
61                        p.addLast(client);
62                    }
63                });
64        try {
65            b.connect("localhost", 8990).sync();
66        } catch (InterruptedException e) {
67            e.printStackTrace();
68        }
69    }
70}
71

该类有 2 个方法，创建代理和初始化客户端。

初始化客户端逻辑：创建一个 Netty 的客户端，并连接提供者，并设置一个自定义 handler，和一些 String 类型的序列化方式。

创建代理逻辑：使用 JDK 的动态代理技术，代理对象中的 invoke 方法实现如下：
如果 client 没有初始化，则初始化 client，这个 client 既是 handler ，也是一个 Callback。将参数设置进 client ，使用线程池调用 client 的 call 方法并阻塞等待数据返回。

看看 UserClientHandler 的实现：

1package cn.chinotan;
2
3import io.netty.channel.ChannelHandlerContext;
4import io.netty.channel.ChannelInboundHandlerAdapter;
5
6import java.util.concurrent.Callable;
7
8/**
9 * @program: test
10 * @description:
11 * @author: xingcheng
12 * @create: 2018-12-30 19:59
13 **/
14public class UserClientHandler extends ChannelInboundHandlerAdapter implements Callable {
15
16    private ChannelHandlerContext context;
17    private String result;
18    private String para;
19
20    @Override
21    public void channelActive(ChannelHandlerContext ctx) {
22        context = ctx;
23    }
24
25    /**
26     * 收到服务端数据，唤醒等待线程
27     */
28    @Override
29    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) {
30        result = msg.toString();
31        notify();
32    }
33
34    /**
35     * 写出数据，开始等待唤醒
36     */
37    @Override
38    public synchronized Object call() throws InterruptedException {
39        context.writeAndFlush(para);
40        wait();
41        return result;
42    }
43
44    void setPara(String para) {
45        this.para = para;
46    }
47
48}
49

该类缓存了 ChannelHandlerContext，用于下次使用，有两个属性：返回结果和请求参数。

当成功连接后，缓存 ChannelHandlerContext，当调用 call 方法的时候，将请求参数发送到服务端，等待。当服务端收到并返回数据后，调用 channelRead 方法，将返回值赋值个 result，并唤醒等待在 call 方法上的线程。此时，代理对象返回数据。

再看看消费者调用方式，一般的TCP的RPC只需要这样调用即可，无需关心具体的协议和通信方式：

1package cn.chinotan;
2
3/**
4 * @program: test
5 * @description: 测试类
6 * @author: xingcheng
7 * @create: 2018-12-30 20:10
8 **/
9public class ClientBootstrap {
10
11    public static final String providerName = "UserService#sayHello#";
12
13    public static void main(String[] args) throws InterruptedException {
14        RpcConsumer consumer = new RpcConsumer();
15        // 创建一个代理对象
16        UserService service = (UserService) consumer.createProxy(UserService.class, providerName);
17        for (;;) {
18            Thread.sleep(1000);
19            System.out.println(service.sayHello("are you ok ?"));
20        }
21    }
22    
23}
24

调用者首先创建了一个代理对象，然后每隔一秒钟调用代理的 sayHello 方法，并打印服务端返回的结果。

结果

可以看到，消费者无需通过jar包的形式引入具体的实现项目，而是通过远程TCP通信的形式，以一定的协议和代理通过接口直接调用了方法，实现远程service间的调用，是分布式服务的基础

Netty 实现简单的RPC远程调用

开始

项目

接口的定义

提供者的实现

消费者相关实现

结果

评论区

相关推荐