SpringMVC03

SpringMVC的文件上传

一、文件上传的前端必要前提

form 表单的 entcype取值必须是：multipart/form-data。默认值：application/x-www-form-urlencoded，是表单请求正文的类型
method 属性取值必须是 post
提供一个文件选择域

二、文件上传原理分析

form 表单的 enctype取值不是默认值后，request.getParameter()将失效。
enctype=”application/x-www-form-urlencoded”时，form 表单的正文内容是：key=value&key=value&key=value;
form 表单的 enctype 取值为 Mutilpart/form-data 时，form 表单的请求正文内容就变成：每一部分都是 MIME 类型描述的正文;

enctype=“application/x-www-form-urlencoded”

key=value&key=value&key=value;
 request.getParameter(); 
 底层： form表单是一个大请求体：

enctype=“Mutilpart/form-data”;

 request.getParameter(); 失效
 每一个组件都是一个小的请求体： 
 ------------------------------------------------------
 username=lisi
 -------------------------------------------------------
 age=21
  ------------------------------------------------------
 file=xxx.jpg
  ------------------------------------------------------

三、SpringMVC的文件上传

1、构建maven工厂添加依赖(pom.xml)

<?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.etime</groupId>
    <artifactId>day0413</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spring.version>5.2.5.RELEASE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--commons-fileupload 依赖了commos-io Apach提供的-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>
</project>

2、配置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">
    <!--注册DispatcherServlet dispatcher:调度程序-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--加载dispatcherServlet初始化资源-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:application.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern><!-- 根路径下的，所有请求都经过dispatcher-->
    </servlet-mapping>
    <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>
</web-app>

3、配置application.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:mvc="http://www.springframework.org/schema/mvc"
       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-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
   <!-- 上下文组件扫描-->
    <context:component-scan base-package="com.etime"></context:component-scan>
    <!--&lt;!&ndash;处理器映射器:根据请求路径匹配映射器路径找到对应的执行器(Controller)&ndash;&gt;
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>
    &lt;!&ndash;处理器适配器:根据处理器映射器返回的执行器对象，去执行器对象(Controller)&ndash;&gt;
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>-->
    <!--视图解析器:解析视图-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <!--将上面标签替换成<mvc:annotation-driven/>-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--无法加载静态页面配置-->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>
   <!-- 注意： id必须固定~-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
</beans>

4、搭建jsp页面

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="upload/test01" method="post" enctype="multipart/form-data">
        文件上传:<input type="file" name="photo">
        <input type="submit" value="测试">
    </form>
</body>
</html>

message.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>message</title>
</head>
<body>
    <h1>测试消息</h1>
</body>
</html>

5、编写控制器

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

    @PostMapping("test01")
    public String test01(MultipartFile photo){
        // 文件存放位置
        String path = "D:"+ File.separator+"upload";
        File file = new File(path);
        // 文件不存在就创建
        if (!file.exists()) {
            file.mkdirs();
        }
        // 获取上传的文件名
        String originalFilename = photo.getOriginalFilename();
        // 上传
        try {
            /*File参数:
                参数1:父文件对象
                参数2:子文件名
            */
            photo.transferTo(new File(file,originalFilename));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "message";
    }
}

6、多文件

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="upload/test01" method="post" enctype="multipart/form-data">
        文件上传:<input type="file" name="photo">
        文件上传:<input type="file" name="photo">
        文件上传:<input type="file" name="photo">
        <input type="submit" value="测试">
    </form>
</body>
</html>

编写控制器代码

