2.Java设计模式-----抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式（Abstract Factory），是23种设计模式之一。抽象工厂模式是这样子定义的：

抽象工厂模式，提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

       在学习抽象工厂模式之前，最好熟悉简单工厂模式以及工厂方法模式，这样对理解抽象工厂模式会有一定帮助，而且抽象工厂模式是基于工厂方法模式而来的。如果你还没有了解到什么是简单工厂模式以及工厂方法模式，你可以去了解一下：1.大白话讲解-----工厂方法模式（Factory Pattern）     工厂模式------关心的是结果

       你可能看着上面的定义，一时无法理解它到底是什么意思。 你可以接着继续往下面看，看了这个实例，我相信你应该就能够理解上面这句话的含义了。

现在我们有一个新的需求：

        ①现在我有一套系统，系统里面分别用到了MySQL和Oracle数据库。

        ②我需要对这两套数据库进行相同的操作，比如：我要对MySQL和Oracle进行用户信息的相同操作（insert，get用户信息等）

现在既然已经有了相关的需求，那我们现在就可以来对该需求进行一些简单的分析：

        ①数据库两套：MySQL、Oracle

        ②分别要对两套数据库中的数据，都进行insert操作、get信息操作

接下来，我们就来按照我们平常的思路，来编写一下代码了。

①我们现在分别有两个类MySQLUser类、OracleUser类，然后类里都有insertUser()和getUser()方法来实现相关操作

//1.MySQLUser.java
public class MySQLUser {
    public void insertUser(){
        System.out.println("我是MySQL中的insert方法");
    }
    public void getUser(){
        System.out.println("我是MySQL中的getUser方法");
    }
}
//2.OracleUser.java
public class OracleUser {
    public void insertUser(){
        System.out.println("我是Oracle中的insertUser方法");
    }
    public void getUser(){
        System.out.println("我是Oracle中的getUser方法");
    }
}

然后我们在main方法中测试一下：

public class Test {
    public static void main(String[] args) {
        MySQLUser mysql = new MySQLUser();
        mysql.getUser();//打印结果：我是MySQL中的getUser方法
        mysql.insertUser();//打印结果：我是MySQL中的insert方法
        OracleUser oracle = new OracleUser();
        oracle.getUser();//打印结果：我是Oracle中的getUser方法
        oracle.insertUser();//打印结果：我是Oracle中的insertUser方法
    }
}

如上结果，完全可以实现我们的功能。但是，看上去确实有点太low了。如果我有10个乃至100个地方需要用到mysql对象，那么我每次都需要new MySQLUser()才能够获取到一个mysql对象，然后对其进行操作。借用工厂方法模式，我们可以来一个工厂方法Factory来帮助我们去创建mysql对象和oracle对象。

②接下来，我们可以将其进一步进行修改。

       1.从MySQLUser类和OracleUser类中抽取出一个IUser接口，接口包括insertUser()和getUser()抽象方法

       2.MySQLUser类和OracleUser类，分别实现IUser接口，然后重写insertUser()和getUser()方法

       3.创建MySQLFactory和OracleFactory工厂类，主要用来创建用户，从工厂类中可以抽取出一个IFactory接口，接口包括createUser()抽象方法

       4.MySQLFactory类和OracleFactory类，分别实现IFactory接口，并且重写createUser()方法

       5.进行测试

代码实现具体如下：

//1.IUser接口
public interface IUser {
    public void insertUser();
    public void getUser();
}

//2.1 MySQLUser类实现IUser
public class MySQLUser implements IUser {
    @Override
    public void insertUser(){
        System.out.println("我是MySQL中的insert方法");
    }
    @Override
    public void getUser(){
        System.out.println("我是MySQL中的getUser方法");
    }
}
//2.2 OracleUser类实现IUser
public class OracleUser implements IUser {
    @Override
    public void insertUser(){
        System.out.println("我是Oracle中的insertUser方法");
    }
    @Override
    public void getUser(){
        System.out.println("我是Oracle中的getUser方法");
    }
}

//3.IFactory接口
public interface IFactory {
    public IUser createUser();
}

//4.1 MySQLFactory类实现IFactory 
public class MySQLFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new MySQLUser();
    }
}
//4.2 OracleFactory类实现IFactory 
public class OracleFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new OracleUser();
    }
}

//5.测试
public class Test01 {
    public static void main(String[] args) {
        IFactory factory = new MySQLFactory();
        IUser user = factory.createUser();
        user.insertUser(); //打印结果：我是MySQL中的insert方法
        user.getUser();//打印结果：我是MySQL中的getUser方法
    }
}

       如果现在我不用MySQL了，目前要换成Oracle，则只需要将new MySQLFactory()换成new OracleFactory()即可。你会发现这完全就是工厂方法模式。对的。就是工厂方法模式的实现。我们开头就说到：抽象工厂模式是基于工厂方法模式而来的。接下来，我们再继续向着抽象工厂模式继续演进吧

