Java How To ...

Java Dynamic Proxy Example

2011-12-29T13:36:00.018-05:00

In this post, I will go over the basic constructs of dynamic proxy, followed by some notes and things to watch out when implementing it. First, the 5 elements of a dynamic proxy as implemented in this example:

TestImpl: the class behind the proxy, not to be directly invoked by the client. In some cases, this type may not exist.

TestIF: the proxy interface implemented by TestImpl, and the dynamic proxy. This is the interface type the client should reference. One or more interfaces are required to create dynamic proxy. If there is no such interface, you may need to dynamically generate them with tools like ASM.

TestInvocationHandler: the InvocationHandler that handles method invocation on the proxy from the client. It contains an instance of TestImpl to delegate method invocations to.

Test: the test main class.

$Proxy0: the dynamic proxy that implements TestIF, and the client-facing implementation of TestIF.

public interface TestIF {
    String hello(String name);
}

--------------------------

public class TestImpl implements TestIF {
public String hello(String name) {
   return String.format("Hello %s, this is %s", name, this);
}
}

--------------------------

import java.lang.reflect.*;
public class TestInvocationHandler implements InvocationHandler {
private Object testImpl;

public TestInvocationHandler(Object impl) {
   this.testImpl = impl;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   if(Object.class  == method.getDeclaringClass()) {
       String name = method.getName();
       if("equals".equals(name)) {
           return proxy == args[0];
       } else if("hashCode".equals(name)) {
           return System.identityHashCode(proxy);
       } else if("toString".equals(name)) {
           return proxy.getClass().getName() + "@" +
               Integer.toHexString(System.identityHashCode(proxy)) +
               ", with InvocationHandler " + this;
       } else {
           throw new IllegalStateException(String.valueOf(method));
       }
   }
   return method.invoke(testImpl, args);
}
}

--------------------------

import java.lang.reflect.*;
public class Test {
public static void main(String... args) {
   TestIF t = (TestIF) Proxy.newProxyInstance(TestIF.class.getClassLoader(),
                           new Class<?>[] {TestIF.class},
                           new TestInvocationHandler(new TestImpl()));
   System.out.printf("t.hello(Duke): %s%n", t.hello("Duke"));
   System.out.printf("t.toString(): %s%n", t);
   System.out.printf("t.hashCode(): %H%n", t);
   System.out.printf("t.equals(t): %B%n", t.equals(t));
   System.out.printf("t.equals(new Object()): %B%n", t.equals(new Object()));
   System.out.printf("t.equals(null): %B%n", t.equals(null));
}
}

Implementation notes:

When dispatching method invocations on proxy to delegate object, 3 methods from java.lang.Object need special handling: toString(), hashCode() and equals(Object). Since they are related to the proxy object identity, they should be serviced directly by the handler. One option is to base their return values on the proxy param, as in this example.

Other public methods from java.lang.Object are all final, and are not routed to the InvocationHandler by JVM. These methods are:

public final native Class<?> getClass();
public final native void notify();
public final native void notifyAll();
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException;
public final void wait() throws InterruptedException

The handler's invoke method should not invoke methods on the proxy object passed in as the first param (except the 6 final methods listed above), to avoid infinite loop and StackOverflowError. For example, this following debug line should not be used:

System.out.printf("proxy=%s, method=%s, args=%s%n", 
                  proxy, method, Arrays.toString(args));

If the handler already knows how to acquire the delegate TestImpl instance, through either direct instantiation or lookup, it can hide it completely from the client. So the only type of TestIF the client knows is the proxy.

The Object[] args passed into handler's invoke method is null, when the invoked method takes no param. This can come as a surprise to many. So a null check is needed before operating on args.

To run this example after compiling all java classes:

$ java Test

t.hello(Duke): Hello Duke, this is TestImpl@a3901c6
t.toString(): $Proxy0@24a37368, with InvocationHandler TestInvocationHandler@66edc3a2
t.hashCode(): 24A37368
t.equals(t): TRUE
t.equals(new Object()): FALSE
t.equals(null): FALSE

To save/keep/dump the generated proxy class file (with non-standard option):

java -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true Test

To view the structure of the proxy class:

$JAVA_HOME/bin/javap -v \$Proxy0

My Unix Linux Notes

2011-12-29T07:29:00.017-05:00

How to extract/expand/explode file.tar.gz, or file.tgz:
gtar xzvf file.tar.gz # if gtar is available, otherwise,
gunzip < file.tgz | tar xvf -

Note the use of < (gunzip file.tgz | tar xvf - won't work). You can always run gunzip and tar in 2 steps, which creates an extra tar file:

gunzip file.tar.gz
tar xvf file.tar

How to find a port number (8080) in use:

netstat -an | grep 8080

How to kill all java processes:
killall java

How to list all background jobs:

jobs
[1]    Running                       ./standalone.sh

How to kill the current background job:
kill %

How to list all java processes:


$JAVA_HOME/bin/jps
$JAVA_HOME/bin/jps -l
$JAVA_HOME/bin/jps -lv
ps -ef | grep java    # more reliable than jps

How to find a java (jboss) process with jps and kill it:


jps | grep jboss | awk '{print $1}' | xargs kill -9

How to find a jboss process with "ps -ef" and kill it:


ps -ef | grep -v grep | grep jboss | awk '{print $2}' | xargs kill -9

Note that in "ps -ef" output, the PID is the 2nd column, after UID. This is different from "ps" and "jps..." output, where PID is column 1.

How to find a file is opened by which program and user (takes a while to finish):


lsof | vim -

How to list all files in current directory in absolute path (for copying the path):


find $PWD

Extend Thread vs implement Runnable

2011-12-05T09:27:00.008-05:00

There are two ways to create your own thread type: subclass java.lang.Thread class, or implementing java.lang.Runnable and pass it to Thread constructor or java.util.concurrent.ThreadFactory. What is the difference, and which one is better?

1, The practical reason is, a Java class can have only one superclass. So if your thread class extends java.lang.Thread, it cannot inherit from any other classes. This limits how you can reuse your application logic.

2, From a design point of view, there should be a clean separation between how a task is identified and defined, between how it is executed. The former is the responsibility of a Runnalbe impl, and the latter is job of the Thread class.

3, A Runnable instance can be passed to other libraries that accept task submission, e.g., java.util.concurrent.Executors. A Thread subclass inherits all the overhead of thread management and is hard to reuse.

4, Their instances also have different lifecycle. Once a thread is started and completed its work, it's subject to garbage collection. An instance of Runnalbe task can be resubmitted or retried multiple times, though usually new tasks are instantiated for each submission to ease state management.

My tcsh notes

2011-11-27T10:55:00.007-05:00

Settings to remember when I need to use tcsh in a foreign environment:

set prompt="%/ > "
# set prompt="%{\033]0;%M: %c\007%}%/ > "
set complete=enhance
set autolist=true

set colorcat
setenv GREP_OPTIONS --color=auto
setenv GREP_COLOR 32

Copy the above lines to $HOME/.tcshrc. The first 3 are the most important ones to remember. Setting prompt to "%/ > " puts the $cwd in the front of the command prompt. $cwd is the same as the all-upper-case $PWD but is easier to type.

To list current key bindings in tcsh:

$ bindkey
"^A"           ->  beginning-of-line
"^D"           ->  delete-char-or-list-or-eof
"^E"           ->  end-of-line
"^I"           ->  complete-word
"^J"           ->  newline
"^K"           ->  kill-line
"^L"           ->  clear-screen
"^M"           ->  newline
"^P"           ->  up-history
"^T"           ->  transpose-chars
"^U"           ->  kill-whole-line
"^W"           ->  kill-region
... ...

To use vi-mode or emacs-mode command-line editing and navigation:

bindkey -v
bindkey -e

Why use ThreadFactory

2011-11-14T10:44:00.009-05:00

When submitting tasks to java executor service, some thread will be allocated to perform that task. The servicing thread may be assigned from the internal thread pool, or created on-demand. Each executor service has an associated ThreadFactory, and a default ThreadFactory if the application does not specify one. For non-trivial apps, it's always a good idea to set a custom ThreadFactory.

1, To set a more descriptive thread name. With the default ThreadFactory, it gives thread names in the form of pool-m-thread-n, such as pool-1-thread-1, pool-2-thread-1, pool-3-thread-1, etc. When these threads showing up in debugger, profiler, or monitoring tool, it's hard to know their purpose and how they were started.

2, To set thread daemon status. The default ThreadFactory produces non-daemon threads.

3, To set thread contextClassLoader to appropriate value. Threads created by the default ThreadFactory will inherit the contextClassLoader from the parent thread, which may not be what you want. In general, a pooled thread itself should not be associated with any specific class loader. Instead, the submitted task has the best knowledge about its class loading requirement, so the task Runnable or Callable should manage the thread contextClassLoader for the duration of its run method.

If the new thread does not need to access classes loaded in the parent thead, set its contextClassLoader to null. If a task needs visibility to a class loader, set its contextClassLoader at the beginning of its run method, and restore its contextClassLoader right before exiting run method.

The default ThreadFactory in JDK 6 java.util.concurrent is a package-private static nested class in java.util.concurrent.Executors:

static class DefaultThreadFactory implements ThreadFactory {
        static final AtomicInteger poolNumber = new AtomicInteger(1);
        final ThreadGroup group;
        final AtomicInteger threadNumber = new AtomicInteger(1);
        final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null)? s.getThreadGroup() :
                                 Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

Note that poolNumber is declared as static final and threadNumber as final. Each instance of ThreadFactory is tied to a unique pool, and a static poolNumber tracks the sequence of all instances of DefaultThreadFactory. An instance of ThreadFactory (and the associated pool) contains multiple threads, and the instance field threadNumber tallies all threads therein.

Both poolNumber and threadNumber fields are of type java.util.concurrent.AtomicInteger to take advantage of its atomic compound operations. Their initial value is 1 and getAndIncrement() is invoked to produce sequence like 1, 2, 3. Alternatively we could set its initial value to 0 and invoke incrementAndGet() to produce the same sequence.

Why poolNumber and threadNumber need to guard against concurrent access and modification? poolNumber is static and thus a shared data among all instances of DefaultThreadFactory. Multiple instances of DefaultThreadFactory may be incrementing it simutaneously, so it needs to be thread-safe.

As for threadNumber, the creation of threads, either initially at execution service startup time, or under heavy load, may be serialized by the execution service. But an instance of ThreadFactory can be passed around and associated with multiple execution service. Therefore, the internal state of ThreadFactory needs to be thread-safe and immutable.

Notes on Java Debugger (NetBeans)

2011-11-09T13:04:00.006-05:00

Some notes on using NetBeans Java Debugger. They also apply in principal to other Java debuggers.

1, Set line breakpoint (the most common breakpoint), optionally make them conditional breakpoint to filter out irelevant hits. Sometimes I found conditional breakpoint doesn't seem to work and the execution always pauses regardless of the condition.

2, Use field breakpoint to intercept field access and/or modification. This is very useful to track all access and mutation of the field without having to inspect its setter and getter. And some fields don't even have setter or getter methods.

3, Use method breakpoint to inspect method entry and exit. This is just a variation of line breakpoint.

4, Use class breakpoint to track class loading and unloading. This is useful when you just have a vague idea that a certain class will be executed but don't know which part. When the class breakpoint is hit, you can then note down the calling stack trace.

5, Exception breakpoint is also available but haven't tried that.

6, Rewind (step back) the calling sequence by popping off the top element in the calling stack. You can do it from Debugger menu, or the context menu of a particular thread.

7, Add debug buttons to tools bar, including "Attach Debugger ..." button. If "Attach Debugger button is not included by default, you can customize the tool bar by dragging it into the bar. This is very convenient for attaching debugger to remote java process.

8, Apply code changes dynamically to the debugging session, without restarting the remote java application. Debug > Apply Code Changes, or Apply Code Changes button in tool bar. Note that the code changes are not effective in current debugging session. To make it permanent, need to rebuild and restart the remote application.

9, You can start multiple debugging sessions by attaching to different java processes. For example, to debug both the client side and server side operations. Pay attention to where the execution is, the client side, or the server side? Sometimes you can't tell where you are by just looking at the current class name, because some classes are loaded by both the client side and the server side programs.

10, To copy the current stack trace, go to Debug > Evaluate Express, enter
Thread.dumpStack();
The stack trace will appear in the application's log file or console.

11, If you need to step into source code outside your main project, get hold of its source code if available, and create a IDE project off it. That may involve checking it out from different repo, with different scm tool, or download source zip/jar files from maven repo. A decompiler may be able to handle some simple classes, but tend to produce incomplete source code for large, complext classes.

12, Always attach JDK source code and javadoc to your IDE. NetBeans Tools > Java Platform > JDK 1.6 > Sources. You will need to download the JDK source installer and install it to disk. Source files for JDK classes are located in j2se/src/share/classes.

Finally, shortcuts:

Step Over        F8
Step Into        F7
Continue         F5
Breakpoints      Ctrl-Shift-5
Variables        Ctrl-Shift-1
Watches          Ctrl-Shift-2
Terminate Debug  Shift-F5

Example of StackOverflowError

2011-10-19T22:24:00.003-04:00

One cause of java.lang.StackOverflowError is a method calling itself without exit condition. The following Room class overrides toString method to produce more meaningful string representation, but is implemented wrong:

public class Room {
    public static void main(String args[]) {
        System.out.println("Created Room: " + new Room());
    }

    @Override public String toString() {
        return "Room: " + this.toString();  //change to super.toString() to avoid StackOverflowError
    }
}

Running Room class would fail with java.lang.StackOverflowError.

Dependency Injection (DI) in Java EE

2011-09-25T11:03:00.006-04:00

In a J2EE/JavaEE server, container has always been the backbone for creating and managing the lifecycle of resident components. It's not a surprise to see some forms of DI is already present at the beginning of J2EE. For example, javax.ejb.SessionBean, the legacy interface implemented by old-style EJB bean class, contains a setSessionContext(SessionContext ctx) method, which is called by ejb container to inject a SessionContext to the bean class. Similarly, javax.ejb.EntityBean has setEntityContext(EntityContext ctx), and javax.ejb.MessageDrivenBean has setMessageDrivenContext(MessageDrivenContext ctx) callbacks.

Another less obvious example is Servlet init methods, which are invoked by servlet container to initialize ServletContext and ServletConfig for servlet class:

//Declared in javax.servlet.Servlet interface and implemented in GenericServlet:
public void init(ServletConfig config)

//Convenience method implemented in GenericServlet
public void init();

This early forms of DI is typically defined as part of the lifecycle callbacks and strongly typed to a specific interface or abstract class.

DI capability was substantially expanded in Java EE 5 with the introduction of annotation- and xml-based DI. Both field- and setter-injections are supported, and xml deployment descriptors can be used to override or augment annotation meta data. Most common ones are:

@EJB private Calc calc;

@EJB(name="ejb/calc", beanName="DefaultCalc", beanInterface=com.my.ejb.Calc.class)

@Resource SessionContext ctx;

@Resource private String widgetName;

@Resource(mappedName="custom/widgetName")
private String widgetName;

@PersistenceContext private EntityManager em;

@PersistenceContext(unitName="advanced-pu", type=TRANSACTION)
private EntityManager em;

As you can see, the annotation type is specific to each resource type. The advantage of this approach is, you can easily customize how a specific type of dependency is constructed and initialized. This design makes sense as some resources need more initialization params than others. But the downside is lack of internal consistency across the board. For each new type of resources, we need to decide whether to reuse the existing annotations, add new attributes to existing annotations, or create a new one. This task is tackled in Java EE 6, with JSR 330 (AtInject spec) and JSR 299 (CDI spec), both are required component specs in Java EE 6 Platform.

Now in Java EE 6, all the above is doable with a single @java.inject.Inject. For injections with no attributes (or default attributes), we can easily replace @EJB/@Resource/@PersistenceContext with @Inject. Otherwise, a @javax.inject.Qualifier is needed to provider more information. Basically we are promoting annotation attributes to auxiliary annotations, replacing string-based qualifiers with typed qualifiers, and chaining them together to resolve the DI.

@EJB and @Resource are also enhanced in Java EE 6 to take an additional portable attribute lookup, mainly as a replacement for the nonportable mappedName attribute:

@EJB(lookup="java:global/myApp/myEJBModule/CalcBean")
private Calc calc;

@Resource(lookup="java:module/env/sleepSeconds")
private long sleepSeconds;

JUnit Notes, Do's and Don'ts

2011-09-23T13:05:00.021-04:00

A skeleton JUnit 4 test case:

import java.util.*;
import org.junit.*;
import static org.junit.Assert.*;

public class MyTest {
/** 4 optional lifecycle callback methods */
@Before public void before() {}  //must be public void no-arg

@After public void after() {}    //must be public void no-arg

@BeforeClass public static void beforeClass() {} //must be public static void no-arg

@AfterClass public static void afterClass() {}  //must be public static void no-arg

@Test public void testAdd() {
  int a = 1, b =2, expected = 3;
  int actual = a + b;
  assertEquals(expected, actual);
}
}

Do not name your test main class Test.java, which has the same short name as @Test annotation. Unless you explicitly use @org.junit.Test, @Test will resolve to your test class, instead of org.junit.Test annotation type.

Avoid using Java assert; use static assertXXX methods (statically imported) in org.junit.Assert class. Java assert is turned off by default, and can be enabled only at command line with "java -ea", or "java -enableassertions" options. So some tests using Java assert will always pass when running with the default configuration, regardless of the actual test conditions. For example, the following method passes unless -ea option is passed to java:

@Test public void testNumber() {
  assert(1 < 0);
}

java -cp $tmp/junit-4.8.1.jar:. org.junit.runner.JUnitCore MyTest
JUnit version 4.8.1
Time: 0.009
OK (4 tests)

A secondary reason to favor org.junit.Assert.assertXXX over Java assert is, the former is a richer API with more descriptive output, whereas Java assert, in its common form, only fails with java.lang.AssertionError and stack trace with no description. Java assert can also provide details with a second param: assert false : reason

maven surefire plugin automatically enables Java assertions when running JUnit tests on JDK 1.4 and above. So when running with surefire, there is no problem of false positive test results. But still I would like my JUnit tests to work the same way across all testing environment.

Avoid using assertTrue(list1.equals(list2)); use assertEquals(list1, list2) instead. assertTrue will only print out the useless message like "expecting true, but actual false", whereas assertEquals gives more helpful message like "expected:[null, 1, 2], but was:[1, 2]"

Do not add assertTrue(true) at the end of a @Test to signal the success result. It's just not needed. The test simply passes when nothing goes wrong.

@Test method can declare throws clause, e.g., throws NamingException. When an exception is thrown during test run, the test is failed. So use exception as a means to communicate test failures. Do not try-catch an exception, just to print it and manually fail() it. For example, do this:

@Test public void testNumber() {
      int i = 10 / 0;
}

Do NOT do this:

@Test public void testNumber() {
    try {
      int i = 10 / 0;
    } catch (ArithmeticException e) {
        e.printStackTrace();
        fail();      // or even worse, assert(false);
    }
}

When running the try-catch version, ArithmeticException stack trace is printed, followed by another stack trace of java.lang.AssertionError from calling fail(), whereas in the shorter version, only the ArithmeticException is logged and hence much easier to trace.

How to run a single test? org.junit.runner.JUnitCore, the default command-line runner, takes a list of test classes as input, but doesn't support running a single test method. Other tools and IDE may support it by providing their own runner. With maven surefire 2.7.3+ and JUnit 4 tests, it is supported with a -D sysprop (link):

mvn test -Dtest=com.my.test.TestMain#test1
mvn test -Dtest=com.my.test.TestMain#*egative*
mvn org.apache.maven.plugins:maven-surefire-plugin:2.8:test -Dtest=com.my.test.TestMain#test1

I prefer to put the test name at the very end of the line so it's easier to go through the history and edit command.

To check the version of your JUnit:

$ java -cp $tmp/junit.jar junit.runner.Version
4.8.1

To skip or exclude a test, use @Ignore (org.junit.Ignore).

Singleton, DCL, Holder Idiom, and When Singleton is not a Singleton

2011-08-09T10:56:00.018-04:00

For eager-initialization singleton, the simplest way is to use an enum type with only 1 INSTANCE.

public enum EnumSingleton implements Calc {
    INSTANCE;

    public int add(int a, int b) {
        return a + b;
    }
}

A traditional, non-enum implementation of eager-initialization singleton is:

public class EagerSingleton {
    private static EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {}

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

A lazy-initialization singleton implemented with double-checked locking (DCL), which works in Java 5 onward:

package test.concurrent;
public final class MySingleton1 {
 private static volatile MySingleton1 instance;

 private MySingleton1() {}

 public static MySingleton1 getInstance() {
   MySingleton1 result = instance;
   if(result == null) {
     synchronized (MySingleton1.class) {
       result = instance;
       if(result == null) {
         instance = result = new MySingleton1();
       }
     }
   }
   return result;
 }

A lazy-initialization singleton implemented with holder idoim (applicable to lazy static field):

package test.concurrent;
public final class MySingleton2 {
 private MySingleton2() {}

 private static class Holder {
   private static final MySingleton2 instance = new MySingleton2();
 }

 public static MySingleton2 getInstance() {
   return Holder.instance;
 }

A main method that spawns multiple threads calling getInstance():

public static void main(String[] args) {
   int numOfThreads = Integer.parseInt(args[0]);
   for(int i = 0; i < numOfThreads; i++) {
     Thread t = new Thread(new Runnable() {
       public void run() {
         System.out.println(MySingleton1.getInstance());
       }
     });
     t.start();
   }
 }

When the same singleton class is loaded by different class loaders, each loader has its own class data. MySingleton1.class loaded by classloader1 is a distinct class from MySingleton1.class loaded by classloader2. Hence multiple instances will be created when calling MySingleton1.getInstance().

To test this scenario, write a servlet that calls MySingleton1.getInstance, and print it. Package the servlet class and MySingleton1 class in test.war, deploy it to appserver. Redeploy the same war in a different context root test2. Invoke the 2 webapp to see if the same instance is printed.

The servlet class:

package test;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

@javax.servlet.annotation.WebServlet(urlPatterns = "/*")
public class TestServlet extends HttpServlet {
 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
   PrintWriter out = response.getWriter();
   out.println("singleton: " + MySingleton1.getInstance());
 }
 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
   processRequest(request, response);
 }
 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
   processRequest(request, response);
 }
}

The content of test.war:

WEB-INF/classes/test/MySingleton1$1.class
WEB-INF/classes/test/MySingleton1.class
WEB-INF/classes/test/TestServlet.class

To deploy the webapp to GlassFish:

$ asadmin deploy test.war
$ asadmin deploy --name test2 test.war
$ asadmin list-applications

To run the 2 webapp and notice 2 different instances of MySingleton class are instantiated within the same JVM, one for each webapp:

$ curl http://localhost:8080/test/
singleton: test.MySingleton1@114536a5

$ curl http://localhost:8080/test/
singleton: test.MySingleton1@114536a5

$ curl http://localhost:8080/test2/
singleton: test.MySingleton1@3997ebf6

$ curl http://localhost:8080/test2/
singleton: test.MySingleton1@3997ebf6

Join threads with FutureTask and Callable

2011-08-08T17:43:00.008-04:00

Here is another way of having the main thread wait for all child threads to complete, using java.util.concurrent.FutureTask and Callable.

package test.concurrent;  
 import java.util.Vector;  
 import java.util.concurrent.*;  
 
public class FutureTaskTest {  
   private Vector<String> threadNames = new Vector<String>();  
   public static void main(String[] args) {  
     FutureTaskTest test = new FutureTaskTest();  
     test.threadTest(Integer.parseInt(args[0]));  
     System.out.println(test.threadNames);  
   }  

   private void threadTest(int numOfThreads) {  
     Thread[] threads = new Thread[numOfThreads];  
     FutureTask<String>[] futureTasks = new FutureTask[numOfThreads];  
     for (int i = 0; i < threads.length; i++) {  
       futureTasks[i] = new FutureTask<String>(new MyCallable());  
       threads[i] = new Thread(futureTasks[i]);  
       threads[i].start();  
     }  
     for (FutureTask<String> f : futureTasks) {  
       try {  
         threadNames.add(f.get());  
       } catch (InterruptedException e) {  
         e.printStackTrace();  
       } catch (ExecutionException e) {  
         e.printStackTrace();  
       }  
     }  
   }  

   private static class MyCallable implements Callable<String> {  
     public String call() {  
       for (int i = 0; i < 1000000; i++) {  
         i = i + 0;  
       }  
       return Thread.currentThread().getName();  
     }  
   }  
 }

FutureTask is usually used along with ExecutorService, but it can also be passed to Thread constructor. The output is always in the order from thread-0 to thread-9, because when we iterate through futureTasks to get result, each get() call wait for a certain duration for the result to be published by child thread.

$ java test.concurrent.FutureTaskTest 10
[Thread-0, Thread-1, Thread-2, Thread-3, Thread-4, Thread-5, Thread-6, Thread-7, Thread-8, Thread-9]

The Vector field threadNames can also be replaced with ArrayList, since it is only accessed in the main thread and no synchronization is needed.

When to join threads with CountDownLatch

2011-08-07T23:55:00.018-04:00

In my previous post When to join threads, Thread.join() is used to wait for all child threads to complete. Now I will update it using CountDownLatch instead:

package test.concurrent;
import java.util.Vector;
import java.util.concurrent.CountDownLatch;

public class ThreadTest {
    private Vector<String> threadNames = new Vector<String>();
    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        test.threadTest(Integer.parseInt(args[0]));
        System.out.println(test.threadNames);
    }

    private void threadTest(int numOfThreads) {
        final CountDownLatch latch = new CountDownLatch(numOfThreads);
        Thread[] threads = new Thread[numOfThreads];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new ThreadTest.MyThread(latch);
            threads[i].start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private class MyThread extends Thread {
        private final CountDownLatch latch;
        public MyThread(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override public void run() {
            for (int i = 0; i < 1000000; i++) {
                i = i + 0;
            }
            threadNames.add(getName());
            latch.countDown();
        }
    }
}

A CountDownLatch is created in main thread, passed to each child thread's constructor. Each child thread will count down by 1. After starting all child threads, the main thread then wait for the latch count to reach 0. To run it:

$ java test.concurrent.ThreadTest 10
[Thread-1, Thread-2, Thread-0, Thread-3, Thread-4, Thread-5, Thread-6, Thread-7, Thread-8, Thread-9]

My notes on java thread

2011-08-07T19:52:00.013-04:00

(1) Thread.dumpStack(), not Thread.dumpStackTrace(), not Thread.currentThread().dumpStack().

(2) thread can sleep with or without acquiring a lock, inside or outside synchronized block. When sleeping without a lock, the CPU resource is re-allocated to one of the ready-to-run threads. When sleeping inside synchronized block with a monitor lock, the lock is not relinquished, and the CPU is re-allocated to one of the other runnable threads that are not waiting on this lock.

(3) wait-notify-flag pattern. wait is almost always inside a while(flag) loop. There can be multiple threads waiting on the same monitor, some is waiting for the flag to change value, and others are not. In other words, there could be homogeneous threads and/or heterogeneous waiters. Once the flag changes value and notifyAll() is invoked, all threads waiting on the same monitor will be awaken. All of them exit waiting state and enter ready-to-run state, but only one of them will get the lock and proceed. If the lucky one consumes (reset) the flag after obtaining the lock, the previous flag set in notifyAll() becomes obsolete. Therefore, other threads, after they get the monitor, will need to recheck the flag to decide to wait again or proceed.

Another reason wait is inside a loop is there can be spurious wakeup, which are not triggered by notify or notifyAll calls. wait can also be interrupted by other threads. So the wait-notify protocol is not 100% reliable, and that's why a flag is needed to aid the inter-thread communication.

When to use notify and when to use notifyAll? When all waiters are homogeneous, i.e., whoever gets the monitor doesn't matter, use notify. When waiters are heterogeneous, use notifyAll to ensure the correct threads are awaken. If waiter are heterogeneous and we call notify, a waiter that does not care about the flag may be picked to proceed, while those waiters interested in the flag will not get the signal.

The flag should be exclusively for this purpose, not used by other part of the application. All access to this flag is inside synchronized block, so no need to make it volatile or AtomicBoolean.

(4) make the lock object final if possible, for example:

private final Object lock = new Object();

Do not synchronize on string literals, which are merely reference to the same string object in the string pool, or global constants. It will unintentionally cause too many threads competing for the same lock.

(5) volatile can be used on fields of primitive type, primitive wrapper types, or any other Object types. A typical use is in singleton DCL pattern. If a mutable field is simply read or written by multiple threads, then making it volatile usually suffice. One step up in concurrency is to use java.util.concurrent.atomic.* classes like AtomicInteger, AtomicBoolean, etc. Atomic types are ideal for simple compound operations like read-update-assignment, or if-absent-set. Anything more complicated than that will need synchronized access.

Further readings:
Sun's Java Concurrency Tutorial

stackoverflow discussion on wait, notify, CountdownLatch, etc

(6), 3 ways to get a new thread:
* extend java.lang.Thread class and overriding its run() method;

* provide an impl of Runnable interface and use it to instantiate a new thread;

* provide an impl of Runnable interface and call ThreadFactory.newThread(runnable). Get the default ThreadFactory with Executors.defaultThreadFactory().

See their differences in another post: Extend Thread vs implement Runnable

Example of expensive computation

2011-08-07T17:42:00.008-04:00

Sometimes I need to simulate some expensive computation, or long-running task, without using Thread.sleep or Object.wait. A real busy waiting. The following example of computing PI is adapted from this RMI tutorial:

package test;
import java.math.BigDecimal;

public class Pi implements java.io.Serializable {
   private static final long serialVersionUID = 227L;
   private static final BigDecimal FOUR = BigDecimal.valueOf(4);
   private static final int roundingMode = BigDecimal.ROUND_HALF_EVEN;
   public static void main(String[] args) {
       BigDecimal result = computePi(Integer.parseInt(args[0]));
       System.out.println("Pi is " + result);
   }

   /**
    * Compute the value of pi to the specified number of digits after the
    * decimal point. The value is computed using Machin's formula:
    * pi/4 = 4*arctan(1/5) - arctan(1/239)
    * and a power series expansion of arctan(x) to sufficient precision.
    */
   public static BigDecimal computePi(int digits) {
       int scale = digits + 5;
       BigDecimal arctan1_5 = arctan(5, scale);
       BigDecimal arctan1_239 = arctan(239, scale);
       BigDecimal pi = arctan1_5.multiply(FOUR).subtract(arctan1_239).multiply(FOUR);
       return pi.setScale(digits, BigDecimal.ROUND_HALF_UP);
   }

   /**
    * Compute the value, in radians, of the arctangent of the inverse of the
    * supplied integer to the specified number of digits after the decimal
    * point. The value is computed using the power series expansion for the arc
    * tangent:
    * arctan(x) = x - (x^3)/3 + (x^5)/5 - (x^7)/7 + (x^9)/9 ...
    */
   public static BigDecimal arctan(int inverseX, int scale) {
       BigDecimal result, numer, term;
       BigDecimal invX = BigDecimal.valueOf(inverseX);
       BigDecimal invX2 = BigDecimal.valueOf(inverseX * inverseX);
       numer = BigDecimal.ONE.divide(invX, scale, roundingMode);
       result = numer;
       int i = 1;
       do {
           numer = numer.divide(invX2, scale, roundingMode);
           int denom = 2 * i + 1;
           term = numer.divide(BigDecimal.valueOf(denom), scale, roundingMode);
           if ((i % 2) != 0) {
               result = result.subtract(term);
           } else {
               result = result.add(term);
           }
           i++;
       } while (term.compareTo(BigDecimal.ZERO) != 0);
       return result;
   }
}

To run and time the task:

$ time java test.Pi 50000
Pi is 3.14159265358979323846264338327950288419716939937510 ...
9.263u 0.187s 0:09.22 102.3% 0+0k 0+6io 8pf+0w

It takes about 10 seconds to compute PI with 5000 digits after the decimal point.

My notes on serialization and de-serialization

2011-08-07T15:18:00.012-04:00

I wrote the following test to check some aspects of java serialization and de-serialization, followed by some notes:

package test;
import java.io.*;
import java.util.logging.Logger;

public class SerializableTest implements java.io.Serializable {

private static final long serialVersionUID = 0L;
private static final String fileName = "Serializable.ser";
private static final Logger logger = Logger.getLogger("");
private static String var;
transient private String tran = "this is a transient instance field";
private int number;
private Thread th;

public static void main(String[] args) throws IOException, ClassNotFoundException {
    if (args[0].startsWith("ser")) {
        SerializableTest test = new SerializableTest();
        test.number = 1;
        var = "this is a static variable";
        writeOut(test);
        System.out.println("SerializableTest to be saved: " + test);
    } else if (args[0].startsWith("deser")) {
        System.out.println("SerializableTest deserialized: " + readIn());
    }
}

private static Object readIn() throws IOException, ClassNotFoundException {
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File(fileName)));
    return ois.readObject();
}

private static void writeOut(java.io.Serializable obj) throws IOException {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File(fileName)));
    oos.writeObject(obj);
    oos.close();
}

