1.3.springmvc

springmvc

1.springmvc有什么用

springmvc对原生的servlet进行封装，解决了servlet开发中各种繁琐问题（比如：一个serlvet业务处理单一性。繁琐的getParameter。异步返回json数据。文件上传）,提高了开发效率。

2.入门springmvc

目标：前端发起请求，进入服务端的处理且方法，然后调用service层对象，返回视图

• 1.创建web工程
• 2.添加依赖jar包（spring的核心包，spring-aop.jar;spring-web.jar，spring-mvc.jar）
• 3.创建springmvc.xml

开启ioc与di注解的识别：
<context:component-scan base-package="com.javasm"></context:component-scan>
开启springmvc注解的识别：
<mvc:annotation-driven></mvc:annotation-driven>
配置jsp视图解析器对象：
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/page/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

• 4.在web.xml中配置springmvc的前端控制器

<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
</servlet>
    
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

• 5.写控制层组件

@Controller
@RequestMapping("user")
public class SysuserHandler {

    @RequestMapping("hellomvc")
    public String hello(){
        System.out.println("进入hello");
        return "hello";//返回的是视图名，通过视图解析器对象得到完成视图路径，进行请求转发
    }
}

• 到这里可以先将上述步骤完成并测试前端请求查看是否能响应，如不能则查找问题解决后在继续。

3.springmvc的处理流程（核心对象）

DispatcherServlet:前端控制器，中央处理器

RequestMappingHandlerMapping：处理器映射器

RequestMappingHandlerAdapter：处理器适配器

InternalResourceViewResolver：视图解析器

同步开发中完整处理流程：

• 1.在启动tomcat时，进行ioc和di实现，同时处理器映射器解析bean对象上的RequestMapping注解进行url映射关系的维护。
• 2.用户发起http请求，进入前端控制器，进行uri解析，通过处理器映射器查找对应的处理器方法，返回给前端控制器
• 3.前端控制器调用处理器适配器对象来封装前端请求表单参数，调用处理器方法，把执行结果交给前端控制器
• 4.前端控制器调用视图解析器对象来得到视图路径。
• 5.前端控制器进行视图的转发，request.getRequestDispatcher(“路径”).forward(req,resp),渲染视图。

异步开发流程：

• 1.在启动tomcat时，进行ioc和di实现，同时处理器映射器解析bean对象上的RequestMapping注解进行url映射关系的维护。
• 2.用户发起异步http请求(ajax,axios)，进入前端控制器，进行uri解析，通过处理器映射器查找对应的处理器方法，返回给前端控制器
• 3.前端控制器调用处理器适配器对象来封装前端请求表单参数，调用处理器方法，把执行结果交给前端控制器
• 4.前端控制器调用json处理器对象来把执行结果转json字符串，通过输出流返回前端。

4.详细的认识springmvc接收数据

• 1.接收前端的key=value&key=value格式的数据（请求头Content-type：application/x-www-form-urlencoded）

在处理器方法上加形参即可，
注意点：
1.形参类型不能是基本类型变量（int，double），必须包装类对象。
2.如果多个形参属于一个实体类的话，加实体类形参。
3.可以给形参指定默认值,给形参加注解@RequestParam

• 2.接收前端的{key:value,key:value}json格式的数据（请求头Content-type：application/json）

