綠 青 色

SpringMVC总结

SpringMVC

  Spring MVC是Spring提供的一个强大而灵活的web框架。借助于注解,Spring MVC提供了几乎是POJO的开发模式,使得控制器的开发和测试更加简单。这些控制器一般不直接处理请求,而是将其委托给Spring上下文中的其他bean,通过Spring的依赖注入功能,这些bean被注入到控制器中。

  Spring MVC主要由DispatcherServlet、处理器映射、处理器(控制器)、视图解析器、视图组成。

两个核心:

  处理器映射:选择使用哪个控制器来处理请求.

  视图解析器:选择结果应该如何渲染.

Servlet有哪些功能:

  1. 根据URL 找到Servlet : 解析请求 -----> 找到对应的Servlet

  2. 处理请求 : 获取请求的头信息 获取请求的数据

  3. 响应 : JSP HTML JSON Servlet:

    1. 将JSP内容,根据格式渲染HTML页面

    2. 将HTML内容,直接渲染成HTML页面

    3. JSON数据解析 : 字符串 resp.setContentType ("text/json;charset=UTF-8") :封装了JSON对象 Javascript对象

    4. Servlet解析,调用
      解析:解析
      渲染:告诉浏览器 数据格式
     Servlet :

      1.解析URL
      2.处理请求
      3.处理数据
      4.渲染视图

  尽可能职能是单一的,但是此时Servlet自身职能相对较多. 地址 各种if

  其二,本身Servlet 每个只能处理一个请求 。Service,当请求多时,需要定义多个Servlet

  对象多,代码复用性降低,性能也会降低。

基于Servlet可能存在的问题:

  Servlet调用Service:AService  BService : 业务处理.

  Spring对Servlet进行了封装:SpringMVC,这个框架只充当控制层.

SpringMVC原理图

springMVC架构流程:

​ 1. 用户发送请求到前端控制器DispatcherServlet

​ 2. DispatcherServlet 收到请求调用 HanderMapping 处理器映射器

​ 3. 处理器映射器根据请求 URL 找到具体的处理器,生成处理器对象及处理器拦截器(若有则生成)一并返回给 DispatcherServlet

​ 4. DispatcherServlet 通过 HandlerAdapter 处理器适配器调用处理器

​ 5. 执行处理器 Controller (也叫后端控制器)

​ 6. Controller 执行完成后返回 ModeAndView

​ 7. HandlerAdapter 将 controller 执行结果 ModeAndView 返回给 DispatcherServlet

​ 8. DispatcherServlet 将 ModeAndView 传给 ViewReslover 视图解析器

​ 9. ViewReslover 解析后返回具体 View

​ 10. DispatcherServlet 对 View 进行渲染视图(即将模型数据填充至视图中)

​ 11. DispatcherServlet 响应用户

springmvc 的三大组件

  处理器映射器(HanderMapping)处理器适配器(HandlerAdapter)视图解析器(ViewReslover)

springMVC流程原理:
  客户端(浏览器)发送请求到DispatcherServlet(调度器),DispatcherServlet(调度器)收到请求后,根据请求调用HandlerMapping(处理器映射器),HandlerMapping(处理器映射器)根据请求的URL找到具体的处理器,处理器生成处理器对象返回给DispatcherServlet(调度器),DispatcherServlet(调度器)通过HandlerAdapter(处理器适配器)调用Handler(处理器),Handler(处理器)处理相应的Service(业务层)业务逻辑,Handler(处理器)处理完成后找到ModelAndView(模型视图处理器)对象(Model是返回的数据对象(解析数据),View是一个逻辑上的View)传给ViewResolver(视图映射器)查找对应的View(逻辑视图)进行视图渲染(实际视图),DispatcherServlet(调度器)把返回的Model传给View,通过View响应给客户端(浏览器)。

1. DispatcherServlet接口:

  Spring提供的前端控制器,所有的请求都有经过它来统一分发。在DispatcherServlet将请求分发给Spring Controller之前,需要借助于Spring提供的HandlerMapping定位到具体的Controller。

2. HandlerMapping接口:

  能够完成客户请求到Controller映射。

