代理模式：即Proxy Pattern，常用的设计模式之一。代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问。
代理概念 ：为某个对象提供一个代理，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。
下面以明星为例模拟需求说明静态代理和动态代理。
一、首先看静态代理
看下图：歌迷希望明星许巍唱歌(许巍即是目标对象)，但不可能直接找到许巍，只能通过许巍经纪人，然后经纪人让许巍唱歌。这里的经纪人即是许巍的一个代理对象，这样就可以阻止对目标对象的直接访问。
代理接口
package com.lizhou.test.proxy; /**
* 代理接口：明星
* @author bojiangzhou
* @date 2016年5月5日
*/
public interface Star { /**
* 明星唱歌
*/
void sing(String song); }
委托类：真正执行任务的类
package com.lizhou.test.proxy; /**
* 委托类：真正执行任务的类（许巍），实现了代理接口
* @author bojiangzhou
* @date 2016年5月5日
*/
public class Xuwei implements Star { public void sing(String song) {
System.out.println("许巍唱歌："+song);
} }
静态代理类，实现了代理接口：许巍经纪人
package com.lizhou.test.proxy; /**
* 静态代理类，实现了代理接口：许巍经纪人
* @author bojiangzhou
* @date 2016年5月5日
*/
public class XuweiProxy implements Star { /**
* 代理类持有一个委托类的对象引用
*/
private Star star; public XuweiProxy(Star star){
this.star = star;
} /**
* 代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理
*/
public void sing(String song) {
//代理类负责请求的预处理
System.out.println("-----预处理：分析打电话给许巍经纪人要许巍唱歌-----");
System.out.println("-----预处理：经纪人要求许巍唱歌-----"); //将请求分派给委托类处理
star.sing(song); //委托类执行完请求后的后续处理
System.out.println("-----后处理：许巍唱歌完毕-----");
} }
粉丝：通过代理对象让目标对象执行任务
package com.lizhou.test.proxy; /**
* 粉丝呼吁许巍唱歌
* 粉丝不可能直接找许巍唱歌，需要先联系经纪人，经纪人再让许巍唱歌
* @author bojiangzhou
* @date 2016年5月5日
*/
public class Fans { public static void main(String[] args) {
//创建代理对象(即经纪人)
XuweiProxy xuweiProxy = new XuweiProxy(new Xuwei()); xuweiProxy.sing("完美生活");
} }
这就是一个静态代理。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。
静态代理的缺点：
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
--------------------------------------------------------------------------------------------------------------------------------------------
二、动态代理
看下图：动态代理时，代理类(即经纪人)是没有实现代理接口的(Star)，是一个独立的类。那代理类如何代理目标对象呢？此时代理类则借助Proxy在运行时动态指向目标对象。
Java提供了一个Proxy类，Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
Proxy类：
---------------------
还是以明星为例模拟需求动态代理
代理接口不变：
package com.lizhou.test.proxy; /**
* 代理接口：明星
* @author bojiangzhou
* @date 2016年5月5日
*/
public interface Star { /**
* 明星唱歌
*/
void sing(String song); }
目标对象不变：
package com.lizhou.test.proxy; /**
* 委托类：真正执行任务的类（许巍），实现了代理接口
* @author bojiangzhou
* @date 2016年5月5日
*/
public class Xuwei implements Star { public void sing(String song) {
System.out.println("许巍唱歌："+song);
} }
代理类：通过Proxy来动态产生目标对象
动态代理类开发步骤：
1)写一个普通类，无需任何继承或实现
2)写一个实例变量，记住代理谁，即目标对象
3)使用构造方法为实例变量赋值
4)写一个普通方法，该方法的返回值是接口，该接口是目标对象的实现接口
package com.lizhou.test.proxy; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; /**
* 代理类：没有任何实现、继承
* @author bojiangzhou
* @date 2016年5月5日
*/
public class XuweiProxy { /**
* 代理类持有一个委托类的对象引用
*/
private Star star; public XuweiProxy(Star star){
this.star = star;
} /**
* 动态产生代理对象
* @return
*/
public Star getProxy(){
//参数一：loader表示动态代理对象是由哪个类加载器完成的。
//参数二：interface表示动态代理对象与目标对象有一样的方法。
//参数三：InvocationHandler处理器，接口中只有一个方法，这里使用匿名内部类实现
return (Star) Proxy.newProxyInstance(
XuweiProxy.class.getClassLoader(),
star.getClass().getInterfaces(),
new InvocationHandler() {
//invoke方法是代理的重点，会在invoke里面处理大量的业务逻辑判断
//proxy:动态产生的代理对象本身
//method:表示方法
//args:表示参数
public Object invoke(
Object proxy,
Method method,
Object[] args) throws Throwable {
//预处理
System.out.println("----------预处理：粉丝要求经纪人要许巍唱歌----------");
if("sing".equals(method.getName())){
method.invoke(star, args);
}
//后处理
System.out.println("----------后处理：许巍唱歌完毕----------");
return null;
}
}
);
} }
粉丝类：
package com.lizhou.test.proxy; /**
* 粉丝呼吁许巍唱歌
* 粉丝不可能直接找许巍唱歌，需要先联系经纪人，经纪人再让许巍唱歌
* @author bojiangzhou
* @date 2016年5月5日
*/
public class Fans { public static void main(String[] args) {
//创建代理对象(即经纪人)
XuweiProxy xuweiProxy = new XuweiProxy(new Xuwei());
//通过代理对象找目标对象
Star star = xuweiProxy.getProxy();
star.sing("完美生活");
} }
结果：可以看得出来，虽然调用的是star.sing()，但并不是直接调用的。因为此处star是一个代理对象，先调用的是代理对象的invoke方法(invoke表示动态代理对象的拦截方法，每次调用目标对象都会执行该invoke())，我们在里面可以做一些预处理及后处理等操作。
动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。
动态代理优点： 动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。
JDK动态代理总结：
1，JAVA动态代理是使用java.lang.reflect包中的Proxy类与InvocationHandler接口这两个来完成的。
2，要使用JDK动态代理，必须要定义接口。
3，JDK动态代理将会拦截所有pubic的方法（因为只能调用接口中定义的方法），这样即使在接口中增加了新的方法，不用修改代码也会被拦截。
4，如果只想拦截一部分方法，可以在invoke方法中对要执行的方法名进行判断。
--------------------------------------------------------------------------------------------------------------------------------------------
三、列举一个动态代理的实际应用例子：解决网站POST和GET的统一编码问题
思路：使用过滤器拦截请求，自定义一个代理request的类，然后将代理对象返回
看代码：
package com.lizhou.test.proxy; import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest; /**
* 使用代理类解决网站POST和GET的统一编码问题
* @author bojiangzhou
* @date 2016年5月5日
*/
public class CharacterEncodingFilter implements Filter { public void destroy() { } public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
//获取request的代理对象，这里request的代理对象对字符编码进行了处理的
RequestProxy proxy = new RequestProxy((HttpServletRequest) request);
//然后将代理对象传过去即可
chain.doFilter(proxy.getProxy(), response);
} public void init(FilterConfig fConfig) throws ServletException { } } /**
* request代理类
* @author bojiangzhou
* @date 2016年5月5日
*/
class RequestProxy {
//明确代理对象
private HttpServletRequest request; public RequestProxy(HttpServletRequest request){
this.request = request;
} /**
* 返回request的代理对象
* @return
*/
public ServletRequest getProxy(){ return (ServletRequest) Proxy.newProxyInstance(
RequestProxy.class.getClassLoader(),
request.getClass().getInterfaces(),
new InvocationHandler() { public Object invoke(
Object proxy,
Method method,
Object[] args) throws Throwable {
System.out.println("执行代理对象方法");
if("getParameter".equals(method.getName())){
//如果调用了request的getParameter方法，则对其进行编码处理 String param = (String) args[0];
if("get".equalsIgnoreCase(request.getMethod())){
//如果是get请求方式
String value = request.getParameter(param);
return new String(value.getBytes("ISO8859-1"), "UTF-8");
} else{
//post方式
request.setCharacterEncoding("UTF-8");
return request.getParameter(param);
}
} else{
//放行资源
return method.invoke(request, args);
}
}
});
} }
Servlet类：
package com.lizhou.test.proxy; import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; public class LoginServlet extends HttpServlet { private static final long serialVersionUID = 1L; protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//注意此处的request实际上是一个代理对象，在调用getParmeter方法时，实际调用的是代理对象的invoke方法。
String name = request.getParameter("name");
System.out.println("doGet 姓名："+name);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doGet(request, response);
} }
个人理解：代理的作用其实就类似于过滤器、Struts2的拦截器、Spring的切面/通知，在进行某个请求的时候，拦截该请求，做一些预处理、过滤、后置处理等，代理最重要的就是让你不能直接访问到实际的目标对象，使用的是目标对象的一个代理对象。
本文部分参考：java静态代理和动态代理
本文纯属个人学习笔记，因为代理比较少用到，所以这次再次学习后做个笔记以便以后需要的时候快速学习。
如有不当之处，敬请指出O(∩_∩)O~