Map与JavaBean实体类之间的相互转化

package com.newcapec.util.map;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.PropertyUtilsBean;

import com.newcapec.cloudpay.dao.po.HostUserInfo;
import com.newcapec.cloudpay.dao.po.WXUserInfo;

/**
 * @Title: Java 中 Map与JavaBean实体类之间的相互转化
 * @ClassName:MapBeanTransUtils.java
 * @Description:
 *
 * @Copyright 2016-2017  - Powered By 研发中心
 * @author: FLY
 * @date:2016年12月23日 上午10:11:49
 * @version V1.0
 */
public class MapBeanTransUtils {

   /**
    * 将一个 JavaBean 对象转化为一个 Map
    * 
    * @param bean
    *            要转化的JavaBean 对象
    * @return 转化出来的 Map 对象
    * @throws IntrospectionException
    *             如果分析类属性失败
    * @throws IllegalAccessException
    *             如果实例化 JavaBean 失败
    * @throws InvocationTargetException
    *             如果调用属性的 setter 方法失败
    */
   @SuppressWarnings({ "rawtypes", "unchecked" })
   public static Map bean2Map(Object bean)
         throws IntrospectionException, IllegalAccessException, InvocationTargetException {
      Class type = bean.getClass();
      Map returnMap = new HashMap();
      BeanInfo beanInfo = Introspector.getBeanInfo(type);

      PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
      for (int i = 0; i < propertyDescriptors.length; i++) {
         PropertyDescriptor descriptor = propertyDescriptors[i];
         String propertyName = descriptor.getName();
         if (!propertyName.equals("class")) {
            Method readMethod = descriptor.getReadMethod();
            Object result = readMethod.invoke(bean, new Object[0]);
            if (result != null) {
               returnMap.put(propertyName, result);
            } else {
               returnMap.put(propertyName, "");
            }
         }
      }
      return returnMap;
   }

   /**
    * 将一个 Map 对象转化为一个 JavaBean
    * 
    * @param type
    *            要转化的类型
    * @param map
    *            包含属性值的 map
    * @return 转化出来的 JavaBean 对象
    * @throws IntrospectionException
    *             如果分析类属性失败
    * @throws IllegalAccessException
    *             如果实例化 JavaBean 失败
    * @throws InstantiationException
    *             如果实例化 JavaBean 失败
    * @throws InvocationTargetException
    *             如果调用属性的 setter 方法失败
    */
   @SuppressWarnings("rawtypes")
   public static Object map2Bean(Class type, Map map)
         throws IntrospectionException, IllegalAccessException, InstantiationException, InvocationTargetException {
      
      BeanInfo beanInfo = Introspector.getBeanInfo(type); // 获取类属性
      Object obj = type.newInstance(); // 创建 JavaBean 对象

      // 给 JavaBean 对象的属性赋值
      PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
      for (int i = 0; i < propertyDescriptors.length; i++) {
         PropertyDescriptor descriptor = propertyDescriptors[i];
         String propertyName = descriptor.getName();

         if (map.containsKey(propertyName)) {
            // 下面一句可以 try 起来，这样当一个属性赋值失败的时候就不会影响其他属性赋值。
            Object value = map.get(propertyName);

            Object[] args = new Object[1];
            args[0] = value;

            descriptor.getWriteMethod().invoke(obj, args);
         }
      }
      return obj;
   }

   // 将JAVABEAN实体类转为map类型，然后返回一个map类型的值
   public static Map<String, Object> beanToMap(Object obj) {
      Map<String, Object> params = new HashMap<String, Object>(0);
      try {
         PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
         PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(obj);
         for (int i = 0; i < descriptors.length; i++) {
            String name = descriptors[i].getName();
            if (!"class".equals(name)) {
               params.put(name, propertyUtilsBean.getNestedProperty(obj, name));
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
      return params;
   }
   

   public static void main(String[] args)
         throws IllegalAccessException, InstantiationException, InvocationTargetException, IntrospectionException {
      // 获取分隔符
      // System.out.println(System.getProperty("path.separator"));

      // java对象拷贝之BeanUtils.copyProperties() 用法
      WXUserInfo wxUserInfo = new WXUserInfo();
      HostUserInfo hostUserInfo = new HostUserInfo();
      wxUserInfo.setCustomerCode("11");
      wxUserInfo.setCustomerId("id");
      wxUserInfo.setCustomerName("name");
      wxUserInfo.setName("aa");
      wxUserInfo.setStuNo("001");
      wxUserInfo.setUserId("uset");

      // BeanUtils.copyProperties(wxUserInfo, hostUserInfo);

      // System.out.println(hostUserInfo);

      // Map<String, String> hashMap = new HashMap<String, String>();

      Map convertBean = MapBeanTransUtils.bean2Map(wxUserInfo);
      
      Map<String, Object> beanToMap = MapBeanTransUtils.beanToMap(wxUserInfo);
      // MapBeanTransUtils.beanToMap(obj)
      System.out.println(beanToMap);
      
      // map 遍历
      
      for (Map.Entry<String, Object> entry : beanToMap.entrySet()) {
         System.out.println("属性名称："+entry.getKey()+"------"+"值："+entry.getValue());
      }
   }

}