CallBack Handler Pattern

[Mahesh Bhutkar]

import java.util.Map;

/**
 * The class <code>AbstractCallbackHandler</code> is used by
 * <code>AbstractService</code> and <code>AbstractController</code> to
 * enable call backs.
 */
public abstract class AbstractCallbackHandler
{
	/**
	 * If supported this method can be used to raise call backs/events to
	 * <code>AbstractService</code> and <code>AbstractController</code>.
	 * @param callbackType <code>String</code> indicating the event type
	 * @param inputObject object associated with the event
	 * @return object of type <code>Map</code> containing the result of the
	 *         call back
	 */
	public abstract Map<String, Object> callback(String callbackType, Object inputObject);
}

import java.util.Map;

/**
 * This class provides default implementation for call back handling. Classes
 * wanting to support call backs can extend this class.
 */
public abstract class CallbackManager
{
	/**
	 * An object of type <code>AbstractCallbackHandler</code>.
	 */
	private AbstractCallbackHandler	callbackHandler;

	/**
	 * The classes that want to handle call back can use this method on the
	 * extending class to register them selves for events/call backs.
	 * @param handler object of type <code>AbstractCallbackHandler</code>
	 */
	public final void registerCallbackHandler(final AbstractCallbackHandler handler)
	{
		if (callbackHandler != null)
		{
			throw new IllegalStateException("Callback handler is already registered!");
		}

		callbackHandler = handler;
	}

	/**
	 * The classes that have register their instance for call back can deregister
	 * themselves by calling this method on the extending class.
	 * @param handler object of type <code>AbstractCallbackHandler</code>
	 */
	public final void deregisterCallbackHandler(final AbstractCallbackHandler handler)
	{
		if (callbackHandler != handler)
		{
			throw new IllegalStateException("Callback Handler registered is different");
		}

		callbackHandler = null;
	}

	/**
	 * Extending classes can use the method to raise events on the registered
	 * event handlers.
	 * @param callbackType <code>String</code> indicating the event type
	 * @param inputObject object associated with the event
	 * @return object of type <code>Map</code> containing the result of the
	 *         call back
	 */
	protected final Map<String, Object> callback(final String callbackType, final Object inputObject)
	{
		if (callbackHandler == null)
		{
			throw new UnsupportedOperationException("Callback Handler is not registered");
		}

		if (callbackType == null || inputObject == null)
		{
			throw new IllegalArgumentException("Input provided is null");
		}

		return callbackHandler.callback(callbackType, inputObject);
	}
}

import java.util.Map;

/**
 * It defines the methods that are to be
 * implemented by the extending class.
 * <p>
 * The extending class has three primary responsibilities: 
 * 1) Identify the controller to be used based on the requested mode. 
 * 2) Extract the necessary data from input object of type <code>Serializable</code>.
 * 3) Extract the required information from the data map received from the controller and create the output.
 */
public abstract class AbstractService 
{
	/**
	 * The handler is used to store an object of type
	 * <code>AbstractCallbackHandler</code>.
	 */
	private final AbstractCallbackHandler	handler	= new CallbackHandler();
	
	public static enum Mode{
		NORMAL,
		BATCH		
	}
	
	public final void execute(final Object input)
	{
		if(!(((Mode)input).equals(Mode.NORMAL)))
		{
			throw new IllegalArgumentException("Invalid input type");
		}
		
		execute((Mode)input);
	}

	/**
	 * This method provides an entry point into the service.
	 * @param input an object of type <code>BaseServiceInput</code>
	 * @return object of type <code>Serializable</code>
	 */
	private void execute(final Mode input)
	{
		validateInput(input);
		logInput(input);
		final AbstractController controller = getController(input);
		if (controller == null)
		{
			throw new RuntimeException("Controller is not defined");
		}
		initializeController(controller);
		final Map<String, Object> dataInputMap = getDataInputMap(input);
		final Map<String, Object> dataOutputMap = controller.process(dataInputMap);
		finalizeController(controller);
	}

	/**
	 * This method does the basic validation on the input object.
	 * @param input an object of type <code>BaseServiceInput</code>
	 */
	protected void validateInput(final Mode input)
	{
		if (input == null)
		{
			throw new IllegalArgumentException("Input provided is null!");
		}		
	}

	/**
	 * Register a call back handler with the controller. The controller can use
	 * this handle to raise call backs to the service.
	 * @param controller object of type <code>AbstractController</code>
	 */
	private void initializeController(final AbstractController controller)
	{
		controller.registerCallbackHandler(handler);
	}

