Most of teams using Eclipse as their primary IDE, rely on Eclipse code formatter that can be configured by enabling project specific setting and then adding /.settings directory to version control system. This directory contains org.eclipse.jdt.core.prefs which has formatting details.

Since these files are part of version control, all developers now has these settings file and formatting changes gets applied automatically on saving file.

But if you are an IDEA user, then there is was no way to use these Eclipse code formatting.

To make life somewhat easy, over the weekend I created a small plugin which basically let you use the Eclipse Code Formatter from IDEA. The main feature of this is that you can apply these on a Change List. Change List in IDEA is basically list of files that you have modified/created and are going to commit.

For more details visit project page – eclipse-code-formatter-on-change-list

The plugin is also available in IDEA plugin repository.

I had wrote a simple program to explain him that. Thought of putting it here. Below it is -

TreeMap – The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used. Below example you will notice that treeMap toString shows that entries are ordered by performing natural ordering on Int keys.

HashMap – This class makes no guarantees as to the order of the map. Uses object equality to check if key already exist in map and replace value if it exist. As in example while trying to put key11 as it equals with key1 value “One” is replaced with “Eleven”.

IdentityHashMap - Unlike above HashMap, this uses reference-equality in place of object-equality when comparing keys. As in following example even after key11 equals key1, but as their references are not equals so a new key/value is inserted.

LinkedHashMap – This implementation keeps track of order in which keys were inserted into the map. In below example you will notice that the toString shows entries in same order in which they were inserted. This also has another feature discussed next.

LRU Caching using LinkedHashMap – Another feature of LinkedHashMap is that it provide constructor to create a linked hash map whose order of iteration is the order in which its entries were last accessed, from least-recently accessed to most-recently (access-order). In following example, you will notice that when elements are inserted and none is accessed yet, the order of Entries is same as that of above example. But after accessing elements, you will notice that the entries order is changed based on when last it was accessed. Using this feature one can create a LRU(accessed) cache as shown in example. You will need to override removeEldestEntry method of LinkedHashMap and add your logic for caching. Each put operation will call this removeEldestEntry by passing least-recently-accessed element to it and based on removeEldestEntry’s return value it will either be kept or removed from the map.

WeakHashMap- In this implementation keys are held as WeakReferences. This way if there is no strong reference for key, on next Garbage Collection this key and corresponding value will be removed from the Map. Read this article for details on Java References. As in below example we are adding three keys to map and then clearing one strong reference to key6 by setting it to null. Then we request GC by calling System.gc() and in next statement you will notice that the key/value for key6 is removed from Map.

package collections;

import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.WeakHashMap;

public class DemoMap {

