Spring纯注解实现AOP

作者: 瓢鳍小虾虎 | 来源:发表于2021-03-24 00:01 被阅读0次

Spring纯注解实现AOP
AOP笔记
Spring Aop支持
06 AOP
Spring之使用注解配置Spring AOP
web填坑-AOP
第12章-Spring基于注解配置AOP
Spring_9 Spring基于AspectJ AOP 注解实
Spring AOP
Spring源码之Aop

依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
<!--        aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>

开启AOP

@ComponentScan("com.study")
@EnableAspectJAutoProxy(exposeProxy = true, proxyTargetClass = true)
public class GoodsServiceApplication {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(GoodsServiceApplication.class);
        context.start();

        System.in.read();
        context.close();
    }
}

切面

package com.study;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;

@Aspect
@Component
public class TestLimitAnnotationAspect {

    /**
     * 定义切点,这里根据需求调整表达式
     */
    @Pointcut("@annotation(com.study.dubbo.goods.TestLimitAnnotation)")
    public void pcut() {
    }

    @Around("pcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before------>")
        Object result = pjp.proceed();
        System.out.println("after------>")
        return pjp.proceed();
    }
}

拓展
如果你的程序分模块了，你想让当前的切面支持其他业务模块，但是其他模块的启动类又无法scan到这个实现类。这时候你可以在程序加载的过程中手动注册这个切面。

package com.study.common;

import com.study.rpc.permitsLimit.spring.aspect.RatePermitsAspect;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

// 通过继承ImportBeanDefinitionRegistrar，手动加载自定义的class，这个过程处在bean被创建之前，因此不能用bean或者override注解
public class MyConfiguration implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
                                        BeanNameGenerator importBeanNameGenerator) {

        String beanName;

        // 手动注册Aspect
        beanName = "ratePermitsAspect";
        registerAspect(beanName, registry, RatePermitsAspect.class);

    }

    private void registerAspect(String beanName, BeanDefinitionRegistry registry, Class configClass) {
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(configClass);
        registry.registerBeanDefinition(beanName, beanDefinitionBuilder.getBeanDefinition());
    }
}

然后写一个注解import上面的实现类，把这个注解加到其他模块的启动类上面

package com.study.annotation;

import com.study.common.MyConfiguration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Import;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 使用spring注解的import扩展功能
 */
@Target(value = ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@EnableAspectJAutoProxy(exposeProxy = true, proxyTargetClass = true) // 开启aop功能
@Import({MyConfiguration.class})
public @interface EnableMyCommon {
}