In this part of the tutorial we will correct the bugs inherent in version 2.2 of Seam-gen and we will add some code to spice up our blog CMS.

First of all, our PostEdit.seam page is not working at all as it is. We shall fix this:

Figure 4.1 - Fixing the PostEdit.xhtml page

Open PostEdit.xhtml from the WebContent folder and find the <rich:tabPanel switchType=”ajax”> block. This is what’s causing the problem, because it has more than one tab – one to have the user select a category from a grid on another page, and the second one for selecting a user, since these two entites have @ManyToOne relationships to the post entity, and Seam-gen can’t handle generating more than one joined object selection user interface item in this version.

I don’t want an external grid for selection of a category anyway, so we will delete the entire <rich:tabPanel> block on this page, and instead make the category selectable from a pop-up menu using a typical JSF selectOneMenu UI component.

After you delete the <rich:tabPanel> go towards the beginning of the page and locate the code block starting with <s:decorate id=”titleField” template=”layout/edit.xhtml”>.
Within that block replace <h:inputTextarea id=”title” cols=”80″ rows=”2″ required=”true” value=”#{postHome.instance.title}”/> with <h:inputText id=”title” required=”true” value=”#{postHome.instance.title}”/>

Next, add the following code block below the closing tag (</s:decorate>) for titleField:

           <s:decorate id="categoryField" template="layout/edit.xhtml">
                <ui:define name="label">Post Category</ui:define>
                <h:selectOneMenu id="category"
                           required="true"
                              value="#{postHome.instance.title}">
                     <s:selectItems value="#{categoryList.resultList}" var="cat" label="#{cat.name}" noSelectionLabel="Please select..." />
                     <s:convertEntity />
                </h:selectOneMenu>
            </s:decorate>

Now find the following after the closing tag of richPanel (</rich:panel) :

<h:commandButton id="save"
              value="Save"
             action="#{postHome.persist}"
           disabled="#{!postHome.wired}"
           rendered="#{!postHome.managed}"/>

Replace #{!postHome.wired} with “false”
so that disabled=”false”.

Now open Post.xhtml and put the following between title and content:

<s:decorate id="category" template="layout/display.xhtml">
            <ui:define name="label">Post Category</ui:define>
            <h:outputText value="#{postHome.instance.category.name}"/>
</s:decorate>

We also want to display category and user names instead of IDs in the post list. So open PostList.xhtml and find the following (should be at line 69 or somewhere near):

<ui:param name="propertyLabel" value="User id"/>

Remove ” id” from the value then three lines below, replace #{_post.user.id} with #{_post.user.name}

Now let’s make the authenticator authenticate real users from the database. Open Authenticator.java (in net.ozar.blog.session package). After line 16 (@In Credentials credentials) add the following:

    @In(required = false)
    @Out(required = false, scope = SESSION)
    private User user;
    @In
    private EntityManager entityManager;
    @In
    private FacesMessages facesMessages;

You may want to

import net.ozar.blog.entity.User;
import static org.jboss.seam.ScopeType.SESSION;
import org.jboss.seam.annotations.Out;

(JBoss Tools can fail to auto-guess where to import ScopeType.SESSION.)

Here we are using a Seam-specific technique called “bijection” a term invented by makers of Seam. What bijection is basically injecting the User component using dependency injection, and also ‘outject’ing it, so that it is made available to both the method handling the event and the subsequent view.

Delete or comment the following and replace it with the code snippet below the following:

        //write your authentication logic here,
        //return true if the authentication was
        //successful, false otherwise
        if ("admin".equals(credentials.getUsername()))
        {
            identity.addRole("admin");
            return true;
        }
        return false;

The final version of the Authenticator.java should be like the following:

package net.ozar.blog.session;

import java.util.List;

import javax.persistence.EntityManager;

import net.ozar.blog.entity.User;
import static org.jboss.seam.ScopeType.SESSION;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Logger;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Out;
import org.jboss.seam.log.Log;
import org.jboss.seam.security.Credentials;
import org.jboss.seam.security.Identity;

@Name("authenticator")
public class Authenticator
{
    @Logger private Log log;

    @In Identity identity;
    @In Credentials credentials;

    @In(required = false)
    @Out(required = false, scope = SESSION)
    private User user;
    @In
    private EntityManager entityManager;
    @In
    private FacesMessages facesMessages;

    @SuppressWarnings("unchecked")
    public boolean authenticate()
    {
        log.info("authenticating {0}", credentials.getUsername());
        List<User> adaylar =  entityManager.createQuery("select u from User u where u.login=#{identity.username} and u.password =#{identity.password}").getResultList();

        if (adaylar== null || adaylar.size()==0) {
			String msj="No user by that name or password can be found";
			log.error(msj);
                        facesMessages.add(msj);
			return false;
		} else {
			user = (User) adaylar.get(0);
			if (user.getLevel()>1 ) identity.addRole("admin");
			return true;
		}
    }
}

I will be updating this post shortly demonstrating further optimization to the application and finally deploying it to a server in the cloud. Stay tuned!

In this part III of the tutorial, we’ll build the entity classes from the database we created in Part I and configure the Seam project we created in Part II so as to make it fully compatible with Apache Tomcat.

Creating The Model Layer

We’ll use Hibernate‘s reverse engineering tool (hbm2java) embedded in Seam-gen to create the entity classes from the database we created in part 1.

Figure 3.1 - Generating entities from database in JBoss Seam

Right-click the project blog in project explorer and select New > Seam Generate Entities.

Figure 3.2 - Reverse Engineering from database

Select reverse engineer from database and then click ‘next‘ like shown in figure 3.2.

Figure 3.3 - Reverse engineering from database (2)

