Java注解和反射

文章目录

• 一、注解
• • 1.1 注解入门
  • • 1.1.1 Java注解概述
  • 1.2 内置注解
  • 1.3 自定义注解，元注解
  • • 1.3.1 元注解
    • 1.3.2 自定义注解
• 二、反射
• • 2.1 Java反射机制概述
  • • 2.1.1 静态VS动态语言
    • 2.1.2 反射概述
    • 2.1.3 Java反射优点和缺点
  • 2.2 理解Class类并获取Class实例
  • • 2.2.1 反射相关的主要API
    • 2.2.2 Class类
    • 2.2.3 得到Class类的机种方式
    • 2.2.4 所有类型的Class对象
  • 2.3 类的加载与ClassLoader
  • • 2.3.1 Java内存分析
    • 2.3.2 类的加载过程
    • 2.3.3 类的加载与ClassLoader的理解
    • 2.3.4 分析类初始化
    • 2.3.5 类的加载器
    • 2.3.6 双亲委派机制
  • 2.4 创建运行时类的对象
  • • 获取运行时类的完整结构
    • 动态创建对象执行方法
    • 性能对比分析
    • 获取泛型信息
    • 获取注解信息

---

学习视频来自于：秦疆（遇见狂神说）Bilibili地址
他的自学网站：kuangstudy

唯有热爱，能抵岁月漫长

---

一、注解 1.1 注解入门 1.1.1 Java注解概述

• Annotation是JDK1.5及以后版本引入的新技术。
• Annotation的作用：
  • 不是程序本身，可以对程序作出解释（这一点和注释（comment）没有区别）。
  • 可以被其它程序（编译器等）读取。
• Annotation的格式：
  • @注解名称，还可以添加一些参数值。
  • 例如：@SuppressWarmings（value=“unchecked”）。
• Annotation的使用范围：
  • 它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，相当于给它们添加额外的辅助信息，可以通过反射机制编程实现对这些元数据的访问。

• 作用分类：
  ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
  ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
  ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

1.2 内置注解

• @Override
  定义在java.lang.Override中，此注释只适用于修饰方法，表示一个方法声明打算重写父类中的另一个方法声明。
• @Deprecated
  定义在java.lang.Deprecated中，此注释可以用于修饰方法、属性、类，表示该注解标注的内容，表示已过时，有更好的可以代替。
• @SuppressWarnings
  定义在java.lang.SuppressWarnings中，用来压制警告信息，与前两个注释不同，需要添加一个参数才可以正确使用。
  @SuppressWarnings(“all”)
  @SuppressWarnings(“unchecked”)
  @SuppressWarnings(value={“unchecked”,“deprecation”})
  等等…

1.3 自定义注解，元注解 1.3.1 元注解

• 用于描述注解的注解，java定义了4个标准的meta-annotation类型，他们被用来提供对其它annotation类型作说明。
• 这些类型和它们所支持的类在java.lang.annotation包中可以找到。
  • @Target：描述注解能够作用的范围。
  • @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE
  • @Documented：描述注解是否被抽取到API文档中。
  • @Inherited：描述注解是否被子类继承。

1.3.2 自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口。

• 分析：
  • @interface用来声明一个注释，格式public @interface 注解名 { 定义内容 }。
  • 其中的每一个方法实际上是声明了一个配置参数。
  • 方法的名称就是参数的名称。
  • 返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）。
  • 可以通过default来声明参数的默认值。
  • 如果有一个参数成员，一般参数名为value。
  • 注解元素必须要有值，定义注解元素时，经常使用空字符串，0作为默认值。

自动继承

public interface MyAnno extends java.lang.annotation.Annotation {}

自定义注解代码

// 自定义注解
@Target(value = {ElementType.METHOD})// 使用范围：方法
@Retention(RetentionPolicy.RUNTIME)// 作用域：运行时有效
@Documented // 可以被抽取到API文档中
@Inherited // 可以被子类继承。
@interface MyAnnotation {
    // 注解的参数：参数类型 + 参数名();
    String name() default "";// 需要输入一个String类型，不输入默认空字符串。
    int age() default 0;// 需要输入一个int类型，不输入默认0。
    int id() default -1;// 默认值-1，代表不存在。
    String[] schools();// 需要一个String类型数组
}

