Spring MVC + Spring Boot2 + JSP + JPA + Hibernate 5 + MySQL Example

In this article, we will learn how to develop a Spring MVC web application using Spring MVC, Spring boot 2, JSP, Hibernate 5, JPA, Maven, and MySQL database.

Table of Contents

                

                    
What we’ll build 
                        
  Tools and Technologies Used
                            
  Creating and Importing a Project
                                
 Packaging Structure
                                    
  The pom.xml File
                                        
 The Springboot2WebappJspApplication.java File
                                            
 Create a JPA Entity called User.java
                                                
 Create Spring Data JPA Repository - UserRepository.java
                                                    
 Create Spring Controller - UserController.java
                                                        
 Configuring MySQL Database and JSP View Resolver
                                                            
 Insert SQL Script
                                                                
 Create a JSP View - users.jsp
                                                                    
 Running the Application
                                                                        
 Source code on GitHub
                
            

1. What we’ll build

We are building a simple Spring MVC web application and JSP as a view. We will create JSP page which displays a list of users from MySQL database.

2. Tools and Technologies Used

• Spring Boot - 2.0.4.RELEASE
• JDK - 1.8 or later
• Spring Framework - 5.0.8 RELEASE
• Hibernate - 5.2.17.Final
• Maven - 3.2+
• IDE - Eclipse or Spring Tool Suite (STS)
• Tomcat - 8.5+
• Spring Data JPA - 2.0.10 RELEASE
• JSP
• Bootstrap - 3+

3. Creating and Importing a Project

There are many ways to create a Spring Boot application. The simplest way is to use Spring Initializr at http://start.spring.io/, which is an online Spring Boot application generator.

Look at the above diagram, we have specified following details:

• Generate: Maven Project
• Java Version: 1.8 (Default)
• Spring Boot:2.0.4
• Group: net.guides.springboot2
• Artifact: springboot2-webapp-jsp
• Name: springboot2-webapp-jsp
• Package Name : net.guides.springboot2.springboot2webappjsp
• Packaging: jar (This is the default value)
• Dependencies: Web, JPA, MySQL, DevTools

Once, all the details are entered, click on Generate Project button will generate a spring boot project and downloads it. Next, Unzip the downloaded zip file and import it into your favorite IDE.

4. Packaging Structure

Once we will import generated spring boot project in IDE, we will see some auto-generated files.

1. pom.xml
2. resources
3. Springboot2WebappJspApplication.java
4. Springboot2WebappJspApplicationTests.java

5. The pom.xml File

            <?xml version="1.0" encoding="UTF-8"?>
            <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>net.guides.springboot2</groupId>
                <artifactId>springboot2-webapp-jsp</artifactId>
                <version>0.0.1-SNAPSHOT</version>
                <packaging>jar</packaging>
            
                <name>springboot2-webapp-jsp</name>
                <description>Demo project for Spring Boot</description>
            
                <parent>
                     <groupId>org.springframework.boot</groupId>
                     <artifactId>spring-boot-starter-parent</artifactId>
                     <version>2.0.4.RELEASE</version>
                     <relativePath /> <!-- lookup parent from repository -->
                </parent>
            
                <properties>
                   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                   <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
                   <java.version>1.8</java.version>
                </properties>
            
                <dependencies>
                    <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-web</artifactId>
                    </dependency>
            
                    <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-data-jpa</artifactId>
                    </dependency>
            
                    <dependency>
                         <groupId>org.springframework.boot</groupId>
                         <artifactId>spring-boot-devtools</artifactId>
                         <scope>runtime</scope>
                    </dependency>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <scope>runtime</scope>
                    </dependency>
                    <dependency>
                         <groupId>org.springframework.boot</groupId>
                         <artifactId>spring-boot-starter-test</artifactId>
                         <scope>test</scope>
                    </dependency>
            
                    <!-- JSTL for JSP -->
                   <dependency>
                        <groupId>javax.servlet</groupId>
                        <artifactId>jstl</artifactId>
                   </dependency>
            
                   <!-- Need this to compile JSP -->
                   <dependency>
                      <groupId>org.apache.tomcat.embed</groupId>
                      <artifactId>tomcat-embed-jasper</artifactId>
                      <scope>provided</scope>
                   </dependency>
            
                   <!-- Optional, test for static content, bootstrap CSS -->
                  <dependency>
                      <groupId>org.webjars</groupId>
                      <artifactId>bootstrap</artifactId>
                      <version>3.3.7</version>
                  </dependency>
               </dependencies>
            
               <build>
                   <plugins>
                      <plugin>
                         <groupId>org.springframework.boot</groupId>
                         <artifactId>spring-boot-maven-plugin</artifactId>
                     </plugin>
                  </plugins>
               </build>
            </project>
            

WebJars

Note that we have added Twitter Bootstrap to pom.xml.

    <!-- Optional, test for static content, bootstrap CSS -->
    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>bootstrap</artifactId>
        <version>3.3.7</version>
    </dependency>
    

WebJars are client-side dependencies packaged into JAR archive files. They work with most JVM containers and web frameworks.

Here are a few interesting advantages of WebJars:

1. We can explicitly and easily manage the client-side dependencies in JVM-based web applications

2. We can use them with any commonly used build tool, eg: Maven, Gradle, etc

