SpringMVC

SpringMVC

概念

Spring web mvc和Struts2都属于表现层的框架,它是Spring框架的一部分

springmvc和Struts2的区别

1、springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。
2、springmvc是基于方法开发(一个url对应一个方法)，请求参数传递到方法的形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。
Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。Jsp视图解析器默认使用jstl

springMvc的处理流程

框架结构

架构流程

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响应用户

SpringMVC组件

以下组件通常使用框架提供实现：
1.DispatcherServlet：前端控制器
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

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

3.Handler：处理器
Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

4.HandlAdapter：处理器适配器
通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

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

6.View：视图
springmvc框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是jsp。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

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

注解映射器和适配器

1.组件扫描器
    使用组件扫描器省去在spring容器配置每个controller类的繁琐。使用<context:component-scan>自动扫描标记@controller的控制器类，配置如下：
    <!-- 扫描controller注解,多个包中间使用逗号分隔 -->
    <context:component-scan base-package="cn.itcast.springmvc.controller.first"/>

2.RequestMappingHandlerMapping
    注解式处理器映射器，对类中标记@ResquestMapping的方法进行映射，根据ResquestMapping定义的url匹配ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器，HandlerMethod对象中封装url对应的方法Method。 
从spring3.1版本开始，废除了DefaultAnnotationHandlerMapping的使用，推荐使用RequestMappingHandlerMapping完成注解式处理器映射。
配置如下：
    <!--注解映射器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/> 
   注解描述：
@RequestMapping：定义请求url到处理器功能方法的映射 

 3.RequestMappingHandlerAdapter
注解式处理器适配器，对标记@ResquestMapping的方法进行适配。
从spring3.1版本开始，废除了AnnotationMethodHandlerAdapter的使用，推荐使用RequestMappingHandlerAdapter完成注解式处理器适配。
配置如下：
<!--注解适配器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

4.<mvc:annotation-driven>
springmvc使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter，可用在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置

视图解析器

在springmvc.xml文件配置如下：
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass"
              value="org.springframework.web.servlet.view.JstlView" />
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
</bean>
InternalResourceViewResolver：支持JSP视图解析
viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，所以classpath中必须包含jstl的相关jar 包。此属性可以不设置，默认为JstlView。
prefix 和suffix：查找视图页面的前缀和后缀，最终视图的址为：
前缀+逻辑视图名+后缀，逻辑视图名需要在controller中返回ModelAndView指定，比如逻辑视图名为hello，则最终返回的jsp视图地址 “WEB-INF/jsp/hello.jsp”

SpringMVC整合mybatis

整合思路

Dao层：
1、SqlMapConfig.xml，空文件即可。需要文件头。
2、applicationContext-dao.xml。
a)数据库连接池
b)SqlSessionFactory对象，需要spring和mybatis整合包下的。
c)配置mapper文件扫描器。

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

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

Web.xml
配置前端控制器。

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>

applicationContext-dao.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">

    <!-- 加载配置文件 -->
    <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>
    <!-- mapper配置 -->
    <!-- 让spring管理sqlsessionfactory 使用mybatis和spring整合包中的 -->
    <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">
        <property name="basePackage" value="cn.itcast.springmvc.mapper"/>
    </bean>
</beans>

Db.properties配置

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springmvc?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

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">

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

</beans

applicationContext-transaction.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:attributes>
    </tx:advice>
    <!-- 切面 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice"
            pointcut="execution(* cn.itcast.springmvc.service.*.*(..))" />
    </aop:config>
</beans>

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:dubbo="http://code.alibabatech.com/schema/dubbo" 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://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.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" />
    <!-- 加载注解驱动 -->
    <mvc:annotation-driven/>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <!-- jsp前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- jsp后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

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>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>
    <!-- 加载spring容器 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext-*.xml</param-value>
    </context-param>
    <!--  -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 前端控制器 -->
    <servlet>
        <servlet-name>springmvc</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</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>
</web-app>

代码实现

1.dao层:
代码逆向生成器生成

2.service层
public interface ItemService {
    List<Items> getItemsList();
}

3.serviceimpl实现类
@Service
public class ItemServiceImpl implements ItemService {
    @Autowired
    private ItemMapper itemMapper;
    @Override
    public List<Items> getItemsList() {
        List<Items> itemList = itemMapper.getItemList();
        return itemList;
    }
}

