设计模式---工厂模式

目录

工厂模式概述

 简单工厂模式

工厂方法模式(Factory Method)

 抽象工厂模式(Abstract Factory)

案例

 使用前

使用后

应用场景

---

工厂模式概述

工厂方法模式(Factory Method Pattern)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式(Factory Pattern)，又可称作虚拟构造器模式(Virtual Constructor Pattern)或多态工厂模式(Polymorphic Factory Pattern)。工厂方法模式是一种类创建型模式。

工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：

• 简单工厂模式(Simple Factory)
• 工厂方法模式(Factory Method)
• 抽象工厂模式(Abstract Factory)

这三种模式从上到下逐步抽象，并且更具一般性。还有一种分类法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。下面是使用工厂模式的两种情况：

• 在编码时不能预见需要创建哪种类的实例。
• 系统不应依赖于产品类实例如何被创建、组合和表达的细节

术语

• Model 模型

• Factory 模型工厂

通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系

 简单工厂模式

下面我们使用手机生产来讲解该模式：

 Phone类：手机标准规范类(AbstractProduct)

public interface Phone {
    void make();
}

MiPhone类：制造小米手机（Product1）

public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}

IPhone类：制造苹果手机（Product2）

public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
}

PhoneFactory类：手机代工厂（Factory）

public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}

演示：

public class Demo {
   public static void main(String[] arg) {
       PhoneFactory factory = new PhoneFactory();
       Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
       IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
   }
}

工厂方法模式(Factory Method)

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，其UML类图如下：

 

也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。

接下来继续使用生产手机的例子来讲解该模式。

其中和产品相关的Phone类、MiPhone类和IPhone类的定义不变。

AbstractFactory类：生产不同产品的工厂的抽象类 

public interface AbstractFactory {
    Phone makePhone();
}

XiaoMiFactory类：生产小米手机的工厂（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

AppleFactory类：生产苹果手机的工厂（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

演示：

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}

总结

简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中，根据参数的类型进行实例化，同时不存在抽象接口。而后者则增加了抽象工厂，通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品，这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则

 抽象工厂模式(Abstract Factory)

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品Phone（AbstractProduct），如果要生成另一种产品PC，应该怎么表示呢？

最简单的方式是把2中介绍的工厂方法模式完全复制一份，不过这次生产的是PC。但同时也就意味着我们要完全复制和修改Phone生产管理的所有代码，显然这是一个笨办法，并不利于扩展和维护。

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。

 

从上面类图结构中可以清楚的看到如何在工厂方法模式中通过增加新产品接口来实现产品的增加的。

接下来我们继续通过小米和苹果产品生产的例子来解释该模式。

为了弄清楚上面的结构，我们使用具体的产品和工厂来表示上面的UML类图，能更加清晰的看出模式是如何演变的：

 PC类：定义PC产品的接口(AbstractPC)

public interface PC {
    void make();
}

MiPC类：定义小米电脑产品(MIPC)

public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}

MAC类：定义苹果电脑产品(MAC)

public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}

下面需要修改工厂相关的类的定义：

AbstractFactory类：增加PC产品制造接口

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

XiaoMiFactory类：增加小米PC的制造（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

AppleFactory类：增加苹果PC的制造（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

演示：

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}

总结：

抽象工厂模式是工厂方法模式的升级版，后者面向单个产品，而前者面向的的是一个产品族。根据官方定义：为创建一组相关/互相依赖的对象提供一个接口而无需指定它们的具体类。
比如一个汽车工厂要生成骑车，而每种汽车都有车门、车轮胎等一系列产品，这意味着每增加一款汽车就需要增加一个新的工厂来提供新产品的实现。这时候就可以使用抽象工厂模式来进行设计。抽象工厂模式适用于一系列产品族。

案例

需求：一个披萨制作的项目，要求该项目易于扩展维护；

• 能够生产出美式披萨、中式披萨...
• 披萨制作过程包含原材料准备、烘培、切割、打包
• 可生成披萨订单

 使用前

public interface Pizza {
    void pre();

    void bake();

    void cut();

    void box();
}

/**
 * 中式披萨
 */
class ChinesePizza implements Pizza {

    public ChinesePizza() {
        this.pre();
        this.bake();
        this.cut();
        this.box();
    }

    @Override
    public void pre() {
        System.out.println("中式披萨材料准备...");
    }

    @Override
    public void bake() {
        System.out.println("中式披萨烘培...");
    }

    @Override
    public void cut() {
        System.out.println("中式披萨的切片...");
    }

    @Override
    public void box() {
        System.out.println("中式披萨包装盒包装");
    }
}

/**
 * 美式披萨
 */
class AmericaPizza implements Pizza {
    public AmericaPizza() {
        this.pre();
        this.bake();
        this.cut();
        this.box();
    }

    @Override
    public void pre() {
        System.out.println("美式 披萨材料准备...");
    }

    @Override
    public void bake() {
        System.out.println("美式 披萨烘培...");
    }

    @Override
    public void cut() {
        System.out.println("美式 披萨的切片...");
    }

    @Override
    public void box() {
        System.out.println("美式 披萨包装盒包装");
    }
}

class JapanPizza implements Pizza {
    public JapanPizza() {
        this.pre();
        this.bake();
        this.cut();
        this.box();
    }

    @Override
    public void pre() {
        System.out.println("日式 披萨材料准备...");
    }

    @Override
    public void bake() {
        System.out.println("日式 披萨烘培...");
    }