@PostMapping("test02")
public String test02(MultipartFile[] photo){
    // 文件存放位置
    String path = "D:"+ File.separator+"upload";
    File file = new File(path);
    // 文件不存在就创建
    if (!file.exists()) {
        file.mkdirs();
    }
    for (MultipartFile f : photo) {
        // 获取上传的文件名
        String originalFilename = f.getOriginalFilename();
        // 上传
        try {
        /*File参数:
            参数1:父文件对象
            参数2:子文件名
        */
            f.transferTo(new File(file,originalFilename));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return "message";
}

SpringMVC的异常处理

一、项目开发中一场处理得我方式介绍

系统异常
- 预期异常：通过捕获异常从而获取异常信息
- 运行时异常 RuntimeException：通过规范代码开发、测试等手段减少运行时异常的发生。

二、异常处理的设计思路

dao层、service层、controller层出现都通过 throws Exception 向上抛出，最后由 springmvc 前端控制器交由异常处理器进行异常处理。

三、异常处理的步骤

1、测试页面index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <a href="exceptionController/test">测试</a>
</body>
</html>

2、编写异常类

@Controller
@RequestMapping("/exceptionController")
public class ExceptionController {
    @GetMapping("test")
    public String test(){
        System.out.println("异常处理 进来了");
        int a = 10 / 0;
        return "message";
    }
}

测试原生报错异常

在这里插入图片描述

3、自定义异常处理器

（1）引入servlet-api依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
</dependency>

(2) 编写自定义处理器代码

@Component
public class MyException implements HandlerExceptionResolver {


    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
                                         Object o, Exception e) {
        e.printStackTrace();
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("message");
        return modelAndView;
    }
}

（3）编写处理异常的页面message

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>message</title>
</head>
<body>
    <h1>测试消息,出错了</h1>
</body>
</html>

（4）测试
在这里插入图片描述

SpringMVC的拦截器

一、拦截器的介绍和作用

SpringMVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。
开发者可以自定义一些拦截器来实现特定的功能。
拦截器链：Interceptor chain。连接器链：就是将拦截器按一定的顺序联结成一条链。
在访问被拦截的方法和字段时，拦截器链中的拦截器就会按照之前定义的顺序被调用。

二、拦截器与过滤器的区别（面试题）

区别	过滤器（Filter）	拦截器（Interceptor）
使用场景	过滤器是Servlet规范的一部分，任何 JavaWeb 工程都可以使用。	拦截器是SpringMVC 框架自己的，只有使用了SpringMVC框架的工程才能用。
作用	过滤器在web.xml中 url-pattern标签中配置了 /* 后，可对所用要访问的资源进行拦截。资源：html、css、js、image	拦截器只会拦截拦截访问的控制器方法，若访问的是 jsp、html、css、image或者js是不会进行拦截的。拦截器也是AOP思想的具体应用。
总结	拦截资源: /* : js、css、html、image	拦截资源：/**：控制器方法、jsp

三、自定义拦截器的步骤

1、实现 HandlerInterceptor 接口

HandlerInterceptor 接口

public interface HandlerInterceptor {
    // 控制层执行器方法前 的拦截器
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        /*
        	true:表示继续执行控制层控制器方法
        	false:表示方法结束，不会执行控制层执行器方法，也就是说不会进入控制层
        */
        return true;
    }
	// 控制层方法返回时 的拦截器
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
	// 控制器方法结束后 的拦截器
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

创建一个 HandlerInterceptor 接口的实现类

public class MyInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("控制层执行器方法 前 的控制器");
        // 注意返回值是 true，还是true
        return false;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("控制层执行器方法 返回值 的控制器");

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        System.out.println("控制层执行器方法 结束后 的控制器");
    }
}

2、编写控制器执行器测试方法

@GetMapping("test03")
public String test03(){
    System.out.println("拦截器测试方法 test03 进入拦截器");
    return "message";
}

@GetMapping("test04")
public String test04(){
    System.out.println("拦截器测试方法 test04 进入拦截器");
    return "message";
}

3、编写测试页面test01.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>test01</title>
</head>
<body>
    <a href="testController/test03">测试3</a>
    <a href="testController/test04">测试4</a>
</body>
</html>

4、配置拦截器application.xml

<!--配置拦截器链-->
<mvc:interceptors>
    <!--配置拦截器-->
    <mvc:interceptor>
        <!--拦截控制层执行方法的范围./**:拦截所用Controller请求-->
        <mvc:mapping path="/**"/>
        <!--配置不拦截某个控制层执行器方法。最前面一定要有/:表示根路径下-->
        <mvc:exclude-mapping path="/testController/test04"/>
        <!--配置 是那个拦截器，一定要有-->
        <bean class="com.etime.interceptor.MyInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

5、测试

点击测试03，而preHandle() 这个方法的返回值是 false，所以它进入该方法后就不会进入控制层方法了
点击测试04，而preHandle() 这个方法的返回值是 false，但是在application.xml文件中配置了不拦截test04的信息，故它没有被拦截，而进入了Controller层执行方法。

在这里插入图片描述

四、拦截器的注意事项

1、拦截器的放行

概念：若有下一个拦截器就执行下一个，若拦截器处于拦截器链的最后一个，则执行控制器中的方法。
注意：
- public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)方法返回true表示继续执行控制层执行器方法，返回false表示方法结束，不会执行控制层执行器方法

2、多个拦截器的执行顺序

（1）控制层执行器方法

@GetMapping("test03")
public String test03(){
    System.out.println("拦截器测试方法 test03");
    return "message";
}

@GetMapping("test04")
public String test04(){
    System.out.println("拦截器测试方法 test04");
    return "message";
}

（2）编写拦截器代码

拦截器1

public class FirstInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("控制层执行器 前 的拦截器1");
        /*
            true表示继续执行控制层执行器方法，
            false表示方法结束，不会执行控制层执行器方法
         */
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("控制层执行器方法 返回值 时的拦截器1");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("控制层执行器方法 结束后的拦截器1");
    }
}

