springMVC学习笔记

最新推荐文章于 2024-10-12 22:35:37 发布

不爱吃橘子7

最新推荐文章于 2024-10-12 22:35:37 发布

阅读量126

点赞数

分类专栏： springmvc 文章标签： java spring

本文链接：https://blog.csdn.net/zhw00508zz/article/details/117549601

版权

springmvc 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

springMVC

用maven创建web工程
- 使用maven模板快速创建
- 创建maven工程后添加
spring集成web环境
- 监听器
- ApplicationContext的获取方式（一）配置文件
- ApplicationContext的获取方式（二）配置类
- 获取app的优化
spring提供获取上下文的工具
springMVC简介
springMVC开发步骤
- 快速入门
springmvc组件解析
- springmvc执行流程
- springmvc注解解析
- - @RequestMapping
  - 组件扫描配置filter
- springmvc的xml配置解析
- - springmvc的默认原生组件
- 视图解析器
springmvc的数据响应
- 页面跳转
- - 直接返回字符串
  - 返回ModelAndView对象
- 回写数据
spring获得请求参数
- 基本数据类型
- 获取Pojo(对象)数据
- 获取数组数据
- 获取集合数据(一)
- 获取集合数据(二)
- 引入静态资源问题
- post请求乱码问题
- @RequestParam注解
- 获取restful风格的参数
- 自定义类型转换器
- 获取servlet相关API
- - 原生Servlet对象作为参数
  - 获得请求中的信息
文件上传
Spring JDBCTemplate
- 概述
- 使用步骤
- 快速入门
- 优化
- jdbcTemplate的常用操作
- 知识要点
SpringMVC 拦截器
- 拦截器的作用
- 拦截器和过滤器的区别
- 拦截器快速入门
- 快速入门详解
- 多个拦截器拦截顺序
- 拦截器路径的配置
- 拦截器小结
- 案例
SpringMVC异常处理机制
- 异常处理的2种方式
- 简单异常处理器
- 自定义异常处理器

用maven创建web工程

使用maven模板快速创建

在这里插入图片描述

创建maven工程后添加

1.先创建maven工程
使用idea快速创建
在这里插入图片描述

2.添加webApp
在这里插入图片描述
3.修改路径

spring集成web环境

监听器

当ServletContext被创建时，将app放入ServletContext中，然后再每一个servlet中就可以得到app对象，不必每一个servlet中都再创建容器对象
1.创建监听器

package cn.zhw.mvc.listener;

import cn.zhw.mvc.config.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

//等同于在web.xml配置了该listener
@WebListener
public class ContextLoaderListener implements ServletContextListener {
	//当ServletContextListener被创建时执行该方法
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        //System.out.println("Servlet容器被创建");
        //创建ioc容器对象
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(ApplicationContext.class);
        //获取servletContext对象
        ServletContext servletContext = sce.getServletContext();
        //将ioc容器放入servletContext中
        servletContext.setAttribute("app",app);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
}

2.servlet

package cn.zhw.mvc.web;

import cn.zhw.mvc.config.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(urlPatterns = {"/userServlet"})
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        //获取servletContext
        ServletContext servletContext = this.getServletContext();
        //从servletContext中获取app对象
        AnnotationConfigApplicationContext app = (AnnotationConfigApplicationContext)servletContext.getAttribute("app");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

ApplicationContext的获取方式（一）配置文件

在这里插入图片描述
1.在web.xml中配置初始化参数指定配置文件的名称

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
<!--  全局初始化参数-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>applicationContext.xml</param-value>
  </context-param>
</web-app>

2.配置applicationContext配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <context:component-scan base-package="cn.zhw.mvc"/>
</beans>

3.监听器，和servlet皆用注解形式

package cn.zhw.mvc.listener;

import cn.zhw.mvc.config.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import java.util.Enumeration;

