JavaBean之间拷贝利器-Dozer

Dozer 使用总结，也许对你有帮助  http://vincent1003.iteye.com/blog/762494

1.1 什么是dozer？
Dozer 是一个对象转换工具。
Dozer可以在JavaBean到JavaBean之间进行递归数据复制,并且这些JavaBean可以是不同的复杂的类型。
所有的mapping，Dozer将会很直接的将名称相同的fields进行复制，如果field名不同，或者有特别的对应要求，则可以在xml中进行定义。
更多详细请参考dozer官网：http://dozer.sourceforge.net/documentation/about.html
1.2 为什么要使用Dozer？
分析多层架构的J2EE系统，经常存在JavaBean直接的拷贝。比如我们在DAO层，通过Do取得业务层需要的数据，将这些数据传递给 Service层的VO。Do与VO就存在典型的值拷贝。
典型的解决方案就是手动拷贝，弊端很明显，代码中充斥大量Set 和Get方法，真正的业务被埋藏值与值的拷贝之中。另一种方案就是使用BeanUtil，但BeanUtil不够很好的灵活性，又时候还不得不手动拷贝。Dozer可以灵活的对对象进行转换，且使用简单。
Dozer 支持的转换类型
Dozer支持
Primitive 基本数据类型 , 后面带 Wrapper 是包装类 Complex Type 是复杂类型
• Primitive to Primitive Wrapper
• Primitive to Custom Wrapper
• Primitive Wrapper to Primitive Wrapper
• Primitive to Primitive
• Complex Type to Complex Type
• String to Primitive
• String to Primitive Wrapper
• String to Complex Type if the Complex Type contains a String constructor
• String 到复杂类型 , 如果复杂类型包含一个 String 类型的构造器
• String to Map
• Collection to Collection
• Collection to Array
• Map to Complex Type
• Map to Custom Map Type
• Enum to Enum
• Each of these can be mapped to one another: java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp, java.util.Calendar, java.util.GregorianCalendar
• String to any of the supported Date/Calendar Objects.
• Objects containing a toString() method that produces a long representing time in (ms) to any supported Date/Calendar object.
3 Dozer使用(不与spring集成下)
3.1 dozer使用分类
根据有无映射文件和文件的多少，有三种方式：
第一种：该方式用于数据类型为基本类型，名称相同的对象映射 

Mapper mapper = new DozerBeanMapper();  
SourceObject sourceObject = new SourceObject();  
DestinationObject destObject = (DestinationObject) mapper.map(sourceObject, DestinationObject.class);  
    //  or  
DestinationObject destObject = new DestinationObject();  
mapper.map(sourceObject, destObject);  

第二种：该方式用于数据类型不一致，或者名称不相同或者有级联关系等情况下的映射，该方式可以添加多个配置文件dozerBeanMapping.xml、someOtherDozerBeanMappings.xml 等 

List myMappingFiles = new ArrayList();  
myMappingFiles.add("dozerBeanMapping.xml");  
//myMappingFiles.add("someOtherDozerBeanMappings.xml");  
DozerBeanMapper mapper = new DozerBeanMapper();  
SourceObject sourceObject = new SourceObject();  
mapper.setMappingFiles(myMappingFiles);  
DestinationObject stObject=  
(DestinationObject) mapper.map(sourceObject, DestinationObject.class);

 

第三种：该方式用于数据类型不一致，或者名称不相同或者有级联关系等情况下的映射，配置文件只有一个映射文件叫dozerBeanMapping.xml且在根目录下 

Mapper mapper = DozerBeanMapperSingletonWrapper.getInstance();  
SourceObject sourceObject = new SourceObject();  
DestinationObject destObject = (DestinationObject) mapper.map(sourceObject, DestinationObject.class);  
//or  
//Mapper mapper = DozerBeanMapperSingletonWrapper.getInstance();  
//DestinationObject destObject = new DestinationObject();  
mapper.map(sourceObject, destObject); 

3.2 举例说明：
假设我们现在有一个userDo类，如下： 

package ce.dozer;  
public class User {  
    private int id;  
    private String name;  
    private String password;  
    private Info info;  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getPassword() {  
        return password;  
    }  
    public void setPassword(String password) {  
        this.password = password;  
    }  
    public Info getInfo() {  
        return info;  
    }  
    public void setInfo(Info info) {  
        this.info = info;  
    }  
}  

