抽象工厂模式解析

学习了抽象工厂模式,我把自己所理解的抽象工厂模式拿出来和大家分享。

1.首先什么是抽象工厂模式？

   抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据LSP原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

2.抽象工厂模式的结构?

  1) 抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

  2) 具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

  3) 抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

  4) 具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑

3.在什么情况下使用抽象工厂模式？

 1） 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

 2）这个系统有多于一个的产品族，而系统只消费其中某一产品族。

 3）同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

 4）系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

 

4.实例来说明：

    以个人计算机来说明：

      产品族有两个 一个是pc(IMB 系列)一个是Mac(macintosh 系列) 电脑里面又有产品，CPU,RAM等。PCCPU与PCRAM都在PC机上，MacCPU，MacRAMMac机器上。这样中约束条件要在系统设计中体现出来，这样就满足了3里面的条件二和三。

   为了让思路更加的清晰，容易初学者 我们可以 按照抽象工厂模式的结构来做。

      1）建立一个抽象工厂类。

package com.demo.abstractFactory; public abstract class AbstractFactory { /** * 根据不同的个人计算机要求创建出不同的工厂 */ public static AbstractFactory getInstance(String productName){ AbstractFactory af=null; try { af = (AbstractFactory) Class.forName(productName).newInstance(); } catch (Exception e) { e.printStackTrace(); } return af; } /** * 建立创建CPU,RAM的抽象接口，由各实现的工厂来创建具体的CPU,RAM */ public abstract CPU createCPU(); public abstract RAM createRAM(); }

    2) 创建具体工厂类，这里有两个具体的工厂类 ，分别PCFactory，MacFactory

   package com.demo.abstractFactory; /** * 具体的实现Mac工厂 */ public class MacFactory extends AbstractFactory { @Override public CPU createCPU() { // 创建本体系中的CPU实现 return new MacCPU(); } @Override public RAM createRAM() { return new MacRAM(); } } 

package com.demo.abstractFactory; /** * 具体的实现PC工厂 */ public class PCFactory extends AbstractFactory { @Override public CPU createCPU() { // 创建本体系中的CPU实现 return new PCCPU(); } @Override public RAM createRAM() { return new PCRAM(); } }  

    3) 创建抽象产品类 CPU，RAM

        package com.demo.abstractFactory; /** * CPU类接口 */ public interface CPU { public void cpu(); }  

        package com.demo.abstractFactory; public interface RAM { public void ram(); }  

4) 创建具体产品类，也有分别有两个，它们是PCCPU，PCRAM，和MacCPU，MacRAM.

package com.demo.abstractFactory; /** * PC机cpu的业务实现 */ public class PCCPU implements CPU { public void cpu() { System.out.println("PC cpu....."); } } package com.demo.abstractFactory; public class PCRAM implements RAM { @Override public void ram() { System.out.println("PC ARM...."); } } package com.demo.abstractFactory; public class MacCPU implements CPU { public void cpu() { System.out.println("Mac CPU...."); } } package com.demo.abstractFactory; public class MacRAM implements RAM { @Override public void ram() { System.out.println("Mac RAM..."); } }  

在此抽象工厂模式实现了。

最后 测试类：

   package com.demo.abstractFactory; public class Test { /** * @param args */ public static void main(String[] args) { AbstractFactory af = AbstractFactory.getInstance("com.demo.abstractFactory.PCFactory"); CPU pcCPU = af.createCPU(); pcCPU.cpu(); RAM pcRAM=af.createRAM(); pcRAM.ram(); AbstractFactory af2=AbstractFactory.getInstance("com.demo.abstractFactory.MacFactory"); CPU macCPU = af2.createCPU(); macCPU.cpu(); RAM macRAM=af2.createRAM(); macRAM.ram(); } } 

当然还有测试结果：

  PC cpu.....

  PC ARM....

  Mac CPU....

  Mac RAM...

 

5.总结：

     通过上面的例子抽象工厂模式中可以理解为： 1）一个抽象工厂类，派生出多个具体的工厂类，比如PCFactory，MacFactory；

   2) 有多个抽象产品类（如：CPU,ARM），并且每个抽象产品类可以派生出多个具体产品类(PCCPU，MacCPU).

   3） 每个具体工厂类都可以创建多个具体产品类的实例。

 抽象工厂模式的优缺点：

 

优点：它分离了具体的类，它使得易于交换产品系列。

缺点：难以支持新种类的产品。

6.还有我们也可以像spring管理bean一样，对factory进行集中管理。

   1）加入一个配置文件。applicationContext.xml

    <beans> <bean id="pc" class="com.demo.abstractFactory.PCFactory" /> <bean id="mac" class="com.demo.abstractFactory.MacFactory" /> </beans> 

2）新建一个XmlBean 

package com.demo.abstractFactory; public class XmlBean { private String id; private String className; public XmlBean(String id2, String clazz) { this.id=id2; this.className=clazz; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getClassName() { return className; } public void setClassName(String className) { this.className = className; } } 

 

3）为了不影响上面的功能，重新建一个类 MyApplicationContext

 package com.demo.abstractFactory; import java.io.File; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.XPath; import org.dom4j.io.SAXReader; public class MyApplicationContext { private List<XmlBean> listBean = new ArrayList<XmlBean>(); private Map<String,Object> sigletons = new HashMap<String,Object>(); public MyApplicationContext(String fileName){ this.readXml(fileName); this.instanceBeans(); } private void readXml(String fileName) { SAXReader reader = new SAXReader (); Document doc=null; try { doc = (Document) reader.read(new File(fileName)); XPath xsub=doc.createXPath("//ns:beans/ns:bean"); List<Element> beans=xsub.selectNodes(doc); for (Element element : beans) { String id=element.attributeValue("id"); String clazz=element.attributeValue("class"); XmlBean xmlBean = new XmlBean(id,clazz); listBean.add(xmlBean); } } catch (Exception e) { e.printStackTrace(); } } private void instanceBeans() { try { for (XmlBean xmlBean : listBean) { if (null != xmlBean.getClassName()) { sigletons.put(xmlBean.getId(), Class.forName(xmlBean.getClassName()).newInstance()); } } } catch (Exception e) { e.printStackTrace(); } } public Object getBean(String beanName){ return sigletons.get(beanName); } }  

4）最后测试

   package com.demo.abstractFactory; public class Test { /** * @param args */ public static void main(String[] args) { // AbstractFactory af = AbstractFactory.getInstance("com.demo.abstractFactory.PCFactory"); // CPU pcCPU = af.createCPU(); // pcCPU.cpu(); // RAM pcRAM=af.createRAM(); // pcRAM.ram(); // AbstractFactory af2=AbstractFactory.getInstance("com.demo.abstractFactory.MacFactory"); // CPU macCPU = af2.createCPU(); // macCPU.cpu(); // RAM macRAM=af2.createRAM(); // macRAM.ram(); MyApplicationContext mctx= new MyApplicationContext("src/applicationContext.xml"); AbstractFactory af = (AbstractFactory)mctx.getBean("pc"); CPU cpu=af.createCPU(); cpu.cpu(); RAM ram=af.createRAM(); ram.ram(); AbstractFactory af2 = (AbstractFactory)mctx.getBean("mac"); CPU cpu2=af2.createCPU(); cpu2.cpu(); RAM ram2=af2.createRAM(); ram2.ram(); } } 

5）结果

 

PC cpu.....

PC ARM....

Mac CPU....

Mac RAM...

最后把factory集中管理起来成功。