实现AutoMapper（1.0版本）

最近有个需求就是实体之间自动转换，网上肯定有很多现成的实现，不过还是自己写了一个，就当对java高级特性的一个熟悉的过程。这中间包含了泛型，反射，lamada表达式。对于想了解java高级特性的人来说，这也算一个不错的实战例子。

1，变化的需求。

当0.1版本的时候，能做的就是将完全匹配的字段名称mapper过去，但是没有多久发现这个远不能满足需求。

0.2版本，将原来代码加了toLowerCase()，不在区分大小写。之后就发现有些字段名称不一样了。

0.3版本，可以添加一些全局设置，可以在全局找到相关字段，把不匹配的转换过去。

0.4....可以想象还有很多比如全局设置和自动匹配顺序问题，还有每次修改都要改动mapper源代码，风险性很高，所以进行了一次重构，也就是产生了现在的1.0版本。

2，1.0版本

将原来只有处理逻辑mapper类拆分为两部分，映射的AutoMapper类，以及映射的逻辑MapperPolicy接口。AutoMapper类能够根据配置的MapperPolicy的配置进行mapper，提高灵活性，也保证业务逻辑分隔。并且加入了注解配置的方式，进一步提高灵活性。不过这个版本也只是一个雏形，还不是一个能够广泛使用的版本，以后肯定还要升级到1.1，1.2......

闲话少说，show me code。

 public class AutoMapper {
     //策略数组
     private List<Supplier<MapperPolicy>> policyList = new ArrayList<>();

     private boolean hasInit = false;

     //默认策略
     private List<Supplier<MapperPolicy>> getDefaultMapperPolicy() {
         List<Supplier<MapperPolicy>> defaultPolicyList = new ArrayList<>();
         defaultPolicyList.add(() -> UseAnnotationMapperPolicy.getInstance());
         defaultPolicyList.add(() -> IgnoreCaseMapperPolicy.getInstance());
         return defaultPolicyList;
     }

     //初始化
     private void init() {
         if (hasInit) {
             return;
         }
         if (policyList == null || policyList.isEmpty()) {
             policyList.addAll(getDefaultMapperPolicy());
             hasInit = true;
         }
     }

     //重置策略
     public AutoMapper clearPolicy() {
         hasInit = false;
         policyList.clear();
         return this;
     }

     //添加策略
     public AutoMapper addPolicy(Supplier<MapperPolicy> mapperPolicySupplier) {
         policyList.add(mapperPolicySupplier);
         return this;
     }

     //添加策略
     public AutoMapper addPolicy(MapperPolicy mapperPolicy) {
         return addPolicy(() -> mapperPolicy);
     }

     //mapper核心类
     public <T1, T2> T2 mapModel(T1 source, Class<T2> desc) {
         init();
         try {
             T2 descObj = desc.newInstance();
             Arrays.stream(desc.getDeclaredFields()).forEach(field -> {
                 Object descFieldObject = null;
                 for (Supplier<MapperPolicy> policySupplie : policyList) {
                     MapperPolicy policy = policySupplie.get();
                     Field sourceField = policy.getField(field, source);
                     if (sourceField == null) {
                         continue;
                     }
                     sourceField.setAccessible(true);
                     try {
                         descFieldObject = sourceField.get(source);
                         if (descFieldObject == null) {
                             continue;
                         } else {
                             break;
                         }
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     }
                 }
                 field.setAccessible(true);
                 try {
                     if(descFieldObject!=null){
                         field.set(descObj, descFieldObject);
                     }
                 } catch (IllegalAccessException e) {
                     e.printStackTrace();
                 }
             });
             return descObj;
         } catch (Exception ex) {
             return null;
         }
     }

     public static AutoMapper getInstance() {
         return new AutoMapper();
     }
 }

AutoMapper（核心类）

策略类：

 public interface MapperPolicy {
     Field getField(Field descField, Object source);
 }

策略接口

 public class IgnoreCaseMapperPolicy implements MapperPolicy {
     @Override
     public Field getField(Field descField, Object source) {
         Field[] fields = source.getClass().getDeclaredFields();
         if (fields.length == 0) {
             return null;
         }
         List<Field> allMatchFields= Arrays.stream(fields).filter(field -> {
             return field.getName().toLowerCase().equals(descField.getName().toLowerCase());
         }).collect(Collectors.toList());
         if(allMatchFields.isEmpty()){
             return null;
         }else {
             return allMatchFields.get(0);
         }
     }

     public static  IgnoreCaseMapperPolicy getInstance(){
         return new IgnoreCaseMapperPolicy();
     }
 }

