Pushing to both Github and Bitbucket is easy.

Here is a project cloned from Github. If you check out the remote repository info, it has only Github repo info.

$ git remote -v show 
origin  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (fetch)
origin  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (push)

The YOUR_PROJECT/.git/config file, of course, has only Github info.

[remote "origin"]
  fetch = +refs/heads/*:refs/remotes/origin/*
  url = git@github.com:YOUR_USERNAME/YOUR_PROJECT.git

To add a remote git repository on Bitbucket, use git remote set-url.

$ git remote set-url origin --add ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git

Now, it has Bitbucket info too.

$ git remote -v show 
origin  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (fetch)
origin  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (push)
origin  ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git (push)

YOUR_PROJECT/.git/config

[remote "origin"]
  fetch = +refs/heads/*:refs/remotes/origin/*
  url = git@github.com:YOUR_USERNAME/YOUR_PROJECT.git
  url = ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git

Now, run git push -u origin master to set upstream.

$ git push -u origin master

It’s enough for pushing to both Github and Bitbucket. So once it’s done, you can just do

$ git push

Whenever you want to push to both.

e.g.)
Make some changes, Commit and Push

# Add all changes
$ git add -A

# Commit changes
$ git commit -m "added: .gitignore"
[master 0e649a6] added: .gitignore
 1 file changed, 1 insertion(+)
 create mode 100644 .gitignore

# Push to Github and Bitbucket
$ git push
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 286 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To git@github.com:YOUR_USERNAME/YOUR_PROJECT.git
   a24a46c..0e649a6  master -> master
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 286 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
remote: bb/acl: YOUR_USERNAME is allowed. accepted payload.
To ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git
   a24a46c..0e649a6  master -> master

If what you need is only to push to Github and Bitbucket then you don’t need to read this post any further. However, if you also want to pull data from both Github and Bitbucket, it requires a little more extra steps.

Before I show the steps, I need to point out another case that you might want to know. With what I’ve done here, it fetches the data only from Github when running the git pull command. If what you want is only changing it to make it pull from Bitbucket, it’s simple. You just need to swap the positions of origin urls in the YOUR_PROJECT/.git/config file.

So change from this

[remote "origin"]
  fetch = +refs/heads/*:refs/remotes/origin/*
  url = git@github.com:YOUR_USERNAME/YOUR_PROJECT.git
  url = ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git

to

[remote "origin"]
  fetch = +refs/heads/*:refs/remotes/origin/*
  url = ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git
  url = git@github.com:YOUR_USERNAME/YOUR_PROJECT.git

Now it pulls from Bitbucket instead of Github.

To pull from both Github and Bitbucket, first add the remote repository information using git remote.

$ git remote add github git@github.com:YOUR_USERNAME/YOUR_PROJECT.git 
$ git remote add bitbucket git@bitbucket.org:YOUR_USERNAME/your_project.git

You can add both Github and Bitbucket or just the one that is not pulled when running git pull. It’s all up to you.
Now, the YOUR_PROJECT/.git/config file contains the information of the new remote repositories just added.

$ git remote -v show 
bitbucket git@bitbucket.org:YOUR_USERNAME/your_project.git (fetch)
bitbucket git@bitbucket.org:YOUR_USERNAME/your_project.git (push)
github  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (fetch)
github  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (push)
origin  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (fetch)
origin  git@github.com:YOUR_USERNAME/YOUR_PROJECT.git (push)
origin  ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git (push)

YOUR_PROJECT/.git/config now has “github” and “bitbucket” as well as “origin”.

[remote "origin"]
  fetch = +refs/heads/*:refs/remotes/origin/*
  url = git@github.com:YOUR_USERNAME/YOUR_PROJECT.git
  url = ssh://git@bitbucket.org/YOUR_USERNAME/your_project.git

[remote "github"]
  url = git@github.com:YOUR_USERNAME/YOUR_PROJECT.git
  fetch = +refs/heads/*:refs/remotes/github/*
[remote "bitbucket"]
  url = git@bitbucket.org:YOUR_USERNAME/your_project.git
  fetch = +refs/heads/*:refs/remotes/bitbucket/*

If you run git pull, it still pulls from only Github so you need to also run git pull bitbucket master.

* pull from Github

$ git pull

or

$ git pull github master

* pull from Bitbucket

$ git pull bitbucket master

If you want to pull it from all the remote repositories, you can use a function in shell script.

Add the following function to .bash_aliases or .bashrc or .profile depending on your OS (sorry Windows users).

gitpullall()
{
  repos_to_ignore="origin github"
  should_ignore=-1

  echo "running: git pull"
  git pull
  echo ""

  for remote in `git remote`
    do

    for ignore in $repos_to_ignore
      do
        [ "$remote" == "$ignore" ] && should_ignore=1 || :
    done

    if [ "$should_ignore" == "-1" ]
      then
      echo "running: git pull $remote master"
      git pull $remote master
      echo ""
    fi
  done
}

Then you can simply run gitpullall to pull from all the remote repositories specified in the YOUR_PROJECT/.git/config file.

To ignore repositories when pulling, add the remote repository names to the repos_to_ignore variable in the gitpullall function above.

$ gitpullall 

running: git pull
Already up-to-date.

running: git pull bitbucket master
From bitbucket.org:YOUR_USERNAME/your_project
 * branch            master     -> FETCH_HEAD
Already up-to-date.

Before I start to talk about usefulness of it, let’s start with problems that can happen if you don’t use generics when using generified types.
If your code looks like this, you’re making your code error-prone.

List list = new ArrayList();

As it discards all the generic type information in the class. To see what exactly happens, better take a look at some example.

If you have type like

public class SomeType<T>
{
  public <E> void test(final Collection<E> collection)
  {
    for (final E object : collection)
    {
      System.out.println("E: " + object);
    }
  }

  public void test(final Set<T> set)
  {
    for (final T t : set)
    {
      System.out.println("T from set: " + t);
    }
  }

  public void test(final List<Integer> integerList)
  {
    int result = 0;
    for (final Integer integer : integerList)
    {
      result += integer.intValue();
    }
    System.out.println("result: " + result);
  }
}

and execute code like

final SomeType someType = new SomeType();
final List<String> list = Arrays.asList("some", "test", "value");
someType.test(list);

Then you will get ClassCastException saying “java.lang.String cannot be cast to java.lang.Integer” in runtime but no errors in compile-time. Why? because it uses public void test(final List<Integer> integerList) method instead of public <E> void test(final Collection<E> collection). But why does it use the one taking List of Integer instead of the one with the Collection of some type E when the passed parameter is a List of String which is a Collection of some type E, in this case, String? The reason is that SomeType is generified but when using it, no generics are used. If generified type is used without generic type info specified, the Java compiler makes it like the old type in JDK prior to 5.0 which doesn’t have generics.

Thus, the methods above all become like

  public void test(final Collection collection)

  public void test(final Set set)

  public void test(final List integerList)

So the closest type matched with a List of String is a List and that’s why public void test(final List<Integer> integerList) is called. But the method, public <E> void test(final Collection<E> collection), has nothing to do with the generic type specified in the class SomeType<T>. It’s just a generic method and the E has nothing to do with the T. Yeah, but if the type is generified, yet no generic type is specified when it is used, all the generics info including the ones in the generic methods is gone.

To solve the problem, you just need to specify the generic type. In the case above, you can even use just ‘?‘ (wildcard) since you’re not using the generic type specified in the class but the generic method, public <E> void test(final Collection<E> collection).

final SomeType<?> someType = new SomeType<Object>();
final List<String> list = Arrays.asList("some", "test", "value");
someType.test(list);

Now, with generics, you don’t have the problem you had before without generics.

So, it’s clear why you should use generics when using generified types. What I just explained is actually not new but well known to most Java programmers. Now, let’s talk about some benefits from using generics.

You can avoid a problem that you have with arrays if you use generics. Arrays of reference types in Java are covariant so you may have a problem like this.

  final Integer[] integerArray = { 1, 2, 3, 4, 5 };
  final Object[] objectArray = integerArray;
  objectArray[0] = "test";

There is no compile-time error, yet running this code results in java.lang.ArrayStoreException: java.lang.String when objectArray[0] = "test"; is executed.

Unlike arrays, generics are invariant, so if you use generics like,

  final List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
  final List<Object> objectList = integerList;

You get a compile-time error.

  final List<Object> objectList = (List<Integer>) integerList; // compile-time error

Even this one causes the compile-time error too since a List of Integer is not a subtype of List of Object (In arrays, an Integer array is a subtype of Object array).

On the other hand, you may need to cast it although it happens very occasionally. Here is an example taken from one of my libraries.
In KommonLee ASM, there is a visitor class, MethodAnalysisClassVisitor.

public class MethodAnalysisClassVisitor<T, M extends Member> extends EmptyVisitor
{
  private final MemberCollector<M> memberCollector;
  private final Class<T> theClass;
  private final Map<M, String[]> memberToParameterNamesMap;

  public MethodAnalysisClassVisitor(final MemberCollector<M> memberCollector, final Class<T> theClass,
      final Map<M, String[]> memberToParameterNamesMap)
  {
    this.memberCollector = memberCollector;
    this.theClass = theClass;
    this.memberToParameterNamesMap = memberToParameterNamesMap;
  }
  // Remainder omitted...
}

This visitor collects all the methods / constructors and their parameter names. Why do I need this kind of tool? It’s because I needed to get the parameter names of constructors in a class for one of my libraries, JSON Statham, but there was no easy way to get the parameter names of methods or constructors in Java. Reflection in Java certainly doesn’t have this convenience which is, I believe, an integral part for library / framework development although it would be depending on what sort of library it is. So I had to use ASM to get the method parameter names. I was shocked when I first discovered it. Anyway, back to the original topic again, the visitor is used by AsmMethodAndConstructorAnalyser.

public class AsmMethodAndConstructorAnalyser implements MethodAndConstructorAnalyser
{
  // ...

  @Override
  public <T> Map<Constructor<T>, String[]> findConstructorsWithParameterNames(final Class<T> theClass)
      throws IllegalArgumentException
  {
    final Map<Constructor<T>, String[]> constructorToParameterNamesMap = new LinkedHashMap<Constructor<T>, String[]>();

    @SuppressWarnings({ "cast", "unchecked", "rawtypes" })
    final Map<Constructor<?>, String[]> map = (Map<Constructor<?>, String[]>) ((Map) constructorToParameterNamesMap);

    getClassReader(theClass).accept(
        new MethodAnalysisClassVisitor<T, Constructor<?>>(constructorCollector, theClass, map), 0);
    return constructorToParameterNamesMap;
  }
  // ...
}

I know that the type M defined in the MethodAnalysisClassVisitor is Constructor<T> in this particular method as I’m passing Class<T> and want to collect all the constructors in it which are all Constructor<T>, yet the Java compiler can’t figure it out so I get a compile-time error if I just do

    final Map<Constructor<T>, String[]> constructorToParameterNamesMap = new LinkedHashMap<Constructor<T>, String[]>();

    getClassReader(theClass).accept(
        new MethodAnalysisClassVisitor<T, Constructor<?>>(constructorCollector, theClass, constructorToParameterNamesMap), 0);

Therefore, what I did was:
first, cast Map<Constructor<T>, String[]> constructorToParameterNamesMap to a raw type Map then it will lose all the generic type info.
second, I can cast it to Map of any key value pair since the Java compiler erases all the generic types when it’s compiled.
finally, I ended up having the following lines of code. I had to add @SuppressWarnings({ "cast", "unchecked", "rawtypes" }) to make the compiler happy. I could do it because I know the constructors stored in the Map are all Constructors of T type.

  @SuppressWarnings({ "cast", "unchecked", "rawtypes" })
  final Map<Constructor<?>, String[]> map = (Map<Constructor<?>, String[]>) ((Map) constructorToParameterNamesMap);

  getClassReader(theClass).accept(
      new MethodAnalysisClassVisitor<T, Constructor<?>>(constructorCollector, theClass, map), 0);

This doesn’t happen often though. So most of the time, you don’t need to do it and can enjoy type safety that generics offer.

Along with the benefit I mentioned above with the case compared with arrays, generics offer convenience of postponing specifying the type information until it is used with compile-time type safety. One example that everyone knows is Java’s collections framework. The programmer of collections didn’t know what types would be stored in the collections when it was created, thus when it came out, it stored just an object type as there were no generics. This is the part where Java loses static typing although it’s a static type language. However, after introduction of generics, the users of collections can have compile-time type safety. Ironically, the collections are one of the most popular examples of how generics can be useful, yet according to Neal Gafter, it’s one of the most important reasons why generics are implemented using type erasure and wild-card, which make generics more complex. If you’re interested in it, you’d better watch his presentation.

Generics give us compile-time type safety but it’s compile-time only because, as I just mentioned, it does type erasure which means the compiler removes all the generic type information when it compiles, and that’s why we can’t create a generic type object or array like.

T t = new T();
T[] t = new T[10];

This is impossible in Java and that’s why you don’t see method like E[] toArray() but Object[] toArray() and <T> T[] toArray(T[] a) in the Collection class and its sub classes. You can create an array of E type if an instance of array of E is given as a parameter value. For example,

public <E> E[] copyArray(final E[] array)
{
  @SuppressWarnings("unchecked")
  final E[] copiedArray = (E[]) Array
                          .newInstance(array
                                        .getClass()
                                        .getComponentType(),
                                      array.length);
  System.arraycopy(array, 0, copiedArray, 0, array.length);
  return copiedArray;
}

It takes an array of E object then creates a new array object of E then copies all the elements in the given one to the new one then returns it.

How is it possible? It’s possible because now I’m dealing with an ‘array object’ of E type not the generic type E directly so I can get the class of the array object in order to take the component type of the element stored in the array. So first, get the class of E[] ‘object’ (not class) which is a parameter value and given in runtime, then I can get the component type of it. However, the following case is impossible.

public <E, NE, F extends Function1<E, NE>> NE[] apply(final F function, final E[] source)
{
  final List<NE> list = new ArrayList<NE>();
  for (final E element : source)
  {
    list.add(function.apply(element));
  }
  @SuppressWarnings("unchecked")
  final NE[] resultArray = list.toArray(
      (NE[]) Array
          .newInstance(NE[].class // <- compile time error here: Illegal class literal for the type parameter NE!!!
                      .getComponentType(),
                       list.size()));
  return resultArray;
}

Because there is no such thing as an NE[] ‘class’ (not object), there is no way to get the class. When it’s compiled, NE[] becomes an Object array (Object[]).

I used to hate this type erasure as I had some issues when I developed my libraries. However, I do not anymore. It’s not just because of the reason mentioned here. I have mine and will explain it later in this post.

So let me talk about why we use generics again. We use it to have compile-time type safety without having to decide the type when designing the API. One example can be found in my old post about Easier and Better Way to Use JDBC. Simply, it makes use of callback function object much more useful.

Let’s say you want to map a type stored in a List to some other type. If you don’t use generics, you probably need to make a method for each mapped type like

public List<BigDecimal> takePricesOf(List<Product> list)
{
  List<BigDecimal> newList = new ArrayList<BigDecimal>();
  for (Product product : list)
  {
    newList.add(product.getPrice());
  }
  return newList;
}

public List<DiscountedProduct> toDiscountedProducts(int discountRate, List<Product> list)
{
  List<DiscountedProduct> newList = new ArrayList<DiscountedProduct>();
  for (Product product : list)
  {
    newList.add(new DiscountedProduct(product, discountRate));
  }
  return newList;
}

// and more...

(OK, here are actually generics used but it’s only for using List).

It can become one reusable method with some callback function object like.

public interface Mapper
{
  Object map(Object input);
}

public List<Object> mapWithoutGenerics(Mapper mapperWithoutGenerics, List<?> list) // <- this cannot be List<Object> since you want to pass a List of any type not just List<Object>.
{
  List<Object> newList = new ArrayList<Object>();
  for (Object object : list)
  {
    newList.add(mapperWithoutGenerics.map(object));
  }
  return newList;
}

When you use it.

List<Object> productPriceList = mapWithoutGenerics(new Mapper() {
  public Object map(Object input)
  {
    Product product = (Product) input;
    return product.getPrice();
  }
}, productList);

Now, you don’t have compile-time type safety anymore so you may pass a List of any type.
So the following code doesn’t cause any compile-time error but the runtime exception that is java.lang.ClassCastException.

List<Object> productPriceList = mapWithoutGenerics(new Mapper() {
  public Object map(Object input)
  {
    Product product = (Product) input;
    return product.getPrice();
  }
}, Arrays.asList("Some", "String", "List"));

It can surely become much better with generics.

public interface Function1<T, R>
{
  R apply(T input);
}

public <T, R, F extends Function1<T, R>> List<R> map(F mapper, List<T> list)
{
  final List<R> newList = new ArrayList<R>();
  for (final T t : list)
  {
    newList.add(mapper.apply(t));
  }
  return newList;
}

Then when you use it.

final List<BigDecimal> productPriceList = map(new Function1<Product, BigDecimal>() {
  @Override
  public BigDecimal apply(final Product product)
  {
    return product.getPrice();
  }
}, productList);

Or the function object can be reused.

private static final Function1<Product, BigDecimal> PRODUCT_TO_PRICE_MAPPER = new Function1<Product, BigDecimal>() {
  @Override
  public BigDecimal apply(final Product product)
  {
    return product.getPrice();
  }
};

//...

final List<BigDecimal> productPriceList        = map(PRODUCT_TO_PRICE_MAPPER, productList);
final List<BigDecimal> anotherProductPriceList = map(PRODUCT_TO_PRICE_MAPPER, anotherProductList);

The other method that is toDiscountedProducts() can be done with this generic map method and closure.

final int discountRate = 15;

final List<DiscountedProduct> discountedProductList = map(new Function1<Product, DiscountedProduct>() {
  @Override
  public DiscountedProduct apply(final Product product)
  {
    return new DiscountedProduct(product, discountRate);
  }
}, productList);

Speaking of generics used for collections, I should point out that it would have been much more useful, if the collections had got methods like select (or filter), map, etc.

So if you had got a List of Integer and wanted to get all the positive ones, you would have done like.

List<Integer> positiveIntegerList = integerList.select(new Condition1<Integer>() {
  public boolean isMet(Integer integer)
  {
    return 0 < integer.intValue();
  }
});

Or getting all the prices from the List of Product object as I already showed. Unfortunately Java’s Collections don’t have those methods. Well, my collection library has it, but it’s incomplete and not so compatible with existing code using Java’s collections although it has a way to convert from and to Java ones. So to keep using Java’s collections, I made some helper methods to achieve the goal which is having one generic method to apply different kinds of functions to all the elements in the collections. By the way, why do I bother about it? Can’t I just use for or foreach loop? Sure, I can. So why? With the generic methods mentioned above and function objects, I can focus on the actual problems. For instance, to get all the prices from the list of Product, my concern should be getting the price of each Product not how to use for or foreach loop.

Here, I need to worry about using foreach and creating ArrayList.

List<BigDecimal> productPriceList = new ArrayList<BigDecimal>();
for (Product product : productList)
{
  productPriceList.add(product.getPrice());
}

With the generic one (if there were one), I wouldn’t.

List<BigDecimal> productPriceList = productList.map(new Function1<Product, BigDecimal>() {
  public BigDecimal apply(Product product)
  {
    return product.getPrice(); // <- here I'm focusing on getting the price.
  }
});

Since Java doesn’t support first-class function, the syntax is not so pleasant. However, JDK 8 will have lambda expression to support it so when it comes out, it can probably be like.

List<BigDecimal> productPriceList = productList.map((product) -> product.getPrice());
// It hasn't been finalised yet so the syntax can be different.

Anyway, Java collections still don’t have those methods so, as I said already, I made the ones for the collections. So let me talk about one of these that is Selector. What Selector does is checking all the elements in a collection and takes only the ones that meet the given Condition. I wanted to have only one Selector that can easily deal with all the classes extends Collection instead of having one for each (e.g. ListToArrayListSelector, ListToHashSetSetSelector, SetToListSelector, and so on). Thus I made it like this.

public class IterableToCollectionSelector<E, T extends Iterable<? extends E>, C extends Condition1<? super E>, R extends Collection<E>>
    implements Selector1<T, C, R>
{
  @Override
  public R select(final C condition, final T source)
  {
    final R result = // <- How can I get the Collection instance of R?
    for (final E element : source)
    {
      if (condition.isMet(element))
      {
        result.add(element);
      }
    }
    return result;
  }
}

Here are Condition1 and Selector1 in my library.

public interface Condition1<T>
{
  boolean isMet(T input);
}

public interface Selector1<T, C, R>
{
  R select(C condition, T source);
}

Let me explain it step by step. First,

public class IterableToCollectionSelector<E, T extends Iterable<? extends E>, C extends Condition1<? super E>, R extends Collection<E>>
    implements Selector1<T, C, R>

E

E is a type of an element stored in the given collection.

T

T is any type extends Iterable of the type extends E.

1. Why is it Iterable of any type extends E (? extneds E)? Otherwise, you can’t use a List of any sub type of E.
   It would be easier to understand with an example. Let’s say you need to get a List of Product the price of which is greater than 50 dollars. If it’s just Iterable<E> then you have no problem with passing a List of Product yet you do have when you try to pass a List of DiscountedProduct which is a sub class of Product and it should be perfectly valid to pass it as a parameter of the selector made for Product (Think about Liskov substitution principle).
   If you have Iterable<? extends E>, you can pass E type and any sub-types of E, in this case, Product and DiscountedProduct are all fine.

2. Then why T extends Iterable? Can I just have Iterable for the input type then I can remove the generic type T? Yes, it’s OK, but what if there is anyone who wants to extends this class and wants to restrict the input type to only List instead of any sub-type of Iterable (probably if you care about Open/closed principle)?
   If you have a class like this.

   // Notice that T extends Iterable<? extends E> is gone, and it has Iterable<? extends E> instead (No T).
   public class IterableToCollectionSelector<E, C extends Condition1<? super E>, R extends Collection<E>> implements
     Selector1<Iterable<? extends E>, C, R>
   {
   }
   

   You can’t restrict the input type to something other than Iterable<? extends E>, and if you try to override the select method in the sub-class of it.
   e.g.)

   public class IterableToArrayListSelector<E> extends
     IterableToCollectionSelector<E, Condition1<? super E>, ArrayList<E>>
   {
     @Override
     public ArrayList<E> select(final Condition1<? super E> condition, final List<? extends E> source)
     {
       return super.select(condition, source);
     }
   }
   

   You will get a compile-time error because T is not the same as “? extends T“. In this case, “Iterable<? extends E>” specified as a generic type T for the Selector1<T, C, R> is not the same as “? extends T” that is, in here, List<? extends E> (one of “T extends Iterable<? extends E>“) in the overridden method select() (It’s not actually overridden as List<? extends E> can’t be a substitute for Iterable<? extends E> here). Still not sure why List can’t be used? Well, think about this. List<String> is not the same as and can’t be a substitute for List<Object>. You know it, and I already explained it earlier when I talked about the side-effect of using arrays. Then think about this one. Can List<List<?>> be a substitute for List<Iterable<?>>? No, it’s just like List<String> and List<Object>, and the problem we have here is the same.

   So

   public class IterableToCollectionSelector<E, T extends Iterable<? extends E>, C extends Condition1<? super E>, R extends Collection<E>>
     implements Selector1<T, C, R>
   

   gives me freedom to restrict the input iterable to whatever extends Iterable I want.
   e.g.)

   public class IterableToArrayListSelector<E> extends
       IterableToCollectionSelector<E, List<? extends E>, Condition1<? super E>, ArrayList<E>>
   

   There will be a compile-time error when passing a Set instead of a List for the input value of the select() method.

C extends Condition1<? super E>

Next one is C extends Condition1<? super E>. What? Why is the input type of the Condition1 “? super E“? Because, with “? super E“, I can have one Condition1 object for many sub-types of the type E. Imagine that you want to get a List of Product the price of which is greater than 20, you can have a Condition1 for Product, then if you also need to get a List of DiscountedProduct the price of which is also greater than 20, you can reuse that Condition1 object for it as DiscountedProduct is a sub-type of Product which means Condition1<Product> is a kind of Condition1<? super DiscountedProduct>. If I have “C extends Condition1<E>” then I can’t do that, but because it’s “C extends Condition1<? super E>“, I can.

R

The last one is R. R extends Collection<E> so it can be any sub-type of Collection.

Now let’s look at the method. Here I have some problem.

  public R select(final C condition, final T source)
  {
    final R result = // <- How can I get the Collection instance of R???
    for (final E element : source)
    {
      if (condition.isMet(element))
      {
        result.add(element);
      }
    }
    return result;
  }

If it’s one type of Collection, I can easily create it but it’s not determined yet. It will be set when it’s used. Then why don’t I postpone instantiation of it until it’s used. More precisely when the selector is instantiated. So I just create another type to create one of Collection also using generics.

public interface CollectionCreator<E, T extends Collection<? extends E>>
{
  T createCollection();
}

So it can be used to create any sub-types of Collection.
e.g.) for ArrayList

public class ArrayListCreator<E> implements CollectionCreator<E, ArrayList<E>>
{
  @Override
  public ArrayList<E> createCollection()
  {
    return new ArrayList<E>();
  }
}

for HashSet

public class HashSetCreator<E> implements CollectionCreator<E, HashSet<E>>
{
  @Override
  public HashSet<E> createCollection()
  {
    return new HashSet<E>();
  }
}

With all these, the final version of IterableToCollectionSelector is

public class IterableToCollectionSelector<E, T extends Iterable<? extends E>, C extends Condition1<? super E>, R extends Collection<E>>
    implements Selector1<T, C, R>
{
  private final CollectionCreator<E, ? extends R> collectionCreator;

  public <CC extends CollectionCreator<E, ? extends R>> IterableToCollectionSelector(final CC collectionCreator)
  {
    this.collectionCreator = collectionCreator;
  }

  @Override
  public R select(final C condition, final T source)
  {
    final R result = collectionCreator.createCollection();
    for (final E element : source)
    {
      if (condition.isMet(element))
      {
        result.add(element);
      }
    }
    return result;
  }
}

It needs to have CollectionCreator but it’s immutable so I don’t need to worry about the state of the selector object once it’s created.

When IterableToCollectionSelector is used, it looks

// selector for the List of Product.
final IterableToCollectionSelector<Product, Iterable<Product>, Condition1<Product>, ArrayList<Product>> collectionSelector =
  new IterableToCollectionSelector<Product, Iterable<Product>, Condition1<Product>, ArrayList<Product>>(new ArrayListCreator());
final List<Product> resultList = collectionSelector.select(greaterThan20, productList);

// selector for the List of DiscountedProduct
final IterableToCollectionSelector<DiscountedProduct, Iterable<DiscountedProduct>, Condition1<Product>, ArrayList<DiscountedProduct>> collectionSelector2 =
  new IterableToCollectionSelector<DiscountedProduct, Iterable<DiscountedProduct>, Condition1<Product>, ArrayList<DiscountedProduct>>(new ArrayListCreator());
final List<DiscountedProduct> resultList2 = collectionSelector2.select(greaterThan20, discountedProductList)

Wait, do I have to create the IterableToCollectionSelector whenever I need to use it for a different type? It seems like it’s waste of memory and not to mention of boilerplate code. OK, here comes why I don’t hate generics’ type erasure anymore. Considering type erasure, both objects, used above, actually have no difference in runtime.

So what I can do is that I can create a helper class containing one really generic IterableToCollectionSelector then cast it using a generic method so that it always returns the same instance but can be used for different types with compile-time type safety. It would be clear if I just show the code.

public class CollectionUtil
{
  private static final IterableToCollectionSelector<?, ? extends Iterable<?>, ? extends Condition1<?>, ? extends ArrayList<?>> ITERABLE_TO_ARRAY_LIST_SELECTOR =
    new IterableToCollectionSelector<Object, Iterable<?>, Condition1<Object>, ArrayList<Object>>(
        new ArrayListCreator<Object>());

  public static <E, T extends Iterable<? extends E>, C extends Condition1<? super E>> IterableToCollectionSelector getIterableToCollectionSelector()
  {
    @SuppressWarnings("unchecked")
    final IterableToCollectionSelector<E, T, C, ArrayList<E>> iterableToCollectionSelector =
      (IterableToCollectionSelector<E, T, C, ArrayList<E>>) ITERABLE_TO_ARRAY_LIST_SELECTOR;
    return iterableToCollectionSelector;
  }
}

And similarly, ArrayListCreator doesn’t have to be created more than once. It doesn’t have any state so one instance can be and should be reused.

public class ArrayListCreator<E> implements CollectionCreator<E, ArrayList<E>>
{
  public static final ArrayListCreator<Object> ARRAY_LIST_CREATOR = new ArrayListCreator<Object>();

  @Override
  public ArrayList<E> createCollection()
  {
    return newArrayList();
  }

  public static <E> ArrayListCreator<E> getInstance()
  {
    @SuppressWarnings("unchecked")
    final ArrayListCreator<E> arrayListCreator = (ArrayListCreator<E>) ARRAY_LIST_CREATOR;
    return arrayListCreator;
  }
}

So CollectionUtil is rewritten.

public class CollectionUtil
{
  private static final IterableToCollectionSelector<?, ? extends Iterable<?>, ? extends Condition1<?>, ? extends ArrayList<?>> ITERABLE_TO_ARRAY_LIST_SELECTOR =
    new IterableToCollectionSelector<Object, Iterable<?>, Condition1<Object>, ArrayList<Object>>(
        ArrayListCreator.getInstance());

  public static <E, T extends Iterable<? extends E>, C extends Condition1<? super E>> IterableToCollectionSelector getIterableToCollectionSelector()
  {
    @SuppressWarnings("unchecked")
    final IterableToCollectionSelector<E, T, C, ArrayList<E>> iterableToCollectionSelector =
      (IterableToCollectionSelector<E, T, C, ArrayList<E>>) ITERABLE_TO_ARRAY_LIST_SELECTOR;
    return iterableToCollectionSelector;
  }
}

@SuppressWarnings("unchecked")
final IterableToCollectionSelector<E, T, C, ArrayList<E>> iterableToCollectionSelector =
  (IterableToCollectionSelector<E, T, C, ArrayList<E>>) ITERABLE_TO_ARRAY_LIST_SELECTOR;

This is possible due to type erasure, so you don’t have to create many objects of the same type with different generic type info (e.g. instances of the same type, ‘IterableToCollectionSelector‘, with ‘different generic types’ like different E, T, C) which will be all the same in runtime. That’s why I do not hate type erasure anymore. Of course, you need to @SuppressWarnings to make the compiler quiet, but it’s not a big deal and I know what I’m doing. It’s perfectly valid.

The condition can be reused.

final Condition1<Product> greaterThan20 = new Condition1<Product>() {
  private final BigDecimal twenty = new BigDecimal("20");
  @Override
  public boolean isMet(final Product input)
  {
    return 0 > twenty.compareTo(input.getPrice());
  }
};

Now I can just do,

final IterableToCollectionSelector<Product, Iterable<Product>, Condition1<Product>, ArrayList<Product>> collectionSelectorForProduct =
  CollectionUtil.getIterableToCollectionSelector();
final List<Product> resultForProduct = collectionSelectorForProduct.select(greaterThan20, productList);

final IterableToCollectionSelector<DiscountedProduct, Iterable<DiscountedProduct>, Condition1<Product>, ArrayList<DiscountedProduct>> collectionSelectorForDiscountedProduct =
  CollectionUtil.getIterableToCollectionSelector();
final List<DiscountedProduct> resultForDiscountedProduct = collectionSelectorForDiscountedProduct.select(greaterThan20, discountedProductList);

Each time when you get an instance of IterableToCollectionSelector using the getIterableToCollectionSelector() method, you get the same IterableToCollectionSelector instance.

OK, that sounds good but do I really need to know all those complex E, T, C, R and even wildcard like “? extends E” or “? super E“? Well, you don’t have to. It depends on what you do. If you’re a library or framework developer, you should probably. Otherwise, not really. The library or API designer should carefully design it to offer APIs that are easy to use and understand for the users of the library. The designer or architect, on the other hand, should know the things I talked about here to make complex things simple. That’s our job, isn’t it? Making a complex thing simple then solve it. Anyway, most of the time, you don’t need to deal with that kind of complex API if you’re an application developer. Your company should have at least one person who can deal with it and he/she should provide easy to use APIs. If your company doesn’t have any, ask your boss to hire one. Using well designed good APIs can surely save your time which means saving your company’s money. Also less error-prone.

So how can the IterableToCollectionSelector be simple so that the users wouldn’t need to care about E, T, C, etc.

The library designer should create more specific type of selector like

public final class IterableToArrayListSelector<E> extends
    IterableToCollectionSelector<E, Iterable<? extends E>, Condition1<? super E>, ArrayList<E>>
{
  IterableToArrayListSelector(final ArrayListCreator<E> collectionCreator)
  {
    super(collectionCreator);
  }
}

Then CollectionUtil becomes

public class CollectionUtil
{
  private static final IterableToArrayListSelector<?> ITERABLE_TO_ARRAY_LIST_SELECTOR =
    new IterableToArrayListSelector<Object>(ArrayListCreator.getInstance());

  public static <E> IterableToArrayListSelector<E> getIterableToArrayListSelector()
  {
    @SuppressWarnings("unchecked")
    final IterableToArrayListSelector<E> iterableToCollectionSelector =
      (IterableToArrayListSelector<E>) ITERABLE_TO_ARRAY_LIST_SELECTOR;
    return iterableToCollectionSelector;
  }
}

Now using it is much easier.
(with static import)

import static your.package_name.here.CollectionUtil.*;

// ...

final IterableToArrayListSelector<Product> arrayListSelectorForProduct =
  getIterableToArrayListSelector();
final List<Product> resultForProduct = arrayListSelectorForProduct.select(greaterThan20, productList);

final IterableToArrayListSelector<DiscountedProduct> arrayListSelectorForDiscountedProduct =
  getIterableToArrayListSelector();
final List<DiscountedProduct> resultForDiscountedProduct =
  arrayListSelectorForDiscountedProduct.select(greaterThan20, discountedProductList);

You may not be satisfied yet, because you have the variables for the IterableToArrayListSelector objects. Should you have these? No, you don’t have to. So you probably try like this.

final List<Product> resultForProduct = getIterableToArrayListSelector()
                                         .select(greaterThan20, productList);

Yet, this doesn’t work. When getIterableToArrayListSelector() is called there is no generic type info given so it returns just an object of IterableToArrayListSelector<Object>. Thus it causes a compile-time error on calling select(greaterThan20, productList).

It can be solved by specifying the generic type like.

final List<Product> resultForProduct2 = CollectionUtil.<Product> getIterableToArrayListSelector()
                                          .select(greaterThan20, productList);

It’s not so elegant though. It can be solved as well. How? instead of having the getIterableToArrayListSelector() method to get an instance of IterableToArrayListSelector, why don’t I just create another generic select() method which does both getting the instance and calling the select() method in it.

So CollectionUtil is re-written.

public class CollectionUtil
{
  private static final IterableToArrayListSelector<?> ITERABLE_TO_ARRAY_LIST_SELECTOR =
    new IterableToArrayListSelector<Object>(ArrayListCreator.getInstance());

  public static <E, T extends Iterable<? extends E>, C extends Condition1<? super E>> ArrayList<E> select(
      final C condition, final T iterable)
  {
    final IterableToArrayListSelector<E> iterableToCollectionSelector =
      (IterableToArrayListSelector<E>) ITERABLE_TO_ARRAY_LIST_SELECTOR;
    return iterableToCollectionSelector.select(condition, iterable);
  }
}

How to use? Really simple.
(also with static import)

import static your.package_name.here.CollectionUtil.*;

// ...

final List<Product> resultForProduct = select(greaterThan20, productList);

final List<DiscountedProduct> resultForDiscountedProduct = select(greaterThan20, discountedProduct);

So it’s

final IterableToCollectionSelector<Product, Iterable<Product>, Condition1<Product>, ArrayList<Product>> collectionSelectorForProduct =
  getIterableToCollectionSelector();
final List<Product> resultForProduct = collectionSelectorForProduct.select(greaterThan20, productList);

VS

final List<Product> resultForProduct = select(greaterThan20, productList);

As you can see, depending on how you use generics it can give you a really nice, simple and easy to use API.

Just a moment. It might not be enough. That select takes an Iterable object and returns an ArrayList object, but what if I want to get HashSet instead, or what about taking an array as an input parameter instead of an Iterable object? It can be accomplished too, but I’m not going to explain it here. I’ll do it later when I talk about good API design in another post not in the generics series.

In the meantime, you can use what I’ve already provided in my library that is KommonLee.

If you use it, you can simply do

final List<Product> anotherPositiveIntegerList = selector()
        .fromIterable()
        .toArrayList()
        .select(greaterThan20, productList);

OR

final Set<Product> anotherPositiveIntegerList = selector()
        .fromIterable()
        .toHashSet()
        .select(greaterThan20, productList);

OR

Product[] productArray = // ...
final List<Product> anotherPositiveIntegerList = selector()
        .fromArray()
        .toArrayList()
        .select(greaterThan20, productArray);

and so on…
More examples are >>here<<
It also has Mappers and SelectableMappers so you can convert one type stored in a Collection to another.

Also the example code I used here is available on Github. Example Code: CLICK HERE!!!

Next post about generics would be about something easier than the selector example. So it would be some practical but easier, then the final post would be about really complex one when it’s designed but easy when it’s used. It is also very practical and useful. Unfortunately, however, I can’t tell when I can write it as I need to think about good examples to explain. As you can see above, it can be difficult to understand without example code (or even with it, still difficult). I do actually have some examples but it’s the code I made for my work so I can’t just use it. Anyway, I will figure it out so stay tuned.
 
 

Java Generics: Generics in Real Life Programming – dzone.com/I5lP – @dzone Big Link by kevinshlee

— DZone (@DZone) December 7, 2012

The old one was

My homepage – OLD

The new one is

My homepage – New

My projects and about me page are also added.

My Projects

About Me

Google I/O 2008 – Effective Java Reloaded – Joshua Bloch

Effective Java – Still Effective After All These Years – Joshua Bloch

For better API / language design

Growing a Language, by Guy Steele

How To Design A Good API and Why it Matters – Joshua Bloch

Evolving the Java Language – Neal Gafter

http://www.infoq.com/presentations/neal-gafter-evolving-java
 
 

Advanced Topics In Programming Languages: Closures For Java – Neal Gafter

So the first number is 1 then there is one "1". one 1 -> 11
Now use the number "11" and there are two 1s. two 1s -> 21
21: one 2 and one 1 -> 1211
1211: one 1, one 2 and two 1s -> 111221
111221: three 1s, two 2s and one 1 -> 312211
312211: one 3, one 1, two 2s and two 1 -> 13112221
13112221: one 1, one 3, two 1s, three 2s and one 1 -> 1113213211

----------------------------------------------------------------
1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211 ...

The Java programme code which reads off the given number can be written like

public static String LookAndSayUsingForLoop(final String number)
{
  if (null == number || number.isEmpty())
  {
    return "";
  }
  int firstCharPosition = 0;
  final StringBuilder stringBuilder = new StringBuilder();
  for (int i = 0; i < number.length(); i++)
  {
    if (number.charAt(firstCharPosition) != number.charAt(i))
    {
      //
      // the char at the current position is not equal to the first char
      // in the group of the equal chars so collect the chars
      // from the first char position to just before the current position.
      //
      final String digitsFound = number.substring(firstCharPosition, i);
      stringBuilder.append(digitsFound
                          .length())
                   .append(number
                          .charAt(firstCharPosition));
      firstCharPosition = i; // set the new first char position
    }
  }
  /* add the leftover */
  stringBuilder.append(number
                      .substring(firstCharPosition,
                                 number.length())
                      .length())
               .append(number
                      .charAt(firstCharPosition));
  return stringBuilder.toString();
}

