1 /**
2 * Copyright 2003-2006 Greg Luck
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17 package net.sf.ehcache.config;
18
19 import net.sf.ehcache.store.MemoryStoreEvictionPolicy;
20
21 import java.util.ArrayList;
22 import java.util.List;
23
24 /**
25 * A class to represent Cache configuration.
26 * e.g.
27 * <cache name="testCache1"
28 * maxElementsInMemory="10000"
29 * eternal="false"
30 * timeToIdleSeconds="3600"
31 * timeToLiveSeconds="10"
32 * overflowToDisk="true"
33 * diskPersistent="true"
34 * diskExpiryThreadIntervalSeconds="120"
35 * />
36 * @author <a href="mailto:gluck@thoughtworks.com">Greg Luck</a>
37 * @version $Id: CacheConfiguration.java 52 2006-04-24 14:50:03Z gregluck $
38 */
39 public final class CacheConfiguration {
40
41 /**
42 * the name of the cache.
43 */
44 protected String name;
45
46 /**
47 * the maximum objects to be held in the {@link net.sf.ehcache.store.MemoryStore}.
48 */
49 protected int maxElementsInMemory;
50
51 /**
52 * The policy used to evict elements from the {@link net.sf.ehcache.store.MemoryStore}.
53 * This can be one of:
54 * <ol>
55 * <li>LRU - least recently used
56 * <li>LFU - Less frequently used
57 * <li>FIFO - first in first out, the oldest element by creation time
58 * </ol>
59 * The default value is LRU
60 *
61 * @since 1.2
62 */
63 protected MemoryStoreEvictionPolicy memoryStoreEvictionPolicy;
64
65
66 /**
67 * Sets whether elements are eternal. If eternal, timeouts are ignored and the element
68 * is never expired.
69 */
70 protected boolean eternal;
71
72 /**
73 * the time to idle for an element before it expires. Is only used
74 * if the element is not eternal.A value of 0 means do not check for idling.
75 */
76 protected int timeToIdleSeconds;
77
78 /**
79 * Sets the time to idle for an element before it expires. Is only used
80 * if the element is not eternal. This attribute is optional in the configuration.
81 * A value of 0 means do not check time to live.
82 */
83 protected int timeToLiveSeconds;
84
85 /**
86 * whether elements can overflow to disk when the in-memory cache
87 * has reached the set limit.
88 */
89 protected boolean overflowToDisk;
90
91 /**
92 * For caches that overflow to disk, whether the disk cache persists between CacheManager instances.
93 */
94 protected boolean diskPersistent;
95
96 /**
97 * The interval in seconds between runs of the disk expiry thread.
98 * <p/>
99 * 2 minutes is the default.
100 * This is not the same thing as time to live or time to idle. When the thread runs it checks
101 * these things. So this value is how often we check for expiry.
102 */
103 protected long diskExpiryThreadIntervalSeconds;
104
105 /**
106 * The event listener factories added by BeanUtils.
107 */
108 protected final List cacheEventListenerConfigurations = new ArrayList();
109
110 /**
111 * Sets the name of the cache. This must be unique.
112 */
113 public final void setName(String name) {
114 this.name = name;
115 }
116
117 /**
118 * Sets the maximum objects to be held in memory.
119 */
120 public final void setMaxElementsInMemory(int maxElementsInMemory) {
121 this.maxElementsInMemory = maxElementsInMemory;
122 }
123
124 /**
125 * Sets the eviction policy. An invalid argument will set it to null.
126 */
127 public final void setMemoryStoreEvictionPolicy(String memoryStoreEvictionPolicy) {
128 this.memoryStoreEvictionPolicy = MemoryStoreEvictionPolicy.fromString(memoryStoreEvictionPolicy);
129 }
130
131 /**
132 * Sets whether elements are eternal. If eternal, timeouts are ignored and the element is never expired.
133 */
134 public final void setEternal(boolean eternal) {
135 this.eternal = eternal;
136 }
137
138 /**
139 * Sets the time to idle for an element before it expires. Is only used if the element is not eternal.
140 */
141 public final void setTimeToIdleSeconds(int timeToIdleSeconds) {
142 this.timeToIdleSeconds = timeToIdleSeconds;
143 }
144
145 /**
146 * Sets the time to idle for an element before it expires. Is only used if the element is not eternal.
147 */
148 public final void setTimeToLiveSeconds(int timeToLiveSeconds) {
149 this.timeToLiveSeconds = timeToLiveSeconds;
150 }
151
152 /**
153 * Sets whether elements can overflow to disk when the in-memory cache has reached the set limit.
154 */
155 public final void setOverflowToDisk(boolean overflowToDisk) {
156 this.overflowToDisk = overflowToDisk;
157 }
158
159 /**
160 * Sets whether, for caches that overflow to disk, the disk cache persist between CacheManager instances.
161 */
162 public final void setDiskPersistent(boolean diskPersistent) {
163 this.diskPersistent = diskPersistent;
164 }
165
166 /**
167 * Sets the interval in seconds between runs of the disk expiry thread.
168 * <p/>
169 * 2 minutes is the default.
170 * This is not the same thing as time to live or time to idle. When the thread runs it checks
171 * these things. So this value is how often we check for expiry.
172 */
173 public final void setDiskExpiryThreadIntervalSeconds(int diskExpiryThreadIntervalSeconds) {
174 this.diskExpiryThreadIntervalSeconds = diskExpiryThreadIntervalSeconds;
175 }
176
177 /**
178 * Configuration for the CachePeerListenerFactoryConfiguration.
179 */
180 public final class CacheEventListenerFactoryConfiguration extends FactoryConfiguration {
181 }
182
183 /**
184 * Used by BeanUtils to add cacheEventListenerFactory elements to the cache configuration.
185 */
186 public final void addCacheEventListenerFactory(CacheEventListenerFactoryConfiguration factory) {
187 cacheEventListenerConfigurations.add(factory);
188 }
189
190 }