精华内容
下载资源
问答
  • 判断实体类是否为空的注解
    千次阅读
    2022-04-01 11:20:26

    pom文件添加依赖

      <dependency>
          <groupId>org.hibernate.validator</groupId>
          <artifactId>hibernate-validator</artifactId>
          <version>6.0.17.Final</version>
      </dependency>
    

    1. 创建实体类并且添加非空注解

    在此说明 lombook的 @Data有bug,有的时候会出现无法获取到值,值为null的情况,最好使用set,get方法和tostring重写
    @Slf4j
    @Data
    public class Test {
    
        @NotEmpty(message = "名称不能为空!")
        private String name;
        @NotEmpty(message = "性别不能为空!")
        private String sex;
        @NotEmpty(message = "地址不能为空!")
        private String address;
        //注意这里如果字段的类型为 int 类型,该注解会失效,因为int类型的默认值为0,不传参数就使用默认值,为避免出现类似情况,可以使用包装类Integer ,他们的区别可以查一下,在这里不做详解
        @NotNull(message = "年龄不能为空!")
        private Integer age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public static Logger getLog() {
            return log;
        }
    
        @Override
        public String toString() {
            return "test{" +
                    "name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    ", address='" + address + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    

    控制器

    在方法的参数中需要使用注解 @Valid 与实体类中的为空注解结合使用
    @Slf4j
    @RestController
    @RequestMapping("/api/test")
    public class TestController {
    
        @PostMapping("/add")
        public void  add(@RequestBody @Valid Test test){
            log.info("====新增的数据===="+test);
    
        }
    }
    

    测试,这里使用的测试工具是RunAPI

    通过JSON传参
    正常返回结果
    {
    "name":"测试",
    "age":"22",
    "address":"444444",
    "sex":"男"
    }
    

    缺少age传值

    {
    "name":"测试",
    "address":"444444",
    "sex":"男"
    }
    
    返回结果
    {6 items
    "timestamp":"2022-04-01T03:28:45.102+0000"
    "status":400
    "error":"Bad Request"
    "errors":[1 item
    		0:{8 items
    		"codes":[...]4 items
    		"arguments":[...]1 item
    		"defaultMessage":"年龄不能为空!"
    		"objectName":"test"
    		"field":"age"
    		"rejectedValue":NULL
    		"bindingFailure":false
    		"code":"NotNull"
    		}
    ]
    "message":"Validation failed for object='test'. Error count: 1"
    "path":"/api/test/add"
    }
    
    
    更多相关内容
  • 我们写接口经常要做字段必填校验以及字段长度控制,前端访问就以实体类来传参,这样加上注解就可以实现判断字段是否为null,限制字段长度 自定义注解主要是分两部分,一部分是实现的util,一部分就是注解了 字段校验...

    我们写接口经常要做字段必填校验以及字段长度控制,前端访问就以实体类来传参,这样加上注解就可以实现判断字段是否为null,限制字段长度
    自定义注解主要是分两部分,一部分是实现的util,一部分就是注解了

    字段校验非空注解

    package cc.mrbird.febs.server.system.utils;
    
    import java.lang.annotation.*;
    
    /**
     * 空指针验证类
     */
    @Documented
    @Inherited
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface IsEmptyAnnotation {
        public boolean isEmpty() default true;
    
        public String message() default "字段不能为空!";
    }
    

    字段长度判断

    package cc.mrbird.febs.server.system.utils;
    
    
    import java.lang.annotation.*;
    
    /**
     * 最大长度验证类
     */
    @Documented
    @Inherited
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MaxSize {
        public int max() default 20;
    
        public String message() default "长度太长";
    }
    
    
    package cc.mrbird.febs.server.system.utils;
    
    
    import java.lang.annotation.*;
    
    /**
     * 最小长度验证类
     *
     */
    @Documented
    @Inherited
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MinSize {
        public int min() default 0;
    
        public String message() default "长度太短";
    }
    

    下面的util亲测可用

    package cc.mrbird.febs.server.system.utils;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.logging.Logger;
    
    /**
         * 注解验证处理类
         */
        public class AnnotationDealUtil {
            private static Logger log = Logger.getAnonymousLogger();
    
            /**
             * 注解验证电泳方法
             * @param bean 验证的实体
             * @return
             */
            @SuppressWarnings("unchecked")
            public static Map<String, Object> validate(Object bean) {
                Map<String, Object> result = new HashMap<String, Object>();
                result.put("message", "验证通过");
                result.put("result", true);
                Class<?> cls = bean.getClass();
    
                // 检测field是否存在
                try {
                    // 获取实体字段集合
                    Field[] fields = cls.getDeclaredFields();
                    for (Field f : fields) {
                        // 通过反射获取该属性对应的值
                        f.setAccessible(true);
                        // 获取字段值
                        Object value = f.get(bean);
                        // 获取字段上的注解集合
                        Annotation[] arrayAno = f.getAnnotations();
                        for (Annotation annotation : arrayAno) {
                            // 获取注解类型(注解类的Class)
                            Class<?> clazz = annotation.annotationType();
                            // 获取注解类中的方法集合
                            Method[] methodArray = clazz.getDeclaredMethods();
                            for (Method method : methodArray) {
                                // 获取方法名
                                String methodName = method.getName();
                                // 过滤错误提示方法的调用
                                if(methodName.equals("message")) {
                                    continue;
                                }
                                // 初始化注解验证的方法处理类
                                Object obj = AnnotationDealUtil.class.newInstance();
                                // 获取方法
                                try {
                                    // 根据方法名获取该方法
                                    Method m = obj.getClass().getDeclaredMethod(methodName, Object.class, Field.class);
                                    // 调用该方法
                                    result = (Map<String, Object>)m.invoke(obj, value, f);
                                    //验证结果 有一处失败则退出 
                                    if(result.get("result").equals(false)) {
                                        return result;
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                    log.info("找不到该方法:"+methodName);
                                }
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    log.info("验证出错");
                }
                return result;
            }
    
            /**
             * 验证是否空值
             *
             * @param value 参数值
             * @param field 字段
             * @return
             */
            public Map<String, Object> isEmpty(Object value, Field field) {
                Map<String, Object> validateResult = new HashMap<String, Object>();
                IsEmptyAnnotation annotation = field.getAnnotation(IsEmptyAnnotation.class);
                if(value == null || value.equals("")) {
                    validateResult.put("message", field.getName() + annotation.message());
                    validateResult.put("result", false);
                } else {
                    validateResult.put("message", "验证通过");
                    validateResult.put("result", true);
                }
                return validateResult;
            }
    
            /**
             * 验证最小值
             *
             * @param value 参数值
             * @param field 字段
             * @return
             */
            public Map<String, Object> min(Object value, Field field) {
                Map<String, Object> validateResult = new HashMap<String, Object>();
                MinSize annotation = field.getAnnotation(MinSize.class);
                if(value != null && value.toString().length() < annotation.min()) {
                    validateResult.put("message", annotation.message());
                    validateResult.put("result", false);
                } else {
                    validateResult.put("message", "验证通过");
                    validateResult.put("result", true);
                }
                return validateResult;
            }
            /**
             * 验证最大值
             *
             * @param value 参数值
             * @param field 字段
             * @return
             */
            public Map<String, Object> max(Object value, Field field) {
                Map<String, Object> validateResult = new HashMap<String, Object>();
                MaxSize annotation = field.getAnnotation(MaxSize.class);
                if(value != null && value.toString().length() > annotation.max()) {
                    validateResult.put("message", annotation.message());
                    validateResult.put("result", false);
                } else {
                    validateResult.put("message", "验证通过");
                    validateResult.put("result", true);
                }
                return validateResult;
            }
            //测试
            public static void main(String[] args) {
                Test test = new Test();
                test.setName("11");
                test.setAge("");
                test.setSex("12");
                System.out.println( validate(test));
    
            }
        }
    

    测试实体类

    package cc.mrbird.febs.server.system.utils;
    
    import lombok.Data;
    
    @Data
    public class Test {
        @IsEmptyAnnotation
        private String name;
        @MaxSize(max=2)
        private String sex;
        @MinSize(min = 1)
        private String age;
    }
    
    
    展开全文
  • JAVA自定义注解判断属性是否为空

    千次阅读 2020-07-21 18:29:05
    一、自定义注解 Java @Target(value=ElementType.FIELD) @Retention(value = RetentionPolicy.RUNTIME) public @interface NotNull { String message() default ""; } Target,Retention是元注解,也就是注解...

    一、自定义注解

    Java

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

    Target,Retention是元注解,也就是注解的注解
    Target:注解的范围,这里选ElementType.FIELD,表示作用在属性上。
    Retention:注解的生命周期,RUNTIME代表编译,运行的时候注解都存在,能影响到程序的逻辑。

    二、定义注解处理逻辑

    Java

    public  class ParamsRequired {
    
        public boolean validate() throws Exception {
            Field[] fields = this.getClass().getDeclaredFields();
            for (Field field : fields) {
                NotNull notNull = field.getAnnotation(NotNull.class);
                if (notNull != null) { 
                    Method m = this.getClass().getMethod("get" + getMethodName(field.getName()));
                    Object obj=m.invoke(this);
                    if (obj==null) {
                        System.err.println(field.getName() +notNull.message());
                        //throw new NullPointerException(notNull.message());
                    }
                }
            }
            return true;
        }
    
        /**
         * 把一个字符串的第一个字母大写
         */
        private String getMethodName(String fildeName) throws Exception {
            byte[] items = fildeName.getBytes();
            items[0] = (byte) ((char) items[0] - 'a' + 'A');
            return new String(items);
        }
    }

    三、使用注解

    Java

    public class Car extends ParamsRequired{
    
        @NotNull(message="名称不能为空")
        private String name;
        @NotNull(message="价格不能为空")
        private Double price;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Double getPrice() {
            return price;
        }
        public void setPrice(Double price) {
            this.price = price;
        }
    }

    四、测试

    Java

    public class Test {
        public static void main(String[] args) throws Exception {
            Car car=new Car();
            car.validate();
        }
    }
    

    运行结果:
    运行结果

    展开全文
  • 判别指定对象的属性值是否为空,那确实可以,但是随着的增多,判别对象的属性是否为空就非常的繁琐,所以可以使用自定义注解和反射来判定指定的字段是否为空。第一步:创建一个自定义注解package ...

    我们在写项目的时候,如何类比较少。判别指定对象的属性值是否为空,那确实可以,但是随着类的增多,判别对象的属性是否为空就非常的繁琐,所以可以使用自定义注解和反射来判定指定的字段是否为空。

    第一步:创建一个自定义注解

    package com.zczy.test.annoation;

    import java.lang.annotation.ElementType;

    import java.lang.annotation.Retention;

    import java.lang.annotation.RetentionPolicy;

    import java.lang.annotation.Target;

    @Target(ElementType.FIELD)

    @Retention(RetentionPolicy.RUNTIME)

    public @interface ParamsCheck {

    /**

    * 此注解就是过滤不需要的字段,来判断需要的字段是否为空

    */

    String attributeName();

    }

    第二步:创建一个类,并在类的属性上加上自定义注解的标识,就是为了判断这些字段是否为空

    package com.zczy.test.bean;

    import com.zczy.test.annoation.ParamsCheck;

    import lombok.Data;

    @Data

    public class Person {

    @ParamsCheck(attributeName = "userName")

    private String userName;

    @ParamsCheck(attributeName = "id")

    private String id;

    private String sex;

    public Person(String userName,String id,String sex){

    this.userName = userName;

    this.id = id;

    this.sex = sex;

    }

    }

    第三部:自定义一个返回类型的类

    package com.zczy.test.utils;

    import lombok.Data;

    @Data

    public class ValidResult {

    private String msg;

    private String code;

    public ValidResult(){

    }

    public ValidResult(String msg,String code){

    this.msg = msg;

    this.code = code;

    }

    }

    第四步:编写反射的代码

    package com.zczy.test.utils;

    import com.zczy.test.annoation.ParamsCheck;

    import java.lang.annotation.Annotation;

    import java.lang.reflect.Field;

    import java.lang.reflect.InvocationTargetException;

    import java.lang.reflect.Method;

    import java.util.ArrayList;

    import java.util.List;

    public class CheckPointParamsHandlar {

    public Class clazz;

    private Field[] fields;

    private T t;

    public CheckPointParamsHandlar(T t){

    this.t = t;

    this.clazz = t.getClass();

    //getDeclaredFields()返回Class中所有的字段,包括私有字段;

    //getFields 只返回公共字段,即有public修饰的字段

    this.fields = t.getClass().getDeclaredFields();

    }

    //判断已经注解的字段是否为空

    public ValidResult getParamChecksResults(){

    List list = new ArrayList<>();

    ValidResult res = new ValidResult();

    Boolean flag = true;

    StringBuffer sb = new StringBuffer();

    for(Field field : fields ){

    //System.out.println(field);

    //private java.lang.String com.zczy.test.bean.Person.userName

    //private java.lang.String com.zczy.test.bean.Person.id

    //private java.lang.String com.zczy.test.bean.Person.sex

    //查看注解的必要字段不能为空--如果没有注解直接跳过

    Annotation annotation=null;

    annotation = field.getAnnotation(ParamsCheck.class);

    if(annotation == null){

    continue;

    }

    //判断注解过的字段是否为空

    // System.out.println("annotation>>>>>"+annotation);

    //annotation>>>>>@com.zczy.test.annoation.ParamsCheck(attributeName=userName)

    //annotation>>>>>@com.zczy.test.annoation.ParamsCheck(attributeName=id)

    String name = field.getName();

    // System.out.println(name);

    // userName

    // id

    // sex

    char[] tempChar = name.toCharArray();

    tempChar[0] -= 32;

    String tempStr ="get"+ String.valueOf(tempChar);

    list.add(tempStr);

    //System.out.println("list>>>>>"+list);

    // list>>>>>[getUserName, getId]

    }

    for(String str : list){

    try {

    Method method = clazz.getMethod(str);

    //System.out.println("method>>>"+method);

    // method>>>public java.lang.String com.zczy.test.bean.Person.getUserName()

    //method>>>public java.lang.String com.zczy.test.bean.Person.getId()

    Object invoke = method.invoke(t);

    // System.out.println(invoke);

    if(null == invoke || "".equals(invoke)){

    flag = false;

    sb.append(str.toLowerCase()+"不能为空").append(",");

    }

    } catch (NoSuchMethodException e) {

    e.printStackTrace();

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    } catch (InvocationTargetException e) {

    e.printStackTrace();

    }

    }

    if(flag == false){

    res = new ValidResult(sb.toString(),"1");

    }else{

    res = new ValidResult("校验成功!","0");

    }

    return res;

    }

    }

    测试类:

    package com.zczy.test.Test;

    import com.zczy.test.bean.Person;

    import com.zczy.test.utils.CheckPointParamsHandlar;

    import com.zczy.test.utils.ValidResult;

    public class ParamsCheckTest {

    public static void main(String[] args) {

    Person person = new Person("1111","22","111");

    ValidResult paramChecksResults = new CheckPointParamsHandlar<>(person).getParamChecksResults();

    System.out.println(paramChecksResults.toString());

    }

    }

    结果:

    测试1:

    ec5f25595ce84c98f0a0235cb93bf288.png

    ec401e64ab892462b708ccb4d81c21f6.png

    测试2:

    dc9b296e0eca1e618487fbbcfaa07c3b.png

    325609a2a6ef2edb183311ae35cd967c.png

    测试3:

    579983c3ce34c8b0821b3cd55c91793f.png

    测试4:

    4164e06216f39afdde31c77831ad7ece.png

    本文地址:https://blog.csdn.net/trainhui/article/details/107336671

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 这个是用来验证表单传来的json对象里是否必填,如果值... * java反射机制判断对象所有属性是否全部为空 * @param obj * @return 返回属性名称 */ public static String checkObjFieldIsNotNull(Object obj,Stri
  • 1.自定义个注解类 @Target({ElementType.PARAMETER})//参数级别 @Retention(RetentionPolicy.RUNTIME) //注解保留到运行阶段 public @interface ParamsNotNull { } @Target 通俗讲,定义放在什么位置,这个是放在...
  • Hibernate 实体类 注解及功能说明。
  • java高级之注解

    2020-12-21 17:30:39
    注解相当一种标记,是的组成部分,可以给携带一些额外的信息。 注解可以加在包,,字段,方法,方法参数以及局部变量上。 注解是给编译器看的,编译器可以根据注解来完成对应的功能。 注解的作用:给程序带入...
  • 对Hibernate的实体类注解做了详细的说明
  • 这个实体类在属性上加入了注解@NotEmpty,@Length,那么常用的注解有: 约束注解名称 约束注解说明 @null 验证对象是否为空 @notnull 验证对象是否为非空 @asserttrue 验证 boolean 对象是否为 true @assertfalse ...
  • 如何判断一个对象的内容是否为空

    千次阅读 2021-02-28 19:04:52
    原因使用Controller的...搜索一番,找到一个不错的思路:利用反射获取所有字段,再判断内容是否为null。初步代码如下/*** 注意,如果order是null,也返回true。**@paramorder*@return*/private booleanisOrderAll...
  • 一、注解的基础 1.注解的定义:Java文件叫做Annotation,用@interface表示。 2.元注解:@interface上面按需要注解上一些东西,包括@Retention、@Target、@Document、@Inherited四种。 3.注解的保留策略: @Retention...
  • * @param demo 实体类 */ private static void defaultValue(Object demo) { try { Class<?> aClass = demo.getClass(); Field[] declaredFields = aClass.getDeclaredFields(); List<String> ...
  • Mybatis-plus实体类注解

    2022-04-21 10:22:03
    mybatis-plus实体类注解: 1、@TableName(value = …) 当数据库名与实体类名不一致或不符合驼峰命名时,需要在此注解指定表名 2、@TableId(type = …) 指定实体类的属性对应的主键,主要有以下几种: // ...
  • java实体类非空判断@NotEmpty、@NotNull等注解无效解决
  • 实体类中的注解

    千次阅读 2020-06-09 21:32:20
    实体类与其映射的数据库表名不同名时需要使用 @Table 标注说明,该标注与 @Entity 标注并列使用,置于实体类声明语句之前,可写于单独语句行,也可与声明语句同行。 @Table 标注的常用选项是 name,用于指明数据库...
  • JAVA学习1-注解

    2021-04-15 13:46:12
    1.实体类加上注解,比如: public class Student { @StringNull public String name=null; @StringNull public String xuehao=null; @StringNull public String sex=null; public void setName(String ...
  • spring 中对实体类字段校验注解@Valid 说明及使用 先看下注释说明: 注解 说明 @Null 限制只能null @NotNull 限制必须不null @AssertFalse 限制必须false @AssertTrue 限制必须true @...
  • 判断对象的某些属性是否为空

    万次阅读 多人点赞 2019-05-29 09:50:10
    背景:很多时候我们需要判断对象的某些属性中的值是否为空,然后进行操作,这里不需要整个的对象,只是需要获取对象中的某些属性进行判断,如果写很多的if进行判断,例如: if (StringUtils.isBlank(equipInfo....
  • java 实体类 代码生成器 带注释
  • 前面学习了如何自定义一个注解:java如何优雅的自定义一个注解 下面来实战演示一下... * 判断屬性不为空注解 */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface NotNull { /*
  • java自定义注解验证实体类

    千次阅读 2020-11-07 16:49:17
    * 实体检验自定义注解类 * @author 李 */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface ValidateEntity { public boolean required() default false;//是否检验null ...
  • 放入缓存的实体类在每个属性上加@Tag注释,根据Tag里面的值来进行序列化的,顺序一旦确定了就不能变,否则反序列化会找不到。 javax.validation.constraints 数据校验,会根据对应属性的注解对前端传入参数做判断,...
  • 1.注解类/**注解作用在方法上*/@Target({ElementType.METHOD})/**注解的生命周期一直程序运行时都存在VM运行期间保留注解,可以通过反射机制读取注解信息*/@Retention(RetentionPolicy.RUNTIME)/**注解包含在Javadoc...
  • 接口字段转实体是否为空判断

    千次阅读 2017-09-29 17:21:32
    在开发中如果需要和第三方进行接口交互,这时候对接口字段校验就是必不可少的,对方如果少传字段,或是必传字段为空,如果我们不做判断,很可能导致某个流程出错一般校验无非就是以下这种处理方式if(requestVo....
  • Java 反射判断类是否包含某个方法 Java反射判断类是否存在某个属性(字段) 一、前言 在java中,可以通过反射获取中的所有属性和方法,要判断类是否包含某个方法或某个属性,使用常见的 getMethod() / ...
  • 创建需要被校验的实体类 public class Foo { @NotBlank private String name; @Min(18) private Integer age; @Pattern(regexp = "^1(3|4|5|7|8)\\d{9}$",message = "手机号码格式错误") @NotBlank...
  • mybatis plus实体类注解使用

    万次阅读 2020-07-07 15:59:51
    mybatis plus实体类注解使用前言特性支持数据库框架结构@TableName@TableId@TableField@Version:乐观锁注解、标记@KeySequence:序列主键策略@EnumValue:通枚举类注解@TableLogic:表字段逻辑处理注解(逻辑删除)...
  • 实体类的验证

    千次阅读 2021-03-12 23:57:45
    ① 首先需要在实体类的相应字段上添加用于充当校验条件的注解,如:@Min,如下代码(age属于Girl类中的属性):@Min(value = 18,message = "未成年禁止入内")private Integer age;② 其次在controller层的方法的要校验...
  • springboot效验参数是否为空

    千次阅读 2021-01-05 15:34:59
    实体类 public class User{ @NotNull(message = "用户名不能为空") private String name; @NotNull(message="年龄不能为空") private Integer age; } Controller @Controller public class User2Controller {...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,149
精华内容 18,059
关键字:

判断实体类是否为空的注解

友情链接: Lcd12864.rar