2018-05-08

关于SpringAop学习的一点记录

AOP思想是一种面向切面编程思想，是将已经封装好的对象“切开”，将内部与业务无关的却又被多个业务模块所共同调用的部分进行抽取、封装。提高代码的重用性，降低各模块之间的耦合度(解耦)，提高系统的可维护性。
举个栗子：
在系统管理过程中，经常会需要打印日志来对用户操作进行留痕处理，这个时候就可以将业务逻辑处理中的日志打印代码进行提取封装，以达到简化日志相关代码，降低各个模块之间耦合度的目的。下面用实际代码做简要说明。

Eclipse创建一个Maven项目：
pom.xml 配置如下：

<dependencies>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>4.1.0.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aspects</artifactId>
         <version>4.1.0.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>4.1.4.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.6.8</version>
      </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

方案一：
XML配置方式实现AOP

新建Student类如下：

package com.spring.aop.annotation;

public class Student {
      private Integer age;
      private String name;

      public void setAge(Integer age) {
         this.age = age;
      }
      public Integer getAge() {
         System.out.println("Age : " + age );
         return age;
      }

      public void setName(String name) {
         this.name = name;
      }
      public String getName() {
         System.out.println("Name : " + name );
         return name;
      }

      public void printThrowException(){
          System.out.println("Exception raised");
          throw new IllegalArgumentException();
      }
   }

新建切面类LoggingAnnotation如下：

package com.spring.aop.xml;

import org.springframework.core.annotation.Order;

public class LoggingAnnotation {

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
    @Order(1)
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }

   /** 
    * This is the method which I would like to execute
    * after a selected method execution.
    */
   public void afterAdvice(){
      System.out.println("Student profile has been setup.");
   }

   /** 
    * This is the method which I would like to execute
    * when any method returns.
    */
   public void afterReturningAdvice(Object obj){
       obj = (Object)true;
       int error = 1/0;
       System.out.println("Returning:" + obj.toString() );
   }

   /**
    * This is the method which I would like to execute
    * if there is an exception raised.
    * @throws Exception 
    */
   @Order(2)
   public void AfterThrowingAdvice(IllegalArgumentException ex){
       System.out.println(ex.toString());
       throw ex;
   }

}

注1：以上方法包含了多个切点(Pointcut，可逐一添加测试方便理解)；
注2：@Order注解是设置方法执行优先级。
注3：afterReturningAdvice中以0做分母是为了触发AfterThrowingAdvice方法，以打印出相应得到异常信息。

新建MainApp类如下：

package com.spring.aop.xml;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class MainApp {
    public static void main(String[] args) {
        //TODO:XML实现Spring AOP
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("xml-spring-aop.xml");

        Student student = (Student) context.getBean("student");

        student.getName();
        student.getAge();
    }
}

新建resource文件夹下，新建xml-spring-aop.xml文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
    <!-- XML配置方式实现AOP需要AOP相关配置，切点表达式，方法名 -->
   <aop:config>
      <aop:aspect id="log" ref="logging">
         <aop:pointcut id="selectAll" expression="execution(* com.spring.aop.xml.*.*(..))"/>
         <aop:before pointcut-ref="selectAll" method="beforeAdvice"/>
         <aop:after pointcut-ref="selectAll" method="afterAdvice"/>
         <aop:after-returning pointcut-ref="selectAll" returning="obj" method="afterReturningAdvice"/>
         <aop:after-throwing pointcut-ref="selectAll" throwing="ex" method="AfterThrowingAdvice"/>
      </aop:aspect>
   </aop:config>
   
   <bean id="student" class="com.spring.aop.xml.Student">
      <property name="name"  value="Maxsu" />
      <property name="age"  value="21"/>      
   </bean>

   <!-- XML配置方式实现AOP需要关联配置方式对应的切面类 -->
   <bean id="logging" class="com.spring.aop.xml.LoggingAnnotation"/>

</beans>

注：配置文件名称与MainApp中的加载资源文件名一致；
Student类路径与创建的Student类路径一致；
<aop:config>中表达式的扫描路径和切面类的加载路径需同步修改。

执行MainApp中的main方法打印日志如下：


image.png

方案二：
注解方式实现AOP

新建resource文件夹下，新建annotation-spring-aop.xml文件，配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
   
   <!-- 该配置表示默认使用jdk代理方式，即基于接口的代理 -->
   <aop:aspectj-autoproxy/>
   
   <!-- Definition for student bean -->
   <bean id="student" class="com.spring.aop.annotation.Student">
      <property name="name"  value="Maxsu" />
      <property name="age"  value="21"/>      
   </bean>

   <!-- 注解方式实现AOP需要关联到相应切面类 -->
   <bean id="logging" class="com.spring.aop.annotation.LoggingAnnotation"/>

