软件设计模式的学习（以Java为例）

---

一、软件设计模式是什么？

软件设计模式（Software Design Pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。

它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。

其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。

---

二、单例模式

1. 什么是单例模式？

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

2. 单例模式的优缺点

优点：

• 单例模式可以保证内存里只有一个实例，减少了内存的开销。
• 可以避免对资源的多重占用。
• 单例模式设置全局访问点，可以优化和共享资源的访问。

缺点：

• 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

3. 单例模式的实现方式

常见的实现方式有：懒汉模式、饥汉模式、双重校验锁、静态内部类、枚举等。

1. 懒汉模式

public class Singleton {
    private static Singleton instance = null;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        //如果还没有被实例化过，就实例化一个，然后返回
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

关键字synchronized用于确保getInstance方法线程安全，但是这种方式弊端特别大，因为所有线程到达该方法以后需要进行排队等候，所以对性能的损耗非常大，该处理解决了线程安全安全问题，并没有解决效率问题。

懒汉模式将实例化的时机放到了需要使用的时候（饿汉是类加载了就有实例），也就是“延迟加载”，相比饿汉，能避免在加载的时候实例化有可能用不到的实例，但是问题也很明显，我们要花精力去解决线程安全的问题。

2. 饥汉模式

public class Singleton {
    //类加载的时候instance就已经指向了一个实例
    private static Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return instance;
    }
}

饥汉模式相比懒汉模式，在类加载的时候就已经存在一个实例。饥汉的缺点：可能会产生很多无用的实例。

3. 双重校验锁

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

双重检验锁也是一种延迟加载，并且较好的解决了在确保线程安全的时候效率低下的问题。对比一下懒汉模式，将整个getInstance方法锁住，那么每次调用这个方法都要获得锁，释放锁，然后等待…而双重校验锁只锁住了部分的代码。进入方法后，如果检查为空才进入同步代码块，这样很明显效率高了很多。

4. 静态内部类

public class Singleton {
    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

静态内部类既能享受类加载确保线程安全带来的便利，又能延迟加载。

Java静态内部类的特性是：加载的时候不会加载内部静态类，使用的时候才会进行加载。而使用到的时候类加载又是线程安全的，这就完美的达到了我们的预期效果。

---

三、工厂模式

1. 什么是工厂模式？

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。所有我们在实际开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。

2. 简单工厂模式

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。
在简单工厂模式中创建实例的方法通常为静态（static）方法。
因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

1. 实现方法

public class Client {
    //抽象产品
    public interface Product {
        void show();
    }
    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }
    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
        static final int PRODUCT_C = 2;
    }
    static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

2. 优缺点

优点：

• 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
• 客户端无需知道所创建具体产品的类名，只需知道参数即可。
• 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

• 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
• 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
• 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
• 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

但是简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

3. 工厂方法模式

“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

1. 实现方法

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af;
            af = (AbstractFactory) ReadXML.getObject();
            //抽象工厂内容放入到外部配置文件xml/properties等文件中，通过I/O流加载从而创建出抽象工厂
            a = af.newProduct();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
//抽象产品：提供了产品的接口
interface Product {
    public void show();
}
//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}
//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}
//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}
//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

public class ReadXML {
    //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    public static Object getObject() {
        try {
            //创建文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/FactoryMethod/config1.xml"));
            //获取包含类名的文本节点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = "FactoryMethod." + classNode.getNodeValue();
            //System.out.println("新类名："+cName);
            //通过类名生成实例对象并将其返回
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

}

2. 优缺点

优点：

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
• 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
• 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

4.抽象工厂模式

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构，这里便出现了两个概念：同族和同等级。

1. 实现方法

public class FarmTest {
    public static void main(String[] args) {
        try {
            Farm f;
            Animal a;
            Plant p;
            //读取相应的配置信息，用于生产工厂
            f = (Farm) ReadXML.getObject();
            a = f.newAnimal();
            p = f.newPlant();
            a.show();
            p.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
//抽象产品：动物类
interface Animal {
    public void show();
}
//具体产品：马类
class Horse implements Animal {
    public Horse() {
        System.out.println("具体马类的生成");
    }
    public void show() {
        System.out.println("执行马类的相应操作");
    }
}
//具体产品：牛类
class Cattle implements Animal {

    public Cattle() {
        //具体牛类的生成
        System.out.println("具体牛类的生成");
    }
    public void show() {
        System.out.println("执行马类的相应操作");
    }
}
//抽象产品：植物类
interface Plant {
    public void show();
}
//具体产品：水果类
class Fruitage implements Plant {

    public Fruitage() {
        System.out.println("具体水果类生成");
    }
    public void show() {
        System.out.println("执行水果类的相应操作");
    }
}
//具体产品：蔬菜类
class Vegetables implements Plant {
    public Vegetables() {
        System.out.println("具体蔬菜类生成");
    }
    public void show() {
        System.out.println("执行蔬菜类的相应操作");
    }
}
//抽象工厂：农场类
interface Farm {
    public Animal newAnimal();
    public Plant newPlant();
}
//具体工厂：农场类1
class SGfarm implements Farm {
    public Animal newAnimal() {
        System.out.println("新牛出生！");
        return new Cattle();
    }
    public Plant newPlant() {
        System.out.println("蔬菜长成！");
        return new Vegetables();
    }
}
//具体工厂：农场类2
class SRfarm implements Farm {
    public Animal newAnimal() {
        System.out.println("新马出生！");
        return new Horse();
    }
    public Plant newPlant() {
        System.out.println("水果长成！");
        return new Fruitage();
    }
}

public class ReadXML2 {
    public static Object getObject() {
        try {
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/AbstractFactory/config.xml"));
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = "AbstractFactory." + classNode.getNodeValue();
            System.out.println("新类名：" + cName);
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

2. 优缺点

优点：

• 抽象工厂模式是在工厂方法模式的基础之上进行优化而来，所有工厂方法模式的优点都有。

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。

• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。

• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

缺点：

• 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

---

总结

首先是对软件设计模式有了一定的了解，它是解决特定问题的一系列套路，是代码设计经验的总结，具有一定的普遍性。而它的目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。软件设计模式又分为单例模式、工厂模式等，而工厂模式也可以分为简单工厂模式、工厂方法模式、抽象工厂模式。对于不同的应用场景，我们可以选择不同的设计模式。

参考:
https://segmentfault.com/a/1190000040289636.
https://segmentfault.com/a/1190000040297407.
https://segmentfault.com/a/1190000040319351.