java web牛刀小试之spring mvc

1.Spring MVC工作原理:

　springMVC是一个MVC的开源框架，springMVC=struts2+spring，springMVC就相当于是Struts2加上sring的整合，但是这里有一个疑惑就是，springMVC和spring是什么样的关系呢？这个在百度百科上有一个很好的解释：意思是说，springMVC是spring的一个后续产品，其实就是spring在原有基础上，又提供了web应用的MVC模块，可以简单的把springMVC理解为是spring的一个模块（类似AOP，IOC这样的模块），网络上经常会说springMVC和spring无缝集成，其实springMVC就是spring的一个子模块，所以根本不需要同spring进行整合。借助于注解，Spring MVC提供了几乎是POJO的开发模式，使得控制器的开发和测试更加简单。这些控制器一般不直接处理请求，而是将其委托给Spring上下文中的其他bean，通过Spring的依赖注入功能，这些bean被注入到控制器中。

2.SpringMVC流程

1、用户发送请求至前端控制器DispatcherServlet。

2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、 DispatcherServlet调用HandlerAdapter处理器适配器。

5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、 Controller执行完成返回ModelAndView。

7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、 ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

3.组件：
3.1前端控制器DispatcherServlet（不需要工程师开发）,由框架提供
作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

3.2处理器映射器HandlerMapping(不需要工程师开发),由框架提供
作用：根据请求的url查找Handler
HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3.3处理器适配器HandlerAdapter
作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler
通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

3.4处理器Handler(需要工程师开发)
注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。

3.5视图解析器View resolver(不需要工程师开发),由框架提供
作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。

3.6视图View(需要工程师开发jsp...)
View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf...）

前端控制器（DispatcherServlet）：接收请求，响应结果，相当于电脑的CPU。

处理器映射器（HandlerMapping）：根据URL去查找处理器

处理器（Handler）：（需要程序员去写代码处理逻辑的）

处理器适配器（HandlerAdapter）：会把处理器包装成适配器，这样就可以支持多种类型的处理器，类比笔记本的适配器（适配器模式的应用）

视图解析器（ViewResovler）：进行视图解析，多返回的字符串，进行处理，可以解析成对应的页面

SpringMVC处理json的使用：

（1）HttpInputMessage 将请求的信息先转为 InputStream 对象，InputStream 再由 HttpMessageConverter 转换为 SpringMVC 需要的java对象；

（2）SpringMVC 返回一个 java 对象，并通过 HttpMessageConverter 转为响应信息，接着 HttpOutputMessage 将响应的信息转换为 OutputStream，接着给出响应。

4.常用注解：

//配置url和方法的一个关系
@RequestMapping("item/{itemId}");

request.getParameter("name")，另外一种是用注解@RequestParam直接获取;

@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上

5.spring-mvc配置和代码：

web.xml

 <!--声明项目的初始化参数 ，这里声明了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>

    <!--配置springmvc DispatcherServlet-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--Sources标注的文件夹下需要新建一个spring文件夹-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/maven-springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>

