狂神说SpringMVC视频学习笔记（自用）

最新推荐文章于 2022-12-13 13:48:27 发布

发际线码农

最新推荐文章于 2022-12-13 13:48:27 发布

阅读量966

点赞数 1

文章标签： java springmvc

本文链接：https://blog.csdn.net/qq_43130076/article/details/121763323

版权

SpringMVC学习笔记

SSM：mybatis+Spring+SpringMVC

javaSE：

javaWeb：

框架：研究官方文档，锻炼自学能力，锻炼笔记能力，锻炼项目能力

javaee + mysql + jdbc + mybatis + spring + SpringMVC + Vue + SpringBoot + SpringCloud + Linux

SSM = javaweb做项目

Spring：IOC和AOP

spring、springMVC和MyBatis之间的关系

spring：提供了一种代理模式IOC（控制反转）和AOP（面向切面编程），将mybatis和springMVC配置文件整合在一起（不用再new对象，在程序需要加入新功能时不用重写代码使用切面编程）
springMVC实现控制层，视图层，和数据之间的交互，主要是通过控制层对各种条件的设置对相对应显示的视图页面的一种控制。而控制层和数据层也需要进行交互（完成控制页面，控制页面）
mybatis：完成程序和数据库之间的交互，使用mapper.xml文件完成接口的实现，完成我们对数据库的操作。（操作数据库）

1、SpringMVC

官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

MVC：Model(dao,service)+View(jsp)+Controller(servlet)模型，视图，控制器

dao

service

servlet

jsp/html

将业务逻辑，数据，显示分离的方法组织代码。MVC主要作用是降低了视图与业务逻辑间的双向耦合

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或者JavaBean组件（包含数据和行为），不过现在一般都分离开，value Object（数据Dao）和服务层（service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包含数据和业务。

业务逻辑
保存数据的状态

View（视图）：负责进行模型的展示一般都是我们见到的用户界面，客户想看到的东西

显示页面

Controller（控制器）：接收用户请求委托给模型进行处理（状态改变），处理完毕之后把返回的模型数据返回给制图，由视图负责展示

取得表单数据
调用业务逻辑
转向指定的页面

假设：项目的架构，是设计好的还是演进的？

Alibaba PHP
随着用户的增加，java

Spring MVC的特点：

轻量级，简单易学
高效，基于请求响应的mvc框架
与spring兼容性好，无缝结合
约定大于配置
功能强大：REATFul风格，数据验证、格式化、本地化、主题等
简洁灵活
以请求为驱动，围绕一个中心servlet分派请求及提供其他功能，DispatcherServlet是一个实际的servlet（它继承自httpservlet的基类）

2、回顾servlet

2.1、创建父项目（Spring-mvc）在父项目pom.xml中配置依赖

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

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

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>3.0-alpha-1</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2.1-b03</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

</dependencies>

2.2、在父项目中创建子项目（springmvc-01-servlet）并添加web支持

2.3、在子项目的pom.xml文件中配置依赖

jsp和jar依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>3.0-alpha-1</version>
</dependency>

<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2.1-b03</version>
</dependency>

2.4、创建包com.company.servlet

2.5、新建一个java文件，HelloServlet.java，继承HttpServlet，重写doGet和doPost方法

package com.company.servlet;

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

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //取得参数
        String method = req.getParameter("method");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //业务逻辑
        //视图跳转
        req.getRequestDispatcher("WEB-INF/jsp/hello.jsp").forward(req,resp);
    }

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

2.6、在web中WEB-INF文件夹下创建一个新的文件夹jsp，新建一个hello.jsp

<%--
  Created by IntelliJ IDEA.
  User: zhangyingying
  Date: 2021/10/15
  Time: 15:49
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>hello</title>
</head>
<body>
${msg}
</body>
</html>

2.7、配置web.xml（注册Servlet）

<?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">

    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.company.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

2.8、在WEB-INF文件下新建一个from.jsp

<%--
  Created by IntelliJ IDEA.
  User: zhangyingying
  Date: 2021/10/15
  Time: 15:59
  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 action="/hello" method="post">
    <input type="text" name="method">
    <input type="submit">
</form>
</body>
</html>

2.9、添加配置Tomcat，运行程序

SpringMVC要做的哪些事情

