Technotrance, Illusions and Perspectives » Uncategorized

Tip: Listing and Compressing modified files on SVN since latest update on Linux

Shrihari — Thu, 26 Nov 2009 12:52:17 +0000

In order to find or look at the list of all the modified files on SVN (since the last update) on any Linux host, you may use the following command (say we need to find java or xhtml files)


svn status -u | grep -e '.java' -e '.xhtml' | awk '{if($2 ~/^[0-9]+$/) {print $3} else {print $2}}'

This command would also print the unversioned (not added to SVN) files as well. Now if you want to compress these list of files (using tar), issue the following shell command:


svn status -u | grep -e '.java' -e '.xhtml' | awk '{if($2 ~/^[0-9]+$/) {print $3} else {print $2}}' | xargs tar cvfz modifiedfiles.tar.z

Custom injection example in Google Guice

Shrihari — Fri, 10 Jul 2009 12:11:19 +0000

Google Guice supports custom injections using 2 endpoints: type listener and injection listener and registeration of end-points. You may read the whole theory behind here, where a Logging Injection using Log4J is explained.

Lets try to implement that and see what more is required. In order to test the whole exercise, we could embrace TestNG to write a sample unit test-case using a dummy class have a method. Lets write a simple class which uses the Log4J Logger instance, injected using InjectLogger.

public class LoggingUsage  
{   @InjectLogger org.apache.log4j.Logger log;
     public int doAddition(int a,int b)
     {      int c = a+b;
           log.info("Added result: "+c);
           return c;
     }
}

Lets us now a write a TestNG testcase to try and test the same.
public class CustomLoggerInjectionTest
{ LoggingUsage logUsage;
@BeforeMethod
public void initLogUsage()
{ logUsage = Guice.createInjector(new LoggerModule(),new MyLoggerModule()).getInstance(LoggingUsage.class);
}

@Test
public void testLogUsage()
{ int value = logUsage.doAddition(20, 15);
assertEquals(value,35);
}

static class MyLoggerModule extends AbstractModule
{ @Override
protected void configure()
{ bind(LoggingUsage.class);
}
}
}
[/sourcecode]
Lets examine this testcase. Just before test execution, we register the LoggerModule, which binds the LOG4J specific listeners (type/injections) and custom module to bind our custom class which needs Logger injection we wrote above, and instantiate the class that uses this Logger instance. When the test executes, the usage-class would already have a injected Logger and would execute without issues.

Using enums in DWR to populate select or multi-select

Shrihari — Mon, 06 Jul 2009 18:04:04 +0000

In case we need to population enumeration data in combo box or multi-select widgets, in DWR (integrated on Spring), following is the approach:

1) In the spring’s applicationContext.
a) Add the method which returns the enum entity to
b) Add a dwr:convert tag of type ‘enum’ (as below)

2) In the view (jsp) file, you could invoke the following javascript function


function loadEnumeration()
{ myOperations.getDataAsEnum(callbackFunctionHandle);
};
var callbackFunctionHandle = function(data)
{   dwr.util.removeAllOptions('enum_select');
     dwr.util.addOptions('enum_select',['--Select--']);
     dwr.util.addOptions('enum_select', data);
}

Resolving conflicts on DWR with jQuery

Shrihari — Sat, 04 Jul 2009 11:11:32 +0000

Since DWR’s util.js uses $ as an alias to ‘dwr.util.byId’ function, it may not have a smooth integration with jQuery as $ is also used by the latter as a function alias. In order to resolve this conflict, one could follow snippet:

‘jq’ variable defined in place of $ to invoke the rest of other jQuery functions.

dwr/util.jsfor

Integrating PrimeFaces with GuiceyFruit on JPA

Shrihari — Tue, 30 Jun 2009 18:47:43 +0000

Following suggestions from James Stratchan and Catagay Civici, I set my foot to integrate GuiceyFruit with JPA for the PrimeFaces tutorial I wrote. You could download the example hosted there and try it. Here are the steps I followed on that Book-Store example and ended up with a cool working code.

1) Add the following repository to pom.xml


 guiceyfruit.release
 GuiceyFruit Release Repository
 http://guiceyfruit.googlecode.com/svn/repo/releases/
 
 false
 
 
 true

2) Add the following dependencies


 org.guiceyfruit
 guiceyfruit-jpa
 2.0-beta-7

3) Comment/remove the following dependency

4) Open the dataservice bould concrete implementation (e.g. BookStoreImpl in the example) and replace @Inject with @javax.persistence.PeristenceContext.

public class BookStoreImpl implements BookStore
{  @PersistenceContext()
   private EntityManager em;
}

5) Open the WEB-INF/web.xml and modify the context-param ‘optimus.CONFIG_MODULES’ like this


 optimus.CONFIG_MODULES
 com.ts.pfaces.core.BookStoreModule
 ,org.primefaces.optimus.persistence.JPAModule
 ,org.guiceyfruit.jpa.JpaModule

And voila it works!

Implementing a Unitils DAO testing infrastructure for Spring and JPA on TestNG

Shrihari — Mon, 29 Jun 2009 17:50:51 +0000

Unitils provides an excellant infrastructure for unit testing DAO (and data-service) layers for Spring as IoC Framework on all the component unit testing frameworks such as JUnit 3, JUnit4 and TestNG, without any boilerplate code or coniguration hassles. We will look at establishing a testing infrastructure for Spring with JPA on TestNG frmaework.

Suppose the custom DAO and its implementation definition are like this (with regard to semantics of Spring JPA integration)

package mypackage;
public CustomDAO
{    public List findAll();
     public void save(Entity eo);
}

