java.lang.reflect.Proxy @since 1.3

import java.lang.Override; 
import java.lang.System; 
import staticProxy.Servlet; 

class Proxy implements Servlet { 
      private Servlet impl; 
 
      public Proxy(Servlet impl) { this.impl = impl; } 
      
      @Override 
public void uploadFile() { 
　　　　　　　　long start = System.currentTimeMillis(); 
this.impl.uploadFile(); 
long end = System.currentTimeMillis(); 
             System.out.println("Fly Time =" + (end - start)); 
      } 
} 

那么利用javapoet可以这么写,我写Proxy1 是1.0版本 
public class Proxy1 { 

            public static Object newProxyInstance() throws IOException { 
                   //第一步 通过javapoet工具类 创建一个名为Proxy的java类 , 该类实现了Servlet接口 
                   // == public class Proxy implement Servlet //这里之前少写一个public 导致后面获取构造器对象时报NoSuchException, 
                   TypeSpec.Builder typeSpecBuilder = TypeSpec.classBuilder("Proxy") .addModifiers(Modifier.PUBLIC)//定义类的修饰符//构造一个类,类名 
                      .addSuperinterface(Servlet.class); 
 
                   //第二步 创建类里面的属性 我们要注入该接口 
                   //我们希望的属性是 private Servlet impl //所以指定 属性的类型 和 属性的名字 和 属性的范围 
                   //注意 Modifier包千万不要导错了,import javax.lang.model.element.Modifier; //之前报错找了好久 
                   FieldSpec fieldSpec = FieldSpec.builder(Servlet.class, "impl", Modifier.PRIVATE).build(); 

                   //将属性 添加到类中 
                   typeSpecBuilder.addField(fieldSpec); 

                  //我们希望构造方法中 将该接口的实现类 传到构造器里 方便灵活调用要处理的方法 //Proxy(Servlet impl) { // this.impl = impl; // } 
                  MethodSpec constructorMethodSpec = MethodSpec.constructorBuilder()
                        .addModifiers(Modifier.PUBLIC).addParameter(Servlet.class, "impl")
                        //构造器传入参数的类型 就是你要创建的java类实现接口的类型, 属性名字 
                        .addStatement("this.impl = impl")//构造器里面的语句 
                        .build(); 

　　　　　　　　　　 typeSpecBuilder.addMethod(constructorMethodSpec); 
 
                   //类 ,属性 ,构造器都写完了, 接下来开始写方法 , 你实现的接口有N个方法 
                   Method[] methods = Servlet.class.getDeclaredMethods(); 
                   for (Method method : methods) { 

                       //在文件中写入方法 和 方法内容 方法里有返回值 入参 方法名 
                      MethodSpec methodSpec = MethodSpec.methodBuilder(method.getName()) 
 
                     //给方法添加范围 
                     .addModifiers(Modifier.PUBLIC) 
                     //给方法添加 注解 通常都是实现 x接口的覆盖注解  
                     .addAnnotation(Override.class) 
                    //给方法添加返回值通过method.getReturnType能拿到该方法return接收的对象
.returns(method.getReturnType()) 
                    //给方法添加语句 这里是给每个方法都加上了一个计算时间              
                    .addStatement("long start = $T.currentTimeMillis()", System.class) 

                    //添加换行符 
                    .addCode("\n") //添加执行语句 我们希望的执行语句是 执行传过来的接口的某个方法 //比如 impl.upload() 
                    .addStatement("this.impl." + method.getName() + "()") .addCode("\n") //$T可以理解为占位符,javapoet会去找对应的类 
                    .addStatement("long end = $T.currentTimeMillis()", System.class) 
                    .addStatement("$T.out.println(\"Fly Time =\" + (end - start))", System.class) 
                    .build(); 


                   typeSpecBuilder.addMethod(methodSpec); 
            } 

　　　　　　//生成一个 TypeSpec 前面定义的java文件 第一个参数是包名 这样生成的xx.java文件再次包下 
　　　　　　JavaFile javaFile = JavaFile.builder("proxy", typeSpecBuilder.build()).build(); 
　　　　　　String sourcePath = "C:/Users/自己登陆的电脑用户名/Desktop"; 

　　　　　　//在桌面上生成一个Proxy.java的文件 
　　　　　　javaFile.writeTo(new File(sourcePath)); return null; 
}

public interface InvocationHandler {
    void invoke(Object proxy, Method method, Object[] args);
}

package animateProxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import staticProxy.Servlet;

public class MyInvocationHandler implements InvocationHandler {

