Comment définir l'en-tête HTTP dans l'infrastructure client RESTEasy?

RESTEasy (un JAX-RS de mise en œuvre) a une belle cadre du clientpar exemple:

RegisterBuiltin.register(ResteasyProviderFactory.getInstance());

SimpleClient client = ProxyFactory.create(SimpleClient.class, "http://localhost:8081");
client.putBasic("hello world");

Comment pouvez-vous définir les en-têtes HTTP?

Précisions:

La solution proposée par jkeeler est une bonne approche, mais je veux mettre les en-têtes HTTP ProxyFactory niveau et je ne veux pas passer en-têtes de l'objet client. Des idées?

source d'informationauteur Lukasz R.

  1. 18

    Avec RestEasy 3.x-je utiliser ClientRequestFilters. Dans l'exemple ci-dessous il y a une intégration continue (CI) serveur à l'écoute pour les demandes en cours d'exécution en arrière-plan. Le test et le serveur CI utilisent la même base de données et les classes d'entité.

    Supposons qu'un locataire nommée "test-locataire' existe effectivement, et il y a un utilisateur "root" qui appartient à qui le locataire, et l'utilisateur a le mot de passe spécifié ci-dessous.

    private static final String BASE_URI = "http://localhost:" + PORT;
@Test(groups = "functionalTests")
public void testGetTenant() throws Exception {
    Client client = ClientBuilder.newClient();
    ResteasyWebTarget target = (ResteasyWebTarget)client.target(BASE_URI);
    client.register(new AddAuthHeadersRequestFilter("root", "DefaultPasswordsAre:-("));
    TenantResource resource = target.proxy(TenantResource.class);

    RestTenant restTenant = resource.getTenant(tenant.id().value().toString());

    assertThat(restTenant.getName(), is("test-tenant"));
    assertThat(restTenant.isActive(), is(true));
}

    Et la AddAuthHeadersRequestFilter classe:

    public static class AddAuthHeadersRequestFilter implements ClientRequestFilter {

    private final String username;
    private final String password;

    public AddAuthHeadersRequestFilter(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public void filter(ClientRequestContext requestContext) throws IOException {
        String token = username + ":" + password;
        String base64Token = Base64.encodeBase64String(token.getBytes(StandardCharsets.UTF_8));
        requestContext.getHeaders().add("Authorization", "Basic " + base64Token);
    }
}

    Les déclarations d'importation (en supposant que vous venez de coller le test et la statique de la classe en un seul TestNg test-fichier de classe):

    import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget;
import org.testng.annotations.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import javax.ws.rs.client.ClientRequestContext;
import javax.ws.rs.client.ClientRequestFilter;
import org.apache.commons.codec.binary.Base64;
  2. 11

    Dans votre client de proxy interface, utilisez la @HeaderParam annotation:

    public interface SimpleClient
{
   @PUT
   @Path("basic")
   @Consumes("text/plain")
   public void putBasic(@HeaderParam("Greeting") String greeting);
}

    L'appel dans votre exemple ci-dessus serait d'ajouter un en-tête HTTP qui ressemble à ceci:

    Greeting: hello world
  3. 11

    J'ai trouvé une solution:

    import org.apache.commons.httpclient.HttpClient;
import org.jboss.resteasy.client.ClientRequest;
import org.jboss.resteasy.client.ClientResponse;
import org.jboss.resteasy.client.ProxyFactory;
import org.jboss.resteasy.client.core.executors.ApacheHttpClientExecutor;
import org.jboss.resteasy.plugins.providers.RegisterBuiltin;
import org.jboss.resteasy.spi.ResteasyProviderFactory;

RegisterBuiltin.register(ResteasyProviderFactory.getInstance());
HttpClient httpClient = new HttpClient();
ApacheHttpClientExecutor executor = new ApacheHttpClientExecutor(httpClient) {
    @Override
    public ClientResponse execute(ClientRequest request) throws Exception {
        request.header("X-My-Header", "value");
        return super.execute(request);
    }           
};

SimpleClient client = ProxyFactory.create(SimpleClient.class, "http://localhost:8081", executor);
client.putBasic("hello world");
  4. 9

    Encore plus facile:

        ResteasyClient client = new ResteasyClientBuilder().build();
    ResteasyWebTarget target = client.target("https://test.com");
    Response response = target.request().header("Authorization", "Basic test123")
            .acceptEncoding("gzip, deflate")
            .post(Entity.entity(some_xml, "application/x-www-form-urlencoded"));