Example :

Take a look at org.jboss.tutorial.asynch.bean.Echo and org.jboss.tutorial.asynch.bean.EchoBean. They define a normal stateless session bean with a remote interface, nothing special. Now take a look at org.jboss.tutorial.asynch.client.Client. It shows an example of asynchronous calls on a remote interface. We will walk through what it does here. The following lines just obtain the remote interface of the bean and call a method following the standard synchronous usage pattern:

      			
InitialContext ctx = new InitialContext();
Echo echo = (Echo) ctx.lookup("EchoBean/remote");
System.out.println("-------- Synchronous call");
String ret = echo.echo("normal call");
System.out.println(ret);

      			

      		

Next we obtain the asynchronous proxy and make a call via that. The method will be invoked asynchronously :

      			
Echo asynchEcho = org.jboss.ejb3.common.proxy.plugins.async.AsyncUtils.mixinAsync(echo);
System.out.println("-------- Asynchronous call");
ret = asynchEcho.echo("asynchronous call");
System.out.println("Direct return of async invocation is: " + ret);

      			
      		

We use the org.jboss.ejb3.common.proxy.plugins.async.AsyncUtils's mixinAsync method to create the asynchronous proxy. All methods invoked on this proxy are invoked asynchronously, and the returned value will always be null (or 0 in the case of numeric primitive types). In this example, the echo() method called has low overhead, but imagine if this was a method that took a long time. In this case it would be good to be able to go ahead with some other tasks.

In Client.java, we make another call on the normal remote interface while "waiting" for the asynchronous call:

      			
System.out.println("-------- Synchronous call");
ret = echo.echo("normal call 2");
System.out.println(ret);
      			
      		

Now that we have finished everything we want to do, while waiting for the asynchronus call to complete, we invoke the getFutureResult(asynchProxy) API on the org.jboss.ejb3.common.proxy.plugins.async.AsyncUtils. This will return us an instance of java.util.concurrent.Future. To obtain the final result of the asynchronous call, we invoke the get() API on the returned java.util.concurrent.Future object.

      			
System.out.println("-------- Result of Asynchronous call");
Future<String> future = (Future<String>) AsyncUtils.getFutureResult(asynchEcho);

// blocking call
ret = (String) future.get();
System.out.println(ret);