✨设计模式～工厂模式✨

一、简述

工厂模式是最常用的一类创建型设计模式，工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建。下面我们我们来简单介绍一下三种工厂模式，以及在实际项目中的应用。

二、简单工厂模式

角色：

Factory（工厂角色）：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；
Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。
ConcreteProduct（具体产品角色）：它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

示例：

抽象产品类


abstract class Product {
    
    
    //所有产品类的公共业务方法
    public void methodSame() {
    
    
        //公共方法的实现
    }
 
    //声明抽象业务方法
    public abstract void methodDiff();
}

具体产品类


class ConcreteProduct extends Product {
    
    
    
    //实现业务方法
    @Override
    public void methodDiff() {
    
    
        //业务方法的实现
    }
}

工厂类


class Factory {
    
    
    //静态工厂方法
	public static Product getProduct(String arg) {
    
    
		Product product = null;
		if (arg.equalsIgnoreCase("A")) {
    
    
			product = new ConcreteProductA();
            //初始化设置product
		}
		else if (arg.equalsIgnoreCase("B")) {
    
    
			product = new ConcreteProductB();
            //初始化设置product
		}
		return product;
	}
}

总结：

 简单工厂模式提供了专门的工厂类用于创建对象，将对象的创建和对象的使用分离开，它作为一种最简单的工厂模式在软件开发中得到了较为广泛的应用。

主要缺点
(1) 由于工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响。
(2) 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。
适用场景
在以下情况下可以考虑使用简单工厂模式：
(1) 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。

三、工厂方法模式

简单工厂模式虽然简单，但是当系统中需要引入新产品时，由于工厂类中通过所传入参数的不同来创建不同的产品，这必定要修改工厂类的源代码，将违背“开闭原则”。
而和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，其UML类图如下：

角色：

Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。
ConcreteProduct（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。
Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。
ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

与简单工厂模式相比，工厂方法模式最重要的区别是引入了抽象工厂角色，抽象工厂可以是接口，也可以是抽象类或者具体类。

示例：

需求：实现日志记录器(Logger)，该记录器可以通过多种途径保存系统的运行日志，如通过文件记录或数据库记录。


//日志记录器接口：抽象产品
interface Logger {
    
    
	public void writeLog();
}
 
//数据库日志记录器：具体产品
class DatabaseLogger implements Logger {
    
    
	public void writeLog() {
    
    
		System.out.println("数据库日志记录。");
	}
}
 
//文件日志记录器：具体产品
class FileLogger implements Logger {
    
    
	public void writeLog() {
    
    
		System.out.println("文件日志记录。");
	}
}
 
//日志记录器工厂接口：抽象工厂
interface LoggerFactory {
    
    
	public Logger createLogger();
}
 
//数据库日志记录器工厂类：具体工厂
class DatabaseLoggerFactory implements LoggerFactory {
    
    
	public Logger createLogger() {
    
    
			//连接数据库，代码省略
			//创建数据库日志记录器对象
			Logger logger = new DatabaseLogger(); 
			//初始化数据库日志记录器，代码省略
			return logger;
	}	
}
 
//文件日志记录器工厂类：具体工厂
class FileLoggerFactory implements LoggerFactory {
    
    
	public Logger createLogger() {
    
    
            //创建文件日志记录器对象
			Logger logger = new FileLogger(); 
			//创建文件，代码省略
			return logger;
	}	
}

客户端测试代码：


