常用客户端一：memcached java client

1
2
3
4
5
<dependency>
    <groupId>com.whalin</groupId>
    <artifactId>Memcached-Java-Client</artifactId>
    <version>3.0.2</version>
</dependency>

客户端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class MemcachedJavaClientTest {
    
    public static void main(String[] args) {
    	
        SockIOPool pool = SockIOPool.getInstance("memcachedPool");
        
        pool.setServers(new String[]{"192.168.1.102:11211", "192.168.1.103:11211"});
        
        pool.setInitConn(20);
        
        pool.setMinConn(10);
        
        pool.setMaxConn(50);
        
        pool.setMaintSleep(5000);
        
        pool.setNagle(false);
        
        pool.setAliveCheck(false);
        
        pool.setSocketTO(3000);
        
        pool.setSocketConnectTO(5000);
        
        pool.initialize();
        
        MemCachedClient client = new MemCachedClient("memcachedPool");
        
        client.set("client_message", "Memcached Java Client");
        
        Object obj = client.get("client_message");
        
        System.out.println(obj);
        
    }
    
}

与 spring 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<context:property-placeholder location="classpath:memcached.properties" />
<bean class="com.whalin.MemCached.SockIOPool" factory-method="getInstance" 
    init-method="initialize" destroy-method="shutDown" lazy-init="false">
    <constructor-arg value="memcachedPool" />
    <property name="servers">
        <list>
            <value>${memcached.servers}</value>
        </list>
    </property>
    <property name="initConn">
        <value>${memcached.initConn}</value>
    </property>
    <property name="minConn">
        <value>${memcached.minConn}</value>
    </property>
    <property name="maxConn">
        <value>${memcached.maxConn}</value>
    </property>
    <property name="maintSleep">
        <value>${memcached.maintSleep}</value>
    </property>
    <property name="nagle">
        <value>${memcached.nagle}</value>
    </property>
    <property name="aliveCheck">
        <value>${memcached.aliveCheck}</value>
    </property>
    <property name="socketTO">
        <value>${memcached.socketTO}</value>
    </property>
    <property name="socketConnectTO">
        <value>${memcached.socketConnectTO}</value>
    </property>
</bean>
<bean class="com.whalin.MemCached.MemCachedClient">
    <constructor-arg value="memcachedPool" />
</bean>

memcached.properties 配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 服务器地址
memcached.servers = 192.168.1.102:11211,192.168.1.103:11211
# 初始化连接的数目
memcached.initConn = 20
# 最小的连接数
memcached.minConn = 10
# 最大的连接数
memcached.maxConn = 50
# 自查线程周期休眠时间
memcached.maintSleep = 5000
# 关闭 Nagle 算法
memcached.nagle = false
# 不检查连接是否有效
memcached.aliveCheck = false
# Socket 阻塞读取数据的超时时间
memcached.socketTO = 3000
# Socket 阻塞读取数据的超时时间
memcached.socketConnectTO = 5000

客户端测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@ContextConfiguration("/beans.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class MemcachedJavaClientTest extends AbstractJUnit4SpringContextTests {
    
    @Test
    public void testSet() {
        MemCachedClient client = applicationContext.getBean(MemCachedClient.class);
        client.set("client_message", "Memcached Java Client");
    }
    
    @Test
    public void testGet() {
        MemCachedClient client = applicationContext.getBean(MemCachedClient.class);
        Object obj = client.get("client_message");
        System.out.println(obj);
    }
    
}

常用客户端二：spymemcached

1
2
3
4
5
<dependency>
    <groupId>net.spy</groupId>
    <artifactId>spymemcached</artifactId>
    <version>2.11.6</version>
</dependency>

客户端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class SpyMemcachedJavaClientTest {
    public static void main(String[] args) throws Throwable {
        ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
        builder.setDaemon(true);
        builder.setFailureMode(FailureMode.Redistribute);
        builder.setHashAlg(DefaultHashAlgorithm.KETAMA_HASH);
        builder.setLocatorType(Locator.CONSISTENT);
        builder.setUseNagleAlgorithm(false);
        builder.setOpTimeout(3000);
        builder.setProtocol(Protocol.BINARY);
        builder.setTranscoder(new SerializingTranscoder());
        String servers = "192.168.1.102:11211,192.168.1.103:11211";
        MemcachedClient client = new MemcachedClient(builder.build(), AddrUtil.getAddresses(servers));
        client.set("client_message", 0, "spymemcached");
        Object obj = client.get("client_message");
        System.out.println(obj);
    }
}

