copySimpleObject对象覆盖控制是否带null工具类

package com.test;

import java.util.Map;
import java.util.Date;
import java.util.List;
import java.util.HashMap;
import java.util.Iterator;
import java.util.ArrayList;
import java.math.BigDecimal;
import java.util.LinkedList;
import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;

public class copySimpleObject {

	private static final Object[] ZERO_OBJECT_ARRAY = new Object[0];
	private static Map<String, Method[]> methodMap = new ConcurrentHashMap();
	private static Map<Class, String> supportTypeMap = new HashMap();

	public static void copySimpleObject(Object target, Object source,
			boolean isCopyNull) {
		Method method;
		if ((target == null) || (source == null)) {
			return;
		}
		List targetMethodList = getSetter(target.getClass());
		List sourceMethodList = getGetter(source.getClass());
		Map map = new HashMap();

		for (Iterator iter = sourceMethodList.iterator(); iter.hasNext();) {
			method = (Method) iter.next();
			map.put(method.getName(), method);
		}
		Object value = null;
		Object[] objArray = new Object[1];

		StringBuilder sb = new StringBuilder();

		for (Iterator iter = targetMethodList.iterator(); iter.hasNext();) {
			method = (Method) iter.next();
			String fieldName = method.getName().substring(3);
			try {
				Method sourceMethod;
				do
					do {
						sb.setLength(0);
						sb.append("get").append(fieldName);
						sourceMethod = (Method) map.get(sb.toString());
						if (sourceMethod == null) {
							sb.setLength(0);
							sb.append("is").append(fieldName);
							sourceMethod = (Method) map.get(sb.toString());
						}
					} while (sourceMethod == null);

				while (!(supportTypeMap.containsKey(sourceMethod
						.getReturnType())));

				value = sourceMethod.invoke(source, ZERO_OBJECT_ARRAY);
				if (isCopyNull) {
					objArray[0] = value;
					method.invoke(target, objArray);
				} else if (value != null) {
					objArray[0] = value;
					method.invoke(target, objArray);
				}
			} catch (Exception e) {
				System.out.println("123");
			}
		}
	}

	public static List<Method> getSetter(Class cl) {
		Method[] list = getMethods(cl);
		List resultList = new ArrayList();

		for (Method method : list) {
			String methodName = method.getName();
			if (methodName.length() < 3) {
				continue;
			}
			if (method.getParameterTypes().length != 1) {
				continue;
			}

			if ((methodName.charAt(0) != 's') || (methodName.charAt(1) != 'e')
					|| (methodName.charAt(2) != 't'))
				continue;
			resultList.add(method);
		}

		return resultList;
	}

	public static List<Method> getGetter(Class cl) {
		Method[] list = getMethods(cl);
		List resultList = new ArrayList();

		for (Method method : list) {
			String methodName = method.getName();
			if (methodName.length() < 3) {
				continue;
			}
			if (method.getParameterTypes().length != 0) {
				continue;
			}
			if ((methodName.charAt(0) == 'g') && (methodName.charAt(1) == 'e')
					&& (methodName.charAt(2) == 't')) {
				resultList.add(method);
			} else {
				if ((methodName.charAt(0) != 'i')
						|| (methodName.charAt(1) != 's'))
					continue;
				resultList.add(method);
			}
		}
		return resultList;
	}

	public static Method[] getMethods(Class cl) {
		initClassMethod(cl);
		return ((Method[]) methodMap.get(cl.getName()));
	}

	private static void initClassMethod(Class cl) {
		String key = cl.getName();
		if (methodMap.containsKey(key)) {
			return;
		}
		Map map = new HashMap();
		List list = new LinkedList();
		initClassMethodInner(cl, list, map);
		Method[] methods = new Method[list.size()];
		list.toArray(methods);
		methodMap.put(key, methods);
	}

	private static void initClassMethodInner(Class cl, List<Method> list,
			Map<String, String> map) {
		Method[] methods = cl.getDeclaredMethods();
		int size = methods.length;

		for (int i = 0; i < size; ++i) {
			Method method = methods[i];
			String key = method.toString();
			if (map.containsKey(key)) {
				continue;
			}
			map.put(key, null);
			list.add(method);
		}
		Class superClass = cl;
		while (true) {
			superClass = superClass.getSuperclass();
			if (superClass == Object.class) {
				return;
			}
			initClassMethodInner(superClass, list, map);
		}
	}

	static {
		supportTypeMap.put(Integer.class, "");
		supportTypeMap.put(Long.class, "");
		supportTypeMap.put(Double.class, "");
		supportTypeMap.put(BigDecimal.class, "");
		supportTypeMap.put(String.class, "");
		supportTypeMap.put(Date.class, "");
		supportTypeMap.put(Boolean.class, "");
	}
}