Integration of Drools and spring to perform business logic validation in JSF

In a previous post I explained how to use AOP to perform custom validation in JSF. Here I will show how you can use the business logic framework Drools to perform validation based upon external (business) rules in conjunction with springframework.

In this example I will perform the bussiness rules validation inside an advice class, but you can implement the same mechanism to perform that validation inside a JSF backing bean or in a spring bean.

Inside your application-context.xml file add your advice in the following way:

<bean id="validatorAspect" 
   class="com.foo.aspects.BackingBeanValidatorAdvice" 
   factory-method="aspectOf">
<property name="resources">
<list>
<value>/com/foo/business/rules.drl</value>
</list>
</property>
</bean>

I'm assuming you have basic knowledge of Drool, I will not get into syntax details here, there is a lot of documentation in Drool's site; instead I will just present a simple validation rule file rules.drl:


package com.foo.business

import com.foo.model.ModelBean;
import com.foo.aspects.Error;

query "Error" ()
    error : Error()
end


rule "Rule 1"
when
   ModelBean( id == 32 && internalId not matches "(J|P|R) ([0-9]){6}")
then
   Error err = new Error();
   err.setSummary("Error in Model Bean. ");
   err.setDetail("Internal Id not matches format: (J, P o R) followed by whitespace and 6 digits");
   insert(err);
end

Error is just a simple Pojo containing two properties (summary and detail).

Then, you must fire the validation inside the advice class:

public aspect BackingBeanValidatorAdvice {

    private KnowledgeBase kbase;

    private StatefulKnowledgeSession ksession;
    
    private String[] resources;

    pointcut doSaveChanges() : execution(* com.foo.beans.BackingBean.saveChanges(..));

    void around() : doSaveChanges() {
        FacesContext context = FacesContext.getCurrentInstance();
        ModelBean mbean = context.getApplication().evaluateExpressionGet(context, "#{bBean.selected}", ModelBean.class); 

        this.init();
        this.getKsession().insert(mbean);
        this.getKsession().fireAllRules();

        QueryResults results = this.getKsession().getQueryResults("Error");
        if (results.size() > 0) {
            for (QueryResultsRow row : results) {
                Error err = (Error) row.get("error");
                context.addMessage("error", new FacesMessage(FacesMessage.SEVERITY_ERROR, err
                        .getSummary(), err.getDetail()));
            }
        }
        proceed();
    }

    public void init() {
        if (this.getKbase() == null) {
            KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
            for (int i = 0; i < this.getResources().length; i++) {
                String rule = this.getResources()[i];
                kbuilder.add(ResourceFactory.newInputStreamResource(this.getClass().getResourceAsStream(rule)),
                    ResourceType.DRL);
            }
    
            if (kbuilder.hasErrors()) {
                System.out.println(kbuilder.getErrors());
                return;
            }
            Collection < KnowledgePackage > kpkgs = kbuilder.getKnowledgePackages();
            KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
            kbase.addKnowledgePackages(kpkgs);
            this.setKbase(kbase);
        }
        this.setKsession(this.getKbase().newStatefulKnowledgeSession());       
    }
    
    public StatefulKnowledgeSession getKsession() {
        return ksession;
    }

    public void setKsession(StatefulKnowledgeSession ksessionToSet) {
        this.ksession = ksessionToSet;
    }

    public String[] getResources() {
        return resources;
    }

    public void setResources(String[] resourcesToSet) {
        this.resources = resourcesToSet;
    }

    public KnowledgeBase getKbase() {
        return kbase;
    }

    public void setKbase(KnowledgeBase kbase) {
        this.kbase = kbase;
    }    
}

That's it. In case the validation fails, a FacesMessage is added to the FacesContext and JSF is responsible for handling and showing the error in a jsf page, eg: <h:messages .../>

How to create a "Processing" panel in RichFaces

Supose you have a page with a form inside to edit some values, and you want to show a "Processing" or "Please Wait" message when you click on a "save" button on that form. In RichFaces you can use the popupPanel compoment to this purpose.

This article assumes you are using RichFaces 4, and JSF/Facelets

I've created this wait.xhtml file containing only the wait panel to favor reusability and maintainability.


<ui:composition xmlns="http://www.w3.org/1999/xhtml" 
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:rich="http://richfaces.org/rich"
xmlns:a4j="http://richfaces.org/a4j">

<a4j:status name="waitStatus" onstart="#{rich:component('wait')}.show();"
onstop="#{rich:component('wait')}.hide();" />
<rich:popupPanel id="wait" autosized="true"
modal="false" moveable="false" resizeable="false" zindex="2005">
<f:facet name="header">
<h:outputText value="Processing" />
</f:facet>
<h:outputText value="Please wait..." />
</rich:popupPanel>
</ui:composition>


