前言

<<Java开发工具类>>是新开的一篇笔记系列，趁着现在有空了，把之前一年多工作，为了方便生产开发写的工具类给记一记并分享出来，如果有更好用的办法，欢迎随时在评论区提供见解，后续更新会贴上这些工具类的GitHub地址。

反射工具类

本工具类主要是针对了使用字段名来调用实体类为目的编写，就好比，前端经常会通过对象的属性名传输不同的内容给后端，但一般情况下，这个字段的数量有可能是多变的，也有可能是并非每一次都是同一个属性，当前批次可能只需要读出属性1的值，下一次便有可能是给属性2注入值。

代码

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import  java.lang.reflect.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import a.a.a.T;


import weblogic.deploy.beans.factory.InvalidTargetException;


public class ColInvoke {
	
	private  ColInvoke(){
		
	}
	
	
	/**
	 * get
	 *@param beanObj 实体类
	 *@param colName 要调用get的属性名
	 *@return 调用invoke
	 * @throws IntrospectionException 
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 * */
	public static Object getProperty(Object beanObj,String colName)throws IntrospectionException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		Method[] m = beanObj.getClass().getMethods();
		for(int i=0;i<m.length;i++){
			if(("get"+colName).toLowerCase().equals(m[i].getName().toLowerCase())){
				return m[i].invoke(beanObj);
			}
		}
		
		return null;	
	}
	
	/**
	 * set
	 *@param beanObj 实体类
	 *@param colName 要调用set的属性名
	 *@param value
	 * @throws NoSuchMethodException 
	 * @throws SecurityException 
	 * */
	public static void setProperty(Object beanObj,Class<?>clazz,String colName,Class<?> typeClass,Object value)throws IllegalArgumentException,IllegalAccessException,InvocationTargetException, IntrospectionException, SecurityException, NoSuchMethodException{
	
		colName = removeLine(colName);
		String methodName ="set"+colName.substring(0, 1).toUpperCase()+colName.substring(1);
		Method method = clazz.getDeclaredMethod(methodName, new Class[]{typeClass});
		method.invoke(beanObj, new Object[]{getClassTypeValue(typeClass,value)});
		
		
	}
	
	
	public static void roundingOffPoJo(Object obj) throws IllegalArgumentException, IllegalAccessException, SecurityException, InvocationTargetException, IntrospectionException, NoSuchMethodException{
		if(obj!=null){
		
			
			Class<?> clazz = (Class<?>)obj.getClass();
			
//			Field[] fs =getAllFields(clazz);
			
			Field[] fs =clazz.getDeclaredFields();
		
			for(int i=0;i<fs.length;i++){
				fs[i].setAccessible(true);
				
				String type =fs[i].getType().toString();
							
				if(type.equals("class java.lang.Double")){
					if(!isNull(obj,fs[i].getName().toString())){
						String valueDoubleStr =getProperty(obj,fs[i].getName().toString()).toString();
						Double valueDouble =Double.valueOf(valueDoubleStr);
						valueDouble = new BigDecimal(valueDouble).setScale(4, RoundingMode.HALF_UP).doubleValue();
						setProperty(obj,clazz,fs[i].getName().toString(),Double.class,valueDouble);
					}
				}
				
				
			}

			
		}
	}
	
	
	public  static Field[] getAllFields(Class<?> clazz){
		List<Field> list =new ArrayList();
		while(clazz!=null){
			list.addAll(new ArrayList(Arrays.asList(clazz.getDeclaredFields())));
			clazz =clazz.getSuperclass();
		}
		Field[] fields =new Field[list.size()];
		return list.toArray(fields);
	}
	
	
	
	
	/**
	 * 通过class类型获取对应类型的值
	 * @param typeClass class类型
	 * @param value值
	 * */
	private static Object getClassTypeValue(Class<?> typeClass,Object value){
		if(typeClass==int.class || value instanceof Integer){
			if(null == value){
				return 0;
			}
			return value;
		}else if(typeClass == short.class){
			if(null == value){
				return 0;
			}
			return value;
		}else if(typeClass == byte.class){
			if(null == value){
				return 0;
			}
			return value;
		}else if(typeClass == double.class){
			if(null == value){
				return 0;
			}
			return value;
		}else if(typeClass == long.class){
			if(null == value){
				return 0;
			}
			return value;
		}else if(typeClass == String.class){
			if(null == value){
				return "";
			}
			return value;
		}else if(typeClass == boolean.class){
			if(null == value){
				return true;
			}
			return value;
		}else if(typeClass == BigDecimal.class){
			if(null == value){
				return new BigDecimal(0);
			}
			return new BigDecimal(value+"");
		}else{
			return typeClass.cast(value);
		}
		
		
	}
	
	public static String removeLine(String str){
		if(null!=str && str.contains("_")){
			int i=str.indexOf("_");
			char ch=str.charAt(i+1);
			char newCh=(ch+"").substring(0,1).toUpperCase().toCharArray()[0];
			String newStr =str.replace(str.charAt(i+1), newCh);
			String newStr2 =newStr.replace("_", "");
			return newStr2;
		}
		return str;
	}
	
	
	/**
	 * 判断属性值是否为null
	 * @return true 为null
	 *         false 不为null
	 * */
	public static Boolean isNull(Object obj,String FieldName) throws IllegalArgumentException, IllegalAccessException{
		Boolean flag =false;
		
		if(obj!=null){
			Class<?> clazz = (Class<?>)obj.getClass();
			
			Field[] fs =clazz.getDeclaredFields();
			
			Method[] methods = clazz.getDeclaredMethods();
			
			for(Field f: fs){
				f.setAccessible(true);
				if(f.getName()==FieldName){
					Object val = f.get(obj);
					if(val!=null){
						break;
					}else{
						flag =true;
						break;
					}
				}
				
			}
			
		}
		return flag;
	}
	
	/**
	 * 获得属性值
	 * @throws NoSuchFieldException 
	 * @throws SecurityException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 * */
	public static String getVariable(Object  t , String variable) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{
		Class<?> beanClass =t.getClass();
		
		Field filed = beanClass.getDeclaredField(variable);
		
		filed.setAccessible(true);
		return filed.get(t).toString();
		
		
	}
	/**
	 * 空值/错误值 修正
	 * 主要针对于数值型的属性，统一将一些福错误值修改为0
	 * */
	public static void nullAndNaNToZero(Object obj) throws IllegalArgumentException, IntrospectionException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException{
	if(obj!=null){
		Class<?> cls = (Class<?>)obj.getClass();
		Field[] fld = cls.getDeclaredFields();
		for(int i=0;i<fld.length;i++){
			fld[i].setAccessible(true);
			String type = fld[i].getType().toString();
			if(type.equals("class java.lang.Double")){
				Object ob =getProperty(obj,fld[i].getName().toString());
				if(ob==null || ob.toString().equals("Infinity") || ob.toString().equals("-Infinity") || ob.toString().equals("NaN")||ob.toString().equals("Infinite or NaN")||ob.toString().equals("-Infinite or NaN")){
					setProperty(obj, cls, fld[i].getName().toString(), Double.class, 0.0);
				}
			}
		}
	}
}
}

