Java – Are there any good J2EE value list handler pattern implementations

To understand the proper way to workaround Singletons, you need to understand what is wrong with Singletons (and global state in general):

Singletons hide dependencies.

Why is that important?

Because If you hide the dependencies you tend to lose track of the amount of coupling.

You might argue that

void purchaseLaptop(String creditCardNumber, int price){
  CreditCardProcessor.getInstance().debit(creditCardNumber, amount);
  Cart.getInstance().addLaptop();
}

is simpler than

void purchaseLaptop(CreditCardProcessor creditCardProcessor, Cart cart, 
                    String creditCardNumber, int price){
  creditCardProcessor.debit(creditCardNumber, amount);
  cart.addLaptop();
}

but at least the second API makes it clear exactly what the method's collaborators are.

So the way to workaround Singletons is not to use static variables or service-locators, but to change the Singleton-classes into instances, which are instantiated in the scope where they make sense and injected into the components and methods that need them. You might use a IoC-framework to handle this, or you might do it manually, but the important thing is to get rid of your global state and make the dependencies and collaborations explicit.

I have used AIR quite successfully for this sort of thing, and intend to converge with you at the MVC abstraction level. From one of my SO questions, my attention was directed to this. Maybe you could look it over and let me know what you think. At a high level it seems to coincide with your description of your design.

I'm using AMF - tried starting with JSON but AMF is more direct and for my purposes functionally equivalent.

My app is used by a couple dozen people across random platforms, Windows and Mac and Linux. Installation is painless. I post one installation package, and the Adobe installer figures out what runtime stuff is needed for the platform being served, and makes sure things are set up correctly with no attention on my part. It completely abstracts out platform dependencies, and there was no learning curve.