java 反射技术

阳光穿透心脏的1/2处 2022-05-29 10:52 206阅读 0赞

# 简介 #

> JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。（来源：百度百科）

## Class对象的常用方法　　 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>forName()</td> 
   <td>(1)获取Class对象的一个引用，但引用的类还没有加载(该类的第一个对象没有生成)就加载了这个类。<br> (2)为了产生Class引用，forName()立即就进行了初始化。</td> 
  </tr> 
  <tr> 
   <td>Object.getClass()</td> 
   <td>获取Class对象的一个引用，返回表示该对象的实际类型的Class引用。</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>取全限定的类名(包括包名)，即类的完整名字。</td> 
  </tr> 
  <tr> 
   <td>getSimpleName()</td> 
   <td>获取类名(不包括包名)</td> 
  </tr> 
  <tr> 
   <td>getCanonicalName()</td> 
   <td>获取全限定的类名(包括包名)</td> 
  </tr> 
  <tr> 
   <td>isInterface()</td> 
   <td>判断Class对象是否是表示一个接口</td> 
  </tr> 
  <tr> 
   <td>getInterfaces()</td> 
   <td>返回Class对象数组，表示Class对象所引用的类所实现的所有接口。</td> 
  </tr> 
  <tr> 
   <td>getSupercalss()</td> 
   <td>返回Class对象，表示Class对象所引用的类所继承的直接基类。应用该方法可在运行时发现一个对象完整的继承结构。</td> 
  </tr> 
  <tr> 
   <td>newInstance()</td> 
   <td>返回一个Oject对象，是实现“虚拟构造器”的一种途径。使用该方法创建的类，必须带有无参的构造器。</td> 
  </tr> 
  <tr> 
   <td>getFields()</td> 
   <td>获得某个类的所有的公共（public）的字段，包括继承自父类的所有公共字段。 类似的还有getMethods和getConstructors。</td> 
  </tr> 
  <tr> 
   <td>getDeclaredFields</td> 
   <td>获得某个类的自己声明的字段，即包括public、private和proteced，默认但是不包括父类声明的任何字段。类似的还有getDeclaredMethods和getDeclaredConstructors。</td> 
  </tr> 
 </tbody> 
</table>

## 实例对象的常用方法　 ##

### Java反射机制类： ###

java.lang.Class; //类 
    java.lang.reflect.Constructor;//构造方法 
    java.lang.reflect.Field; //类的成员变量 
    java.lang.reflect.Method;//类的方法
    java.lang.reflect.Modifier;//访问权限

### 1.）class对象的获取 ###

