package xhj;interface CalculatePtl {int multiply(int a, int b);float divide(int a, int b);
}class CalculateImpl implements CalculatePtl {@Overridepublic int multiply(int a, int b) {// TODO Auto-generated method stubreturn a * b;}@Overridepublic float divide(int a, int b) {// TODO Auto-generated method stubreturn  (float)a / b;}}class CalculateProxy implements CalculatePtl {private CalculateImpl cImpl;public CalculateProxy (CalculateImpl cImpl) {this.cImpl = cImpl;}@Overridepublic int multiply(int a, int b) {// TODO Auto-generated method stub//预处理int r = cImpl.multiply(a, b);//后处理return r;}@Overridepublic float divide(int a, int b) {// TODO Auto-generated method stub//预处理float r = cImpl.divide(a, b);//后处理return r;}}public class StaticProxyExample {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubCalculateImpl cImpl = new CalculateImpl();CalculateProxy proxy = new CalculateProxy(cImpl);int result = proxy.multiply(5, 3);System.out.println("multiply 5 3 = " + result);float dresult = proxy.divide(5, 3);System.out.println("divide 5 3 = " + dresult);}}

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) // 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl) // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
Object invoke(Object proxy, Method method, Object[] args) 

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler }); 

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, new Class[] { Interface.class },  handler ); 

package xhj;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;interface CalculateProtocol {int add (int a, int b);int subtract(int a, int b);
}class CalculateServer implements CalculateProtocol {@Overridepublic int add(int a, int b) {// TODO Auto-generated method stubreturn a + b;}@Overridepublic int subtract(int a, int b) {// TODO Auto-generated method stubreturn a - b;}}class CalculateHandler implements InvocationHandler {private Object objOriginal;public CalculateHandler(Object object) {this.objOriginal = object;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {// TODO Auto-generated method stub//预处理Object result = method.invoke(this.objOriginal, args);//后处理return result;}}public class DynamicProxyExample {public static void main(String[] args) {CalculateProtocol server = new CalculateServer();InvocationHandler handler = new CalculateHandler(server);CalculateProtocol client = (CalculateProtocol) Proxy.newProxyInstance(server.getClass().getClassLoader(), server.getClass().getInterfaces(), handler);//创建一个clientint r = client.add(5, 3);System.out.println("add 5 3 = " + r);r = client.subtract(10, 2);System.out.println("subtract 10 2 = " + r);}
}