Source Allies Blog

Multi-Step Forms in Django

Arlan Whatling — Fri, 13 Apr 2012 23:40:12 +0000

Forms in Django seem to be a relatively advanced topic if you want to do anything outside of models. Case in point: I had to develop a multi-step form in django that would spit out a certain result. There were only two forms that the user needed to fill out, but the second form had to change what fields it had based on the input from the first form. Also, the form did not save anything to the database; it just created a file for the end user to download. To solve this problem, I did research. A lot of research. And like any good technical topic, the information I needed was all over the place on the Internet.

The first solution I looked at was using Django’s built-in wizard system. Essentially, you create several form classes in your app’s forms.py file, and each form class translates to each step in the wizard. Then, in your project’s urls.py file your create a URL match and associate it with WizardForm.as_view([MyFormStep1, MyFormStep2, ...]). I spent most of my time trying to make this solution work, but the wizard objects in Django don’t do so well passing information from one form to the next, let alone modifying subsequent forms on the fly.

The second solution– the one I took in the end– was to basically make URLs that point to each step in the form (two URLs in my case) and handle passing POST data to subsequent forms myself. The forms still resided in the forms.py file for my app, but the logic for passing information from the first form to the second was handled in the views.py file. Each view function in views.py accepts an HTTPRequest object which has POST and GET members that store form information, if any, from the request. The second view function passed the POST data into the constructor of the second form, which could then add or modify its own form fields on the fly. Each view function used render_to_response() from django.shortcuts to put the forms on templates and present them to the user.

Example Code

forms.py

from django import forms

class MyFormStep1:
  car_brand = forms.ChoiceField(
    label="Select a car brand",
    choices=(('chevrolet', 'Chevrolet'),
      ('ford', 'Ford'), ('toyota', 'Toyota'))
  )

class MyFormStep2:
  def __init__(self, data_from_post = None):
    if data_form_post is not None:
      _post = data_from_post
      brand = _post.get('car_brand', None)
      list_of_cars = get_cars_by_brand(brand)

      for carname in list_of_cars:
         self.fields['car_%s' % carname] = forms.CharField(label=carname)

views.py

from myapp.forms import MyFormStep1, MyFormStep2
from django.shortcuts import render_to_response

def select_car_brand_view(request):
  form = MyFormStep1()
  return render_to_response('myform_1_template.html', {'form': form})

def list_cars_for_brand_view(request):
  form = MyFormStep2()
  return render_to_response('myform_2_template.html', {'form': form})

Conclusions

Is it an elegant solution? Probably not, since I didn’t use WizardForms from Django, but the amount of time I spent getting nowhere trying to mangle up a WizardForm implementation to get it to work definitely wasn’t any better.

If anyone has a better solution, I would love to hear from you in the comments section below. I’m a Django newbie.

Resources

http://stackoverflow.com/questions/1246322/get-previously-entered-information-in-django-formwizard
http://jacobian.org/writing/dynamic-form-generation/ (skip to “Part 2″ for the relevant parts)
“Django FormWizard with dynamic forms” - http://stackoverflow.com/a/358556/425533

Automated Testing Strategy for Legacy Systems

David Kessler — Sun, 01 Apr 2012 06:00:11 +0000

Once you catch the automated testing itch you want to write test for everything. But should we use the same strategy for every piece of software? The conclusion that I’ve come to is no. While I’m completely committed to the practice of TDD and aggressive test coverage, I’ve found that legacy software needs to be approached strategically.

Wikipedia defines a “legacy system” as

…an old method, technology, computer system, or application program that continues to be used, typically because it still functions for the users’ needs, even though newer technology or more efficient methods of performing a task are now available. http://en.wikipedia.org/wiki/Legacy_software

For this article I’ll be using a much narrower definition of this phrase. For this post “legacy software” is software that was written without automated tests.

Cement Shoes

After I drank the TDD kool-aid I wanted to write tests for everything. As the Technical Lead on a legacy system I began back-filling this application with tests. After a short amount of time I realized that I was fitting this app with a large pair of cement shoes.

As an committed agilist I was undermining my ability to respond to change by adding unit tests. Blindly applying a valuable practice was harming one of my core values. I was writing unit tests for code that may not be correct or even executed in production. This large enterprise application contained hundreds of thousands of lines of code. Spaghetti code that had not been tamed by test assertions.

Backward engineering unit test for each method was time consuming and mindless. Instead of designing tests that were expressive and reflected business requirements, I found myself creating awkward, confusing, poorly named tests. In many cases the code could not be tested without changing the very code that I was testing. As I was diligently slogging through the code I realized that I was not adding value to this application. In fact, I was pouring cement around poorly written code.

Test Types

Up until now I have been talking about unit tests. These are the most common type of automated tests but they are not the only ones. There are three types of tests: unit, integration and customer. I’m sure that someone will disagree with this narrow breakdown. Nevertheless, understanding this breakdown will help us understand how to test legacy systems. Unit tests verify a single piece of functionality in complete isolation. On the other hand, integration tests assert related functionality working together. Lastly, customer tests assert the behavior of the software from the user’s perspective.

Avoid associating these categories with tools. Unit tests are not one and the same as JUnit tests. Customer tests are not the same thing as Selenium or Cucumber. I can write any of these types of tests in JUnit or a variety of tools for that matter.

One other thing that needs to be said is that customer tests can blur between integration and unit testing boundaries. The only requirement is that a customer test focuses on user interactions. Users only see the final value, not all the individual functions that were called to calculate and format that value. On the other hand, unit tests and integration tests are mutually exclusive. Unit tests exercise a single function in isolation while integration tests exercise functions in unison.

Now that I’ve beaten a dead horse I will move on to legacy software.

Encapsulation

The problem that I encountered when I started writing unit tests for my legacy code was one of encapsulation. I was verifying the implementation at the wrong level of abstraction. Let me be clear, well written unit tests do not undermine the principles of encapsulation. However, in the case of this legacy system I was only certain that the customer interface was correct. The units of functionality within the system were producing a consistent user experience but any one piece of functionality was not necessarily correct.

To illustrate this point lets take a look at a trivial application.

There are two primary levels of abstract encapsulation within this application. The first one is at the system level. The second is at the level of each function. Within a legacy system we must preserve the customer experience. Whether a unit test passes or fails the customer tests must continue to preserve the customer experience.

In the example above there are three yellow boxes and three red boxes. The red boxes represent functionality that is no longer called by the application. The yellow boxes represent incorrect functionality. The top yellow box converts the incoming number to a decimal. While this may have been valuable in the past now the application is already passing in a decimal value. This conversion is unnecessary and it should not be preserved with a test.

The next two red boxes contain rate look-up functionality that’s no longer used. Writing tests around this would not only be useless, but it would insure that this code was not easily removed. The next two yellow boxes have a couple of issues. First of all, rounding to the penny before you round to the dollar is unnecessary and distracting. But even more importantly, why is it looking up local rates and formatting based on the region but it rounds based on US currency. And the final red box represents dead formatting code.

While this is a tiny example it represents a significant issue. These types of issues are sprinkled throughout large legacy code bases. Blindly plugging test holes in legacy systems can be ineffective and even harmful. Pouring testing cement around the previous example will just make it harder to change. Nevertheless, you should not make changes without customer tests.

The only thing that we need to preserve in a legacy system is the user experience. So the right level of encapsulation is at the UI level. Any code can be changed, added or deleted as long as the user can send an amount and location and get an accurate tip.

Initial Focus

When you begin to write automated tests for a legacy application you need to focus on customer tests. Whether your application is web-based, desktop, batch job, or service you need to focus your attention on how the software is used. Avoid writing tests that verify how the outputs are retrieved, calculated or formatted. Just verify that the user outputs are correct based on the provided inputs.

Defects

If you’re like me, only writing customer tests seems like a bad idea. The right time to write unit and integrations tests for internal implementation is when you receive defects. Unfortunately this will significantly slow down your response time. However it will also slow down the overall hemorrhaging of the system. Defects are the right time to add internal testing because you are focusing on specific functionality and you generally have access to business resources. The best time to write a test is when you are focused on solving a problem and clearly understand the business need. In legacy software this is often when you fix defects.

Several years ago I started writing automated tests for a legacy system that I had been supporting for years. Once I committed to writing tests for defects, no matter how long it took, I quickly reaped the benefits. Within a few months I broke a test while I was fixing a new defect. After I ruled out common test failure issues, I realized that the new requirements violated an existing business rule. I went back to the system owner and they amended the defect to be consistent with the rest of the system.

How many times have I broken existing code with my insightful and timely “fixes”? Based on my defect rates before I started writing automated tests, way too often. Now it’s possible, that my incompetence exceeds that of my readers. Nevertheless, it is wise for you to guard your amazing code from the incompetent fools that you work with. Who knows, I might get the privileged to work on your code and I will certainly screw it up without the safety net of automated tests.

New Features

Another opportunity in a legacy system to write full scale automated tests in during new feature development. This is a perfect time to add new customer tests for the new features and write unit and integration tests for the internal implementations. Don’t allow laziness to push this new code into the “legacy” code bucket that doesn’t have automated tests.

