Java反射机制

从动态语言说起反射

“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。
从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。
但是JAVA有着一个非常突出的动态相关机制:Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。
换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造(但不包括methods定义)，并生成其对象实体、或对其fields设值、或唤起其methods。
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;
对于任意一个对象，都能够调用它的任意方法和属性;
这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

反射的好处及应用

Java反射机制是一个非常强大的功能，在很多大型项目比如Spring, Mybatis中都可以看见反射的身影。通过反射机制我们可以在运行期间获取对象的类型信息，利用这一特性我们可以实现工厂模式和代理模式等设计模式，同时也可以解决Java泛型擦除等令人苦恼的问题。

什么是类 Class

在面向对象的世界里，万事万物皆是对象。

• 而在java语言中，static修饰的东西不是对象，但是它属于类。
• 普通的数据类型不是对象，例如：int a = 5;它不是面向对象，但是它有其包装类 Integer 或者分装类来弥补了它。

除了以上两种不是面向对象，其余的包括类也有它的面向对象，类是java.lang.Class的实例化对象（注意Class是大写）。也就是说：
Class A{}
当我创建了A类，那么类A本身就是一个对象，谁的对象？java.lang.Class的实例对象。
那么这个对象又该怎么表示呢？
我们先看一下下面这段代码：

public class Demo(){
F f=new F();
}
class F{}

F类的实例化对象就可以用f表达出来。
F类也是一个实例化对象，Class类的实例化对象。
我们可以理解为任何一个类都是Class类的实例化对象，这种实例化对象有三种表示方法：

public class Demo(){
	F f=new F();
	//第一种表达方式
	Class c1=F.class;//这种表达方式同时也告诉了我们任何一个类都有一个隐含的静态成员变量class
	//第二种表达方式
	Class c2=f.getClass();//这种表达方式在已知了该类的对象的情况下通过getClass方法获取
	//第三种表达方式
	Class c3 = null;
	try {
	c3 = Class.forName("com.text.F");//类的全称
	} catch (ClassNotFoundException e) {
	e.printStackTrace();
	}
}
class F{}

以上三种表达方式，c1,c2,c3都表示了F类的类类型，也就是官方解释的Class Type。
那么问题来了：

System.out.println(c1 == c2)?  or  System.out.println(c1 == c3)?

答案是肯定的，返回值为ture。这表明不论c1 or c2 or c3都代表了F类的类类型，也就是说一个类只可能是Class类的一个实例对象。
理解了Class的概念，我们也可以通过类的类类型创建该类的对象实例，用c1 or c2 or c3的newInstance()方法：

Public class Demo1{
	try {
			Foo foo = (Foo)c1.newInstance();//foo就表示F类的实例化对象
			foo.print();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
}}
class F{
void print(){
}
}

这里需要注意的是，c1是F类的类类型，创建出来的就是F类的对象。如果a是A类的类类型，那么创建出来的对象也应该与之对应，属于A类的对象。

方法的反射

Class类有一个最简单的方法，getName()：

public class Demo2 {
	public static void main(String[] args) {
		Class c1 = int.class;//int 的类类型
		Class c2 = String.class;//String类的类类型
		Class c3 = void.class;
		System.out.println(c1.getName());
		System.out.println(c2.getName());
		System.out.println(c2.getSimpleName());
		System.out.println(c3.getName());
	}
}

基本数据类型以及void关键字都是存在类类型的。

public class ClassUtil {

	public static void printClassMethodMessage(Object obj){
	//要获取类的信息》》首先我们要获取类的类类型
	Class c = obj.getClass();
	//我们知道Object类是一切类的父类，所以我们传递的是哪个子类的对象，c就是该子类的类类型。
	//接下来我们要获取类的名称
	System.out.println("类的名称是:"+c.getName());
	/*
	*我们知道，万事万物都是对象，方法也是对象，是谁的对象呢？
	* 在java里面，方法是Method类的对象
	*一个成员方法就是一个Method的对象，那么Method就封装了对这个成员
	*方法的操作
	*/
	//如果我们要获得所有的方法，可以用getMethods()方法，这个方法获取的是所有的Public的函数，包括父类继承而来的。如果我们要获取所有该类自己声明的方法，就可以用getDeclaredMethods()方法，这个方法是不问访问权限的。
	Method[] ms = c.getMethods();//c.getDeclaredMethods()
	//接下来我们拿到这些方法之后干什么？我们就可以获取这些方法的信息，比如方法的名字。
	//首先我们要循环遍历这些方法
	for(int i = 0; i < ms.length;i++){
	//然后可以得到方法的返回值类型的类类型
	Class returnType = ms[i].getReturnType();
	//得到方法的返回值类型的名字
	System.out.print(returnType.getName()+" ");
	//得到方法的名称
	System.out.print(ms[i].getName()+"(");
	//获取参数类型--->得到的是参数列表的类型的类类型
	Class[] paramTypes = ms[i].getParameterTypes();
	for (Class class1 : paramTypes) {
	System.out.print(class1.getName()+",");
	}
	System.out.println(")");
	}
	}
}