3. Controller接口:

  需要为并发用户处理上述请求,因此实现Controller接口时,必须保证线程安全并且可重用。

  Controller将处理用户请求,这和Struts Action扮演的角色是一致的。一旦Controller处理完用户请求,则返回ModelAndView对象给DispatcherServlet前端控制器,ModelAndView中包含了模型(Model)和视图(View)。

  从宏观角度考虑,DispatcherServlet是整个Web应用的控制器;从微观考虑,Controller是单个Http请求处理过程中的控制器,而ModelAndView是Http请求过程中返回的模型(Model)和视图(View)。

4. ViewResolver接口:

  Spring提供的视图解析器(ViewResolver)在Web应用中查找View对象,从而将相应结果渲染给客户。

SpringMVC使用

  1. 下载相关jar包,由于SpringMVC是Spring提供的框架,Spring的jar中,,包含SpringMVC相关jar包
spring-web-4.3.24.RELEASE.jar
spring-webmvc-4.3.24.RELEASE.jar
  1. 配置DispatcherServlet,让这个Servlet处理所有请求
<!-- 配置DispatcherServlet  调度器 -->
<servlet>
  	<servlet-name>springmvc</servlet-name>
  	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  	<!-- 配置SpringMVC的映射器需要的文件 -->
  	<init-param>
  		<!-- 处理器映射器文件属性名 -->
  		<param-name>contextConfigLocation</param-name>
  		<!-- 具体的处理器文件 -->
  		<param-value>classpath:spring-mvc.xml</param-value>
  	</init-param>
  	<!-- 配置启动时机 -->
  	<load-on-startup>1</load-on-startup>
</servlet>
  
<servlet-mapping>
  	<servlet-name>springmvc</servlet-name>
  	<url-pattern>*.do</url-pattern>
</servlet-mapping>
  1. 定义处理器Handler

方式一:

package com.sxt.controller;

import java.io.IOException;

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

import org.springframework.web.HttpRequestHandler;

public class Controller01 implements HttpRequestHandler   {
	@Override
	public void handleRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		request.setAttribute("name", "Hello  Spring MVC");
		//跳转到 info.jsp
		request.getRequestDispatcher("info.jsp").forward(request, response);
	}

}

方式二:

package com.sxt.controller;

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

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class Controller02 implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		ModelAndView modelAndView = new ModelAndView();
		// 设置model数据
		modelAndView.addObject("name", "Hello Spring MVC");
		// 设置视图地址
		modelAndView.setViewName("info.jsp");
		return modelAndView;
	}

}
  1. 配置处理器,让调度器通过处理器映射器找到处理器
<?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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 处理器的配置文件 -->
	<!-- 注册处理器 -->
	<bean name="/controller01.do" class="com.sxt.controller.Controller01"></bean>
	<bean name="/controller02.do" class="com.sxt.controller.Controller02"></bean>
	<!-- 扫描注解 -->
	<context:component-scan base-package="com.sxt"></context:component-scan>
	<!-- 让 mvc 注解生效  -->	
	<mvc:annotation-driven></mvc:annotation-driven>
</beans>
  1. 请求
http://127.0.0.1:8080/springmvc/controller01.do

注解版

注解方式:

<!-- 扫描注解 -->
<context:component-scan base-package="com.sxt"></context:component-scan>
<!-- 让 mvc 注解生效  -->	
<mvc:annotation-driven></mvc:annotation-driven>

定义处理器

package com.sxt.controller;

import java.io.IOException;

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

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class Controller03 {

	@RequestMapping("/hello.do")
	public void hello(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
		req.setAttribute("name", "Hello Spring MVC");
		req.getRequestDispatcher("info.jsp").forward(req, resp);
	}
	
	@RequestMapping("/hello1.do")
	public ModelAndView hello1()  {
		ModelAndView  modelAndView = new ModelAndView();
		modelAndView.addObject("name",  "Hello Spring MVC");
		modelAndView.setViewName("info.jsp");
		return modelAndView;
	}
	
	
	@RequestMapping("/hello2.do")
	public String hello2(Model model)  {
		model.addAttribute("name",  "Hello Spring MVC");
		return "info.jsp";
	}
}

SpringMVC初始化流程:

DispatcherServlet : ---  init

