SpringMVC详解（拦截器与文件上传框架整合）

最新推荐文章于 2022-07-04 21:10:06 发布

Trycol

最新推荐文章于 2022-07-04 21:10:06 发布

阅读量262

点赞数

分类专栏： SpringMVC 文章标签： spring mvc

本文链接：https://blog.csdn.net/weixin_44454512/article/details/110188641

版权

SpringMVC 专栏收录该内容

3 篇文章 1 订阅

订阅专栏

SpringMVC详解（补加）

1. 学习⽬标

在这里插入图片描述

2. 拦截器

2.1. 基本概念

SpringMVC 中的 Interceptor 拦截器也是相当重要和相当有⽤的，它的主要作⽤是拦截⽤户的请求并进⾏相应的处理。⽐如通过它来进⾏权限验证，或者是来判断⽤户是否登陆等操作。对于 SpringMVC拦截器的定义⽅式有两种：

实现接⼝：org.springframework.web.servlet.HandlerInterceptor
继承适配器：org.springframework.web.servlet.handler.HandlerInterceptorAdapter

2.2. 拦截器实现

2.2.1. 实现 HandlerInterceptor 接⼝

接⼝实现类

package com.suntao.springmvc.interceptor;

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

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

/**
 * 拦截器实现
 * 实现 HandlerInterceptor 接⼝
 */
public class MyInterceptor01 implements HandlerInterceptor {
    /**
     * 在 ⽬标Handler(⽅法)执⾏前 执⾏
     * 返回 true：执⾏handler⽅法
     * 返回 false：阻⽌⽬标handler⽅法执⾏
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("⽬标Handler执⾏前执⾏MyInterceptor01 --> preHandle⽅ 法...");
        /**
         * 返回 true：执⾏handler⽅法
         * 返回 false：阻⽌⽬标handler⽅法执⾏
         */
        return true;
    }
    /**
     * 在 ⽬标Handler(⽅法)执⾏后，视图⽣成前 执⾏
     * @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("⽬标Handler执⾏后，视图⽣成后执⾏MyInterceptor01 --> afterCompletion⽅法...");
    }
}

拦截器spring.xml配置

 <!-- 拦截器配置：⽅式⼀ -->
    <!--<mvc:interceptors>
        &lt;!&ndash;
        使⽤bean定义⼀个Interceptor
        直接定义在mvc:interceptors根下⾯的Interceptor将拦截所有的请求
        &ndash;&gt;
        <bean class="com.suntao.springmvc.interceptor.MyInterceptor01"/>
    </mvc:interceptors>-->
    <!-- 拦截器配置：⽅式⼆ (推荐使⽤) -->
    <mvc:interceptors>
        <!--
        定义在 mvc:interceptor 下⾯，可以⾃定义需要拦截的请求
        如果有多个拦截器满⾜拦截处理的要求，则依据配置的先后顺序来执⾏
        -->
        <mvc:interceptor>
            <!-- 通过 mvc:mapping 配置需要拦截的资源。⽀持通配符。可配置多个。 -->
            <mvc:mapping path="/**"/> <!-- "/**"表示拦截所有的请求。 -->
            <!-- 通过 mvc:mapping 配置不需要被拦截的资源。⽀持通配符。可配置多个。 -->
            <mvc:exclude-mapping path="/url/*"/> <!-- "/url/*"表示放⾏url路径下的请
求。 -->
            <bean class="com.suntao.springmvc.interceptor.MyInterceptor01"/>
        </mvc:interceptor>
    </mvc:interceptors>

2.2.2. 继承 HandlerInterceptorAdapter

实际上最终还是 HandlerInterceptor 接⼝实现。

⼦类实现类

package com.suntao.springmvc.interceptor;

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

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

/**
 * 拦截器实现
 * 继承 HandlerInterceptorAdapter 适配器
 */
public class MyInterceptor02 extends HandlerInterceptorAdapter {
    /**
     * 在 ⽬标Handler(⽅法)执⾏前 执⾏
     * 返回 true：执⾏handler⽅法
     * 返回 false：阻⽌⽬标handler⽅法执⾏
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("⽬标Handler执⾏前执⾏MyInterceptor02 --> preHandle⽅ 法...");
        /**
         * 返回 true：执⾏handler⽅法
         * 返回 false：阻⽌⽬标handler⽅法执⾏
         */
        return true;
    }
}

拦截器xml配置

<mvc:interceptors>
		<mvc:interceptor>
            <!-- 拦截的资源 -->
            <mvc:mapping path="/**"/>
            <!-- 放⾏的资源 -->
            <mvc:exclude-mapping path="/url/test01"/>
            <mvc:exclude-mapping path="/url/test02"/>
            <bean class="com.suntao.springmvc.interceptor.MyInterceptor02"/>
        </mvc:interceptor>
    </mvc:interceptors>

2.2.3. 多个拦截器实现

