수색…


큰 파일 다운로드

RestTemplategetForObjectgetForEntity 메소드는 전체 응답을 메모리에로드합니다. 메모리 부족 예외가 발생할 수 있으므로 대용량 파일을 다운로드하는 데는 적합하지 않습니다. 이 예에서는 GET 요청의 응답을 스트리밍하는 방법을 보여줍니다.

RestTemplate restTemplate // = ...;

// Optional Accept header
RequestCallback requestCallback = request -> request.getHeaders()
        .setAccept(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM, MediaType.ALL));

// Streams the response instead of loading it all in memory
ResponseExtractor<Void> responseExtractor = response -> {
    // Here I write the response to a file but do what you like
    Path path = Paths.get("some/path");
    Files.copy(response.getBody(), path);
    return null;
};
restTemplate.execute(URI.create("www.something.com"), HttpMethod.GET, requestCallback, responseExtractor);

execute 메소드가 돌아올 때까지 기본 연결과 스트림이 이미 닫혀 있기 때문에 Extractor에서 InputStream 을 단순히 반환 할 수는 없습니다.

RestTemplate 및 HttpClient에서 선점 기본 인증 사용

선점 형 기본 인증은 서버가 요청하는 401 응답으로 응답 하기 전에 http 기본 인증 자격 증명 (사용자 이름 및 암호)을 전송하는 관행입니다. 기본 인증이 필요한 것으로 알려진 REST API를 사용하면 왕복 요청을 저장할 수 있습니다.

Spring 문서에 설명 된대로 Apache HttpClientHttpComponentsClientHttpRequestFactory 를 사용하여 HTTP 요청을 작성하기위한 기본 구현으로 사용될 수 있습니다. 선점 기본 인증 을 수행하도록 HttpClient를 구성 할 수 있습니다.

다음 클래스는 HttpComponentsClientHttpRequestFactory 를 확장하여 선점 기본 인증을 제공합니다.

/**
 * {@link HttpComponentsClientHttpRequestFactory} with preemptive basic
 * authentication to avoid the unnecessary first 401 response asking for
 * credentials.
 * <p>
 * Only preemptively sends the given credentials to the given host and
 * optionally to its subdomains. Matching subdomains can be useful for APIs
 * using multiple subdomains which are not always known in advance.
 * <p>
 * Other configurations of the {@link HttpClient} are not modified (e.g. the
 * default credentials provider).
 */
public class PreAuthHttpComponentsClientHttpRequestFactory extends HttpComponentsClientHttpRequestFactory {

    private String hostName;
    private boolean matchSubDomains;
    private Credentials credentials;

    /**
     * @param httpClient
     *            client
     * @param hostName
     *            host name
     * @param matchSubDomains
     *            whether to match the host's subdomains
     * @param userName
     *            basic authentication user name
     * @param password
     *            basic authentication password
     */
    public PreAuthHttpComponentsClientHttpRequestFactory(HttpClient httpClient, String hostName,
            boolean matchSubDomains, String userName, String password) {
        super(httpClient);
        this.hostName = hostName;
        this.matchSubDomains = matchSubDomains;
        credentials = new UsernamePasswordCredentials(userName, password);
    }

    @Override
    protected HttpContext createHttpContext(HttpMethod httpMethod, URI uri) {
        // Add AuthCache to the execution context
        HttpClientContext context = HttpClientContext.create();
        context.setCredentialsProvider(new PreAuthCredentialsProvider());
        context.setAuthCache(new PreAuthAuthCache());
        return context;
    }

    /**
     * @param host
     *            host name
     * @return whether the configured credentials should be used for the given
     *         host
     */
    protected boolean hostNameMatches(String host) {
        return host.equals(hostName) || (matchSubDomains && host.endsWith("." + hostName));
    }

    private class PreAuthCredentialsProvider extends BasicCredentialsProvider {
        @Override
        public Credentials getCredentials(AuthScope authscope) {
            if (hostNameMatches(authscope.getHost())) {
                // Simulate a basic authenticationcredentials entry in the
                // credentials provider.
                return credentials;
            }
            return super.getCredentials(authscope);
        }
    }

