类转换

package zxc.utils;

import java.lang.reflect.Member;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.springframework.util.StringUtils;

import com.opensymphony.xwork2.inject.Inject;
import com.opensymphony.xwork2.util.ObjectTypeDeterminer;
import com.opensymphony.xwork2.util.XWorkBasicConverter;
import com.opensymphony.xwork2.util.XWorkConverter;

public class CustomShareConverter extends XWorkBasicConverter {
	public static final String		SEQUENCE_SEPARATOR	= ",";

	public static final String		MAP_SEPARATOR		= ":";

	private ObjectTypeDeterminer	objectTypeDeterminer;

	@Inject
	public void setObjectTypeDeterminer(ObjectTypeDeterminer det) {
		this.objectTypeDeterminer = det;
	}

	/**
	 * 这里的toType一定是一个在配置文件将此转换器作为它的转换器的类或者是String类
	 */
	@SuppressWarnings("unchecked")
	@Override
	public Object convertValue(Map context, Object target, Member member, String property, Object value, Class toType) {
		if (value == null || toType == String.class || ((String[]) value).length != 1) {
			//注意第一个条比较怪,具体解释是:1.如果为null交给超类;2.如果向前台转,也交给超类;
			//3.前台向后台转,且value不为null,但是前台传递同一个name多于一个值,则仍然使用超类转换
			return super.convertValue(context, target, member, property, value, toType);
		} 
		String strValue = ((String[]) value)[0];//我现存在认为只要前台传值至少会有一个元素,放在这个表达式在这里确认一下
		if (toType == Boolean.class) {
			if (value == null || !StringUtils.hasText(strValue) || "null".equals(strValue)) {
				return null;
			} else if ("true".equals(strValue) || "1".equals(strValue)) {
				return Boolean.TRUE;
			} else {//注意:除去true,1,与null全部返回false
				return Boolean.FALSE;
			}
		} else if (toType.isArray() || Collection.class.isAssignableFrom(toType)) {//向台向后台转,并且是单参数(即序列转数组)
			String sequence = strValue;
			if (!StringUtils.hasText(sequence)||"null".equals(sequence)) {
				return null;//对序列情况的处理
			}
			//这里重写了拆分逻辑
			value = new SequenceSplitor(sequence).split(SEQUENCE_SEPARATOR.charAt(0));
			return super.convertValue(context, target, member, property, value, toType);
		} else if (Map.class.isAssignableFrom(toType)) {
			//超类并没有给出对map情况的处理,这里直接将它处理掉,但是map中的成员仍然是依赖超类处理
			return convertToMap(context, target, member, property, value, toType);
		}
		
		throw new RuntimeException("预期外的类型");
	}

	//将一个序列转换成一个Map
	private Object convertToMap(Map<?, ?> context, Object target, Member member, String property, Object value, Class<?> toType) {
		String sequence = ((String[]) value)[0];
		String[] splitArray = new SequenceSplitor(sequence).split(SEQUENCE_SEPARATOR.charAt(0));

		Class<?> keyClass = String.class;
		Class<?> valueClass = String.class;
		if (target != null) {
			keyClass = this.objectTypeDeterminer.getKeyClass(target.getClass(), property);
			valueClass = this.objectTypeDeterminer.getElementClass(target.getClass(), property, null);
		}
		Map<Object, Object> map = createMap(context, target, member, property, value, toType, splitArray.length);
		for (int index = 0; index < splitArray.length; index++) {
			String keyValue = splitArray[index];
			//这里重写了拆分逻辑
			String[] keyValuePair = new SequenceSplitor(keyValue).split(MAP_SEPARATOR.charAt(0));
			//注意这个地方注入xworkConverter来进行转换,主要是怕遗漏Map中的键值有可能需要定制转换器,还有一点需要注意,传值使用字符串数组以模拟前台
			Object key = XWorkConverter.getInstance().convertValue(context, null, null, null, new String[] { keyValuePair[0] }, keyClass);
			Object val = XWorkConverter.getInstance().convertValue(context, null, null, null, new String[] { keyValuePair[1] }, valueClass);
			map.put(key, val);
		}

		return map;
	}

	private Map<Object, Object> createMap(Map<?, ?> context, Object target, Member member, String property, Object value, Class<?> toType, int size) {
		Map<Object, Object> map;
		if (toType == ConcurrentMap.class) {
			if (size > 0) {
				map = new ConcurrentHashMap<Object, Object>(size);
			} else {
				map = new ConcurrentHashMap<Object, Object>();
			}
		} else if (toType == SortedMap.class) {
			map = new TreeMap<Object, Object>();
		} else {
			if (size > 0) {
				map = new HashMap<Object, Object>(size);
			} else {
				map = new HashMap<Object, Object>();
			}
		}

		return map;
	}

}