常用自定义注解

最新推荐文章于 2025-04-28 10:42:10 发布
最新推荐文章于 2025-04-28 10:42:10 发布
阅读量649 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java Spring & Spring Boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014745069/article/details/119203362
该博客介绍了如何利用Spring AOP实现三个方面：1)方法执行计时，通过`MethodTimer`注解记录方法执行时间；2)参数校验的通用返回，借助`ValidCommonResp`注解简化错误处理；3)接口访问频次拦截，通过`Ide`注解实现幂等性，防止短时间内重复请求。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

导航

一、方法计时器

注解类：MethodTimer

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodTimer {
}

处理器（需要AOP和spring的支持）：MethodTimerProcessor

@Slf4j
@Component
@Aspect
public class MethodTimerProcessor {

    /**
     * 处理 @MethodTimer 注解
     */
    @Around("@annotation(methodTimer)")
    public Object timerAround(ProceedingJoinPoint point, MethodTimer methodTimer) throws Throwable {
        long beginMills = System.currentTimeMillis();
        // process the method
        Object result = point.proceed();
        log.info("{} 耗时 : {} ms", point.getSignature(), System.currentTimeMillis() - beginMills);
        return result;
    }
}

使用方法：直接标记在 Controller 的方法上。

二、valid 参数校验的通用返回

注解类：ValidCommonResp

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidCommonResp {
}

处理器（aop+spring）：ValidCommonRespProcessor

@Slf4j
@Aspect
@Component
public class ValidCommonRespProcessor {
    /**
     * 处理 @ValidCommonResp 注解.
     * 注意，BindingResult是Spring validation的校验结果，
     * 当参数传入 BindingResult后,Spring MVC就不再控制校验
     * 结果的返回，如果不希望使用 @ValidCommonResp的校验结果
     * 封装，请在方法中实现校验结果的处理，二者任选其一。
     *
     * @author mouhaotian
     */
    @Around("@annotation(validCommonResp)")
    public Object aroundAdvice(ProceedingJoinPoint point, ValidCommonResp validCommonResp) throws Throwable {
        Object[] args = point.getArgs();
        for (Object arg : args) {
            if (arg instanceof BindingResult) {
                BindingResult bindingResult = (BindingResult) arg;
                if (bindingResult.hasErrors()) {
                    FieldError fieldError = bindingResult.getFieldError();
                    CommonResp commonResp = new CommonResp(
                            CommonCode.FAIL,
                            fieldError.getField() + fieldError.getDefaultMessage());
                    return R.data(commonResp);
                }
                break;
            }
        }
        Object result = point.proceed(args);
        return result;
    }
}

使用方法：搭配 validation 注解、BindingResult 一起使用：

    @PostMapping("/xxxx")
    @ValidCommonResp
    public R submit(@Valid @RequestBody DoorzoneInfo doorzoneInfo, BindingResult result) {
        log.info("请求{}", doorzoneInfo);
        R commonResp = doorzoneInfoService.insertOrUpdDoorzoneInfo(doorzoneInfo);
        log.info("响应{}", commonResp);
        return commonResp;
    }

好处：可以替代代码块中处理 BindingResult 的逻辑。

三、接口访问频次拦截（幂等）

实现一个注解，当controller中的方法收到请求后，在一定时间之内（如10s内）拒绝接收相同参数的请求。即对后台接口的访问增加了频次限制，可以理解为一种不是特别标准的幂等。

注解 @Ide

/**
 * 幂等校验注解类
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Ide {

	/**
	 * 关键key
	 * key是本次请求中参数的键，
	 * 重复请求的key取自header中的rid
	 * 用来标识这个请求的唯一性
	 * 拦截器中会使用key从请求参数中获取value
	 *
	 * @return String
	 */
	String key() default "";

	/**
	 * 自定义key的前缀用来区分业务
	 */
	String perFix();

	/**
	 * 自定义key的超时时间(基于接口)
	 */
	String expireTime();

	/**
	 * 禁止重复提交的模式
	 * 默认是全部使用
	 */
	IdeTypeEnum ideTypeEnum() default IdeTypeEnum.ALL;
}

AOP 横切处理逻辑

/**
 * 注解执行器 处理重复请求 和串行指定条件的请求
 * <p>
 * 两种模式的拦截
 * 1.rid 是针对每一次请求的
 * 2.key+val 是针对相同参数请求
 * </p>
 * <p>
 * 另根据谢新的建议对所有参数进行加密检验，提供思路，可以自行扩展
 * DigestUtils.md5Hex(userId + "-" + request.getRequestURL().toString()+"-"+ JSON.toJSONString(request.getParameterMap()));
 * 或 DigestUtils.md5Hex(ip + "-" + request.getRequestURL().toString()+"-"+ JSON.toJSONString(request.getParameterMap()));
 * </p>
 */
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
@ConditionalOnClass(RedisService.class)
public class IdeAspect extends BaseAspect {

	private final ThreadLocal<String> PER_FIX_KEY = new ThreadLocal<String>();

	/**
	 * 配置注解后 默认开启
	 */
	private final boolean enable = true;

	/**
	 * request请求头中的key
	 */
	private final static String HEADER_RID_KEY = "RID";

	/**
	 * redis中锁的key前缀
	 */
	private static final String REDIS_KEY_PREFIX = "RID:";

	/**
	 * 锁等待时长
	 */
	private static int LOCK_WAIT_TIME = 10;

	private final RedisService redisService;

	@Autowired
	IdeAspectConfig ideAspectConfig;

	@Pointcut("@annotation(cn.com.bmac.wolf.core.ide.annotation.Ide)")
	public void watchIde() {

	}

	@Before("watchIde()")
	public void doBefore(JoinPoint joinPoint) {
		Ide ide = getAnnotation(joinPoint, Ide.class);

		if (enable && null != ide) {
			ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
			if (null == attributes) {
				throw new IdeException("请求数据为空");
			}
			HttpServletRequest request = attributes.getRequest();
			//根据配置文件中的超时时间赋值
			if (Func.isNotBlank(ideAspectConfig.getExpireTime())) {
				if(Func.isNumeric(ideAspectConfig.getExpireTime())){
					LOCK_WAIT_TIME = Integer.parseInt(ideAspectConfig.getExpireTime());
				}
			}
			//根据注解传参赋值
			if(Func.isNotBlank(ide.expireTime())){
				LOCK_WAIT_TIME = Integer.parseInt(ide.expireTime());
			}
			//1.判断模式
			if (ide.ideTypeEnum() == IdeTypeEnum.ALL || ide.ideTypeEnum() == IdeTypeEnum.RID) {
				//2.1.通过rid模式判断是否属于重复提交
				String rid = request.getHeader(HEADER_RID_KEY);

				if (Func.isNotBlank(rid)) {
					Boolean result = redisService.tryLock(REDIS_KEY_PREFIX + rid, LOCK_WAIT_TIME);
					if (!result) {
						throw new IdeException("命中RID重复请求");
					}
					log.debug("msg1=当前请求已成功记录,且标记为0未处理,,{}={}", HEADER_RID_KEY, rid);
				} else {
					log.warn("msg1=header没有rid,防重复提交功能失效,,remoteHost={}" + request.getRemoteHost());
				}
			}
			boolean isApiExpireTime = false;
			if (ide.ideTypeEnum() == IdeTypeEnum.ALL
					|| ide.ideTypeEnum() == IdeTypeEnum.KEY) {
				//2.2.通过自定义key模式判断是否属于重复提交
				String key = ide.key();
				if (Func.isNotBlank(key)) {
					String val = "";
					Object[] paramValues = joinPoint.getArgs();
					String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();
					//获取自定义key的value
					String[] keys = key.split("\\|");

					for(int i = 0; i < keys.length; i++){
						for (int j = 0; j < paramNames.length; j++) {
							//BindingResult 不能转json，会导致线程报错终止
							if (paramValues[j] instanceof BindingResult) {
								continue;
							}
							String params = JSON.toJSONString(paramValues[j]);
							if (params.startsWith("{")) {
								//如果是对象
								//通过key获取value
								JSONObject jsonObject = JSON.parseObject(params);
								val = val + jsonObject.getString(keys[i]);
							} else if (keys[i].equals(paramNames[j])) {
								//如果是单个k=v
								val = val + params;
							} else {
								//如果自定义的key,在请求参数中没有此参数,说明非法请求
								log.warn("自定义的key,在请求参数中没有此参数,防重复提交功能失效");
							}
						}
					}


					//判断重复提交的条件
					String perFix = "";
					if (Func.isNotBlank(val)) {
						String[] perFixs = ide.perFix().split("\\|");
						int perFixsLength = perFixs.length;
						for(int i = 0; i < perFixs.length; i++){
							if(Func.isNotBlank(perFix)){
								perFix = perFix + ":" + perFixs[i];
							}else{
								perFix = perFixs[i];
							}
						}
						perFix = perFix + ":" + val;
						Boolean result = true;
						try {
							result = redisService.tryLock(perFix, LOCK_WAIT_TIME);
						} catch (Exception e) {
							log.error("获取redis锁发生异常", e);
							throw e;
						}
						if (!result) {
							String targetName = joinPoint.getTarget().getClass().getName();
							String methodName = joinPoint.getSignature().getName();
							log.error("msg1=不允许重复执行,,key={},,targetName={},,methodName={}", perFix, targetName, methodName);
							throw new IdeException("不允许重复提交");
						}
						//存储在当前线程
						PER_FIX_KEY.set(perFix);
						log.info("msg1=当前请求已成功锁定:{}", perFix);
					} else {
						log.warn("自定义的key,在请求参数中value为空,防重复提交功能失效");
					}
				}
			}
		}
	}

