java高级编程——Class类与反射机制

Love The Way You Lie 2022-01-26 01:15 296阅读 0赞

### 文章目录 ###

*  Class类
 *   *  类的加载过程
     *  类的加载时机
     *  类加载器
 *  java的反射机制
 *   *  获取Class对象的三种方法
     *  通过反射实例化对象
     *  通过反射调用构造方法
     *  通过反射调用成员方法
     *  通过反射访问成员变量
 *  反射的简单应用
 *   *  反射运行配置文件内容
     *  利用反射越过泛型检查

很早之前就已经学过反射了，但是一直没有机会总结，最近在学习Spring框架的底层原理，频繁的遇到反射机制，借此机会稍微总结一下。几乎所有的开发框架以及应用技术都是基于反射技术的应用，所有这块知识非常重要，不掌握就没有办法了解框架的底层。

# Class类 #

反射机制和java.lang.Class< T >这个类息息相关，因为整个反射机制就是基于对Class对象的操作。了解反射机制前，我们需要先了解Class这个类。

Class这个类名，很特殊的一个名字吧，那么它的意义一定非同一般。一句话，**Class这个类就表示正在运行的Java应用程序中的类和接口**。如果把一个类比作一个人的话，那么Class对象就相当于这个人的资料卡片，关于这个人的一切都在这个小小的资料卡片中存储着。

介绍Class类，我们需要稍微了解一下java中关于类的加载机制。

## 类的加载过程 ##

当我们在程序中使用一个类时，java虚拟机会先判断这个类是否已经加载进内存，如果没有，就会按照下面的步骤进行类的初始化：

1.  加载
2.  链接
3.  初始化

**所谓加载**，就是把\*.class文件加载进内存，并为之创建一个Class对象，这个Class对象保存了关于这个类的所有信息，所有的类初次使用都会创建一个Class对象。Class对象在内存中只有一个，如果一个类多次使用，不会再重复创建Class对象，虚拟机会自己判断。

**所谓链接**，分为大概三个过程，

1.  验证 : 是否有正确的内部结构，并和其他类协调一致
2.  准备 : 负责为类的静态成员分配内存，并设置默认初始化值
3.  解析： 把类中的符号引用转换为直接引用

**所谓初始化**，就是访问该类的父类中的成员和方法，完成对子类的初始化。

## 类的加载时机 ##

那么，一个类什么时候才会被加载呢？也就是类的加载时机，大致有这么几个场景：

1.  创建类的实例；
2.  访问类的静态变量，后者为静态变量赋值；
3.  调用类的静态方法；
4.  使用反射方式来强制创建某个类或者接口对应的java.lang.Class对象；
5.  初始化某个类的子类；
6.  直接使用java.exe命令来运行某一个主类；

还需要提到的一个概念就是类的加载器，它负责将.Class文件加载到内存中，并为之生成相应的Class对象。

## 类加载器 ##

Class 这个类并没有提供公共的构造方法，它是由虚拟机通过调用类加载器中defineClass()方法来创建的。

类加载器分为以下几种类型:

1.  Bootstrap ClassLoader - 根类加载器
2.  Extension ClassLoader - 扩展类加载器
3.  Sysetm ClassLoader - 系统类加载器

作用：

1.  **根类加载器**：负责java核心类的加载 System String ……
2.  **扩展类加载器**：负责JRE的扩展目录中的jar包的加载。
3.  **系统类加载器**：负责在JVM启动时加载来自java命令的class文件

# java的反射机制 #

一个很关键的概念，叫做RTTI（Run-Time Type Identification）运行时类型识别。  
JVM虚拟机要运行我们的程序，就必须知道我们的每一个对象所属的类和这个类的所有信息，这就是运行时类型识别。

RTTI分为两种：

1.  编译器已经确定类型
2.  反射机制

我们回想一下，一般来说，我们创建一个对象，都是基于 `类名 对象名 = new 类名 (形参列表)` 这种形式利用公共的构造函数来创建一个对象。这就是所谓的编译器已经确定类型。而我们的反射，是在运行时才确定类型的，也就是说，java反射机制使得在运行状态中，对于任意一个类，虚拟机都能够知道这个类的所有属性和方法，对于任意一个对象，虚拟机都能够调用它的任意一个方法和属性。**这种动态获取的信息以及动态调用对象的方法的功能称为java的反射机制**。

要想使用反射，我们就必须获取到这个类的Class对象，因为Class对象保存了所有关于这个类的信息。

## 获取Class对象的三种方法 ##

1.  方法一：调用Object类的getClass()方法

// 调用Object类中的getClass方法来获取Class对象
    Date date = new Date();
    // 使用这种方法获取Class对象必须要有一个实例对象
    Class aClass = date.getClass();

// Class中的getName方法用来返回类名
    System.out.println(aClass.getName());
    // java.util.Date

这个程序通过Date类的实例化对象，调用了从Object类继承来的getClass方法，这样就取得了java.util.Date类型的反射操作类对象，通过getName()方法可以直接输出其完整名称。

1.  方法二：使用类的静态属性class获取

// 通过类的静态属性class来获取Class对象
     Class<Date> aClass1 = Date.class;

这是一种比较特殊的格式，而且不只是java的核心类，所有的类（包括自己写的）都有这个静态属性，所以不必担心自己创建的类没法通过这种方法来获取Class对象。

1.  方法三：调用Class类提供的forName()方法  
    `static Class<?> forName(String className) throws ClassNotFoundException`  
    返回带有给定字符串名的类或接口相关联的Class对象，className是类的全限定名。

Class<?> aClass2 = Class.forName("java.util.Date");

本程序使用Class类的静态方法forName来获取Class对象，如果通过className找到了这个类，就不会抛出‘ClassNotFoundException’的异常。

以上提到的三种常见的Class类的实例化方法几乎在所有的开发框架中都会用到，也很难分辨出那种方法使用的更多，三种方法都有各自适用的场景。

*  利用“getClass()”方法操作往往出现在简单的javaBean与提及参数的自动赋值操作中，比如Struts、SpringMVC都会体用表单参数和javaBean属性的绑定。
 *  利用“类.class”静态属性的方法往往是将反射操作的类型设置交给用户使用，想Hibernate中进行数据及保存以及根据ID查询中会使用到此类操作。
 *  利用“Class.forName()”方法可以实现配置文件以及Annotation配置的反射操作，几乎所有的开发框架都是依靠次方式实现的。

## 通过反射实例化对象 ##

我们已经学会了怎用获取一个类的Class对象，有了这个Class对象，我们就可以利用它来进行类的反射控制了。  
Class类有几个常用的方法需要了解一下：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>static Class&lt;?&gt; forName(String className) throws ClassNotFoundException</code></td> 
   <td>获取某个类的Class对象</td> 
  </tr> 
  <tr> 
   <td><code>public Class&lt;?&gt;[] getInterfaces()</code></td> 
   <td>获取类实现的所有接口</td> 
  </tr> 
  <tr> 
   <td><code>public String getName()</code></td> 
   <td>获取反射操作类的全名</td> 
  </tr> 
  <tr> 
   <td><code>public String getSimplename()</code></td> 
   <td>获取反射操作类的类名</td> 
  </tr> 
  <tr> 
   <td><code>public Package getPackage()</code></td> 
   <td>获取反射操作类所在的包</td> 
  </tr> 
  <tr> 
   <td><code>public Class&lt;? super T&gt;()</code></td> 
   <td>获取反射操作类的父类</td> 
  </tr> 
  <tr> 
   <td><code>public boolean isEnum()</code></td> 
   <td>判断反射操作类是否是枚举类</td> 
  </tr> 
  <tr> 
   <td><code>public boolean isInterface()</code></td> 
   <td>判断反射操作类是否是接口</td> 
  </tr> 
  <tr> 
   <td><code>public boolean isArray()</code></td> 
   <td>判断反射操作类是否是数组</td> 
  </tr> 
  <tr> 
   <td><code>public T newInstance() throws InstantiationException,IllegalAccessException</code></td> 
   <td>获取反射操作类的实例化对象</td> 
  </tr> 
 </tbody> 
