RPC远程调用原理解析及java例子

RPC（Remote Procedure Call）远程调用，通过某种手段，协议，约定调用非本地服务，

也即是说调用者不和提供服务者直接联系（原来:我们买房直接去供应商那里去买，RPC让我们可以：我们买房可以找中介，中介再去找供应商）

那不就是说RPC会使我们程序效率降低吗？很明显会，但是，我们业务逻辑直连的话，我们生产的供应商只能对你这边进行一对一的服务，我要给很多平台都有卖房这个能力呢？我又要在他们平台生成供应商？

RPC 框架作为架构微服务化的基础组件，它能大大降低架构微服务化的成本，提高调用方与服务提供方的研发效率，屏蔽跨进程调用函数（服务）的各类复杂细节。让调用方感觉就像调用本地函数一样调用远端函数、让服务提供方感觉就像实现一个本地函数一样来实现服务。

1.调用客户端句柄；执行传送参数            （大王要打劫）

2.调用本地系统内核发送网络消息            （给直系小弟下命令）

3.消息发送到远程主机                                 （直系小弟跑腿小喽啰带消息）

4.服务器句柄得到消息并取得参数               （小喽啰接收到命令）

5.执行远程过程                                            （跑去打劫中）

6.执行的过程将结果返回服务器句柄             （打劫到多少钱财，姑娘）

7.服务器句柄返回结果，调用远程系统内核    （带回）

8.消息传回本地主机                                         （上交给大王的直系小弟）

9.客户句柄由内核接收消息                              （直系小弟带回收获）

10.客户接收句柄返回的数据                                （直系小弟上交给大王，大王乐呵呵）

 

如果我们也想要来实现一个RPC，远程过程调用怎么搞？

抽空可以理解一下：RPC调用和HTTP调用的区别  https://blog.csdn.net/m0_38110132/article/details/81481454

个人理解是：RPC远程过程调用，是能够远程调用到我们用到的服务，给远程服务下命令，帮助我们去做某一件事情

可以用各种方式去实现，可以是socket  可以是http，可以是webservice等等等等，当然如果从效率，安全等等角度来讲

不是都适合来做RPC。

好了闲话不扯了，让我们来实现一个，方便理解理解RPC这玩意

项目结构如上，由于我这里写小例子的原因，所以放在一个demo里面，实际是可以拆分出来的

UserVo可以和RpcService提取出去，作为一个共享jar，有开发基础的都应该知到怎么拆分吧？

package com.example.demo.api;

import java.io.Serializable;

public class UserVo implements Serializable {
    private String name;                  //当然也可以使用lombok 来实现get，，set，这里从简
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.example.demo.api;

public interface RpcService {

     String call(String name);

     UserVo getUser(String name);
}

package com.example.demo.api;

import java.util.ArrayList;
import java.util.List;

public class RpcServiceImpl implements RpcService {

   private static List<UserVo> userVos = new ArrayList<>();
    static {

        UserVo userVo = new UserVo();
        userVo.setAge(20);
        userVo.setName("zhangsan");
        userVo.setSex("男");
        userVos.add(userVo);

        UserVo userVo2 = new UserVo();
        userVo2.setAge(20);
        userVo2.setName("lisi");
        userVo2.setSex("男");
        userVos.add(userVo2);

        UserVo userVo3 = new UserVo();
        userVo3.setAge(20);
        userVo3.setName("wangermazi");
        userVo3.setSex("女");
        userVos.add(userVo3);
    }
    @Override
    public String call(String name) {
        return "hello:"+name;
    }

    @Override
    public UserVo getUser(String name) {
        UserVo userVo = new UserVo();
        for (UserVo user:userVos) {
            if (user.getName().equals(name)){
                userVo=user;
            }
        }
        return userVo;
    }
}

package com.example.demo.server;


import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.Socket;

public class RegisterHelper extends Thread{

     Socket socket;
     Object service;
    public RegisterHelper( Socket socket,Object service)
    {
        this.socket = socket;
        this.service = service;
    }
    @Override
    public void run() {
        try {
            ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
            String methodName = in.readUTF();
            Class<?>[] parameterTypes = (Class<?>[]) in.readObject();
            Object[] parameters = (Object[]) in.readObject();
            Method method = service.getClass().getMethod(methodName, parameterTypes);
            try {
                Object result = method.invoke(service, parameters);
                ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
                out.writeObject(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package com.example.demo.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class RpcRegisterCenter {
	public void register(Object service, int port){
		try {
			System.out.println("服务开启");
			ServerSocket server = new ServerSocket(port);
			Socket socket;
			while((socket = server.accept()) != null){
				new RegisterHelper(socket,service).start();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

package com.example.demo;

import com.example.demo.api.RpcService;
import com.example.demo.api.RpcServiceImpl;
import com.example.demo.server.RpcRegisterCenter;

public class Server {
 
	public static void main(String args[]){
		RpcService rpcService = new RpcServiceImpl();
		RpcRegisterCenter server = new RpcRegisterCenter();
		server.register(rpcService, 1000);
	}
}

package com.example.demo;

import com.example.demo.api.RpcService;
import com.example.demo.api.UserVo;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;

public class Client {
 
	public static void main(String args[]){
		RpcService rpcService = getClient(RpcService.class);
		System.out.println(rpcService.call("zhansan"));
		UserVo userVo = rpcService.getUser("wangermazi");
		System.out.println("name:"+userVo.getName()+"\n age:"+userVo.getAge()+"\n sex:"+userVo.getSex());
	}
	@SuppressWarnings("unchecked")
	public static <T> T getClient(Class<T> clazz){
		return  (T) Proxy.newProxyInstance(Client.class.getClassLoader(), new Class<?>[]{clazz}, new InvocationHandler() {
			@Override
			public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
				Socket socket = new Socket("127.0.0.1", 1000);
				ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
				out.writeUTF(arg1.getName());
				out.writeObject(arg1.getParameterTypes());
				out.writeObject(arg2);
				ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
				return in.readObject();
			}
		});
	}
}

<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

 

只需引入jdk就好

 

 完美运行，当然这里只是demo，加深理解 下载地址:https://download.csdn.net/download/qq_14926283/11271853