SpringMVC 框架⽀持多个拦截器配置，从⽽构成拦截器链，对客户端请求进⾏多次拦截操作。

拦截器代码实现
这⾥参考MyInterceptor01、MyInterceptor02代码
拦截器xml配置

<mvc:interceptors>
	 <!--
 	拦截器链（多个拦截器）
		如果有多个拦截器满⾜拦截处理的要求，则依据配置的先后顺序来执⾏
 		先配置的拦截器的 preHandle ⽅法先执⾏
 		先配置的拦截器的 postHandle、afterCompletion ⽅法后执⾏
 	-->
 	<mvc:interceptor>
 		<!-- 拦截所有请求 -->
 		<mvc:mapping path="/**" />
 		<bean class="com.suntao.springmvc.interceptor.MyInterceptor01" />
 </mvc:interceptor>
 	<mvc:interceptor>
 		<!-- 拦截所有请求 -->
 		<mvc:mapping path="/**" />
 		<bean class="com.suntao.springmvc.interceptor.MyInterceptor02" />
 	</mvc:interceptor>
</mvc:interceptors>

2.3. 拦截器应⽤ - ⾮法请求拦截

使⽤拦截器完成⽤户是否登录请求验证功能

2.3.1. ⽤户控制器

UserInfoController 定义

package com.suntao.springmvc.controller;


import com.suntao.springmvc.po.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpSession;

/**
 * ⽤户操作模拟实现
 * ⽤户登录（⽆需登录）
 * ⽤户添加（需要登录）
 * ⽤户修改（需要登录）
 * ⽤户删除（需要登录）
 */
@Controller
@RequestMapping("/userInfo")
public class UserInfoController {
    /**
     * ⽤户登录
     * @return
     */
    @RequestMapping("/login")
    public ModelAndView userLogin(HttpSession session){
        System.out.println("用户登录");
        ModelAndView mv = new ModelAndView();
        //设置视图
        mv.setViewName("success");
        // ⽤户登录后，设置对应的session域对象
        User user = new User();
        user.setId(1);
        user.setUserName("admin");
        user.setUserPwd("123456");
        session.setAttribute("user",user);

        return mv;
    }
    /**
     * ⽤户添加
     * @return
     */
    @RequestMapping("/add")
    public ModelAndView userAdd(){
        System.out.println("⽤户添加...");
        ModelAndView mv = new ModelAndView();
        // 设置视图
        mv.setViewName("success");
        return mv;
    }
    /**
     * ⽤户修改
     * @return
     */
    @RequestMapping("/update")
    public ModelAndView userUpdate(){
        System.out.println("⽤户更新...");
        ModelAndView mv = new ModelAndView();
        // 设置视图
        mv.setViewName("success");
        return mv;
    }
    /**
     * ⽤户删除
     * @return
     */
    @RequestMapping("/delete")
    public ModelAndView userDelete(){
        System.out.println("⽤户删除...");
        ModelAndView mv = new ModelAndView();
        // 设置视图
        mv.setViewName("success");
        return mv;
    }
}

2.3.2.页面定义

success.jsp 定义

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
 <title>Title</title>
</head>
<body>
 <h3>欢迎登录！</h3>
</body>
</html>

2.3.3. ⾮法请求拦截器定义

LoginInterceptor 定义

package com.suntao.springmvc.interceptor;

import com.suntao.springmvc.po.User;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

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

/**
 * ⾮法访问拦截
 */
