我们先别急着想工厂模式是什么样的啊 先看看下面这个例子啊,怎么设计,如何写,才能更好。 一步一步引出Java工厂模式。
需求:设计一个咖啡店点餐系统。
设计一个咖啡类(Coffee),并定义其两个子类(美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】);再设计一个咖啡店类(CoffeeStore),咖啡店具有点咖啡的功能。
代码是比较简单的,我这是采取一步一步引入的,如果不喜欢,可以直接看下文。
我们先用曾经的方式来设计和进行代码的编写。
我们先用以前的方式来实现一遍哈。
1、先写好Coffee这个抽象类
public abstract class Coffee {
public abstract void addMilk();
public abstract void addSugar();
public abstract String getName();
}
2、再写好美式咖啡和拿铁咖啡继承Coffee抽象类
public class AmericanCoffee extends Coffee {
@Override
public void addMilk() { System.out.println("给咖啡加奶"); }
@Override
public void addSugar() { System.out.println("给咖啡加糖"); }
@Override
public String getName() { return "美式咖啡"; }
}
public class LatteCoffee extends Coffee {
@Override
public void addMilk() { System.out.println("给咖啡加奶"); }
@Override
public void addSugar() { System.out.println("给咖啡加糖"); }
@Override
public String getName() { return "拿铁咖啡"; }
}
3、咖啡店
public class CoffeeStore {
public Coffee createCoffee(String type){
Coffee coffee = null;
if("americano".equals(type)) {
coffee = new AmericanCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
}
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
4、写个客户端来测试点咖啡哈
public class Client {
public static void main(String[] args) {
CoffeeStore coffeeStore = new CoffeeStore();
Coffee coffee = coffeeStore.createCoffee("americano");
System.out.println(coffee.getName());
/**
* 输出:
* 给咖啡加奶
* 给咖啡加糖
* 美式咖啡
*/
}
}
其实乍一看没啥问题,但是如果我这个需要增加几种咖啡,你说该如何才合适勒?
是不是需要修改CoffeeStore的代码。又如果要开设美团外卖点单呢?又如何改呢?
在java中,万物皆对象。
如果创建的时候直接new该对象,就会对该对象耦合严重,假如我们要更换对象,所有new对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则。(而且这种重复工作简直想死)
如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;所以说,工厂模式最大的优点就是:解耦。
接下来就出现了简单工厂模式(简单工厂模式并非23种经典模式之内,更像是一种编程习惯吧)。😁
简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。
简单工厂包含如下角色:
使用场景
工厂类负责创建的对象比较少;
客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心;
简单来说就是在原有的设计上加了一层(没有什么是加一层解决不了的,不行就加两层(狗头保命))😁
就在原有基础上做了一些修改:
增加一个SimpleCoffeeFactory类,在这个地方进行对象的创建。😀
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type) {
Coffee coffee = null;
if("americano".equals(type)) {
coffee = new AmericanCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
}
return coffee;
}
}
再修改一下CoffeeStore类
public class CoffeeStore {
public Coffee createCoffee(String type){
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
Coffee coffee = factory.createCoffee(type);
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
看起来好像只是把创建对象的权力给到了SimpleCoffeeFactory
,没有什么其他操作,但是就是这个SimpleCoffeeFactory
工厂类,已经将CoffeeStore
类和Coffee对象解耦了,CoffeeStore
不再需要管具体产品对象是如何创建的,只需要负责自己的事情就可以了,明确了各自的职责和权利,有利于整个软件体系结构的优化
总结:
工厂(factory)处理创建对象的细节,有了SimpleCoffeeFactory
,CoffeeStore类中的orderCoffee()就变成此对象的客户,后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合,但同时又产生了新的耦合,CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合,工厂对象和商品对象的耦合。
后期如果再加新品种的咖啡,我们势必要需求修改SimpleCoffeeFactory
的代码,违反了开闭原则。
工厂类的客户端可能有很多,比如创建美团外卖等,这样只需要修改工厂类的代码,省去其他的修改操作。
优点:
封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的.明确了各自的职责和权利,有利于整个软件体系结构的优化。
缺点:
当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求.这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利,违背了“开闭原则”。
在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的,这个就是静态工厂模式,它也不是23种设计模式中的。代码如下
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;
}
}
可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。
在工厂类中加载配置文件中的全类名,并创建对象进行存储,客户端如果需要对象,直接进行获取即可。
定义一个配置文件 my.properties
american=com.crush.factory.simple_factory_properties.AmericanCoffee
latte=com.crush.factory.simple_factory_properties.LatteCoffee
改进工厂类
public class CoffeeFactory {
private static Map<String,Coffee> map = new HashMap();
static {
Properties p = new Properties();
InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("my.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);
}
}
静态成员变量用来存储创建的对象(键存储的是名称,值存储的是对应的对象),而读取配置文件以及创建对象写在静态代码块中,目的就是只需要执行一次。
这种方式用的也很多,常见也很简单。
这个简单工厂并不完善,增加新产品时还是需要修改工厂类的代码,违背了“开闭原则”,所以才有了后文的工厂模式、抽象工厂模式
。
持续更新中哦。