java - getforobject - Spring RestTemplate GET con parámetros

resttemplate spring boot post example

Question

Tengo que hacer una llamada REST que incluya encabezados personalizados y parámetros de consulta. Configuré mi HttpEntity solo con los encabezados (sin cuerpo) y utilizo el método RestTemplate.exchange () de la siguiente manera:

HttpHeaders headers = new HttpHeaders();
headers.set("Accept", "application/json");
Map<String, String> params = new HashMap<String, String>();
params.put("msisdn", msisdn);
params.put("email", email);
params.put("clientVersion", clientVersion);
params.put("clientType", clientType);
params.put("issuerName", issuerName);
params.put("applicationName", applicationName);
HttpEntity entity = new HttpEntity(headers);
HttpEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, entity, String.class, params);

Esto falla en el extremo del cliente porque el servlet del distribuidor no puede resolver la solicitud a un controlador. Havinf lo depuró, parece que los parámetros de solicitud no se envían.

Cuando hago un intercambio con un POST usando un cuerpo de solicitud y sin parámetros de consulta, funciona bien.

¿Alguien tiene alguna idea?

Answer 1

Desde al menos Spring 3, en lugar de utilizar UriComponentsBuilder para compilar la URL (que es un poco detallada), muchos de los métodos RestTemplate aceptan marcadores de posición en la ruta de parámetros (no solo de exchange ).

De la documentación:

Muchos de los métodos RestTemplate aceptan una plantilla URI y variables de plantilla URI, ya sea como String vararg, o como Map<String,String> .

Por ejemplo, con un vararg de String :

restTemplate.getForObject(
"http://example.com/hotels/{hotel}/rooms/{hotel}", String.class, "42", "21");

O con un Map<String, String> :

Map<String, String> vars = Collections.singletonMap("hotel", "42");
restTemplate.getForObject("http://example.com/hotels/{hotel}/rooms/{hotel}",
String.class, vars);

Referencia: https://docs.spring.io/spring/docs/current/spring-framework-reference/integration.html#rest-resttemplate-uri

Si observa RestTemplate for RestTemplate y busca la "Plantilla URI", puede ver con qué métodos puede usar marcadores de posición.

Answer 2

Estaba intentando algo similar, y el ejemplo de RoboSpice me ayudó a resolverlo :

HttpHeaders headers = new HttpHeaders();
headers.set("Accept", "application/json");
HttpEntity<String> request = new HttpEntity<>(input, createHeader());
String url = "http://awesomesite.org";
Uri.Builder uriBuilder = Uri.parse(url).buildUpon();
uriBuilder.appendQueryParameter(key, value);
uriBuilder.appendQueryParameter(key, value);
...
String url = uriBuilder.build().toString();
HttpEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, request , String.class);

Answer 3

Los uriVariables también se expanden en la cadena de consulta. Por ejemplo, la siguiente llamada ampliará los valores para ambos, cuenta y nombre:

restTemplate.exchange("http://my-rest-url.org/rest/account/{account}?name={name}",
HttpMethod.GET,
httpEntity,
clazz,
"my-account",
"my-name"
);

por lo que la url de solicitud real será

http://my-rest-url.org/rest/account/my-account?name=my-name

Mira HierarchicalUriComponents.expandInternal (UriTemplateVariables) para más detalles. La versión de Spring es 3.1.3.

Answer 4

OK, entonces estoy siendo un idiota y estoy confundiendo los parámetros de consulta con los parámetros de url. Esperaba que hubiera una manera más agradable de completar mis parámetros de consulta en lugar de una cadena concatenada fea, pero ahí estamos. Simplemente es un caso de construir la URL con los parámetros correctos. Si lo pasa como un String Spring también se encargará de la codificación por usted.

Answer 5

Para manipular fácilmente las URL / ruta / params / etc., puede usar la clase UriComponentsBuilder de Spring. Es más claro que la concatenación manual de cadenas y se encarga de la codificación URL para usted:

HttpHeaders headers = new HttpHeaders();
headers.set("Accept", MediaType.APPLICATION_JSON_VALUE);
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url)
.queryParam("msisdn", msisdn)
.queryParam("email", email)
.queryParam("clientVersion", clientVersion)
.queryParam("clientType", clientType)
.queryParam("issuerName", issuerName)
.queryParam("applicationName", applicationName);
HttpEntity<?> entity = new HttpEntity<>(headers);
HttpEntity<String> response = restTemplate.exchange(
builder.toUriString(),
HttpMethod.GET,
entity,
String.class);

Answer 6

Tomo un enfoque diferente, puede estar de acuerdo o no, pero quiero controlar el archivo .properties en lugar del código compilado de Java

Dentro del archivo application.properties

endpoint.url = https: // suHost / recurso? requestParam1 = {0} & requestParam2 = {1}

El código Java va aquí, puede escribir si cambia la condición para averiguar si el URL del punto final en el archivo .properties tiene @PathVariable (contiene {}) o @RequestParam (suURL? Clave = valor) etc ... luego invoque el método en consecuencia ... . De esa manera es dinámica y no necesita cambiar el código en una ventanilla única futura ...

Estoy tratando de dar más idea que el código real aquí ... intentar escribir un método genérico para @RequestParam, y @PathVariable, etc. ... luego llamar cuando sea necesario

 @Value("${endpoint.url}")
private String endpointURL;
// you can use variable args feature in Java
public String requestParamMethodNameHere(String value1, String value2) {
RestTemplate restTemplate = new RestTemplate();
restTemplate
.getMessageConverters()
.add(new MappingJackson2HttpMessageConverter());
HttpHeaders headers = new HttpHeaders();
headers.set("Accept", MediaType.APPLICATION_JSON_VALUE);
HttpEntity<String> entity = new HttpEntity<>(headers);
try {
String formatted_URL = MessageFormat.format(endpointURL, value1, value2);
ResponseEntity<String> response = restTemplate.exchange(
formatted_URL ,
HttpMethod.GET,
entity,
String.class);
return response.getBody();
} catch (Exception e) { e.printStackTrace(); }

Answer 7

public static void main(String[] args) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.set("Accept", MediaType.APPLICATION_JSON_VALUE);
final String url = "https://host:port/contract/{code}";
Map<String, String> params = new HashMap<String, String>();
params.put("code", "123456");
HttpEntity<?> httpEntity = new HttpEntity<>(httpHeaders);
RestTemplate restTemplate = new RestTemplate();
restTemplate.exchange(url, HttpMethod.GET, httpEntity,String.class, params);
}