Case: check the empty field [annotation + reflection + custom exception]

Learning never stops ！
A combination of annotations 、 Reflection 、 Small cases of custom exception knowledge —— Check for empty fields ！

1、 Define a specification class ： All fields that need to be checked need to be implemented

package com.dongzi;

/** *  Define standardized interfaces  */
public interface CheckRule {
    
}

2、 Define entity classes and implement standard interfaces ： Add CheckField annotation , The first 3 Item with code

package com.dongzi;

/** *  Simulate entity class  */
public class Student implements CheckRule {
    

    public Student() {
    

    }

    public Student(Integer id, Integer age, Integer sex, String name) {
    
        this.id = id;
        this.age = age;
        this.sex = sex;
        this.name = name;
    }

    private Integer id;

    @CheckField(message = " Student age ")
    private Integer age;

    private Integer sex;

    @CheckField(message = " The student's name ")
    private String name;

    public Integer getId() {
    
        return id;
    }

    public void setId(Integer id) {
    
        this.id = id;
    }

    public Integer getAge() {
    
        return age;
    }

    public void setAge(Integer age) {
    
        this.age = age;
    }

    public Integer getSex() {
    
        return sex;
    }

    public void setSex(Integer sex) {
    
        this.sex = sex;
    }

    public String getName() {
    
        return name;
    }

    public void setName(String name) {
    
        this.name = name;
    }
}

3、 Define check field annotations

package com.dongzi;

import java.lang.annotation.*;

/** *  Define the annotation of the check field  * <pre> * @Retention: Specify the runtime  * @Target: Specify the scope of the annotation  * </pre> */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface CheckField {
    

    /** *  Whether to open the field NULL Value check  * @return true  The default return check on field  */
    boolean value() default true;

    /** *  Field related description  */
    String message();
}

4、 Custom exception ： Check that the field is NULL Throw when

package com.dongzi;

/** *  Custom check exception  */
public class CheckException extends Exception{
    

    /** *  There is no special implementation to directly call the parent class construction  * @param msg  Exception message  */
    public CheckException(String msg){
    
        super(msg);
    }
}

5、 Define the check field tool class ： How to check fields

package com.dongzi;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/** *  Define exception checking tool classes  */
public class CommentUtils {
    

    /** *  Check the empty field tool class  * * @param checkRule  Need to be checked bean */
    public static void checkNonField(CheckRule checkRule) throws CheckException {
    
        Class<? extends CheckRule> beanClass = checkRule.getClass();
        Field[] fields = beanClass.getDeclaredFields();
        if (fields.length > 0) {
    
            for (Field field : fields) {
    
                CheckField checkField = field.getAnnotation(CheckField.class);
                if (checkField != null && checkField.value()) {
    
                    // field.setAccessible(true);
                    String fieldName = field.getName();
                    // TODO： No other tool classes have been introduced , temporarily replace 
                    char[] chars = fieldName.toCharArray();
                    chars[0] = Character.toUpperCase(chars[0]);
                    fieldName = String.copyValueOf(chars);
                    String methodName = "get" + fieldName;
                    Object objVal;
                    try {
    
                        objVal = beanClass.getMethod(methodName).invoke(checkRule);
                    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
    
                        // method invoke exception handling 
                    }

                    if (objVal == null || "".equals(objVal)) {
    
                        throw new CheckException(checkField.message() + ": Is required ");
                    }
                }
            }
        }
    }
}

6、 Program starts

package com.dongzi;

public class Main {
    

    public static void main(String[] args) {
    
        // Student student_1 = new Student(1, 23, 1, " Outlaw maniac —— Zhang San "); //  Output results ：~~~ Field is not NULL
        Student student_2 = new Student(1, null, 1, " Outlaw maniac —— Zhang San "); //  Output results ： Student age : Is required 

        try {
    
            CommentUtils.checkNonField(student_2);
            System.out.println("~~~ Field is not NULL");
        } catch (CheckException e) {
    
            e.printStackTrace();
        }

    }
}

7、 Two execution results

• Pass in student_1 object ：
  
• Pass in student_2 object ：
  
  Throw an exception ,NULL Field check complete ！ Can complete a Bean Check all non empty fields .

attach 1： Project structure

attach 2： About reflection execution efficiency

• Java Reflection efficiency analysis
• Java Some efficiency analysis of reflection