package mypackage;
public CustomDAOImpl implements CustommmDAO
{   @PersistenceContext
    private EntityManager em;

    //all other method implementations..
      ....
}

In order to setup a Unitils test infrastructure on TestNG, the following is the class-template:

public class CustomDAOTestCase extends UnitilsTestNG
{   /**
     * Injects a test specific application context configuration
     */
    @SpringApplicationContext
    public ConfigurableApplicationContext createApplicationContext()
    {  return new ClassPathXmlApplicationContext("applicationContext-test.xml");
    }

     @SpringBean("customDAO")
     private CustomDAO customDAO;

     //all @Test annotated methods..

      @Override
      protected void unitilsAfterTestTearDown(java.lang.reflect.Method method)
      {}
}

for which the following would be the test specific Spring’s application context confguration (applicationContext-test.xml)

Look specifically at entityManagerFactory bean definition, org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean allows us to load test specific persistence.xml which could allow us to maintain more than onne persistence context for a sample application.
These two definitions extend the Spring’s JPA capabilities for unit testing DAO on Unitils infrastructure!

Overcoming pitfalls with Query cache in Hibernate

Shrihari — Sat, 27 Jun 2009 17:41:43 +0000

Query caching in Hibernate used to cache query state and results, has multiple shortcomings if, not used judiciously. Some of the common pitfalls include:

(i) Query Cache structural representation is a QueryKey mapped to Object[][] (2-dimensional) and holds majority of persistent object references. QueryKey represents query specific data such as the SQL Query text with parameters (positional/named). QueryKey representation would get deteriorated if parameters represent entity object or a deep rooted object hierarchy.

(ii) If multiple equivalents of load() is invoked, there could potentially create multiple parameter versions of QueryKey containing equivalent duplicate entity objects exist in the cache.

Following are the patterns and practices that could be followed to fix these shortcomings:

1) Decorate org.hibernate.cache.StandardQueryCache and override the put() method to check if a canonical equivalent of a query results object already exist in the Object[][], and assign the same QueryKey if it exists. One needs to implement org.hibernate.cache.QueryCacheFactory also to plug into the Hibernate config.

2) Refactor the code to set entity’s keys as query parameters, rather than setting the entire entity object. Critreia representations should also use identifiers as parameters.

3) Write HQL queries to use identifiers in any substitutable parameters such as WHERE clause, IN clause etc.

4) Use positional parameters over named parameters as it could prevent using string pools.

5) If you are in a single JVM using in memory cache only, use hibernate.cache.use_structured_entries=false in your hibernate configuration.

Hibernate Session's get() annd load() comparison

Shrihari — Fri, 26 Jun 2009 18:43:39 +0000

These are the differences I could readily understand when I was comparing the runtime behaviour of Hibernate Session’s get and load methods.

a) get() does a database hit as soon as the method is called, load() makes a database hit, only if one of the field in the entity is called.

b) load() should be used when the entity is assured that it exists in the database, else get() should be called. If an non-existent primary key is passed, get() returns a null directly. However passing a non-existing primary key to load() returns you a non-null entity object, but would throw this exception when a field of that entity is referenced: org.hibernate.ObjectNotFoundException: No row with the given identifier exists.

c) calling a field in the entity in load() method after getTransaction().commit(), would throw a LazyInitializationException (could not initialize proxy – no Session).

Dependency Injection's equivalent Java reflection invocations

Shrihari — Wed, 24 Jun 2009 18:16:17 +0000

As we know that there are 3 types of injections supported by any IoC framework, following are the equivalent function points in the reflection package (java.lang.reflect):

1) Constructor Injection -   Constructor.newInstance(Object... initargs)
2) Method Injection    -     Object Method.invoke(Object obj, Object... args)
3) Field Injection -  void Field.set(Object obj, Object value)

Interestingly all these reflection classes are subclasses of java.lang.reflect.AccessibleObject and are final. Also the complete mechanics of Injection semantics hinges on the accessible flag defined in java.lang.reflect.AccessibleObject. Please see javadocs for effective explanation.

Using Google Guice to inject JPA EntityManager

Shrihari — Tue, 23 Jun 2009 17:54:26 +0000

I am working on an persistence example using PrimeFaces, Google Guice and Hibernate. Following are the four steps to inject a JPA EntityManager into the Manager (Appfuse parlance) / DAO Layer:

1) Define META-INF/persistence.xml containing JPA Configuration (similar to hibernate.cfg.xml)




 
 org.hibernate.ejb.HibernatePersistence
 
 ...

2) Create a startup controller Guice bean

@Controller(name="startupBean", startup=true)
public class StartupBean
{    public StartupBean()
      {}
}

3) Create a Google Guice Module

public class MyModule implements Module
{       public void configure(Binder binder)
          {   AnnotatedBindingBuilder bindingBuilder = binder.bind(MyDataService.class);
              ScopedBindingBuilder scopedBuilder = bindingBuilder.to(MyDataServiceImpl.class);
              scopedBuilder.in(SINGLETON);
          }
}

and create a context parameter in WEB-INF/web.xml


 optimus.CONFIG_MODULES
 mypackage.MyModule,org.primefaces.optimus.persistence.JPAModule

Note: org.primefaces.optimus.persistence.JPAModule actually injects the EntityManager reading the META-INF/persistence.xml

4) Create the DaraService implementation containing the injected EntityManager

public class MyDataServiceImpl implements MyDataService
{        @Inject
            private EntityManager em;
           //all methods using JPA entityManager here

}

No other configuration xmls to be changed. Ain’t it cool!