使用：
1.需要引入jackson组件，3个jackson的jar包(
jackson-annotations-2.9.6.jar,
jackson-core-2.9.6.jar,
jackson-databind-2.9.6.jar);
2.在处理器方法加形参，但是形参使用@RequestBody注解来获取请求体中的json字符串数据并通过jackson组件转对象。
注意点：
1.RequestBody注解的形参不能是String，Double，Integer等简单类型对象，必须是实体类或Map.
2.如果前端传递的参数比较复杂，是服务端中多个实体对象中数据，不能使用requestBody注解多个实体，如果传过来的数据应该用多个实体对象进行承载，则服务端使用Map接收参数，然后通过BeanUtils工具类来把map中数据分发到不同的实体对象（如下）。
  @PostMapping("add")
    public ResponseEntity addUserAndRole(@RequestBody Map map, HttpServletRequest req, HttpServletResponse resp, HttpSession session){
        ServletContext servletContext = req.getServletContext();
        //把map中的数据分发到两个对象中
        Sysuser u = new Sysuser();
        Sysrole r = new Sysrole();
        try {
            BeanUtils.populate(u,map);
            BeanUtils.populate(r,map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        r.setRid(1);
    //设置响应头
        HttpHeaders headers =new HttpHeaders();
        headers.add("myname","1231");//给响应头添加参数
        return new ResponseEntity(r,headers,HttpStatus.OK);
    }

5.限定前端请求方式：

在方法啥能够进行url映射的时候，两种方法：

1.@RequestMapping(path = "add2",method = RequestMethod.POST)
2.使用GetMapping或PostMapping,PutMapping,DeleteMapping进行url映射。

6.详细的认识springmvc返回数据

1.同步开发中返回的视图加数据

方法1：在处理器方法上加Model类型的形参
@RequestMapping("hellomvc")
    public String hello(Model model){
        us.test();
        System.out.println("进入hello");
        model.addAttribute("uname","admin");
        model.addAttribute("uage",12);//等价于request.setAttribute
        return "hello";//   通过视图解析器对象得到完成视图路径，转发请求
    }
方法2：处理器方法的返回值类型改为ModelAndView对象
 @RequestMapping("hellomvc")
    public ModelAndView hello(){
        us.test();
        System.out.println("进入hello");
        ModelAndView mv = new ModelAndView();//数据与视图
        mv.addObject("uname","admin22");
        mv.addObject("uage",12);
        mv.setViewName("hello");

        return mv;//   通过视图解析器对象得到完成视图路径，转发请求
    }

2.异步开发中返回的是json数据

在项目环境下添加jackson依赖包。把处理器方法的通过json处理器对象，返回值转成json字符串

方法1：使用ResponseBody注解处理器方法；
	
方法2：使用ReponseEntity对象作为处理器方法的返回值；这种方式支持添加响应头。
	return ResponseEntity.ok(放响应体中的数据，Object类型);
	return new ResponseEntity(响应体数据,响应头HttpHeaders,状态吗HttpStatus.OK);

方法3：使用RestController注解处理器类，表示当前类中的所有处理器方法的返回值转json字符串输出前端。

7.转发重定向

转发与重定向请求，用在同步开发中。

在同步开发中，处理器方法返回的视图名以forward:或redirect:开头，则表示转发或重定向到另外一个处理器。

    //重定向过程中重新设置参数，保证原始参数不丢失
@RequestMapping(value = "test4")
    public String test4(UserInfo userInfo, RedirectAttributes ra){
        ra.addAttribute("userId",userInfo.getUserId());
        ra.addAttribute("username",userInfo.getUsername());
        ra.addAttribute("password",userInfo.getPassword());
        ra.addFlashAttribute("userId",userInfo.getUserId());
        ra.addFlashAttribute("username",userInfo.getUsername());
        ra.addFlashAttribute("username",userInfo);
        ra.addFlashAttribute("userId",userInfo.getUserId());
        ra.addFlashAttribute("username",userInfo.getUsername());
        ra.addFlashAttribute("password",userInfo.getPassword());
        return "redirect:test2";
    }

8.数据乱码处理

tocmat8以上的版本，对于url字符串按照utf-8解析，支持中文，所有url上可以带中文；

​ 对于请求体中的数据按照iso-8859-1进行编码，不支持中文，需要request.setCharacterEncoding(“UTF-8”)

get请求：参数在url后面追加，只要我们的tomcat使用8版本以上，tomcat8以后的版本，tomcat对于url字符窜是按照utf-8编码解析，这里的中文绝对不会乱码.

post请求：请求体中的数据格式如果是key=value格式，中文会乱码；

​ 请求体中的数据格式如果是{key：value}格式，tomcat仍然不支持中文，但是springmvc在把乱码的字符串转对象的时候，采用的是utf-8编码，中文不会乱码；

          <!--以下过滤器配置在web.xml中第一个过滤器中-->

    <!--编码格式过滤器:将同步请求中的编码格式设置为utf-8-->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

9.servlet对象的获取

HttpSevletRequest,HttpServletResponse,HttpSession,ServletContext

HttpSevletRequest,HttpServletResponse,HttpSession直接添加处理器形参

ServletContext通过request或session对象间接获取。

 //request,response,session 可用如下方式给控制层方法添加参数即可，context则可以通过request或session对象间接获取
@PostMapping("login")
    public ResponseEntity dologin(@RequestBody Sysuser user, HttpSession session) throws WebException {
        System.out.println(session);
        Sysuser u = us.selectUser(user);
        if(u==null){
            throw new WebException(StatusEnum.LOGIN_PWD_ERROR);
        }
        session.setAttribute("LOGIN_USER",u);
        return ResponseEntity.ok(new RespBean(StatusEnum.SUC,u));
    }

总结：

开发模式：

​ 同步开发模式：

后端代码与前端代码在一个项目中，前端发起请求，通过form表单里面的submit按钮提交请求，或者通过js的location.href发起请求。每次发起请求，进入服务端，服务端进行页面的转发或重定向。

​ 半分离异步开发：

后端代码与前端代码在一个项目中。前端发起请求，通过ajax或axios来发起异步请求，不涉及页面的转发与重定向。

​ 前后端分离异步开发：

前端与后端代码不在一个项目中。前端发起请求，通过ajax或axios来发起异步请求，不涉及页面的转发与重定向。
服务度要解决跨域问题。(设置一些跨域响应头)

前端提交请求的方式：

​ get请求：

前端提交的数据都是key=value格式的数据，数据在url上追加。

​ post请求:

前端提交的数据存在两种格式：key=value    或者是   {key:value}

1.如果前端提交的是key=value ，后端request.getParameter("key")，这种方式乱码通过request.setCharacterEncoding("UTF-8")
2.如果前端提交的是{key:value},后端request.getInputStream来读取流数据，读成字符串,再通过json组件转我们需要的对象。这种方式的乱码通过读取流的时候指定编码格式。

http协议：

请求：

​ 请求行：url，method

​ 请求头：content-type=“application/x-www-form-urlencoded”|“application/json”|“multipart/form-data”

​ content-length=数据大小

​ user-agent：客户端信息

​ 请求体：这部分是用来承载除了get请求以外的参数。

响应：

​ 响应行：200 http

​ 响应头：content-type：text/html;application/json

​ 响应体：服务端回传给客户端的数据。

springmvc总结：

1.对处理器方法，如何进行url映射：

​ springMVC通过RequestMapping，GetMapping，PostMapping进行url映射，这三个注解写在类或方法上，通常写法：类上写RequestMapping注解，方法上写GetMapping或PostMapping，如果处理器方法进行查询的话，写getMapping；如果进行添加修改，写PostMapping；如果提交表单参数涉及敏感信息，写PostMapping。

2.对处理器方法，如何获取前端参数：

​ kv参数格式：加形参，底层是getParameter，这种方式有乱码，需要引入编码过滤器request.setCharacterEncoding(“UTF-8”)

​ json参数格式：加形参，同时加@RequestBody注解，底层是getInputStream，通过json组件转对象。这种方式没乱码，因为json组件内部对字符串进行了utf-8重新编码。

注意点：RequestBody注解不能注解到简单类型（String，Integer，Double…），只能注解Map，实体。

​ RequestParam注解只能用在key=value获取获取，只能用在简单类型上。

3.处理器方法中如何返回数据给前端：

​ 同步开发：把数据放在Model对象或ModelAndView对象中，等价于request.setAttribute(key,value)，通过视图解析器对象（InternalResourceViewResolver）得到完整视图路径，渲染视图。在jsp中使用el+jstl来获取request域中的数据。

​ 异步开发：通过给处理器方法加标志，让该方法的返回值不走视图解析器，而是走json转换器

方法1：在处理器方法上加@ReponseBody注解，方法直接返回实体对象或List或Map，通过json消息转换器对象(MappingJackson2HttpMessageConverter)把实体对象，list或map转json字符串，发送给前端。

方法2：处理器方法的返回值类型ResponseEntity，通过new ResponseEntity（实体或list或map，响应头，状态码）。

4.servlet对象获取：

加形参

5.对于postman接口测试工具的使用：

params选项：该选项下的参数都是追加的url后面的。只有get请求才使用。

10.rest风格url

• 服务端定义rest风格接口；异步开发中才使用

resturl：描述性状态转移，url的写法风格与传统的url不同

传统url	method	参数
/user/add	post	请求体:k=v|{k:v}
/user/selectUserById	get	/user/selectUserById?uid=100
/user/updateById	post	请求体:k=v|{k:v}
/user/deleteByIds	get	/user/deleteByIds?uids=1,2,3

resturl：url中无动词，同一个url通过提交方法的不同表示不同的处理器方法。前后端都支持put与delete请求

restUrl	method	参数
/user	post	请求体:k=v|{k:v}
/user/100	get	参数是url路径的一部分
/user	put	请求体:k=v|{k:v}
/user/1,2,3	delete	参数是url路径的一部分

注意点：

如果请求体中的参数格式是json格式，后端接口正常使用@RequestBody接收数据

不重要：如果请求体中的参数格式时kv格式，且提交method是put的话，服务端接口收不到数据，因为是tomcat对put和delete请求，参数不进行解析。需要添加过滤器对put和delete请求通过流的方式获取请求体中的数据独立处理。

       <!--以下过滤器配置在web.xml中-->
      <!--rest风格Url过滤器：处理put delete接收不到kv格式数据的问题-->
<filter>
        <filter-name>formContentFilter</filter-name>
        <filter-class>org.springframework.web.filter.FormContentFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>formContentFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

11.springMVC的异常处理

• 局部异常处理（不重要）

针对单个处理器中的方法异常进行处理。

//1.创建一个异常类
public class WebException extends Exception {
    private StatusEnum se;
    public WebException(StatusEnum se) {
        this.se = se;
    }
    public StatusEnum getSe() {
        return se;
    }
    public void setSe(StatusEnum se) {
        this.se = se;
    }
}
//2.给异常处理方法加注解@ExceptionHandler(WebException.class)
//注意：此方法只处理本类内的异常
public StatusBean doExcetion(Exception e){
    
}

• 全局异常处理（不重要）

对所有处理器类的异常都处理，但建议是对同步开发的异常处理的，转异常视图的。

//单独设置一个异常处理类用于转到异常视图 由于只有一个resolveException方法，所以对于异常的分类处理不利不便于扩展
@Component
public class GlobExceptionHandler implements HandlerExceptionResolver{
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        WebException we= (WebException)e;
        StatusEnum se = we.getSe();
        StatusBean bean = new StatusBean(se);
        String s = JSON.toJSONString(bean);
        httpServletResponse.setContentType("application/json");
        httpServletResponse.setCharacterEncoding("UTF-8");
        PrintWriter writer = null;
        try {
            writer = httpServletResponse.getWriter();
            writer.print(s);
            writer.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return null;
}

• 全局统一异常处理（重要）

使用@ControllerAdvice注解进行全局统一异常处理.

//通过注解方式创建异常响应类，通过分方法来实现不同异常的分别处理，是在全局异常处理的一个改进版在实际开发过程中使用此方法进行异常处理。
@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public StatusBean doException(Exception e){
        e.printStackTrace();
        String msg = e.getMessage();
        System.out.println(msg);
        return new StatusBean(StatusEnum.ERROR);
    }

    @ExceptionHandler(WebException.class)
    @ResponseBody
    public StatusBean doWebException(WebException e){
        String msg = e.getSe().getMsg();
        System.out.println(msg);//服务端能够记录异常日志
        return new StatusBean(e.getSe());//请求正常结束，返回异常状态信息
    }
}

12.静态资源处理（在前端未分离开发模式下重要）

css,js,img，视频音频文件

由于DispatcherServlet的url映射路径为/，所有的url请求都进入了DisptcherServlet，根据uri去找处理器方法。

tomcat下有两个默认Servlet，DefaultServlet的映射路径/，JspServlet的映射路径时*.jsp

我们在springmvc项目下配置DispatcherServlet的映射路径/，覆盖了DefaultServlet

jsp能够直接访问，是因为在tomcat下有JspServlet的映射路径时*.jsp,我们访问jsp文件没有进入DispatcherServlet。

方法1，在web.xml中对DefaultServlet进行映射

	<!--在web.xml中进行一个单独的静态资源服务映射：开启默认服务进行分配：避开了拦截器-->
	<servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.css</url-pattern>
        <url-pattern>*.png</url-pattern>
        <url-pattern>*.html</url-pattern>
        <url-pattern>*.jpg</url-pattern>
    </servlet-mapping>

方法2：建议使用这种方式

<!--在springmvc配置文件中配置静态资源，使用应用服务器下的DefaultServlet来处理静态资源-->
<mvc:default-servlet-handler></mvc:default-servlet-handler>

方法3：

	<!--springmvc官方推荐进行静态资源地址映射-->
<mvc:resources mapping="/static/**" location="/static/"></mvc:resources>
<mvc:resources mapping="/page/**" location="/page/"></mvc:resources>
<mvc:resources mapping="/upload/**" location="/upload/"></mvc:resources>

13.文件上传下载处理

springmvc底层对commons-fileupload组件进行了封装,提供了CommonsMultipartResolver这个bean对象

1.添加commons-fileupload的两个jar包。
2.在springmvc.xml配置文件解析器
 <!--文件上传,id必须叫做multipartResolver-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="UTF-8"></property><!--中文文件名支持-->
        <property name="maxUploadSize" value="50000000"></property>
        <property name="maxInMemorySize" value="10000000"></property><!--临时文件的限制域-->
        <property name="uploadTempDir" value="/upload/tmp"></property>
    </bean>

3.写文件上传的处理器方法
    @PostMapping("upload")
    public ResponseEntity doUpload(MultipartFile userFile, HttpServletRequest req) throws IOException {
        String name = userFile.getName();//表单参数名
        String fileName = userFile.getOriginalFilename();//文件真实名
        byte[] bytes = userFile.getBytes();//文件内容字节数组，处理小文件
        InputStream inputStream = ufile.getInputStream();//文件内容字节流，处理大文件
        long size = userFile.getSize();//文件大小
        
        //把文件存到upload目录
        String rootPath = req.getServletContext().getRealPath("/"); 
        String uploadPath = "/upload/"+fileName;   // upload/aaa.jpg
        File targetFile = new File(rootPath+uploadPath);// 
        FileUtils.writeByteArrayToFile(targetFile,bytes);
        //返回数据给前端,{"path":服务器路径,"realName":文件真实名,"size":文件大小}
        Map<String,String> result = new HashMap<>();
        result.put("path",uploadPath);
        result.put("realName",fileName);
        result.put("size",size+"");
        return ResponseEntity.ok(new RespBean(StatusEnum.SUC,result));
    }

上传：

异步上传前端：

myupload(param) {
	let formData = new FormData();
	formData.append("userFile",param.file);
	this.$axios.post("upload",formData,{headers:{"Content-Type":"multipart/form-data"}}).then(resp=>{
					this.addform.headImg = resp.data.path;
		})
	}

上传服务端：

 @PostMapping("upload")
    public ResponseEntity doUpload(MultipartFile userFile, HttpServletRequest req) throws IOException {
        String name = userFile.getName();//表单参数名
        String fileName = userFile.getOriginalFilename();//文件真实名
        byte[] bytes = userFile.getBytes();//文件内容字节数组，处理小文件
        InputStream inputStream = userFile.getInputStream();//文件内容字节流，处理大文件
        long size = userFile.getSize();//文件大小

        //把文件存到upload目录
        String rootPath = req.getServletContext().getRealPath("/"); //D:/threeWorksapce/out/0105web/
        String uploadPath = "/upload/"+fileName;   //  /upload/aaa.jpg
        File targetFile = new File(rootPath+uploadPath);//  D:/threeWorksapce/out/0105web/upload/aaa.jpg
        FileUtils.writeByteArrayToFile(targetFile,bytes);

        //返回数据给前端,{"path":服务器路径,"realName":文件真实名,"size":文件大小}
        Map<String,String> result = new HashMap<>();
        result.put("path",uploadPath);
        result.put("realName",fileName);
        result.put("size",size+"");
        return ResponseEntity.ok(new RespBean(StatusEnum.SUC,result));
    }

下载：

前端异步下载：同步下载在前后端分离的项目下会产生会话问题。拦截问题

download(){
                    const res = axios.request({
                        url: '/download?filepath=/upload/beauty.png',
                        method: 'get',   // 以post请求为例
                        responseType: 'blob'//axios底层对返回数据以流的方式处理
                    }).then(res=>{
                        const data = res.data;
                        let url = window.URL.createObjectURL(data)  
                        var a = document.createElement('a')
                        document.body.appendChild(a)
						a.href = url;
						a.download = 'aaa.png'
						a.click() 
						window.URL.revokeObjectURL(url)
               		 })
				}

服务端下载接口：

@GetMapping("download")
    public ResponseEntity doDownload(String filepath, HttpServletRequest req) throws WebException, IOException {
        String rootPath = req.getServletContext().getRealPath("/");
        File f = new File(rootPath+filepath);
        if(!f.exists()){
            throw new WebException(StatusEnum.NOTFOUND_ERROR);
        }
        String fileName = f.getName();
        byte[] bytes = FileUtils.readFileToByteArray(f);

        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Disposition", "attachment; filename="+URLEncoder.encode(fileName,"UTF-8"));

        return new ResponseEntity(bytes,headers,HttpStatus.OK);
    }

14.拦截器(重要)

是框架中的一个概念，类似于过滤器的职责。拦截器在进入DispatcherServlet中后才执行，过滤器是之前执行的。

1.定义拦截器：

public class LoginInterceptor implements HandlerInterceptor {
    //前拦截
  @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        Object login_user = session.getAttribute("LOGIN_USER");
        if(login_user==null){
            throw new WebException(StatusEnum.NO_LOGIN);//继续进入统一异常处理对象中。
        }
        return true;
    }
}

2.配置拦截器：

在springmvc.xml中配置拦截器，配置拦截范围，忽略范围
   <mvc:interceptors>
        <mvc:interceptor>
         <mvc:mapping path="/**"/><!--拦截路径-->
         <mvc:exclude-mapping path="/user/login"></mvc:exclude-mapping><!--忽略路径-->
         <mvc:exclude-mapping path="/upload/**"></mvc:exclude-mapping><!--忽略路径-->
         <bean class="com.javasm.common.interceptor.LoginInterceptor"></bean><!--拦截器bean-->
        </mvc:interceptor>
    </mvc:interceptors>

15.跨域支持

方法1：

@CrossOrigin只针对当前处理器进行跨域处理

方法2：单独使用正常，但是一旦和拦截器结合使用，出问题。

在springmvc.xml中配置全局的跨域支持，也有缺陷。
  <mvc:cors>
        <mvc:mapping path="/**" allowed-origins="http://localhost:8088/" allowed-headers="*" allowed-methods="*" allow-credentials="true" />
    </mvc:cors>
    
  注意点：
  与拦截器结合使用出问题。

方法3：基于跨域过滤器。建议使用方法3

在springmvc.xml中(在ssm整合时则应该配置在spring.xml中)配置CorsFilter注册到容器
<bean id="corsFilter" class="org.springframework.web.filter.CorsFilter">
         <constructor-arg name="configSource">
            <bean class="org.springframework.web.cors.UrlBasedCorsConfigurationSource">
                <property name="corsConfigurations">
                    <map>
                        <entry key="/**">
                            <bean 				class="org.springframework.web.cors.CorsConfiguration">
                                <property name="allowCredentials" value="true"/>
                                <property name="allowedMethods">
                                    <list>
                                        <value>GET</value>
                                        <value>POST</value>
                                        <value>HEAD</value>
                                        <value>PUT</value>
                                        <value>DELETE</value>
                                        <value>OPTIONS</value>
                                    </list>
                                </property>
                                <property name="allowedHeaders" value="*"/>
                                <property name="allowedOrigins" value="http://localhost:8088"/>
                            </bean>
                        </entry>
                    </map>
                </property>
            </bean>
         </constructor-arg>
    </bean>
    
在web.xml中配置过滤器
<filter>
        <filter-name>myCorsFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
        <init-param>
            <param-name>targetBeanName</param-name>
            <param-value>corsFilter</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>myCorsFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

16.会话处理（重要）

• 基于HttpSession
  • 登录用户对象在服务端使用HttpSession来管理对象，前提是多次请求共享Session，axios提交请求携带cookie，服务端接收cookie

前端：跨域场景下，发起请求时带着cookie
axios.defaults.withCredentials = true
后端：跨域场景下，服务端设置响应头接收cookie
响应头需要加allowCredentials=true

• 基于token（重要）

前后端交互不带cookie.

SpringMVC总结：

@RequestMapping

@GetMapping

@PostMapping

@PutMapping

@DeleteMapping

@RequestBody 取json

@ResponseBody返回json

ResponseEntity返回json

servlet对象获取

@ControllerAdvice统一异常处理

定义拦截器，配置拦截器

基于过滤器的跨域配置