spring boot（1）基本请求参数校验

雨点打透心脏的1/2处 2022-09-06 00:27 212阅读 0赞

# spring boot（1） 基本请求 #

### 第一个 hello world ###

使用idea新建中的Spring Initializr创建一个spring boot项目勾选上spring web依赖

目录结构：

*  java
    
     *  com.example.springboot01
        
         *  controller(新建目录)
            
             *  HelloController.java(新建类)
         *  Springboot01Application.java(自动生成的入口程序类)

HelloController.java：

package com.example.springboot01.controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    // @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体，@Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
    @RestController
    public class HelloController { 
        // @RequestMapping注解为控制器指定可以处理的URL请求
        @RequestMapping("/")
        public String index(){ 
            return "hello world";
        }
    }

然后启动程序访问 http://127.0.0.1:8080/ ，会看到hello world，说明成功了

### 第一个 get请求 ###

目录结构：

*  java
    
     *  com.example.springboot01
        
         *  controller
            
             *  HelloController.java
             *  GetPlayController.java(新建)
         *  Springboot01Application.java

GetPlayController.java：

package com.example.springboot01.controller;
    import org.springframework.web.bind.annotation.*;
    import java.util.Map;
    // @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
    // @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
    @RestController
    // 通过这里配置使下面的映射都在/play下
    @RequestMapping("/play")
    public class GetPlayController { 
        // @GetMapping注释将 HTTP GET 请求映射到特定的处理程序方法。
        // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.GET)的快捷方式
        // 这个相当于二级路由，访问的是http://127.0.0.1:8080/play/
        @GetMapping("/")
        public String getPlays(){ 
            return "这是get请求";
        }
        // URL是http://127.0.0.1:8080/play/1，通过@PathVariable获取参数
        @GetMapping("/{id}")
        public String getPlay(@PathVariable("id") int id){ 
            return "id: "+id;
        }
        // URL是http://127.0.0.1:8080/play?id=1，通过@RequestParam获取参数
        // @RequestParam还可以有两个参数，required是否可以为空，defaultValue默认值
        // 可以有多个@RequestParam参数
        @GetMapping("")
        public String getPlay2(@RequestParam("id") int id){ 
            return "id2: "+id;
        }
        // 如果参数过多使用上面那样的方法显然比较麻烦，就可以使用map参数
        // URL是http://127.0.0.1:8080/play/user?id=1&name=hhh
        @GetMapping("/user")
        public String getPlayUser(@RequestParam Map<String, Object> params){ 
            return "name: "+params.get("name")+" id: "+params.get("id");
        }
        // 可以接受数据参数
        // URL是http://127.0.0.1:8080/play/users?ids=1&ids=2&ids=3
        @GetMapping("/users")
        public String getPlayUser2(@RequestParam int[] ids){ 
            String str = "";
            for(int id: ids){ 
                System.out.println(id);
                str = str + "id"+id+": "+id+" ";
            }
            return str;
        }
        // get请求还可以接收对象参数，还能指定对象前缀
    }

### 第一个 post请求 ###

目录结构：

*  java
    
     *  com.example.springboot01
        
         *  controller
            
             *  HelloController.java
             *  GetPlayController.java
             *  PostPlayController.java(新建)
         *  Springboot01Application.java

PostPlayController.java：

package com.example.springboot01.controller;
    import org.springframework.web.bind.annotation.*;
    import java.util.Map;
    // @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
    // @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
    @RestController
    // 通过这里配置使下面的映射都在/play下
    @RequestMapping("/postplay")
    public class PostPlayController { 
        // @PostMapping注释将 HTTP POST 请求映射到特定的处理程序方法。
        // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.POST)的快捷方式
        // URL是http://127.0.0.1:8080/postplay
        @PostMapping("")
        // @RequestParam就是前端的表单参数，form-data参数
        // 和get一样@RequestParam也可以单个参数，多个参数，数组参数，设置默认值，是否为空，这里不演示
        public String postPlay(@RequestParam Map<String, Object> params){ 
            return "id: "+params.get("id")+" name: "+params.get("name");
        }
        // URL是http://127.0.0.1:8080/postplay/
        @PostMapping("/")
        // 如果把 json 作为参数传递，我们可以使用 @RequestBody 接收参数，将数据转换 Map
        public String postPlay1(@RequestBody Map<String, Object> params){ 
            return "id: "+params.get("id")+" name: "+params.get("name");
        }
        // post也可以接收对象为参数
        // put，delete能使用@PathVariable，@RequestParam和@RequestBody
    }