System.out.println(LookAndSayUsingForLoop("1"));

Result:
11

System.out.println(LookAndSayUsingForLoop("11"));

Result:
21

System.out.println(LookAndSayUsingForLoop("21"));

Result:
1211

So to get the first ten elements,

String result1 = number;
System.out.print(result1 + " ");
for (int i = 1; i < howMany; i++)
{
  result1 = LookAndSayUsingForLoop(result1);
  System.out.print(result1 + " ");
}

It prints out.

1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211 

It can be simpler if recursion is used.
The LookAndSayUsingForLoop method can be re-written like

private static String lookAndSayV1(final String number, final int position)
{
  if (number.length() == position)
  {
    // reached the end which means every digit in the number is
    // equal to one another so just read off the entire number.
    return String.valueOf(number.length()) + number.charAt(0);
  }
  final char firstChar = number.charAt(0);
  return firstChar == number.charAt(position) ?
            // the current char equals to the first one so keep checking
            lookAndSayV1(number, position + 1) :
            // otherwise, read off until just before the current position
            // then check from the current position
            // calling this function itself again.
            String.valueOf(number
                          .substring(0, position)
                          .length()) +
              firstChar +
              lookAndSayV1(number
                          .substring(position), 0);
}

The result is exactly the same as the one using ‘for’ loop.

System.out.println(lookAndSayV1("1", 0));

Result:
11

System.out.println(lookAndSayV1("11", 0));

Result:
21

System.out.println(lookAndSayV1("21", 0));

Result:
1211

To get the first ten elements, another recursive method can be used.

public static String lookAndSay(final int howMany, final String number)
{
  return 0 >= howMany ? "" : number + " " + lookAndSay(howMany - 1, lookAndSayV1(number, 0));
}

final String number = "1";
final String result = lookAndSay(10, number);
System.out.println(result);

Result:

1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211 

The method lookAndSayV1() can be re-written using only one return statement and a few conditional operations.

private static String lookAndSayV2(final String number, final int position)
{
  return number.length() == position ?
            String.valueOf(number
                          .length()) +
              number.charAt(0) :
            (number.charAt(0) == number.charAt(position) ?
                lookAndSayV2(number, position + 1) :
                String.valueOf(number
                              .substring(0, position)
                              .length()) +
                  number.charAt(0) +
                  lookAndSayV2(number
                            .substring(position), 0));
}

This works the same as the lookAndSayV1() method. The code would be more readable with readOff() method.

private static String readOff(final String digits)
{
  return String.valueOf(digits.length()) + digits.charAt(0);
}

private static String lookAndSayV3(final String number, final int position)
{
  return number.length() == position ?
            readOff(number) :
            (number.charAt(0) == number.charAt(position) ?
                lookAndSayV3(number, position + 1) :
                readOff(number
                      .substring(0, position)) +
                      lookAndSayV3(number
                                  .substring(position), 0));
}

public static String lookAndSay3(final int howMany, final String number)
{
  return 0 >= howMany ? "" : number + " " + lookAndSay3(howMany - 1, lookAndSayV3(number, 0));
}

If the numbers should be stored in a List object, it can be done like

public static void lookAndSayUsingList(final String number, final int howMany, final List<String> resultList)
{
  resultList.add(number);
  if (resultList.size() < howMany)
  {
    lookAndSayUsingList(lookAndSayV3(number, 0), howMany, resultList);
  }
}

final List<String> resultList = new ArrayList<String>();
lookAndSayUsingList(number, howMany, resultList);
System.out.println(resultList);

If you prefer having returned result,

private static List<String> lookAndSayUsingList2(final String number, final int howMany, final List<String> list)
{
  list.add(number);
  if (list.size() < howMany)
  {
    return lookAndSayUsingList2(lookAndSayV3(number, 0), howMany, list);
  }
  return Collections.unmodifiableList(new ArrayList<String>(list));
}

The last line which returns an unmodifiable list object should use a new ArrayList object instead of directly using list.
Just making list unmodifiableList is not enough as the caller of this method can still modify the given parameter list
e.g.) Just have Collections.unmodifiableList(list); will result in

