什么是注解?

注解是什么意思? 前言: 注解: *注解:说明程序的(给计算机看) *注释:用文字描述程序的。(给程序员看) *定义: 从JDK5开始,Java增加对元数据的支持,也就是注解,注解与注释是有一定区别的,可以把注解理解为代码里的特殊标记,这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 *概念描述: *JDK1.... 阅读详情

一、注解是什么?

java注解是在JDK5的时候引入的一种新特性。
注解(也可以称为元数据)为在代码中添加信息提供了一种形式化的方法,使得在代码中任一时刻可以非常方便的使用这些数据。
注解类型定义了一种新的特殊接口类型,在接口关键期interface之前加@符号,即用@interface即可区分注解与普通接口声明。目前大部分框架都是通过使用注解简化代码提高编码效率

二、注解的作用

  1. 提供信息给编译器:编译器可直接通过注解探测错误和警告信息,例如:@Override,@Deprecated
  2. 编译阶段时的处理:软件工具可以用来利用注解信息生成代码、html文档或者做其他相应处理,例如:@Param,@Return,@See,@Author用于生成javadoc文档
  3. 运行时的处理:某些注解可以在程序运行时接收代码的提取,但注解本身不是代码的一部分

三、注解定义

3.1 注解的本质

所有的注解本质上都是继承自 Annotation 接口。但是,手动定义一个接口继承 Annotation 接口无效的,需要通过 @interface 声明注解,Annotation 接口本身也不定义注解类型,只是一个普通的接口。

public interface Annotation {  
    boolean equals(Object obj);
    int hashCode();
    String toString();
    /**
     *获取注解类型 
     */
    Class<? extends Annotation> annotationType();
}

来对比下 @interface 定义注解和继承 Annotation 接口

public @interface TestAnnotation1 {
}
public interface TestAnnotation2 extends Annotation  {
}

通过使用 javap 指令对比两个文件的字节码,发现通过 @interface 定义注解,本质上就是继承 Annotation 接口。

// javap -c TestAnnotation1.class
Compiled from "TestAnnotation1.java"                                                                 
public interface com.hncboy.corejava.annotation.TestAnnotation1 extends java.lang.annotation.Annotation {}
​
// javap -c TestAnnotation2.class
Compiled from "TestAnnotation2.java"                                                                 
public interface com.hncboy.corejava.annotation.TestAnnotation2 extends java.lang.annotation.Annotation {}

虽然本质上都是继承 Annotation 接口,但即使接口可以实现多继承,注解的定义仍然无法使用继承关键字来实现。

通过 @interface 定义注解后,该注解也不能继承其他的注解或接口,注解是不支持继承的,如下代码就会报错。

public @interface TestAnnotation1 {
}
/** 错误的定义,注解不能继承注解 */
@interface TestAnnotation2 extends TestAnnotation1 {
}
/** 错误的定义,注解不能继承接口 */
@interface TestAnnotation3 extends Annotation {
}

虽然注解不支持继承其他注解或接口,但可以使用组合注解的方式来解决这个问题。如 @SpringBootApplication 就采用了组合注解的方式。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    
}

3.2 注解的架构

​在这里插入图片描述
注解的基本架构如图所示,先简单了解下该架构,后面会详细讲解。
该架构的左半部分为基本注解的组成,一个基本的注解包含了 @interface 以及 ElementType 和 RententionPolicy 这两个枚举类。
Annotation 和 ElementType 是一对多的关系
Annotation 和 RetentionPolicy 是一对一的关系
该架构的右半部分为 JDK 部分内置的标准注解及元注解。
标准注解:@Override、@Deprecated 等
元注解:@Documented、@Retention、@Target、@Inherited 等

3.3 注解的属性

注解的属性也称为成员变量,注解只有成员变量,没有方法。注解的成员变量在注解的定义中以“无形参的方法”形式来声明,其方法名定义了该成员变量的名字,其返回值定义了该成员变量的类型。

注解内的可使用的数据类型是有限制的,类型如下:

所有的基本类型(int,float,boolean 等)

  • String
  • Class
  • enum(@Retention 中属性的类型为枚举)
  • Annotation
  • 以上类型的数组(@Target
    中属性类型为枚举类型的数组)