### 定义统一返回result对象 ###

目录结构：

*  java
    
     *  com.example.springboot01
        
         *  controller
            
             *  HelloController.java(修改，测试效果)
             *  GetPlayController.java
             *  PostPlayController.java
         *  ret(新建目录)
            
             *  RetCode.java(返回码枚举，新建)
             *  RetResult.java(返回对象，新建)
             *  RetResponse.java(返回对象封装，新建)
         *  Springboot01Application.java

RetCode.java 返回码枚举：

package com.example.springboot01.ret;
    // 响应码枚举，参考HTTP状态码的语义
    public enum RetCode { 
        // 成功
        SUCCESS(200),
        // 失败
        FAIL(400),
        // 未认证（签名错误）
        UNAUTHORIZED(401),
        // 接口不存在
        NOT_FOUND(404),
        // 服务器内部错误
        INTERNAL_SERVER_ERROR(500);
        public int code;
        RetCode(int code) { 
            this.code = code;
        }
    }

RetResult.java 返回对象：

package com.example.springboot01.ret;
    // 返回对象实体（泛型）
    public class RetResult<T> { 
        // 状态码
        public int code;
        // 状态
        private String msg;
        // 返回数据
        private T data;
    
        public RetResult<T> setCode(RetCode retCode) { 
            this.code = retCode.code;
            return this;
        }
        public int getCode() { 
            return code;
        }
        public RetResult<T> setCode(int code) { 
            this.code = code;
            return this;
        }
        public String getMsg() { 
            return msg;
        }
        public RetResult<T> setMsg(String msg) { 
            this.msg = msg;
            return this;
        }
        public T getData() { 
            return data;
        }
        public RetResult<T> setData(T data) { 
            this.data = data;
            return this;
        }
    }

RetResponse.java 返回对象封装：

package com.example.springboot01.ret;
    // 将结果转换为封装后的对象
    public class RetResponse { 
        private final static String SUCCESS = "success";
        // 成功不带数据
        public static <T> RetResult<T> success() { 
            return new RetResult<T>().setCode(RetCode.SUCCESS).setMsg(SUCCESS);
        }
        // 成功带状态信息
        public static <T> RetResult<T> success(String message) { 
            return new RetResult<T>().setCode(RetCode.SUCCESS).setMsg(message);
        }
        // 成功带数据
        public static <T> RetResult<T> success(T data) { 
            return new RetResult<T>().setCode(RetCode.SUCCESS).setMsg(SUCCESS).setData(data);
        }
        // 失败
        public static <T> RetResult<T> error(String message) { 
            return new RetResult<T>().setCode(RetCode.FAIL).setMsg(message);
        }
        // 通用不带数据，需要传状态码
        public static <T> RetResult<T> init(int code, String msg) { 
            return new RetResult<T>().setCode(code).setMsg(msg);
        }
        // 通用带数据，需要传状态码
        public static <T> RetResult<T> init(int code, String msg, T data) { 
            return new RetResult<T>().setCode(code).setMsg(msg).setData(data);
        }
    }

HelloController.java 修改：

package com.example.springboot01.controller;
    import com.example.springboot01.ret.RetResponse;
    import com.example.springboot01.ret.RetResult;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    // @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
    // @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
    @RestController
    public class HelloController { 
        // @RequestMapping注解为控制器指定可以处理的URL请求
        @RequestMapping("/")
        // 统一返回格式
        public RetResult<String> index(){ 
            return RetResponse.success("hello word");
        }
    }

### 参数校验 ###

maven添加组件：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

