反射机制介绍

 什么是反射

Java 反射机制是Java语言一个很重要的特性，它使得Java具有了“动 态性”。在Java程序运行时，对于任意的一个类，我们能不能知道这 个类有哪些属性和方法呢？对于任意的一个对象，我们又能不能调 用它任意的方法？答案是肯定的！这种动态获取类的信息以及动态 调用对象方法的功能就来自于Java 语言的反射（Reflection）机 制。

 反射的作用

简单来说两个作用，RTTI（运行时类型识别）和DC（动态创建）。 我们知道反射机制允许程序在运行时取得任何一个已知名称的class 的内部信息，包括其modifiers(修饰符)，fields(属性)，methods(方 法)等，并可于运行时改变fields内容或调用methods。那么我们便 可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间 进行源代码链接，降低代码的耦合度；还有动态代理的实现等等； 但是需要注意的是反射使用不当会造成很高的资源消耗！

创建对象过程 

Java创建对象的三个阶段

 创建对象时内存结构

Users user = new Users();

 实际上，我们在加载任何一个类时都会在方法区中建立“这个类对应 的Class对象”，由于“Class对象”包含了这个类的整个结构信息，所 以我们可以通过这个“Class对象”来操作这个类。 我们要使用一个类，首先要加载类；加载完类之后，在堆内存中， 就产生了一个 Class 类型的对象（一个类只有一个 Class 对象）， 这个对象就包含了完整的类的结构信息。我们可以通过这个对象知 道类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的 结构，所以，我们形象的称之为：反射。 因此，“Class对象”是反射 机制的核心。

反射的具体实现 

获取Class对象的三种方式

 1、通过getClass()方法;

 2、通过.class 静态属性;

 3、通过Class类中的静态方法forName();

 创建Users类

public class Users {
    private String username;
    private int userage;
    public String getUsername() {
        return username;
      }
   public void setUsername(String username)
     {
        this.username = username;
     }
   public int getUserage() {
        return userage;
      }
    public void setUserage(int userage) {
        this.userage = userage;
   }
}

通过getClass()方法获取Class对象

* 通过getClass()方法获取该类的Class对象
*/
public class GetClass1 {
    public static void main(String[] args) {
        Users users = new Users();
        Users users1 = new Users();
        Class clazz = users.getClass();
        System.out.println(clazz);
        System.out.println(clazz.getName());
        System.out.println(users.getClass() == users1.getClass());
   }
}

通过.class 静态属性获取Class对象

/**
* .class静态属性获取Class对象
*/
public class GetClass2 {
    public static void main(String[] args) {
        Class clazz = Users.class;
        Class clazz2 = Users.class;
        System.out.println(clazz);
        System.out.println(clazz.getName());
        System.out.println(clazz == clazz2);
   }
}

通过forName()获取Class对象

/**
* 通过Class.forName("class Name")获取Class对象
*/
public class GetClass3 {
    public static void main(String[] args)throws Exception {
        Class clazz = Class.forName("com.bjsxt.Users");
        Class clazz2 = Class.forName("com.bjsxt.Users");
        System.out.println(clazz);
        System.out.println(clazz.getName());
        System.out.println(clazz == clazz2);
   }
}

获取类的构造方法

方法介绍

 方法使用

修改Users类

public class Users {
    private String username;
    private int userage;
    public Users(){}
    public Users(String username,int userage){
        this.username= username;
        this.userage=userage;
   }
   
 public  Users(String username){
        this.username= username;
   }
   
 private Users(int userage){
        this.userage = userage;
   }
   
 public String getUsername() {
        return username;
   }
    
 public void setUsername(String username)
   {
        this.username = username;
   }
    
 public int getUserage() {
        return userage;
   }
 public void setUserage(int userage) {
        this.userage = userage;
   }
}

获取构造方法

public class GetConstructor {
    public static void main(String[] args)throws Exception {
        Class clazz = Users.class;
        Constructor[]  arr = clazz.getDeclaredConstructors();
        for(Constructor c:arr){
            System.out.println(c);
       }
        System.out.println("---------------------");
        Constructor[]  arr1 = clazz.getConstructors();
        for(Constructor c:arr1){
            System.out.println(c);
       }
        System.out.println("------------------------");
        Constructor c =   clazz.getDeclaredConstructor(int.class);
        System.out.println(c);
        System.out.println("------------------------");
        Constructor c1 =   clazz.getConstructor(null);
        System.out.println(c1);
   }
}

