1. 
   
2. <P>import java.lang.reflect.InvocationHandler;
   
3. import java.lang.reflect.Method;
   
4. import java.lang.reflect.Proxy;
   
5. 
   
6. public class MyHandler implements InvocationHandler
   
7. {
   
8. Object target ;
   
9. Advice advice ;
   
10. public MyHandler(Object target , Advice advice )
    
11. {
    
12. this.target = target;
    
13. this.advice = advice;
    
14. }
    
15. 
    
16. @Override
    
17. public Object invoke(Object proxy, Method method, Object[] args)
    
18. throws Throwable
    
19. {
    
20. advice.beforDo(method);
    
21. //这里执行方法不是要在Object proxy对象上执行吗？为什么往往都是在目标对象上执行呢？
    
22. Object retval = method.invoke(target , args);
    
23. advice.afterDo(method);
    
24. return retval;
    
25. }
    
26. 
    
27. public Object getDynamicProxy()
    
28. {
    
29. return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this );
    
30. }
    
31. }</P>

复制代码

1. import java.lang.reflect.InvocationHandler;
   
2. import java.util.ArrayList;
   
3. import java.util.List;
   
4. 
   
5. public class MyDynamicTest
   
6. {
   
7. public static void main(String[] args)
   
8. {
   
9. List<String> list = new ArrayList<String>();
   
10. Advice advice = new MyAdvice();
    
11. MyHandler handler = new MyHandler(list, advice);
    
12. List<String> listProxy = ( List)handler.getDynamicProxy();
    
13. listProxy.add("Ansen");
    
14. listProxy.add("Kaka1 SB");
    
15. listProxy.add("Rudy SB");
    
16. System.out.println( listProxy.size());
    
17. 
    
18. }
    
19. 
    
20. }
    

复制代码

1. import java.lang.reflect.Method;
   
2. 
   
3. public interface Advice
   
4. {
   
5. public abstract void beforDo(Method m);
   
6. public abstract void afterDo(Method m);
   
7. }

复制代码

1. import java.lang.reflect.Method;
   
2. 
   
3. public class MyAdvice implements Advice
   
4. {
   
5. long startTime = 0;
   
6. @Override
   
7. public void beforDo(Method m)
   
8. {
   
9. System.out.println(m.getName()+"方法开始执行!");
   
10. startTime = System.currentTimeMillis();
    
11. }
    
12. @Override
    
13. public void afterDo(Method m)
    
14. {
    
15. long endTime =System.currentTimeMillis();
    
16. System.out.println();
    
17. System.out.println(m.getName()+"方法执行结束! 执行用时为:"+(endTime-startTime));
    
18. 
    
19. }
    
20. }
    

复制代码

问题一:   
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
advice.beforDo(method);
//这里执行方法正常不是要在Object proxy对象上执行吗？为什么往往都是在目标对象上执行呢？
Object retval = method.invoke(target , args);
advice.afterDo(method);
return retval;
}
为什么不写成这种格式:
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
advice.beforDo(method);
Object retval = method.invoke(proxy , args);----->会导致死循环？为什么？
advice.afterDo(method);
return retval;
}

问题二:

protected

Proxy(InvocationHandler h) 使用其调用处理程序的指定值从子类（通常为动态代理类）构建新的 Proxy 实例。

Proxy这个类不不抽象类，构造方法也不是私有，是不是代表它可以创建对象？protected修饰的成员是可以被子类访问的，不是吗？

http://bbs.itheima.com/forum.php ... mp;page=1#pid478397
这是我前几天发的一个关于动态代理的帖子。
问题1：
invoke可以理解为一个代理方法，通过Proxy.newProxyInstance生成一个代理类的实例，然后流程就会转到实现了InvocationHandler的类的invoke方法里边。而这Proxy.newProxyInstance只是为了得到一个实例而已，在哪里用都没区别。

问题2：
Proxy可不可以创造对象你自己大可以实验一下，如果能，用这个对象调用newProxyInstance()我想效果也一样，不过这么做很明显是画蛇添足，静态方法推荐用类名来调用！