物件賦值轉換

工具類：

　　

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class BeanUtils {
	
	/**
	 * transBean:(物件屬性轉換，將A物件的屬性賦值給B物件。
	 * 	前提要求：
	 * 	1:如A物件的方法：T getName() 那麼B物件的方法需要對應為：setName(T t);
	 * 	2:A物件T getName()的返回值型別必須為B物件的引數型別
	 *  3:B物件只能接收一個引數
	 *  4:傳入的最後一個引數沒有把它忽略
	 *  邏輯：
	 *  	1：遍歷A物件中所有方法
	 *  	2：遍歷B物件中所有方法
	 *  	得到方法名進行判斷 ：
	 *  		1：將A物件的方法名getName() 改成 setName();
	 *  		2：對比B方法是否含setName()
	 *  			如果沒有，此次迴圈結束
	 *  			如果有，繼續對比返回值型別。
	 *  				1：得到A物件getName()的返回值型別
	 *  				2：得到B物件setName()的返回值型別
	 *  				3：判斷型別是否一致
	 *  					如果不一致，此次迴圈結束 
	 *  					如果一致，將A物件的值賦給B物件
	 *  						1：執行呼叫getName()方法得到返回值 。
	 *  						2：執行呼叫setName()方法，完成賦值。
	 *  						賦值時如果有異常，需要招聘異常。
	 * @author xiangning
	 *
	 * @param bean1	帶有引數的物件A
	 * @param bean2	接收引數的物件B
	 * @param ignores	忽略轉換的屬性。引數為字串陣列,可變引數
	 * 傳入的引數可以為：
	 * 		BeanUtils.transBean(A, B , null);
	 * 		BeanUtils.transBean(A, B , "");
	 * 		BeanUtils.transBean(A, B , "age");
	 * 		BeanUtils.transBean(A, B , "age","name");
	 * 		BeanUtils.transBean(A, B , new String[0]);
	 * @throws Exception
	 */
	@Deprecated
	public static  void transBeanByMethodName(Object bean1,Object bean2,String... ignores) throws Exception {
		Method[] methods1 = bean1.getClass().getDeclaredMethods();
		Method[] methods2 = bean2.getClass().getDeclaredMethods();
		for (Method method1 : methods1) {
			String methodName1 = method1.getName();
			if(!methodName1.startsWith("get")) {
				continue;
			}
			for (Method method2 : methods2) {
				String methodName2 = method2.getName();
				boolean flag = false;
				if(!methodName2.startsWith("set")) {
					flag = true;;
				}
				String tempMethodName2 = methodName2.replace("set", "").toLowerCase();
				if(ignores != null) {
					for (int i=0 ; i < ignores.length; i++) {
						if(tempMethodName2.equals(ignores[i].toLowerCase())) {
							flag = true;
						}
					}
				}				
				if (flag) {
					continue;
				}
				if(methodName1.replaceFirst("get", "set").equals(methodName2)) {
					Type type = method1.getGenericReturnType();
					Type[] paramTypes = method2.getGenericParameterTypes();
					if (paramTypes.length > 1) {
						continue;
					}
					//System.out.println(paramTypes[0].getName());
					if(type.getTypeName().equals(paramTypes[0].getTypeName())) {
						Object obj = method1.invoke(bean1);
						method2.invoke(bean2,obj);
					}
				}
			}
		}
	}
	
	/**
	 * transBeanByAnnotation:(通過註解獲對屬性值進行轉換)
	 * @author xiangning
	 *
	 * @param bean1	帶有屬性值的物件A
	 * @param bean2	接收屬性值的物件B
	 * @param ignores	忽略傳值的屬性名，以註解@BeanTrans優先，其次是定義的屬性名
	 * @throws Exception
	 */
	public static  void transBeanByAnnotation(Object bean1,Object bean2,String... ignores) throws Exception{
		  Field[] fields1 = bean1.getClass().getDeclaredFields();
		  Field[] fields2 = bean2.getClass().getDeclaredFields();
		  List<Map<Field,Object>> list1 = new ArrayList<Map<Field,Object>>();
		  for (Field field1 : fields1) {
			  Map<String,Object> fieldMap1 = BeanUtils.getFieldInfo(field1, bean1);
			  boolean flag = false;
			  if(ignores!=null) {
				  for (String string : ignores) {
						if(fieldMap1.get("name").equals(string)) {
							flag = true;
						}
					  }
			  }
			  if(flag) {
				  continue;
			  }
			  for (Field field2 : fields2) {
				  Map<String,Object> fieldMap2 = BeanUtils.getFieldInfo(field2, bean2);
				  if(fieldMap1.get("name").equals(fieldMap2.get("name"))
						  && fieldMap1.get("typeName").equals(fieldMap2.get("typeName")) ){
					  //如果屬性名一樣，同時資料型別一樣那麼就可以將A物件的值賦給B物件
					  field2.set(bean2, fieldMap1.get("obj"));
				  }
			  }
			  
		  }
	}
	
	private static Map getFieldInfo(Field field,Object bean) throws Exception {
		Map<String,Object> fieldMap = new HashMap<String,Object>();
		field.setAccessible(true);
		  String fieldName = field.getName();
		  Object value = field.get(bean);
		  String typeName = field.getGenericType().getTypeName();
		  if(field.isAnnotationPresent(BeanTrans.class)) {
			  BeanTrans annotation = field.getAnnotation(BeanTrans.class);
			  fieldName = annotation.value();
		  }
		  fieldMap.put("name", fieldName);
		  fieldMap.put("obj", value);
		  fieldMap.put("typeName", typeName);
		return fieldMap;
	}

}

　

註解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface BeanTrans {
	public String value() default ""; 
}