@Override public String toString() {
    return "SerializableTest: final static fileName=" + fileName + ", final static logger=" + logger
            + ", non-final static var=" + var + ", instance number=" + number
            + ", transient instance tran=" + tran + ", non-serializable instance field:=" + th;
}
}

To run the program to serialize an instance to current directory:

$ java test.SerializableTest ser

SerializableTest to be saved: SerializableTest:
final static fileName=Serializable.ser,
final static logger=java.util.logging.LogManager$RootLogger@43ef9157,
non-final static var=this is a static variable,
instance number=1,
transient instance tran=this is a transient instance field

The output dumps the in-memory state of the object, before writing it to disk. To show the file type of the data file containing the object:

$ file Serializable.ser
Serializable.ser: Java serialization data, version 5

To de-serialize, or re-constitute the object from the data file:

$ java test.SerializableTest deser

SerializableTest deserialized:
SerializableTest: final static fileName=Serializable.ser,
final static logger=java.util.logging.LogManager$RootLogger@252f0999,
non-final static var=null,
instance number=1,
transient instance tran=null

The output shows the object state reconstructed from the data file.

(1) transient and static fields are ignored in serialization. After de-serialization transient fields and non-final static fields will be null. Final static fields still have values since they are part of the class data.

(2) ObjectOutputStream.writeObject(obj) and ObjectInputStream.readObject() are used in serialization and de-serialization, not BufferedOutputStream/BufferedInputStream. There is no BufferedObjectOutputStream or BufferedObjectInputStream.

(3) During serialization, you need to handle IOException; during de-serialization, you need to handle IOException and ClassNotFoundException. So the transitive closure of the de-serializaed type must be in the classpath on the receiving side.

(4) Some non-serializable classes: Thread, Logger, LogManager and most classes in java.util.logging (Level and LogRecord are serializable, though). Throwable extends Serializable, so all Error and Exception types are serializable via inheritance.

(5) Uninitialized non-serializable, non-transient instance fields are tolerated. When adding "private Thread th;", no error in serializable. However, "private Thread th = new Thread();" will cause exception:

Exception in thread "main" java.io.NotSerializableException: java.lang.Thread
 at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1164)
 at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1518)
 at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1483)
 at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400)
 at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158)
 at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:330)
 at test.SerializableTest.writeOut(SerializableTest.java:33)
 at test.SerializableTest.main(SerializableTest.java:19)

(6) It is possible to include static fields in serialization and de-serialization, by implementing writeObject and readObject methods. These 2 methods are not in java.io.Serialiable, which is just a marker interface, and not in java.lang.Object, either. They are just 2 magic methods with pre-defined signatures. The following is from Technical Article: Advanced Serialization

private void writeObject(ObjectOutputStream oos) throws IOException {
  oos.defaultWriteObject();
  // Write/save additional fields
  oos.writeObject(new java.util.Date());
}

// assumes "static java.util.Date aDate;" declared
private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
  ois.defaultReadObject();
  // Read/initialize additional fields
  aDate = (java.util.Date)ois.readObject();
}

For a definitive guide, refer to Official Java Object Serialization Specification version 6.0

(7) Serialization and de-serialization can be used for copying and cloning objects. It is slower than regular clone, but can produce a deep copy very easily. The following util method is adapted from Secrets of Java Serialization:

    public static Object clone(Object o) throws IOException, ClassNotFoundException {
       ByteArrayOutputStream bos = new ByteArrayOutputStream();
       ObjectOutputStream oos = new ObjectOutputStream(bos);
       oos.writeObject(o);
       oos.close();
       ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
       ObjectInputStream ois = new ObjectInputStream(bis);
       Object copy = ois.readObject();
       ois.close();
       return copy;
   }

Example of Java thread deadlock

2011-08-04T17:44:00.005-04:00

A simple example showing a typical Java thread deadlock. 2 threads are spawned: thread-0 first locks lock1 and then lock2; thread-1 first locks lock2 and then lock1. Each thread sleeps a bit before acquiring the second lock, to increase the chance of deadlock.

package test.concurrent;
public class DeadLockTest {
   private static long sleepMillis;
   private final Object lock1 = new Object();
   private final Object lock2 = new Object();

   public static void main(String[] args) {
       sleepMillis = Long.parseLong(args[0]);
       DeadLockTest test = new DeadLockTest();
       test.doTest();
   }

   private void doTest() {
       Thread t1 = new Thread(new Runnable() {
           public void run() {
               lock12();
           }
       });
       Thread t2 = new Thread(new Runnable() {
           public void run() {
               lock21();
           }
       });
       t1.start();
       t2.start();
   }

   private void lock12() {
       synchronized (lock1) {
           sleep();
           synchronized (lock2) {
               sleep();
           }
       }
   }

   private void lock21() {
       synchronized (lock2) {
           sleep();
           synchronized (lock1) {
               sleep();
           }
       }
   }