总结思路：
通过方法的反射得到该类的名称步骤：
1.获取该类的类类型
2.通过类类型获取类的方法（getMethods()）
3.循环遍历所获取到的方法
4.通过这些方法的getReturnType()得到返回值类型的类类型，又通过该类类型得到返回值类型的名字
5.getName()得到方法的名称，getParameterTypes()获取这个方法里面的参数类型的类类型

成员变量的反射

首先我们需要认识到成员变量也是对象，是java.lang.reflect.Field类的对象，那么也就是说Field类封装了关于成员变量的操作。既然它封装了成员变量，我们又该如何获取这些成员变量呢？它有这么一个方法：

public class ClassUtil {
	public static void printFieldMessage(Object obj){
		Class c = obj.getClass();
		//Field[] fs = c.getFields();
	}
}

这里的getFields()方法获取的所有的public的成员变量的信息。和方法的反射那里public的成员变量一样，也有一个获取所有自己声明的成员变量的信息：
Field[] fs = c.getDeclaredFields();
我们得到它之后，可以进行遍历（既然封装了Field的信息，那么我们就可以得到Field类型）

for (Field field : fs) {
	//得到成员变量的类型的类类型
	Class fieldType = field.getType();
	String typeName = fieldType.getName();
	//得到成员变量的名称
	String fieldName = field.getName();
	System.out.println(typeName+" "+fieldName);
}

构造函数的反射

不论是方法的反射、成员变量的反射、构造函数的反射，我们只需要知道：要想获取类的信息，首先得获取类的类类型。

public static void printConMessage(Object obj){
	Class c = obj.getClass();
	/*
	* 首先构造函数也是对象，是java.lang.Constructor类的对象
	* 也就是java.lang. Constructor中封装了构造函数的信息
	* 和前面说到的一样，它也有两个方法：
	* getConstructors()方法获取所有的public的构造函数
	* getDeclaredConstructors()方法得到所有的自己声明的构造函数
	*/
	//Constructor[] cs = c.getConstructors();
	Constructor[] cs = c.getDeclaredConstructors();
	for (Constructor constructor : cs) {
	//我们知道构造方法是没有返回值类型的，但是我们可以：
	System.out.print(constructor.getName()+"(");
	//获取构造函数的参数列表》》得到的是参数列表的类类型
	Class[] paramTypes = constructor.getParameterTypes();
	for (Class class1 : paramTypes) {
	System.out.print(class1.getName()+",");
	}
	System.out.println(")");
	}
}

Class类的动态加载类

如何动态加载一个类呢？
首先我们需要区分什么是动态加载？什么是静态加载？我们普遍认为编译时刻加载的类是静态加载类，运行时刻加载的类是动态加载类。我们举一个例子：

Class A{
	Public static void main(String[] args){
		if("B".equal(args[0]))
		{
			B b=new B();
			b.start();
		}
		if("C".equal(args[0]))
		{
			C c=new C();
			C.start();
		}
	}
}

上面这一段代码，当我们在用eclipse或者myeclipse的时候我们并不关心是否能够通过编译，当我们直接在cmd使用javac访问A.java类的时候，就会抛出问题:

A.java：7：错误：找不到符号
B b=new B();
符号:  类B
位置： 类A
A.java：7：错误：找不到符号
B b=new B();
符号:  类B
位置： 类A
A.java：12：错误：找不到符号
C c=new C();
符号:  类C
位置： 类A
A.java：12：错误：找不到符号
C c=new C();
符号:  类C
位置： 类A
4个错误

或许我们理所当然的认为这样应该是错，类B根本就不存在。但是如果我们多思考一下，就会发现B一定用吗？不一定。C一定用吗？也不一定。那么好，现在我们就让B类存在

Class B{
	Public static void start(){
		System.out.print("B...satrt");
	}
}

现在我们就先 javac B.class,让B类先开始编译。然后在运行javac A.class。结果是：

A.java：12：错误：找不到符号
C c=new C();
符号:  类C
位置： 类A
A.java：12：错误：找不到符号
C c=new C();
符号:  类C
位置： 类A
2个错误

们再想，这个程序有什么问题。如果你说没有什么问题？C类本来就不存在啊！那么问题来了B类已经存在了，假设我现在就想用B，我们这个程序用得了吗？答案是肯定的，用不了。那用不了的原因是什么？因为我们这个程序是做的类的静态加载，也就是说new创建对象是静态加载类，在编译时刻就需要加载所有的，可能使用到的类。所以不管你用不用这个类。
现在B类是存在的，但是我们这个程序仍然用不了，因为会一直报C类有问题，所以B类我也用不了。那么在实际应用当中，我们肯定需要如果B类存在，B类我就能用，当用C类的时候，你再告诉我错了。如果说将来你有100个类，只要其中一个类出现问题，其它99个类你都用不了。所以这并不是我们想要的。
我们想要的就是：我用到那个类就加载那个类，也就是常说的运行时刻加载，动态加载类。如何实现动态加载类呢？我们可以建这么一个类：