    private Servlet impl; //为了完成对被代理对象的方法拦截，我们需要在InvocationHandler对象中传入被代理对象实例。

    public MyInvocationHandler(Servlet impl) {
        this.impl = impl;
    }
    
    
    //参数1  想要、
    
    //参数2  这个参数表示  传入接口  中的所有Method对象
    
    //参数3 这个参数   对应当前method方法   中的参数
    @Override
    public void invoke(Object proxy, Method method, Object[] args) {
        // TODO Auto-generated method stub
        //1.自定义想要加在 动态代理类 的方法的处理 比如 
        //统计想要 代理类的 方法的时间
        long start = System.currentTimeMillis();
        
        System.out.println("proxy:" + proxy); //proxy: proxy.Proxy@636a59bb
        
        try {
            //方法的反射操作
            //方法的反射操作是method对象来进行方法调用
            //和 执行  impl.upload() 效果完全相同
            method.invoke(impl, new Object[] {});
            
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println("Fly time = " + (end - start));
        
        
    }

}

package proxy;

import animateProxy.InvocationHandler;
import java.lang.Override;
import java.lang.reflect.Method;
import staticProxy.Servlet;

public class Proxy implements Servlet {
  private InvocationHandler handler;

  public Proxy(InvocationHandler handler) {
    this.handler = handler;
  }

  @Override
  public void uploadFile() {
    try {
        Method method = staticProxy.Servlet.class.getMethod("uploadFile");
         this.handler.invoke(this, method, null);
    } catch(Exception e) {
        e.printStackTrace();
    }
  }
}

package animateProxy;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

import javax.lang.model.element.Modifier;




import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

/**
 * 
 * 现在在proxy2的基础上进化下, 
 * 
 * 现在想执行  我们自己 想执行的代码 而不是 
 * 
 * 固定的写死的 计算每个方法时间的代码
 * 
 * 这点比较难想到 , 就是代理的逻辑抽取出来, 把打印方法执行时间的逻辑抽取出来
 * 可以自定义个接口 用于处理自己想  加在代理对象上面的方法
 * 
 * 定义个接口 ,所有想写自己的代理的类的 处理逻辑的 都必须 实现该接口
 * 
 * 然后将实现了 该接口的对象  接口传进来 
 * 
 * 
 * 修改后是为了实现 TimProxy里面的内容
 * 
 * this.handler.invoke(this, method, null);
 * 代码理解起来比较吃力  看个图
 *                                                                      InvocationHandler
 *                                  InterfaceT.java                     |·
 *                                  |           |                       聚合了MyInvocationHandler.java
 * Proxy.newProxyInstance----->TimeProxy      interfaceTimpl.java       |
 *                                  |                                   |
 *                                  ------------------------------------
 * 
 * 
 * TimeProxy.upload()---------->MyInvocationHandler.invoke()---->interfaceTimpl.upload()
 * 
 * <p>Title: Proxy1</p>  
 * <p>Description: </p>  
 * @author 18045153  
 * @date 2019年2月27日
 */
public class Proxy3 {
    
    //只要你在newProxyInstance方法中指定代理需要实现的接口Class clazz
    //jdk1.3 Class<?>[]：第二个参数也和我们的实现版本不一致，这个其实很容易理解，
    //我们应该允许我们自己实现的代理类同时实现多个接口。前面设计只传入一个接口，只是为了简化实现，让你专注核心逻辑实现而已
    public static Object newProxyInstance(Class clazz, InvocationHandler handler) throws IOException, ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        
        //第一步 通过javapoet工具类 创建一个名为TimeProxy的java类 , 该类实现了interfaceT接口
        //InterfaceT.class ===   public class TimeProxy implement InterfaceT
        
        TypeSpec.Builder typeSpecBuilder = TypeSpec.classBuilder("Proxy")
                .addModifiers(Modifier.PUBLIC)//定义类的修饰符//构造一个类,类名
                .addSuperinterface(clazz);
        
        
        
        //第二步 创建类里面的属性 我们要注入该接口 具体参考interfaJuhe.java 的写法
        //我们希望的属性是 InterfaceT impl
        //所以指定 属性的类型 和 属性的名字 和 属性的范围
        
        //在生成的代理类中增加成员变量handler 效果就是 private InvocationHandler handler
        FieldSpec fieldSpec = FieldSpec.builder(InvocationHandler.class, "handler", Modifier.PRIVATE).build();
        