    @Override
    public void cut() {
        System.out.println("日式 披萨的切片...");
    }

    @Override
    public void box() {
        System.out.println("日式 披萨包装盒包装");
    }
}


public class PizzaFactory {
    public static Pizza createPizza(int no){
        switch (no){
            case 1:
                return new ChinesePizza();
            case 2:
                return new AmericaPizza();
            case 3:
                return new JapanPizza();
        }
        return null;
    }
}


public class Client {
    public static void main(String[] args) {
        Pizza chinaPizza = PizzaFactory.createPizza(1);

        System.out.println("=============================");
        Pizza americaPizza = PizzaFactory.createPizza(2);

        System.out.println("=============================");
        Pizza japanPizza = PizzaFactory.createPizza(3);
    }
}

使用后

public interface Pizza {
    void pre();

    void bake();

    void cut();

    void box();
}

/**
 * 中式披萨
 */
class ChinesePizza implements Pizza {

    @Override
    public void pre() {
        System.out.println("中式披萨材料准备...");
    }

    @Override
    public void bake() {
        System.out.println("中式披萨烘培...");
    }

    @Override
    public void cut() {
        System.out.println("中式披萨的切片...");
    }

    @Override
    public void box() {
        System.out.println("中式披萨包装盒包装");
    }
}

/**
 * 美式披萨
 */
class AmericaPizza implements Pizza {

    @Override
    public void pre() {
        System.out.println("美式 披萨材料准备...");
    }

    @Override
    public void bake() {
        System.out.println("美式 披萨烘培...");
    }

    @Override
    public void cut() {
        System.out.println("美式 披萨的切片...");
    }

    @Override
    public void box() {
        System.out.println("美式 披萨包装盒包装");
    }
}

class JapanPizza implements Pizza {

    @Override
    public void pre() {
        System.out.println("日式 披萨材料准备...");
    }

    @Override
    public void bake() {
        System.out.println("日式 披萨烘培...");
    }

    @Override
    public void cut() {
        System.out.println("日式 披萨的切片...");
    }

    @Override
    public void box() {
        System.out.println("日式 披萨包装盒包装");
    }
}



public class PizzaFactory {
    public static Pizza createPizza(int no){
        Pizza pizza = null;
        switch (no){
            case 1:
                pizza = new ChinesePizza();
                break;
            case 2:
                pizza = new AmericaPizza();
                break;
            case 3:
                pizza = new JapanPizza();
                break;
        }
        if (pizza == null){
            System.out.println("没有此披萨订购服务");
        }else {
            pizza.pre();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
        return pizza;
    }
}


public class Client {
    public static void main(String[] args) {
        Pizza chinaPizza = PizzaFactory.createPizza(1);

        System.out.println("=============================");
        Pizza americaPizza = PizzaFactory.createPizza(2);

        System.out.println("=============================");
        Pizza japanPizza = PizzaFactory.createPizza(3);

        System.out.println("=============================");
        Pizza otherPizza = PizzaFactory.createPizza(4);
    }
}

使用前后代码对比：

前者将对象初始化的工作交给了对象的构造函数完成；

后者将初始化的过程交给了工厂类完成；

这么做的好处在于解耦自身对象实例化和对象初始化动作，还有一个因素在于构造函数的初始化会影响到子类；

注意事项及细节

将对象的初始化交给工厂类 构造函数初始化会影响到子类，耦合度过高

应用场景

spring中Bean的生命周期（单例多例bean初始化源码剖析）

public class InstanceFactory {
	public void init() {
		System.out.println("初始化方法");
	}
	
	public void destroy() {
		System.out.println("销毁方法");
	}
	
	public void service() {
		System.out.println("业务方法");
	}
}

<bean id="instanceFactory" class="com.lx.single.demo.InstanceFactory"
		scope="prototype" init-method="init" destroy-method="destroy"></bean>

/**
 * Bean的生命周期
		单例对象
			出生：当容器创建时对象出生
			活着：只要容器还在，对象一直活着
			死亡：容器销毁，对象消亡
			总结：单例对象的生命周期和容器相同
		多例对象
			出生：当我们使用对象时Spring框架为我们创建
			活着：对象只要是在使用过程中就一直活着
			死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收
 * 
 * @author Administrator
 *
 */
public class Demo2 {
	
//	单例对象与多例对象的初始化时间不一样	通过scope属性来演示
	@Test
	public void test1() {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
	}
	
//	单例对象与多例对象的初始化时间不一样	通过scope属性来演示
	@Test
	public void test2() {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
		InstanceFactory i1 = (InstanceFactory) applicationContext.getBean("instanceFactory");
		i1.service();
//		scope="prototype"，容器关闭不会自动销毁bean对象
		applicationContext.close();
	}
	
	/**
	 * 说明了两点：
	 * scope的值对应的是两个工厂类，生产javabean的模式一样；
	 * 1.一个是单例一个是多例
	 * 2.一个是立即初始化，一个是使用初始化
	 * 反正要初始化一次，干脆把所有的初始化操作放到监听器里面去，提高系统应用的性能
	 * 多例本身会耗性能，那么就尽可能在使用的时候再去创造对象
	 */
	@Test
	public void test3() {
//		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
		
		Resource resource = new ClassPathResource("/spring-context.xml");
		BeanFactory beanFactory = new XmlBeanFactory(resource );
		InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
	}
}

至此，工厂模式介绍完毕，由于作者水平有限难免有疏漏，欢迎留言纠错。