自定义一个RPC框架

最新推荐文章于 2022-08-28 23:25:49 发布

却顾所来径

最新推荐文章于 2022-08-28 23:25:49 发布

阅读量406

点赞数 1

分类专栏： RPC

本文链接：https://blog.csdn.net/weixin_42130471/article/details/90483974

版权

RPC 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.client：客户端，传递要调用的接口名给服务端，在服务端执行完成返回结果给客户端。原理是在客户端使用一个动态代理，可动态的切换要调用的接口和方法。

2.客户端要调用的接口服务：接口服务都到ServiceCenter服务中心中册，注册后客户端只需要到ServiceCenter调用服务即可。

3.servciceCenter：服务中心。内部维护一个map，用于保存接口服务。key是接口名，value是接口实现类。通过接口名可以获取接口实现类，然后执行相应方法，得到执行结果，返回给客户端即可。

三、项目工程结构：

四、具体实现：

1.remote.procedure.call.client包

1.1Client

2.remote.procedure.call.server包

3.remote.procedure.call.test包

3.1.RPCServerTest

3.2.RPCClientTest

一、用到的技术：

1.socket通信

2.反射

3.动态代理（jdk动态代理）

4.线程池

二、架构：

1.client：客户端，传递要调用的接口名给服务端，在服务端执行完成返回结果给客户端。原理是在客户端使用一个动态代理，可动态的切换要调用的接口和方法。

2.客户端要调用的接口服务：接口服务都到ServiceCenter服务中心中册，注册后客户端只需要到ServiceCenter调用服务即可。

3.servciceCenter：服务中心。内部维护一个map，用于保存接口服务。key是接口名，value是接口实现类。通过接口名可以获取接口实现类，然后执行相应方法，得到执行结果，返回给客户端即可。

三、项目工程结构：

四、具体实现：

1.remote.procedure.call.client包

1.1Client

package remote.procedure.call.client;

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.InetSocketAddress;
import java.net.Socket;

public class Client {
	