将url映射到java类或java方法
封装用户提交的数据
处理请求——调用相关的业务处理——封装响应数据
将响应的数据进行渲染，.jsp/html等表示层数据

常见的服务器端mvc框架有：Struts、SpringMVC、ASP.NET MVC、Zend Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM等。

3、SpringMVC第一个程序

SpringMVC的执行原理

这里有一个图丢了。。。。。呜呜呜呜呜找回来我会补上的

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

如上url拆分成三部分：

http://localhost:8080服务器域名

SpringMVC部署在服务器上的web站点

hello表示控制器

通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

3.1、创建一个干净的maven项目作为父项目

3.2、在maven父项目中创建一个子模块springmvc-02-hello并添加web支持

3.3、给子模块添加web依赖

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

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>3.0-alpha-1</version>
</dependency>

<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2.1-b03</version>
</dependency>

3.4、配置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">

    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>


    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>

3.5、在resources下创建springmvc-servlet.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--1、BeanNameUrlHandlerMapping 处理器映射器的 name 名字中必须要有‘/’
         （该映射器是使用处理器的 name 值来作为url映射的）
         即根据 "http://loaclhost:8080/springMvc/simpleController2.action" 
         来找到处理器 com.wangBeat.module.simpleController -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--2、处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>


    <!--3、视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


    <!--Handler-->
    <bean id="/hello" class="com.company.controller.HelloController"/>

</beans>

3.6、在java文件夹下创建com.company.controller后创建HelloController.java

HelloController.java

package com.company.controller;

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


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


//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }

}

3.7、在WEB-INF下创建jsp文件夹

创建hello.jsp

<%--
  Created by IntelliJ IDEA.
  User: zhangyingying
  Date: 2021/10/16
  Time: 10:23
  To change this template use File | Settings | File Templates.
--%>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>hello</title>
</head>
<body>
${msg}
</body>
</html>

3.8、配置本地tomcat启动tomcat

3.9、出现问题

404

查看控制台是否有jar包没导入，如果导入的话

打开设置，在WEB-INF下创建lib将maven导入，如下图

这里有一个图丢了。。。。。呜呜呜呜呜找回来我会补上的

查看maven是否本地maven仓库

编码是否都设置为utf-8

重启tomcat

4、使用注解开发Springmvc

4.1、springmvc配置

使用注解开发不需要再配置映射器、适配器和对应controller层的bean

<!--自动扫描包，让指定包下的注解生效，由IOC统一管理。相当于spring中的托管类-->
<context:component-scan base-package="com.company.controller"/>
<!--让SpringMVC不再处理静态资源-->
<mvc:default-servlet-handler/>

<!--
   支持mvc注解驱动
   在spring中一般采用@RequestMapping注解来完成映射关系
   要想使@RequestMapping注解生效
   必须向上下文中注册DefaultAnnotationHandlerMapping
   和一个AnnotationMethodHandlerAdapter实例
   这两个实例分别在类级别和方法级别处理。
   而annotation-driven配置帮助我们自动完成上述两个实例的注入。
-->
<mvc:annotation-driven/>
<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>

4.2、由于Maven可能存在资源过滤问题要在pom.xml中配置

<build>
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>false</filtering>
       </resource>
       <resource>
           <directory>src/main/resources</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>false</filtering>
       </resource>
   </resources>
</build>

4.3、配置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">
 
   <!--1.注册servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
       </init-param>
       <!-- 启动顺序，数字越小，启动越早 -->
       <load-on-startup>1</load-on-startup>
   </servlet>
 
 
   <!--所有请求都会被springmvc拦截 -->
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

注意：

<!--所有请求都会被springmvc拦截 -->
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

