Spring进阶（十一）之注解你真的全知道？

已于 2022-12-03 19:07:43 修改
阅读量352 收藏 1
点赞数
分类专栏： spring 文章标签： spring java spring boot
于 2022-10-05 14:45:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56644618/article/details/127156914
版权

目录

注解如何使用？

定义注解

定义注解语法

注解中定义参数

指定注解的使用范围：@Target

指定注解的保留策略：@Retention

使用注解

语法

无参注解

一个参数的注解

一个参数为value的注解，参数名称可以省略

数组类型参数

为参数指定默认值

注解信息的获取

AnnotatedElement常用方法

案例：

@Inherit：实现类之间的注解继承

@Repeatable重复使用注解

@AliasFor：对注解进行增强

我们先来看一个案例：

案例1：通过@AliasFor解决刚才难题 

案例2：同一个注解中使用@AliasFor

案例3：@AliasFor中不指定value和attribute

注解如何使用？

3个步骤：

  • 定义注解
  • 使用注解
  • 获取注解信息做各种牛逼的事情

定义注解

谈到注解的定义，先来想想三个问题：

  • 如何为注解定义参数
  • 注解可以用在哪里
  • 注解会被保留到什么时候

定义注解语法

jdk中注解相关的类和接口都定义在 java.lang.annotation 包中。 注解的定义和我们常见的类、接口类似，只是注解使用 @interface 来定义，如下定义一个名称为 MyAnnotation 的注解：

public @interface MyAnnotation{

}

注解中定义参数

注解有没有参数都可以，定义参数如下：

public @interface 注解名称{
    [public] 参数类型 参数名称1() [default 参数默认值];
    [public] 参数类型 参数名称2() [default 参数默认值];
                        .
                        .
                        .
    [public] 参数类型 参数名称n() [default 参数默认值];
}

注解中可以有多个参数，特点如下：

1. 访问修饰符必须为public，不写默认为public

2. 该元素的类型只能是基本数据类型、String、Class、枚举类型、注解类型（体现了注解的嵌套效果）以及上述类型的一维数组

3. 该元素的名称一般定义为名词，如果注解中只有一个元素，请把名字起为value（后面使用会带来便利操作）

4. 参数名称后面的 () 不是定义方法参数的地方，也不能在括号中定义任何参数，仅仅只是一个特殊的语法

5. default 代表默认值，值必须和第2点定义的类型一致

6. 如果没有默认值，代表后续使用注解时必须给该类型元素赋值

指定注解的使用范围：@Target

使用@Target注解也定义注解的使用范围，如下：

@Target(value = {ElementType.TYPE,ElementType.METHOD})
public @interface MyAnnotation {
    
}

上面指定了 MyAnnotation 注解可以用在类、接口、注解类型、枚举类型以及方法上面，自定义注解上 也可以不使用@Target注解，如果不使用，表示自定义注解可以用在任何地方。

我们来看一下@Target的源码：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}

有一个参数value，是ElementType类型的一个数组，再来看一下 ElementType ，是个枚举，源码如下：

/*注解的使用范围*/
public enum ElementType {
    /*类、接口、枚举、注解上面*/
    TYPE,
    /*字段上*/
    FIELD,
    /*方法上*/
    METHOD,
    /*方法的参数上*/
    PARAMETER,
    /*构造函数上*/
    CONSTRUCTOR,
    /*本地变量上*/
    LOCAL_VARIABLE,
    /*注解上*/
    ANNOTATION_TYPE,
    /*包上*/
    PACKAGE,
    /*类型参数上*/
    TYPE_PARAMETER,
    /*类型名称上*/
    TYPE_USE
}

指定注解的保留策略：@Retention

我们先来看一下java程序的3个过程

  • 源码阶段
  • 源码被编译为字节码之后变成class文件
  • 字节码被虚拟机加载然后运行

我们可以通过@Retention注解来指定注解保留到那个阶段，如：

@Retention(RetentionPolicy.SOURCE)//表示MyAnnotation只保留到源码阶段，之后的两个阶段会丢失
@Target(value = {ElementType.TYPE,ElementType.METHOD})
public @interface MyAnnotation {

}

