打开orika的正确方式

<dependency>
    <groupId>ma.glasnost.orika</groupId>
    <artifactId>orika-core</artifactId>
    <version>${orika.version}</version>
</dependency>

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

MapperFacade mapper = mapperFactory.getMapperFacade();
PersonSource source = new PersonSource();
PersonDest destination = mapper.map(source, PersonDest.class);

class Person {
  private String name;
  private int age;
  private Date birthDate;
  List<Address> addresses; // <1>
  // getters/setters omitted
}
class PersonDto { 
  private String name;
  private int age;
  private Date birthDate;
  List<AddressDto> addresses; // <1>
  // getters/setters omitted
}
class Address {
    private String name;
}
class AddressDto {
    private String name;
}

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
Person person = new Person();
//一顿赋值
PersonDto personDto = mapperFactory.getMapperFacade().map(person, PersonDto.class);

public class Person {
  private String id;
  private Name name;
  private List<Name> knownAliases;
  private Date birthDate;
}

public class Name {
  private String first;
  private String last; 
}

public class PersonDto {
  private String personId;
  private String firstName;
  private String lastName;
  private Date birthDate;
  private String[][] aliases;
}

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
factory.classMap(Person.class, PersonDto.class) // <2>
      .field("id","personId")
      .field("name.first", "firstName")
      .field("name.last", "lastName")
      .field("knownAliases{first}", "aliases{[0]}")
      .field("knownAliases{last}", "aliases{[1]}")
      .byDefault() //<1>
      .register();

classMapBuilder.field("a","b");//Person和PersonDto的双向映射
classMapBuilder.fieldAToB("a","b");//单向映射  
classMapBuilder.fieldBToA("a","b");//单向映射
classMapBuilder.exclude("a");//移除指定的字段映射，即使字段名相同也不会拷贝
classMapBuilder.field("a","b").mapNulls(false).mapNullsInReverse(false);//是否拷贝空属性，默认是true

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();List<Person> persons = new ArrayList<>();List<PersonDto> personDtos = mapperFactory.getMapperFacade().mapAsList(persons, PersonDto.class);

class A {  private B b;}class B {    private C c;}class C {    private D d;}class D {    private String name;}

public class Response<T> {    private T data;}public class ResponseDto<T> {    private T data;}

@Testpublic void genericTest1(){    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();    Response<String> response = new Response<>();    response.setData("test generic");    ResponseDto<String> responseDto = mapperFactory.getMapperFacade().map(response, ResponseDto.class);// *    Assert.assertFalse("test generic".equals(responseDto.getData()));}

@Testpublic void genericTest2(){    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();    Response<Person> response = new Response<>();    Person person = new Person();    person.setName("test generic");    response.setData(person);    Response<PersonDto> responseDto = mapperFactory.getMapperFacade().map(response, Response.class);    Assert.assertFalse(responseDto.getData() instanceof PersonDto);}

@Testpublic void genericTest1() {    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();    Response<String> response = new Response<>();    response.setData("test generic");    Type<Response<String>> fromType = new TypeBuilder<Response<String>>() {}.build();    Type<ResponseDto<String>> toType = new TypeBuilder<ResponseDto<String>>() {}.build();    ResponseDto<String> responseDto = mapperFactory.getMapperFacade().map(response, fromType, toType);    Assert.assertTrue("test generic".equals(responseDto.getData()));}

@Testpublic void genericTest2() {    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();    Response<Person> response = new Response<>();    Person person = new Person();    person.setName("test generic");    response.setData(person);    Type<Response<Person>> fromType = new TypeBuilder<Response<Person>>() {}.build();    Type<Response<PersonDto>> toType = new TypeBuilder<Response<PersonDto>>() {}.build();    Response<PersonDto> responseDto = mapperFactory.getMapperFacade().map(response, fromType, toType);    Assert.assertEquals("test generic" , responseDto.getData().getName());}

@Testpublic void deepCloneTest() throws Exception {    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();    Person person = new Person();    Address address = new Address();    person.setAddress(address);    PersonDto personDto = mapperFactory.getMapperFacade().map(person, PersonDto.class);    Assert.assertFalse(personDto.getAddress().hashCode() == person.getAddress().hashCode());}