DispatcherServlet 中没有init 方法
	|--- DispatcherServlet的父类:FrameworkServlet
			|--- FrameworkServlet 没有init方法 : FrameworkServlet的父类
				|--- HttpServletBean 中init方法 :   initServletBean () :
					|--- FrameworkServlet.initServletBean()
							|--- FrameworkServlet:initWebApplicationContext()
									|---FrameworkServlet.createWebApplicationContext() : 加载  springmvc的配置文件,且初始化handler对象
									|--- FrameworkServlet.onRefresh() : DispatcherServlet.onRefresh(WebApplicationContext)
									|--- DispatcherServlet.initStrategies(ApplicationContext) : 初始化DispatcherServlet 从DispatcherServlet.properties 进行默认的配置

@RequestMapping

@GetMapping/@PostMapping

value/path : 映射地址:

  该注解可以使用在类上面,也可以使用在方法上面.映射地址,是按照类上面该注解的value/path属性值与方法上面value/path属性进行拼接,组成URL路径.

method : 支持的请求方式.若不写,则默认GET和POST请求都支持.

在Spring新的版本中,使用 @PostMapping代理method为post,@GetMapping代替了method为get

params:限定请求中必须含有的参数

headers:限定请求中必须包含的请求头信息

consumes:限定请求的数据格式

produces:限定返回的数据格式

数据绑定-获取请求参数

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="user/add.do">
	<p>用户名:<input type="text"  name="userName1"/></p>
	<p>密码:<input type="text"  name="password"/></p>
	<p>年龄:<input type="text"  name="age"/></p>
	<input type="submit" value="提交">
</form>
<hr>
<form action="user/add2.do">
	<p>用户名:<input type="text"  name="userName"/></p>
	<p>密码:<input type="text"  name="password"/></p>
	<p>年龄:<input type="text"  name="age"/></p>
	<input type="submit" value="提交">
</form>
<hr>
<form action="user/add3.do">
	<p>用户名:<input type="text"  name="userName1"/></p>
	<p>密码:<input type="text"  name="password1"/></p>
	<p>年龄:<input type="text"  name="age1"/></p>
	<input type="submit" value="提交">
</form>
<hr>
<form action="user/add4.do">
	<p>用户名:<input type="text"  name="userName1"/></p>
	<p>密码:<input type="text"  name="password1"/></p>
	<p>年龄:<input type="text"  name="age1"/></p>
	<input type="submit" value="提交">
</form>
<h2>map</h2>
<form action="user/add5.do">
	<p>用户名:<input type="text"  name="userName1"/></p>
	<p>密码:<input type="text"  name="password1"/></p>
	<p>年龄:<input type="text"  name="age1"/></p>
	<input type="submit" value="提交">
</form>
<h2>list</h2>
<form action="user/add6.do">
	<p>爱好:
		<input type="checkbox"  name="like" value="篮球"/>
		<input type="checkbox"  name="like" value="足球"/>
		<input type="checkbox"  name="like" value="羽毛球"/>
		<input type="checkbox"  name="like" value="乒乓球"/>
	</p>
	<input type="submit" value="提交">
</form>
<h2>格式化</h2>
<form action="user/add7.do">
	<p>用户名:<input type="text"  name="userName"/></p>
	<p>密码:<input type="text"  name="password"/></p>
	<p>生日:<input type="text"  name="age"/></p>
	<input type="submit" value="提交">
</form>
<h2>格式化</h2>
<form action="user/add8.do">
	<p>用户名:<input type="text"  name="userName"/></p>
	<p>密码:<input type="text"  name="password"/></p>
	<p>生日:<input type="text"  name="age"/></p>
	<input type="submit" value="提交">
</form>
</body>
</html>
package com.sxt.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

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

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.ModelAndView;

import com.sun.xml.internal.ws.client.RequestContext;
import com.sxt.pojo.User;

@Controller
@RequestMapping("/user")
public class UserController {

	/**
	 *  简单的数据类型绑定
	 * 	在SpringMVC中,获取请求参数参数,只需要方法中形式参数的名称与请求的数据的name属性值一致,就可以自动的绑定相关参数 且简单数据类型可以自动进行数据转换.
	 * @param userName
	 * @param password
	 * @param age
	 * @return: void
	 */
	@RequestMapping("/add.do")
	public void add(String userName,String password,Integer age) {
		System.out.println(userName);
		System.out.println(password);
		System.out.println(age);
	}
    
	/**
	 *  获取请求的参数,且将其封装到对象中
	 * 		1. 创建对象
	 * 		2.属性注入 根据set方法进行属性注入
	 * @param user
	 * @return: void
	 */
	@RequestMapping("/add2.do")
	public void add(User user)  {
		System.out.println(user);
	}
	
