设计模式（1）

单例模式

1. 什么是单例模式

保证一个类只有一个实例，并且提供一个访问该全局访问点

2. 单例模式优缺点

优点：

1. 在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这

样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例

2. 单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩

性。

3. 提供了对唯一实例的受控访问。

4. 由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例

模式无疑可以提高系统的性能。

5. 允许可变数目的实例。

6. 避免对共享资源的多重占用。

缺点：

1. 不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据

的错误，不能保存彼此的状态。

2. 由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。

3. 单例类的职责过重，在一定程度上违背了“单一职责原则

3. 单例模式创建注意事项

1. 使用时不能用反射模式创建单例，否则会实例化一个新的对象

2. 使用懒单例模式时注意线程安全问题

3. 饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承

（如登记式模式）

4. 单例模式的创建方式

• 懒汉式

• 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能，线程不安全

package com.lijie;
//懒汉式
public class Demo2 {
//类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
private static Demo2 demo2;
private Demo2() {
System.out.println("私有Demo2构造参数初始化");
}
public synchronized static Demo2 getInstance() {
if (demo2 == null) {
demo2 = new Demo2();
}
return demo2;
}
public static void main(String[] args) {
Demo2 s1 = Demo2.getInstance();
Demo2 s2 = Demo2.getInstance();
System.out.println(s1 == s2);
}
}

• 饿汉式

• 类初始化时,会立即加载该对象，线程天生安全,调用效率高。

package com.lijie;
//饿汉式
public class Demo1 {
// 类初始化时,会立即加载该对象，线程安全,调用效率高
private static Demo1 demo1 = new Demo1();
private Demo1() {
System.out.println("私有Demo1构造参数初始化");
}
public static Demo1 getInstance() {
return demo1;
}
public static void main(String[] args) {
Demo1 s1 = Demo1.getInstance();
Demo1 s2 = Demo1.getInstance();
System.out.println(s1 == s2);
}
}

• 懒汉式（双重锁检验）

• 线程安全的，保证并发情况下 线程是安全的 需要加上volatile

package com.lijie;
//双重检测锁方式
public class Demo5 {
private static volatile Demo5 demo5;
private Demo5() {
System.out.println("私有Demo4构造参数初始化");
}
public static  Demo5 getInstance() {
if (demo5 == null) {
synchronized (Demo5.class) {
if (demo5 == null) {
demo5 = new Demo5();
}
}
}
return demo5;
}
public static void main(String[] args) {
Demo5 s1 = Demo5.getInstance();
Demo5 s2 = Demo5.getInstance();
System.out.println(s1 == s2);
}
}

• 静态内部类

• 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。

package com.lijie;
// 静态内部类方式
public class Demo3 {
private Demo3() {
System.out.println("私有Demo3构造参数初始化");
}
public static class SingletonClassInstance {
private static final Demo3 DEMO_3 = new Demo3();
}
// 方法没有同步
public static Demo3 getInstance() {
return SingletonClassInstance.DEMO_3;
}
public static void main(String[] args) {
Demo3 s1 = Demo3.getInstance();
Demo3 s2 = Demo3.getInstance();
System.out.println(s1 == s2);
}
}

• 枚举

package com.lijie;
//使用枚举实现单例模式 优点:实现简单、枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反
public class Demo4 {
public static Demo4 getInstance() {
return Demo.INSTANCE.getInstance();
}
public static void main(String[] args) {
Demo4 s1 = Demo4.getInstance();
Demo4 s2 = Demo4.getInstance();
System.out.println(s1 == s2);
}
//定义枚举
private static enum Demo {
INSTANCE;
// 枚举元素为单例
private Demo4 demo4;
private Demo() {
System.out.println("枚举Demo私有构造参数");
demo4 = new Demo4();
}
public Demo4 getInstance() {
return demo4;
}
}
}

5. 总结

如果不需要延迟加载单例，可以使用枚举或者饿汉式，相对来说枚举性好于饿汉式。 如果需要延

迟加载，可以使用静态内部类或者懒汉式，相对来说静态内部类好于懒韩式。 最好使用饿汉式

工厂模式

1. 什么是工厂模式

它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻

辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式

分为简单工厂、工厂方法、抽象工厂模式

2. 工厂模式的优点

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。

利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。

将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

3. 工程模式创建方法

• 简单工厂

• 创建工厂

package com.lijie;
public interface Car {
public void run();
}

• 创建工厂的产品（宝马）

package com.lijie;
public class Bmw implements Car {
public void run() {
System.out.println("我是宝马汽车...");
}
}

• 创建工另外一种产品（奥迪）

package com.lijie;
public class AoDi implements Car {
public void run() {
System.out.println("我是奥迪汽车..");
}
}

• 创建核心工厂类，由他决定具体调用哪产品

package com.lijie;
public class CarFactory {
public static Car createCar(String name) {
if ("".equals(name)) {
return null;
}
if(name.equals("奥迪")){
return new AoDi();
}
if(name.equals("宝马")){
return new Bmw();
}
return null;
}
}

• 演示创建工厂的具体实例

package com.lijie;
public class Client01 {
public static void main(String[] args) {
Car aodi =CarFactory.createCar("奥迪");
Car bmw =CarFactory.createCar("宝马");
aodi.run();
bmw.run();
}
}

• 单工厂的优点/缺点

优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了

各自的职责和权力，有利于整个软件体系结构的优化。

缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

• 工厂方法

• 创建工厂

package com.lijie;
public interface Car {
public void run();
}

• 创建工厂方法调用接口（所有的产品需要new出来必须继承他来实现方法）

package com.lijie;
public interface CarFactory {
Car createCar();
}

• 创建工厂的产品（奥迪）

package com.lijie;
public class AoDi implements Car {
public void run() {
System.out.println("我是奥迪汽车..");
}
}

• 创建工厂另外一种产品（宝马）

package com.lijie;
public class Bmw implements Car {
public void run() {
System.out.println("我是宝马汽车...");
}
}

• 创建工厂方法调用接口的实例（奥迪）

package com.lijie;
public class AoDiFactory implements CarFactory {
public Car createCar() {
return new AoDi();
}
}

• 创建工厂方法调用接口的实例（宝马）

package com.lijie;
public class BmwFactory implements CarFactory {
public Car createCar() {
return new Bmw();
}
}

• 演示创建工厂的具体实例

package com.lijie;
public class Client {
public static void main(String[] args) {
Car aodi = new AoDiFactory().createCar();
Car jili = new BmwFactory().createCar();
aodi.run();
jili.run();
}
}

• 工厂方法优缺点

工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负

责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅

负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节

• 抽象工厂

• 创建第一个子工厂，及实现类

package com.lijie;
//汽车
public interface Car {
void run();
}
class CarA implements Car{
public void run() {
System.out.println("宝马");
}
}
class CarB implements Car{
public void run() {
System.out.println("摩拜");
}
}

• 创建第二个子工厂，及实现类

package com.lijie;
//发动机
public interface Engine {
void run();
}
class EngineA implements Engine {
public void run() {
System.out.println("转的快!");
}
}
class EngineB implements Engine {
public void run() {
System.out.println("转的慢!");
}
}

• 创建一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）

package com.lijie;
public interface TotalFactory {
// 创建汽车
Car createChair();
// 创建发动机
Engine createEngine();
}
//总工厂实现类，由他决定调用哪个工厂的那个实例
class TotalFactoryReally implements TotalFactory {
public Engine createEngine() {
return new EngineA();
}
public Car createChair() {
return new CarA();
}
}

• 运行测试

package com.lijie;
public class Test {
public static void main(String[] args) {
TotalFactory totalFactory2 = new TotalFactoryReally();
Car car = totalFactory2.createChair();
car.run();
TotalFactory totalFactory = new TotalFactoryReally();
Engine engine = totalFactory.createEngine();
engine.run();
}
}

• 抽象工厂的优缺点

抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。

4. 总结

在实际开发经验中，我们可以使用工厂模式和map集合判断条件，然后具体交给那个工厂进行加工

责任链模式

1. 什么是责任链模式？

一个事件需要经过多个对象处理是一个挺常见的场景，譬如采购审批流程，请假流程，软件开发中的异常处理流程，web请求处理流程等各种各样的流程，可以考虑使用责任链模式来实现。

2. 责任链模式的好处

可以减少if-else代码的书写量，防止业务代码过于复杂，实现高内聚，低耦合

3. 责任链模式创建

• 接口（实现了四个方法）

public interface AccessStatusServiceChain {

    /**
     * 获取接入状态流
     *
     * @param paramList 接入状态入参集合
     * @return
     */
    void getAccessStatusStream(List<AccessStatusStreamParam> paramList);
}

• 实现（其中之一）@Order(1)表示这是责任链里面的第一道关卡

@Order(1)
@Service
@Slf4j
public class AccessStatusByDataTableHandler implements AccessStatusServiceChain {

    @Autowired
    private AccessStatusStreamDAO accessStatusStreamDAO;

    /**
     * 获取接入状态流
     *
     * @param param@return
     */
    @Override
    public void getAccessStatusStream(AccessStatusStreamParam param) {
        getAccessStatusStream(Lists.newArrayList(param));
    }

    /**
     * 获取接入状态流
     *
     * @param paramList 接入状态入参
     * @return
     */
    @Override
    public void getAccessStatusStream(List<AccessStatusStreamParam> paramList) {
        // 只获取未取到接入状态的数据
        paramList = paramList.stream().filter(e -> e.getAccessStatusStreamEnum() == null).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(paramList)) {
            return;
        }
.............................................................

• 图示

4. 总结

使用责任链模式，我们需要明白和理解，数据流转的整个生命周期，这样才方便我们设计整个链路的状态和返回！