spring
RestTemplate

एक बड़ी फ़ाइल डाउनलोड करना

getForObject और getForEntity के तरीकों RestTemplate स्मृति में पूरे प्रतिक्रिया लोड। यह बड़ी फ़ाइलों को डाउनलोड करने के लिए उपयुक्त नहीं है क्योंकि यह मेमोरी अपवादों से बाहर हो सकती है। यह उदाहरण दिखाता है कि 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);

ध्यान दें कि आप एक्स्ट्रेक्टर से InputStream को वापस नहीं कर सकते, क्योंकि जब तक निष्पादित विधि वापस आती है, तब तक अंतर्निहित कनेक्शन और स्ट्रीम पहले ही बंद हो जाती है।

RestTemplate और HttpClient के साथ प्रीमेप्टिव बेसिक ऑथेंटिकेशन का उपयोग करना

प्रीमेप्टिव बेसिक ऑथेंटिकेशन सर्वर के 401 जवाब देने से पहले http बेसिक ऑथेंटिकेशन क्रेडेंशियल (यूजरनेम और पासवर्ड) भेजने का चलन है। यह REST एपिस का उपभोग करते समय एक अनुरोध राउंड ट्रिप को बचा सकता है जिसे मूल प्रमाणीकरण की आवश्यकता होती है।

जैसा कि स्प्रिंग डॉक्यूमेंटेशन में बताया गया है, Apache HttpClient को HttpComponentsClientHttpRequestFactory का उपयोग करके HTTP अनुरोध बनाने के लिए अंतर्निहित कार्यान्वयन के रूप में उपयोग किया जा सकता है। प्रचलित मूल प्रमाणीकरण करने के लिए HttpClient को कॉन्फ़िगर किया जा सकता है।

निम्नांकित वर्ग HttpComponentsClientHttpRequestFactory बेसिक प्रमाणीकरण प्रदान करने के लिए 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 के साथ मूल प्रमाणीकरण का उपयोग करना

HTTP अनुरोध बनाने के लिए RestTemplate के अंतर्निहित कार्यान्वयन के रूप में HttpClient का उपयोग करना एपीआई के साथ बातचीत करते समय बुनियादी प्रमाणीकरण अनुरोधों (एक 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);

स्प्रिंग रिस्टेमप्लेट अनुरोध पर हेडर सेट करना

RestTemplate की exchange विधियाँ आपको एक 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());
}

जेनरिक का परिणाम स्प्रिंग रेस्टेमप्लेट से है

RestTemplate को लौटी हुई सामग्री के सामान्य को समझने के लिए हमें परिणाम प्रकार के संदर्भ को परिभाषित करने की आवश्यकता है।

org.springframework.core.ParameterizedTypeReference 3.2 के बाद से पेश किया गया है

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

एक नियंत्रक से उदाहरण के लिए List<User> प्राप्त करने के लिए उपयोगी हो सकता है।