public class LoginInterceptor extends HandlerInterceptorAdapter {
    /**
     * 在 ⽬标⽅法执⾏前 执⾏
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取session域对象中的user对象
        User user = (User) request.getSession().getAttribute("user");
        //判断session域对象是否为空
        if(null == user){
            //为空表示用户未登录
            //拦截用户跳转到登录页面
            response.sendRedirect(request.getContextPath()+"/login.jsp");
            return false;
        }
        return true;
    }
}

2.3.4. 拦截器xml配置

<!-- 拦截所有请求 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <!-- 拦截所有请求 -->
            <mvc:mapping path="/**" />
            <!-- 放⾏⽤户登录请求 -->
            <mvc:exclude-mapping path="/userInfo/login"/>
            <bean class="com.suntao.springmvc.interceptor.LoginInterceptor" />
        </mvc:interceptor>
    </mvc:interceptors>

3. ⽂件上传

3.1. 环境配置

3.1.1. pom.xml⽂件修改

<!-- 添加 commons-fileupload 依赖 -->
<dependency>
	<groupId>commons-fileupload</groupId>
	<artifactId>commons-fileupload</artifactId>
	<version>1.3.2</version>
</dependency>

3.2. 代码实现

3.2.1. 单⽂件上传

3.2.1.1. ⻚⾯表单

input 的type设置为file
form 表单的method设为post,
form 表单的enctype设置为multipart/form-data，以⼆进制的形式传输数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件上传</title>
</head>
<body>
    <form action="uploadFile" method="post" enctype="multipart/form-data">
        <input type="file" name="file" />
        <button type="submit">提交</button>
    </form>
</body>
</html>

3.2.1.2. 代码实现

package com.suntao.springmvc.controller;

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;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

/**
 * ⽂件上传
 */
@Controller
public class FileController {
    /**
     * 单⽂件上传
     * 使⽤MultipartFile对象作为参数，接收前端发送过来的⽂件
     *
     * @param file
     * @param request
     * @return
     */
    @RequestMapping("/uploadFile")
    public String uploadFile(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
        // 判断⽂件是否为空，如果不为空进⾏对应的⽂件上传操作
        if (!file.isEmpty()) {
            try {
                // 获取项⽬的所在的路径 （绝对路径）
                String path = request.getServletContext().getRealPath("/");
                // 设置上传的⽂件存放的⽬录
                File uploadFile = new File(path + "/upload");
                // 判断⽂件⽬录是否存在，不存在则新建⽬录
                if (!uploadFile.exists()) {
                    // 新建⽬录
                    uploadFile.mkdir();
                }
                // 获取上传⽂件的原⽂件名
                String originalName = file.getOriginalFilename();
                // 获取上传的⽂件的后缀
                String suffix =
                        originalName.substring(originalName.lastIndexOf("."));
                // 通过系统当前时间的毫秒数，⽣成随机⽂件名 （避免上传的⽂件名重复）
                String fileName = System.currentTimeMillis() + suffix;
                // 上传⽂件 (转存⽂件到指定⽬录)
                file.transferTo(new File(uploadFile, fileName));
                // 设置成功的域对象
                request.setAttribute("msg", "⽂件上传成功！");
            } catch (IOException e) {
                e.printStackTrace();
                // 如果报错，设置的域对象
                request.setAttribute("msg", "⽂件上传失败！");
            }
        } else {
            // 上传⽂件不存在，设置的域对象
            request.setAttribute("msg", "⽂件不存在，上传失败！");
        }
        return "result";
    }
}

3.2.2. 多⽂件上传

3.2.2.1. ⻚⾯表单

<form action="uploadFiles" method="post" enctype="multipart/form-data">
	<input type="file" name="files" />
	<input type="file" name="files" />
	<input type="file" name="files" />
	<button type="submit"> 提交</button>
</form>

3.2.2.2.代码实现

 /**
     * 上传⽂件
     *
     * @param file
     * @param request
     */
    public void saveFile(MultipartFile file, HttpServletRequest request) {
        // 判断⽂件是否为空，如果不为空进⾏对应的⽂件上传操作
        if (!file.isEmpty()) {
            try {
                // 获取项⽬的所在的路径 （绝对路径）
                String path = request.getServletContext().getRealPath("/");
                // 设置上传的⽂件存放的⽬录
                File uploadFile = new File(path + "/upload");
                // 判断⽂件⽬录是否存在，不存在则新建⽬录
                if (!uploadFile.exists()) {
                    // 新建⽬录
                    uploadFile.mkdir();
                }
                // 获取上传⽂件的原⽂件名
                String originalName = file.getOriginalFilename();
                // 获取上传的⽂件的后缀
                String suffix = originalName.substring(originalName.lastIndexOf("."));
                // 通过系统当前时间的毫秒数，⽣成随机⽂件名 （避免上传的⽂件名重复）
                String fileName = System.currentTimeMillis() + suffix;
                // 上传⽂件 (转存⽂件到指定⽬录)
                file.transferTo(new File(uploadFile, fileName));
                // 设置成功的域对象
                request.setAttribute("msg", "⽂件上传成功！");
            } catch (IOException e) {
                e.printStackTrace();
                // 如果报错，设置的域对象
                request.setAttribute("msg", "⽂件上传失败！");
            }
        } else {
            // 上传⽂件不存在，设置的域对象
            request.setAttribute("msg", "⽂件不存在，上传失败！");
        }
    }

    /**
     * 多⽂件上传
     *
     * @param files
     * @param request
     * @return
     */
    @RequestMapping("/uploadFiles")
    public String uploadFiles(@RequestParam("files") List<MultipartFile> files,
                              HttpServletRequest request) {
        // 判断⽂件集合是否为空
        if (files != null && files.size() > 0) {
            // 循环上传
            for (MultipartFile file : files) {
                // 上传⽂件
                saveFile(file, request);
            }
        }
        return "result";
    }

4. SSM 框架集成与测试

4.1. 环境配置

4.1.1. IDEA 下创建项⽬

创建Maven对应的Web项⽬

4.1.2. 配置 pom.xml

4.1.2.1. 修改 JDK 版本与添加坐标依赖、设置资源⽬录和插件

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.suntao</groupId>
  <artifactId>ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>ssm Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!-- spring 核⼼jar -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring 测试jar -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <!-- spring jdbc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring事物 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- aspectj切⾯编程的jar -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.5</version>
    </dependency>

