自定义注解的使用

1.定义一个自定义注解

package xxx.xxxx.xxxx.aop;

import org.springframework.core.annotation.Order;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Order(value = Integer.MAX_VALUE)
public @interface PreConsumer {

    
    boolean isCheck() default true;

    int upperLimitValue() default 5;

}

解释说明：

@Target:表示注解的作用范围，可选范围是枚举值，包括类、字段、方法、参数、构造方法、本地变量、注解类型等

@Retention：表示注解的作用范围，按生命周期来划分可分为3类：
   1、RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；
   2、RetentionPolicy.CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期；
   3、RetentionPolicy.RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在；

@Target 和 @Retention 是自定义注解必须声明的。

@Order 是排序作用，声明切面的执行顺序，值越小优先级越高

方法体：可以声明返回值类型，同时可以指定默认值。

至此，自定义注解就写完了，如何使用呢？ 一般通过aop的方式

package xx.xx.xx.xx;

import xx.*;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

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


@Component
@Aspect
public class PreConsumerAspect {

    private static final Logger logger = LoggerFactory.getLogger(PreConsumerAspect.class);

    private static final String OVERRIDE_METHOD = "onMessage";
    private static final String CAT_TYPE = "SERVICE";

    @Pointcut("execution(public * xx.xx.*.*(..))")
    public void syncPointCut() {
    }

    //@@Around("syncPointCut()  || checkPointCut()")
    @Around("syncPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {


        Object[] args = null;
            //获取注解所在类下所有的方法
            Class clazz = joinPoint.getSignature().getDeclaringType();
            Method[] methods = clazz.getMethods();
            Method tagMethod = null;
            for (Method method : methods) {
                //判断方法上有@PreConsumer注解的
                if (method.isAnnotationPresent(PreConsumer.class)) {
                    tagMethod = method;
                    break;
                }
            }
            if (Objects.isNull(tagMethod)) {
                //如果没找到@PreConsumer注解的不拦截
                logger.warn("【{}】没找到@PreConsumer注解的不拦截", clazz);
                return joinPoint.proceed();
            }
            PreConsumer preConsumer = tagMethod.getAnnotation(PreConsumer.class);
            if (!preConsumer.isCheck()) {
                //如果isCheck=false 则不拦截
                return joinPoint.proceed();
            }
            //获取拦截阈值 ，小于3的按最小3次处理
            Integer upperLimitValue = preConsumer.upperLimitValue() < 3 ? 3 : preConsumer.upperLimitValue();
            //获取方法参数
            args = joinPoint.getArgs();
            String methodName = joinPoint.getSignature().getName();
            //方法名不是 onMessage || 参数为空 || 参数数量大于1 || 参数类型不是String , @PreConsumer注解只在实现了@RocketMQMessageListener接口的重写方法onMessage上
            if (!Objects.equals(methodName, OVERRIDE_METHOD) || Objects.isNull(args) || args.length > 1 || !(args[0] instanceof String)) {
                //不满足则直接返回
                String declaringTypeName = joinPoint.getSignature().getDeclaringTypeName();
                logger.warn("方法名是【{}】，不是实现了@RocketMQMessageListener接口的方法 或者不是重写onMessage方法,或者参数不是String类型，不做拦截", declaringTypeName + "." + methodName);
                return joinPoint.proceed();
            }
            String message = (String) args[0];
            JSONObject jsonObject = JSON.parseObject(message);
            //消息体里没有upper_limit_value这个字段则设置这个字段的值为0，有则+1
            Integer value = Objects.isNull(jsonObject.getInteger(BinlogKey.EXPAND_UPPER_LIMIT_VALUE)) ? 0 : jsonObject.getInteger(BinlogKey.EXPAND_UPPER_LIMIT_VALUE) + 1;
            logger.warn("方法【{}】的阈值为【{}】，当前消息的实际值是：【{}】", clazz, upperLimitValue, value);
            //如果设置的不增加则值不变
            //value = preConsumer.isIncrease() ? value +1 : value;
            //需要将这个值设置到消息体中，在sync和check之间传递
            jsonObject.put(BinlogKey.EXPAND_UPPER_LIMIT_VALUE, value);
            //消息体的value大于设置的阈值则停止消费
            if (value.compareTo(upperLimitValue) > 0) {
                logger.info("方法【{}.{}】消费消息阈值大于【{}】，停止消费", clazz, methodName, upperLimitValue, message);
                String msg = "方法" + clazz + "." + methodName + "消费消息，实际值 (" + value + ") 大于阈值(" + upperLimitValue + "),停止消费";
                return joinPoint;
            }
            logger.warn("方法【{}.{}】的阈值为【{}】，当前消息的实际值是：【{}】,继续消费", clazz, methodName, upperLimitValue, value);
            //否则继续消费
            args[0] = jsonObject.toJSONString();
            return joinPoint.proceed(args);

        } 
    }
}

这段代码是实际项目中RocketMQ消费的场景，结合自己的业务架构，在消费的时候防止在两个系统之间无限循环消费，在其中一个系统上加上一段切面，就用这个自定义注解实现，具体的使用方式要了解了aop的使用方式就很好理解.