1…创建动态代理类的实例对象及调用其方法
代码:
//开始创建动态类的实例对象
publicstatic void name1() throws Exception {
//获得动态代理类的字节码
ClassclazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);
//Objectobj = clazzProxy1.newInstance();报错,,因为Proxy类里面只有一个有参构造函数
//先得到有参的构造函数,,参数的类型是InvocationHandler类
Constructorconstructor=clazzProxy1.getConstructor(InvocationHandler.class);
//InvocationHandler是接口,不能直接创建对象,,就得创建一个InvocationHandler的实现类作为对象传给newInstance方法使用
//创建了一个内部类
classMyInvocationHander1 implements InvocationHandler{
//实现接口里面的方法
@Override
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
//TODO Auto-generated method stub
returnnull;
}
}
//创建对象,传入一个具体的参数(InvocationHandler的实现类,就是一个InvocationHandler对象),
//代理类实现了Collection接口,所以返回的代理类对象一定是Collection类型的
Collectionproxy1=(Collection) constructor.newInstance(new MyInvocationHander1());
//这里返回null,是proxy1.toString()返回null,,proxy1默认会调用toString(),,而不是proxy1对象为null(对象没有创建成功)
System.out.println(proxy1);
//发现调用返回值为void的方法不会发生异常
proxy1.clear();
//发现调用这个有返回值的方法size()会发生异常
proxy1.size();
}
发现调用这个有返回值的方法size()会发生异常,调用这个对象的没有返回值的方法clear()不会发生异常
在这里成功的获得了一个动态代理类Proxy的 字节码,并且用这个动态类字节码创建了一个实例对象
//InvocationHandler是接口,不能直接创建对象,,就得创建一个InvocationHandler的实现类作为对象传给newInstance方法使用
//创建了一个内部类
classMyInvocationHander1 implements InvocationHandler{
//实现接口里面的方法
@Override
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
//TODO Auto-generated method stub
returnnull;
}
}
//创建对象,传入一个具体的参数(InvocationHandler的实现类,就是一个InvocationHandler对象),
//代理类实现了Collection接口,所以返回的代理类对象一定是Collection类型的
Collectionproxy1=(Collection) constructor.newInstance(new MyInvocationHander1());
发现那个内部类只使用了一次(newMyInvocationHander1()),,只使用一次就写个内部类太麻烦了,,可以在newInstance()里面new一个匿名内部类:
Class clazzProxy1 =Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
Constructorconstructor = clazzProxy1.getConstructor(InvocationHandler.class);
//参数是new 匿名内部类,InvocationHandler后面加{}等于在创建InvocationHandler的子类对象,,这个子类的名字不知道(匿名)
//传入的对象是InvocationHandler的实现类的实例对象,,这里是new一个InvocationHandler的子类对象,子类名字不知道
Collectionproxy2 = (Collection)constructor.newInstance(new InvocationHandler(){
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
returnnull;
}
});
2... InvocationHandler 对象
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；告诉虚拟机那个目标类实现了哪些接口
产生的类字节码必须有个一个关联的类加载器对象；
生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代 码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些 代码被调用运行了。
用Proxy.newInstance方法直接一步就创建出代理对象。
现在把创建动态类和创建实例对象的这2个步骤合二为一,之前是先得到代理类的字节码,然后再用字节码创建实例对象,现在想一步到位,,,使用newProxyInstance方法
Proxy类:
方法:
static Object newProxyInstance(ClassLoaderloader, Class<?>[] interfaces, InvocationHandler h)
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
参数：
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表(数组),,interfaces是一个数组,,而不能是可变参数,因为可变参数必须位于newProxyInstance方法参数的最后(必须是最后面的一个参数),这里的interfaces 不是最后面的一个参数,所以不能用可变参数,只能用数组
h - 指派方法调用的调用处理程序 ,,传入一个InvocationHandler对象
返回：
一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口
这个方法一步到位,即创建了字节码同时又使用这个字节码创建了实例对象
代码1:
//创建一个代理类实例对象
Collectionproxy3=(Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),
//interfaces是一个数组,,而不能是可变参数,因为可变参数必须位于newProxyInstance方法参数的最后(必须是最后面的一个参数),
//这里的interfaces 不是最后面的一个参数,所以不能用可变参数,只能用数组
newClass[]{Collection.class},
//第三个参数是一个InvocationHandler子类对象.他是一个匿名内部类
newInvocationHandler(){
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
return null;
}
}
);
System.out.println(proxy3);
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
上面的代码1创建了一个动态代理类proxy3...我们还没有为这个proxy3挂上(指定)目标类,就给他指定一个目标进去,在InvocationHandler内部给他指定一个目标类(arraylist),,
代码2
//创建一个代理类实例对象
Collectionproxy3=(Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),
//interfaces是一个数组,,而不能是可变参数,因为可变参数必须位于newProxyInstance方法参数的最后(必须是最后面的一个参数),
//这里的interfaces 不是最后面的一个参数,所以不能用可变参数,只能用数组
newClass[]{Collection.class},
//第三个参数是一个InvocationHandler子类对象.他是一个匿名内部类
newInvocationHandler(){
//在InvocationHandler内部给他(代理类)指定一个目标类,,
//可以在InvocationHandler内部的任意位置指定目标类
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
//这里给代理类指定一个ArrayList目标类
ArrayListtarget=new ArrayList();
returnmethod.invoke(target, args);
}
}
);
3…InvocationHandler对象的运行原理
(1)
动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
(2)
构造方法接收一个InvocationHandler对象，接收对象了要干什么用呢？该方法内部的代码会是怎样的呢？
(3)
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：
Client程序调用objProxy.add(“abc”)方法时，涉及三要素：objProxy对象、add方法、“abc”参数,,,objProxy是代理对象,add是代理对象的方法
Class Proxy$ {
//别人在调用这个代理对象的add方法时,,这个add方法内部就把add方法接收的那三个要素传递给了invoke方法
add(Objectobject) {
//args是方法的参数
returnhandler.invoke(Object proxy, Method method, Object[] args);
}
}
别人在调用代理对象的方法时涉及到了3个要素,这个方法内部就把这3个要素传递给了invoke方法
(4)
分析先前打印动态类的实例对象时，结果为什么会是null呢？调用有基本类型返回值的方法时为什么会出现NullPointerException异常？
(5)
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？ 代码5
调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。
voidclear(){
handler.invoke(this,this.getClass().getMethod("clear"),null);
}
代码1:
//创建一个代理类实例对象
Collectionproxy3=(Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),
//interfaces是一个数组,,而不能是可变参数,因为可变参数必须位于newProxyInstance方法参数的最后(必须是最后面的一个参数),
//这里的interfaces 不是最后面的一个参数,所以不能用可变参数,只能用数组
newClass[]{Collection.class},
//第三个参数是一个InvocationHandler子类对象.他是一个匿名内部类
newInvocationHandler(){
//在InvocationHandler内部给他(代理类)指定一个目标类,,
//可以在InvocationHandler内部的任意位置指定目标类
//这里给代理类指定一个ArrayList目标类
//此时target就是匿名内部类的成员变量了,下面的invoke的方法不管执行多少次,他使用的都是这个成员变量
ArrayListtarget=new ArrayList();
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
//在调用目标类的方法(method.invoke(target,args))之前和之后加点代码(代理类调用目标类的方法并对这个方法增加功能),,
//测试这个method.invoke(target, args方法的运行时间
longbeginTime = System.currentTimeMillis();
ObjectretVal = method.invoke(target, args);
longendTime = System.currentTimeMillis();
System.out.println(method.getName()+ " running time of " + (endTime - beginTime));
returnretVal;
}
}
);
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
调用代理对象的add和size方法,这个代理对象的add和size方法的内部做的是:他会去调用代理对象身上的InvocationHandler()对象里面的invoke方法,所以我们每调用一次代理对象的add方法,这个invoke方法就执行了一次,
注意;可以在执行method.invoke(target, args)方法之前对args进行修改,比如设置一个过滤器把你传进来的args的数据过滤修改后再传给method.invoke,,
还可以对retVal返回值进行修改,,把返回的结果修改后返回
method.invoke(target, args);:
调用目标对象的方法,就是在目标对象身上执行那个代理对象正在执行的方法(proxy3.add),,,也就是在目标对象身上执行add方法,这里不是调用代理对象的add方法
3…总结分析动态代理类的设计原理与结构
源对象的类必须自己定义时就实现接口，从该类的祖辈类上继承的接口是无效的。
该方法接口两个参数：一个是目标对象，另一个是封装了用户系统功能代码的Advice对象，
该对象必须实现Advice接口。
*/
getProxy
由此联想到spring的一个问题：spring无法将通知应用到目标类的父类的方法上，例如，我们写的Action继承了DispatachAction，那么spring无法将advice应用到execute方法上。
(2)
怎样将目标类传进去？
直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
(3)
将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
(4)
将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
为bind方法增加一个Advice参数。
把系统功能的代码以参数的形式传递进来,,把这些系统功能代码放在一个对象a的方法里面,,之后把这个对象传递给InvocationHandler对象使用,,InvocationHandler 对象在执行a对象里面的方法就可以了,,这就是面向切面的编程,,就是把切面代码用对象的形式进行封装,然后以对象的形式传递给你,之后你执行对象里面的方法就等于执行了切面代码
4…_编写可生成代理和插入通告的通用方法
//现在把创建动态类和创建实例对象的这2个步骤合二为一,之前是先得到代理类的字节码,然后再用字节码创建实例对象,现在想一步到位,,,使用newProxyInstance方法
publicstatic void name() {
//不加final就报错,,name方法里面的内部类要想访问这个name方法里面的局部变量target,那么这个变量就必须final修饰
finalArrayList target=new ArrayList();
Collectionproxy3 = (Collection)getProxy(target, new MyAdvice());
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
System.out.println(proxy3.getClass().getName());
}
//构造一个代理方法
//把这个方法做成通用的方法(不仅仅只对集合进行处理),那么返回值Collection和参数ArrayList就改为object(对任意的类型都可以进行封装)
//接收一个切面代码对象进来,,
//Adviceadvice不加final就报错,,getProxy方法里面的内部类要想访问这个getProxy方法里面的局部变量advice,那么这个变量就必须final修饰
privatestatic Object getProxy(final Objecttarget,final Advice advice) {
//创建一个代理类实例对象
Objectproxy3=Proxy.newProxyInstance(
target.getClass().getClassLoader(),
//与target实现相同的接口,target(目标类)实现了什么接口.我(代理类)这里就去实现与target相同的接口
target.getClass().getInterfaces(),
newInvocationHandler(){
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
//在这里我要调用那个(切面代码对象)对象,而那个对象的名称我又不知道,那就通过接口来约定
//就是我知道你(切面代码对象)对象一定实现了某个接口,我有这个接口就可以调用你,你一定要实现那个接口,这就叫通信的契约(接口)
//所以要自己写定义一个接口(契约),,那么这里就通过一个接口去引用传入进来的(切面代码对象)对象
advice.beforeMethod(method);
ObjectretVal = method.invoke(target, args);
advice.afterMethod(method);
returnretVal;
}
}
);
returnproxy3;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
