Spring MVC

Agenda

• Spring MVC overview

• Creating controllers

• Rendering frontend

• Spring Boot MVC

Spring MVC overview
 Spring MVC

• Spring MVC is web development framework built on top

of the Spring core DI framework

• MVC stands for “model-view-controller” and is an

architectural pattern implemented by a number of so
called web “MVC” frameworks
 Spring MVC architecture

Service

request Front controller Controller

Browser
(DispatcherServlet)
response

Renders calls
HTML (using model)
Model

View
template
 Spring MVC dependencies

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
 Spring MVC configuration

• To configure Spring MVC in a Spring application it is

sufficient to add the @EnableWebMvc annotation on a
@Configuration class
@Configuration
@EnableWebMvc
public class AppConfig {
…
}
 Spring MVC controllers

• A Spring MVC controller is a Spring bean annotated with

the @Controller or @RestController annotations
@Controller
public class AppController {

@RequestMapping(value = "/home")
public String home() {
return "index.jsp";
}
}
Creating controllers
 Mapping annotations

• Mapping of a controller method to an HTTP endpoint can

be done with the @RequestMapping annotations

• It can be applied on the controller class or a controller

method (or both)

• Convenience annotations can be used on the method

level such as @GetMapping, @PostMapping,
@PutMapping, @DeleteMapping, and @PatchMapping
 Method parameters

• Controller method parameters can be bound to different

parts of the HTTP request:

– @RequestParam: for mapping an argument to an HTTP request

parameter
– @RequestHeader: for mapping an argument to an HTTP request
header
– @RequestBody: for mapping an argument to the HTTP request body
– @CookieValue: for mapping an argument to an HTTP cookie value
– @PathParam: for mapping an argument to a URL path value
– HttpEntity: for access to request headers and body
 Handling request parameters

@Controller
public class AppController {

@GetMapping(value = "/home")
public String home(@RequestParam String page) {
…
return "index.jsp";
}
}

e.g. localhost:8080/home?page=3
 Handling path parameters

@Controller
public class AppController {

@GetMapping(value = "/home/{page}")
public String home(@PathParam String page) {
…
return "index.jsp";
}
}

e.g. localhost:8080/home/3
 Handling headers

@Controller
public class AppController {

@GetMapping(value = "/home/{page}")
public String home(@PathParam String page,
@RequestHeader(“Accept-Encoding") String encoding ) {
…
return "index.jsp";
}
}
 Handling cookies
@Controller
public class AppController {

@GetMapping(value = "/home/{page}")
public String home(@PathParam String page,
@CookieValue("language") String lang) {
…
return "index.jsp";
}
}
 Handling HTTP body

@Controller
public class AppController {

@GetMapping(value = "/home/{page}")
public String home(@PathParam String page,
@RequestBody Entity entity) {
…
return "index.jsp";
}
}
 Handling exceptions

• Exceptions are handled in Spring MVC by means of

HandlerExceptionResolver beans

• A few different implementations are provided by Spring

framework such as:

– SimpleMappingExceptionResolver
– DefaultHandlerExceptionResolver
– ResponseStatusExceptionResolver
– ExceptionHandlerExceptionResolver
 Handling exceptions

• The most common strategy used by application is

provided by the ExceptionHandlerExceptionResolver:

– local: @Controller classes have one or more methods annotated

with @ExceptionHandler

– global (apply for all controllers): a class annotated with

@ControllerAdvice with one or more @ExceptionHandler
methods
 Validation

• Bean validation supported by Spring DI framework can be

used in the same manner in Spring MVC applications

• Entity classes are either marked with @Validated or

controller method parameters with @Valid

• Bean validation annotations are used

 Interceptors

• Interceptors can be registered in order to pre-process

incoming requests
@Configuration
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer
{
@Override
public void addInterceptors(InterceptorRegistry
registry) {
registry.addInterceptor(…);
registry.addInterceptor(…);
}
 Rendering response

• The response can be rendered as follows:

– Using the @ResponseBody annotation and a defined

HttpMessageConverter bean used to convert the response to a proper
format

– A String that indicates the view template to render

Rendering frontend
 Rendering frontend

• The result of controller methods can be interpreted by

Spring MVC framework in any of the following ways:

– by marshalling a Java bean in a proper representation (XML, JSON) or

returning a ResponseEntity instance (as already discussed)

– by rendering a proper frontend page that is returned using a proper

ViewResolver for the target template being used
 Configuring a view resolver
• In order to render a template a view resolver needs to be
explicitly configured

• For example to configure a Thymeleaf view resolver:

@Controller
public class WebMvcConfig {

@Bean
public ThymeleafViewResolver viewResolver() {
final ThymeleafViewResolver resolver =
new ThymeleafViewResolver();
…
return resolver;
}
}
 Configuring a view resolver
@Bean
public ThymeleafViewResolver viewResolver() {

ThymeleafViewResolver viewResolver =
new ThymeleafViewResolver();
SpringResourceTemplateResolver templateResolver =
new SpringResourceTemplateResolver();

templateResolver.setPrefix("classpath:/views");
templateResolver.setSuffix(".html");

SpringTemplateEngine templateEngine =
new SpringTemplateEngine();
templateEngine.setTemplateResolver(
templateResolver);
viewResolver.setTemplateEngine(templateEngine);
return viewResolver;
}
 Template engines

• Spring MVC supports the following templating engines

(among others) for rendering of frontend:

– Thymeleaf
– Velocity
– Freemarker
– Mustache
 Passing the model

• The model can be modified before passed to the view as

follows:

– passing a Model argument to the controller method

– passing a ModelMap argument to the controller method
– passing a ModelAndView argument to the controller method and
returning it
Spring Boot MVC
 Spring Boot MVC
• Spring simplifies configuration of Spring MVC
applications

• For example:

– adding spring-boot-starter-thymeleaf as a dependency to the builds

automatically configures Thymeleaf as a template engine

– Adding spring-boot-starter-json as a dependency to the build

automatically configures Jackson for marshaling/unmarshalling of
Spring MVC data to/from JSON
 Spring Boot MVC
• Spring Boot configuration can be provided by creating
proper beans (provided by Spring Boot classes) in a
@Configuration class with using @EnableWebMvc
annotation
@Configuration
public class MvcConfiguration {

@Bean
public HttpMessageConverters customConverters() {
HttpMessageConverter<?> first = ...
HttpMessageConverter<?> second = ...
return new HttpMessageConverters(first, second);
}
}

Default converters for JSON and XML and provided by Spring Boot
 Static content

• Spring Boot by default serves static content from the

following directories on the classpath:

– /static
– /public
– /resources
– /META-INF/resources)

Static resources can be controlled with the spring.mvc.static-path-pattern property:

i.e. spring.mvc.static-path-pattern=/resources/*.jpg
 View templates

• Spring Boot serves view templates from the

src/main/resources/templates directory

• Provides autoconfiguration for the following template

engines:

– Thymeleaf
– FreeMaker
– Groovy
– Mustache
 Error handling

• By default Spring Boot provides an /error mapping that

handles application errors

• Error handling response can be customized

• Error pages can also be placed in the /error directory and

must be named with HTTP error code
src/main/resources/public/error/404.html
Questions ?