web-dev-qa-db-fra.com

Client Jersey: comment ajouter une liste en tant que paramètre de requête

Je crée un client Jersey pour un service GET ayant un paramètre List en tant que requête. Selon documentation , il est possible d’avoir une liste comme paramètre de requête (cette information est également présente à @ QueryParam javadoc), consultez-la:

En général, le type Java du paramètre de méthode peut:

  1. Être un type primitif;
  2. Avoir un constructeur qui accepte un seul argument String.
  3. Disposez d'une méthode statique nommée valueOf ou fromString qui accepte un seul argument String (voir, par exemple, Integer.valueOf (String) et Java.util.UUID.fromString (String)); ou
  4. Be List, Set ou SortedSet, où T en satisfait 2 ou 3 ci-dessus. La collection résultante est en lecture seule.

Parfois, les paramètres peuvent contenir plusieurs valeurs pour le même nom. Si tel est le cas, les types de 4) peuvent être utilisés pour obtenir toutes les valeurs.

Cependant, je ne vois pas comment ajouter un paramètre de requête List à l'aide du client Jersey.

Je comprends les solutions alternatives sont:

  1. Utilisez POST au lieu de GET;
  2. Transformez la liste en chaîne JSON et transmettez-la au service.

Le premier n'est pas bon, car le verbe HTTP approprié pour le service est GET. C'est une opération de récupération de données.

La seconde sera mon option si vous ne pouvez pas m'aider. :)

Je développe également le service, donc je peux le changer si nécessaire.

Merci!

Mettre à jour

Code client (en utilisant 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>() {});
javarestjersey
73
lsborg

@GET supporte la liste de chaînes

Configuration:
Java: 1,7
Version Jersey: 1.9

ressource

@Path("/v1/test")

Subresource:

// 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();
}

test de Jersey

@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());
}
100
Dharmi

Si vous envoyez autre chose que de simples chaînes, je vous recommande d'utiliser un POST avec un corps de requête approprié ou de transmettre la liste complète sous forme de chaîne JSON codée de manière appropriée. Cependant, avec des chaînes simples, il vous suffit d’ajouter chaque valeur à l’URL de la demande et Jersey la désérialisera pour vous. Donc, étant donné l'exemple de noeud final suivant:

@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();
    }
}

Votre client enverra une demande correspondant à:

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

Ce qui aurait pour résultat que inputList serait désérialisé pour contenir les valeurs 'Hello', 'Stay' et 'Goodbye'

28
Perception

je suis d'accord avec vous sur les solutions alternatives que vous avez mentionnées ci-dessus

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

et il est vrai que vous ne pouvez pas ajouter List à MultiValuedMap en raison de sa classe d'implants MultivaluedMapImpl ont la capacité d'accepter la clé et la valeur de chaîne. qui est montré dans la figure suivante

enter image description here

vous voulez quand même faire ce que vous essayez de suivre le code.

classe de contrôleur

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) ;
       }
}

Classe client

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;
    }
}

j'espère que ça va vous aider.

6
Yogesh Prajapati

Demande GET avec un paramètre de requête JSON

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();    
        }    
    }    
}

Poster une demande:

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();

        }    
    }    
}
2
vaquar khan