Stuff about Java and technology

Building Android kernel from source

2010-07-02T00:11:00.003+05:00

So, you wanna build the Android kernel from source. Great, that's a cool thing to do. I assume that you'r already using a Linux distribution (and probably Ubuntu). If not, go get Ubuntu first.

To build the kernel image from source you need tools like:

1- Android SDK for Linux (add path-to-sdk/tools to system path)

2- Oracle's/Sun Microsystem's JDK set to your system path. I have built using JDK1.5, you can try JDK1.6 and it should work.

3- From ubuntu repository, install the following tools:

g++, perl, bison, flex, zlib1g-dev, x11proto-core-dev and libx11-dev
fastboot (move it under your sdk/tools/.)

4- Get the Android NDK for linux to get some native tools

5- Clone the Git repo of kernel source and switch to branch (2.6.32 is currently the latest one)

git clone git://android.git.kernel.org/kernel/msm.git
cd msm
git checkout origin/android-msm-2.6.32

6A- Before you build the source, you need to have a .config file which you can auto-generate using

make msm_defconfig

6B- Or get it from your phone using following commands:

adb pull /proc/config.gz .
gunzip config.gz
mv config .config

7- Now you can make the build giving the platform arguments:

make -j2 ARCH=arm CROSS_COMPILE=android-ndk/build/prebuilt/linux-x86/arm-eabi-4.4.0/bin/arm-eabi-

Relax, and have a cup of Java before the build completes.

You can boot this image in the emulator that comes with the SDK.

emulator -kernel arch/arm/boot/zImage

Or more interestingly, you can also boot from phone's RAM using 'fastboot' (make sure 'adb devices' lists your attached device):

fastboot boot arch/arm/boot/zImage

P.S: If you find some confusion, have some suggestions or need more stuff, the comments' area is always open for you.

Gwt-coded Presentations

2010-06-12T00:40:00.003+05:00

Yes, a presentation but not built on Google Docs(I din't consider Powerpoint or OpenOffice since I love web as a platform). I was just looking for some fun time so I thought maybe I should _code_ my slides instead of writing them.

I searched for a GWT API to do so but din't find any. So instead of wasting more time looking for such API I started writing my own app on bare GWT. It was a lot of fun writing and then actually using that app for presentation.

Although currently, it's cleanly coded but since I had to build something from scratch in just one day, I left behind many design considerations in my mind which i'm gonna put into this app to make it work out more sophisticated presentations.

You can have your own copy of this code (it's completely open-source under Apache 2 License), use it, improve it, give your suggestions/patches or a couple of words about what you think.

The repo can be found at:

http://github.com/nabeelalimemon/Gwt-Presentations

Have fun building your presentations.

Update 1: To actually use this project to build your presentation slides yourself, you can follow the wiki I've created for my GitHub's Gwt-Presentation repo

Unit and Integration Testing with TestNG

2010-05-18T01:51:00.005+05:00

I am a big fan of developer testing. You begin to realize the real benefits of testing, six months down the road (or maybe a year) when your code-base starts growing, your project has more features than before and suddenly you come across a bug. You write your patch and start thinking how would you test that patch and make sure that:

I) It actually solves the issue
II) It doesn't shake already working features
III) It doesn't, by any chance, introduce a new bug

Then you realize that proper testing would've helped you a lot. Your test code is as important as your production code. The moment you start ignoring testing is the moment your code-base starts turning into a nightmare.

Some people even push testing to the levels where it may help design good API's. Yes, I am talking about this blog post of Ted Young.

Good frameworks that realize that the client code should be easy-to-test provide good unit/integration testing support. Let's see how Spring 3 provides better support for unit/integration testing while maintaining great flexibility for clients at the same time.

Let's go back to our Spring 3 & Hibernate integration project and write unit/integration tests for it.

First off, we'll have to change our pom.xml a bit to remove non-Spring-3 library dependencies in our project's dependency graph. For your convenience, here's the updated version of pom.xml (updated on rev: 5)

You may notice that I've added TestNG 5.12.1 dependency with sure-fire plugin to the pom.xml. Yes, instead of JUnit, we'll use a far superior and flexible testing framework called TestNG.

Tests should be kept as close to their target sources as possible. Luckily, in Java we have package semantics. Which means we can even test package-private methods which are for internal use and which we don't expose to the clients.

