有关Java中的注解和反射

学习目标

● 了解注解相关
● 掌握元注解
● 了解反射概念
● 掌握反射常用的方法

1.注解

1.1 概念

● Java注解又称Java标注，是在 JDK5 时引入的新特性，注解（也被称为元数据）。
● Java注解它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。
● Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能

● 总结: 注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
● 注解不是程序的一部分，可以理解为注解就是一个标签，程序可以通过这个标签来获取信息，或者执行动作。

1.2 作用

● 编写文档：生成文档这是最常见的，也是java 最早提供的注解;
● 编译检查：在编译时进行格式检查，如@Override放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出；为我们的代码提供了一种规范制约，避免我们后续在代码中处理太多的代码以及功能的规范。
● 较少配置: 跟踪代码依赖性，实现替代配置文件功能，比较常见的是后期的基于注解配置,作用就是减少配置;
● 代码分析：在反射的 Class, Method, Field 等函数中，有许多于 Annotation 相关的接口,可以在反射中解析并使用 Annotation。

1.3 注解分类

1. Java自带的标准注解，包括@Override、@Deprecated、@SuppressWarning等，使用这些注解后编译器就会进行检查。
   ● @Override：检测被该注解标注的方法是否是继承自父类(接口)的
   ● @Deprecated：该注解标注的内容，表示已过时
   ● @SuppressWarnings：压制警告，一般传递参数all @SuppressWarnings(“all”)
   ● @FunctionalInterface: 函数式接口。用来修饰接口。标识接口有且只有1个抽象方法，但是可以有多个非抽象的 方法。

2. 元注解
   ● 元注解是用于定义注解的注解，包括@Retention、@Target、@Inherited、@Documented 等。
   ● 元注解也是Java自带的标准注解，只不过用于修饰注解，比较特殊。

3. 自定义注解
   ● 用户可以根据自己的需求定义注解。

1.4 元注解

● 元注解是Java API提供的，是用于修饰注解的注解，通常用在注解的定义上
● 没有元注解解释说明注解，自定义的注解没有任何意义的。通过合理使用元注解，可以精确控制自定义注解的行为和适用范围

以下是Java元注解（用于修饰其他注解的注解）的总结表格，涵盖核心作用、可选值及使用场景：

补充说明

1. @Target：若未指定，默认支持所有目标类型。

2. @Retention：默认值为RetentionPolicy.CLASS，但常用RUNTIME以实现动态处理（如反射）。

3. 组合使用：多个元注解可同时修饰一个注解，例如：

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

4. @Inherited限制：仅对类级注解有效，接口或方法上的注解无法被继承。

1.4 自定义注解

1.4.1 语法

● 在开发中，满足具体的业务需求。
● 当我们了解了内置注解, 元注解和反射后，我们便可以开始自定义以及使用注解了。
● 创建自定义注解和创建一个接口相似，但是注解的interface关键字需要以@符号开头，我们可以为注解声明方法

//语法
[public]  @interface  注解名称{//大写驼峰
    //有很多参数
    属性数据类型  属性名1() [default  默认数据];
    属性数据类型  属性名2() [default  默认数据];
  
    //属性名称要唯一
}

1.4.2 属性类型

在注解里面 可以使用哪些数据类型作为属性的数据类型?

1. 基本数据类型 4类八种
2. String
3. 枚举类型
4. Class
5. 以上类型的数组类型 int[] String[] Class[] DayOfWeek[]

1.4.3 属性值

● 定义了属性，在使用时需要给属性赋值:
● 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
● 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接输入值即可。
● 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略。

1.5.4 创建注解

//使用注解 注解里面有且只有1个参数  并且参数名就是value 可以省略参数名
//@Target(value = {ElementType.TYPE, ElementType.METHOD})
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation {

    //参数
    int id();

    String name();

    String[] hobby();

    DayOfWeek day() default DayOfWeek.MONDAY;

    Class<?> clazz() default Object.class;
    
}

1.5 使用注解

• 在哪里使用，要看注解上的元注解@Target

@MyAnnotation(id = 1001, name = "张三", hobby = {"code", "music"}, clazz = Student.class)
public class Student {


    @MyAnnotation(id = 1002, name = "李四", day = DayOfWeek.SUNDAY)
    public void info() {

    }
}

2.反射

2.1 基本概念

● Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。
● 核心功能: 动态获取信息以及动态调用对象方法.

● Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。这种“看透class”的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

2.2 优缺点

补充说明

• 性能优化建议：对高频调用的反射代码可缓存Class或Method对象，减少重复解析开销。
• 安全实践：限制反射权限（如通过安全策略文件），避免滥用导致的安全漏洞。
• 框架中的应用：Spring通过反射实现依赖注入（如@Autowired），动态代理（AOP）则结合反射和字节码增强技术。

● Java程序的运行过程： .java源文件 --> 经过编译器 编译成 .class（字节码文件，是一个二进制文件） ->被类加载器加载到 JVM内存（加载到方法区）,在Java中万事万物皆对象，那么字节码文件对应的也有一个对象，这个对象是Class类{模板 属性，方法 }的对象。把这个类对象放大来看，里面的每一个组成成分都是对象 属性对象（Filed类型） 方法对象（Method类型） 构造器对象（Constructor类型）
● 要想解剖一个类，必须先要获取到该类的Class对象。而剖析一个类或用反射解决具体的问题就要使用如下相关API：
○ java.lang.Class；
○ java.lang.reflect. *；

2.3 获取类对象

