在上篇博客中讨论到java的静态代理， 就是通过组合的方法，前提是委托类需要实现一个接口，代理类也实现这个这个 接口，从何组合两个类，让代理类给委托类添加功能！
知道java的静态代理，我们又遇到一个问题，我们又遇到一个问题，是不是每个类要添加功能，都得重新写个类呢！怎么才能实现同样的代码，可以在其他类都能起作用！
这就是java动态代理的内容，在java中通Proxy类好AnnotationHandler接口来实现动态代理，我先尝试自己写一个自己的动态代理！
一.实现简单的自定义动态代（没考虑参数，接口） 只能称之为 伪java动态代理
1、接口：
public interface ICommonInterface {
//nothing
public void addUser();
public void delete();
}
2、需要代理的类（委托类）
/*
* 自定义java动态代理
* 这是一个委托类
*/
public class DelegationClass implements ICommonInterface { public void addUser()
{
System.out.println("add user success");
} public void delete()
{
System.out.println("delete user success");
} }
3.代理类
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; public class ProxyClass { //定义委托类对象（组合对象）
private Object target=null;
public ProxyClass(Object target)
{
this.target=target; //构造方法初始化委托对象实例
} public void invokeFunction(Method m) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
{
System.out.println("before start.....");
m.invoke(target);
} }
4.测试类
import java.lang.reflect.InvocationTargetException;
public class Test {
public static void main(String [] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException
{
//获取委托对象
DelegationClass target=new DelegationClass();
//获取代理对象
ProxyClass pro=new ProxyClass(target);
//传递委托对象调用方法，调用代理对象对应的方法实现
pro.invokeFunction(target.getClass().getMethod("addUser"));
pro.invokeFunction(target.getClass().getMethod("delete"));
}
}
结果：
before start.....
add user success
before start.....
delete user success
我们可以看到实现的简单代理类，代理类没有涉及到接口，也没涉及到参数传递.....这些条件导致这个代理很好实现，现实中，我们得考虑接口，考虑参数 ！
我们来看看java怎么实现动态代理的：
java中有两个类：InvocationHandler 和Proxy 其中Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现
我们来看看实例：
业务接口：
public interface ICommonInterface {
//nothing
public void addUser();
public void delete();
}
业务接口实现：
public class DelegationClass implements ICommonInterface {
public void addUser()
{
System.out.println("add user success");
}
public void delete()
{
System.out.println("delete user success");
}
}
InvocationHandler实现，需要在接口方法调用前加入一部分其他逻辑
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class Interceptor implements InvocationHandler { //声明一个委托类的对象
private Object target=null;
public Interceptor(Object target)
{
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
doBefore();
method.invoke(target, args);
return null;
}
public void doBefore()
{
System.out.println("start ...............");
} }
测试类：
public class Test {
public static void main(String [] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException
{
//获取委托对象
DelegationClass target=new DelegationClass();
//获取InvocationHanlder的实例对象
Interceptor inter=new Interceptor(target);
//获取代理对象(实际上Proxy根据target的类加载器，接口和InvocationHandle生成一个类，再生成一个对象)
ICommonInterface de= (ICommonInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), inter);
//测试这个对象
System.out.println(de.getClass().getInterfaces()[0].getName());
de.addUser();
de.delete();
}
}
结果：
com.test.proxy.javaproxy.ICommonInterface
start ...............
add user success
start ...............
delete user success