	/**
	 * Deregister the call back handle with the controller.
	 * @param controller object of type <code>AbstractController</code>.
	 */
	private void finalizeController(final AbstractController controller)
	{
		controller.deregisterCallbackHandler(handler);
	}

	/**
	 * The extending class should over ride this method if it is to provide call
	 * back handling to the controller.
	 * @param eventType the type of event raised
	 * @param inputObject input object for the call back/event
	 * @return object of type <code>Map</code>
	 */
	protected Map<String, Object> handleCallback(final String eventType, final Object inputObject)
	{
		throw new UnsupportedOperationException();
	}

	/**
	 * This class provides a default implementation for
	 * <code>AbstractEventHandler</code>.
	 */
	private final class CallbackHandler extends AbstractCallbackHandler
	{
		@Override
		public Map<String, Object> callback(final String eventType, final Object inputObject)
		{
			return handleCallback(eventType, inputObject);
		}
	}

	/**
	 * Based on the mode, this method instantiates different controller. If the
	 * mode is not supported <code>UnsupportedOperationException</code> is
	 * thrown.
	 * @param mode the mode of operation.
	 * @return object of type <code>AbstractController</code>.
	 */
	private AbstractController getController(final Mode mode)
	{
		switch(mode)
		{
			case NORMAL:
				return getNormalFlowController();
			case BATCH:
				return getBatchFlowController();			
			default:
				throw new UnsupportedOperationException();
		}
	}

	/**
	 * The extending class is to override this method to return an instance of
	 * controller that can handle batch operations.
	 * @return object of type <code>AbstractController</code>.
	 */
	protected AbstractController getBatchFlowController()
	{
		throw new UnsupportedOperationException();
	}

	/**
	 * The extending class is to override this method to return an instance of
	 * controller that can handle normal flow.
	 * @return object of type <code>AbstractController</code>.
	 */
	protected AbstractController getNormalFlowController()
	{
		throw new UnsupportedOperationException();
	}

	/**
	 * Method to be implemented by the extending class. Use the method to log
	 * input received.
	 * @param input object of type <code>BaseServiceInput</code>
	 */
	protected abstract void logInput(Mode input);

	/**
	 * Method to be implemented by the extending class. Use the method to extract
	 * required data from the input and convert it into a data map.
	 * @param input object of type <code>BaseServiceInput</code>
	 * @return object of type <code>Map</code> containing the <code>String</code>
	 *         identification of the data as key and the object as value.
	 */
	public abstract Map<String, Object> getDataInputMap(Mode input);

	/**
	 * Method to be implemented by the extending class. The method is supposed
	 * convert the data map passed to it from the controller into an object of
	 * type <code>Serializable</code>
	 * @param dataOutputMap object of type <code>Map</code> containing the
	 *           <code>String</code> identification of the data as key and the
	 *           object as value.
	 * @return object of type <code>BaseServiceOutput</code>
	 */
	public abstract void extractOutput(Map<String, Object> dataOutputMap);
}

import java.util.Map;

/**
 * The class <code>AbstractController</code> is responsible for loading the
 * appropriate business objects and for controlling the interaction between
 * them.
 * <p>
 * <code>AbstractController</code> can also raise a call back to
 * <code>AbstractService</code> if it needs to make a request to another
 * service.
 */
public abstract class AbstractController extends CallbackManager
{
	/**
	 * The handler is used to store an object of type
	 * <code>AbstractEventHandler</code>.
	 */
	protected final AbstractCallbackHandler	callbackHandler	= new CallBackHandler();

	/**
	 * Entry point for the controller.
	 * @param inputDataMap object of <code>Map</code> containing the input data
	 *           as key/value pair
	 * @return object of <code>Map</code> containing the output data as
	 *         key/value pair
	 */
	public final Map<String, Object> process(final Map<String, Object> inputDataMap)
	{
		logInput(inputDataMap);
		validateInput(inputDataMap);
		return execute(inputDataMap);
	}

	/**
	 * Logs the input data received as <code>Map</code>.
	 * @param inputDataMap object of <code>Map</code>
	 */
	private void logInput(final Map<String, Object> inputDataMap)
	{
		if (inputDataMap == null)
		{
			return;
		}

		for (String inputDataItem : inputDataMap.keySet())
		{
			logInput(inputDataItem, inputDataMap.get(inputDataItem));
		}
	}

	/**
	 * Validates the input received from service.
	 * @param inputDataMap object of <code>Map</code>
	 */
	private void validateInput(final Map<String, Object> inputDataMap)
	{
		final Map<String, Boolean> inputDataItems = getInputDataItems();
		for (String inputDataItem : inputDataItems.keySet())
		{
			final boolean isMandatory = inputDataItems.get(inputDataItem);
			if (isMandatory && !inputDataMap.containsKey(inputDataItem))
			{
				throw new IllegalArgumentException("Required Data for :" + inputDataItem + " is not provided.");
			}
		}
	}