通过构造方法创建对象

public class GetConstructor2 {
    public static void main(String[] args)throws Exception {
        Class clazz = Users.class;
        Constructor constructor = clazz.getConstructor(String.class,int.class);
        Object o = constructor.newInstance("OldLu",18);
        Users users = (Users)o;
      System.out.println(users.getUsername()+"\t"+ users.getUserage());
   }
}

获取类的成员变量

方法介绍

 方法使用

修改Users类

public class Users {
    private String username;
    public int userage;
    public Users(){
   }
    
    public Users(String username,int userage){
        this.username= username;
        this.userage=userage;
      }
    
    public  Users(String username){
        this.username= username;
      }
    
    private Users(int userage){
        this.userage = userage;
      }

    public String getUsername() {
        return username;
      }
    public void setUsername(String username)
      {
        this.username = username;
      }
    public int getUserage() {
        return userage;
      }
    public void setUserage(int userage) {
        this.userage = userage;
   }
}

获取成员变量

public class GetField {
    public static void main(String[] args)throws Exception {
        Class clazz = Users.class;
        Field[] fields = clazz.getFields();
        for(Field f:fields){
            System.out.println(f);
            System.out.println(f.getName());
        }
        System.out.println("------------------------");
        Field[] fields2 =clazz.getDeclaredFields();
        for(Field f:fields2){
            System.out.println(f);
            System.out.println(f.getName());
       }
        System.out.println("------------------------");
        Field field = clazz.getField("userage");
        System.out.println(field);
        System.out.println("---------------------");
        Field field1 = clazz.getDeclaredField("username");
        System.out.println(field1);
   }
}

操作成员变量

public class GetField2 {
    public static void main(String[] args)throws Exception {
        Class clazz = Users.class;
        Field field = clazz.getField("userage");
        //对象实例化
        Object obj = clazz.newInstance();
        //为成员变量赋予新的值
        field.set(obj,18);
        //获取成员变量的值
        Object o = field.get(obj);
        System.out.println(o);
   }
}

获取类的方法

方法介绍

 方法使用

修改Users类

public class Users {
    private String username;
    public int userage;
    public Users(){ }
    public Users(String username,int userage){
        this.username= username;
        this.userage=userage;
      }
    public  Users(String username){
        this.username= username;
      }
    private Users(int userage){
        this.userage = userage;
      }
    public String getUsername() {
        return username;
      }
    public void setUsername(String username)
      {
        this.username = username;
      }
    public int getUserage() {
        return userage;
      }
    public void setUserage(int userage) {
        this.userage = userage;
      }
    private void suibian(){
        System.out.println("Hello Oldlu");
   }
}

获取方法

public class GetMethod {
    public static void main(String[] args)throws Exception{
        Class clazz = Users.class;
        Method[] methods = clazz.getMethods();
        for(Method m: methods){
            System.out.println(m);
            System.out.println(m.getName());
       }
        System.out.println("---------------------------");
        Method[] methods2 = clazz.getDeclaredMethods();
        for(Method m: methods2){
            System.out.println(m);
            System.out.println(m.getName());
       }
        System.out.println("--------------------------");
        Method method = clazz.getMethod("setUserage", int.class);
        System.out.println(method.getName());
        System.out.println("--------------------------");
        Method method1 = clazz.getDeclaredMethod("suibian");
        System.out.println(method1.getName());
   }
}

调用方法

public class GetMethod2 {
    public static void main(String[] args)throws  Exception {
        Class clazz = Users.class;
        Method method = clazz.getMethod("setUsername",String.class);
         //实例化对象
        Object obj = clazz.getConstructor(null).newInstance();
        //通过setUserName赋值
        method.invoke(obj,"oldlu");
        //通过getUserName获取值
        Method method1 = clazz.getMethod("getUsername");
        Object value = method1.invoke(obj);
        System.out.println(value);
   }
}