直接匹配策略（忽略大小写）

 public class SettingMapperPolicy implements MapperPolicy {
     @Override
     public Field getField(Field descField, Object source) {
         if (allSettings.containsKey(descField.getName())) {
             List<Supplier<String>> allSupplier = allSettings.get(descField.getName());
             Field[] fields = source.getClass().getDeclaredFields();
             List<Field> allMatchFields = Arrays.stream(fields).filter(field -> {
                 return allSupplier.stream().anyMatch(supplier -> {
                     return field.getName().toLowerCase().equals(supplier.get().toLowerCase());
                 });
             }).collect(Collectors.toList());
             if (allMatchFields.isEmpty()) {
                 return null;
             } else {
                 return allMatchFields.get(0);
             }
         }
         return null;
     }

     private static Map<String, List<Supplier<String>>> allSettings = new HashMap<String, List<Supplier<String>>>();

     public SettingMapperPolicy add(String sourceName, String descName) {
        return add(descName, () -> sourceName);
     }

     public SettingMapperPolicy add(String descName, Supplier<String> stringSupplier) {
         if (!allSettings.containsKey(descName)) {
             allSettings.put(descName, new ArrayList<>());
         }
         List<Supplier<String>> allSupplier = allSettings.get(descName);
         allSupplier.add(stringSupplier);
         return this;
     }
 }

