Java设计模式——工厂模式

工厂模式和抽象工厂模式都属于创建型模式。

创建型模式
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

简单工厂模式

在简单工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
作用：

• 1、减少和复用代码：同一类复杂的对象（比如圆形、方形、三角形都属于图形；线性布局、相对布局都属于布局），如果它们在创建时都需要编写大量的步骤，那么可以考虑将它们的创建交给工厂去进行；

• 2、减少耦合度：两个类的关系最好是A创造B或者是A使用B，而不是A又创造B又使用B（单一职能原则）。比如我使用B时是直接new一个B对象，往后我们需求变更，需要将B替换为C，那么我就需要更改代码中new B为new C，这样的替换很麻烦也很容易出错。

优点：

• 1、一个调用者想创建一个对象，只要知道其名称就可以了；
• 2、屏蔽产品的具体实现，调用者只关心产品的接口；
• 3、简单粗暴，可以创建任何我们想要创建的对象。

缺点：

• 1、每次增加一个产品时，都需要修改工厂类，这违反了开闭原则，同时也增加了系统具体类的依赖。这并不是什么好事。

使用案例：
首先，我们现在有一个需求，要连接MySQL数据库，那么我们建一个连接MySQL数据库的类：

public class MySQLHelper {
    
    private String userName;
    private String passWord;
    
    public MySQLHelper(String userName, String password) {
        this.userName = userName;
        this.passWord = password;
    }
    
    public void setTimeout(long time) {
         //Set TimeOut
    }
    
    public void setSelectMode(String mode) {
        // Set SelectMode
    }
    
    public void setCache(String cache) {
        // Set Cache
    }

    public void connect() {
        // Connect SQL
    }

    // ...  更多初始化操作

}

现在，我们在AConnectSQL类和BConnectSQL类中分别用不同的账号密码连接数据库：

AConnectSQL：

public class AConnectSQL {
    
    public void connect() {
        MySQLHelper mySQLHelper = new MySQLHelper("jack", "123");
        mySQLHelper.setTimeout(1000);
        mySQLHelper.setSelectMode("A Mode");
        mySQLHelper.setCache("ALL");
        mySQLHelper.connect();
    }

}

BConnectSQL：

public class BConnectSQL {
        
    public void connect() {
        MySQLHelper mySQLHelper = new MySQLHelper("lucy", "456");
        mySQLHelper.setTimeout(1000);
        mySQLHelper.setSelectMode("A Mode");
        mySQLHelper.setCache("ALL");
        mySQLHelper.connect();
    }

}

以上代码存在两个问题：
1、每一次创建MySQLHelper时，都需要编写大量初始化代码；
2、如果项目需求改动，要求不再所有的数据库连接都连接MySQL，而改用部分连接MySQL，部分连接SQLite，此时就需要将部分连接MySQL的地方都改成连接SQLite，一个两个类还好改，要是有更多的类，那么不仅工作量巨大，而且极有可能造成问题隐患。

此时，工厂模式就可以很好的解决如上两个问题。

首先，我们先建一个接口SQLHelper，只有一个connectSQL方法用于连接数据库：

public interface SQLHelper {
    
    void connectSQL();
    
}

然后，让我们的MySQLHelper实现这个接口，在重写的connectSQL中调用connect方法连接数据库：

public class MySQLHelper implements SQLHelper{
    
    private String userName;
    private String passWord;
    
    public MySQLHelper(String userName, String password) {
        this.userName = userName;
        this.passWord = password;
    }
    
    public void setTimeout(long time) {
         //Set TimeOut
    }
    
    public void setSelectMode(String mode) {
        // Set SelectMode
    }
    
    public void setCache(String cache) {
        // Set Cache
    }

    public void connect() {
        // Connect SQL
    }

    // ...  更多初始化操作
    
    
    @Override
    public void connectSQL() {
        connect();
    }
}

接着，我们新建一个类似于MySQLHelper的类SQLiteHelper用于连接SQLite数据库，并且它也实现了SQLHelper这个接口：

public class SQLiteHelper implements SQLHelper {

    private String userName;
    private String passWord;
    
    public SQLiteHelper(String userName, String password) {
        this.userName = userName;
        this.passWord = password;
    }
    
    public void setTimeout(long time) {
         //Set TimeOut
    }
    
    public void setSelectMode(String mode) {
        // Set SelectMode
    }
    
    public void setCache(String cache) {
        // Set Cache
    }

    public void connect() {
        // Connect SQL
    }

    // ...  更多初始化操作
    
    
    @Override
    public void connectSQL() {
        connect();
    }
}

