Java反射模式转载

概述1。反射机构
Java 反射机制是在运行状态下，对于任何类，都可以获得该类的所有属性和方法，对于任何对象，都可以调用其任何属性和方法。在运行时动态获取信息并动态调用对象的方法的函数称为 Java 反射机制。

Class 类与 java.lang.reflect 类库支持反射的概念，它包含 Field,Method,Constructor 类 (每个类实现 Member 接口)。这些类型的对象由使用 JVM 在运行时创建，以表示未知类的对应成员。

这样您就可以使用 Constructor 要创建新对象，请使用 get() 和 set() 方法读取和修改 Field 与对象关联的字段，使用 invoke() 方法调用和 Method 与对象关联的方法。此外，您可以拨打 getFields() getMethods() 和 getConstructors() 以及其他方便的方法，以返回表示字段、方法和构造函数的对象数组。这允许在运行时完全确定匿名对象的信息，而无需在编译时知道任何信息。

2.获取字节码的方法
在 Java 有三种方法可以获取类的字节码 (Class) 对象

通过 Object 类中的 getClass() 方法，则要使用此方法，必须明确特定的类并创建该类的对象。
所有数据类型都有一个静态属性.class 获取相应的 Class 对象但是，在调用类中的静态成员之前，仍然需要指定类。
只要给定类的字符串名称，就可以获得给定类的字节码对象，这更具可扩展性。通过 Class.forName() 方法完成时，必须指定类的完全限定名称，因为前两个方法是在知道类以获取类的字节码对象的情况下，因此不会出现异常， Class.forName() 方法如果写入了错误类的路径，则将报告该路径。 ClassNotFoundException 的异常。
package com.jas.reflect;

public class ReflectTest {
public static void main(String[] args) {

Fruit fruit = new Fruit();
Class<?> class1 = fruit.getClass();     //方法一

Class<?> class2 = Fruit.class;     //方法二

Class class3 = null;
try {    //方法3，如果此处未指定类的包名，则将报告 ClassNotFoundException 异常
class3 = Class.forName("com.jas.reflect.Fruit");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

System.out.println(class1 + "  " +class2 + "    " + class3);

}
}

class Fruit{}

3.通过反射机制获得类信息
对象是通过反射机制创建的，在创建对象之前获取对象的构造函数对象，并通过构造函数对象创建相应类的实例。

下面的代码在运行时创建一个没有参与参数的对象实例。由于 getConstructor() 方法与 newInstance() 方法抛出大量异常 (您可以通过源代码查看它们)，这里只是抛出一个直接 Exception，下同。

package com.jas.reflect;

import java.lang.reflect.Constructor;

public class ReflectTest {
public static void main(String[] args) throws Exception {

Class clazz = null;
clazz = Class.forName("com.jas.reflect.Fruit");
Constructor constructor1 = clazz.getConstructor();
Constructor constructor2 = clazz.getConstructor(String.class);

Fruit fruit1 = constructor1.newInstance();
Fruit fruit2 = constructor2.newInstance("Apple");

}
}

class Fruit{
public Fruit(){
System.out.println("无参数构造函数 Run...........");
}
public Fruit(String type){
System.out.println("带参数的构造函数 Run..........." + type);
}

}

输出：
无参数构造函数 Run………..
带参数的构造函数 Run………..Apple

通过反射机制获得 Class 中的属性。

package com.jas.reflect;

import java.lang.reflect.Field;

public class ReflectTest {
public static void main(String[] args) throws Exception {

Class<?> clazz = null;
Field field = null;

clazz = Class.forName("com.jas.reflect.Fruit");
//field = clazz.getField("num");       getField() 方法无法获取私有属性
// field = clazz.getField("type");     访问私有字段时，会报告该字段。 NoSuchFieldException 异常
field = clazz.getDeclaredField("type");     //获取私有 type 属性
field.setAccessible(true);  //取消选中对私有字段的访问
Fruit fruit = (Fruit) clazz.newInstance();  //创建无参数对象实例
field.set(fruit,"Apple");   //为无参数对象实例属性指定值
Object type = field.get(fruit); //通过 fruit 对象以获取属性值

System.out.println(type);
}
}

class Fruit{
public int num;
private String type;

public Fruit(){
System.out.println("无参数构造函数 Run...........");
}
public Fruit(String type){
System.out.println("带参数的构造函数 Run..........." + type);
}

}

输出：
无参数构造函数 Run………..
Apple

通过反射机制获得 Class 方法，然后运行。

package com.jas.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectTest {
public static void main(String[] args) throws Exception {

Class clazz = null;
Method method = null;

clazz = Class.forName("com.jas.reflect.Fruit");
Constructor fruitConstructor = clazz.getConstructor(String.class);
Fruit fruit = fruitConstructor.newInstance("Apple");    //创建参数对象实例

method = clazz.getMethod("show",null);  //获取Null参数 show 方法
method.invoke(fruit,null);  //执行无参数方法

method = clazz.getMethod("show",int.class); //获取有参 show 方法
method.invoke(fruit,20);  //使用参数执行方法

}
}

class Fruit{
private String type;

public Fruit(String type){
this.type = type;
}
public void show(){
System.out.println("Fruit type = " + type);
}
public void show(int num){
System.out.println("Fruit type = " + type + ".....Fruit num = " + num);
}
}

输出：
Fruit type = Apple
Fruit type = Apple…..Fruit num = 20

简单应用4。反射机制（使用简单工厂创建对象）
Class.forName() 生成的结果与编译时无关，因此在执行时提取所有方法特征签名信息。反射机制可以创建一个在编译时完全未知的对象，并调用该对象上的方法。

以下是通过工厂类创建不同类型实例的反射机制和泛型的应用程序。

创建对象的实例类 Apple ：

package com.jas.reflect;

public interface Fruit {}
class Apple implements Fruit{}

已加载配置文件 config.properties：

Fruit=com.jas.reflect.Apple
1
工厂类 BasicFactory ：

package com.jas.reflect;

import java.io.FileReader;
import java.util.Properties;

public class BasicFactory {
private BasicFactory(){}

private static BasicFactory bf = new BasicFactory();
private static Properties pro = null;

static{
pro = new Properties();
try{
//通过类加载器加载配置文件
pro.load(new FileReader(BasicFactory.class.getClassLoader().
getResource("config.properties").getPath()));
}catch (Exception e) {
e.printStackTrace();
}
}

public static BasicFactory getFactory(){
return bf;
}

//使用泛型获取泛型对象
public   T newInstance(Class clazz){
String cName = clazz.getSimpleName();   //获取字节码对象的类名
String clmplName = pro.getProperty(cName);   //根据字节码对象的类名，从配置文件中获取类的完全限定名

try{
return (T)Class.forName(clmplName).newInstance();   //基于类的完全限定名称创建实例对象
}catch (Exception e) {
throw new RuntimeException(e);
}

}
}

要创建对象实例，请执行以下操作：

package com.jas.reflect;

public class ReflectTest {
public static void main(String[] args) throws Exception {
Fruit fruit = BasicFactory.getFactory().newInstance(Fruit.class);
System.out.println(fruit);
}
}

输出
com.jas.reflect.Apple@4554617c

上面的示例通过工厂创建不同对象的实例，这样可以减少代码的耦合，代码已经大大扩展，以前创建过。 Apple 对象需要通过 new 关键字创建 Apple 对象，如果我们还想创建 Orange 那物体呢？你也想通过吗？ new 关键字创建实例并向上转换 Fruit 这样做很麻烦。

现在我们直接有了工厂。只要在配置文件中配置要创建的对象的信息，就可以创建任何类型的对象。是不是简单多了？可见反射机制的价值是惊人的。

Spring 中的 IOC 的基本实现原理是反射机制，Spring 容器将帮助我们创建一个实例，容器中使用的方法是反射，通过解析 xml 文件，获取 id 属性和 class 属性，使用反射原理在配置文件中创建类的实例对象，并将其保存到 Spring 的 bean 容器中。

参考书：
《Java 编程思想 Bruce Eckel 著 陈昊鹏 译

---

作者：喷口，喷口
来源：CSDN
原文：https://blog.csdn.net/codejas/article/details/78635926
版权声明：本文为博主原创文章，转载请附上博客链接！