Spring5之面向切面编程（AoP）

2022年05月13日阅读数：1

这篇文章主要向大家介绍Spring5之面向切面编程（AoP）,主要内容包括基础应用、实用技巧、原理机制等方面，希望对大家有所帮助。

标签： java spring express 编程安全框架性能测试 3d 代理

目录java

前言spring

1、AoP的特色及功能express

三、进行AOP操做测试

前言

前面讲过IoC操做bean管理，这里主要对Spring的另外一核心AoP作个描述。AoP：面向切面编程，它能够在不经过修改源代码的基础之上，在主干功能里增长新的功能。代理

1、AoP的特色及功能

一、特色：利用AOP能够对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度下降，提升程序的可重用性，同时提升了开发的效率。

二、主要功能：日志记录，性能统计，安全控制，事务处理，异常处理等等。

2、AoP的原理及JDK动态代理

一、aop底层用了动态代理，有两种状况的动态代理：

第一种有接口的状况，使用JDK动态代理，建立接口实现类代理对象，增长类的方法。

第二种没有接口的状况，使用CGLIB动态代理，建立当前类子类的代理对象，增长类的方法。

二、JDK动态代理

（1）使用JDK动态代理，使用Proxy类里面的方法建立代理对象

（2）调用newProxyInstance方法

方法里有三个参数：第一个参数表示类加载器。第二个参数表示加强方法所在的类，这个类实现的接口，支持多个接口。第三个参数表示实现接口InvocationHandler，建立代理对象，写加强的方法

3、基于注解的方式实现AoP

一、Aop的相关术语

（1）链接点

类里面哪些方法能够被加强，这些方法称为链接点

（2）切入点

实际被真正加强的方法，称为切入点

（3）通知（加强）

实际加强的逻辑部分称为通知（加强），好比登陆功能中的权限判断

通知有多种类型，以下所示：

前置通知:@Before

后置通知:@AfterReturning（返回通知）

环绕通知:@Around

异常通知:@AfterThrowing

最终通知:@After（不管程序出不出现异常，其都会出现，且出如今被加强方法以后，因此称为最终通知）

（4）切面

把通知应用到切入点的过程，好比将权限判断加入进登陆方法中

（5）切入点表达式

切入点表达式的做用：知道对哪一个类里面的哪一个方法进行加强。语法结构以下：

execution（【权限修饰符】【返回类型】【类全路径】【方法名称】（【参数列表】））

@Before(value = "execution(* com.aopanno.User.add(..))")

权限修饰符能够不写，但返回值必需要写，*表示任意返回类型，它必需要与类全路径名用空格隔开，add表示要加强的方法，“..”表示参数列表。

二、导入相关依赖

Spring框架通常都是基于AspectJ实现AOP操做的。AspectJ不是Spring的组成部分，它是一个独立的AOP框架，通常把AspectJ和Spring框架一块儿使用，进行AOP操做。因此要导入AspectJ的jar包。

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

三、进行AOP操做

（1）建立类，该类为被加强类，在类里面定义方法

package com.aopanno;
public class User {
    public void add() {
        System.out.println("add......");
    }
}

（2）建立加强类（编写加强逻辑），在加强类里面，建立方法，让不一样的方法表明不一样通知类型

//加强的类
public class UserProxy {
    public void before() {
        System.out.println("before......");
    }
    public void after(){
        System.out.println("after........");
    }
    public void afterReturning(){
        System.out.println("afterReturning........");
    }
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕以前......");
        //被加强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕以后......");
    }
}

（3）进行通知的配置

在spring文件中先开启注解扫描：

<context:component-scan base-package="com.aopanno"/>

使用注解建立User和UserProxy对象，并在加强的类上面添加注解@Aspect

@Component
@Aspect  //生成代理对象

在spring配置文件中开启生成代理对象

<aop:aspectj-autoproxy/>

配置不一样类型的通知，在加强类的里面，在做为通知方法上面添加通知类型注解，使用切入点表达式进行配置。

@Component
@Aspect  //生成代理对象
public class UserProxy {
    //前置通知，里面用切入点表达式
    @Before(value = "execution(* com.aopanno.User.add(..))")
    public void before() {
        System.out.println("before......");
    }
    //在方法以后执行，不管异常与否都执行
    @After(value = "execution(* com.aopanno.User.add(..))")
    public void after(){
        System.out.println("after........");
    }
    //在返回值以后执行，只有在方法正常返回的状况下才执行
    @AfterReturning(value = "execution(* com.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning........");
    }
    @AfterThrowing(value = "execution(* com.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
    @Around(value = "execution(* com.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕以前......");
        //被加强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕以后......");
    }
}

（4）对相同的切入点进行抽取

你们会发现切入点的表达式都是同样的，那如何对相同的切入点进行抽取呢？相似于静态方法，该方法能够被共享，因此咱们定义一个方法，将切入点表达式放入该方法中，只需调用该方法便可。此种作法方便代码的后期维护，好比切入点表达式发生变化，无需一个个费劲地去改，只需改方法里的代码。

@Component
@Aspect  //生成代理对象
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value ="execution(* com.aopanno.User.add(..))")
    public void pointDemo(){
    }

    //前置通知，里面用切入点表达式
    @Before(value = "pointDemo()")
    public void before() {
        System.out.println("before......");
    }
    //在方法以后执行，不管异常与否都执行
    @After(value = "pointDemo()")
    public void after(){
        System.out.println("after........");
    }
    //在返回值以后执行，只有在方法正常返回的状况下才执行
    @AfterReturning(value = "pointDemo()")
    public void afterReturning(){
        System.out.println("afterReturning........");
    }
    @AfterThrowing(value = "pointDemo()")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
    @Around(value = "pointDemo()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕以前......");
        //被加强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕以后......");
    }
}

（5）结果分析

从结果能够看出每一个通知的执行。前置通知before，做用在被加强方法add方法的前面，环绕通知around，围绕add方法，而且在前置通知和最终通知以前，最终通知after做用在后置通知afterReturning以前，此外咱们还发现，异常通知还未出现。假设程序出现异常，每一个通知的执行顺序又会有怎样的变化呢？

当出现异常时，异常通知afterThrowing出现，且最终通知after出现，这也是它为何叫最终通知了。

（6）当有多个加强类对同一个方法进行加强，能够设置加强类的优先级

在加强类上面添加注解@Order（数字值），数字越小，优先级就越高，再建立一个加强方法：

package com.aopanno;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.aopanno.User.add(..))")
    public void before() {
        System.out.println("Person Before......");
    }

}

@Order(2)
@Component
@Aspect  //生成代理对象
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value ="execution(* com.aopanno.User.add(..))")
    public void pointDemo(){
    }

结果以下：

（7）彻底注解开发

建立配置类，不须要建立xml配置文件，@Configuration，添加此注解，系统就知道这是配置类，@ComponentScan，表示开启注解扫描，@EnableAspectJAutoProxy，开启Aspect生成代理对象

package com.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = {"com"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

@Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(ConfigAop.class);
        User user = context.getBean("user", User.class);
        user.add();

    }

须要注意的是，Junit测试单元写法有点不一样，后面表示加载注解配置文件

4、基于配置文件的方式实现AoP

基于配置文件的方式稍微了解便可

一、建立两个类，加强类和被加强类，而后再建立方法

package com.aopxml;

public class Book {
    public void buy(){
        System.out.println("buy.........");
    }

}

package com.aopxml;

public class BookProxy {
    public void before() {
        System.out.println("before.......");
    }

}

二、在spring配置文件中建立两个类的对象

<bean id="book" class="com.aopxml.Book"></bean>
<bean id="bookProxy" class="com.aopxml.BookProxy"></bean>

三、在spring配置文件中配置切入点，并之前置通知@before为例

<!--配置aop加强-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="point" expression="execution(* com.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--加强做用在具体的方法上-->
            <aop:before method="before" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

四、编写测试类

@Test
    public void testAopXml() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book = context.getBean("book", Book.class);
        book.buy();
    }

五、结果