	/**
	 * 请求参数名称和形式参数名称不一致时  可以使用@RequestParam 别名
	 * @param userName
	 * @param password
	 * @param age
	 * @return: void
	 */
	@RequestMapping("/add3.do")
	public void add3(@RequestParam("userName1")String userName,@RequestParam("password1")String password,@RequestParam("age1")Integer age)  {
		System.out.println(userName);
		System.out.println(password);
		System.out.println(age);
	}
	
	/**
	 * name/value  参数别名
	 * required : 是否是必须传递的参数  默认是true
	 * defaultValue : 当这个参数没有的时候的默认值				
	 * @param userName
	 * @param password
	 * @param age
	 * @return: void
	 */
	@RequestMapping("/add4.do")
	public void add4(@RequestParam(name="userName1",required = false,defaultValue = "我是默认值")String userName,@RequestParam("password1")String password,@RequestParam("age1")Integer age)  {
		System.out.println(userName);
		System.out.println(password);
		System.out.println(age);
	}
	/**
	 * 使用Map接收请求参数
	 * @param map
	 * @return: void
	 */
	@RequestMapping("/add5.do")
	public void add4(@RequestParam Map<String,Object> map)  {
		System.out.println(map);
	}
	/**
	 * 接收数组格式的参数
	 * @RequestParam("参数名称")
	 * @param like
	 * @return: void
	 */
	@RequestMapping("/add6.do")
	public void add6(@RequestParam("like")List<String> like)  {
		System.out.println(like);
	}
	/**
	 * 将字符串格式化 时间对象
	 * @param userName
	 * @param password
	 * @param age
	 * @return: void
	 */
	@RequestMapping("/add7.do")
	public void add6(String userName,String password,@DateTimeFormat(pattern = "yyyy-MM-dd")Date age)  {
		System.out.println(userName);
		System.out.println(password);
		System.out.println(age);
	}
	
	@RequestMapping("/add8.do")
	public void add6(User user)  {
		System.out.println(user);
	}
	/**
	 * 内置对象的注入
	 * @return: void
	 */
	@RequestMapping("/httpObj.do")
	public void httpObj(HttpServletRequest req,HttpServletResponse resp,HttpSession session,Model mode) {
		System.out.println(mode);
		System.out.println(req);
		RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
		ServletRequestAttributes req1 = (ServletRequestAttributes)RequestContextHolder.currentRequestAttributes();
		System.out.println(req1.getRequest().getServletContext());
		System.out.println(requestAttributes);
		System.out.println(resp);
		System.out.println(session);
	}
}

WebUtil

package com.sxt.util;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

public class WebUtil {
	
	/**
	 * 获取当前请求对象
	 * @return
	 * @return: HttpServletRequest
	 */
	public HttpServletRequest getRequest() {
		ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
		return servletRequestAttributes.getRequest();
	}
	/**
	 * 获取当前Session
	 * @return
	 * @return: HttpSession
	 */
	public HttpSession getSession() {
		return getRequest().getSession();
	}
	/**
	 *  获取当前ServletContext 容器
	 * 	当项目直接启动时,可能需要向ServletContext 设置全局参数
	 * 	如果直接使用 request.getServletContext() 会空指针异常
	 *  所以需要根据WebApplicationContext 获取
	 * @return
	 * @return: ServletContext
	 */
	public ServletContext ServletContext() {
		HttpServletRequest request = getRequest();
		// 若当前请求存在 则直接从当前请求中获取ServletContext
		if(request != null) {
			return request.getServletContext();
		}else {
			// 若不存在则根据WebApplicationContext 获取当前ServletContext
			return ContextLoader.getCurrentWebApplicationContext().getServletContext();
		}
	}
}

编码过滤器

<filter>
  	<filter-name>charset</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>charset</filter-name>
  	<!-- 此时配置 只过滤 springmvc请求 -->
  	<servlet-name>springmvc</servlet-name>
</filter-mapping>

关于SpringMVC跳转

 SpringMVC中,默认是使用内部转发.

 如果需要使用重定向:redirect:地址

package com.sxt.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/user")
public class UserController {
	/**
	 * springmvc 默认是使用内部转发
	 * @return
	 * @return: String
	 */
	@RequestMapping("list.do")
	public String list() {
		return "/list.jsp";
	}
    
