动态代理是JAVA的一大特性。
动态代理的优势就是实现无浸入式的代码扩展。
目前动态代理主要分为JAVA自己提供的动态代理和CGLIB类似框架。（本文只说JAVA自己提供的动态代理）
JAVA自带的动态代理是需要接口的。CGLIB这种则是直接修改字节码。
在学习Java动态代理之前，我们需要明白静态代理是怎么实现的，怎么说呢，动态代理是更优雅的实现代理模式。只有了解静态代理的不足之处，才能更好的运用动态代理。静态代理对于重复代码的解决很差劲，每一个override的方法都会有重复代码。如果一个项目有成百上千个Bean的话，岂不是要造很多静态代理类么？所以动态代理就出现了。
什么是代理模式？
代理模式的作用是：为其他对象提供一种代理以控制这个对象的访问。
代理模式有什么好处？
在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。
代理模式一般涉及的角色有？
抽象角色：声明真实对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。
代理角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标 对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单传地将调用传递给目标对象，同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：定义了代理对象所代表的目标对象，代理角色锁代表的真实对象，是我们最终要引用的对象，定义了代理对象所代表的目标对象。
抽象角色：
<pre>public abstract class AbstractObject {
//操作
public abstract void operation();
}</pre>
真实角色：
<pre>
public class RealObject extends AbstractObject {
@Override
public void operation() {
//一些操作
System.out.println("一些操作");
}
}
</pre>
代理角色：
<pre>
public class ProxyObject extends AbstractObject{
RealObject realObject = new RealObject();
@Override
public void operation() {
//调用目标对象之前可以做相关操作
System.out.println("before");
realObject.operation();
//调用目标对象之后可以做相关操作
System.out.println("after");
}
}
</pre>
<pre>public class Client {
public static void main(String[] args) {
// TODO Auto-generated method stub
AbstractObject obj = new ProxyObject();
obj.operation();
}
}
</pre>
以上是静态代理的实现，接下来才是进入正题了，Java的动态代理。
什么是动态代理？
代理类是在程序运行前不存在，运行时由程序动态生成的代理方式称为动态代理。
Java提供了动态代理的实现方式，可以在运行时刻动态生成代理类。这种代理方式的一大好处是可以方便对代理类的函数做统一或特殊处理，如记录所有函数执行时间，所有函数执行前添加验证判断，对某个特殊函数进行特殊操作，而不用像静态代理方式那样需要修改每个函数。
动态代理实例
实现动态代理包括散步：
1.新建委托类；
2.实现InvocationHandler接口，这是负责连接代理类和委托类的中间类必须实现的接口；
3.通过Proxy类新建代理类对象。
1-新建委托类
<pre>
public interface UserService{
public String getName(int id);
public Integer getAge(int id);
}
public class UserServiceImpl implements UserService {
@Override
public String getName(int id) {
System.out.println("------getName------");
return "Tom";
}
@Override
public Integer getAge(int id) {
System.out.println("------getAge------");
return 10;
}
}
</pre>
UserService是一个接口，定义了一些函数。
UserServiceImpl是委托类，实现了UserService接口，每个函数只是简单的输出字符串。动态代理要求委托类必须实现了某个接口，比如这里委托类UserServiceImpl实现了UserService。
2-实现InvocationHandler接口
<pre>
public class MyInvocationHandler implements InvocationHandler {
private Object target;
MyInvocationHandler() {
super();
}
MyInvocationHandler(Object target) {
super();
this.target = target;
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
if("getName".equals(method.getName())){
System.out.println("++++++before " + method.getName() + "++++++");
Object result = method.invoke(target, args);
System.out.println("++++++after " + method.getName() + "++++++");
return result;
}else{
Object result = method.invoke(target, args);
return result;
}
}
}
</pre>
target属性表示委托类对象。
InvocationHandler是负责连接代理类和委托类的中间类必须实现的接口。其中只有一个
<pre>public Object invoke(Object proxy, Method method, Object[] args)</pre>
函数需要去实现，参数：
proxy表示Proxy.newProxyInstance()生成的代理类对象。
method表示代理对象被调用的函数。
args表示代理对象被调用的函数的参数。
调用代理对象的每个函数实际最终都是调用了InvocationHandler的invoke函数。这里我们在invoke实现中添加了一些代码片。
invoke函数中我们也可以通过method做一些判断，从而对某些函数特殊处理。
3-通过Proxy类静态函数生成代理对象
<pre>public class Main1 {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
InvocationHandler invocationHandler = new MyInvocationHandler(userService);
UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(), invocationHandler);
System.out.println(userServiceProxy.getName(1));
System.out.println(userServiceProxy.getAge(1));
}
} </pre>
这里我们先将委托类对象new UserServiceImpl()
作为MyInvocationHandler
构造函数入参创建invocationHandler
对象；然后通过Proxy.newProxyInstance(…)
函数新建了一个代理对象，实际代理类就是在这时候动态生成的。我们调用该代理对象的函数就会调用到invocationHandler
的invoke
函数(是不是有点类似静态代理)，而invoke
函数实现中调用委托类对象new UserServiceImpl()
相应的 method(是不是有点类似静态代理)。
<pre>public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)</pre>
loader表示类加载器
interfaces表示委托类的接口，生成代理类时需要实现这些接口
h是InvocationHandler实现类对象，负责连接代理类和委托类的中间类
我们可以这样理解，如上的动态代理实现实际是双层的静态代理，开发者提供了委托类 B，程序动态生成了代理类 A。开发者还需要提供一个实现了InvocationHandler的子类 C，子类 C 连接代理类 A 和委托类 B，它是代理类 A 的委托类，委托类 B 的代理类。用户直接调用代理类 A 的对象，A 将调用转发给委托类 C，委托类 C 再将调用转发给它的委托类 B。
在Android的使用场景
基于 REST 的 Android 端网络请求框架 Retrofit
作用：简化网络请求操作。一般情况下每个网络请求我们都需要调用一次HttpURLConnection
或者HttpClient
进行请求，或者像 Volley 一样丢进等待队列中，Retrofit 极大程度简化了这些操作，示例代码如下：
<pre>public interface GitHubService {
@GET("/users/{user}/repos")
List<Repo> listRepos(@Path("user") String user);
}
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://api.github.com")
.build();
GitHubService service = restAdapter.create(GitHubService.class);</pre>
以后我们只需直接调用
<pre>List<Repo> repos = service.listRepos("octocat");</pre>
即可开始网络请求，Retrofit
的原理就是基于动态代理，它同时用到了 注解 的原理，本文不做深入介绍，具体请等待 Retrofit 源码解析 完成。
