君，已阅读到文档的结尾了呢~~
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
Java程序性能优化之代理模式
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer--144.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口java设计模式之——代理模式 - 阿福 - ITeye博客
1，什么是代理模式？
代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。
2，策略模式有什么好处？
在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
3，代理模式一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
4，应用场景举例：
比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时是这样的体现的
先说说这个场景中的要素：一种类型的女人，潘金莲，王婆，西门庆，后来扩展的贾氏也和西门庆勾上了，我们是假设的，然后西门庆找潘金莲happy,但潘金莲不好意思直接，就找个王婆代理呗。我们看看具体代码。
先定义一种女人
package com.yangguangfu.
* @author 阿福()&br&
*定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
public interface KindWoman {
//这种女人能做什么事情呢？
public void makeEyesWithMan();//抛媚眼
public void happyWithMan();//和男人那个....
一种类型嘛，那肯定是接口，定义个潘金莲
package com.yangguangfu.
* @author 阿福()&br&
*定义一个潘金莲是什么样的人
public class PanJinLian
implements KindWoman{
public void happyWithMan() {
System.out.println("潘金莲和男人在做那个...");
public void makeEyesWithMan() {
System.out.println("潘金莲抛媚眼...");
再定义个丑陋的王婆
package com.yangguangfu.
* @author 阿福()&br&
*王婆这个人老聪明了，她太老了，是个男人都看不上她，
*但是她有智慧经验呀，他作为一类女人的代理！
public class WangPo implements KindWoman {
private KindWoman kindW
public WangPo(){
//默认的话是潘金莲的代理
this.kindWoman = new PanJinLian();
//她可以是KindWomam的任何一个女人的代理，只要你是这一类型
public WangPo(KindWoman kindWoman){
this.kindWoman = kindW
public void happyWithMan() {
//自己老了，干不了了，但可以叫年轻的代替。
this.kindWoman.happyWithMan();
public void makeEyesWithMan() {
//王婆年纪大了，谁看她抛媚眼啊
this.kindWoman.makeEyesWithMan();
两个女主角都上场了，该男主角了，定义个西门庆
package com.yangguangfu.
* @author 阿福()&br&
*水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下：
*如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！
public class XiMenQiang {
* @param args
public static void main(String[] args) {
WangPo wangPo;
//把王婆叫出来
wangPo = new WangPo();
//然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：
wangPo.makeEyesWithMan();
//看到没有表面是王婆在做，其实爽的是潘金莲
wangPo.happyWithMan();
那这就是活生生的一个例子，通过代理人实现了某种目的，如果真去了王婆这个中间环节，直接西门庆和潘金莲勾搭，估计很难成就武松杀嫂事件。
那我们再考虑一下，水浒里面还有没有这类型的女人？有，卢俊义的老婆贾氏（就是和那个管家苟合的那个），这个名字起的：“贾氏”，那我们也让王婆做她的代理：
package com.yangguangfu.
* @author 阿福()&br&
*定义一个贾氏是什么样的人
public class JiaShi implements KindWoman {
public void happyWithMan() {
System.out.println("贾氏和男人在做那个...");
public void makeEyesWithMan() {
System.out.println("贾氏抛媚眼...");
西门庆勾潘金莲又勾引贾氏
package com.yangguangfu.
* @author 阿福()&br&
*水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下：
*如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！
public class XiMenQiang {
* @param args
public static void main(String[] args) {
WangPo wangPo;
//把王婆叫出来
wangPo = new WangPo();
//然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：
wangPo.makeEyesWithMan();
//看到没有表面是王婆在做，其实爽的是潘金莲
wangPo.happyWithMan();
//西门庆勾引贾氏
JiaShi jiaShi = new JiaShi();
wangPo = new WangPo(jiaShi);
wangPo.makeEyesWithMan();
wangPo.happyWithMan();
说完这个故事，那我总结一下，代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口呗。好了不多说了，慢慢体会吧。
描述: 源码附上
下载次数: 122
浏览 71920
最后一个表示不解，既然已经New JiaShi出来了，为毛在装载给王婆要注意王婆的构造方法有两个，不带参数的默认要叫潘金莲。带参数的你装载谁就叫谁。
最后一个表示不解，既然已经New JiaShi出来了，为毛在装载给王婆这是要让王婆知道，西门庆要找哪个女人。
& 上一页 1
yangguangfu
浏览: 1314714 次
来自: 北京
aclululu 写道最后一个表示不解，既然已经New Jia ...
aclululu 写道最后一个表示不解，既然已经New Jia ...
写的不错，是男人的话，瞬间就能理解了。
最后一个表示不解，既然已经New JiaShi出来了，为毛在装 ...java设计模式之代理模式 （静态&动态） - WannerWang的博客 - CSDN博客
java设计模式之代理模式 （静态&动态）
& 为其他对象提供一个代理控制对某个对象的访问，代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。
代理类和委托类要实现相同的接口，因为代理真正实现的还是委托类的方法。
使用场景：
&&如果需要委托类处理某一业务，就可以在代理类中统一处理然后调用具体的实现类。
&&主题接口：
&&&&&&&&代理模式---------主题接口
public&interface&Usermanager&{
&&&public&final&String&userId=null,&userName=
&&&public&void&addUser(String&userId,&String&userName);
&&&public&void&deluser(String&userId);
&&&public&String&findUser&(String&userId);
&&&public&void&modifyUser(String&userId,&String&userName);
&&*&具体用户管理实现类
public&class&UserManagerImpl&implements&Usermanager&{
public&void&addUser(String&userId,&String&userName)&{
&&&System.out.println(&UserManagerImpl.adduser&);
public&void&deluser(String&userId)&{
System.out.println(&UserManagerImpl.deluser&);
public&String&findUser(String&userId)&{
System.out.println(&UserManagerImpl.finduser&);
return&&张三&;
public&void&modifyUser(String&userId,&String&userName)&{
System.out.println(&UserManagerImpl.modifyUser&);
&*&代理类------用户管理实现类
public&class&UserManagerImplProxy&implements&Usermanager&{
//&目标对象
private&Usermanager&
//&通过构造方法传入对象
public&UserManagerImplProxy(Usermanager&um)&{
this.um&=&
public&void&addUser(String&userId,&String&userName)&{
//&添加日志打印功能
//&开始添加用户
System.out.println(&start-----------&adduser()&);
um.addUser(userId,&userName);
//&添加用户成功
System.out.println(&success---------------&adduser()&);
}&catch&(Exception&e)&{
//&添加用户失败
System.out.println(&error------&adduser()&);
public&void&deluser(String&userId)&{
um.deluser(userId);
public&String&findUser(String&userId)&{
um.findUser(userId);
return&&张三&;
public&void&modifyUser(String&userId,&String&userName)&{
um.modifyUser(userId,&userName);
public&class&Test&{
public&static&void&main(String[]&args)&{
Usermanager&um&=&new&UserManagerImplProxy(new&UserManagerImpl());
um.addUser(&&,&&张三丰&);
运行结果：
start-----------&adduser()
UserManagerImpl.adduser
success---------------&adduser()
&&&编译期加入，提前指定谁调用谁，效率高。
&&1：静态代理很麻烦，需要大量的代理类。（当我们有多个目标对象需要代理时，就需要建立多个代理类）
&2：在编译期加入，系统的灵活性低。
&&应用：&代理类可以对实现类进行统一的管理，如在实现具体之前，需要打印日志信息，这时只需添加一个静态代理，在代理类中添加打印功能，然后调用具体的实现类，这样就可以避免修改具体的实现类。
&&引入动态代理：
&&&通过以上可以发现，每一个代理类只能为一个接口服务，这样程序开发中必然会产生许多代理类，此时可以使用一个代理类完成我那个全部的代理功能。。。
package&com.xiyou.
/*&代理模式
&*&主题接口
public&interface&Usermanager&{
&&&public&final&String&userId=null,&userName=
&&&public&void&addUser(String&userId,&String&userName);
&&&public&void&deluser(String&userId);
&&&public&String&findUser&(String&userId);
&&&public&void&modifyUser(String&userId,&String&userName);
package&com.xiyou.
&&*&具体用户管理实现类&(实现&Usermanager接口)
public&class&UserManagerImpl&implements&Usermanager&{
public&void&addUser(String&userId,&String&userName)&{
&&&System.out.println(&UserManagerImpl.adduser&);
public&void&deluser(String&userId)&{
System.out.println(&UserManagerImpl.deluser&);
public&String&findUser(String&userId)&{
System.out.println(&UserManagerImpl.finduser&);
return&&张三&;
public&void&modifyUser(String&userId,&String&userName)&{
System.out.println(&UserManagerImpl.modifyUser&);
动态代理类：
&*&采用JDK动态代理必须实现InvocationHandler接口&使用Proxy&类创建相应的代理类&
&*&InvocationHandler&是代理实例的调用处理程序实现的接口，
&*&每个代理类都具有一个关联的调用处理程序。
&*&对代理实例调用方法时，将对方调用进行编码并将其指派到它的调用处理程序的invoke（）方法中。
public&class&ProxyHandler&implements&InvocationHandler&{
private&Object&
public&Object&newProxyInstance(Object&target)&{
this.target&=&
&*&newProxyInstance&返回一个指定接口的代理实例，该接口可以将方法代用指派到指定的调用处理程序。&loader&-
&*&定义代理类的类加载器&interfaces&-&代理类要实现的接口列表&h&-&指派方法调用的调用处理程序
return&Proxy.newProxyInstance(target.getClass().getClassLoader(),&target.getClass().getInterfaces(),&this);
&*&反射&，可以在不知道具体类的情下，根据配置的参数去调用一个类的方法，&invoke(Object&proxy,&Method&method,
&*&Object[]&args)&在代理实例上处理方法调用并返回结果&proxy&在其上调用方法的代理实例。
&*&method：对应于在实例上处理的接口方法的Method实例。&arg：包含传入代理实例方法参数值的对应对象，
&*&返回：从代理实例的方法调用返回的值。
public&Object&invoke(Object&proxy,&Method&method,&Object[]&args)&throws&Throwable&{
System.out.println(&satrt------&&&+&method.getName());
for&(int&i&=&0;&i&&&args.&i++)&{
System.out.println(&args=&&+&args[i]);
Object&ret&=&
//&调用目标方法
ret&=&method.invoke(target,&args);
System.out.println(&sucess------&&&+&method.getName());
}&catch&(Exception&e)&{
System.out.println(&error----------&&&+&method.getName());
public&class&Client&{
public&static&void&main(String[]&args)&{
&ProxyHandler&p&=&new&ProxyHandler();
&Usermanager&&usermanager&=&&(Usermanager)&p.newProxyInstance(new&UserManagerImpl());
&&&&&usermanager.addUser(&&,&&李四&);
&&&&&System.out.println(usermanager.findUser(&&));
&&&&&System.out.println(&client&main&=------&&);
运行结果：
satrt------&addUser
UserManagerImpl.adduser
sucess------&addUser
satrt------&findUser
UserManagerImpl.finduser
sucess------&findUser
client&main&=------&
&在AOP（面向切面编程）：将日志，性能统计，安全控制，事件处理，异常处理等代码从业务逻辑代码中分离出来，通过这些行为的分离，我们希望可以将它们独立到非指导业务逻辑方法中，进而改变这些行为的时候不影响业务的逻辑的代码。
UserManagerImplProxy类中它的两个方法System.out.println(&start--&addUser()&)和System.out.println(&success--&addUser()&)，这是做核心动作之前和之后的两个截取段，正是这两个截取段，却是我们AOP的基础，在OOP里，System.out.println(&start--&addUser()&)、核心动作、System.out.println(&success--&addUser()&)这个三个动作在多个类里始终在一起，但他们所要完成的逻辑却是不同的，如System.out.println(&start--&addUser()&)里做的可能是权限的判断，在所有类中它都是做权限判断，而在每个类里核心动作却各不相同，System.out.println(&success--&addUser()&)可能做的是日志，在所有类里它都做日志。正是因为在所有的类里，核心代码之前的操作和核心代码之后的操作都做的是同样的逻辑，因此我们需要将它们提取出来，单独分析，设计和编码，这就是我们的AOP思想。一句话说，AOP只是在对OOP的基础上进行进一步抽象，使我们的类的职责更加单一。
&&&&&总结：
代理对象就是被代理的对象包装一层，对齐内部做一些额外工作，比如用户无法访问外网，可以使用网络代理先翻墙，然后在访问外网。这就是代理的作用。
我的热门文章在此可输入您对该资料的评论~
(window.slotbydup=window.slotbydup || []).push({
id: '4540180',
container: s,
size: '250,200',
display: 'inlay-fix'
资料评价：
所需积分：0您所在的位置： &
Java设计模式之虚拟代理模式
Java设计模式之虚拟代理模式
stoneWindow 翻译
javaresearch
虚拟代理模式(Virtual Proxy)是一种节省内存的技术，它建议创建那些占用大量内存或处理复杂的对象时，把创建这类对象推迟到使用它的时候。
描述：虚拟代理模式(Virtual&Proxy)是一种节省内存的技术，它建议创建那些占用大量内存或处理复杂的对象时，把创建这类对象推迟到使用它的时候。在特定的应用中，不同部分的功能由不同的对象组成，应用启动的时候，不会立即使用所有的对象。在这种情况下，虚拟代理模式建议推迟对象的创建直到应用程序需要它为止。对象被应用第一次引用时创建并且同一个实例可以被重用。这种方法优缺点并存。优点：这种方法的优点是，在应用程序启动时，由于不需要创建和装载所有的对象，因此加速了应用程序的启动。缺点：
因为不能保证特定的应用程序对象被创建，在访问这个对象的任何地方，都需要检测确认它不是空(null)。也就是，这种检测的时间消耗是最大的缺点。
应用虚拟代理模式，需要设计一个与真实对象具有相同接口的单独对象（指虚拟代理）。不同的客户对象可以在创建和使用真实对象地方用相应的虚拟对象来代替。虚拟对象把真实对象的引用作为它的实例变量维护。代理对象不要自动创建真实对象，当客户需要真实对象的服务时，调用虚拟代理对象上的方法，并且检测真实对象是否被创建。
如果真实对象已经创建，代理把调用转发给真实对象1）&&&&代理对象创建真实对象2）&&&&代理对象把这个对象分配给引用变量。3）&&&&代理把调用转发给真实对象
按照这种安排，验证对象存在和转发方法调用这些细节对于客户是不可见的。客户对象就像和真实对象一样与代理对象进行交互。因此客户从检测真实对象是否为null中解脱出来，另外，由于创建代理对象在时间和处理复杂度上要少于创建真实对象。因此，在应用程序启动的时候，用代理对象代替真实对象初始化。
假设我们建立一个JAVA程序的集成开发环境（Integrated&Development&Environment）,这个环境包括三个功能：编译、运行、生成JavaDoc文档。在新建和编辑Java程序时，最为常用的是编译和运行。至于生成JavaDoc文档对于每一个Java程序不是必需的。因此，在Java开发环境启动时，不要创建和装载实现集成开发环境全部功能的所有对象，仅创建那些在编辑、编译、运行时用到的对象，保留提供生成JavaDoc文档的对象，这是一个好的设计思想。这种对象创建策略能够高效地利用内存空间并且加快了集成开发环境的启动速度。
假设编译、运行、生成JavaDoc文档这些功能分别由三个工具类提供――Compiler、Runtime和JavaDoc。客户对象可以访问的不同IDE操作的接口以抽象类IDEOperation的形式定义。
public&abstract&class&IDEOperation&{&
&&private&&&
&&private&&&
&&public&void&compile(&javaFile)&{&
&&&&pile(javaFile);&
&&public&void&run(String&classFile)&{&
&&&&rtime.run&(classFile);&
&&//to&be&delayed&until&needed.&
&&public&abstract&void&generateDocs(String&javaFile);&
&&public&IDEOperation()&{&
&&&&cmp&=&new&Compiler();&
&&&&rtime&=&new&Runtime();&
类IDEOperation提供了编译、运行java程序方法的实现，作为它构造函数的一部分，IDEOperation创建和装载了进行编译和执行操作的Compiler和Runtime对象。生成JavaDoc文档的方法generateDocs方法被设计成抽象的方法，由它的子类来实现。
让我们定义抽象类IDEOperation的一个具体子类RealProcessor。作为RealProcessor构造函数的一部分，创建JavaDoc对象来提供生成JavaDoc文档的服务，通过使用JavaDoc对象功能实现generateDocs方法。
public&class&RealProcessor&extends&IDEOperation&{&
&&JavaDoc&&
&&public&RealProcessor()&{&
&&&&super();&
&&&&jdoc&=&new&JavaDoc();&
&&public&void&generateDocs(String&javaFile)&{&
&&&&jdoc.generateDocs(javaFile);&
通过上面的实现，RealProcessor类包含了编译、运行和生成JavaDoc文档的所有功能。像我们原来讨论的，生成JavaDoc文档的功能不是每一个Java程序所必须的，当RealProcessor实例化的时候，包括负责生成JavaDoc文档的JavaDoc对象的一系列对象被创建。推迟创建JavaDoc对象有以下优点：1）&&&&加速了RealProcessor对象的创建时间，因为它的构造函数创建的很少的对象。2）&&&&高效地利用内存，因为在不需要对象服务的时候，不需要把对象保持在内存中。在不改变RealProcessor实现的前提下，可以通过定义IDEOperation的另外一个子类ProxyProcessor来实现虚拟代理。因为RealProcessor和ProxyProcessor共享相同的接口，客户对象可以用ProxyProcessor代替RealProcessor。
public&class&ProxyProcessor&extends&IDEOperation&{&
&&private&RealProcessor&realP&
&&public&void&generateDocs(&javaFile)&{&
&&&&&In&order&to&generate&javadocs&
&&&&&the&proxy&loads&the&actual&object&and&
&&&&&invokes&its&methods.&
&&&&if&(realProcessor&==&null)&{&
&&&&&&realProcessor&=&new&RealProcessor();&
&&&&&&realProcessor.generateDocs(javaFile);&
}& 作为自己的实例变量，ProxyProcessor维护了RealProcessor对象的一个引用。作为generateDocs方法的一部分，ProxyProcessor检测引用变量是否被初始化为RealProcessor对象。如果没有被初始化，它创建一个RealProcessor对象并把这个对象分配给它的实例变量。一旦RealProcessor对象已经被创建，就调用其上的generateDocs方法。实际上，也就是当客户对象第一次请求产生javadoc文档时，RealProcessor才被初始化装入内存中。反过来，直到客户需要为Java程序生成javadocs时，JavaDoc对象才会被创建和装入内存中。客户对象像调用真实处理对象一样调用ProxyProcessor上的方法，并不需要关心（知道）RealProcessor对象是否存在。&至于验证、检测和ProxyProcessor和RealProcessor之间的交互、这样的细节对于客户对象是透明的。
public&class&Client&{&
&&public&static&void&main([]&args)&{&
&&&At&this&point&objects&required&for&
&&&the&compile&and&run&operations&are&
&&&created,&but&not&the&objects&that&provide&the&
&&&generate&Javadoc&functionality.&
&&&IDEOperation&IDE&=&new&ProxyProcessor();&
&&&pile("test.java");&
&&&IDE.run("test.class");&
&&&The&Javadoc&functionality&is&accessed&
&&&For&the&first&time&and&hence&the&
&&&Object&offering&the&Javadoc&generation&
&&&Functionality&is&loaded&at&this&point.&
&&&IDE.generateDocs("test.java");&
}& 附件为原码和原文：&&
关于&&的更多文章
Scala是一种针对 JVM 将函数和面向对象技术组合在一起的编程语言
随着云计算、物联网、大数据、移动互联网的大发展，你应该知道这些。
讲师： 66人学习过讲师： 2人学习过讲师： 163人学习过
2014年节假放假安于这周出台，80%的公民对此次的放假
进入12月份，一年的日子到头了。年末总结什么的也都开
Jquery是继prototype之后又一个优秀的Javascript框架
本书是数据库系统方面的经典教材之一。国际上许多著名大学包括斯坦福大学、耶鲁大学、得克萨斯大学、康奈尔大学、伊利诺伊大学、
51CTO旗下网站