springmvc基础 – 怀旧家

springmvc基础-springmvc与struts2的比较

①. Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter •
②. Spring MVC 会稍微比 Struts2 快些. Spring MVC 是基 •
于方法设计, 而 Sturts2 是基于类, 每次发一次请求都会实
例一个 Action.
③. Spring MVC 使用更加简洁, 开发效率Spring MVC确实 •
比 struts2 高: 支持 JSR303, 处理 ajax 的请求更方便
④. Struts2 的 • OGNL 表达式使页面的开发效率相比
Spring MVC 更高些.

springmvc基础-springmvc与spring的整合与关系

<!--  
	需要进行 Spring 整合 SpringMVC 吗 ?
	还是否需要再加入 Spring 的 IOC 容器 ?
	是否需要再 web.xml 文件中配置启动 Spring IOC 容器的 ContextLoaderListener ?
		
	1. 需要: 通常情况下, 类似于数据源, 事务, 整合其他框架都是放在 Spring 的配置文件中(而不是放在 SpringMVC 的配置文件中).
	实际上放入 Spring 配置文件对应的 IOC 容器中的还有 Service 和 Dao. 
	2. 不需要: 都放在 SpringMVC 的配置文件中. 也可以分多个 Spring 的配置文件, 然后使用 import 节点导入其他的配置文件
-->
	
<!--  
	问题: 若 Spring 的 IOC 容器和 SpringMVC 的 IOC 容器扫描的包有重合的部分, 就会导致有的 bean 会被创建 2 次.
	解决:
	1. 使 Spring 的 IOC 容器扫描的包和 SpringMVC 的 IOC 容器扫描的包没有重合的部分. 
	2. 使用 exclude-filter 和 include-filter 子节点来规定只能扫描的注解
-->
	
<!--  
	SpringMVC 的 IOC 容器中的 bean 可以来引用 Spring IOC 容器中的 bean. 
	返回来呢 ? 反之则不行. Spring IOC 容器中的 bean 却不能来引用 SpringMVC IOC 容器中的 bean!
-->

一、springmvc与spring的整合举例：

1、配置 web.xml ，配置了两个容器。

<?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_2_5.xsd" id="WebApp_ID" version="2.5">
  
  	<!-- 配置启动 Spring IOC 容器的 Listener -->
	<!-- needed for ContextLoaderListener -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:springioc.xml</param-value>
	</context-param>

	<!-- Bootstraps the root web application context before servlet initialization -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
  
  
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

2、配置父容器 springioc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:component-scan base-package="com.test.springmvc">
		<context:exclude-filter type="annotation" 
			expression="org.springframework.stereotype.Controller"/>
		<context:exclude-filter type="annotation" 
			expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
	</context:component-scan>

	<!-- 配置数据源, 整合其他框架, 事务等. -->

</beans>

3、配置springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

	<!-- 配置自动扫描的包 -->
	<context:component-scan base-package="com.test.springmvc" use-default-filters="false">
		<context:include-filter type="annotation" 
			expression="org.springframework.stereotype.Controller"/>
		<context:include-filter type="annotation" 
			expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
	</context:component-scan>
	
	<!-- 配置视图解析器 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>


</beans>

4、编辑服务器：

package com.test.springmvc.handlers;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

//	//因为父容器 配置文件 规定了 不扫描handler 所以，helloWorld无法注入
//	@Autowired
//	private HelloWorld helloWorld;
	
	public UserService() {
		System.out.println("UserService Constructor...");
	}
	
}

5、编辑控制器：

package com.test.springmvc.handlers;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller // spring里面 又名handler 处理器
public class HelloWorld {

	/**
	 * 1、使用RequestMapping 注解来映射 请求的url
	 * 2、返回值会通过视图解析器解析为实际的物理视图，
	 * 对于org.springframework.web.servlet.view.InternalResourceViewResolver
	 * 会做如下解析，prefix + returnVal + suffix 得到实际的物理视图。然后做转发操作。
	 * 即 WEB-INF/views/success.jsp
 	 */

	@Autowired
	private UserService userService;
	
	public HelloWorld() {
		System.out.println("HelloWorld Constructor...");
	}
	
	@RequestMapping("/helloworld")
	public String hello( HttpServletRequest request,HttpServletResponse response){
		System.out.println("hello request" + request.toString());
		System.out.println("hello response" + response.toString());
		
		System.out.println("success");
		System.out.println(userService);
		
		return "success";
		//return "/WEB-INF/views/success.jsp";
     }
	
	
}

二、springmvc与spring容器关系

spring容器是父容器，springmvc是子容器。

子容器（相当于局部变量）可以访问父容器的对象（相当于全局变量）
但是父容器不能访问子容器中的对象。

springmvc基础-运行流程图

备注：

1、
<mvc:default-servlet-handler/>可以解决请求静态资源问题。<mvc:annotation-driven></mvc:annotation-driven>可以保证非静态资源也能请求，当配置了<mvc:default-servlet-handler/>

2、在DispatcherServlet.doDispatch(request, response)中有一个 mappedHandler= getHandler(processedRequest);

mappedHandler 就是 HandlerExecutionChain (里面包含了控制器方法handler和拦截器Interceptors)

HandlerExecutionChain 由 handlerMapping 根据处理器和请求映射而来。

当没有配置1中的<mvc:default-servlet-handler/>和<mvc:annotation-driven>时，handlerMapping 包括：【
BeanNameUrlHandlerMapping
DefaultAnnotationHandlerMapping
】

当有配置1中时：handlerMapping 包括:【
RequestMappingHandlerMapping
SimpleUrlHandlerMapping
BeanNameUrlHandlerMapping
】

3、HandlerAdapter 里面有 MessageConverter

springmvc基础-@ModelAttribute注解详解

@ModelAttribute 三种用法

1、对handler中的方法进行注解:

@ModelAttribute 注解的方法，本质来说：会在其他方法执行前，会首先被调用。用于初始化一些参数。然后其他方法执行时，会先查找这些参数是否已经存在，若不存则创建一个。

参看：springmvc基础-控制器返回值总结

2、对handler内的方法的形参进行注解：

html表单提交的，可以在控制器内生产一个pojo对象。默认情况下：会将该pojo对象的类型的首字母小写作为关键字，将pojo对象值作为参数。放置到request属性中。如果pojo对象前面有@ModelAttribute(value =”XXX”)，则request存储的pojo对象关键字为XXX，不再是该对象的类型的首字母小写。

参看：springmvc基础-请求映射总结

3、在jsp中的使用springmvc 的表单标签问题：

参数页面：

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

