Dozer 学习笔记

来源：互联网发布：sqlserver修改默认值编辑：程序博客网时间：2024/05/21 11:06

Dozer是一种java bean映射工具，类似于apache的BeanUtils。主要作用是建立DTO与Entity之间的属性关联，区分对外接口实体与内部实体，避免两者造成影响。

Dozer依赖于get与set方法，不能直接以public来访问。

dozer支持双向依赖，如A类中包含B对象、而B类中包含A对象。

对于两个相互关联的类，两个属性本质含义相同名字不同，则通过@Mapping（）来进行转换，而且只需要在一边进行转换即可。

dozer支持String和基础类型的转换。

dozer支持collection之间的转换，或者数组与list转换。

一、dozer可以由xml配置文件文件建立DTO与Entity之间管理。

案例：

1.book实体类：

public class Book {
private String name;
private String author;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public Book() {
}
}
2.bookvo实体类：

public class BookVo {
private String namevo;
private String authorvo;

public String getNamevo() {
return namevo;
}

public void setNamevo(String namevo) {
this.namevo = namevo;
}

public String getAuthorvo() {
return authorvo;
}

public void setAuthorvo(String authorvo) {
this.authorvo = authorvo;
}

public BookVo() {
}
}
3.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">

<mapping>
<class-a>test.Book</class-a>
<class-b>test.BookVo</class-b>
<field>
<a>name</a>
<b>namevo</b>
</field>
<field>
<a>author</a>
<b>authorvo</b>
</field>
</mapping>
</mappings>
4.测试类：

package test;

import java.util.ArrayList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dozer.DozerBeanMapper;

/**
* 说明：
*
* @author lsr
* @version Aug 17, 2011
*/
public class DozerTest {
/**
* @param args
*/
public static void main(String[] args) {
testByXml();
}

public static void testByXml() {
Book book = new Book();
book.setAuthor("lsr");
book.setName("dozer demo");
DozerBeanMapper mapper = new DozerBeanMapper();
List<String> mappers = new ArrayList<String>();
mappers.add("bookMapper.xml");
mapper.setMappingFiles(mappers);
BookVo vo = new BookVo();
mapper.map(book, vo);
System.out.println("book's name:" + book.getName());
System.out.println("bookVo's name:" + vo.getNamevo());
}
}

二、dozer也可以由注解关联。

案例：

1.product类：

public static class Product {
private String productName;
private Double price;
private List<Part> parts;
//DTO中没有的属性
private Double weight;
public String getProductName() {
return productName;
}
public void setProductName(String productName) {
this.productName = productName;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public List<Part> getParts() {
return parts;
}
public void setParts(List<Part> parts) {
this.parts = parts;
}
public Double getWeight() {
return weight;
}
public void setWeight(Double weight) {
this.weight = weight;
}
}
2.part类：

public static class Part {
//反向依赖Product
private Product product;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
}
3.productDTO：

public static class ProductDTO {
//定义到Product中的productName,只要在一边定义，双向转换都可以使用.
         @Mapping("productName")
private String name;
//类型为String 而非 Double
         private String price;
//类型为Array而非List, PartDTO而非Part
         private PartDTO[] parts;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPrice() {
return price;
}
public void setPrice(String price) {
this.price = price;
}
public PartDTO[] getParts() {
  return parts;
}
public void setParts(PartDTO[] parts) {
this.parts = parts;
}
}
4.partDTO：

public static class PartDTO {
//反向依赖ProductDTO
private ProductDTO product;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ProductDTO getProduct() {
return product;
}
public void setProduct(ProductDTO product) {
this.product = product;
}
}
5.测试类：

import static org.junit.Assert.*;
import java.util.List;
import org.dozer.Mapping;
import org.junit.Test;
import org.springside.modules.mapper.BeanMapper;
/**
  * 演示Dozer如何只要属性名相同，可以罔顾属性类型是基础类型<->String的差别，Array转为List，甚至完全另一种DTO的差别。
  * 并且能完美解决循环依赖问题。
  * 使用@Mapping能解决属性名不匹配的情况.
  */
public class DozerDemo {
/**
      * 从一个ProductDTO实例，创建出一个新的Product实例。
      */
@Test
public void map() {
ProductDTO productDTO = new ProductDTO();
productDTO.setName("car");
productDTO.setPrice("200");
PartDTO partDTO = new PartDTO();
partDTO.setName("door");
partDTO.setProduct(productDTO);
productDTO.setParts(new PartDTO[] { partDTO });
//ProductDTO->Product
         Product product = BeanMapper.map(productDTO, Product.class);
assertEquals("car", product.getProductName());
//原来的字符串被Map成Double。
         assertEquals(new Double(200), product.getPrice());
//原来的PartDTO同样被Map成Part ,Array被Map成List
         assertEquals("door", product.getParts().get(0).getName());
//Part中循环依赖的Product同样被赋值。
         assertEquals("car", product.getParts().get(0).getProduct().getProductName());
//再反向从Product->ProductDTO
         ProductDTO productDTO2 = BeanMapper.map(product, ProductDTO.class);
assertEquals("car", productDTO2.getName());
assertEquals("200.0", productDTO2.getPrice());
assertEquals("door", productDTO2.getParts()[0].getName());
}
/**
      * 演示将一个ProductDTO实例的内容，Copy到另一个已存在的Product实例.
      */
@Test
public void copy() {
ProductDTO productDTO = new ProductDTO();
productDTO.setName("car");
productDTO.setPrice("200");
PartDTO partDTO = new PartDTO();
partDTO.setName("door");
partDTO.setProduct(productDTO);
productDTO.setParts(new PartDTO[] { partDTO });
//已存在的Product实例
         Product product = new Product();
product.setProductName("horse");
product.setWeight(new Double(20));
BeanMapper.copy(productDTO, product);
//原来的horse，被替换成car
         assertEquals("car", product.getProductName());
//原来的20的属性被覆盖成200，同样被从字符串被专为Double。
         assertEquals(new Double(200), product.getPrice());
//DTO中没有的属性值,在Product中被保留
         assertEquals(new Double(20), product.getWeight());
//Part中循环依赖的Product同样被赋值。
         assertEquals("car", product.getParts().get(0).getProduct().getProductName());
}
  }

复制去Google翻译翻译结果

0 0