   private void sleep() {
       try {
           Thread.sleep(sleepMillis);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

To run the deadlock test with sleep time 1 millisecond:

java -cp . test.concurrent.DeadLockTest 1

The process seems to hang for ever. To get the thread dump, press Ctrl-\ (Ctrl-break on Windows). Thread dump contains the following deadlock diagnositc:

Found one Java-level deadlock:
=============================
"Thread-1":
 waiting to lock monitor 1017fcfb0 (object 7f31050b0, a java.lang.Object),
 which is held by "Thread-0"
"Thread-0":
 waiting to lock monitor 1017fe360 (object 7f31050c0, a java.lang.Object),
 which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
   at test.concurrent.DeadLockTest.lock21(DeadLockTest.java:44)
   - waiting to lock <7f31050b0> (a java.lang.Object)
   - locked <7f31050c0> (a java.lang.Object)
   at test.concurrent.DeadLockTest.access$1(DeadLockTest.java:40)
   at test.concurrent.DeadLockTest$2.run(DeadLockTest.java:23)
   at java.lang.Thread.run(Thread.java:680)
"Thread-0":
   at test.concurrent.DeadLockTest.lock12(DeadLockTest.java:35)
   - waiting to lock <7f31050c0> (a java.lang.Object)
   - locked <7f31050b0> (a java.lang.Object)
   at test.concurrent.DeadLockTest.access$0(DeadLockTest.java:31)
   at test.concurrent.DeadLockTest$1.run(DeadLockTest.java:18)
   at java.lang.Thread.run(Thread.java:680)

Found 1 deadlock.

Simple Example of JSF and EJB 3.1

2011-08-02T22:58:00.003-04:00

This is a very simple example of a JSF 2.0 managed bean invoking EJB 3.1 local singleton EJB. Everything is packaged into a test.war file, and deployed to GlassFish.

test.war consists of 4 entries:

WEB-INF/classes/test/HelloEJB.class
WEB-INF/classes/test/HelloJSFBean.class
WEB-INF/web.xml
index.xhtml

index.xhtml page:

<!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"
 xmlns:ui="http://java.sun.com/jsf/facelets"
 xmlns:f="http://java.sun.com/jsf/core"
 xmlns:h="http://java.sun.com/jsf/html">
<ui:composition>
 <h:head>
     <h1><h:outputText value="jsf-ejb example" /></h1>
 </h:head>

 <h:body>
     <h:form id="form">
         <h:outputLabel value="helloEJB returned message: "/>
         <h:outputText  value="#{HelloJSFBean.message}"/>
     </h:form>
 </h:body>
</ui:composition>
</html>

HelloJSFBean managed bean:

package test;
import javax.faces.bean.*;
import javax.ejb.*;

@ManagedBean(name="HelloJSFBean")
@RequestScoped
public class HelloJSFBean implements java.io.Serializable {
 @EJB
 private HelloEJB helloEJB;

 public String getMessage() {
     return helloEJB.hello();
 }
}

HelloEJB singleton bean:

package test;
import javax.ejb.*;

@Singleton
public class HelloEJB {
 public String hello() {
     return "Hello from " + this;
 }
}

web.xml:

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   version="3.0">
<servlet>
 <servlet-name>Faces Servlet</servlet-name>
 <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
 <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
 <servlet-name>Faces Servlet</servlet-name>
 <url-pattern>/faces/*</url-pattern>
</servlet-mapping>
</web-app>

To run the webapp:

curl http://localhost:8080/test/faces/index.xhtml

helloEJB returned message: Hello from test.HelloEJB@1326d2fe

Runnable, Callable, FutureTask, ExecutorService and thread pool

2011-08-01T13:30:00.010-04:00

Some notes on Java concurrency, starting with Runnable vs Callable:

(1), Runnable.run() does not return a value; Callable<T>.run() returns a value of type T. Callable<T> is a parameterized type whose type parameter indicates the return type of its run method. Runnable cannot be parameterized.

(2), Runnable.run() cannot throw any checked exception; Callable<T>.run() can throw checked and unchecked exceptions.

(3), so it seems Callable is more powerful than Runnable. But you cannot just replace all use of Runnable with Callable. For example, in new Thread(runnable). You cannot instantiate a new thread with Callable.

(4), Callable is introduced in Java SE 5, as part of java.util.concurrent library. Callable is mainly intended to use with ExecutorService, which is a higher level service than the direct manipulation of Thread. Both Runnable and Callable can be submitted to ExecutorService for (usually asynchronous) execution.

(5), java.util.concurrent.Executors (a util class similar to Collections, Arrays) has methods to upgrade a Runnable to Callable, but not the other way.

Callable<Object> callable(Runnable task)
<T> Callable<T> callable(Runnable task, T result)

The Callable converted from callable(Runnable) returns null. The Callable converted from callable(Runnable, T) returns T. However, this return value that was passed in by the client is not the real result of executing task. Its purpose is to tell the client that the return type will be Future<T>. In order to obtain the real result, the client still needs to arrange for a thread-safe shared data storage, e.g., a final or volatile field of Runnable impl. Therefore, the converted Callable is still a Runnalbe in its core.

(6) FutureTask is another artifact involving both Callable and Runnable. FutureTask class implements RunnableFuture interface, which in turn extends both Runnable and Future interfaces. So FutureTask is a Runnable by inheritance, and can be passed to new Thread(futureTask), or ExecutorService.submit(futureTask).

FutureTask has a Callable<V> by composition as FutureTask's constructor takes Callable<V> as a param. FutureTask also has another constructor that takes 2 params (Runnable, V), which are simply converted to Callable via Executors.callable(Runnable, V). In fact, the same pattern is employed in java.util.concurrent wherever a method is overloaded with (Callable) and (Runnable, V).

(7), Runnable and Callable run() method takes no param. Why? For one thing, there is no way to know which types are to be passed in. The best we can do is probably Object[] if we were to add params to it. More importantly, it would export state from the calling thread to the task thread, and entails synchronization between the 2 sides. I guess this is why the plain old Runnable.run() takes no param and returns void. In Java 5 to balance simplicity and usefulness, Callable was added to return a result.

(8), how can a task be performed without any params passed to run()? The typical answer is to pass any required data in when instantiating the Callable or Runnable impl class via its constructor. For example,

public class RunnableImpl implements Runnable {
 private final List<String> names;
 
 public RunnableImpl(List<String> names) {
   this.names = names;
 }

 public void run() {...}
}

If RunnableImpl is a static inner class, its run() method can directly reference any static fields in the enclosing class. If RunnableImpl is an instance inner class, its run() method can directly reference any static and instance fields in the enclosing class. If RunnableImpl is an anonymous inner class, its run() method can directly reference any static and instance fields of the enclosing class, and any final local variables in the enclosing method.

(9), you can call Thread.setUncaughtExceptionHandler, or Thread.setDefaultUncaughtExceptionHandler to handle exceptions from Runnable.run(). When using ExecutionService where you have no direct control of threads, you can use a custom ThreadFactory. Executors methods newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor, newSingleThreadScheduledExecutor all take a custom ThreadFactory.

(10), Worker thread in thread pools and regular thread are different. A regular thread dies after its run method terminates and cannot be restarted. A worker thread does not die after the completion of the assigned task; it goes back to the thread pool. The main run method of a work thread is an infinite loop: taking a task from the work queue, and invoke the task's run method to do the task.

(11), ThreadLocal variables should be cleared up by the client once the task is done. Otherwise the left-over reference in worker threads prevent the referenced objects from being garbage-collected. Over time it may cause OutOfMemoryError.

(12), The thread pool default work queue in ExecutionService framework is unbounded. It means once the corePoolSize is reached, all subsequent requests will go into this unbound BlockingQueue, until some busy worker threads complete its task. No new worker threads will be created beyond corePoolSize, and maximumPoolSize is ignored in this case. For more details, see bug 6756747: java.util.concurrent.ThreadPoolExecutor doesn't create new worker when it should.

Example of JPA and Hibernate with JBoss and MySql

2011-07-29T22:07:00.007-04:00

This post demonstrates how to write a simple web app using Java Persistence API (JPA), EJB 3 session bean and servlet, connecting to MySql database, and deployed to JBoss appserver 6.

1, JPA entity class, Greeting, is the same as in my previous example, also included here in its entirety:

package test;
import java.io.Serializable;
import javax.persistence.*;

@Entity
public class Greeting implements Serializable {
@Id @GeneratedValue private int id;
@Basic private String message;
@Basic private String language;

public Greeting() {}

public Greeting(String message, String language) {
   this.message = message;
   this.language = language;
}

public String toString() {
   return "Greeting id=" + id + ", message=" + message + ", language=" + language;
}
}

2, a stateless session bean facade for CRUD operations with container-managed transaction and container-managed persistence context:

package test;
import javax.ejb.*;
import javax.persistence.*;

@Stateless
public class GreetingBean {
   @PersistenceContext
   private EntityManager em;

   public void create(Greeting... gs) {
       for(Greeting g : gs) {
           em.persist(g);
       }
   }

   public Greeting findByLang(String lang) {
       return (Greeting) em.createQuery("select g from Greeting g where g.language = :language")
           .setParameter("language", lang).getSingleResult();
   }
}

3, TestServlet, which calls the stateless session bean:

package test;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.ejb.EJB;

@javax.servlet.annotation.WebServlet(urlPatterns = "/*")
public class TestServlet extends HttpServlet {
   @EJB
   private GreetingBean bean;

   protected void processRequest(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
       PrintWriter out = response.getWriter();
       Greeting g_en = new Greeting("hello world", "en");
       Greeting g_es = new Greeting("hola, mundo", "es");
       bean.create(g_en, g_es);
       out.println("Created and persisted " + g_en + ", and " + g_es);

       Greeting g = bean.findByLang("en");
       out.println("Query returned: " + g);
   }

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

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

4, persistence.xml with JTA transaction using a MySQL datasource:

<?xml version="1.0" encoding="UTF-8"?>
<persistence 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_2_0.xsd"
       version="2.0">
   <persistence-unit name="greeting-pu" transaction-type="JTA">
   <!--
   <jta-data-source>java:/DefaultDS</jta-data-source>
   -->
   <jta-data-source>java:/MySqlDS</jta-data-source>
   <properties>
       <!--
       <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>
       -->
       <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
       <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
   </properties>
   </persistence-unit>
</persistence>

5, create the MySql datasource in JBoss appserver:

cp $JBOSS_HOME/docs/examples/jca/mysql-ds.xml $JBOSS_HOME/server/default/deploy/
# change user-name and password elements in mysql-ds.xml
cp $HOME/downloads/mysql-connector-java-5.1.15-bin.jar $JBOSS_HOME/server/default/lib/

6, compile and package class files and persistence.xml into test.war:

javac -d ../ -cp "$JBOSS_HOME/client/*" *.java

content of test.war:
====================
WEB-INF/classes/META-INF/persistence.xml
WEB-INF/classes/test/Greeting.class
WEB-INF/classes/test/GreetingBean.class
WEB-INF/classes/test/TestServlet.class

7, start MySql database server, JBoss default server and deploy test.war:

cd /usr/local/mysql-5.1.32
sudo bin/mysqld_safe --user root

$JBOSS_HOME/bin/run.sh

8, deploy and run the test:

cp test.war $JBOSS_HOME/server/default/deploy
curl http://localhost:8080/test/

If you use the default HyperSonic embedded database in JBoss AS, instead of MySql database server, make the following adjustments:

(a), toggle the comments in persistence.xml;
(b), no need to copy mysql-ds.xml, or MySql driver jar;
(c), no need to start MySql database server.

How to programmatically copy jar files

2011-07-05T23:06:00.003-04:00

To copy a jar file programmatically in java involves the following steps:

1, create a JarOutputStream based on the destination jar file;

2, loop through all entries in the source jar file, and get the InputStream from each entry;

3, create a new jar entry with the same name as the source jar entry, and put the new entry to the JarOutputStream;

4, now we have InputStream, OutputStream, and the new jar entry in place, we are ready to transfer the bits, by reading bytes from InputStream into a buffer and writing buffer content to OutputStream.

5, close the InputStream, flush the JarOutputStream, and close the jar entry. This completes the copying of one jar entry.

6, after the loop ends, all entries are copied from source jar file to destination jar file. Finally, close the JarOutputStream.

package test;
import java.io.*;
import java.util.Enumeration;
import java.util.jar.*;

//java -cp . test.CopyZip xxx/lib/sac-1.3.jar /tmp
//
public class CopyZip {
   public static void main(String[] args) throws Exception {
       File sourceFileOrDir = new File(args[0]);
       File destDir = new File(args[1]);
       if (sourceFileOrDir.isFile()) {
           copyJarFile(new JarFile(sourceFileOrDir), destDir);
       } else if (sourceFileOrDir.isDirectory()) {
           File[] files = sourceFileOrDir.listFiles(new FilenameFilter() {
               public boolean accept(File dir, String name) {
                   return name.endsWith(".jar");
               }
           });
           for (File f : files) {
               copyJarFile(new JarFile(f), destDir);
           }
       }
   }

   public static void copyJarFile(JarFile jarFile, File destDir) throws IOException {
       String fileName = jarFile.getName();
       String fileNameLastPart = fileName.substring(fileName.lastIndexOf(File.separator));
       File destFile = new File(destDir, fileNameLastPart);

       JarOutputStream jos = new JarOutputStream(new FileOutputStream(destFile));
       Enumeration<JarEntry> entries = jarFile.entries();

       while (entries.hasMoreElements()) {
           JarEntry entry = entries.nextElement();
           InputStream is = jarFile.getInputStream(entry);

           //jos.putNextEntry(entry);
           //create a new entry to avoid ZipException: invalid entry compressed size
           jos.putNextEntry(new JarEntry(entry.getName()));
           byte[] buffer = new byte[4096];
           int bytesRead = 0;
           while ((bytesRead = is.read(buffer)) != -1) {
               jos.write(buffer, 0, bytesRead);
           }
           is.close();
           jos.flush();
           jos.closeEntry();
       }
       jos.close();
   }
}

A common error is:

Exception in thread "main" java.util.zip.ZipException: invalid entry compressed size (expected 1665 but got 1680 bytes)
   at java.util.zip.ZipOutputStream.closeEntry(ZipOutputStream.java:206)
   at test.CopyZip.copyJarFile(CopyZip.java:63)
   at test.CopyZip.main(CopyZip.java:37)

It usually occurs when text file entries in the source jar file contain some non-ASCII characters such as ^I ^Z ^D ^C. Some common files are META-INF/COPYRIGHT.html, META-INF/LICENSE.txt, etc, probably because these files were created in a non-ASCII editor but saved as text files. Open them in vi or vim to see these offending characters.

To avoid this type of ZipException, always create a new JarEntry with the same name, and pass it to putNextEntry() method. Do not pass the existing jar entry from the source jar file to putNextEntry() method.

Servlet init method vs PostConstruct method

2011-07-03T12:36:00.009-04:00

There are 2 initialization methods in servlet:

(1), init(ServletConfig config) methods defined in javax.servlet.Servlet interface. Servlet init method has been there since the first version of Servlet. This method was later (around Servlet 2.3) overloaded in javax.servlet.GeneircServlet for convenience. According to the above javadoc, the servlet container calls the init method exactly once after instantiating the servlet.

(2), PostConstruct method, as defined in javax.annotation.PostConstruct, was introduced in Java EE 5 to all component types, including all web components (Servlet 2.5). Similarly, @PostConstruct (or post-construct, if declared in deployment descriptors) methods are to be invoked only once after the component class is instantiated and before it is put into service.

But these two servlet methods are not exactly the same.

The name of Servlet init method is set in the interface, and it must be public. PostConstruct method is more flexible: it can be private, package default, protected, or public, and can be named anything.

I could not find docs specifying the invocation order and relationship of the two methods. But it turns out the order is:

servlet class constructor --> PostConstruct --> init and init(ServletConfig)

So inside PostConstruct method at the second step, ServletConfig has not been initialized, and neither is ServletContext. Calling getServletConfig() in PostConstruct returns null. Calling getServletContext() results in IllegalStateException in most servers (GlassFish 3, Tomcat 7 and JBoss 6), but returns null in Resin 4.

Apparently there are overlappings and subtle differences between PostConstruct and servlet init methods. I guess ideally we could merge them into one. If there is no PostConstruct method in servlet class, init() will be considered as its PostConstruct method; if developers want to specify a PostConstruct method, it has to be the same as init() method, basically adding the redundant @PostConstruct to init(). This is roughly how ejbCreate and PostConstruct is handled in EJB 3.

What about web apps that already have both PostConstruct and init methods? In order to accommodate them, the next desirable approach is to allow both, but clearly specify their relationship, making clear getServletConfig() and getServletContext() both return valid values inside the both methods.

The same applies to PreDestroy and servlet destroy method, to a lesser extent.

Jetty to GlassFish remote EJB invocation

2011-06-20T15:30:00.011-04:00

Jetty-to-GlassFish EJB invocation is similar to Tomcat-to-GlassFish case. I tested with Jetty Hightide 7.4.2 and GlassFish 3.1.

Jetty configuration (in csh/tcsh syntax):

setenv JETTY_HOME $HOME/tools/jetty
setenv JETTY_PORT 7070     # avoid port conflict
mkdir $JETTY_HOME/lib/ext/glassfish

The following commands copy 32 GlassFish jars needed for this test to Jetty directory:

cd $GLASSFISH_HOME/modules
cp javax.ejb.jar ejb-container.jar deployment-common.jar dol.jar glassfish-corba-csiv2-idl.jar glassfish-corba-codegen.jar ssl-impl.jar security.jar ejb.security.jar management-api.jar gmbal-api-only.jar gmbal.jar glassfish-corba-asm.jar glassfish-corba-newtimer.jar glassfish-corba-orbgeneric.jar config-types.jar kernel.jar config.jar config-api.jar glassfish-corba-omgapi.jar glassfish-corba-orb.jar orb-connector.jar orb-enabler.jar orb-iiop.jar glassfish-api.jar auto-depends.jar hk2-core.jar internal-api.jar common-util.jar glassfish-corba-internal-api.jar glassfish-naming.jar bean-validator.jar $JETTY_HOME/lib/ext/glassfish

I had to slightly modify TestServlet to make it work in Jetty:

1, declare TestServlet with web.xml instead of using @javax.servlet.annotation.WebServlet, probably because servlet 3.0 support is not there yet in Jetty 7.4.2;

2, change @PostConstruct method to servlet init method. When using @PostConstruct to look up TestBean, it is not initialized and produced NullPointerException at request time. So I changed it to servlet init() method, which is a lifecycle method since early days of servlet. The complete TestServlet.java and web.xml:

package test;
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.naming.*;
import javax.annotation.*;

public class TestServlet extends HttpServlet {
   private static final String glassfishJndiPropertiesPath = "/glassfish-jndi.properties";
   private static final String testBeanJndi = "java:global/test-ejb/TestBean";
   private TestIF testBean;

   private Properties getGlassFishJndiProperties() {
      Properties props = new Properties();
      try {
          props.load(getClass().getResourceAsStream(glassfishJndiPropertiesPath));
      } catch (IOException e) {
          System.out.println("Failed to load " + glassfishJndiPropertiesPath);
      }
      System.out.println("Got glassfish-jndi.properties: " + props);
      return props;
   }

   public void init() {
       try {
           InitialContext ic = new InitialContext(getGlassFishJndiProperties());
           testBean = (TestIF) ic.lookup(testBeanJndi);
           System.out.println("Looked up " + testBeanJndi + ", got " + testBean);
       } catch (NamingException e) {
           throw new RuntimeException(e);
       }
   }

   protected void processRequest(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
       PrintWriter out = response.getWriter();
       out.println("testBean.hello(): " + testBean.hello());
   }

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

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

web.xml:
--------
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

 <servlet>
   <servlet-name>TestServlet</servlet-name>
   <servlet-class>test.TestServlet</servlet-class>
 </servlet>

 <servlet-mapping>
   <servlet-name>TestServlet</servlet-name>
   <url-pattern>/*</url-pattern>
 </servlet-mapping>
</web-app>

After packaging, test2.war (a sample app test.war is already included in jetty/webapps, so use a different name) contains the following entries:

WEB-INF/classes/glassfish-jndi.properties
WEB-INF/classes/test/TestIF.class
WEB-INF/classes/test/TestServlet.class
WEB-INF/web.xml

Other files, TestIF, TestBean, test-ejb.jar and glassfish-jndi.properties, are all the same as in Tomcat and Resin exercise.

Resin to GlassFish remote EJB invocation

2011-06-16T13:03:00.003-04:00

Resin-to-GlassFish EJB invocation is almost identical to Tomcat-to-GlassFish case. I tested with Resin-4.0.18 with GlassFish 3.1. One minor difference is that Resin has its own bean validation implementation, so GlassFish's bean-validator.jar need not be copied to Resin. The following is the list of 31 GlassFish jars needed for Resin client, in one single line for copying:

cd $GLASSFISH_HOME/modules
cp javax.ejb.jar ejb-container.jar deployment-common.jar dol.jar glassfish-corba-csiv2-idl.jar glassfish-corba-codegen.jar ssl-impl.jar security.jar ejb.security.jar management-api.jar gmbal-api-only.jar gmbal.jar glassfish-corba-asm.jar glassfish-corba-newtimer.jar glassfish-corba-orbgeneric.jar config-types.jar kernel.jar config.jar config-api.jar glassfish-corba-omgapi.jar glassfish-corba-orb.jar orb-connector.jar orb-enabler.jar orb-iiop.jar glassfish-api.jar auto-depends.jar hk2-core.jar internal-api.jar common-util.jar glassfish-corba-internal-api.jar glassfish-naming.jar $RESIN_HOME/lib

To change Resin http port number from the default 8080 to other number (e.g., 7070), edit resin/conf/resin.xml:

<http address="*" port="7070"/>

All the rest, including test app code, deployment & execution steps are exactly the same as in Tomcat exercise. This is the test command & output in resin:

curl http://localhost:7070/test/
testBean.hello(): From test.TestBean@47dccc2

Tomcat to GlassFish remote EJB invocation

2011-06-11T21:56:00.013-04:00

In order to make Tomcat(7.0.8)-to-GlassFish(v3) remote EJB invocation, one has to solve 2 challenges:

1, add relevent GlassFish client-side jar files to tomcat lib. There is an all-inclusive client jar (glassfish/lib/gf-client.jar), which references practically all GlassFish jars. But adding gf-client.jar to Tomcat lib would cause various conflict of system classes. So one still needs to figure out which GlassFish jars are needed, mostly by trial and error.

For a simple Tomcat-GlassFish test that includes a servlet (in Tomcat) invoking remote EJB 3 stateless bean (in GlassFish 3), the following 32 jars are the minimum set of jars to be included in Tomcat lib:

javax.ejb.jar
ejb-container.jar
deployment-common.jar
dol.jar
glassfish-corba-csiv2-idl.jar
glassfish-corba-codegen.jar
ssl-impl.jar
security.jar
ejb.security.jar
management-api.jar
gmbal-api-only.jar
gmbal.jar
glassfish-corba-asm.jar
glassfish-corba-newtimer.jar
glassfish-corba-orbgeneric.jar
bean-validator.jar
config-types.jar
kernel.jar
config.jar
config-api.jar
glassfish-corba-omgapi.jar
glassfish-corba-orb.jar
orb-connector.jar
orb-enabler.jar
orb-iiop.jar
glassfish-api.jar
auto-depends.jar
hk2-core.jar
internal-api.jar
common-util.jar
glassfish-corba-internal-api.jar
glassfish-naming.jar

2, add GlassFish jndi properties to application lookup code. The complete servlet class:

package test;

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.naming.*;
import javax.annotation.*;

@javax.servlet.annotation.WebServlet(urlPatterns = "/*")
public class TestServlet extends HttpServlet {
private static final String glassfishJndiPropertiesPath = "/glassfish-jndi.properties";
private static final String testBeanJndi = "test.TestIF";
private TestIF testBean;

private Properties getGlassFishJndiProperties() {
Properties props = new Properties();
try {
 props.load(getClass().getResourceAsStream(glassfishJndiPropertiesPath));
} catch (IOException e) {
 System.out.println("Failed to load " + glassfishJndiPropertiesPath);
}
System.out.println("Got glassfish-jndi.properties: " + props);
return props;
}

@PostConstruct
private void initTestBean() {
try {
  InitialContext ic = new InitialContext(getGlassFishJndiProperties());
  testBean = (TestIF) ic.lookup(testBeanJndi);
} catch (NamingException e) {
  throw new RuntimeException(e);
}
}

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.println("testBean.hello(): " + testBean.hello());
}

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

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

The content of the test.war deployed in Tomcat:

WEB-INF/classes/glassfish-jndi.properties
WEB-INF/classes/test/TestIF.class
WEB-INF/classes/test/TestServlet.class

TestIF is the remote business interface of TestBean. WEB-INF/classes/glassfish-jndi.properties is packaged into the war file to provide GlassFish jndi bootstrap properties. Its content is basedon the one in GlassFish server:

java.naming.factory.initial=com.sun.enterprise.naming.impl.SerialInitContextFactory
java.naming.factory.url.pkgs=com.sun.enterprise.naming
# Required to add a javax.naming.spi.StateFactory for CosNaming that
# supports dynamic RMI-IIOP.
java.naming.factory.state=com.sun.corba.ee.impl.presentation.rmi.JNDIStateFactoryImpl

# uncomment the following lines if GlassFish is running on
# different host and non-default port number.
# org.omg.CORBA.ORBInitialHost=localhost
# org.omg.CORBA.ORBInitialPort=3700

test-ejb.jar deployed in GlassFish 3 just contains the bean class and its remote business interface:

test/TestBean.class
test/TestIF.class

TestIF.java:
========

package test;
import javax.ejb.*;

@Remote
public interface TestIF {
public String hello();
}

TestBean.java:
==========

package test;
import javax.ejb.*;

@Stateless
@Remote(TestIF.class)
public class TestBean implements TestIF {
public String hello() {
return "From " + this;
}
}

After both test-ejb.jar and test.war are packaged, first deploy test-ejb.jar to GlassFish, and then deploy test.war to Tomcat:

cp test-ejb.jar $GLASSFISH_HOME/domains/domain1/autodeploy

# to verify it has been successfully deployed:
$GLASSFISH_HOME/bin/asadmin list-applications

cp test.war tomcat/webapps

Visit the test URL http://localhost:7070/test/ to see the result of remote EJB invocation. The default http port number in Tomcat and GlassFish are the same (8080). So if they are on the same host, need to change one of them. I changed Tomcat to use 7070 by editing tomcat/conf/server.xml.

When loading glassfish-jndi.properties, the current class loader, instead of ServletContext, is used to get the resource. The reason is in @PostConstruct method, ServletConfig has not been initialized, and so GenericServlet.getServletConfig().getServletContext() failed with NullPointerException.

The jndi name for looking up, test.TestIF, is the default GlassFish-specific global jndi name. The portable global jndi name, java:global/test-ejb/TestBean, works as well.

javax.naming.Reference cannot be cast to in GlassFish

2011-06-10T22:19:00.008-04:00

This error usually happens when the client tries to cast the lookup result to the expected type, such as EJB remote interface. This is what happens behind the scene. During the naming context lookup, a javax.naming.Reference is first acquired, which contains information how to create the actual object for the client. If the object creation step fails, then the half-baked javax.naming.Reference is returned to the client, hence the ClassCastException.

Some reasons why the naming manager failed to create object:

1, the object factory class responsible for creating the object is not available in the client classpath. Think of javax.naming.Reference as the raw material for creating the object. When there is no factory, no object is created, and the raw material is thrown back to the client.

In GlassFish 3, the object factory for remote EJB reference appears to be com.sun.ejb.containers.RemoteBusinessObjectFactory, packaged in ejb-container.jar. So ejb-container.jar and javax.ejb.jar should be in the client classpath by direct inclusion or by reference, along with a series of other jar files.

The following is the toString format of the returned javax.naming.Reference:

Reference Class Name: test.TestIF
Type: url
Content: ejb/TestBean__3_x_Internal_RemoteBusinessHome__

2, the object factory is in client classpath, but not loadable by the current thread context class loader.

The algorithm for creating object is in javax.naming.spi.NamingManager.

VirtualBox shared folder for Ubuntu guest

2011-05-05T13:28:00.007-04:00

After upgrading my Ubuntu guest OS, the configured Guest Addition and shared folders are gone. So I have to go through the exercise again. Keep this note for future reference:

1, Make sure dkms is up to date:

sudo apt-get install dkms

Reading package lists... Done
Building dependency tree
Reading state information... Done
dkms is already the newest version.
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

2, install Guest Addition on Ubuntu:

Click VirtualBox menu Devices | Install Guest Additions..., nothing happened. Then run it manually instead:

sudo sh /media/VBOXADDITIONS_4.0.6_71344/VBoxLinuxAdditions.run

3, Add shared folders by clicking VirtualBox menu Devices | Shared Folders

4, Mount the shared folder to the guest Ubuntu and make it accessible to yourself.

The default mounting point is /media/sf_<the-name-entered-in-step-3>, and is accessible to group vboxsf only. To open it up for yourself, go to Ubuntu menu System | Administration | Users and Groups, then go to Manage Groups | vboxsf | Properties | Group Members, and add yourself to this group.

While there, also change the account type to Administrator. It's not a required step, but I like to have maximum permission.

My mvn notes

2011-04-20T08:37:00.005-04:00

To skip running tests:

mvn install -DskipTests
mvn install -DskipTests=true  //to override skipTests property in pom

To skip compiling and running tests:

mvn install -Dmaven.test.skip=true

To run maven in offline mode, to avoid downloading:

mvn -o install
mvn --offline install

To force check for updates of snapshots and releases from remote repositories:

mvn -U install
mvn --update-snapshots install

To override maven surefire plugin forkMode:

mvn test -DforkMode=never
mvn test -DforkMode=always

To debug a non-forked test, just need to attach the remote debugger to mvn process itself. mvnDebug is a convenience script located in the same directory as mvn executable:

mvnDebug test
mvnDebug test -DforkMode=never

To debug a forked test, you will need to set the debug option to the forked VM, not the mvn VM. The way to do it is to set -Dmaven.surefire.debug flag to mvn VM (the parent VM):

mvn test -Dmaven.surefire.debug
mvn test -Dmaven.surefire.debug -DforkMode=always
mvn test -Dmaven.surefire.debug -Dtest=com.my.test.MyTest#test1

To avoid OutOfMemoryError from running maven, especially maven 3, set environment variable MAVEN_OPTS:

# in $HOME/.tcshrc, or $HOME/.cshrc, if using csh or tcsh:
setenv MAVEN_OPTS "-Xmx1024m -XX:MaxPermSize=256m"

# in $HOME/.profile or $HOME/.bashrc, if using ksh or bash:
export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=256m"

# in Windows Control Panel, or set it in DOS command line:
set MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=256m

To run mvn with an alternate user setting file, e.g., settings-jboss.xml:

mvn -s $HOME/.m2/settings-jboss.xml

The content of settings-jboss.xml:

<settings>
<repositories>
        <repository>
          <id>jboss-public-repository-group</id>
          <name>JBoss Public Maven Repository Group</name>
          <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url>
          <layout>default</layout>
          <releases>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
          </releases>
          <snapshots>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
          </snapshots>
        </repository>
      </repositories>
</settings>

My vim notes

2011-04-01T15:28:00.024-04:00

To open all files whose paths are stored in a file into multiple vim buffers:

cat list.txt | xargs vim
xargs vim < /tmp/a

To redirect the output from a command (ps) into vim for easy search and maybe saving it:

ps -ef | vim -

To combine vim and find to open all matched files:

vim `find . -name build.xml`
find . -name web.xml | xargs vim

find . -name web.xml -exec vim {} \; is different: it will find a match, vim it, and repeat, and only 1 buffer in any vim session.

Be careful with file names with spaces. These pipelined use of find and xargs will treat spaces as delimiter between args, and break one arg into two.

vim search & replace in a file(replace old with new in the whole file, CASE sensitive, asking for confirmation). When prompted for confirmation, press 'a' to confirm all ocurrences including and after the current one.

:%s/old/new/gcI

To bookmark a location as bookmark a, type ma. To go to bookmark a, type 'a

To turn off syntax highlighting, run command ":sy off", or ":syn off", or ":syntax off", to turn on highlighting again ":sy on", or ":syn on", or ":syntax on". After typing ":sy", you can press TAB key for autocomplete, or press Ctrl-D to list all matching commands.

To turn off highlight after you are done with a search, run command ":nohl"

To turn on highight search, if it's not already on, run command ":set hls"

To save all changed files, run command ":wa"

To save all changed files and exit, run command ":xa"

":x" is the same as ":wq": save and exit

To close all files and exit, run command ":qa", but vim won't exit if there is unsaved changes.

To close all files and exit forcifully, run command ":q!".

To open a file and go the end of the file (to skip long copyright):


vim -c :$ pom.xml

To open a file (e.g., log file) in read-only mode and go to the end of file:


  view -c :$ $JBOSS_HOME/standalone/log/server.log
vim -R -c :$ $JBOSS_HOME/standalone/log/server.log

The above commands are similar to tail -f, but easier to search and navigate inside vim.

To open a file with gvim or vim from Mac OS terminal, run

"open -a gvim build.xml"

If you configure Finder to always open *.xml files with gvim, directly run

"open build.xml"

You can still open them with the default TextEdit with

"open -a textedit build.xml"

To customize gvim window size (the default is too small), add the following lines to $HOME/.gvimrc on Mac/Linux/Solaris, or %HOMEPATH%\_gvimrc on Windows:

set lines=80 columns=120

To substitue the current character and stay in insertion mode, type s

To change to overwrite/replace mode (as opposed to insertion), shift-R (Uppercase R)

To undo the last undo: Ctrl-R

To search with case-insensitive option for this search only, /foo\c

GlassFish embedded, JPA, EJB, DataSource and glassfish-resources.xml

2011-02-11T10:32:00.009-05:00

In a previous post I wrote about using @DataSourceDefinition to create a JTA data source for JPA in a standalone java application. Another option is to use glassfish-resources.xml to define the data source. The following is a standalone test app that includes glassfish embedded, JPA, EJB, Servlet, and JTA data source defined with glassfish-resources.xml.

As with the previous test app, GlassFish server is running in the same JVM as the test app. And in this example, the test program starts the GlassFish embedded, constructs a scattered web app, deploys it, sends http request, undeploys it, and finally shuts down the server.

WEB-INF/classes/META-INF/persistence.xml :

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.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_2_0.xsd">
<persistence-unit name="test_pu" transaction-type="JTA">
<jta-data-source>java:app/jdbc/test</jta-data-source>
<properties>
 <property name="eclipselink.ddl-generation" value="create-tables"/>
 <property name="eclipselink.logging.level" value="FINE"/>
</properties>
</persistence-unit>
</persistence>

WEB-INF/glassfish-resources.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Resource Definitions//EN" "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">

<resources>
<jdbc-connection-pool
 name="java:app/jdbc/test_pool"
 res-type="javax.sql.DataSource"
 datasource-classname="com.mysql.jdbc.jdbc2.optional.MysqlDataSource"
 pool-resize-quantity="1"
 max-pool-size="5"
 steady-pool-size="0"
 statement-timeout-in-seconds="30" >
   <property name="User" value="root"></property>
   <property name="Password" value="root"></property>
   <property name="portNumber" value="3306"></property>
   <property name="dataBaseName" value="test"></property>
   <property name="serverName" value="localhost"></property>
 </jdbc-connection-pool>
 <jdbc-resource pool-name="java:app/jdbc/test_pool" jndi-name="java:app/jdbc/test"></jdbc-resource>
</resources>

WEB-INF/classes/test/Employee:

package test;
import javax.persistence.*;

@Entity
public class Employee implements java.io.Serializable {
private static final long serialVersionUID = 1L;

@Id @GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

@Basic private String name;

public Long getId() {
   return id;
}

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

public String getName() {
   return name;
}

public void setName(String name) {
   this.name = name;
}

@Override public int hashCode() {
   int hash = 0;
   hash += (id != null ? id.hashCode() : 0);
   return hash;
}

@Override public boolean equals(Object object) {
   // TODO: Warning - this method won't work in the case the id fields are not set
   if (!(object instanceof Employee)) {
       return false;
   }
   Employee other = (Employee) object;
   if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
       return false;
   }
   return true;
}

@Override public String toString() {
   return "Employee id=" + id + ", name=" + name;
}
}

WEB-INF/classes/test/TestBean:

package test;
import javax.ejb.Stateless;
import javax.persistence.*;
import javax.annotation.sql.DataSourceDefinition;

@Stateless
public class TestBean {
@PersistenceContext private EntityManager em;

public void addEmployee(String[] names) {
   for(String name : names) {
       Employee e = new Employee();
       e.setName(name);
       em.persist(e);
   }
}
}

WEB-INF/classes/test/TestServlet:

package test;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.annotation.*;
import javax.ejb.*;

@javax.servlet.annotation.WebServlet(urlPatterns = "/*")
public class TestServlet extends HttpServlet {
 @EJB private TestBean testBean;

 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
     PrintWriter out = response.getWriter();
     String[] names =request.getParameterValues("name");
     testBean.addEmployee(names);
     out.println("Added employees " + java.util.Arrays.toString(names));
 }

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

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

WEB-INF/classes/test/Client:

package test;

import org.glassfish.embeddable.Deployer;
import org.glassfish.embeddable.GlassFish;
import org.glassfish.embeddable.GlassFishProperties;
import org.glassfish.embeddable.GlassFishRuntime;
import org.glassfish.embeddable.archive.ScatteredArchive;

import java.io.*;
import java.net.*;

public class Client {
 private static final String warName = "test";
 private static final int portNumber = 8080;
 private GlassFish glassfish;
 private Deployer  deployer;

 public static void main(String[] args) throws Exception {
     Client client = new Client();
     client.setUp();
     client.test(args);
     client.tearDown();
 }

 protected void setUp() throws Exception {
     GlassFishProperties props = new GlassFishProperties();
     props.setPort("http-listener", portNumber);
     glassfish = GlassFishRuntime.bootstrap().newGlassFish(props);
     glassfish.start();
     deployer = glassfish.getDeployer();
 }

 protected void tearDown() throws Exception {
     deployer.undeploy(warName);
     glassfish.dispose();
 }

 protected void test(String[] names) throws Exception {
     ScatteredArchive scattered = new ScatteredArchive(warName, ScatteredArchive.Type.WAR, new File("./"));
     deployer.deploy(scattered.toURI());
     URL url = new URL("http://localhost:" + portNumber + "/" + warName + "/?name=Jon&name=Jane");
     HttpURLConnection conn = (HttpURLConnection) url.openConnection();
     BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
     System.out.println("Request url: " + url);
     String line = null;
     while ((line = in.readLine()) != null) {
         System.out.println(line);
     }
     in.close();
     conn.disconnect();
 }
}

To compile from project directory:

$ javac -cp "$GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar" WEB-INF/classes/test/*java

Start mysqld, and run the app:

cd /usr/local/mysql-5.1.32; sudo bin/mysqld_safe --user root
java -cp "WEB-INF/classes:$GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar:$HOME/mysql-connector-java-5.1.5-bin.jar" test.Client

Among very verbose command-line output are these lines:

Request url: http://localhost:8080/test/?name=Jon&name=Jane
Added employees [Jon, Jane]
classLoader = WebappClassLoader (delegate=true; repositories=WEB-INF/classes/)

Verify entities are successfully created by running mysql:

mysql> select * from EMPLOYEE;
+----+------+
| ID | NAME |
+----+------+
|  1 | Jon  |
|  2 | Jane |
+----+------+
2 rows in set (0.00 sec)

The test client main class mimics the strucutre of a JUnit test case, and can be easily converted to one if needed.

How to create and look up thread pool resource in GlassFish

2011-02-10T10:41:00.013-05:00

In order to create a custom thread pool task executor resource, one needs to implement 2 classes: the thread pool class, and its object factory class.

In my implementation, the thread pool class, test.ThreadPoolExecutor is simply a subclass of java.util.concurrent.ThreadPoolExecutor. It is implemented as a singleton so every lookup and injection always return the same instance.

package test;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor {
 static final int defaultCorePoolSize = 5;
 static final int defaultMaximumPoolSize = 10;
 static final long defaultKeepAliveTime = 10;
 static final TimeUnit defaultTimeUnit = TimeUnit.MINUTES;
 static final BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
 private static ThreadPoolExecutor instance;

 private ThreadPoolExecutor() {
     super(defaultCorePoolSize, defaultMaximumPoolSize, defaultKeepAliveTime, defaultTimeUnit, workQueue);
 }

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

The factory class, test.ThreadPoolExecutorFactory, is required to implement javax.naming.spi.ObjectFactory. It also implements a GlassFish-specific interface com.sun.appserv.server.LifecycleListener so that it can also be registered as a GlassFish lifecycle module. Upon receiving a server termination event, this class will shutdown the thread pool resource.

package test;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.concurrent.TimeUnit;

import javax.naming.Context;
import javax.naming.Name;
import javax.naming.NamingException;
import javax.naming.RefAddr;
import javax.naming.Reference;

import com.sun.appserv.server.LifecycleEvent;
import com.sun.appserv.server.ServerLifecycleException;

public class ThreadPoolExecutorFactory implements javax.naming.spi.ObjectFactory,
     com.sun.appserv.server.LifecycleListener, java.io.Serializable {
 public Object getObjectInstance(Object obj, Name name, Context nameCtx,
         Hashtable<?, ?> environment) throws Exception {
     ThreadPoolExecutor tp = ThreadPoolExecutor.getInstance();
     try {
         Reference reference = (Reference) obj;
         Enumeration<?> enumeration = reference.getAll();
         TimeUnit timeUnit = ThreadPoolExecutor.defaultTimeUnit;
         long keepAliveTime = ThreadPoolExecutor.defaultKeepAliveTime;
         while (enumeration.hasMoreElements()) {
             RefAddr refAddr = (RefAddr) enumeration.nextElement();
             String pname = refAddr.getType();
             String pvalue = (String) refAddr.getContent();
             if ("corePoolSize".equalsIgnoreCase(pname)) {
                 tp.setCorePoolSize(Integer.parseInt(pvalue));
             } else if ("maximumPoolSize".equalsIgnoreCase(pname)) {
                 tp.setMaximumPoolSize(Integer.parseInt(pvalue));
             } else if ("timeUnit".equalsIgnoreCase(pname)) {
                 timeUnit = TimeUnit.valueOf(pvalue);
             } else if ("keepAliveTime".equalsIgnoreCase(pname)) {
                 keepAliveTime = Long.parseLong(pvalue);
             } else if ("allowCoreThreadTimeOut".equalsIgnoreCase(pname)) {
                 tp.allowCoreThreadTimeOut(Boolean.parseBoolean(pvalue));
             } else if ("prestartAllCoreThreads".equalsIgnoreCase(pname)) {
                 if (Boolean.parseBoolean(pvalue)) {
                     tp.prestartAllCoreThreads();
                 }
             } else {
                 throw new IllegalArgumentException("Unrecognized property name: " + pname);
             }
         }
         tp.setKeepAliveTime(keepAliveTime, timeUnit);
     } catch (Exception e) {
         throw (NamingException) (new NamingException()).initCause(e);
     }
     return tp;
 }

 public void handleEvent(LifecycleEvent event) throws ServerLifecycleException {
     if (event.getEventType() == LifecycleEvent.TERMINATION_EVENT) {
         ThreadPoolExecutor tp = ThreadPoolExecutor.getInstance();
         System.out.println("About to purge and shutdown " + tp + ", active thread count: "
                 + tp.getActiveCount());
         tp.purge();
         tp.shutdown();
     }
 }
}

Copy 2 class files to $GLASSFISH_HOME/domains/domain1/lib/classes directory, with package name, and restart domain:

ls $GLASSFISH_HOME/domains/domain1/lib/classes/test/
ThreadPoolExecutorFactory.class  ThreadPoolExecutor.class

$ asadmin restart-domain

Next, create the thread pool resource, and register lifecycle module. It can also be done in admin console, in a more user-friendly manner.

$ asadmin create-custom-resource --restype test.ThreadPoolExecutor --factoryclass test.ThreadPoolExecutorFactory --description "A ThreadPoolExecutor backed by LinkedBlockingQueue" --property corePoolSize=6:maximumPoolSize=50:keepAliveTime=4:timeUnit=MINUTES:allowCoreThreadTimeOut=true:prestartAllCoreThreads=true concurrency/TP
Command create-custom-resource executed successfully.

$ asadmin create-lifecycle-module --classname "test.ThreadPoolExecutorFactory" --failurefatal=true concurrency/TP-shutdown

To list and delete custom resources and lifecycle modules:

$ asadmin list-custom-resources

$ asadmin list-lifecycle-modules

$ asadmin delete-lifecycle-module concurrency/TP-shutdown

$ asadmin delete-custom-resource concurrency/TP

This is how it looks like in admin console, where you can easily manage it:

To use this resource, just inject or look up in application components. The following is a test servlet that verifies that the resource can be obtained with either @Resource or regular lookup, and that multiple lookups return the same instance.

package test;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.annotation.*;
import javax.naming.*;

@javax.servlet.annotation.WebServlet(urlPatterns = "/*")
public class TestServlet extends HttpServlet {
   @Resource(name="java:app/env/concurrency/TP", mappedName="concurrency/TP")
   private test.ThreadPoolExecutor tp;

   @Override
   protected void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
       testLookup();
       System.out.println("About to submit tasks to " + tp);
       for(int i = 0; i < 30; i++) {
           tp.execute(new MyRunnable());  
       }
   }

   private void testLookup() throws ServletException {
       try {
           for(int i = 0; i < 10; i++) {
               ThreadPoolExecutor t = InitialContext.<ThreadPoolExecutor>doLookup("java:app/env/concurrency/TP");
               System.out.println("ThreadPoolExecutor from lookup: " + t);
           }
       } catch (NamingException e) {
           throw new ServletException(e);
       }
   }

   private static class MyRunnable implements Runnable {
       public void run() {
           System.out.println("Executing task in " + Thread.currentThread());
       }
   }
}

When running the test webapp at http://localhost:8080/test/, many log messages like these will appear in server.log:

ThreadPoolExecutor from lookup: test.ThreadPoolExecutor@12e0a75a
Executing task in Thread[pool-29-thread-6,5,grizzly-kernel

In the above output, pool-29-thread-6 is the thread name, 5 (normal) is its priority, and grizzly-kernel is thread group name. When shutting down the server, the thread pool is purged and shutdown, thanks to the lifecycle module concurrency/TP-shutdown:

Server shutdown initiated
About to purge and shutdown test.ThreadPoolExecutor@12e0a75a, active thread count: 0
JMXStartupService: Stopped JMXConnectorServer: null
JMXStartupService and JMXConnectors have been shut down.
Shutdown procedure finished

This is just a simplistic implementation of thead pool resource in GlassFish. There is a potential class loader leak and may cause ClassCastException and/or OutOfMemoryError in large applications.

EJB lite, JPA, DataSource embedded in java application

2011-02-06T14:54:00.009-05:00

This post demonstrates how to put EJB lite, JPA, DataSource together in a standalone java application, using standard JavaEE 6 API in GlassFish. The application source consists of 4 files: persistence.xml, JPA entity, no-interface EJB, and main class.

Transaction is managed by embeddable EJB container. The persistence unit is backed by an application-scoped JTA DataSource declared with annotation on EJB class. No need to package or deploy anything. Client and server pieces are all in a single JVM.

classes/META-INF/persistence.xml :

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.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_2_0.xsd">
<persistence-unit name="test_pu" transaction-type="JTA">
  <jta-data-source>java:app/jdbc/test</jta-data-source>
  <properties>
    <property name="eclipselink.ddl-generation" value="create-tables"/>
    <property name="eclipselink.logging.level" value="FINE"/>
  </properties>
</persistence-unit>
</persistence>

JPA entity Employee:

package test;
import javax.persistence.*;

@Entity
public class Employee implements java.io.Serializable {
  private static final long serialVersionUID = 1L;

  @Id @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  @Basic private String name;

  public Long getId() {
      return id;
  }

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

  public String getName() {
      return name;
  }

  public void setName(String name) {
      this.name = name;
  }

  @Override public int hashCode() {
      int hash = 0;
      hash += (id != null ? id.hashCode() : 0);
      return hash;
  }

  @Override public boolean equals(Object object) {
      // TODO: Warning - this method won't work in the case the id fields are not set
      if (!(object instanceof Employee)) {
          return false;
      }
      Employee other = (Employee) object;
      if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
          return false;
      }
      return true;
  }

  @Override public String toString() {
      return "Employee id=" + id + ", name=" + name;
  }
}

No-interface stateless EJB:

package test;
import javax.ejb.Stateless;
import javax.persistence.*;
import javax.annotation.sql.DataSourceDefinition;

@Stateless
@DataSourceDefinition(
          name="java:app/jdbc/test",
          className="com.mysql.jdbc.jdbc2.optional.MysqlDataSource",
          user="root",
          password="root",
          databaseName="test",
          serverName="localhost",
          portNumber=3306 )
public class TestBean {
  @PersistenceContext private EntityManager em;

  public void addEmployee(String[] names) {
      for(String name : names) {
          Employee e = new Employee();
          e.setName(name);
          em.persist(e);
      }
  }
}

main class:

package test;
import javax.ejb.embeddable.EJBContainer;
import javax.naming.*;

public class Client {
  public static void main(String[] args) throws Exception {
      EJBContainer container = EJBContainer.createEJBContainer();
      Context namingContext = container.getContext();
      TestBean testBean = (TestBean) namingContext.lookup("java:global/classes/TestBean");
      testBean.addEmployee(args);  //need to pass in employee names from command line
      container.close();
  }
}

To compile from project directory:

$ javac -cp "classes:$GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar" classes/test/*java

Start mysqld, and run the app:

cd /usr/local/mysql-5.1.32; sudo bin/mysqld_safe --user root
java -cp "classes:$GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar:$HOME/mysql-connector-java-5.1.5-bin.jar" test.Client Jon Jane

Verify entities are successfully created by running mysql:

mysql> select * from EMPLOYEE;
+----+------+
| ID | NAME |
+----+------+
|  1 | Jon  |
|  2 | Jane |
+----+------+
2 rows in set (0.00 sec)

If you are wondering why the jar is named xxx-static-shell.jar, I guess "static" means it's not OSGi bundle, and "shell" means it's a wrapper for all the other GlassFish jars.

A sample glassfish-resources.xml

2011-02-05T09:24:00.009-05:00

A sample glassfish-resources.xml file that defines a global datasource and its underlying jdbc connection pool:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Resource Definitions//EN" "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">
<resources>
<jdbc-connection-pool name="jdbc/test-pool" res-type="javax.sql.DataSource"
datasource-classname="org.apache.derby.jdbc.ClientDataSource"
pool-resize-quantity="1" max-pool-size="5" steady-pool-size="0"
statement-timeout-in-seconds="60" >
   <property name="serverName" value="localhost" />
   <property name="portNumber" value="1527" />
   <property name="dataBaseName" value="sun-appserv-samples" />
   <property name="User" value="APP" />
   <property name="Password" value="APP" />
   <property name="connectionAttributes" value=";create=true" />
   <property name="driverType" value="4" />
 </jdbc-connection-pool>

 <jdbc-resource jndi-name="jdbc/test-ds" pool-name="jdbc/test-pool" />
</resources>

To create the declared jdbc resources with GlassFish asadmin command:

$ asadmin add-resources $HOME/glassfish-resources.xml
Command : JDBC connection pool jdbc/test-pool created successfully.
Command : JDBC resource jdbc/test-ds created successfully.
Command add-resources executed successfully.

To delete both resources:

$ asadmin delete-jdbc-connection-pool
--cascade true jdbc/test-pool
JDBC Connection pool jdbc/test-pool deleted successfully
Command delete-jdbc-connection-pool executed successfully.

To create, delete or list these jdbc resources in a cluster, simply add target option to the asadmin command:

$ asadmin add-resources --target cluster1 $HOME/glassfish-resources.xml
instance1:
Command : JDBC connection pool jdbc/test-pool created successfully.
Command : JDBC resource jdbc/test-ds created successfully.

instance2:
Command : JDBC connection pool jdbc/test-pool created successfully.
Command : JDBC resource jdbc/test-ds created successfully.

Command : JDBC connection pool jdbc/test-pool created successfully.
Command : JDBC resource jdbc/test-ds created successfully.
Command add-resources executed successfully.


$ asadmin list-jdbc-resources cluster1
jdbc/test-ds
Command list-jdbc-resources executed successfully.


$ asadmin list-jdbc-connection-pools cluster1
__TimerPool
DerbyPool
jdbc/test-pool
Command list-jdbc-connection-pools executed successfully.


$ asadmin delete-jdbc-connection-pool --cascade true --target cluster1 jdbc/test-pool
CLI031 Warning: Option "target" is obsolete and will be ignored.
JDBC Connection pool jdbc/test-pool deleted successfully
instance1:
JDBC Connection pool jdbc/test-pool deleted successfully

instance2:
JDBC Connection pool jdbc/test-pool deleted successfully

Command delete-jdbc-connection-pool executed successfully.

You can also create jdbc resources in GlassFish admin console, or via asadmin specifying command-line options. More details are in How to create jdbc connection pool and DataSource in GlassFish

Another usage of glassfish-resources.xml is to include it inside application, e.g., WEB-INF/glassfish-resources.xml for web app, META-INF/glassfish-resources.xml for ejb jar, etc. The declared resources are created upon deployment, and disposed of upon undeployment. More details in GlassFish embedded, JPA, EJB, DataSource and glassfish-resources.xml

Simple webapp with FORM authentication and SSL

2011-01-02T15:03:00.011-05:00

This post is similar to Simple webapp with BASIC authentication, except that this one uses form-based authentication and ssl. The required steps are as follows:

(1) configure roles and other security aspects in web.xml;

(2) administratively create the users in application server;

(3) map the roles declared in step 1 to users created in step 2, with appserver-specific descriptor;

(4) create login form for entering username and password, and error form for displaying after failed login.

This test webapp contains the servlet class, web.xml, sun-web.xml, login.html, and error.html:

TestServlet.java:
--------------------

package test;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class TestServlet extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.println("Hello from " + getServletName());
}

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

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

web.xml:
-----------

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<servlet>
<servlet-name>TestServlet</servlet-name>
<servlet-class>test.TestServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>TestServlet</servlet-name>
<url-pattern>/TestServlet</url-pattern>
</servlet-mapping>

<security-constraint>
<web-resource-collection>
    <web-resource-name>secure</web-resource-name>
    <url-pattern>/TestServlet</url-pattern>
</web-resource-collection>
<auth-constraint>
    <role-name>tester</role-name>
</auth-constraint>
<user-data-constraint>
    <transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
</security-constraint>

<login-config>
<auth-method>FORM</auth-method>
<realm-name>file</realm-name>
<form-login-config>
    <form-login-page>/login.html</form-login-page>
    <form-error-page>/error.html</form-error-page>
</form-login-config>
</login-config>

<security-role>
<role-name>tester</role-name>
</security-role>
</web-app>

sun-web.xml:
----------------

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sun-web-app PUBLIC "-//Sun Microsystems, Inc.//DTD GlassFish Application Server 3.0 Servlet 3.0//EN" "http://www.sun.com/software/appserver/dtds/sun-web-app_3_0-0.dtd">
<sun-web-app>
<security-role-mapping>
<role-name>tester</role-name>
<principal-name>joe</principal-name>
<group-name>user</group-name>
</security-role-mapping>
</sun-web-app>

<html>
<head>
    <title>Login Form</title>
</head>
<body>
    <form method="POST" action="j_security_check" >
        <p>username: <input type="text"  name="j_username" ></p>
        <p>password: <input type="password"  name="j_password" ></p>

        <p>
        <input type="submit" value="Submit" >
        <input type="reset" value="Reset" >
        </p>
    </form>
</body>
</html>

error.html:
-------------

<html>
<head>
    <title>Invalid user name or password</title>
</head>
<body>
    <a href="login.html">Login again</a>
</body>
</html>

To create the user in GlassFish (this is the user name and password that will be entered when running it):

$ $GLASSFISH_HOME/bin/asadmin create-file-user --group user joe

Compile TestServlet class and jar up *.class, *.html and *.xml into a test.war:

WEB-INF/classes/test/TestServlet.class
WEB-INF/sun-web.xml
WEB-INF/web.xml
error.html
login.html

Copy it to $GLASSFISH_HOME/domains/domain1/autodeploy directory to deploy it. To run it go to the url http://localhost:8181/test/TestServlet. After entering the username and password, the following response is displayed:

Hello from TestServlet

If the wrong user name / password is entered, error.html will be displayed with a link to login.html for retry. 8181 is the default ssl port in GlassFish. If you use the non-secure port number 8080 in the test url, GlassFish will automatically redirect to 8181. The browser may display a warning since a self-signed cert (as opposed to one issued by certificate authority) is used to identify the GlassFish server.

Simple webapp with BASIC authentication

2010-12-31T18:01:00.008-05:00

To enable BASIC authentication in a webapp, one needs to
(1) configure roles and other security aspects in web.xml;

(2) administratively create the users in application server; and

(3) map the roles declared in step 1 to users created in step 2, with appserver-specific descriptor.

The following is a simple webapp that only contains 3 files: TestServlet class, web.xml, sun-web.xml.

package test;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class TestServlet extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
   PrintWriter out = response.getWriter();
   out.println("Hello from " + getServletName());
}

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

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

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<servlet>
  <servlet-name>TestServlet</servlet-name>
  <servlet-class>test.TestServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>TestServlet</servlet-name>
  <url-pattern>/TestServlet</url-pattern>
</servlet-mapping>

<security-constraint>
  <web-resource-collection>
      <web-resource-name>secure</web-resource-name>
      <url-pattern>/TestServlet</url-pattern>
  </web-resource-collection>
  <auth-constraint>
      <role-name>tester</role-name>
  </auth-constraint>
</security-constraint>

<login-config>
  <auth-method>BASIC</auth-method>
  <realm-name>file</realm-name>
</login-config>

<security-role>
  <role-name>tester</role-name>
</security-role>
</web-app>


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sun-web-app PUBLIC "-//Sun Microsystems, Inc.//DTD GlassFish Application Server 3.0 Servlet 3.0//EN" "http://www.sun.com/software/appserver/dtds/sun-web-app_3_0-0.dtd">
<sun-web-app>
<security-role-mapping>
 <role-name>tester</role-name>
 <principal-name>joe</principal-name>
 <group-name>user</group-name>
</security-role-mapping>
</sun-web-app>

To create the user in GlassFish:

$ $GLASSFISH_HOME/bin/asadmin create-file-user --group user joe

Compile TestServlet class and jar up *.class and *.xml into a test.war:

WEB-INF/classes/test/TestServlet.class
WEB-INF/sun-web.xml
WEB-INF/web.xml

Copy it to $GLASSFISH_HOME/domains/domain1/autodeploy directory to deploy it. To run it go to the url http://localhost:8080/test/TestServlet. After entering the username and password, the following response is displayed:

Hello from TestServlet

vnc notes on Linux

2010-12-12T17:10:00.009-05:00

To start vncserver: $ vncserver

To stop vncserver: $ vncserver -kill :1

To make the vnc view screen larger, edit /usr/bin/vncserver script:

sudo chmod a+w /usr/bin/vncserver
vim !$

#$geometry = "1024x768";
$geometry = "1500x1050";

A sample $HOME/.vnc/xstartup file:

#!/bin/sh

# Uncomment the following two lines for normal desktop:
unset SESSION_MANAGER
exec /etc/X11/xinit/xinitrc

[ -x /etc/vnc/xstartup ] && exec /etc/vnc/xstartup
[ -r $HOME/.Xresources ] && xrdb $HOME/.Xresources
xsetroot -solid grey
vncconfig -iconic &
xterm -geometry 80x24+10+10 -ls -title "$VNCDESKTOP Desktop" &
twm &

Programmatically bind global JNDI resources

2010-11-05T17:26:00.009-04:00

Starting from Java EE 6, an application can configure JNDI resources in global, application, module, and component namespaces. Usually this is done with @Resource annotations and deployment descriptors. It is also possible to bind global JNDI resources programmatically in a Java EE application, as shown in the following servlet.

package test;

import java.io.*;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import javax.naming.*;
import javax.annotation.*;

@WebServlet(urlPatterns = "/*")
public class TestServlet extends HttpServlet {

  private static final String name = "java:global/env/foo";
  private static final String value = "FOO";

  protected void doPost(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
  PrintWriter out = response.getWriter();

  try {
      InitialContext ic = new InitialContext();
      try {
          Object obj = ic.lookup(name);
          out.println("found " + name + " : " + obj);
      } catch (NamingException ne) {
          ic.rebind(name, value);
          out.println("not found: " + name + ", rebind: " + value);
      }
  } catch (NamingException e) {
      out.println(e);
  }
  }

  @PreDestroy
  private void preDestroy() {
      try {
          InitialContext ic = new InitialContext();
          ic.unbind(name);
          System.out.println("unbound " + name);
      } catch (NamingException e) {
          System.out.println("failed to unbind " + name);
      }
  }

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

Compile TestServlet.java, package it in test.war:WEB-INF/classes/test/TestServlet.class, cp it to $GLASSFISH_HOME/domains/domain1/autodeploy/, and run it at http://localhost:8080/test/

Result from the first run:

not found: java:global/env/foo, rebind: FOO

Result from the subsequent run:

found java:global/env/foo : FOO

You can also verify the global JNDI resource with GlassFish asadmin command:

$ asadmin list-jndi-entries --context java:global/env
foo: java.lang.String

This resource is available server-wide to all deployed apps. It will be removed after test.war is undeployed thanks to TestServlet.preDestroy. To retain it beyond the life of test.war, do not unbind it in TestServlet.preDestroy.

glassfish-application.xml and sun-application.xml examples

2010-10-22T15:48:00.004-04:00

The following glassfish-application.xml and sun-application.xml have the same content. glassfish-application.xml (the new name for sun-application.xml) is the file for specifying additional application (EAR) configuration in GlassFish 3.1.

sun-application.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sun-application PUBLIC "-//Sun Microsystems, Inc.//DTD GlassFish Application Server 3.0 Java EE Application 6.0//EN" "http://www.sun.com/software/appserver/dtds/sun-application_6_0-0.dtd">
<sun-application>
 <web>
   <web-uri>hello.war</web-uri>
   <context-root>hi</context-root>
 </web>
 <security-role-mapping>
   <role-name>admin</role-name>
   <principal-name>js</principal-name>
   <group-name>manager</group-name>
 </security-role-mapping>
</sun-application>

glassfish-application.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE glassfish-application PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Java EE Application 6.0//EN" "http://glassfish.org/dtds/glassfish-application_6_0-1.dtd">
<glassfish-application>
 <web>
   <web-uri>hello.war</web-uri>
   <context-root>hi</context-root>
 </web>
 <security-role-mapping>
   <role-name>admin</role-name>
   <principal-name>js</principal-name>
   <group-name>manager</group-name>
 </security-role-mapping>
</glassfish-application>

glassfish-application-client.xml and sun-application-client.xml examples

2010-10-22T15:27:00.006-04:00

The following glassfish-application-client.xml and sun-application-client.xml have the same content. glassfish-application-client.xml (the new name for sun-application-client.xml) is the file for specifying additional application client (application-client.jar) configuration in GlassFish 3.1.

sun-application-client.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sun-application-client PUBLIC "-//Sun Microsystems, Inc.//DTD GlassFish Application Server 3.0 Application Client 6.0//EN" "http://www.sun.com/software/appserver/dtds/sun-application-client_6_0-0.dtd">
<sun-application-client>
<ejb-ref>
  <ejb-ref-name>ejb/BarBean</ejb-ref-name>
  <jndi-name>java:global/app-name/module-name/FooBean!com.test.xxx.FooRemote</jndi-name>
</ejb-ref>

<resource-ref>
  <res-ref-name>queueConnectionFactory</res-ref-name>
  <jndi-name>jms/QueueConnectionFactory</jndi-name>
  <default-resource-principal>
    <name>guest</name>
    <password>guest</password>
  </default-resource-principal>
</resource-ref>
</sun-application-client>

glassfish-application-client

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE glassfish-application-client PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Java EE Application Client 6.0//EN" "http://glassfish.org/dtds/glassfish-application-client_6_0-1.dtd">
<glassfish-application-client>
<ejb-ref>
  <ejb-ref-name>ejb/BarBean</ejb-ref-name>
  <jndi-name>java:global/app-name/module-name/FooBean!com.test.xxx.FooRemote</jndi-name>
</ejb-ref>

<resource-ref>
  <res-ref-name>queueConnectionFactory</res-ref-name>
  <jndi-name>jms/QueueConnectionFactory</jndi-name>
  <default-resource-principal>
    <name>guest</name>
    <password>guest</password>
  </default-resource-principal>
</resource-ref>
</glassfish-application-client>

glassfish-web.xml and sun-web.xml examples

2010-10-22T14:51:00.006-04:00

The following glassfish-web.xml and sun-web.xml have the same content. glassfish-web.xml (the new name for sun-web.xml) is the file for specifying additional web app (WAR) configuration in GlassFish 3.1.

sun-web.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sun-web-app PUBLIC "-//Sun Microsystems, Inc.//DTD GlassFish Application Server 3.0 Servlet 3.0//EN" "http://www.sun.com/software/appserver/dtds/sun-web-app_3_0-0.dtd">
<sun-web-app>
 <context-root>different-name</context-root>

 <security-role-mapping>
   <role-name>admin</role-name>
   <principal-name>js</principal-name>
   <group-name>manager</group-name>
 </security-role-mapping>

 <ejb-ref>
     <ejb-ref-name>ejb/helloBean</ejb-ref-name>
     <jndi-name>HelloBean</jndi-name>
 </ejb-ref>

 <resource-ref>
     <res-ref-name>jdbc/dataSource</res-ref-name>
     <jndi-name>jdbc/__default</jndi-name>
     <default-resource-principal>
         <name>guest</name>
         <password>guest</password>
     </default-resource-principal>
 </resource-ref>
 <class-loader delegate="true"/>
</sun-web-app>

glassfish-web.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE glassfish-web-app PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Servlet 3.0//EN" "http://glassfish.org/dtds/glassfish-web-app_3_0-1.dtd">
<glassfish-web-app>
 <context-root>different-name</context-root>

 <security-role-mapping>
   <role-name>admin</role-name>
   <principal-name>js</principal-name>
   <group-name>manager</group-name>
 </security-role-mapping>

 <ejb-ref>
     <ejb-ref-name>ejb/helloBean</ejb-ref-name>
     <jndi-name>HelloBean</jndi-name>
 </ejb-ref>

 <resource-ref>
     <res-ref-name>jdbc/dataSource</res-ref-name>
     <jndi-name>jdbc/__default</jndi-name>
     <default-resource-principal>
         <name>myname</name>
         <password>password</password>
     </default-resource-principal>
 </resource-ref>
 <class-loader delegate="true"/>
</glassfish-web-app>

glassfish-ejb-jar.xml and sun-ejb-jar.xml examples

2010-10-22T14:13:00.005-04:00

The following glassfish-ejb-jar.xml and sun-ejb-jar.xml have the same content. glassfish-ejb-jar.xml (the new name for sun-ejb-jar.xml) is the file for specifying additional EJB jar configuration in GlassFish 3.1.

sun-ejb-jar.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sun-ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 EJB 3.0//EN" "http://www.sun.com/software/appserver/dtds/sun-ejb-jar_3_0-0.dtd">
<sun-ejb-jar>
   <enterprise-beans>
   <ejb>
     <ejb-name>FooBean</ejb-name>
     <jndi-name>FooBean</jndi-name>
     <ejb-ref>
       <ejb-ref-name>ejb/BarBean</ejb-ref-name>
       <jndi-name>java:global/app-name/module-name/FooBean!com.test.xxx.FooRemote</jndi-name>
     </ejb-ref>
     <ejb-ref>
       <ejb-ref-name>ejb/BuzBean</ejb-ref-name>
       <jndi-name>corbaname:iiop:1.2@otherserver:3700#BuzBean</jndi-name>
     </ejb-ref>
     <resource-ref>
       <res-ref-name>jdbc/employee</res-ref-name>
       <jndi-name>jdbc/__default</jndi-name>
     </resource-ref>
   </ejb>
   </enterprise-beans>
</sun-ejb-jar>

glassfish-ejb-jar.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE glassfish-ejb-jar PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 EJB 3.1//EN" "http://glassfish.org/dtds/glassfish-ejb-jar_3_1-1.dtd">
<glassfish-ejb-jar>
   <enterprise-beans>
   <ejb>
     <ejb-name>FooBean</ejb-name>
     <jndi-name>FooBean</jndi-name>
     <ejb-ref>
       <ejb-ref-name>ejb/BarBean</ejb-ref-name>
       <jndi-name>java:global/app-name/module-name/FooBean!com.test.xxx.FooRemote</jndi-name>
     </ejb-ref>
     <ejb-ref>
       <ejb-ref-name>ejb/BuzBean</ejb-ref-name>
       <jndi-name>corbaname:iiop:1.2@otherserver:3700#BuzBean</jndi-name>
     </ejb-ref>
     <resource-ref>
       <res-ref-name>jdbc/employee</res-ref-name>
       <jndi-name>jdbc/__default</jndi-name>
     </resource-ref>
   </ejb>
   </enterprise-beans>
</glassfish-ejb-jar>

java -agentlib:jdwp for attaching debugger

2010-09-28T14:03:00.004-04:00

In Java SE 5 or newer, one can use a new standard JVM option to attach a remote debugger. For example,

-agentlib:jdwp=transport=dt_socket,address=localhost:9009,server=y,suspend=y

In Sun JDK 1.4 or earlier, one still uses this old options:

-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=9009

The following is the usage from running this java command:

$ java -agentlib:jdwp=help

            Java Debugger JDWP Agent Library
            --------------------------------

(see http://java.sun.com/products/jpda for more information)

jdwp usage: java -agentlib:jdwp=[help]|[<option>=<value>, ...]

Option Name and Value            Description                       Default
---------------------            -----------                       -------
suspend=y|n                      wait on startup?                  y
transport=<name>                 transport spec                    none
address=<listen/attach address>  transport spec                    ""
server=y|n                       listen for debugger?              n
launch=<command line>            run debugger on event             none
onthrow=<exception name>         debug on throw                    none
onuncaught=y|n                   debug on any uncaught?            n
timeout=<timeout value>          for listen/attach in milliseconds n
mutf8=y|n                        output modified utf-8             n
quiet=y|n                        control over terminal messages    n

Obsolete Options
----------------
strict=y|n
stdalloc=y|n

Examples
--------
- Using sockets connect to a debugger at a specific address:
 java -agentlib:jdwp=transport=dt_socket,address=localhost:8000 ...
- Using sockets listen for a debugger to attach:
 java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y ...

Notes
-----
- A timeout value of 0 (the default) is no timeout.

Warnings
--------
- The older -Xrunjdwp interface can still be used, but will be removed in
 a future release, for example:
     java -Xdebug -Xrunjdwp:[help]|[<option>=<value>, ...]

My subversion svn notes

2010-08-25T10:48:00.045-04:00

Non-comment lines of $HOME/.subversion/config (%APPDATA%\Subversion\config on Windows):

global-ignores = *.ipr *.iml *.iws .project .classpath .settings .*.swp out.txt todo.txt *.save *.my *.class *.org #*# .*.rej *.rej .*~ *~ .#* .DS_Store
enable-auto-props = yes
*.java = svn:eol-style=native;svn:keywords=Date Author Id Revision HeadURL

To view the usage of a subcommand, for example, propedit:

svn help propedit

To view the details of a commit with rev number, including changed files and log messages (Without -v option, changed files are omitted in the output):

svn log -v -c 1234 Foo.java

# shows all changes made by rev 1234 compared to previous rev
svn diff -c 1234 Foo.java

To get, or set end-of-line property (One of 'native', 'LF', 'CR', 'CRLF'):

svn pg      svn:eol-style Utils.java
svn pget    svn:eol-style Utils.java
svn propget svn:eol-style Utils.java

svn propset svn:eol-style LF Utils.java
svn pset    svn:eol-style LF Utils.java
svn ps      svn:eol-style LF Utils.java

To view the svn:externals or svn:ignore for the current directory:

svn propget svn:externals .
svn pg svn:externals .
svn pg svn:ignore .

To delete the svn:ignore for the current directory:

svn pd svn:ignore .

To edit the externals for the current directory:

svn --editor-cmd vim propedit svn:externals .
svn --editor-cmd vim pe svn:externals .

If any one of these environment variables SVN_EDITOR, VISUAL or EDITOR is set, you can omit the "--editor-cmd vim" part:

setenv EDITOR vim (in csh/tcsh)
export EDITOR=vim (in bash)
svn pe svn:externals .

To compare two different versions of a file:

svn diff -r r99:r100 build.xml
svn diff -r 99:100 build.xml
svn diff -c 100

It's easier to copy r99 r100 from svn log output, so I prefer the first form. The option "-c 100" is the same as "-r 99:100", and shows all changes made by rev 100.

To skip any differences in deleted files:

svn diff --no-diff-deleted

svn diff will not included newly added files, or files that are moved to target directory. To view colored diff with vim:

svn diff | view -

I also have a shell script wrapper (diffv) for the above:

#! /bin/sh
svn diff -x -wub $@ | view -
# use -x -wub to ignore whitespace changes

To get detailed info like URL, repository URL, revision, last changed date, etc:

svn info .

To relocate a loca workspace after the server repository has moved:

cd root-of-current-workspace
svn switch --relocate http://old http://new .

To revert all modified files under current directory:

svn revert *
svn revert util/*

Note that "svn revert ." does not revert changes in sub-directories. For recursive revert,

svn revert --depth infinity util
svn revert -R util
svn revert --recursive util

To downgrade svn client version:

cd {to the directory with local changes};
python $HOME/bin/change-svn-wc-format.py . 1.5

The above command will downgrade the working copy format to svn 1.5. This is to fix the annoying svn version error:

svn: This client is too old to work with working copy '...'.  You need
to get a newer Subversion client, or to downgrade this working copy.
See http://subversion.tigris.org/faq.html#working-copy-format-change
for details.

To apply a patch (.diff file), ignoring all parent directories in diff index:

cd {working directory containing the target file}
patch -i $HOME/Desktop/a.diff

To apply a patch (.diff file), preserving all parent directories in diff index:

cd {parent directory of the whole directory structure in diff index}
patch -p0 -i /tmp/a.diff

This is useful when target files do not fall under the same directory. -p means how many levels of directories to prune. patch is a Unix (not svn) command, usually resolves to /usr/bin/patch.

To make directories and parent directories together (the equivalent of mkdir -p),

svn mkdir --parents com/a/b/c

To move some files to another directory (--parents option will make any intermediate directories):

cd <source directory>
svn mv --parents *.java $HOME/my-project-svn/a/b/c

To remove a directory (there is no svn rmdir command),

svn rm a/

To merge some changes from trunk to branch, branch to trunk, or branch 1 to branch 2:

cd <source directory of changes>
svn log . | head -25
copy and paste the start rev and end rev, e.g., r123:r129
svn info; and copy the source URL, e.g., http://host:port/my-project-svn/a/b
cd <dest directory>
svn merge --dry-run -r r123:r129 http://host:port/my-project-svn/a/b

To make real changes, omit --dry-run option.

To merge ALL changes in Foo.java from trunk to branch:

cd <source directory of changes>
svn info Foo.java; and copy the complete source URL, e.g., http://host:port/.../Foo.java
cd <dest directory>
svn merge http://host:port/.../Foo.java ./Foo.java

To merge rev 567 in Foo.java from trunk to branch:

cd <source directory of changes>
svn info Foo.java; and copy the complete source URL, e.g., http://host:port/.../Foo.java
cd <dest directory>
svn merge -c 567 http://host:port/.../Foo.java ./Foo.java

To quickly undo or revert a bad commit (rev 99) with a reverse merge (notice the negative rev number is used. It must be a number; args like -c -r99 is rejected.):

svn merge -c -99 .
svn ci -m 'revert my changes in rev 99.'

String.contains and String.indexOf

2010-07-16T11:14:00.003-04:00

To check if a string contains a substring, I usually use:

if(s.indexOf(sub) >= 0)

For JDK 5 or later, a contains method can also be used, which seems to be a little more readable:

if(s.contains(sub))

The signature of contains method is:

public boolean contains(java.lang.CharSequence s);

Note that CharSequence is a super-interface of String, StringBuffer, StringBuilder, java.nio.CharBuffer, javax.swing.text.Segment. So you can pass any of the 5 types to contains method.

The current implementation of contains method just convert the param to String and calls indexOf.

Java debug options in ant build.xml

2010-07-14T10:00:00.002-04:00

To add debug options to java (Sun's JDK) command line:

-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=9009

If the java process runs and terminates itself, change suspend=y, so you can have a chance to attach the remote debugger.

To add the same debug options to ant build.xml java task:

<target name="run">
 <java fork="on"
       failonerror="true"
       classpath="xxx"
       classname="xxx">
     <jvmarg line="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=9009" />
     <arg line="--arg1 arg2 --arg3 arg4"/>
  </java>
</target>

Note: <arg> and <jvmarg> take either line or value attribute, but value attributes are treated as one single argument that may contain spaces. So in our case line attribute is used to specify multiple arguments separated by spaces. If value attribute was used instead of line attribute, the debug options will not take effect.

Some basic steps using Derby 10.5

2010-07-04T16:18:00.008-04:00

The following is some basic steps of using derby bundled with GlassFish.

1. start derby database server:

$GLASSFISH_HOME/bin/asadmin start-database

or start it on a non-default port number:

$GLASSFISH_HOME/bin/asadmin start-database --dbport 1528

2. make sure environment variable DERBY_HOME is set:

$ echo $DERBY_HOME
/Users/root/v3/glassfish/../javadb

3. start derby ij (or ij.bat), connect to derby server:

$ $DERBY_HOME/bin/ij
ij version 10.5
ij> connect 'jdbc:derby://localhost:1527/sun-appserv-samples;user=APP;password=APP;create=true';

ij> select count(*) COUNT from sys.systables;
COUNT 
-----------
24    

1 row selected

ij> select OWNERID from EJB__TIMER__TBL;
ij> delete from EJB__TIMER__TBL;

ij> show tables;
TABLE_SCHEM |TABLE_NAME           |REMARKS           
-------------------------------------------
SYS         |SYSALIASES            |                               
SYS         |SYSCHECKS             |                               
SYS         |SYSCOLPERMS           |                               
SYS         |SYSCOLUMNS            |                               
SYS         |SYSCONGLOMERATES      |                               
SYS         |SYSCONSTRAINTS        |                               
SYS         |SYSDEPENDS            |                               
SYS         |SYSFILES              |                               
SYS         |SYSFOREIGNKEYS        |                               
SYS         |SYSKEYS               |                               
SYS         |SYSROLES              |                               
SYS         |SYSROUTINEPERMS       |                               
SYS         |SYSSCHEMAS            |                               
SYS         |SYSSTATEMENTS         |                               
SYS         |SYSSTATISTICS         |                               
SYS         |SYSTABLEPERMS         |                               
SYS         |SYSTABLES             |                               
SYS         |SYSTRIGGERS           |                               
SYS         |SYSVIEWS              |                               
SYSIBM      |SYSDUMMY1             |                               
APP         |LEAGUE                |                               
APP         |PLAYER                |                               
APP         |TEAM                  |                               
APP         |TEAMPLAYER            |                               

24 rows selected

ij> describe player;
COLUMN_NAME         |TYPE_NAME|DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL&
------------------------------------------------------------------------------
PLAYER_ID           |VARCHAR  |NULL|NULL|255   |NULL      |510       |NO 
NAME                |VARCHAR  |NULL|NULL|255   |NULL      |510       |YES
POSITION            |VARCHAR  |NULL|NULL|255   |NULL      |510       |YES
SALARY              |DOUBLE   |NULL|2   |52    |NULL      |NULL      |NO 

4 rows selected

ij> CREATE TABLE FOO (FOO_ID BIGINT, FOO_NAME VARCHAR(25), DESCRIPTION VARCHAR(64));
0 rows inserted/updated/deleted

ij> insert into foo values(1, 'foo1', 'foo1, that is.');
1 row inserted/updated/deleted

ij> select * from foo;
FOO_ID              |FOO_NAME                 |DESCRIPTION                                                
---------------------------------------------------------------------------------------------------------------
1                   |foo1                     |foo1, that is.                                             

1 row selected

ij> update foo set foo_name='foo1 new name' where foo_id=1;
1 row inserted/updated/deleted

ij> delete from foo where foo_id=1;
1 row inserted/updated/deleted

ij> select count(*) count from foo;
COUNT 
-----------
0     

1 row selected

ij> drop table foo;
0 rows inserted/updated/deleted

To start ij and connect to a database in single step:

java -classpath $GLASSFISH_HOME/../javadb/lib/derbyrun.jar -Dij.connection.sample="jdbc:derby://localhost:1527/sun-appserv-samples;user=APP;password=APP;create=true" org.apache.derby.tools.ij

When starting derby with GlassFish "asadmin start-database" command, the default host is localhost, the default port number is 1527, and the default derby system home is set to $GLASSFISH_HOME/databases. This is also the directory where derby.log and database files will be stored. To overwrite the defaults with the following options:

asadmin start-database --dbhost dell-01 --dbport 3333 --terse=true --dbhome $HOME/derby

A sample web.xml (servlet 3.0) with ejb-ref and ejb-local-ref

2010-07-04T14:44:00.002-04:00

This is a sample web.xml based on servlet 3.0 (part of Java EE 6).

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
      version="3.0"> 
      
  <servlet>
   <display-name>Servlet1</display-name>
   <servlet-name>Servlet1</servlet-name>
   <servlet-class>test.Servlet1</servlet-class>
   <init-param>
     <param-name>sleep-time-in-seconds</param-name>
     <param-value>10</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
   <servlet-name>Servlet1</servlet-name>
   <url-pattern>/Servlet1</url-pattern>
 </servlet-mapping>
 
  <ejb-ref>
    <ejb-ref-name>ejb/fooremote</ejb-ref-name>
    <ejb-ref-type>Session</ejb-ref-type>
    <remote>test.FooRemoteIF</remote>
  </ejb-ref>
  
  <ejb-local-ref>
    <ejb-ref-name>ejb/foo</ejb-ref-name>
    <ejb-ref-type>Session</ejb-ref-type>
    <local>test.FooIF</local>
    <ejb-link>FooBean</ejb-link>
  </ejb-local-ref>
</web-app>

GlassFish rotate-log

2010-06-25T10:10:00.006-04:00

GlassFish has a command to rotate or reset server.log file:

$GLASSFISH_HOME/bin/asadmin rotate-log

After running this command the logs directory looks like this:

/glassfish-3.1/glassfish/domains/domain1/logs > ll
total 200
-rw-r--r--  1 root      0 Jun 25 10:11 server.log
-rw-r--r--  1 root  10780 Jun 25 10:11 server.log_2010-06-25T10-09-48
-rw-r--r--  1 root  16384 Jun 25 10:10 jvm.log
drwxr-xr-x  3 root    102 Jun 25 10:02 server/

This command renames server.log file to a timestamped backup file, and leaves the current server.log file empty. I usually run this command before starting a test run to make sure the current server.log only contains logs from this test run.

For convenience, I also have an alias for it (in tcsh syntax):

alias rlog '$GLASSFISH_HOME/bin/asadmin rotate-log'

For more details, see official docs, or view the online help:

$GLASSFISH_HOME/bin/asadmin rotate-log --help

Double click in NetBeans 6.5 & 6.8 editor

2010-05-24T11:42:00.004-04:00

NetBeans 6.x editors handle double-click differently from other applications. In firefox, thunderbird, eclipse, or even terminal, I can doulble-click anywhere in a word to select the whole word, keep the mouse button pressed, and slide forward to expand the selection.

In NetBeans, doing the same will drag the selected word, just like moving the word elsewhere. While it seems cool to be able to drag-and-drop, I don't see any practical value. In java editor, I always avoid drag-and-drop anything, since the selected element often lands in the wrong place when your mouse/pad reaches its end.

Update: It has been fixed in NetBeans 7.1 according to this bug. I installed 7.1 beta just to get this fix.

Example of EJB 3.1 Stateful Session Bean and Servlet

2010-05-06T11:22:00.007-04:00

Stateful session bean class:

package test;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import javax.ejb.PostActivate;
import javax.ejb.PrePassivate;
import javax.ejb.Stateful;
import javax.ejb.StatefulTimeout;

@Stateful
@StatefulTimeout(unit = TimeUnit.MINUTES, value = 30)
public class StatefulTestBean {
 private static final Logger logger = Logger.getLogger("test");

 private String clientInfo;

 @SuppressWarnings("unused")
 @PrePassivate
 private void prePassivate() {
     logger.info("In PrePassivate method");
 }

 @SuppressWarnings("unused")
 @PostActivate
 private void postActivate() {
     logger.info("In PostActivate method");
 }

 public String getBeanInfo() {
     return this.toString();
 }

 public String getClientInfo() {
     return clientInfo;
 }

 public void setClientInfo(String clientInfo) {
     this.clientInfo = clientInfo;
 }
}

Servlet class:

package test;
import java.io.IOException;
import java.io.PrintWriter;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet(urlPatterns = "/TestServlet")
public class TestServlet extends HttpServlet {
 private static final String STATEFUL_TEST_BEAN_KEY = "STATEFUL_TEST_BEAN_KEY";

 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException {
     PrintWriter writer = response.getWriter();
     StatefulTestBean statefulTestBean = getStatefulTestBean(request);
     writer.println("clientInfo: " + statefulTestBean.getClientInfo());
     writer.println("beanInfo:   " + statefulTestBean.getBeanInfo());
 }

 private StatefulTestBean getStatefulTestBean(HttpServletRequest request)
         throws ServletException {
     HttpSession httpSession = request.getSession(true);
     StatefulTestBean statefulTestBean = (StatefulTestBean)
             httpSession.getAttribute(STATEFUL_TEST_BEAN_KEY);
     if (statefulTestBean == null) {
         try {
             InitialContext ic = new InitialContext();
             statefulTestBean = (StatefulTestBean) ic.lookup("java:module/StatefulTestBean");
             httpSession.setAttribute(STATEFUL_TEST_BEAN_KEY, statefulTestBean);
          
             String userAgent = request.getHeader("User-Agent");
             String userName  = request.getParameter("userName");
             statefulTestBean.setClientInfo(userAgent + ", " + userName);
         } catch (NamingException e) {
             throw new ServletException(e);
         }
     }
     return statefulTestBean;
 }
}

To compile the above 2 classes:

javac -cp "$GLASSFISH_HOME/modules/*" TestServlet.java StatefulTestBean.java

Copy *.class files under a WEB-INF directory, and package the above 2 classes into a WAR file, stateful.war, that contains the following:

WEB-INF/classes/test/StatefulTestBean.class
WEB-INF/classes/test/TestServlet.class

To deploy it, copy stateful.war to appserver autodeploy directory.

I did the following to test the stateful session behavior:

1, open the following url in firefox:
http://localhost:8080/stateful/TestServlet?userName=nobody

will get the following response:
clientInfo: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3, nobody
beanInfo: test._StatefulTestBean_Serializable@3af78ba5

2, In the same firefox window, enter url without userName:
http://localhost:8080/stateful/TestServlet

will still get the same response, since the second request share the same http session and stateful session bean with the first request.

3, Open a new firefox window and repeat step 2, will still get the same response, since the http session is tied to the firefox browser.

4, Open a chrome window and repeat step 2, will get a different response due to a new http session and new stateful session bean instance were created.

Since both http sessin and stateful session bean are used to manage user session, their timeout value should be in kept in sync.

This app is programmed to JavaEE 6 and EJB 3.1, using some new features such as @StatefulTimeout and a portable module-scope jndi name. I've tested with GlassFish 3.0, and it should also work, without any modification, in any JavaEE-6-compliant appserver. To run with JavaEE 5 appserver, some minor modifications are needed.

The stateful bean reference is looked up, instead of using field injection. This is necessary to keep it thread safe and avoid being accessed by different users.

restart-domain in GlassFish

2010-04-26T21:53:00.004-04:00

Restarting an appserver is a common operation after manually editing server config, or adding new library jars, or just to be safe. I hava an alias to restart GlassFish, and all it does is: stop domain, sleep 3 seconds, and start domain.

In GlassFish v3, this can be done with a single asadmin command: restart-domain.

First, I tried restart-domain while the server is not running, which is equivalent to start-domain command:

./asadmin restart-domain
Server is not running, will attempt to start it...
Waiting for DAS to start .....................
Started domain: domain1
Domain location: /v3/glassfish/domains/domain1
Log file: /v3/glassfish/domains/domain1/logs/server.log
Admin port for the domain: 4848
Command restart-domain executed successfully.

Then, try it while the server is running. This command takes a few seconds to finish since it involves stopping the domain first, possibly pausing a bit, and then starting the domain:

./asadmin restart-domain
Successfully restarted the domain
Command restart-domain executed successfully.

Example of EJB Interceptor class

2010-04-21T22:03:00.006-04:00

EJB 3.x interceptor class can contain either EJB lifecycle callback methods (e.g., @PostConstruct, @PreDestroy, @PrePassivate, @PostActivate), or business interceptor methods (i.e., @AroundInvoke), or any combination of these methods. The following is a simple example of EJB interceptor class:

package test;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.PrePassivate;
import javax.ejb.PostActivate;
import javax.interceptor.AroundInvoke;
import javax.interceptor.InvocationContext;

public class Interceptor1 {
   @PostConstruct
   protected void myPostConstruct(InvocationContext ctx) {

   }

   @PreDestroy 
   protected void myPreDestroy(InvocationContext ctx) {

   }
   
   @PostActivate
   private void postActivate(InvocationContext ctx) {

   }

   @PrePassivate
   private void prePassivate(InvocationContext ctx) {

   }

   @AroundInvoke
   public Object businessIntercept(InvocationContext ctx) 
       throws Exception {
       Object result = null;
       try {
           // PreInvoke: do something before handing control to the next in chain
           result = ctx.proceed();
           return result;
       } finally {
           // PostInvoke: do something (cleanup, etc) after the main processing is done
       }
   }
}

The interceptor class is attached to EJB bean class (or business method in EJB bean class) with @Interceptors annotation, or specified in ejb-jar.xml.

@Resource.lookup and classpath

2010-04-20T17:26:00.005-04:00

JavaEE 6 added a new lookup attribute to @javax.annotation.Resource. So one can inject resources like this:

@Resource(lookup = "java:module/env/rate")
private String rate;

Compile the classes:

javac -cp "$GLASSFISH_HOME/modules/*" *Bean.java

EmailBean.java:18: cannot find symbol
symbol  : method lookup()
location: @interface javax.annotation.Resource
   @Resource(lookup = "java:module/env/rate")
             ^
1 error

In GlassFish, all JavaEE classes are in various jars under $GLASSFISH_HOME/modules and its subdirectories. It failed because version 1.0 of javax.annotation.Resource class (and other javax.annotation.* classes) are included in Java SE 6. The use of lookup attribute requires version 1.1 of Common Annotation jar, which is included in JavaEE 6.

To fix it, simply add a -Djava.endorsed.dirs sysprop to override those classes in Java SE 6:

javac -cp "$GLASSFISH_HOME/modules/*" -Djava.endorsed.dirs=$GLASSFISH_HOME/modules/endorsed  *Bean.java

In Eclipse IDE, you just need to put $GLASSFISH_HOME/modules/endorsed/javax.annotation.jar before JRE System Library when configuring Java Build Path.

This should also work with any compliant appserver, though actual jar name and location may vary. The same -Djava.endorsed.dirs sysprop should also be used when running the app.

2 @ManagedBean in JavaEE 6

2010-04-19T13:45:00.003-04:00

There are 2 @ManagedBean annotations in JavaEE 6:

javax.annotation.ManagedBean (javadoc)
javax.faces.bean.ManagedBean (javadoc)

Looks like we are running out of names.

Env-entry enhancement in JavaEE 6

2010-04-17T09:52:00.005-04:00

JavaEE 6 adds 2 additional types to the list of env-entry types: java.lang.Class and any enum type. So there are now 11 portable env-entry types that must be supported by all compliant application servers:

       java.lang.Class
      any enum type
      java.lang.Boolean
      java.lang.Byte
      java.lang.Character
      java.lang.String
      java.lang.Short
      java.lang.Integer
      java.lang.Long
      java.lang.Float
      java.lang.Double

For example, to use java.lang.Class and enum env-entry-type in a web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<env-entry>
<description>example of java.lang.Class env-entry-type</description>
<env-entry-name>java:app/env/myImplClass</env-entry-name>
<env-entry-type>java.lang.Class</env-entry-type>
<env-entry-value>test.MyServiceProvider</env-entry-value>
</env-entry>

<env-entry>
<description>example of enum env-entry-type</description>
<env-entry-name>java:app/env/day</env-entry-name>
<env-entry-type>com.examplexxx.util.Day</env-entry-type>
<env-entry-value>SUNDAY</env-entry-value>
</env-entry>
</web-app>

To inject the above 2 env-entry into fields in a servlet, or EJB bean class, or any other components in the EAR:

@Resource(lookup="java:app/env/myImplClass")
@SuppressWarnings("unchecked")
private Class myImplClass;

@Resource(lookup="java:app/env/day")
private com.examplexxx.util.Day day;

For java.lang.Class type, only the raw type, not the generic type, can be declared as the field type, hence @SuppressWarnings("unchecked").

DataSourceDefinition Examples in JavaEE 6

2010-04-16T09:34:00.006-04:00

The usual way to create a DataSource is through the appserver's administration, CLI or GUI tool. Then applications can declare resource-ref mapped to the DataSource. This involves both application developer and server administrator, and sometimes can be too much for simple apps. JavaEE 6 added 2 annotations to ease this task: javax.annotation.sql.DataSourceDefinition and javax.annotation.sql.DataSourceDefinitions.

With the 2 annotations, applications can take control of DataSource creation, and choose to expose the DataSource in various scopes: component-, module-, application, and global-scope. For simple apps, all this can be done without any server configuration or XML descriptors.

Example 1: a servlet declares how to create a derby DataSource, and injects a reference to this DataSource into a field. This DataSource is scoped to the whole module (the entire webapp).

@DataSourceDefinition(name="java:module/env/inventory",
   className="org.apache.derby.jdbc.ClientDataSource",
      portNumber=1527,
      serverName="localhost",
      databaseName="inventory",
      user="user1",
      password="password1")
@WebServlet(urlPatterns = "/InventoryServlet")
public class InventoryServlet extends HttpServlet {
  @Resource(lookup="java:module/env/inventory")
  private DataSource inventoryds;

Example 2: a Stateless session bean creates an application-scope Oracle DataSource, and injects its resource-ref. This DataSource is visible to the entire application (EAR).

@DataSourceDefinition(name="java:app/env/inventory",
      className="oracle.jdbc.pool.OracleDataSource",
      portNumber=1521,
      serverName="localhost",
      databaseName="inventory",
      user="user1",
      password="password1",
      properties={"driverType=thin"}
)
@Stateless
public class InventoryBean {
  @Resource(lookup="java:app/env/inventory")
  private DataSource inventoryds;

For more details, see JavaEE 6 javadoc page for @DataSourceDefinition

Message Driven Bean Example with Servlet Client

2010-04-14T17:31:00.008-04:00

This is a simple example of JMS Queue message-driven bean (MDB), with a servlet client. MessageServlet sends a text message to the queue that the MDB is bound to, the MDB then consumes the incoming message. This example requires EJB 3.1 and Servlet 3.0, both are in Java EE 6.

First, the MDB class:

package test;

import java.util.logging.Logger;
import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;

@MessageDriven(mappedName="testQueue2",
     activationConfig = { @ActivationConfigProperty(
     propertyName="destinationType", propertyValue="javax.jms.Queue")})
public class MessageBean implements MessageListener {
 Logger logger = Logger.getLogger("test");

 public void onMessage(Message msg) {
     try {
         String name = msg.getStringProperty("name");
         logger.info("Received msg " + msg + ", from " + name);
     } catch (JMSException e) {
         throw new RuntimeException(e);
     }
 }
}

The servlet class:

package test;

import java.io.IOException;
import javax.annotation.Resource;
import javax.jms.*;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;

@WebServlet(urlPatterns = "/MessageServlet")
public class MessageServlet extends HttpServlet {
 @Resource(mappedName = "testQueue2")
 private Queue queue;

 @Resource(mappedName = "jms/QueueConnectionFactory")
 private QueueConnectionFactory queueConnectionFactory;

 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException {
     QueueConnection queueConnection = null;
     try {
         queueConnection = queueConnectionFactory.createQueueConnection();
         queueConnection.start();
         QueueSession queueSession = queueConnection.createQueueSession(false,
                 Session.AUTO_ACKNOWLEDGE);
         QueueSender sender = queueSession.createSender(queue);

         TextMessage msg = queueSession.createTextMessage();
         msg.setText("A message from MessageServlet");
         msg.setStringProperty("name", "MessageServlet");

         sender.send(msg);
     } catch (JMSException e) {
         throw new RuntimeException(e);
     } finally {
         try {
             if (queueConnection != null) {
                 queueConnection.close();
             }
         } catch (JMSException e) { //ignore
         }
     }
 }
}

After compiling, package the two classes into a WAR file, say, mdb.war:

WEB-INF/classes/test/MessageBean.class
WEB-INF/classes/test/MessageServlet.class

Create the 2 JMS resources (testQueue2 & jms/QueueConnectionFactory) in the target application server. In GlassFish, you can do it in Admin GUI, or via asadmin CLI:

./asadmin create-jms-resource --restype javax.jms.Queue testQueue2
./asadmin create-jms-resource --restype javax.jms.QueueConnectionFactory jms/QueueConnectionFactory

Deploy mdb.war by copying it to server autodeploy directory.

Enter the URL in browser to invoke the servlet:
http://localhost:8080/mdb/MessageServlet

You will see the following log in server.log as a result of MDB processing:

[#|2010-04-14T17:28:49.900-0400|INFO|glassfishv3.0|test|_ThreadID=31;_ThreadName=Thread-1;|Received msg com.sun.messaging.jms.ra.DirectTextPacket@3ce177de, from MessageServlet|#]

GlassFish set-web-env-entry

2010-04-08T14:46:00.007-04:00

env-entry elements can be used to configure a webapp without recompiling. Usually one still needs to update them in web.xml, and redeploy the WAR for the new config to take effect. I just noticed GlassFish v3 now supports in-place, dynamic updating web env-entry via its powerful asadmin command. I guess it can also be done in GlassFish admin GUI.

1, download a sample webapp, hello.war, from GlassFish web site, to $GLASSFISH_HOME/domains/domain1/autodeploy/ directory:

wget https://glassfish.dev.java.net/downloads/quickstart/hello.war

2, verify hello.war has been successfully deployed:

cd $GLASSFISH_HOME/bin
./asadmin list-components

./asadmin set-web-env-entry --name=contact-email --value=info@examplexxx.com --type=java.lang.String hello
./asadmin set-web-env-entry --name=debug --value=true --type=java.lang.Boolean hello

4, verify the 2 new env-entry elements:

./asadmin list-web-env-entry hello
Reported 2 env-entry settings

contact-email (java.lang.String) = info@examplexxx.com ignoreDescriptorItem=false //(description not specified)
debug (java.lang.Boolean) = true ignoreDescriptorItem=false //(description not specified)

You can also verify them by viewing $GLASSFISH_HOME/domains/domain1/domain.xml:

<application context-root="/hello" location="${com.sun.aas.instanceRootURI}/applications/hello/" name="hello" object-type="user">
<property name="defaultAppName" value="hello" />
<module name="hello">
  <engine sniffer="security" />
  <engine sniffer="web">
    <web-module-config>
      <env-entry>
        <env-entry-type>java.lang.String</env-entry-type>
        <env-entry-value>info@examplexxx.com</env-entry-value>
        <env-entry-name>contact-email</env-entry-name>
      </env-entry>
      <env-entry>
        <env-entry-type>java.lang.Boolean</env-entry-type>
        <env-entry-value>true</env-entry-value>
        <env-entry-name>debug</env-entry-name>
      </env-entry>
    </web-module-config>
  </engine>
</module>
</application>

To learn more about set-web-env-entry subcommand, try one of the following:

./asadmin help set-web-env-entry
./asadmin set-web-env-entry --help

To list and unset env-entry, use the following asadmin commands:


list-web-env-entry
unset-web-env-entry

The same feature also exists for web context-param, via the following commands:


list-web-context-param
set-web-context-param
unset-web-context-param

EJB 3.1 Timer Simple Example

2010-04-01T11:30:00.012-04:00

This is a simple webapp that polls a web site to check if a product is available. It uses a stateless session bean and calendar-based timer.

package test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URL;
import java.util.logging.Logger;

import javax.ejb.Schedule;
import javax.ejb.Stateless;

@Stateless
public class InventoryCheckBean {
  private static final String PRODUCT_URL = "http://www.amazon.com/dp/B002BSA298/";
  private static final String IN_STOCK = "In Stock";

  @SuppressWarnings("unused")
  @Schedule(dayOfWeek = "0-5", hour = "0/2", minute = "0/20", timezone = "America/Los_Angeles")
  private void checkInventory() {
      BufferedReader br = null;
      try {
          String line = null;
          URL url = new URI(PRODUCT_URL).toURL();
          br = new BufferedReader(new InputStreamReader(url.openStream()));
          while ((line = br.readLine()) != null) {
              if(line.indexOf(IN_STOCK) >= 0) {
                  //email notify
                  Logger.getLogger("").info(line);
                  break;
              }
          }
      } catch (Exception e) {
          throw new RuntimeException(e);
      } finally {
          if(br != null) {
              try {
                  br.close();
              } catch (IOException e) { //ignore
              }
          }
      }
  }
}

After compiling, simply package test/InventoryCheckBean.class into a WAR file under WEB-INF/classes. No other files are needed.

/tmp > jar tf $owd/inventory.war
META-INF/
META-INF/MANIFEST.MF
WEB-INF/
WEB-INF/classes/
WEB-INF/classes/test/
WEB-INF/classes/test/InventoryCheckBean.class

Deploy this war to any application server that is Java EE 6 compliant. The timer is activated upon successful deployment, and starts to check the specified site at the specified intervals. This is so-called automatic timer.

In the server log file, you will notice these logs:

[#|2010-04-01T10:50:01.644-0400|INFO|glassfishv3.0||_ThreadID=26;_ThreadName=Thread-1;|<span class="availGreen">In Stock.</span><br/ > Ships from and sold by <b>Amazon.com</b>. Gift-wrap available.|#]

Note:
(1) This WAR file contains only an EJB bean class.

(2) There is no business method in this EJB; only 1 private timer method, which is only invoked by the container after deployment. So @SuppressWarnings is used to mute any warnings that this method is never used.

(3) No client action is needed. Right after deployment, the timer is activated and starts the processing specified in the timer method.

(4) timezone is optionals and defaults to that of the hosting machine.

(5) This timer goes off every 20 minutes of every other hour starting from 0 o'clock from Sunday to Friday, and the time is based on America/Los_Angeles timezone.

Update on 3/4/2011, I deployed the same inventory.war to JBoss AS 6.0, by copying it to $JBOSS_HOME/server/default/deploy, it also worked. No need to change anything.

Simple Asynchronous methods in EJB 3.1

2010-03-17T11:19:00.010-04:00

EJB 3.1 introduced a simple mechanism for asynchronous invocation. This post presents such an example with a Singleton session bean and its JUnit test case. 2 styles of asynchronous EJB invocations are used:

(1) fire-and-forget asynchronous methods having void return type.

(2) retrieve-result-later asynchronous methods having Future<?> return type.

package test;

import java.util.concurrent.Future;
import javax.ejb.Asynchronous;
import javax.ejb.AsyncResult;
import javax.ejb.Singleton;

@Singleton
@Asynchronous
public class AsyncBean {
    @Asynchronous  //this line can be omitted
    public void ignoreResult(int a, int b) {
        // the client doesn't care what happens here
    }

    @Asynchronous  //this line can be omitted
    public Future<Integer> longProcessing(int a, int b) {
        return new AsyncResult<Integer>(a * b);
    }
}

Since the class is annotated with @Asynchronous, all business methods are asynchronous. The method-level @Asynchronous is therefore redundant, and kept there for illustration purpose.

package test;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;
import junit.framework.TestCase;

public class AsyncBeanTest extends TestCase {
    private EJBContainer container;
    private Context namingContext;
    private AsyncBean asyncBean;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        container = EJBContainer.createEJBContainer();
        namingContext = container.getContext();
        asyncBean = (AsyncBean) namingContext.lookup("java:global/testApp/AsyncBean");
    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        container.close();
    }

    public final void testIgnoreResult() {
        asyncBean.ignoreResult(0, 0); // fire and forget
        System.out.println("Proceed without waiting for the async method result.");
    }

    public final void testLongProcessing() throws InterruptedException, ExecutionException {
        Future<Integer> futureResult = asyncBean.longProcessing(8, 9);
        System.out.println("Proceed to other tasks and check async method result later.");
        Integer intResult = futureResult.get();
        System.out.println("The prior async method returned " + intResult);
    }
}

I've tested this example with GlassFish V3 in its embedded mode. It should work with any Java EE 6 application servers as well. The configureation (classpath, outputDir, etc) and how to run it are the same as EJB Lite testing with JUnit and embeddable container.

How to trim ant property string value

2010-03-10T17:03:00.005-05:00

When writing ant build files, I often need to trim the string value of an ant property. But I couldn't find a simple task to do that. So I wrote the following ant macrodef for this purpose. In short, it saves the property value into a temp file, trims lines while moving the file, and loads the file back into a new property.

<?xml version="1.0" encoding="UTF-8"?>
<project basedir="." default="trim" name="test">
 <target name="trim">
   <trim input="${text}" property="text.trimmed" />
   <echo message="original text='${text}'" />
   <echo message="trimmed  text='${text.trimmed}'" />
 </target>

 <macrodef name="trim">
   <attribute name="input" />
   <attribute name="property" />
   <sequential>
     <tempfile property="temp.file" />
     <echo file="${temp.file}" message="@{input}" />
     <move file="${temp.file}" tofile="${temp.file}.2">
       <filterchain>
         <trim/>
       </filterchain>
     </move>
     <loadfile property="@{property}" srcFile="${temp.file}.2" />
     <delete file="${temp.file}.2" failonerror="false" />
   </sequential>
 </macrodef>

</project>

To run this target:

/tmp > ant -Dtext=' a b c '
Buildfile: build.xml

trim:
    [move] Moving 1 file to /tmp
  [delete] Deleting: /tmp/null1355243589.2
    [echo] original text=' a b c '
    [echo] trimmed  text='a b c'

BUILD SUCCESSFUL
Total time: 0 seconds

The ant macro named trim declares the trim operation, while the trim target shows an example of calling the trim macro.

There are other solutions to achive the same result, e.g., write a custom ant task, or use ant-contrib tasks. But the advantage of this sample is that it only uses built-in ant tasks and no other library jars are needed.

Portable JNDI names in EJB 3.1

2009-12-16T13:17:00.015-05:00

Java EE 6 made some efforts to standardize JNDI names at global,application, and module levels. Now EJB deployed to EJB-3.1-capable server will have various standard JNDI names registered. EJB 3.1 spec defines the following 3 levels of JNDI names for EJB:

Global JNDI name:

java:global[/<app-name>]/<module-name>/<bean-name>[!<fully-quali-fied-interface-name>]

Application-scope JNDI name:

java:app/<module-name>/<bean-name>[!<fully-qualified-interface-name>]

Module-scope JNDI name:

java:module/<bean-name>[!<fully-qualified-interface-name>]

The following exampels shows various EJB JNDI names, depending upon how the EJB is packaged, its business interface(s), and bean class:

Bean class: test.TestBean
business interface: none

How the EJB is packaged	Global JNDI names	Application-scope JND names	Module-scope JNDI names
in testEJB.jar inside testApp.ear	java:global/testApp/testEJB/TestBean java:global/testApp/testEJB/TestBean!test.TestBean	java:app/testEJB/TestBean java:app/testEJB/TestBean!test.TestBean	java:module/TestBean java:module/TestBean!test.TestBean
in testWeb.war	java:global/testWeb/TestBean java:global/testWeb/TestBean!test.TestBean	java:app/testWeb/TestBean java:app/testWeb/TestBean!test.TestBean	java:module/TestBean java:module/TestBean!test.TestBean
in testEJB.jar	java:global/testEJB/TestBean java:global/testEJB/TestBean!test.TestBean	java:app/testEJB/TestBean java:app/testEJB/TestBean!test.TestBean	java:module/TestBean java:module/TestBean!test.TestBean

EJB Lite testing with JUnit and embeddable container

2009-12-10T13:11:00.014-05:00

In EJB 3.1, one can unit-test EJB using standadard EJB API, JUnit, and outside any application server. This is how I created an Eclipse java project to unit-test a simple EJB with GlassFish v3.

1. inside Eclipse, create a new java project, named ejblite.

Build path: $GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar $GLASSFISH_HOME/modules/javax.ejb.jar

Output dir: testApp (it is used in global jndi name in the test)

2. create a new java class named TestBean:

package test;

import javax.ejb.Stateless;

@Stateless
public class TestBean {
public int add(int a, int b) {
   return a + b;
}

public int multiply(int a, int b) {
   return a * b;
}
}

3. select TestBean.java in the package panel, create a new JUnit Test Case (File -> New -> JUnit Test Case). Choose TestBean as the test target, and the test method for both business methods (add and multiply) will be generated, along with setUp and tearDown.

4. modify the test case:

package test;

import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;

import junit.framework.TestCase;

public class TestBeanTest extends TestCase {
private EJBContainer container;
private Context namingContext;
private TestBean testBean;

@Override
protected void setUp() throws Exception {
   super.setUp();
   container = EJBContainer.createEJBContainer();
   namingContext = container.getContext();
   testBean = (TestBean) namingContext.lookup("java:global/testApp/TestBean");
}

@Override
protected void tearDown() throws Exception {
   super.tearDown();
   namingContext.close();
   container.close();
}

/**
* Test method for {@link test.TestBean#add(int, int)}.
*/
public final void testAdd() {
   int a = 1, b = 2, expected = a + b;
   assertEquals(expected, testBean.add(a, b));
}

/**
* Test method for {@link test.TestBean#multiply(int, int)}.
*/
public final void testMultiply() {
   int a = 1, b = 2, expected = a * b;
   assertEquals(expected, testBean.multiply(a, b));
}

}

5. select TestBeanTest class, and run it as JUnit test.

Our EJB classes all reside under testApp directory (the output dir of the current project), and testApp is also used as the module-name for the current EJB app. If you choose to use a different output dir value, you will also need to change the global jndi-name accordingly.

If you are interested in using DataSource and JPA in EJB embeddable, check out EJB lite, JPA, DataSource embedded in java application.

A sample EJB 3.1 Lite client

2009-12-08T15:50:00.008-05:00

EJB Lite is a lightweight subset of EJB 3.1, including the support for running EJB container embedded in the current java application. So one can run EJB without appserver. The following sample contains a no-interface stateless EJB, and a java application that looks up and invokes the EJB.

1. project structure:

mkdir -p ejblite/src/test
mkdir -p ejblite/testApp

2. go to ejblite/src/test, and edit 2 java files:

-------------
TestBean.java
-------------

package test;
import javax.ejb.Stateless;

@Stateless
public class TestBean {
  public String hello(String name) {
      return "Hello, " + name;
  } 
}

-----------
Client.java
-----------

package test;

import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;
import javax.naming.NamingException;

public class Client {
  public static void main(String args[]) throws NamingException {
        EJBContainer container = null;
        try {
            container = EJBContainer.createEJBContainer();
            Context namingContext = container.getContext();
            TestBean testBean = (TestBean) namingContext.lookup(
                    "java:global/testApp/TestBean");
            String hi = testBean.hello("client");
            System.out.println("testBean.hello method returned: " + hi);
        } finally {
            if(container != null) {
                container.close();
            }
        }
  }
}

3. compile and run from src/test directory, using GlassFish v3:

javac -d ../../testApp/ -cp $GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar:../../classes Client.java TestBean.java

java -cp $GLASSFISH_HOME/lib/embedded/glassfish-embedded-static-shell.jar:../../testApp test.Client

You will see the following output, when running with GlassFish v3:

Dec 8, 2009 3:47:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: GlassFish v3 (74.2) startup time : Embedded(1246ms) startup services(511ms) total(1757ms)
Dec 8, 2009 3:47:45 PM org.glassfish.admin.mbeanserver.JMXStartupService$JMXConnectorsStarterThread run
INFO: JMXStartupService: JMXConnector system is disabled, skipping.
Dec 8, 2009 3:47:46 PM com.sun.enterprise.transaction.JavaEETransactionManagerSimplified initDelegates
INFO: Using com.sun.enterprise.transaction.jts.JavaEETransactionManagerJTSDelegate as the delegate
Dec 8, 2009 3:47:46 PM AppServerStartup run
INFO: [Thread[GlassFish Kernel Main Thread,5,main]] started
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.SecurityLifecycle <init>
INFO: security.secmgroff
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.SecurityLifecycle onInitialization
INFO: Security startup service called
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.PolicyLoader loadPolicy
INFO: policy.loading
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.auth.realm.Realm doInstantiate
INFO: Realm admin-realm of classtype com.sun.enterprise.security.auth.realm.file.FileRealm successfully created.
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.auth.realm.Realm doInstantiate
INFO: Realm file of classtype com.sun.enterprise.security.auth.realm.file.FileRealm successfully created.
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.auth.realm.Realm doInstantiate
INFO: Realm certificate of classtype com.sun.enterprise.security.auth.realm.certificate.CertificateRealm successfully created.
Dec 8, 2009 3:47:47 PM com.sun.enterprise.security.SecurityLifecycle onInitialization
INFO: Security service(s) started successfully....
Dec 8, 2009 3:47:48 PM com.sun.ejb.containers.BaseContainer initializeHome
INFO: Portable JNDI names for EJB TestBean : [java:global/testApp/TestBean!test.TestBean, java:global/testApp/TestBean]
testBean.hello method returned: Hello, client
Dec 8, 2009 3:47:48 PM org.glassfish.admin.mbeanserver.JMXStartupService shutdown
INFO: JMXStartupService and JMXConnectors have been shut down.
Dec 8, 2009 3:47:48 PM com.sun.enterprise.v3.server.AppServerStartup stop
INFO: Shutdown procedure finished
Dec 8, 2009 3:47:48 PM AppServerStartup run
INFO: [Thread[GlassFish Kernel Main Thread,5,main]] exiting

It's a good practice to close the EJB container before program exists, to avoid any resource leaking. It's more easily handled in JUnit tearDown method. See my follow-up post EJB Lite testing with JUnit and embeddable container

How to get module name and app name

2009-12-08T11:08:00.004-05:00

Java EE 6 brings an easy and portable way to get the module name and application name of the current app, using @Resource field injection or lookup:

    @Resource(lookup="java:module/ModuleName")
   private String moduleName;
      
   @Resource(lookup="java:app/AppName")
   private String appName;

The above code can be in any Java EE component classes, such as servlet, servlet filter, web listener class, JSP tag handler class, JSF managed bean, EJB bean class, interceptor class, application client main class, and their super classes as well.

You can also look up the module name and app name by their reserved jndi names:

//look up inside a method
String mname = (String) initialContext.lookup("java:module/ModuleName");
String anmae = (String) initialContext.lookup("java:app/AppName");

If you only need moduleName or appName in a particular method, I feel looking them up on-demand is slightly better.

From Java EE 6 forward, the default module name is the base name of a WAR, ejb-jar, or application client jar, that is, the jar name without the .war and .jar extension. One can customize it in descriptors (web.xml, ejb-jar.xml, application-client.xml), though this is rarely needed.

The default app name is the basename of a EAR, i.e., the EAR name without the .ear extension. One can customize it in application.xml.

A sample application-client.xml (Java EE 5)

2009-10-14T08:54:00.004-04:00

Application client is another type of Java EE module, the least utilized one. It attempts to wrap up Java SE application, deploy it to application server, and make use of deployed EJB, platform services and resources.

The following application-client.xml declares an env-entry, ejb-ref and resource-ref.

<?xml version="1.0" encoding="UTF-8"?>
<application-client xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="5"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application-client_5.xsd">

 <display-name>A sample application client</display-name>

 <env-entry>
   <description>admin email</description>
   <env-entry-name>adminEmail</env-entry-name>
   <env-entry-value>admin@example.x</env-entry-value>
 </env-entry>

 <ejb-ref>
   <ejb-ref-name>ejb/testBean</ejb-ref-name>
   <remote>test.TestRemoteInterface</remote>
   <ejb-link>TestBean</ejb-link>
 </ejb-ref>

 <resource-ref>
   <res-ref-name>HRDS</res-ref-name>
   <res-type>javax.sql.DataSource</res-type>
   <mapped-name>jdbc/__default</mapped-name>
 </resource-ref>

</application-client>

The env-entry can be looked up with name "java:comp/env/adminEmail", or injected into the application client main class or its superclasses. For example:

@Resource(name="adminEmail")
//use static modifier in application client main class only
private static String adminEmail;

The ejb-ref and resource-ref can be looked up with names "java:comp/ejb/testBean" and "java:comp/env/HRDS", respectively.

The reason I include ejb-ref and resource-ref is to show how they fit in descriptors. In Java EE 5 and later, it is easier to use @EJB and @Resource to declare and inject them into component classes.

A sample application.xml (Java EE 5 and Java EE 6)

2009-10-13T13:02:00.005-04:00

The following is a sample application.xml that declares 3 modules (application client, ejb jar, and war), and a library directory. The library-directory element is redundant here since the default value is "lib".

<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="5"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_5.xsd">

<module>
 <java>test-client.jar</java>
</module>

<module>
 <ejb>test-ejb.jar</ejb>
</module>

<module>
 <web>
   <web-uri>test.war</web-uri>
   <context-root>test</context-root>
 </web>
</module>

<library-directory>lib</library-directory>
</application>

Java EE 6 application.xml:


<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  version="6" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_6.xsd">

  <application-name>test-app</application-name>
  <initialize-in-order>true</initialize-in-order>
  <module>
    <web>
      <web-uri>test-web.war</web-uri>
      <context-root>test</context-root>
    </web>
  </module>

  <module>
    <ejb>test-ejb.jar</ejb>
  </module>
  <library-directory>lib</library-directory>
</application>

A sample ejb-jar.xml (EJB 3.0)

2009-10-12T16:27:00.007-04:00

ejb-jar.xml is optional starting from EJB 3.0. Annotations are extensively used to declare metadata in place of descriptor elements. In certain cases, ejb-jar.xml is still necessary, and 2 such cases I can think of are the declaration of env-entry and default interceptor.

<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  version="3.0" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd">
  <enterprise-beans>
    <session>
      <ejb-name>TestBean</ejb-name>
      <env-entry>
        <description>admin email</description>
        <env-entry-name>adminEmail</env-entry-name>
        <env-entry-value>admin@example.x</env-entry-value>
      </env-entry>
    </session>
  </enterprise-beans>

  <interceptors>
    <interceptor>
      <interceptor-class>test.Interceptor1</interceptor-class>
    </interceptor>
  </interceptors>

  <assembly-descriptor>
    <interceptor-binding>
      <ejb-name>*</ejb-name>
      <interceptor-class>test.Interceptor1</interceptor-class>
    </interceptor-binding>
  </assembly-descriptor>
</ejb-jar>

This ejb-jar.xml assumes that TestBean is already annotated with either @Stateless or @Stateful. The descriptor adds a env-entry resource to this session bean's naming environment. This env-entry can be injected into TestBean class, or looked up in TestBean's naming environment.

The interceptor-binding element binds Interceptor1 to all EJBs packaged in the current ejb jar.

A minimal sample web.xml (servlet 2.5)

2009-10-12T15:24:00.004-04:00

A very short web.xml (Servlet 2.5) that declares a servlet and its mapping. Some elements, like session-config and welcome-file-list have reasonable defaults provided by web containers.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

  <servlet>
    <display-name>Servlet1</display-name>
    <servlet-name>Servlet1</servlet-name>
    <servlet-class>test.Servlet1</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>Servlet1</servlet-name>
    <url-pattern>/Servlet1</url-pattern>
  </servlet-mapping>

</web-app>

A sample web.xml (servlet 2.5)

2009-10-12T13:30:00.005-04:00

This is a sample web.xml based on Servlet 2.5 (part of Java EE 5) that declares common elements. All top-level elements are optional, and can be in any order.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

 <context-param>
   <param-name>debug</param-name>
   <param-value>false</param-value>
 </context-param>

 <session-config>  <!--  10 minutes -->
   <session-timeout>10</session-timeout>
 </session-config>

 <servlet>
   <display-name>Servlet1</display-name>
   <servlet-name>Servlet1</servlet-name>
   <servlet-class>test.Servlet1</servlet-class>
   <init-param>
     <param-name>sleep-time-in-seconds</param-name>
     <param-value>10</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
   <servlet-name>Servlet1</servlet-name>
   <url-pattern>/Servlet1</url-pattern>
 </servlet-mapping>

 <env-entry>
   <description>admin email</description>
   <env-entry-name>adminEmail</env-entry-name>
   <env-entry-value>admin@example.x</env-entry-value>
 </env-entry>

 <resource-ref>
   <res-ref-name>HRDS</res-ref-name>
   <res-type>javax.sql.DataSource</res-type>
   <mapped-name>jdbc/__default</mapped-name>
 </resource-ref>

 <filter>
   <display-name>Filter1</display-name>
   <filter-name>Filter1</filter-name>
   <filter-class>Filter1</filter-class>
 </filter>

 <filter-mapping>
   <filter-name>Filter1</filter-name>
   <url-pattern>/Filter1</url-pattern>
 </filter-mapping>

 <filter-mapping>
   <filter-name>Filter1</filter-name>
   <servlet-name>Servlet1</servlet-name>
   <dispatcher>REQUEST</dispatcher>
   <dispatcher>FORWARD</dispatcher>
   <dispatcher>INCLUDE</dispatcher>
   <dispatcher>ERROR</dispatcher>
 </filter-mapping>

 <listener>
   <listener-class>Listener1</listener-class>
 </listener>

 <welcome-file-list>
   <welcome-file>index.html</welcome-file>
   <welcome-file>index.htm</welcome-file>
   <welcome-file>index.jsp</welcome-file>
   <welcome-file>default.html</welcome-file>
   <welcome-file>default.htm</welcome-file>
   <welcome-file>default.jsp</welcome-file>
 </welcome-file-list>

</web-app>

Servlet without web.xml

2009-10-09T17:59:00.005-04:00

One of the new features in Servlet 3.0 is the introduction of annotation to define a servlet, thus making web.xml optional. The following is a simple web app that only contains a servlet:

1. create project directory structure:

mkdir nowebxml
cd nowebxml/
mkdir -p src/test build/WEB-INF/classes

2. create TestServlet.java in src/test

cd src/test
-------------------

package test;

import java.io.IOException;
import java.io.PrintWriter;

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

@WebServlet(urlPatterns = "/TestServlet", loadOnStartup = 1)
public class TestServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    doPost(request, response);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    PrintWriter writer = response.getWriter();
    writer.println("A servlet without web.xml: " + getServletName());
}
}

