Spring AOP 学习（一） 代理模式

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

　　

AOP 的应用范围

　　传统的程序通常表现出一些不能自然地适合单一的程序模块或者是几个紧密相关的程序模块的行为，AOP 将这种行为称为横切，它们跨越了给定编程模型中的典型职责界限。横切行为的实现都是分散的，软件设计师会发现这种行为难以用正常的逻辑来思考、实现和更改。最常见的一些横切行为如下面这些：

 

　　日志记录，跟踪，优化和监控

 

　　事务的处理

 

　　持久化

 

　　性能的优化

 

　　资源池，如数据库连接池的管理

 

　　系统统一的认证、权限管理等

 

　　应用系统的异常捕捉及处理

 

　　针对具体行业应用的横切行为

Spring 为解耦而诞生，其中AOP（面向切面编程）是很浓重的一笔。

这里简单记录一下AOP 给我带来的好处：

1.

用了一段时间，想通过简单的代码，更好的阐述以及理解它。

以前：假设我们有个简单的业务，还是经典的Hello World,那么我们定义一个Service 接口，一个ServiceImpl 实现类，一个sayHello 方法，这里使用网上很经典的日志记录的例子。

1.Service接口：定义一个sayHello  的业务方法

2.ServiceImpl实现类：主要是打印HelloWord,但是日常项目中，在主要业务前后可能会添加日志记录，或者开启事务等其他必要操作。

1. public class ServiceImpl implements Service{  
   
       @Override
       public void sayHello() {
           System.out.println("前置日记：打印、启动事务等..");
           System.out.println("Hello world!");
           System.out.println("后置日记：打印、关闭事务等..");
       }
   }  

例子很简单，那么假设，我们不光拥有sayHello ,还有sayBye 等多个方法，并且都需要其他操作呢？那么你是不是会写很多个这样的，重复的代码？

当然，你可以减少一部分工作量，你可以这样：

1. public class ServiceImpl implements Service{  
   
       @Override
       public void sayHello() {
           before();
           System.out.println("Hello world!");
           after();
       }  
   
       @Override
       public void sayBye() {
           before();
           System.out.println("Bye bye!");
           after();
       }  
   
       public static void before(){
           System.out.println("前置日记：打印、启动事务等..");
       }  
   
       public static void after(){
           System.out.println("后置日记：打印、关闭事务等..");
       }
   }  

我们再次假设，如果我们拥有更多的业务方法：sayHi(),sayOther()....，需要更多的其他操作：打印信息，传输记录....。并且其他ServiceImpl 里面的方法也需要这些方法呢？那么我们是不是每个类又要继续添加呢？

当然，你可以这样做：建立一个对Service 添加额外功能的类，统一提供。

1. public class ServiceFactory {
       public static void before(){
           System.out.println("前置日记：打印、启动事务等..");
       }  
   
       public static void after(){
           System.out.println("后置日记：打印、关闭事务等..");
       }  
   
       public static void other(){
           System.out.println("做其他的事..");
       }
   }  

ServiceImpl 就成这样：

1. public class ServiceImpl implements Service{  
   
       @Override
       public void sayHello() {
           ServiceFactory.before();
           System.out.println("Hello world!");
           ServiceFactory.after();
       }  
   
       @Override
       public void sayBye() {
           ServiceFactory.before();
           System.out.println("Bye bye!");
           ServiceFactory.after();
       }  
   
       @Override
       public void sayHi() {
           ServiceFactory.before();
           System.out.println("Hi");
           ServiceFactory.after();  
   
           ServiceFactory.other();
       }
   }  

这样代码，感觉是少了一些，但是我们的原则是尽量 别重复同样的代码，提高代码的复用性，改动最小为基准。也许业务很复杂，比较多，那么你要重复多少代码，整个类要写得多麻烦所啊！如果到时候有些假设before 和after 需要变化位置，你又要改动多少呢？

当然，目前的的JDK （大于1.3）为了解决这些问题，为我们提供的反射机制，动态代理机制。看看如何更好的解决这个问题。这里先copy 下，什么是代理：

Java的动态代理机制
代理模式是常用的Java设计模式。代理类主要负责为委托类预处理消息、过滤信息、把消息转发给委托类，以及事后处理信息等。
    理论 - -总是那么抽象（~。~），简单点说，就是：1.我的目的是去学校，那么校服　早餐 校车，这些我都需要，但是不由我做，全部代理给我父母搞定了（当然我是自己搞定的。）2.再简单的说就是：我只关注我主要的事情，其他附加的事情，全部交给别人搞定。看代码..

MyPorxy 我的代理类：

1. import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;  
   
   public class MyProxy implements InvocationHandler{  
   
       // 目标对象，也就是我们主要的业务，主要目的要做什么事
       private Object delegate;  
   
       /**
        * 和你额外需要做得事情，进行绑定，返回一个全新的对象（写法，基本上固定的）
        * @param delegate
        * @return
        */
       public Object bind(Object delegate){
           this.delegate = delegate;
           return Proxy.newProxyInstance(this.delegate.getClass().getClassLoader(),
                   this.delegate.getClass().getInterfaces(), this);
       }  
   
       /**
        * 你刚才需要执行的方法，都需要通过该方法进行动态调用
        */
       @Override
       public Object invoke(Object proxy, Method method, Object[] args)
               throws Throwable {
           Object obj = null;
           // 执行前置的方法
           ServiceFactory.before();
           // 通过反射，执行目标方法，也就是你的主要目的
           obj = method.invoke(this.delegate, args);
           // 执行后置的方法
           ServiceFactory.after();
           // 返回值给调用者
           return obj;
       }  
   
   }  

这里运用的反射知识，还需要去看看，这里就不解释了。

ServiceImpl 变化：

1. public class ServiceImpl implements Service{  
   
       @Override
       public void sayHello() {
           System.out.println("Hello world!");
       }  
   
       @Override
       public void sayBye() {
           System.out.println("Bye bye!");
       }  
   
       @Override
       public void sayHi() {
           System.out.println("Hi");
       }
   }  

测试类：

1. public class Test {  
   
       /**
        * 测试类
        * @param args
        */
       public static void main(String[] args) {
           // 不启用代理
           //Service service = new ServiceImpl();
           // 使用代理
           Service service = (Service)new MyProxy().bind(new ServiceImpl());  
   
           service.sayHello();
           service.sayBye();
           service.sayHi();
       }
   }  

OK，那么你现在看看，我们的业务实现类ServiceImpl 是不是干净多了，代码是不是在某些地方见过呢？即时你再进行添加更多的方法，也可以同样实现了对吗？当然，在Test里面，假设我们有的方法想用，有的方法不想用，那么又该怎么实现呢？