Spring MVC入门

教你创建一个简单的SpringMVC项目

首先创建一个Java web项目，然后引入SpringMVC所需要的jar包，或者创建一个maven webapp项目也可以。创建好以后开始配置springMVC

1. 首先配置 springMVC 的 Servlet 负责请求分发，在web.xml中配置

<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-mvc.xml</param-value>  
        </init-param>  
        <!--配置启动，1是当服务器启动的时候就初始化spring servlet-->
        <load-on-startup>1</load-on-startup>  
        <async-supported>true</async-supported>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>SpringMVC</servlet-name>  
        <!-- 配置要拦截的请求，这里配置是拦截所有请求,此处可以可以配置成*.do，对应struts的后缀习惯 -->  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  

2. 然后配置springMVC的配置文件spring-mvc.xml

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
	<!-- 在WEB-INF下面起到一个安全作用，如果从客户端直接访问JSP是访问不了的，必须通过SpringMVC访问-->  
		<property name="prefix" value="/WEB-INF/jsp/"/>
		<property name="suffix" value=".jsp"/>
	</bean>

3. 创建一个Controller测试一下

public class HelloController implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest arg0,
			HttpServletResponse arg1) throws Exception {
		// TODO Auto-generated method stub
		System.out.println("进入了HelloController.......");
		return new ModelAndView("/welcome");
	}

}

创建好Controller，需要实现org.springframework.web.servlet.mvc.Controller接口，返回一个ModelAndView，"welcome"是返回在jsp文件夹中的welcome.jsp页面

然后需要在spring-mvc.xml里面注入

<bean name="/test/hello" class="com.zzh.hao.controller.HelloController"></bean>

启动Tomcat，在浏览器里面输入  http://localhost:8080/项目名/test/hello，就可以看到效果了

4. 上面的一个Controller只能有一个Action，下面看看多个Action请求的实现

public class MultiController extends MultiActionController {

	public ModelAndView monday(HttpServletRequest request, HttpServletResponse response){
		System.out.println("---------monday方法----------");
		return new ModelAndView("/welcome", "mothod", "monday方法");
	}
	
	public ModelAndView friday(HttpServletRequest request, HttpServletResponse response){
		System.out.println("---------friday方法----------");
		return new ModelAndView("/welcome", "mothod", "friday方法");
	}
}

如上所示，多个Action需要集成org.springframework.web.servlet.mvc.multiaction.MultiActionController，然后在spring-mvc.xml里面配置

<!-- 配置springMVC多个action请求的方法名称解析器 -->
	<bean id="paramMethodResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
		<property name="paramName" value="action"></property>
	</bean>
	<bean name="/test/week" class="com.zzh.hao.controller.MultiController">
		<property name="methodNameResolver">
			<ref bean="paramMethodResolver"/>
		</property>
	</bean>

配置好之后，在浏览器里输入 http://localhost:8080/项目名/test/week?action=friday 其中action是上面配置的，可以改变

5. 使用注解

从上面的Action中可以看出需要继承Controller，还要在配置文件里面注入，代码量较大而且挺麻烦，spring从2.5开始支持Controller的注解，下面看看注解的使用

首先在spring-mvc.xml文件指定要扫描Controller所在的包

<!-- base-package 如果多个，用“,”分隔 -->
	<!-- 使用Annotation自动注册Bean,use-default-filters="false"说明只要include-filter过滤到的类型，也就是只扫描@Controller -->
	<context:component-scan base-package="com.zzh.hao" use-default-filters="false">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>

然后配置开启注解  一个是针对方法，一个针对类

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"></bean>
	<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean>

或者

<mvc:annotation-driven />

这句话的意思和上面两句一样，自动注入，不需要手写bean，很是方便

下面是Controller类

@Controller
@RequestMapping(value = "/base")
public class BaseController {

	@RequestMapping(value = "/select")
	public String selectAll(HttpServletRequest request, HttpServletResponse response){
		System.out.println("------selectAll------");
		return "welcome";
	}
	
	@RequestMapping(value = "/testmvc")
	public ModelAndView getModels(HttpServletRequest request, HttpServletResponse response){
		System.out.println("-------getModels-------");
		return new ModelAndView("/welcome", "method", "Today is Friday");
	} 
}

在浏览器输入就可以访问了 http://localhost:8080/项目名/base/select，这种方式比较适合REST风格的开发

6. 访问静态文件

