Maven - Brico::Command

Creating a controller

Brico::Command defines a Controller interface and provides a handy base class: AbstractController. From this base implementation, a simple but yet powerful Controller is available, the MapBackedController. This controller manages all the complexity of command processing while leaving you, the developer, the task of defining the source of three sets on objects need for command processing, mainly the commands, forms and filters (if any). MapBackedController is an abstract class, for which you must implement three methods:

getCommandMap(): a Map which every key is a command name and each value is a Command.
getFormFactoryMap(): a Map which every key is a form name and each value is a FormFactory.
getFilterSet(): a Set of FilterInjectors.

Example:

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import net.sf.brico.cmd.Command;
import net.sf.brico.cmd.FormFactory;
import net.sf.brico.cmd.base.form.ClassNameFormFactory;
import net.sf.brico.cmd.impl.MapBackedController;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class MyController extends MapBackedController {
   private static final Log log = LogFactory.getLog( SimpleController.class );

protected Map getCommandMap() {
      Map commands = new HashMap();
      addCommand( HelloCommand.class, "hello", "helloForm", commands );
      return commands;
   }

protected Set getFilterSet() {
      return Collections.EMPTY_SET;
   }

protected Map getFormFactoryMap() {
      Map factoryMap = new HashMap();
      addFormFactory( newClassNameFormFactory( "helloForm", HelloForm.class ), factoryMap );
      return factoryMap;
   }

private void addCommand( Class commandClass, String name, String formName, Map commandMap ) {
      try{
         commandMap.put( name, newCommand( commandClass, name, formName ) );
      }catch( Exception e ){
         log.warn( e, e );
      }
   }

private void addFormFactory( FormFactory formFactory, Map factoryMap ) {
      factoryMap.put( formFactory.getName(), formFactory );
   }

private FormFactory newClassNameFormFactory( String name, Class className ) {
      ClassNameFormFactory formFactory = new ClassNameFormFactory();
      formFactory.setName( name );
      formFactory.setClassName( className.getName() );
      return formFactory;
   }

private Command newCommand( Class commandClass, String name, String formName ) {
      Command command = null;
      try{
         command = (Command) commandClass.newInstance();
         PropertyUtils.setProperty( command, "name", name );
         PropertyUtils.setProperty( command, "formName", formName );
      }catch( Exception e ){
         log.warn( e, e );
      }
      return command;
   }
}

Configuring the controller

You may configure a group of properties for your controller, taking into account that if one of them is left, a default option would be used. This gives you the freedom of configuring what you need instead of what the component needs. The following is a list of configurable properties of the MapBackedController and their default values:

Property	Default value
name	NO DEFAULT VALUE You should name your controllers if you intend to use more than one in the same JVM process.
contextFactory	net.sf.brico.cmd.base.DefaultContextFactory
responseFactory	net.sf.brico.cmd.base.DefaultResponseFactory
requestHandler	net.sf.brico.cmd.RequestHandler
exceptionConfig exceptionConfigs	EMPTY

Using the controller

To use your newly configurated controller you need a RequestFactory that will let you create Request instances, configure it with the desired command to be execute along with any properties that may be used in its Form and then call the process() method of your controller, like the following example:

Brico::Command

Tutorials

Project Documentation

Working with a standalone Controller

Creating a controller

Configuring the controller

Using the controller