Getting Started with JBoss 4.0

Release 5

Table of Contents

About this book
What this Book Covers
1. Getting Started
1.1. Downloading and Installing JBoss
1.2. Starting the Server
1.3. The JMX Console
1.4. Stopping the Server
1.5. Running as a Service
2. The JBoss Server - A Quick Tour
2.1. Server Structure
2.1.1. Main Directories
2.1.2. Server Configurations
2.2. Basic Configuration Issues
2.2.1. Core Services
2.2.2. Logging Service
2.2.3. Security Service
2.2.4. Additional Services
2.3. The Web Container - Tomcat
3. About the Example Applications
3.1. The J2EE Tutorial
3.2. What’s Different?
3.2.1. Container-Specific Deployment Descriptors
3.2.2. Database Changes
3.2.3. Security Configuration
3.3. J2EE in the Real World
4. The Duke’s Bank Application
4.1. Building the Application
4.1.1. Preparing the Files
4.1.2. Compiling the Java Source
4.1.3. Package the EJBs
4.1.4. Package the WAR File
4.1.5. Package the Java Client
4.1.6. Assembling the EAR
4.1.7. The Database Enabling the HSQL MBean and TCP/IP Connections Creating the Database Schema The HSQL Database Manager Tool
4.1.8. Deploying the Application
4.2. JNDI and Java Clients
4.2.1. The File
4.2.2. Application JNDI Information in the JMX Console
4.3. Security
4.3.1. Configuring the Security Domain
4.3.2. Security Using a Database
4.3.3. Using Password Hashing
5. J2EE Web Services
5.1. Web services in JBoss
5.2. Duke’s Bank as a Web Service
5.3. Running the Web Service Client
5.4. Monitoring webservices requests
6. JMS and Message-Driven Beans
6.1. Building the Example
6.1.1. Compiling and Packaging the MDB and Client Specifying the Source Queue for the MDB
6.2. Deploying and Running the Example
6.3. Managing JMS Destinations
6.3.1. The jbossmq-destinations-service.xml File
6.3.2. Using the DestinationManager from the JMX Console
6.3.3. Administering Destinations
7. Container-Managed Persistence
7.1. Building the Example
7.2. Deploying and Running the Application
7.2.1. Running the Client
7.3. CMP Customization
7.3.1. XDoclet
8. Using other Databases
8.1. DataSource Configuration Files
8.2. Using MySQL as the Default DataSource
8.2.1. Creating a Database and User
8.2.2. Installing the JDBC Driver and Deploying the DataSource
8.2.3. Testing the MySQL DataSource
8.3. Setting up an XADataSource with Oracle 9i
8.3.1. Padding Xid Values for Oracle Compatibility
8.3.2. Installing the JDBC Driver and Deploying the DataSource
8.3.3. Testing the Oracle DataSource
9. Using Hibernate
9.1. Creating a Hibernate archive
9.2. Using the hibernate objects
9.3. Packaging the complete application
9.4. Deploying Running the application
A. Further Information Sources

About this book

