设计模式-创建型

设计模式-创建型

目的：实例化过程的解耦

写在前面

​ 发现对于落地这件事情还是要静下心一个一个目标完成，设计模式一直搁浅了好久也没个系统整理，作为网上标配开篇，最近还是补上这个作业吧

1. 为什么用设计模式

   • 设计模式是前人总结下来的经验，对于扩展性和可维护性有很大帮助
   • 也是为了使设计变得简单，容易阅读

2. 设计模式原则（SOLID）

   • 单一职责原则（Single Responsibility Principle）：可以理解为最好一个类只负责一项职责
   • 开闭原则（Open Close Priciple）：尽量对扩展开放，对修改关闭
   • 里氏替换原则（Liskov Substitution Principle）：引用父类处可以用任意子类代替
   • 接口隔离原则（Interface Segregation priciple）：建立单一接口，最好是一个类依赖一个接口，而不是多个类依赖一个接口
   • 依赖倒置原则 (Dependency InVersion Principle) ：调用方和实现方都应该依赖抽象，彼此相互独立，实现类应该依赖抽象，而不能反过来
   • 迪米特法则（Law of Demeter）：一个对象保持对其他对象最少的了解
   • 合成复用原则（Composite/Aggregate Reuse Principle）：尽量使用组合/聚合，不要使用继承，继承基类会暴露实现破坏封装；基类改变，子类实现也需要改变；实现是静态的，不够灵活
3. 如何使用设计模式

   以上原则只是设计参考的一个约束，并不绝对，对于“最好的设计模式就是不用设计模式”，我们还没有达到这个境界，只有合适的场景用更合适的方法。

我们原先想获取一个新对象

Object o = new Object();

之后在创建新对象的场景可以参考考虑一下使用以下的思路

1. 单例模式

   说明：一个类只能有一个实例，提供全局唯一的访问点

   应用场景：控制资源场景，例如数据库连接池，线程池等

   • 匿名内部类

     class SingletonInnerClass {
       // 私有构造器保证不能new 创建新实例
         private SingletonInnerClass() {
         }
     
         public static SingletonInnerClass getInstance() {
             return SingletonInner.instance;
         }
     
         private static class SingletonInner {
             private static final SingletonInnerClass instance = new SingletonInnerClass();
         }
     }

   • 枚举类型

     enum SingletonEnum {
         INSTACN；
     }

   • 双重检查锁

     class SingletonDCL {
         private volatile static SingletonDCL instance;
     
         private SingletonDCL() {
     
         }
     
         public static SingletonDCL getInstance() {
             if (instance == null) {
                 synchronized (SingletonDCL.class) {
                     if (instance == null) {
                         instance = new SingletonDCL();
                     }
                 }
             }
             return instance;
         }
     }

   • Spring单例注册表

     /** Cache of singleton objects: bean name to bean instance. */
     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
     /** Cache of singleton factories: bean name to ObjectFactory. */
     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
     /** Cache of early singleton objects: bean name to bean instance. 
     提前曝光的单例Cache
     */
     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
     
     @Nullable
         protected Object getSingleton(String beanName, boolean allowEarlyReference) {
         // 一级缓存 获取单例的bean
             Object singletonObject = this.singletonObjects.get(beanName);
         // 判断bean是否在创建中（并未创建完）
             if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
                 synchronized (this.singletonObjects) {
             // 二级缓存 获取提前曝光的单例
                     singletonObject = this.earlySingletonObjects.get(beanName);
             // 判断是否允许提前引用
                     if (singletonObject == null && allowEarlyReference) {
               // 三级缓存 获取单例bean
                         ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                         if (singletonFactory != null) {
                 // 放入二级缓存 并删除三级缓存中的bean
                             singletonObject = singletonFactory.getObject();
                             this.earlySingletonObjects.put(beanName, singletonObject);
                             this.singletonFactories.remove(beanName);
                         }
                     }
                 }
             }
             return singletonObject;
         }

     上面也直接说了spring 对于循环依赖的解决方案

2. 简单工厂

   说明：根据传入的变量决定输出什么样的实例

   interface Product {
       void use();
   }
   // 产品实现
   class ProductA implements Product {
       @Override
       public void use() {
           System.out.println("product A");
       }
   }
   
   class ProductB implements Product {
   
       @Override
       public void use() {
           System.out.println("product B");
       }
   }
   // 工厂
   class Factory {
       public Product produce(String type) {
           if ("A".equals(type)) {
               return new ProductA();
           } else if ("B".equals(type)) {
               return new ProductB();
           } else {
               return null;
           }
       }
   }

3. 工厂方法

   说明：创建对象行为进行抽象，在子类里实现逻辑

   适用场景：

   • 如下是spring中的工厂方法接口

     public interface FactoryBean<T> {
         @Nullable
         T getObject() throws Exception;
     
         @Nullable
         Class<?> getObjectType();
     
         default boolean isSingleton() {
             return true;
         }
     }

   • jdk中Collection类

     
     public interface Collection<E> extends Iterable<E> {
       ...
         // 这是一个工厂方法
          Iterator<E> iterator();
       ...
     }
     //   实现在子类中
     public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
        public Iterator<E> iterator() {
             return new Itr();
         }
     }

4. 抽象工厂

   说明：创建相关或依赖对象的家族，而无需明确指定具体类

   适用场景：对象的创建和使用隔离开来

   • Collection类中抽象了多个工厂方法，本身又是一个抽象的创建类

5. 建造者模式

   说明：封装一个对象复杂的构建过程

   适用场景：crud时候，优化繁琐的实体构建过程

   • lombok @Builder

     Builder builder = Builder
                        .age(10)
                         .name("builder")
                         .build();

6. 原型模式

   说明：实例对象的复制获取新实例

   //浅拷贝，仅对象内的引用也被复制时为深拷贝
   @Data
   @AllArgsConstructor
   class Prototype implements Cloneable {
       private String name;
       private Map<String, String> map;
   
       @Override
       public Prototype clone() throws CloneNotSupportedException {
           Prototype prototype = (Prototype) super.clone();
           prototype.map = map;
           prototype.name = name;
           return prototype;
       }
   }

7. 总结

   以上是对创建型的设计模式的一些demo及一些源码的引用，目的是尽快的理解和快速的用起来，后续会补全UML图

   其中最常用的是单例模式/工厂方法/抽象工厂/建造者模式，设计模式的主要目的也是为了代码的可维护性和可扩展性，把会变动的地方和不变的地方隔离开来

如有不正确的地方欢迎大佬指正

本文由博客群发一文多发等运营工具平台 OpenWrite 发布