获取类的其他信息

public class GetClassInfo {
    public static void main(String[] args) {
        Class clazz = Users.class;
        //获取类名
        String className = clazz.getName();
        System.out.println(className);
        //获取包名
        Package p = clazz.getPackage();
        System.out.println(p.getName());
        //获取超类
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass.getName());
        //获取该类实现的所有接口
        Class[] interfaces = clazz.getInterfaces();
        for(Class inter:interfaces){
           System.out.println(inter.getName());
       }
   }
}

反射应用案例

需求：根据给定的方法名顺序来决定方法的执行顺序。

class Reflect {
    public void method1(){
      System.out.println("Method1.......");
   }
    public void method2(){
       System.out.println("Method2.......");
   }
    public void method3(){
       System.out.println("Method3.......");
   }
}
public class ReflectDemo {
    public static void main(String[] args)throws Exception {
        Reflect rd = new Reflect();
        if(args != null && args.length > 0){
            //获取ReflectDemo的Class对象
            Class clazz = rd.getClass();
            //通过反射获取ReflectDemo下的所有方法
            Method[] methods = clazz.getMethods();
            for(String str :args){
                for(int i=0;i<methods.length;i++){ if(str.equalsIgnoreCase(methods[i].getName())){
                      methods[i].invoke(rd);
                        break;
                   }
               }
           }
       }else{
            rd.method1();
            rd.method2();
            rd.method3();
       }
   }
}

反射机制的效率

由于Java反射是要解析字节码，将内存中的对象进行解析，包括了 一些动态类型，而JVM无法对这些代码进行优化。因此，反射操作 的效率要比那些非反射操作低得多！ 接下来我们做个简单的测试来直接感受一下反射的效率。

反射机制的效率测试 

public class Test{
    public static void main(String[] args) {
        try {
            //反射耗时
            Class clazz = Class.forName("com.bjsxt.Users");
            Users users = (Users) clazz.getConstructor(null).newInstance();
            long reflectStart = System.currentTimeMillis();
            Method method = clazz.getMethod("setUsername", String.class);
            for(int i=0;i<100000000;i++){
               method.invoke(users,"oldlu");
           }
            long reflectEnd = System.currentTimeMillis();
            //非反射方式的耗时
            long start = System.currentTimeMillis();
            Users u = new Users();
            for(int i=0;i<100000000;i++){
                u.setUsername("oldlu");
           }
            long end = System.currentTimeMillis();
            System.out.println("反射执行时 间："+(reflectEnd - reflectStart)); System.out.println("普通方式执行时间："+(end - start));
       } catch (Exception e) {
            e.printStackTrace();
       }
   }
}

setAccessible方法

setAccessible()方法： setAccessible是启用和禁用访问安全检查的开关。值为 true 则指示 反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指 示反射的对象应该实施 Java 语言访问检查;默认值为false。 由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关 闭安全检查就可以达到提升反射速度的目的。

public class Test2 {
    public static void main(String[] args)throws Exception {
        Users users = new Users();
        Class clazz = users.getClass();
        Field field = clazz.getDeclaredField("username");
        //忽略安全检查
        field.setAccessible(true);
        field.set(users,"oldlu");
        Object object = field.get(users); System.out.println(object);
        System.out.println("-----------------------------");
        Method method = clazz.getDeclaredMethod("suibian");
        method.setAccessible(true);
        method.invoke(users);
   }
}

本章总结

Java 反射机制是Java语言一个很重要的特性，它使得Java具有了 “动态性”。

反射机制的优点：

    1、更灵活。

    2、更开放。

反射机制的缺点：

    1、降低程序执行的效率。

    2、增加代码维护的困难。

获取Class类的对象的三种方式：

   1、运用getClass()。

   2、运用.class 语法。

   3、运用Class.forName()（最常被使用）。

反射机制的常见操作

   1、动态加载类、动态获取类的信息（属性、方法、构造器）。

   2、动态构造对象。

   3、动态调用类和对象的任意方法。

   4、动态调用和处理属性。

   5、 获取泛型信息。

   6、处理注解。