java学习之路 之 反射机制综合练习题、动态代理实例

 在上一篇博文中我们已经进行了反射机制的习题练习，这里我们在做一个考察比较全面的练习，如下：

写一个类ReflectUtil类, 类中写一个静态方法Object methodInvoker(String classMethd) 此方法为无参方法如，

我们传入的实参字符串为：classMethod "java.lang.String.length()"就可以通过反射执行String类中的length方法、

 当传入的实参字符串为"com.atguigu.javase.reflect.Teacher.test()"就可以执行指定包下，指定类中的指定方法。

具体实现如下：

package com.aguigu.javase.work;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/*
写一个类ReflectUtil类, 类中写一个静态方法Object methodInvoker(String classMethd)
此方法为无参方法如：
classMethod "java.lang.String.length()"
com.atguigu.javase.reflect.Teacher.test()
*/
public class ReflectUtil {

public static Object methodInvoker(String classMethd) throws ClassNotFoundException,
NoSuchMethodException,
SecurityException,
InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException {
// 获取最后一个"."出现的下标
int lastDot = classMethd.lastIndexOf(".");
// 获取子字符串从第0下标到最后一个"."出现的下标，这个字符串即为类的全限定名称
String className = classMethd.substring(0, lastDot);
// 获取子字符串，为方法的名称
String methodName = classMethd.substring(lastDot + 1, classMethd.length() - 2);
// 根据类名获取Class对象
Class clazz = Class.forName(className);
Method method = null;
Class tmp = clazz;
// 判断次方法是否存在
while (tmp != null) {
try {
// 若存在，获取方法对象，以防是私有方法，使用getDeclaredMethod方法获取
method = tmp.getDeclaredMethod(methodName);
break;
} catch (NoSuchMethodException e) {
// 若不存在，在父类中获取此方法
tmp = tmp.getSuperclass();
}
}
Object object = clazz.newInstance();
// 根据Class对象创建对象
// 突破私有方法的禁锢性
method.setAccessible(true);
return method.invoke(object);
}

public static void main(String[] args) {
try {
Object object = methodInvoker("java.lang.String.length()");
System.out.println(object);

} catch (Exception e) {
e.printStackTrace();
}
}
}动态代理：客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。从而实现一个客户代理对象可以完成多个业务的代理。
动态的代理实例：一个代理可以完成房屋出租、售票等.....业务

// 动态的代理实例,一个代理可以完成房屋出租、售票等.....业务
package com.aguigu.javase.reflect;

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

// 创建一个HouseRent接口，其中有Rent方法（房屋出租）
interface HouseRent {
public void rent();
}

// 创建一个FangDong类，实现HouseRent接口的Rent方法（房屋出租）
class FangDong implements HouseRent {
@Override
public void rent() {
System.out.println("婚房, 请爱护");
}
}

// 创建一个TrainTicket接口，其中有buy方法（售票）
interface TrainTicket {
public void buy();
}

// 创建一个BeijingNan类，实现TrainTicket接口的buy方法（售票）
class BeiJingNan implements TrainTicket {
@Override
public void buy() {
System.out.println("您请稍等, 正在出票...");
for (int i = 0; i < 10000000; i++) {
int j = i * i;
}
}
}

// 创建一个MyInvocationHandler类实现InvocationHandler接口，将被代理对象作为属性，实现对象的关联，并提供get，set方法
class MyInvocationHandler implements InvocationHandler {

private Object target; // 被代理对象

public Object getTarget() {
return target;
}

public void setTarget(Object target) {
this.target = target;
}

// method方法调用必须需要一个真的被代理对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) // 第1个是代理对象, 第2个是代理方法, 第3个是方法需要实参
throws Throwable {
// 调用对象.getClass方法获取对的类模板，方法名的getName方法获取方法名
System.out.println("动态代理代理对象[" + proxy.getClass() + "],方法[" + method.getName() + "]调用前");
long time1 = System.currentTimeMillis();

// 执行被代理对象的方法，并返回被代理对象类型的对象
Object object = method.invoke(target, args);

long time2 = System.currentTimeMillis();
System.out.println("动态代理方法[" + method.getName() + "]执行完毕 , 共用了" + (time2 - time1) + "毫秒");

return object;
}

}

public class ProxyTest {

public static void main(String[] args) {
MyInvocationHandler h = new MyInvocationHandler();
FangDong fd = new FangDong();
h.setTarget(fd);//设置被代理对象
HouseRent hRent = (HouseRent)Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), // 第一个参数是类加载器类加载器
fd.getClass().getInterfaces(), // 代理类中的所有接口
h); // 第三个参数是一个方法调用处理器(包含了对象原始对象的方法的进一步处理)
hRent.rent();

// 重复利用方法调用处理器
h.setTarget(new BeiJingNan()); // 只需要改变被代理对象即可
TrainTicket tt = (TrainTicket)Proxy.newProxyInstance(ProxyTest.class.getClassLoader(),
new Class[]{TrainTicket.class},
h);
tt.buy();
}

}