poner - titledborder java

Cliente de Jersey: cómo agregar una lista como parámetro de consulta

Question

Estoy creando un cliente Jersey para un servicio GET que tiene una lista como parámetro de consulta. Según la documentation , es posible tener una lista como parámetro de consulta (esta información también está en @QueryParam javadoc), compruébalo:

En general, el tipo de Java del parámetro de método puede:

1. Sé un tipo primitivo;
2. Tener un constructor que acepte un único argumento String;
3. Tener un método estático llamado valueOf o fromString que acepte un único argumento String (consulte, por ejemplo, Integer.valueOf (String) y java.utiliránID.fromString (String)); o
4. Be List, Set u SortedSet, donde T satisface 2 o 3 arriba. La colección resultante es de solo lectura.

Algunas veces los parámetros pueden contener más de un valor para el mismo nombre. Si este es el caso, entonces los tipos en 4) se pueden usar para obtener todos los valores.

Sin embargo, no puedo entender cómo agregar un parámetro de consulta de lista usando el cliente de Jersey.

Entiendo que las soluciones alternativas son:

1. Use POST en lugar de GET;
2. Transforma la lista en una cadena JSON y pásala al servicio.

El primero no es bueno, porque el verbo HTTP apropiado para el servicio es GET. Es una operación de recuperación de datos.

El segundo será mi opción si no puedes ayudarme. :)

También estoy desarrollando el servicio, por lo que puedo cambiarlo si es necesario.

¡Gracias!

Actualizar

Código de cliente (usando json)

Client client = Client.create();
WebResource webResource = client.resource(uri.toString());
SearchWrapper sw = new SearchWrapper(termo, pagina, ordenacao, hits, SEARCH_VIEW, navegadores);
MultivaluedMap<String, String> params = new MultivaluedMapImpl();
params.add("user", user.toUpperCase());
params.add("searchWrapperAsJSON", (new Gson()).toJson(sw));
ClientResponse clientResponse = webResource .path("/listar")
.queryParams(params)
.header(HttpHeaders.AUTHORIZATION, AuthenticationHelper.getBasicAuthHeader())
.get(ClientResponse.class);
SearchResultWrapper busca = clientResponse.getEntity(new GenericType<SearchResultWrapper>() {});

Answer 1

Estoy de acuerdo con usted acerca de las soluciones alternativas que mencionó anteriormente

1. Use POST instead of GET;
2. Transform the List into a JSON string and pass it to the service.

y es cierto que no puede agregar List a MultiValuedMap porque su clase impl MultivaluedMapImpl tiene capacidad para aceptar String Key y String Value. que se muestra en la siguiente figura

todavía quieres hacer esas cosas que intentar seguir el código.

Clase de controlador

package net.yogesh.test;
import java.util.List;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import com.google.gson.Gson;
@Path("test")
public class TestController {
@Path("testMethod")
@GET
@Produces("application/text")
public String save(
@QueryParam("list") List<String> list) {
return new Gson().toJson(list) ;
}
}

Clase Cleint

package net.yogesh.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.ws.rs.core.MultivaluedMap;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;
import com.sun.jersey.core.util.MultivaluedMapImpl;
public class Client {
public static void main(String[] args) {
String op = doGet("http://localhost:8080/JerseyTest/rest/test/testMethod");
System.out.println(op);
}
private static String doGet(String url){
List<String> list = new ArrayList<String>();
list = Arrays.asList(new String[]{"string1,string2,string3"});
MultivaluedMap<String, String> params = new MultivaluedMapImpl();
String lst = (list.toString()).substring(1, list.toString().length()-1);
params.add("list", lst);
ClientConfig config = new DefaultClientConfig();
com.sun.jersey.api.client.Client client = com.sun.jersey.api.client.Client.create(config);
WebResource resource = client.resource(url);
ClientResponse response = resource.queryParams(params).type("application/x-www-form-urlencoded").get(ClientResponse.class);
String en = response.getEntity(String.class);
return en;
}
}