一个userVo类，如下： 

package ce.dozer;  
public class UserVO {  
    private int id;  
    private String userName;  
    private String password;  
    private InfoVO info;  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getUserName() {  
        return userName;  
    }  
    public void setUserName(String userName) {  
        this.userName = userName;  
    }  
    public String getPassword() {  
        return password;  
    }  
    public void setPassword(String password) {  
        this.password = password;  
    }  
    public InfoVO getInfo() {  
        return info;  
    }  
    public void setInfo(InfoVO info) {  
        this.info = info;  
    }  
}  

一个性別枚舉类，如下： 

package ce.dozer;  
public enum GenderType {  
    male,//男  
    female//女  
}  

一个infoDo类，如下： 

package ce.dozer;  
import java.util.Date;  
public class Info {  
    private int id;  
    private Date createDate;  
    private GenderType gender;  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public Date getCreateDate() {  
        return createDate;  
    }  
    public void setCreateDate(Date createDate) {  
        this.createDate = createDate;  
    }  
    public GenderType getGender() {  
        return gender;  
    }  
    public void setGender(GenderType gender) {  
        this.gender = gender;  
    }  
}  

一个infoVo类，如下： 

package ce.dozer;  
public class InfoVO {  
    private int id;  
    private String date;  
    private Integer gender;  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getDate() {  
        return date;  
    }  
    public void setDate(String date) {  
        this.date = date;  
    }  
    public Integer getGender() {  
        return gender;  
    }  
    public void setGender(Integer gender) {  
        this.gender = gender;  
    }  
}  

在给出的示例中我们可以看到userDo与 userVo 中的字段对应关系
userVo userDo 不同
id（int） id（int）
userName（String） name（String） 名称不同
password（String） password（String）
Info(InfoVo) info (Info) 类型不同
再看看infoDo与 infoVo 中的字段对应关系
infoVo infoDo 不同
id(int) Id(int)
createDate(String) date(Date) 类型不同
gender(Integer) Gender(GenderType)枚举 类型不同
综合上面的问题我们可以如下解决方式：

3.2.1 字段名称不同映射配置 

<mapping>  
        <class-a>ce.dozer.User</class-a>  
        <class-b>ce.dozer.UserVO</class-b>  
        <field>  
            <a>name</a>  
            <b>userName</b>  
        </field>  
</mapping>

 

3.2.2 Date与String映射配置如下： 

<mapping date-format="yyyy-MM-dd">  
        <class-a>ce.dozer.User</class-a>  
        <class-b>ce.dozer.UserVO</class-b>  
        <field>  
            <a>info.createDate</a>  
            <b>info.date</b>  
        </field>  
</mapping>  

3.2.3 在示例中我们看到在userDo和userVo对象中关联了其他的对象，这个问题不用担心，因为对象名称相同dozer会为我们自动转换。而问题不在这，在与对象中有枚举类型，我们该怎么写配置呢？在这里我们就必须自己编写一个处理类来处理枚举与Integer的转换了（假设我们的处理类为util.EnumIntConverter），配置如下： 

<configuration>  
    <stop-on-errors>true</stop-on-errors>  
    <date-format>yyyy-MM-dd</date-format>  
    <wildcard>true</wildcard>  
    <custom-converters>   
        <converter type=" util.EnumIntConverter">  
            <class-a>java.lang.Enum</class-a>  
            <class-b>java.lang.Integer</class-b>  
        </converter>  
    </custom-converters>  
</configuration>  
<mapping>  
    <class-a>ce.dozer.User</class-a>  
    <class-b>ce.dozer.UserVO</class-b>  
    <field>  
        <a>info.gender</a>  
        <b>info.gender</b>  
    </field>  
</mapping> 

最终的dozerBeanMapping.xml 配置文件： 

