跟JBPM学设计模式之工厂方法模式

跟JBPM学设计模式之工厂方法模式

 

模式简介

         工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化那个类，其使一个类的实例化延迟到其子类中。

         前边我们学习了简单工厂模式，简单工厂模式的最大优势在于工厂类中包含了必要逻辑判断，根据客户端的条件动态实例化相关的类，对于客户端不需要了解具体的产品类，所以解除了对具体产品类的依赖。在引入新的产品的时候，我们不需要修改客户端代码，但是必须修改工厂，所以违背了开闭原则。

         工厂方法模式是简单工厂模式的进一步抽象和推广。由于工厂类使用多态性，使其即保持了简单工厂模式的优点，也克服了其缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体的创建工作交给子类去做，它仅仅负责给出具体工厂类需要实现的接口。通过这种抽象和依赖倒转的结果，这样就可以允许我们在不修改具体工厂类的前提下，引进新的产品类型。

         工厂方法模式的结构如下图，其一般会涉及到一下角色

 

图 1. 工厂方法模式结构图

 

         抽象工厂：为具体的工厂类提供必需实现的接口，其通常是与具体的业务应用无关。

         具体工厂：其实现抽象工厂定义的接口，其接受客户的调用创建产品对象。

         抽象产品：工厂方法模式创建的产品对象的父类，其提供具体产品需要继承的成员。

         具体产品：工厂类需要创建的产品对象。

JBPM中的工厂方法模式

         日志功能往往是每个软件系统必备的模块，JBPM也不例外，其本身支持两种日志类型，我们可以通过配置灵活的选择。其中对Log对象的实例化使用了工厂方法模式，具体的结构图如下

 

 

图 1. JBPM中的工厂方法模式结构图

 

         Log类作为产品基类，其提供了具体的产品需要实现的所有的接口，在这里就是获取日志等级开关和相应等级记录日志的接口；但是在这里其提供了一个静态的getLog方法，它是做什么用的呢？从代码的实现上来看，其持有一个工厂实例，如果这个工厂实例已经被实例化，那就直接调用工厂创建具体的日志类；如果还没有实例化，就读取相关的配置文件，根据配置来实例化相应的工厂类，然后调用工厂类创建产品。我们可以看到这一小段代码中使用了单例模式和简单工厂模式；单例模式避免每次获取Log对象的时候读取、解析配置文件、初始化相关的工厂类等繁琐的工作；简单工厂模式封装了具体工厂类的实例化，间接的负责具体产品的创建，这样客户就不需要依赖具体的工厂类，直接调用getLog就可以了。具体代码如下

         

public abstract class Log {
  
  static LogFactory logFactory;

  //使用简单工厂模式，根据配置初始化具体的工厂
  public static synchronized Log getLog(String name) {
    if (logFactory==null) {
      
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

      // if logging.properties is available on the classpath
      if (classLoader.getResource("logging.properties")!=null) {
        logFactory = new Jdk14LogFactory();
        
      // if log4j is available on the classpath
      } else if (isLog4jAvailable(classLoader)) {
        logFactory = new Log4jLogFactory();
        
      } else {
        logFactory = new Jdk14LogFactory();
         
      }
    }
    return logFactory.getLog(name);
  }

  static boolean isLog4jAvailable(ClassLoader classLoader) {
    try {
      Class.forName("org.apache.log4j.LogManager", false, classLoader);
      return true;
    } catch (ClassNotFoundException e) {
      return false;
    }
  }

  //声明具体的log类需要实现的接口
  public abstract void error(String msg);
  public abstract void error(String msg, Throwable exception);

  public abstract boolean isInfoEnabled();
  public abstract void info(String msg);
  public abstract void info(String msg, Throwable exception);

  public abstract boolean isDebugEnabled();
  public abstract void debug(String msg);
  public abstract void debug(String msg, Throwable exception);

  public abstract boolean isTraceEnabled();
  public abstract void trace(String msg);
  public abstract void trace(String msg, Throwable exception);
  
  public abstract boolean isWarnEnabled();
  public abstract void warn(String msg);
  public abstract void warn(String msg, Throwable exception);
  

         Log4jLog实现了Log定义的一些结构，并将相应的接口需要完成的工作委托给org.apache.log4j.Logger来实现，具体代码如下

         

public class Log4jLog extends Log {

