设计模式

创建型模式

单例

常见的单例：

RunTime
Spring中的ApplicationContext

public class SingleTon {
    private static volatile SingleTon single;

    private SingleTon() {

    }

    public static SingleTon getInstance() {
        if(single == null) {
            synchronized(SingleTon.class) {
                if(single == null) single = new SingleTon();
            }
        }

        return single;
    }
}

简单工厂

主要角色：

抽象产品
具体产品
简单工厂

所有产品都交由简单工厂创建，若需新增产品，则需要改动简单工厂的代码

// 抽象产品
public interface Phone {
}

// 具体产品
public class XiaoMi implements Phone{
}

// 具体产品
public class HuaWei implements Phone{
}

// 简单工厂
public class PhoneFactory {
    public static Phone createPhone(String type) {
        if(type == null) return null;
        if(type.equals("XiaoMi")) return new XiaoMi();
        else if(type.equals("HuaWei")) return new HuaWei();
        return null;
    }
}

工厂方法

主要角色：

抽象产品
具体产品
抽象工厂
具体工厂

对于简单工厂，新增产品需要改动代码。将工厂抽象之后，新增产品，只需新增对应产品的具体工厂即可，每个具体工厂只负责产生相应的具体产品，对比简单工厂，新增产品后，只需新增，而无需修改代码，使得新增产品非常灵活，符合开闭原则。

// 抽象产品
public interface Shape {
}

// 具体产品
public class Circle implements Shape{
}

// 具体产品
public class Square implements Shape{
}

// 抽象工厂
public interface ShapeFactory {
    Shape createShape();
}

// 具体工厂
public class CircleFactory implements ShapeFactory{
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 具体工厂
public class SquareFactory implements ShapeFactory{
    @Override
    public Shape createShape() {
        return new Square();
    }
}

抽象工厂

主要角色：

多个抽象产品
每个抽象产品具有多个具体产品
抽象工厂，声明多个创建抽象产品的方法
具体工厂，具体工厂组合多个具体产品

对于工厂方法，每个具体工厂只能创建一个具体产品，在抽象工厂中，声明多个创建抽象产品的方法，可以对抽象产品的具体实现进行多样的组合，非常灵活。

// 抽象产品
public interface Mouse {
}

// 具体产品
public class LogitechMouse implements Mouse{
}

// 具体产品
public class XiaoMiMouse implements Mouse{
}

// 抽象产品
public interface Watch {
}

// 具体产品
public class AppleWatch implements Watch {
}

// 具体产品
public class HuaWeiWatch implements Watch {
}

// 抽象工厂
// 此工厂能够组合不同鼠标以及不同手表
public interface AbstractFactory {
    Watch createWatch();
    
    Mouse createMouse();
}

// 具体工厂
// 此具体工厂组合小米鼠标以及苹果手表
public class XiaoMiAppleFactory implements AbstractFactory{
    @Override
    public Watch createWatch() {
        return new AppleWatch();
    }

    @Override
    public Mouse createMouse() {
        return new XiaoMiMouse();
    }
}

// 具体工厂
// 此工厂组合华为手表以及罗技鼠标
public class HuaWeiLogitechFactory implements AbstractFactory{
    @Override
    public Watch createWatch() {
        return new HuaWeiWatch();
    }

    @Override
    public Mouse createMouse() {
        return new LogitechMouse();
    }
}

建造者模式

通过链式调用（fluent api）灵活地构造对象

lombok的@Builder注解，使用了构造者模式，为实体内部生成一个Builder

public class User {
    private String name;

    private int age;

    private String email;

    private String province;

    private String city;

    private String address;

    private LocalDateTime bornAt;

    public User(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.email = builder.email;
        this.province = builder.province;
        this.city = builder.city;
        this.address = builder.address;
        this.bornAt = builder.bornAt;
    }

    public static Builder builder() {
        return new Builder();
    }

    @Override
    public String toString() {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", province='" + province + '\'' +
                ", city='" + city + '\'' +
                ", address='" + address + '\'' +
                ", bornAt=" + bornAt.format(dateTimeFormatter) +
                '}';
    }

    public static class Builder {
        private String name;

        private int age;

        private String email;

        private String province;

        private String city;

        private String address;

        private LocalDateTime bornAt;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public Builder province(String province) {
            this.province = province;
            return this;
        }

        public Builder city(String city) {
            this.city = city;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public Builder bornAt(LocalDateTime bornAt) {
            this.bornAt = bornAt;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }

    public static void main(String[] args) {
        User myself = new Builder()
                .name("jasper")
                .age(23)
                .province("广东")
                .city("湛江")
                .address("you guess")
                .email("iamkevinkd@gmail.com")
                .bornAt(LocalDateTime.now().minusYears(23))
                .build();

        System.out.println(myself);
    }
}

结构型模式

适配器模式

主要角色：

目标接口：target
适配器：adapter
被适配对象：adaptor

适配器实现target的接口，并且持有一个adaptor实例。这样，客户端就可以继续使用target，而不需要修改adaptor，adapter起到一个转接的作用。

应用场景：

当使用一个已存在的类，但是它的接口与现有接口不兼容，可以使用适配器进行适配
或者需要新增一个类，并且类的接口与现有接口不一致，则可以使用适配器适配

// target接口
public interface Target {
    void request();
}

// 被适配对象 adaptor
public class Adaptor {
    void specifyRequest() {
        System.out.println("特殊的请求。。。");
    }
}

// 适配器 adapter
public class Adapter implements Target{

    private final Adaptor adaptor;

    public Adapter(Adaptor adaptor) {
        this.adaptor = adaptor;
    }

    @Override
    public void request() {
        adaptor.specifyRequest();
    }
}

行为型模式

策略模式

主要角色：

Context，持有抽象策略
抽象策略
多个具体策略

根据不同的行为，选择相应的具体策略，减少if else。如果需要新的具体策略，只需新增，符合开闭原则。

// 抽象策略
public interface Algorithm {
    void calculate();
}

// 具体策略
public class AlgorithmOne implements Algorithm {
    @Override
    public void calculate() {
        System.out.println("算法一，执行计算中。。。。");
    }
}

// 具体策略
public class AlgorithmTwo implements Algorithm {
    @Override
    public void calculate() {
        System.out.println("算法二，执行计算中。。。。");
    }
}

// Context
public class Context {
    private final Algorithm strategy;

    public Context(Algorithm algo) {
        this.strategy = algo;
    }

    public void calculate() {
        strategy.calculate();
    }
}

模板方法模式

主要角色：

模板类，定义基本方法，定义templateMethod（定义如何调用基本方法）
具体类，实现具体方法

应用场景：

模板方法将算法的通用逻辑封装在templateMethod中，而将可变的逻辑有子类来完成，这样做可以很好的提高代码的复用性。

整体来说，当算法的整体步骤很固定，而细节实现不同时，通常考虑使用模板方法。

// 模板类
public abstract class Cooking {

    public final void cook() {
        step1();

        step2();

        step3();
    }

    void step1(){}

    void step2(){}

    void step3(){}
}

// 具体类
public class EggCooking extends Cooking {
    @Override
    void step1() {
        System.out.println("开火");
    }

    @Override
    void step2() {
        System.out.println("放油");
    }

    @Override
    void step3() {
        System.out.println("出锅");
    }
	
    // 测试
    public static void main(String[] args) {
        EggCooking eggCooking = new EggCooking();
        eggCooking.cook();
    }
    // 结果：
    // 开火
    // 放油
    // 出锅
}