Maven 3 + Hibernate 4 + Spring 3 +…

Introduction

This is a quick tutorial about integration of second level caching, more specifically ehcache to spring 3 along with hibernate 4.1.

These are the versions of apis and frameworks etc. used;

• Java 1.6
• Spring 3.2.8.RELEASE
• Hibernate 4.2.11.FINAL
• Mysql 5
• JUnit 4.11

Within this tutorial you will see

• Testing with Spring and JUnit, application context loading. (Kind of encouraging test driven development)
• Separated Dao and Service layers
• Second level caching with ehcache
• Spring caching
• Spring 3 + Hibernate 4 + Ehcache integration
• Hibernate statistics
• Many-to-Many on Hibernate

DB Table

No worries, tables will be created automatically! 🙂

CREATE DATABASE `learn`
    CHARACTER SET 'utf8'
    COLLATE 'utf8_general_ci';

USE `learn`;

Project Structure

Dependencies (pom.xml)

<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>info.hevi.learn</groupId>
	<artifactId>spring-hibernate-ehcache</artifactId>
	<version>1.0</version>

	<description>Annotation Based Spring 3 + Hibernate 4 + EHCache + log4j Demo</description>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.build.mainClass>info.hevi.learn.spring3hibernate4ehcache.Main</project.build.mainClass>
		<java.version>1.6</java.version>
		<spring.version>3.2.8.RELEASE</spring.version>
		<hibernate.version>4.2.11.Final</hibernate.version>

	</properties>

	<dependencies>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
		<!--@Transactional -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-ehcache</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<!-- connection pooling with c3p0 -->
        <dependency>
			<groupId>c3p0</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.1.2</version>
		</dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>		

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.27</version>
		</dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>

        </dependency>

	</dependencies>

    <repositories>

        <repository>
            <id>JBoss repository</id>
            <url>http://repository.jboss.org/nexus/content/groups/public/</url>
        </repository>

        <repository>
            <id>java.net-Public</id>
            <url>https://maven.java.net/content/groups/public/</url>
        </repository>

    </repositories>

</project>

Bean & hibernate definitions (applicationContext.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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-3.2.xsd  http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

    <!-- Autowired -->
    <!--  used to activate annotations in beans already registered in the application context (no matter if they were defined with XML or by package scanning) -->
    <context:annotation-config/>
    <!-- scans packages to find and register beans within the application context. -->
    <context:component-scan base-package="info.hevi.learn.spring3hibernate4ehcache"/>

    <!-- enable @Transactional Annotation -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--spring cache-->
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
                <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="task" />
            </set>
        </property>
    </bean>

    <!-- @PersistenceUnit annotation -->
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>

    <!--  classpath*:*.properties-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!-- data source with c3p0 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"
          p:driverClass="${jdbc.driverClassName}"
          p:jdbcUrl="${jdbc.url}"
          p:user="${jdbc.username}"
          p:password="${jdbc.password}"
          p:acquireIncrement="${c3p0.acquire_increment}"
          p:minPoolSize="${c3p0.min_size}"
          p:maxPoolSize="${c3p0.max_size}"
          p:maxIdleTime="${c3p0.max_idle_time}"
          p:unreturnedConnectionTimeout="${c3p0.unreturned_connection_timeout}"/>

    <!-- Hibernate as JPA vendor-->
    <bean id="jpaAdapter"
          class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
          p:database="${jpa.database}" p:showSql="${jpa.showSql}"/>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>

        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <!--<prop key="hibernate.connection.autocommit">${hibernate.connection.autocommit}</prop>-->

                <prop key="hibernate.cache.use_second_level_cache">true</prop>
                <prop key="hibernate.cache.use_query_cache">true</prop>
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
                <prop key="hibernate.show_sql">true</prop>

                <!--useful for debugging-->
                <prop key="hibernate.generate_statistics">true</prop>
            </props>
        </property>
        <property name="packagesToScan" value="info.hevi.learn.spring3hibernate4ehcache"/>
    </bean>

    <bean id="transactionManager"
          class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
</beans>

Ehcache cache definitions (ehcache.xml)

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <diskStore path="cacheIO" />

    <defaultCache maxElementsInMemory="10000" eternal="true"
                  overflowToDisk="false" diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="1800" memoryStoreEvictionPolicy="FIFO">
    </defaultCache>

    <cache name="info.hevi.learn.spring3hibernate4ehcache.domain.Country"
           maxElementsInMemory="300"
           eternal="true"
           overflowToDisk="false"
           timeToIdleSeconds="12000"
           timeToLiveSeconds="12000"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120"
           memoryStoreEvictionPolicy="LRU"  />

    <cache name="countryCache"
           maxElementsInMemory="300"
           eternal="true"
           overflowToDisk="false"
           timeToIdleSeconds="12000"
           timeToLiveSeconds="12000"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120"
           memoryStoreEvictionPolicy="LRU"  />

    <cache name="countryByNameCache"
           maxElementsInMemory="300"
           eternal="true"
           overflowToDisk="false"
           timeToIdleSeconds="12000"
           timeToLiveSeconds="12000"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120"
           memoryStoreEvictionPolicy="LRU"  />

</ehcache>

Class Diagram of Services

Test file (MainTest.java)

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"/applicationContext.xml"})
public class MainTest {

