It has come to use MVC pattern, so I create first controller. It is very simple HomeController and it is manage the view component, in this cas the home.jsp page.
To take an incoming URI and find the right combination of handlers (generally methods on Controller classes) and views (generally JSPs) that combine to form the page or resource I must create the dispatcher-servlet.xml file.
The way how dispatcher-servlet works looks at the picture below:
So, the The dispatcher servlet is the bit that "knows" to call that method when a browser requests the page, and to combine its results with the matching JSP file to make an html document.
Without create dispatcher-servlet.ml I must configure in the application the web.xml file. In the web.xml file there are defines everything about the application that a server needs to know. It is placed in the /WEB-INF/ directory of the application. The <servlet> element declares the DispatcherServlet. When the DispatcherServlet is initialized, the framework try to load the application context from a file named applicationContext.xml located in /WEB-INF/conf directory. So, I've created the dispatcher-servlet.xml and the <servlet-mapping> lement in
for now web.xml file looks:
The dispatcher-servlet.xml file is placed in /WEB-INF/ directory. This is the file where all beans created, such as Controllers, will be placed and defined. So, the HomeController, that is the controller in application is defined here, and will be shown in next steps. The
My dispatcher-servlet.xml file looks:
The
Finally create HomeContoller and home.jsp page. My first controller is very easy and display "Hello world" on the page and looks:
Annotation @RequestMapping is one of the most widely usedby Spring MVC annotation and is using for mapping web requests onto specific handler classes and/or handler methods. In above method /home is the URI for which this controller will be used.This concept is very similar to servlet context of a web application.
aaaa
To take an incoming URI and find the right combination of handlers (generally methods on Controller classes) and views (generally JSPs) that combine to form the page or resource I must create the dispatcher-servlet.xml file.
The way how dispatcher-servlet works looks at the picture below:
So, the The dispatcher servlet is the bit that "knows" to call that method when a browser requests the page, and to combine its results with the matching JSP file to make an html document.
Without create dispatcher-servlet.ml I must configure in the application the web.xml file. In the web.xml file there are defines everything about the application that a server needs to know. It is placed in the /WEB-INF/ directory of the application. The <servlet> element declares the DispatcherServlet. When the DispatcherServlet is initialized, the framework try to load the application context from a file named applicationContext.xml located in /WEB-INF/conf directory. So, I've created the dispatcher-servlet.xml and the <servlet-mapping> lement in
web.xml file, which specifies what URLs will be handled by the DispatcherServlet.for now web.xml file looks:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>PizzaDeliverySystem</display-name>
<welcome-file-list>
<welcome-file>home.htm</welcome-file>
</welcome-file-list>
<context-param>
<param-name>contextConfigLocation</param-name>
<!-- <param-value> /WEB-INF/conf/applicationContext.xml</param-value> -->
<param-value>/WEB-INF/security-context.xml</param-value>
</context-param>
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>/WEB-INF/conf/log4j.xml</param-value>
</context-param>
<!-- <context-param> -->
<!-- <param-name>spring.profiles.active</param-name> -->
<!-- <param-value>dev</param-value> -->
<!-- </context-param> -->
<!-- <context-param> -->
<!-- <param-name>spring.profiles.default</param-name> -->
<!-- <param-value>dev</param-value> -->
<!-- </context-param> -->
<context-param>
<param-name>spring.liveBeansView.mbeanDomain</param-name>
<param-value>dev</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- <listener> -->
<!-- org.springframework.web.context.request.RequestContextListener -->
<!-- </listener> -->
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<!-- The definition of the Root Spring Container shared by all Servlets
and Filters -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/dispatcher-servlet.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app> The dispatcher-servlet.xml file is placed in /WEB-INF/ directory. This is the file where all beans created, such as Controllers, will be placed and defined. So, the HomeController, that is the controller in application is defined here, and will be shown in next steps. The
<context:component-scan> tag is used so that the container will know where to search for the classes.My dispatcher-servlet.xml file looks:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:c="http://www.springframework.org/schema/c"
xmlns:security="http://www.springframework.org/schema/security"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.1.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
<context:annotation-config />
<!-- Scan for annotations... -->
<context:component-scan base-package="com.pizza.delivery"></context:component-scan>
<!-- Configures the @Controller programming model -->
<mvc:annotation-driven />
<jpa:repositories base-package="com.pizza.delivery" />
</bean>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/views/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans> The
InternalResourceViewResolver maps the jsp and html files in the ?WEB-INF/ folder and it allows to set properties such as perefix or suffixto the view name to generate the final view page URL.Finally create HomeContoller and home.jsp page. My first controller is very easy and display "Hello world" on the page and looks:
package com.pizza.delivery.controllers;
//import javax.servlet.http.HttpServletRequest;
//import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HomeController {
@RequestMapping(value="/home", method = RequestMethod.GET)
public String home(ModelAndView model) {
String message = "Hello World, Spring 3.0!";
model.addObject("message", message);
return "home";
}
} Annotation @RequestMapping is one of the most widely usedby Spring MVC annotation and is using for mapping web requests onto specific handler classes and/or handler methods. In above method /home is the URI for which this controller will be used.This concept is very similar to servlet context of a web application.
aaaa