*  java
    
     *  com.example.springboot01
        
         *  controller
            
             *  HelloController.java
             *  GetPlayController.java
             *  PostPlayController.java(修改)
         *  ret
            
             *  RetCode.java
             *  RetResult.java
             *  RetResponse.java
             *  GlobalExceptionHandler.java(全局校验异常处理，新建)
         *  validation(参数校验，新建目录)
            
             *  PlayUserValidation.java(校验参数，新建)
         *  Springboot01Application.java

PlayUserValidation.java 校验参数：

package com.example.springboot01.validation;
    import lombok.Data;
    import javax.validation.constraints.Email;
    import javax.validation.constraints.NotBlank;
    import javax.validation.constraints.Size;
    @Data
    public class PlayUserValidation { 
        private Long id;
        @NotBlank(message = "用户名不能为空")
        @Size(max = 3,message = "用户名不能超过3")
        private String userName;
        @NotBlank(message = "昵称不能为空")
        private String nickName;
        @Email(message = "邮箱格式不正确")
        private String email;
    }

PostPlayController.java 修改：

package com.example.springboot01.controller;
    import com.example.springboot01.validation.PlayUserValidation;
    import com.example.springboot01.ret.RetResponse;
    import com.example.springboot01.ret.RetResult;
    import org.springframework.context.support.DefaultMessageSourceResolvable;
    import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    // @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
    // @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
    @RestController
    // 通过这里配置使下面的映射都在/play下
    @RequestMapping("/postplay")
    public class PostPlayController { 
        // @PostMapping注释将 HTTP POST 请求映射到特定的处理程序方法。
        // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.POST)的快捷方式
        // URL是http://127.0.0.1:8080/postplay
        @PostMapping("")
        // @RequestParam就是前端的表单参数，form-data参数
        // 和get一样@RequestParam也可以单个参数，多个参数，数组参数，设置默认值，是否为空，这里不演示
        public String postPlay(@RequestParam Map<String, Object> params){ 
            return "id: "+params.get("id")+" name: "+params.get("name");
        }
        // URL是http://127.0.0.1:8080/postplay/
        @PostMapping("/")
        // 如果把 json 作为参数传递，我们可以使用 @RequestBody 接收参数，将数据转换 Map
        public String postPlay1(@RequestBody Map<String, Object> params){ 
            return "id: "+params.get("id")+" name: "+params.get("name");
        }
        // post也可以接收对象为参数
        // put，delete能使用@PathVariable，@RequestParam和@RequestBody
    
        // URL是http://127.0.0.1:8080/postplay/user
        // 测试参数：{"id":1,"userName":"hhhh","nickName":"xxx","email":"xxxqq.com"}
        @PostMapping("/user")
        // @Validated 使用校验，BindingResult校验结果类可以获取失败信息
        public RetResult<Object> postPlayUser(@RequestBody @Validated PlayUserValidation user, BindingResult bindingResult){ 
            List<FieldError> fieldErrors = bindingResult.getFieldErrors();
            if(!fieldErrors.isEmpty()){ 
                //取出所有校验不通过的信息
                List<String> collect = fieldErrors.stream().map(DefaultMessageSourceResolvable::getDefaultMessage).collect(Collectors.toList());
                return RetResponse.init(HttpStatus.BAD_REQUEST.value(),"字段校验不通过", collect);
            }
            return RetResponse.success(user);
        }
    }

这样就能使用校验获取校验信息  
结果为：

{ 
        "code": 400,
        "msg": "参数检验不通过",
        "data": [
            "邮箱格式不正确",
            "用户名不能超过3"
        ]
    }

但是每个校验都要写一遍失败处理太麻烦所有就有了全局处理  
GlobalExceptionHandler.java 全局校验异常处理：