    public static void main(String[] args) {
        // TreeMap
        Map<Integer, String> treeMap = new TreeMap<Integer, String>();
        treeMap.put(4, "Four");
        treeMap.put(1, "One");
        treeMap.put(5, "Five");
        treeMap.put(3, "Three");
        treeMap.put(2, "Two");
        System.out.println("TreeMap - " + treeMap);
        // TreeMap - {1=One, 2=Two, 3=Three, 4=Four, 5=Five}

        // HashMap
        Key key1 = new Key(1);
        Key key11 = new Key(1);
        Key key2 = new Key(2);
        Key key3 = new Key(3);
        Map<Key, String> map = new HashMap<Key, String>();
        map.put(key1, "One");
        map.put(key11, "Eleven");
        map.put(key2, "Two");
        map.put(key3, "Three");
        System.out.println("HashMap - " + map);
        // HashMap - {3=Three, 1=Eleven, 2=Two}

        // IdentityHashMap
        Map<Key, String> idMap = new IdentityHashMap<Key, String>();
        idMap.put(key1, "One");
        idMap.put(key11, "One");
        idMap.put(key2, "Two");
        idMap.put(key3, "Three");
        System.out.println("IdentityHashMap - " + idMap);
        // IdentityHashMap - {1=One, 1=One, 3=Three, 2=Two}

        // LinkedHashMap
        Map<Integer, String> linkedMap = new LinkedHashMap<Integer, String>(5);
        linkedMap.put(4, "Four");
        linkedMap.put(1, "One");
        linkedMap.put(5, "Five");
        linkedMap.put(3, "Three");
        linkedMap.put(2, "Two");
        System.out.println("LinkedHashMap - " + linkedMap);
        //LinkedHashMap - {4=Four, 1=One, 5=Five, 3=Three, 2=Two}

        // LinkedHashMap for Caching using access-order
        Map<Integer, String> cachedLinkedMap = new CacheUsingLinkedHashMap<Integer, String>(5);
        cachedLinkedMap.put(4, "Four");
        cachedLinkedMap.put(1, "One");
        cachedLinkedMap.put(5, "Five");
        cachedLinkedMap.put(3, "Three");
        cachedLinkedMap.put(2, "Two");
        System.out.println("LinkedHashMap at full capacity no access performed yet - " + cachedLinkedMap);
        // LinkedHashMap at full capacity no access performed yet - {4=Four, 1=One, 5=Five, 3=Three, 2=Two}
        cachedLinkedMap.get(1);
        cachedLinkedMap.get(2);
        cachedLinkedMap.get(4);
        cachedLinkedMap.get(5);
        cachedLinkedMap.get(3);
        System.out.println("LinkedHashMap at full capacity after accessing few elements - " + cachedLinkedMap);
        // LinkedHashMap at full capacity after accessing few elements - {1=One, 2=Two, 4=Four, 5=Five, 3=Three}
        cachedLinkedMap.put(6, "Six");
        System.out.println("LinkedHashMap after adding new entry - " + cachedLinkedMap);
        // As 1 is least recently accessed.
        // LinkedHashMap after adding new entry - {2=Two, 4=Four, 5=Five, 3=Three, 6=Six}

        // WeakHashMap
        Map<Key, String> weakMap = new WeakHashMap<Key, String>();
        Key key4 = new Key(4);
        Key key5 = new Key(5);
        Key key6 = new Key(6);
        weakMap.put(key4, "Four");
        weakMap.put(key5, "Five");
        weakMap.put(key6, "Six");
        System.out.println("WeakHashMap before GC - " + weakMap);
        // WeakHashMap before GC - {6=Six, 5=Five, 4=Four}
        key6 = null;
        System.gc();
        System.out.println("WeakHashMap after GC - " + weakMap);
        // WeakHashMap after GC - {5=Five, 4=Four}
    }

    static class CacheUsingLinkedHashMap<K, V> extends LinkedHashMap<K, V> {

        int capacity;

        public CacheUsingLinkedHashMap(int cap) {
            super(cap + 1, 1.1f, true);
            capacity = cap;
        }

        @Override
        protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
            return size() > capacity;
        }

    }

    static class Key {
        int key;

        public Key(int key) {
            this.key = key;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + key;
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Key other = (Key) obj;
            if (key != other.key)
                return false;
            return true;
        }

        @Override
        public String toString() {
            return String.valueOf(key);
        }
    }

}

This component is a service component exposing various web services which are consumed by another .Net based UI component.

The initial attempt was not successful as the component was incompatible with multi-homed hosts (those with multiple IP addresses / network interfaces), because it listen to port 80 on the primary network interface only.

As currently the component was running on a single-homed host, there’s no problem, since there’s only one IP address, and no ambiguity.

But VCS clusters are multi-homed devices – they have local IP, and cluster IP.

And in VCS world, nobody is connecting to host name / IP directly, connection should be established to cluster name / IP.

So to make the component publish web service on all interfaces, instead of using localhost or host address, use 0.0.0.0 as address. With 0.0.0.0 you tell it to ‘listen’ to incoming connections to any ip-address (associated with box).

I tried to install latest available version but its not compatible. I played around with plugin.xml by removing until-build=”IU-93.94″, it got enabled but then threw following exception,

Caused by: java.lang.NumberFormatException: For input string: "IU-93.94"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
	at java.lang.Integer.parseInt(Integer.java:449)
	at java.lang.Integer.parseInt(Integer.java:499)
	at org.codehaus.testdox.intellij.IntelliJApiFactory.<init>(IntelliJApiFactory.java:24)