</table>

通过这些方法我们可以发现，在反射操作中类或者接口都是利用Class来包装的，利用Class类可以表示任意类、枚举、接口、数组等引用类型的操作。

这一小节的关键方法在**newInstance**方法，我们就是用它来创建我们的反射操作类的实例化对象的。

值得注意的是，**使用newInstance()方法来实例化对象，那么这个类型中一定要提供无参构造方法**。

public static void main(String[] args) throws ClassNotFoundException, 
    	IllegalAccessException, InstantiationException {
        
    	    // 获取Class对象
    	    Class<?> aClass2 = Class.forName("java.util.Date");
    	    // 获取Date类的实例化对象
    	    Date newInstance = (Date) aClass2.newInstance();
    	
    	    System.out.println(newInstance);
    	    //    Mon May 27 21:26:55 CST 2019
    }

可以发现，这个程序中并没有使用new关键字来创建Date类的对象，而是通过由Date类创建的Class对象的newInstance()方法来创建Date对象的，newInstance方法默认访问的是Date类中的无参构造方法，返回的类型是Object类型，根据需要向下转型。  
可以利用一下方法来判断是否可以转型为某个类型：

//判断这个对象能不能被转化为这个类
    class.inInstance(obj)

比如：

Class<?> aClass2 = Class.forName("java.util.Date");
     // Date 能不能转换成 String ?
     boolean b = aClass2.isInstance(new String());
     System.out.println(b); //false

好吧，现在我们已经掌握了通过反射机制创建一个类对象，可是，问题来了？你可能想说，这么做有什么用啊？我简简单单的用new实例化一个类不好吗？你整这么多行代码不都是创建对象吗？

首先，必须承认，通过new进行对象的实例化是最正统的做法，也是使用最多的方法。但是通过new实例化对象时需要明确的指定类的构造方法，所以new也是造成代码耦合的最大元凶！要想解决代码的耦合问题，就要先解决关键字 new 来创建对象的操作。比如，来看一个简单的工厂模式：

package com.xx.test1;
    
    interface Animal{
        
        public void eat();
    }
    
    class Dog implements Animal{
        
        public Dog() {
        
            System.out.println("Dog构造方法");
        }
    
        @Override
        public void eat() {
        
            System.out.println("我爱吃骨头");
        }
    }
    
    class Cat implements Animal{
        
    
        public Cat() {
        
            System.out.println("Cat构造方法");
        }
    
        @Override
        public void eat() {
        
            System.out.println("我爱吃鱼");
        }
    }
    
    class Factory{
        
        public static Animal getInstance(String animalName){
        
            if(animalName.equals("Cat")) return new Cat();
            else if(animalName.equals("Dog")) return  new Dog();
            else return null;
        }
    }
    
    class Factory{
        
        public static Animal getInstance(String animalName){
        
            if(animalName.equals("Cat")) return new Cat();
            else if(animalName.equals("Dog")) return  new Dog();
            else return null;
        }
    }
    
    public class newIssue {
        
    
        public static void main(String[] args) {
        
            Animal dog = Factory.getInstance("Dog");
            Animal cat = Factory.getInstance("Cat");
            dog.eat();
            cat.eat();
        }
    
    }
    // 运行结果：
    Dog构造方法
    Cat构造方法
    我爱吃骨头
    我爱吃鱼

这个程序的最大问题在于，我每新增加一个动物，就需要在Factory中改动代码，因为new这个关键字需要访问到子类的构造方法，我们需要在Factory中去调用。这就是耦合，很麻烦不是吗?我们可以利用反射机制对工厂类进行改造：

