十分钟全面理解Spring AOP

什么是AOP

AOP(Aspect-Oriented Programming,面向切面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

而AOP技术则恰恰相反,它利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即切面。所谓“切面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系,如果说“对象”是一个空心的圆柱体,其中封装的是对象的属性和行为;那么面向方面编程的方法,就仿佛一把利刃,将这些空心圆柱体剖开,以获得其内部的消息。而剖开的切面,也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原,不留痕迹。

使用“横切”技术,AOP把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说,AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

实现AOP的技术,主要分为两大类:一是采用动态代理技术,利用拦截方法的方式,对该方法进行装饰,以取代原有对象行为的执行;二是采用静态织入的方式,引入特定的语法创建“切面”,从而使得编译器可以在编译期间织入有关“切面”的代码。

AOP相关概念

为了更好的理解AOP,我们有必要先了解AOP的相关术语。

切面(Aspect)

横切关注点的模块化(跨越应用程序多个模块的功能,比如 日志功能),这个关注点实现可能另外横切多个对象。

连接点(Join point)

连接点是在应用执行过程中能够插入切面的一个点。这个点可以是类的某个方法调用前、调用后、方法抛出异常后等。切面代码可以利用这些点插入到应用的正常流程之中,并添加行为。

通知(Advice)

在特定的连接点,AOP框架执行的动作。

Spring AOP 提供了5种类型的通知:

  • 前置通知(Before):在目标方法被调用之前调用通知功能。
  • 后置通知(After):在目标方法完成之后调用通知,无论该方法是否发生异常。
  • 后置返回通知(After-returning):在目标方法成功执行之后调用通知。
  • 后置异常通知(After-throwing):在目标方法抛出异常后调用通知。
  • 环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为。

切点(Pointcut)

指定一个通知将被引发的一系列连接点的集合。AOP 通过切点定位到特定的连接点。切点和连接点不是一对一的关系,一个切点匹配多个连接点,切点通过 org.springframework.aop.Pointcut 接口进行描述,它使用类和方法作为连接点的查询条件。每个类都拥有多个连接点,例如 ArithmethicCalculator类的所有方法实际上都是连接点。

引入(Introduction)

添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如,你可以使用一个引入使任何对象实现 IsModified接口,来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知,通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口

目标对象(Target Object)

包含连接点的对象。也被称作被通知或被代理对象。

AOP代理(AOP Proxy)

AOP框架创建的对象,包含通知。 在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。

织入(Weaving)

织入描述的是把切面应用到目标对象来创建新的代理对象的过程。 Spring AOP 的切面是在运行时被织入,原理是使用了动态代理技术。Spring支持两种方式生成代理对象:JDK动态代理和CGLib,默认的策略是如果目标类是接口,则使用JDK动态代理技术,否则使用Cglib来生成代理。

Spring AOP使用

可以通过XML配置文件或者 注解的方式来使用Spring AOP。

1、基于XML配置

1、maven依赖

<properties>
    <spring.version>4.3.6.RELEASE</spring.version>
    <aspectj.version>1.8.8</aspectj.version>
    <java.version>1.7</java.version>
    <junit.version>4.12</junit.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- AOP -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2、定义目标对象

package com.bytebeats.spring4.aop.xml.service;

public interface UserService {

    String login(String username, String passowrd);
    
    String register(String username, String passowrd);
}

UserServiceImpl
package com.bytebeats.spring4.aop.xml.service;

import org.springframework.stereotype.Service;

@Service("userService")
public class UserServiceImpl implements UserService {

    @Override
    public String login(String username, String passowrd) {
        System.out.println("login username:"+username+",passowrd:"+passowrd);
        if(username==null){
            throw new NullPointerException("username is null");
        }
        return "OK";
    }

    @Override
    public String register(String username, String passowrd) {
        System.out.println("register username:"+username+",passowrd:"+passowrd);
        return "OK";
    }

}

3、定义切面

package com.bytebeats.spring4.aop.xml;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

import java.util.Arrays;
import java.util.List;

public class LogInterceptor {

    /**
     * 前置通知:在方法执行前执行的代码
     * @param joinPoint
     */
    public void beforeExecute(JoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());

        System.out.println(this.getClass().getSimpleName()+" before execute");
    }
    
    /**
     * 后置通知:在方法执行后执行的代码(无论该方法是否发生异常),注意后置通知拿不到执行的结果
     * @param joinPoint
     */
    public void afterExecute(JoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+" after execute");
    }
    
    /**
     * 后置返回通知:在方法正常执行后执行的代码,可以获取到方法的返回值
     * @param joinPoint
     */
    public void afterReturning(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+" afterReturning execute, result:"+result);
    }
    
    /**
     * 后置异常通知:在方法抛出异常之后执行,可以访问到异常信息,且可以指定出现特定异常信息时执行代码
     * @param joinPoint
     */
    public void afterThrowing(JoinPoint joinPoint, Exception /**NullPointerException*/ exception){

        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+" afterThrowing execute, exception:"+exception);
    }
    
    /**
     * 环绕通知, 围绕着方法执行
     */
    public Object around(ProceedingJoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+" around execute start");
        
        Object result = null;
        try {
                        //执行目标方法
            result = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return result;
    }
}