编译器对属性的默认值也有约束。首先,属性不能有不确定的的值。也就是说,属性要么具有默认值,要么在使用注解时提供属性的值。对于非基本类型的属性,无论是在源代码中声明时,或是在注解接口中定义默认值时,都不能使用 null 为其值。因此,为了绕开这个约束,我们需要自己定义一些特殊的值,例如空字符串或负数,来表示某个属性不存在。

通过一个案例来演示下注解可使用的数据类型及默认值。

@interface Reference {
    boolean contain() default false;
}
​
enum Week {
    Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
}
​
public @interface TestAnnotation {
​
    /**
     * int 基本数据类型
     * @return
     */
    int type() default -1;
​
    /**
     * boolean 基本数据类型
     * @return
     */
    boolean status() default false;
​
    /**
     * String 类型
     * @return
     */
    String name() default "";
​
    /**
     * Class 类型
     * @return
     */
    Class<?> loadClass() default String.class;
​
    /**
     * 枚举类型
     * @return
     */
    Week today() default Week.Sunday;
​
    /**
     * 注解类型
     * @return
     */
    Reference reference() default @Reference(contain = true);
​
    /**
     * 枚举数组类型
     * @return
     */
    Week[] value();
}

四、组成

我们已经了解了注解的架构,先来定义一个简单的注解。

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

4.1 ElementType

ElementType 枚举类型的常量为 Java 程序中可能出现注解的声明位置提供了简单的分类。这些常量用于 @Target 注解中。@Target 用于描述注解适用的范围,即注解能修饰的对象范围,通过 ElementType 的枚举常量表示。

先来看下 ElementType 该枚举类的代码。

public enum ElementType {
    
    /**
     * 用于描述类、接口(包括注解类型)、枚举的定义
     */
    TYPE,
​
    /**
     * 用于描述成员变量、对象、属性(包括枚举常量)
     */
    FIELD,
​
    /**
     * 用户描述方法
     */
    METHOD,
​
    /**
     * 用于描述参数
     */
    PARAMETER,
​
    /**
     * 用于描述构造器
     */
    CONSTRUCTOR,
​
    /**
     * 用于描述局部变量
     */
    LOCAL_VARIABLE,
​
    /**
     * 用于描述注解的(元注解)
     */
    ANNOTATION_TYPE,
​
    /**
     * 用于描述包
     */
    PACKAGE,
​
    /*
     * 表示该注解能写在类型变量的声明语句中
     * @since 1.8
     */
    TYPE_PARAMETER,
​
    /**
     * 表示该注解能写在使用类型的任何语句中(声明语句、泛型和强制转换语句中的类型)
     * @since 1.8
     */
    TYPE_USE
}

因为 Annotation 和 ElementType 是一对多的关系,所以 @Target 中可以存放数组,表示多个范围,默认所有范围。

JDK8 之前,注解只能用于声明的地方,JDK8 中添加了 TYPE_PARAMETER 和 TYPE_USE 类型注解,可以应用于所有地方:泛型、父类、接口,异常、局部变量等。举个例子,定义一个 @AnyWhere 注解,Boy 接口和 Test 类。

@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface AnyWhere {
}
​
public interface Boy {
}
​
public class Test<@AnyWhere T> extends @AnyWhere Object implements @AnyWhere Boy {
​
    private @AnyWhere T test1(@AnyWhere T t) throws @AnyWhere Exception {
        return t;
    }
    
    private void test2() {
        Test<Integer> test = new @AnyWhere Test<>();
        @AnyWhere List<@AnyWhere Integer> list = new ArrayList<>();
    }
}

4.2 RetentionPolicy

RetentionPolicy 枚举类型的常量用于保留注解的各种策略,即该注解的有效期。它们与 @Retention 注解类型一起使用,以指定保留注解的时间。RetentionPolicy 枚举的代码如下。

public enum RetentionPolicy {
    /**
     * 表示该注解只存在于源码阶段,
     */
    SOURCE,
​
    /**
     * 表示该注解存在于源码阶段和编译后的字节码文件里
     */
    CLASS,
​
    /**
     * 表示该注解存在于源码阶段、编译后的字节码文件和运行时期,且注解的内容将会被 JVM 解释执行
     * 该范围的注解可通过反射获取到
     */
    RUNTIME
}

Annotation 和 RetentionPolicy 是一对一的关系,即每个注解只能有一种保留策略。

