pom.xml

Let’s start with the pom.xml...

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sample</groupId>
    <artifactId>jsf</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>jsf-sample</name>

	<repositories>
		<repository>
			<id>jboss</id>
			<name>JBoss Repository for Maven</name>
			<url>https://repository.jboss.org/nexus/content/groups/public/</url>
		</repository>
		<repository>
			<id>central</id>
			<name>Maven Repository Switchboard</name>
			<url>http://repo1.maven.org/maven2</url>
		</repository>
		<repository>
			<id>maven2-repository.java.net</id>
			<name>Java.net Repository for Maven</name>
			<url>http://download.java.net/maven/2/</url>
		</repository>
	</repositories>

    <dependencies>
    	<dependency>
			<groupId>javax</groupId>
			<artifactId>javaee-web-api</artifactId>
			<version>6.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-api</artifactId>
			<version>${jsf.version}</version>
		</dependency>
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-impl</artifactId>
			<version>${jsf.version}</version>
		</dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
              	<groupId>org.apache.maven.plugins</groupId>
             	<artifactId>maven-war-plugin</artifactId>
              	<version>2.1.1</version>
              	<configuration>
                  	<failOnMissingWebXml>false</failOnMissingWebXml>
                  	<contextRoot>/jsf</contextRoot>
              	</configuration>
          	</plugin>
            <plugin>
          	 	<groupId>org.apache.maven.plugins</groupId>
              	<artifactId>maven-eclipse-plugin</artifactId>
              	<version>2.8</version>
              	<configuration>
                  	<wtpmanifest>true</wtpmanifest>
		          	<wtpversion>2.0</wtpversion>
		          	<manifest>${basedir}/src/main/resources/META-INF/MANIFEST.MF</manifest>
              	</configuration>
	        </plugin>
        </plugins>
    </build>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jsf.version>2.1.2</jsf.version>
    </properties>
</project>

If you're using a web server such as Tomcat 6.0 or above you will need to have jsf-api and jsf-impl. I've decided to use the jars in the public JBoss repository because the ones in the central Maven repo will produce an error during server start-up:
java.lang.ClassFormatError: Absent Code attribute in method that is not native or abstract in class file javax/faces/FacesException

You can use any Java EE 6 server instead but that is not part of this post because there maybe additional configurations such as ear pom configuration which I haven't tried yet.

web.xml

Next, we need to configure the web.xml file to direct *.xhtml requests to the FacesServlet.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  version="2.5">
  <!-- Minimum requirement for JSF 2 is a servlet 2.5 declaration -->
  <!-- Map FacesServlet -->
  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>
  <!-- For better error messages during development -->
  <context-param>
    <param-name>javax.faces.PROJECT_STAGE</param-name>
    <param-value>Development</param-value>
  </context-param>

  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.xhtml</welcome-file>
  </welcome-file-list>
</web-app>

Mapping *.xhtml to FacesServlet will allow us to use JSF tags in our xhtml files.

faces-config.xml

At the minimum we need to have an empty faces-config.xml in WEB-INF.

<?xml version="1.0"?>
<faces-config 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/web-facesconfig_2_0.xsd"
   version="2.0">
  <!-- Empty but needed -->
</faces-config>

Test

To test the configuration I created a basic index.xhtml file which uses some JSF tags (with the h prefix) in src/main/webapp.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"
	  xmlns:h="http://java.sun.com/jsf/html">
<h:head>
	<title>JSF | Index</title>
</h:head>
<h:body>
	<h1>Hello World!</h1>
</h:body>
</html>

Just run the mvn clean eclipse:clean eclipse:eclipse install, import in Eclipse, create a server, add the project, run the server and go to index.xhtml.

I hope this helped you. Cheers!

So there I was reconstructing everything that I mentioned starting with Java Persistence with Hibernate Part 2 – Getting Started until I was done with my test class to see if everything works and that’s what I was expecting but I was wrong. Instead I got this error:

Exception in thread "main" java.lang.AbstractMethodError: com.microsoft.jdbc.base.BaseDatabaseMetaData.supportsGetGeneratedKeys()Z

I immediately blamed the JDBC driver I have for SQL Server 2000 and then I also remembered that there’s a new JDBC version already for SQL Server. Sure enough when I changed to sqljdbc4.jar(I’m using JDK 6.0, use sqljdbc.jar for JDK 5.0) and changed the driver class to com.microsoft.sqlserver.jdbc.SQLServerDriver everything went smoothly and the application executed correctly.

