spring aop 示例

项目代码下载链接  https://download.csdn.net/download/boss_way/12523064

新建一个maven 项目：

大概如下:

第一步 修改pom 增加依赖：

    4.0.0

    com.aop
    spring4Aop
    1.0-SNAPSHOT
    
        
            org.springframework
            spring-context
            4.1.6.RELEASE
        
        
            
            org.springframework
            spring-aop
            4.1.6.RELEASE
        
        
            org.aspectj
            aspectjrt
            1.8.9
        
        
            org.aspectj
            aspectjweaver
            1.8.9
        

    
    
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    1.8
                    1.8
                
            
        
    

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

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 都是生效的：