Question

I am trying to determine the best design pattern to use for a business key validation web service. The basic logic flow is coded below. The program will take a parameter and use a field to help determine the path to take in searching multiple systems where this business key can be found. System1 is searched first, if not found, search System2 and System3. The System1 search logic depends on a field in the parameter passed into the original validation method.

I am not exactly sure which design pattern to use. It looks like Command, Chain of Responsibility, Template Method all could be used here.

With my implementations below, I see the following problems:

1. Each SearchSystemX method needs to know to return null if the business key is not found so that the “control” method will continue to search other systems.

2. Each SearchSystemX must know how to populate the business object, currently just implemented by a simple primitive string, but that is for example only.

Please let me know your thoughts.

public string Validate (string parms) {
 string returnValue = null;

 returnValue = SearchSystem1(parms);

 if (returnValue == null) {
  returnValue = SearchSystem2(parms);

  if (returnValue != null) {
   returnValue = SearchSystem3(parms);
  }
  else if (returnValue == null) {
   if (parms == "Criteria1") {
    returnValue = SearchSystem4(parms);

    if (returnValue == null) {
     throw new ApplicationException("ID Invalid");
    }
   }
   else if (parms == "Criteria2") {
    throw new ApplicationException("ID Invalid");
   }
  }
 }
 return returnValue;

private string SearchSystem1 (string parms) {
 string returnValue = null;

 if (parms == "Criteria1") {
  returnValue = SearchSystem1UsingColumn1(parms);
 }
 else if (parms == "Criteria2") {
  returnValue = SearchSystem1UsingColumn2(parms);

  if (returnValue == null) {
   returnValue = SearchSystem1UsingColumn4(parms);
  }
 }

 if (returnValue != null) {
  returnValue = FetchXYCoordinate(parms);
 }

 return returnValue;
}

Thanks!

Answer 1

Chain of responsability

Each processing object contains a set of logic that describes the types of command objects that it can handle, and how to pass off those that it cannot to the next processing object in the chain

So you define and abstract SearchSystem ( or SystemSearch ) and add subclasses like this:

class SearchSystem
{
    //link to the next in the chain 
    SearchSystem next;

    // Basic search, If cannot handle forward to the next.
    public Result search( Criteria c ) 
    {
        Result r = doSearch( c );

        if( r != null ) 
        {
            return r;
        }

        return next.search( c );
    }
    // subclass specific system search
    abstract Result doSearch( Criteria c );
}

class SearchSystemOne: SearchSystem 
{
    Result doSearch( Criteria c )
    {
        // do some system 1 speficif stuff 
        // and return either and instance or null
    }
}
class SearchSystemTwo: SearchSystem 
{
    Result doSearch( Criteria c )
    {
        // do some system 2 speficif stuff 
        // and return either and instance or null
    }
}
.... etc etc. 
// End of the chain
class SearchSystemOver: SearchSystem 
{
    public Result search( Criteria c ) 
    {
        throw new ApplicationException("Criteria not foud", c );
    }
    Result doSearch( Criteria c )
    {
       // didn't we throw exception already?
    }
}

Instantiate

SearchSystem one = new SearchSystemOne();
SearchSystem two = new SearchSystemTwo();
SearchSystem three = new SearchSystemThree();
SearchSystem four = new SearchSystemFour();
SearchSystem over = new SearchSystemOver();

And build the chain

one.next = two;
two.next = three;
three.next = four;
four.next = over;

And finally search it.

SearchSystem searcher = one;

searcher.search( Criteria.addName("Oscar").addLastName("Reyes"));