在本教程中会介绍三种工厂的使用
- 简单工厂模式(不属于GOF的23种经典设计模式)
- 工厂方法模式
- 抽象工厂模式
1.案例
1.产品抽象类
package 工厂模式.简单工厂模式;
public abstract class Coffee {
public abstract String getName();
//加糖
public void addsugar(){
System.out.println("加糖");
}
//加奶
public void addMilk(){
System.out.println("加奶");
}
}
2.产品具体类
package 工厂模式.简单工厂模式;
//产品1: 美式咖啡
public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}
package 工厂模式.简单工厂模式;
//产品2: 拿铁咖啡
public class LatterCoffee extends Coffee{
@Override
public String getName() {
return "拿铁咖啡";
}
}
3.商店类
package 工厂模式.简单工厂模式;
//产品商店
public class CoffeeStore {
public Coffee orderCoffee(String type){
Coffee coffee = null;
if("American".equals(type)){
coffee = new AmericanCoffee();
}else if("Latter".equals(type)){
coffee = new LatterCoffee();
}else{
throw new RuntimeException("没有你要的咖啡");
}
coffee.addsugar();
coffee.addMilk();
return coffee;
}
}
4.客户
package 工厂模式.简单工厂模式;
public class Client {
public static void main(String[] args) {
CoffeeStore store = new CoffeeStore();
Coffee coffee = store.orderCoffee("Latter");
System.out.println(coffee.getName());
}
}
缺陷:coffeeStore类依赖于具体的coffee实现类,如果需要增添coffee品类,就需要修coffeeStore类,违反了开闭原则
在java中,万物皆对象,这些对象都需要创建,如果创建的时候直接new该对象,就会对该对象耦合严重,假如我们要更换对象,所有new对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;所以说,工厂模式最大的优点就是:解耦。
2.简单工厂模式
简单工厂不是一种设计模式,反而比较像是一种编程习惯。
2.1 结构
简单工厂包含如下角色:
- 抽象产品 :定义了产品的规范,描述了产品的主要特性和功能。
- 具体产品 :实现或者继承抽象产品的子类
- 具体工厂 :提供了创建产品的方法,调用者通过该方法来获取产品。
2.2 实现
现在使用简单工厂对上面案例进行改进,类图如下:
2.2.1 工厂类
package 工厂模式.简单工厂模式.SimpleFactory;
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type) {
Coffee coffee = null;
if("American".equals(type)) {
coffee = new AmericanCoffee();
} else if("Latter".equals(type)) {
coffee = new LatterCoffee();
}
return coffee;
}
}
2.2.2 coffeeStore
package 工厂模式.简单工厂模式.SimpleFactory;
//产品商店
public class CoffeeStore {
public Coffee orderCoffee(String type){
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
Coffee coffee = factory.createCoffee(type);
coffee.addMilk();
coffee.addsugar();
return coffee;
}
}
工厂(factory)处理创建对象的细节,一旦有了SimpleCoffeeFactory,CoffeeStore类中的orderCoffee()就变成此对象的客户,后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了CoffeeStore类和Coffee实现类的耦合,同时又产生了新的耦合,CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合,工厂对象和商品对象的耦合。
后期如果再加新品种的咖啡,我们势必要需求修改SimpleCoffeeFactory的代码,违反了开闭原则。工厂类的客户端可能有很多,比如创建美团外卖等,这样只需要修改工厂类的代码,省去其他的修改操作。
2.3 优缺点
优点:
封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户端代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
缺点:
增加新产品时还是需要修改工厂类的代码,违背了“开闭原则”。
2.4 静态工厂
在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的,这个就是静态工厂模式,它也不是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;
}
}
3. 工厂模式
使用工厂方法模式就可以完美的解决,完全遵循开闭原则。
2.1 结构
工厂方法模式的主要角色:
- 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。
- 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
- 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
- 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。
工厂接口
package 工厂模式.简单工厂模式.Factory;
public interface CoffeeFactory {
Coffee createCoffee();
}
产品对应的工厂类
package 工厂模式.简单工厂模式.Factory;
public class LatterCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
package 工厂模式.简单工厂模式.Factory;
public class AmericanCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
商店类
package 工厂模式.简单工厂模式.Factory;
//产品商店
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;
}
}
不依赖产品本身,而是依赖产品工厂
优缺点
优点:
- 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程;
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;
缺点:
- 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。
4.抽象工厂模式
简单工厂模式下,coffee工厂只生产工厂;抽象工厂模式下,工厂可以生产多种同族类产品,比如水果工厂,不仅生产苹果,还盛产橘子;
产品族:不同类型的产品但是属于同一品牌
产品等级:同一品牌下不同产品( iphone和ipad的关系)
概念
比如运动风格的工厂,即有生产上衣的接口,也有生产裤子、运动鞋的接口
结构
抽象工厂模式的主要角色如下:
- 抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品。
- 具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
- 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
- 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它 同具体工厂之间是多对一的关系。
实现
现咖啡店业务发生改变,不仅要生产咖啡还要生产甜点,如提拉米苏、抹茶慕斯等,要是按照工厂方法模式,需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类,很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级,都是咖啡;提拉米苏、抹茶慕斯也是一个产品等级;拿铁咖啡和提拉米苏是同一产品族(也就是都属于意大利风味),美式咖啡和抹茶慕斯是同一产品族(也就是都属于美式风味)。所以这个案例可以使用抽象工厂模式实现。类图如下:
1.抽象工厂
只定义生产厂品的接口
package 工厂模式.简单工厂模式.AbstractFactory;
//科技公司
public interface technologyCompany {
Phone createPhone();
Computer createComputer();
}
2.具体工厂类
package 工厂模式.简单工厂模式.AbstractFactory;
//
public class Apple implements technologyCompany{
@Override
public Phone createPhone() {
return new Iphone();
}
@Override
public Computer createComputer() {
return new Ipad();
}
}
package 工厂模式.简单工厂模式.AbstractFactory;
public class XiaoMi implements technologyCompany{
@Override
public Phone createPhone() {
return new RedMi();
}
@Override
public Computer createComputer() {
return new XiaoMiCpmupter();
}
}
3.具体产品
package 工厂模式.简单工厂模式.AbstractFactory;
//产品1: Ipad
public class Iphone extends Phone {
@Override
public void show() {
System.out.println("this is iphone");
}
}
package 工厂模式.简单工厂模式.AbstractFactory;
public class Ipad extends Computer{
@Override
public String getName() {
return "Ipad";
}
}
package 工厂模式.简单工厂模式.AbstractFactory;
public class RedMi extends Phone {
@Override
public void show() {
System.out.println("这是红米手机");
}
}
package 工厂模式.简单工厂模式.AbstractFactory;
public class XiaoMiCpmupter extends Computer{
@Override
public String getName() {
return "小米电脑";
}
}
4.产品抽象类
package 工厂模式.简单工厂模式.AbstractFactory;
public abstract class Computer {
public abstract String getName();
public void playVideo(){
System.out.println("苍老师");
}
public void playGame(){
System.out.println("LOL");
}
}
package 工厂模式.简单工厂模式.AbstractFactory;
public abstract class Phone {
public abstract void show();
}
优缺点
优点:
当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
缺点:
当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。
使用场景
-
当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。
-
系统中有多个产品族,但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
-
系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。
如:输入法换皮肤,一整套一起换。生成不同操作系统的程序。
抽象工厂在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()方法创建具体的商品类的对象。
5.简单工厂+配置文件解除耦合
第一步:定义配置文件
为了演示方便,我们使用properties文件作为配置文件,名称为bean.properties
第二步:改进简单工厂类
简单工厂->只能生产同一类产品
public class CoffeeFactory {
private static Map<String,Coffee> map = new HashMap();
static {
Properties p = new Properties();
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);
}
}
- 读取配置文件以及创建对象写在静态代码块中,目的就是在类加载的时候就读取配置文件,只需要执行一次。
- 由于容器是在静态代码块中初始化的,因此需要将容器定义为静态成员变量(键存储的是名称,值存储的是对应的对象),