In the world of Java web development, the JSP, Servlet, and Hibernate are common technologies used for creating dynamic and interactive web applications. In this blog post, we'll dive into an example that demonstrates how to use these three technologies together to create a CRUD (Create, Read, Update, Delete) application for managing users.
Overview of the Technologies
JSP (JavaServer Pages)
Role: Presentation Layer
Function: Allows embedding of Java code directly within HTML to create dynamic content.
Benefits: Simplifies the development of web pages with dynamic content.
Servlets
Role: Controller Layer
Function: Handles HTTP requests and responses, connecting the presentation layer to the business logic.
Benefits: Provides a robust and scalable way to handle user requests and server responses.
Hibernate
Role: Persistence Layer
Function: A powerful ORM (Object-Relational Mapping) tool that facilitates interaction with the database.
Benefits: Simplifies database operations, improving development speed, maintainability, and portability.
You can download the source code of this tutorial from my GitHub repository and the link is given at the end of this tutorial.
MVC Pattern
In this example, we are going to follow Model-View-Controller (MVC) pattern to organize the codebase.
The Model-View-Controller (MVC) pattern is a design pattern used in software engineering aimed at organizing code in a way that separates concerns, and it's particularly popular in web development.
Here's how it applies to Java web applications using JSP (JavaServer Pages) and Servlets.
1. Model
The Model is responsible for the data and the rules of the application. It communicates to the database and updates the View whenever the data changes. In Java, the model is usually represented by a POJO (Plain Old Java Object), possibly annotated to interact with a database using an ORM like Hibernate.
2. View
The View is what the end-user interacts with. It presents the model data and sends user commands to the Controller. In Java web applications, this is typically handled by JSP files, which generate the HTML that's sent to the user's browser.
3. Controller
The Controller (Servlet) takes the user's input from the View, processes it (with possible updates to the Model), and returns the output display to the user (a View).
JSP Servlet Hibernate CRUD Example
In this example, we will create a simple User Management web application and implement below CRUD features:
- Create a User
- Update a User
- Delete a User
- Retrieve a User
- List of all Users
The application looks something like this:
1. Create an Eclipse Dynamic Web Project
To create a new dynamic Web project in Eclipse:
1. On the main menu select File > New > Project....
2. In the upcoming wizard choose Web > Dynamic Web Project.
3. Click Next.
4. Enter project name as "jsp-servlet-hibernate-mysql-example";5. Make sure that the target runtime is set to Apache Tomcat with the currently supported version.
2. Add Dependencies
Add the latest release of the below jar files to the lib folder:
You can download all these JAR files from my GitHub repository - jsp-servlet-hibernate-mysql-tutorial
4. MySQL Database Setup
Let's create a database named "demo" in MySQL. Now, create a users table using below DDL script:
CREATE DATABASE 'demo';
USE demo;
create table users (
id int(3) NOT NULL AUTO_INCREMENT,
name varchar(120) NOT NULL,
email varchar(220) NOT NULL,
country varchar(120),
PRIMARY KEY (id)
);
You can use either MySQL Command Line Client or MySQL Workbench tool to create the database. The above a users table looks like this:
5. Model Layer - Create a JPA Entity - User.java
Let's create a User persistent class that is mapped to a database table:
Here are the JPA annotations used in the above class:package net.javaguides.usermanagement.model; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name="users") public class User { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) @Column(name="id") protected int id; @Column(name="name") protected String name; @Column(name="email") protected String email; @Column(name="country") protected String country; public User() { } public User(String name, String email, String country) { super(); this.name = name; this.email = email; this.country = country; } public User(int id, String name, String email, String country) { super(); this.id = id; this.name = name; this.email = email; this.country = country; } // getter/setter methods }
@Entity: Specifies that a class is an entity and is mapped to a database table.
@Table: Specifies the table name associated with an entity.
@Id: Marks a field as the primary key of an entity.
@GeneratedValue: Specifies the strategy for generating primary key values.
@Column: Specifies the mapping for a database column.
6. Hibernate Java-based configuration
Let's create HibernateUtil to bootstrap Hibernate. This class typically encapsulates the creation and management of the SessionFactory, a thread-safe and heavyweight object that is created once per application.
Here is the complete code:
package net.javaguides.usermanagement.utl;
import java.util.Properties;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.service.ServiceRegistry;
import net.javaguides.usermanagement.model.User;
public class HibernateUtil {
private static SessionFactory sessionFactory;
public static SessionFactory getSessionFactory() {
if (sessionFactory == null) {
try {
Configuration configuration = new Configuration();
// Hibernate settings equivalent to hibernate.cfg.xml's properties
Properties settings = new Properties();
settings.put(Environment.DRIVER, "com.mysql.jdbc.Driver");
settings.put(Environment.URL, "jdbc:mysql://localhost:3306/demo?useSSL=false");
settings.put(Environment.USER, "root");
settings.put(Environment.PASS, "root");
settings.put(Environment.DIALECT, "org.hibernate.dialect.MySQL5Dialect");
settings.put(Environment.SHOW_SQL, "true");
settings.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "thread");
settings.put(Environment.HBM2DDL_AUTO, "create-drop");
configuration.setProperties(settings);
configuration.addAnnotatedClass(User.class);
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Java Config serviceRegistry created");
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Exception e) {
e.printStackTrace();
}
}
return sessionFactory;
}
}
The SessionFactory is responsible for creating Session objects, which represent a single unit of work with the database. It is a heavyweight object and is usually instantiated only once for the entire application. This object holds the second-level cache and other configurations that are required to create a Session.
The Configuration object is used to configure and bootstrap Hibernate. It's created within HibernateUtil and is responsible for reading Hibernate properties from an XML file or annotations.
The configuration.addAnnotatedClass(User.class) method call adds the User class as an entity, allowing Hibernate to map it to a database table.
The ServiceRegistry is responsible for holding and managing services that Hibernate uses. It's constructed with the settings from the Configuration object.
7. Persistence Layer - Create a UserDAO.java
Let's create a UserDAO class which is a Data Access Layer (DAO) class that provides CRUD (Create, Read, Update, Delete) operations using for the users table in a database using Hibernate. Here’s the full source code of the UserDAO:
package net.javaguides.usermanagement.dao; import java.util.List; import org.hibernate.Session; import org.hibernate.Transaction; import net.javaguides.usermanagement.model.User; import net.javaguides.usermanagement.utl.HibernateUtil; /** * CRUD database operations * @author Ramesh Fadatare * */ public class UserDao { /** * Save User * @param user */ public void saveUser(User user) { Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { // start a transaction transaction = session.beginTransaction(); // save the student object session.save(user); // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } /** * Update User * @param user */ public void updateUser(User user) { Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { // start a transaction transaction = session.beginTransaction(); // save the student object session.update(user); // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } /** * Delete User * @param id */ public void deleteUser(int id) { Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { // start a transaction transaction = session.beginTransaction(); // Delete a user object User user = session.get(User.class, id); if (user != null) { session.delete(user); System.out.println("user is deleted"); } // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } /** * Get User By ID * @param id * @return */ public User getUser(int id) { Transaction transaction = null; User user = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { // start a transaction transaction = session.beginTransaction(); // get an user object user = session.get(User.class, id); // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } return user; } /** * Get all Users * @return */ @SuppressWarnings("unchecked") public List < User > getAllUser() { Transaction transaction = null; List < User > listOfUser = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { // start a transaction transaction = session.beginTransaction(); // get an user object listOfUser = session.createQuery("from User").getResultList(); // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } return listOfUser; } }
8. Controller Layer - Create a UserServlet.java
Now, let's create a UserServlet that acts as a page controller to handle all requests from the client.
Let’s look at the code first:
package net.javaguides.usermanagement.web; import java.io.IOException; import java.sql.SQLException; import java.util.List; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import net.javaguides.usermanagement.dao.UserDao; import net.javaguides.usermanagement.model.User; /** * ControllerServlet.java * This servlet acts as a page controller for the application, handling all * requests from the user. * @email Ramesh Fadatare */ @WebServlet("/") public class UserServlet extends HttpServlet { private static final long serialVersionUID = 1 L; private UserDao userDao; public void init() { userDao = new UserDao(); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String action = request.getServletPath(); try { switch (action) { case "/new": showNewForm(request, response); break; case "/insert": insertUser(request, response); break; case "/delete": deleteUser(request, response); break; case "/edit": showEditForm(request, response); break; case "/update": updateUser(request, response); break; default: listUser(request, response); break; } } catch (SQLException ex) { throw new ServletException(ex); } } private void listUser(HttpServletRequest request, HttpServletResponse response) throws SQLException, IOException, ServletException { List < User > listUser = userDao.getAllUser(); request.setAttribute("listUser", listUser); RequestDispatcher dispatcher = request.getRequestDispatcher("user-list.jsp"); dispatcher.forward(request, response); } private void showNewForm(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { RequestDispatcher dispatcher = request.getRequestDispatcher("user-form.jsp"); dispatcher.forward(request, response); } private void showEditForm(HttpServletRequest request, HttpServletResponse response) throws SQLException, ServletException, IOException { int id = Integer.parseInt(request.getParameter("id")); User existingUser = userDao.getUser(id); RequestDispatcher dispatcher = request.getRequestDispatcher("user-form.jsp"); request.setAttribute("user", existingUser); dispatcher.forward(request, response); } private void insertUser(HttpServletRequest request, HttpServletResponse response) throws SQLException, IOException { String name = request.getParameter("name"); String email = request.getParameter("email"); String country = request.getParameter("country"); User newUser = new User(name, email, country); userDao.saveUser(newUser); response.sendRedirect("list"); } private void updateUser(HttpServletRequest request, HttpServletResponse response) throws SQLException, IOException { int id = Integer.parseInt(request.getParameter("id")); String name = request.getParameter("name"); String email = request.getParameter("email"); String country = request.getParameter("country"); User user = new User(id, name, email, country); userDao.updateUser(user); response.sendRedirect("list"); } private void deleteUser(HttpServletRequest request, HttpServletResponse response) throws SQLException, IOException { int id = Integer.parseInt(request.getParameter("id")); userDao.deleteUser(id); response.sendRedirect("list"); } }
9. View Layer
9.1 Creating User Listing JSP Page - user-list.jsp
Next, let's create a JSP page for displaying all users from the database.
Let's create a list-user.jsp page under the WebContent directory in the project and add the following code:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>User Management Application</title>
</head>
<body>
<center>
<h1>User Management</h1>
<h2>
<a href="new">Add New User</a>
<a href="list">List All Users</a>
</h2>
</center>
<div align="center">
<table border="1" cellpadding="5">
<caption><h2>List of Users</h2></caption>
<tr>
<th>ID</th>
<th>Name</th>
<th>Email</th>
<th>Country</th>
<th>Actions</th>
</tr>
<c:forEach var="user" items="${listUser}">
<tr>
<td><c:out value="${user.id}" /></td>
<td><c:out value="${user.name}" /></td>
<td><c:out value="${user.email}" /></td>
<td><c:out value="${user.country}" /></td>
<td>
<a href="edit?id=<c:out value='${user.id}' />">Edit</a>
<a href="delete?id=<c:out value='${user.id}' />">Delete</a>
</td>
</tr>
</c:forEach>
</table>
</div>
</body>
</html>
Once you will deploy the above JSP page in Tomcat and open it in the browser looks something like this:
9.2 Create a User Form JSP Page - user-form.jsp
Next, we create a JSP page for creating a new User called user-form.jsp. Here’s its full source code:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>User Management Application</title>
</head>
<body>
<center>
<h1>User Management</h1>
<h2>
<a href="new">Add New User</a>
<a href="list">List All Users</a>
</h2>
</center>
<div align="center">
<c:if test="${user != null}">
<form action="update" method="post">
</c:if>
<c:if test="${user == null}">
<form action="insert" method="post">
</c:if>
<table border="1" cellpadding="5">
<caption>
<h2>
<c:if test="${user != null}">
Edit User
</c:if>
<c:if test="${user == null}">
Add New User
</c:if>
</h2>
</caption>
<c:if test="${user != null}">
<input type="hidden" name="id" value="<c:out value='${user.id}' />" />
</c:if>
<tr>
<th>User Name: </th>
<td>
<input type="text" name="name" size="45"
value="<c:out value='${user.name}' />"
/>
</td>
</tr>
<tr>
<th>User Email: </th>
<td>
<input type="text" name="email" size="45"
value="<c:out value='${user.email}' />"
/>
</td>
</tr>
<tr>
<th>Country: </th>
<td>
<input type="text" name="country" size="15"
value="<c:out value='${user.country}' />"
/>
</td>
</tr>
<tr>
<td colspan="2" align="center">
<input type="submit" value="Save" />
</td>
</tr>
</table>
</form>
</div>
</body>
</html>
Once you will deploy the above JSP page in Tomcat and open it in the browser looks something like this:
The above page acts for both functionalities to create a new User and Edit the same user. The edit page looks like this:
9.3 Creating Error JSP page
Here’s the code of the Error.jsp page which simply shows the exception message:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isErrorPage="true" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Error</title>
</head>
<body>
<center>
<h1>Error</h1>
<h2><%=exception.getMessage() %><br/> </h2>
</center>
</body>
</html>
10. Deploying and Testing the Application
It's time to see a demo of the above User Management web application. Deploy this web application to the Tomcat server.
Type the following URL in your web browser to access the User Management application: http://localhost:8080/jsp-servlet-jdbc-mysql-crud-example/
Create a new User
Edit a User
List of all Users
GitHub Repository
The source code of this tutorial (User Management) is available on my GitHub repository at JSP Servlet Hibernate CRUD Example
Conclusion
JSP, Servlet, and Hibernate form a powerful combination for building robust and scalable web applications. With JSP handling the view, Servlets taking care of the control logic, and Hibernate managing the data access, developers can create maintainable and efficient CRUD applications.By following the separation of concerns and employing the MVC pattern, this example illustrates a clean and modular approach to web application development. Whether you're building a complex enterprise application or a simple website, these technologies provide a strong foundation for your Java web development needs.
hey bro i need help the project run good but when i add new user the data doesn't insert into database
ReplyDeletemaybe you forget commit the transaction
DeleteHi,
ReplyDeleteI followed the tutorial but I am getting this error as
"The import org.hibernate cannot be
resolved". Please help me
u make sure that "added" hibernate in lib
DeleteThis comment has been removed by the author.
ReplyDeleteHi Bro,
ReplyDeleteHow to auto-genrate create table schema instead of manually create in mysql terminal
i aways get an error.
ReplyDelete```org.hibernate.property.access.spi.PropertyAccessException: Error accessing field```
when i opt the data
Hi sir, thanks for the great tutorial.
ReplyDeleteI added a servlet for login and from my loginServlet i try to access the "UserServlet"
but i keep getting an error when trying to add a new user or update it. the problem is with my action because it returns /UserServlet instead of /new or /list. Can you please help me solve this issue I tried multiple ways but nothing works.