设计模式初识创建型模式

Posted 2021-06-14 三笠·阿卡曼

为什么使用创建型模式

• 创建型模式关注点"怎样创建出对象"
• 将创建的与使用分离开（Java中就是不使用传统的new对象的方式）
• 降低系统的耦合度；
• 使用者无需关注对象的创建细节：
  • 各种工厂模式：对象的创建由工厂完成；
  • 建造者模式：对象的创建由一个建造者来完成；
  • 原型模式：对象的创建由原来对象克隆完成；
  • 单例模式：对象时钟在系统中只有一个实例

单例模式

一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象被创建；

双重检测锁模式+volatile

package com.vleus.design.creation.singleton;

/**
 * @author vleus
 * @date 2021年05月30日 21:25
 */
public class Person {

    private String name;

    private String age;

    private Person() {
        System.out.println("创建了Person");
    }

    private volatile static Person instance;

    //基于懒汉式模式的双重检测锁的单例模式
    public static Person guiguBoss() {

        if (instance == null) {
            synchronized (Person.class) {
                if (instance == null) {
                    Person person = new Person();
                    instance = person;
                }
            }
        }
        return instance;
    }

}

这种模式可能有指令重排的问题，加volatile即可

单例模式的场景

• 多线程中的线程池；
• 数据库的连接池；
• 系统环境信息；
• 系统上下文（ServerContext）；
  …
  面试问题：
• 系统环境信息；
• Spring是如何保持组件单例的？
• ServletContext是什么？是单例吗？如何保证？
• ApplicationContext是什么？是单例？怎么保证？
  • ApplcationContext：在Tomcat中，一个应用（部署的一个war包）会有一个应用上下文；
  • ApplicationContext：在Spring中表示整个IOC容器（怎么保证单例的），ioc容器中有很多组件；
• 数据库连接池一般怎么创建出啦的？如何保证单实例？

原型模式（Prototype Pattern）

概念：原型模式是用于创建重复的对象，同时又要能保证性能；

工厂模式

工厂模式（Factory Pattern）提供了一种创建对象的最佳方式，我们不必关系对象的创建细节，只需要根据不同情况获取不同产品即可；
工厂模式可分为静态工厂、工厂方法、抽象工厂三种；

以造车为例

简单工厂

定义一个产品的抽象类AbstractCar

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:07
 * @desc 工厂的产品
 */
public abstract class AbstractCar {

    String engine;

    public abstract void run();
}

整两个产品的实现类，具体是什么品牌的车
MiniCar

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:10
 */
public class MiniCar extends AbstractCar{

    public MiniCar() {
        this.engine = "四缸水平对峙发动机";
    }

    @Override
    public void run() {
        System.out.println(engine + "---->嘟嘟嘟");
    }
}

VanCar

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:09
 */
public class VanCar extends AbstractCar{

    VanCar() {
        this.engine = "单缸柴油机";
    }

    @Override
    public void run() {
        System.out.println(engine + "---> 哒哒哒。。。");
    }
}

简单工厂类，根据传入的类型创建对应的具体的产品

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:11
 * @desc 简单工厂，产品数量少
 */
public class WulinSimpleFactory {

    //工厂的核心方法
    public AbstractCar newCar(String typeName) {
        if ("van".equals(typeName)) {
            return new VanCar();
        } else if ("mini".equals(typeName)) {
            return new MiniCar();
        }
        return null;
    }

}

整一个测试类：

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:06
 */
public class MainTest {

    public static void main(String[] args) {

        WulinSimpleFactory wulinSimpleFactory = new WulinSimpleFactory();

        AbstractCar van = wulinSimpleFactory.newCar("van");
        AbstractCar mini = wulinSimpleFactory.newCar("mini");
        AbstractCar zz = wulinSimpleFactory.newCar("zz");

        System.out.println();
        System.out.println(mini);
        System.out.println(zz);


    }
}

简单工厂的特点：简单工厂就是十分简单，工厂其实就是简单的一个类，根据用户传入的类型去创建相应对象，简单但扩展难；

工厂方法