<!--意思是static文件夹下面的可以直接访问，可以把图片JS等放在里面-->
	<!--因为springMVC拦截所以请求，如果把拦截所有请求改成拦截特点.do或者.action的，就不用配置这个了-->
	<mvc:resources location="/static/" mapping="/static/**" />

7. 编码过滤，web.xml

    <filter>  
        <filter-name>encodingFilter</filter-name>  
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <async-supported>true</async-supported>  
        <init-param>  
            <param-name>encoding</param-name>  
            <param-value>UTF-8</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>encodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  

8. 前台页面传参

首先是界面部分，创建一个Form表单，里面创建两个Input标签，一个是用户名一个是密码
然后创建Controller

@Controller
	@RequestMapping(value="/zzh")
	public class UserController{
		
		@RequestMapping("/getUser")
		public String getUser(String userName, String passWord, HttpServletRequest request){
			request.setAttribute("userName", userName);
			request.setAttribute("passWord", passWord);
			return "/Tuesday";
		}
	}

注意，用户名密码对应参数名 userName passWord，如果把用户名密码封装到一个类里面 且参数名称一样，那么getUser方法中也可以直接用User实体类来接收

9. 上传文件

首先配置最大上传限制，在spring-mvc.xml中配置（这个配置最好是在客户端判断，减少服务器压力）

<!-- 上传文件拦截，设置最大上传文件大小   10M=10*1024*1024(B)=10485760 bytes -->  
	 <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">  
		<property name="maxUploadSize" value="10485760" />  
	</bean> 

@RequestMapping("/upload2")
	public String uploadFile2(@RequestParam("upFile") CommonsMultipartFile file, HttpServletRequest request, HttpServletResponse response){
		///经测试，该方法上传一个9M的文档用时523ms
		if(!file.isEmpty()){
			try {
				long currentTime = System.currentTimeMillis();
				FileOutputStream fosFileOutputStream = new FileOutputStream("D:/" + new Date().getSeconds() + file.getOriginalFilename());
				InputStream inputStream = file.getInputStream();
				byte[] b = new byte[256];
				while (inputStream.read(b) != -1) {
					fosFileOutputStream.write(b);
				}
				fosFileOutputStream.flush();
				fosFileOutputStream.close();
				inputStream.close();
				System.out.println("----uploadFile2用时----" + (System.currentTimeMillis() - currentTime));
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		return "welcome";
	}
	
	@RequestMapping("/upload3")
	public String uploadFile3(@RequestParam("upFile3") CommonsMultipartFile file, HttpServletRequest request, HttpServletResponse response){
		///经测试，该方法上传一个9M的文档用时61ms
		if(!file.isEmpty()){
			try {
				long currentTime = System.currentTimeMillis();
				FileOutputStream fosFileOutputStream = new FileOutputStream("D:/" + new Date().getSeconds() + file.getOriginalFilename());
				BufferedOutputStream bos = new BufferedOutputStream(fosFileOutputStream);
				InputStream inputStream = file.getInputStream();
				BufferedInputStream bis = new BufferedInputStream(inputStream);
				byte[] b = new byte[256];
				while (bis.read(b) != -1) {
					bos.write(b);
				}
				bos.flush();
				bos.close();
				bis.close();
				inputStream.close();
				fosFileOutputStream.close();
				System.out.println("----uploadFile3用时----" + (System.currentTimeMillis() - currentTime));
			}catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		return "welcome";
	}
	
	@RequestMapping("/upload4")
	public String uploadFile4(HttpServletRequest request, HttpServletResponse response){
		///经测试，该方法上传一个9M的文档用时5ms
		CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());
		if(multipartResolver.isMultipart(request)){
			long currentTime = System.currentTimeMillis();
			MultipartHttpServletRequest multipartRequest = multipartResolver.resolveMultipart(request);
			Iterator<String> iterator = multipartRequest.getFileNames();
			while(iterator.hasNext()){
				MultipartFile multipartFile = multipartRequest.getFile(iterator.next());
				if(multipartFile != null){
					String pathString = "D:/" + new Date().getSeconds() + multipartFile.getOriginalFilename();
					File localFile = new File(pathString);
					try {
						
						multipartFile.transferTo(localFile);
						
					} catch (IllegalStateException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			System.out.println("----uploadFile4用时----" + (System.currentTimeMillis() - currentTime));
		}
		return "welcome";
	}

上面的三种方法，第一种是直接读写字节，上传一个9M的文档大概需要523ms

第二种是使用了缓冲区，上传一个9M的文档大概需要61ms

第三种使用的是Spring自带的上传方法，上传一个9M的文档大概需要5ms