01: /*
02: * Licensed to the Apache Software Foundation (ASF) under one or more
03: * contributor license agreements. The ASF licenses this file to You
04: * under the Apache License, Version 2.0 (the "License"); you may not
05: * use this file except in compliance with the License.
06: * You may obtain a copy of the License at
07: *
08: * http://www.apache.org/licenses/LICENSE-2.0
09: *
10: * Unless required by applicable law or agreed to in writing, software
11: * distributed under the License is distributed on an "AS IS" BASIS,
12: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13: * See the License for the specific language governing permissions and
14: * limitations under the License. For additional information regarding
15: * copyright in this work, please see the NOTICE file in the top level
16: * directory of this distribution.
17: */
18:
19: package org.apache.roller.util.cache;
20:
21: import java.io.Serializable;
22:
23: /**
24: * A cache entry that is meant to expire in a lazy fashion.
25: *
26: * The way to use this class is to wrap the object you want to cache in an
27: * instance of this class and store that in your cache. Then when you want
28: * to retrieve this entry you must input a last-expired time which can be
29: * compared against the time this entry was cached to determine if the cached
30: * entry is "fresh". If the object is not fresh then we don't return it.
31: *
32: * This essentially allows us to track when an object is cached and then before
33: * we can retrieve that cached object we must compare it with it's last known
34: * invalidation time to make sure it hasn't expired. This is useful because
35: * instead of actively purging lots of cached objects from the cache at
36: * invalidation time, we can now be lazy and just invalidate them when we
37: * actually try to retrieve the cached object.
38: *
39: * This is useful for Roller because we will no longer have to iterate through
40: * the list of cached objects and inspect the keys to figure out what items to
41: * invalidate. Instead we can just sit back and let the items be invalidated as
42: * we try to use them.
43: */
44: public class LazyExpiringCacheEntry implements Serializable {
45:
46: private Object value = null;
47: private long timeCached = -1;
48:
49: public LazyExpiringCacheEntry(Object item) {
50: this .value = item;
51: this .timeCached = System.currentTimeMillis();
52: }
53:
54: /**
55: * Retrieve the value of this cache entry if it is still "fresh".
56: *
57: * If the value has expired then we return null.
58: */
59: public Object getValue(long lastInvalidated) {
60: if (this .isInvalid(lastInvalidated)) {
61: return null;
62: } else {
63: return this .value;
64: }
65: }
66:
67: /**
68: * Determine if this cache entry has expired.
69: */
70: public boolean isInvalid(long lastInvalidated) {
71:
72: return (this .timeCached < lastInvalidated);
73: }
74:
75: public long getTimeCached() {
76: return timeCached;
77: }
78:
79: }
|