RPC远程调用

客户端通过定义接口，通过动态代理的方式向服务端请求运行结果，服务端通过解析字符串，来解析所要调用接口、方法、参数，并将接口实现的结果通过Socket的方式返回给客户端。

1.    服务端将接口通过map的方式映射成方法名和接口类，并启动socket连接。

package server;

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

}

package serverImpl;

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.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import server.ServerCenter;

public class ServerCenterImpl implements ServerCenter {

	private final int port = 12000;
	@SuppressWarnings("rawtypes")
	private static ConcurrentHashMap<String, Class> register = new ConcurrentHashMap<>();
	// 连接池：连接池中存在多个连接对象，每个对象都可以处理一个客户请求
	private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
	// 是否启动线程
	private static boolean isRunning = false;

	@SuppressWarnings("resource")
	@Override
	public void start() {
		ServerSocket server = null;
		try {
			server = new ServerSocket();
			server.bind(new InetSocketAddress(port));
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		isRunning = true;
		System.out.println("开启服务线程...");
		while (true) {
			Socket socket = null;
			try {
				socket = server.accept();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			executor.execute(new ServiceTask(socket));
		}

	}

	// 关停请求线程
	@Override
	public void stop() {
		// 如果有线程运行，则关闭
		if (isRunning) {
			executor.shutdown();
		}
	}

	// 注册服务
	@Override
	public void register(Class service, Class serviceImpl) {
		register.put(service.getName(), serviceImpl);
	}

	private static class ServiceTask implements Runnable {

		private Socket socket;

		public ServiceTask(Socket socket) {
			this.socket = socket;
		}

		@Override
		public void run() {
			ObjectInputStream input = null;
			ObjectOutputStream output = null;
			try {
				// 等待客户端连接
				input = new ObjectInputStream(socket.getInputStream());

				// 序列流需要顺序接收解析
				String serviceName = input.readUTF();
				String methodName = input.readUTF();
				@SuppressWarnings("rawtypes")
				Class[] parametersTypes = (Class[]) input.readObject();
				Object[] args = (Object[]) input.readObject();

				// 根据client请求找到具体接口
				Class<?> serviceClass = register.get(serviceName);
				// 根据方法名和参数类型获取方法
				Method method = serviceClass.getMethod(methodName, parametersTypes);
				// 执行方法
				Object res = method.invoke(serviceClass.newInstance(), args);

				// 返回结果
				output = new ObjectOutputStream(socket.getOutputStream());
				output.writeObject(res);

			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				if (input != null) {
					try {
						input.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				if (output != null) {
					try {
						output.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

 2. 客户端与服务端建立连接，通过JDK动态代理方式将请求的接口名、方法名、参数类型、参数列表发送给服务端。服务端解析这些字段，调用服务端的接口实现，将结果返回给客户端。

package client;

import java.io.IOException;
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 {
	
	@SuppressWarnings("unchecked")
	public static <T> T getRemoteProxyRes(Class<?> serviceInterface,InetSocketAddress addr){
		
        /**
         * 1. 类加载器 classLoader: 加载需要代理的类（HelloServic接口）
         * 2. 需要代理对象，具有哪些功能 接口
         * 3. 
         */
		return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[] {serviceInterface} , new InvocationHandler() {
			
			/*
			 * (non-Javadoc)
			 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
			 * proxy: 代理对象
			 * method: 哪个方向
			 * args ：参数列表
			 */
			@Override
			public Object invoke(Object proxy , Method method, Object[] args)
					throws Throwable {
				ObjectOutputStream output = null;
				ObjectInputStream input = null;
				@SuppressWarnings("resource")
				Socket socket = new Socket();
				socket.connect(addr);
				
				try {		
				// 发送信息
				output = new ObjectOutputStream(socket.getOutputStream());
				// 接口名
				output.writeUTF(serviceInterface.getName());
				// 方法名
				output.writeUTF(method.getName());
				// 参数类型
				output.writeObject(method.getParameterTypes());
				// 参数列表
				output.writeObject(args);
				
				// 等待服务器处理...
				
				// 读取服务器返回的结果
				input = new ObjectInputStream(socket.getInputStream());
				return input.readObject();
				
				} catch (Exception e) {
					e.printStackTrace();
					return null;
				} finally {
					if (input != null){
						try {
							input.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
					
					if (output != null){
						try {
							output.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
				}
			}
		});
	}
}