一个最简单的RPC调用Demo04

于 2021-07-27 21:18:22 发布
阅读量470 收藏 2
点赞数
分类专栏： RPCDemo 文章标签： tomcat eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41115379/article/details/119153342
版权

MyRPC版本三

上一篇博客的地址：https://blog.csdn.net/qq_41115379/article/details/119153197

Netty高性能网络框架的使用

Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。

针对之前提出的问题，主要就是提高这个性能，从两个方面入手，网络传输从BIO到NIO，序列化要减少字节流长度，提高序列化反序列化效率，而知名的RPC框架，dubbo和grpc都是用netty底层进行通信的

pom.xml 导入netty
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.20.Final</version>
    </dependency>
重构客户端代码

是因为客户端代码太乱了，先进行代码重构，才有利于后面使用netty的方式实现客户端，使之不同方式网络连接的客户端有相同的结构，同样的api

假设有了两个客户端，SimpleRPCClient (使用Java BIO的方式)和NettyRPCClient(使用netty) ,他们的共性是发送请求与得到response，而建立连接与发送请求的方式是不同的

RPC接口以及一个实现
package RPCVersion01.MyRPCVersion03.client;

import RPCVersion01.MyRPCVersion03.common.RPCRequest;
import RPCVersion01.MyRPCVersion03.common.RPCResponse;

/**
 * 代替原来的RPCClient
 */
//直接把客户端作为一个接口
//把共性给抽取出来
public interface RPCClient {
    //共性就是 发送请求和得到response
    RPCResponse sendRequest(RPCRequest request);
}

package RPCVersion01.MyRPCVersion03.client;

import RPCVersion01.MyRPCVersion03.common.RPCRequest;
import RPCVersion01.MyRPCVersion03.common.RPCResponse;
import lombok.AllArgsConstructor;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 代替原来的SimpleRPCClient
 */
//使用BIO方式实现这个接口
@AllArgsConstructor
public class SimpleRPCClient implements RPCClient {
    //携带的参数
    private String host;
    private int port;
    //这里客户端发起一次请求调用，Socket建立连接，发起请求request,得到相应response
    //这里request 是封装好的，不同的service需要进行不同的封装
    //客户只需要知道service接口，需要一层动态代理来根据反射封装不同的service
    public RPCResponse sendRequest(RPCRequest request) {
        try{
            //发起一次Socket连接请求
            Socket socket=new Socket(host,port);
            //之后会被SockServer的
            ObjectInputStream objectInputStream=new ObjectInputStream(socket.getInputStream());
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(socket.getOutputStream());

            System.out.println(request);
            //写入request 因为写入之后要输出出去 所有是output这边
            objectOutputStream.writeObject(request);
            //然后刷新一下
            objectOutputStream.flush();

            //再通过读取来获取对应的response
            RPCResponse response = (RPCResponse) objectInputStream.readObject();
            return response;

        } catch (UnknownHostException e) {
            e.printStackTrace();
            System.out.println("UnKnowHostException====");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IOException====");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("ClassNotFound====");
        }
        return null;
    }
}
重构PRCClientProxy
package RPCVersion01.MyRPCVersion03.client;

import RPCVersion01.MyRPCVersion03.common.RPCRequest;
import RPCVersion01.MyRPCVersion03.common.RPCResponse;

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

//这个类动态代理Service类，封装不同的service请求为request对象
//并且持有一个RPCClient对象，负责与客户端的通信
public class PRCClientProxy implements InvocationHandler {
    //创建一个RPCClient对象
    private RPCClient rpcClient;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //这里才是真正创建的方法 构建一个request
        //interfaceName是服务类的名字 这个名字怎么获取呢
        //基本上是不用去管 proxy都是method的问题
        //getDeclaringClass是返回 声明这个method对象表示的方法的类的class对象
        //就相当于是 A这个类有 a 和b这两个方法，通过方法的getDeclaringClass的getName就可以知道 A这个名字了
        //相当于就是知道类 getParameterTypes就是返回方法里面的参数的类型 那params就表示的是参数吧
        RPCRequest rpcRequest=RPCRequest.builder().interfaceName(method.getDeclaringClass().getName())
                .methodName(method.getName())
                .params(args).paramsTypes(method.getParameterTypes()).build();