4、XML配置

spring-aop-xml.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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 自动扫描的包 -->
    <context:component-scan base-package="com.bytebeats.spring4.aop.xml">
    </context:component-scan>

    <!-- 启用AspectJ自动代理 -->
    <aop:aspectj-autoproxy />

    <!-- 配置 bean -->
    <bean id="userService" 
        class="com.bytebeats.spring4.aop.xml.service.UserServiceImpl"></bean>

    <!-- 配置切面 -->
    <bean id="logInterceptor"
        class="com.bytebeats.spring4.aop.xml.LogInterceptor"></bean>

    <!-- aop配置 -->
    <aop:config>
        <!-- 配置切点表达式 -->
        <aop:pointcut expression="execution(* com.bytebeats.spring4.aop.xml.service.UserService.*(..))"
            id="pointcut"/>
        <!-- 配置切面及通知 -->
        <aop:aspect ref="logInterceptor" order="1">
            <aop:before method="beforeExecute" pointcut-ref="pointcut"/>
            <aop:after method="afterExecute" pointcut-ref="pointcut"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="exception"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
            <aop:around method="around" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

</beans>

 到此,基于XML的AOP配置已经完成了,接下来我们可以验证一下。

package com.bytebeats.spring4.aop.xml;

import com.bytebeats.spring4.aop.xml.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAopXmlApp {

    public static void main(String[] args) {
        
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring-aop-xml.xml");

        UserService userService = (UserService) ctx.getBean("userService");
        //userService.login("ricky", "123");

        System.out.println("***********************");
        userService.login(null, "123456");

        ctx.close();
    }

}

2、注解方式

1、定义目标对象

package com.bytebeats.spring4.aop.annotation.service;

/**
 * ${DESCRIPTION}
 *
 * @author Ricky Fung
 * @create 2017-04-03 11:11
 */
public interface BankService {

    boolean transfer(String from, String to, int amount);
}

BankServiceImpl
package com.bytebeats.spring4.aop.annotation.service;

import org.springframework.stereotype.Service;

/**
 * ${DESCRIPTION}
 *
 * @author Ricky Fung
 * @create 2017-04-03 11:12
 */
@Service
public class BankServiceImpl implements BankService {

    @Override
    public boolean transfer(String from, String to, int amount) {
        if(amount<1){
            throw new IllegalArgumentException("transfer amount must be a positive number");
        }
        System.out.println("["+from+"]向["+to+ "]转账金额"+amount);
        return false;
    }
}

 

2、定义切面

package com.bytebeats.spring4.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

@Order(1)
@Aspect
@Component
public class TransferLogAdvice {

    @Pointcut("execution(* com.bytebeats.spring4.aop.annotation.service.BankServiceImpl.*(..))")
    public void pointcut1() {
    }

    @Pointcut("execution(* com.bytebeats.spring4.aop.annotation.service.*ServiceImpl.*(..))")
    public void myPointcut() {
    }

    /**
     * 前置通知:在方法执行前执行的代码
     * @param joinPoint
     */
    @Before(value = "pointcut1() || myPointcut()")
    //@Before("execution(* com.bytebeats.spring4.aop.annotation.service.BankServiceImpl.*(..))")
    public void beforeExecute(JoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        
        System.out.println(this.getClass().getSimpleName()+ " before execute:"+methodName+ " begin with "+args);
    }
    