我们来看一下@Retention源码

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * Returns the retention policy.
     * @return the retention policy
     */
    RetentionPolicy value();
}

有一个value参数，类型为RetentionPolicy枚举，如下：

public enum RetentionPolicy {
/*注解只保留在源码中，编译为字节码之后就丢失了，也就是class文件中就不存在了*/
SOURCE,
/*注解只保留在源码和字节码中，运行阶段会丢失*/
CLASS,
/*源码、字节码、运行期间都存在*/
RUNTIME
}

使用注解

语法

将注解使用在目标对象的上面

@注解名称(参数1=值1,参数2=值2,参数n=值n)

目标对象

无参注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann1 { //@1
}
@Ann1 //@2
public class UseAnnotation1 {
}

一个参数的注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann2 { //@1
String name();
}
@Ann2(name = "张三") //@2
public class UseAnnotation2 {
}

一个参数为value的注解，参数名称可以省略

当注解只有一个为value的参数时，使用的时候参数名称可以省略

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann3 {
String value();//@1
}
@Ann3("张三") //@2
public class UseAnnotation3 {
}

数组类型参数

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann4 {
String[] name();//@1
}
@Ann4(name = {"张三", "李四"}) //@2
public class UseAnnotation4 {
@Ann4(name = "如果只有一个值，{}可以省略") //@3
public class T1 {
}
}

为参数指定默认值

通过default为参数指定默认值，使用的时候如果没有为该参数设置值则使用默认值，如果为该参数设置了值就使用该值。没有设置默认值的参数使用的时候必须设置值。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann5 {
String[] name() default {"张三", "李四"};//@1
int[] score() default 1; //@2
int age() default 30; //@3
String address(); //@4
}
@Ann5(age = 32,address = "上海") //@5
public class UseAnnotation5 {
}

注解信息的获取

为了运行时能准确获取到注解的相关信息，Java在 java.lang.reflect 反射包下新增了 AnnotatedElement 接口，它主要用于表示目前正在虚拟机中运行的程序中已使用注解的元素，通过该 接口提供的方法可以利用反射技术地读取注解的信息。

Package：用来表示包的信息

Class：用来表示类的信息

Constructor：用来表示构造方法信息

Field：用来表示类中属性信息

Method：用来表示方法信息

Parameter：用来表示方法参数信息

TypeVariable：用来表示类型变量信息，如：类上定义的泛型类型变量，方法上面定义的泛型类型变量 

AnnotatedElement常用方法

案例：

现有一个类如下：
 

@Ann1("用在了类上")
@Ann2(0)
public class MyAnnotation<@Ann1("用在类变量类型T1上") @Ann2(1) T1,@Ann1("用在类变量类型T2上") @Ann2(2) T2> {

    @Ann1("用在字段上")
    @Ann2(3)
    private String name;

    private Map<@Ann1("用在了泛型类型上，String") @Ann2(4) String,@Ann1("用在了泛型类型上，Integer") @Ann2(5) Integer> map;

    @Ann1("用在了构造方法上")
    @Ann2(6)
    public MyAnnotation(@Ann1("用在了参数上") @Ann2(7) String name) {
        this.name = name;
    }

    @Ann1("用在了返回值上")
    @Ann2(8)
    public String test(){
        return null;
    }
}

