avatar
文章
92
标签
37
分类
14
首页
时间轴
标签
分类
郝永亮的主页
首页
时间轴
标签
分类
SpringMVC 异常拦截器文件上传
|框架
阅读量:

0 今日案例需要的依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
<?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>org.example</groupId>
  <artifactId>springmvc021</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <dependencies>
    <!--jackson-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!-- servlet3.1规范的坐标 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!--jsp坐标-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <!--spring的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.6.RELEASE</version>
    </dependency>
    <!--spring web的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.1.6.RELEASE</version>
    </dependency>
    <!--springmvc的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.6.RELEASE</version>
    </dependency>
    <!--Lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.6</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!--jdk编译插件-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>utf-8</encoding>
        </configuration>
      </plugin>

      <!--tomcat插件-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <!-- tomcat7的插件， 不同tomcat版本这个也不一样 -->
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <!-- 通过maven tomcat7:run运行项目时，访问项目的端口号 -->
          <port>80</port>
          <!-- 项目虚拟路径  如果配置的aa， 则访问路径为localhost:8080/aa-->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

1 异步调用@RequestBody

1.1 发送异步请求

前端index.jsp代码

两个注意事项

​ 1.前端需要通过contentType告诉后端是JSON数据，并且数据在请求体中

​ 2.前端需要把数据转换成字符串再发送

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
    <button id="btn1">点击发送请求</button>

    <script>
        $(function () {
            $("#btn1").on('click',function () {
                var users = [
                    {
                        name:"jack",
                        age:34
                    },
                    {
                        name:"tom",
                        age:32
                    },{
                        name:"张三",
                        age:3
                    }


                ];
                $.ajax({
                    type:"post",
                    url:"/user/ajax",
                    data:JSON.stringify(users),//把对象转字符串
                    contentType:"application/json",//用json，text后端封装复杂数据会失败报415，自行测试
                    success:function (data) {
                        console.log(data)
                    }
                });
            });
        });
    </script>
</body>
</html>

java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package cn.itcast.controller;

import cn.itcast.domain.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/ajax")
    @ResponseBody
    public Map<Object, Object> ajax(@RequestBody List<User> users){
        System.out.println(users);


        //不要直接返回字符串，返回对象，测试前端success接收到的是字符串还是对象
        HashMap<Object, Object> map = new HashMap<>();
        map.put("status","success");
        return map;
    }
}

总结 @RequestBody的作用

用来获取请求体中的数据，前端请求头的类型Content-Type:applicaiton/json,还要求前段传到后端的数据必须是string类型的json数据

如果前端正常的发送表单数据(比如前端使用了form表单，又或者是正常调用$.get,$.post,$.ajax,并没有指定contnetType)，那么后端获取数据的时候不需要加@RequestBody

2 异步请求-跨域访问

2.1 跨域访问介绍

  • 当通过域名A下的操作访问域名B下的资源时，称为跨域访问
  • 跨域访问时，会出现无法访问的现象

image-20200427162623591

2.2 跨域环境搭建

当前电脑启动两台服务器会比较麻烦。

可以为当前电脑设置两个host域名，访问页面用A域名，页面访问后台用B域名

修改C:\Windows\System32\drivers\etc 目录下的 host文件，将该文件拷贝到其他盘，修改后替换原文件即可

添加如下内容

1
2
127.0.0.1       a.com
127.0.0.1       b.com

前端index.jsp代码 修改访问的服务的地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
    <button id="btn1">点击发送请求</button>

    <script>
        $(function () {
            $("#btn1").on('click',function () {
                var users = [
                    {
                        name:"jack",
                        age:34
                    },
                    {
                        name:"tom",
                        age:32
                    },{
                        name:"张三",
                        age:3
                    }


                ];
                $.ajax({
                    type:"post",
                    url:"http://b.com/user/ajax",//修改此处！！！！！！
                    data:JSON.stringify(users),//把对象转字符串
                    contentType:"application/json",//用json，text后端封装复杂数据会失败报415，自行测试
                    success:function (data) {
                        console.log(data)
                    }
                });
            });
        });
    </script>
</body>
</html>

在浏览器中访问a.com ,因为要发请求给http://b.com服务器，所以会报跨域错误

1593099295180

2.3 跨域访问支持

在接口所在的方法或者类上加@CrossOrigin注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//使用@CrossOrigin开启跨域访问
//标注在处理器方法上方表示该方法支持跨域访问
//标注在处理器类上方表示该处理器类中的所有处理器方法均支持跨域访问
package cn.itcast.controller;

import cn.itcast.domain.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("/user")
@CrossOrigin
public class UserController {


