创建型设计模式抽象工厂模式

Posted 2022-06-25 vbirdbest

一：工厂方法模式的适用的场景

工厂方法模式是一个具体工厂只生产一类产品。
现在咖啡店升级了不止卖咖啡了也开始卖甜点了，咖啡和甜点是两种不同的产品，如果我们按照工厂方法模式该怎么做呢？首先无论使用什么模式Dessert(甜点)、Trimisu(提拉米苏)、MatchMousse(抹茶慕斯) 三个实体肯定是少不了的，因为增加两个具体的甜品所以也要相应的增加两天具体的甜品工厂MatchMousseDessertFactory、TrimisuDessertFactory，相应的CoffeeStore也要增加orderDessert()方法。

// 甜点父类
public abstract class Dessert 
    public abstract String getName();


public class Trimisu extends Dessert 
    @Override
    public String getName() 
        return "提拉米苏（意大利风味）";
    


public class MatchMousse extends Dessert 
    @Override
    public String getName() 
        return "抹茶慕斯（美式风味）";
    


// 增加一个甜点工厂
public interface DessertFactory 
    Dessert createDessert();


// 增加一个抹茶慕斯工厂
public class MatchMousseDessertFactory implements DessertFactory 
    @Override
    public Dessert createDessert() 
        return new MatchMousse();
    


// 增加一个提拉米苏工厂
public class TrimisuDessertFactory implements DessertFactory 
    @Override
    public Dessert createDessert() 
        return new Trimisu();
    

public class CoffeeStore 

    private CoffeeFactory coffeeFactory;
    // 新增甜点工厂
    private DessertFactory dessertFactory;

    public void setCoffeeFactory(CoffeeFactory coffeeFactory) 
        this.coffeeFactory = coffeeFactory;
    

    public void setDessertFactory(DessertFactory dessertFactory) 
        this.dessertFactory = dessertFactory;
    

    public Coffee orderCoffee() 
        Coffee coffee = coffeeFactory.createCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    
    
    // 增加点甜品功能
    public Dessert orderDessert() 
        Dessert dessert = dessertFactory.createDessert();
        System.out.println("制作甜点");
        return dessert;
    

public class ItalyClient 
    public static void main(String[] args) 
        CoffeeFactory coffeeFactory = new LatteCoffeeFactory();
        // 新增提拉米苏工厂
        DessertFactory dessertFactory = new TrimisuDessertFactory();

        CoffeeStore coffeeStore = new CoffeeStore();
        coffeeStore.setCoffeeFactory(coffeeFactory);
        coffeeStore.setDessertFactory(dessertFactory);

        Coffee coffee = coffeeStore.orderCoffee();
        // 点甜点
        Dessert dessert = coffeeStore.orderDessert();
        System.out.println(coffee.getName());
        System.out.println(dessert.getName());
    

现在是增加了2个甜点需要创建2个工厂，如果增加100个甜点就要增加100个工厂类，这样会造成类文件过多（类爆炸）。

二：抽象工厂要解决的问题

工厂方法模式是一个工厂只生产一种特定的产品，实际社会中很多工厂都会生产多个产品（如咖啡店可能买咖啡、甜点、简餐等）。我们能不能把“一个工厂只生产一种特定产品”再进行抽象一下，让一个工厂可以生产多个产品，并且这个工厂生产的所有产品都有一定的关联性。

比如开一个美式风味工厂可以生产美式咖啡、美式甜点、美式简餐，再开一个意大利风味工厂可以生产意大利式咖啡、意大利式甜点、意大利式简餐。

工厂方法模式和抽象工厂模式其实就是分类颗粒度的程度不同，工厂方法模式分类是分的特别细一类产品就属于一个工厂，而抽象工厂模式是以系列作为分类，分类的范围更广泛。

这样由原来的工厂方法模式（如果新增100个产品增加100个具体工厂类）就变成了抽象工厂模式（如果新增100个产品，就变成只需要2个工厂类（美式风味工厂、意大利风味工厂）即可）。

public interface CategoryFactory 
    Coffee createCoffee();
    Dessert createDessert();


// 美式风味工厂
public class AmericanFactory implements CategoryFactory 
    @Override
    public Coffee crateCoffee() 
        return new AmericanCoffee();
    

    @Override
    public Dessert createDessert() 
        return new MatchMousse();
    


// 意大利风味工厂
public class ItalyFactory implements CategoryFactory 
    @Override
    public Coffee crateCoffee() 
        return new LatteCoffee();
    

    @Override
    public Dessert createDessert() 
        return new Trimisu();
    

public class CoffeeStore 
	// 系列工厂
    private CategoryFactory categoryFactory;

    public void setCategoryFactory(CategoryFactory categoryFactory) 
        this.categoryFactory = categoryFactory;
    

    public Coffee orderCoffee() 
        Coffee coffee = categoryFactory.createCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    

    public Dessert orderDessert() 
        Dessert dessert = categoryFactory.createDessert();
        System.out.println("制作甜点");
        return dessert;
    

public class Client 
    public static void main(String[] args) 
        // 只需要创建一个系列工厂，就能获取该系列工厂的所有产品
        CategoryFactory factory = new ItalyFactory();
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();
    

三：抽象工厂的应用场景

抽象工厂模式是工厂方法模式的升级版本，解决了工厂方法设计模式的类爆炸问题，同时也改变了应用场景，抽象工厂模式是为了解决一系列相关产品的创建。比如如果我偏好喜欢意大利口味的，我只需要创建一个意大利风味的工厂，就能得到这个工厂生产所有意大利口味的东西（咖啡、甜点、面条等）。

例如比如数据库驱动如果配置成mysql，就会创建mysql相关的所有对象如MysqlConnecton、MysqlSession、MySqlDataSource等，如果是oracle也会创建oracle相关的对象。

四：抽象工厂的优缺点

• 优点：用于一次创建一系列对象的工厂，解决了工厂方法的类爆炸问题。
• 缺点：每增加一个具体的对象都需要在每个工厂中添加对应的实现。比如咖啡店要卖简餐了，那所有的工厂都要增加一个方法。

public interface CategoryFactory 
    Coffee createCoffee();
    Dessert createDessert();
    SimpleFood createSimpleFood();



public class ItalyFactory implements CategoryFactory 
    @Override
    public Coffee createCoffee() 
        return new LatteCoffee();
    

    @Override
    public Dessert createDessert() 
        return new Trimisu();
    

	// 意大利工厂要增加简餐
    @Override
    public SimpleFood createSimpleFood() 
        return null;
    



public class AmericanFactory implements CategoryFactory 
    @Override
    public Coffee createCoffee() 
        return new AmericanCoffee();
    

    @Override
    public Dessert createDessert() 
        return new MatchMousse();
    

	// 美式工厂也要增加简餐
    @Override
    public SimpleFood createSimpleFood() 
        return null;