二、反射 2.1 Java反射机制概述 2.1.1 静态VS动态语言

动态语言
在运行时可以改变其结构的语言：例如新的函数、对象、代码都可以被引进，已有的函数可以被删除或者其它结构上的变化。
主要动态语言：Object-C、C#、JavaScript、PHP、Python等。
静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言，如Java、C、C++。
Java不是动态语言，但是Java可以称之为“准动态语言”。Java有一定的动态性，可以利用反射机制获得类似动态语言的特性，Java的动态性让编程更加灵活。

2.1.2 反射概述

Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息，并且直接操作任意对象的内部属性及方法。

Class c = Class.forName("java.lang.String")

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类结构信息。我们可以通过这个对象看到类的结构，这个对象就像一个镜子，通过这个镜子看到类的结构，我们形象的称之为：反射。
正常方式：
引入需要的“包类”名称->通过new实例化->取得实例化对象
反射方式：
实例化对象->getClass（）方法->得到完整的“包类”名称

2.1.3 Java反射优点和缺点

优点
可以实现动态创建对象和编译，体现出很大的灵活性。
缺点
对性能有影响，使用反射基本上是一种解释操作，我们可以告诉JVM，希望做什么并且满足我们的要求，这类操作总是慢于直接执行相同操作。

2.2 理解Class类并获取Class实例 2.2.1 反射相关的主要API

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器

2.2.2 Class类

概述
对象照镜子后可以得到一个信息：某个类的属性、方法和构造器，某个类到底实现了哪些接口。
对于每个类而言，JRE都为其保留一个不变的Class类型的对象，一个Class对象包含了特定某个结构的有关信息。

class/interface/enum/annotation/primitive type/void[]

1. Class本身也是一个类。
2. Class对象只能由系统建立对象。
3. 一个加载的类在JVM中只会有一个Class实例。
4. 一个Class对象对应的是一个加载到JVM中的.class文件。
5. 每个类的实例都会记得自己是由哪个Class实例所生成的。
6. 通过Class可以完整地得到一个类中的所有被加载的结构。
7. Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

Class类的常用方法

1. static ClassforName(String name);返回指定类名name的Class对象。
2. Object newInstance();调用缺省构造函数，返回Class对象的一个实例。
3. getName();返回此Class对象所表示的实体类（类、接口、数组类或void）的名称。
4. Class getSuperClass();返回当前Class对象的父类的Class对象。
5. Class[] getinterfaces();获取当前Class对象的接口。
6. ClassLoader getClassLoader();返回该类的类加载器。
7. Constructor[] getConstructors();返回一个包含某些Constructor对象的数组。
8. Method getMothed(String name,Class… T);返回一个Method对象，此对象的形参类型为paramType。
9. Field[] getDeclaredFields();返回Field对象的一个数组。

2.2.3 得到Class类的机种方式

1. Class.forName(“全类名”)：已知一个类的全类名，且该类在类路径下，可以通过Class类的静态方法获取
   * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取，该方法最为安全可靠，程序性能最高
   * 多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
   * 多用于对象的获取字节码的方式
4. 内置基本数据类型可以直接用类名.Type
5. 还可以利用ClassLoader之后讲解
6. 结论：
   同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象

2.2.4 所有类型的Class对象

class：外部类、成员（成员内部类、静态内部类）、局部内部类、匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void：空类型

2.3 类的加载与ClassLoader 2.3.1 Java内存分析

2.3.2 类的加载过程

当程序主动使用某个类时，如果该类还未加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

2.3.3 类的加载与ClassLoader的理解

• 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
• 链接：将Java类的二进制代码合并到JVM的运行状态中的过程。
  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
  • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区进行分配。
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
• 初始化：JVM负责对类进行初始化。
  • 执行类构造器() 方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
  • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

public class Application {
    public static void main(String[] args) throws Exception {
        A a = new A();
        System.out.println(A.m);
        
    }
}
class A{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
    public A(){
        System.out.println("A类的无参构造初始化");
    }
}

执行结果

A类静态代码块初始化
A类的无参构造初始化
100

2.3.4 分析类初始化

