月度归档： 2017 年 12 月

1. 问题的源由

在J2EE项目开发中，会涉及很多领域模型对象，例如，

更多领域分层模型，及其所在的应用分层，可见阿里巴巴Java开发手册中的工程规约定义。

这些VO/DTO/PO都是POJO对象，每个属性都有getter/setter方法的定义，其数据转换链条大概为，

数据库DB 》PO 》DTO 》VO

可以看到，在项目中不同的应用分层DB/DAO/Service/Manager/Web，经常会需要把一个数据对象转换为其它类型的数据对象，转换的同时复制部分对象属性，有时部分属性需要从多个数据对象获取进行组装。这些数据的转换有一个共同的需求，那就是从一个源对象变为目标对象

源对象 Source s 》目标对象 Target t

接下来我们就需要讨论这个转换过程。

2. 单个对象的转换

1）简单的Java对象转换，使用BeanUtils.copyProperties

使用Spring都知道Spring Beans中提供了一个BeanUtils，可以用于对象的属性复制，其使用方法为，

    Target t = new Target();
    BeanUtils.copyProperties(s, t);
    BeanUtils.copyProperties(s, t, 'password');

其中，第二个copyProperties方法中第三个参数是告知复制过程中忽略复制’password’这个属性。

2）单个对象的转换，指定目标类

BeanUtils.copyProperties不提供目标对象的创建，因此每次都需要new出一个目标对象。为了能够省去这一步，可以使用下面的方法。

实现代码

public static  T convert(S s, Class clazz) {
  T t = null;

  try {
    t = clazz.newInstance();
    BeanUtils.copyProperties(s, t);
  } catch (Exception e) {
    e.printStackTrace();
  }

  return t;
}

上述方法将对象的生成封装起来返回。

使用样例

Target t = convert(s, Target.class);

使用中直接指定目标类，代码更加简洁易懂。

3. List/Set集合之间的转换

在很多时候，我们不仅处理一个对象的转换，而是面对集合的对象，这时需要能够对集合中的对象进行批量处理转换。

1）List集合转换，将列表中每一个实体转换为目标类

实现代码

public static  List convert(Iterable iterable, Class clazz) {
  return StreamSupport.stream(iterable.spliterator(), false)
                      .map(s -> convert(s, clazz))
                      .collect(Collectors.toList());
}

List targets = convert(srcCollection, Target.class);

public static  List convert(Iterable iterable, 
           Function mapper) {
  return StreamSupport.stream(iterable.spliterator(), false)
                      .map(mapper)
                      .collect(Collectors.toList());
}

List targets = convert(srcCollection, mapper);

public static > U collect(Iterable iterable, CollectionFactory factory) {
  U collection = factory.createCollection();
  iterable.forEach(collection::add);
  return collection;
}

Iterable iterable = IntStream.range(0, 5).boxed().collect(Collectors.toList());
ArrayList arrayList = collect(iterable, ArrayList::new);
HashSet hashSet = collect(iterable, HashSet::new);
LinkedList linkedList = collect(iterable, LinkedList::new);

public static , T> U collect(Iterable iterable, Class clazz, CollectionFactory factory) {
  Iterable list = convert(iterable, clazz);
  U collection = factory.createCollection();
  list.forEach(collection::add);
  return collection;
}

Iterable users = UserDao.SingleInstance.findAll();
ArrayList arrayList = collect(users, UserVO.class, ArrayList::new);
HashSet hashSet = collect(users, UserVO.class, HashSet::new);
LinkedList linkedList = collect(users, UserVO.class, LinkedList::new);

public static  Map map(Iterable iterable, Function keyGenerator) {
  return StreamSupport.stream(iterable.spliterator(), false)
         .collect(Collectors.toMap(keyGenerator, Function.identity()));
}

List users = UserDao.SingleInstance.findAll();
Map result = map(users, UserEntity::getName);

public static > U collect(Map map, CollectionFactory factory) {
  U collection = factory.createCollection();
  map.values().iterator().forEachRemaining(collection::add);
  return collection;
}

Map users;
List list1 = collect(users, ArrayList::new);
Set set = collect(users, HashSet::new);
List list2 = collect(users, LinkedList::new);
Collection collection = users.values();

public static > U map(Map srcMap, Class clazz,  MapFactory factory) {
  U u = factory.createMap();
  srcMap.entrySet()
        .forEach(ksEntry -> u.put(ksEntry.getKey(),
                          convert(ksEntry.getValue(), clazz)));
  return u;
}

Map users;
Map m1 = map(users, UserVO.class, HashMap::new);
Map m2 = map(users, UserVO.class, LinkedHashMap::new);
Hashtable m3 = map(users, UserVO.class, Hashtable::new);

git clone git@gitee.com:pphh/blog.git