SpringMVC笔记(全网最细，长文警告)

第一章 初识SpringMVC

1.1 SpringMVC概念

• SpringMVC是Spring的子框架

• SpringMVC是Spring 为**【展现层|表示层|表述层|控制层】**提供的基于 MVC 设计理念的优秀的 Web 框架，是目前最主流的MVC 框架。

• SpringMVC是非侵入式的：可以使用注解让普通的Java对象，作为请求处理器【Controller】

• SpringMVC是用来代替Servlet

  Servlet作用

  1. 处理请求
  2. 做出相应

1.2 SpringMVC处理请求的原理图

• 请求
• DispatcherServlet【前端控制器】
  • 将请求交给Controller | Handler
• Controller | Hander【请求处理器】
  • 处理请求
  • 返回数据模型
• ModelAndView
  • Model：数据模型
  • View：视图对象或视图名
• DispatcherServlet渲染视图
  • 将数据共享到域中
  • 跳转页面【视图】
• 响应

第二章 SpringMVC搭建框架

• 导入jar包

  <!--spring-webmvc-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.1</version>
  </dependency>
  
  <!-- 导入thymeleaf与spring5的整合包 -->
  <dependency>
      <groupId>org.thymeleaf</groupId>
      <artifactId>thymeleaf-spring5</artifactId>
      <version>3.0.12.RELEASE</version>
  </dependency>
  
  <!--servlet-api-->
  <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
  </dependency>
  

• 编写配置文件

  web.xml的标头

  <?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
           version="4.0">
  </web-app>
  

  • web.xml注册DispatcherServlet

    • url配置：

      /是除了jsp以外的路径

      /*是所有路径

    • init-param:contextConfigLocation，设置springmvc.xml配置文件路径【管理容器对象】

      <!--    设置springmvc.xml配置文件路径【管理容器对象】-->
          <init-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath:springmvc.xml</param-value>
          </init-param>
      

    • <load-on-startup>：设置DispatcherServlet优先级【启动服务器时，创建当前Servlet对象】

      <!--    设置DispatcherServlet优先级【启动服务器时，创建当前Servlet对象】-->
          <load-on-startup>1</load-on-startup>
      

  • 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:context="http://www.springframework.org/schema/context"
             xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
      <!--    开启组件扫描-->
      <context:component-scan base-package="com.allen"></context:component-scan>
      <!--    配置视图解析器-->
          <bean id="templateResolver"
                class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
              <property name="prefix" value="/WEB-INF/pages/"/>
              <property name="suffix" value=".html"/>
              <property name="characterEncoding" value="UTF-8"/>
              <property name="order" value="1"/>
              <property name="templateMode" value="HTML5"/>
              <property name="cacheable" value="false"/>
          </bean>
      
          <bean id="templateEngine"
                class="org.thymeleaf.spring5.SpringTemplateEngine">
              <property name="templateResolver" ref="templateResolver"/>
          </bean>
      
          <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
              <property name="templateEngine" ref="templateEngine"/>
              <property name="characterEncoding" value="UTF-8"/>
          </bean>
      </beans>
      

• 编写请求处理器

  • 使用**@Controller**注解表示请求处理器
  • 使用**@RequestMapping**注解标识处理方法【URL】

• 准备页面进行测试

第三章 @RequestMapping详解

3.1 @RequestMapping注解位置

• 书写在类上面
  • 作用：为当前类设置映射URL
  • 注意：不能单独使用，需要与方法上的@RequestMapping配合使用
• 书写在方法上面
  • 作用：为当前方法设置映射URL
  • 注意：可以单独使用

3.2 @RequestMapping注解属性

• value属性

  • 类型：String[]
  • 作用：设置URL信息

• path属性

  • 类型：String[]
  • 作用：与value属性作用一致

• method属性

  • 类型：RequestMethod[]

    public enum RequestMethod {
    	GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
    }
    

  • 作用：为当前URL【类或方法】设置请求方式【POST、DELETE、PUT、GET】

  • 注意：

    • 默认情况：所有请求方式均支持
    • 如请求方式不支持，会报如下错误
      • 405【Request method ‘GET’ not supported】

• params

  • 类型：String[]
  • 作用：为当前URL设置请求参数
  • 注意：如设置指定请求参数，但URL中未携带指定参数，会报如下错误
    • 400【Parameter conditions “lastName” not met for actual request parameters:】

• headers

  • 类型：String[]
  • 作用：为当前URL设置请求头信息
  • 注意：如设置指定请求头，但URL中未携带请求头，会报如下错误
    • 404：请求资源未找到

3.3 @RequestMapping支持Ant风格的路径（了解）

• 常用通配符

  a）？：匹配一个字符

  b）*：匹配任意字符

  c）**：匹配多层路径

• 实例代码

  @RequestMapping("/testAnt/**")
  public String testAnt() {
         System.out.println("==>testAnt!");
         return SUCCESS;
  }
  

第四章 @pathVariable注解

4.1 @PathVariable注解位置

@Target(ElementType.PARAMETER)

• 书写在参数前面

4.2 @PathVariable注解作用

• 获取URL中占位符参数

• 占位符语法：{}

• 实例代码

  <a th:href="@{/testPathVariable/100}">测试pathVariable</a>
  

  @RequestMapping("/testPathVariable/{id}")
  public String testVariable(@PathVariable("id") Integer id) {
          System.out.println("id = " + id);
          return SUCCESS;
  }
  

4.3 @pathVariable注解属性

• value属性
  • 类型：String
  • 作用：设置占位符中的凡署名
• name属性
  • 类型：String
  • 作用：与name属性的作用一致
• required属性
  • 类型：boolean
  • 作用：设置当前参数是否必须入参【默认值：true】
    • true：标识当前参数必须入参，如未入参会报如下错误
      • Missing URI template variable ‘id’ for method parameter of type Integer
    • false：标识当前参数不必须入参，如未入参，会装配null值

第五章 REST【RESTful】风格CRUD

5.1 REST的CRUD与传统风格CRUD对比

• 传统风格CRUD

  • 功能 URL 请求方式
  • 增 /insertEmp POST
  • 删 /deleteEmp?empId=1001 GET
  • 改 /updateEmp POST
  • 查 /selectEmp?empId=1001 GET

• REST风格CRUD

  • 功能 URL 请求方式
  • 增 /emp POST
  • 删 /emp/1001 DELETE
  • 改 /emp PUT
  • 查 /emp/1001 GET

5.2 REST风格CRUD优势

• 提高网站排名
  • 排名方式
    • 竞价排名
    • 技术排名
• 便于第三方平台对接

5.3 实现PUT&DELETE提交方式步骤

• 注册过滤器HiddenHttpMethodFilter

      <filter>
          <filter-name>HiddenHttpMethodFilter</filter-name>
          <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
      </filter>
      <filter-mapping>
          <filter-name>HiddenHttpMethodFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
  

• 设置表单的提交方式为POST

  <form th:action="@{/emp}" method="post">
      <input type="hidden" name="_method" value="PUT" >
      <input type="submit" value="修改员工信息">
  </form>
  

• 设置参数：_method=PUT或_method=DELETE

5.4 源码解析HiddenHttpMethodFilter

public static final String DEFAULT_METHOD_PARAM = "_method";

	private String methodParam = DEFAULT_METHOD_PARAM;


	/**
	 * Set the parameter name to look for HTTP methods.
	 * @see #DEFAULT_METHOD_PARAM
	 */
	public void setMethodParam(String methodParam) {
		Assert.hasText(methodParam, "'methodParam' must not be empty");
		this.methodParam = methodParam;
	}

	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {

		HttpServletRequest requestToUse = request;

		if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
			String paramValue = request.getParameter(this.methodParam);
			if (StringUtils.hasLength(paramValue)) {
				String method = paramValue.toUpperCase(Locale.ENGLISH);
				if (ALLOWED_METHODS.contains(method)) {
					requestToUse = new HttpMethodRequestWrapper(request, method);
				}
			}
		}

		filterChain.doFilter(requestToUse, response);
	}


	/**
	 * Simple {@link HttpServletRequest} wrapper that returns the supplied method for
	 * {@link HttpServletRequest#getMethod()}.
	 */
	private static class HttpMethodRequestWrapper extends HttpServletRequestWrapper {

		private final String method;

		public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
			super(request);
			this.method = method;
		}

		@Override
		public String getMethod() {
			return this.method;
		}
	}