<body>

       <!--  
		1. WHY 使用 form 标签呢 ?
		可以更快速的开发出表单页面, 而且可以更方便的进行表单值的回显
		2. 注意:
		可以通过 modelAttribute 属性指定绑定的模型属性,
		若没有指定该属性，则默认从 request 域对象中读取 command 的表单 bean
		如果该属性值也不存在，则会发生错误。
	-->

        <form:form action="emp" method="post" modelAttribute="employee">
		<!-- path标签对应 html表单标签的 name属性值 -->
                LastName:<form:input path="lastName"  />

		<input type="submit" value="submit" />
	</form:form>

       <!-- form:form 标签在springmvc会有回显值，一开始加载页面时，就需要填充表单，
       所以 modelAttribute="employee" 用来标记从 request中的 取出 employee 关键字的 属性值 -->

</body>

编辑处理器：

@RequestMapping(value="/emp", method=RequestMethod.GET)
	public String input(Map<String, Object> map){

	    //主要是每次 访问表单时，springmvc 都会 回显 之前的表单值，因为第一次 没有创建，所以需要默认新建一个
		map.put("employee", new Employee());
		return "input";
	}

springmvc基础-视图与视图解析器详解

一、概述

请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个ModelAndView 对象，它包含了逻辑名和模型对象的视图。

Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是Excel、JFreeChart 等各种表现形式的视图。

对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦。

二、视图含义

视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。
为了实现视图模型和具体实现技术的解耦，Spring 在org.springframework.web.servlet 包中定义了一个高度抽象的 View接口：

视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题

三、常用的视图实现类

四、视图解析器

SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB 上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。
所有的视图解析器都必须实现 ViewResolver 接口：

五、常用的视图解析器实现类

程序员可以选择一种视图解析器或混用多种视图解析器
每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order 越小优先级越高。
SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则将抛出 ServletException 异常

六、自定义视图

大白话总结：1、编辑正常的请求连接提交给控制器。2、控制器处理请求返回视图名。3、视图解析器利用视图名从IOC容器中获取自定义视图。

比如控制器返回”success”，

如果配置用InternalResourceViewResolver解析的视图，肯定有解析器的前缀和后缀，可能最终解析完路径是 /WEB-INF/views/success.jsp
[即实际地址是：网站根目录/WEB-INF/views/success.jsp]
因为如果不想用解析器的前缀和后缀，那么控制器的返回值应该是 WEB-INF/views/success.jsp
补充：控制器返回字符串值 “/WEB-INF/views/success.jsp” 和这个效果一样 “WEB-INF/views/success.jsp”

如果配置用BeanNameViewResolver视图解析器，则会根据视图名去IOC容器里面，获取一个视图。

1、编辑测试页

在测试页面添加超链接

<body>
测试自定义view
<a href="testredirect">testdiyview</a>
</body>

2、编辑控制器

@RequestMapping("/diyview")
public String testdiyview(){
		
	System.out.println("test-diyview");
	//返回值是自定义视图的类名且第一个字母需小写
        return "helloView";
}

3、编辑转发配置页

<!-- 配置视图  BeanNameViewResolver 解析器: 使用视图的名字来解析视图 -->
<!-- 通过 order 属性来定义视图解析器的优先级, order 值越小优先级越高 , 至于InternalResourceViewResolver其优先级是最低的 -->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
    <property name="order" value="100"></property>
</bean>

核心注意：当时在转发配置页中：扫描注解包时，扫描路径是
com.test.springmvc.handlers 所以com.test.springmvc.views 无法扫描到【views包下面有view类，里面有注解】所以正确做法是：

<!-- 对于注解的Handler可以单个配置 实际开发中建议使用组件扫描 -->
<!-- <bean class="com.test.springmvc.handlers.HelloWorld" />  -->
<!-- 可以扫描controller、service、...这里让扫描controller，指定controller的包,但是view的包下面的注解类就扫描不到了，
所以 com.test.springmvc.handlers 改成 com.test.springmvc就行啦，子目录都能扫描得到  -->
<!--下面是 配置扫描  指定目录包 中的 java文件 -->
<context:component-scan base-package="com.test.springmvc"></context:component-scan>

4、创建自定义view

package com.test.springmvc.views;

import java.util.Date;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.View;

//这个@Component注解的意思是  将该view 放到 IOC 容器里面 
@Component
public class HelloView implements View {

	@Override
	public String getContentType() {
		// TODO Auto-generated method stub
		return "text/html";
	}

	@Override
	public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		// TODO Auto-generated method stub
		response.getWriter().print("hello view ,time" + new Date());
	}

}

springmvc基础-控制器返回值总结

关于请求问题：
请求映射到了控制器，如果控制器处理后的返回值是 “success” ，经过解析器转换成 WEB-INF/views/success.jsp 【如果解析器没有前后缀，则控制器的返回值就必须是完整的，也就是带上了前后缀的】
最后的完整路径是：网站根目录/WEB-INF/views/success.jsp
【当然，因为/WEB-INF 文件夹仅对服务器可见，对浏览器隐藏的，所以直接访问网站根目录/WEB-INF/views/success.jsp 是无法访问的】

springmvc的控制器【controller】或者叫Handler，它的返回值是：ModelAndView 类型。之前学习过说返回值可以是map或string。其实到最后，都会内部转化成ModelAndView 类型。

一、基础流程

测试： <a href=”springmvc/testModelAndView”>Test ModelAndView</a>

控制器：

/**
	 * 目标方法的返回值可以是 ModelAndView 类型。 
	 * 其中可以包含视图和模型信息
	 * SpringMVC 会把 ModelAndView 的 model 中数据放入到 request 域对象中. 
	 * @return
	 */
	@RequestMapping("/testModelAndView")
	public ModelAndView testModelAndView(){
		String viewName = SUCCESS;
		ModelAndView modelAndView = new ModelAndView(viewName);
		
		//添加模型数据到 ModelAndView 中.
		modelAndView.addObject("time", new Date());
		
		return modelAndView;
	}

控制器中 ModelAndView 的构造函数名，就是ModelAndView中的view里面的转发页面的名字。

返回页jsp编辑：
time: ${requestScope.time }

二、控制器中的map参数

控制器中的map参数，最后变成了返回值 ModelAndView 中的model。至于ModelAndView 中的view里面包含了返回页的名字。

测试： <a href=”springmvc/testMap”>Test Map</a>

控制器：

      /**
	 * 目标方法可以添加 Map 类型(实际上也可以是 Model 类型或 ModelMap 类型)的参数. 【因为是继承关系，最后都是一样的】
	 * @param map
	 * @return
	 */
	@RequestMapping("/testMap")
	public String testMap(Map<String, Object> map){
		System.out.println(map.getClass().getName()); 
		map.put("names", Arrays.asList("Tom", "Jerry", "Mike"));
		return "success";
	}

返回页jsp编辑：