        //通过生成的request来进行传输得到response
        RPCResponse rpcResponse=rpcClient.sendRequest(rpcRequest);
        return rpcResponse.getData();
    }
       //再写一个getProxy的方法
    <T>T getProxy(Class<T> clazz){
        Object o= Proxy.newProxyInstance(clazz.getClassLoader(),new Class[]{clazz},this);
        return (T) o;
    }
}
使用netty方式进行数据的传输，实现NettyRPCServer,NettyRPCClient
NettyRPCClient
package RPCVersion01.MyRPCVersion03.client;

import RPCVersion01.MyRPCVersion03.common.RPCRequest;
import RPCVersion01.MyRPCVersion03.common.RPCResponse;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.util.AttributeKey;

/**
 * 实现RPCClient接口
 */
public class NettyRPCClient implements RPCClient{
    private static final Bootstrap bootstrap;
    private static final EventLoopGroup eventLoopGroup;
    private String host;
    private int port;
    public NettyRPCClient(String host,int port){
        this.host=host;
        this.port=port;
    }
    //这里就是这些static的初始化
    static {
        eventLoopGroup=new NioEventLoopGroup();
        bootstrap=new Bootstrap();
        //然后就是那个创建过程
        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).handler(new NettyClientInitializer());
    }

    /**
     * 这里需要操作一下，因为netty的传输都是异步的，你发送request，会立刻返回
     * 而不是想要的相应的response
     * @param request
     * @return
     */
    //经过测试 发现不是这部分的错误
    @Override
    public RPCResponse sendRequest(RPCRequest request) {
        try{
            ChannelFuture channelFuture=bootstrap.connect(host,port).sync();
            Channel channel=channelFuture.channel();
            //发送数据
            channel.writeAndFlush(request);
            channel.closeFuture().sync();

            //阻塞的获得结果 通过给channel设计别名 获取特定名字下的channel中的内容(这个在hanlder中设置)
            //attributeKey 是线程隔离的，不会有线程安全问题
            //实际上不应通过阻塞，可以通过回调函数
            AttributeKey<RPCResponse> key= AttributeKey.valueOf("RPCResponse");
            //这里就是通过别名获取这个
            RPCResponse rpcResponse=channel.attr(key).get();
            //这个地方就是null了
            System.out.println("NettyRPCClient===="+rpcResponse);
            return rpcResponse;

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

}
NettyClientInitializer
package RPCVersion01.MyRPCVersion03.client;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.serialization.ClassResolver;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

public class NettyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //要写这个初始化的方法
        ChannelPipeline pipeline=socketChannel.pipeline();
        //老规矩 为了防止粘包和拆包
        pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4));
        pipeline.addLast(new LengthFieldPrepender(4));

        //这里忘记写了
        pipeline.addLast(new ObjectEncoder());
        pipeline.addLast(new ObjectDecoder(new ClassResolver() {
            @Override
            public Class<?> resolve(String className) throws ClassNotFoundException {
                return Class.forName(className);
            }
        }));

        pipeline.addLast(new NettyClientHandler());
    }
}
NettyClientHandler
package RPCVersion01.MyRPCVersion03.client;

import RPCVersion01.MyRPCVersion03.common.RPCResponse;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.AttributeKey;
import io.netty.util.concurrent.EventExecutorGroup;

public class NettyClientHandler extends SimpleChannelInboundHandler<RPCResponse> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, RPCResponse rpcResponse) throws Exception {
     //接收到response，给channel设计别名，让sendRequest 里读取response
        //这里应该是设计别名
        AttributeKey<RPCResponse> key= AttributeKey.valueOf("RPCResponse");
        //再把别名放进去 这里是set方法 对应之后的get方法
        channelHandlerContext.channel().attr(key).set(rpcResponse);
        //再把通道关闭
        channelHandlerContext.channel().close();
    }
    //另一个override的还没写
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
Netty服务端
NettyRPCServer 服务端的实现
package RPCVersion01.MyRPCVersion03.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.AllArgsConstructor;