	@After("watchIde()")
	public void doAfter(JoinPoint joinPoint) throws Throwable {
		try {
			Ide ide = getAnnotation(joinPoint, Ide.class);
			if (enable && null != ide) {

				if (ide.ideTypeEnum() == IdeTypeEnum.ALL
						|| ide.ideTypeEnum() == IdeTypeEnum.RID) {
					ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
					HttpServletRequest request = attributes.getRequest();
					String rid = request.getHeader(HEADER_RID_KEY);
					if (Func.isNotBlank(rid)) {
						try {
							log.info("msg1=当前请求已成功处理,,rid={}", rid);
						} catch (Exception e) {
							log.error("释放redis锁异常", e);
						}
					}
					PER_FIX_KEY.remove();
				}

				if (ide.ideTypeEnum() == IdeTypeEnum.ALL
						|| ide.ideTypeEnum() == IdeTypeEnum.KEY) {
					// 自定义key
					String key = ide.key();
					if (Func.isNotBlank(key) && Func.isNotBlank(PER_FIX_KEY.get())) {
						try {
							log.info("msg1=当前请求已成功释放,,key={}", PER_FIX_KEY.get());
							PER_FIX_KEY.set(null);
							PER_FIX_KEY.remove();
						} catch (Exception e) {
							log.error("释放redis锁异常", e);
						}
					}
				}
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
	}
}

其他相关类

@Data
@Component
@ConfigurationProperties(prefix = "ide")
public class IdeAspectConfig {
	/**
	 * 过期时间 秒
	 */
	private String expireTime;

}

@Getter
@AllArgsConstructor
public enum IdeTypeEnum {

	/**
	 * 0+1
	 */
	ALL(0, "ALL"),
	/**
	 * ruid 是针对每一次请求的
	 */
	RID(1, "RID"),
	/**
	 * key+val 是针对相同参数请求
	 */
	KEY(2, "KEY");

	private final Integer index;
	private final String title;
}
Java自定义注解与AOP的完美融合
Angindem博客
01-22 1009
AOPAspectOrientedProgramming(面向切面编程、面向方面编程)，其实就是面向特定方法编程。我们想象一个场景，我们写的系统中的某个部分功能运行较慢，需要定位执行耗时较长的业务方法，此时需要统计每一个业务方法的执行耗时。如果我们对每一个业务方法手动的插入检查，这将会是巨大的工程量，且改动原始方法的过程中也会不小心疏忽。所以，我们提出 AOP 概念，面对不同的方法，我们重复使用一个功能的时候，我们设计出一个模板套用即可。
自定义注解类
无名老仙
07-30 1108
一、注解的定义 An annotation is a form of metadata, that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated. Annotations have no direct effect on the operation of the code they annotate. --注解是一种能被添加到java代码中的元数据
开发中常用注解及自定义注解
Fzxey的博客
08-25 573
文章目录常见的注解：java自带的注解第三方注解元注解自定义注解 在java中注解是一个很重要的组成部分，使用注解能够使代码更加简洁，动态的提高代码的扩展性和可维护性。 按照来源分类： java自带的注解 第三方提供的注解 自定义的注解 元注解 常见的注解： java自带的注解 @Override 重写 @Test 测试 @Deprecated 方法过时 @SuppresWarning 忽略...
自定义注解！绝对是程序员装逼的利器！！
热门推荐
HollisChuang's Blog
11-10 1万+
GitHub 18k Star 的Java工程师成神之路，不来了解一下吗！ GitHub 18k Star 的Java工程师成神之路，真的不来了解一下吗！ GitHub 18k Star 的Java工程师成神之路，真的真的不来了解一下吗！ 相信很多人对Java中的注解都很熟悉，比如我们经常会用到的一些如@Override、@Autowired、@Service等，这些都是JDK或者诸如Spring这类框架给我们提供的。 在以往的面试过程中，我发现，关于注解的知识很多程序员都仅仅停留在使用的层面上，很少有人知
常见注解，自定义注解
weixin_38171030的博客
07-10 108
@Override表示重写的方法，编译器会验证@Override下面的方法名是否是父类中存在的，如果不存在则会报错。@Service用于标注业务层组件@Controller用于标注控制层组件@Repository用于标注数据访问组件，即DAO组件@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。 @Configuration 表示该类是一个配置类。与x...
自定义注解上常使用的注解
weixin_44728369的博客
06-23 440
@Target->用于标注注解使用的位置 @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE }) 属性 描述 备注 @Target(ElementType.TYPE) 接口、类、枚举、注解 @Target(ElementType.FIELD) 字段、枚举的常量 @Target(ElementType.METHOD) 方法 @Target(ElementType.PARAMETER) 方法
自定义注解详解
weixin_44083513的博客
05-19 3071
java中自定义注解详解
谈谈Java中自定义注解及使用场景
09-07
Java中的自定义注解是一种强大的工具，允许程序员在代码中添加元数据，这些元数据可以在编译时或运行时被解析和使用。自定义注解是Java 5引入的新特性，它增强了代码的可读性和可维护性，同时也简化了框架和库的开发...
自定义注解的创建与使用以及注解处理器的开发
最新发布
qq_40453972的博客
04-28 1168
假设我们需要一个注解@Route，用于标记类或方法对应的 HTTP 路由路径。// 元注解：定义注解的作用目标（类、方法）和保留策略（保留到运行时）@Retention(RetentionPolicy.RUNTIME) // 注解保留到运行时，方便反射获取// 路由路径（必填）// HTTP 方法，默认GET关键元注解说明@Target：指定注解可以应用的位置（类、方法、字段等）。@RetentionSOURCE：仅保留在源码中（如@OverrideCLASS：保留到字节码，但运行时不可见。
Java 注解概述和自定义注解案例
weixin_44814196的博客
07-26 979
注解是元数据的一种形式，它提供的数据不是程序本身的一部分。注解对它们注释的代码的操作没有直接影响。举个简单的例子，系统上有一个sm.png文件，这个文件才是我们真正需要的数据本身，而这个文件的属性则可以称之为sm.png的元数据，是用来描述 png 文件的创建时间、修改时间、分辨率等信息的，这些信息无论是有还是没有都不影响它作为图片的性质，都可以使用图片软件打开。注解的生效依赖于它们被解析的方式编译期直接扫描：编译器在编译 Java 代码时会扫描对应的注解并进行相应处理。运行期通过反射处理。
src.zip Java的注解讲解案例代码（ 元注解、自定义注解、常用内置注解等）
06-27
Java提供了许多内置注解，同时也支持自定义注解。 适用人群： Java注解适用于所有使用Java编程语言的开发者。不论是开发框架、库，还是进行特定行为的配置和处理，都可以从使用注解中获益。 使用场景： 以下是一些...
项目中的自定义注解
NewBeeMu的博客
09-06 432
项目中的自定义注解
自定义注解实现
追梦赤子的博客
12-25 3028
一、首先讲一下自定义注解需要用到的四个原注解 1.@interface @interface用来声明自定义的注解 2.@Target @Target的作用：用于描述注解的使用范围（ElementType有这几种取值TYPE,PACKAGE,CONSTRUCTOR(用于描述构造器),FIELD（用于描述域）, METHOD（用于描述方法）,LOCAL_VARIABLE（用于描述局部变量）,PARAM...
项目笔记（一）：自定义注解
People of solitary
01-02 175
这系列博客算是一篇在闲时读别人的代码，遇到疑惑时 百度+整理 所得（当然对我来说是不太理解的，可能对你来说 so eassy）。
【Java 注解】自定义注解(注解属性与使用)
m0_71621983的博客
07-19 5665
Java注解是一种元数据（metadata）机制，它提供了在Java代码中添加附加信息的方式。注解可以应用于类、方法、字段和其他程序元素，以提供关于这些元素的额外信息。注解以符号开头，后面跟着注解的名称。注解可以包含属性，属性可以带有默认值。使用注解时，可以为属性提供值，也可以使用默认值。提供编译时的静态检查和验证。在运行时通过反射获取元数据信息。自动生成代码或配置文件。在框架和库中进行配置和扩展。Java提供了一些内置的注解，如@Override和。
JAVA-常见的几种注解以及如何创建自定义注解
mulinghanxue的博客
06-07 555
文章目录常见的几种注解元注解无参注解的定义有参注解的定义 平常我们在编写代码中经常会看到这样的一种代码,@****,看着好像没有什么作用,像是注释,但又不是注释的形式,其实,这是注解… 常见的几种注解 下面举几个我们经常看见的例子: //方法的重写 @Override // 不推荐使用注解, 但你非要用的话,也可以使用 @Deprecated //消除代码警告(注意是警告,不是报错,别搞混了......
【SpringMVC】自定义注解和使用（看完它相信我）
无法自律的人的博客
09-15 2181
定义注解：使用注解语法，在相关的注解类上定义自定义注解，可以指定注解的目标范围和属性。标记使用：在控制器类、方法或者方法参数上使用自定义注解，标识需要应用自定义逻辑的地方。处理注解：通过Spring的AOP、拦截器等机制，对标记了特定自定义注解的类、方法或者参数进行处理，实现相关的功能。注解分类（根据Annotation是否包含成员变量,可以把Annotation分为两类）标记Annotation:没有成员变量的Annotation;这种Annotation仅利用自身的存在与否来提供信息。
自定义注解的使用
weixin_41979002的博客
07-15 4444
自定义注解的使用 文章目录自定义注解的使用前言一、注解是什么？二、四个元注解三、自定义注解示例1.原生方式2.读入数据总结 前言 一、注解是什么？ 注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解 一般常用的注解可以分为三类： 一类是Java自带的标准注解，包括@Override（标明重写某个方法）、@Deprecated（标明某个类或方法过时）和@Suppres
学习ing——注解之自定义注解
is__good的博客
06-02 897
自定义注解
一些常用的自定义注解
07-29
常用的自定义注解有以下几种： 1. @Autowired：用于自动装配依赖对象，可以在Spring容器中自动查找匹配的Bean，并将其注入到目标对象中。 2. @RequestMapping：用于映射HTTP请求的URL路径到具体的处理方法上，可以指定请求的方法、路径、参数等。 3. @Component：用于将一个类标识为Spring容器中的组件，可以通过@ComponentScan注解扫描并注册到容器中。 4. @Transactional：用于标识一个方法或类需要进行事务管理，可以控制事务的提交、回滚等行为。 5. @Validated：用于对方法参数进行校验，可以指定参数的验证规则，如非空、长度范围等。 6. @Aspect：用于定义切面，可以在方法执行前、后或异常时执行一些额外的逻辑，如日志记录、性能监控等。 这些是常用的自定义注解，可以根据具体的需求自定义更多的注解来实现特定的功能。 #### 引用[.reference_title] - *1* [Spring Boot中的自定义注解](https://blog.csdn.net/qq_44717657/article/details/130869793)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [springboot项目中自定义注解的使用总结、java自定义注解实战（常用注解DEMO）](https://blog.csdn.net/qq_21187515/article/details/109643130)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [自定义注解](https://blog.csdn.net/u014365523/article/details/126730735)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值