java简单远程调用

public interface HelloService {
	public String say(String name);

	public int add(int a, int b);
}

 服务接口，需要在客户端与服务端都定义

public class HelloServiceImpl implements HelloService {

	@Override
	public String say(String name) {
		// 模拟方法执行需要的时间
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return "Hello " + name;
	}

	@Override
	public int add(int a, int b) {
		// 模拟方法执行需要的时间
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return a + b;
	}

}

 服务实现类，在服务端定义

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {
	/**
	 * @param interfaceClass
	 *            接口Class类型
	 * @param host
	 *            IP地址或主机
	 * @param port
	 *            服务器端监听端口号
	 * @return 代理类
	 */
	public static <T> T getProxy(Class<T> interfaceClass, final String host,
			final int port) {
		InvocationHandler handler = new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				OutputStream os = null;
				ObjectOutputStream oos = null;
				InputStream is = null;
				ObjectInputStream ois = null;
				Socket socket = null;
				try {
					socket = new Socket(host, port);
					// 创建输出流
					os = socket.getOutputStream();
					oos = new ObjectOutputStream(os);
					// 向服务器端传递要执行的方法的方法名
					oos.writeUTF(method.getName());
					// 向服务器端传递要执行的方法的参数类型
					oos.writeObject(method.getParameterTypes());
					// 向服务器端传递要执行的方法的实际参数
					oos.writeObject(args);

					// 创建输入流
					is = socket.getInputStream();
					ois = new ObjectInputStream(is);
					// 从输入流中读取服务器端执行的结果
					return ois.readObject();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					os.close();
					oos.close();
					is.close();
					ois.close();
					socket.close();
				}
				return null;
			}
		};
		return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),
				new Class[] { interfaceClass }, handler);
	}

	public static void main(String[] args) throws UnknownHostException,
			IOException {
		for (int i = 0; i < 9999; i++) {
			HelloService hs = (HelloService) getProxy(HelloService.class,
					"172.16.14.223", 2555);
			System.out.println(hs.say("jack" + i));
			System.out.println(hs.add(i + 1, i * i));
		}
	}
}

 以上是客户端的代码

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
	static class ProcessThread extends Thread {
		private Socket socket;

		public Socket getSocket() {
			return socket;
		}

		public void setSocket(Socket socket) {
			this.socket = socket;
		}

		public ProcessThread() {
			super();
		}

		public ProcessThread(Socket socket) {
			super();
			this.socket = socket;
		}

		@Override
		public void run() {

			ObjectInputStream ois = null;
			InputStream is = null;
			ObjectOutputStream oos = null;
			OutputStream os = null;
			try {
				// 获取输入流
				is = socket.getInputStream();
				ois = new ObjectInputStream(is);
				String methodName = ois.readUTF();
				System.out.println("方法名为：" + methodName);
				Class[] paramTypes = (Class[]) ois.readObject();
				Object[] args = (Object[]) ois.readObject();
				System.out.println("参数值为：");
				for (Object obj : args) {
					System.out.print(obj.toString() + ",");
				}
				System.out.println();
				// 获取输出流
				os = socket.getOutputStream();
				oos = new ObjectOutputStream(os);
				// 得到客户端请求的方法反射类型
				Method method = HelloServiceImpl.class.getMethod(methodName,
						paramTypes);
				// 执行客户端请求的方法
				HelloServiceImpl helloImpl = new HelloServiceImpl();
				Object rst = method.invoke(helloImpl, args);
				// 将执行结果写入输出流
				oos.writeObject(rst);
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			} catch (SecurityException e) {
				e.printStackTrace();
			} finally {
				try {
					ois.close();
					is.close();
					os.close();
					oos.close();
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

	public static void main(String[] args) throws IOException {
		final ServerSocket serverSocket = new ServerSocket(2555);
		final HelloServiceImpl service = new HelloServiceImpl();
		// 服务器端处理线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						// 服务器端开始监听
						Socket socket = serverSocket.accept();
						// 监听到一个客户端请求
						Thread processThread = new ProcessThread(socket);
						// 处理客户端请求
						processThread.start();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
}

 以上是服务器端的代码

 

客户端由代理类，向服务端发送远程调用请求，把方法名，方法的参数类型，方法的实际参数，传递给服务端，服务端用服务接口的实现类执行客服端请求的相应方法，将结果返回给客户端的代理类