names: ${requestScope.names }

三、控制器中的@SessionAttributes

@SessionAttributes : 该注解只能放在类的上面. 而不能修饰放方法.

测试：<a href=”springmvc/testSessionAttributes”>Test SessionAttributes</a>

控制器：

@SessionAttributes(value={"user"}, types={String.class})
@RequestMapping("/springmvc")
@Controller
public class SpringMVCTest {

      /**
	 * @SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外(实际上使用的是 value 属性值),
	 * 还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中(实际上使用的是 types 属性值)
	 * 
	 * 注意: 该注解只能放在类的上面. 而不能修饰放方法. 
	 */
	@RequestMapping("/testSessionAttributes")
	public String testSessionAttributes(Map<String, Object> map){
		User user = new User("Tom", "123456", "[email protected]", 15);
		map.put("user", user);
		map.put("school", "atguigu");
		return "success";
	}

}

这个实验表示：加了@SessionAttributes 注解后，map会根据相应的关键字或类型名，额外放置一份数据到session中。原本map放置到request中的信息，仍会保留在request中。

返回值jsp页：

	request user: ${requestScope.user }
	<br><br>
	
	session user: ${sessionScope.user }
	<br><br>
	
	request school: ${requestScope.school }
	<br><br>
	
	session school: ${sessionScope.school }

四、控制器中的@ModelAttribute

这个例子：介绍的是从数据库中读取一段信息，然后修改了一部分，又重新保存到数据库中。
测试页：

<!--  
		模拟修改操作
		1. 原始数据为: 1, Tom, 123456,[email protected],12
		2. 密码不能被修改.
		3. 表单回显, 模拟操作直接在表单填写对应的属性值
	-->
	<form action="springmvc/testModelAttribute" method="Post">
		<input type="hidden" name="id" value="1"/>
		username: <input type="text" name="username" value="Tom"/>
		<br>
		email: <input type="text" name="email" value="[email protected]"/>
		<br>
		age: <input type="text" name="age" value="12"/>
		<br>
		<input type="submit" value="Submit"/>
	</form>

控制器：

       /**
	 * 1. 有 @ModelAttribute 标记的方法, 会在每个目标方法执行之前被 SpringMVC 调用! 
	 * 2. @ModelAttribute 注解也可以来修饰目标方法 POJO 类型的入参, 其 value 属性值有如下的作用:
	 * 1). SpringMVC 会使用 value 属性值在 implicitModel 中查找对应的对象, 若存在则会直接传入到目标方法的入参中.
	 * 2). SpringMVC 会一 value 为 key, POJO 类型的对象为 value, 存入到 request 中. 
	 */
	@ModelAttribute
	public void getUser(@RequestParam(value="id",required=false) Integer id, 
			Map<String, Object> map){
		System.out.println("modelAttribute method");
		if(id != null){
			//模拟从数据库中获取对象
			User user = new User(1, "Tom", "123456", "[email protected]", 12);
			System.out.println("从数据库中获取一个对象: " + user);
			
			map.put("user", user);
		}
	}
	
	/**
	 * 运行流程:
	 * 1. 执行 @ModelAttribute 注解修饰的方法: 从数据库中取出对象, 把对象放入到了 Map 中. 键为: user
	 * 2. SpringMVC 从 Map 中取出 User 对象, 并把表单的请求参数赋给该 User 对象的对应属性.
	 * 3. SpringMVC 把上述对象传入目标方法的参数. 
	 * 
	 * 注意: 在 @ModelAttribute 修饰的方法中, 放入到 Map 时的键需要和目标方法入参类型的第一个字母小写的字符串一致!
	 * 
	 * SpringMVC 确定目标方法 POJO 类型入参的过程
	 * 1. 确定一个 key:
	 * 1). 若目标方法的 POJO 类型的参数木有使用 @ModelAttribute 作为修饰, 则 key 为 POJO 类名第一个字母的小写
	 * 2). 若使用了  @ModelAttribute 来修饰, 则 key 为 @ModelAttribute 注解的 value 属性值. 
	 * 2. 在 implicitModel 中查找 key 对应的对象, 若存在, 则作为入参传入
	 * 1). 若在 @ModelAttribute 标记的方法中在 Map 中保存过, 且 key 和 1 确定的 key 一致, 则会获取到. 
	 * 3. 若 implicitModel 中不存在 key 对应的对象, 则检查当前的 Handler 是否使用 @SessionAttributes 注解修饰, 
	 * 若使用了该注解, 且 @SessionAttributes 注解的 value 属性值中包含了 key, 则会从 HttpSession 中来获取 key 所
	 * 对应的 value 值, 若存在则直接传入到目标方法的入参中. 若不存在则将抛出异常. 
	 * 4. 若 Handler 没有标识 @SessionAttributes 注解或 @SessionAttributes 注解的 value 值中不包含 key, 则
	 * 会通过反射来创建 POJO 类型的参数, 传入为目标方法的参数
	 * 5. SpringMVC 会把 key 和 POJO 类型的对象保存到 implicitModel 中, 进而会保存到 request 中. 
	 * 
	 * 源代码分析的流程
	 * 1. 调用 @ModelAttribute 注解修饰的方法. 实际上把 @ModelAttribute 方法中 Map 中的数据放在了 implicitModel 中.
	 * 2. 解析请求处理器的目标参数, 实际上该目标参数来自于 WebDataBinder 对象的 target 属性
	 * 1). 创建 WebDataBinder 对象:
	 * ①. 确定 objectName 属性: 若传入的 attrName 属性值为 "", 则 objectName 为类名第一个字母小写. 
	 * *注意: attrName. 若目标方法的 POJO 属性使用了 @ModelAttribute 来修饰, 则 attrName 值即为 @ModelAttribute 
	 * 的 value 属性值 
	 * 
	 * ②. 确定 target 属性:
	 * 	> 在 implicitModel 中查找 attrName 对应的属性值. 若存在, ok
	 * 	> *若不存在: 则验证当前 Handler 是否使用了 @SessionAttributes 进行修饰, 若使用了, 则尝试从 Session 中
	 * 获取 attrName 所对应的属性值. 若 session 中没有对应的属性值, 则抛出了异常. 
	 * 	> 若 Handler 没有使用 @SessionAttributes 进行修饰, 或 @SessionAttributes 中没有使用 value 值指定的 key
	 * 和 attrName 相匹配, 则通过反射创建了 POJO 对象
	 * 
	 * 2). SpringMVC 把表单的请求参数赋给了 WebDataBinder 的 target 对应的属性. 
	 * 3). *SpringMVC 会把 WebDataBinder 的 attrName 和 target 给到 implicitModel. 
	 * 近而传到 request 域对象中. 
	 * 4). 把 WebDataBinder 的 target 作为参数传递给目标方法的入参. 
	 */
	@RequestMapping("/testModelAttribute")
	public String testModelAttribute(User user){
		System.out.println("修改: " + user);
		return "success";
	}

