在Spring的有两个核心：IOC与AOP，AOP又是基于动态代理模式实现的。所以要了解SpringAOP是如何设计的之前，还是先了解一下Java中的动态代理比较好。
认识代理模式
代理模式是这么描述的：
代理模式是为其他对象提供一种代理以控制对这个对象的访问
代理对象的功能：
通过创建一个代理对象，用这个代理对象去代理真实的对象，客户端得到这个代理对象后，对客户端并没有什么影响，就跟真实的对象一样（因为代理对象和真是对象实现了同一接口）。
下面看看代理模式的类图：
解说：
RealSubject是真实对象。
Proxy是代理者，他来代理RealSubject，表现在Proxy对象拥有RealSubject实例，真正执行的还是realSubject.request()。
Client，代理模式的客户，他是直接与Subject接口打交道。
Proxy与RealSubject实现了同一接口Subject，所以Client看到的Proxy就跟看到了RealSubject一样。
对代理模式分析一下：
举一个现实中的例子：现实生活中有很多专卖店，手机提供商等。
做手机的：中华酷联、小米、三星、苹果、魅族等等。
做家电的：海尔、美的等等。
他们其实就是真是的对象，提供手机的。
各大品牌专卖店：海尔专卖店、诺基亚专卖店、三星专卖店、苹果专卖店
他们其实就是代理商，他们不提供手机，他们提供的是额外的服务，例如和电信运营商结合提供买手机送话费服务。
实例说明：
// 接口Foo就充当代理模式中的Subject角色
public interface Foo {
public void sayFoo(String name);
}
// FooImpl充当了RealSubject角色，对Foo提供的方法做了具体实现
public class FooImpl implements Foo{
public void sayFoo(String name) {
System.out.println("手机卖给 "+name);
}
}
// FooProxy是代理者
public class FooProxy implements Foo{
Foo foo=null;
public FooProxy(Foo foo){
this.foo=foo;
}
// 处理请求时，还是有真实的对象来处理的
public void sayFoo(String name) {
if(foo!=null){
foo.sayFoo(name);
}
}
}
// 客户端调用
public class Client {
public static void main(String[] args){
Foo proxy=new FooProxy(new FooImpl());
proxy.sayFoo("zhang san");
}
}
// 执行结果：
//手机卖给 zhang san
如果只是像上面那样使用代理模式，还不如不使用代理模式。
代理模式：用于控制对真实对象的访问。这种控制是多方面的，实际应用中，代理模式又被分为下列几种：
就拿最后一种来说吧，智能引用，在访问对象时附加一些操作（这块AOP中要用到）。
接下来，专卖店（代理商）对象要提供一些附加功能：
public class FooProxy implements Foo{
Foo foo=null;
public FooProxy(Foo foo){
this.foo=foo;
}
public void sayFoo(String name) {
if(foo!=null){
before();
foo.sayFoo(name);
after();
}
}
public void before(){
System.out.println("before: 介绍手机，介绍服务 .....");
}
public void after(){
System.out.println("after: 送话费 .....");
}
}
在真实的对象处理请求的前后，附加了两个功能：before(),after()。Client的代码不需要改变，执行的结果是:
before: 介绍手机，介绍服务 ..... 手机卖给 zhang san after: 送话费 .....
这样就达到了附加功能的目的，这样手机就卖的多了。
动态代理模式
AOP使用了代理模式，但并非这个，这个代理模式是设计模式中的代理模式，在Java中有一种特有的代理模式，也称为动态代理模式。
假若上面的例子是卖手机的，现在系统中要有卖家电的，那我可以在系统中添加如下设计：
做法还是这样的：
public interface Hello {
public void sayHello(String hello);
}
public class HelloImpl implements Hello {
public void sayHello(String hello) {
System.out.println("hello, "+hello);
}
}
public class HelloProxy implements Hello{
Hello hello;
public HelloProxy(Hello hello){
this.hello=hello;
}
public void sayHello(String hello) {
this.hello.sayHello(hello);
}
}
public class Client {
public static void main(String[] args){
Foo proxy=new FooProxy(new FooImpl());
proxy.sayFoo("zhang san");
Hello hello=new HelloProxy(new HelloImpl() );
hello.sayHello("li si");
}
}
如果有更多的呢，例如要加入卖床上用品，卖办公用品，卖相机等数码产品。。。。
提供商直接与客户打交道，这事是很困难的，操作性不好，肯定得有代理商的参与。难道在系统中都为他们设计一个代理？
上面的例子中，一个代理商只代理一种产品，代理商太多的话，提供商与代理商打交道也麻烦，客户与代理商打交道也麻烦，那么多该选哪一个呀？
对于代理商来说，只代理一样产品，对那样产品的依赖性太大了，那样小命就捏在提供商手里了，最重要的是不是很赚钱。因此就会想着要多代理几样产品。
于是商城就出现了，例如国美，京东等，这里不去管国美，京东到底是怎样操作的，只是为了理解动态代理需要。
那么商城反映到程序中就是：
public class FooProxy implements Foo, Hello ,,,,更多接口{
Foo foo=null;
Hello hello=null;
// 更多真实对象
public FooProxy(Foo foo){
this.foo=foo;
}
public FooProxy(Hello hello){
this.hello=hello;
}
这样一来，一个大的代理商（商城）就出现了，可以代理很多产品了。
这样一来，业务实现了，但是我们程序员悲催了。尼玛呀，每添加一类商品，程序猿就得调整一个或者或者多个xxxProxy类。这样程序员太累，这样的设计也违反了开闭原则。
咋办呢，那些大牛们就根据JVM的特性和ClassLoader设计出来动态代理。使用动态代理，可以动态的生成xxxProxy类呢,这样就避免了编程的方式了。
动态代理涉及到了一个接口和一个类：InvocationHandler、Proxy。
Proxy就是代理了，Proxy的对象就是上面程序中的fooProxy,helloProxy。同时他也提供了生成代理类的静态方法，生成代理对象的静态方法。
InvocationHandler就是利用反射调用真实对象的接口。
现在利用动态代理来改造上面程序，Foo接口，FooImple用做调整。附加一个Handler就行了：
public class MyInvokerHandler implements InvocationHandler {
private Foo foo;
public MyInvokerHandler(){}
public MyInvokerHandler(Foo foo){
this.foo=foo;
}
public void beforeInvoke(){
System.out.println("doSomething before invoke");
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeInvoke();
method.invoke(foo,args); // 通过反射调用
afterInvoke();
return null;
}
public void afterInvoke(){
System.out.println("doSomething after invoke");
}
}
// Client程序调整为：
public class Client {
public static void main(String[] args){
FooImpl foo=new FooImpl();
MyInvokerHandler handler=new MyInvokerHandler(foo);
// proxy是代理对象，它既是Proxy的对象，也是Foo的对象
Object proxy=Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[]{Foo.class},handler);
Foo fooProxy=(Foo)proxy;
fooProxy.sayFoo("zhang san");
}
}
// 程序执行结果：
doSomething before invoke
手机卖给 zhang san
doSomething after invoke
这样不用写代理类就完成了上面的功能。
要让它也实现Hello接口呢 ？
再对上面的程序调整：
public class MyInvokerHandler implements InvocationHandler {
private Foo foo;
private Hello hello;
public MyInvokerHandler(){}
public MyInvokerHandler(Foo foo){
this.foo=foo;
}
public void setFoo(Foo foo) {
this.foo = foo;
}
public void setHello(Hello hello) {
this.hello = hello;
}
public void beforeInvoke(){
System.out.println("doSomething before invoke");
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeInvoke();
System.out.println(method.getName());
if(method.getName().equals("sayHello") && proxy instanceof Hello) {
method.invoke(hello,args); // 通过反射调用
}else if(method.getName().equals("sayFoo") && proxy instanceof Foo){
method.invoke(foo,args);
}
afterInvoke();
return null;
} public void afterInvoke(){
System.out.println("doSomething after invoke");
}
}
//Client调整为：
public class Client {
public static void main(String[] args){
FooImpl foo=new FooImpl();
HelloImpl hello=new HelloImpl();
MyInvokerHandler handler=new MyInvokerHandler();
handler.setFoo(foo);
handler.setHello(hello);
// proxy是代理对象，它既是Proxy的对象，也是Foo的实例 ,还是Hello的实例
Object proxy=Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[]{Foo.class,Hello.class},handler);
Foo fooProxy=(Foo)proxy;
fooProxy.sayFoo("zhang san");
Hello helloProxy=(Hello)proxy;
helloProxy.sayHello("li si");
}
}
//执行结果是：
doSomething before invoke
sayFoo
手机卖给 zhang san
doSomething after invoke
doSomething before invoke
sayHello
hello, li si
doSomething after invoke
// 如果还要添加更多功能，只需要调整这个Handler即可。
猜想动态生成的代理类
现在可以猜测一下，动态生成的代理类到底是什么样的呢？
public ProxyClass extends Proxy implement Foo, Hello{
InvocationHandler handler;
public ProxyClass(InvocationHandler handler){
this.handler=handler;
}
private execute(String methodName, Object[] args){
Method method=this.getClass().getMethod(methodName);
Handler.invoke(this, method, args);
}
public void sayFoo(String name){
Object[] args=new Object[]{name};
execute(this, "sayFoo", args);
}
public void sayHello(String hello){
Object[] args=new Object[]{hello};
execute(this, "sayHello", args);
}
}
Spring源码阅读：Spring AOP设计与实现（一）：动态代理