好，我们接下来新建一个连接数据库的工厂类SQLHelperFactory：

public class SQLHelperFactory {
    
    public static final int TYPE_SQLITE = 0x0001;
    public static final int TYPE_MYSQL = 0x0002;
    
    public SQLHelper createSQLHelper(int type, String userName, String passWord) {
        if(type == TYPE_SQLITE) {
            MySQLHelper mySQLHelper = new MySQLHelper(userName, passWord);
            mySQLHelper.setTimeout(1000);
            mySQLHelper.setSelectMode("A Mode");
            mySQLHelper.setCache("ALL");
            return mySQLHelper;
        }else if(type == TYPE_MYSQL) {
            SQLiteHelper sqLiteHelper = new SQLiteHelper(userName, passWord);
            sqLiteHelper.setTimeout(1000);
            sqLiteHelper.setSelectMode("A Mode");
            sqLiteHelper.setCache("ALL");
            return sqLiteHelper;
        }
        
        return null;
    } 

}

然后，我们在需要使用这两种数据库连接的AConnectSQL和BConnectSQL代码更改成这样：

AConnectSQL:

public class AConnectSQL {
    
    public void connect() {
        SQLHelperFactory sqlHelperFactory = new SQLHelperFactory();
        SQLHelper sqlHelper = sqlHelperFactory.createSQLHelper(SQLHelperFactory.TYPE_SQLITE, "jack", "123");
        sqlHelper.connectSQL();
    }

}

BConnectSQL:

public class BConnectSQL {
        
    public void connect() {
        SQLHelperFactory sqlHelperFactory = new SQLHelperFactory();
        SQLHelper sqlHelper = sqlHelperFactory.createSQLHelper(SQLHelperFactory.TYPE_MYSQL, "lucy", "456");
        sqlHelper.connectSQL();
    }

}

这样，需要连接哪个数据库就从工厂中创造该类型的数据库即可。即使以后需要将SQLite换成Oracle也仅仅只是将SQLHelperFactory中的SQLite更改就行。

有的朋友也许会通过反射的写法写工厂类的方法：