I had patched the IntelliJApiFactory and updated .class file in the testdox-plugin-1.1.12-diana.jar. I am using it for some time and my usage is limited to navigate between class and its test. Not seeing any exceptions but overall IDEA 9.x plugin api are changed a lot and using a patched plugin might crash IDEA.

But for those who can’t live without it, can download it here. Extract it to your IDEA plugins directory.

So tried to integrate dbdeploy with maven without ant on my Snow Leopard –

You will need following jars -

dbdeploy-cli-3.0M2.jar
hsqldb-1.8.0.7.jar

keep above jars in dir “db” in same dir of pom.xml and keep your dbdeploy sql scripts in dir “db/scripts”. This will look like -

|-db
|----lib
|-------dbdeploy-cli-3.0M2.jar
|-------hsqldb-1.8.0.7.jar
|----scripts
|-------createSchemaVersionTable.sql
|-pom.xml

Next configure following Maven plugins -

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>sql-maven-plugin</artifactId>
                <version>1.1</version>
                <dependencies>
                    <dependency>
                        <groupId>hsqldb</groupId>
                        <artifactId>hsqldb</artifactId>
                        <version>1.8.0.7</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <driver>${test.jdbc.driverClassName}</driver>
                    <url>${test.jdbc.url}</url>
                    <username>${test.jdbc.username}</username>
                    <password>${test.jdbc.password}</password>
                </configuration>
                <executions>
                    <execution>
                        <id>create-change-log</id>
                        <phase>process-test-sources</phase>
                        <goals>
                            <goal>execute</goal>
                        </goals>
                        <configuration>
                            <srcFiles>
                                <srcFile>${basedir}/db/scripts/createSchemaVersionTable.sql</srcFile>
                            </srcFiles>
                        </configuration>
                    </execution>
                    <execution>
                        <id>apply-db-changes</id>
                        <phase>process-test-classes</phase>
                        <goals>
                            <goal>execute</goal>
                        </goals>
                        <configuration>
                            <srcFiles>
                                <srcFile>${basedir}/target/consolidated_script.sql</srcFile>
                            </srcFiles>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

createSchemaVersionTable.sql is part of dbdeploy distribution. Copy HSQLDB version.

And the following

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.1</version>
                <executions>
                    <execution>
                        <id>dbdeploy</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <executable>java</executable>
                            <workingDirectory>${basedir}/db</workingDirectory>
                            <commandlineArgs>
                                -cp ${test.hsql.jar}:lib/dbdeploy-cli-3.0M2.jar com.dbdeploy.CommandLineTarget -U ${test.jdbc.username} -D ${test.jdbc.driverClassName} -u ${test.jdbc.url.escaped} -d ${test.dbdeploy.dbms.type} -o ${basedir}/target/consolidated_script.sql -s scripts/
                            </commandlineArgs>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

Following are the important maven properties that are to be set -

        <test.jdbc.driverClassName>org.hsqldb.jdbcDriver</test.jdbc.driverClassName>
        <test.jdbc.url>jdbc:hsqldb:file:${basedir}/target/testdb;shutdown=true</test.jdbc.url>
        <test.jdbc.url.escaped>jdbc:hsqldb:file:${basedir}/target/testdb\\;shutdown=true</test.jdbc.url.escaped>
        <test.jdbc.username>sa</test.jdbc.username>
        <test.jdbc.password></test.jdbc.password>
        <test.dbdeploy.dbms.type>hsql</test.dbdeploy.dbms.type>
        <test.hsql.jar>lib/hsqldb-1.8.0.7.jar</test.hsql.jar>

How it works –

We are using dbdeploy command line interface to achieve integration. The HSQLDB is used in a file mode which is evident by test.jdbc.url, since maven exec task executes by using bash semi-colon used in jdbc url needs to be escaped, thats the reason for defining test.jdbc.url.escaped property.

The sql-maven-plugin’s execution “create-change-log” is configured to run after phase “process-test-sources”, which creates change log table which is required by dbdeploy.

The exec-maven-plugin’s execution “dbdeploy” is configured to run after phase “test-compile”, executes dbdeploy command line interface, creates “${basedir}/target/consolidated_script.sql” which contains sql changes to be applied.

The sql-maven-plugin’s execution “apply-db-changes” is configured to run after phase “process-test-classes”, which applies consolidated change log script.

Hope it helps somebody..

EHCache is the actual provider of caching solution and Spring Module handles method interception and result storing in cache.

Since I am using Maven2, so added following dependancies -

        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>org.springmodules</groupId>
            <artifactId>spring-modules-cache</artifactId>
            <version>0.9</version>
        </dependency>

My complete pom.xml -

<?xml version="1.0" encoding="UTF-8"?>
<project 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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>Spring</groupId>
    <artifactId>Spring</artifactId>
    <version>1.0</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>3.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>3.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>3.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.10</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>3.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>org.springmodules</groupId>
            <artifactId>spring-modules-cache</artifactId>
            <version>0.9</version>
        </dependency>
    </dependencies>
</project>

Contact Table sql -

 CREATE TABLE `contact` (
  `ID` int(15) NOT NULL AUTO_INCREMENT,
  `FIRSTNAME` varchar(50) DEFAULT NULL,
  `LASTNAME` varchar(50) DEFAULT NULL,
  `EMAIL` varchar(150) DEFAULT NULL,
  PRIMARY KEY (`ID`),
  UNIQUE KEY `EMAIL` (`EMAIL`)
) ENGINE=MyISAM AUTO_INCREMENT=4 DEFAULT CHARSET=latin1

Adding ehcache namespace to Spring config file -

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:ehcache="http://www.springmodules.org/schema/ehcache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
...
</beans>

Created ehcache.xml file in classpath.

<ehcache>
    <defaultCache
            maxElementsInMemory="500" eternal="true" overflowToDisk="false" memoryStoreEvictionPolicy="LFU"/>
    <cache name="contactCache" maxElementsInMemory="500" eternal="true" overflowToDisk="false"
           memoryStoreEvictionPolicy="LFU"/>
</ehcache>

Adding caching to application-context.xml –

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:ehcache="http://www.springmodules.org/schema/ehcache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <ehcache:config configLocation="classpath:ehcache.xml" />

    <ehcache:proxy id="contactDAO" refId="contactDAOTarget">
        <ehcache:caching cacheName="contactCache" methodName="findAll"/>
        <ehcache:flushing cacheNames="contactCache" methodName="createContact" when="after"/>
    </ehcache:proxy>

    <bean id="contactDAOTarget" class="byteco.de.spring.ContactDAOImpl">
        <property name="namedParameterJdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <bean id="datasource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
        <property name="initialSize" value="5"/>
        <property name="url" value="jdbc:mysql://localhost:3306/springjpa"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg type="javax.sql.DataSource" ref="datasource"/>
    </bean>
</beans>

Here is my test class -

package byteco.de.spring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.test.annotation.ExpectedException;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

import static org.junit.Assert.assertTrue;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "/application-context.xml")
public class ContactDAOTest {

    @Autowired
    ContactDAO contactDAO;

    @Test
    public void shouldCreateNewContact(){
         assertTrue(contactDAO.createContact("gabbar","singh","gabbar@singh.com"));
         assertTrue(contactDAO.createContact("kalia","singh","kalia@singh.com"));
    }

    @Test
    public void shouldReturnListOfContact(){
        assertTrue(contactDAO.findAll().size()>0);
        assertTrue(contactDAO.findAll().size()>0);
        assertTrue(contactDAO.findAll().size()>0);
        // This will cause the cache to be cleared. refer to logs.
        assertTrue(contactDAO.createContact("samba","singh","samba@singh.com"));
        assertTrue(contactDAO.findAll().size()>0);
        assertTrue(contactDAO.findAll().size()>0);
        assertTrue(contactDAO.findAll().size()>0);
    }
}

Executed test shouldCreateNewContact first then shouldReturnListOfContact. Below is the console output -