    @Autowired
    ILanguageService languageService;

    @Autowired
    ICountryService countryService;

    @After
    public void cleanup() {
        Logger rootLogger = Logger.getRootLogger();
        rootLogger.setLevel(Level.ERROR);

        countryService.deleteAll();
        languageService.deleteAll();
    }

    @Before
    public void setup() {
        Logger rootLogger = Logger.getRootLogger();
        Level level = rootLogger.getLevel();
        rootLogger.setLevel(Level.ERROR);

        Language english = new Language("english");
        Language french = new Language("french");
        Language german = new Language("german");
        Language spanish = new Language("spanish");
        Language turkish = new Language("turkish");
        Language finnish = new Language("finnish");

        languageService.save(english);
        languageService.save(french);
        languageService.save(german);
        languageService.save(spanish);
        languageService.save(turkish);
        languageService.save(finnish);

        Country uk = new Country("uk");
        Country us = new Country("us");
        Country tr = new Country("tr");
        Country es = new Country("es");
        Country sw = new Country("sw");
        Country fn = new Country("fn");
        Country gr = new Country("gr");

        countryService.save(uk);
        countryService.save(us);
        countryService.save(tr);
        countryService.save(es);
        countryService.save(fn);
        countryService.save(sw);
        countryService.save(gr);

        Country country = countryService.getByName("gr");

        // adding some languages to Greece
        country.getLanguages().add(english);
        country.getLanguages().add(finnish);
        country.getLanguages().add(french);
        country.getLanguages().add(turkish);
        countryService.save(country);
        rootLogger.setLevel(level);
    }

    @Test
    public void testCache() {
        countryService.getAll();
        countryService.getByName("gr");
        countryService.getAll();
    }
}

Download Source Code

Google Interview Question: Chain of strings

There is a list of strings and they ask if it is possible create a chain of string using all the strings in the given list.
A chain can be formed b/w strings if last char of the 1st string matches with 1st char of second string. (this question is taken from careercup)
To give an example;
let’s say the given list is {aaszx, prtws, stuia} in this case the only posible chain is prtws–stuia–aaszx

At first sight the problem looks to be pretty easy, just put the first and last characters on two seperate hasmaps ;

 
List<String> stringList = ...
stringList.add ...
Map<Character, Integer> firstCharacterCountMap = ...;
for each string : str in the list
    increment firstCharacterCountMap(first character of str)
    decrement lastCharacterCountMap(last character of str)

in the pseudo code above the idea is finding the number of characters at start position and number of end characters at the end. after check if there final sum of the results is 0. A reasonable solution yet doesn’t provide the chain to be constructed.
the difficulty is that there might be some dead-ends. let say the list is {ab, bd, cb, bc} if we start with ab; ab->bd->? there is no solution even though there is one. (Btw the solution is; ab->bc->cb->bd). At this point one solution may come to mind is starting from a string whose first character doesn’t correspond to and end. Unfortunately this idea is not as good as it seems since there might all the first characters have a correspondence.

My solution is in O(n^2) 🙁 yet it works. Anyway topological sorting also has n^2 complexity.

I first create two separate hashmaps for both start and end characters. then I put the strings to these maps with corresponding characters. next I check for all possible combinations recursively;