//等同于在web.xml配置了该listener
@WebListener
public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {

        //将app放入servletContext中
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = sce.getServletContext();
        servletContext.setAttribute("app",app);
        System.out.println("Servlet容器被创建");
        }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
}

ApplicationContext的获取方式（二）配置类

1.配置类

package cn.zhw.mvc.config;


import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"cn.zhw.mvc"})
public class ApplicationContext {

}

2.web.xml配置配置类的全限定名

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
<!-- 配置类的全限定名-->
  <context-param>
    <param-name>contextConfigClass</param-name>
    <param-value>cn.zhw.mvc.config.ApplicationContext</param-value>
  </context-param>
</web-app>

3.监听器

package cn.zhw.mvc.listener;

import cn.zhw.mvc.config.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import java.util.Enumeration;

//等同于在web.xml配置了该listener
@WebListener
public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        //1.将app放入servletContext中
	        try {
	            ServletContext servletContext = sce.getServletContext();
	            Class<?> contextConfigClass = Class.forName(servletContext.getInitParameter("contextConfigClass"));
	            AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(contextConfigClass);
	
	            servletContext.setAttribute("app",app);
	            System.out.println("Servlet容器被创建");
	        } catch (ClassNotFoundException e) {
	            e.printStackTrace();
	        }
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
}

获取app的优化

使用工具类快速获取app对象
1.工具类

package cn.zhw.mvc.utils;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import javax.servlet.ServletContext;
public class WebApplicatiionUtil {
	//通过servlet参数获取app对象
    public static ApplicationContext getApplicationContext(ServletContext servletContext){
        String contextConfigClass = servletContext.getInitParameter("contextConfigClass");
        return new AnnotationConfigApplicationContext(contextConfigClass);
    }
}

2.获取app实例

package cn.zhw.mvc.listener;
import cn.zhw.mvc.utils.WebApplicatiionUtil;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import java.util.Enumeration;

//等同于在web.xml配置了该listener
@WebListener
public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext servletContext = sce.getServletContext();
        ApplicationContext app = WebApplicatiionUtil.getApplicationContext(servletContext);
        servletContext.setAttribute("app",app);
        System.out.println("Servlet容器被创建");
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
    }
}

spring提供获取上下文的工具

在这里插入图片描述
1.导入pom坐标

   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>

2.在web.xml中配置监听器

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
 
  <context-param>
    <param-name>contextConfigLocation</param-name>
<!--    配置配置文件的位置-->
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

3.获取app对象


package cn.zhw.mvc.web;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/WebApplicationServlet")
public class WebApplicationServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        System.out.println(app.hashCode());

    }
}

在这里插入图片描述
知识要点
1.配置ContextLoaderListener监听器
2.使用WebWebApplicationContextUtils工具类获取上下文
3.当tomcat启动时使用ContextLoaderListener监听器，先把App对象存入到ServletContext中，再需要用到App对象的时候，通过WebWebApplicationContextUtils工具类获取上下文

springMVC简介

在这里插入图片描述

springMVC开发步骤

在这里插入图片描述

快速入门

1.导入坐标

   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>

2.配置springmvc前端控制器

 <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--配置spring-mvc的核心配置文件-->
    <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>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

3.配置spring-mvc配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<!--扫描controller层-->
    <context:component-scan base-package="cn.zhw.mvc.controller"/>


</beans>

4.创建controller和跳转的视图

package cn.zhw.mvc.controller;

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

//加入到ioc容器中
@Controller
public class UserController {
	//配置映射地址
    @RequestMapping("/quick")
    public String save(){
        System.out.println("userController  save...");
        return "success.jsp";
    }
}

<%--
  Created by IntelliJ IDEA.
  User: 小七
  Date: 2021/6/7
  Time: 8:11
  To change this template use File | Settings | File Templates.
--%>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
恭喜你跳转成功！
</body>
</html>