    private class PreAuthAuthCache extends BasicAuthCache {
        @Override
        public AuthScheme get(HttpHost host) {
            if (hostNameMatches(host.getHostName())) {
                // Simulate a cache entry for this host. This instructs
                // HttpClient to use basic authentication for this host.
                return new BasicScheme();
            }
            return super.get(host);
        }
    }
}

다음과 같이 사용할 수 있습니다.

HttpClientBuilder builder = HttpClientBuilder.create();
ClientHttpRequestFactory requestFactory =
    new PreAuthHttpComponentsClientHttpRequestFactory(builder.build(),
        "api.some-host.com", true, "api", "my-key");
RestTemplate restTemplate = new RestTemplate(requestFactory);

HttpComponent의 HttpClient에서 기본 인증 사용

HttpClientRestTemplate 의 기본 구현으로 사용하여 HTTP 요청을 만들면 API와 상호 작용할 때 기본 인증 요청 (http 401 응답)을 자동으로 처리 할 수 ​​있습니다. 이 예제는이를 달성하기 위해 RestTemplate 을 구성하는 방법을 보여줍니다.

// The credentials are stored here
CredentialsProvider credsProvider = new BasicCredentialsProvider();
credsProvider.setCredentials(
        // AuthScope can be configured more extensively to restrict
        // for which host/port/scheme/etc the credentials will be used.
        new AuthScope("somehost", AuthScope.ANY_PORT), 
        new UsernamePasswordCredentials("username", "password"));

// Use the credentials provider
HttpClientBuilder builder = HttpClientBuilder.create();
builder.setDefaultCredentialsProvider(credsProvider);

// Configure the RestTemplate to use HttpComponent's HttpClient
ClientHttpRequestFactory requestFactory =
        new HttpComponentsClientHttpRequestFactory(builder.build());
RestTemplate restTemplate = new RestTemplate(requestFactory);

Spring RestTemplate 요청에 헤더 설정하기

RestTemplateexchange 메소드를 사용하면 메소드를 실행할 때 요청에 쓰여지는 HttpEntity 를 지정할 수 있습니다. 이 엔티티에 헤더 (예 : 사용자 에이전트, 리퍼러 ...)를 추가 할 수 있습니다.

public void testHeader(final RestTemplate restTemplate){
        //Set the headers you need send
        final HttpHeaders headers = new HttpHeaders();
        headers.set("User-Agent", "eltabo");

        //Create a new HttpEntity
        final HttpEntity<String> entity = new HttpEntity<String>(headers);
        
        //Execute the method writing your HttpEntity to the request
        ResponseEntity<Map> response = restTemplate.exchange("https://httpbin.org/user-agent", HttpMethod.GET, entity, Map.class);        
        System.out.println(response.getBody());
    }

또한 여러 요청에 동일한 헤더를 추가해야하는 경우 RestTemplate 인터셉터를 추가 할 수 있습니다.

public void testHeader2(final RestTemplate restTemplate){
    //Add a ClientHttpRequestInterceptor to the RestTemplate
    restTemplate.getInterceptors().add(new ClientHttpRequestInterceptor(){
        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            request.getHeaders().set("User-Agent", "eltabo");//Set the header for each request
            return execution.execute(request, body);
        }
    }); 
    
    ResponseEntity<Map> response = restTemplate.getForEntity("https://httpbin.org/user-agent", Map.class);        
    System.out.println(response.getBody());
    
    ResponseEntity<Map> response2 = restTemplate.getForEntity("https://httpbin.org/headers", Map.class);        
    System.out.println(response2.getBody());
}

Spring RestTemplate의 일반 결과

RestTemplate 이 반환 된 내용의 일반을 이해하게하려면 결과 유형 참조를 정의해야합니다.

org.springframework.core.ParameterizedTypeReference 는 3.2 이후에 도입되었습니다.

Wrapper<Model> response = restClient.exchange(url, 
                          HttpMethod.GET, 
                          null, 
                          new ParameterizedTypeReference<Wrapper<Model>>() {}).getBody();

List<User> 를 컨트롤러에서 가져 오는 것이 유용 할 수 있습니다.



Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow