Commons Collections学习笔记（四）

BeanMap这个Map类用于把一个javaBean转换为Map,在其中存储了javaBean的各个属性的setXXX方法和getXXX方法，属性的类型。

public class BeanMap extends AbstractMap implements Cloneable 
{
    private transient Object bean;//javaBean对象

    private transient HashMap readMethods = new HashMap();//getXXX方法集
    private transient HashMap writeMethods = new HashMap();//setXXX方法集
    private transient HashMap types = new HashMap();//成员变量类型集

    public static final Object[] NULL_ARGUMENTS = {};//空参数集，用于通过reflection调用getXXX方法
    public static HashMap defaultTransformers = new HashMap();//把基本类型映射为transformer类型，后者用于将字符串转换为合适的基本型的包装类
  
    //默认transformer
    static 
    {
        defaultTransformers.put( Boolean.TYPE, new Transformer() 
        {
                public Object transform( Object input ) 
                {
                    return Boolean.valueOf( input.toString() );
                }
            }
        );
        defaultTransformers.put( Character.TYPE, new Transformer() 
        {
                public Object transform( Object input ) 
                {
                    return new Character( input.toString().charAt( 0 ) );
                }
            }
        );
        defaultTransformers.put( Byte.TYPE, new Transformer() 
        {
                public Object transform( Object input ) 
                {
                    return Byte.valueOf( input.toString() );
                }
            }
        );
        defaultTransformers.put( Short.TYPE, new Transformer() 
        {
                public Object transform( Object input ) 
                {
                    return Short.valueOf( input.toString() );
                }
            }
        );
        defaultTransformers.put( 
            Integer.TYPE, 
            new Transformer() {
                public Object transform( Object input ) {
                    return Integer.valueOf( input.toString() );
                }
            }
        );
        defaultTransformers.put( Long.TYPE, new Transformer() 
        {
                public Object transform( Object input ) {
                    return Long.valueOf( input.toString() );
                }
            }
        );
        defaultTransformers.put( Float.TYPE, new Transformer() 
        {
                public Object transform( Object input ) {
                    return Float.valueOf( input.toString() );
                }
            }
        );
        defaultTransformers.put( Double.TYPE, new Transformer() 
        {
                public Object transform( Object input ) {
                    return Double.valueOf( input.toString() );
                }
            }
        );
    }

    public BeanMap(Object bean) {
        this.bean = bean;
        initialise();
    }


    public Object clone() throws CloneNotSupportedException {
        BeanMap newMap = (BeanMap)super.clone();

        if(bean == null) {//若底层bean不存在，则返回一个复制的空BeanMap,
            return newMap;
        }
        Object newBean = null;            
        Class beanClass = null;
        try {
            beanClass = bean.getClass();//底层bean的Class
            newBean = beanClass.newInstance();//实例化一个新的bean
        } catch (Exception e) {
            // unable to instantiate
            throw new CloneNotSupportedException
                ("Unable to instantiate the underlying bean \"" +
                 beanClass.getName() + "\": " + e);
        }
            
        try {
            newMap.setBean(newBean);
        } catch (Exception exception) {
            throw new CloneNotSupportedException
                ("Unable to set bean in the cloned bean map: " + 
                 exception);
        }
            
        try {
            //复制所有可读写的属性
            Iterator readableKeys = readMethods.keySet().iterator();
            while(readableKeys.hasNext()) {
                Object key = readableKeys.next();//属性名称
                if(getWriteMethod(key) != null) {
                    newMap.put(key, get(key));//放入到新BeanMap中
                }
            }
        } catch (Exception exception) {
            throw new CloneNotSupportedException
                ("Unable to copy bean values to cloned bean map: " +
                 exception);
        }
        return newMap;
    }

  
    public void clear() {
        if(bean == null) return;
        Class beanClass = null;
        try {
            beanClass = bean.getClass();
            bean = beanClass.newInstance();//重新实例化,一切都回到默认状态
        }
        catch (Exception e) {
            throw new UnsupportedOperationException( "Could not create new instance of class: " + beanClass );
        }
    }

    public Object get(Object name) {//获取指定名称属性的值
        if ( bean != null ) {
            Method method = getReadMethod( name );
            if ( method != null ) {
                try {
                    return method.invoke( bean, NULL_ARGUMENTS );
                }
                catch (  IllegalAccessException e ) {
                    logWarn( e );
                }
                catch ( IllegalArgumentException e ) {
                    logWarn(  e );
                }
                catch ( InvocationTargetException e ) {
                    logWarn(  e );
                }
                catch ( NullPointerException e ) {
                    logWarn(  e );
                }
            }
        }
        return null;
    }