4.发请求测试结果
请求地址：http://localhost:8080/quick
在这里插入图片描述
总结：
1.配置文件是分离的，spring-mvc只扫描controller层
2.配置DispatcherServlet时，需要指定spring-mvc的配置文件

springmvc组件解析

在这里插入图片描述

springmvc执行流程

在这里插入图片描述

springmvc注解解析

@RequestMapping

在这里插入图片描述

package cn.zhw.mvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/xxx")
public class UserController {
    //http://localhost:8080/xxx/quick
    @RequestMapping(
    //请求地址
    value = {"/quick"},
    //可以处理的请求方式
    method = {RequestMethod.GET},
    //必须带有name参数
    params = {"name"})
    
    @GetMapping
    public String save(){
        System.out.println("userController  save...");
        //   /代表从web根目录下找success.jsp资源
        return "/success.jsp";
        //等同于，省略了forward
        //return "forward:/success.jsp";
        
    }
}

组件扫描配置filter

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="cn.zhw.mvc">
    <!--只扫描Controller类型的注解的类，加入到容器中-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
   
</beans>

springmvc的xml配置解析

springmvc的默认原生组件

1.在spring-webmvc包中有一个DispatcherServlet.properties配置文件，里面定义了使用的原生的组件

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter


org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

视图解析器

在这里插入图片描述
配置视图解析器

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

springmvc的数据响应

页面跳转

直接返回字符串

在这里插入图片描述
1.配置视图解析器

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

2.编写controller

package cn.zhw.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/student")
public class StudentController {

    @GetMapping("save")
    public String save(){
        System.out.println("学生保存成功");
        return "success";
    }
}

最终会跳转到webapp/jsp/success.jsp页面

3.当配置了视图解析器的前缀和后缀，转发和重定向怎么实现？


package cn.zhw.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/student")
public class StudentController {

    @GetMapping("save")
    public String save(){
        System.out.println("学生保存成功");
        System.out.println("转发了");
        //直接按照原来的写,转发会拼接，而重定向需要自己指定
        return "redirect:/jsp/success.jsp";
    }
}

返回ModelAndView对象

package cn.zhw.mvc.controller;

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

@Controller
@RequestMapping("/student")
public class StudentController {

    @GetMapping("save")
    public String save(){
        System.out.println("学生保存成功");
        System.out.println("转发了");
        return "redirect:/jsp/success.jsp";
    }

    @GetMapping("quick1")
    public ModelAndView quick(){

        ModelAndView modelAndView = new ModelAndView();
        //添加转发视图
        modelAndView.setViewName("forward:/jsp/success.jsp");
        return modelAndView;
    }
    
    @GetMapping("quick2")
    public ModelAndView quick2(){
        ModelAndView modelAndView = new ModelAndView();
        //添加重定向视图
        modelAndView.setViewName("redirect:/index.jsp");
        return modelAndView;
    }
    
    //在request中添加数据，并且转发到show.jsp
    @GetMapping("quick3")
    public String quick3(HttpServletRequest request){

        request.setAttribute("name","zhenghaowen");
        return "show";
    }
    
    @GetMapping("quick4")
    public ModelAndView quick4(){
        ModelAndView modelAndView = new ModelAndView();
        //添加数据
        modelAndView.addObject("name","zhengshihao");
        //设置视图
        modelAndView.setViewName("forward:/jsp/show.jsp");
        return modelAndView;
    }
    
	@GetMapping("quick5")
    public String quick5(Model model){
        model.addAttribute("name","zhenghaowei");
        return "show";
    }
}

回写数据

直接返回字符串

1.通过response返回字符串
在这里插入图片描述

package cn.zhw.mvc.controller;

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

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
@RequestMapping("/string")
public class StringController {

    //1.通过response返回字符串数据
    @RequestMapping("/quick1")
    public void test01(HttpServletResponse response) throws IOException {
        response.getWriter().println("hello world");
    }

}

2.通过@ResponseBody注解返回
在这里插入图片描述

