對象賦值轉換

工具類：

　　

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 ""; 
}