	/**
	 * The extending class should over ride this method if it is to provide call
	 * back handling to the business object.
	 * @param eventType the type of event raised
	 * @param inputObject input object for the call back/event
	 * @return object of type <code>Map</code>
	 */
	protected Map<String, Object> handleCallback(final String eventType, final Object inputObject)
	{
		throw new UnsupportedOperationException();
	}

	/**
	 * This class provides a default implementation for
	 * <code>AbstractCallbackHandler</code>.
	 */
	private class CallBackHandler extends AbstractCallbackHandler
	{
		@Override
		public Map<String, Object> callback(final String eventType, final Object inputObject)
		{
			return handleCallback(eventType, inputObject);
		}
	}

	/**
	 * Register a call back handler with the business object. The business object
	 * can use this handle to raise call backs to the controller.
	 * @param businessDO object of type <code>AbstractBusinessDO</code>
	 */
	protected final void initializeController(final AbstractBusinessDO businessDO)
	{
		businessDO.registerCallbackHandler(callbackHandler);
	}

	/**
	 * Deregister the call back handle with the business object.
	 * @param businessDO object of type <code>AbstractBusinessDO</code>
	 */
	protected final void finalizeController(final AbstractBusinessDO businessDO)
	{
		businessDO.deregisterCallbackHandler(callbackHandler);
	}

	/**
	 * Method to be implemented by the extending class. Use the method to log
	 * input received.
	 * @param inputDataItem <code>String</code> identification of the object
	 *           passed
	 * @param object input
	 */
	protected abstract void logInput(String inputDataItem, Object object);

	/**
	 * Method to be implemented by the extending class. this method is used to
	 * identify the data expected in the put. If the mandatory data is not
	 * present in the input exception is raised.
	 * @return object of type <code>Map</code> containing the
	 *         <code>String</code> identifier of the data required as key and
	 *         the flag true/false as value that specifies if the data is
	 *         mandatory or not
	 */
	protected abstract Map<String, Boolean> getInputDataItems();

	/**
	 * The method has to implemented by the extending the class. The method
	 * should contain the logic to load the business objects and manage
	 * interaction between them.
	 * @param inputDataMap object of type <code>Map</code> containing the
	 *           <code>String</code> identification of the data as key and the
	 *           object as value.
	 * @return output of the operation as object of type <code>Map</code>
	 *         containing the <code>String</code> identification of the data as
	 *         key and the object as value.
	 */
	protected abstract Map<String, Object> execute(Map<String, Object> inputDataMap);
}

import java.util.List;

/**
 * Abstract class that extends <code>EventManager</code>. The business
 * classes are to extend <code>AbstractBusinessDO</code>. Currently the class
 * is used as a marker, however can be used in the future to extend the
 * behaviour of extending classes.
 */
public abstract class AbstractBusinessDO extends CallbackManager
{
	
	/**
	 * The extending class can use this method to add a set of exceptions in the
	 * current exception list. Returns <code>null</code> if either of the input
	 * parameters are null or <code>
	 * exceptions</code> parameter is empty.
	 * @param consolidatedExceptions Current exception list.
	 * @param exceptions Exception list to be added.
	 * @return Consolidated exception list.
	 */
	protected final List<Exception> appendExceptions(final List<Exception> consolidatedExceptions, final List<Exception> exceptions)
	{
		if (consolidatedExceptions == null || exceptions == null || exceptions.isEmpty())
		{
			return null;
		}

		consolidatedExceptions.addAll(exceptions);

		return consolidatedExceptions;
	}

	/**
	 * The extending class can use this method to add a set of exceptions in the
	 * current exception list. Returns <code>null</code> if either of the input
	 * parameters are <code>null<code>
	 * @param consolidatedExceptions Current exception list.
	 * @param exception Exception to be added.
	 * @return Consolidated exception list.
	 */
	protected final List<Exception> appendExceptions(final List<Exception> consolidatedExceptions, final Exception exception)
	{
		if (consolidatedExceptions == null || exception == null)
		{
			return null;
		}

		consolidatedExceptions.add(exception);

		return consolidatedExceptions;
	}
}

import java.util.HashMap;
import java.util.Map;

public class GetVehicleInformation extends AbstractService
{
	protected final AbstractController getNormalFlowController()
	{
		return new ProcessVehicleInfoController();
	}
	
	@Override
	protected void logInput(Mode input) {		
		System.out.println("Call to GetVehicleInformation");		
	}
	
