public interface Service
{  
  public void add();
}

public class ServiceImpl implements Service
{
  public void add()
  {
    System.out.println("添加用户！");
    
  }
}

public class ServiceProxy implements Service
{
  private Service service;
  public ServiceProxy(Service service)
  {
    super();
    this.service = service;
  }
  public void add()
  {
    System.out.println("服务开始");
    service.add();
    System.out.println("服务结束");
  }
}

public class TestMain
{
  public static void main(String[] args)
  {
    Service serviceImpl=new ServiceImpl();
    Service proxy=new ServiceProxy(serviceImpl);
    proxy.add();
  }
}

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy)

// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces)

// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl)

// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h)

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
Object invoke(Object proxy, Method method, Object[] args)

public class ServiceHandle implements InvocationHandler
{
  private Object s;
  
  public ServiceHandle(Object s)
  {
    this.s = s;
  }
  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable
  {
    System.out.println("服务开始");
    //invoke表示对带有指定参数的指定对象调用由此 Method 对象表示的底层方法
    Object result=method.invoke(s, args);
    System.out.println("服务结束");
    return result;
  }
}

public class TestMain
{
  public static void main(String[] args)
  {
    Service service=new ServiceImpl();
    InvocationHandler handler=new ServiceHandle(service);
    Service s=(Service) Proxy.newProxyInstance(service.getClass().getClassLoader(), service.getClass().getInterfaces(), handler);
    s.add();
  }
}

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });

// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });

// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException
　　{
       //检查h不为空，否则抛异常
      Objects.requireNonNull(h);
      //获得与制定类装载器和一组接口相关的代理类类型对象
      final Class<?>[] intfs = interfaces.clone();
      
      //检查接口类对象是否对类装载器可见并且与类装载器所能识别的接口类对象是完全相同的
      final SecurityManager sm = System.getSecurityManager();  
      if (sm != null) 
      {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
      }
      //获得与制定类装载器和一组接口相关的代理类类型对象
      Class<?> cl = getProxyClass0(loader, intfs);
      try
      {
        if (sm != null) 
        {
          checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
        // 通过反射获取构造函数对象并生成代理类实例
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) 
        {
          AccessController.doPrivileged(new PrivilegedAction<Void>() 
          {
            public Void run() 
            {
            cons.setAccessible(true);
            return null;
            }
          });
        }
        return cons.newInstance(new Object[]{h});
      } 
      catch (IllegalAccessException|InstantiationException e)
      {
        throw new InternalError(e.toString(), e);
      }
      catch (InvocationTargetException e) 
      {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) 
        {
          throw (RuntimeException) t;
        }
        else 
        {
          throw new InternalError(t.toString(), t);
        }
      } 
      catch (NoSuchMethodException e) 
      {
        throw new InternalError(e.toString(), e);
      }
　}

public class Proxy
{
  public static Object newProxyInstance(Class inface,InvocationHandle h) throws Exception
  {
    String rt="\r\n";
    String methodStr="";
    Method[] methods=inface.getMethods();
    for(Method m:methods)
    {
      methodStr+="@Override"+rt+
           "public void "+m.getName()+"()"+rt+"{" + rt +
          "  try {"+rt+
          " Method md="+inface.getName()+".class.getMethod(\""+m.getName()+"\");"+rt+
            "h.invoke(this,md);"+rt+
          "  } catch(Exception e){e.printStackTrace();}"+rt+
          
          "}";
    }
    String src="package test;"+rt+
        "import java.lang.reflect.Method;"+rt+
        "public class ServiceImpl2 implements "+inface.getName()+ rt+
        "{"+rt+
          "public ServiceImpl2(InvocationHandle h)"+rt+
          "{"+rt+
            "this.h = h;"+rt+
          "}"+rt+
          " test.InvocationHandle h;"+rt+
          methodStr+
        "}";
    String fileName="d:/src/test/ServiceImpl2.java";
    //compile
    compile(src, fileName);
    //load into memory and create instance
    Object m = loadMemory(h);
    
    return m;
  }
  private static void compile(String src, String fileName) throws IOException
  {
    File f=new File(fileName);
    FileWriter fileWriter=new FileWriter(f);
    fileWriter.write(src);
    fileWriter.flush();
    fileWriter.close();
    //获取此平台提供的Java编译器
    JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
    //获取一个标准文件管理器实现的新实例
    StandardJavaFileManager fileManager=compiler.getStandardFileManager(null,null, null);
    //获取表示给定文件的文件对象
    Iterable units=fileManager.getJavaFileObjects(fileName);
    //使用给定组件和参数创建编译任务的 future
    CompilationTask t=compiler.getTask(null, fileManager, null, null, null, units);
    //执行此编译任务
    t.call();  
    fileManager.close();
  }
  private static Object loadMemory(InvocationHandle h)
      throws MalformedURLException, ClassNotFoundException,
      NoSuchMethodException, InstantiationException,
      IllegalAccessException, InvocationTargetException
  {
    URL[] urls=new URL[] {new URL("file:/"+"d:/src/")};
    //从路径d:/src/加载类和资源
    URLClassLoader ul=new URLClassLoader(urls);
    Class c=ul.loadClass("test.ServiceImpl2");
    //返回Class对象所表示的类的指定公共构造方法。  
    Constructor ctr=c.getConstructor(InvocationHandle.class);
    //使用此 Constructor对象ctr表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
    Object m = ctr.newInstance(h);
    return m;
  }
}