注解和反射学习

1 注解

1.1 注解入门

1. Annotation作用

• 不是程序本身，可以对程序做出解释。（这一点和注释comment没有什么区别）
• 可以被其他程序（比如：编译器等）读取。

2. Annotation格式

• 以“@注解名”在代码中存在，还可以添加一些参数值。例如：@SuppressWarnings(value = "unchecked")

3. 使用范围

• 可以附加在package,class,method,field等上面，相当于给他们添加了额外的辅助信息，我们可以通过放射机制编程实现对于这些元数据的访问。

1.2 内置注解

1. @Override:定义在java.lang.Override中，此注释只适用于修饰方法，表示一个方法声名打算重写超类中另一个方法的声名。
2. @Deprecated:定义在java.lang.Deprecated中，此注释只适用于修饰方法、属性和类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择。
3. @SuppressWarnings:定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息。与前两个注解有所不同，需要添加一个参数才能正确使用，这些参数都是已经定义好的。

1.3 元注解

1. 元注解的作用是负责注释其他注解，Java中定义了4个标准的meta-annonation（@Target,@Retention,@Document,@Inherited）类型，他们被用来提供对于其他annotation类型的说明。

• @Target:用于描述注解的使用范围（被描述的注解可以放在什么地方）。

• @Retention:用于需要在什么级别保存该注释信息，用于描述注解的生命周期。

  • SOURCE （源代码）< CLASS < RUNTIME

• @Document:说明该注解将被包含到javadoc中。

• @Inherited: 说明子类可以继承父类的该注解。

public class Test01 {
    
    

    @MyAnnotation //添加设置的注解
    public  void test(){
    
    

    }
}

//定义一个注解
//Target定义范围，此时可以使用在方法和类上
@Target(value = {
    
    ElementType.METHOD,ElementType.TYPE})
//Retention 表示注解在什么地方有效
@Retention(value = RetentionPolicy.RUNTIME)
// 是否将该注解生成到Javadoc中
@Documented 
@interface MyAnnotation{
    
    

}

1.4 自定义注解

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

• 声名格式为：public @interface 注解名{定义内容}
• 声名的每一个方法实际上是声明了一个配置参数，方法的名称就是参数的名称，返回值的类型就是参数的类型（只能是基本类型）。
• 可以使用default来声明参数的默认值。
• 如果只有一个参数成员，一般参数名为value。

1. 多个参数注解

public class Test01 {
    
    

    //注解可以显示赋值，如果没有默认值，我们必须给注解赋值
    @MyAnnotation(name = "小伦",schools = "武汉理工大学，华科")
    public  void test(){
    
    
    }
}