final List<String> resultList = new ArrayList<String>();
resultList.add(number);
final List<String> result = lookAndSayUsingList2(resultList, howMany);
// result.add("test"); // <- this does not work! runtime exception!
resultList.add("test"); // <- yet this does!!!
// Now the result has "test" at the end although it's unmodifiable List.
// It was modified using resultList.

If you don’t want to pass a List object, create another method and use it with the lookAndSayUsingList2() method.

public static List<String> lookAndSayUsingList2(final String number, final int howMany)
{
  final List<String> list = new ArrayList<String>();
  return lookAndSayUsingList2(number, howMany, list);
}

System.out.println(lookAndSayUsingList2(number, howMany));

Finally, using a Function object.

public interface LookAndSayFunction
{
  void apply(String number, int howMany);
}

final List<String> resultListFromFunctionObject = new ArrayList<String>();
new LookAndSayFunction() {
  @Override
  public void apply(final String number, final int howMany)
  {
    resultListFromFunctionObject.add(number);
    if (resultListFromFunctionObject.size() < howMany)
    {
      apply(lookAndSayV3(number, 0), howMany);
    }
  }
}.apply(number, howMany);

System.out.println(resultListFromFunctionObject);

Don’t want to get a mutable List object staying outside the function?

public interface Function1<T, R>
{
  R apply(T input);
}

public interface Function2<T1, T2, R>
{
  R apply(T1 input1, T2 input2);
}

final Function2<String, Integer, List<String>> anotherFunction =
  new Function2<String, Integer, List<String>>() {
    @Override
    public List<String> apply(final String number, final Integer howMany)
    {
      return new Function<List<String>>() {
        @Override
        public List<String> apply()
        {
          final List<String> resultList = new ArrayList<String>();
          return new Function1<String, List<String>>() {
            @Override
            public List<String> apply(final String number)
            {
              resultList.add(number);
              if (resultList.size() < howMany.intValue())
              {
                return apply(lookAndSayV3(number, 0));
              }
              return Collections.unmodifiableList(resultList);
            }
          }.apply(number);
        }
      }.apply();
    }
  };

System.out.println(anotherFunction.apply(number, howMany));

Or currying can be used.

final Function1<Integer, Function1<String, List<String>>> lookAndSayWithCurrying =
new Function1<Integer, Function1<String, List<String>>>() {
  @Override
  public Function1<String, List<String>> apply(final Integer howMany)
  {
    return new Function1<String, List<String>>() {
      @Override
      public List<String> apply(final String number)
      {
        final List<String> resultList = new ArrayList<String>();
        return new Function1<String, List<String>>() {
          @Override
          public List<String> apply(final String number)
          {
            resultList.add(number);
            if (resultList.size() < howMany.intValue())
            {
              return apply(lookAndSayV3(number, 0));
            }
            return Collections.unmodifiableList(resultList);
          }
        }.apply(number);
      }
    };
  }
};
System.out.println(lookAndSayWithCurrying.apply(howMany)
        .apply(number));

The function can be reused.

final Function1<String, List<String>> lookAndSayToGet10Elements = lookAndSayWithCurrying.apply(10);
System.out.println(lookAndSayToGet10Elements.apply(number));
System.out.println(lookAndSayToGet10Elements.apply(number));

Result:
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

final Function1<String, List<String>> lookAndSayToGet5Elements = lookAndSayWithCurrying.apply(5);
System.out.println(lookAndSayToGet5Elements.apply(number));

Result:
[1, 11, 21, 1211, 111221]

System.out.println(lookAndSayToGet5Elements.apply("111221"));

Result:
[111221, 312211, 13112221, 1113213211, 31131211131221]

System.out.println(lookAndSayToGet5Elements.apply("21"));

Result:
[21, 1211, 111221, 312211, 13112221]

System.out.println(lookAndSayToGet5Elements.apply("1"));

Result:
[1, 11, 21, 1211, 111221]

If you want to fix the number and get different numbers of elements as the results from the look and say function,

final Function1<String, Function1<Integer, List<String>>> lookAndSayWithCurryingAndNumberFixed =
  new Function1<String, Function1<Integer, List<String>>>() {
    @Override
    public Function1<Integer, List<String>> apply(final String number)
    {
      return new Function1<Integer, List<String>>() {
        @Override
        public List<String> apply(final Integer howMany)
        {
          final List<String> resultList = new ArrayList<String>();
          return new Function1<String, List<String>>() {
            @Override
            public List<String> apply(final String number)
            {
              resultList.add(number);
              if (resultList.size() < howMany.intValue())
              {
                return apply(lookAndSayV3(number, 0));
              }
              return Collections.unmodifiableList(resultList);
            }
          }.apply(number);
        }
      };
    }
  };

final Function1<Integer, List<String>> lookAndSayWithNumberFixed = lookAndSayWithCurryingAndNumberFixed.apply("1");
System.out.println(lookAndSayWithNumberFixed.apply(3));
System.out.println(lookAndSayWithNumberFixed.apply(5));
System.out.println(lookAndSayWithNumberFixed.apply(10));

Results:

[1, 11, 21]
[1, 11, 21, 1211, 111221]
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

Here are all the examples.

Results:

Using LookAndReadUsingForLoop: 
String result1 = number;
System.out.print(result1 + " ");
for (int i = 1; i < howMany; i++)
{
  result1 = LookAndSayUsingForLoop(result1);
  System.out.print(result1 + " ");
}
1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211 
--------------------------------------------------------------------------------

Using lookAndSayV1: 
System.out.println(lookAndSay(howMany, number));
1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211 
--------------------------------------------------------------------------------

Using lookAndSaV2: 
System.out.println(lookAndSay2(howMany, number));
1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211 
--------------------------------------------------------------------------------

Using lookAndSaV3: 
System.out.println(lookAndSay3(howMany, number));
1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211 
--------------------------------------------------------------------------------

Using lookAndSayUsingList: 
final List<String> resultList = new ArrayList<String>();
lookAndSayUsingList(number, howMany, resultList);
System.out.println(resultList);
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]
--------------------------------------------------------------------------------

Using lookAndSayUsingList2: 
System.out.println(lookAndSayUsingList2(number, howMany, new ArrayList<String>()));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]
--------------------------------------------------------------------------------

Using another lookAndSayUsingList2 (without passing List): 
System.out.println(lookAndSayUsingList2(number, howMany))
--------------------------------------------------------------------------------

Using Function object: 
final List<String> resultListFromFunctionObject = new ArrayList<String>();
new LookAndSayFunction() {
  @Override
  public void apply(final String number, final int howMany)
  {
    resultListFromFunctionObject.add(number);
    if (resultListFromFunctionObject.size() < howMany)
    {
      apply(lookAndSayV3(number, 0), howMany);
    }
  }
}.apply(number, howMany);
System.out.println(resultListFromFunctionObject);
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]
--------------------------------------------------------------------------------

Using Function object with returned List object: 
final Function2<String, Integer, List<String>> anotherFunction = new Function2<String, Integer, List<String>>() {
  @Override
  public List<String> apply(final String number, final Integer howMany)
  {
    return new Function<List<String>>() {
      @Override
      public List<String> apply()
      {
        final List<String> resultList = new ArrayList<String>();
        return new Function1<String, List<String>>() {
          @Override
          public List<String> apply(final String number)
          {
            resultList.add(number);
            if (resultList.size() < howMany.intValue())
            {
              return apply(lookAndSayV3(number, 0));
            }
            return Collections.unmodifiableList(resultList);
          }
        }.apply(number);
      }
    }.apply();
  }
};
System.out.println(anotherFunction.apply(number, howMany));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

System.out.println(anotherFunction.apply(number, 5));
[1, 11, 21, 1211, 111221]

System.out.println(anotherFunction.apply(number, 7));
[1, 11, 21, 1211, 111221, 312211, 13112221]
--------------------------------------------------------------------------------

Using currying (number of elements fixed): 
final Function1<Integer, Function1<String, List<String>>> lookAndSayWithCurrying =
  new Function1<Integer, Function1<String, List<String>>>() {
    @Override
    public Function1<String, List<String>> apply(final Integer howMany)
    {
      return new Function1<String, List<String>>() {
        @Override
        public List<String> apply(final String number)
        {
          final List<String> resultList = new ArrayList<String>();
          return new Function1<String, List<String>>() {
            @Override
            public List<String> apply(final String number)
            {
              resultList.add(number);
              if (resultList.size() < howMany.intValue())
              {
                return apply(lookAndSayV3(number, 0));
              }
              return Collections.unmodifiableList(resultList);
            }
          }.apply(number);
        }
      };
    }
  };
lookAndSayWithCurrying.apply(howMany)
    .apply(number);
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

final Function1<String, List<String>> lookAndSayToGet10Elements = lookAndSayWithCurrying.apply(10);
System.out.println(lookAndSayToGet10Elements.apply(number));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

System.out.println(lookAndSayToGet10Elements.apply(number));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

System.out.println(lookAndSayToGet10Elements.apply(number));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]


final Function1<String, List<String>> lookAndSayToGet5Elements = lookAndSayWithCurrying.apply(5);
System.out.println(lookAndSayToGet5Elements.apply(number));
[1, 11, 21, 1211, 111221]

System.out.println(lookAndSayToGet5Elements.apply(number));
[1, 11, 21, 1211, 111221]

System.out.println(lookAndSayToGet5Elements.apply(number));
[1, 11, 21, 1211, 111221]

System.out.println(lookAndSayToGet5Elements.apply("111221"));
[111221, 312211, 13112221, 1113213211, 31131211131221]

System.out.println(lookAndSayToGet5Elements.apply("21"));
[21, 1211, 111221, 312211, 13112221]

System.out.println(lookAndSayToGet5Elements.apply("1"));
[1, 11, 21, 1211, 111221]
--------------------------------------------------------------------------------

Using currying (number fixed): 
final Function1<String, Function1<Integer, List<String>>> lookAndSayWithCurryingAndNumberFixed =
  new Function1<String, Function1<Integer, List<String>>>() {
    @Override
    public Function1<Integer, List<String>> apply(final String number)
    {
      return new Function1<Integer, List<String>>() {
        @Override
        public List<String> apply(final Integer howMany)
        {
          final List<String> resultList = new ArrayList<String>();
          return new Function1<String, List<String>>() {
            @Override
            public List<String> apply(final String number)
            {
              resultList.add(number);
              if (resultList.size() < howMany.intValue())
              {
                return apply(lookAndSayV3(number, 0));
              }
              return Collections.unmodifiableList(resultList);
            }
          }.apply(number);
        }
      };
    }
  };
final Function1<Integer, List<String>> lookAndSayWithNumberFixed = lookAndSayWithCurryingAndNumberFixed.apply("1");
System.out.println(lookAndSayWithNumberFixed.apply(howMany));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

System.out.println(lookAndSayWithNumberFixed.apply(3));
[1, 11, 21]

System.out.println(lookAndSayWithNumberFixed.apply(5));
[1, 11, 21, 1211, 111221]

System.out.println(lookAndSayWithNumberFixed.apply(10));
[1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, 31131211131221, 13211311123113112211]

mQlicker is a audience response system (audience interaction system / classroom interaction system) which can give a voice to the audience. It can be used for classroom, presentation, lecture, survey, quiz, etc. It consists of two main UIs which are the user UI for those who want to get the responses from people and the respondent UI for those who respond.

What’s new in new mQlicker

1. Respondent UI

1.1. Design Change in Respondent UI

OLD: Respondent UI

The old version of the respondent UI for computers doesn’t look so pretty. The look is also too different from the one displayed on the mobile devices (Please see how it looks on iPhone).
The new one looks prettier and similar to the mobile one.

Respondent UI: iPhone

New Respondent UI

1.2. Page Breaks.

OLD: All qeustions on one page

New Respondent UI with different number of question on each page.

New Respondent UI with one question on one page.

1.3. Optional Questions.

Old Respondent UI without optional questions

New Respondent UI with an optional question

1.4. Missing Answer Indicator for Mandatory Questions.

Old Respondent UI with no missing answer indicator

New Respondent UI with a missing answer indicator

1.5. Other Answer

Old Respondent UI with no other answer

New Respondent UI with other answer

1.6. Result is Visible to the Respondents.

Old Respondent UI with no result after submission

New Respondent UI with result after answer submission

New Respondent UI with result after answer submission

New Respondent UI with result after answer submission

New Respondent UI with result after answer submission

2. User UI

Old User UI

New User UI

2.1. Rich Text Editor

Please compare the new one with the old one. You could only have plain text without any formatting. Now, it is possible to format your text just like using a word processor.

2.2 Result Visible to Respondent

As already mentioned above, you can set the interaction to make the response result visible to the respondents once they submit their answers.

2.3. Other Answer

You can make the multiple choice questions have other answers with the label you want (Other? Something else?, etc).

2.4 Optional Question

Questions and be optional so not all of them are mandatory.

2.5. Page Breaks

You can easily set the number of questions per page by just clicking the page breaker bar to enable and disabled it.

2.6. Images in Question

Now you can upload an image file or set the location of the image to display it with the question.

User UI – Question with image

User UI – Question with image

User UI – Question with image

Respondent UI – Question with image

2.7 Slide type question

Sometimes you only need to provide some text that you want your audience to read. Now you can have a slide type question which only displays the text you provide!

2.8. Running Session Indicator

New User UI has a running session indicator

OK, that’s it. There are still several minor things but not that big deal so I rather not talk about here.
I hope you enjoy the new mQlicker.

System.out.println("client " + authorized ? "authorized" : "unauthorized");

JavaScript:

alert('client ' + authorized ? 'authorized' : 'unauthorized');

(Let’s assume that the authorized is a parameter variable)

In Java, if you write code like this, you definitely get a compile time error, since String concatenation gets higher precedence than conditional operator whereas in JavaScript, you don’t get any error although String concatenation has higher precedence just like Java.

Reason for that is unlike Java which allows only true or false (or boxed Boolean) for conditional expression, in JavaScript, there are several cases that make conditional expression working and make the evaluation result of it false (false, undefined, 0, Number.NaN, "" (empty String), etc.) or true (cases other than the ones making it false). So if you have some value other than those and test it, the result is true.

e.g.) some cases making the evaluation of conditional expression false.

if (0)
{
  // false so never come here.
}

if (undefined)
{
  // false so never come here.
}

if (Number.NaN)
{
  // false so never come here.
}

if (false)
{
  // false so never come here.
}

if ("")
{
  // false so never come here.
}

e.g.) some cases making the evaluation of conditional expression true.

if (1)
{
  // true!
}

if ("some value")
{
  // true!
}

if (true)
{
  // of course true!
}

if ({})
{
  // true!
}


if ({"someName":"someValue"})
{
  // true!
}


if ([])
{
  // true!
}


if ([1,2,3,])
{
  // true!
}

So this code

alert('client ' + authorized ? 'authorized' : 'unauthorized');

will eventually become like

if authorized is true,

alert('client true' ? 'authorized' : 'unauthorized');

then

alert('authorized');

if authorized is false,

alert('client false' ? 'authorized' : 'unauthorized');

then

alert('authorized');

if the caller of the function didn’t send the authorized.

alert('client undefined' ? 'authorized' : 'unauthorized');

then

alert('authorized');

So if you want to get the result you want, the conditional operator part should be wrapped in parentheses.

alert('client ' + (authorized ? 'authorized' : 'unauthorized'));

In Java, you must!

System.out.println("client " + (authorized ? "authorized" : "unauthorized"));

I quite agree with him.

What mistake most people make when they compare Java with other programming languages and talk about how bad Java is is that they only talk about the Java programming language but not Java platform. It is not really fair to talk about Java without thinking its ecosystem including the platform, frameworks, libraries, tools, etc. As Erik says in the talk above, if you use vim to programme Java code, it’s like pounding a nail with your head. People complain about static typing but with help from proper IDEs, it can actually increase programming productivity not to mention of easier debugging.

What about Java’s verbosity? Programming is a conversation between a computer and a human. Imagine, instead of using a human language, we use all mathematical symbols to talk, would it be so easy to understand?

What does this picture mean? It might be 2? or victory? But if I say, “two” or “victory” then it’s clear. There are places where simple symbols and icons are helpful (think about iPhone app icons and math problems) while there are some other places where verbose instructions are helpful. Verbosity in Java, in fact, helps you understand the code written by you or others. It doesn’t mean there is no room for Lambda (closure) in Java though. Java with Lambda can result in much simpler code, but without it, it’s still not that bad to read. Anyway, Lambda will come to Java soon (JDK 8 ), and I’m looking forward to it as it looks much nicer than its initial state. I do functional programming using Java in many places in my project so it would be nice to have Lambda, but without it, I’m still fine. What I more desire to have in Java is a way to retrieve the names of method parameters using reflection (or some other simple and easy way). I had to use ASM instead to solve this issue. Why do I need that? I needed it to develop JSON Statham, Java/Json mapper library, to use one of my projects that is mQlicker (audience response system). I can keep using ASM but it’s a library to decompose and modify Java bytecode so there can be some situations where I cannot use it (e.g. Android uses its own bytecode that is dalvik bytecode, and ASM doesn’t support it as far as I know).

Some people perhaps complain about the design patterns. If you don’t need it, you don’t have to or should not use it. We do not programme to apply the patterns. We do programme to solve our problems. We can use the patterns if these solve our problems. If applying it causes more problems, don’t use it. I don’t try to apply the patterns first. I code to solve a problem and later find my solution is actually some pattern A. It’s usually like this. When I know exactly what pattern solves my problem, then of course, I use it, but I’ve never coded in order to use the patterns I know unless I need to write some example code to show how to use the patterns.

Some others may say like “Framework A is too heavy and complex. It took me more time to learn than developing apps and still requires more time to develop than the time spent on development without it.” If it’s the case, you should not use it. You’ve got lots of other choices so why bother to stick to only one thing? Albert Einstein said that repeating the same thing over and over again and expecting different results is insane. You can try something else. Usually, if you feel like that about the framework you’re using, it’s either you don’t need it or you’re not good enough to use it. “you don’t need it” might mean the framework really sucks or it’s not appropriate to your project. “you’re not good enough to use it” probably means “you’re not good enough YET to use it and need more knowledge to learn it then will be able to use it properly.” Either way, try something else as well then you will possibly have some more idea of what to use. You don’t have to repeat the same thing and have the same bad result.

I know there are too many bad examples of Java code and projects which are enough to make a really bad impression of Java on people who try to learn and use it. Fortunately, owing to the Internet, we can easily find good ones too these days. If I read only those terrible Java code examples and books, I would probably not use Java. So don’t read too old Java books and go to some developer’s websites to find some good Java examples. I also have to admit that there are really horrible and poorly designed APIs in Java (e.g. JAXP DOM API, java.net.URL, java.util.Calendar, etc.). There are also no immutable collections in Java JDK (there are unmodifiable collections but these are not really immutable since the collection passed as the parameter of Collections.unmodifiableXxx() methods can be modified by the user of the Collections utility class or any objects having the reference to the parameter collection). These are bad, but it can be solved by using other nice libraries (e.g. XStream, XOM, dom4j, Joda-Time, DATE4J, Apache Commons, Guava, etc.).

Don’t be extremist. Object-oriented programming or functional programming is not the answer to your problems. You may need both to solve your problem or neither might help you solve your issue. It’s just one of the tools you can use to solve your problems. Don’t waste your time to argue which is superior to the other.

By the way, I don’t like Java. It’s just a tool. I can use whatever tools that solve or help me solve my problems. Wouldn’t you feel weird if I say “I like a hammer but hate a screwdriver”? I neither like nor dislike these tools. I just need a hammer to put a nail into a well and a screwdriver to tighten a screw. Wouldn’t it look so stupid if I attempt to pound a nail with a screwdriver or try to tighten a screw using a hammer? I use Java as it is just a proper tool to solve some of my problems. For other problems, I use some other tools.

Hmmm, come to think of it, I’d rather not waste my time on this kind of topic anymore.

However, there may come a time when you need to directly use JDBC. It can be developing an application which requires accessing and using database or for developing your own Java persistence framework. One way or another it is good to learn this very fundamental Java persistence technology to get some good things from it as well as its drawback in order to avoid it. I am not going to talk about what JDBC is or how to use it as there are plenty of other tutorials explaining these on the Internet. What I am going to do is talking about better and easier way to use JDBC. I will not cover every single detail about it though, as my point here is giving some idea to use it better and there are already known solutions that provide what I am going to explain.

There are four steps to take to explain the better way of using JDBC. First of all, I will show a typical way to use JDBC then point out problems in it. After that analyse it to find a better way. Finally, I will implement it.

Preparation

Database and JDBC Driver

In my examples, I’ve used MySQL 5.1 and MySQL Connection/J 5.1.17 downloaded from the Connector/J download page on the MySQL website.

mysql-connector-java-5.1.17.zip

If you don’t want to become a user of the site, you can click the “No thanks, just take me to the downloads!” link at the bottom.
What you need is only one jar file that is mysql-connector-java-5.1.17-bin.jar in the zip file.

Java Beans

There are three JavaBeans used in the example to contain the data from the database.

public class Person
{
  private Long id;
  private String surname;
  private String givenName;
  private Address address;

  // getters and setters omitted.
}

public class Address
{
  private String street;
  private String suburb;
  private String state;
  private String country;
  private String postcode;
  private Date birthday;

  // constructors, getters and setters omitted.
}

import java.util.Date;

public class Book
{
  private Long id;
  private String title;
  private String authours;
  private String edition;
  private String isbn10;
  private String isbn13;
  private String publisher;
  private Date publishingDate;

  // getters and setters omitted.
}

1. Typical Way to Use JDBC

Here is a very typical way to use JDBC when retrieving data from the database.

Connection connection = null;
PreparedStatement statement = null;
ResultSet resultSet = null;

try
{
  // get connection.
  connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb",
                                           "testuser",
                                           "1234");

  final String sql = "SELECT * FROM people";
  
  // get PreparedStatement
  statement = connection.prepareStatement(sql);
  
  // run the query and get the result stored in the ResultSet.
  resultSet = statement.executeQuery();
  
  final List<Person> people = new ArrayList<Person>();
  while (resultSet.next())
  {
    // Map each row to a Person object and add it to the Person List, people.
    final Person person = new Person();
    person.setId(resultSet.getLong("person_id"));
    person.setSurname(resultSet.getString("surname"));
    person.setGivenName(resultSet.getString("given_name"));
    final Address address =
      new Address(resultSet.getString("street"),
          resultSet.getString("city"),
          resultSet.getString("state"),
          resultSet.getString("country"),
          resultSet.getString("postcode"));
    person.setAddress(address);
    person.setBirthday(new Date(resultSet
                          .getDate("birthday")
                          .getTime()));
    people.add(person);
  }
  System.out.println(people);
}
catch (final SQLException e)
{
  // you MUST catch SQLException exception
  // or add the throws clause having SQLException to the method declaration.
  e.printStackTrace();
}
finally
{
  // close ResultSet, PreparedStatement and Connection.
  if (null != resultSet)
  {
    try
    {
      resultSet.close();
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
  }
  if (null != statement)
  {
    try
    {
      statement.close();
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
  }
  if (null != connection)
  {
    try
    {
      connection.close();
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
  }
}

2. Problems

Now, I will make DAOs for Person and Book objects to examine what issues we can have when we follow the typical way to use JDBC mentioned above. Here is the PersonDao interface.

package com.lckymn.kevin.tutorial.jdbc_old.dao;

import java.util.List;

import com.lckymn.kevin.tutorial.jdbc_old.beans.Person;

public interface PersonDao
{
  Person find(Long id);
  List<Person> findPeopleByState(String state);
  List<Person> getAllPeople();
}

The following one is the BookDao interface.

package com.lckymn.kevin.tutorial.jdbc_old.dao;

import java.util.List;

import com.lckymn.kevin.tutorial.jdbc_old.beans.Book;

public interface BookDao
{
  Book find(Long id);
  List<Book> findBooksByPublisher(String publisher);
}

Before making the implementations of these, I will create an abstract class for both DAOs.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public abstract class AbstractDao
{
  private final String url;
  private final String username;
  private final String password;

  public AbstractDao(final String url, final String username, final String password)
  {
    this.url = url;
    this.username = username;
    this.password = password;
  }

  protected final Connection getConnection() throws SQLException
  {
    /*
     * depending on the version of JDBC (prior to 4.0) you may need to load the driver first.
     */
    return DriverManager.getConnection(url, username, password);
  }
}

Or for better use of database connection, Using Connection Pool and DataSource is desirable.

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

public abstract class AbstractDao
{
  private final DataSource dataSource;

  public AbstractDao(final DataSource dataSource)
  {
    this.dataSource = dataSource;
  }

  protected final Connection getConnection() throws SQLException
  {
    return dataSource.getConnection();
  }
}

Here is the implementation of PersonDao. The PersonDao extends AbstractDao thus it can get the Connection from the getConnection() method in the super class.

package com.lckymn.kevin.tutorial.jdbc_old.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.lckymn.kevin.tutorial.jdbc_old.beans.Address;
import com.lckymn.kevin.tutorial.jdbc_old.beans.Person;
import com.lckymn.kevin.tutorial.jdbc_old.dao.AbstractDao;
import com.lckymn.kevin.tutorial.jdbc_old.dao.PersonDao;

public class PersonDaoImpl extends AbstractDao implements PersonDao
{
  // constructor omitted...

  @Override
  public Person find(final Long id)
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<Person> result = new ArrayList<Person>();
    try
    {
      connection = getConnection();
      final String sql = "SELECT * FROM people WHERE person_id = ?";
      statement = connection.prepareStatement(sql);
      statement.setLong(1, id);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        final Person person = new Person();
        person.setId(resultSet.getLong("person_id"));
        person.setSurname(resultSet.getString("surname"));
        person.setGivenName(resultSet.getString("given_name"));
        final Address address =
          new Address(resultSet.getString("street"),
              resultSet.getString("city"),
              resultSet.getString("state"),
              resultSet.getString("country"),
              resultSet.getString("postcode"));
        person.setAddress(address);
        person.setBirthday(new Date(resultSet
                              .getDate("birthday")
                              .getTime()));
        result.add(person);
      }
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
    finally
    {
      if (null != resultSet)
        try { resultSet.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != statement)
        try { statement.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != connection)
        try { connection.close(); }
        catch (final SQLException e) { e.printStackTrace(); }
    }
    return result.isEmpty() ? null : result.get(0);
  }

  @Override
  public List<Person> findPeopleByState(final String state)
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<Person> result = new ArrayList<Person>();
    try
    {
      connection = getConnection();
      final String sql = "SELECT * FROM people WHERE state = ?";
      statement = connection.prepareStatement(sql);
      statement.setString(1, state);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        final Person person = new Person();
        person.setId(resultSet.getLong("person_id"));
        person.setSurname(resultSet.getString("surname"));
        person.setGivenName(resultSet.getString("given_name"));
        final Address address =
          new Address(resultSet.getString("street"),
              resultSet.getString("city"),
              resultSet.getString("state"),
              resultSet.getString("country"),
              resultSet.getString("postcode"));
        person.setAddress(address);
        person.setBirthday(new Date(resultSet
                              .getDate("birthday")
                              .getTime()));
        result.add(person);
      }
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
    finally
    {
      if (null != resultSet)
        try { resultSet.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != statement)
        try { statement.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != connection)
        try { connection.close(); }
        catch (final SQLException e) { e.printStackTrace(); }
    }
    return result;
  }

  @Override
  public List<Person> getAllPeople()
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<Person> result = new ArrayList<Person>();
    try
    {
      connection = getConnection();
      final String sql = "SELECT * FROM people";
      statement = connection.prepareStatement(sql);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        final Person person = new Person();
        person.setId(resultSet.getLong("person_id"));
        person.setSurname(resultSet.getString("surname"));
        person.setGivenName(resultSet.getString("given_name"));
        final Address address =
          new Address(resultSet.getString("street"),
              resultSet.getString("city"),
              resultSet.getString("state"),
              resultSet.getString("country"),
              resultSet.getString("postcode"));
        person.setAddress(address);
        person.setBirthday(new Date(resultSet
                              .getDate("birthday")
                              .getTime()));
        result.add(person);
      }
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
    finally
    {
      if (null != resultSet)
        try { resultSet.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != statement)
        try { statement.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != connection)
        try { connection.close(); }
        catch (final SQLException e) { e.printStackTrace(); }
    }
    return result;
  }
}

As you can see, there is too much boilerplate code here. Then what about the implementation of BookDao?

package com.lckymn.kevin.tutorial.jdbc_old.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.lckymn.kevin.tutorial.jdbc_old.beans.Book;
import com.lckymn.kevin.tutorial.jdbc_old.dao.AbstractDao;
import com.lckymn.kevin.tutorial.jdbc_old.dao.BookDao;

public class BookDaoImpl extends AbstractDao implements BookDao
{
  public BookDaoImpl(final String url, final String username, final String password)
  {
    super(url, username, password);
  }

  @Override
  public Book find(final Long id)
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<Book> result = new ArrayList<Book>();
    try
    {
      connection = getConnection();
      final String sql = "SELECT * FROM book WHERE book_id = ?";
      statement = connection.prepareStatement(sql);
      statement.setLong(1, id);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        final Book book = new Book();
        book.setId(resultSet.getLong("book_id"));
        book.setTitle(resultSet.getString("title"));
        book.setAuthours(resultSet.getString("authours"));
        book.setEdition(resultSet.getString("edition"));
        book.setIsbn10(resultSet.getString("isbn10"));
        book.setIsbn13(resultSet.getString("isbn13"));
        book.setPublisher(resultSet.getString("publisher"));
        book.setPublishingDate(resultSet.getDate("publishing_date"));
        result.add(book);
      }
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
    finally
    {
      if (null != resultSet)
        try { resultSet.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != statement)
        try { statement.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != connection)
        try { connection.close(); }
        catch (final SQLException e) { e.printStackTrace(); }
    }
    return result.isEmpty() ? null : result.get(0);
  }

  @Override
  public List<Book> findBooksByPublisher(final String publisher)
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<Book> result = new ArrayList<Book>();
    try
    {
      connection = getConnection();
      final String sql = "SELECT * FROM book WHERE publisher = ?";
      statement = connection.prepareStatement(sql);
      statement.setString(1, publisher);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        final Book book = new Book();
        book.setId(resultSet.getLong("book_id"));
        book.setTitle(resultSet.getString("title"));
        book.setAuthours(resultSet.getString("authours"));
        book.setEdition(resultSet.getString("edition"));
        book.setIsbn10(resultSet.getString("isbn10"));
        book.setIsbn13(resultSet.getString("isbn13"));
        book.setPublisher(resultSet.getString("publisher"));
        book.setPublishingDate(resultSet.getDate("publishing_date"));
        result.add(book);
      }
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
    finally
    {
      if (null != resultSet)
        try { resultSet.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != statement)
        try { statement.close(); }
        catch (final SQLException e) { e.printStackTrace(); }

      if (null != connection)
        try { connection.close(); }
        catch (final SQLException e) { e.printStackTrace(); }
    }
    return result;
  }
}

Just the same… OK, now I will compare just one method in each DAO and try to find if there are any similarities in these methods. One method from PersonDaoImpl is findPeopleByState(String) and the other one from BookDaoImpl is findBooksByPublisher(String).

Let’s see what are different.

Method Comparison Between PersonDao and BookDao

As you can see, except for a few parts highlighted, I’ve just repeated the same code. That means if the user of the DAO can dynamically give the code for these few differences when using it, I do not need to repeat the same code over and over again.

There is another problem in the catch block that catches the SQLException which can be thrown in the try block containing the main part of the code snippet.

}
catch (final SQLException e)
{
  e.printStackTrace(); // It just prints the StackTrace and ignores the exception.
}
finally
{

It just prints the StackTrace and ignores the exception, and this may cause a more serious problem as the exception is simply ignored so the programmers cannot easily find what went wrong. I need to deal with it too.

3. Finding Better Way

I will create a JdbcManager which takes care of selection, insertion, update and deletion of data.

I will try something very easy to do first. In the typical DAO code, every method has a finally block having really ugly code snippet to close ResultSet, Statement and Connection. I am sick of it so want to get rid of it first, but I cannot simply remove that code as it’s absolutely necessary therefore it’s there. Then I can make a method which closes those objects quietly without throwing any exception, for it’s already in the finally block and there might be already an exception thrown. So I don’t want the finally block to throw another exception which interrupts the fist exception.

My JdbcManager class will have the following method to close ResultSet, Statement and Connection.

private void closeQuietly(final Connection connection,
                          final PreparedStatement statement,
                          final ResultSet resultSet)
{
  if (null != resultSet)
    try { resultSet.close(); }
    catch (final SQLException e) { e.printStackTrace(); } // or log properly

  if (null != statement)
    try { statement.close(); }
    catch (final SQLException e) { e.printStackTrace(); } // or log properly

  if (null != connection)
    try { connection.close(); }
    catch (final SQLException e) { e.printStackTrace(); } // or log properly
}

So now findPeopleByState(String) looks like this.

public List<Person> findPeopleByState(final String state)
{
  Connection connection = null;
  PreparedStatement statement = null;
  ResultSet resultSet = null;

  final List<Person> result = new ArrayList<Person>();
  try
  {
    connection = getConnection();
    final String sql = "SELECT * FROM people WHERE state = ?";
    statement = connection.prepareStatement(sql);
    statement.setString(1, state);
    resultSet = statement.executeQuery();
    while (resultSet.next())
    {
      final Person person = new Person();
      person.setId(resultSet.getLong("person_id"));
      person.setSurname(resultSet.getString("surname"));
      person.setGivenName(resultSet.getString("given_name"));
      final Address address =
        new Address(resultSet.getString("street"),
                    resultSet.getString("city"),
                    resultSet.getString("state"),
                    resultSet.getString("country"),
                    resultSet.getString("postcode"));
      person.setAddress(address);
      person.setBirthday(new Date(resultSet
                            .getDate("birthday")
                            .getTime()));
      result.add(person);
    }
  }
  catch (final SQLException e)
  {
    e.printStackTrace();
  }
  finally
  {
    closeQuietly(connection, statement, resultSet);
  }
  return result;
}

Now think about the highlighted lines that are different depending on what type of object should be returned.
The first one is the method signature. I will talk about the parameters later and now focus on only the return type.

public List<Person> findPeopleByState(final String state)

It returns a List of Person but what if I want to get a List of Book? So the return type is of type List, but the type of the element should be contained in the List is undecided. It should be pending until the user of the method specifies it. In this kind of situation, what do we normally use? When we design an API and want to defer specifying what type to use until the user of the API decides it with providing compile-time type safety, we use Generics in Java.
So I can just easily make the method a generic method so that the return type would be depending on how the user of the method uses it.

public <T> T findPeopleByState( *don't worry about params for a while* )

The second part is the same, I don’t know what type of object the user wants to have in the List, so I just use a generic type parameter T.
So I’ve changed this

final List<Person> result = new ArrayList<Person>();

to

final List<T> result = new ArrayList<T>();

The third one is easy. It can easily become a parameter of the method.

final String sql = "SELECT * FROM people WHERE state = ?";

So the method signature would be like

public <T> T findPeopleByState(String sql, *don't worry about the rest params for now* )

Next one also looks simple. It’s just one line of code. Well, it is one line in this example but can be many lines depending on the given parameter values.

statement.setString(1, state);

So it might be like

statement.setLong(1, longValue);
statement.setString(2, stringValue);
statement.setBoolean(3, booleanValue);

So it seems like it will possibly have many parameters from the user of my method. So I think I should use some kind of Collection type containing the parameters or an array of Object containing these because the types of the parameters can vary. Wait. More conveniently I can just use varargs so that the user of my method doesn’t need to create any extra instance of collection or array to pass the parameters although using varargs results in creation of an array by compiler, yet in the user’s point of view, it’s hidden so can be very convenient.

public <T> T findPeopleByState(String sql,
                               //possibly more params here
                               Object ... params)

The types of the parameters can vary so I put Object type varargs. Now I need to set the parameters to the PreparedStatement. Since the varargs is actually an array, I can iterate over it to get each parameter then I use an index to get a parameter and index + 1 to set the parameterIndex in the PreparedStatement as it starts from 1. I will cover here only primitive types (including boxed ones), String and other commonly used reference types in db programming which are Date, Calendar and BigDecimal. All the other types will cause an IllegalArgumentException. It can of course improve but I am just giving an idea to use it better so am trying to make it just simple enough to understand with providing the idea. So the code would be

private void setParameters(final PreparedStatement statement, final Object... parameters) throws SQLException
{
  for (int i = 0, length = parameters.length; i < length; i++)
  {
    final Object parameter = parameters[i];
    final int parameterIndex = i + 1;
    if (null == parameter)
    {
      statement.setObject(parameterIndex, null);
    }
    else if (parameter instanceof Boolean)
    {
      statement.setBoolean(parameterIndex, (Boolean) parameter);
    }
    else if (parameter instanceof Character)
    {
      statement.setString(parameterIndex, String.valueOf(parameter));
    }
    else if (parameter instanceof Byte)
    {
      statement.setByte(parameterIndex, (Byte) parameter);
    }
    else if (parameter instanceof Short)
    {
      statement.setShort(parameterIndex, (Short) parameter);
    }
    else if (parameter instanceof Integer)
    {
      statement.setInt(parameterIndex, (Integer) parameter);
    }
    else if (parameter instanceof Long)
    {
      statement.setLong(parameterIndex, (Long) parameter);
    }
    else if (parameter instanceof Float)
    {
      statement.setFloat(parameterIndex, (Float) parameter);
    }
    else if (parameter instanceof Double)
    {
      statement.setDouble(parameterIndex, (Double) parameter);
    }
    else if (parameter instanceof String)
    {
      statement.setString(parameterIndex, (String) parameter);
    }
    else if (parameter instanceof Date)
    {
      statement.setDate(parameterIndex, new java.sql.Date(((Date) parameter)
                                            .getTime()));
    }
    else if (parameter instanceof Calendar)
    {
      statement.setDate(parameterIndex, new java.sql.Date(((Calendar) parameter)
                                            .getTimeInMillis()));
    }
    else if (parameter instanceof BigDecimal)
    {
      statement.setBigDecimal(parameterIndex, (BigDecimal) parameter);
    }
    else
    {
      throw new IllegalArgumentException(String.format(
          "Unknown type of the parameter is found. [param: %s, paramIndex: %s]",
          parameter,
          parameterIndex));
    }
  }
}

It can be used by other methods in the JdbcManager as well, so I made it a method.

Next is

while (resultSet.next())
{
  final Person person = new Person();
  person.setId(resultSet.getLong("person_id"));
  person.setSurname(resultSet.getString("surname"));
  person.setGivenName(resultSet.getString("given_name"));
  final Address address =
    new Address(resultSet.getString("street"),
                resultSet.getString("city"),
                resultSet.getString("state"),
                resultSet.getString("country"),
                resultSet.getString("postcode"));
  person.setAddress(address);
  person.setBirthday(new Date(resultSet
                        .getDate("birthday")
                        .getTime()));
  result.add(person);
}

The highlighted part should be done by the user of the API. The JdbcManager does’t know what should be there nor can it guess what data the user of it wants to retrieve from the database. It looks like I can use Callback here. Java does not have First-Class Function yet (Java will have First-Class Function in the form of lambda expression in the Java SE 8. Click here to get more details about Project Lambda), but I can define an interface which maps data in a ResultSet row to a Java object and let the user pass an instance of class implementing the interface or an anonymous class instance of the interface can be used too.
What I need to consider is the return type and the ResultSet as I’m now trying to map the data in the ResultSet to a Java object (return type). So the mapper interface should look like.

package com.lckymn.kevin.tutorial.jdbc_better.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;

public interface RowMapper<T>
{
  T map(ResultSet resultSet) throws SQLException;
}

Notice that I’ve also added the throws clause having SQLException as using ResultSet requires it and that’s why we put try-catch block in our code using JDBC. The SQLException thrown in the map() method will be handled by the try-catch block in the main part of the JdbcManager select() method.

There is one last issue left. Now I need to take care of ignoring SQLException in the catch block.

}
catch (final SQLException e)
{
  e.printStackTrace();
}
finally

I can properly log it instead of just calling the printStackTrace() method in the SQLException, but it’s not enough. I don’t want to just ignore it as it may cause some serious issue in runtime. However, I don’t want to re-throw it either because then the caller of this method or “the caller of the caller” of the method or in the worst case, all the methods in the method call hierarchy have to deal with the SQLException. Thus I want to create my own unchecked exception (an exception that extends RuntimeException) which wraps the SQLException. It is beneficial not only because the caller of the method doesn’t need to catch or re-throw it but because it is also understandable by the caller of the method even after I decide not to use JDBC at all so it doesn’t have any SQLException any more. In this case, if I used SQLException, I would have to change the code in the caller-side as the caller would directly deal with it.

Here is my new Exception for data access.

package com.lckymn.kevin.tutorial.jdbc_better.exception;

public class DataAccessException extends RuntimeException
{
  private static final long serialVersionUID = 1L;

  public DataAccessException()
  {
  }

  public DataAccessException(final String message, final Throwable cause)
  {
    super(message, cause);
  }

  public DataAccessException(final String message)
  {
    super(message);
  }

  public DataAccessException(final Throwable cause)
  {
    super(cause);
  }
}

I also want to have another exception that extends it in order to indicate data access connection failure.

package com.lckymn.kevin.tutorial.jdbc_better.exception;

public class DataAccessConnectionFailureException extends DataAccessException
{
  private static final long serialVersionUID = 1L;

  public DataAccessConnectionFailureException(final Throwable cause)
  {
    super(cause);
  }
}

Finally one for general data access operation problems.

package com.lckymn.kevin.tutorial.jdbc_better.exception;

public class DataAccessOperationErrorException extends DataAccessException
{
  private static final long serialVersionUID = 1L;

  public DataAccessOperationErrorException()
  {
  }

  public DataAccessOperationErrorException(final String message, final Throwable cause)
  {
    super(message, cause);
  }

  public DataAccessOperationErrorException(final String message)
  {
    super(message);
  }

  public DataAccessOperationErrorException(final Throwable cause)
  {
    super(cause);
  }
}

I can replace the old code that prints stack trace with

}
catch (final SQLException e)
{
  throw new DataAccessOperationErrorException(e);
}
finally

So with all the solutions I mentioned above, my new code now becomes

public <T> List<T> select(final String sql,
                          final RowMapper<T> rowMapper,
                          final Object... parameters)
      throws DataAccessException
{
  Connection connection = null;
  PreparedStatement statement = null;
  ResultSet resultSet = null;

  final List<T> result = new ArrayList<T>();
  try
  {
    connection = getConnection();
    statement = connection.prepareStatement(sql);
    setParameters(statement, parameters);
    resultSet = statement.executeQuery();
    while (resultSet.next())
    {
      result.add(rowMapper.map(resultSet));
    }
  }
  catch (final SQLException e)
  {
    throw new DataAccessOperationFailureException(e);
  }
  finally
  {
    closeQuietly(connection, statement, resultSet);
  }
  return result;
}

It’s time to use it. Before using it, I’ll show my JdbcManager interface and the implementing class.

package com.lckymn.kevin.tutorial.jdbc_better.jdbc;

import java.util.List;

import com.lckymn.kevin.tutorial.jdbc_better.exception.DataAccessException;

/**
 * @author Lee, SeongHyun (Kevin) / <a href="http://blog.lckymn.com">Kevin&#39;s Blog</a>
 * @version 0.0.1 (2011-09-04)
 */
public interface JdbcManager
{
  <T> List<T> select(String sql, RowMapper<T> rowMapper, Object... parameters) throws DataAccessException;

  int update(final String sql, final Object... parameters) throws DataAccessException;
}

package com.lckymn.kevin.tutorial.jdbc_better.jdbc.impl;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.sql.DataSource;

import com.lckymn.kevin.tutorial.jdbc_better.exception.DataAccessConnectionFailureException;
import com.lckymn.kevin.tutorial.jdbc_better.exception.DataAccessException;
import com.lckymn.kevin.tutorial.jdbc_better.exception.DataAccessOperationErrorException;
import com.lckymn.kevin.tutorial.jdbc_better.jdbc.JdbcManager;
import com.lckymn.kevin.tutorial.jdbc_better.jdbc.RowMapper;

/**
 * @author Lee, SeongHyun (Kevin) / <a href="http://blog.lckymn.com">Kevin&#39;s Blog</a>
 * @version 0.0.1 (2011-09-04)
 */
public class JdbcManagerImpl implements JdbcManager
{
  private final DataSource dataSource;

  public JdbcManagerImpl(final DataSource dataSource)
  {
    this.dataSource = dataSource;
  }

  protected final Connection getConnection()
  {
    try
    {
      return dataSource.getConnection();
    }
    catch (final SQLException e)
    {
      throw new DataAccessConnectionFailureException(e);
    }

  }

  private void closeQuietly(final Connection connection,
                            final PreparedStatement statement,
                            final ResultSet resultSet)
  {
    if (null != resultSet)
      try { resultSet.close(); }
      catch (final SQLException e) { e.printStackTrace(); }

    if (null != statement)
      try { statement.close(); }
      catch (final SQLException e) { e.printStackTrace(); }

    if (null != connection)
      try { connection.close(); }
      catch (final SQLException e) { e.printStackTrace(); }
  }

  private void setParameters(final PreparedStatement statement, final Object... parameters) throws SQLException
  {
    for (int i = 0, length = parameters.length; i < length; i++)
    {
      final Object parameter = parameters[i];
      final int parameterIndex = i + 1;
      if (null == parameter)
      {
        statement.setObject(parameterIndex, null);
      }
      else if (parameter instanceof Boolean)
      {
        statement.setBoolean(parameterIndex, (Boolean) parameter);
      }
      else if (parameter instanceof Character)
      {
        statement.setString(parameterIndex, String.valueOf(parameter));
      }
      else if (parameter instanceof Byte)
      {
        statement.setByte(parameterIndex, (Byte) parameter);
      }
      else if (parameter instanceof Short)
      {
        statement.setShort(parameterIndex, (Short) parameter);
      }
      else if (parameter instanceof Integer)
      {
        statement.setInt(parameterIndex, (Integer) parameter);
      }
      else if (parameter instanceof Long)
      {
        statement.setLong(parameterIndex, (Long) parameter);
      }
      else if (parameter instanceof Float)
      {
        statement.setFloat(parameterIndex, (Float) parameter);
      }
      else if (parameter instanceof Double)
      {
        statement.setDouble(parameterIndex, (Double) parameter);
      }
      else if (parameter instanceof String)
      {
        statement.setString(parameterIndex, (String) parameter);
      }
      else if (parameter instanceof Date)
      {
        statement.setDate(parameterIndex, new java.sql.Date(((Date) parameter).getTime()));
      }
      else if (parameter instanceof Calendar)
      {
        statement.setDate(parameterIndex, new java.sql.Date(((Calendar) parameter).getTimeInMillis()));
      }
      else if (parameter instanceof BigDecimal)
      {
        statement.setBigDecimal(parameterIndex, (BigDecimal) parameter);
      }
      else
      {
        throw new IllegalArgumentException(String.format(
            "Unknown type of the parameter is found. [param: %s, paramIndex: %s]", parameter, parameterIndex));
      }
    }
  }

  @Override
  public <T> List<T> select(final String sql,
                            final RowMapper<T> rowMapper,
                            final Object... parameters)
      throws DataAccessException
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<T> result = new ArrayList<T>();
    try
    {
      connection = getConnection();
      statement = connection.prepareStatement(sql);
      setParameters(statement, parameters);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        result.add(rowMapper.map(resultSet));
      }
    }
    catch (final SQLException e)
    {
      throw new DataAccessOperationErrorException(e);
    }
    finally
    {
      closeQuietly(connection, statement, resultSet);
    }
    return result;
  }

  // the rest code omitted...
}