@Target({ElementType.PACKAGE,
        ElementType.TYPE,
        ElementType.FIELD,
        ElementType.CONSTRUCTOR,
        ElementType.METHOD,
        ElementType.PARAMETER,
        ElementType.TYPE_PARAMETER,
        ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann1 {
    String value();
}

@Target({ElementType.PACKAGE,
        ElementType.TYPE,
        ElementType.FIELD,
        ElementType.CONSTRUCTOR,
        ElementType.METHOD,
        ElementType.PARAMETER,
        ElementType.TYPE_PARAMETER,
        ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann2 {
    int value();
}

解析类上的注解：

    @Test
    //解析类上的注解
    public void test1() {
        for (Annotation annotations : MyAnnotation.class.getAnnotations()) {
            System.out.println(annotations);
        }
    }

解析类上的类型变量：

    @Test
    //解析类上的类型变量
    public void test2() {
        TypeVariable<Class<MyAnnotation>>[] typeParameters = MyAnnotation.class.getTypeParameters();
        for (TypeVariable<Class<MyAnnotation>> typeVariable : typeParameters) {
            System.out.println(typeVariable.getName());
            Annotation[] annotations = typeVariable.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.println(annotation);
            }
        }
    }

解析字段name上的注解：

    @Test
    //解析字段name上的注解
    public void test3() throws Exception {
        Field name = MyAnnotation.class.getDeclaredField("name");
        for (Annotation annotation : name.getAnnotations()) {
            System.out.println(annotation);
        }
    }

解析泛型字段map上的注解：

    @Test
    //解析泛型字段map上的注解
    public void test4() throws NoSuchFieldException {
        Field field = MyAnnotation.class.getDeclaredField("map");
        Type genericType = field.getGenericType();
        Type[] actualTypeArguments = ((ParameterizedType)
                genericType).getActualTypeArguments();
        AnnotatedType annotatedType = field.getAnnotatedType();
        AnnotatedType[] annotatedActualTypeArguments = ((AnnotatedParameterizedType) annotatedType).getAnnotatedActualTypeArguments();
        int i = 0;
        for (AnnotatedType actualTypeArgument : annotatedActualTypeArguments) {
            Type actualTypeArgument1 = actualTypeArguments[i++];
            System.out.println(actualTypeArgument1.getTypeName() + "类型上的注解如下：");
            for (Annotation annotation : actualTypeArgument.getAnnotations()) {
                System.out.println(annotation);
            }
        }
    }

 解析构造函数上的注解：

    @Test
    //解析构造函数上的注解
    public void test5(){
        Constructor<?> constructor = MyAnnotation.class.getDeclaredConstructors()[0];
        for (Annotation annotation:constructor.getAnnotations()){
            System.out.println(annotation);
        }
    }

解析指定方法的参数位置的注解： 

    @Test
    //解析指定方法的参数位置的注解
    public void test6(){
        Constructor<?> constructor = MyAnnotation.class.getDeclaredConstructors()[0];
        Parameter parameter = constructor.getParameters()[0];
        for (Annotation annotation:parameter.getAnnotations()){
            System.out.println(annotation);
        }
    }

 解析test方法上的注解：

    @Test
    //解析test方法上的注解
    public void test7(){
        Method method = MyAnnotation.class.getDeclaredMethods()[0];
        for (Annotation annotation:method.getAnnotations()){
            System.out.println(annotation);
        }
    }

@Inherit：实现类之间的注解继承

@Inherited注解，我们先来看看其源码：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

由@Target(ElementType.ANNOTATION_TYPE)我们能得知Inhrited注解是用在注解上面的

作用：让子类可以继承父类中被@Inherited修饰的注解，注意是继承父类中的，如果接口中的注解也使用@Inherited修饰了，那么接口的实现类是无法继承这个注解的

案例：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface T1 {
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface T2 {
}
@T1
public class B {
}
@T2
public interface C {
}
public class D extends B implements C{
}
public class InheritTest {

    @Test
    public void test(){
        Annotation[] annotations = D.class.getAnnotations();
        for (Annotation annotation:annotations){
            System.out.println(annotation);
        }
    }
}

运行后输出：

对于上面的代码：

我们首先是创建了两个注解T1 T2，且这两个注解都有@Inherited注解的修饰。

其次我们又创建了一个B类，B类使用了@T1注解，以及一个C接口，C接口使用了@T2注解。

最后我们是创建了一个D类来继承B类实现C接口，然后测试该D类含有的注解。

运行后发现D类只有@T1一个注解，验证了我们上面所说：一个类可以继承其父类中用@Inherited注解来修饰的注解，而不能继承其父接口中用@Inherited注解来修饰的注解

@Repeatable重复使用注解

先来看一段代码：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Ann1{}


@Ann1
@Ann1
public class test {
}

上面的代码肯定是会报错的，因为test这个类上面用了两次@Ann1这个注解。默认情况下，同一个注解在同一个位置不能重复使用。

这时候，就需要用到我们的@Repeatable注解了

使用步骤：

  • 先定义一个“容器”注解
@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Ann1 {
    Ann2[] value();
}

容器注解中必须有个value类型的参数，参数类型为子注解类型的数组。

  • 为注解指定容器
@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Ann1.class)
public @interface Ann2 {
    String name();
}

要让一个注解可以重复使用，需要在注解上加上@Repeatable注解，@Repeatable中value的值为容器注解

  • 使用注解

这种可以重复使用的注解的使用方法有两种：

重复使用注解，如下面的类上重复使用@Ann1注解

通过容器注解来使用更多个注解，如下面的字段name上使用@Ann2容器注解

@Ann2(name = "张三")
@Ann2(name = "李四")
public class B {

    @Ann1({@Ann2(name = "王五"), @Ann2(name = "陈六")})
    private String name;
}

 测试：

public class RepeatableTest {

    @Test
    public void test() throws NoSuchFieldException {
        Annotation[] annotations = B.class.getAnnotations();
        for (Annotation annotation:annotations){
            System.out.println(annotation);
        }
        System.out.println("---------------");
        Field name = B.class.getDeclaredField("name");
        for (Annotation annotation:name.getAnnotations()){
            System.out.println(annotation);
        }
    }
}

@AliasFor：对注解进行增强

我们先来看一个案例：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface A1 {

    String value() default "a";
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A1
public @interface B1 {

    String name() default "b";
}
@B1(name = "张三")
public class QuestionTest {

    @Test
    public void test(){

        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, A1.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, B1.class));
    }
}

运行输出：

上述代码中：

我们创建了一个A1注解，value参数默认值为a

又创建了一个B1注解，且B1注解用到了A1注解，B1注解的name参数默认值为b

接着我们又写了个测试方法test，里面使用到了spring中的一个类 AnnotatedElementUtils ，通过这个工具类可以很方便的获取注解的各种信息，方法中的2行代码用于获取QuestionTest类上B1注解和A1注解的信息。

--------------------------------------------------------------------------------------------------------------------------

此时有个问题：此时如果想在 QuestionTest类上给B1上的A1注解设置值是没有办法的，注解定义无法继承导致的，如果注解定义上面能够继承，那用起来会爽很多，spring通过@Aliasfor方法解决了这个问题。

案例1：通过@AliasFor解决刚才难题 

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface A1 {

    String value() default "a";
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A1//@1
public @interface B1 {

    String name() default "b";

    @AliasFor(annotation = A1.class,value = "value")
    String test();
}
@B1(name = "张三",test = "李四")
public class QuestionTest {

    @Test
    public void test(){

        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, A1.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, B1.class));
    }
}

运行后输出：

上面输出汇总可以看出A1的value值和B1的test值一样，说明通过B1给A1设置值成功了。 重点在于@AliasFor 注解：

这个相当于给某个注解指定别名，即将B1注解中test参数作为 A1中 value 参数的别名，当给 B1的test设置值的时候，就相当于给 A1的value设置值 ，有个前提是@AliasFor注解的 annotation 参数指定的注解需要加在当前的这个注解上面，如：@1

案例2：同一个注解中使用@AliasFor

@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface T1 {

    @AliasFor("v2")
    String v1() default "";

    @AliasFor("v1")
    String v2() default "";
}
@T1(v1 = "张三")
public class QuestionTest {

    @T1(v2 = "李四")
    public String name;



    @Test
    public void test() throws NoSuchFieldException {
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, T1.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class.getDeclaredField("name"), T1.class));
    }
}