3. compile and package

javac -cp "$GLASSFISH_HOME/modules/*" -d ../../build/WEB-INF/classes/ TestServlet.java

cd ../../build/

jar cvf nowebxml.war WEB-INF/

4. deploy

cp nowebxml.war $GLASSFISH_HOME/domains/domain1/autodeploy/

5. run TestServlet

curl http://localhost:8080/nowebxml/TestServlet
A servlet without web.xml: test.TestServlet

GlassFish V3 is used for deploy and running the test web app, but this web app is portable and should work with any container that supports Servlet 3.0.

My javac command uses a wildcard in classpath values, which is only supported in Java SE 6 or later. Classpath wildcard is very convenient, especially in testing. In addition, Servlet 3.0 is part of Java EE 6, which itself requires Java SE 6.

Print array content with Arrays.toString or Arrays.asList

2009-10-09T17:14:00.005-04:00

When directly printing an array, it gives its element type and hashcode, which is not the desired result in most cases. A better way is to use java.util.Arrays.toString(), or Arrays.asList() method to print the string representation of the array.

This test method tries 2 ways of printing the content of a string array:

public final void testPrintArray() {
   final String[] names = {"Linux", "Mac OS X", "Windows", "Solaris", null};
   System.out.println("print names array directly: " + names);
   System.out.println("print names with Arrays.toString(): " + Arrays.toString(names));
   System.out.println("print names with Arrays.asList(): " + Arrays.asList(names));
}