    @RequestMapping("/ajax")
    @ResponseBody
    public Map<Object, Object> ajax(@RequestBody List<User> users){
        System.out.println(users);


        HashMap<Object, Object> map = new HashMap<>();
        map.put("status","success");
        return map;
    }
}

3 拦截器

3.1 拦截器Interceptor

请求处理过程解析

image-20200427164038103

概念和作用

是一种动态拦截方法调用的机制

作用

1.在指定的方法调用前后执行预先设定后的的代码

2.阻止原始方法的执行

核心原理：AOP思想

拦截器链：多个拦截器按照一定的顺序，对原始被调用功能进行增强

拦截器VS过滤器

归属不同： Filter属于Servlet技术， Interceptor属于SpringMVC技术
拦截内容不同： Filter对所有访问进行增强， Interceptor仅针对SpringMVC的访问进行增强

image-20200427164512745

3.2 自定义拦截器开发过程

第一步:实现HandlerInterceptor接口 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//自定义拦截器需要实现HandleInterceptor接口
public class MyInterceptor implements HandlerInterceptor {
    //处理器运行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("前置运行----a1");
        //返回值为false将拦截原始处理器的运行
        //如果配置多拦截器，返回值为false将终止当前拦截器后面配置的拦截器的运行
        return true;
    }

    //处理器运行之后执行
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("后置运行----b1");
    }

    //所有拦截器的后置执行全部结束后，执行该操作
    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                Exception ex) throws Exception {
        System.out.println("完成运行----c1");
    }

    //三个方法的运行顺序为    preHandle -> postHandle -> afterCompletion
    //如果preHandle返回值为false，三个方法仅运行preHandle
}

第二步:配置拦截器 

1
2
3
4
5
6
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/showPage"/>
        <bean class="com.itheima.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

注意：配置顺序为先配置执行位置，后配置执行类

3.3 拦截器执行流程

image-20200427164840131

3.4 拦截器配置与方法参数

3.4.1 前置处理方法

原始方法之前运行

1
2
3
4
5
6
public boolean preHandle(HttpServletRequest request,
                         HttpServletResponse response,
                         Object handler) throws Exception {
    System.out.println("preHandle");
    return true;
}
  • 参数
     request:请求对象
     response:响应对象
     handler:被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装
  • 返回值
     返回值为false，被拦截的处理器将不执行

3.4.2 后置处理方法

原始方法运行后运行，如果原始方法被拦截，则不执行 

1
2
3
4
5
6
public void postHandle(HttpServletRequest request,
                       HttpServletResponse response,
                       Object handler,
                       ModelAndView modelAndView) throws Exception {
    System.out.println("postHandle");
}

 参数
 modelAndView:如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整

3.4.3 完成处理方法

拦截器最后执行的方法，无论原始方法是否执行 

1
2
3
4
5
6
public void afterCompletion(HttpServletRequest request,
                            HttpServletResponse response,
                            Object handler,
                            Exception ex) throws Exception {
    System.out.println("afterCompletion");
}

 参数
 ex:如果处理器执行过程中出现异常对象，可以针对异常情况进行单独处理

