设计模式

设计模式分为创建型、结构性和行为型。

什么是责任链模式？

责任链模式，是一种行为设计模式，它使得多个对象都有机会处理请求，从而避免请求发送者和接收者之间的耦合关系。

请求会沿着一条链传递，直到有一个对象处理它为止。

基本概念

主要角色：

• Handler（抽象处理者）：定义一个处理请求的接口或抽象类，其中通常包含一个指向链中下一个处理者的引用
• ConcreteHandler（具体处理着）：实现抽象处理者的处理方法。能处理就处理，否则请求转发给链中的下一个处理者。
• Client（客户端）：创建处理链，并向链的第一个处理者对象提交请求。

工作流程： 客户端把请求发送给链上的第一个处理者对象。处理者接收到请求后，自己能处理就处理，否则发给下一个处理者。

应用场景

• 多个对象可以处理同一个请求，但具体由哪个对象处理在运行时动态决定。
• 在不明确指定接收者的情况下，向多个对象中的一个提交请求。
• 需要动态组织和管理处理者时。

什么是工厂模式？

主要用于创建对象，而不暴露创建对象的逻辑给客户端。属于创建型设计模式。 父类提供了一个创建对象的方法，允许子类决定实例化对象的类型。

下面是一个简单工厂模式：引入创建者概念，把实例化的代码从应用程序的业务逻辑中分离出来。

class SimpleFactory {
    public static Transport createTransport(String type) {
        if ("truck".equalsIgnoreCase(type)) {
            return new Truck();
        } else if ("ship".equalsIgnoreCase(type)) {
            return new Ship();
        }
        return null;
    }

    public static void main(String[] args) {
        Transport truck = SimpleFactory.createTransport("truck");
        truck.deliver();

        Transport ship = SimpleFactory.createTransport("ship");
        ship.deliver();
    }
}

工厂方法模式：定义一个创建对象的接口，但是由子类决定要实例化的是哪一个。

什么是单例模式？

单例模式，是一种创建型设计模式。确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

主要用于控制对某些共享资源的访问，比如配置管理器、连接池、线程池、日志对象等。

实现单例模式的关键点

1. 私有构造方法：确保外部代码不能通过构造器新建类的实例。
2. 私有静态实例变量：持有类的唯一实例。
3. 公有静态方法：提供全局访问点以获取实例，如果实例不存在，则在内部创建。

常见的单例模式实现

饿汉式

饿汉式单例模式，在类加载的时候就创建类的实例。简单，但不支持延时加载实例。

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式

懒汉式只有在第一次调用getInstance的时候才会创建实例对象，同时要考虑线程安全，因此一般有synchronized。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

上面的锁粒度在方法上，并且可能会有指令重排。并且锁住的是类。

更好的方法：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance != null) return instance;
        else {
            synchronized (Singleton.class) {
                if (instance == null) {
                    this.instance = new Singleton();
                    return instance;
                }
            }
        }
    }
}

上面使用的是双重检查锁+volatile。安全。

还有一种是利用静态内部类实现的。

public class Singleton {
    private Singleton() {
    }

    private static class SingletonHandler() {
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHandler.instance;
    }
}

这个也是延时加载的。第一次加载Singleton类的时候不会初始化Holder。只有第一次调用getInstance的时候才会。并且是线程安全的，因为类加载器是加锁的。

策略模式

策略模式是一种行为型设计模式，它定义了一系列算法，每个算法封装起来，使得可以相互替换。