4.Controller视图层
@Controller
public class ItemController {
    @Autowired
    private ItemService itemService;
    @RequestMapping("/itemList")
    public ModelAndView getItemList() {
        List<Items> list = itemService.getItemsList();
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("itemList", list);
        modelAndView.setViewName("itemList");
        return modelAndView;
    }

Model/ModelMap
ModelMap是Model接口的实现类，通过Model或ModelMap向页面传递数据，如下：

//调用service查询商品信息
Items item = itemService.findItemById(id);
model.addAttribute("item", item);

页面通过${item.XXXX}获取item对象的属性值。
使用Model和ModelMap的效果一样，如果直接使用Model，springmvc会实例化ModelMap。
如果使用Model则可以不使用ModelAndView对象，Model对象可以向页面传递数据，View对象则可以使用String返回值替代。不管是Model还是ModelAndView，其本质都是使用Request对象向jsp传递数据。

参数绑定

1.简单参数绑定
当请求的参数名称和处理器形参名称一致时会将请求参数与形参进行绑定。从Request取参数的方法可以进一步简化。

//比如先获得到传过来的id,调用model向jsp传递数据,然后再返回逻辑视图跳转到jsp页面
@RequestMapping("/itemEdit")
public String itemEdit(Integer id, Model model) {
    Items items = itemService.getItemById(id);
    //向jsp传递数据
    model.addAttribute("item", items);
    //设置跳转的jsp页面
    return "editItem";
}
支持的数据类型
参数类型推荐使用包装数据类型，因为基础数据类型不可以为null
整形：Integer、int
字符串：String
单精度：Float、float
双精度：Double、double
布尔型：Boolean、boolean
说明：对于布尔类型的参数，请求的参数值为true或false。
处理器方法：
public String editItem(Model model,Integer id,Boolean status) throws Exception
请求url：
http://localhost:8080/xxx.action?id=2&status=false

如果参数名称不一致在不能改的情况下我们就何以使用@RequestParam注解
例如:
public String editItem(@RequestParam(value="item_id",required=true) String id) {
    意思是将item_id映射到String id ,通俗讲就是讲id替换为item_id
}
@RequestParam中有三个参数 分别是 value required defaultValue
value：参数名字，即入参的请求参数名字，如value=“item_id”表示请求的参数区中的名字为item_id的参数的值将传入；
required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报；
TTP Status 400 - Required Integer parameter 'XXXX' is not present

defaultValue：默认值，表示如果请求中没有同名参数时的默认值


2.pojo参数绑定

使用pojo接收表单数据
如果提交的参数很多，或者提交的表单中的内容很多的时候可以使用pojo接收数据。要求pojo对象中的属性名和表单中input的name属性一致。
页面定义如下;
<input type="text" name="name"/>
<input type="text" name="price"/>

请求的参数名称和pojo类的属性名称一致，会自动将请求参数赋值给pojo的属性。

@RequestMapping("/updateitem")
public String updateItem(Items items) {
    itemService.updateItem(items);
    return "success";
}
注意:在此参数绑定中不能有日期类型,否则会 报400错误,如果想用日期类型应该用自定义参数绑定.

3.绑定包装pojo参数 
定义一个包装对象,创建一个QueryVo类
Public class QueryVo {
    private Items items;    
}
页面定义如下;
<input type="text" name="items.name"/>
<input type="text" name="items.price"/>
controller编写:
@RequestMapping("/queryitem")
public String queryItem(QueryVo queryVo) {
    //打印绑定结果
    System.out.println(queryVo.getItems().getId());
    System.out.println(queryVo.getItems().getName());
    return "success";
}


4.自定义参数绑定
由于日期数据有很多种格式，所以springmvc没办法把字符串转换成日期类型。所以需要自定义参数绑定。前端控制器接收到请求后，找到注解形式的处理器适配器，对RequestMapping标记的方法进行适配，并对方法中的形参进行参数绑定。在springmvc这可以在处理器适配器上自定义Converter进行参数绑定。如果使用<mvc:annotation-driven/>可以在此标签上进行扩展。
创建Converter类:
public class DateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String source) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            return simpleDateFormat.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

配置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.convert.DateConverter"/>
            </set>
        </property>
    </bean>

解决post乱码问题

在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>

解决get请求乱码

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

高级参数绑定

