BlogJava-OpenStudio Weblog-随笔分类-设计模式

工厂方法模式Factory Method

阿卜 — Tue, 27 Feb 2007 16:51:00 GMT

1. 模式定义... 1

2. 模式介绍... 1

3. 模式特点... 2

4. 与其它模式的关系... 3

5. 参考... 3

1. 模式定义

工厂方法模式 (Factory Method) 是创建模式的一种，也叫虚拟构造子 (Virture Constractor) 模式或多态性工厂 (Polymorphic Factory) 模式。

工厂方法模式定义一个抽象的对象创建类或接口，将实际的对象创建工作交给子类来实现。

2. 模式介绍

2.1. 简单类图

2.2. 类图对应示例代码

2.2.1. 抽象产品： AbstractProduct

public interface AbstractProduct{

public void printName();

}

2.2.2. 具体产品： ConcreteProduct1 和 ConcreteProduct2

public class ConcreteProduct1 implements AbstractProduct{

public void printName(){

System.out.println(“ConcreteProduct1”);

}

public class ConcreteProduct2 implements AbstractProduct{

public void printName(){

System.out.println(“ConcreteProduct2”);

}

2.2.3. 抽象工厂： AbstractFactory

public interface AbstractFactory {

public AbstractProduct factoryMethod();

}

2.2.4. 具体工厂： ConcreteFactory1 和 ConcreteFactory2

public class ConcreteFactory1 implements AbstractFactory{

public AbstractProduct factoryMethod(){

//do something.

return new ConcreteProduct1();

}

public class ConcreteFactory2 implements AbstractFactory{

public AbstractProduct factoryMethod(){

//do something.

return new ConcreteProduct2();

}

3. 模式特点

3.1. 开闭原则（优点）

工厂方法模式解决了简单工厂模式的一些缺陷，是在简单工厂模式的基础上发展的。

简单工厂模式把所有的重心放到工厂类上，一旦向系统增加新的产品，就必须修改工厂类，不满足开闭原则；工厂方法模式提供一个抽象的工厂接口，在不同的产品结构上实现不同的产品工厂具体类来创建该层次中的产品，通常一个具体工厂创建一个具体产品。在新增产品的时候，只需要实现新的对应工厂就可以满足需要，是符合开闭原则的。

3.2. 缺点

相比简单工厂模式，工厂方法模式客户端编程复杂，每个产品的创建都需要实例化对应的工厂类。
相对的扩展性，当需要修改产品结构中的对各产品的时候，需要修改各个工厂（当然也可以直接新加入很多新的产品和工厂，但这样不是又增加了很多无用的遗留类吗，而且现实中很可能要修改客户端代码了。），而简单工厂模式仍然只要修改一个工厂类。
现实中常常要使用退化模式，失去多态性。实际设计中经常会有子类新增功能，那么在对应工厂生产该类的时候就需要直接返回该具体类，而不是抽象产品，不然就要向下转型了。

5. 参考

《 java 设计模式》阎宏电子工业出版社

阿卜 2007-02-28 00:51 发表评论

简单工厂模式Simple Factory

阿卜 — Tue, 27 Feb 2007 15:32:00 GMT

简单工厂模式也叫静态工厂方法模式（Static Factory Method），是由一个工厂对象隐藏并决定产品类的具体创建的一种创建模式。是工厂方法模式的一种特例。

什么时候使用？
1、创建一类有公共接口或父类的对象，并要求隐藏具体实现。
2、隐藏子类的创建，提高扩展性。

优点：隐藏具体产品的创建，客户端独立的创建产品而不用关心具体的创建过程，并在引入新的产品类时不用修改客户调用类。
缺点：所用产品的创建集中到factory上，成为系统的中心，一旦factory出现问题整个系统崩溃。

标准简单工厂模式

工厂类

package pattern.simplefactory;

/**
* 简单工厂模式－工厂类
@author ZhangPu
*/

public class ProductFactory {
     /**
     * 简单工厂方法：通过类全路径创建产品
     * @param className
     * @return
      */
     public static Product factory(String className) {
        Product product = null ;
         try {
            product = (Product)Class.forName(className).newInstance();
        } catch (Exception e) {
             throw new RuntimeException(e);
        }
         return product;
    }

}

抽象产品接口

package pattern.simplefactory;

/**
* 产品接口
*/
public interface Product {
public String getName();
}

具体产品类

package pattern.simplefactory;

/**
* 普通产品
@author ZhangPu
*/

public class ConcreteProduct implements Product {
    private String name = "普通产品";

