springboot -- 整合 memcache缓存

最新推荐文章于 2022-06-23 12:15:00 发布

兮家小二

最新推荐文章于 2022-06-23 12:15:00 发布

阅读量919

点赞数

分类专栏： # springboot 文章标签： win安装memcache springboot使用memcache缓存

本文链接：https://blog.csdn.net/qq_41463655/article/details/89601308

版权

springboot 专栏收录该内容

45 篇文章 4 订阅

订阅专栏

win安装memcache 借鉴地址

https://www.cnblogs.com/wujuntian/p/4791220.html

API 借鉴

spymemcached 与 pool 方式都类似

//	    Memcache::add – 添加一个值，如果已经存在，则返回false 
//	    Memcache::addServer – 添加一个可供使用的服务器地址 
//	    Memcache::close – 关闭一个Memcache对象 
//	    Memcache::connect – 创建一个Memcache对象 
//	    memcache_debug – 控制调试功能 
//	    Memcache::decrement – 对保存的某个key中的值进行减法操作 
//	    Memcache::delete – 删除一个key值 
//	    Memcache::flush – 清除所有缓存的数据 
//	    Memcache::get – 获取一个key值 
//	    Memcache::getExtendedStats – 获取进程池中所有进程的运行系统统计 
//	    Memcache::getServerStatus – 获取运行服务器的参数 
//	    Memcache::getStats – 返回服务器的一些运行统计信息 
//	    Memcache::getVersion – 返回运行的Memcache的版本信息 
//	    Memcache::increment – 对保存的某个key中的值进行加法操作 
//	    Memcache::pconnect – 创建一个Memcache的持久连接对象 
//	    Memcache::replace -对一个已有的key进行覆写操作 
//	    Memcache::set – 添加一个值，如果已经存在，则覆写 
//	    Memcache::setCompressThreshold – 对大于某一大小的数据进行压缩 
//	    Memcache::setServerParams – 在运行时修改服务器的参数

springboot 使用方法一 ,（spymemcached/推荐）

maven依赖

<!--memcache 缓存 -->
        <dependency>
		  <groupId>net.spy</groupId>
		  <artifactId>spymemcached</artifactId>
		  <version>2.12.2</version>
		</dependency>

application.properties 配置

################################################
###   memcache缓存 
################################################
memcache.ip=127.0.0.1
memcache.port=11211

config 配置类（MemcachedRunner）

import java.io.IOException;
import java.net.InetSocketAddress;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import net.spy.memcached.MemcachedClient;
import net.spy.memcached.compat.log.Logger;
import net.spy.memcached.compat.log.LoggerFactory;

/**
 * Memcached缓存配置  MemcachedClient.getClient(),获取缓存
 * @author wangsong
 * @date 2019年4月27日 下午5:17:22
 */
@Component
public class MemcachedRunner implements CommandLineRunner {
    protected Logger logger =  LoggerFactory.getLogger(this.getClass());

    private MemcachedClient client = null;

    @Value("${memcache.ip}")
    private String ip;
    
    @Value("${memcache.port}")
    private int port;
    
    
    @Override
    public void run(String... args) throws Exception {
        try {
            client = new MemcachedClient(new InetSocketAddress(ip,port));
        } catch (IOException e) {
            logger.error("inint MemcachedClient failed ",e);
        }
    }
    public MemcachedClient getClient() {
        return client;
    }
}

测试

使用中先测试插入一个 key 为 key ，
1000 为过期时间，单位为秒，0为永不过期
最后的 “wangsong” 为 key 对应的值

@RunWith(SpringRunner.class)
@SpringBootTest
public class WarGameWebApplicationTests {

		 @Resource
		 private MemcachedRunner memcachedRunner;

		  @Test
		  public void testSetGet()  {
		    MemcachedClient memcachedClient = memcachedRunner.getClient();
		    memcachedClient.set("key", 1000, "wangsong");
		    System.out.println("***********  "+memcachedClient.get("key").toString());
		  }
 }

springboot 使用方法二（pool ）

maven 依赖

<!--memcache-->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
        </dependency>
        <dependency>
            <groupId>com.whalin</groupId>
            <artifactId>Memcached-Java-Client</artifactId>
            <version>3.0.2</version>
        </dependency>

application.properties 配置

################################################
###        memcache缓存

###   Servers(addr);        //设置连接池可用cache服务器列表，服务器构成形式：ip地址+端口号
###   Weights(weight);      //设置连接池可用cache服务器的权重，和server数组的位置一一对应
###   InitConn(5);          //设置初始连接数
###   MinConn(5);           //设置最小连接数
###   MaxConn(200);         //设置最大连接数
###   MaxIdle(1000*30*30);  //设置可用连接的最长等待时间
###   MaintSleep(30);       //设置连接池维护线程的睡眠时间，设置为0，维护线程不启动
###   Nagle(false);        //设置Nagle算法，设置为false，因为通讯数据量比较大要求相应及时
###   SocketTO(30);        //设置socket读取等待超时时间
###   SocketConnectTO(0);  //设置连接等待超时值
################################################
memcache.servers=127.0.0.1:11211
memcache.failover=true
memcache.initConn=10
memcache.minConn=20
memcache.maxConn=1000
memcache.maintSleep=50
memcache.nagle=false
memcache.socketTO=3000
memcache.aliveCheck=truememcache.servers=127.0.0.1:11211
memcache.failover=true
memcache.initConn=10
memcache.minConn=20
memcache.maxConn=1000
memcache.maintSleep=50
memcache.nagle=false
memcache.socketTO=3000
memcache.aliveCheck=true

MemcacheConfiguration 配置类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.whalin.MemCached.MemCachedClient;
import com.whalin.MemCached.SockIOPool;

@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.nagle}")
	    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();
	    }

}

conteoller 测试（也可以test测试）

import java.util.Date;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.whalin.MemCached.MemCachedClient;

@Controller
public class MemcacheController {
	
	 @Autowired
	 private MemCachedClient memCachedClient;
	 
	    /**
	     * memcache缓存
	     */
	    @RequestMapping("/memcache")
	    @ResponseBody
	    public String memcache() throws InterruptedException{
	        // 放入缓存
	        boolean flag = memCachedClient.set("mem", "name");
	        // 取出缓存
	        Object value = memCachedClient.get("mem");
	        System.out.println(value);
	        // 3s后过期
	        memCachedClient.set("num", "666", new Date(3000));
	         /*memCachedClient.set("num", "666", new Date(System.currentTimeMillis()+3000));与上面的区别是当设置了这个时间点
	                   之后，它会以服务端的时间为准，也就是说如果本地客户端的时间跟服务端的时间有差值，这个值就会出现问题。
	                   例：如果本地时间是20:00:00,服务端时间为20:00:10，那么实际上会是40秒之后这个缓存key失效*/
	        Object key = memCachedClient.get("num");
	        System.out.println(key);
	        //多线程睡眠3s
	        Thread.sleep(3000);
	        key  = memCachedClient.get("num");
	        System.out.println(value);
	        System.out.println(key );
	        return "success";
	    }	
}