socket通信在RPC中简单应用

服务提供者：

public interface EchoService {
    String echo(String ping);
}
public class EchoServiceImpl implements EchoService{
    @Override
    public String echo(String ping) {
        return ping != null ? ping +"--> i am ok." : " I am ok.";
    }
}

服务器发布者：

/**
 * Created by hailong on 2016/11/18.
 * 服务器发布者
 */
public class RpcExporter {

	public static Executor executor =
			Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
	
	public static void exporter(String hostName, int port) throws Exception {

		// 建立socket服务端
		ServerSocket server = new ServerSocket();
		// 绑定socket与地址端口,在RPC服务发布者
		server.bind(new InetSocketAddress(hostName, port));
		try {
			while (true) {
				// 线程中，接收要来自客户端的请求
				executor.execute(new ExporterTask(server.accept()));
			}
		} finally {
			server.close();
		}
	}
	// 新启动线程接收来自客户端的请求
	private static class ExporterTask implements Runnable
	{
		Socket client = null;
		public ExporterTask(Socket client)
		{
			this.client = client;
		}
		
		public void run(){

			ObjectInputStream input = null;
			ObjectOutputStream output = null;
			
			try{
				input = new ObjectInputStream(client.getInputStream());
		        //将客户端发送的码流反序列化成对象
				String interfaceName = input.readUTF();
				Class<?> service = Class.forName(interfaceName);
				String methodName = input.readUTF();
				Class<?>[] parameterTypes = (Class<?>[])input.readObject();
				
				Object[] arguments = (Object[])input.readObject();
				Method method = service.getMethod(methodName, parameterTypes);
                // 反射调用服务实现者，获取执行结果。
				Object result = method.invoke(service.newInstance(), arguments);
				output = new ObjectOutputStream(client.getOutputStream());
                // 执行结果反序列化，通过socket发送给客户端。
				output.writeObject(result);
			}
			catch(Exception e) 
			{
				e.printStackTrace();
			}
			finally
			{
				if (output != null) 
					try {
						output.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				if (input != null)
					try {
						input.close();
					} catch (IOException e) {
						// TODO: handle exception
						e.printStackTrace();
					}
				if(client != null) {
					try {
						client.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

客户端本地服务：

/**
 * Created by hailong on 2016/11/18.
 * 客户端本地服务
 */
public class RpcImporter<S> {

	public S importer(final Class<?> serviceClass, final InetSocketAddress addr) {
                // 本地客户端的接口调用转换成JDK动态代理，在动态代理中实现远程调用
		return (S) Proxy.newProxyInstance(serviceClass.getClassLoader(), 
				new Class<?>[] {serviceClass.getInterfaces()[0]},
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						Socket socket = null;
						ObjectOutputStream output = null;
						ObjectInputStream input = null;
						
						try{
							socket = new Socket();
							socket.connect(addr);
							output = new ObjectOutputStream(socket.getOutputStream());

                            //RPC服务接口值设定到输出流（EchoServiceImpl.class）
							output.writeUTF(serviceClass.getName());
                            //设定方法名echo
							output.writeUTF(method.getName());
							output.writeObject(method.getParameterTypes());
							output.writeObject(args);
							
							input = new ObjectInputStream(socket.getInputStream());
							return input.readObject();
						}
						finally{
							if (socket != null) {
								socket.close();
							}
							if(output != null) {
								output.close();
							}
							if (input != null) {
								input.close();
							}
						}
					}
				});
	}
}

测试类：

public class RpcTest {

    public static void main (String[] args) throws Exception {

        // RPC服务器发布者
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 建立RPC服务发布者
                    RpcExporter.exporter("localhost", 8088);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // RPC客户端
        RpcImporter<EchoService> importer = new RpcImporter<EchoService>();
        // RPC客户端访问RPC服务器接口
        EchoService echo = importer.importer(EchoServiceImpl.class,
            new InetSocketAddress("localhost",8088));
        System.out.println(echo.echo("Are you ok ?"));
    }
}