Test output:

print names array directly: [Ljava.lang.String;@5122cdb6
print names with Arrays.toString(): [Linux, Mac OS X, Windows, Solaris, null]
print names with Arrays.asList(): [Linux, Mac OS X, Windows, Solaris, null]

Between the 2 methods, I find toString() is more natural. Arrays.toString() was introduced in Java 5, somewhat later than Arrays.asList().

Also note that a List can take null as element value, and its string representation is "null".

Use string constants in annotations

2009-04-28T11:32:00.012-04:00

Generally speaking, string literals should be replaced with string constants in source code. This rule also holds when it comes to annotation-based resource injections.

For field or setter injections, any string constants can be declared in the enclosing class. The following example shows how to declare an env-entry in web.xml and inject it to a servlet class.

public static final String ADMIN_EMAIL = "adminEmail";

@Resource(name=ADMIN_EMAIL)
private String adminEmail;

<env-entry>
   <description>admin email</description>
   <env-entry-name>adminEmail</env-entry-name>
   <env-entry-value>admin@example.x</env-entry-value>
</env-entry>

The name attribute is mandatory and used to match this injection to the appropriate env-entry in web.xml. This env-entry can be injected into several other classes, and therefore it is desirable to declare its name as a constant. This string constant may also reside in a separate class (e.g., a Constants class, utility class, or even some interface), depending on how it is used.

For type-level injections, these string constants must be declared in a separate class in order to be referenced in type-level annotations. This is probably because any field declarations have not be parsed when type-level annotations in the same class are processed. The follwoing example shows how to inject a stateful EJB reference at a servlet class level.

import static test.Constants.FOO_EJB_NAME;
import static test.Constants.FOO_EJB_REF_NAME;

@EJB(name=FOO_EJB_REF_NAME, beanName=FOO_EJB_NAME, beanInterface=FooBean.class)
public class Servlet2 extends HttpServlet {...}

In the above injection, beanName is optional only if there is only one EJB with business interface FooBean, and hence no ambiguity in mapping the EJB reference to target EJB. name and beanInterface attributes are always required when the @EJB injection is used at type level.

Configure default target class name when copying class in Eclipse

2009-03-27T14:06:00.007-04:00

I often copy a class and paste it into the same package, just as a template for creating another similar class. This is well supported in both NetBeans and Eclipse. The small difference between the 2 IDE is in the default name for the target class: NetBeans uses the format "Foo_1", while Eclipse uses "CopyOfFoo". Since I will never use a class like CopyOfFoo, I prefer the short form used in NetBeans.

So how to configure the default target class name in Eclipse? I searched in Eclipse preference to no avail. A grep through Eclipse installation directory reveals 2 jar files containing the string "CopyOf"

Binary file ./plugins/org.eclipse.jdt.ui_3.4.1.r341_v20080827-1100.jar matches
Binary file ./plugins/org.eclipse.wst.jsdt.ui_1.0.12.v200809172136.jar matches

The first one looks right. So I first quit Eclipse, back up plugins/org.eclipse.jdt.ui_3.4.1.r341_v20080827-1100.jar, expand it to /tmp/eclipse, and edit the file org/eclipse/jdt/internal/corext/refactoring/refactoring.properties.

Change the value of the following property from CopyOf{0} to the desired value (say X{0}):

- CopyRefactoring_cu_copyOf1=CopyOf{0}
+ CopyRefactoring_cu_copyOf1=X{0}

Update plugins/org.eclipse.jdt.ui_3.4.1.r341_v20080827-1100.jar with modified refactoring.properties:

cd /tmp/eclipse
jar uvf $HOME/eclipse/plugins/org.eclipse.jdt.ui_3.4.1.r341_v20080827-1100.jar org/eclipse/jdt/internal/corext/refactoring/refactoring.properties

Ideally, I wanted to append, rather than prepend, the extra 'X', but it turns out {0}X is resolved to a file name like Foo.javaX, not FooX.java. So Eclipse refactoring complains about it not being a valid compilation unit.

Restart Eclipse and see the new default name in action. These steps have worked for me (my Eclipse is Version 3.4.1), but this should not be the preferred way to configure Eclipse. I wish it can be configured in preferences. Any changes to that plugin jar may be overwritten when it is updated from remote repository.

Unable to copy and paste multiple files in Eclipse project explorer

2009-02-13T10:00:00.006-05:00

One thing I often do inside a java IDE is to copy files from one package to another. The IDE (either Eclipse or NetBeans) does the refactoring automatically including renaming the package. I usually copy multiple files of mixed types (e.g., java source files, ant build.xml files, web.xml, etc) in one operation.

I recently found I can't do that in Eclipse project explorer (3.4.1 ganymede). I can only copy files of the same content type in one command. That is, I can copy-paste-refactor multiple java files, or multiple xml files from one package to another. But it would fail if I try to copy java source files AND xml files.

It seems the copying part failed. When I tried to paste files of mixed types, the files copied in the last command were pasted, not the one supposed to have been copied.

This has been working pretty well in NetBeans 6.1 and 6.5.

Install subversion 1.5.5 on Ubuntu

2009-02-03T20:56:00.014-05:00

The latest subversion is 1.5.5 (as of now 2/3/2009), but it's not available yet in Ubuntu repository or web site (svn 1.4.6). So I tried to install it manually. I only need the client, not the server, so I would skip those parts that are only for server. I went through the following steps and finally was able to install it. Take it at your own risk.

0. Switch (su) to root.

1. Go to http://subversion.tigris.org/getting.html, and click the link Source Releases Area. Download subversion 1.5.5 source archive and the dependency tarball to Desktop (note: 2 separate gz files: subversion-1.5.5.tar.gz & subversion-deps-1.5.5.tar.gz). This site also lists binary downloads for various platforms. I checked Ubuntu and other Linux platforms, but they don't have 1.5.5 yet.

2. Unpack subversion source and dependency tarballs (note that both must be unpacked inside the same directory)

cd $HOME/tmp
tar xzvf $HOME/Desktop/subversion-1.5.5.tar.gz
tar xzvf $HOME/Desktop/subversion-deps-1.5.5.tar.gz

3. Try to configure and install it

cd $HOME/tmp/subversion-1.5.5
./configure --without-berkeley-db --without-apache --without-neon --without-swig
make
make install

4. If it failed at step 3, most likely some dependencies are still missing. In my case, openssl is reported missing, though I'm sure openssl is already installed. Anyway, download and install openssl. It should be straight-forward to install openssl from source:

Go to openssl.org to download the latest stable version of openssl (currently openssl-0.9.8j). Note: OpenSSL 0.9.8 has a problem that can cause SSL negotiation failure (SSL negotiation failed: SSL error: decryption failed or bad record mac). For more details, see http://wiki.open.collab.net/wiki/Subversion_Client_FAQ

cd $HOME/tmp
tar xzvf $HOME/Desktop/openssl-0.9.8j.tar.gz
cd openssl-0.9.8j
./config
make
make install

5. Try installing subversion 1.5.5 again, with --with-openssl=/usr/local/ssl option, assuming openssl is installed to /usr/local/ssl.

cd $HOME/tmp/subversion-1.5.5
./configure --without-berkeley-db --without-apache --without-neon
--without-swig --with-openssl=/usr/local/ssl

6. If it fails due to zlib not present, try installing zlib1g-dev:

sudo apt-get install zlib1g-dev  (without sudo, if running as root)

7. Try installing subversion 1.5.5 again, with --with-zlib=... option:

./configure --without-berkeley-db --without-apache --without-neon
--without-swig --with-openssl=/usr/local/ssl --with-zlib=/usr/include

That should do it. Subversion 1.5.5 (at least the client) has been installed successfully!

/tmp > which svn
/usr/local/bin/svn

/tmp > svn  --version
svn, version 1.5.5 (r34862)
compiled Feb  3 2009, 14:23:41

Copyright (C) 2000-2008 CollabNet.
Subversion is open source software, see http://subversion.tigris.org/
This product includes software developed by CollabNet (http://www.Collab.Net/).

The following repository access (RA) modules are available:

* ra_svn : Module for accessing a repository using the svn network protocol.
- handles 'svn' scheme
* ra_local : Module for accessing a repository on local disk.
- handles 'file' scheme
* ra_serf : Module for accessing a repository via WebDAV protocol using serf.
- handles 'http' scheme
- handles 'https' scheme

Update: After using this subversion client for about a month, I found a problem when committing changes to a repository with https. It only happens when running the commit sub-command using http protocol. It's probably related to the openssl issue mentioned above.

Change svn project to java project in Eclipse

2009-02-03T10:52:00.004-05:00

I checked out a project from subversion repository using Eclipse (3.4.1 ganymede). I chose to check it out into a new Eclipse project, but it turned out to be a non-java, svn project was created. In the project properties, there is no associated builder. Its .project file looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
 <name>project1</name>
 <comment>project1</comment>
 <projects>
 </projects>
 <buildSpec>
 </buildSpec>
 <natures>
 </natures>
</projectDescription>

Now I want to turn it into a java project so it can be built with a java builder. I tried a few menus and other places inside Eclipse to no avail. Then I found I can just edit .project file, and that did the trick. Close Eclipse before doing these manual editing.

$HOME/workspace/project1/.project:
----------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
 <name>project1</name>
 <comment>project1</comment>
 <projects>
 </projects>
 <buildSpec>
  <buildCommand>
   <name>org.eclipse.jdt.core.javabuilder</name>
   <arguments>
   </arguments>
  </buildCommand>
 </buildSpec>
 <natures>
  <nature>org.eclipse.jdt.core.javanature</nature>
 </natures>
</projectDescription>

I also added a .classpath file:

$HOME/workspace/project1/.classpath:
-----------------------------------

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
 <classpathentry kind="src" path="src"/>
 <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
       <!-- change the default bin directory to classes directory -->
 <classpathentry kind="output" path="classes"/>
</classpath>

Finally, start Eclipse, open project1, and modify its source path, libraries, and other project properties.

NetBeans 6.5 Quick Search Box, Slow Refactoring, and Transfering Repository Index

2009-01-01T17:40:00.007-05:00

I recently upgraded to NetBeans 6.5 and have been pretty happy with it overall. These 3 new features you may have also noticed:

1. There is now a new Quick Search box at the upper right corner, with shortcut key Ctrl-I. The pull-down list shows it can search for Types, Actions, Options and help items. It seems interesting and I should use it more often.

I usually use Ctrl-O to jump to a class in my projects, which is very fast. Or use Alt-Shift-O to go to a file (much slower than Ctrl-O). In NetBeans 6.1, Ctrl-O (go to type) used to show all the useless javascript files except the java classes I was looking for. Now 6.5 seems to have fixed it.

2. Refactoring is extremely slow. Any refactoring, even renaming a local variable is slow. The blue progress bar stops at 100% for close to 1 minute in my computer. NetBeans seems to be searching across all projects and cache and gathering dependency.

3. Sometimes at startup, it shows a background task "Transfering Repository Index :Central Repository" (NetBeans typo: it should be Transferring). It's not blocking anything but does take quite long to complete.

GlassFish MySql connection pool with empty password

2008-12-31T17:18:00.005-05:00

The default mysql database server password is empty, which is convenient in development mode, but turns out to be trouble when creating a jdbc connection pool in GlassFish. There seems to be no way to specify an empty password either in admingui or asadmin.

One workaround is to use a temporary password (say, "xxx") when creating the connection pool, stop the domain, open $GLASSFISH_HOME/domains/domain1/config/domain.xml, and replace "xxx" with ""

This should work with all versions of GlassFish (v1, v2, and v3). To do it with script:

$GLASSFISH_HOME/bin/asadmin start-domain

$GLASSFISH_HOME/bin/asadmin create-jdbc-connection-pool --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlXADataSource --property user=root:password=xxx:DatabaseName=test:ServerName=localhost:port=3306 mysql-pool
$GLASSFISH_HOME/bin/asadmin create-jdbc-resource --connectionpoolid mysql-pool jdbc/test

$GLASSFISH_HOME/bin/asadmin stop-domain

cd $GLASSFISH_HOME/domains/domain1/config
cat domain.xml | sed "s/xxx//" > domain.xml.replaced
mv domain.xml domain.xml.original
mv domain.xml.replaced domain.xml

$GLASSFISH_HOME/bin/asadmin start-domain

vi/vim is also well suited for this type of search-replace:

vim domain.xml
/xxx
dw
:wq

Pass optional params with varargs

2008-12-17T08:27:00.013-05:00

Varargs (introduced in Java SE 5) allows you to pass 0, 1, or more params to a method's vararg param. This reduces the need for overloading methods that do the similar things. For example,

package javahowto;

import org.apache.commons.lang.StringUtils;

public class HelloWorld {
    public static void main(String[] args) {
        hello();
        hello("World");
        hello("Santa", "Bye");
        
        final String[] names = {"John", "Joe"};
        hello(names);
    }

    public static void hello(String... names) {
        final String defaultName = "Duke";
        String msg = "Hello, ";
        msg += ((names.length == 0) ? defaultName : StringUtils.join(names, ", "));
        System.out.println(msg);
    }
}

org.apache.commons.lang.StringUtils is in commons-lang-2.4.jar. Running this example gives the following output:

Hello, Duke
Hello, World
Hello, Santa, Bye
Hello, John, Joe
BUILD SUCCESSFUL (total time: 0 seconds)

How to create jdbc connection pool and DataSource in GlassFish

2008-12-07T21:52:00.012-05:00

Every GlassFish DataSource depends on a connection pool that specifies how to connect to database. DataSource is just a thin layer on top of a connection pool. This is different from several other appservers.

Usually the easiest way is to do it in admin GUI at http://localhost:4848/ , choose Create New JDBC Connection Pools from the Common Tasks list on the front page right after login. You may need to scroll down a little bit to see it. On my screen, it is always hidden underneath the panel bottom. So for a while, I didn't notice its existence and always go to the left panel and choose Resources | JDBC | Connection Pools, which does the same with more clicks. The rest steps are self-explanatory.

For repeated configuration tasks, I prefer using GlassFish command line tool asadmin ($GLASSFISH_HOME/bin/asadmin). For example, this is script for creating mysql connection pool and datasource:

cp $HOME/mysql-connector-java-5.1.5-bin.jar $GLASSFISH_HOME/domains/domain1/lib/ext

$GLASSFISH_HOME/bin/asadmin stop-domain
$GLASSFISH_HOME/bin/asadmin start-domain

$GLASSFISH_HOME/bin/asadmin create-jdbc-connection-pool --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlDataSource --property user=root:password=test:DatabaseName=test:ServerName=localhost:port=3306 test-pool

$GLASSFISH_HOME/bin/asadmin create-jdbc-resource --connectionpoolid test-pool jdbc/test

To create a connection pool that supports distributed transaction, use com.mysql.jdbc.jdbc2.optional.MysqlXADataSource as datasourceclassname, and set --restype javax.sql.XADataSource option:

$GLASSFISH_HOME/bin/asadmin create-jdbc-connection-pool --restype javax.sql.XADataSource --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlXADataSource --property user=root:password=test:DatabaseName=test:ServerName=localhost:port=3306 test-pool

Run asadmin ping-connection-pool test-pool to verify whether the created connection pool can connect to the database. The database server needs to be running.

Disable NetBeans httpmonitor in GlassFish

2008-12-02T14:58:00.008-05:00

I found my GlassFish v2 server.log file is littered with these warning messages:

WARNING *********** NetBeans HTTP Monitor ************
The request cannot be recorded most likely because the
NetBeans HTTP Server is not running....

Here is what I just did to disable and completely remove NetBeans httpmonitor from my GlassFish v2:

1. Open $GLASSFISH_HOME/domains/domain1/config/default-web.xml, delete or comment out the declaration and mapping for servlet filter HTTPMonitorFilter. That is, the following lines:

<filter>
<filter-name>HTTPMonitorFilter</filter-name>
<filter-class>org.netbeans.modules.web.monitor.server.MonitorFilter</filter-class>
<init-param>
 <param-name>netbeans.monitor.ide</param-name>
 <param-value>127.0.0.1:8082</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>HTTPMonitorFilter</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>INCLUDE</dispatcher>
<dispatcher>ERROR</dispatcher>
</filter-mapping>

2. Optionally, delete $GLASSFISH_HOME/domains/domain1/lib/org-netbeans-modules-web-httpmonitor.jar.
Since I don't need this httpmonitor, there is no reason to keep this jar.

3. Redeploy any web applications that was previously deployed when NetBeans HTTPMonitorFilter was in default-web.xml. This step is needed for apps already deployed, because the generated web.xml already contains HTTPMonitorFilter (inherited from the old default-web.xml), and it will not be regenerated even at server restart.

That should get rid of this warning messages. For more technical details, see NetBeans issue 139653 and GlassFish issue 3844.

HelloWorld with EclipseLink and MySQL

2008-10-20T11:43:00.011-04:00

This is a simple example of standalone java application using Java Persistence API (JPA), EclipseLink, and MySql. It consists of an entity class, a main class, and a persistence.xml file. No need to create tables, as they are created and dropped automatically.

META-INF/persistence.xml must be at the root of the persistence unit. In my example project, it's located at $HOME/NetBeansProjects/greeting/build/classes/META-INF/persistence.xml.

<?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="greetingPU" transaction-type="RESOURCE_LOCAL">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<class>javahowto.Greeting</class>
<properties>
<property name="eclipselink.jdbc.password" value=""/>
<property name="eclipselink.jdbc.user" value="root"/>
<property name="eclipselink.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.jdbc.url" value="jdbc:mysql://localhost:3306/test"/>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables"/>
<property name="eclipselink.logging.level" value="INFO"/>
</properties>
</persistence-unit>
</persistence>

Entity class (generated by NetBeans 6.1):

package javahowto;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Greeting implements Serializable {
private static final long serialVersionUID = 1L;

@Id
private Long id;

@Basic
private String message;

public Long getId() {
return id;
}

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

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

@Override
public int hashCode() {
int hash = 0;
hash += (id != null ? id.hashCode() : 0);
return hash;
}

@Override
public boolean equals(Object object) {
// TODO: Warning - this method won't work in the case the id fields are not set
if (!(object instanceof Greeting)) {
 return false;
}
Greeting other = (Greeting) object;
if ((this.id == null && other.id != null) ||
 (this.id != null && !this.id.equals(other.id))) {
 return false;
}
return true;
}

@Override
public String toString() {
return "javahowto.Greeting[id=" + id + ", message='" + getMessage() +
"']";
}
}

Main class:

package javahowto;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class Main {
private static final Logger logger = Logger.getLogger("javahowto.greeting");
private static final String PERSISTENCE_UNIT_NAME = "greetingPU";
private EntityManagerFactory emf;
private EntityManager em;

public static void main(String[] args) {
Main main = new Main();
main.initEntityManager();
main.createAndRead();
main.createAndRollback();
}

private void createAndRead() {
Greeting g = new Greeting();
g.setId(1L);
g.setMessage("hello, createAndRead");
em.getTransaction().begin();
em.persist(g);
em.getTransaction().commit();

//g should be written to database now.
//Read it from db (no transaction context needed for em.find method)
Greeting g2 = em.find(Greeting.class, g.getId());
logger.info("Greeting " + g.getId() + " from db: " + g2);
}

private void createAndRollback() {
Greeting g = new Greeting();
g.setId(2L);
g.setMessage("hello, createAndRollback");
em.getTransaction().begin();
em.persist(g);
em.getTransaction().rollback();

logger.info("Persisted " + g + ", but the transaction was rolled back.");
Greeting g2 = em.find(Greeting.class, g.getId());
logger.info("Greeting " + g.getId() + " from db: " + g2);  //should be null
}

private void initEntityManager() {
emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
em = emf.createEntityManager();
}
}

To compile the project,

/NetBeansProjects/greeting/src >
javac -d ../build/classes -cp $GLASSFISH_HOME/modules/javax.persistence.jar javahowto/*.java

Start MySql on localhost, and run the following command. No need to create the table since our persistence.xml tells EclipseLink to automatically drop and create it.

/home/javahowto/mysql > bin/mysqld_safe &

/NetBeansProjects/greeting/build/classes >
java -cp $HOME/tmp/mysql-connector-java-5.1.5-bin.jar:$GLASSFISH_HOME/modules/javax.persistence.jar:$GLASSFISH_HOME/modules/org.eclipse.persistence.jpa.jar:$GLASSFISH_HOME/modules/org.eclipse.persistence.core.jar:. javahowto.Main

[EL Info]: 2008.10.20 11:56:24.712--ServerSession(4744654)--EclipseLink, version: Eclipse Persistence Services - 1.0.1 (Build 20080905)
[EL Info]: 2008.10.20 11:56:25.163--ServerSession(4744654)--file:/home/javahowto/NetBeansProjects/greeting/build/classes/-greetingPU login successful
Oct 20, 2008 11:56:25 AM javahowto.Main createAndRead
INFO: Greeting 1 from db: javahowto.Greeting[id=1, message='hello, createAndRead']
Oct 20, 2008 11:56:25 AM javahowto.Main createAndRollback
INFO: Persisted javahowto.Greeting[id=2, message='hello, createAndRollback'], but the transaction was rolled back.
Oct 20, 2008 11:56:25 AM javahowto.Main createAndRollback
INFO: Greeting 2 from db: null

To stop MySQL server:

/home/javahowto/mysql > bin/mysqladmin -u root shutdown

Solve java.lang.ArrayStoreException: sun.reflect.annotation.TypeNotPresentExceptionProxy

2008-10-09T11:01:00.010-04:00

I recently ran into this type of exceptions when experimenting with GlassFish V3. It turned out the root cause is that a class (HelloInterceptor) used in type-level @Interceptors annotation is missing in the WAR file. Once this class is packaged in the WAR file, it works. In appservers that support EJB 3.1, EJB can be packaged inside a WAR file.

@Stateless
@Interceptors(HelloInterceptor.class)
public class HelloBean {
   public String hello(String name) {
       return "Hello, " + name;
   }
}

ArrayStoreException has been in Java since JDK 1.0, but this is the first time I saw it. The javadoc says it is "[t]hrown to indicate that an attempt has been made to store the wrong type of object into an array of objects." So it's a low level exception that I would normally catch and shield it from client.

The stacktrace in server.log is pretty long, repeating the same stacktrace 3-4 times. In short it looks like this:

[#|2008-10-09T10:57:39.262-0400|SEVERE|GlassFish10.0|javax.enterprise.system.core|_ThreadID=17;_ThreadName=Thread-4;|
Exception while deploying the app
java.lang.RuntimeException: sun.reflect.annotation.TypeNotPresentExceptionProxy
at org.glassfish.javaee.core.deployment.JavaEEDeployer.loadMetaData(JavaEEDeployer.java:160)
at com.sun.enterprise.v3.server.ApplicationLifecycle.prepare(ApplicationLifecycle.java:436)
at com.sun.enterprise.v3.server.ApplicationLifecycle.deploy(ApplicationLifecycle.java:180)
at org.glassfish.deployment.admin.DeployCommand.execute(DeployCommand.java:314)
at com.sun.enterprise.v3.admin.CommandRunner$2.execute(CommandRunner.java:302)
at com.sun.enterprise.v3.admin.CommandRunner.doCommand(CommandRunner.java:312)
at com.sun.enterprise.v3.admin.CommandRunner.doCommand(CommandRunner.java:135)
at org.glassfish.deployment.autodeploy.AutoOperation.run(AutoOperation.java:122)
at org.glassfish.deployment.autodeploy.AutoDeployer.deploy(AutoDeployer.java:524)
at org.glassfish.deployment.autodeploy.AutoDeployer.deployAll(AutoDeployer.java:410)
at org.glassfish.deployment.autodeploy.AutoDeployer.run(AutoDeployer.java:342)
at org.glassfish.deployment.autodeploy.AutoDeployer.run(AutoDeployer.java:330)
at org.glassfish.deployment.autodeploy.AutoDeployService$1.run(AutoDeployService.java:200)
at java.util.TimerThread.mainLoop(Timer.java:512)
at java.util.TimerThread.run(Timer.java:462)
Caused by: java.lang.ArrayStoreException: sun.reflect.annotation.TypeNotPresentExceptionProxy
at sun.reflect.annotation.AnnotationParser.parseClassArray(AnnotationParser.java:653)
at sun.reflect.annotation.AnnotationParser.parseArray(AnnotationParser.java:460)
at sun.reflect.annotation.AnnotationParser.parseMemberValue(AnnotationParser.java:286)
at sun.reflect.annotation.AnnotationParser.parseAnnotation(AnnotationParser.java:222)
at sun.reflect.annotation.AnnotationParser.parseAnnotations2(AnnotationParser.java:69)
at sun.reflect.annotation.AnnotationParser.parseAnnotations(AnnotationParser.java:52)
at java.lang.Class.initAnnotationsIfNecessary(Class.java:3072)
at java.lang.Class.getAnnotations(Class.java:3052)
at org.glassfish.apf.impl.AnnotationProcessorImpl.processAnnotations(AnnotationProcessorImpl.java:278)
at org.glassfish.apf.impl.AnnotationProcessorImpl.process(AnnotationProcessorImpl.java:188)
at org.glassfish.apf.impl.AnnotationProcessorImpl.process(AnnotationProcessorImpl.java:129)
at com.sun.enterprise.deployment.archivist.Archivist.processAnnotations(Archivist.java:476)
at com.sun.enterprise.deployment.archivist.Archivist.readAnnotations(Archivist.java:348)
at com.sun.enterprise.deployment.archivist.Archivist.readDeploymentDescriptors(Archivist.java:320)
at com.sun.enterprise.deployment.archivist.Archivist.open(Archivist.java:211)
at com.sun.enterprise.deployment.archivist.ApplicationFactory.openArchive(ApplicationFactory.java:143)
at org.glassfish.javaee.core.deployment.JavaEEDeployer.parseModuleMetaData(JavaEEDeployer.java:231)
at com.sun.enterprise.web.WebDeployer.parseModuleMetaData(WebDeployer.java:110)

Update on Mar 06, 2009: I ran into ArrayStoreException again. This time I used type-level @Remote and @Local on bean class but forgot to include the remote and local business interface classes into the WAR file:

@Remote(HelloRemote.class)
@Local(HelloLocal.class)
public class HelloBean {
   public String hello(String name) {
       return "Hello, " + name;
   }

Install MySql GUI tools (MySql Administrator and Query Browser)

2008-07-07T11:28:00.010-04:00

The easiest way to install them on Ubuntu is to use Ubuntu package manager, either command line:

sudo apt-get install mysql-admin
sudo apt-get install mysql-query-browser

Or inside System | Administration | Synaptic Package Manager, search for "mysql-admin" and "mysql-query", mark them for install, and then apply the changes.

After installation is complete, open a terminal and run command mysql-admin or mysql-query-browser. If running them in an existing terminal, you may need to run rehash command first to include the new tools in PATH. Everything should just work.

I also tried installing the generic Linux tar bundle for MySql GUI tools, but had a couple of problems:

1. Download the generic Linux bundle (mysql-gui-tools-5.0r12-linux-i386.tar.gz) from http://dev.mysql.com/downloads/gui-tools/5.0.html . The bundle for Linux includes MySql Administrator and Query Browser (MySQL Migration Toolkit is currently only in Windows bundle).

2. To install the tools, just extract the archive. There are instructions at http://dev.mysql.com/doc/administrator/en/install-generic-tarball.html . Basically, execute this command to expand the downloaded file on Desktop to /opt:

cd /opt
sudo tar xzf $HOME/Desktop/mysql-gui-tools-5.0r12-linux-i386.tar.gz

3. To run MySql Administrator and Query Browser:

/opt/mysql-gui-tools-5.0/mysql-administrator
/opt/mysql-gui-tools-5.0/mysql-query-browser

You may also want to copy/move/link MySQLAdministrator.desktop and MySQLQueryBrowser.desktop to $HOME/Desktop, so you can double-click to launch them.

When running Query Browser, I ran into this issue: mysql-query-browser is freezing every way i try to pick, or click, a scheme. I tried removing everything under $HOME/.mysqlgui/ but still the same.

It's possible to install to directories other than /opt, but it may cause various troubles. I'd suggest stick to the default install directory /opt. I first tried to install under $HOME/mysql directory, to group all mysql-related programs under one umbrella. But I had this error when running ./mysql-administrator --update-paths:

(mysql-administrator-bin:11880): libglade-WARNING **: could not find glade file '/home/me/mysql/share/mysql-gui/common/preferences.glade'
terminate called after throwing an instance of 'MGGladeXML::Error'
Aborted

I then chose to install directly under $HOME so that mysql-gui-tools-5.0/ and mysql/ are at the same level. I also ran mysql-administrator --update-paths to update the paths. I was able to run MySql Administrator, but the GUI fonts are sort of blurred, probably because some GTK library cannot be found. This problem was gone once I changed to the default install location /opt/mysql-gui-tools-5.0.

In addition, the update-paths command doesn't seem to update path for Query Browser, since MySQLQueryBrowser.desktop file still has paths under /opt.

Configure MySql in NetBeans

2008-07-07T10:15:00.011-04:00

NetBeans 6.1 has an interface to manage MySql, including start and stop MySql database server, connect/disconnect from databases, launch external MySql admin tool, execute queries, etc. Here are steps to configure MySql management inside NetBeans:

1. Create a wrapper script for mysqld_safe. The reason is that mysqld start script assumes the user is running the script from mysql base directory. An attempt to start mysqld from mysql/bin directory results in the following error:

/home/me/mysql/bin > ./mysqld_safe
./mysqld_safe: 199: my_print_defaults: not found
./mysqld_safe: 204: my_print_defaults: not found
The file /usr/local/mysql/bin/mysqld doesn't exist or is not executable
Please do a cd to the mysql installation directory and restart
this script from there as follows:
./bin/mysqld_safe.
See http://dev.mysql.com/doc/mysql/en/mysqld_safe.html for more information

So I created script /home/me/mysql/bin/mymysqld_safe, which can be called by NetBeans:

#! /bin/sh
cd /home/me/mysql/
./bin/mysqld_safe &

I had also tried changing mysqld_safe script to replace the hardcoded ./bin/ with `dirname $0`, but it caused other errors. So I figured the best option is to use a wrapper without touching mysql files.

2. Go to NetBeans Window | Services tab, and right-click DataBases node. Choose Properties.
Basic properties:
Server host name: localhost
Server port number: 3306
Administrator user name: root
Administrator password:

Admin properties:
Path/URL to admin tool: /usr/bin/mysql-admin
Path to start command: /home/me/mysql/bin/mymysqld_safe
Path to stop command: /home/me/mysql/bin/mysqladmin
Arguments to stop command: -u root shutdown

How to install MySql admin tool and Query Browser is posted in the previous post Install MySql GUI tools (MySql Administrator and Query Browser) .

java pkg.Main or java pkg/Main?

2008-06-19T14:25:00.008-04:00

Which format do you use to run a java application? I always pass the fully-qualified class name to java command, namely, java com.whatever.Main. In fact, either way is acceptable:

build/classes > java javahowto.Member
build/classes > java javahowto/Member

I've tried java command with both forms in JDK 1.4, JDK 5, and JDK 6 on Linux without any error. On Windows, you can use either pkg.Main, or pkg/Main, but not pkg\Main:

C:\javahowto\build\classes>java javahowto.Main
In Main.main(String[])
C:\javahowto\build\classes>java javahowto/Main
In Main.main(String[])
C:\javahowto\build\classes>java javahowto\Main
Exception in thread "main" java.lang.NoClassDefFoundError: javahowto\Main (wrong name: javahowto/Main)
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:620)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:260)
    at java.net.URLClassLoader.access$000(URLClassLoader.java:56)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:195)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:276)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:251)
    at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:319)

In any event, do not include .class in the class name. When running from the root of class directory on Unix, one can use the shell auto-completion to fill the class name, instead of typing the FQN. That's a big plus for the the second format. On Windows, auto-complete doesn't help in this case, since \ is class name is not accepted. I guess from now on, I will be using the slash form more often.

Unlike java command, javac operates on java source files and always takes file paths as arguments.

Java generics examples -- parameterized class

2008-06-08T15:30:00.011-04:00

Not only can Java generics be used in fields and methods, it can also be used in class definitions to produce parameterized classes. Since JDK 1.5, many built-in Java classes have been retrofitted to parameterized forms. An example is java.lang.Class, which is declared to be public final class Class<T>, the parameter type <T> represents the actual type modeled by this Class object. One benefit is that some of its methods can take or return specific types, avoiding casting while enforcing type-check.

It's also easy to write your own parameterized class. The following is a Member class whose Id field can be parameterized to String, Integer, etc:

package javahowto;
public class Member<T> {
 private T id;
 public Member(T id) {
   this.id = id;
 }
 public T getId() {
   return id;
 }
 public void setId(T id) {
   this.id = id;
 }
 public static void main(String[] args) {
   Member<String> mString = new Member<String>("id1");
   mString.setId("id2");
   System.out.printf("id after setting id: %s%n", mString.getId());
   //output:  id after setting id: id2

   Member<Integer> mInteger = new Member<Integer>(1);
   mInteger.setId(2);
   System.out.printf("id after setting id: %d%n", mInteger.getId());
   //output:  id after setting id: 2
 }

Java generics examples -- use generics in collection

2008-05-26T14:22:00.011-04:00

Here are some most simple and common use of generics with collection.

Example 1:

List<String> names = new ArrayList<String>();
names.add("John");
System.out.printf("List<String> names: %s%n", names);

In the above example, names is a List of String. When retrieving elements from the List, the return value is of type String. So no need for casting, which is a big advantage over the old, non-parameterized collection.

Example 2:

Map<Integer, String> idToName = new HashMap<Integer, String>();
idToName.put(0, "John");
System.out.printf("Map<Integer, String> idToName: %s%n", idToName);

In the above example, idToName is a Map with a Integer key and String value. The output is:

Map<Integer, String> idToName: {0=John}

Example 3:

List<List<String>> listOfList = new ArrayList<List<String>>();
List<String> sublist1 = new ArrayList<String>();
sublist1.add("A String inside sublist1");
listOfList.add(sublist1);

List<String> sublist2 = new LinkedList<String>();
sublist2.add("A String inside sublist2");
listOfList.add(sublist2);
System.out.printf("List<List<String>> listOfList: %s%n", listOfList);

The above example shows a List whose elements are of type List, i.e., a List of List. The inner List declares that it can only hold String elements. The first inner list is an ArrayList of String, and the second is a LinkedList of String. Running this code snippet prints:

List<List<String>> listOfList: [[A String inside sublist1], [A String inside sublist2]]

Example 4:

private static <T> List<T> extractElements(List bag, Class<T> type) {
 List<T> result = new ArrayList<T>();
 for(Object e : bag) {
//if(e instanceof T)  can't use instanceof
if(type.isAssignableFrom(e.getClass())) {
    result.add((T) e);
}
 }
 return result;
}

This method takes a List of mixed elements and extracts those elements of the desired type. The following shows how to call this method:

List bag = new ArrayList();
bag.add(new Integer(0));
bag.add(new Integer(1));
bag.add(new Double(2008.5));
bag.add("a string");
List<Number> numbersInBag = extractElements(bag, Number.class);
System.out.printf("All elements in bag: %s%nNumber elements in bag: %s%n",
bag, numbersInBag);
List<Integer> integersInBag = extractElements(bag, Integer.class);
System.out.printf("All elements in bag: %s%nInteger elements in bag: %s%n",
bag, integersInBag);

-------- output -----------
All elements in bag: [0, 1, 2008.5, a string]
Number elements in bag: [0, 1, 2008.5]
All elements in bag: [0, 1, 2008.5, a string]
Integer elements in bag: [0, 1]

Copy plugins between NetBeans installations

2008-05-16T12:19:00.007-04:00

NetBeans installer does not migrate plugins, and with every new installation, your old plugins are gone. This makes sense because the new NetBeans installation may not support the old plugins. So you will need to re-install these plugins through update centers or manually installing downloaded *.nbm files.

Another option is to copy the plugin jar and configuration files, from the old .netbeans directory to the new .netbeans directory. For example, this is how I copied whichelement plugin from NetBeans 6.0 to 6.1:

cd $HOME/.netbeans/6.0/modules
cp org-netbeans-modules-whichelement.jar $HOME/.netbeans/6.1/modules/

cd $HOME/.netbeans/6.0/config/Modules/
cp org-netbeans-modules-whichelement.xml $HOME/.netbeans/6.1/config/Modules/

Restart NetBeans and you will see the new plugin is enabled. These copied plugins will always appear installed in Tools | Plugins window, and grayed out. So there is no way to deactivate or uninstall them, since they were not installed with the wizard in the first place. But I guess you can always configure them by editing their config files under .netbeans/6.1/config/Modules. The following is the config file for whichelement (org-netbeans-modules-whichelement.xml):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE module PUBLIC "-//NetBeans//DTD Module Status 1.0//EN"
                     "http://www.netbeans.org/dtds/module-status-1_0.dtd">
<module name="org.netbeans.modules.whichelement">
 <param name="autoload">false</param>
 <param name="eager">false</param>
 <param name="enabled">true</param>
 <param name="jar">modules/org-netbeans-modules-whichelement.jar</param>
 <param name="reloadable">false</param>
 <param name="specversion">1.5</param>
</module>

This is not the recommended approach in most cases and may not work for some plugins. However, it can be useful if you can't find it in update centers or in *.nbm form.

Update on 12/07/2008:
I've copied whichelement plugin from my NetBeans 6.1 installation to 6.5. It works fine so far.

How to customize NetBeans look and feel

2008-05-15T11:43:00.006-04:00

NetBeans by default uses the platform native look and feel: windows look and feel on Windows, and Gtk look and feel on Linux and Solaris where Gtk 2 is available. While the windows look and feel is fine and pretty close to native windows applications, NetBeans doesn't look the best with Gtk look and feel. Here are some options to adjust them, in order of my preference:

1. Plastic looks from JGoodies. Go to JGoodies download page, choose "JGoodies Looks" among the list of download links. Runs with Java 1.4 or greater.

Unzip the download file (looks-2.1.4.zip) to somewhere, e.g., /home/xxx. The zip file contains a top-level root directory so no need to make a temp dir for unzipping.

Edit NetBeans-dir/etc/netbeans.conf file, appending the following options to netbeans_default_options (You may want to copy and comment out the original line for safety):


--cp:p /home/xxx/looks-2.1.4/looks-2.1.4.jar --laf com.jgoodies.looks.plastic.Plastic3DLookAndFeel

Note that netbeans_default_options value is quoted so after your editing, it should still end with ". Restart NetBeans to see the new look. You can also pass these options in command line when you start NetBeans and command line options will override netbeans_default_options in netbeans.conf file:


NetBeans-dir/bin/netbeans --cp:p /home/xxx/looks-2.1.4/looks-2.1.4.jar --laf com.jgoodies.looks.windows.WindowsLookAnd

JGoodies looks comes with the following look and feels:

com.jgoodies.looks.plastic.Plastic3DLookAndFeel
com.jgoodies.looks.plastic.PlasticLookAndFeel
com.jgoodies.looks.plastic.PlasticXPLookAndFeel
com.jgoodies.looks.windows.WindowsLookAndFeel

All of them are cross-platform, which means you can also use com.jgoodies.looks.windows.WindowsLookAndFeel on Linux. But it's not much different from swing metal look and feel. While trying Plastic3DLookAndFeel, PlasticLookAndFeel and PlasticXPLookAndFeel on my Linux laptop, I didn't see any noticeable difference among them.

2. Use the classic swing metal look and feel. Although not visually appealing, it has some benefits: (1) no additional jar on classpath; (2) consistent look and feel across platform; and (2) maybe a bit faster. To use metal, edit NetBeans-dir/etc/netbeans.conf:

netbeans_default_options="... --laf javax.swing.plaf.metal.MetalLookAndFeel"

Since NetBeans always sets look and feel whether you specify --laf option or not, the swing default look and feel does to take effect. Adding a file in JAVA_HOME/jre/lib/swing.properties has no effect either. It is not possible to use swing Windows look and feel on non-Windows platform.

3. If NetBeans is running on JDK 6 or greater, Install NetBeans Substance plugin. This is listed # 3, though recommended at NetBeans wiki page. You can download the plugin as a *.nbm file at NetBeans Plugin Portal, and install it following menu Tools | Plugins | Downloaded tab | Add Plugins... button. Once installed, a wide variety of skins can be chosen from menu View | Skins. You can change skin at any time without restarting NetBeans.

I tried all skins and they seem to be very similar, differing only in colors used. The good ones (good to my eyes) are "Moderate" and "Business *". One thing I don't like is that they all auto-hide the plus sign in front of the folder icon inside File and Favorite panel, which I found is very annoying and distracting. When the mouse moves on the left panel, the on-focus elements changes background color. I find it confusing since the current selected element is also highlighted.

After trying it for a couple of days, I decide to unininstall it (Tools | Plugins | Installed tab, select the plugin and click Deactivate on the right, or click Uninstall button on the bottom).

4. Napkin look and feel, making you feel like coding on a napkins. I don't quite like its informal style but others may. Links: overview & snapshots, download, instructions.

5. Nimbus look and feel in JDK 6 update 10 (beta as of 5/15/2008). See here for a comparison to metal. To use it with NetBeans, install JDK 6 update 10, set netbeans_jdkhome to JDK 6u10, and netbeans_default_options to include "--laf com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" in NetBeans-dir/etc/netbeans.conf.

Wtih Nimbus, I can only see the selected items on my left panel (File, Favorite, or Project views). Other elements all have the same color as the white background so are invisible. Will try it again when the final JDK 6u10 is out.

A sample servlet that dynamically creates images

2008-04-17T15:00:00.010-04:00

This is a sample servlet that dynamically generates JPEG images. Currently all image properties are hard-coded, but it should be trivial to provide a jsp form to collect them (e.g., color, font, dimensions, messages). The generated image contains dynamic data such as the appserver name, and OS name.

package javahowto;

import com.sun.image.codec.jpeg.JPEGCodec;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.*;
import javax.servlet.http.*;
import javax.servlet.*;

public class ImageServlet extends HttpServlet {
private static final int WIDTH = 450;
private static final int HEIGHT = 200;
private static final Color BACKGROUND_COLOR = new Color(100,149,237);
private static final Color COLOR = new Color(0,0,139);
private static final Font FONT = new Font("Times New Roman", Font.BOLD, 46);
private static final Font FOOT_FONT = new Font("Courier", Font.ITALIC, 14);
private static final Color FOOT_COLOR = Color.BLACK;

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
   response.setContentType("image/jpg");
   ServletOutputStream out = response.getOutputStream();
   BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_BYTE_INDEXED);
   Graphics graphics = image.getGraphics();
   graphics.setColor(BACKGROUND_COLOR);
   graphics.fillRect(0, 0, image.getWidth(), image.getHeight());
   graphics.setColor(COLOR);
   graphics.setFont(FONT);
   graphics.drawString("Hello World!", 10, HEIGHT/2);
   graphics.setFont(FOOT_FONT);
   graphics.setColor(FOOT_COLOR);
   graphics.drawString("Created by " + getServletContext().getServerInfo(), 10, HEIGHT - 30);
   graphics.drawString("for http://javahowto.blogspot.com/ on " + System.getProperty("os.name"), 10, HEIGHT - 10);
   JPEGCodec.createJPEGEncoder(out).encode(image);
}
}

The web.xml file is as simple as declaring and mapping a servlet:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<servlet>
   <servlet-name>image</servlet-name>
   <servlet-class>javahowto.ImageServlet</servlet-class>
</servlet>
<servlet-mapping>
   <servlet-name>image</servlet-name>
   <url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

Build the project and deploy the image.war to any web server or appserver. Enter the URL http://localhost:8080/image/ to view the generated image. Here we are using the .war file base name as the default context-root and a / servlet path. I tested it on Glassfish v2 update 1, Tomcat 6, and JBoss-5.0.0.Beta4 successfully, except some redeployment errors on JBoss, which was resolved by deleting the .war and restarting server.

If the appserver is running on a headless server, you may need to set the system property java.awt.headless to true. Also note that a Sun-specific encoder class (com.sun.image.codec.jpeg.JPEGCodec) is used. It is in rt.jar of Sun's JDK, but may not be available in other vendors' JDK like IBM's JDK or BEA's (now Oracle's) JRockit. If a non-Sun Java is used, you will need to use the appropriate encoder class. Unfortunately, there seems to be no portable JPEG encoder class as of JDK 6.

Java enum examples

2008-04-13T18:02:00.006-04:00

Simple enum. The ; after the last element is optional, when this is the end of enum definition.

public enum Color {
 WHITE, BLACK, RED, YELLOW, BLUE;  //; is optional
}

Enum embedded inside a class. Outside the enclosing class, elements are referenced as Outter.Color.RED, Outter.Color.BLUE, etc.

public class Outter {
 public enum Color {
   WHITE, BLACK, RED, YELLOW, BLUE
 }
}

Enum that overrides toString method. A semicolon after the last element is required to be able to compile it. More details on overriding enum toString method can be found here.

public enum Color {
 WHITE, BLACK, RED, YELLOW, BLUE;  //; is required here.

 @Override public String toString() {
   //only capitalize the first letter
   String s = super.toString();
   return s.substring(0, 1) + s.substring(1).toLowerCase();
 }
}

Enum with additional fields and custom constructor. Enum constructors must be either private or package default, and protected or public access modifier is not allowed. When custom constructor is declared, all elements declaration must match that constructor.

public enum Color {
 WHITE(21), BLACK(22), RED(23), YELLOW(24), BLUE(25);

 private int code;

 private Color(int c) {
   code = c;
 }

 public int getCode() {
   return code;
 }

Enum that implements interfaces. Enum can implement any interfaces. All enum types implicitly implements java.io.Serializable, and java.lang.Comparable.

public enum Color implements Runnable {
 WHITE, BLACK, RED, YELLOW, BLUE;

 public void run() {
   System.out.println("name()=" + name() +
       ", toString()=" + toString());
 }
}

A sample test program to invoke this run() method:

for(Color c : Color.values()) {
 c.run();
}

Or,

for(Runnable r : Color.values()) {
 r.run();
}

Is the main method inherited?

2008-04-13T16:54:00.004-04:00

Is the public static void main method on the superclass inherited by subclasses? Yes, it can be accessed by all subclasses directly. So it is possible to have a main method just on the superclass, and be able to run each subclass that doesn't itself declare the main method. For example:

public class Main {
 public static void main(String[] args) {
   System.out.println("In Main.main(String[])");
 }
}

public class Main2 extends Main {
 public void m2() {
   main(null);  //access the main method in superclass
 }
}

public class Main3 extends Main2 {}

Running Main, Main2, Main3 have the same effect:

C:\tmp> java Main
In Main.main(String[])

C:\tmp> java Main2
In Main.main(String[])

C:\tmp> java Main3
In Main.main(String[])

When running Main2 and Main3 inside NetBeans 6.1 beta, I got the error Class "Main2" does not have a main method. Note this error is not from java runtime. It seems NetBeans is doing some validation and being too restrictive.

A servlet-EJB3 sample on JBoss AS 5 beta

2008-03-30T22:57:00.003-04:00

This is a simple project illustrating how to deploy and run an EAR that contains an ejb-jar and .war on JBoss 5 beta 4. This project is completely portable and contains no JBoss-specific configurations. It should also work on any other JavaEE application servers (Glassfish v1, v2, WebLogic 10, etc).

I will take advantage of the sample projects bundled inside NetBeans 6.1 beta (earlier versions should also have them, though I haven't checked). Download the NetBeans bundle that includesJavaEE and Glassfish.

1. Inside NetBeans, press Ctrl-Shift-N to create a new project. In the popup window, under Categories choose Samples | Enterprise, then under Projects on the right panel choose Servlet Stateless.

2. On the next window, accept defaults for Name and Location, then click Finish.

3. Under Project tab, you will see a new enterprise project called ServletStateless, which contains 2 sub-projects: ServletStateless-ejb and ServletStateless-war. Everything for this project is already in place.

4. Right click the project ServletStateless (the parent project) and choose build. You will see this output: Building jar: C:\javahowto\ServletStateless\dist\ServletStateless.ear

5. Start JBoss AS all config (not default config). You can also do it inside NetBeans if JBoss has been set as the target server for this project.

cd %JBOSS_HOME%\bin
run.bat -c all

6. Deploy the EAR to JBoss AS. Or inside NetBeans, right click the project node and choose Undeploy and Deploy

cd %JBOSS_HOME%\server\all\deploy
copy C:\javahowto\ServletStateless\dist\ServletStateless.ear .

Make sure it's correctly deployed, checking the output on JBoss console:

22:27:15,859 INFO  [MCKernelAbstraction] installing bean: jboss.j2ee:ear=ServletStateless.ear,jar=ServletState
less-ejb.jar,name=StatelessSessionBean,service=EJB3 with dependencies:
22:27:15,859 INFO  [MCKernelAbstraction]   and demands:
22:27:15,859 INFO  [MCKernelAbstraction]        jboss.ejb:service=EJBTimerService
22:27:15,859 INFO  [MCKernelAbstraction]   and supplies:
22:27:15,859 INFO  [MCKernelAbstraction]        Class:enterprise.servlet_stateless_ejb.StatelessSession
22:27:16,843 INFO  [EJBContainer] STARTED EJB: enterprise.servlet_stateless_ejb.StatelessSessionBean ejbName:
StatelessSessionBean
22:27:16,984 INFO  [TomcatDeployment] deploy, ctxPath=/ServletStateless-war, vfsUrl=ServletStateless.ear/Servl
etStateless-war.war

7. Enter the following URL in the browser. Or inside NetBeans right click project node and choose Run.
http://localhost:8080/ServletStateless-war/servlet, you will see this:

 Servlet2Stateless:: Please enter your name

Some notes:

1. Deploying this simple EAR to JBoss default config doesn't work. I had these errors:

22:22:27,937 INFO  [EJBContainer] STARTED EJB: enterprise.servlet_stateless_ejb.StatelessSessionBean ejbName:
StatelessSessionBean
22:22:28,171 WARN  [HDScanner] Failed to process changes
org.jboss.deployers.client.spi.IncompleteDeploymentException: Summary of incomplete deployments (SEE PREVIOUS
ERRORS FOR DETAILS):

*** CONTEXTS MISSING DEPENDENCIES: Name - Dependency{Required State:Actual State}

jboss.web.deployment:war=/ServletStateless-war
- jboss.cache:service=TomcatClusteringCache{Start:** NOT FOUND **}
- jboss.cache:service=TomcatClusteringCache{Create:** NOT FOUND **}


*** CONTEXTS IN ERROR: Name - Error

jboss.cache:service=TomcatClusteringCache - ** NOT FOUND **


      at org.jboss.deployers.plugins.deployers.DeployersImpl.checkComplete(DeployersImpl.java:576)
      at org.jboss.deployers.plugins.main.MainDeployerImpl.checkComplete(MainDeployerImpl.java:559)
      at org.jboss.system.server.profileservice.hotdeploy.HDScanner.scan(HDScanner.java:291)
      at org.jboss.system.server.profileservice.hotdeploy.HDScanner.run(HDScanner.java:221)
      at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:441)
      at java.util.concurrent.FutureTask$Sync.innerRunAndReset(FutureTask.java:317)
      at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:150)

Maybe because JBoss 5 is still at beta 4?

2. In my NetBeans, I set Glassfish as my default target appserver. Your NetBeans should have one target appserver, and I remember NetBeans also supports JBoss, Webspere, WebLogic with plugins. In my projects I also see various deployment descriptors auto-generated by NetBeans. For this simple project you only need web.xml (to specify servlet mapping) and other *.xml files are all redundant.

3. This is the line that injects bean reference to servlet class:


@EJB private StatelessSession sless;

Install FindBugs plugin in NetBeans 6

2008-03-24T13:44:00.002-04:00

To install FindBugs in NetBeans 6, the basic idea is to add an updatecenter configuration to NetBeans plugin manager. It will then periodically keep your installed plugin updated. These are the steps that worked for me. Note that these steps will install FindBugs + PMD + CheckStyle co-bundled plugins.

1, Go to NetBeans Tools -> plugins, click Settings tab. It shows a list of existing update centers like 3rd Party Plugins, NetBeans, NetBeans Beta, Plugin Portal.

2, Click Add button on the right side. You will see a Update Center Customizer popup, asking for Name and URL. Enter the following values. You may also enable Check for updates automatically.

Name: SQE Update Center
URL: https://sqe.dev.java.net/updatecenters/sqe/updates.xml

3, Click OK and you will see it is added the the list of update centers. Otherwise, most likely your network proxy is not properly configured. You can also manually verify the above URL in the browser.

4, Click Available Plugins tab, and then click the Reload Catalog button beneath the tab. After a short while, you will see a long list (close to 100) plugins. Plugins that are already installed are not included here.

5, Click Category column head to sort them. Notice 3 plugins under Quality category: SQE Java, SQE Update Center, SQE Platform.

6, Select all 3 plugins and click Install button. The rest is just clicking a few OK buttons. At the end, you will see 4 new icons on your tool bar: Check Quality, Run FindBugs, Run PMD, Run CheckStyle.

sqe (Software Quality Environment) is a java.net project. It also has instructions for integrate these tools with NetBeans here. But this page is slightly dated, with an invalid updatecenter URL (https://sqe.dev.java.net/updatecenters/sqe/catalog.xml). That page consists largely of screen shots and no way to copy that URL, which is the most critical data.

In sqe home page under Announcement section, it does mention that:

There is a new updatecenter url for NetBeans6 Beta 1 or later compatible development builds (pre-alpha) https://sqe.dev.java.net/updatecenters/sqe/updates.xml.This should allow the PluginManager to detect SQE as as 3 plugins (all other modules are hidden)!

Enum wrapper for javax.transaction.Status (2)

2008-03-23T10:25:00.005-04:00

In this previous post, I wrote about a enum type wrapper around javax.transaction.Status. It uses a static map to hold the mapping between integer status code and enum type. Here is a slightly shorter (better) implementation without using a static mapping. The commented lines are original code:

package javahowto;
import java.util.EnumSet;
import javax.transaction.Status;

public enum TransactionStatusEnum {
   STATUS_ACTIVE           (Status.STATUS_ACTIVE),
   STATUS_COMMITTED        (Status.STATUS_COMMITTED),
   STATUS_COMMITTING       (Status.STATUS_COMMITTING),
   STATUS_MARKED_ROLLBACK  (Status.STATUS_MARKED_ROLLBACK),
   STATUS_NO_TRANSACTION   (Status.STATUS_NO_TRANSACTION),
   STATUS_PREPARED         (Status.STATUS_PREPARED),
   STATUS_PREPARING        (Status.STATUS_PREPARING),
   STATUS_ROLLEDBACK       (Status.STATUS_ROLLEDBACK),
   STATUS_ROLLING_BACK     (Status.STATUS_ROLLING_BACK),
   STATUS_UNKNOWN          (Status.STATUS_UNKNOWN);
  
//    private static Map<Integer, TransactionStatusEnum> codeToEnums
//        = new HashMap<Integer, TransactionStatusEnum>();
//   
//    static {
//        codeToEnums.put(Status.STATUS_ACTIVE, STATUS_ACTIVE);
//        codeToEnums.put(Status.STATUS_COMMITTED, STATUS_COMMITTED);
//        codeToEnums.put(Status.STATUS_COMMITTING, STATUS_COMMITTING);
//        codeToEnums.put(Status.STATUS_MARKED_ROLLBACK, STATUS_MARKED_ROLLBACK);
//        codeToEnums.put(Status.STATUS_NO_TRANSACTION, STATUS_NO_TRANSACTION);
//        codeToEnums.put(Status.STATUS_PREPARED, STATUS_PREPARED);
//        codeToEnums.put(Status.STATUS_PREPARING, STATUS_PREPARING);
//        codeToEnums.put(Status.STATUS_ROLLEDBACK, STATUS_ROLLEDBACK);
//        codeToEnums.put(Status.STATUS_ROLLING_BACK, STATUS_ROLLING_BACK);
//        codeToEnums.put(Status.STATUS_UNKNOWN, STATUS_UNKNOWN);
//    }
  
   private Integer statusCode;
  
   public Integer getStatusCode() {
       return statusCode;
   }
  
   public static TransactionStatusEnum getEnumFor(Integer i) {
//        return codeToEnums.get(i);
       for(TransactionStatusEnum t : EnumSet.allOf(TransactionStatusEnum.class)) {
           if(t.statusCode == i) {
               return t;
           }
       }
       throw new IllegalArgumentException("Invalid transaction status code: " + i);
   }
  
   @Override public String toString() {
       return super.toString() + "(" + statusCode + ")";
   }
  
   private TransactionStatusEnum(int statusCode) {
       this.statusCode = statusCode;
   }
}

The output from the testcase in the previous post:

status code -> enum:
STATUS_ACTIVE(0)
STATUS_MARKED_ROLLBACK(1)
STATUS_PREPARED(2)
STATUS_COMMITTED(3)
STATUS_ROLLEDBACK(4)
STATUS_UNKNOWN(5)
STATUS_NO_TRANSACTION(6)
STATUS_PREPARING(7)
STATUS_COMMITTING(8)
STATUS_ROLLING_BACK(9)

enum -> status code:
STATUS_ACTIVE(0) 0
STATUS_COMMITTED(3) 3
STATUS_COMMITTING(8) 8
STATUS_MARKED_ROLLBACK(1) 1
STATUS_NO_TRANSACTION(6) 6
STATUS_PREPARED(2) 2
STATUS_PREPARING(7) 7
STATUS_ROLLEDBACK(4) 4
STATUS_ROLLING_BACK(9) 9
STATUS_UNKNOWN(5) 5

A third approach is to combine the above 2 approaches by building the mapping inside getEnumFor method so that subsequent calls may not need to iterate over all elements. This can be useful if the enum type has many elements. getEnumFor can be rewritten as:

public static synchronized TransactionStatusEnum getEnumFor(Integer i) {
   TransactionStatusEnum en = codeToEnums.get(i);
   if (en == null) {
       for (TransactionStatusEnum t : values()) {
           if (t.statusCode == i) {
               en = t;
               codeToEnums.put(i, t);
               break;
           }
       }
   }
   if (en == null) {
       throw new IllegalArgumentException("Invalid transaction status code: " + i);
   }
   return en;
}

How to initialize a list when declaring it

2008-03-11T15:11:00.005-04:00

With array, we can easily declare and initialize it at the same time:

String[] favorites = new String[] {"EJB", "JPA", "Glassfish", "NetBeans"};

Or even simpler:

String[] favorites = {"EJB", "JPA", "Glassfish", "NetBeans"};

We can do the same with a List using java.util.Arrays.asList method. For example:

package javahowto;

import java.util.Arrays;
import java.util.List;

public class ListTest {
  public static final List<String> favorites =
        Arrays.asList("EJB", "JPA", "Glassfish", "NetBeans");

  public static void main(String[] args){
      System.out.println("favorites: " + favorites);
  }
}

UnsupportedOperationException and OperationNotSupportedException

2008-03-09T17:02:00.002-04:00

For some unimplemented methods, I want to throw some exception instead of leaving it blank. I know there is already such a class in Java but don't know its exact name. So I typed "Operation" and then Ctrl-Space to let NetBeans to complete it. But only javax.naming.OperationNotSupportedException showed up, which is not what I want. After some search, it turns out the right class is java.lang.UnsupportedOperationException. Description from its javadoc:

java.lang.Object
 java.lang.Throwable
     java.lang.Exception
         java.lang.RuntimeException
             java.lang.UnsupportedOperationException

All Implemented Interfaces:: Serializable

Direct Known Subclasses:: HeadlessException, ReadOnlyBufferException

public class UnsupportedOperationException
extends RuntimeException
extends RuntimeException

Thrown to indicate that the requested operation is not supported.

This class is a member of the Java Collections Framework.

Since:: 1.2

Access Weblogic DataSource remotely from Java and JRuby client

2007-12-11T14:16:00.001-05:00

In previous posts, I wrote how to access JBoss or Glassfish DataSource remotely from a java client (JBoss example and Glassfish example). Here is a simple program in Java and JRuby, how to do it in Weblogic 10, using the same appserver setup as Calling Weblogic EJB 3 from JRuby and java client.

package foo;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;

public class DataSourceClient {
    public static void main(String[] args) throws Exception {
        String sql = "SELECT id FROM MEDRECWLSTORE";
        Context ic = new InitialContext();
        DataSource dataSource = 
          (DataSource) ic.lookup("jdbc/MedRecGlobalDataSource");
        System.out.println("lookup dataSource returned " + dataSource);
        Connection connection = dataSource.getConnection();
        System.out.println("Got connection: " + connection);

        Statement stmt = connection.createStatement();
        ResultSet rs = stmt.executeQuery(sql);
        while(rs.next()) {
            System.out.print(rs.getString(1) + " ");
        }
    }
}

To do the equivalent in JRuby with less code (testDataSourceWeblogic.rb):

require 'java'
include_class 'javax.naming.InitialContext'

sql = "SELECT id FROM MEDRECWLSTORE"
ic = InitialContext.new
data_source = ic.lookup("jdbc/MedRecGlobalDataSource")
puts "lookup DataSource returned #{data_source}"
connection = data_source.getConnection
puts "Got connection #{connection}"
stmt = connection.createStatement
rs = stmt.executeQuery(sql)
while rs.next
    print rs.getString(1) + " "
end

Set environment variable CLASSPATH for JRuby. Currently this is the only way to pass java classpath to JRuby (jruby1.0.2). Since I need to set CLASSPATH anyway, I will use it for compiling and running java client as well.

set CLASSPATH=%WL_HOME%\server\lib\weblogic.jar;%WL_HOME%\server\lib\api.jar;C:\simple-ejb3\classes

prepare jndi.properties somewhere in client classpath, e.g., simple-ejb3\classes directory:

java.naming.factory.initial=weblogic.jndi.WLInitialContextFactory
java.naming.provider.url=t3://localhost:7011

7011 is the default port for t3, iiop, ldap and http for the sample MedRecServer. Your port number may be different.

Compile and run java client:

C:\simple-ejb3\classes > javac -d . ..\src\foo\DataSourceClient.java
C:\simple-ejb3\classes > java foo.DataSourceClient

Run JRuby client:

jruby testDataSourceWeblogic.rb

Both clients will produce the following output, if run successfully:

lookup DataSource returned ClusterableRemoteRef(-4637547633404831470S:localhost:[7011,7011,-1,-1,-1,-1,-1]:medrec:MedRecServer [-4637547633404831470S:localhost:[7011,7011,-1,-1,-1,-1,-1]:medrec:MedRecServer/286])/286
Got connection weblogic.jdbc.rmi.SerialConnection_weblogic_jdbc_rmi_internal_ConnectionImpl_weblogic_jdbc_wrapper_PoolConnection_com_pointbase_net_netJDBCConnection30_1001_WLStub@1
-1 1 2 3 4 5 6 7 8 9 10 134217727 268435454 402653181 536870908 671088635 805306362 939524089 1073741816 1207959543 1342177270 1476394997 1610612724 1744830451 1879048178 2013265905 214748363

Note that iiop protocol is not supported when accessing remote DataSource on Weblogic. Using iiop will cause the following failure:

Exception in thread "main" java.lang.ClassCastException: weblogic.jdbc.common.internal.ConnectionEnv cannot be cast to java.io.Serializable
        at weblogic.iiop.InboundResponseImpl.unmarshalReturn(InboundResponseImpl.java:103)
        at weblogic.rmi.cluster.ClusterableRemoteRef.invoke(ClusterableRemoteRef.java:338)
        at weblogic.rmi.cluster.ClusterableRemoteRef.invoke(ClusterableRemoteRef.java:252)
        at weblogic.jdbc.common.internal.RemoteDataSource_IIOP_WLStub.getConnection(Unknown Source)
        at foo.DataSourceClient.main(DataSourceClient.java:12)
Caused by: java.lang.ClassCastException: weblogic.jdbc.common.internal.ConnectionEnv cannot be cast to java.io.Serializable
        at weblogic.iiop.IIOPOutputStream.writeObject(IIOPOutputStream.java:2253)

Technorati Tags: weblogic, DataSource, JRuby

Calling Weblogic EJB 3 from JRuby and java client

2007-12-07T15:11:00.001-05:00

This is a continuation of Calling EJB 3 from JRuby client and Calling JBoss EJB 3 from JRuby client. This post will show how to do it with Weblogic application server 10.

1. project directory structure:

C:\simple-ejb3> tree /A /F
+---classes
|   \---foo
\---src
   \---foo
          Client.java
          FooBean.java
          FooRemote.java

2. create EJB remote business interface and bean class under src\foo:

package foo;
import javax.ejb.*;

@Remote
public interface FooRemote {
public String echo(String s);
}
------------
package foo;
import javax.ejb.*;

@Stateless
public class FooBean implements FooRemote {
public String echo(String s) {
 return s;
}
}

3 createJRuby script (testEJBWeblogic.rb) or java client, which is almost identical to the one for glassfish and JBoss, except the default jndi name.

Note that the jndi name I'm using below is not user-friendly, but I found this is the one that always worked. I also tried using the default jndi name for weblogic EJB3 but didn't find any in admin console's View JNDI Tree. Weblogic doesn't seem to fully honor mappedName either. When I specified mappedName="FooBean", the actual jndi name after deployment is FooBean/foo.FooRemote, with the remote business interface name appended to mappedName value.

package foo;
import javax.ejb.*;
import javax.naming.*;

public class Client {
    public static void main(String[] args) throws Exception {
        Context ic = new InitialContext();
        Object obj = ic.lookup("_appsdir_foo-ejb_jarfoo-ejb_jarFooBean_FooRemote");

        //the above jndi name is the default one used by weblogic server.
        //You can check ejb jndi-name in 
        //admin console | environment | servers | MedRecServer(admin) | view JNDI tree
        //You can also customize the jndi name with @Stateless(mappedName="myname")

        FooRemote foo = (FooRemote) obj;
        String s = foo.echo("Hello Foo!");
        System.out.println(foo + " echo returned " + s);
    }
}

==== testEJBWeblogic.rb ====
require 'java'
include_class 'javax.naming.InitialContext'

ic = InitialContext.new
foo = ic.lookup("_appsdir_foo-ejb_jarfoo-ejb_jarFooBean_FooRemote")
result = foo.echo("This is foo!")
puts "Calling the EJB 3 : #{foo} returned #{result}"

4. compile java src. An environment variable WL_HOME is set for convenience but it's not required.

C:\simple-ejb3\classes> set WL_HOME=C:\bea\wlserver_10.0
C:\simple-ejb3\classes> javac -d . -classpath %WL_HOME%\server\lib\weblogic.jar;%WL_HOME%\server\lib\api.jar;. ..\src\foo\*.java

5. start Weblogic server. I will use the sample medrec server to deploy the EJB:

%WL_HOME%\samples\domains\medrec\startWebLogic

6. package and autodeploy ejb-jar. We can combine the 2 steps in 1 by using %WL_HOME%\samples\domains\medrec\autodeploy as the destdir:

C:\simple-ejb3\classes> 
jar cvf %WL_HOME%\samples\domains\medrec\autodeploy\foo-ejb.jar
foo\FooBean.class foo\FooRemote.class

7. start the EJB3 in the admin console http://localhost:7011/console, login with username "weblogic" and password "weblogic". Select Deployments on the left, then _appsdir_foo-ejb_jar (autodeployed) on the right, and click start button.

Alternatively, you can deploy and start the ejb app with weblogic.Deployer class:

java -cp %WL_HOME%\server\lib\weblogic.jar weblogic.Deployer -adminurl t3://localhost:7011 -username weblogic -password weblogic -deploy foo-ejb.jar

8. prepare jndi.properties somewhere in client classpath, e.g., simple-ejb3\classes directory:

java.naming.factory.initial=weblogic.jndi.WLInitialContextFactory
java.naming.provider.url=iiop://localhost:7011

Note that weblogic server listens on port 7011 for iiop, t3 and http protocols. So using t3://localhost:7011 works as well. If you use the sample wl_server instead of medrec server, the default port is 7001.

9. run JRuby client. Before running the script, we need to set the environment variable CLASSPATH, which is of course different from the one for glassfish and JBoss.

set CLASSPATH=%WL_HOME%\server\lib\weblogic.jar;%WL_HOME%\server\lib\api.jar;C:\simple-ejb3\classes
jruby testEJB.rb

The test output:

Calling the EJB 3 : Delegate(602878) [weblogic.iiop.IOR[RMI:foo.FooBean_my4bwg_FooRemoteIntf:0000000000000000] @localhost:7011, <337, null>] returned This is foo!

The command to run java client (no -cp nor -classpath is needed since we already set CLASSPATH:

java foo.Client

Technorati Tags: EJB3, weblogic, JRuby