package cn.zhw.mvc.controller;

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

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
@RequestMapping("/string")
public class StringController {

    //1.通过response返回字符串数据
    @RequestMapping("/quick1")
    public void test01(HttpServletResponse response) throws IOException {
        response.getWriter().println("hello world");
    }
    //1.通过@ResponseBody返回字符串数据,告诉mvc不要页面跳转，而是返回字符串数据
    @RequestMapping("/quick2")
    @ResponseBody
    public String  test02(){
        return "hello world";
    }
}

返回对象或集合（一）

1.返回自己拼接的json对象

package cn.zhw.mvc.controller;

import cn.zhw.mvc.domain.User;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
@RequestMapping("/string")
public class StringController {

    //1.通过response返回字符串数据
    @RequestMapping("/quick1")
    public void test01(HttpServletResponse response) throws IOException {
        response.getWriter().println("hello world");
    }

    //2.通过response返回字符串数据
    @RequestMapping("/quick2")
    @ResponseBody
    public String  test02(){
        return "hello world";
    }

    //3.通过拼接json字符串返回数据
    @RequestMapping("/quick3")
    @ResponseBody
    public String  test03(){
        return "{\"name\":zhenghaowen\",age:\"21}";
    }
}

2.通过fastjson工具，对json和对象之间相互映射
1.添加json转换工具pom坐标

  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.76</version>
      <scope>compile</scope>
    </dependency>