<?xml version="1.0" encoding="UTF-8"?>  
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://dozer.sourceforge.net  
          http://dozer.sourceforge.net/schema/beanmapping.xsd">  
  
    <configuration>  
        <stop-on-errors>true</stop-on-errors>  
        <date-format>yyyy-MM-dd</date-format>  
        <wildcard>true</wildcard>  
        <custom-converters>  
            <converter type=" util.EnumIntConverter">  
                <class-a>java.lang.Enum</class-a>  
                <class-b>java.lang.Integer</class-b>  
            </converter>  
        </custom-converters>  
    </configuration>  
    <mapping date-format="yyyy-MM-dd">  
        <class-a>ce.dozer.User</class-a>  
        <class-b>ce.dozer.UserVO</class-b>  
        <field>  
            <a>info.createDate</a>  
            <b>info.date</b>  
        </field>  
        <field>  
            <a>info.gender</a>  
            <b>info.gender</b>  
        </field>  
        <field>  
            <a>info.createDate</a>  
            <b>info.date</b>  
        </field>  
        <field>  
            <a>name</a>  
            <b>userName</b>  
        </field>  
    </mapping>  
</mappings>  

4 与spring的集成
4.1 1、dozer 要与spring集成需要将dozer交给spring管理，配置如下： 

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd  
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"  
    default-autowire="byName" default-lazy-init="false">  
  
    <bean id="mapper" class="org.dozer.spring.DozerBeanMapperFactoryBean">  
        <property name="mappingFiles">  
<list>             <value>classpath*:dozer-config/dozerBeanMapping.xml</value>  
            </list>  
        </property>  
    </bean>  
</beans>  

4.2 2、当我们的dozer交给了spring管理，当spring容器启动后我们可以将下面的代码添加到用于继承的基类中去： 

private Mapper mapper ;  
public Mapper getMapper() {  
    return mapper;  
}  
public void setMapper(Mapper mapper) {  
    this.mapper = mapper;  
}  

4.3 3、在继承者类中就可以直接如下使用： 

getMapper().map(sourceObject, DestinationObject.class)  

5 结束语
Dozer的转换功能很强大，我们所能想到的类型转换，它基本都可以帮助我们完成。所以如果您想对dozer了解更多更深，建议到官网仔细阅读相关文档和说明！
官网：http://dozer.sourceforge.net/documentation/mappings.html






JavaBean之间拷贝利器-Dozer
http://www.blogjava.net/vincent/archive/2009/04/12/265179.html

<dependency>
	<groupId>net.sf.dozer</groupId>
	<artifactId>dozer</artifactId>
	<version>5.5.1</version>
</dependency>

分析多层架构的JEE系统，经常存在JavaBean直接的拷贝。比如在DAO层，我们通过POJO取得业务层需要的数据，将这些数据传递给Service层的VO。POJO与VO就存在典型的值拷贝。还有就是Webservice，客户端调用Webservice，也存在将大量返回值映射到相应的JavaBean里。呵呵 我们项目就是这个需求。
    典型的解决方案就是手动拷贝，弊端很明显，代码中充斥大量Set Get方法，真正的业务没埋藏与值的拷贝之中。另一种方案就是使用BeanUtil，但BeanUtil不够很好的灵活性，又时候还不得不手动拷贝。
     对于这种重复没有实际意义的拷贝难道没有终结解决方案吗？！ Dozer 一把JavaBean利器。（http://dozer.sourceforge.net/）

    什么是Dozer？
    看看官方的定义：
Dozer is a Java Bean to Java Bean mapper that recursively copies data from one object to
another. Typically, these Java Beans will be of different complex types.

Dozer supports simple property mapping, complextype mapping, bi-directional mapping, implicitexplicit mapping, as well as recursive
mapping.This includes mapping collection attributes that also need mapping at the element level.
    注意：Dozer支持简单类型 复杂类型的双向递归映射。
    
    如何使用呢？ 类似BeanUtil 很简单，如果两个javaBean之间，属性名相同，类型为基本类型，那么下面代码就OK了，基本没有学习曲线。
   

Mapper mapper = new DozerBeanMapper();

DestinationObject destObject = mapper.map(sourceObject, DestinationObject.class);
             or
DestinationObject destObject = new DestinationObject();
mapper.map(sourceObject, destObject);

   在后续的的内容中，我会介绍如何配置复杂的Map，如何自定义Map，如何获得Map的统计数据等。