You also can run the code from ideone

import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * User: uerturk
 * Date: 08/10/13
 * Time: 17:04
 * To change this template use File | Settings | File Templates.
 */
class HasChain {

    Map<Character, List<String>> startsWithStringMap = new HashMap<Character, List<String>>();
    Map<Character, List<String>> endsWithStringMap = new HashMap<Character, List<String>>();

    private Character getFirstChar(String str) {
        return str.charAt(0);
    }

    private Character getLastChar(String str) {
        return str.charAt(str.length() - 1);
    }

    boolean hasChain(List<String> stringList) {
        // create relations between strings and their first 
        // and last characters using two hasmaps.  
        for (String str : stringList) {
            Character start = getFirstChar(str);
            Character end = getLastChar(str);
            List<String> startsWithList;
            List<String> endsWithList;

            if (startsWithStringMap.containsKey(start)) {
                startsWithList = startsWithStringMap.get(start);
            } else {
                startsWithList = new ArrayList<String>();
                startsWithStringMap.put(start, startsWithList);
            }

            if (endsWithStringMap.containsKey(end)) {
                endsWithList = endsWithStringMap.get(end);
            } else {
                endsWithList = new ArrayList<String>();
                endsWithStringMap.put(end, endsWithList);
            }
            startsWithList.add(str);
            endsWithList.add(str);
        }

        // this stack is the solution stack
        Stack<String> stringStack = new Stack<String>();
        for (String str : stringList) {
            if (hasChain(stringList.size(), str, stringStack)) {
                System.out.println(stringStack);

                return true;
            }
        }

        return false;
    }

    // recursively iterates through all possibilities
    private boolean hasChain(int size, String startString, Stack<String> stringStack) {
        if (size == stringStack.size()) return true; // if the stack is full of strings, we found it!
        Character last = getLastChar(startString);
        if (startsWithStringMap.containsKey(last)) {
            List<String> stringList = startsWithStringMap.get(last);
            for (int i = 0; i < stringList.size(); i++) {
                String candidate = stringList.remove(i--); // remove the candidate as it shouldn't be used in the next iterations
                stringStack.push(candidate); // as if it is the solution
                if (hasChain(size, candidate, stringStack)) {
                    return true; // no need to continue
                }
                stringStack.pop(); // candidate is not the solution
                stringList.add(++i, candidate); // put it back to the list, where it belongs
            }
        }

        return false;
    }

    public static void main(String[] args) {
        List<String> stringList = new ArrayList<String>();
        stringList.add("bd");
        stringList.add("fk");
        stringList.add("ab");
        stringList.add("kl");
        stringList.add("cf");
        stringList.add("ff");
        stringList.add("fa");
        stringList.add("ak");
        stringList.add("ka");
        stringList.add("lf");
        stringList.add("bc");

        System.out.println(new HasChain().hasChain(stringList)); // should return true as there is a solution

        stringList.remove("ka"); // we break the chain here

        System.out.println(new HasChain().hasChain(stringList));  // should return false as there is no solution after removing 'ka'

    }
}

hope that helped to someone 🙂

Google Interview Question: Find a Pair Set Where Sum…

Here is another google interview question (taken from here)

They give you a list of numbers such as {4, 1, 5, 2, 3, -1, 6,} and a threshold lets say 4
and ask for distinct pair sets from the list, where sum of the numbers in each pair less or equal to the threshold.
in this case answer should be;(4, -1), (1, -1), (1, 1), (1, 2), (1, 3), (5, -1), (2, -1), (2, 1), (2, 2), (3, -1), (3, 1), (-1, -1), (-1, 1), (-1, 2), (-1, 3), (-1, 4), (-1, 5)

well my solution is not O(n) as I use a sorted set. First put all the numbers and then get the range up to the difference between a number and the threshold.
In the worst case my solution is O(n^2) and on average O(n.logn)

You can run it from here
here is the code:

/**
 * User: uerturk
 */

import java.util.*;

/**
 * Input - array of integers size N, integer Threshold.
 * Output - the pairs (x, y) of distinct elements with condition x + y <= Threshold.
 * Is that possible to implement is with O(n) ?
 */
class FindPairsUnderThreshold {


