Java——基于AspectJ的AOP开发

1.AspectJ简介

AspectJ是一个基于Java语言的AOP框架。
Spring2.0以后新增了对AdpectJ切点表达式的支持。
@AspectJ是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面。
新版本Spring框架，建议使用AspectJ方式来开发AOP。
使用AspectJ需要导入Spring AOP和AspectJ相关jar包。

2.语法简介

（1）@AspectJ提供不同的通知类型

@Before 前置通知，相当于BeforeAdvice
@AfterReturning 后置通知，相当于AfterReturningAdvice
@Around 环绕通知，相当于MethodInterceptor
@AfterThrowing异常抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor

（2）在通知中通过value属性定义切点

 

通过execution函数，可以定义切点的方法切入。
语法：
　　execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
例如：
　　匹配所有类public方法 execution(public * *(..)) 第一个*任意方法返回值，第二个*任意参数 ..表示任意参数
　　匹配指定包下所有类方法(不包含子包) execution(* com.ikidana.dao.*(..)) 访问修饰符可以没有，第一个*返回值类型 第二个*方法名称 ..表示任意参数
　　匹配指定包下所有类方法(包含子包) 第一个..*表示包、子孙包下所有类
　　匹配指定类所有方法 execution(* com.ikidana.service.UserService.*(..))
　　匹配实现特定接口所有类方法 execution(* com.imooc.dao.GenericDAO+.*(..))
　　匹配所有save开头的方法 execution(* save*(..))

3.简单案例

导入依赖包：

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.1.12</version>
</dependency>
<!--引入Spring的基本开发包-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>aopalliance</groupId>
  <artifactId>aopalliance</artifactId>
  <version>1.0</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.9</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>compile</scope>
</dependency>

创建XML配置文件，开启自动代理：

<aop:aspectj-autoproxy/>

1）前置通知

a.创建一个实例类，并创建许多方法，现在我需要增强这个类中的方法

 public class ProductDAO {
    public void save(){
        System.out.println("ProductDAO save");
    }
    public void delete(){
        System.out.println("ProductDAO delete");
    }
    public void update(){
        System.out.println("ProductDAO update");
    }
    public void find(){
        System.out.println("ProductDAO find");
    }
}

b.添加一个切面

@Aspect  //代表一个切面
public class MyAspectAnno {
    @Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.*(..))")  //ProductDao所有方法
    public void before(){
        System.out.println("前置通知");
    }
}

c.在XML中声明注册

<!--目标类，属性注入-->
<bean id="productDao" class="com.imooc.aspectJ.demo1.ProductDAO"/>
<!--定义切面，不需要引用，所以不需要方法-->
<bean class="com.imooc.aspectJ.demo1.MyAspectAnno"/>

d.属性注入、目标注入、通知测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {
    @Resource(name="productDao")  //目标注入
    private ProductDAO productDAO;

    @Test
    public void demo1(){
        productDAO.save();
        productDAO.delete();
        productDAO.update();
        productDAO.find();
    }
} 

e.测试结果

　　前置通知
　　ProductDAO save
　　前置通知
　　ProductDAO delete
　　前置通知
　　ProductDAO update
　　前置通知
　　ProductDAO find

我们可以发现，ProductDAO类下面的所有方法，都添加了前置通知。

如果我们这样定义切面：
@Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.save(..))")
那么只会在save前面添加前置通知

可以在方法中传入JoinPoint对象，用来获得切点信息。

@Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.*(..))")  //ProductDao所有方法
public void before(JoinPoint joinPoint){
    System.out.println("前置通知"  + joinPoint) ;
}

切点信息类似如下：
execution(void com.imooc.aspectJ.demo1.ProductDAO.save())

2）后置通知

添加一个切面：

@AfterReturning(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.update(..))",returning = "ret")
public void afterReturing(Object ret){
    System.out.println("后置通知" + ret);
}

结果：
ProductDAO save
ProductDAO delete
ProductDAO update
后置通知  ProductDAO update 返回值
ProductDAO find

通过returning属性，可以定义方法返回值。

3）环绕通知

around方法的返回值就是目标代理方法执行的返回值。
可以通过ProceedingJoinPoint可以调用拦截目标方法执行。
a.添加一个环绕通知的切面

public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("环绕前通知");
    Object obj = joinPoint.proceed();  //执行目标方法，如果不调用这句话，那么目标方法将不会执行
    System.out.println("环绕后通知");
    return obj;
}
//结果：
ProductDAO save
环绕前通知
ProductDAO delete
环绕后通知
ProductDAO update
ProductDAO find

4）异常抛出通知

通过设置throwing属性，可以设置发生异常对象参数。

