Java反射机制

最新推荐文章于 2024-08-16 14:06:47 发布

acjunt

最新推荐文章于 2024-08-16 14:06:47 发布

阅读量179

点赞数

分类专栏： Java基础

Java基础专栏收录该内容

15 篇文章

订阅专栏

Java反射机制

转载自：http://www.cnblogs.com/luoxn28/p/5686794.html

要想理解反射的原理，首先要了解什么是类型信息。Java让我们在运行时识别对象和类的信息，主要有2种方式：一种是传统的RTTI，它假定我们在编译时已经知道了所有的类型信息；另一种是反射机制，它允许我们在运行时发现和使用类的信息。

一.Class对象
理解RTTI在Java中的工作原理，首先需要知道类型信息在运行时是如何表示的，这是由Class对象来完成的，它包含了与类有关的信息。Class对象就是用来创建所有“常规”对象的，Java使用Class对象来执行RTTI，即使你正在执行的是类似类型转换这样的操作。每个类都会产生一个对应的Class对象，所有类都是在对其第一次使用时，动态加载到JVM的，当程序创建一个对类的静态成员的引用时，就会加载这个类。Class对象仅在需要的时候才会加载，static初始化是在类加载时进行的。

public class TestMain {
	public static void main(String[] args) {
    	System.out.println(XYZ.name);
	}
}

class XYZ {
	public static String name = "luoxn28";

	static {
    	System.out.println("xyz静态块");
	}

	public XYZ() {
    	System.out.println("xyz构造了");
	}
}

运行结果：

xyz静态块
luoxn28

类加载器首先会检查这个类的Class对象是否已被加载过，如果尚未加载，默认的类加载器就会根据类的全限定名查找对应的.class文件。想在运行时使用类型信息，必须获取对象(比如类Base对象)的Class对象的引用，使用方法Class.forName(“Base”)可以实现该目的，或者使用base.class。注意，有一点很有趣，使用功能”.class”来创建Class对象的引用时，不会自动初始化该Class对象，使用forName()会自动初始化该Class对象。

为了使用类而做的准备工作一般有以下3个步骤：
1.加载：由类加载器完成，找到对应的字节码，创建一个Class对象
2.链接：验证类中的字节码，为静态域分配空间
3.初始化：如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块

class Base {
	static int num = 1;
    
	static {
		System.out.println("Base " + num);
	}
}
public class TestMain {
    public static void main(String[] args) {
        Class clazz1 = Base.class;
        System.out.println("------");
        try{
        	Class clazz2 = Class.forName("Base");
        }catch (Exception e) {
			e.printStackTrace();
		}
    }
}

运行结果：

------
Base 1

由结果可知：Base.class并没有初始化Base类，而是由forName方法来初始化。Class对象只会进行一次初始化，如下：

class Base {
	static int num = 1;
    
	static {
		System.out.println("Base " + num);
	}
}
public class TestMain {
    public static void main(String[] args) {
    	try{
    		Class clazz1 = Class.forName("Base");
    	}catch (Exception e) {
			e.printStackTrace();
		}
        System.out.println("------");
        try{
        	Class clazz2 = Class.forName("Base");
        }catch (Exception e) {
			e.printStackTrace();
		}
    }
}

运行结果：

Base 1
------

二.类型转换前先做检查
编译器将检查类型向下转型是否合法，如果不合法将抛出异常。向下转换类型前，可以使用instanceof判断。

class Base { }
class Derived extends Base { }

public class TestMain {
	public static void main(String[] args) {
    	Base base = new Derived();
    	if (base instanceof Derived) {
    		//这里可以进行向下转型
    		System.out.println("ok");
    	} else {
    		System.out.println("not ok");
    	}
	}
}

运行结果：

ok

三.反射：运行时类信息
如果不知道某个对象的确切类型，RTTI可以告诉你，但是有一个前提：这个类型在编译时必须已知，这样才能使用RTTI来识别它。Class类与java.lang.reflect类库一起对反射进行了支持，该类库包含Field、Method和Constructor类，这些类的对象由JVM在启动时创建，用以表示未知类里对应的成员。这样的话就可以使用Contructor创建新的对象，用get()和set()方法获取和修改类中与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。另外，还可以调用getFields()、getMethods()和getConstructors()等许多便利的方法，以返回表示字段、方法、以及构造器对象的数组，这样，对象信息可以在运行时被完全确定下来，而在编译时不需要知道关于类的任何事情。
反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。所以对于RTTI和反射之间的真正区别只在于：
1.RTTI：编译器在编译时打开和检查.class文件
2.反射：运行时打开和检查.class文件