	/**
	 * 若想使用 重定向 :
	 * 		redirect: 地址
	 * @return
	 * @return: String
	 */
	@RequestMapping("list2.do")
	public String list2() {
		return "redirect:/list.jsp";
	}
	
	@RequestMapping("list3.do")
	public ModelAndView list3() {
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.setViewName("/list.jsp");
		return modelAndView;
	}
	
	@RequestMapping("list4.do")
	public ModelAndView list4() {
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.setViewName("redirect:/list.jsp");
		return modelAndView;
	}
	
}

配置视图解析器

<!-- 配置视图解析器 -->
<!-- 
	配置 SpringMVC视图解析器时 
	 	其前后缀 只对 内部转发生效
 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<!-- 配置视图解析器前缀 -->
	<property name="prefix" value="/WEB-INF/jsp"></property>
	<!-- 配置视图解析器后缀 -->
	<property name="suffix" value=".jsp"></property>
</bean>

springmvc返回json数据

package com.sxt.controller;

import org.json.JSONException;
import org.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {
	/**
	 * @Title: list
	 * @author: Mr.T   
	 * @date: 2019年11月26日 下午2:35:12 
	 * @Description: 在springmvc中,方法返回的字符串,默认会当做路径处理.springmvc 默认会解析该路径,
	 * 		因为springmvc 提供了注解 @ResponseBody, 表示该方法返回的是字符,阻止springmvc 当做路径处理
	 * 		默认是用  @ResponseBody 时  中文乱码, 需要设置编码格式  数据格式
	 * @return
	 * @return: String
	 * @throws JSONException 
	 */
	@RequestMapping(value ="/list.do",produces = "text/json;charset=UTF-8" )
	@ResponseBody
	public String  list() throws JSONException {
		System.out.println("==============");
		String msg = "{'name':'张三','age':18}";
		JSONObject json = new JSONObject();
		json.put("name", "张三");
		json.put("age", 18);
		System.out.println(json.toString());
		msg = json.toString();
		return msg;
	}

}

@RestController

  RestController 继承了Controller和ResponseBody,当controller类被RestController修饰时,其下面所有的方法,返回的结果,都会当做字符串输出浏览器. 等价于,在一个类上面定义Controller和ResponseBody.

  一般若用于接口开发,都使用RestController ,若controller不需要进行页面跳转,则可以直接使用RestController。否则(若controller需要页面跳转),只能使用@Controller。

@ResponseBody

  @ResponseBody: 可以作用于方法上和类上面,若作用于方法上,则该方法的返回值,当做字符串输出给客户端.若作用于类上面,则该类中的所有方法的返回值,当做字符串输出给客户端.

springmvc返回json对象

  在springmvc中,默认是使用jackson进行数据解析,进行返回.若返回的结果是一个json对象.可以直接返回.

但是需要导入jackson的相关jar包.

jackson-annotations-2.9.9.jar
jackson-core-2.9.9.jar
jackson-databind-2.9.9.jar
@RequestMapping("/list.do")
public Object list() throws JSONException {
	Map<String,Object> map = new HashMap<String,Object>();
	map.put("name", "韩梅梅");
	return map;
}

@RequestMapping("/list3.do")
public Object list3() throws JSONException {
	User user = new User(1, "韩梅梅", 18);
	return user;
}

文件上传和下载

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<form action="file/upload.do" method="post" enctype="multipart/form-data">
		文本:<input type="text" name="userName" /><br>
		文件:<input type="file" name="fileName" /><br>
			<input type="submit" value="提交" />
	</form>
</body>
</html>

spring-mvc.xml

<!-- 配置解析二进制数据解析器 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</bean>

文件上传

package com.lyang.controller;

import java.io.File;
import java.io.IOException;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

@Controller
@RequestMapping("/file")
public class FileUploadController {

	@RequestMapping("/upload.do")
	public void upload(@RequestParam("fileName")MultipartFile file,String userName) throws IOException {
		// 获取提交的 input name的属性值
		System.out.println(file.getName());
		// 获取文件真实名称
		System.out.println(file.getOriginalFilename());
		// 获取数据的格式
		System.out.println(file.getContentType());
		// 获取文件的输入流
		System.out.println(file.getInputStream());
		// 获取文件的大小(字节)
		System.out.println(file.getSize());
		// 文件进行保存
		file.transferTo(new File("D:\\uploadTest.jpg"));
	}

}

文件下载