2.使用

	@RequestMapping("/quick5")
	@ResponseBody
	public String  test04(){
        //将json转换为对象,使用的是alibaba的fastJson
        String s = "{\"name\":\"zhenghaowen\",\"age\":21}";
        JSONObject jsonObject = JSONObject.parseObject(s);
        //将对象转换为json字符串
        System.out.println(jsonObject.toJSONString()); //结果 {"name":"zhenghaowen","age":21}
        //获取jsonObject的运行时对象类型
        System.out.println(jsonObject.getClass());//结果 class com.alibaba.fastjson.JSONObject

        String name =(String) jsonObject.get("name");
        Integer age =(Integer)jsonObject.get("age");
        return name +":"+ age;
    }
    
	//将对象转换为json字符串
    @RequestMapping("/quick6")
    @ResponseBody
    public String  test06(){
        //将对象转换为json字符串
        User user = new User("zhenghaowen",21);
        //将user对象转换为json字符串
        String s = JSON.toJSONString(user);
        return s; //结果 {"age":21,"name":"zhenghaowen"}

3.配置处理器适配器直接返回user的json字符串

因为每一次都要写String s = JSON.toJSONString(user);将对象转换为json字符串。比较繁琐，可以使用适配器，来优化。

1.配置处理器适配器

<!--    配置适配器，告诉mvc返回对象的json字符串-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>

2.springmvc返回json数据需要依赖下面的jar包

 <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.5</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.5</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.5</version>
    </dependency>

3.测试

//通过配置适配器返回对象的json字符串形式
    @RequestMapping("/quick7")
    @ResponseBody
    public User  test07(){
        //将对象转换为json字符串
        User user = new User("zhenghaowen",21);
        return user; //结果：{"name":"zhenghaowen","age":21}
    }
//通过配置适配器返回集合的json字符串形式
    @RequestMapping("/quick8")
    @ResponseBody
    public List<User> test08(){
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张国荣",20));
        users.add(new User("古天乐",21));
        return users;  //结果： [{"name":"张国荣","age":20},{"name":"古天乐","age":21}]
    }

返回对象或集合（二）

在这里插入图片描述
1.在spring-mvc.xml里配置

<!--    会自动加载处理器映射器和处理器适配器，并且配置了适配器自动返回json字符串-->
    <mvc:annotation-driven/>

2.测试

	//mvc自动加载
    @RequestMapping("/quick9")
    @ResponseBody
    public List<User> test09(){
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张柏芝",20));
        users.add(new User("王祖贤",21));
        return users;  //结果： [{"name":"张柏芝","age":20},{"name":"王祖贤","age":21}]
    }

spring获得请求参数

在这里插入图片描述

基本数据类型

1.请求地址

http://localhost:8080/params/quick1?username=zhw&age=21

2.controller

package cn.zhw.mvc.controller;

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

/**
 * @author 小七
 * @description 获取请求的参数
 */
@Controller
@ResponseBody
@RequestMapping("/params")
public class ParamsController {

    //获取基本数据类型
    @RequestMapping("/quick1")
    public String quick1(@RequestParam("username") String name,Integer age){

        return name+":"+age; //结果 zhw:21
    }
}

3.总结

只要请求的参数名称和方法的形参一致mvc会自动封装
当不一样可以使用@RequestParam注解来进行指定

获取Pojo(对象)数据

1.worker对象

package cn.zhw.mvc.domain.pojo;

import cn.zhw.mvc.domain.Hobby;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Worker {
    private String name;
    private Integer age;
    private List<Hobby> hobbyList;
}

2.请求地址
http://localhost:8080/params/quick2?name=zhw&age=21
3.controller

//封装到pojo对象中
    @RequestMapping("/quick2")
    public Worker quick2(Worker worker){
        System.out.println(worker.getName());
        System.out.println(worker.getAge());
        return worker; //结果：{"name":"zhw","age":21,"hobbyList":null}
    }

4.总结

只需要请求的参数和对象中的属性一致就可以注入
javaBean中要有属性的set方法

获取数组数据

1.请求地址
http://localhost:8080/params/quick3?strs=hello&strs=world
2.controller


    //3.封装到数组中
    @RequestMapping("/quick3")
    public String[] quick3(String[] strs){
        return strs; //结果: ["hello","world"]
    }

获取集合数据(一)

1.表单

    <form method="get" action="/params/quick4">
        <input type="text" name="name"><br>
        <input type="text" name="age"><br>
        <input type="text" name="hobbyList[0].name"><br>
        <input type="text" name="hobbyList[1].name"><br>
        <input type="submit" value="提交"><br>
    </form>

2.controller

//封装到集合中
    @RequestMapping("/quick4")
    public Worker quick3(Worker worker){
        return worker;
    }

3.worker类

package cn.zhw.mvc.domain.pojo;

import cn.zhw.mvc.domain.Hobby;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Worker {
    private String name;
    private Integer age;
    private List<Hobby> hobbyList;
}

4.hobby类

package cn.zhw.mvc.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Hobby {
    private String name;
}

5.测试

请求数据
请求结果

6.注意
对于集合要封装到Vo类中来使用
o

获取集合数据(二)

当使用ajax传过来的数据为json时，可以使用@RequestBody直接封装数据，无需使用Vo类

在这里插入图片描述

 //6.封装到集合中
    @RequestMapping("/quick6")
    public List<User> quick6(@RequestBody  List<User> userList){
        System.out.println(userList.size());
        return userList;
    }

引入静态资源问题

当jsp页面引入其他的静态资源文件时，前端控制器仍然会去匹配相应的Controller地址，当找不到就什么也不做，所以会报错，找不到要找的资源。
有两种方式可以解决该问题：

配置对哪些资源不进行拦截匹配

<!--放行js目录下的所有文件-->
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:resources mapping="/img/**" location="/img/"/>

2.当前端控制器找不到后，交给原来的容器去处理

	<!--当前端控制器，找不到对应的资源交给原始的容器去找-->
    <mvc:default-servlet-handler/>

在这里插入图片描述

post请求乱码问题

只需要在web.xml中配置mvc提供的过滤器

<!--  配置post请求乱码问题-->
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

@RequestParam注解

在这里插入图片描述

	@RequestMapping("/test02")
    //将请求参数username赋值给name变量
    //required:默认为true,当为true必须带有username参数,不然会报错
    //defaultValue:当username为空时,默认给name赋给定的值,必须required必须为false
    public String test02(@RequestParam(value = "username",required = false,defaultValue = "张国荣") String name){
        System.out.println(name);
        return null;
    }

获取restful风格的参数

在这里插入图片描述

1.请求地址

2.controller

@RequestMapping("/test01/{name}/{age}")
    public String test01(@PathVariable("name") String name1,@PathVariable("age") Integer age,@RequestParam("name") String name2){
        System.out.println(name1); //zhw
        System.out.println(age); //21
        System.out.println(name2); //zsh
        return null;
    }

自定义类型转换器

1.定义转换器

package cn.zhw.Converter;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date = format.parse(source);
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
            System.out.println("String类型的数据转换成Date数据失败");
        }

        return null;

    }
}

