vvvvvvvvvvvv

package com.cv.framework.utils;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.cv.mvc.utils.Util;


public class PropertyUtil {
	
	private final static Resolver resolver = new Resolver();
	
	public static void setProperty(Object bean, String name , Object value) throws Exception
	{
		if (bean == null || name == null) {
            return;
        }
        // Resolve nested references
        while (resolver.hasNested(name)) {
            String next = resolver.next(name);
            Object nestedBean = null;
            if(bean instanceof Map)
            {
            	nestedBean = getMappedProperty((Map)bean, next);
            } else if(bean instanceof PropertyGetter){
                nestedBean = getSimpleProperty((PropertyGetter)bean, next);
            } else if (resolver.isMapped(next)) {
                nestedBean = getMappedProperty(bean, next);
            } else if (resolver.isIndexed(next)) {
                nestedBean = getIndexedProperty(bean, next);
            }else {
                nestedBean = getSimpleProperty(bean, next);
            }
            //System.out.println(nestedBean);
            if (nestedBean == null || name == null) {
                return;
            }
            bean = nestedBean;
            name = resolver.remove(name);
        }
        //System.out.println(bean+"-"+name);
        if(bean instanceof Map)
        {
        	setMappedProperty((Map)bean, name ,value);
        }else if (resolver.isMapped(name)) {
            setMappedProperty(bean, name ,value);
        } else if (resolver.isIndexed(name)) {
             setIndexedProperty(bean, name ,value);
        } else if(bean instanceof PropertySetter){
        	 setSimpleProperty((PropertySetter)bean, name ,value);
        } else {
             setSimpleProperty(bean, name ,value);
        }
	}
	
	

	


	private static void setMappedProperty(Map bean, String propertyName, Object value) {
		
		String key = resolver.getKey(propertyName);
		propertyName = resolver.getProperty(propertyName);
		if(Util.isEmpty(propertyName))
		{
			propertyName = key;
			key = null;
		}
		
		Object obj = bean.get(propertyName);
		
		if(!Util.isEmpty(key))
		{
			Object map = bean.get(propertyName);
			//自动构建
			if(map == null)
			{
				Map subMap = new HashMap(1);
				subMap.put(key, value);
				bean.put(propertyName, subMap);
			}else if(map instanceof Map){
				((Map)map).put(key, value);
			}
		}else{
			bean.put(propertyName, value);
		}
		
	}
	private static void setMappedProperty(Object bean, String propertyName, Object value) {
		String key  = null;
        try {
            key = resolver.getKey(propertyName);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException
                    ("Invalid mapped property '" + propertyName +
                    "' on bean class '" + bean.getClass() + "' " + e.getMessage());
        }
        if (key == null) {
            throw new IllegalArgumentException("Invalid mapped property '" +
            		propertyName + "' on bean class '" + bean.getClass() + "'");
        }
        ((Map)bean).put(propertyName, value);
	}
	private static void setSimpleProperty(PropertySetter bean, String name,Object value) throws Exception {
		bean.set(name, value);
	}
	private static void setSimpleProperty(Object bean, String name, Object value) throws Exception {
		PropertyDescriptor des = new PropertyDescriptor(name, bean.getClass());
		des.getWriteMethod().invoke(bean, new Object[]{TypeUtil.toValue(des.getReadMethod().getReturnType(),value)});
	}



