BlogJava-欢迎来到小小家院-随笔分类-设计模式

命令模式学习笔记

扭转乾坤 — Mon, 05 May 2008 01:28:00 GMT

命令模式：将“请求”封装成对象，以便使用不同得请求，队列或者日志来参数化其他对象，命令模式也支持可撤销得操作！（Head First Design Patterns ）
优点：解耦了发送者和接受者之间联系。发送者调用一个操作，接受者接受请求执行相应的动作，因为使用Command模式解耦，发送者无需知道接受者任何接口。
1. 简单的命令模式
命令接口：

public interface Command {
public void execute();
}

关闭灯命令：

public class LightOffCommand implements Command {
Light light;

public LightOffCommand(Light light) {
this.light = light;
}

public void execute() {
light.off();
}
}

打开灯命令：

public class LightOnCommand implements Command {
    Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.on();
    }
}

灯：

public class Light {

    public Light() {
    }

    public void on() {
        System.out.println("Light is on");
    }

    public void off() {
        System.out.println("Light is off");
    }
}

命令调用者：

public class SimpleRemoteControl {
    Command slot;

    public SimpleRemoteControl() {}

    public void setCommand(Command command) {
        slot = command;
    }

    public void buttonWasPressed() {
        slot.execute();
    }
}

测试类：

public class RemoteControlTest {
public static void main(String[] args) {
  SimpleRemoteControl remote = new SimpleRemoteControl();
  Light light = new Light();
  LightOnCommand lightOn = new LightOnCommand(light);

  remote.setCommand(lightOn);
  remote.buttonWasPressed();
    }
}

命令模式得特点：
1》分布登记统一执行：
在作程序时，经常碰到一些需求，先注册一些操作，并不马上执行，等最终确定后统一执行。如一个具体的例子:用户定制自己的报表，可以订阅饼，柱，折线，曲线图，客户选择相应的报表组合，这样对应一个命令集合，在没确定之前用户可以增删这些报表（命令），等最终确定统一交给调用者根据命令执行，生成组合报表。实现了命令分布提出，确定后统一执行的功能。

2》形如流水线操作：还是出书的例子
//先是一本空白的书：
Book book = new Book();
//找几个作者
Author author1 ＝ new Author();
Author author2 ＝ new Author();
//把写1，2章的名类分别给这两个作者
Command writeCommand = new Write1Command (author1，book);
Command writeCommand = new Write2Command (author2，book);
List commands ＝ new List ();
Commands.add(writeCommand);
//调用者
Invoker invoker = new invoker();
Invoker.setCommands(commands);
//流水写书
invoker.action()
实际上在aciton这一方法中，invoker按照命令，让两个作者流水写作这本书。（类似一个书的流水线加工工厂）
这样我们的书就被流水加工成功（当然这本书只有两章）

这样就给了我们一种系统设计的框架，
模型＋工具＋命令
客户端产生命令，命令调用工具操作模型。
Book 相当于模型
Author 相当于和多工具类中的一个
Command 命令

3》系统需要支持命令的撤消(undo)。提供redo()方法【容易扩展】
我们可以和容易的加入undo和redo，这个不难理解

4》在Invoker中我们可以实现跟踪，和日志。

5》当系统需要为某项复制增加形的功能的时候，命令模式使新的功能（表现为一种命令）很容易地被加入到服务种里。
命令联系了工具类即执行类和系统逻辑，

简化/变化的命令模式：
命令模式的角色比较多，在实际应用种我们可以根据所需要的功能和不需要的功能加以简化。

1》去掉调用者
产生命令集合后，我们可以直接在client中迭代执行执行操作
2》变化调用者成为跟踪者
//调用者
public class Invoker{
List commands; //已经执行完毕的命令集合
public void addCommand (Command command,int i){
commands.add(i,command);
}
public void action(Command command){
//执行操作
command. execute();
//
commands.add(command);
}
}
……………
//还可以有丰富的redo和undo操作；(当然一些都给基于命令类提供的相应方法)
}
这样这个类就记录了所有执行过的操作。

3》去掉命令用map替代
我们完全可以用map代替命令，这样无需定义各种命令类
我们改进例子
Author author ＝ new Author();
Publisher publisher ＝ new Publisher ();
Map m = new HashMap;
m.put(author, write);
m.put(author, publisherBook);
在Invoker的action方法：
得代map
运用java反射来调用方法；

4》去掉执行者：
直接在命令中（execute方法种）加业务逻辑。这样只适合于简单的小的系统.

其他要说的内容
1》将某些参数传给某个方发的方式很多，除了当作方法的参数外还可以当作类的成员便俩变量传入：
这就为命令的抽象带来了极大的方便
abstract class Command
{
abstract public void execute();
}
当我们已经有了执行者（类Test）方法execute（args1，args2 ….argsn）
我们不必向Command加入execute（args1，args2 ….argsn）抽象方法，在说即使加了，在我们迭代的时候也无法判断或十分不容易判断哪个命令调用哪个execute方法。
那么我们可以这样
class ConcreteCommand : Command
{
Test test;
args1
args2
…..
argsn
public override void Execute()
{
test. execute (args1，args2 ….argsn);
}
}
2》在想跟踪操作的时候，一般为每一个操作对象分配一个调用者，操作对象在调用者中设置。（可以抽象出一个总的调用者，来协调调用每一个具体的调用者）
3》命令的抽象粒度我觉得是要注意的。
4》理解思想，不要机械的照搬。消化成自己的，加以灵活的运用和创造在是根本出路。
所谓命令模式的根本思想就是在先形成命令，在根据命令执行。

参考：http://blog.csdn.net/baggio785/archive/2006/05/23/750513.aspx

扭转乾坤 2008-05-05 09:28 发表评论

工厂模式学习笔记

扭转乾坤 — Sun, 04 May 2008 06:13:00 GMT

1. 简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

1.public class CarFactory{
       public static Car getCar(int type){
           if(type == 1){
                  return new Car1();
              } else {
              return new Car2();
           }
       }
}

2. public class CarFactory{
        public static Car getCar(String carClass){
            String className = carClass;
             Class c = Class.forName(className);
             Car car = (Car)c.newInstance();
             return car;
        }
}

3. public class CarFactory{
        public static Car getCar(String carJNDIName){
            InitialContext ic = new InitialContext();
            String className = ic.lookUp(carJNDIName);
            Car car = (Car)Class.forName(className).newInstance();
            return car;
        }
}
方式1～3适合于工厂所产生的对象都是属于同一个父类型的，而从方式1～3来看，方式1无疑是最简单的，也是最容易理解和接受的，而方式2和方式3则相对来说要高级一点。高级在哪里呢？我们可以看到，方式1中对对象的创建是使用Hardcode的形式，也即是程序员需要事先知道系统里面存在多少个类型的对象及其对应的编号，一旦增加或删除、修改了对象的类型，则必然引起if-else块的改变，造成了维护的困难。

而方式2则采用了动态类加载的方式，方式3在方式2的基础上使用了JNDI，更进了一步，其好处是不用出现HardCode的方式，即便你后面的应用增加、删除了对象的类型，我的程序还是保持现在的样子，跟进一步来说：可以去掉那些讨厌的if-else语句。
2. 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。【实质上它是让工厂实现了抽象的工厂接口，它把具体怎么生产一种东西，放在具体的工厂去实现了，所谓”延迟到子类中实现“】
示例一：
public interface Driver{
       public Car driverCar();
}
public class BenzDriver implements Driver{
       public Car driverCar(){
              return new Benz();
       }
}
public class BmwDriver implements Driver{
       public Car driverCar()   {

return new Bmw();
}
}

// 应该和具体产品形成对应关系 ...
// 有请暴发户先生
public class Magnate

