深拷贝浅拷贝
Tips:
- 主要是对于
List和Map - 是同个类进行转换，而不是不同类进行转换
深拷贝
public class CustomerDto {
private Long id;
private String customerName;
private List<OrderItemDto> orders;
private Map<OrderItemKeyDto, OrderItemDto> stock;
}
public class OrderItemDto {
private String name;
private Long quantity;
}
public class OrderItemKeyDto {
private long stockNumber;
}
// --------------------------------------浅拷贝-------------------------
@Mapper
public interface Cloner {
Cloner MAPPER = Mappers.getMapper( Cloner.class );
CustomerDto clone(CustomerDto customerDto);
}
//生成的时候 list 里面的值是浅拷贝
public CustomerDto clone(CustomerDto customerDto) {
if (customerDto == null) {
return null;
} else {
CustomerDto customerDto1 = new CustomerDto();
customerDto1.setId(customerDto.getId());
customerDto1.setCustomerName(customerDto.getCustomerName());
List<OrderItemDto> list = customerDto.getOrders();
if (list != null) {
customerDto1.setOrders(new ArrayList(list));
}
Map<OrderItemKeyDto, OrderItemDto> map = customerDto.getStock();
if (map != null) {
customerDto1.setStock(new LinkedHashMap(map));
}
return customerDto1;
}
}
//--------------------------------深拷贝----------------------------
@Mapper(mappingControl = DeepClone.class)
public interface Cloner {
Cloner MAPPER = Mappers.getMapper( Cloner.class );
CustomerDto clone(CustomerDto customerDto);
}
// 生成的文件
public CustomerDto clone(CustomerDto customerDto) {
if (customerDto == null) {
return null;
} else {
CustomerDto customerDto1 = new CustomerDto();
customerDto1.setId(customerDto.getId());
customerDto1.setCustomerName(customerDto.getCustomerName());
customerDto1.setOrders(this.orderItemDtoListToOrderItemDtoList(customerDto.getOrders()));
customerDto1.setStock(this.orderItemKeyDtoOrderItemDtoMapToOrderItemKeyDtoOrderItemDtoMap(customerDto.getStock()));
return customerDto1;
}
}
protected OrderItemDto orderItemDtoToOrderItemDto(OrderItemDto orderItemDto) {
if (orderItemDto == null) {
return null;
} else {
OrderItemDto orderItemDto1 = new OrderItemDto();
orderItemDto1.setName(orderItemDto.getName());
orderItemDto1.setQuantity(orderItemDto.getQuantity());
return orderItemDto1;
}
}
protected List<OrderItemDto> orderItemDtoListToOrderItemDtoList(List<OrderItemDto> list) {
if (list == null) {
return null;
} else {
List<OrderItemDto> list1 = new ArrayList(list.size());
Iterator var3 = list.iterator();
while(var3.hasNext()) {
OrderItemDto orderItemDto = (OrderItemDto)var3.next();
list1.add(this.orderItemDtoToOrderItemDto(orderItemDto));
}
return list1;
}
}
protected OrderItemKeyDto orderItemKeyDtoToOrderItemKeyDto(OrderItemKeyDto orderItemKeyDto) {
if (orderItemKeyDto == null) {
return null;
} else {
OrderItemKeyDto orderItemKeyDto1 = new OrderItemKeyDto();
orderItemKeyDto1.setStockNumber(orderItemKeyDto.getStockNumber());
return orderItemKeyDto1;
}
}
protected Map<OrderItemKeyDto, OrderItemDto> orderItemKeyDtoOrderItemDtoMapToOrderItemKeyDtoOrderItemDtoMap(Map<OrderItemKeyDto, OrderItemDto> map) {
if (map == null) {
return null;
} else {
Map<OrderItemKeyDto, OrderItemDto> map1 = new LinkedHashMap(Math.max((int)((float)map.size() / 0.75F) + 1, 16));
Iterator var3 = map.entrySet().iterator();
while(var3.hasNext()) {
Map.Entry<OrderItemKeyDto, OrderItemDto> entry = (Map.Entry)var3.next();
OrderItemKeyDto key = this.orderItemKeyDtoToOrderItemKeyDto((OrderItemKeyDto)entry.getKey());
OrderItemDto value = this.orderItemDtoToOrderItemDto((OrderItemDto)entry.getValue());
map1.put(key, value);
}
return map1;
}
}
字段映射 嵌套使用
public class CustomerDto {
private Long id;
private String customerName;
private List<OrderItemDto> orders;
}
public class Customer {
private Long id;
private String name;
private Collection<OrderItem> orderItems;
}
public class OrderItemDto {
private String name;
private Long quantity;
}
public class OrderItem {
private String name;
private Long quantity;
}
//---------------------------类定义结束-----------------------------------
// uses 涉及嵌套类的时候可以引入另外一个类的转换方法
@Mapper(uses = { OrderItemMapper.class } )
public interface CustomerMapper {
CustomerMapper MAPPER = Mappers.getMapper( CustomerMapper.class );
//将 CustomerDto 转为 Customer
//将原本命名的 orders 转为 orderItems
@Mapping(source = "orders", target = "orderItems")
//将原本命名的 orders 转为 orderItems
@Mapping(source = "customerName", target = "name")
Customer toCustomer(CustomerDto customerDto);
//反转 上面类型的转换 ，可以少写 @Mapping
@InheritInverseConfiguration
CustomerDto fromCustomer(Customer customer);
}
@Mapper
public interface OrderItemMapper {
OrderItemMapper MAPPER = Mappers.getMapper(OrderItemMapper.class);
OrderItem toOrder(OrderItemDto orderItemDto);
@InheritInverseConfiguration
OrderItemDto fromOrder(OrderItem orderItem);
}
集合 转为 拿第一个或者最后一个
public class Source {
private List<Integer> myIntegers;
private List<String> myStrings;
}
public class Target {
private Integer myInteger;
private String myString;
}
@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface FirstElement {
}
@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface LastElement {
}
public class IterableNonIterableUtil {
@FirstElement
public <T> T first( List<T> in ) {
if ( in != null && !in.isEmpty() ) {
return in.get( 0 );
}
else {
return null;
}
}
@LastElement
public <T> T last( List<T> in ) {
if ( in != null && !in.isEmpty() ) {
return in.get( in.size() - 1 );
}
else {
return null;
}
}
}
//---------------------重点 --------------------------注意这里是用到了 IterableNonIterableUtil 方法，
@Mapper( uses = IterableNonIterableUtil.class )
public interface SourceTargetMapper {
SourceTargetMapper MAPPER = Mappers.getMapper( SourceTargetMapper.class );
//字段之间的映射，并且用到了 qualifiedBy (合格者) ，表示使用了有这个注解的方法
@Mapping( source = "myIntegers", target = "myInteger", qualifiedBy = FirstElement.class )
@Mapping( source = "myStrings", target = "myString", qualifiedBy = LastElement.class )
Target toTarget( Source s );
}
// 看下生成是怎么样的
public class SourceTargetMapperImpl implements SourceTargetMapper {
private final IterableNonIterableUtil iterableNonIterableUtil = new IterableNonIterableUtil();
public SourceTargetMapperImpl() {
}
public Target toTarget(Source s) {
if (s == null) {
return null;
} else {
Target target = new Target();
target.setMyInteger((Integer)this.iterableNonIterableUtil.first(s.getMyIntegers()));
target.setMyString((String)this.iterableNonIterableUtil.last(s.getMyStrings()));
return target;
}
}
}
@Context
无法这样子使用
@Mapping(target = "handleProList.typeMain",qualifiedByName = "custom")
@Named(value = "custom")
default String custom(String typeMain ){
return "ss";
}
//但是可以这样子做
@Mapping(target = "typeMain",qualifiedByName = "custom")
@Named(value = "custom")
default String custom(String typeMain ){
return "ss";
}