全局设置策略

 @Target({ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface UseMapper {
     String[] fromName();
 }

 public class UseAnnotationMapperPolicy implements MapperPolicy {
     @Override
     public Field getField(Field descField, Object source) {
         UseMapper useMapper = descField.getAnnotation(UseMapper.class);
         if(useMapper==null){
             return null;
         }
         String[] sourceFieldNames = useMapper.fromName();
         if (sourceFieldNames == null || sourceFieldNames.length == 0) {
             return null;
         }
         Field[] sourceFields = source.getClass().getDeclaredFields();
         if (sourceFields == null) {
             return null;
         }
        List<Field> allMatchFields= Arrays.stream(sourceFields).filter(field -> {
             return Arrays.asList(sourceFieldNames).stream().filter(fieldName -> {
                 return fieldName.toLowerCase().equals(field.getName().toLowerCase());
             }).findFirst().isPresent();
         }).collect(Collectors.toList());
         if (allMatchFields.isEmpty()) {
             return null;
         } else {
             return allMatchFields.get(0);
         }
     }

     public static  UseAnnotationMapperPolicy getInstance(){
         return new UseAnnotationMapperPolicy();
     }
 }

注解策略

3，测试代码

 //内部对象类
 public class InnerField {
     public String getInnerField() {
         return innerField;
     }

     public InnerField setInnerField(String innerField) {
         this.innerField = innerField;
         return this;
     }

     private String innerField;
 }
 //转换源实体
 public class TestSource {
     public int getField1() {
         return field1;
     }

     public TestSource setField1(int field1) {
         this.field1 = field1;
         return this;
     }

     public double getField2() {
         return field2;
     }

     public TestSource setField2(double field2) {
         this.field2 = field2;
         return this;
     }

     public String getField3() {
         return field3;
     }

     public TestSource setField3(String field3) {
         this.field3 = field3;
         return this;
     }

     public InnerField getField4() {
         return field4;
     }

     public TestSource setField4(InnerField field4) {
         this.field4 = field4;
         return this;
     }

     private int field1;
     private double field2;
     private String field3;
     private InnerField field4;
 }
 //转换目标实体类
 public class TestDest {
     public int getField1() {
         return Field1;
     }

     public void setField1(int field1) {
         Field1 = field1;
     }

     public double getField2() {
         return Field2;
     }

     public void setField2(double field2) {
         Field2 = field2;
     }

     public String getField3() {
         return Field3;
     }

     public void setField3(String field3) {
         Field3 = field3;
     }

     public InnerField getField4() {
         return Field4;
     }

     public void setField4(InnerField field4) {
         Field4 = field4;
     }

     public int getField5() {
         return field5;
     }

     public void setField5(int field5) {
         this.field5 = field5;
     }

     public double getField6() {
         return field6;
     }

     public void setField6(double field6) {
         this.field6 = field6;
     }

     public String getField7() {
         return field7;
     }

     public void setField7(String field7) {
         this.field7 = field7;
     }

     public InnerField getField8() {
         return field8;
     }

     public void setField8(InnerField field8) {
         this.field8 = field8;
     }

     public int getField9() {
         return field9;
     }

     public void setField9(int field9) {
         this.field9 = field9;
     }

     public double getField10() {
         return field10;
     }

     public void setField10(double field10) {
         this.field10 = field10;
     }

     public String getField11() {
         return field11;
     }

     public void setField11(String field11) {
         this.field11 = field11;
     }

     public InnerField getField12() {
         return field12;
     }

     public void setField12(InnerField field12) {
         this.field12 = field12;
     }

     private int Field1;
     private double Field2;
     private String Field3;
     private InnerField Field4;

     @UseMapper(fromName = "field1")
     private int field5;
     @UseMapper(fromName = "field2")
     private double field6;
     @UseMapper(fromName = "field3")
     private String field7;
     @UseMapper(fromName = "field4")
     private InnerField field8;

     private int field9;
     private double field10;
     private String field11;
     private InnerField field12;
 }

测试的实体类

Main函数，默认策略和自定义策略

 public static void main(String[] args) {
         AutoMapper autoMapper= AutoMapper.getInstance().clearPolicy()
                 .addPolicy(UseAnnotationMapperPolicy.getInstance())//设置字段注解映射，忽略大小写的
                 .addPolicy(IgnoreCaseMapperPolicy.getInstance())//设置忽略大小写的字段映射
                 .addPolicy(()->{
                     return new SettingMapperPolicy()                //设置全局映射
                             .add("field1","field9")   //全局具体映射的字段1
                             .add("field2","field10")   //全局具体映射的字段2
                             .add("field3","field11")   //全局具体映射的字段3
                             .add("field4","field12");  //全局设置映射的字段4
                 });
         TestSource testSource=new TestSource().setField1(1).setField2(2.0).setField3("field3").setField4(new InnerField().setInnerField("InnerField4"));
         TestDest dest=autoMapper.mapModel(testSource,TestDest.class);

         AutoMapper autoMapper2= AutoMapper.getInstance();
         TestDest dest2=autoMapper2.mapModel(testSource,TestDest.class);
     }

4，代码部分解释

1，这里面用了链式编程，因为我实在不习惯每一次set都要一行代码，感觉巨蠢无比，不过链式编程也没有什么技术含量，只是return this而已。

2，内置接口Supplier的使用，这是为lamada表达式量身定做的内置接口。很多人觉得lamada表达式作用不大，但是确实能大大简化代码。本文中一共使用了俩次。

　　第一次是SettingMapperPolicy中，设置映射是String到List<Supplier<String>>的映射，我们抛开List不谈，String和Supplier<String>有什么区别呢？其实区别挺大的。比如下面的代码（参见上面main方法），config这个字段就是从configsource对象中获取来的，当然这个对象可以是新构建的，也可以是上下文存在的对象。能极大的提高灵活性。

 .add("Config",()->new ConfigSource().getConfigName())

　　第二次是AutoMapper的策略不是List<MapperPolicy>，而是List<Supplier<MapperPolicy>>，也是基于上面的理由。而且传递 Supplier<T>等内置的lamada支持对象，都是延时处理的，能大大降低程序运行的负担。

3，策略的威力。其实这是个典型策略模式。而且策略是可以组合的，通过不同的内置策略，进行不同的转换。不过和传统意义的设计模式却有差异。以前我学设计模式总想记住各个类的关系，时间过了几年后，发现设计模式的意义不在于类图，函数式编程会颠覆大部分结构的实现方式，但是其内在意义却不会变。所以学习设计模式多理解内涵更为重要。

5，不足

毕竟是花少量时间写的，和产品级别的差距不是一星半点。我这个只能满足我暂时的需求，这里面对于数组、集合、字典等以及子对象都不能自动转换。所以有使用的人注意一下。