spring => RestTemplate

큰 파일 다운로드

RestTemplate 의 getForObject 및 getForEntity 메소드는 전체 응답을 메모리에로드합니다. 메모리 부족 예외가 발생할 수 있으므로 대용량 파일을 다운로드하는 데는 적합하지 않습니다. 이 예에서는 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 HttpClient 는 HttpComponentsClientHttpRequestFactory 를 사용하여 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에서 기본 인증 사용

HttpClient 를 RestTemplate 의 기본 구현으로 사용하여 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);