1 先看一个简单点动态代理的例子(没有用到factory)
2 1 定义接口
3 package com.dynamic.simple;
4
5 import com.dynamic.simple.Subject;
6
7 public interface Subject{
8 public void request();
9 }
10
11 2 实现真实类
12 package com.dynamic.simple;
13
14 public class RealSubject implements Subject{
15 public RealSubject(){}
16 public void request() {
17 System.out.println("From real subject.");
18 }
19 }
20
21 3 定义动态代理
22 package com.dynamic.simple;
23
24 import java.lang.reflect.Method;
25 import java.lang.reflect.InvocationHandler;
26 public class DynamicSubject implements InvocationHandler {
27 private Object sub;
28
29 public DynamicSubject() {
30 }
31
32 public DynamicSubject(Object obj) {
33 sub = obj;
34 }
35
36 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
37 System.out.println("before calling " + method);
38 method.invoke(sub,args);
39 System.out.println("after calling " + method);
40 return null;
41 }
42 }
43
44 4 客户端
45 package com.dynamic.simple;
46
47 import java.lang.reflect.InvocationHandler;
48 import java.lang.reflect.Proxy;
49
50 public class Client{
51 static public void main(String[] args) throws Throwable{
52 RealSubject rs = new RealSubject(); //在这里指定被代理类
53 InvocationHandler ds = new DynamicSubject(rs); //初始化代理类
54 Class cls = rs.getClass();
55 Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
56 subject.request();
57 }
58 }
运行客户端结果为:
before calling public abstract void com.dynamic.simple.Subject.request()
From real subject.
after calling public abstract void com.dynamic.simple.Subject.request()
1 下面看一个复杂点的动态代理实现(用到了factory)
2 1 定义接口
3 package com.proxy;
4
5 import com.proxy.SomeClass;
6 import com.proxy.SomeClassImpl;
7
8 public interface SomeClass {
9 public void someMethod();
10
11 public void someOtherMethod(final String text);
12 }
13
14 2 定义实现类
15 package com.proxy;
16
17
18 public class SomeClassImpl implements SomeClass{
19 private String name;
20
21 public SomeClassImpl(final String name){
22 this.name = name;
23 }
24
25 public void someMethod(){
26 System.out.println(this.name);
27 }
28
29 public void someOtherMethod(final String text){
30 System.out.println(text);
31 }
32 }
33
34 3 定义2个代理SomeClassProxy和SomeClassCountingProxy(静态代理时才需要)
35 /*SomeClassProxy*/
36 package com.proxy;
37
38
39 public class SomeClassProxy implements SomeClass{
40
41 private final SomeClassImpl impl;
42
43 public SomeClassProxy(SomeClassImpl impl){
44 this.impl = impl;
45 }
46
47 public void someMethod(){
48 this.impl.someMethod();
49 }
50
51 public void someOtherMethod(final String text){
52 this.impl.someOtherMethod(text);
53 }
54 }
55
56 /*SomeClassCountingProxy*/
57 package com.proxy;
58
59
60 public class SomeClassCountingProxy implements SomeClass{
61 private final SomeClassImpl impl;
62
63 private int invocationCount = 0;
64
65 public SomeClassCountingProxy(SomeClassImpl impl){
66 this.impl = impl;
67 }
68
69 public void someMethod(){
70 this.invocationCount ++;
71 this.impl.someMethod();
72 }
73
74 public void someOtherMethod(final String text){
75 this.invocationCount ++;
76 this.impl.someOtherMethod(text);
77 }
78
79 public int getInvocationCount() {
80 return invocationCount;
81 }
82
83 public void setInvocationCount(int invocationCount) {
84 this.invocationCount = invocationCount;
85 }
86 }
87
88 4 定义工厂
89 package com.proxy;
90
91 import java.lang.reflect.InvocationHandler;
92 import java.lang.reflect.Proxy;
93
94
95 public class SomeClassFactory {
96 /*//static proxy
97 public static final SomeClass getStaticSomeClassProxy(){
98 SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
99 if (false) {//generally when debuging
100 return new SomeClassCountingProxy(impl);
101 } else {
102 return new SomeClassProxy(impl);
103 }
104 }
105 */
106
107 //dynamic proxy
108 public static final SomeClass getDynamicSomeClassProxy(){
109 SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
110 ClassLoader loader = SomeClassImpl.class.getClassLoader();
111 Class[] interfaces = new Class[] {SomeClass.class};
112 InvocationHandler handler = new MethodCountingHandler(impl);
113 SomeClass proxy = (SomeClass)Proxy.newProxyInstance(loader, interfaces, handler);
114 return proxy;
115 }
116 }
117
118 5 定义InvocationHandler,主要通过这个类实现动态代理功能及其扩展
119 package com.proxy;
120
121 import java.lang.reflect.InvocationTargetException;
122 import java.lang.reflect.InvocationHandler;
123 import java.lang.reflect.Method;
124
125
126 public class MethodCountingHandler implements InvocationHandler{
127
128 private final Object impl;
129 private int invocationCount = 0;
130
131 public MethodCountingHandler(final Object impl){
132 this.impl = impl;
133 }
134
135 public int getInvocationCount(){
136 return invocationCount;
137 }
138
139 @Override
140 public Object invoke(Object proxy, Method method, Object[] args)
141 throws Throwable {
142 try {
143 this.invocationCount++;
144 Object result = method.invoke(impl, args);
145 return result;
146 } catch (final InvocationTargetException e) {
147 throw e.getTargetException();
148 }
149 }
150 }
151
152
153 6 定义客户端
154 package com.proxy;
155
156 import java.lang.reflect.InvocationHandler;
157 import java.lang.reflect.Proxy;
158
159
160 public class DemoDynamic {
161
162 /**
163 * @param args
164 */
165 public static void main(String[] args) {
166 /*//no use factory
167 SomeClassImpl real = new SomeClassImpl(System.getProperty("user.name"));
168 InvocationHandler dynamic = new MethodCountingHandler(real);
169 Class clz = real.getClass();
170 SomeClass obj = (SomeClass)Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), dynamic);
171 obj.someMethod();
172 obj.someOtherMethod("test");
173 */
174
175 //use factory to get a real object
176 SomeClass obj = (SomeClass)SomeClassFactory.getDynamicSomeClassProxy();
177 obj.someMethod();
178 obj.someOtherMethod("test");
179
180 //the invocationhandler works as proxy function, extend the function of real object
181 InvocationHandler handler = Proxy.getInvocationHandler(obj);
182 if (handler instanceof MethodCountingHandler) {
183 System.out.println(((MethodCountingHandler)handler).getInvocationCount());
184 }
185 }
186 }
运行结果为:
Administrator
test
2
参照链接:
http://blog.csdn.net/goodluckforlove/archive/2009/10/13/4663079.aspx
分享到:
相关推荐
java动态代理例子,这里面有两个例子,一个是jdk的动态代理,一个是cglib的动态代理,让你明白什么是动态代理,动态代理可以做什么。
语言程序设计资料:Java程序设计例子源代码.doc
java 动态代理 简单实例 新手看看
1:静态代理出现的实际背景,静态代理时如何演化成动态代理 2: 动态代理demo 举例实际应用场景(载入数据库驱动的时候,使用AIDL与系统Servic进行通信) 3: 动态代理使用到基础理论:ClassLoader 加载.class字节码...
JAVA动态代理的例子 一个简单的例子 初学者可以下载试试
开发者突击:Java Web主流框架整合开发:J2EE+Struts+Hibernate+Spring 部分例子源代码 及数据库
本例子所实现的是从数据库获得的数据通过webservice,显示在C#前台的DataGrid里面。CXF的jar包请本人自己下载。【注意:本人忘记把下面内容放入文档中】本人采用了JNDI来连接数据库。tomcat里面的配置:在%tomcat%\...
Java代理模式 事例很生动,非常容易理解,推荐给大家。
Java动态代理类位于Java.lang.reflect包下,一般主要涉及到以下两个类: (1) Interface InvocationHandler (2) Proxy:该类即为动态代理类,
Java动态代理类位于Java.lang.reflect包下,一般主要涉及到以下两个类: (1) Interface InvocationHandler (2) Proxy:该类即为动态代理类,
Java试题-2:ArrayList类动态代理 什么是动态代理 动态代理该怎么实现
演示了Java动态代理技术,学习查看详细的实现细节,更多代码的说明请参考博客文章 :http://520code.net/index.php/archives/19/
spring framework入门(6):java中的动态代理(jdk和cglib) 博客地址:https://blog.csdn.net/u010476739/article/details/76737460
语言程序设计资料:Java2程序设计例子源代码-经典源码.doc
Java设计模式——代理设计模式(静态代理和动态代理) 各种情况例子源码
主要讲述Java反射机制与设计模式之一:代理模式的原理与应用;同时详细讲述了Java对代理模式的支持以及Java中动态代理的原理,应用与实践。
NULL 博文链接:https://xueyue.iteye.com/blog/1202897
java设计模式【之】JDK动态代理【源码】【场景:帮爸爸买菜】.rar /** * 代理模式 * 在开发者的角度来看,创建一个代理对象,提供给用户使用,避免用户直接访问真正的对象 * 在用户角度来看,就是普通的类方法...
Java中提供了一个java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现动态代理。代理类在运行时会根据被代理接口自动生成,并且可以通过InvocationHandler接口对方法进行增强。
Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典...