这三个枚举值是有等级关系的,SOURCE < CLASS < RUNTIME,即 RUNTIME 的有效范围是最大的,其次的是 CLASS,最小的范围是 SOURCE,默认的保留范围为 CLASS。

RUNTIME 范围使用于在运行期间通过反射的方式去获取注解。

CLASS 适用于编译时进行一些预处理操作。

SOURCE 适用于一些检查性的工作,或者生成一些辅助的代码,如 @Override 检查重写的方法,Lombok 中的 @Date、@Getter、@Setter 注解。

4.3 注解与反射

通过前面我们了解到,注解本质上继承 Annotation 接口,也就是说,Annotation 接口是所有注解的父接口。@Retention 的保留策略为 RetentionPolicy.RUNTIME 的情况下,我们可以通过反射获取注解的相关信息。Java 在 java.lang.reflect 包下也提供了对注解支持的接口。
在这里插入图片描述

主要来了解下 AnnotationElement 这个接口,其他接口都为该接口的子接口。该接口的对象代表 JVM 运行期间使用注解的类型(Class,Method,Field 等)。该包下的 Constructor 类、Method 类、Package 类和 Class 类等都实现了该接口。简单了解下该接口的部分函数。

public interface AnnotatedElement {
    /**
     * default 方法是 Java8 新增的
     * 如果指定类型的注解存在该类型上,则返回 true,否则返回 false。此方法的主要目的是方便访问一些已知的注解
     *
     * @param annotationClass 该泛型参数表示所有继承了Annotation 接口的接口,也就是注解
     * @return 返回该类型上是否有指定的注解
     */
    default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
        return getAnnotation(annotationClass) != null;
    }
    
    /**
     * 根据注解的 Class 查询注解
     */
    <T extends Annotation> T getAnnotation(Class<T> annotationClass);
    
    /**
     * 返回该类型上的所有注解,包含继承的
     */
    Annotation[] getAnnotations();
    
    /**
     * 返回该类型上的所有注解,不包含继承的
     */
    Annotation[] getDeclaredAnnotations();
}

我们使用代码来测试下反射获取注解。定义两个注解,一个保留策略为 RetentionPolicy.RUNTIME,另一个为 RetentionPolicy.CLASS。创建 TestAnnotation 类测试注解,该类上使用了这两个注解。

@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation1 {
    String status() default "hncboy";
}
​
@Retention(RetentionPolicy.CLASS)
public @interface TestAnnotation2 {
    String value() default "hncboy";
}
​
@TestAnnotation1(status = "hncboy2")
@TestAnnotation2("hncboy2")
public class TestAnnotation {
​
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz = Class.forName("com.hncboy.corejava.annotation.TestAnnotation");
        // 获取该类的所有注解
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation.annotationType());
            System.out.println(annotation.toString());
        }
    }
}

输出结果如下,可见 TestAnnotation2 注解没有输出,因为 TestAnnotation2 注解类型是 RetentionPolicy.CLASS 的,所以用反射方法获取不到。这里还涉及到了注解的一个快捷方法,就是当注解里的属性名字定义为 value 时,可以在使用该注解时不指定属性名,上面的 @Target 注解和 @Retention 注解都属于这种情况,不过当注解里有多个属性时,那就必须指定属性名了。

interface com.hncboy.corejava.annotation.TestAnnotation1
@com.hncboy.corejava.annotation.TestAnnotation1()(status=hncboy2)

五、元注解

元注解即注解的注解且只能作用于注解上的注解,也就是说元注解负责其他注解的注解,而且只能用在注解上面。

JDK8 以前内置的元注解有 @Documented、@Retention、@Target、@Inherited 这四个,JDK 8 引入了 @Repeatable, 前面已经了解过了 @Target 和 @Retention,下面做一些简单的补充。

元注解的 @Target 都为 ElementType.ANNOTATION_TYPE,因为元注解只能应用于注解的注解。元注解在定义该注解的同时也可以直接使用该注解。

5.1 @Target
该注解用于定义注解能使用的范围,取值为 ElementType 枚举。

复制代码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * 返回可以应用注解类型的各种范围的枚举数组
     * 名字为 value 时可以省略属性名
     * @return
     */
    ElementType[] value();
}
复制代码

使用方式:

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