//第一种方式 通过对象getClass方法
    Person person = new Person();
    Class<?> class1 = person.getClass();
    //第二种方式 通过类的class属性
    class1 = Person.class;
    try {
        //第三种方式 通过Class类的静态方法——forName()来实现
        class1 = Class.forName("com.whoislcj.reflectdemo.Person");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

### 2.）获取class对象的摘要信息 ###

boolean isPrimitive = class1.isPrimitive();//判断是否是基础类型
    boolean isArray = class1.isArray();//判断是否是集合类
    boolean isAnnotation = class1.isAnnotation();//判断是否是注解类
    boolean isInterface = class1.isInterface();//判断是否是接口类
    boolean isEnum = class1.isEnum();//判断是否是枚举类
    boolean isAnonymousClass = class1.isAnonymousClass();//判断是否是匿名内部类
    boolean isAnnotationPresent = class1.isAnnotationPresent(Deprecated.class);//判断是否被某个注解类修饰
    
    String className = class1.getName();//获取class名字 包含包名路径
    Package aPackage = class1.getPackage();//获取class的包信息
    String simpleName = class1.getSimpleName();//获取class类名
    int modifiers = class1.getModifiers();//获取class访问权限
    
    Class<?>[] declaredClasses = class1.getDeclaredClasses();//内部类
    Class<?> declaringClass = class1.getDeclaringClass();//外部类

### 3.）获取class对象的属性、方法、构造函数等 ###

Field[] allFields = class1.getDeclaredFields();//获取class对象的所有属性
    Field[] publicFields = class1.getFields();//获取class对象的public属性
    try { Field ageField = class1.getDeclaredField("age");//获取class指定属性 Field desField = class1.getField("des");//获取class指定的public属性 } catch (NoSuchFieldException e) { e.printStackTrace(); }
    
    Method[] methods = class1.getDeclaredMethods();//获取class对象的所有声明方法
    Method[] allMethods = class1.getMethods();//获取class对象的所有方法 包括父类的方法
    
    Class parentClass = class1.getSuperclass();//获取class对象的父类
    Class<?>[] interfaceClasses = class1.getInterfaces();//获取class对象的所有接口
    
    Constructor<?>[] allConstructors = class1.getDeclaredConstructors();//获取class对象的所有声明构造函数
    Constructor<?>[] publicConstructors = class1.getConstructors();//获取class对象public构造函数
    try { Constructor<?> constructor = class1.getDeclaredConstructor(new Class[]{String.class});//获取指定声明构造函数
        Constructor publicConstructor = class1.getConstructor(new Class[]{});//获取指定声明的public构造函数
    } catch (NoSuchMethodException e) { e.printStackTrace(); }
    
    Annotation[] annotations = class1.getAnnotations();//获取class对象的所有注解
    Annotation annotation = class1.getAnnotation(Deprecated.class);//获取class对象指定注解
    
    Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 Type
    Type[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接口的type集合

### 4.）class对象动态生成 ###

//第一种方式 Class对象调用newInstance()方法生成
    Object obj = class1.newInstance();
    //第二种方式 对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成
    Constructor<?> constructor = class1.getDeclaredConstructor(new Class[]{ String.class});//获取指定声明构造函数
    obj = constructor.newInstance(new Object[]{"lcj"});

### 5.）动态调用函数 ###

try { // 生成新的对象：用newInstance()方法 Object obj = class1.newInstance(); //判断该对象是否是Person的子类 boolean isInstanceOf = obj instanceof Person; //首先需要获得与该方法对应的Method对象 Method method = class1.getDeclaredMethod("setAge", new Class[]{int.class});
        //调用指定的函数并传递参数
        method.invoke(obj, 28);
        method = class1.getDeclaredMethod("getAge");
        Object result = method.invoke(obj, new Class[]{});
    } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); }

### 6.)通过反射机制获取泛型类型 ###

例如下面这种结构

//People类
    public class People<T> { }
    //Person类继承People类
    public class Person<T> extends People<String> implements PersonInterface<Integer> { }
    //PersonInterface接口
    public interface PersonInterface<T> { }

获取泛型类型

Person<String> person = new Person<>();
    //第一种方式 通过对象getClass方法
    Class<?> class1 = person.getClass();
    Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 Type
    Type[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接口的Type集合
    
    getComponentType(genericSuperclass);
    getComponentType(interfaceTypes[0]);

getComponentType具体实现

private Class<?> getComponentType(Type type) { 
    Class<?> componentType = null;
    if (type instanceof ParameterizedType) { 
        //getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。
        Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();
        if (actualTypeArguments != null && actualTypeArguments.length > 0) {
        componentType = (Class<?>) actualTypeArguments[0];
        }
    } else if (type instanceof GenericArrayType) { 
        // 表示一种元素类型是参数化类型或者类型变量的数组类型
        componentType = (Class<?>) ((GenericArrayType) type).getGenericComponentType();
    } else {
        componentType = (Class<?>) type;
    }
    return componentType;
    }

### 6.)通过反射机制获取注解信息 ###

这里重点以获取Method的注解信息为例

try { //首先需要获得与该方法对应的Method对象 Method method = class1.getDeclaredMethod("jumpToGoodsDetail", new Class[]{String.class, String.class});
        Annotation[] annotations1 = method.getAnnotations();//获取所有的方法注解信息
        Annotation annotation1 = method.getAnnotation(RouterUri.class);//获取指定的注解信息
        TypeVariable[] typeVariables1 = method.getTypeParameters();
        Annotation[][] parameterAnnotationsArray = method.getParameterAnnotations();//拿到所有参数注解信息
        Class<?>[] parameterTypes = method.getParameterTypes();//获取所有参数class类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();//获取所有参数的type类型
        Class<?> returnType = method.getReturnType();//获取方法的返回类型
        int modifiers = method.getModifiers();//获取方法的访问权限
    } catch (NoSuchMethodException e) { e.printStackTrace(); }

## 反射机制的应用场景： ##

*  逆向代码 ，例如反编译
 *  与注解相结合的框架 例如Retrofit
 *  单纯的反射机制应用框架 例如EventBus 2.x
 *  动态生成类框架 例如Gson

# 反射应用： #

反射用到的技术不多，也不难理解，只是反射的应用特别灵活，真正是“只有想不到，没有做不到”

## 反射在Spring IoC中的应用 ##

> IOC：即“控制反转”，不是什么技术，而是一种思想。使用IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

在Spring的配置文件中，经常看到如下配置：

那么通过这样配置，Spring是怎么帮我们实例化对象，并且放到容器中去了了？对，就是通过反射！！！

下面是Spring通过配置进行实例化对象，并放到容器中的伪代码：

//解析<bean .../>元素的id属性得到该字符串值为“courseDao”  
    String idStr = "courseDao";  
    //解析<bean .../>元素的class属性得到该字符串值为“com.qcjy.learning.Dao.impl.CourseDaoImpl”  
    String classStr = "com.qcjy.learning.Dao.impl.CourseDaoImpl";  
    //利用反射知识，通过classStr获取Class类对象  
    Class<?> cls = Class.forName(classStr);  
    //实例化对象  
    Object obj = cls.newInstance();  
    //container表示Spring容器  
    container.put(idStr, obj);

通过解析xml文件，获取到id属性和class属性里面的内容，利用反射原理获取到配置里面类的实例对象，存入到Spring的bean容器中。

当一个类里面需要应用另一类的对象时，Spring的配置如下所示：

我们继续用伪代码的形式来模拟实现一下Spring底层处理原理：

//解析<property .../>元素的name属性得到该字符串值为“courseDao”  
    String nameStr = "courseDao";  
    //解析<property .../>元素的ref属性得到该字符串值为“courseDao”  
    String refStr = "courseDao";  
    //生成将要调用setter方法名  
    String setterName = "set" + nameStr.substring(0, 1).toUpperCase()  
            + nameStr.substring(1);  
    //获取spring容器中名为refStr的Bean，该Bean将会作为传入参数  
    Object paramBean = container.get(refStr);  
    //获取setter方法的Method类，此处的cls是刚才反射代码得到的Class对象  
    Method setter = cls.getMethod(setterName, paramBean.getClass());  
    //调用invoke()方法，此处的obj是刚才反射代码得到的Object对象  
    setter.invoke(obj, paramBean);

反射源码详解：[http://www.importnew.com/23902.html][http_www.importnew.com_23902.html]  
参考：[https://www.cnblogs.com/whoislcj/p/6038511.html][https_www.cnblogs.com_whoislcj_p_6038511.html]

[http_www.importnew.com_23902.html]: http://www.importnew.com/23902.html
[https_www.cnblogs.com_whoislcj_p_6038511.html]: https://www.cnblogs.com/whoislcj/p/6038511.html