    public List<Map.Entry<Integer, Set<Integer>>> solve(Integer[] integers, Integer threshold) {

        // the complexity > O(n), sorted list is the key in this solution
        SortedSet<Integer> sortedSet = new TreeSet<Integer>();

        // first put values into the sorted set
        for (Integer number : integers) {
            sortedSet.add(number);
        }

        // then get the range from the head (smallest value) to the maximum value that satisfies the condition
        List<Map.Entry<Integer, Set<Integer>>> result = new ArrayList<Map.Entry<Integer, Set<Integer>>>();
        for (Integer number : integers) {
            // headSet is not inclusive, +1 is to make it include the exact sum
            int diff = threshold - number + 1;
            Set<Integer> integerIntegerSortedMap = sortedSet.headSet(diff);

            Map.Entry<Integer, Set<Integer>> integerSetPair = new AbstractMap.SimpleEntry<Integer, Set<Integer>>(number, integerIntegerSortedMap);
            result.add(integerSetPair);
        }
        return result;
    }


    public static void main(String[] args) {
        Integer[] integers = {4, 1, 5, 2, 3, -1, 6,};
        Integer threshold = 4;
        List<Map.Entry<Integer, Set<Integer>>> solution = new FindPairsUnderThreshold().solve(integers, threshold);
        for (Map.Entry<Integer, Set<Integer>> entry : solution) {
            Integer first = entry.getKey();
            for (Integer second : entry.getValue()) {
                System.out.print("(" + first + ", " + second + "), ");
            }
        }
        System.out.println(solution);
    }

}

Google Interview Question: Find the Longest Sequence in an…

Google interview questions are popular since a while and it’s become a fashion to ask difficult to answer questions during interviews.
Here is one question :
Given an int array which might contain duplicates, find the largest subset of it which form a sequence.
Eg. {1,6,10,4,7,9,5}
then answer is 4,5,6,7
Sorting is an obvious solution. Can this be done in O(n) time?

here is my solution. Buy I can’t understand the reason for asking such questions to be solved in a very short time. I wonder who could really solve this problem in 5 minutes time and if someone can does it really mean that s/he is a good programmer?

Run the code below from here
 

import java.util.HashMap;
import java.util.Map;

/**
 * User: uerturk
 */

/**
 * Given an int array which might contain duplicates, find the largest
 * subset of it which form a sequence.
 * Eg. {1,6,10,4,7,9,5}
 * then answer is 4,5,6,7
 * Sorting is an obvious solution. Can this be done in O(n) time
 */
class FindTheLongestSequence {
    private int follow(int startNumber, Map<Integer, Pair<Boolean, Integer>> pairMap) {
        Pair<Boolean, Integer> currentPair = pairMap.get(startNumber);
        if (currentPair == null) {
            return 0;
        } else {
            if (currentPair.getFirst()) {
                return currentPair.getSecond();
            } else {
                int result = follow(startNumber + 1, pairMap) + 1;
                currentPair.setFirst(true);
                currentPair.setSecond(result);
                return result;
            }
        }
    }

    public void longestSequence() {
        int[] ints = {1, 6, 10, 4, 7, 9, 5};
        // in the map first is the number, in the pair first isVisited flag, second is the score
        Map<Integer, Pair<Boolean, Integer>> pairMap = new HashMap<Integer, Pair<Boolean, Integer>>();
        for (Integer i : ints) {
            pairMap.put(i, new Pair<Boolean, Integer>(false, 1));
        }

        int[] results = new int[ints.length];
        for (int i = 0; i < ints.length; i++) {
            int result = follow(ints[i], pairMap);
            results[i] = result;
            System.out.println(ints[i] + ":" + result);
        }

    }

    class Pair<First, Second> {
        First first;
        Second second;

        public Pair(First first, Second second) {
            this.first = first;
            this.second = second;
        }

        public void setFirst(First first) {
            this.first = first;
        }

        public void setSecond(Second second) {
            this.second = second;
        }

        public First getFirst() {
            return first;
        }

        public Second getSecond() {
            return second;
        }

        public void set(First first, Second second) {
            setFirst(first);
            setSecond(second);
        }
    }

    public static void main(String[] args) {
        new FindTheLongestSequence().longestSequence();
    }
}