@Target(value = {
    
    ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    
    
    //注解的参数：参数类型+参数名（）；定义参数不写参数，注解就会报错。
    String name();
//    String name() default ""; //设置默认值
    int age() default 0;
    int id() default -1; //如果默认值为-1，代表不存在；同indexof，默认值找不到，不存在
    String [] schools() default {
    
    "清华，北大"}; //定义一个数组
}

2. 单个参数注解

public class Test01 {
    
    
    //不写value = ""
    @MyAnnotation2("小伦")
    public  void test2(){
    
    
    }
}
@Target(value = {
    
    ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@interface  MyAnnotation2{
    
    
    String value(); //注解只有一个值，可以使用该value命名，在使用时可以省略该value。
}

2 反射

2.1 Java放射概述

1、Reflection(反射)是Java被认为动态语言的关键，反射机制允许程序在执行期间借助于Relection API获取任何类的内部信息，并能够直接操作任意对象的内部属性及方法。

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

2、当加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象可以看到类的结构。这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

（1）正常方式

引入需要的“包类”名称 -> 通过new实例化 -> 取得实例化对象。

（2）反射方式

实例化对象-> getClass()方法 -> 得到完整的“包类”名称。

2.2 获取反射对象

1、反射机制提供的功能

• 在运行时判断任意一个对象所属的类
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时构造任意一个类的对象
• 在运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理

2、反射的优缺点

（1）优点：可以实现动态创建对象和编译，体现出很大的灵活性。

（2）缺点：对性能有影响。使用反射基本上是一种解释操作，我们告诉JVM，希望做什么并且它满足我们的要求。这类操作总是慢于直接执行的操作。

3、反射相关的API

java.lang.Class:代表一个类（表示一个通用的类，描述类的类）。
java.lang.reflect.Method:代表类的方法。
java.lang.reflect.Field:代表类的成员变量。
java.lang.reflect.Constructor:代表类的构造器。

public class Test02 {
    
    
    public static void main(String[] args) throws ClassNotFoundException {
    
    
        //通过反射获取类的Class对象（包名+类名）
       // Class称为反射的源头
        Class c1 = Class.forName("com.xiaolun.User");
        System.out.println(c1);
        System.out.println(c1.hashCode());

        Class c2 = Class.forName("com.xiaolun.User");
        System.out.println(c2.hashCode());
    }
}

//定义一个实体类
class User {
    
    
    private String name;
    private int id;
    private int age;

    public User() {
    
    
    }

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

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        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;
    }
}

（1）通过反射获取类的Class对象（包名+类名）.

（2）c1.hashCode() = c2.hashCode()，即一个类在内存中只有一个Class对象，一个类被加载后，类的整个结构都会被封装在Class对象中。

（3）使用下面方式获取Class类的对象

public final Class getClass()

在Object类中定义了这个方法，此方法将被所有子类继承。该方法的返回值的类型是一个Class类，此类就是Java反射的源头,实际上所有反射从程序运行结果来看就是：可以通过对象反射求出类的名称。

（4）通过直接new的方式或者反射的方式可以调用公共的结构，开发中建议使用new的方式。当我们编译的时候无法确定造那个类的对象时，应该使用反射的方式。

2.3 得到类的几种方式

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

• Class本身就是一个对象，且该对象只能由系统建立对象。
• 一个加载的类在JVM中只会有一个Class实例。
• 一个Class对象对应的是一个加载到JVM中的一个class文件。
• 每个类的实例（例如：上图中的”张三“）都会记得自己是由哪个Class实例所生成。
• Class类是Reflection的根源，针对任何你想要动态加载、运行的类，唯有获得相应的Class对象。

Class类的创建方式

public class Test03 {
    
    
    public static void main(String[] args) throws ClassNotFoundException {
    
    
        Person person = new Student();
        System.out.println("这个人是："+ person.name);

        //方式1：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1); //结果：class com.xiaolun.Student

        //方式2：forname获得
        Class c2 = Class.forName("com.xiaolun.Student");
        System.out.println(c2.hashCode());

        //方式2：通过类名.class获取
        Class c3 = Student.class;
        System.out.println(c3.hashCode());

        //获取父类类型
        Class c4 = c1.getSuperclass();
        System.out.println(c4); //结果class com.xiaolun.Person
    }
}

//实体类
class Person{
    
    
    public String name;
    public  Person(){
    
    
    }
    public Person(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

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

class Student extends Person{
    
    
    public Student(){
    
    
        this.name = "学生";
    }
}

class Teacher extends Person{
    
    
    public Teacher(){
    
    
        this.name = "老师";
    }
}

2.4 所有类型的Class对象

1、可以有Class对象的类型

• class:外部类，成员（成员内部类，静态内部类）、局部内部类和匿名内部类。
• interface:接口。
• []:数组。
• enum:枚举。
• annotation:注释@interface。
• primitive type:基本数据类型。
• void。

public class Test04 {
    
    
    public static void main(String[] args) {
    
    
        Class c1 = Object.class;//类
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;//数组
        Class c4 = Override.class;//注解
        Class c5 = ElementType.class;//枚举类型
        Class c6 = Integer.class;//基本数据类型
        Class c7 = void.class;//空类型
        Class c8 = Class.class;//Class类型

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
    }
}

2.5 类加载内存分析

1、类的加载与ClassLoader的理解

（1）加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行数据结构，然后生成一个代表这个类的java.lang.Class对象。

（2）链接

将Java类的二进制代码合并到JVM的运行状态之中的过程。

• 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
• 准备：正式为类变量（static）分配，并设置类变量默认初始化阶段，这些内存将在方法区中进行分配。
• 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

（3）初始化

执行类构造器<clinit>()方法的过程，该方法是由编译器自动收集类中所有类变量的赋值和静态代码块中语句合并产生的。（类构造器是构造类信息的，不是构造类对象的构造器）

当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

虚拟机会保证一个类的<clinit>()方法在多线程中被正确加锁和同步。

public class Test05 {
    
    
    public static void main(String[] args) {
    
    
        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

执行顺序：

• 加载到内存，会产生一个类对应的Class对象。

• 链接，链接结构，m = 0（初始值）。

• 初始化（静态代码块中语句的合并）：

  <clinit>(){
        
        
  	  System.out.println("A类静态代码快初始化");
          m = 300;
          m = 100; //所以，最后产生的m值等于100。
  	}
  

• 流程讲解图

2.6 分析类初始化

1. 类的主动引用（一定会发生类的初始化）

• 当虚拟机启动，先初始化main方法所在的类。
• new一个类的对象。
• 调用类的静态成员（除了final常量）和静态方法。
• 使用java.lang.reflect包的方法对类进行反射调用。
• 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类。

public class Test06 {
    
    
    static {
    
    
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
    
    
        //主动引用
//        Son son = new Son();

        //反射也会产生主动引用
//        Class.forName("com.xiaolun.Son");
    }
}

class Father{
    
    
    static int b = 2;
    static {
    
    
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    
    

    static {
    
    
        System.out.println("子类被加载");
    }
    static int m = 100;
    static final int M = 1;
}

控制台输出结果：

Main类被加载
父类被加载
子类被加载

1. 类的被动调用（不会发生类的初始化）

• 当访问一个静态域时，只要真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
• 定义数组定义类引用，不会触发此类的初始化。
• 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）。

public class Test06 {
    
    
    static {
    
    
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
    
    
        //不会产生类的引用的方法
//        System.out.println(Son.b);

        //不会加载类，只是一片空间而已
        //控制台输出：Main类被加载。
//        Son[] array = new Son[5];

        //子类和父类都不会初始化
//        System.out.println(Son.M);
    }
}

class Father{
    
    
    static int b = 2;
    static {
    
    
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    
    

    static {
    
    
        System.out.println("子类被加载");
    }
    static int m = 100;
    static final int M = 1;
}

控制台输出：

Main类被加载
父类被加载
2

2.7 ClassLoader

1、类的加载过程

程序经过java.exe命令之后，会生成一个或多个字节码文件（.class结尾），接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将该字节码文件加载到内存中，此过程叫做类的加载。

加载到内存中的类，我们就称为运行时类，此运行类，就作为Class的一个实例。

//显式使用
Class c1 = Person.class;

2、类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据转化成方法区的运行时数据结构，然后再堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

3、类缓存

标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过，JVM垃圾回收机制可以回收这些Class对象。

4、代码

public class Test07 {
    
    
    public static void main(String[] args) throws ClassNotFoundException {
    
    

//        获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取系统类加载器的父类加载器-根加载器（C/C++）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类时那个加载器加载的
        ClassLoader classLoader = Class.forName("com.xiaolun.Test07").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置的类是那个加载器加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //获取系统类加载器可以加载的路径
  System.out.println(System.getProperty("java.class.path"));
       
    }

运行结果：

sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1540e19d
null
sun.misc.Launcher$AppClassLoader@18b4aac2
null
     /**
         *   D:\a22IDEA\Annotation_fanshe\out\production\Annotation_fanshe;
         *   D:\a22IDEA\install200226\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar
         */

2.8 获取类的运行时结构

1. 通过反射可以获得运行时类的完整结构

Field、Method、Constructor、Superclass、Interface、Annotation。

• 实现全部接口
• 所继承的父类
• 全部的构造器
• 全部的Filed方法

public class Test08 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        Class c1 = Class.forName("com.xiaolun.User");

        //获取类的名字
        System.out.println(c1.getName());//包名+类名
        System.out.println(c1.getSimpleName());//类名

        //获得类的属性
        System.out.println("------------------");
        Field[] fields = c1.getFields();//只能找到public属性
        fields = c1.getDeclaredFields(); //找到全部的属性
        for (Field field: fields) {
    
    
            System.out.println(field);
        }

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        System.out.println("------------------");
        Method[] methods = c1.getMethods();//获得本类及其父类所有的public方法
        methods = c1.getDeclaredMethods(); //获取本类的方法
        for (Method method:methods) {
    
    
            System.out.println(method);
        }

        //获得指定属性的值
        //考虑到重载
        Method getName = c1.getDeclaredMethod("getName", null);//参数为null
        Method setName = c1.getDeclaredMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得类的构造器
        System.out.println("------------------");
        Constructor[] constructors = c1.getConstructors();
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor:constructors) {
    
    
            System.out.println(constructor);
        }

        //获取指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(declaredConstructor);
    }
}

运行结果：

com.xiaolun.User
User
------------------
private java.lang.String com.xiaolun.User.name
private int com.xiaolun.User.id
private int com.xiaolun.User.age
private java.lang.String com.xiaolun.User.name
------------------
public java.lang.String com.xiaolun.User.getName()
public int com.xiaolun.User.getId()
public void com.xiaolun.User.setName(java.lang.String)
public void com.xiaolun.User.setAge(int)
public void com.xiaolun.User.setId(int)
public int com.xiaolun.User.getAge()
public java.lang.String com.xiaolun.User.getName()
public void com.xiaolun.User.setName(java.lang.String)
------------------
public com.xiaolun.User()
public com.xiaolun.User(java.lang.String,int,int)
public com.xiaolun.User(java.lang.String,int,int)

2.9 动态创建对象执行方法

1. 有了Class对象，能做什么

• 创建类的对象：调用Class对象的newInstance()方法。

  • 类必须有一个无参数的构造器。
  • 类的构造器的访问权限需要足够。

  只有再操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以进行实例化操作。步骤为：

  • 通过Class中的getDeclaredConstructor(Class… parameterTypes)取得本类的指定形参类型的构造器。
  • 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
  • 通过Constructor实例化对象。

2. 调用指定类的方法

• 通过反射，调用类中的方法，通过Method类完成。
  • 通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需的参数类型。
  • 之后使用Object invoke(Object obj,Object[] args)进行调用，并向方法中传递设置的obj对象的参数信息。

3. 调用指定的方法

Object invoke(Object obj,Object...args)

• Object对应原方法的返回值，若原方法无返回值，此时返回null。
• 若原方法为静态方法，此时形参Object obj可为null。
• 若原方法为形参列表为空，此时形参Object…argsj为null。
• 若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)，将可以访问private方法。

1. setAccessible(true)

• Method和Field、Constructor对象都有setAccessible(true)方法。
• 该方法的作用是启用和禁止访问安全检查的开关。
  • 参数为true则指示反射的对象在使用时应该取消Java语言访问检查。使得原本无法访问的私有成员可以被访问到。反之，实施Java语言访问检查。
  • 可以提高反射效率。

public class Test09 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //获得Class对象
        Class c1 = Class.forName("com.xiaolun.User");

//        //创建一个对象
//        User user = (User) c1.newInstance(); //本质上是调用了类的无参构造器
//        System.out.println(user); //需要User无参构造器，否则会报错
//
//        //通过指定构造器创建一个对象
//        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
//        User user2 = (User) constructor.newInstance("小伦", 001, 18);
//        System.out.println(user2);

        //通过反射调用普通方法
        User user3 = (User) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);

        //invoke:激活（对象，方法的值）
        setName.invoke(user3, "小伦");
        System.out.println(user3.getName());

        //通过反射调用属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //不能直接操作属性，我们需要关闭程序的安全检测
        name.setAccessible(true);
        name.set(user4, "小伦2");
        System.out.println(user4.getName());
    }
}

• //注释语句输出结果
  User{
        
        name='null', id=0, age=0}
  User{
        
        name='小伦', id=1, age=18}
  
  //下面语句输出结果
  小伦
  小伦2
  

2.10 性能对比分析

public class Test10 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        test01();
        test02();
    }

    //普通方式调用
    public static void test01(){
    
    
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
    
    
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式调用100万次，耗时："+(endTime-startTime)+"ms");
    }

    //反射方式调用，关闭检测
    public static void test02() throws Exception {
    
    
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true); //关闭检测
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
    
    
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("关闭检测调用100万次，耗时："+(endTime-startTime)+"ms");
    }
}