Espero que esto te ayude.

Answer 2

GET Request con JSON Query Param

package com.rest.jersey.jerseyclient;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
public class JerseyClientGET {
public static void main(String[] args) {
try {
String BASE_URI="http://vaquarkhan.net:8080/khanWeb";
Client client = Client.create();
WebResource webResource = client.resource(BASE_URI);
ClientResponse response = webResource.accept("application/json").get(ClientResponse.class);
/*if (response.getStatus() != 200) {
throw new RuntimeException("Failed : HTTP error code : "
+ response.getStatus());
}
*/
String output = webResource.path("/msg/sms").queryParam("search","{/"name/":/"vaquar/",/"surname/":/"khan/",/"ext/":/"2020/",/"age/":/"34/""}").get(String.class);
//String output = response.getEntity(String.class);
System.out.println("Output from Server .... /n");
System.out.println(output);
//
} catch (Exception e) {
e.printStackTrace();
}
}
}

Solicitud de publicación:

package com.rest.jersey.jerseyclient;
import com.rest.jersey.dto.KhanDTOInput;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;
import com.sun.jersey.api.json.JSONConfiguration;
public class JerseyClientPOST {
public static void main(String[] args) {
try {
KhanDTOInput khanDTOInput = new KhanDTOInput("vaquar", "khan", "20", "E", null, "2222", "8308511500");
ClientConfig clientConfig = new DefaultClientConfig();
clientConfig.getFeatures().put( JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
Client client = Client.create(clientConfig);
//
// final HTTPBasicAuthFilter authFilter = new HTTPBasicAuthFilter(username, password);
// client.addFilter(authFilter);
// client.addFilter(new LoggingFilter());
//
WebResource webResource = client
.resource("http://vaquarkhan.net:12221/khanWeb/messages/sms/api/v1/userapi");
ClientResponse response = webResource.accept("application/json")
.type("application/json").put(ClientResponse.class, khanDTOInput);
if (response.getStatus() != 200) {
throw new RuntimeException("Failed : HTTP error code : "
+ response.getStatus());
}
String output = response.getEntity(String.class);
System.out.println("Server response .... /n");
System.out.println(output);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Answer 3

Si está enviando algo más que strings simples, le recomendaría usar un POST con un cuerpo de solicitud apropiado, o pasar la lista completa como una cadena JSON adecuadamente codificada. Sin embargo, con cadenas simples, solo debe agregar cada valor a la URL de la solicitud de manera adecuada y Jersey lo deserializará por usted. Por lo tanto, dado el siguiente punto final de ejemplo:

@Path("/service/echo") public class MyServiceImpl {
public MyServiceImpl() {
super();
}
@GET
@Path("/withlist")
@Produces(MediaType.TEXT_PLAIN)
public Response echoInputList(@QueryParam("list") final List<String> inputList) {
return Response.ok(inputList).build();
}
}

Su cliente enviaría una solicitud correspondiente a:

OBTENER http://example.com/services/echo?list=Hello&list=Stay&list=Goodbye

Lo que daría como resultado que inputList se deserialice para contener los valores ''Hello'', ''Stay'' y ''Goodbye''

Answer 4

@GET admite la lista de cadenas

Configuración :
Java: 1.7
Versión de Jersey: 1.9

Recurso

@Path("/v1/test")

Subcurso :

// receive List of Strings
@GET
@Path("/receiveListOfStrings")
public Response receiveListOfStrings(@QueryParam("list") final List<String> list){
log.info("receieved list of size="+list.size());
return Response.ok().build();
}

Jersey testcase

@Test
public void testReceiveListOfStrings() throws Exception {
WebResource webResource = resource();
ClientResponse responseMsg = webResource.path("/v1/test/receiveListOfStrings")
.queryParam("list", "one")
.queryParam("list", "two")
.queryParam("list", "three")
.get(ClientResponse.class);
Assert.assertEquals(200, responseMsg.getStatus());
}