A simple cache for http cookies

CookiesCache.java

package com.mobihabi.xxx.yyy

import javax.ws.rs.core.NewCookie;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * Created by Max Malakhov on 9/26/14.
 */
public class CookiesCache
{
    public static int TTL = 600000; // 10 min

    private final ConcurrentMap<Integer, MyCookies> cache = new MyCache();

    private static volatile CookiesCache _instance;

    public static CookiesCache getCache() {
        if(_instance == null) {
            synchronized (CookiesCache.class) {
                if(_instance == null) {
                    _instance = new CookiesCache();
                }
            }
        } else {
            _instance.cleanup();
        }
        return _instance;
    }

    public MyCookies put(Integer key, List<NewCookie> cookies) {
        return cache.put(key, new MyCookies(cookies));
    }

    public List<NewCookie> get(Integer key) {
        return cache.get(key);
    }

    public static int buildKey(String sessionId, String name, String password) {
        int result = (sessionId != null ? sessionId.hashCode() : 0);
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (password != null ? password.hashCode() : 0);
        return result;
    }

    public void cleanup() {
        for(Iterator<ConcurrentMap.Entry<Integer, MyCookies>> it = cache.entrySet().iterator(); it.hasNext(); ) {
            MyCookies cookies = it.next().getValue();
            // remove only expired cookies
            if(cookies.expired()) {
                it.remove();
            }
        }
    }

    public void clearAll() {
        cache.clear();
    }

    public int size() {
        return cache.size();
    }

    /////////////////////////////////////////////////////////////////////
    public class MyCache extends ConcurrentHashMap<Integer, MyCookies> {
        @Override
        public MyCookies get(Object key) {
            MyCookies cookies = super.get(key);
            if (cookies == null || cookies.expired()) {
                cookies = new MyCookies();
            }
            return cookies;
        }

        @Override
        public MyCookies put(Integer key, MyCookies newCookies) {
            MyCookies cookies = this.get(key);
            if (newCookies !=null && newCookies.size() > 0 &&
                cookies !=null && cookies.invalidate(newCookies)) {

                return super.put(key, newCookies);
            }
            return cookies;
        }
    }

    /////////////////////////////////////////////////////////////////
    public class MyCookies extends ArrayList<NewCookie> {
        private long creation = System.currentTimeMillis();

        public MyCookies() {
        }

        public MyCookies(List<NewCookie> cookies) {
            if(cookies != null && cookies.size() > 0) {
                this.addAll(cookies);
            }
        }

        public boolean expired() {
            return System.currentTimeMillis() - creation > TTL;
        }

        public boolean invalidate(MyCookies newCookies) {
            return size() == 0 || (newCookies != null && newCookies.hashCode() != hashCode());
        }

        @Override
        public int hashCode() {
            int hashCode = 1;
            Iterator<NewCookie> i = iterator();
            while (i.hasNext()) {
                NewCookie obj = i.next();
                hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
            }
            return hashCode;
        }
    }
}