Conclusions

Legacy software needs a custom testing strategy. For new systems we write automated tests while we are solving the problem at hand. We have the context and focus necessary to write relevant tests. On the other hand, testing legacy systems should be approached from the outside in. Customer interactions must be preserved through automated tests while internal implementation testing should be delayed until the appropriate time.

The right time for testing internal behavior is during defect resolution. While this will slow down your defect turnaround time, it will prevent future “fixes” from “unfixing” your application. Defects provide the focus and context necessary to write relevant internal implementation tests. This strategy is not a quick fix, but it will slowly move you from being reactive to becoming proactive with your legacy systems.

Code Quality Metrics with Sonar, Part I

Akrem Saed — Mon, 05 Mar 2012 21:16:52 +0000

What is Sonar and Why it’s Needed?

I was fortunate to be able to attend the 2011 edition of No Fluff Just Stuff . One of my favorite presentations was by Matthew McCullough on Sonar . Hence, when the issue of code metrics was raised at a client, Sonar seemed like the right tool to use.

Our client wanted to explore ways to measure and enforce software and code quality metrics. Their goals were to have quantitative measurements of their code quality and analyze those metrics to come up with a set of benchmark measurements. They wanted to utilize Sonar to discourage bad practices.

How can Sonar help ?

Sonar can help achieve those goals in addition to providing tools to instantly evaluate and monitor the standings of any project with respect to these benchmarks. It can also help decision makers determine which issues, if tackled, provide the biggest increase in quality. Furthermore, this helps them assess areas of risk within their current software.

Sonar, according to wikipedia, is “an open source software quality platform. Sonar uses various static code analysis tools such as Checkstyle, PMD, FindBugs, Clover to extract software metrics, which then can be used to improve software quality”.

One of the main attributes of Sonar is that its users do not have to be restricted to developers or the technically savvy but rather it can provide helpful information to project managers, technical leads and IT leadership within an organization. This is made possible by Sonar’s plug-in architecture.

Plugins like SQALE and Technical Debt provide relevant information to managers and the business. They provide a high level overview of the project standing as it related to quality and cost.

At the same time, Sonar has popular development plugins like PMD, Checkstyle, Emma, and many others.

Why collect metrics in the first place?

This is the first of a series of blogs that describe how Sonar can be used. Each part in this series will include some technical details of how to incorporate Sonar into a development environment. Technical details to be discussed will include how to launch Sonar analysis from QuickBuild CI server using an Ant task, and collect metrics of Java projects that has JUnit unit tests and gather Emma coverage data and pass them to Sonar.

Before I get into the implementation details we need to talk about why measuring metrics is important. I’m not interested in the “new cool tools” out there if they don’t provide significant value to our clients and steer them towards success.

Here are some reasons why it is valuable to track metrics :

You cannot improve what you don’t measure: There are three scenarios related to the idea that the existence of a metric can help you decide your next action, plan it, and evaluate its results. These scenarios are as follow ;
- Scenario 1: Your team doesn’t collect code metrics from projects. Therefore, your code base could be getting worse and worse without anyone ever noticing. You might start noticing when the technical debt (we will elaborate on this concept later) has reached a certain level where it’s too expensive to address them, given the time and budget constraints. Collecting code metrics continuously can give your team the advantage of keeping the technical debt of your code base under control. For example, you can make it a rule that you don’t allow your code base to extend beyond a certain threshold in terms of some metric values. Whenever that threshold is reached you are notified immediately through your continuous build.
- Scenario 2: Time and time again I’ve witnessed teams that start refactoring because they are convinced the code base was bad in terms of performance, brittleness, instability, difficulty to maintain and/or to extend. While our intentions are good, we don’t know what part of the code base is responsible for the issue we encounter. Hence, there is a good chance changes will be applied to the wrong code. Or we end up refactoring the right code in the wrong way. Or we only fix part of the problem. This is where metrics and tools like Sonar can help. Sonar points out the parts of the code that are causing problems. Once these issues are identified they can be prioritized and added to the backlog. Sonar helps teams identify and address issues with confidence.
- Scenario 3: Another team is the best in the world and has remarkable instincts in identifying and correcting issues, but they fail to track the quantity of issues fixed in their triumphant voyage. Let’s face it, managers and team leaders would definitely appreciate having a clear idea of how many improvements were made with their resources and budget. They also want to know which issues still need to be fixed in the future. Now, if you preserve a snapshot of metric values before the voyage, you could report something like this “… before our code base was 75% compliant with the company’s best practices and now it’s at 95%”.
What you don’t measure, you cannot prove: This is relevant when the technical team needs to get buy-in from the stakeholders to allow them to spend time and resources to fix the code base. However the way we present information is very important. The stakeholders won’t have any idea what you mean when you say “swallowed exceptions”, tightly coupled classes, large amounts of duplication, etc. But they can come to understand that “our code has 14% of technical debt that will need X amount of days to fix it” and show them the numbers from SQALE saying that the product is not robust in terms of portability, security and efficiency. This way you’re allowing management to make informed decisions and prioritize accordingly instead of having unsubstantiated requests for resources and time to fix the issues.
Broken Window Theory: This theory comes from a book entitled the Pragmatic Programmer, which states :

Don’t leave “broken windows” (bad designs, wrong decisions, or poor code) unrepaired. Fix each one as soon as it is discovered. If there is insufficient time to fix it properly, then board it up. Perhaps you can comment out the offending code, or display a “Not Implemented” message, or substitute dummy data instead. Take some action to prevent further damage and to show that you’re on top of the situation.

We’ve seen clean, functional systems deteriorate pretty quickly once windows start breaking. There are other factors that can contribute to software rot, and we’ll touch on some of them elsewhere, but neglect accelerates the rot faster than any other factor.

You may be thinking that no one has the time to go around cleaning up all the broken glass of a project. If you continue to think like that, then you’d better plan on getting a dumpster, or moving to another neighborhood. Don’t let entropy win.

Continuously collecting and reviewing software metrics can help identify and fix “broken windows” before they affect other windows. The longer a bad design and bad code are left unfixed, the more vulnerable your code is to receiving additional hacks. However, if you keep an eye out for the symptoms of broken windows like : highly coupled classes, very complex methods and classes, low unit test coverage, etc, then you can act on them before they can attract more “badness”.

Prevention is the best medicine: It’s true that fixing issues will take you some time after you start identifying them in your code, but once this is in place you will prevent the same problem from occurring in new code. For example, I found in one of our projects that we had a large amount of “Integer Instantiation” violations which meant that we were wasting memory space when we created integer objects. It took us sometime to clear them all out, but we were able to eventually remove them completely from the code. This is a rather simple violation but the point is that we didn’t introduce new instances of the same problem that we were trying to fix. This gives you a morale boost knowing that your newer code is better than your older stuff.
Planning and Prioritizing: Having measurements for each area of concern and what it would cost to fix them is extremely valuable when you want to plan and prioritize the effort needed. In this case, you have a large amount of technical debt that needs concentrated effort to fix it. Measurements can be used to predict the amount of effort it will take to address each issue. This is a reactive approach to technical debt which you can replace with a proactive attitude. An example of a proactive approach would be that the team decides that whenever developers are changing a piece of code, they should fix any technical debt items related to that piece of code. Hence, killing two birds with one stone. This approach will help also with testing and quality assurance when your technical debt resolutions are tied to new features the testers will be already verifying.
Technical Debt Resolution: Getting technical debt under control gets easier when you start measuring and monitoring it. Ward Cunningham had this to say about it in his 1992 experience report titled The WyCash Portfolio Management System :

Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite… The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise.

Technical debt is the collection of “grey decisions” we make for the sake of meeting deadlines or coding something that “just works”. Ultimately we forget to refactor into “white code”. Therefore, when the grey materials amass with time, it can turn your code quality from a faint shade of grey to a darker shade. For me, the strongest and clearest manifestation of technical debt is when my team starts talking about rewriting a code base, as opposed to refactoring little by little. When we opt for rewriting instead of refactoring, it’s an indication that the technical debt has exceeded a certain level after which it becomes unfeasible to fix the issues and/or we have so many issues tangled with each others that we don’t know how to begin to address them. Uncle Bob argues against rewriting legacy code in his post called The Big Redesign In the Sky and prefers to fix the code base by applying smaller changes all the time. I’d say that we need to keep an eye on the technical debt all the time and address it promptly before it reaches an unmanageable level where it will be hard to convince the rest of the team NOT to rewrite.

What’s next?

In this post I made a case for using and collecting software metrics for projects. I touched a little bit on what makes Sonar valuable in this area. In my next post, I will give an overview of the main features of Sonar that I find most helpful and intriguing. After that, I will go into the technical details of incorporating Sonar into our development environment.

Portlet Development using JSF, PrimeFaces and Spring

Lal Sah — Thu, 01 Mar 2012 12:52:18 +0000

About the Post:

This article presents techniques on how to develop Java Portlets using JavaServer Faces, PrimeFaces and Spring. This hands-on example will integrate all of these technologies into a single application.

Assumptions

This post assumes that you have a basic understanding of Portlet, JSF, PrimeFaces and Spring. And a good understanding of Java 5 and annotations.