转发显示jsp页：

request user: ${requestScope.user }

五、视图和视图解析器

请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个ModelAndView 对象，它包含了逻辑名和模型对象的视图。

Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是Excel、JFreeChart 等各种表现形式的视图。

对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦。

六、重定向和转发

一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理
如果返回的字符串中带 forward: 或 redirect: 前缀时，SpringMVC 会对他们进行特殊处理：将 forward: 和redirect: 当成指示符，其后的字符串作为 URL 来处理

–redirect:success：请求重定向到 -> 站点入口所在目录/success ，继续交由handler处理

–forward:success：请求转发到 -> 站点入口所在目录/success ，继续交由handler处理【不过转发时，请求路径是不会跳转的】

测试页：

@RequestMapping("/testredirect")
public String testRedirect(){

System.out.println("test-redirect");

//return "redirect:/index";
return "forward:/success";

}

七、静态资源请求

核心说明：
1、如果url请求对象是 xxx.jsp ，就按照网站路径去查找对应的文件。
2、如果url请求对象不是 xxx.jsp 比如 xx.html 或者 xx ，就交给视图解析器【如果设置了前缀和后缀，就转换成最终路径】去查询路径中是否存在文件。

这样，就造成了无法直接请求静态资源的问题：（在配置开发环境中已提到）

为了能够在网页中请求静态资源，如加载js和css等，所以需要编辑转发配置器。

 <!--  
		default-servlet-handler 将在 SpringMVC 上下文中定义一个 DefaultServletHttpRequestHandler,
		它会对进入 DispatcherServlet 的请求进行筛查, 如果发现是没有经过映射的请求, 就将该请求交由 WEB 应用服务器默认的 
		Servlet 处理. 如果不是静态资源的请求，才由 DispatcherServlet 继续处理

		一般 WEB 应用服务器默认的 Servlet 的名称都是 default.
		若所使用的 WEB 服务器的默认 Servlet 名称不是 default，则需要通过 default-servlet-name 属性显式指定
		
	-->
	<mvc:default-servlet-handler/>
	<!-- 前面的 mvc:default-servlet-handler 可以解决静态资源了，但是让其他经过handler的请求，又失效了，所以配置了下面的 mvc:annotation-driven 来解决问题 -->
	<mvc:annotation-driven></mvc:annotation-driven>

springmvc基础-请求映射总结

@RequestMapping 请求映射总结

注意：

@RequestMapping(“/helloworld”)
public String hello( HttpServletRequest request ,HttpServletResponse response){
System.out.println(“hello request” + request.toString());
System.out.println(“hello response” + response.toString());
return “success”;
}
handler 控制器：函数参数可以有request和 response，可以有其中一个，也可以都没有，request和response 都是spring容器注入的。他们是接口。还有将request 和 response 内部对象作为形参的。另外也可以将 map【返回值ModelAndView中的model】作为形参。

经过了测试：如果控制器的映射是这个–>@RequestMapping("/") 那么访问网站根目录时，还是以网站根目录下的 index.jsp、 index.html 等做为结果返回给浏览器。

一、请求映射-路径区分

1、请求映射-路径区分-基础

<a href="springmvc/testRequestMapping">Test RequestMapping</a>

package com.test.springmvc.handlers;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller // spring里面 又名handler 处理器
public class HelloWorld {

	/**
	 * 1、使用RequestMapping 注解来映射 请求的url
	 * 2、返回值会通过视图解析器解析为实际的物理视图，
	 * 对于org.springframework.web.servlet.view.InternalResourceViewResolver
	 * 会做如下解析，prefix + returnVal + suffix 得到实际的物理视图。然后做转发操作。
	 * 即 WEB-INF/views/success.jsp
 	 */
	@RequestMapping("/helloworld")
	public String hello( HttpServletRequest request,HttpServletResponse response){
		System.out.println("hello request" + request.toString());
		System.out.println("hello response" + response.toString());
		return "success";
	}
	
}

2、请求映射-路径区分-利用post方式

<form action="springmvc/testMethod" method="POST">
	<input type="submit" value="submit"/>
</form>

/**
	 * 常用: 使用 method 属性来指定请求方式
	 */
	@RequestMapping(value = "/testMethod", method = RequestMethod.POST)
	public String testMethod() {
		System.out.println("testMethod");
		return "success";
	}

3、请求映射-路径区分-利用请求参数和请求头

	<a href="springmvc/testParamsAndHeaders?username=atguigu&age=10">Test ParamsAndHeaders</a>

/**
	 * 了解: 可以使用 params 和 headers 来更加精确的映射请求. params 和 headers 支持简单的表达式.
	 * 
	 * @return
	 */
	@RequestMapping(value = "testParamsAndHeaders", params = { "username","age!=10" }, headers = { "Accept-Language=en-US,zh;q=0.8" })
	public String testParamsAndHeaders() {
		System.out.println("testParamsAndHeaders");
		return "success";
	}

4、请求映射-路径区分-利用ant风格

Ant 风格资源地址支持3种匹配符：
?：匹配文件名中的一个字符
*：匹配一层路径
**：** 匹配多层路径

测试： <a href=”springmvc/testAntPath/mnxyz/abc”>Test AntPath</a>

@RequestMapping("/testAntPath/*/abc")
	public String testAntPath() {
		System.out.println("testAntPath");
		return "success";
	}

二、请求映射-信息传递

1、请求映射-信息传递-利用路径变量

测试： <a href=”springmvc/testPathVariable/1″>Test PathVariable</a>

/**
	 * @PathVariable 可以来映射 URL 中的占位符到目标方法的参数中.
	 * @param id
	 * @return
	 */
	@RequestMapping("/testPathVariable/{id}")
	public String testPathVariable(@PathVariable("id") Integer id) {
		System.out.println("testPathVariable: " + id);
		return "success";
	}

2、请求映射-信息传递-REST风格

示例：
/order/1 HTTP GET ：得到id = 1的 order –
/order/1 HTTP DELETE：删除 id = 1 的 order –
/order/1 HTTP PUT：更新 id = 1的 order –
/order HTTP POST：新增 order –

HiddenHttpMethodFilter：浏览器 form 表单只支持 GET与POST请求，而DELETE、PUT 等method并不支持，Spring3.0 添加了一个过滤器，可以将这些请求转换为标准的 http 方法，使得支持 GET、POST、PUT 与DELETE 请求。

第一步：首先在web.xml的添加过滤器