	@Override
	public Map<String, Object> getDataInputMap(Mode input)
	{
		final Map<String, Object> dataInputMap = new HashMap<String, Object>();
		if(input.name().equals("NORMAL"))
		{
			dataInputMap.put("VEHICLENAME", "MERCEDES");
		}
		return dataInputMap;    
	}
	
	@Override
	public void extractOutput(Map<String, Object> dataOutputMap) 
	{
		if (dataOutputMap != null && dataOutputMap.get("EXCEPTIONS") != null)
		{
			System.out.println(dataOutputMap.get("EXCEPTIONS"));
			// Return an exception
		}
	}

	@Override
	protected Map<String, Object> handleCallback(final String eventType, final Object inputObject)
	{
		if ("GetVehiclePics".equals(eventType))
		{
			return callGetVehiclePics(inputObject);
		}
		throw new UnsupportedOperationException("The event type : " + eventType + " is not supported!");
	}
	
	/**
	 * Contains the logic to handle GetVehiclePics call back.
	 */
	@SuppressWarnings("unchecked")
	private Map<String, Object> callGetVehiclePics(final Object inputObject)
	{
		final Map<String, Object> dataMap = (Map)inputObject;
		final String vehicleName = (String) dataMap.get("VEHICLENAME");
		
		//Invoke some service
		
		final Map<String, Object> outputMap = new HashMap<String, Object>();
		outputMap.put("VEHICLEPICS", "JPEG");
		return outputMap;
	}

}

import java.util.HashMap;
import java.util.Map;

public class ProcessVehicleInfoController extends AbstractController
{
	@Override
	protected Map<String, Boolean> getInputDataItems() {

		final Map<String, Boolean> map = new HashMap<String, Boolean>();
		map.put("VEHICLENAME", true);
		return map;
	}

	@Override
	protected Map<String, Object> execute(Map<String, Object> inputDataMap)
	{
		System.out.println("Start ProcessVehicleInfoController :");
		final String vehicleName = (String) inputDataMap.get("VEHICLENAME");
		final Map<String, Object> dataMap = new HashMap<String, Object>();
		
		final VehiclInfo vehicleInfo = new VehiclInfo(vehicleName);
		initializeController(vehicleInfo);
		vehicleInfo.process();
		finalizeController(vehicleInfo);		
		return dataMap;
	}
	
	@Override
	protected void logInput(String inputDataItem, Object object) 
	{
		System.out.println("ProcessVehicleInfoController Started");
	}
	
	@Override
	protected Map<String, Object> handleCallback(String eventType, Object inputObject)
	{
		return callback(eventType, inputObject);
	}

}

import java.util.HashMap;
import java.util.Map;

public class VehiclInfo extends AbstractBusinessDO
{
	protected final String vehicleName;	
	
	public VehiclInfo(final String vehicleName) 
	{
		if(vehicleName == null)
		{
			throw new IllegalArgumentException(" vehicleName is null ");	
		}
		this.vehicleName = vehicleName;
	}

	public void process()
	{
		if(vehicleName == null)
		{
			throw new IllegalArgumentException(" vehicleName is null ");	
		}
		
		final Map<String, Object> getVehiclePicsMap	= fetchVehiclePics(vehicleName);
		final String jpegImages = (String) getVehiclePicsMap.get("VEHICLEPICS");		
	}
	
	
	private Map<String, Object> fetchVehiclePics(final String vehicleName)
	{
		System.out.println("call fetchVehiclePics  ");
		final Map<String, Object> dataMap = new HashMap<String, Object>();
		dataMap.put("VEHICLENAME", vehicleName);
		final Map<String, Object> getVehiclePicsMap = callback("GetVehiclePics", dataMap);
		return getVehiclePicsMap;
	}	
}

public class TestGetVehicleInformation 
{
	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		GetVehicleInformation getVehicleInformation = new GetVehicleInformation();
		getVehicleInformation.execute(AbstractService.Mode.NORMAL);
	}
}

[Stephan van Hulst]

Welcome to JavaRanch Mahesh.

Please take a look at HowToAskQuestionsOnJavaRanch.

[Bert Bates]

Hi Mahash,

It's not clear exactly what your question is, but callbacks aren't a topic on the SCJP exam, so I'm moving this thread over to Java in General.

Welcome to the ranch!

Bert

[Rob Spoor]

Mahesh, I've browsed through your code (which would be easier if you'd UseCodeTags) but I don't see a question. Is there something you would like to ask or share?

[Javin Paul]

with this big code it really takes a lot to answer any question, I would suggest directly asking question with some context and having code for further reading.