0
点赞
收藏
分享

微信扫一扫

SpringIOC之AbstractMessageSource

文章目录


前言

软件设计模式之工厂模式。


一、引入

具体类的设计如下:

在这里插入图片描述

二、简单工厂模式

1.实现

现在使用简单工厂对上面案例进行改进,类图如下:
在这里插入图片描述

public class SimpleCoffeeFactory {

    public Coffee createCoffee(String type) {
        Coffee coffee = null;
        if("americano".equals(type)) {
            coffee = new AmericanoCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffee;
    }
}

2.优缺点

  • 优点:
    • 封装了创建对象的过程,可以通过参数直接获取对象。
    • 把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
  • 缺点:
    • 增加新产品时还是需要修改工厂类的代码,违背了“开闭原则”。

3.扩展

静态工厂

public class SimpleCoffeeFactory {

    public static Coffee createCoffee(String type) {
        Coffee coffee = null;
        if("americano".equals(type)) {
            coffee = new AmericanoCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffe;
    }
}

三、工厂方法模式

1.实现

在这里插入图片描述
代码如下:

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Coffee
 * @Description: 咖啡类
 * @Date: 2023/12/21 16:27
 */
public abstract class Coffee {

    public abstract String getName();

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

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

}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AmericanCcoffee
 * @Description: 美式咖啡类
 * @Date: 2023/12/21 16:29
 */
public class AmericanCoffee extends Coffee{

    @Override
    public String getName() {
        return "美式咖啡";
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: LatteCoffee
 * @Description: 拿铁咖啡类
 * @Date: 2023/12/21 16:35
 */
public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: CoffeeFactory
 * @Description: 咖啡工厂接口
 * @Date: 2023/12/21 16:36
 */
public interface CoffeeFactory {
   Coffee createCoffee();
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AmericanCoffeeFactory
 * @Description: 美式咖啡工厂
 * @Date: 2023/12/21 16:37
 */
public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: LatteCoffeeFactory
 * @Description: 拿铁咖啡工厂
 * @Date: 2023/12/21 16:38
 */
public class LatteCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: CoffeeStore
 * @Description: 咖啡店类
 * @Date: 2023/12/21 16:39
 */
public class CoffeeStore {
    private CoffeeFactory factory;

    public void setFactory(CoffeeFactory factory) {
        this.factory = factory;
    }

    public Coffee orderCoffee() {
        Coffee coffee = factory.createCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Client
 * @Description: 测试类
 * @Date: 2023/12/21 16:44
 */
public class Client {
    public static void main(String[] args) {
        CoffeeStore store = new CoffeeStore();
        store.setFactory(new LatteCoffeeFactory());
        Coffee coffee = store.orderCoffee();
        System.out.println(coffee.getName());
    }
}

2.优缺点

  • 优点:
    • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程;
    • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;
  • 缺点:
    • 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。

四、抽象工厂模式

在这里插入图片描述
在这里插入图片描述

1.实现

在这里插入图片描述
代码如下:

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Coffee
 * @Description: 咖啡类
 * @Date: 2023/12/21 16:27
 */
public abstract class Coffee {

    public abstract String getName();

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

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

}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: LatteCoffee
 * @Description: 拿铁咖啡类
 * @Date: 2023/12/21 16:35
 */
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AmericanCcoffee
 * @Description: 美式咖啡类
 * @Date: 2023/12/21 16:29
 */
public class AmericanCoffee extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Dessert
 * @Description: 甜点类
 * @Date: 2023/12/21 17:30
 */
public abstract class Dessert {
    public abstract void show();
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: MatcheMousse
 * @Description: 抹茶慕斯类
 * @Date: 2023/12/21 17:31
 */
public class MatcheMousse extends Dessert{
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Tiramisu
 * @Description: 提拉米苏类
 * @Date: 2023/12/21 17:30
 */
public class Tiramisu extends Dessert{
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: DessertFactory
 * @Description: 甜品工厂
 * @Date: 2023/12/21 17:33
 */
public interface DessertFactory {
    Coffee createCoffee();
    Dessert createDessert();
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AmericanDessertFactory
 * @Description: 美式风味工厂类
 *              生产美式咖啡和抹茶慕斯
 * @Date: 2023/12/21 17:34
 */
public class AmericanDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new MatcheMousse();
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: ItalyDessertFactory
 * @Description: 意大利风味工厂
 *              生产拿铁咖啡和提拉米苏
 * @Date: 2023/12/21 17:35
 */
public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Tiramisu();
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Client
 * @Description: 测试类
 * @Date: 2023/12/21 17:36
 */
public class Client {
    public static void main(String[] args) {
        ItalyDessertFactory italyDessertFactory = new ItalyDessertFactory();
        Dessert dessert = italyDessertFactory.createDessert();
        Coffee coffee = italyDessertFactory.createCoffee();
        System.out.println(coffee.getName());
        dessert.show();
    }
}

在这里插入图片描述

2.优缺点

  • 优点:
    • 当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
  • 缺点:
    • 当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。

3.使用场景

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

五、模式扩展

简单工厂+配置文件解除耦合

第一步:定义配置文件
使用properties文件作为配置文件,名称为bean.properties

american=com.itheima.pattern.factory.config_factory.AmericanCoffee
latte=com.itheima.pattern.factory.config_factory.LatteCoffee
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Coffee
 * @Description: 咖啡类
 * @Date: 2023/12/21 16:27
 */
public abstract class Coffee {

    public abstract String getName();

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

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

}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AmericanCcoffee
 * @Description: 美式咖啡类
 * @Date: 2023/12/21 16:29
 */
public class AmericanCoffee extends Coffee {

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

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: LatteCoffee
 * @Description: 拿铁咖啡类
 * @Date: 2023/12/21 16:35
 */
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: CoffeeFactory
 * @Description: 咖啡工厂类
 * @Date: 2023/12/21 21:06
 */
public class CoffeeFactory {
    //定义容器对象存储咖啡对象
    private static Map<String,Coffee> map = new HashMap();

    // 加载配置文件,只需要加载一次
    static {
        // 创建Properties对象
        Properties p = new Properties();
        // 调用p对象中的load方法进行配置文件的加载
        InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            p.load(is);
            //遍历Properties集合对象
            Set<Object> keys = p.keySet();
            for (Object key : keys) {
                //根据键获取值(全类名)
                String className = p.getProperty((String) key);
                //获取字节码对象
                Class clazz = Class.forName(className);
                Coffee obj = (Coffee) clazz.newInstance();
                map.put((String)key,obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 根据名称获取对象
    public static Coffee createCoffee(String name) {

        return map.get(name);
    }
}

六、JDK源码解析

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("令狐冲");
        list.add("风清扬");
        list.add("任我行");

        //获取迭代器对象
        Iterator<String> it = list.iterator();
        //使用迭代器遍历
        while(it.hasNext()) {
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

在这里插入图片描述
Collection接口是抽象工厂类,ArrayList是具体的工厂类;Iterator接口是抽象商品类,ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。


总结

以上就是设计模式工厂模式的讲解。

举报

相关推荐

0 条评论