class Client {
    
    
	public static void main(String args[]) {
    
    
		LoggerFactory factory;
		Logger logger;
		factory = new FileLoggerFactory(); //可引入配置文件实现
		logger = factory.createLogger();
		logger.writeLog();
	}

总结:

工厂方法模式是简单工厂模式的延伸，它继承了简单工厂模式的优点，同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一，是很多开源框架和API类库的核心模式。

四、抽象工厂模式

工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是下面要说的抽象工厂模式的基本思想。

角色：

AbstractFactory（抽象工厂）：声明了一组用于创建一族产品的方法，每一个方法对应一种产品。
ConcreteFactory（具体工厂）：实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
AbstractProduct（抽象产品）：为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。

ConcreteProduct（具体产品）：定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

在抽象工厂中声明了多个工厂方法，用于创建不同类型的产品，抽象工厂可以是接口，也可以是抽象类或者具体类。

示例：

产品类：

/**
 *按钮接口：抽象产品
 */
interface Button {
    
    
	public void display();
}
 
//Spring按钮类：具体产品
class SpringButton implements Button {
    
    
	public void display() {
    
    
		System.out.println("显示浅绿色按钮。");
	}
}
 
//Summer按钮类：具体产品
class SummerButton implements Button {
    
    
	public void display() {
    
    
		System.out.println("显示浅蓝色按钮。");
	}	
}

 
/**
 *文本框接口：抽象产品
 */
interface TextField {
    
    
	public void display();
}
 
//Spring文本框类：具体产品
class SpringTextField implements TextField {
    
    
	public void display() {
    
    
		System.out.println("显示绿色边框文本框。");
	}
}
 
//Summer文本框类：具体产品
class SummerTextField implements TextField {
    
    
	public void display() {
    
    
		System.out.println("显示蓝色边框文本框。");
	}	
}
 

/**
 *组合框接口：抽象产品
 */
interface ComboBox {
    
    
	public void display();
}
 
//Spring组合框类：具体产品
class SpringComboBox implements ComboBox {
    
    
	public void display() {
    
    
		System.out.println("显示绿色边框组合框。");
	}
}
 
//Summer组合框类：具体产品
class SummerComboBox implements ComboBox {
    
    
	public void display() {
    
    
		System.out.println("显示蓝色边框组合框。");
	}	
}

工厂类：



 
//界面皮肤工厂接口：抽象工厂
interface SkinFactory {
    
    
	public Button createButton();
	public TextField createTextField();
	public ComboBox createComboBox();
}
 
//Spring皮肤工厂：具体工厂
class SpringSkinFactory implements SkinFactory {
    
    
	public Button createButton() {
    
    
		return new SpringButton();
	}
 
	public TextField createTextField() {
    
    
		return new SpringTextField();
	}
 
	public ComboBox createComboBox() {
    
    
		return new SpringComboBox();
	}
}
 
//Summer皮肤工厂：具体工厂
class SummerSkinFactory implements SkinFactory {
    
    
	public Button createButton() {
    
    
		return new SummerButton();
	}
 
	public TextField createTextField() {
    
    
		return new SummerTextField();
	}
 
	public ComboBox createComboBox() {
    
    
		return new SummerComboBox();
	}
}

总结：

抽象工厂模式是工厂方法模式的进一步延伸，由于它提供了功能更为强大的工厂类并且具备较好的可扩展性，在软件开发中得以广泛应用，尤其是在一些框架和API类库的设计中，例如在Java语言的AWT（抽象窗口工具包）中就使用了抽象工厂模式，它使用抽象工厂模式来实现在不同的操作系统中应用程序呈现与所在操作系统一致的外观界面。
缺点
增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

五、总结

三种工厂模式有各自的应用场景，实际应用时能解决问题满足需求即可，可灵活变通，无所谓高级与低级。
此外无论哪种模式，由于可能封装了大量对象和工厂创建，新加产品需要修改已定义好的工厂相关的类，因此对于产品和工厂的扩展不太友好，利弊需要权衡一下。
Spring 中的 BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得 Bean 对象。
附部分源码感兴趣的同学可以自己去看一下源码

@Override
public Object getBean(String name) throws BeansException {
    
    
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    
    
 // 尝试通过bean名称获取目标bean对象，比如这里的A对象
 Object sharedInstance = getSingleton(beanName);
 
 // 我们这里的目标对象都是单例的
 if (mbd.isSingleton()) {
    
    
  // 这里就尝试创建目标对象，第二个参数传的就是一个ObjectFactory类型的对象，这里是使用Java8的lamada
  // 表达式书写的，只要上面的getSingleton()方法返回值为空，则会调用这里的getSingleton()方法来创建
  // 目标对象
  sharedInstance = getSingleton(beanName, () -> {
    
    
   try {
    
    
    // 尝试创建目标对象
    return createBean(beanName, mbd, args);
   } catch (BeansException ex) {
    
    
    throw ex;
   }
  });
 }
 return (T) bean;

如果将应用程序自己的工厂对象交给Spring管理,那么Spring管理的就不是普通的bean, 而是一个工厂Bean。这样的模式就是工厂方法模式。流程就是先从Spring中获取到工厂类，然后在获取具体的产品实例。