工厂模式是最为常用的设计模式了,不必多说,以前断断续续学了好多遍,今天在学过框架理解的基础上做个总结。首先来看简单工厂模式。
一.简单工厂模式
简单工厂模式又叫静态工厂方法模式,他定义一个具体的工厂类来负责创建类的对象,将对象的创建过程封装起来,而这些被创建的类有一个共同的接口,从而实现面向接口编程。
当一个对象的创建和初始化工作比较复杂或则一个对象反复创建,采用简单工厂模式是很好的选择,在工程中会大量减少重复代码的出现。Spring中就是用XML或java注解来表示Bean之间的依赖关系,而不用new创建对象,其采用的就是工厂模式的思想。
下面我举个例子,直接看代码
public interface Product {//定义一个商品接口
void operation();
}
public class Product1 implements Product{//其中一个实现类
@Override
public void operation() {
System.out.println("operation1");
}
}
public class Product2 implements Product{//另一个实现类
@Override
public void operation() {
System.out.println("operation2");
}
}
public class SimpleFactory {//工厂类
Product product = null;
public Product createProduct(String type){
try {//这里通过反射根据传进来的参数创建实例
product = (Product) Class.forName(type).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return product;
}
public static void main(String[] args) {//方便起见,没有单独写测试类
SimpleFactory simpleFactory = new SimpleFactory();
Product product1 = simpleFactory.createProduct("com.easy.singleton.Product1");
System.out.println(product1);
}
}
为了更清晰的描述各个类之间的关系,我画了个UML图,第一次画,有点丑==
简单工厂模式很好的将对象的创建和使用分离开了,但是如果要创建的对象的初始化比较复杂,而且不同对象的创建又有很大的不同,这时如果再使用简单工厂模式,这个工厂类就会变得非常庞大,这时候我们就要采用解耦的原则,将对象的创建也单独分离出来,这就是工厂方法模式。
二.工厂方法模式
每一个产品都有一个具体的工厂来创建,把简单工厂模式中庞大的工厂类拆分成一个个工厂类,这样每个具体的小工厂只负责单独对象的创建,职责就变小了,这就是工厂方法模式。
下面看代码,其中Product的接口和实现类还依然采用上面的。
public interface Factory {//抽象出的统一的工厂类的接口
public Product createProduct();
}
public class Product1Factory implements Factory{
//1的工厂类
@Override
public Product createProduct() {
return new Product1();
}
}
public class Product2Factory implements Factory{
//二的工厂类
@Override
public Product createProduct() {
return new Product2();
}
}
public class Test { //测试类
public static void main(String[] args) {
Factory factory = new Product1Factory();
Product product = factory.createProduct();
System.out.println(product);
}
}
可以看出,工厂方法模式对于简单工厂模式来说,就是把一个单一的工厂类,分成多个小工厂,并抽象出一个工厂接口,这个接口只负责定义创建的方式,至于创建的具体内容由继承的小工厂类来实现。
三.抽象工厂模式
试想这样一个场景,如果如果有两种牌子的产品,ProductA,ProductB,每个牌子下又有不同种类的产品,PruductA1,ProductA2,ProductB1,ProductB2,那么,按照原来的工厂方法模式,就会有两个工厂接口,四个工厂类,如果产品牌子更多,每个牌子下各种种类的产品更多,那么工厂类的数量就会变得非常多,抽象类之间的关联也会变得越来越复杂,前辈们就想出抽象工厂模式来解决这个问题。先看代码吧:
//定义商品A的接口
public interface ProductA {
void operation();
}
//商品B的接口
public interface ProductB {
void operation();
}
public class ProductA1 implements ProductA{
//商品A1的实现类
@Override
public void operation() {
System.out.println("ProductA1 operation");
}
}
public class ProductA2 implements ProductA{
//商品A2的实现类
@Override
public void operation() {
System.out.println("ProductA2 operation");
}
}
public class ProductB1 implements ProductB{
//商品B1的实现类
@Override
public void operation() {
System.out.println("ProductB1 operation");
}
}
public class ProductB2 implements ProductB{
//商品B2的实现类
@Override
public void operation() {
System.out.println("ProductB2 operation");
}
}
public interface AbstractFactory { //抽象工厂接口,
//将AB商品的生产抽象到一个接口中
ProductA createProductA();
ProductB createProductB();
}
public class Product1Factory implements AbstractFactory{
//商品一工厂实现类
@Override
public ProductA createProductA() {
ProductA productA = new ProductA1();
return productA;
}
@Override
public ProductB createProductB() {
ProductB productB = new ProductB1();
return productB;
}
}
public class Product2Factory implements AbstractFactory{
//商品二工厂的实现类
@Override
public ProductA createProductA() {
ProductA productA = new ProductA2();
return productA;
}
@Override
public ProductB createProductB() {
ProductB productB = new ProductB2();
return productB;
}
}
public class Test {
//测试类
public static void main(String[] args) {
AbstractFactory product1Factory = new Product1Factory();
ProductA1 productA1 = (ProductA1) product1Factory.createProductA();
System.out.println(productA1);
AbstractFactory product2Factory = new Product2Factory();
ProductA2 productA2 = (ProductA2) product2Factory.createProductA();
System.out.println(productA2);
}
}
测试结果://这里为了方便输出直接是产品的哈希码
com.easy.factory.ProductA1@557531fd
com.easy.factory.ProductA2@7ac4b626
可以看到,抽象工厂模式相对于工厂方法模式来说,就是工厂方法模式是针对一个产品系列的,而抽象工厂模式是针对多个产品系列的,即工厂方法模式是一个产品系列的工厂类,而抽象工厂模式是多个产品系列的一个工厂类。以上这些工厂模式,核心的一个思想就是解耦,让调用者使用的简单,使用者不负责对象的创建,只负责对象的调用,这样一来,各个模块也利于后期的维护,从而明确了各个类的职责。
对于抽象工厂模式,当一系列的相互关联的产品被设计到一个工厂类后,当修改这个系列的产品,那么只修改相应工厂类即可。下面我画一个UML图看着更清晰。
我觉得以图这种方式记忆对于一些思维方式的人可能更好。设计模式理论偏多,我觉得以实践来理解才会有更深的理解,看一些大神写的开源框架或源码是很好的学习方式,等我整理完,再与大家一起分享。