Then my AbstractDao now has the JdbcManager.

package com.lckymn.kevin.tutorial.jdbc_better.dao;

import com.lckymn.kevin.tutorial.jdbc_better.jdbc.JdbcManager;

/**
 * @author Lee, SeongHyun (Kevin) / <a href="http://blog.lckymn.com">Kevin&#39;s Blog</a>
 * @version 0.0.1 (2011-09-04)
 */
public abstract class AbstractDao
{
  private JdbcManager jdbcManager;

  public AbstractDao(final JdbcManager jdbcManager)
  {
    this.jdbcManager = jdbcManager;
  }

  protected final JdbcManager jdbcManager()
  {
    return jdbcManager;
  }
}

So the old DAO methods now look like

@Override
public Person find(final Long id)
{
  final List<Person> result =
    jdbcManager().select("SELECT * FROM people WHERE person_id = ?", new RowMapper<Person>() {

      @Override
      public Person map(final ResultSet resultSet) throws SQLException
      {
        final Person person = new Person();
        person.setId(resultSet.getLong("person_id"));
        person.setSurname(resultSet.getString("surname"));
        person.setGivenName(resultSet.getString("given_name"));
        final Address address =
            new Address(resultSet.getString("street"),
                resultSet.getString("city"),
                resultSet.getString("state"),
                resultSet.getString("country"),
                resultSet.getString("postcode"));
        person.setAddress(address);
        person.setBirthday(new Date(resultSet
                              .getDate("birthday")
                              .getTime()));
        return person;
      }
    }, id);
  return result.isEmpty() ? null : result.get(0);
}

@Override
public List<Person> findPeopleByState(final String state)
{
  return jdbcManager().select("SELECT * FROM people WHERE state = ?", new RowMapper<Person>() {

    @Override
    public Person map(final ResultSet resultSet) throws SQLException
    {
      final Person person = new Person();
      person.setId(resultSet.getLong("person_id"));
      person.setSurname(resultSet.getString("surname"));
      person.setGivenName(resultSet.getString("given_name"));
      final Address address =
          new Address(resultSet.getString("street"),
              resultSet.getString("city"),
              resultSet.getString("state"),
              resultSet.getString("country"),
              resultSet.getString("postcode"));
      person.setAddress(address);
      person.setBirthday(new Date(resultSet
                            .getDate("birthday")
                            .getTime()));
      return person;
    }
  }, state);
}

Oh, I can see the RowMapper anonymous classes used in the both methods are the same therefore I can declare constant variable for it and both can just use it.
So my new PersonDaoImpl is

package com.lckymn.kevin.tutorial.jdbc_better.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;

import com.lckymn.kevin.tutorial.jdbc_better.beans.Address;
import com.lckymn.kevin.tutorial.jdbc_better.beans.Person;
import com.lckymn.kevin.tutorial.jdbc_better.dao.AbstractDao;
import com.lckymn.kevin.tutorial.jdbc_better.dao.PersonDao;
import com.lckymn.kevin.tutorial.jdbc_better.jdbc.JdbcManager;
import com.lckymn.kevin.tutorial.jdbc_better.jdbc.RowMapper;

/**
 * @author Lee, SeongHyun (Kevin) / <a href="http://blog.lckymn.com">Kevin&#39;s Blog</a>
 * @version 0.0.1 (2011-09-04)
 */
public class PersonDaoImpl extends AbstractDao implements PersonDao
{
  private static final RowMapper<Person> PERSON_MAPPER = new RowMapper<Person>() {
    @Override
    public Person map(final ResultSet resultSet) throws SQLException
    {
      final Person person = new Person();
      person.setId(resultSet.getLong("person_id"));
      person.setSurname(resultSet.getString("surname"));
      person.setGivenName(resultSet.getString("given_name"));
      final Address address =
          new Address(resultSet.getString("street"),
              resultSet.getString("city"),
              resultSet.getString("state"),
              resultSet.getString("country"),
              resultSet.getString("postcode"));
      person.setAddress(address);
      person.setBirthday(new Date(resultSet
                            .getDate("birthday")
                            .getTime()));
      return person;
    }
  };

  public PersonDaoImpl(final JdbcManager jdbcManager)
  {
    super(jdbcManager);
  }

  @Override
  public Person find(final Long id)
  {
    final List<Person> result = jdbcManager().select("SELECT * FROM people WHERE person_id = ?", PERSON_MAPPER, id);
    return result.isEmpty() ? null : result.get(0);
  }

  @Override
  public List<Person> findPeopleByState(final String state)
  {
    return jdbcManager().select("SELECT * FROM people WHERE state = ?", PERSON_MAPPER, state);
  }

  @Override
  public List<Person> getAllPeople()
  {
    return jdbcManager().select("SELECT * FROM people", PERSON_MAPPER);
  }
}

Wow! It’s really simple now! Just passing an SQL query and parameters with a RowMapper.

OK, it’s good, but what happens if I want to insert or update or delete data from the database? The JdbcManager interface has the method signature for these but how can I implement it?
It would be simple too.

private void rollback(final Connection connection)
{
  if (null != connection)
  {
    try
    {
      connection.rollback();
    }
    catch (final SQLException e)
    {
      e.printStackTrace();
    }
  }
}

@Override
public int update(final String sql, final Object... parameters)
    throws DataAccessException
{
  Connection connection = null;
  PreparedStatement statement = null;

  try
  {
    connection = getConnection();
    connection.setAutoCommit(false);
    statement = connection.prepareStatement(sql);
    setParameters(statement, parameters);
    final int result = statement.executeUpdate();
    connection.commit();
    return result;
  }
  catch (final DataAccessException e)
  {
    rollback(connection);
    throw e;
  }
  catch (final Exception e)
  {
    rollback(connection);
    throw new DataAccessOperationErrorException(e);
  }
  finally
  {
    closeQuietly(connection, statement, null);
  }
}

Turn off auto commit so the changes can be rolled back if any Exception is thrown.

There is still room for improvement in JdbcManagerImpl. Instead of having the setParameters() method to set parameter values to the Statement, Strategy pattern can be used so that the user of JdbcManager can later inject an object that sets the parameters so how to handle the parameters can be decided by the user of the API.

package com.lckymn.kevin.tutorial.jdbc_better.jdbc;

import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author Lee, SeongHyun (Kevin) / <a href="http://blog.lckymn.com">Kevin&#39;s Blog</a>
 * @version 0.0.1 (2011-09-04)
 */
public interface PreparedStatementParameterSetter
{
  void setParameters(final PreparedStatement statement, final Object... parameters) throws SQLException;
}

public class JdbcManagerImpl implements JdbcManager
{
  private final DataSource dataSource;
  private final PreparedStatementParameterSetter preparedStatementParameterSetter;

  public JdbcManagerImpl(DataSource dataSource, PreparedStatementParameterSetter preparedStatementParameterSetter)
  {
    this.dataSource = dataSource;
    this.preparedStatementParameterSetter = preparedStatementParameterSetter;
  }

  // code omitted...

  @Override
  public <T> List<T> select(final String sql,
                            final RowMapper<T> rowMapper,
                            final Object... parameters)
      throws DataAccessException
  {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    final List<T> result = new ArrayList<T>();
    try
    {
      connection = getConnection();
      statement = connection.prepareStatement(sql);
      preparedStatementParameterSetter.setParameters(statement, parameters);
      resultSet = statement.executeQuery();
      while (resultSet.next())
      {
        result.add(rowMapper.map(resultSet));
      }
    }
    catch (final SQLException e)
    {
      throw new DataAccessOperationErrorException(e);
    }
    finally
    {
      closeQuietly(connection, statement, resultSet);
    }
    return result;
  }
  
  // ... the rest omitted.
}

I think it’s enough to learn the better way to use JDBC. What I’ve explained here can be useful for solving other problems too (e.g. reading and writing files).
The code I’ve posted here is not production-ready. It’s solely for educational purpose. If you want to use it in practice, I recommend already existing libraries and frameworks which provide what I’ve explained here. These are well tested so are likely to be better than my in-house JdbcManager. If you use or are willing to use the Spring Framework, you can use its JdbcTemplate. If you don’t or cannot use the Spring Framework, you can choose Apache Commons DbUtils.

=================================================================
The source code of “Easier and Better Way to Use JDBC” is available ->HERE<-.

Call-by-reference means a reassigned reference to a method parameter variable is visible by the caller of the method which means if a new object reference is assigned to the parameter variable in a method then caller will have the newly assigned one after execution of the method whereas call-by-sharing means the new reference is not visible by the caller. Thus the old reference will still remain after calling the method. That means if a new reference is assigned to the parameter variable, it is visible just within the method thus after execution of the method, the caller will still get the old reference so the same old object.

The people who do not understand the difference between call-by-reference and call-by-sharing do probably not know the difference between assigning a new reference to a variable and changing the state of an object the reference of which is stored in the variable. I guess, it is presumably caused by their ignorance about a reference of object and the actual object. They perhaps think a variable is an object itself or that contains an object, yet the variable does not contain an object but the reference of an object. So when we use a variable to change the state of an object or use the methods in it, we are not directly having the actual object but are using the reference of the object stored in the variable in order to access the object.

To sum up, Java uses call-by-sharing NOT call-by-reference. The difference between call-by-reference and call-by-sharing is

call-by-reference: You are able to assign a new reference to a method parameter variable in a method, and it will be visible by the caller of the method so after calling the method, the caller will get the new reference (new object).

call-by-sharing: You are able to assign a new reference to a method parameter variable in a method, BUT it will NOT be visible by the caller of the method so after calling the method, the caller will still get the same old reference which was passed as a method parameter to the method.

In both evaluation strategies, you have access to the reference so are able to change the state of the object the reference of which is stored in the parameter variable if the object is mutable. Therefore it is possible to change the values of the object member variables in the method and these changes are visible by the caller but the caller still see the same old object with a different state from the state it had before calling the method.

These quizzes remind me of my childhood as these kinds of quizzes are what I used to solve when I was a primary schoolchild. It was approximately 22 years ago. That time, I learned Basic (Not Visual Basic (VB), VB didn’t exist back then), Fortran, COBOL and C. When I was learning Basic, those kinds of problems were what I solved. After I graduated from the primary school, I had not touched any computer programming languages at all for 13 years. I started it again as I came to Sydney and entered the university to study IT. Then I realised that I could remember nothing about what I learned before. Nothing at all. That’s why my ‘about me‘ page doesn’t contain any of Basic, Fortran and COBOL since I’ve completely forgot about these (it does have Visual Basic though as it’s my first programming language that I learned at the diploma school, UTS:INSEARCH). So my point is, doesn’t matter whether it’s a programming language or a human language, if you don’t practice or keep studying constantly, you will lose your skills and fluency of the language.

Anyway, I saw those quizzes and solved it for fun yet feel like I did better when I was a kid. Back then, I didn’t even use a computer to solve it but only pen and paper.
The followings are the quizzes and my answers, yet there can be much better answers of course, so why don’t you try by yourself before you check out mine.

This is the prompt utility class, used for the other programmes, to get input values. Notice that it doesn’t check whether the input value is number, integer more precisely, or not although it does check if the given integer is a positive one.

package com.lckymn.kevin.simplequiz;

import java.util.Scanner;

/**
 * @author Lee, SeongHyun (Kevin)
 * @version 0.0.1 (2010-05-05)
 */
public final class PromptUtil
{
    private PromptUtil()
    {
        throw new IllegalStateException(getClass().getName() + " cannot be instantiated.");
    }

    public static int askForPositiveInt(String message)
    {
        final Scanner scanner = new Scanner(System.in);
        System.out.print(message);
        int number = Integer.parseInt(scanner.nextLine());

        while (0 >= number)
        {
            System.out.println("Please enter a position integer.");
            System.out.print(message);
            number = Integer.parseInt(scanner.nextLine());
        }
        return number;
    }
}

Quiz 1. (taken from http://xeraph.com/5251248)

n for diamond? 3

  *
 ***
*****
 ***
  *

n for diamond? 5

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

n for diamond? 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
 ***********
  *********
   *******
    *****
     ***
      *

n for diamond? 9

        *
       ***
      *****
     *******
    *********
   ***********
  *************
 ***************
*****************
 ***************
  *************
   ***********
    *********
     *******
      *****
       ***
        *

* Kevin’s Answer1

[[Visit blog to check out this spoiler]]

* Kevin’s Answer2

[[Visit blog to check out this spoiler]]

Quiz 2. (taken from http://xeraph.com/5251248)

n for outer box? 4
m for inner box? 2

****
*  *
*  *
****

n for outer box? 7
m for inner box? 3

*******
*******
**   **
**   **
**   **
*******
*******

n for outer box? 10
m for inner box? 4

**********
**********
**********
***    ***
***    ***
***    ***
***    ***
**********
**********
**********

n for outer box? 12
m for inner box? 6

************
************
************
***      ***
***      ***
***      ***
***      ***
***      ***
***      ***
************
************
************

* Kevin’s Answer

[[Visit blog to check out this spoiler]]

Quiz 3. (taken from http://xeraph.com/5251248)

n for outer triangle? 3
m for inner triangle? 1

  *
 ***
** **

n for outer triangle? 5
m for inner triangle? 3

    *
   ***
  ** **
 **   **
**     **

n for outer triangle? 8
m for inner triangle? 4

       *
      ***
     *****
    *******
   **** ****
  ****   ****
 ****     ****
****       ****

n for outer triangle? 10
m for inner triangle? 5

         *
        ***
       *****
      *******
     *********
    ***** *****
   *****   *****
  *****     *****
 *****       *****
*****         *****

* Kevin’s Answer

[[Visit blog to check out this spoiler]]

Quiz 4. (taken from http://xeraph.com/5261697)

matrix size n? 5
  1   2   3   4   5
 16  17  18  19   6
 15  24  25  20   7
 14  23  22  21   8
 13  12  11  10   9

matrix size n? 6
  1   2   3   4   5   6
 20  21  22  23  24   7
 19  32  33  34  25   8
 18  31  36  35  26   9
 17  30  29  28  27  10
 16  15  14  13  12  11

matrix size n? 7
  1   2   3   4   5   6   7
 24  25  26  27  28  29   8
 23  40  41  42  43  30   9
 22  39  48  49  44  31  10
 21  38  47  46  45  32  11
 20  37  36  35  34  33  12
 19  18  17  16  15  14  13

matrix size n? 8
  1   2   3   4   5   6   7   8
 28  29  30  31  32  33  34   9
 27  48  49  50  51  52  35  10
 26  47  60  61  62  53  36  11
 25  46  59  64  63  54  37  12
 24  45  58  57  56  55  38  13
 23  44  43  42  41  40  39  14
 22  21  20  19  18  17  16  15

* Kevin’s Answer1

[[Visit blog to check out this spoiler]]

* Kevin’s Answer2

[[Visit blog to check out this spoiler]]

I have been very busy and am still busy so haven’t written anything for quite a while on my blog except for those entries with only one or two sentences. So I’m quickly writing what I do these days and some issues I have dealt with.

1. Issue with the new m2eclipse (version: 0.10.0.20100209-0800)

Sonatype released the new version of m2eclipse in February 2010. Since I updated with it, I had got some problem with maven build through Hudson.

The new version of m2eclipse comes with maven3 embedded yet my server uses maven2 so does my Linux on my Desktop PC. So it was only m2eclipse which uses maven3 (SNAPSHOT version) and I deployed some of my libraries used in one web application development project. Problem was that I deployed the dependency libraries several times with the same version number. With maven2, it’s OK as it uses time-stamp to distinguish one version from another within the same version, yet with maven3, having the same version is not allowed. Well, I am not 100% sure about this as once I solved the problem I didn’t really check the details as I didn’t have enough time. Anyway, so as shown in the following image, the project status icon once became dark rain clouds which mean really bad.

Build Failure: Project status icon became dark rain clouds

My project build failed seven times due to the difference between maven2 and maven3 I described above, or it can be something else yet it is caused by some difference between those two versions.

Build Failure: It failed seven times due to the difference between maven2 and maven3

So why did I not just keep the old version of m2eclipse with maven2 embedded? Well, the old one comes with some old version of maven2 which does not support password encryption while the maven2 on both my PC and my server does support it as it is a newer version. Thus I updated with the new m2eclipse as soon as it was available yet didn’t really expect that it comes with maven3. Anyway, It’s solved by using maven2 installed on my PC when deploying project packages. The other times such as solving dependencies and building package without deployment, I can still use the embedded maven3 in the new m2eclipse without any problems.

2. I have been working on…

I founded a start-up company with my friend a few months ago, and we are currently working on a web application development for our own start-up, but it is probably too premature to announce what it is as it’s still an early stage of development.
The issues listed in the following image is a part of the issues I and my colleague have solved and been working on.

I'm currently working on this project.

In addition, I have been developing my own Java libraries which can be commonly used in many other projects (and my friend has also been developing reusable JavaScript libraries). However, I did not record all the issues belong to these reusable components and recently felt that I should do it before I go any further. Otherwise, I may later forget what problems I solved and how I did as well as all the issues covered previously. So I wrote all the tickets for those libraries.

Issues of commonly used libraries built by myself

I’ve also been developing ‘Java object to JSON’ library and did the same as what I just explained (that is creating issue tickets). There are already a number of the libraries which convert Java object into JSON so why would I make another? Well, there can be several reasons but major ones are

1. I need it to convert any POJO with only annotations into JSON.
2. It has to be simple as I do not want to have any complex functions or heavy library for a simple conversion (some libraries are too heavy for such a simple task).
3. When customisation is required or bug is found in the library, I want to be able to change and fix it however I want so that I do not have to waste my time on waiting for others to solve it.
4. I want it to work in some environments where using bytecode manipulation is not an option. So if I programme one with bytecode manipulation then it works faster when it’s available whereas the other one is without it so that it can be used in those enviornments (I currently have only the latter one and will do the former one when I have time later).

The following issues are what I have solved for the Java to JSON library.

Issues of my Java object to JSON library

Finally, I have another project to help Ajax enabled web application development. From my experience, I found that it is sharing the information about the available server-side functions with the client-side developers that causes the most waste of time between the front-end development and the back-end development. The first time one function is made or whenever the existing ones are changed, I have to write or rewrite the document explaining it and the client-side developer has to find the changed parts in the document. It is annoying and a non-productive moment in the development so I and my colleague discussed about this issue and came up with the idea of having a library which exposes all the available server-side functions to the front-end (It can understand Spring @MVC controllers). For now, it has only this, yet I will add more features to help Ajax web application development.

Issues of my web method library

* As I used more and more reflection to develop those libraries, I realised that Java Reflection has no method to get the names of method parameters. Well, there can be some ways for instance, using -g (generating debugging info) option when compiling or using some libraries such as ASM or use ParaNamer (It requires an additional step when compiling to add the constants having the parameter names in the class) but not by just Java reflection. Anyway, none of these is the solution I want, and unfortunately if I heard right, this problem will remain in JDK 7.

3. Bug in Java compiler? Shadowing Declarations?

I created the Objects utility class based on http://download.java.net/jdk7/docs/api/java/util/Objects.html. This will be available in JDK 7 yet I wanted to use it before JDK 7 is released so I made my own one. I can use it now, and it can easily be replaced by the one in JDK when it’s available. After I made it, I found some weird bug, I believe, in Java compiler. After I used it, I had some problem and thought it could be a bug in Java compiler yet it looks like ‘shadowing declarations’.

This is the part of Objects class I coded.

package com.lckymn.kevin.common.util;

/**
 * @author Lee, SeongHyun (Kevin)
 * @version 0.0.1 (2010-04-30)
 */
public final class Objects
{
    private Objects()
    {
        throw new IllegalStateException(getClass().getName() + " cannot be instantiated.");
    }

    // other code omitted ...

    /**
     * Returns the hash code of a non-{@code null} argument and 0 for a {@code null} argument.
     * 
     * @param o
     *            an object
     * @return the hash code of a non-{@code null} argument and 0 for a {@code null} argument
     * @see {@link Object#hashCode()}
     */
    public static int hashCode(final Object o)
    {
        return (null == o ? 0 : o.hashCode());
    }

    // other code omitted ...
}

The following code is a POJO in which I want to use the Objects.hashCode(Object) method.

package com.lckymn.kevin.test.bean;

/**
 * @author Lee, SeongHyun (Kevin)
 * @version 0.0.1 (2010-04-30)
 */
public class SomePojo
{
    private final int number;
    private final String name;

    public SomePojo(int number, String name)
    {
        this.number = number;
        this.name = name;
    }

    public int getNumber()
    {
        return number;
    }

    public String getName()
    {
        return name;
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + number;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (!(obj instanceof SomePojo))
        {
            return false;
        }
        final SomePojo that = (SomePojo) obj;
        return (this.number == that.getNumber())
                && (this.name == that.getName() || 
                        (null != this.name && this.name.equals(that.getName())));
    }
}

So I changed this code snippet

@Override
public int hashCode()
{
    final int prime = 31;
    int result = 1;
    result = prime * result + number;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

to this.

package com.lckymn.kevin.test.bean;

import static com.lckymn.kevin.common.util.Objects.*;

public class SomePojo
{
    // ...

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

I used static import and hashCode(Object) method in the Objects class. Although, nothing’s wrong in the code, my Eclipse complains that there is a compile-time error. The following image shows that.

Objects.hashCode(Object) with static import does not work.

Yet the same code with no-static import but using class name as the qualifier to use hashCode(Object) method works perfectly. The following code has Objects.hashCode(name) and no compile-time error.

package com.lckymn.kevin.test.bean;

import com.lckymn.kevin.common.util.Objects;

/**
 * @author Lee, SeongHyun (Kevin)
 * @version 0.0.1 (2010-04-30)
 */
public class SomePojo
{
    private final int number;
    private final String name;

    public SomePojo(int number, String name)
    {
        this.number = number;
        this.name = name;
    }

    public int getNumber()
    {
        return number;
    }

    public String getName()
    {
        return name;
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + number;
        result = prime * result + Objects.hashCode(name);
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (null == obj)
        {
            return false;
        }
        if (!(obj instanceof SomePojo))
        {
            return false;
        }
        final SomePojo that = (SomePojo) obj;
        return (this.number == that.getNumber())
                && (this.name == that.getName() || (null != this.name && this.name.equals(that.getName())));
    }
}

The following image shows it has no error in the part where Objects.hashCode(Object) is used..

Using Class as qualifier to use hashCode works.

I wondered if it’s a bug in the Eclipse or a bug in the Java compiler. So I opened the terminal and tested it.

$ javac -version
javac 1.6.0_15


$ javac com/lckymn/kevin/test/bean/SomePojo.java
com/lckymn/kevin/test/bean/SomePojo.java:39: cannot find symbol
symbol  : method hashCode(java.lang.String)
location: class com.lckymn.kevin.test.bean.SomePojo
        result = prime * result + hashCode(name);
                                  ^
com/lckymn/kevin/test/bean/SomePojo.java:39: operator + cannot be applied to int,hashCode
        result = prime * result + hashCode(name);
                       ^
com/lckymn/kevin/test/bean/SomePojo.java:39: incompatible types
found   : <nulltype>
required: int
        result = prime * result + hashCode(name);
                                ^
3 errors

As it shows, the compiler does totally not understand that the hashCode(Object) method from the Objects class is available and valid.

Is a bug only in the SUN JDK in the Ubuntu Linux repository? So I tried with OpenJDK 6 as well.

$ /usr/lib/jvm/java-6-openjdk/bin/javac -version
javac 1.6.0_0

$ /usr/lib/jvm/java-6-openjdk/bin/javac com/lckymn/kevin/test/bean/SomePojo.java 
com/lckymn/kevin/test/bean/SomePojo.java:39: cannot find symbol
symbol  : method hashCode(java.lang.String)
location: class com.lckymn.kevin.test.bean.SomePojo
        result = prime * result + hashCode(name);
                                  ^
com/lckymn/kevin/test/bean/SomePojo.java:39: operator + cannot be applied to int,hashCode
        result = prime * result + hashCode(name);
                       ^
com/lckymn/kevin/test/bean/SomePojo.java:39: incompatible types
found   : <nulltype>
required: int
        result = prime * result + hashCode(name);
                                ^
3 errors

The same result…

OK, it might be a bug in that particular version. Fortunately, the most recent version of SUN JDK 6 was released yesterday. It was officially released before (the 15th of April, 2010) yet the version managed by Ubuntu was not available before yesterday. So I installed it and tested it again with the Java compiler in the new JDK6.

New version of SUN JDK6 is available in the Ubuntu repository

It still has the same problem.

$ javac -version
javac 1.6.0_20

$ javac com/lckymn/kevin/test/bean/SomePojo.java
com/lckymn/kevin/test/bean/SomePojo.java:39: cannot find symbol
symbol  : method hashCode(java.lang.String)
location: class com.lckymn.kevin.test.bean.SomePojo
        result = prime * result + hashCode(name);
                                  ^
com/lckymn/kevin/test/bean/SomePojo.java:39: operator + cannot be applied to int,hashCode
        result = prime * result + hashCode(name);
                       ^
com/lckymn/kevin/test/bean/SomePojo.java:39: incompatible types
found   : <nulltype>
required: int
        result = prime * result + hashCode(name);
                                ^
3 errors

I probably need to test with the Java compiler in the JDK6 for Windows but I have no stomach for that now nor do I have time to do that.

package com.lckymn.kevin.common.util;

public final class SomeHelper
{
    private SomeHelper()
    {
        throw new IllegalStateException(getClass().getName() + " cannot be instantiated.");
    }
    
    public static void test(Object... object)
    {
        System.out.println("SomeHelper.test()");
    }
}

package com.lckymn.kevin.test;

import static com.lckymn.kevin.common.util.SomeHelper.test;

public class Test
{
    public void test()
    {
        System.out.println("Test.test()");
    }

    public void callTest()
    {
        test();            // no error here.

        Object object = new Object();
        test(object);    // compile-time error
    }
}

package com.lckymn.kevin.test;

import static com.lckymn.kevin.common.util.SomeHelper.test;

public class Test
{
    public void test()
    {
        System.out.println("Test.test()");
    }

    public void callTest()
    {
        test();    // static import of SomeHelper.test has no effect here.
    }
    
    public static void main(String[] args)
    {
        new Test().callTest();
        System.exit(0);
    }
}

package com.lckymn.kevin.common.util;

public final class SomeHelper
{
    private SomeHelper()
    {
        throw new IllegalStateException(getClass().getName() + " cannot be instantiated.");
    }
    
    public static void test()
    {
        System.out.println("SomeHelper.test()");
    }
}

package com.lckymn.kevin.test;

import static com.lckymn.kevin.common.util.SomeHelper.test;

public class Test
{
    public void test(Object... object)
    {
        System.out.println("Test.test(Object...object)");
    }

    public void callTest()
    {
        test(); // it calls the Test.test(Object... object) method NOT SomeHelper.test().
    }

    public static void main(String[] args)
    {
        new Test().callTest();
        System.exit(0);
    }
}

4. Using Objects

By the way, the Objects class is simple but very useful.
with it, the highlighted parts of the following code can

package com.lckymn.kevin.test.bean;

public class Bank
{
    private Long id;
    private String bankName;
    private String bsbNumber;
    private String address;

    public Long getId()
    {
        return id;
    }

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

    public String getBankName()
    {
        return bankName;
    }

    public void setBankName(String bankName)
    {
        this.bankName = bankName;
    }

    public String getBsbNumber()
    {
        return bsbNumber;
    }

    public void setBsbNumber(String bsbNumber)
    {
        this.bsbNumber = bsbNumber;
    }

    public String getAddress()
    {
        return address;
    }

    public void setAddress(String address)
    {
        this.address = address;
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((bankName == null) ? 0 : bankName.hashCode());
        result = prime * result + ((bsbNumber == null) ? 0 : bsbNumber.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object bank)
    {
        if (this == bank)
        {
            return true;
        }
        if (!(bank instanceof Bank))
        {
            return false;
        }
        final Bank that = (Bank) bank;
        return (this.bankName == that.getBankName() || 
               (null != this.bankName && this.bankName.equals(that.getBankName())))
                && (this.bsbNumber == that.getBsbNumber() || 
                   (null != this.bsbNumber && this.bsbNumber.equals(that.getBsbNumber())));
    }
}

become like this

package com.lckymn.kevin.test.bean;

import com.lckymn.kevin.common.util.Objects;

public class Bank
{
    private Long id;
    private String bankName;
    private String bsbNumber;
    private String address;

    public Long getId()
    {
        return id;
    }

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

    public String getBankName()
    {
        return bankName;
    }

    public void setBankName(String bankName)
    {
        this.bankName = bankName;
    }

    public String getBsbNumber()
    {
        return bsbNumber;
    }

    public void setBsbNumber(String bsbNumber)
    {
        this.bsbNumber = bsbNumber;
    }

    public String getAddress()
    {
        return address;
    }

    public void setAddress(String address)
    {
        this.address = address;
    }

    @Override
    public int hashCode()
    {
        return Objects.hash(bankName, bankName);
    }

    @Override
    public boolean equals(Object bank)
    {
        if (this == bank)
        {
            return true;
        }
        if (!(bank instanceof Bank))
        {
            return false;
        }
        final Bank that = (Bank) bank;
        return Objects.equals(this.bankName, that.getBankName()) 
               && Objects.equals(this.bsbNumber, that.getBsbNumber());
    }
}

So these five lines in the hashCode method

final int prime = 31;
int result = 1;
result = prime * result + ((bankName == null) ? 0 : bankName.hashCode());
result = prime * result + ((bsbNumber == null) ? 0 : bsbNumber.hashCode());
return result;

become

return Objects.hash(bankName, bankName);

and these four lines in the equals method

return (this.bankName == that.getBankName() || 
       (null != this.bankName && this.bankName.equals(that.getBankName())))
        && (this.bsbNumber == that.getBsbNumber() || 
           (null != this.bsbNumber && this.bsbNumber.equals(that.getBsbNumber())));

become

return Objects.equals(this.bankName, that.getBankName()) 
       && Objects.equals(this.bsbNumber, that.getBsbNumber());

Although one might say that I can use Lombok instead, I prefer to see what is going on in my code. Those hashCode and equals methods are not additional info of the class. It tells what makes instances of the class equal thus I prefer to have it in there to see and want to freely change it whenever and however I want. Well, in other words, just a matter of personal preference.
That’s it.
I perhaps have more to say yet am getting tired (4:55 AM :O). So I’m calling it a night.

Code Bubbles - Cool Java IDE

Seeing is believing so just visit http://www.andrewbragdon.com/codebubbles_site.asp and watch the video.
What an awesome IDE!!!

Download Page: Google Collections Library 1.0 – FINAL

Maven users can simply add the following dependency info to use Google Collections Library 1.0 – FINAL.

<dependency>
	<groupId>com.google.collections</groupId>
	<artifactId>google-collections</artifactId>
	<version>1.0</version>
	<type>jar</type>
	<scope>compile</scope>
</dependency>

It’s a question to find an algorithm that gives the highest floor where you can drop a water balloon without breaking it at a 100 story building. You have only two balloons. I had actually seen this problem before and solved it already. It was not balloons but eggs. The solution is simple. Since if you miss two chances then have no balloons available, you need to try from the lowest safe level which means throw it from the first floor then if it does not pop, pick it up and go up to the level 2 and repeat it until the balloon pops. When you get the level from which the balloon bursts after dropping it, one level below this level is the highest safe level. (e.g. If the balloon first breaks on the 20th floor, the highest safe floor is the 19th).

It’s easy isn’t it? Yet the post above has one more condition to make it a little bit more difficult which is that you can try only 15 times. This means if I try the solution I’ve just described, I can test up to only the 15th floor. If the breaking point is the 40th floor or even the 16th floor, I’ll never know it. When I first saw it, I tried to solve it for about five minutes yet couldn’t solve it. That time, I was too busy to think about it further thus couldn’t be bothered to do it. So I saved the URI of the post and forgot about it. Last night, no actually today morning, at approximately 6 am, I went to bed (yeah, am I a vampire or what? ). Although I didn’t even try to think about the problem yet all of sudden I came up with the answer of that question. It was just like the ‘Eureka‘ story of Archimedes. Just like he figured out how to assess the purity of a golden crown when he stepped into a bath. OK, stop flattering myself I figured it out as the question was easy to solve.

Well, an important point here is that I in fact often find solutions to some difficult problems when I am not struggling to solve it yet am doing something irrelevant to the problem such as working out at the gym, washing dishes after a meal, lying on the bed to sleep or even when I’m dreaming. So if you can’t solve some problem then why don’t you try something else rather than thinking about the solution all the time. Your brain may need to relax or when you use the other parts of the brain by doing something else, it might figure it out.

Anyway, here is what my brain told me that time.

Since I have only two balloons, if I choose a wrong floor twice, I lose all the chances. Then what if I check every second level as I have two balloons. So first, if I drop it from the second level and it breaks then I still have one more balloon so that I can try it from the first level and I can find if the highest safe level is the first or there is no safe level. If the balloon is fine after dropping it from the second level then I can pick it up and try it from the fourth level and so on. However, with this solution I can check at most until the 30th floor which is better than checking up to the 15th one but still not enough to check the 100 stories. This means that it is not sufficient to check ever second level in order to find the floor and I should focus on not only the two balloons but also the 15 times of attempts. From the first solution above, I know that I can definitely have 15 times if I try from the lowest safe floor and move up. It means if the number of floors between the already known highest safe level and the breaking point level found is the same as or fewer than the number of attempts I still have, I can find the very first level where the balloon bursts after dropping it (In order to reduce the number of attempts, of course, I have to make it the same as the number of attempts still left). Therefore I can tell the highest safe level that is one level below the breaking point level found. This should be easier to understand with an example.

Let’s assume that the breaking point is the 17th floor.

At first, I have 15 tries to drop one balloon from the 15th floor.
The balloon’s still OK and I now have 14 times of attempts. Since the number of attempts I still have is 14 time, I can’t try it from the 30th floor which is 15 + 15 yet I have to try it from the 29th floor (15 + 14). Because the breaking point is the 17th floor, the balloon breaks on the 29th floor. Now I have 13 times of attempts and 1 balloon left. From the first try, I know the 14th floor is fine so I try from the next floor that is floor 15 to see if floor 14 is the highest safe floor. It turns out the 15th one is fine and now I have 12 times left. 16th -> OK / 11 times left, 17th -> it breaks! / 10 times left
So I can tell the 16th floor is the highest safe floor and I didn’t even use all the 15 times of attempts.

The post that has the question specifies the floor starts from 0 so let’s make the first floor is floor 0 and see have it works. I made a table which shows the number of attempts required to find the highest safe floor.

====================================================
 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15   tries
====================================================
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14	- 1
15 16 17 18 19 20 21 22 23 24 25 26 27 28		- 2
29 30 31 32 33 34 35 36 37 38 39 40 41			- 3
42 43 44 45 46 47 48 49 50 51 52 53				- 4
54 55 56 57 58 59 60 61 62 63 64				- 5
65 66 67 68 69 70 71 72 73 74					- 6
75 76 77 78 79 80 81 82 83						- 7
84 85 86 87 88 89 90 91							- 8
92 93 94 95 96 97 98							- 9
99												- 10

So if the highest safe floor is 73. The first balloon breaks on the floor 74 after 6 times of attempts. After that try from the floor 65 (attempts: 7) through 66 (8), 67 (9), 68 (10), 69 (11), 70 (12), 71 (13), 72 (14) to 73 (15) and the second balloon hasn’t broken so I can tell the highest safe floor is the floor 73.

====================================================
 1  2  3  4  5  6  7  8[ 9]10 11 12 13 14 15
====================================================
65 66 67 68 69 70 71 72[73]74					-[6]

attempts: 6 times to get the floor 74 + 9 times to check until the floor 73 = 15 times.

Once I found the solution writing code is a piece of cake.
I roughly wrote the main part of the code like this.

private static final int MAX_ATTEMPTS = 15;

private int theFloor = (int) (Math.random() * 100);
private int numberOfBalloons = 2;
private int numberOfAttempts = 0;

// ...


public void findHighestSafeFloor()
{
	int previousFloorIndex = -1;
	int floorIndex = MAX_ATTEMPTS - 1;
	int highestSafeFloor = 0;

	while (MAX_ATTEMPTS > numberOfAttempts)
	{
		numberOfAttempts++;
		if (theFloor <= floorIndex)
		{
			numberOfBalloons--;
			highestSafeFloor = findHighestSafeFloor(previousFloorIndex + 1, floorIndex);
			break;
		}
		previousFloorIndex = floorIndex;
		floorIndex += (MAX_ATTEMPTS - numberOfAttempts);
		if (99 < floorIndex)
		{
			floorIndex = 99;
		}
	}
	
	/* print the result. */
}

private int findHighestSafeFloor(final int start, final int end)
{
	for (int i = start; i < end; i++)
	{
		numberOfAttempts++;
		if (theFloor == i)
		{
			numberOfBalloons--;
			return (i - 1);
		}
	}
	return (end - 1);
}

I am sure that the findHighestSafeFloor() method above works but I decided to make it recursion. Why? No special reasons. I just like recursion as I haven’t used it for approximately four years since I last programmed in a functional programming language like Haskell in my math class thus miss it.

Although the code can be very simple as the following code with recursion, it has to increase the number of attempts and to decrease the number of balloons left, so it would be a bit more verbose as the second code.

private int findHighestSafeFloor(final int start, final int end)
{
	return (start < end ? (theFloor == start ? (start - 1) : findHighestSafeFloor((start + 1), end)) : (end - 1));
}

private int findHighestSafeFloor(final int start, final int end)
{
	if (start < end)
	{
		numberOfAttempts++;
		if (theFloor == start)
		{
			numberOfBalloons--;
			return (start - 1);
		}
		else
		{
			return findHighestSafeFloor((start + 1), end);
		}
	}
	else
	{
		return (end - 1);
	}
}

Now it’s time to code the complete programme and test it. Well, since it’s a very small programme, I didn’t do object-oriented programming.

package com.lckymn.kevin.findingfloor;

public final class HighestSafeFloorFinder
{
	private static final int TOP_LEVEL = 99;
	private static final int MAX_ATTEMPTS = 15;

	private int theBreakingPointFloor;
	private int numberOfBalloons;
	private int numberOfAttemptsMade;

	public void init(final int theBreakingPointFloor)
	{
		this.theBreakingPointFloor = theBreakingPointFloor;
		System.out.println("The breaking point: " + theBreakingPointFloor);
		numberOfBalloons = 2;
		numberOfAttemptsMade = 0;
	}

	public void findHighestSafeFloor()
	{
		int previousFloorIndex = -1;
		int floorIndex = MAX_ATTEMPTS - 1;
		int highestSafeFloor = 0;

		while (MAX_ATTEMPTS > numberOfAttemptsMade)
		{
			dropBalloon();
			if (theBreakingPointFloor <= floorIndex)
			{
				breakBalloon();
				highestSafeFloor = findHighestSafeFloor(previousFloorIndex + 1, floorIndex);
				break;
			}
			previousFloorIndex = floorIndex;
			floorIndex += (MAX_ATTEMPTS - numberOfAttemptsMade);
			if (TOP_LEVEL < floorIndex)
			{
				floorIndex = TOP_LEVEL;
			}
		}

		if (0 > highestSafeFloor)
		{
			System.out.println("There is no floor that you can drop a balloon without breaking it. Even the first floor (floor 0) is not safe.");
		}
		else
		{
			System.out.println("The highest safe floor: " + highestSafeFloor);
		}

		System.out.println("The number of attempts made: " + numberOfAttemptsMade);
	}

	private int findHighestSafeFloor(final int start, final int end)
	{
		if (start < end)
		{
			dropBalloon();
			if (theBreakingPointFloor == start)
			{
				breakBalloon();
				return (start - 1);
			}
			else
			{
				return findHighestSafeFloor((start + 1), end);
			}
		}
		else
		{
			return (end - 1);
		}
	}

	private void dropBalloon()
	{
		if (MAX_ATTEMPTS == numberOfAttemptsMade)
		{
			throw new IllegalStateException("You've already tried 15 times.");
		}
		numberOfAttemptsMade++;
	}

	private void breakBalloon()
	{
		if (0 == numberOfBalloons)
		{
			throw new IllegalStateException("You've already broken all the balloons available.");
		}
		numberOfBalloons--;
	}

	public static void main(String[] args)
	{
		HighestSafeFloorFinder highestSafeFloorFinder = new HighestSafeFloorFinder();
		for (int i = 0; i < 100; i++)
		{
			System.out.println("[Test Number: " + i + "]");
			highestSafeFloorFinder.init(i);
			highestSafeFloorFinder.findHighestSafeFloor();
			System.out.println("=======================================");
		}
		System.exit(0);
	}
}

Well, the code looks a bit ugly but in my defence, I’d just like to see the result and am busy so had no stomach for making it pretty. (Oh! such a poor excuse / but really busy )

The dropBalloon() and the breakBalloon() are added to increase the number of attempts made and to decrease the number of balloons left respectively. The dropBalloon() method also checks if the number of attempts already made is 15 and it tries to make another one than throws an exception telling that all the chances have been used. Similarly the breakBalloon() method checks if all the available balloons have broken if so, it also throws an exception saying there are no available balloons left. Thus I can see if the programme can find the highest safe floor with 15 times or fewer times of attempts and only two water balloons. If it cannot, it immediately throws an exception and stop the programme so I can see my programme fails to prove my algorithm.

The init() method is to initialise all the variables so that I can test it many times. It checks all the floors from the first one (floor 0) to the last one (floor 99) so if the programme works fine without any exception thrown then it might prove my answer is correct.

Let’s check out the result!

[Test Number: 0]
The breaking point: 0
There is no floor that you can drop a balloon without breaking it. Even the first floor (floor 0) is not safe.
The number of attempts made: 2
=======================================
[Test Number: 1]
The breaking point: 1
The highest safe floor: 0
The number of attempts made: 3
=======================================
[Test Number: 2]
The breaking point: 2
The highest safe floor: 1
The number of attempts made: 4
=======================================
[Test Number: 3]
The breaking point: 3
The highest safe floor: 2
The number of attempts made: 5
=======================================
[Test Number: 4]
The breaking point: 4
The highest safe floor: 3
The number of attempts made: 6
=======================================
[Test Number: 5]
The breaking point: 5
The highest safe floor: 4
The number of attempts made: 7
=======================================
[Test Number: 6]
The breaking point: 6
The highest safe floor: 5
The number of attempts made: 8
=======================================
[Test Number: 7]
The breaking point: 7
The highest safe floor: 6
The number of attempts made: 9
=======================================
[Test Number: 8]
The breaking point: 8
The highest safe floor: 7
The number of attempts made: 10
=======================================
[Test Number: 9]
The breaking point: 9
The highest safe floor: 8
The number of attempts made: 11
=======================================
[Test Number: 10]
The breaking point: 10
The highest safe floor: 9
The number of attempts made: 12
=======================================
[Test Number: 11]
The breaking point: 11
The highest safe floor: 10
The number of attempts made: 13
=======================================
[Test Number: 12]
The breaking point: 12
The highest safe floor: 11
The number of attempts made: 14
=======================================
[Test Number: 13]
The breaking point: 13
The highest safe floor: 12
The number of attempts made: 15
=======================================
[Test Number: 14]
The breaking point: 14
The highest safe floor: 13
The number of attempts made: 15
=======================================
[Test Number: 15]
The breaking point: 15
The highest safe floor: 14
The number of attempts made: 3
=======================================
[Test Number: 16]
The breaking point: 16
The highest safe floor: 15
The number of attempts made: 4
=======================================
[Test Number: 17]
The breaking point: 17
The highest safe floor: 16
The number of attempts made: 5
=======================================
[Test Number: 18]
The breaking point: 18
The highest safe floor: 17
The number of attempts made: 6
=======================================
[Test Number: 19]
The breaking point: 19
The highest safe floor: 18
The number of attempts made: 7
=======================================
[Test Number: 20]
The breaking point: 20
The highest safe floor: 19
The number of attempts made: 8
=======================================
[Test Number: 21]
The breaking point: 21
The highest safe floor: 20
The number of attempts made: 9
=======================================
[Test Number: 22]
The breaking point: 22
The highest safe floor: 21
The number of attempts made: 10
=======================================
[Test Number: 23]
The breaking point: 23
The highest safe floor: 22
The number of attempts made: 11
=======================================
[Test Number: 24]
The breaking point: 24
The highest safe floor: 23
The number of attempts made: 12
=======================================
[Test Number: 25]
The breaking point: 25
The highest safe floor: 24
The number of attempts made: 13
=======================================
[Test Number: 26]
The breaking point: 26
The highest safe floor: 25
The number of attempts made: 14
=======================================
[Test Number: 27]
The breaking point: 27
The highest safe floor: 26
The number of attempts made: 15
=======================================
[Test Number: 28]
The breaking point: 28
The highest safe floor: 27
The number of attempts made: 15
=======================================
[Test Number: 29]
The breaking point: 29
The highest safe floor: 28
The number of attempts made: 4
=======================================
[Test Number: 30]
The breaking point: 30
The highest safe floor: 29
The number of attempts made: 5
=======================================
[Test Number: 31]
The breaking point: 31
The highest safe floor: 30
The number of attempts made: 6
=======================================
[Test Number: 32]
The breaking point: 32
The highest safe floor: 31
The number of attempts made: 7
=======================================
[Test Number: 33]
The breaking point: 33
The highest safe floor: 32
The number of attempts made: 8
=======================================
[Test Number: 34]
The breaking point: 34
The highest safe floor: 33
The number of attempts made: 9
=======================================
[Test Number: 35]
The breaking point: 35
The highest safe floor: 34
The number of attempts made: 10
=======================================
[Test Number: 36]
The breaking point: 36
The highest safe floor: 35
The number of attempts made: 11
=======================================
[Test Number: 37]
The breaking point: 37
The highest safe floor: 36
The number of attempts made: 12
=======================================
[Test Number: 38]
The breaking point: 38
The highest safe floor: 37
The number of attempts made: 13
=======================================
[Test Number: 39]
The breaking point: 39
The highest safe floor: 38
The number of attempts made: 14
=======================================
[Test Number: 40]
The breaking point: 40
The highest safe floor: 39
The number of attempts made: 15
=======================================
[Test Number: 41]
The breaking point: 41
The highest safe floor: 40
The number of attempts made: 15
=======================================
[Test Number: 42]
The breaking point: 42
The highest safe floor: 41
The number of attempts made: 5
=======================================
[Test Number: 43]
The breaking point: 43
The highest safe floor: 42
The number of attempts made: 6
=======================================
[Test Number: 44]
The breaking point: 44
The highest safe floor: 43
The number of attempts made: 7
=======================================
[Test Number: 45]
The breaking point: 45
The highest safe floor: 44
The number of attempts made: 8
=======================================
[Test Number: 46]
The breaking point: 46
The highest safe floor: 45
The number of attempts made: 9
=======================================
[Test Number: 47]
The breaking point: 47
The highest safe floor: 46
The number of attempts made: 10
=======================================
[Test Number: 48]
The breaking point: 48
The highest safe floor: 47
The number of attempts made: 11
=======================================
[Test Number: 49]
The breaking point: 49
The highest safe floor: 48
The number of attempts made: 12
=======================================
[Test Number: 50]
The breaking point: 50
The highest safe floor: 49
The number of attempts made: 13
=======================================
[Test Number: 51]
The breaking point: 51
The highest safe floor: 50
The number of attempts made: 14
=======================================
[Test Number: 52]
The breaking point: 52
The highest safe floor: 51
The number of attempts made: 15
=======================================
[Test Number: 53]
The breaking point: 53
The highest safe floor: 52
The number of attempts made: 15
=======================================
[Test Number: 54]
The breaking point: 54
The highest safe floor: 53
The number of attempts made: 6
=======================================
[Test Number: 55]
The breaking point: 55
The highest safe floor: 54
The number of attempts made: 7
=======================================
[Test Number: 56]
The breaking point: 56
The highest safe floor: 55
The number of attempts made: 8
=======================================
[Test Number: 57]
The breaking point: 57
The highest safe floor: 56
The number of attempts made: 9
=======================================
[Test Number: 58]
The breaking point: 58
The highest safe floor: 57
The number of attempts made: 10
=======================================
[Test Number: 59]
The breaking point: 59
The highest safe floor: 58
The number of attempts made: 11
=======================================
[Test Number: 60]
The breaking point: 60
The highest safe floor: 59
The number of attempts made: 12
=======================================
[Test Number: 61]
The breaking point: 61
The highest safe floor: 60
The number of attempts made: 13
=======================================
[Test Number: 62]
The breaking point: 62
The highest safe floor: 61
The number of attempts made: 14
=======================================
[Test Number: 63]
The breaking point: 63
The highest safe floor: 62
The number of attempts made: 15
=======================================
[Test Number: 64]
The breaking point: 64
The highest safe floor: 63
The number of attempts made: 15
=======================================
[Test Number: 65]
The breaking point: 65
The highest safe floor: 64
The number of attempts made: 7
=======================================
[Test Number: 66]
The breaking point: 66
The highest safe floor: 65
The number of attempts made: 8
=======================================
[Test Number: 67]
The breaking point: 67
The highest safe floor: 66
The number of attempts made: 9
=======================================
[Test Number: 68]
The breaking point: 68
The highest safe floor: 67
The number of attempts made: 10
=======================================
[Test Number: 69]
The breaking point: 69
The highest safe floor: 68
The number of attempts made: 11
=======================================
[Test Number: 70]
The breaking point: 70
The highest safe floor: 69
The number of attempts made: 12
=======================================
[Test Number: 71]
The breaking point: 71
The highest safe floor: 70
The number of attempts made: 13
=======================================
[Test Number: 72]
The breaking point: 72
The highest safe floor: 71
The number of attempts made: 14
=======================================
[Test Number: 73]
The breaking point: 73
The highest safe floor: 72
The number of attempts made: 15
=======================================
[Test Number: 74]
The breaking point: 74
The highest safe floor: 73
The number of attempts made: 15
=======================================
[Test Number: 75]
The breaking point: 75
The highest safe floor: 74
The number of attempts made: 8
=======================================
[Test Number: 76]
The breaking point: 76
The highest safe floor: 75
The number of attempts made: 9
=======================================
[Test Number: 77]
The breaking point: 77
The highest safe floor: 76
The number of attempts made: 10
=======================================
[Test Number: 78]
The breaking point: 78
The highest safe floor: 77
The number of attempts made: 11
=======================================
[Test Number: 79]
The breaking point: 79
The highest safe floor: 78
The number of attempts made: 12
=======================================
[Test Number: 80]
The breaking point: 80
The highest safe floor: 79
The number of attempts made: 13
=======================================
[Test Number: 81]
The breaking point: 81
The highest safe floor: 80
The number of attempts made: 14
=======================================
[Test Number: 82]
The breaking point: 82
The highest safe floor: 81
The number of attempts made: 15
=======================================
[Test Number: 83]
The breaking point: 83
The highest safe floor: 82
The number of attempts made: 15
=======================================
[Test Number: 84]
The breaking point: 84
The highest safe floor: 83
The number of attempts made: 9
=======================================
[Test Number: 85]
The breaking point: 85
The highest safe floor: 84
The number of attempts made: 10
=======================================
[Test Number: 86]
The breaking point: 86
The highest safe floor: 85
The number of attempts made: 11
=======================================
[Test Number: 87]
The breaking point: 87
The highest safe floor: 86
The number of attempts made: 12
=======================================
[Test Number: 88]
The breaking point: 88
The highest safe floor: 87
The number of attempts made: 13
=======================================
[Test Number: 89]
The breaking point: 89
The highest safe floor: 88
The number of attempts made: 14
=======================================
[Test Number: 90]
The breaking point: 90
The highest safe floor: 89
The number of attempts made: 15
=======================================
[Test Number: 91]
The breaking point: 91
The highest safe floor: 90
The number of attempts made: 15
=======================================
[Test Number: 92]
The breaking point: 92
The highest safe floor: 91
The number of attempts made: 10
=======================================
[Test Number: 93]
The breaking point: 93
The highest safe floor: 92
The number of attempts made: 11
=======================================
[Test Number: 94]
The breaking point: 94
The highest safe floor: 93
The number of attempts made: 12
=======================================
[Test Number: 95]
The breaking point: 95
The highest safe floor: 94
The number of attempts made: 13
=======================================
[Test Number: 96]
The breaking point: 96
The highest safe floor: 95
The number of attempts made: 14
=======================================
[Test Number: 97]
The breaking point: 97
The highest safe floor: 96
The number of attempts made: 15
=======================================
[Test Number: 98]
The breaking point: 98
The highest safe floor: 97
The number of attempts made: 15
=======================================
[Test Number: 99]
The breaking point: 99
The highest safe floor: 98
The number of attempts made: 10
=======================================

It works!

Firstly, create a web service interface then put the @WebService annotation.

package com.lckymn.kevin.test.openejb.webservice;

import javax.jws.WebService;

import com.lckymn.kevin.test.openejb.domain.User;

@WebService
public interface TestWebService
{
	User getUser(Long id);
}

Secondly, create a class implmenting the web service interface with also the @WebService annotation then specify the targetNamespace and the serviceName as you wish. In my case, these are

targetNamespace: "http://webservice.webhibernate.test"
serviceName: "testWebService"

To use the UserService EJB, injected by OpenEJB, make the web service class session EJB with the @Stateless annotation.

package com.lckymn.kevin.test.openejb.webservice;

import javax.ejb.EJB;
import javax.ejb.Local;
import javax.ejb.Stateless;
import javax.jws.WebService;

import com.lckymn.kevin.test.openejb.domain.User;
import com.lckymn.kevin.test.openejb.service.UserService;

@Local
@Stateless
@WebService(targetNamespace = "http://webservice.webhibernate.test", serviceName = "testWebService")
public class TestWebServiceImpl implements TestWebService
{
	@EJB
	private UserService userService;

	@Override
	public User getUser(Long id)
	{
		return userService.getUser(id);
	}
}

The class above simply returns a User entity object acquired from the UserService EJB, made in the previous post.

That’s it. You have just made your web service. When the server starts and the application is deployed, the EJB container (OpenEJB) registers the above EJB as a web service.

Now, let’s make a web service client. To make a very simple example client, I’m going to create a servlet in the same web application to which the web service belongs, yet it can of course be another web application, Java desktop application, Java console application and so on.

Here is a simple servlet which gets the user ID from the client-side then accesses the web service to get the User. After that it passes the User entity object through the HttpSession to the JSP page to display.

package com.lckymn.kevin.test.openejb.web;

import java.io.IOException;
import java.net.URL;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;

import com.lckymn.kevin.test.openejb.domain.User;
import com.lckymn.kevin.test.openejb.webservice.TestWebService;

public class TestWebServiceClientServlet extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		doPost(request, response);
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		Service service = Service.create(new URL("http://localhost:8080/TestWebServiceImpl?wsdl"), new QName(
				"http://webservice.webhibernate.test", "testWebService"));
		TestWebService testWebService = service.getPort(TestWebService.class);

		String userIdParam = request.getParameter("userId");

		HttpSession session = request.getSession();
		if (null == userIdParam || 0 == userIdParam.length())
		{
			session.removeAttribute("userFound");
		}
		else
		{
			Long userId = Long.parseLong(userIdParam);
			User user = testWebService.getUser(userId);
			session.setAttribute("userFound", user);
		}
		getServletContext().getRequestDispatcher("/WEB-INF/jsp/webServiceClient.jsp")
				.forward(request, response);
	}
}

This is just a simple example thus I omitted validation (e.g. checking whether the userId is ‘long’ type or not) and exception handling.

The WSDL location is the server URI + “/” + web service class name + “?wsdl”.
http://localhost:8080/TestWebServiceImpl?wsdl
The parameters of the QName constructor are namespaceURI and localPart, and these are defined in the web service. If you look at the web service code again, these can easily be found from the @WebService annotation.

@WebService(targetNamespace = "http://webservice.webhibernate.test", serviceName = "testWebService")
public class TestWebServiceImpl implements TestWebService
{
	...
}

The value of the targetNamespace element is the namespaceURI of the QName constructor, and the value of the serviceNmae element is the localPart.

This is web.xml. The information of the new servlet, the web service client just created, is added to the web.xml, made in the previous post.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>test-web-hibernate</display-name>
  <servlet>
    <description></description>
    <display-name>TestServlet</display-name>
    <servlet-name>TestServlet</servlet-name>
    <servlet-class>com.lckymn.kevin.test.openejb.web.TestServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>TestServlet</servlet-name>
    <url-pattern>/Test</url-pattern>
  </servlet-mapping>
  <servlet>
    <description></description>
    <display-name>TestWebServiceClientServlet</display-name>
    <servlet-name>TestWebServiceClientServlet</servlet-name>
    <servlet-class>com.lckymn.kevin.test.openejb.web.TestWebServiceClientServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>TestWebServiceClientServlet</servlet-name>
    <url-pattern>/TestWebServiceClient</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

Finally, add a JSP file to enter the userId to search a user and to display the user info.
In my case, I added the file to the application/WebContent/WEB-INF/jsp directory which is the same location that I set in the TestWebServiceClientServlet (look at the TestWebServiceClientServlet code above).
test-web-hibernate/WebContent/WEB-INF/jsp/webServiceClient.jsp

<?xml version="1.0" encoding="UTF-8" ?>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Insert title here</title>
</head>
<body>
<div>
<form name="userForm" action="TestWebServiceClient" method="post" >
	<input type="text" name="userId" value="" /> <input type="submit" name="userIdSubmit" value="Search" />
</form>
</div>
<div>
	<table>
		<tr>
			<td>User ID: </td><td>${userFound.id }</td>
		</tr>
		<tr>
			<td>Username: </td><td>${userFound.username }</td>
		</tr>
		<tr>
			<td>Surname: </td><td>${userFound.surname }</td>
		</tr>
		<tr>
			<td>Given name: </td><td>${userFound.givenName }</td>
		</tr>
		<tr>
			<td>Email: </td><td>${userFound.email }</td>
		</tr>
	</table>
</div>
</body>
</html>

To test it, open the browser and enter the following URI.

http://localhost:8080/test-web-hibernate/TestWebServiceClient

It displays the screen like below

Enter userId and click the 'Search' button

It displays the result yet there is one problem. It doesn’t display the userId.

The Search Result: userId is not displayed

There are two simple ways to solve this problem. Either way works so choose whichever you like.

1. Add the setter method. If there is setId() method, the id field is included when the object is passed through the web service. The reason why I did not write the setter method is that the id is supposed to be set by Hibernate and to avoid any problems caused by setting it manually, I did not write it. However, it is required in order to include the field when passing object through the web service. So adding setter can solve this problem. If you do not like this solution as you do not like to put the setter method due to the reason I explained, you can try the second solution.

@Entity
@Table(name = "users")
public class User implements Serializable
{
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "user_id")
	private Long id;

	...

	public Long getId()
	{
		return id;
	}

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

OR

2. If you add the @XmlElement annotation to the id field and set the value of the required element to true, the id field is included even without the setter method.

...

import javax.xml.bind.annotation.XmlElement;

...
@Entity
@Table(name = "users")
public class User implements Serializable
{
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "user_id")
	@XmlElement(required = true)
	private Long id;

	...

	public Long getId()
	{
		return id;
	}

	// No setId() required
	
	...
}

Now, test if it works.

Enter userId and click the 'Search' button

It works!

The Search Result: userId is displayed correctly

There are also other ways and tools to create a web service in Java. I used to use Apache Axis then later moved to XFire. Now, I use Apache CXF which is considered as XFire 2.0. It is, as explained here, very easy to create a web service client, yet it can be even easier with WSDL2Java from Apache Axis or WSDL2Java from Apache Axis2.

Before I start writing this blog entry, I’d better point out a few things.

• This blog entry is not about how to make a good Java EE application yet is about how to use OpenEJB on Apache Tomcat server with Hibernate as an implementation of the JPA. If you are looking for better Java EE development or similar, this one is not for you.
• I don’t have enough time to explain all the details of how to install JDK, Eclipse, Tomcat and so on. So this post doesn’t have that level of details. I simply assume that you’ve already known how to install JDK, Eclipse and Tomcat. Well, anyway, installing Eclipse and Tomcat are as easy as extracting a zip or gzip file and JDK installation is also not difficult at all.
• This post does not cover how to use those tools and frameworks in the production environment. In other words, it is only for the development. Setting up the environment for development and for the production use have some differences. It is, however not that hard to figure out once you know how to use those in your development environment.

1. Development Environment

First of all, I’m going to list the development environment and tools I have for this introductory tutorial post.
(Click each name and it will take you to the download page).

OS: Ubuntu Linux Jaunty Jackalope 9.04 Desktop 64bit
Java: Sun JDK 1.6.0_16 (64 bit) (it’s from the Ubuntu repository).
Database: MySQL Community Server 5.0 (it’s from the Ubuntu repository).
JDBC Driver: MySQL Connector/J 5.1.10
Eclipse: Eclipse IDE for Java EE Developer Ganymede SR2 (Eclipse 3.4.2)
Tomcat: Tomcat 6.0.20
OpenEJB: OpenEJB 3.1.1 (openejb.war)
Hibernate: Hibernate 3.2.1GA (including hibernate-3.2.1.ga, hibernate-annotations-3.2.1.ga, hibernate-entitymanager-3.2.1.ga) (OR just >>download this<<)

2. Installing OpenEJB

Java EE server normally means a Java application server which consists of a Servlet container and an EJB container. Apache Tomcat is a servlet container but not an EJB container so you need to have an EJB container like OpenEJB or use a Java EE server instead of Tomcat in order to use EJB unless you’re using the frameworks supporting EJB such as Spring framework. “So if I use Tomcat server and Spring framework, do I not need OpenEJB or other Java EE servers to use EJB?” No, you don’t.

Since this post is, as already mentioned, about using using EJB on Tomcat with OpenEJB and Hibernate, I will first show you how to install OpenEJB.

Before installing OpenEJB, don’t forget to copy JDBC driver that is, in this post, MySQL Connector/J to the $TOMCAT/lib directory.
-Copy the Connector/J jar file to the Tomcat’s library directory ($TOMCAT_HOME/lib)

Select Connector/J and Extract to the $TOMCAT/lib directory.

Make sure the Connector/J jar file is in the $TOMCAT/lib directory.

-Run Eclipse and add Tomcat server: Menu – Window -> Preferences -> Server -> Runtime Environments -> Add

-Download the openejb.war, OpenEJB for Tomcat, and import the file from Eclipse.
-Right click on the project explorer -> Import -> WAR file

Right Click on the project explorer -> Import -> WAR File

-Click the ‘Browse’ button and select the openejb.war file -> Select your Tomcat 6.0 as the target runtime. -> Click the ‘Finish’ button.

Click the 'Browse' button and select the openejb.war file -> Select your Tomcat 6.0 as the target runtime. -> Click the 'Finish' button.

3. Add OpenEJB project to the Server to deploy

-Right click on the server name in the ‘Server’ view -> Select the ‘Add and Remove Projects…’

Right click on the server name in the 'Server' view -> Select the 'Add and Remove Projects...'

-Select openejb -> Click the ‘Add’ button -> Click the ‘Finish’ button

Select openejb -> Click the 'Add' button -> Click the 'Finish' button

-openejb is ready to be deployed.

openejb is deployed.

-Now run the server to deploy openejb.

Run the server to deploy openejb

-openejb is successfully deployed.

the openejb is successfully deployed.

4. Set up DataSource

-openejb.xml has to be copied to the Tomcat configuration folder of the Eclipse workspace.

openejb.xml has to be copied to the Tomcat configuration folder of the Eclipse workspace.

If you are using Tomcat without OpenEJB and want to create a DataSource, you might do by putting the DataSource info to Tomcat’s server.xml file or your application’s context configuration file (your_app/META-INF/context.xml). Yet to create the DataSource for JPA, you need to do through openejb.xml file. It is created in the Tomcat folder in the .metadata folder of your Eclipse workspace when the openejb project is deployed. However, it is not copied automatically to the configuration folder of your Eclipse workspace, you should copy the openejb.xml file to the Server configuration folder manually. If the location of the workspace is ‘/home/username/workspace’, the Tomcat is in ‘/home/username/test-workspace/.metadata/.plugins/org.eclipse.wst.server.core’ and the openejb.xml file can be found in the ‘/home/username/workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/conf’ directory.

-Find the openejb.xml file and copy to the Tomcat configuration folder of the Eclipse workspace.

Find the openejb.xml file and copy to the Tomcat configuration folder of the Eclipse workspace.

Paste the file to the Tomcat configuration folder of the Eclipse workspace.

-Open the ‘openejb.xml’ file then you can find the default DataSources.

Open the 'openejb.xml' file then you can find the default DataSources

-Add the following lines and modify for your own database.

<Resource id="mysqlDataSource" type="javax.sql.DataSource">
	JdbcDriver      	com.mysql.jdbc.Driver
	JdbcUrl         	jdbc:mysql://localhost:3306/test_db
	UserName        	test_user
	Password        	1234
	JtaManaged      	true
	DefaultAutoCommit 	true
	InitialSize     	3
	MaxActive       	20
	MinIdle         	20
	MaxIdle         	0
	MaxWait         	50000
	ValidationQuery 	SELECT 1
	TestOnBorrow    	true
	TestOnReturn    	false
	TestWhileIdle   	false
</Resource>

DataSource to access the MySQL database.

If you want to use OpenJPA as an implmentation of the JPA, you can do now. However, to use Hibernate there is one more step to do.

5. Install Hibernate

If you just have the Hibernate jar files in your application directory (e.g. your_app/WEB-INF/lib), the EJB container that is OpenEJB cannot find the hibernate classes as it is the container, it tries to find the hibernate class from the server’s lib directory. Thus just like you need to copy the JDBC driver, in this post it’s ‘Connector/J’, to the tomcat’s lib directory, the hibernate jar files should be placed in the Tomcat’s lib directory.

Otherwise, you will get an error like this.

ERROR - Unable to deploy collapsed ear in war /test-web-hibernate: Exception: Creating application failed: /home/username/workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/test-web-hibernate: java.lang.ClassNotFoundException: org.hibernate.ejb.HibernatePersistence: org.hibernate.ejb.HibernatePersistence
org.apache.openejb.OpenEJBException: Creating application failed: /home/username/workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/test-web-hibernate: java.lang.ClassNotFoundException: org.hibernate.ejb.HibernatePersistence: org.hibernate.ejb.HibernatePersistence
	at org.apache.openejb.assembler.classic.Assembler.createApplication(Assembler.java:658)
	at org.apache.openejb.assembler.classic.Assembler.createApplication(Assembler.java:442)
	at org.apache.openejb.tomcat.catalina.TomcatWebAppBuilder.start(TomcatWebAppBuilder.java:249)
	at org.apache.openejb.tomcat.catalina.GlobalListenerSupport.lifecycleEvent(GlobalListenerSupport.java:58)
	at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:119)
	at org.apache.catalina.core.StandardContext.start(StandardContext.java:4339)
	at org.apache.catalina.core.StandardContext.reload(StandardContext.java:3190)
	at org.apache.catalina.loader.WebappLoader.backgroundProcess(WebappLoader.java:404)
	at org.apache.catalina.core.ContainerBase.backgroundProcess(ContainerBase.java:1309)
	at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.processChildren(ContainerBase.java:1601)
	at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.processChildren(ContainerBase.java:1610)
	at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.processChildren(ContainerBase.java:1610)
	at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.run(ContainerBase.java:1590)
	at java.lang.Thread.run(Thread.java:619)
Caused by: org.apache.openejb.OpenEJBException: java.lang.ClassNotFoundException: org.hibernate.ejb.HibernatePersistence: org.hibernate.ejb.HibernatePersistence
	at org.apache.openejb.assembler.classic.Assembler.createApplication(Assembler.java:487)
	... 13 more
Caused by: java.lang.ClassNotFoundException: org.hibernate.ejb.HibernatePersistence
	at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1387)
	at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1233)
	at org.apache.openejb.assembler.classic.PersistenceBuilder.createEntityManagerFactory(PersistenceBuilder.java:177)
	at org.apache.openejb.assembler.classic.Assembler.createApplication(Assembler.java:482)
	... 13 more

6. Adding logger configuration (Optional)

By default, OpenEJB creates a log file in the Eclipse’s $TOMCAT/logs directory. It is very inconvenient as you have to open the file when you want to get information from the log. However, it is very easy to change this to make it displayed on the Console view of Eclipse.

-Right click on the Tomcat configuration folder -> Select ‘New’ -> Select ‘File’ -> crated a file with the name ‘logging.properties’.

Right click on the Tomcat configuration folder -> Select 'New' -> Select 'File' -> crated a file with the name 'logging.properties'.

-Open the file and put the following lines

log4j.rootLogger                   = fatal,C
log4j.category.OpenEJB             = warn
log4j.category.OpenEJB.options     = info
log4j.category.OpenEJB.server      = info
log4j.category.OpenEJB.startup     = info
log4j.category.OpenEJB.startup.service = warn
log4j.category.OpenEJB.startup.config = info
log4j.category.OpenEJB.hsql        = info
log4j.category.CORBA-Adapter       = info
log4j.category.Transaction         = warn
log4j.category.org.apache.activemq = error
log4j.category.org.apache.geronimo = error
log4j.category.openjpa             = error

log4j.appender.C                   = org.apache.log4j.ConsoleAppender
log4j.appender.C.layout            = org.apache.log4j.SimpleLayout

Put the logger config details

7. Create Web Application Project

Now, you can develop a web application using EJB3 and Hibernate as the implementation of the JPA.

-Right click on the project explorer -> Select ‘New’ -> Select ‘Dynamic Web Project’

Right click on the project explorer -> Select 'New' -> Select 'Dynamic Web Project'

-Put the name you like -> Select the ‘Apache Tomcat v6.0′ as the target runtime -> Select ’2.5′ as the version of ‘Dynamic Web Module’ -> Select the default Tomcat configuration or your own one -> Click the ‘Next’ button.

Put the name you like -> Select the 'Apache Tomcat v6.0' as the target runtime -> Select '2.5' as the version of 'Dynamic Web Module' -> Select the default Tomcat configuration or your own one -> Click the 'Next' button.

-Change the project context root and directory names if you like -> Click the ‘Finish’ button.

Change the project context root and directory names if you like -> Click the 'Finish' button.

-Right click on the Server to add the project -> Select the ‘Add and Remove Projects…’.

Right click on the Server to add the project -> Select the 'Add and Remove Projects...'.

-Select the project you created -> Click the ‘Add’ button -> Click the ‘Finish’ button.

Select the project you created -> Click the 'Add' button -> Click the 'Finish' button.

-Both openejb and your project are added.

Both openejb and your project are added.

8. Make JPA Project

To use the JPA support feature of Eclipse, you need to change the project facet configuration.

-Right click on your project -> Select the ‘Properties’.

Right click on your project -> Select the 'Properties'.

-Select the ‘Project Facets’ -> Check ‘Java Persistence 1.0′ -> Click the ‘Further configuration available…’ link.

Select the 'Project Facets' -> Check 'Java Persistence 1.0' -> Click the 'Further configuration available...' link.

-Select ‘Generic’ -> Select ‘None’ or your own connection or add a new connection if you wish -> Select ‘Use implementation provided by server runtime’ -> Select ‘Discover annotated classes automatically’ -> Uncheck ‘Create orm.xml’ option -> Click the ‘OK’ button.

Select 'Generic' -> Select 'None' or your own connection or add a new connection if you wish -> Select 'Use implementation provided by server runtime' -> Select 'Discover annotated classes automatically' -> Uncheck 'Create orm.xml' option -> Click the 'OK' button.

9. Add Java EE 5 API library file

You also need to add the Java EE 5 API library file so you can use all the necessary annotations required for EJB3 and JPA.

-Select ‘Java Build Path on the left-hand side menu -> Select the ‘Libraries’ tab -> Click the ‘Add JARs…’ button.

Select 'Java Build Path on the left-hand side menu -> Select the 'Libraries' tab -> Click the 'Add JARs...' button.

-Select ‘javaee-api-5.0-2.jar in the openejb/WebContent/lib directory -> Click the ‘OK’ button.

Select 'javaee-api-5.0-2.jar in the openejb/WebContent/lib directory -> Click the 'OK' button.

-Click the ‘OK’ button.

Click the 'OK' button.

JPA configuration file (persistence.xml) is added

10. Configure persistence.xml file

It’s the last step before starting to programme the actual application.

-Open the persistence.xml file -> Type ‘org.hibernate.ejb.HibernatePersistence’ to the ‘Persistence Provider’.

org.hibernate.ejb.HibernatePersistence

Open the persistence.xml file -> put 'org.hibernate.ejb.HibernatePersistence' to the 'Persistence Provider'.

-Click the ‘Connection’ tab -> Select the ‘JTA’ as the ‘Transaction Type’ -> Type ‘mysqlDataSource’ or your datasource name added in the previous steps. -> Press ‘Ctrl + S’ keys to save the file.

Click the 'Connection' tab -> Select the 'JTA' as the 'Transaction Type' -> Type 'mysqlDataSource' or your datasource name added in the previous steps. -> Press 'Ctrl + S' keys to save the file.

-If you select the ‘Source’ tab, you should see the XML like this.

If you select the 'Source' tab, you should see the XML like above.

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0"
	xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
	<persistence-unit name="test-web-hibernate" transaction-type="JTA">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<jta-data-source>mysqlDataSource</jta-data-source>
	</persistence-unit>
</persistence>

-If you want Hibernate to automatically create the database tables based on your entity classes every time the server is restarted (in other words, the application is re-deployed), You can add Hibernate specific properties.

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0"
	xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
	<persistence-unit name="test-web-hibernate" transaction-type="JTA">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<jta-data-source>mysqlDataSource</jta-data-source>
		<properties>
			<property name="hibernate.hbm2ddl.auto" value="create" />
		</properties>
	</persistence-unit>
</persistence>

11. Test

Finally, we have the development environment ready. To test, if I can use EJB3 and JPA with Hibernate on Tomcat, I made a very simple application. The way I design it is not my usual way yet I used Generic DAO pattern which I usually use.

11.1. Entity classes

Here is my only entity class in this test.

package com.lckymn.kevin.test.openejb.domain;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
public class User implements Serializable
{
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "user_id")
	private Long id;

	@Column(name = "username", nullable = false, length = 30)
	private String username;

	@Column(name = "surname", nullable = false, length = 50)
	private String surname;

	@Column(name = "given_name", nullable = false, length = 50)
	private String givenName;

	@Column(name = "email", nullable = true, length = 255)
	private String email;

	public Long getId()
	{
		return id;
	}

	public String getUsername()
	{
		return username;
	}

	public void setUsername(String username)
	{
		this.username = username;
	}

	public String getSurname()
	{
		return surname;
	}

	public void setSurname(String surname)
	{
		this.surname = surname;
	}

	public String getGivenName()
	{
		return givenName;
	}

	public void setGivenName(String givenName)
	{
		this.givenName = givenName;
	}

	public String getEmail()
	{
		return email;
	}

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

	@Override
	public boolean equals(Object obj)
	{
		if (this == obj)
		{
			return true;
		}

		if (!(obj instanceof User))
		{
			return false;
		}
		User that = (User) obj;
		return (username == that.getUsername() || (null != username && username.equals(that.getUsername())));
	}

	@Override
	public int hashCode()
	{
		return (null == username ? 0 : username.hashCode());
	}
}

