0
点赞
收藏
分享

微信扫一扫

基于grpc从零开始搭建一个准生产分布式应用(6) -05- MapStruct特殊实现

一、clone

@Mapper(mappingControl = DeepClone.class)//这里需要注意用这个注解
public interface Cloner {
Cloner MAPPER = Mappers.getMapper( Cloner.class );
CustomerDto clone(CustomerDto customerDto);
}

二、特殊注解

2.1、@qualifiedBy

​这个注解的作用是当有重复的转换类时,指定一个,但也可以用注解来实现,下面的例子就是从一个集合中的对象中特定的地方取值然后mapping到特定的属性上,下面是一个集合应用。

public class Source {
private List<Integer> myIntegers;
private List<String> myStrings;
}
public class Target {
private Integer myInteger;
private String myString;
}
public static void main( String[] args ) {
Source s = new Source();
s.setMyIntegers( Arrays.asList( 5, 3, 7 ) );
s.setMyStrings( Arrays.asList( "five", "three", "seven " ) );

Target t = SourceTargetMapper.MAPPER.toTarget( s );
System.out.println( t.getMyInteger() );
System.out.println( t.getMyString() );
}
//5
//seven
@Mapper( uses = IterableNonInterableUtil.class )
public interface SourceTargetMapper {
SourceTargetMapper MAPPER = Mappers.getMapper( SourceTargetMapper.class );
@Mapping( source = "myIntegers", target = "myInteger", qualifiedBy = FirstElement.class )
@Mapping( source = "myStrings", target = "myString", qualifiedBy = LastElement.class )
Target toTarget( Source s );
}

@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface FirstElement {
}

@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface LastElement {
}
public class IterableNonInterableUtil {

@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;
}
}
}

2.2、@ObjectFactory

@Mapper
public interface SourceTargetMapper {

SourceTargetMapper MAPPER = Mappers.getMapper( SourceTargetMapper.class );

@Mapping( target = "descriptionArticle1", source = "brush.description" )
@Mapping( target = "descriptionArticle2", source = "paste.description" )
CombinedOfferingEntity toEntity(Toothbrush brush, ToothPaste paste, @Context ArticleRepository repo);

@ObjectFactory
default <T extends Entity> T lookup(Toothbrush brush, ToothPaste paste, @Context ArticleRepository repo,
@TargetType Class<T> targetType ) {
ComposedKey key = new ComposedKey(brush.getName(), paste.getName() );
CombinedOfferingEntity entity = repo.lookup( key );
if ( entity == null ) {
entity = new CombinedOfferingEntity();
}
return (T) entity;
}
}

//生成的代码如下,上面代码大概的逻辑是先执行工厂方法,然后先执行工厂方法,再执行余下的映射
public CombinedOfferingEntity toEntity(Toothbrush brush, ToothPaste paste, ArticleRepository repo) {
if ( brush == null && paste == null ) {
return null;
}

CombinedOfferingEntity combinedOfferingEntity = lookup( brush, paste, repo, CombinedOfferingEntity.class );

if ( brush != null ) {
combinedOfferingEntity.setDescriptionArticle1( brush.getDescription() );
}
if ( paste != null ) {
combinedOfferingEntity.setDescriptionArticle2( paste.getDescription() );
}

return combinedOfferingEntity;
}

2.3、@Context循环依赖

public class Employee {
private String name;
private Employee reportsTo;
private List<Employee> team;
}
public class EmployeeDto {
private String employeeName;
private EmployeeDto reportsTo;
private List<EmployeeDto> team;
}
@Mapper
public interface EmployeeMapper {

EmployeeMapper MAPPER = Mappers.getMapper( EmployeeMapper.class );

@Mapping(source = "employeeName", target = "name")
Employee toEmployee(EmployeeDto employeeDto, @Context CycleAvoidingMappingContext context);

@InheritInverseConfiguration
EmployeeDto fromEmployee(Employee employee, @Context CycleAvoidingMappingContext context);
}
public class CycleAvoidingMappingContext {
private Map<Object, Object> knownInstances = new IdentityHashMap<Object, Object>();

@BeforeMapping
public <T> T getMappedInstance(Object source, @TargetType Class<T> targetType) {
return (T) knownInstances.get( source );
}

@BeforeMapping
public void storeMappedInstance(Object source, @MappingTarget Object target) {
knownInstances.put( source, target );
}
}

