Raible Designs

However, currently there is no Validation / Interceptor architecture like Struts. Unfortunately you'd have to hack that type of validation into your application. Considering Echo is based on Swing's Interfaces, it's going to inherit Swing's validation framework, which basically means that validation will occur in the actionListener method when a user clicks a button...

However, I can understand the power and need to externalize that kind of thing into the XML files... One person has suggested the use of commons-validation but no one has reported success either way. It really needs some sort of declarative framework though...

On a side note, I'm thinking that XDoclet is something that I seriously need to learn. :)

thx

Posted by mnickel on February 04, 2004 at 11:23 PM MST #

public class Pojo {
   private Integer id;
   private Integer[] checkboxFields;
   private String username;
   private Date date;
   // assume the usual accessors
}

<input type="text" name="date" value="2/4/2004">

public class PojoAction implements Action, ModelDriven {
    private Pojo model = new Pojo() ;

    // ModelDriven implementation
    public Object getModel() { return model; }

    // Action implementation
    public String execute() {
        Session session = // fetch hibernate session;
        session.save(model);
        // close hibernate session here
        return "success";
    }
}

Posted by Matt Ho on February 05, 2004 at 12:50 AM MST #

Posted by Redmapper on February 05, 2004 at 07:17 AM MST #

Posted by Scott Mitchell on February 05, 2004 at 11:54 AM MST #

Posted by Arron Bates on February 05, 2004 at 12:19 PM MST #

Posted by Erik Hatcher on February 05, 2004 at 07:51 PM MST #

Posted by PSK on February 07, 2004 at 10:33 PM MST #

Posted by PSK on February 09, 2004 at 05:29 PM MST #

Posted by Juergen Hoeller on February 10, 2004 at 04:27 AM MST #

First we created a project-specific abstract base class that extends ActionForm, and implements the DynaBean interface. We added a Map to our form class to cache UI string values (both inbound and outbound), and implemented the DynaBean get() and set() methods to transparently access its values. We overrode the RequestProcessor such that prior to forwarding to the JSP, it invokes a method on the form that populates the Map of string values by recursively descending the object graph that begins at the form. Conversions are done on bean properties by instances of Formatter classes. Our framework provides a default set of bindings of Java types to Formatter classes, so that this stuff happens automagically, unless the developer specifies something other than the default (very rare in our application since we have custom value classes for money, percentages, etc., but quite easy to do, either through a Java API or XML).

The Map that is built models the structure of the object graph, so that references in the JSP look exactly like they would normally (e.g., <bean:write name="foo" property="bean.nestedBean.someProperty"/>). When Struts (using beanutils) binds inbound values, the beanutils code sees that the form is a DynaBean and invokes it's get() method to get the initial value in the keypath. We designed our implementation to lie about the underlying data types (telling beanutils that they're all Strings or arrays of Strings) to avoid ConvertUtils conversions.

We then added a bit of code to our RequestUtils processValidate() method to invoke a method on our form class that binds the values from the Map to the real objects. Our framework again finds the approriate Formatter classes by introspecting the property types (don't worry, we cache all this stuff, so the overhead is minimal). Any time a conversion error is encountered, the framework automatically adds an ActionError with an appropriate error message. If there are no conversion errors, the form calls the regular validation code.

This design allows us to use POJOs in our ActionForms, and automatically handles conversion errors and formatting. You can actually do an even simpler version of this with beanutils 1.7, by subclassing BeanUtilsBean and PropertyUtilsBean to allow values to be diverted to the Map of strings (DynaBean's a pretty big interface, so there's a lot more you have to do to use that approach, though it's arguably a more robust way to do it).

On the other hand, if you don't *have* to use Struts (a lot of projects mandate it), then by all means look at Tapestry. I haven't worked with it myself, but I have used WebObjects (which takes a similar approach) quite a bit, and it's one tenth the work/ten times the flexibility of doing stuff with *any* JSP-based framework.

Posted by Jonathan Lehr on February 11, 2004 at 06:24 PM MST #

Posted by Eelco Hillenius on April 09, 2004 at 04:27 PM MDT #

Posted by 203.88.149.218 on January 23, 2007 at 03:55 AM MST #

Posted by 122.169.244.87 on August 19, 2008 at 12:04 AM MDT #