<!-- 
	配置 org.springframework.web.filter.HiddenHttpMethodFilter: 可以把 POST 请求转为 DELETE 或 POST 请求 
	-->
	<filter>
		<filter-name>HiddenHttpMethodFilter</filter-name>
		<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
	</filter>
	
	<filter-mapping>
		<filter-name>HiddenHttpMethodFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

第二步：编写测试网页

<form action="springmvc/testRest/1" method="post">
		<input type="hidden" name="_method" value="PUT"/>
		<input type="submit" value="TestRest PUT"/>
	</form>
	<br><br>
	
	<form action="springmvc/testRest/1" method="post">
		<input type="hidden" name="_method" value="DELETE"/>
		<input type="submit" value="TestRest DELETE"/>
	</form>
	<br><br>
	
	<form action="springmvc/testRest" method="post">
		<input type="submit" value="TestRest POST"/>
	</form>
	<br><br>
	
	<a href="springmvc/testRest/1">Test Rest Get</a>
	<br><br>

3、请求映射-信息传递-利用请求参数

	/**
	 * @RequestParam 来映射请求参数. value 值即请求参数的参数名 required 该参数是否必须. 默认为 true
	 *               defaultValue 请求参数的默认值
	 */
	@RequestMapping(value = "/testRequestParam")
	public String testRequestParam(
			@RequestParam(value = "username") String un,
			@RequestParam(value = "age", required = false, defaultValue = "0") int age) {
		System.out.println("testRequestParam, username: " + un + ", age: "
				+ age);
		return "success";
	}

测试： <a href=”springmvc/testRequestParam?username=atguigu&age=11″>Test RequestParam</a>

其实也可以用表单的post方法，来传递请求参数，因为控制器也能解析的。

第三步：编写控制器

/**
	 * Rest 风格的 URL. 以 CRUD 为例: 新增: /order POST 修改: /order/1 PUT update?id=1 获取:
	 * /order/1 GET get?id=1 删除: /order/1 DELETE delete?id=1
	 * 
	 * 如何发送 PUT 请求和 DELETE 请求呢 ? 1. 需要配置 HiddenHttpMethodFilter 2. 需要发送 POST 请求
	 * 3. 需要在发送 POST 请求时携带一个 name="_method" 的隐藏域, 值为 DELETE 或 PUT
	 * 
	 * 在 SpringMVC 的目标方法中如何得到 id 呢? 使用 @PathVariable 注解
	 * 
	 */
	@RequestMapping(value = "/testRest/{id}", method = RequestMethod.PUT)
	public String testRestPut(@PathVariable Integer id) {
		System.out.println("testRest Put: " + id);
		return "success";
	}

	@RequestMapping(value = "/testRest/{id}", method = RequestMethod.DELETE)
	public String testRestDelete(@PathVariable Integer id) {
		System.out.println("testRest Delete: " + id);
		return "success";
	}

	@RequestMapping(value = "/testRest", method = RequestMethod.POST)
	public String testRest() {
		System.out.println("testRest POST");
		return "success";
	}

	@RequestMapping(value = "/testRest/{id}", method = RequestMethod.GET)
	public String testRest(@PathVariable Integer id) {
		System.out.println("testRest GET: " + id);
		return "success";
	}

4、请求映射-信息传递-利用请求头

测试： <a href=”springmvc/testRequestHeader”>Test RequestHeader</a>

/**
	 * 了解: 映射请求头信息 用法同 @RequestParam
	 */
	@RequestMapping("/testRequestHeader")
	public String testRequestHeader(
			@RequestHeader(value = "Accept-Language") String al) {
		System.out.println("testRequestHeader, Accept-Language: " + al);
		return "success";
	}

5、请求映射-信息传递-利用cookie值

测试：<a href=”springmvc/testCookieValue”>Test CookieValue</a>

/**
	 * 了解:
	 * 
	 * @CookieValue: 映射一个 Cookie 值. 属性同 @RequestParam
	 */
	@RequestMapping("/testCookieValue")
	public String testCookieValue(@CookieValue("JSESSIONID") String sessionId) {
		System.out.println("testCookieValue: sessionId: " + sessionId);
		return "success";
	}

6、请求映射-信息传递-form表单的pojo

将表单信息转换成 bean ，支持级联属性。如：dept.deptId、dept.address.tel 等

1、测试页：

<form action="springmvc/testPojo" method="post">
		username: <input type="text" name="username"/>
		<br>
		password: <input type="password" name="password"/>
		<br>
		email: <input type="text" name="email"/>
		<br>
		age: <input type="text" name="age"/>
		<br>
		city: <input type="text" name="address.city"/>
		<br>
		province: <input type="text" name="address.province"/>
		<br>
		<input type="submit" value="Submit"/>
	</form>

2、控制页

	/**
	 * Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配， 自动为该对象填充属性值。支持级联属性。
	 * 如：dept.deptId、dept.address.tel 等
	 */
	@RequestMapping("/testPojo")
	public String testPojo(User user) {
		System.out.println("testPojo: " + user);
		return "success";
	}

3、Bean [估计是调用默认构造函数，然后set属性，完成bean创建]

bean – user

public class User {
	
	private Integer id;
	
	private String username;
	private String password;

	private String email;
	private int age;
	
	private Address address;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	public User() {}
}

bean-address

public class Address {

	private String province;
	private String city;

	public String getProvince() {
		return province;
	}

	public void setProvince(String province) {
		this.province = province;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}
}

显示jsp页：

<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“c”%>

…

request user: ${requestScope.user }

核心摘要：在控制器中，自动生成的pojo的 User类型对象。会自动产生一个首字母小写的类型对象的关键字，并将关键字和其类型对象值，一同传入request中。

如这里：会将 “user” 作为关键字，user 对象作为value值，存放到request中。

操作和 request.setAttribute("user", user);一样
如果控制器的pojo参数用了 @ModelAttribute 注解标记，那么标记值若是XXX，则效果就像 request.setAttribute("XXX", user);一样

//举例如下：
//控制器中 用 @ModelAttribute&nbsp;注解标记 的情况
public String testPojo(@ModelAttribute(value ="test") User user) {
	System.out.println("testPojo: " + user);
	return "success";
}
//在转发显示页 用 ${requestScope.test} 调用。当然别忘记添加 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

总之一旦有pojo对象生成，那显示jsp页就可以直接调用${requestScope.标记名 }

7、请求映射-信息传递-原始servletapi作为参数

测试：<a href=”springmvc/testServletAPI”>Test ServletAPI</a>

/**
	 * 可以使用 Serlvet 原生的 API 作为目标方法的参数 具体支持以下类型
	 * 
	 * HttpServletRequest 
	 * HttpServletResponse 
	 * HttpSession
	 * java.security.Principal 
	 * Locale InputStream 
	 * OutputStream 
	 * Reader 
	 * Writer
	 * @throws IOException 
	 */
	@RequestMapping("/testServletAPI")
	public void testServletAPI(HttpServletRequest request,
			HttpServletResponse response, Writer out) throws IOException {
		System.out.println("testServletAPI, " + request + ", " + response);
		out.write("hello springmvc");
//		return "success";
	}

Handler的函数参数可以添加上面的这些，其实本质上来说：函数参数只有 request和response。其他的参数都是这些方法里面包括的。比如writer就是response.getWriter()

springmvc基础-注解方式编程和非注解方式编程

一、简单情境下

1、配置文件概述

2、注册转发器

在web.xml文件中，配置如下：

<?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_2_5.xsd" id="WebApp_ID" version="2.5">
	
	<!-- 配置 DispatcherServlet -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 配置 DispatcherServlet 的一个初始化参数: 配置 SpringMVC 配置文件的位置和名称 -->
		<!-- 
			实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.
			默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
		-->
		<!--  
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		-->
		<load-on-startup>1</load-on-startup>
        <!-- load on starup 大于、等于0代表随系统启动后加载 ，数字越小优先级越高 ; 数值为负数时，启动时不加载，调用时再加载 -->
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
     <!-- 
              第一种：*.action 或者 *.do，访问以.action或*.do结尾 由DispatcherServlet进行解析
              第二种：/，所以访问的地址都由DispatcherServlet进行解析，对于静态文件的解析需要配置不让DispatcherServlet进行解析
              使用此种方式可以实现 RESTful风格的url
              第三种：/*，这样配置不对，使用这种配置，最终要转发到一个jsp页面时，
              仍然会由DispatcherServlet解析jsp地址，不能根据jsp页面找到handler，会报错。
       -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

<!-- 下面这个没有写不要紧，因为tomcat服务器默认 index为首页 --> 
<welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>

</web-app>

3、配置转发器

转发配置文件–>【前面web.xml配置的是在src下，取名springmvc.xml文件。如果是默认配置应该在WEB-INF下即和web.xml同目录，取名dispatcherServlet-servlet.xml文件】，其中配置自定扫描的包，是为了扫描指定包文件中，有@Controller ，@Component等注解的类文件。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

	
    <!-- 对于注解的Handler可以单个配置 实际开发中建议使用组件扫描 -->
    <!-- <bean class="com.test.springmvc.handlers.HelloWorld" />  -->
    <!-- 可以扫描controller、service、...这里让扫描controller，指定controller的包,但是view的包下面的注解类就扫描不到了，
    所以 com.test.springmvc.handlers 改成 com.test.springmvc就行啦，子目录都能扫描得到  -->
	<!--下面是 配置扫描  指定目录包 中的 java文件 -->
	<context:component-scan base-package="com.test.springmvc.handlers"></context:component-scan>

<!-- 配置视图解析器【多个函数可选择】: 此解析器默认生成InternalResourceView,如果项目添加了jstl.jar包的话就会自动改为生成JstlView; 即如何把 handler 方法返回值解析为实际的物理视图，handler的返回值也可以具体是 /WEB-INF/XXXX/XXX.jsp，这样下面的试图解析器就不需要添加前缀和后缀了 -->	
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
	


</beans>

4、编写控制器

在dispatcherServlet-servlet.xml中，因为标明了自定义扫描包路径，来寻找控制器。于是我们就用代码来实现控制器。在包名 com.test.springmvc.handlers 下，创建 HelloWorld.java

[java]
package com.test.springmvc.handlers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller // spring里面又名handler 处理器
public class HelloWorld {

/**
* 1、使用RequestMapping 注解来映射请求的url
* 2、返回值会通过视图解析器解析为实际的物理视图，
* 对于org.springframework.web.servlet.view.InternalResourceViewResolver
* 会做如下解析，prefix + returnVal + suffix 得到实际的物理视图。然后做转发操作。
* 即 WEB-INF/views/success.jsp
*/
@RequestMapping("/helloworld")
public String hello(){
System.out.println("hello world");
return "success";
}

}

[/java]

上面的请求路径为：projectname/helloworld
也可以在类上面多加一个 RequestMapping 注解，比如 xxx
那么请求路径为 projectname/xxx/helloworld

五、配置返回结果页

/WEB-INF/views/success.jsp 编辑如下：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>



<h4> Success page </h4>



</body>
</html>

6、url请求测试结果

下面两个都能正常访问
http://localhost:5858/springmvc-1/
http://localhost:5858/springmvc-1/index.jsp

WEB-INF只允许服务器访问，外部无法访问，所以下面的请求无法访问。
http://localhost:5858/springmvc-1/WEB-INF/views/success.jsp

springmvc页面能正常访问
http://localhost:5858/springmvc-1/helloworld

在index.jsp文件后面又新建了一个测试文件test1.jsp，发现能够正常访问。
http://localhost:5858/springmvc-1/test1.jsp

总结：在此web.xml配置的转发器的拦截域是：
经测试发现，先判断请求是不是网站根目录/零层或多层路径/xxx.jsp,
如果是，查找是不是存在，存在的话就OK。不存在的就返回404
如果不是，那么再查看控制器，判断是否有匹配的映射名，如果仍没有就返回 404

补充：配置注解映射器和注解适配器

在配置转发器中，需要添加的注解映射器和注解适配器：
在spring3.1之前使用org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping注解映射器。

在spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping注解映射器。

在spring3.1之前使用org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter注解适配器。

在spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter注解适配器。

下面是在配置转发器【即前面提到的dispatcherServlet-servlet.xml】中，进行编辑的内容：

<!-- 注解映射器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <!-- 注解的适配器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
    <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置
        mvc:annotation-driven默认加载很多的参数绑定方法，
        比如json转换解析器就默认加载了，如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter
        实际开发时使用mvc:annotation-driven
     -->
    <!-- <mvc:annotation-driven></mvc:annotation-driven> -->

在实际使用时，不配置注解映射器和注解适配器，也能正常运行。因为MVC有默认配置在核心中的/org/springframework/web/servlet/DispatcherServlet.properties中，有兴趣的同学可以自行查看。

二、非注解情况配置

与注解情况的区别就是：1、修改handle 2、配置转发器文件

1、在springmvc.xml中的配置，如下：{也就是前面提到的dispatcherServlet-servlet.xml，因为配置文件可以随意取名}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

	
     