注意上面代码，T1注解中 v1 和 v2 的2个参数都设置了@AliasFor，@AliasFor如果不指定 annotation 参数的值，那么 annotation 默认值就是当前注解，所以上面2个属性互为别名，当 给v1设置值的时候也相当于给v2设置值，当给v2设置值的时候也相当于给v1设置值。

从从下面输出中也可以看出v1和v2的值始终是相等的，所以如果同时给v1和v2设置值的时候运行代码会报错。

运行后输出：

 我们来看看@AliasFor注解的源码：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface AliasFor {
    @AliasFor("attribute")
    String value() default "";

    @AliasFor("value")
    String attribute() default "";

    Class<? extends Annotation> annotation() default Annotation.class;
}

AliasFor注解中 value 和 attribute 互为别名，随便设置一个，同时会给另外一个设置相同的值。

案例3：@AliasFor中不指定value和attribute

当使用@AliasFor时如果不指定value或者attribute，会自动将@AliasFor修饰的参数作为value和attribute的值，还需注意一点，此种情况要想满足需要满足这两个注解中的这俩参数名称需一致

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface T1 {

    String test() default "";//@1
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@T1
public @interface T2 {

    @AliasFor(annotation = T1.class)
    String test() default "";//@2
}
@T2(test = "测试数据")
public class QuestionTest {

    @Test
    public void test(){

        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, T1.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(QuestionTest.class, T2.class));
    }
}

