下次自动登录
现在的位置:
& 综合 & 正文
Struts Hibernate Integration Tutorial
First steps using Struts and Hibernate
In this tutorial we will show how the Web Framework Struts and the Database Persistence Solution Hibernate can be used together. Though we explain some basic, you should try the basic tutorials for each technology first when you are a beginner.
In-depth, detailed and easy-to-follow Tutorials for JSP, JavaServer Faces, Struts, Spring, Hibernate and EJB
Seminars and Education at reasonable prices on a wide range of Java Technologies, Design Patterns, and Enterprise Best Practices Improve your development quality
An hour of support can save you a lot of time - Code and Design Reviews to insure that the best practices are being followed! Reduce solving and testing time
Consulting on Java technologies Get to know best suitable libraries and technologies
Author: Sebastian Hennebrueder
updated January, 2nd 2006
updated, July, 27th 2005
updated January, 16th 2005
First Edition December, 22th 2004
Used software and frameworks
Hibernate version 3.x (I used 3.1)
Struts 1.2
Java 5 or 1.5
Eclipse 3.x
MyEclipse 4 recommended but not obligatory
(A cheap and quite powerful Extension to Eclipse to develop Web Applications and EJB (J2EE) Applications. I think that there is a test version availalable at MyEclipse.)
I used PostgreSQL 8.0 and MySQL but you may use any database supported by Hibernate.
Application Server
Jboss 4.0.3 (our environment)
Tomcat standalone
probably any other application server like Jonas, WebSphere, Oracle, Websphere etc.
Source code:
PDF version of the tutorial:
Old version using Hibernate 2:
1 First steps using Struts and Hibernate 1
2 General 2
3 Requirements 2
4 Creating the application 3
4.1 Create the project and add the Hibernate capabilities (for MyEclipse user) 3
4.2 Preparing the project for anybody 6
4.3 Reduce Hibernate Libraries 7
5 Create the Database 7
6 Generate the Hibernate Mapping Files and Classes 8
6.1 Import using MyEclipse 8
6.2 Repair the mapping of customer 10
6.3 Repair the mapping of book 12
6.3.1 Correct the Boolean mapping 12
6.4 Improvements to the session factory 13
6.5 Testing the Hibernate part 13
6.6 PostgreSQL Problem 15
7 Generating the Business Logic 16
7.1 Create a business logic class 16
8 Creating the dialogs with Struts 25
8.1 Create a default, welcome page 26
8.2 Global Action Forwards and Action Mappings 27
8.3 Book list 30
8.3.1 Action mapping und action class of the book list 32
8.3.2 Edit the source code of the action form class 33
8.3.3 Edit the source code of the action class 33
8.3.4 Display the books list in the jsp file. 34
9 Test the application 37
9.1 Add, edit, borrow and delete books 37
9.1.1 Action Mapping 37
9.1.2 Edit the source code of the jsp files 40
9.1.3 Form bean 42
9.1.4 Methods of the dispatch action class 46
9.2 Use case Customer list 49
9.2.1 Edit the source code of the action form class 52
9.2.2 Displaying the custom list 53
9.3 Use case add, edit, delete customers 54
9.3.2 Customer form bean 57
9.3.3 Edit the source code of the action class 59
9.3.4 Edit the source code of the jsp file 60
10 Test the applications 62
11 Copyright and disclaimer 62
Requirements
We will use the IDE Eclipse with the plugin MyEclipse in this tutorial. But you are not forced to use it, as we will explain what the MyEclipse wizards created actually. Have a look at the colored notice we put everywhere.
You may try MyEclipse, as it is not expensive. There is also a trial version available:
If you want to use free tools for web application development, have a look at the tutorial
Creating the application
We will start with creating and testing of the persistence layer. The second step is to add the business logic and at last will integrate the Struts part.
Create the project and add the Hibernate capabilities (for MyEclipse user)
Create a new web project.
So let's start.
Press Ctrl+n (or Strg+n) to open the ,,New ...“ dialog.
Create a Web Project and select the project name shown below.
Add the Hibernate capabilities by right clicking on the project in the Package View.
Check the two checkboxes to add the libraries to the project and select to create a new hibernate mapping file. The hibernate file holds the configuration of your hibernate settings and mappings.
The next step is to select a Connection Profile for the Database.
Select the button ,,New profile“ to create a new profile.
When the Postgre Driver is missing. Click on ,,New Driver“ to create a new driver. You will need the jar including your Database Driver.
We call our profile library-web. Specify the user name and the password and create it.
Back to the first dialog, make sure that you have the checkbox ,,Copy JDBC Driver ...“ selected. We are going to use PostgreSQL. It should not be difficult to make the same thing for MySQL or another database. Make sure that you have the Jar File of the Database Driver somewhere on your disc. In the source code you will find also a configuration for MySQL.
In the next step you must invent a nice name for your SessionFactory.
Preparing the project for anybody
Download Hibernate from
As minimum requirement add the following libraries to get Hibernate 3 to work. When you want to know more about the libraries and if they are required, have a look at the file README.txt included in the lib directory of the hibernate.zip.
The configuration file is a simple XML file named hibernate.cfg.xml
In our case we will put it directly in the src directory. Create an XML file there and add the following content. In the source code you can find the configuration for a MySQL database, I use PostgreSQL here.
&?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.url"&jdbc:postgresql://localhost/libraryweb&/property& &property name="connection.username"&postgres&/property& &property name="connection.password"&p&/property& &property name="connection.driver_class"&org.postgresql.Driver&/property& &property name="dialect"&org.hibernate.dialect.PostgreSQLDialect&/property&&/session-factory&&/hibernate-configuration&
Then create the HibernateSessionFactory class in the package de.laliluna.library and add the content as included in the sources with this tutorial.
That's all for the non MyEclipse users.
Reduce Hibernate Libraries
By default MyEclipse includes a heavy load of libraries. Some of them will only be needed for local development others only for special cache implementations. When you want to optimize your deployment after you learned the basics of Hibernate download Hibernate from the website
In the lib directory you will find a README.txt explaining what libraries are optional.
Now we are prepared to start the development. Fasten the seatbelts, it is getting really fast now.
Create the Database
Create the database and the following tables. Do not forget the foreign key!
Postgre SQL ScriptCREATE TABLE customer(id serial NOT NULL,firstname text,lastname text,age int4,CONSTRAINT customer_pk PRIMARY KEY (id)) ;CREATE TABLE book(id serial NOT NULL,title text,author text,customer_fk int4,borrowallowed bool NOT NULL DEFAULT true,CONSTRAINT book_pk PRIMARY KEY (id)) ;ALTER TABLE bookADD CONSTRAINT book_customer FOREIGN KEY (customer_fk) REFERENCES customer (id) ON UPDATE RESTRICT ON DELETE RESTRICT;MySQL ScriptCREATE TABLE customer(id int( 11
AUTO_INCREMENT ,firstname varchar( 255
) ,lastname
varchar( 255
) ,age int( 11
),CONSTRAINT customer_pk PRIMARY KEY (id)) TYPE=INNODB;CREATE
TABLE book( id
AUTO_INCREMENT ,title varchar( 255
) ,author varchar( 255
) ,customer_fk int( 11
),borrowallowed TINYINT NOT NULL, CONSTRAINT book_pk PRIMARY
KEY ( id ),INDEX (customer_fk)
) TYPE=INNODB;ALTER
TABLE book ADD
CONSTRAINT book_customer FOREIGN
KEY ( customer_fk ) REFERENCES customer( id )
RESTRICT ;
Generate the Hibernate Mapping Files and Classes
Import using MyEclipse
Open the View DB Browser (MyEclipse). If you cannot find it open the ,,Show View“ Dialog and select in the MyEclipse Enterprise Workbench the DB Browser.
Open the connection profile you specified before.
Select the two tables we have just created. Right click and choose ,,Create Hibernate Mapping“.
Select your LibraryWeb project as target. When your are using PostgreSQL select ,,sequence“ as ID Generator. When you are using MySQL select ,,increment“.
Click OK and your are really good! You have just created your persistence layer
Now we will have a closer look at our package explorer to see what happened.
First open the hibernate.cfg.xml.
There are two new entries, specifying where the two mapping files are located. It is a good idea to keep the mapping files separated from the hibernate.cfg.xml. (What MyEclipse actually does for you.)
&!-- mapping files --&&mapping resource="de/laliluna/library/Book.hbm.xml"/&&mapping resource="de/laliluna/library/Customer.hbm.xml"/&
Have a look at the mapping file Book.hbm.xml. In this file the mapping from the class and its attributes to the table fields is specified. Your foreign key may or may not have been generated. This function is relative new and not working on all platforms.
&?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="de.laliluna.library"&&class name="Book" table="book"&&id name="id" column="id" type="java.lang.Integer"&&generator class="sequence"/&&/id&&property name="title" column="title" type="java.lang.String" /&&property name="author" column="author" type="java.lang.String" /&&property name="customerFk" column="customer_fk" type="java.lang.Integer" /&&property name="borrowallowed" column="borrowallowed" type="java.lang.Byte" /&&/class&&/hibernate-mapping&
When you are using MySQL the mapping is slightly different.
&class name="Book" table="book"&&id name="id" column="id" type="java.lang.Integer"&&generator class="increment"/&&/id&...
MyEclipse created two files per class. The first one is an abstract class. (AbstractBook) It will be overwritten each time you repeat the import procedure. In the second class (Book) you may adapt any changes you want to make. It is only generated once.
Non MyEclipse users please take the files Book.hbm.xml, AbstractBook, Book, customer.hbm.xml, AbstractCustomer and Customer from the sources provided with this tutorial.
Hibernate does also provide tools to create mapping files. Have a look at the hibernate website.
Improve the mapping of customer
We are going to make some changes.
Hibernate do not generate a relation back from the customer to the book. We will add this by hand.
In the file Customer.class add the following.
public Set getBooks() {
} public void setBooks(Set books) {
this.books = }
In the file Customer.hbm.xml we have to add the mapping from the books variable. Add the set entry to the file.
&?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="de.laliluna.library"& &class name="Customer" table="customer"&
&id name="id" column="id" type="java.lang.Integer"&
&generator class="sequence"&&param name="sequence"&customer_id_seq&/param&&/generator&
&set name="books" inverse="false" &
&column name="customer_fk"&&/column&
&one-to-many class="Book" /&
&property name="firstname" column="firstname" type="java.lang.String" /&
&property name="lastname" column="lastname" type="java.lang.String" /&
&property name="age" column="age" type="java.lang.Integer" /& &/class&&/hibernate-mapping&
&generator class="sequence"&
This tag specifies how the id is generated. Using PostgreSQL the sequence customer_id_seq is called. The generator depends on your database. For MySQL you will find the example in the source.
&set name="books" inverse="false" &
&column name="customer_fk"&&/column&
&one-to-many class="Book" /&
We have a set, which is accessed by the name books, i.e. GetBooks and setBooks in the Customer class. The foreign key column is customer_fk and related to the mapping of the class Book.
inverse="false"
This is a little more complex to explain. You can write a relation from two sides.
customer.getBooks().add(book);
book.setCustomer(customer);
Very often you only need to set the relation from one side. So you can inform Hibernate that it needs not to monitor the offer side of the relation. This could be a performance issue. In this case we would set inverse=”true” and could only use the second approach to write a relation.
In the class customer I overwrote the toString method to have a proper output during debugging. In addition I changed the constructor method to have the property books initialized with an empty hashset. The advantage is that you do not have to test in the business logic if your hashSet is null or empty.
package de.laliluna.import java.io.Simport java.util.HashSimport java.util.Limport java.util.S/** * A class that represents a row in the 'customer' table. This class may be * customized as it is never re-generated after being created. */public class Customer extends AbstractCustomer implements Serializable { private S /**
* Simple constructor of Customer instances.
*/ public Customer() {
books = new HashSet(); } /**
* Constructor of Customer instances given a simple primary key.
* @param id
*/ public Customer(java.lang.Integer id) {
super(id);
books = new HashSet(); } public Set getBooks() {
} public void setBooks(Set books) {
this.books = } /* Add customized code below */ @Override public String toString() {
return "Customer
" + getId() + " firstname: " + getFirstname()
+ " lastname: " + getLastname(); }}
Improve the mapping of book
See below the content of the Book.hbm.xml file. When you imported this with MyEclipse please correct the borrowAllowed property. The postgre bool column is recognized as Byte and as Short when you are using MySql. Do not ask me why.
&?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="de.laliluna.library"&&class name="Book" table="book"&&id name="id" column="id" type="java.lang.Integer"&&generator class="sequence"&&param name="sequence"&book_id_seq&/param&&/generator&&/id&&property name="title" column="title" type="java.lang.String" /&&property name="author" column="author" type="java.lang.String" /&&property name="borrowallowed" column="borrowallowed" type="java.lang.Boolean"/&&many-to-one name="customer" column="customer_fk" not-null="false" &
&/many-to-one&&/class&&/hibernate-mapping&
Manually changing the file above is not very good but there is no other way here.
The disadvantage is that this will be overwritten each time you regenerate the mapping files. In our case it is not so important but in a larger project this will make it impossible to use the autogeneration from MyEclipse except at the beginning. The hibernate import function is quite new for MyEclipse, so you can be sure that there will be larger improvements in the next versions.
I had a problem copy and pasting source code from the tutorial to Eclipse files due to use of tabs in this document. If you encounter funny problems when pasting content to Eclipse, please consider to type the code manually.
Correct the Boolean mapping
Change the variable and the getter and setter in the file AbstractBook.java to Boolean type.
/** The value of the simple borrowallowed property. */private java.lang.B/*** Return the value of the borrowallowed column.* @return java.lang.Byte*/public java.lang.Boolean getBorrowallowed(){return this.}/*** Set the value of the borrowallowed column.* @param borrowallowed*/public void setBorrowallowed(java.lang.Boolean borrowallowed){this.borrowallowed =}
In the class Book I overwrote the toString method to get a proper output during debugging. If the relation to customer is not detected properly, here is the complete code of the class.
package de.laliluna.import java.io.S/** * A class that represents a row in the 'book' table.
* This class may be customized as it is never re-generated
* after being created. */public class Book
extends AbstractBook
implements Serializable{ private C
@Override public String toString() {
return "Book:
" + getId()+" title: "+getTitle()+" author: "+getAuthor() + " borrowed to: "+getCustomer();
} public Customer getCustomer() {
} public void setCustomer(Customer customer) {
this.customer = } /**
* Simple constructor of Book instances.
public Book()
* Constructor of Book instances given a simple primary key.
* @param id
public Book(java.lang.Integer id)
super(id);
/* Add customized code below */}
Improvements to the session factory
The session factory generated by MyEclipse is not very nice because it lets you run into errors when you use the session.close() method. The session factory expects that you use the static method closeSession() of the factory, which actually sets the session to null if it is closed.
But no problem, here are the changes to the method currentSession of the factory.
public static Session currentSession() throws HibernateException {Session session = (Session) threadLocal.get();/** [laliluna] 20.12.2004* we want to use the standard session.close() method and not the closeSession() from this class.* For this we need the following line of code.*/if (session != null && !session.isOpen()) session =if (session == null) {if (sessionFactory == null) {try {cfg.configure(CONFIG_FILE_LOCATION);sessionFactory = cfg.buildSessionFactory();} catch (Exception e) {System.err
.println("%%%% Error Creating HibernateSessionFactory %%%%");e.printStackTrace();}}session = sessionFactory.openSession();threadLocal.set(session);}}
Testing the Hibernate part
We will need log4j to test Hibernate outside of an Application Server. You can find the library as jar file here:
Add the library to your Eclipse project (project properties =& Java Build Path =& Add Jar or Add external Jar. You can find a basic log4j.properties file in the source.
Create a new class to implement the test methods.
Add the following content:
package de.laliluna.library.import java.util.Iimport java.util.Limport java.util.Simport org.apache.log4j.Limport org.hibernate.Simport org.hibernate.Timport de.laliluna.library.Bimport de.laliluna.library.Cimport de.laliluna.library.HibernateSessionFpublic class LibraryTest { private S private L public static void main(String[] args) {
* hibernate needs log4j. Either create a log4j.properties file in the
* source directory * or alternatively make the following to create a
* standard configuration BasicConfigurator.configure();
LibraryTest libraryTest = new LibraryTest();
libraryTest.setUp();
libraryTest.testCreateDomains();
libraryTest.testAddRemoveRelation();
libraryTest.listBooks();
libraryTest.tearDown();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } private void testCreateDomains() {
Transaction tx = session.beginTransaction();
Book book = new Book();
book.setAuthor("Sebastian");
book.setTitle("Hibernation in winter");
book.setBorrowallowed(true);
session.save(book);
tx.commit();
tx = session.beginTransaction();
Customer customer = new Customer();
customer.setLastname("Liebzeit");
customer.setFirstname("Carsten");
customer.setAge(25);
session.save(customer);
tx.commit(); } private void testAddRemoveRelation() {
("Adding and removing relations");
Transaction tx = session.beginTransaction();
// create two books and a customer
Book book = new Book();
book.setAuthor("Sebastian's");
book.setTitle("Hibernation in the summer");
book.setBorrowallowed(true);
session.save(book);
Book book2 = new Book();
book2.setAuthor("Karl May");
book2.setTitle("Wildes Kurdistan");
book2.setBorrowallowed(true);
session.save(book2);
Customer customer = new Customer();
customer.setLastname("Meier");
customer.setFirstname("John");
customer.setAge(25);
session.save(customer);
//customer borrows
customer.getBooks().add(book);
customer.getBooks().add(book2);
session.flush();
session.refresh(customer);
session.refresh(book);
session.refresh(book2);
Set books = customer.getBooks();
("list books of customer");
for (Iterator iter = books.iterator(); iter.hasNext();) {
Book element = (Book) iter.next();
(element);
//first book is returned
book.setCustomer(null);
customer.getBooks().remove(book);
session.flush();
session.refresh(customer);
("list books of customer");
books = customer.getBooks();
for (Iterator iter = books.iterator(); iter.hasNext();) {
Book element = (Book) iter.next();
(element);
tx.commit();
tx = session.beginTransaction();
session.delete(customer);
session.delete(book);
session.delete(book2);
tx.commit(); } protected void setUp() throws Exception {
session = HibernateSessionFactory.currentSession();
log = Logger.getLogger(this.getClass()); } protected void tearDown() throws Exception {
HibernateSessionFactory.closeSession(); } /**
* creates a book and saves it to the db.
* lists all books in the db
*/ private void listBooks() {
("####### list customers");
Transaction tx = session.beginTransaction();
List customers = session.createQuery("select c from Customer as c")
for (Iterator iter = customers.iterator(); iter.hasNext();) {
Customer element = (Customer) iter.next();
Set books = element.getBooks();
System.out.println(element);
if (books == null)
("no books");
for (Iterator iterator = books.iterator(); iterator.hasNext();) {
Book book = (Book) iterator.next();
- " + book);
(element);
tx.commit();
("####### list books");
tx = session.beginTransaction();
List books = session.createQuery("select b from Book as b").list();
for (Iterator iter = books.iterator(); iter.hasNext();) {
System.out.println((Book) iter.next());
tx.commit(); } /**
* @return Returns the session.
*/ public Session getSession() {
* @param session
The session to set.
*/ public void setSession(Session session) {
this.session = }}
Right click on the class and choose Run -& Java Application.
And at least when we are using PostgreSQL, we got a lots of error message.
java.sql.SQLException: ERROR: relation "hibernate_sequence" does not exist
PostgreSQL Problem
This is because there is a simple bug in the import script. It assumes that the sequence is called hibernate_sequence. The sequences created automatically when your are using a serial column, is called table_column_seq, eg: book_id_seq.
The easiest work around is to wait until MyEclipse improves the script. The fastest to create a sequence called hibernate_sequence. A disadvantage is that all tables share the same sequence.
CREATE SEQUENCE
hibernate_sequenceINCREMENT 1MINVALUE 1MAXVALUE 4775807START 1CACHE 1;
The nicest way, but only possible when you are sure not to regenerate your mapping files (you would override your changes) is to change the mapping from
&generator class="sequence"/&
to the following for the book. The changes for the customer are analogues.
&generator class="sequence"&&param name="sequence"&book_id_seq&/param&&/generator&
That's it for the persistence layer for our application.
Generating the Business Logic
Create a business logic class
We will place all business logic in a single class. Later our Struts part will only use this Class. There won't be any direct access to the persistence layer. You could even think about replacing your persistence layer with another one.
This class will hold all methods we need as business logic
creating, updating and deleting books
creating, updating and deleting customers
borrowing and returning books
reading all customers or books from the db into a list
Hibernate Design we used
A hibernate query returns a List interface to a special Hibernate implementation of a List. This implementation is directly connected to the session. You cannot close your session when you use this Hibernate lists. Either you have to disconnect the session from the database and reconnect it, use one of the caching solutions or take the easiest but not best way to work with Value Objects.
We took the easiest way:
The consequence is that we have to copy all elements of a hibernate list to a normal java.util.List.
/** Created on 25.11.2004 by HS* */package de.laliluna.library.import java.util.ArrayLimport java.util.Iimport java.util.Limport java.util.Simport org.hibernate.Simport org.hibernate.Timport de.laliluna.library.Bimport de.laliluna.library.Cimport de.laliluna.library.HibernateSessionF/*** @author HS* * */public class LibraryManager { /**
* get all books from the database
* @return Array of BookValue
*/ public Book[] getAllBooks() {
/* will hold the books we are going to return later */
List books = new ArrayList();
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
List tmpBooks = session.createQuery(
"select b from Book as b order by b.author, b.title").list();
for (Iterator iter = tmpBooks.iterator(); iter.hasNext();) {
books.add((Book) iter.next());
tx.commit();
return (Book[]) books.toArray(new Book[0]); } /**
* get book by primary key
* @param primaryKey
* @return a Book or null
*/ public Book getBookByPrimaryKey(Integer primaryKey) {
/* holds our return value */
Book book =
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
book = (Book) session.get(Book.class, primaryKey);
tx.commit();
* sets the book as borrowed to the user specified in the database
* @param primaryKey
* @param userPrimaryKey
*/ public void borrowBook(Integer primaryKey, Integer customerPrimaryKey) {
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
Book book = (Book) session.get(Book.class, primaryKey);
// only if borrowing of the book is allowed
if (book.getBorrowallowed()) {
Customer customer = (Customer) session.get(Customer.class,
customerPrimaryKey);
if (book != null && customer != null)
book.setCustomer(customer);
tx.commit(); } /**
* customer returns a book, relation in the db between customer and book is
* @param primaryKey
*/ public void returnBook(Integer primaryKey) {
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
Book book = (Book) session.get(Book.class, primaryKey);
if (book != null) {
// session.get returns null when no entry is found
Customer customer = book.getCustomer();
if (customer != null) {
customer.getBooks().remove(book);
book.setCustomer(null);
tx.commit(); } /**
* updates/creates a book
* @param bookValue
*/ public void saveBook(Book bookValue) {
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
if (bookValue.getId() != null && bookValue.getId().intValue() != 0) { // [laliluna]
// 04.12.2004
book = (Book) session.get(Book.class, bookValue.getId());
if (book != null) {
book.setAuthor(bookValue.getAuthor());
book.setTitle(bookValue.getTitle());
book.setBorrowallowed(bookValue.getBorrowallowed());
session.update(book);
} else // [laliluna] 04.12.2004 create new book
book = new Book();
book.setAuthor(bookValue.getAuthor());
book.setTitle(bookValue.getTitle());
book.setBorrowallowed(bookValue.getBorrowallowed());
session.save(book);
tx.commit(); } /**
* deletes a book
* @param primaryKey
*/ public void removeBookByPrimaryKey(Integer primaryKey) {
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
Book book = (Book) session.get(Book.class, primaryKey);
if (book != null)
if (book.getCustomer() != null)
book.getCustomer().getBooks().remove(book);
session.delete(book);
tx.commit(); } /**
* returns all customers from the db
*/ public Customer[] getAllCustomers() {
/* will hold the books we are going to return later */
List customers = new ArrayList();
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
List tmpCustomer = session.createQuery(
"select c from Customer as c order by c.lastname").list();
for (Iterator iter = tmpCustomer.iterator(); iter.hasNext();) {
customers.add((Customer) iter.next());
tx.commit();
return (Customer[]) customers.toArray(new Customer[0]); } /**
* gets a customer from the db
* @param primaryKey
* @return the customer class or null, when no customer is found
*/ public Customer getCustomerByPrimaryKey(Integer primaryKey) {
/* holds our return value */
Customer customer =
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
customer = (Customer) session.get(Customer.class, primaryKey);
tx.commit();
* saves the customers to the db
* @param customer
*/ public void saveCustomer(Customer customer) {
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
if (customer.getId() == null || customer.getId().intValue() == 0) // [laliluna]
// 06.12.2004
// customer
session.save(customer);
Customer toBeUpdated = (Customer) session.get(Customer.class,
customer.getId());
toBeUpdated.setAge(customer.getAge());
toBeUpdated.setLastname(customer.getLastname());
toBeUpdated.setFirstname(customer.getFirstname());
session.update(toBeUpdated);
tx.commit(); } /**
* deletes a customer from the database
* @param primaryKey
*/ public void removeCustomerByPrimaryKey(Integer primaryKey) {
/* a Hibernate session */
Session session =
/* we always need a transaction */
Transaction tx =
/* get session of the current thread */
session = HibernateSessionFactory.currentSession();
tx = session.beginTransaction();
Customer customer = (Customer) session.get(Customer.class, primaryKey);
if (customer != null) {
Set books = customer.getBooks();
for (Iterator iter = books.iterator(); iter.hasNext();) {
Book element = (Book) iter.next();
element.setCustomer(null);
session.delete(customer);
tx.commit(); }}
That's all we have created our business logic.
And now the last part: the dialogs
Creating the dialogs with Struts
For now your project is still a normal Web project, so we need to add the struts capabilityies. Right click on the project and add the capabilityies for struts with Add Struts Capabilityies.
Change the Base package for new classes and theDefault application resource.
You can use the libraries and tlds found in the struts-blanc.war when you do not have MyEclipse. Download struts from
You can find the struts-blank.war in the folder jakarta-struts-1.2.4/webapps.
Create a default, welcome page
Ok, now we want to create a default page. Right click (yes again) on the Folder WebRoot in the Project and choose New & JSP.
Set the name to index.jsp and choose on template to use & Standard JSP using Struts 1.2 MyEcplise will use the template to create the JSP File.
You will find the file index.jsp in the folder WebRoot of the project. On the top of the file you will find the declaration of the struts tag libraries. These includes will be use to access the tags of struts. In this case we only need the logic tag library.
Insert the following line below the included logic tag.
&logic:forward name="welcome" /&
This line instructs struts to look for a forward with the name welcome. If the application don?t find this forward, it will state an error. In the next section I briefly explain the action forward.
Create a second index.jsp file in the folder /WebRoot/jspChange the body of the file to the following:
&body&Welcome!&br&&html:link action="bookList"&Show the book list&/html:link&&br&&html:link action="customerList"&Show the customer list&/html:link&&/body&
Global Action Forwards and Action Mappings
What is an action forward?A action forward can be used to forward to a jsp or action mapping. There are two different action forwards. The global action forward and the local action forward. You can access a global action forward on each jsp or action class. A local action forward can only be accessed by the assigned action class.
What is a action mapping?The action mapping is the heart of struts. It managed all actions between the application and the user. You can define which action will be executed by creating a action mapping.
The diagram show you, how the application server manage the request of the index.jsp or a non existing action mapping.
In the first step we create a new action mapping. Open the struts-config.xml, you will find it in the folder WebRoot/WEB-INF. Right click in the outline view on action-mapping.
MyEclipse provides some nice features for creating struts files. Open the struts-config.xml and the Outline View.
Click with the right mouse button on the entry action-mappings to create a new action with the wizard.
Choose Use Case default and Action Type Forward. The Forward Path is the welcome page /jsp/index.jsp
To catch all requests of non existing action mappings, we have to add manually a parameter unknow="true" to the action forward.
&action-mappings &&action forward="/jsp/index.jsp" path="/default" unknown="true"/&&/action-mappings&
In the second step you create a global action forward. Go back to the outline window of MyEclipse and choose Global Forward
Choose the Forward Scope Global Forward. For name use the same you have set in your default page. The Global Forward refers to your action mapping.
You will see the following in your struts-config.xml now:
&?xml version="1.0" encoding="UTF-8"?&&!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd"&&struts-config&&data-sources /&&form-beans /&&global-exceptions /&&global-forwards &&forwardname="welcome"path="/default.do"redirect="true" /&&/global-forwards&&action-mappings &&action forward="/jsp/index.jsp" path="/default" unknown="true"
/&&/action-mappings&&message-resources parameter="de.laliluna.library.struts.ApplicationResources" /&&/struts-config&
This use case lists all available books.
Select the wizard for creating a new form, action and JSP.
Use Case is bookList, Superclass org.apache.struts.ActionForm. You should create a reset method to initialize your fields. Select public void reset to create this method.
Go on to the jsp tab and set the name of the jsp to be created.
Press the next button to continue to the action mapping.
Action mapping und action class of the book list
Make the following changes for the action class.
Superclass org.apache.struts.ActionOn Optional Details choose the Form Bean bookListForm. The input source is /jsp/bookList.jsp
Now add a forward showList to the action mapping.
That's it. Let the files be generated.
MyEclipse adds the action mapping to the struts-config, creates a blanc JSP, an Action class and the ActionForm class. You can of course do this by hand or using a tool like the struts console.
The action look like:
&actionattribute="bookListForm"input="/jsp/bookList.jsp"name="bookListForm"path="/bookList"scope="request"type="de.laliluna.library.struts.action.BookListAction"&&forward name="showList" path="/jsp/bookList.jsp" /&<
&&&&推荐文章:
【上篇】【下篇】}