• 基于grpc从零开始搭建一个准生产分布式应用(6) - 03 - MapStruct高级映射

    一、对象工厂

    在映射成目标对象时，创建目标对象实例，可以使用@ObjectFactory注解的方法取代调用默认的构造方法创建目标对象，工厂方法可以是无参返回类型是目标类型的方法，无参的工厂方法可以不设置@ObjectFactory注解；或有参返回类型是目标类型的方法，参数可以用@TargetType或@Context注解。

    • 为避免返回类型有泛型时的匹配错误，特别是继承List的类的情况下，不建议使用无参的工厂方法。
    • 例如protobuf中的repeated·string生成的ProtocolStringList要在CollectionMappingStrategy.ACCESSOR_ONLY策略下使用。

    1.1、自定义工厂@ObjectFactory

    可用来生成默认source。

    1. @Data
    2. public class TestFivePO {
    3.     private TestFourPO test;
    4.     private TestPO testPO;
    5. }
    6. @Mapper
    7. public class BaseMapper {
    8.     @ObjectFactory-------注解
    9.     public TestSixBO createSixBO() {
    10.         TestSixBO testSixBO = new TestSixBO();
    11.         testSixBO.setId(1L);
    12.         return testSixBO;
    13.     }
    14. }
    15.  
    16. @Mapper(uses = BaseMapper.class)
    17. public interface TestMapper {
    18.     @Mapping(target = "test.id", ignore = true)
    19.     TestSevenBO toBOS(TestFivePO testPO);
    20. }
    21.  
    22. @Component
    23. public class TestMapperImpl implements TestMapper {
    24.     @Autowired
    25.     private BaseMapper baseMapper;
    26.     @Override
    27.     public TestSevenBO toBOS(TestFivePO testPO) {
    28.         if ( testPO == null ) {
    29.             return null;
    30.         }
    31.         TestSevenBO testSevenBO = new TestSevenBO();
    32.         testSevenBO.setTest( testFourPOToTestSixBO( testPO.getTest() ) ); 
    33.         return testSevenBO;
    34.     }
    35.  
    36.     protected TestSixBO testFourPOToTestSixBO(TestFourPO testFourPO) {
    37.         if ( testFourPO == null ) {
    38.             return null;
    39.         }
    40.         TestSixBO testSixBO = baseMapper.createSixBO();//只用在了这行。
    41.         testSixBO.setName( testFourPO.getName() );
    42.         testSixBO.setCreateTime( testFourPO.getCreateTime() );
    43.         return testSixBO;
    44.     }
    45. }

    1.2、泛型工厂@TargetType

    1. @Mapper
    2. public class BaseMapper {
    3.     @ObjectFactory
    4.     public extends BaseBO> T createSixBO(@TargetType Class tClass) throws IllegalAccessException, InstantiationException {
    5.         T t = tClass.newInstance();
    6.         t.setId(3L);
    7.         return t;
    8.     } 
    9. }
    10.  
    11. testSevenBO.setTest( testFourPOToTestSixBO( testPO.getTest() ) );

    二、高级映射选项

    2.1、默认值defaultValue

    1. //给@Mapping的属性defaultValue设置一个值，若果源字段为空，那么目标字段就为此默认值
    2. @Mapping(target = "name", source = "name", defaultValue = "noName")
    3. TestBO toBO(TestPO testPO);

    2.2、表达式expression和defaultExpression

    1. @Mapping(target = "name", expression = "java(testPO.getName() + \"BO\")")
    2. @Mapping(target = "totalPrice", expression = "java(testThreePO.getTotalPrice().toString() + \"元\")")
    3. TestBO toBO(TestPO testPO);
    4.  
    5. 还可以设置@Mapping的defaultExpression设置默认表达式，在source的值为null时，调用此默认表达式代码。
    6. @Mapping(target = "name", source = "name", defaultExpression  = "java(StringBOUtils.toBOString(testPO.getName()))")
    7.  
    8. @Mapping(target = "state", expression = "java(net.shukun.universe.core.common.DoctorMapStructUtil.doctorId1(var1.getState()))" )
    9. //这块需要注意包装类型
    10. @Mapping(target = "state", expression = "java(DoctorMapStructUtil.getStateByName(var1.getState().getValue()).getCode())" )
    1. public class StringBOUtils { 
    2.     public static String toBOString(String poString) {
    3.         return poString + "BO";
    4.     }
    5. }
    6. //使用 imports 
    7. @Mapper(uses = BaseMapper.class, imports = {StringBOUtils.class})
    8. public interface TestMapper {
    9.     @Mapping(target = "name", expression = "java(StringBOUtils.toBOString(testPO.getName()))")
    10.     TestBO toBO(TestPO testPO);
    11. }
    1. //还可以设置@Mapping的defaultExpression设置默认表达式，在source的值为null时，调用此默认表达式代码
    2. @Mapping(target = "name", source = "name", defaultExpression  = "java(StringBOUtils.toBOString(testPO.getName()))")
    3. TestBO toBO(TestPO testPO);

    2.3、确定映射结果的具体类型resultType属性

    如果映射的结果是父类，又存在不同子类的映射方法，编译会报错，此时需要使用@Mapping或@BeanMapping的resultType指定映射结果的具体类型。

    1. @Mapper
    2. public class BaseMapper {
    3.     public TestSixBO createSixBO() {
    4.         return new TestSixBO();
    5.     }
    6.     public TestEightBO createEightBO() {
    7.         return new TestEightBO();
    8.     }
    9. }
    10. @Mapper(uses = {BaseMapper.class})
    11. public interface TestMapper {
    12.     @BeanMapping(resultType = TestEightBO.class)
    13.     BaseBO toBO(TestFourPO testFourPO);
    14. }

    2.4、NULL映射控制

    2.4.1、源对象NULL映射

    当映射的source对象为null时可以通过@BeanMapping、@IterableMapping、@MapMapping（优先级最高），@Mappe，@MappingConfig（优先级最低）的nullValueMappingStrategy策略来控制NULL值的映射结果。策略值有：

    • NullValueMappingStrategy.RETURN_NULL（默认，源为null，目标直接返回null）；
    • NullValueMappingStrategy.RETURN_DEFAULT（返回一个对象，除填充的常量和表达式，其他字段属性为空；集合返回一个对象，size为0）。

    @IterableMapping：

    集合使用了NullValueMappingStrategy.RETURN_DEFAULT策略所以源为NULL时返回return new ArrayList()；bean对象使用默认策略所以源为NULL时返回return null。

    1. @Mapper
    2. public interface TestMapper {
    3.     @IterableMapping(nullValueMappingStrategy = NullValueMappingStrategy.RETURN_DEFAULT)
    4.     List<TestThreeBO> toBO(List<TestFivePO> testFivePO);
    5. }
    6.  
    7. @Component
    8. public class TestMapperImpl implements TestMapper {
    9.  
    10.     @Override
    11.     public List<TestThreeBO> toBO(List<TestFivePO> testFivePO) {
    12.         if ( testFivePO == null ) {
    13.             return new ArrayList<TestThreeBO>();
    14.         }
    15.  
    16.         List<TestThreeBO> list = new ArrayList<TestThreeBO>( testFivePO.size() );
    17.         for ( TestFivePO testFivePO1 : testFivePO ) {
    18.             list.add( testFivePOToTestThreeBO( testFivePO1 ) );
    19.         }
    20.  
    21.         return list;
    22.     }
    23.  
    24.     protected TestBO testPOToTestBO(TestPO testPO) {
    25.         if ( testPO == null ) {
    26.             return null;
    27.         }
    28.  
    29.         TestBO testBO = new TestBO();
    30.  
    31.         testBO.setId( testPO.getId() );
    32.         testBO.setName( testPO.getName() );
    33.         if ( testPO.getPrice() != null ) {
    34.             testBO.setPrice( testPO.getPrice().toString() );
    35.         }
    36.         if ( testPO.getCreateTime() != null ) {
    37.             testBO.setCreateTime( new SimpleDateFormat().format( testPO.getCreateTime() ) );
    38.         }
    39.  
    40.         return testBO;
    41.     }
    42.  
    43.     protected TestThreeBO testFivePOToTestThreeBO(TestFivePO testFivePO) {
    44.         if ( testFivePO == null ) {
    45.             return null;
    46.         }
    47.  
    48.         TestThreeBO testThreeBO = new TestThreeBO();
    49.  
    50.         testThreeBO.setTest( testPOToTestBO( testFivePO.getTest() ) );
    51.  
    52.         return testThreeBO;
    53.     }
    54. }

    @BeanMapping

    1. @Mapper
    2. public interface TestMapper {
    3.     @BeanMapping(nullValueMappingStrategy = NullValueMappingStrategy.RETURN_DEFAULT)
    4.     @Mapping(target = "id", constant = "0L")
    5.     @Mapping(target = "name", expression = "java(testPO.getName() + \"BO\")")
    6.     TestBO toBO(TestPO testPO);
    7. }
    8.  
    9. @Component
    10. public class TestMapperImpl implements TestMapper {
    11.  
    12.     @Override
    13.     public TestBO toBO(TestPO testPO) {
    14.  
    15.         TestBO testBO = new TestBO();
    16.  
    17.         if ( testPO != null ) {
    18.             if ( testPO.getPrice() != null ) {
    19.                 testBO.setPrice( testPO.getPrice().toString() );
    20.             }
    21.             else {
    22.                 testBO.setPrice( testPO.getPrice() + "BO" );
    23.             }
    24.             if ( testPO.getCreateTime() != null ) {
    25.                 testBO.setCreateTime( new SimpleDateFormat().format( testPO.getCreateTime() ) );
    26.             }
    27.         }
    28.         testBO.setId( (long) 0L );
    29.         testBO.setName( testPO.getName() + "BO" );
    30.  
    31.         return testBO;
    32.     }
    33. }
    2.4.2、在更新时源对象属性NULL映射

    在使用@MappingTarget更新目标时，可以设置@Mapping、@BeanMapping（优先级最高），@Mapper或@MappingConfig（优先级最底）的nullValuePropertyMappingStrategy属性值，用于设置当源对象属性为null时，如何设置目标属性的值。nullValuePropertyMappingStrategy的值有：

    • NullValuePropertyMappingStrategy.SET_TO_DEFAULT：源属性为null，目标属性会被赋予特定的默认值。List被赋予ArrayList，Map被赋予HashMap，数组就是空数组，String是“”，基本类型或包装类是0或false，对象是空的构造方法。
    • NullValuePropertyMappingStrategy.IGNORE：源属性为null，忽略目标属性的设值。
    • NullValuePropertyMappingStrategy.SET_TO_NULL：默认，源属性是null，目标属性也是null。
    1. @Mapper
    2. public interface TestMapper {
    3.     @Mapping(target = "name", nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT)
    4.     @Mapping(target = "price", nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
    5.     void toBO(TestPO testPO, @MappingTarget TestBO testBO);
    6. }
    7.  
    8. @Component
    9. public class TestMapperImpl implements TestMapper {
    10.  
    11.     @Override
    12.     public void toBO(TestPO testPO, TestBO testBO) {
    13.         if ( testPO == null ) {
    14.             return;
    15.         }
    16.  
    17.         if ( testPO.getName() != null ) {
    18.             testBO.setName( testPO.getName() );
    19.         }
    20.         else {
    21.             testBO.setName( "" );
    22.         }
    23.         if ( testPO.getPrice() != null ) {
    24.             testBO.setPrice( testPO.getPrice().toString() );
    25.         }
    26.         testBO.setId( testPO.getId() );
    27.         if ( testPO.getCreateTime() != null ) {
    28.             testBO.setCreateTime( new SimpleDateFormat().format( testPO.getCreateTime() ) );
    29.         }
    30.         else {
    31.             testBO.setCreateTime( null );
    32.         }
    33.     }
    34. }

    三、映射扩展

    3.1、装饰器映射

    在进行映射时可以通过装饰器模式，为目标对象设置一些，不能由源对象直接生成或者源对象没有的属性。spring注入策略的装饰器映射使用@DecoratedWith注解制定装饰器。装饰器中使用@Qualifier("delegate")指定注入的bean。

    1. @Mapper
    2. @DecoratedWith(TestDecotator.class)
    3. public interface TestMapper {
    4.     TestBO toTestBO(TestPO testPO);
    5. }
    6.  
    7. public  abstract class TestDecorator implements TestMapper {
    8.     @Autowired
    9.     @Qualifier("delegate")
    10.     private TestMapper testMapper;
    11.  
    12.     @Override
    13.     public TestBO toTestBO(TestPO testPO) {
    14.         TestBO testBO = testMapper.toTestBO(testPO);
    15.         testBO.setName("1111");//这处应该是个组合关系，用来设计一些特定的不能由源对象直接映射的赋值操作
    16.         return testBO;
    17.     }
    18. }
    19.  ================================生成的代码如下================================
    20. class TestMapperImpl extends TestDecorator implements TestMapper {
    21.     private final TestMapper delegate;
    22.     public TestMapperImpl() {
    23.         this( new TestMapperImpl_() );
    24.     }
    25.     private TestMapperImpl(TestMapperImpl_ delegate) {
    26.         this.delegate = delegate;
    27.     }
    28. }
    29.  
    30. class TestMapperImpl_ implements TestMapper {
    31.  
    32.     @Override
    33.     public TestBO toTestBO(TestPO testPO) {
    34.         if ( testPO == null ) {
    35.             return null;
    36.         }
    37.  
    38.         TestBO testBO = new TestBO();
    39.  
    40.         testBO.setId( testPO.getId() );
    41.         testBO.setName( testPO.getName() );
    42.         testBO.setPrice( testPO.getPrice() );
    43.         testBO.setCreteTime( testPO.getCreteTime() );
    44.  
    45.         return testBO;
    46.     }
    47. }

    3.2、映射前置/后置方法

    可以在抽象mapper类、Mapper#uses引入的类或被@Context注解的上下文对象类中设置映射前后的回调方法。@BeforeMapping注解的方法是前置方法，@AfterMapping注解的方法是后置方法。如果前后置方法具有参数，返回的类型能被赋予映射方法的返回类型并且参数都可以用源/目标参数获取，才会调用前后置方法。

    前后置方法中用@MappingTarget注解的参数获得的是目标实例，@TargetType获取的是目标类型，@Context可以获取上下文对象，其他的参数被赋予源参数。然后前后置方法不是void的，返回的值不为null的情况下将作为映射方法的返回值。同样，若前后置方法能匹配到多个，将会都调用，可以通过给前置方法添加@Named和映射方法上添加@BeanMapping#qualifiedByName制定要调用的前后置方法；一旦使用了@BeanMapping#qualifiedByName就必须指定自己选用调用的所有前后置方法的@Named名。不带@MappingTarget注解参数的@BeforeMapping会在源参数进行null检查并且构造新的目标bean之前调用；带@MappingTarget注解参数的@BeforeMapping会在构造新的目标bean之后调用；@AfterMapping会在return前最后调用。在使用建造者时，@BeforeMapping、@AfterMapping中要想获取目标对象，@MappingTarget注解的就必须是建造者。

    1. @Mapper
    2. @Named("baseMapper")
    3. public class BaseMapper {
    4.  
    5.     @BeforeMapping
    6.     @Named("before")
    7.     public void before(BasePO basePO, @MappingTarget BaseBO baseBO) {
    8.         System.out.println(basePO);
    9.         System.out.println(baseBO);
    10.     }
    11.  
    12.     @AfterMapping
    13.     public  T after(@TargetType Class clazz, @Context ThreadLocalContext threadLocalContext){
    14.         System.out.println(threadLocalContext);
    15.         T t = null;
    16.         try {
    17.            t = clazz.newInstance();
    18.         } catch (InstantiationException | IllegalAccessException e) {
    19.             e.printStackTrace();
    20.         }
    21.         return t;
    22.     }
    23.  
    24. }
    25.  
    26. @Data
    27. public class ThreadLocalContext {
    28.  
    29.     private ThreadLocal threadLocal;
    30.  
    31.     public ThreadLocalContext() {
    32.         threadLocal = new ThreadLocal<>();
    33.     }
    34.  
    35.     @BeforeMapping
    36.     @Named("before2")
    37.     public static void before2(BasePO basePO, @MappingTarget BaseBO baseBO) {
    38.         System.out.println(basePO);
    39.         System.out.println(baseBO);
    40.     }
    41. }
    42.  
    43. @Mapper(uses = BaseMapper.class)
    44. public interface TestMapper {
    45.  
    46.     @BeanMapping(qualifiedByName = { "baseMapper"})
    47.     TestSixBO toTestBO(TestFourPO testPO, @Context ThreadLocalContext threadLocalContext);
    48.  
    49. }
    50.  
    51. @Component
    52. public class TestMapperImpl implements TestMapper {
    53.  
    54.     @Autowired
    55.     private BaseMapper baseMapper;
    56.  
    57.     @Override
    58.     public TestSixBO toTestBO(TestFourPO testPO, ThreadLocalContext threadLocalContext) {
    59.         if ( testPO == null ) {
    60.             return null;
    61.         }
    62.  
    63.         TestSixBO testSixBO = new TestSixBO();
    64.  
    65.         baseMapper.before( testPO, testSixBO );
    66.  
    67.         testSixBO.setId( testPO.getId() );
    68.         testSixBO.setName( testPO.getName() );
    69.         if ( testPO.getCreateTime() != null ) {
    70.             testSixBO.setCreateTime( new SimpleDateFormat().format( testPO.getCreateTime() ) );
    71.         }
    72.  
    73.         TestSixBO target = baseMapper.after( TestSixBO.class, threadLocalContext );
    74.         if ( target != null ) {
    75.             return target;
    76.         }
    77.  
    78.         return testSixBO;
    79.     }
    80. }
      81.  

      1. public interface LicenseModelTranslator {
      2.  
      3.     LicenseModelTranslator INSTANCE = Mappers.getMapper(LicenseModelTranslator.class);
      4.  
      5.     @Mapping(target = "activationInfo",ignore = true)
      6.     @Mapping(target = "operatorUid", source = "operatorUserId")
      7.     @Mapping(target = "createdAt", source = "ctime")
      8.     LicenseActivationRecordBo toActivationRecordBo(ActivationRecordEntity var1);
      9.  
      10.     List<LicenseActivationRecordBo> toActivationRecordBos(List<ActivationRecordEntity> var1);
      11.  
      12.     @AfterMapping
      13.     default void  setLicenseActivationInfoBo(@MappingTarget LicenseActivationRecordBo bo,  ActivationRecordEntity var1) {
      14.         List<LicenseActivationInfoBo> activationInfo = JSONUtil.toList(var1.getActivationInfo(), LicenseActivationInfoBo.class);
      15.         bo.setActivationInfo(activationInfo);
      16.     }
      17. }
       

      3.3、父子结构映射
       

      1. public class Employee {
      2.     private String name;
      3.     private Employee reportsTo;
      4.     private List team;
      5. }
      6. public class EmployeeDto {
      7.     private String employeeName;
      8.     private EmployeeDto reportsTo;
      9.     private List team;
      10. }
      11. @Mapper
      12. public interface EmployeeMapper {
      13.  
      14.     EmployeeMapper MAPPER = Mappers.getMapper( EmployeeMapper.class );
      15.  
      16.     @Mapping(source = "employeeName", target = "name")
      17.     Employee toEmployee(EmployeeDto employeeDto, @Context CycleAvoidingMappingContext context);
      18.  
      19.     @InheritInverseConfiguration
      20.     EmployeeDto fromEmployee(Employee employee, @Context CycleAvoidingMappingContext context);
      21. }
       

      1. public class CycleAvoidingMappingContext {
      2.     private Map<Object, Object> knownInstances = new IdentityHashMap<Object, Object>();
      3.  
      4.     @BeforeMapping
      5.     public  T getMappedInstance(Object source, @TargetType Class targetType) {
      6.         return (T) knownInstances.get( source );
      7.     }
      8.  
      9.     @BeforeMapping
      10.     public void storeMappedInstance(Object source, @MappingTarget Object target) {
      11.         knownInstances.put( source, target );
      12.     }
      13. }
       

      3.3.1、循环嵌套对象调用前后置方法
       

      1. @Data
      2. public class TestBOS {
      3.  
      4.     private TestBOS testS;
      5.  
      6.     private List list;
      7. }
      8.  
      9. @Data
      10. public class TestPOS {
      11.  
      12.     private TestPOS testS;
      13.  
      14.     private List list;
      15. }
      16.  
      17. @Mapper
      18. public class BaseMapper {
      19.  
      20.     @BeforeMapping
      21.     public  T before(Object source, @TargetType Class targetType) {
      22.         T t;
      23.         try {
      24.             t = targetType.newInstance();
      25.         } catch (InstantiationException | IllegalAccessException e) {
      26.             return null;
      27.         }
      28.         return t;
      29.     }
      30.  
      31. }
      32.  
      33.  
      34. @Mapper(uses = BaseMapper.class)
      35. public interface TestMapper {
      36.  
      37.     TestBOS toBean(TestPOS testPOS);
      38.  
      39. }
       

      四、高级映射属性
       

      4.1、映射配置继承@InheritConfiguration
       

      @InheritConfiguration可以继承@Mapping，@BeanMapping，@IterableMapping的映射规则。@InheritConfiguration注解的方法上，有需要映射的字段，它会搜索有相同配置的映射，找到了直接复用此映射；若找到多个方法上都有满足此映射的配置，需要制定@InheritConfiguration#name的值，制定继承方法的映射。
       

      1. @Data
      2. @ToString
      3. public class TestPO {
      4.     private String name;
      5. }
      6.  
      7. @Data
      8. @ToString
      9. public class TestBO {
      10.     private String nickName;
      11. }
      12.  
      13. @Data
      14. public class TestTwoBO {
      15.     private String realName;
      16. }
      17.  
      18. @Mapper
      19. public interface TestMapper {
      20.     @Mapping(target = "nickName", source = "name", defaultValue = "nickName")
      21.     TestBO toTestBO(TestPO testPO);
      22.     @Mapping(target = "nickName", source = "name", defaultValue = "realName")
      23.     TestBO toTestTwoBO(TestPO testPO);
      24.     @InheritConfiguration(name = "toTestTwoBO")
      25.     TestBO toTestThreeBO(TestPO testPO); //toTestThreeBO的实现方法在设置nickName时，继承的toTestTwoBO方法的映射配置。
      26. }
       

      4.2、逆映射@InheritInverseConfiguration
       

      当我们定义了一种对象到另一种对象的映射后，可以通过@InheritInverseConfiguration直接进行逆映射。可以看到实现的toTestBO方法中的price->priceString使用的就是toTestPO中priceString->price的逆映射，但是正映射的@Mapping#expression、#defaultExpression、#defaultValue和#constant会被逆映射忽略，就如其中的默认值“-1”在逆映射中不存在；此外某个字段的逆映射可以被ignore，expression或constant覆盖，就如name->nameString；在正映射的createTimeString->createTime上设置了ignore，若此时同时制定了source，则逆映射会继承ignore，不用再重新设置。@InheritConfiguration的优先级高于@InheritInverseConfiguration。
       

      1. @Data
      2. @ToString
      3. public class TestPO { 
      4.     private Long id; 
      5.     private String nameString;
      6.     private BigDecimal priceString;
      7.     private Date createTimeString;
      8. }
      9.  //InheritInverseConfiguration 这个注解是一个相对的操作，必须要有前提此处才会有用，比如下例中必须有TestBO  toTestBO(TestPO testPO)才可以，也就是为了少写
      10.  //映射代码，如果有多个类似的话，可以用@InheritInverseConfiguration( name = "toTestBO" )指定一个原实现方法名
      11. @Mapper
      12. public interface TestMapper {
      13.     @Mapping(target = "price", source = "priceString", defaultValue = "-1")
      14.     @Mapping(target = "name", source = "nameString")
      15.     @Mapping(target = "createTime", source = "createTimeString", ignore = true)
      16.     TestBO  toTestBO(TestPO testPO);
      17.  
      18.     @InheritInverseConfiguration
      19.     @Mapping(target = "nameString", constant = "namePO")
      20.     TestPO  toTestBO(TestBO testBO);
      21. }
      22.  
      23.  
      24. @Component
      25. public class TestMapperImpl implements TestMapper {
      26.     @Override
      27.     public TestBO toTestBO(TestPO testPO) {
      28.         if ( testPO == null ) {
      29.             return null;
      30.         }
      31.  
      32.         TestBO testBO = new TestBO();
      33.  
      34.         if ( testPO.getPriceString() != null ) {
      35.             testBO.setPrice( testPO.getPriceString().toString() );
      36.         }
      37.         else {
      38.             testBO.setPrice( "-1" );
      39.         }
      40.         testBO.setName( testPO.getNameString() );
      41.         testBO.setId( testPO.getId() );
      42.  
      43.         return testBO;
      44.     }
      45.  
      46.     @Override
      47.     public TestPO toTestBO(TestBO testBO) {
      48.         if ( testBO == null ) {
      49.             return null;
      50.         }
      51.  
      52.         TestPO testPO = new TestPO();
      53.         if ( testBO.getPrice() != null ) {
      54.             testPO.setPriceString( new BigDecimal( testBO.getPrice() ) );
      55.         }
      56.         testPO.setId( testBO.getId() );
      57.         testPO.setNameString( "namePO" );
      58.         return testPO;
      59.     }
      60. }
       

      4.3、配置共享
       

      @MapperConfig注解的接口就是共享配置，可以在@Mapper#config指定共享配置，@MapperConfig中的属性和@Mapper相同，@Mapper中的属性会覆盖@MapperConfig。共享配置中可以设置原型映射，也可以是父类映射，再通过@MapperConfig、@Mapper的mappingInheritanceStrategy就可以实现原型映射的继承。mappingInheritanceStrategy的值有：
       

      • MappingInheritanceStrategy.EXPLICIT：默认，要想继承原型映射必须使用@InheritConfiguration或@InheritInverseConfiguration注解方法，且此方法的源类型和目标类型要能赋予原型映射类型；
      • MappingInheritanceStrategy.AUTO_INHERIT_FROM_CONFIG：不需要@InheritConfiguration注解方法，只需要满足类型条件就能继承，但只能是正映射；
      • MappingInheritanceStrategy.AUTO_INHERIT_REVERSE_FROM_CONFIG：不需要@InheritInverseConfiguration注解方法，只需要满足类型条件就能继承，但只能是逆映射；
      • MappingInheritanceStrategy.AUTO_INHERIT_ALL_FROM_CONFIG：不需要@InheritInverseConfiguration注解方法，只需要满足类型条件就能继承，正/逆映射都可以。
       

      以上也都要注意映射类型冲突，冲突同样需要指明name属性。
       

      1. @Data
      2. @ToString
      3. public class BaseBO {
      4.     private Long id;
      5.     private String name;
      6.     private String createTimeString;
      7. }
      8.   
      9. @MapperConfig
      10. public interface BaseConfig {
      11.     @Mapping(target = "createTimeString", source = "createTime")
      12.     BaseBO toTestBaseBO(BasePO basePO);
      13. }
       

      4.3.1、MappingInheritanceStrategy.EXPLICIT
       

      共享配置的原型映射并不会生成单独的实现方法。虽然默认继承策略支持正/逆，但是引入共享配置，且mapper中正映射能继承原型映射的情况下，再设置逆映射方法，就必须制定name属性，否则同样有冲突报错。
       

      1. @Mapper(config = BaseConfig.class, mappingInheritanceStrategy = MappingInheritanceStrategy.EXPLICIT)
      2. public interface TestMapper {
      3.  
      4.     @InheritConfiguration
      5.     void updateBO(TestFourPO testFourPO, @MappingTarget TestSixBO testSixBO);
      6.  
      7.     @InheritInverseConfiguration(name = "toTestBaseBO")
      8.     void updatePO(TestSixBO testSixBO, @MappingTarget TestFourPO testFourPO);
      9.  
      10. }
      11.  
      12. @Component
      13. public class TestMapperImpl implements TestMapper {
      14.  
      15.     @Override
      16.     public void updateBO(TestFourPO testFourPO, TestSixBO testSixBO) {
      17.         if ( testFourPO == null ) {
      18.             return;
      19.         }
      20.  
      21.         if ( testFourPO.getCreateTime() != null ) {
      22.             testSixBO.setCreateTimeString( new SimpleDateFormat().format( testFourPO.getCreateTime() ) );
      23.         }
      24.         else {
      25.             testSixBO.setCreateTimeString( null );
      26.         }
      27.         testSixBO.setId( testFourPO.getId() );
      28.         testSixBO.setName( testFourPO.getName() );
      29.     }
      30.  
      31.     @Override
      32.     public void updatePO(TestSixBO testSixBO, TestFourPO testFourPO) {
      33.         if ( testSixBO == null ) {
      34.             return;
      35.         }
      36.  
      37.         try {
      38.             if ( testSixBO.getCreateTimeString() != null ) {
      39.                 testFourPO.setCreateTime( new SimpleDateFormat().parse( testSixBO.getCreateTimeString() ) );
      40.             }
      41.             else {
      42.                 testFourPO.setCreateTime( null );
      43.             }
      44.         }
      45.         catch ( ParseException e ) {
      46.             throw new RuntimeException( e );
      47.         }
      48.         testFourPO.setId( testSixBO.getId() );
      49.         testFourPO.setName( testSixBO.getName() );
      50.     }
      51. }
       

      4.3.2、MappingInheritanceStrategy.AUTO_INHERIT_FROM_CONFIG
       

      1. @Mapper(config = BaseConfig.class, mappingInheritanceStrategy = MappingInheritanceStrategy.AUTO_INHERIT_FROM_CONFIG)
      2. public interface TestMapper {
      3.  
      4.     void updateBO(TestFourPO testFourPO, @MappingTarget TestSixBO testSixBO);
      5.  
      6. }
      7.  
      8. @Component
      9. public class TestMapperImpl implements TestMapper {
      10.  
      11.     @Override
      12.     public void updateBO(TestFourPO testFourPO, TestSixBO testSixBO) {
      13.         if ( testFourPO == null ) {
      14.             return;
      15.         }
      16.  
      17.         if ( testFourPO.getCreateTime() != null ) {
      18.             testSixBO.setCreateTimeString( new SimpleDateFormat().format( testFourPO.getCreateTime() ) );
      19.         }
      20.         else {
      21.             testSixBO.setCreateTimeString( null );
      22.         }
      23.         testSixBO.setId( testFourPO.getId() );
      24.         testSixBO.setName( testFourPO.getName() );
      25.     }
      26. }
       

      4.3.3、MappingInheritanceStrategy.AUTO_INHERIT_REVERSE_FROM_CONFIG
       

      1. @Mapper(config = BaseConfig.class, mappingInheritanceStrategy = MappingInheritanceStrategy.AUTO_INHERIT_ALL_FROM_CONFIG)
      2. public interface TestMapper {
      3.  
      4.     void updatePO(TestSixBO testSixBO, @MappingTarget TestFourPO testFourPO);
      5.  
      6. }
      7.  
      8. @Component
      9. public class TestMapperImpl implements TestMapper {
      10.  
      11.     @Override
      12.     public void updatePO(TestSixBO testSixBO, TestFourPO testFourPO) {
      13.         if ( testSixBO == null ) {
      14.             return;
      15.         }
      16.  
      17.         try {
      18.             if ( testSixBO.getCreateTimeString() != null ) {
      19.                 testFourPO.setCreateTime( new SimpleDateFormat().parse( testSixBO.getCreateTimeString() ) );
      20.             }
      21.             else {
      22.                 testFourPO.setCreateTime( null );
      23.             }
      24.         }
      25.         catch ( ParseException e ) {
      26.             throw new RuntimeException( e );
      27.         }
      28.         testFourPO.setId( testSixBO.getId() );
      29.         testFourPO.setName( testSixBO.getName() );
      30.     }
      31. }
       

      4.3.4、MappingInheritanceStrategy.AUTO_INHERIT_ALL_FROM_CONFIG
       

      1. @Mapper(config = BaseConfig.class, mappingInheritanceStrategy = MappingInheritanceStrategy.AUTO_INHERIT_ALL_FROM_CONFIG)
      2. public interface TestMapper {
      3.  
      4.     void updateBO(TestFourPO testFourPO, @MappingTarget TestSixBO testSixBO);
      5.  
      6.     void updatePO(TestSixBO testSixBO, @MappingTarget TestFourPO testFourPO);
      7.  
      8. }
      9.  
      10. @Component
      11. public class TestMapperImpl implements TestMapper {
      12.  
      13.     @Override
      14.     public void updateBO(TestFourPO testFourPO, TestSixBO testSixBO) {
      15.         if ( testFourPO == null ) {
      16.             return;
      17.         }
      18.  
      19.         if ( testFourPO.getCreateTime() != null ) {
      20.             testSixBO.setCreateTimeString( new SimpleDateFormat().format( testFourPO.getCreateTime() ) );
      21.         }
      22.         else {
      23.             testSixBO.setCreateTimeString( null );
      24.         }
      25.         testSixBO.setId( testFourPO.getId() );
      26.         testSixBO.setName( testFourPO.getName() );
      27.     }
      28.  
      29.     @Override
      30.     public void updatePO(TestSixBO testSixBO, TestFourPO testFourPO) {
      31.         if ( testSixBO == null ) {
      32.             return;
      33.         }
      34.  
      35.         try {
      36.             if ( testSixBO.getCreateTimeString() != null ) {
      37.                 testFourPO.setCreateTime( new SimpleDateFormat().parse( testSixBO.getCreateTimeString() ) );
      38.             }
      39.             else {
      40.                 testFourPO.setCreateTime( null );
      41.             }
      42.         }
      43.         catch ( ParseException e ) {
      44.             throw new RuntimeException( e );
      45.         }
      46.         testFourPO.setId( testSixBO.getId() );
      47.         testFourPO.setName( testSixBO.getName() );
      48.     }
      49. }
       

      
                
                    
                

                
    81. 

                    相关阅读:
      
                    
数据结构与算法 | 第一章：概论                            
      
LeetCode:1480.一维数组的动态和                            
      
如何只使用TD跟踪微分器改进普通PID控制(附完整梯形图代码）                            
      
vue3.0运行npm run dev 报错Cannot find module node:url                            
      
【JDBC】JDBC的基本使用                            
      
基于CUBEMX的STM32F4 Hal库，配置LVGL（无操作系统版）                            
      
ElasticSearch详解                            
      
C语言入门（二）运算符和表达式                            
      
Drogon源码剖析                            
      
openlayers多边形的绘制的撤销/回退                            
      
                          
                
      82. 
                
    82. 
                    原文地址：https://blog.csdn.net/liudonglovehemin/article/details/132848425
                
      83.