1. package com.itheima.dynamic.proxy;
   
2.                         public interface Subject {
   
3.                                 public void request();
   
4.                         }
   
5. 
   
6.                         package com.itheima.dynamic.proxy;
   
7.                         public class RealSubject implements Subject {
   
8.                                 @Override
   
9.                                 public void request()
   
10.                                 {
    
11.                                         System.out.println("需要被代理的任务。。。");
    
12.                                 }
    
13.                         }
    
14. 
    
15.                         package com.itheima.dynamic.proxy;
    
16.                         import java.lang.reflect.InvocationHandler;
    
17.                         import java.lang.reflect.Method;
    
18.                         public class DynamicSubject implements InvocationHandler {
    
19.                                 private Subject sub;
    
20.                                 public DynamicSubject(Subject sub)
    
21.                                 {
    
22.                                         this.sub = sub;
    
23.                                 }
    
24.                                 @Override
    
25.                                 public Object invoke(Object proxy, Method method, Object[] args)
    
26.                                                 throws Throwable
    
27.                                 {
    
28.                                         System.out.println("被代理执行之前：" + method);
    
29.                                         method.invoke(sub, args);
    
30.                                         System.out.println("被代理执行之后：" + method);
    
31.                                         return null;
    
32.                                 }
    
33.                         }
    
34. 
    
35.                         package com.itheima.dynamic.proxy;
    
36.                         import java.lang.reflect.InvocationHandler;
    
37.                         import java.lang.reflect.Proxy;
    
38.                         public class Test {
    
39.                                 public static void main(String[] args) {
    
40.                                         //创建被代理类的对象
    
41.                                         Subject sub = new RealSubject();
    
42.                                         //创建代理类对象，并将被代理类传递进去
    
43.                                         InvocationHandler handler = new DynamicSubject(sub);
    
44.                                         //获取代理类的Class对象
    
45.                                         Class c = handler.getClass();
    
46.                                 
    
47.                                         sub = (Subject)Proxy.newProxyInstance(c.getClassLoader(), sub.getClass().getInterfaces(), handler);//这里是什么意思？还有getInterfaces()这个方法时干什么的？
    
48.                                         //调用方法
    
49.                                         sub.request();
    
50.                                         System.out.println("------------------------------------------------");
    
51.                                         System.out.println("自动生成动态代理类的名字：" + sub.getClass().getName());
    
52.                                         Class[] interfaces = sub.getClass().getInterfaces();
    
53.                                         for(Class item : interfaces)
    
54.                                                 System.out.println("自动生成动态代理类所实现的接口" + item);
    
55.                                        
    
56.                                 }
    
57.                         }

复制代码

sub = (Subject)Proxy.newProxyInstance(c.getClassLoader(), sub.getClass().getInterfaces(), handler);//这里是什么意思？还有getInterfaces()这个方法时干什么的？\

这句话的意思是说 创建了代理类的实例对象,  首先c.getClassLoader() 是目标类的类加载器, 然后sub.getClass().getInterfaces() 获取到目标类里所有实现的接口.. 如果传进去的是一个接口的话, 那么.. 就是jiekou.class

最后传进去一个要执行的方法.. 由代理执行.. 所以用到了InvocationHandler 接口..

InvocationHandler 里必须要有一个代理执行目标的方法, method.invoke(sub, args);  这个sub是从目标类的接口中获取.. 也就是说 代理延续了之前类执行的方法.. 交由代理去实现

这题由于老师跟API里说的有出入. 我跟同学讨论了一下.. 暂时不能给出正确的答案..

API里说的参数是代理类的类加载器, 老师视频里说的是目标类的类加载器

但是具体的思路还是一样的.. 就是不知道 到底是代理还是目标, 这个无法确定

sub = (Subject)Proxy.newProxyInstance(c.getClassLoader(), sub.getClass().getInterfaces(), handler);
这句是调用Proxy类的静态方法创建一个代理实例；
首先你要知道 创建一个代理实例有两种方法，
一种是通过反射获得代理类Proxy的构造方法（因为Proxy的构造方法是被保护的，所以不能直接用构造方法创建一个实例），然后用这个创建一个实例（Proxy只有一个带参的构造函数）；
另一种就是直接调用Proxy类的静态方法newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h),需要传入三个参数；也就是楼主用的这种。
至于getInterface()是返回sub对象所在的类实现的接口，并且返回的是class[]类型的，也正符合参数的要求。

getInterface是获得目标类接口。