class Factory {
        
        public static Animal getInstance(String animalName) {
        
            //if(animalName.equals("Cat")) return new Cat();
            //else if(animalName.equals("Dog")) return  new Dog();
            //else return null;
            Animal animal = null;
            try {
        
            	// 使用反射来创建对象返回
                Class aClass = Class.forName(animalName);
                animal = (Animal) aClass.newInstance();
            } catch (Exception e) {
        
                System.out.println("该类型不存在");
            } finally {
        
                return animal;
            }
        }
    }

你看，这么一来，不管有多少动物，我们都无需对工厂类再做改动。

在实际的开发中，如果将以上的工厂模式再结合上一些配置文件，常用的是XML文件，就可以利用配置文件来动态定义项目中的所需的操作类，此时程序将会变得十分灵活。

值得一提的是，使用new关键字仍是创建对象最正统的方法，在应用开发中（非架构层次的开发）大部分都使用它而不是反射。

## 通过反射调用构造方法 ##

上面提到了，使用newInstance方法来实例化对象有一个要求就是类中必须提供无参构造方法，但是，实际中由于开发者个人原因，可能只会提供有参构造方法，此时就会报错。解决这个问题的方法就是使用反射调用构造方法。Class类为我们提供了这样的方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public Constructor&lt;?&gt;[] getConstructors() throws SecurityException</code></td> 
   <td>获取反射操作类中的所有构造方法</td> 
  </tr> 
  <tr> 
   <td><code>public Constructor&lt;T&gt; getConstructor(Class&lt;?&gt;... parameterTypes) throws NoSuchMethodException,SecurityException</code></td> 
   <td>获取指定参数类型的构造方法</td> 
  </tr> 
 </tbody> 
</table>

这两个方法会返回类中的构造方法，是Constructor类型，Constructor有些常用方法需要了解一下：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public Class&lt;?&gt;[] getExceptionTypes()</code></td> 
   <td>获取构造方法上抛出的所有异常的类型</td> 
  </tr> 
  <tr> 
   <td><code>public int getModifiers()</code></td> 
   <td>获取构造方法上的修饰符</td> 
  </tr> 
  <tr> 
   <td><code>public String getName()</code></td> 
   <td>获取构造方法的名字</td> 
  </tr> 
  <tr> 
   <td><code>public String getParameterCount</code></td> 
   <td>获取构造方法的形参个数</td> 
  </tr> 
  <tr> 
   <td><code>public Class&lt;?&gt;[] getParameterTypes()</code></td> 
   <td>获取构造方法中的参数类型</td> 
  </tr> 
  <tr> 
   <td><code>public T newInstance(Object... initargs)</code></td> 
   <td>调用指定参数的构造实例化类对象</td> 
  </tr> 
 </tbody> 
</table>

一个有趣的方法是`public int getModifiers()`，获取构造方法上的修饰符，发现了吗，它返回的是int类型。实际上，所有的修饰符都是一个数字，修饰符的组成就是数字的加法操作，比如public用1表示，static用8表示，那么public static 就是1+8=9。在java.lang.reflect.Modifer类中明确定义了各个修饰符对应的常量操作，同时也提供了将数字转成修饰符的方法`public static String toString(int mod)`。

可以看到，Constructor类中也提供了`newInstance`方法来实例化对象，我们取得了有参构造的Constructor对象，就用它来执行以实例化对象：

package com.xx.test1;
    
    import java.lang.reflect.*;
    
    class Student{
        
        String name;
        Integer age;
    
        public Student(String name, Integer age) {
        
            this.name = name;
            this.age = age;
            System.out.println("有参构造方法执行了");
        }
    
        public Student() {
        
            System.out.println("无参构造方法执行了");
        }
    }
    
    public class GetCons {
        
    
        public static void main(String[] args) throws Exception {
        
            Class aClass = Class.forName("com.xx.test1.Student");
            // 调用有参构造
            Constructor<Student> constructor = aClass.getConstructor(String.class, Integer.class);
            // 使用有参构造的newInstance方法来实例化对象
            Student student = constructor.newInstance("张三", 19);
            
        }
    }

