JSP Servlet Hibernate CRUD Example


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:
  1. Create a User
  2. Update a User
  3. Delete a User
  4. Retrieve a User
  5. List of all Users
The application looks something like this:
Let's go ahead and create CRUD web application step-by-step.

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

3. Project Structure

Standard project structure for your reference - 


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:
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    
}
Here are the JPA annotations used in the above class:

@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>
         &nbsp;&nbsp;&nbsp;
         <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>
                     &nbsp;&nbsp;&nbsp;&nbsp;
                     <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>
         &nbsp;&nbsp;&nbsp;
         <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.

Related Servlet + JSP + JDBC + MySQL Examples

Comments

  1. hey bro i need help the project run good but when i add new user the data doesn't insert into database

    ReplyDelete
  2. Hi,
    I followed the tutorial but I am getting this error as
    "The import org.hibernate cannot be
    resolved". Please help me

    ReplyDelete
    Replies
    1. u make sure that "added" hibernate in lib

      Delete
  3. This comment has been removed by the author.

    ReplyDelete
  4. Hi Bro,
    How to auto-genrate create table schema instead of manually create in mysql terminal

    ReplyDelete
  5. i aways get an error.

    ```org.hibernate.property.access.spi.PropertyAccessException: Error accessing field```

    when i opt the data

    ReplyDelete
  6. Hi sir, thanks for the great tutorial.
    I 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.

    ReplyDelete

Post a Comment

Leave Comment