动态代理

所谓的动态代理，即通过代理类：Proxy的代理，接口和实现类之间可以不直接发生联系，而可以在运行期实现动态关联。
java动态代理主要是使用java.lang.reflect包中的两个类

InvocationHandler类
public Object invoke(Object obj,Method method,Object[] obs)
其中第一个参数Obj指的是代理类，method是被代理的方法，obs是指被代理的方法的参数组。此方法由代理类来实现

Proxy类
protected Proxy(InvocationHandler h);
static Class getProxyClass(ClassLoader loader,Class[] interfaces);
static Object newProxyInstance(ClassLoader loader,Class[] inferfaces,InvocationHandler h);
动态代理其实是在运行时生成class，所以我们必须提供一组interface，然后告诉他class已经实现了这些Interface，而且在生成Proxy的时候，必须提供一个handler，让他来接管实际工作。

Java动态代理的优势是实现无侵入式的代码扩展，也就是方法的增强；让你可以在不用修改源码的情况下，增强一些方法；在方法的前后你可以做你任何想做的事情（甚至不去执行这个方法就可以）。

实例
第一步：创建一个接口
package com.slit;
public interface Subject {
void hello(String param);
}

第二步：实现接口
package com.slit;
public class SubjectImpl implements Subject{
@Override
public void hello(String param) {
System.out.println(“hello”+param);
}
}

第三步：创建SubjectImpl的代理类
package com.slit;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class SubjectProxy implements InvocationHandler {
private Subject subject;
public SubjectProxy(Subject subject){
this.subject=subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------begin------");
Object invoke = method.invoke(subject,args);
System.out.println("------end------");
return invoke;
}
}

第四步：编写代理类实际的调用，利用Proxy类创建代理之后的Subject类
package com.slit;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Main {
public static void main(String[] args){
Subject subject = new SubjectImpl();
InvocationHandler subjectProxy = new SubjectProxy(subject);
Subject proxyInstacne = (Subject) Proxy.newProxyInstance(subjectProxy.getClass().getClassLoader(),subject.getClass().getInterfaces(),subjectProxy);
proxyInstacne.hello(“world”);
}
}