#展望我的2022Flag#Spring框架使用AspectJ实现AOP前置通知学习笔记

Posted 2022-01-15 这只肥猫很凶

其实AOP_AspectJ的编程与传统的AOP的编程的最大的区别就是写一个Aspect 支持多个Advice和多个PointCut 。而且我们写AOP_Aspctj不需要继承任何的接口，不像传统的AOP还要继承接口。

1. 前置通知是在运行我们被代理的方法之前先执行的。
2. 前置通知具有如下的特点：

• 在目标方法执行前 进行增强代码。
• AspectJ 提供Advice无需实现任何借口， 可以将很多通知代码 写入一个类 （切面类）
• 前置通知定义方法： 无返回值，可以传入参数 JoinPoint 连接点

---

​​Spring框架教程【IDEA版】-Spring框架从入门到精通​​

简介：

本套Java视频教程主要讲解了Spring4在SSM框架中的使用及运用方式。本套Java视频教程内容涵盖了实际工作中可能用到的几乎所有知识点。为以后的学习打下坚实的基础。

什么是AOP？

AOP面向切面编程，是基于动态代理的。AOP就是动态代理的规范化，把动态代理的实习按步骤和方式都定义好了，让开发人员用一种统一的方式使用动态代理。

Aspect Orient Programming：面向切面编程

Aspect：切面。给目标类增加的功能就是切面。添加的日志信息和事务都是切面。

切面的最大特点就是：非业务方法，和我们的业务功能没有关系，可以独立使用的。

怎么理解面向切面编程：

1. 需要在分析项目时，找出切面。
2. 合理的安排切面的执行时间（是在目标方法前执行，还是在目标方法后执行）。
3. 合理的安排切面执行的位置（在哪个类，哪个方法增加增强功能）。

术语：

1. Aspect：切面，表示要给业务方法增强的功能，就是一堆代码，这堆代码完成某一个功能。切面是非业务功能（日志，事务，统计信息，参数检查，权限验证）
2. JoinPoint：连接点，连接业务方法和切面的位置，就是某个类中的业务方法。
3. PointCut：切入点，指多个连接点方法的结合。是多个方法，这些方法都要加入切面的功能。
4. 目标对象：要给哪个类增加方法
5. Advice：通知，表示切面功能的执行时间（切面在什么时候执行，是在方法之前还是在方法之后）

一个切面有3个关键的要素：

1. 切面的功能代码：切面要干什么
2. 切面的执行位置，使用pointcut表示
3. 切面的执行时间：在目标方法之前还是在目标方法之后，用advice表示

AOP的实现：是一个规范，是对动态代理的一个规范化。

AOP的技术实现框架：

1.Spring：Spring实现了AOP规范，主要在事务处理时使用了AOP。项目开发中很少使用Spring的AOP实现。

2.aspectJ：一个开源的专门做AOP的框架。Spring框架中集成了aspectJ框架，通过Spring就能使用aspectJ框架的功能了。aspectJ框架实现AOP有两种方式：

• 使用xml配置文件
• 使用注解（我们在项目中要做AOP功能，一般都使用注解），aspectJ有5个注解。

学习aspectJ框架的使用：

1、切面的执行时间，也就是advice通知。在aspectJ框架中是使用注解来表示的。

• @Before：
• @AfterReturning
• @Around
• @AfterThrowing
• @After

2、表示切面执行的位置，使用的是切入点表达式。

execution (访问权限 方法返回值 方法声明（参数）异常类型)

其中，访问权限和异常类型这两个可以省略。

切入点表达式要匹配的对象就是目标方法的方法名字。

举例：

execution（public **（..））：指定切入点为任意公共方法

execution（*set*（..））：指定切入点为任何一个以set开始的方法

execution（*com.xyz.service.*.*(..)）:指定切入点为com.xyz.service 包中的任意类中的任意方法

使用aspectJ框架实现aop

使用aop的目的是给已经存在的类和方法在不改变原来的代码的情况下增加额外的功能。

使用aspectJ实现AOP的基本步骤：

1. 新建maven项目
2. 加入依赖：（1）Spring依赖（2）aspectJ依赖(3)Junit 单元测试
3. 创建目标类：这个类有接口和接口的实现类。我们想要给这个类中的方法增加功能。
4. 创建切面类（增加功能的代码写在切面类里面）：普通类