5.2 @Retention

该注解定义注解的保留策略或者说定义注解的有效期,取值范围为 RetationPolicy 枚举。

复制代码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * 返回保留策略
     * @return
     */
    RetentionPolicy value();
}
复制代码

使用方式:

@Retention(RetentionPolicy.RUNTIME)
@Retention(value = RetentionPolicy.RUNTIME)

5.3 @Documented

该注解的使用表示是否包含在生成的 javadoc 文档中。

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

举个例子,定义一个 @TestAnnotation 注解和 Test 类。

复制代码
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
public @interface TestAnnotation {

}

@TestAnnotation
public class Test {

}
复制代码

通过 javadoc -d doc *.java 命令将该目录下的这两个类生成文档并放在 doc 目录下。生成的文件如下,点击 index.html。
在这里插入图片描述​
看到如图所示的样子,Test 类中包含 @TestAnnotation。
在这里插入图片描述
我们再把 @TestAnnotation 注解上的 @Documenet 注解注释掉再来生成下文档。此时发现 Test 类中没有 @TestAnnotation 注解了。
在这里插入图片描述

5.4 @Inherited

该注解表示注解是否具有继承的特性。

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

举个例子来测试下。新建 TestAnnotation 注解,Father 类,Son 类,Father 类使用了该注解,Son 类继承 Father 类。

复制代码
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface TestAnnotation {
}

@TestAnnotation
public class Father {
}

public class Son extends Father {
}
复制代码

新建一个测试类,测试 Father 和 Son 这两个类是否包这两个注解。

复制代码
public class Test {

    public static void main(String[] args) {
        System.out.println(Father.class.isAnnotationPresent(TestAnnotation.class));
        System.out.println(Son.class.isAnnotationPresent(TestAnnotation.class));
    }
}
复制代码

输出为 true true,当把 @TestAnnotation 注解上的 @Inherited 注解注释掉时,输出 true false,如此可见该注解的作用。

5.5 @Repeatable

JDK8 以前是不支持重复注解的,同一个地方只能使用同一个注解一次。 该注解从 JDK8 引入,该注解类型用于表示其声明注解的注解类型为可重复时。 value() 的值表示可重复注解的类型,包含注解类型。

复制代码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    /**
     * 指可重复注解的类型,包含注解类型
     * @return
     */
    Class<? extends Annotation> value();
}
复制代码

举个例子,定义 @Activity 和 @Activities 注解,定义 Hncboy 类测试重复注解。@Activity 注解被 @Repeatable(Activities.class) 注解,@Activities 相当于一个容器注解,属性为 Activity 类型的数组,通过这样的方式,使得 @Activity 注解可以被重复使用。

复制代码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Activities {
    Activity[] value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Activities.class)
public @interface Activity {
    String value();
}

@Activity("打代码")
@Activity("吃饭")
@Activity("睡觉")
public class Hncboy {
}

@Activities({@Activity("打代码"), @Activity("吃饭"), @Activity("睡觉")})
public class Hncboy {
}
复制代码

六、标准注解

JDK 内置的注解有 @Deprecated、@Override、@SuppressWarnnings、@SafeVarargs(JDK 7 引入)、@FunctionalInterface(JDK 引入)等。接下来介绍下 3 中常用的内置注解。

6.1 @Deprecated

注解为 @Deprecated 的类型是不鼓励程序员使用的元素,通常是因为这样做很危险,或者是因为存在更好的替代方法。当在不推荐使用的代码中使用或覆盖不推荐使用的程序元素时,编译器会发出警告。该注解可以用来修饰构造器、字段、局部变量、方法等类型。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

举个例子,使用 @Deprecated 修饰的元素是不推荐使用的,编译器会帮我们将这些类和方法用删除线标记。直接声明在包上会报 Package annotations should be in file package-info.java 错误。

复制代码
@Deprecated
public class TestDeprecated {

    @Deprecated
    String s = "hncboy";

    @Deprecated
    public void test() {
    }
}
复制代码
​

​

6.2 @Override

@Override 注解我们经常用到,提示子类需要重写父类的方法。方法重写或实现了在父类中声明的方法时需要加上该注解,该注解用于编译器检查重写的操作是否正确,保留策略为 RetentionPolicy.SOURCE。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

6.3 @SuppressWarnings