    public String getName() {
        return name;
    }
}

客户端类

package pattern.simplefactory;

/**
* client class
@author ZhangPu
*/

public class Client {
    public static void main(String[] args) {
        Product product = ProductFactory.factory("pattern.simplefactory.ConcreteProduct");
        System.out.println(product.getName());
    }
}

合并抽象产品和产品的简单工厂模式

合并产品和工厂的模式

请注意与单例模式的区别：
1.单例模式构造函数是私有的，不允许外界创建。
2.单例模式只有一个实例。

阿卜 2007-02-27 23:32 发表评论

多例模式Multiton

阿卜 — Thu, 22 Feb 2007 13:45:00 GMT

多例模式Multiton基本特性同单例Singleton,由自己创建和管理自身实例，并向系统提供自身实例。不同之处是多例类在同一容器（类加载器）或JVM中可以存在多个实例。

应用实例：序列键值生成器

本例采用hqldb作为演示数据库。表结构如下：

CREATE TABLE KEYTABLE(
KEYNAME VARCHAR(32) NOT NULL PRIMARY KEY,
KEYVALUE int NOT NULL
)

package pattern.multiton;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/*
* Key service

* table strunction:

* CREATE TABLE KEYTABLE(

* KEYNAME VARCHAR(32) NOT NULL PRIMARY KEY,

* KEYVALUE int NOT NULL

* )

@author ZhangPu
Feb 22, 2007 4:30:47 PM
*/

public class KeyService {

    private int cache;
    private String keyName;

    private int maxValue;
    private int nextValue;

    public KeyService(int cache,String keyName) {
      this.cache = cache;
      this.keyName = keyName;
      retrieveKey();
    }

    /**
     * get next key form keyinfo
     *
     * @return
     */
    public int getNextKey() {
        if(nextValue >= maxValue){
            retrieveKey();
        }
        return nextValue++;
    }

    /**
     * retrieve current value form db.
     * @return
     */
    private void retrieveKey(){
        System.out.println("retrieve database!");

        String sqlUpdate = "update KEYTABLE set KEYVALUE = KEYVALUE + " + cache + " where KEYNAME = '"+keyName+"'";
        String sqlSelete = "select KEYVALUE from KEYTABLE where KEYNAME = '"+keyName+"'";

        Connection conn = null;
        Statement stmt = null;
        int keyFormDb = 0;
        try{
            Driver driver = (Driver)Class.forName("org.hsqldb.jdbcDriver").newInstance();
            DriverManager.registerDriver(driver);

            String url = "jdbc:hsqldb:hsql://localhost/pattern";
            String user = "sa";
            String passwd = "";
            conn = DriverManager.getConnection(url,user,passwd);
            stmt = conn.createStatement();
            stmt.executeUpdate(sqlUpdate);
            ResultSet rs = stmt.executeQuery(sqlSelete);
            if(rs != null && rs.next()){
                keyFormDb = rs.getInt(1);
            }

        }catch(Exception e){
            try {
                stmt.close();
                conn.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }

        maxValue = keyFormDb;
        nextValue = keyFormDb - cache;

    }


}

package pattern.multiton;

import java.util.HashMap;
import java.util.Map;

/*
* KeyGenerator with multiton pattern
@author ZhangPu
Feb 22, 2007 5:55:24 PM
*/

public class KeyGenerator {

    /**
     * save keyServices
     */
    private static Map<String,KeyGenerator> KeyGenerators = new HashMap<String,KeyGenerator>();
    /**
     * the current instance.
     */
    private KeyService keyService;
    /**
     * cache pool size
     */
    private static final int KEY_CACHE = 20;

    private KeyGenerator(){}

    private KeyGenerator(String keyName){
         keyService = new KeyService(KEY_CACHE,keyName);
    }

    /**
     * Multiton instance
     * @param keyName
     * @return
     */
    public synchronized static KeyGenerator getInstance(String keyName){

        KeyGenerator keyGenerator;
        if(KeyGenerators.containsKey(keyName)){
            keyGenerator = KeyGenerators.get(keyName);
        }else{
            keyGenerator = new KeyGenerator(keyName);
            KeyGenerators.put(keyName, keyGenerator);
        }
        return keyGenerator;
    }

    /**
     * business method.
     * @return
     */
    public int getNextKey(){
        return keyService.getNextKey();
    }


}

package pattern.multiton;

/*
@author ZhangPu
Feb 22, 2007 6:27:22 PM
*/

public class Client {

    public static void main(String[] args) {
        String keyName = "SYS_RESOURCE";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(keyName);

        for(int i=0;i<20;i++){
            System.out.println("time"+(i+1)+":"+keyGenerator.getNextKey());
        }
    }
}

阿卜 2007-02-22 21:45 发表评论

单例模式Singleton

阿卜 — Thu, 22 Feb 2007 10:48:00 GMT

摘要: 单例模式(singleton)在很多系统中都比较常用。我用得最多的就是用来做缓存。最新重新学习设计模式，想整理一下开发中的一些经验和资料上的讲解以备以后查看。Singleton模式要点1.单例类在一个容器中只有一个实例。2.单例类使用静态方法自己提供向客户端提供实例，自己拥有自己的引用。3.必须向整个容器提供自己的实例。单例类的状态1、无状态单例类可以在多个容器或JVM中存在多个实例而正常运行，因... 阅读全文

阿卜 2007-02-22 18:48 发表评论

【原创】装饰模式Decorator

阿卜 — Sun, 24 Dec 2006 06:36:00 GMT

装饰（Decorator）模式又名包装（Wrapper）模式。Decorator以对客户端透明的方式扩展对象的功能，是继承的一种代替方案。

1.什么时候使用

需要动态的扩展一个类，这些扩展也可以动态的撤销，并保持原有类的静态定义的情况。
需要增加由一些基本功能排列组合贰产生的非常强大的功能，并使继承关系变得不实现，典型的Wrapper应用。

模拟类图：

在装饰模式中的各个角色有：

抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加责任的对象。
具体构件（Concrete Component）角色：定义一个将要接收附加责任的类。
装饰（Decorator）角色：持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口。
具体装饰（Concrete Decorator）角色：负责给构件对象"贴上"附加的责任。

2.示例代码

在一个实际的项目中，给部分用户增加了一个网络硬盘的服务。要对原来的用户注册方法进行扩展完成注册的时候给用户开通和绑定网络硬盘的功能，又要保持原来注册的功能。我考虑使用decorator模式添加一个装饰的用户管理类扩展原有的管理类来实现。

/**
* 用户管理抽象接口（Component）
*/
public interface UserManager{
public void register(User user);
}

/**
*  原有用户管理具体类（Concrete Component）
*/
public class DefaultUserManager implements UserManager{
   public void register(User user){
       //常规注册实现
   }
}

/**
* 用户管理具体装饰类NetDiskManager(只有一个装饰对象的情况，装饰类和具体装饰类合并)
*/
public class NetdiskUserManager implements UserManager{
  private UserManager userManager;
  public NetdiskUserManager(UserManager userManager){
    this.userManager = userManager;
  }

  public void register(User user){
    bandingNetdisk(user);
    userManager.register(user);
  }

  private void bandingNetdisk(User user){
    //实现绑定网络硬盘服务。
  }
}

3.在JDK-io包中的应用

在jdk-io包中标准输入输出流等相关类库都大量使用了Decorator模式。如OutputStream与其相关子类的实现。

请参考：http://redlly.blog.hexun.com/2545654_d.html

4.使用装饰模式的优点和缺点

使用装饰模式主要有以下的优点：

装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。
通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。
这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错。

使用装饰模式主要有以下的缺点：

由于使用装饰模式，可以比使用继承关系需要较少数目的类。使用较少的类，当然使设计比较易于进行。但是，在另一方面，使用装饰模式会产生比使用继承关系更多的对象。更多的对象会使得查错变得困难，特别是这些对象看上去都很相像。

5.使用装饰模式的讨论

大多数情况下，装饰模式的实现都比上面定义中给出的示意性实现要简单。对模式进行简化时需要注意以下的情况：

（1）一个装饰类的接口必须与被装饰类的接口相容。

（2）尽量保持Component作为一个"轻"类，不要把太多的逻辑和状态放在Component类里。

（3）如果只有一个ConcreteComponent类而没有抽象的Component类（接口），那么Decorator类经常可以是ConcreteComponent的一个子类。

（4）如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。

透明的装饰模式

所谓透明是指对客户端程序员来说是针对接口编程，而不是具体的继承或实现类。引用彦博士的《java与模式》的说法是：“必须永远把孙悟空的所有变化都当成孙悟空来对待，而如果把老孙变成的雀儿当成雀儿，而不是老孙，那就被老孙骗了，而这是不应当发生的。”

下面的做法是对的：

Component c = new ConcreteComponent()；
Component c1 = new ConcreteDecorator1(c)；
Component c2 = new ConcreteDecorator(c1)；

而下面的做法是不对的：

ConcreteComponent c = new ConcreteDecorator()；

半透明的装饰模式

然而，纯粹的装饰模式很难找到。装饰模式的用意是在不改变接口的前提下，增强所考虑的类的性能。在增强性能的时候，往往需要建立新的公开的方法。即便是在孙大圣的系统里，也需要新的方法。比如齐天大圣类并没有飞行的能力，而雀儿有。这就意味着雀儿应当有一个新的fly()方法。

这就导致了大多数的装饰模式的实现都是"半透明"（semi-transparent）的，而不是完全"透明"的。换言之，允许装饰模式改变接口，增加新的方法。即声明ConcreteDecorator类型的变量，从而可以调用ConcreteDecorator类中才有的方法：

齐天大圣 c = new 大圣本尊()；
雀儿 bird = new 雀儿(c)；
bird.fly()；

齐天大圣接口根本没有fly()这个方法，而雀儿接口里有这个方法。

参考：

《java与模式》

google搜索："java decorator"

阿卜 2006-12-24 14:36 发表评论