• 类的主动引用（一定会发生类的初始化）
  • 当虚拟机启动，初始化main方法所在的类。
  • new一个类的对象。
  • 调用类的静态方法（除了final常量）和静态方法。
  • 使用java.lang.reflect包的方法对类进行反射调用。
  • 当初始化一个类，如果其父类没有被初始化，则先会初始化他的父类。
• 类的被动调用（不会发生类的初始化）
  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
  • 通过数组定义类引用，不会触发的初始化。
  • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）。

2.3.5 类的加载器

类加载的作用：
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存：
标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象。

类加载器的分类
引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库,用来装载核心类库，该加载器无法直接获取。
扩展类加载器：负责jre/lib/ext目录下的jar包或-D Java.ext.dirs指定目录下的jar包装入工作库
系统类加载器：负责java -classpath或 -D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器

// 获取系统类的加载器
// 获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
// 获取系统类加载器的父类加载器-->扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@4554617c
// 获取扩展类加载器的父类加载器-->根加载器(c/c++)
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);//null
// 测试当前类是哪个加载器加载的
ClassLoader classLoader = Application.class.getClassLoader();
System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
// 测试Object类是哪个加载器加载的
ClassLoader loader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(loader);//null 是由根加载器加载的核心包
// 获取系统加载器可以加载那些路径
System.out.println(System.getProperty("java.class.path"));

2.3.6 双亲委派机制

防止同名包、类与 jdk 中的相冲突，实际上加载类的时候，先通知 appLoader，看 appLoader 是否已经缓存，没有的话，appLoader 又委派给他的父类加载器(extLoader)询问，看他是不是能已经缓存加载，没有的话，extLoader 又委派他的父类加载器(bootstrapLoader)询问，BootstrapLoader看是不是自己已缓存或者能加载的，有就加载，没有再返回 extLoader，extLoader 能加载就加载，不能的话再返回给 appLoader 加载，再返回的路中，谁能加载，加载的同时也加缓存里。正是由于不停的找自己父级，所以才有 Parents 加载机制，翻译过来叫 双亲委派机制。

2.4 创建运行时类的对象 获取运行时类的完整结构

通过反射获取运行时类的完整结构
Field、Method、Constructor、Superclass、Interface、Annotation

Class application = Class.forName("User");
// 获得类的名字
System.out.println(application.getName());// 获得包名+类型
System.out.println(application.getSimpleName());// 获得类名
// 获得所有属性(因为属性全部私有，所有一个都没有被获得)
for (Field field : application.getFields()) {
    System.out.println(field);
}
// 获取全部属性
System.out.println("==================================");
for (Field field : application.getDeclaredFields()) {
    System.out.println(field);
}
// 获取指定属性指
System.out.println("==================================");
System.out.println(application.getDeclaredField("name"));
// 获取类的方法(本类和父类)
System.out.println("==================================");
for (Method method : application.getMethods()) {
    System.out.println(method);
}
// 获取类的方法(本类)
System.out.println("==================================");
for (Method method : application.getDeclaredMethods()) {
    System.out.println(method);
}
// 获取类的指定方法(Java有重载，需要参数判断)
System.out.println("==================================");
Method getAge = application.getMethod("getAge");
Method setAge = application.getMethod("setAge",int.class);
System.out.println(getAge);
System.out.println(setAge);
// 获取类的指定构造器
System.out.println("==================================");
for (Constructor constructor : application.getConstructors()) {
    System.out.println("getConstructors:"+ constructor);// 获得public修饰的
}
for (Constructor constructor : application.getDeclaredConstructors()) {
    System.out.println("getDeclaredConstructors:"+constructor);// 获得全部
}
// 获取指定的构造器
System.out.println("==================================");
System.out.println(application.getConstructor(null));

动态创建对象执行方法

创建对象
调用Class对象的newInstance（）方法

//获取class对象
Class c1 = Class.forName("User");
// 构造一个对象
//Object user = c1.newInstance();
//System.out.println(user);

调用指定方法
通过Method类调用，使用Object invoke（Object obj，Object[] args）调用

// 通过反射调用普通方法 invoke(对象，方法需要的值)激活
Method getName = c1.getMethod("getName");
System.out.println(getName.invoke(user,null));// 输出要调用的方法的返回值

setAccessible

