【学习笔记】springMVC--01

时间  2020-12-08
标签 前端 java 程序员 web spring sql 数据库 apache 后端 spring-mvc 栏目 Spring 繁體版
原文   原文链接

1.springMVC介绍

springMVC是一个web层框架，是Spring框架的一部分。前端

2.搭建springMVC框架

（1）建立web工程，导入jar包java

（2）加入配置文件程序员

（2.1）建立springmvc.xmlweb

建立SpringMVC的核心配置文件，SpringMVC自己就是Spring的子项目，对Spring兼容性很好，不须要作不少配置。这里只配置一个Controller扫描就能够了，让Spring对页面控制层Controller（就是web层）进行管理。spring

<?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:p="http://www.springframework.org/schema/p"
	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-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!-- 配置controller扫描包 -->
	<context:component-scan base-package="cn.itcast.springmvc.controller" />

</beans>

（2.2）在web.xml中配置前端控制器sql

<?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">
	<display-name>springmvc-first</display-name>

	<!-- 配置SpringMVC前端控制器 -->
	<servlet>
		<servlet-name>springmvc-first</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 指定SpringMVC配置文件 -->
		<!-- SpringMVC的配置文件的默认路径是/WEB-INF/${servlet-name}-servlet.xml -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
	</servlet>

	<servlet-mapping>
		<servlet-name>springmvc-first</servlet-name>
		<!-- 设置全部以action结尾的请求进入SpringMVC -->
		<url-pattern>*.action</url-pattern>
	</servlet-mapping>
</web-app>

（3）加入页面，复制到工程的/WEB-INF/jsp目录下数据库

（4）实现案例：显示商品列表apache

（4.1）建立商品实体类Item.java后端

（4.2）建立包cn.itcast.springmvc.controller，就是springmvc.xml扫描的包。包中建立ItemController.java
ItemController是一个普通的java类，不须要实现任何接口。须要在类上添加@Controller注解，把Controller交由Spring管理。在方法上面添加@RequestMapping注解，里面指定请求的url。其中“.action”能够加也能够不加。spring-mvc

@Controller
public class ItemController {

	// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配
	// action能够写也能够不写
	@RequestMapping("/itemList.action")
	public ModelAndView queryItemList() {
		// 建立页面须要显示的商品数据
		List<Item> list = new ArrayList<>();
		list.add(new Item(1, "1华为 荣耀8", 2399, new Date(), "质量好！1"));
		list.add(new Item(2, "2华为 荣耀8", 2399, new Date(), "质量好！2"));

		// 建立ModelAndView，用来存放数据和视图
		ModelAndView modelAndView = new ModelAndView();
		// 设置数据到模型中
		modelAndView.addObject("list", list);
		// 设置视图jsp，须要设置视图的物理地址
		modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");

		return modelAndView;
	}
}

3.springMVC的架构

（1）架构图

（2）架构流程：

  1. 用户发送请求至前端控制器DispatcherServlet
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
  3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(若是有则生成)一并返回给DispatcherServlet。
  4. DispatcherServlet经过HandlerAdapter处理器适配器调用处理器
  5. 执行处理器(Controller，也叫后端控制器)。
  6. Controller执行完成返回ModelAndView
  7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
  8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器
  9. ViewReslover解析后返回具体View
  10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
  11. DispatcherServlet响应用户

（3）组件说明：

  • DispatcherServlet：前端控制器

用户请求到达前端控制器，它就至关于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在下降了组件之间的耦合性。

  • HandlerMapping：处理器映射器

HandlerMapping负责根据用户请求url找到Handler，即处理器，springmvc提供了不一样的映射器实现不一样的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

  • Handler：处理器

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
因为Handler涉及到具体的用户业务请求，因此通常状况须要程序员根据业务需求开发Handler。

  • HandlAdapter：处理器适配器

经过HandlerAdapter对处理器进行执行，这是适配器模式的应用，经过扩展适配器能够对更多类型的处理器进行执行。
下图是许多不一样的适配器，最终均可以使用usb接口链接

  • ViewResolver：视图解析器

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果经过页面展现给用户。

  • View：视图

springmvc框架提供了不少的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。咱们最经常使用的视图就是jsp。
通常状况下须要经过页面标签或页面模版技术将模型数据经过页面展现给用户，须要由程序员根据业务需求开发具体的页面。

说明：在springmvc的各个组件中，处理器映射器（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）称为springmvc的三大组件。
须要用户开发的组件有handler、view

（4）默认加载的组件

咱们没有作任何配置，就可使用这些组件，由于框架已经默认加载这些组件了。

（5）组件扫描器

使用组件扫描器省去在spring容器配置每一个Controller类的繁琐。
使用<context:component-scan>自动扫描标记@Controller的控制器类，在springmvc.xml配置文件中配置以下：

<!-- 配置controller扫描包，多个包之间用,分隔 -->

<context:component-scan base-package="cn.itcast.springmvc.controller" />

（6）配置处理器映射器、处理器适配器

（6.1）

注解式处理器映射器，对类中标记了@ResquestMapping的方法进行映射。根据@ResquestMapping定义的url匹配@ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器。HandlerMethod对象中封装url对应的方法Method。
从spring3.1版本开始，废除了DefaultAnnotationHandlerMapping的使用，推荐使用RequestMappingHandlerMapping完成注解式处理器映射。在springmvc.xml配置文件中配置以下：

<!-- 配置处理器映射器 -->
<bean
	class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />

注解式处理器适配器，对标记@ResquestMapping的方法进行适配。从spring3.1版本开始，废除了AnnotationMethodHandlerAdapter的使用，推荐使用RequestMappingHandlerAdapter完成注解式处理器适配。在springmvc.xml配置文件中配置以下：

<!-- 配置处理器适配器 -->
<bean
	class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" />

（6.2）直接配置处理器映射器和处理器适配器比较麻烦，可使用注解驱动来加载。SpringMVC使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter，能够在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。

<!-- 注解驱动 -->
<mvc:annotation-driven />

（7）配置视图解析器

视图解析器使用SpringMVC框架默认的InternalResourceViewResolver，这个视图解析器支持JSP视图解析。
在springmvc.xml配置文件中配置以下：

<!-- 配置视图解析器 -->
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置逻辑视图的前缀 -->
		<property name="prefix" value="/WEB-INF/jsp/" />
		<!-- 配置逻辑视图的后缀 -->
		<property name="suffix" value=".jsp" />
	</bean>

逻辑视图名须要在controller中的ModelAndView指定，好比逻辑视图名为ItemList，则最终返回的jsp视图地址:“WEB-INF/jsp/itemList.jsp”
配置后，modelAndView.setViewName("WEB-INF/jsp/itemList.jsp")能够改成modelAndView.setViewName("itemList");

4.整合Mybatis

整合目标：控制层采用springmvc、持久层使用mybatis实现。
（1）须要的jar包：

  1. spring（包括springmvc）
  2. mybatis
  3. mybatis-spring整合包
  4. 数据库驱动
  5. 第三方链接池。

（2）整合思路

Dao层：

  1. SqlMapConfig.xml，空文件便可，可是须要文件头。
  2. applicationContext-dao.xml
    1. 数据库链接池
    2. SqlSessionFactory对象，须要spring和mybatis整合包下的。
    3. 配置mapper文件扫描器。

Service层：

  1. applicationContext-service.xml包扫描器，扫描@service注解的类。
  2. applicationContext-trans.xml配置事务。

Controller层：

  1. Springmvc.xml
    1. 包扫描器，扫描@Controller注解的类。
    2. 配置注解驱动
    3. 配置视图解析器

Web.xml文件：

  1. 配置spring
  2. 配置前端控制器。

（3）建立web工程

（3.1）使用逆向工程生成pojo类和mapper文件，不须要配置别名。sqlMapConfig.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

</configuration>

（3.2）applicationContext-dao.xml：数据源，SQLSessionFactory，mapper扫描

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

	<!-- 加载配置文件 -->
	<context:property-placeholder location="classpath:db.properties" />

	<!-- 数据库链接池 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="maxActive" value="10" />
		<property name="maxIdle" value="5" />
	</bean>

	<!-- 配置SqlSessionFactory -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 数据库链接池 -->
		<property name="dataSource" ref="dataSource" />
		<!-- 加载mybatis的全局配置文件 -->
		<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />
	</bean>

	<!-- 配置Mapper扫描 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- 配置Mapper扫描包 -->
		<property name="basePackage" value="cn.itcast.ssm.mapper" />
	</bean>

</beans>

（3.3）applicationContext-service.xml：

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

	<!-- 配置service扫描 -->
	<context:component-scan base-package="cn.itcast.ssm.service" />

</beans>

（3.4）applicationContext-trans.xml：配置事务。

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

	<!-- 事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 数据源 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="query*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>

	<!-- 切面 -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice"
			pointcut="execution(* cn.itcast.ssm.service.*.*(..))" />
	</aop:config>
织入...
</beans>

（3.5）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:p="http://www.springframework.org/schema/p"
	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-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!-- 配置controller扫描包 -->
	<context:component-scan base-package="cn.itcast.ssm.controller" />

	<!-- 注解驱动 -->
	<mvc:annotation-driven />

	<!-- 配置视图解析器 -->
	<bean
	class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置逻辑视图的前缀 -->
		<property name="prefix" value="/WEB-INF/jsp/" />
		<!-- 配置逻辑视图的后缀 -->
		<property name="suffix" value=".jsp" />
	</bean>

</beans>

（3.6）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">
	<display-name>springmvc-web</display-name>

	<!-- 配置spring -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring/applicationContext*.xml</param-value>
	</context-param>

	<!-- 使用监听器加载Spring配置文件 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 配置SrpingMVC的前端控制器 -->
	<servlet>
		<servlet-name>springmvc-web</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring/springmvc.xml</param-value>
		</init-param>
	</servlet>

	<servlet-mapping>
		<servlet-name>springmvc-web</servlet-name>
		<!-- 配置全部以action结尾的请求进入SpringMVC -->
		<url-pattern>*.action</url-pattern>
	</servlet-mapping>

</web-app>

（3.7）加入jsp页面。WEB-INF目录下

（4）实现商品列表展现

（4.1）dao层开发

使用逆向工程生成代码。

（4.2）Service层开发

ItemService接口，ItemServiceImpl实现类

@Service
public class ItemServiceImpl implements ItemService {

	@Autowired
	private ItemMapper itemMapper;

	@Override
	public List<Item> queryItemList() {
		// 从数据库查询商品数据
		List<Item> list = itemMapper.selectByExample(null);
		return list;
	}
}

（4.3）controller层开发（web层）

@Controller
public class ItemController {

	@Autowired
	private ItemService itemService;

	/**
	 * 显示商品列表
	 * 
	 * @return
	 */
	@RequestMapping("/itemList")
	public ModelAndView queryItemList() {
		// 获取商品数据
		List<Item> list = this.itemService.queryItemList();

		ModelAndView modelAndView = new ModelAndView();
		// 把商品数据放到模型中
		modelAndView.addObject("itemList", list);
		// 设置逻辑视图
		modelAndView.setViewName("itemList");

		return modelAndView;
	}

}

5.参数绑定

（5.0）绑定简单类型

当请求的参数名称和处理器形参名称一致时，会将请求参数与形参进行绑定。这样，从Request取参数的方法就能够进一步简化。（如5.1中的Integer id）

支持的数据类型：
参数类型推荐使用包装数据类型，由于基础数据类型不能够为null

  • 整形：Integer、int
  • 字符串：String
  • 单精度：Float、float
  • 双精度：Double、double
  • 布尔型：Boolean、boolean

说明：对于布尔类型的参数，请求的参数值为true或false。或者1或0
请求url：http://localhost:8080/xxx.action?id=2&status=false
处理器方法：
public String editItem(Model model,Integer id,Boolean status)

补充：使用@RequestParam经常使用于处理简单类型的绑定。

value：参数名字，即入参的请求参数名字，如value=“itemId”表示请求的参数     区中的名字为itemId的参数的值将传入
required：是否必须，默认是true，表示请求中必定要有相应的参数，不然将报错TTP Status 400 - Required Integer parameter 'XXXX' is not present
defaultValue：默认值，表示若是请求中没有同名参数时的默认值

@RequestMapping("/itemEdit")
public String queryItemById(@RequestParam(value = "itemId", required = true, defaultValue = "1") Integer id,
		ModelMap modelMap) {
	// 根据id查询商品数据
	......
}

（5.1）默认支持的参数类型

页面点击修改按钮，发起请求：http://127.0.0.1:8080/springmvc-web/itemEdit.action?id=${item.id}
须要从请求的参数中把请求的id取出来。id包含在Request对象中。能够从Request对象中取id。
想得到Request对象只须要在Controller方法的形参中添加一个参数便可。Springmvc框架会自动把Request对象传递给方法。以下代码：

@RequestMapping("/itemEdit.action")
	public ModelAndView toEdit(Integer id,HttpServletRequest request) {
//		String id = request.getParameter("id");
//		Items item = itemsService.queryItemById(Integer.valueOf(id));//若用形参直接接收，不须要手动转换

		Items item = itemsService.queryItemById(id);
		ModelAndView mv=new ModelAndView();
		mv.addObject("item", item);
		mv.setViewName("editItem");
		return mv;
	}

处理器形参中添加以下类型的参数，处理器适配器会默认识别并进行赋值：HttpServletRequest、HttpServletResponse、HttpSession

（5.2）Model和ModelMap

除了ModelAndView之外，还可使用Model来向页面传递数据，Model是一个接口，在参数里直接声明model便可。
若是使用Model则能够不使用ModelAndView，Model对象能够向页面传递数据，View对象则可使用String返回值替代。
不论是Model仍是ModelAndView，其本质都是使用Request对象向jsp传递数据。
代码实现：

@RequestMapping("/itemEdit")
public String queryItemById(HttpServletRequest request, Model model) {
	// 从request中获取请求参数
	String strId = request.getParameter("id");
	Integer id = Integer.valueOf(strId);

	// 根据id查询商品数据
	Item item = this.itemService.queryItemById(id);

	// 把结果传递给页面
	// ModelAndView modelAndView = new ModelAndView();
	// 把商品数据放在模型中
	// modelAndView.addObject("item", item);
	// 设置逻辑视图
	// modelAndView.setViewName("itemEdit");

	// 把商品数据放在模型中
	model.addAttribute("item", item);

	return "itemEdit";//返回的也是jsp页面
}

ModelMap是Model接口的实现类，也能够经过ModelMap向页面传递数据。使用Model和ModelMap的效果同样，若是直接使用Model，springmvc会实例化ModelMap。

（5.3）绑定pojo类型

若是提交的参数不少，或者提交的表单中的内容不少的时候,可使用简单类型接受数据,也可使用pojo接收数据。
要求：pojo对象中的属性名和表单中input的name属性一致。

@RequestMapping("/updateItem")
public String updateItem(Item item) {
	// 调用服务更新商品
	itemService.updateItemById(item);
	// 返回逻辑视图
	return "success";
}

注意：提交的表单中不要有日期类型的数据，不然会报400错误。若是想提交日期类型的数据须要用到后面的自定义参数绑定的内容。

表单提交乱码解决方法：

web.xml：

<!-- 解决post乱码问题 -->
	<filter>
		<filter-name>encoding</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<!-- 设置编码参是UTF8 -->
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

对于get请求中文参数出现乱码解决方法有两个：
修改tomcat配置文件添加编码与工程编码一致，以下：
<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
另一种方法对参数进行从新编码：
String userName =new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")
ISO8859-1是tomcat默认编码，须要将tomcat编码后的内容按utf-8编码

（5.4）绑定包装pojo类型

包装类：

public class QueryVo {
	private Item item;
set/get。。。
}

表单提交的是QueryVo的属性的属性

@RequestMapping("/updateitem.action")
//	public void updateItem(Items item,HttpServletRequest request,HttpServletResponse response) throws Exception {
	public void updateItem(QueryVo vo,HttpServletRequest request,HttpServletResponse response) throws Exception {
		itemsService.updateItem(vo.getItem());
		request.getRequestDispatcher("/queryItemsList.action").forward(request, response);
	}

（5.5）自定义参数绑定

商品修改页修改日期，根据业务需求自定义日期格式

因为日期数据有不少种格式，springmvc没办法把字符串转换成日期类型。因此须要自定义参数绑定。

前端控制器接收到请求后，找到注解形式的处理器适配器，对RequestMapping标记的方法进行适配，并对方法中的形参进行参数绑定。能够在springmvc处理器适配器上自定义转换器Converter进行参数绑定。

通常使用<mvc:annotation-driven/>注解驱动加载处理器适配器，能够在此标签上进行配置。

a.自定义转换器converter：（springMVC根据这个接口中的Date类型，拿到Date类型的数据以后会放到这里执行）

//Converter<S, T>
//S:source,须要转换的源的类型
//T:target,须要转换的目标类型
public class DateConverter implements Converter<String, Date> {

	@Override
	public Date convert(String source) {
		try {
			// 把字符串转换为日期类型
			SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
			Date date = simpleDateFormat.parse(source);

			return date;
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 若是转换异常则返回空
		return null;
	}
}

b.配置converter

<!-- 配置注解驱动 -->
<mvc:annotation-driven conversion-service="conversionService" />

<!-- 转换器配置 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
	<property name="converters">
		<set>
			<bean class="cn.itcast.springmvc.converter.DateConverter" />
            <bean class="这里能够配置多个转换器" />
		</set>
	</property>
</bean>

配置完成后，在修改页面修改日期提交，转换器拿到日期的字符串，转换成自定义的格式保存到数据库。

6.springMVC和Struts2的不一样

  1. springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过滤器。
  2. springmvc是基于方法开发(一个url对应一个方法)，请求参数传递到方法的形参，能够设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是经过类的属性，只能设计为多例。
  3. Struts采用值栈存储请求和响应的数据，经过OGNL存取数据， springmvc经过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据经过request域传输到页面。Jsp视图解析器默认使用jstl。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程