设计模式 | 抽象工厂模式及典型应用

抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。

在抽象工厂模式中，每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品。

角色

在抽象工厂模式包含如下几个角色：

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

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

具体工厂实现了抽象工厂，每一个具体的工厂方法可以返回一个特定的产品对象，而同一个具体工厂所创建的产品对象构成了一个产品族

示例

首先定义我们的抽象产品 Article 和 Video，他们是产品族的抽象类，有一个 Article 就有一个 Video

public abstract class Article {
    public abstract void produce();
}

public abstract class Video {
    public abstract void produce();
}

具体产品 JavaArticle、PythonArticle、PythonVideo、JavaVideo

public class JavaArticle extends Article {
    @Override
    public void produce() {
        System.out.println("编写Java课程笔记记");
    }
}

public class PythonArticle extends Article {
    @Override
    public void produce() {
        System.out.println("编写Python课程笔记");
    }
}

public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Java课程视频");
    }
}

public class PythonVideo extends Video {
    @Override
    public void produce() {
        System.out.println("录制Python课程视频");
    }
}

定义我们的抽象工厂 CourseFactory，与工厂方法模式不同，工厂方法模式中一个工厂只生产一个产品，而抽象工厂模式中一个工厂生产一族产品，有多个工厂方法

public interface CourseFactory {
    Video getVideo();
    Article getArticle();
}

具体工厂 JavaCourseFactory 和 PythonCourseFactory，它们都继承抽象工厂接口 CourseFactory

public class JavaCourseFactory implements CourseFactory {
    @Override
    public Video getVideo() {
        return new JavaVideo();
    }

    @Override
    public Article getArticle() {
        return new JavaArticle();
    }
}

public class PythonCourseFactory implements CourseFactory {
    @Override
    public Video getVideo() {
        return new PythonVideo();
    }

    @Override
    public Article getArticle() {
        return new PythonArticle();
    }
}

客户端只需要指定具体工厂，就可以获取该工厂生产的一族产品

public class Test {
    public static void main(String[] args) {
        CourseFactory courseFactory = new JavaCourseFactory();
        Video video = courseFactory.getVideo();
        Article article = courseFactory.getArticle();
        video.produce();
        article.produce();
    }
}

输出

录制Java课程视频
编写Java课程笔记

也可以利用反射机制和配置文件，当需要修改具体工厂的时候就不需要修改客户端代码，只改配置文件即可

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        // 从配置文件或数据库等外部渠道获取具体工厂类名
        String factoryName = "com.designpattern.JavaCourseFactory";
        // 通过反射机制获取工厂类
        Class c = Class.forName(factoryName);
        CourseFactory courseFactory = (CourseFactory) c.newInstance();
        Video video = courseFactory.getVideo();
        Article article = courseFactory.getArticle();
        video.produce();
        article.produce();
    }
}

最终的类图如下所示

示例.抽象工厂类图

抽象工厂模式总结

抽象工厂模式的主要优点如下：

• 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易，所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
• 增加新的产品族很方便，无须修改已有系统，符合"开闭原则"。

抽象工厂模式的主要缺点如下：

• 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了"开闭原则"。

适用场景：

• 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是很重要的，用户无须关心对象的创建过程，将对象的创建和使用解耦。
• 系统中有多于一个的产品族，而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。
• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束，如同一操作系统下的按钮和文本框，按钮与文本框之间没有直接关系，但它们都是属于某一操作系统的，此时具有一个共同的约束条件：操作系统的类型。
• 产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

抽象工厂模式的典型应用及源码分析

我们来看 java.sql 包下的 Connection 接口，该接口定义了与特定数据库的连接 Connection，执行 SQL statements 并返回 results

public interface Connection  extends Wrapper, AutoCloseable {
    Statement createStatement() throws SQLException;
    PreparedStatement prepareStatement(String sql) throws SQLException;
    CallableStatement prepareCall(String sql) throws SQLException;
    DatabaseMetaData getMetaData() throws SQLException;
    Savepoint setSavepoint() throws SQLException;
    Clob createClob() throws SQLException;
    Blob createBlob() throws SQLException;
    SQLXML createSQLXML() throws SQLException;
    // ...省略...
}

其中 Statement、PreparedStatement、CallableStatement、DatabaseMetaData、Savepoint、Clob、Blob、SQLXML 等均为接口

我们来看 Statement 接口

public interface Statement extends Wrapper, AutoCloseable {
    ResultSet executeQuery(String sql) throws SQLException;
    int executeUpdate(String sql) throws SQLException;
    void close() throws SQLException;
    int getMaxFieldSize() throws SQLException;
    boolean execute(String sql) throws SQLException;
    // ...省略...
}

其中的 ResultSet 又是一个接口

public interface ResultSet extends Wrapper, AutoCloseable {
    boolean next() throws SQLException;
    void close() throws SQLException;
    boolean wasNull() throws SQLException;
    String getString(int columnIndex) throws SQLException;
    //...省略...
}

我们可以看一下他们的实现类

Connection的实现类 Statement的实现类 ResultSet的实现类

可以看出这里边的抽象工厂模式，Connection 为抽象工厂，工厂方法很多，其中一个抽象产品为 Statement，同时 Statement 也是一个抽象工厂，工厂方法也很多，其中一个抽象产品为 ResultSet，具体工厂和具体产品则为他们的实现类

参考：
刘伟：设计模式Java版
慕课网java设计模式精讲 Debug 方式+内存分析

后记

欢迎评论、转发、分享，您的支持是我最大的动力

更多内容可访问我的个人博客：http://laijianfeng.org

关注【小旋锋】微信公众号，及时接收博文推送

关注_小旋锋_微信公众号