1.Java反射机制
在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
反射指Java在运行时可以加载、探知、使用编译期间完全未知的classes。
2.反射机制的基础Class类
在JVM的角度上，所有的类比如String、Integer等Java类都有成员变量，成员方法和构造函数，JVM把这些所有的类再进行共性提取，定义了Class类，这是所有类的类，我们可以把String、Integer都理解成Class类的一个对象。
java.lang.Class注意查看源码可以发现Class的构造函数是private的，这说明我们是不能new Class的，只有JVM可以创建Class的对象,但是我们可以获取到Class的对象。
3.Java反射的相关操作
1.获取Class对象
package com.per.Reflection;
public class ReflectionDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
//第一种：Class c1 = 类名.class;
Class class1=ReflectionDemo1.class;
System.out.println(class1.getName());
//第二种：Class c2 = 对象.getClass();
ReflectionDemo1 demo= new ReflectionDemo1();
Class class2 = demo.getClass();
System.out.println(class2.getName());
//第三种：Class c3 = Class.forName("XX");
Class class3 = Class.forName("com.per.Reflection.ReflectionDemo1");
System.out.println(class3.getName());
}
}
2.获取成员方法信息
java.lang.reflect.Method通过Method类获取类的成员方法。
package com.per.Reflection;
import java.lang.reflect.Method;
public class ReflectionDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
Class c = Class.forName("java.lang.String");
Method[] methods = c.getDeclaredMethods();
System.out.println("不包含父类的private&pubic方法");
for (Method m : methods) {
System.out.println(m);
}
Method[] methodsPublic = c.getMethods();
System.out.println("包含父类的pubic方法");
for (Method m : methodsPublic) {
System.out.println(m);
}
Method method1 = c.getDeclaredMethod("toString", null);
System.out.println(method1);
Method method2 = c.getMethod("startsWith",String.class);
System.out.println(method2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
①getDeclaredMethods()返回本类中定义的所有方法，不包括父类的方法。
②getMethods()返回包括父类的权限为public的方法。
③getDeclaredMethod(String name, Class... parameterTypes) 返回此Class对象对应类的、带指定形参列表的不包含父类的方法。
④getMethod(String name, Class... parameterTypes) 返回此Class对象对应类的、带指定形参列表的包含父类的public方法。
3.获取构造函数
java.lang.reflect.Constructor通过Constructor获取类的构造函数。
package com.per.Reflection;
import java.lang.reflect.Constructor;
public class ReflectionDemo3 {
public static void main(String[] args) {
try {
Class c = Class.forName("java.lang.String");
Constructor[] constructors = c.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
Constructor[] constructorsPublic = c.getConstructors();
for (Constructor constructor : constructorsPublic) {
System.out.println(constructor);
}
Constructor constructor1 = c.getDeclaredConstructor(String.class);
constructor1.setAccessible(true);// 设置是否允许访问，如果该构造器是private的，所以要手动设置允许访问，如果构造器是public的就不需要这行了。
Object o=constructor1.newInstance("refelect test");
System.out.println(o);
Method method=c.getDeclaredMethod("startsWith", String.class);
System.out.println(method.invoke(o, "refe"));
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.调用成员函数
public Object invoke(Object obj, Object... args)
①以String类为例子，首先获取String的Class的对象
②创建String类的对象
③获取String类的特定Method
④通过Method的invoke方法调用String类的成员方法
Class c = Class.forName("java.lang.String");//①
Object obj1=c.newInstance();//②
Method method=c.getDeclaredMethod("startsWith", String.class);//③
method.invoke(obj, "refe"));//④false
//根据构造函数创建String对象
Constructor constructor1 = c.getDeclaredConstructor(String.class);
Object o=constructor1.newInstance("refelect test");
method.invoke(obj, "refe"));//true
4.代理模式
1.问题的背景：计算一个方法运行的时间
定义一个Moveable接口
public interface Moveable {
void move();
}
定义一个实现Moveable的类
public class Tank implements Moveable {
@Override
public void move() {
System.out.println("Tank Moving...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
问题：如何计算出Tank类中move方法运行的时间
解决策略：
①直接在Tank类中修改源码，添加计时操作；
②继承：新建一个类继承Tank类，并覆盖move方法，在子类的move方法中添加计时操作，并调用父类super.move()方法；
③聚合：新建一个代理类实现Moveable接口，并且该类中包含一个Tank类的对象，在代理类中的move方法中调用Tank类对象的move方法。静态代理
2.静态代理
静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
JDK代理都是面向接口的，实现类和代理类必须实现同一个接口
public class StaticProxy implements Moveable {
private Moveable m = new Tank();//多态
public StaticProxy(Moveable m) {
this.m = m;
}
@Override
public void move() {
long start = System.currentTimeMillis();
System.out.println("starttime:" + start);
m.move();
long end = System.currentTimeMillis();
System.out.println("time:" + (end-start));
}
}
代理客户端
public class Client {
public static void main(String[] args) throws Exception {
StaticProxy proxy=new StaticProxy();
proxy.move();
}
}
总结
①定义代理类和委托类的总接口
②实现类的具体方法
③实现代理类，包含委托类的一个实例，并在代理类的方法中调用委托类的方法
④客户端，创建一个代理类对象，实现代理。
优点
不用修改委托类的源代码通过代理类就可以实现对委托类的控制。
缺点
代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
静态代理类只能为特定的接口服务。如想要为多个接口服务则需要建立很多个代理类。
3.动态代理
动态：在运行的时候才生成classes的文件。
思路：将程序的代码保存成String类型，然后在运行的过程中将该String的内容写入XX.java文件中，调用JavaCompiler 编译器将java文件在运行的时候产生classes文件。并将class文件加载到内存，调用成员函数。
package com.bjsxt.compiler.test;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
import com.bjsxt.proxy.Moveable;
import com.bjsxt.proxy.Tank;
public class Test1 {
public static void main(String[] args) throws Exception{
String rt = "\r\n";
String src =
"package com.bjsxt.proxy;" + rt +
"public class TankTimeProxy implements Moveable {" + rt +
" public TankTimeProxy(Moveable t) {" + rt +
" super();" + rt +
" this.t = t;" + rt +
" }" + rt +
" Moveable t;" + rt +
" @Override" + rt +
" public void move() {" + rt +
" long start = System.currentTimeMillis();" + rt +
" System.out.println(\"starttime:\" + start);" + rt +
" t.move();" + rt +
" long end = System.currentTimeMillis();" + rt +
" System.out.println(\"time:\" + (end-start));" + rt +
" }" + rt +
"}";
String fileName = System.getProperty("user.dir")
+ "/src/com/bjsxt/proxy/TankTimeProxy.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//compile
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMgr.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
t.call();
fileMgr.close();
//load into memory and create an instance
URL[] urls = new URL[] {new URL("file:/" + System.getProperty("user.dir") +"/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.bjsxt.proxy.TankTimeProxy");
System.out.println(c);
Constructor ctr = c.getConstructor(Moveable.class);
Moveable m = (Moveable)ctr.newInstance(new Tank());
m.move();
}
}
遇到的问题 compiler一直返回null，将jdk\lib下将tools.jar复制到jre\lib下就能正确运行了，我的path中保存了jre和jdk的目录。
程序运行结束后Window——Show view——Nivigator，然后再刷新一下项目，我们可以发现在程序运行的过程中生成了TankTimeProxy.java文件，并且我们调用了java的编译器生成了TankTimeProxy.class文件。
现在存在的问题：1.接口是固定的；2.函数也是固定move
我们很自然的能够想到传入一个参数来获取指定类型的接口
根据反射机制，我们如果知道了某个类的名字也就能够获取所有的方法。这样我们就可以不用在代码中写出固定的函数了。
Method[] methods = infce.getMethods();
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
" try {" + rt +
" Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
" h.invoke(this, md);" + rt +
" }catch(Exception e) {e.printStackTrace();}" + rt +
"}";
}
假如我们还需要在函数处理前后记录日志呢，读取权限呢，那样我们就有各种处理不同事物的代理，我们可以把这些代理抽象出来，这些代理全部都必须实现InvocationHandler这个接口。
public interface InvocationHandler {
public void invoke(Object o, Method m);
}
package com.bjsxt.proxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
private Object target;
public TimeHandler(Object target) {
super();
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
long start = System.currentTimeMillis();
System.out.println("starttime:" + start);
System.out.println(o.getClass().getName());
try {
m.invoke(target);
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("time:" + (end - start));
}
}
注意：实际上我们的代理类内部仍然包含了一个委托类的对象，并且在代理类中调用了实际上是一个委托类的对象调用了委托类的方法。
m.invoke(target);
所以我们不但要将接口作为参数，还要将何种类型的代理也传入进去，这样我们就能实现对任意对象、任意接口，实现任意的代理。
package com.bjsxt.proxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
public class Proxy {
public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM
String methodStr = "";
String rt = "\r\n";
Method[] methods = infce.getMethods();
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
" try {" + rt +
" Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
" h.invoke(this, md);" + rt +
" }catch(Exception e) {e.printStackTrace();}" + rt +
"}";
}
String src =
"package com.bjsxt.proxy;" + rt +
"import java.lang.reflect.Method;" + rt +
"public class $Proxy1 implements " + infce.getName() + "{" + rt +
" public $Proxy1(InvocationHandler h) {" + rt +
" this.h = h;" + rt +
" }" + rt +
" com.bjsxt.proxy.InvocationHandler h;" + rt +
methodStr +
"}";
String fileName =
"d:/src/com/bjsxt/proxy/$Proxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//compile
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMgr.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
t.call();
fileMgr.close();
//load into memory and create an instance
URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.bjsxt.proxy.$Proxy1");
System.out.println(c);
Constructor ctr = c.getConstructor(InvocationHandler.class);
Object m = ctr.newInstance(h);
//m.move();
return m;
}
}
客户端的程序：
public class Client {
public static void main(String[] args) throws Exception {
Tank t = new Tank();
InvocationHandler h = new TimeHandler(t);
Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);
m.move();
}
}
总结：静态代理的实现类和代理类都必须实现同一个接口，但是在动态代理中，代理类必须实现InvocationHandler这个接口，这个接口在指定方法时会自动的调用。
invoke(Object proxy, Method method, Object[] args)
在客户端程序中，静态代理直接创建一个代理类对象通过调用代理类的 方法实现代理。在动态代理中，实现InvocationHandler这个接口的类并不是代理类，而是代理类的必备环节。
Tank t = new Tank();
InvocationHandler h = new TimeHandler(t);
Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);
注意：在Proxy文件中调用的是 h.invoke(this, md)，这里的h指的是我们实现InvocationHandler这个接口的对象，调用的Method是infce中的方法，实际上就是h中有一个infec的对象，是h中的infec对象调用的方法。
5.参考资料
马士兵代理模式视频
http://www.jianshu.com/p/da4a20d3ab77
http://www.jianshu.com/p/1f329f5fda9d
