spring aop 示例

刺骨的言语ヽ痛彻心扉 2023-02-17 15:58 18阅读 0赞

项目代码下载链接  [https://download.csdn.net/download/boss\_way/12523064][https_download.csdn.net_download_boss_way_12523064]

新建一个maven 项目：

大概如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jvc3Nfd2F5_size_16_color_FFFFFF_t_70][]

第一步 修改pom 增加依赖：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.aop</groupId>
        <artifactId>spring4Aop</artifactId>
        <version>1.0-SNAPSHOT</version>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.1.6.RELEASE</version>
            </dependency>
            <dependency>
                
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>4.1.6.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.8.9</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.9</version>
            </dependency>
    
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

第二步 声明一个注解 在定义切点的时候 使用这个注解类：

package aop;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * Created by lovejing on 2020/6/14
     *  声明一个注解  定义一个参数 name  这个注解将在切面的切点中使用
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface LogAnnotation {
        String name();
    }

第三步 写一个aop 拦截类，一个是注解方式 一个是方法规则拦截的方式

package aop;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    
    /**
     * Created by lovejing on 2020/6/14.
     */
    @Aspect
    @Component
    public class LogAspect {
        //声明切点 也就是所有使用到 注解LogAnnotaiton 的位置都会执行定义的
        @Pointcut("@annotation(aop.LogAnnotation)")
        public void annotationPointcut(){};
    
        @After("annotationPointcut()")
        public void after(JoinPoint joinPoint){
            MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
            Method method = methodSignature.getMethod();
            LogAnnotation annotation = method.getAnnotation(LogAnnotation.class);
            System.out.println("注解方式拦截获取的信息："+annotation.name());
        }
    
        @Before("execution(* aop.UseAopMethodService.*(..))")
        public void before(JoinPoint joinPoint){
            MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
            Method method = methodSignature.getMethod();
            String name = method.getName();
            System.out.println("方法规则拦截："+name);
        }
    }

第四步 写两个类 分别使用注解 ，和不适用注解 都达到 aop拦截的效果:

package aop;
    
    import org.springframework.stereotype.Service;
    
    /**
     * Created by lovejing on 2020/6/14.
     * 这个 是使用方法拦截规则
     */
    @Service
    public class UseAopMethodService {
    
        // 使用方法规则拦截
        public void userMethodAop(){}
        public void userMethodAop333(){}
    
    }

package aop;
    
    import org.springframework.stereotype.Service;
    
    /**
     * Created by lovejing on 2020/6/14.
     * 这个类的方法是使用注解 拦截规则示例
     */
    @Service
    public class UseAopService {
        // 只需要使用这个注解即可执行 注解aop中的过滤逻辑
        @LogAnnotation(name = "这个参数传入给注解定义的变量中1")
        public void useAop(){};
    
        @LogAnnotation(name = "这个参数传入给注解定义的变量中2")
        public void useAop2(){};
    }

第五步 写一个springboot 的配置类：启动配置，配置扫描包位置，开启aop支持

package config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    import org.springframework.stereotype.Component;
    
    /**
     * Created by lovejing on 2020/6/14.
     * spring boot  可以使用配置java类 来替代xml
     */
    @Configuration
    @ComponentScan("aop")
    @EnableAspectJAutoProxy
    public class SpringBootConfig {
    
    }

第六步 写一个main方法，加载context 获取上面的bean 并执行 被注解修饰的方法：

package main;
    
    import aop.UseAopMethodService;
    import aop.UseAopService;
    import config.SpringBootConfig;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /**
     * Created by lovejing on 2020/6/14.
     * main 方法 new 一个contenxt 并获取bean 执行方法。
     */
    public class AopMain {
        public static  void main (String[] args){
            AnnotationConfigApplicationContext applicationContext= new AnnotationConfigApplicationContext(SpringBootConfig.class);
           UseAopMethodService useAopMethodService =  applicationContext.getBean(UseAopMethodService.class);
           UseAopService useAopService = applicationContext.getBean(UseAopService.class);
    
           useAopService.useAop();
           useAopService.useAop2();
    
           useAopMethodService.userMethodAop();
           useAopMethodService.userMethodAop333();
    
           applicationContext.close();
        }
    }

运行mian 方法，跟踪代码执行流程 就可以看到 通过注解和 方法规则写的aop 都是生效的：

![20200614235638513.png][]

[https_download.csdn.net_download_boss_way_12523064]: https://download.csdn.net/download/boss_way/12523064
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jvc3Nfd2F5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200614235110674.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jvc3Nfd2F5,size_16,color_FFFFFF,t_70
[20200614235638513.png]: https://img-blog.csdnimg.cn/20200614235638513.png