【创建型】工厂模式

简单工厂模式/静态工厂方法

简单工厂模式（Simple Factory Pattern）又叫做静态工厂方法模式（Static Factory Method Pattern），并不属于 GoF 的23种设计模式之一，是学习其他工厂模式的的基础。

• Factory：创建产品，返回抽象产品类
• Product：抽象产品类，公有属性和方法
• Concrete Product：具体产品角色，继承了抽象产品角色，需要实现抽象方法。

【例】硬币：铜币、金币

/**
 * 简单工厂模式
 * 创建对象和使用分离
 * 客户端不需要关心如何创建对象，只需要知道创建对象对应的参数
 * -违背了开闭原则
 * -一个类创建了太多对象，职责很重，出了故障系统崩溃
 * 1.直接new
 * 2.通过配置文件获取目标对象名，更加灵活
 */
public class Client {
    public static void main(String[] args) {
        CoinFactory coinFactory = new CoinFactory();
        Coin copper = coinFactory.creatCoin("copper");
        System.out.println(copper.getCoin());
        //使用配置文件来进行灵活加载
        Properties properties = new Properties();
        try {
            //相对于类加载器的路径进行加载，根路径
            properties.load(CoinFactory.class.getClassLoader().getResourceAsStream("conf.properties"));
            //这里配置文件默认string，文件中不要加“”
            String coinName = (String)properties.get("sfp");
            Coin copper2 = coinFactory.creatCoin(coinName);
            System.out.println(copper2.getCoin());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
//抽象产品
public interface Coin {
    String getCoin();
}
//工厂
public class CoinFactory {
    public Coin creatCoin(String coin){
        if (coin.equals("copper")){
            return new CopperCoin();
        }else if(coin.equals("gold")){
            return new GoldCoin();
        }else {
            return null;
        }
    }
}
//具体产品
public class CopperCoin implements Coin{
    @Override
    public String getCoin() {
        return "I am a copper coin.";
    }
}

优点：

• 对象创建和使用分离
• 客户端只需要知道创建参数即可，不需要知道类名
• 引入配置文件一定程度上提高了灵活性

缺点：

• 工厂类职责过重，停摆影响大
• 增加系统复杂度和理解难度
• 添加新产品还是需要修改工厂类逻辑，违反开闭原则
• 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构

适用场景：

• 工厂类负责创建的对象比较少
• 客户端只知道传入工厂类的参数，对于如何创建对象并不关心。 

工厂方法模式

工厂方法模式也被称为虚拟构造器模式（Virtual Constructor Pattern）或多态工厂模式（Polymorphic Factory Pattern）。

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

• Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。
• ConcreteProduct（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。
• Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口
• ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

【例】武器：精灵武器、兽人族武器

/**
 * 工厂方法模式：定义一个用于创建对象的接口即工厂，实例创建推迟到子类实现
 *
 */
public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        //读取配置文件
        Properties properties = new Properties();
        properties.load(Client.class.getClassLoader().getResourceAsStream("conf.properties"));
        String factoryName = properties.getProperty("fmp");
        //反射加载类，多态性
        BlackSmith blacksmith = (BlackSmith) Class.forName(factoryName).newInstance();
        Weapon weapon = blacksmith.createWeapon();
        weapon.showWeapon();
    }
}
//抽象产品
public abstract class Weapon {
    public abstract void showWeapon();
}
//抽象工厂
public abstract class BlackSmith {
    public abstract Weapon createWeapon();
}
//子类创建实例
public class ElfBlackSmith extends BlackSmith {
    @Override
    public Weapon createWeapon() {
        System.out.println("精灵族武器+1");
        return new ElfWeapon();
    }
}
public class OrcBlackSmith extends BlackSmith {
    @Override
    public Weapon createWeapon() {
        System.out.println("兽人族武器+1");
        return new OrcWeapon();
    }
}

优点：

• 无需关心创建细节
• 多态性设计的工厂和产品，让工厂自行决定如何创建对象，封装细节
• 符合开闭原则，无需修改，只需要添加新的工厂和产品。

缺点：

• 更多的类，额外开销
• 更抽象，且在实现时可能需要用到配置文件、反射等技术，增加了系统的实现难度。

适用环境：

• 客户端不知道它所需要的对象的类
• 抽象工厂类通过其子类来指定创建哪个对象，利用面向对象的多态性和里氏代换原则，系统更容易扩展。

抽象工厂模式

工厂方法模式一个工厂只能生产一个产品，会产生大量类。将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是抽象工厂模式（Abstract Factory Pattern）的基本思想。

• AbstractFactory（抽象工厂）：它声明了一组用于创建一组产品的方法，每一个方法对应一种产品。
• ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
• AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
• ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

【例】精灵和兽人王国生产器：城堡、军队、国王

王国工厂（抽象类）：定义了一组用于创建产品的方法，需要军队、国王、城堡

精灵工厂（具体工厂）：创建精灵军队、城堡、国王

兽人工厂（具体工厂）：创建兽人军队、城堡、国王

城堡、军队、国王（抽象类）：声明方法

public class Client {
    public static void main(String[] args) throws Exception {
        //加载配置
        ResourceBundle conf = ResourceBundle.getBundle("conf");
        String className = conf.getString("afp");
        //创建工厂
        KingdomFactory factory = (KingdomFactory) Class.forName(className).newInstance();
        //创建王国
        System.out.println("建造了一座" + factory.creatCastle().getDescription());
        System.out.println("推选了一位" + factory.createKing().getDescription());
        System.out.println("组建了一支" + factory.createArmy().getDescription());
    }
}
//抽象产品
public interface King {
    String getDescription();
}
public interface Army {
    String getDescription();
}
public interface Castle {
    String getDescription();
}
//具体工厂（创建一组相关产品）
public class ElfKingdomFactory implements KingdomFactory {
    @Override
    public Castle creatCastle() {
        return new ElfCastle();
    }

    @Override
    public King createKing() {
        return new ElfKing();
    }

    @Override
    public Army createArmy() {
        return new ElfArmy();
    }
}
//抽象工厂（定义一组创建方法）
public interface KingdomFactory {
    Castle creatCastle();
    King createKing();
    Army createArmy();
}

优点：

1. 封装性：将具体产品的创建封装在工厂类中，客户端无需了解具体产品的创建细节。
2. 易于扩展：可以添加新的产品族，客户端代码无需修改。
3. 一致性：保证创建的产品对象都是同一产品族的，从而保持产品的一致性。

缺点：

1. 复杂性：增加了代码的复杂性，尤其是在产品族较多时，会导致类的数量急剧增加。
2. 扩展性：添加新的产品类型时，需要修改抽象工厂接口，违反了开闭原则。

适用环境：

• 系统中有多于一个的产品族，而每次只使用其中某一产品族
• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束，如同一操作系统下的按钮和文本框，按钮与文本框之间没有直接关系，但它们都是属于某一操作系统的，此时具有一个共同的约束条件：操作系统的类型。
• 产品类型稳定，设计完成之后，不会向系统中增加新的产品类或者删除已有的产品类。

jdk 源码分析

JDK 中的 Calendar 类使用到了简单工厂模式

这个getInstance()方法实际上是一个工厂方法，它通过调用createCalendar方法，创建了一个合适的Calendar实例。

jdk中的iterator同样也使用到了工厂方法进行创建