@AfterThrowing(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.find(..))")
public void afterThrowing(){
    System.out.println("异常抛出通知" );
}

当然我们还可以打印异常：

@AfterThrowing(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.find(..))",throwing = "e")
public void afterThrowing(Throwable e){
    System.out.println("异常抛出通知" + " " + e);
}

5）最终通知

无论是否出现异常，最终通知总是会被执行的。

@After(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.find(..))")
public void after(){
    System.out.println("最终通知");
}

4.切点命中

通过@Pointcut为切点命名。
在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用@Pointcut进行定义。

切点方法：private void 无参方法，方法名为切点名。
当通知多个切点时，可以使用||进行连接。

大概意思就是，如果同一个切点value被很多地方引用，改起来就不太方便。

@Pointcut(value = "execution(* com.imooc.aspectJ.demo1.ProductDAO.save(..))")
private void myPointcut1(){}

@AfterReturning(value = "myPointcut1()")
public void afterReturing(){
    System.out.println("后置通知");
}

相当于创建了别名，修改了别名，就相当于修改了所有的引用。

5.基于AspectJ的XML方式的AOP开发

1）前置通知

//创建接口类和实例类
public interface CustomerDao {
    public void save();
    public void update();
    public void delete();
    public void find();
}

public class CustomerDaoImpl implements CustomerDao {
    public void save() {
        System.out.println("c-save");
    }

    public void update() {
        System.out.println("c-update");
    }

    public void delete() {
        System.out.println("c-delete");
    }

    public void find() {
        System.out.println("c-find");
    }
}

//创建通知
public class MyAspectXml {
    //前置通知
    public void before(){
        System.out.println("XML方式的前置通知");
    }
}

//配置增强
<!--XML配置的方式完成AOP开发-->
<!--配置目标类-->
<bean id="customerDao" class="com.imooc.aspectJ.demo2.CustomerDaoImpl"/>
<!--配置切面类-->
<bean id="myAspectXml" class="com.imooc.aspectJ.demo2.MyAspectXml"/>
<!--AOP相关配置-->
<aop:config>
    <!--定义切入点：那些类的那些方法需要应用增强-->
    <aop:pointcut id="pointcut1" expression="execution(* com.imooc.aspectJ.demo2.CustomerDao.save(..))"/>
    <!--配置AOP切面：使用那些增强-->
    <aop:aspect ref="myAspectXml">
        <!--配置前置增强 pointcut-ref哪个切点增强 method使用那个增强方法 aop:before增强类型-->
        <aop:before method="before" pointcut-ref="pointcut1"/>
    </aop:aspect>
</aop:config>

//测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext2.xml")
public class SpringDemo2 {
    @Resource(name = "customerDao")
    private CustomerDao customerDao;

    @Test
    public void demo1(){
        customerDao.save();
        customerDao.delete();
        customerDao.find();
        customerDao.update();
    }
}

//结果
XML方式的前置通知
c-save
c-delete
c-find
c-update

2）其他通知

public class MyAspectXml {
    //前置通知
    public void before(){  //一样可以打印JoinPoint连接点
        System.out.println("XML方式的前置通知");
    }

    //后置通知
    public void afterReturing(){
        System.out.println("XML方式的后置通知");
    }

    //环绕通知
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前");
        Object obj = joinPoint.proceed(); //执行目标方法
        System.out.println("环绕后");
        return obj;
    }
}

<aop:config>
    <!--定义切入点：那些类的那些方法需要应用增强-->
    <aop:pointcut id="pointcut1" expression="execution(* com.imooc.aspectJ.demo2.CustomerDao.save(..))"/>
    <aop:pointcut id="pointcut2" expression="execution(* com.imooc.aspectJ.demo2.CustomerDao.find(..))"/>
    <aop:pointcut id="pointcut3" expression="execution(* com.imooc.aspectJ.demo2.CustomerDao.delete(..))"/>

    <!--配置AOP切面：使用那些增强-->
    <aop:aspect ref="myAspectXml">
        <!--配置前置增强 pointcut-ref哪个切点增强 method使用那个增强方法 aop:before增强类型-->
        <aop:before method="before" pointcut-ref="pointcut1"/>
        <!--配置后置通知-->
        <aop:after method="afterReturing" pointcut-ref="pointcut2"/>
        <!--环绕通知-->
        <aop:around method="around" pointcut-ref="pointcut3"/>
    </aop:aspect>
</aop:config>

在现在企业中，spring在进行AOP开发的时候，都不会使用传统方式，都会基于AspectJ的AOP开发。
传统AOP开发需要手动开发代理层，这样工作量会稍大。