设计模式关键点讲解及其常用情景（创建型）

￡神魔★判官ぃ 2022-05-31 06:48 121阅读 0赞

**1.工厂模式(Factory)**

简单工厂模式: 工厂的一个函数内创建产品的实例,根据客户端传入的参数或者加载配置文件等形式来确定创建的到底是哪个产品的实例

public Fruit createFruit(int fruitType)

工厂方法模式: 有工厂接口，每一个工厂的实现各自负责创建一种产品实例

FruitFactory factory = new AppleFactory();
    Fruit fruit = factory.createFruit();

抽象工厂模式: 有工厂接口,每一个工厂的实现均负责一组产品的创建

ComputerFactory interFactory = new InterFactory();
    CPU interCPU = interFactory.createCPU();
    Memory interMemory = interFactory.createMemory();
    
    ComputerFactory amdFactory = new InterFactory();
    CPU amdCPU = amdFactory.createCPU();
    Memory amdMemory = amdFactory.createMemory();

工厂模式负责创建对象，不同形式有各自的好处及坏处，简单工厂模式增加产品时需要修改工厂类代码，工厂方法模式和抽象工厂模式则会增加很多的类和接口，具体选择需要看实际的业务场景。

**2.单例模式(SingleTon)**

单例模式是希望应用内只有一个指定类对象，加载的形式有懒汉式和饿汉式，也可使用枚举，推荐使用枚举。饿汉式是指在应用启动时就实例化，我们能控制对象的生成时机，这种生成形式相对可靠。但是如果单例对象的实例化需要很多资源，而我们希望在没用到这个单例时不实例化，节省资源，那么就需要使用懒汉式的生成形式。这种形式需要考虑实例化时的线程安全问题，也就是保证同一时间只有一个线程在执行生成对象的过程。常见的实例化形式有两种：双重检查形式，嵌套类持有实例形式。

**双重检查形式**：

![这里写图片描述][SouthEast]

**嵌套类持有实例形式**：

![这里写图片描述][SouthEast 1]

**3.建造者模式(Builder)**

建造者模式主要用于创建复杂对象，一般类名称都叫”**\*Builder**“。比如一个对象有10个属性，但是不确定实际使用时会用到那些属性，因此定义构造函数不可行。那么常见的就是用到一个属性就set一次，如果用到了10个，那么就set10次。也就是说至少需要11行代码。如果使用建造者模式，可能两三行代码就够了。另一方面，如果一个对象在使用前需要验证一番，比如属性a一定要在属性b不存在而c存在时才能被赋值，如果使用set这种形式，不好实现，而使用建造者模式，很简单。

我贴一个很常见的建造者模式的使用范例，Mybatis的XML文件里参数定义。

age = #{
       age,jdbcType=INTEGER}

在”\#\{\}”内部可以定义多个元素，Mybatis在生成参数对象前需要校验其正确性：

public class ParameterMapping {
        ......
        public static class Builder {
            private ParameterMapping parameterMapping = new ParameterMapping();
    
            public Builder mode(ParameterMode mode) {
              parameterMapping.mode = mode;
              return this;
            }
    
            public Builder javaType(Class<?> javaType) {
              parameterMapping.javaType = javaType;
              return this;
            }
    
            public Builder jdbcType(JdbcType jdbcType) {
              parameterMapping.jdbcType = jdbcType;
              return this;
            }
    
            public Builder numericScale(Integer numericScale) {
              parameterMapping.numericScale = numericScale;
              return this;
            }
    
            ......
    
            public ParameterMapping build() {
              resolveTypeHandler();
              validate();
              return parameterMapping;
            }
    
            private void validate() {
              if (ResultSet.class.equals(parameterMapping.javaType)) {
                if (parameterMapping.resultMapId == null) { 
                  throw new IllegalStateException("Missing resultmap in property '"  
                      + parameterMapping.property + "'. " 
                      + "Parameters of type java.sql.ResultSet require a resultmap.");
                }            
              } else {
                if (parameterMapping.typeHandler == null) { 
                  throw new IllegalStateException("Type handler was null on parameter mapping for property '"
                    + parameterMapping.property + "'. It was either not specified and/or could not be found for the javaType ("
                    + parameterMapping.javaType.getName() + ") : jdbcType (" + parameterMapping.jdbcType + ") combination.");
                }
              }
            }
    
            private void resolveTypeHandler() {
              if (parameterMapping.typeHandler == null && parameterMapping.javaType != null) {
                Configuration configuration = parameterMapping.configuration;
                TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
                parameterMapping.typeHandler = typeHandlerRegistry.getTypeHandler(parameterMapping.javaType, parameterMapping.jdbcType);
              }
            }
    
        }
    }

建造者模式在给一个属性赋值时，会返回当前对象，这样就能够多次赋值：

builder.jdbcType(...).javaType(...)...

因此一行代码能赋值多个属性；其次，在最终生成对象的build()方法里可以添加自己的逻辑，这就是建造者模式的精髓所在。

**4.原型模式(Prototype)**

原型模式就是以一个对象为模型生成其他对象，常用在需要大量对象且初始化对象步骤繁杂的场景。从一个对象生成另一个对象，常见有两种实现形式：浅拷贝和深拷贝。

**浅拷贝**：通过实现Cloneable接口，重写Object的clone()方法，返回克隆对象。

public class *** implements Cloneable{ 
         @Override
         protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

Object的clone()属于浅拷贝(实现Cloneable接口)，实质是从内存中以二进制数据的拷贝。为新对象分配一块内存，将原始对象的数据复制到新的内存块中，因此对象构造函数没有执行。通过这种形式复制对象，因此也复制了原始对象对其他对象的引用。原始对象的基本数据类型引用向运行时常量池的各处，克隆后的对象也引用相同的地址，复杂类型属性的引用地址同样被拷贝过去。因此原始对象和克隆对象的属性均引用自内存中的相同地方，也就是他们的属性值均相同。通过内存中数据拷贝的形式生成对象比new的形式效率高得多。

**深拷贝**：实现Serializable接口，以IO流的形式拷贝对象数据；或者通过gson的形式拷贝

public class *** implements Serializable { 
    
        public CloneEntity deepCloneByStream() throws IOException, ClassNotFoundException {
            ByteArrayOutputStream bao = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bao);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (CloneEntity)ois.readObject();
        }
    }

将对象写入IO流中，此时可通过流将对象信息持久化，或者传递到其他处，因此流中势必需要包含对象重构所需的所有信息。通过重新读取流中的数据，来重构一个新的对象，同时也会重构这个对象的所有属性。基本类型属性指向运行时常量池，复杂类型属性重新解析生成新的。

相比于浅拷贝，深拷贝得到的对象复杂类型的属性与原始对象不共享，在从流中读取数据生成对象时，已经为所有复杂类型属性都生成了副本。

通过gson形式拷贝对象也能实现深拷贝的效果，而且更简单。不过有一个缺点就是gson的生成和解析效率形式依赖于反射，反射的效率不高。

![这里写图片描述][SouthEast 2]

[SouthEast]: /images/20220531/25d0ecbc773844db869c3242d0e41462.png
[SouthEast 1]: /images/20220531/487a7bc71a144fa09530186793319c12.png
[SouthEast 2]: /images/20220531/ea0b20137c9e48cba20ed192ab2bdf7f.png