基于Netty自定义RPC框架

最新推荐文章于 2024-04-08 22:36:54 发布

小默有礼

最新推荐文章于 2024-04-08 22:36:54 发布

阅读量256

点赞数

分类专栏： Java 分布式集群 RPC 文章标签： rpc 网络 udp

本文链接：https://blog.csdn.net/qq_40377973/article/details/126651909

版权

Java 同时被 3 个专栏收录

9 篇文章 0 订阅

订阅专栏

分布式集群

7 篇文章 0 订阅

订阅专栏

RPC

1 篇文章 0 订阅

订阅专栏

1、基本原理

要实现网络机器间的通讯，首先得来看看计算机系统网络通信的基本原理，在底层层面去看，网络
通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络IO来实现，其中传输
协议比较出名的有tcp、udp等等，tcp、udp都是在基于Socket概念上为某类应用场景而扩展出的传输
协议，网络IO，主要有bio、nio、aio三种方式，所有的分布式应用通讯都基于这个原理而实现.

2、什么是RPC

RPC全称为remote procedure call，即远程过程调用。借助RPC可以做到像本地调用一样调用远程服
务，是一种进程间的通信方式.
比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用
B服务器上的应用提供的方法，由于两个应用不在一个内存空间，不能直接调用，所以需要通过网络来
表达调用的语义和传达调用的数据。需要注意的是RPC并不是一个具体的技术，而是指整个网络远程调
用过程。
在这里插入图片描述
RPC架构
一个完整的RPC架构里面包含了四个核心的组件，分别是Client，Client Stub，Server以及Server Stub，这个Stub可以理解为存根。

客户端(Client)，服务的调用方。
客户端存根(Client Stub)，存放服务端的地址消息，再将客户端的请求参数打包成网络消息，然后通过网络远程发送给服务方。
服务端(Server)，真正的服务提供者。
服务端存根(Server Stub)，接收客户端发送过来的消息，将消息解包，并调用本地的方法。

客户端（client）以本地调用方式（即以接口的方式）调用服务；
客户端存根（client stub）接收到调用后，负责将方法、参数等组装成能够进行网络传输的消息体
（将消息体对象序列化为二进制）；
客户端通过socket将消息发送到服务端；
服务端存根( server stub）收到消息后进行解码（将消息对象反序列化）；
服务端存根( server stub）根据解码结果调用本地的服务；
服务处理
本地服务执行并将结果返回给服务端存根( server stub）；
服务端存根( server stub）将返回结果打包成消息（将结果消息对象序列化）；
服务端（server）通过socket将消息发送到客户端；
客户端存根（client stub）接收到结果消息，并进行解码（将结果消息发序列化）；
客户端（client）得到最终结果。

RPC的目标是要把2、3、4、5、7、8、9、10这些步骤都封装起来。只剩下1、6、11
注意：无论是何种类型的数据，最终都需要转换成二进制流在网络上进行传输，数据的发送方需要
将对象转换为二进制流，而数据的接收方则需要把二进制流再恢复为对象。

在java中RPC框架比较多，常见的有Hessian、gRPC、Dubbo 等，其实对于RPC框架而言，核心模块就是通讯和序列化.

3、基于Netty实现RPC框架

实现需求：
dubbo 底层使用了 Netty 作为网络通讯框架，使用 Netty 实现一个简单的 RPC 框架，消费者和提供者约定接口和协议，消费者远程调用提供者的服务。

创建一个接口，定义抽象方法。用于消费者和提供者之间的约定,
创建一个提供者，该类需要监听消费者的请求，并按照约定返回数据
创建一个消费者，该类需要透明的调用自己不存在的方法，内部需要使用 Netty 进行数据通信
提供者与消费者数据传输使用json字符串数据格式
提供者使用netty集成spring boot 环境实现

目标: 客户端远程调用服务端提供根据ID查询user对象的方法.

在这里插入图片描述
代码实现：

服务端代码

RPCServer

/**
 * 对外暴露服务接口
 */
@Target(ElementType.TYPE) // 用于接口和类上
@Retention(RetentionPolicy.RUNTIME)// 在运行时可以获取到
@Documented
public @interface RPCServer {
}

UserServiceImpl

 @RPCServer
@Component
public class UserServiceImpl implements UserService{

    Map<Object,User> userMap = new HashMap();

    @Override
    public User getById(int id) {
        if (userMap.size() == 0){
            User user1 = new User();
            user1.setId(1);
            user1.setName("张三");
            User user2 = new User();
            user2.setId(2);
            user2.setName("李四");
            userMap.put(user1.getId(), user1);
            userMap.put(user2.getId(), user2);
        }
        return userMap.get(id);
    }
}

Server

@Component
public class Server implements DisposableBean {
    private NioEventLoopGroup bossGroup;
    private NioEventLoopGroup workerGroup;
    @Autowired
    RpcServerHandler rpcServerHandler;

    public void startServer(String id, int port) {
        try {
            //1. 创建线程组
            bossGroup = new NioEventLoopGroup(1);
            workerGroup = new NioEventLoopGroup();
            //2. 创建服务端启动助手
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel channel) throws Exception {
                            ChannelPipeline pipeline = channel.pipeline();
                            //添加String的编解码器
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new StringDecoder());
                            //业务处理类
                            pipeline.addLast(rpcServerHandler);
                        }
                    });
            ChannelFuture future = bootstrap.bind(id, port).sync();
            System.out.println("==========服务端启动成功==========");
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (bossGroup != null) {
                bossGroup.shutdownGracefully();
            }
            if (workerGroup != null) {
                workerGroup.shutdownGracefully();
            }
        }
    }

    @Override
    public void destroy() throws Exception {

        if (bossGroup != null) {
            bossGroup.shutdownGracefully();
        }
        if (workerGroup != null) {
            workerGroup.shutdownGracefully();
        }
    }
}

