Is a @Singleton bean really a singleton?

Well, as you might have expected from the title, the answer is "yeah well, not really". A singleton in the J2EE world is not a singleton as you know it from the normal Java world. In a non-J2EE environment you typically write something like this to generate a singleton:

public class MySingleton {

     final private static MySingleton instance = new MySingleton();

     protected String name = "whatever";

     private MySingleton() {}

     public static MySingleton instance() {
          return instance;
     }
}

You can get exactly one instance of this bean and you could access the fields directly or through getter and setters. There is only one instance of this object and all information is stored there. This pattern is well known to every programmer. The demand was great to port this pattern to the J2EE world. A new type of bean was invented, the Singleton bean. The idea behind all this is to provide a single instance of a particular bean within your application. You can construct a singleton bean with the following code:

     @LocalBean
     @Singleton
     @Startup
     public class MySingleton {

     }

First we declare it as a local bean, and we load it during startup. The @Singleton annotation makes a singleton out of this class. But is this class really instantiated once when using the @LocalBean annotation? No, it is instantiated twice! Let's test this out with by adding a static field in the bean. 

    static int i=1;

    public MySingleton() {
        System.out.println("INSTANCE: " + i++);
    } 

You will see in the logs that you get two different instances. If you print out the reference of the class, you will notice that one of the instances is a proxy object. The proxy object is instantiated too and the constructor is instantiated again. When you write some kind of initialisation logic inside the constructor, you will run into somekind of unwanted behaviour because it executes your code twice where you expect that the constructor is executed only once. So, don't use the constructor to set up your data but use the @PostConstruct annotation to execute a method with your initialisation logic in it.

    @PostConstruct
    public void init() {
     ... do your init here ....
    }         

You will see that the proxy object does not execute this code (which is obvious of course because the code is not in the constructor anymore). Another pitfall might be that during some kind of rapid prototyping action you store some state-data in a non-private field in the singleton or a stateful session bean. When you do not provide a getter/setter for the field, the field-value of the injected bean will always be null because the proxy gets injected and not the "real" instance. The proxy object does not store state. Let's test this:

     @LocalBean
     @Singleton
     @Startup
     public class MySingleton {
         protected String name = "whatever";
         .....
         public String getName() {
              return this.name;
         }
     }

We inject this bean in another session: 

     @LocalBean
     @Stateless
     public class MyTest {

          @EJB private MySingleton mySingleton;
          public void test() {
               // mySingleton.name --> null; (proxy)
               // mySingleton.getName() ---> "whatever" (real object)

         }
     }

The injected reference is the proxy object without state. Getting the value of the field directly must always return null when it is not initialised. The real state is maintained in the singleton. You can get the "real" data when you use the method "getName()" because the proxy object tunnels your method and not the field. This is the reason behind the fact that you may not use fields directly in session-beans. 

Well, as you might have expected, it is really a bad idea to get the field from a singleton or other bean directly (in general, it is an anti-pattern in J2EE). Try to encapsulate your data with nice getters and setters and keep in mind that your objects can get dynamic proxies depending on the annotations you add to the class.