设计模式之工厂模式VS抽象工厂

一、工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）：不利于产生系列产品；

2）工厂方法模式（Factory Method）：又称为多形性工厂；

3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；
             这三种模式从上到下逐步抽象，并且更具一般性。
             GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

二、简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

        先来看看它的组成：

         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

三、工厂方法模式

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
　　来看下它的组成：

       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！

代码：

package cn.happy.b;
//抽象产品角色
public class LeiFeng {
    public void sweep(){
        System.out.println("扫地");
    }
    public void wash(){
        System.out.println("洗衣服");
    }
}

package cn.happy.b;
//具体产品角色
public class Student extends LeiFeng{

}

package cn.happy.b;
//具体产品角色
public class Volunter extends LeiFeng{

}

package cn.happy.b;
//抽象工厂
public interface IFactory {
    public LeiFeng getLeiFeng();
}

package cn.happy.b;
//具体工厂
public class StudentFactory implements IFactory{

    @Override
    public LeiFeng getLeiFeng() {        
        return new Student();
    }

}

package cn.happy.b;
//具体工厂
public class VolunterFactory implements IFactory{

    @Override
    public LeiFeng getLeiFeng() {
        
        return new Volunter();
    }

}

package cn.happy.b;

//测试类
public class Test {

    public static void main(String[] args) {
        IFactory factory=new StudentFactory();
        //IFactory factory=new VolunterFactory();
        LeiFeng stu=factory.getLeiFeng();
        stu.wash();
        stu.sweep();

    }

}

工厂方法定义：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到了子类

在简单工厂中，工厂类与分支耦合，所以我们就对工厂类下手，把工厂类抽象出一个接口，

这个接口只有一个方法，就是创建抽象产品的工厂方法，然后所有要生产具体的工厂，都实现这个接口，这样简单工厂的工厂类就变成了一个工厂抽象接口和多个具体生产对象的工厂，要增加功能，就不需要更改原来的工厂类，之需要增加此功能的类和相应的工厂类就可以了

四、简单工厂和工厂方法模式的比较

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。 
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

五、抽象工厂模式

定义：

提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类

抽象工厂模式：

 

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。

 

抽象工厂模式与工厂方法模式的区别

 

        抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

 

        在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。我们依然拿生产汽车的例子来说明他们之间的区别。

在上面的类图中，User和Student是两个抽象产品，之所以为抽象，是因为他们都有可能有两种不同的实现，而SqlUser、AccessUser和SqlStudent、AccessStudent

就是对这两个抽象产品的具体分类

IFactory是一个抽象工厂接口，他里面应该包含所有产品创建的抽象方法，SqlFactory和AccessFatory就是具体工厂；

 

代码：

package cn.happy.c;

public class User {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

package cn.happy.c;

public class Student {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

package cn.happy.c;
/**
 * IUser接口，用于客户端访问，解除与具体数据库访问的耦合
 * @author 川哥哥
 *
 */
public interface IUser {
    public void insert(User user);
    public User getUser(int id);
}

package cn.happy.c;

public interface IStudent {
    public void insert(Student stu);
    public Student getUser(int id);
}

package cn.happy.c;

public class SqlUser implements IUser{

    @Override
    public void insert(User user) {
        System.out.println("sql中给user表添加一条记录");
    }

    @Override
    public User getUser(int id) {
        System.out.println("在sql中根据id得到一条记录");
        return null;
    }

}

package cn.happy.c;

public class AccessUser implements IUser{

    @Override
    public void insert(User user) {
        System.out.println("Access中给user表添加一条记录");
        
    }

    @Override
    public User getUser(int id) {
        System.out.println("在Access中根据id得到一条记录");
        return null;
    }

}

package cn.happy.c;

public class SqlStudent implements IStudent{

    @Override
    public void insert(Student stu) {
        System.out.println("在sql中给student表添加一条记录");
        
    }

    @Override
    public Student getUser(int id) {
        System.out.println("在sql中，根据Id得到一条记录");
        return null;
    }

}

package cn.happy.c;

public class AccessStudent implements IStudent{
    @Override
    public void insert(Student stu) {
        System.out.println("在Access中给student表添加一条记录");
        
    }

    @Override
    public Student getUser(int id) {
        System.out.println("在Access中，根据Id得到一条记录");
        return null;
    }
}

package cn.happy.c;
/**
 * 定义一个接口，创建访问user表对象的抽象工厂类
 * @author 川哥哥
 *
 */
public interface IFactory {
    public IUser creIUser();
    public IStudent greateStudent();
}

package cn.happy.c;
/**
 * 实现Ifactory接口，实例化SqlUser
 * @author 川哥哥
 *
 */
public class 
SqlFactory implements IFactory{

    @Override
    public IUser creIUser() {
        
        return new SqlUser();
    }

    @Override
    public IStudent greateStudent() {
        // TODO Auto-generated method stub
        return new SqlStudent();
    }
    

}

package cn.happy.c;

public class AccessFactory implements IFactory{

    @Override
    public IUser creIUser() {
        
        return new AccessUser();
    }

    @Override
    public IStudent greateStudent() {
        // TODO Auto-generated method stub
        return new AccessStudent();
    }

}

测试类

package cn.happy.c;

public class Test {

    public static void main(String[] args) {
        
        User user=new User();
        Student stu=new Student();
        IFactory factory=new SqlFactory();
        //IFactory factory=new AccessFactory();
        IUser iUser=factory.creIUser();
        IStudent is=factory.greateStudent();
        iUser.insert(user);
        iUser.getUser(1);
        is.insert(stu);
        is.getUser(1);
 }
}

运行结果：

sql中给user表添加一条记录
在sql中根据id得到一条记录
在sql中给student表添加一条记录
在sql中，根据Id得到一条记录

抽象工厂模式的优点

        抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

 

抽象工厂模式的缺点

       产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

 

适用场景

       当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

 

总结

       无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

       所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。