这样，就可以明确指定用有参构造方法来实例化对象了。

另外，如果构造方法是私有的，就需要用另外一种方法来获取`public Constructor<?>[] getDeclaredConstructors()`获取所有的构造方法，包括私有的。或者`public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)`获取单个的构造方法包含私有的。

## 通过反射调用成员方法 ##

方法是类的主要操作手段，以往我们调用一个方法是通过`对象.方法名`的方式，通过反射也可以实现类方法的操作。一样，它也是通过操作Class对象来完成的。  
具体方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public Method[] getMethods()</code></td> 
   <td>获取所有的成员方法，不包括私有</td> 
  </tr> 
  <tr> 
   <td><code>public Method[] getDeclaredMethods()</code></td> 
   <td>获取所有的成员方法，包括私有</td> 
  </tr> 
  <tr> 
   <td><code>public Method getMethod(String name,Class&lt;?&gt;... parameterTypes)</code></td> 
   <td>通过指定参数类型的Class对象获取单个成员方法，不包括私有</td> 
  </tr> 
  <tr> 
   <td><code>public Method getDeclaredMethod(String name,Class&lt;?&gt;... parameterTypes)</code></td> 
   <td>通过指定参数类型的Class对象获取单个成员方法，包括私有</td> 
  </tr> 
 </tbody> 
</table>

其实有一个规律，如果你想用私有方法，就必须要使用getDeclaredXxxxx()这个方法，前面获取私有的构造方法也是一样的。

上述的方法会返回java.lang.reflect.Method类型的对象或者数组对象，有必要了解Method类型的常用方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public Class&lt;?&gt;[] getExceptionTypes()</code></td> 
   <td>获取方法抛出的异常类型</td> 
  </tr> 
  <tr> 
   <td><code>public int getModifiers()</code></td> 
   <td>获取方法的修饰符</td> 
  </tr> 
  <tr> 
   <td><code>public Class&lt;?&gt; getReturnType()</code></td> 
   <td>获取方法的返回值类型</td> 
  </tr> 
  <tr> 
   <td><code>public int getParameterCount()</code></td> 
   <td>获取方法中定义的参数数量</td> 
  </tr> 
  <tr> 
   <td><code>public Class&lt;?&gt;[] getParameterTypes()</code></td> 
   <td>获取方法中定义的所有参数类型</td> 
  </tr> 
  <tr> 
   <td><code>public Object invoke(Object obj,Object... args)</code></td> 
   <td>反射调用方法并且传递参数</td> 
  </tr> 
 </tbody> 
</table>

这些方法中最重要的就是这个invoke方法了，它是实现反射调用方法的核心操作。

必须之处，**任何情况下调用方法都必须产生类的实例化对象**，反射也不例外，invoke方法接收的第一个参数就是一个实例化对象，不过，它不需要指定具体的对象类型，我们通过Class对象的newInstance方法获取到的实例化对象是一个obj类型，不需要向下转型，可以直接当做参数传递。

还有一个需要注意的是，获取到私有方法的method对象之后，**要想通过invoke方法来调用，必须设置或者取消访问检查（使用继承父类（AccessibleObject类）来的setAccessible()方法）**，以达到执行私有方法的目的。

举个例子：

