spring MVC从零开始

创建第一个hellow程序

用到的编译器是一个Intellij
创建一个maven的
然后按照提示操作,进入之后打开pom.xml

这里是对我们创建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>test1</groupId><artifactId>test1-demo1</artifactId><version>1.0-SNAPSHOT</version><packaging>war </packaging><!--打包方式--><dependencies><!--这里面描述的都是添加的依赖--><!--添加spring MVC--><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.1</version></dependency><!--添加日志--><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.3</version></dependency><!--添加ServletApI--><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.1.0</version><!--依赖范围设置--><scope>provided</scope></dependency><!--Spring5 和Thymelef--><!--thymelef 用来控制我们当前显示--><dependency><groupId>org.thymeleaf</groupId><artifactId>thymeleaf-spring5</artifactId><version>3.0.12.RELEASE</version></dependency></dependencies>

接下来我们配置web.xml
首先我们要创建一个web.xml，web.xml位于src/main/webapp/WEB-INF/web.xml

创建一个webapp文件

创建web.xml

补齐目录为完整路径后点击欧克

然后点击Apply
这样我们就创建了一个web.xml

配置web.xml

这里我们配置的是
第一种默认的springMVc方法

或者可以使用第二种扩展的

我们通过使用这个方法来指定我们所创建的文件位置在哪<init-param><param-name>contextConfigLocation</param-name><!--contextConfigLocation这个叫做上下文配置路径--><!--这里配置了classpath我们就可以去resources里面创建一个springMvc.xml文件--><param-value>classpath:springMvc.xml</param-value><!--这里设置的是一个是位置classpath,一个是名称--></init-param><load-on-startup>1</load-on-startup><!--将前端控制器DispatcherServlet的初始化提前到服务器启动时-->

就可以在resources里面创建一个springMvc.xml了，这里我们创建的文件名称需要和param-values>中指定的文件名字相同

接下来我们创建我们的控制器类

首先我们要知道我们为什么要去创建这个类
1.由于我们前端控制器对游览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程
因此需要创建不同请求的类，即为请求控制器

创建一个helleController.java

这里我们需要通过添加注解，扫描让程序知道我们这是一个控制组件
组件的类型有：

1.@component 这个是普通组件
2.@controller 这个是控制组件
3.@service 这个是业务层组件
4.@Rrpository这个是持久组件

2.扫描：就是在springMvc.xml中配置扫描组件

  <!--配置扫苗--><context:component-scan base-package="com.xiaoran.mvc.controller"></context:component-scan>

还需要在springMvc.xml中配置一个视图解析器（Thymeleaf）
为什么要去添加Thymeleaf因为：1.因为我们需要解析的内容在WEB-INF下面不能直接去访问所以我们需要去通过Thymeleaf来解析

 <!--配置视图解析器--><bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver"><property name="order" value="1"></property><!--设置优先级为一--><property name="characterEncoding" value="utf-8"></property><!--设置编码格式--><property name="templateEngine"><bean class="org.thymeleaf.spring5.SpringTemplateEngine"><property name="templateResolver"><!--内部Bean--> <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver"><!--视图前缀--><property name="prefix" value="/WEB-INF/templates/"></property><!--视图后缀--><property name="suffix" value=".html"></property><property name="templateMode" value="HTML5"></property><!--设置解析文件的格式--><property name="characterEncoding" value="UTF-8"></property></bean></property></bean></property></bean>

我们配置完成后就可以在WEB-INF下面创建一个文件夹（templates）记住这个文件夹的名字要和我们上面前缀视图中路径名字相同
在templates 中创建一个index.xml我先做一个列子

创建了index.xml我们需要让他在网页中显示a1标签，HelloController.java中调用

@RequestMapping（value=“”）这个的意思就是当我们向游览器发送的是斜线的时候，就会执行我们注解标识的内容

我们这里返回的index其实是试图名字，通过springMvc.xml中我们配置的视图解析器
中的视图前缀后视图后缀拼接成一条完整的路径。我们启动tomcat就可以看到效果
tomcat的配置

点击ok 点击Apply就可以了，tomcat就配置完成了
我们在启动tomcat就可以，注意tomcat的配置到启动可能会出现各种各样的问题，大家可以去百度，通常的一般问题就是tomcat和jdk的版本不匹配，大家仔细检查就可以了嘻嘻，应该问题不大