To display the database schema in the first place, you may need to hit the refresh button first. Since we set everything up properly (did you, too? in Part II, we don’t need to tackle anything else – just click Finish.

Figure 3.4 - Seam-generated entity classes and controllers

And voilà! After some processing, our entities should show up in the project explorer along with some controller classes as well as the (JSF) xhtml files in the web content as shown in figure 3.4.

The classes with the suffix ‘Home’ such as CategoryHome are some sort of a JSF managed bean + JPA controller combo’s. In fact, these classes extend Seam’s EntityHome class which is pre-built with most of the methods for instantiating the entity object and performing CRUD operations using Seam’s built-in EntityManager. Likewise, the other classes in the session package with the suffix ‘List’ such as CategoryList extend  Seam’s EntityQuery class which make it easy to perform certain basic persistence queries on entities without having to write so many lines of code to invoke the EntityManager, start transactions and run queries.

In the next section we’ll do some hacks and mods to the project and make it Tomcat-savvy, so that we can preview what we’ve done so far by running the application and see it in the browser for ourselves.

Configuring the Seam Project for Tomcat Deployment

There are a few articles, blog and forum posts all over the Internet which describe how to deploy a Seam application on Tomcat. But in my experience, none of them alone were accurate for deploying Seam 2.2 apps on Tomcat 6 (and perhaps 7, too) without crashing Tomcat at startup. Either one or more of the required jars were never mentioned, or components.xml modification was not correctly described.

In this part of the tutorial, I will explain step-by-step what exactly is necessary to be done and which versions of which libraries are exactly the ones to be included in the project so that Tomcat won’t crash as soon as started up – and neither your application.

The required library jar files (some of them are already be present in the project as we set up user defined JSF libraries in part II and some of them – and unfortunately not all of them come with recent versions of Seam):

• antlr.jar
• asm.jar
• cglib.jar
• commons-beanutils.jar
• common-collections.jar
• commons-digester.jar
• commons-lang.jar
• commons-logging.jar
• dom4j.jar
• hibernate-annotations.jar
• hibernate-commons-annotations.jar
• hibernate-entitymanager.jar
• hibernate.jar
• hibernate-validator.jar
• javassist.jar
• jboss-archive-browsing.jar
• jboss-el.jar
• jboss-seam-debug.jar
• jboss-seam.jar
• jboss-seam-ui.jar
• jsf-api.jar
• jsf-facelets.jar
• jsf-impl.jar
• jstl.jar
• jta.jar
• lucene-core.jar
• persistence-api.jar
• richfaces-api.jar
• richfaces-impl.jar
• richfaces-ui.jar
• \test\hibernate-all.jar

You can download all of these necessary files in a zip file here. After downloading, decompress them in a folder on your computer and follow the steps in the next section to import them into your project. Please note that since some of them are already present in your project’s WEB-INF/lib, be sure to uncheck ‘overwrite existing files’ option.

Importing the .jar files into the Eclipse Project

Expand the WebContent folder and then the WEB-INF folder residing inside of it in Eclipse’s package explorer so that you reveal WEB-INF/lib. Then right-click lib, and select ‘Import…’ from the dropdown menu that pops up.

Figure 3.5 - Importing Seam jars into WEB-INF/lib

Select ‘File System’ as the import source and click ‘Next’. Then select the folder in your file system (i.e. Windows explorer on the PC, or the Finder on the Mac)

Figure 3.6 - Copying external JARs into your Eclipse Project from the file system

Refer to figure 3.6 and make sure you tick the checkbox next to the name of the folder containing the jar files to select them all at once (if you don’t want to individually select the checkboxes of the jar files yourself) then make sure of the following:

• Into folder: blog/WebContent/WEB-INF/lib (importing the jars anywhere outside this path will fail you)
• Overwrite existing resources without warning had better be unchecked. Why? Because if you try this tutorial with a version of Seam other than 2.2, you probably want to keep the original versions of the duplicate jars that shipped with Seam – for not risking anything to break up.
• Create selected folders only is as good as checked. (It should be so by default anyway)

Click Finish to start importing the Seam libraries from the file system.

Figure 3.7 - Dealing with duplicate Seam libraries in the import process

In case you’re asked what to do about overwriting some of the libraries already existing in your project, go with ‘No to All’. Because if you try this tutorial with a version of Seam other than 2.2, you probably want to keep the original versions of the duplicate jars that shipped with Seam – for not risking anything to break up.

Modifying the data source for Tomcat

Every Seam project created with Seam-Gen or JBoss Tools comes with a datasource definition in XML format called ‘blog-ds.xml’ residing in a folder called ‘resources’ in the project folder. This approach of ‘deploying the datasource to the server’ suits the JBoss AS very well, but in the case of Tomcat, the portable datasource definition file is useless and we need to define the datasource differently on Tomcat so as to have it supply us the database connection when running our application.

Therefore we will now create a file named context.xml in our WebContent/META-INF folder and create a new resource there. Fill the context.xml with the following definitions:

<?xml version="1.0" encoding="UTF-8"?>

<Context docBase="blog" path="/blog" reloadable="true">

  <Resource auth="Container" driverClassName="com.mysql.jdbc.Driver"
  maxActive="20" maxIdle="10" maxWait="-1" name="jdbc/seamblog"
  password="12345"
  type="javax.sql.DataSource" url="jdbc:mysql://localhost:3306/seamblog"
  username="blogger" />

</Context>

Now we need to handle the other configuration files which use this connection. First of them is persistence.xml is which contains the definition of our JPA persistence unit. We need to change the jta-data-source value which is normally intended for a container-managed transaction such as on JBoss AS. Since we’re working for Tomcat deployment here, we need to change the transaction type to the local resource in persistence.xml.

Open persistence.xml (src/main/META-INF/persistence.xml) and modify the persistence unit so as to resemble the following:

<?xml version="1.0" encoding="UTF-8"?>
<persistence-unit name="seamblogPU" transaction-type="RESOURCE_LOCAL">
      <provider>org.hibernate.ejb.HibernatePersistence</provider>
      <jta-data-source>java:comp/env/jdbc/seamblog</jta-data-source>
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"/>
         <property name="hibernate.hbm2ddl.auto" value="validate"/>
         <property name="hibernate.show_sql" value="true"/>
         <property name="hibernate.format_sql" value="true"/>         
         <property name="hibernate.default_catalog" value="seamblog"/>
         <property name="jboss.entity.manager.factory.jndi.name" value="java:/blogEntityManagerFactory"/>
      </properties>
   </persistence-unit>

Here we defined the data-source as java:comp/env/jdbc/seamblog  for Tomcat requires all connection JNDI names to be prefixed with java:comp/env.

Finally we will modify the components.xml which holds the definition of certain Seam components and resides in WEB-INF folder.

There are a few things to do in components.xml

First add an XML namespace definition for transaction:

xmlns:transaction="http://jboss.com/products/seam/transaction"

and its

 xsi:schemaLocation = http://jboss.com/products/seam/transaction http://jboss.com/products/seam/transaction-2.2.xsd

then add the following line somewhere:

<transaction:entity-transaction entity-manager="#{entityManager}"/>

Also the persistence-related definitions should be something like:

   <!-- If you are using Tomcat, you need the following to have your PU started -->
  <persistence:entity-manager-factory name="entityManagerFactory"
                     persistence-unit-name="seamblogPU"/>
   <!-- If you are using Tomcat, you need the following as well to have the entityManagerFactory used -->
  <persistence:managed-persistence-context name="entityManager" auto-create="true"
                         entity-manager-factory="#{entityManagerFactory}"/>

   <!-- If you are not using JBoss AS 5 or above, the following should be commented -->
<!--    <persistence:managed-persistence-context name="entityManager" auto-create="true" -->
<!--                            persistence-unit-jndi-name="java:/blogEntityManagerFactory"/> -->

Least but not last, open up your web.xml and add the following:

<resource-ref>
        <res-ref-name>jdbc/seamblog</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
 </resource-ref>

Running the Seam Blog Project for the first time

Now let’s run the project and see what we’ve done.

Right-click the project name and select Run As > Run on Server from the pop-up menu. Remember to choose Tomcat for target server.

If you’ve done everything correctly or at least as instructed in this tutorial, you should be welcomed with Seam’s cute welcome page thanks to its default template as shown in figure 3.7.

Figure 3.7 - The Successfully Deployed Seam Blog Project

You can customize the welcome page by modifying home.xhtml at the root of the web content folder.
Now let’s test our new app a little: Go to the menu bar of Seam Blog and click Browse data to pull down a menu from which I want you to select ‘Category List’. Here we will encounter a blank categories list. Click ‘Create Category’ and after a possible user authentication which you may pass just by entering ‘admin’ as the username and leaving the password blank (we haven’t programmed the user authentication yet), you should then encounter a form like the one in figure 3.8:

Figure 3.8 - Creating a new category for the blog

I created my first category as ‘General’ and hit ‘Save’. Then I’ll repeat the step to create a few more categories such as ‘IT’, ‘Internet’, ‘Movies’ and ‘Music’.

Figure 3.9 - Seam Blog category list filled up

Finally I’ll go to Users section, to create the blog’s first user: Me!

Figure 3.10 - Creating blog's users

The user entry page signals us that the form needs our help with certain aspects such as converting the password field into a real password field hiding the entered characters – i.e. JSF-wise an <h:inputSecret /> and the level field seems to make no sense there and should be worked on.

You could also choose to experiment with the post entry form which I saved for last, but not as best, yet you will probably find out how peculiar it is to select a category and a user from a grid on a separate screen instead of a pop-up menu when entering a blog post – assuming of course you did not get a “duplicate Id for a component selectParent” error which arises due to a Seam-gen 2.2 bug when the generated page of a given entity has more than one other object association – in our case the Post entity has Many-to-One associations of the Category and User entities respectively.

Our project has now some basic CRUD functionality and runs on Tomcat. In Part IV of the tutorial, we will customize the code, correct the buggy code Seam-gen gave us, and add some of our own code, all in JSF.

In part I of the tutorial, I provided the instructions about the development environment and  how to create the blog’s database. In this part II, using Eclipse’s JBoss tools plugin, we’ll create and configure the JBoss Seam web project and prepare it for full Tomcat-compatibilty and for the creation the basic CRUD (create, read, update and delete) functionality of entities which will be reverse engineered from the database using hbm2java embedded in Seam-gen whose GUI version comes built-in with JBoss Tools.

The Development Environment

To be able to follow the tutorial and reproduce the same results, it’s best (if not mandatory) that you have exactly the same version of the tools and plug-ins I mentioned in the previous post. As of this part (and so on) I’ll instruct on Eclipse Helios with JBoss Tools 3.2. You can also refer to my post titled ‘Matrix of compatible platforms and runtimes with JBoss Tools‘ to see which version of Eclipse and other stuff (such as Seam framework version) is compatible with which version of JBoss tools plugin, etc.

So here we go. Now launch Eclipse if you already haven’t done so.

Figure 2.1 - Changing perspective in Eclipse

First of all, we shall change the perspective in Eclipse to Seam – that option, however, is only available if you have JBoss tools installed. See figure 2.1 and 2.2.

Figure 2.2 - Switching to the Seam perspective in Eclipse

Now since we need to define a server runtime – in this case Apache Tomcat, go to the Servers tab on the bottom pane, right click the empty area and select New > Server as shown in figure 2.3.

Figure 2.3 - Defining a new server in Eclipse

Then in the window which opens, specify the server as Apache Tomcat 6 as shown in figure 2.4.

Figure 2.4 - Adding Tomcat 6 as the web server in Eclipse workspace

As you select Tomcat v6.0 server from the Apache category in the list box, server’s host name will automatically be set to localhost as well as server name field being set to Tomcat v6.0 Server at localhost which are descriptive and good enough, therefore we’ll leave the rest as it is and click next, then finish.

Creating the Seam project for Tomcat and MySQL

Now we’re ready to create our Seam project. From the File menu on Eclipse’s main menu bar select New > Seam Web Project as shown in figure 2.5. (Last reminder: this option only available if you have JBoss Tools installed, otherwise see the beginning of this post)

Figure 2.5 - Creating a new Seam web project in Eclipse

Now we need to specify the settings and configuration for our new Seam web project which is a blog (CMS).

Figure 2.6 - Specifying configuration of a new Seam web project in Eclipse

Referring to figure 2.6, you can make the following settings.

• Project name: blog
• Target runtime: Apache Tomcat 6.0
• Dynamic web module version: 2.5
• Target Server: Tomcat v6.0 server at localhost
• Configuration: Dynamic Web Project with Seam 2.2

Click Next twice and you will get something like in figure 2.7:

Figure 2.7 - Specifying JSF implementation library for the Seam project

In this screen (as shown in figure 2.7), we need to specify the JSF implementation library which is to be Mojarra 1.2. If we had chosen a JBoss Application Server for deployment, we would have had the possibility of using the libraries bundled with the JBoss runtime. Since we’ll deploy to Tomcat we need to go with the user library option which we need to provide ourselves. So click the tiny ‘manage libraries’ button and click ‘New..’ in the new window which opens. Here, I named the new user library as GO-JSF. You can name yours whatever you want as this is a one-time thing.

Figure 2.8 - Adding JSF libraries to the Seam project manually

Now after you provide the name for the new user library intended for our JSF jars, we we need to put them in there. Make sure you have downloaded Mojarra 1.2 jars or my bundle called GO-JSF and have them somewhere accessible and ready (as separate jar files) on your computer.

Figure 2.9 - Adding JSF 1.2 jar files to user-defined library in Eclipse

Refer to figure 2.9 for a complete list of JSF jar files to our custom library and namely they are:

• jsf-api.jar
• jsf-facelets.jar
• jsf-impl.jar
• jsf-tlds.jar
• jstl.jar

Click OK and then make sure the user JSF library’s checkbox is checked as well as an option saying “include libraries with this application”. The remaining settings regarding JSF in this screen should be as good as defaults, so you can click ‘next’ if what’s on your screen resembles figure 2.10 (otherwise make your settings similar to it).

Figure 2.10 - JSF settings of Seam web project in Eclipse

On the next screen we need to specify the Seam runtime and a database connection profile for ORM. If you’re making a Seam development for the first time with the IDE, the Seam runtime selection pop-up menu will probably be blank in which case we need to add one. We want Seam 2.2.2, so if it is not present as an option we need to ‘add’ it.

Figure 2.11 - Configuring Seam facet in Eclipse

After clicking ‘Add’ (assuming you needed to), you should click browse in the pop-up window, to specify the location of the Seam framework folder you have (downloaded) on your hard-drive. Make sure it’s version 2.2(.2) and click Finish.

Figure 2.12 - Specifying Seam 2.2.2 final as the Seam runtime

Finally we can enter the database settings. Select MySQL (InnoDB) for database type and click ‘New’ or ‘Edit’ depending on whether you’re doing this for the first time in the given workspace or not.

Figure 2.13 - Configuring database connection profile in Seam

Figure 2.14 demonstrates how to configure the database settings in detail:

Figure 2.14 - Configuring MySQL connection profile for Seam project (1)

Figure 2.15 - Configuring MySQL connection profile for Seam project (1)

When you reach to the next screen, you will need to specify the version and location of the MySQL JDBC driver library (.jar) if you’ve never done this before in the current workspace.

You’ll know what to do if the drop-down list is blank or you don’t see an item indicating that MySQL 5.1 JDBC driver is installed. (See figure 2.15) Just click the tiny button next to it on the right and then refer to figure 2.16.

Figure 2.16 - Selecting MySQL JDBC Driver 5.1 for Seam project

Switch to the Jar List tab in the New Driver Definition window to put in the appropriate MySQL JDBC jar, otherwise the OK button won’t even be active to save the settings and close the window.

Figure 2.17 - Editing the JAR location

Figure 2.18 - Indicating the file path of MySQL JDBC driver library (jar)

Figure 2.19 - Seam database connection details

After you specify the location of the jars, you can specify the connection details as shown in figure 2.19 and finalize the settings. Also click the Test connection button to see if you have configured everything properly. If the ping fails, repeat the steps to create a connection profile and defining the JDBC driver.

As soon as the connection settings are OK, we will lastly specify the model and the controller package names under the source code generation section. Session bean package name refers to the controller although we won’t use any EJB here since we’re sticking with Tomcat.

Enter net.ozar.blog.session for the controller package name, and net.ozar.blog.entity for the entity bean package name, and then click the Finish button to finalize the creation steps of the Seam web project, in this case the blog.

Figure 2.20 - Finalizing Seam web project creation

In part III of the tutorial, we will create the model layer and some basic controller code (for CRUD operations)  and then modify the project’s configuration so as to make it Tomcat-compatible.

Tired of simple hello world tutorials or tutorials taking you only as far as user login and registration examples? Here’s an intermediate-level tutorial in which I will demonstrate how to make a blog CMS application using JBoss Seam incorporating JSF (w/Facelets), Hibernate JPA and how to deploy it to Apache Tomcat web server. With this tutorial, I also aim to provide complete and correct instructions for preparing a Seam 2.2 project to be deployed on Tomcat without errors.

The blog we’ll make in this tutorial is simple, but the tutorial itself is not.

Here’s a list of technologies and frameworks with their versions which we will use here:

• Java EE 5 (on JRE 6)
• JBoss Seam 2.2.2 (incorporating JSF 1.2 + Facelets, RichFaces 3.3.3 and Hibernate JPA 1.0)
• Apache Tomcat 6.0
• MySQL 5.1 (community edition)

And the tools we will use such as the IDE and the database GUI administartion tool:

• Eclipse Helios for Java EE developers
• JBoss Tools 3.2
• PremiumSoft Navicat 9.07

Make sure you get the tools above or some equivalent so that you can follow me as I go along the tutorial. Although Seam development with JBoss Tools makes it easy to incorporate the necessary libraries (jars) into your project, in case of Tomcat development you will need to bring along your own set of JSF libraries – for the sake of the tuorial and making life easier I created a bundle of the necessary jar files in a zip file which you could download from here.

Creating the Blog Database

Assuming you already have a MySQL 5.1 database server installed and running, we will create the blog database on MySQL using Navicat and then the necessary tables.

Figure 1.1

In Navicat, having your localhost defined and connected to, right-click localhost and select ‘Create new database…’ and then you should be presented with a dialog box as shown in figure 1.1 asking you to specify the database name and select a character set from a drop-down menu.

Enter “seamblog” (without quotes) and select UTF-8 (unicode) from the pull-down menu below, then click OK. (Optionally you can specify a collation matching that of your language if it is anything different than English.

Figure 1.2 - Manage Users

Then click ‘Manage users’ the big button with a user icon on the toolbar of Navicat’s main window whileyour newly created database is selected. Alternatively you can right-click ‘seamblog’ from the databases list and select ‘Manage Users…’ from the pop-up menu.

Name the user ‘blogger’, the host localhost and enter ’12345′ as the password then click OK.

Figure 1.3 - Granting Seam blog priveleges to the blogger user in Navicat

Click the tiny triangle (bullet) preceding the blogger@localhost user to display the database list, and select seamblog from the list, then Select All the priveleges on the right pane of the window as shown in figure 1.3. Finally click ‘save’.

Now it’s time we created the necessary tables.

Figure 1.4 - Creating the 'category' table in Navicat

Click ‘New Table’ from the the Navicat toolbar, then create three fields named ‘id’ (smallint, primary key, auto-incrementing), ‘name’ (varchar, 31 characters length) and version (smallint, with null values allowed) respectively. Then save the table with the name ‘category’. It’s easy with Navicat’s intuitive graphic user interface. An SQL dump of the database is also included at the end of the database section of the tutorial.

As the name suggests, this table is where the categories of blog posts will be kept. Now onto the ‘user’ table:

Figure 1.5 - Creating the blog's 'user' table in Navicat

Create the user table with the following fields as shown in figure 1.5:

• id (mediumint, allow null, primary key with auto-increment)
• name (varchar 50)
• login (varchar 12)
• password (varchar 40, allow null)
• email (varchar 50)
• level (tinyint)

And finally the table for posts:

Figure 1.6 - Creating the 'post' table in Navicat

For this one we need the following fields as shown in figure 1.6:

• id (int, auto-incrementing primary key)
• user_id (mediumint, null values allowed)
• category_id (smallint)
• title (varchar 200)
• content (longtext)
• post_date (datetime)
• version (smallint, allowing null values)

Now that’s it for creation of the tables. Next, we will define some foreign-key restraints. This is absolutely necessary for mapping the many-to-one and one-to-many relationships between the JPA entities.

Figure 1.7 - Defining a many-to-one relationship between post and user in Navicat

Now right-click the post table from the tables list and select ‘Design table’ from the pop-up menu. In the table design window, switch to the ‘Foreign Keys‘ tab. Then click ‘Add foreign key‘ button on the toolbar.

Name the foreign key ‘fk_post_4_user’, choose user_id for field name(s), seamblog for reference database, user for reference table, and check ‘id’ from the pop-up menu under ‘Foreign Field Names’ as shown in figure 1.7. Select cascade on delete, and restrict on update.

What this FK definition means is that for a post we have many users to choose from, and a user can have many posts.

Now we need one last foreign key for defining a many-to-one relationship between post and categories, so that a post can have one category to choose from a list of many categories, but a single category can have many posts.

Refer to figure 1.8 for creating the foreign key named “fk_post_4_category’.

Figure 1.8 - Defining a foreign key between post and category in Navicat

That’s it for the database which I want to keep simple for the time being.

In Part II, I’ll show you how to create the Seam project and the database connection settings and in Part III the creation of the model layer by reverse engineering this very database, so it is important that you carefully follow the instructions here for creating the seamblog database.

You can download the database dump file in .sql format in the downloads section (which has some sample data in it – posts and categories entered with the finished version of the blog)

Some programmers think JSF has a steep learning curve

When it comes to developing web applications using Java, writing all the code from scratch has its advantages if you’re trying to master a new technology, but for real life web applications, you have to go for a framework as many expert developers would agree. Otherwise you risk a great deal of failure because of having allocated too much time and too many resources by re-inventing the wheels.

There are some hardliners who still argue why there’s ever a need for a framework, since everything can be accomplished by Servlets, JSP and Filters. One of them is Bear Bibeault author of JQuery in Action.

-Adeel Ansari

The cost is an important factor—although “free” in most cases also means widespread usage, community support, and no dependence on a single vendor. It takes some time for developers to get used to a framework and be good at it. Therefore choosing a framework as a long-term strategy. You cannot be switching frameworks for every project. Sticking with one framework also helps as once the expertise in that framework builds up; customizing the framework also becomes a possibility.

A tempting option is for organizations to build their own framework to address needs specific to the kind of work the organization undertakes. Although it does seam seem to make sense on paper, for my money, this is a suicidal strategy. Thoroughly testing and maintaining a framework is a huge task that will need dedicated human resources. These few people would become critical and the only source of support for others using that framework. Also, with so many quality frameworks available for free, I seriously doubt it really is necessary.

As with many web frameworks emerging nowadays, the ever-increasing number of Java web application frameworks out there today is intimidating for many developers even to look into because of being presented with too many choices. However, matching the criteria of popularity, widespread usage and tooling support, I can list a few of the best Java web application frameworks here and in a descending order of my personal choice. Sorry if I haven’t listed your favorite Java web framework here, feel free to agree or disagree in the comments section.

1. Struts (2)
2. Wicket
3. Spring
4. JSF
5. Seam

Struts 2

Struts 1.x was the first most popular and widely accepted web framework for Java, because of the way it handled the MVC model 2 paradigm and its action-based architecture. It was an elegant framework that handled the flow of application and a lot of other routine tasks. Another advantage of using Struts was an incredibly growing number of developers preferred it as a de-facto J2EE standard. Many of the popular Java IDEs also provided tools for Struts development, making life even easier for the programmers. Even today IDEs like NetBeans and JBoss Developer Studio have built-in support for Struts 1.

Apache Struts 2 was originally known as WebWork 2 built on top of XWork, which provided a generic command pattern framework as well as an Inversion of Control container. After working independently for several years, the WebWork and Struts communities joined forces to create Struts2.

Programming the abstract classes instead of interfaces is one of design problem of Struts 1 framework that has been resolved in Struts2. Most of the Struts 2 classes are based on interfaces and most of its core interfaces are HTTP independent. Struts 2 Action classes are framework-independent and are simplified and they resemble POJOs. Framework components can easily be loosely coupled.

Struts 2 Actions are simple POJOs. Any java class with execute() method can be used as an Action class. With Struts 2 you don’t even have to implement interfaces. Inversion of Control is introduced while developing the action classes. This make the actions to be neutral to the underlying framework

ActionForms are also gone in Struts2. Simple JavaBean flavored actions are used to put properties directly. No need to use all String properties.

Biggest downfall of Struts 2 is poor documentation and no debugger feedback for missing properties or invalid OGNL expressions which makes debugging a nightmare.

Wicket

“With proper mark-up/logic separation, a POJO data model, and a refreshing lack of XML, Apache Wicket makes developing web-apps simple and enjoyable again” says the Apache Wicket Team in their description of this young and popular framework. “Swap the boilerplate, complex debugging and brittle code for powerful, reusable components written with plain Java and HTML”.

It’s a wide-spread Java web application framework mostly adopted by Struts old-timers and those who refuse to switch to JSF and Seam as far as what I observe.

Wicket strives for a clean separation between the roles of HTML page designer and Java developer by supporting plain HTML-based templates (which live next to Java code) that can be built using any WYSIWYG HTML design tools. The templates can then be made dynamic with little modification.

Like other frameworks, Wicket is built on top of Sun Microsystems’ servlet API. However, unlike frameworks based on the Model-View-Controller (MVC) model (such as Struts), Wicket takes away from you the task of handling request/response objects, which is inherent with technologies such as servlets. By taking away this task, Wicket allows you to concentrate on the application’s business logic.

As a Wicket developer, you should think in terms of building reusable components that are stateful, instead of building controllers that handle request/response objects and worrying about multithreading issues. Instead of creating a controller or action class, you create a page, place components on it, and define how each component reacts to user input.

Wicket is great for Java developers, not especially for web developers. It requires a good grasp of objected-oriented programming as everything’s done almost in pure Java. It It has tight binding between pages and views and there’s an active community support including support from its creators.

Spring MVC and Webflow

Spring is the most popular application development framework for enterprise Java, that provides an incredibly powerful and flexible collection of technologies to improve your enterprise Java application development that is used by millions of developers.

Some of its advantages are:

• Lifecyle for overriding binding, validation, etc.
• Integrates with many view options seamlessly: JSP/JSTL, Tiles, Velocity, FreeMarker, Excel, PDF
• Inversion of Control makes it easy to test
• Advanced security
• Advanced support for Aspect-Oriented Programming (AOP)

Many mission-critical Java enterprise applications are based on the Spring framework. Although you can integrate JSF (even Seam) with Spring, it lacks built-in JSF and AJAX support unlike JBoss Seam.

Java Server Faces

Although JSF is not fairly a new framework, it’s become a Java EE standard (as of Java EE 5), developed through Java Community Process (JCP), that makes it easy to build user interfaces for java web applications by assembling reusable components in a page. Fast and easy to develop with initially, JSF comes with a plethora of ready to use components which you can quickly and easily reuse or add to many times in a page and capture events generated by actions on these components.

JSF is based on the well-established Model-View-Controller (MVC) design paradigm. Applications developed using JSF frameworks are forcibly well designed and usually easier to maintain than others.

Unlike action-based frameworks such as Struts and Spring, JSF applications are event-based. You typically embed components in a web page using custom tags defined by JSF technology and use the framework to handle navigation from one page to another.

JSF offers a flexible and extensible architecture that makes easy creating reusable, complex server side UI components without limiting developers to a particular mark-up language, protocol, or client device by combining the UI component functionality with custom renderers.

Some other advantages of using Java Server Faces are:

• JSF provides standard, reusable components for creating user interfaces for web applications.
• JSF provides many tag libraries for accessing and manipulating the components.
• It automatically saves the form data and repopulates the form when it is displayed at client side.
• JSF encapsulates the event handling and component rendering logic from programmers, programmers just use the custom components.
• There are many GUIs available these days to simplify the development of web based application based on JSF framework.

See my other articles on JSF for more detailed information, tutorials and resources.

JBoss Seam

JBoss Seam is a framework that brings together existing Java Platform, Enterprise Edition (Java EE) standards to enable them to work as an integrated solution. At its core, the Seam framework ties the Enterprise JavaBeans 3 (EJB3) and JavaServer Faces (JSF) specifications. However, Seam does not just stop there—it will also join together other component models that you may be used to, such as Hibernate (for ORM), jBPM (for business process management and workflows), Drools (business rule management system), and more.

To be useful, your application has to be a multitiered application that uses specific components for the presentation, business, and persistence tiers. Before, you may have accomplished this with a combination of Struts (presentation), Spring (business), and Hibernate (persistence) frameworks. Now, following the Java EE specification, you will be using JSF (presentation), EJB3 session-beans (business), and EJB3 entity beans (persistence) with Seam. As before, each of these components requires lots of glue to link them together to talk to each other where Seam solves all of these.

EJB 2.1 had some negative connotations, especially regarding the way it relates to stateful session beans and entity beans. Thanks to the new EJB3 specification, EJBs have become lightweight plain old Java objects (POJOs) that do not require as much of the “plumbing” as before.

Seam has been designed from the ground up to eliminate complexity at both architecture and API levels. It enables developers to assemble complex web applications using simple annotated Java classes, a rich set of UI components, and very little XML. Seam’s unique support for conversations and declarative state management can introduce a more sophisticated user experience while at the same time eliminating common bugs found in traditional web applications.

Seam 2 introduces the concept of bijection, taken from Spring’s dependency injection feature where objects can be in-jected or out-jected to/from assigned variables using the @In and @Out annotations.

The framework also expands the concept of contexts. Each Seam component exists within a context. The default Seam context, a conversation, can span multiple pages and usually spans the whole business flow, from start to finish. The session context captures all actions of a user until he/she logs out or closes the browser – even across multiple uses of the browser back-button.

One can automatically generate a CRUD (create-read-update-delete) web-application from an existing database using the command-line tool seam-gen supplied with the framework.

Where there are holes in the specifications (for example, limitations in the JSF lifecycle for GET requests), Seam fixes them. And the authors of Seam are working with the JCP expert groups to make sure those fixes make their way back into the next revision of the standards.

Seam facilitates development through the use of JBoss Tools, a set of plug-ins targeted at the open-source Eclipse integrated development environment.
Seam integrates out of the box with the RichFaces and ICEfaces Ajax libraries, as well as with many other Ajax libraries – without the need to write JavaScript code.

Seam also includes built-in libraries for creation of PDF documents, Microsoft Excel worksheets, graphs / charts (independent from Excel) and emailing them.

The possibility of integrating Seam with Spring might make it the ideal choice for developers who are also keen for making the switch to JSF.

Conclusion

Although Tapestry and Stripes might deserve a mention, I purposefully omitted them in this article as I don’t believe they’re in the top 5 java web frameworks. Tapestry with its HTML-based templates is almost as old as Struts, very productive once you learn, but with its scarcity of learning resources and steep learning curve, every adopter chooses – sooner or later – to switch to something else. As for Stripes which could deserve mentioning for its convention over configuration (no XML) and good documentation, has some major drawbacks such as the size of its community being too small, and it’s not actively developed as other projects.

JBoss Dev Studio is a branded version of a Eclipse packed with the right version of JBoss Tools. The dev studio is usually bundled with a developer subscription from RedHat for $99. (I’ve been told, however, by Max Rydahl Andersen a JBoss employee who is also one of the developers of JBoss tools and the developer studio that the JBoss Developer Studio IDE itself is actually free without the JBoss commercial runtimes – i.e. JBoss EAP).

If you stick with Eclipse IDE with the JBoss tools plugin, I came up with the following matrix of the set of tools showing the coupling of compatible versions.

JBoss Tools Compatibility Matrix

Example: For an employee entity with properties such as an id and the employee name also a monthlySalary property, you might also want to have a yearlySalary which is not necessarily stored in the database.

package net.ozar.exp.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="EMPLOYEE")
public class Employee implements java.io.Serializable {

	private static final long serialVersionUID = -7311873726885796936L;

	@Id
	@Column(name="ID")
	private Integer id;

	@Column(name="FIRST_NAME", length=31)
	private String firstName;

	@Column(name="LAST_NAME", length=31)
	private String lastName;

	@Column(name="MONTHLY_SALARY")
	private float monthlySalary;

	public Employee() {
	}

	// getters and setters
     // ...

	public float getMonthlySalary() {
		return monthlySalary;
	}

	public void setMonthlySalary(float monthlySalary) {
		this.monthlySalary = monthlySalary;
	}

     /* This artificial property - as I call it - is a kind of a calculated property, but not with Hibernate derived property support - not just yet */
	public float getYearlySalary() {
		return this.monthlySalary * 12;
	}

}

The above example gives us a simple calculation in memory for just screen output without Hibernate’s derived property or the @Formula support.  Now take a moment to reflect that we need all the employees whose yearly salary average is above $5000. Then what? In this case, you might wanna make use of Hibernate’s derived property feature.

To define a derived property in Hibernate, we use the @Formula annotation or the <formula> tag in the hbm.xml definition file.

package net.ozar.exp.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.Formula;

@Entity
@Table(name="EMPLOYEE")
public class Employee implements java.io.Serializable {

	private static final long serialVersionUID = -7311873726885796936L;

	@Id
	@Column(name="ID")
	private Integer id;

	@Column(name="FIRST_NAME", length=31)
	private String firstName;

	@Column(name="LAST_NAME", length=31)
	private String lastName;

	@Column(name="MONTHLY_SALARY")
	private float monthlySalary;

	@Formula("MONTHLY_SALARY*12")
        private float yearlySalary;

	public Employee() {
	}

	public Integer getId() {
		return id;
	}

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

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public float getMonthlySalary() {
		return monthlySalary;
	}

	public void setMonthlySalary(float monthlySalary) {
		this.monthlySalary = monthlySalary;
	}

	public float getYearlySalary() {
		return yearlySalary;
	}

}

Please note that in the above example the value of the @Formula annotation is actually an SQL expression which refers to the “MONTHLY_SALARY” column in the database and not the Hibernate property monthlySalary.

Please note that the @Formula annotation is specific to Hibernate and is not present in other JPA implementations – at least not just yet.

A more complex example:

@Formula("(select min(l.creation_date) from Logs l where l.customer_id = id)")
private Date firstLoginDate;

In this example the query is a native SQL query and id (as the parameter) is the id of the current entity.

@OneToMany(mappedBy="user",cascade=CascadeType.ALL, fetch=FetchType.LAZY)
@BatchSize(size=100)
private Set<Log> logs = new HashSet<Log>();

@Formula("(select min(l.creation_date) from logs l where l.user_id = id)")
private Date firstLoginDate;

@Formula("(select max(l.creation_date) from logs l where l.user_id = id)")
private Date lastLoginDate;

@Formula("(select coalesce(extract ('day' from age(max(l.creation_date))), 9999) from logs l where l.user_id = id)")
private int daysSinceLastLogin;

// ...

public Date getFirstLoginDate() {
  return firstLoginDate;
}

public Date getLastLoginDate() {
  return lastLoginDate;
}

public int getDaysSinceLastLogin() {
   return daysSinceLastLagin;
}

And the log entity would be something like:

@Entity
@Table(name = "LOGS")
public class Log {
 //  ...
  @NotNull
  @Column(name="CREATION_DATE")
  private Date creationDate;

  @ManyToOne
  @JoinColumn(name="USER_ID")
  private User user;

  @PrePersist
  public void prePersist()  {
    creationDate = new Date();
  }
}

In my case I already have Tomcat and Glassfish which are set to use the 8080 port as well, so I will show you how to modify the port number of Oracle 10g XE as I go along.

About APEX or what I would normally call Oracle 10g XE

Oracle Database 10g Express Edition (Oracle Database XE also goes by an abbreviated code name APEX) is an entry-level, small-footprint database based on the Oracle Database 10g Release 2 code base that’s free to develop, deploy, and distribute; fast to download; and simple to administer. Oracle Database XE is a great starter database for:

• Developers working on PHP, Java, .NET, XML, and Open Source applications
• DBAs who need a free, starter database for training and deployment
• Independent Software Vendors (ISVs) and hardware vendors who want a starter database to distribute free of charge
• Educational institutions and students who need a free database for their curriculum.

With Oracle Database XE, you can now develop and deploy applications with a powerful, proven, industry-leading infrastructure, and then upgrade when necessary without costly and complex migrations.

Installing Oracle Database 10g Express Edition

Just download the double-clickable installer (named OracleXEUniv.exe ) from Oracle’s web site whose URL at the time of this writing was: http://www.oracle.com/technetwork/database/express-edition/downloads/index.html

Alternatively from the following (fast & direct download) link:

Oracle Database 10g Express Edition for Microsoft Windows (17) for Windows

Double-click OracleXEUniv.exe and you should see a typical InstallShield window:

Changing the default port number of APEX (the port # 8080 of the http listener)

Now I don’t want APEX to block my Java EE application servers who need (and probably deserve) the 8080 port more. I’m quite OK with the light database server itself which is listening the port 1521.

Go to Start > All Programs > Oracle Database 10g Express Edition > Run SQL Command Line

In the console window type the commands as shown below and in the screenshot:

SQL> -- get current status
SQL> select dbms_xdb.gethttpport as "HTTP-Port"
, dbms_xdb.getftpport as "FTP-Port" from dual;

HTTP-Port FTP-Port
---------- ----------
8080 0

You can change the http port and the ftp port to whatever you like (keep in mind that you need special privileges for ports < 1024 on Unix/Linux systems).

SQL> -- set http port and ftp port
SQL> begin
2 dbms_xdb.sethttpport('8888');
3 dbms_xdb.setftpport('2100');
4 end;
5 /

PL/SQL procedure successfully completed.

SQL> select dbms_xdb.gethttpport as “HTTP-Port”
, dbms_xdb.getftpport as “FTP-Port” from dual;

HTTP-Port FTP-Port
---------- ----------
8888 2100

In my case I’m changing the HTTP port to 8888.

There I’m also changing the FTP port to 2100 which was 0 (disabled) by default.

If you only want to use the database without allowing access via HTTP or FTP then you can disable both:

SQL> -- disable http and ftp access
SQL> begin
 2    dbms_xdb.sethttpport('0');
 3    dbms_xdb.setftpport('0');
 4  end;
 5  /

PL/SQL procedure successfully completed.

SQL> -- get current status
SQL> select dbms_xdb.gethttpport as "HTTP-Port"
            , dbms_xdb.getftpport as "FTP-Port" from dual;

HTTP-Port   FTP-Port
---------- ----------
        0          0