SpringMVC----自定义注解

这篇具有很好参考价值的文章主要介绍了SpringMVC----自定义注解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

自定义注解

是什么

作用 

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
        }
    }
}

测试结果

SpringMVC----自定义注解,java,开发语言 

 文章来源地址https://www.toymoban.com/news/detail-732830.html

SpringMVC----自定义注解,java,开发语言 

案例二(获取类属性上的注解属性值)  

编写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

 SpringMVC----自定义注解,java,开发语言

 测试test2

SpringMVC----自定义注解,java,开发语言

 测试test3

SpringMVC----自定义注解,java,开发语言

测试test4

SpringMVC----自定义注解,java,开发语言

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

编写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 

SpringMVC----自定义注解,java,开发语言

测试hello2

SpringMVC----自定义注解,java,开发语言

测试hello3 

SpringMVC----自定义注解,java,开发语言

五.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("这里随便来点啥");
    }
}

测试结果

SpringMVC----自定义注解,java,开发语言

SpringMVC----自定义注解,java,开发语言 

 

 

 

到了这里,关于SpringMVC----自定义注解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 注解开发SpringMVC

               

    2024年02月16日
    浏览(35)
  • “深入理解SpringMVC的注解驱动开发“

    在现代的Web开发中,SpringMVC已经成为了一个非常流行和强大的框架。它提供了许多注解来简化开发过程,使得我们能够更加专注于业务逻辑的实现。本文将深入探讨SpringMVC的注解驱动开发,重点关注常用注解、参数传递、返回值和页面跳转等方面。 1.1 @Controller @Controller注解用

    2024年02月09日
    浏览(33)
  • 【Java】后端开发语言Java和C#,两者对比注解和属性的区别以及作用

    欢迎来到《小5讲堂》 大家好,我是全栈小5。 这是《Java》序列文章,每篇文章将以博主理解的角度展开讲解, 特别是针对知识点的概念进行叙说,大部分文章将会对这些概念进行实际例子验证,以此达到加深对知识点的理解和掌握。 温馨提示:博主能力有限,理解水平有限

    2024年01月16日
    浏览(51)
  • Java语言开发在线小说推荐网 小说推荐系统 基于用户、物品的协同过滤推荐算法 SSM(Spring+SpringMVC+Mybatis)开发框架 大数据、人工智能、机器学习开发

    1、开发工具和使用技术 MyEclipse10/Eclipse/IDEA,jdk1.8,mysql5.5/mysql8,navicat数据库管理工具,tomcat,SSM(spring+springmvc+mybatis)开发框架,jsp页面,javascript脚本,jquery脚本,bootstrap前端框架(用户端),layui前端框架(管理员端),layer弹窗组件等。 2、实现功能 前台用户包含:注

    2023年04月26日
    浏览(79)
  • Java|注解之定义注解

    Java语言使用 @interface 语法来定义注解( Annotation ),它的格式如下:  注解的参数类似无参数方法,可以用 default 设定一个默认值(强烈推荐)。最常用的参数应当命名为 value 。 元注解 有一些注解可以修饰其他注解,这些注解就称为元注解 (meta annotation)。Java标准库已经

    2024年02月05日
    浏览(45)
  • 【Java基础】注解——自定义注解

    Java 注解(Annotation)又称 Java 标注,是 JDK5.0 引入的一种注释机制。 比如我们常见的@Override和@Deprecated都是注解,注解可以加在类、方法、成员变量等上面,类似于给他们“ 打标签 \\\"。 public @interface 注解名{} 看起来和定义接口很相似只是多了一个@符号 接口: public interface 接口名

    2024年02月03日
    浏览(44)
  • Java中的注解,自定义注解

    框架 = 注解 + 反射 + 设计模式 注解( Annotation )是从JDK5.0开始引入,以“@注解名”在代码中存在。 Annotation 可以像修饰符一样被使用,可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。还可以添加一些参数值,这些信息被保存在 Annotation 的 “name=valu

    2023年04月16日
    浏览(103)
  • java 元注解||自定义注解的使用

    1. @Retention注解 指定了标记的注解如何存储: RetentionPolicy.SOURCE,标记的注解仅保留在源代码级别,并被编译器忽略。 RetentionPolicy.CLASS,标记的注解在编译时由编译器保留,但被Java虚拟机(JVM)忽略。 RetentionPolicy.RUNTIME,标记的注解由JVM保留,以便运行时环境可以使用。 2. @Do

    2024年02月16日
    浏览(36)
  • Java的自定义注解

            自定义注解包括注解声明、元注解、运行时处理器三个部分。注解声明指定了注解的名称、作用域、成员等信息;元注解则用来对注解进行修饰;运行时处理器则负责在程序运行过程中处理注解,并根据注解提供的信息执行相应的逻辑。自定义注解在编写框架、插

    2024年02月03日
    浏览(37)
  • Java自定义注解

    目录 一、什么是自定义注解 1)Java注解简介 2)Java注解分类 JDK基本注解 JDK元注解 自定义注解 如何自定义注解? 二、自定义注解 1)获取类上注解值 2)获取类属性上的注解属性值 3)获取方法上的注解值  4)获取参数修饰注解对应的属性值 三、aop应用自定义注解 自定义注

    2024年02月19日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包