注解与反射 -（反射篇）

反射

概述：Reflection(反射) 是java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

正常方式：引入需要的“包类”名称 -> new实例化 -> 取得实例化对象

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

Java反射机制提供的功能

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

反射相关的主要API

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

Class类

对象照镜子后可以得到的信息：某个类的属性、方法和构造器对于每个类而言，jre都为其保留一个不变的Class类型的对象。

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

Class类的常用方法

• static ClassforName(String name):返回指定类名的Class对象

• Object newInstance():调用缺省构造函数，返回Class对象的一个实例

• getName():返回此Class对象所表示的实体（类、接口、数组类或void）的名称

• Class getSuperClass():获取当前Class对象的父类Class对象

• Class[] getinterfaces():获取当前Class对象的接口

• ClassLoader getClassLoader():返回该类的类加载器

• Constructer[] getConstructors():返回一个包含某些Constructor对象的数组

• Method getMothed(String name,Class… T):返回一个Method对象，此对象的形参类型为paramType

• Field[] getDeclaredFields():返回Field对象的一个数组

  public class Test02 {
      public static void main(String[] args) throws ClassNotFoundException {
          Person person = new Student();
          System.out.println("这个人是"+person.name);
          //方式一：通过对象获得
          Class c1 = person.getClass();
          System.out.println(c1.hashCode());
          //方式二：forName获得
          Class c2 = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Student");
          System.out.println(c2.hashCode());
          //方式三：通过类名.class获取
          Class c3 = Student.class;
          System.out.println(c3.hashCode());
          //获得父类类型
          Class c4 = c1.getSuperclass();
          System.out.println(c4);
          /**
           * 输出结果
           * 这个人是学生
           * 1179381257
           * 1179381257
           * 1179381257
           * class com.archforce.aclub.forum.Test.OverrideTest.Person
           */
      }
  }
  //实体类，含name属性
  class Person{
      String name;
      public Person(){
      }
      public Person(String name){
          this.name= name;
      }
      @Override
      public String toString() {
          return "Person{" +
                  "name='" + name + '\'' +
                  '}';
      }
  }
  class Student extends Person{
      public Student(){
          this.name = "学生";
      }
  }
  class Teacher extends Person{
      public Teacher(){
          this.name = "老师";
      }
  }
  

哪些类型可以有Class对象

• class:外部类、成员（成员内部类，静态内部类），局部内部类，匿名内部类

• interface:接口

• []:数组

• enum:枚举

• annotation:注解@interface

• primitive type:基本数据类型

• void

  import java.lang.annotation.ElementType;
  //所有类型的Class
  public class Test03 {
      public static void main(String[] args) {
          Class c1 = Object.class;
          Class c2 = Comparable.class;
          Class c3 = String[].class;
          Class c4 = int[][].class;
          Class c5 = Override.class;
          Class c6 = ElementType.class;
          Class c7 = Integer.class;
          Class c8 = void.class;
          Class c9 = 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);
          System.out.println(c9);
          //只要元素类型和维度一样，就是同一个Class
          int[] a = new int[10];
          int[] b = new int[100];
          System.out.println(a.getClass().hashCode());
          System.out.println(b.getClass().hashCode());
          /**
           * class java.lang.Object
           * interface java.lang.Comparable
           * class [Ljava.lang.String;
           * class [[I
           * interface java.lang.Override
           * class java.lang.annotation.ElementType
           * class java.lang.Integer
           * void
           * class java.lang.Class
           * 1860944798
           * 1860944798
           */
      }
  }
  
  

类加载过程

1. 加载到内存，产生一个类对应Class对象
2. 链接，链接结束后变量初始值为0
3. 初始化-执行顺序
   • 静态代码块
   • 类的无参构造方法
   • 静态变量

分析类初始化

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

类加载器

1. 作用：把类装载进内存，去百度

2. 分类

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

   public class Test04 {
       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.archforce.aclub.forum.Test.OverrideTest.Test04").getClassLoader();
           System.out.println(classLoader);
           //测试JDK内部类是哪个类加载器加载的
           ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
           System.out.println(classLoader1);
           /**
            * jdk.internal.loader.ClassLoaders$AppClassLoader@2d8e6db6
            * jdk.internal.loader.ClassLoaders$PlatformClassLoader@6eebc39e
            * null
            * jdk.internal.loader.ClassLoaders$AppClassLoader@2d8e6db6
            * null
            */
           //如何获得系统类加载器可以加载的路径:jre下的一系列包
           System.out.println(System.getProperty("java.class,pass"));
       }
   }
   

获取类的运行时结构

1. //获取类的信息
   public class Test05 {
       public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
           Class c1 = Class.forName("com.archforce.aclub.module.AclubUser");
           //获取类的名字
           System.out.println(c1.getName());//获得包名+类名com.archforce.aclub.module.AclubUser
           System.out.println(c1.getSimpleName());//获得类名AclubUser
           //获得类的属性
           Field[] fields = c1.getFields();//只能找到public属性
           fields=c1.getDeclaredFields();//全部属性（包括private私有）
           for(Field field:fields){
               System.out.println(field);
           }
           //获取指定属性的值
           Field name = c1.getDeclaredField("userName");
           //获取类的方法
           Method[] methods = c1.getMethods();//获取public属性的方法
           methods = c1.getDeclaredMethods();//获取所有方法
           //获取指定方法
           Method getName = c1.getMethod("getUserName",null);
           Method setName = c1.getMethod("setUserName", String.class);
           //获取所有构造器
           Constructor[] constructors = c1.getConstructors();
           constructors = c1.getDeclaredConstructors();
           //获取指定构造器
           Constructor constructor = c1.getConstructor(String.class,int.class,int.class);
       }
   }
   
   