Resources

Before getting started, please have the following downloaded and setup in your environment.

Eclipse IDE configured with Maven 2 to ease development.
Apache Pluto 2.0.3

Development Steps

Create a Web Project named SimplePortlet and convert it to Maven Project / enable Maven support.

Let’s start with the application requirements. So, build your Maven Configurations – pom.xml file. As you might have guessed, this will contain the dependencies for the following. If you have confusion about any of the dependencies below, don’t worry, things will be clear as we move forward.

Spring Web


>
>org.springframework>
>spring-web>
>${spring.version}>
>

Portlet


>
>javax.portlet>
>portlet-api>
>${portlet-api.version}>
>provided>
>

Servlet


>
>javax.servlet>
>servlet-api>
>${servlet-api.version}>
>provided>
>
>
>javax.servlet>
>jstl>
>1.2>
>compile>
>

JEE Dependency Injection

>
>javax.inject>
>javax.inject>
>1>
>


>
>com.sun.faces>
>jsf-api>
>2.1.6>
>
>
>com.sun.faces>
>jsf-impl>
>2.1.6>
>

 
>
>com.sun.el>
>el-ri>
>1.0>
>
>
>javax.el>
>el-api>
>1.0>
>provided>
>

PrimeFaces


>
>org.primefaces>
>primefaces>
>3.0>
>

PortletFaces bridge


>
>org.portletfaces>
>portletfaces-bridge>
>2.0.1>
>
>
>org.portletfaces.alloy.faces>
>alloyfaces>
>1.0.1.1>
>

>
>commons-fileupload>
>commons-fileupload>
>1.2.2>
>
>
>commons-io>
>commons-io>
>1.3.1>
>
.

Add the following repositories to your pom.xml so that all the dependencies can be downloaded successfully.


>
>
>maven2-repository.dev.java.net>
>http://download.java.net/maven/2>
>
>
>maven2-repository.jboss.org>
>http://repository.jboss.org/nexus/content/groups/public-jboss>
>
>
>maven2-repository-portletfaces.org>
>http://repository.portletfaces.org/content/repositories/portletfaces-releases>
>
>
>prime-repo>
>PrimeFaces Maven Repository>
>http://repository.primefaces.org>
>default>
>
>

Add the the following properties to your pom.xml file.

>
>2.0.3>
>2.0>
>2.5>
>2.0>
>4.10>
>3.1.1.RELEASE>
>

Build your web.xml file

Add Spring bootstrap – ContextLoaderListener.
Add RequestContextListener to the web.xml to enable Spring support request and session scoped beans.
Add JSF Servlet Configurations.
Finally, the web.xml looks like this:

 version="1.0" encoding="UTF-8"?>
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 id="WebApp_ID" version="3.0">
 >SimplePortlet>
 >
 >contextConfigLocation>
 >classpath:applicationContext.xml>
 >
 >
 >javax.faces.CONFIG_FILES>
 >/WEB-INF/faces-config.xml>
 >
 >
 >javax.faces.PROJECT_STAGE>
 >Development>
 >
 >
 >javax.faces.PARTIAL_STATE_SAVING>
 >false>
 >
 >
 >org.springframework.web.context.ContextLoaderListener>
 >
 >
 >org.springframework.web.context.request.RequestContextListener>
 >
 >
 >Faces Servlet>
 >javax.faces.webapp.FacesServlet>
 >1>
 >
 
 >
 >
 >Facelet View XHTML>
 >*.xhtml>
 >
 >
 >nobody>
 >
 >
 >
 >nobody>
 >
>

Create faces-config.xml file and add SpringBeanFacesELResolver into it. JSF Els look up Spring beans with the help of this EL Resolver. This looks like:

 version="1.0" encoding="UTF-8"?>
 version="2.0" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd">
>
>org.springframework.web.jsf.el.SpringBeanFacesELResolver>
>
>

Write your JSF Controller class. In this example, I’ve created a controller class that has a zipCode field which is submitted from the user request. This controller has dependency with the service layer to get the weather information which has been injected into this. Controller invokes the service class, WeatherServiceClient in this case, to get weather info for that zip code and gets it back as a WeatherReturn. (The controller also has a field called currentTime. The view invokes this using AJAX and displays the current time. This is done using PrimeFaces poll component)

/**
 *
 */
package com.sourceallies.portlets.spring.controller;
 
import java.io.Serializable;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Logger;
 
import javax.inject.Inject;
import javax.inject.Named;
 
import com.sourceallies.portlets.spring.bean.WeatherReturn;
import com.sourceallies.service.WeatherServiceClient;
 
/**
 * @author lsah
 *
 */
@Named("viewController")
public class WeatherViewController implements Serializable {
 
 /**
 *
 */
 private static final long serialVersionUID = 8811407513884269900L;
 
 private static final Logger LOGGER = Logger.getLogger(WeatherViewController.class.getName());
 
 private static final DateFormat DATE_FORMAT = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss a z");
 
 @Inject
 @Named("weatherServiceClient")
 private WeatherServiceClient weatherServiceClient;
 
 private WeatherReturn weatherReturn;
 
 private String zipCode = "50312";
 
 private String currentTime = DATE_FORMAT.format(new Date());
 
 /**
 * @return the currentTime
 */
 public String getCurrentTime() {
 return currentTime;
 }
 
 /**
 * @param currentTime
 *            the currentTime to set
 */
 public void setCurrentTime(String currentTime) {
 this.currentTime = currentTime;
 }
 
 public WeatherViewController() {
 }
 
 public String updateWeather() {
 LOGGER.info("Zip Code: " + zipCode);
 weatherReturn = weatherServiceClient.getWeatherByZipCode(zipCode);
 return null;
 }
 
 public void updateTime() {
 // LOGGER.info("------------------>>>>>>Updating time...");
 this.currentTime = DATE_FORMAT.format(new Date());
 }
 
 /**
 * @return the weatherServiceClient
 */
 public WeatherServiceClient getWeatherServiceClient() {
 return weatherServiceClient;
 }
 
 /**
 * @param weatherServiceClient
 *            the weatherServiceClient to set
 */
 public void setWeatherServiceClient(WeatherServiceClient weatherServiceClient) {
 this.weatherServiceClient = weatherServiceClient;
 }
 
 /**
 * @return the weatherReturn
 */
 public WeatherReturn getWeatherReturn() {
 if (this.weatherReturn == null) {
 weatherReturn = weatherServiceClient.getWeatherByZipCode("50312");
 LOGGER.info("Temperature (Spring Portlet MVC): " + weatherReturn.getTemperature());
 }
 return weatherReturn;
 }
 
 /**
 * @param weatherReturn
 *            the weatherReturn to set
 */
 public void setWeatherReturn(WeatherReturn weatherReturn) {
 this.weatherReturn = weatherReturn;
 }
 
 /**
 * @return the zipCode
 */
 public String getZipCode() {
 return zipCode;
 }
 
 /**
 * @param zipCode
 *            the zipCode to set
 */
 public void setZipCode(String zipCode) {
 this.zipCode = zipCode;
 }
}

The WeatherReturn bean is shown below.

/**
* Weather.java
* Feb 28, 2012
*/
package com.sourceallies.portlets.spring.bean;
 
import java.io.Serializable;
 
/**
* @author Lal
*
*/
public class WeatherReturn implements Serializable {
 
/**
*
*/
private static final long serialVersionUID = 2221936547464343855L;
 
private String zipCode;
 
private String temperature;
 
private String city;
 
private String state;
 
private String description;
 
/**
* @return the zipCode
*/
public String getZipCode() {
return zipCode;
}
 
/**
* @param zipCode
*            the zipCode to set
*/
public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}
 
/**
* @return the temperature
*/
public String getTemperature() {
return temperature;
}
 
/**
* @param temperature
*            the temperature to set
*/
public void setTemperature(String temperature) {
this.temperature = temperature;
}
 
/**
* @return the city
*/
public String getCity() {
return city;
}
 
/**
* @param city
*            the city to set
*/
public void setCity(String city) {
this.city = city;
}
 
/**
* @return the state
*/
public String getState() {
return state;
}
 
/**
* @param state
*            the state to set
*/
public void setState(String state) {
this.state = state;
}
 
/**
* @return the description
*/
public String getDescription() {
return description;
}
 
/**
* @param description
*            the description to set
*/
public void setDescription(String description) {
this.description = description;
}
 
/**
* @param zipCode
* @return
*/
public WeatherReturn withZipCode(String zipCode) {
this.zipCode = zipCode;
return this;
}
 
/**
* @param temperature
* @return
*/
public WeatherReturn withTemperature(String temperature) {
this.temperature = temperature;
return this;
}
 
/**
* @param city
* @return
*/
public WeatherReturn withCity(String city) {
this.city = city;
return this;
}
 
/**
* @param state
* @return
*/
public WeatherReturn withState(String state) {
this.state = state;
return this;
}
 
/**
* @param description
* @return
*/
public WeatherReturn withDescription(String description) {
this.description = description;
return this;
}
}

