使用反射机制对类字段进行选择性校验(java反射二)

      这是一个使用java反射机制对类字段进行校验的工具，在工厂类中定义map存储需要校验的类类型和该类中需要校验的字段，在校验类中使用反射获取相关类的字段并进行校验，多用于接口开发时对字段的校验。

1、定义三个常用类用于测试

package validation;

//测试用的动物类
public class Animal {
 private String animalName;
 private String animalColor;
 public String getAnimalName() {
  return animalName;
 }
 public void setAnimalName(String animalName) {
  this.animalName = animalName;
 }
 public String getAnimalColor() {
  return animalColor;
 }
 public void setAnimalColor(String animalColor) {
  this.animalColor = animalColor;
 }
}

package validation;

//测试用的水果类
public class Fruit {
 private String fruitKind;
 private String fruitColor;
 private String fruitAmount;
 public String getFruitKind() {
  return fruitKind;
 }
 public void setFruitKind(String fruitKind) {
  this.fruitKind = fruitKind;
 }
 public String getFruitColor() {
  return fruitColor;
 }
 public void setFruitColor(String fruitColor) {
  this.fruitColor = fruitColor;
 }
 public String getFruitamount() {
  return fruitAmount;
 }
 public void setFruitamount(String fruitamount) {
  this.fruitAmount = fruitamount;
 }
}

package validation;

//测试用的人物类
public class Person {
 private String personName;
 private String personSex;
 private String personAge;
 public String getPersonName() {
  return personName;
 }
 public void setPersonName(String personName) {
  this.personName = personName;
 }
 public String getPersonSex() {
  return personSex;
 }
 public void setPersonSex(String personSex) {
  this.personSex = personSex;
 }
 public String getPersonAge() {
  return personAge;
 }
 public void setPersonAge(String personAge) {
  this.personAge = personAge;
 } 
}

二、使用工厂类初始化需要校验的类和字段有哪些

package validation;

import java.util.HashMap;
import java.util.Map;
/**
 * 注入需要校验的类类型的工厂类
 *
 */
public class ValidationDataMapFactory {
 private Map<String, Map<String, String>> beanTransationMap;
 private static ValidationDataMapFactory validationDataMapFactory;
 //使用构造方法初始化所需Map,在对象被创建时初始化
 public ValidationDataMapFactory(){
  initBeanTransationMap();
 }
 //单例模式初始化对象
 public static ValidationDataMapFactory newInstance(){
  if(validationDataMapFactory == null){
   validationDataMapFactory = new ValidationDataMapFactory();
  }
  return validationDataMapFactory;
 }
 public Map<String, Map<String, String>> getBeanTransationMap(){
  return this.beanTransationMap;
 }
 //初始化map，用于存储哪些类和字段需要校验
 private void initBeanTransationMap(){
  if(beanTransationMap == null){
   this.beanTransationMap = new HashMap<String, Map<String,String>>();
  }
  this.beanTransationMap.put(Person.class.getName(), addPersonTransationMap());
  this.beanTransationMap.put(Animal.class.getName(), addAnimalTransationMap());
  this.beanTransationMap.put(Fruit.class.getName(), addFruitTransationMap());
 }
 
 private Map<String, String> addPersonTransationMap(){
  Map<String, String> personTransationMap = new HashMap<String, String>();
  personTransationMap.put("personName", "人员名称");
  personTransationMap.put("personAge", "人员年龄");
  return personTransationMap;
 }
 private Map<String, String> addAnimalTransationMap(){
  Map<String, String> animalTransationMap = new HashMap<String, String>();
  animalTransationMap.put("animalName", "动物名");
  animalTransationMap.put("animalColor", "动物颜色");
  return animalTransationMap;
 }
 private Map<String, String> addFruitTransationMap(){
  Map<String, String> fruitTransationMap = new HashMap<String, String>();
  fruitTransationMap.put("fruitKind", "水果种类");
  fruitTransationMap.put("fruitAmount", "水果数量");
  return fruitTransationMap;
 }
}

三、使用反射获取需要校验的类的字段进行校验

