CODEWITHSUNDEEP
javadesign-patterns
Abraham Farris
Abraham Farris

Reputation: 114

Design pattern advice for loading data from different sources based on logic

I am currently reading about design patterns and their uses. I am trying to find a design pattern to use to re-factor my current code.

Problem:

Load data from several different sources in a certain order into one large JavaBean. Data is loaded based on some simple initial criteria. Data returned from the first source will build criteria for the next source.

It is possible that no data may return from certain data sources. This may not stop the load process into the JavaBean, but based on some logic the load process may skip certain data sources because it doesn't have enough criteria to query.

Current Solution:

BigJavaBean Class

Each loader class contains methods to access each source DAOs

Queries to each DAOs are built from attributes in the BigJavaBean

There is logic in each loader class to determine if its "loaded" or not

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


}

Thanks.

Upvotes: 6

Views: 3035

Answers (2)

CordiS
CordiS

Reputation: 66

This is 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);

Upvotes: 2

Rand
Rand

Reputation: 530

To me, this screams for a state pattern (there are cleaner implementations than this but I've not had enough coffee).

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);

Upvotes: 1

Related Questions