这是一个简单的原生RPC例子，用了JDK动态代理,反射,JDK自带的序列化和反序列化以及JAVA原生Socket通信。关于原理的文章很多,可以参考一下其他人的，这里就稍微借鉴一下别人的时序图
1、首先介绍一下项目图
一个RPC Maven项目,其中有三个模块,分别是API、Server、Client。API模块放公共类,Server模块来做服务端,Client模块做客户端。
二、API模块
这里是项目结构图
package org.Simple.API;
//公共接口类
public interface HelloService {
String sayHello(String name);
Person getPerson(String name);
}
package org.Simple.API;
import java.io.Serializable;
import java.util.Arrays;
/*公共网络通信类，通过序列化该类,将客户端调用接口、方法、参数、参数类型封装，然后服务端反序列化,再通过反射,调取相应实现类的方法。*/
public class NetModel implements Serializable{
private static final long serialVersionUID = 1L;
private String className; //接口名
private String method; //方法名
private Object[] args ; //参数
private String[] types; //参数类型
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public Object[] getArgs() {
return args;
}
public void setArgs(Object[] args) {
this.args = args;
}
public String[] getTypes() {
return types;
}
public void setTypes(String[] types) {
this.types = types;
}
@Override
public String toString() {
return "NetModel [className=" + className + ", method=" + method + ", args=" + Arrays.toString(args)
+ ", types=" + Arrays.toString(types) + "]";
}
}package org.Simple.API;
import java.io.Serializable;
//普通公共bean
public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
package org.Simple.API;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializeUtils {
/**
* 序列化
* @param object
* @return
* @throws IOException
*/
public static byte[] serialize(Object object) throws IOException {
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(os);
outputStream.writeObject(object);
outputStream.flush();
byte[] byteArray = os.toByteArray();
outputStream.close();
os.close();
return byteArray;
}
/**
* 反序列化
* @param buf
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public static Object deSerialize(byte[] buf) throws IOException, ClassNotFoundException {
ByteArrayInputStream is = new ByteArrayInputStream(buf);
ObjectInputStream inputStream = new ObjectInputStream(is);
Object object = inputStream.readObject();
inputStream.close();
is.close();
return object;
}
}
2、接下来讲一下Server模块
先展示一下项目结构图
这里重点讲一下RPCServer,本人使用JDK自带的ServerSocket来进行进行,服务端收到数据后,对数据进行处理,处理完把结构返回给客户端
package org.Simple.S;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import org.Simple.API.NetModel;
import org.Simple.API.SerializeUtils;
//Server服务端,这里使用JDK自带的ServerSocket来进行进行,服务端收到数据后,对数据进行处理,处理完把结构返回给客户端
public class RPCServer {
public static void main(String[] args)
{
try {
openServer();
} catch (Exception e) {
e.printStackTrace();
}
}
//这个方法用来启动服务端,然后接受数据,返回处理完的结果
public static void openServer() throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
try {
System.out.println("服务开启");
while(true) {
Socket socket = serverSocket.accept();
System.out.println(socket.getInetAddress()+"-connected");
InputStream in = socket.getInputStream();
byte[] buf = new byte[1024];
in.read(buf);
byte[] formatDate = formatData(buf);
OutputStream out = socket.getOutputStream();
out.write(formatDate);
socket.close();
}
} catch (Exception e) {
e.printStackTrace();
serverSocket.close();
}
}
/*这个方法用来处理接收到的数据,通过反序列化得到传过来的通信类NetModel,然后得到接口名,方法名,参数,参数类型,
最后通过JDK反射,来调取实现类的方法,并将调取结果,序列化为byte数组,然后返回
*/
public static byte[] formatData(byte[] bs){
try {
//将收到的byte数组反序列化为NetModel类型,然后通过反射调用HelloServiceImpl实现类的方法
NetModel netModel = (NetModel)SerializeUtils.deSerialize(bs);
String className = netModel.getClassName();
String[] types = netModel.getTypes();
Object[] args = netModel.getArgs();
/*这里简单通过Map来做接口映射到实现类,从map中取
Map<String, String> map = new HashMap<String,String>();
map.put("org.Simple.API.HelloService", "org.Simple.S.HelloServiceImpl");
Class<?> clazz = Class.forName(map.get(className));
*/
//也可以把这个键值放到配置文件下，通过配置文件读取
Class<?> clazz = Class.forName(getPropertyValue(className));
Class<?> [] typeClazzs = null;
if(types!=null) {
typeClazzs = new Class[types.length];
for (int i = 0; i < typeClazzs.length; i++) {
typeClazzs[i] = Class.forName(types[i]);
}
}
Method method = clazz.getMethod(netModel.getMethod(),typeClazzs);
Object object = method.invoke(clazz.newInstance(), args);
byte[] byteArray = SerializeUtils.serialize(object);
return byteArray;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
//通过key去properties文件中取值
public static String getPropertyValue(String key) throws IOException {
Properties properties = new Properties();
FileInputStream in = new FileInputStream("src/main/resources/config.properties");
properties.load(in);
in.close();
return properties.getProperty(key);
}config.properties
org.Simple.API.HelloService=org.Simple.S.HelloServiceImplpackage org.Simple.S;
import org.Simple.API.HelloService;
import org.Simple.API.Person;
//简单实现类
public class HelloServiceImpl implements HelloService {
public String sayHello(String name) {
return "hello,"+name;
}
public Person getPerson(String name) {
Person person = new Person();
person.setName(name);
person.setAge(20);
return person;
}
}
三、最后讲一下Client客户端模块
package org.Simple.C;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import org.Simple.API.HelloService;
import org.Simple.API.SerializeUtils;
/*RPC客户端,也是用Socket与服务端进行通信*/
public class RPCClient {
//Socket发送消息给服务端,并反序列化服务端返回的数据,返回给方法调用者
public static Object send(byte[] bs) {
try {
Socket socket = new Socket("127.0.0.1", 9999);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bs);
InputStream in = socket.getInputStream();
byte[] buf = new byte[1024];
in.read(buf);
Object formatDate = SerializeUtils.deSerialize(buf);
socket.close();
return formatDate;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
//main方法,运行客户端
public static void main(String[] args) {
HelloService helloService = ProxyFactory.getInstance(HelloService.class);
System.out.println("say:"+helloService.sayHello("zhangsan"));
System.out.println("Person:"+helloService.getPerson("zhangsan"));
}
}这里重点讲一下,算是本篇文章的中心，代理工厂类ProxyFactory。通过调用方法getInstance(),动态代理生成代理接口类。代理接口调用方法的时候,该代理类会去调用InvocationHandler 中的invoke方法，在invoke方法中能得到代理接口的全名,调用的方法,参数和参数类型，然后将这些参数封装在NetModel中,然后序列化NetModel,将序列化后的byte数组,调用RPCClient中的send方法,将消息发送给服务端,服务端然后将消息反序列化,得到接口名,方法名,参数,参数类型,最后通过JDK反射,来调取实现类的方法,并将调取结果,序列化为byte数组,然后返回。send再将byte数组反序列化对象,返回给调用者。最后invoke再将send方法的返回值返回，这个返回值就是客户端调用接口的返回值了。这个过程也就是客户端与服务端通信的过程
package org.Simple.C;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.Simple.API.NetModel;
import org.Simple.API.SerializeUtils;
public class ProxyFactory {
private static InvocationHandler handler = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
NetModel netModel = new NetModel();
Class<?>[] classes = proxy.getClass().getInterfaces();
String className = classes[0].getName();
netModel.setClassName(className);
netModel.setArgs(args);
netModel.setMethod(method.getName());
String [] types = null;
if(args!=null) {
types = new String [args.length];
for (int i = 0; i < types.length; i++) {
types[i] = args[i].getClass().getName();
}
}
netModel.setTypes(types);
byte[] byteArray = SerializeUtils.serialize(netModel);
Object send = RPCClient.send(byteArray);
return send;
}
};
@SuppressWarnings("unchecked")
public static <T> T getInstance(Class<T> clazz) {
return (T) Proxy.newProxyInstance(clazz.getClassLoader(),
new Class[]{clazz}, handler );
}
}
最后演示一下项目,首先跑动服务端RPCServer的main方法，得到该截图
然后再跑一下客户端的RPCClient的main方法,就会得到一下结果
讲到这里，本篇文章到此也就结束了,中间可能存在一些问题,有一些不够严谨完善的地方,希望大家体谅体谅。有问题的话,欢迎大家留意,交流交流。
最后附上本项目github的地址https://github.com/Albert-WuBinBin/RPC
扫一扫
1732
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