In the page where you have the form, add the reference to that file:

...
<ui:include src="../wait.xhtml" />
</h:form>

Somewhere inside the form you'll have a "Save" button that processes the input:


<a4j:commandButton value="Save"
action="#{bBean.save}"
status="waitStatus"
oncomplete="if (#{facesContext.maximumSeverity==null}) #{rich:component('ap')}.hide(); return false;">
</a4j:commandButton>

The key part for the wait popup panel to appear only when the "Save" commandButton is clicked, is the status="waitStatus" that links the action of the commandButton to the a4j:status that opens the wait panel.

If you don't do it this way, the wait panel will popup upon every ajax call  in the editing form (autocomplete fields, a4j:ajax calls, etc).

Hope this helps, comment if you have problems with this approach.

Use aspectj-maven-plugin to perform custom validation in JSF

You can use AspectJ to do many things, but its potential arise when you use it in order to apply the SoC paradigm.
In this post I will show you how to use it to perform custom validation in the presentation layer of a JSF webapp. Later I will show how to use spring to define more generic pointcuts in your application.

Note: I'll asume you already have basic knowledge of AOP in general and AspectJ in particular. I will not get into syntax and terminology details here. You can consult AspectJ site for documentation and resources. You can also find some terms definitions used here in Captain Debug's Blog.

It is very straightforward to configure AspectJ when you are using maven in your project. All you have to do is to add the aspectj-maven-plugin in the build section of your pom.xml:

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>aspectj-maven-plugin</artifactId>
<version>1.2</version>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>test-compile</goal>
</goals>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjtools</artifactId>
<version>1.6.1</version>
</dependency>
</dependencies>
</plugin>

You have to add the aspectjrt and aspectjtools dependencies to the plugin in order to let maven find the necessary to compile the AspectJ source.


Then you can code the validation AspectJ advice BackingBeanValidatorAdvice.aj as a normal source file:

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
...

