creation型design模式tutorial

creation型design模式关注object creation过程, providing了一种 in creationobject时隐藏creation逻辑方式, 使得code更加flexible and 可maintenance. 本tutorial将详细介绍单例, 工厂, 建造者, 原型etc.common creation型design模式.

creation型design模式overview

creation型design模式主要目 is 将object creation and using分离, from 而improvingcode flexible性 and 可maintenance性. throughusingcreation型模式, 我们可以:

控制object creation过程
隐藏objectcreation 细节
使system独立于object creation, 组合 and 表示
providing一种统一方式来creationobject

1. singleton pattern (Singleton)

concepts

singleton pattern确保一个class只 has 一个instance, 并providing一个全局访问点来访问这个instance.

implementation

                    // 懒汉式singleton pattern
class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // 私 has constructmethod, 防止 out 部instance化
    }
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 饿汉式singleton pattern
class SingletonEager {
    private static final SingletonEager instance = new SingletonEager();
    
    private SingletonEager() {
        // 私 has constructmethod
    }
    
    public static SingletonEager getInstance() {
        return instance;
    }
}

// 双重checklocksingleton pattern
class SingletonDoubleCheck {
    private static volatile SingletonDoubleCheck instance;
    
    private SingletonDoubleCheck() {
        // 私 has constructmethod
    }
    
    public static SingletonDoubleCheck getInstance() {
        if (instance == null) {
            synchronized (SingletonDoubleCheck.class) {
                if (instance == null) {
                    instance = new SingletonDoubleCheck();
                }
            }
        }
        return instance;
    }
}
                

application场景

log记录器
configurationmanagement器
datalibrary连接池
thread池
cache

2. factory pattern (Factory Method)

concepts

工厂method模式定义了一个creationobject interface, 但让子class决定要instance化 class is 哪一个. 工厂method让class instance化推迟 to 子classinfor.

implementation

                    // 产品interface
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// 工厂interface
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}
                

application场景

当一个class不知道它所必须creation object class时
当一个class希望由它子class来指定它所creation object时
当class将creationobject 职责委托给 many 个helping子classin 某一个, 并且你希望将哪一个helping子class is proxy者这一information局部化时

3. Builder Pattern

concepts

Builder Pattern将一个 complex object 构建 and 它表示分离, 使得同样构建过程可以creation不同表示.

implementation

                    // 产品class
class Product {
    private String partA;
    private String partB;
    private String partC;
    
    public void setPartA(String partA) {
        this.partA = partA;
    }
    
    public void setPartB(String partB) {
        this.partB = partB;
    }
    
    public void setPartC(String partC) {
        this.partC = partC;
    }
    
    public void show() {
        System.out.println("Product parts: " + partA + ", " + partB + ", " + partC);
    }
}

// 建造者interface
interface builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

// 具体建造者1
class Concretebuilder1 implements builder {
    private Product product;
    
    public Concretebuilder1() {
        product = new Product();
    }
    
    @Override
    public void buildPartA() {
        product.setPartA("Part A1");
    }
    
    @Override
    public void buildPartB() {
        product.setPartB("Part B1");
    }
    
    @Override
    public void buildPartC() {
        product.setPartC("Part C1");
    }
    
    @Override
    public Product getResult() {
        return product;
    }
}

// 具体建造者2
class Concretebuilder2 implements builder {
    private Product product;
    
    public Concretebuilder2() {
        product = new Product();
    }
    
    @Override
    public void buildPartA() {
        product.setPartA("Part A2");
    }
    
    @Override
    public void buildPartB() {
        product.setPartB("Part B2");
    }
    
    @Override
    public void buildPartC() {
        product.setPartC("Part C2");
    }
    
    @Override
    public Product getResult() {
        return product;
    }
}