    /**
     * 后置通知:在方法执行后执行的代码(无论该方法是否发生异常),注意后置通知拿不到执行的结果
     * @param joinPoint
     */
    @After(value = "pointcut1()")
    public void afterExecute(JoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+ " after execute:"+methodName+" end!");
    }
    
    /**
     * 后置返回通知:在方法正常执行后执行的代码,可以获取到方法的返回值
     * @param joinPoint
     */
    @AfterReturning(value = "pointcut1()",
            returning="result")
    public void afterReturning(JoinPoint joinPoint, Object result){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+ " afterReturning execute:"+methodName+" end with result:"+result);
    }
    
    /**
     * 后置异常通知:在方法抛出异常之后执行,可以访问到异常信息,且可以指定出现特定异常信息时执行代码
     * @param joinPoint
     */
    @AfterThrowing(value = "pointcut1()",
            throwing="exception")
    public void afterThrowing(JoinPoint joinPoint, Exception /**NullPointerException*/ exception){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+ " afterThrowing execute:"+methodName+" occurs exception:"+exception);
    }
    
    /**
     * 环绕通知, 围绕着方法执行
     */
    @Around(value = "pointcut1()")
    public Object around(ProceedingJoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+ " around:"+methodName+" execute start");
        
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println(this.getClass().getSimpleName()+ " around:"+methodName+" execute end");
        return result;
    }
}


Spring AOP提供了 @Before,@After、@AfterReturning、@AfterThrowing、@Around注解来指定 通知类型。
/**
     * 前置通知:在方法执行前执行的代码
     * @param joinPoint
     */
    

但是,为了复用切点,推荐使用@Pointcut来定义切点,然后在 @Before、@After等注解中引用定义好的切点,代码如下:
@Pointcut("execution(* com.bytebeats.spring4.aop.annotation.service.BankServiceImpl.*(..))")
    public void pointcut1() {
    }

    /**
     * 前置通知:在方法执行前执行的代码
     * @param joinPoint
     */
    @Before(value = "pointcut1()")
    public void beforeExecute(JoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        
        System.out.println(this.getClass().getSimpleName()+ " before execute:"+methodName+ " begin with "+args);
    }
/**
     * 后置通知:在方法执行后执行的代码(无论该方法是否发生异常),注意后置通知拿不到执行的结果
     * @param joinPoint
     */
    @After(value = "pointcut1()")
    public void afterExecute(JoinPoint joinPoint){
        
        String methodName = joinPoint.getSignature().getName();
        System.out.println(this.getClass().getSimpleName()+ " after execute:"+methodName+" end!");
    }

3、启用注解扫描

spring-aop-annotation.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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 自动扫描的包 -->
    <context:component-scan base-package="com.bytebeats.spring4.aop.annotation">
    </context:component-scan>

    <!-- 启用AspectJ自动代理 -->
    <aop:aspectj-autoproxy />

</beans>

 到此,基于注解方式配置AOP已经结束了,接下来可以验证一下。

package com.bytebeats.spring4.aop.annotation;

import com.bytebeats.spring4.aop.annotation.service.BankService;
import com.bytebeats.spring4.aop.xml.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAopAnnotationApp {

    public static void main(String[] args) {
        
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring-aop-annotation.xml");

        BankService bankService = ctx.getBean(BankService.class);
        bankService.transfer("jordan", "kobe", 2000);

        System.out.println("*********************");
        bankService.transfer("jordan", "kobe", 0);

        ctx.close();
    }

}

 

Spring AOP切入点表达式

切入点指示符用来指示切入点表达式目的,在Spring AOP中目前只有执行方法这一个连接点,表达式如下:

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)  

括号中各个pattern分别表示 修饰符匹配(modifier-pattern?)、返回值匹配(ret-type-pattern)、类路径匹配(declaring-type-pattern?)、方法名匹配(name-pattern)、参数匹配((param-pattern))、异常类型匹配(throws-pattern?),其中后面跟着“?”的是可选项。

我们来看几个例子:
1、匹配所有方法

execution(* *(..))  

2、<p>匹配 com.bytebeats.spring4.aop.xml.service.UserService中所有的公有方法</p>
execution(public * com.bytebeats.spring4.aop.xml.service.UserService.*(..))  

3、匹配com.bytebeats.spring4.aop.xml.service 包及其子包下的所有方法
execution(* com.bytebeats.spring4.aop.xml.service..*.*(..))  

另外,@Pointcut 定义切点时,还可以使用 &&、|| 和 !,如下:
@Pointcut("execution(* com.bytebeats.mq.MqProducer.*(..))")  
private void mqSender(){
}  
@Pointcut("execution(* com.bytebeats.mq.MqConsumer.*(..))")  
private void mqReceiver(){
}

@Pointcut("mqSender() || mqReceiver()")  
private void mqTrace(){
}  


源码下载

https://github.com/TiFG/spring4-in-action/tree/master/spring-ch2-aop



posted @ 2021-07-15 13:21  yl_diao  阅读(75)  评论(0编辑  收藏  举报