用法

简单介绍一下其中几个常用函数的用法

//设置实体类属性值
void setProperty(Object beanObj,Class<?> clazz,String colName,Class<?> typeClass,Object value)
@Param  Object beanObj   => 实体类对象  即可 任意对象 pojo = new 任意对象（） 中的pojo
@Param  Class<?> clazz     => 实体类对象的class pojo.getClass()即可
@Param  String colName   =>要注入的属性名称
@Param  Object value    =>要注入的值

举例：
往Test中的 private Double v3 属性 注入 值5.4
Test pojo = new Test（）;
Class<?> clazz = (Class<?>) pojo.getClass();
ColInvoke .setProperty(pojo,clazz, “v3”,(double)5.4);

注意：由于注入值是Object类型，方法内部已经做了由输入值的类型进行自动转换，
但还是推荐在注入值时加入值的类型
比如，如果是一个Integer数据(int)5  Double数据(double)5.4  String类型数据”5.4”
以防注入时转换成与实体类属性不符合的类型而报错。

//实体类四舍五入余四位
public static void roundingOffPoJo(Object obj)

@Param Object obj => 实体类对象  即可 Test pojo = new Test （） 中的pojo 

举例：
往Test 中的各项Double类型属性自动四舍五入余4位数化
Test pojo = new Test （）;
ColInvoke.roundingOffPojo(pojo);

//获取实体类属性值
Object getProperty(Object beanObj,String colName)

@Param  Object beanObj   => 实体类对象  即可 任意对象 pojo = new 任意对象（） 中的pojo
@Param  String colName   => 实体类中的 属性名
@Param  Object 属性的值

举例：
读取Test中的 private Double v3 属性
Testpojo = new Test（）;
pojo.setV3（5.3）;
//方法一
Double value = (Double) ColInvoke.getProperty(pojo,“v3”);
//方法二
String valueDoubleStr = ColInvoke .getProperty(pojo, “v3”).toString();
Double valueDouble =Double.valueOf(valueDoubleStr);

后续

后续将会更新一下，关于Excel导入导出的工具类，会结合本反射工具类一起使用，打造一个利用注解读取Excel文件，便可映射进实体类中的一个工具。