简单聊聊设计模式之工厂模式

设计模式之-----工厂模式

1. 设计模式的类型

• 创建型模式
  1. 单例模式（Singleton）
  2. 工厂模式（Factory Method）
  3. 抽象工厂模式（Abstract Factory）
  4. 原型模式（Prototype）
  5. 建造者模式（Builder）
• 结构型模式
  1. 适配器模式（Adapter）
  2. 桥接模式（Bridge）
  3. 组合模式（Composite）
  4. 装饰器模式（Decorator）
  5. 外观模式（Facade）
  6. 享元模式（Flyweight）
  7. 代理模式（Proxy）
• 行为型模式
  1. 责任链模式（Chain Of Responsibility）
  2. 命令模式（Command）
  3. 解释器模式（Interpreter）
  4. 迭代器模式（Iterator）
  5. 中介者模式（Mediator）
  6. 备忘录模式（Memento）
  7. 观察者模式（Observer）
  8. 状态模式（State）
  9. 策略模式（Strategy）
  10. 模板模式（Template Method）
  11. 访问者模式（Visitor）

设计模式的六大原则

1. 开闭原则
   • 开闭原则的意思是：对扩展开放，对修改关闭。在程序进行拓展的时候，不能修改原有的代码，实现一个热拔插的效果。简而言之，是为了使程序扩展性更好，易于维护和升级，想要达到这样的效果，我们需要使用接口和抽象类。
2. 里氏代换原则
   • 里氏代换原则是面向对象设计的基本准则之一，里氏代换意思是：任何基类出现的地方，子类一定可以出现，只有当派生类可以替换掉基类，且软件单位的功能不受影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充，实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体体现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
3. 依赖倒转原则
   • 这个原则是开闭原则的基础，具体内容是，针对接口编程，依赖于抽象而不依赖于具体。
4. 接口隔离原则
   • 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好，它还有另外一个意思是：降低类之间的契合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
5. 迪米特原则、又称最少知道原则
   • 迪米特原则是指：一个实体应当尽量少与其他实体之间发生相互作用，使得系统功能模块相对独立。
6. 合成复用原则
   • 合成复用原则是指：尽量使用合成/聚合得方式，而不是使用继承。

工厂模式

简介

• 工厂模式是java中最常用的设计模式之一，这种类型的模式属于创建型模式，它提供了一种创建对象的最佳方法。在工厂模式中，我们创建对象时不会对客户端暴露创建逻辑，并且通过使用一个共同的接口来指向新创建的对象。

优点

• 一个调用者想创建一个对象，只要知道其名称就可以了。
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点

• 每次增加一个产品时，都要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加。在一定程度上增加了系统的复杂性，同时也增加了类之间的依赖关系。

场景

• 日志记录器，记录可能记录到本地磁盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
• 数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
• 设计一个连接服务器的框架，需要多个协议，可以把这多个协议作为一个产品类，共同实现一个接口。

实现

• 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类中进行。

  • 在这个例子中，我们使用工厂模式创建一个获取任意数据库连接的功能。

    /**
     * @ClassName DBManageer
     * @Description: TODO
     * @Author qywang
     * @Date 2020/6/29
     * @Version V1.0
     **/
    public interface DBManager {
    
        Connection getConnection() throws Exception;
    }
    
    /**
     * @ClassName HiveConnection
     * @Description: TODO
     * @Author qywang
     * @Date 2020/6/29
     * @Version V1.0
     **/
    public class HiveConnection implements DBManager {
        @Override
        public Connection getConnection() throws Exception {
            Class.forName("");
            String url = "";
            String userName = "";
            String password = "";
            return DriverManager.getConnection(url,userName,password);
        }
    }
    
    /**
     * @ClassName MySQLConnection
     * @Description: TODO
     * @Author qywang
     * @Date 2020/6/29
     * @Version V1.0
     **/
    public class MySQLConnection implements DBManager {
    
        @Override
        public Connection getConnection() throws Exception {
            Class.forName("");
            String url = "";
            String userName = "";
            String password = "";
            return DriverManager.getConnection(url,userName,password);
        }
    }
    
    /**
     * @ClassName OracleConnection
     * @Description: TODO
     * @Author qywang
     * @Date 2020/6/29
     * @Version V1.0
     **/
    public class OracleConnection implements DBManager {
        @Override
        public Connection getConnection() throws Exception {
            Class.forName("");
            String url = "";
            String userName = "";
            String password = "";
            return DriverManager.getConnection(url,userName,password);
        }
    }
    
    /**
     * @ClassName ConnectionFactory
     * @Description: TODO
     * @Author qywang
     * @Date 2020/6/29
     * @Version V1.0
     **/
    public class ConnectionFactory {
    
        public static volatile ConnectionFactory connectionFactory;
    
        private ConnectionFactory() {
        }
    
        public static  ConnectionFactory getInstance() {
            if (null == connectionFactory) {
                synchronized (ConnectionFactory.class) {
                    if (null == connectionFactory) {
                        connectionFactory = new ConnectionFactory();
                    }
                }
            }
            return connectionFactory;
        }
    
        public DBManager getDBManager(String dbName) {
            DBManager dbManageer = null;
            if ("mysql".equalsIgnoreCase(dbName)) {
                dbManageer = new MySQLConnection();
            } else if ("oracle".equalsIgnoreCase(dbName)) {
                dbManageer = new OracleConnection();
            } else if("hive".equalsIgnoreCase(dbName)){
                dbManageer = new HiveConnection();
            }else{
                System.out.println("please write a new Connection,no dbName");
            }
            return dbManageer;
        }
    }
    
    /**
     * @ClassName Main
     * @Description: TODO
     * @Author qywang
     * @Date 2020/6/29
     * @Version V1.0
     **/
    public class Main {
        public static void main(String[] args) throws Exception {
            DBManager dbManager = ConnectionFactory.getInstance().getDBManager("mysql");
            dbManager.getConnection();
        }
    }
    

注意事项

• 作为一种创建型模式，在任何需要生成复杂对象的地方，都可以使用工厂模式，有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要new就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂性。