DEBUG [org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor] - Autowiring by type from bean name 'byteco.de.spring.ContactDAOTest' to bean named 'contactDAO'
DEBUG [org.springframework.beans.factory.support.DefaultListableBeanFactory] - Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
DEBUG [org.springframework.beans.factory.support.DefaultListableBeanFactory] - Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to retrieve a cache entry using key <2056181503|2056171012> and cache model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Retrieved cache element <null>
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - Executing prepared SQL query
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - Executing prepared SQL statement [select * from contact]
DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to store the object <[0. 1 gabbar singh , 1. 2 kalia singh ]> in the cache using key <2056181503|2056171012> and model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Object was successfully stored in the cache
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to retrieve a cache entry using key <2056181503|2056171012> and cache model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Retrieved cache element <[0. 1 gabbar singh , 1. 2 kalia singh ]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to retrieve a cache entry using key <2056181503|2056171012> and cache model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Retrieved cache element <[0. 1 gabbar singh , 1. 2 kalia singh ]>
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - Executing prepared SQL update
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - Executing prepared SQL statement [insert into contact (firstname,lastname,email) values (?,?,?)]
DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - SQL update affected 1 rows
DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to flush the cache using model <org.springmodules.cache.provider.ehcache.EhCacheFlushingModel@2dd59d3c[cacheNames={'contactCache'}, flushBeforeMethodExecution=false]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Cache has been flushed.
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to retrieve a cache entry using key <2056181503|2056171012> and cache model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Retrieved cache element <null>
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - Executing prepared SQL query
DEBUG [org.springframework.jdbc.core.JdbcTemplate] - Executing prepared SQL statement [select * from contact]
DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to store the object <[0. 1 gabbar singh , 1. 2 kalia singh , 2. 3 samba singh ]> in the cache using key <2056181503|2056171012> and model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Object was successfully stored in the cache
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to retrieve a cache entry using key <2056181503|2056171012> and cache model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Retrieved cache element <[0. 1 gabbar singh , 1. 2 kalia singh , 2. 3 samba singh ]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Attempt to retrieve a cache entry using key <2056181503|2056171012> and cache model <org.springmodules.cache.provider.ehcache.EhCacheCachingModel@1531164[cacheName='contactCache', blocking=false, cacheEntryFactory=null]>
DEBUG [org.springmodules.cache.provider.ehcache.EhCacheFacade] - Retrieved cache element <[0. 1 gabbar singh , 1. 2 kalia singh , 2. 3 samba singh ]>

Here are my DAO classes –

package byteco.de.spring;
import java.util.List;
public interface ContactDAO {
    boolean createContact(String firstName, String lastName, String email);
    List findAll();
}

package byteco.de.spring;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ContactDAOImpl implements ContactDAO {

    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    public void setNamedParameterJdbcTemplate(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
    }

    public boolean createContact(String firstName, String lastName, String email) {
        Map<String,String> map = new HashMap<String, String>();
        map.put("firstname",firstName);
        map.put("lastname",lastName);
        map.put("email",email);
        int i = namedParameterJdbcTemplate.update("insert into contact (firstname,lastname,email) values (:firstname,:lastname,:email)", map);
        return i>0;
    }

    public List findAll() {
        return namedParameterJdbcTemplate.query("select * from contact", (Map<String, ?>) null, new RowMapper() {
            public Object mapRow(ResultSet resultSet, int i) throws SQLException {
                return i + ". " + resultSet.getString(1) + " " + resultSet.getString(2) + " " + resultSet.getString(3) + " ";
            }
        });
    }
}

We are caching the result of findAll and clearing cache when createContact is executed.

Using following MAVEN_OPTS worked for me -

$ export MAVEN_OPTS=”-Xms256m -Xmx512m -agentlib:jdwp=transport=dt_socket,address=7848,server=y,suspend=n”

After setting above executed -

mvn jetty:run

Then configured IDEA Remote Server by connecting to server on above configured port 7848

Below are the built-in Validators -

1. f:validateDoubleRange
2. f:validateLongRange
3. f:validateLength

