Java反射机制的简单使用

系统管理员 2023-06-21 10:12 36阅读 0赞

### 文章目录 ###

*  什么是Java反射机制？
 *  哪些地方用到反射机制？
 *  反射机制提供了哪些功能？
 *  如何实现反射机制？
 *  反射的三种实现方式
 *   *  一、通过对象的getClass()方法
     *  二、通过类的.class属性
     *  三、通过Class类的forName()方法（常用）
 *  判断一个类是否为某个类的实例
 *   *  1、instanceof
     *  2、isInstance
 *  利用反射创建对象实例
 *   *  1、通过Class对象的 newInstance() 方法
     *  2、通过Constructor对象的 getConstructor() 方法
 *  Field
 *   *  getField(String name)
     *   *  getField0(String name)
         *  privateGetDeclaredFields(boolean publicOnly)
     *  getFields(String name)
     *  getDeclaredField(String name)
     *  getDeclaredFields()
 *  Method
 *   *  getMethod(String name)
     *  getMethods()
     *  getDeclaredMethod(String name, Class<?>... parameterTypes)
     *  getDeclaredMethods()
     *  使用invoke方法
 *  Constructor
 *   *  getConstructor(Class<?>... parameterTypes)
     *  getConstructors()
     *  getDeclaredConstructor(Class<?>... parameterTypes)
     *  getDeclaredConstructors()
     *  使用newInstance创建实例
 *  总结

# 什么是Java反射机制？ #

Java反射机制是 Java 语言的一个重要特性，它在服务器程序和中间件程序中得到了广泛运用。在服务器端，往往需要根据客户的请求，动态调用某一个对象的特定方法。此外，在 ORM 中间件的实现中，运用 Java 反射机制可以读取任意一个 JavaBean 的所有属性，或者给这些属性赋值

通过反射机制，可以在运行的时候访问到对象的属性、方法、构造方法等等

# 哪些地方用到反射机制？ #

其实我们都用过反射机制，只是并不知道它是反射机制而已。比如我们使用JDBC连接数据库的时候（Class.forName() 这个相信大家都用过），只是当时并没有在意那么多（心里想能用就行，管它呢），使用到反射机制的框架有（Spring、SpringMVC、Mybatis、Hibernate、Structs）

# 反射机制提供了哪些功能？ #

*  在运行时判定任意一个对象所属的类
 *  在运行时构造任意一个类的对象
 *  在运行时判定任意一个类所具有的成员变量和方法
 *  在运行时调用任意一个对象的方法
 *  生成动态代理

# 如何实现反射机制？ #

先来个实体类 Student