Class All{
	Public static void start()
	{
		try{
			Class cl= Class.forName(args[0]);
			//通过类类型，创建该类的对象
			cl.newInstance();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

前面我们在分析Class实例化对象的方式的时候，==Class.forName(“类的全称”)，它不仅仅表示了类的类类型，还表示了动态加载类。==当我们javac All.java的时候，它不会报任何错误，也就是说在编译的时候是没有错误的。只有当我们具体用某个类的时候，那个类不存在，它才会报错。
如果加载的类是B类，就需要：

B bt = (B) cl.newInstance();

万一加载的是C类呢，可以改成

C ct = (C) cl.newInstance();

但是如果我想用很多的类或者加载很多的类，该怎么办？我们可以统一一个标准，不论C类还是B类或者其他的类，比如定义一个标准

Stand s = (Stand) cl.newInstance();

只要B类和C类都是这个标准的就行了。

Class All
{
	Public static void start()
	{
		try{
			Class cl= Class.forName(args[0]);
			//通过类类型，创建该类的对象
			Stand s = (Stand) cl.newInstance();
			s.start();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}
interface Stand {
	Public void start();
}

现在如果我想要用B类，我们只需要：

Class B implements Stand
{
	Public void start()
	{
		System.out.print("B...satrt");
	}
}

加载B类,编译运行。

javac B.java
javac Stand.java
java Stand B

结果：B...satrt
如果以后想用某一个类，不需要重新编译，只需要实现这个标准的接口即可。只需要动态的加载新的东西就行了。
这就是动态加载类。

---

转自http://www.importnew.com/23560.html

动态代理

利用动态代理实现面向切面编程

AOP是Spring提供的一个强大特性之一，AOP的意思是面向切面编程，就是说要分离和业务不相关的代码，当我们需要新增相关的事务的时候，我们不想要对业务本身做修改。面向切面编程和面向对象变成相比到底有什么好处呢，我们通过一个例子来看一下，对于新手来说，常常会写出下面这样的代码：

public class Example1 {
    public void execute() {
        // 记录日志
        Logger logger = Logger.getLog(...);
        // 进行性能统计
        PerformanceUtil.startTimer(...);
        // 权限检查
        if (!user.hasPrevilege()) {
            // 抛出异常
        }
        // 执行真正的业务
        executeTransaction();
        PerformanceUtil.endTimer();
    }
}

虽然我们上面真正要执行的业务只有executeTransaction()，但是日志，性能，权限相关的代码差不多要将真正的业务代码掩盖了。而且以后如果我们还有一个Example2，它同样需要实现相同的日志，性能，权限代码。这样当以后我们需要新增相关的逻辑检查的时候，我们需要所有Example进行重构，这显然不符合面向对象的一个基本原则-封装变化。

上面这个场景利用模板方法和装饰器模式都可以解决，在Spring中是通过动态代理来实现的，下面我们通过一个例子来模拟一下Spring中的AOP实现。

我们要实现的业务是：统计程序统计员工工资所执行的时间以及检查用户的权限。首先先来实现的Salary类，它里面包含一些实现统计员工工资的业务逻辑：

public interface SalaryInterface {
    public void doSalary();
}

public class Salary implements SalaryInterface {
    public void doSalary() {
        ...
    }
}

通过InvocationHandler我们来实现动态代理，以后当我们调用obj的相关方法之前，都会通过invoke方法进行代理，而不会直接调用obj方法。

public class SimpleProxy implements InvocationHandler {
    private Object obj;
    private Object advice;
    // 绑定代理对象
    public Object bind(Object obj, Advice advice) {
        this.obj = obj;
        this.advice = advice;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
            obj.getClass().getInterfaces(), this)
    }
    // 实现代理
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwalbe {
        Object result = null;
        try {
            advice.before();
            result = method.invoke(obj, args);
            advice.after();
        } catch(Exception e) {
            e.printStackTrace();
        }
        return result
    }
}

模拟Spring中的Advice接口：

public interface Advice {
    public void before();
    public void after();
}

实现TimeAdvice用于统计程序的执行时间：

public class TimeAdvice implements Advice {
    long startTime;
    long endTime;
    @Override
    public void before() {
        startTime = System.nanoTime(); // 获取开始时间
    }
    @Override
    public void after() {
        endTime = System.nanoTime(); // 获取结束时间
    }
}

客户端调用代码如下：

public class Client {
    public static void main(String[] args) {
        SimpleProxy = new SimpleProxy();
        SalaryInterface salaryInterface =
            (SalaryInterface) simpleProxy.bind(new Salary(), new TimeAdvice());
        salaryInterface.doSalary();
    }
}

如果我们现在需要新增权限控制，我们来实现ControlAdvie类：

public class ControlAdvice implements Advice {
    @Override
    public void before() {
        if (...) {
            ...
        } else {
            ...
        }
    }
    @Override
    public void after() {
        ...
    }
}

而我们客户端的代码只需要改成simpleProxy.bind(new Salary(), new ControlAdvie)就行了，而SimpleProxy本身不需要做任何的修改。