工厂方法是基于简单工厂的上层抽象，将简单工厂创建对象的方式向上提，做成一个抽象类，那么实现这个抽象类就相当于实现一个专门创造某个产品的工厂，那么扩展起来即是扩展这个抽象类即可，满足设计模式的七大原则

产品不变
抽象产品类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:07
 * @desc 工厂的产品
 */
public abstract class AbstractCar {

    String engine;

    public abstract void run();
}

实现抽象产品类的几种产品

package com.vleus.design.creation.factory.factorymethod;


/**
 * @author vleus
 * @date 2021年05月31日 22:09
 */
public class VanCar extends AbstractCar {

    VanCar() {
        this.engine = "单缸柴油机";
    }

    @Override
    public void run() {
        System.out.println(engine + "---> 哒哒哒。。。");
    }
}

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:24
 */
public class RacingCar extends AbstractCar{

    public RacingCar() {
        this.engine = "v9发动机";
    }

    @Override
    public void run() {
        System.out.println(engine + "嗖一下。。。");
    }
}

工厂的抽象类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:27
 */
public abstract class AbstractCarFactory {

    public abstract AbstractCar newCar();
}

工厂的实现类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:28
 */
public class WulingVanCarFactory extends AbstractCarFactory{

    @Override
    public AbstractCar newCar() {
        return new VanCar();
    }
}

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:29
 */
public class WulingRacingFactory extends AbstractCarFactory {

    @Override
    public AbstractCar newCar() {
        return new RacingCar();
    }
}

测试类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:33
 */
public class MainTest {

    public static void main(String[] args) {

        AbstractCarFactory carFactory = new WulingRacingFactory();
        AbstractCar abstractCar = carFactory.newCar();
        abstractCar.run();

        carFactory = new WulingVanCarFactory();
        AbstractCar vanCar = carFactory.newCar();
        vanCar.run();

    }
}

抽象工厂

建造者模式

抽象建造者类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年05月31日 23:57
 */
public abstract class AbstractBuilder {

    Phone phone;

    abstract AbstractBuilder customCpu(String cpuName);

    abstract AbstractBuilder customMem(String mem);

    abstract AbstractBuilder customDisk(String disk);

    abstract AbstractBuilder customCam(String cam);

    Phone getProduct() {
        return phone;
    }
}

实现一个Builder类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年05月31日 23:58
 */
public class XiaomiBuilder extends AbstractBuilder{

    public XiaomiBuilder() {
        phone = new Phone();
    }

    @Override
    AbstractBuilder customCpu(String cpuName) {
        phone.cpu = cpuName;
        return this;
    }

    @Override
    AbstractBuilder customMem(String mem) {
        phone.mem = mem;
        return this;
    }

    @Override
    AbstractBuilder customDisk(String disk) {
        phone.disk = disk;
        return this;
    }

    @Override
    AbstractBuilder customCam(String cam) {
        phone.cam = cam;
        return this;
    }
}

产品类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年05月31日 23:53
 */
public class Phone {

    protected String cpu;

    protected String mem;

    protected String disk;

    protected String cam;

    public String getCpu() {
        return cpu;
    }

    public String getMem() {
        return mem;
    }

    public String getDisk() {
        return disk;
    }

    public String getCam() {
        return cam;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Phone{");
        sb.append("cpu='").append(cpu).append('\\'');
        sb.append(", mem='").append(mem).append('\\'');
        sb.append(", disk='").append(disk).append('\\'');
        sb.append(", cam='").append(cam).append('\\'');
        sb.append('}');
        return sb.toString();
    }
}

测试类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年06月01日 0:00
 */
public class MainTest {

    public static void main(String[] args) {

        AbstractBuilder builder = new XiaomiBuilder();

        builder.customMem("16G");
        builder.customDisk("1T");
        builder.customCam("2亿");
        builder.customCpu("骁龙888");

        //链式建造者
        builder = builder.customCpu("骁龙888").
                customCam("2亿").
                customDisk("2T").
                customMem("16G");

        Phone product = builder.getProduct();

        System.out.println(product);
    }
}