@AllArgsConstructor
public class NettyRPCServer implements RPCServer{
    //实现这两个方法
    private ServiceProvider serviceProvider;
    @Override
    public void start(int port) {
        //netty服务线程组boss负责建立连接，work负责具体的请求
        //NioEventLoopGroup直接就是 EventLoopGroup的具体实现
        //boss word就相当于是 parent和childGroup
        // boss 或者说是parent是对port进行监听的
        //word 或者说是 ChildGroup是用来和Channel绑定的
        NioEventLoopGroup bossGroup=new NioEventLoopGroup();
        NioEventLoopGroup workGroup=new NioEventLoopGroup();
        System.out.println("Netty服务端启动了....");
        try{
            //启动服务器 是Netty的启动程序 引导类
            ServerBootstrap serverBootstrap=new ServerBootstrap();
            //初始化
            //这里没用到Handler 因为这个调用的是父类的，但childHandler则是自己的，是负责和客户端进行连接的IO交互
            serverBootstrap.group(bossGroup,workGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new NettyServerInitializer(serviceProvider));


            //上面这些都是初始化，都是为了后面的操作做准备
            //同步阻塞 ChannelFuture是异步操作的"代言人”
            //.bind是为了通过端口创建，.sync是为了让主线程间接调用wait()，进而实现阻塞的效果
            //当调用bind(port)时，是异步的，因此为了保证在初始化完成后才进行操作，避免调用一个初始化未完成的句柄，sync方法是等待异步操作执行完毕.
            ChannelFuture channelFuture=serverBootstrap.bind(port).sync();

            //死循环监听
            channelFuture.channel().closeFuture().sync();


        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //应该是关闭吧
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }

    }

    @Override
    public void stop() {

    }
}
NettyServerInitializer 初始化
package RPCVersion01.MyRPCVersion03.server;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.serialization.ClassResolver;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import lombok.AllArgsConstructor;

//他的作用就是生成一个ChannelHandler

/**
 * 初始化，主要负责序列化的编码和解码，需要解决netty的粘包问题
 */
@AllArgsConstructor
public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {
    private ServiceProvider serviceProvider;
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //意思是 初始化Channel
        //创建的这个pipeline是可以把channel依次进去的
        ChannelPipeline pipeline=socketChannel.pipeline();

        /**
         * 后面这两个相当于是Netty自带的格式功能，总的来说就是为了解决粘包和拆包的问题
         */
        //消息格式[长度][消息体]，解决粘包问题
        //LengthFieldBasedFrameDecoder是通用拆包器，几乎所有和长度相关的二进制协议都可以用他来实现
        //第一个参数是表示包的最大长度，第二个参数是 长度域的偏移量，0表示无偏移。第三个参数是 长度域的长度
        //第五个参数 是4的话，表示获取完一个完整的数据包之后，忽略前面的四个字节
        //第四个参数 lengthAdjustment是对包体长度调整的大小
        pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4));
        //计算过当前待发送消息的长度 写入到前四个字节中
        pipeline.addLast(new LengthFieldPrepender(4));
        //这里还是使用的Java的序列化方法，netty的自带的解码编码支持传输
        pipeline.addLast(new ObjectEncoder());
        pipeline.addLast(new ObjectDecoder(new ClassResolver() {
            @Override
            public Class<?> resolve(String className) throws ClassNotFoundException {
                return Class.forName(className);
            }
        }));
        pipeline.addLast(new NettyPRCServerHandler(serviceProvider));


    }
}

NettyRPCServerHandler netty server具体的handler

package RPCVersion01.MyRPCVersion03.server;

import RPCVersion01.MyRPCVersion03.common.RPCRequest;
import RPCVersion01.MyRPCVersion03.common.RPCResponse;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.concurrent.EventExecutorGroup;
import lombok.AllArgsConstructor;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

@AllArgsConstructor
public class NettyPRCServerHandler extends SimpleChannelInboundHandler<RPCRequest> {
    private ServiceProvider serviceProvider;

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, RPCRequest rpcRequest) throws Exception {
        System.out.println("channelRead0===="+rpcRequest);
        RPCResponse rpcResponse=getResponse(rpcRequest);
        channelHandlerContext.writeAndFlush(rpcResponse);
        channelHandlerContext.close();
    }


    private RPCResponse getResponse(RPCRequest rpcRequest) {
        //得到服务名
        String interfaceName=rpcRequest.getInterfaceName();
        //得到服务端相应服务实现类
        Object service = serviceProvider.getService(interfaceName);
        //反射调用方法
        Method method=null;
        try{
            method=service.getClass().getMethod(rpcRequest.getMethodName(),rpcRequest.getParamsTypes());
            Object invoke = method.invoke(service, rpcRequest.getParams());
            return RPCResponse.success(invoke);
        } catch (NoSuchMethodException |IllegalAccessException |InvocationTargetException e) {
            System.out.println("方法执行错误");
            e.printStackTrace();
            return RPCResponse.fail();
        }

    }
    //一个overrider
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
客户端和服务端的测试代码
服务端的测试代码 TestServe
package RPCVersion01.MyRPCVersion03.server;