用来关闭编译器生成警告信息,可以用来修饰类、方法、成员变量等,在使用该注解时,应采用就近原则,如方法产生警告是,应该针对方法声明该注解,而不是对类声明,有利于发现该类的其他警告信息。

复制代码
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    /**
     * 带有注解的元素中的编译器将禁止的警告集。
     * 使用 unchecked 忽略无法识别的警告
     */
    String[] value();
}
复制代码

举个例子,rawtypes 用于使用泛型时忽略没有指定相应的类型,unused 用于没有使用过的代码。

复制代码
public class Test {

    @SuppressWarnings({"rawtypes", "unused"})
    private List test() {
        return new ArrayList();
    }
}
复制代码

七、自定义注解

自定义注解实现 Spring IOC Bean 实例创建,自定义简单的注解: @Component、@Bean 和 @ComponentScan。

通过什么是反射?这篇文章我们已经学习到通过反射实现 Spring IOC Bean 实例的三种创建方式,不清楚的可以去看下那篇文章。

7.1 新建 @MyComponent、@MyBean、 @MyComponentScan

复制代码
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyBean {

    String value() default "";
}

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

    String value() default "";
}

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

    String value() default "";
}
复制代码

7.2 新建 A、B、C 三个类

复制代码
@MyComponent(“a”)
public class A {

public A() {
    System.out.println("调用 A 的无参构造器");
}

@MyBean("b")
public static B createBInstance() {
    System.out.println("调用 A 的静态方法 createBInstance");
    return new B();
}

@MyBean("c")
public C createCInstance() {
    System.out.println("调用 A 的实例方法 createCInstance");
    return new C();
}

}

class B {}
class C {}
复制代码
7.3 新建 IOCContainer 类
复制代码
/**

  • 定义 map 存放 bean
    */
    public class IOCContainer {

    private static HashMap<String, Object> container = new HashMap<>();

    public static void putBean(String id, Object object) {
    container.put(id, object);
    }

    public static Object getBean(String id) {
    return container.get(id);
    }
    }
    复制代码
    7.4 新建 Test 类
    先获取 @MyComponentScan 注解中的包名

然后扫描该包下所有类的全限定名

遍历类名,判断改类是否实现 @MyComponent 注解

遍历方法,判断该方法是否实现 @MyBean 注解

大致过程是这样,具体的可以见代码的注释。

复制代码
@MyComponentScan(“com.hncboy.corejava.annotation.spring”)
public class Test {

public static void main(String[] args) throws Exception {
    Test test = new Test();
    // 获取 MyComponentScan 注解中的包名
    String scanPackage = test.getScanPackage();

    HashSet<String> classPathSet = new HashSet<>();
    // 扫描包下的所有类并将类的全限定名放进 classPathSet
    test.doScanPackage(classPathSet, scanPackage);

    // 遍历扫描包下的所有类
    for (String className : classPathSet) {
        // 通过类的全限定名获取 Class
        Class<?> clazz = Class.forName(className);
        // 判断该类是否实现了 MyComponent 注解
        if (clazz.isAnnotationPresent(MyComponent.class)) {
            // 方式1:通过构造器实例化
            IOCContainer.putBean(className, clazz.newInstance());
        }

        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            // 判断方法是否有 MyBean 注解
            if (method.isAnnotationPresent(MyBean.class)) {
                // 获取 bean 值
                String beanName = method.getAnnotation(MyBean.class).value();
                // 判断该方法是否是静态方法或实例方法
                if (Modifier.isStatic(method.getModifiers())) {
                    // 方式2:通过静态工厂实例化
                    IOCContainer.putBean(beanName, method.invoke(null));
                } else {
                    // 方式3:通过实例工厂实例化
                    // 首先获取该类的实例对象,再调用实例方法进行实例化
                    IOCContainer.putBean(beanName, method.invoke(IOCContainer.getBean(className)));
                }
            }
        }
    }
}

/**
 * 获取 MyComponentScan 注解中的包名
 *
 * @return
 */
private String getScanPackage() {
    Class<?> clazz = this.getClass();
    if (!clazz.isAnnotationPresent(MyComponentScan.class)) {
        return "";
    }
    MyComponentScan scanPackage = clazz.getDeclaredAnnotation(MyComponentScan.class);
    return scanPackage.value();
}