Write your service layer. I’ve simply short-circuited the service layer for example purpose ONLY. WeatherServiceClient in this case simply returns an object with static / hard-coded values as shown below. A real-time service client would invoke a real-time weather web service and get the data from there – which is beyond the scope of this article.

/**
*
*/
package com.sourceallies.service;
 
import java.util.logging.Logger;
 
import javax.inject.Named;
 
import com.sourceallies.portlets.spring.bean.WeatherReturn;
 
/**
* @author lsah
*
*/
@Named(value = "weatherServiceClient")
public class WeatherServiceClient {
 
private static final Logger LOGGER = Logger.getLogger(WeatherServiceClient.class.getName());
 
public WeatherServiceClient() {
}
 
/**
* @param zipCode
* @return the weather for the given zip code.
*/
public WeatherReturn getWeatherByZipCode(String zipCode) {
LOGGER.info("Zip Code: " + zipCode);
 
// Invoke Web Service / DAO layer to get the real-time data and return
 
return new WeatherReturn().withZipCode(zipCode).withCity("Des Moines").withState("IA").withTemperature("37").withDescription("Light Rain");
}
}

This WeatherServiceClient mentioned above is named as “weatherServiceClient”. This was injected into the controller class using @Inject and @Named annotations.
Write your Spring Bean configuration file. I’ve named it applicationContext.xml in the web.xml contextConfigLocation context parameter. You can choose any name as long as you have the same name in the web.xml above. We have all the beans configured using annotations so this file doesn’t have any bean creation setup. Instead it tells Spring the meta information about the annotation processing i.e. enable annotation processing and the packages that contain the annotated beans to be processed via annotation processing.

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
 
 />
 base-package="com.sourceallies.portlets.spring.controller" />
 base-package="com.sourceallies.service" />
>

Now let’s create the views. As you might have guessed, we are going to use Facelets on views. Since a Portlet operates in three modes namely VIEW, EDIT and HELP and we are going to create a portlet to support all three modes, we will create three view pages naming them view.xhtml, edit.xhtml and help.xhtml. Create a folder named xhtmls inside WEB-INF to place these files. Let’s start with view.xhtml.

This contains a JSF form with a singular field zipCode. This portlet will query weather for the entered zip code. It displays the weather info in the same page. Even though, you can navigate to any view page using JSF navigation based on your need. Here’s our view.

 xmlns="http://www.w3.org/1999/xhtml"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui">
 />
>
>
 value="Time: #{viewController.currentTime}"
id="currentTime" />
 interval="1" listener="#{viewController.updateTime()}"
update="currentTime" />
>
>Check Weather>
Please enter your Zip Code below to view weather update:  />
 />
Zip Code:  value="#{viewController.zipCode}" />
 action="#{viewController.updateWeather()}"
value="Submit" />
>Weather at Zip Code: #{viewController.zipCode}>
>Location: >

value="#{viewController.weatherReturn.city}, #{viewController.weatherReturn.state}"
id="citystate" />
 />
>Temperature: >
 value="#{viewController.weatherReturn.temperature} °F"
id="temperature" />
 />
>Description: >
 value="#{viewController.weatherReturn.description}"
id="desc" />
 />
>
>

I created the exact same page for EDIT mode just to have EDIT mode support – just copy and paste the same content in a file named edit.xhtml. However, you can create your own based on what you need for your application.
I’ve created a simplest page for HELP mode for this example.

 version="1.0" encoding="UTF-8"?>
 xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:ui="http://java.sun.com/jsf/facelets">
HELP MODE
>

Now that we have created almost everything, let’s create the Portlet configuration file / deployment descriptor. As mentioned before, we are using PortletFaces bridge. So, we are going to use org.portletfaces.bridge.GenericFacesPortlet as our portlet class, the class provided by PortletFaces library to handle portlet lifecycles. This class along with the PortletFaces library is responsible for bridging the gap between portlet and JSF servlet lifecycles and handles JSF views as portlets on the Portal page. Here is the Portlet configurations file:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd"
version="1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd
http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd">

>
>Weather Portlet JSF PortletFaces Bridge>
>weatherPortlet>
>Weather Portlet using JSF PortletFaces Bridge>
>org.portletfaces.bridge.GenericFacesPortlet>
>
>javax.portlet.faces.defaultViewId.view>
>/WEB-INF/xhtmls/view.xhtml>
>
>
>javax.portlet.faces.defaultViewId.edit>
>/WEB-INF/xhtmls/edit.xhtml>
>
>
>javax.portlet.faces.defaultViewId.help>
>/WEB-INF/xhtmls/help.xhtml>
>
>
>text/html>
>VIEW>
>HELP>
>EDIT>
>
>en>
>
>Weather Portlet (PortletFaces) Title>
>WeatherPortletPortletFacesTitle>
>weather portlet faces portlet>
>
>
>

Here is the snapshot of my Eclipse project assembly.

SimplePortlet Project Assembly

This completes our development of sample Weather portlet. Now let’s deploy this portlet.

Deployment

Now that we are done with the development, let’s deploy this portlet on Apache Pluto Portal Server. I am using Pluto 2.0.3.

Create Tomcat Context Deployment Descriptor. This is an XML file named same as the project name and is placed in the webapp/META-INF/ directory. Our SimplePortlet.xml contains the following information:

 version="1.0" encoding="UTF-8"?>
 path="/SimplePortlet" docBase="SimplePortlet" crossContext="true" />

Add the following plugins to yout pom.xml. The first is the compiler plugin that tells maven which version of java to use for compile java classes. The second and third are maven war and pluto plugins which tell maven how to create WAR assembly and where to put the deployment descriptors in the assembly so that Pluto can locate the deployment configurations and deploy the portlet. The fourth and last one is the automatic deployment plugin that tells maven where to copy the final deployment package. We are copying to pluto webapps directory so that it will be automatically deployed.

>
>${pom.name}>
>

>
>org.apache.maven.plugins>
>maven-compiler-plugin>
>
>1.6>
>1.6>
>
>
>
>maven-war-plugin>
>
>${project.build.directory}/pluto-resources/web.xml>
>
>

>
>org.apache.portals.pluto>
>maven-pluto-plugin>
>${pluto.version}>
>
>
>generate-resources>
>
>assemble>
>
>
>
>
>
>maven-antrun-plugin>
>
>
>integration-test>
>
>
 environment="env" />

 name="pluto.home" value="${catalina.home}" />
 file="target/${pom.name}.war" todir="${pluto.home}/webapps" />
>
>
>
>run>
>
>
>
>
>
>

Add a property catalina.home to your pom.xml file. Change its value to point to the home directory of your Pluto installation directory.

>/home/lsah/java/pluto-2.0.3>

The resulting pom.xml looks like this.

 xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
>4.0.0>
>com.sourceallies.simpleportlet>
>SimplePortlet>
>0.1>
>war>
>${pom.artifactId}>

>
>2.0.3>
>2.0>
>2.5>
>2.0>
>4.10>
>3.1.1.RELEASE>
>/home/lsah/java/pluto-2.0.3>
>
>

>
>org.springframework>
>spring-web>
>${spring.version}>
>
 

>
>javax.portlet>
>portlet-api>
>${portlet-api.version}>
>provided>
>
 

>
>javax.servlet>
>servlet-api>
>${servlet-api.version}>
>provided>
>
>
>javax.servlet>
>jstl>
>1.2>
>compile>
>
 

>
>javax.inject>
>javax.inject>
>1>
>
 

>
>com.sun.faces>
>jsf-api>
>2.1.6>
>
>
>com.sun.faces>
>jsf-impl>
>2.1.6>
>
 

>
>com.sun.el>
>el-ri>
>1.0>
>
>
>javax.el>
>el-api>
>1.0>
>provided>
>
 

>
>org.primefaces>
>primefaces>
>3.0>
>
 

>
>org.portletfaces>
>portletfaces-bridge>
>2.0.1>
>
>
>org.portletfaces.alloy.faces>
>alloyfaces>
>1.0.1.1>
>

>
>commons-fileupload>
>commons-fileupload>
>1.2.2>
>
>
>commons-io>
>commons-io>
>1.3.1>
>

 

>
>junit>
>junit>
>${junit.version}>
>test>
>
>
>
>${pom.name}>
>

>
>org.apache.maven.plugins>
>maven-compiler-plugin>
>
>1.6>
>1.6>
>
>
>
>maven-war-plugin>
>
>${project.build.directory}/pluto-resources/web.xml>
>
>

>
>org.apache.portals.pluto>
>maven-pluto-plugin>
>${pluto.version}>
>
>
>generate-resources>
>
>assemble>
>
>
>
>
>
>maven-antrun-plugin>
>
>
>integration-test>
>
>
 environment="env" />

 name="pluto.home" value="${catalina.home}" />
 file="target/${pom.name}.war" todir="${pluto.home}/webapps" />
>
>
>
>run>
>
>
>
>
>
>
>

>
>org.eclipse.m2e>
>lifecycle-mapping>
>1.0.0>
>
>
>
>
>
>
org.apache.portals.pluto
>
>
maven-pluto-plugin
>
>
[2.0.3,)
>
>
>assemble>
>
>
>
>>
>
>
>
>
>
>
>
>
>
 

