• process request and return result
• process request partially and run subsequent handler
• ignore the request and pass the control further as above
• run next handler and, after it returns, process already handled request
• simply return, without processing and passing control down the chain
• throw an exception

public interface RegistrationChainHandler {
   long handle(Car car, RegistrationChain chain) throws Exception;
}

public class RegistrationChain {
   private final ListIterator<RegistrationChainHandler> currentHandlerIter;

   public long proceed(Car car) throws Exception {
       if (!currentHandlerIter.hasNext())
           return handleEndOfChain();
       RegistrationChainHandler handler = currentHandlerIter.next();
       try {
           return handler.handle(car, this);
       } finally {
           currentHandlerIter.previous();
       }
   }

   protected long handleEndOfChain() {
       throw new IllegalStateException("No handler fulfilled the request");
   }

}

public class StoreCarHandler implements RegistrationChainHandler {
   @PersistenceContext
   private EntityManager em;

   @Override
   @Transactional(propagation = Propagation.MANDATORY)
   public long handle(Car car, RegistrationChain chain) throws Exception {
       em.persist(car);
       return chain.proceed(car);
   }
}

public class RegisterInCarDeptHandler implements RegistrationChainHandler {

   @Resource
   private CarRegisterRemote carRegisterRemote;

   @Override
   public long handle(Car car, RegistrationChain chain) throws Exception {
       String carDeptId = carRegisterRemote.register(car.getRegistrationNo(), car.getEngineCapacity().doubleValue());
       car.setCarDeptId(carDeptId);
       return chain.proceed(car);
   }
}

public class ValidationHandler implements RegistrationChainHandler {

   @Override
   public long handle(Car car, RegistrationChain chain) throws Exception {
       Validate.notNull(car, "Car can't be null");
       Validate.notEmpty(car.getRegistrationNo(), "Registration number can't be empty");
       Validate.notNull(car.getColor(), "Color can't be null");
       Validate.notNull(car.getEngineCapacity(), "Engine capacity can't be null");
       Validate.notNull(car.getWeight(), "Weight can't be null");
       return chain.proceed(car);
   }
}

public class LoggingHandler implements RegistrationChainHandler {

   private static final Logger log = LoggerFactory.getLogger(LoggingHandler.class);

   @Override
   public long handle(Car car, RegistrationChain chain) throws Exception {
       log.debug("Processing car: {}", car);
       return chain.proceed(car);
   }
}

public class Perf4jHandler implements RegistrationChainHandler {

   private String tag;

   @PostConstruct
   public void init() {
       if(StringUtils.isBlank(tag))
       tag = Perf4jHandler.class.getName();
   }

   @Override
   public long handle(Car car, RegistrationChain chain) throws Exception {
       StopWatch watch = new Slf4JStopWatch(tag);
       try {
           return chain.proceed(car);
       } finally {
           watch.stop();
       }
   }

   public void setTag(String tag) {
       this.tag = tag;
   }
}

public class ExceptionTranslatorHandler implements RegistrationChainHandler {

   @Override
   public long handle(Car car, RegistrationChain chain) throws Exception {
       try {
           return chain.proceed(car);
       } catch (CarRegistrationException e) {
           throw e;
       } catch (Exception e) {
           throw new CarRegistrationException("Error while registering car", e);
       }
   }
}

public class TransactionalHandler implements RegistrationChainHandler {

   @Override
   @Transactional
   public long handle(Car car, RegistrationChain chain) throws Exception {
       return chain.proceed(car);
   }
}

public class CatchAllHandler implements RegistrationChainHandler {
   private boolean fail;
   private String failMessage;

   @Override
   public long handle(Car car, RegistrationChain chain) throws Exception {
       if(fail)
           throw new IllegalStateException(failMessage);
       return car.getId();
   }

   public void setFail(boolean fail) {
       this.fail = fail;
   }
}

public class HandlerWithTimeout implements RegistrationChainHandler {

   @Resource
   private ExecutorService executorService;
   private long timeoutInMillis = 5000;

   @Override
   public long handle(final Car car, final RegistrationChain chain) throws Exception {
       Future<Long> registrationResult = executorService.submit(new Callable<Long>() {
           @Override
           public Long call() throws Exception {
              return chain.proceed(car);
           }});

       try {
           return registrationResult.get(timeoutInMillis, TimeUnit.MILLISECONDS);
       } catch (ExecutionException e) {
           if(e.getCause() instanceof Exception)
              throw ((Exception) e.getCause());
           else
              throw new CarRegistrationException(e.getCause());
       } catch (TimeoutException e) {
           registrationResult.cancel(true);
           throw new CarRegistrationException("Registration did not finished after " + timeoutInMillis + "ms");
       }
   }
}

@WebService
public interface CarRegistrationWs {
   long registerCar(Car car);
}

public class CarRegistrationWsImpl implements CarRegistrationWs {
   @Override
   public long registerCar(Car car) {
       return car.register();
   }
}

@Configurable
public class Car implements Serializable {

   private List<RegistrationChainHandler> handlers;

   public void setHandlers(List<RegistrationChainHandler> handlers) {
       this.handlers = handlers;
   }

   public long register() {
       try {
           return new RegistrationChain(handlers).proceed(this);
       } catch (CarRegistrationException e) {
           throw e;
       } catch (RuntimeException e) {
           throw e;
       } catch (Exception e) {
           throw new RuntimeException(e);
       }

   }
   /*  */
}

<bean id="carRegistrationWs" class="com.blogspot.nurkiewicz.cars.registration.ws.CarRegistrationWsImpl"/>
<jaxws:endpoint id="helloWorld" implementor="#carRegistrationWs" address="/Registration"/>

<bean id="car" class="com.blogspot.nurkiewicz.cars.Car" scope="prototype" lazy-init="true">
   <property name="handlers" ref="handlersList"/>
</bean>
 
<util:list id="handlersList">
   <ref bean="exceptionTranslatorHandler"/>
   <ref bean="validationHandler"/>
   <ref bean="handlerWithTimeout"/>
   <ref bean="perf4jHandler"/>
   <ref bean="loggingHandler"/>
   <ref bean="transactionalHandler"/>
   <ref bean="storeCarHandler"/>
   <ref bean="registerInCarDeptHandler"/>
   <ref bean="catchAllHandler"/>
</util:list>

• Flexibility – chain can be easily configured, altering the system behavior without or with a little modification in code
• Testability – thanks to louse coupling promoted by this pattern each handler can be unit tested as well as easy integration testing of any handlers combination
• Readability – It is much easier to read a single class focused on one purpose rather than having a big class, even properly divided into methods
• Maintainability – adding, removing and changing the order of handlers is very easy. Also modifying existing handlers is easier
• ...also logging, profiling, etc. is centralized in a single place (RegistrationChain)

• Some people find it harder (?) to follow the process when it is split into several classes, especially when the order is configured somewhere else
• Wrong chain configuration might harm the application, I showed an example