One should be cautious as when the required attribute is not set and user supplies a blank input, then no validation are performed.

Below is a example of using JSF Validator -

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%>
<html>
<head>
<title>JSF Validations Example Form</title>
</head>
<body>
<f:view>
<h2>JSF Validations Example Form</h2>
<h:form id="helloForm">

<ul>
<li><h:outputText value="Enter your name :" /> <br />
<t:message id="usernameMessage" for="username" style="color:red;" /> <br />
<h:inputText value="#{userBean.name}" id="username" required="true" />
</li>
</ul>
<h:commandButton action="#{userBean.sayHello}" value="Enter" />
</h:form>
</f:view>
</body>
</html>

When user does not supply value for username -

Creating a Custom Validator
JSF also provides support for writing your own custom Validators. Below are the steps which you would need to do in order to write your own custom validator. I am writing a custom validator for verifying a email address using commons-validator.

Step 1:
Implement interface, javax.faces.validator.Validator

package com.test.validator;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;

public class EmailValidator implements Validator {
	public void validate(FacesContext facesContext, UIComponent component, Object object)
			throws ValidatorException {
		org.apache.commons.validator.EmailValidator instance = org.apache.commons.validator.EmailValidator.getInstance();
		if(!instance.isValid(object.toString())){
			FacesMessage facesMessage = new FacesMessage("Invalid email address");
			throw new ValidatorException(facesMessage);
		}
	}
}

Step 2:

Register above validator in faces-config.xml.

<validator>
	<description></description>
	<display-name>EmailValidator</display-name>
	<validator-id>EmailValidator</validator-id>
	<validator-class>com.test.validator.EmailValidator</validator-class>
</validator>

Step 3:

Use above registered validator in your page –

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%>
<html>
<head>
<title>JSF Validations Example Form</title>
</head>
<body style="font:Arial 12px;">
<f:view>
	<h2>JSF Validations Example Form</h2>
	<h:form id="helloForm">

		<ul>
			<li><h:outputText value="Enter email :" /> <br />
			<t:message id="emailMessage" for="email" style="color:red;" /> <br />
			<h:inputText value="#{userBean.email}" id="email" required="true">
				<f:validator validatorId="EmailValidator"></f:validator>
			</h:inputText>
			</li>
		</ul>
		<h:commandButton action="#{userBean.sayHello}" value="Enter" />
	</h:form>
</f:view>
</body>
</html>

Output:

Interdependant Fields Validation using Custom Validator

Though not a perfect example for dependant field validation, I couldn’t come up with any other in short time, we have a check box [are you married?] which when selected then marriage date should be valid.

I have created a custom validator for Date which I am using here -

package com.test.validator;

import javax.faces.component.UIComponent;
import javax.faces.component.UIInput;
import javax.faces.context.FacesContext;
import javax.faces.validator.ValidatorException;

public class MarriedDateValidator extends DateValidator {

	@Override
	public void validate(FacesContext facesContext, UIComponent component,
			Object object) throws ValidatorException {
		UIInput input = (UIInput) component.findComponent("married");
		if(input.isValid()){
			if(input.getValue().toString().equals("true")){
				super.validate(facesContext, component, object);
			}
		}
	}
}

If you notice line where I get access to the input component component.findComponent(“married”); and then uses it for further decisions on validations.

Just for reference – below is the class DateValidator.

package com.test.validator;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;

public class DateValidator implements Validator {

	public void validate(FacesContext facesContext, UIComponent component, Object object)
			throws ValidatorException {
		org.apache.commons.validator.DateValidator instance = org.apache.commons.validator.DateValidator.getInstance();
		if(!instance.isValid(object.toString(), "dd/MM/yyyy", true)){
			FacesMessage facesMessage = new FacesMessage("Invalid date");
			throw new ValidatorException(facesMessage);
		}
	}

}

The next step is to define above in faces-config.xml.

<validator>
	<description></description>
	<display-name>MarriedDateValidator</display-name>
	<validator-id>MarriedDateValidator</validator-id>
	<validator-class>com.test.validator.MarriedDateValidator</validator-class>
</validator>