The goal of this book is to get you up and running J2EE 1.4 applications on JBoss 4.0 as quickly as possible. At the time of writing, the latest release is version 4.0.4. You should use this version or later with the examples. We will use update 7 of Sun’s J2EE 1.4 tutorial examples ( to illustrate the deployment and configuration of J2EE applications in JBoss. While the book is not intended to teach you J2EE, we will be covering the subject from quite a basic standpoint, so it will still be useful if you are new to J2EE. If you would like to use JBoss to run the standard Sun J2EE tutorials then this is the book for you. It should ideally be read in parallel with the tutorial texts.

What this Book Covers

Chapter 1, Getting Started will show you how to install and run JBoss. Then Chapter 2, The JBoss Server - A Quick Tour will provide a quick tour of the server directory structure and layout, the key configuration files and services. Finally, Chapter 3, About the Example Applications introduces the J2EE tutorial code that is used throughout out the book.

Moving on to the examples, Chapter 4, The Duke’s Bank Application introduces the Duke’s Bank application from the Sun J2EE Tutorial. You will see JBoss in action get some exposure simple configuration and deployment issues. Chapter 5, J2EE Web Services adds web services to the application. We work through how to expose EJB methods from the Duke’s Bank application through web services and then call them with a Java client.

After that, Chapter 6, JMS and Message-Driven Beans and Chapter 7, Container-Managed Persistence show additional applications showing JMS messaging with message-driven beans and a more in-depth container-managed persistence example.

Chapter 8, Using other Databases explores database configuration using MySQL and Oracle as the database. We end with Chapter 9, Using Hibernate, which shows how to use Hibernate with JBoss. The example applies Hibernate persistence to one of the earlier applications.

Of course, that barely scratches the surface of what you can do with JBoss. Once you feel comfortable with the information here, the JBoss 4 Application Server Guide can take you the rest of the way to total mastery of the JBoss.

Chapter 1. Getting Started

1.1. Downloading and Installing JBoss

Before you download and run JBoss make sure you have an up-to-date version of Java on your machine. JBoss 4.0 requires either a Java 1.4 or Java 5 JVM. We recommend Java 5 for overall performance and the ability to work with the newer EJB3/Java EE 5 technologies. A full JDK install is not required to run JBoss, but you will need a full JDK to build and run the tutorial examples. Before gettings started, make sure you have an appropriate JDK installed and that your JAVA_HOME environment variable is set to the directory where you installed Java.

The JBoss application server is available as a free download from the JBoss website. ( We provide both binary, source, and Web Start distributions. If you are just getting started with JBoss, the easiest way to get going is to use the Java Web Start Installer.

The binary versions are available as a .zip archive, for example. Once it's downloaded, unpack the archive to a suitable location on your machine. It should all unpack into a single directory named jboss-4.0.4. Of course the version number suffix will be different if you are running a later release. Make sure you don't use a directory which has any spaces in the path (such as the Program Files directory on Windows) as this may cause problems.

The installer versions are available as executable JAR files. The installer can also be launched using Web Start by following the Run Installer links from the JBoss AS downloads page. Follow the instructions of each page of the installer wizard and make sure you choose the All option on the Server Profile page, the configuration name default on the Configuration Name page and go ahead and select all the check boxes and then set a password for the admin account on the JMX Security page. The rest of the pages are pretty self explanatory.

1.2. Starting the Server

Our first step is to try running the server. You'll find a bin directory inside the main JBoss directory which contains various scripts. Execute the run script (run.bat if you're on Windows, if you're on Linux, OS X, or another UNIX-like system). You should then see the log messages from all the JBoss components as they are deployed and started up. The last message (obviously with different values for the time and start-up speed) should look like the following.

13:52:00,183 INFO  [Server] JBoss (MX MicroKernel)
[4.0.4.GA (build: CVSTag=JBoss_4_0_4_GA date=200605111311)] Started in 31s:941ms


You can verify that the server is running by going the JBoss web server, which is running on port 8080. (Make sure you don't have anything else already on your machine using that port) The default page has links to a few useful JBoss resources.

1.3. The JMX Console

You can get a live view of the server by going to the JMX console application at http://localhost:8080/jmx-console [1]. You should see something similar to Figure 1.1, “View of the JMX Management Console Web Application”.

This is the JBoss Management Console which provides a raw view of the JMX MBeans which make up the server. You don't really need to know much about these to begin with, but they can provide a lot of information about the running server and allow you to modify its configuration, start and stop components and so on.

For example, find the service=JNDIView link and click on it. This particular MBean provides a service to allow you to view the structure of the JNDI namespaces within the server. Now find the operation called list near the bottom of the MBean view page and click the invoke. The operation returns a view of the current names bound into the JNDI tree, which is very useful when you start deploying your own applications and want to know why you can’t resolve a particular EJB name.

View of the JMX Management Console Web Application

Figure 1.1. View of the JMX Management Console Web Application

Look at some of the other MBeans and their listed operations; try changing some of the configuration attributes and see what happens. With a very few exceptions, none of the changes made through the console are persistent. The original configuration will be reloaded when you restart JBoss, so you can experiment freely and shouldn’t be able to do any permanent damage.

1.4. Stopping the Server

To stop the server, you can type Ctrl-C or you can run the shutdown script (shutdown.bat or from the bin directory. Alternatively, you can use the management console. Look for type=Server under the jboss.system domain and invoke the shutdown operation.

1.5. Running as a Service

In a real deployment scenario, you won’t want to stop and start JBoss manually but will want it to run in the background as a service or daemon when the machine is booted up. The details of how to do this will vary between platforms and will require some system administration knowledge and root privileges.

On Linux or other UNIX-like systems, you will have to install a startup script (or get your system administrator to do it). There are examples in the JBoss bin directory called and which you can modify and use. On a Windows system, you can use a utility like Javaservice [2] to manage JBoss as a system service.

[1] Note that on some machines, the name localhost won’t resolve properly and you should use the local loopback address instead.

[2] Javaservice is freely available from

Chapter 2. The JBoss Server - A Quick Tour

2.1. Server Structure

Now that you’ve downloaded JBoss and have run the server for the first time, the next thing you will want to know is how the installation is laid out and what goes where. At first glance there seems to be a lot of stuff in there, and it’s not obvious what you need to look at and what you can safely ignore for the time being. To remedy that, we’ll explore the server directory structure, locations of the key configuration files, log files, deployment and so on. It’s worth familiarizing yourself with the layout at this stage as it will help you understand the JBoss service architecture so that you’ll be able to find your way around when it comes to deploying your own applications.

2.1.1. Main Directories

The binary distribution unpacks into a top-level jboss-4.0.4 directory. There are four sub-directories immediately below this:

  • bin: contains startup and shutdown and other system-specific scripts. We’ve already seen the run script which starts JBoss.

  • client: stores configuration and JAR files which may be needed by a Java client application or an external web container. You can select archives as required or use jbossall-client.jar.

  • docs: contains the XML DTDs used in JBoss for reference (these are also a useful source of documentation on JBoss configuration specifics). There are also example JCA (Java Connector Architecture) configuration files for setting up datasources for different databases (such as MySQL, Oracle, Postgres).

  • lib: JAR files which are needed to run the JBoss microkernel. You should never add any of your own JAR files here.

  • server: each of the subdirectories in here is a different server configuration. The configuration is selected by passing -c <config-name> to the run script. We’ll look at the standard server configurations next.

JBoss Directory Structure

Figure 2.1. JBoss Directory Structure

2.1.2. Server Configurations

Fundamentally, the JBoss architecture consists of the JMX MBean server, the microkernel, and a set of pluggable component services, the MBeans. This makes it easy to assemble different configurations and gives you the flexibility to tailor them to meet your requirements. You don’t have to run a large, monolithic server all the time; you can remove the components you don’t need (which can also reduce the server startup time considerably) and you can also integrate additional services into JBoss by writing your own MBeans. You certainly don’t need to do this to be able to run standard J2EE applications though. Everything you need is already there. You don’t need a detailed understanding of JMX to use JBoss, but it’s worth keeping a picture of this basic architecture in mind as it is central to the way JBoss works.

Within the server directory, you will find one or more configuration directories depending on which installer packages you choose when installing. If you ran the installer, you will only have a default configuration (This is because you choose a specific configuration in the installer for a setup like EJB3, EJB3 Clustered or J2EE 1.4 Full) and so the default configuration has all the services for the specific configuration you choose. If you downloaded a binary or source version you will see that there are three server configurations: all, default and minimal, each of which provides a different set of services. Not surprisingly, the default configuration is the one used if you don’t specify another one when starting up the server, so that’s the one we were running in the previous chapter. The configurations are explained below.

  • minimal: The minimal configuration contains the bare minimum services required to start JBoss. It starts the logging service, a JNDI server and a URL deployment scanner to find new deployments. This is what you would use if you want to use JMX/JBoss to start your own services without any other J2EE technologies. This is just the bare server. There is no web container, no EJB or JMS support.

  • default: The default configuration consists of the standard services needed by most J2EE applications. It does not include the JAXR service, the IIOP service, or any of the clustering services.

  • all: The all configuration starts all the available services. This includes the RMI/IIOP and clustering services, which aren’t loaded in the default configuration.

You can add your own configurations too. The best way to do this is to copy an existing one that is closest to your needs and modify the contents. For example, if you weren’t interested in using messaging, you could copy the default directory, renaming it as myconfig, remove the jms subdirectory and then start JBoss with the new configuration.

run -c myconfig

The directory server configuration you’re using, is effectively the server root while JBoss is running. It contains all the code and configuration information for the services provided by the particular configuration. It’s where the log output goes, and it’s where you deploy your applications. Let’s take a look at the contents of the default server configuration directory. If you haven’t tried running the server yet, then do so now, as a few of the sub-directories are only created when JBoss starts for the first time.

  • conf: This directory contains the jboss-service.xml file which specifies the core services. Also used for additional configuration files for these services.

  • data: This directory holds persistent data for services intended to survive a server restart. Serveral JBoss services, such as the embedded Hypersonic database instance, store data there.

  • deploy: The deploy directory contains the hot-deployable services (those which can be added to or removed from the running server) and applications for the current server configuration. You deploy your application code by placing application packages (JAR, WAR and EAR files) in the deploy directory. The directory is constantly scanned for updates, and any modified components will be re-deployed automatically. We’ll look at deployment in more detail later.

  • lib: This directory contains JAR files needed by this server configuration. You can add required library files here for JDBC drivers etc.

  • log: This is where the log files are written. JBoss uses the Jakarta log4j package for logging and you can also use it directly in your own applications from within the server.

  • tmp: The tmp directory is used for temporary storage by JBoss services. The deployer, for example, expands application archives in this directory.

  • work: This directory is used by Tomcat for compilation of JSPs.

The data, log, tmp and work directories are created by JBoss and won’t exist until you’ve run the server at least once.

We’ve touched briefly on the issue of hot-deployment of services in JBoss so let’s have a look at a practical example of this before we go on to look at server configuration issues in more detail. Start JBoss if it isn’t already running and take a look in the deploy directory again (make sure you’re looking at the one in the default configuration directory). Remove the mail-service.xml file and watch the output from the server:

13:10:05,235 INFO  [MailService] Mail service 'java:/Mail' removed from JNDI

Then replace the file and watch the JBoss re-install the service:

13:58:54,331 INFO  [MailService] Mail Service bound to java:/Mail

It's hot-deployment in action.

2.2. Basic Configuration Issues

Now that we’ve examined the layout of the JBoss server, we’ll take a look at some of the main configuration files and what they’re used for. All paths are relative to the server configuration directory (server/default, for example).

2.2.1. Core Services

The core services specified in the conf/jboss-service.xml file are started first when the server starts up. If you have a look at this file in an editor you'll see MBeans for various services including logging, security, JNDI (and the JNDIView service that we saw earlier). Try commenting out the entry for the JNDIView service. Please note that because the mbeans definition had nested comments, we had to comment out the mbean in in two sections, leaving the original comment as it was.

<!-- Section 1 commented out
<mbean code="org.jboss.naming.JNDIView"
    <!-- The HANamingService service name -->
<!-- Section two commented out
    <attribute name="HANamingService">jboss:service=HAJNDI</attribute>

If you then restart JBoss, you’ll see that the JNDIView service no longer appears in the JMX Management Console (JMX Console) listing. In practice, you should rarely, if ever, need to modify this file, though there is nothing to stop you adding extra MBean entries in here if you want to. The alternative is to use a separate file in the deploy directory, which allows your service to be hot deployable.

2.2.2. Logging Service

We mentioned already that log4j is used for logging. If you're not familiar with the log4j package and would like to use it in your applications, you can read more about it at the Jakarta web site. ( Logging is controlled from a central conf/log4j.xmlfile. This file defines a set of appenders, specifying the log files, what categories of messages should go there, the message format and the level of filtering. By default, JBoss produces output to both the console and a log file (server.log in the log directory).

There are 5 basic log levels used: DEBUG, INFO, WARN, ERROR and FATAL. The logging threshold on the console is INFO, which means that you will see informational messages, warning messages and error messages on the console but not general debug messages. In contrast, there is no threshold set for the server.log file, so all generated logging messages will be logged there. If things are going wrong and there doesn’t seem to be any useful information in the console, always check the log file to see if there are any debug messages which might help you track down the problem. However, be aware that just because the logging threshold allows debug messages to be displayed, that doesn't mean that all of JBoss will produce detailed debug information for the log file. You will also have to boost the logging limits set for individual categories. Take the following category for example.

<!-- Limit JBoss categories to INFO --> 
<category name="org.jboss"> 
    <priority value="INFO"/> 

This limits the level of logging to INFO for all JBoss classes, apart from those which have more specific overrides provided. If you were to change this to DEBUG, it would produce much more detailed logging output.

As another example, let’s say you wanted to set the output from the container-managed persistence engine to DEBUG level and to redirect it to a separate file, cmp.log, in order to analyze the generated SQL commands. You would add the following code to the log4j.xml file:

<appender name="CMP" class="org.jboss.logging.appender.RollingFileAppender"> 
    <errorHandler class="org.jboss.logging.util.OnlyOnceErrorHandler"/> 
    <param name="File" value="${jboss.server.home.dir}/log/cmp.log"/> 
    <param name="Append" value="false"/> 
    <param name="MaxFileSize" value="500KB"/> 
    <param name="MaxBackupIndex" value="1"/> 
    <layout class="org.apache.log4j.PatternLayout"> 
        <param name="ConversionPattern" value="%d %-5p [%c] %m%n"/> 
<category name="org.jboss.ejb.plugins.cmp"> 
    <priority value="DEBUG" /> 
    <appender-ref ref="CMP"/> 

This creates a new file appender and specifies that it should be used by the logger (or category) for the package org.jboss.ejb.plugins.cmp. This will be useful when we come to look at CMP (Chapter 7, Container-Managed Persistence).

The file appender is set up to produce a new log file every day rather than producing a new one every time you restart the server or writing to a single file indefinitely. The current log file is cmp.log. Older files have the date they were written added to the name. You will notice that the log directory also contains HTTP request logs which are produced by the web container.

2.2.3. Security Service

The security domain information is stored in the file login-config.xml as a list of named security domains, each of which specifies a number of JAAS [3] login modules which are used for authentication purposes in that domain. When you want to use security in an application, you specify the name of the domain you want to use in the application’s JBoss-specific deployment descriptors, jboss.xml and/or jboss-web.xml. We'll quickly look at how to do this to secure the JMX Console application that ship with JBoss.

We saw the JMX Console briefly in Section 1.3, “The JMX Console”. Almost every aspect of the JBoss server can be controlled through the JMX Console, so it is important to make sure that, at the very least, the application is password protected. Otherwise, any remote user could completely control your server. To protect it, we will add a security domain to cover the application. [4] This can be done in the jboss-web.xml file for the JMX Console, which can be found in deploy/jmx-console.war/WEB-INF/ directory. Uncomment the security-domain in that file, as shown below.


This links the security domain to the web application, but it doesn't tell the web application what security policy to enforce. What URLs are we trying to protect, and who is allowed to access them? To configure this, go to the web.xml file in the same directory and uncomment the security-constraint that is already there. This security constraint will require a valid user name and password for a user in the JBossAdmin group.

   A security constraint that restricts access to the HTML JMX console
   to users with the role JBossAdmin. Edit the roles to what you want and
   uncomment the WEB-INF/jboss-web.xml/security-domain element to enable
   secured access to the HTML JMX console.
            An example security config that only allows users with the
            role JBossAdmin to access the HTML JMX console web application

That's great, but where do the user names and passwords come from? They come from the jmx-console security domain we linked the application to. We've provided the configuration for this in the conf/login-config.xml.

<application-policy name="jmx-console">
        <login-module code=""
            <module-option name="usersProperties">
            <module-option name="rolesProperties">

This configuration uses a simple file based security policy. The configuration files are found in the conf/props directory of your server configuration. The usernames and passwords are stored in in the directory and take the form "username=password". To assign a user to the JBossAdmin group add "username=JBossAdmin" to the file. The existing file creates an admin user with the password admin. You'll want to remove that user or change the password to something stronger.

JBoss will re-deploy the JMX Console whenever you update its web.xml. You can check the server console to verify that JBoss has seen your changes. If you've configured everything correctly and re-deployed the application, the next time you try to access the JMX Console, JBoss will ask you for a name and password. [5]

The JMX Console isn't the only web based management interface to JBoss. There is also the Web Console. Although it's a Java applet, the corresponding web application can be secured in the same way as the JMX Console. The Web Console is in deploy/management/web-console.war. The only difference is that the Web Console is provided as a simple WAR file instead of using the exploded directory structure that the JMX Console did. The only real difference between the two is that editing the files inside the WAR file is a bit more cumbersome.

2.2.4. Additional Services

The non-core, hot-deployable services are added to the deploy directory. They can be either XML descriptor files, *-service.xml, or JBoss Service Archive (SAR) files. SARs contain both the XML descriptor and additional resources the service requires (e.g. classes, library JAR files or other archives), all packaged up a single archive.

Detailed information on all these services can be found in the JBoss 4 Application Server Guide, which also provides comprehensive information on server internals and the implementation of services such as JTA and the J2EE Connector Architecture (JCA).

2.3. The Web Container - Tomcat

JBoss now comes with Tomcat 5.5 as the default web container. The embedded Tomcat service is the expanded SAR jbossweb-tomcat55.sar in the deploy directory. All the necessary jar files needed by Tomcat can be found in there, as well as a web.xml file which provides a default configuration set for web applications. If you are already familiar with configuring Tomcat, have a look at the server.xml, which contains a subset of the standard Tomcat format configuration information. As it stands, this includes setting up the HTTP connector on the default port 8080, an AJP connector on port 8009 (can be used if you want to connect via a web server such as Apache) and an example of how to configure an SSL connector (commented out by default).

You shouldn’t need to modify any of this other than for advanced use. If you’ve used Tomcat before as a stand-alone server you should be aware that things are a bit different when using the embedded service. JBoss is in charge and you shouldn’t need to access the Tomcat directory at all. Web applications are deployed by putting them in the JBoss deploy directory and logging output from Tomcat can be found in the JBoss log directory.

[3] The Java Authentication and Authorization Service. JBoss uses JAAS to provide pluggable authentication modules. You can use the ones that are provided or write your own if have more specific requirements.

[4] If you had installed JBoss using Web Start and set the JMX Security up, then you will not have to uncomment the sections, because they are already uncommented. Additionally, the admin password will be set up to whatever you had specified.

[5] Since the username and password are session variables in the web browser you may need to shut down your browser and come back in to see the login dialog come back up.

Chapter 3. About the Example Applications

3.1. The J2EE Tutorial

To make it easy if your just starting out with J2EE using JBoss, we will make use of the example applications provided in the J2EE tutorial, in particular the Duke’s Bank application. The J2EE tutorial explains how to run the applications using the J2EE SDK Reference Implementation server. Our aim is to show how to deploy and run those same examples in JBoss, and we do so by supplementing the J2EE tutorial where necessary with JBoss-specific configuration information and deployment descriptors.

You can find the J2EE tutorial on-line at and the example code can be found downloaded from You should download update 7 of the tutorial and Unpack/Uncompress the archive in a convenient location. You'll end up with a directory named j2eetutorial14. You can get the JBoss code on the JBoss documentation page, Unpack/Uncompress the JBoss example code into the J2EE tutorial directory j2eetutorial14. This code provides the JBoss specific configuration and deployment descriptors.

Additionally, we also use the Apache Ant build tool, which you should download and install. You can get an up-to-date copy of Ant from We recommend using version 1.6.2 or later with this tutorial. Ant is almost universally used in Java projects these days so if you aren’t already familiar with its use then we recommend you spend some time reading the documentation that comes with it and learning the basics of Ant build files. The default file name is build.xml, and it contains a set of targets which you can use to perform automated tasks in your project. Usually all you will have to do is run the Ant command in the directory which contains the build file. The default target in the file will perform the necessary operations to build and deploy the tutorial applications.

3.2. What’s Different?

J2EE technologies are designed so that the code is independent of the server in which the application is deployed. The deployment descriptors for EJBs and web applications (ejb-jar.xml and web.xml, respectively) are standard and also do not need to change between different J2EE containers. However, there are still one or two things that need to be done in order to move the application to JBoss. In particular, we have to supply JBoss-specific descriptors and make sure that the database scripts will work.

3.2.1. Container-Specific Deployment Descriptors

Container-specific information is usually contained in extra XML descriptors which map logical information used in the application (such as JNDI names and security role names) to actual values which are used in the server. JBoss uses separate files for the EJB and web modules of an application, called jboss.xml and jboss-web.xml respectively. There is also a client version of these files which fulfils the same role in a Java client, in combination with the J2EE application-client.xml descriptor. If container-managed persistence (CMP) is being used for entity EJBs, it is also possible to configure the JBoss persistence engine through the jbosscmp-jdbc.xml file.

3.2.2. Database Changes

The J2EE SDK comes with the Cloudscape database and this is used throughout the tutorials. We will be using the Hypersonic database which runs as an embedded service within JBoss.

In a real-world situation, porting an application to a different databases is rarely straightforward, especially if proprietary features such as sequences, stored procedures and non-standard SQL are used. For these simple applications, though it is relatively easy. When we look at the Duke’s Bank application in the next chapter, you will see that there are only a few minor syntax changes required in the database scripts.

We’ll look at how to configure JBoss to use a different database in Chapter 8, Using other Databases.

3.2.3. Security Configuration

J2EE defines how you specify security constraints within your application, but doesn’t say how the authentication and access control mechanisms are actually implemented by the server or how they are configured. As we mentioned earlier, JBoss uses JAAS to provide a pluggable means of incorporating different security technologies in your applications. It also comes with a set of standard modules for the use of file, database and LDAP-based security information. We’ll start out using file-based information as this is the simplest approach.

3.3. J2EE in the Real World

The examples here are only intended to get you up and running with JBoss and to help you familiarize yourself with the basics. The applications definitely aren’t intended to reflect how you should go about writing production J2EE software - indeed there is a lot of differing opinion on this subject. Many people disagree on the use of EJBs for example, particularly the use of entity beans; the use of bean-managed persistence is especially controversial yet is convenient for examples. There is also endless debate about the use of different web technologies (it would be safe to say that not everyone loves JSPs) and the numerous different Model-2 frameworks that are out there. Struts was one of the first and is probably the best known but is not without its critics. We’ve provided some sources at the end of this chapter which you can check out for more information.

If you’re starting out, your best bet is probably to look at some existing open-source projects and see how they are structured, and then pick something appropriate for your project.

Finally, we hope you’ll realize that there’s a lot more depth to JBoss than we can hope to cover here and once you’ve worked your way through this basic introduction, we hope you’ll be eager to learn more. JBoss is also a continually evolving project with lots of plans for the future. So keep an eye on the bleeding-edge version, even if you’re running all your production applications on the stable 4.0 series.

Chapter 4. The Duke’s Bank Application

Now that you have the server running, we will use the Duke’s Bank example from the J2EE tutorial to illustrate how to get an application up and running in JBoss. Duke’s Bank demonstrates a selection of J2EE technologies working together to implement a simple on-line banking application. It uses EJBs and web components (JSPs and servlets) and uses a database to store the information. The persistence is bean-managed, with the entity beans containing the SQL statements which are used to manipulate the data.

We won’t look in detail at its functionality or comment on the implementation but will concentrate on a step-by-step guide to building and deploying it in JBoss.

4.1. Building the Application

You should have already downloaded the J2EE 1.4 tutorial, which includes Duke’s Bank. We’ll go through building and deploying the application first and then look at things in a bit more detail.

4.1.1. Preparing the Files

You should be able to obtain the supplementary JBoss files from the same place as this document. The file is packaged as a ZIP archive called Download this and unpack it into the j2eetutorial14 directory, adding to the existing tutorial files. All the Duke’s Bank code is in a the examples/bank subdirectory. If you've unpacked the JBoss extensions correctly, you will see a jboss-build.xml there. This is our Ant build8 script for the JBoss version of the application. Rather than just overwriting the existing build.xml file, we’ve used a different name from the default. This means that Ant must now be run as ant -f jboss-build.xml.

Before we can build, you'll need to edit the file in the j2eetutorial14 to point to your JBoss install directory. Set the jboss.home property to the full path to your JBoss 4.0 installation. If you’ve unpacked JBoss 4.0 in the C: drive on a windows machine, you would set it as follows.

# Set the path to the JBoss directory containing the JBoss application server 
# (This is the one containing directories like "bin", "client" etc.) 

4.1.2. Compiling the Java Source

At the command line, go to the bank directory. All the build commands will be run from here. Compilation is pretty straightforward; just type the following command to invoke the compile Ant target.

ant -f jboss-build.xml compile

If there aren’t any errors, you will find a newly created build directory with the class files in it.

4.1.3. Package the EJBs

The application has one EJB jar, bank-ejb.jar, which contains the code and descriptors (ejb-jar.xml and jboss.xml) for the entity beans and associated controller session beans which the clients interact with. The package-ejb Ant target will create them in the jar directory.

ant -f jboss-build.xml package-ejb

4.1.4. Package the WAR File

The next target is the web application which provides the front end to allow users to interact with the business components (the EJBs). The web source (JSPs, images etc.) is contained in the src/web directory and is added unmodified to the archive. The Ant war task also adds a WEB-INF directory which contains the files which aren’t meant to be directly accessed by a web browser but are still part of the web application. These include the deployment descriptors (web.xml and jboss-web.xml), class files, (e.g. servlets and EJB interfaces) and extra jars and the extra JSP tag-library descriptors required by the web application. The package-web Ant target builds the web client WAR file.

ant -f jboss-build.xml package-web 

4.1.5. Package the Java Client

In addition to the web interface, there is a standalone Java client for administering customers and accounts. You can build it using the package-client Ant target.

ant -f jboss-build.xml package-client

The generated WAR file contains the application-client.xml and jboss-client.xml descriptors as well as the client file. The client JAR will also be included as an additional module in the EAR file and the server.

4.1.6. Assembling the EAR

The EAR file is the complete application, containing the three EJB modules and the web module. It must also contain an additional descriptor, application.xml. It is also possible to deploy EJBs and web application modules individually but the EAR provides a convenient single unit. The assemble-app Ant target will produce the final file JBossDukesBank.ear.

ant -f jboss-build.xml assemble-app 

4.1.7. The Database

Before we can deploy the application, we need to populate the database it will run against. If you are writing an application that uses container-managed persistence, you can configure the CMP engine to create the tables for you at deployment, but otherwise you will need have to have a set of scripts to do the job. This is also a convenient place pre-populating the database with data. Enabling the HSQL MBean and TCP/IP Connections

The HSQL database can be run in one of two modes: in-process or client-server (the HSQL documentation refers to this as server mode). Since we are going to be running the SQL scripts using a tool that connects to the database, we want to make sure the database is running in client-server mode and will accept TCP/IP connections. In later versions of JBoss, client-server mode is disabled to prevent direct database access, which could be a security risk if the default login and password have not been modified. Open the hsqldb-ds.xml file which you’ll find in the deploy directory and which sets up the default datasource. Near the top of the file, you’ll find the connection-url element. Make sure the value is set to jdbc:hsqldb:hsql://localhost:1701 and that any other connection-url elements are commented out.

<!-- The jndi name of the DataSource, it is prefixed with java:/ --> 
<!-- Datasources are not available outside the virtual machine --> 

<!-- for tcp connection, allowing other processes to use the hsqldb 
database. This requires the org.jboss.jdbc.HypersonicDatabase mbean. --> 

<!-- for totally in-memory db, not saved when jboss stops. 
The org.jboss.jdbc.HypersonicDatabase mbean is unnecessary 
<!-- for in-process db with file store, saved when jboss stops. The 
org.jboss.jdbc.HypersonicDatabase is unnecessary 

Now scroll down to the bottom of the file, and you should find the MBean declaration for the Hypersonic service.

<mbean code="org.jboss.jdbc.HypersonicDatabase" name="jboss:service=Hypersonic"> 
    <attribute name="Port">1701</attribute> 
    <attribute name="Silent">true</attribute> 
    <attribute name="Database">default</attribute> 
    <attribute name="Trace">false</attribute> 
    <attribute name="No_system_exit">true</attribute> 

Make sure this is also uncommented so JBoss will start the database in the correct mode. If you choose to delete the other MBean definition, make sure to change the dependency on the datasource from jboss:service=Hypersonic,database=localDB to jboss:service=Hypersonic. Creating the Database Schema

We have supplied scripts to run with HSQL in the sql directory. The database tasks in the build file will try to contact the HSQL database. If JBoss isn’t already running, you should start it now, so that the database is available.

First we need to create the necessary tables with the db-create-table target.

ant -f jboss-build.xml db-create-table 

Then run the db-insert target to populate them with the required data.

ant -f jboss-build.xml db-insert 

Finally, if everything has gone according to plan, you should be able to view some of the data using the db-list target, which lists the transactions for a specific account.

ant -f jboss-build.xml db-list The HSQL Database Manager Tool

Just as a quick aside at this point, start up the JMX console application web application and click on the service=Hypersonic link which you’ll find under the section jboss. If you can’t find this, make sure the service is enabled as described in Section, “Enabling the HSQL MBean and TCP/IP Connections”.

The HSQL Database Manger

Figure 4.1. The HSQL Database Manger

This will take you to the information for the Hypersonic service MBean. Scroll down to the bottom of the page and click the invoke button for the startDatabaseManager() operation. This starts up the HSQL Manager, a Java GUI application which you can use to manipulate the database directly.

4.1.8. Deploying the Application

Deploying an application in JBoss is easy. You just have to copy the EAR file to the deploy directory. The deploy target in the build file does this for our application.

ant -f jboss-build.xml deploy 

You should see something close to the following output from the server:

18:07:53,923 INFO  [EARDeployer] Init J2EE application: 
18:07:55,024 INFO  [EjbModule] Deploying CustomerBean
18:07:55,103 INFO  [EjbModule] Deploying AccountBean
18:07:55,142 INFO  [EjbModule] Deploying TxBean
18:07:55,403 INFO  [EjbModule] Deploying NextIdBean
18:07:55,439 INFO  [EjbModule] Deploying AccountControllerBean
18:07:55,478 INFO  [EjbModule] Deploying CustomerControllerBean
18:07:55,503 INFO  [EjbModule] Deploying TxControllerBean
18:07:56,950 INFO  [EJBDeployer] Deployed: file:/private/tmp/jboss-4.0.4/server/default/t
18:07:57,267 INFO  [TomcatDeployer] deploy, ctxPath=/bank, warUrl=file:/private/tmp/jboss
18:08:00,784 INFO  [EARDeployer] Started J2EE application: file:/private/tmp/jboss-4.0.4/

If there are any errors or exceptions, make a note of the error message and at what point it occurs (e.g. during the deployment of a particular EJB, the web application or whatever). Check that the EAR is complete and inspect the WAR file and each of the EJB jar files to make sure they contain all the necessary components (classes, descriptors etc.).

You can safely redeploy the application if it is already deployed. To undeploy it you just have to remove the archive from the deploy directory. There’s no need to restart the server in either case. If everything seems to have gone OK, then point your browser at the application URL.


You will be forwarded to the application login page. As explained in the tutorial, you can login with a customer ID of 200 and the password j2ee. Figure 4.2, “Duke's Bank” shows the Duke's Bank application in action.

Duke's Bank

Figure 4.2. Duke's Bank

If you got an error at this point, check again that you have set up the database correctly as described in Section, “Enabling the HSQL MBean and TCP/IP Connections”. In particular, check that the connection-url is correct and that you have populated the database with data.

You can also run the standalone client application using the run-client target.

ant -f jboss-build.xml run-client 

This is a Swing GUI client which allows you to administer the customers and accounts.

4.2. JNDI and Java Clients

It’s worth taking a brief look at the use of JNDI with standalone clients. The example makes use of the J2EE Application Client framework, which introduces the concept of a client-side local environment naming context within which JNDI names are resolved with the prefix java:/comp/env. This is identical to the usage on the server side; the additional level of indirection means you can avoid using hard-coded names in the client. The name mapping is effected by the use of the proprietary jboss-client.xml which resolves the references defined in the standard application-client.xml.

4.2.1. The File

One issue with a Java client is how it bootstraps itself into the system, how it manages to connect to the correct JNDI server to lookup the references it needs. The information is supplied by using standard Java properties. You can find details of these and how they work in the JDK API documentation for the javax.naming.Context class. The properties can either be hard-coded, or supplied in a file named on the classpath. The file we’ve used is shown below.


The first three are standard properties, which are set up in order to use the JBoss JNDI implementation. The j2ee.clientName property identifies the client deployment information on the server side. The name must match the jndi-name specified in the jboss-client.xml descriptor:


Of course if you were only building a simple web application, you wouldn't need to worry about remote clients

4.2.2. Application JNDI Information in the JMX Console

While we’re on the subject of JNDI, let’s take a quick look at the JBoss JMX console again and see what information it shows about our application. This time click on the service=JNDIView link and then invoke the list() operation, which displays the JNDI tree for the server. You should see the EJB modules from Duke’s Bank listed near the top and the contents of their private environment naming contexts as well as the names the entries are linked to in the server. Here's an abbreviated view:

Ejb Module: bank-ejb.jar

java:comp namespace of the CustomerBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
java:comp namespace of the AccountBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
java:comp namespace of the TxBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
java:comp namespace of the NextIdBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
java:comp namespace of the AccountControllerBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
  |   +- ejb (class: org.jnp.interfaces.NamingContext)
  |   |   +- tx[link -> MyTx] (class: javax.naming.LinkRef)
  |   |   +- nextId[link -> MyNextId] (class: javax.naming.LinkRef)
  |   |   +- account[link -> MyAccount] (class: javax.naming.LinkRef)
  |   |   +- customer[link -> MyCustomer] (class: javax.naming.LinkRef)
java:comp namespace of the CustomerControllerBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
  |   +- ejb (class: org.jnp.interfaces.NamingContext)
  |   |   +- tx[link -> MyTx] (class: javax.naming.LinkRef)
  |   |   +- nextId[link -> MyNextId] (class: javax.naming.LinkRef)
  |   |   +- account[link -> MyAccount] (class: javax.naming.LinkRef)
  |   |   +- customer[link -> MyCustomer] (class: javax.naming.LinkRef)
java:comp namespace of the TxControllerBean bean:
  +- env (class: org.jnp.interfaces.NamingContext)
  |   +- ejb (class: org.jnp.interfaces.NamingContext)
  |   |   +- tx[link -> MyTx] (class: javax.naming.LinkRef)
  |   |   +- nextId[link -> MyNextId] (class: javax.naming.LinkRef)
  |   |   +- account[link -> MyAccount] (class: javax.naming.LinkRef)
  |   |   +- customer[link -> MyCustomer] (class: javax.naming.LinkRef)
java: Namespace
  +- XAConnectionFactory (class:
  +- DefaultDS (class: org.jboss.resource.adapter.jdbc.WrapperDataSource)
  +- SecurityProxyFactory (class:
  +- DefaultJMSProvider (class: org.jboss.jms.jndi.JNDIProviderAdapter)
  +- comp (class: javax.naming.Context)
  +- JmsXA (class: org.jboss.resource.adapter.jms.JmsConnectionFactoryImpl)
  +- ConnectionFactory (class:
  +- jaas (class: javax.naming.Context)
  |   +- HsqlDbRealm (class:
  |   +- jmx-console (class:
  |   +- jbossmq (class:
  |   +- JmsXARealm (class:
  +- timedCacheFactory (class: javax.naming.Context) 
         Failed to lookup: timedCacheFactory, errmsg=org.jboss.util.TimedCachePolicy
  +- TransactionPropagationContextExporter 
  +- StdJMSPool (class: org.jboss.jms.asf.StdServerSessionPoolFactory)
  +- Mail (class: javax.mail.Session)
  +- TransactionPropagationContextImporter 
  +- TransactionManager (class:

Note that these objects are created on demand, so the dukesbank entry will only appear if you have configured the application to use the dukesbank domain and have tried to log in to the application.

4.3. Security

When you first access Duke's Bank, you are prompted for an account number and password using a simple login form. J2EE security always requires some configuration in the application server. The authentication logic which decides whether a login succeeds or fails is outside the scope of the J2EE specification. The actual authentication mechanism is controlled by the security domain that the application is linked to. In this section we will see how the security domain is configured for Duke's Bank.

4.3.1. Configuring the Security Domain

The standard J2EE security declarations for the web and EJB tiers are declared in the web.xml and ejb-jar.xml files, respectively. However, the JBoss security configuration needs to go in the companion JBoss deployment descriptors.

The configuration is quite straightforward. In both cases, a single security-domain element is all that is needed. The following fragment from jboss-web.xml illustrates the usage in the web application.


The configuration looks the same on the EJB side. The following jboss.xml file shows how this works.


In both cases, we've linked to a security domain located by the java:/jaas/dukesbank JNDI name. All security domains are bound under the java:/jaas context, so we would really just say that the application is using the dukesbank security domain.

Security domains are configured by a corresponding application policy in the conf/login-config.xml file. But, if you look, you won't see a dukesbank policy. When JBoss doesn't find a matching policy, it defaults to using the other policy, which is shown below.

<application-policy name="other">
        <login-module code=""
                         flag="required" />

The login module used here uses local properties files for authentication. There are two files; one provides usernames and passwords, and other provides the roles assigned to the users. The following listing shows the file used for Duke's Bank.

# file for use with the UsersRolesLoginModule
# Format is:
# username=password


The format is simple. Each line takes the form username=password. So, this file contains one user named 200 whose password is j2ee. That is the name and password you used to access the application. Try changing the password and deploying the application again.

J2EE application security isn't driven only by a username and password. Users are assigned to roles, and the application can only only give access to a user based on that user's roles. Duke's bank can only be accessed by users that are customers, as indicated by the bankCustomer role. The following listing shows the file used to assign the bankCustomer role to the user.

# A file for use with the UsersRolesLoginModule
# Format is
# username=role1,role2,role3

To complete the application, you should actually define the dukesbank security domain rather than letting the server fall back to the default security domain. All you need to do is add the following policy to the conf/login-config.xml file.

<application-policy name="dukesbank"> 
        <login-module code="" 
                         flag="required" /> 

You will, unfortunately, need to restart JBoss to make the changes to login-config.xml visible.

4.3.2. Security Using a Database

As you can well imagine, password files are not a very flexible method for maintaining security. In a real project you will want to use a more sophisticated approach to authentication. Since the user accounts are in the database, it would be very convenient to be able to store the passwords there too. We'll do that now.

JBoss comes with a login module called DatabaseServerLoginModule that can use authentication information stored in a relational database. The following database schema mirrors the information in the properties files.

CREATE TABLE Users(username VARCHAR(64) PRIMARY KEY, passwd VARCHAR(64)) 
CREATE TABLE UserRoles(username VARCHAR(64), userRoles VARCHAR(32))
INSERT INTO Users VALUES ('200','j2ee') 
INSERT INTO UserRoles VALUES ('200','bankCustomer')

You can use they Hypersonic database manager we looked at earlier to create these tables and load the data. Once you have the data, we'll need to configure the DatabaseServerLoginModule. The login module requires the appropriate queries to retrieve the password and roles for a particular user and a reference to the datasource that those queries should be issued on. For Duke's Bank, the following configuration should be added to login-config.xml.

<application-policy name="dukesbank"> 
        <login-module code="" 
            <module-option name="dsJndiName">java:/DefaultDS</module-option> 
            <module-option name="principalsQuery">   
                select passwd from Users where username=? 
            <module-option name="rolesQuery"> 
                select userRoles,'Roles' from UserRoles where username=? 

The query to retrieve the password is straightforward. However, there is an additional field with value Roles in the roles query. This is the role group. It allows you to store additional roles (for whatever purpose) classified by the role group. The ones which will affect JBoss permissions are expected to have the value Roles. In this simple example we only have a single set of roles in the database and no role group information. The details aren't critical to understand here. Just remember that the roles query should return the text Roles in the second column.

You will need to restart JBoss for changes to login-config.xml to take effect. Do that and access Duke's bank.

4.3.3. Using Password Hashing

The login modules we’ve used so far all have support for password hashing; rather than storing passwords in plain text, a one-way hash of the password is stored (using an algorithm such as MD5) in a similar fashion to the /etc/passwd file on a UNIX system. This has the advantage that anyone reading the hash won’t be able to use it to log in. However, there is no way of recovering the password should the user forget it, and it also makes administration slightly more complicated because you also have to calculate the password hash yourself to put it in your security database. This isn’t a major problem though. To enable password hashing in the database example above, you would add the following module options to the configuration

<module-option name="hashAlgorithm">MD5</module-option> 
<module-option name="hashEncoding">base64</module-option>

This indicates that we want to use MD5 hashes and use base64 encoding to covert the binary hash value to a string. JBoss will now calculate the hash of the supplied password using these options before authenticating the user, so it’s important that we store the correctly hashed information in the database. If you’re on a UNIX system or have Cygwin installed on Windows, you can use openssl to hash the value.

$ echo -n "j2ee" | openssl dgst -md5 -binary | openssl base64 

You would then insert the resulting string, glcikLhvxq1BwPBZN0EGMQ==, into the database instead of the plaintext password, j2ee. If you don’t have this option, you can use the class which you’ll find in the jbosssx.jar file.

$ java -classpath ./jbosssx.jar j2ee MD5 

With a single argument it will just encode the given string but if you supply the name of a digest algorithm as a second argument it will calculate the hash of the string first.

Chapter 5. J2EE Web Services

From the start, web services have promised genuine interoperability by transmitting XML data using platform and language-independent protocols such as SOAP over HTTP. While the early days of multiple competing standards and general developer confusion may have made this more of a dream than a reality, web services have matured and standardized enough to have been incorporated into the J2EE 1.4 specification.

Keeping with the spirit of this guide, we'll assume you have some experience with web services already. If you don't, we would recommend you do some reading in advance. A good place to start would be on the JBoss wiki, which covers web services on JBoss in more depth. We also recommend J2EE Web Services by Richard Monson-Haefel for more general coverage of J2EE web services.

5.1. Web services in JBoss

JBossWS is the JBoss module responsible for providing web services in JBoss 4.0, replacing the previous JBoss.NET package. Like its predecessor, it is also based on Apache Axis ( However, JBossWS provides the complete set of J2EE 1.4 web services technologies, including SOAP, SAAJ, JAX-RPC and JAXR.

J2EE web services provides for two types of endpoints. If you think of a web service as a platform-independent invocation layer, then the endpoint is the object you are exposing the operations of and invoking operations on. Naturally, J2EE web services support exposing EJBs as web services, but only stateless session beans can be used. That makes sense given the stateless nature of web services requests. Additionally, J2EE web services provide for JAX-RPC service endpoints, (JSEs) which are nothing more than simple Java classes. We'll only be working with EJB endpoints in this example.

5.2. Duke’s Bank as a Web Service

We'll continue working with the Duke's Bank application from Chapter 4, The Duke’s Bank Application and create a simple web service for querying accounts and balances. The AccountController session bean provides this functionality to the Duke's Bank web application. Unfortunately the application uses stateful session beans as its external interface, so we can't expose the AccountController session bean directly. Instead, we'll create a new stateless session bean, the TellerBean, which will provide a more suitable web service endpoint.

Before we start, make sure that you have built and deployed Duke's Bank according to the instructions in Chapter 4, The Duke’s Bank Application. As with that example, we'll be working from the examples/bank directory. Although TellerBean will have already been compiled when you deployed Duke's Bank, you'll need to remember to invoke the compile target to compile any changes you might make.

ant -f jboss-build.xml compile

The magic of J2EE is in the deployment descriptors. We've seen how to deploy session beans already. Deploying a session bean as a web service is as simple as adding a service-endpoint element to the session bean definition in ejb-jar.xml. The service-endpoint specifies the class that provides the interface corresponding to the methods on the session bean being exposed as a web service.


You might have noticed that we didn't declare a home or remote interface for TellerBean. If your session bean is only accessed by the web services interface, you don't need one, so we've left them out here. Instead, we've declared the TellerEndpoint class as our endpoint interface. Our web service interface exposes two operations, both of which map onto the equivalent methods on TellerBean.

public interface TellerEndpoint
    extends Remote
    public AccountList getAccountsOfCustomer(String customerId)
        throws RemoteException;

    public BigDecimal getAccountBalance(String accountID)
        throws RemoteException;

The required web services deployment descriptors (WSDL file, JAX-RPC mapping file, webservices deployment descriptor) can be generated using the wstools generator that comes with JBossWS. The wstools target runs the generator.

ant -f jboss-build.xml wstools

The wstools program uses the wstools-config.xml file to guide the generation project.

<configuration xmlns="">
        <service name="TellerService" style="rpc" endpoint="com.jboss.ebank.TellerEndpoint"/>
        <namespaces target-namespace=""
        <mapping file="jaxrpc-mapping.xml"/>
        <webservices ejb-link="TellerBean"/>

The following artificats are generated by this configuration.

  • TellerService.wsdl: This is the WSDL definition that describes the web service. Some values, like the SOAP address, will be filled in at runtime by JBossWS.

  • jaxrpc-mapping.xml: This mapping file describes the mapping between the WSDL types and the underlying Java implementation. Since the client program happens to use the same Java classes, we will re-use this file for the client-side mappings.

  • webservices.xml: This file declares the webservice. It links the endpoint to a server-side component (in this case a session bean) and points to the location of the related deployment files.

This web service is a simple session bean, so deploying it only requires us to package up the bean and the associated deployment descriptors into an EJB JAR file. The package-ws task accomplishes this, and the deploy-ws target deploys the EJB JAR to JBoss.

ant -f jboss-build.xml package-ws
ant -f jboss-build.xml deploy-ws

Once the service is deployed you can view the WSDL (Web Service Description Language) for it by browsing to the URL http://localhost:8080/bankws-ejb/TellerService?wsdl. In this example we generate the WSDL, but it would also have been possible to write the WSDL for the service by hand and then generate a Java endpoint interface for it using wsdl2java, which is also provided with JBossWS.

5.3. Running the Web Service Client

We’ve also supplied a Java client which accesses the web service from a non-J2EE environment.

public class WSClient {
    public static void main(String[] args) 
        throws Exception 
        URL url = 
            new URL("http://localhost:8080/bankws-ejb/TellerBean?wsdl");

        QName qname = new QName("",

        File mapping = new File("dd/ws/jaxrpc-mapping.xml");
        ServiceFactoryImpl factory = new ServiceFactoryImpl();
        Service            service = factory.createService(url, qname, mapping.toURL());

        TellerEndpoint endpoint = (TellerEndpoint)

        String customer = "200";
        System.out.println("Customer: " + customer);
        AccountList accounts = endpoint.getAccountsOfCustomer(customer);
        String[]    ids      = accounts.getAccounts();
        for (int i=0; i<ids.length; i++) {
            System.out.println("account[" + ids[i] +  "]  " + 

The client can be run using the run-ws target.

ant -f jboss-build.xml run-ws

The client will display the balance for each account belonging to the given customer.

     [java] Customer: 200
     [java] account[5005]  3300.00
     [java] account[5006]  2458.32
     [java] account[5007]  220.03
     [java] account[5008]  59601.35

5.4. Monitoring webservices requests

When processing web services requests, it is often useful to be able and observe the actual messages being passed between the client and the server. JBossWS logs this information in the category. To enable web services logging, add the following debug category to the log4j.xml file:

<category name="">
    <priority value="DEBUG"/>

When enabled, all SOAP requests and responses will be logged to the server.log file. Here is a log of a call to the getAccountsOfCustomer method.

2005-05-16 17:50:43,479 DEBUG [org.jboss.axis.transport.http.AxisServlet] 
<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv=""
  <ns1:getAccountsOfCustomer xmlns:ns1="">
...2006-05-23 14:51:51,710 DEBUG [] Outgoing SOAPMessage
<env:Envelope xmlns:env=''>
  <ns1:getAccountsOfCustomerResponse xmlns:ns1=''>
   <result xmlns:xsi=''>

Chapter 6. JMS and Message-Driven Beans

One thing that’s missing from the Duke’s Bank application is any use of JMS messaging, so we’ll work through the tutorial example on Message Driven Beans (MDBs) to see how to use messaging in JBoss. We’ll assume you’re already familiar with general JMS and MDB concepts. The J2EE tutorial code for the MDB is in j2eetutorial14/examples/ejb/simplemessage. We’ve supplied a jboss-build.xml file in the simplemessage directory which will allow you to build the example from scratch and run it in JBoss.

The example code is very simple. There are only two classes, one for the client and one for the bean (unlike normal EJBs, MDBs don’t need any interfaces). The client publishes messages to a JMS Queue and the MDB handles them via its standard onMessage method. The messages are all of type javax.jms.TextMessage and the bean simply prints out the text contained in each message.

The only container-specific tasks required are setting up the Queue in JBoss, and configuring the MDB to accept messages from it.

6.1. Building the Example

6.1.1. Compiling and Packaging the MDB and Client

To compile the files, invoke the compile-mdb target from the simplemessage directory.

ant -f jboss-build.xml compile-mdb

Then run the following targets to produce archives for the bean and the client and a combined EAR file in the jar directory.

ant -f jboss-build.xml package-mdb 
ant -f jboss-build.xml package-mdb-client 
ant -f jboss-build.xml assemble-mdb

We’ve retained the same layout we used in the Duke’s Bank build, with a dd directory containing the deployment descriptors and the jar directory containing the archives produced by the build. Specifying the Source Queue for the MDB

As with other container-specific information, the queue name for the MDB is specified in the jboss.xml file:


The MDB will receive messages from the queue with JNDI name queue/MyQueue.

6.2. Deploying and Running the Example

To deploy the MDB, copy the SimpleMessage.ear file to the JBoss deploy directory. The deploy-mdb target does this:

ant -f jboss-build.xml deploy-mdb

A successful deployment should look something like this:

08:20:08,188 INFO  [EARDeployer] Init J2EE application: 
08:20:08,370 INFO  [EjbModule] Deploying SimpleMessageEJB
08:20:08,565 INFO  [ClientDeployer] Client ENC bound under: SimpleMessageClient
08:20:08,712 WARN  [JMSContainerInvoker] Could not find the queue 
08:20:08,719 WARN  [JMSContainerInvoker] destination not found: queue/MyQueue 
reason: javax.naming.NameNotFoundException: MyQueue not bound
08:20:08,719 WARN  [JMSContainerInvoker] creating a new temporary destination: queue/MyQueue
08:20:08,772 INFO  [MyQueue] Bound to JNDI name: queue/MyQueue
08:20:08,952 INFO  [EJBDeployer] Deployed: 
08:20:08,996 INFO  [EARDeployer] Started J2EE application: 

If you look more closely at this, you will see warnings that the message queue specified in the deployment doesn’t exist. In this case JBoss will create a temporary one for the application and bind it under the supplied name. You can check it exists using the JNDIView MBean again. Look under the global JNDI namespace. We’ll look at how to explicitly create JMS destinations below.

Run the client with the run-mdb Ant target.

ant -f jboss-build.xml run-mdb

You should see output in both the client and server windows as they send and receive the messages respectively.

6.3. Managing JMS Destinations

As with most things in JBoss, JMS Topics and Queues are implemented using MBeans. There are two ways you can create them: you can add MBean declarations to the appropriate configuration file, or you can create them dynamically using the JMX Console. However, if you use the latter method, they won’t survive a server restart.

6.3.1. The jbossmq-destinations-service.xml File

You’ll find this file in the jms directory inside the deploy directory. It contains a list of JMS destinations and sets up a list of test topics and queues which illustrate the syntax used. To add the queue for our example, you would simply add the following MBean declaration to the file.

<mbean code="" 

6.3.2. Using the DestinationManager from the JMX Console

With JBoss running, bring up the JMX Console in your browser and look for the section labelled in the main agent view. Click on the link which says service=DestinationManager. The DestinationManager MBean is the main JMS service in JBoss and you can use it to create and destroy queues and topics at runtime. Look for the operation called createQueue. There will be two operations by that name, both of which take a different number of arguments. Look for the one that takes only one argument. That argument is the name of the queue. This takes two parameters. Enter MyQueue and click the Invoke button. This will create a queue bound under the JNDI name queue/MyQueue, assuming it doesn't already exist.

6.3.3. Administering Destinations

You can access the attributes and operations that the MBeans representing a queue or topic exposes via JMX. Look at the main JMX Console view again and you’ll find a separate section which should contain an entry for our Queue (no matter how it was created). Click on this and you’ll see the attributes for the queue. One of them is QueueDepth, which is the number of messages which are currently on the queue.

As an exercise, you can try temporarily stopping the delivery of messages to the MDB. Locate the section called jboss.j2ee in the JMX console and you should find an MBean listed there which is responsible for invoking your MDB. The name will be binding=message-driven-bean, jndiName=local/SimpleMessageEJB, plugin=invoker,service=EJB

You can start and stop the delivery of messages using the corresponding MBean operations which it supports. Invoke the stopDelivery() method, and then run the client a few times. You will see the QueueDepth increase as the messages accumulate. If you re-start message delivery, with the startDelivery() method, you should see all the messages arriving at once.

Chapter 7. Container-Managed Persistence

In this chapter we’ll use the RosterApp example application from the J2EE tutorial to explore container-managed persistence in a bit more depth than we did with Duke's Bank. You should read through the CMP tutorial notes before proceeding so that you have a good overview of the beans and their relationships.

You’ll find the code in j2eetutorial14/examples/ejb/cmproster. The application implements a player roster for sports teams playing in leagues. There are three entity beans PlayerEJB, TeamEJB and LeagueEJB and a single session bean, RosterEJB, which manipulates them and provides the business methods accessed by the client application. Only the session bean has a remote interface.

7.1. Building the Example

The EJBs are packaged in two separate JAR files, one for the entity beans and one for the session bean. As before, we’ve provided an ejb-jar.xml file for each one. You don’t need a jboss.xml file for this example. All the CMP information needed to build the database schema is included in the standard descriptor. We’ll look at JBoss-specific customization later.

To compile the code, first make sure you’re in the examples directory. Running the compile-cmp target will compile all the code in one go.

ant -f jboss-build.xml compile-cmp

Run the following package-team to build the team JAR file which contains the entity beans.

ant -f jboss-build.xml package-team 

The package-roster target builds the roster JAR.

ant -f jboss-build.xml package-roster

Both JAR files will be created in the jar directory. Build the client jar using the package-roster-client target.

ant -f jboss-build.xml package-roster-client 

Finally assemble the RosterApp EAR using the assemble-roster target.

ant -f jboss-build.xml assemble-roster

7.2. Deploying and Running the Application

Deploying the application is done with the deploy-cmp Ant target.

ant -f jboss-build.xml deploy-cmp

Copy the RosterApp.ear file from the jar directory to the JBoss deploy directory (or run Ant with the deploy-cmp target) and check the output from the server.

13:49:11,044 INFO  [EARDeployer] Init J2EE application: file:/private/tmp/jboss-4.0.4/serv
13:49:11,884 INFO  [EjbModule] Deploying RosterBean
13:49:13,366 INFO  [EjbModule] Deploying TeamBean
13:49:13,751 INFO  [EjbModule] Deploying LeagueBean
13:49:13,842 INFO  [EjbModule] Deploying PlayerBean
13:49:14,377 INFO  [EJBDeployer] Deployed: file:/private/tmp/jboss-4.0.4/server/default/tm
13:49:17,931 INFO  [EJBDeployer] Deployed: file:/private/tmp/jboss-4.0.4/server/default/tm
13:49:17,991 INFO  [EARDeployer] Started J2EE application: file:/private/tmp/jboss-4.0.4/s

There are a few things worth noting here. In the Duke’s Bank application, we specified the JNDI name we wanted a particular EJBHome reference to be bound under in the jboss.xml file. Without that information JBoss will default to using the EJB name. So the session bean is bound under RosterBean and so on. You can check these in the JMX Console as before.

The first time you deploy the application, JBoss will automatically create the required database tables. If you take a look at the database schema using the Hypersonic database manager (see Section, “The HSQL Database Manager Tool”), you will see that JBoss has created one table for each entity bean and an addition join table needed to handle the many-to-many relationship between players and teams. The table and column names correspond the names of the entity beans and their attributes. If these names are suitable, you won't need to further refine the schema. In this case we've had to manually map the position field on PlayerBean to a column named pos because the default column name, position, is a reserved token in HSQL. The schema is in the jbosscmp-jdbc.xml file.

Note that if you increase the logging level for the org.jboss.ejb.plugins.cmp package (Section 2.2.2, “Logging Service”) to DEBUG, the engine will log the SQL commands which it is executing. This can be useful in understanding how the engine works and how the various tuning parameters affect the loading of data.

7.2.1. Running the Client

The client performs some data creation and retrieval operations via the session bean interface. It creates leagues, teams and players which will be inserted into the database. The session bean methods it calls to retrieve data are mainly wrappers for EJB finder methods. The command to run the client and the expected output are shown below.

$ ant -f jboss-build.xml run-cmp 
Buildfile: jboss-build.xml 
[java] P10 Terry Smithson midfielder 100.0 
[java] P6 Ian Carlyle goalkeeper 555.0 
[java] P7 Rebecca Struthers midfielder 777.0 
[java] P8 Anne Anderson forward 65.0 
[java] P9 Jan Wesley defender 100.0 
[java] T1 Honey Bees Visalia 
[java] T2 Gophers Manteca 
[java] T5 Crows Orland 
[java] P2 Alice Smith defender 505.0 
[java] P22 Janice Walker defender 857.0 
[java] P25 Frank Fletcher defender 399.0 
[java] P5 Barney Bold defender 100.0 
[java] P9 Jan Wesley defender 100.0 
[java] L1 Mountain Soccer 
[java] L2 Valley Basketball 

The client doesn’t remove the data, so if you run it twice it will fail because it tries to create entities which already exist. If you want to run it again you’ll have to remove the data. The easiest way to do this (if you’re using HSQL) is to delete the contents of the data/hypersonic directory in the server configuration you are using (assuming you don’t have any other important data in there) and restart the server. We’ve also provided a SQL script to delete the data. You can run it with the db-delete target.

ant -f jboss-build.xml db-delete

You could also use SQL commands directly through the HSQL Manager tool to delete the data.

7.3. CMP Customization

There are many ways you can further customize the CMP engine’s behaviour by using the jbosscmp-jdbc.xml file. It is used for basic information such as the datasource name and type-mapping (Hypersonic, Oracle etc.) and whether the database tables should be automatically created on deployment and deleted on shutdown. You can customize the names of database tables and columns which the EJBs are mapped to and you can also tune the way in which the engine loads the data depending on how you expect it to be used. For example, by using the read-ahead element you can get it to read and cache blocks of data for multiple EJBs with a single SQL call, anticipating further access. Eager-loading groups can be specified, meaning that only some fields are loaded initially with the entity; the others are lazy-loaded if and when they are required. The accessing of relationships between EJBs can be tuned using similar mechanisms. This flexibility is impossible to achieve if you are using BMP where each bean must be loaded with a single SQL call. If on top of that you include having to write all your SQL and relationship management code by hand then the choice should be obvious. You should rarely, if ever, have to use BMP in your applications.

The details of tuning the CMP engine are beyond the scope of this document but you can get an idea of what’s available by examining the DTD (docs/dtd/jbosscmp-jdbc_4_0.dtd) which is well commented. There is also a standard setup in the conf directory called standardjbosscmp-jdbc.xml which contains values for the default settings and a list of type-mappings for common databases. The beginning of the file is shown below.

        <datasource-mapping>Hypersonic SQL</datasource-mapping> 

You can see that, among other things, this sets the datasource and mapping for use with the embedded Hypersonic database and sets table-creation to true and removal to false, so the schema will be created if it doesn’t already exist. The read-only and read-time-out elements specify whether data should be read-only and the time in milliseconds it is valid for. Note that many of these elements can be used at different granularities such as per-entity or even on a field-by-field basis (consult the DTD for details). The read-ahead element uses an on-load strategy which means that the EJB data will be loaded when it is accessed (rather than when the finder method is called) and the page-size setting means that the data for up to 1000 entities will be loaded with one SQL command. You can override this either in your own jbosscmp-jdbc.xml file’s list of default settings or by adding the information to a specific query configuration in the file.

A comprehensive explanation of the CMP engine and its various loading strategies can be found in the full JBoss 4 Application Server Guide.

7.3.1. XDoclet

Writing and maintaining deployment descriptors is a labour-intensive and error-prone job at the best of times, and detailed customization of the CMP engine can lead to some large and complex files. If you are using CMP (or indeed EJBs) in anger then it is worth learning to use the XDoclet code generation engine ( Using Javadoc-style attribute tags you place in your code, XDoclet will generate the deployment descriptors for you as well as the EJB interfaces and other artifacts if required. It fully supports JBoss CMP, and though the learning curve is quite steep, its use is thoroughly recommended (almost essential in fact) for real projects.

Chapter 8. Using other Databases

In the previous chapters, we’ve just been using the JBoss default datasource in our applications. This is provided by the embedded HSQL database instance and is bound to the JNDI name java:/DefaultDS. Having a database included with JBoss is very convenient for running examples and HSQL is adequate for many purposes. However, at some stage you will want to use another database, either to replace the default datasource or to access multiple databases from within the server.

8.1. DataSource Configuration Files

DataSource configuration file names end with the suffix -ds.xml so that they will be recognized correctly by the JCA deployer. The docs/example/jca directory contains sample files for a wide selection of databases and it is a good idea to use one of these as a starting point. For a full description of the configuration format the best place to look is the DTD file docs/dtd/jboss-ds_1_5.dtd. Additional documentation on the files and the JBoss JCA implementation can also be found in the JBoss 4 Application Server Guide.

Local transaction datasources are configured using the local-tx-datasource element and XA-compliant ones using xa-tx-datasource. The example file generic-ds.xml shows how to use both types and also some of the other elements that are available for things like connection pool configuration. Examples of both local and XA configurations are available for Oracle, DB2 and Informix.

If you look at the example files firebird-ds.xml, facets-ds.xml and sap3-ds.xml, you’ll notice that they have a completely different format, with the root element being connection-factories rather than datasources. These use an alternative, more generic JCA configuration syntax used with a pre-packaged JCA resource adapter. The syntax is not specific to datasource configuration and is used, for example, in the jms-ds.xml file to configure the JMS resource adapter.

Next, we’ll work through some step-by-step examples to illustrate what’s involved setting up a datasource for a specific.

8.2. Using MySQL as the Default DataSource

MySQL is a one of the most popular open source databases around and is used by many prominent organizations from Yahoo to NASA. The official JDBC driver for it is called Connector/J. For this example we’ve used MySQL 4.1.7 and Connector/J 3.0.15. You can download them both from .

8.2.1. Creating a Database and User

We’ll assume that you’ve already installed MySQL and that you have it running and are familiar with the basics. Run the mysql client program from the command line so we can execute some administration commands. You should make sure that you are connected as a user with sufficient privileges (e.g. by specifying the -u root option to run as the MySQL root user).

First create a database called jboss within MySQL for use by JBoss.

mysql> CREATE DATABASE jboss; 
Query OK, 1 row affected (0.05 sec) 

Then check that it has been created.

| Database | 
| jboss    | 
| mysql    | 
| test     | 
3 rows in set (0.00 sec) 

Next, create a user called jboss with password password to access the database.

mysql> GRANT ALL PRIVILEGES ON jboss.* TO jboss@localhost IDENTIFIED BY 'password'; 
Query OK, 0 rows affected (0.06 sec) 

Again, you can check that everything has gone smoothly.

mysql> select User,Host,Password from mysql.User; 
| User  | Host      | Password         | 
| root  | localhost |                  |
| root  | %         |                  | 
|       | localhost |                  | 
|       | %         |                  | 
| jboss | localhost | 5d2e19393cc5ef67 | 
5 rows in set (0.02 sec) 

8.2.2. Installing the JDBC Driver and Deploying the DataSource

To make the JDBC driver classes available to JBoss, copy the file mysql-connector-java-3.0.15-ga-bin.jar from the Connector/J distribution to the lib directory in the default server configuration (assuming that is the configuration you’re running, of course). Then create a file in the deploy directory called mysql-ds.xml with the following datasource configuration. The database user name and password corresponds the MySql user we created in the previous section.


Because we have added a new JAR file to the lib directory, you will need to JBoss to make sure that the server is able to find the MySQL driver classes.

8.2.3. Testing the MySQL DataSource

We’ll use the CMP roster application from Chapter 7, Container-Managed Persistence to test the new database connection. In order to use MySql in our application, we'll need to set the datasource name a nd type-mapping in the jbosscmp-jdbc.xml file in the dd/team directory of the CMP roster application. Edit the file and add the following datasource and datasource-mapping elements to the defaults element. to mySQL.



After restarting JBoss, you should be able to deploy the application and see the tables being created as we did in Section 7.2, “Deploying and Running the Application”. The tables should be visible from the MySQL client.

mysql> show tables; 
| Tables_in_jboss                   |
| LeagueBean                        |
| PlayerBean                        |
| PlayerBean_teams_TeamBean_players |
| TeamBean                          |
4 rows in set (0.00 sec) 

You can see the JMS persistence tables in there too since we’re using MySQL as the default datasource.

8.3. Setting up an XADataSource with Oracle 9i

Oracle is one of the main players in the commercial database field and most readers will probably have come across it at some point. You can download it freely for non-commercial purposes from

Installing and configuring Oracle is not for the faint of heart. It isn’t really just a simple database, but it is heavy on extra features and technologies which you may not actually want (another Apache web server, multiple JDKs, Orbs etc.) but which are usually installed anyway. So we’ll assume you already have an Oracle installation available. For this example, we’ve used Oracle 10g.

8.3.1. Padding Xid Values for Oracle Compatibility

If you look in the jboss-service.xml file in the default/conf directory, you’ll find the following service MBean.

<!-- The configurable Xid factory. For use with Oracle, set pad to true --> 
<mbean code="" 
    <!--attribute name="Pad">true</attribute--> 

The transaction service uses this to create XA transactions identifiers. The comment explains the situation: for use with Oracle you have to include the line which sets the attribute Pad to true. This activates padding the identifiers out to their maximum length of 64 bytes. Remember that you’ll have to restart JBoss for this change to be put into effect, but wait until you’ve installed the JDBC driver classes which we’ll talk about next.

8.3.2. Installing the JDBC Driver and Deploying the DataSource

The Oracle JDBC drivers can be found in the directory $ORACLE_HOME/jdbc/lib. Older versions, which may be more familiar to some users, had rather uninformative names like but at the time of writing the latest driver version can be found in the file ojdbc14.jar. There is also a debug version of the classes with _g appended to the name which may be useful if you run into problems. Again, you should copy one of these to the lib directory of the JBoss default configuration. The basic driver class you would use for the non-XA setup is called oracle.jdbc.driver.OracleDriver. The XADataSource class, which we’ll use here, is called oracle.jdbc.xa.client.OracleXADataSource.

For the configuration file, make a copy of the oracle-xa-ds.xml example file and edit it to set the correct URL, username and password.

        <xa-datasource-property name="URL">
        <xa-datasource-property name="User">jboss</xa-datasource-property> 
        <xa-datasource-property name="Password">password</xa-datasource-property> 
    <mbean code="" 
        <depends optional-attribute-name="TransactionManagerService">

We’ve used the Oracle thin (pure java) driver here and assumed the database is running on the host monkeymachine and that the database name (or SID in Oracle terminology) is jboss. We’ve also assumed that you’ve created a user jboss with all the sufficient privileges. You can just use dba privileges for this example.

SQL> connect / as sysdba 
SQL> create user jboss identified by password; 
User created. 
SQL> grant dba to jboss; 
Grant succeeded. 

Now copy the file to the deploy directory. You should get the following output.

11:33:45,174 INFO  [WrapperDataSourceService] Bound connection factory for resource adapter
for ConnectionManager 'jboss.jca:name=XAOracleDS,service=DataSourceBinding to JNDI name

If you use the JNDIView service from the JMX console as before, you should see the name java:/XAOracleDS listed.

8.3.3. Testing the Oracle DataSource

Again we’ll use the CMP example to test out the new database connection. The jbosscmp-jdbc.xml file should contain the following.


There are other Oracle type-mappings available too. If you’re using an earlier version, have a look in the conf/standardjbosscmp-jdbc.xml file to find the correct name

Deploy the application as before, check the output for errors and then check that the tables have been created using Oracle SQLPlus again from the command line.

SQL> select table_name from user_tables;


Chapter 9. Using Hibernate

Hibernate is a popular persistence engine that provides a simple, yet powerful, alternative to using standard entity beans. Hibernate runs in almost any application server, or even outside of an application server completely. However, when running inside of JBoss, you can choose to deploy your application as a Hibernate archive, called a HAR file, and make Hibernate's simple usage even simpler. JBoss can manage your Hibernate session and other configuration details, allowing you to use Hibernate objects with minimal setup.

In this chapter, we will return the CMP roster application from Chapter 7, Container-Managed Persistence and show how to access the roster database tables with Hibernate. We'll demonstrate how to create a HAR file to package your Hibernate objects, and then we'll show how to access them from a web application in a WAR file. The entire project will be bundled in an EAR file, just like all of our previous examples.

The code for this section is in the examples/hibernate directory. However, the Hibernate example here is intended to be run along side of the CMP roster application in Chapter 7, Container-Managed Persistence. If you don't have the roster application deployed, go back and follow the instructions there. Make sure that you follow the instructions for creating the database schema and populating the database. We will be using the schema and data from that task.

Also, please keep in mind that we'll only be looking at the steps required to deploy a Hibernate application in JBoss. If you need a more general guide to Hibernate, we recommend Hibernate in Action by Christian Bauer and Gavin King (Manning, 2004).

9.1. Creating a Hibernate archive

The Hibernate portion of the application consists of a single Java class, org.jboss.roster.Player, that maps onto the PlayerBean entity bean from the CMP roster application. The Player object is a simple POJO object with no direct coupling to Hibernate. The details of the Hibernate mapping are specified in the Player.hbm.xml file, shown below.

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    <class name="org.jboss.roster.Player" table="PlayerBean">
       <id name="id" type="string" column="playerID"> 
           <generator class="assigned" />

       <property name="position" type="string" column="POS"    />
       <property name="name"     type="string" column="name"   />
       <property name="salary"   type="float"  column="salary" />

In addition to the Player object and its mapping file, we also need to provide a hibernate-service.xml file that creates an MBean that will manage the Hibernate configuration. The following is the hibernate-service.xml files we are using.

    <mbean code="org.jboss.hibernate.jmx.Hibernate" 
        <attribute name="DatasourceName">java:/DefaultDS</attribute>
        <attribute name="Dialect">org.hibernate.dialect.HSQLDialect</attribute>
        <attribute name="SessionFactoryName">java:/hibernate/SessionFactory</attribute>
        <attribute name="CacheProviderClass">
        <!-- <attribute name="Hbm2ddlAuto">create-drop</attribute> -->

This configuration information should be familiar to any Hibernate user. The JBoss specific details are the mapping to our java:/DefaultDS and the JNDI location where we want our Hibernate SessionFactory bound.

To compile the project and build the hibernate archive, use the compile and package-har Ant targets.

ant -f jboss-build.xml compile
ant -f jboss-build.xml package-har

The contents of the create HAR file look like the following:

$ jar tf jar/roster.har 

Experienced Hibernate users may be wondering where we've told Hibernate what our persistent objects are. The Hibernate deployer determines the set of persistent objects by searching the HAR file for hibernate mapping files. All hibernate objects found are added to the configuration with no further effort required.

9.2. Using the hibernate objects

By deploying the Hibernate archive, we have created a fully configured SessionFactory for use in other parts of our application. In this example, we have created a simple JSP which creates a Session from the SessionFactory and issues a query directly. Normally it would be preferable to put the Hibernate access code in a servlet or in a session bean, but for example purposes we'll keep the code together in the JSP. For reference, the following code fragment shows how we are accessing the Hibernate session in the JSP.

InitialContext ctx      = new InitialContext();
SessionFactory factory  = (SessionFactory)
Session        hsession = factory.openSession();
try {
    Query query = hsession.createQuery("from org.jboss.roster.Player order by name");
    request.setAttribute("players", query.list());
} finally {

To package the complete web application, use the package-web Ant target.

ant -f jboss-build.xml package-web

This creates roster.war in the jar directory containing our simple web application.

9.3. Packaging the complete application

Next, we need to package the entire application into an EAR file. The assemble Ant target does this.

ant -f jboss-build.xml assemble

This creates the HibernateRoster.ear file. The contents of the EAR file our our roster.har and roster.war files, along with the appropriate deployment descriptors.

$ jar tf jar/HibernateRoster.ear 

Just as we need to declare the WAR file in the application.xml file, we also need to declare the HAR file. However, since Hibernate archives are not a standard J2EE deployment type, we need to declare it in the jboss-app.xml file.

<!DOCTYPE jboss-app PUBLIC "-//JBoss//DTD J2EE Application 1.4//EN"

Now our application is ready to be deployed.

9.4. Deploying Running the application

Once the EAR file is created, we need to deploy it using the deploy Ant target. This copies the EAR file to the appropriate JBoss deploy directory.

ant -f jboss-build.xml deploy

The deployed application can be accessed at http://localhost:8080/roster/players.jsp. When the page is loaded, you will see a list of players sorted by name. If you don't see any data, make sure that you have deployed the CMP roster application from Chapter 7, Container-Managed Persistence and run it to populate the tables with the shared player data.

Appendix A. Further Information Sources

For a longer introduction to JBoss, see JBoss: A Developer's Notebook. (O'Reilly, 2005. Norman Richards, Sam Griffith).

For more comprehensive JBoss documentation covering advanced JBoss topics, see JBoss 4 Application Server Guide, available at A print version of the guide is available as JBoss 4.0: The Official Guide. (Sams, 2005)

For general EJB instruction, with thorough JBoss coverage, see Enterprise JavaBeans, 4th Edition. (O'Reilly, 2004. Richard Monson-Haeful, Bill Burke, Sacha Labourey)

For additional, but dated, EJB instruction, we also recommend the classic Mastering Enterprise JavaBeans, Second Edition. (Wiley, 2001. Ed. Roman et al.) A free PDF version of the first edition is available online at

For complete coverage of the new J2EE 1.4 web services, see J2EE Web Services. (Addison-Wesley, 2003. Richard Monson-Haefel )

For more information about using XDoclet to simplify J2EE development, see XDoclet in Action. (Manning, 2003. Craig Walls, Norman Richards)

To learn more about Hibernate, see Hibernate in Action. (Manning, 2004. Christian Bauer, Gavin King)