blob: f006314659b31a794d145abe4bbf986bf86d1e93 (
plain) (
tree)
|
|
package com.btr.proxy.selector.misc;
import java.io.IOException;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.SocketAddress;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
/*****************************************************************************
* Implements a cache that can be used to warp it around an existing ProxySelector.
* You can specify a maximum cache size and a "time to live" for positive resolves.
* @author Bernd Rosstauscher (proxyvole@rosstauscher.de) Copyright 2009
****************************************************************************/
public class BufferedProxySelector extends ProxySelector {
private ProxySelector delegate;
private ConcurrentHashMap<String, CacheEntry> cache;
private int maxSize;
private long ttl;
private static class CacheEntry {
List<Proxy> result;
long expireAt;
public CacheEntry(List<Proxy> r, long expireAt) {
super();
this.result = new ArrayList<Proxy>(r.size());
this.result.addAll(r);
this.result = Collections.unmodifiableList(this.result);
this.expireAt = expireAt;
}
public boolean isExpired() {
return System.nanoTime() >= this.expireAt;
}
}
/*************************************************************************
* Constructor
* @param maxSize the max size for the cache.
* @param ttl the "time to live" for cache entries as amount in milliseconds.
* @param delegate the delegate to use.
************************************************************************/
public BufferedProxySelector(int maxSize, long ttl, ProxySelector delegate) {
super();
this.cache = new ConcurrentHashMap<String, CacheEntry>();
this.maxSize = maxSize;
this.delegate = delegate;
this.ttl = ttl;
}
/*************************************************************************
* connectFailed
* @see java.net.ProxySelector#connectFailed(java.net.URI, java.net.SocketAddress, java.io.IOException)
************************************************************************/
@Override
public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {
this.delegate.connectFailed(uri, sa, ioe);
}
/*************************************************************************
* select
* @see java.net.ProxySelector#select(java.net.URI)
************************************************************************/
@Override
public List<Proxy> select(URI uri) {
//String cacheKey = uri.getHost(); // Caching per host may produce wrong results
String cacheKey = uri.toString();
CacheEntry entry = this.cache.get(cacheKey);
if (entry == null || entry.isExpired()) {
List<Proxy> result = this.delegate.select(uri);
entry = new CacheEntry(result, System.nanoTime()+this.ttl*1000*1000);
synchronized (this.cache) {
if (this.cache.size() >= this.maxSize) {
purgeCache();
}
this.cache.put(cacheKey, entry);
}
}
return entry.result;
}
/*************************************************************************
* Purge cache to get some free space for a new entry.
************************************************************************/
private void purgeCache() {
// Remove all expired entries and find the oldest.
boolean removedOne = false;
Entry<String, CacheEntry> oldest = null;
Set<Entry<String, CacheEntry>> entries = this.cache.entrySet();
for (Iterator<Entry<String, CacheEntry>> it = entries.iterator(); it.hasNext();) {
Entry<String, CacheEntry> entry = it.next();
if (entry.getValue().isExpired()) {
it.remove();
removedOne = true;
} else
if (oldest == null || entry.getValue().expireAt < oldest.getValue().expireAt) {
oldest = entry;
}
}
// Remove oldest if no expired entries were found.
if (!removedOne && oldest != null) {
this.cache.remove(oldest.getKey());
}
}
}
|