DozerBeanMapper + 對象轉Map方法

 

一、簡介 
    dozer是一種JavaBean的映射工具，相似於apache的BeanUtils。可是dozer更強大，它能夠靈活的處理複雜類型之間的映射。不但能夠進行簡單的屬性映射、複雜的類型映射、雙向映射、遞歸映射等，而且能夠經過XML配置文件進行靈活的配置。 

二、準備 
   如今開始就小試一下。 
   首先，須要下載jar包， 
   dozer.jar :http://dozer.sourceforge.net/downloading.html 
   還須要slf4j.jar，commons-lang.jar,commons-beanutil.jar, commons-loggin.jar 

 

http://lishaorui.iteye.com/blog/1151513

 

import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.dozer.DozerBeanMapper;

public class BeanMapper
{
  private static DozerBeanMapper dozer = new DozerBeanMapper();

  /**
  * 構造新的destinationClass實例對象，經過source對象中的字段內容
  * 映射到destinationClass實例對象中，並返回新的destinationClass實例對象。
  *
  * @param source 源數據對象
  * @param destinationClass 要構造新的實例對象Class
  */
  public static <T> T map(Object source, Class<T> destinationClass)
  {
    return dozer.map(source, destinationClass);
  }



  public static <T> List<T> mapList(Collection sourceList, Class<T> destinationClass)
  {
    List destinationList = Lists.newArrayList();
    for (Iterator i$ = sourceList.iterator(); i$.hasNext(); ) { Object sourceObject = i$.next();
      Object destinationObject = dozer.map(sourceObject, destinationClass);
      destinationList.add(destinationObject);
    }
    return destinationList;
  }


  /**
  * 將對象source的全部屬性值拷貝到對象destination中.
  *
  * @param source 對象source
  * @param destination 對象destination
  */
  public static void copy(Object source, Object destinationObject)
  {
    dozer.map(source, destinationObject);
  }
}

 

 

使用：

SmIaasQuotaV result = null;
        try {
            result = limitService.getLimitDetails(id,parentId);
            if(result != null){
                response.setData(BeanMapper.map(result, Map.class));
                response.setSuccess(true);
            }
        }

BeanMapper.map(result, Map.class)

轉換爲Map對象。

 

 

 

public static <T> Map<String, T> toMap(Object target) {
    return toMap(target,false);
}

/**
 * 將目標對象的全部屬性轉換成Map對象
 *
 * @param target 目標對象
 * @param ignoreParent 是否忽略父類的屬性
 *
 * @return Map
 */
public static <T> Map<String, T> toMap(Object target,boolean ignoreParent) {
    return toMap(target,ignoreParent,false);
}

/**
 * 將目標對象的全部屬性轉換成Map對象
 *
 * @param target 目標對象
 * @param ignoreParent 是否忽略父類的屬性
 * @param ignoreEmptyValue 是否不把空值添加到Map中
 *
 * @return Map
 */
public static <T> Map<String, T> toMap(Object target,boolean ignoreParent,boolean ignoreEmptyValue) {
    return toMap(target,ignoreParent,ignoreEmptyValue,new String[0]);
}

/**
 * 將目標對象的全部屬性轉換成Map對象
 *
 * @param target 目標對象
     * @param ignoreParent 是否忽略父類的屬性
     * @param ignoreEmptyValue 是否不把空值添加到Map中
     * @param ignoreProperties 不須要添加到Map的屬性名
 */
    public static <T> Map<String, T> toMap(Object target,boolean ignoreParent,boolean ignoreEmptyValue,String... ignoreProperties) {
        Map<String, T> map = new HashMap<String, T>();

    List<Field> fields = ReflectionUtils.getAccessibleFields(target.getClass(), ignoreParent);

    for (Iterator<Field> it = fields.iterator(); it.hasNext();) {
        Field field = it.next();
        T value = null;

        try {
            value = (T) field.get(target);
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (ignoreEmptyValue
                && ((value == null || value.toString().equals(""))
                || (value instanceof Collection && ((Collection<?>) value).isEmpty())
                || (value instanceof Map && ((Map<?,?>)value).isEmpty()))) {
            continue;
        }

        boolean flag = true;
        String key = field.getName();

        for (String ignoreProperty:ignoreProperties) {
            if (key.equals(ignoreProperty)) {
                flag = false;
                break;
            }
        }

        if (flag) {
            map.put(key, value);
        }
    }

        return map;
    }