RestTemplate获取API数据：去重与重塑技巧

1. 引言：RestTemplate与外部数据集成

在现代微服务架构中，应用程序经常需要与各种外部服务进行交互，获取数据或调用功能。Spring Framework 提供了 RestTemplate 作为一种便捷的方式来执行 HTTP 请求。然而，从外部 API 获取的数据往往需要经过一系列的清洗、转换和过滤，才能符合我们自身 API 的设计要求。本教程将以一个具体的案例为例，讲解如何利用 RestTemplate 获取数据，并进一步对其进行去重和结构重塑，最终以自定义的格式暴露给前端。

2. 原始数据结构与需求分析

假设我们正在构建一个服务，需要从一个外部天气API获取省份数据。原始数据结构如下：

Provinces 类：

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Provinces {

    @JsonProperty("provincial")
    private List provinces;

    public Provinces() {}

    public Provinces(List provinces) {
        this.provinces = provinces;
    }

    @JsonProperty("provincial")
    public List getprovinces() {
        return provinces;
    }

    @JsonProperty("Test") // 示例中存在此注解，实际应修正为正确的setter注解
    public void setprovinces(List provinces) {
        this.provinces = provinces;
    }
}

ProvincesData 类：

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;

@JsonIgnoreProperties(ignoreUnknown = true)
public class ProvincesData {

    @JsonProperty("CODPROV")
    private String codProv;

    @JsonProperty("NOMBRE_PROVINCIA")
    private String nomeProvincia;

    @JsonProperty("CODAUTON")
    private String codAuton;

    @JsonProperty("COMUNIDAD_CIUDAD_AUTONOMA")
    private String comunidadeCidadeAutonoma;

    public ProvincesData() {}

    public ProvincesData(String codProv, String nomeProvincia, String codAuton, String comunidadeCidadeAutonoma) {
        this.codProv = codProv;
        this.nomeProvincia = nomeProvincia;
        this.codAuton = codAuton;
        this.comunidadeCidadeAutonoma = comunidadeCidadeAutonoma; 
    }

    @JsonProperty("CODPROV")
    public String getCodProv() {
        return codProv;
    }

    @JsonProperty("Test") // 示例中存在此注解，实际应修正为正确的setter注解
    public void setCodProv(String codProv) {
        this.codProv = codProv;
    }

    // 省略其他属性的getter和setter，确保它们是正确的
    @JsonProperty("NOMBRE_PROVINCIA")
    public String getNomeProvincia() {
        return nomeProvincia;
    }

    public void setNomeProvincia(String nomeProvincia) {
        this.nomeProvincia = nomeProvincia;
    }

    @JsonProperty("CODAUTON")
    public String getCodAuton() {
        return codAuton;
    }

    public void setCodAuton(String codAuton) {
        this.codAuton = codAuton;
    }

    @JsonProperty("COMUNIDAD_CIUDAD_AUTONOMA")
    public String getComunidadeCidadeAutonoma() {
        return comunidadeCidadeAutonoma;
    }

    public void setComunidadeCidadeAutonoma(String comunidadeCidadeAutonoma) {
        this.comunidadeCidadeAutonoma = comunidadeCidadeAutonoma;
    }
}

我们的核心需求是：

1. 从外部API获取 Provinces 对象，其中包含 List。
2. 对 List 进行过滤，移除基于 codAuton 字段重复的数据，只保留唯一的自治区编码。
3. 将过滤后的数据转换为一个新的列表结构，其中只包含 codAuton 和 comunidadeCidadeAutonoma 字段，并且可能需要重命名这些字段以适应我们自己的API规范。

3. 使用 RestTemplate 获取原始数据

首先，我们需要一个辅助方法来使用 RestTemplate 调用外部 API 并获取原始数据。

import org.springframework.web.client.RestTemplate;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Templates {

    public static Provinces restTemplateProvince(RestTemplate restTemplate) {
        String provinceCommunityURL = "https://www.el-tiempo.net/api/json/v2/provincias";
        Provinces province = restTemplate.getForObject(provinceCommunityURL, Provinces.class);
        return province;
    }
}

在实际应用中，RestTemplate 实例通常通过 Spring 的依赖注入机制进行管理。

4. 核心处理：数据去重与过滤

获取到原始 Provinces 对象后，下一步是处理其内部的 List，以移除基于 codAuton 字段的重复项。我们可以利用 Java 8 的 Stream API 结合一个辅助 Set（或 List）来实现高效去重。

以下是优化后的 restTemplateProvince 方法，它在获取数据后立即执行去重逻辑：

import org.springframework.web.client.RestTemplate;
import java.util.ArrayList;
import java.util.HashSet; // 推荐使用HashSet进行更高效的去重判断
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Templates {

    public static Provinces restTemplateProvince(RestTemplate restTemplate) {
        String provinceCommunityURL = "https://www.el-tiempo.net/api/json/v2/provincias";
        Provinces province = restTemplate.getForObject(provinceCommunityURL, Provinces.class);

        if (province != null && province.getprovinces() != null) {
            // 使用 HashSet 比 ArrayList 更高效地检查元素是否存在
            Set includedCodAuton = new HashSet<>(); 

            List filteredProvinces = province.getprovinces()
                .stream()
                .filter(p -> {
                    // 如果 codAuton 已经存在于 Set 中，则过滤掉此项（返回false）
                    // 否则，将其添加到 Set 中并保留此项（返回true）
                    return includedCodAuton.add(p.getCodAuton());
                })
                .collect(Collectors.toList());

            province.setprovinces(filteredProvinces);
        }
        return province;
    }
}

去重逻辑说明：

