Check that the JOnAS server is well installed. Below the result of the jonas check command :

Checking jonas.properties file...
- jonas.services : registry,jmx,jtm,db,security,resource,ejb2,ejb3,jaxws,web,ear,depmonitor

Checking JORAM configuration...

Checking port availability...

The JOnAS environment seems correct.

JPA stands for Java Persistence API, that's a specification extracted from the EJB 3.0 core that addresses persistency problem. Basically, it allows POJOs to be persisted and queried to and from a JDBC database.

Some JPA EntityManager Providers:

EJB 3.0 is the new Enterprise Java Beans specification targeting ease of development (EoD), a feature that was lacking in the previous version (EJB 2.x). This specification makes heavy use of Java 5 annotations (@Stateless, @Stateful, @MessageDriven, ...). One of the main advantages is the introduction of the concept of business method Interceptors.

EJBs are packaged in an EjbJar (.jar).

OW2 EasyBeans is the EJB 3.0 Container used in JOnAS 5.

JAAS is the authentication and authorization mechanism of Java EE that manages Principals and Roles.It is used in this sample to authenticate one of the application's client users.

JMS is the standard for Messaging system (MOM) in Java. It is used to asynchronously (using JMS Destinations like Queues or Topics) perform calls to the application (usually using MessageDriven Beans).

OW2 JORAM is the JMS provider used in JOnAS 5.

Servlets and JSPs compose the web front-end of a classical Java EE application. This is what is accessed when an HTTP URL (http://localhost:9000/javaee5-earsample for example) is called.

Servlets/JSPs are packaged in a web application (.war).

Application Clients are described in the Java EE specification as a way to package code for "heavy-weight" clients (not like web applications, usually known as "light-weight") of the application's business objects (EJBs, JMS Destinations, ...). Application Clients are top level Java EE modules so they benefit from uniform naming (java:comp/env).

Application Clients are packaged in .jar files.

EARs do not contain any code but are used to package together all the modules composing the application (EjbJar + Web Applications + Resource Adapters + Application Clients).

The javaee5-earsample needs the following JOnAS services to be activated for a flawless execution:

Access to the dataSource is provided by the resource service .

A resource adapter has been created at the JONAS_BASE creation time via newjb tool from the properties found in $JONAS_ROOT/build-jb.properties file:

rajdbc.hsql.user=jonas
rajdbc.hsql.password=jonas
rajdbc.hsql.url=jdbc:hsqldb:hsql://localhost:9001/db_jonas  
rajdbc.hsql.drivername=org.hsqldb.jdbcDriver  
rajdbc.hsql.jndiname=jdbc_1   
rajdbc.hsql.jdbcdriverjarfile=none
rajdbc.hsql.mappername=rdb.hsql

A JPA Entity bean is a simple class considered as a POJO (Plain Old Java Object). That means that the class has a public default constructor (no arguments). Moreover, for each attribute/field of the class, a getter and a setter method (getXYZ() and setXYZ(...)) has to be provided.

A JPA Entity bean will be annotated with the @Entity annotation.

The primary key is defined through an @Id annotation. In the earsample use case, this key has to be auto-generated. Finally, the getId() method should look like this:

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    public long getId() {
        return this.id;
    }

The Author bean is in relation with the bean Book, because an Author can have many Books (a OneToMany relationship).

The relation is also defined through an annotation:

    @OneToMany(mappedBy="author", fetch=FetchType.EAGER, cascade=CascadeType.ALL)
    public Collection<Book> getBooks() {
        return books;
    }

This relation is of One-To-Many type. The link will be done with the entity bean Book on the author attribute (owner of the relation).

The fetching type is EAGER (it means that when the Author instance is constructed, all the linked books are fetched). Another choice could have been to use LAZY fetching (meaning that the Books will only be fetched when the getBooks() method will be called). In the earsample use case, the entity beans will be accessed from a client in another Java VM (detached mode), so, to reduce latencies caused by network exchanges, it was decided to not use LAZY fetching. Because the Author and Books classes are usable from the remote JVM, they must implements the Serializable interface.

Finally, the cascading mode is set to ALL: when the Author bean is be persisted, all the Books related to the Author bean will be persisted too.

package org.ow2.jonas.examples.ear.entity;

import static org.ow2.jonas.examples.ear.entity.Author.QN.ALL_AUTHORS;
import static org.ow2.jonas.examples.ear.entity.Author.QN.FIND_AUTHOR;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;

/**
 * Author of a book.
 * @author Florent Benoit
 */
@Entity
@NamedQueries({@NamedQuery(name=ALL_AUTHORS, query="select o FROM Author o"),
               @NamedQuery(name=FIND_AUTHOR, query="select o FROM Author o WHERE name = :name")})
public class Author implements Serializable {
    /**
     * Store Query names.
     */
    public static interface QN {
        /**
         * Search all authors.
         */
        String ALL_AUTHORS = "Author.allAuthors";

        /**
         * Search a named author.
         */
        String FIND_AUTHOR = "Author.findAuthor";
    }

    /**
     * Serial Version UID.
     */
    private static final long serialVersionUID = 0L;

    /**
     * Primary key (will be auto generated).
     */
    private long id;

    /**
     * Name of the author.
     */
    private String name = null;

    /**
     * List of books written by the author.
     */
    private Collection<Book> books;

    /**
     * Default constructor.
     */
    public Author() {
        books = new ArrayList<Book>();
    }

    /**
     * Constructor with a given author name.
     * @param name - the name of the author
     */
    public Author(final String name) {
        this();
        setName(name);
    }

    /**
     * Relation ship (do not using lazy mode).
     * @return books written by this author
     */
    @OneToMany(mappedBy="author", fetch=FetchType.EAGER, cascade=CascadeType.ALL)
    public Collection<Book> getBooks() {
        return books;
    }

    /**
     * Add a book with a given title.
     * @param title - the title of the book
     */
    public void addBook(final String title) {
        Book livre = new Book();
        livre.setTitle(title);
        livre.setAuthor(this);
        getBooks().add(livre);
    }

    /**
     * Sets the collection of books written by this author.
     * @param books the list of the books
     */
    public void setBooks(final Collection<Book> books) {
        this.books = books;
    }

    /**
     * @return name of the author
     */
    public String getName() {
        return name;
    }

    /**
     * Sets the name of the author.
     * @param name - the name of this author
     */
    public void setName(final String name) {
        this.name = name;
    }

    /**
     * @return an id for this object (incremented automatically)
     */
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    public long getId() {
        return this.id;
    }

    /**
     * Sets the id of this author object.
     * @param id the given id of this author
     */
    public void setId(final long id) {
        this.id = id;
    }


    /**
     * @return String representation of this entity object.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(this.getClass().getName());
        sb.append("[id=");
        sb.append(getId());
        sb.append(", name=");
        sb.append(getName());
        sb.append("]");
        return sb.toString();
    }
}

	Note
	Two EJB-QL queries have been defined in the bean's class.They will be used to retrieve all the authors and an author with a given name respectively.

The Book bean is also a JPA entity bean. There is a relationship with the Author bean, one book being related to only one Author: Many-To-One relationship.

The @JoinColumn annotation defines the column of the primary key to be used for the association between 2 entity beans:

    @ManyToOne
    @JoinColumn(name="Author_id")
    public Author getAuthor() {
        return author;
    }

Here is the complete Book class:

package org.ow2.jonas.examples.ear.entity;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;

/**
 * Define a book.
 * @author Florent Benoit
 */
@Entity
@NamedQueries({@NamedQuery(name=Book.QN.ALL_BOOKS, query="select o FROM Book o"),
               @NamedQuery(name=Book.QN.FIND_BOOK, query="select o FROM Book o WHERE name = :name")
})
public class Book implements Serializable {

    /**
     * Defines Query names.
     */
    public static interface QN {
        /**
         * Search all books.
         */
        String ALL_BOOKS = "Book.allBooks";

        /**
         * Search a book.
         */
        String FIND_BOOK = "Book.findBook";
    }

    /**
     * Serial Version UID.
     */
    private static final long serialVersionUID = 0L;

    /**
     * Primary key.
     */
    private long id;

    /**
     * Author's book.
     */
    private Author author;

    /**
     * title of the book.
     */
    private String title;

    /**
     * Default constructor.
     */
    public Book() {

    }

    /**
     * Constructor. Build a new Book with the given title and written by the
     * given author.
     * @param title the given title
     * @param author the given author.
     */
    public Book(final String title, final Author author) {
        setTitle(title);
        setAuthor(author);
    }

    /**
     * @return the Author of this Book.
     */
    @ManyToOne
    @JoinColumn(name="Author_id")
    public Author getAuthor() {
        return author;
    }

    /**
     * Sets the author of this book.
     * @param author the given author.
     */
    public void setAuthor(final Author author) {
        this.author = author;
    }

    /**
     * @return the title of this book.
     */
    public String getTitle() {
        return title;
    }

    /**
     * Set the title of the book.
     * @param title - the title of the book
     */
    public void setTitle(final String title) {
        this.title = title;
    }

    /**
     * @return an id for this object (incremented automatically)
     */
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    public long getId() {
        return this.id;
    }

    /**
     * Sets the id of this author object.
     * @param id the given id of this author
     */
    public void setId(final long id) {
        this.id = id;
    }

    /**
     * @return String representation of this entity object.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(this.getClass().getName());
        sb.append("[id=");
        sb.append(getId());
        sb.append(", title=");
        sb.append(getTitle());
        sb.append("]");
        return sb.toString();
    }
}

It is required to have a persistency file META-INF/persistence.xml to describe useful information. For example, the JNDI name of the DataSource to be used for database persistency.

<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
<persistence-unit name="entity" transaction-type="JTA">
   <provider></provider>
   <jta-data-source>jdbc_1</jta-data-source>
   <properties>
      <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect" />
      <property name="hibernate.hbm2ddl.auto" value="create-drop"/>

      <property name="eclipselink.ddl-generation" value="drop-and-create-tables"/>
      <property name="eclipselink.ddl-generation.output-mode" value="database"/>
      <property name="eclipselink.target-database" value="HSQL"/>

      <property name="toplink.target-database" value="HSQL"/>
      <property name="toplink.ddl-generation" value="drop-and-create-tables"/>
      <property name="toplink.ddl-generation.output-mode" value="database"/>

      <property name="openjpa.jdbc.DBDictionary" value="hsql"/>
      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
   </properties>
</persistence-unit>
</persistence>

The Session beans have been separated into two logical parts: Writer and Reader beans provide the basic operations (read/write) on the entities, while Mailer and Initializer are using the previous ones to perform more advanced operations.

package org.ow2.jonas.examples.ear.reader;

import java.util.List;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;

/**
 * The {@link Reader} business interface is an un-restricted
 * read only view of the entities.
 * @author Guillaume Sauthier
 */
public interface Reader {

    /**
     * @return the list of all the persisted {@link Author}s.
     */
    List<Author> listAllAuthors();

    /**
     * @return the list of all the persisted {@link Book}s.
     */
    List<Book> listAllBooks();

    /**
     * Find a given {@link Author} using it's name as a key.
     * @param name {@link Author}'s name.
     * @return the first {@link Author} that matches the given name.
     */
    Author findAuthor(final String name);

    /**
     * Find a given {@link Book} using it's name as a key.
     * @param name {@link Book}'s name.
     * @return the first {@link Book} that matches the given name.
     */
    Book findBook(final String name);
}

    /**
     * Entity manager used by this bean.
     */
    @PersistenceContext
    private EntityManager entityManager = null;

    /**
     * @returns the list of all the persisted {@link Author}s.
     */
    public List<Author> listAllAuthors() {
        return entityManager.createNamedQuery(ALL_AUTHORS).getResultList();
    }

package org.ow2.jonas.examples.ear.reader;

import static org.ow2.jonas.examples.ear.entity.Author.QN.ALL_AUTHORS;
import static org.ow2.jonas.examples.ear.entity.Author.QN.FIND_AUTHOR;
import static org.ow2.jonas.examples.ear.entity.Book.QN.ALL_BOOKS;
import static org.ow2.jonas.examples.ear.entity.Book.QN.FIND_BOOK;

import java.util.List;

import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;

/**
 *The {@link ReaderBean} EJB is an unrestricted, read-only, Stateless Bean.
 * @author Guillaume Sauthier
 */
@Stateless
@Local(LocalReader.class)
@Remote(RemoteReader.class)
public class ReaderBean implements LocalReader, RemoteReader {

    /**
     * Entity manager used by this bean.
     */
    @PersistenceContext
    private EntityManager entityManager = null;

    /**
     * Find a given {@link Author} using it's name as a key.
     * @param name {@link Author}'s name.
     * @return the first {@link Author} that matches the given name.
     */
    @SuppressWarnings("unchecked")
    public Author findAuthor(final String name) {
        Query query = entityManager.createNamedQuery(FIND_AUTHOR);
        query.setParameter("name", name);
        List<Author> authors = query.getResultList();
        if (authors != null && authors.size() > 0) {
            return authors.get(0);
        }
        return null;
    }

    /**
     * Find a given {@link Book} using it's name as a key.
     * @param name {@link Book}'s name.
     * @return the first {@link Book} that matches the given name.
     */
    @SuppressWarnings("unchecked")
    public Book findBook(final String name) {
        Query query = entityManager.createNamedQuery(FIND_BOOK);
        query.setParameter("name", name);
        List<Book> books = query.getResultList();
        if (books != null && books.size() > 0) {
            return books.get(0);
        }
        return null;
    }

    /**
     * @return the list of all the persisted {@link Author}s.
     */
    @SuppressWarnings("unchecked")
    public List<Author> listAllAuthors() {
        return entityManager.createNamedQuery(ALL_AUTHORS).getResultList();
    }

    /**
     * @return the list of all the persisted {@link Book}s.
     */
    @SuppressWarnings("unchecked")
    public List<Book> listAllBooks() {
        return entityManager.createNamedQuery(ALL_BOOKS).getResultList();
    }

}

package org.ow2.jonas.examples.ear.writer;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;

/**
 * Remote interface for the bean Writer.
 * @author JOnAS team
 */
public interface Writer {

    /**
     * Persists a new {@link Author}.
     * @param author {@link Author} to add.
     */
    void addAuthor(final Author author);

    /**
     * Persists a new {@link Book}.
     * @param book {@link Book} to add.
     */
    void addBook(final Book book);

    /**
     * Cascade remove an {@link Author}.
     * @param author {@link Author} to be removed.
     */
    void removeAuthor(final Author author);

    /**
     * Cascade remove a {@link Book}.
     * @param book {@link Book} to be removed.
     */
    void removeBook(final Book book);
}

    /**
     * Entity manager used by this bean.
     */
    @PersistenceContext
    private EntityManager entityManager = null;

    /**
     * Persists a new {@link Book}.
     * @param book {@link Book} to add.
     */
    public void addBook(final Book book) {
        entityManager.persist(book);
    }

    /**
     * Cascade remove a {@link Book}.
     * @param book {@link Book} to be removed.
     */
    public void removeBook(final Book book) {
        entityManager.remove(book);
    }

package org.ow2.jonas.examples.ear.writer;

import javax.annotation.security.DeclareRoles;
import javax.annotation.security.RolesAllowed;
import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;

/**
 * This is an example of Session Bean, stateless, secured, available
 * with a Local and a Remote interface (with the same methods).
 * @author JOnAS team
 */
@Stateless
@Remote(RemoteWriter.class)
@Local(LocalWriter.class)
@DeclareRoles("earsample")
@RolesAllowed("earsample")
public class WriterBean implements LocalWriter, RemoteWriter {

    /**
     * Entity manager used by this bean.
     */
    @PersistenceContext
    private EntityManager entityManager = null;

    /**
     * Persists a new {@link Author}.
     * @param author {@link Author} to add.
     */
    public void addAuthor(final Author author) {
        entityManager.persist(author);
    }

    /**
     * Persists a new {@link Book}.
     * @param book {@link Book} to add.
     */
    public void addBook(final Book book) {
        entityManager.persist(book);
    }

    /**
     * Cascade remove an {@link Author}.
     * @param author {@link Author} to be removed.
     */
    public void removeAuthor(final Author author) {
        entityManager.remove(author);
    }

    /**
     * Cascade remove a {@link Book}.
     * @param book {@link Book} to be removed.
     */
    public void removeBook(final Book book) {
        entityManager.remove(book);
    }

}

package org.ow2.jonas.examples.ear.mail;

/**
 * The {@link Mailer} business interface is used to send a status
 * mail, with all the {@link org.ow2.jonas.examples.ear.entity.Author}s
 * and {@link org.ow2.jonas.examples.ear.entity.Book}s in the library.
 * @author Guillaume Sauthier
 */
public interface Mailer {

    /**
     * Send a mail to the given mail address.
     * @param address target mail address (must be of the form: xyz@abc.z)
     */
    void sendStatusMail(final String address);
}

@Stateless(mappedName="myMailerBean")
@Remote(Mailer.class)
public class MailerBean implements Mailer {

    /**
     * Mail Session used to send the Mail.
     */
    @Resource(mappedName="mailSession_1")
    private Session mailSession;

    /**
     * Template for the message's content.
     */
    @Resource(mappedName="mailMimePartDS_1")
    private MimePartDataSource mimePartDatasource;

    /**
     * {@link LocalReader} EJB (Local interface).
     */
    @EJB
    private LocalReader reader;

package org.ow2.jonas.examples.ear.mail;

import java.util.Collection;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.ejb.EJB;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.mail.Address;
import javax.mail.Message;
import javax.mail.MessageContext;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimePartDataSource;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;
import org.ow2.jonas.examples.ear.reader.LocalReader;

/**
 * @author Guillaume Sauthier
 */
@Stateless(mappedName="myMailerBean")
@Remote(Mailer.class)
public class MailerBean implements Mailer {

    /**
     * Mail Session used to send the Mail.
     */
    @Resource(mappedName="mailSession_1")
    private Session mailSession;

    /**
     * Template for the message's content.
     */
    @Resource(mappedName="mailMimePartDS_1")
    private MimePartDataSource mimePartDatasource;

    /**
     * {@link LocalReader} EJB (Local interface).
     */
    @EJB
    private LocalReader reader;

    /**
     * Send a mail to the given mail address.
     * @param address target mail address (must be of the form: xyz@abc.z)
     * @see org.ow2.jonas.examples.ear.mail.Mailer#sendStatusMail(java.lang.String)
     */
    public void sendStatusMail(final String address) {

        Address mailAddress = null;
        try {
            mailAddress = new InternetAddress(address);
        } catch (AddressException e) {
            System.err.println("Invalid mail address: " + e.getMessage());
            e.printStackTrace();
            return;
        }

        MessageContext context = mimePartDatasource.getMessageContext();
        Message message = context.getMessage();
        try {
            message.setContent(getContent(), "text/plain");
        } catch (MessagingException e) {
            System.err.println("Cannot set message content:" + e.getMessage());
            e.printStackTrace(System.err);
            return;
        }

        Transport transport = null;
        try {
            transport = mailSession.getTransport(mailAddress);
        } catch (NoSuchProviderException e) {
            System.err.println("No provider found for @:" + address);
            e.printStackTrace(System.err);
            return;
        }
        try {
            transport.connect();
            transport.sendMessage(message, new Address[] {mailAddress});
            transport.close();
        } catch (MessagingException e) {
            System.err.println("Cannot send message:" + e.getMessage());
            e.printStackTrace(System.err);
            return;
        }

        System.out.println("Mail successfully sent to: " + address);
    }

    /**
     * Generate the mail's content.
     * @return the mail message content.
     */
    private String getContent() {

        StringBuilder sb = new StringBuilder();

        // Print Header
        sb.append("---------------------------------------------------\n");
        sb.append(" OW2 JOnAS EAR Sample Mailer Bean.\n");
        sb.append("---------------------------------------------------\n");
        sb.append("Generated the " + new Date() + "\n");
        sb.append("\n");

        // Print the Authors
        List<Author> authors = reader.listAllAuthors();
        sb.append("List of all registered Authors (" + authors.size() + ") and their Books:\n");
        for (Author author : authors) {
            sb.append("  * " + author.getName() + " [" + author.getId() + "]\n");
            Collection<Book> books = author.getBooks();
            for (Book book : books) {
                sb.append("    - " + book.getTitle() + "[" + book.getId() + "]\n");
            }
        }

        // Print the Books
        sb.append("\n");
        sb.append("List of all registered Books:\n");
        List<Book> books = reader.listAllBooks();
        for (Book book : books) {
            sb.append("  * " + book.getTitle() + "[" + book.getAuthor().getName() + "]\n");
        }

        // Print the footer
        sb.append("\n");
        sb.append("Enjoy your new JOnAS !\n");
        sb.append("\n");
        sb.append("       -- JOnAS Team\n");

        return sb.toString();
    }

}

@RunAs("earsample")
public class InitializerBean implements Initializer {

package org.ow2.jonas.examples.ear.init;

import javax.annotation.security.RunAs;
import javax.ejb.EJB;
import javax.ejb.Remote;
import javax.ejb.Stateless;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;
import org.ow2.jonas.examples.ear.reader.LocalReader;
import org.ow2.jonas.examples.ear.writer.LocalWriter;

/**
 * The {@link InitializerBean} EJB is here to initialize only once
 * the Database/Entities. It simply checks if there is some {@link Author}s
 * already persisted; if none are found, we will inject defaults values.
 * @author Guillaume Sauthier
 */
@Stateless(mappedName="myInitializerBean")
@Remote(Initializer.class)
@RunAs("earsample")
public class InitializerBean implements Initializer {

    /**
     * Injected reference to the {@link org.ow2.jonas.examples.ear.writer.Writer} EJB.
     */
    @EJB
    private LocalWriter writer;

    /**
     * Injected reference to the {@link org.ow2.jonas.examples.ear.reader.Reader} EJB.
     */
    @EJB
    private LocalReader reader;

    /**
     * Initialize the minimal set of entities needed by the sample.
     * @see org.ow2.jonas.examples.ear.init.Initializer#initializeEntities()
     */
    public void initializeEntities() {

        if (reader.findAuthor("Honore de Balzac") == null) {
            // Balzac was not persited, add it now.
            Author balzac = new Author("Honore de Balzac");
            Book pereGloriot = new Book("Le Pere Goriot", balzac);
            balzac.getBooks().add(pereGloriot);
            Book lesChouans = new Book("Les Chouans", balzac);
            balzac.getBooks().add(lesChouans);

            // Persists the Author and all of his books
            writer.addAuthor(balzac);
        }

        if (reader.findAuthor("Victor Hugo") == null) {
            // Hugo was not persited, add it now.
            Author hugo = new Author("Victor Hugo");
            hugo.addBook("Les Miserables");
            hugo.addBook("Notre-Dame de Paris");

            // Store
            writer.addAuthor(hugo);
        }
    }

}

The javaee5-earsample application provides a MessageDriven bean, aka an EJB that receives JMS messages. A MDB does not have a business interface, therefore, it is not exposed (through JNDI) to application clients or other EJBs. The only way to interact with them is to send messages to the JMS destination they're listening on.

A MDB is defined using the @MessageDriven annotation. The bean is also configured with the help of the @ActivationConfigProperty annotations. In this case, they define the JNDI name of the JMS destination ("SampleQueue") and the destination type (can be javax.jms.Queue or javax.jms.Topic for JMS destinations). MDBs listening to JMS destinations need to implement the javax.jms.MessageListener interface.

@MessageDriven(activationConfig={
        @ActivationConfigProperty(propertyName="destination",
                                  propertyValue="SampleQueue"),
        @ActivationConfigProperty(propertyName="destinationType",
                                  propertyValue="javax.jms.Queue")
        })
@RunAs("earsample")
public class JMSMessageBean implements MessageListener {

This bean is also executed with the @RunAs annotation. This is needed because (like the Initializer) it uses the Writer bean, which is a secured bean.

Here is the code of the MDB:

package org.ow2.jonas.examples.ear.mdb;

import javax.annotation.security.RunAs;
import javax.ejb.ActivationConfigProperty;
import javax.ejb.EJB;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;
import org.ow2.jonas.examples.ear.reader.LocalReader;
import org.ow2.jonas.examples.ear.writer.LocalWriter;

/**
 * The {@link JMSMessageBean} is a message driven bean activated when a JMS
 * {@link Message} comes to a given Destination.
 * For each new {@link Message}, this bean will create and persists a new
 * {@link Book} instance.
 * This MDB is annotated with {@link RunAs} because it uses a secured
 * business interface.
 * @author Guillaume Sauthier
 */
@MessageDriven(activationConfig={
        @ActivationConfigProperty(propertyName="destination",
                                  propertyValue="SampleQueue"),
        @ActivationConfigProperty(propertyName="destinationType",
                                  propertyValue="javax.jms.Queue")
        })
@RunAs("earsample")
public class JMSMessageBean implements MessageListener {

    /**
     * Secured business interface.
     */
    @EJB
    private LocalWriter writer;

    /**
     * Unsecured {@link LocalReader} business interface.
     */
    @EJB
    private LocalReader reader;

    /**
     * Called when a new JMS {@link Message} is received on the destination.
     * This method will use the {@link LocalWriter} Bean interface to add
     * Books to a given Author.
     * @param message {@link Message} containing {@link Book} title.
     * @see javax.jms.MessageListener#onMessage(javax.jms.Message)
     */
    public void onMessage(final Message message) {

        // TODO to be removed
        System.out.println("Received JMS Message: " + message);

        // Extract Message's text value
        String text = null;
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            try {
                text = textMessage.getText();
            } catch (JMSException e) {
                System.err.println("Unexpected Exception: " + e.getMessage());
                e.printStackTrace(System.err);
                return;
            }
        } else {
            // not a TextMessage, I don't know what to do with it
            return;
        }

        Author edition = reader.findAuthor("Editions XY");
        if (edition == null) {
            edition = new Author("Editions XY");
            writer.addAuthor(edition);
        }

        // Persists a new Book
        Book book = new Book(text, edition);
        writer.addBook(book);

    }

}

This AC uses 3 beans that are freely available for anonymous usage: Initializer, Reader and Mailer.

The Client can be launched using the following command line:

>$ jclient -nowsgen $JONAS_BASE/deploy/javaee5-earsample.ear -jarClient not-secured-application-client.jar
ClientContainer.info : Use the application client
'/tmp/client-deployer-coqp/EARDeployableImpl/javaee5-earsample.ear/not-secured-application-client.jar'
of the Ear 'file:/tmp/client-deployer-coqp/EARDeployableImpl/javaee5-earsample.ear/'.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OW2 JOnAS :: EAR Sample :: Not Secured Application Client
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialization ... Done.
Get the RemoteReader Bean reference: org.ow2.jonas.examples.ear.reader.ReaderBean_org.ow2.jonas.examples.ear.reader.RemoteReader/7735352
List of authors, and their books:
 * Honore de Balzac
 -> Le Pere Goriot [id: 1]
 -> Les Chouans [id: 2]
 * Victor Hugo
 -> Les Miserables [id: 3]
 -> Notre-Dame de Paris [id: 4]
List of books:
 * Le Pere Goriot [Honore de Balzac]
 * Les Chouans [Honore de Balzac]
 * Les Miserables [Victor Hugo]
 * Notre-Dame de Paris [Victor Hugo]
Get the Mailer Bean reference: org.ow2.jonas.examples.ear.mail.MailerBean_org.ow2.jonas.examples.ear.mail.Mailer/7735352
Success.

The Initializer, Mailer and Reader beans are get via annotation based injection (no JNDI lookup is necessary).

@EJB
RemoteReader reader;

By default, a mail displaying the library content is sent to the ${user.name}@localhost address. This value can be changed by adding another mail address into the command line:

>$ jclient -nowsgen $JONAS_BASE/deploy/javaee5-earsample.ear \
           -jarClient not-secured-application-client.jar someone@somewhere.org

---------------------------------------------------
 OW2 JOnAS EAR Sample Mailer Bean.
---------------------------------------------------
Generated the Wed May 21 16:58:57 CEST 2008

List of all registered Authors (3) and their Books:
  * Honore de Balzac [1]
    - Le Pere Goriot[1]
    - Les Chouans[2]
  * Victor Hugo [2]
    - Les Miserables[3]
    - Notre-Dame de Paris[4]

List of all registered Books:
  * Le Pere Goriot[Honore de Balzac]
  * Les Chouans[Honore de Balzac]
  * Les Miserables[Victor Hugo]
  * Notre-Dame de Paris[Victor Hugo]

Enjoy your new JOnAS !

       -- JOnAS Team

Here is the not secured application client code:

package org.ow2.jonas.examples.ear.client;

import java.io.PrintStream;
import java.util.Collection;
import java.util.List;

import javax.ejb.EJB;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;
import org.ow2.jonas.examples.ear.init.Initializer;
import org.ow2.jonas.examples.ear.mail.Mailer;
import org.ow2.jonas.examples.ear.reader.RemoteReader;

/**
 * Simple Application Client.
 * @author Guillaume Sauthier
 */
public final class NotSecuredApplicationClient {

    /**
     * Empty default constructor for utility class.
     */
    private NotSecuredApplicationClient() {

    }

    /**
      * Link to the initializer bean.
      */
     @EJB
     static private Initializer initializerBean;

    /**
      * Link to the Remote Reader bean. Bean will be injected by JOnAS.
      */
     @EJB
     static private RemoteReader readerBean;

     /**
      * Link to the Mailer bean. Bean will be injected by JOnAS.
      */
     @EJB
     static private Mailer mailerBean;


    /**
     * @param args Command line arguments
     *
     */
    public static void main(final String[] args)  {

        PrintStream out = System.out;

        // Print Header
        out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
        out.println("OW2 JOnAS :: EAR Sample :: Not Secured Application Client  ");
        out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");

        // Init datas if needed
        out.print("Initialization ... ");
        initializerBean.initializeEntities();
        out.println("Done.");


        out.println("The RemoteReader Bean reference is : " + readerBean);

        // List registered authors and their books
        out.println("List of authors, and their books:");
        // retrieve again the authors list (now it has been initialized)
        List<Author> authors = readerBean.listAllAuthors();
        for (Author author : authors) {
            out.println(" * " + author.getName());
            Collection<Book> books = author.getBooks();
            for (Book book : books) {
                out.println(" -> " + book.getTitle() + " [id: " + book.getId() + "]");
            }
        }

        // Only list registered books
        List<Book> books = readerBean.listAllBooks();
        out.println("List of books:");
        for(Book book : books) {
            out.println(" * " + book.getTitle() + " [" + book.getAuthor().getName() + "]");
        }

        // Use the Mailer bean to send
        // Use the first command line argument as a mail address.
        // Fall back to a reasonable default ${user.name}@localhost
        String address = System.getProperty("user.name") + "@localhost";
        if (args.length > 0) {
            // Got an argument, use it ...
            address = args[0];
        }

        out.println("The Mailer Bean reference is : " + mailerBean);

        // Call the Mailer bean to send the expected e-mail.
        mailerBean.sendStatusMail(address);

        // OK, we're done
        out.println("Success.");

    }
}
        

This AC is secured using JAAS. It means that the client will be authenticated at startup.

The Client can be launched using the following command line:

>$ jclient -nowsgen $JONAS_BASE/deploy/javaee5-earsample.ear -jarClient jaas-secured-application-client.jar                            
ClientContainer.info : Use the application client
'/tmp/client-deployer-sauthieg/EARDeployableImpl/javaee5-earsample.ear/jaas-secured-application-client.jar'
of the Ear 'file:/tmp/client-deployer-sauthieg/EARDeployableImpl/javaee5-earsample.ear/'.
ClientContainer.info : Using the login/password specified in the jonas-client.xml file with a specific CallbackHandler
ClientContainer.info : Using JAAS loginContext 'javaee5-earsample'
from the file 'jar:file:/tmp/client-deployer-sauthieg/EARDeployableImpl/javaee5-earsample.ear/jaas-secured-application-client.jar!/jaas.config'.
ClientContainer.info : Starting client...
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OW2 JOnAS :: EAR Sample :: Secured Application Client
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialization ... Done.
Get the RemoteReader Bean reference: org.ow2.jonas.examples.ear.reader.ReaderBean_org.ow2.jonas.examples.ear.reader.RemoteReader/7735352
List of authors, and their books:
 * Honore de Balzac
 -> Le Pere Goriot [id: 1]
 -> Les Chouans [id: 2]
 * Victor Hugo
 -> Les Miserables [id: 3]
 -> Notre-Dame de Paris [id: 4]
Get the RemoteWriter Bean reference: org.ow2.jonas.examples.ear.writer.WriterBean_org.ow2.jonas.examples.ear.writer.RemoteWriter/7735352
Created a new Author:
org.ow2.jonas.examples.ear.entity.Author[id=0, name=Emile Zola]
Updated authors' list:
 * Honore de Balzac
 -> Le Pere Goriot [id: 1]
 -> Les Chouans [id: 2]
 * Victor Hugo
 -> Les Miserables [id: 3]
 -> Notre-Dame de Paris [id: 4]
 * Emile Zola
 -> Germinal [id: 45]
 -> La Bete Humaine [id: 46]
Cleaned added Author.
Success.

This AC has been configured to use the LoginCallbackHandler. The CallbackHandler will be configured by JOnAS to use the jonas/jonas username and password pair. So, nothing has to be done to provide a password interactively.

<application-client
  xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      http://java.sun.com/xml/ns/javaee/application-client_5.xsd"
  version="5">
  <display-name>OW2 JOnAS :: EAR Sample :: Secured Application Client</display-name>
  <callback-handler>org.ow2.jonas.security.auth.callback.LoginCallbackHandler</callback-handler>
</application-client>

<jonas-client xmlns="http://www.objectweb.org/jonas/ns"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.objectweb.org/jonas/ns
        http://jonas.ow2.org/ns/jonas-client_5_0.xsd" >

  <jonas-security>
    <jaasfile>jaas.config</jaasfile>
    <jaasentry>javaee5-earsample</jaasentry>
    <username>jonas</username>
    <password>jonas</password>
  </jonas-security>

</jonas-client>

javaee5-earsample {
    // Login Module to use for the example javaee5-earsample.

    // First, use a LoginModule for the authentication
    // Use the resource memrlm_1
    org.ow2.jonas.security.auth.spi.JResourceLoginModule required
    resourceName="memrlm_1"
    ;

    // Use the login module to propagate security to the JOnAS server
    org.ow2.jonas.security.auth.spi.ClientLoginModule  required
    ;
};

The CallbackHandler is configured using the jonas-security element: it will load the specified JAAS configuration file (jaas.config), then load the entry named javaee5-earsample and will create a dedicated LoginModule chain. The ClientContainer will then configure the CallbackHandler to provide a specified username and password when requested by the LoginModules.

As the authentication is done by the ClientContainer at startup, there are no security concerns in the code. The ClientContainer guarantees that if this code is executed, it is run by an authenticated user. If the user could not authenticate, the ClientContainer will exit before running the real client's code.

package org.ow2.jonas.examples.ear.client;

import java.io.PrintStream;
import java.util.Collection;
import java.util.List;
import java.text.MessageFormat;

import javax.ejb.EJB;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;
import org.ow2.jonas.examples.ear.init.Initializer;
import org.ow2.jonas.examples.ear.reader.RemoteReader;
import org.ow2.jonas.examples.ear.writer.RemoteWriter;

/**
 * Simple Application Client.
 * @author Guillaume Sauthier
 */
public final class SecuredApplicationClient {

    /**
     * Empty default constructor for utility class.
     */
    private SecuredApplicationClient() {

    }

       /**
      * Link to the initializer bean.
      */
     @EJB
     static private Initializer initializerBean;

    /**
      * Link to the Remote Reader bean. Bean will be injected by JOnAS.
      */
     @EJB
     static private RemoteReader readerBean;

     /**
      * Link to the Remote Writer bean. Bean will be injected by JOnAS.
      */
     @EJB
     static private RemoteWriter writerBean;

    /**
     * @param args Command line arguments
     *
     */
    public static void main(final String[] args) {

        PrintStream out = System.out;

        // Print Header
        out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
        out.println("OW2 JOnAS :: EAR Sample :: Secured Application Client      ");
        out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
        // Init. data if needed
        out.print("Initialization ... ");
        initializerBean.initializeEntities();
        out.println("Done.");

        out.println("The RemoteReader Bean reference is: " + readerBean);

        // List registered authors and their books
        out.println("List of authors, and their books:");
        // retrieve again the authors list (now it has been initialized)
        List<Author> authors = readerBean.listAllAuthors();
        for (Author author : authors) {
            out.println(" * " + author.getName());
            Collection<Book> books = author.getBooks();
            for (Book book : books) {
                out.println(MessageFormat.format(" -> {0} [id: {1}]", book.getTitle(), book.getId()));
            }
        }

        // Use the secured Bean (RemoteWriter)
        // ======================================
        out.println("Get the RemoteWriter Bean reference: " + writerBean);

        // Add another author, and some books
        Author zola = new Author("Emile Zola");
        Book germinal = new Book("Germinal", zola);
        Book beteHumaine = new Book("La Bete Humaine", zola);
        zola.getBooks().add(germinal);
        zola.getBooks().add(beteHumaine);

        // Display Author before storage
        out.println("Created a new Author: ");
        out.println(zola.toString());

        // Persists
        writerBean.addAuthor(zola);

        // See the new content
        out.println("Updated authors' list:");
        authors = readerBean.listAllAuthors();
        for (Author author : authors) {
            out.println(" * " + author.getName());
            Collection<Book> books = author.getBooks();
            for (Book book : books) {
                out.println(MessageFormat.format(" -> {0} [id: {1}]", book.getTitle(), book.getId()));
            }
        }

        // Remove Zola (and its books), so that next time the client
        // is executed, we can add them again.
        writerBean.removeAuthor(zola);
        out.println("Cleaned added Author.");
        out.println("Success.");

    }
}

This AC demonstrates how to connect a client to the application using JMS instead of using RMI EJB objects.

The Client can be launched using the following command line:

>$ jclient -nowsgen $JONAS_BASE/deploy/javaee5-earsample.ear
ClientContainer.warn : There are 3 clients in this ear, choosing the first one : jms-application-client.jar
ClientContainer.info : Use the application client '/tmp/client-deployer-sauthieg/EARDeployableImpl/javaee5-earsample.ear/jms-application-client.jar'
of the Ear 'file:/tmp/client-deployer-sauthieg/EARDeployableImpl/javaee5-earsample.ear/'.
ClientContainer.info : Starting client...
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OW2 JOnAS :: EAR Sample :: Messager Application Client
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialization ... Done.
Sended creation order for 'Encyclopedia Universalis Vol.0'
Sended creation order for 'Encyclopedia Universalis Vol.1'
Sended creation order for 'Encyclopedia Universalis Vol.2'
Sended creation order for 'Encyclopedia Universalis Vol.3'
Sended creation order for 'Encyclopedia Universalis Vol.4'
Sended creation order for 'Encyclopedia Universalis Vol.5'
Sended creation order for 'Encyclopedia Universalis Vol.6'
Sended creation order for 'Encyclopedia Universalis Vol.7'
Sended creation order for 'Encyclopedia Universalis Vol.8'
Sended creation order for 'Encyclopedia Universalis Vol.9'
Wait for 2500 ms...
Get Reader Bean ...
 * Honore de Balzac
 -> Le Pere Goriot [id: 1]
 -> Les Chouans [id: 2]
 * Victor Hugo
 -> Les Miserables [id: 3]
 -> Notre-Dame de Paris [id: 4]
 * Editions XY
 -> Encyclopedia Universalis Vol.0 [id: 5]
 -> Encyclopedia Universalis Vol.1 [id: 6]
 -> Encyclopedia Universalis Vol.2 [id: 7]
 -> Encyclopedia Universalis Vol.3 [id: 8]
 -> Encyclopedia Universalis Vol.4 [id: 9]
 -> Encyclopedia Universalis Vol.5 [id: 10]
 -> Encyclopedia Universalis Vol.6 [id: 11]
 -> Encyclopedia Universalis Vol.7 [id: 12]
 -> Encyclopedia Universalis Vol.8 [id: 13]
 -> Encyclopedia Universalis Vol.9 [id: 14]
Success.

The client acts as a message producer: it retrieves a JMS Queue object (named SampleQueue) and a JMS QueueConnectionFactory. Then, it uses both to send asynchronous messages to the server.

Each message represents a book registration order and contains the name of the Book to create.

On the application's side (in other words, on the server), there is a dedicated MessageDrivenBean (see the Section 2.2.3.2, “MessageDriven Bean”), that will be invoked for all the JMS messages received by the Queue.

Usage of JMS objects have to be declared in standard and specific deployment descriptors (using resource-ref and/or resource-env-ref, respectively jonas-resource and/or jonas-resource-env)

This JMS example shows how to use resource injection via @Resource annotation (see JMS client code below).

<application-client
  xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      http://java.sun.com/xml/ns/javaee/application-client_5.xsd"
  version="5">

  <display-name>OW2 JOnAS :: EAR Sample :: JMS Application Client</display-name>

  <!-- The JMS ConnectionFactory to use -->
  <resource-ref>
    <res-ref-name>jms/QueueConnectionFactory</res-ref-name>
    <res-type>javax.jms.QueueConnectionFactory</res-type>
    <res-auth>Container</res-auth>
  </resource-ref>

  <!-- The JMS Queue where Messages will be send -->
  <resource-env-ref>
    <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
  </resource-env-ref>

</application-client>

<jonas-client xmlns="http://www.objectweb.org/jonas/ns"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.objectweb.org/jonas/ns
        http://jonas.ow2.org/ns/jonas-client_5_0.xsd" >
  <jonas-resource>
    <res-ref-name>jms/QueueConnectionFactory</res-ref-name>
    <jndi-name>JQCF</jndi-name>
  </jonas-resource>

  <jonas-resource-env>
    <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
    <jndi-name>SampleQueue</jndi-name>
  </jonas-resource-env>
</jonas-client>

Here is the code of the JMS client:

package org.ow2.jonas.examples.ear.client;

import java.io.PrintStream;
import java.util.Collection;
import java.util.List;
import java.text.MessageFormat;

import javax.jms.*;
import javax.ejb.EJB;
import javax.annotation.Resource;

import org.ow2.jonas.examples.ear.entity.Author;
import org.ow2.jonas.examples.ear.entity.Book;
import org.ow2.jonas.examples.ear.init.Initializer;
import org.ow2.jonas.examples.ear.reader.RemoteReader;

/**
 * This application-client shows usage of JMS destinations to
 * interact with the server-side application.
 * @author Guillaume Sauthier
 */
public final class JMSApplicationClient {

    /**
     * Number of Books to be created.
     */
    private static final int ITERATION_NUMBER = 10;

    /**
      * Link to the initializer bean.
      */
     @EJB
     private static  Initializer initializerBean;

    /**
     *  JMS conectionFactoery
     */
    // Resource injection
     @Resource(mappedName="JQCF")
      private static ConnectionFactory factory;

    /**
     *   JMS Queue  SampleQueue
     */
    // Resource injection
     @Resource(mappedName="SampleQueue")
     private static Queue queue;


    /**
      * Link to the Remote Reader bean. Bean will be injected by JOnAS.
      */
     @EJB
     static private RemoteReader readerBean;

    /**
     * Empty default constructor for utility class.
     */
    private JMSApplicationClient() {

    }

    /**
     * @param args Command line arguments
     * @throws Exception JMS
     */
    public static void main(final String[] args) throws Exception {

        PrintStream out = System.out;

        // Print Header
        out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
        out.println("OW2 JOnAS :: EAR Sample :: Messager Application Client     ");
        out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");




        // Init. data if needed
        out.print("Initialization ... ");

        initializerBean.initializeEntities();
        out.println("Done.");

        // Send Book creation Messages
        Connection connection = factory.createConnection();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageProducer messageProducer= session.createProducer(queue);

        for (int i = 0; i < ITERATION_NUMBER; i++) {
            String title = "Encyclopedia Universalis Vol." + i;
            Message message = session.createTextMessage(title);
            messageProducer.send(message);
            out.println("Sended creation order for '" + title + "'");
        }

        // Close JMS objects
        messageProducer.close();
        session.close();
        connection.close();

        // Wait for some time ...
        // Remember JMS is for asynchronous messages :)
        final long period = 2500;
        out.println(MessageFormat.format("Wait for {0} ms...", period));
        Thread.sleep(period);

        out.println(MessageFormat.format("The RemoteReader Bean reference is: {0}", readerBean));
        // List Authors and Books
        List<Author> authors = readerBean.listAllAuthors();
        for (Author author : authors) {
            out.println(MessageFormat.format(" * {0}", author.getName()));
            Collection<Book> books = author.getBooks();
            for (Book book : books) {
                out.println(MessageFormat.format(" -> {0} [id: {1}]", book.getTitle(), book.getId()));
            }
        }

        out.println("Success.");

    }
}