J2EE Blogger

Improvement on Hibernate Query Cache

2010-03-15T10:05:00.000-07:00

Cache improves performance by transparently storing data such that future requests for that data can be served faster. Hibernate offers a session scope transactional cache which spans the scope of the session. Hibernate also offers a configurable secondary level cache which spans across multiple sessions. Clustered/Distributed Caches can be configured so that it can be accessed across the entire application server cluster.

Hibernate secondary cache offers pretty good entity cache. Entity cache speeds up entity loading by its primary key. For instance:

select c from Cat c where c.id = :id

It supports query cache too, to enable query cache, you'll need to specify the hibernate property:

hibernate.cache.use_query_cache true

Query cache caches Query result sets, so the cache can provide you an answer for the queries like:

select p from Person p where p.sin = :sin

Let's say, the SIN of a person is never gonna change, so cache the above query will be useful.

Hibernate provides 'natural id' based on queries which can effectively solve the above problem. However, there are many other queries that hibernate cannot handle effectively. For instance, if we want to find all contact information (phone numbers only) for a person:

select pn from PhoneNumbers pn where pn.person.id = :pid

The primary problem for Query caches, is that hibernate will completely invalidated by any modification to the underlying table, even on entities that's totally unrelated to the query. In the above example, any insertion/update/deletion to the telephone table, on any record, will completely wipe out the entire cache for the above query.

There needs to be a 'smart query cache' to solve this problem. Fortunately, this can be done by providing custom query cache, and we can then refreshes them by listening on hibernate 'entity modification' events. The listener will allow us to intercept any insertion/update/deletion to any telephone record, and then we can determine to only refresh the affected query cache.

DisplayTag 1.2 Form Submission Problem

2009-02-15T16:10:00.001-08:00

Prior to 1.2, all the links generated by displaytag are Http Get only, which prevented it from being integrated into many web applications. Including ours. Those links includes paging/sorting and exporting links.

I had to solve the problem by using a customized TableTag along with custom javascript code. The solution was applied around the 1st week of December.

DisplayTag 1.2, released Dec. 27, 2008, solves the form submission problem. Now The paging/sorting links can actually be Http Post instead of Get. Woot!

However, they must have forgot the export link - it's still get only... Another custom patch...

Well one day I'll have to contribute it back to the open source project. Too busy recently.

Simple tip: Inject the nested class in Spring context

2008-09-03T10:09:00.001-07:00

It's a simple tip and is not mentioned in Spring reference docs:

When you want create a bean in Spring which is a nested class of some owner class, use the "$" to separate the owner class name and the nested class name like following example:

<bean class="org.balah.OwnerClass$NestedClass"

.....

Don't use the convention like "org.balah.OwnerClass.NestedClass" that is used in the source code usually. Because the Spring will use Class.forName() similar mechanism to find the class specified in the bean definition. As you use the Class.forName() to load a nested class, always use "$" to let the classloader locate the exact class file from your classpathes. The "." sperated convention just confused the class resolver anf finally throw a ClassNotFoundException.

Java7 new features: Personal View

2008-04-24T00:54:00.000-07:00

Ref: The incoming Java 7 new features

All about just one thing: Java is becoming a platform and heavier and heavier version by version.Losing its very authentic and original simple beauty purely from language perspective.

Actually all the ideas are not quite new or very original innovative, they have already appeared in various libraries, components, frameworks and products. Sun is just collecting and refurbishing those ideas in name of JSR process then put them in its own JDK's shoes. Afterwards, MS will borrow the ideas but make it much easier to use in its monolithic .NET tools than diverted java tools world.

However, it's still a good news that the new changes on the heavier new "JAVA platform" will definitely drive the success of simpler and straightforward emerging dynamic 2G languages on top of Java, such as Groovy, which is just copying the same story Java replacing C/C++/Delphi 10 years ago!

Let's see.

Inter-thread coordination: wait, notify and interrupt

2008-04-24T00:29:00.000-07:00

Just a sample code to test the inter-thread coordinating by using the object's wait and notify methods.

