Spring Boot 2 Web Application JSP JPA Hibernate 5 MySQL Example - RameshMF/spring-boot-developers-guide GitHub Wiki

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

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

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+
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: springboot2webappjsp
Name: springboot2webappjsp
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

diagram here

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

pom.xml
resources
Springboot2WebappJspApplication.java
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>

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);
	}
}

@SpringBootApplication is a convenience annotation that adds all of the following:

@Configuration tags the class as a source of bean definitions for the application context.
@EnableAutoConfiguration tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings.
Normally you would add @EnableWebMvc for a Spring MVC app, but Spring Boot adds it automatically when it sees spring-web MVC on the classpath. This flags the application as a web application and activates key behaviors such as setting up a DispatcherServlet.
@ComponentScan tells Spring to look for other components, configurations, and services in the hello package, allowing it to find the controllers.

The main() method uses Spring Boot’s SpringApplication.run() method to launch an application. Did you notice that there wasn’t a single line of XML? No web.xml file either. This web application is 100% pure Java and you didn’t have to deal with configuring any plumbing or infrastructure.

7. Create a JPA Entity called 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<User, Integer>
{

}

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

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 user table in database and use below insert SQL script to populate few records in user 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 should see the list of users in a table format.

diagram here

Spring Boot 2 Web Application JSP JPA Hibernate 5 MySQL Example - RameshMF/spring-boot-developers-guide GitHub Wiki

Table of Contents

1. What we’ll build

2. Tools and Technologies Used

3. Creating and Importing a Project

4. Packaging Structure

5. The pom.xml File

6. The Springboot2WebappJspApplication.java File

7. Create a JPA Entity called User.java

8. Create Spring Data JPA Repository - UserRepository.java

9. Create Spring Controller - UserController.java

10. Configuring MySQL Database and JSP View Resolver

11. Insert SQL Script

12. Create a JSP View - users.jsp

13. Running the Application

⚠️ GitHub.com Fallback ⚠️

Spring Boot 2 Web Application JSP JPA Hibernate 5 MySQL Example - RameshMF/spring-boot-developers-guide GitHub Wiki

Table of Contents

1. What we’ll build

2. Tools and Technologies Used

3. Creating and Importing a Project

4. Packaging Structure

5. The pom.xml File

6. The Springboot2WebappJspApplication.java File

7. Create a JPA Entity called User.java

8. Create Spring Data JPA Repository - UserRepository.java

9. Create Spring Controller - UserController.java

10. Configuring MySQL Database and JSP View Resolver

11. Insert SQL Script

12. Create a JSP View - users.jsp

13. Running the Application

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️