与 spring 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<context:property-placeholder location="classpath:spymemcached.properties" />
<bean class="net.spy.memcached.spring.MemcachedClientFactoryBean">
    <property name="servers">
        <value>${memcached.servers}</value>
    </property>
    <property name="daemon">
        <value>${memcached.daemon}</value>
    </property>
    <property name="failureMode">
        <value>${memcached.failureMode}</value>
    </property>
    <property name="hashAlg">
        <value type="net.spy.memcached.DefaultHashAlgorithm">${memcached.hashAlg}</value>
    </property>
    <property name="locatorType">
        <value>${memcached.locatorType}</value>
    </property>
    <property name="useNagleAlgorithm">
        <value>${memcached.useNagleAlgorithm}</value>
    </property>
    <property name="protocol">
        <value>${memcached.protocol}</value>
    </property>
    <property name="opTimeout">
        <value>${memcached.opTimeout}</value>
    </property>
    <property name="transcoder">
        <bean class="net.spy.memcached.transcoders.SerializingTranscoder" />
    </property>
</bean>

spymemcached.properties 配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 服务器地址
memcached.servers = 192.168.1.102:11211,192.168.1.103:11211
# 设置 IO 线程的守护进程
memcached.daemon = true
# 发生故障重新分配连接
memcached.failureMode = Redistribute
# 一致性哈希算法
memcached.hashAlg = KETAMA_HASH
# 定位器类型
memcached.locatorType = CONSISTENT
# 关闭 Nagle 算法
memcached.useNagleAlgorithm = false
# 使用二进制协议
memcached.protocol = BINARY
# 操作超时时间
memcached.opTimeout = 3000

客户端测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@ContextConfiguration("/beans.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class SpyMemcachedJavaClientTest extends AbstractJUnit4SpringContextTests {
    
    @Test
    public void testSet() {
        MemcachedClient client = applicationContext.getBean(MemcachedClient.class);
        client.set("client_message", 0, "spymemcached");
    }
    
    @Test
    public void testGet() {
    	MemcachedClient client = applicationContext.getBean(MemcachedClient.class);
        Object obj = client.get("client_message");
        System.out.println(obj);
    }
    
}

常用客户端三：xmemcached

1
2
3
4
5
<dependency>
    <groupId>com.googlecode.xmemcached</groupId>
    <artifactId>xmemcached</artifactId>
    <version>2.0.0</version>
</dependency>

客户端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class XMemcachedJavaClientTest {
    public static void main(String[] args) throws Throwable {
        List<InetSocketAddress> list = AddrUtil.getAddresses("192.168.1.102:11211 192.168.1.103:11211");
        
        XMemcachedClientBuilder builder = new XMemcachedClientBuilder(list, new int[] { 1, 1 });
        
        builder.setConnectionPoolSize(1);
        
        builder.setFailureMode(true);
        
        builder.setOpTimeout(3000);
        
        builder.setConnectTimeout(5000);
        
        builder.setCommandFactory(new TextCommandFactory());
        
        builder.setSessionLocator(new KetamaMemcachedSessionLocator());
        
        builder.setTranscoder(new SerializingTranscoder());
        
        MemcachedClient client = builder.build();
        client.set("client_message", 0, "xmemcached");
        Object obj = client.get("client_message");
        System.out.println(obj);
    }
}

与 spring 集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<context:property-placeholder location="classpath:xmemcached.properties" />
<bean class="net.rubyeye.xmemcached.utils.XMemcachedClientFactoryBean">
    <property name="servers">
        <value>${memcached.servers}</value>
    </property>
    <property name="weights">
        <list>
            <value>${memcached.server1}</value>
            <value>${memcached.server2}</value>
        </list>
    </property>
    <property name="failureMode">
        <value>${memcached.failureMode}</value>
    </property>
    <property name="opTimeout">
        <value>${memcached.opTimeout}</value>
    </property>
    <property name="connectTimeout">
        <value>${memcached.connectTimeout}</value>
    </property>
    <property name="connectionPoolSize">
        <value>${memcached.connectionPoolSize}</value>
    </property>
    <property name="commandFactory">
        <bean class="net.rubyeye.xmemcached.command.TextCommandFactory" />
    </property>
    <property name="sessionLocator">
        <bean class="net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator" />
    </property>
    <property name="transcoder">
        <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder" />
    </property>
</bean>

xmemcached.properties 配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 服务器地址
memcached.servers = 192.168.1.102:11211 192.168.1.103:11211
# 权重设置
memcached.server1 = 1
# 权重设置
memcached.server2 = 1
# 连接池大小
memcached.connectionPoolSize = 1
# 宕机警报
memcached.failureMode = true
# 连接超时
memcached.connectTimeout = 5000
# 等待超时
memcached.opTimeout = 3000

客户端测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@ContextConfiguration("/beans.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class XMemcachedJavaClientTest extends AbstractJUnit4SpringContextTests {
    
    @Test
    public void testSet() throws Throwable {
        MemcachedClient client = applicationContext.getBean(MemcachedClient.class);
        client.set("client_message", 0, "xmemcached");
    }
    
    @Test
    public void testGet() throws Throwable {
        MemcachedClient client = applicationContext.getBean(MemcachedClient.class);
        Object obj = client.get("client_message");
        System.out.println(obj);
    }
    
}