<!-- 配置视图解析器【多个函数可选择】: 此解析器默认生成InternalResourceView,如果项目添加了jstl.jar包的话就会自动改为生成JstlView; 即如何把 handler 方法返回值解析为实际的物理视图，handler的返回值也可以具体是 /WEB-INF/XXXX/XXX.jsp，这样下面的试图解析器就不需要添加前缀和后缀了 -->	

	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置jsp路径的前缀 -->
		<property name="prefix" value="/WEB-INF/views/"></property>
	    <!-- 配置jsp路径的后缀 -->
		<property name="suffix" value=".jsp"></property>
	</bean>
	
    <!-- 配置handler -->
     <bean id="helloController" name="/hello" class="com.test.springmvc.handlers.HelloController"></bean> 
    <!-- 处理器映射器  根据bean的name进行查找Handler 将controller 的url配置在bean的name中-->
     <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean> 
    <!-- 处理器适配器  通过查看源码，可知此适配器能执行实现Controller接口的handler：-->
     <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> 

	
</beans>

所有的映射器都实现HandlerMapping接口，所有的适配器都实现HandlerAdapter接口，还有另外一个非注解的适配器：org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter，另外一个映射器：org.springframework.web.servlet.handler.SimpleUrlHandlerMapping，如果这些都不配置的话，仍然能够使用，因为MVC有默认配置在核心中的/org/springframework/web/servlet/DispatcherServlet.properties中，有兴趣的同学可以自行查看。

2、配置handler【又叫controller】

package com.test.springmvc.handlers;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

//HelloController类必须实现Controller接口，查看映射文件：
//这样，springmvc 才能识别它

public class HelloController  implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		
	//返回ModelAndView
        ModelAndView modelAndView =  new ModelAndView();
        //相当 于request的setAttribut，在jsp页面中通过itemsList取数据
        //在当前的实验中， 我没有在网页中进行获取信息测试，所以设置了空值
        modelAndView.addObject("itemsList", "");
        
        //指定视图 下面这句有错误 （正确做法是在 转发配置页中  删除视图解析器的前缀和后缀）
        modelAndView.setViewName("/WEB-INF/views/success.jsp");    
        //或者另一种正确的做法 上面这句返回"success"；保留 转发配置页中的视图解析器的前缀和后缀

        //modelAndView.setViewName("success");
        
        System.out.println("hello world" + request.toString());
		request.toString();

        return modelAndView;
	}

}

springmvc基础-配置开发环境

一、从官网下载 spring jar包

http://repo.spring.io/release/org/springframework/

楼主选的是spring 4 版本，开发要用到的基本jar包如下：

-javadoc 其实里面就是 html，用于介绍 api 的说明文档
-sources 里面是源代码，用于查看框架的设计和实现

二、 eclipse 新建 dynamic web 项目

记得勾选自动生成 web.xml文件啊。。。

三、编辑web.xml文件，创建springmvc文件

先了解一下web.xml文件，

web.xml文件进行配置：