3.5 拦截器配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<mvc:interceptors>
    <!--开启具体的拦截器的使用，可以配置多个-->
    <mvc:interceptor>
        <!--设置拦截器的拦截路径，支持*通配-->
        <!--/**         表示拦截所有映射-->
        <!--/*          表示拦截所有/开头的映射-->
        <!--/user/*     表示拦截所有/user/开头的映射-->
        <!--/user/add*  表示拦截所有/user/开头，且具体映射名称以add开头的映射-->
        <!--/user/*All  表示拦截所有/user/开头，且具体映射名称以All结尾的映射-->
        <mvc:mapping path="/*"/>
        <mvc:mapping path="/**"/>
        <mvc:mapping path="/handleRun*"/>
        <!--设置拦截排除的路径，配置/**或/*，达到快速配置的目的-->
        <mvc:exclude-mapping path="/b*"/>
        <!--指定具体的拦截器类-->
        <bean class="MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

3.6 多拦截器配置

image-20200427171422781

责任链模式
 责任链模式是一种行为模式
 特征：
沿着一条预先设定的任务链顺序执行，每个节点具有独立的工作任务
 优势：
独立性：只关注当前节点的任务，对其他任务直接放行到下一节点
隔离性：具备链式传递特征，无需知晓整体链路结构，只需等待请求到达后进行处理即可
灵活性：可以任意修改链路结构动态新增或删减整体链路责任
解耦：将动态任务与原始任务解耦
 弊端：
链路过长时，处理效率低下
可能存在节点上的循环引用现象，造成死循环，导致系统崩溃

4 异常处理

系统的Dao、Service、Controller出现都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如下图：

1593101330925

4.0 异常处理的方式

方式1(了解)

使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver

1593101397999

方式2(XML了解)

第一步 创建异常处理器类实现HandlerExceptionResolver

1593101437662

第二步 编写异常页面error.jsp

1593101464016

第三步:把自定义异常处理类注册到springmvc框架中

1593101488122

第四步:控制器中编写会发生异常的代码

1593101511200

测试异常跳转
1593101520636

方式3(注解)掌握

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package cn.itcast.exception;

import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;

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

@ControllerAdvice
public class ExceptionAdvice {
    //该注解中设置要捕获的异常的类型,当前方法中编写异常的处理方式
    @ExceptionHandler(RuntimeException.class)
    public ModelAndView resolveException(HttpServletRequest request,
                                         HttpServletResponse response,
                                         Object handler,
                                         Exception ex) {

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/error.jsp");
        modelAndView.addObject("msg","系统出错");
        return modelAndView;
    }
}

1593153998744

4.1 异常处理解决方案

  • 异常处理方案
    • 业务异常：
       发送对应消息传递给用户，提醒规范操作
    • 系统异常：
       发送固定消息传递给用户，安抚用户
       发送特定消息给运维人员，提醒维护
       记录日志
    • 其他异常：
       发送固定消息传递给用户，安抚用户
       发送特定消息给编程人员，提醒维护
       纳入预期范围内
       记录日志

1593156991219

4.2 自定义异常

1593102161185

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//自定义异常继承RuntimeException，覆盖父类所有的构造方法
public class BusinessException extends RuntimeException {
    public BusinessException() {
    }

    public BusinessException(String message) {
        super(message);
    }

    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }

    public BusinessException(Throwable cause) {
        super(cause);
    }

    public BusinessException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

  • 异常触发方式

    1
    2
    3
    if(user.getName().trim().length()<4) {
        throw new BusinessException("用户名长度必须在2-4位之间，请重新输入！ ");
    }

  • 通过自定义异常将所有的异常现象进行分类管理，以统一的格式对外呈现异常消息

5 实用技术

5.1 文件上传下载

前端页面

必表单中的三个注意事项

  • input的type必须是file类型
  • 表单的提交方式必须是post
  • 表单的enctype属性的值必须是”multipart/form-data”

页面表单代码
1593102313554

1593102324376

单文件上传

1.导入fileupload和common-io依赖

1
2
3
4
5
6
7
8
9
10
<dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.3</version>
</dependency>

2.配置文件上传解析器

1593102410802

B表示Byte
1M=1024*1024
注意事项:bean的id值必须和我的保持一致，不然后台获取不到表单数据

3.编写控制器

1593102437307

1593102446579

多文件上传

页面代码

1593102484899

页面效果

1593102497607

控制器

1593102515834

1593102523368

总结

1.页面中的多个上传选项name要一致
2.后端接受文件上传数据时使用数组接收

5.2 文件上传注意事项

  1. 文件命名问题， 获取上传文件名，并解析文件名与扩展名
  2. 文件名过长问题
  3. 文件保存路径
  4. 重名问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@RequestMapping(value = "/fileupload")
//参数中定义MultipartFile参数，用于接收页面提交的type=file类型的表单，要求表单名称与参数名相同
public String fileupload(MultipartFile file,MultipartFile file1,MultipartFile file2, HttpServletRequest request) throws IOException {
    System.out.println("file upload is running ..."+file);
    //        MultipartFile参数中封装了上传的文件的相关信息
    //        System.out.println(file.getSize());
    //        System.out.println(file.getBytes().length);
    //        System.out.println(file.getContentType());
    //        System.out.println(file.getName());
    //        System.out.println(file.getOriginalFilename());
    //        System.out.println(file.isEmpty());
    //首先判断是否是空文件，也就是存储空间占用为0的文件
    if(!file.isEmpty()){
        //如果大小在范围要求内正常处理，否则抛出自定义异常告知用户（未实现）
        //获取原始上传的文件名，可以作为当前文件的真实名称保存到数据库中备用
        String fileName = file.getOriginalFilename();
        //设置保存的路径
        String realPath = request.getServletContext().getRealPath("/images");
        //保存文件的方法，指定保存的位置和文件名即可，通常文件名使用随机生成策略产生，避免文件名冲突问题
        file.transferTo(new File(realPath,file.getOriginalFilename()));
    }
    //测试一次性上传多个文件
    if(!file1.isEmpty()){
        String fileName = file1.getOriginalFilename();
        //可以根据需要，对不同种类的文件做不同的存储路径的区分，修改对应的保存位置即可
        String realPath = request.getServletContext().getRealPath("/images");
        file1.transferTo(new File(realPath,file1.getOriginalFilename()));
    }
    if(!file2.isEmpty()){
        String fileName = file2.getOriginalFilename();
        String realPath = request.getServletContext().getRealPath("/images");
        file2.transferTo(new File(realPath,file2.getOriginalFilename()));
    }
    return "page.jsp";
}

5.4 Restful风格配置

5.4.1 Rest

5.4.2 Rest行为约定方式

 GET（查询） http://localhost/user/1 GET
 POST（保存） http://localhost/user POST
 PUT（更新） http://localhost/user PUT
 DELETE（删除） http://localhost/user DELETE
注意：上述行为是约定方式，约定不是规范，可以打破，所以称Rest风格，而不是Rest规范

5.4.3 Restful开发入门

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//设置rest风格的控制器
@RestController
//设置公共访问路径，配合下方访问路径使用
@RequestMapping("/user/")
public class UserController {

    //rest风格访问路径完整书写方式
    @RequestMapping("/user/{id}")
    //使用@PathVariable注解获取路径上配置的具名变量，该配置可以使用多次
    public String restLocation(@PathVariable Integer id){
        System.out.println("restful is running ....");
        return "success.jsp";
    }

    //rest风格访问路径简化书写方式，配合类注解@RequestMapping使用
    @RequestMapping("{id}")
    public String restLocation2(@PathVariable Integer id){
        System.out.println("restful is running ....get:"+id);
        return "success.jsp";
    }

    //接收GET请求配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.GET)
    //接收GET请求简化配置方式
    @GetMapping("{id}")
    public String get(@PathVariable Integer id){
        System.out.println("restful is running ....get:"+id);
        return "success.jsp";
    }

    //接收POST请求配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.POST)
    //接收POST请求简化配置方式
    @PostMapping("{id}")
    public String post(@PathVariable Integer id){
        System.out.println("restful is running ....post:"+id);
        return "success.jsp";
    }

    //接收PUT请求简化配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.PUT)
    //接收PUT请求简化配置方式
    @PutMapping("{id}")
    public String put(@PathVariable Integer id){
        System.out.println("restful is running ....put:"+id);
        return "success.jsp";
    }

    //接收DELETE请求简化配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.DELETE)
    //接收DELETE请求简化配置方式
    @DeleteMapping("{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("restful is running ....delete:"+id);
        return "success.jsp";
    }
}
1
2
3
4
5
6
7
8
9
<!--配置拦截器，解析请求中的参数_method，否则无法发起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>
    <servlet-name>DispatcherServlet</servlet-name>
</filter-mapping>

 开启SpringMVC对Restful风格的访问支持过滤器，即可通过页面表单提交PUT与DELETE请求
 页面表单使用隐藏域提交请求类型，参数名称固定为_method，必须配合提交类型method=post使用

1
2
3
4
<form action="/user/1" method="post">
    <input type="hidden" name="_method" value="PUT"/>
    <input type="submit"/>
</form>

  • Restful请求路径简化配置方式 

    1
    2
    3
    4
    5
    6
    7
    8
    @RestController
    public class UserController {
        @RequestMapping(value = "/user/{id}",method = RequestMethod.DELETE)
        public String restDelete(@PathVariable String id){
            System.out.println("restful is running ....delete:"+id);
            return "success.jsp";
        }
    }

5.5 postman工具安装与使用

postman 是 一款可以发送Restful风格请求的工具，方便开发调试。首次运行需要联网注册

image-20200427180851880

面试题

spring里面用到了哪些设计模式？

  1. 代理模式

  2. 工厂模式

  3. 单例模式

  4. 责任链模式

  5. 模板模式： 模版方法模式定义了一个操作中的算法骨架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构,就可以重定义该算法的某些特定步骤

    https://www.cnblogs.com/Adam-Ye/p/13638784.html

拦截器和过滤器的区别

过滤器是web核心三大组件之一，可以增强所有的请求和响应。

拦截器是springmvc的一个特有功能，理论上只能增强处理器(处理器：controller中的方法)，底层是AOP技术。

文章作者: 微信：hao_yongliang
文章链接: https://haoyongliang.gitee.io/2020/06/14/springmvc/springmvc02/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 郝永亮的主页！
springMVC
打赏
  • 微信
    微信
  • 支付寶
    支付寶
相关推荐
2020-06-13
SpringMVC入门+请求和响应
2020-06-15
SpringMVC 参数校验+整合spring+mybatis
评论