Learn to create and configure JSP view resolver in Spring Boot 3 application which uses JSP template files to render the view layer. Also, learn to build and deploy the application and serve static content in the JSP files.
1. Project Structure
For reference, the files in this application are placed as the given structure in the image.
2. Maven
To sever an application using JSP, we need the following dependencies. Note that we are using the Jakarta Servlet API which uses the Jakarta namespace required by Spring Boot 3.
- spring-boot-starter-web
- tomcat-embed-jasper
- jakarta.servlet.jsp.jstl-api
- jakarta.servlet.jsp.jstl
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jakarta.servlet.jsp.jstl</groupId>
<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>jakarta.servlet.jsp.jstl</artifactId>
<version>3.0.1</version>
</dependency>Additionally, we must use the war packaging as jar packaging is not supported as discussed in the official documentation.
<packaging>war</packaging>3. Application Setup
3.1. Extend SpringBootServletInitializer in the Application Class
The first step in producing a deployable war file is to provide a SpringBootServletInitializer subclass and override its configure() method. This makes use of Spring Framework’s Servlet 3.0 support and allows you to configure the application when it is launched by the Servlet container.
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 App extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(App.class);
}
public static void main(String[] args) {
SpringApplication.run(App.class);
}
}3.2. Web Controller
The controller class is a regular @Controller class with request mapping annotations. Please note that we should not use the @RestController annotation, by mistake.
@Controller
public class ItemController {
@Autowired
ItemService itemService;
@RequestMapping("/view-items")
public ModelAndView viewBooks(ModelAndView model) {
model.setViewName("view-items");
model.addObject("items", itemService.getAll());
return model;
}
}3.3. Model and Service
For reference, we are using a simple POJO Item as model and ItemService for returning a list of items. The service returns two items. In a real application, it will connect to the database and fetch the details from the database or any other source.
@Service
public class ItemService {
public List<Item> getAll() {
return List.of(new Item(1L, "Item - 1"), new Item(2L, "Item - 2"));
}
}@Data
@AllArgsConstructor
@NoArgsConstructor
public class Item {
private Long id;
private String name;
}4. Setting up JSP View Resolver
To resolve JSP files location and automatically configure the JSP view resolver, we can have two approaches:
4.1. Using application.properties
The following properties automatically configure the Spring MVC to serve the content from the configured location and register the JstlView class. It is a specialization of InternalResourceView for JSTL pages, i.e. JSP pages.
Once registered, every view name returned from a handler will be translated to a JSP resource (for example: “home” → “/WEB-INF/jsp/home.jsp“), using this view class to enable explicit JSTL support.
spring.mvc.view.prefix=/WEB-INF/view/
spring.mvc.view.suffix=.jsp4.2. Using Java Configuration
We can configure the JSP view resolution in the Java configuration also, as follows. Do not forget to use the @EnableWebMvc which configures the other necessary beans to support a MVC application.
@Configuration
@EnableWebMvc
public class WebMvcConfig implements WebMvcConfigurer {
@Bean
public ViewResolver viewResolver() {
final InternalResourceViewResolver bean = new InternalResourceViewResolver();
bean.setViewClass(JstlView.class);
bean.setPrefix("/WEB-INF/jsp/");
bean.setSuffix(".jsp");
return bean;
}
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
registry.viewResolver(viewResolver());
}
}4.3. Serving Static Content
By default, Spring MVC serves the static files (JS, CSS etc) from the following directories:
- /src/main/resources
- /src/main/resources/static
We can configure the custom URI and directory location as follows. The following configuration will serve a file http://localhost:8080/static/css/style.css from the location /src/main/resources/static/css/style.css.
@Configuration
@EnableWebMvc
public class WebMvcConfig implements WebMvcConfigurer {
//...
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry
.addResourceHandler("/static/**")
.addResourceLocations("classpath:/static/")
.setCachePeriod(3600)
.resourceChain(true)
.addResolver(new PathResourceResolver());
}
}
5. JSP Files
The JSP files can be placed in /webapp/WEB-INF/jsp directory as /WEB-INF/jsp path has been configured with the view resolver. Add the webapp directory as the resources root so its content is copied to the root directory when building the project.
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
<title>View Items</title>
<link href="/static/css/style.css" rel="stylesheet">
</head>
<body>
<table>
<thead>
<tr>
<th>Id</th>
<th>Name</th>
</tr>
</thead>
<tbody>
<c:forEach items="${items}" var="item">
<tr>
<td>${item.id}</td>
<td>${item.name}</td>
</tr>
</c:forEach>
</tbody>
</table>
</body>
</html>6. Package and Run the Application
After the code has been created, we can package the application from the terminal:
mvc clean installIt will create a war file in the target directory. We can run the war file in two ways:
- Using the
java -jarcommand from the terminal. - Deploying in the Tomcat application server.
To run the application from the terminal, run the following command:
java -jar .\target\jsp-demo-1.0-SNAPSHOT.warIt will start the embedded Tomcat server and deploy the application with it.
7. Demo
After the application has been deployed, we can access a valid application URL in the browser and the JSP page will be rendered in the browser.
8. FAQs
8.1. Views are not resolved with 404 Error
In most cases, this error indicates that you are trying to run the application as embedded jar deployment or you are not using the java-jar command to run the application.
To fix this issue, you must run the application with java-jar command or deploy it inside a Tomcat server.
java -jar .\target\jsp-demo-1.0-SNAPSHOT.war8.2. ClassNotFoundException: jakarta.servlet.jsp.jstl.core.Config
This error indicates that you are still using the javax.servlet:jstl dependency. With the latest Spring Boot release, we must use the Jakarta namespaces so add the following dependency.
<!-- Remove javax packages -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Add jakarta packages -->
<dependency>
<groupId>jakarta.servlet.jsp.jstl</groupId>
<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>jakarta.servlet.jsp.jstl</artifactId>
<version>3.0.1</version>
</dependency>9. Conclusion
In this Spring Boot JSP example, we learned to serve the JSP pages in a Spring boot 3 application, configure the view resolution, and serve static content with a demo. We also learned to fix some common mistakes that developers make when serving the JSP page.
Happy Learning !!
Comments