{"id":75907,"date":"2018-04-17T01:00:15","date_gmt":"2018-04-16T22:00:15","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=75907"},"modified":"2023-12-11T10:49:03","modified_gmt":"2023-12-11T08:49:03","slug":"spring-mvc-tutorial-2","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/04\/spring-mvc-tutorial-2.html","title":{"rendered":"Spring MVC Tutorial"},"content":{"rendered":"

1. Introduction<\/h2>\n

As an Enterprise Java<\/a> Developer, one of the main focus in the job is developing web applications. With a web application, many challenges also come into the picture as consequences. To be specific, some of these are state management, workflow and validations. The HTTP protocol’s stateless nature only make things more complex. The Spring’s web framework is designed to help us in these challenges. Based on the Model-View-Controller (MVC) pattern, Spring MVC helps us to build applications which are very loosely coupled and flexible, even after we take care of all the challenges presented by HTTP protocol and other.<\/p>\n

In this lesson, we will start by understanding the purpose of each of the Spring MVC Component and the role they play in handling request and response objects throughout their life in a Spring application. After this, we will start configuring a simple Spring MVC application, adding a component at each step, writing a very simple Thymeleaf template and finally including a JUnit<\/a> test case for the Controller we write. Let’s get started!<\/p>\n

2. Life of a Request<\/h2>\n

\"Life<\/a>
Life of Request Object<\/figcaption><\/figure><\/p>\n

As soon as a user on the web clicks on a link on an HTML page, work of a request object starts. When a request object leaves the browser and enters into a Spring MVC application which finally transforms into a response object, it makes several stops to provide some information to the MVC Components and get loaded with some new information. The above image shows all the stops the request object makes before it is transformed into a response object.<\/p>\n

Let us understand what all steps do a request object takes in a Spring MVC application:<\/p>\n

    \n
  1. The request first arrives at the DispatcherServlet<\/code> which acts as a Front Controller and delegates responsibility<\/strong> to other components of the framework to do the processing. To identify the Controller where a request should be sent, DispatcherServlet<\/code> consults the Handler Mappings which extract the URL from the request object and finds the appropriate Controller for this request.<\/li>\n
  2. Once a request reaches a Controller, it drops all information it has and patiently waits for Controller to perform his processing. Usually, Controller provides a model and a view name which provides the HTML content for the response.<\/li>\n
  3. To keep things decoupled between a Controller and views, Controller only returns the logical view name as a String to the DispatcherServlet<\/code>. DispatcherServlet <\/code> then consults a View Resolver to map this String logical view name to a specific view implementation which can be a JSP page or an HTML page.<\/li>\n
  4. After DispatcherServlet <\/code>knows which View to render, it finally sends the model data to the actual view so that a response object can be constructed. Now, the life of the request object is over.<\/li>\n
  5. This View is now converted to a response object and sent back to the user where it can be shown in a browser.<\/li>\n<\/ol>\n

    Sounds like all the work was done by request object and the user only sees the response object. That’s true!<\/p>\n

    3. Project Setup<\/h2>\n

    We will be using one of the many Maven archetypes to create a sample project for our example. To create the project execute the following command in a directory that you will use as workspace:<\/p>\n

    Create project<\/em><\/span><\/p>\n

    mvn archetype:generate -DgroupId=com.javacodegeeks.example -DartifactId=JCG-SpringMVC-example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false\n<\/pre>\n
    If you are running maven for the first time, it will take a few seconds to accomplish the generate command because maven has to download all the required plugins and artifacts in order to make the generation task.<\/p>\n
    \"Creating<\/a>
    Creating Project with Maven<\/figcaption><\/figure><\/p>\n
    Once you have created the project, feel free to open it in your favourite IDE. Next step is to add appropriate Maven Dependencies to the project.<\/p>\n
    Here is the pom.xml<\/code> file with the appropriate dependencies:<\/p>\n
    pom.xml<\/em><\/span><\/p>\n
    <project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n  xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/maven-v4_0_0.xsd\">\n  <modelVersion>4.0.0<\/modelVersion>\n\n  <groupId>com.javacodegeeks.example<\/groupId>\n  <artifactId>JCG-SpringMVC-example<\/artifactId>\n  <version>1.0-SNAPSHOT<\/version>\n  <name>JCG-SpringMVC-example<\/name>\n  <packaging>war<\/packaging>\n  <description>Spring MVC Hello World Example<\/description>\n\n  <dependencies>\n\n    <!--Spring MVC Dependencies-->\n    <dependency>\n      <groupId>org.springframework<\/groupId>\n      <artifactId>spring-webmvc<\/artifactId>\n      <version>4.3.9.RELEASE<\/version>\n    <\/dependency>\n    <dependency>\n      <groupId>org.springframework<\/groupId>\n      <artifactId>spring-web<\/artifactId>\n      <version>4.3.9.RELEASE<\/version>\n    <\/dependency>\n\n    <!-- Servlet -->\n    <dependency>\n      <groupId>javax.servlet<\/groupId>\n      <artifactId>servlet-api<\/artifactId>\n      <version>2.5<\/version>\n      <scope>provided<\/scope>\n    <\/dependency>\n    <dependency>\n      <groupId>javax.servlet.jsp<\/groupId>\n      <artifactId>jsp-api<\/artifactId>\n      <version>2.1<\/version>\n      <scope>provided<\/scope>\n    <\/dependency>\n    <dependency>\n      <groupId>javax.servlet<\/groupId>\n      <artifactId>jstl<\/artifactId>\n      <version>1.2<\/version>\n    <\/dependency>\n\n  <\/dependencies>\n\n  <build>\n    <plugins>\n      <plugin>\n        <artifactId>maven-compiler-plugin<\/artifactId>\n        <version>3.6.1<\/version>\n        <configuration>\n          <source>1.8<\/source>\n          <target>1.8<\/target>\n        <\/configuration>\n      <\/plugin>\n      <plugin>\n        <artifactId>maven-war-plugin<\/artifactId>\n        <version>3.0.0<\/version>\n        <configuration>\n          <warSourceDirectory>WebContent<\/warSourceDirectory>\n        <\/configuration>\n      <\/plugin>\n    <\/plugins>\n    <!-- added to remove Version from WAR file -->\n    <finalName>${project.artifactId}<\/finalName>\n  <\/build>\n<\/project>\n<\/pre>\n
    Finally, to understand all the JARs which are added to the project when we added this dependency, we can run a simple Maven command which allows us to see a complete Dependency Tree for a project when we add some dependencies to it. Here is a command which we can use:
     
    <\/div> <\/div><\/p>\n
    Dependency Tree<\/em><\/span><\/p>\n
    mvn dependency:tree\n<\/pre>\n
    When we run this command, it will show us the following Dependency Tree:<\/p>\n
    \"Spring<\/a>
    Spring MVC Project Dependency Tree<\/figcaption><\/figure><\/p>\n
    4. Configuring DispatcherServlet<\/h2>\n
    As we expressed in the last section, everything starts at DispatcherServlet<\/code>. So, this will be the first component we will be adding to our project. Note that instead of a web.xml<\/code> file, we will configuring DispatcherServlet <\/code>in a Java class:<\/p>\n
    AppInitializer.java<\/em><\/span><\/p>\n
    package com.javacodegeeks.example.config;\n\nimport org.springframework.web.servlet.support.\n        AbstractAnnotationConfigDispatcherServletInitializer;\n\npublic class AppInitializer extends\n        AbstractAnnotationConfigDispatcherServletInitializer {\n\n    @Override\n    protected Class<?>[] getRootConfigClasses() {\n        return new Class[] { RootConfig.class };\n    }\n\n    @Override\n    protected Class<?>[] getServletConfigClasses() {\n        return new Class[] { WebConfig.class };\n    }\n\n    @Override\n    protected String[] getServletMappings() {\n        return new String[] { \"\/\" };\n    }\n}\n<\/pre>\n
    The first thing to notice here is that any class which extends AbstractAnnotationConfigDispatcherServletInitializer<\/code> will be used to configure the DispatcherServlet <\/code>and the application context.<\/p>\n
    The method getServletMappings()<\/code> identifies the path where the DispatcherServlet<\/code> will be mapped to. Here, as we provided a \/<\/code>, it will be the application’s default servlet. When the DispatcherServlet <\/code>starts up, it creates Spring application context and starts loading it with beans declared in the WebConfig<\/code> class which is defined by the getServletConfigClasses()<\/code> method. Finally, the classes returned by getRootConfigClasses()<\/code> method is used to load the context created by ContextLoaderlistener<\/code>.<\/p>\n
    Let’s define the WebConfig<\/code> and RootConfig<\/code> classes now and see what their functions are.<\/p>\n
    5. Enabling Web MVC<\/h2>\n
    One of the classic ways to enable Spring MVC Components is to use XML files with <\/code> elements. But in this lesson, we will show the latest way to provide all configuration using Java classes only. Let us enable Spring MVC Components by defining our WebConfig<\/code> class:<\/p>\n
    WebConfig.java<\/em><\/span><\/p>\n
    package com.javacodegeeks.example.config;\n\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.web.servlet.ViewResolver;\nimport org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;\nimport org.springframework.web.servlet.config.annotation.EnableWebMvc;\nimport org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;\nimport org.springframework.web.servlet.view.InternalResourceViewResolver;\n\n@Configuration\n@EnableWebMvc\n@ComponentScan(\"com.javacodegeeks.example\")\npublic class WebConfig extends WebMvcConfigurerAdapter {\n    \n    @Bean\n    public ViewResolver viewResolver() {\n        InternalResourceViewResolver viewResolver = \n                new InternalResourceViewResolver();\n        viewResolver.setPrefix(\"\/WEB-INF\/views\/\");\n        viewResolver.setSuffix(\".jsp\");\n        viewResolver.setExposeContextBeansAsAttributes(true);\n        return viewResolver;\n    }\n\n    @Override\n    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {\n        configurer.enable();\n    }\n}\n<\/pre>\n
    A lot of things happened in this configuration class. Let’s understand each of those things:<\/p>\n