import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class TestMain{
	public static void main(String[] args) {
		Person person = new Person("luoxn28", 23);
		Class clazz = person.getClass();

		Field[] fields = clazz.getDeclaredFields();
		for (Field field : fields) {
			try{
				String key = field.getName();
				PropertyDescriptor descriptor = new PropertyDescriptor(key, clazz);
				Method method = descriptor.getReadMethod();
				Object value = method.invoke(person);
				System.out.println(key + ":" + value);
			}catch (Exception e) {
				e.printStackTrace();
			}

		}
	}
}

运行结果：

name:luoxn28
age:23

以上通过getReadMethod()方法调用类的get函数，通过getWriteMethod()方法来调用类的set方法。通常来说，我们不需要使用反射工具，但是它们在创建动态代码会更有用，反射在Java中用来支持其他特性的，例如对象的序列化和JavaBean等。

四.动态代理
代理模式是为了提供额外或不同的操作，而插入的用来替代”实际”对象的对象，这些操作涉及到与“实际”对象的通信，因此代理通常充当中间人角色。Java的动态代理比代理的思想更前进了一步，它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的策略。以下是一个动态代理示例：
接口和实现类：

public interface Interface {
	void doSomething();
	void somethingElse(String arg);
}
public class RealObject implements Interface {
	public void doSomething() {
		System.out.println("doSomething.");
	}
	public void somethingElse(String arg) {
		System.out.println("somethingElse " + arg);
	}
}

动态代理对象处理器：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class DynamicProxyHandler implements InvocationHandler {
	private Object proxyed;
    
	public DynamicProxyHandler(Object proxyed) {
		this.proxyed = proxyed;
	}
    
    @Override
	public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    		System.out.println("代理工作了.");
    		return method.invoke(proxyed, args);
	}
}

测试类：

import java.lang.reflect.Proxy;

public class TestMain {
	public static void main(String[] args) {
		RealObject real = new RealObject();
		Interface proxy = (Interface) Proxy.newProxyInstance(
				Interface.class.getClassLoader(), new Class[] {Interface.class},
				new DynamicProxyHandler(real));
        
		proxy.doSomething();
		proxy.somethingElse("luoxn28");
    }
}

运行结果：

代理工作了.
doSomething.
代理工作了.
somethingElse luoxn28

通过调用Proxy静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器，一个你希望该代理实现的接口列表(不是类或抽象类)，以及InvocationHandler的一个实现类。动态代理可以将所有调用重定向到调用处理器，因此通常会调用处理器的构造器传递一个”实际”对象的引用，从而将调用处理器在执行中介任务时，将请求转发。

五.反射应用场景
转载自http://blog.youkuaiyun.com/zolalad/article/details/29370565

  1.Java的反射机制在做基础框架的时候非常有用，有一句话这么说来着：反射机制是很多Java框架的基石。而一般应用层面很少用，不过这种东西，现在很多开源框架基本都已经给你封装好了，自己基本用不着写。典型的除了Hibernate之外，还有Spring也用到很多反射机制。经典的就是在xml文件或者properties里面写好了配置，然后在Java类里面解析xml或properties里面的内容，得到一个字符串，然后用反射机制，根据这个字符串获得某个类的Class实例，这样就可以动态配置一些东西，不用每一次都要在代码里面去new或者做其他的事情，以后要改的话直接改配置文件，代码维护起来就很方便了，同时有时候要适应某些需求，Java类里面不一定能直接调用另外的方法，这时候也可以通过反射机制来实现。
  总的来说，自己写的很少，具体什么时候要用那要看需求，反射机制无非就是根据一个String来得到你要的实体对象，然后调用它原来的东西。但是如果是要自己写框架的话，那就会用得比较多了。
  2.当你做一个软件可以安装插件的功能，你连插件的类型名称都不知道，你怎么实例化这个对象呢？因为程序是支持插件的（第三方的），在开发的时候并不知道。所以无法在代码中new出来，但反射可以，通过反射，动态加载程序集，然后读出类，检查标记之后再实例化对象，就可以获得正确的类实例。
  3.在编码阶段不知道那个类名，要在运行期从配置文件读取类名，这时候就没有办法硬编码new ClassName()，而必须用到反射才能创建这个对象。反射的目的就是为了扩展未知的应用。比如你写了一个程序，这个程序定义了一些接口，只要实现了这些接口的dll都可以作为插件来插入到这个程序中。那么怎么实现呢？就可以通过反射来实现。就是把dll加载进内存，然后通过反射的方式来调用dll中的方法。很多工厂模式就是使用的反射。