默认情况下,java并不完成缓存。要安装URL类使用的系统级缓存,需要由:
ResponseCache的一个具体子类。
CacheRequest的一个具体子类。
CacheResponse的一个具体子类。
要安装你的ResponseCache子类来处理你的CacheRequest子类和CacheResponse子类,需要把它传递到静态放ResponseCache.setDefault()。这会把这个缓存对象安装为系统的默认缓存。Java虚拟机只支持一个共享缓存。
一旦安装了缓存,只要系统尝试加载一个新的URL,它手下会在缓存中查找。如果缓存返回了所要的内容,URLConnecton就不需要与远程服务器连接。不过,如果所请求的数据不在缓存中,协议处理器将从远程服务器下载相应数据。完成之后,它会把这个响应放在缓存中,使得下一次加载这个URL时,可以很快从缓存中得到这个内容。
ResponseCache提供了两个抽象方法,可以存储和获取系统缓存中的数据:
public abtract CacheResponse get(URI uri, String requestMethod, Map<String,List<String>> requestHeaders ) throws IOException
public abtract CacheResponse put(URI uri, URLConnection connection) throws IOException
put()方法返回一个CacheResponse 对象,它包装了一个OutputStream,URL将把读取的可缓存数据写入这个输入流。
public static ResponseCache getDefault()
public static void setDefault(ResponseCache responseCache )
这些方法会在设置同一个java虚拟机中运行的所有程序所使用的缓存。例如,在下面这行代码中会在应用中安装:
ResponseCache.getDefault(new MyResponseCache):
一旦安装了类似示例的缓存,HTTP URLConnection就会一直使用这个缓存。
ResponseCache的一个具体子类。
CacheRequest的一个具体子类。
CacheResponse的一个具体子类。
要安装你的ResponseCache子类来处理你的CacheRequest子类和CacheResponse子类,需要把它传递到静态放ResponseCache.setDefault()。这会把这个缓存对象安装为系统的默认缓存。Java虚拟机只支持一个共享缓存。
一旦安装了缓存,只要系统尝试加载一个新的URL,它手下会在缓存中查找。如果缓存返回了所要的内容,URLConnecton就不需要与远程服务器连接。不过,如果所请求的数据不在缓存中,协议处理器将从远程服务器下载相应数据。完成之后,它会把这个响应放在缓存中,使得下一次加载这个URL时,可以很快从缓存中得到这个内容。
ResponseCache提供了两个抽象方法,可以存储和获取系统缓存中的数据:
public abtract CacheResponse get(URI uri, String requestMethod, Map<String,List<String>> requestHeaders ) throws IOException
public abtract CacheResponse put(URI uri, URLConnection connection) throws IOException
put()方法返回一个CacheResponse 对象,它包装了一个OutputStream,URL将把读取的可缓存数据写入这个输入流。
get()方法从缓存中获取数据和首部,包装在CacheResponse对象中返回
package cache;
import java.util.Date;
import java.util.Locale;
//缓存参数类
public class CacheControl {
private Date maxAge = null; //从现在知道缓存项过期前的秒数
private Date sMaxAge = null; //从现在起,直到缓存项在共享缓存中过期之前的秒数
private boolean mustRevalidate = false; //
private boolean noCache = false; //这个策略的作用与名字不太一致。缓存 项任然可以缓存,不过客户端在每次访问时要用一个Etag或者Last-modified首部重新验证响应的状态
private boolean noStore = false;//不管怎么样都不缓存
private boolean proxyRevalidate = false;
private boolean publicCache = false; //可以缓存一个经过认证的响应
private boolean privateCache = false;//仅单个用户缓存可以保存响应
public CacheControl(String s){
if(s == null || !s.contains(":")){
return;
}
String value = s.split(":")[1].trim();
String[] components = value.split(",");
Date now = new Date();
for(String component : components){
try{
component = component.trim().toLowerCase(Locale.US);
if(component.startsWith("max-age=")){
int secondsInTheFuture = Integer.parseInt(component.substring(8));
maxAge = new Date(now.getTime() + 1000 * secondsInTheFuture);
}else if(component.startsWith("s-maxage=")){
int secondsInTheFuture = Integer.parseInt(component.substring(8));
maxAge = new Date(now.getTime() + 1000 * secondsInTheFuture);
}else if(component.equals("must-revalidate")){
mustRevalidate = true;
}else if(component.equals("proxy-revalidate")){
proxyRevalidate = true;
}else if(component.equals("no-cache")){
noCache = true;
}else if(component.equals("public")){
publicCache = true;
}else if(component.equals("private")){
privateCache = true;
}
}catch(RuntimeException ex){
continue;
}
}
}
public Date getMaxAge() {
return maxAge;
}
public Date getsMaxAge() {
return sMaxAge;
}
public boolean isMustRevalidate() {
return mustRevalidate;
}
public boolean isNoCache() {
return noCache;
}
public boolean isNoStore() {
return noStore;
}
public boolean isProxyRevalidate() {
return proxyRevalidate;
}
public boolean isPublicCache() {
return publicCache;
}
public boolean isPrivateCache() {
return privateCache;
}
}
package cache;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.CacheRequest;
public class MyCacheRequest extends CacheRequest{
private ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
//返回从协议处理器获得的输出流
@Override
public OutputStream getBody() throws IOException {
return outputStream;
}
//当协议处理器把从服务器读取的数据复制到OutputStream时发生意外中断,协议处理器就调用该方法删除缓存中这个请求的所有数据
@Override
public void abort() {
outputStream.reset();
}
//返回请求的数据
public byte[] getData(){
if(outputStream.size() == 0){
return null;
}else{
return outputStream.toByteArray();
}
}
}
package cache;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.CacheResponse;
import java.net.URLConnection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java7_URLConnection.CacheControl;
public class MyCacheResponse extends CacheResponse{
private MyCacheRequest myCacheRequest = null;//请求的数据
private Map<String,List<String>> headers = null;//请求的数据的首部信息
private CacheControl control;//请求的数据的缓存策略
private Date expires;//请求的数据的过期时间
public MyCacheResponse(MyCacheRequest myCacheRequest, URLConnection conn,
Map<String,List<String>> headers,CacheControl control){
this.headers = headers;//获取所有首部信息的键值对形式
this.myCacheRequest = myCacheRequest;
this.control = control;
this.expires = new Date(conn.getExpiration());
}
@Override
public Map<String, List<String>> getHeaders() throws IOException {
return headers;
}
@Override
public InputStream getBody() throws IOException {
return new ByteArrayInputStream(myCacheRequest.getData());
}
//返回缓存的数据协议信息
public CacheControl getControl() {
return control;
}
//缓存是否过期
public boolean isExpires(){
Date now = new Date();
if(control.getMaxAge().before(now)){
return true;
}else if(expires != null && control.getMaxAge() != null){
return expires.before(now);
}else{
return false;
}
}
}
package cache;
import java.io.IOException;
import java.net.CacheRequest;
import java.net.CacheResponse;
import java.net.ResponseCache;
import java.net.URI;
import java.net.URLConnection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java7_URLConnection.CacheControl;
public class MyResponseCache extends ResponseCache{
//维护一个Map用以缓存所有的URI请求
private Map<URI,MyCacheResponse> responses = new ConcurrentHashMap<URI, MyCacheResponse>();
private int maxEntries;
public MyResponseCache(){
this(100);
}
public MyResponseCache(int maxEntries){
this.maxEntries = maxEntries;
}
@Override
public CacheResponse get(URI uri, String rqstMethod,
Map<String, List<String>> rqstHeaders) throws IOException {
if("GET".equals(rqstMethod)){
MyCacheResponse responseCache = responses.get(uri);
//检查过期时间
if(responseCache != null && responseCache.isExpires()){
responses.remove(uri);
responseCache = null;
}
return responseCache;
}else{
return null;
}
}
@Override
public CacheRequest put(URI uri, URLConnection conn) throws IOException {
CacheControl control = new CacheControl(conn.getHeaderField("Cache-Control"));
//如果需要缓存的uri超过100则不允许缓存
if(responses.size() >= maxEntries){
return null;
}
//判断是否需要缓存
if(control.isNoStore()){
return null;
}else if(!conn.getHeaderField(0).startsWith("GET")){//只缓存get请求
return null;
}
//从服务器中读取需要缓存的信息
MyCacheRequest cacheRequest = new MyCacheRequest();
//将信息保存到MyCacheResponse中,请求的数据,请求头,缓存策略
MyCacheResponse cacheResponse = new MyCacheResponse(cacheRequest, conn,
Collections.unmodifiableMap(conn.getHeaderFields()), control);
//缓存该信息
responses.put(uri, cacheResponse);
return cacheRequest;
}
}
public static ResponseCache getDefault()
public static void setDefault(ResponseCache responseCache )
这些方法会在设置同一个java虚拟机中运行的所有程序所使用的缓存。例如,在下面这行代码中会在应用中安装:
ResponseCache.getDefault(new MyResponseCache):
一旦安装了类似示例的缓存,HTTP URLConnection就会一直使用这个缓存。