>
>
>maven2-repository.dev.java.net>
>http://download.java.net/maven/2>
>
>
>maven2-repository.jboss.org>
>http://repository.jboss.org/nexus/content/groups/public-jboss>
>
>
>maven2-repository-portletfaces.org>
>http://repository.portletfaces.org/content/repositories/portletfaces-releases>
>
>
>prime-repo>
>PrimeFaces Maven Repository>
>http://repository.primefaces.org>
>default>
>
>
>

Run the maven command mvn install to have the build war file automatically deployed to your Pluto portal server. You can also run this with Eclipse IDE – just select Run As → Maven Install
Now if you go to your Pluto Admin page, you will see your Portlet deployed there. You can simply create a new Portal page with a name of your choice and add this Portlet on it or add this Portlet on an existing Portal page to view / edit / help with the portlet.

weatherPortlet shown on the Pluto Admin Page

weatherPortlet added on Source Allies Weather Portal

Parallel Programming With Barrier Synchronization

Ghaith Alrabadi — Thu, 01 Mar 2012 12:32:20 +0000

Parallel Programming is an emerging computer science field that studies the opportunity of splitting data into small chucks and process them on multiple processors simultaneously which provides a faster execution time. Parallel programming is useful in sorting, image processing, network processing and may other memory intensive tasks.

For parallel program execution to be effective and fruitful, we need to run programs on computers with multiple CPUs or cores. Of course, most people have computers with multiple processors and they are interested in high speed execution. This opens the way for parallel programming.

Having a sequential program running on a machine with multiple processors does not mean it will run faster than on a single processor computer. But why? Let’s say we have five processors on a machine, a running sequential program would leave four CPUs untouched and run on only one processor. This will execute in the same amount of time it would take on a single processor machine. On the other hand, a parallel program designed to run on multiple processors can perform the same task in less time.

Java provides parallel programming capabilities with different frameworks and APIs.
This example is using CyclicBarrier. We have two programs, one is sequential and the other is parallel. Both of them have the same input and should give the same output. The Algorithm I’m using is a merge sort. In both cases they take two different sorted lists and merges them into new sorted list which has a size equal to the sum of their sizes.

For the parallel version I’m using a Barrier Synchronization algorithm to parallelize the merge sort.

Example:-

Before merge:

x = [1,3,5,7,9]
y = [2,4,6,8,10]
z = [0,0,0,0,0,0,0,0,0,0]

After merge:

x = [1,3,5,7,9]
y = [2,4,6,8,10]
z = [1,2,3,4,5,6,7,8,9,10]

I created a method that takes x, y and z and called merge, this method compares list y with list x and replace the element of y in the proper positions of list z sorted as follows:
merge(x,y,z) change the value of z to be (z = [0,2,0,4,0,6,0,8,0,10])
Then we apply the merge method with changing x and y places in the method call
merge(y,x,z) change the value of z to be (z = [1,2,3,4,5,6,7,8,9,10])

Now let’s take a look at the code:

Merger.java

package com.sourceallies.test.sort;
 
/**
 * Utility class that is used for merging two lists in one list
 *
 * @author Ghaith Alrabadi
 *
 */
public class Merger {
	/**
	 * Method that compare y elements with x and puts them in the proper place in
	 * z
	 *
	 * @param x
	 * @param y
	 * @param z
	 */
	public static void merge(int[] x, int[] y, int[] z) {
		for (int i = 0; i &lt; y.length; i++) {
			int low = 0;
			int mid = 0;
			int high = y.length;
			int val = y[i];
			while (low &lt; high) {
				mid = low + ((high - low) / 2);
				if (x[mid] &lt; val)
					low = mid + 1;
				else
					high = mid;
			}
			z[i + low] = val;
		}
	}
}

ThreadX.java

package com.sourceallies.test.sort;
 
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
 
public class ThreadX implements Runnable {
	int[] x;
	int[] y;
	int[] z;
	CyclicBarrier barrier;
	/**
	 * Constructor that passes the arrays and the shared barrier to the thread.
	 *
	 * @param x
	 * @param y
	 * @param z
	 * @param barrier
	 */
	public ThreadX(int[] x, int[] y, int[] z, CyclicBarrier barrier) {
		super();
		this.x = x;
		this.y = y;
		this.z = z;
		this.barrier = barrier;
	}
 
	/**
	 *
	 */
	@Override
	public void run() {
		handle(x, y, z, barrier);
	}
 
	/**
	 * call the merge method with barriers,
	 * each thread will wait for the other threads on that barrier and until all of them are done,
	 * then they will leave the barrier after that in a sync way
	 *
	 */
	private void handle(int[] x, int[] y, int[] z, CyclicBarrier barrier) {
		try {
			Merger.merge(x, y, z);
			//force the thread to wait on the barrier.
			barrier.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
	}
 
}

ParallelApplication.java

package com.sourceallies.test.sort;
 
import java.util.concurrent.CyclicBarrier;
 
/**
 * Class that is used to pass the two arrays x, y into two Threads that will
 * merge sort them in array z then calculate the elapsed time and show it on the
 * console
 *
 * @author Ghaith Alrabadi
 *
 */
public class ParallelApplication {
 
	public static void test(int[] X, int[] Y, int[] Z) {
		long before = System.nanoTime();
		CyclicBarrier barrier = new CyclicBarrier(2);
		// each thread gets half the array
		Runnable x = new ThreadX(X, Y, Z, barrier);
		Runnable y = new ThreadX(Y, X, Z, barrier);
		Thread tx = new Thread(x);
		Thread ty = new Thread(y);
		tx.start();
		ty.start();
		try {
			tx.join();
			ty.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		long after = System.nanoTime();
		System.out.print("Elapsed Time for parallel version: ");
		System.out.println((after - before) + " ns");
		System.out.println("First element:" + Z[0]);
		System.out.println("Last element:" + Z[Z.length - 1]);
	}
}

SequentialApplication.java

package com.sourceallies.test.sort;
 
/**
 * Class that is used to pass the two arrays x,y to Merger class then merge sort them in
 * array z then calculate the elapsed time and show it on the console
 *
 * @author Ghaith Alrabadi
 *
 */
public class SequentialApplication {
	public static void test(int[] X, int[] Y, int[] Z) {
		long before = System.nanoTime();
		/*******************************/
		Merger.merge(X, Y, Z);
		Merger.merge(Y, X, Z);
		/*******************************/
		long after = System.nanoTime();
		System.out.print("Elapsed Time for sequential version: ");
		System.out.println((after - before) + " ns");
		System.out.println("First element:" + Z[0]);
		System.out.println("Last element:" + Z[Z.length - 1]);
	}
}

Main.java

package com.sourceallies.test.sort;
 
/**
 * Startup class
 *
 * @author Ghaith Alrabadi
 *
 */
public class Main {
 
	static int n = 1;
	static int[] X = new int[n];
	static int[] Y = new int[n];
	static int[] Z = new int[2 * n];
 
	public static void initiatData() {
		X = new int[n];
		Y = new int[n];
		Z = new int[2 * n];
		int i;
		/* input sorted lists X and Y */
		for (i = 0; i &lt; n; i++)
			X[i] = i * 2;
		for (i = 0; i &lt; n; i++)
			Y[i] = 1 + i * 2;
	}
 
