Skip navigation


Although this latest release of JBoss Remoting does not have an interesting code name, like “Wasabi” or “Blade”, it does have some interesting new features. For example, a multiplex transport has been added which supports multiple streams of communication over a single pair of sockets. This allows servers to send callbacks to a client on a network connection initiated by the client, thus by-passing the headaches that can be involved when clients are running in unknown or restrictive environments.


Another big change is the use of the Apache Tomcat connectors for the http transport implementation, to provide full HTTP 1.1 support. Therefore, most any configuration allowed for Tomcat can be configured for the remoting HTTP server invoker. This includes being able to swap out the Tomcat protocol implementations being used, so can use the default Java protocol implementation or the native protocol implementation based on the Apache Portable Runtime.


JBoss Remoting also now allows for plugging in of custom serialization implementations. By default, the standard Java serialization is used, but can easily be configured to use JBoss Serialization. JBoss Serialization is a new project under development to provide a more performant implementation of object serialization. One of the main benefits of using JBoss Serialization, besides being faster, is allows for sending of non-serializable objects over the network.


Please check out the JBoss Remoting user guide for more information on features and configuration options as well as the samples guide for some examples of how easy it is to use JBoss Remoting.

The JBossRemoting 1.2.0 release is now available.

Some of the new features include:
  • SSL Support
  • Support for HTTP/HTTPS proxy and basic authentication (direct and via proxy)
  • Sending of input streams
  • Servlet based invoker
  • Pluggable custom socket factories
  • Pluggable thread pools
  • Connection failure detection (even on idle clients)
  • Persistence of pull callback messages

This release includes many enhancements to current features and some bug fixes as well. See release notes for further details.

If you are not already familiar with the JBossRemoting project, check out the architecture overview for a quick rundown.

Visit the JBossRemoting project page for more information on the project.
After having been at JBoss for a while, I was surprise to see that there were not more people that volunteered to contribute to open source projects. At the time I just chalked it up to being a lack of time, money, or something like that which was really out the control of the open source community.



Recently I had someone who contacted me about contributing to the JBoss Remoting project and as I talked with him about the project, such as how to set up the project, where to get the documentation, how to lookup coding tasks, etc., he kept thanking me for my help. Finally I had to tell him that it was he who was helping me by contributing and that I would do whatever I could to help him. Besides him being a capable and nice guy, it was in my best interest for him to have everything I could reasonably afford to give. To me, this just made sense.



He then told me about a previous experience he had with another open source group and how it had left a bad taste in his mouth. The problems ranged from just getting help to make the build work to getting a project lead to respond to e-mails. One of his last comments pretty much summed it up for me, “yeah, its pretty much a very tight group.. who dont like "intruders" :) ”.



So am now starting to wonder if the reason more developers don’t contribute to open source projects is that they have the perception, real or not, that they are not welcome. It is certainly disappointing to think this might be their real reason as it is definitely not the case at JBoss. All you need is a compiler and a chair. Ok, it isn’t exactly that easy, but we really do want developers to contribute and to help in that process. For me, this is what open source is all about. Professional open source is even better since it takes a step further and removes the other barriers I talked about earlier (time and money).



So developers, take heed, the welcome mat is out for you at JBoss.



To find out how to get involved in the JBoss projects, visit our community page at






JBossRemoting 1.0.1 final has been released. This release includes bug fixes, remote loading of marshalling resources, memory management and persistent stores for callbacks. This will be the same version that is included in the JBoss AS 4.0.2 release that is due out soon.


There has also been a great article written by John Mazzitelli published at which provides a great introduction to JBossRemoting. It covers how to setup a remoting client and server, making invocations, and handling of callbacks. Is a good read for those who want to get a quick overview JBossRemoting without having to read the user guide.


The way software systems make calls from one system to another is pretty much the same, regardless of implementation. One system sends data to another and either does or does not expect data in return. I know this is greatly simplifying it, but wouldn’t it be great if it were that simple. This is the purpose of JBoss Remoting; to provide a framework with a single, simple API for most network based invocations and related services. This allows for users to change the transport protocol (i.e. socket, http, or rmi) as well as data marshalling format (i.e. serialization, iiop, or jaxrpc) for their remote invocations without ever having to change their code.


The design of JBoss Remoting is such that the user only needs a simple url string in order to be able to identify and call upon any remote server. For example, the string ‘socket://’ is all the information that is needed to make a call on the JBoss Remoting server using the socket transport on host, which is listening on port 5400.


On the server side, the user only needs to implement a simple invoke method that the remoting server will call upon with it receives a remote invocation. This invoke method implementation will remain the same, regardless of any transport or marshalling changes.


Setting up a remoting server is easy. The following shows the code from the samples in the remoting release for configuring and starting a remoting server.




String locatorURI = “socket” + "://" + “localhost + ":" + 5400;


Connector connector = new Connector();








SampleInvocationHandler invocationHandler = new SampleInvocationHandler();


connector.addInvocationHandler("sample", invocationHandler);




Making a call on this server is just as easy to code:




String locatorURI = “socket” + "://" + “localhost” + ":" + 5400;


InvokerLocator locator = new InvokerLocator(locatorURI);


Client remotingClient = new Client(locator);


Object response = remotingClient.invoke("Do something");




That’s all there is to it. To change between from using a socket based transport to http, just change the “socket” string to “http”.


JBoss Remoting 1.0.1 beta has just been released. See the project page ( for more info on remoting (including full user’s guide, demo, and distribution). To wet your appetite, here is a list of features included in JBoss Remoting:

  • Server identification – a simple String identifier which allows for remoting servers to be identified and called upon.
  • Pluggable transports – can use different protocol transports, such as socket, rmi, http, etc., via the same remoting API.
  • Pluggable data marshallers – can use different data marshallers and unmarshallers to convert the invocation payloads into desired data format for wire transfer.
  • Automatic discovery – can detect remoting servers as they come on and off line.
  • Server grouping – ability to group servers by logical domains, so only communicate with servers within specified domains.
  • Callbacks – can receive server callbacks via push and pull models.
  • Asynchronous calls – can make asynchronous, or one way, calls to server.
  • Local invocation – if making an invocation on a remoting server that is within the same process space, remoting will automatically make this call by reference, to improve performance.