注意/和/*的区别：

< url-pattern > / </ url-pattern > 不会匹配到.jsp，只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类。

< url-pattern > /* </ url-pattern > 会匹配 *.jsp，会出现返回 jsp视图时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。

注意web.xml版本问题，要最新版！

注册DispatcherServlet

关联SpringMVC的配置文件

启动级别为1

映射路径为 / 【不要用/*，会404】

4.4、创建Controller

由于使用了注解开发，我们不用再继承Controller只需要用简单的注解和下方简单代码就可以完成继承中的应用

package com.kuang.controller;
  
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
 
 
@Controller
@RequestMapping("/HelloController")
public class HelloController {
 
 
   //真实访问地址 : 项目名/HelloController/hello
   @RequestMapping("/hello")
   public String sayHello(Model model){
       //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
       model.addAttribute("msg","hello,SpringMVC");
       //web-inf/jsp/hello.jsp
       return "hello";
  }
}

@Controller是为了让Spring IOC容器初始化时自动扫描到；

@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；

方法中声明Model类型的参数是为了把Action中的数据带到视图中；

方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

4.5、创建视图层

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>hello</title>
</head>
<body>
${msg}
</body>
</html>

5、Controller配置总结

使用Controller注解的原因：

使用继承的方式每添加一个controller就要重写一个类，代码的冗余度太高。使用注解就可以在一个类中写多种不同类型的方法

以继承方式实现controller每添加一个控制器就要在配置文件中配置一个bean，代码冗余度增加。

@Controller注解用于将类注册到spring中，提醒这是一个控制类，因此使用@Controller注解需要在SpringMVC-config.xml文件中配置，用于自动扫描指定包下的注解，使注解生效。

<context:component-scan base-package="com.company.controller"

6、RequestMapping说明

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
为了测试结论更加准确，我们可以加上一个项目名测试 myweb
只注解在方法上面

7、RestFul风格讲解

一种资源定位及资源操作的风格

**功能：**使用POST、GET、DELETE、PUT使用不同方法对资源进行操作，分别对应添加、查询、删除、修改

传统方式操作资源：通过不同的参数来实现不同的效果

RESTFul操作资源：可以通过不同的请求方式来实现不同的效果，请求地址可能一样但功能可能不同（转发的特点）

@Controller
public class RestFulController{
    //将请求路径中传入的值对应到参数中
    @RequestMapping("/hello/{p1}/{p2}")
    public String test(@PathVariable int p1,@PathVariable int p2,Model model){
        int result = p1 + p2;
        //向视图中传值
        model.addAttribute("msg","结果："+result);
        //返回视图文件名
        return "test";
    }
}

优点：框架会自动进行类型转换，路径变的简洁，通过路径变量可以约束访问参数

8、重定向和转发

结果跳转方式：转发和重定向

ModelAndView

设置ModelAndView对象，根据view的名称和视图解析器跳到指定的页面

页面：{视图解析器前缀} + viewName + {视图解析器后缀}

<bean class = "org.springfamework.web.servlet.view.InternalResourceViewResolver" id = "internalResourceViewResolver">
    <property name = "prefix" value = "/WEB-INF/jsp/"/>
    <property name = "suffix" value = ".jsp"/>
</bean>

对应的controller类

public class ControllerTest implements Controller{
    public ModelAndView handleRequest(HttpservletRequest httpservletRequest,HttpservletResonse HttpservletResonse) throw Exception{
        ModelAndView model = new ModelAndView();
        mv.addObject("msg","ControllerTest");
        mv.setViewName("test");
        return mv;
    }
}

ServletAPI

通过设置HttpServletResponse进行输出

通过HttpServletResponse进行重定向

通过HttpServletRequest进行转发

@Controller
public class ResultGo {
 
    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        //输出
        rsp.getWriter().println("Hello,Spring BY servlet API");
    }
 
    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        //重定向
        rsp.sendRedirect("/index.jsp");
    }
 
    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //转发
        req.setAttribute("msg","/result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
    }
 
}

SpringMVC来实现转发和重定向——无需视图解析器

@Controller
public class RequestSpringMVC{
    @RequestMapping("/rsm/t1");
    public String test1(){
        //转发
        return "/index.jsp";
    }
    
    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发
        return "forward:/index.jsp";
    }
    
    @RequestMapping("/rsm/t3")
    public String test3(){
        //重定向
        return "redirect:/index.jsp";
    }
}

通过SpringMVC来实现转发和重定向——有视图解析器

@Controller
public class RequestSpringMVC2{
    @RequestMapping("/rsm/t1");
    public String test1(){
        //转发
        return "test";
    }
    
    @RequestMapping("/rsm/t2")
    public String test2(){
        //重定向
        return "redirect:/index.jsp";
    }
}

数据处理

1、处理提交数据：提交的域名称和处理方法的参数名一致

请求路径提交数据：http://localhost:8080/hello?name=zhangsan

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

2、提交的域名称和处理方法的参数名不一致

请求路径提交数据：http://localhost:8080/hello?username=zahngsan

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

3、提交的是一个对象

要求提交表单域和对象的属性名一致，参数使用对象即可

1、实体类

public class User{
    private int id;
    private String name;
    private int age;
}

2、数据请求连接：http://localhost:3306/hello?name=zhangsan&id=1&age=30

3、Controller

@RequestMapping("/hello")
public String user(User user){
    System.out.println(user);
    return "hello";
}

4、数据显示到前端

4.1、通过ModelAndView

public ModelAndView handleRequest(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse) throw Exception{
    
    //返回一个模型视图对象
    ModelAndView mv = new ModelAndView();
    mv.addObject("msg","ControllerTest");
    mv.setName("test");
    return mv;
}

4.2、通过ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

4.3、通过Model

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, Model model){
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

对比：

Model简化了新手对于Model对象的操作和理解；

ModelMap继承了LinkMap除了自己特有的方法还有父类的方法和特性

ModelAndView可以在存储数据的同时进行设置返回的逻辑视图，进行控制展示层的跳转。

9、乱码过滤器

9.1、自己写一个过滤器

修改tomcat配置文件

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

自定义过滤器

package com.company.filter;

import javax.servlet.*;
import java.io.IOException;

public class EncodingFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

配置文件web.xml

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.company.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <!--都经过过滤器，包括.jsp文件-->
    <url-pattern>/*</url-pattern>
</filter-mapping>

9.2、使用spring提供的过滤器

在一些极端情况下这个过滤器对get的支持不友好

<filter>
    <filter-name>encoding</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>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

9.3、大佬提供的过滤器

package com.kuang.filter;
 
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
 
/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {
 
    @Override
    public void destroy() {
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
 
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
}
 
//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
 
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }
 
    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
 
    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
 
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

配置文件中进行配置

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.company.filter.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <!--都经过过滤器，包括.jsp文件-->
    <url-pattern>/*</url-pattern>
</filter-mapping>

10、JSON

10.1、什么是JSON?

是一种轻量级的数据交换格式，目前使用特别广泛
采用完全独立于编程语言的文本格式来存储和表示数据
简洁，清晰
易于机器解析和生成，并有效的提升网络传输效率
对象表示方式为键值对，数据由逗号分隔
花括号保存对象，方括号保存数组

10.2、JSON键值对是用来保存JavaScript对象的一种方式

{"name":"张三"}
{"age":"3"}
{"sex":"男"}

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

10.3、JSON和JavaScript对象互转

//将JSON字符串转换为JavaScript对象JSON.parse()
var obj = JSON.parse('{"a": "Hello", "b": "World"}');

//将JavaScript对象转换为JSON字符串
var json = JSON.stringify({a: 'Hello', b: 'World'});

10.4、Controller返回JSON数据

10.4.1、配置jackson依赖(pom.xml)

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

10.4.2、实体类

package com.company.pojo;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
 
    private String name;
    private int age;
    private String sex;
}

10.4.3、Controller

@Controller
public class UserController{
    //json出现中文乱码问题，需要在请求注解里指定返回类型和编码
    //produces:指定响应体返回类型和编码
    @RequestMapping("/json1",produces = "application/json;charset=utf-8")
    public String jsonTest(Model model){
        ObjectMapper mapper = new ObjectMapper();
        User user = new User("张三",40,"男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

10.5、JSON乱码统一解决

在springmvc-config.xml文件中添加

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

10.6、返回json字符串统一解决

如果一个类整个都要返回json字符串不经过制图解析器，那就在类上加@RestController

10.7、将时间对象返回为json字符串

@RequestMapping("/json")
public String jsonTest(){
    ObjectMapper mapper = new ObjectMapper();
    
    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm-ss");
    //指定日期格式
    mapper.setDateFormat(sdf);
    Date date = new Date();
    String str = mapper.writeValueAsString(date);
    return str;
}

10.8、FastJson

10.8.1、pom依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

10.8.2、fastjson的三个类

JSONObject代表JSON对象
JSONArray代表json数组对象

JSONObject和JSONArray的转化

JSON类源码分析与使用
主要是实现json对象，json对象数组，javabean数组，json字符串之间的相互转化。

package com.kuang.controller;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kuang.pojo.User;
 
import java.util.ArrayList;
import java.util.List;
 
public class FastJsonDemo {
    public static void main(String[] args) {
        //创建一个对象
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
 
        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);
 
        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
 
        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
 
        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}

注解的使用方式：

dao层接口【@Repository】
service层实现类【@Service】
controller层控制类【@Controller】
bean层实体类【@Component】

使用以上注解最大的作用不是希望不同的注解实现不同的功能，这些注解的存在是为了能让spring自动扫描到类并注册，而不用手动将这些类注册到spring中。

但我们一般不使用@Component和@Repository注解

整合ssm框架

创建一个总的配置文件applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:spring-dao.xml"/>
    <import resource="classpath:spring-Service.xml"/>
    <import resource="classpath:springmvc-config.xml"/>
</beans>

1、整合Mybatis

db.properties：数据库基本信息配置文件

jdbc.driver=com.mysql.jdbc.Driver
#如果使用的是mysql8.0+，增加一个时区的配置；$serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

MyBatis-config.xml：MyBatis配置（MyBatis配置文件框架）

<?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>
    <!--配置数据源，交给Spring去做-->
    <typeAliases>
        <package name="com.company.bean"/>
    </typeAliases>
    <!--配置Mapper文件路径，每写一个就要配置一个-->
    <mappers>
        <mapper resource="com/company/dao/BookMapper"/>
    </mappers>
</configuration>

Spring-dao.xml：Spring整合Mybatis中的数据库配置(Spring配置文件框架)

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

    <!--1、关联数据库配置文件:绑定数据库基本信息配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--2、配置连接池
        dbcp:半自动化操作
        c3p0:自动化操作（）
        druid:
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--3、创建SqlSessionFactory：相当于Connection连接-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--引入数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--绑定MyBatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--
          4、配置dao接口扫描包，动态实现了Dao接口可以注入Spring容器中
          这里dao层没有添加注解，MapperScannerConfigurer会自动帮我们成批的创建映射器。
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--要扫描的dao包-->
        <property name="basePackage" value="com.company.dao"/>
    </bean>
</beans>

2、整合Spring

service层第一次出现在spring框架的代理模式中，service层的出现便于我们后面添加新的代码和功能，符合Spring的面向切面编程（AOP）

spring-service.xml

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

    <!--1、扫描service下的包，通过自动扫描注解，将类注入到spring容器中-->
    <context:component-scan base-package="com.company.service"/>

    <!--2、将我们的所有业务类，注入到Spring,可以通过配置或者注解实现-->
    <bean id="BookServiceImpl" class="com.company.service.Impl.BookServiceImpl">
        <!---->
        <property name="bookDao" ref="bookDao"/>
    </bean>

    <!--3、声明式事务配置-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--4、aop事务支持-->
</beans>

11、AJAX异步无刷新请求

AJAX = Asynchronous JavaScript and XML（异步的JavaScript和XML）

AJAX是一种在无需加载整个网页的情况下，能够更新局部网页的技术。

jQuery.ajax

Ajax的核心是XMLHttpRequest对象（XHR）

坑：jQuery文件放在web下面，而不是WEB-INF下面

11.1、异步加载数据

前端通过Ajax请求后台然后加载数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/static/js/jquery-3.4.1.js"></script>
    <script>
        $(function (){
            $("#btn").click(function (){
                $.post({
                    //向后台发送要请求的url
                    url:"${pageContext.request.contextPath}/a2",
                    //回调函数
                    success:function (data){
                        var html="";
                        for (let i = 0; i < data.length; i++) {
                            html += "<tr>" +
                                "<td>" + data[i].name + "</td>" +
                                "<td>" + data[i].age + "</td>" +
                                "<td>" + data[i].sex + "</td>" +
                                "</tr>"
                        }

                        $("#content").html(html);
                    }
                });

            })
        });

    </script>
</head>
<body>
<input type="button" value="加载数据" id="btn">
<table>
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
    <%--从后台获取数据--%>
    </tbody>
</table>
</body>
</html>

失去焦点时发起一个请求

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
    <%--将jquery资源加载过来--%>
    <script src="${pageContext.request.contextPath}/static/js/jquery-3.4.1.js"></script>

    <script>
      function a(){
        /*post请求类型*/
        $.post({
          //向后台发送要请求的url
          url:"${pageContext.request.contextPath}/a1",
          //传送数据，获取表单的值传给java请求
          data:{"name":$("#username").val()},
          //回调函数
          success:function (data){
            alert(data);
          }
        })
      }
    </script>
  </head>
  <body>

  <%--失去焦点事务时候，发起一个请求(携带信息)到后台--%>
  <%--当这个表单失去焦点时请求一个事件a--%>
  用户名：<input type="text" id="username" onblur="a()">
  </body>
</html>

对应的controller层

package com.company.controller;

import com.company.bean.User;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * ClassName: ajaxController
 * Description:
 * date: 2021/11/16 10:44
 *
 * @author zhangyingying
 * @since JDK 1.8
 */
@RestController
public class ajaxController {
    @RequestMapping("/t1")
    public String test(Model model){
        model.addAttribute("msg","helloword!");
        return "hello2";
    }

    @RequestMapping("/a1")
    public void abc(String name, HttpServletResponse response) throws IOException {
        System.out.println("a1:param=>" + name);
        if("zhangsan".equals(name)){
            response.getWriter().print("true");
        }else {
            response.getWriter().print("false");
        }
    }

    @RequestMapping("/a2")
    public List<User> a2(){
        List<User> userList = new ArrayList<User>();

        userList.add(new User("zhangsan",30,"男"));
        userList.add(new User("李四",30,"男"));
        userList.add(new User("王五",30,"男"));
        //添加数据
        return userList;
    }
}

11.2、验证用户名

前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
    <script src="${pageContext.request.contextPath}/static/js/jquery-3.4.1.js"></script>
    <script>
        function a1(){
            //发起一个请求验证用户名是否存在
            $.post({
                url:"${pageContext.request.contextPath}/b1",
                data:{"username":$("#name").val()},
                success:function (data){
                    console.log(data);
                    if (data.toString() === "OK"){
                        $("#userInfo").css("color","green");
                    }else {
                        $("#userInfo").css("color","red");
                    }
                    $("#userInfo").html(data);
                }
            })
        }
        function a2(){
            $.post({
                url:"${pageContext.request.contextPath}/b1",
                data:{"password":$("#password").val()},
                success:function (data){
                    console.log(data);
                    if (data.toString() === "OK"){
                        $("#pwdInfo").css("color","green");
                    }else{
                        $("#pwdInfo").css("color","red");
                    }
                    $("#pwdInfo").html(data);
                }
            })


        }
    </script>