动态创建对象执行方法

1. import java.lang.reflect.Field;
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   
   //动态的创建对象，通过反射
   public class Test06 {
       public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
           //获取Class对象
           Class c1 = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Person");
           //构造一个对象，本质是调用了类的无参构造器
           Person person = (Person)c1.newInstance();
           //通过反射调用普通方法,invoke是激活的意思，invoke(对象,"方法的值")
           Method setName = c1.getMethod("setName",String.class);
           setName.invoke(person,"任建勇");
           System.out.println(person.getName());
           //通过反射操作属性
           Person person2 = (Person)c1.newInstance();
           Field name = c1.getDeclaredField("name");
           //不能直接操作私有属性，需要关闭程序的安全监测,通过属性或者方法的setAccessible(true)
           name.setAccessible(true);
           name.set(person2,"renjianyogn");
           System.out.println(person2.getName());
       }
   }
   

性能对比分析

正常调用 > 反射方式（关闭检测） > 反射方式

通过反射获取泛型信息

1. ParameterizedType：表示一种参数化类型，比如Collection

2. GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

3. TypeVariable：是各种类型变量的公共父接口

4. WildcardType：代表一种通配符类型表达式

   import java.lang.reflect.Method;
   import java.lang.reflect.ParameterizedType;
   import java.lang.reflect.Type;
   import java.util.List;
   import java.util.Map;
   //通过反射获取泛型信息
   public class Test07 {
       public void Test1(Map<String,Person> map, List<Person> list){
           System.out.println("Test1");
       }
       public Map<String,Person> Test2(){
           System.out.println("Test2");
           return null;
       }
       public static void main(String[] args) throws NoSuchMethodException {
           Method method = Test07.class.getMethod("Test1", Map.class, List.class);
           //获取方法Test1的参数信息
           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 method2 = Test07.class.getMethod("Test2", null);
           //获取方法Test2的返回值类型
           Type genericReturnType = method2.getGenericReturnType();
           if(genericReturnType instanceof ParameterizedType){
               Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
               for(Type actualTypeArgument:actualTypeArguments){
                   //打印真实参数信息
                   System.out.println(actualTypeArgument);
               }
           }
   
       }
   }
   /**
    * java.util.Map<java.lang.String, com.archforce.aclub.forum.Test.OverrideTest.Person>
    * class java.lang.String
    * class com.archforce.aclub.forum.Test.OverrideTest.Person
    * java.util.List<com.archforce.aclub.forum.Test.OverrideTest.Person>
    * class com.archforce.aclub.forum.Test.OverrideTest.Person
    */
   /**
    * class java.lang.String
    * class com.archforce.aclub.forum.Test.OverrideTest.Person
    */
   

反射操作注解

1. ORM（Object relationship Mapping） --> 对象关系映射

   • 类和表结构对应（实体类，数据库表）
   • 属性和字段对应
   • 对象和记录对应（数据库每条记录代表一个对象）

2. 练习：利用注解和反射完成类和表结构的映射关系

   import java.lang.annotation.*;
   import java.lang.reflect.Field;
   
   public class Test08 {
       public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
           Class c1 = Class.forName("com.archforce.aclub.forum.Test.OverrideTest.Student2");
           //通过反射获得注解
           Annotation[] annotations = c1.getAnnotations();
           for(Annotation annotation:annotations){
               System.out.println(annotation);
           }
           //获得注解的value的值
           Tablerenjianyong tablerenjianyong = (Tablerenjianyong)c1.getAnnotation(Tablerenjianyong.class);
           String value = tablerenjianyong.value();
           System.out.println(value);
   
           //获取类指定的注解（属性/字段）
           Field field = c1.getDeclaredField("name");
           Fieldrenjianyong tablerenjianyong1 = field.getAnnotation(Fieldrenjianyong.class);
           System.out.println(tablerenjianyong1.column());
           System.out.println(tablerenjianyong1.type());
           System.out.println(tablerenjianyong1.length());
           /**
            * @com.archforce.aclub.forum.Test.OverrideTest.Tablerenjianyong(value="db_student")
            * db_student
            * db_name
            * varchar
            * 10
            */
       }
   }
   @Tablerenjianyong(value = "db_student")
   class Student2{
   
       @Fieldrenjianyong(column = "db_id",type = "int",length = 10)
       private int id;
       @Fieldrenjianyong(column = "db_age",type = "int",length = 10)
       private int age;
       @Fieldrenjianyong(column = "db_name",type = "varchar",length = 10)
       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 Tablerenjianyong{
       String value();
   }
   //属性（参数）的注解
   @Target(ElementType.FIELD)
   @Retention(RetentionPolicy.RUNTIME)
   @interface Fieldrenjianyong{
       String column();
       String type();
       int length();
   }