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<ProvincesData> provinces;
public Provinces() {}
public Provinces(List<ProvincesData> provinces) {
this.provinces = provinces;
}
@JsonProperty("provincial")
public List<ProvincesData> getprovinces() {
return provinces;
}
@JsonProperty("Test") // 示例中存在此注解，实际应修正为正确的setter注解
public void setprovinces(List<ProvincesData> 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;
}
}我们的核心需求是：
- 从外部API获取 Provinces 对象，其中包含 List<ProvincesData>。
- 对 List<ProvincesData> 进行过滤，移除基于 codAuton 字段重复的数据，只保留唯一的自治区编码。
- 将过滤后的数据转换为一个新的列表结构，其中只包含 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<ProvincesData>，以移除基于 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<String> includedCodAuton = new HashSet<>();
List<ProvincesData> 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<String> 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<ProvincesData>。
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<AutonomyRegionDTO> 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<AutonomyRegionDTO>。
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<AutonomyRegionDTO> 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 进行数据传输。
