后端思維之通過層層代碼去重，我又搞了一個通用模板

作者：撿田螺的小男孩 2023-09-01 08:53:52

開發(fā) 后端

最近工作中,我通過層層優(yōu)化重復代碼,最后抽出個通用模板.因此跟大家分享一下優(yōu)化以及思考的過程。我會先造一個相似的例子,然后一步步帶大家如何優(yōu)化哈,看完一定會有幫助的。

后端思維

大家好,我是田螺。

后端思維系列好久沒更新啦~今天，終于來了。本文是田螺哥后端思維專欄的第7篇哈。

優(yōu)化前的例子
第一步優(yōu)化：抽取公用方法
第二步優(yōu)化：反射對比字段
第三步優(yōu)化：泛型+ lambda函數式
第四步優(yōu)化：繼承多態(tài)
第五步優(yōu)化：模板方法成型
大功告成: 策略模式+工廠模式+模板方法模式

1. 優(yōu)化前的例子

在這里,我先給大家模擬一個業(yè)務場景哈,并給出些簡化版的代碼

假設你有個對賬需求:你要把文件服務器中,兩個A、B不同端，上送的余額明細和轉賬明細,下載下來,對比每個字段是否一致.

明細和余額的對比類似,代碼整體流程:

讀取A、B端文件到內存的兩個list
兩個list通過某個唯一key轉化為map
兩個map字段逐個對比

我們先看明細對比哈，可以寫出類似醬紫的代碼:

//對比明細
private void checkDetail(String detailPathOfA,String detailPathOfB )throws IOException{

   //讀取A端的文件
   List<DetailDTO> resultListOfA = new ArrayList<>();
   try (BufferedReader reader1 = new BufferedReader(new FileReader(detailPathOfA))) {
            String line;
            while ((line = reader1.readLine()) != null) { 
                resultListOfA.add(DetailDTO.convert(line));
            }
        }
    
   //讀取B端的文件
   List<DetailDTO> resultListOfB = new ArrayList<>();
   try (BufferedReader reader1 = new BufferedReader(new FileReader(detailPathOfB))) {
            String line;
            while ((line = reader1.readLine()) != null) { 
                resultListOfB.add(DetailDTO.convert(line));
            }
        }
    
    //A列表轉化為Map
    Map<String,DetailDTO> resultMapOfA = new HashMap<>();
    for(DetailDTO detail:resultListOfA){
        resultMapOfA.put(detail.getBizSeq(),detail);
    }
    
     //B列表轉化為Map
    Map<String,DetailDTO> resultMapOfB = new HashMap<>()
    for(DetailDTO detail:resultListOfB){
        resultMapOfB.put(detail.getBizSeq(),detail);
    }
    
    //明細逐個對比
    for (Map.Entry<String, DetailDTO> temp : resultMapOfA.entrySet()) {
        if (resultMapOfB.containsKey(temp.getKey())) {
            DetailDTO detailOfA = temp.getValue();
            DetailDTO detailOfB = resultMapOfB.get(temp.getKey());

            if (!detailOfA.getAmt().equals(detailOfB.getAmt())) {
                  log.warn("amt is different,key:{}", temp.getKey());
            }
            if (!detailOfA.getDate().equals(detailOfB.getDate())) {
                log.warn("date is different,key:{}", temp.getKey());
            }

            if (!detailOfA.getStatus().equals(detailOfB.getStatus())) {
                log.warn("status is different,key:{}", temp.getKey());
            }
            ......
        }
  }
}

2. 抽取公用方法去重

大家仔細看以上明細對比的例子,發(fā)現了重復代碼:

圖片

我們可以抽取一個公用方法去優(yōu)化它,比如抽取個讀取文件的公用方法 readFile:

//對比明細
private void checkDetail(String detailPathOfA,String detailPathOfB )throws IOException{

   //讀取A端的文件
    List<DetailDTO> resultListOfA = readFile(detailPathOfA);
   //讀取B端的文件
   List<DetailDTO> resultListOfB = readFile(detailPathOfB);
   ......
}

//抽取公用方法
 private List<DetailDTO> readFile(String detailPath) throws IOException {
        List<DetailDTO> resultList = new ArrayList<>();
        try (BufferedReader reader1 = new BufferedReader(new FileReader(detailPath))) {
            String line;
            while ((line = reader1.readLine()) != null) {
                resultList.add(DetailDTO.convert(line));
            }
        }
        return resultList;
    }

同理，這塊代碼也是重復了:

圖片

我們也可以抽個公用方法:convertListToMap

//對比明細
private void checkDetail(String detailPathOfA,String detailPathOfB ){

   //讀取A端的文件
    List<DetailDTO> resultListOfA = readFile(detailPathOfA);
   //讀取B端的文件
   List<DetailDTO> resultListOfB = readFile(detailPathOfB);
   
   //A列表轉化為Map
   Map<String,DetailDTO> resultMapOfA = convertListToMap(resultListOfA);
   //B列表轉化為Map
   Map<String,DetailDTO> resultMapOfB = convertListToMap(resultListOfB);
   ......
}

//抽取公用方法
private Map<String,DetailDTO> convertListToMap(List<DetailDTO> list){
    Map<String,DetailDTO> map = new HashMap<>()
    for(DetailDTO detail:list){
        map.add(detail.getBizSeq(),detail);
    }
    return map;
}

通過抽取公用方法后，已經優(yōu)雅很多啦~

3. 反射對比字段

我們再來看下字段對比的邏輯，如下：

圖片

以上代碼會取兩個對象的每個字段對比，如果明細對象的屬性字段特別多的話，這塊代碼也會顯得重復冗余。我們可以通過反射去對比兩個對象的屬性，如下：

public static List<String> compareObjects(Object obj1, Object obj2) {
        List<String> list = new ArrayList<>();

        Class<?> clazz = obj1.getClass();
        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            String fieldName = field.getName();
            field.setAccessible(true);
            try {
                Object value1 = field.get(obj1);
                Object value2 = field.get(obj2);

                if ((value1 == null && value2 != null) || (value1 != null && !value1.equals(value2))) {
                    list.add(fieldName);
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return list;
        }

有了這個反射對比方法，原來的代碼就可以優(yōu)化成這樣啦，是不是優(yōu)雅了很多:

//對比明細
private void checkDetail(String detailPathOfA,String detailPathOfB ){

   //讀取A端的文件
    List<DetailDTO> resultListOfA = readFile(detailPathOfA);
   //讀取B端的文件
   List<DetailDTO> resultListOfB = readFile(detailPathOfB);
   
   //A列表轉化為Map
   Map<String,DetailDTO> resultMapOfA = convertListToMap(resultListOfA);
   //B列表轉化為Map
   Map<String,DetailDTO> resultMapOfB = convertListToMap(resultListOfB);
   
    //明細逐個對比
    for (Map.Entry<String, DetailDTO> temp : resultMapOfA) {
          if(resultMapOfB.containsKey(temp.getKey()){
             DetailDTO detailOfA = temp.getValue();
             DetailDTO detailOfB = resultMapOfB.get(temp.getKey());
             
             List<String> resultList=compareObjects(detailOfA,detailOfB);
             for(String temp:resultList){
                log.warn("{} is different,key:{}",temp,detailOfA.getKey()); 
             }
            ......
          }
      }
}

4.Lambda函數式+泛型

實現完明細文件的對比,我們還需要余額文件的對比:

同樣的,也是先讀取文件,如下:

//對比明細
private void checkBalance(String balancePathOfA,String balancePathOfB ){

   //讀取A端的文件
   List<BalanceDTO> resultListOfA = new ArrayList<>();
   try (BufferedReader reader1 = new BufferedReader(new FileReader(balancePathOfA))) {
            String line;
            while ((line = reader1.readLine()) != null) { 
                resultListOfA.add(BalanceDTO.convert(line));
            }
        }
        
   List<DetailDTO> resultListOfB = new ArrayList<>();
   try (BufferedReader reader1 = new BufferedReader(new FileReader(detailPathOfB))) {
            String line;
            while ((line = reader1.readLine()) != null) { 
                resultListOfB.add(DetailDTO.convert(line));
            }
        }
    ......
    }

大家可以發(fā)現,讀取余額文件和剛剛的讀取明細文件很像,有一部分代碼是重復的,但是不能直接一下子抽個共同函數出來:

圖片

對了,convert方法是醬紫的哈:

public static BalanceDTO convert(String line){
        BalanceDTO dto = new BalanceDTO();
        String[] dataLine = line.split(",",-1);
        dto.setBalance(dataLine[1]);
        dto.setType(dataLine[2]);
        ......
        return dto;
    }

大家可以發(fā)現,就是一個返回類型,以及這個對應類型的一個靜態(tài)convert方法不一致而已,如果是類型不一樣,我們可以使用泛型替代,如果是一個小的靜態(tài)方法不一致,我們則可以使用lambda函數式接口提取,因此可以抽這個這么一個公用方法吧:

public <T> List<T> readDataFromFile(String filePath, Function<String, T> converter) throws IOException {
    List<T> result = new ArrayList<>();
    try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
        String line;
        while ((line = reader.readLine()) != null) { 
            result.add(converter.apply(line));
        }
    }
    return result;
}

//余額讀取調用
List<BalanceDTO> resultListOfA = readDataFromFile(balancePathOfA, BalanceDTO::convert);
//明細讀取調用
List<DetailDTO> resultList = readDataFromFile(detailPath, DetailDTO::convert);

平時我們用泛型+ Lambda表達式結合，去抽取公用方法，代碼就顯得高端大氣很多，對吧！

5. 繼承多態(tài).

在余額對比文件中，讀取完文件到內存后，我們需要把通過某個唯一key關聯(lián)起來，即把List轉為Map，如下：

//對比明細
private void checkBalance(String balancePathOfA,String balancePathOfB ){

  //讀取A端的文件
  List<BalanceDTO> resultListOfA = readDataFromFile(balancePathOfA, BalanceDTO::convert);
   //讀取B端的文件
  List<BalanceDTO> resultListOfB = readDataFromFile(balancePathOfB, BalanceDTO::convert);
   
  //A列表list轉化為Map
  Map<String,BalanceDTO> resultMapOfA = new HashMap<>()
  for(BalanceDTO balance:resultListOfA){
    resultMapOfA.add(balance.getType()+balance.getAccountNo(),balance);
  }

一般來說，把兩個list轉化為Map，抽一個公用方法是不是就好了？比如說醬紫：

private Map<String,BalanceDTO> convertListToMap(List<BalanceDTO> list){
    Map<String,BalanceDTO> map = new HashMap<>()
    for(BalanceDTO balance:list){
        resultMapOfA.add(balance.getType()+balance.getAccountNo(),balance);
    }
    return map;
}

其實也行，但是其實可以更抽象一點。因為余額和明細對比都有l(wèi)ist轉map的需求，而且也是有共性的，只不過是轉化map的key和value的類型不一致而已。

圖片

我們仔細思考一下，value類型是不同類型（分別是BalanceDTO和DetailDTO），而key則是對應對象的一個或者某幾個屬性連接起來的。對于不同類型，我們可以考慮泛型。對于余額和明細對象不同的key的話，我們則可以考慮繼承和多態(tài)，讓它們實現同一個接口就好啦。

我們可以使用繼承和多態(tài)，定義一個抽象類BaseKeyDTO，里面有個getKey的抽象方法,然后BalanceDTO 和DetailDTO都繼承它，實現各自getKey的方法，如下：

public abstract class BaseDTO {
    abstract String getKey();
} 

public class BalanceDTO extends BaseDTO {
    @Override
    String getKey() {
        return type + accountNo;
    }
}

public class DetailDTO extends BaseDTO {
    @Override
    String getKey() {
        return bizSeq;
  }

最后，我們應用繼承多態(tài)+擴展泛型（<T extends BaseDTO>），就可以把余額和明細對比的convertListToMap方法抽成一個啦：

private static <T extends BaseDTO> Map<String, T> convertListToMap(List<T> list) {
        Map<String, T> map = new HashMap<>();
        for (T item : list) {
            map.put(item.getKey(), item);
        }
        return map;
    }

最后明細和余額對比，可以優(yōu)化成這樣，其實看起來已經比較優(yōu)雅啦：

//對比明細
    private void checkDetail(String detailPathOfA, String detailPathOfB) throws IOException {

        //讀取A端明細的文件
        List<DetailDTO> resultListOfA = readDataFromFile(detailPathOfA, DetailDTO::convert);
        //讀取B端明細的文件
        List<DetailDTO> resultListOfB = readDataFromFile(detailPathOfB, DetailDTO::convert);

        //A列表轉化為Map
        Map<String, DetailDTO> resultMapOfA = convertListToMap(resultListOfA);
        //B列表轉化為Map
        Map<String, DetailDTO> resultMapOfB = convertListToMap(resultListOfB);

        //明細逐個對比
        compareDifferent(resultMapOfA,resultMapOfB);
    }
    

   //對比余額
    private void checkBalance(String balancePathOfA,String detailPathOfB) throws IOException {

        //讀取A端余額的文件
        List<BalanceDTO> resultListOfA = readDataFromFile(balancePathOfA,BalanceDTO::convert);
        //讀取B端余額的文件
        List<BalanceDTO> resultListOfB = readDataFromFile(detailPathOfB,BalanceDTO::convert);

        //A余額列表轉化為Map
        Map<String,BalanceDTO> resultMapOfA = convertListToMap(resultListOfA);
        //B余額列表轉化為Map
        Map<String,BalanceDTO> resultMapOfB = convertListToMap(resultListOfB);

        //余額逐個對比
        compareDifferent(resultMapOfA,resultMapOfB);
    }
    
    //對比也用泛型，抽一個公用的方法哈
    private void compareDifferent(Map<String, T> mapA, Map<String, T> mapB) {
        for (Map.Entry<String, T> temp : mapA.entrySet()) {
            if (mapB.containsKey(temp.getKey())) {
                T dtoA = temp.getValue();
                T dtoB = mapB.get(temp.getKey());

                List<String> resultList = compareObjects(dtoA, dtoB);
                for (String tempStr : resultList) {
                    log.warn("{} is different,key:{}", tempStr, dtoA.getKey());
                }
            }
        }
    }
}

6. 模板方法

大家回頭細看，可以發(fā)現不管是明細還是余額對比，兩個方法很像，都是一個骨架流程來的：

讀取A、B端文件到內存的兩個list
兩個list通過某個唯一key轉化為map
兩個map字段逐個對比

圖片

大家先回想一下模板方法模式：

定義了一個算法的骨架，將一些步驟延遲到子類中實現。這有助于避免在不同類中重復編寫相似的代碼。

頓時是不是就覺得這塊代碼還有優(yōu)化空間。

6.1 定義對比模板的骨架

我們可以嘗試這兩塊代碼再合并，用模板方法優(yōu)化它。我們先定義一個模板，然后模板內定義它們骨架的流程，如下:

//聲明對比抽象模板
public abstract class AbstractCheckTemplate<T extends BaseDTO> {

    public void checkTemplate(String filePathA, String filePathB) throws IOException {

        //從文件讀取為List
        readDataFromFile(filePathA, filePathB);
        //list轉化為Map
        covertListToMap(resultListOfA, resultListOfB);
        //比較
        compareDifferent(mapA, mapB);
    }

6.2 模板的方法逐步細化

因為readDataFromFile需要輸出兩個list，所以我們可以定義返回類型為Pair，代碼如下：

private Pair<List<T>, List<T>> readDataFromFile(String filePathA, String filePathB, Function<String, T> converter) throws IOException {
        //讀取A端余額的文件
        List<T> resultListOfA = readDataFromFile(filePathA, converter);
        //讀取B端余額的文件
        List<T> resultListOfB = readDataFromFile(filePathB, converter);
        return new Pair<>(resultListOfA, resultListOfB);
    }

又因為這個函數式的轉化，是不同子類才能定下來的，我們就可以聲明個抽象方法convertLineToDTD，讓子類去實現。因此模板就變成這樣啦：

public abstract class AbstractCheckTemplate<T extends BaseDTO> {

    public void checkTemplate(String filePathA, String filePathB) throws IOException {

        //從文件讀取為List
        Pair<List<T>, List<T>> resultListPair = readDataFromFile(filePathA, filePathB, this::convertLineToDTD);
        List<T> resultListOfA = resultListPair.getKey();
        List<T> resultListOfB = resultListPair.getValue();

        //list轉化為Map
        covertListToMap(resultListOfA, resultListOfB);
        //比較
        compareDifferent(mapA, mapB);
    }
    
    //延遲到子類實現轉換為不同的DTO
    protected abstract T convertLineToDTD(String line);

同理，還有兩個list轉化為兩個map再對比，我們可以聲明為這樣：

private Pair<Map<String, T>, Map<String, T>> covertListToMap(List<T> listA, List<T> listB) {
        return new Pair<>(convertListToMap(listA), convertListToMap(listB));
    }

因此最終模板就是這樣啦：

@Slf4j
public abstract class AbstractCheckTemplate<T extends BaseDTO> {

    public void checkTemplate(String filePathA, String filePathB) throws IOException {

        //從文件讀取為List
        Pair<List<T>, List<T>> resultListPair = readDataFromFile(filePathA, filePathB, this::convertLineToDTD);
        List<T> resultListOfA = resultListPair.getKey();
        List<T> resultListOfB = resultListPair.getValue();

        //list轉化為Map
        Pair<Map<String, T>, Map<String, T>> resultMapPair = covertListToMap(resultListOfA, resultListOfB);
        Map<String, T> mapA = resultMapPair.getKey();
        Map<String, T> mapB = resultMapPair.getValue();

        //比較
        compareDifferent(mapA, mapB);
    }
    
    protected abstract T convertLineToDTD(String line);
    ......此處省略公用的私有方法
}

6.3 不同對比子類

如果你是余額對比，那你聲明一個CheckBalanceStrategyServiceImpl去繼承抽象模板。

/**
 * 余額對比策略
 * 公眾號: 撿田螺的小男孩
 */
@Service
public class CheckBalanceStrategyServiceImpl extends AbstractCheckTemplate<BalanceDTO> {

    @Override
    protected BalanceDTO convertLineToDTD(String line) {
        return BalanceDTO.convert(line);
    }
}

如果你是明細對比，那你聲明一個CheckDetailStrategyServiceImpl去繼承抽象模板。

/**
 * 明細對比策略
 * 關注公眾號: 撿田螺的小男孩
 */
@Service
public class CheckDetailStrategyServiceImpl extends AbstractCheckTemplate<DetailDTO> {
    @Override
    protected DetailDTO convertLineToDTD(String line) {
        return DetailDTO.convert(line);
    }
}

這兩個不同的子類，就像不同的策略，我們應該都能嗅到策略模式的味道啦~

7. 工廠模式+ 模板方法 + 策略模式全家桶

有了明細對比、余額對比的模板，為了更方便調用，我們還可以定義一個校驗策略接口，然后交給spring工廠類，這樣更方便調用。其實日常開發(fā)中，這三種設計模式一般一起出現，非常實用:

我們先聲明一個校驗ICheckStrategy接口:

/**
 * 關注公眾號: 撿田螺的小男孩
 */
public interface ICheckStrategy {

    /**
     * 對比校驗邏輯
     * @param filePathA
     * @param filePathB
     * @throws IOException
     */
    void check(String filePathA, String filePathB) throws IOException;

    /**
     * 校驗的類型，明細/余額
     * @return
     */
    CheckEnum getCheckEnum();
}

然后，模板AbstractCheckTemplate實現ICheckStrategy接口。

public abstract class AbstractCheckTemplate<T extends BaseDTO> implements ICheckStrategy {

接著，不同對比策略類CheckDetailStrategyServiceImpl 和CheckDetailStrategyServiceImpl映射對應的對比校驗類型:

/**
 * 明細對比策略
 * 關注公眾號: 撿田螺的小男孩
 */
@Service
public class CheckDetailStrategyServiceImpl extends AbstractCheckTemplate<DetailDTO> {

     @Override
    protected DetailDTO convertLineToDTD(String line) {
        return DetailDTO.convert(line);
    }
  
    @Override
    public void check(String filePathA, String filePathB) throws IOException {
        checkTemplate(filePathA, filePathB);
    }

    //對比校驗類型為：明細
    @Override
    public CheckEnum getCheckEnum() {
        return CheckEnum.DETAIL_CHECK;
    }
}

/**
 * 余額對比策略
 * 關注公眾號: 撿田螺的小男孩
 */
@Service
public class CheckBalanceStrategyServiceImpl extends AbstractCheckTemplate<BalanceDTO> {

    @Override
    public void check(String filePathA, String filePathB) throws IOException {
        checkTemplate(filePathA, filePathB);
    }
     //對比校驗類型為：余額
    @Override
    public CheckEnum getCheckEnum() {
        return CheckEnum.BALANCE_CHECK;
    }

    @Override
    protected BalanceDTO convertLineToDTD(String line) {
        return BalanceDTO.convert(line);
    }
}

最后一步，我們借助spring的生命周期，使用ApplicationContextAware接口，把對用的策略，初始化到map里面。然后對外提供checkCompare方法即可。讓調用者決定用哪一種對比，其實這算工廠模式思想，大家可以自己思考一下~

@Component
public class CheckCompareFactory implements ApplicationContextAware {

    private final Map<CheckEnum, ICheckStrategy> checkStrategyMap = new ConcurrentHashMap<>();
    
    //把不同策略放到map
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, ICheckStrategy> tmepMap = applicationContext.getBeansOfType(ICheckStrategy.class);
        tmepMap.values().forEach(strategyService -> checkStrategyMap.put(strategyService.getCheckEnum(), strategyService));
    }

    /**
     * 直接調用這個方法即可
     */
    public void checkCompare(CheckEnum checkEnum, String filePathA, String filePathB) throws IOException {
        ICheckStrategy checkStrategy = checkStrategyMap.get(checkEnum);
        checkStrategy.check(filePathA, filePathB);
    }
}

最后

我是撿田螺的小男孩。本文介紹了：如何將一些通用的、用于優(yōu)化重復冗余代碼的技巧應用到開發(fā)中。最終，我通過這些技巧將代碼優(yōu)化成一個通用模板。

責任編輯：武曉燕來源：撿田螺的小男孩

后端優(yōu)化開發(fā)

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看