import RPCVersion01.MyRPCVersion03.service.BlogService;
import RPCVersion01.MyRPCVersion03.service.BlogServiceImpl;
import RPCVersion01.MyRPCVersion03.service.UserService;
import RPCVersion01.MyRPCVersion03.service.UserServiceImpl;

public class TestServer {
    public static void main(String[] args) {
        UserService userService=new UserServiceImpl();
       // BlogService blogService=new BlogServiceImpl();
        //再使用Map把服务添加进去
    /*    Map<String,Object> serviceProvide=new HashMap<>();

        //暴露两个服务接口 在RPCServer中加入一个HashMap
        serviceProvide.put("PRCVersion01.UserService",userService);
        serviceProvide.put("PRCVersion01.BlogService",blogService);*/

        //因为直接写了一个ServiceProvider所以可以进行修改
        ServiceProvider serviceProvider = new ServiceProvider();
        serviceProvider.provideServiceInterface(userService);
       // serviceProvider.provideServiceInterface(blogService);
        //MyRPC 版本2的   RPCServer RPCServer = new SimpleRPCRPCServer(serviceProvider) 会报错呀
        //这里修改了一下 不知道有没有用
       // RPCServerVersion2 rpcServerVersion2=new SimpleRPCServerVersion2(serviceProvider.getInterfaceProvider());
       //线程池版
        RPCServer rpcServerVersion2=new NettyRPCServer(serviceProvider);
       rpcServerVersion2.start(8899);
    }
}
服务端的测试代码 TestClient
package RPCVersion01.MyRPCVersion03.client;


import RPCVersion01.MyRPCVersion03.common.User;
import RPCVersion01.MyRPCVersion03.service.UserService;

public class TestClient {
    public static void main(String[] args) {
        //创建一个client
        System.out.println("TestClient开始了====");
        RPCClient nettyRPCClient=new NettyRPCClient("127.0.0.1",8899);
      //  System.out.println("nettyRPCClient===="+nettyRPCClient);
        //把客户端传入到代理客户端中
        RPCClientProxy rpcClientProxy=new RPCClientProxy(nettyRPCClient);
      //  System.out.println("rpcClientProxy===="+rpcClientProxy);
        //代理客户端根据不同的服务，获得一个代理类
        //经过测试 是这个部分出现了问题
        UserService proxy = rpcClientProxy.getProxy(UserService.class);
        //问题就处在这  proxy不能先调用的
      // System.out.println("proxy===="+proxy);

        //调用方法
        User userByUserId = proxy.getUserByUserId(10);
        System.out.println("userByUserId===="+userByUserId);


    }
}
运行结果

在这里插入图片描述

代码问题

这里关于动态代理，出现了一个问题，让我代码一直运行不起来

经过debug之后，发现错误出现这个地方

正确的代码部分：

\

错误的代码：

在这里插入图片描述

也就是多写了一个

System.out.println("proxy===="+proxy);

在debug的情况下看看到了这部分会出现什么情况

首先

RPCClientProxy rpcClientProxy=new RPCClientProxy(nettyRPCClient);

这一步只是进行了 RPCClientProxy部分的注解@AllArgsConstructor，也就是进行了创建构造函数

这个时候下面的方法都还没开始调用

然后到这一步

在这里插入图片描述

调用了Proxy下的 getproxy方法
在这里插入图片描述

这个时候才创建好一个proxy

然后是这一步

在这里插入图片描述

首先他会报出一个异常：

Method threw ‘java.lang.NullPointerException’ exception. Cannot evaluate com.sun.proxy.$Proxy0.toString()

https://blog.csdn.net/weixin_43979923/article/details/107151410

但这个异常是可以暂时忽略不计的

进入这个之后 就先进入到了RPCReuqest的build方法，也就是request的初始化

随即进入到invoke当中

问题就在于 这个时候的proxy还没有指定对应的方法

在这里插入图片描述

这样子生成的request是不带任何参数的

在这里插入图片描述

然后调用了 RPCClient的sendRequest

在这里插入图片描述

所以导致这个时候输出的是null了

在这里插入图片描述

而正常情况下

到这一步的时候

首先进行RPCRequest的builder

在这里插入图片描述

然后进入到invoke当中

在这里插入图片描述

注意，这个时候的method就是有方法的

这样子生成的request就是有值的

RPCRequest(interfaceName=RPCVersion01.MyRPCVersion03.service.UserService, methodName=getUserByUserId, params=[10], paramsTypes=[class java.lang.Integer])

并且这样子输出的response也不是null 了

在这里插入图片描述

所以问题还是出在了 这个输出上面

总结

这个版本完成了客户端的重构，使之能够支持多种版本客户端的扩展，实现了RPCClient接口

并使用了Netty实现了客户端和服务端的通信

痛点

使用了Java自带的序列化方式，Java序列化写入不仅是完整的类名，也包含整个类的定义，包含所有被引用的类，不够通用，不够高效

关切得大神
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
手写rpc的demo
qq_50475119的博客
03-15 1690
前置知识 了解rpc 和http的不同 对于服务来说有基于http的restful风格的远程调用还有rpc的远程调用 它们之间最显著的区别就是 http一般对外服务之间的调用 而rpc则是内部的方法调用 好比http的调用就是用户购买模块调用购物车模块 而rpc则是购买模块内部请求其他集齐上资源的远程调用 tcp 和 udp 我们知道tcp 和 udp 都是传输层的协议但是它们之间还是有很多不同的 tcp是安全的可靠的但是效率低 udp是无状态的不可靠的但是效率高 远程服务调用的过程 tips: 序列化就
一个最简单的RPC调用Demo01
wzw的博客
06-27 399
RPC的定义 一个RPC最最简单的过程就是客户端调用服务端的一个方法，服务端返回执行方法的返回值给客户端 前置知识 下面就是一个简单的从数据库中取数据的例子 对注解的解释： @Builder @Data//提供了读写属性，还提供了 equals() hashCode() toString()这些方法 @Builder//这个注解是为类生成相对略微复制的构建器API 就是所谓的提供一个内部的Builder @NoArgsConstructor//这个是生成一个无参的构造函数 @AllArgsConstruc
一个最简单的RPC调用Demo02
wzw的博客
07-13 210
MyRPC版本一 上一篇博客的地址：https://blog.csdn.net/qq_41115379/article/details/118281642 本节问题 1.让客户端请求远程方法能支持多种 2.让服务端返回值的类型多样 总结知识 Serializable https://www.jianshu.com/p/2e83ab8210dc 他是一个对象序列化的接口，一个类只有实现了Serializable接口，对象才能被序列化。而什么是序列化，怎么体现实现了序列化呢。 序列化含义 将对象的状态
java_rpc_demo
05-10
（1）用java写的RPC调用的demo。通过这个demo，可以了解RPC的基本原理。 （2）没有用到其他的jar包，java对象和流之间的转换用的是java.io.ObjectInputStream和java.io.ObjectOutputStream。 （3）下载解压，可以直接导入Eclipse运行调试。
rpc demo 一学就会
02-06
java编写 注释到位. 解压导入eclipse即可使用.帮助你更快的学习rpc原理.
Hessian远程调用RPC最简单demo
04-04
本教程将详细介绍"Hessian远程调用RPC最简单demo"，包括服务器端服务发布和客户端服务调用的实现，以及所需资源。 首先，我们来看一下`hessian-4.0.7.jar`这个文件。这是Hessian库的核心组件，包含了实现Hessian...
一个简单的grpc开发demo
最新发布
06-17
【标题】：“一个简单的gRPC开发demo” 在IT行业中，gRPC是一个高性能、开源和通用的RPC（远程过程调用）框架，它基于Google的Protocol Buffers（protobuf）进行序列化和接口定义。gRPC使用HTTP/2作为传输协议，...
最简单的RPC框架源码.zip
11-04
通过对"最简单的RPC框架源码"的分析，我们可以学习到如何设计和实现一个基本的RPC框架，理解其工作流程和核心组件。这将有助于我们更好地理解和使用复杂的RPC框架，如Dubbo、gRPC、Spring Cloud等。
rpc-demo.zip
08-17
在这个“rpc-demo.zip”压缩包中，你将找到一个简单的RPC实现，它是基于Spring框架和服务的动态发布，同时使用了底层的Socket通信。下面我们将深入探讨这个实例中的关键知识点。 首先，RPC的核心思想是透明性，即...
Dubbo入门---搭建一个最简单的Demo框架
04-24
【标题】：“Dubbo入门---搭建一个最简单的Demo框架” 【描述】：这篇博客通过一个简单的实例，引导读者了解如何入门Dubbo框架的使用。它可能是以创建一个包含服务提供者和服务消费者的基本项目为背景，逐步讲解了...
Java RPC调用示例
02-09
使用Java实现简单的RPC调用，解释了接口是如何执行其它服务函数体的。
纯java 远程调用DEMO
08-02
远程调用有很多框架可以学习。本DEMO是用纯java的socket实现的基础RPC。便于理解RPC的底层实现
系统间通信：基于TCP协议的RPC实现范例
追梦客
12-15 4567
系统间通信：基于TCP协议的RPC实现范例 一、RPC名词解释          RPC的全称是Remote Process Call，即远程过程调用，它应用广泛，实现方式也很多，拥有RMI、WebService等诸多成熟的方案，在业界得到了广泛的使用。单台服务的处理能力受到硬件成本的限制，不可能无限制地提升。RPC将原来的本地调用转变为调用远端的服务器上的方法，给系统的处理能力和吞吐量带来了
手写rpc简单demo以及相关学习思考
大鸡腿的博客
10-05 341
文章目录RPC介绍Fegin原理@FeignClientDubbo理解手写rpc框架时序图个人的实战启动zkmaven编写rpc-provider请求类编写rpc-consumer调用远程接口手写框架相关改造动态代理调用远程接口返回结果@Component理解源码地址 RPC介绍 RPC是远程过程调用（Remote Procedure Call）的缩写形式。 个人理解：相关框架会封装相应的ht...
RPC简单的demo
liurong_scut的博客
10-17 313
编写rpc服务端代码如下： package com.bootdo.testDemo.rpc; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.OutputStream; import java.lang.reflect.Method; import java.lang.re...
【Java】java实现的远程调用例子 rpc原理
热门推荐
u010900754的专栏
09-25 1万+
当今分布式应用盛行，rpc框架也就随之出现，今天用java写一个小的demo。 首先看一下什么事远程调用 远程调用涉及到了网络io，基本过程是客户端向服务端发送消息，表明自己要调用的方法的名字以及包含的参数，然后服务端调用函数，再向客户端返回结果。所以涉及了两次网络io。 这样的话，客户端的代码写起来比较费劲，每一个方法底层都是网络io，但是过程都是一样的，传递参数，得到结果，所以这里肯定可
深入浅出 RPC - 深入篇
iteye_2022的博客
09-22 5852
《深入篇》我们主要围绕 RPC 的功能目标和实现考量去展开，一个基本的 RPC 框架应该提供什么功能，满足什么要求以及如何去实现它？ RPC 功能目标 RPC 的主要功能目标是让构建分布式计算（应用）更容易，在提供强大的远程调用能力时不损失本地调用的语义简洁性。为实现该目标，RPC 框架需提供一种透明调用机制让使用者不必显式的区分本地调用和远程调用，在前文《浅出篇》中给出了一种实现结构，基于 ...
项目通信之RPC调用——java简单实现
ilovexiaou的博客
01-03 1569
微服务项目通信方法很多，有像springcloud解决方案的http通信，还有像阿里Dubbo的RPC通信，这里简单实现RPC调用。一共2个端，客户端server和客户端client.项目demo很简单，就不多讲了，看代码好了。 下面是服务端的demo，直接main函数启动。 package com.alvis.rpcserverdemo.server; /** * @author...
JAVA rpc调用webservice服务
huhailong_1的博客
11-21 3387
入参是xml的： package com.comparator.interfaces.cxf; public class RPCClient {     private static final String arg0 = "&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;\r\n"             +"  \r\n"         ...
写一个rpc的请求调用
04-01
下面是一个简单的Python代码示例，展示如何调用getUserInfo方法： ```python import json import requests # 定义RPC请求的URL和参数 url = 'http://user_service/getUserInfo' payload = { 'user_id': '12345' }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值