After creating test folder following maven convention, we create packages inside that with the same names as our source packages are.

Before we begin writing test cases, make sure you've created 'testng.xml' under 'test/java/resources' which will work as our tests' configuration file. Your testng.xml should contain all necessary information regarding test-run configuration and package information where your tests reside.

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite thread-count="10" verbose="1" name="SpringHibernateIntegration-suite" annotations="JDK" parallel="methods">

<!--base defaults which i'll be passing to my test methods-->
<parameter name="firstName" value="Nabeel"/>
<parameter name="lastName" value="Memon"/>
<parameter name="emailAddress" value="nabeelalimemon@gmail.com"/>

<!--view names that return from UserController methods-->
<parameter name="getUsers" value="users"/>
<parameter name="getUser" value="userDetails"/>

<test name="integration-tests">
<packages>
<package name="com.springhibernate.integration.model"/>
<package name="com.springhibernate.integration.repository"/>
<package name="com.springhibernate.integration.web.controllers"/>
</packages>
</test>

</suite>

Let's test our business Entity first which is 'User'.

package com.springhibernate.integration.model;

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

import static org.testng.Assert.assertEquals;

/**
 * @author Nabeel Ali Memon
 */

@Test
public class UserTest {
  @Test
  @Parameters({"firstName", "lastName", "emailAddress"})
  public void setAndGetAttrs(String firstName, String lastName, String emailAddress) {
    User user = new User();
    user.setFirstName(firstName);
    user.setLastName(lastName);
    user.setEmail(emailAddress);

    assertEquals(user.getFirstName(), firstName, "Should get first name that was set");
    assertEquals(user.getLastName(), lastName, "Should get last name that was set");
    assertEquals(user.getEmail(), emailAddress, "Should get email address that was set");
  }
}

Notice that although business entities are often trivial to test, like in this case i've just written a test for getters/setters which may look trivial. But trust me, it helps when you try to start relying on your test suite.

Let's move towards our repository layer where, perhaps, the most critical part of any application resides. We know them as transactions which are quite sensitive, must obey business complications and yet they must be efficient and fail-safe. In one of my previous blog posts I had explained how peacefully we can configure transactional operations using the flexibility of Spring 3 and AOP. Now we'll see how much flexibility does Spring 3 provide on the same par to test those transactions. We'll write integration tests for our repository and will use same database to execute tests(which will rollback after every test execution of course).

package com.springhibernate.integration.repository;

import com.springhibernate.integration.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;
import org.springframework.transaction.annotation.Transactional;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

/**
 * @author Nabeel Ali Memon
 */

@ContextConfiguration(locations = {"classpath:/META-INF/spring/integration-data.xml"})
public class UserBaseTest extends AbstractTransactionalTestNGSpringContextTests {
  @Autowired
  private UserBase userRepository;

  private User user;

  /**
   * Preparing test data which will be initialized only once for all @Test methods of this class
   */
  @BeforeClass
  @Parameters({"firstName", "lastName", "emailAddress"})
  public void init(String firstName, String lastName, String emailAddress) {
    user = new User();
    user.setFirstName(firstName);
    user.setLastName(lastName);
    user.setEmail(emailAddress);
  }

  /**
   * Transactional operation which will be rolled back by Spring after the test method runs
   */
  @Test
  @Transactional
  public void addAndGetUser() {
    int actualUsers = userRepository.getUsers().size();
    userRepository.addUser(user);
    int incrementedUsers = userRepository.getUsers().size();
    Assert.assertNotNull(user.getId(), "If user is persisted it must have been assigned an id");
    Assert.assertEquals(incrementedUsers, actualUsers + 1, "After adding 1 user, total users' count must increment by 1");
  }
}

It is due to Spring's provision of TestContext framework which handles caching and context management and which in turn makes your test executions really fast. You may notice that here we've extended Spring's TestNG Transactional TestContext support [abtract] class that Spring provides to perform integration testing through TestNG with transaction support.

Going towards the end of this post, we have Spring web MVC controllers to test. Even for Controllers, Spring provides it's handy mock objects which can be used to write unit tests. The mix the using EasyMock for mocking up repository bean makes it even more fun.