public class TestWaitAndNotify {

private final Object event = new Object(); private final Task1 task1 = new Task1(); private final Task2 task2 = new Task2(); private boolean stop; public TestWaitAndNotify() {

stop = false;

} public static void main(String[] args) throws InterruptedException {

TestWaitAndNotify twan = new TestWaitAndNotify(); twan.doIt();

} void doIt() throws InterruptedException {

task2.start(); task1.start(); stop = true; System.out.println("main:t [try to stop]"); synchronized (event){

System.out.println("main:t [notify all waiting threads]"); event.notifyAll();

} System.out.println("main:t [quit]");

} class Task1 extends Thread{

public void run(){

synchronized (event){

System.out.println("task1 running."); while(!stop){

System.out.println(">>>>>>>>task1 did"); event.notifyAll(); try {

System.out.println("task1 waiting."); event.wait(0); System.out.println("task1 wake");

} catch (InterruptedException e) {

throw new RuntimeException(e);

}

} System.out.println("task1 quit");

}

} class Task2 extends Thread{

public void run(){ synchronized (event){

System.out.println("Task2 running."); while(!stop){

try {

//Thread.sleep(10000); System.out.println("task2 waiting."); event.wait(0); System.out.println("task2 wake");

} catch (InterruptedException e) {

e.printStackTrace();

} System.out.println("<<<<<<<task2 did"); event.notifyAll();

} System.out.println("task2 quit");

} }

}

Conclusion:

The order of threads starting is important in order to make sure the threads are waiting and notifying in sequence per our expectation.
One object could be used as an event/signal to coordinate the threads behaviors by using wait and notify combination.
Don't swallow or ignore the InterruptedException as you usually will do. Try to handle it properly, because someone might try to stop the blocking thread by interrupt it. Especially you are doing some common library which might be called by various unknown classes in various unknown conditions. Ignore it in your codes might cause other guy's attempts fail.
Gracefully shutting down a thread by using an central control flag. However, a control thread or the main thread should try to call the coordinating object's notifyall before quit itself in order to wake up all the waiting threads and let them have a chance to shutdown gracefully.
You can not always assume the call to the interrupt method of a blocking thread will work as your wish if you try to wake up it and let it quit. The probable failure case is:

If the blocking of thread is caused by waiting for the monitor of a synchronized method, it can not release the lock. However, if it's the case that the thread is waiting for a synchronized object, it's possible the interrupt will release the lock.
InterruptedException ignored by any codes is running in the thread when its interrupt is called.

Incoming new Java 7 Featuers

2008-04-22T15:30:00.000-07:00

Alex Miller has an excellent summarize of the new Java 7 Featuers:

Improved Modularity Support (superpackages)

   1. superpackage example.bar.lib {  
   2.   
   3.     // member packages  
   4.     member package example.bar.lib;  
   5.   
   6.     // member superpackages  
   7.     member superpackage example.bar.lib.net, example.bar.lib.xml;  
   8.   
   9.     // list of exported types  
  10.     export example.bar.lib.Table;  
  11.   
  12.     export superpackage example.bar.lib.net;  
  13. }

Java Module System
A distribution format and a repository for collections of Java code and related resources. It also defines the discovery, loading, and integrity mechanisms at runtime. Defines a new deployment archive called a JAM (Java Module). The Java Module is a JAR file that contains other JARs, resources, and metadata. JAMs can specify which portions of the module are public and which are hidden. JAMs can specify dependencies on other modules.

Java Kernel
Implement Java as a small kernel, then load the rest of the platform and libraries as needed, with the goal of reducing startup time, memory footprint, installation, etc. In the past this has also been referred to as “Java Browser Edition”.

NIO2
APIs for filesystem access, scalable asynchronous I/O operations, socket-channel binding and configuration, and multicast datagrams.

Date and Time API
A new and improved date and time API for Java. The main goal is to build upon the lessons learned from the first two APIs (Date and Calendar) in Java SE, providing a more advanced and comprehensive model for date and time manipulation.

Units and Quantities
one or more Java packages for the programmatic handling of physical quantities and their expression as numbers of units.

JCache API
Standardizes in process caching of Java objects in a way that allows an efficient implementation, and removes from the programmer the burden of implementing cache expiration, mutual exclusion, spooling, and cache consistency.

Concurrency Utilities
New kind of BlockingQueue called TransferQueue and a fine-grained parallel computation framework based on divide-and-conquer and work-stealing.

XQuery API
An API for executing XQuery calls and working with results. XQJ is to XQuery what JDBC is to SQL. At a glance, the XQJ API intentionally shares many high-level concepts from JDBC (DataSource, Connection, etc) but supports XQuery specific concepts such as static and dynamic phases, XML-oriented retrieval, etc.

Resource Consumption Management API
Allow for partitioning resources (constraints, reservations) among Java applications and for querying about resource availability (notifications). It will also provide means of exposing various kinds of resources. Example resources are heap memory size, CPU time, open JDBC connections, etc. The goal is to allow resources to be managed so that multiple applications might run simultaneously in a JVM and be given finite amounts of memory, cpu, etc. This JSR will build on top of JSR 121 Isolates.

Swing Application Framework
A simple application framework for Swing applications. It will define infrastructure common to most desktop applications. In so doing, Swing applications will be easier to create.

Beans Binding
An API that allows two properties of two beans to stay in sync. Formalizes an API for connecting JavaBeans.

Beans Validation
Define a meta-data model and API for JavaBeanTM validation based on annotations, with overrides and extended meta-data through the use of XML validation descriptors.

Java Media Components
Support for video to Java. It will initially address playback and ultimately will also cover capture and streaming. Video playback will provide support for both native players and a pure Java player.

JMX 2.0
Updates the JMX and JMX Remote APIs to improve usability of existing features and add new functionality such as annotations for ease of development, federated JMX servers, etc.

Web Services Connector for JMX
A connector for the JMX Remote API that uses Web Services to make JMX instrumentation available remotely. Clients do not have to be Java applications, but can be.

Javadoc Technology Update
New tags and generated Javadoc document representation aimed to increase readability, information richness, and make the Javadoc more approachable to developers learning and using the APIs.

Reified Generics
Currently, generics are implemented using erasure, which means that the generic type information is not available at runtime, which makes some kind of code hard to write. Generics were implemented this way to support backwards compatibility with older non-generic code. Reified generics would make the generic type information available at runtime, which would break legacy non-generic code. However, Neal Gafter has proposed making types reifiable only if specified, so as to not break backward compatibility.

Type Literals

   1. Type<List<String>> x = List<String>.class;

Annotations on Java Types
enriches the Java annotation system. For example, it permits annotations to appear in more places than Java 6 permits; one example is generic type arguments (List<@NonNull Object>). These enhancements to the annotation system require minor, backward-compatible changes to the Java language and classfile format.

Type Inference
Constructor invocation can be changed from:

   1. Map<String, List<String>> anagrams = new HashMap<String, List<String>>();  
   2. to   
   3. Map<String, List<String>> anagrams = new HashMap<>();

and explicit type references can now be inferred changing:

# timeWaitsFor(Collections.<Man>emptySet());  
# to  
# timeWaitsFor(Collections.emptySet());

Closures
A closure is a function that captures the bindings of free variables in its lexical context. Closures support passing functions around and make many anonymous inner class use cases easier to use. In addition, they support additional high-level programming abstractions.

Automatic Resource Block Management

   1. // Start a block using two resources, which will automatically   
   2. // be cleaned up when the block exits scope  
   3. do (BufferedInputStream bis = ...; BufferedOutputStream bos = ...) {  
   4.      ... // Perform action with bis and bos  
   5. }

Language level XML support

   1. elt.appendChild(  
   2.     <muppet>
   3.         <name>Kermit</name>
   4.     </muppet>);

JavaBean Property Support

   1. public property String foo;   
   2. a->Foo = b->Foo;

BigDecimal operator support
Support for manipulating BigDecimal objects with arithmetic operators (just like other numeric primitives) instead of via method calls.

Strings in switch statements

# static boolean booleanFromString(String s) {  
#     switch(s) {  
#       case "true":  
#         return true;  
#       case "false":  
#         return false;  
#     }  
#     throw new IllegalArgumentException(s);  
# }

Comparisons for Enums

   1. boolean isRoyalty(Rank r) {  
   2.     return rank >= Rank.JACK && rank != Rank.ACE;  
   3. }

Chained Invocation

   1. class Factory {  
   2.      void setSomething(Something something) { ... }  
   3.      void setOther(Other other) { ... }  
   4.      Thing result() { ... }  
   5.  }  
   6.   
   7.  Thing thing = new Factory()  
   8.      .setSomething(something)  
   9.      .setOther(other)  
  10.      .result();

Extension methods

   1. import static java.util.Collections.sort;  
   2. List<String> list = ...;  
   3. list.sort();    // looks like call to List.sort(), but really call to static Collections.sort().

Improved Catch Clause

# try {  
#      return klass.newInstance();  
#  } catch (InstantiationException | IllegalAccessException e) {  
#      throw new AssertionError(e);  
#  }

invokedynamic
Introduces a new bytecode invokedynamic for support of dynamic languages.

Tiered compilation
Tiered compilation uses a mix of the client (JIT) and server hot spot compilers - the client engine improves startup time by using JIT over interpreted and the server hot spot compiler gives better optimization for hot spots over time.

G1 Garbage Collector
G1 (for “garbage first”) is a single collector that divides the entire space into regions and allows a set of regions to be collected, rather than split the space into an arbitrary young and old generation. Sun intends to make this new collector the default in Java 7. (This applies only to the Sun JDK.)

More Script Engine
additional language interpreters to JSE. The JavaScript Rhino engine was added in Java 6. Leading candidates for Java 7 are: JRuby, Jython, and Beanshell.

GIS For Web Developers

2008-04-20T15:29:00.001-07:00

Scott Davis on Seattle NFJS Java Conference

ACT1 - Free Data Available

- Raster Data, Google Satellite

- Vector Data, Google Map

- Hybrid, Google Satellite + Google Map Hybrid mode

Type of Vectors

- Point

- Line

- Polygon

Free Vectors: www.census.gov

Shapefile: well documented proprietary ESRI standard, .shp, .shx, .dbf

Downloadable States of America: http://www.census.gov/geo/cob/bdy/st/st00shp/st99_d00_shp.zip

ESRI free viewer: http://www.esri.com/software/arcexplorer/download.html

More data, please: http://www.nationalatlas.gov

Canada: http://www.geobase.ca

For local data, most state and municipal government agencies offer free data as well.

ACT2 - Projections

Earth is round but maps are flat, projections take fundamentally 3d data and portraying it in 2-dimensions, this procedure introduce error for distance, direction, shape, area. On a Cartesian Planes, X and Y lines form perfect squares, however, on a globe, only the line of Latitude are perfectly parallel, line of Longitude converge at the poles. Different projections attempt to minimize map distortions, common projections are "State Plane" and "UTM".

Reprojection Utility available: GDAL

EPSG Codes: http://www.epsg.org

ACT3 - Spartial Databases

Why bothers with a database?

- Centralize many scattered files

- Provide security

- Indexing

- Cross dataset queries

PostgreSQL + PostGIS: http://postgis.refractions.net

Visualizing the Data: uDig

ACT4 - Web Services

- Google Maps, undeniably cool, proprietary interface

- Open set of standards available: Open Geospatial Consortium (OGC)

- OGC Features: GetCapabilities, DescribeFeatureType, GetFeature

- Data Service: WFS (Web Feature Service), WMS (Web Mapping Service)

- Open standard, any one can implement them: http://opengeospatial.org/resource/products

- GeoServer: Java based, runs in a Servlet container, provides OGC web services

- MapBuilder: Pure Javascript web client for OGC, included with GeoServer

- Explore Our Planet

- OpenLayers: Pure javascript web client, supports OGC, Google Maps, Yahoo Maps, MS Virtual Earth and WorldWind

Acceptance Testing Application Behavior

2008-04-20T14:10:00.000-07:00

Venkat Subramaniam on Seattle NFJS Java Conference

How do you ensure your applications meet the expectations of your key customers?

Agile Development, it's all about building relevant working software by constantly getting feedback. Testing is a key ingredient in Agile development.

Type of tests and Level:

- UI/Presentation: Watir, Selenium

- Controls/Services: BDD/FIT

- Classes/Models: Unit Testing

Gathering requirement is a challenge. Use case helps, but often tend to be heavy weight and in effective beyond certain point of diminishing returns. Agile development use User Stories. When creating User Stories, 3Cs is important:

- Card: Feature expressed in an index card

- Conversation: Use short description as starting point for useful discussions that promote exploration and understanding

- Confirmation: Tests are written as a way to confirm completion of feature development

INVEST in User Stories:

- Independent

- Negotiable

- Valuable

- Estimable

- Small

- Testable

FIT: Framework for Integration Testing

- General purpose open-ended framework for expressing tests

- Help focus on business perspectives

- Easy for non-programmers to use (Table represent tests)

- Automated checking and reporting of results

- Useful for Business Rules related to business calculation and business process/workflow

How does it FIT together?

- Table of Tests, expresses expectations by way of examples

- Fixture, check that the system satisfied the given tests

- Column Fixture, helps test calculations

- Action Fixture, helps test events or actions

- Row Fixture, helps test collections

Tables are in pure html, which includes the test that the fixture will be used to execute on. Fixture is glue code in java that extends from FIT abstract Fixtures.

FitNesse provides a single web based UI for developing, running and viewing results of test.

BDD - Behavior Driven Design

- Each behavior is expressed as a test/exercise method

- It tells what the object should do

- Java Tools for BDD: JBehave, JDave, beanSpec, Instinct

- Groovy Tools for BDD: GSpect, easyb

Reference:

http:/fit.c2.com

http://www.fitnesse.org

http://behavior-driven.org

http://jbehave.org

http://codeforfun.wordpress.com/gspec

http://www.easyb.com

Pragmatic Programmer

2008-04-20T10:46:00.000-07:00

http://www.codinghorror.com/blog/files/Pragmatic%20Quick%20Reference.htm

It summarizes the tips and checklists found in book The Pragmatic Programmer.

10 Ways to use Hibernate Effectively, by Brian Sam Bodden

2008-04-20T10:32:00.000-07:00

Brian Sam Bodden on the Seattle NFJS Java Conference.

- Inheritance, Table per Concrete Class, Table per Class Hierarchy, Table per Subclass

- Identify and use Components in the Mapping

- Dynamic Data Filtering can be enabled in either HBM file or use Annotation

- While generated SQL is good enough in most case, Hibernate does support Customer SQL as well as native SQL with direct JDBC connection. iBATIS alike but you only require to customize the SQL when needed.

- Bulk Operations - Enable JDBC Batching & Be mindful of Session and 2nd Level Cache

- Cache - Session Cache & 2nd Level Cache, Read-Only, Read/Write & Query Cache

- Terracotta - Claims of performance gains in the range of 2-4x when integrating with second level cache

- Hibernate Search - Free text search with Lucene, Annotation driven, luceneQuery = parser.parse("name:beckham or name:galaxy")

- Profiling/Debugging - beware of the Write behind fact of Hibernate. p6spy, Jahia's SQL Profiler, Hibernate Statistics

- Hibernate/Jboss Tools - http://www.hibernate.org/255.html

- Hibernate Tips & Tricks Page: http://www.hibernate.org/118.html

Watch out for Lazy Initialization when you schedule a job

2008-04-20T10:06:00.000-07:00

http://www.jroller.com/habuma/entry/a_funny_thing_happened_while

Spring should probably initialize those Job Scheduler more actively. Lazily initialize things like that sounds not a good idea.

Spring Security by Craig Walls

2008-04-20T09:09:00.000-07:00

Craig Walls presented the Spring Security Session at the latest NFJS Java Conference in Seattle.

What ACEGI Offers?

- Declarative Security, keeps security details out of your code

- Authentication and Authorization, against virtually any user store

- Support for anonymous sessions, concurrent sessions, remember-me, channel enforcement, and much more

- Spring-based, but can be used for non-Spring web framework

ACEGI's moving parts:

- Security Interceptors, aspects for methods, filters for servlets

- Managers, Authentication, Access Decision, Run-As, After-Invocation

- Authentication Providers

- Access Voters

Security Intercepter - First line of defense

Authentication Manager - Verifies user identity

Access Decision Manager - Determines if the authenticated user has authority to access the secured resource, by aggregating the result from the Voters

Run-As Manager - Temporarily replaces user's Authentication object for the duration of the current secure invocation

After Invocation Manager - Reviews the object returned from a secured invocation, allows for 'after-the-fact' security

The problem of ACEGI

Every time you use Acegi... A fairy dies... It's a great framework but is very hard to use.

- Lots of moving parts

- Lots of options

- Everything is a <bean> with various options injected with <property>

- Requires lots of XML

Spring Security 2.0

- Released last week (Apr.15th)

- All the Same goodness with some new stuff with much less XML

- Provides a new security configuration namespace for Spring that hides <bean> <property>

- Provides auto-configuration

Method Security

- Intercepting method using Spring AOP

- Or, Annotation Driven

How CRAP is your java source code?

2008-04-19T18:11:00.000-07:00

Crap4j, a Java implementation of the CRAP (Change Risk Analysis and Predictions) software metric - a mildly offensive metric name to help protect you from truly offensive code.

I guess nobody likes it if his code's CRAP level is high. In fact I found this to be really useful when we talk about code quality.

Download from: http://www.crap4j.org/. Ideally we'd like the build script to output a CRAP report automatically, just like it'll run the test cases automatically.

Spring, Hibernate, and GWT Tutorial

2008-04-15T16:03:00.001-07:00

GWT is hot at client side but we still needs Spring/Hibernate to support it on the server side. Here is how. Courtesy of eggsylife blog.

Part 1: http://eggsylife.blogspot.com/2007/10/well-this-tutorial-aims-at-helping.html

Part 2: http://eggsylife.blogspot.com/2007/11/hibernate-spring-google-web-toolkit.html

Part 3: http://eggsylife.blogspot.com/2008/02/hibernate-spring-google-web-toolkit.html

And this GWT crash course is helpful too: http://google.wikia.com/wiki/Jump_Start_Your_AJAX_Development_with_the_Google_Web_Toolkit

A lot more here:
http://www.j2eeblogs.blogspot.com/2008/03/gwt-tutorials.html

Will it Compile?

2008-04-09T09:56:00.000-07:00

This small sample project uses two libraries, apache-log4j-1.2.15 from www.apache.org and jpos-1.6.0-r2465 from www.jpos.org. Both are latest version as of the date I write this blog - freshly downloaded. The jpos library comes with no pre-packaged distribution jar file, thus we used ant to build the jar file from it's source files and the build.xml.

Besides that, we have a source file of our own, A.java:

import org.apache.log4j.Logger;

/**
* A.java
*/
public class A {
  static Logger logger = Logger.getLogger(A.class);

  public static void main(String[] args){
      logger.trace("blah blah");
  }
}

It does nothing except log a message at trace level. The question here is, will this compile?

The answer? Yes and No. Depends how you compile it.

To demonstrate the problem, we'll just try to use the command line to compile it, instead of using apache-ant or any IDE. It helps us to identify the root of the problem. (Assume lib is where you put your libraries, also we have two version of j2sdk installed, 1.4.2_16 under c:\j2sdk1.4.2_16, 1.5.0_14 under c:\jdk1.5.0_14.)

c:\j2sdk1.4.2_16\bin\javac -classpath lib\apache-log4j-1.2.15\log4j-1.2.15.jar;lib\jpos-1.6.0-r2465\build\jpos.jar src\*.java

Result: Compile success.

c:\jdk1.5.0_14\bin\javac -classpath lib\apache-log4j-1.2.15\log4j-1.2.15.jar;lib\jpos-1.6.0-r2465\build\jpos.jar src\*.java

Result: Compile Success.

Now swap the classpath entries and try it again:

c:\j2sdk1.4.2_16\bin\javac -classpath lib\jpos-1.6.0-r2465\build\jpos.jar;lib\apache-log4j-1.2.15\log4j-1.2.15.jar src\*.java

Result: Compile success.

c:\jdk1.5.0_14\bin\javac -classpath lib\jpos-1.6.0-r2465\build\jpos.jar;lib\apache-log4j-1.2.15\log4j-1.2.15.jar src\*.java

Result:
src\A.java:12: cannot find symbol
symbol  : method trace(java.lang.String)
location: class org.apache.log4j.Logger
      logger.trace("blah blah");
            ^
1 error

Surprise, huh? Try it yourself.

Everything comes with a reason. Since jdk1.5, both java and javac recurse the manifest classpath of a jar on the java classpath. Looking into jpos.jar, we found that its manifest file says to use log4j-1.2.8.jar and the trace method wasn't supported till log4j-1.2.12 or above.

jpos.jar manifest file entry:

Class-Path: lib/bsh-2.0b4.jar lib/commons-cli.jar lib/jdbm-1.0.jar lib
/jdom-1.0.jar lib/log4j-1.2.8.jar lib/mx4j-impl.jar lib/mx4j-jmx.jar
lib/mx4j-tools.jar lib/classes

That's the reason why the compilation error happened - javac was instructed to used log4j-1.2.8.jar come with the jpos distribution, instead of the the 1.2.15 that we want it to use.

Conclusion? Well, I don't know what to say here, but this looks something similiar to the windows DLL hell problem. And it was called DLL 'Hell' for a reason.

Further reading: How classes are found?

Microsoft favours Enterprise Java Platform

2008-04-03T09:46:00.001-07:00

Microsoft is using Tomcat and JSP rather than IIS+.Net

Today I happened to catch an error screen from MSN china.
What an ironic screen of Microsoft WEB toolkits marketing policy!

Someone may say it's not true and it was a Fools day joke! O.K, see the further picture that what's the link of http://msn.china.ynet.com:

And more, you can right click any of the url on its page to see the detail of the link properties. What, something like:

http://msn.china.ynet.com/view.jsp?oid=32306246

Although you can say it's just a partner, who cares! Totally wrong, it's Microsoft's Chinese MSN portal which is branded as MSN and Microsoft!

However, it may give Microsoft a chance to say "you see our demos of how unstable of a free software like Tomcat, JSP, Linux, MySql combination! We are considering migrate them to IIS2020+.NET2020+SqlServer2020!".

Wait, one more footnote "until we can make even of MSN in China!".

TypeSafe Enum and equals()

2008-04-02T09:40:00.000-07:00

At first it seems a No Brainer Problem

If you assign the same pre-initialized instance of the same class to two variables, do they always equal to each other? Note that this is the typical pre-jdk1.5 typesafe enum pattern.

public class ReagentType implements Serializable{
private static final String PROTEIN_TYPE = "PROTEIN";
// more types here

public ReagentType PROTEIN = new ReagentType(PROTEIN_TYPE);
// more pre-initialized instance here

private String type;

public String getType(){
  return this.type;
}

private ReagentType(String type){
    this.type = type;
}

public void checkEquals(ReagentType a, ReagentType b){
    System.out.println(a.equals(b));
}

public static void main(String[] args){
    ReagentType a = ReagentType.PROTEIN;
    ReagentType b = ReagentType.PROTEIN;

    checkEquals(a,b);
}

}

Sounds like a no brainer. The answer obviously should be yes. checkEquals() method will print out "true". Always. That is, in an ideal world.

However...

In real world, assuming a & b are both assigned to ReagentType.PROTEIN, in many cases we will see checkEquals() method prints out "false". The standard java equals() compares object identity, which is nothing but the memory location of the object instance, which will most certainly fail in a real world deployment environment.

Consider Distributed Computing. Either a or b has travelled the wire before checkEquals() method gets it, a.equals(b) is false. They resides in two different memory location.
Even in a single server, after serializable/deserialization, it's guranteed that an object will have a different memory location. a equals() the serialize/deserialized copy of itself, is false.
Consider an EJB invoking a method in another EJB, if they're packaged in different deployment JARs and both contains the ReagentType class, depends how the class loading mechanism in app-server works, there might exists many pre-initialized instance of the REAGENT object and they have different memory location.

Solutions.

Oh yeah, there's always solutions. For one, implement the equals() method properly.

public boolean equals(Object obj){
  if (obj!=null && obj instanceof ReagentType){
      return getType().equals( ((ReagentType)obj).getType());
  } else {
      return false;
  }
}

// hashcode() methods omitted here

For two, for those who're not big fan of the typesafe enum pattern, they can simply fall back to the good old set-of-static-primitive-values enumeration.

A note is that while implementation of the RMI readResolve() method might seem to solve this problem, it actually will fail in scenario 3, since the container may decide not to perform serialize/deserialize if the EJBs resides in the same server. However the readResolve() solution should be safe in non-EJB situation where the class loading situation is simpler.

Java Constructor Invocation and Instance Variable Initialization

2008-03-31T17:08:00.000-07:00

This is a tricky one:


abstract public class BasePayment {
public BasePayment(){
 setFakeValue();
}
abstract public void setFakeValue();
}

public final class Payment extends BasePayment{
private String property = null;
public Payment(){
 super();
 System.out.println("after super(): " + this.getProperty());
}
public String getProperty() {
 return property;
}
public void setFakeValue() {
 System.out.println("Calling setFakeValue()");
 this.property = "property";
 System.out.println("After setFakeValue(), property: " + this.getProperty());
}

public static void main(String[] args) throws Exception{
 Payment p = new Payment();
 System.out.println("'new'ed a Payment, property value: " + p.getProperty());
}
}

What the println in the main() method will output? null? "property"?

It has something to do whether java will initialize the instance variable first, or will invoke the constructor of the super class first. The behaviour is fully documented (it better be!) at http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.8.7.1

And yes, the output is 'null'.

Watch out for java SimpleDateFormat

2007-12-11T17:51:00.001-08:00

Look at this code, what it will come out?

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test{
public static void main(String[] args){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date dt = null;
try{
dt = sdf.parse("2000999878-3454555-35344");
System.out.println(sdf.format(dt));
}catch (Exception e){
System.out.println("error");
}
}
}

The result is:

247625706-07-03

Is this what you expected? You thought it would have thrown an exception of invalid format of text you passed in.

It's very common for a developer do date and time data conversion from text and vice versa in different format. Will it breach your boundary validation if you purely rely on this stupid SimpleDateFormat class?

Work around so far like:

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test{
public static void main(String[] args){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date dt = null;
try{
dt = sdf.parse("2000999878-3454555-35344");
String s = sdf.format(dt);
if(!s.equals("2000999878-3454555-35344"))
System.out.println("Data format wrong!");
}catch (Exception e){
System.out.println("error");
}
}

Ugly codes, but works.

How many online Web systems relying on Java and J2EE have those codes?

Manageable Spring Application - enable JMX in minutes

2007-11-07T11:13:00.001-08:00

We are keeping talking about manageability of an application. Why is it so important? Because at any stage of the application lifecycle, you need a way to probe the some key aspects of the application's internal status and take appropriate actions to change the application's behaviors as a consequence. Without it, you just guess the application's runtime status and never able to steer it per your needs.

But hold on, it's easy to talk about manageability. And it's really a great idea in the air until you want put it in a concrete base in your application. It's so cumbersome, tedious and error prone to make an implementation. There are couples of option you could choose to inject the manageability in your application:

Your own proprietary mechanism.
Standard SNMP
JMX

Forget about option 1, smart as you, don't want invent any wheel. Well, SNMP (Simple Network Management Protocol) sounds good: standardized, bunch of tools and applications and really structured, until you dig in the details of all the ugly OID (Obejct Identification) definitions, binary format, pure data driven approach. And difficulties of debugging. Plus extra cost for those usable commercial SNMP tools and editors.

Fortunately, we are in campus of Java, which is so far the only language and platform that put the serious crucial enterprise aspects intrinsically in the body, especially manageability in an offer as JMX. For the people working for .Net, either they just don't know what is the manageability, or struggling with various proprietary approaches or annoying SNMP stuffs.

Best of the best in Java application manageability is that we have the generous platform MBean Server as a gift from SUN in new version of JVM, which save your efforts looking for a MBean server; we have the JConsole as tool to directly craft your JMX management GUI frontend; and the offer from Spring's JMX supports. Combine them together, you can make any Java application JMX enabled in minutes.

Here is a simple example called MockServer. It's just a simple socket server for any mock testing purpose. With JMX, you can get the information and stop it in runtime.

Following is the partial code snippets, which is definitely the beautiful POJO. No any special MBean or MXBean stuffs in it, see!

/**
* A mock Socket server.
*/
public class MockServer implements Runnable{
private String name="";
private int port = 80;
private boolean bSSL = false;
private int sotimeout = 2*60*1000;//2 minutes

private ServerSocket listeningSocket = null;
private boolean bStop=false;
private long connCounts = 0; //Ongoing total connection counter.

public MockServer(String name, boolean isSSL, int port, int sotimeout){
this.name = name;
this.bSSL = isSSL;
this.port = port;
this.sotimeout = sotimeout;
}

public String getName(){
return name;
}

public int getPort(){
return port;
}

public boolean isSSL(){
return bSSL;
}

public int getSotimeout(){
return sotimeout;
}

public boolean isStopped(){
return bStop;
}

public void stop(){
bStop = true;
try {
listeningSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}

protected void createListeningSocket() throws IOException {
ServerSocketFactory factory = (bSSL? SSLServerSocketFactory.getDefault():ServerSocketFactory.getDefault());
listeningSocket = (ServerSocket) factory.createServerSocket(port);
}

public void run(){
System.out.println("Server: "+getName()+" started.");
try {
createListeningSocket();
while (!isStopped()){
Socket worker = listeningSocket.accept();
//Spawn a thread to handle the request.
fork(worker);
}
}catch (Exception e){
e.printStackTrace();
}finally {
if (null!=listeningSocket){
try {
listeningSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println("Server: "+getName()+" stopped.");
}

protected void fork(Socket worker){
Thread wt = new Thread(new Worker(worker));
wt.start();
}

public long getConnCounts(){
return connCounts;
}
protected synchronized void addCount(){
this.connCounts++;
}
protected synchronized void minusCount(){
this.connCounts--;
}

protected class Worker implements Runnable {
private Socket socket=null;

protected Worker(Socket socket){
this.socket = socket;
}

public void run() {
addCount();
byte[] buf = new byte[1024*10];//10K buffer
InputStream is;
OutputStream os;
try {
//Read request from socket input stream.
is = socket.getInputStream();
int size = is.read(buf);
is.close();
//Process the request.
byte[] resp = processRequest(buf, size);

//Write back the response to socket output stream.
os = socket.getOutputStream();
os.write(resp);
os.flush();
os.close();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(null != socket){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
minusCount();
}
}
}

//Subclasses to override it.
protected byte[] processRequest(byte[] buf, int size){

return buf;//echo it.

}
}

/**
* A mock server services to manage the mock servers.
*/
public class MockServerService {
private Set<MockServer> servers = null;

public void setServers(Set<MockServer> servers){
this.servers = servers;
}

protected void init(){
if(null != servers){
for(MockServer server: servers){
new Thread(server).start();
}
}
System.out.println("Service initialized.");
}

public Set<MockServer> getServers(){
return servers;
}

public void stop(){
if(null != servers){
for(Server server: servers){
server.stop();
}
}
System.out.println("Service stopped.");
}
}

Then we need an application entry point and integrate with Spring.

public class MockServer {
public static void main(String[] args){
AbstractApplicationContext ctxt = new ClassPathXmlApplicationContext("context-mockserver.xml");
ctxt.registerShutdownHook();
MockServerService service = (MockServerService) ctxt.getBean("mockServerService");
service.init();
}
}

the context file for Sring defining the beans.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="mockProcessor0" class="MockServer" >
<constructor-arg index="0" value="Server1"/>
<constructor-arg index="1" value="false"/>
<constructor-arg index="2" value="80"/>
<constructor-arg index="3" value="120000"/>
</bean>
<bean id="mockProcessor1" class="MockServer" >
<constructor-arg index="0" value="Server2"/>
<constructor-arg index="1" value="false"/>
<constructor-arg index="2" value="90"/>
<constructor-arg index="3" value="120000"/>
</bean>
<bean id="mockProcessor2" class="MockServer" >
<constructor-arg index="0" value="Server3"/>
<constructor-arg index="1" value="false"/>
<constructor-arg index="2" value="100"/>
<constructor-arg index="3" value="120000"/>
</bean>

Until now, nothing to do with JMX. You can run it as a normal Spring application. You can use JConsole to connect with it locally, if you run the application in this command line:

java -cp . -D-Dcom.sun.management.jmxremote MockServer

This is the snapshot of JConsole MBeans tab. Besides the default threads, memory etc. JVM MXBeans, you can't do anything else to this application.

Now, let's just simply tweak the context file, then see what happens. Add this extra block just at the end of the context file.

...

<bean id="mockServerService" class="MockServerService">
<property name="servers">
<set>
<ref local="mockProcessor0"/>
<ref local="mockProcessor1"/>
<ref local="mockProcessor2"/>
</set>
</property>
</bean>
<bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
<property name="beans">
<map>
<entry key="bean:name=MockProcessor0" value-ref="mockProcessor0"/>
<entry key="bean:name=MockProcessor1" value-ref="mockProcessor1"/>
<entry key="bean:name=MockProcessor2" value-ref="mockProcessor2"/>
<entry key="bean:name=MockServerService" value-ref="mockServerService"/>
</map>
</property>
</bean>
...

Here it is! The new JConsole MBeans tab populated with your beans. Now you can see the name of each bean and stop it just by invoking the corresponding stop() method of that bean. Done! You can manage your Spring application now!

In a nutshell, following this pattern, you can tweak any of your applications to be manageable in minutes:

Define the management interfaces for your Object.
Spring your application and expose the object as MBean you want control. Nevertheless, Spring is a extremely noninvasive container, don't be afraid. The things need you Springlize is just make a context file for beans, add less than 5 lines of code to create the application context and put the spring.jar in your classpath. Everything is so familiar to you in a POJO world.
Enable the JVM JMX platform MBean server in command line with -Dcom.sun.management.jmxremote and run it.
Launch the JConsole and connect to the application then control it in your hands.

1.5 & 2 Factor Authentication

2007-11-06T09:37:00.000-08:00

1.5 factors:

The Grid data solution:
http://www.brianmadden.com/blog/iForum07/Grid-Data-Security-introduces-really-cool-15-factor-authentication-for-Citrix

Passmark Security's (acquired by RSA):
http://www.rsa.com/node.aspx?id=3072

2 factors:
http://en.wikipedia.org/wiki/Two-factor_authentication

However, don't trust these too much because 2 factor authentication does not work:

http://blog.washingtonpost.com/securityfix/2006/07/citibank_phish_spoofs_2factor_1.html
http://www.schneier.com/blog/archives/2005/03/the_failure_of.html
http://www.vnunet.com/vnunet/news/2139253/two-factor-authentication
http://www.channelregister.co.uk/2005/03/15/2-factor_auth_is_pants/
http://www.cafeid.com/art-sitekey.shtml

Man-in-the-middle attack:

An attacker puts up a fake bank website and entices user to that website. User types in his password, and the attacker in turn uses it to access the bank's real website. Done right, the user will never realize that he isn't at the bank's website. Then the attacker either disconnects the user and makes any fraudulent transactions he wants, or passes along the user's banking transactions while making his own transactions at the same time.

Trojan-horse attack:

Attacker gets Trojan installed on user's computer. When user logs into his bank's website, the attacker piggybacks on that session via the Trojan to make any fraudulent transaction he wants.

To fight these type of attack:

The problem here is that the bank's website doesn't authenticate the message source. The attacker's computer sends the transaction request to the bank, and the bank trusted it blindly during and after the authentication process. The message source, i.e. both the hardware and the software sending the message, must include itself as part of the authentication token as well as in the following transaction requests.

In the trojan-horse attack, the trojan software is not the original software that generates the request. It will try to generate the exact same transaction request the original software will be generating, but ultimitally, it is still not the original software and cannot predict the behaviour of the original software in a full scale. As long as the original software is properly protected against reverse-engineering and have a way to generate some ever-changing additional piece of information that the server can use to validate it's authenticity, (better, this piece of information has something to do with the transaction request itself), it makes it more difficult for the trojan to generate his own transaction request for his own benefit.

In the man-in-the-middle attack, the hacker does not own the user's computer, he cannot overcome this obfuscate without physical involvement. Serial number of the CPU of user's computer? MAC of one of his network card? Some secret signature on user's hard-disk? The problem is that the cient and the server must, separately, has a way to obtain this piece of information independent of each other. This can be quite a difficult problem.

In case of http request, one way I can think of is to use the REMOTE_ADDR cgi variable. Server can get this from the http header, client can get this, by performing a lookup to sites like
http://www.whatismyip.org/ or some similar service provided by the bank.

The client can use REMOTE_ADDR to salt the authentication token as well as future requests. The server can decrypt it using the REMOTE_ADDR variable in the request. Thus, if the man-in-the-middle intercepted the communication and try to relay it to the server, the authentication will be invalid because the REMOTE_ADDR is different as in the original request.

In order to defeat this, the man-in-the-middle will need to not only intercept the communication to the bank, but also to intercept the client's request to get the REMOTE_ADDR and respond with the REMOTE_ADDR of the phishing website. This will require a network device very close to the user's computer, and is quite difficult for most phishing sites.

Another method the man-in-the-middle can try is to decrypt the communication and re-encrypt it with his own REMOTE_HOST environment setting. The way we can fight against this is to use a strong encryption algorithm that needs some good amount of time to be defeated. Thus, by the time the communication is decrypted and re-encrypted, the ever-changing part is already invalid and useless. RSA? SHA? RIPEND? http://www.keylength.com/

Do they work?

Unfortunately, the above solution also does not work. the attacker, being his first step, is to analyze the site/application he's going to phish, and because of the openess of the web page, any code generating the hardware/software identification token will be discovered sooner or later, and he'll incorporate them in the phishing website/trojan software. It'll be more difficult for him if it's a obfuscated standalone application and/or webpages with their source code protected (http://www.antssoft.com/htmlprotector/index.htm), but not at all impossible.

Spring Property Placeholder Configurer

2007-11-06T09:26:00.000-08:00

A way to separate configuration parameters: http://almaer.com/blog/spring-propertyplaceholderconfigurer-a-nice-clean-way-to-share

Singleton vs. Multiton & Synchronization

2007-10-25T14:44:00.000-07:00

1. The classic java singleton synchronization problem

public class Singleton{
private static Singleton instance;

/** Prevents instantiating by other classes. */
private Singleton(){}

public static synchronized Singleton getInstance()
 if (instance == null){
     instance = new Singleton();
 }
 return instance;
}
}

The synchronized keyword on the getInstance() method is the evil. In a multi-thread environment, every thread will be blocked by each other when trying to grab the singleton instance. This is the classic java singleton synchronization problem.

2. The traditional solution using a static variable

public class Singleton {
private final static Singleton instance = new Singleton();

/** Prevents instantiating by other classes. */
private Singleton() {}

public static Singleton getInstance() {
 return instance;
}
}

The singleton instance is initialized during the class loading time. No synchronization is necessary on the getInstance level

3. The Classic synchronized Multiton

public class Multiton{
private static final HashMap<Object, Multiton> instances = new HashMap<Object, Multiton>();

private Multiton(){}

public static Multiton getInstance(Object key){
 synchronized (instances) {
     // Our "per key" singleton
     Multiton instance;
     if ((instance = instances.get(key)) == null) {
         // Lazily create instance and add it to the map
         instance = new Multiton();
         instances.put(key, instance);
     }
     return instance;
 }
}
}

The Multiton pattern begins with the concept of the Singleton pattern and expands it into an object pool of keys to objects. Instead of having a single instance per runtime, the Multiton pattern ensures a single instance per key. It simplifies retrieval of shared objects in an application.

As we noticed from the above scriptlet, the access to the getInstance() method is synchronized to ensure the uniqueness of instance per key. This, again, is a performance bottleneck in multi-thread environment. The traditional 'static' solution for Singleton pattern can't be used here since the keys are passed into the Multiton on-the-fly. We have no way to predict how many keys will be passed into the Multiton during the runtime.

4. The double-checked locking solution

public class Multiton {
private static final HashMap<Object, Multiton> instances = new HashMap<Object, Multiton>();

public static Multiton getInstance(Object key) {
 // Our "per key" singleton
 Multiton instance;
 if ((instance = instances.get(key)) == null){
     synchronized(instances){
         if ((instance = instances.get(key)) == null){
             instance = new Multiton();
             instances.put(key, instance);
         }
     }
 }
 return instance;
}
}

Yes the double-checked locking does not work for Singleton (http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html), but it does work for our Multiton pattern. Reason? We have our intermediate HashMap object sits in between. Actually we can use the HashMap to solve the Singleton double-checked locking problem as well, if we don't already have the more elegant solution using a static variable.

5. An alternative solution: Using the Java 5 ConcurrentMap

public class Multiton {
private static final ConcurrentMap<Object, Multiton> instances = new ConcurrentHashMap<Object, Multiton>();

public static Multiton getInstance(Object key) {
 // Our "per key" singleton
 if (instances.get(key) == null){
     // Lazily create instance and try to add it to the map
     Multiton instance = new Multiton();
     instances.putIfAbsent(key, instance);
 }
 return instances.get(key);
}
}

The Java 5 ConcurrentMap.putIfAbsent(), being an atomic operation, returns the previous value associated with the key instead of the new suggested value. This ensures the uniqueness of the Multiton instance inside the ConcurrentMap.

In this solution, before a key object has been associated with a Multiton object, if two or more threads are trying to retrieve the instance with the same key object, it's possible that multiple Multiton instance will be created inside the if() block. However, the ConcurrentMap ensures that a same Multiton instance is to be returned to the caller. Extra instances are eligible for Garbage Collection as soon as the method returns. You may not want to use this solution if the creation of the Multiton instance is an expensive operation, as in certain situation.

6. Afterwords

Synchronization and double-checked locking is such an interesting classic java topic, I'm so much wanting to participating in any sort of discussion, it'll always be interesting :)

Java Performance - ALL Tips

2007-10-24T15:36:00.000-07:00

Oh yes, this is a complete list of ALL Java perfomance tips. Thanks for www.javaperformancetuning.com

http://www.javaperformancetuning.com/tips/rawtips.shtml

Bean Definitions Tip1: Avoid Circular References

2007-10-23T23:56:00.001-07:00

Spring is a really powerful framework, which is not only providing the JEE similar or much better and lighter container services, but also providing a straightforward declarative and configuration driven bean definition model. With the flexibility and capability of bean definition mechanism, especially when you unleashing the power of XML schema based context file introduced since Spring 2.0, you can almost do any sorts of bean wiring, parameter configuration, application assembling tasks. After you use it, I bet you will forget all the unpleasant and cumbersome JEE configuration files and the coarse grained Enterprise Beans. However, when dealing with bean definitions, it's still very tricky and the similar problems probably happen as in your traditional programmatic approach.

One typical problem is that the bean definition circular referencing. This is the circumstance under which there are beans relying on each others instance before they could be instantiated by Spring container.

For below example:

public class BeanA {
BeanB b;
public BeanA(BeanB beanB){
b = beanB;
}
public void print(String s) {
System.out.print(s);
}
public void foo(){
b.foo();
}
}

public class BeanB {
private BeanA a;
public BeanB(BeanA beanA){
a = beanA;
}

public void print(String s){
a.print(s);
}

public void foo() {
System.out.print("foo!");
}
}

public class TestStub {
public static void main(String[] args){
AbstractApplicationContext ctxt= new ClassPathXmlApplicationContext("beandef.xml");
}
}

...bean definitions in beandef.xml ...

When you run TestStub, it will show following exception (pay attention to the underline):

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'beanA' defined in class path resource [beandef.xml]: Cannot resolve reference to bean 'beanB' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'beanB' defined in class path resource [beandef.xml]: Cannot resolve reference to bean 'beanA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'beanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'beanB' defined in class path resource [beandef.xml]: Cannot resolve reference to bean 'beanA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'beanA': Requested bean is currently in creation: Is there an unresolvable circular reference?
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'beanA': Requested bean is currently in creation: Is there an unresolvable circular reference?

It's a simple sample of bean circular reference. Specifically, the container tried to instantiate "beanA" first, then it found "beanA" need a reference of "beanB" as constructor argument; subsequently, it tried to create an instance of "BeanB" as "beanB", but this time the "beanB" need a "beanA" instance as a constructor reference argument that is still creation pending waiting for "beanB". This situation confused the container and it can not resolve all the bean references. Then it came the complains of exception. This circular reference problem was caused by circular references of bean by means of Constructor Injection.

To solve this issue, one option is that replace constructor reference to "beanA" of "beanB" with a setter injection. Then the container will not try to create the "beanB" with the "beanB" reference at same time. Instead, it will defer this by injecting the "beanA" reference latter on via "setter" method of "BeanB" after the "beanA" has been created. The same changes happen to "BeanA". It needs some tweaks to the code and bean definitions as well.

public class BeanA {
BeanB b;
public BeanA(){
}
public void setBeanB(BeanB b){
this.b = b;
}
public void print(String s) {
System.out.print(s);
}
public void foo(){
b.foo();
}
}

public class BeanB {
private BeanA a;
public BeanB(){
}

public void setBeanA(BeanA a){
this.a = a;
}
public void print(String s){
a.print(s);
}

public void foo() {
System.out.print("foo!");
}
}

...

...

This time, the Sping was very happy to create all the beans.

An alternative option is still workable for this case but a lit bit tricky related with bean instantiating order. We can ask "beanA" injected "beanB" by setter, whereas "beanB" can still use the constructor injection. But wait, the order of bean definition is very important. You can not let constructor injected "beanB" defined before setter injected "beanA".

public class BeanA {
BeanB b;
public BeanA(){
}
public void setBeanB(BeanB b){
this.b = b;
}
public void print(String s) {
System.out.print(s);
}
public void foo(){
b.foo();
}
}

public class BeanB {
private BeanA a;
public BeanB(BeanA a){
this.a = a;
}

public void print(String s){
a.print(s);
}

public void foo() {
System.out.print("foo!");
}
}

...

...

This works very well. If you move the "beanB" definition before "beanA", it will not work because the "beanA" will need a creating "beanB".

In a nutshell, the circular reference problem is very typical for a sophisticated "Spring" application if you did not cook it very well. It will cost you time to debug and fix it. But not just that. Because the nature of configuration driven of "Spring", the same bean definition file itself could have huge chances to be manipulated by different personnel, thus, more chances of introducing new errors regarding the "Spring" competency level. I will talk about in future sessions how to address this issue by establishing your project or organization level bean definition schema extended from "Spring" base schema. In this way, it mandates some of important project wise constraints for bean definition, such as available tags, bean types, data types etc. Thus, it could reduce some errors caused by arbitrary string parameters or typos in bean definition files for your project.

It's strongly recommended to use setter injection for bean wiring and bean reference injection. If it's very necessary to do constructor based reference injection, and unfortunately involved with circular reference, please well comment or document the bean definition and put notices for future maintaining people. You don't just want someone else happened to ruin your whole fragile bean constructor injection hierarchy someday, do you?

IntelliJ IDEA Performance

2007-10-17T09:40:00.000-07:00

There're some concerns about IntelliJ IDEA Performance. And here is the tips that I used to make mine run fast. Some of them come from my own experience, some of them come from the know-everything internet.

Make sure you have all your libraries on your local harddrive (as opposed to mounted network drive). After I moved all my libraries from a network drive to local harddrive, the time for a 'make' on the project is reduced from around 60 seconds to just 5-7 seconds!

Defragment your Disk and reboot your computer. IDEA creates lots of small files and too much fragmentation is a nightmare.

Turn off Anti Virus completely. Yes I mean completely. It affects the performance dramatically.

Turning off Local History or even reducing the number of history days improved the performance significantly.

Adjust VM settings. Here is my idea.exe.vmoptions file (on windows):

-Xms512m
-Xmx512m
-XX:MaxPermSize=99m
-ea

Change it as you see fit per your hardware configuration.

More information is available at http://blogs.jetbrains.com/idea/2006/04/configuring-intellij-idea-vm-options/.

The Debugger in IDEA may work slowly if the Force classic VM option is not selected in the File Project Properties Debugger dialog. Using Method Breakpoints may also slow down the debugging process. I had two breakpoints on the method name instead of the first line of the method. It was taking a half hour to get to the breakpoint Changing these to line breakpoints gave me two orders of magniture

You may notice IDEA hang for several seconds when you switch to it from other applicationDisable Settings General Synchronize files on frame activation.

Disable windows paging file if you have enough memory. Get more memory if you don't have enough. Swapping is a performance nightmare.

Turn off windows indexing services, either set it to Disabled or Manual unless you do lots of file system search (even you do, I recommend Google Desktop Search). IDEA use lots of small files so background indexing can have a big negative effect on it's performance.

Control Panel/System/Properties/Advanced/Visual Effcts, Adjust for best performance. Unless you're willing to sacrify performance for visual effects like windows animation, fading/sliding etc.

Hibernate Mapping Cheat Sheet

2007-10-12T16:23:00.001-07:00

Here's a nice hibernate mapping cheat sheet. Good reference when programming.

http://ndpsoftware.com/HibernateMappingCheatSheet.html

SpringContextAware JUnit TestCase

2007-10-12T11:28:00.001-07:00

In order to run Junit test case outside of a J2EE container, the test case need to initialize the Spring framework properly. I created this abstract class SpringContextAware, which extends from junit.framework.TestCase and initialize the Spring framework in it's setUp() method. User Test Cases that extends from this class will be running with Spring context loaded already.

public abstract class SpringContextAware extends TestCase {
public SpringContextAware(String name){
super(name);
}

public void setUp() throws Exception{
if (SpringApplicationContext.getApplicationContext()==null) {
AbstractApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{
// list your context files here
"context-service.xml",
"context-hibernate.xml"
});
ctx.registerShutdownHook();
}
}

public void tearDown() throws Exception{
}
}

Here is the SpringApplicationContext class, basically it allows java classes not defined as a spring bean to be able to access the Spring Application Context.

public class SpringApplicationContext implements ApplicationContextAware {

private static ApplicationContext context;

public static ApplicationContext getApplicationContext() {
return SpringApplicationContext.context;
}

/**
* This method is called from within the ApplicationContext once it is
* done starting up, it will stick a reference to itself into this bean.
*
* @param context a reference to the ApplicationContext.
*/
public void setApplicationContext(ApplicationContext context) throws BeansException {
SpringApplicationContext.context = context;
}

/**
*This is about the same as context.getBean("beanName"), except it has its
* own static handle to the Spring context, so calling this method statically
* will give access to the beans by name in the Spring application context.
* As in the context.getBean("beanName") call, the caller must cast to the
* appropriate target class. If the bean does not exist, then a Runtime error
* will be thrown.
*
* @param beanName the name of the bean to get.
* @return an Object reference to the named bean.
*/
public static Object getBean(String beanName) {
return context.getBean(beanName);
}
}

This bean itself however, needs to be defined in the Spring Context XML file:


<bean id="springApplicationContext" class="com.blah.blah.SpringApplicationContext">
</bean>

Any comments are welcome :)

EHCache Singleton CacheManager

2007-10-12T10:56:00.000-07:00

Here's the problem, when we enable the hibernate secondary cache using org.hibernate.cache.EHCacheProvider, and enable ACEGI user cache using

<property name="userCache">
<bean class="org.acegisecurity.providers.dao.cache.EhCacheBasedUserCache">
<property name="cache">
<bean class="org.springframework.cache.ehcache.EhCacheFactoryBean">
<property name="cacheName" value="AcegiUserCache">
</property>
</bean>
</property>
</bean>
</property>

They belongs to two different cache manager.

Instead of have to configure 2 different cache manager separately, have to have separate cache invalidating thread etc, we can fall back to the EHCache Singleton CacheManager.

hibernate.cache.provider_class=net.sf.ehcache.hibernate.SingletonEhCacheProvider

Now ACEGI will use the same EHCache CacheManager. They can be configured in the same ehcache.xml file. Yup!