    public Object put(Object name, Object value) throws IllegalArgumentException, ClassCastException
    {//设置指定名称的属性的值
        if ( bean != null ) {
            Object oldValue = get( name );//原来的值
            Method method = getWriteMethod( name );
            if ( method == null ) {
                throw new IllegalArgumentException( "The bean of type: "+ bean.getClass().getName() + " has no property called: " + name );
            }
            try {
                Object[] arguments = createWriteMethodArguments( method, value );//转换参数
                method.invoke( bean, arguments );//设置新值
                Object newValue = get( name );//获取新设置的值 
                firePropertyChange( name, oldValue, newValue );//fire属性值改变事件
            }
            catch ( InvocationTargetException e ) {
                logInfo( e );
                throw new IllegalArgumentException( e.getMessage() );
            }
            catch ( IllegalAccessException e ) {
                logInfo( e );
                throw new IllegalArgumentException( e.getMessage() );
            }
            return oldValue;
        }
        return null;
    }

    public Method getReadMethod(String name) {//获取指定名称属性的getXXX方法
        return (Method) readMethods.get(name);
    }

    public Method getWriteMethod(String name) {//获取指定名称属性的setXXX方法
        return (Method) writeMethods.get(name);
    }

    private void initialise() 
    {
        if(getBean() == null) return;
        Class  beanClass = getBean().getClass();//bean的Class
        try 
        {
            //BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
            BeanInfo beanInfo = Introspector.getBeanInfo( beanClass );//bean的信息
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            if ( propertyDescriptors != null ) 
            {
                for ( int i = 0; i < propertyDescriptors.length; i++ ) 
                {
                    PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
                    if ( propertyDescriptor != null ) 
                    {
                        String name = propertyDescriptor.getName();//属性名称
                        Method readMethod = propertyDescriptor.getReadMethod();//getXXX方法
                        Method writeMethod = propertyDescriptor.getWriteMethod();//setXXX方法
                        Class aType = propertyDescriptor.getPropertyType();//属性类型
                        if ( readMethod != null ) {
                            readMethods.put( name, readMethod );//保存到getXXX集合
                        }
                        if ( writeMethod != null ) {
                            writeMethods.put( name, writeMethod );//保存到setXXX集合
                        }
                        types.put( name, aType );//保存属性类型
                    }
                }
            }
        }
        catch ( IntrospectionException e ) {
            logWarn(  e );
        }
    }

    protected static class MyMapEntry extends AbstractMapEntry 
    {//BeanMap使用的Map entry        
        private BeanMap owner;//所属的Map
       
        protected MyMapEntry( BeanMap owner, Object key, Object value ) {
            super( key, value );
            this.owner = owner;
        }

        public Object setValue(Object value) {
            Object key = getKey();
            Object oldValue = owner.get( key );

            owner.put( key, value );
            Object newValue = owner.get( key );
            super.setValue( newValue );
            return oldValue;
        }
    }

    protected Object[] createWriteMethodArguments( Method method, Object value ) throws IllegalAccessException, ClassCastException 
    {            
        try 
        {
            if ( value != null ) 
            {
                Class[] types = method.getParameterTypes();//setXXX方法的参数类型
                if ( types != null && types.length > 0 ) 
                {
                    Class paramType = types[0];
                    if ( ! paramType.isAssignableFrom( value.getClass() ) ) 
                    {
                        value = convertType( paramType, value );//把新参数转换为setXXX方法的参数类型
                    }
                }
            }
            Object[] answer = { value };
            return answer;
        }
        catch ( InvocationTargetException e ) {
            logInfo( e );
            throw new IllegalArgumentException( e.getMessage() );
        }
        catch ( InstantiationException e ) {
            logInfo( e );
            throw new IllegalArgumentException( e.getMessage() );
        }
    }

    protected Object convertType( Class newType, Object value ) 
        throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        
        // try call constructor
        Class[] types = { value.getClass() };
        try {//尝试用带一个参数的构造函数进行转换
            Constructor constructor = newType.getConstructor( types );        
            Object[] arguments = { value };
            return constructor.newInstance( arguments );
        }
        catch ( NoSuchMethodException e ) {
            // try using the transformers
            Transformer transformer = getTypeTransformer( newType );//获取可用的transformer
            if ( transformer != null ) {
                return transformer.transform( value );//转换类型
            }
            return value;
        }
    }

    protected Transformer getTypeTransformer( Class aType ) {
        return (Transformer) defaultTransformers.get( aType );
    }

}