• 我们创建了一个 HashSet includedCodAuton 来存储已经处理过的 codAuton 值。HashSet 提供了 O(1) 的平均时间复杂度来检查元素是否存在和添加元素，这比 ArrayList.contains() 的 O(n) 效率更高。
• stream().filter() 方法遍历 ProvincesData 列表。
• 在 filter 的 lambda 表达式中，includedCodAuton.add(p.getCodAuton()) 会尝试将当前 ProvincesData 对象的 codAuton 添加到 Set 中。
  • 如果 codAuton 之前不存在于 Set 中，add() 方法会返回 true，表示添加成功，当前 ProvincesData 对象会被保留。
  • 如果 codAuton 已经存在于 Set 中，add() 方法会返回 false，表示添加失败（因为 Set 不允许重复元素），当前 ProvincesData 对象会被过滤掉。
• 最终，collect(Collectors.toList()) 将过滤后的元素收集成一个新的 List。

5. 数据转换与重塑：生成自定义API响应

仅仅去重还不足以满足我们的所有需求。我们还需要将数据结构重塑，只包含 codAuton 和 comunidadeCidadeAutonoma 字段，并且可能希望重命名这些字段。最专业的做法是定义一个专门用于 API 响应的数据传输对象 (DTO)。

定义 AutonomyRegionDTO：

// AutonomyRegionDTO.java
public class AutonomyRegionDTO {
    private String regionCode; // 对应原始的 codAuton
    private String regionName; // 对应原始的 comunidadeCidadeAutonoma

    public AutonomyRegionDTO(String regionCode, String regionName) {
        this.regionCode = regionCode;
        this.regionName = regionName;
    }

    // Getters and Setters
    public String getRegionCode() {
        return regionCode;
    }

    public void setRegionCode(String regionCode) {
        this.regionCode = regionCode;
    }

    public String getRegionName() {
        return regionName;
    }

    public void setRegionName(String regionName) {
        this.regionName = regionName;
    }
}

现在，我们可以在 ProvinceService 中执行数据获取、去重和转换的完整流程。

改造 ProvinceService：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class ProvinceService {

    @Autowired
    private RestTemplate restTemplate; // 确保 RestTemplate 已被正确配置和注入

    public List getUniqueAutonomyRegions() {
        Provinces rawProvinces = Templates.restTemplateProvince(restTemplate); // 调用包含去重逻辑的方法

        if (rawProvinces != null && rawProvinces.getprovinces() != null) {
            // 将过滤后的 ProvincesData 列表映射到 AutonomyRegionDTO 列表
            return rawProvinces.getprovinces().stream()
                .map(pData -> new AutonomyRegionDTO(pData.getCodAuton(), pData.getComunidadeCidadeAutonoma()))
                .collect(Collectors.toList());
        }
        return List.of(); // 返回空列表或抛出异常，根据业务需求而定
    }
}

map 操作说明：

• 在去重后的 ProvincesData 列表上，我们继续使用 stream().map() 方法。
• map 方法将每个 ProvincesData 对象转换为一个新的 AutonomyRegionDTO 对象，只提取并重命名了我们关心的字段。
• collect(Collectors.toList()) 将转换后的 DTO 收集成一个 List。

6. API层暴露处理后的数据

最后，我们的 RestController 将调用 ProvinceService 来获取处理后的数据，并将其作为 API 响应返回。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
public class ShowcaseController {

    @Autowired
    private ProvinceService provinceService;

    @GetMapping("/autonomy-regions")
    public List getAutonomyRegions(){
      return provinceService.getUniqueAutonomyRegions(); 
    }
}

现在，当访问 /autonomy-regions 接口时，将返回一个只包含去重后的自治区编码和名称的列表，并且字段名也已根据 AutonomyRegionDTO 的定义进行了重命名。

7. 注意事项与最佳实践

• RestTemplate 配置：确保 RestTemplate 在 Spring 应用程序中正确配置并作为 Bean 注入。通常推荐使用 RestTemplateBuilder 来创建和配置 RestTemplate 实例，例如添加拦截器、消息转换器等。
• 错误处理：在实际应用中，restTemplate.getForObject() 调用可能会因为网络问题、API 不可用或响应格式不正确而抛出异常。应添加 try-catch 块或使用 ResponseEntity 来处理这些潜在错误，提供健壮的用户体验。
• 性能考量：对于非常大的数据集，虽然 HashSet 提供了高效的去重，但整个 Stream 处理过程仍需要将数据加载到内存。如果数据量极其庞大，可能需要考虑分页、外部存储或更高级的数据处理框架。
• DTO 的重要性：使用 DTO（Data Transfer Object）是 API 设计中的一个最佳实践。它允许你将内部数据模型与外部 API 响应解耦，确保 API 响应的稳定性和安全性，同时可以根据客户端需求定制数据结构。
• 关注点分离：将数据获取、去重、转换等逻辑分别封装在不同的方法或服务中，可以提高代码的可读性、可维护性和可测试性。
• JSON 属性映射：@JsonProperty 注解用于将 JSON 字段名映射到 Java 对象的属性名。请确保在 ProvincesData 和 Provinces 类中的 setter 方法上不要使用错误的 @JsonProperty("Test") 注解，这可能导致反序列化问题。通常，@JsonProperty 只用于 getter 或字段本身。

8. 总结

本教程演示了如何利用 Spring RestTemplate 从外部 API 获取数据，并通过 Java Stream API 结合 HashSet 实现高效的数据去重。更重要的是，我们展示了如何将原始的、可能冗余的数据结构转换为一个更精简、更符合自身 API 需求的自定义 DTO 列表。通过这种方式，我们不仅解决了数据处理的实际问题，也遵循了良好的软件设计原则，如关注点分离和使用 DTO 进行数据传输。