2.在web.xml中配置

<!--    配置自定义类型转换器-->
    <bean id="converter" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="cn.zhw.Converter.DateConverter"/>
            </list>
        </property>
    </bean>
    
<!--    配置处理器映射器，处理器适配器和转换器-->
    <mvc:annotation-driven conversion-service="converter"/>

3.测试
在这里插入图片描述

package cn.zhw.controller;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
@RequestMapping("/converter")
public class ConverterController {

    @RequestMapping("/test1/{date}")
    public void test01(@PathVariable("date") Date date){
        System.out.println(date); //结果:Thu Jun 10 00:00:00 CST 2021
    }
}

获取servlet相关API

原生Servlet对象作为参数

在这里插入图片描述

@RequestMapping("/test01")
    public String test1(HttpServletRequest request, HttpServletResponse response, HttpSession session){
        request.setAttribute("request","hello");
        session.setAttribute("session","world");
        return  "show";
    }

获得请求中的信息

1.@RequestHeader获取请求头
在这里插入图片描述

//获得请求头
    @RequestMapping("/test02")
    @ResponseBody
    public String test2(@RequestHeader("User-Agent") String headerValue){
        System.out.println(headerValue);
        return headerValue; //结果:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36 Edg/91.0.864.41
    }

2.获取cookie
在这里插入图片描述

 //在response中放cookie
    @RequestMapping("/test03")
    @ResponseBody
    public String test3(HttpServletResponse response){
        Cookie cookie = new Cookie("name", "zhw");
        cookie.setMaxAge(3000);
        response.addCookie(cookie);
       return "放好啦!";
    }
    //获取cookie的值
    @RequestMapping("/test04")
    @ResponseBody
    public String test4(@CookieValue("name") String name){
        return name;
    }

1.请求http://localhost:8081/servlet/test03
在这里插入图片描述
2.请求http://localhost:8081/servlet/test04

文件上传

在这里插入图片描述

文件上传实现

1.导入坐标

<dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.5</version>
    </dependency>

2.在spring-mvc中配置文件上传解析器

<!--    配置文件上传解析器-->
    <bean id="MultipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="500000"/>
    </bean>

3.表单

<%--
  Created by IntelliJ IDEA.
  User: 小七
  Date: 2021/6/10
  Time: 18:05
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form method="post" enctype="multipart/form-data" action="">
    名称:<input type="text" name="username"><br/>
    文件:<input type="file" name="upload"><br/>
    <input type="submit" name="提交">
</form>
</body>
</html>

4.controller

package cn.zhw.controller;

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

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;

@Controller
@RequestMapping("/upload")
public class UploadController {

    /**
     * @param username 上传的用户名
     * @param file  上传的文件
     */
    @RequestMapping("test1")
    @ResponseBody
    public String test1(@RequestParam("name") String username,@RequestParam("file") MultipartFile file) throws IOException {
        String name = file.getName();
        System.out.println(name);
        return "上传成功";
    }
}

Spring JDBCTemplate

概述

在这里插入图片描述

使用步骤

在这里插入图片描述

快速入门

1.导入jar包

!--    使用jdbc需要的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>