</beans>

新建Student类：


package com.spring.aop.annotation;

public class Student {
     private Integer age;
     private String name;

     public void setAge(Integer age) {
        this.age = age;
     }
     public Integer getAge() {
        System.out.println("Age : " + age );
        return age;
     }

     public void setName(String name) {
        this.name = name;
     }
     public String getName() {
        System.out.println("Name : " + name );
        return name;
     }

     public void printThrowException(){
         System.out.println("Exception raised");
         throw new IllegalArgumentException();
     }
  }

新建LoggingAnnotation类：

package com.spring.aop.annotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class LoggingAnnotation {

   /** Following is the definition for a pointcut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @Pointcut("execution(* com.spring.aop.annotation.*.*(..))")
   private void selectAll(){}

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("selectAll()")
   public void beforeAdvice(){
      System.out.println("[beforeAdvice] Going to setup student profile.");
   }  
   
   @Pointcut("execution(* com.spring.aop.annotation.Student.getAge(..))")
   private void selectAge(){};
   
   @After("selectAge()")
   public void afterAdvice(){
       System.out.println("[afterAdvice] Going to setup student profile.");
   }
   
   @Pointcut("execution(* com.spring.aop.annotation.Student.getAge(..))")
   private void selectGetName(){}

   @Around("selectGetName()")
   public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
      System.out.println("[aroundAdvice] Around advice");
      Object[] args = proceedingJoinPoint.getArgs();
      if(args.length>0){
         System.out.print("[aroundAdvice] Arguments passed: " );
         for (int i = 0; i < args.length; i++) {
            System.out.print("[aroundAdvice] arg "+(i+1)+": "+args[i]);
         }
      }

      Object result = proceedingJoinPoint.proceed(args);
      System.out.println("[aroundAdvice] Returning " + result);
   }
}

新建MainApp类：

package com.spring.aop.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class MainApp {
    public static void main(String[] args) {
        //TODO:注解方式实现Spring AOP
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("annotation-spring-aop.xml");
        Student student = (Student) context.getBean("student");
        
        student.getName();
        student.getAge();
        student.printThrowException();
    }
}

执行MainApp中的main方法，打印结果如下:


image.png

方案三:
代理方式实现AOP

新建resource文件下新建proxy-spring-aop.xml文件，配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
   
   <!-- 代理方式实现AOP需要添加AOP代理配置 -->
   <!-- 其中proxy-target-class="true/false"属性，
        决定是基于接口的还是基于类的代理被创建。
        如果proxy-target-class 属性值被设置为true，
        那么基于类的代理将起作用(这时需要cglib库)。
        如果proxy-target-class属值被设置为false或者这个属性被省略，
        那么标准的JDK 基于接口的代理将起作用。 
    -->
   <aop:config proxy-target-class="true"></aop:config>

   <!-- Definition for student bean -->
   <bean id="student" class="com.spring.aop.proxy.Student">
      <property name="name"  value="Maxsu" />
      <property name="age"  value="21"/>      
   </bean>

   <!-- 注解方式实现AOP需要关联到相应切面类 -->
   <bean id="logging" class="com.spring.aop.proxy.LoggingAnnotation"/>

</beans>

新建Student类：


package com.spring.aop.proxy;

public class Student {
       private Integer age;
       private String name;

       public void setAge(Integer age) {
          this.age = age;
       }
       public Integer getAge() {
          System.out.println("Age : " + age );
          return age;
       }

       public void setName(String name) {
          this.name = name;
       }
       public String getName() {
          System.out.println("Name : " + name );
          return name;
       }

       public void printThrowException(){
           System.out.println("Exception raised");
           throw new IllegalArgumentException();
       }
    }

新建LoggingAnnotation类：

package com.spring.aop.proxy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class LoggingAnnotation {

   /** Following is the definition for a pointcut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @Pointcut("execution(* com.spring.aop.proxy.*.*(..))")
   private void selectAll(){}

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("selectAll()")
   public void beforeAdvice(){
      System.out.println("[beforeAdvice] Going to setup student profile.");
   }  
   
   @Pointcut("execution(* com.spring.aop.proxy.Student.getAge(..))")
   private void selectAge(){};
   
   @After("selectAge()")
   public void afterAdvice(){
       System.out.println("[afterAdvice] Going to setup student profile.");
   }
   
   @Pointcut("execution(* com.spring.aop.proxy.Student.*(..))")
   private void selectGetName(){}

   @Around("selectGetName()")
   public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
      System.out.println("[aroundAdvice] Around advice");
      Object[] args = proceedingJoinPoint.getArgs();
      if(args.length>0){
         System.out.print("[aroundAdvice] Arguments passed: " );
         for (int i = 0; i < args.length; i++) {
            System.out.print("[aroundAdvice] arg "+(i+1)+": "+args[i]);
         }
      }

      Object result = proceedingJoinPoint.proceed(args);
      System.out.println("[aroundAdvice] Returning " + result);
   }
}

新建MainApp类：

package com.spring.aop.proxy;

import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Hello world!
*
*/
public class MainApp {
   public static void main(String[] args) {
       //TODO:代理模式实现Spring AOP
       @SuppressWarnings("resource")
       ApplicationContext context = new ClassPathXmlApplicationContext("proxy-spring-aop.xml");
       Student student = (Student) context.getBean("student");
       //Create the Proxy Factory
       AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);
       //Add Aspect class to the factory
       proxyFactory.addAspect(LoggingAnnotation.class);
       //Get the proxy object
       Student proxyStudent = proxyFactory.getProxy();
       //Invoke the proxied method.
       proxyStudent.getAge();
       proxyStudent.getName();
   }
}

