SpringMVC----自定义注解

最新推荐文章于 2023-12-17 22:23:58 发布
最新推荐文章于 2023-12-17 22:23:58 发布
阅读量807 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74934282/article/details/132890025
版权

目录

自定义注解

是什么

作用 

JDK元注解 

测试案列 

案例一（获取类与方法上的注解值）

案例二（获取类属性上的注解属性值）  

案例三（获取参数修饰注解对应的属性值）

五.Aop自定义注解的应用

Mylog前置通知

自定义注解

是什么

SpringMVC自定义注解是指开发者根据自己的需求，在SpringMVC框架中自定义的注解。通过自定义注解，可以实现对请求参数、方法、类等进行自定义的标记和处理。

开发者可以通过自定义注解来简化代码，提高代码的可读性和可维护性。例如，可以自定义一个注解来标记某个方法需要进行权限验证，然后在拦截器中根据该注解进行相应的处理；或者可以自定义一个注解来标记某个方法需要进行日志记录，然后在切面中根据该注解进行相应的处理。

自定义注解可以使用Java的元注解（如@Target、@Retention、@Inherited等）来指定注解的使用范围和生命周期。同时，还可以使用注解处理器来对自定义注解进行解析和处理，从而实现更加复杂的功能。

总之，SpringMVC自定义注解是开发者在SpringMVC框架中自己定义的注解，可以用于对请求参数、方法、类等进行自定义的标记和处理。

作用 

SpringMVC自定义注解的主要用途有以下几个方面：

  1. 简化代码：通过自定义注解，可以将一些重复性的代码逻辑封装在注解中，从而简化代码的编写和维护工作。

  2. 增强可读性和可维护性：通过自定义注解，可以将一些特定的功能和逻辑以注解的方式进行标记，使代码更加清晰易懂，提高代码的可读性和可维护性。

  3. 实现特定功能：通过自定义注解，可以实现一些特定的功能，如权限验证、日志记录、参数校验等。开发者可以在自定义注解中定义相应的逻辑，并在相应的地方使用该注解来触发相应的功能。

  4. 解耦合：通过自定义注解，可以将一些与业务逻辑无关的功能从代码中解耦出来，使得代码更加清晰、简洁和可扩展。

总之，SpringMVC自定义注解可以帮助开发者简化代码、增强代码的可读性和可维护性，实现特定的功能，并解耦合相关的功能，提高代码的质量和开发效率。

JDK元注解 

@Retention：定义注解的保留策略
@Retention(RetentionPolicy.SOURCE)             //注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS)              //默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
@Retention(RetentionPolicy.RUNTIME)            //注解会在class字节码文件中存在，在运行时可以通过反射获取到

@Target：指定被修饰的Annotation可以放置的位置(被修饰的目标)
@Target(ElementType.TYPE)                      //接口、类
@Target(ElementType.FIELD)                     //属性
@Target(ElementType.METHOD)                    //方法
@Target(ElementType.PARAMETER)                 //方法参数
@Target(ElementType.CONSTRUCTOR)               //构造函数
@Target(ElementType.LOCAL_VARIABLE)            //局部变量
@Target(ElementType.ANNOTATION_TYPE)           //注解
@Target(ElementType.PACKAGE)                   //包
注：可以指定多个位置，例如：
@Target({ElementType.METHOD, ElementType.TYPE})，也就是此注解可以在方法和类上面使用

@Inherited：指定被修饰的Annotation将具有继承性

@Documented：指定被修饰的该Annotation可以被javadoc工具提取成文档.

测试案列 

案例一（获取类与方法上的注解值）

编写定义常量TranscationModel类

package com.xiaoxu.annotation.demo1;

public enum  TranscationModel {
    Read, Write, ReadWrite;
    private String name;
    private Integer id;
    public void init1(){
        Read.id = 1;
        Read.name = "sz";
    }
    public void init2(){
        Write.id = 2;
        Write.name = "sg";
    }
    public void init3(){
        ReadWrite.id = 3;
        ReadWrite.name = "sn";
    }
}

编写MyAnnotation1 

package com.xiaoxu.annotation.demo1;

import java.lang.annotation.*;