    <!-- c3p0 连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>
    <!-- mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.3</version>
    </dependency>
    <!-- 添加mybatis与Spring整合的核⼼包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.3</version>
    </dependency>

      <!-- mysql 驱动包 -->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>8.0.19</version>
      </dependency>
      <!-- ⽇志打印相关的jar -->
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.7.2</version>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>1.7.2</version>
      </dependency>

    <!-- 分⻚插件 -->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.10</version>
    </dependency>
    <!-- spring web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring mvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- web servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>
    <!-- 添加json 依赖jar包（注意版本问题） -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.10.0</version>
    </dependency>
    <!-- commons-fileupload -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.2</version>
    </dependency>



  </dependencies>

  <build>
    <finalName>ssm</finalName>
    <!--
    Maven 项⽬:如果源代码(src/main/java)存在xml、properties、tld 等⽂件
    Maven 默认不会⾃动编译该⽂件到输出⽬录,如果要编译源代码中xml properties tld 等⽂件
    需要显式配置 resources 标签
    -->
    <resources>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
          <include>**/*.properties</include>
          <include>**/*.tld</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <plugins>
      <!-- 编译环境插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <!-- jetty插件 -->
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>9.4.27.v20200227</version>
        <configuration>
          <scanIntervalSeconds>10</scanIntervalSeconds>
          <!-- 设置端⼝ -->
          <httpConnector>
            <port>8989</port>
          </httpConnector>
          <!-- 设置项⽬路径 -->
          <webAppConfig>
            <contextPath>/ssm</contextPath>
          </webAppConfig>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

4.1.3. 配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <!-- 启动spring容器-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
  <!-- 设置监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- 编码过滤 utf-8 -->
  <filter>
    <description>char encoding filter</description>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!-- servlet请求分发器 -->
  <servlet>
    <servlet-name>springMvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:servlet-context.xml</param-value>
    </init-param>
    <!-- 表示启动容器时初始化该Servlet -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springMvc</servlet-name>
    <!-- 这是拦截请求， "/"代表拦截所有请求，"*.do"拦截所有.do请求 -->
    <url-pattern>/</url-pattern>
    <!--<url-pattern>*.do</url-pattern>-->
  </servlet-mapping>
</web-app>

4.1.4. 配置 servlet-context.xml

在项⽬的 src/main/resources 下创建 servlet-context.xml ⽂件，内容如下

<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
 http://www.springframework.org/schema/mvc/spring-mvc.xsd
 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="com.xxxx.ssm.controller" />
    <!-- mvc 注解驱动 并添加json ⽀持 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <!-- 返回信息为字符串时 处理 -->
            <bean
                    class="org.springframework.http.converter.StringHttpMessageConverter"/>
            <!-- 将对象转换为json 对象 -->
            <bean
                    class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 使⽤默认的 Servlet 来响应静态⽂件 -->
    <mvc:default-servlet-handler/>

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!-- 前缀：在WEB-INF⽬录下的jsp⽬录下 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀：以.jsp结尾的资源 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- ⽂件上传 -->
    <bean id="multipartResolver"

          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 允许⽂件上传的最⼤尺⼨ -->
        <property name="maxUploadSize">
            <value>104857600</value>
        </property>
        <!--
        设置⽂件放⼊临时⽂件夹的最⼤⼤⼩限制。
        此值是阈值，低于此值，则保存在内存中，如⾼于此值，则⽣成硬盘上的临时⽂件。
        -->
        <property name="maxInMemorySize">
            <value>4096</value>
        </property>
    </bean>
</beans>

4.1.5. 配置 spring.xml

在项⽬的 src/main/resources 下创建 spring.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 扫描基本包 -->
    <context:component-scan base-package="com.xxxx.ssm" >
        <!-- context:exclude-filter标签：排除对某个注解的扫描 （过滤controller层）
       -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
    <!-- 加载properties 配置⽂件 -->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- aop -->
    <aop:aspectj-autoproxy />
    <!-- 配置c3p0 数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 设置事物增强 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED" />
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
    <!-- aop 切⾯配置 -->
    <aop:config>
        <aop:pointcut id="servicePointcut"
                      expression="execution(* com.xxxx.ssm.service..*.*(..))"
        />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="servicePointcut" />
    </aop:config>
    <!-- 配置 sqlSessionFactory -->
    <bean id="sqlSessionFactory"
          class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis.xml" />
        <property name="mapperLocations" value="classpath:com/xxxx/ssm/mapper/*.xml" />
    </bean>
    <!-- 配置扫描器 -->
    <bean id="mapperScanner"
          class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描com.xxxx.ssm.dao这个包以及它的⼦包下的所有映射接⼝类 -->
        <property name="basePackage" value="com.xxxx.ssm.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
</beans>

4.1.6. 配置 mybatis.xml

在项⽬的 src/main/resources 下创建 mybatis.xml ⽂件，内容如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.xxxx.ssm.po"/>
    </typeAliases>
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
</configuration>

4.1.7. 配置 db.properties

在项⽬的 src/main/resources 下创建 db.properties ⽂件，内容如下(mysql 创建数据库ssm)

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?
useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
jdbc.username=root
jdbc.password=123456

4.1.8. 添加 log4j.properties

在项⽬的 src/main/resources 下创建 log4j.properties ⽂件，内容如下

log4j.rootLogger=DEBUG, Console
# Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

4.2. 添加源代码

4.2.1. 添加包

在项⽬的 src/main/java 下创建对应的包结构
com.xxxx.ssm.controller
com.xxxx.ssm.service
com.xxxx.ssm.mapper
com.xxxx.ssm.dao
com.xxxx.ssm.po

4.2.2. 添加 User.java

在 com.xxxx.ssm.po 包下创建 JavaBean ⽂件 User.java (数据库字段对应如下)

package com.xxxx.ssm.po;

import java.util.Date;

public class User {

