public class CacheEntity<T> implements Serializable {

    private static final long serialVersionUID = -4337711009801627866L;

    public static final long CACHE_NEVER_EXPIRE = -1;        //快取永不過期
private long id;
    private String key;
    private HttpHeaders responseHeaders;              //　響應頭
    private 
 
T data;
    private long localExpire;                          // 本地到期

    //該變數不必儲存到資料庫,程式執行起來後會動態計算
private boolean isExpire;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getKey() {
        return key;
    }

    public void 
 
setKey(String key) {
        this.key = key;
    }

    public HttpHeaders getResponseHeaders() {
        return responseHeaders;
    }

    public void setResponseHeaders(HttpHeaders responseHeaders) {
        this.responseHeaders = responseHeaders;
    }

    public T getData() {
        return data
 
;
    }

    public void setData(T data) {
        this.data = data;
    }

    public long getLocalExpire() {
        return localExpire;
    }

    public void setLocalExpire(long localExpire) {
        this.localExpire = localExpire;
    }

    public boolean isExpire() {
        return isExpire;
    }

    public void setExpire(boolean expire) {
        isExpire = expire;
    }

    /**
     * @param cacheTime 允許的快取時間
     * @param baseTime  基準時間,小於當前時間視為過期
     * @return 是否過期
     */
public boolean checkExpire(CacheMode cacheMode, long cacheTime, long baseTime) {
        //304的預設快取模式,設定快取時間無效,需要依靠服務端的響應頭控制
if (cacheMode == CacheMode.DEFAULT) return getLocalExpire() < baseTime;
        if (cacheTime == CACHE_NEVER_EXPIRE) return false;
        return getLocalExpire() + cacheTime < baseTime;
    }

    public static <T> ContentValues getContentValues(CacheEntity<T> cacheEntity) {
        ContentValues values = new ContentValues();
        values.put(CacheHelper.KEY, cacheEntity.getKey());
        values.put(CacheHelper.LOCAL_EXPIRE, cacheEntity.getLocalExpire());

        HttpHeaders headers = cacheEntity.getResponseHeaders();
        ByteArrayOutputStream headerBAOS = null;
        ObjectOutputStream headerOOS = null;
        try {
            if (headers != null) {
                headerBAOS = new ByteArrayOutputStream();
                headerOOS = new ObjectOutputStream(headerBAOS);
                headerOOS.writeObject(headers);
                headerOOS.flush();
                byte[] headerData = headerBAOS.toByteArray();
                values.put(CacheHelper.HEAD, headerData);
            }
        } catch (IOException e) {
            OkLogger.e(e);
        } finally {
            try {
                if (headerOOS != null) headerOOS.close();
                if (headerBAOS != null) headerBAOS.close();
            } catch (IOException e) {
                OkLogger.e(e);
            }
        }

        T data = cacheEntity.getData();
        ByteArrayOutputStream dataBAOS = null;
        ObjectOutputStream dataOOS = null;
        try {
            if (data != null) {
                dataBAOS = new ByteArrayOutputStream();
                dataOOS = new ObjectOutputStream(dataBAOS);
                dataOOS.writeObject(data);
                dataOOS.flush();
                byte[] dataData = dataBAOS.toByteArray();
                values.put(CacheHelper.DATA, dataData);
            }
        } catch (IOException e) {
            OkLogger.e(e);
        } finally {
            try {
                if (dataOOS != null) dataOOS.close();
                if (dataBAOS != null) dataBAOS.close();
            } catch (IOException e) {
                OkLogger.e(e);
            }
        }
        return values;
    }

    public static <T> CacheEntity<T> parseCursorToBean(Cursor cursor) {
        CacheEntity<T> cacheEntity = new CacheEntity<>();
        cacheEntity.setId(cursor.getInt(cursor.getColumnIndex(CacheHelper.ID)));
        cacheEntity.setKey(cursor.getString(cursor.getColumnIndex(CacheHelper.KEY)));
        cacheEntity.setLocalExpire(cursor.getLong(cursor.getColumnIndex(CacheHelper.LOCAL_EXPIRE)));

        byte[] headerData = cursor.getBlob(cursor.getColumnIndex(CacheHelper.HEAD));
        ByteArrayInputStream headerBAIS = null;
        ObjectInputStream headerOIS = null;
        try {
            if (headerData != null) {
                headerBAIS = new ByteArrayInputStream(headerData);
                headerOIS = new ObjectInputStream(headerBAIS);
                Object header = headerOIS.readObject();
                cacheEntity.setResponseHeaders((HttpHeaders) header);
            }
        } catch (Exception e) {
            OkLogger.e(e);
        } finally {
            try {
                if (headerOIS != null) headerOIS.close();
                if (headerBAIS != null) headerBAIS.close();
            } catch (IOException e) {
                OkLogger.e(e);
            }
        }

        byte[] dataData = cursor.getBlob(cursor.getColumnIndex(CacheHelper.DATA));
        ByteArrayInputStream dataBAIS = null;
        ObjectInputStream dataOIS = null;
        try {
            if (dataData != null) {
                dataBAIS = new ByteArrayInputStream(dataData);
                dataOIS = new ObjectInputStream(dataBAIS);
                T data = (T) dataOIS.readObject();
                cacheEntity.setData(data);
            }
        } catch (Exception e) {
            OkLogger.e(e);
        } finally {
            try {
                if (dataOIS != null) dataOIS.close();
                if (dataBAIS != null) dataBAIS.close();
            } catch (IOException e) {
                OkLogger.e(e);
            }
        }

        return cacheEntity;
    }

    @Override
public String toString() {
        return "CacheEntity{" +
                "id=" + id +
                ", key='" + key + '\'' +
                ", responseHeaders=" + responseHeaders +
                ", data=" + data +
                ", localExpire=" + localExpire +
                '}';
    }
}