/** * @author Woo_home * @create by 2019/12/10 */
    public class Student { 
    
        private int id;
        private String name;
    
        public Student(){ }
        
        public int getId() { 
            return id;
        }
    
        public void setId(int id) { 
            this.id = id;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        @Override
        public String toString() { 
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

# 反射的三种实现方式 #

## 一、通过对象的getClass()方法 ##

getClass()方法是Object类的方法，因为所有类都继承自Object类，所以可以直接使用getClass()方法

public class ReflectDemo { 
        public static void main(String[] args) { 
            Student student = new Student();
            Class studentClass = student.getClass();
            System.out.println(studentClass);
        }
    }

## 二、通过类的.class属性 ##

直接获取一个类的class

public class ReflectDemo { 
        public static void main(String[] args) { 
            Class<?> studentClass = Student.class;
            System.out.println(studentClass);
        }
    }

## 三、通过Class类的forName()方法（常用） ##

Class.forName() 是一个静态方法

public class ReflectDemo { 
        public static void main(String[] args) { 
            // 使用 try、catch 处理异常
            try { 
                Class<?> studentClass = Class.forName("com.example.app.demo.Student");
                System.out.println(studentClass);
            }catch (ClassNotFoundException e){ 
                e.printStackTrace();
            }
        }
    }

public class ReflectDemo { 
        // 使用 throws 处理异常
        public static void main(String[] args) throws ClassNotFoundException{ 
                Class<?> studentClass = Class.forName("com.example.app.demo.Student");
                System.out.println(studentClass);
        }
    }

三种方法打印的结果都是一样的，如下图所示

![在这里插入图片描述][20191210173153449.png]

> **注意：** 这里的Class.forName()方法需要使用try、catch语句括住或者在方法或类中抛出ClassNotFoundException 异常，不然会报错

有些人就问了，为什么需要使用try、catch语句括住呢，来看下forName方法源码：  
可以看到forName需要抛出一个 ClassNotFoundException 异常，自然而然地你使用forName()方法也自然要抛出 **/** 处理日常了

@CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException { 
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

# 判断一个类是否为某个类的实例 #

## 1、instanceof ##

public class ReflectDemo { 
        public static void main(String[] args) { 
            HashMap<Integer,String> map = new HashMap<>();
            if (map instanceof Map){ 
                System.out.println("HashMap is Map instance");
            }
        }
    }

输出：HashMap is Map instance

## 2、isInstance ##

public class ReflectDemo { 
        public static void main(String[] args) { 
            HashMap<Integer,String> map = new HashMap<>();
            if (Map.class.isInstance(map)){ 
                System.out.println("HashMap is Map Instance");
            }
        }
    }

输出：HashMap is Map Instance

# 利用反射创建对象实例 #

## 1、通过Class对象的 newInstance() 方法 ##

public class ReflectDemo { 
        public static void main(String[] args) throws IllegalAccessException, InstantiationException { 
            // 这里的Student是使用上面一开始的Student类
            Class<?> studentClass = Student.class;
            
            // 使用newInstance创建实例
            Student student = (Student)studentClass.newInstance();
            student.setId(1);
            student.setName("John");
            System.out.println(student);
        }
    }

输出：John

## 2、通过Constructor对象的 getConstructor() 方法 ##

输出：John

# Field #

根据字段名获取字段（只能获取public的）

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchFieldException { 
            Class<?> classes = Student.class;
            Field id = classes.getField("id");
            Field name = classes.getField("name");
            System.out.println(id);
            System.out.println(name);
        }
    }
    
    class Student{ 
        public int id;
        public String name;
    }

输出：

> 以下为输出结果  
> public int com.example.app.demo.Student.id  
> public java.lang.String com.example.app.demo.Student.name

如果获取的字段是被private修饰的，那么将会抛出 NoSuchFieldException 异常

> 以下为输出结果  
> Exception in thread “main” java.lang.NoSuchFieldException: id  
> at java.lang.Class.getField(Class.java:1703)  
> at com.example.app.demo.ReflectDemo.main(ReflectDemo.java:12)

为什么会这样呢？我们朝着这个问题看下源码是怎么实现的

## getField(String name) ##

根据名称获取公有的（public）类成员

@CallerSensitive
    public Field getField(String name)
        throws NoSuchFieldException, SecurityException { 
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        
        // 可以看到在getField传入的name实际是调用getField0来实现的
        Field field = getField0(name);
        if (field == null) { 
            throw new NoSuchFieldException(name);
        }
        return field;
    }

### getField0(String name) ###

而getField0主要判断依据是searchFields，searchFields根据privateGetDeclaredFields判断

private Field getField0(String name) throws NoSuchFieldException { 
           
        Field res;
        // Search declared public fields
        if ((res = searchFields(privateGetDeclaredFields(true), name)) != null) { 
            return res;
        }
        // 省略部分代码...
        return null;
    }

### privateGetDeclaredFields(boolean publicOnly) ###

可以看到当privateGetDeclaredFields传入的值是true的时候表示使用的是 declaredPublicFields ，也就是说是public声明的字段，当传入的值为false的时候使用的是 declaredFields（所有声明字段）

private Field[] privateGetDeclaredFields(boolean publicOnly) { 
        checkInitted();
        Field[] res;
        ReflectionData<T> rd = reflectionData();
        if (rd != null) { 
            // 判断输入的布尔值是true还是false
            res = publicOnly ? rd.declaredPublicFields : rd.declaredFields;
            if (res != null) return res;
        }
        // 省略部分代码...
        return res;
    }

## getFields(String name) ##

获取所有 public 修饰的字段

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchFieldException { 
            Class<?> classes = Student.class;
            Field[] allField = classes.getFields();
            for (Field field : allField) { 
                System.out.println(field);
            }
        }
    }
    
    class Student{ 
        private int id;
        public String name;
    }

输出：

> 以下为输出结果  
> public java.lang.String com.example.app.demo.Student.name

可以看到我们的Student类中声明了一个private修饰的id和一个public修饰的name，根据输出结果可以知道getFields()方法只能获取public修饰的字段

看下实现源码：

在getFields中返回了一个copyFields方法，该方法中调用了 privateGetPublicFields 方法

@CallerSensitive
    public Field[] getFields() throws SecurityException { 
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        return copyFields(privateGetPublicFields(null));
    }

来看下privateGetPublicFields方法可以知道在该方法中调用了 privateGetDeclaredFields(true) 这个方法，关于这个方法上面已经讲述过

private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces) { 
        
        // Local fields
        Field[] tmp = privateGetDeclaredFields(true);
        addAll(fields, tmp);
    	
        // 省略部分代码...
        return res;
    }

## getDeclaredField(String name) ##

根据名称获取已声明的类成员。但不能得到其父类的类成员

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchFieldException { 
            Class<?> classes = Student.class;
            Field allField = classes.getDeclaredField("name");
            System.out.println(allField);
        }
    }
    
    class Student{ 
        private int id;
        private String name;
    }
    
    Class Student{ 
        public int id;
        public String name;
    }

输出：可以看到getDeclaredField()方法即可以获取public类型的字段也能获取private类型的字段

> 以下为输出结果：  
> private java.lang.String com.example.app.demo.Student.name
> 
> public java.lang.String com.example.app.demo.Student.name

来看下源码的原理

@CallerSensitive
    public Field getDeclaredField(String name)
        throws NoSuchFieldException, SecurityException { 
        checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
        Field field = searchFields(privateGetDeclaredFields(false), name);
        if (field == null) { 
            throw new NoSuchFieldException(name);
        }
        return field;
    }

可以看到 getDeclaredField() 方法调用的也是 privateGetDeclaredFields 方法，上面已经讲述过

## getDeclaredFields() ##

获取所有已声明的类成员变量

public class ReflectDemo { 
        public static void main(String[] args) { 
            Class<?> classes = Student.class;
            Field[] allField = classes.getDeclaredFields();
            for (Field field : allField) { 
                System.out.println(field);
            }
        }
    }
    
    class Student{ 
        public int id;
        public String name;
    }

输出：

> 以下为输出结果：  
> public int com.example.app.demo.Student.id  
> public java.lang.String com.example.app.demo.Student.name

而且 getDeclaredFields 还可以获取private修饰的字段

输出：

> 以下为输出结果：  
> private int com.example.app.demo.Student.id  
> private java.lang.String com.example.app.demo.Student.name

来看下源码 getDeclaredFields() 方法的源码

可以看到 getDeclaredFields() 方法中也是调用 privateGetDeclaredFields 方法的，并且这里的 privateGetDeclaredFields传入的值是 false ，也就是获取所有已声明的字段

@CallerSensitive
    public Field[] getDeclaredFields() throws SecurityException { 
        checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
        return copyFields(privateGetDeclaredFields(false));
    }

# Method #

## getMethod(String name) ##

返回类或接口的特定方法。其中第一个参数为方法名称，后面的参数为方法参数对应 Class 的对象的方法名

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException { 
            // 传入CaseMethod的方法名
            Method methods = CaseMethod.class.getMethod("caseOfMethod");
            System.out.println(methods);
        }
    }
    
    class CaseMethod{ 
        public void caseOfMethod(){ 
            System.out.println("case");
        }
    }

输出：

> 以下为输出结果：  
> public void com.example.app.demo.CaseMethod.caseOfMethod()

## getMethods() ##

获取类或接口的所有 public 方法，包括其父类的 public 方法

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException { 
            // 获取所有方法，使用Method数组接收
            Method[] methods = CaseMethod.class.getMethods();
            for (Method method : methods) { 
                System.out.println(method);
            }
        }
    }
    
    class CaseMethod{ 
        public void caseOfMethod(){ 
            System.out.println("case");
        }
    }

输出：

可以看到输出结果中第一个就是我们自定义的CaseMethod中的方法，其余的都是Object类的方法

> 以下为输出结果：  
> public void com.example.app.demo.CaseMethod.caseOfMethod()  
> public final void java.lang.Object.wait() throws java.lang.InterruptedException  
> public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException  
> public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException  
> public boolean java.lang.Object.equals(java.lang.Object)  
> public java.lang.String java.lang.Object.toString()  
> public native int java.lang.Object.hashCode()  
> public final native java.lang.Class java.lang.Object.getClass()  
> public final native void java.lang.Object.notify()  
> public final native void java.lang.Object.notifyAll()

## getDeclaredMethod(String name, Class<?>… parameterTypes) ##

获取类或接口的特定声明方法。其中第一个参数为方法名称，后面的参数为方法参数对应 Class 的对象

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException { 
            Method methods = CaseMethod.class.getDeclaredMethod("caseOfMethod",null);
            System.out.println(methods);
        }
    }
    
    class CaseMethod{ 
        public void caseOfMethod(){ 
            System.out.println("case");
        }
    
        private void caseOf(){ 
            System.out.println("case1");
        }
    }

## getDeclaredMethods() ##

获取类或接口声明的所有方法，包括 public、protected、默认（包）访问和 private 方法，但不包括继承的方法

public class ReflectDemo { 
        public static void main(String[] args) { 
            Method[] methods = CaseMethod.class.getDeclaredMethods();
            for (Method method : methods) { 
                System.out.println(method);
            }
        }
    }
    
    class CaseMethod{ 
        public void caseOfMethod(){ 
            System.out.println("case");
        }
    
        private void caseOf(){ 
            System.out.println("case1");
        }
    }

输出：

> 以下为输出结果：  
> public void com.example.app.demo.CaseMethod.caseOfMethod()  
> private void com.example.app.demo.CaseMethod.caseOf()

## 使用invoke方法 ##

当获取一个对象之后就可以使用invoke方法，invoke方法示例如下：

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { 
            Method methods = CaseMethod.class.getMethod("caseOfMethod");
            CaseMethod caseMethod = new CaseMethod();
            methods.invoke(caseMethod);
        }
    }
    
    class CaseMethod{ 
        public void caseOfMethod(){ 
            System.out.println("case");
        }
    
        private void caseOf(){ 
            System.out.println("case1");
        }
    }

输出：case

那么invoke是如何实现的呢？来看下源码

boolean override;
    
    @CallerSensitive
    public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
    InvocationTargetException
    { 
        
        // 判断override是否为true
        if (!override) { 
            // 判断modifiers（方法的修饰符）是否为public
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { 
                // 通过方法的修饰符（protected、private、）或声明类（如子类可以访问父类的protected方法）与caller之间的关系
                Class<?> caller = Reflection.getCallerClass();
                // 判断caller是否有权限方法该方法
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) { 
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

> **注意：** invoke方法如果提供了错误的参数，会抛出一个异常，所以要提供一个异常处理器。建议在有必要的时候才使用invoke方法，有如下原因：

*  1、invoke方法的参数和返回值必须是Object类型，意味着必须进行多次类型转换
 *  2、通过反射调用方法比直接调用方法要明显慢一些

# Constructor #

## getConstructor(Class<?>… parameterTypes) ##

获取类的特定 public 构造方法。参数为方法参数对应 Class 的对象

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { 
            Constructor<CaseMethod> constructor = CaseMethod.class.getConstructor(int.class, String.class);
            System.out.println(constructor);
        }
    }
    
    class CaseMethod{ 
    
        private int id;
        private String name;
        private int cap;
    
        public CaseMethod(int id,String name){ 
            this.id = id;
            this.name = name;
        }
    
        public CaseMethod(int cap){ 
    
        }
    }

输出：

> 以下为输出结果：  
> public com.example.app.demo.CaseMethod(int,java.lang.String)

## getConstructors() ##

获取类的所有 public 构造方法

public class ReflectDemo { 
        public static void main(String[] args) { 
            Constructor<?>[] constructors = CaseMethod.class.getConstructors();
            for (Constructor<?> constructor : constructors) { 
                System.out.println(constructor);
            }
        }
    }
    
    class CaseMethod{ 
    
        private int id;
        private String name;
        private int cap;
    
        public CaseMethod(int id,String name){ 
            this.id = id;
            this.name = name;
        }
    
        public CaseMethod(int cap){ 
    
        }
    }

输出：

> 以下为输出结果：  
> public com.example.app.demo.CaseMethod(int,java.lang.String)  
> public com.example.app.demo.CaseMethod(int)

## getDeclaredConstructor(Class<?>… parameterTypes) ##

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException { 
            // 注意：由于private修饰的CaseMethod构造函数没有参数，所以getDeclaredConstructor()可以为空
            // 默认的getDeclaredConstructor(Class<?>... parameterTypes)方法是要传参数类型的
            Constructor<CaseMethod> constructor = CaseMethod.class.getDeclaredConstructor();
            Constructor<CaseMethod> declaredConstructor = CaseMethod.class.getDeclaredConstructor(int.class, String.class);
            System.out.println(constructor);
            System.out.println(declaredConstructor);
        }
    }
    
    class CaseMethod{ 
    
        private int id;
        private String name;
        private int cap;
    
        private CaseMethod(){ 
    
        }
    
        public CaseMethod(int id,String name){ 
            this.id = id;
            this.name = name;
        }
    }

输出：

> 以下为输出结果：  
> private com.example.app.demo.CaseMethod()  
> public com.example.app.demo.CaseMethod(int,java.lang.String)

## getDeclaredConstructors() ##

获取类的所有构造方法

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException { 
            Constructor<?>[] constructors = CaseMethod.class.getDeclaredConstructors();
            for (Constructor<?> constructor : constructors) { 
                System.out.println(constructor);
            }
        }
    }
    
    class CaseMethod{ 
    
        private int id;
        private String name;
        private int cap;
    
        private CaseMethod(){ 
    
        }
    
        public CaseMethod(int id,String name){ 
            this.id = id;
            this.name = name;
        }
    }

输出：

> 以下为输出结果：  
> private com.example.app.demo.CaseMethod()  
> public com.example.app.demo.CaseMethod(int,java.lang.String)

## 使用newInstance创建实例 ##

public class ReflectDemo { 
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { 
            Constructor<CaseMethod> constructor = CaseMethod.class.getConstructor(String.class);
            CaseMethod caseMethod = constructor.newInstance("Lisa");
            System.out.println(caseMethod);
        }
    }
    
    class CaseMethod{ 
    
        private String name;
    
        public CaseMethod(String name){ 
            this.name = name;
        }
    
        @Override
        public String toString() { 
            return "CaseMethod{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

> 输出：  
> CaseMethod\{name=‘Lisa’\}

# 总结 #

Java获得Class对象的引用的方法中，**Class.forName()** 方法会自动初始化Class对象，而 **.class** 方法不会，**.class** 的初始化被延迟到静态方法或非常数静态域的首次引用

[20191210173153449.png]: https://img-blog.csdnimg.cn/20191210173153449.png