    private Integer userId;
    private String userName;
    private String userPwd;
    private String userEmail;
    private Date createDate;
    private Date updateDate;

    public User() {
    }

    public User(Integer userId, String userName, String userPwd, String userEmail, Date createDate, Date updateDate) {
        this.userId = userId;
        this.userName = userName;
        this.userPwd = userPwd;
        this.userEmail = userEmail;
        this.createDate = createDate;
        this.updateDate = updateDate;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPwd() {
        return userPwd;
    }

    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }

    public String getUserEmail() {
        return userEmail;
    }

    public void setUserEmail(String userEmail) {
        this.userEmail = userEmail;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userPwd='" + userPwd + '\'' +
                ", userEmail='" + userEmail + '\'' +
                ", createDate=" + createDate +
                ", updateDate=" + updateDate +
                '}';
    }
}

4.2.3. 添加UserDao.java 接⼝

com.xxxx.ssm.dao 包下创建 UserDao.java ⽂件，提供对应的⽤户详情查询功能

public interface UserDao {
	User queryUserByUserId(Integer userId);
}

4.2.4. 添加UserMapper.xml 映射⽂件

com.xxxx.ssm.mapper 包下创建 UserMapper.xml ⽂件，提供select 查询标签配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xxxx.ssm.dao.UserDao">
    <select id="queryUserByUserId" parameterType="int" resultType="com.xxxx.ssm.po.User">
        select
            user_id userId,user_name userName, user_pwd userPwd , user_email userEmail,
            create_date createDate, update_date updateDate
        from
            user
        where
            user_id = #{id}
 </select>
</mapper>

4.2.5. 添加 UserService.java

com.xxxx.ssm.service 包下创建UserService.java ⽂件，提供⽤户详情查询⽅法

package com.xxxx.ssm.service;

import com.xxxx.ssm.dao.UserDao;
import com.xxxx.ssm.po.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    public User queryUserByUserId(Integer userId){
        return userDao.queryUserByUserId(userId);
    }
}

4.2.6. 添加 HelloController.java

在 com.xxxx.ssm.controller 包下创建 HelloController.java ⽂件

package com.xxxx.ssm.controller;

import com.xxxx.ssm.po.User;
import com.xxxx.ssm.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloController {
    // 注⼊userService
    @Autowired
    private UserService userService;
    @RequestMapping("/hello")
    public ModelAndView hello(){
        ModelAndView mv = new ModelAndView();
        // 调⽤service 层查询⽅法
        User user = userService.queryUserByUserId(1);
        mv.addObject("user", user);
        mv.setViewName("hello");
        return mv;
    }
}

4.2.7. 添加 hello.jsp 视图⽂件

在src/main/webapp/WEB-INF 创建jsp ⽬录，并在该⽬下创建hello.jsp ，展示查询的⽤户信息

<body>
	欢迎你，${user.userName}
</body>

4.3. 执⾏测试

4.3.1. Idea 下配置 jetty 启动命令

在这里插入图片描述

4.3.2. 启动 jetty 浏览器访问http://localhost:8080/ssm/hello查看结果

5. RestFul URL

5.1. 基本概念

模型 - 视图 - 控制器（MVC）是⼀个众所周知的以设计界⾯应⽤程序为基础的设计思想。

Restful ⻛格的 API 是⼀种软件架构⻛格，设计⻛格⽽不是标准，只是提供了⼀组设计原则和约束条件。它主要⽤于客户端和服务器交互类的软件。基于这个⻛格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

在Restful ⻛格中，⽤户请求的 url 使⽤同⼀个 url，⽤请求⽅式：get，post，delete，put…等⽅式对请求的处理⽅法进⾏区分，这样可以在前后台分离式的开发中使得前端开发⼈员不会对请求的资源地址产⽣混淆和⼤量的检查⽅法名的麻烦，形成⼀个统⼀的接⼝。