1.绑定数组
列如:删除多条记录
在页面上给所有行添加复选框
<c:forEach items="${itemList }" var="item">
<tr>
    <td><input name="ids" value="${item.id}" type="checkbox"></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>
    <td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>
</tr>
</c:forEach>
Controller编写:
在Controller方法中可以用String[]接收，或者pojo的String[]属性接收,两种方式都可以对其进行操作

在方法中定义形参
@RequestMapping("/queryitem")
public String queryItem(QueryVo queryVo, String[] ids) {
    System.out.println(queryVo.getItems().getName());
    System.out.println(queryVo.getItems().getPrice());
    return null;
}

在pojo中定义String[] ids
public class QueryVo {
    private Items items;
    private String[] ids;   
}
以上两种方法任选其一即可..........................

2.将表单的数据绑定到List
接收商品列表的pojo
List中存放对象，并将定义的List放在包装类中，使用包装pojo对象接收。
Jsp改造
页面定义如下：
<tr>
<td>
<input type="text" name=" itemsList[0].id" value="${item.id}"/>
</td>
<td>
<input type="text" name=" itemsList[0].name" value="${item.name }"/>
</td>
<td>
<input type="text" name=" itemsList[0].price" value="${item.price}"/>
</td>
</tr>
<tr>
<td>
<input type="text" name=" itemsList[1].id" value="${item.id}"/>
</td>
<td>
<input type="text" name=" itemsList[1].name" value="${item.name }"/>
</td>
<td>
<input type="text" name=" itemsList[1].price" value="${item.price}"/>
</td>
</tr>

Name属性必须是包装pojo的list属性+下标+元素属性。Jsp做如下改造：
<c:forEach items="${itemList }" var="item">
<tr>
    <td><input name="ids" value="${item.id}" type="checkbox"></td>
    <td>
        <input name="id" value="${item.id}" type="hidden">
        <input name="name" value="${item.name }" type="text">
    </td>
    <td><input name="name" value="${item.price }" type="text"></td>
    <td><input name="name" value="<fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/>" type="text"></td>
    <td><input name="name" value="${item.detail }" type="text"></td>
    <td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>
</tr>
</c:forEach>

varStatus属性常用参数总结下：
${status.index}      输出行号，从0开始。
${status.count}      输出行号，从1开始。
${status.current}   当前这次迭代的（集合中的）项
${status.first}  判断当前项是否为集合中的第一项，返回值为true或false
${status.last}   判断当前项是否为集合中的最后一项，返回值为true或false
begin、end、step分别表示：起始序号，结束序号，跳跃步伐。

Contrller
@RequestMapping("/queryitem")
    public String queryItem(QueryVo queryVo, String[] ids) {
        System.out.println(queryVo.getItems().getName());
        System.out.println(queryVo.getItems().getPrice());
        System.out.println(ids.toString());
        return null;
    }

注意：接收List类型的数据必须是pojo的属性，方法的形参为List类型无法正确接收到数据。

@RequestMapping