2.创建实体类

package cn.zhw.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Account {
    private String name;
    private Integer money;
}

3.创建JdbcTemplate对象
4.执行数据库操作

package cn.zhw;

import com.alibaba.druid.pool.DruidDataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.sql.DataSource;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTest {

    @Test
    public void test1(){
        //1.数据源
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        //2.jdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //3.设置jdbcTemplate的数据源
        jdbcTemplate.setDataSource(dataSource);
        //4.执行操作
        int update = jdbcTemplate.update("insert into account values('tom',4000)");
        if (update != 0){
            System.out.println("插入成功");
        }
    }
}

优化

1.将数据源和jdbcTemplate对象加入到ioc容器中

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
#useUnicode是否使用字符集
#characterEncoding设置使用的字符集
#useSSL是否使用SSL协议通信
jdbc.username=root
jdbc.password=123456

	<!--引入resources目录下的数据库配置文件-->
	 <context:property-placeholder location="classpath:db.properties"/>
	<!--配置数据源-->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
	<!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

2.测试

 @Test
    public void test2(){
        int update = jdbcTemplate.update("insert into account values(?,?)","tom",21);
        if (update != 0){
            System.out.println("插入成功");
        }
    }

jdbcTemplate的常用操作

package cn.zhw.dao.impl;

import cn.zhw.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;


@Repository
public class AccountDaoImpl {

    //引入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //增加
    public int add(Account account){
        Integer money = account.getMoney();
        String name = account.getName();
        int update = jdbcTemplate.update("insert into account(name,money) values(?,?)",name,money);
        return update;
    }
    
    //删除
    public int delete(String name){
        int update = jdbcTemplate.update("delete from account where name = ?", name);
        return update；
    }
    
    //修改
    public int updateByName(Account account){
        String name = account.getName();
        Integer money = account.getMoney();
        int update = jdbcTemplate.update("update account set money = ? where name = ?", money, name);
        return update;
    }
    
    //查找全部,new BeanPropertyRowMapper<Account>(Account.class) 将数据封装成Account类型的对象
    public List<Account> findAll(){
        return jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
    }
    
    //查找
    public Account findByName(String name){
        return jdbcTemplate.queryForObject("select * from account where name = ? ",new BeanPropertyRowMapper<Account>(Account.class),name);
    }
}

知识要点

在这里插入图片描述

SpringMVC 拦截器

拦截器的作用

在这里插入图片描述

拦截器和过滤器的区别

在这里插入图片描述
拦截器只会拦截Controller中的方法

拦截器快速入门

在这里插入图片描述
1.编写拦截器

package cn.zhw.interceptor.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class MyInterceptor implements HandlerInterceptor {

    //目标方法执行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle1");
        String name = request.getParameter("name");
        if ("zhw".equals(name)){
            return true;
        }
        else {
            request.setAttribute("error","name的值不是zhw");
            request.getRequestDispatcher("/error.jsp").forward(request,response);
        }
        return false;
    }

    //目标方法执行之后 视图对象返回之前执行
    //可以更改ModelAndView中的数据
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    //在流程都执行完毕后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

2.配置拦截器

<!--    配置拦截器-->
    <mvc:interceptors>

        <mvc:interceptor>
<!--            对哪些资源进行拦截,所有资源-->
            <mvc:mapping path="/**"/>
            <bean class="cn.zhw.interceptor.interceptor.MyInterceptor"/>
        </mvc:interceptor>

    </mvc:interceptors>

3.拦截器拦截效果
访问地址：http:localhost:8080/intercetper/target?name=zhw

preHandle
执行目标资源
postHandle
afterCompletion

快速入门详解

多个拦截器拦截顺序

当拦截器有多个，并且拦截同一个目标资源，那么执行顺序和配置的顺序是有关的
1.拦截器1

