反射与简单java类

通过反射解决多个属性赋值的重复。

属性自动赋值的思路实现

建议采用字符串的形式描述对应的内容。

1. String可以描述很多内容，所以先采用“属性：内容|属性：内容|……”
2. 构造一个工具类，用于属性的设置。
   传入Class<?> classname，String value 返回配置好属性内容的类

单级属性赋值

所给数据类型没有了其他引用关联，只描述了classname本身的对象，这样的设计称为单级属性设计。
注：如果要用反射，类中必须含有无参构造（规范，不是规则）

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

public class SingleLevel {

	public static void main(String[] args) {
		String value="msg:这是啥|active:get";
		QQMessage mm=ClassInstanceFactory.create(QQMessage.class,value);
		System.out.println("信息："+mm.getMsg()+"，发送方法："+mm.getActive());
	}

}
class ClassInstanceFactory{
	private ClassInstanceFactory() {}
	public static <T> T create(Class<?> cla,String value) {
		try {
			Object obj=cla.getDeclaredConstructor().newInstance();
			Beanutil.setValue(obj, value);
			return (T)obj;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}
class Finalutil{
	private Finalutil() {}
	public static String initcap(String str) {
		if(str==null||"".equals(str)) {
			return null;
		}else if(str.length()==1) {
			return str.toUpperCase();
		}else {
			return str.substring(0,1).toUpperCase()+str.substring(1);
		}
	}
}
class Beanutil{
	private Beanutil() {}
	
	public static void setValue(Object obj,String value) {
		String results[]=value.split("\\|");
		for(int i=0;i<results.length;i++) {
			String temp[]=results[i].split(":");
			try {
				Field fie=obj.getClass().getDeclaredField(temp[0]);
				Method setmeth=obj.getClass().getDeclaredMethod("set"+Finalutil.initcap(temp[0]), fie.getType());
				setmeth.invoke(obj, temp[1]);
			}catch(Exception e) {
				
			}
		}
	}
}
class QQMessage{
	private String msg=null;
	private String active=null;
	public String name="QQ";
	public QQMessage() {
		System.out.println("constructor!!!!!");
	}
	public QQMessage(String msg) {
		this.msg=msg;
		System.out.println(msg);
	}
	public void setMsg(String msg) {
		this.msg=msg;
	}
	public String getMsg() {
		return msg;
	}
	public void setActive(String act) {
		this.active=act;
	}
	public String getActive() {
		return active;
	}
	public void send() {
		System.out.println("QQ message");
	}
	public String toString() {
		return msg;
	}
}

拆开的优势在于可以对某块单独进行维护。

设置多种数据类型

class Beanutil{
	private Beanutil() {}
	//用于完成属性赋值处理
	public static void setValue(Object obj,String value) {
		String results[]=value.split("\\|");
		for(int i=0;i<results.length;i++) {
			String temp[]=results[i].split(":");
			try {
				Field fie=obj.getClass().getDeclaredField(temp[0]);
				Method setmeth=obj.getClass().getDeclaredMethod("set"+Finalutil.initcap(temp[0]), fie.getType());
				Object val=Beanutil.convertFinaltype(fie.getType().getName(), temp[1]);
				setmeth.invoke(obj, val);
			}catch(Exception e) {
				
			}
		}
	}
	//实现属性类型转换
	private static Object convertFinaltype(String type,String value) {
		if("long".equals(type)||"java.lang.Long".equals(type)) {
			return Long.parseLong(value);
		}else if("int".equals(type)||"java.lang.int".equals(type)) {
			return Integer.parseInt(value);
		}else if("double".equals(type)||"java.lang.Double".equals(value)) {
			return Double.parseDouble(value);
		}else if("Date".equals(type)||"java.util.Date".equals(value)) {
			SimpleDateFormat sdf=null;
			if(value.matches("\\d{4}-\\d{2}-\\d{2}[ \\d{2}:\\d{2}:\\d{2}]")) {
				sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
			}else {
				return new Date();
			}
			try {
				return sdf.parse(value);
			} catch (ParseException e) {
				return new Date();
			}
		}else {
			return value;
		}
	}
}

联级对象实例化及其属性赋值

	public static void setValue(Object obj,String value) {
		String results[]=value.split("\\|");
		for(int i=0;i<results.length;i++) {
			String temp[]=results[i].split(":");
			try {
				if(temp[0].contains(".")) {//多级配置
					String levels[]=temp[0].split(".");
					Object currentObject=obj;//用于传递调用
					for(int x=0;x<levels.length-1;x++) {
//						System.out.println(levels[x]);
						Method meth=currentObject.getClass().getDeclaredMethod("get"+Finalutil.initcap(levels[x]));
						Object tempObject=meth.invoke(currentObject);
						if(tempObject==null) {
							Field field=currentObject.getClass().getDeclaredField(levels[x]);
							Method setMethod=obj.getClass().getDeclaredMethod("set"+Finalutil.initcap(levels[x]),field.getType());
							currentObject=setMethod.invoke(currentObject,field.getType().getConstructor().newInstance());
						}else {
							currentObject=tempObject;
						}
					}
					//设置属性
					Field fie=obj.getClass().getDeclaredField(levels[levels.length-1]);
					Method setmeth=obj.getClass().getDeclaredMethod("set"+Finalutil.initcap(levels[levels.length-1]), fie.getType());
					Object val=Beanutil.convertFinaltype(fie.getType().getName(), temp[1]);
					setmeth.invoke(currentObject, val);
				}else {
					Field fie=obj.getClass().getDeclaredField(temp[0]);
					Method setmeth=obj.getClass().getDeclaredMethod("set"+Finalutil.initcap(temp[0]), fie.getType());
					Object val=Beanutil.convertFinaltype(fie.getType().getName(), temp[1]);
					setmeth.invoke(obj, val);
				}

			}catch(Exception e) {
				
			}
		}
	}