package com.example.springboot01.ret;
    
    
    import lombok.extern.slf4j.Slf4j;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindException;
    import org.springframework.validation.FieldError;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    import javax.validation.ConstraintViolation;
    import javax.validation.ConstraintViolationException;
    import java.util.List;
    import java.util.Set;
    import java.util.stream.Collectors;
    @Slf4j
    // 全局校验异常处理，使用@RestControllerAdvice修饰的GlobalExceptionHandler类
    @RestControllerAdvice
    public class GlobalExceptionHandler { 
        private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
        private static final String BAD_REQUEST_MSG = "参数检验不通过";
        //处理 form data方式调用接口校验失败抛出的异常
        @ExceptionHandler(BindException.class)
        public RetResult<Object> bindExceptionHandler(BindException e) { 
            List<FieldError> fieldErrors = e.getBindingResult().getFieldErrors();
            List<String> collect = fieldErrors.stream().map(o -> o.getDefaultMessage()).collect(Collectors.toList());
            return RetResponse.init(HttpStatus.BAD_REQUEST.value(), BAD_REQUEST_MSG, collect);
        }
        // 处理 json 请求体调用接口校验失败抛出的异常
        @ExceptionHandler(MethodArgumentNotValidException.class)
        public RetResult<Object> methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) { 
            List<FieldError> fieldErrors = e.getBindingResult().getFieldErrors();
            List<String> collect = fieldErrors.stream().map(o -> o.getDefaultMessage()).collect(Collectors.toList());
            return RetResponse.init(HttpStatus.BAD_REQUEST.value(), BAD_REQUEST_MSG, collect);
        }
        // 处理单个参数校验失败抛出的异常
        @ExceptionHandler(ConstraintViolationException.class)
        public RetResult<Object> constraintViolationExceptionHandler(ConstraintViolationException e) { 
            Set<ConstraintViolation<?>> constraintViolations = e.getConstraintViolations();
            List<String> collect = constraintViolations.stream().map(o -> o.getMessage()).collect(Collectors.toList());
            return RetResponse.init(HttpStatus.BAD_REQUEST.value(), BAD_REQUEST_MSG, collect);
        }
        // 处理以上处理不了的其他异常
        @ExceptionHandler(Exception.class)
        public RetResult<Object> exceptionHandler(Exception e) { 
            return RetResponse.init(HttpStatus.BAD_REQUEST.value(), BAD_REQUEST_MSG, e.getMessage());
        }
    }

再次去修改PostPlayController.java：

package com.example.springboot01.controller;
    import com.example.springboot01.validation.PlayUserValidation;
    import com.example.springboot01.ret.RetResponse;
    import com.example.springboot01.ret.RetResult;
    import org.springframework.context.support.DefaultMessageSourceResolvable;
    import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    // @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
    // @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
    @RestController
    // 通过这里配置使下面的映射都在/play下
    @RequestMapping("/postplay")
    public class PostPlayController { 
        // @PostMapping注释将 HTTP POST 请求映射到特定的处理程序方法。
        // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.POST)的快捷方式
        // URL是http://127.0.0.1:8080/postplay
        @PostMapping("")
        // @RequestParam就是前端的表单参数，form-data参数
        // 和get一样@RequestParam也可以单个参数，多个参数，数组参数，设置默认值，是否为空，这里不演示
        public String postPlay(@RequestParam Map<String, Object> params){ 
            return "id: "+params.get("id")+" name: "+params.get("name");
        }
        // URL是http://127.0.0.1:8080/postplay/
        @PostMapping("/")
        // 如果把 json 作为参数传递，我们可以使用 @RequestBody 接收参数，将数据转换 Map
        public String postPlay1(@RequestBody Map<String, Object> params){ 
            return "id: "+params.get("id")+" name: "+params.get("name");
        }
        // post也可以接收对象为参数
        // put，delete能使用@PathVariable，@RequestParam和@RequestBody
    
        // URL是http://127.0.0.1:8080/postplay/user
        // 测试参数：{"id":1,"userName":"hhhh","nickName":"xxx","email":"xxxqq.com"}
        @PostMapping("/user")
        // @Validated 使用校验，BindingResult校验结果类可以获取失败信息
        // 有了全局处理就可以去掉BindingResult结果类参数和错误处理
        public RetResult<Object> postPlayUser(@RequestBody @Validated PlayUserValidation user){ 
            return RetResponse.success(user);
        }
    }