springboot中集成memcached

前言

Memcached 是一个高性能的分布式内存对象缓存系统,其存储性能在某些方面不比redis差，甚至在文本类型数据的存储上性能略优于redis,本文将介绍如何在springboot中集成memcached

准备工作

首先我们需要一款客户端连接对象，类似于我们在使用redis时使用的jedis , 目前memcached主流的客户端是Xmemcached，如果使用的是maven构建项目，则引入对应的依赖

   <!--引入memcached-->
        <dependency>
            <groupId>com.googlecode.xmemcached</groupId>
            <artifactId>xmemcached</artifactId>
            <version>2.4.5</version>
        </dependency>

配置

memcached在yml(properties)文件的相关配置

# memcached配置
memcached:
  server: 1.1.1.1:3333 2.2.2.2:4444 #memcached服务器集群(格式为host:port，多个服务器之间用空格隔开)
  opTimeout: 3000 #接口操作的默认超时时间，可以被接口覆盖
  poolSize: 10 #池子大小
  failureMode: false #是否开启失败模式，默认为false
  enabled: true # 是否使用memcached缓存

将memcached的配置由bean来管理，方便我们调用

package com.me.config.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author : wang zns
 * @date : 2018-12-19
 */
@Component
@ConfigurationProperties(prefix = "memcached")
public class MemcachedProperties {

    /**
     * 服务器
     */
    private String server;

    /**
     * 操作超时时间，可以被API覆盖
     */
    private Integer opTimeout;
    /**
     * 连接池大小
     */
    private Integer poolSize;

    /**
     * 是否开启失败模式
     */
    private boolean failureMode;

    /**
     * 是否使用memcached缓存
     */
    private boolean enabled;



    public String getServer() {
        return server;
    }

    public void setServer(String server) {
        this.server = server;
    }

    public Integer getOpTimeout() {
        return opTimeout;
    }

    public void setOpTimeout(Integer opTimeout) {
        this.opTimeout = opTimeout;
    }

    public Integer getPoolSize() {
        return poolSize;
    }

    public void setPoolSize(Integer poolSize) {
        this.poolSize = poolSize;
    }

    public boolean isFailureMode() {
        return failureMode;
    }

    public void setFailureMode(boolean failureMode) {
        this.failureMode = failureMode;
    }

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }
}

memcached配置类(创建memcached客户端对象，并注入spring容器中)

package com.me.config;

import cn.stylefeng.guns.config.properties.MemcachedProperties;
import lombok.extern.slf4j.Slf4j;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.command.BinaryCommandFactory;
import net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author : wang zns
 * @date : 2018-12-19
 */
@Configuration
@Slf4j
public class MemcachedConfig {

    @Autowired
    private MemcachedProperties memcachedProperties;



    @Bean(name = "memcachedClientBuilder")
    public MemcachedClientBuilder getBuilder() {
        MemcachedClientBuilder memcachedClientBuilder = new XMemcachedClientBuilder(memcachedProperties.getServer());

        // 内部采用一致性哈希算法
        memcachedClientBuilder.setSessionLocator(new KetamaMemcachedSessionLocator());
        // 操作的超时时间
        memcachedClientBuilder.setOpTimeout(memcachedProperties.getOpTimeout());
        // 采用二进制传输协议（默认为文本协议）
        memcachedClientBuilder.setCommandFactory(new BinaryCommandFactory());
        // 设置连接池的大小
        memcachedClientBuilder.setConnectionPoolSize(memcachedProperties.getPoolSize());
        // 是否开起失败模式
        memcachedClientBuilder.setFailureMode(memcachedProperties.isFailureMode());
        return memcachedClientBuilder;
    }

    /**
     * 由Builder创建memcachedClient对象，并注入spring容器中
     * @param memcachedClientBuilder
     * @return
     */
    @Bean(name = "memcachedClient")
    public MemcachedClient getClient(@Qualifier("memcachedClientBuilder") MemcachedClientBuilder memcachedClientBuilder) {
        MemcachedClient client = null;
        try {
            client =  memcachedClientBuilder.build();
        } catch(Exception e) {
            log.info("exception happens when bulid memcached client{}",e.toString());
        }
       return client;
    }



}

使用

有了client对象之后，我们可以像直接操作服务端那样进行对应的操作，下面用一个小案例进行演示

service

package cn.stylefeng.guns.modular.housemanage.cache;

import cn.stylefeng.guns.modular.system.model.TblHouse;

/**
 * 房屋管理缓存 业务层
 * @author : wang zns
 * @date : 2018-12-19
 */
public interface HouseManageCacheService {

    /**
     * 添加
     * @param tblHouse
     */
    void add(TblHouse tblHouse);

    /**
     * 根据主键删除
     * @param tblHouseId
     */
    void delete(Integer tblHouseId);
    
}

serviceImpl

package cn.stylefeng.guns.modular.housemanage.cache;

import cn.stylefeng.guns.modular.housemanage.service.ITblHouseService;
import cn.stylefeng.guns.modular.system.model.TblHouse;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import net.rubyeye.xmemcached.MemcachedClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author : wang zns
 * @date : 2018-12-19
 */
@Service
@Slf4j
public class HouseManageCacheServiceImpl implements HouseManageCacheService{

    @Autowired
    private MemcachedClient memcachedClient;
    @Autowired
    private ITblHouseService iTblHouseService;

    @Override
    public void add(TblHouse tblHouse) {
        // 先入库，入库成功则入缓存
        boolean isSuccess = iTblHouseService.insert(tblHouse);
        if (isSuccess) {
            try {
                String houseJsonStr = JSON.toJSONString(tblHouse);
                memcachedClient.set(String.valueOf(tblHouse.getId()),0,houseJsonStr);
            } catch (Exception e) {
                log.info("exception happens when add House:{}",e.toString());
                throw new RuntimeException(e.getMessage());
            }
        }
    }

    @Override
    public void delete(Integer tblHouseId) {
        // 先删除数据库内容，成功则清空缓存
        boolean isSuccess = iTblHouseService.deleteById(tblHouseId);
        if (isSuccess) {
            try {
                memcachedClient.delete(String.valueOf(tblHouseId));
            } catch (Exception e) {
                log.info("exception happens when delete House:{}",e.toString());
                throw new RuntimeException(e.getMessage());
            }
        }
    }

}

controller

 /**
     * 新增房屋管理
     */
    @RequestMapping(value = "/add")
    @ResponseBody
    public Object add(@Valid TblHouse tblHouse, BindingResult bindingResult) {
        if(bindingResult.hasErrors()){
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        // 如果确定要使用缓存
        if (memcachedProperties.isEnabled()) {
            houseManageCacheService.add(tblHouse);
        } else {
            tblHouseService.insert(tblHouse);
        }
        return SUCCESS_TIP;
    }

    /**
     * 删除房屋管理
     */
    @RequestMapping(value = "/delete")
    @ResponseBody
    public Object delete(@RequestParam Integer tblHouseId) {
        if (memcachedProperties.isEnabled()) {
            houseManageCacheService.delete(tblHouseId);
        } else {
            tblHouseService.deleteById(tblHouseId);
        }
        return SUCCESS_TIP;
    }

运行结果：

提交之后，去缓存服务器上查看

至此，springboot中集成memcached就完成了

写在最后

springboot集成memcached非常简单，核心步骤就是添加依赖、创建client对象并注入spring容器、然后就是用client对象进行各种操作。

client的接口当然有非常多，xmemcached对接口进行了封装。

最后附上xmemcached官网的地址，里面的文档很详细  https://github.com/killme2008/xmemcached/wiki