在 Restful ⻛格中，现有规定如下：

GET（SELECT）：从服务器查询，可以在服务器通过请求的参数区分查询的⽅式。
POST（CREATE）：在服务器端新建⼀个资源，调⽤ insert 操作。
PUT（UPDATE）：在服务器端更新资源，调⽤ update 操作。
PATCH（UPDATE）：在服务器端更新资源（客户端提供改变的属性）。(⽬前 jdk7 未实现，tomcat7 不⽀持)。
DELETE（DELETE）：从服务器端删除资源，调⽤ delete 语句。

5.2. SpringMVC ⽀持 RestFul URL ⻛格设计

案例：如何使⽤ Java 构造没有扩展名的RESTful url，如 /forms/1?
SpringMVC 是通过 @RequestMapping 及 @PathVariable 注解提供的。
通过如@RequestMapping(value="/blog /{id}", method = RequestMethod.DELETE)，即可处理/blog/1 的 delete 请求。

5.3. RestFul URL 映射地址配置

5.3.1. 准备环境

5.3.1.1. 添加 Account

在 src/resources/java 对应的 com.xxxx.ssm.po ⽬录下新建 Account.java 实体类

package com.xxxx.ssm.po;

import java.util.Date;

public class Account {

    private Integer accountId;
    private String accountName;
    private String accountType;
    private Double money;
    private Date createDate;
    private Date updateDate;
    private String remark;

    public Integer getAccountId() {
        return accountId;
    }

    public void setAccountId(Integer accountId) {
        this.accountId = accountId;
    }

    public String getAccountName() {
        return accountName;
    }

    public void setAccountName(String accountName) {
        this.accountName = accountName;
    }

    public String getAccountType() {
        return accountType;
    }

    public void setAccountType(String accountType) {
        this.accountType = accountType;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
}

5.3.1.2. 添加 AccountDao

在 src/resources/java 对应的 com.xxxx.ssm.dao ⽬录下新建 AccountDao.java 接⼝类

package com.xxxx.ssm.dao;

import com.xxxx.ssm.po.Account;
import com.xxxx.ssm.po.User;

public interface AccountDao {

    //查询
    public Account queryAccountById(Integer id);

    //删除
    public Integer deleteAccountById(Integer id);

    //修改
    public Integer updateAccount(Account account);

    //添加
    public Integer insertAccount(Account account);

}

}

5.3.1.3. 添加 AccountMapper

