Java动态代理实现及实际应用
一、代理的概念
动态代理技术是整个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: luquanjan
7 * @date: 2014-9-14 下午9:44:22
8 *
9 */
10 public interface Person {
11
12 /**
13 * @Method: sing
14 * @Description: 唱歌
15 * @Anthor:luquanjian
16 *
17 * @param name
18 * @return
19 */
20 String sing(String name);
21 /**
22 * @Method: sing
23 * @Description: 跳舞
24 * @Anthor:luquanjian
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: luquanjian
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:luquanjian
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: luquanjian
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
<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: luquanjian
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:luquanjian
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、在字符过滤器中使用动态代理压缩服务器响应的内容后再输出到客户端
压缩过滤器的代码如下：
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: luquanjian
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>
Java动态代理实现及实际应用的更多相关文章
- Java 动态代理机制详解
在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的 ...
- Java动态代理全面分析
代理模式 解说:给某一个对象提供一个代理,并由代理对象控制对原对象的引用: 代理模式需要以下几个角色: 1 主题:规定代理类和真实对象共同对外暴露的接口: 2 代理类:专门代理真实对象的类: 3 ...
- JAVA动态代理模式（从现实生活角度理解代码原理）
所谓动态代理,即通过代理类:Proxy的代理,接口和实现类之间可以不直接发生联系,而可以在运行期(Runtime)实现动态关联. java动态代理主要是使用java.lang.reflect包中的两个 ...
- Java 动态代理作用是什么？
Java 动态代理作用是什么? 1 条评论 分享 默认排序按时间排序 19 个回答 133赞同反对,不会显示你的姓名 Intopass 程序员,近期沉迷于动漫ING 133 人赞同 ① 首先你 ...
- java动态代理原理
我们经常会用到Java的动态代理技术, 虽然会使用, 但是自己对其中的原理却不是很了解.比如代理对象是如何产生的, InvocationHandler的invoke方法是如何调用的?今天就来深究下Ja ...
- java 动态代理示例，带主要注释
Java proxy是基于反射,仅仅支持基于接口的动态代理. java 动态代理是一切架构的基础,必须了解. 废话少说,先上代码获得感性认识. 示例代码有主要注释. 接口: public interf ...
- java动态代理浅析
最近在公司看到了mybatis与spring整合中MapperScannerConfigurer的使用,该类通过反向代理自动生成基于接口的动态代理类. 于是想起了java的动态代理,然后就有了这篇文章 ...
- Java 动态代理
被代理的接口特点: 1. 不能有重复的接口,以避免动态代理类代码生成时的编译错误. 2. 这些接口对于类装载器必须可见,否则类装载器将无法链接它们,将会导致类定义失败. 3. 需被代理的所有非 pub ...
- [转]java动态代理（JDK和cglib）
转自:http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html java动态代理(JDK和cglib) JAVA的动态代理 代理模式 代理 ...
- java动态代理模式
java动态代理机制详解 Spring的核心AOP的原理就是java的动态代理机制. 在java的动态代理机制中,有两个重要的类或接口: 1.InvocationHandler(Interface): ...
随机推荐
- HeadFirst设计模式读书笔记之工厂模式
1. 简单工厂 1. 你开了一家披萨店,点披萨的方法可能是这样: public Pizza orderPizza(String type) { Pizza pizza; if (type.equals ...
- XSS攻击之窃取Cookie
10 年前的博客似乎有点老了,但是XSS 攻击的威胁依然还在,我们不得不防. 窃取Cookie是非常简单的,因此不要轻易相信客户端所声明的身份.即便这个Cookie是在数秒之前验证过,那也未必是真的, ...
- Vue slot插槽
插槽用于内容分发,存在于子组件之中. 插槽作用域 父级组件作用域为父级,子级组件作用域为子级,在哪定义的作用域就在哪. 子组件之间的内容是在父级作用域的,无法直接访问子组件里面的数据. 插槽元素 &l ...
- dedecms织梦上下页标签和CSS
模板中的分页部分源码: <div class="pagination-wrapper" style= "font-size:20pt;color:red;text- ...
- 工具资源系列之给虚拟机装个centos
前文我们已经讲解了如何在 mac 系统上安装虚拟机软件,这节我们接着讲解如何利用虚拟机安装 centos 镜像. 安装镜像的大致步骤基本相同,只不过是配置项略显不同而已,如果需要安装其他系统镜像,请参 ...
- 神经网络MPLClassifier分类
代码: # -*- coding: utf-8 -*- """ Created on Fri Aug 24 14:38:56 2018 @author: zhen &qu ...
- windows常用目录
启动目录位置 %USERPROFILE%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
- U盘启动盘安装Windows10操作系统详解
没有装过系统的同学,总以为装系统很神秘?是专业技术人员干的事情.今天我们来看看怎么借助常用的U盘装上全新的win10系统. 准备材料: 软件软碟通,可上官网下载:https://cn.ultraiso ...
- R语言学习——数据合并及绘制密度分布曲线图
setwd("E:/08_cooperation/07_X-lab/06-Crosstalk/Aadapter_primer")# 读取lane01.txt,并对其按列进行相加处理 ...
- ValueError: too many values to unpack
Error msg: 执行: python manage,py makemigrations 报错:Value: too many values to unpack 问题: django第一次数据库迁 ...