• 关闭检测的反射调用方式比第一种方式稍慢，getName.setAccessible(true); 在频繁调用时很有效。

2.11 获取泛型信息

1. Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的问题。但是，一旦编译完成，所有和泛型有关的类型全部擦除。
2. 为了通过反射操作这些类型，Java新增了ParameterizedType、GenericArrayType、TypeVariable和WildcardType几种类型来代表不能归一到Class类型中的类型但是又和原始类型齐名的类型。

• ParameterizedType：表示一种参数化类型，可以获取泛型参数Class类型比如Collection。
• GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型。
• TypeVariable：是各种类型变量的公共父接口。
• WildcardType：代表一种通配符类型表达式。

public class Test11 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        Method method = Test11.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes(); //获取参数类型
        for (Type genericParameterType : genericParameterTypes) {
    
    
            System.out.println("#"+genericParameterType);

            //获取参数类型里面的信息
            if (genericParameterType instanceof ParameterizedType){
    
     //参数类型是否等于结构化类型
                //获取真实参数信息，并打印
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
    
    
                    System.out.println(actualTypeArgument);
                }
            }
        }

        //获取泛型返回值信息
        method = Test11.class.getMethod("test02", null);
        Type genericReturnType = method.getGenericReturnType();//获取返回值类型
        if (genericReturnType instanceof ParameterizedType){
    
     //参数类型是否等于结构化类型
            //获取真实参数信息，并打印
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
    
    
                System.out.println(actualTypeArgument);
            }
        }
    }

    public void test01(Map<String,User> map,List<User> list){
    
    
        System.out.println("test01");
    }
    public Map<String,User> test02(){
    
    
        System.out.println("test02");
        return null;
    }
}

