package net.b2bcenter.framework.modules.objectpool;
import java.security.NoSuchAlgorithmException;
import java.util.Date;
import java.util.Map;
import net.b2bcenter.entity15.base.IdEntity;
import net.b2bcenter.framework.modules.utils.EncodeUtils;
import org.apache.log4j.BasicConfigurator;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
public class ObjectPool {
private boolean enable;
private ObjectPoolLogger logger = new ObjectPoolLogger();
public final static int ONE_MINUTE = 60; // 1m
public final static int ONE_HOUR = 60 * 60; // 1h
public final static int ONE_DAY = 60 * 60 * 24; // 1day
public final static int DEFAULT_LIFE = 60 * 60; // 1h
private PoolConfig config = new PoolConfig();
private MemCachedClient mcc = null;
private String[] servers = {"localhost:11211"};
private synchronized MemCachedClient _init() {
return _init(servers);
}
private synchronized static MemCachedClient _init(String[] servers) {
// memcached should be running on port 11211 but NOT on 11212
BasicConfigurator.configure();
SockIOPool pool = SockIOPool.getInstance();
pool.setServers( servers );
pool.setFailover( true );
pool.setInitConn( 10 );
pool.setMinConn( 5 );
pool.setMaxConn( 250 );
pool.setMaxIdle( 1000 * 60 * 60 * 6 );
// set the sleep for the maint thread
// it will wake up every x seconds and
// maintain the pool size
pool.setMaintSleep( 30 );
// Tcp的规则就是在发送一个包之前,本地机器会等待远程主机
// 对上一次发送的包的确认信息到来;这个方法就可以关闭套接字的缓存,
// 以至这个包准备好了就发;
pool.setNagle( false );
//连接建立后对超时的控制
pool.setSocketTO( 3000 );
//连接建立时对超时的控制
pool.setSocketConnectTO( 0 );
pool.setAliveCheck( true );
pool.initialize();
MemCachedClient mcc = new MemCachedClient();
// turn off most memcached client logging:
//Logger.getLogger( MemCachedClient.class.getName() ).setLevel( com.schooner.MemCached.Logger. );
return mcc;
}
public void setLogFile(String logFile) {
this.logger.setLogFile(logFile);
}
public void setEnable(boolean enable) {
this.enable = enable;
}
public boolean isEnable() {
return enable;
}
public void setLogEnable(boolean logEnable) {
this.logger.setEnable(logEnable);
}
public void setServers(String servers) {
this.servers = servers.split(",");
}
public void init() {
mcc = _init();
}
public void init(String[] servers) {
mcc = _init(servers);
}
/**
* @return true if success
*/
public boolean set(IdEntity obj) {
return set(KeyGenerator.getKey(obj), obj);
}
/**
* @return true if success
*/
public boolean set(String key, Object value) {
if (!enable) {
return true;
}
if (mcc == null) {
mcc = _init();
}
// value = convert(value);
return mcc.set(encodeKey(key), value);
}
private boolean _set(String key, Object value) {
if (!enable) {
return true;
}
if (mcc == null) {
mcc = _init();
}
return mcc.set(encodeKey(key), value);
}
/*
* @return true if success
*/
public boolean set(IdEntity obj, int lifeSeconds) {
return set(KeyGenerator.getKey(obj), obj, lifeSeconds);
}
/**
* @param lifeSeconds the data will be discard after the given seconds.
* @return true if success
*/
public boolean set(String key, Object value, int lifeSeconds) {
if (!enable) {
return true;
}
if (mcc == null) {
mcc = _init();
}
// value = convert(value);
return mcc.set(encodeKey(key), value, new Date(lifeSeconds * 1000));
}
public IdEntity get(Class model, Long id) {
return (IdEntity)get(KeyGenerator.getKey(model, id));
}
public IdEntity[] get(Class model, String[] ids) {
String[] keys = new String[ids.length];
for (int i = 0 ; i < ids.length ; i++) {
keys[i] = KeyGenerator.getKey(model, new Long(ids[i]));
}
Object[] values = get(keys);
IdEntity[] ret = new IdEntity[values.length];
for (int i = 0 ; i < values.length ; i++) {
ret[i] = (IdEntity)values[i];
}
return ret;
}
public Object[] get(String[] keys) {
if (!enable) {
return null;
}
if (mcc == null) {
mcc = _init();
}
for (int i = 0 ; i < keys.length ; i++) {
keys[i] = encodeKey(keys[i]);
}
Map<String, Object> values = mcc.getMulti(keys);
Object[] ret = new Object[keys.length];
for (int i = 0 ; i < keys.length ; i++) {
ret[i] = values.get(keys[i]);
if (ret[i] != null) {
// ret[i] = convert(ret[i]);
}
}
return ret;
}
public Object get(String key) {
if (!enable) {
return null;
}
if (mcc == null) {
mcc = _init();
}
Object value = mcc.get(encodeKey(key));
if (value != null) {
// value = convert(value);
logger.writeHitLog(key);
// System.out.println("Object pool hit: " + key);
} else {
logger.writeMissedLog(key);
// System.out.println("Object pool missed: " + key);
}
return value;
}
public void remove(IdEntity obj) {
remove(KeyGenerator.getKey(obj), false);
}
public void remove(IdEntity obj, boolean force) {
remove(KeyGenerator.getKey(obj), force);
}
public void remove(Class model, String id) {
remove(model, id, false);
}
public void remove(Class model, String id, boolean force) {
remove(KeyGenerator.getKey(model, new Long(id)), force);
}
public void remove(String key) {
remove(key, false);
}
public void remove(String key, boolean force) {
if (!enable) {
return;
}
if (mcc == null) {
mcc = _init();
}
String encodedKey = encodeKey(key);
Object o = mcc.get(encodedKey);
if (o != null) {
if (force) {
mcc.delete(encodedKey);
} else {
// 在数据发生改变后,会删掉cache里的值。但这时事务还没提交,数据库里的值还没变,如果有人这时读数据,发现cache里
// 没值就会去数据库读,这样就会产生脏数据。为了避免这种现象,这里延迟1s再删数据以等待事务提交完成,可以降低产生
// 脏数据的可能
mcc.set(encodedKey, o, new Date(1 * 1000));
}
}
}
public boolean isCachable(Class cls) {
if (cls.getName().contains("$$")) {
cls = cls.getSuperclass();
}
return config.isCachable(cls);
}
public int getLife(Class cls) {
return config.getLife(cls);
}
// key maybe include some char invalid for memcache, so we need to encode it
private String encodeKey(String key) {
try {
java.security.MessageDigest md5 = java.security.MessageDigest.getInstance( "MD5" );
md5.update(key.getBytes());
byte tmp[] = md5.digest();
key = EncodeUtils.base64Encode(tmp);
return key;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return key;
}
}
public static void main(String[] args) {
long t1 = new Date().getTime();
ObjectPool pool = new ObjectPool();
pool.setEnable(true);
pool.set("kkk", "OOOO");
Object o = pool.get("kkk");
System.out.println("o:"+o);
// for (int i = 0 ; i < 1000000 ; i++) {
// pool.set(""+i, ""+i);
// }
//
// long t2 = new Date().getTime();
//
// System.out.println("set time:"+(t2-t1));
//
// for (int i = 0 ; i < 1000000 ; i++) {
// pool.get(""+i);
// }
// long t3 = new Date().getTime();
//
// System.out.println("set time:"+(t3-t2));
}
}
java Memcached-1
最新推荐文章于 2024-09-04 15:29:36 发布