package com.xx.test1;
    
    import java.lang.reflect.*;
    
    class Student {
        
       
        public Student() {
        
            System.out.println("无参构造方法执行了");
        }
    
        public void doA(String s) {
        
            System.out.println("公有方法执行了" + s);
        }
    
        private void doB(Integer i) {
        
            System.out.println("私有方法执行了" + i);
        }
    
    }
    
    public class GetCons {
        
    
        public static void main(String[] args) throws Exception {
        
            Class aClass = Class.forName("com.xx.test1.Student");
    
            // 获取公有方法，第一个参数name是方法名
            // 第二个parameterTypes参数是以声明顺序标识方法的形式参数类型的Class对象的数组,可以是null
            Method doA = aClass.getMethod("doA", String.class);
            // 通过Student类的Class对象的newInstance方法获取实例化对象，不需要转型
            Object obj = aClass.newInstance();
            // 执行方法，第一个参数是对象，第二个参数是参数
            doA.invoke(obj, "hahaha");
    
            // 反射调用私有方法
            Method doB = aClass.getDeclaredMethod("doB", Integer.class);
            // 取消访问检查
            doB.setAccessible(true);
            // 执行方法
            doB.invoke(obj, 10000);
        }
    }
    // 运行结果：
    // 无参构造方法执行了
    // 公有方法执行了hahaha
    // 私有方法执行了10000

在这个案例中，我们的Student类中有一个无参构造，有一个公有方法doA，和一个私有方法doB，我们利用反射都可以获取到并且调用，前提是获得这个类的实例化对象。

既然提到了反射访问私有方法，有人就不明白了，我们都清楚java的特性之一就是封装，现在使用反射机制，那么封装性会不会被破坏了？

答案当然是否定的，我们都知道，封装的意义在于对外部隐藏具体的细节，只暴露实现功能的具体方法，这样有利于数据的安全性。也就是说，仅仅通过公有的方法我们就可以实现这个类的所有功能，通过反射来获取私有类是没有任何意义的，不仅实现不了功能，可能还会报错。反射就相当于你看病时医生使用的X光片，医生  
（开发者）可以通过它来查看问题，普通的病人看不懂也用不着来看。所以说，封装性并没有被破坏，反而提高了java语言的灵活性。

## 通过反射访问成员变量 ##

成员的获取依然要通过Class类的方法。成员有变量有常量之分，并且部分成员还有可能是从父类继承过来的。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public Field[] getFields()</code></td> 
   <td>获取所有的成员变量包含从父类继承过来的</td> 
  </tr> 
  <tr> 
   <td><code>public Field[] getDeclaredFields()</code></td> 
   <td>获取所有的成员变量 包含私有的 也包含从父类继承过来的成员变量</td> 
  </tr> 
  <tr> 
   <td><code>public Field getField(String name)</code></td> 
   <td>获取单个成员变量包含从父类继承过来的</td> 
  </tr> 
  <tr> 
   <td><code>public Field getDeclaredField(String name)</code></td> 
   <td>获取单个成员变量 包含私有的 也包含从父类继承过来的成员变量</td> 
  </tr> 
 </tbody> 
</table>

这四种方法返回的类型都是java.lang.reflect.Field类型，这个类用来描述类中的成员信息。  
Field类常用的方法有：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public Class&lt;?&gt; getType()</code></td> 
   <td>获取该成员的类型</td> 
  </tr> 
  <tr> 
   <td><code>public Object get(Object obj)</code></td> 
   <td>获取指定对象中的成员的内容，相当于直接访问成员</td> 
  </tr> 
  <tr> 
   <td><code>public void set(Object obj,Object value)</code></td> 
   <td>设置指定对象中的成员内容，相当于直接利用对象调用成员设置内容</td> 
  </tr> 
 </tbody> 
</table>

实际在Field中还定义了许多setXxx()，getXxx()方法，可以直接设置这些方法或方法具体的类型。

再次重申，不管使用反射调用普通方法还是成员，都必须存在实例化对象（通常依靠反射获取），因为类中的属性必须在类产生实例化对象（有堆内存空间）后才可以使用。

举个例子：

package com.xx.test1;
    
    import java.lang.reflect.*;
    
    class Student {
        
        private String name;
    
        public Student() {
        
        }
    }
    
    public class GetCons {
        
    
        public static void main(String[] args) throws Exception {
        
            Class aClass = Class.forName("com.xx.test1.Student");
            // 实例化Student类
            Object obj = aClass.newInstance();
            // 获取成员对象
            Field nameField = aClass.getDeclaredField("name");
            // 取消封装
            nameField.setAccessible(true);
            // 赋值
            nameField.set(obj, "James");
            // 相当于Student类对象.name
            Object o = nameField.get(obj);
            // 输出
            System.out.println(o);
        }
    }

