【Java开源代码栏目提醒】:以下是网学会员为您推荐的Java开源代码-MemoryCacheLevel.java,希望本篇文章对您学习有所帮助。
/*
* Copyright 2004 Clinton Begin
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing per
missions and
* limitations under the License.
*/
package com.ibatis.sqlmap.engine.cache.memory;
import com.ibatis.
sqlmap.client.SqlMapException;
import java.util.HashMap;
import java.util.Map;
/**
* An enumeration for the values for the memory cache levels
*/
public final class MemoryCacheLevel {
private static Map cacheLevelMap = new HashMap();
/**
* Constant for weak caching
* This cache model is probably the best choice in most cases. It will increase
* performance for popular results, but it will absolutely release the memory to
* be used in allocating other objects, assuming that the results are not currently
* in use.
*/
public final static MemoryCacheLevel WEAK;
/**
* Constant for soft caching.
* This cache model will reduce the likelihood of running out of memory in case the
* results are not currently in use and the memory is needed for other objects.
* However, this is not the most aggressive cache-model in that regard. Hence,
* memory still might be allocated and unavailable for more important objects.
*/
public final static MemoryCacheLevel SOFT;
/**
* Constant for strong caching.
* This cache model will guarantee that the results stay in memory until the cache
* is explicitly flushed. This is ideal for results that are:
* <ol>
* <li>very small</li>
* <li>absolutely static</li>
* <li>used very often</li>
* </ol>
* The advantage is that performance will be very good for this particular query.
* The disadvantage is that if the memory used by these results is needed, then it
* will not be released to make room for other objects (possibly more important
* objects).
*/
public final static MemoryCacheLevel STRONG;
private String referenceType;
static {
WEAK = new MemoryCacheLevel("WEAK");
SOFT = new MemoryCacheLevel("SOFT");
STRONG = new MemoryCacheLevel("STRONG");
cacheLevelMap.put(WEAK.referenceType, WEAK);
cacheLevelMap.put(SOFT.referenceType, SOFT);
cacheLevelMap.put(STRONG.referenceType, STRONG);
}
/**
* Creates a new instance of CacheLevel
*/
private MemoryCacheLevel(String type) {
this.referenceType = type;
}
/**
* Getter for the reference type
*
* @return the type of reference type used
*/
public String getReferenceType() {
return this.referenceType;
}
/**
* Gets a MemoryCacheLevel by name
*
* @param refType the name of the reference type
* @return the MemoryCacheLevel that the name indicates
*/
public static MemoryCacheLevel getByReferenceType(String refType) {
MemoryCacheLevel cacheLevel = (MemoryCacheLevel) cacheLevelMap.get(refType);
if (cacheLevel == null) {
throw new SqlMapException("Error getting CacheLevel (reference type) for name: '" + refType + "'.");
}
return cacheLevel;
}
}