RPCServerHandler

@Component
@ChannelHandler.Sharable
public class RpcServerHandler extends SimpleChannelInboundHandler<String> implements ApplicationContextAware {

    /**
     * 服务端业务处理类
     * 1.将标有@RpcService注解的bean缓存
     * 2.接收客户端请求
     * 3.根据传递过来的beanName从缓存中查找到对应的bean
     * 4.解析请求中的方法名称. 参数类型 参数信息
     * 5.反射调用bean的方法
     * 6.给客户端进行响应
     */

    private static final Map SERVICE_INSTANCE_MAP = new ConcurrentHashMap();

    @Override
    /**
     * 1.将标有@RpcService注解的bean缓存
     *
     * @param applicationContext
     * @throws BeansException
     */
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> beans = applicationContext.getBeansWithAnnotation(RPCServer.class);
        Set<Map.Entry<String, Object>> entries = beans.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            Object value = entry.getValue();
            if (value.getClass().getInterfaces().length == 0){
                throw new RuntimeException("服务必须实现接口");
            }
            String name = value.getClass().getInterfaces()[0].getName();
            SERVICE_INSTANCE_MAP.put(name,value);

        }
    }

    @Override
    /**
     * 通道读取就绪事件
     *
     * @param channelHandlerContext
     * @param msg
     * @throws Exception
     */
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, String s) throws Exception {
        //1.接收客户端请求- 将msg转化RpcRequest对象
        RPCRequest rpcRequest = JSON.parseObject(s, RPCRequest.class);
        RPCResponse rpcResponse = new RPCResponse();
        rpcResponse.setResponseId(rpcRequest.getRequestId());
        try {
            rpcResponse.setResult(handler(rpcRequest));
        } catch (InvocationTargetException e) {
            e.printStackTrace();
            rpcResponse.setError(e.getMessage());
        }
        channelHandlerContext.writeAndFlush(JSON.toJSONString(rpcResponse));

    }

    /**
     * 业务处理逻辑
     *
     * @return
     */
    public Object handler(RPCRequest rpcRequest) throws InvocationTargetException {
        //4.解析请求中的方法名称. 参数类型 参数信息
        String name = rpcRequest.getClassName();
        Object value = SERVICE_INSTANCE_MAP.get(name);
        if (value == null) {
            System.out.println(SERVICE_INSTANCE_MAP);
            throw new RuntimeException("根据beanName找不到服务,beanName:" + name);
        }
        String methodName = rpcRequest.getMethodName();
        Class<?>[] parameterTypes = rpcRequest.getParameterTypes();
        Object[] parameters = rpcRequest.getParameters();
        //5.反射调用bean的方法
        FastClass fastClass = FastClass.create(value.getClass());
        FastMethod method = fastClass.getMethod(methodName, parameterTypes);
        Object invoke = method.invoke(value, parameters);
        return invoke;
    }
}

RPCSpringbootApplication

@SpringBootApplication
public class RPCSpringbootApplication implements CommandLineRunner {

    @Autowired
    Server server;

    public static void main(String[] args){
        SpringApplication.run(RPCSpringbootApplication.class,args);
    }

    @Override
    public void run(String... args) throws Exception {
        new Thread(new Runnable() {
            @Override
            public void run() {
                server.startServer("127.0.0.1",9999);
            }
        }).start();
    }
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>lotus-rpc</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>lotus-rpc-provider</artifactId>

    <dependencies>
        <!--spring相关依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <artifactId>lotus-rpc-api</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

</project>

客户端代码

Client

public class Client {

    private EventLoopGroup group;

    private Channel channel;

    private String ip;

    private int port;

    private RpcClientHandler rpcClientHandler = new RpcClientHandler();

    private ExecutorService executorService = Executors.newCachedThreadPool();

    public Client(String ip, int port) {
        this.ip = ip;
        this.port = port;
        initClient();
    }

    public void initClient(){

        //1.创建线程组
        NioEventLoopGroup group = new NioEventLoopGroup();
        //2.创建启动助手
        Bootstrap bootstrap = new Bootstrap();

        try {
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel channel) throws Exception {
                            ChannelPipeline pipeline = channel.pipeline();
                            //String类型编解码器
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            //添加客户端处理类
                            pipeline.addLast(rpcClientHandler);
                        }
                    });
            channel = bootstrap.connect(ip, port).sync().channel();
        } catch (InterruptedException e) {
            e.printStackTrace();
            if (channel != null) {
                channel.close();
            }
            if (group != null) {
                group.shutdownGracefully();
            }
        }

    }
    /**
     * 提供给调用者主动关闭资源的方法
     */
    public void close() {
        if (channel != null) {
            channel.close();
        }
        if (group != null) {
            group.shutdownGracefully();
        }
    }

    /**
     * 提供消息发送的方法
     */
    public Object send(String msg) throws ExecutionException, InterruptedException {
        rpcClientHandler.setRequestMsg(msg);
        Future submit = executorService.submit(rpcClientHandler);
        return submit.get();
    }
}

RpcClientHandler

public class RpcClientHandler extends SimpleChannelInboundHandler<String> implements Callable {

    ChannelHandlerContext context;

    //发送的消息
    String requestMsg;

    String responseMsg;

    public void setRequestMsg(String requestMsg) {
        this.requestMsg = requestMsg;
    }

    /**
     * 通道连接就绪事件
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        context = ctx;
    }

    /**
     * 通道读取就绪事件
     *
     * @param channelHandlerContext
     * @param msg
     * @throws Exception
     */
    @Override
    protected synchronized void channelRead0(ChannelHandlerContext channelHandlerContext, String msg) throws Exception {
        responseMsg = msg;
        notify();
    }

    @Override
    public synchronized Object call() throws Exception {
        context.writeAndFlush(requestMsg);
        wait();
        return responseMsg;
    }
}

RpcClientProxy

public class RpcClientProxy {
    public static Object createProxy(Class service){
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{service}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        /**
                         *  * 1.封装request请求对象
                         *  * 2.创建RpcClient对象
                         *  * 3.发送消息
                         *  * 4.返回结果
                         */
                        RPCRequest request = new RPCRequest();
                        request.setRequestId(UUID.randomUUID().toString());
                        request.setClassName(method.getDeclaringClass().getName());
                        request.setMethodName(method.getName());
                        request.setParameterTypes(method.getParameterTypes());
                        request.setParameters(args);
                        String jsonString = JSON.toJSONString(request);
                        //2.创建RpcClient对象
                        Client rpcClient = new Client("127.0.0.1", 9999);
                        try {
                            //3.发送消息
                            Object responseMsg = rpcClient.send(jsonString);
                            RPCResponse rpcResponse = JSON.parseObject(responseMsg.toString(), RPCResponse.class);
                            if (rpcResponse.getError() != null) {
                                throw new RuntimeException(rpcResponse.getError());
                            }
                            //4.返回结果
                            Object result = rpcResponse.getResult();
                            return JSON.parseObject(result.toString(), method.getReturnType());
                        } catch (Exception e) {
                            throw e;
                        } finally {
                            rpcClient.close();
                        }
                    }
                }
        );
    }
}

ClientBootstrap

public class ClientBootstrap {
    public static void main(String[] args) {
        UserService userService = (UserService) RpcClientProxy.createProxy(UserService.class);
        User user = userService.getById(1);
        System.out.println(user);
    }
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>lotus-rpc</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>lotus-rpc-consumer</artifactId>

    <dependencies>
        <dependency>
            <artifactId>lotus-rpc-api</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

</project>

公共服务

UserService

public interface UserService {
    /**
     * 根据ID查询用户
     *
     * @param id
     * @return
     */
    User getById(int id);
}

RPCRequest

@Data
public class RPCRequest {
    /**
     * 请求对象的ID
     */
    private String requestId;
    /**
     * 类名
     */
    private String className;
    /**
     * 方法名
     */
    private String methodName;
    /**
     * 参数类型
     */
    private Class<?>[] parameterTypes;
    /**
     * 入参
     */
    private Object[] parameters;
}

RPCResponse

@Data
public class RPCResponse {
    /**
     * 响应id
     */
    private String responseId;
    /**
     * 错误信息
     */
    private String error;
    /**
     * 返回值
     */
    private Object result;
}

User

@Data
public class User {
    private int id;
    private String name;
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>lotus-rpc</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>lotus-rpc-api</artifactId>


    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
        </dependency>
        <!--json依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>
        <!--lombok依赖 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

</project>

小默有礼

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
基于Netty自定义RPC框架

RPC全称为remote procedure call，即远程过程调用。借助RPC可以做到像本地调用一样调用远程服务，是一种进程间的通信方式.比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用B服务器上的应用提供的方法，由于两个应用不在一个内存空间，不能直接调用，所以需要通过网络来表达调用的语义和传达调用的数据。需要注意的是RPC并不是一个具体的技术，而是指整个网络远程调用过程。RPC架构。
复制链接

扫一扫