首页 > 编程学习 > 创建者模式--工厂模式

创建者模式--工厂模式

发布时间:2022/8/29 16:14:29

概述

需求:设计一个咖啡店点餐系统

设计一个咖啡类(Coffee),并定义两个子类(美式咖啡[AmericanCoffee]和拿铁咖啡[LatteCoffee]);再设计一个咖啡店(CoffeeStore),咖啡店具有点咖啡的功能.

类图如下

 

//首先创建一个抽象的coffee类
public abstract class Coffee {

    abstract String getName();

    public void addSuger() {
        System.out.println("加糖");
    }

    public void addMilk() {
        System.out.println("加奶");
    }
}

//美式咖啡
public class AmericaCoffee extends Coffee {


    @Override
    String getName() {
        return "美式咖啡";
    }
}

//拿铁咖啡
public class LatteCoffee extends Coffee {


    @Override
    String getName() {
        return "拿铁咖啡";
    }
}

//咖啡店,可以创建咖啡对象
public class CoffeeStore {

    public Coffee ordderCoffee(String type) {
        Coffee coffee = null;
        if ("america".equals(type)) {
            coffee = new AmericaCoffee();
        }else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        }else {
            throw new RuntimeException("抱歉,你点的咖啡没有");
        }
        coffee.addSuger();
        coffee.addMilk();
        return coffee;
    }
}

public class Client {

    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee coffee = coffeeStore.ordderCoffee("latte");
        System.out.println(coffee.getName());
    }
}

 结果:

加糖
加奶
拿铁咖啡

后续如果我想加一个咖啡品类的话,就要修改咖啡店的代码,违背了开闭原则

在java中,万物皆对象,这些对象都需要被创建,如果创建的时候直接new对象,就会导致该对象耦合严重,假如我们要更换对象,所有new 对象的地方都需要修改一遍,这显然违背了软件的开闭原则,如果我们需要工厂来生产对象,我们就只和工厂打交道就行了,彻底解决耦合, 如果要更换对象,直接在工厂里更换对象就行,打到了于对象解耦的目的;所以说,工厂模式最大的优点就是:解耦

抽象工厂模式

前面介绍得工厂方法模式中考虑的是一类产品的生产,如电视机厂只生产电视机等,

这些工厂只生产同种类的产品,同种类的产品又称同等级产品,也就是说,工厂方法模式只考虑生产同等级的产品,但是在现实生活中许多工厂是综合性工厂,能生产多等级的产品,如电器厂既可以生产电视机也可以生产洗衣机,

本节要介绍的抽象工厂模式将考虑多等级产品的生产,将统一个具体工厂所生产的位于不同等级的一组产品称为一个产品族,

下图横轴是产品等级,也就是同一类产品,纵轴是产品族,也就是同一品牌的产品,同一品牌的产品来自同一个工厂

 

概念

是一种为访问类提供一个创建一组相关或互相依赖对象的接口,切访问类无需指定索要产品的具体类就能得到同组的不同等级的产品的模式结构

抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产同一等级的产品,而抽象工厂模式可生产多个等级的产品

结构

  • 抽象工厂(Abstract Factory) : 提供了创建产品的接口,它包含了多个创建产品的方法,可以创建不同等级的产品
  • 具体工厂(Concrete Factory) : 主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建
  • 抽象产品(Product) : 定义了产品的规范,描述了产品的主要特性和功能,抽象工厂有多个抽象产品
  • 具体产品(ConcreteProduct) : 实现了抽象产品角色所定义的接口,由具体工厂创建,它同具体工厂是多对一的关系

实现

现咖啡店业务发生改变,不仅要生产咖啡,还生产甜点,要是按照工厂方法模式,需定义提拉米苏类等,很容易发生类爆炸情况,其中拿铁咖啡和美式咖啡是一个产品等级,都是咖啡;提拉米苏等也是一个产品等级,拿铁咖啡和提拉米苏是一个产品族(意大利风味),美式咖啡和抹茶慕斯是同一个产品族(美式风味),所以这个案例可以可以使用抽象工厂模式来实现:类图如下

 

 

 

 