// 指挥者
class Director {
    public void construct(builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        Director director = new Director();
        
        builder builder1 = new Concretebuilder1();
        director.construct(builder1);
        Product product1 = builder1.getResult();
        product1.show();
        
        builder builder2 = new Concretebuilder2();
        director.construct(builder2);
        Product product2 = builder2.getResult();
        product2.show();
    }
}
                

application场景

当creation complex object algorithms应该独立于该object 组成部分以及它们装配方式时
当construct过程必须允许被construct object has 不同表示时

4. Prototype Pattern

concepts

Prototype Pattern用原型instance指定creationobject 种class, 并且through拷贝这个原型来creation new object.

implementation

                    // 原型interface
interface Prototype {
    Prototype clone();
}

// 具体原型1
class ConcretePrototype1 implements Prototype {
    private String field;
    
    public ConcretePrototype1(String field) {
        this.field = field;
    }
    
    @Override
    public Prototype clone() {
        return new ConcretePrototype1(this.field);
    }
    
    public void setField(String field) {
        this.field = field;
    }
    
    public String getField() {
        return field;
    }
    
    @Override
    public String toString() {
        return "ConcretePrototype1{field='" + field + "'}";
    }
}

// 具体原型2
class ConcretePrototype2 implements Prototype {
    private int field;
    
    public ConcretePrototype2(int field) {
        this.field = field;
    }
    
    @Override
    public Prototype clone() {
        return new ConcretePrototype2(this.field);
    }
    
    public void setField(int field) {
        this.field = field;
    }
    
    public int getField() {
        return field;
    }
    
    @Override
    public String toString() {
        return "ConcretePrototype2{field=" + field + "}";
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        ConcretePrototype1 prototype1 = new ConcretePrototype1("Prototype 1");
        ConcretePrototype1 clone1 = (ConcretePrototype1) prototype1.clone();
        clone1.setField("Clone of Prototype 1");
        System.out.println(prototype1);
        System.out.println(clone1);
        
        ConcretePrototype2 prototype2 = new ConcretePrototype2(100);
        ConcretePrototype2 clone2 = (ConcretePrototype2) prototype2.clone();
        clone2.setField(200);
        System.out.println(prototype2);
        System.out.println(clone2);
    }
}

                

application场景

当一个system应该独立于它产品creation, 构成 and 表示时
当要instance化 class is in run时刻指定时
当你希望throughcopy现 has object来creation new object, 而不 is throughinstance化 new object时

creation型模式选择guide

in 选择creation型模式时, 可以考虑以 under 因素:

such as果需要确保一个class只 has 一个instance, usingsingleton pattern
such as果需要将object creation and using分离, usingfactory pattern
such as果需要构建 complex object, usingBuilder Pattern
such as果需要throughcopy现 has object来creation new object, usingPrototype Pattern

实践case: creation型模式 application

case: configurationmanagementsystem

fake设你需要design一个configurationmanagementsystem, 需要考虑以 under requirements:

system需要一个全局唯一 configurationmanagement器
需要support不同class型 configuration (datalibraryconfiguration, applicationconfiguration, logconfigurationetc.)
configurationobject creation过程比较 complex , 需要 many 个步骤
可能需要基于现 has configurationcreation new configuration

in 这个systemin, 你可以application以 under creation型模式:

singleton pattern: 用于configurationmanagement器, 确保全局只 has 一个instance
factory pattern: 用于creation不同class型 configurationobject
Builder Pattern: 用于构建 complex configurationobject
Prototype Pattern: 用于基于现 has configurationcreation new configuration

互动练习

练习1: singleton patternimplementation

请implementation一个threadsecurity singleton pattern, 并解释其implementation原理.

练习2: factory patternapplication

请design一个graph形工厂, able tocreation不同class型 graph形 (such as圆形, 矩形, 三角形) , 并usingfactory patternimplementation.

练习3: Builder Patternapplication

请usingBuilder Patterndesign一个计算机object 构建过程, 计算机package含CPU, memory, 硬盘etc.component.