package validation;


import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
 * 校验规则类
 */
public class ValidationEmptyData {

 /**校验bean字段中文转义map**/
 private Map<String, Map<String, String>> beanTransationMap;

 public ValidationEmptyData(Map<String,Map<String, String>> beanTransationMap){
  this.beanTransationMap = beanTransationMap;
 }

 /**
  * 校验自定义的并且需要校验的javaBean中的字段不能为空
  * @param bean 要进行校验的javaBean
  * @throws Exception 
  * @throws  
  */
 @SuppressWarnings("rawtypes")
 public void validationEmptyData(Object bean) throws Exception{
  Class clazz = bean.getClass();
  if(haveValidation(clazz)){
   validationBeanField(clazz.getDeclaredFields(), bean, clazz);
  }

 }
 
 /**
  * 校验bean中的字段
  * @param fields 属性字段
  * @param bean 要进行校验的bean
  * @param beanClass 要进行校验bean的Class
  * @throws Exception
  */
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public void validationBeanField(Field[] fields, Object bean, Class beanClass) throws Exception{

  Class superClazz = beanClass.getSuperclass();
  //获取包括其父类在内的所有字段

  if(null != superClazz && haveValidation(superClazz)){
   validationBeanField(superClazz.getDeclaredFields(),bean, superClazz);
  }
  Map<String, String> fieldTransationMap = getFieldTransationMap(beanClass.getName());
  if(null != fields && fields.length > 0){
   for(Field field : fields){
    field.setAccessible(true);
    String fieldName = field.getName();
    Class fieldClass = field.getType();
    Object fieldValue = field.get(bean);
    if(fieldClass.isAssignableFrom(String.class)){
     if(isEmptyString((String)fieldValue)){
      throwEmptyException(fieldName,fieldTransationMap);
     }
    }else if(fieldClass.isArray()){
     validationArray(fieldValue,fieldName, fieldTransationMap);
    }else if(fieldClass.isAssignableFrom(List.class)){
     validationList(fieldValue,fieldName, fieldTransationMap);
    }else if(fieldClass.isAssignableFrom(Map.class)){
     validationMap(fieldValue,fieldName, fieldTransationMap);
    }else{
     if(isNullObject(fieldValue)){
      throwEmptyException(fieldName,fieldTransationMap);
     }
    }
   }
  }
 }

 /**
  * 校验Map中的字段
  * @param map
  * @param fieldName
  * @param fieldTransationMap
  * @throws Exception
  */
 @SuppressWarnings("rawtypes")
 public void validationMap(Object map, String fieldName,Map<String, String> fieldTransationMap) throws Exception{
  if(!isNullObject(map) && !(((Map)map).isEmpty())){
   Iterator ite = ((Map)map).keySet().iterator();
   while(ite.hasNext()){
    Object obj = ((Map)map).get(ite.next());
    if(null != obj && haveValidation(obj.getClass())){
     validationEmptyData(obj);
    }else if(null != obj){
     validationObject(obj, fieldName, fieldTransationMap);
    }
   }
  }else{
   throwEmptyException(fieldName, fieldTransationMap);
  }
 }

 /**
  * 校验list中的值
  * @param list
  * @param fieldName
  * @param fieldTransationMap
  * @throws Exception
  */
 @SuppressWarnings("rawtypes")
 public void validationList(Object list, String fieldName, Map<String, String> fieldTransationMap) throws Exception{
  if(!isNullObject(list)){
   validationArray(((List)list).toArray(),fieldName, fieldTransationMap);
  }else{
   throwEmptyException(fieldName, fieldTransationMap);
  }
 }

 /**
  * 校验数组中的数据
  * @param array
  * @param fieldName
  * @param fieldTransationMap
  * @throws Exception
  */
 public void validationArray(Object array,String fieldName, Map<String, String> fieldTransationMap) throws Exception{
  if(!isNullObject(array) && (0 < ((Object[]) array).length)){
   for(Object obj : (Object[]) array){
    if(null != obj && haveValidation(obj.getClass())){
     validationEmptyData(obj);
    }else if(null != obj){
     validationObject(obj, fieldName, fieldTransationMap);
    }
   }
  }else{
   throwEmptyException(fieldName, fieldTransationMap);
  }
 }
 