Now we can easily mock up our 'UserBase' repository bean, instantiate our controller and directly call methods on them. This way we'll be able to test our controller's method response quite easily. But, what about testing the RequestMapping and friends. Well, let's see Spring provided mock objects and EasyMock in action.

package com.springhibernate.integration.web.controllers;

import com.springhibernate.integration.model.User;
import com.springhibernate.integration.repository.UserBase;
import org.easymock.EasyMock;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Nabeel Ali Memon
 */

@Test
public class UserControllerTest {
  private MockHttpServletRequest request;
  private MockHttpServletResponse response;
  private UserController userController;
  private AnnotationMethodHandlerAdapter methodHandlerAdapter;
  private UserBase userRepositoryMock;

  /**
   * Initialize before every individual test method
   */
  @BeforeMethod
  public void init() {
    request = new MockHttpServletRequest();
    response = new MockHttpServletResponse();
    methodHandlerAdapter = new AnnotationMethodHandlerAdapter();
    userRepositoryMock = EasyMock.createStrictMock(UserBase.class);
  }

  @Test(alwaysRun = true)
  @Parameters({"getUsers"})
  public void getAllUsers(String usersPage) throws Exception {
    List users = new ArrayList();
    request.setRequestURI("/integration/users");
    request.setMethod("GET");
    EasyMock.expect(userRepositoryMock.getUsers()).andReturn(users);
    EasyMock.replay(userRepositoryMock);
    userController = new UserController(userRepositoryMock);
    ModelAndView modelAndView = methodHandlerAdapter.handle(request, response, userController);
    Assert.assertEquals(modelAndView.getViewName(), usersPage, "returned view name should be " + usersPage);
    EasyMock.verify(userRepositoryMock);
  }

  /**
   * Let this method run after the previous method is done. It keeps you from thread-safety
   * issues while using mock-ups.
   */
  @Test(dependsOnMethods = {"getAllUsers"}, alwaysRun = true)
  @Parameters({"getUser"})
  public void getSingleUser(String userDetailsPage) throws Exception {
    request.setRequestURI("/integration/users/{id}");
    request.setMethod("GET");
    User user = new User();
    Long userId = new Long(1);
    Map pathVariables = new HashMap();
    pathVariables.put("id", String.valueOf(userId));
    request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, pathVariables);
    EasyMock.expect(userRepositoryMock.getUser(userId)).andReturn(user).anyTimes();
    EasyMock.replay(userRepositoryMock);
    userController = new UserController(userRepositoryMock);
    ModelAndView modelAndView = methodHandlerAdapter.handle(request, response, userController);
    Assert.assertEquals(modelAndView.getViewName(), userDetailsPage, "returned view name should be " + userDetailsPage);
    EasyMock.verify(userRepositoryMock);
  }
}

Note that i've carefully used test configuration options provided by TestNG framework in order to achieve cleaner, reliable and efficient tests. Although a good support for unit-testing becomes available when you introduce 'Dependency Injection' to your application design, but frameworks like Spring take it a step further and make it much cleaner and fun to write.

Spring 3 integrated with Hibernate Part-C

2010-05-13T23:49:00.010+05:00

After going through Part-B of this tutorial series, you must have a working console application built on Spring 3 and Hibernate and by now you must have got a good idea of how Spring can manage your database transactions by encapsulating persistence-layer based transactions behind the curtains. Yes, behind the scenes Spring delegates transactional handling to [in our case] Hibernate and exposes an easy-to-use transaction facade for us. Since Spring has been in such a widespread use that if you follow old-school DAO pattern to encapsulate Hibernate POJO's then you don't even need to provide transaction details, instead you just extend one of the Spring provided DAO templates (HibernateTemplate in our case), override the CRUD methods and Spring will handle transaction details internally. But it poses two serious drawbacks of vendor lock-in and tight-coupling.

Let's move forward towards turning our project into a web application but hey what about Aspect-oriented programming stuff? I'm sure you must have heard a lot about AOP and maybe some of you know just how to get around it. In any case I assume that you understand what is:

Aspect: A concern that cuts across multiple classes. For example Transaction, Logging, Authentication etcetera.
Join Point: A point during the program's execution. In Spring, only method execution represents a Join Point.
Advice: An action taken by an Aspect on a Join Point. That Advice might be executed "before", "after", "after-return" or "around" that Join Point. In Spring, an Advice executes as an Interceptor.
Pointcut: An expression that when matches with a Join Point, the associated Advice is executed. Spring uses AspectJ's expression language to define Pointcuts.

Instead of going the old-school way of following schema-based approach to declare aspects in Spring configuration .xml file, let's use Spring's powerful AOP support annotations.

You may observe that we haven't logged our transactional methods yet which is commonly followed practice. This functionality can be flexibly achieved using AOP. So let's start some coding.

1: To enable AspectJ support to this application you need to declare following inside 'META-INF/spring/integration-data.xml'

<aop:aspect-autoproxy/>

2: Under 'src/main/java/com/springhibernate/integration' create a package named 'aspects'.
3: Inside 'aspects' package, create a class 'LoggingAspect.java' with proper annotations on class and it's methods that are required for an AOP Advice to execute in a desirable manner.

package com.springhibernate.integration.aspects;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author Nabeel Ali Memon
 */

@Component
@Aspect
public class LoggingAspect {
  //Pointcut definition for all repository transactions that get entities
  @Pointcut("execution(* com.springhibernate.integration.repository.*.get*(..))")
  public void getterTransaction() {}

  //Pointcut definition for all repository transactions that add entities
  @Pointcut("execution(* com.springhibernate.integration.repository.*.add*(..))")
  public void adderTransaction() {}

  //For common Advice on both Pointcuts we combine them to make a single Pointcut
  @Pointcut("adderTransaction() || getterTransaction()")
  public void adderOrGetterTransaction() {}

  //Advice that executes before an Adder or Getter Transaction Join Point is called
  @Before("adderOrGetterTransaction()")
  public void beforeTransaction() {
    System.out.println("------------------------------------");
    System.out.println("--------Beginning transaction-------");
    System.out.println("------------------------------------");
  }

  @AfterThrowing(pointcut = "adderOrGetterTransaction()", throwing = "throwable")
  public void adderOrGetterThrewException(Throwable throwable) {
    throw new RuntimeException("Transaction Unsuccessful. "+throwable.getMessage());
  }
  //Advice that executes after an Adder Transaction Join Point is executed
  @After("adderTransaction()")
  public void afterAdderTransaction() {
    System.out.println("-------Ending Adder Transaction-----");
  }

  //Advice that executes after a Getter Transaction Join Point is executed
  @AfterReturning(pointcut = "getterTransaction()", returning = "retVal")
  public void afterGetterTransaction(Object retVal) {
    System.out.println("Transaction returned value: "+ retVal.toString());
  }
}

Note: Again, you can read my comments inside code to clearly understand which annotation is doing what. You can do many useful things with AOP Advices, but, just to make it more easy-to-understand I rather did simple logging.

4: To let Spring container auto-detect and initialize the bean that we just created, declare the following in 'META-INF/spring/integration-date.xml'

<context:component-scan base package="com.springhibernate.integration.aspects" />

You can go back to 'App.java' and execute it as is and read the console output to see AOP in action.

We'r not gonna log every detail using AOP, that was just for transactional stuff. Let's turn to the widely used log4j logging. The dependency declaration, classpath scope everything is already in place inside your 'pom.xml'. All we have to do is to create a file 'log4j.properties' under 'META-INF/properties'

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.rootLogger=DEBUG, stdout, R
log4j.appender.R.File=application.log
log4j.appender.R.MaxFileSize=100KB
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.MaxBackupIndex=1
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.logger.org.hibernate.SQL=debug
log4j.logger.org.hibernate.tool.hbm2ddl=debug
log4j.logger.org.hibernate.hql=debug
log4j.logger.org.hibernate.transaction=debug

Of course it's a matter of convenience to configure logging that matches your choices.

Since we have an application engine in place and working, let's actually turn it into a web application. We'll be using widely adopted MVC pattern for our web layer provided by Spring MVC. Although we'll just scratch the surface of what Spring MVC has to offer us with the release of Spring 3, but you'll get an idea of how flexible it is compared to frameworks like Struts and JSF etcetera. Detailed coverage of Spring MVC is an interesting topic i'll keep for my next blog post.