1. 类型名.class，要求编译期间已知类型 .
2. 对象.getClass()，获取对象的运行时类型.
3. Class.forName(类型全名称)，可以获取编译期间未知的类型

  /**
     * 1,获取 类对象
     */
    public static void method1() throws ClassNotFoundException {
        //1,类名.class
        Class<UserInfo> stuClass = UserInfo.class;
        //2 对象名.getClass
        UserInfo user = new UserInfo();
        Class<? extends UserInfo> aClass = user.getClass();
        // 3, Class.forName(类的全路径) 最常用
        Class<?> aClass1 = Class.forName("com.java.reflect.UserInfo");
        System.out.println(stuClass == aClass);
        System.out.println(aClass == aClass1);
    }

2.4 Class常用方法

● 反射相关的API在java.lang包和java.lang.reflect包。

2.5 Field常用方法

• 获取属性信息

2.6 Method常用方法

• 获取方法对象

2.7 Constructor常用方法

• 获取构造器 创建实例

2.8 基本操作

2.8.1 操作属性

   private static void demo4() throws Exception {
       // SysUser sysUser = new SysUser().setUsername("张三");
        Class<SysUser> sysUserClass = SysUser.class;
        //对属性取值/赋值
        //public修饰的属性
       Field[] fields = sysUserClass.getFields();
        System.out.println(Arrays.toString(fields));

        //获得类中所有的属性
        fields = sysUserClass.getDeclaredFields();
        System.out.println(Arrays.toString(fields));

        Field field = sysUserClass.getDeclaredField("username");
        //Object get(Object obj)
        field.setAccessible(true);//属性private修饰 默认无法访问 需要开启权限
        Object name = field.get(sysUser);
        System.out.println(name);

        field.set(sysUser, "李四");
        System.out.println(field.getName());
        System.out.println(field.getType());
        System.out.println(field.getModifiers());
        System.out.println(sysUser.getUsername());
    }

2.8.2 操作方法

private static void demo5() throws Exception {
    Class<SysUser> sysUserClass = SysUser.class;
    SysUser sysUser = new SysUser();
    //反射操作方法----->执行方法体逻辑
    //本类/父级public
    Method[] methods = sysUserClass.getMethods();
    System.out.println(Arrays.toString(methods));

    //本类中声明的所有的方法
    methods = sysUserClass.getDeclaredMethods();
    System.out.println(Arrays.toString(methods));

    //执行b方法的方法体逻辑
    Method method = sysUserClass.getMethod("b", String.class, int.class);
    method.setAccessible(true);
    Object returnValue = method.invoke(sysUser, "hello", 200);
    System.out.println("returnValue:"+returnValue);
}

2.8.3 操作构造

private static void test3() {
    Class<SysUser> sysUserClass = SysUser.class;
    //SysUser sysUser = sysUserClass.newInstance();

    //获得类中public修饰的构造方法
    Constructor<?>[] constructors = sysUserClass.getConstructors();
    System.out.println(Arrays.toString(constructors));

    //获得类中声明的所有构造方法
    constructors = sysUserClass.getDeclaredConstructors();
    System.out.println(Arrays.toString(constructors));

    //创建对象
    //获得一个构造
    try {
            Constructor<SysUser> constructor = sysUserClass.getDeclaredConstructor(int.class, int.class);
            constructor.setAccessible(true);
            SysUser sysUser = constructor.newInstance(1, 2);
            System.out.println(sysUser);
        } catch (NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    SysUser sysUser = sysUserClass.getConstructor().newInstance();

}

2.8.4 操作注解

// @Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
// 前提: 注解参数只有1个 参数名value的时候 value可以省略的
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno {
    //注解的组成部分
    //属性/参数
    //数据类型 属性名称() [default 默认的数据];   看成了抽象方法
    //数据类型： 1. 字面量数据类型(基本+String)  2. 枚举类型  3. Class类型 4. 以上类型的数组类型
    //模拟注册用户
    int id();

    String name();

    double balance() default 100;

    String[] hobby() default {"code", "sleep"};

    Month birthday() default Month.JANUARY;

    Class<?> clazz() default SysUser.class;
}
@MyAnno(id = 1001,name = "张三",birthday = Month.APRIL)
@Setter
@Getter
public class Demo {
    private int num;

    @MyAnno(id=1002,name = "李四",hobby = {"music","game"},clazz = Object.class)
    public void info(){
    }
}
public static void main(String[] args) throws Exception {
        //使用注解: 获得注解里面参数数据
        //程序只要启动，批量的扫描所有的注解，存储的容器中。
        //反射---->Class
        //获得Demo类上的注解  获得注解里面的参数
        Class<Demo> demoClass = Demo.class;
        //RetentionPolicy.RUNTIME
        Annotation[] annotations = demoClass.getAnnotations();
        System.out.println(Arrays.toString(annotations));

        annotations =  demoClass.getDeclaredAnnotations();
        System.out.println(Arrays.toString(annotations));*/

        MyAnno annotation = demoClass.getAnnotation(MyAnno.class);
        System.out.println(annotation.id());
        System.out.println(annotation.name());
        System.out.println(Arrays.toString(annotation.hobby()));
        System.out.println(annotation.birthday());
        System.out.println(annotation.balance());
        System.out.println(annotation.clazz());

        Method method = demoClass.getMethod("info");
        MyAnno annotation = method.getAnnotation(MyAnno.class);
        System.out.println(annotation.id());
        System.out.println(annotation.name());
        System.out.println(Arrays.toString(annotation.hobby()));
        System.out.println(annotation.birthday());
        System.out.println(annotation.balance());
        System.out.println(annotation.clazz());
    }