</head>
<body>
<p>
    用户名：<input type="text" id="name" onblur="a1()">
    <span id="userInfo"></span>
</p>
<p>
    密码：<input type="text" id="password" onblur="a2()">
    <span id="pwdInfo"></span>
</p>
</body>
</html>

对应的controller层

@RequestMapping("/b1")
public String b1(String username,String password){
    String msg = null;
    if(username!=null){
        if(username.equals("admin")){
            msg = "OK";
        }else{
            msg="用户名有误！";
        }
    }
    if(password!=null){
        if(password.equals("123456")){
            msg = "OK";
        }else{
            msg="密码有误！";
        }
    }
    return msg;
}

HTML（熟练）+css（略懂）+js（超级熟练）

js面试常问：

函数：闭包（）（）
Dom
- id,name,tag
- create, remove
Bom
- window
- document

12、拦截器

类似于Servlet开发中的过滤器Filter

**过滤器和拦截器的区别：**拦截器是AOP思想的具体应用（横切进程序不改变原本的代码）

过滤器

Servlet的一部分，任何java web工程都可以用

在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

拦截器只会拦截访问的控制器方法，如果访问的是jsp /html /css /image / js是不会进行拦截的

12.1、自定义拦截器

自定义

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行前");
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    //拦截日志
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("执行后");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }
    
    //拦截日志
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("清理");
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

