精华内容
下载资源
问答
  • 本系列将为大家介绍笔者在开发... 本章将介绍如果通过AOP来对请求的参数进行自动的非空检查并返回。相信部分同学的代码中会出现如下的例子: if (parameters.get("openId") == null || StringUtils.isBlank(param...

              本系列将为大家介绍笔者在开发过程中使用aop的一些功能扩展,有从网上看到的,也有自己想的,如果有相似的代码,敬请海涵。

              本章将介绍如果通过AOP来对请求的参数进行自动的非空检查并返回。相信部分同学的代码中会出现如下的例子:

    if (parameters.get("openId") == null || StringUtils.isBlank(parameters.get("openId").toString())) {
        result.setResult(Constant.FAIL);
        result.setMessage("openId 为空,请检查参数");
        logger.info("openId is null");
    } else if (parameters.get("type") == null || StringUtils.isBlank(parameters.get("type").toString())) {
        result.setResult(Constant.FAIL);
        result.setMessage("type 为空,请检查参数");
        logger.info("type is null");
    } else if (signListByDays.equals(parameters.get("type").toString()) && (parameters.get("days") == null || StringUtils.isBlank(parameters.get("days").toString()))) {
        result.setResult(Constant.FAIL);
        result.setMessage("天数 为空,请检查参数");
        logger.info("days is null");
    } 

            又或者是

     

    // 检查参数
    if (parameters == null || StringUtils.isBlank(parameters.get("openId"))
            || StringUtils.isBlank(parameters.get("plateNumber"))
            || StringUtils.isBlank(parameters.get("frameNumber"))
            || StringUtils.isBlank(parameters.get("engineNumber"))
            || StringUtils.isBlank(parameters.get("registrationDate"))) {
        result.setResult(Constant.FAIL);
        result.setMessage("参数为空,请检查参数");
        logger.info("parameters is null");
        return result;
    }

    如果又增加了参数怎么办,继续在代码中添加判断,这样代码的侵入性太大,而且冗余度太多。为了解决这个问题。我们可以这么做。请看下面的一个controller 的方法

    /**
     * @Author Eric
     * @Description 增加一个商品模板
     * @Date 13:42 2019/1/29
     * @Param [parameters]
     * @return com.bxlsj.pojo.R
     **/
    @RequestMapping(method = RequestMethod.POST)
    @RequestRequire(require="supplierId,sku,state,name,unit,purchasePrice,storage",parameter = ProductTempletDto.class)
    public R addSupplier(@RequestBody ProductTempletDto productTempletDto){
        try {
            productTempletService.save(productTempletDto);
        } catch (Exception e) {
            logger.error("增加商品模板失败,{}", ExceptionUtil.getTrace(e));
            return R.error(e.getMessage());
        }
        return R.ok();
    }

    添加一个注解@RequestRequire 让aop来统一的帮我们进行非空的判断。

     

    第一步:添加一个注解@RequestRequire

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface RequestRequire {
    
        /**
         * 请求当前接口所需要的参数,多个以小写的逗号隔开
         * @return
         */
        public String require() default "";
    
        /**
         *传递参数的对象类型
         */
        public Class<?> parameter() default Object.class;
    
    }

    第二步:再增加一个注解@SetPropertyName 这个注解的主要目的是为了非空检查返回属性的中文信息

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface SetPropertyName {
    
        String value() default "";
    }

    第三步:编写切面类,代码不长就不仔细说了,最后注释掉的部分是可以持续扩展的,目前只检查了null和String类型空字符串的问题,如果还想对数字类型进行大于0等的判定,将注释的部分打开就可以了

    /**
     * @author Eric
     * @version 1.0
     * @ClassName: RequestRequireAspect
     * @Description: TODO
     * @company lsj
     * @date 2019/1/30 9:49
     **/
    @Component
    @Aspect
    public class RequestRequireAspect {
    
        private static final Logger logger = LoggerFactory.getLogger(RequestRequireAspect.class);
    
        static final String split = ",";
    
        @Pointcut("@annotation(com.bxlsj.base.annotation.RequestRequire)")
        public void controllerInteceptor() {
    
        }
    
        /**
         * controller层增强类,用于检测参数为空的情况
         * @author Eric
         * @date 9:52 2019/1/30
         * @params pjp
         * @throws
         * @return java.lang.Object
         **/
        @Around("controllerInteceptor()")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
    
            // 获取注解的方法参数列表
            Object[] args = pjp.getArgs();
    
            // 获取被注解的方法
            MethodInvocationProceedingJoinPoint mjp = (MethodInvocationProceedingJoinPoint) pjp;
            MethodSignature signature = (MethodSignature) mjp.getSignature();
            Method method = signature.getMethod();
    
            // 获取方法上的注解
            RequestRequire require = method.getAnnotation(RequestRequire.class);
    
            // 以防万一,将中文的逗号替换成英文的逗号
            String fieldNames=require.require().replace(",", ",");
    
            // 从参数列表中获取参数对象
            Object parameter=null;
            for(Object pa:args){
                //class相等表示是同一个对象
                if (pa.getClass()==require.parameter() ) {
                    parameter=pa;
                }
            }
    
            // 通过反射去和指定的属性值判断是否非空
            // 获得参数的class
            Class aClass = parameter.getClass();
    
            // 遍历参数,找到是否为空
            for(String name:fieldNames.split(split)){
                Field declaredField = aClass.getDeclaredField(name);
                String fieldName = declaredField.getName();
                declaredField.setAccessible(true);
                Object fieldObject = declaredField.get(parameter);
                // 获取属性的中文名称
                SetPropertyName spv = declaredField.getAnnotation(SetPropertyName.class);
                if(spv != null && StringUtils.isNotBlank(spv.value())){
                    fieldName = spv.value();
                }
    
                if(fieldObject == null){
                    return R.error("参数" + fieldName + "不能为空");
                }
                // 如果type是类类型,则前面包含"class ",后面跟类名
                if (declaredField.getGenericType().toString().equals("class java.lang.String")) {
                    if(StringUtils.isBlank((String)fieldObject)){
                        return R.error("参数" + fieldName + "不能为空");
                    }
                }
                // 如果是数字类型的
    /*           if (declaredField.getGenericType().toString().equals("class java.lang.Integer")
                      || declaredField.getGenericType().toString().equals("class java.lang.Long")
                       || declaredField.getGenericType().toString().equals("class java.lang.Double")
                      || declaredField.getGenericType().toString().equals("class java.lang.Float")) {
                    if(fieldObject == null){
                        return R.error("参数" + fieldName + "不能为空");
                   }
                } */
            }
            // 如果没有报错,放行
            return pjp.proceed();
        }
    }

    如果大家有什么疑问,欢迎留言交流

    推荐:史上最全的java开发工具类    地址:https://github.com/EricLoveMia/JavaTools

     

    展开全文
  • 在我们写后台接口时,难免对参数进行非空校验,如果一两个还好,但如果需要写大量的接口,及必填参数太多的时候,会给我们开发带来大量的重复工作,及很多相似代码。而sping自带的@RequestParam注解并能完全满足...

    一、前言

            在我们写后台接口时,难免对参数进行非空校验,如果一两个还好,但如果需要写大量的接口,及必填参数太多的时候,会给我们开发带来大量的重复工作,及很多相似代码。而sping自带的@RequestParam注解并不能完全满足我们的需求,因为这个注解只会校验请求中是否存在该参数,而不会校验这个参数的值是nulll还是空字符串(“”),如果参数不存在则会抛出org.springframework.web.bind.MissingServletRequestParameterException异常。虽然目前已经有许多成熟的校验框架,功能丰富,但是我们只需要做一个非空校验即可。

            因此我们可以自定义 一个注解用于校验参数是否为空。

    使用的的框架

    • spring boot:1.5.9.RELEASE
    • JDK:1.8

    二、准备工作

            首先需要创建一个spring boot项目,并引入相关maven依赖(主要是spring-boot-starter-web与aspectjweaver),pom文件如下:

    <?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>com.beauxie</groupId>
        <artifactId>param-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>param-demo</name>
        <description>param-demo for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.9.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <!-- 添加支持web -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!--引入AOP相应的注解-->
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.5</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    说明:

    • spring-boot-starter-web用于spring boot WEB支持
    • aspectjweaver 用于引入aop的相关的注解,如@Aspect@Pointcut

    三、自定义注解实现统一校验

    总体思路:自定义一个注解,对必填的参数加上该注解,然后定义一个切面,校验该参数是否为空,如果为空则抛出自定义的异常,该异常被自定义的异常处理器捕获,然后返回相应的错误信息。

    1. 自定义注解

    创建一个名为’ParamCheck’的注解,代码如下:

    package com.beauxie.param.demo.annotation;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * "参数不能为空"注解,作用于方法参数上。
     * 
     * @author Beauxie
     * @date Created on 2017/1/6
     */
    @Target(ElementType.PARAMETER)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ParamCheck {
        /**
         * 是否非空,默认不能为空
         */
        boolean notNull() default true;
    }

    说明:

    • @Target(ElementType.PARAMETER)表示该注解作用于方法参数上
    • 该类可以拓展,比如增加length校验

    2. 自定义异常类

    这个异常类与自定义注解配合一起使用,当加上’@ParamCheck’的参数为空时,抛出该异常,代码如下:

    package com.beauxie.param.demo.exception;
    
    /**
     * @author Beauxie
     * @date Created on 2017/1/6
     */
    public class ParamIsNullException extends RuntimeException {
        private final String parameterName;
        private final String parameterType;
    
        public ParamIsNullException(String parameterName, String parameterType) {
            super("");
            this.parameterName = parameterName;
            this.parameterType = parameterType;
        }
    
        @Override
        public String getMessage() {
            return "Required " + this.parameterType + " parameter \'" + this.parameterName + "\' must be not null !";
        }
    
        public final String getParameterName() {
            return this.parameterName;
        }
    
        public final String getParameterType() {
            return this.parameterType;
        }
    }

    说明:

    • 该异常继承RuntimeException,并定义了两个成员属性、重写了getMessage()方法
    • 之所以自定义该异常,而不用现有的org.springframework.web.bind.MissingServletRequestParameterException类,是因为MissingServletRequestParameterException为Checked异常,在动态代理过程中,很容易引发java.lang.reflect.UndeclaredThrowableException异常。

    3. 自定义AOP

    代码如下:

    package com.beauxie.param.demo.aop;
    
    import com.beauxie.param.demo.annotation.ParamCheck;
    import com.beauxie.param.demo.exception.ParamIsNullException;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    
    /**
     * @author Beauxie
     * @date Created on 2017/1/6
     */
    @Component
    @Aspect
    public class ParamCheckAop {
        private Logger logger = LoggerFactory.getLogger(this.getClass());
    
    
        /**
         * 定义有一个切入点,范围为web包下的类
         */
        @Pointcut("execution(public * com.beauxie.param.demo.web..*.*(..))")
        public void checkParam() {
        }
    
        @Before("checkParam()")
        public void doBefore(JoinPoint joinPoint) {
        }
    
        /**
         * 检查参数是否为空
         */
        @Around("checkParam()")
        public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    
            MethodSignature signature = ((MethodSignature) pjp.getSignature());
            //得到拦截的方法
            Method method = signature.getMethod();
            //获取方法参数注解,返回二维数组是因为某些参数可能存在多个注解
            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            if (parameterAnnotations == null || parameterAnnotations.length == 0) {
                return pjp.proceed();
            }
            //获取方法参数名
            String[] paramNames = signature.getParameterNames();
            //获取参数值
            Object[] paranValues = pjp.getArgs();
            //获取方法参数类型
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (int i = 0; i < parameterAnnotations.length; i++) {
                for (int j = 0; j < parameterAnnotations[i].length; j++) {
                    //如果该参数前面的注解是ParamCheck的实例,并且notNull()=true,则进行非空校验
                    if (parameterAnnotations[i][j] != null && parameterAnnotations[i][j] instanceof ParamCheck && ((ParamCheck) parameterAnnotations[i][j]).notNull()) {
                        paramIsNull(paramNames[i], paranValues[i], parameterTypes[i] == null ? null : parameterTypes[i].getName());
                        break;
                    }
                }
            }
            return pjp.proceed();
        }
    
        /**
         * 在切入点return内容之后切入内容(可以用来对处理返回值做一些加工处理)
         *
         * @param joinPoint
         */
        @AfterReturning("checkParam()")
        public void doAfterReturning(JoinPoint joinPoint) {
        }
    
        /**
         * 参数非空校验,如果参数为空,则抛出ParamIsNullException异常
         * @param paramName
         * @param value
         * @param parameterType
         */
        private void paramIsNull(String paramName, Object value, String parameterType) {
            if (value == null || "".equals(value.toString().trim())) {
                throw new ParamIsNullException(paramName, parameterType);
            }
        }
    
    }

    4. 全局异常处理器

    该异常处理器捕获在ParamCheckAop类中抛出的ParamIsNullException异常,并进行处理,代码如下:

    package com.beauxie.param.demo.exception;
    
    import com.beauxie.param.demo.common.Result;
    import com.beauxie.param.demo.enums.EnumResultCode;
    import com.beauxie.param.demo.utils.ResponseMsgUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.MissingServletRequestParameterException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * 全局异常处理.
     * 一般情况下,方法都有异常处理机制,但不能排除有个别异常没有处理,导致返回到前台,因此在这里做一个异常拦截,统一处理那些未被处理过的异常
     *
     * @author Beauxie
     * @date Created on 2017/1/6
     */
    @RestControllerAdvice
    public class GlobalExceptionHandler {
        private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    
        /**
         * 参数为空异常处理
         *
         * @param ex
         * @return
         */
        @ExceptionHandler({MissingServletRequestParameterException.class, ParamIsNullException.class})
        public Result<String> requestMissingServletRequest(Exception ex) {
            LOGGER.error("request Exception:", ex);
            return ResponseMsgUtil.builderResponse(EnumResultCode.FAIL.getCode(), ex.getMessage(), null);
        }
    
        /**
         * 特别说明: 可以配置指定的异常处理,这里处理所有
         *
         * @param request
         * @param e
         * @return
         */
        @ExceptionHandler(value = Exception.class)
        public Result<String> errorHandler(HttpServletRequest request, Exception e) {
            LOGGER.error("request Exception:", e);
            return ResponseMsgUtil.exception();
        }
    }
    

    说明:

    • requestMissingServletRequest()方法上加上@ExceptionHandler({MissingServletRequestParameterException.class, ParamIsNullException.class})注解,表明只处理处理MissingServletRequestParameterExceptionParamIsNullException异常
    • errorHandler()方法则处理其他的异常

    四、测试

    com.beauxie.param.demo.web包下新建一个名为HelloController的类,用于测试,代码如下:

    package com.beauxie.param.demo.web;
    
    import com.beauxie.param.demo.annotation.ParamCheck;
    import com.beauxie.param.demo.common.Result;
    import com.beauxie.param.demo.enums.EnumResultCode;
    import com.beauxie.param.demo.utils.ResponseMsgUtil;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author Beauxie
     * @date Created on 2018/1/6
     */
    @RestController
    public class HelloController {
        /**
         *测试@RequestParam注解
         * @param name
         * @return
         */
        @GetMapping("/hello1")
        public Result<String> hello1(@RequestParam String name) {
            return ResponseMsgUtil.builderResponse(EnumResultCode.SUCCESS.getCode(), "请求成功", "Hello," + name);
        }
    
        /**
         * 测试@ParamCheck注解
         * @param name
         * @return
         */
        @GetMapping("/hello2")
        public Result<String> hello2(@ParamCheck String name) {
            return ResponseMsgUtil.builderResponse(EnumResultCode.SUCCESS.getCode(), "请求成功", "Hello," + name);
        }
    
        /**
         * 测试@ParamCheck与@RequestParam一起时
         * @param name
         * @return
         */
        @GetMapping("/hello3")
        public Result<String> hello3(@ParamCheck @RequestParam String name) {
            return ResponseMsgUtil.builderResponse(EnumResultCode.SUCCESS.getCode(), "请求成功", "Hello," + name);
        }

    最后运行ParamDemoApplicatio的main方法,打开浏览器进行测试。

    1. 测试@RequestParam注解

    • 参数名为空测试
      在浏览器的地址栏输入:http://localhost:8080/hello1,结果如下:
      RequestParam1
      后台错误信息输出:
      Error1
      此时后台会报org.springframework.web.bind.MissingServletRequestParameterException: Required String parameter 'name' is not present错误信息,提示参数’name’不存在
    • 参数名不为空,值为空测试
      在浏览器的地址栏输入:http://localhost:8080/hello1?name=,结果如下:
      RequestParam2

      此时,name的值为空,但请求结果正常返回。

    • 参数名与值都不为空测试
      在浏览器的地址栏输入:http://localhost:8080/hello1?name=Beauxie,结果如下:
      RequestParam3

    2. 测试@ParamCheck注解

    3. 测试总结

    • 当参数名为空时,分别添加两个注解的接口都会提示参数不能为空
    • 当参数名不为空,值为空时,@RequestParam注解不会报错,但@ParamCheck注解提示参数’name’的值为空

    五、总结

    • 经过以上的测试也验证了@RequestParam只会验证对应的参数是否存在,而不会验证值是否为空
    • ParamCheck还可以进行拓展,比如参数值长度、是否含有非法字符等校验

    六、源码下载地址

    由于csdn下载需要积分,因此添加github源码地址:

    展开全文
  • SpringBoot参数非空判断

    2021-10-12 16:32:13
    搭建springboot项目,我们都是采用的Restful接口,那么问题来了,当前端调用接口或者是其他项目调用时,我们能单一靠调用方来控制参数的准确性,自己也要对一些非空的值进行判定。 二、方案 按照我们以往的做法,...

    一、前言
    搭建springboot项目,我们都是采用的Restful接口,那么问题来了,当前端调用接口或者是其他项目调用时,我们不能单一靠调用方来控制参数的准确性,自己也要对一些非空的值进行判定。

    二、方案
    按照我们以往的做法,都是对request中的参数一个一个进行非空判定。

     Model:      
    

    1 public class Order {
    2
    3
    4 private Long userID;
    5
    6
    7 private Long addressID;
    8
    9 private String comment;
    10
    11 }
    复制代码

    Controller:
    

    复制代码
    1 @PostMapping("/createOrders")
    2 public String createOrders(@RequestBody Order dto) {
    3 if(dto.getUserIDnull)
    4 return “userID不能为空”;
    5 if(dto.getAddressID
    null)
    6 return “addressID不能为空”;
    7 if(dto.getComment==null)
    8 return “comment不能为空”;
    9 return “sucess”;
    10 }
    复制代码

    这种做法首先是可取的,能达到我们的要求,但是这样如果model字段过多,判定的就很多,相对维护起来就不是那么方便,其次增加controller层的负担,既然我们来到spring4的时代,就应该适应使用注解的趋势,下面是使用注解后的比变化。

    Model:

    复制代码
    public class Order {

      @NotNull(message = "用户ID不能为空")
      private Long userID;
    
      @NotNull(message = "收货人地址id不能为空")
      private Long addressID;
    
      @NotBlank(message = "备注不为空")
      private String comment;
    

    }
    复制代码

    Controller:

    @PostMapping("/createOrders")
    public String createOrders(@RequestBody @Valid Order dto, BindingResult results) {
    if (results.hasErrors())
    return results.getFieldError().getDefaultMessage();
    return “success”;
    }

    这样我们就只需要在model字段上加上非空验证和相应提示语就好了。

    链接:https://www.cnblogs.com/wangyaobk/articles/8327780.html

    展开全文
  • (1)假设请求地址是如下这种 RESTful 风格,hangge 这个参数值直接放在路径里面: http://localhost:8080/hello/tom (2)Controller 可以这么获取该参数参数前一定要加@PathVariable(“name”),不然会是null...

    利用 Spring Boot 来制作 Web 应用,就必定会涉及到前端与后台之间互相传递参数。下面演示 Controller 如何接收以 GET 方式传递过来的参数。

    一、参数直接在路径中

    (1)假设请求地址是如下这种 RESTful 风格,hangge 这个参数值直接放在路径里面:

     http://localhost:8080/hello/tom
    

    (2)Controller 可以这么获取该参数:
    参数前一定要加@PathVariable(“name”),不然会是null。是路径的请求。

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello/{name}")
        public String hello(@PathVariable("name") String name) {//一定要加@PathVariable("name"),不然会是null
            return "获取到的name是:" + name;
        }
    }
    

    (3)结果:
    在这里插入图片描述

    二、参数跟在 ? 号后面

    1,获取参数的基本方法
    (1)假设请求地址是如下这种传统方式,参数跟在问号后面:

    http://localhost:8080/hello?name=tom
    

    (2)Controller 可以这么获取该参数:
    参数前的requestParam(“name”) 可以省略,因为这个用的是request的请求

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(@RequestParam("name") String name) {
            return "获取到的name是:" + name;
        }
    }
    

    (3)结果:
    在这里插入图片描述
    2,参数没有传递的情况
    (1)如果没有传递参数 Controller 将会报错,我们可以使用 required = false 标注参数是非必须的。

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(@RequestParam(name = "name", required = false) String name) {
            return "获取到的name是:" + name;
        }
    }
    

    (2)结果:
    在这里插入图片描述

    3,使用 map 来接收参数

    (1)Controller 还可以直接使用 map 来接收所有的请求参数:

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    import java.util.Map;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(@RequestParam Map<String, Object> params) {
            return "name:" + params.get("name") + "<br>age:" + params.get("age");
        }
    }
    

    (2)下面是一个简单的测试样例:
    在这里插入图片描述

    4,接收一个数组

    (1)假设请求地址是如下这种,有多个同名参数

    http://localhost:8080/hello?name=tom&name=james

    (2)我们可以定义一个数组类型的参数来接收:

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(@RequestParam("name") String[] names) {
            String result = "";
            for(String name:names){
                result += name + "<br>";
            }
            return result;
        }
    }
    

    附:使用对象来接收参数

    1,基本用法
    (1)如果一个 get 请求的参数太多,我们构造一个对象来简化参数的接收方式:

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(User user) {
            return "name:" + user.getName() + "<br> age:" + user.getAge();
        }
    }
    

    (2)User 类的定义如下,到时可以直接将多个参数通过 getter、setter 方法注入到对象中去:

    import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    //用了lombok插件省去了get和set方法
    @Setter
    @Getter
    @ToString
    public class User {
        private String name;
        private Integer age;
    }
    

    (3)下面是一个简单的测试样例:

    http://localhost:8080/hello?name=tom&age=10

    http://localhost:8080/hello?name=tom&age=10
    (4)如果传递的参数有前缀,且前缀与接收实体类的名称相同,那么参数也是可以正常传递的:

    http://localhost:8080/hello?user.name=tom&user.age=10

    2,指定参数前缀

    (1)如果传递的参数有前缀,且前缀与接收实体类的名称不同相,那么参数无法正常传递:

    http://localhost:8080/hello?u.name=tom&u.age=10

    (2)我们可以结合 @InitBinder 解决这个问题,通过参数预处理来指定使用的前缀为 u.
    除了在 Controller 里单独定义预处理方法外,我们还可以通过 @ControllerAdvice 结合 @InitBinder 来定义全局的参数预处理方法,方便各个 Controller 使用。

    package com.example.demo;
     
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.*;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(@ModelAttribute("u") User user) {
            return "name:" + user.getName() + "<br> age:" + user.getAge();
        }
     
        @InitBinder("u")
        private void initBinder(WebDataBinder binder) {
            binder.setFieldDefaultPrefix("u.");
        }
    }
    

    (3)重启程序可以看到参数以及成功接收了.

    3,构造多个对象来接收参数
    (1)如果一个 get 请求的参数分属不同的对象,也可以使用多个对象来接收参数:

    package com.example.demo;
     
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.bind.annotation.GetMapping;
     
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello(User user, Phone phone) {
            return "name:" + user.getName() + "<br> age:" + user.getAge()
                    + "<br> number:" + phone.getNumber();
        }
    }
    

    (2)新增的 Phone 类定义如下:

    package com.example.demo;
     
    public class Phone {
        private String number;
     
        public String getNumber() {
            return number;
        }
     
        public void setNumber(String number) {
            this.number = number;
        }
    }
    

    http://localhost:8080/hello?name=tom&age=10&number=123456

    参考来自:航歌

    下一篇:SpringBoot - 获取POST请求参数详解(附样例:表单数据、json、数组、对象)

    展开全文
  • 如果文件存储位置和cmd打开位置一样,请使用绝对路径 五:命令行参数示例hello_argv.py hello_argv.py文件在桌面 import sys print("Hello,",sys.argv[1]) #这样写也行: #print("Hello,"+sys.argv[1]) 在桌面打开...
  • 官方宣称已经在 DartPad、Dart 2.7 版本可以体验 non-nullable,具体的体验地址: https://nullsafety.dartpad.dev/ 5.2 配置 IDE 支持 non-nullable experiment 是不是用 DartPad 去学习可空和非空总觉得怪怪的,...
  • 1.JS概述 1)概念 js全程:JavaScript(一门客户端脚本语言) a.js可以直接嵌入在html页面中,由浏览器解释执行,进行预编译 ...1.解释执行:需要预编译,逐行执行 2.基于对象:内置了大量的现成对象 ...
  • MySQL 面试题

    万次阅读 多人点赞 2019-09-02 16:03:33
    如果能容忍拆分带来的查询性能损失的话,上面的方案在某个极致条件下肯定会出现问题,那么拆就是最好的选择。 实际场景下,例如说商品表数据量比较大的情况下,会将商品描述单独存储到一个表中。即,...
  • adb命令大全

    千次阅读 多人点赞 2019-06-03 22:19:07
    使用 -s 参数 No space left on device 空间不足 清理空间 Permission denied … sdcard … sdcard 可用 signatures do not match the previously installed version; ignoring! 已...
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    CMM与CMMI的区别 23 第五章 SQL 24 约束: 29 1主键约束 29 2 非空约束 not null 30 3 外键约束 FOREIGN KEY 30 4 默认约束 31 5 检查约束 check 31 6 唯一约束 unique 32 SQL语句 32 创建数据库. 32 表、字段、...
  • Java的非空处理

    千次阅读 2019-01-20 17:00:31
    我之前太年轻,经常在项目中做很多if/else的空值判断,现在回想之前写的代码感觉像是一坨屎,现在写起来虽然好点,最后还是变成了另一坨屎,会让人觉得很优雅。这些虽然跟业务逻辑没有多大关系,但就是会让你很...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    C#基础教程-c#实例教程,适合初学者。...当然仅靠一章的内容就完全掌握C#语言是可能的,如需进一步学习C#语言,还需要认真阅读有关C#语言的专著。 1.1 C#语言特点 Microsoft.NET(以下简称.NET)框...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    内容及步骤: 1、 设计一个图的类,采用临接表法进行存储,该图每个结点的数据类型类模板的模板参数进行定义(注:需先设计一个结点类Node); 2、 为该类分别设计一个实现深度优先搜索和广度优先搜索的成员...
  • 工作中遇到针对API中存在的实体类的非空校验,如果封装只能一个一个获取再校验。比较麻烦,所以写了个通用工具类,通过反射去实现效果 /** * 功能描述:对象非空校验 * * @author: hfanss * @date: 2021-...
  • 实体类的非空等校验

    2021-01-24 11:19:07
    开发中经常需要校验前端传来的对象属性是否为空等,整理出一份文档 1.添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>...2.实体类添加非空
  • SpringBoot里参数校验/参数验证

    万次阅读 多人点赞 2019-05-08 13:47:56
    * 否则,校验不通过。 * @param value 用户输入的值,如从前端传入的某个值 */ @Override public boolean isValid(Object value, ConstraintValidatorContext constraintValidatorContext) { // 切割获取值 ...
  • 第五章-Linux实操篇

    千次阅读 多人点赞 2019-10-24 18:45:20
    通过useradd -d 指定目录,创建新用户,并指定家 目录 8.3 修改密码 passwd 用户名 //修改密码 8.4 删除用户 8.4.1 基本语法 userdel 用户名 //删除用户保留用户主目录 userdel - r 用户名 //删除...
  • linux命令大全

    千次阅读 2015-12-24 08:44:14
    Linux 命令大全完整版 目  ...若指定任何参数,则chfn指令会进入问答式界面。 参 数:  -f<真实姓名>或--full-name<真实姓名> 设置真实姓名。   -h<家中电话>或--home-phone...
  • SpringBoot 对 JavaBean做非空验证

    千次阅读 2020-07-20 12:02:21
    java非空验证使用的是springboot的validation进行验证 一、需要引入spring-boot-starter-validation包 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core&...
  • 转载地址https://blog.csdn.net/qq_33996921/article/details/79568456关于springboot项目中,controller层对传递对象的校验,可以参照该文进行查看,点击打开链接...对于单个参数的校验:1、...
  • js校验参数是否为空以及校验url格式

    千次阅读 2018-11-08 10:39:24
     alert(message+"格式正确");  return false;  }else{  return true;  }  }else{  if(param == ''){  alert(message+"能为空");  return false;  }  if(!re.test(param)){  alert...
  • -----oracle创建表空间的方法 create tablespace dragon --dragon为创建的表空间名称 bagfile/smallfile代表创建 datafile 'D:\dragon.dbf' ...--设置初始大小 reuse参数为 如果文件存在则删除 autoexte...
  • 对于非空的错误指针导致的崩溃,能用常用的try{}catch{}进行处理,在C++中,这种方法只能处理异常,但对于空指针、除以0这些操作,能算是异常,而是错误,是能捕获并处理的;非空的错误指针,通常是由试图访问...
  • 【JAVA面试】java面试题整理(3)

    千次阅读 2018-10-28 12:50:13
    当这个参数打开之后,就需要手工指定新生代的大小、Eden与Survivor区的比例、晋升老年代对象年龄等细节参数了,虚拟机会根据当前系统的运行情况收集性能监控信息,动态调整这些参数以提供最合适的停顿时间或者最大...
  • java中优雅的参数校验方法

    万次阅读 多人点赞 2019-09-12 01:52:42
    如何更有“逼格”地在java中写出高大上的参数校验方法?
  • 最近一直在做前后端分离的项目,前端提交的参数很多,用Bean来接前端还要写每个Bean的前缀,索性就直接传参了。我们在controller用一个Map接参。 我看网上很少关于Map接参校验的,我就直接贴代码了。 1、首先是...
  • // 验证非空 String msg = new String(); msg = msg.length()==0?StringUtils.isBlank((mallMerchants.getShopname()))?"店铺名称能为空!":"":msg; msg = msg.length()==0?StringUtils.isBlank((mallMerchants....
  • 这个约束的参数是一个通过BigDecimal定义的最小值的字符串表示 . 小数存在精度 @Digits 验证 Number 和 String 的构成是否合法 @Digits ( integer = , fraction = ) 验证字符串是否是符合指定格式的数字,...
  • spring mvc 使用@notNull 注解验证请求参数使用方式@NotNull@Min@valid验证生效进阶注解接口校验逻辑实现自定义注解使用 处理请求时, 有些参数是必传或者必须遵循某些规则的, 如果针对每个请求都写一遍验证的话...
  • 1,通过cd切换到想要到的文件夹地址 2,执行下面的命令: del *.* 删除空文件夹以及非空文件夹: 参数: rd /s/q 文件夹的名字 /s 删除指定目录和所有子目录及其包含的所有文件 /q 安静模式。删除...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,455
精华内容 22,582
关键字:

地址参数非空不通过