Implementing Validation Rules using Aspects

[18]Loan Application Use Case

The use case for the loan processing application starts with the user entering loan details in an HTML form and submitting it, which triggers data validation on both the client and server tiers. Depending on successful data validation, a confirmation number is provided to the user that can be used for future inquiries on the loan application. These steps are shown in the sequence diagram in Figure 1.

Now, let's look at the main components of the sample application.

1. Client interface: I used Spring MVC for the controller (web navigation) layer in the loan processing application. This includes a JSP as the view and a Spring Controller to handle the navigation.

2. The listing below shows the sample code of the onSubmit method controller class (LoanApplicationController).

   
   protected ModelAndView onSubmit(HttpServletRequest request,
           HttpServletResponse response,
           Object command, BindException errors)
           throws Exception {
   
       System.out.println("Enter onSubmit().");
       LoanApplication loanApp = (LoanApplication)command;
       System.out.println("LoanApplication:\n"+loanApp.toString());
   
       int confirmationNumber = service.registerLoanApplication(loanApp);
   
       // Get opportunities
       request.setAttribute("confirmationNumber",
           Integer.toString(confirmationNumber));
   
       return new ModelAndView(getSuccessView());
   }
   
   

3. Service layer: I used Spring for writing the service layer that calls the DAO object to perform CRUD operations on the LoanApplication table in the back-end database.

4. A code snippet of the registerLoanApplication method in the LoanApplicationService class is shown below.

   
   public int registerLoanApplication(LoanApplication loanApp)
   {
       int confirmationNumber = 0;
   
       try
       {
           dao.updateLoanApplication(loanApp);
   
           // Get confirmation number for the submitted loan application
           confirmationNumber =
               dao.getLoanApplication(
                   loanApp.getLoanAppId()).getConfirmationNumber();
   
   
       } catch (DAOException e)
       {
           log.error(e,e);
       }
       return confirmationNumber;
   }
   
   

5. Database: I created the loandb database using the Hypersonic SQL database. The database has a single table called LoanApplication.
6. Rules: I defined validation rules in an XML file and used the Drools API to load and apply these rules to the data fields.

7. The validation rules for the loan application fields are defined in rules XML files as shown below.

   
   <?xml version="1.0"?>
   <rule-set name="LoanApplicationRules"
           xmlns="http://drools.org/rules"
           xmlns:java="http://drools.org/semantics/java"
           xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
           xs:schemaLocation="http://drools.org/rules rules.xsd
           http://drools.org/semantics/java [20] java.xsd">
   
       <!-- Java Imports -->
       <java:import>java.lang.Object</java:import>
       <java:import>java.lang.String</java:import>
       <java:import>com.loanapp.domain.LoanApplication</java:import>
   
       <!-- Java function to print message -->
       <java:functions>
           public void printMessage(
               com.loanapp.domain.LoanApplication loanApp,
               String msg)
           {
               System.out.println(msg);
           }
       </java:functions>
   
       <!-- Validate SSN -->
       <rule name="SSN Validation">
   
           <parameter identifier="loanApplication">
               <class>LoanApplication</class>
           </parameter>
   
           <java:condition>
               loanApplication.getSsn().length() < 9
           </java:condition>
   
           <java:consequence>
               printMessage(loanApplication,
                   "Invalid SSN - should be 9 digits.");
           </java:consequence>
       </rule>
   
       <!-- Check Loan Amount -->
       <rule name="LoanAmount Is High">
   
           <!-- Parameters -->
           <parameter identifier="loanApplication">
               <class>LoanApplication</class>
           </parameter>
   
           <!-- Validate the data field -->
           <java:condition>
               loanApplication.getLoanAmount().intValue() > 1000000
           </java:condition>
   
           <java:consequence>
               printMessage(loanApplication,
                   "LoanAmount is higher than the allowed limit.");
           </java:consequence>
       </rule>
   
   </rule-set>
   
   

   And the code implementation of loading these validation rules using Drools API is as follows:

   
   public void doValidation(BaseDomainObject domainObj)
       throws ValidationException
   {
       runValidationRules(domainObj);
   }
   
   public void runValidationRules(BaseDomainObject domainObj)
   {
       try
       {
           // Validation Rules File Name
           String ruleFileName = 
               domainObj.getClass().getName()+"Rules.xml";
           // Load the validation rules
           loadRules(ruleFileName);
   
           WorkingMemory workingMemory =
               validationRules.newWorkingMemory();
           workingMemory.addEventListener(
               new DebugWorkingMemoryEventListener());
           workingMemory.assertObject(domainObj);
   
           // Fire rules
           workingMemory.fireAllRules( );
       }
       catch (Exception e)
       {
       }
   }
   
   /**
    * Load the business rules from the xml file
    */
   private static void loadRules(String ruleFileName)
       throws Exception
   {
       if (validationRules == null)
       {
           //Specify this resolver when we load are rules
           validationRules = RuleBaseLoader.loadFromUrl(
                   BusinessLayer.class.getResource(
                       "/rules/"+ruleFileName));
       }
   }
   
   

8. Aspects: I wrote aspects to apply validation rules to various data fields (or methods, in the case of server code) in the loan application. We inject these rules into the controller (MVC layer) and service classes to implement the validation rules wherever we need them. For more information on Aspects and AOP check, out the articles "Introduction to Aspect-Oriented Programming [21]" and "Performance Analysis of J2EE Applications Using AOP Techniques [22]."

9. The following listings show the pointcuts and advices defined to inject validation code into the LoanApplicationController and LoanApplicationService classes, respectively.

   Here's a pointcut and around advice to intercept the onSubmit() method and apply validation on the LoanApplication object.

   
   @Pointcut(
          "execution(* *.onSubmit(..)) && args(request, response, command, errors)"
   )
   void executeOnSubmit(HttpServletRequest request,
          HttpServletResponse response,
          Object command, BindException errors) {};
   
   @Before("executeOnSubmit(request, response, command, errors)")
   public void beforeOnSubmit(HttpServletRequest request,
          HttpServletResponse response,
          Object command, BindException errors) {
      System.out.println("beforeOnSubmit");
   }
   
   @Around("executeOnSubmit(request, response, command, errors)")
   public Object aroundOnSubmit(ProceedingJoinPoint jp,
          HttpServletRequest request,
          HttpServletResponse response,
          Object command, BindException errors) {
      Object proceedResult = null;
      System.out.println("aroundOnSubmit");
      try {
          DataValidator validator = new DataValidator();
          BaseDomainObject domainObj = (BaseDomainObject)command;
          validator.doValidation(domainObj);
   
          proceedResult = jp.proceed();
      } catch (Throwable t) {
          log.error(t,t);
      }
      return proceedResult;
   }
   
   
   

   Here's the pointcut and advice for the registerLoanApplication() method in LoanApplicationService class.

   
   @Pointcut(
         "execution(* *.registerLoanApplication(..)) && args(loanApp)"
   )
   void executeRegisterLoanApplication(LoanApplication loanApp) {};
   
   @Before("executeRegisterLoanApplication(loanApp)")
   public void beforeRegisterLoanApplication (
           LoanApplication loanApp) {
      System.out.println("before");
   }
   
   @Around("executeRegisterLoanApplication(loanApp)")
   public int aroundRegisterLoanApplication (
           JoinPoint thisJoinPoint, LoanApplication loanApp) {
      System.out.println("aroundRegisterLoanApplication");
      return 0;
   }
   
   

Figure 2 shows the different elements of the validation framework and their relationship with each other.

Testing Validation Rules

I wrote two JUnit test scripts (DataValidatorTest and LoanApplicationControllerTest) to verify that validation is working correctly by submitting both valid and invalid data. If validation fails, we set the validation flag in the LoanApplication object to false, indicating that the data cannot be sent to the server. LoanApplicationControllerTest is a good example, since it can be executed outside the J2EE container and the DAO returns a test confirmation number. I also wrote a test client (called LoanApplicationClient) using Commons HttpClient to simulate a web request with data fields filled in with the loan application details. Once the Submit button is clicked, validation rules are applied to the submitted data and validation errors are returned for any invalid data.

If basic validation passes, server-side validation rules are then applied on the data sent by the client. If there is a violation of any of the rules, server will return error messages for the invalid data.

Conclusion

In this article, we looked at the implementation of data validation rules using a rules engine and aspects. Data validation is an essential part of any enterprise application, and using aspects to implement it offers the flexibility to respond in an agile manner to any changes in validation requirements.

We defined data validation rules using a rules engine (Drools) and used aspects to weave validation logic in those classes where validation is required to verify the quality of user-entered data.

Since we need some kind of validation on the web client so that we don't send any invalid data past the client layer, a better solution is to use JavaScript for basic validation (such as checking empty or null values and format) and process all other types of validations (such as checking for value and business validations) using a centralized custom data validation framework.

Sometimes, validation rules are stored in a SQL database. It's a good idea to store the validation rules in memory (cache) after loading them from the database for the first time. This way, we won't be hitting the database every time we need to validate a data field.

An administration tool to add new validation rules or modify or delete existing rules (preferably a JMX-based solution) would be a nice enhancement to the proposed validation framework.

Note that both object caching and monitoring are also cross-cutting concerns that can use the help of aspects for their implementation. Check out this article [24] on how we can implement object caching using AOP techniques.

Resources

• AOP Validation Framework Sample code [25]
• Java rules engines [26]
• "Give Your Business Logic a Framework with Drools [17]"
• "Implementing Object Caching with AOP [27]"

Srini Penchikala [1] presently works as an enterprise architect at Flagstar Bank.

Related Topics >> Programming [28]   |