Spring----AOP面向切面编程例子解析

AOP概述（Aspect Oriented Programming）

是面向对象编程的有力补充。

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

面向切面编程：就是在原直线编程的某处咔嚓一下，加点动西，而且不影响原来的代码。可以用在日志，加权限，事物，异常管理等方面。

从简单的例子说起：

现在有一个save（）方法，需要在save（）前、后分别加上日志打印的信息。

  

    

     

    
    

     

      public 
      class UserDAOImp implements UserDAO
     
    

    

     

    
    

     

      {
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
      @Override
     
    

    

     

    
    

     
 
      public void save(User u)
     
    

    

     

    
    

     

       {
     
    

    

     

    
    

     

              System.out.println(
      “a DAO implements!”);
     
    

    

     

    
    

     

          }
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      }
     
    
  

1.  解决办法一：

直接在源代码save里加一些输出就行了。

前提条件：有源代码！

  

    

     

    
    

     

      public 
      class UserDAOImp implements UserDAO
     
    

    

     

    
    

     

      {
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
      @Override
     
    

    

     

    
    

     
 
      public void save(User u)
     
    

    

     

    
    

     

       {
     
    

    

     

    
    

     

              System.out.println(
      “before!!!!!”);
     
    

    

     

    
    

     

            System.out.println(
      “a DAO implements!”);
     
    

    

     

    
    

     

              System.out.println(
      “after!!!!!!”);
     
    

    

     

    
    

     

       }
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      }
     
    
  

评价：傻瓜式的！可拓展性差！！

2.  解决办法二：

如果没有源代码呢？

可以继承UserDAOImp, 然后在xml中将bean的class改成继承的类。

前提条件：继承

  

    

     

    
    

     

      public 
      class UserDAOImp1 extends UserDAOImp
     
    

    

     

    
    

     

      {
     
    

    

     

    
    

     
    
     
    

    

     

    
    

     
 
      @Override
     
    

    

     

    
    

     
 
      public void save(User u)
     
    

    

     

    
    

     

       {
     
    

    

     

    
    

     

              System.out.println(
      “save start……”);
     
    

    

     

    
    

     
     
      super.save(u);
     
    

    

     

    
    

     

       }
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      }
     
    
  

评价：继承尽量少用。可拓展性也差！！

3.  解决办法三：

针对第二种办法优化，用接口。

  

    

     

    
    

     

      public 
      class UserDAOImp2 implements UserDAO
     
    

    

     

    
    

     

      {
     
    

    

     

    
    

     
    
      private UserDAO userDAO = 
      new UserDAOImp();
     
    

    

     

    
    

     
  
      @Override
     
    

    

     

    
    

     
 
      public void save(User u)
     
    

    

     

    
    

     

       {
     
    

    

     

    
    

     

              System.out.println(
      “save start…..”);
     
    

    

     

    
    

     

            userDAO.save(u);
     
    

    

     

    
    

     

       }
     
    

    

     

    
    

     
   
     
    

    

     

    
    

     

      }
     
    
  

评价：比较灵活了，但还是有一个问题, 当有1000个bean时, 就要组合1000次……..如何解决?

4. 解决办法四：

AOP！！！！！

在 不修改源代码 的情况下给程序动态统一添加功能。

  

    

     

    
    

     

      /*
     
    

    

     

    
    

     

       *面向切面编程, 动态代理. Aspect声明切面, Component初始化.
     
    

    

     

    
    

     

       */
     
    

    

     

    
    

     

      @Aspect
     
    

    

     

    
    

     

      @Component
     
    

    

     

    
    

     

      public 
      class LogInterceptor
     
    

    

     

    
    

     

      {
     
    

    

     

    
    

     
  
      //这个可用来替代以后重复出现的. 直接在后面的Before(“myMethod()”)就行了.
     
    

    

     

    
    

     
   
      @Pointcut(
      “execution(public * com.dao.impl..*.*(..))”)
     
    

    

     

    
    

     
  
      public void myMethod(){};
     
    

    

     

    
    

     
   
     
    

    

     

    
    

     
    
      //下面用到的是织入点语法, 看文档里面有. 就是指定在该方法前执行
     
    

    

     

    
    

     
    
      //@Before(“execution(public void com.dao.impl.UserDAOImp.save(com.model.User))”)
     
    

    

     

    
    

     
  
      //记住下面这种通用的, *表示所有
     
    

    

     

    
    

     
    
      @Before(
      “execution(public * com.dao.impl..*.*(..))”)
     
    

    

     

    
    

     
    
      public void beforeMethod()
     
    

    

     

    
    

     

        {
     
    

    

     

    
    

     

             System.out.println(
      “save start……”);
     
    

    

     

    
    

     

          }
     
    

    

     

    
    

     
   
     
    

    

     

    
    

     
    
      //正常执行完后
     
    

    

     

    
    

     
  
      @AfterReturning(
      “execution(public * com.dao.impl..*.*(..))”)
     
    

    

     

    
    

     
    
      public void afterReturnning()
     
    

    

     

    
    

     

         {
     
    

    

     

    
    

     

             System.out.println(
      “after save……”);
     
    

    

     

    
    

     

          }
     
    

    

     

    
    

     
   
     
    

    

     

    
    

     
    
      //抛出异常时才调用
     
    

    

     

    
    

     
    
      @AfterThrowing(
      “myMethod()”)
     
    

    

     

    
    

     
    
      public void afterThrowing()
     
    

    

     

    
    

     

       {
     
    

    

     

    
    

     

             System.out.println(
      “after throwing……”);
     
    

    

     

    
    

     

          }
     
    

    

     

    
    

     
   
     
    

    

     

    
    

     
    
      //环绕, 这个特殊点.
     
    

    

     

    
    

     
  
      @Around(
      “myMethod()”)
     
    

    

     

    
    

     
   
      public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable
     
    

    

     

    
    

     

          {
     
    

    

     

    
    

     
       
      //加逻辑的时候, 不要依赖执行的的先后顺序
     
    

    

     

    
    

     

              System.out.println(
      “method around start!”);
     
    

    

     

    
    

     

              pjp.proceed();
     
    

    

     

    
    

     

            System.out.println(
      “method around end!”);
     
    

    

     

    
    

     

        }
     
    

    

     

    
    

     

      }
     
    
  

评价：good！切入！

源码下载：http://download.youkuaiyun.com/detail/xn4545945/4828055

转载请注明出处：http://blog.youkuaiyun.com/xn4545945