	private static void setIndexedProperty(Object bean, String name,
			Object value) throws Exception {
		int index = -1;
        try {
            index = resolver.getIndex(name);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid indexed property '" +
                    name + "' on bean class '" + bean.getClass() + "' " +
                    e.getMessage());
        }
        if (index < 0) {
            throw new IllegalArgumentException("Invalid indexed property '" +
                    name + "' on bean class '" + bean.getClass() + "'");
        }
        name = resolver.getProperty(name);
        if (!Util.isEmpty(name))
        {
        	setProperty(bean, name ,value);
        }
        if (bean.getClass().isArray()) {
            Array.set(bean, index, value);
        } else if (bean instanceof List) {
            ((List)bean).set(index, value);
        }
		
	}

	/**
	 * @param bean
	 * @param name
	 * @return
	 * @throws NoSuchMethodException
	 * @throws Exception
	 */
	public static Object getProperty(Object bean, String name) throws NoSuchMethodException, Exception
	{
		if (bean == null || name == null) {
            return null;
        }
        // Resolve nested references
        while (resolver.hasNested(name)) {
            String next = resolver.next(name);
            Object nestedBean = null;
            if(bean instanceof Map)
            {
            	nestedBean = getMappedProperty((Map)bean, next);
            }else if (resolver.isMapped(next)) {
                nestedBean = getMappedProperty(bean, next);
            } else if (resolver.isIndexed(next)) {
                nestedBean = getIndexedProperty(bean, next);
            } else if(bean instanceof PropertyGetter){
                nestedBean = getSimpleProperty((PropertyGetter)bean, next);
            } else {
                nestedBean = getSimpleProperty(bean, next);
            }
           
            if (bean == null || name == null) {
                return null;
            }
            
            bean = nestedBean;
            name = resolver.remove(name);
        }
        if(bean instanceof Map)
        {
        	bean = getMappedProperty((Map)bean, name);
        }else if (resolver.isMapped(name)) {
            bean = getMappedProperty(bean, name);
        } else if (resolver.isIndexed(name)) {
            bean = getIndexedProperty(bean, name);
        } else if(bean instanceof PropertyGetter){
        	bean = getSimpleProperty((PropertyGetter)bean, name);
        } else {
            bean = getSimpleProperty(bean, name);
        }
        return bean;
		
	}
	private static Object getSimpleProperty(PropertyGetter bean, String name) throws Exception {
		return bean.get(name);
	}
	private static Object getSimpleProperty(Object bean, String name) throws Exception, NoSuchMethodException {
		Method method = bean.getClass().getMethod("get"+Character.toUpperCase(name.charAt(0))+name.substring(1), new Class[]{});
		return method.invoke(bean, null);
	}
	private static Object getIndexedProperty(Object bean, String name) throws NoSuchMethodException, Exception {
		int index = -1;
        try {
            index = resolver.getIndex(name);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid indexed property '" +
                    name + "' on bean class '" + bean.getClass() + "' " +
                    e.getMessage());
        }
        if (index < 0) {
            throw new IllegalArgumentException("Invalid indexed property '" +
                    name + "' on bean class '" + bean.getClass() + "'");
        }

        // Isolate the name
        name = resolver.getProperty(name);
        if (!Util.isEmpty(name))
        {
        	bean = getProperty(bean, name);
        }
        if (bean.getClass().isArray()) {
            return Array.get(bean, index);
        } else if (bean instanceof List) {
            return ((List)bean).get(index);   
        }
        
		return null;
	}
	private static Object getMappedProperty(Map bean, String propertyName) throws InstantiationException, IllegalAccessException {
		
		int index = resolver.getIndex(propertyName);
		String key = null;
		if (index!=-1 || resolver.isMapped(propertyName)) {
			key = resolver.getKey(propertyName);
			propertyName = resolver.getProperty(propertyName);
			if(Util.isEmpty(propertyName))
			{
				propertyName = key;
				key = null;
			}
        }
		
		Object obj = bean.get(propertyName);
		if((obj instanceof Map) && !Util.isEmpty(key))
		{
			obj = ((Map)obj).get(key);
		}
		
		if(index == -1)return obj;
		if(obj.getClass().isArray())
		{
			int len = Array.getLength(obj);
			//超出最大长度
			if(index >= len)
			{
				Object newArr =  Array.newInstance(obj.getClass().getComponentType(), index+1);
				System.arraycopy(obj, 0, newArr, 0, len);
				Object newObj = newArr.getClass().getComponentType().newInstance();
				Array.set(newArr, index, newObj);
				obj = newArr;
				bean.put(propertyName, obj);
				return newObj;
			}
			
			return Array.get(obj, index);
		}else if(List.class.isAssignableFrom(obj.getClass())){
			List list = (List)obj;
			//超出最大长度
			if(index >= list.size())return null;
			
			return list.get(index);
		}
		return null;
	}
	private static Object getMappedProperty(Object bean, String propertyName) {
		
		String key  = null;
        try {
            key = resolver.getKey(propertyName);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException
                    ("Invalid mapped property '" + propertyName +
                    "' on bean class '" + bean.getClass() + "' " + e.getMessage());
        }
        if (key == null) {
            throw new IllegalArgumentException("Invalid mapped property '" +
            		propertyName + "' on bean class '" + bean.getClass() + "'");
        }
        
        return ((Map)bean).get(key);
	}
	

	public static interface PropertyGetter{
		public Object get(String key) throws Exception;
	}
	public static interface PropertySetter{
		public void set(String key , Object value) throws Exception;
	}
}