  org.apache.log4j.Logger log;
  
  public Log4jLog(org.apache.log4j.Logger log) {
    this.log = log;
  }

  public void error(String msg) {
    log.error(msg);
  }

  public void error(String msg, Throwable exception) {
    log.error(msg, exception);
  }

  public boolean isInfoEnabled() {
    return log.isInfoEnabled();
  }

  public void info(String msg) {
    log.info(msg);
  }

  public void info(String msg, Throwable exception) {
    log.info(msg, exception);
  }

  public boolean isDebugEnabled() {
    return log.isDebugEnabled();
  }

  public void debug(String msg) {
    log.debug(msg);
  }

  public void debug(String msg, Throwable exception) {
    log.debug(msg, exception);
  }

  public boolean isTraceEnabled() {
    return log.isTraceEnabled();
  }

  public void trace(String msg) {
    log.trace(msg);
  }

  public void trace(String msg, Throwable exception) {
    log.trace(msg, exception);
  }
  
  public boolean isWarnEnabled() {
    return log.isEnabledFor(Level.WARN);
  }
  
  public void warn(String msg) {
    log.warn(msg);
  }
  
  public void warn(String msg, Throwable exception) {
    log.warn(msg, exception);
  }
  

         同样的Jdk14Log作为具体的产品类，其也将相应的工作委托给java jdk提供的日志类来实现产品基类Log的接口，具体代码如下

         

public class Jdk14Log extends Log {
  
  Logger log;

  public Jdk14Log(Logger logger) {
    this.log = logger;
  }

  public void error(String msg) {
    log.log(Level.SEVERE, msg);
  }

  public void error(String msg, Throwable exception) {
    log.log(Level.SEVERE, msg, exception);
  }

  public boolean isInfoEnabled() {
    return log.isLoggable(Level.INFO);
  }

  public void info(String msg) {
    log.log(Level.INFO, msg);
  }

  public void info(String msg, Throwable exception) {
    log.log(Level.INFO, msg, exception);
  }

  public boolean isDebugEnabled() {
    return log.isLoggable(Level.FINE);
  }

  public void debug(String msg) {
    log.log(Level.FINE, msg);
  }

  public void debug(String msg, Throwable exception) {
    log.log(Level.FINE, msg, exception);
  }

  public boolean isTraceEnabled() {
    return log.isLoggable(Level.FINEST);
  }

  public void trace(String msg) {
    log.log(Level.FINEST, msg);
  }

  public void trace(String msg, Throwable exception) {
    log.log(Level.FINEST, msg, exception);
  }
  
  public boolean isWarnEnabled() {
    return log.isLoggable(Level.WARNING);
  }
  
  public void warn(String msg) {
    log.warning(msg);
  }
  
  public void warn(String msg, Throwable exception) {
    log.log(Level.WARNING, msg, exception);
  }
  

         LogFactory作为工厂的基类，其提供了具体工厂类需要实现的创建接口getLog，代码如下

         

public interface LogFactory {

  Log getLog(String name);

         Log4jLogFactory实现工厂接口的方法，负责实例化Log4jLog代码如下

         

public class Log4jLogFactory implements LogFactory {

  public Log getLog(String name) {
    return new Log4jLog(LogManager.getLogger(name));
  }

         Jdk14LogFactory也实现工厂接口的方法，负责实例化Jdk14Log

 

public class Jdk14LogFactory implements LogFactory {

  public Log getLog(String name) {
    return new Jdk14Log(Logger.getLogger(name));
  }  

工厂方法模式的优劣

         工厂方法模式抽象出工厂基类，使其只提供创建产品的接口，将创建具体产品的职责下放到工厂子类中，同时每个工厂子类只负责创建一种产品，解除了简单工厂类对所有产品的依赖，所以当我们新增产品的时候，只要同时新增相应的工厂类就可以了。但是如果仔细观察我们就会发现，使用工厂方法模式时，客户端需要决定实例化哪个工厂来创建产品，这个选择判断的问题还是存在的，其实，工厂方法把简单工厂的内部判断逻辑转移到了客户端代码来进行，在添加新的产品时，本来是修改工厂类，而现在是修改客户端。