如果以上都没有问题，那我们就可以在index.html里面写一个跳转![请添加图片描述](https://img-blog.csdnimg.cn/1d3fd5167d854ee0a9ac767cb7a742e3.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg2NDk3Mg==,size_16,color_FFFFFF,t_70
我们先在WEB-INF下面创建一个targe.html，
我们在Hellocontroller.xml中调用

这样我的第一用springMVC写的程序就做完了

二@RequestMapping的注解

注意一个程序中RequestMapping（value）中的value是唯一的，不然会出现二异性

2.RequestMapping注解的位置，可以标识在“类”上也可以标识在”方法“上

RequestMapping有多个属性

value() 通过我们请求的请求地址来匹配
method() 通过我们当前的请求方式来匹配
params() 通过请求参数来匹配请求
headers() 通过请求头信息来匹配请求

RequestMapping注解的value属性

@ RequestMapping 注解的values属性是一个字符串类型的数组，表示该请求映射能构匹配多个请求地址所对应的请求
@RequestMapping注解的vlaue是必须设置的

@RequestMapping(value={"/testRequest","/test"}  //这里面可以写多个value值，指我们在游览器中的跳转只需要满足其中一个就可以执行，我们注解的内容
)

RequestMapping注解的method属性

@RequestMapping注解的method属性通过请求的请求方式（get或者post）匹配请求
@method是一个数组类型也就是说我们也可以在method中写多个匹配方式
##但是我们要注意在通过method匹配的时候我们需要先去匹配value的值当value匹配通过后我们才可以匹配method中的值

@RequestMapping(
value={"/testRequest","/test"},
method={RequestMethod.GET,RequestMethod.post}//这里的RequestMethod是一个枚举类型，里面包含了GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE多种方法
)

RequestMapping 注解中的 params 属性

@params=“这里面写的参数必须同时满足才会跳转到我们指定的页面”

@RequestMapping(
value={"/testRequest"},
params={"username","password"}//这里面可以写多个但是必须同时满足才会跳转
)

@RequestMapping中的params属性（了解就可以）

#通过请求参数来匹配请求
举个小例子：
在controller.java中写

    //params传参@RequestMapping(value = "/testheader",params = {"username"}//params中写的内容我们在 跳转时必须满足里面所有条件才会跳转)public String testheader(){return "sucess";}

在index.html中写

<!--这里面我们把params里面的参数写在小括号中-->
<a th:href="@{/testheader(username)}">测试params属性</a><br>

然后我们在启动tomcat就可以看到界面了点击 “测试params” 我们就会跳转到sucess.html中

headers属性这个不用去过多了解基本不常用

springMVC支持ant风格路径（可以理解为模糊查询）

这些都是用于描写RequestMapping中value的

？表示可以匹配任意字符
* 表示可以匹配0个或多个
** 表示可以匹配一层或多层目录

举一个实例大致用法都差不多，只是意思不同

//在控制类中写
@RequestMapping(
//这的？在value中就表示为——》a后面可以匹配任意字符，但是必须要有如果没有就会报错value="/a?/testant"
)
public String ant(){return "sucess"
}

<!--在index.html中写-->
<a th:href="@{/ar/testant}"></a><!--这里面得到跳转路径后面的r我们可以随便写成什么-->

springMVC中使用占位符（针对于value）

用一个实列来说明一下把

在中写控制器类
@RequestMapping(value="zhangweifu/{id}/{name}")public String zhangweifu(@PathVariable("id")Integer id,PathVariable("name")String name){System.out.print("id:"+id);System.out.println("name:"+name);return "sucess"}

在index.html中写

<!--我们把想要传递的参数放在斜杠后面-->
<a th:href="@{/zhangweifu/1/admin}">测试value对于占位符的使用</a><br>

之后启动tomcat，然后我们在去ij里面看结果

SpringMVC通过servletAPI来获取值（很少很少用）

在控制器中写`

  //servletAPI传递参数@RequestMapping(value = "/servletAPI")public String servletApI(HttpServletRequest request){String name=request.getParameter("name");String six=request.getParameter("six");System.out.println("name:::"+name+"    "+"six:::"+six);return "sucess";}

在index.html中写

<!--我们这里面传递参数就直接写在括号里面就可以了-->
<a th:href="@{/servletAPI(name='小冉',six='男')}">测试对ServletAPI的使用</a><br>

通过控制器方法的形参获取参数的请求（重要）

在控制器中

@RequestMapping(value="/test11")
public String test(String name,String six){System.out.println("name::"+name+"  "+"six::"+six);return "sucess";
}

在index.html中写

<a th:href="@{/test11(name='小冉',six='小飞侠')}">通过控制器方法来传递参数</a><br>

这种写法控制器中的形参（name）必须和html中的实参（name）相同,如果不同是不可用读取到数据的
,所以这里我们就可以了解到另一个注解

@RequestParam注解这个注解里面有几个参数我们可以了解一下
value=“ 这里面我们就写实参的名字” 然后写上类名就可以
required=“true|false” 这里默认是为true意思就是说必须传参，不然就会报错
用这个的时候前提是required=“true” 才可以使用defaultValue=“这里面写是如果不传参数，那么我们也会有一个默认的值输出”

我们就用上面的列子来简单的运用一下把
我们只需要修改一下控制器就可以了

@RequestMapping(value="/test11")
public String test(@RequestParam(value="name")String xingming,String six){System.out.println("name::"+xingming+"  "+"six::"+six);return "sucess";
}

通过servletAPI向request中共享数据

在控制类中写

    @RequestMapping("/testRequest")public String test(HttpServletRequest request){request.setAttribute("xiaoran","帅哥");return "success";}

在indedx.html中写

<a th:href="@{/testRequest}">通过servletAPI向request域对象共享数据</a>

我们通过 setAttribut()传递值，我们在success.html页面中只需要通过键来获取到值
但是这里要注意的是我们在success.html的写法

<p th:text="${xiaoran}"></p><!--这里面的这种写法是thymeleaf在网页中通过键获取到值-->

接下来我们只需要启动tomcat就可以了

使用ModelandView向request对象共享数据

ModelandView通过名字我们就可以分成两buf

Model：主要用于请求域共享数据
view：主要用于设置视图,实现页面跳转

 @RequestMapping("/ModelandView")//大家注意我们这里的返回值类型是ModelandView类型public ModelandView modelandview(){ModelandView mav=new ModelandView();mav.addObject("xiaoran","modelandView");//处理模型数据，向request共享数据mav.setViewName("success");//发送视图名字（以前我们都是通过return 返回视图名字而这里不同）return mav;
}

在index.html中写

<a th:href="@{/ModelandView}">同过Modelandview来向request对象共享数据</a>

在success.html中写

<p th:text="${xiaoran}"></p>

之后启动tomcat

使用Model向request对象共享数据

在控制器中写
我们这里只需要关注的就是不同的方法这么传递值

@RequestMapping("/model")
public String model(Model model){model.addAttribute("xiaoran","model");
return "success";
}

在index.html中写

<a th:href="@{/model}">同过Model来向request对象共享数据</a>

在success.html中写

<p th:text="${xiaoran}"></p>

使用Map向request对象共享数据

在控制类中写

 @RequestMapping("/map")public String  map(Map<String,Object> map){map.put("xiaoran","map");return "success";}

在index.html

<a th:href="@{/map}">通过map来向request对象共享数据</a>

在success.html中写

<p th:text="${xiaoran}"></p>

使用ModelMap向request对象共享数据

在控制类中写

@Request("/modelmap")
public String modelMap(ModelMap modelMap){modelMap.addAttribute("xiaoran","modelMap");
return "success";
}

在index.html中写

<a th:href="@{/modelMap}">同过Model来向request对象共享数据</a>

在success.html中写

<p th:text="${xiaoran}"></p>

向session域中共享数据

在控制器中写

@RequestMapping("/testSession")
public Strign test(HttpSession ss){ss.setAttribute("testsessionScope","hello,session")\return "success";
}

在html中访问我我们的键值对，用session.键

<p th:text="${session.testsessionScope}"></p>

向Application域中共享数据

在控制器中写

@Request("test")
public String test1(HttpSession tt){ServletContext applicat=tt.getServletContext();applicat.setAttribute("xiao","application")return "success"
}

在html中获取到我们的值，通过application.键

<p th:href="${application.xiao}"></p>

SpringMVC的视图

转发视图

我们确定转发视图的方式是看，视图名称前面是否有 forward:
转发视图是共享视图，共用同一个request
转发请求的时候地址栏不会改变
转发请求是一次请求

在控制器中写

@RequestMapping("/xiao")
public String test(){return "success";
}@RequestMapping("/test")
public String test1(){//这里的意思就是当我们地址输入”/test“的时候我们通过返回的forward:/xiao进行转发到上面那个方法里面去return "forward:/xiao"
}

重定向

发送2次请求
我们确定是重定向请求的方法就是，判断视图名称的开头是不是 redirect
重定向请求不会共享资源，不是同一个request
重定向请求时的地址栏不会改变
重定向是不可用直接去访问WEB-INF下面的内容

在控制器中

@RequestMapping("/test1")
public String test(){return "redirect:/xx"
}

视图控制器

视图控制器是仅实现页面跳转，即只需要设置视图名称时
视图控制器的配置
1.在springMVC.xml中配置视图控制器

 <!--配置视图控制器--><!--path：设置处理的请求地址 ，也就是以前我们控制器中@RequestMapping中写的内容view-naem:设置请求地址所对应的视图名称，也就是我们控制器中return里面写的视图名称
-->  <mvc:view-controller path="/" view-name="index"></mvc:view-controller>

当我们写了这个就可以代替我们以前写的

@RequestMapping("/")
public String test(){return "index";
}

但是我们写了这个以后就有一个问题我们以前在index.html中的链接都用不了了
这个时候我们还需要在springMVC.xml中配置一个开启MVC的注解驱动

 <!--开启MVC注解的功能--><mvc:annotation-driven></mvc:annotation-driven>

现在在访问index.html中的链接就可以使用了

我们重新按照上面的步骤创建一个新的工程

我们简单的介绍一下一下在jsp中的转发发送数据的方式

我们在SpringMVC.xml中不需要配置以前的视图解析器，直接配置jsp的视图解析器

 <!--配置JSP的视图解析器--><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/templates/"></property><property name="suffix" value=".jsp"></property></bean>

我们创建一个index.jsp，在webapp下面

在templates下面创建一个success.jsp

我们在控制器中写

@RequestMapping("/success")
public String jsp(){return "success"
}

我们在index.html写跳转到success.jsp的超链接
我们在html中跳转页面时要用到EL表达式${pageContext.request.contextPath}

<a href="${pageContext.request.contextPath}/success">访问success</a>

RestFul表现层状态转移

get 获取资源
post 新建资源
put 更新资源
DELETE 删除资源

在我们的请求中我们是可以直接去使用get或者post请求的，而我们去使用put或者delete的时候会被转换为get请求

我们来测试一下
1.查询所有用户
在控制类中写

 @RequestMapping(value = "/user",method = RequestMethod.GET)public String test1(){System.out.println("查询所有用户信息");return "success";}

在html中写

<a th:href="@{/user}">查询所有的用户信息</a>

这个是可以访问的
2.根据ID查询用户信息
在控制类中写、

 @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)public String test2(@PathVariable("id")Integer id){System.out.println("根据ID查询用户信息"+id);return "success";}

在html中写

<a th:href="@{/user/1}">根据D查询用户信息</a>

3.我们测试一下post请求，注意post请求只能在表单提交时使用
在控制类中写

@RequestMapping(value = "/user",method = RequestMethod.POST)public String test3(String username,String password){System.out.println("添加所有用户信息"+username+password);return "success";}

在html中写

<form th:action="@{/user}"method="post">用户名：<input type="text" name="username">密码：<input type="password"name="password" ><input type="submit">
</form>

4。测试PUT请求
如果我们要使用put或者DELETE我就必须在web.xml中配置一个用于使用put和DELETE请求的过滤器
******记住记住，这个过滤器一定一定要写在我们配置编码过滤器的后面不然我们以前设置的编码格式就会失效

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

接下来我们就开始测试吧，
在控制类中写

 @RequestMapping(value = "/user",method = RequestMethod.PUT)public String test4(String username,String password){System.out.println("修改所有用户信息"+username+password);return "success";}

在html中写
我们还需要在传递时告诉程序这是PUT请求
所以我们加了一个input 我把type=“hidden“设置为看不见 name=”_method"这里的name必须必须必须为_method 不可以修改，value=”“这里面写我们的请求方式

<form th:action="@{/user}"method="post"><input type="hidden" name="_method" value="PUT">用户名：<input type="text" name="username">密码：<input type="password"name="password" ><input type="submit">
</form>

执行就可以了
DELETE也和PUT差不多就介绍了

接下来我们就来实际操作一下这个几个请求吧
安装以前的方法创建一个新的工程
当一切都配置好了之后我们就开始操作吧

创建一个bean文件夹在下面创建一个Employee.java 这里面的属性对应于mysql数据库中的属性所以可不要写错了
在Employee.java中写


public class Employee {private int id;private String lastName;private  String email;private  int gender;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getLastName() {return lastName;}public void setLastName(String lastName) {this.lastName = lastName;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public Employee(int id, String lastName, String email, int gender) {this.id = id;this.lastName = lastName;this.email = email;this.gender = gender;}public Employee(){}
}

在创建一个dao文件夹，在dao文件夹下面创建一个EmployeeDao.java用来实现我们对数据库的增删改查方法，
在EmployeeDao.java中写，这里我们用到了一个注解@Repository 持久层组件，

@Repository
public class EmployeeDao {private  static Map<Integer,Employee> employees=null;static{employees =new HashMap<Integer, Employee>();employees.put(1001,new Employee(1001,"E-AA","aa@163",1));employees.put(1002,new Employee(1002,"E-BB","aa@163",1));employees.put(1003,new Employee(1003,"E-CC","aa@163",0));employees.put(1004,new Employee(1004,"E-DD","aa@163",0));employees.put(1005,new Employee(1005,"E-EE","aa@163",1));}private  static  Integer initId=1006;//添加public void save(Employee employee){if(employee.getId()==0){employee.setId(initId++);}employees.put(employee.getId(),employee);}//获取所有结果public Collection<Employee> getAll(){return employees.values();}//根据ID获取结果public Employee get(int id){return employees.get(id);}//根据ID删除结果public void  delete(Integer id){employees.remove(id);}
}

细心的同学就会说为什么我们写的这个@Repository注解会报错，我又没有写错，其实这个原因是因为我们以前在springMVC.xml中写的配置扫描的base-package=”“这里面我们是指定了扫描组件的范围的
这里我们又两种
方法一就是我们扩大范围就可以了

    <context:component-scan base-package="com.xaioran.MVC"></context:component-scan>

二就是我们在添加一个路径

    <context:component-scan base-package="com.xaioran.MVC.controller,com.xaioran.MVC.dao"></context:component-scan>

我们还需要去创建一个控制类，叫testController.java在这里面写

import com.xaioran.MVC.bean.Employee;
import com.xaioran.MVC.dao.EmployeeDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;import java.util.Collection;@Controller
public class TestController {@Autowired//我们在这里面自动装配一个EmployeeDao这样可以方便我们后面直接去调用EmployeeDao中的接口private EmployeeDao employeeDao;}

写到这里我的所有准备工作就写完了
我们写一个index.html来测试一下吧

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>首页</title>
</head>
<body>
<h1>首页</h1>
</body>
</html>

我们需要访问到页面首页我们启动tomcat后没有反应，这是为什么，因为我们在控制器中没有配置去访问index.html的路径呀,但是这里我们不需要那么麻烦去控制器类中配置，我们直接去配置一个视图控制器就可以了

  <!--配置视图控制器--><mvc:view-controller path="/" view-name="index"></mvc:view-controller><!--配置加载注解驱动--><mvc:annotation-driven></mvc:annotation-driven>

测试结束
接下来我需要查询所有员工的信息
在index中写

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/Employee}">查询所有</a>
</body>
</html>

在Testcontroller.java中写

package com.xaioran.MVC.controller;import com.xaioran.MVC.bean.Employee;
import com.xaioran.MVC.dao.EmployeeDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;import java.util.Collection;@Controller
public class TestController {@Autowiredprivate EmployeeDao employeeDao;@RequestMapping(value = "/Employee",method = RequestMethod.GET)public String test(Model model){Collection<Employee> employees= employeeDao.getAll();model.addAttribute("employeeList",employees);return  "success";}
}

这里我需要重新创建一个新的success.html
在里面写

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<h1>成功</h1>
<table border="1" cellspaceing="0" cellpadding="0" style="text-align: center;"><tr><th>Eemployee Info</th></tr><tr><th> id</th><th>lastName</th><th>email</th><th>gender</th><th>options</th></tr><tr th:each="employee:${employeeList}"><!--这里我们是通过Testcontroller里面的getall()方法来，来获取到所有值，然后我们通过Model来把所有的值存入到（employeeList）键中，然后我们通过这个键取出对应的值--><td th:text="${employee.id}"></td><td th:text="${employee.lastName}"></td><td th:text="${employee.email}"></td><td th:text="${employee.gender}"></td><td><a th:href="@{'/delete/'+${employee.id}}">delete</a><a href="">update</a></td></tr>
</table>
</body>
</html>

然后测试在网页中会出现

接下来我们就可以写我们就要写我们的删除页面

我们在success.html页面中写了一个delete的超链接，删除的条件是根据ID删除所以我们要加上一个ID

在这里就要用到我们上面的，我们知道删除时用的请求时DELETE请求，但是程序无法识别DELETE
所以我要用一个表单来传递我们的请求，这里面我们不用写action=“”

<form id="deleteFrom" method="post"><input type="hidden" name="_method" value="DELETE">
</form>

我们给success页面中的删除超链接设置一个点击事件@click=“”
<a @Click="deleteEmployee" th:href="@{'/delete/'+${employee.id}}">delete</a>

我们在html中使用触发事件时是无法解析的，所以我们要引入一个插件vue.js

<script type="text/javascript" th:src="@{static/js/vue.js}"></script><!--引入vue.js 包-->
<script type="text/javascript">var vue=new Vue({el:"#dataTable",//我们使用vue的容器，就是我们使用vue.js的范围methods:{deleteEmployee:function (event) {//根据ID获取表单元素var deleteFrom=document.getElementById("deleteFrom")//将触发点击事件的超链接赋值给我们提交表单的actiondeleteFrom.action=event.target.href//提交表单deleteFrom.submit()//取消超链接的默认行为event.preventDefault()}}})
</script>

这样我们在success.html中的写完了，
在我们的控制器类中写

 //获取我们的 列表@RequestMapping(value = "/Employee",method = RequestMethod.GET)public String test(Model model){Collection<Employee> employees= employeeDao.getAll();model.addAttribute("employeeList",employees);return  "success";}//删除@RequestMapping(value = "/delete/{id}",method = RequestMethod.DELETE)public String test(@PathVariable("id")Integer id){employeeDao.delete(id);//这里我们的使用重定向：/Employee， 是为了我们每一次删除除之后，重新加载一下页面return "redirect:/Employee";}

接下来万事俱备，我们就来启动Tomcat吧。启动之后是肯定会报错的，，，
因为我们需要重新打包一下程序
然后我们还需要在springMVC里面配置对静态资源的访问`

 <!--配置对静态资源的访问--><mvc:default-servlet-handler></mvc:default-servlet-handler>`

删除就完成了。

添加：
1.给success页面中的options添加一个超链接

   <th>options(<a th:href="@{/toadd}">add</a>)</th>

2.创建一个add.html页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>添加</title>
</head>
<body>
<form action="/employeee" method="post">lastName: <input type="text" name="lastName">email:<input type="text" name="email">gender:<input type="radio" name="gender" value="0">男<input type="radio" name="gender" value="1">女<input type="submit" value="add">
</form>
</body>
</html>

3.我们直接配置一个视图控制器跳转到add.html，就不需要去控制器中写了

 <mvc:view-controller path="/toadd" view-name="add"></mvc:view-controller>

在控制器中写

  @RequestMapping(value = "/employeee",method = RequestMethod.POST)public String test(Employee employee){employeeDao.save(employee);return "redirect:/Employee";}

下一个：修改
1.在success中设置的update设置一个超链接

 <a th:href="@{'/update/'+${employee.id}}">update</a>

2.我们在控制器类中写，当我们从success.html中点击超链接传递过来一个ID,Test1.java类接到ID
因为我们要在add.html中写一个回显所以我们需要把查询到的每一个结果存入到我们的Model容器中

@RequestMapping(value = "/update/{id}",method =RequestMethod.GET)public String test1(@PathVariable("id") Integer id,Model model){Employee employee=employeeDao.get(id);model.addAttribute("user",employee);return "update";}

3.创建一个updata.html页面，页面中我们要用到一个回显，因为我们是修改，我们需要知道我们以前写的是什么所以需要一个回显，我们通过键来访问

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>修改</title>
</head>
<body>
<form action="/update" method="post"><input type="hidden" name="_method" value="PUT"><input type="hidden" name="id"  th:value="${user.id}">lastName: <input type="text" name="lastName"th:value="${user.lastName}">email:<input type="text" name="email"th:value="${user.email}">gender:<input type="radio" name="gender" value="0" th:field="${user.gender}">男<input type="radio" name="gender" value="1"th:field="${user.gender}">女<input type="submit" value="update">
</form>
</body>
</html>

我们看一下现在运行的结果：

3.我们最后只需要把add.html中进行修改然后在用action=“”链接出去，用一个控制器类来重新添加进去

 @RequestMapping(value = "/update" ,method = RequestMethod.PUT)public String test2(Employee employee){employeeDao.save(employee);return "redirect:/Employee";}

然后我们在测试一下发现没有问题，我们的增删改查就完成了

HttpMessageConverter

我们先了解几个属性和注解吧：

@RequestBody 将请求报文转换为java对象
@ResponseBody 将java对象转换为响应报文
RequestEntity 请求实体
ResponseEntity 响应实体

我们先来介绍第一个把
@RequestBody 可以获取请求体
我们测试一下
在index.html中写，记住请求体的获取一定是通过post而不是get请求

<form th:action="@{/requestbody}" method="post"><input type="text" name="username" ><input type="password" name="password" ><input type="submit">
</form>

在控制器中写

 @RequestMapping(value = "/requestbody")public String test(@RequestBody String requestbody){System.out.println("requestBody:"+requestbody);return "success";}

最后的结果是：

2.测试RequestEntity ，这个属性是封装请求报文的一种类型，封装的是整个请求信息
我们在index.html中写

<form th:action="@{/requestEntity}" method="post"><input type="text" name="username" ><input type="password" name="password" ><input type="submit" value="测试requestEntity">
</form>
<br>

我们在控制器中写

  @RequestMapping(value = "/requestEntity")public String requestEntity(RequestEntity<String>  entity){System.out.println("请求头："+entity.getHeaders());System.out.println("请求体:"+entity.getBody());return "success";}

测试结果：

3.@ResponseBody
以前我们没有学习这个注解的时候我们是通过向游览器传递值的方法
我们先写一下以前的方法
在index页面中写


<a th:href="@{/response}">测试response以前向游览器传递值的方法</a><br>

在控制值类中写

//这是以前我们， 向游览器中传递值的方法@RequestMapping(value = "/response")public void test(HttpServletResponse response) throws IOException {response.getWriter().print("hell, word");}

最后我们在游览器中的结果为

4.而我们用注解@ResponseBody传递参数是同return=“”返回参数
在index页面中写

<a th:href="@{/testresponse}">测试注解@Response以前向游览器传递值的方法</a>

在控制器中写，
在这里面我们return返回的值，不是返回的页面，而是我们向游览器传递的值

  @RequestMapping(value = "/testresponse")@ResponseBodypublic String test1(HttpServletResponse response)  {return "6666";}

结果显示

@ResponseBody处理json

我们用 @ResponseBody向游览器传输一个jsoon

我们需要在pom.xml中配置一个Jackson对象

 <!--添加jackson--><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.12.1</version></dependency>

还需要在springMVC.xml中配置一个加载驱动

 <mvc:annotation-driven></mvc:annotation-driven>

2.我们还需要创建一个User类

package com.xaioran.MVC.bean;public class User {private  int id;private String admin;private  String password;private  int age;private  String sex;public User(int id, String admin, String password, int age, String sex) {this.id = id;this.admin = admin;this.password = password;this.age = age;this.sex = sex;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getAdmin() {return admin;}public void setAdmin(String admin) {this.admin = admin;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public User(){}}

3.在index.htm中写

<a th:href="@{/responseBodyUser}">测试注解@Response以前向游览器传递对象的方法</a>

4.在控制器中写

@RequestMapping("/responseBodyUser")@ResponseBodypublic  User test(){return new User(1001,"admin","12345",12,"男");}

启动tomcat结果为

SpringMVC处理ajax

1.ajax是什么？
ajax是一种用于创建快速动态网页的技术
2.ajax怎么使用？
ajax是不会影响服务器的跳转，正因为如此我们不能使用转发和重定向访问
ajax是可以在不发生跳转的情况下于页面交互

3.ajax使用需要引入axios.min.js

我们就实际测试一下

1.首先我们在index.html中写，我们的ajax是在不发生跳转的情况下与页面交互
我们不能直接写超链接，需要要把超链接写到div标签中，我们在超链接中写了一个点击事件，所以我们需要引入2个包，一个处理ajax一个处理点击事件
ajax包的链接
链接：https://pan.baidu.com/s/1uCcw85kLIu0aVczX0uzQ3Q
提取码：12s2
vue.js的包
链接：https://pan.baidu.com/s/1GHXRM8zqNBK82N-3d6z8yQ
提取码：1345


<div id="app"><a @click="testAxios" th:href="@{/testAxios}">测试axios</a>
</div>

我们把引入的这个两个包放在

我们引入这两个包之后就可以处理js事件了，继续在index.html中写

<!--引入axios包和vue包--->
<script type="text/javascript" th:src="@{/static/axios.min.js}"></script>
<script type="text/javascript" th:src="@{/static/vue.js}"></script><script type="text/javascript">new Vue({el:"#app",methods:{testAxios:function (event) {//写axios的内容axios({method:"post",//我们超链接的请求方式url:event.target.href,//我们超链接所使用的href//传输到服务器的数据params:{username:"admin",password:"123456"}//axios处理成功之后，执行的函数}).then(function (response) {alert(response.data);//表示我们响应的数据});event.preventDefault();<!--取消超链接的默认行为-->}}})
</script>

写完了之后我们还需要取springMVC中去配置静态资源使用

 <!--配置对静态资源的访问--><mvc:default-servlet-handler></mvc:default-servlet-handler>

在控制器中写

    @RequestMapping("/testAxios")@ResponseBodypublic String test1(String username, String password){System.out.println(username+","+password);return "hello ,axios";}

这里面return的内容就是我们会在屏幕上弹出来

而我们的界面并没有刷新

@Restcontroller注解非常重要

这个注解就相当于结合了@controller注解和@ResponseBody注解

ResponseEntity

1。用于控制器方法返回值类型，该控制器方法的返回值就是响应到游览器的响应报文

可以用来做文件的下载

我们创建一个file.html页面

<a th:href="@{/testfile}">下载文件</a>

我们在img包里面存放一张图片，用来模拟重网上下载下来

在控制器中写

@RequestMapping("/testfile")public ResponseEntity<byte[]> test(HttpSession session) throws IOException {//获取 servletContext对象(全局共享数据对象)ServletContext servletContext=session.getServletContext();//获取服务器的部署路径String realpath=servletContext.getRealPath("/static/img/1.jpg");//创建输入流InputStream is=new FileInputStream(realpath);//创建字节数组///available()这个函数的意思就是输出所对应的所有字节数长度，byte[] bytes=new byte[is.available()];//将流读到字节数组中is.read(bytes);//创建HttpHeader对象设置响应头信息MultiValueMap<String ,String> headers=new HttpHeaders();//设置要下载的方式以及下载文件的名字，记住记住这里面只有1.jpg可以修改剩下的都是默认的headers.add("Content-Disposition","attachment;filename=1.jpg");//设置响应状态码，响应码ok就是200,,404就是not fountHttpStatus statucode=HttpStatus.OK;//创建ResponseEntity对象ResponseEntity<byte[]> responseEntity=new ResponseEntity<byte[]>(bytes,headers,statucode);//关闭输入流is.close();return responseEntity;}

启动tomcat就可以下载这个图片了

文件上传

1，文件的上传比文件的下载操作难度要高一些
2.文件的下载我们需要考虑的是文件下载是以二进制的方式下载
3.文件下载是可能出现重名的情况，如果我们不处理的话，它默认是直接覆盖的呀
4.上传文件我们是不可用get请求的呀，怎么可能可以把图片写在地址栏中呢对吧，所以只可以用post请求
5.我们在传递的时候需要改变传递方式，enctype="multipart/form-data"以二进制的方式传输

我们file页面中写

<form th:action="@{/testup}" method="post" enctype="multipart/form-data">头像：<input type="file" name="photo"><br><input type="submit" value="上传">
</form>

我们在控制器中写

我们上传的文件不能直接保存为MultipartFile 类
我们需要以一个传递解析器，所以我们在spring MVC中配置

<!--配置文件上传解析器，转换为MultpartFile--><bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

//在控制器中写//文件上传@RequestMapping(value = "/testup")public String test2(MultipartFile photo,HttpSession session) throws IOException {String  fileName=photo.getOriginalFilename();//获取到我们上传的文件名字//获取上传文件的后缀名字String suffixName=fileName.substring(fileName.lastIndexOf("."));//将UUID作为我们的文件名字,不知到的无所谓就是获取随机数String uuid=UUID.randomUUID().toString();//将UUID和后缀名字拼接，拼接成名字，这样我们每一次的名字都不同，这样就解决了重命名的问题fileName=uuid+suffixName;ServletContext servletContext=session.getServletContext();//获取servletContext对象String photopath= servletContext.getRealPath("photo");//通过servletContext获取服务器中photo目录路径File file=new File(photopath);//这个文件就是代表photopath这个路径//判断photopath路径是否存在if(!file.exists()){//若不存在创建一个file.mkdir();}//File.separator就是分隔符（斜线）String finalpath=photopath+File.separator+fileName;photo.transferTo(new File(finalpath));//transferTo（）就是上传的意思 return "success";}

文件的上传就完成了

拦截器的配置

拦截器一共有三个方法
1.preHandle 在控制器方法之气执行
2.postHandle 控制器方法之后执行
3.aftercompletion 在控制器视图之后执行

我们来了解一下这些方法吧：
我们新创建一个FirstInterceptors.java类
1.我们把这个类通过注解标识为@Componemt 普通组件
2.我们通过ctrl+o重写方法
3.当我们写了之后我们就需要在springMVC中配置拦截器

在控制器中写

package com.xaioran.MVC.interceptors;import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
public class FirstInterceptors implements HandlerInterceptor {public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("FirstInterceptor--->>preHander");//我们每一个方法我们都返回相对应的值这样方便我们知道是是谁执行；return true;//这里面我们要特别注意：这里返回的false表示拦截，true表示放行}public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("FirstInterceptor--->>postHandle");}public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("FirstInterceptor--->>afterCompletion");}
}

接下来我们就要配置我们的springMVC
第一种配置拦截器

<!--配置拦截器-->
<!--我们这样配置拦截器，所有的控制器都会被我们拦截到--><mvc:interceptors><!--class="这里面写的就是我们拦截器的方法"--><bean class="com.xaioran.MVC.interceptors.FirstInterceptors"></bean></mvc:interceptors>

第二种配置拦截器

<!--我们种配置拦截器和第一种差不多都是会拦截所有控制器--><mvc:interceptors><!--bean="这里面写的就是我们拦截器名字（名字的开头要小写）"--><ref bean="firstInterceptors"></ref></mvc:interceptors>

第三种配置拦截器吗，这种配置拦截器也是我们最常用的，这种可以配置我们拦截的条件

<!--配置拦截器--><mvc:interceptors><mvc:interceptor><mvc:mapping path="/*"/> <!--这个是设置拦截的路径--><mvc:exclude-mapping path="/"></mvc:exclude-mapping><!--这个是设置不拦截这个路径--><ref bean="firstInterceptors"></ref><!--这个是设置指定我们的拦截器--></mvc:interceptor></mvc:interceptors>

之后我们启动就可以在我们的IDEA里面看到输出的函数

那么我们的单个拦截器的执行顺序很简单，我们一看就知道，如果有多个拦截器呢
在多个拦截器的情况，我们的执行顺序是

prehandle 的执行顺序是按照我们在springMVC中拦截器配置的先后顺序执行
posthandle 的执行顺序是按照我们在springMVC中拦截器配置的倒叙执行的
afterCompletion的执行顺序是按照我们在springMVC中拦截器配置的倒叙执行的

还有一种情况是：
当我们设置了多个拦截器，其中有一个拦截器设置为false，那么我们的执行顺序是什么呢？？
1.返回false的拦截器和他之前的都会执行preHandle
2.postHandle都不会执行
3.返回false的拦截器前的拦截器都会执行afterCompletion

异常处理

1。学习异常处理我们最要的就是学会去自定义异常错误提示
2.学习异常处理也可以帮助我们读程序，方便我们知道自己哪里有错
异常处理的第一种办法，在springMVC中配置异常处理

<!--配置异常处理--><bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"><!--name中写 的是异常映射，exceptionMappings是properties类型，是键值对结构--><property name="exceptionMappings"><props><!--key=“要出现的异常”-，error写的是我们的视图名字--><!--下面这句话的意思就是出现ArithmeticException，中的错误我们就 跳转到error这个界面--><prop key="java.lang.ArithmeticException">error</prop></props></property><!--我们上面写的意思只是发现错误，然后跳转到error页面但是我们并不输出错误在哪--><!--设置将异常共享到请求域中的键，这样我们就可以在error页面中通过键来访问到我们的值，以value=“”为键，异常为值--><property name="exceptionAttribute" value="ex"></property></bean>

创建我们显示异常的界面，名字为error.html在这里面写

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>错误</title>
</head>
<body>
<h1>提示错误</h1>
<p th:text="${ex}"></p>
</body>
</html>

我们随便写在一个控制器类中写一个错误我们来测试一下

  @RequestMapping("/testException")public String test1(){System.out.println(1/0);return "success";}

我们还需要在index.html中写一个超链接来跳转

<a th:href="@{/testException}">异常处理</a>

之后运行tomcat看一下结果

下面我们介绍，另一注解配置异常处理，我们先把SpringMVC里面的异常处理去除掉
我们新创建一个：testException.java

package com.xaioran.MVC.conterllor;import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;@ControllerAdvice//标识实现全局异常处理
public class TestException {//下面这个注解的意思就是我们把可能出现的错误写在value里面，{}里面可以写多个@ExceptionHandler(value = {ArithmeticException.class})//exception就是我们的错误信息，我要想在界面上输出，我们可以通过API，Model，ModelView等多种方法这里我们选择的Modelpublic String test(Exception exception, Model model){model.addAttribute("ex",exception);//以ex为键，我们的异常信息为值return "error";}
}

我们的控制器和index,和error中都不需要改变，因为我们这里键的名字没有改变
我们在次执行Tomcat发现我们执行的结果是相同的

通过注解配置SpringMVC

1.创建初始化类用来代替我们之前写的web.xml
2.我们想要用一个类来代替我们的web.xml，创建类需要继承AbstractAnnotationConfigDispatcherServletInitializer
3.我们创建一个web.java

package com.xiaoran.MVC.config;import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;import javax.servlet.Filter;//这个是用来代替web.xml的，，， web工程的初始化类
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {//getRootConfigClasses()获取我们的根配置，指定spring的配置类protected Class<?>[] getRootConfigClasses() {//我们对应的要去创建这个类SpringConfig.javareturn new Class[]{SpringConfig.class};}//设置springMVC的配置类protected Class<?>[] getServletConfigClasses() {//我们对应的要去创建这个类SpringMVC.javareturn new Class[]{SpringMVC.class};}//这个就是我们一起web.xml中配置的 servlet//指定DispartcharsServlet的映射规则，即url-patternprotected String[] getServletMappings() {return new String[]{"/"};}/*还需要在重写过滤器,跟Filter相关的就可以*  还有一个是配置编码过滤器*一个是配置处理请求方式put和delete的HiddenHttpMethodFile*/@Overrideprotected Filter[] getServletFilters() {CharacterEncodingFilter characterEncodingFilter=new CharacterEncodingFilter();characterEncodingFilter.setEncoding("UTF-8");characterEncodingFilter.setForceResponseEncoding(true);HiddenHttpMethodFilter hiddenHttpMethodFilter=new HiddenHttpMethodFilter();return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};}
}

web.xml变成web.java我们就配置好了

接下来我们要配置SpringMVC.jav

首先我们要知道SpringMVC以前处理的内容有哪些
1.扫描组件
2.视图解析器
3.view-controller
4.default-serverlet
5.mvc注解驱动
6.文件上传解析器
7.异常处理
8.拦截器

package com.xiaoran.MVC.config;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.ServletContextResource;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.thymeleaf.processor.templateboundaries.ITemplateBoundariesProcessor;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;//代替springMVC配置文件：
//1.扫描组件  2.视图解析器 3.view-controller  4.default-serverlet  5.mvc注解驱动  6.文件上传解析器
//7.异常处理  8.拦截器@Configuration//将当前类标识为一个配置类
@ComponentScan("com.xiaoran.MVC")//扫描组件路径，用来识别我们标识的注解
@EnableWebMvc //mvc注解驱动
public class SpringMVC {//下面的3个Bean其实就是在配置我们的Thmrleaf解析器//我们以前springMVC中的Thmrleafbean是从里面开始向外面读所以这里面也是相同的由内向外写//配置生成模板解析器@Beanpublic ITemplateResolver templateResolver(){WebApplicationContext webApplicationContext=ContextLoader.getCurrentWebApplicationContext();ServletContextTemplateResolver templateResolver=new ServletContextTemplateResolver(webApplicationContext.getServletContext());templateResolver.setPrefix("/WEB-INF/templates/");templateResolver.setSuffix(".html");templateResolver.setCharacterEncoding("UTF-8");templateResolver.setTemplateMode(TemplateMode.HTML);return templateResolver;}//生成模板引擎为模板引擎注入模板解析器@Beanpublic SpringTemplateEngine templateEngine(ITemplateResolver templateResolver){SpringTemplateEngine templateEngine=new SpringTemplateEngine();templateEngine.setTemplateResolver(templateResolver);return templateEngine;}//生成视图解析器并为解析器注入模板引擎@Beanpublic ViewResolver viewResolver(SpringTemplateEngine templateEngine){ThymeleafViewResolver viewResolver=new ThymeleafViewResolver();viewResolver.setCharacterEncoding("UTF-8");viewResolver.setTemplateEngine(templateEngine);return viewResolver;}}

接下来我们就写一个简单的测试：
在webapp下面创建，就不需要写web.xml

在index中写

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<h1>首页</h1>
</body>
</html>

在控制器中写

package com.xiaoran.MVC.controller;import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;@Controller
public class TestController {@RequestMapping("/")public String test(){return "index";}
}

之后我们启动tomcat就可以看到结果

我们继续完善springMVC中的内容

package com.xiaoran.MVC.config;import com.xiaoran.MVC.Interceptors.TestInterceptors;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.ServletContextResource;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.processor.templateboundaries.ITemplateBoundariesProcessor;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;import java.util.List;
import java.util.Properties;//代替springMVC配置文件：
//1.扫描组件  2.视图解析器 3.view-controller  4.default-serverlet  5.mvc注解驱动  6.文件上传解析器
//7.异常处理  8.拦截器@Configuration//将当前类标识为一个配置类
@ComponentScan("com.xiaoran.MVC")//扫描组件
@EnableWebMvc //mvc注解驱动
public class SpringMVC  implements WebMvcConfigurer {// 4.default-serverletpublic void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {configurer.enable();}//8.拦截器public void addInterceptors(InterceptorRegistry registry) {TestInterceptors interceptors=new TestInterceptors();registry.addInterceptor(interceptors).addPathPatterns("/");}//4.view-controllerpublic void addViewControllers(ViewControllerRegistry registry) {registry.addViewController("/hello").setViewName("hello");}//6.文件上传解析器@Beanpublic MultipartResolver multipartResolver(){CommonsMultipartResolver commonsMultipartResolver=new CommonsMultipartResolver();return commonsMultipartResolver;}//7.异常处理public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {SimpleMappingExceptionResolver ExceptionResolver=new SimpleMappingExceptionResolver();Properties prop=new Properties();prop.setProperty("java.lang.ArithmeticException","error");ExceptionResolver.setExceptionMappings(prop);ExceptionResolver.setExceptionAttribute("exption");resolvers.add(ExceptionResolver);}//2.视图解析器//配置生成模板解析器@Beanpublic ITemplateResolver templateResolver(){WebApplicationContext webApplicationContext=ContextLoader.getCurrentWebApplicationContext();ServletContextTemplateResolver templateResolver=new ServletContextTemplateResolver(webApplicationContext.getServletContext());templateResolver.setPrefix("/WEB-INF/templates/");templateResolver.setSuffix(".html");templateResolver.setCharacterEncoding("UTF-8");templateResolver.setTemplateMode(TemplateMode.HTML);return templateResolver;}//生成模板引擎为模板引擎注入模板解析器@Beanpublic SpringTemplateEngine templateEngine(ITemplateResolver templateResolver){SpringTemplateEngine templateEngine=new SpringTemplateEngine();templateEngine.setTemplateResolver(templateResolver);return templateEngine;}//生成视图解析器并为解析器注入模板引擎@Beanpublic ViewResolver viewResolver(SpringTemplateEngine templateEngine){ThymeleafViewResolver viewResolver=new ThymeleafViewResolver();viewResolver.setCharacterEncoding("UTF-8");viewResolver.setTemplateEngine(templateEngine);return viewResolver;}}

这样我们就把springMVC中内容补充完全了。