黑马程序员技术交流社区
标题:
代理
[打印本页]
作者:
Inspur
时间:
2013-9-18 08:50
标题:
代理
今天看了代理一节课，感觉和装饰类差不多，请高手给讲解一下代理和装饰类的区别？
作者:
麦子609
时间:
2013-9-18 08:59
装饰模式：以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案；
代理模式：给一个对象提供一个代理对象，并有代理对象来控制对原有对象的引用；
装饰模式应该为所装饰的对象增强功能；代理模式对代理的对象施加控制，并不提供对象本身的增强功能。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。总之，使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。
作者:
诗化了邂逅
时间:
2013-9-18 11:43
区别在于，代理模式对于被代理的类是固化在代理类中的，而对于装饰器模式，被装饰的类是调用时实例化的，也就是说被装饰的类是可以调用时动态选择的。代理模式中，代理类对被代理的对象有控制权，决定其执行或者不执行。而装饰模式中，装饰类对代理对象没有控制权，只能为其增加一层装饰，以加强被装饰对象的功能，仅此而已。
对装饰器模式来说，装饰者和装饰客户都实现同一个接口。对代理模式来说，代理类和真实处理的类都实现同一个接口。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。
总结起来可以说：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。
//代理模式
public class Proxy implements Subject{
private Subject subject;
public Proxy(){
//关系在编译时确定
subject =new RealSubject();
}
public void doAction(){
subject.doAction();
}
}
//代理的客户
public class Client {
public static void main(String[] args){
//客户不知道代理委托了另一个对象
Subject subject = new Proxy();
}
}
//装饰模式
public class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component = component
}
public void operation() {
component.operation();
}
}
//装饰的客户
public class Client{
public static void main(String[] args){
//客户指定了装饰者需要装饰的是哪一个类
Component component = new Decorator(new ConcreteComponent());
}
}
作者:
0和1，编程世界
时间:
2013-9-24 21:17
代理模式是一种很常用的设计模式，其目的是对其他对象提供一种代理以控制对这个对象的访问。
代理模式又分为静态代理和动态代理，静态代理是在程序运行之前就已经存在了代理类，动态代理是程序运行中在内存中生成代理类。
代理模式存在的意义：代理模式是为了解决滥用继承的问题而生的，当想对某个类的功能进行扩充的时候可以使用继承或聚合，很明显用继承的话会造成类泛滥，还有一点就是继承是类具有很强的层级关系的情况下用才好，而紧紧对某个类进行功能的扩充就拿起继承的大刀明显的不合适，那么用聚合呢？聚合是一种松耦合的，用聚合创建的代理类就是静态代理，还有更好的代理是动态代理。
动态代理自己实现其实也很简单，不过JDK提供了方便的解决方案。
java.lang.reflect.InvocationHandler
java.lang.reflect.Proxy
这两个东东就是为动态代理而生的
Java代码
1.package design.proxy.hello;
2./**
3. * @author 作者 E-mail:
jqsl2012@163.com
4. * @version 创建时间：2012-2-2 下午03:57:56 <br>
5. */
6.public interface Hello {
7. void say();
8.}
Java代码
1.package design.proxy.hello;
2.
3./**
4. * @author 作者 E-mail:
jqsl2012@163.com
5. * @version 创建时间：2012-2-2 下午03:58:10 <br>
6. * 被代理的类
7. */
8.public class HelloImpl implements Hello {
9.
10. public void say() {
11. System.out.println("say");
12. }
13.}
Java代码
1.package design.proxy.hello;
2.
3.import java.lang.reflect.InvocationHandler;
4.import java.lang.reflect.Method;
5.import java.lang.reflect.Proxy;
6.
7./**
8. * @author 作者 E-mail:
jqsl2012@163.com
9. * @version 创建时间：2012-2-2 下午03:54:45 <br>
10. * 动态代理
11. */
12.public class HelloProxy {
13. public static Object newProxyInstance(final Object target) {
14. InvocationHandler h = new InvocationHandler() {
15.
16. public Object invoke(Object proxy, Method method, Object[] args)
17. throws Throwable {
18. before();
19. Object result = method.invoke(target, args);
20. after();
21. return result;
22. }
23. };
24. return Proxy.newProxyInstance(target.getClass().getClassLoader(),
25. target.getClass().getInterfaces(), h);
26. }
27.
28. private static void before() {
29. System.out.println("before");
30. }
31.
32. private static void after() {
33. System.out.println("after");
34. }
35.}
Java代码
1.package design.proxy.hello;
2./**
3. * @author 作者 E-mail:
jqsl2012@163.com
4. * @version 创建时间：2012-2-2 下午03:57:44 <br>
5. *
6. */
7.public class Test {
8. public static void main(String[] args) {
9. /*
10. * 代理模式
11. */
12. Hello proxy = (Hello) HelloProxy.newProxyInstance(new HelloImpl());
13. proxy.say();
14. }
15.}
-----------------------------分割线----------------------------------
上面是代理模式，其实装饰模式和代理模式极为相似
相同点：都是为被代理(被装饰)的类扩充新的功能。
不同点：代理模式具有控制被代理类的访问等性质，而装饰模式紧紧是单纯的扩充被装饰的类。所以区别紧紧在是否对被代理/被装饰的类进行了控制而已。
Java代码
1.package design.staticProxy;
2./**
3. * @author 作者 E-mail:
jqsl2012@163.com
4. * @version 创建时间：2012-2-3 下午10:10:43 <br>
5. */
6.public interface InputStream {
7. void read();
8.}
Java代码
1.package design.staticProxy;
2./**
3. * @author 作者 E-mail:
jqsl2012@163.com
4. * @version 创建时间：2012-2-3 下午10:11:16 <br>
5. */
6.public class FileInputStream implements InputStream{
7.
8. public void read() {
9. System.out.println("FileInputStream.read");
10. }
11.
12.}
Java代码
1.package design.staticProxy;
2.
3./**
4. * @author 作者 E-mail:
jqsl2012@163.com
5. * @version 创建时间：2012-2-3 下午10:11:50 <br>
6. * 代理/装饰类具有和被代理/被装饰的类相同的接口
7. */
8.public class BufferedInputStream implements InputStream {
9. protected InputStream in;
10.
11. public BufferedInputStream(InputStream in) {
12. this.in = in;
13. }
14.
15. public void read() {
16. //加入控制代码就是代理，否则单纯的扩充功能就是装饰模式
17. if(true){
18. System.out.println("BufferedInputStream.read");
19. }
20. this.in.read();
21. }
22.}
Java代码
1.package design.staticProxy;
2.
3./**
4. * @author 作者 E-mail:
jqsl2012@163.com
5. * @version 创建时间：2012-2-3 下午10:13:20 <br>
6. */
7.public class Test {
8. public static void main(String[] args) {
9. BufferedInputStream buffIn = new BufferedInputStream(new FileInputStream());
10. buffIn.read();
11. }
12.}
很明显，装饰模式和静态代理极为相似。设计模式里面有许多模式都看起来很相似，要区分估计得从目的上去区分了。
作者:
陈洋
时间:
2013-9-24 22:15
楼主可以看看下面的总结：
装饰模式：以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案；
代理模式：给一个对象提供一个代理对象，并有代理对象来控制对原有对象的引用；
装饰模式应该为所装饰的对象增强功能；代理模式对代理的对象施加控制，并不提供对象本身的增强功能
二者的实现机制确实是一样的，可以看到他们的实例代码重复是很多的。但就语义上说，这两者的功能是相反的，模式的一个重要作用是简化其他程序员对你程序的理解，
你在一个地方写装饰，大家就知道这是在增加功能，你写代理，大家就知道是在限制，
虽然代码很可能相同，但如果你都叫他们装饰，别人会很迷惑的。
作者:
yting_xmei1129
时间:
2013-9-24 23:15
本帖最后由 yting_xmei1129 于 2013-9-24 23:16 编辑
这两个设计模式看起来很像。
对装饰器模式来说，装饰者（decorator）和被装饰者（decoratee）都实现同一个 接口。对代理模式来说，代理类（proxy class）和真实处理的类（real class）都实现同一个接口。此外，不论我们使用哪一个模式，都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。
然而，实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。
我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。
希望可以帮到楼主、、、
The you smile until forever 、、、、、、、、、、、、、、、、、、、、、
欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)
黑马程序员IT技术论坛 X3.2