第六章 SpringMVC处理请求数据

使用servlet处理请求数据

1. 请求参数

• String param = request.getParameter();

2. 请求头

• request.getHeader();

3. Cookie

• request.getCookies();

6.1 处理请求参数

• 默认情况：可以将请求参数名，与入参参数名一致的参数，自动入参【自动类型转换】

• SpringMVC支持POJO入参

  • 要求：

• @RequestParam注解

  • 作用：如请求参数与入参参数名不一致时，可以使用@RequestParam注解设置入参参数名
  • 属性

• @RequestParam注解

  • 作用：如请求参数与入参参数名不一致时，可以使用@RequestParam注解设置入参参数名

  • 属性

    • value
      • 类型：String
      • 作用：设置需要入参的参数名
    • name
      • 类型：String
      • 作用：与value属性作用一致
    • required
      • 类型：Boolean
      • 作用：设置当前参数，是否必须入参
        • true【默认值】：表示当前参数必须入参，如未入参会报如下错误
          • 400【Required String parameter ‘sName’ is not present】
        • false：表示当前参数不必须入参，如未入参，装配null值
    • defaultValue
      • 类型：String
      • 作用：当装配数值为null时，指定当前defaultValue默认值

  • 示例代码

    @RequestMapping("requestParam1")
    public String param1(@RequestParam(value = "sName"
                                        ,required = false,defaultValue = "张三") String stuName, Integer stuAge){
        System.out.println("stuName = " + stuName);
        System.out.println("stuAge = " + stuAge);
        return SUCCESS;
    }
    

6.2 处理请头

• 语法：@RequestHeader注解