通过@RequestMapping注解可以定义不同的处理器映射规则
书写规则@RequestMapping(value="/item")或@RequestMapping("/item）value的值是数组可以将多个url映射到同一个方法

@RequestMapping的窄化请求映射
该注解可以在类上面使用,也可以在方法上使用,也可以同时使用,如果类上面天啊家该注解,就会限制在该类下面的所有方法请求url时必须以请求前缀开头
如下：
@RequestMapping放在类名上边，设置请求前缀 
@Controller
@RequestMapping("/item")

方法名上边设置请求映射url：
@RequestMapping放在方法名上边，如下：
@RequestMapping("/queryItem ")

访问地址为：/item/queryItem

请求方法的限定:
该注解可以对请求的方式进行限定
只允许GET请求:@RequestMapping(value="/editItem",method=RequestMethod.GET)
只允许POST请求:@RequestMapping(value="/editItem",method = RequestMethod.POST)
GET和POST请求都可以:买足都可以的话可以在注解里面不用写,也可以将两个都写上@RequestMapping(method={RequestMethod.GET,RequestMethod.POST})

controller方法返回值

返回的方式有3种modelandview,viod,字符串

modelandview返回(参考上面代码实现)

viod返回
在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串");

字符串

controller方法返回字符串可以指定逻辑视图名，通过视图解析器解析为物理视图地址。
//指定逻辑视图名，经过视图解析器解析为jsp物理路径：/WEB-INF/jsp/item/editItem.jsp
return "item/editItem";
重定向:
Contrller方法返回结果重定向到一个url地址，如下商品修改提交后重定向到商品查询方法，参数无法带到商品查询方法中。
//重定向到queryItem.action地址,request无法带过去
return "redirect:queryItem.action";
redirect方式相当于“response.sendRedirect()”，转发后浏览器的地址栏变为转发后的地址，因为转发即执行了一个新的request和response。
由于新发起一个request原来的参数在转发时就不能传递到下一个url，如果要传参数可以/item/queryItem.action后边加参数，如下：
/item/queryItem?...&…..
 转发:
controller方法执行后继续执行另一个controller方法，如下商品修改提交后转向到商品修改页面，修改商品的id参数可以带到商品修改方法中。
//结果转发到editItem.action，request可以带过去
return "forward:editItem.action";
forward方式相当于“request.getRequestDispatcher().forward(request,response)”，转发后浏览器地址栏还是原来的地址。转发并没有执行新的request和response，而是和转发前的请求共用一个request和response。所以转发前请求的参数在转发后仍然可以读取到。

异常处理

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。
    系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图：

自定义异常

为了区别不同的异常通常根据异常类型自定义异常类，这里我们创建一个自定义系统异常，如果controller、service、dao抛出此类异常说明是系统预期处理的异常信息

创建CoutomException类
public class CoutomException extends Exception {
    private String message;
    public CoutomException(String message){
        super(message);
        this.message = message;
    }
    public String getMassage() {
        return message;
    }
    public void setMassage(String message) {
        this.message = message;
    }
}

创建自定义异常处理器
/**
 * 自定义异常处理器
 */
public class GlobalExceptionProcessor implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler, Exception ex) {
        String message = null;
        //判断错吴类型,如果是自定义异常,我们取出错误信息,如果是运行时异常,我们取错误的堆栈
        if (ex instanceof CoutomException){
            //如果是自定义异常取出错误信息
            CoutomException coutomException = (CoutomException) ex;
            message = coutomException.getMassage();
        } else {
            //如果不是自定义异常取出错误堆栈
            ex.printStackTrace();
            //下列为取异常堆栈代码
            StringWriter s = new StringWriter();
            PrintWriter printWriter = new PrintWriter(s);
            ex.printStackTrace(printWriter);
            message = s.toString();
        }
        //给相关人员发送短信邮件写日志等
        //返回错误页面
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message",message);
        modelAndView.setViewName("error");
            return modelAndView;
    }
}

页面编写
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%> 
<!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>错误页面</title>

</head>
<body>
您的操作出现错误如下：<br/>
${message }
</body>
</html>

异常处理器配置
在springmvc.xml中添加：
<!-- 异常处理器 -->
    <bean id="handlerExceptionResolver" class="cn.itcast.ssm.controller.exceptionResolver.CustomExceptionResolver"/>

图片上传

配置虚拟目录
在tomcat上配置图片虚拟目录，在tomcat下conf/server.xml中添加：
<Context docBase="F:\develop\upload\temp" path="/pic" reloadable="false"/>

访问http://localhost:8080/pic即可访问F:\develop\upload\temp下的图片。
jar包
CommonsMultipartResolver解析器依赖commons-fileupload和commons-io，加入如下jar包：

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

图片上传
controller：