• 在类的上面加入@Aspect注解
• 在类中定义切面方法，方法就是切面要执行的功能代码。在方法上面加入aspectJ中的通知注解，例如@Before，还需要指定切入点表达式。

 5.要把对象交给容器去创建，由容器Spring管理这些对象。

    创建Spring的配置文件，在配置文件中声明对象，把对象交给容器统一管理。声明对象可以使用注解或者xml的<bean>标签。

• 声明目标对象
• 声明切面类对象
• 声明aspectJ框架中的自动代理生成器标签。

    自动代理生成器：用来完成代理对象的自动创建功能的。

 6.创建测试类，从Spring容器中获取目标对象（这个对象实际就是代理对象）。通过代理执行方法，实现AOP的功能增强。

完整代码：

IDEA-Maven-模板选择quickstart-pom.xml添加相关依赖：（1）Spring依赖（2）aspectJ依赖(3)Junit 单元测试

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
  <!--单元测试-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
  </dependency>
  <!--Spring依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <!--aspectJ依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
</dependencies>

Maven查看添加的依赖：

Com.hik包下面的类和接口：

SomeService接口

package com.hik;
 
public interface SomeSeivece 
    void doSome(String name, Integer age);

 SomeService接口的实现类SomeServiceImpl

package com.hik;
 
public class SomeSeiveceImpl implements SomeSeivece 
    @Override
    public void doSome(String name, Integer age) 
        //给doSome()方法增加一个功能，在doSome执行之前，输出方法的执行时间
        System.out.println("目标方法doSome（）执行");
    

MyAspect类

package com.hik;
 
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
 
import java.util.Date;
 
/*
* @Aspect：是aspectJ这个框架中的注解。
* 作用：来表示当前类是切面类，切面类是给业务方法增加功能的类，在这个类中有切面的功能代码
* 注解的使用位置：在切面类的定义上面
* */
@Aspect
public class MyAspect 
    /*
    * 定义方法：方法是实现切面功能的。
    * 方法的定义要求：
    * 1.公共方法public
    * 2.方法没有返回值
    * 3.方法名称是自定义的
    * 4.方法可以有参数也可以没有参数。如果有参数，参数不是自定义的，有几个参数类型可供使用
    * */
 
    /*
    * @Before：前置通知注解
    * 这个注解是有属性值的，属性值是value：是切入点表达式execution（）,表示切面的功能执行的位置
    *@Befor注解的位置：是在方法上面添加注解
    * 特点：
    * 1.在目标方法之前先执行
    * 2.不会改变目标方法的执行结果
    * 3.不会影响目标方法的运行
    * */
    /*execution(访问修饰符 包名.类名.方法名（参数类型1，参数类型2...）)*/
    @Before(value = "execution(public void com.hik.SomeSeiveceImpl.doSome(String,Integer))")
    public void myBefore()
        //就是切面要执行的功能代码
        System.out.println("前置通知，切面功能：在目标方法之前输出执行时间：" + new Date());
    

main目录下的resource中设置配置文件：applicationcontext.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.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--把对象交给Spring容器，由Spring容器统一创建和管理对象-->
    <!--声明目标对象-->
    <bean id="someService" class="com.hik.SomeSeiveceImpl"></bean>
 
    <!--声明切面对象-->
    <bean id="myAspect" class="com.hik.MyAspect"></bean>
 
    <!--声明自动代理生成器：使用aspectJ框架内部的功能，创建目标对象的代理对象。
        创建代理对象是在内存中实现的，修改目标对象的内存中结构。
        创建为代理对象，所以，目标对象就是被修改后的代理对象-->
    <!--这个标签会把容器中所有的对象都找到，然后，按照切入点表达式的声明信息，找到目标生成目标的代理，
        会把Spring中的目标对象一次性都生成代理对象-->
    <aop:aspectj-autoproxy>
 
    </aop:aspectj-autoproxy>

测试类

package com.hik;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MyTest 
    @Test
    public void Test01()
        String config = "applicationcontext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeSeivece proxy = (SomeSeivece) applicationContext.getBean("someService");
        //通过代理对象执行方法，实现目标方法执行时，增强了功能
        proxy.doSome("Rita", 18);
    

执行结果：

前置通知，切面功能：在目标方法之前输出执行时间：Thu Jan 13 16:30:16 CST 2022

目标方法doSome（）执行

Process finished with exit code 0