SpringBoot（十四）：SpringBoot整合Memcached

矫情吗；* 2022-05-23 08:40 164阅读 0赞

#### 一、环境准备 ####

*  memcached 1.4.5
 *  SpringBoot 1.5.10.RELEASE
 *  java\_memcached-release\_2.6.6.jar

memcached 1.4.5 windows 下载地址：[http://www.runoob.com/memcached/window-install-memcached.html][http_www.runoob.com_memcached_window-install-memcached.html]

danga memcached java client 下载地址：[https://github.com/gwhalin/Memcached-Java-Client/downloads][https_github.com_gwhalin_Memcached-Java-Client_downloads]

pom依赖：

<dependency>
                <groupId>commons-pool</groupId>
                <artifactId>commons-pool</artifactId>
                <version>1.5.6</version>
            </dependency>
    
            <dependency>
                <groupId>com.danga</groupId>
                <artifactId>java_memcached-release</artifactId>
                <version>2.6.6</version>
                <scope>system</scope>
                <systemPath>${project.basedir}/src/main/webapp/WEB-INF/lib/java_memcached-release_2.6.6.jar</systemPath>
            </dependency>

#### 二、项目结构 ####

![这里写图片描述][70]

#### 三、代码详情 ####

application.yml

## Memcache 配置 ##
    memcache:
      servers: 127.0.0.1:11211
      failover: true
      initConn: 100
      minConn: 20
      maxConn: 1000
      maintSleep: 50
      nagel: false
      socketTO: 3000
      aliveCheck: true

MemcacheConfiguration.java

package cn.saytime.config;
    
    import com.danga.MemCached.MemCachedClient;
    import com.danga.MemCached.SockIOPool;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author zh * @ClassName cn.saytime.config.config.MemcacheConfiguration * @Description Memcache配置 */
    @Configuration
    public class MemcacheConfiguration { 
    
        @Value("${memcache.servers}")
        private String[] servers;
        @Value("${memcache.failover}")
        private boolean failover;
        @Value("${memcache.initConn}")
        private int initConn;
        @Value("${memcache.minConn}")
        private int minConn;
        @Value("${memcache.maxConn}")
        private int maxConn;
        @Value("${memcache.maintSleep}")
        private int maintSleep;
        @Value("${memcache.nagel}")
        private boolean nagel;
        @Value("${memcache.socketTO}")
        private int socketTO;
        @Value("${memcache.aliveCheck}")
        private boolean aliveCheck;
    
        @Bean
        public SockIOPool sockIOPool () {
            SockIOPool pool = SockIOPool.getInstance();
            pool.setServers(servers);
            pool.setFailover(failover);
            pool.setInitConn(initConn);
            pool.setMinConn(minConn);
            pool.setMaxConn(maxConn);
            pool.setMaintSleep(maintSleep);
            pool.setNagle(nagel);
            pool.setSocketTO(socketTO);
            pool.setAliveCheck(aliveCheck);
            pool.initialize();
            return pool;
        }
    
        @Bean
        public MemCachedClient memCachedClient(){
            return new MemCachedClient();
        }
    
    }

测试类 SpringbootMemcacheApplicationTests.java

package cn.saytime;
    
    import com.danga.MemCached.MemCachedClient;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.Date;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootMemcacheApplicationTests {
    
        @Autowired
        private MemCachedClient memCachedClient;
    
        @Test
        public void contextLoads() throws InterruptedException {
            // 放入缓存
            boolean flag = memCachedClient.set("a", 1);
    
            // 取出缓存
            Object a = memCachedClient.get("a");
            System.out.println(a);
    
    
            // 3s后过期
            memCachedClient.set("b", "2", new Date(3000));
            Object b = memCachedClient.get("b");
            System.out.println(b);
    
            Thread.sleep(3000);
            b = memCachedClient.get("b");
            System.out.println(b);
    
        }
    
    }

先运行memcached，然后执行test，输出结果为：

1
    2
    null

> 测试memcached存取以及失效时间成功。

#### 四、部分操作方法 ####

1.  set与add在key不存在时效果一致，add在key存在时不会成功。
2.  set与replace在key存在时效果一致，replace在key不存在不会成功。

#### 五、注意点 ####

使用danga memcached设置失效时间有两种方式：

1.  第一种

memCachedClient.set("xx", "xx", new Date(3000));

1.  第二种

memCachedClient.set("xx", "xx", new Date(System.currentTimeMillis() + 3 * 1000));

> 对比两种形式，第一种是指定key在3s后过期，第二种是指定key在xxxx-xx-xx xx:xx:xx 时间点失效，如果服务器时间跟客户端时间不一致，就会跟想要的结果不一样，比如客户端现在时间点为2018-01-01 00:00:00，服务端时间为2018-01-01 00:00:10，服务端时间快10s，那么如果客户端使用第二种方式设置30s后失效，也就是2018-01-01 00:00:30失效，实际上客户端想要的是30s后失效，而服务端20s就将key失效了。

从上可以发现，最好是使用第一种形式，但是第一种形式在某些时间也会存在问题，比如如果设定的时间小于1s，会发现key会永久保存，不会在指定时间失效，原因可以通过源码得到。

我们使用的MemCachedClient，在configuration里面是直接new的，也就是

new MemCachedClient();

查看MemCachedClient的set带时间方法，可以看到：

public boolean set(String var1, Object var2, Date var3) {
            return this.client.set(var1, var2, var3);
        }

而这个client是在构造方法实例化的，也就是

public MemCachedClient() {
            this((String)null, true, false);
        }
    
        public MemCachedClient(String var1, boolean var2, boolean var3) {
            this.BLAND_DATA_SIZE = " ".getBytes();
            if(var3) {
                this.client = new BinaryClient(var1);
            } else {
                this.client = (MemCachedClient)(var2?new AscIIClient(var1):new AscIIUDPClient(var1));
            }
    
        }

可以看到实际上执行类是AscIIClient，接下来我们查看AscIIClient的带失效时间的set方法

public boolean set(String var1, Object var2, Date var3) {
            return this.set("set", var1, var2, var3, (Integer)null, Long.valueOf(0L), this.primitiveAsString);
        }
    
        private boolean set(String var1, String var2, Object var3, Date var4, Integer var5, Long var6, boolean var7) {
    
            // xxx
    
            // 这里的var4就是传入的失效时间
            String var10 = var1 + " " + var2 + " " + var9 + " " + var4.getTime() / 1000L + " ";
    
            // xxx
        }

可以看到这里有执行

var4.getTime() / 1000L

> 也就是在var.getTime()小于1的时候，得到的结果是0，而0表示永久有效。

我们来测试一下，在代码中加入以下代码

memCachedClient.set("c", "3", new Date(500));
            Object c = memCachedClient.get("c");
            System.out.println(c);
    
            Thread.sleep(1000);
            c = memCachedClient.get("c");
            System.out.println(c);

设置时间为0.5s，然后立马取出结果，然后等待1s之后，再次取出结果.

通过上面的说明，结果可想而知。

3
    3

> 说明当时间小于1s的时候，使用第一种方式会造成指定时间不生效，key永久存在，这种时间如果客户端服务端时间没有误差的时候，使用第二种形式。
> 
> 关于memcached最大设置30天有效的情形暂时没有测试。

[http_www.runoob.com_memcached_window-install-memcached.html]: http://www.runoob.com/memcached/window-install-memcached.html
[https_github.com_gwhalin_Memcached-Java-Client_downloads]: https://github.com/gwhalin/Memcached-Java-Client/downloads
[70]: /images/20220523/6252c54316b74769914a3d8cbecf9d68.png