Java动态代理类(包括客户端服务端使用反射机制来代理的)

package reflection.remotecall;

import java.util.Date;

public interface IHelloService {

public String echo(String msg);
public Date getTime();

}

package reflection.remotecall.impl;

import java.util.Date;

import reflection.remotecall.IHelloService;

public class HelloServiceImpl implements IHelloService {

public String echo(String msg) {

return "echo:"+msg;
}

public Date getTime() {

return new Date();
}

}

package reflection.proxyfactory;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import reflection.remotecall.IHelloService;
import reflection.remotecall.impl.HelloServiceImpl;

/**
* 创建一个实现了HelloService 接口的动态代理类的实例 参数 helloService 引用被代理的HelloService 实例
*/
public class HelloServiceProxyFactory {

public static IHelloService getHelloServiceProxy(final IHelloService helloService) {

// 创建一个实现了InvocationHandler接口的匿名类的实例
InvocationHandler handler = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object args[])throws Exception {

System.out.println("before calling " + method); // 预处理
Object result = method.invoke(helloService, args);
// 调用被代理的HelloService 实例的方法
System.out.println("after calling " + method); // 事后处理
return result;
}
};

Class classType = IHelloService.class;

return (IHelloService)Proxy.newProxyInstance(classType.getClassLoader(), new Class[]{classType}, handler);
}

public static void main(String[] args) {

IHelloService helloService = new HelloServiceImpl();
IHelloService helloServiceProxy = HelloServiceProxyFactory.getHelloServiceProxy(helloService);

System.out.println("动态代理类的名字为: " + helloServiceProxy.getClass().getName());

System.out.println(helloServiceProxy.echo("linwei"));
}

}

package reflection.client;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

import reflection.util.Call;

public class SimpleClient {

public void invoke() throws Exception {

Socket socket = new Socket("localhost", 8000);

OutputStream out = socket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
InputStream in = socket.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in);

Call call = new Call("reflection.remotecall.IHelloService","echo",new Class[]{String.class},new Object[]{"Hello"});
//向服务器发送Call对象
oos.writeObject(call);
//接收包含了执行结果的Call对象
call = (Call)ois.readObject();
System.out.println("结果是: " + call.getResult());

ois.close();
oos.close();
socket.close();

}

public static void main(String[] args) throws Exception {
new SimpleClient().invoke();
}

}

package reflection.server;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
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 reflection.remotecall.impl.HelloServiceImpl;
import reflection.util.Call;

public class SimpleServer {

//该Map用来存放远程对象的
private Map remoteObjects = new HashMap();

/*
* 把一个远程对象放到缓存中去
*/
public void register(String className, Object remoteObject) {
remoteObjects.put(className, remoteObject);
}

/**
* 远程服务器提供的服务方法
* @throws Exception
*/
public void service() throws Exception {

ServerSocket serverSocket = new ServerSocket(8000);
System.out.println("服务器已经启动了!");

while (true) {
Socket socket = serverSocket.accept();

InputStream in = socket.getInputStream();
//把取到的输入流从新封装成一个  对象输入流
ObjectInputStream ois = new ObjectInputStream(in);

OutputStream out = socket.getOutputStream();
//把获取到的输出流 转化为 对象输出流
ObjectOutputStream oos = new ObjectOutputStream(out);

//接收客户端发送的Call对象
Call call = (Call) ois.readObject();
System.out.println("call is " + call);
//调用相关对象的执行方法(采用反射机制来调用)
call = invoke(call);
//向客户端发送包含了执行结果的Call对象
oos.writeObject(call);

ois.close();
oos.close();
socket.close();
}
}

public Call invoke(Call call) {

Object result = null;

try {
String className = call.getClassName();
String methodName = call.getMethodName();
Object[] params = call.getParamValue();
Class classType = Class.forName(className);
Class[] paramTypes = call.getParamTypes();

//通过 方法名字和方法参数类型 来决定调用何种方法
Method method = classType.getMethod(methodName, paramTypes);

//通过类名，从缓存中取出相关的远程对象
Object remoteObject = remoteObjects.get(className);
if(remoteObject == null) {
throw new Exception(className + "远程对象不存在");
} else {

result = method.invoke(remoteObject, params);
}
} catch (Exception e) {
e.printStackTrace();
result = e;
}

call.setResult(result);

return call;
}

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

SimpleServer simpleServer = new SimpleServer();
//把事先创建的HelloServiceImpl 对象加入到服务器的缓存中
simpleServer.register("reflection.remotecall.IHelloService",new HelloServiceImpl());
simpleServer.service();
}
}