Download the JDK
Search the Tutorials
Hide the TOC
Trail: Custom Networking
Lesson: Working With Cookies
Working With Cookies
HTTP State Management With Cookies
CookieHandler Callback Mechanism
Default CookieManager
Custom CookieManager
Home Page > Custom Networking > Working With Cookies
Custom CookieManager

> Two aspects of the `CookieManager` class can be customized, the `CookiePolicy` and the `CookieStore`.

### CookiePolicy

> For convenience, `CookiePolicy` defines the following pre-defined policies for accepting cookies:
> - `CookiePolicy.ACCEPT_ORIGINAL_SERVER` only accepts cookies from the original server.
> - `CookiePolicy.ACCEPT_ALL` accepts all cookies.
> - `CookiePolicy.ACCEPT_NONE` accepts no cookies. </li</ul> You can also define your own cookie policy by implementing the `shouldAccept` method of `CookiePolicy`. You can then use this `CookiePolicy` by passing it to the multi-argument `CookieManager` constructor or by calling the `setCookiePolicy(cookiePolicy)` method to change an already existing cookie manager.

>   The following is an example of a cookie policy that rejects cookies from domains that are on a blacklist, before applying the `CookiePolicy.ACCEPT_ORIGINAL_SERVER` policy:

>   >     import java.net.*;

>   >     public class BlacklistCookiePolicy implements CookiePolicy
>   >     {
>   >         String[] blacklist;

>   >         public BlacklistCookiePolicy(String[] list) {
>   >             blacklist = list;
>   >         }

>   >         public boolean shouldAccept(URI uri, HttpCookie cookie)  {
>   >             String host;
>   >             try {
>   >                 host =  InetAddress.getByName(uri.getHost()).getCanonicalHostName();
>   >             } catch (UnknownHostException e) {
>   >                 host = uri.getHost();
>   >             }

>   >             for (int i=0; i<blacklist.length; i++) {
>   >     	    if (HttpCookie.domainMatches(blacklist[i], host)) {
>   >                     return false;
>   >                 }
>   >             }

>   >             return CookiePolicy.ACCEPT_ORIGINAL_SERVER.shouldAccept(uri, cookie);
>   >         }
>   >     }

>   When you create a `BlacklistCookiePolicy` instance, you pass it an array of strings representing the domains that you do not want to accept cookies from. Then, you set this `BlacklistCookiePolicy` instance as the cookie policy for your `CookieManager`. For example:

>   >     String[] list = new String[] { ".bar.com" };
>   >     CookieManager cm = new CookieManager(null, new BlacklistCookiePolicy(list));
>   >     CookieHandler.setDefault(cm);

>   The sample code will not accept cookies from hosts such as the following:

>   >     foo.bar.com
>   >     goo.bar.com

>   However, this sample code will accept cookies from hosts such as the following:

>   >     y.com
>   >     bar.com
>   >     x.foo.bar.com

### CookieStore

> A `CookieStore` is an interface that represents a storage area for cookies. `CookieManager` adds the cookies to the `CookieStore` for every HTTP response and retrieves cookies from the `CookieStore` for every HTTP request.

> You can implement this interface to provide your own `CookieStore` and pass it to the `CookieManager` during creation. You cannot set the `CookieStore` after the `CookieManager` instance has been created. However, you can get a reference to the cookie store by calling `CookieManager.getCookieStore()`. Doing so can be useful as it enables you to leverage the default in-memory `CookieStore` implementation that is provided by Java SE and complement its functionality.

> For example, you might want to create a persistent cookie store that would save cookies so that they can be used even if the Java Virtual Machine is restarted. Your implementation would work similar to the following:

> 1. Any cookies that were previously saved are read in.
> 2. During runtime, cookies are stored and retrieved from memory.
> 3. Cookies are written out to persistent storage before exiting.
> The following is an incomplete example of this cookie store. This example shows you how to leverage the Java SE default in-memory cookie store and how you might extend its functionality.

> >     import java.net.*;
> >     import java.util.*;

> >     public class PersistentCookieStore
> >        implements CookieStore, Runnable
> >     {
> >         CookieStore store;

> >         public PersistentCookieStore() {
> >             // get the default in memory cookie store
> >             store = new CookieManager().getCookieStore();

> >             // todo: read in cookies from persistant storage
> >             // and add them store

> >             // add a shutdown hook to write out the in memory cookies
> >             Runtime.getRuntime().addShutdownHook(new Thread(this));
> >         }

> >         public void run() {
> >             // todo: write cookies in store to persistent storage
> >         }

> >         public void	add(URI uri, HttpCookie cookie) {
> >             store.add(uri, cookie);
> >         }

> >         public List<HttpCookie> get(URI uri) {
> >             return store.get(uri);
> >         }

> >         public List<HttpCookie> getCookies() {
> >             return store.getCookies();
> >         }

> >         public List<URI> getURIs() {
> >             return store.getURIs();
> >         }

> >         public boolean remove(URI uri, HttpCookie cookie) {
> >             return store.remove(uri, cookie);
> >         }

> >         public boolean removeAll()  {
> >             return store.removeAll();
> >         }
> >     }

Previous page: Default CookieManager
Next page: End of Trail