版权声明:转载请注明原创 https://blog.csdn.net/qq_42151769/article/details/89853930
自定义注解:
@NotEmpty
package com.hf.autocheck.annotation;
import java.lang.annotation.*;
/**
* @Description: 非空注解
* @Date: 2019/5/5
* @Auther:
*/
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NotEmpty {
String value();
}
@NotEmptyIn 改注解用来,属性是另外一个对象的时候,打上改注解,则自动渗透进入该小对象的类型,获取含有@NotEmpty注解的字段,可以无限渗透(也就是递归进入获取)
package com.hf.autocheck.annotation;
import java.lang.annotation.*;
/**
* @Description: 用来渗透进入
* @Date: 2019/5/5
* @Auther:
*/
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NotEmptyIn {
}
封装一个返回结果,统一返回结果
package com.hf.autocheck.result;
/**
* @Description: 统一返回值
* @Date: 2019/5/5
* @Auther:
*/
public class Response<T> {
private Integer code;
private String msg;
private Boolean success;
private T data;
public Response(Integer code,Boolean success,String msg, T data) {
this.msg = msg;
this.data = data;
this.code = code;
this.success = success;
}
public Response() {
}
public static <T> Response createSuccess(String msg, T data){
return new Response(200,true,msg,data);
}
public static Response createSuccess(String msg){
return new Response(200,true,msg,null);
}
public static <T> Response createError(String msg,T data){
return new Response(500,false,msg,data);
}
public static Response createError(String msg){
return new Response(500,false,msg,null);
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Boolean isSuccess() {
return this.success;
}
public void setSuccess(Boolean success) {
this.success = success;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
常量枚举类:
package com.hf.autocheck.enums;
import org.springframework.util.CollectionUtils;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description:
* @Date: 2019/5/5
* @Auther:
*/
public enum ResultEnum {
PROPERTIES_CHECK_SUCCESS(10000,"字段校验成功"),
PROPERTIES_CHECK_ERROR(10001,"字段校验失败")
;
ResultEnum(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
private Integer code;
private String msg;
public String getMsg(){
return this.msg;
}
public String getMsg(Integer code){
List<ResultEnum> list = Arrays.stream(ResultEnum.values()).filter((ResultEnum var) -> null != code
&& var.code == code).limit(1).collect(Collectors.toList());
return CollectionUtils.isEmpty(list) ? null:list.get(0).getMsg();
}
}
处理注解的工具类:
package com.hf.autocheck.utils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @Description: 字段反射工具类
* @Date: 2019/5/5
* @Auther:
*/
public class FeildReflectUtil {
public static Field[] getAllFields(Class<?> clzz){
if(null == clzz){
return null;
}
List<Field> resultList = new ArrayList<>();
while(null != clzz){
resultList.addAll(new ArrayList<>(Arrays.asList(clzz.getDeclaredFields())));
//是否有继承类
clzz = clzz.getSuperclass();
}
Field[] resultArr = new Field[resultList.size()];
return resultList.toArray(resultArr);
}
}
package com.hf.autocheck.utils;
import com.hf.autocheck.annotation.NotEmpty;
import com.hf.autocheck.annotation.NotEmptyIn;
import com.hf.autocheck.enums.ResultEnum;
import com.hf.autocheck.result.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description: 校验字段非空
* @Date: 2019/4/30
* @Auther:
*/
public class PropertiesCheckUtil {
private static final Logger log = LoggerFactory.getLogger(PropertiesCheckUtil.class);
public static Response<String> autoCheck(Object target){
if(null == target){
return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_ERROR.getMsg());
}
Class<?> clzz = target.getClass();
Field[] fields = FeildReflectUtil.getAllFields(clzz);
//过滤字段
List<Field> list = Arrays.stream(fields).filter((Field var) -> !Modifier.isStatic(var.getModifiers()) && !Modifier.isFinal(var.getModifiers())).collect(Collectors.toList());
for (Field field : list) {
try {
Response<String> response = doCheck(field, target);
if(!response.isSuccess()){
return response;
}
} catch (Exception e) {
log.error("<autoCheck> check properties not empty error....{}" + e.getMessage(),e);
}
}
return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
}
private static Response<String> doCheck(Field field,Object target) throws Exception {
if(field.isAnnotationPresent(NotEmpty.class)){
Response response = autoMatch(field,target);
if(!response.isSuccess()){
return response;
}
}else if(field.isAnnotationPresent(NotEmptyIn.class)){
if(!field.isAccessible()){
field.setAccessible(true);
}
Response<String> response = deepToCheck(field, field.get(target));
if(!response.isSuccess()){
return response;
}
}else{
return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
}
return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
}
private static Response<String> deepToCheck(Field field,Object target) throws Exception {
if(null == target){
return Response.createError("<deepToCheck> deep object .... " + field.toGenericString() + " cannot be null...{}");
}
if(field.isAnnotationPresent(NotEmptyIn.class)){
//对有NotEmptyIn注解的字段层层深入,直到没有为止
Class<?> clzz = field.getType().newInstance().getClass();
Field[] fields = FeildReflectUtil.getAllFields(clzz);
//过滤字段
List<Field> list = Arrays.stream(fields).filter((Field var) -> !Modifier.isStatic(var.getModifiers()) && !Modifier.isFinal(var.getModifiers())).collect(Collectors.toList());
for (Field var : list) {
if(var.isAnnotationPresent(NotEmpty.class)){
Response response = autoMatch(var,target);
if(!response.isSuccess()){
return response;
}
}else if(var.isAnnotationPresent(NotEmptyIn.class)){
Class<? extends Class> c = var.getType().getClass();
//获取小对象的值
if(!var.isAccessible()){
var.setAccessible(true);
}
Object o = var.get(target);
Field[] varFields = FeildReflectUtil.getAllFields(clzz);
List<Field> varList = Arrays.stream(fields).filter((Field var2) -> !Modifier.isStatic(var2.getModifiers()) && !Modifier.isFinal(var2.getModifiers())).collect(Collectors.toList());
//递归查找
for (Field var1 : varList) {
Response<String> response = deepToCheck(var1, o);
if(!response.isSuccess()){
return response;
}
}
}
}
}
return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
}
/**
* 自动匹配对应的类型,用来做相应的处理
* @param
* @return
*/
private static Response autoMatch(Field field,Object target){
if(null == target){
return Response.createError(field.toGenericString() + "can not be null...");
}
//获取字段的类型的名称,在获取到对应的字节码(也就是类型的字节码对象)
Class clzz = field.getType().getName().getClass();
String value = field.getAnnotation(NotEmpty.class).value();
Object o = null;
try {
if(!field.isAccessible()){
field.setAccessible(true);
}
o = field.get(target);
} catch (IllegalAccessException e) {
log.error("<autoMatch> error....{}" + e.getMessage(),e);
}
if(o == null){
return Response.createError(value);
}
if(String.class == clzz){
if(StringUtils.isEmpty(o)){
return Response.createError(value);
}
}
return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
}
}
创建三个实体类,如下:
User.class
package com.hf.autocheck.model;
import com.hf.autocheck.annotation.NotEmpty;
import com.hf.autocheck.annotation.NotEmptyIn;
import java.io.Serializable;
/**
* @Description:
* @Date: 2019/5/5
* @Auther:
*/
public class User implements Serializable {
private static final long serialVersionUID = -6946551306395077514L;
@NotEmpty("姓名不能为空")
private String name;
@NotEmpty("性别不能为空")
private String gender;
@NotEmpty("年龄不能为空")
private Integer age;
@NotEmptyIn
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
Student.class:
package com.hf.autocheck.model;
import com.hf.autocheck.annotation.NotEmpty;
import com.hf.autocheck.annotation.NotEmptyIn;
import java.io.Serializable;
/**
* @Description:
* @Date: 2019/5/5
* @Auther:
*/
public class Student implements Serializable {
private static final long serialVersionUID = 2622208368622944597L;
@NotEmpty("学生姓名不能为空")
private String name;
@NotEmpty("学生班级不能为空")
private String className;
@NotEmpty("学生年龄不能为空")
private Integer age;
@NotEmptyIn
private Teacher teacher;
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
Teacher.class:
package com.hf.autocheck.model;
import com.hf.autocheck.annotation.NotEmpty;
import java.io.Serializable;
/**
* @Description:
* @Date: 2019/5/5
* @Auther:
*/
public class Teacher implements Serializable {
private static final long serialVersionUID = 3416746508578309442L;
@NotEmpty("教师名称不能为空")
private String name;
@NotEmpty("教师班级不能为空")
private String className;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
}
其对于的关系在类中已经很明显的显示出来了:
下面开始测试,测试类如下:
package com.hf.autocheck.test;
import com.hf.autocheck.model.Student;
import com.hf.autocheck.model.Teacher;
import com.hf.autocheck.model.User;
import com.hf.autocheck.result.Response;
import com.hf.autocheck.utils.PropertiesCheckUtil;
import org.junit.Test;
/**
* @Description:
* @Date: 2019/5/5
* @Auther:
*/
public class CheckTest {
@Test
public void tt(){
User user = new User(){{
setName("yu");
setGender("男");
setAge(11);
Student student = new Student();
student.setAge(12);
student.setClassName("3班");
student.setName("yy");
Teacher teacher = new Teacher();
teacher.setClassName("5班");
student.setTeacher(teacher);
setStudent(student);
}};
Response<String> response = PropertiesCheckUtil.autoCheck(user);
System.out.println(response.getMsg());
}
}
结果如下:
好了,就先写到这里了.....