Comment utiliser RESTEasy cadre du client pour envoyer des données dans un POST

Je suis en utilisant le RESTEasy cadre du client à l'appel d'un service web RESTful. L'appel se fait via un POST et envoie des données XML sur le serveur. Comment puis-je y arriver?

Ce qui est de l'incantation magique des annotations à utiliser pour ce faire?

Escandell, auriez-vous s'il vous plaît poster l'intégralité de l'exemple ici. Je suis en mesure d'afficher les données à l'aide de xml, mais pas en mesure de sérialiser l'objet correctement. J'espère que votre exemple peut beaucoup m'aider.
J'adore le "incantation magique d'annotations" partie de la question ... c'est l'une des grandes parties de cette nouvelle ingénierie des phénomènes!

OriginalL'auteur David Escandell | 2010-05-20

  1. 12

    Je pense que David est en se référant à la RESTeasy Client "Cadre". Donc, votre réponse (Riduidel) n'est pas particulièrement ce qu'il cherche. Votre solution utilise HttpUrlConnection que le client http. À l'aide de la resteasy client au lieu de HttpUrlConnection ou DefaultHttpClient est bénéfique, car resteasy client est JAX-RS conscient. Pour utiliser le RESTeasy client, vous construisez org.jboss.resteasy.client.ClientRequest objets et de construire des requêtes à l'aide de ses constructeurs et des méthodes. Ci-dessous est ce que je pourrais mettre en oeuvre de David, la question de l'utilisation du client cadre de RESTeasy.

    ClientRequest request = new ClientRequest("http://url/resource/{id}");

StringBuilder sb = new StringBuilder();
sb.append("<user id=\"0\">");
sb.append("   <username>Test User</username>");
sb.append("   <email>[email protected]</email>");
sb.append("</user>");


String xmltext = sb.toString();

request.accept("application/xml").pathParameter("id", 1).body( MediaType.APPLICATION_XML, xmltext);

String response = request.postTarget( String.class); //get response and automatically unmarshall to a string.

//or

ClientResponse<String> response = request.post();

    Espère que cette aide,
    Charlie

    Effectivement aider. La solution que j'ai trouvé encore plus simple. Le cadre permet de construire une interface java définir le RESTE des méthodes que vous allez appeler. vous pouvez placer un @Produit("application/xml") en face de la méthode, puis la passer dans les objets appropriés annotations JAXB, et magie, tout fonctionne.
    Certainement! Cette façon de faire les appels utilise RESTeasy Client Proxy. On pourrait appeler cela un autre type de "client-cadre" pour apporter des services restful. Je préfère même cette méthode car elle permet de réutiliser l'interface de service du serveur sur le client et disposent ainsi d'un plus facile et l'auto-documentation api unifiée.

    OriginalL'auteur Charles Akalugwu

  2. 4

    C'est aussi simple que suivant

        @Test
    public void testPost() throws Exception {
        final ClientRequest clientCreateRequest = new ClientRequest("http://localhost:9090/variables");
        final MultivaluedMap<String, String> formParameters = clientCreateRequest.getFormParameters();
        final String name = "postVariable";
        formParameters.putSingle("name", name);
        formParameters.putSingle("type", "String");
        formParameters.putSingle("units", "units");
        formParameters.putSingle("description", "description");
        formParameters.putSingle("core", "true");
        final ClientResponse<String> clientCreateResponse = clientCreateRequest.post(String.class);
        assertEquals(201, clientCreateResponse.getStatus());
    }

    OriginalL'auteur daydreamer

  3. 0

    J'ai emprunté à partir de cet exemple : Construire de service restful avec RESTEasy le fragment de code suivant, qui semble faire exactement ce que vous voulez, non ?

    URL url = new URL("http://localhost:8081/user");
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/xml");
connection.setDoOutput(true);
connection.setInstanceFollowRedirects(false);

StringBuffer sbuffer = new StringBuffer();
sbuffer.append("<user id=\"0\">");
sbuffer.append("   <username>Test User</username>");
sbuffer.append("   <email>[email protected]</email>");
sbuffer.append("</user>");

OutputStream os = connection.getOutputStream();
os.write(sbuffer.toString().getBytes());
os.flush();

assertEquals(HttpURLConnection.HTTP_CREATED, connection.getResponseCode());
connection.disconnect();

    OriginalL'auteur Riduidel

  4. 0

    J'ai eu quelques difficultés à trouver comment faire cela, donc j'ai pensé que je pourrais le poster ici. À l'aide de la RESTeasy client proxy mécanisme est en fait trop facile.

    Comme Charles Akalugwu l'indique, cette approche permet de créer une seule interface Java que vous pouvez utiliser à la fois sur le client et côté serveur, et des résultats à la fois le client et le code côté serveur c'est évident et facile à utiliser.

    D'abord, déclarer une interface Java pour le service. Ce sera utilisé à la fois sur le client et côté serveur, et devrait contenir tous les JAX-RS déclarations:

    @Path("/path/to/service")
public interface UploadService
{
  @POST
  @Consumes("text/plan")
  public Response uploadFile(InputStream inputStream);
}

    Ensuite, écrire un serveur qui implémente cette interface. C'est aussi facile que ça en a l'air:

    public class UploadServer extends Application implements UploadService
{
  @Override
  public Response uploadFile(InputStream inputStream)
  {
    //The inputStream contains the POST data
    InputStream.read(...);

    //Return the location of the new resource to the client:
    Response.created(new URI(location)).build();
  }
}

    Pour répondre à la question "comment utiliser RESTEasy Cadre du Client pour envoyer des données dans un POST", tout ce que vous avez à faire est d'appeler le service d'interface à partir du côté client via un RESTeasy proxy, et RESTeasy va faire de la POSTE pour vous. Pour créer le proxy client:

    Client client = ClientBuilder.newClient();
WebTarget target = client.target("http://path/to/service");
ResteasyWebTarget rtarget = (ResteasyWebTarget)target;
UploadService uploadService = rtarget.proxy(UploadService.class);

    Pour publier des données au service:

    InputStream inputStream = new FileInputStream("/tmp/myfile");
uploadService.uploadFile(inputStream);

    Naturellement, si vous écrivez à un service REST existant, alors vous pourriez aborder le problème par l'écriture d'une interface Java juste pour le client.

    OriginalL'auteur Doctor Eval