//商品修改提交
    @RequestMapping("/editItemSubmit")
    public String editItemSubmit(Items items, MultipartFile pictureFile)throws Exception{

        //原始文件名称
        String pictureFile_name =  pictureFile.getOriginalFilename();
        //新文件名称
        String newFileName = UUID.randomUUID().toString()+pictureFile_name.substring(pictureFile_name.lastIndexOf("."));

        //上传图片
        File uploadPic = new java.io.File("F:/develop/upload/temp/"+newFileName);

        if(!uploadPic.exists()){
            uploadPic.mkdirs();
        }
        //向磁盘写文件
        pictureFile.transferTo(uploadPic);

.....

页面：

form添加enctype="multipart/form-data"：
<form id="itemForm"
action="${pageContext.request.contextPath }/item/editItemSubmit.action"
        method="post" enctype="multipart/form-data">
        <input type="hidden" name="pic" value="${item.pic }" />


file的name与controller形参一致：
<tr>
    <td>商品图片</td>
    <td><c:if test="${item.pic !=null}">
            <img src="/pic/${item.pic}" width=100 height=100 />
            <br />
        </c:if> <input type="file" name="pictureFile" /></td>
</tr>

json数据交互

json数据交互
1.@RequestBody
作用：
@RequestBody注解用于读取http请求的内容(字符串)，通过springmvc提供的HttpMessageConverter接口将读到的内容转换为json、xml等格式的数据并绑定到controller方法的参数上。
List.action?id=1&name=zhangsan&age=12

本例子应用：
@RequestBody注解实现接收http请求的json数据，将json数据转换为java对象

2.@ResponseBody
作用：
该注解用于将Controller的方法返回的对象，通过HttpMessageConverter接口转换为指定格式的数据如：json,xml等，通过Response响应给客户端

本例子应用：
@ResponseBody注解实现将controller方法返回对象转换为json响应给客户端

3.请求json，响应json实现：
环境准备
Springmvc默认用MappingJacksonHttpMessageConverter对json数据进行转换，需要加入jackson的包，如下：

配置json转换器
在注解适配器中加入messageConverters

<!--注解适配器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
        <list>
        <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
        </list>
        </property>
    </bean>

注意：如果使用<mvc:annotation-driven /> 则不用定义上边的内容。


controller编写
// 商品修改提交json信息，响应json信息
    @RequestMapping("/editItemSubmit_RequestJson")
    public @ResponseBody Items editItemSubmit_RequestJson(@RequestBody Items items) throws Exception {
        System.out.println(items);
        //itemService.saveItem(items);
        return items;

    }

页面js方法编写：
引入 js：
<script type="text/javascript" 
src="${pageContext.request.contextPath }/js/jquery-1.4.4.min.js"></script>


//请求json响应json
    function request_json(){
        $.ajax({
            type:"post",
            url:"${pageContext.request.contextPath }/item/editItemSubmit_RequestJson.action",
            contentType:"application/json;charset=utf-8",
            data:'{"name":"测试商品","price":99.9}',
            success:function(data){
                alert(data);
            }
        });
    }

restful

什么是restful？
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格，是对http协议的诠释。
资源定位：互联网所有的事物都是资源，要求url中没有动词，只有名词。没有参数
Url格式：http://blog.csdn.net/beat_the_world/article/details/45621673
资源操作：使用put、delete、post、get，使用不同方法对资源进行操作。分别对应添加、删除、修改、查询。一般使用时还是post和get。Put和Delete几乎不使用。
需求
RESTful方式实现商品信息查询，返回json数据

添加DispatcherServlet的rest配置

<servlet>
        <servlet-name>springmvc-servlet-rest</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-servlet-rest</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
URL 模板模式映射
@RequestMapping(value="/ viewItems/{id}")：{×××}占位符，请求的URL可以是“/viewItems/1”或“/viewItems/2”，通过在方法中使用@PathVariable获取{×××}中的×××变量。
@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。

@RequestMapping("/viewItems/{id}") 
    public @ResponseBody viewItems(@PathVariable("id") String id,Model model) throws Exception{
        //方法中使用@PathVariable获取useried的值，使用model传回页面
        //调用 service查询商品信息
        ItemsCustom itemsCustom = itemsService.findItemsById(id);
        return itemsCustom;
}

如果RequestMapping中表示为"/viewItems/{id}"，id和形参名称一致，@PathVariable不用指定名称。

商品查询的controller方法也改为rest实现：

// 查询商品列表
    @RequestMapping("/queryItem")
    public ModelAndView queryItem() throws Exception {
        // 商品列表
        List<Items> itemsList = itemService.findItemsList(null);

        // 创建modelAndView准备填充数据、设置视图
        ModelAndView modelAndView = new ModelAndView();

        // 填充数据
        modelAndView.addObject("itemsList", itemsList);
        // 视图
        modelAndView.setViewName("item/itemsList");

        return modelAndView;
    }

静态资源访问<mvc:resources>
如果在DispatcherServlet中设置url-pattern为 /则必须对静态资源进行访问处理。
spring mvc 的<mvc:resources mapping="" location="">实现对静态资源进行映射访问。
如下是对js文件访问配置：
<mvc:resources location="/js/" mapping="/js/**"/>