自定义RPC

最新推荐文章于 2023-03-13 22:30:07 发布
最新推荐文章于 2023-03-13 22:30:07 发布
阅读量436 收藏 3
点赞数
分类专栏： RPC 文章标签： RPC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39827145/article/details/96327033
版权

一、概述

RPC（remote procedure call）,即远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络实现的技术。
常见的RPC框架有：阿里的Dubbo、Spring cloud 、Google 出品的 grpc 等等。
在这里插入图片描述

  1. 服务消费方（Client）调用本地方法
  2. client stub 接收到调用后负责将方法、参数等信息封装成能够进行网络传输的消息体
  3. client stub 将消息体进行编码发送到服务端
  4. server stub 收到消息后解码
  5. server stub 根据解码结果调用本地服务
  6. 本地服务执行并将结果返回给server stub
  7. server stub 将结果封装并编码发送给客户端
  8. client stub 接收到消息解码
  9. client stub 解码成功得到结果

RPC的目标就是将 2-8步骤 都封装起来，用户无需关系这些细节，就像可以调用本地接口一样。

二、设计和实现

2.1 结构设计

在这里插入图片描述

  • client (客户端) ：创建两个接口 HelloRPC、HelloNetty，还有一个测试类TestNettyRPC
  • client stub : 一个客户端代理类 NettyRPCProxy、一个客户端业务处理类 ResultHandler
  • Server(服务端)： 创建两个名称和客户端一样的接口HelloRPC、HelloNetty，并且实现这个接口里面的方法。
  • Server stub :一个网络处理器InvokeHandler、一个服务器的业务处理器NettyRPCServer

注意：客户端的接口必须和服务端的接口保持一致。

在这里插入图片描述
这里设计到一个jar,主要作用是获取接口实现类

        <!-- https://mvnrepository.com/artifact/org.reflections/reflections -->
        <dependency>
            <groupId>org.reflections</groupId>
            <artifactId>reflections</artifactId>
            <version>0.9.11</version>
        </dependency>

client.HelloNetty

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.client;

/**
 * @author yangjikang
 * @date 2019/7/17 15:36
 * @modified By yangjikang
 */
public interface HelloNetty {
    String hello();
}

cilent.HelloRPC

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.client;

/**
 * @author yangjikang
 * @date 2019/7/17 15:37
 * @modified By yangjikang
 */
public interface HelloRPC {
    String hello(String name);
}

client.TestNettyRPC

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.client;

import com.jikang.rpc.clientStub.NettyRPCProxy;

/**
 * @author yangjikang
 * @date 2019/7/17 15:37
 * @modified By yangjikang
 */
public class TestNettyRPC {

    public static void main(String[] args) {
        //第一次远程调用
        HelloNetty helloNetty = (HelloNetty) NettyRPCProxy.create(HelloNetty.class);
        System.out.println(helloNetty.hello());

        //第二次远程调用
        HelloRPC helloRPC = (HelloRPC) NettyRPCProxy.create(HelloRPC.class);
        System.out.println(helloRPC.hello("RPC"));
    }
}

clientStub.NettyRPCProxy

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.clientStub;

import com.jikang.rpc.serverStub.ClassInfo;
import com.jikang.rpc.serverStub.InvokeHandler;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 *
 * 客户端代理类
 *
 * @author yangjikang
 * @date 2019/7/17 15:38
 * @modified By yangjikang
 */
public class NettyRPCProxy {

    //根据接口创建代理对象
    public static  Object create (Class target){

        return Proxy.newProxyInstance(target.getClassLoader(), new Class[]{target}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //封装ClassInfo
                ClassInfo classInfo = new ClassInfo();
                classInfo.setClassName(target.getName());
                classInfo.setMethodName(method.getName());
                classInfo.setObjects(args);
                classInfo.setTypes(method.getParameterTypes());

                //开始用Netty发送数据
                EventLoopGroup group = new NioEventLoopGroup();
                ResultHandler resultHandler = new ResultHandler();
                try{
                    Bootstrap bootstrap = new Bootstrap();
                    bootstrap.group(group)
                            .channel(NioSocketChannel.class)
                            .handler(new ChannelInitializer<SocketChannel>() {

                                @Override
                                protected void initChannel(SocketChannel socketChannel) throws Exception {
                                    ChannelPipeline pipeline = socketChannel.pipeline();
                                    pipeline.addLast("encoder",new ObjectEncoder());//编码器
                                    pipeline.addLast("decoder",new ObjectDecoder(Integer.MAX_VALUE,
                                            ClassResolvers.cacheDisabled(null)));//解码器
                                    pipeline.addLast(resultHandler);
                                }
                            });
                    ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();
                    channelFuture.channel().writeAndFlush(classInfo).sync();
                    channelFuture.channel().closeFuture().sync();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                        group.shutdownGracefully();
                }
                return resultHandler.getResponse();
            }
        });
    }


}