• Method和Field、Constructor对象都有setAccessible（）方法。
• setAccessible作用是启动和禁用方法安全检查开关。
• 参数值为true则指示反射的对象是使用时应该取消Java语言访问检查。
  • 提高反射的效率，如果代码中必须有反射，而该句需要被频繁的使用，请设置为true。
  • 使得原本无法访问的私有成员也可以访问。
• 参数值为false则指示反射的对象应该实施Java语言访问检查

// 通过反射调用属性
Field name = c1.getDeclaredField("name");
// 因为是private修饰，关闭权限检测,true关闭
name.setAccessible(true);
name.set(user,"四");
System.out.println(user.getName());

性能对比分析

测试代码

// 普通方式调用
User user = new User();
long start = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
    user.getName();
}
long endTime = System.currentTimeMillis();
System.out.println("普通方式执行10亿次：" + (endTime - start) + "ms");
// 反射方式调用
Class c1 = Class.forName("User");
User u1 = (User)c1.newInstance();
Method getName = c1.getMethod("getName", null);
start = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
    getName.invoke(u1,null);
}
endTime = System.currentTimeMillis();
System.out.println("反射方式执行10亿次：" + (endTime - start) + "ms");
// 反射方式调用 关闭检查
Class c2 = Class.forName("User");
User u2 = (User)c2.newInstance();
Method method = c2.getMethod("getName",null);
start = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
    method.setAccessible(true);
    method.invoke(u2,null);
}
endTime = System.currentTimeMillis();
System.out.println("反射方式,关闭检查执行10亿次：" + (endTime - start) + "ms");

结果

普通方式执行10亿次：4ms
反射方式执行10亿次：2377ms
反射方式,关闭检查执行10亿次：1132ms

获取泛型信息

• Java采用泛型擦除的机制来引用泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部拆除。
• 为了通过反射操作这些类型，Java新增了几种类型来表示不能被归一到Class类中的类型但是又和原始类型齐名的类型。
• ParameterizedType：表示一个参数化类型，比如Collection。
• GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型。
• TypeVariable：是各种类型变量的公共父接口。
• WildcardType：代表一种通配符类型表达式。

// 参数泛型
public void test01(Map map, List list) {
System.out.println("test01");
}

// 返回值泛型
public Map test02() {
System.out.println("test02");
return null;
}

public static void main(String[] args) throws Exception {
// 获得Class对象
Class c1 = Application.class;
// 获得方法test01
Method test01 = c1.getMethod("test01", Map.class, List.class);
// 获得参数类型
for (Type genericParameterType : test01.getGenericParameterTypes()) {
    System.out.println("参数类型：" + genericParameterType);
    // 属于参数化类型，就可以获得真实类型（结构化参数类型）
    if (genericParameterType instanceof ParameterizedType) {
        // 获得泛型参数类型
        for (Type actualTypeArgument : ((ParameterizedType) genericParameterType).getActualTypeArguments()) {
            System.out.println("真实类型:" + actualTypeArgument);
        }
    }
}
// 获得方法test02
Method test02 = c1.getMethod("test02", null);
// 获得返回值类型
Type genericReturnType = test02.getGenericReturnType();
System.out.println("返回值类型：" + genericReturnType);
// 属于参数化类型，就可以获得真实类型（结构化参数类型）
if (genericReturnType instanceof ParameterizedType) {
    // 获得泛型参数类型
    for (Type actualTypeArgument : ((ParameterizedType) genericReturnType).getActualTypeArguments()) {
        System.out.println("真实类型:" + actualTypeArgument);
    }
}

获取注解信息

• getAnnotations
• getAnnotation
  实体类

@Table("db_student")
class User {
    @Field(Columname = "db_id", type = "int", length = 10)
    private int id;
    private int age;
    private String name;

    public User() {
    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + ''' +
                '}';
    }
}

注解类

// 类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
    String value();
}

// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field {
    String Columname();

    String type();

    int length();
}

调用

Class c1 = Class.forName("User");
// 获取类注解
Table annotation = (Table)c1.getAnnotation(Table.class);
// 获取value
System.out.println(annotation.value());
// 获取属性注解
java.lang.reflect.Field id = c1.getDeclaredField("id");
Field annotation1 = id.getAnnotation(Field.class);
// 获取Columname值
System.out.println(annotation1.Columname());