11.2. Generic DAOs

package com.lckymn.kevin.test.openejb.dao;

public interface GenericDao<E, K>
{
	E find(K id);

	void persist(E e);

	void remove(E e);
}

package com.lckymn.kevin.test.openejb.dao;

import java.lang.reflect.ParameterizedType;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

public abstract class AbstractGenericDao<E, K> implements GenericDao<E, K>
{
	private Class<E> classType;

	@PersistenceContext(unitName = "test-web-hibernate")
	private EntityManager entityManager;

	@SuppressWarnings("unchecked")
	public AbstractGenericDao()
	{
		ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass();
		classType = (Class<E>) parameterizedType.getActualTypeArguments()[0];
	}

	protected final EntityManager getEntityManager()
	{
		if (null == entityManager)
		{
			throw new IllegalStateException("EntityManager is not injected.");
		}
		return entityManager;
	}

	@Override
	public E find(K id)
	{
		return getEntityManager().find(classType, id);
	}

	@Override
	public void persist(E e)
	{
		getEntityManager().persist(e);
	}

	@Override
	public void remove(E e)
	{
		getEntityManager().remove(e);
	}
}

package com.lckymn.kevin.test.openejb.dao;

import java.util.List;

import javax.ejb.Local;

import com.lckymn.kevin.test.openejb.domain.User;