拦截器2

public class SecondInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("控制层执行器 前 的拦截器2");
        /*
            true表示继续执行控制层执行器方法，
            false表示方法结束，不会执行控制层执行器方法
         */
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("控制层执行器方法 返回值 时的拦截器2");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("控制层执行器方法 结束后的拦截器2");
    }
}

（3）配置拦截器application.xml

<!--配置拦截器链-->
<mvc:interceptors>
    <!--配置拦截器1-->
    <mvc:interceptor>
        <!--拦截控制层执行方法的范围-->
        <mvc:mapping path="/**"/>
        <!--配置不拦截某个控制层执行器方法。最前面一定要有/-->
        <mvc:exclude-mapping path="/testController/test04"/>
        <!--配置 是那个拦截器，一定要有-->
        <bean class="com.etime.interceptor.FirstInterceptor"></bean>
    </mvc:interceptor>
    <!--配置拦截器2-->
    <mvc:interceptor>
        <!--拦截控制层执行方法的范围-->
        <mvc:mapping path="/**"/>
        <!--配置不拦截某个控制层执行器方法。最前面一定要有/-->
        <mvc:exclude-mapping path="/testController/test04"/>
        <!--配置 是那个拦截器，一定要有-->
        <bean class="com.etime.interceptor.SecondInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

（4）编写测试页面test01.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>test01</title>
</head>
<body>
    <a href="testController/test03">测试3</a>
    <a href="testController/test04">测试4</a>
</body>
</html>

（5）测试

结果截图：

在这里插入图片描述

拦截器执行过程：

控制层执行器方法前的拦截器，执行顺序是据配置拦截器的先后顺序执行的。
控制器执行器方法返回值时的拦截器，执行顺序是后配置先执行。
控制器执行器方法结束时的拦截器，执行顺序是后配置先执行。

五拦截器综合案例

1、实现思路分析

定义登录页面，并定义请求映射。
判断用户名密码是否正确
如果正确向 session 中写入用户信息
返回登录成功。
拦截用户请求，判断用户是否登录
如果用户已经登录。放行
如果用户未登录，跳转到登录页面

2、案例代码

（1）登录页面login.jsp bianxie

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>
    <form action="userController/login" method="post" enctype="application/x-www-form-urlencoded">
        用户名:<input type="text" name="username"><br>
        密码:<input type="password" name="password"><br>
        <input type="submit" value="登录">
    </form>
</body>
</html>

（2）控制层执行器方法login编写

@Controller
@RequestMapping("/userController")
@SessionAttributes("username")
public class UserController {

    @PostMapping("login")
    public ModelAndView login(String username,String password){
        System.out.println("username = " + username);
        ModelAndView modelAndView = new ModelAndView();
        // 模拟登录成功
        boolean res = true;
        if (res){
            modelAndView.addObject("username",username);
            modelAndView.setViewName("message");
        }else {
            System.out.println("密码或用户名错误");
        }
        return modelAndView;
    }
}

（3）拦截器编写

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        HttpSession session = request.getSession();
        Object username = session.getAttribute("username");
        System.out.println("loginInterceptor username = "+username);
        if (username != null && username != ""){
            System.out.println("已登录");
            response.sendRedirect("../message.jsp");
            return true;
        }else {
            System.out.println("未登录");
            response.sendRedirect("../login.jsp");
            return false;
        }
    }

}

（4）注册拦截器

<!--配置拦截器链-->
<mvc:interceptors>
    <!--配置拦截器login-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/userController/login"/>
        <bean class="com.etime.interceptor.LoginInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

（5）测试

直接访问前面的 test01.jsp页面中的测试方法，并点击测试，结果是返回到登录页面。分析：没有登录session中没有 username这个属性值，被拦截器给拦截，返回到登录页面
输入用户名和密码登录成功，并将username 暂存到session中，执行其他方法时 session中username属性值存在，能进行操作

edirect(“…/message.jsp”);
return true;
}else {
System.out.println(“未登录”);
response.sendRedirect(“…/login.jsp”);
return false;
}
}

}


（4）注册拦截器

```xml
<!--配置拦截器链-->
<mvc:interceptors>
    <!--配置拦截器login-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/userController/login"/>
        <bean class="com.etime.interceptor.LoginInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

（5）测试

直接访问前面的 test01.jsp页面中的测试方法，并点击测试，结果是返回到登录页面。分析：没有登录session中没有 username这个属性值，被拦截器给拦截，返回到登录页面
输入用户名和密码登录成功，并将username 暂存到session中，执行其他方法时 session中username属性值存在，能进行操作