Spring MVC小总结

最新推荐文章于 2023-08-03 08:00:00 发布

bobshute

最新推荐文章于 2023-08-03 08:00:00 发布

阅读量172

点赞数

分类专栏： OPEN 总结文章标签：开源 Spring

本文链接：https://blog.csdn.net/bobshute/article/details/102773850

版权

总结同时被 2 个专栏收录

88 篇文章 0 订阅

订阅专栏

OPEN

11 篇文章 0 订阅

订阅专栏

1.基本原理

1.1 Spring MVC在Spring中位置

SpringMVC-在Spring中位置

1.2 基本原理

前端控制器、处理器映射器、处理器适配器、视图解析器
第一步：发起请求到前端控制器(DispatcherServlet)
第二步：前端控制器请求HandlerMapping查找 Handler
可以根据xml配置、注解进行查找
第三步：处理器映射器HandlerMapping向前端控制器返回Handler
第四步：前端控制器调用处理器适配器去执行Handler
第五步：处理器适配器去执行Handler
第六步：Handler执行完成给适配器返回ModelAndView
第七步：处理器适配器向前端控制器返回ModelAndView
ModelAndView是springmvc框架的一个底层对象，包括 Model和view
第八步：前端控制器请求视图解析器去进行视图解析
根据逻辑视图名解析成真正的视图(jsp)
第九步：视图解析器向前端控制器返回View
第十步：前端控制器进行视图渲染
视图渲染将模型数据(在ModelAndView对象中)填充到request域
第十一步：前端控制器向用户响应结果
组件：
- 1、前端控制器DispatcherServlet（不需要程序员开发）[web.xml]
  作用接收请求，响应结果，相当于转发器，中央处理器。
  有了DispatcherServlet减少了其它组件之间的耦合度。
- 2、处理器映射器（HandlerMapping）(不需要程序员开发)[直接选择Spring的不同配置]
  作用：根据请求的url查找Handler
- 3、处理器适配器（HandlerAdapter）【都实现了 HandlerAdapter 接口】
  作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler
- 4、处理器Handler(需要程序员开发)
  注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
- 5、视图解析器View resolver(不需要程序员开发)
  作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
- 6、视图View(需要程序员开发jsp)
  View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）

2. 核心模块

2.1 配置前端控制器(web.xml)

web.xml