<?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_2_5.xsd" id="WebApp_ID" version="2.5">
	
	<!-- 配置 DispatcherServlet -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 配置 DispatcherServlet 的一个初始化参数: 配置 SpringMVC 配置文件的位置和名称 -->
		<!-- 
			实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.
			默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
		-->
		<!--  
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		-->
		<load-on-startup>1</load-on-startup>
        <!-- load on starup 大于、等于0代表随系统启动后加载 ，数字越小优先级越高 ; 数值为负数时，启动时不加载，调用时再加载 -->
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
     <!-- 
              第一种：*.action 或者 *.do，访问以.action或*.do结尾 由DispatcherServlet进行解析
              第二种：/，所以访问的地址都由DispatcherServlet进行解析，对于静态文件的解析需要配置不让DispatcherServlet进行解析
              使用此种方式可以实现 RESTful风格的url
              第三种：/*，这样配置不对，使用这种配置，最终要转发到一个jsp页面时，
              仍然会由DispatcherServlet解析jsp地址，不能根据jsp页面找到handler，会报错。
       -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

<!-- 下面这个没有写不要紧，因为tomcat服务器默认 index为首页 --> 
<welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>

</web-app>

可以参考一下：
j2ee标准-web.xml中load-on-startup源码解析

四、编辑 spring mvc 配置文件

根据 web.xml 中已经配置好的 org.springframework.web.servlet.DispatcherServlet 的类，加载这个类时需要转发配置文件。

转发配置文件的基本配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <!-- 对于注解的Handler可以单个配置 实际开发中建议使用组件扫描 -->
    <!-- <bean class="com.test.springmvc.handlers.HelloWorld" />  -->
    <!-- 可以扫描controller、service、...这里让扫描controller，指定controller的包,但是view的包下面的注解类就扫描不到了，
    所以 com.test.springmvc.handlers 改成 com.test.springmvc就行啦，子目录都能扫描得到  -->
	<!--下面是 配置扫描  指定目录包 中的 java文件 -->
	<context:component-scan base-package="com.test.springmvc"></context:component-scan>
    
	<!-- 配置视图解析器【多个函数可选择】: 此解析器默认生成InternalResourceView,如果项目添加了jstl.jar包的话就会自动改为生成JstlView; 即如何把 handler 方法返回值解析为实际的物理视图，handler的返回值也可以具体是 /WEB-INF/XXXX/XXX.jsp，这样下面的试图解析器就不需要添加前缀和后缀了 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
	
</beans>

1、自定义扫描目录范围表示扫描指定文件，查看是否存在注解。
2、springmvc 配置文件的视图解析器，告诉了控制器返回结果时，应该将页面跳转到哪里。比如控制器【第五节介绍】返回结果 success ，那么跳转页面应该到 /WEB-INF/views/success.jsp 文件中

四、配置控制器

在包名 com.test.springmvc.handlers 下
创建 HelloWorld.java

[java]
package com.test.springmvc.handlers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller // spring里面又名handler 处理器
public class HelloWorld {

}

[/java]

上面的请求路径为：projectname/helloworld
也可以在类上面多加一个 @RequestMapping 注解，比如 xxx
那么请求路径为 projectname/xxx/helloworld

五、配置返回结果页

/WEB-INF/views/success.jsp 编辑如下：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>


<h4> Success page </h4>


</body>
</html>

六、启动服务器，输入地址

在配置控制器时，已经在类HelloWorld 使用了@RequestMapping(“/helloworld”)注解
所以浏览器直接输入 ” http://localhost:端口号/工程名/helloworld” 就能看到结果啦

七、补充：配置注解映射器和注解适配器

在spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping注解映射器。

在spring3.1之前使用org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter注解适配器。

在spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter注解适配器。

下面是在配置转发器【即前面提到的dispatcherServlet-servlet.xml】中，进行编辑的内容：

<!-- 注解映射器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <!-- 注解的适配器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
    <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置
        mvc:annotation-driven默认加载很多的参数绑定方法，
        比如json转换解析器就默认加载了，如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter
        实际开发时使用mvc:annotation-driven
     -->
    <!-- <mvc:annotation-driven></mvc:annotation-driven> -->

八、非注解方式配置方法

参考springmvc基础-注解方式编程和非注解方式编程

九、国际化配置方法

1、新建i18n文件，存放于src文件夹下面：

i18n.username=Username
i18n.password=Password

i18n.username=\u7528\u6237\u540D
i18n.password=\u5BC6\u7801

i18n.username=Username
i18n.password=Password

2、在转发配置文件中添加：

<!-- 配置国际化资源文件 -->
<bean id="messageSource"
	class="org.springframework.context.support.ResourceBundleMessageSource">
	<property name="basename" value="i18n"></property>	
</bean>

3、在请求页面jsp中：添加

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<body>
	<fmt:message key="i18n.username" ></fmt:message>
	<fmt:message key="i18n.password" ></fmt:message>
</body>

国际化问题特别注意点：<fmt:message>标签只能出现在转发页面中，不能出现在请求页面中【请求页面我测试了一下，出现乱码】原因是在转发配置页中，指定了国际化配置文件啊，必须在转发过程中才会生效啊！！！

十、配置无控制器直接转发

一般情况下，请求页需要由控制器处理后，才能转发到目标页面。但是也可以编辑转发配置文件，实现不经过控制器而直接转发到目标页面。【本质上就是在这里配置了一个默认控制器，path代表控制器的@RequestMaping ,view-name代表控制器的返回值】

<!-- 配置直接转发的页面 -->
	<!-- 可以直接相应转发的页面, 而无需再经过 Handler 的方法.  -->
	<mvc:view-controller path="/success" view-name="success"/>

但是上面的配置会造成，那些所有需要经过控制器转发的url请求，全部失效无法访问。为了解决这个问题，需要在转发配置页继续配置如下：

<mvc:annotation-driven></mvc:annotation-driven>

十一、请求静态资源问题

因为前面测试过了，如果请求路径是xxx.jsp是可以直接显示的。如果是XXX，就会交由handler处理。

为了能够在网页中，加载js和css，请求静态资源，所以需要编辑转发配置器。

 <!--  
		default-servlet-handler 将在 SpringMVC 上下文中定义一个 DefaultServletHttpRequestHandler,
		它会对进入 DispatcherServlet 的请求进行筛查, 如果发现是没有经过映射的请求, 就将该请求交由 WEB 应用服务器默认的 
		Servlet 处理. 如果不是静态资源的请求，才由 DispatcherServlet 继续处理

		一般 WEB 应用服务器默认的 Servlet 的名称都是 default.
		若所使用的 WEB 服务器的默认 Servlet 名称不是 default，则需要通过 default-servlet-name 属性显式指定
		
	-->
	<mvc:default-servlet-handler/>
	<!-- 前面的 mvc:default-servlet-handler 可以解决静态资源了，但是让其他经过handler的请求，又失效了，所以配置了下面的 mvc:annotation-driven 来解决问题 -->
	<mvc:annotation-driven></mvc:annotation-driven>

出现过的问题小结：之前在项目中添加了entity文件，里面有@NotEmpty注解等。这些注解用到了校验jar包，比如 hibernate-validator-5.0.0.CR2.jar

在没有添加这句话 <mvc:annotation-driven></mvc:annotation-driven> 前，一直没有报错，后来加了这句话后报错了。

Caused by: java.lang.NoClassDefFoundError: org/jboss/logging/BasicLogger
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
	at org.apache.catalina.loader.WebappClassLoaderBase.findClassInternal(WebappClassLoaderBase.java:2541)
	at org.apache.catalina.loader.WebappClassLoaderBase.findClass(WebappClassLoaderBase.java:858)
	at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1301)
	at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1166)
	at org.hibernate.validator.internal.util.logging.LoggerFactory.make(LoggerFactory.java:29)
	at org.hibernate.validator.internal.util.Version.<clinit>(Version.java:27)
	at org.hibernate.validator.internal.engine.ConfigurationImpl.<clinit>(ConfigurationImpl.java:65)
	at org.hibernate.validator.HibernateValidator.createGenericConfiguration(HibernateValidator.java:41)
	at javax.validation.Validation$GenericBootstrapImpl.configure(Validation.java:276)
	at org.springframework.validation.beanvalidation.LocalValidatorFactoryBean.afterPropertiesSet(LocalValidatorFactoryBean.java:250)
	at org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean.afterPropertiesSet(OptionalValidatorFactoryBean.java:40)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1687)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1624)
	... 28 more

发现是缺少了 jboss-logging的jar包，添加了就行。

一、springmvc与spring的整合举例：

1、配置 web.xml ，配置了两个容器。

2、配置父容器 springioc.xml

3、配置springmvc.xml

4、编辑服务器：

5、编辑控制器：

二、springmvc与spring容器关系

@ModelAttribute 三种用法

1、对handler中的方法进行注解:

2、对handler内的方法的形参进行注解：

3、在jsp中的使用springmvc 的表单标签 问题：

一、概述

二、视图含义

三、常用的视图实现类

四、视图解析器

五、常用的视图解析器实现类

六、自定义视图

1、编辑测试页

2、编辑控制器

3、编辑转发配置页

4、创建自定义view

一、基础流程

二、控制器中的map参数

三、控制器中的@SessionAttributes

四、控制器中的@ModelAttribute

五、视图和视图解析器

六、重定向和转发

七、静态资源请求

@RequestMapping 请求映射总结

注意：

一、请求映射-路径区分

1、请求映射-路径区分-基础

2、请求映射-路径区分-利用post方式

3、请求映射-路径区分-利用请求参数和请求头

4、请求映射-路径区分-利用ant风格

二、请求映射-信息传递

1、请求映射-信息传递-利用路径变量

2、请求映射-信息传递-REST风格

3、请求映射-信息传递-利用请求参数

4、请求映射-信息传递-利用请求头

5、请求映射-信息传递-利用cookie值

6、请求映射-信息传递-form表单的pojo

7、请求映射-信息传递-原始servletapi作为参数

一、简单情境下

1、配置文件概述

2、注册转发器

3、配置转发器

4、编写控制器

五、配置 返回结果 页

6、url请求测试结果

补充：配置注解映射器和注解适配器

二、非注解情况配置

一、从官网下载 spring jar包

二、 eclipse 新建 dynamic web 项目

三、编辑web.xml文件，创建springmvc文件

四、编辑 spring mvc 配置文件

四、配置 控制器

五、配置 返回结果 页

六、启动服务器，输入地址

七、补充：配置注解映射器和注解适配器

八、非注解方式配置方法

九、国际化配置方法

十、配置无控制器直接转发

十一、请求静态资源问题

3、在jsp中的使用springmvc 的表单标签问题：

五、配置返回结果页

四、配置控制器

五、配置返回结果页