And then using it in your page -

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%>
<html>
<head>
<title>JSF Validations Example Form</title>
</head>
<body style="font:Arial 12px;">
<f:view>
	<h2>JSF Validations Example Form</h2>
	<h:form id="helloForm">
		<ul>
			<li><h:outputText value="Are you married? :" /> <h:selectBooleanCheckbox value="#{userBean.married}" id="married" /> <br />
			<h:outputText value="Enter marriage date :" /> <br />
			<t:message id="domMessage" for="dom" style="color:red;" /> <br />
			<h:inputText value="#{userBean.dateOfMarriage}" id="dom">
				<f:validator validatorId="MarriedDateValidator"></f:validator>
			</h:inputText>
			</li>
		</ul>
		<h:commandButton action="#{userBean.sayHello}" value="Enter" />
	</h:form>
</f:view>
</body>
</html>

In above notice that there is no required=”true” for the userBean.dateOfMarriage input tag. When the check box is not selected no validations are performed on the field.

Only when the checkbox is selected, validations are performed and you get following message –

Creating Custom Converters

A custom converter is called after custom validations are performed and any errors during conversion step, the errors are displayed in the same input page while all orignal input values are retained.

The good thing about convertors is unlike a validator which is only called when required=”true” is set for the input tag, it gets called even if the input field is having a empty value.

We can use this to handle validations of non mandatory fields where if the user enters the data then it should be valid. For eg. We are having a field “Date Of Joining” which is not a mandatory field, but if user enters a value we want it to be a valid date.

Below are the steps on writing a custom converters -

Step 1:

Implement a interface, javax.faces.convert.Converter.

package com.test.converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.component.UIInput;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.ConverterException;

public class DateConverter implements Converter {

	public Object getAsObject(FacesContext facesContext, UIComponent uiComponent, String val)
			throws ConverterException {
		String pattern = "dd/MM/yyyy";
		boolean required = ((UIInput)uiComponent).isRequired();
		if((val==null || val.trim().isEmpty()) && !required )
			return null;
		org.apache.commons.validator.DateValidator instance = org.apache.commons.validator.DateValidator.getInstance();
		if(!instance.isValid(val.toString(), pattern, true)){
			FacesMessage facesMessage = new FacesMessage("Using Converter - Invalid date");
			throw new ConverterException(facesMessage);
		}
		try {
			return new SimpleDateFormat(pattern).parse(val);
		} catch (ParseException e) {
			FacesMessage facesMessage = new FacesMessage("Using Converter - Invalid date");
			throw new ConverterException(facesMessage);
		}
	}

	public String getAsString(FacesContext facesContext, UIComponent uiComponent, Object val)
			throws ConverterException {
		return val.toString();
	}

}

Please note following -

boolean required = ((UIInput)uiComponent).isRequired(); – Using this we can check if the field was required or not. Based on it we can either ignore the conversion or perform it.

Step 2:

The next step is registering this convertor in faces-config.xml.

	<converter>
		<display-name>DateConverter</display-name>
		<converter-for-class>java.util.Date</converter-for-class>
		<converter-class>com.test.converter.DateConverter</converter-class>
	</converter>

The JSF will call our converter when it finds the type of field in a bean as java.util.Date.

Below is our UserBean.java

package com.test.beans;

import java.util.Date;

import javax.faces.component.UIComponent;
import javax.faces.component.UIInput;
import javax.faces.context.FacesContext;
import javax.faces.validator.ValidatorException;

import com.test.validator.DateValidator;

public class UserBean {

	private Date dateOfJoining;

	public Date getDateOfJoining() {
		return dateOfJoining;
	}

	public void setDateOfJoining(Date dateOfJoining) {
		this.dateOfJoining = dateOfJoining;
	}

	public String sayHello() {
		return "hello";
	}
}

Step 3:

