Development Steps for Spring MVC Hibernate Integration and Porting to Spring Boot

Initial Setup: Spring MVC Hibernate Template

1. Copy and Import Template:

   • Import the spring_mvc_hibernate template project.

2. Configure Spring’s Front Controller (DispatcherServlet):

   • Purpose: Ensures all client requests are intercepted by a centralized dispatcher.

   • Class: org.springframework.web.servlet.DispatcherServlet (D.S) – the entry point.

   • Lifecycle Management: Handled by the Web Container (WC).

   • Configuration in web.xml:

     <servlet>
         <servlet-name>spring</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
         <servlet-name>spring</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
     
     

3. Web Application Startup:

   • The Web Container starts the lifecycle of the DispatcherServlet (D.S).
   • In the init() method of D.S:
     • Starts the Spring Container (SC) by creating an instance of WebApplicationContext.
     • Uses a default XML configuration file:
       • Name: servletName-servlet.xml (e.g., spring-servlet.xml).
       • Location: WEB-INF.
       • Contents: Instructions for starting the Spring Container.
     • SC creates:
       • HandlerMapping Bean: Initially empty, used to map requests to handlers.
       • ViewResolver Bean:
         • Configured with three properties:
           • prefix: /WEB-INF/views/
           • suffix: .jsp
           • viewClass: JSTLView (to enable JSTL actions in JSP).

4. Create Request-Handling Controller (Handler):

   • Purpose: Contains presentation logic (P.L).
   • Type: Programmer-supplied Spring bean (singleton and eager).
   • Mandatory Annotations:

     • @Controller: Class-level annotation.

     • @RequestMapping: Method-level annotation (mandatory) to map HTTP requests (GET, POST, PUT, DELETE, PATCH, etc.).

       • Optionally used at the class level to specify a base URL pattern.

     • Method-Level Annotations:

       @RequestMapping
       // OR
       @GetMapping // Equivalent to doGet
       // OR
       @PostMapping // Equivalent to doPost
       
       

5. Create JSP-Based View Layer:

   • Example: Create index.jsp.
   • Location: WEB-INF/views.

6. Test the Flow:

   • Client Request:

     <http://host>:port/ctx_path/
     
     

     • Flow: D.S → HandlerMapping → HandlerName + MethodName → D.S invokes method → Returns Logical View Name (LVN) → D.S → ViewResolver (V.R) → Actual View Name (AVN) → D.S checks for model attributes (none) → Forwards to view layer (index.jsp).

   • After Clicking a Link in index.jsp:

     <h5>
         <a href="test/test1">Test ModelAndView</a>
     </h5>
     
     

     • URL: http://host:port/ctx_path/test/test1
     • Flow: D.S → HandlerMapping → TestController.testModelAndView → D.S invokes the method.

Model Attributes

• Definition: Server-side key-value pairs created by the handler to share data between the handler and the view layer (JSP).
• Storage: Saved under request scope.

Ways to Add Model Attributes

1. Using ModelAndView Class:

   • Purpose: Holds the Logical View Name (LVN) and model attributes.

   • Constructor:

     public ModelAndView(String LVN, String modelAttributeName, Object modelValue)
     
     

   • Flow:

     • Handler creates and returns a ModelAndView object to D.S.

     • D.S extracts LVN → V.R resolves to AVN.

     • D.S checks for model attributes (if present) → SC adds them to request scope.

     • Forwards to JSP.

     • Access in JSP:

       ${requestScope.attrName}
       
       

2. Using org.springframework.ui.Model Interface:

   • Purpose: Acts as a holder for model attributes.

   • Setup: Add Model as a method argument in the request-handling method.

     • Spring Container (SC) provides an empty Model map via Dependency Injection (IoC).

   • Programmer’s Task: Add model attributes using:

     public Model addAttribute(String attrName, Object attrValue);
     
     

   • Flow:

     • Handler explicitly returns the LVN to D.S.
     • SC implicitly returns the model map to D.S.
     • D.S sends LVN to V.R → Resolves to AVN.
     • SC adds model attributes to request scope.
     • Forwards to the view layer.

Spring MVC Hibernate Integration

Objective: List all available restaurants.

Configuration Steps