	public static void main(String[] args) {
		// run the sequential and parallel versions
		n = 1000000;
		initiatData();
		SequentialApplication.test(X, Y, Z);
		initiatData();
		ParallelApplication.test(X, Y, Z);
 
	}
 
}

Running and Speedup

I ran the two main programs the SequentialApplication.java and the ParallelApplication.java on a machine that has four processors.
The variable part on these tests were the size of the array n, which is the size of array x or y and also the size of array z depends on it (2xn).

Results

Test cases and the results of execution time for different values for n

figure 1

figure 2

Conclusion

The maximum speedup we can get is “2″ (Max_Sequential_Time/Max_Parallel_Time). Why? Because we have two threads that run on two processors of the four processors.

For small values of “n” the sequential execution was faster than the parallel. Why? Because the creation time for two threads in the parallel program plus the merging time is more than just the merging time in the sequential program.

Every parallel program must have a sequential part, In our case it was the merge method.

There is a tradeoff between using parallel vs sequential program. The parallel program “granularity factor” helps us decide what to use. It is basically comparing the threads creation time with the sequential execution time of the parallel program, for instance, in the previous example thread creation happens when we call “new ThreadX()” which needs a creation time, The sequential part of the parallel program is inside the run() method of the thread which basically calls the merge method.

Nowadays we have machines with multiple processors, and users are searching for high speed execution. I recommend developers to start reading more about parallel programming algorithms and how to implement these algorithms in their projects.

Mobile Grails

David Kessler — Thu, 01 Mar 2012 06:00:56 +0000

Background

I was recently asked to throw together an application that would register and score a model car race. I went home and created a Grails app. Unfortunately this race will be held in a building that doesn’t have internet access. So I tried to keep my pages compact and clean so they could be used on mobile phones.

Research

After I created the first release it kept bothering me that my app was not designed for mobile devices. So I visited the Grails Plugins page and searched for the word “mobile”. The following results caught my attention:

I threw out iWebKit immediately because it only targets iPhone, iPod Touch and iPad. While iUI “now supports most smartphones & tablets” it’s current version is 0.40alpha1. Furthermore the Grails plugin doesn’t appear to have been updated in the past 2 years.

This left me with Spring Mobile Grails and jQuery Mobile. While I naturally gravitate to Spring products, jQuery Mobile Scaffolding had me at the word “scaffolding”. Besides, their page states that they support the following devices.

I’m a visual person and the sight of all of these phones convinced me to try this plugin.

jQuery Mobile Scaffolding Plugin Tutorial

The rest of this post details my expereince cutting my site over to use the jQuery Mobile Scaffolding plugin.

Setup

First I installed the plugin

grails install-plugin jquery-mobile-scaffolding

| Loading Grails 2.0.0
| Configuring classpath.
| Environment set to development.....
| Resolving plugin jquery-mobile-scaffolding. Please wait...
| Installing zip jquery-mobile-scaffolding-0.1.zip.....
| Installed plugin jquery-mobile-scaffolding-0.1
| Resolving plugin JAR dependencies.....
| Plugin installed.

grails install-mobile-templates --non-interactive

| Loading Grails 2.0.0
| Configuring classpath.
| Environment set to development.....
| jQuery-mobile templates installed successfully

I renamed my custom business logic and views so the scaffolding would not overwrite my code.

Then I ran “generate-all” for all of my domain classes

grails generate-all [my domain class package & name]

Then I merged my controller and view changes back into the newly generated code.

Then I started up my app.

grails run-app

I opened the site with my iPhone and I was really impressed with the clean look and navigation.

Before I continue, I must admit that I was thrilled to learn how to create an iPhone screenshot. What a great feature.

iPhone Issues

After playing around with this app I found the following issues.

1. The list pagination links look strange and are difficult to use.

2. The flash messages are obscured by the search box on the list screen.

3. The menu floats over the form that I’m trying to complete.

Google Chrome Issue

4. Number Validation

In order to get my iPhone to launch the number keyboard instead of the standard letter keyboard I used the HTML5 input type.

As I was testing this on my iPhone and various desktop browsers I ran across the following error.

Apparently Google Chrome provides client side validation. Unfortunately I want users to be able to enter decimal values.

Fixing The Issues

Instead of fixing each page separately I modified the scaffolding templates located in “src\templates\scaffolding\”.

-src
--template
---scaffolding
----Controller.groovy
----create.gsp
----edit.gsp
----list.gsp
----renderEditor.template
----show.gsp

1. To fix the pagination issue, I replaced it with an iPhone style “Show … More” button. This required changes in the action and the list.gsp.

Changes for ’src\template\scaffolding\list.gsp’

 ... 
     
  
 
Show \${showMoreSize} More

...

Changes for ’src\template\scaffolding\Controller.groovy’

... 
private static final int RESULT_SIZE = 10 
... 
def list = { 
     def entityListSize = ${className}.count() 
     def max = params.max ? params.int('max') : 0 
     max += RESULT_SIZE 
     max = Math.min(entityListSize, max) 
 
     def showMoreSize = entityListSize - max 
     showMoreSize = Math.min(showMoreSize, RESULT_SIZE) 
 
     params.max = max 
     [${propertyName}List: ${className}.list(params), max: max, showMoreSize: showMoreSize] 
} 
...

2. To fix the message issue, surround the message with paragraph tags.

Changes for ’src\template\scaffolding\’: ‘create.gsp’, ‘edit.gsp’, ‘list.gsp’ and ’show.gsp’

 
\${flash.message}

3. To fix the floating menu issue modify the header with the following:

Changes for ’src\template\scaffolding\’: ‘create.gsp’, ‘edit.gsp’, ‘list.gsp’ and ’show.gsp’

... 
 
 
...

4. To change the whole number validation to accept decimal values make the following change:

This should be changed on a case-by-case basis.

The ’step’ attribute “specifies the value granularity of the element’s value.” In other words, the default behavior of a number input only accepts whole numbers. The ’step’ attribute is used to allow decimal values.

Final Thoughts

I’m pleasantly surprised how simple it was to convert my grails app to a mobile friendly version. Granted, jQuery Mobile Scaffolding does have a few bugs on the iPhone. Nevertheless, the fixes were relatively simple. I anticipate that their will be an increasing demand to provide mobile versions of our traditional websites. Grails with jQuery Mobile simplifies this transition.

Injecting Spring Beans into Java Servlets

Lal Sah — Thu, 23 Feb 2012 21:00:41 +0000

If you are working in a Java Web Application and you are using Spring IoC Container in your application, there is a chance that you might have to inject Spring Beans into a Java Servlet.

Since there is not a direct way to inject Spring Beans into a Java Servlet, you might try to lookup the Spring Beans from the Spring Context within your servlet and assign the dependencies which means that part of injection would no more be IoC and you would be looking for some concise way of doing this.

To solve this problem, Spring provides a trick which is a class called org.springframework.web.context.support.HttpRequestHandlerServlet which consists of two behaviors:

It is-a javax.servlet.http.HttpServlet - completes one of the requirements.
and, it is a wrapper around org.springframework.web.HttpRequestHandler which has to be Spring Bean configured with bean injections, if any, to achieve the second goal (dependency injection). This is an interface which has a method called handleRequest(HttpServletRequest request, HttpServletResponse response) which the HttpRequestHandlerServlet delegates to while serving a request. So you need to implement this interface and have the dependencies wired in that class.

Note! Your servlet name (1) and you bean id (2) must match because HttpRequestHandlerServlet uses the servlet name to look up the beans form the context.

Now let’s look at an example:

Write your Spring bean (which is also a request handler / implements HttpRequestHandler). This bean should be configured to be component scanned. In the example below, this bean has a service called HelloService wired using Spring DI annotation @Autowired which will be injected by the Spring IoC container.

/**
* AnnotatedHttpServletRequestHandler.java
* Feb 15, 2012
*/
package com.sourceallies.spring.noxml.demo.web.servlet.handler;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Logger;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.HttpRequestHandler;
 
import com.sourceallies.spring.noxml.demo.service.HelloService;
 
/**
* @author Lal
*
*/
@Component("annotatedServletHandler")
public class AnnotatedHttpServletRequestHandler implements HttpRequestHandler {
 
private static final Logger LOGGER = Logger.getLogger(AnnotatedHttpServletRequestHandler.class.getName());
 
@Autowired
private HelloService helloService;
 
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter writer = response.getWriter();
writer.write("Spring Beans Injection into Java Servlets!
" + helloService.sayHello("World") + "
");
}

Write your Servlet. This servlet class extends org.springframework.web.context.support.HttpRequestHandlerServlet.

package com.sourceallies.spring.noxml.demo.web.servlet;
 
import javax.servlet.annotation.WebServlet;
 
import org.springframework.web.context.support.HttpRequestHandlerServlet;
 
/**
* Servlet implementation class AnnotatedHttpServlet
*/
@WebServlet(description = "Http Servlet using pure java / annotations", urlPatterns = { "/annotatedServlet" }, name = "annotatedServletHandler")
public class AnnotatedHttpServlet extends HttpRequestHandlerServlet {
 
private static final long serialVersionUID = 1L;
}

Notice the @Component(”annotatedServletHandler”) and @WebServlet(…, name = “annotatedServletHandler”). The bean id and the servlet name are exactly same.

Now, this will absolutely work and in fact you got access to Spring Beans from the Servlet provided that your Spring bean annotatedServletHandler was registered in the Spring Root Context (the context that is setup using org.springframework.web.context.ContextLoaderListener). However, it could be possible that your Web related beans, annotatedServletHandler for instance, are registered in the Spring Dispatcher Context. If this is the case, the previous example would not work. This leads to a situation where you have to implement your own HttpRequestHandlerServlet that could lookup both root and dispatcher contexts.

Here is an implementation of such a HttpRequestHandlerServlet which is pretty much similar to what Spring provides but with added functionality to support dispatcher context as well.

package com.sourceallies.spring.noxml.demo.web.servlet.framework;
 
import java.io.IOException;
import java.util.logging.Logger;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.util.StringUtils;
import org.springframework.web.HttpRequestHandler;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.servlet.FrameworkServlet;
 
import com.sourceallies.spring.noxml.demo.initializer.ApplicationContextInitializer;
 
@SuppressWarnings("serial")
public class MyHttpRequestHandlerServlet extends HttpServlet {
 
private static final Logger LOGGER = Logger.getLogger(MyHttpRequestHandlerServlet.class.getName());
 
// Replace ApplicationContextInitializer.DISPATCHER_SERVLET_NAME with the
// name of your dispatcher servlet
private static final String DISPATCHER_CONTEXT_ATTRIBUTE_NAME = FrameworkServlet.SERVLET_CONTEXT_PREFIX + ApplicationContextInitializer.DISPATCHER_SERVLET_NAME;
 
private HttpRequestHandler target;
 
@Override
public void init() throws ServletException {
WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
try {
this.target = (HttpRequestHandler) wac.getBean(getServletName(), HttpRequestHandler.class);
} catch (NoSuchBeanDefinitionException e) {
LOGGER.info("HTTP Request Handler bean was not found in Spring Root Context! Now looking up in the Dispatcher Context...");
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(getServletContext(), DISPATCHER_CONTEXT_ATTRIBUTE_NAME);
this.target = (HttpRequestHandler) context.getBean(getServletName(), HttpRequestHandler.class);
}
}
 
@Override
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
 
LocaleContextHolder.setLocale(request.getLocale());
try {
this.target.handleRequest(request, response);
} catch (HttpRequestMethodNotSupportedException ex) {
String[] supportedMethods = ((HttpRequestMethodNotSupportedException) ex).getSupportedMethods();
if (supportedMethods != null) {
response.setHeader("Allow", StringUtils.arrayToDelimitedString(supportedMethods, ", "));
}
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, ex.getMessage());
} finally {
LocaleContextHolder.resetLocaleContext();
}
}
}

The rest are normal Spring configurations.

References

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/web/context/support/HttpRequestHandlerServlet.html

http://andykayley.blogspot.com/2008/06/how-to-inject-spring-beans-into.html

Static Caching in Drupal

Arlan Whatling — Mon, 06 Feb 2012 21:36:49 +0000

If you’re a PHP veteran, then you know static caching is a relatively simple thing to do in PHP, but it can result in inconsistent behavior and sloppy code, such as adding an extra parameter to a function for the sole purpose of resetting that function’s internal cache.

Drupal’s static caching system improves upon the old way by providing a simple and consistent way for creating your own cache store and resetting cache stores set by other systems within Drupal. The entire functionality of this system is wrapped up in the drupal_static() function, with a side function, drupal_static_reset(), for resetting any existing cache store.

Using static caching in Drupal 7 is a little scary at first, especially if you’ve never worried too much about references or magic constants. Please be aware that the following example works only in Drupal 7. Prior versions of Drupal do not provide a static caching system. Here’s how static caching works:

function bark($who) {
$barked = &drupal_static(__FUNCTION__, array());

$barked[] = $who;
}

?>

The ampersand (&) in front of the function call indicates that the function drupal_static() returns a reference variable (recall that PHP is by default a pass-by-value language). The magic constant __FUNCTION__ is the name of the calling function (bark, in this case). The function’s name, “bark”, will be used as the key that points to the data you are storing. There’s no need to check if $barked has been set because drupal_static() will handle that for you.

Static caching is useful for storing objects that are expensive to generate. For example, Drupal uses a tree data structure to represent menus. Menu trees are expensive to generate since Drupal has to spend time determining parent-child relationships, ordering items by weight, and running hooks. That, on top of the database queries needed to simply retrieve the menu information. So it would make sense, then, that Drupal would generate the menu only once during a request and stuff it away in the static cache. Just as important is the fact that plenty of other modules rely on the menu system in order to function, and so caching is not only convenient but absolutely necessary for exposing menu data.

Caching should be used responsibly, however. Caching anything and everything is naive and can do more bad than good. Recall that PHP is a garbage-collected language. Without getting into the gritty details of how it works, it’s enough to say that static data will NOT be reclaimed under the regular rules of garbage collection. It stays around– even outside the function scope– until you reset it or the request ends. Since websites can serve many visitors at once, it’s not hard to see why this can become a big problem very quickly.

In summary, remember that caching (of any kind, not just static caching) is to be done in a responsible manner. Overzealous usage of caching floods memory which can crash high traffic websites. Remember also that caching should be used for large data structures that are expensive to generate. Lastly, use caching only if you know for sure that what you cache will be needed again (e.g., menu data in Drupal). There’s no point caching a list of names or addresses or colors if that list will never be used again. That would be like saving your old car tires after you put new ones on.

Hibernate Date vs Timestamp

David Kessler — Thu, 02 Feb 2012 20:24:21 +0000

I encountered a subtle hibernate mapping issue involving Dates and Timestamps. The following test recreates this issue.

package com.sourceallies.logging;
 
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
 
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.apache.commons.lang.time.DateUtils;
import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Transactional;
 
import com.sourceallies.Person;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TransactionConfiguration(defaultRollback=false)
public class HibernateDateTimeTest {
 