/**
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation1 {
    String name();
}

编写MyAnnotation2 

package com.xiaoxu.annotation.demo1;

import java.lang.annotation.*;

/**
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

编写MyAnnotation3 

package com.xiaoxu.annotation.demo1;

import java.lang.annotation.*;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

 编写测试类Demo1

package com.xiaoxu.annotation.demo1;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {

    @MyAnnotation1(name = "xyz")
    protected Integer age;

    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }

    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}

编写测试类Demo1Test 

package com.xiaoxu.annotation.demo1;

import org.junit.jupiter.api.Test;


public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo2.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//abc

//        获取方法上的注解
//        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
//        System.out.println(myAnnotation2.model());//Read
//
        获取属性上的注解
//        MyAnnotation1 myAnnotation1 = Demo2.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
//        System.out.println(myAnnotation1.name());// xyz
    }

    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo2.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

测试结果

 

 

 

案例二（获取类属性上的注解属性值）  

编写TestAnnotation类

package com.xiaoxu.annotation.demo2;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

    String what() default "这里是默认的what属性对应的值";
}

编写Demo2测试类 

package com.xiaoxu.annotation.demo2;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    private static String msg1;

    @TestAnnotation("这就是value对应的值1")
    private static String msg2;

    @TestAnnotation(value = "这就是value对应的值2")
    private static String msg3;

    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

编写Demo2Test测试类

package com.xiaoxu.annotation.demo2;

import org.junit.jupiter.api.Test;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }

    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }

    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }

    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}

 测试test1

 

 测试test2

 测试test3

测试test4

案例三（获取参数修饰注解对应的属性值）

编写IsNotNull类

package com.xiaoxu.annotation.Demo3;

import java.lang.annotation.*;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

编写Demo3测试类

 

package com.xiaoxu.annotation.Demo3;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {

    public void hello1(@IsNotNull(true) String name) {

        System.out.println("hello:" + name);
    }

    public void hello2(@IsNotNull String name) {

        System.out.println("hello:" + name);
    }
}

编写Demo3Test测试类

 

package com.xiaoxu.annotation.Demo3;

import org.junit.jupiter.api.Test;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;


/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
public class Demo3Test {

    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
            }
        }
    }

    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false
            }
        }
    }

    @Test
    public void hello3() throws Exception {
//        模拟浏览器传递到后台的参数 解读@requestParam
        String name = "zs";
        Demo3 demo3 = new Demo3();
        Method method = demo3.getClass().getMethod("hello1", String.class);
        for (Parameter parameter : method.getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
                if (annotation.value() && !"".equals(name)){
                    method.invoke(demo3,name);
                }
            }
        }
    }
}

测试hello1 

测试hello2

测试hello3 

五.Aop自定义注解的应用

Mylog前置通知

编写Mylog前置通知类

package com.xiaoxu.annotation.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

编写MyLogAspect切面类 

package com.xiaoxu.aspect;

import com.xiaoxu.annotation.aop.MyLog;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.Arrays;


@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);

    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.xiaoxu.annotation.aop.MyLog)")
    private void MyValid() {
    }

//    @Before("MyValid()")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        logger.debug("[" + signature.getName() + " : start.....]");
        System.out.println("[" + signature.getName() + " : start.....]");

        MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
        logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
        System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    }


    @Around("MyValid()")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println(pjp.getTarget());
        System.out.println(pjp.getThis());
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        Object ob = pjp.proceed();// ob 为方法的返回值
        System.out.println(ob);
        logger.info("耗时 : "+(System.currentTimeMillis() - startTime));
        return ob;
    }


}

编写LogController

package com.xiaoxu.web;

import com.xiaoxu.annotation.aop.MyLog;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;


@Controller
public class LogController {

    @RequestMapping("/mylog")
    @MyLog(desc = "日志管理")
    public void testLogAspect(HttpServletRequest request) {
        request.getRemoteAddr();
        request.getRemotePort();
        System.out.println("这里随便来点啥");
    }
}

测试结果

 

 

 

 

懒大王o
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springMvc-Study1
07-05
9. **拦截器（Interceptor）**：Spring MVC 允许自定义拦截器，可以在请求处理前后进行预处理和后处理，如权限检查、日志记录等。 10. **转换器和格式化器（Converter & Formatter）**：这些组件用于将请求参数转换...
SpringMVC - 车
05-23
在Spring Boot中，通过@EnableWebMvc注解开启SpringMVC支持，也可以使用WebMvcConfigurer接口自定义配置，如拦截器、静态资源处理等。 11. **测试支持** SpringMVC提供了MockMvc类，可以方便地进行单元测试和集成...
springAop自定义注解,并响应前端
heni6560的博客
11-12 661
执行顺序 在一个方法只被一个aspect类拦截时，aspect类内部的+advice+将按照以下的顺序进行执行： 正常情况： 异常情况： 功能描述 在方法执行前，判断任务是否开启，若开启，返回前端，提示任务已开启，并阻止方法执行。 前端请求 function testSchdule() { $.ajax({ url: "/sys...
【springMvc】自定义注解的使用方式
2301_76988707的博客
09-15 320
注解Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观、更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
SpringBoot优化控制层代码，使用@Valid 对传入的参数进行校验，并自定义一个参数校验注解
Wangdiankun的博客
05-17 1922
在controller层，对数据进行校验首先使用@Valid注解，去到自己定义的和传入参数对应的类中，进行相应的参数要求的校验、 在controller接受 @PostMapping(value = "/login_submit") public ResponseResult<Boolean> login_submit(@Valid LoginVo loginVo) { userService.checkLogin(loginVo); return Re
Aop+自定义注解对入参进行操作（过滤、解密）
Muscleheng的博客
07-21 4658
背景：对外提供接口，为了数据安全，接口入参进行了数据加密，接口收到参数后需要进行解密；如果每一个接口都要对入参进行一 一的解密操作，就大大增加了代码量和工作量； 所以，这里使用自定义注解加Aop进行无侵入式的操作； 第一步：自定义注解 package com.example.demo.common; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.ann
Spring Boot 之自定义注解&&切面日志&&前端响应
m0_58525944的博客
01-19 1756
一，了解自定义注解 1.1 自定义注解的定义、描述 注解是一种能被添加到java源代码中的元数据，方法、类、参数和包都可以用注解来修饰。注解可以看作是一种特殊的标记，可以用在方法、类、参数和包上，程序在编译或者运行时可以检测到这些标记而进行一些特殊的处理。 1.2 常用的自定义注解 1.3 OK！到这就结束了，希望能帮到你！！！ ...
spring自定义注解及使用
ZHANGLIZENG的博客
05-31 8576
一文搞懂spring自定义注解及使用场景
springmvc-mybatis. rar后端- Java
06-18
5. **拦截器**：自定义拦截器可以实现通用的功能，如权限验证、日志记录等。 6. **注解驱动**：Spring MVC支持使用注解来配置控制器和方法，简化XML配置。 MyBatis是一个优秀的持久层框架，它支持定制化的SQL、存储...
springmvc-high-other-05.rar
01-24
8. **RESTful风格的支持**：SpringMVC支持构建RESTful API，通过@RequestMapping注解和HTTP动词（GET、POST、PUT、DELETE等）定义资源操作，使得服务更符合Web标准，易于集成和测试。 9. **模板引擎集成**：...
spring-mvc-test-sample-master.zip_spring mvc_springmvc－test
09-19
开发者可以创建自定义的控制器类，通过`@RequestMapping`等注解来处理特定的HTTP请求。 3. **Model**：模型是应用程序的数据载体，通常由Java对象构成，这些对象包含了业务逻辑处理的结果。 4. **View**：视图负责...
深入探究Spring MVC如何处理请求报文和响应报文
weixin_41998947的博客
12-02 575
创建一个Controller然后定义一个方法，方法上面添加@RequestMapping定义url，然后在方法参数中添加@RequestBody注解，在方法上添加@ResponseBody注解，这样在通过url调用这个接口的时候就会自动将参数转换成对象，并且将响应报文也变成对象。而且在调用接口的时候传的String类型的对象，处理请求的handler方法中参数类型却是Integer，这些都是如何实现的呢。其实这些都是通过Spring的参数装换器实现的，接下来我们就通过源码的形式看一下这种参数装换的细节。
SpringMVC之自定义注解
weixin_74268571的博客
09-16 457
自定义注解的介绍，它的好处及应用场景等，如何去定义并使用自定义注解，也详细讲解了三种使用案例，最后是Aop自定义注解的应用
【精选】SpringMVC处理响应及注解开发
guojiaqi_的博客
12-17 1376
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts 2(一般老项目使用)等等。
controller接口参数使用自定义注解修改传入值
weixin_44807009的博客
09-04 1534
自定义注解修改接口参数
Spring MVC 自定义注解传参
leoxyk的专栏
05-23 3668
1.场景在控制器中，需要获取用户详细信息，该信息可能存储在session或数据库中，为了简便，可以通过自定义注解的方式，将用户信息传入 1/** 2 * 获取当前用户信息 3 * @param currentUser 4 * @return 5 */ 6@GetMapping("/getCurrentUser") 7public ResponseEntity&lt;?&gt; getC...
使用Spring AOP、自定义注解实现对Request传参拦截
chenyi406的博客
11-11 1852
使用Spring boot开发项目与前端人员对接接口时由于在调试，经常传来null、undefined、NaN等非法参数，于是利用spring 的自定义注解以及AOP实现简单的传入参数拦截。 一、使用方法 /** * 登录 * 当参数是实体类时,通过 参数名.属性名 的方式注解参数 */ @CheckParam(params = {"user.stuN...
springmvc-config
最新发布
06-22
1. **Java配置类**：在Spring MVC Config中，开发者可以创建自定义的@Configuration类，使用@Bean注解来声明和配置Bean实例，包括Controller、ViewResolver、MessageSource等。这种方式避免了XML文件的复杂性和冗余...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值