• 属性

  • value
    • 类型：String
    • 作用：设置需要获取请求头名称
  • name
    • 类型：String
    • 作用：与value属性作用一致
  • required
    • 类型：boolean
    • 作用：【默认值true】
      • true：设置当前请求头是否为必须入参，如未入参会报如下错误
        • 400【Required String parameter ‘sName’ is not present】
      • false：表示当前参数不必须入参，如未入参，装配null值
  • defaultValue
    • 类型：String
    • 作用：当装配数值为null时，指定当前defaultValue默认值

• 示例代码

  @RequestMapping("getRequestHead")
  public String getRequestHead(@RequestHeader("User-Agent")String UserAgent,
                               @RequestHeader("Referer") String Referer){
      System.out.println("UserAgent = " + UserAgent);
      System.out.println("Referer = " + Referer);
      return SUCCESS;
  }
  

6.3 获取Cookie

• 属性

  • value
    • 类型：String
    • 作用：设置需要获取Cookie名称
  • name
    • 类型：String
    • 作用：与value属性作用一致
  • required
    • 类型：boolean
    • 作用：【默认值true】
      • true：设置当前Cookie是否为必须入参，如未入参会报如下错误
        • 400【Required String parameter ‘sName’ is not present】
      • false：表示当前Cookie不必须入参，如未入参，装配null值
  • defaultValue
    • 类型：String
    • 作用：当装配数值为null时，指定当前defaultValue默认值

• 示例代码

  // 设置Cookie    
  @RequestMapping("setCookie")
      public String setCookie(HttpSession cookie){
          String id = cookie.getId();
          System.out.println("id = " + id);
          return SUCCESS;
      }
  // 获取Cookie    
      @RequestMapping("getCookie")
      public String getCookie(@CookieValue("JSESSIONID")String cookie){
          System.out.println(cookie);
          return SUCCESS;
      }
  

6.4 使用原生Servlet-API

• 将原生Servlet相关对象，入参即可

• 示例代码

      @RequestMapping("getRealPath")
      public String getRealPath(HttpServletRequest request){
          ServletContext servletContext = request.getServletContext();
          String realPath = servletContext.getRealPath("index.html");
          System.out.println("`realPath` = " + realPath);
          return SUCCESS;
      }
  

第七章 SpringMVC处理响应数据

源码解析ModelAndView

public class ModelAndView {

  /** View instance or view name String. */
  //view代表view对象或viewName【建议使用viewName】
  @Nullable
  private Object view;

  /** Model Map. */
  //ModelMap集成LinkedHashMap,存储数据
  @Nullable
  private ModelMap model;
   
   /**
   	设置视图名称
	 */
	public void setViewName(@Nullable String viewName) {
		this.view = viewName;
	}

	/**
	 * 获取视图名称
	 */
	@Nullable
	public String getViewName() {
		return (this.view instanceof String ? (String) this.view : null);
	}

   /**
	 获取数据，返回Map【无序，model可以为null】
	 */
	@Nullable
	protected Map<String, Object> getModelInternal() {
		return this.model;
	}

	/**
	 * 获取数据，返回 ModelMap【有序】
	 */
	public ModelMap getModelMap() {
		if (this.model == null) {
			this.model = new ModelMap();
		}
		return this.model;
	}

	/**
	 * 获取数据，返回Map【无序】
	 */
	public Map<String, Object> getModel() {
		return getModelMap();
	}
   
   /**
   	设置数据
   */
   public ModelAndView addObject(String attributeName, @Nullable Object attributeValue) {
		getModelMap().addAttribute(attributeName, attributeValue);
		return this;
	}
   
   
}
    

7.1 处理响应数据方式一

• 语法：使用ModelAndView对象作为返回值类型，处理响应数据

• 示例代码

      @RequestMapping("responseData")
      public ModelAndView testModelAndView(){
          ModelAndView modelAndView = new ModelAndView();
          //设置数据
          modelAndView.addObject("stuName","Allen");
          //设置逻辑视图名
          modelAndView.setViewName("response_success");
          return modelAndView;
      }
  

7.2 处理响应数据方式二

• 语法：使用Map或Mode或ModelMap作为参数入参，并处理响应数据

• 体层实现原理

  • 数据共享到 request域
  • 跳转路径方式：转发

• 示例代码

      @RequestMapping("testModelOrModelMapOrMap")
      public String testModelOrModelMapOrMap(Map<String,Object> map) {
      	//设置数据
          map.put("stuName","张三");
          return "response_success";
      }
  

7.3 如何将数据共享到session域

@Controller
@SessionAttributes("stuName")  //将request域数据，同步至session域中
public class ResponseDataController {
   @RequestMapping("testSession")
    public String testSession(/*HttpSession session*/ Map<String,Object> map) {
        //设置数据【session域】
//        session.setAttribute("stuName","zhaoliu");
        
        map.put("stuName","ShowMaker");
        
        return "response_success";
    }
}

了解：在使用map入参时候，是将数据放入请求域中，若想同步在session域中可以在类的上面添加@SessionAttributes(“stuName”) 括号里面写的是需要同步的key

第八章 SpringMVC处理请求域相应乱码问题

javaWeb解决乱码：三行代码

• 解决POST请求乱码
• request.setCharacterEncoding(“UTF-8”);
• 解决GET请求乱码【Tomcat8及以后，自动解决】
• 解决相应乱码
• response.setHeader(“Content-Type”, “text/html;charset=utf-8”);
• response.setContentType(“text/html;charset=utf-8”);

8.1 源码解析CharacterEncodingFilter

public class CharacterEncodingFilter extends OncePerRequestFilter {

   @Nullable
   private String encoding;

   private boolean forceRequestEncoding = false;

   private boolean forceResponseEncoding = false;
   
   	public void setForceEncoding(boolean forceEncoding) {
		this.forceRequestEncoding = forceEncoding;
		this.forceResponseEncoding = forceEncoding;
	}
   
   
   	@Override
	protected void doFilterInternal(
			HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
		//字符集
		String encoding = getEncoding();
		if (encoding != null) {
			if (isForceRequestEncoding() || request.getCharacterEncoding() == null) {
			//解决请求乱码
				request.setCharacterEncoding(encoding);
			}
			if (isForceResponseEncoding()) {
			//解决响应乱码
				response.setCharacterEncoding(encoding);
			}
		}
		filterChain.doFilter(request, response);
	}

8.2 使用CharacterEncodingFilter步骤

1. 注册CharacterEncodingFilter

2. 为CharacterEncodingFilter设置初始化参数

   <!--    处理乱码-->
       <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>
           <init-param>
               <param-name>forceEncoding</param-name>
               <param-value>true</param-value>
           </init-param>
       </filter>
       <filter-mapping>
           <filter-name>CharacterEncodingFilter</filter-name>
           <url-pattern>/*</url-pattern>
       </filter-mapping>
   

第九章 SpringMVC中视图对象及视图解析对象

9.1 视图解析器【ViewResolver】

• 概述：SpringMVC中所有视图解析器对象均实现了ViewResolver接口
• 作用：使用ViewResolver，将View从ViewResolver中解析出来
  • 在SpringMVC中无论方法返回的是ModelAndView还是String，最终底层封装为ModelAndView

9.2 视图对象【View】

• 概述：SpringMVC中所有视图对象【View】均实现View接口
• 作用：视图渲染
  • 将数据共享到域中【request、session、application(ServletContext)】
  • 跳转路径【转发或重定向】

9.3 源码解析SpringMVC工作原理_入门

• DispatcherServlet：1061行代码如下【前端控制器调用Controller的入口】

  // 1061行代码【前端控制器调用Controller的入口】
  mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  // 1078行代码【前端控制器处理ModelAndView对象入口】
  processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  // 1139行代码【渲染视图的入口】
  render(mv, request, response);
  // 1371行代码【视图解析器作用的源码】
  view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
  // 1394行代码【视图渲染的入口，视图对象的源码】
  view.render(mv.getModelInternal(), request, response);
  

  • 进入【1371行代码】resolveViewName()方法内部

    @Nullable
    protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
          Locale locale, HttpServletRequest request) throws Exception {
    
       if (this.viewResolvers != null) {
          for (ViewResolver viewResolver : this.viewResolvers) {
              //视图解析器通过视图viewName解析出View对象
             View view = viewResolver.resolveViewName(viewName, locale);
             if (view != null) {
                return view;
             }
          }
       }
       return null;
    }
    

  • 进入【1394行代码】view.render(mv.getModelInternal(), request, response);

    ThymeleafView对象

    //解决相应乱码
    response.setContentType(computedContentType);
    

  • 在WebEngineContext类的setVariable方法的467行将模型数据放到了request域

9.2 视图及视图解析器源码

视图解析器将View从ModelAndView中解析出来

• ThymeleafViewResolver的837行代码

  //底层使用反射的方式，newInstance()创建视图对象
  final AbstractThymeleafView viewInstance = BeanUtils.instantiateClass(getViewClass());
  

第十章 SpringMVC视图及视图解析器

10.1 视图解析器对象【ViewResolver】

• 概述：ViewResolver接口的实现类或子接口，称之为视图解析器

• 作用：将ModelAndView中的View对象解析出来

10.2 视图对象【View】

• 概述：View接口的实现类或子接口，称之为视图对象
• 作用：视图渲染
  1. 将数据共享域中
  2. 跳转路径【转发或重定向】

第十一章 视图控制器&重定向&加载静态资源

11.1 视图控制器

• 语法：view-controller
• 步骤：
  1. 添加<mvc:view-controller>标签
  2. 添加<mvc:annotation-driven>
     • 有20+种功能
     • 配置了<mvc:view-controller>标签之后会导致其他请求路径都失效，添加<mvc:annotation-driven>

11.2 重定向

• 语法：return"**redirect:/**xxx.html"

11.3 加载静态资源

• 由DefaultServlet加载静态资源到服务器

  • 静态资源：html、css、js等资源
  • tomcat->conf->web.xml关键代码如下：

  <servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
          <init-param>
              <param-name>debug</param-name>
              <param-value>0</param-value>
          </init-param>
          <init-param>
              <param-name>listings</param-name>
              <param-value>false</param-value>
          </init-param>
        <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
          <servlet-name>default</servlet-name>
          <url-pattern>/</url-pattern>
  </servlet-mapping>
  

• 发现问题

  • DispatcherServlet与DefaultDiServlet的URL配置均为：/，导致DefaultDiServlet中的配置将DefaultDiServlet配置的/覆盖掉了【DefaultDiServlet失效，无法加载静态资源】

• 解决方案

  <!--   解决静态资源加载问题-->
      <mvc:default-servlet-handler></mvc:default-servlet-handler>
  <!--   添加上述标签，会导致Controller无法正常使用，需要添加mvc:annotation-driven解决-->
      <mvc:annotation-driven></mvc:annotation-driven>
  

11.4 源码解析重定向原理

• 创建RedirectView对象【ThymeleafViewResolver的第775行代码】

  // Process redirects (HTTP redirects)
  if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
      vrlogger.trace("[THYMELEAF] View \"{}\" is a redirect, and will not be handled directly by ThymeleafViewResolver.", viewName);
      final String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length(), viewName.length());
      final RedirectView view = new RedirectView(redirectUrl, isRedirectContextRelative(), isRedirectHttp10Compatible());
      return (View) getApplicationContext().getAutowireCapableBeanFactory().initializeBean(view, REDIRECT_URL_PREFIX);
  }
  

• RedirectView视图渲染

  • RedirectView对象URL处理【330行代码】

    

  • 执行重定向【RedirectView的627行代码】

    

第十二章 REST风格CRUD练习

12.1 搭建环境

• 导入相关jar包

  <!--spring-webmvc-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.1</version>
  </dependency>
  
  <!-- 导入thymeleaf与spring5的整合包 -->
  <dependency>
      <groupId>org.thymeleaf</groupId>
      <artifactId>thymeleaf-spring5</artifactId>
      <version>3.0.12.RELEASE</version>
  </dependency>
  
  <!--servlet-api-->
  <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
  </dependency>
  

• 编写配置文件

  • web.xml
    • CharacterEncodingFilter
    • HiddenHttpMethodFilter
    • DispatcherServlet
  • springmvc.xml
    • 开启组件扫描
    • 装配视图解析器
    • 装配视图控制器
    • 解决静态资源加载问题
    • 装配annotation-driver

• dao&pojo

12.2 实现功能思路

• 实现添加功能思路

  1. 跳转添加页面【查询所有部门信息】
  2. 实现添加功能

• 实现删除功能思路

  1. 方式一：直接使用表单实现DELETE提交方式

  2. 方式二：使用超链接【a】实现DELETE提交方式

     • 使用Vue实现单击超链接，后提交对应表单

     • 取消超链接默认行为

     • 示例代码

  <div align="center" id="app">
      <a href="#" @click="deleteEmp">删除</a>
      <form id="delForm" th:action="@{/emps/}+${emp.id}" method="post">
          <input type="hidden" name="_method" value="DELETE">
      </form>
  </div>
  <script type="text/javascript" src="static/js/vue_v2.6.14.js"></script>
  <script type="text/javascript">
      new Vue({
          el:"#app",
          data:{},
          methods:{
              deleteEmp(){
                  alert("hehe");
                  //获取响应表单
                  var formEle = document.getElementById("delForm");
                  formEle.submit();
                  //取消超链接默认行为
                  event.preventDefault();
              }
          }
      });
  </script>
  

第十三章 SpringMVC消息转换器

13.1 消息转换器概述

• HttpMessageConverter<T>：消息转换器主要作用

  • 将Java对象与请求报文及响应报文的相互转换

    

  • 使用HttpMessageConverter<T>将请求信息转化并绑定到处理方法的入参中或将响应结果转为对应类型的相应信息，Spring提供了两种途径：

    1. 使用@RequestBody/@ResponseBody对处理方法进行标注。
    2. 使用HttpEntity<T>ResponseEntity<T>作为处理方法的入参或返回值。

13.2 使用消息转换器处理请求报文

• 使用@RequestBody获取请求体

  • 语法

  @RequestMapping(value = "/requestBodyTest", method = RequestMethod.POST)
  public String requestBodyTest(@RequestBody String requestBody) {
          System.out.println("requestBody = " + requestBody);
          return SUCCESS;
  }
  

  • 注意：使用@RequestBody必须以POST方式提交，不能使用GET方式【GET提交方式，没有请求体】

• 使用HttpEntity<T>

  • 语法：

     @RequestMapping(value = "/httpEntityTest",method = RequestMethod.POST)
      public String httpEntityTest(HttpEntity<String> httpEntity) {
          System.out.println("httpEntity = " + httpEntity);
          //获取请求头
          System.out.println("Header = " +  httpEntity.getHeaders());
          //获取请求体
          System.out.println("Body = " + httpEntity.getBody());
          return SUCCESS;
      }
  

  • 可以获取请求体及请求头

13.3 使用消息转换器处理响应报文

• @ResponseBody

  • 位置
    • 书写在class类上面【当前类所有方法，均返回文本，不跳转页面】
    • 书写在方法上面【在当前类下只有标记@ResponseBody的方法才会返回文本，不跳转页面】
  • 语法

  /**
  * 测试ResponseBody
  * @return
  */
  @ResponseBody
  @RequestMapping(value = "/responseBodyTest",method = RequestMethod.POST)
  public String responseBodyTest() {
          System.out.println("ResponseBody!!!!");
          return "Hello World";
  }
  

