How to design correct validation module for your J2EE application?

Validation is an important aspect of any J2EE applications.Several approaches are currently used in different layers.In most of the applications, the validation is commonly kept at Presentation tier-both at server side (struts validator) as well client side(java script). And few places the logic is embedded with business tier - for SOA systems.

There is strong argument that validation,especially user inputs validations are not core business logic and they should NOT be coupled with business tier. Also keeping them at inner layers results in performance bottleneck.This sounds good especially if business tieris going to serve only web interface. However in current business scenario, service layer should be built robustly so that in future it can be used to serve multiple clients - web services, web interface, any batch processes etc

This also leads to Domain Driven validation - Validation at Service/Domain layer.
The first thought on keeping the validation at domain layer is that - Domain object should be always "VALID". Hence it cannot contain any invalid data and validate itself. This is self contradictory.

This pretty much leaves us a single option - Validation @ Service Tier

Okay...what are the approaches? Any patterns

Consider an example.An admin functionality to Add/Edit/Delete and View User Details.The application has following layers

• Web MVC - Struts - UserAction (Struts Action) and UserForm (Struts Form)
• Service & Data Access - Spring - UserDTO (POJO for data transfer),UserService (Service), UserManager(DAO) and Domain object User

On high level, there are two level of validations for this Domain Object

1. Field Level Validations- UserName(content,length),Password(content,length,combinations),Email,FirstName,LastName,Status
2. Object Level Validations - Mandatory fields,Specific combinations (User can only be added in Active status etc)

We need to devise different sets of validation as below

• validateSearch - Only Field level validations. ie, all input fields (whatever entered) should be alphanumeric,email should be valid.If any of the fields are invalid add warning message and carry forward the search.
• validateAdd - Field level and object level validations
• validateUpdate - Field level and object level validations

---

Solution 1

Summary:

• Inject Dynamic Proxy validation service layer for exisiting service calls-On successful validation, the actual service methods will be called
• Custom Validation classes specific to Domain objects can be created and injected in Spring application context
• Need to explore how to collect validation errors.

Advantages

• Pure Spring way
• Declarative and validation implementation can be changed anytime without affecting any structure
• Scalability & Robustness
• Code-Reusability

Disadvantages

• Performance issue to make dynamic proxy calls
• Already Service calls are routed as dynamic proxies for Transaction Management and this will add additional layer
• Over kill for more of user input validations?! [w.r.to LCN application nature]

---

Solution 2

Summary:

• Define Validator classes that implements Spring Framework Validator interface, specific to domain objects
• Invoke validate() method with specific validation type[SEARCH,INSERT,UPDATE] on corresponding Service methods;
• Use Data Binder and MessageCodesResolver to retrieve the ErrorMessages
• Devise mechanism to automatically map the Spring Error Messages to Struts ActionErrors

Advantages

• Utilization of Spring infrastructure and possible extention

Disadvantages

• Framework dependent.
• Framework is rudimentary and need to define lot of custom methods for our application

---

Solution 3

Summary:

• Define custom Validator class containing validate() method for each domain object at service layer
• Invoke validate() method with specific validation type[SEARCH,INSERT,UPDATE] on corresponding Service methods;
• Consolidate validation errors on ServiceMessage object which can be saved to struts specific ActionErrors
• Code Reusage can be acheived by having utility methods like EmailValidator, NumericValidator,AlphaNeumericValidator etc

 UserAction.java - Struts Action
 class UserAction extends Action{
   ActionForward searchUser(){
     UserForm uform=(UserForm)form; 
     UserDTO dto=new UserDTO(); 
     BeanUtils.copy(uform,dto); 
     UserService userSvc=getUserService();  dto=userSvc.findUser(dto);
   } 
  ActionForward addUser(){
      UserForm uform=(UserForm)form; 
      UserDTO dto=new UserDTO(); 
      BeanUtils.copy(uform,dto); 
      UserService userSvc=getUserService(); 
    ServiceMessage svcMsg=userSvc.addUser(dto);
  if(svcMsg.getErrorMessage().size()>0){  
      ActionMessages errors=new ActionMessages()  
     //Copy the keys to actione messages  
      copyErrors(svcMgs.getErrorMessage(),errors);  
    //All set. Now the JSP html:errors will print the Error Messages defined in ApplicationResource.properties  
      saveErrors(request,errors)     }
 }
 }
UserService.java - Service Interface
 class UserService{
 UserDTO findUser(UserDTO dto){
     UserValidator validator=new UserValidator(); 
     validator.setValidationType(ValidationConstants.SEARCH); 
     boolean isValid=validator.validate(dto);   
     if(isValid){  
       UserManager manager=new UserManager();  
       dto=manager.findUsers(dto); 
     }else{  
     validator.getErrorMessages();
  }
 return dto;
}

ServiceMessages addUser(UserDTO dto){
  UserValidator validator=new UserValidator(); 
  validator.setValidationType(ValidationConstants.INSERT); 
  boolean isValid=validator.validate(dto);   
 if(isValid){  
    UserManager manager=new UserManager();  
    manager.addUsers(dto); 
}else{  
  ServiceMessages svcMsg=validator.getErrorMessages();
  }
 return svcMsg; }
 }
UserValidator.java
class UserValidator implements Validator{
     String validationType;
     ServiceMessage serviceMessage
    
    boolean validate(UserDTO dto){
        boolean isValid=false;
     if(getValidationType().equals(ValidationConstants.INSERT)){ 
       if(StringUtils.isEmpty(dto.getUserName()){  
        serviceMessage.add(Type.ERROR,"username.empty"); 
     } }
       return isValid;}
}
ServiceMessage.java
class ServiceMessage {
List errorMessage;List warningMessage;

void add(String type,String key){
       if(type.equals(Type.ERROR){ 
          errorMessages.add(key);
      }else if(type.equals(Type.WARNING){ 
         warningMessage.add(key);
     }
}
}

Advantages

• Service Layer to offer centralized validation irrespective of the client
• Independent of any frameworks
• Code-Reusability

Disadvantages

• Kind of - Re-inventing wheel
• Possible Performance impact-as Service calls are coslier than just Web tier calls.