Spring6 - （07） GoF之工厂模式

Spring6 -（07）GoF之工厂模式

1. 设计模式

设计模式：一种可以被重复利用的解决方案。

GoF（Gang of Four），中文名——四人组。

• 《Design Patterns: Elements of Reusable Object-Oriented Software》（即《设计模式》一书），1995年由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著。这几位作者常被称为"四人组（Gang of Four）"。

• 该书中描述了23种设计模式。我们平常所说的设计模式就是指这23种设计模式。

• 不过除了GoF23种设计模式之外，还有其它的设计模式，比如：JavaEE的设计模式（DAO模式、MVC模式等）。

GoF23种设计模式可分为三大类：

• 创建型（5个）：解决对象创建问题。

  单例模式、单例模式、抽象工厂模式、抽象工厂模式、原型模式

• 结构型（7个）：一些类或对象组合在一起的经典结构。

  代理模式、装饰模式、适配器模式、组合模式、享元模式、外观模式、桥接模式

• 行为型（11个）：解决类或对象之间的交互问题。

  策略模式、模板方法模式、责任链模式、观察者模式、迭代子模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式

  、解释器模式

工厂模式是解决对象创建问题的，所以工厂模式属于创建型设计模式。这里为什么学习工厂模式呢？这是因为Spring框架底层使用了大量的工厂模式。

2. 工厂模式的三种形态

工厂模式通常有三种形态：

• 第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做：静态 工厂方法模式。简单工厂模式是工厂方法模式的一种特殊实现。
• 第二种：工厂方法模式（Factory Method）：是23种设计模式之一。
• 第三种：抽象工厂模式（Abstract Factory）：是23种设计模式之一。

3. 简单工厂模式

简单工厂模式是工厂方法模式的一种特殊实现，又被称为：静态工厂模式

简单工厂模式的角色包括三个：

• 抽象产品角色
• 具体产品角色
• 工厂类角色

简单工厂模式的代码如下：、

抽象产品角色

package com.julissa.factory;

/**
 * 智能产品 （抽象产品角色）
 */
public abstract class SmartProduction {
    /**
     * 每一种智能产品都有发送功能
     */
    public abstract void send();
}

具体产品角色

package com.julissa.factory;

/**
 *
 * 电脑 （具体产品角色）
 */
public class Computer extends SmartProduction{
    @Override
    public void send() {
        System.out.println("电脑端发送信息~~~");
    }
}

package com.julissa.factory;

/**
 *
 * 智能手机 （具体产品角色）
 */
public class SmartPhone extends SmartProduction{
    @Override
    public void send() {
        System.out.println("手机端发送信息~~~");
    }
}

package com.julissa.factory;

/**
 * 手表 （具体产品角色）
 */
public class Watch extends SmartProduction {
    @Override
    public void send() {
        System.out.println("智能手表发送信息~~~");
    }
}

工厂类角色

package com.julissa.factory;

/**
 * 工厂类角色
 */
public class SmartFactory {
    /**
     *
     * 根据不同的智能产品类型生产产品
     * @param smartType
     * @return
     */
    public static SmartProduction getProduct(String smartType){
        if("Computer".equals(smartType)){
            return new Computer();
        }else if("SmartPhone".equals(smartType)){
            return new SmartPhone();
        } else if ("Watch".equals(smartType)) {
            return new Watch();
        }else {
            throw new RuntimeException("不支持该产品的生产！");
        }
    }
}

测试程序（客户端程序）

package com.julissa.factory;

/**
 *
 * 客户端程序
 *
 */
public class Test {
    public static void main(String[] args) {

        //对客户端来说，只负责消费，不关注生产的细节，我只要向工厂索要即可
        //工厂负责生产，生产和消费分离了
        //这就是简单工厂的作用
        SmartProduction computer = SmartFactory.getProduct("Computer");
        computer.send();
        SmartProduction smartPhone = SmartFactory.getProduct("SmartPhone");
        smartPhone.send();
        SmartProduction watch = SmartFactory.getProduct("Watch");
        watch.send();
    }
}

运行测试程序

简单工厂模式的优点：

• 客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。

简单工厂模式的缺点：

• 缺点1：工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。
• 缺点2：不符合OCP开闭原则，在进行系统扩展时，需要修改工厂类。

4. 工厂方法模式

工厂方法模式可以解决简单工厂模式中的OCP问题

怎么解决？一个工厂对应一个一种产品

这样工厂就不是全能类了，不是上帝类了

工厂方法模式中的角色

• 抽象工厂角色
• 具体工厂角色
• 抽象产品角色
• 具体产品角色

抽象产品类

package com.julissa.factory;

/**
 * 抽象产品角色
 */
public abstract class SmartProduction {
    /**
     * 每一种智能产品都有发送功能
     */
    public abstract void send();
}

具体产品类

package com.julissa.factory;

/**
 *
 * 电脑 （具体产品角色）
 */
public class Computer extends SmartProduction{
    @Override
    public void send() {
        System.out.println("电脑端发送信息~~~");
    }
}

package com.julissa.factory;

/**
 *
 * 智能手机 （具体产品角色）
 */
public class SmartPhone extends SmartProduction{
    @Override
    public void send() {
        System.out.println("手机端发送信息~~~");
    }
}

抽象工厂类

package com.julissa.factory;

/**
 *
 * 抽象工厂类
 */
public interface SmartFactory {
    SmartProduction get();
}

具体工厂类

package com.julissa.factory;

/**
 *
 * 具体工厂类
 */
public class ComputerFactory implements SmartFactory{
    @Override
    public SmartProduction get() {
        return new Computer();
    }
}

package com.julissa.factory;

/**
 * 具体工厂类
 */
public class SmartPhoneFactory implements SmartFactory{
    @Override
    public SmartProduction get() {
        return new SmartPhone();
    }
}

客户端程序：

package com.julissa.factory;

public class Test {
    public static void main(String[] args) {
        ComputerFactory computerFactory = new ComputerFactory();
        SmartProduction computer = computerFactory.get();
        computer.send();

        SmartPhoneFactory smartPhoneFactory = new SmartPhoneFactory();
        SmartProduction smartPhone = smartPhoneFactory.get();
        smartPhone.send();
    }
}

执行客户端程序：

如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增:手表

增加：具体产品角色

package com.julissa.factory;

/**
 * 手表 （具体产品角色）
 */
public class Watch extends SmartProduction {
    @Override
    public void send() {
        System.out.println("智能手表发送信息~~~");
    }
}

增加：具体工厂角色

package com.julissa.factory;

/**
 * 具体工厂类
 */
public class WatchFactory implements SmartFactory{
    @Override
    public SmartProduction get() {
        return new Watch();
    }
}

客户端程序：

package com.julissa.factory;

public class Test {
    public static void main(String[] args) {
        ComputerFactory computerFactory = new ComputerFactory();
        SmartProduction computer = computerFactory.get();
        computer.send();

        SmartPhoneFactory smartPhoneFactory = new SmartPhoneFactory();
        SmartProduction smartPhone = smartPhoneFactory.get();
        smartPhone.send();

        WatchFactory watchFactory = new WatchFactory();
        SmartProduction watch = watchFactory.get();
        watch.send();
    }
}

执行客户端程序

我们可以看到在进行功能扩展的时候，不需要修改之前的源代码，显然工厂方法模式符合OCP原则。

工厂方法模式的优点：

• 一个调用者想创建一个对象，只要知道其名称就可以了。
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 屏蔽产品的具体实现，调用者只关心产品的接口。

工厂方法模式的缺点：

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。