③现在我们又有了新的需求：

          现在MySQL和Oracle中，都有一张日志Log表，我们在insertUser之后，都要向日志表中添加一条数据

    现在我们来对这个需求进行一下简单的分析：

          1.之前MySQLUser和OracleUser分别有一个insertUser()和getUser()方法，目前它们都需要往日志表中添加日志

          2.所以我们现在抽取出一个ILog接口，接口中有一个insertLog()抽象方法

          3.新建一个MySQLLog类和OracleLog类，分别实现ILog接口，然后重写insertLogr()方法

          4.之前IFactory接口已有createUser()功能的情况下，在该接口中新增一个createLog()抽象方法，来满足插入日志的功能

          5.MySQLFactory类和OracleFactory类，因为实现了IFactory接口，需要重写createLog()方法

          6.开启测试

//2.ILog接口
public interface ILog {
    public void insertLog();
}

//3.1 MySQLLog实现ILog接口
public class MySQLLog implements ILog {
    @Override
    public void insertLog() {
        System.out.println("我是MySQL中的insertLog方法");
    }
}
//3.2 OracleLog实现ILog接口
public class OracleLog implements ILog {
    @Override
    public void insertLog() {
        System.out.println("我是Oracle中的insertLog方法");
    }
}

//4.IFactory接口新增createLog()方法
public interface IFactory {
    public IUser createUser();
    public ILog createLog();
}

//5.1 MySQLFactory工厂类重写新增的createLog()方法
public class MySQLFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new MySQLUser();
    }
    @Override
    public ILog createLog() {
        return new MySQLLog();
    }
}
//5.2 OracleFactory工厂类重写新增的createLog()方法
public class OracleFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new OracleUser();
    }
    @Override
    public ILog createLog() {
        return new OracleLog();
    }
}

//6.开启测试
public class Test02 {
    public static void main(String[] args) {
        IFactory factory = new MySQLFactory();
        IUser mysql = factory.createUser();
        mysql.getUser(); //打印结果：我是MySQL中的getUser方法

        ILog log = factory.createLog();
        log.insertLog(); //打印结果：我是MySQL中的insertLog方法
    }
}

④我们现在有个改变，就是说在③中第6步测试中，我们现在业务要废弃MySQL而使用Oracle了，现在我们只需要将第6步中的new MySQLFactory() 换成 new OracleFactory()即可。而无需改动其他代码，就能够解决业务的变动，这就已经明显解决了与具体数据库之间的耦合关系

⑤如果我们现在又要换成SqlServer呢。则我们现在只需要实现如下几步，即可满足要求

         1.创建一个SqlServerUser，来实现已写好的IUser接口，并重写其中的insertUser()和getUser()方法。

         2.创建一个SqlServerFactory，实现已写好的IFactory接口，并重写其中的createUser()方法。

         3.在③中第6步测试中，直接将new MySQLFactory()换成new SqlServerFactory()即可。

         4.这样就可以最大程度上解决功能与业务代码之间的耦合，将修改工作量降到最低。

⑥实际上我们这次代码的重构中，已经使用到了抽象工厂模式，抽象工厂可能表面上看起来貌似与工厂方法模式没什么区别的。所以，抽象工厂模式是基于工厂方法模式而来的。现在你在重头来看一下抽象工厂模式的定义：抽象工厂模式，提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。你也许可能就会有所体会

⑦在该实例中，你完全可以理解成是多个工厂方法的组合。

⑧抽象工厂模式的优点：

        1.方便交换产品系列，诸如在本实例中，如果现在业务需求需要将MySQL替换为Oracle或者SqlServer，你只需要将new MySQLFactory()替换为new OracleFactory()或者new SqlServerFactory()即可满足要求。这样可以在保证在最小改动的情况下而完成对整体业务的修改，起到了最大程度的解耦操作。

        2.在实现过程(xxxFactory类中)和具体使用中(测试类中),我们通过向上造型用到IFactory，IUser，ILog类，我们在具体使用中就用到了上面三个类，我们通过factory.createUser()来创建用户，通过factory.createLog()来插入日志。如果没有new xxxFactory()的话，我们完全不知道我们是在操作哪个类型的数据库，从而达到了实现类和使用之间的隔离。

⑨抽象工厂模式的缺点：

         在我们每次需要createUser和createLog的时候，我们都需要通过IFactory factory = new xxxFactory()；来获取到factory对象，然后对其进行相关的操作。如果我现在有100个地方需要使用，则需要来100次new操作，这显然是太扯淡了。这算的上一个缺点吧。

⑩面对⑨中的缺点，我们该如何解决这种问题？

       我们可以使用反射机制来解决，可以参考1.大白话讲解-----工厂方法模式（Factory Pattern）中的⑩部分来做出修改，这就是抽象工厂方法了。

附：全文实例结构图：

Demo实例地址： https://download.csdn.net/download/lzb348110175/11147854

---->如有疑问，请发表评论，或者联系博主：[email protected]，欢迎哦^_^