BlogJava-我的JAVA学习笔记-随笔分类-设计模式

Bridge模式

EvanLiu — Fri, 01 Feb 2008 08:20:00 GMT

7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了

【GOF95】在提出桥梁模式的时候指出，桥梁模式的用意是"将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化"。这句话有三个关键词，也就是抽象化、实现化和脱耦。

/**
* 抽象化角色
*/
public abstract class Abstraction {
   protected Implementor imp;
   public void setImp(Implementor imp) {
       this.imp = imp;
   }
   public void operation() {
       imp.operationImpl();
   }
}
/**
* 修正抽象化角色A
*/
public class RefinedAbstractionA extends Abstraction {
   public void operation() {
       //improved logic
   }
}
/**
* 修正抽象化角色B
*/
public class RefinedAbstractionB extends Abstraction {
   public void operation() {
       //improved logic
   }
}
/**
* 实现化角色
*/
public abstract class Implementor {
   public abstract void operationImp();
}
/**
* 具体实现化角色A
*/
public class ConcreteImplementorA extends Implementor {
   public void operationImp() {
       System.out.println("Do something...");
   }
}
/**
* 具体实现化角色B
*/
public class ConcreteImplementorB extends Implementor {
   public void operationImp() {
       System.out.println("Do another thing...");
   }
}
public class Client {
   public static void main(String[] args) {
       Abstraction abs = new RefinedAbstractionA();
       abs.setImp(new ConcreteImplementorA()); //等于把RefinedAbstractionA和ConcreteImplementorA组合起来了
       abs.operation();
       abs.setImp(new ConcreteImplementorB()); //等于把RefinedAbstractionA和ConcreteImplementorB组合起来了
       abs.operation();

       //或者再换RefinedAbstractionB
       //...
   }
}

EvanLiu 2008-02-01 16:20 发表评论

Adapter模式

EvanLiu — Thu, 31 Jan 2008 06:28:00 GMT

ADAPTER —在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)

个人理解，适配器模式，就是两个水管A(Target)和C(Adaptee)接口不匹配不兼容，就拿另外一截管子B(Adapter)，一头接上原本的水管A（继承），另一头接上C(调用)。那么，A通过B，和C接上了。

public interface Target {
    public void methodA();
}
public class Adaptee {
    public void methodB() {
       //do something...
    }
}
public class Adapter extends Target {
    private Adaptee ee;
    public Adapter(Adaptee ee) {
       this.ee = ee;
    }
    public void methodA() { //水管C Adapter的接口
       ee.methodB(); //实际调用了水管B Adaptee的接口
    }
}

Adapter和Proxy的区别：
adapter是适配adaptee和target之间的关系，proxy是realSubject对subject的代理。
adaptee和target无关系，realSubject和subject有继承关系。这就是他们的区别。

这里有篇文章很不错，链接一下：
http://yichao.blog.edu.cn/user2/yichaozhang/archives/2006/1501606.shtml

又找到网上另一个见解：
proxy 和adapter有一定类似，都是属于一种衔接性质的。
区别是很明显的，从大体上说：proxy是一种原来对象的代表，其它需要与这个对象打交道的操作都是和这个代表交涉，就象歌星的经纪人一样。
adapter目的则不是要虚构出一个代表者，而是为应付特定使用目的，将原来的类进行一些组合。

EvanLiu 2008-01-31 14:28 发表评论

Command模式

EvanLiu — Thu, 24 Jan 2008 08:45:00 GMT

14、COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给我。
这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说："我同时给我姐姐三个男朋友送COMMAND，就数你最小气，才请我吃面。"，:-(

命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，
何时被执行以及是怎么被执行的。系统支持命令的撤消。

典型的Command模式需要有一个接口.接口中有一个统一的方法,这就是"将命令/请求封装为对象":
public interface Command {
    public abstract void execute ( );
}

《Java与模式》一书中的例子如下：
/**
* 客户端(Client)代码
*/
public class Client {
   public static void main(String[] args) {
       Receiver receiver = new Receiver();
       Command command = new ConcreteCommand(receiver);
       Invoker invoker = new Invoker(command);
       invoker.action();
   }
}
/**
* 请求者(Invoker)角色代码
*/
public class Invoker {
   private Command command;
   public Invoker(Command command) {
       this.command = command;
   }
   public void action() {
       command.execute();
   }
}
/**
* 接收者(Receiver)角色代码
*/
public class Receiver {
   public Receiver() {
       //write code here
   }
   public void action() {
       System.out.println(""Action has been taken);
   }
}
/**
* 抽象命令角色由Command接口扮演
*/
public class Command {
   void execute();
}
/**
* 具体命令类
*/
public class ConcreteCommand implements Command {
   private Receiver receiver;
   public ConcreteCommand(Receiver receiver) {
       this.receiver = receiver;
   }
   public void execute() {
       receiver.action();
   }
}

再用某公司写的Command模式，简化代码写个大概样子：
/**
* 客户端(Client)代码
*/
public class Client {
   public static void main(String[] args) {
       String receiverName = "xAO";
       String methodName = "methodA";

       //receiverName这里用Spring的依赖注入来创建Receiver对象
       Command command = new ConcreteCommand(receiverName);
       command.getParameters.put("method", methodName);   //实际代码做了封装，并不是这样直接写的。这里简化一下
       command.getParameters.put("param1", "param1"); //传递参数
       command.getParameters.put("param2", "param2");

       Result result = getNewInvoker.execute(command); //创建Invoker对象，并调用receiver执行最终的方法
   }
}
/**
* 请求者(Invoker)角色代码
*/
public class Invoker {
   private Command command;
   public Invoker(Command command) {
       this.command = command;
   }
   public void action() {
       command.execute();
   }

   private BeanFactoryService beanFactory;

   public Result execute(Command command) {
       ApplicationObject ao = beanFactory.getBean(command.getName(), ApplicationObject.class, new XXProcessor(command));
       return ao.execute(); //这里就是接收者Receiver来执行具体方法: xAO.methodA();
   }
}

/**
* 抽象命令角色由Command接口扮演
*/
public class Command {
   //...
   //没有execute()方法
}
/**
* 具体命令类
*/
public class ConcreteCommand implements Command {
   //也没有execute()方法
   //...
}

EvanLiu 2008-01-24 16:45 发表评论

Proxy模式

EvanLiu — Thu, 24 Jan 2008 05:48:00 GMT

12、PROXY?跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀？”“你多大了？”“身高多少呀？”这些话，真烦人，写个程序做为我的Proxy吧，凡是接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，酷吧。

代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。

public interface Subject {
    public void methodA();
}
public class RealSubject implements Subject {
    public void methodA() {
       System.out.println("...");
    }
}
public class Proxy implements Subject {
    private RealSubject r;
    public void methodA() {
       if(r == null) {
          r = RealSubject();
       }
       r.methodA();
       //do something...
    }
}
我觉得可以理解为通过RealSubject的兄弟Proxy去调用RealSubject的方法

和Decorator模式的比较：
相同点：Both patterns use a proxy that forwards method calls to another object, known as the real subject.
不同点：with the Proxy pattern, the relationship between a proxy and the real subject is typically set at compile time, whereas decorators can be recursively constructed at runtime.
从另一种角度考虑：proxy是对类的代理，强调的是对已有功能的代理；而decorator更多的是用于增加装饰，来丰富类的内涵。

Adapter和Proxy的区别：
adapter是适配adaptee和target之间的关系，proxy是realSubject对subject的代理。
adaptee和target无关系，realSubject和subject有继承关系。这就是他们的区别。

这里有篇文章很不错，链接一下：
http://yichao.blog.edu.cn/user2/yichaozhang/archives/2006/1501606.shtml

又找到网上另一个见解：
proxy 和adapter有一定类似，都是属于一种衔接性质的。
区别是很明显的，从大体上说：proxy是一种原来对象的代表，其它需要与这个对象打交道的操作都是和这个代表交涉，就象歌星的经纪人一样。
adapter目的则不是要虚构出一个代表者，而是为应付特定使用目的，将原来的类进行一些组合。

EvanLiu 2008-01-24 13:48 发表评论

Decorator/Wrapper模式

EvanLiu — Thu, 24 Jan 2008 03:31:00 GMT

9、 DECORATOR: Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上 “最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？

装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

它最经典的特征就是：
1.必须有一个它自己的父类为自己的成员变量；
2.必须继承公共父类。

public interface Component {
    public void methodA();
}
public class ConcreteComponent implements Component {
    public void methodA() {
       //do somthing...
    }
}
public class Decorator implements Component {
    private Component c;

    public Decorator(Component c) {
       this.c = c;
    }
    public void methodA() {
       //do sth.
       c.methodA();
       //do sth.
    }
}

下面这个例子来自Head First，收藏
http://www.blogjava.net/sterning/archive/2008/01/21/176679.html

EvanLiu 2008-01-24 11:31 发表评论

观察者模式（Observer）

EvanLiu — Mon, 12 Nov 2007 09:44:00 GMT

19、OBSERVER —想知道咱们公司最新MM情报吗？加入公司的MM情报邮件组就行了，tom负责搜集情报，他发现的新情报不用一个一个通知我们，直接发布给邮件组，我们作为订阅者（观察者）就可以及时收到情报啦

观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

观察者（Observer）模式又名发布-订阅（Publish/Subscribe）模式。GOF给观察者模式如下定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

观察者模式的组成部分。

1) 抽象目标角色（Subject）

2) 抽象观察者角色（Observer）

3) 具体目标角色（Concrete Subject）

4) 具体观察者角色（Concrete Observer）

EvanLiu 2007-11-12 17:44 发表评论