As you have mapped the converter for Date classes you don’t need to specify anything in page –

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%>
<html>
<head>
<title>JSF Validations Example Form</title>
</head>
<body>
<f:view>
	<h2>JSF Validations Example Form</h2>
	<h:form id="helloForm">

		<ul>
			<li><h:outputText value="Enter date of joining :" /> <br />
			<t:message id="dojMessage" for="doj" style="color:red;" /> <br />
			<h:inputText value="#{userBean.dateOfJoining}" converterMessage="Please enter valid date of joining" id="doj" />
			</li>
		</ul>
		<h:commandButton action="#{userBean.sayHello}" value="Enter" />
	</h:form>
</f:view>
</body>
</html>

Notice that the required=”true” is not set and you can specify your own custom message to be shown in case of conversion error by using converterMessage.

Output:

A regular complaint about this task is that it echoes characters to the console, this is a critical security defect, we must fix it immediately, etc, etc. We know it leaves something to be desired, but the problem is Java, not Ant. There is nothing we can do to stop the console echoing.

But as of JDK 1.6, which allows you to read password using console, I have created following ant task which allows you to prompt a message to user and accept a password and it will be set as a ant property.

You can also use the same to accept normal input.

package com.shivprasad.anttask;
import java.io.Console;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;

public class YetAnotherInputTask extends Task {

	private String outputproperty;
	private String message;
	private Boolean password;

	public void setPassword(String password) {
		this.password = Boolean.parseBoolean(password);
	}

	public void setMessage(String message) {
		this.message = message;
	}

	public void setOutputproperty(String outputproperty) {
		this.outputproperty = outputproperty;
	}

	@Override
	public void execute() throws BuildException {
		Console cons = System.console();
		String text=null;
		if (cons != null){
			if(password.booleanValue()){
				char[] passwd = cons.readPassword("[yainput] %s", message);
				text = new String(passwd);
			}else{
				text = cons.readLine("[yainput] %s", message);
			}
			getProject().setProperty(outputproperty, text);
		}
	}
}

You can download above as a jar.

Download ya-ant-input-task.jar

In order to use it in ant, you will have to have the above jar as part of classpath. Then define, ant task -

        <taskdef name="yainput" classname="com.shivprasad.anttask.YetAnotherInputTask">
            <classpath>
                <fileset dir="${dependency.lib}">
                    <include name="ya-ant-input-task.jar"/>
                </fileset>
            </classpath>
        </taskdef>

For actually using it -

    	<yainput outputproperty="db.tns" message="Enter the TNS entry for the database : " password="false" />
    	<yainput outputproperty="db.password" message="Enter the password for the database : " password="true" /> 

The outputproperty is the property which will be available in ant after user enters the text.

Updated: Above code is licensed under : http://ant.apache.org/license.html

	<target name="tomcat.start">
		 <exec executable="${tomcat.home}/bin/startup.bat" spawn="true">
		 	<env key="CATALINA_HOME" value="${tomcat.home}"/>
		 </exec>
		<sleep seconds="10"/>
	</target>

Stopping the tomcat -

I was facing some issues using the tomcat shutdown.bat as tomcat server was not stopping due to one of the application deployed was not getting stopped gracefully. And the next time tomcat tried to start it used to give “JVM_BIND Exception -Port already in use”.

As Windows doesn’t have a native kill command, I have used following which allowed me to kill any java process using ant.

PsKill – Running PsKill with a process ID directs it to kill the process of that ID on the local computer.
jps – The jps command will report the process ID of each JVM running on local computer.

	<target name="tomcat.stop">
	    <exec executable="${env.JAVA_HOME}/bin/jps" output="pid.out.file"/>
		<loadfile srcfile="pid.out.file" property="pid.out">
		  <filterchain>
				<linecontains>
				  <contains value="Bootstrap"/>
				</linecontains>
				<tokenfilter>
					<deletecharacters chars="Bootstrap"/>
					<trim/>
					<ignoreblank/>
				</tokenfilter>
				<striplinebreaks/>
		  </filterchain>
		</loadfile>
		<echo>Killing tomcat instance with PID - "${pid.out}"</echo>
		<exec executable="pskill">
			<arg value="${pid.out}"/>
		</exec>
		<delete file="pid.out.file"/>
	</target>

The above way can be used to kill any java process using the ant.