Java基礎加強總結(三)——代理(Proxy)
阿新 • • 發佈：2017-10-11
set txt dsi 框架 itl 以及 然而 亂碼 else if 
一、代理的概念
動態代理技術是整個java技術中最重要的一個技術，它是學習java框架的基礎，不會動態代理技術，那麽在學習Spring這些框架時是學不明白的。
動態代理技術就是用來產生一個對象的代理對象的。在開發中為什麽需要為一個對象產生代理對象呢？
舉一個現實生活中的例子：歌星或者明星都有一個自己的經紀人，這個經紀人就是他們的代理人，當我們需要找明星表演時，不能直接找到該明星，只能是找明星的代理人。比如劉德華在現實生活中非常有名，會唱歌，會跳舞，會拍戲，劉德華在沒有出名之前，我們可以直接找他唱歌，跳舞，拍戲，劉德華出名之後，他幹的第一件事就是找一個經紀人，這個經紀人就是劉德華的代理人(代理)，當我們需要找劉德華表演時，不能直接找到劉德華了(劉德華說，你找我代理人商談具體事宜吧!)，只能是找劉德華的代理人，因此劉德華這個代理人存在的價值就是攔截我們對劉德華的直接訪問！
這個現實中的例子和我們在開發中是一樣的，我們在開發中之所以要產生一個對象的代理對象，主要用於攔截對真實業務對象的訪問。那麽代理對象應該具有什麽方法呢？代理對象應該具有和目標對象相同的方法
所以在這裏明確代理對象的兩個概念：
1、代理對象存在的價值主要用於攔截對真實業務對象的訪問。
2、代理對象應該具有和目標對象(真實業務對象)相同的方法。劉德華(真實業務對象)會唱歌，會跳舞，會拍戲，我們現在不能直接找他唱歌，跳舞，拍戲了，只能找他的代理人(代理對象)唱歌，跳舞，拍戲，一個人要想成為劉德華的代理人，那麽他必須具有和劉德華一樣的行為(會唱歌，會跳舞，會拍戲)，劉德華有什麽方法，他(代理人)就要有什麽方法，我們找劉德華的代理人唱歌，跳舞，拍戲，但是代理人不是真的懂得唱歌，跳舞，拍戲的，真正懂得唱歌，跳舞，拍戲的是劉德華，在現實中的例子就是我們要找劉德華唱歌，跳舞，拍戲，那麽只能先找他的經紀人，交錢給他的經紀人，然後經紀人再讓劉德華去唱歌，跳舞，拍戲。
二、java中的代理
2.1、"java.lang.reflect.Proxy"類介紹
現在要生成某一個對象的代理對象，這個代理對象通常也要編寫一個類來生成，所以首先要編寫用於生成代理對象的類。在java中如何用程序去生成一個對象的代理對象呢，java在JDK1.5之後提供了一個"java.lang.reflect.Proxy"類，通過"Proxy"類提供的一個newProxyInstance方法用來創建一個對象的代理對象，如下所示：
1 static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
newProxyInstance方法用來返回一個代理對象，這個方法總共有3個參數，ClassLoader loader用來指明生成代理對象使用哪個類裝載器，Class<?>[] interfaces用來指明生成哪個對象的代理對象，通過接口指定，InvocationHandler h用來指明產生的這個代理對象要做什麽事情。所以我們只需要調用newProxyInstance方法就可以得到某一個對象的代理對象了。
2.2、編寫生成代理對象的類
在java中規定，要想產生一個對象的代理對象，那麽這個對象必須要有一個接口，所以我們第一步就是設計這個對象的接口，在接口中定義這個對象所具有的行為(方法)
1、定義對象的行為接口
1 package cn.gacl.proxy;
2
3 /**
4 * @ClassName: Person
5 * @Description: 定義對象的行為
6 * @author: 孤傲蒼狼
7 * @date: 2014-9-14 下午9:44:22
8 *
9 */
10 public interface Person {
11
12 /**
13 * @Method: sing
14 * @Description: 唱歌
15 * @Anthor:孤傲蒼狼
16 *
17 * @param name
18 * @return
19 */
20 String sing(String name);
21 /**
22 * @Method: sing
23 * @Description: 跳舞
24 * @Anthor:孤傲蒼狼
25 *
26 * @param name
27 * @return
28 */
29 String dance(String name);
30 }
2、定義目標業務對象類
1 package cn.gacl.proxy;
2
3 /**
4 * @ClassName: LiuDeHua
5 * @Description: 劉德華實現Person接口，那麽劉德華會唱歌和跳舞了
6 * @author: 孤傲蒼狼
7 * @date: 2014-9-14 下午9:22:24
8 *
9 */
10 public class LiuDeHua implements Person {
11
12 public String sing(String name){
13 System.out.println("劉德華唱"+name+"歌！！");
14 return "歌唱完了，謝謝大家！";
15 }
16
17 public String dance(String name){
18 System.out.println("劉德華跳"+name+"舞！！");
19 return "舞跳完了，多謝各位觀眾！";
20 }
21 }
3、創建生成代理對象的代理類
1 package cn.gacl.proxy;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Proxy;
6
7 /**
8 * @ClassName: LiuDeHuaProxy
9 * @Description: 這個代理類負責生成劉德華的代理人
10 * @author: 孤傲蒼狼
11 * @date: 2014-9-14 下午9:50:02
12 *
13 */
14 public class LiuDeHuaProxy {
15
16 //設計一個類變量記住代理類要代理的目標對象
17 private Person ldh = new LiuDeHua();
18
19 /**
20 * 設計一個方法生成代理對象
21 * @Method: getProxy
22 * @Description: 這個方法返回劉德華的代理對象：Person person = LiuDeHuaProxy.getProxy();//得到一個代理對象
23 * @Anthor:孤傲蒼狼
24 *
25 * @return 某個對象的代理對象
26 */
27 public Person getProxy() {
28 //使用Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)返回某個對象的代理對象
29 return (Person) Proxy.newProxyInstance(LiuDeHuaProxy.class
30 .getClassLoader(), ldh.getClass().getInterfaces(),
31 new InvocationHandler() {
32 /**
33 * InvocationHandler接口只定義了一個invoke方法，因此對於這樣的接口，我們不用單獨去定義一個類來實現該接口，
34 * 而是直接使用一個匿名內部類來實現該接口，new InvocationHandler() {}就是針對InvocationHandler接口的匿名實現類
35 */
36 /**
37 * 在invoke方法編碼指定返回的代理對象幹的工作
38 * proxy : 把代理對象自己傳遞進來
39 * method：把代理對象當前調用的方法傳遞進來
40 * args:把方法參數傳遞進來
41 *
42 * 當調用代理對象的person.sing("冰雨");或者 person.dance("江南style");方法時，
43 * 實際上執行的都是invoke方法裏面的代碼，
44 * 因此我們可以在invoke方法中使用method.getName()就可以知道當前調用的是代理對象的哪個方法
45 */
46 @Override
47 public Object invoke(Object proxy, Method method,
48 Object[] args) throws Throwable {
49 //如果調用的是代理對象的sing方法
50 if (method.getName().equals("sing")) {
51 System.out.println("我是他的經紀人，要找他唱歌得先給十萬塊錢！！");
52 //已經給錢了，經紀人自己不會唱歌，就只能找劉德華去唱歌！
53 return method.invoke(ldh, args); //代理對象調用真實目標對象的sing方法去處理用戶請求
54 }
55 //如果調用的是代理對象的dance方法
56 if (method.getName().equals("dance")) {
57 System.out.println("我是他的經紀人，要找他跳舞得先給二十萬塊錢！！");
58 //已經給錢了，經紀人自己不會唱歌，就只能找劉德華去跳舞！
59 return method.invoke(ldh, args);//代理對象調用真實目標對象的dance方法去處理用戶請求
60 }
61
62 return null;
63 }
64 });
65 }
66 }
測試代碼：
1 package cn.gacl.proxy;
2
3 public class ProxyTest {
4
5 public static void main(String[] args) {
6
7 LiuDeHuaProxy proxy = new LiuDeHuaProxy();
8 //獲得代理對象
9 Person p = proxy.getProxy();
10 //調用代理對象的sing方法
11 String retValue = p.sing("冰雨");
12 System.out.println(retValue);
13 //調用代理對象的dance方法
14 String value = p.dance("江南style");
15 System.out.println(value);
16 }
17 }
運行結果如下：
Proxy類負責創建代理對象時，如果指定了handler（處理器），那麽不管用戶調用代理對象的什麽方法，該方法都是調用處理器的invoke方法。
由於invoke方法被調用需要三個參數：代理對象、方法、方法的參數，因此不管代理對象哪個方法調用處理器的invoke方法，都必須把自己所在的對象、自己（調用invoke方法的方法）、方法的參數傳遞進來。
三、動態代理應用
在動態代理技術裏，由於不管用戶調用代理對象的什麽方法，都是調用開發人員編寫的處理器的invoke方法（這相當於invoke方法攔截到了代理對象的方法調用）。並且，開發人員通過invoke方法的參數，還可以在攔截的同時，知道用戶調用的是什麽方法，因此利用這兩個特性，就可以實現一些特殊需求，例如：攔截用戶的訪問請求，以檢查用戶是否有訪問權限、動態為某個對象添加額外的功能。
3.1、在字符過濾器中使用動態代理解決中文亂碼
在平時的JavaWeb項目開發中，我們一般會寫一個CharacterEncodingFilter(字符過濾器)來解決整個JavaWeb應用的中文亂碼問題，如下所示：
1 package me.gacl.web.filter;
2
3 import java.io.IOException;
4
5 import javax.servlet.Filter;
6 import javax.servlet.FilterChain;
7 import javax.servlet.FilterConfig;
8 import javax.servlet.ServletException;
9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11
12 /**
13 * @ClassName: CharacterEncodingFilter
14 * @Description: 解決中文亂碼的字符過濾器
15 * @author: 孤傲蒼狼
16 * @date: 2014-9-14 下午10:38:12
17 *
18 */
19 public class CharacterEncodingFilter implements Filter {
20
21 @Override
22 public void init(FilterConfig filterConfig) throws ServletException {
23
24 }
25
26 @Override
27 public void doFilter(ServletRequest request, ServletResponse response,
28 FilterChain chain) throws IOException, ServletException {
29 //解決以Post方式提交的中文亂碼問題
30 request.setCharacterEncoding("UTF-8");
31 response.setCharacterEncoding("UTF-8");
32 response.setContentType("text/html;charset=UTF-8");
33 chain.doFilter(request, response);
34 }
35
36 @Override
37 public void destroy() {
38
39 }
40 }
但是這種寫法是沒有辦法解決以get方式提交中文參數時的亂碼問題的，我們可以用如下的代碼來證明上述的解決中文亂碼過濾器只對以post方式提交中文參數時有效，而對於以get方式提交中文參數時無效
jsp測試頁面如下：
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--引入jstl標簽庫 --%>
3 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>使用字符過濾器解決解決get、post請求方式下的中文亂碼問題</title>
8 </head>
9 <body>
10 <%--使用c:url標簽構建url，構建好的url存儲在servletDemo1變量中--%>
11 <c:url value="/servlet/ServletDemo1" scope="page" var="servletDemo1">
12 <%--構建的url的附帶的中文參數 ，參數名是：username，值是：孤傲蒼狼--%>
13 <c:param name="username" value="孤傲蒼狼"></c:param>
14 </c:url>
15 <%--使用get的方式訪問 --%>
16 <a href="${servletDemo1}">超鏈接(get方式請求)</a>
17 <hr/>
18 <%--使用post方式提交表單 --%>
19 <form action="${pageContext.request.contextPath}/servlet/ServletDemo1" method="post">
20 用戶名：<input type="text" name="username" value="孤傲蒼狼" />
21 <input type="submit" value="post方式提交">
22 </form>
23
24 </body>
25 </html>
處理請求的ServletDemo1代碼如下：
1 package me.gacl.web.controller;
2
3 import java.io.IOException;
4 import java.io.PrintWriter;
5
6 import javax.servlet.ServletException;
7 import javax.servlet.http.HttpServlet;
8 import javax.servlet.http.HttpServletRequest;
9 import javax.servlet.http.HttpServletResponse;
10
11 public class ServletDemo1 extends HttpServlet {
12
13 public void doGet(HttpServletRequest request, HttpServletResponse response)
14 throws ServletException, IOException {
15 // 接收參數
16 String username = request.getParameter("username");
17 // 獲取請求方式
18 String method = request.getMethod();
19 // 獲取輸出流
20 PrintWriter out = response.getWriter();
21 out.write("請求的方式：" + method);
22 out.write("<br/>");
23 out.write("接收到的參數：" + username);
24 }
25
26 public void doPost(HttpServletRequest request, HttpServletResponse response)
27 throws ServletException, IOException {
28 doGet(request, response);
29 }
30 }
在web.xml中註冊上述的CharacterEncodingFilter和ServletDemo1
1 <filter> 2 <filter-name>CharacterEncodingFilter</filter-name> 3 <filter-class>me.gacl.web.filter.CharacterEncodingFilter</filter-class> 4 </filter> 5 6 <filter-mapping> 7 <filter-name>CharacterEncodingFilter</filter-name> 8 <url-pattern>/*</url-pattern> 9 </filter-mapping> 10 11 <servlet> 12 <servlet-name>ServletDemo1</servlet-name> 13 <servlet-class>me.gacl.web.controller.ServletDemo1</servlet-class> 14 </servlet> 15 16 <servlet-mapping> 17 <servlet-name>ServletDemo1</servlet-name> 18 <url-pattern>/servlet/ServletDemo1</url-pattern> 19 </servlet-mapping>
測試結果如下所示：
從運行結果可以看出，上述的過濾器的確是不能解決以get方式提交中文參數的亂碼問題，下面使用動態代理技術改造上述的過濾器，使之能夠解決以get方式提交中文參數的亂碼問題，改造後的過濾器代碼如下：
1 package me.gacl.web.filter;
2
3 import java.io.IOException;
4 import java.lang.reflect.InvocationHandler;
5 import java.lang.reflect.Method;
6 import java.lang.reflect.Proxy;
7
8 import javax.servlet.Filter;
9 import javax.servlet.FilterChain;
10 import javax.servlet.FilterConfig;
11 import javax.servlet.ServletException;
12 import javax.servlet.ServletRequest;
13 import javax.servlet.ServletResponse;
14 import javax.servlet.http.HttpServletRequest;
15 import javax.servlet.http.HttpServletResponse;
16
17 /**
18 * @ClassName: CharacterEncodingFilter
19 * @Description: 解決中文亂碼的字符過濾器
20 * @author: 孤傲蒼狼
21 * @date: 2014-9-14 下午10:38:12
22 *
23 */
24 public class CharacterEncodingFilter implements Filter {
25
26 @Override
27 public void init(FilterConfig filterConfig) throws ServletException {
28
29 }
30
31 @Override
32 public void doFilter(ServletRequest req, ServletResponse resp,
33 FilterChain chain) throws IOException, ServletException {
34
35 final HttpServletRequest request = (HttpServletRequest) req;
36 HttpServletResponse response = (HttpServletResponse) resp;
37 //解決以Post方式提交的中文亂碼問題
38 request.setCharacterEncoding("UTF-8");
39 response.setCharacterEncoding("UTF-8");
40 response.setContentType("text/html;charset=UTF-8");
41 //獲取獲取HttpServletRequest對象的代理對象
42 ServletRequest requestProxy = getHttpServletRequestProxy(request);
43 /**
44 * 傳入代理對象requestProxy給doFilter方法，
45 * 這樣用戶在使用request對象時實際上使用的是HttpServletRequest對象的代理對象requestProxy
46 */
47 chain.doFilter(requestProxy, response);
48 }
49
50
51 /**
52 * @Method: getHttpServletRequestProxy
53 * @Description: 獲取HttpServletRequest對象的代理對象
54 * @Anthor:孤傲蒼狼
55 *
56 * @param request
57 * @return HttpServletRequest對象的代理對象
58 */
59 private ServletRequest getHttpServletRequestProxy(final HttpServletRequest request){
60 ServletRequest proxy = (ServletRequest) Proxy.newProxyInstance(
61 CharacterEncodingFilter.class.getClassLoader(),
62 request.getClass().getInterfaces(),
63 new InvocationHandler(){
64 @Override
65 public Object invoke(Object proxy, Method method, Object[] args)
66 throws Throwable {
67 //如果請求方式是get並且調用的是getParameter方法
68 if (request.getMethod().equalsIgnoreCase("get") && method.getName().equals("getParameter")) {
69 //調用getParameter方法獲取參數的值
70 String value = (String) method.invoke(request, args);
71 if(value==null){
72 return null;
73 }
74 //解決以get方式提交的中文亂碼問題
75 return new String(value.getBytes("iso8859-1"),"UTF-8");
76 }else {
77 //直接調用相應的方法進行處理
78 return method.invoke(request, args);
79 }
80 }
81 });
82 //返回HttpServletRequest對象的代理對象
83 return proxy;
84 }
85
86 @Override
87 public void destroy() {
88
89 }
90 }
我們在過濾器中使用動態代理技術生成一個HttpServletRequest對象的代理對象requestProxy，然後把代理對象requestProxy進行chain.doFilter(requestProxy, response)傳遞給用戶使用，這樣用戶實際上使用的就是HttpServletRequest對象的代理對象requestProxy。然而這一過程對於用戶來說是透明的，用戶是不知道自己使用的HttpServletRequest對象是一個代理對象requestProxy，由於代理對象requestProxy和目標對象HttpServletRequest具有相同的方法，當用戶調用getParameter方法接收中文參數時，實際上調用的就是代理對象requestProxy的invoke方法，因此我們就可以在invoke方法中就判斷當前的請求方式以及用戶正在調用的方法，如果判斷當前的請求方式是get方式並且用戶正在調用的是getParameter方法，那麽我們就可以手動處理get方式提交中文參數的中文亂碼問題了。
測試結果如下所示：
3.2、在字符過濾器中使用動態代理壓縮服務器響應的內容後再輸出到客戶端
壓縮過濾器的代碼如下：
1 package me.gacl.web.filter;
2
3 import java.io.ByteArrayOutputStream;
4 import java.io.IOException;
5 import java.io.OutputStreamWriter;
6 import java.io.PrintWriter;
7 import java.lang.reflect.InvocationHandler;
8 import java.lang.reflect.Method;
9 import java.lang.reflect.Proxy;
10 import java.util.zip.GZIPOutputStream;
11
12 import javax.servlet.Filter;
13 import javax.servlet.FilterChain;
14 import javax.servlet.FilterConfig;
15 import javax.servlet.ServletException;
16 import javax.servlet.ServletOutputStream;
17 import javax.servlet.ServletRequest;
18 import javax.servlet.ServletResponse;
19 import javax.servlet.http.HttpServletRequest;
20 import javax.servlet.http.HttpServletResponse;
21
22 /**
23 * @ClassName: GzipFilter
24 * @Description: 壓縮過濾器，將web應用中的文本都經過壓縮後再輸出到瀏覽器
25 * @author: 孤傲蒼狼
26 * @date: 2014-9-15 下午9:35:36
27 *
28 */
29 public class GzipFilter implements Filter {
30
31 @Override
32 public void init(FilterConfig filterConfig) throws ServletException {
33
34 }
35
36 @Override
37 public void doFilter(ServletRequest req, ServletResponse resp,
38 FilterChain chain) throws IOException, ServletException {
39
40 final HttpServletRequest request = (HttpServletRequest) req;
41 final HttpServletResponse response = (HttpServletResponse) resp;
42 final ByteArrayOutputStream bout = new ByteArrayOutputStream();
43 final PrintWriter pw = new PrintWriter(new OutputStreamWriter(bout,"UTF-8"));
44
45 chain.doFilter(request, getHttpServletResponseProxy(response, bout, pw));
46 pw.close();
47 //拿到目標資源的輸出
48 byte result[] = bout.toByteArray();
49 System.out.println("原始大小：" + result.length);
50
51 ByteArrayOutputStream bout2 = new ByteArrayOutputStream();
52 GZIPOutputStream gout = new GZIPOutputStream(bout2);
53 gout.write(result);
54 gout.close();
55
56 //拿到目標資源輸出的壓縮數據
57 byte gzip[] = bout2.toByteArray();
58 System.out.println("壓縮大小：" + gzip.length);
59
60 response.setHeader("content-encoding", "gzip");
61 response.setContentLength(gzip.length);
62 response.getOutputStream().write(gzip);
63 }
64
65 /**
66 * @Method: getHttpServletResponseProxy
67 * @Description: 獲取HttpServletResponse對象的代理對象
68 * @Anthor:孤傲蒼狼
69 *
70 * @param response
71 * @param bout
72 * @param pw
73 * @return HttpServletResponse對象的代理對象
74 */
75 private ServletResponse getHttpServletResponseProxy(
76 final HttpServletResponse response,
77 final ByteArrayOutputStream bout,
78 final PrintWriter pw) {
79
80 return (ServletResponse) Proxy.newProxyInstance(GzipFilter.class.getClassLoader(),
81 response.getClass().getInterfaces(),
82 new InvocationHandler(){
83 @Override
84 public Object invoke(Object proxy, Method method, Object[] args)
85 throws Throwable {
86 if(method.getName().equals("getWriter")){
87 return pw;
88 }else if(method.getName().equals("getOutputStream")){
89 return new MyServletOutputStream(bout);
90 }else{
91 return method.invoke(response, args);
92 }
93 }
94 });
95 }
96
97 @Override
98 public void destroy() {
99
100 }
101
102 class MyServletOutputStream extends ServletOutputStream{
103
104 private ByteArrayOutputStream bout = null;
105 public MyServletOutputStream(ByteArrayOutputStream bout){
106 this.bout = bout;
107 }
108 @Override
109 public void write(int b) throws IOException {
110 bout.write(b);
111 }
112
113 }
114 }
在web.xml中註冊上述的GzipFilter
1 <filter>
2 <description>配置壓縮過濾器</description>
3 <filter-name>GzipFilter</filter-name>
4 <filter-class>me.gacl.web.filter.GzipFilter</filter-class>
5 </filter>
6
7 <!--jsp文件的輸出的內容都經過壓縮過濾器壓縮後才輸出 -->
8 <filter-mapping>
9 <filter-name>GzipFilter</filter-name>
10 <url-pattern>*.jsp</url-pattern>
11 <!-- 配置過濾器的攔截方式-->
12 <!-- 對於在Servlet中通過
13 request.getRequestDispatcher("jsp頁面路徑").forward(request, response)
14 方式訪問的Jsp頁面的要進行攔截 -->
15 <dispatcher>FORWARD</dispatcher>
16 <!--對於直接以URL方式訪問的jsp頁面進行攔截，過濾器的攔截方式默認就是REQUEST-->
17 <dispatcher>REQUEST</dispatcher>
18 </filter-mapping>
19 <!--js文件的輸出的內容都經過壓縮過濾器壓縮後才輸出 -->
20 <filter-mapping>
21 <filter-name>GzipFilter</filter-name>
22 <url-pattern>*.js</url-pattern>
23 </filter-mapping>
24 <!--css文件的輸出的內容都經過壓縮過濾器壓縮後才輸出 -->
25 <filter-mapping>
26 <filter-name>GzipFilter</filter-name>
27 <url-pattern>*.css</url-pattern>
28 </filter-mapping>
29 <!--html文件的輸出的內容都經過壓縮過濾器壓縮後才輸出 -->
30 <filter-mapping>
31 <filter-name>GzipFilter</filter-name>
32 <url-pattern>*.html</url-pattern>
33 </filter-mapping>
GzipFilter過濾器會將*.jsp，*.js，*.css，*.html這些文件裏面的文本內容都經過壓縮後再輸出到客戶端顯示。
Java基礎加強總結(三)——代理(Proxy)