<!-- springmvc前端控制器 -->
  <servlet>
  	<servlet-name>springmvc</servlet-name>
  	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  	<!-- contextConfigLocation配置springmvc加载的配置文件（配置处理器映射器、适配器等等）
  	如果不配置contextConfigLocation，默认加载的是/WEB-INF/servlet名称-serlvet.xml（springmvc-servlet.xml）
  	 -->
  	<init-param>
  		<param-name>contextConfigLocation</param-name>
  		<param-value>classpath:springmvc.xml</param-value>
  	</init-param>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>springmvc</servlet-name>
  	<!-- 
  	第一种：*.action，访问以.action结尾 由DispatcherServlet进行解析
  	第二种：/，所以访问的地址都由DispatcherServlet进行解析，对于静态文件的解析需要配置不让DispatcherServlet进行解析
  	使用此种方式可以实现 RESTful风格的url
  	第三种：/*，这样配置不对，使用这种配置，最终要转发到一个jsp页面时，
  	仍然会由DispatcherServlet解析jsp地址，不能根据jsp页面找到handler，会报错。
  	
  	 -->
  	<url-pattern>*.action</url-pattern>
  </servlet-mapping>

2.2 配置处理器适配器、处理器映射器、视图解析器(都在springmvc.xml中)

springmvc.xml

<!-- 处理器适配器 所有处理器适配器都实现 HandlerAdapter接口 -->
	<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />
	
	
	<!-- 配置Handler 配合BeanNameUrlHandlerMapping使用-->
	<bean id="itemsController1" name="/queryItems_test.action" class="course.springmvc.cast1.srcs.controller.ItemsController1" />
	<!-- 处理器映射器 将bean的name作为url进行查找 ，需要在配置Handler时指定beanname（就是url） 
	所有的映射器都实现 HandlerMapping接口。-配合itemsController1使用
	-->
	<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />
	
	<!--简单url映射  -->
	<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<property name="mappings">
			<props>
				<!-- 对itemsController1进行url映射，url是/queryItems1.action -->
				<prop key="/queryItems1.action">itemsController1</prop> 
			</props>
		</property>
	</bean>
	
		<!-- 视图解析器
	解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包
	 -->
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置jsp路径的前缀 -->
		<property name="prefix" value="/WEB-INF/jsp/"/>
		<!-- 配置jsp路径的后缀 -->
		<property name="suffix" value=".jsp"/>
	</bean>

此适配器能执行实现 Controller接口的Handler。

2.3 开发Handle

需要实现 controller接口，才能由org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter适配器执行。 ,具体可以看后面的源码分析.


import java.util.ArrayList;
import java.util.List;

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

import course.springmvc.cast1.srcs.po.Items;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;


public class ItemsController1 implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		
		//调用service查找 数据库，查询商品列表，这里使用静态数据模拟
		List<Items> itemsList = new ArrayList<Items>();
		//向list中填充静态数据
		
		Items items_1 = new Items();
		items_1.setName("联想笔记本");
		items_1.setPrice(6000f);
		items_1.setDetail("ThinkPad T430 联想笔记本电脑！");
		
		Items items_2 = new Items();
		items_2.setName("苹果手机");
		items_2.setPrice(5000f);
		items_2.setDetail("iphone6苹果手机！");
		
		itemsList.add(items_1);
		itemsList.add(items_2);

		//返回ModelAndView
		ModelAndView modelAndView =  new ModelAndView();
		//相当 于request的setAttribut，在jsp页面中通过itemsList取数据
		modelAndView.addObject("itemsList", itemsList);
		
		//指定视图
		modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

		return modelAndView;
	}
}

2.4 视图解析器

<!-- 视图解析器:解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包-->
<bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 配置jsp路径的前缀 -->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!-- 配置jsp路径的后缀 -->
    <property name="suffix" value=".jsp"/>
</bean>

2.5 其它处理器映射器和适配器

spring-webmvc.jar中有DispatcherSerlvet.properties:前端控制器从上边的文件中加载处理映射器、适配器、视图解析器等组件，如果不在springmvc.xml中配置，使用默认加载的。

2.5.1 非注解的处理器映射器和适配器

2.5.1.1 非注解的处理器映射器

org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

<!-- 配置Handler(和BeanNameUrlHandlerMapping组合使用) -->
<bean id="itemsController1" name="/queryItems_test.action" class="course.springmvc.cast1.srcs.controller.ItemsController1" />

<!-- 处理器映射器 将bean的name作为url进行查找 ，需要在配置Handler时指定beanname（就是url） 
所有的映射器都实现 HandlerMapping接口。上面的[itemsController1]配置方式配合使用
-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

org.springframework.web.servlet.handler.SimpleUrlHandlerMapping


<!--简单url映射  -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
	<props>
		<!-- 对itemsController1进行url映射，url是/queryItems1.action -->
		<prop key="/queryItems1.action">itemsController1</prop>
		<prop key="/queryItems2.action">itemsController1</prop>
		<prop key="/queryItems3.action">itemsController2</prop>
	</props>
</property>
</bean>

多个映射器可以并存，前端控制器判断url能让哪些映射器映射，就让正确的映射器处理。

2.5.1.2 非注解的处理器适配器

org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter

要求编写的Handler实现 Controller接口。

- springmvc.xml

<!-- 处理器适配器 所有处理器适配器都实现 HandlerAdapter接口 -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />



- 对应Handler(Controller)

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

import course.springmvc.cast1.srcs.po.Items;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class ItemsController1 implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		
		//调用service查找 数据库，查询商品列表，这里使用静态数据模拟
		List<Items> itemsList = new ArrayList<Items>();
		//向list中填充静态数据
		//返回ModelAndView
		ModelAndView modelAndView =  new ModelAndView();
		//相当 于request的setAttribut，在jsp页面中通过itemsList取数据
		modelAndView.addObject("itemsList", itemsList);
		
		//指定视图
		modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

		return modelAndView;
	}
}

org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter

要求编写的Handler实现 HttpRequestHandler接口。

- springmvc.xml
<!-- 另一个非注解的适配器 -->
<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>

- 对应Handler(ItemsController2)

public class ItemsController2 implements HttpRequestHandler {

	@Override
	public void handleRequest(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		
		//调用service查找 数据库，查询商品列表，这里使用静态数据模拟
		List<Items> itemsList = new ArrayList<Items>();
		//向list中填充静态数据
		//设置模型数据
		request.setAttribute("itemsList", itemsList);
		//设置转发的视图
		request.getRequestDispatcher("/WEB-INF/jsp/items/itemsList.jsp").forward(request, response);
		
		//使用此方法可以通过修改response，设置响应的数据格式，比如响应json数据

        /*  
		response.setCharacterEncoding("utf-8");
		response.setContentType("application/json;charset=utf-8");
		response.getWriter().write("json串");*/
	}
}

2.5.2 注解的处理器映射器和适配器

注解映射器(HandlerMapping)
- spring3.1之前使用org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
- spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
注解适配器(HandlerAdapter)
- spring3.1之前使用org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
- spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