 /**
  * 校验非自定义的对象
  * @param obj
  * @param fieldName
  * @param fieldTransationMap
  * @throws Exception
  */
 @SuppressWarnings({ "rawtypes", "unchecked" })
 private void validationObject(Object obj,String fieldName, Map<String, String> fieldTransationMap) throws Exception{
  if(null != obj){
   Class objClass = obj.getClass();
   if(objClass.isAssignableFrom(String.class)){
    if(isEmptyString((String)obj)){
     throwEmptyException(fieldName,fieldTransationMap);
    }
   }else if(objClass.isArray()){
    validationArray(obj,fieldName, fieldTransationMap);
   }else if(objClass.isAssignableFrom(List.class)){
    validationList(obj,fieldName, fieldTransationMap);
   }else if(objClass.isAssignableFrom(Map.class)){
    validationMap(obj,fieldName, fieldTransationMap);
   }else{
    if(isNullObject(obj)){
     throwEmptyException(fieldName,fieldTransationMap);
    }
   }
  }
 }

 /**
  * 抛出不能为空字段的错误提示
  * @param fieldName
  * @param fieldTransationMap
  * @throws Exception
  */
 public void throwEmptyException(String fieldName,Map<String, String> fieldTransationMap) throws Exception{
  if(null != fieldTransationMap && !fieldTransationMap.isEmpty() && fieldTransationMap.containsKey(fieldName)){
   throw new Exception("字段【"+fieldTransationMap.get(fieldName)+"("+fieldName+")"+"】不能为空！");
  }
 }

 /**
  * 判断该对象是否需要进行空值的判断
  * @param clazz
  * @return
  * @throws Exception
  */
 @SuppressWarnings("rawtypes")
 private boolean haveValidation(Class clazz) throws Exception{
  String className = clazz.getName();
  if(null == this.beanTransationMap || this.beanTransationMap.isEmpty()){
   throw new Exception("先初始化字段转义Map");
  }else if(this.beanTransationMap.containsKey(className)){
   return true;
  }else{
   return false;
  }
 }

 /**
  * 判断字符串是否为空
  * @param value
  * @return
  */
 private boolean isEmptyString(String value){

  if(isNullObject(value) || "".equals(value.trim()) || "null".equals(value.trim())){
   return true;
  }
  return false;
 }

 /**
  * 判断obj对象时是否为null
  * @param obj
  * @return
  */
 private boolean isNullObject(Object obj){
  if(null != obj){
   return false;
  }
  return true;
 }

 /**
  * 获得该className所对应的字段中文转义
  * @param className
  * @return
  * @throws Exception
  */
 private Map<String, String> getFieldTransationMap(String className) throws Exception{
  if(null != this.beanTransationMap && !this.beanTransationMap.isEmpty() && this.beanTransationMap.containsKey(className)){
   return this.beanTransationMap.get(className);
  }else{
   throw new Exception("请为"+className+"添加字段转义Map");
  }
 }
}

四、进行测试

package validation;
//测试Main类
public class ValidationDataMainTest {
 private static ValidationEmptyData validationEmptyData;
 public static void main(String[] args) throws Exception {
//  Person per = new Person();
//  per.setPersonName("kitty");
//  per.setPersonSex("nv");
//  getValidationEmptyData().validationEmptyData(per);
//  Animal ani = new Animal();
//  ani.setAnimalName("老虎");
//  getValidationEmptyData().validationEmptyData(ani);
  Fruit fru = new Fruit();
  fru.setFruitKind("香蕉");
  getValidationEmptyData().validationEmptyData(fru);
 }
 public static ValidationEmptyData getValidationEmptyData(){
  if(validationEmptyData == null){
   ValidationDataMapFactory cvdm = new ValidationDataMapFactory();
   validationEmptyData = new ValidationEmptyData(cvdm.getBeanTransationMap());
  }
  return validationEmptyData;
 }
}