clientStub.ResultHandler

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.clientStub;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 *
 * 客户端业务处理类
 *
 * @author yangjikang
 * @date 2019/7/17 15:38
 * @modified By yangjikang
 */
public class ResultHandler extends ChannelInboundHandlerAdapter{

    private Object response;

    public Object getResponse() {
        return response;
    }

    //读取客户端返回的数据（远程调用的结果）
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        response = msg;
        ctx.close();
    }
}

server.HelloNetty

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.server;

/**
 * @author yangjikang
 * @date 2019/7/17 15:38
 * @modified By yangjikang
 */
public interface HelloNetty {
    String hello();
}

server.HelloNettyImpl

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.server;

/**
 * @author yangjikang
 * @date 2019/7/17 15:39
 * @modified By yangjikang
 */
public class HelloNettyImpl implements HelloNetty {

    @Override
    public String hello() {
        return "hello,netty";
    }
}

server.HelloRPC

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.server;

/**
 * @author yangjikang
 * @date 2019/7/17 15:39
 * @modified By yangjikang
 */
public interface HelloRPC {
    String hello(String name);
}

server.HelloRPCImpl

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.server;

/**
 * @author yangjikang
 * @date 2019/7/17 15:39
 * @modified By yangjikang
 */
public class HelloRPCImpl implements HelloRPC {

    @Override
    public String hello(String name) {
        return "hello,"+name;
    }
}

serverStub.ClassInfo

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.serverStub;

import java.io.Serializable;

/**
 *
 * 封装类信息
 *
 *
 * @author yangjikang
 * @date 2019/7/17 15:40
 * @modified By yangjikang
 */
public class ClassInfo implements Serializable {

    private static final long serialVersionUID = 2989221128581296303L;

    private String className;//类名

    private String methodName;//方法名

    private Class<?>[] types;//参数类型

    private Object[] objects;//参数列表

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    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 Class<?>[] getTypes() {
        return types;
    }

    public void setTypes(Class<?>[] types) {
        this.types = types;
    }

    public Object[] getObjects() {
        return objects;
    }

    public void setObjects(Object[] objects) {
        this.objects = objects;
    }
}

serverStub.InvokeHandler

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.serverStub;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.reflections.Reflections;

import java.lang.reflect.Method;
import java.util.Set;

/**
 *
 * 服务器端业务处理类
 *
 * @author yangjikang
 * @date 2019/7/17 15:40
 * @modified By yangjikang
 */
public class InvokeHandler extends ChannelInboundHandlerAdapter {


    /**
     * 得到某个接口下某个实现类的名字
     * @param classInfo
     * @return
     * @throws Exception
     */
    private String getImplClassName(ClassInfo classInfo) throws Exception {
        //服务方接口和实现类所在包路径
        String interfacePath = "com.jikang.rpc.server";
        int lastDot = classInfo.getClassName().lastIndexOf(".");
        String interfaceName = classInfo.getClassName().substring(lastDot);
        Class superaClass = Class.forName(interfacePath + interfaceName);
        //得到某接口下所有实现类
        Reflections reflections = new Reflections(interfacePath);
        Set<Class> implClassSet = reflections.getSubTypesOf(superaClass);
        if (implClassSet.size() == 0) {
            System.out.println("未找到实现类");
            return null;
        }else if (implClassSet.size()>1){
            System.out.println("找到多个实现类，未明确使用哪一个");
            return null;
        }else{
            //把集合转化成数组
            Class[] classes = implClassSet.toArray(new Class[0]);
            return classes[0].getName();//得到实现类的名称
        }

    }
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ClassInfo classInfo = (ClassInfo) msg;
        Object object = Class.forName(getImplClassName(classInfo)).newInstance();
        Method method = object.getClass().getMethod(classInfo.getMethodName(), classInfo.getTypes());
        //通过反射调用实现类的方法
        Object result = method.invoke(object, classInfo.getObjects());
        ctx.writeAndFlush(result);
    }
}

serverStub.NettyRPCServer

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.rpc.serverStub;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.serialization.ClassResolver;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

/**
 *
 * 网络处理服务器
 *
 * @author yangjikang
 * @date 2019/7/17 15:40
 * @modified By yangjikang
 */
public class NettyRPCServer {
    private int port;

    public NettyRPCServer(int port) {
        this.port = port;
    }

