首页 > 编程语言 >开始使用AspectJ-实现步骤@Aspect,@Before,还有其中的JoinPoint参数

开始使用AspectJ-实现步骤@Aspect,@Before,还有其中的JoinPoint参数

时间:2022-11-05 21:15:05浏览次数:50  
标签:void JoinPoint AspectJ 切面 Aspect 执行 方法 public Before

开始使用AspectJ

1.maven依赖

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
插件
<build>
<plugins>
 <plugin>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.1</version>
 <configuration>
 <source>1.8</source>
 <target>1.8</target>
 </configuration>
     </plugin>
</plugins>
</build>

引入 AOP 约束

在 AspectJ 实现 AOP 时,要引入 AOP 的约束。配置文件中使用的 AOP 约束中的标签, 均是 AspectJ 框架使用的,而非 Spring 框架本身在实现

AOP 时使用的。 AspectJ 对于 AOP 的实现有注解和配置文件两种方式,常用是注解方式。

2. AspectJ 基于注解的 AOP 实现(掌握)

项目结构如下:

2.1 实现步骤

  • Step1:定义业务接口与实现类

    接口:

    package com.bjpowernode.ba01;
    
    public interface SomeService {
        void doSome(String name,Integer age);
    }
    

    接口实现类:

    package com.bjpowernode.ba01;
    
    //目标类
    public class SomeServiceImpl implements SomeService {
        @Override
        public void doSome(String name,Integer age) {
            //给doSome方法增加一个功能,在doSome()执行之前, 输出方法的执行时间
            System.out.println("====目标方法doSome()====");
        }
    
        public void doOther(String name,Integer age) {
            //给doSome方法增加一个功能,在doSome()执行之前, 输出方法的执行时间
            System.out.println("====目标方法doSome()====");
        }
    }
    
    

    Step2:定义切面类此时我们用的是 @Before

    package com.bjpowernode.ba01;
    
    import org.aspectj.lang.JoinPoint;
    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 ,是切入点表达式,表示切面的功能执行的位置。
         *   位置:在方法的上面
         * 特点:
         *  1.在目标方法之前先执行的
         *  2.不会改变目标方法的执行结果
         *  3.不会影响目标方法的执行。
         */
       @Before(value = "execution(public void com.bjpowernode.ba01.SomeServiceImpl.doSome(String,Integer))")
        public void myBefore(){
            //就是你切面要执行的功能代码
            System.out.println("前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
        }
        
        //可以省略 public
        /*@Before(value = "execution(void com.bjpowernode.ba01.SomeServiceImpl.doSome(String,Integer))")
        public void myBefore(){
            //就是你切面要执行的功能代码
            System.out.println("1=====前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
        }*/
    
       //使用 <*..>的方法表明不管上级多少目录的SomeServiceImpl的方法   
       /*  @Before(value = "execution(void *..SomeServiceImpl.doSome(String,Integer))")
        public void myBefore(){
            //就是你切面要执行的功能代码
            System.out.println("2=====前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
        }*/
    
        //其中返回值也可以用 * 号代替
        /*@Before(value = "execution(* *..SomeServiceImpl.*(..))")
        public void myBefore(){
            //就是你切面要执行的功能代码
            System.out.println("3=====前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
        }*/
    
        //可以使用 * 号作为通配符,只要是do开头的都可以被动态代理识别
        /*@Before(value = "execution(* do*(..))")
        public void myBefore2(){
            //就是你切面要执行的功能代码
            System.out.println("4=====前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
        }*/
    
    
        //形式参数可以被 <..> 代替
        /*@Before(value = "execution(* com.bjpowernode.ba01.*ServiceImpl.*(..))")
        public void myBefore2(){
            //就是你切面要执行的功能代码
            System.out.println("2=====前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
        }*/
    
    }
    
    

    Step3:声明目标对象切面类对象 此时我们用的配置文件,在文件种需要注册aspectj的自动代理生成器对象

    在定义好切面 Aspect 后,需要通知 Spring 容器,让容器生成“目标类+ 切面”的代理 对象。这个代理是由容器自动生成的。只需要在 Spring 配置文件中注册一个基于 aspectj 的 自动代理生成器,其就会自动扫描到@Aspect 注解,并按通知类型与切入点,将其织入,并 生成代理。

    <?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.bjpowernode.ba01.SomeServiceImpl" />
    
        <!--声明切面类对象-->
        <bean id="myAspect" class="com.bjpowernode.ba01.MyAspect" />
    
        <!--声明自动代理生成器:使用aspectj框架内部的功能,创建目标对象的代理对象。
            创建代理对象是在内存中实现的, 修改目标对象的内存中的结构。 创建为代理对象
            所以目标对象就是被修改后的代理对象.
            aspectj-autoproxy:会把spring容器中的所有的目标对象,一次性都生成代理对象。
        -->
        <aop:aspectj-autoproxy />
    
    </beans>
    

2.2 [掌握]@Before 前置通知-方法有 JoinPoint 参数

在目标方法执行之前执行。被注解为前置通知的方法,可以包含一个 JoinPoint 类型参 数。该类型的对象本身就是切入点表达式。通过该参数,可获取切入点表达式、方法签名、 目标对象等。 不光前置通知的方法,可以包含一个 JoinPoint 类型参数,所有的通知方法均可包含该 参数。

package com.bjpowernode.ba01;

import org.aspectj.lang.JoinPoint;
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 ,是切入点表达式,表示切面的功能执行的位置。
     *   位置:在方法的上面
     * 特点:
     *  1.在目标方法之前先执行的
     *  2.不会改变目标方法的执行结果
     *  3.不会影响目标方法的执行。
     */


    /**
     * 指定通知方法中的参数 : JoinPoint
     * JoinPoint:业务方法,要加入切面功能的业务方法
     *    作用是:可以在通知方法中获取方法执行时的信息, 例如方法名称,方法的实参。
     *    如果你的切面功能中需要用到方法的信息,就加入JoinPoint.
     *    这个JoinPoint参数的值是由框架赋予, 必须是第一个位置的参数
     */
    @Before(value = "execution(void *..SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(JoinPoint jp){
        //获取方法的完整定义
        System.out.println("方法的签名(定义)="+jp.getSignature());
        System.out.println("方法的名称="+jp.getSignature().getName());
        //获取方法的实参
        Object args [] = jp.getArgs();
        for (Object arg:args){
            System.out.println("参数="+arg);
        }
        //就是你切面要执行的功能代码
        System.out.println("2=====前置通知, 切面功能:在目标方法之前输出执行时间:"+ new Date());
    }
}

代码执行结果如下;(执行的还是上述方法)

标签:void,JoinPoint,AspectJ,切面,Aspect,执行,方法,public,Before
From: https://www.cnblogs.com/atao-BigData/p/16861279.html

相关文章