	//serviceName：请求的接口名
	//addr:待请求服务端的ip:端口
	@SuppressWarnings("unchecked")
	public static <T>T getRemoteProxyObj(Class serviceInteface,InetSocketAddress addr){
		//newProxyInteface(a,b,c)
		/**
		 * a:类加载器：需要代理那个类（例如HelloService接口），就需要将HelloService的类加载器传如第一个参数
		 * b:需要代理的对象，具备那些功能 --这里写接口
		 * 为什么是数组：因为java中单继承，多实现，可能有多个接口
		 * 类似字符串数组：String[] str=new String[]{"aa","bb"}
		 * c:handlerIntecepter
		 */
		
		return (T)Proxy.newProxyInstance(
serviceInteface.getClassLoader(), new Class<?>[] {serviceInteface}, new InvocationHandler() {
			
			/**
			 * a:proxy:代理的对象
			 * b:method:代理对象的具体方法
			 * c:args:方法中的参数数组
			 */
			@Override
			public Object invoke(Object proxy, Method method, Object[] args){
				Socket socket =new Socket();
				ObjectOutputStream oos = null;
				ObjectInputStream ois = null;
				try {
				socket.connect(addr);
				oos = new ObjectOutputStream(socket.getOutputStream()) ;
				
				//发送接口名和方法名：字符串类型
				oos.writeUTF(serviceInteface.getName());
				oos.writeUTF(method.getName());
				
				//发送方法参数类型和方法参数
				oos.writeObject(method.getParameterTypes());
				System.out.println("client要调用的参数类型是："+method.getParameterTypes());
				oos.writeObject(args);
				
				//等待服务端处理...
				//接收服务端处理后的返回值
				ois = new ObjectInputStream(socket.getInputStream());
				Object result = ois.readObject();
				return result;
				}catch(Exception e) {
					e.printStackTrace();
					return null;
				}finally {
					try {
						if(oos != null)oos.close();
						if(ois != null)ois.close();
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
			}
		});
		
	}
}

2.remote.procedure.call.server包

2.1.HelloService

package remote.procedure.call.server;

public interface HelloService {
	public abstract String sayHi(String name);
}

2.2.HelloServiceImpl

package remote.procedure.call.server;

public class HelloServiceImpl implements HelloService{

	@Override
	public String sayHi(String name) {
		return "hi "+name;
	}

}

2.3.Server

package remote.procedure.call.server;

import java.io.IOException;

public interface Server {
	public void start();
	public void stop();
	public void register(Class service,Class serviceImpl);
}

2.4.ServerCenter

package remote.procedure.call.server;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.imageio.spi.RegisterableService;
@SuppressWarnings("unchecked")
public class ServerCenter implements Server{

	//map:服务端的所有可供客户端访问的接口，都注册到该map中
	private static Map<String, Class> serviceRegister = new HashMap<String, Class>();
	private static int port;
	//连接池：连接池中存在多个链接对象，每个连接对象都可以处理一个客户请求
	private static ExecutorService executor = 
Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors());
	
	private static boolean isRunning = false;
	
	public ServerCenter(int port) {
		this.port = port;
	}
	
	//开启服务端服务
	@Override
	public void start(){
		ServerSocket server = null;
		try {
			server = new ServerSocket();
			server.bind(new InetSocketAddress(port));
		} catch (IOException e) {
			e.printStackTrace();
		}
		isRunning = true;
		
		while(true) {
			//客户端每请求一个链接，则服务端从连接池中获取一个线程对象去处理
			Socket socket = null;
			System.out.println("start server...");
			try {
				socket = server.accept();//等待客户端连接
				
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			executor.execute(new ServiceTask(socket));
		}
		
	}

	@Override
	public void stop() {
		isRunning = false;
		executor.shutdown();
	}

	@Override
	public void register(Class service,Class serviceImpl) {
		serviceRegister.put(service.getName(), serviceImpl);
		System.out.println("注册了方法："+service.getName());
	}

	//线程处理
	private static class ServiceTask implements Runnable{

		private Socket socket;
		public ServiceTask() {
		}

		public ServiceTask(Socket socket) {
			this.socket = socket;
		}
		
		@Override
		public void run() {//线程所作的事情
			System.out.println("开启了一个新线程...");
			
			ObjectOutputStream oos =null;
			ObjectInputStream ois = null;
			
			try {
				//接受客户端连接及请求，处理该请求
				ois= new ObjectInputStream(socket.getInputStream());
				//ObjectInputStream对接受顺序有严格要求
				String serviceName = ois.readUTF();
				String methodName = ois.readUTF();
				Class[] parameterTypes = (Class[]) ois.readObject();
				Object[] args = (Object[]) ois.readObject();
				
				//根据客户请求找到具体的接口,如果没有注册，则注册一个
				Class serviceClass = serviceRegister.get(serviceName);
				
				Method method = serviceClass.getMethod(methodName, parameterTypes);
				Object result=method.invoke(serviceClass.newInstance(), args);
				
				oos = new ObjectOutputStream(socket.getOutputStream());
				oos.writeObject(result);
			}catch(Exception e) {
				e.printStackTrace();
			}
			finally {
					try {
						if(oos != null)oos.close();
						if(ois != null)ois.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
			}
		}
		
	}
}

3.remote.procedure.call.test包

3.1.RPCServerTest

package remote.procedure.call.test;

import remote.procedure.call.server.HelloService;
import remote.procedure.call.server.HelloServiceImpl;
import remote.procedure.call.server.Server;
import remote.procedure.call.server.ServerCenter;

public class RPCServerTest {
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				Server server = new ServerCenter(9999);
				server.register(HelloService.class, HelloServiceImpl.class);
				server.start();
			}
		}).start();
		
	}
}

3.2.RPCClientTest

package remote.procedure.call.test;

import java.net.InetSocketAddress;

import remote.procedure.call.client.Client;
import remote.procedure.call.server.HelloService;

public class RPCClientTest {
	public static void main(String[] args) throws ClassNotFoundException {
		HelloService service = Client.getRemoteProxyObj(
		    Class.forName("remote.procedure.call.server.HelloService"), 
                    new InetSocketAddress("127.0.0.1",9999));
		System.out.println(service.sayHi("小明"));
	}
}

却顾所来径

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
自定义一个RPC框架

目录一、用到的技术：1.socket通信2.反射3.动态代理（jdk动态代理）4.线程池二、架构：1.client：客户端，传递要调用的接口名给服务端，在服务端执行完成返回结果给客户端。原理是在客户端使用一个动态代理，可动态的切换要调用的接口和方法。2.客户端要调用的接口服务：接口服务都到ServiceCenter服务中心中册，注册后客户端只需要到ServiceC...
复制链接

扫一扫