        //将属性 添加到类中
        typeSpecBuilder.addField(fieldSpec);
        
        
        //我们希望构造方法中 将该接口的实现类 传到构造器里 方便灵活调用要处理的方法
        //interfaJuhe(InterfaceT impl) {
        //    this.impl = impl;
        //  }
        
        
        //效果就是 public TimeProxy(InvocationHandler handler ) {
        //              this.handler = handler;
        //}
        MethodSpec constructorMethodSpec = MethodSpec.constructorBuilder()
                .addModifiers(Modifier.PUBLIC)
                .addParameter(InvocationHandler.class, "handler")//构造器传入参数的类型 就是你要创建的java类实现接口的类型, 属性名字
                .addStatement("this.handler = handler")//构造器里面的语句
                .build();
        
        typeSpecBuilder.addMethod(constructorMethodSpec);
        
        //类 ,属性 ,构造器都写完了, 接下来开始写方法 , 你实现的接口有N个方法
        //本来方法是写死的 , 现在该为 
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            
            //在文件中写入方法 和 方法内容  方法里有返回值 入参 方法名 
            MethodSpec methodSpec = MethodSpec.methodBuilder(method.getName())
                     //给方法添加范围
                    .addModifiers(Modifier.PUBLIC)
                     //给方法添加 注解  通常都是实现 x接口的覆盖注解
                    .addAnnotation(Override.class)
                     //给方法添加返回值    通过method.getReturnType能拿到该方法return接收的对象
                    .returns(method.getReturnType())
                     //给方法添加语句  这里是给每个方法都加上了一个计算时间
                    
                    .addCode("try {\n")
                    
                     //Method method = staticProxy.Servlet.class.getMethod("uploadFile");
                     //这样写是为了拿到 要代理的那个接口类的 xx 方法
                    .addStatement("\t$T method = " + clazz.getName() + ".class.getMethod(\"" + method.getName() + "\")", Method.class)
                     // 为了简单起见，这里参数直接写死为空
                    
                     //这样写诗为了执行 实现了InvocationHandler接口的 java类自己的处理方法
                     // this.handler.invoke(this, method, null);
                    .addStatement("\t this.handler.invoke(this, method, null)")
                    .addCode("} catch(Exception e) {\n")
                    .addCode("\te.printStackTrace();\n")
                    .addCode("}\n")

                    .build();
            //给每个类加一个方法
            typeSpecBuilder.addMethod(methodSpec);
        }
        
        //生成一个 TypeSpec 前面定义的java文件  第一个参数是包名 这样生成的xx.java文件再次包下
        //package animateProxy;
       
        
        
        
        String sourcePath = "C:/Users/"+System.getProperties().getProperty("user.name")+"/Desktop";
        
        JavaFile javaFile = JavaFile.builder("proxy", typeSpecBuilder.build()).build();
        // 为了看的更清楚，我将源码文件生成到桌面
       
        javaFile.writeTo(new File(sourcePath));
 
        // 编译
        JavaCompiler.compile(new File(sourcePath + "/proxy/Proxy.java"));
 
        // 使用反射load到内存
        URLClassLoader classLoader = new URLClassLoader(new URL[] { new URL("file:C:\\Users\\"+System.getProperties().getProperty("user.name")+"\\Desktop\\") });

        Object obj = null;
        
        //Classloader：类加载器，你可以使用自定义的类加载器，我们的实现版本为了简化，直接在代码中写死了Classloader。
        
        Class clazz1 = classLoader.loadClass("proxy.Proxy");
        
        System.out.println(clazz1);
        System.out.println(clazz1.getDeclaredConstructors().getClass());
        
        //将生成的TimeProxy编译成class 使用类加载器加载进内存中 再通过反射或者该类的构造器 
        //再通过构造器将其代理类 TimeProxy 构造出来
        
        //NoSuchException  打印classz信息 发现 刚开始创建类 没有使用public 
        Constructor constructor = clazz1.getConstructor(InvocationHandler.class);
        System.out.println("constructor" + constructor);
        obj = constructor.newInstance(handler);
        
        return obj;

    }
 
}

        Servlet a = (Servlet) Proxy3.newProxyInstance(Servlet.class, handler);
        
        System.out.println("返回的代理对象" + a);//返回的代理对象proxy.TimeProxy@5b2936fa

        //handler.invoke(a, a.getClass().getDeclaredMethod("uploadFile", null), null);
        //Proxy.newProxyInstance(Flyable.class, new MyInvocationHandler(new Bird()));
        // 代理了interfaceTimpl类 并且 写了自己的实现
        a.uploadFile();