@Local
public interface UserDao extends GenericDao<User, Long>
{
	List<User> getUsersByGivenName(String givenName);
}

package com.lckymn.kevin.test.openejb.dao;

import java.util.List;

import javax.ejb.Stateless;

import com.lckymn.kevin.test.openejb.domain.User;

@Stateless
public class UserDaoImpl extends AbstractGenericDao<User, Long> implements UserDao
{
	@SuppressWarnings("unchecked")
	@Override
	public List<User> getUsersByGivenName(String givenName)
	{
		return getEntityManager().createQuery("from User where givenName = ?")
				.setParameter(1, givenName)
				.getResultList();
	}
}

11.3. Services

package com.lckymn.kevin.test.openejb.service;

import java.util.List;

import javax.ejb.Local;

import com.lckymn.kevin.test.openejb.domain.User;

@Local
public interface UserService
{
	User getUser(long id);

	void AddUser(User user);

	List<User> getUserByGivenName(String givenName);
}

package com.lckymn.kevin.test.openejb.service;

import java.util.List;

import javax.ejb.EJB;
import javax.ejb.Stateless;

import com.lckymn.kevin.test.openejb.dao.UserDao;
import com.lckymn.kevin.test.openejb.domain.User;

@Stateless
public class UserServiceBean implements UserService
{
	@EJB
	private UserDao userDao;

	@Override
	public User getUser(long id)
	{
		return userDao.find(id);
	}

	@Override
	public void AddUser(User user)
	{
		userDao.persist(user);
	}

	@Override
	public List<User> getUserByGivenName(String givenName)
	{
		return userDao.getUsersByGivenName(givenName);
	}

}

11. 4. Servlets

package com.lckymn.kevin.test.openejb.web;

import java.io.IOException;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.lckymn.kevin.test.openejb.domain.User;
import com.lckymn.kevin.test.openejb.service.UserService;

public class TestServlet extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	@EJB
	private UserService userService;

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		doPost(request, response);
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		User user = new User();
		user.setUsername("kevinlee");
		user.setSurname("Lee");
		user.setGivenName("Kevin");
		user.setEmail("test@test.test");

		userService.AddUser(user);

		HttpSession session = request.getSession();
		session.setAttribute("user", user);

		getServletContext().getRequestDispatcher("/index.jsp")
				.forward(request, response);
	}

}

11.5. Deployment Descriptor (web.xml)

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	<display-name>test-web-hibernate</display-name>
	<servlet>
		<description></description>
		<display-name>TestServlet</display-name>
		<servlet-name>TestServlet</servlet-name>
		<servlet-class>com.lckymn.kevin.test.openejb.web.TestServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>TestServlet</servlet-name>
		<url-pattern>/Test</url-pattern>
	</servlet-mapping>
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

11. 6. index.jsp

<?xml version="1.0" encoding="UTF-8" ?>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Insert title here</title>
</head>
<body>
<div>
	<table>
		<tr>
			<td>User ID: </td><td>${user.id }</td>
		</tr>
		<tr>
			<td>Username: </td><td>${user.username }</td>
		</tr>
		<tr>
			<td>Surname: </td><td>${user.surname }</td>
		</tr>
		<tr>
			<td>Given name: </td><td>${user.givenName }</td>
		</tr>
		<tr>
			<td>Email: </td><td>${user.email }</td>
		</tr>
	</table>
</div>
</body>
</html>

12. Run the test application

Access the application URI

http://localhost:8080/test-web-hibernate/Test

It gives me this result.

User ID: 	1
Username: 	kevinlee
Surname: 	Lee
Given name: 	Kevin
Email: 	test@test.test

http://blog.springsource.com/2009/08/10/springsource-chapter-two/
http://www.vmware.com/company/news/releases/springsource.html
http://blogs.vmware.com/console/2009/08/vmware-acquires-springsource.html
http://www.earthtimes.org/articles/show/vmware-to-acquire-springsource,921934.shtml

Looks like a good deal for both companies.

VMware recently hired Mark Lucovsky from Google and now has SpringSource. I guess VMware is really doing well.

Plug-in org.eclipse.jst.server.tomcat.core was unable to load class org.eclipse.jst.server.tomcat.core.internal.TomcatLaunchConfigurationDelegate.
 /eclipse_installed_path/eclipse/configuration/org.eclipse.osgi/.lazy.15 (Too many open files)

or

Problems occurred while trying to save the state of the workbench.
 Could not read master table.
 /your_workspace/.metadata/.plugins/org.eclipse.core.resources/.safetable/org.eclipse.core.resources (Too many open files)

or

java.util.zip.ZipException: error in opening zip file

This is because there are too many files opened and these are more files than the number of open files allowed . So Eclipse cannot open more files and displays the errors above.

Let’s see the number of open files.

$ lsof | wc -l 

e.g.)

$ lsof | wc -l 
8965

In my case, it was 8965.

What about the number of files Eclipse opens. To see it, use

$ lsof | grep eclipse | wc -l 

In my case,

$ lsof | grep eclipse | wc -l 
2094

2094 files are opened.

Now check the limitation of open files

$ ulimit -a 
core file size          (blocks, -c) #
data seg size           (kbytes, -d) #
scheduling priority             (-e) #
file size               (blocks, -f) #
pending signals                 (-i) #
max locked memory       (kbytes, -l) #
max memory size         (kbytes, -m) #
open files                      (-n) 1024
pipe size            (512 bytes, -p) #
POSIX message queues     (bytes, -q) #
real-time priority              (-r) #
stack size              (kbytes, -s) #
cpu time               (seconds, -t) #
max user processes              (-u) #
virtual memory          (kbytes, -v) #
file locks                      (-x) #

or just use

$ ulimit -n 
1024

To change it, open the file /etc/security/limits.conf and put a greater number than 1024 depending on the number of open files you checked with lsof | wc -l just before.
For example,
Open the file

$ gksudo gedit /etc/security/limits.conf 
add these lines
*                soft    nofile          9216
*                hard    nofile          9216

I just chose some big number that is 9216 (9 * 1024) as it’s greater than 8965

Log out and in then check with ulimit. It should show like this.

$ ulimit -n 
9216

You may try this

$ ulimit -n 9216 

yet I don’t believe it changes the limit for open files permanently. So you’d better modify /etc/security/limits.conf file.

If it is still not changed. Restart the computer and check again. If it still doesn’t show the changed value, open /etc/pam.d/common-session file and add session required pam_limits.so.

$ gksudo gedit /etc/pam.d/common-session 

session required pam_limits.so

$ ulimit -n 
9216