package com.lyang.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.FileUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/file")
public class FileDownloadController {

	@RequestMapping("/download.do")
	public void downLoad(HttpServletResponse resp) {
		// 找到需要被下载的文件
		File file = new File("D:\\download.jpg");
		// 创建输入流 读取文件
		FileInputStream fis = null;
		// 输出流
		OutputStream ops = null;
		// 设置数据格式为二进制输数据流,让浏览器不要进行解析
		resp.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
		try {
			// 设置响应头信息 告诉浏览器 文件的相关信息 文件的名称 汉字时 容易出现乱码不识别问题 需要 编码
			String fileName = URLEncoder.encode("下载.jpg", "UTF-8");
			resp.addHeader("Content-Disposition", "form-data;name=\"img\";filename=\"" + fileName + "\"");
			// 输入流绑定需要读取的文件!
			fis = new FileInputStream(file);
			// 获取与客户端绑定的数据流
			ops = resp.getOutputStream();
			byte[] data = new byte[1024];
			int len = -1;
			while ((len = fis.read(data)) != -1) {
				// 向客户端输出
				ops.write(data, 0, len);
				ops.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				fis.close();
				ops.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	@RequestMapping("download2.do")
	public ResponseEntity<byte[]> downLoad2(){
		// 找到需要被下载的文件
		File file = new File("D:\\download.jpg");
		// 存储文件数据的容器
		byte[] fileByte = null;
		ResponseEntity<byte[]> entity = null;
		try {
			// 将文件一次性读到内存中
			fileByte = FileUtils.readFileToByteArray(file);
			// 创建响应头
			HttpHeaders headers = new HttpHeaders();
			// 设置MediaType  为二进制 避免浏览器解析
			headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
			// 设置文件的名称	 如果名称是中文,需要进行转码
			String fileName = URLEncoder.encode("下载.jpg", "UTF-8");
			headers.setContentDispositionFormData("filename", fileName);
			entity = new ResponseEntity<byte[]>(fileByte, headers, HttpStatus.OK);
		} catch (IOException e) {
			e.printStackTrace();
		} 
		return entity;
	}

}

总结

springMVC原理:

  1. 浏览器发送请求,DispatcherServlet(调度器)

  2. DispatcherServlet(调度器)需要要找处理器,找到处理器映射器(HandlerMapping).

  3. 处理器映射器(HandlerMapping)找到对应的处理器: Handler

  4. 处理器: Handler,处理器请求 Service.

  5. 处理器处理完后,找到ModelAndView处理器.

  6. Model解析数据

  7. 视图映射器,查找对应的视图,View渲染视图.

  8. 将视图返回给浏览器

SpringMVC三种方式:

  1. 实现HttpRequestHandler接口

  2. Controller接口

  3. 使用注解 :

SpringMVC的数据绑定:

 @RequestParam : 请求参数的注解

​ value /name : 参数名称

​ required : 必传 : true false 可选参数

​ defaultValue : 参数没有值的时候的默认值

  1. web请求的参数,要与方法中的参数名保持一致。若不一致可以使用RequestParam别名
  2. RequestParam 默认参数必传,设置属性是否必传,设置默认值
  3. 使用Map 和 List 接收数据
  4. SpringMVC 默认是:HttpServletRequest HttpServletResponse HttpSession Model 可以注入的
  5. Spring 提供的工具类 获取到当前 HttpServletRequest 对象 默认的Spring的web容器,是与ServlectContext 绑定的关系,可以根据 Spring 的容器找到 ServlectContext 。

在springMVC中,可以自动注入web对象:

HttpServletRequest

HttpServletResponse

HttpSession

Model

编码过滤器:

  SpringMVC 提供内置的编码过滤器 只需要配置编码即可

跳转:

  SpringMVC 默认是内部转发, 若想使用重定向: redirect:前缀

在SpringMVC中,/表示项目根目录.

配置前缀和后缀:

  配置视图解析器:InternalResourceViewResolver

    prefix 前缀

    suffix 后缀

注意点: 视图解析器的前后缀 对 重定向不生效

参数传递问题:

​ springmvc 推荐使用 Model 优先级高于Request

注意:

​ 在springmvc中,默认配置是支持所有的映射器和适配器,一旦指定了适配器和映射器,其他的就不生效了。

posted @ 2020-03-24 23:53  LYANG-A  阅读(199)  评论(0编辑  收藏  举报