Hope this helps someone cause it’s really hard to find the solution for the error that I encountered if you’re not familiar with the history of JDBC with SQL Server. For more information on using the new driver please visit Using the JDBC Driver.

Create the Mapping File

The basic structure of a mapping file is like this:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.phoenixone.hibernate.model">
	<class name="com.tutorial.enrollment.model.Student" table="student">
		<id name="id" column="student_id">
			<generator class="org.hibernate.id.enhanced.SequenceStyleGenerator" />
		</id>
		<property name="firstName" column="first_name" />
		<property name="lastName" column="last_name" />
	</class>
</hibernate-mapping>

The DOCTYPE is required in the mapping file. You can use it for auto-completion of the XML elements of the mapping file. The DTD is included in hibernate3.jar.

<hibernate-mapping> is the root element of the XML mapping file. You need to provide the package where the class belongs.

<class> tags is used for mapping the persistent class and other classes to which your persistent class is dependent.
e.g. If we have an Address property

private Address address;

inside the Student class then we need to create another <class> tag for Address but that’s another topic.

The <id> tag is used to mapped the primary key in the table to the property in the class.

The <generator> tag provides auto-generation of the id. You can choose from a list of generator classes or short names which you can find here. You can also plugin your own generator strategy.

The <property> tag is used to map the other properties of the class. Just make sure that the value of name attribute has the same casing as you used in the class file.

After creating the mapping file save it as Student.hbm.xml and put it on the same directory as Student.java. All mapping files should have the same name as the class it maps and ends with .hbm.xml.

Create the Hibernate Configuration File

Ok, at this point we already have our database(enrollment) and persistent class(Student.java) which was done in Part 3 and earlier in this post we have the mapping file for Student.java(Student.hbm.xml). There’s only one thing left to configure so we can store and load objects with Hibernate and that is tell Hibernate our database configuration, how to locate the mapping files(*.hbm.xml), etc.

Here’s how our configuration file may look like…

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost/enrollment</property>
		<property name="connection.username">root</property>
		<property name="connection.password">root</property>

		<property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
		<property name="show_sql">true</property>
		<property name="hbm2ddl.auto">update</property>
		<property name="current_session_context_class">thread</property>

		<mapping resource="com/tutorial/enrollment/model/Student.hbm.xml" />
	</session-factory>
</hibernate-configuration>

The DOCTYPE here is different from the mapping file’s DOCTYPE.

<hibernate-configuration> is the root element of the file.

<session-factory> allows you to configure Hibernate’s SessionFactory which is the one responsible for a specific database. The SessionFactory is also the one responsible for creating Session objects that will allow us to store and load objects as we will see in Part 5. If you have several databases then you should have several <session-factory> elements too.

The first four properties take care of our database connection. You can search for your particular database’s connection configuration by searching on how to use the JDBC driver for it. As for MySQL it’s here.

The dialect property determines what particular SQL variant Hibernate will generate depending on your database. For other dialects go here.

The show_sql property tells Hibernate to print the generated sql to the console.

If by chance you accidentally dropped the database for our persistent class you can add hbm2ddl.auto and it will automatically create the database schema for you, handy isn’t it?

The current_session_context_class property enables the automatic session context management.

You can visit this page if you want to learn about other configurations you can set.

Part 3 – Create the Database and Persistent Class o0o Part 5 – Creating a SessionFactory Helper and Storing/Loading Objects

In using Hibernate you may either create the database first and create the class we need to persist or vice-versa.

create database enrollment;
create table student(
 student_id int,
 first_name varchar(40),
 last_name varchar(40),
 primary key(student_id)
);

With the SQL code above, we’ve created a database named “enrollment” and a table named “student” with three columns(student_id, first_name and last_name) with student_id as our primary key(unique identifier).

Create the Eclipse Project

Again, you don’t need to have an eclipse project just adjust what is done here to your development environment.

1. Create a new Java project in this case I named the project “com.tutorial.enrollment”. Image
2. Add the libraries mentioned in Part 2 to the build path Image 1, Image 2

Create the Student Class

package com.tutorial.enrollment.model;

import java.io.Serializable;

public class Student implements Serializable {
	private static final long serialVersionUID = 6981987850136048701L;