package cn.zhw.interceptor.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class MyInterceptor1 implements HandlerInterceptor {

    //目标方法执行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle1");
            return true;
    }

    //目标方法执行之后 视图对象返回之前执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    	modelANdView.setObject("name","zhw"); //修改model中的值
        System.out.println("postHandle1");

    }

    //在流程都执行完毕后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion1");
    }
}

2.拦截器2

package cn.zhw.interceptor.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class MyInterceptor2 implements HandlerInterceptor {

    //目标方法执行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle2");
        return true;
    }

    //目标方法执行之后 视图对象返回之前执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle2");

    }

    //在流程都执行完毕后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion2");
    }
}

3.配置

<!--    配置拦截器-->
    <mvc:interceptors>

        <mvc:interceptor>
<!--            对哪些资源进行拦截,所有资源-->
            <mvc:mapping path="/**"/>
            <bean class="cn.zhw.interceptor.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="cn.zhw.interceptor.interceptor.MyInterceptor2"/>
        </mvc:interceptor>

    </mvc:interceptors>

3.执行结果

preHandle1
preHandle2
执行目标资源
postHandle2
postHandle1
afterCompletion2
afterCompletion1

拦截器路径的配置

<!--    配置拦截器-->
    <mvc:interceptors>

<!--        对多有资源进行拦截-->
        <mvc:interceptor>
<!--            对哪些资源进行拦截,所有资源-->
            <mvc:mapping path="/**"/>
            <bean class="cn.zhw.interceptor.interceptor.MyInterceptor1"/>
        </mvc:interceptor>

<!--        只拦截/interceptor/target1-->
        <mvc:interceptor>
            <mvc:mapping path="/interceptor/target1"/>
            <bean class="cn.zhw.interceptor.interceptor.MyInterceptor2"/>
        </mvc:interceptor>

<!--        拦截/interceptorController里的所有资源-->
        <mvc:interceptor>
            <mvc:mapping path="/interceptor/**"/>
            <bean class="cn.zhw.interceptor.interceptor.MyInterceptor2"/>
        </mvc:interceptor>

    </mvc:interceptors>

拦截器小结

在这里插入图片描述

案例

在这里插入图片描述
只要看session中是否有user值
1.拦截器

package cn.zhw.interceptor.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        Object user = session.getAttribute("user");

        //没有登录，当session中没有user值，就跳转到登录页面
        if (user == null){
            response.sendRedirect(request.getContextPath()+"/login.jsp");
            return false;
        }
        return true;

    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

SpringMVC异常处理机制

在这里插入图片描述
当出现异dao层–>service层–>controller层–>Dispatcher一层一层向上抛，直到给到Dispatcher，Dispatcher会处理该异常。

异常处理的2种方式

在这里插入图片描述

简单异常处理器

在这里插入图片描述
当配置的异常都不匹配时，才会使用默认的错误页面
注意：
1.只有Controller中的方法向上抛给Dispatcher才可以
2.如果用try…catch自己处理了不会，进入springmvc的错误处理机制
3.指定的错误页面会和视图解析器拼接

自定义异常处理器

在这里插入图片描述
1.编写异常处理解析器

package cn.zhw.exception.exception;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

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

public class MyExceptionResolver implements HandlerExceptionResolver {
    /**
     *
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @param e 异常对象
     * @return 返回模型和视图
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView modelAndView = new ModelAndView();

        if (e instanceof MyException){
            modelAndView.addObject("error","自定义异常");
            modelAndView.setViewName("error1");
        }

        if (e instanceof ClassCastException){
            modelAndView.addObject("error","类型转换异常");
            modelAndView.setViewName("error2");
        }

        modelAndView.addObject("error","其他异常");
        modelAndView.setViewName("error");

        return modelAndView;
    }
}

2.在spring-mvc.xml中配置自定义解析器

<!--    配置自定义异常-->
    <bean id="exceptionResolver" class="cn.zhw.exception.exception.MyExceptionResolver"/>

不爱吃橘子7

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录