org.tinygroup.context2object.impl.ClassNameObjectGeneratorWithException Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.tinygroup.context2object Show documentation
There is a newer version: 3.0.0
Show newest version
package org.tinygroup.context2object.impl;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.tinygroup.commons.tools.StringUtil;
import org.tinygroup.context.Context;
import org.tinygroup.context2object.ObjectAssembly;
import org.tinygroup.context2object.ObjectGenerator;
import org.tinygroup.context2object.TypeConverter;
import org.tinygroup.context2object.config.BasicTypeConverter;
import org.tinygroup.logger.LogLevel;
import org.tinygroup.logger.Logger;
import org.tinygroup.logger.LoggerFactory;

public class ClassNameObjectGeneratorWithException extends
		BaseClassNameObjectGenerator implements ObjectGenerator {
	private static final Logger LOGGER = LoggerFactory
			.getLogger(ClassNameObjectGeneratorWithException.class);
	private Map>> typeConverterMap = new HashMap>>();

	public Object getObject(String varName, String bean, String className,
			ClassLoader loader, Context context) {
		if (StringUtil.isBlank(className) && StringUtil.isBlank(bean)) {
			throw new RuntimeException("传入的className和beanID不可同时为空");
		}
		Object o = null;
		Class clazz = null;
		if (bean != null) { // 以bean为优先
			o = getInstanceBySpringBean(bean);
			clazz = o.getClass();
		} else {
			// 如果传入的className不为空
			clazz = getClazz(className, loader);
		}
		Object parseResult = getObject(null, varName, clazz, loader, context);
		if (parseResult == null) {
			return o;
		}
		return parseResult;
	}

	private Object checkIsSameType(String preName, String varName,
			String propertyName, Class clazz, Context context) {
		Object value = getPerpertyValue( preName, varName,propertyName, context);
		if (value != null && value.getClass() == clazz) {
			return value;
		}
		return null;
	}

	private Object getObject(String preName, String varName, Class clazz,
			ClassLoader loader, Context context) {
		Object value = checkIsSameType(null, preName, varName, clazz, context);
		if(value!=null){
			return value;
		}
		List> typeConverterList = getTypeConverterList(clazz);
		if (typeConverterList != null) {// 如果存在typeConverter
			if (value == null) {
				LOGGER.logMessage(LogLevel.WARN, "类型:{0}在上下文中的变量名:{1}值为null",
						clazz, varName);
				return typeConverterList.get(0).getObject(null);
			}
			for (TypeConverter typeConverter : typeConverterList) {
				if (value.getClass() == typeConverter.getSourceType()) {
					return typeConverter.getObject(value);
				}
			}
			// throw new
			// RuntimeException("未从已有的类型转换器中找到合适的转换器，目标类型:"+className+",值:"+value+",类型:"+value.getClass());
		}
		// 没有找到合适的转换器类型，继续执行
		// 处理基本类型
		if (isSimpleType(clazz)) {
			return getSimpleTypeValue(
					getReallyPropertyName(null, preName, varName), clazz,
					context);
		} else {
			// 处理对象
			Object o = getObjectInstance(clazz);
			Object result = buildObject(preName, varName, o, loader, context);
			return result;
		}
	}

	/**
	 * 到了这一步 object对应的类型，既不是数组、集合、基本类型，同时也不存在转换器 只能进行解析拼装
	 */
	private Object buildObject(String preName, String varName, Object object,
			ClassLoader loader, Context context) {
		String objName = varName;
		Class clazz = object.getClass();
		ObjectAssembly assembly = getObjectAssembly(object.getClass());
		if (assembly != null) {
			assembly.assemble(varName, object, context);
			return object;
		}
		boolean allPropertyNull = true;
		if (isNull(objName)) {
			objName = getObjName(object);
		}
		for (PropertyDescriptor descriptor : PropertyUtils
				.getPropertyDescriptors(object.getClass())) {
			Class propertyType = descriptor.getPropertyType();
			String propertyName = descriptor.getName();
			if (propertyType.equals(Class.class)) {
				continue;
			}
			Object propertyValue = checkIsSameType(preName, varName,
					propertyName, propertyType, context);
			if (propertyValue != null) {
				try {
					BeanUtils.setProperty(object, descriptor.getName(),
							propertyValue);
					allPropertyNull = false;
					continue;
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
			}

			if (implmentInterface(propertyType, Collection.class)) {
				// 如果是集合类型
				Field field = getDeclaredFieldWithParent(clazz, propertyName);
				if (field == null) {
					LOGGER.logMessage(LogLevel.WARN, "{}不存在字段{}",
							clazz.getName(), propertyName);
					continue;
				}
				String newPreName = getReallyPropertyName(preName, objName,
						propertyName);
				Class type = field.getType();
				ParameterizedType pt = (ParameterizedType) field
						.getGenericType();
				Type[] actualTypeArguments = pt.getActualTypeArguments();
				Collection