运行后输出：

冰魄雕狼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
idea使用lombok插件，用注解写getter，setter，tostring，有参无参
qq_44374239的博客
08-03 1867
package org.example.bean; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import lombok.ToString; //idea使用lombok插件，用注解写getter，setter，tostring，有参无参 @Data//代表getter,setter @AllArgsConstructor//有参构造 @NoArgsConstructor
参数注解
不赖床会死星人的博客
02-16 694
1、对函数的参数进行类型注解 2、对函数的返回值进行类型注解 3、只对函数参数做一个辅助说明，并不对函数参数进行类型检查 4、提供给第三方工具，做代码分析，发现隐藏BUG 5、函数注解的信息，保存在__annotations__属性中 def add(x: int, y: int, *args, **kwargs) -&gt; int: ret = x + y ret...
不要再稀里糊涂的使用反射了，四万字带你搞定Java反射（JDK8）
有术无道止于术，有道无术尚有可为。
12-05 593
阅读本文要求对Java和JVM具有一定程度的了解，请先看下面几个基础问题：如果不能回答出以上问题，建议再复习一下Java语法。通过本文你将彻底掌握反射。类加载器通过一个类的全限定类名加载此类的字节码文件，并将字节码文件的静态存储结构转化为元空间的运行时数据结构，接着在堆中生成一个代表这个类的对象作为元空间这个类的各种元数据的接口，我们可以在程序中获取类的对象，从而获得在运行时分析类的能力，这就是反射。代表Java中的类、接口、枚举、注解（以上这些不含类型变量的类型被称为原始类型）、数组和基本类型。这在没有泛
springboot注解方式，@Autowire和有参构造和无参构造使用哪个创建对象
H_Q_Li的博客
11-04 3409
springboot注解方式，@Autowire和有参构造和无参构造使用哪个创建对象
JAVA-常见的几种注解以及如何创建自定义注解
mulinghanxue的博客
06-07 485
文章目录常见的几种注解元注解无参注解的定义有参注解的定义 平常我们在编写代码中经常会看到这样的一种代码,@****,看着好像没有什么作用,像是注释,但又不是注释的形式,其实,这是注解… 常见的几种注解 下面举几个我们经常看见的例子: //方法的重写 @Override // 不推荐使用注解, 但你非要用的话,也可以使用 @Deprecated //消除代码警告(注意是警告,不是报错,别搞混了......
构造函数讲解
weixin_41987908的博客
11-21 637
我们调用某一个类中的方法时，SysController.方法 。但是这个SysController 并不是类上的SysController 而是构造函数上的SysController，默认为public ，改为private 目的是为了不允许别的类中在new 这个SysController。 ...
报错异常：java.lang.IllegalArgumentException: Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]
qq_43514855的博客
09-17 3534
问题描述：数据库表中的字段类型为VARCHAR类型，而bean实体类中，该字段设置为了DATE类型，并且利用get方法把该字段的值赋值给另一个DATE类型的字段插入数据库。 解决办法： Date date1 = new Date();//获取当前时间 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String str = sdf.format(date1);//时间存储.
常用参数注解
richest_qi的博客
12-31 2245
文章目录@PathVariable@RequestHeader@RequestParam@CookieValue@RequestBody 本篇内容与 SpringMVC获取请求参数、SpringMVC获取请求体这两篇文章内容有重复，就当是复习总结了。 首先，新建Spring项目：demo4，并添加依赖Lombok、Spring Configuration Processer和Spring Web。 新建控制器com.example.boot.controller.Demo4Controller，内容如下。
java getgenericparametertypes,如何从Java 8中的getAnnotatedParameterTypes（）获取泛型类型信息？...
weixin_35489715的博客
02-25 366
It seems like getAnnotatedParameterTypes() returns an array of AnnotatedTypes holding raw, rather than generic, types. For example:public void genericMethod(T t) {}@Testpublic void testAnnotatedType...
AnnotationMetadata、 MethodMetadata
aataxuefeihong的博客
11-02 217
Metadata在框架中往往是个很重要的概念，不仅仅是Spring，MyBatis、Hibernate等流行框架中都有类似的元数据的概念。它没有Standard的实现（毕竟AnnotatedElement也是接口，没办法做基础实现的），但是它有两个非常重要的子接口：AnnotationMetadata和MethodMetadata 这两个接口是Spring内部的直接运用。ClassMetadata：对Class的封装适配，使用它时，并不要求该Bean已经被加载~它的所有方法，基本上都跟Class有关。
详解Spring Boot最核心的27个注解，你了解多少？
08-25
主要介绍了详解Spring Boot最核心的27个注解，你了解多少？文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
下面小编就为大家分享一篇Spring Aop之AspectJ注解配置实现日志管理的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java进阶之Spring概述共3页.pdf.zip
11-20
Java进阶之Spring概述共3页.pdf.zip
Java进阶之SpringIoC源码深度剖析共19页.pd
11-20
Java进阶之SpringIoC源码深度剖析共19页.pdf.zip
Java进阶之SpringAOP源码深度剖析共17页.pd
11-20
Java进阶之SpringAOP源码深度剖析共17页.pdf.zip
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
最新发布
阿里巴巴云原生的博客
04-29 747
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
springboot集成-mybatis-puls
csy08845的博客
04-29 118
Spring Boot中集成MyBatis Plus是一个相对简单的过程，MyBatis Plus是一个MyBatis的增强工具，它简化了CRUD操作，并且提供了一些额外的功能，比如性能优化、自动填充等。3.配置MyBatis Plus：通常，MyBatis Plus的配置与MyBatis类似，不需要额外的配置，因为它会自动配置。6.使用Mapper：在你的Service中注入Mapper，并使用它。7.配置扫描：确保Spring Boot扫描到你的Mapper接口。
SpringBoot项目打包分离高阶操作
Record Little
04-23 735
虽然传输jar包 比较大，但是安全性、稳定性比较高，不需要关注pom.xml 添加了新的依赖、更新了版本号等等影响版本功能的操作。关注maven的特性， profiles即可满足， 根据不同的activation 状态，激活不同的build操作。每次修改一小部分代码或仅仅更新某个依赖jar包时，都需要重新进行整个项目的构建、打包、上传和部署。但是当你的项目趋于稳定，只有业务上的逻辑变更时，如果使用分离版本，可以加快迭代、更新的速度。弊端： 需要配置IDE命令，修改依赖时需要同时修改2处。
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
xzy的博客
04-23 1030
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
spring配置文件注解变成#??????
08-01
可以尝试以下步骤来解决Spring配置文件注解变成#??????的问题： 1. 检查配置文件的编码格式是否正确。确保配置文件的编码格式与项目所使用的编码格式一致。可以尝试将配置文件的编码格式改为UTF-8。 2. 检查配置文件的路径是否正确。确保配置文件在正确的位置，并且在项目中能够正确加载。 3. 检查注解的引入是否正确。确保在配置文件中正确引入了注解的命名空间。例如，在XML配置文件中，需要添加如下命名空间声明： ```xml xmlns:context="http://www.springframework.org/schema/context" ``` 并在 `<beans>` 标签内添加如下引入： ```xml xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" ``` 4. 检查注解的使用是否正确。确保注解的使用方式正确，并且注解所标注的类、方法或字段符合规范。 如果上述步骤都没有解决问题，可以提供更多的详细信息，例如完整的配置文件内容、相关代码片段或错误信息，以便更好地帮助你解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰魄雕狼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值