java使用泛型实现Bean类和Map的相互转换

java使用泛型实现Bean类和Map的相互转换，使用泛型可以这带来了很多好处：

      首要就是类型安全， Java 程序的类型安全。通过知道使用泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

      泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当作 ClassCastException 展示出来。

 　  将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。

　　消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

主方法實現：

public class BeanUtil {

    public static void main(String[] args) throws Exception {

        Map<String, Object> mp = new HashMap<String, Object>();
        mp.put("name", "Jack");
        mp.put("age", 40);
        mp.put("mN", "male");

        PersonBean person = map2Bean(mp, PersonBean.class);
        System.out.println("transMap2Bean Map Info:");
        for (Map.Entry<String, Object> entry : mp.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("Bean Info:");
        System.out.println("name: " + person.getName());
        System.out.println("age: " + person.getAge());
        System.out.println("mN: " + person.getmN());

        bean2Map(person, mp);
        System.out.println("transBean2Map Map Info:");
        for (Map.Entry<String, Object> entry : mp.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

mapToBean方法：

    public static <T, K, V> T map2Bean(Map<K, V> mp, Class<T> beanCls)
            throws Exception, IllegalArgumentException, InvocationTargetException {
        T t = null;
        try {

            BeanInfo beanInfo = Introspector.getBeanInfo(beanCls);
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

            t = beanCls.newInstance();

            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();

                if (mp.containsKey(key)) {
                    Object value = mp.get(key);
                    Method setter = property.getWriteMethod();// Java中提供了用来访问某个属性的
                                                                // getter/setter方法
                    setter.invoke(t, value);
                }
            }

        } catch (IntrospectionException e) {

            e.printStackTrace();
        }
        return t;
    }

beanToMap方法：

public static <T, K, V> Map<String, Object> bean2Map(T bean, Map<String, Object> mp)
            throws Exception, IllegalAccessException {

        if (bean == null) {
            return null;
        }

        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();

                if (!key.equals("class")) {

                    Method getter = property.getReadMethod();// Java中提供了用来访问某个属性的
                                                                // getter/setter方法
                    Object value;

                    value = getter.invoke(bean);
                    mp.put(key, value);
                }

            }

        } catch (IntrospectionException e) {

            e.printStackTrace();
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }
        return mp;

    }
}

　　總結：使用泛型可以避免類型轉換錯誤，可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，

即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象。因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：

Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");

要让程序通过编译，必须将 get() 的结果强制类型转换为 String，并且希望结果真的是一个 String。但是有可能某人已经在该映射中保存了不是 String 的东西，这样的话，上面的代码将会抛出 ClassCastException。