java.net.ResponseCache Class in Java

0 1 2 minutes read

ResponseCache in java is used for constructing implementation of URLConnection caches, and it nominates which resource has to be cached and up to what time duration a resource needed to be cached.

An instance of ResponseCache can be created using the system by doing :

ResponseCache.setDefault(ResponseCache)

The instance created by using the above statement will call an object of ResponseCache in order to :

For storing resource data that has been which has been retrieved from an external source into the cache.
For fetching a resource that has been stored in the cache on request.
Response cache can be imported through java.net package

java.net.ResponseCache

Methods of ResponseCache class :

Method	Description
get(URI uri, String rqstMethod, Map<String,List<String> > rqstHeaders)	This method is used for retrieving the cached response depending upon the requesting URI, request method and request headers.
getDefault()	This method is used for retrieving the system-wide cache response.
put(URI uri, URLConnection conn)	The protocol handler calls this method whenever a resource has been retrieved and the ResponseCache must decide whether to store the resource in its cache.
setDefault(ResponseCache responseCache)	This method is used to set or unset the system-wide cache

Applications of ResponseCache class :

1. In the java.net package, ResponseCache is used for implementing for caching of resources for various network applications such as :

Email
File Transfer
Remote Terminal Access
Loading web pages

java.net.ResponseCache

2. In java.net, ResponseCache is applied in fetching out system-wide response cache.

public static ResponseCache.getDefault()

3. In java.net, ResponseCcahe is used in setting or unsetting out the system-wide cache.

public static void ResponseCache.setDefault(ResponseCache responseCache)

Java program for implementing java.net.ResponseCache :

Java

import java.io.IOException;
import java.net.*;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public class JavaResponseCacheExample1 {
    public static void main(String args[]) throws Exception
    {
  
        // passing the string uri
        String uri = "https://www.onlinegdb.com";
  
        // Calling the constructor of the URI class
        URI uri1 = new URI(uri);
  
        // passing the url
        URL url = new URL("http://www.onlinegdb.com");
  
        // calling the constructor of the URLConnection
        URLConnection urlcon = url.openConnection();
        ResponseCache responseCache = new ResponseCache() {
            // calling the abstract methods
            @Override
            public CacheResponse get(
                URI uri, String rqstMethod,
                Map<String, List<String> > rqstHeaders)
                throws IOException
            {
                return null;
            }
  
            @Override
            public CacheRequest put(URI uri,
                                    URLConnection conn)
                throws IOException
            {
                return null;
            }
        };
  
        // The sets the system-wide response cache.
        ResponseCache.setDefault(responseCache);
  
        // The getDefault() method returns
        // the system-wide ResponseCache .
        System.out.println("Default value: "
                           + ResponseCache.getDefault());
        Map<String, List<String> > maps
            = new HashMap<String, List<String> >();
        List<String> list = new LinkedList<String>();
        list.add("REema");
  
        // put() method sets all the applicable cookies,
        // present in the response headers into a cookie
        // cache
        maps.put("1", list);
        System.out.println(
            "The put() method has been called...");
  
        // The put() method returns the
        // CacheRequest for recording
        System.out.println(
            "The put() method returns: "
            + responseCache.put(uri1, urlcon));
        System.out.println(
            "The get() method has been called...");
  
        // The get() method returns a CacheResponse
        // instance if it is available
        System.out.println(
            "The get() method returns: "
            + responseCache.get(uri1, uri, maps));
    }
}