spring-AOP（面向切面编程)-注解方式自定义配置切入点

前言
用Spring 的AOP来简化处理自定义注解，并将通过实现一个简单的方法执行判断节点是否开始的状态示列源码。

AOP概念
面向侧面的程序设计（aspect-oriented programming，AOP，又译作面向方面的程序设计、观点导向编程、剖面导向程序设计）是计算机科学中的一个术语，指一种程序设计范型。该范型以一种称为侧面（aspect，又译作方面）的语言构造为基础，侧面是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点（crosscutting concern）。

创建一个自定义注解类：

package com.common.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 自定义注解
 * @Description 自定义注解@HAStatusCheck  拦截service层   HAStatusCheckService
 * @Author Justin zeng 
 * @Date 2019-04-19
 * @version 1.0
 */
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface HAStatusCheck {
	//自定义的方法描述信息 
	String description()  default "";
}

@Target
自定义注解的使用范围
ElementType.METHOD：方法声明
ElementType.TYPE：类、接口（包括注解类型）或enum声明
ElementType.CONSTRUCTOR：构造器的声明
ElementType.FIELD：域声明（包括enum实例）
ElementType.LOCAL_VARIABLE：局部变量声明
ElementType.PACKAGE：包声明
ElementType.PARAMETER：参数声明

@Retention
注解级别信息
RetentionPolicy.RUNTIME：VM运行期间保留注解，可以通过反射机制读取注解信息
RetentionPolicy.SOURCE：注解将被编译器丢弃
RetentionPolicy.CLASS：注解在class文件中可用，但会被VM丢弃

@Document
将注解包含在Javadoc中

@Inherited
允许子类继承父类中的注解，默认不能被子类继承

建一个切点类实现你的要处理的事情

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author wangl
 * @date 2018/10/24
 */
@Aspect //这个注解标识当前的类为一个切面
@Component //标识容器受管的Bean对象
public class UserServiceAspect {

    /**
     * 声明一个切入点,并编写切入点表达式
     *  xxx包路径
     */
    @Pointcut("@annotation(xxx.xxx.xxx.HAStatusCheck)")
    public void pointcut(){
    }

    /**
     * 前置通知,指定切入点函数
     * 也可在注解中自定义不同的切入点表达式
     * @Before("execution(...)")
     *
     */
    @Before("pointcut()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知..."+joinPoint.getArgs()[0]);
    }

    /**
     * 后置通知
     */
    @AfterReturning(value = "pointcut()", returning = "returnVal")
    public void afterReturn(String returnVal){
        System.out.println("后置通知..." + returnVal);
    }

    /**
     * 环绕通知
     */
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知前...");
        Object returnVal = pjp.proceed();
        System.out.println("环绕通知后...");
        return returnVal;
    }

    /**
     * 异常通知
     * 通过pointcut指定切入点
     */
    @AfterThrowing(pointcut = "pointcut()", throwing = "e")
    public void throwableAdvice(Throwable e){
        System.out.println("异常通知..." + e.getMessage());
    }

    /**
     * 最终通知
     */
    @After("pointcut()")
    public void after(){
        System.out.println("最终通知...");
    }

}

最后
在你需要的判断预处理的地方加上自定义的注解 @HAStatusCheck

import com.annotation.HAStatusCheck;
 
import lombok.extern.slf4j.Slf4j;
 
@Slf4j
public class TestJob {
    //这就是上面自定义的注解
	@HAStatusCheck
	public void job() throws Exception {
		System.out.println("TestJob job run ....");
	}
}

这样自定义注解开发就结束了，需要的可以试试吧，希望能帮到大家。