工厂模式

          工厂模式，与单例模式一样，属于创建型模式，而工厂模式还可以细分为：

（1）简单工厂模式，或者称之为静态工厂模式

（2）工厂方法模式

（3）抽象工厂模式

 

一、简单工厂模式

 既然工厂模式的目的是为了创建对象，首先得有要有待创建的对象，假如要生产一辆汽车，定义如下：

public abstract class Car {
    public abstract void run();
}

 这是一个抽象类，假如有两个实现类：

public class BWM extends Car{
    @Override
    public void run() {
        System.out.println("宝马汽车在跑");
    }
}

public class BYD extends Car{
    @Override
    public void run() {
        System.out.println("比亚迪汽车在跑");
    }
}

现在需要根据用户的需求返回不同是实例对象，创建一个工厂类：

public class SimpleFactory {
    public static Car getCar(String type){
        if ("BWM".equals(type)){
            return new BWM();
        }else if ("BYD".equals(type)){
            return new BYD();
        }else {
            System.out.println("输入的类型不正确");
            return null;
        }
    }
}

简单工厂的核心，就是这个工厂类了，实质就是，它根据传入的不同类型，返回不同的对象，由于返回对象的方法，一般都做成静态方法，所有又称之为，静态工厂。在使用时，只需要传入要创建的对象类型即可：

public class TestSimpleFactory {
    public static void main(String[] args) {
        Car car = SimpleFactory.getCar("BWM");
        car.run();
    }
}

 

二、工厂方法模式

工厂方法模式，与简单工厂相比，不同的是，对工厂进一步抽象，由具体的实例工厂创建对象

抽象工厂定义，返回汽车对象：

public interface CarFactory {
    Car getCar();
}

然后，由具体的工厂子类来实例化对象：

public class BWMFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new BWM();
    }
}

public class BYDFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new BYD();
    }
}

 使用也很简单，需要什么类型的汽车，就new一个对应的工厂，再由工厂方法对象即可：

public class TestFactoryMethod {
    public static void main(String[] args) {
        BWMFactory factory = new BWMFactory();
        Car car = factory.getCar();
        car.run();
    }
}

 

三、抽象工厂模式

    抽象工厂模式，与工厂方法模式的区别在于，抽象工厂可以返回多个不同类型的产品，而工厂方法只返回一种类型的产品，如果抽象工厂只返回一种类型的产品，则抽象工厂模式就退化为工厂方法模式。

抽象工厂返回多个类型的产品：

// 抽象工厂
public interface CarFactory {
    // 获取发动机
    CarEngine getCarEngine();
    // 获取方向盘
    CarWheel getCarWheel();
}

具体工厂：

public class BWMFactory implements CarFactory {

    @Override
    public CarEngine getCarEngine() {
        return new BWMEngine();
    }

    @Override
    public CarWheel getCarWheel() {
        return new BWMWheel();
    }
}

public class BYDFactory implements CarFactory {

    @Override
    public CarEngine getCarEngine() {
        return new BYDEngine();
    }

    @Override
    public CarWheel getCarWheel() {
        return new BYDWheel();
    }
}

CarEngine和CarWheel都是产品的抽象类，这样，工程类就可以返回多个不同类型的产品了

public class TestAbsFactory {
    public static void main(String[] args) {
        CarFactory bwmFactory = new BWMFactory();
        CarEngine carEngine = bwmFactory.getCarEngine();
        CarWheel carWheel = bwmFactory.getCarWheel();
        carEngine.engine();
        carWheel.wheel();
        System.out.println("====分割线====");
        CarFactory bydFactory = new BYDFactory();
        CarEngine carEngine2 = bydFactory.getCarEngine();
        CarWheel carWheel2 = bydFactory.getCarWheel();
        carEngine2.engine();
        carWheel2.wheel();

    }
}

 

四、应用实例

         相信大家都用过mybatis，对SqlSessionFactory肯定不会陌生，根据名字就可以知道，它使用了工厂模式：

public interface SqlSessionFactory {

  SqlSession openSession();

  SqlSession openSession(boolean autoCommit);

  SqlSession openSession(Connection connection);

  SqlSession openSession(TransactionIsolationLevel level);

  SqlSession openSession(ExecutorType execType);

  SqlSession openSession(ExecutorType execType, boolean autoCommit);

  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);

  SqlSession openSession(ExecutorType execType, Connection connection);

  Configuration getConfiguration();

}

这个接口，别看写了那么多方法，其实就做了两件事，返回SqlSession和Configuration对象，实现类有两个：

SqlSessionManager，我没有用过，一般都是用DefaultSqlSessionFactory，看看如何返回SqlSession的：

  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

注意到，它是直接new了一个DefaultSqlSession，因为SqlSessionManager并没有用到，不用判断使用哪个

 return new DefaultSqlSession(configuration, executor, autoCommit);

 

再看DataSourceFactory获取数据源的工厂，也使用了工厂模式：

public interface DataSourceFactory {

  void setProperties(Properties props);

  DataSource getDataSource();

}

它有3个工厂子类：

Jndi用得比较少，我们看下UnpooledDataSourceFactory和PooledDataSourceFactory

 UnpooledDataSourceFactory在构造方法直接new了一个UnpooledDataSource

  public UnpooledDataSourceFactory() {
    this.dataSource = new UnpooledDataSource();
  }

而PooledDataSourceFactory继承于UnpooledDataSourceFactory，将返回的数据源变成PooledDataSource

  public PooledDataSourceFactory() {
    this.dataSource = new PooledDataSource();
  }