    public void start(){
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try{
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,128)
                    .childOption(ChannelOption.SO_KEEPALIVE,true)
                    .localAddress(port)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast("encoder",new ObjectEncoder());//编码器
                            pipeline.addLast("decoder",new ObjectDecoder(Integer.MAX_VALUE,
                                    ClassResolvers.cacheDisabled(null)));//解码器
                            pipeline.addLast(new InvokeHandler());
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            System.out.println("-------server is ready------");
            channelFuture.channel().closeFuture().sync();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        NettyRPCServer nettyRPCServer = new NettyRPCServer(9999);
        nettyRPCServer.start();
    }
}
jikangyang
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RPC远程接口调用
qq_42006229的博客
08-17 2234
认识RPC远程接口调用
ENVI自定义RPC文件图像正射校正及数据
10-11
本知识点主要围绕“ENVI自定义RPC文件图像正射校正”展开，讲解相关概念和操作步骤。 首先，RPC（Rational Polynomial Coefficients，有理多项式系数）是一种数学模型，用于描述遥感传感器的几何特性。它包含了从像...
自己动手实现一个RPC框架
Kongfq的博客
08-28 416
RPC（Remote Procedure Call Protocol）远程过程调用协议。一个通俗的描述是：客户端在不知道调用细节的情况下，调用存在于远程计算机上的某个对象，就像调用本地应用程序中的对象一样。kong-rpc-spring-boot-starter,手写RPC框架。.........
自定义RPC框架
吴大侠的博客
01-17 573
一、分布式架构网络通信 在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现 远程通讯的技术，例如:RMI、Hessian、SOAP、ESB和JMS等，它们背后到底是基于什么原理实现的 1.1 基本原理 网络 通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络IO来实现，其中传输 协议比较出名的有tcp、udp等等，tcp、udp都是在基于Socket概念上为某类应用场景而扩展出的传输 协议，网络IO，主要有bio、nio、aio三种方式，所
自定义 RPC
苏凯的博客
02-01 640
                                                          自定义 RPC 概述 RPC（Remote Procedure Call)，即远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络实现的技术。常见的 RPC 框架有: 源自阿里的 Dubbo， Spring 旗下的 Spring Cloud，Google...
自定义RPC项目——常见问题及详解（1）
love and share
05-13 1252
作为Java后端选手，项目是必不可少的，目前主流做的就是各种管理系统和商城项目，同质化严重，那么怎么可以找到一个更加出彩的、与众不同的项目呢，我想下面这个自定义的RPC框架项目是一个不错的选择 项目地址：https://blog.csdn.net/qq_40856284/category_10138756.html 众所周知，用框架和写框架所需要的对框架的熟悉程度显然不在一个级别。为了更好的去理解这个项目，我会把这个项目的常见问题及解答做一个整理（个人见解），让我们开始吧...
RPC 远程调用
Gamble6
12-04 4029
RPC 全称是 Remote Procedure Call ，即远程过程调用，其对应的是我们的本地调用。 远程其实指的就是需要网络通信，可以理解为调用远程机器上的方法。 那可能有人说：我用 HTTP 调用不就是远程调用了，那不也叫 RPC 了？ 不是的，RPC 的目的是：让我们调用远程方法像调用本地方法一样无差别。 本来没有拆分服务都是本地调用的时候方法是这样写的： publicStringgetSth(Stringstr){ returnyesService...
netty自定义rpc实现
12-26
综上所述，实现一个基于Netty的自定义RPC框架，需要理解Netty的异步I/O模型，设计合理的RPC通信协议，利用Zookeeper进行服务注册与发现，同时考虑服务的高可用性和性能优化。通过分析提供的压缩包文件，我们可以深入...
自定义rpc框架
05-16
自定义RPC（Remote Procedure Call）框架是软件开发中的一个重要领域，它允许程序在不同的网络节点间进行通信，仿佛调用本地方法一般。本项目旨在通过深入研究Netty和Zookeeper来构建一个类似Dubbo的RPC框架，从而...
使用netty自定义rpc通信框架
08-23
本项目是基于Netty 4.0实现的自定义RPC通信框架，旨在为Java开发者提供一种高效、灵活的远程服务调用解决方案。 首先，我们来深入理解Netty的基本概念。Netty的核心是其NIO（非阻塞I/O）模型，它使用了Reactor模式...
自定义RPC的Java实现
06-27
自定义RPC(远程方法调用)的Java实现。
自定义rpc思路设计
05-16
自定义rpc框架 ，用到了nettty zookeeper等等，模仿dubbo
深入浅出 RPC - 深入篇
iteye_2022的博客
09-22 5852
《深入篇》我们主要围绕 RPC 的功能目标和实现考量去展开，一个基本的 RPC 框架应该提供什么功能，满足什么要求以及如何去实现它？ RPC 功能目标 RPC 的主要功能目标是让构建分布式计算（应用）更容易，在提供强大的远程调用能力时不损失本地调用的语义简洁性。为实现该目标，RPC 框架需提供一种透明调用机制让使用者不必显式的区分本地调用和远程调用，在前文《浅出篇》中给出了一种实现结构，基于 ...
手撸rpc框架，并基于spring进行二次注解开发
Java新生代
11-29 1233
本文手写rpc框架，可以帮助了解rpc通信原理，并且基于spring进行二次开发，参考mybatis将我们的框架整合到spring中，可以使用@AutoWried注解即可像普通对象一样调用远程方法
接口开发 — — RPC远程过程调用实现
weixin_45565886的博客
09-23 4554
接口开发 — — RPC远程过程调用实现
【分布式-2】自定义RPC框架
最新发布
growing_duck的博客
03-13 371
使用Netty自定义RPC框架

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值