在 src/resources/java 对应的 com.xxxx.ssm.mapper ⽬录下新建 AccountMapper.xml 映射⽂件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xxxx.ssm.dao.AccountDao">
    <select id="queryAccountById" parameterType="Integer" resultType="com.xxxx.ssm.po.Account">
        select
            account_id accountId,account_name accountName , money money , account_type accountType,
            create_date createDate, update_date updateDate , remark remark
        from
            tb_account
        where
            account_id = #{id}
    </select>

    <delete id="deleteAccountById" parameterType="Integer">
        delete from tb_account where account_id = #{id}
    </delete>

    <update id="updateAccount" parameterType="com.xxxx.ssm.po.Account">
        update
            tb_account
        set
            account_name = #{accountName},
            money = #{money},
            account_type = #{accountType},
            create_date = now(),
            update_date = now(),
            remark = #{remark}
        where
            account_id = #{accountId}
    </update>

    <insert id="insertAccount" parameterType="com.xxxx.ssm.po.Account">
        insert into
            tb_account(account_name , money  , account_type ,create_date , update_date  , remark )
        values
            (#{accountName},#{money},#{accountType},now(),now(),#{remark})
    </insert>
</mapper>

5.3.1.4. 添加 AccountService

在 src/resources/java 对应的 com.xxxx.ssm.service ⽬录下新建 AccountService.java

@Service
public class AccountService {
 	@Autowired
 	private AccountDao accountDao;
 	public Account selectById(Integer id){
 		return accountDao.selectById(id);
 	}
 	public int saveAccount(Account account){
 		return accountDao.save(account);
 	}
 	public int updateAccount(Account account){
 		return accountDao.update(account);
 	}
 	public int delAccount(Integer id){
 		return accountDao.delete(id);
 	}
}

5.3.2. URL 映射地址配置

5.3.2.1. 请求配置

package com.xxxx.ssm.controller;

import com.xxxx.ssm.po.Account;
import com.xxxx.ssm.service.AccountService;
import com.xxxx.ssm.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * RestFul
 *      GET
 *      POST
 *      PUT
 *      DELETE
 *
 *      @RequestMapping(value = "url地址",method = RequestMethod.GET)
 *
 *      @PathVariable：表示参数为地址参数（值在url地址中）
 */
@Controller
public class AccountController {

    @Resource
    private AccountService accountService;

    @GetMapping("account/{id}")
    @ResponseBody
    public Account queryUser(@PathVariable Integer id){
        return accountService.queryAccountById(id);
    }

    @DeleteMapping("account/{id}")
    public ModelAndView deleteUser(@PathVariable Integer id){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("New_result");
        Integer index = accountService.deleteAccountById(id);
        if(index > 0){
            mv.addObject("msg","删除成功");
            mv.addObject("code",1);
        }else{
            mv.addObject("msg","删除失败");
            mv.addObject("code",0);
        }
        return mv;
    }


    @PostMapping("account")
    public ModelAndView insertUser(@RequestBody Account account){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("New_result");
        Integer index = accountService.insertAccount(account);
        if(index > 0){
            mv.addObject("msg","添加成功");
            mv.addObject("code",1);
        }else{
            mv.addObject("msg","添加失败");
            mv.addObject("code",0);
        }
        return mv;
    }


    @PutMapping("account")
    public ModelAndView updatetUser(@RequestBody Account account){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("New_result");
        Integer index = accountService.updateAccount(account);
        if(index > 0){
            mv.addObject("msg","修改成功");
            mv.addObject("code",1);
        }else{
            mv.addObject("msg","修改失败");
            mv.addObject("code",0);
        }
        return mv;
    }
}

6. 全局异常统⼀处理

6.1. 全局异常概念

在 JavaEE 项⽬的开发中，不管是对底层的数据库操作过程，还是业务层的处理过程，还是控制层的处理过程，都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常，系统的代码耦合度⾼，⼯作量⼤且不好统⼀，维护的⼯作量也很⼤。SpringMVC 对于异常处理这块提供了⽀持，通过 SpringMVC 提供的全局异常处理机制，能够将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单⼀，也实现了异常信息的统⼀处理和维护。
全局异常实现⽅式 Spring MVC 处理异常有 3 种⽅式：

使⽤ Spring MVC 提供的简单异常处理器 SimpleMappingExceptionResolver
实现 Spring 的异常处理接⼝ HandlerExceptionResolver ⾃定义⾃⼰的异常处理器
使⽤ @ExceptionHandler 注解实现异常处理

6.2. 异常处理实现

6.2.1. 全局异常处理⽅式⼀

6.2.1.1. 配置简单异常处理器

配置 SimpleMappingExceptionResolver 对象

<!-- 配置全局异常统⼀处理的 Bean （简单异常处理器） -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
 <!-- ⻚⾯在转发时出现异常，设置默认的错误⻚⾯ （error代表的是⼀个视图） -->
 <property name="defaultErrorView" value="error"></property>
 <!-- 异常发⽣时，设置异常的变量名 -->
 <property name="exceptionAttribute" value="ex"></property>
</bean>

可以在处理异常的⻚⾯获取异常信息

${ex}

6.2.1.2. 使⽤⾃定义异常

参数异常

/**
* ⾃定义异常：参数异常
*/
public class ParamsException extends RuntimeException {

 	private Integer code = 300;
	private String msg = "参数异常!";
 	public ParamsException() {
 		super("参数异常!");
 	}
 	public ParamsException(String msg) {
 		super(msg);
 		this.msg = msg;
 	}
 	public ParamsException(Integer code) {
 		super("参数异常!");
 		this.code = code;
 	}
 	public ParamsException(Integer code, String msg) {
 		super(msg);
 		this.code = code;
 		this.msg = msg;
 	}
 	public Integer getCode() {
 		return code;
 	}
 	public void setCode(Integer code) {
 		this.code = code;
 	}
 	public String getMsg() {
 		return msg;
 	}
 	public void setMsg(String msg) {
 		this.msg = msg;
 	}
}

业务异常

/**
* ⾃定义异常：业务异常
*/
public class BusinessException extends RuntimeException {
 	private Integer code=400;
 	private String msg="业务异常!";

 	public BusinessException() {
 		super("业务异常!");
 	}
 	public BusinessException(String msg) {
 		super(msg);
 		this.msg = msg;
 	}
 	public BusinessException(Integer code) {
 		super("业务异常!");
 		this.code = code;
 	}
 	public BusinessException(Integer code, String msg) {
 		super(msg);
 		this.code = code;
 		this.msg = msg;
 	}
 	public Integer getCode() {
 		return code;
 	}
 	public void setCode(Integer code) {
 		this.code = code;
 	}
 	public String getMsg() {
 		return msg;
 	}
 	public void setMsg(String msg) {
 		this.msg = msg;
 	}
}

6.2.1.3. 设置⾃定义异常与⻚⾯的映射

<!-- 设置⾃定义异常与⻚⾯的映射 -->
<property name="exceptionMappings">
 	<props>
 	<!-- key：⾃定义异常对象的路径； 标签中设置具体的处理⻚⾯的视图名-->
 	<prop key="com.xxxx.ssm.exception.BusinessException">error</prop>
 	<prop key="com.xxxx.ssm.exception.ParamsException">error</prop>
 	</props>
</property>

使⽤ SimpleMappingExceptionResolver 进⾏异常处理，具有集成简单、有良好的扩展性、对已有代码没有⼊侵性等优点，但该⽅法仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适⽤。

6.2.2. 全局异常处理⽅式⼆(推荐)

6.2.2.1. 实现 HandlerExceptionResolver 接⼝

/**
* 全局异常统⼀处理
*/
@Component
public class GlobalExceptionResolver implements HandlerExceptionResolver {
 	@Override
 	public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler,Exception ex) {
 	ModelAndView mv = new ModelAndView("error");
 	mv.addObject("ex","默认错误信息");
 	return mv;
 	}
}

6.2.2.2. ⾃定义异常处理

/**
* 全局异常统⼀处理
*/
@Component
public class GlobalExceptionResolver implements HandlerExceptionResolver {
 	@Override
 	public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler,Exception ex) {
 	ModelAndView mv = new ModelAndView("error");
 	mv.addObject("ex","默认错误信息");
 	// 判断是否是⾃定义异常
 	if (ex instanceof ParamsException) {
 	mv.setViewName("params_error");
 	ParamsException e = (ParamsException) ex;
 	mv.addObject("ex", e.getMsg());
 	}
 	if (ex instanceof BusinessException) {
 	mv.setViewName("business_error");
 	BusinessException e = (BusinessException) ex;
 	mv.addObject("ex", e.getMsg());
 	}
 	return mv;
 	}
}

6.2.3. 全局异常处理⽅式三

⻚⾯处理器继承 BaseController

public class BaseController {
 @ExceptionHandler
 public String exc(HttpServletRequest request,HttpServletResponse response,Exception ex){
	request.setAttribute("ex", ex);
 	if(ex instanceof ParamsException){
 		return "error_param";
 	}
 	if(ex instanceof BusinessException){
 		return "error_business";
 	}
 		return "error";
 	}
}

使⽤ @ExceptionHandler 注解实现异常处理，具有集成简单、有扩展性好（只需要将要异常处理的Controller 类继承于 BaseController 即可）、不需要附加Spring 配置等优点，但该⽅法对已有代码存在⼊侵性(需要修改已有代码，使相关类继承于 BaseController)，在异常处理时不能获取除异常以外的数据。

6.3. 未捕获异常的处理

对于 Unchecked Exception ⽽⾔，由于代码不强制捕获，往往被忽略，如果运⾏期产⽣了
Unchecked Exception，⽽代码中⼜没有进⾏相应的捕获和处理，则我们可能不得不⾯对尴尬的 404、500……等服务器内部错误提示⻚⾯。

此时需要⼀个全⾯⽽有效的异常处理机制。⽬前⼤多数服务器也都⽀持在 web.xml 中通过
(Websphere/Weblogic)或者(Tomcat)节点配置特定异常情况的显示⻚⾯。修改 web.xml ⽂件，增加以下内容：

<!-- 出错⻚⾯定义 -->
<error-page>
 	<exception-type>java.lang.Throwable</exception-type>
 	<location>/500.jsp</location>
</error-page>
<error-page>
 	<error-code>500</error-code>
 	<location>/500.jsp</location>
</error-page>
<error-page>
 	<error-code>404</error-code>
 	<location>/404.jsp</location>
</error-page>

7. 总结

SpringMVC 拦截器概念、实现配置与应⽤场景，借助SpringMvc来实现应⽤资源的拦截操作，借助 SpringMVC 框架⽂件上传环境实现了单⽂件与多⽂件上传功能。同时为了以后使⽤ SSM 框架开发企业应⽤，还完成了 SSM 框架环境整合操作，以后对与 SpringMVC 应⽤的开发基本都是在整合环境下进⾏，这⾥希望⼤家能够在整合环境下实现功能代码开发操作。

最后两块主要介绍 Restful 概念，在 SpringMVC 环境下 Restful URL 地址设计规范与账户模块代码实现，同时对于应⽤程序的异常通过使⽤ SpringMVC 全局异常来进⾏统⼀处理，从⽽降低异常处理代码的耦合度。

Trycol

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC详解（拦截器与文件上传框架整合）

SpringMVC - 第⼆天1. 学习⽬标2. 拦截器2.1. 基本概念SpringMVC 中的 Interceptor 拦截器也是相当重要和相当有⽤的，它的主要作⽤是拦截⽤户的请求并进⾏相应的处理。⽐如通过它来进⾏权限验证，或者是来判断⽤户是否登陆等操作。对于 SpringMVC拦截器的定义⽅式有两种：实现接⼝：org.springframework.web.servlet.HandlerInterceptor继承适配器：org.springframework.web.servlet.h
复制链接

扫一扫