1: Create a folder named 'spring' under 'src/main/webapp/WEB-INF'
2: To use Spring MVC we need to have some configuration declared in our Spring configuration .xml file. We'll create a separate file named 'integration-mvc.xml' inside 'spring' folder that we just created.

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
xmlns:context="http://www.springframework.org/schema/context"  
xmlns:mvc="http://www.springframework.org/schema/mvc"  
xmlns:p="http://www.springframework.org/schema/p"  
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xsi:schemaLocation="http://www.springframework.org/schema/beans  
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
http://www.springframework.org/schema/context  
http://www.springframework.org/schema/context/spring-context-3.0.xsd  
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">  

<!--controllers are autodetected pojo's annotated with @Controller-->  
<context:component-scan base-package="com.springhibernate.integration.web.controllers" use-default-filters="false">  
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>  
</context:component-scan>  

<!--support for @Controller mvc request mapping. also registers formatters and validators for use across @Controller-->  
<mvc:annotation-driven/>  

<!--select static view for rendering without going through @Controller-->  
<mvc:view-controller path="/index" view-name="index"/>  

<!--inside controllers you don't need to worry about where your jsp is located-->  
<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">  
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>  
<property name="prefix" value="/WEB-INF/views/"/>  
<property name="suffix" value=".jsp"/>  
</bean>  

</beans>

3: Create subsequent packages named 'web/controllers' under '/src/main/java/com/springhibernate/integration'
4: In 'controllers' package, create a Spring MVC controller named 'User'Controller'. We'll use this controller to respond to web requests on our User entity.

package com.springhibernate.integration.web.controllers;

import com.springhibernate.integration.model.User;
import com.springhibernate.integration.repository.UserBase;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

/**
 * @author Nabeel Ali Memon
 */

/**
 * This annotation makes it a Spring MVC controller.
 * No need to extend any abstract controller like old Spring way
 */
@Controller
/**
 * Spring MVC 3 supports RESTful URL's out of the box.
 * Every request on 'integration' resource will be handled by this controller
 */
@RequestMapping("/integration/*")
public class UserController {
  private UserBase usersRepository;

  //Injecting a repository bean to talk to database
  @Autowired
  public UserController(UserBase usersRepository) {
    this.usersRepository = usersRepository;
  }

  /**
   * List all the users and display "users.jsp" page.
   * The location and mime-type of "users.jsp" will be resolved by Spring container's "viewResolver" bean
   * that declared in "integration-mvc.xml"
   */
  @RequestMapping(value = "users", method = RequestMethod.GET)
  public ModelAndView getUsers() {
    List users = usersRepository.getUsers();
    ModelAndView modelAndView = new ModelAndView("users");
    modelAndView.addObject("users", users);
    return modelAndView;
  }

  /**
   * To get a specific User by it's user-id RESTfully.
   * Notice how easily you can bind a RESTful request parameter to a controllers method parameter
   * using @PathVariable
   */
  @RequestMapping(value = "users/{id}", method = RequestMethod.GET)
  public ModelAndView getUser(@PathVariable Long id) {
    User user = usersRepository.getUser(id);
    ModelAndView modelAndView = new ModelAndView("userDetails");
    modelAndView.addObject("user", user);
    return modelAndView;
  }
}

5: Create the jsp pages 'users.jsp' and 'userDetails.jsp' in 'views' folder which you'll create under 'webapp/WEB-INF'
Users.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page isELIgnored="false" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<html>
<head><title>All Users</title></head>
<body>

<h2>Total Users: <c:out value="${fn:length(users)}"/> </h2>

 
<c:forEach var="user" items="${users}">
<h3>User's Details:</h3>

First Name: <c:out value="${user.firstName}"/>
Last Name: <c:out value="${user.lastName}"/> 
Email Address: <c:out value="${user.email}"/> 

</c:forEach>

</body>
</html>

UserDetails.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page isELIgnored="false" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head><title>User Details</title></head>

<body>

<h3>User's Details:</h3>

First Name: <c:out value="${user.firstName}"/>
Last Name: <c:out value="${user.lastName}"/> 
Email Address: <c:out value="${user.email}"/> 

</body>

</html>

6: To deploy this app on a web container (Jetty in our case) we need a deployment descriptor and since we'r using Spring container and Log4j, we need to provide additional context configuration in our 'web.xml'

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
<display-name>Archetype Created Web Application</display-name>

<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:META-INF/properties/log4j.properties</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

<!--All spring configuration files need to be loaded in context. Although we have single file but
with the growing configuration stuff we need to break down configuration files too-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:META-INF/spring/integration-*.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
<!--Spring's front controller or dispatcher which will be responsible to handle every web request
and dispatch it to a specific web controller-->
<servlet-name>integration</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/integration-mvc.xml</param-value>
</init-param>
</servlet>

<!--Let every request be handled by Spring's Dispatcher servlet and it'll decide which web controller to call -->
<!--based on @RequestMapping-->
<servlet-mapping>
<servlet-name>integration</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

<welcome-file-list>
<welcome-file>
index.jsp
</welcome-file>
</welcome-file-list>
</web-app>

We have just created our web app based on Spring 3 and Hibernate using Maven 2. It's ready to be deployed and serve it's purpose. To deploy it, fire-up your command line and issue the following maven commands one by one:

mvn package
mvn jetty:run

After you see a clean application boot sequence log on the console, you'r ready to visit your web app through your internet browser. Visit the following URL's in your browser, see the result data, read the console logs and code ahead.

http://localhost:8080/spring-hibernate-webapp/integration/users
http://localhost:8080/spring-hibernate-webapp/integration/users/1

Although we haven't looked at various other features, some improved and some new, of Spring 3 yet. But I hope this tutorial series has given you a kickstart into the technologies we've used. More will be covered in depth into my future blog posts. So hang on.

Spring 3 integrated with Hibernate Part-B

2010-05-12T22:41:00.020+05:00

You must have reached this page after covering the first part of this tutorial series Spring 3 integrated with Hibernate part A. If not, then you need to go through that part prior to reading ahead.

