求助，动态代理模式的困惑

checkcode
小弟最近在看动态代理的时候觉得有些奇怪

package bbb;

import java.lang.reflect.*;
import java.util.*;

public class Test implements java.lang.reflect.InvocationHandler {
	private Object ob;
	
	public Test(Object oo) {
		ob = oo;	
	}	
	
	public static Object factory(Object oo) {
		Class cls = oo.getClass();
		Object o = Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new Test(oo));
//		System.out.println(o.getClass()); //此处的对像是Proxy?????
		return o;	
	}
	
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
	{
		//System.out.println("我让代理了");	
		Object o = method.invoke(ob,args);

		return o;
	}
	
	public static void main(String args[]) throws Exception {
    	Object oo = factory(new TTT()); //如果factory是Proxy,如何转型成Good?
    	System.out.println(oo.getClass().getName());
    	Proxy v = (Proxy)oo;
    	System.out.println(v);
    	Good f = (Good)v;
    	f.ff();
    }
}

interface Good {
	void ff();	
}

class TTT implements Good {
	public void ff() {}
}

我的问题是一个类并没有实现一个接口却能被转型成那个接口请问这是如何实现的？？？

checkcode 2007-02-27 14:43
没人回答？是不是我没描述清楚？？？？？

我的意思是

Proxy v = (Proxy)oo;
System.out.println(v);
Good f = (Good)v;
proxy并没有实现good接口，但是转换成good以后并不出错？
请问这是如何实现的？？？？？？？

Coolyu0916 2007-02-27 15:42
你的TTT不是实现了么？？
banq 2007-03-01 12:18
>我的问题是一个类并没有实现一个接口却能被转型成那个接口请问这是如何实现的
这就是动态代理的特点，这是JVM提供的一个底层机制，具体需要打开源码研究，但是我们搞JAVA不提倡向下研究到底的思维方式，因为这样探究下去，就要回到过去汇编时代，我们的时间和精力不允许，说不客气就是浪费时间和精力。

在有限时间精力下，我们只要知道有这样一个特点，我们需要研究的是，如何利用这个特点为我们应用服务，也就是模式思维，是一种向上面向业务的思维。

当然，我这样回答你可能不满意，因为虽然我使用动态代理做了Jdon框架，并且又基于其上开发N多复杂系统，但是其内部我还真不知道，我个人也没有想知道过。

checkcode 2007-03-01 20:51
这两天忙，没看贴，感谢各位关注

楼上的我觉的有些情况下，某种精神还是应该具备的 ^^

具体java源码我没看到，不过
昨晚测试，发现了一点东西，由于所有"对象实例"都是由Class(class.newInstance()，new是低层实现，我这里只是说明我的class指得是什么 :) )对象产生的但是动态内部将其class对象置换
TTT t = new TTT();

Object oo = factory(t);

Proxy v = (Proxy)oo;

System.out.println(v.getClass().getName()); //这里
System.out.println(v);
Good f = (Good)v;
f.ff();
但是由于需要得到被代理类的引用，需要传递其接口，
Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new Test(oo));
并且只能是接口
如果
abstract class Good {
abstract void ff();
}
就会出错

总结一下：
1被代理的类实际上，是被代理了class
2被代理类需要实现某个接口,而不是继承某个类
[该贴被checkcode于2007年03月01日 21:40修改过]

Coolyu0916 2007-03-01 20:53
public final class XXXXX$proxy extends Proxy implements Good
{
public final void ff()
{
try
{

//调用InvocationHandler的invoke方法
super.h.invoke(this, m3, null);
return;
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
private static Method m3;
static
{
try
{
m3 = Class.forName("Good").getMethod("ff", new Class[0]);
}
catch(NoSuchMethodException nosuchmethodexception)
{
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
}
catch(ClassNotFoundException classnotfoundexception)
{
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}

public XXXXX$proxy(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
}

这个是他替你写的东西
你看看这个就明白你问得问题了
[该贴被Coolyu0916于2007年03月01日 21:03修改过]

checkcode 2007-03-01 21:37
谢了楼上的朋友

你这段代码是回调实现，应该算模式的应用吧，我问的是底层实现:)
我过我发现proxy中最重要的部分，竟然是

private static native Class defineClass0(ClassLoader loader, String name,
byte[] b, int off, int len);

.......


不过谢了各位，终于认识到有些东西应该先记住（但是探究总是好的） :)
[该贴被checkcode于2007年03月01日 21:39修改过]

Coolyu0916 2007-03-01 21:44


那就看看源代码吧

checkcode 2007-03-02 11:23
哦，谢了朋友