利用Spring AOP自定义注解解决日志和签名校验

最新推荐文章于 2023-11-07 23:17:27 发布
最新推荐文章于 2023-11-07 23:17:27 发布
阅读量223 收藏
点赞数

一、需解决的问题

  1. 部分API有签名参数（signature），Passport首先对签名进行校验，校验通过才会执行实现方法。

　　　　第一种实现方式(Origin)：在需要签名校验的接口里写校验的代码，例如：

boolean isValid = accountService.validSignature(appid, signature, client_signature);
if (!isValid) return ErrorUtil.buildError(ErrorUtil.ERR_CODE_COM_SING);

　　　　第二种实现方式(Spring Interception)：利用spring的拦截器功能，对指定的接口进行拦截，拦截器实现签名校验算法，例如：

复制代码

<mvc:interceptors>
     <mvc:interceptor>
            <mvc:mapping path="/connect/share/**" />
            <mvc:mapping path="/friend/**" />
            <mvc:mapping path="/account/get_bind" />
            <mvc:mapping path="/account/get_associate" />
            <bean class="com.sogou.upd.passport.web.inteceptor.IdentityAndSecureInteceptor" />
     </mvc:interceptor>
 </mvc:interceptors>

复制代码

　　　　第三种实现方式(spring AOP)：自定义注解，对需要进行签名验证的方法添加注解，例如：

复制代码

@SecureValid
@ResponseBody
@RequestMapping(value = "/share/add", method = RequestMethod.POST)
public Object addShare(HttpServletRequest req, HttpServletResponse res,InfoAPIRequestParams requestParams) {
　　　　...
}

复制代码

　　2. 日志记录功能，例如：某些接口需要记录请求和响应，执行时间，类名，方法名等日志信息。也可采用以上三种方式实现。

　　3. 代码性能监控问题，例如方法调用时间、次数、线程和堆栈信息等。这类问题在后一个专题提出解决方案，采用以上三种方式实现缺点太多。

以下是三种实现方式比较：

实现方式优点缺点
Origin

不采用反射机制，性能最佳

逻辑复杂时，代码复用不好

需要在每个接口里写入相同代码（我太懒，就想写几个字母）

Spring Inter

非常适合对所有方法进行拦截，例如调试时打印所有方法执行时间

类似过滤器的功能，如日志处理、编码转换、权限检查

是AOP的子功能

不采用反射机制，性能有所影响

需要在xml文件里配置对哪些接口进行拦截，比较麻烦

Spring AOP

使用方便，增加一个注解

非常灵活，可@Before，@After，@Around等

不采用反射机制，性能有所影响（性能对比后面详细展示）

二、Spring AOP 自定义注解的实现

在Maven中加入以下以依赖：

复制代码

<!-- Spring AOP + AspectJ by shipengzhi -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.11</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.11</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
        <!-- end -->

复制代码

在spring-***.xml中加入spring支持，打开aop功能

复制代码

头文件声明 ：
xmlns:aop="http://www.springframework.org/schema/aop" 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
　　<!-- 自定义AOP -->
    <aop:aspectj-autoproxy proxy-target-class="true">
        <aop:include name="controllerAspect" />
    </aop:aspectj-autoproxy>
    <bean id="controllerAspect" class="com.sogou.upd.passport.common.aspect.ControllerAspect"></bean>

　　或：
　　<aop:aspectj-autoproxy>

复制代码

编写自定义注解。实现对方法所实现的功能进行描述，以便在通知中获取描述信息

复制代码

/*
 * 校验签名合法性 自定义事务
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface SecureValid {
    String desc() default "身份和安全验证开始...";
}

复制代码

　　@Target 用于描述注解的使用范围（即：被描述的注解可以用在什么地方），其取值有：

取值

描述

CONSTRUCTOR

用于描述构造器（领盒饭）。

FIELD

用于描述域（领盒饭）。

LOCAL_VARIABLE

用于描述局部变量（领盒饭）。

METHOD

用于描述方法。

PACKAGE

用于描述包（领盒饭）。

PARAMETER

用于描述参数。

TYPE

用于描述类或接口（甚至 enum ）。

 

　　@Retention 用于描述注解的生命周期（即：被描述的注解在什么范围内有效），其取值有：

取值

描述

SOURCE

在源文件中有效（即源文件保留，领盒饭）。

CLASS

在 class 文件中有效（即 class 保留，领盒饭）。

RUNTIME

在运行时有效（即运行时保留）。

　　@Documented 在默认的情况下javadoc命令不会将我们的annotation生成再doc中去的，所以使用该标记就是告诉jdk让它也将annotation生成到doc中去

　　@Inherited 比如有一个类A，在他上面有一个标记annotation，那么A的子类B是否不用再次标记annotation就可以继承得到呢，答案是肯定的

　　Annotation属性值 有以下三种： 基本类型、数组类型、枚举类型 

　　　1：基本串类型 

复制代码

public @interface UserdefinedAnnotation {  
    intvalue();  
    String name();  
    String address();  
}
使用：
@UserdefinedAnnotation(value=123,name="wangwenjun",address="火星")  
    public static void main(String[] args) {  
        System.out.println("hello");  
    }  
}

复制代码

　　　　如果一个annotation中只有一个属性名字叫value，我没在使用的时候可以给出属性名也可以省略。 

复制代码

public @interface UserdefinedAnnotation {  
    int value();  
}  
也可以写成如下的形式 

Java代码  
@UserdefinedAnnotation(123)  等同于@UserdefinedAnnotation(value=123) 
    public static void main(String[] args) {  
        System.out.println("hello");  
}

复制代码

 　　2：数组类型 我们在自定义annotation中定义一个数组类型的属性，代码如下： 

  1. 复制代码

    public @interface UserdefinedAnnotation {  
    int[] value();  
}  
使用：  
public class UseAnnotation {  
      
    @UserdefinedAnnotation({123})  
    public static void main(String[] args) {  
        System.out.println("hello");  
    }  
}

    复制代码

　　　　注意1：其中123外面的大括号是可以被省略的，因为只有一个元素，如果里面有一个以上的元素的话，花括号是不能被省略的哦。比如{123，234}。 
　　　　注意2：其中属性名value我们在使用的时候进行了省略，那是因为他叫value，如果是其他名字我们就不可以进行省略了必须是@UserdefinedAnnotation（属性名={123,234}）这样的格式。 

　　　3：枚举类型 

复制代码

public enum DateEnum {  
    Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday  
}  
然后在定义一个annotation  
package com.wangwenjun.annatation.userdefined;  
  
public @interface UserdefinedAnnotation {  
    DateEnum week();  
}  
使用： 
public class UseAnnotation {  
    @UserdefinedAnnotation(week=DateEnum.Sunday)  
    public static void main(String[] args) {  
        System.out.println("hello");  
    }  
}

复制代码

  　4：默认值 

复制代码

public @interface UserdefinedAnnotation {  
    String name() default "zhangsan";  
}  
使用：  
public class UseAnnotation {  
    @UserdefinedAnnotation()  
    public static void main(String[] args) {  
        System.out.println("hello");  
    }  
}

复制代码

　　5：注意 
　　　　Annotation是不可以继承其他接口的，这一点是需要进行注意，这也是annotation的一个规定吧。 
　　　　Annotation也是存在包结构的，在使用的时候直接进行导入即可。 
　　　　Annotation类型的类型只支持原声数据类型，枚举类型和Class类型的一维数组，其他的类型或者用户自定义的类都是不可以作为annotation的类型，我查看过文档并且进行过测试。 

编写操作日志切面通知实现类

在编写切面通知实现类之前，我们需要搞清楚我们需要哪些通知类型，是前置通知、后置通知、环绕通知或异常通知？根据我的需求，我们知道我们记录的操作日志有两种情况，一种是操作成功，一种是操作失败。操作成功时则方法肯定已经执行完成，顾我们需要实现一个后置通知；操作失败时则说明方法出现异常无法正常执行完成，顾还需要一个异常通知。代码如下：

复制代码

@Aspect //该注解标示该类为切面类 
@Component //注入依赖
public class LogAspect {  
  
    //标注该方法体为后置通知，当目标方法执行成功后执行该方法体  
    @AfterReturning("within(com.abchina.irms..*) && @annotation(rl)")  
    public void addLogSuccess(JoinPoint jp, rmpfLog rl){  
        Object[] parames = jp.getArgs();//获取目标方法体参数  
        String params = parseParames(parames); //解析目标方法体的参数  
        String className = jp.getTarget().getClass().toString();//获取目标类名  
        className = className.substring(className.indexOf("com"));  
        String signature = jp.getSignature().toString();//获取目标方法签名  
        String methodName = signature.substring(signature.lastIndexOf(".")+1, signature.indexOf("("));  
        String modelName = getModelName(className); //根据类名获取所属的模块  
          
      ...
    }  
  
    //标注该方法体为异常通知，当目标方法出现异常时，执行该方法体  
    @AfterThrowing(pointcut="within(com.abchina.irms..*) && @annotation(rl)", throwing="ex")  
    public void addLog(JoinPoint jp, rmpfLog rl, BusinessException ex){  
       ...
    }

复制代码

有两个相同的参数jp和rl，jp是切点对象，通过该对象可以获取切点所切入方法所在的类，方法名、参数等信息，具体方法可以看方法体的实现；rl则是我们的自定义注解的对象，通过该对象我们可以获取注解中参数值，从而获取方法的描述信息。在异常通知中多出了一个ex参数，该参数是方法执行时所抛出的异常，从而可以获取相应的异常信息。此处为我写的自定义异常。注意：如果指定异常参数，则异常对象必须与通知所切入的方法体抛出的异常保持一致，否则该通知不会执行。

@AfterReturning("within(com.abchina.irms..*) && @annotation(rl)")注解，是指定该方法体为后置通知，其有一个表达式参数，用来检索符合条件的切点。该表达式指定com/abchina/irms目录下及其所有子目录下的所有带有@rmpfLog注解的方法体为切点。

@AfterThrowing(pointcut="within(com.abchina.irms..*) && @annotation(rl)", throwing="ex")注解，是指定方法体为异常通知，其有一个表达式参数和一个抛出异常参数。表达式参数与后置通知的表达式参数含义相同，而抛出异常参数，则表示如果com/abchina/irms目录下及其所有子目录下的所有带有@rmpfLog注解的方法体在执行时抛出BusinessException异常时该通知便会执行。

AOP的基本概念：

  • 切面（Aspect） ：通知和切入点共同组成了切面，时间、地点和要发生的“故事”。
  • 连接点（Joinpoint） ：程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。
  • 通知（Advice） ：通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。
  • 切入点（Pointcut） ：通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称。
  • 目标对象（Target Object） ：即被通知的对象。
  • AOP代理（AOP Proxy） 在Spring AOP中有两种代理方式，JDK动态代理和CGLIB代理。默认情况下，TargetObject实现了接口时，则采用JDK动态代理；反之，采用CGLIB代理。
  • 织入（Weaving）把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机：

　　（1）编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才能做到，例如AspectJ的织入编译器；

　　（2）类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码；

　　（3）运行时：切面在运行的某个时刻被织入，SpringAOP就是以这种方式织入切面的，原理是使用了JDK的动态代理。

切入点表达式，Pointcut的定义包括两个部分：Pointcut表示式(expression)和Pointcut签名(signature)。让我们先看看execution表示式的格式：

execution(modifier-pattern? ret-type-pattern declaring-type-pattern?  name-pattern(param-pattern) throws-pattern?) 
pattern分别表示修饰符匹配（modifier-pattern?）、返回值匹配（ret-type-pattern）、类路径匹配（declaring-type-pattern?）、方法名匹配（name-pattern）、参数匹配（(param-pattern)）、异常类型匹配（throws-pattern?），其中后面跟着“?”的是可选项。

在各个pattern中可以使用“*”来表示匹配所有。在(param-pattern)中，可以指定具体的参数类型，多个参数间用“,”隔开，各个也可以用“*”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(*,String)表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(..)表示零个或多个任意参数。
　　现在来看看几个例子：
　　1）execution(* *(..)) 表示匹配所有方法
　　2）execution(public * com. savage.service.UserService.*(..)) 表示匹配com.savage.server.UserService中所有的公有方法
　　3）execution(* com.savage.server..*.*(..)) 表示匹配com.savage.server包及其子包下的所有方法
　　除了execution表示式外，还有within、this、target、args等Pointcut表示式。一个Pointcut定义由Pointcut表示式和Pointcut签名组成，例如：

复制代码

//Pointcut表示式
@Pointcut("execution(* com.savage.aop.MessageSender.*(..))")
//Point签名
private void log(){}                             
然后要使用所定义的Pointcut时，可以指定Pointcut签名，如:
@Before("og()")
上面的定义等同与：
@Before("execution(* com.savage.aop.MessageSender.*(..))")
Pointcut定义时，还可以使用&&、||、!运算，如：
@Pointcut("logSender() || logReceiver()")
private void logMessage(){}

复制代码

 通知（Advice）类型

@Before 前置通知（Before advice） ：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。

@After 后通知（After advice） ：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。

@AfterReturning 返回后通知（After return advice） ：在某连接点正常完成后执行的通知，不包括抛出异常的情况。

@Around 环绕通知（Around advice） ：包围一个连接点的通知，类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。

@AfterThrowing 抛出异常后通知（After throwing advice） ： 在方法抛出异常退出时执行的通知。

自定义注解实现在Controller层面

复制代码

　　/**
     * 对Controller进行安全和身份校验  
     */
    @Around("within(@org.springframework.stereotype.Controller *) && @annotation(is)")
    public Object validIdentityAndSecure(ProceedingJoinPoint pjp, SecureValid is)
            throws Exception {
        Object[] args = pjp.getArgs();
        //Controller中所有方法的参数，前两个分别为：Request,Response 
        HttpServletRequest request = (HttpServletRequest) args[0];
        // HttpServletResponse response = (HttpServletResponse)args[1];

        String appid = request.getParameter("appid");
        int app_id = Integer.valueOf(appid);
        String signature = request.getParameter("signature");
        String clientSignature = request.getParameter("client_signature");
        String uri = request.getRequestURI();

        String provider = request.getParameter("provider");
        if (StringUtils.isEmpty(provider)) {
            provider = "passport";
        }

        // 对appid和signature进行校验
        try {
            appService.validateAppid(app_id);
            boolean isValid = accountService.validSignature(app_id, signature, clientSignature);
            if (!isValid) throw new ProblemException(ErrorUtil.ERR_CODE_COM_SING);
        } catch (Exception e) {
            return handleException(e, provider, uri);
        }
        // 继续执行接下来的代码
        Object retVal = null;
        try {
            retVal = pjp.proceed();
        } catch (Throwable e) {
            if (e instanceof Exception) { return handleException((Exception) e, provider, uri); }
        }
        // 目前的接口走不到这里
        return retVal;
    }

复制代码

 

三、Spring拦截器的实现

在spring-***.xml中加入拦截器的配置

编写拦截器实现类

复制代码

public class CostTimeInteceptor extends HandlerInterceptorAdapter {

    private static final Logger log = LoggerFactory.getLogger(CostTimeInteceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        long startTime = System.currentTimeMillis();
        request.setAttribute("startTime", startTime);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        long startTime = (Long) request.getAttribute("startTime");
        long endTime = System.currentTimeMillis();
        long executeTime = endTime - startTime;
        if (log.isInfoEnabled()) {
            log.info("[" + request.getRequestURI() + "] executeTime : " + executeTime + "ms");
        }
    }
}

复制代码

 四、性能对比

 实验环境：对/account/get_associate接口，并发500，压测10分钟

指标OriginSpring InterSpring AOP
CPUuser%:26.57

sys%:10.97

cpu%:37.541

user%:26.246

sys%:10.805

cpu%:37.051

user%:24.123

sys%:9.938

cpu%:34.062

Load13.8513.92 12.21 
QPS61696093.25813.27
RT

0.242ms

0.242ms

0.235ms

采用AOP对响应时间无明显影响

采用AOP对Load无明显影响

采用AOP对CPU无明显影响

结论：使用AOP性能方面影响可忽略

转自：https://www.cnblogs.com/shipengzhi/articles/2716004.html

 

summer320X
关注
接口签名、日志、token校验优化
iOS逆向与安全
07-05 107
需要签名的接口，要求请求参数是自定义对象,因为签名计算是将参数解析为map,即SIGN_REQJSONBODY_ERROR("SIGN_REQJSONBODY_ERROR" , "需要签名的接口，要求请求参数是自定义对象,因为签名计算是将参数解析为map,即java.util.LinkedHashMap")//2。将json请求对象转为Maptry {});
Spring自定义注解实现AOP做简单的拦截/权限校验
whiteBearClimb的博客
10-10 906
关于AOP的资料：AOP（Spring的面向切面编程） (1)新增依赖，pom.xml文件中新增： <!--ASPECT--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </depen
自定义注解API数据加密和签名校验
热门推荐
ggboy的博客
01-21 4万+
api数据数据签名(MD5,SHA1) 签名枚举类SginEnum.java package com.jx.app.api.framework.annotation.enums; /** * @ClassName: SginEnum * @Description: TODO(这是一个签名枚举类) * @author gangyu * @date 2018年11月20日 下午...
spring aop 拦截自定义注解的类和方法
面朝大海，春暖花开
05-11 786
在之前需要了解 @within 和 @annotation 的区别@within: 拦截类上@annotation： 拦截方法上@Target({} }
JAVA 简单自定义注解方式 进行AOP方法请求的认证拦截
lin5198195的博客
08-15 1559
主要校验是前端时候在请求的时候带来的Header 认证码是否正确 来判断请求是否有效   1/自定义认证拦截注解 /** * 定义全局 * @auth LZQ * @date 2018-08-13 上午 10:12 */ public class ApplicationConst { public static final String AUTH_TOKEN = "auth...
利用Spring AOP自定义注解解决日志和签名校验 详解
Josn_Hao的博客
06-06 910
一、需解决的问题 部分API有签名参数（signature），Passport首先对签名进行校验，校验通过才会执行实现方法。 　　　　第一种实现方式(Origin)：在需要签名校验的接口里写校验的代码，例如： boolean isValid = accountService.validSignature(appid, signature, client_signature);
详解使用Spring AOP和自定义注解进行参数检查
08-27
通过自定义注解和spring AOP，我们可以实现参数的校验，提高代码的可读性和可维护性。 自定义注解 在本篇文章中，我们定义了三个自定义注解：`ValidParam`、`NotNull`和`NotEmpty`。`ValidParam`注解用于标注需要...
spring aop+自定义注解+反射实现统一校验脚手架
05-24
工程介绍：SpringBoot项目脚手架，利用spring aop+java反射实现自定义注解校验参数 源码里有使用都例子在DemoContorller example1：校验userName参数必填 @CheckParams(notNull = true) private String userName;...
Spring AOP + 自定义注解，一行代码实现用户操作日志记录
Java日常笔记精选的博客
11-14 957
Spring AOP + 自定义注解，快速实现日志记录
AOP和自定义注解进行参数校验
人生就像一场戏
09-06 392
使用SpringMVC作为Controller层进行Web开发时，经常会需要对Controller中的方法进行参数检查。本来SpringMVC自带@Valid和@Validated两个注解可用来检查参数，但只能检查参数是bean的情况，对于参数是String或者Long类型的就不适用了，对此，可以利用Spring的AOP和自定义注解，自己写一个参数校验的功能。 代码示例 注意：本节代码只是一个演示，给出一个可行的思路，并非完整的解决方案。 本项目是一个简单Web项目，使用到了：Spring、Sprin
spring boot通过自定义注解和AOP拦截指定的请求
阿顾的博客
10-28 1万+
本文主要通过切面类和自定注解的方式，拦截指定的接口（代码中已经作了详细的说明） 目录 一 准备工作 二 自定义注解 三 切面类 四 Controller类 五 测试结果  六 源码地址 一 准备工作 1.1 添加依赖 通过spring boot创建好工程后，添加如下依赖，不然工程中无法使用切面的注解，就无法对制定的方法进行拦截 &lt;dependency&...
最详细的SpringBoot实现接口校验签名调用
passerbyYSQ
07-04 7775
验签是指第三方系统在调用接口之前，需要按照原系统的规则根据所有请求参数生成一个签名（字符串），在调用接口时携带该签名。原系统会验证签名的有效性，只有签名验证有效才能正常调用接口，否则请求会被驳回。
Spring中的5种Aop常见应用方式(扫描注解方式)
ArtisticProgramming的博客
11-05 1957
转载于：https://zhuanlan.zhihu.com/p/103236714 提到Aop，不得不提的那就是动态代理；关于动态代理，可以参考前面写过的文章 加耀：浅谈动态代理​zhuanlan.zhihu.com 一个完整的AOP是由多个元素组成的，AOP由切面、切点、连接点、目标对象、回调 五个元素构成；就好比 aspect：切面，通俗的讲可以理解为一个功能，比如具备某项能力(如：帮助他人是一种能力))，定义为一个切面； pointCut：切点，可以理解为一种匹配规则，比如哪些人需要.
spring 注解详解
sinat_34338162的博客
04-23 528
注解（Annotation）不是程序本身，但是可以对程序作出解释，同时注解还可以让其他程序读取。我们可以把注解加在包（package）、类（class）、方法（method）和变量（field）的上面。 注解是一个接口，一个继承自Annotation的接口。 里面每一个属性，其实就是接口的一个抽象方法 一、内置注解 1、@Override 定义在 java.lang.Override 中 , 此注释只适用于修辞方法 , 表示一个方法声明打算 重写超类中的另一个方法声明，简单来说就是子类在重写...
【java】实现自定义注解校验——方法二
最新发布
m0_46459413的博客
11-07 1064
如图是我们自定义的一个年龄注解，message是该注解校验失败时的提示信息，default是默认值，我们可以重写该提示信息。下面两行代码是自定义注解需要加上的，这里不作研究。这里有两种实现方式，一种是当注解仅仅作用在字段(属性)上生效时：可以在工具类中编写方法进行逻辑校验；另一种：使用@Constraint注解，指明了校验类，进行校验，这里只实现第二种。自定义校验注解在代码中的应用////Class
SpringBoot切面@Aspect --- 注解在嵌套方法不生效的问题
yahya·小阳的博客
04-14 2150
例如在service中方法如下 @PermissionAop @Override public List<PoiPermission> getList() { List<PoiPermission> list = this.list(); return list; } @Override public void test(){ this.getList(); Syst
自定义注解+aop（接口防刷、身份认证）
TAO_dream的博客
06-07 356
*注解就是一个标记，一个元数据（描述数据的数据），作用于类、方法、参数、变量、构造器及包声明中的特殊修饰符。把一些公共的逻辑业务抽取出来成一个单独的方法，在需要用到该方法时在合适的位置（进行标记，当你不小心拼写错想要重写的方法是，依然能够变成成功。标记是一个重写方法，如果父类不存在编译器会报错。
Spring源码系列（五）——@Aspect源码解析
犀利的小牛
12-28 2547
首先我们看一下@Aspect的简单实例代码 首先到Config类中添加@EnableAspectJAutoProxy注解打开AOP功能 @ComponentScan(basePackages = "com.kennor.test") @EnableAspectJAutoProxy public class Config { } 自定义注解StudyTrainAnnotation用于标识连接点Joinpoint @Retention(RetentionPolicy.RUNTIME) @Target(Elem
Spring AOP与自定义注解实现参数校验实战
"这篇文章主要讲解如何使用Spring AOP和自定义注解来实现参数检查，以弥补Spring MVC中@Valid和@Validated注解在特定情况下的不足。通过创建自定义注解，如@ValidParam、@NotNull和@NotEmpty，我们可以实现更灵活的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值