	@Resource
	private SessionFactory sessionFactory;
 
	private Session currentSession;
 
	private Date birthDateWithTime;
	private Date birthDateWithoutTime;
	private Date createDate;
	private Date modifyDate;
 
	@Before
	public void setUp() throws Exception{
		currentSession = sessionFactory.getCurrentSession();
		birthDateWithTime = new Date();
		birthDateWithoutTime = DateUtils.truncate(birthDateWithTime, Calendar.DATE);
		createDate = new Date();
		modifyDate = new Date();
	}
 
	@Test
	@Transactional
	public void testSave(){
		Person person = new Person("testFirst", "testLast", 
                      birthDateWithTime, createDate, modifyDate);
 
		assertFalse(person.getBirthDate() instanceof Timestamp);
		assertFalse(person.getCreateDate() instanceof Timestamp);
		assertFalse(person.getModifyDate() instanceof Timestamp);
 
		saveOrUpdate(person);
	}
 
	@Test
	@Transactional
	public void testFind(){
		List<Person> people = findAll();
 
		assertEquals(1, people.size());
		Person foundPerson = people.get(0);
 
		assertTrue(foundPerson.getBirthDate() instanceof Date);
		assertTrue(foundPerson.getCreateDate() instanceof Timestamp);
		assertTrue(foundPerson.getModifyDate() instanceof Timestamp);
 
		assertFalse(foundPerson.getBirthDate().equals(birthDateWithTime));
		assertTrue(foundPerson.getBirthDate().equals(birthDateWithoutTime));
		assertFalse(foundPerson.getCreateDate().equals(createDate));
		assertFalse(foundPerson.getModifyDate().equals(modifyDate));
	}
 
	public void saveOrUpdate(Person person) {
		currentSession.saveOrUpdate(person);
		currentSession.flush();
	}
 
	@SuppressWarnings("unchecked")
	private List<Person> findAll() {
		Criteria criteria = currentSession.createCriteria(Person.class);
		List<Person> people = criteria.list();
		return people;
	}
}

Here is the mapping for person.

...
@Entity
public class Person {
 
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id = -1L;
 
	@Column
	private String firstName;
 
	@Column
	private String lastName;
 
	@Column
	@Type(type="date")
	private Date birthDate;
 
	@Column
	@Type(type="timestamp")
	private Date createDate;
 
	@Column
	private Date modifyDate;
	...
}

There are three Date fields: ‘birthdate’, ‘createDate’, and ‘modifyDate’. The fields ‘birthDate’ and ‘createDate’ have a specified Type. The field ‘modifyDate’ however, does not have a specified Type. The generated SQL from Hibernate is as follows.

CREATE TABLE Person (id bigint generated BY DEFAULT AS identity (start WITH 1), 
birthDate date, createDate timestamp, firstName varchar(255), 
lastName varchar(255), modifyDate timestamp, PRIMARY KEY (id))

We see that Hibernate created ‘birthDate’ as a ‘Date’ and the other two were created as a ‘Timestamp’. The primary difference between ‘Date’ and ‘Timestamp’ in SQL is that ‘Timestamp’ holds the date and time while the ‘Date’ only holds the date.

At first glance this is not a big deal, but let’s take a closer look at the test.

 
	@Test
	@Transactional
	public void testSave(){
		Person person = new Person("testFirst", "testLast", 
                           birthDateWithTime, createDate, modifyDate);
 
		assertFalse(person.getBirthDate() instanceof Timestamp);
		assertFalse(person.getCreateDate() instanceof Timestamp);
		assertFalse(person.getModifyDate() instanceof Timestamp);
 
		saveOrUpdate(person);
	}

Person is created with three Dates that all include date and time values.

	@Test
	@Transactional
	public void testFind(){
		List<Person> people = findAll();
 
		assertEquals(1, people.size());
		Person foundPerson = people.get(0);
 
		assertTrue(foundPerson.getBirthDate() instanceof Date);
		assertTrue(foundPerson.getCreateDate() instanceof Timestamp);
		assertTrue(foundPerson.getModifyDate() instanceof Timestamp);
 
		assertFalse(foundPerson.getBirthDate().equals(birthDateWithTime));
		assertTrue(foundPerson.getBirthDate().equals(birthDateWithoutTime));
		assertFalse(foundPerson.getCreateDate().equals(createDate));
		assertFalse(foundPerson.getModifyDate().equals(modifyDate));
	}

When Hibernate retrieves a Person from the database the ‘createDate’ and ‘modifyDate’ have been converted to Timestamps. At first glance this doesn’t appear to be a big deal. java.sql.Timestamp extends java.util.Date. But why are they not equal. I found a helpful answer to this question in Effective Java (2nd Edition) page 41.

There are some classes in the Java platform libraries that do extend an instantiable
class and add a value component. For example, java.sql.Timestamp
extends java.util.Date and adds a nanoseconds field. The equals implementation
for Timestamp does violate symmetry and can cause erratic behavior if
Timestamp and Date objects are used in the same collection or are otherwise intermixed.
The Timestamp class has a disclaimer cautioning programmers against
mixing dates and timestamps. While you won’t get into trouble as long as you
keep them separate, there’s nothing to prevent you from mixing them, and the
resulting errors can be hard to debug. This behavior of the Timestamp class was a
mistake and should not be emulated. (Bloch, Effective Java, 2nd Ed.)

If you want to read more about ‘equals’ read chapter 3, Item 8 in Effective Java (2nd Edition). Apart from a hack there are two primary ways to solve this issue. The first way involves typing ‘createDate’ and ‘modifyDate’ to Timestamp.

