1.由于静态代理产生的代理类过多，造成代码量急剧增加，所以在实际开发中，通常使用动态代理来实现代理功能。
2.在java中实现动态代理的方式有很多。Jdk中通过接口来实现动态代理，如果要实现类的动态代理可以使用 cglib。目前也可以通过 javassit 来实现代理。
3.Jdk的动态代理实现是通过一个类和一个接口来实现的。
InvocationHandler 是代理实例 的调用处理程序 实现的接口。
invoke( proxy,
method,
[] args)
throws
在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
参数：
proxy - 在其上调用方法的代理实例
method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。
args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。
返回：
从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。
抛出：
- 从代理实例上的方法调用抛出的异常。该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型，代理实例的方法调用将抛出包含此方法曾抛出的异常的 。
Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
public static newProxyInstance( loader,
<?>[] interfaces,
h)
throws
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：
Proxy.getProxyClass(loader, interfaces).
getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。
参数：
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序
返回：
一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口
抛出：
- 如果违反传递到 getProxyClass 的参数上的任何限制
- 如果 interfaces 数组参数或其任何元素为 null，或如果调用处理程序 h 为 null
4.通过动态代理实现租房
MyInvocationHandler.java
public class MyInvocationHandler implements InvocationHandler{ //目标对象 ---真实对象 private Object target; @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { fare(); //调用真实对象 执行其方法 return method.invoke(target, args); } private void fare(){ System.out.println("中介收费"); } public void setTarget(Object target) { this.target = target; }} Rent.java
public interface Rent { //租房 public void rent();} Host.java
public class Host implements Rent{ @Override public void rent() { System.out.println("========将房屋出租======="); }} Client.java
public class Client { public static void main(String[] args) { Host host = new Host(); MyInvocationHandler handler = new MyInvocationHandler(); handler.setTarget(host); Rent proxy=(Rent)Proxy.newProxyInstance(Client.class.getClassLoader(), host.getClass().getInterfaces(), handler); proxy.rent(); }} 5.封装为一个类
public class DynamicProxy implements InvocationHandler{ private Object target; public void setTarget(Object target) { this.target = target; } public Object getProxy(){ return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); //result方法执行的返回值 Object result = method.invoke(target, args); after(); return result; } private void before(){ System.out.println("在真实方法执行前 添加新的功能"); } private void after(){ System.out.println("在真实方法执行后 添加新的功能"); }} 总结：动态代理解决了静态代理的缺点；一个类可以代理多个真实对象。