Question

我目前正在阅读有关设计模式及其用途的文章。我试图找到一个设计模式来用来重新计算我当前的代码。

问题：

将来自多个不同来源的数据按特定顺序加载到一个大型JavaBean中。根据一些简单的初始标准加载数据。从第一个源返回的数据将构建下一个源的标准。

可能没有数据可能从某些数据源返回。这可能无法阻止加载进程进入JavaBean，但基于某些逻辑，加载进程可能会跳过某些数据源，因为它没有足够的标准来查询。

当前解决方案：

BigJavaBean Class

每个加载器类都包含访问每个源DAO的方法

每个DAO的查询都是根据BigJavaBean中的属性构建的

每个加载器类中都有逻辑来确定它是否“加载”

LoaderClassDataBase for BigJavaBean

LoaderClassFlatFiles for BigJavaBean

LoaderClassXmlFiles for BigJavaBean

LoaderClassWebService for BigJavaBean

... and so on

MainLogicClass

  BigJavaBean bigJavaBean = new BigJavaBean();

  populateBigBeanMethod() {

   loaderClassDataBase(bigJavaBean);

   if (loaderClassDataBase.isLoaded()) {
      loaderClassFlatFiles(bigJavaBean);

       if (loaderClassFlateFile.isLoaded() {
            loaderClassXmlFiles(bigJavaBean);
         }
   }

   ... more if statements


}

感谢。

Answer 1

这是Chain Of Responsibility pattern

abstract class BigJavaBeanLoader {
    private final BigJavaBeanLoader successor;

    public BigJavaBeanLoader() {
        this.successor = null;
    }

    public BigJavaBeanLoader(BigJavaBeanLoader successor) {
        this.successor = successor;
    }

    public void loadData(BigJavaBean bean) {
        if (this.loadDataFromSource(bean) && this.successor != null) {
            this.successor.loadData(bean);
        }
    }

    protected abstract boolean loadDataFromSource(BigJavaBean bean);

    class DataBase extends BigJavaBeanLoader {
        @Override
        protected boolean loadDataFromSource(BigJavaBean bean) {
            // do a database stuff
            return true;
        }
    }

    class FlatFiles extends BigJavaBeanLoader {
        @Override
        protected boolean loadDataFromSource(BigJavaBean bean) {
            // do flat files stuff
            return true;
        }
    }

}

BigJavaBean bigJavaBean = new BigJavaBean();
BigJavaBeanLoader loader;
loader = new BigJavaBeanLoader.FlatFiles();
loader = new BigJavaBeanLoader.DataBase(loader);
loader.loadData(bebigJavaBean);

Answer 2

对我而言，这种状态模式的尖叫声（有比这更清洁的实施，但我没有足够的咖啡）。

public abstract class LoaderState {
  private BigBean bean;
  public LoaderState(BigBean b) { this.bigBean = b; }
  public abstract LoaderState getNextLoader();
  public abstract void loadData();
  class DatabaseLoaderState extends LoaderState {
    public void loadData() { //do some stuff }
    public LoaderState getNextLoader() {
      if (iHadSomeData) return new FlatFileLoaderState(bigBean);
      return new SomeOtherLoaderState(bigBean); //or return null if nothing else to do
    }
  }

}

LoaderState state = new LoaderState.DatabaseLoaderState(new BigBean());
do {
  state.loadData();
  state = state.getNextLoader();
} while (state != null);

设计模式建议，用于根据逻辑加载来自不同来源的数据

2 个答案: