您现在的位置是：首页 > Java

当前栏目

java 反射技术

JAVA 技术对象反射

2023-03-02 11:01:09 时间

# 简介 #

> 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

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

java 反射技术

相关文章