public aspect BackingBeanValidatorAdvice {

    pointcut doSaveChanges() : execution(* com.foo.beans.BackingBean.saveChanges(..));

    void around() : doSaveChanges() {
        FacesContext context = FacesContext.getCurrentInstance();
        BBean bbean = context.getApplication().evaluateExpressionGet(context, "#{bBean.selected}", BBean.class); 

        // perform custom validation

        // if validation fails
        if (..) {
         String sum = "...";
         String det = "...";
         context.addMessage("error", new FacesMessage(FacesMessage.SEVERITY_ERROR, sum, det);
         return;
        }
        proceed();
    }
}

Doing this, when your backing bean's saveChanges(..) method is invoked, the pointcut is reached and the advice performing the custom validation is executed. Then, back to the jsf page, you can show the error's custom message as usual using <h:messages ... />

As you can see, you can apply this mechanism also to perform logging, database audits, notifications, etc. That's precisely the potential of AspectJ used in conjunction with SoC design principle.


Automatic pointcut configuracion using Spring

In this article, you had to add the pointcut manually in your advice's source. If you are using springframework, you can configure the pointcuts in the application-context.xml. Here is an example of using AOP in spring to implement a database logging concern without modifying a single line of code in your existing application. In your application-context.xml file add the following:

...

<bean id="databaseAuditAutoProxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  <property name="beanNames">
<list>
<value>*Dao</value>
</list>
  </property>
  <property name="interceptorNames">
<list>
<value>regexpAdvisor</value>
</list>
  </property>
</bean>

<bean id="regexpAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
<property name="advice">
<ref local="databaseLoggerAuditAdvisor"/>
</property>
<property name="pointcut">
   <bean class="org.springframework.aop.support.JdkRegexpMethodPointcut">
<property name="patterns">
<value>.*read.*,.*load.*,.*get.*,.*save.*,.*Username.*</value>
</property>
<property name="excludedPatterns">
<value>.*find.*,.*History.*</value>
</property>
   </bean>
</property>
</bean>

<bean id="databaseLoggerAuditAdvisor" class="com.foo.aspects.DatabaseLoggerAuditAdvice">
<property name="auditService" ref="auditService"/>
</bean>
...

The databaseAuditAutoProxy automatically create proxies for the beans names that match beanNames attribute. The regexpAdvisor references the advisor implementation itself and defines a pointcut that uses regular expressions to define method names to intercept.

Then you have to code the DatabaseLoggerAuditAdvice.aj class:

public class DatabaseLoggerAuditAdvice implements MethodBeforeAdvice, AfterReturningAdvice, ThrowsAdvice {

    private AuditService auditService;

    public LoggerAuditAdvice() {
    }

    /**
     * @see org.springframework.aop.MethodBeforeAdvice#before(java.lang.reflect.Method,
     *      java.lang.Object[], java.lang.Object)
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {

        log = LogFactory.getLog(target.getClass());
        if (log.isInfoEnabled()) {
            Audit audit = new Audit();
            audit.setUsername(SecurityHelper.getUserName());
            audit.setTime(new Date());
            audit.setMethodName(method.getName());
            audit.setMethodArgumentsValue(ArrayUtils.toString(args, "null"));
            log.info(" [[[BEFORE]]] " + audit);
        }
    }

    /**
     * @see org.springframework.aop.AfterReturningAdvice#afterReturning(java.lang.Object,
     *      java.lang.reflect.Method, java.lang.Object[], java.lang.Object)
     */
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {

        log = LogFactory.getLog(target.getClass());
        if (log.isInfoEnabled()) {
            Audit audit = new Audit();
            audit.setUsername(SecurityHelper.getUserName());
            audit.setTime(new Date());
            audit.setMethodName(method.getName());
            audit.setMethodArgumentsValue(ArrayUtils.toString(args, "null"));
            audit.setTarget(target.getClass().getSimpleName());
            log.info(" [[[AFTER]]] " + audit);
            this.getAuditService().save(audit);
        }
    }

    public void afterThrowing(Method m, Object[] args, Object target, Throwable ex) {
        log = LogFactory.getLog(target.getClass());
        log.error("Exception in method: " + m.getName() + " Exception is: " + ex.getMessage() + " for user "
            + SecurityHelper.getUserName());
    }

    public AuditService getAuditService() {
        return auditService;
    }

    public void setAuditService(AuditService auditServiceToSet) {
        this.auditService = auditServiceToSet;
    }
}

Hope it helps, comment and give feedback.

PS: If you get errors in your project, you have to make sure you have added  *.aj as source files, and to make the project as a "AspectJ Project", ie, add the AspectJ runtime. The method may vary depending on the IDE you are using. In Eclipse, you have to configure the project as an AspectJ Project (right click on the project, Configure > Convert to AspectJ Project..) and add *.aj fileset mapping to the source code in the Java Build Path of your project.

Solving character encoding issues in JSF

When developing a non-english webapp, you'll probably encounter some issues with special characters as "ñ", "á", etc, ie, when you input some of this characters in a text input field, you get those characters back from the server rendered as "Ö" or something similar.

The best approach is to use UTF-8 enconding all over the application so the response is not encoded differently depending of the place that handles that response.

This approach applies to:

• Tomcat 6
• Java 1.6
• MyFaces 2.1.10
• RichFaces 4.2.3-Final

The places to configure the encoding are:

• server.xml in Tomcat
  
  It's neccesary to get Tomcat to encode GET parameters. This is done by adding the URIEncoding attribute to the HTTP connector.

          <Connector port="8080" protocol="HTTP/1.1" URIEncoding="UTF-8"

           .... />

• Servlet Filter
  
  Implement a servlet filter to do the UTF-8 encoding of  the requests and responses:
  
  

  public class SetCharacterEncodingFilter implements Filter {
  
      protected String encoding = null;
      protected FilterConfig filterConfig = null;
      protected boolean ignore = true;
  
      /**
       * Take this filter out of service.
       */
      public void destroy() {
          this.encoding = null;
          this.filterConfig = null;
      }
  
      /**
       * Select and set (if specified) the character encoding to be used to
       * interpret request parameters for this request.
       * @param request The servlet request we are processing
       * @param result The servlet response we are creating
       * @param chain The filter chain we are processing
       * @exception IOException if an input/output error occurs
       * @exception ServletException if a servlet error occurs
       */
      public void doFilter(ServletRequest request, ServletResponse response,
                           FilterChain chain)
   throws IOException, ServletException {
  
          // Conditionally select and set the character encoding to be used
          if (ignore || (request.getCharacterEncoding() == null)) {
              String encoding = selectEncoding(request);
              if (encoding != null)
                  request.setCharacterEncoding(encoding);
          }
  
          response.setContentType("text/html; charset=UTF-8");
          response.setCharacterEncoding("UTF-8");
          // Pass control on to the next filter
          chain.doFilter(request, response);
      }
  
      /**
       * Place this filter into service.
       * @param filterConfig The filter configuration object
       */
      public void init(FilterConfig filterConfig) throws ServletException {
   this.filterConfig = filterConfig;
          this.encoding = filterConfig.getInitParameter("encoding");
          String value = filterConfig.getInitParameter("ignore");
          if (value == null)
              this.ignore = true;
          else if (value.equalsIgnoreCase("true"))
              this.ignore = true;
          else if (value.equalsIgnoreCase("yes"))
              this.ignore = true;
          else
              this.ignore = false;
      }
  
      /**
       * Select an appropriate character encoding to be used, based on the
       * characteristics of the current request and/or filter initialization
       * parameters.  If no character encoding should be set, return
       * null.
       * * The default implementation unconditionally returns the value configured
       * by the encoding initialization parameter for this
       * filter.
       *
       * @param request The servlet request we are processing
       */
      protected String selectEncoding(ServletRequest request) {
          return (this.encoding);
      }
  
  }
  
  

  
  Then you have to reference and map that filter in web.xml:
  
  <filter>
     <filter-name>SetCharacterEncodingFilter</filter-name>
     <filter-class>com.foo.filters.SetCharacterEncodingFilter</filter-class>
     <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
     </init-param>
  </filter>
  <filter-mapping>
     <filter-name>SetCharacterEncodingFilter</filter-name>
     <url-pattern>*.xhtml</url-pattern>
  </filter-mapping>
  
  
  Here I mapped only xhtml files because I'm also encoding the responses to UTF-8, so mapping images and other resources as UTF-8 will probably generate an encoding error.

• .xhtml Files
  
  One final step is neccesary to ensure we have coherent encoding all across the webapp.
  
  The first line in the xhtml files must be:

    <?xml version="1.0" encoding="UTF-8"?>

         Then, inside the head tag of the xhtml, add the following meta tag:

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

This is a lot less painful if you are using facelet templating technique; if that is the case, you'd only have to add the line mentioned above in the master template instead of in every .xhtml file.

Hope this helps, comment if you have any problem using this aproach.

How to setup a masked input for rich:calendar in RichFaces

In richfaces you can use jquery to set up masked inputs. First, you must download masked input plugin for the jQuery javascript library and reference it in some part of the page:

<h:outputScript name="js/jquery.maskedinput-1.3.min.js" target="head" />

Then, to mask some input field you should do:


<h:inputText id="date" value="#{bBean.date}" >
    <rich:jQuery selector="#date" query="mask('99/99/9999',{placeholder:'_'})" />
</h:inputText>

Unfortunely, the same doesn't work for rich:calendar. Richfaces automatically renders rich:calendar into an input field for the date text and a div for the calendar itself. The input field is generated with the id of the rich:calendar tag plus "inputDate" as a prefix: ie, if the calendar has id="dob", the generated input field will have the id="dobInputDate"; so one workaround could be:

<h:form id="someForm">
    ...

    <rich:calendar id="date" value="#{bBean.date}"
        enableManualInput="true" popup="true" showApplyButton="false" >
    </rich:calendar>
    <rich:jQuery selector="#someForm\:dateInputDate" query="mask('99/99/9999',{placeholder:'_'})" />
    ...
</h:form>

The attribute enableManualInput of the calendar should be set to true, otherwise it doesn't make sense to mask the input field.

Avoid closing a rich:popupPanel in richfaces when validation error occurs

In richfaces is common to have a rich:popupPanel that allows some input. If you must validate that input, you may want to left the panel open when a validation error occurs to show error messages. See the following picture that shows the case:

You can achieve this using the oncomplete attribute of the a4j:commandButton tag.


<rich:popupPanel 
  id="cp" minHeight="200" minWidth="450" modal="true"
     domElementAttachment="form" autosized="true">
....


   <a4j:commandButton
      value="Save"
      disabled="#{not securityScope.userInRole['ROLE_ABM']}"
  action="#{backingBean.save}"
      oncomplete="if (#{facesContext.maximumSeverity==null}) 
                  #{rich:component('cp')}.hide(); return false;">
   </a4j:commandButton>
...
</rich:popupPanel>

The important part is  #{facesContext.maximumSeverity == null} to ensure that there are no errors present after validation.

Migration from JSF 1.x to JSF 2

This is one of the things you have to change when migrating your JSF-Spring application from JSF 1.x to JSF 2.

In JSF 1.x, to get access to a spring bean in a backing bean or in a converter, you would do:

FacesContext context = FacesContext.getCurrentInstance();
MyService myService = (MyService) context.getApplication().createValueBinding("#myService}").getValue(context);

In JSF 2 this is replaced by:

FacesContext context = FacesContext.getCurrentInstance();
MyService myService = (MyService) context.getELContext().getELResolver().getValue(context.getELContext(), null, "myService");


Another way to do it would be:

FacesContext context = FacesContext.getCurrentInstance();
String remoteUser = context.getApplication().evaluateExpressionGet(context, "#myService.currentUser}", String.class);