• 输出结果

  #java.util.Map<java.lang.String, com.xiaolun.User>
  class java.lang.String
  class com.xiaolun.User
  #java.util.List<com.xiaolun.User>
  class com.xiaolun.User
  
    //获取泛型返回值信息输出结果
  class java.lang.String
  class com.xiaolun.User
  

2.12 获取注解信息

1. ORM

• 利用注解和反射完成类和表结构的映射关系。

public class Test12 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        Class c1 = Class.forName("com.Student2");

        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
    
    
            System.out.println(annotation); //可以找到外面的注解，并没有找到注解里面的值
        }

        //获取注解value中的值
        Tablelun annotation = (Tablelun)c1.getAnnotation(Tablelun.class); //获取指定的注解
        String value = annotation.value();
        System.out.println(value);

        //获取类指定的注解
        Field f = c1.getDeclaredField("name");
        Filedlun annotation1 = f.getAnnotation(Filedlun.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }
}

@Tablelun("db_student")
class Student2{
    
    
    @Filedlun(columnName = "db_id",type = "int",length = 10)
    private int id;

    @Filedlun(columnName = "db_age",type = "int",length = 10)
    private int age;

    @Filedlun(columnName = "db_name",type = "varchar",length = 3)
    private String name;

    public Student2(){
    
    
    }

    public Student2(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 "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}


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

//类型的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Filedlun{
    
    
    String columnName(); //列名
    String type(); //类型
    int length(); //数据库长度
}

输出结果：

@com.Tablelun(value=db_student)
db_student
db_name
varchar
3

2.13 体会反射的动态性

动态性：在运行程序时根据某些条件创建代码。

import java.util.Random;

public class ReflationTest {
    
    
   public static void main(String[] args) {
    
    
      int num = new Random().nextInt(3); //0,1,2
      String classPath = "";
      switch (num) {
    
    
         case 0:
            classPath = "java.util.Date";
            break;
         case 1:
            classPath = "com.xiaolun.Person";
            break;
         default:
            break;
      }
      Object obj = getInstance(classPath);
      System.out.println(obj);
   }

   /**
    * 创建一个指定的类的对象
    * classPath：指定类的全类名
    */
   public static Object getInstance(String classPath) {
    
    
      try {
    
    
         Class clazz = Class.forName(classPath);
         return clazz.newInstance();
      } catch (Exception e) {
    
    
         e.printStackTrace();
      }
      return null;
   }
}