So let's move towards integrating Spring 3 into our project. We've already added Spring 3 dependency libraries' declarations in our pom.xml. You'll notice that we are using Spring framework version 3.0.2 which is the latest release of the framework to date. What we are going to do first is to create a Repository bean (to encapsulate Hibernate POJO's) and a Spring application context file. While using Spring, we'll prefer annotations over declarative approach which in turn will prove itself to be a much powerful and flexible approach and which is of course the whole point of this tutorial series.

Let's actually get into it and start some coding now.

1: Inside 'src/main/resources' create a folder named 'META-INF'.
2: Inside 'META-INF' create two folders named 'spring' and 'properties' (we'll use 'spring' folder to place spring-specific configuration files and 'properties' folder for our database and log4j properties).
3: Create a new file named 'database.properties' under 'META-INF/properties' which should have our database configuration.

database.url=jdbc:mysql://localhost:3306/integration
database.username=username
database.password=password
database.driverClassName=com.mysql.jdbc.Driver

4: Create a new xml file named 'integration-data.xml' inside the folder 'META-INF/spring'. This file will contain our basic spring configuration to start with.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
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.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 

<!--You don't need declarative transactions. By declaring <tx:annotation-driven...> only, you just annotate your repositories with 
@Transaction--> 
<tx:annotation-driven mode="aspectj"/> 

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
<property name="dataSource" ref="dataSource"/> 
<property name="hibernateProperties"> 
<props> 
<prop key="dialect">org.hibernate.dialect.MySQL5Dialect</prop> 
<prop key="show_sql">true</prop> 
<!--<prop key="format_sql">true</prop>--> 
</props> 
</property> 
<property name="mappingResources"> 
<list> 
<value>mappings/user.hbm.xml</value> 
</list> 
</property> 
</bean> 

<!--Put your often-changing configuration values outside spring configuration anywhere and let spring bring those changes in--> 
<context:property-placeholder location="classpath*:/META-INF/properties/*.properties"/> 

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> 
<property name="driverClassName" value="${database.driverClassName}"/> 
<property name="url" value="${database.url}"/> 
<property name="username" value="${database.username}"/> 
<property name="password" value="${database.password}"/> 
</bean> 

<!--To spring, communication with a database must take place in a transactional context--> 
<!--If you change this bean's id to any string other than "transactionManager", you'll have to specify that id to <tx:annotation-driven...>'s 
transaction-manager attribute. This is an example of convention over configuration which makes your work easier--> 
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
<property name="sessionFactory" ref="sessionFactory"/> 
</bean> 

<!--repository initialization--> 
<bean id="repository.users" class="com.springhibernate.integration.repository.HibernateUserBase" 
autowire="constructor"/> 
</beans>

5: Inside 'src/main/java/com/springhibernate/integration' create a package named 'repository'.
6: Inside 'repository' package create an interface named 'UserBase' and it's implementation class named 'HibernateUserBase'

package com.springhibernate.integration.repository;

import com.springhibernate.integration.model.User;

import java.util.List;

/**
* @author Nabeel Ali Memon
*/
public interface UserBase {
  public User getUser(Long id);
  public List getUsers();
  public void addUser(User user);
}

package com.springhibernate.integration.repository;

import com.springhibernate.integration.model.User;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author Nabeel Ali Memon
 */

@Repository
@Transactional
public class HibernateUserBase implements UserBase {
  private SessionFactory sessionFactory;

  @Autowired
  public HibernateUserBase(SessionFactory sessionFactory) {
    this.sessionFactory = sessionFactory;
  }

  @Override
  @Transactional
  public User getUser(Long id) {
    return (User) sessionFactory.getCurrentSession().get(User.class, id);
  }

  @Override
  @SuppressWarnings("unchecked")
  @Transactional
  public List getUsers() {
    return sessionFactory.getCurrentSession().createQuery("from User u").list();
  }

  @Override
  @Transactional
  public void addUser(User user) {
    sessionFactory.getCurrentSession().save(user);
  }
}

Notice @Repository annotation through which Spring container identifies this bean as a repository and @Transaction annotation which i've discussed in 'integration-data.xml'

7: To test drive our configuration upto this point and have a taste of dependency injection using Spring 3 let's create a class 'App.java' under 'src/main/java/com/springhibernate/integration' having just a main method and try to print our user's email address to the console all the way from database and you'll see how Spring and Hibernate work in harmony.

package com.springhibernate.integration;

import com.springhibernate.integration.model.User;
import com.springhibernate.integration.repository.UserBase;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* @author Nabeel Ali Memon
*/
public class App {
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/*.xml");
    UserBase users = (UserBase) ctx.getBean("repository.users");
    User user = users.getUser(new Long(1));
    System.out.println("User's email address: " + user.getEmail());
  }
}

Run it from your IDE or command line with the main class as 'App.java' and if all goes well, you should see this on your console:
"User's email address: nabeelalimemon@gmail.com"

That marks the end of this part. I hope you learned and enjoyed. To get more explanation of what's going on just take a look at the comments i've written in .xml and .java files where necessary. Stay around for the next and probably last part of this tutorial series in which we'll turn this project into a web application.

Spring 3 integrated with Hibernate Part-A

2010-05-12T00:57:00.009+05:00

Spring 3 has finally been released, a while back, with it's all new features offering a better developer experience. But there hasn't been any straight forward tutorial that could set you up on your path to roll out your application using dependency injection and web layer from Spring 3 and domain repositories through good old Hibernate. At least I couldn't find such a helpful stuff which i could use as a stub for my next project rapidly.

There's already a tool(actually a great code-generator "Spring Roo") which brings up a Spring 3 based project within minutes but that doesn't tell you how features from Spring 3 actually work. To learn that, let's build our own project step by step.

This tutorial will be broken into three parts. By the end of this series it'll have all the good stuff from Spring (that is Dependency Injection, MVC, Repository, Transaction demarcations, Aspects and all the fun) the Spring 3 way. We'll be using Hibernate for relational persistence mapping.

In this Part(that is Part A) we will create a maven project first and make it talk to our database through Hibernate. So let's start some coding by creating a maven project.

mvn archetype:create -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=com.springhibernate.integration -DartifactId=spring-hibernate-webapp

Let's get into our newly created "spring-hibernate-webapp" directory and make this baby work with Intellij Idea by executing

mvn idea:idea

Of course you can use any IDE of your choice. Anyways, after you see a "BUILD SUCCESSFUL" message on the command line, open this project into Intellij Idea. To make this project use Spring 3, Hibernate, Log4j, some Apache libraries and a couple of maven plugins etcetera we need to configure our pom.xml (since pom.xml is fairly long, i've avoided writing it's content here. You can look at the source directly at google-code hosting of this project).

Let's configure Hibernate for this project and march towards the end of this part of series.

1: Under 'src/main' you should have a source folder named 'java' (if not then create it).
2: Under that folder create a package 'com.springhibernate.integration'.
3: Create a class HibernateUtils.java under that package.
4: At this point, to verify that all your maven dependencies are resolved and that your project setup is clean, you can create a main method inside inside HibernateUtils.java to print a greeting message like this

package com.springhibernate.integration;

import com.springhibernate.integration.model.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
* @author Nabeel Ali Memon
*/
public class HibernateUtils {
  public static void main(String[] args) {
    System.out.println("Working Correctly upto this point");
  }
}

5: To execute it, go to command line and run these maven commands

mvn compile
mvn -e exec:java -Dexec.mainClass="com.springhibernate.integration.HibernateUtils"

And you should successfully see "Working Correctly upto this point".

6: Now we need a relational database and a table to persist/retrieve our data. For all practical purposes, let's use MySQL by creating a database, a table and one entry to that table as following.

create database test;
use test;
create table user (user_id int(11) primary key, first_name varchar(30), last_name varchar(30), email varchar(30));
insert into user values(1, 'Nabeel', 'Memon', 'nabeelalimemon@gmail.com');

7: We'r done with the database part. Let's come back to our IDE and under the folder 'src/resources' create a new folder named 'mappings' and create a mapping file named 'user.hbm.xml' inside that folder. This mapping file should look like this:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="com.springhibernate.integration.model.User" table="USER">
<id name="id" column="USER_ID">
<generator class="increment"/>
</id>
<property name="firstName" column="FIRST_NAME"/>
<property name="lastName" column="LAST_NAME"/>
<property name="email" column="EMAIL"/>
</class>
</hibernate-mapping>

8: Under the package 'src/main/java/com/springhibernate/integration' create a package named 'model' and under that package create a class 'User.java' which is simply a Hibernate POJO for User entity.

package com.springhibernate.integration.model;

/**
 * @author Nabeel Ali Memon
 */
public class User {
  private Long id;
  private String firstName;
  private String lastName;
  private String email;

  public User() { }

  public Long getId() {
    return id;
  }

  public void setId(Long id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }
}

9: Hey we haven't provided the hibernate configuration file yet, so let's create one under '/src/resources' named 'hibernate.cfg.xml'

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/test</property>
<property name="connection.username">username</property>
<property name="connection.password">password</property>
<property name="format_sql">true</property>
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>
<!-- Disable the second-level cache  -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<!--property name="hbm2ddl.auto">update</property-->
<mapping resource="mappings/user.hbm.xml"/>
</session-factory>
</hibernate-configuration>

10: So now let's modify our 'HibernateUtil.java' exposing Hibernate Session Factory provider method(static) and get it to do some real stuff

package com.springhibernate.integration;

import com.springhibernate.integration.model.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * @author Nabeel Ali Memon
 */
public class HibernateUtils {
  private static final SessionFactory sessionFactory = buildSessionFactory();

  private static SessionFactory buildSessionFactory() {
    try {
      // Create the SessionFactory from hibernate.cfg.xml
      return new Configuration().configure().buildSessionFactory();
    }
    catch (Throwable ex) {
      // Make sure you log the exception, as it might be swallowed
      System.err.println("Initial SessionFactory creation failed." + ex);
      throw new ExceptionInInitializerError(ex);
    }
  }

  public static SessionFactory getSessionFactory() {
    return sessionFactory;
  }

  public static void main(String[] args) {
    Session session = getSessionFactory().getCurrentSession();
    session.getTransaction().begin();
    User user = (User) session.get(User.class, new Long(1));
    System.out.println("user's email id is: "+user.getEmail());
    session.getTransaction().commit();
  }
}

Simply execute the HibernateUtil.java file from (your IDE or) command line using maven exec plugin like we did before and you should see our user's email address printed to screen.

That marks our project's Hibernate usability. Hang on for the next part in which we actually configure Spring 3 in this project and introduce a Repository layer, Transactions and Logging Aspect being handled by Spring.

Update 1: Spring 3 integrated with Hibernate Part-B of this tutorial series is available now.

Update 2: I've hosted the entire project at code.google.com and have open sourced it under Apache 2 license. Enjoy!