我们在访问私有方法和私有成员都用到了这句代码`对象.setAccessible(true);`，这个方法是`public void setAccessible(boolean flag) throws SecurityException`，如果设置为true则表示此内容可以被直接操作，它是AccessibleObject类中的方法。AccessibleObject类是Filed和Executable类的父类，而Executable类又是Constuctor类和Method类的父类，所以**Filed，Constuctor，Method这三个类都可以使用这个方法来取消封装**。

# 反射的简单应用 #

## 反射运行配置文件内容 ##

需求：通过配置文件的内容来动态创建类对象，调用类中的set方法为对象赋处置，并调用指定方法。

1.  配置文件reflect.properties

# 反射操作类
    className=com.xx.apply.User
    # 初值
    name=James
    age=19
    # 方法名
    methodName=showUser

1.  User类

package com.xx.apply;
    
    public class User {
        
        private String name;
        private Integer age;
    
        public User() {
        
    
        }
    
        public String showUser() {
        
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Integer getAge() {
        
            return age;
        }
    
        public void setAge(Integer age) {
        
            this.age = age;
        }
    
    
    }

1.  测试类

package com.xx.apply;
    
    import java.io.FileReader;
    import java.lang.reflect.Method;
    import java.util.Properties;
    
    
    public class Test {
        
    
        public static void main(String[] args) throws Exception {
        
            //    首先要读取配置文件
            Properties properties = new Properties();
            properties.load(new FileReader("src\\com\\xx\\apply\\reflect.properties"));
            // 获取指定参数
            String className = properties.getProperty("className");
            String userName = properties.getProperty("name");
            String userAge = properties.getProperty("age");
            String methodName = properties.getProperty("methodName");
            //    获取User类的Class对象
            Class<?> aClass = Class.forName(className);
            User user = (User) aClass.newInstance();
            //    为user对象通过set方法设值
            user.setAge(Integer.valueOf(userAge));
            user.setName(userName);
            //    调用指定方法
            Method method = aClass.getMethod(methodName);
            Object invoke = method.invoke(user);
            System.out.println(invoke);
            // User{name='James', age=19}
    
        }
    }

大概过程就是这样，有缺陷的地方就是需要赋初值的set方法需要自己写，如果把它改为配置文件写，测试类获取，采用动态拼串的方法就非常完美了。这种应用其实就是IOC的雏形，即所谓的控制反转。这里思想一致，但效果太小儿科了，过两天在Spring分类里我会写一个比较完善的IOC例子。

## 利用反射越过泛型检查 ##

如果我有一个`ArrayList<Integer>`的对象，我想在这个集合中添加一个字符串数据，如何实现呢？我们都知道泛型指定的类型会在编译器进行校验，既然我们不能在编译器进行，就只能在运行期完成。因为泛型到了运行期以后，泛型会自动擦除，那么要在运行期完成这个需求,那么我们就需要使用反射。

具体实现：

package com.xx.apply;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Test2 {
        
        public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        
            List<Integer> list = new ArrayList<Integer>();
            // 泛型在编译期会进行类型校验，我们只能插入Integer类型的数据
            list.add(1);
            // 而不能插入String类型的数据
            //list.add("sss");
    
            //    使用反射来插入，反射是在运行期操作的，此时泛型已经擦除
            Class<? extends List> aClass = list.getClass();
            Method add = aClass.getMethod("add", Object.class);
            add.invoke(list, "测试");
            //    输出
            System.out.println(list);
            // [1, 测试]
        }
    }

这个应用暂时还想不到有什么实际用处，有点鸡肋，姑且当个好玩的图个乐子吧。

全文完。