Design for filtering chain implementation

In this case, I'll try to simulate the chain and move the execution responsibility to the chain, adding a little bit of "intelligence" to the nodes. In a sense, I would consider nodes as commands, in the sense that they can execute themselves and, having a common interface, be able to create composites . (Btw, I'm not a Java programmer, so please forgive me for possible syntax errors). So my main design decisions:

• The chain knows how to execute itself.
• Chain knots can be composites.

I would start by defining something like:

public abstract class ChainNode
{
public abstract Content apply(Content content);
}

/** 
   The NullObject of the chain 
   http://www.oodesign.com/null-object-pattern.html
*/
public class FinalNode extends ChainNode
{
public Content apply(Content content) {return content;}
}

/** A sample filter */
public class FilterA extends ChainNode
{
private ChainNode nextNode;

FilterA(ChainNode nextNode)
{
    this.nextNode = nextNode;
} 

public Content apply(Content content) 
    {
      filteredValue = //Apply the filter
      return nextNode.apply(filteredValue);
     }
}

/** An if-then-else filter */
public abstract class ConditionalFilter extends ChainNode
{
private ChainNode trueFilter;
private ChainNode falseFilter;

ConditionalFilter(ChainNode trueFilter, ChainNode falseFilter)
{
    this.trueFilter = trueFilter;
    this.falseFilter = falseFilter;
} 

public Content apply(Content content) 
    {
       if (this.evalCondition(content))
       {
            return this.trueFilter.apply(content);
       } 
       else
         {
            return this.falseFilter.apply(content);
         }
     }

    private abstract boolean evalCondition(Content content);
}

      

        
        
        
      

    

In contrast to this approach, what you do is turn control structures into objects and ask them to execute, which even allows you to create logic different from the standard if-then or switch statements. With this base, you can create a chain that has different branching statements by running different filtering paths.

Some notes:

• I assumed that the filter returns something of a type Content
  
  that effectively allows you to hook one filter after another. I assume this is true in your requirement, but I am not sure.
• For each new filter, you simply create a new class and define a method apply
  
  .
• The null object is always the last node in the chain, stopping chain calls.
• To define a new "branch node", you must subclass from ConditionalFilter
  
  and override the method evalCondition
  
  . I don't know if Java has a closure (I think it doesn't), but if you could instead add an instance variable condition
  
  and parameterize it with a closure, thereby avoiding subclassing for every new condition. Or maybe there is a more acceptable solution in the Java world for such things, I just don't know: (.
• I assumed that conditional branching is defined based on a parameter Content
  
  . If you need more information to make a decision, you can also have a context object passed in the method apply
  
  . Depending on your needs, it can be a structured object or just a dictionary if you need more flexibility.

Finally, as far as building the chains, if the chains are long and difficult to build, I think the builder here should match your needs.

NTN

Since you just want to execute the filter chain, so it might be easier to implement the filter chain as List<Filter>

. You could just loop over them and execute. Something like (note that this is obviously a fast implementation that I haven't tried):

public class FilterChainImpl implements FilterChain {
  private List<Filter> filterChain = new ArrayList<Filter>();

  public addFilter(final Filter f) {
    filterChain.add(f);
  }

  public apply(final Content content) {
    Content prevContent = content;
    for(Filter f : filterChain) {
      prevContent = f.apply(prevContent);
    }
  }
}

      

        
        
        
      

    

Then you can use that to create a whole filter chain that you like. You can use some factory method to create filter chains if you have many different filter chains.