{

public static void main(String[] args)

{

try{
Driver driver = new BenzDriver();

Car car = driver.driverCar();

car.drive();

}

……

}
示例二：

public interface Creator
{
public Prouct factory();
}

public SubCreator1 implent Creator
{
   public Prouct factory()
{
   return new ConcreteProduct1();
   }
}

public SubCreator2 implent Creator
{
   public Prouct factory()
{
    return new ConcreteProduct2();
   }
}

请注意：返回类型是Product型的！！
这样客户端调用是直接new 一个具体工厂的实例，然后命令它去生产，而对于具体工厂的父类（既工厂接口，接口完全可以改成子类继承父类来实现，只是这样不好，不符合OO的原则），它完全不知道什么产品被生产了，甚至它连那个具体工厂被实例化它都不知道！
3. 抽象工厂
public abstract class AbstractFactory{
        public abstract Car getCar(String carClass);
        public abstract Plane getPlane(String planeClass);
}

public class Factory1 extends AbstractFactory{
      public Car getCar(String carClass){
          // 参考上面的方式1～3
          return car1;
      }

      public Plane getPlane(String planeClass){
          // 参考上面的方式1～3
          return plane1;
      }
}

public class Factory2 extends AbstractFactory{
     public Car getCar(String carClass){
          // 参考上面的方式1～3
          return car2;
     }

     public Plane getPlane(String planeClass){
          // 参考上面的方式1～3
          return plane2;
     }
}

方式4是最为复杂而且也是最为强大的一种，它在实现了对象工厂抽象的基础上，又集成了工厂方法。使到不同的工厂可以生产相同类型的产品，但产品的子类可能有所不同。就像上面的工厂1和工厂2都可以生产汽车和飞机一样，他们各自之间可以生产不同系列的产品(抽象工厂)，而且每个系列下面可能有不同的型号(工厂方法)。

参考资料：http://www.blogjava.net/pengpenglin/archive/2008/01/02/172325.html
http://www.blogjava.net/killme2008/archive/2007/03/15/104031.html
http://www.blogjava.net/alex/archive/2006/08/29/66479.html

扭转乾坤 2008-05-04 14:13 发表评论

单实例模式学习笔记

扭转乾坤 — Sun, 04 May 2008 00:38:00 GMT

1. 经典的单实例模式例子（非线程安全）：
public class Singleton {
    private static Singleton uniqueInstance;

    // other useful instance variables here

    private Singleton() {}

    public static Singleton getInstance() {
        if (uniqueInstance == null) {
        uniqueInstance = new Singleton();
     }
         return uniqueInstance;
    }

    // other useful methods here
}
本例是最经典的单实例模式例子，但是在多线程的情况下就会产生多个实例！

2. 线程安全的例子：
public class Singleton {
private static Singleton uniqueInstance;

// other useful instance variables here

private Singleton() {}

public static synchronized Singleton getInstance() {
  if (uniqueInstance == null) {
   uniqueInstance = new Singleton();
  }
  return uniqueInstance;
}

// other useful methods here
}
增加synchronized，会让该方法是线程安全的，但是会引起每个线程在调用该方法时的等待，如果getInstance的性能对应用程序不是很关键（记住，同步方法可能会使getInstance方法得运行效率降低100倍），本方法是最好得方法！
3. 提前实例化，不适用延迟实例化（使用于创建和运行时负担不太繁重或者应用程序总是创建并使用单件实例），它是线程安全得：
public class Singleton {
    private static Singleton uniqueInstance = new Singleton();

    // other useful instance variables here

    private Singleton() {}

    public static Singleton getInstance() {
            return uniqueInstance;
    }

    // other useful methods here
}
采用这种方法，我们依赖JVM在加载这个类时候马上创建此唯一实例，JVM保证在任何线程访问它之前，一定先创建它!
4. 在java1.5及以后的版本，增加了volatile关键字，可以采用双重检查加锁！
public class Singleton {
private volatile static Singleton uniqueInstance;

private Singleton() {}

public static Singleton getInstance() {
  if (uniqueInstance == null) {
   synchronized (Singleton.class) {
    if (uniqueInstance == null) {
     uniqueInstance = new Singleton();
    }
   }
  }
  return uniqueInstance;
}
}
volatile关键字确保：当unigueInstance变量在被初始化成实例时，多个线程能够正确的处理它！（对于关注性能的程序，这种做法可以大大减少时耗）

扭转乾坤 2008-05-04 08:38 发表评论