3. WebJars behave like any other Maven dependency – which means that we get transitive dependencies as well

JSP Support

We want to use JSP as the view. Default embedded servlet container for Spring Boot Starter Web is tomcat. To enable support for JSP’s, we would need to add a dependency on tomcat-embed-jasper.

 <dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
    </dependency>

6. The Springboot2WebappJspApplication.java File

This class provides an entry point with the public static void main(String[] args) method, which you can run to start the application.

Note that SpringBootServletInitializer run a SpringApplication from a traditional WAR deployment

package net.guides.springboot2.springboot2webappjsp;

        import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
        import org.springframework.boot.builder.SpringApplicationBuilder;
        import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
        
        @SpringBootApplication
        public class Springboot2WebappJspApplication extends SpringBootServletInitializer{
        
            @Override
            protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
                return application.sources(Springboot2WebappJspApplication.class);
            }
         
            public static void main(String[] args) {
                SpringApplication.run(Springboot2WebappJspApplication.class, args);
            }
        }

7. Create a JPA Entity - User.java

package net.guides.springboot2.springboot2webappjsp.domain;

    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "user")
    public class User
    {
        @Id 
        @GeneratedValue(strategy=GenerationType.AUTO)
        private Integer id;
        private String name;
     
        public User()
        {
        }
    
        public User(Integer id, String name)
        {
            this.id = id;
            this.name = name;
        }
    
        public Integer getId()
        {  
            return id;
        }
    
        public void setId(Integer id)
        {
            this.id = id;
        }
    
        public String getName()
        {
            return name;
        }
    
        public void setName(String name)
        {
            this.name = name;
        }
    }

8. Create Spring Data JPA Repository - UserRepository.java

package net.guides.springboot2.springboot2webappjsp.repositories;

    import org.springframework.data.jpa.repository.JpaRepository;
    
    import net.guides.springboot2.springboot2webappjsp.domain.User;
    
    public interface UserRepository extends JpaRepository
    {
    
    }

9. Create Spring Controller - UserController.java

package net.guides.springboot2.springboot2webappjsp.controllers;

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import net.guides.springboot2.springboot2webappjsp.repositories.UserRepository;
    
    @Controller
    public class UserController {
        @Autowired
        UserRepository userRepo;
    
        @RequestMapping("/users")
        public String home(Model model) {
             model.addAttribute("users", userRepo.findAll());
             return "index";
        }
    }

10. Configuring MySQL Database and JSP View Resolver

Configuring a View Resolver

We would have our jsp’s in /WEB-INF/jsp/. We would need to configure the view resolver with the prefix and suffix.

spring.mvc.view.prefix=/WEB-INF/jsp/
    spring.mvc.view.suffix=.jsp

Configuring the MySQL database

Configure application.properties to connect to your MySQL database. Let's open an application.properties file and add following database configuration to it.

spring.mvc.view.prefix: /WEB-INF/jsp/
    spring.mvc.view.suffix: .jsp
    
    logging.level.org.springframework=INFO
    
    ################### DataSource Configuration ##########################
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/users_database
    spring.datasource.username=root
    spring.datasource.password=root
    
    ################### Hibernate Configuration ##########################
    
    spring.jpa.hibernate.ddl-auto=update
    spring.jpa.show-sql=true

11. Insert SQL Script

Once you will run this application will create users table in a database and use below insert SQL script to populate a few records in the users table.

                INSERT INTO `users_database`.`user` (`id`, `name`) VALUES ('1', 'Salman');
                INSERT INTO `users_database`.`user` (`id`, `name`) VALUES ('2', 'SRK');
                INSERT INTO `users_database`.`user` (`id`, `name`) VALUES ('3', 'AMIR');
                INSERT INTO `users_database`.`user` (`id`, `name`) VALUES ('4', 'Tiger');
                INSERT INTO `users_database`.`user` (`id`, `name`) VALUES ('5', 'Prabhas');

12. Create a JSP View - users.jsp

Let's create a users.jsp view to show the list of users. Locate under webapp/WEB-INF/jsp folder.

<!DOCTYPE html>
    <%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
    <html lang="en">
    <head>
    
    <link rel="stylesheet" type="text/css"
     href="webjars/bootstrap/3.3.7/css/bootstrap.min.css" />
    <c:url value="/css/main.css" var="jstlCss" />
    <link href="${jstlCss}" rel="stylesheet" />
    
    </head>
    <body>
     <div class="container">
      <header>
       <h1>Spring MVC + JSP + JPA + Spring Boot 2</h1>
      </header>
      <div class="starter-template">
       <h1>Users List</h1>
       <table
        class="table table-striped table-hover table-condensed table-bordered">
        <tr>
         <th>Id</th>
         <th>Name</th>
        </tr>
        <c:forEach var="user" items="${users}">
         <tr>
          <td>${user.id}</td>
          <td>${user.name}</td>
         </tr>
        </c:forEach>
       </table>
      </div>
    
     </div>
    
     <script type="text/javascript"
      src="webjars/bootstrap/3.3.7/js/bootstrap.min.js"></script>
    </body>
    
    </html>
        

13. Running the Application

Now run Springboot2WebappJspApplication.java as a Java application.

http://localhost:8080/users hit this URL in a browser. You will see below HTML page on the screen: