Java实现带动态查询参数的REST API GET请求封装方案咨询

Great question! When dealing with a REST API that has multiple optional query parameters (20 in your case) with various valid combinations, the goal is to build a clean, maintainable wrapper that avoids messy string concatenation and makes it easy to manage different request scenarios. Here's a practical, production-ready approach I've implemented in several Java projects:

First, define a Data Transfer Object (DTO) that holds all 20 query parameters as optional fields. Using the builder pattern (either manually or with Lombok) will make it super intuitive to create different parameter combinations without setting unused fields.

If you're using Lombok, this becomes trivial:

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class ApiRequestParams {
    private String param1;
    private String param2;
    private String param3;
    private String param4;
    private String param5;
    // Add the remaining 15 parameters here...
}

If you don't want to use Lombok, you can write the builder manually—just make sure each setter returns the builder instance for fluent chaining.

Next, you need to convert the non-null parameters from the DTO into a properly encoded query string. Using Spring's UriComponentsBuilder is ideal here because it handles URL encoding automatically (no more worrying about special characters breaking your request).

Add a method to your DTO (or create a utility class) to build the query string:

import org.springframework.web.util.UriComponentsBuilder;

public String buildQueryString() {
    UriComponentsBuilder builder = UriComponentsBuilder.fromPath("/api");
    
    if (param1 != null) builder.queryParam("param1", param1);
    if (param2 != null) builder.queryParam("param2", param2);
    if (param3 != null) builder.queryParam("param3", param3);
    if (param4 != null) builder.queryParam("param4", param4);
    if (param5 != null) builder.queryParam("param5", param5);
    // Repeat for all other parameters...
    
    return builder.toUriString();
}

If you're not using Spring, you can use java.net.URLEncoder to encode each parameter value and build the string manually, but UriComponentsBuilder is way less error-prone.

Now, create a dedicated service class that handles the actual HTTP call. This encapsulates all the API logic in one place, making it easy to update the base URL, add error handling, or change HTTP clients later.

Here's an example using Spring's RestTemplate:

import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

@Service
public class ApiClientService {
    private static final String BASE_URL = "http://mock.domain.com";
    private final RestTemplate restTemplate;

    // Inject RestTemplate via constructor (preferred for dependency injection)
    public ApiClientService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public ResponseEntity<String> callApi(ApiRequestParams params) {
        String fullUrl = BASE_URL + params.buildQueryString();
        return restTemplate.getForEntity(fullUrl, String.class);
    }
}

If you prefer using OkHttp instead of RestTemplate, the logic is similar—you'd build the request using the query string from the DTO and execute it with an OkHttpClient instance.

Since different parameter combinations are valid, you might want to add validation to ensure that required parameter sets are provided. For example, if some requests require either param1 or param2, you can use JSR-380 validation annotations (like @NotNull, @AssertTrue) with a custom validator.

Add validation to your DTO:

import javax.validation.constraints.AssertTrue;
import javax.validation.constraints.NotBlank;

@Data
@Builder
public class ApiRequestParams {
    private String param1;
    private String param2;
    // ... other parameters

    @AssertTrue(message = "Either param1 or param2 must be provided")
    public boolean isParam1OrParam2Present() {
        return param1 != null || param2 != null;
    }
}

Then, in your service class, add a @Valid annotation to the params parameter and handle validation exceptions.

Using this wrapper is straightforward. You just create a parameter instance with the builder and call the service:

// Example 1: Only param1
ApiRequestParams params1 = ApiRequestParams.builder()
    .param1("value")
    .build();
apiClientService.callApi(params1);

// Example 2: param3 and param4
ApiRequestParams params2 = ApiRequestParams.builder()
    .param3("value")
    .param4("value")
    .build();
apiClientService.callApi(params2);

This approach keeps your code clean, maintainable, and easy to extend—if you ever need to add more parameters or change the API logic, you only have to update the DTO and service class, not every place where you make the API call.

内容的提问来源于stack exchange，提问作者Shikha A