拦截器配置

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.company.config.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

12.2、登录判断验证

自定义的用户登录拦截器

package com.company.config;

import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * ClassName: LoginInterceptor
 * Description:
 * date: 2021/11/18 14:43
 *
 * @author zhangyingying
 * @since JDK 1.8
 */
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        //放行的判断,因为拦截器会拦截所有情求
        //登录页面应该不被拦截
        if(request.getRequestURI().contains("login")){
            return HandlerInterceptor.super.preHandle(request, response, handler);
        }
        //登录状态下的首页也不被拦截
        //第一次登录也不会有session
        if(session.getAttribute("userLoginInfo") !=null ){
            return HandlerInterceptor.super.preHandle(request, response, handler);
        }

        //判断没有登录的情况，没有登录就不能进入首页,跳转到登录页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
        return false;

    }
}

控制层

package com.company.controller;

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

import javax.servlet.http.HttpSession;

/**
 * ClassName: interceptorTest
 * Description:
 * date: 2021/11/18 11:33
 *
 * @author zhangyingying
 * @since JDK 1.8
 */
@Controller
@RequestMapping("/user")
public class interceptorTest {
    @RequestMapping("/main")
    public String firstPage(){
        return "main";
    }

    @RequestMapping("/gologin")
    public String gologin(){
        return "login";
    }

