RestTemplate client avec les cookies

Je suis en train d'écrire un simple client en Java pour permettre réutilisables exclusif de détection de virus les logiciels accessibles via une API RESTful. Pour télécharger un fichier pour la numérisation de l'API nécessite un POST pour se Connecter, suivie par une POST pour l'Édition du fichier vers le serveur. Dans la réponse à la Connecter POST il y a les cookies placés par le serveur qui doivent être présents dans la suite de la POST pour publier le fichier. Je suis actuellement à l'aide de Printemps RestTemplate dans mon client.

Ma question est comment puis-je accéder aux cookies dans la réponse à l'avant vers le serveur à la suite de la POST? Je peux voir qu'ils sont présents dans l'en-tête qui est retourné, mais il n'existe pas de méthodes sur la ResponseEntity pour y accéder.

OriginalL'auteur Tom | 2014-04-04

9

RestTemplate a une méthode dans laquelle vous pouvez définir l'Interface ResponseExtractor<T>, cette interface est utilisée pour obtenir les en-têtes de la réponse, une fois que vous les avez vous pu l'envoyer en arrière en utilisant HttpEntity et de l'ajouter à nouveau.
```
 .add("Cookie", "SERVERID=c52");
```
Essayer quelque chose comme cela.
```
String cookieHeader = null;

new ResponseExtractor<T>(){
      T extractData(ClientHttpResponse response) {
        response.getHeaders();
      }
}
```
Puis
```
  HttpHeaders headers = new HttpHeaders();
  headers.add("Cookie", cookieHeader );

  ResponseEntity<byte[]> response = restTemplate.exchange("http://example.com/file/123",
      GET,
      new HttpEntity<String>(headers),
      byte[].class);
```
Également lire cette post

Donc, en d'autres mots, je viens de les traiter comme tout autre en-tête? Je n'étais pas sûr si il y avait une façon particulière de traiter avec le RestTemplate où ils obtiennent automatiquement ajouté à la suite des réponses ou quelque chose.
Oui vous avez raison et je ne pense pas que faire automatiquement, cela peut être réaliser avec le resttemplate comme il est. Vous devez prendre les en-têtes et re les envoyer, si vous pouvez obtenir automatiquement n'oubliez pas de me dire votre truc =)

OriginalL'auteur Koitoer
3

Vous devez utiliser exchange méthode de RestTemplate de Java framework Spring.

Lire ce tutoriel: http://codeflex.co/java-rest-client-get-cookie/

OriginalL'auteur user5495300

Petite mise à jour pour gérer les sessions dans un test complet avec java.net.HttpCookie' Objet.

@Merci Shedon

import java.io.IOException;
import java.net.HttpCookie;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.ResponseExtractor;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
/**
* @link https://stackoverflow.com/questions/22853321/resttemplate-client-with-cookies
*/
@Component
public class RestTemplateWithCookies extends RestTemplate {
private final List<HttpCookie> cookies = new ArrayList<>();
public RestTemplateWithCookies() {
}
public RestTemplateWithCookies(ClientHttpRequestFactory requestFactory) {
super(requestFactory);
}
public synchronized List<HttpCookie> getCoookies() {
return cookies;
}
public synchronized void resetCoookies() {
cookies.clear();
}
private void processHeaders(HttpHeaders headers) {
final List<String> cooks = headers.get("Set-Cookie");
if (cooks != null && !cooks.isEmpty()) {
cooks.stream().map((c) -> HttpCookie.parse(c)).forEachOrdered((cook) -> {
cook.forEach((a) -> {
HttpCookie cookieExists = cookies.stream().filter(x -> a.getName().equals(x.getName())).findAny().orElse(null);
if (cookieExists != null) {
cookies.remove(cookieExists);
}
cookies.add(a);
});
});
}
}
@Override
protected <T extends Object> T doExecute(URI url, HttpMethod method, final RequestCallback requestCallback, final ResponseExtractor<T> responseExtractor) throws RestClientException {
final List<HttpCookie> cookies = getCoookies();
return super.doExecute(url, method, new RequestCallback() {
@Override
public void doWithRequest(ClientHttpRequest chr) throws IOException {
if (cookies != null) {
StringBuilder sb = new StringBuilder();
for (HttpCookie cookie : cookies) {
sb.append(cookie.getName()).append(cookie.getValue()).append(";");
}
chr.getHeaders().add("Cookie", sb.toString());
}
requestCallback.doWithRequest(chr);
}
}, new ResponseExtractor<T>() {
@Override
public T extractData(ClientHttpResponse chr) throws IOException {
processHeaders(chr.getHeaders());
return responseExtractor.extractData(chr);
}
});
}
}

OriginalL'auteur GerardNorton

j'ai écrit une simple classe qui étend la classe RestTemplate et gère les cookies.

import java.io.IOException;
import java.net.URI;
import java.util.List;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.ResponseExtractor;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
public class RestTemplateWithCookies extends RestTemplate {
private List<String> cookies = null;
public RestTemplateWithCookies() {
}
public RestTemplateWithCookies(ClientHttpRequestFactory requestFactory) {
super(requestFactory);
}
private synchronized List<String> getCoookies() {
return cookies;
}
private synchronized void setCoookies(List<String> cookies) {
this.cookies = cookies;
}
public synchronized void resetCoookies() {
this.cookies = null;
}
private void processHeaders(HttpHeaders headers) {
final List<String> cookies = headers.get("Set-Cookie");
if (cookies != null && !cookies.isEmpty()) {
setCoookies(cookies);
}
}
@Override
protected <T extends Object> T doExecute(URI url, HttpMethod method, final RequestCallback requestCallback, final ResponseExtractor<T> responseExtractor) throws RestClientException {
final List<String> cookies = getCoookies();
return super.doExecute(url, method, new RequestCallback() {
@Override
public void doWithRequest(ClientHttpRequest chr) throws IOException {
if(cookies != null) {
for(String cookie : cookies) {
chr.getHeaders().add("Cookie", cookie);
}
}
requestCallback.doWithRequest(chr);
}
}, new ResponseExtractor<T>() {
@Override
public T extractData(ClientHttpResponse chr) throws IOException {
processHeaders(chr.getHeaders());
return responseExtractor.extractData(chr);
}
});
}
}

OriginalL'auteur Shedon

J'ai résolu le problème par la création d'un intercepteur qui stocke un cookie et le met dans les prochaines demandes.

public class StatefulRestTemplateInterceptor implements ClientHttpRequestInterceptor {
private String cookie;
@Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
if (cookie != null) {
request.getHeaders().add(HttpHeaders.COOKIE, cookie);
}
ClientHttpResponse response = execution.execute(request, body);
if (cookie == null) {
cookie = response.getHeaders().getFirst(HttpHeaders.SET_COOKIE);
}
return response;
}
}

Ensemble de l'intercepteur pour votre RestTemplate:

@Bean
public RestTemplate restTemplate(RestTemplateBuilder templateBuilder) {
return templateBuilder
.requestFactory(new BufferingClientHttpRequestFactory(new HttpComponentsClientHttpRequestFactory()))
.interceptors(new StatefulRestTemplateInterceptor())
.build();
}

OriginalL'auteur Ilya Lysenko

Vous devez vous connecter pour publier un commentaire.