Java SockIOPool类代码示例

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
protected MemCachedClient getMemcachedClient() {
  String memcachedAddr = System.getProperty("memcached.addr");
  String[] servers = {memcachedAddr};
  SockIOPool pool = SockIOPool.getInstance(POOL_NAME);
  pool.setServers(servers);
  /*
  pool.setFailover( true );
  pool.setInitConn( 10 );
  pool.setMinConn( 5 );
  pool.setMaxConn( 250 );
  pool.setMaintSleep( 30 );
  pool.setNagle( false );
  pool.setSocketTO( 3000 );
  pool.setAliveCheck( true );
  */
  pool.initialize();
  return new MemCachedClient(POOL_NAME, true, false);
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
protected MemCachedClient getMemcachedClient() {
  String memcachedAddr = System.getProperty("memcached.addr");
  String[] servers = {memcachedAddr};
  SockIOPool pool = SockIOPool.getInstance(POOL_NAME);
  pool.setServers(servers);
  /*
  pool.setFailover( true );
  pool.setInitConn( 10 );
  pool.setMinConn( 5 );
  pool.setMaxConn( 250 );
  pool.setMaintSleep( 30 );
  pool.setNagle( false );
  pool.setSocketTO( 3000 );
  pool.setAliveCheck( true );
  */
  pool.initialize();
  return new MemCachedClient(POOL_NAME, true, true);
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
/**
 * Inits the.
 *
 * @param conf
 *          the conf
 * @return the i cache system
 */
public static ICacheSystem create(String server) {

  MemCache f = new MemCache();

  f.url = server.substring(Cache.MEMCACHED.length());

  SockIOPool pool = SockIOPool.getInstance();
  pool.setServers(new String[] { f.url });
  pool.setFailover(true);
  pool.setInitConn(10);
  pool.setMinConn(5);
  pool.setMaxConn(1000);
  pool.setMaintSleep(30);
  pool.setNagle(false);
  pool.setSocketTO(3000);
  pool.setAliveCheck(true);
  pool.initialize();

  f.memCachedClient = new MemCachedClient();

  return f;
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
private void init() {
	SockIOPool pool = SockIOPool.getInstance(poolName);
	pool.setServers(hostAndPort);
	pool.setWeights(hostWeight);
	pool.setInitConn(initConn);
	pool.setMinConn(minConn);
	pool.setMaxConn(maxConn);
	pool.setMaxIdle(maxIdleTime);
	pool.setMaintSleep(maintSleepTime);
	pool.setNagle(socketNagle);
	pool.setSocketTO(socketReadTimeOut);
	pool.setSocketConnectTO(socketConnectTimeOut);
	
	pool.setHashingAlg(SockIOPool.NATIVE_HASH);
	pool.setFailover(failover);
	pool.setFailback(failback);

	pool.initialize();
	memCachedClient = new MemCachedClient(poolName);
	memCachedClient.setPrimitiveAsString(primitiveAsString);
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
/**
 * 
 */
@Start
public void start() {
    String path = plugin.getConfig(FILE_CONF, "");
    Properties _conf = MemcachedFactory.load(new File(path));
    if (_conf == null) {
        LOG.error("Not found memcached.file {}", path);
        return;
    }

    String pname = _conf.getProperty("mem.name");

    SockIOPool _pool = createPool(_conf);
    _pool.initialize();
    LOG.info("SockIOPool {} initialize successfully!", pname);

    mcc = new MemCachedClient(pname);
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
/**
* Initialize connection
*/
public ContactMemcachedClient() {
 
	SockIOPool pool = SockIOPool.getInstance();
	pool.setServers(servers);
	pool.setWeights( weights );
	if (!pool.isInitialized()) {
		pool.setInitConn(5);
		pool.setMinConn(5);
		pool.setMaxConn(250);
		pool.initialize();
	}
	MemCachedClient memCachedClient = new MemCachedClient();
	this.memcachedClient = memCachedClient;
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
public void initializeSockIOPool(String name) {

            Properties memcacheProp = new Properties();
            InputStream input;
            SockIOPool pool = SockIOPool.getInstance(name);
            input = this.getClass().getClassLoader().getResourceAsStream(PROP_NAME);
            try {
                memcacheProp.load(input);
                input.close();
                pool.setServers(memcacheProp.getProperty("serversList").split(","));
                pool.setFailover(Boolean.parseBoolean(memcacheProp.getProperty("failover")));
                pool.setInitConn(Integer.parseInt(memcacheProp.getProperty("initConn")));
                pool.setMinConn(Integer.parseInt(memcacheProp.getProperty("minConn")));
                pool.setMaxConn(Integer.parseInt(memcacheProp.getProperty("maxConn")));
                pool.setMaintSleep(Long.parseLong(memcacheProp.getProperty("maintSleep")));
                pool.setNagle(Boolean.parseBoolean(memcacheProp.getProperty("nagle")));
                pool.setSocketTO(Integer.parseInt(memcacheProp.getProperty("docketTO")));
                pool.setAliveCheck(Boolean.parseBoolean(memcacheProp.getProperty("aliveCheck")));
            } catch (IOException e) {
                Log.error("could not create load/read memcache properties from file: " + PROP_NAME + ", will try with defaults, error: " + e, e);

                String[] servers = {"localhost:11211"};
                pool.setServers(servers);
                pool.setFailover(true);
                pool.setInitConn(10);
                pool.setMinConn(5);
                pool.setMaxConn(250);
                pool.setMaintSleep(30);
                pool.setNagle(false);
                pool.setSocketTO(3000);
                pool.setAliveCheck(true);
            }

            pool.initialize();
        }
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
@BeforeClass
  public static void setup() throws Exception{

// 设置缓存服务器列表，当使用分布式缓存的时，可以指定多个缓存服务器。这里应该设置为多个不同的服务，我这里将两个服务设置为一样的，大家不要向我学习，呵呵。
      String[] servers =
              {
                      "127.0.0.1:11211"
              };

      // 设置服务器权重
      Integer[] weights = {3};

      // 创建一个Socked连接池实例
      SockIOPool pool = SockIOPool.getInstance();

    // 向连接池设置服务器和权重
      pool.setServers(servers);
      pool.setWeights(weights);

      // set some TCP settings
      // disable nagle
      // set the read timeout to 3 secs
      // and don't set a connect timeout
      pool.setNagle(false);
      pool.setSocketTO(3000);
      pool.setSocketConnectTO(0);

     // initialize the connection pool
      pool.initialize();
  }
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
@Override
public void connect() throws IOException
{
  pool = SockIOPool.getInstance();
  if (serverAddresses.isEmpty()) {
    pool.setServers(new String[]{"localhost:11211"});
  } else {
    pool.setServers(serverAddresses.toArray(new String[] {}));
  }
  pool.initialize();
  memcacheClient = new MemCachedClient();
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
private static SockIOPool createPool(Properties _conf) {
    String pname = _conf.getProperty("mem.name");

    SockIOPool _pool = SockIOPool.getInstance(pname);
    String[] servers = _conf.getProperty("mem.servers").split("[,\\s+]");
    String[] memServers = new String[servers.length];
    Integer[] memWeights = new Integer[servers.length];
    for (int i = 0; i < servers.length; i++) {
        memServers[i] = _conf.getProperty("mem.server." + servers[i].trim() + ".host", "127.0.0.1") + ":"
                + _conf.getProperty("mem.server." + servers[i].trim() + ".port", "11211");
        memWeights[i] = Integer.parseInt(_conf.getProperty("mem." + servers[i] + ".weight", "1"));

        LOG.info("memcached -> {}", memServers[i]);
    }
    _pool.setServers(memServers);
    _pool.setWeights(memWeights);

    _pool.setInitConn(Integer.parseInt(_conf.getProperty("mem.initconn", "10")));
    _pool.setMinConn(Integer.parseInt(_conf.getProperty("mem.minconn", "5")));
    _pool.setMaxConn(Integer.parseInt(_conf.getProperty("mem.maxconn", "250")));
    _pool.setMaxIdle(Integer.parseInt(_conf.getProperty("mem.maxidle", "3600000")));

    _pool.setMaintSleep(30);
    _pool.setNagle(false);
    _pool.setSocketTO(Integer.parseInt(_conf.getProperty("mem.timeout.read", "3000")));
    _pool.setSocketConnectTO(Integer.parseInt(_conf.getProperty("mem.timeout.conn", "3000")));
    return _pool;
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
private MemCachedClient initMemCachedClient(String[] servers, int maxConn, boolean sanitizeKeys) {
	// logger.info("maxConn:" + maxConn + " sanitizeKeys:" + sanitizeKeys + " servers" + StringUtils.join(servers));
	Integer[] weights = new Integer[servers.length];
	for (int i = 0; i < weights.length; i++) {
		weights[i] = 3;
	}
	// { 3 };
	// grab an instance of our connection pool
	// String server = StringUtils.join(servers);
	// int hasCode = server.hashCode();
	String poolName = "pool" + servers.hashCode();
	// logger.info("init poolName:" + poolName + " server:" + server);
	SockIOPool pool = SockIOPool.getInstance(poolName);

	MemCachedClient mcc = new MemCachedClient(poolName);

	// mcc.setErrorHandler(new ErrorHandlerImpl());
	// set the servers and the weights
	pool.setServers(servers);
	pool.setWeights(weights);

	// set some basic pool settings
	// 5 initial, 5 min, and 250 max conns
	// and set the max idle time for a conn
	// to 6 hours
	pool.setInitConn(5);
	pool.setMinConn(5);
	pool.setMaxConn(maxConn);
	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 * 1000);

	// set some TCP settings
	// disable nagle
	// set the read timeout to 3 secs
	pool.setNagle(false);
	pool.setSocketTO(3000);
	pool.setSocketConnectTO(0);

	// initialize the connection pool
	pool.initialize();

	mcc.setSanitizeKeys(sanitizeKeys);// 不要对key进行url编码
	// logger.info("connected poolName:" + poolName + " server:" + server + " maxConn:" + maxConn);
	// lets set some compression on for the client
	// compress anything larger than 64k
	// mcc.setCompressEnable(true);
	// mcc.setCompressThreshold(64 * 1024);
	return mcc;
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
public void cleanup() {
    SockIOPool.getInstance().shutDown();
    memCachedClient = null;

}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
public SockIOPool getPool() {
    return _pool;
}
 

import com.whalin.MemCached.SockIOPool; //导入依赖的package包/类
public void setPool(SockIOPool pool) {
    this._pool = pool;
}