如何使用Dozer映射复杂类型：
            1. 数据类型不一致。
            2. 级联映射。
            3. 自定义映射。
    在讨论之前，我们来说说一个朋友在上篇留言中提到的一个问题。估计大家应该都很关心。这个问题就是性能问题。Dozer其实底层使用了现成的BeanUtil，通过反射来映射，况且Dozer应用了Cache技术，应该比自个通过BeanUtils映射性能要好点。所以一般的应用应该不存在性能问题。

    Dozer对于基本类型之间转换是不用配置的，比如Sting <------>Integer ,只要属性名称相同就Ok了。
    而常用的Date与String映射配置如下：

  <mapping date-format="MM-dd-yyyy">
<class-a>net.blogjava.vincent.pojo.CustomerPo</class-a>
<class-b>net.blogjava.vincent.vo.CustomerVo</class-b>
<field>
<a>birthday</a>
<b>dateOfBirth</b>
</field>
</mapping>

   指明 CustomerPo里面的birthday对应CustomerVo里面的dateOfBirth.并且是Date与String之间双向映射。

    对于属性名称不一致，也仅仅需要一个配置文件，如下：

      <mapping>
      <class-a>net.blogjava.vincent.pojo.CustomerPo</class-a>
      <class-b>net.blogjava.vincent.vo.CustomerVo</class-b>
       <field>
       <a>type</a>
     <b>transferType</b>
   </field>
 </mapping>

     指明 CustomerPo里面的type 对应CustomerVo里面的transferType.

    而对以级联，比如CustomerPo里面的一个属性映射为CustomerVo里么一个对象的属性，下面的配置就可以了

           <mapping>
      <class-a>net.blogjava.vincent.pojo.CustomerPo</class-a>
      <class-b>net.blogjava.vincent.vo.CustomerVo</class-b>
       <field>
       <a>type</a>
     <b>transferType.type</b>
   </field>
    </mapping>

     上面其实就是Dozer基本用法，也涵盖了大多数应用场景，可见基本不需要写代码，仅仅一个配置文件搞定，简单吧。

      而对以更个性化的映射，就需要写代码了， 比如在CustomerPo中的into类型的transferId ，映射CustomerVo  String 类型transferType, 如果transferId =1 对应transferType=“immediateTranfer” 如果transferId =2 对应transferType=“scheduleTransfer” 反之亦然。就要写一个Customer的Map了， 如下：

import org.dozer.CustomConverter;

public class CustomerMap implements CustomConverter {

    public Object convert(Object destinationFieldValue,
            Object sourceFieldValue, Class<?> destinationClass,
            Class<?> sourceClass) {
        Object returnVale = null;
        if(sourceFieldValue!=null){
            if(sourceFieldValue instanceof Integer ){
                if((Integer)sourceFieldValue == 1){
                    returnVale ="immediateTranfer";
                }
                if((Integer)sourceFieldValue == 2){
                    returnVale ="scheduleTransfer";
                }
                
            }
            if(sourceFieldValue instanceof String ){
                if("immediateTranfer".equals(destinationFieldValue)){
                    returnVale =1;
                }
                if("scheduleTransfer".equals(destinationFieldValue)){
                    returnVale =2;
                }
                
            }

        }
        return returnVale;
    }

}

    然后在配置文件配置就Ok了 如下：

      <mapping>
          <class-a>net.blogjava.vincent.pojo.CustomerPo</class-a>
         <class-b>net.blogjava.vincent.vo.CustomerVo</class-b>
       <field custom-converter="net.blogjava.vincent.mapUtil.CustomerMap">
       <a>type</a>
      <b>transferType</b>
      </field>
    </mapping>

下面就是一个完整的配置文件：

 <?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://dozer.sourceforge.net E:\dozer\dozer-5.0-src\dozer-5.0\src\site\resources\schema\beanmapping.xsd"
    xmlns="http://dozer.sourceforge.net">
    <mapping  date-format="yyyy-MM-dd">
        <class-a>net.blogjava.vincent.pojo.UserInfo</class-a>
        <class-b>net.blogjava.vincent.vo.UserInfoVo</class-b>
        <field>
            <a>colleage.name</a>
            <b>schoolName</b>
        </field>
    </mapping>
        <mapping>
        <class-a>net.blogjava.vincent.pojo.CustomerPo</class-a>
        <class-b>net.blogjava.vincent.vo.CustomerVo</class-b>
         <field custom-converter="net.blogjava.vincent.mapUtil.CustomerMap">
            <a>type</a>
            <b>transferType</b>
        </field>
    </mapping>

</mappings>