    @RequestMapping("/login1")
    public String login(HttpSession session,String username, String password){
        session.setAttribute("userLoginInfo",username);
        return "main";
    }

    @RequestMapping("/goOut")
    public String goOut(HttpSession session){
        session.removeAttribute("userLoginInfo");
        return "main";
    }
}

applicationContext.xml配置拦截器

<mvc:interceptor>
    <mvc:mapping path="/user/**"/>
    <bean class="com.company.config.LoginInterceptor"/>
</mvc:interceptor>

jsp页面

登录页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录页面</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/user/login1">
    用户名：<input type="text" name="username">
    密 码：<input type="text" name="password">
    <input type="submit" value="提交">
</form>
</body>
</html>

首页页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<h1>首页信息</h1>
<span>${username}</span>
<p>
    <a href="${pageContext.request.contextPath}/user/goOut">退出</a>
</p>
</body>
</html>

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <h1>
    <a href="${pageContext.request.contextPath}/user/main">网站首页</a>
    <a href="${pageContext.request.contextPath}/user/gologin">登录页面</a>
  </h1>
  </body>
</html>

13、文件上传和下载

SpringMVC可以很好的支持文件上传，但SpringMVC上下文中默认没有装配装配MultipartResolver因此，默认情况下其不能处理文件上传工作，如果想使用Spring文件上传功能，需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。这样浏览器才会把用户选择的文件以二进制数据发送给服务器。

对表单中的 enctype 属性做个详细的说明：

application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

<form action="" enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>
    <input type="submit">
</form>

导入文件上传的jar包

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>

上传下载页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>首页</title>
  </head>
  <body>
  <%--以流的方式提交一个file--%>
  <form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post">
    <%--输入一个类型是file的文件--%>
    <input type="file" name="file"/>
    <input type="submit" value="upload">
  </form>
  <a href="${pageContext.request.contextPath}/download">点击下载</a>
  </body>
</html>

上传下载控制层代码

package com.company.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.commons.CommonsMultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;

@Controller
public class FileController {
    
    //上传文件
    //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
    //批量上传CommonsMultipartFile则为数组即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

        //获取文件名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();

        //如果文件名为空，直接回到首页！
        if ("".equals(uploadFileName)){
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名 : "+uploadFileName);

        //上传路径保存设置
        String path = request.getSession().getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址："+realPath);

        InputStream is = file.getInputStream(); //文件输入流
        OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流

        //读取写出
        int len=0;
        byte[] buffer = new byte[1024];
        while ((len=is.read(buffer))!=-1){
            os.write(buffer,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }

    //下载文件
    @RequestMapping(value="/download")
    public String downloads(HttpServletResponse response , HttpServletRequest request) throws Exception{
        //要下载的图片地址
        String  path = request.getSession().getServletContext().getRealPath("/upload");
        String  fileName = "基础语法.jpg";

        //1、设置response 响应头
        response.reset(); //设置页面不缓存,清空buffer
        response.setCharacterEncoding("UTF-8"); //字符编码
        response.setContentType("multipart/form-data"); //二进制传输数据
        //设置响应头
        response.setHeader("Content-Disposition",
                "attachment;fileName="+ URLEncoder.encode(fileName, "UTF-8"));

        File file = new File(path,fileName);
        //2、 读取文件--输入流
        InputStream input=new FileInputStream(file);
        //3、 写出文件--输出流
        OutputStream out = response.getOutputStream();

        byte[] buff =new byte[1024];
        int index=0;
        //4、执行 写出操作
        while((index= input.read(buff))!= -1){
            out.write(buff, 0, index);
            out.flush();
        }
        out.close();
        input.close();
        return null;
    }
}