执行MainApp中的main方法，打印结果如下:


image.png

进阶：
自定义注解配置方法：

新建resource文件夹下新建myannotation-spring-aop.xml文件，配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
  
  <!-- 代理方式实现AOP需要添加AOP代理配置 -->
  <!-- 其中proxy-target-class="true/false"属性，
       决定是基于接口的还是基于类的代理被创建。
       如果proxy-target-class 属性值被设置为true，
       那么基于类的代理将起作用(这时需要cglib库)。
       如果proxy-target-class属值被设置为false或者这个属性被省略，
       那么标准的JDK 基于接口的代理将起作用。 
   -->
  <!-- <aop:config proxy-target-class="true"></aop:config> -->
  
  <aop:aspectj-autoproxy/>

  <!-- Definition for student bean -->
  <bean id="student" class="com.spring.aop.myannotation.Student">
     <property name="name"  value="Maxsu" />
     <property name="age"  value="21"/>      
  </bean>

  <!-- 注解方式实现AOP需要关联到相应切面类 -->
  <bean id="logging" class="com.spring.aop.myannotation.LoggingAnnotation"/>

</beans>

新建LoggingAnnotation类：

package com.spring.aop.myannotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAnnotation {

//  @Pointcut("@annotation(Myannotation)")
//  private void myannotation(){};
   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
    @Before("@annotation(com.spring.aop.myannotation.MyAnnotation)")
    public void beforeAdvice(){
        System.out.println("[beforeAdvice] Going to setup student profile.");
    }     
   
}

新建Student类：


package com.spring.aop.myannotation;

public class Student {
       private Integer age;
       private String name;

       public void setAge(Integer age) {
          this.age = age;
       }
       public Integer getAge() {
          System.out.println("Age : " + age );
          return age;
       }
       public void setName(String name) {
          this.name = name;
       }
       @MyAnnotation
       public String getName() {
          System.out.println("Name : " + name );
          return name;
       }
       
       public void printThrowException(){
           System.out.println("Exception raised");
           throw new IllegalArgumentException();
       }
    }

新建MyAnnotation类：

package com.spring.aop.myannotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {

}

新建MainApp类：

package com.spring.aop.myannotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class MainApp {
    
    public static void main(String[] args) {
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("myannotation-spring-aop.xml");
        Student student = (Student) context.getBean("student");
        
        student.getName();
        student.getAge();   
    }
}

执行MainApp中的main方法，打印结果如下：


image.png

至此，简单的自定义注解配置使用完毕。
以上为我个人学习SpringAop的一点记录，如有错漏，欢迎指正探讨。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,590评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 86,808评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,151评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,779评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,773评论 5赞 367
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,656评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,022评论 3赞 398
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,678评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,038评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,659评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,756评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,411评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,005评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,973评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,053评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,495评论 2赞 343

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,596评论 18赞 139
  • 无标题文章
    spring官方文档：http://docs.spring.io/spring/docs/current/spri...
    牛马风情阅读 1,647评论 0赞 3
  • Clojure开发环境搭建
    该教程是在win环境下搭建clojure开发环境。 下载IntelliJ IDEA，安装Cursive. Curs...
    nicegoing阅读 4,162评论 0赞 3
  • 尼泊尔，尼好，
    一直在路上从未想过放弃，因为爱好所以随心，四海皆友，无江湖不朋友！
    H一个人的梦阅读 267评论 7赞 3
  • 每一部电影都是我们的人生
    有时候当我们过得累了或者乏了，我们会选择去看电影。 我们希望在别人精彩的故事里，忘记自己故事的不精彩。 ...
    张庆朋阅读 1,202评论 2赞 4