public SQLHelper createSQLHelper2(Class<? extends SQLHelper> clazz) {
    SQLHelper sqlHelper = null;
    
    try {
        sqlHelper = (SQLHelper) Class.forName(clazz.getName()).newInstance();
    } catch (InstantiationException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    
    return sqlHelper;   
}

用的时候，这样调用：

SQLHelperFactory sqlHelperFactory = new SQLHelperFactory();
SQLHelper sqlHelper = sqlHelperFactory.createSQLHelper2(SQLiteHelper.class);

但是根据迪米特原则（越少知道越好），调用者是不知道有SQLiteHelper类存在的，如果他知道，那么为什么不直接new SQLiteHelper呢？所以，采用上述这种调用方法的模式，我认为背离了工厂模式的原则。

工厂模式

其实工厂模式和简单工厂模式类似，只是在简单工厂模式中，我们创建了一个类SQLHelperFactory用来创造我们需要的连接数据库的对象比如SQLiteHelper或者MySQLHelper。
而在工厂模式中，我们是把SQLHelperFactory也抽象化，而会针对不同的数据库创建不同的具体工厂，通过具体工厂来创造我们需要的对象。

因为在简单工厂模式中，我们其实可以返回任何我们想要的对象，如果我们想要生产一辆飞机，只需要在判断时传入Type为飞机，同时在create方法中返回飞机的对象就行。而我们的工厂的目的明明是返回SQLHelper。因此，工厂模式就很好的解决了这个问题。

优点：

• 1、减轻工厂类的负担，某一类对象交给某一类的工厂去生产；
• 2、增加新的分类时不用修改工厂类，只需要修改某一类的工厂，符合开闭原则。

缺点：
1、每新增一个分类，就需要增加分类的工厂和产品类，造成代码量成倍增加。

使用场景：
首先，我们把类SQLHelperFactory更改成抽象类SQLHelperFactory：

public abstract class SQLHelperFactory {
    
    public abstract SQLHelper createSQLHelper(String username, String password);
}

然后，我们创建两个类SQLiteHelperFactory和MySQLHelperFactory两个工厂类，它们的作用分别是用来生产SQLiteHelper和MySQLHelper：

SQLiteHelperFactory：

public class SQLiteHelperFactory extends SQLHelperFactory{

    @Override
    public SQLHelper createSQLHelper(String username, String password) {
        SQLiteHelper sqLiteHelper = new SQLiteHelper(username, password);
        sqLiteHelper.setTimeout(1000);
        sqLiteHelper.setSelectMode("A Mode");
        sqLiteHelper.setCache("ALL");
        return sqLiteHelper;
    }

}

MySQLHelperFactory：

public class MySQLHelperFactory extends SQLHelperFactory{

    @Override
    public SQLHelper createSQLHelper(String username, String password) {
        MySQLHelper mySQLHelper = new MySQLHelper(username, password);
        mySQLHelper.setTimeout(1000);
        mySQLHelper.setSelectMode("A Mode");
        mySQLHelper.setCache("ALL");
        return mySQLHelper;
    }

}

使用的时候：

public class AConnectSQL {
    
    public void connect() {
        SQLiteHelperFactory sqLiteHelperFactory = new SQLiteHelperFactory();
        sqLiteHelperFactory.createSQLHelper("jack", "123");
        SQLHelper sqlHelper = sqLiteHelperFactory.createSQLHelper("jack", "123");
        sqlHelper.connectSQL();
    }

}

抽象工厂

在工厂模式中，我们将每一个不同的数据库都更改为一个单独的工厂。这样做，我们避免了“超级工厂”的存在，仅仅针对不同产品，提供不同的工厂。

而抽象工厂的出现，是在工厂模式的基础上又进一步抽象——抽象工厂将工厂和产品都抽象化了，创造一系列相互依赖的接口或类，而无需指明它们具体的实现类。

比如，我们在工厂模式中，我们假设现在是在Android系统上连接数据库，那么此时我们仅仅对每一个不同的数据库做一个单独的工厂，如果我们现在切换到IOS系统上，可能此时连接数据库的方式又变了，那么此时我们在Android系统上所写的连接数据库的方法可能就不管用了，需要重新写工厂模式，而抽象工厂则是把工厂再抽象一层，每一个工厂都有连接MySQL和SQLite的方法，而具体是哪个系统去连接，则交给他们自己去实现。
因此，可以说，工厂模式是针对一个产品，抽象工厂是针对多个产品。

优点：
同工厂模式。

缺点：
扩展极其困难。

使用场景：
比如我们针对MySQL和SQLite都生产了不同的工厂，那么，如果我们在不同的操作系统（Android,IOS等）上连接数据库的方式不同，那么此时就不在使用工厂模式，而使用抽象工厂模式了。

1、首先，我们新建一个抽象产品类ConnectMySQLHelper，用来连接MySQL数据库：

public abstract class ConnectMySQLHelper {
    
    public abstract void connectMySQL();

}

然后建两个实体类AndroidConnectMySQLHelper和IOSConnectMySQLHelper分别实现去连接Android和IOS的方法：

AndroidConnectMySQLHelper：

public class AndroidConnectMySQLHelper extends ConnectMySQLHelper {

    @Override
    public void connectMySQL() {
        System.out.println("Android connect MySQL");
    }

}

IOSConnectMySQLHelper：

public class IOSConnectMySQLHelper extends ConnectMySQLHelper{

    @Override
    public void connectMySQL() {
        System.out.println("IOS connect MySQL");
    }

}

2、同样的，我们也要像步骤1一样建立一个抽象类ConnectSQLiteHelper和两个实体类AndroidConnectSQLiteHelper，IOSConnectSQLiteHelper分别去连接SQLite数据库。

3、创建一个抽象工厂类，用来连接MySQL和SQLite：

public abstract class AbstractSQLFactory {
    
    public abstract ConnectMySQLHelper connectMySQL();
    
    public abstract ConnectSQLiteHelper connectSQLite();

}

4、分别创建Andoird和IOS连接两个数据库的工厂类：

AndroidSQLFactory：

public class AndroidSQLFactory extends AbstractSQLFactory {

    @Override
    public ConnectMySQLHelper connectMySQL() {
        return new AndroidConnectMySQLHelper();
    }

    @Override
    public ConnectSQLiteHelper connectSQLite() {
        return new AndroidConnectSQLiteHelper();
    }

}

IOSSQLFactory：

public class IOSSQLFactory extends AbstractSQLFactory {

    @Override
    public ConnectMySQLHelper connectMySQL() {
        return new IOSConnectMySQLHelper();
    }

    @Override
    public ConnectSQLiteHelper connectSQLite() {
        return new IOSConnectSQLiteHelper();
    }

}

抽象工厂模式，我个人也掌握的不是很好，没有理解它的精髓，但是却看到了它扩展很难的一面（比如此时我再来一个Windows系统，又需要从AbstractSQLFactory那一层开始更改起），因此，我不打算在自己的编码中引入这种模式。