初学spring的时候使用注解总觉得使用注解很神奇，加一个注解就能实现想要的功能，很好奇，也想自己根据需要写一些自己实现的自定义注解。问题来了，自定义注解到底是什么？肯定会有人和我一样有这个疑惑，我根据自己的理解总结一下。看完下面的几个使用自定义注解的实战demo,小伙伴大概就懂怎么用了。
其实注解一点也不神奇，注解就是一种标志，单独使用注解，就相当于在类、方法、参数和包上加上一个装饰，什么功能也没有，仅仅是一个标志，然后这个标志可以加上一些自己定义的参数。就像下面这样，创建一个@interface的注解，然后就可以使用这个注解了，加在我们需要装饰的方法上,但是什么功能也没有
@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface XinLinLog {String value() default"";}
一、 java自定义注解的定义、描述
注解是一种能被添加到java源代码中的元数据，方法、类、参数和包都可以用注解来修饰。注解可以看作是一种特殊的标记，可以用在方法、类、参数和包上，程序在编译或者运行时可以检测到这些标记而进行一些特殊的处理。
1. 创建一个注解的基本元素
修饰符
访问修饰符必须为public,不写默认为pubic；
关键字
关键字为@interface；
注解名称
注解名称为自定义注解的名称，例如上面的XinLinLog 就是注解名称
注解类型元素
注解类型元素是注解中内容，根据需要标志参数，例如上面的注解的value；
2. 元注解（@Target、@Retention、@Inherited、@Documented）
我们上面的创建的注解XinLinLog上面还有几个注解（@Target、@Retention、@Inherited、@Documented），这四个注解就是元注解，元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的元注解类型，它们被用来提供对其它 注解类型作标志操作（可以理解为最小的注解，基础注解）
@Target：用于描述注解的使用范围，该注解可以使用在什么地方
@Retention：表明该注解的生命周期备注：例如@Target(ElementType.METHOD)，标志的注解使用在方法上，但是我们在这个注解标志在类上，就会报错
@Inherited：是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。
@Documented：表明该注解标记的元素可以被Javadoc 或类似的工具文档化
二、自定义注解的使用DEMO
上面总结的注解的定义，但是创建这样一个注解，仅仅是一个标志，装饰类、方法、属性的，并没有功能，要想实现功能，需要我们通过拦截器、AOP切面这些地方获取注解标志，然后实现我们的功能。
java自定义注解的使用范围
一般我们可以通过注解来实现一些重复的逻辑，就像封装了的一个方法，可以用在一些权限校验、字段校验、字段属性注入、保存日志、缓存
1.权限校验注解（校验token）
有些项目进入到接口后调用公用方法来校验token，这样看起来代码就有点不优雅，我们可以写自定义注解来进行校验token。
例如有个项目，前端是把token放到json里面传到后端（也有一些项目放到请求头的header里面，方式一样），没用注解之前，我们可能是通过调用公共的方法去校验token,如validateToken(token)，然后每个接口都有这一段代码，我们用注解的模式替换
1) 首先我们创建一个注解，标志那些类需要校验token
@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface AppAuthenticationValidate {//必填参数String[] requestParams() default {};}
2) 然后再创建一个AOP切面类来拦截这个注解
拦截使用这个注解的方法，同时获取注解上面的requestParams参数，校验json里面必填的属性是否存在
@Aspect@Component@Slf4jpublic class AppAuthenticationValidateAspect {@Reference(check = false, timeout = 18000)private CommonUserService commonUserService;@Before("@annotation(.bluemoon.mon.aspect.AppAuthenticationValidate)")public void repeatSumbitIntercept( JoinPoint joinPoint) {//获取接口的参数Object[] o = joinPoint.getArgs();JSONObject jsonObject = null;String[] parameterNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();String source = null;for(int i=0;i<parameterNames.length;i++){String paramName = parameterNames[i];if(paramName.equals("source")){//获取token来源source = (String)o[i];}if(paramName.equals("jsonObject")){jsonObject = (JSONObject) o[i];}}if(jsonObject == null){throw new WebException(ResponseConstant.ILLEGAL_PARAM_CODE, ResponseConstant.ILLEGAL_PARAM_MSG);}String token = jsonObject.getString("token");if(StringUtils.isBlank(token)){throw new WebException(ResponseConstant.TOKEN_EXPIRED_CODE,"登录超时，请重新登录");}MethodSignature signature = (MethodSignature) joinPoint.getSignature();Method method = signature.getMethod();AppAuthenticationValidate annotation = method.getAnnotation(AppAuthenticationValidate.class);String[] requestParams = annotation.requestParams();//校验必填参数ParamsValidateUtil.isNotBlank(jsonObject,requestParams);ResponseBean<String> response = null;if(StringUtils.isBlank(source)){response = monUserService.checkAppToken(token);}else{response = monUserService.checkAppTokenByAppType(token,source);}if (response.getIsSuccess() && ResponseConstant.REQUEST_SUCCESS_CODE == response.getResponseCode()) {String empCode = response.getData();log.info("---token ={}， empCode={}--", token, empCode);jsonObject.put(ProcessParamConstant.APP_EMP_CODE,empCode);} else {log.info("---token验证不通过，token ={}---", token);throw new WebException(ResponseConstant.TOKEN_EXPIRED_CODE, "登录超时，请重新登录");}}}
3）把注解加在需要校验的接口方法上
这个注解同时校验了必填字段，校验完token后同时会把token的用户信息加在json对象里面
备注：有些项目会把token放到请求头header中，处理方式类似
2.角色校验注解（springsecurity中的角色校验）
我们在使用springsecurity有一个注解@PreAuthorize可以作用在类或方法上，用来校验是否有权限访问，我们可以模仿这个注解，写一个我们自定义注解来实现同样的功能
1）创建一个自定义注解
@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface RoleAuthorize {String[] value() default {};}
2）创建一个拦截器
这个拦截器拦截所有访问路径的url，如果访问方法上带有我们创建的自定义注解RoleAuthorize ，则获取这个注解上限定的访问角色，方法没有注解再获取这个类是否有这个注解，如果这个类也没有注解，则这个类的访问没有角色限制，放行，如果有则校验当前用户的springsecurity是否有这个角色，有则放行，没有则抛出和springsecurity一样的异常AccessDeniedException，全局异常捕获这个异常，返回状态码403（表示没有权限访问）
@Componentpublic class RoleInterceptor extends HandlerInterceptorAdapter{@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler) throws Exception {HandlerMethod handlerMethod = (HandlerMethod)handler;//在方法上寻找注解RoleAuthorize permission = handlerMethod.getMethodAnnotation(RoleAuthorize.class);if (permission == null) {//方法不存在则在类上寻找注解则在类上寻找注解permission = handlerMethod.getBeanType().getAnnotation(RoleAuthorize.class);}//如果没有添加权限注解则直接跳过允许访问if (permission == null) {return true;}//获取注解中的值String[] validateRoles = permission.value();//校验是否含有对应的角色for(String role : validateRoles){//从springsecurity的上下文获取用户角色是否存在当前的角色名称if(AuthUserUtils.hasRole("ROLE_"+role)){return true;}}throw new AccessDeniedException("没有权限访问当前接口");}}
3）配置拦截器
@Configurationpublic class WebMvcConfig extends WebMvcConfigurerAdapter {@Autowiredprivate RoleInterceptor roleInterceptor;/*** 添加拦截器** @param registry*/@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(roleInterceptor).addPathPatterns("/**");super.addInterceptors(registry);}}
备注：
1.这里添加拦截器可以继承WebMvcConfigurerAdapter （已过时，在springboot2.0是继承 WebMvcConfigurationSupport或实现WebMvcConfigurer）
2.WebMvcConfigurationSupport–>不需要返回逻辑视图,可以选择继承此类.WebMvcCofigurer–>返回逻辑视图,可以选择实现此方法,重写addInterceptor方法
3.继承webmvcconfigurationsupport之后就没有springmvc的自动配置了 建议实现WebMvcConfigurer
4）把注解加到接口的类或方法上验证
可以看到接口会返回无权限访问
3.字段属性注入注解
还有一种场景，我们校验token通过后，还需要通过token去换取用户信息，如果通过接口方法里面去调token换用户信息，好像不太优雅，我们用自定义注解把用户信息直接注入我们接口上的属性参数里面
1）创建自定义注解
//作用在参数上@Target({ElementType.PARAMETER})@Retention(RetentionPolicy.RUNTIME)public @interface LoginUserInfo {}
2）需要写一个实现类实现HandlerMethodArgumentResolver接口
Spring也向我们提供了多种解析器Resolver,HandlerMethodArgumentResolver是用来处理方法参数的解析器，包含以下2个方法：
supportsParameter（满足某种要求，返回true，方可进入resolveArgument做参数处理）resolveArgument(解析返回对象注入我们该注解上的属性)
public class UserInfoArgumentResolver implements HandlerMethodArgumentResolver {@Overridepublic boolean supportsParameter(MethodParameter methodParameter) {return methodParameter.getParameterType().isAssignableFrom(LoginUser.class)&& methodParameter.hasParameterAnnotation(LoginUserInfo.class);}@Overridepublic Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {//从我们的request域里获取用户信息对象，返回注入属性return nativeWebRequest.getAttribute(Constants.USER_INFN, RequestAttributes.SCOPE_REQUEST);}}
3）创建拦截器
这个拦截器会通过请求头header拿到token，然后再通过token去从缓存或数据库中获取用户信息，最后把用户信息写进request里面
@Componentpublic class AuthenticationInterceptor extends HandlerInterceptorAdapter {@AutowiredUserService userService;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {StringBuffer requestURL = request.getRequestURL();System.out.println("前置拦截器1 preHandle： 请求的uri为："+requestURL.toString());String token = request.getHeader("token");//根据token从缓存或数据库中获取用户信息LoginUser user = userService.findUserByToken(token);if(user == null){throw new WebException(ResultStatusCode.INVALID_TOKEN);}request.setAttribute(Constants.USER_INFN,user);return true;}}//配置拦截器@Configurationpublic class WebMvcConfig implements WebMvcConfigurer {@AutowiredAuthenticationInterceptor authenticationInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 拦截指定路径registry.addInterceptor(authenticationInterceptor).addPathPatterns("/user/check/**");}}
4）把注解加到接口的参数上
执行测试我们就可以知道只要token正确，loginUser就已经注入用户信息了
4.对象的属性校验注解
完整描述查看springboot中参数验证自定义注解，@Valid总结
validation-api包里面还有一个@Constraint注解，我们的自定义注解里面加上这个注解就能实现自定义验证
1）创建一个自定义验证注解
我们这个自定义注解实现一个简单的功能：
根据type参数进行校验，校验为空、年龄范围、手机号码
@Constraint(validatedBy = {CheckValidator.class})//指向实现验证的类
@Target({ElementType.FIELD,ElementType.PARAMETER})@Retention(RetentionPolicy.RUNTIME)@Constraint(validatedBy = {CheckValidator.class})//指向实现验证的类public @interface Check {CheckValidatorEnum type() default CheckValidatorEnum.Null;long min() default 1;long max() default 1;String message() default "参数异常";Class<?>[] groups() default {};Class<? extends Payload>[] payload() default {};}//校验枚举类@Getterpublic enum CheckValidatorEnum {Null(1,"为空校验"),AGE(2,"年龄校验"),Phone(3,"手机校验");CheckValidatorEnum(int code,String desc){this.code = code;this.desc = desc;}private int code;private String desc;}
2）实现验证的类
我们这个实现自定义验证的类需要实现ConstrainValidator接口
public class CheckValidator implements ConstraintValidator<Check,Object> {private Check check;private CheckValidatorEnum checkValidatorEnum;@Overridepublic void initialize(Check CheckAnnotation){this.check = CheckAnnotation;this.checkValidatorEnum = CheckAnnotation.type();}@Overridepublic boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {if(checkValidatorEnum.getCode()==CheckValidatorEnum.Null.getCode()){//非空校验if(o != null && !o.toString().equals("")){return true;}}else if(checkValidatorEnum.getCode()==CheckValidatorEnum.AGE.getCode()){//年龄校验if(o.toString() == null){return true;}long min = this.check.min();long max = this.check.max();Integer age = Integer.parseInt(o.toString());if(age>=min && age<=max){return true;}}else if(checkValidatorEnum.getCode()==CheckValidatorEnum.Phone.getCode()){if(o == null){return true;}//手机号码校验if(CommonUtil.isMobile(o.toString())){return true;}}return false;}}
3）使用@Valid注解加在类上校验
如下@Valid User user，同时在User里面的属性加入自定义注解
public ResponseObject addUser(@Valid @RequestBody User user) throws IOException {}@Datapublic class User {private int id;@Check(type = CheckValidatorEnum.Null)private String name;@Check(type = CheckValidatorEnum.AGE, min = 18,max = 30,message = "年龄不在18-30范围内")private Integer age;@Check(type = CheckValidatorEnum.Phone,message = "手机号码不正确")private String tel;@Validprivate UserCityInfo cityInfo;}//嵌套对象的校验@Datapublic class UserCityInfo {@Check(type = CheckValidatorEnum.Null,message = "城市编码不能为空")private Integer cityCode;@NotEmptyprivate String cityName;}
备注：
可能需要校验的对象的属性还是对象，然后我们需要校验对象里面的对象，这种嵌套校验，我们只需要在对象的属性对象上再加一个@Valid即可实现嵌套校验
4）在全局异常里捕获校验异常
@Slf4j@RestControllerAdvicepublic class GlobalExceptionHandle {//捕获@Valid校验不通过的异常@ExceptionHandler(MethodArgumentNotValidException.class)public ResponseObject handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {log.error(e.getMessage(), e);BindingResult ex = e.getBindingResult();List<ObjectError> allErrors = ex.getAllErrors();ObjectError error = allErrors.get(0);String defaultMessage = error.getDefaultMessage();ResponseObject responseObject = new ResponseObject(ResultStatusCode.VALIDATE_FAIL.getStatuscode(),defaultMessage,null);return responseObject;}@ExceptionHandler(Exception.class)public ResponseObject handleException(Exception e) {log.error(e.getMessage(), e);ResponseObject responseObject = new ResponseObject(ResultStatusCode.SYSTEM_ERROR.getStatuscode(),ResultStatusCode.SYSTEM_ERROR.getStatusmsg(),null);return responseObject;}}
然后我们就实现了在注解里校验，不需要在接口代码里再判断
5.接口的操作日志注解
记录接口的操作日志注解
1）创建自定义注解
//记录接口的操作日志@Target({METHOD})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface OperationLog {String value() default"";OperationTypeEnum operationTypeEnum() default OperationTypeEnum.OTHER;}
2）通过AOP切面实现注解功能
@Aspect@Componentpublic class LogAspect {@Autowiredprivate ISysLogInfoService sysLogInfoService;//定义切点 @Pointcut//在注解的位置切入代码@Pointcut("@annotation(OperationLog)")public void logPointCut() {}//切面 配置通知@AfterReturning("logPointCut()")public void saveSysLog(JoinPoint joinPoint) {//保存日志SysLogInfo sysLog = new SysLogInfo();MethodSignature signature = (MethodSignature) joinPoint.getSignature();//获取切入点所在的方法Method method = signature.getMethod();//获取操作Operation operation = method.getAnnotation(Operation.class);if (operation != null) {String value = operation.value();//获取请求的类名String className = joinPoint.getTarget().getClass().getName();//获取请求的方法名String methodName = method.getName();String methodStr = (className + "." + methodName);// 构造参数组集合JSONObject allParams = new JSONObject();for (Object arg : joinPoint.getArgs()) {if (arg instanceof JSONObject) {allParams.putAll((JSONObject) arg);}}//获取用户ip地址HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();String url = request.getRequestURI();String ip = IpAddressUtils.getIpAdrress(request);String params = "";//请求参数if (!allParams.isEmpty()) {params = allParams.toJSONString();}if(params.length()> 1000){params = params.substring(0,997).concat("...");}sysLog.setLogDesc(value);sysLog.setBizId(bizId);sysLog.setOpIp(ip);sysLog.setBizParam(params);sysLog.setOpMethod(methodStr);//获取登录用户信息AuthUser user = AuthUserUtils.getCurrentUser();sysLog.setBizType(operation.operationTypeEnum().getCode());sysLog.setOpUser(user.getName());sysLog.setOpUserNo(user.getEmpNo());sysLog.setOpTime(new Date());//保存日志sysLogInfoService.insertSelective(sysLog);}}}
3）把注解加在接口方法上
把注解加在接口的方法上就可以保存进入这个接口请求IP、类型、方法名、入参、用户信息
6.缓存注解
spring里面有一个@Cacheable注解，使用这个注解的方法，如果key在缓存中已有,则不再进入方法，直接从缓存获取数据，缓存没有值则进入并且把值放到缓存里面，我们写一个类似的，简单的注解
备注：使用了这个注解，如果数据有修改，记得清除缓存
1）创建自定义注解
@Target({ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)public @interface CustomCache {//缓存前缀String prefix() default "";//缓存keyString key() default "";}
2）然后再创建一个AOP切面类来实现这个注解
@Aspect@Componentpublic class CustomCacheAspect {private static HashMap<String,Object> cacheMap = new HashMap<>();@Pointcut("@annotation(CustomCache)")public void cache() {}@Around("cache()")public Object printLog(ProceedingJoinPoint joinPoint){MethodSignature signature = (MethodSignature) joinPoint.getSignature();//获取切入点所在的方法Method method = signature.getMethod();//获取操作CustomCache customCache = method.getAnnotation(CustomCache.class);String prefix = customCache.prefix();if(prefix == null || prefix.equals("")){//如果前缀为空，默认使用类型+方法名作为缓存的前缀//获取请求的类名String className = joinPoint.getTarget().getClass().getName();//获取请求的方法名String methodName = method.getName();prefix = className+"-"+methodName;}String key = customCache.key();if(key == null || key.equals("")){//获取接口的参数Object[] o = joinPoint.getArgs();//如果key为空，默认使用参数名称为id的值作为idString[] parameterNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();for(int i=0;i<parameterNames.length;i++){String paramName = parameterNames[i];if(paramName.equals("id")){key = o[i].toString();}}}String cacheKey = prefix+key;Object result = cacheMap.get(cacheKey);if(result != null){//缓存不为空，直接返回缓存结果return result;}try {result = joinPoint.proceed();} catch (Throwable throwable) {throwable.printStackTrace();}cacheMap.put(cacheKey,result);return result;}}
3）把注解加在查询用户信息的Service上
@Override@CustomCache()public User findUser(Integer id) {return baseMapper.selectById(id);}
测试可以看到只有首次才会进入这个方法查询用户信息，查询出用户信息后再调用这个方法只是从缓存中获取
7.防刷新注解
有一些场景，例如申请提交之后几秒内需要防止用户重复提交，我们后端通过注解实现这一功能
1）创建自定义注解
@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface AvoidRepeatSubmit {/*** 指定时间内不可重复提交，单位：s** @return*/long timeout() default 3;}
2）再创建一个AOP切面类来实现这个注解
@Aspect@Component@Slf4jpublic class AvoidRepeatSubmitAspect {@Autowiredprivate RedisRepository redisRepository;@Before("@annotation(.bluemoon.mon.aspect.AvoidRepeatSubmit)")public void repeatSumbitIntercept(JoinPoint joinPoint) {// ip + 类名 + 方法 + timeoutHttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();String ip = IpAddressUtils.getIpAdrress(request);String className = joinPoint.getTarget().getClass().getName();MethodSignature signature = (MethodSignature) joinPoint.getSignature();Method method = signature.getMethod();String methodName = method.getName();// 获取配置的过期时间AvoidRepeatSubmit annotation = method.getAnnotation(AvoidRepeatSubmit.class);long timeout = annotation.timeout();StringBuilder builder = new StringBuilder();builder.append(ip).append(",").append(className).append(",").append(methodName).append(",").append(timeout).append("s");String key = builder.toString();log.info(" --- >> 防重提交：key -- {}", key);// 判断是否已经超过重复提交的限制时间String value = redisRepository.get(key);if (StringUtils.isNotBlank(value)) {String messge = MessageFormat.format("请勿在{0}s内重复提交", timeout);throw new WebException(messge);}this.redisRepository.setExpire(key, key, timeout);}}
8.动态切换数据源注解
原理：Spring提供了AbstractRoutingDataSource用于动态路由数据源，继承AbstractRoutingDataSource类并覆写其protected abstract Object determineCurrentLookupKey()即可
完整描述查看：springboot动态多数据源配置和使用（二）
1）创建自定义注解
/*** 自定义的多数据源注解**/@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inheritedpublic @interface DataSource {String value() default "";}
2）再创建一个AOP切面类来实现这个注解
下面的代码很简单，可以看出，这个切面类先判断注解是在方法上还是类上，如果方法上有注解优先使用方法上的，获取注解的value属性的值，把这个值作为数据源的key。通过 DynamicContextHolder.push(value)来设置数据源的key（这里改变后， determineCurrentLookupKey()重写的方法返回的key也就改变了，从而切换了数据源）
/*** 多数据源，切面处理类**/@Aspect@Component@Order(Ordered.HIGHEST_PRECEDENCE)public class DataSourceAspect {protected Logger logger = LoggerFactory.getLogger(getClass());@Pointcut("@annotation(io.renren.datasource.annotation.DataSource) " +"|| @within(io.renren.datasource.annotation.DataSource)")public void dataSourcePointCut() {}@Around("dataSourcePointCut()")public Object around(ProceedingJoinPoint point) throws Throwable {MethodSignature signature = (MethodSignature) point.getSignature();Class targetClass = point.getTarget().getClass();Method method = signature.getMethod();DataSource targetDataSource = (DataSource)targetClass.getAnnotation(DataSource.class);DataSource methodDataSource = method.getAnnotation(DataSource.class);if(targetDataSource != null || methodDataSource != null){String value;if(methodDataSource != null){value = methodDataSource.value();}else {value = targetDataSource.value();}DynamicContextHolder.push(value);logger.debug("set datasource is {}", value);}try {return point.proceed();} finally {DynamicContextHolder.poll();logger.debug("clean datasource");}}}
3）把这个注解加在需要使用多数据源的service方法或类上
从下面的三个方法逐个调用测试，可以看到操作了三个不同的数据源的数据
@Service//@DataSource("slave1")public class DynamicDataSourceTestService {@Autowiredprivate SysUserDao sysUserDao;@Transactionalpublic void updateUser(Long id){SysUserEntity user = new SysUserEntity();user.setUserId(id);user.setMobile("13500000000");sysUserDao.updateById(user);}@Transactional@DataSource("slave1")public void updateUserBySlave1(Long id){SysUserEntity user = new SysUserEntity();user.setUserId(id);user.setMobile("13500000001");sysUserDao.updateById(user);}@DataSource("slave2")@Transactionalpublic void updateUserBySlave2(Long id){SysUserEntity user = new SysUserEntity();user.setUserId(id);user.setMobile("13500000002");sysUserDao.updateById(user);}}
参考文章
大白快跑8的《Java实现自定义注解》/zt15732625878/article/details/100061528
木叶的《spring 自定义注解（annotation）与 aop获取注解》
/a/1190000013258647
