Interface Command

  • All Known Subinterfaces:
    Chain, Filter
    All Known Implementing Classes:
    AbstractGetLocaleCommand, AbstractSetLocaleCommand, ChainBase, CopyCommand, DispatchCommand, DispatchLookupCommand, FacesGetLocaleCommand, FacesSetLocaleCommand, LookupCommand, PathInfoMapper, PortletGetLocaleCommand, PortletSetLocaleCommand, RemoveCommand, RequestParameterMapper, ServletGetLocaleCommand, ServletPathMapper, ServletSetLocaleCommand

    public interface Command

    A Command encapsulates a unit of processing work to be performed, whose purpose is to examine and/or modify the state of a transaction that is represented by a Context. Individual Commands can be assembled into a Chain, which allows them to either complete the required processing or delegate further processing to the next Command in the Chain.

    Command implementations should be designed in a thread-safe manner, suitable for inclusion in multiple Chains that might be processed by different threads simultaneously. In general, this implies that Command classes should not maintain state information in instance variables. Instead, state information should be maintained via suitable modifications to the attributes of the Context that is passed to the execute() command.

    Command implementations typically retrieve and store state information in the Context instance that is passed as a parameter to the execute() method, using particular keys into the Map that can be acquired via Context.getAttributes(). To improve interoperability of Command implementations, a useful design pattern is to expose the key values used as JavaBeans properties of the Command implementation class itself. For example, a Command that requires an input and an output key might implement the following properties:

       private String inputKey = "input";
       public String getInputKey() {
         return (this.inputKey);
       }
       public void setInputKey(String inputKey) {
         this.inputKey = inputKey;
       }
    
       private String outputKey = "output";
       public String getOutputKey() {
         return (this.outputKey);
       }
       public void setOutputKey(String outputKey) {
         this.outputKey = outputKey;
       }
     

    And the operation of accessing the "input" information in the context would be executed by calling:

       String input = (String) context.get(getInputKey());
     

    instead of hard coding the attribute name. The use of the "Key" suffix on such property names is a useful convention to identify properties being used in this fashion, as opposed to JavaBeans properties that simply configure the internal operation of this Command.

    Version:
    $Revision: 480477 $ $Date: 2006-11-29 08:34:52 +0000 (Wed, 29 Nov 2006) $
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static boolean CONTINUE_PROCESSING
      Commands should return CONTINUE_PROCESSING if the processing of the given Context should be delegated to a subsequent Command in an enclosing Chain.
      static boolean PROCESSING_COMPLETE
      Commands should return PROCESSING_COMPLETE if the processing of the given Context has been completed.
    • Field Detail

      • CONTINUE_PROCESSING

        static final boolean CONTINUE_PROCESSING

        Commands should return CONTINUE_PROCESSING if the processing of the given Context should be delegated to a subsequent Command in an enclosing Chain.

        Since:
        Chain 1.1
        See Also:
        Constant Field Values
      • PROCESSING_COMPLETE

        static final boolean PROCESSING_COMPLETE

        Commands should return PROCESSING_COMPLETE if the processing of the given Context has been completed.

        Since:
        Chain 1.1
        See Also:
        Constant Field Values
    • Method Detail

      • execute

        boolean execute​(Context context)
                 throws java.lang.Exception

        Execute a unit of processing work to be performed. This Command may either complete the required processing and return true, or delegate remaining processing to the next Command in a Chain containing this Command by returning false

        Parameters:
        context - The Context to be processed by this Command
        Returns:
        true if the processing of this Context has been completed, or false if the processing of this Context should be delegated to a subsequent Command in an enclosing Chain
        Throws:
        java.lang.Exception - general purpose exception return to indicate abnormal termination
        java.lang.IllegalArgumentException - if context is null