  • 作用：将指定数据，直接以响应流的方式，响应数据。
    • 类似response.getWriter().write()

• 使用步骤

  1. 添加jackson支持

     <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
     <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.3</version>
     </dependency>
     

  2. 装配MappingJackson2httpMessageConverter消息转换器

     • 必须配置mvc:annotation-driver标签才能装配Jackson的转换器

  3. 在需要转换json数据的方法上，添加@ResponseBody

     • 需要被转换的数据作为方法的返回值

      /**
       * 测试ResponseBody发送json数据
       * @return
       */
      @ResponseBody
      @RequestMapping(value = "/responseBodyToJsonTest",method = RequestMethod.GET)
      public Employee responseBodyToJson() {
          Employee employee = new Employee(1001,"allen","allen@163.com",1);
          return employee;
      }
  

• 底层实现原理【MappingJack2HttpMessageConverter】

  • 添加jar包

  • 装配mvc:annotation-driver

  • 添加支持之前

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tdEsbmqP-1680232274969)(C:/Users/99301/AppData/Roaming/Typora/typora-user-images/image-20230327195706727.png)]

  • 添加支持之后

    

第十四章 SpringMVC文件上传与文件下载

文件上传与下载底层逻辑

14.1 文件下载

• 实现文件下载步骤

  • 准备文件下载相关资源
  • 将ResponseEntity<T>对象，作为方法返回值
  • 为ResponseEntity<T>对象，设置三个参数

• 示例代码

      @RequestMapping(value = "/downLoadController",method = RequestMethod.GET)
      public ResponseEntity<byte[]> fileDownLoad(HttpServletRequest request, String filename){
          ResponseEntity<byte[]> responseEntity = null;
          //获取文件对应的真实路径
          java.lang.String realPath = request.getServletContext().getRealPath("/WEB-INF/download/" + filename);
          // 创建输入流
          try {
              InputStream is = new FileInputStream(realPath);
              //文件下载byte[]
              byte[] bytes = new byte[is.available()];
              is.read(bytes);
              //设置响应头
              HttpHeaders headers = new HttpHeaders();
              //设置要下载的文件的名字【及文件格式为附件格式，通知服务器下载当前资源，而不是打开】
              headers.add("Content-Disposition","attachment;filename=" + filename);
              //处理中文文件名问题
              headers.setContentDispositionFormData("attachment",new String(filename.getBytes("utf-8"),"ISO-8859-1"));
              //状态码
              responseEntity = new ResponseEntity<>(bytes,headers, HttpStatus.OK);
              is.close();
          } catch (Exception e) {
              throw new RuntimeException(e);
          }
          return responseEntity;
      }
  

14.2 文件上传

• 实现文件上传的思路

  • 准备工作

    • 准备文件上传的页面

      • 表单的提交方式必须为POST
      • 设置表单enctype属性值为multipart/form-data
      • 表单中包含文件域【type=file】

    • 导入jar包

      <!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
      <dependency>
          <groupId>commons-fileupload</groupId>
          <artifactId>commons-fileupload</artifactId>
          <version>1.4</version>
      </dependency>
      

    • 装配解析器：CommonMultipartResolver

      • id必须是：multipartResolver
      • 设置上传文件字符集：defaultEncoding=UTF-8

  • 实现步骤

    • 将type=file【文件域】直接入参：MultipartFile
    • 获取文件名称
    • 获取上传文件真实路径
    • 实现文件上传

• 示例代码

    /**
       * 实现文件上传
       * @param text
       * @param uploadFile
       * @param session
       * @return
       */
      @RequestMapping(value = "/fileUpLoadController",method = RequestMethod.POST)
      public String fileUpLoad(String text,
                               MultipartFile uploadFile,
                               HttpSession session){
          try {
              //获取文件名字
              String fileName = uploadFile.getOriginalFilename();
              //获取上传路径
              String realPath = session.getServletContext().getRealPath("/WEB-INF/upload/");
              //判断上传路径是否存在，如果不存在就创建
              File filePath = new File(realPath);
              if(!filePath.exists()){
                  filePath.mkdirs();
              }
              //上传文件
              File file = new File(filePath + File.separator + fileName);
              uploadFile.transferTo(file);
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
          return "success";
      }
  

  • 优化文件上传

    • 允许同名文件上传

      • 使用UUID解决文件名重复问题

        • UUID是一个32位16进制随机数【特点：全球唯一】

        • 示例代码

          //创建UUID
          String uuid = UUID.randomUUID().toString().replace("-","");
          //上传文件【File.separator：路径分隔符】
          File file = new File(filePath + File.separator + uuid + fileName);
          

      • 使用时间戳解决文件名重复问题

        • System.currentTimeMillis();
          

    • 设置上传文件大小限制

      • 在装配CommonsMultipartResolver时，设置上传文件的上线

        <!--    装配CommonsMultipartResolver -->
            <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
                <property name="defaultEncoding" value="UTF-8"></property>
                <property name="maxUploadSizePerFile" value="1024000"></property>
            </bean>
        

第十五章 SpringMVC中拦截器

15.1 拦截器与过滤器的区别

• 过滤器【Filter】属于web服务器组件

  • 过滤器主要作用：过滤Servlet请求
  • 执行实际：两处执行实际【Servlet前、Servlet后】

• 拦截器【Interceptor】属于框架【SpringMVC】

  • 拦截器主要作用：拦截Controller请求
  • 执行实际：三处执行时机
    1. 执行DispatcherServlet之后，Controller之前
    2. 执行Controller之后，DispatcherServlet之前
    3. 执行DispatcherServlet之后【渲染视图之后】

• 图解

  

15.2 拦截器概述

• SpringMVC可以使用拦截器实现拦截Controller请求，用户可以自定义拦截器来实现特定的功能
• 实现拦截器两种方式
  • 实现接口：handlerInterceptor
  • 继承适配器类：HandlerInterceptorAdapter
• 拦截器中的三个方法
  • preHandle()：这个方法在业务处理器处理请求之前被调用，可以在此方法中做一些权限的校验。如果程序员决定该拦截器对请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，则返回true；如果程序员决定不需要再调用其他的组件去处理请求，则返回false/
  • postHandle()：这个方法再业务处理器处理请求之后，渲染视图之前调用。在此方法中可以对ModelAndView中的模型和视图进行处理。
  • afterCompletion()：这个方法再DispatcherServlet完全处理碗请求后被调用，可以在该方法中进行一些资源清理的操作。

15.3 实现拦截器步骤

• 实现接口：HandleInterceptor

• 重写三个方法

• 在spingMVC.xml配置文件中，装配拦截器

  <!--    全局配置拦截器-->
  <mvc:interceptors>
  <!--    <bean id="interceptor" class="com.allen.interceptor.MyInterceptor"></bean>-->
          <ref bean="myInterceptor"></ref>
  </mvc:interceptors>
  
  <!--    局部配置拦截器-->
      <mvc:interceptors>
          <mvc:interceptor>
              <mvc:mapping path="/responseBodyToJsonTest"/>
              <ref bean="myInterceptor"></ref>
          </mvc:interceptor>
      </mvc:interceptors>
  

  package com.allen.interceptor;
  
  import org.springframework.stereotype.Component;
  import org.springframework.web.servlet.HandlerInterceptor;
  import org.springframework.web.servlet.ModelAndView;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  /**
   * ClassName: MyInterceptor
   * Package: com.allen.interceptor
   * Description:
   *
   * @Author: 艾伦
   * @Create: 2023/3/27 - 22:56
   * @Version: v1.0
   */
  @Component
  public class MyInterceptor implements HandlerInterceptor {
      /**
       * 执行1【controller执行之前】
       * @param request
       * @param response
       * @param handler
       * @return
       * @throws Exception
       */
      @Override
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
          System.out.println("==>MyInterceptor->preHandle()!");
          return true;
      }
  
      /**
       * 执行2【controller执行之后】
       * @param request
       * @param response
       * @param handler
       * @param modelAndView
       * @throws Exception
       */
  
      /**
       * 执行3【视图渲染之后】
       * @param request
       * @param response
       * @param handler
       * @param modelAndView
       * @throws Exception
       */
      @Override
      public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
          System.out.println("==>MyInterceptor->postHandle()!");
      }
  
      @Override
      public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
          System.out.println("==>MyInterceptor->afterCompletion()!");
      }
  }
  

15.4 拦截器的工作原理

• 单个拦截器工作原理
  • 浏览器向服务器发送请求
  • 执行拦截器第一个方法preHandle()
  • 执行Controller中方法，处理请求做出响应
  • 执行拦截器第二个方法postHandle()
  • 执行DispatcherServlet中渲染视图
  • 执行拦截器第三个方法afterCompletion()
  • 响应
• 多个拦截器工作原理
  • 浏览器向服务器发送请求
  • 执行拦截器1第一个方法preHandle()
  • 执行拦截器2第一个方法preHandle()
  • 执行Controller中方法，处理请求做出相应
  • 执行拦截器2第二个方法postHandle()
  • 执行拦截器1第二个方法postHandle()
  • 执行DispatcherServlet中渲染视图
  • 执行拦截器2第三个方法afterCompletion()
  • 执行拦截器1第三个方法afterCompletion()
  • 响应

拦截器的顺序由配置的顺序决定

15.6 拦截器preHandle()方法返回值

• 当第一个拦截器preHandle()方法返回false时，执行当前方法后，程序终止。
• 当不是第一个拦截器preHandle()方法返回false时
  • 执行当前拦截器及之前拦截器的preHandle()方法
  • 执行之前拦截器的afterCompletion()方法

第十六章 SpringMVC异常处理器

16.1 为什么需要处理异常

• 如果程序执行当中出现异常，未处理导致程序终止【宕机】
• JavaSE阶段异常处理机制
  • try-catch-finally
  • throw或throws

16.2 SpringMVC中异常处理器

• SpringMVC通过HandlerExceptionResolver处理长须的异常，包括Handler映射、数据绑定以及目标方法执行时发生的异常

• 需要账务两个异常处理器实现类

  • DefaultHandleExceptionResovler
  • SimpleMappingExceptionResolver
    • 映射自定义异常处理器，作用：将指定的异常映射到指定页面
    • 装配异常处理器【SimpleMappingExceptionResolver】

• 总结

  • 出现异常，不会执行postHandle()

  

  • 出现异常，也会返回ModelAndView

  

第十七章 SpringMVC工作原理

17.1 扩展三个对象

• HandlerMapping

  • 概述：请求处理器的映射器对象

  • 作用：通过HandlerMapping可以获取HandlerExecutionChain对象

  • 源码

    //源码
    /*Interface to be implemented by objects that define a mapping between requests and handler objects.*/
    //自己理解
    //HandlerMapping定义了一个映射关系，所有的请求与请求处理器的映射关系
    

• HandlerExecutionChain

  • 概述：请求处理器执行链对象

  • 通过HandlerExecutionChain可以获取HandlerAdapter对象

  • 源码

    //源码
    /*Handler execution chain, consisting of handler object and any handler interceptors. Returned by HandlerMapping's HandlerMapping.getHandler method.
    */
    //自己理解
    //请求处理器执行链对象，由当前请求处理器【Controller】和对应拦截器【Interceptors】组成
    

• HandlerAdapter

  • 概述：请求处理器适配器对象
  • 作用：通过HandlerAdapter的ha.handle()调用请求处理器中相应方法

17.2 SpringMVC工作原理1【URL不存在】

1. 请求【浏览器向服务器发送请求，携带URL（/testSpringMVCWorking）】
2. 通过DispatcherServlet加载SpringMVC容器对象，从而加载Controller【请求处理器】
3. 判断URL是否存在
   • 不存在：判断是否配置<mvc:default-servlet-handler>
     • 配置：出现404现象，同时提示URL不可用
     • 未配置：出现404现象，但不会提示

17.3 SpringMVC工作原理2【URL存在】

1. 请求【浏览器向服务器发送请求，携带URL（/testSpringMVCWorking）】

2. 通过DispatcherServlet加载SpringMVC容器对象，从而加载Controller【请求处理器】

   • 加载三个对象【HandlerMapping、HandlerExecutionChain、HandlerAdapter】

3. 判断URL是否存在【存在】

4. 执行Interceptor【拦截器】第一个方法【preHandle】

   //DispatcherServlet中的1056行代码
   if (!mappedHandler.applyPreHandle(processedRequest, response)) {
   	return;
   }
   

5. 执行Controller【请求处理器】中的相应方法【处理请求，做出响应】

   //DispatcherServlet中的1068行代码
   // Actually invoke the handler.
   mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
   
   

6. 判断Controller中是否存在异常

   • 存在异常
     • 通过HandlerExceptionResolver异常处理器处理异常，并返回ModelAndView
   • 不存在异常
     • Controller返回ModelAndView
     • 触发拦截器第二个方法【postHandle】

7. 通过ViewResolver【视图解析器对象】将View【视图对象】从ModelAndView中解析出来

   //DispatcherServlet中的1435行代码
   if (this.viewResolvers != null) {
      for (ViewResolver viewResolver : this.viewResolvers) {
         View view = viewResolver.resolveViewName(viewName, locale);
         if (view != null) {
            return view;
         }
      }
   }
   

8. View对象开始渲染视图

   • 将数据共享
   • 路径跳转

9. 执行拦截器第三个方法【afterCompletion()】

   //DispatcherServlet中的1157行代码
   if (mappedHandler != null) {
      // Exception (if any) is already handled..
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
   

10. 响应

17.4 总结

• 请求，通过DispatcherServlet加载SpringMVC容器对象，并加载三个对象，从而加载Controller【请求处理器】
• 判断URL是否存在【存在】
  • 存在
    • 执行Interceptor【拦截器】第一个方法【preHandle】
    • 执行Controller【请求处理器】中的相应方法【处理请求，做出响应】
      • 判断Controller中是否存在异常
        • 存在异常
          • 通过HandlerExceptionResolver异常处理器处理异常，并返回ModelAndView
        • 不存在异常
          • Controller返回ModelAndView
          • 触发拦截器第二个方法【postHandle】
    • 通过ViewResolver【视图解析器对象】将View【视图对象】从ModelAndView中解析出来
    • View对象开始渲染视图
    • 执行拦截器第三个方法【afterCompletion()】
    • 执行拦截器第三个方法【afterCompletion()】
  • 不存在
    • 不存在：判断是否配置<mvc:default-servlet-handler>
      • 配置：出现404现象，同时提示URL不可用
      • 未配置：出现404现象，但不会提示
• 响应