	...
	@Column
	@Type(type="date")
	private Date birthDate;
 
	@Column
	private Timestamp createDate;
 
	@Column
	private Timestamp modifyDate;
        ...

The second approach uses a custom UserType. Here is a custom UserType that converts Timestamp to Date and vise versa. There is a side effect with this solution. Converting Timestamp to Date drops the nanosecond precision. If this is not acceptable then the previous solution should be used.

package com.sourceallies;
 
import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Date;
 
import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;
 
public class DateTimeUserType  implements UserType {
 
	@Override
	public int[] sqlTypes() {
		 return new int[]{Types.TIMESTAMP};
	}
 
	@SuppressWarnings("rawtypes")
	@Override
	public Class returnedClass() {
		return Date.class;
	}
 
	@Override
	public boolean equals(Object x, Object y) throws HibernateException {
		 return x == y || !(x == null || y == null) && x.equals(y);
	}
 
	@Override
	public int hashCode(Object x) throws HibernateException {
		return x.hashCode();
	}
 
	@Override
	public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
			throws HibernateException, SQLException {
		Timestamp timestamp = rs.getTimestamp(names[0]);
        if (rs.wasNull()) {
            return null;
        }
        return new Date(timestamp.getTime());
	}
 
	@Override
	public void nullSafeSet(PreparedStatement st, Object value, int index)
			throws HibernateException, SQLException {
        if (value == null) {
            st.setNull(index, Types.TIMESTAMP);
        }
        else {
            Date date = (Date) value;
            Timestamp timestamp = new Timestamp(date.getTime());
            st.setTimestamp(index, timestamp);
        }
	}
 
	@Override
	public Object deepCopy(Object value) throws HibernateException {
		return value;
	}
 
	@Override
	public boolean isMutable() {
		return false;
	}
 
	@Override
	public Serializable disassemble(Object value) throws HibernateException {
		 return (Serializable) value;
	}
 
	@Override
	public Object assemble(Serializable cached, Object owner)
			throws HibernateException {
		return cached;
	}
 
	@Override
	public Object replace(Object original, Object target, Object owner)
			throws HibernateException {
		return original;
	}
}

Here is the way to use it in the Person class.

@Entity
@TypeDefs({
		@TypeDef(name="dateTimeUserType", typeClass=DateTimeUserType.class)
})
public class Person {
	...
	@Column
	@Type(type="date")
	private Date birthDate;
 
	@Column
	@Type(type="dateTimeUserType")
	private Date createDate;
 
	@Column
	@Type(type="dateTimeUserType")
	private Date modifyDate;
        ...

Either of these solutions will prevent the ‘equals’ issue that we encountered before. This issue is not a Hibernate issue it is truly a Java issue as is stated in Effective Java (2nd Edition). Hibernate can be challenging enough without these subtle issues that are easy to miss until a bug is reported.

Here is the complete code. Hibernate Logging Zip .

Hibernate Logging

David Kessler — Mon, 30 Jan 2012 14:54:22 +0000

Through the years I’ve encountered a recurring requirement. Clients need to log changes to the database for auditing and legal purposes. To satisfy this requirement you could add logging to every save/update/delete call in your code. Or better yet, you could create an aspect that wraps these calls. While these would certainly work Hibernate provides a convenient interceptor.

In this article I will show you how to add a simple logger to Hibernate.

Start with a Test

As an avid TDD practitioner I will of coarse start with a test. Here is the final version of the test that I used to drive my code.

package com.sourceallies.logging;
 
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
 
import java.util.Date;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.apache.commons.logging.Log;
import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
 
import com.sourceallies.Person;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class HibernateInterceptorTest {
 
	@Resource
	private SessionFactory sessionFactory;
 
	@Resource
	private HibernateInterceptor hibernateInterceptor;
 
	private Session currentSession;
 
	private Log logger;
 
	private static final Date NOW = new Date();
 
	@Before
	public void setUp(){
		logger = mock(Log.class);
		currentSession = sessionFactory.getCurrentSession();
		hibernateInterceptor.setLogger(logger);
	}
 
	@Test
	@Transactional
	public void testSaveLogging(){
		saveOrUpdate(createPerson());
 
		assertEquals(1, findAll().size());
 
		verify(logger).info("Saving Person [firstName=testFirst, lastName=testLast, birthDate=" + NOW + "].");
		verifyNoMoreInteractions(logger);
	}
 
	@Test
	@Transactional
	public void testUpdateLogging(){
		saveOrUpdate(createPerson());
 
		List<Person> people = findAll();
 
		assertEquals(1, people.size());
 
		Person firstPerson = people.get(0);
		firstPerson.setFirstName("testFirst2");
 
		saveOrUpdate(firstPerson);
 
		currentSession.flush();
 
		verify(logger).info("Saving Person [firstName=testFirst, lastName=testLast, birthDate=" + NOW + "].");	
		verify(logger).info("Updating Person [firstName=testFirst2, lastName=testLast, birthDate=" + NOW + "].");	
		verifyNoMoreInteractions(logger);
	}
 
	@Test
	@Transactional
	public void testDeleteLogging(){
		saveOrUpdate(createPerson());
 
		List<Person> people = findAll();
 
		assertEquals(1, people.size());
 
		Person firstPerson = people.get(0);
 
		delete(firstPerson);
 
		currentSession.flush();
 
		verify(logger).info("Saving Person [firstName=testFirst, lastName=testLast, birthDate=" + NOW + "].");	
		verify(logger).info("Deleting Person [firstName=testFirst, lastName=testLast, birthDate=" + NOW + "].");	
		verifyNoMoreInteractions(logger);
	}
 
	@Transactional
	public void saveOrUpdate(Person person) {
		currentSession.saveOrUpdate(person);
		currentSession.flush();
	}
 
	@Transactional
	public void delete(Person person) {
		currentSession.delete(person);
	}
 
	@SuppressWarnings("unchecked")
	private List<Person> findAll() {
		Criteria criteria = currentSession.createCriteria(Person.class);
		List<Person> people = criteria.list();
		return people;
	}
 
 
	private Person createPerson() {
		Person person = new Person("testFirst", "testLast", NOW);
		return person;
	}
}

I used a mock logger to gather information from the interceptor.

Spring Configuration

Here is the configuration required for the interceptor.

 
	 id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
                ...
		 name="dataSource" ref="dataSource" />
		 name="entityInterceptor" ref="hibernateInterceptor"/>
	>
 
	 id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		 name="sessionFactory" ref="sessionFactory" />
	>
         ...	
	 base-package="com.sourceallies" />
        ...

The ‘entityInterceptor’ property on the ’sessionFactory’ takes a Hibernate interceptor.

Entity

@Entity
public class Person {
 
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id = -1L;
 
	@Column
	private String firstName;
 
	@Column
	private String lastName;
 
	@Column
	private Date birthDate;
...
	@Override
	public String toString() {
		return "Person [firstName=" + firstName + ", lastName="
				+ lastName + ", birthDate=" + birthDate + "]";
	}
}

For this example you need to implement the ‘toString’ method on the entity being logged.

Interceptor

Here is the interceptor code.

package com.sourceallies.logging;
 
import java.io.Serializable;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.EmptyInterceptor;
import org.hibernate.type.Type;
import org.springframework.stereotype.Component;
 
@Component
public class HibernateInterceptor extends EmptyInterceptor {
 
	private static final long serialVersionUID = 1L;
	private Log logger = LogFactory.getLog(HibernateInterceptor.class);
 
	@Override
	public void onDelete(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
		log("Deleting", id, entity);
		super.onDelete(entity, id, state, propertyNames, types);
	}
 
	@Override
	public boolean onFlushDirty(Object entity, Serializable id,
			Object[] currentState, Object[] previousState,
			String[] propertyNames, Type[] types) {
		log("Updating", id, entity);
		return super.onFlushDirty(entity, id, currentState, previousState,
				propertyNames, types);
	}
 
	@Override
	public boolean onSave(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
		log("Saving", id, entity);
		return super.onSave(entity, id, state, propertyNames, types);
	}
 
	protected void setLogger(Log logger) {
		this.logger = logger;
	}
 
	private void log(String action, Serializable id, Object entity) {
		logger.info(action + " " + entity + ".");
	}
}

While the ‘onSave’ and ‘onDelete’ methods are clearly named the ‘onUpdate’ method appears to be missing. With a little research it quickly becomes obvious that ‘onFlushDirty’ is used for updates.

Logging database activity is this simple.

Here is the complete code. Hibernate Logging Zip