/**
 * 扫描该包下的类
 *
 * @param classPathSet
 * @param scanPackage
 */
private void doScanPackage(HashSet<String> classPathSet, String scanPackage) {
    // 通过正则表达式将包名中的 . 替代为 /,并获取到该路径的 class url
    URL url = this.getClass().getResource("/" + scanPackage.replaceAll("\\.", "/"));
    // 获取该 url 下的所有 File(目录/文件)
    File classDir = new File(url.getFile());
    // 遍历所有 File
    for (File file : classDir.listFiles()) {
        // 判断该 file 如果是目录的话
        if (file.isDirectory()) {
            // 拼接该目录的名字并递归遍历该目录
            doScanPackage(classPathSet, scanPackage + "." + file.getName());
        } else {
            // 如果文件不是以 .class 结尾
            if (!file.getName().endsWith(".class")) {
                continue;
            }

            // 通过 包名+目录名+除去.class的类名 拼接该类的全限定名
            String clazzName = (scanPackage + "." + file.getName().replace(".class", ""));
            // 将该类的全限定名放入 classPathSet
            classPathSet.add(clazzName);
        }
    }
}

}
复制代码
输出如下:

调用 A 的无参构造器
调用 A 的静态方法 createBInstance
调用 A 的实例方法 createCInstance

注:APT——这些处理提取和处理 Annotation 的代码统称为 APT(Annotation Processing Tool)。

注解的定义和使用 注解(Annotation):不是程序本身,可以对程序作出解释和comment类似,一般以@开头,可以使用在package、class、method、field上面,作为辅助信息,可以通过反射获得注解反射获取注解时,返回的是Java运行时生成的动态代理对象,代理对象会最终调用invoke方法激活注解注解本质是一个继承了Annotation的特殊接口,其具体实现类是Java运行时生成的动态代理类作用:1、实现替代配置文件功能,依赖注入,跟数据库有关2、在编译时进行格式检查。...... 阅读详情

相关推荐

注解:认识注解、注解的分类、注解的生命周期、自定义注解及反射调用、为注解添加属性

-------android培训、Java培训、期待与您交流!------- 1  认识注解(Annotation) 注解相当于一种标记,在程序中加了注解就等于为程序打上了某种标记,没加,则等于没有某种标记。 以后,javac编译器、开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记,看你有什么标记,就去干相应的事。 注解可以加在包,类,字段,方法,方法的参数以及

Rockray 6533

注解(注解的概念、注解的分类、自定义注解、注解的原理)

注解(注解的概念、注解的分类、自定义注解、注解的原理)

H215919719的博客 1万+

java注解的用法&元注解(注解上的注解)取值说明

在Java中,元注解(Meta-Annotations)是用于注解其他注解的特殊注解。它们用于提供关于注解的额外信息,比如注解的作用范围、生命周期等。Java提供了几个常见的元注解: @Retention @Target @Documented @Inherited @Repeatable

zfj321的博客 909

@Reference注解说明

@Reference注解说明

weixin_43185154的博客 8286

秒懂,Java 注解 (Annotation)你可以这样学

文章开头先引入一处图片。 这处图片引自老罗的博客。为了避免不必要的麻烦,首先声明我个人比较尊敬老罗的。至于为什么放这张图,自然是为本篇博文服务,接下来我自会说明。好了,可以开始今天的博文了。 Annotation 中文译过来就是注解、标释的意思,在 Java 中注解是一个很重要的知识点,但经常还是有点让新手不容易理解。 我个人认为,比较糟糕的技术文档主要特征之一就是:用专业名词来...

frank 的专栏 27万+

Ubuntu1804 关于ubuntu18.04下载软件仓库信息失败,请检查网络连接 的解决方案

今天电脑在更换软件源的时候遇到了这个问题。出现了如上图所示的错误信息。 尝试了各家CSDN的博客之后,发现方法大同小异,均无法解决。 方法大多都是要求更换软件源,如下所示: 打开“Ubuntu软件中心”-->点击“编辑”-->点击“软件源”-->在Ubuntu软件界面,“下载自”默认是“中国的服务器”,改为“主服务器”试试 2.打开更新管理器-》设置-》选择站点-》...

weixin_43729409的博客 1万+

天天用注解,你知道注解到底是怎样实现的吗?

注解,也叫元数据,是一种代码级别的说明。它是JDK1.5引入的一个特性,与类、接口、枚举类所在同一个层次。它可以声明在包、类、方法、成员变量、构造器、局部变量、方法参数等的上面,用来对这些元素进行说明、注释。也可以把注解理解为代码里的特殊标记,这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 1、注解的作用分类 (1)生成文档相关的注释说明:通过代码里标识的注解可以生成文档相关的注释说明。 下面我们就来演示一下,首先我们编

Mr_wxc的博客 1万+

Windows如何使用Anaconda 3进行keras环境的配置

** Windows如何使用Anaconda 3进行keras环境的配置 搭建Keras环境* Anaconda3如何安装keras,主要包括下面三步: 1.安装mingw libpython 2.安装theano 3.安装keras 若你还没有按装anaconda,赶紧下载安装吧! 下载途径有两个 (1)Anaconda版本为Anaconda 4.4.0,对应的python版本为3.6,附上An...

Lance_liangliang的博客 1604

什么是元注解 元注解有哪些 元注解是干什么的 注解用什么修饰

@Retention @Document @Target @Inherited @Repeatable 类型注解(Type Annotation) 怎么用 ,元注解怎么用

weixin_57604284的博客 7972

论文理解【LLM-OR】——【OptMATH】A Scalable Bidirectional Data Synthesis Framework for Optimization Modeling

本文提出 LLM-OR 领域的双向数据合成框架 OptMATH,从已有 MF/PD 出发反向生成 NL,再使用 AutoFormulator 进行正向建模,通过最优值匹配 rejection sampling 确保语义一致性。实现了难度可控的语义一致数据合成

佚失的诗篇 503

qmc5883p芯片坐标系方向定义

问题 最近一个项目用到qmc5883p, 然而确定磁力计方向的时候发现datasheet上写的不是很清楚, 并且example中还有一个设置方向的一步, 于是测试了芯片坐标方向并记录了下来; 该芯片和qmc5883L方向并不一致; 结果 qmc5883P的datasheet给出来如下说明, Y为笔者添加的; 但是这个方向是按照datasheet的example设置的结果: //Define the sign for X Y and Z axis qmc5883p_write_reg(0x2

时有限 4124

注解以及如何利用反射获取注解

什么是注解 1.Annotation是从JDK5.0开始引入的新技术 2.Annotation的作用 : (1)不是程序本身,可以对程序作出解释(这一点和注释(comment)没什么区别) (2)可以被其他程序(比如:编译器等)读取 3.Annotation的格式: 注解是以"@注释名"在代码中存在的,还可以添加一-些参数值,例如:@SuppressWarnings(value="unchecked") 4.Annotation在哪里使用? 可以附加在package , class , method ,

qq_42500503的博客 7996

无网络环境部署:手动获取并安装OneNote for Windows 10完整指南

本文提供了一份详尽的OneNote for Windows 10离线安装指南。针对无网络或内网隔离环境,详细介绍了如何从官方渠道获取正确的产品ID,利用第三方工具下载纯净的.appxbundle安装包,并解决系统兼容性与依赖框架问题。最后,通过PowerShell管理员命令完成安全部署,是IT管理员和高级用户在离线环境下部署UWP应用的实用参考。

loss4bartender的博客 499

注解及Spring系列注解

1.定义:使用@interface2.定义属性:类名+名字()3.赋默认值:default + 默认值4.修饰:使用需要的元注解注解为代码提供元数据,用于标记、约束、文档化和框架集成,可被编译器或运行时处理。熟练运用注解,可以提高开发的效率。

m0_75014903的博客 1130

Android13 CarPowerManagementService启动流程分析

在CarPowerManagementService中init调用PowerHalService的setListener设置事件侦听器以接收车辆的电源事件。

liuning1985622的博客 960

Windows 11 部署 Docker Desktop:从 WSL 报错到服务配置的完整排障实录

本文详细记录了在Windows 11上部署Docker Desktop时遇到的WSL报错问题及完整解决方案。从Hyper-V配置、BIOS设置到系统服务检查,提供了一系列实用命令和排查步骤,帮助开发者快速解决'Unexpecter WSL error'等常见问题,实现Docker与WSL2的稳定运行。

weixin_30687051的博客 123

JAVA中的注解:注解的作用+注解的类型(内置注解、元注解、自定义注解)+注解的实现

本文主要介绍JAVA中的注解,包括什么是注解、注解的作用以及注解的三大类型,内置注解、元注解、自定义注解,另外还介绍了一个注解的实现的小例子

a289246的博客 1169

从零开始学习PX4源码23(飞行模式管理)

本文摘要主要介绍了PX4飞控系统中飞行模式管理模块的代码实现流程。文章从整体架构入手,分析了飞行模式管理模块的启动过程、类继承关系以及核心运行机制。重点阐述了模块从rc.mc_apps启动脚本到FlightModeManager::main()的调用链路,包括任务创建、工作队列初始化和主循环执行流程。核心部分解释了Run()函数如何通过订阅传感器数据、更新参数、处理命令以及生成轨迹设定点来实现飞行模式切换和任务管理功能。文章为理解PX4飞行控制系统的模式切换机制提供了代码层面的详细分析。

陌城烟雨 502

什么是注解,注解怎么用

注释: 对程序进行解释说明的文字,给人看的 什么是注解? Annotation JDK1.5推出的新特性 可能给类增加额外的信息 注解可以保存一些简单的数据 注解的作用: 编写文档:通过代码里标识的注解生成文档【生成文档doc文档】 编译检查:通过代码里标识的注解让编译器能够实现基本的编译检查【Override】 代码分析:通过代码里标识的注解对代码进行分析【使用反射】 今天学注解...

itzhuzhu的博客 1500

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Java关于注解的使用、如何自定义注解、如何通过元注解解析注解

注解属性,其实本质上是抽象方法。但是我们按照属性来理解容易理解,因为到时候使用注解的时候,需要用=为其赋值。public @interface 注解名{XXXXXXX定义属性:增强注解的作用数据类型 属性名():此属性没有默认值,需要在使用注解的时候为其赋值。数据类型 属性名() default 值:此属性有默认值,如果有需要,还可以二次赋值。注解中能定义8种基本类型:String类型、class类型、枚举类型、注解类型、以及以上类型的一维数组。//品牌//车零件//价格//数量。

weixin_45797022的博客 1533

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Java注解以及自定义注解

Java注解以及自定义注解

YIYIYI 1969

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

注解与元注解

1.引用数据类型:类 数组 接口 枚举 注解1.jdk1.5版本的新特性->一个引用数据类型和类,接口,枚举是同一个层次的引用数据类型:类 数组 接口 枚举 注解2.作用:说明:对代码进行说明,生成doc文档(API文档)检查:检查代码是否符合条件 @Override(会用) @FunctionalInterface分析:对代码进行分析,起到了代替配置文件的作用(会用)3.JDK中的注解:@Override -> 检测此方法是否为重写方法。

qq_54100648的博客 1252

Java注解合并,注解继承

注解的继承性回顾根据注解继承的特性,我们再做AOP切面拦截的时候会遇到拦截不到的问题,今天我们就讲解下对这些特殊情况如何解决,对源码不做过渡深入的讲解。

LoveSummer 1万+

java注解(一):什么是注解?什么是元注解?如何自定义注解?注解的原理是什么?

本篇文章主要是介绍注解的概念、原理,以及通过代码演示4种元注解、如何自定义注解。通过反编译的形式进一步认识注解的本质。

rainingCSDN的博客 2027

注解与反射 01:注解的相关概念,内置注解,元注解,自定义注解,以及在 Java 中如何使用注解

本文主要讲述注解相关内容,包括注解的相关概念,内置注解,元注解,自定义注解,以及在 Java 中如何使用注解。

积累,沉淀,温故而知新 992

@reference注解_什么是注解?

一、概念Java 注解是在 JDK5 时引入的新特性,注解(也被称为元数据)为我们在代码中添加信息提供了一种形式化的方法,使我们可以在稍后某个时刻非常方便地使用这些数据。注解类型定义指定了一种新的类型,一种特殊的接口类型。 在关键词 interface 前加 @ 符号也就是用 @interface 来区分注解的定义和普通的接口声明。目前大部分框架(如 Spring Boot 等)都通过使用注解简化...

weixin_39727976的博客 3073
上一篇: Spring的核心是什么?
下一篇: HandlerInterceptor拦截器
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值