	private Long id;
	private String firstName;
	private String lastName;

	public Long getId() {
		return id;
	}
	public void setId(Long 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;
	}
}

The Student class follows the JavaBeans specification with the use of private variables and public getters and setters method. Also, we tried to have the same properties in our class and columns in the student table.

Save Student.java in com.tutorial.enrollment/src/com/tutorial/enrollment/model.

Part 2 – Create the Database and Persistent Class o0o Part 4 – Create the Mapping File and Configuration File

Hibernate has several modules which answer specific problems. The two most important modules to learn are Hibernate Core and Hibernate Annotations.

Hibernate Core

Hibernate Core for Java generates SQL for you, relieves you from manual JDBC result set handling and object conversion, and keeps your application portable to all SQL databases. Hibernate offers sophisticated query options, you can write plain SQL, object-oriented HQL (Hibernate Query Language), or create programatic Criteria and Example queries. – from hibernate.org

Hibernate Annotations

Hibernate, like all other object/relational mapping tools, requires metadata that governs the transformation of data from one representation to the other (and vice versa). As an option, you can now use JDK 5.0 annotations for object/relational mapping with Hibernate 3.2. You can use annotations in addition to or as a replacement of XML mapping metadata. – from hibernate.org

To be able to use the power of Hibernate we only need Hibernate Core. But since Hibernate Core requires a lot of XML configurations, Hibernate Annotations is used to make development simpler and faster. To better understand this let’s create a simple Hibernate application.

Getting Started

First we need to prepare all the libraries for creating a Hibernate application. This could be easily done if you know build tools like Maven or Ant but I decided not to use them because it’s not a requirement and maybe some of you are not familiar with those tools.

1. Download Hibernate Core
   Extract the zip file and you will get hibernate3.jar. Image
2. Inside the lib folder there is a required folder and inside that you will find antlr-2.7.6.jar, commons-collections-3.1.jar, dom4j-1.6.1.jar, javassist-3.9.0.GA.jar and jta-1.1.jar. We will use a different version of sl4j. Image
3. Download sl4j-1.5.6.zip and extract. We will need slf4j-api-1.5.6 and slf4j-simple-1.5.6
4. Lastly we will need the JDBC driver for the database that we would be using, in this case MySQL 5.0. You may use other databases if you want just be sure know how to use them and configure them for database access from Java. Download the MySQL Connector/J 5.0. We need mysql-connector-java-5.0.8-bin.

Java Persistence with Hibernate Part 1 o0o Java Persistence with Hibernate Part 3 – Create the Database and Persistent Class

Persistence in Computer Science basically means the existence of data even after an application or program has ended. This can be done through the use of a relational database such as MySQL or SQL Server with some stored procedures.

However, in creating applications we do not use relational databases by themselves (Imagine all of us creating queries and stored procedures just to save or retrieve data). We just integrate a database as a means to store data to our main application. Your application may be developed using Java or any other object-oriented language but this is where our problem starts.

Our application is an Object-Oriented language which is built around the idea of objects having states and behaviors while the database we are using is Relational which is all about tables. The problem is in translating those objects into a form that can be stored in a relational database.(Paradigm mismatch: Object Relational Mapping)

Another concern is that Java has a different syntax than SQL(the base language being used by relational databases). Well, Java has JDBC but is it enough? Do we just hard-code all of our SQL commands?

Lastly, different relational database management systems(RDBMS) uses different extensions of SQL, meaning they may have different syntax for several SQL commands. This poses a problem when you are trying to migrate from one RDBMS to another. Let’s say you used MySQL as your RDBMS for development and you had all your SQL commands hand-coded within your application. However, before deploying the application your client tells you that they would be using Oracle instead. You think that there’s no problem, since you used JDBC you just need to change some configurations regarding the driver used and migrate the MySQL tables to Oracle. But lo and behold when you deployed the application some part of it was not working. Most probably this is because some of your hand-coded MySQL commands have different syntax in Oracle.

Hibernate is an ambitious project that aims to be a complete solution to the problem of managing persistent data in Java. It mediates the application’s interaction with a relational database, leaving the developer free to concentrate on the business problem at hand. – from the book “Java Persistence With Hibernate”

There are other issues regarding Object Relational Mapping but I guess with the above explanation you already have a basic idea of the importance of Object/Relational persistence.

Java Persistence With Hibernate Part 2 – Getting Started