//首先创建一个抽象的coffee类
public abstract class Coffee {

    abstract String getName();

    public void addSuger() {
        System.out.println("加糖");
    }

    public void addMilk() {
        System.out.println("加奶");
    }
}

//美式咖啡
public class AmericaCoffee extends Coffee {

    @Override
    String getName() {
        return "美式咖啡";
    }
}

//拿铁咖啡
public class LatteCoffee extends Coffee {


    @Override
    String getName() {
        return "拿铁咖啡";
    }
}

//抽象甜品类
public abstract class Dessert {

    abstract void show();
}

public class MatchaMouse extends Dessert{

    @Override
    void show() {
        System.out.println("抹茶慕斯");
    }
}

public class Trimisu extends Dessert{

    @Override
    void show() {
        System.out.println("提拉米苏");
    }
}

public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

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

public class AmericanDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericaCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new MatchaMouse();
    }
}

public interface DessertFactory {

    Coffee createCoffee();

    Dessert createDessert();
}

    public static void main(String[] args) {
        ItalyDessertFactory factory = new ItalyDessertFactory();
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();
        System.out.println(coffee.getName());
        dessert.show();

    }

输出

 

 

 

优缺点:

 

 优点:当一个产品族中的多个对象被设计成一起工作时,他能保证客户端始终只使用同一个产品族中的对象

 缺点:当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改

使用场景

  • 当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机等
  • 系统中有多个产品族,但每次只使用其中的某一组产品.如果人只喜欢穿某一个品牌的衣服和鞋
  • 系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构
  • 如:输入法切换皮肤,一整套一起换;生成不同操作系统的程序

 模式拓展

简单工厂+配置文件接触耦合

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合.在工厂类中加载配置文件的全类名,并反射创建对象进行存储,客户端如果需要对象,直接进行获取即可

 

 

 

//创建配置文件
american=com.ali.designPattern.创建模式.工厂模式.configFactory.AmericaCoffee
latte=com.ali.designPattern.创建模式.工厂模式.configFactory.LatteCoffee

//首先创建一个抽象的coffee类
public abstract class Coffee {

    abstract String getName();

    public void addSuger() {
        System.out.println("加糖");
    }

    public void addMilk() {
        System.out.println("加奶");
    }
}

//美式咖啡
public class AmericaCoffee extends Coffee {

    @Override
    String getName() {
        return "美式咖啡";
    }
}

//拿铁咖啡
public class LatteCoffee extends Coffee {
    
    @Override
    String getName() {
        return "拿铁咖啡";
    }
}

public class CoffeeFactory {


    /*加载配置文件,获取配置文件中配置的全类名,并创建该类的对象进行存储
        1:定义容器对象存储咖啡对象
        2:加载配置文件,只需要加载一次
     */
    private static Map<String,Coffee> map = new HashMap<>();

    static {
        //创建properties对象
        Properties properties = new Properties();
        ClassLoader classLoader = CoffeeFactory.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("bean.properties");
        try {
            properties.load(is);
            //从集合中获取全类名并反射创建对象
            Set<Object> set = properties.keySet();
            for (Object key : set) {
                String className = properties.getProperty((String) key);
                Class<?> clazz = Class.forName(className);
                Coffee coffee = (Coffee) clazz.newInstance();
                map.put((String) key,coffee);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //根据名称获取对象
    public static Coffee createCoffee(String name) {
        return map.get(name);
    }
}

    public static void main(String[] args) {
        Coffee coffee = CoffeeFactory.createCoffee("american");
        System.out.println(coffee.getName());
    }

 

注:包路径包含中文会创建不成功,因为找不到路径,需要把路径URLDecoder.decode(path,"UTF-8")一下

JDK源码

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {
            String next = iterator.next();
            System.out.println(next);
        }
    }

 

相信对这段代码很熟,使用迭代器遍历,获取集合中的元素,而单例集合获取迭代器的方法就使用到了工厂方法模式,

类图

 

Copyright © 2010-2022 mfbz.cn 版权所有 |关于我们| 联系方式|豫ICP备15888888号