springmvc.xml

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <beans xmlns="http://www.springframework.org/schema/beans"
  3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4        xmlns:context="http://www.springframework.org/schema/context"
  5        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7                         http://www.springframework.org/schema/beans/spring-beans.xsd
  8                          http://www.springframework.org/schema/context
  9                         http://www.springframework.org/schema/context/spring-context.xsd
 10                         http://www.springframework.org/schema/mvc
 11                         http://www.springframework.org/schema/mvc/spring-mvc.xsd">
 12     <!--启用spring的一些annotation -->
 13     <context:annotation-config/>
 14 
 15     <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
 16     <context:component-scan base-package="controller">
 17         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
 18     </context:component-scan>
 19 
 20     <context:component-scan base-package="impl"/>
 21     <context:component-scan base-package="dao"/>
 22     <context:component-scan base-package="service"/>
 23 
 24     <!--HandlerMapping 无需配置，springmvc可以默认启动-->
 25 
 26     <!--静态资源映射-->
 27     <!--本项目把静态资源放在了WEB-INF的statics目录下，资源映射如下-->
 28 
 29 
 30     <!--但是项目部署到linux下发现WEB-INF的静态资源会出现无法解析的情况，但是本地tomcat访问正常，因此建议还是直接把静态资源放在webapp的statics下，映射配置如下-->
 31     <!--<mvc:resources mapping="/css/**" location="/statics/css/"/>-->
 32     <!--<mvc:resources mapping="/js/**" location="/statics/js/"/>-->
 33     <!--<mvc:resources mapping="/image/**" location="/statics/images/"/>-->
 34 
 35     <!-- 配置注解驱动 可以将request参数与绑定到controller参数上 -->
 36     <mvc:annotation-driven/>
 37 
 38     <!-- 会自动注册了validator  ConversionService  -->
 39     <mvc:annotation-driven validator="validator" conversion-service="conversionService" content-negotiation-manager="contentNegotiationManager">
 40         <mvc:message-converters register-defaults="true">
 41             <!-- StringHttpMessageConverter编码为UTF-8，防止乱码 -->
 42             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
 43                 <constructor-arg value="UTF-8"/>
 44                 <property name = "supportedMediaTypes">
 45                     <list>
 46                         <bean class="org.springframework.http.MediaType">
 47                             <constructor-arg index="0" value="text"/>
 48                             <constructor-arg index="1" value="plain"/>
 49                             <constructor-arg index="2" value="UTF-8"/>
 50                         </bean>
 51                         <bean class="org.springframework.http.MediaType">
 52                             <constructor-arg index="0" value="*"/>
 53                             <constructor-arg index="1" value="*"/>
 54                             <constructor-arg index="2" value="UTF-8"/>
 55                         </bean>
 56                     </list>
 57                 </property>
 58             </bean>
 59             <!-- 避免IE执行AJAX时,返回JSON出现下载文件 -->
 60             <bean id="fastJsonHttpMessageConverter" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
 61                 <property name="supportedMediaTypes">
 62                     <list>
 63                         <value>application/json;charset=UTF-8</value>
 64                     </list>
 65                 </property>
 66                 <!--<property name="serializerFeature">-->
 67                 <!--这个地方加上这个功能吧，能自己配置一些东西，比如时间的格式化，null输出""等等-->
 68                 <!--</property>-->
 69             </bean>
 70         </mvc:message-converters>
 71 
 72         <mvc:argument-resolvers>
 73             <bean class="org.springframework.data.web.PageableHandlerMethodArgumentResolver" />
 74         </mvc:argument-resolvers>
 75     </mvc:annotation-driven>
 76 
 77     <!-- 对上传文件的配置 -->
 78 
 79     <bean id="multipartResolver"
 80           class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 81         <property name="maxUploadSize" value="209715200" />
 82         <property name="defaultEncoding" value="UTF-8" />
 83         <property name="resolveLazily" value="true" />
 84     </bean>
 85 
 86     <!-- 内容协商管理器  -->
 87     <!--1、首先检查路径扩展名（如my.pdf）；2、其次检查Parameter（如my?format=pdf）；3、检查Accept Header-->
 88     <bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
 89         <!-- 扩展名至mimeType的映射,即 /user.json => application/json -->
 90         <property name="favorPathExtension" value="true"/>
 91         <!-- 用于开启 /userinfo/123?format=json 的支持 -->
 92         <property name="favorParameter" value="true"/>
 93         <property name="parameterName" value="format"/>
 94         <!-- 是否忽略Accept Header -->
 95         <property name="ignoreAcceptHeader" value="false"/>
 96 
 97         <property name="mediaTypes"> <!--扩展名到MIME的映射；favorPathExtension, favorParameter是true时起作用  -->
 98             <value>
 99                 json=application/json
100                 xml=application/xml
101                 html=text/html
102             </value>
103         </property>
104         <!-- 默认的content type -->
105         <property name="defaultContentType" value="text/html"/>
106     </bean>
107 
108     <!-- ===================================================== -->
109     <!-- ViewResolver For FreeMarker -->
110     <!-- ===================================================== -->
111     <bean id="freemarkerResolver" class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
112         <property name="order" value="1" />
113         <property name="suffix" value=".ftl" />
114         <property name="contentType" value="text/html;charset=utf-8" />
115         <property name="viewClass">
116             <value>org.springframework.web.servlet.view.freemarker.FreeMarkerView</value>
117         </property>
118     </bean>
119     <!-- ===================================================== -->
120     <!-- ViewResolver For FreeMarkerConfigurer -->
121     <!-- ===================================================== -->
122     <bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
123         <property name="templateLoaderPath">
124             <value>/WEB-INF/views/</value>
125         </property>
126         <property name="freemarkerSettings"><!-- 设置FreeMarker环境属性 -->
127             <props>
128                 <prop key="template_update_delay">5</prop><!--刷新模板的周期，单位为秒 -->
129                 <prop key="default_encoding">UTF-8</prop><!--模板的编码格式 -->
130                 <prop key="locale">UTF-8</prop><!-- 本地化设置 -->
131                 <prop key="datetime_format">yyyy-MM-dd HH:mm:ss</prop>
132                 <prop key="time_format">HH:mm:ss</prop>
133                 <prop key="number_format">0.####</prop>
134                 <prop key="boolean_format">true,false</prop>
135                 <prop key="whitespace_stripping">true</prop>
136                 <prop key="tag_syntax">auto_detect</prop>
137                 <prop key="url_escaping_charset">UTF-8</prop>
138             </props>
139         </property>
140     </bean>
141 
142     <!-- 对模型视图名称的解析，即在模型视图名称添加前后缀(如果最后一个还是表示文件夹,则最后的斜杠不要漏了) 使用JSP-->
143     <!-- 默认的视图解析器 在上边的解析错误时使用 (默认使用html)- -->
144    <!-- <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
145         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
146         <property name="prefix" value="/WEB-INF/views/"/>&lt;!&ndash;设置JSP文件的目录位置&ndash;&gt;
147         <property name="suffix" value=".jsp"/>
148     </bean>-->
149 
150     <!-- springmvc文件上传需要配置的节点-->
151     <!-- <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
152          <property name="maxUploadSize" value="20971500"/>
153          <property name="defaultEncoding" value="UTF-8"/>
154          <property name="resolveLazily" value="true"/>
155      </bean>-->
156 </beans>

application.xml

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
 6        xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
 7 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 8 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
 9 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
10     <!-- 导入properties属性文件 -->
11     <context:property-placeholder ignore-unresolvable="true" location="classpath:properties/datasource.properties"/>
12     <context:property-placeholder ignore-unresolvable="true" location="classpath:properties/redis.properties"/>
13 
14     <!-- Redis 配置 -->
15     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
16         <property name="maxTotal" value="${redis.pool.maxTotal}" />
17         <property name="maxIdle" value="${redis.pool.maxIdle}" />
18         <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}" />
19         <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
20     </bean>
21     <!-- redis单节点数据库连接配置 -->
22     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
23         <property name="hostName" value="${redis.ip}" />
24         <property name="port" value="${redis.port}" />
25         <!-- <property name="password" value="${redis.pass}" /> -->
26         <property name="poolConfig" ref="jedisPoolConfig" />
27     </bean>
28     <!-- redisTemplate配置，redisTemplate是对Jedis的对redis操作的扩展，有更多的操作，封装使操作更便捷 -->
29     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
30         <property name="connectionFactory" ref="jedisConnectionFactory" />
31     </bean>
32 
33     <!-- 以下 validator  ConversionService 在使用 mvc:annotation-driven 会 自动注册-->
34     <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean" />
35 
36     <!-- 类型转换及数据格式化 -->
37     <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean"/>
38 
39     <!-- 配置数据源 -->
40     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
41         <property name="username" value="${jdbc.uname}"></property>
42         <property name="password" value="${jdbc.pword}"></property>
43         <property name="url" value="${jdbc.url}"></property>
44         <property name="driverClassName" value="${jdbc.driver}"></property>
45     </bean>
46     <!-- 配置sqlSessionFactory-->
47     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
48         <property name="dataSource" ref="dataSource"></property>
49         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
50         <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
51     </bean>
52     <!-- 自动扫描mapper文件对应的接口类，将其中的接口自动创建成 MapperFactoryBean -->
53     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
54         <property name="basePackage" value="dao"></property>
55     </bean>
56     <!-- 配置事务管理器 -->
57     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
58         <property name="dataSource" ref="dataSource"></property>
59     </bean>
60     <!-- 事务的传播属性 -->
61     <tx:advice id="taansactionAdvice" transaction-manager="transactionManager">
62         <tx:attributes>
63             <tx:method name="add*" propagation="REQUIRED"/>
64             <tx:method name="create*" propagation="REQUIRED"/>
65             <tx:method name="delete*" propagation="REQUIRED"/>
66             <tx:method name="remove*" propagation="REQUIRED"/>
67             <tx:method name="update*" propagation="REQUIRED"/>
68             <tx:method name="get*" read-only="true"/>
69             <tx:method name="find*" read-only="true"/>
70             <tx:method name="*" read-only="true"/>
71         </tx:attributes>
72     </tx:advice>
73     <!-- 参与事务的service  -->
74     <aop:config>
75         <aop:pointcut expression="execution(* service.*.*(..))" id="servicePointCut"/>
76         <aop:advisor advice-ref="taansactionAdvice" pointcut-ref="servicePointCut"/>
77     </aop:config>
78 </beans>

  1 package controller;
  2 
  3 import org.apache.commons.io.FileUtils;
  4 import org.apache.commons.lang.builder.ReflectionToStringBuilder;
  5 import org.slf4j.Logger;
  6 import org.slf4j.LoggerFactory;
  7 import org.springframework.beans.factory.annotation.Autowired;
  8 import org.springframework.http.HttpHeaders;
  9 import org.springframework.http.HttpStatus;
 10 import org.springframework.http.MediaType;
 11 import org.springframework.http.ResponseEntity;
 12 import org.springframework.jdbc.core.namedparam.NamedParameterUtils;
 13 import org.springframework.stereotype.Controller;
 14 import org.springframework.ui.ModelMap;
 15 import org.springframework.web.bind.annotation.CookieValue;
 16 import org.springframework.web.bind.annotation.PathVariable;
 17 import org.springframework.web.bind.annotation.RequestBody;
 18 import org.springframework.web.bind.annotation.RequestMapping;
 19 import org.springframework.web.bind.annotation.RequestMethod;
 20 import org.springframework.web.bind.annotation.RequestParam;
 21 import org.springframework.web.bind.annotation.ResponseBody;
 22 import org.springframework.web.multipart.MultipartFile;
 23 import pojo.PagedResult;
 24 import pojo.Person;
 25 import pojo.Teacher;
 26 import pojo.UserResult;
 27 import service.UserService;
 28 import pojo.User;
 29 //import impl.AbstractBaseRedis;
 30 
 31 import javax.annotation.Resource;
 32 import javax.servlet.http.HttpServletRequest;
 33 import javax.servlet.http.HttpServletResponse;
 34 import javax.xml.bind.ValidationEvent;
 35 import java.io.File;
 36 import java.io.FileOutputStream;
 37 import java.io.IOException;
 38 import java.io.ObjectOutputStream;
 39 import java.util.*;
 40 
 41 /**
 42  * Created by 17080606 on 2018/5/31.
 43  */
 44 @Controller
 45 @RequestMapping("/home")
 46 public class HomeController extends BaseController {
 47     //static {}
 48 
 49     private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
 50 
 51     //    @Resource(name="userService")
 52     @Autowired
 53     private UserService userService;
 54 
 55     /*@Autowired
 56     private AbstractBaseRedis abstractBaseRedis;*/
 57 
 58 
 59     @RequestMapping("/index")
 60     public String index(ModelMap modelMap) {
 61         logger.info("the one");
 62 
 63 
 64         // FTL modelmap
 65         // JSP ModelAndView
 66         //ModelAndView model = new ModelAndView("index");
 67         //User user = userService.getUser(1);
 68 
 69         List<User> userlist = userService.getUserList(1);
 70         logger.info(ReflectionToStringBuilder.toString(userlist));
 71         //modelMap.addAttribute("name",user.getUsername());
 72         modelMap.addAttribute("userlist", userlist);
 73         return "/user";
 74         //return model;// index.jsp
 75     }
 76 
 77     @RequestMapping(value = "/p")
 78     public String p() {
 79         return "/ppp";
 80     }
 81 
 82     @RequestMapping("/redindex")
 83     public String RedisIndex(ModelMap modelMap) {
 84         /*abstractBaseRedis.set("user", "key:1", "diyici");
 85         if (!abstractBaseRedis.hexists("user", "key:1")) {
 86             System.out.print("redis key不存在！");
 87             // 从数据库取出数据，然后添加redis
 88 
 89             //删除原rediskey
 90             //abstractBaseRedis.hdel("user","key:1");
 91         }
 92         String s = abstractBaseRedis.get("user", "key:1");*/
 93         /*modelMap.addAttribute("name", s);*/
 94         return "/reduser";
 95     }
 96 
 97     @RequestMapping(value = "/list", produces = {"application/json;charset=UTF-8"})
 98     @ResponseBody
 99     public String list(Integer pageNumber, Integer pageSize) {
100         PagedResult<User> pageResult = userService.queryByPage(1, pageNumber, pageSize);
101         return responseSuccess(pageResult);
102     }
103 
104     @RequestMapping(value = "/listto")
105     @ResponseBody
106     public UserResult<User> listTo() {
107         UserResult<User> userUserResult;
108         try {
109             List<User> userList = userService.getUserList(null);
110             userUserResult = new UserResult<User>(true, userList.get(0));
111         } catch (Exception e) {
112             userUserResult = new UserResult<User>(false, e.getMessage());
113         }
114         return userUserResult;
115     }
116 
117     @RequestMapping("/betachDelete")
118     public String betachDelete(ModelMap modelMap) {
119         List<Integer> integerArrayList = new ArrayList<>();
120         //模拟组装前端传来的id集合
121         int[] ints = {10, 11};
122 
123 //        for(int i=0;i<integers.length;i++){
124 //            integerArrayList.add(integers[i]);
125 //        }
126 
127         userService.betachDeleteUser(ints);
128         return "/reduser";
129     }
130 
131     @RequestMapping("/add")
132     public String Add() {
133         return "/Add";
134     }
135 
136 //    @RequestMapping(value = "/adduser",method = RequestMethod.POST)
137 //    //@ResponseBody
138 //    public String AddUser(User user,String user_name, ModelMap modelMap) {
139 //        //User user1=new User();
140 //        //User u=new User();
141 //        //u.setUsername(users.getUsername());
142 //        int flag = userService.addUser(user);
143 //        if (flag > 0) {
144 //            //modelMap.addAttribute("result", "success");
145 //            return "/Add";
146 //            //return "redirect:/home/index";
147 //        } else {
148 //            modelMap.addAttribute("error", "fail");
149 //            return "/Add";
150 //        }
151 //    }
152 
153     @RequestMapping(value = "/adduser",method = RequestMethod.POST)
154     public String AddUser(@RequestBody Teacher teacher, ModelMap modelMap) {
155         System.out.println("333");
156         //User user1=new User();
157         //User u=new User();
158         //u.setUsername(users.getUsername());
159 //        int flag = userService.addUser(null);
160 //        if (flag > 0) {
161 //            //modelMap.addAttribute("result", "success");
162 //            return "/Add";
163 //            //return "redirect:/home/index";
164 //        } else {
165 //            modelMap.addAttribute("error", "fail");
166 //            return "/Add";
167 //        }
168         return "/Add";
169     }
170 
171     @RequestMapping("/update")
172     public String Update(Integer id,ModelMap modelMap) {
173         User user = userService.getUser(id);
174         modelMap.addAttribute("user", user);
175         return "/Update";
176 
177     }
178 
179     //ResponseBody
180     @RequestMapping("/updateuser")
181     public String UpdateUser(User user, ModelMap modelMap) {
182         int flag = userService.updateUser(user);
183         if (flag > 0) {
184             return "/Update";
185         } else {
186             modelMap.addAttribute("error", "fail");
187             return "/Update";
188         }
189     }
190 
191     @RequestMapping("/upload")
192     public String showUploadPage() {
193         return "/uploadFile";
194     }
195 
196 //    @RequestMapping("/doUpload")
197 //    public String doUploadFile(@RequestParam("file") MultipartFile file) {
198 //        if (!file.isEmpty()) {
199 //            try {
200 //                FileUtils.copyInputStreamToFile(file.getInputStream(), new File("D:\\fileimg", System.currentTimeMillis() + file.getOriginalFilename()));
201 //            } catch (IOException ex) {
202 //                ex.printStackTrace();
203 //            }
204 //        }
205 //        return "/Add";
206 //    }
207 
208     @RequestMapping("/download")
209     public ResponseEntity<byte[]> download(HttpServletRequest request, HttpServletResponse response) throws IOException {
210         //String path=request.getSession().getServletContext().getRealPath("upload");
211         String path = "D:\\fileimg";
212         String fileName = "1.jpg";
213 
214         File targetFile = new File(path, fileName);
215 
216         String dfileName = new String(fileName.getBytes("gb2312"), "iso8859-1");
217         HttpHeaders headers = new HttpHeaders();
218         headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
219         headers.setContentDispositionFormData("attachment", dfileName);
220         return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(targetFile), headers, HttpStatus.CREATED);
221     }
222 
223     /*public String Fore(){
224         Collection c=new ArrayList();
225         c.add("1");
226         c.add(2);
227 
228         for(int j=0;j<c.size();j++){
229 
230         }
231         //foreach循环
232         for(Object cc:c){
233 
234         }
235 
236         //类型转化
237         String str="1";
238         Integer is= Integer.valueOf(str).intValue();
239         Integer.toString(is);
240         Integer.parseInt(str);
241 
242         if(c instanceof Collection){
243             //转换成功 强转
244             Collection cc= (Collection)c;
245         }
246 
247 
248         //iterator循环
249         Iterator it= c.iterator();
250         while (it.hasNext()){
251             System.out.print(it.next());
252         }
253         //转数组
254         Object[] o= c.toArray();
255         //for循环
256         for(int i=0;i<o.length;i++){
257 
258         }
259 
260         for(Iterator itt= c.iterator();itt.hasNext();){
261 
262         }
263 
264         //可变参数
265         cc(1,2,3,4,5);
266         return "";
267     }
268 
269 
270     public void cc(Integer... i){
271         //局部内部类
272         class m{
273 
274         }
275         return;
276     }
277 
278     //内部类
279     class person{
280 
281     }*/
282 
283 
284 }

6.spring-mvc依赖jar包

1) spring-core.jar需commons-collections.jar，spring-core.jar是以下其它各个的基本。

2) spring-beans.jar需spring-core.jar，cglib-nodep-2.1_3.jar

3) spring-aop.jar需spring-core.jar，spring-beans.jar，cglib-nodep-2.1_3.jar，aopalliance.jar

4) spring-context.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，commons-collections.jar，aopalliance.jar

5) spring-dao.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring-context.jar

6) spring-jdbc.jar需spring-core.jar，spring-beans.jar，spring-dao.jar

7) spring-web.jar需spring-core.jar，spring-beans.jar，spring-context.jar

8) spring-webmvc.jar需spring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar

9) spring-hibernate.jar需spring-core.jar，spring- beans.jar，spring-aop.jar，spring-dao.jar，spring-jdbc.jar，spring- orm.jar，spring-web.jar，spring-webmvc.jar

10) spring-orm.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring-dao.jar，spring-jdbc.jar，spring-web.jar，spring-webmvc.jar

11) spring-remoting.jar需spring-core.jar，spring-beans.jar，spring- aop.jar，spring-dao.jar，spring-context.jar，spring-web.jar，spring- webmvc.jar

12) spring-support.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring-dao.jar，spring-context.jar，spring-jdbc.jar

13) spring-mock.jar需spring-core.jar，spring-beans.jar，spring-dao.jar，spring-context.jar，spring-jdbc.jar