1. 代理的分类：
静态代理：每个代理类只能为一个接口服务
动态代理：可以通过一个代理类完成全部的代理功能（由JVM生成实现一系列接口的代理类，即：生成实现接口的类的代理）
2. 动态代理：
在Java中要想实现动态代理机制，需要 java.lang.reflect.InvocationHandler 接口和 java.lang.reflect.Proxy 类的支持
java.lang.reflect.InvocationHandler 接口的定义如下：
public interface InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }
Object proxy：被代理的对象
Method method：要调用的方法
Object[] args：方法调用时传递的参数
注意：并不是对象的所有方法均通过代理来完成，对如继承自Object的方法，只将hashCode()、equals()、toString()转交给InvocationHandler来处理。
可以通过Proxy中的getProxyClass()或newProxyInstance()方法获取代理
其中newProxyInstance()方法定义如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
ClassLoader loader：类加载器
Class<?>[] interfaces：要实现的接口
InvocationHandler h：InvocationHandler子类的实例对象
下面来实现动态代理：
首先定义接口：
1 public interface Sourceable { 2 void function(); 3 }
然后定义实现类：
1 public class Source implements Sourceable { 2 3 @Override 4 public void function() { 5 System.out.println("function"); 6 } 7 }
定义工具类：
1 import java.lang.reflect.Constructor; 2 import java.lang.reflect.InvocationHandler; 3 import java.lang.reflect.Method; 4 import java.lang.reflect.Proxy; 5 6 public class SourceableProxyUtil { 7 private Sourceable source; 8 9 public SourceableProxyUtil(Sourceable source) { 10 super(); 11 this.source = source; 12 } 13 14 public Sourceable getProxy() throws Exception { 15 Class<Sourceable> clazzSource = (Class<Sourceable>) Proxy 16 .getProxyClass(source.getClass().getClassLoader(), source 17 .getClass().getInterfaces()); 18 Constructor<Sourceable> constructor = clazzSource 19 .getConstructor(InvocationHandler.class); // 没有无参构造函数 20 21 return constructor.newInstance(new InvocationHandler() { 22 23 @Override 24 public Object invoke(Object proxy, Method method, Object[] args) 25 throws Throwable { 26 System.out.println("before"); 27 Object retVal = method.invoke(source, args); 28 System.out.println("after"); 29 return retVal; 30 } 31 }); 32 } 33 }
但是，使用getProxyClass()方式过于复杂，改用newProxyInstance()：
1 import java.lang.reflect.Constructor; 2 import java.lang.reflect.InvocationHandler; 3 import java.lang.reflect.Method; 4 import java.lang.reflect.Proxy; 5 6 public class SourceableProxyUtil { 7 private Sourceable source; 8 9 public SourceableProxyUtil(Sourceable source) { 10 super(); 11 this.source = source; 12 } 13 14 public Sourceable getProxy() throws Exception { 15 return (Sourceable)Proxy.newProxyInstance(source.getClass().getClassLoader(), 16 source.getClass().getInterfaces(), new InvocationHandler() { 17 18 @Override 19 public Object invoke(Object proxy, Method method, 20 Object[] args) throws Throwable { 21 System.out.println("before"); 22 Object retVal = method.invoke(source, args); 23 System.out.println("after"); 24 return retVal; 25 } 26 }); 27 } 28 }
测试代码：
1 public class Main { 2 3 public static void main(String[] args) throws Exception { 4 Sourceable source = new Source(); 5 Sourceable proxy = new SourceableProxyUtil(source).getProxy(); 6 proxy.function(); 7 } 8 }
测试结果：
before
function
after
可以看出，代理类能够正常使用。
但是上述方式只能用于生成Sourceable接口的代理类，可以进一步将其抽象得到通用的代理类生成工具：
1 import java.lang.reflect.InvocationHandler; 2 import java.lang.reflect.Method; 3 import java.lang.reflect.Proxy; 4 5 public final class ProxyUtil { 6 public static Object getProxy(final Object target) throws Exception { 7 return Proxy.newProxyInstance(target.getClass().getClassLoader(), 8 target.getClass().getInterfaces(), new InvocationHandler() { 9 10 @Override 11 public Object invoke(Object proxy, Method method, 12 Object[] args) throws Throwable { 13 System.out.println("before"); 14 Object retVal = method.invoke(target, args); 15 System.out.println("after"); 16 return retVal; 17 } 18 }); 19 } 20 }
这样，无论任何类型的对象都可以通过此种方法获得相应的代理对象。此时，测试代码如下：
1 public class Main { 2 3 public static void main(String[] args) throws Exception { 4 // TODO Auto-generated method stub 5 Sourceable proxy = (Sourceable)ProxyUtil.getProxy(new Source()); 6 proxy.function(); 7 } 8 }
3. 抽取切面：
将上述代码中的目标方法执行前后的操作进一步地抽象，将其抽取为切面。将切面代码进行封装得到通告。
定义通告接口：
1 public interface Advice { 2 void before(); 3 void after(); 4 }
改写工具类：
1 import java.lang.reflect.InvocationHandler; 2 import java.lang.reflect.Method; 3 import java.lang.reflect.Proxy; 4 5 public final class ProxyUtil { 6 public static Object getProxy(final Object target, final Advice advice) throws Exception { 7 return Proxy.newProxyInstance(target.getClass().getClassLoader(), 8 target.getClass().getInterfaces(), new InvocationHandler() { 9 10 @Override 11 public Object invoke(Object proxy, Method method, 12 Object[] args) throws Throwable { 13 advice.before(); 14 Object retVal = method.invoke(target, args); 15 advice.after(); 16 return retVal; 17 } 18 }); 19 } 20 }
此时的测试代码为：
1 public class Main { 2 3 public static void main(String[] args) throws Exception { 4 Sourceable proxy = (Sourceable)ProxyUtil.getProxy(new Source(), new Advice() { 5 6 @Override 7 public void before() { 8 // TODO Auto-generated method stub 9 System.out.println("before"); 10 } 11 12 @Override 13 public void after() { 14 // TODO Auto-generated method stub 15 System.out.println("after"); 16 } 17 }); 18 proxy.function(); 19 } 20 }
此种方式更具有普遍适用性，无论对于任意类型都可以产生相对应的代理对象，同时可以自定义所要进行的操作（通过通告）。
在整个过程中需要手动写的只有通告Advice
4. AOP编程：
AOP（Aspect-Oriented Programming）可以通过代理方式完成诸如：安全控制、事务管理、性能统计、日志记录、错误处理...等功能。
在实际过程中，更多是通过getter/setter方式传递target与advice的：
1 import java.lang.reflect.InvocationHandler; 2 import java.lang.reflect.Method; 3 import java.lang.reflect.Proxy; 4 5 public class ProxyFactoryBean { 6 7 private Object target; 8 private Advice advice; 9 10 11 public Object getTarget() { 12 return target; 13 } 14 15 16 public void setTarget(Object target) { 17 this.target = target; 18 } 19 20 21 public Advice getAdvice() { 22 return advice; 23 } 24 25 26 public void setAdvice(Advice advice) { 27 this.advice = advice; 28 } 29 30 31 public Object getProxy() { 32 33 return Proxy.newProxyInstance(target.getClass().getClassLoader(), 34 target.getClass().getInterfaces(), new InvocationHandler() { 35 36 @Override 37 public Object invoke(Object proxy, Method method, 38 Object[] args) throws Throwable { 39 advice.before(); 40 Object retVal = method.invoke(target, args); 41 advice.after(); 42 return retVal; 43 } 44 }); 45 }; 46 }
通过AOP的方式可以在运行时动态地将代码切入到类的指定方法、指定位置上。
Spring框架的核心即是IoC和AOP。