三、MapToObject互转

public class Source {
private Map<String, Object> map;
}
public class Target {
private String ip;
private String server;
}

@Mapper( uses = MappingUtil.class )
public interface SourceTargetMapper {

SourceTargetMapper MAPPER = Mappers.getMapper( SourceTargetMapper.class );

@Mapping(source = "map", target = "ip", qualifiedBy = Ip.class )
@Mapping(source = "map", target = "server", qualifiedBy = Server.class )
Target toTarget(Source s);
}

public class MappingUtil {

@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Ip {
}

@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public static @interface Server {
}

@Ip
public String ip(Map<String, Object> in) {
return (String) in.get("ip");
}

@Server
public String server(Map<String, Object> in) {
return (String) in.get("server");
}
}

@Test
public void testMapperOnExistingIpAndServer() {

Map<String, Object> map = new HashMap<>();
map.put("ip", "127.0.0.1");
map.put("server", "168.192.1.1");

Source s = new Source(map);
Target t = SourceTargetMapper.MAPPER.toTarget( s );
System.out.println(JSONUtil.toJsonStr(t));
//{"server":"168.192.1.1","ip":"127.0.0.1"}
}
//下面的例子是从map中映射字段到object
public class Employee {

private String id;
private String name;
private Department department;
}
public class Department {
private String id;
private String name;
}

@Mapper
public interface MapToBeanMapper {

MapToBeanMapper INSTANCE = Mappers.getMapper(MapToBeanMapper.class);

@Mapping(target = "department", ignore = true)
Employee fromMap(Map<String, String> map);

@AfterMapping
default void finishEmployee(@MappingTarget Employee employee, Map<String, String> map) {
employee.setDepartment(fromMapToDepartment(map));
}

@Mapping(target = "id", source = "did")
@Mapping(target = "name", source = "dname")
Department fromMapToDepartment(Map<String, String> map);
}

@Test
public void shouldMapMapToBean() {
Map<String, String> map = new HashMap<>();
map.put("id", "1234");
map.put("name", "Tester");
map.put("did", "4321"); //Department Id
map.put("dname", "Test");// Depart name

Employee employee = MapToBeanMapper.INSTANCE.fromMap(map);
}

四、SPI实现

//主要是用于一些特定的规则处理
step-1
public class CustomAccessorNamingStrategy extends DefaultAccessorNamingStrategy {

@Override
public boolean isGetterMethod(ExecutableElement method) {
String methodName = method.getSimpleName().toString();
return !methodName.startsWith( "with" ) && method.getReturnType().getKind() != TypeKind.VOID;
}

@Override
public boolean isSetterMethod(ExecutableElement method) {
String methodName = method.getSimpleName().toString();
return methodName.startsWith( "with" ) && methodName.length() > 4;
}

@Override
public String getPropertyName(ExecutableElement getterOrSetterMethod) {
String methodName = getterOrSetterMethod.getSimpleName().toString();
return Introspector.decapitalize( methodName.startsWith( "with" ) ? methodName.substring( 4 ) : methodName );
}
}
step-2
resources/META-INF.services目录下新建文件
org.mapstruct.example.spi.CustomAccessorNamingStrategy
文件内容
org.mapstruct.example.spi.CustomAccessorNamingStrategy

五、lombok配置

这主要是配置,以指定comiple的顺序
<!--处理lombok和mapstruft 加载顺序的问题 防止在生成的实体没有属性-->
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version> //1.18.20 || 1.18.20
</path>
<path>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct-processor</artifactId>
<version>${mapstruct.version}</version> //1.4.2.Final || 1.5.0.Beta2
</path>

<!-- additional annotation processor required as of Lombok 1.18.16 -->
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-mapstruct-binding</artifactId>
<version>0.1.0</version> //0.1.0 || 0.2.0
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
</plugins>
举报

相关推荐

0 条评论