<!--注解映射器 -->
<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> -->

对应Handler(ItemsController3)

//使用Controller标识 它是一个控制器
@Controller
public class ItemsController3 {
	
//商品查询列表
//@RequestMapping实现 对queryItems方法和url进行映射，一个方法对应一个url
//一般建议将url和方法写成一样
@RequestMapping("/queryItems")
public ModelAndView queryItems()throws Exception{
	
	//调用service查找 数据库，查询商品列表，这里使用静态数据模拟
	List<Items> itemsList = new ArrayList<Items>();
	//向list中填充静态数据
	
	//返回ModelAndView
	ModelAndView modelAndView =  new ModelAndView();
	//相当 于request的setAttribut，在jsp页面中通过itemsList取数据
	modelAndView.addObject("itemsList", itemsList);
	
	//指定视图
	modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
	
	return modelAndView;
}

加载Handler

<!-- 对于注解的Handler可以单个配置
实际开发中建议使用组件扫描
 -->
<!-- <bean class="cn.*.ssm.controller.ItemsController3" /> -->
<!-- 可以扫描controller、service、...
这里让扫描controller，指定controller的包
 -->
<context:component-scan base-package="cn.ssm.controller"></context:component-scan>

2.6 Controller 配置

2.6.1 @RequestMapping

url映射
定义controller方法对应的url，进行处理器映射使用
窄化请求映射(类或方法均可使用)

@RequestMapping("/items")
public class ItemsController {
    @RequestMapping("/queryItems/list") 
    public ModelAndView queryItems(HttpServletRequest request) throws Exception {
    }
}

限制http请求方法
出于安全性考虑，对http的链接进行方法限制。如果限制请求为post方法，进行get请求，报错：

@RequestMapping(value = "/queryItems", method={RequestMethod.GET,RequestMethod.POST})

2.6.2 Controller返回值

2.6.2.1 返回ModelAndView

需要方法结束时，定义ModelAndView，将model和view分别进行设置。

@Override
	public ModelAndView handleRequest(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		List<Items> itemsList = new ArrayList<Items>();

		//返回ModelAndView
		ModelAndView modelAndView =  new ModelAndView();
		//相当 于request的setAttribut，在jsp页面中通过itemsList取数据
		modelAndView.addObject("itemsList", itemsList);
		//指定视图
		modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
		return modelAndView;
	}

2.6.2.2 返回string


@RequestMapping(value="/editItems",method={RequestMethod.POST,RequestMethod.GET})
	//@RequestParam里边指定request传入参数名称和形参进行绑定。
	//通过required属性指定参数是否必须要传入
	//通过defaultValue可以设置默认值，如果id参数没有传入，将默认值和形参绑定。
	public String editItems(Model model,@RequestParam(value="id",required=true) Integer items_id)throws Exception {
		
		//调用service根据商品id查询商品信息
		ItemsCustom itemsCustom = itemsService.findItemsById(items_id);
		
		//通过形参中的model将model数据传到页面
		//相当于modelAndView.addObject方法
		model.addAttribute("itemsCustom", itemsCustom);
		
		return "items/editItems";
	}

2.6.2.3 redirect和forward

//商品信息修改提交
@RequestMapping("/editItemsSubmit")
public String editItemsSubmit(HttpServletRequest request,Integer id,ItemsCustom itemsCustom)throws Exception{
	
	//调用service更新商品信息，页面需要将商品信息传到此方法
	itemsService.updateItems(id, itemsCustom);
	
	//重定向到商品查询列表
    //return "redirect:queryItems.action";
	//页面转发
	//return "forward:queryItems.action";
	return "success";
}

2.6.2.3 返回void

在controller方法形参上可以定义request和response，使用request或response指定响应结果：
1、使用request转向页面，如下：
request.getRequestDispatcher("页面路径").forward(request, response);

2、也可以通过response页面重定向：
response.sendRedirect("url")

3、也可以通过response指定响应结果，例如响应json数据如下：
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
response.getWriter().write("json串");

2.7 参数绑定

2.7.1 参数绑定过程

从客户端请求key/value数据，经过参数绑定，将key/value数据绑定到controller方法的形参上。
springmvc中，接收页面提交的数据是通过方法形参来接收,不是在controller类定义成员变更接收.

参数绑定组件：在spirngmvc早期版本使用PropertyEditor（只能将字符串传成java对象）
后期使用converter（进行任意类型的传换）,spirngmvc提供了很多**converter（转换器） **
在特殊情况下需要自定义converter:对日期数据(不同日期格式)绑定需要自定义converter

2.7.2 默认支持的数据对象(方法参数可以直接使用)

直接在controller方法形参上定义下边类型的对象，就可以使用这些对象。
在参数绑定过程中，如果遇到下边类型直接进行绑定。

HttpServletRequest
通过request对象获取请求信息
HttpServletResponse
通过response处理响应信息
HttpSession
通过session对象得到session中存放的对象
Model/ModelMap
model是一个接口，modelMap是一个接口实现。
作用：将model数据填充到request域。

@RequestMapping(value="/editItems",method={RequestMethod.POST,RequestMethod.GET})
//@RequestParam里边指定request传入参数名称和形参进行绑定。
//通过required属性指定参数是否必须要传入
//通过defaultValue可以设置默认值，如果id参数没有传入，将默认值和形参绑定。
public String editItems(Model model,@RequestParam(value="id",required=true) Integer items_id)throws Exception {
	
	//调用service根据商品id查询商品信息
	ItemsCustom itemsCustom = itemsService.findItemsById(items_id);
	
	//通过形参中的model将model数据传到页面
	//相当于modelAndView.addObject方法
	model.addAttribute("itemsCustom", itemsCustom);
	
	return "items/editItems";
}

2.7.3 简单类型(@RequestParam)

通过(@RequestParam)对简单类型的参数进行绑定。

如果不使用@RequestParam，要求request传入参数名称和controller方法的形参名称一致，方可绑定成功。
如果使用@RequestParam，不用限制request传入参数名称和controller方法的形参名称一致。
required设定是否必填,设置为true为必填，如果没有传入参数则会报错。
defaultValue设置默认值.

@RequestParam(value="id",required=true,defaultValue = "0")

2.7.4 pojo绑定

页面中input的name和controller的pojo形参中的属性名称一致，将页面中数据绑定到pojo。

2.7.4.1 属性名称和对象名称保持一致

public class ItemsQueryVo {
		private ItemsCustom itemsCustom;
}

<input name="itemsCustom.name" />

2.7.4.2 Date类型

对于controller形参中pojo对象，如果属性中有日期类型，需要自定义参数绑定。
将请求日期数据串传成日期类型，要转换的日期类型和pojo中日期属性的类型保持一致。
所以自定义参数绑定将日期串转成java.util.Date类型,需要向处理器适配器中注入自定义的参数绑定组件。

import org.springframework.core.convert.converter.Converter;

public class CustomDateConverter implements Converter<String,Date>{
	@Override
	public Date convert(String source) {
		//实现 将日期串转成日期类型(格式是yyyy-MM-dd HH:mm:ss)
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			//转成直接返回
			return simpleDateFormat.parse(source);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		//如果参数绑定失败返回null
		return null;
	}

}


- springmvc.xml

<!-- 自定义参数绑定 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
	<!-- 转换器 -->
	<property name="converters">
		<list>
			<!-- 日期类型转换 -->
			<bean class="course.springmvc.cast1_mybatis.src.controller.converter.CustomDateConverter"/>
		</list>
	</property>
</bean>

2.7.5 数组类型绑定

@RequestMapping("/deleteItems")
	public String deleteItems(Integer[] items_id) throws Exception {

		return "success";
	}

<c:forEach items="${itemsList }" var="item">
<tr>	
	<td><input type="checkbox" name="items_id" value="${item.id}"/></td>
	<td>${item.name }</td>
	<td>${item.price }</td>
	<td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
	<td>${item.detail }</td>
</tr>
</c:forEach>

2.7.6 list绑定

页面中的 itemsList[${status.index }]对应itemsQueryVo对象中的itemsList
ItemsQueryVo

public class ItemsQueryVo {
	//商品信息
	private Items items;
	private ItemsCustom itemsCustom;
	
	private List<ItemsCustom> itemsList;
}

Contrller

// 批量修改商品提交
// 通过ItemsQueryVo接收批量提交的商品信息，将商品信息存储到itemsQueryVo中itemsList属性中。
@RequestMapping("/editItemsAllSubmit")
public String editItemsAllSubmit(ItemsQueryVo itemsQueryVo)
		throws Exception {

	return "success";
}

c:forEach items="${itemsList}" var="item" varStatus="status">
<tr>	

	<td><input name="itemsList[${status.index }].name" value="${item.name }"/></td>
	<td><input name="itemsList[${status.index }].price" value="${item.price }"/></td>
	<td><input name="itemsList[${status.index }].createtime" value="<fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/>"/></td>
	<td><input name="itemsList[${status.index }].detail" value="${item.detail }"/></td>
</tr>
</c:forEach>

2.7.7 Map绑定

QueryVo 对象中有itemInfo属性的类型为Map
QueryVo

Public class QueryVo {
    private Map<String, Object> itemInfo = new HashMap<String, Object>();
    //get/set方法..
}

Contrller 入参 queryVo中包含有 itemInfo

public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
System.out.println(queryVo.getStudentinfo());
}

<tr>
    <td>商品信息：</td>
    <td>
        名称：<inputtype="text" name="itemInfo['name']"/>
        价格：<inputtype="text" name="itemInfo['price']"/>
</td>
</tr>

2.8 SpringMVC校验

- springmvc.xml
<mvc:annotation-driven conversion-service="conversionService"
validator="validator"></mvc:annotation-driven>
	
- CustomValidationMessages.properties
items.name.length.error=\u8bf7\u8f93\u51651\u523030\u4e2a\u5b57\u7b26\u7684\u5546\u54c1\u540d\u79f0


//分组
public interface ValidGroup1 {
    //接口中不需要定义任何方法，仅是对不同的校验规则进行分组
    //此分组只校验商品名称长度
}

- ItemsCustom.java

@Size(min=1,max=30,message="{items.name.length.error}",groups={ValidGroup1.class})
private String name;

- ItemsController
@Controller
// 为了对url进行分类管理 ，可以在这里定义根路径，最终访问url是根路径+子路径
// 比如：商品列表：/items/queryItems.action
@RequestMapping("/items")
public class ItemsController {

//在需要校验的pojo前边添加@Validated，在需要校验的pojo后边添加BindingResult bindingResult接收校验出错信息
//注意：@Validated和BindingResult bindingResult是配对出现，并且形参顺序是固定的（一前一后）。

	@RequestMapping("/editItemsSubmit")
	public String editItemsSubmit(
			Model model,
			HttpServletRequest request,
			Integer id,
			@ModelAttribute("items") @Validated(value = { ValidGroup1.class }) ItemsCustom itemsCustom,
			BindingResult bindingResult,
			MultipartFile items_pic//接收商品图片
			) throws Exception {

		// 获取校验错误信息
		if (bindingResult.hasErrors()) {
			// 输出错误信息
			List<ObjectError> allErrors = bindingResult.getAllErrors();

			for (ObjectError objectError : allErrors) {
				// 输出错误信息
				System.out.println(objectError.getDefaultMessage());

			}
			// 将错误信息传到页面
			model.addAttribute("allErrors", allErrors);
			
			//可以直接使用model将提交pojo回显到页面
			model.addAttribute("items", itemsCustom);
			
			// 出错重新到商品修改页面
			return "items/editItems";
		}
 
	}
}

- edit.jsp

<!-- 显示错误信息 -->
<c:if test="${allErrors!=null }">
	<c:forEach items="${allErrors }" var="error">
	${ error.defaultMessage}<br/>
</c:forEach>
</c:if>

2.9 数据回显

ModelAttribute

- controller
// 商品分类
//itemtypes表示最终将方法返回值放在request中的key
@ModelAttribute("itemtypes")
public Map<String, String> getItemTypes() {

	Map<String, String> itemTypes = new HashMap<String, String>();
	itemTypes.put("101", "数码");
	itemTypes.put("102", "母婴");

	return itemTypes;
}

- jsp
<select name="itemtype">
	<c:forEach items="${itemtypes }" var="itemtype">
		<option value="${itemtype.key }">${itemtype.value }</option>		
	</c:forEach>
</select>

Model

- ItemsController
@Controller
// 为了对url进行分类管理 ，可以在这里定义根路径，最终访问url是根路径+子路径
// 比如：商品列表：/items/queryItems.action
@RequestMapping("/items")
public class ItemsController {

//在需要校验的pojo前边添加@Validated，在需要校验的pojo后边添加BindingResult bindingResult接收校验出错信息
//注意：@Validated和BindingResult bindingResult是配对出现，并且形参顺序是固定的（一前一后）。

	@RequestMapping("/editItemsSubmit")
	public String editItemsSubmit(
			Model model,
			HttpServletRequest request,
			Integer id,
			@ModelAttribute("items") @Validated(value = { ValidGroup1.class }) ItemsCustom itemsCustom,
			BindingResult bindingResult,
			MultipartFile items_pic//接收商品图片
			) throws Exception {

		// 获取校验错误信息
		if (bindingResult.hasErrors()) {
			// 输出错误信息
			List<ObjectError> allErrors = bindingResult.getAllErrors();

			for (ObjectError objectError : allErrors) {
				// 输出错误信息
				System.out.println(objectError.getDefaultMessage());

			}
			// 将错误信息传到页面
			model.addAttribute("allErrors", allErrors);
			
			//可以直接使用model将提交pojo回显到页面
			model.addAttribute("items", itemsCustom);
			
			// 出错重新到商品修改页面
			return "items/editItems";
		}
 
	}
}

- edit.jsp

<!-- 显示错误信息 -->
<c:if test="${allErrors!=null }">
	<c:forEach items="${allErrors }" var="error">
	${ error.defaultMessage}<br/>
</c:forEach>
</c:if>

2.10 异常处理

public class CustomException extends Exception {
	//异常信息
	public String message;
	
	public CustomException(String message){
		super(message);
		this.message = message;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
}




public class CustomExceptionResolver implements HandlerExceptionResolver {
	@Override
	public ModelAndView resolveException(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex) {
		//handler就是处理器适配器要执行Handler对象（只有method）
		
//		解析出异常类型
//		如果该 异常类型是系统 自定义的异常，直接取出异常信息，在错误页面展示
//		String message = null;
//		if(ex instanceof CustomException){
//			message = ((CustomException)ex).getMessage();
//		}else{
			如果该 异常类型不是系统 自定义的异常，构造一个自定义的异常类型（信息为“未知错误”）
//			message="未知错误";
//		}
		
		//上边代码变为
		CustomException customException = null;
		if(ex instanceof CustomException){
			customException = (CustomException)ex;
		}else{
			customException = new CustomException("未知错误");
		}
		
		//错误信息
		String message = customException.getMessage();
		
		ModelAndView modelAndView = new ModelAndView();
		
		//将错误信息传到页面
		modelAndView.addObject("message", message);
		
		//指向错误页面
		modelAndView.setViewName("error");
		return modelAndView;
	}

}

2.11 上传图片

form中提交enctype="multipart/form-data"的数据时，需要springmvc对multipart类型的数据进行解析

<!-- 文件上传 -->
<bean id="multipartResolver"
	class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
	<!-- 设置上传文件的最大尺寸为5MB -->
	<property name="maxUploadSize">
		<value>5242880</value>
	</property>
</bean>

2.12 json交互

1. 客户端请求–>请求的是json串需要指定contentType=application/json—>@RequestBody将json串转成java对象----->@ResponseBody将java对象转成json串输出
1. 客户端请求–>请求的是key/valuecontentType=application/x-www-form-urlen—不需要@RequestBody将json串转成java对象 ----->@ResponseBody将java对象转成json串输出

//请求json串(商品信息)，输出json(商品信息)
//@RequestBody将请求的商品信息的json串转成itemsCustom对象
//@ResponseBody将itemsCustom转成json输出
@RequestMapping("/requestJson")
public @ResponseBody ItemsCustom requestJson(@RequestBody ItemsCustom itemsCustom){
	
	//@ResponseBody将itemsCustom转成json输出
	return itemsCustom;
}

//请求key/value，输出json
@RequestMapping("/responseJson")
public @ResponseBody ItemsCustom responseJson(ItemsCustom itemsCustom){
	
	//@ResponseBody将itemsCustom转成json输出
	return itemsCustom;
}

2.13 RESTful支持

2.13.1 RESTful简介

RESTful架构，就是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。RESTful（即Representational State Transfer的缩写）其实是一个开发理念，是对http的很好的诠释。
1、对url进行规范，写RESTful格式的url
非REST的url：http://…/queryItems.action?id=001&type=T01
REST的url风格：http://…/items/001
特点：url简洁，将参数通过url传到服务端
2、http的方法规范
不管是删除、添加、更新。。使用url是一致的，如果进行删除，需要设置http的方法为delete，同理添加

后台controller方法：判断http方法，如果是delete执行删除，如果是post执行添加。

3、对http的contentType规范
请求时指定contentType，要json数据，设置成json格式的type

示例

//查询商品信息，输出json
///itemsView/{id}里边的{id}表示占位符，通过@PathVariable获取占位符中的参数，
//如果占位符中的名称和形参名一致，在@PathVariable可以不指定名称
@RequestMapping("/itemsView/{id}")
public @ResponseBody ItemsCustom itemsView(@PathVariable("id") Integer id)throws Exception{
	
	//调用service查询商品信息
	ItemsCustom itemsCustom = itemsService.findItemsById(id);
	
	return itemsCustom;
	
}

@RequestMapping(value="/ itemsView/{id}")：{×××}占位符，请求的URL可以是“/viewItems/1”或“/viewItems/2”，通过在方法中使用@PathVariable获取{×××}中的×××变量。
@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。
如果RequestMapping中表示为"/ itemsView /{id}"，id和形参名称一致，@PathVariable不用指定名称。

2.14 拦截器

2.14.2 简介

2.14.2 示例


public class HandlerInterceptor1 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		
		System.out.println("HandlerInterceptor1...preHandle");
		
		//return false表示拦截，不向下执行
		//return true表示放行
		return true;
	}

	//进入Handler方法之后，返回modelAndView之前执行
	//应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
	@Override
	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		
		System.out.println("HandlerInterceptor1...postHandle");
		
	}

	//执行Handler完成执行此方法
	//应用场景：统一异常处理，统一日志处理
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		
		System.out.println("HandlerInterceptor1...afterCompletion");
	}

}



public class HandlerInterceptor2 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		
		System.out.println("HandlerInterceptor2...preHandle");
		
		//return false表示拦截，不向下执行
		//return true表示放行
		return true;
	}

	//进入Handler方法之后，返回modelAndView之前执行
	//应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
	@Override
	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		
		System.out.println("HandlerInterceptor2...postHandle");
		
	}

	//执行Handler完成执行此方法
	//应用场景：统一异常处理，统一日志处理
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		
		System.out.println("HandlerInterceptor2...afterCompletion");
	}

}


- springmvc.xml
<!--拦截器 -->
<mvc:interceptors>
	<!--多个拦截器,顺序执行 -->
	<!-- 登陆认证拦截器 -->
	<mvc:interceptor>
		<mvc:mapping path="/**"/>
		<bean class="cn.interceptor.LoginInterceptor"></bean>
	</mvc:interceptor>
	<mvc:interceptor>
		<!-- /**表示所有url包括子url路径 -->
		<mvc:mapping path="/**"/>
		<bean class="cn.interceptor.HandlerInterceptor1"></bean>
	</mvc:interceptor>
	<mvc:interceptor>
		<mvc:mapping path="/**"/>
		<bean class="cn.interceptor.HandlerInterceptor2"></bean>
	</mvc:interceptor>
</mvc:interceptors>

2.14.3 多拦截器测试

2.14.3.1 两个拦截器都放行

HandlerInterceptor1...preHandle
HandlerInterceptor2...preHandle

HandlerInterceptor2...postHandle
HandlerInterceptor1...postHandle

HandlerInterceptor2...afterCompletion
HandlerInterceptor1...afterCompletion

2.14.3.2 拦截器1放行，拦截器2不放行

HandlerInterceptor1...preHandle
HandlerInterceptor2...preHandle
HandlerInterceptor1...afterCompletion

总结：
拦截器1放行，拦截器2 preHandle才会执行。
拦截器2 preHandle不放行，拦截器2 postHandle和afterCompletion不会执行。
只要有一个拦截器不放行，postHandle不会执行。

2.14.3.拦截器1不放行，拦截器2不放行

HandlerInterceptor1...preHandle

拦截器1 preHandle不放行，postHandle和afterCompletion不会执行。
拦截器1 preHandle不放行，拦截器2不执行。

2.10 核心精简总结

2.10.1 DispatcherServlet

DispatcherServlet 前端控制器：接收request，进行response

2.10.2 HandlerMapping

HandlerMapping 处理器映射器：根据url查找Handler。（可以通过xml配置方式，注解方式）

2.10.3 HandlerAdapter

HandlerAdapter处理器适配器：根据特定规则去执行Handler，编写Handler时需要按照HandlerAdapter的要求去编写。

2.10.4 Handler

Handler处理器（后端控制器）：需要程序员去编写，常用注解开发方式。
Handler处理器执行后结果是ModelAndView，具体开发时Handler返回方法值类型包括：ModelAndView、String（逻辑视图名）、void（通过在Handler形参中添加request和response，类似原始. servlet开发方式，注意：可以通过指定response响应的结果类型实现json数据输出）

2.10.5 View resolver

View resolver视图解析器：根据逻辑视图名生成真正的视图（在springmvc中使用View对象表示）

2.10.6 View视图

View视图:jsp页面，仅是数据展示，没有业务逻辑。

2.10.7 注解开发

使用注解方式的处理器映射器和适配器：
在实际开发，使用mvc:annotation-driven代替上边处理器映射器和适配器配置。

2.10.8 Controller

2.10.8.1 controller注解

@controller注解必须要加，作用标识类是一个Handler处理器。
@requestMapping注解必须要加，作用：
1、对url和Handler的方法进行映射。
2、可以窄化请求映射，设置Handler的根路径，url就是根路径+子路径请求方式
3、可以限制http请求的方法
映射成功后，springmvc框架生成一个Handler对象，对象中只包括一个映射成功的method。

2.10.8.2 注解开发中参数绑定：

将request请求过来的key/value的数据（理解一个串），通过转换（参数绑定的一部分），将key/value串转成形参，将转换后的结果传给形参（整个参数绑定过程）。
springmvc所支持参数绑定：

1、默认支持很多类型，HttpServletRequest、response、session、model/modelMap(将模型数据填充到request域)
2、支持简单数据类型，整型、字符串、日期。
只要保证request请求的参数名和形参名称一致，自动绑定成功,
如果request请求的参数名和形参名称不一致，可以使用@RequestParam（指定request请求的参数名），@RequestParam加在形参的前边。
3、支持pojo类型
只要保证request请求的参数名称和pojo中的属性名一致，自动将request请求的参数设置到pojo的属性中。
注意：形参中即有pojo类型又有简单类型，参数绑定互不影响。
自定义参数绑定：
日期类型绑定自定义：
定义的Converter<源类型，目标类型>接口实现类，比如：
Converter<String,Date>表示：将请求的日期数据串转成java中的日期类型。
注意：要转换的目标类型一定和接收的pojo中的属性类型一致,将定义的Converter实现类注入到处理器适配器中。

4.疑难总结

4.1 post乱码

4.1.1 在web.xml添加post乱码filter

在web.xml中加入：

<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

以上可以解决post请求乱码问题。

4.2 get乱码

对于get请求中文参数出现乱码解决方法有两个：

4.2.1

修改tomcat配置文件添加编码与工程编码一致，如下：

<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

4.2.2

另外一种方法对参数进行重新编码：

String userName new 
String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")

ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码

5.源码小析

5.1 DispatcherServlet

package org.springframework.web.servlet;

public class DispatcherServlet extends FrameworkServlet {
    
    ***
    
    //前端控制器接收请求
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ***
        //查找Handler(前端控制器调用处理器映射器查找 Handler)
        mappedHandler = getHandler(processedRequest);
        ***
        
        //得到 HandlerAdapter
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
        ***
        //得到ModelAndView
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        ***
        
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        --->render(mv, request, response);
        
        ***
    }
    
    
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    	for (HandlerMapping hm : this.handlerMappings) {
    		if (logger.isTraceEnabled()) {
    			logger.trace(
    					"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
    		}
    		HandlerExecutionChain handler = hm.getHandler(request);
    		if (handler != null) {
    			return handler;
    		}
    	}
    	return null;
    }
	
    ***
}

5.1 HandlerAdapter

package org.springframework.web.servlet;

public interface HandlerAdapter {

    boolean supports(Object handler);

	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

	long getLastModified(HttpServletRequest request, Object handler);
}

5.1.1 SimpleControllerHandlerAdapter

支持Controller

public class SimpleControllerHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof Controller);
	}

	@Override
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return ((Controller) handler).handleRequest(request, response);
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}

}

配合使用

public class ItemsController1 implements Controller {
	@Override
	public ModelAndView handleRequest(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		//调用service查找 数据库，查询商品列表，这里使用静态数据模拟
		List<Items> itemsList = new ArrayList<Items>();

		//返回ModelAndView
		ModelAndView modelAndView =  new ModelAndView();
		//相当 于request的setAttribut，在jsp页面中通过itemsList取数据
		modelAndView.addObject("itemsList", itemsList);
		
		//指定视图
		modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

		return modelAndView;
	}

}

5.1.2 HttpRequestHandlerAdapter

public class HttpRequestHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}

	@Override
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		((HttpRequestHandler) handler).handleRequest(request, response);
		return null;
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}

}

5.2 HandlerMapping


public interface HandlerMapping {
	String BEST_MATCHING_HANDLER_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingHandler";

	String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";

 
	String BEST_MATCHING_PATTERN_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingPattern";

 
	String INTROSPECT_TYPE_LEVEL_MAPPING = HandlerMapping.class.getName() + ".introspectTypeLevelMapping";

 
	String URI_TEMPLATE_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".uriTemplateVariables";

 
	String MATRIX_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".matrixVariables";

 
	String PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE = HandlerMapping.class.getName() + ".producibleMediaTypes";

 
	HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

}

5.2.1 MatchableHandlerMapping

public interface MatchableHandlerMapping extends HandlerMapping {
	RequestMatchResult match(HttpServletRequest request, String pattern);
}

5.2.2 RequestMappingHandlerMapping


public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
		implements MatchableHandlerMapping, EmbeddedValueResolverAware {
		}

5.2.3 BeanNameUrlHandlerMapping

public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
}

配合使用:

<!-- 配置Handler -->
	<bean id="itemsController1" name="/queryItems_test.action" class="course.springmvc.cast1.srcs.controller.ItemsController1" />

5.3 Controller

package org.springframework.web.servlet.mvc;

public interface Controller {
	ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

整理于网络视频

bobshute

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring MVC小总结

1.基本原理1.1 Spring MVC在Spring中位置1.2 基本原理前端控制器、处理器映射器、处理器适配器、视图解析器第一步：发起请求到前端控制器(DispatcherServlet)第二步：前端控制器请求HandlerMapping查找 Handler可以根据xml配置、注解进行查找第三步：处理器映射器HandlerMapping向前端控制器返回Hand...
复制链接

扫一扫