memcached与spring提供的cache接口整合demo

最新推荐文章于 2019-11-24 21:15:23 发布
最新推荐文章于 2019-11-24 21:15:23 发布
阅读量383 收藏
点赞数
分类专栏： Spring相关 文章标签： memcached spring 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QZC78/article/details/76434737
版权

一.spring-memcached.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">

    <!-- <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true" />  --><!-- 开启缓存 -->
    <!-- 自定义key生成策略-->
    <cache:annotation-driven key-generator="stringKeyGenerator" />
    <bean id="stringKeyGenerator" class="com.wlsq.fs.cache.StringKeyGenerator" />

    <bean id="cacheManager" class="com.wlsq.fs.cache.MemcachedCacheManager">
<!--        是否事务环绕的，如果true，则如果事务回滚，缓存也回滚，默认false -->
        <property name="transactionAware" value="true" />
        <property name="caches">
            <set>
                <!--产品 -->
                <bean class="com.wlsq.fs.cache.MemcachedSpringCache">
                    <property name="name" value="food_prod" />
                    <property name="memcachedClient" ref="memcachedClient" />
                    <property name="expiredDuration" value="1200" />
                </bean>

                <!-- 用户信息的缓存 -->
                <bean class="com.wlsq.fs.cache.MemcachedSpringCache">
                    <property name="name" value="food_userInfo" />
                    <property name="memcachedClient" ref="memcachedClient" />
                    <property name="expiredDuration" value="300" />
                </bean>
                <!-- 用户信息的缓存 -->

            </set>
        </property>
    </bean>

     <!-- 配置缓存服务器 -->   
    <bean id="memcachedClient" class="net.spy.memcached.spring.MemcachedClientFactoryBean">
        <property name="servers" value="${memcached.servers}" />
        <property name="protocol" value="${memcached.protocol}" />
        <property name="transcoder">
            <bean class="net.spy.memcached.transcoders.SerializingTranscoder">
                <property name="compressionThreshold" value="1024" />
            </bean>
        </property>
        <property name="opTimeout" value="${memcached.opTimeout}" />
        <property name="timeoutExceptionThreshold" value="${memcached.timeoutExceptionThreshold}" />
        <property name="hashAlg">
            <value type="net.spy.memcached.DefaultHashAlgorithm">KETAMA_HASH</value>
        </property>
        <property name="locatorType" value="${memcached.locatorType}" />
        <property name="failureMode" value="${memcached.failureMode}" />
        <property name="useNagleAlgorithm" value="${memcached.useNagleAlgorithm}" />
        <property name="authDescriptor" ref="authDescriptor" />
    </bean> 

    <!-- 阿里云身份校验 -->
    <bean id="authDescriptor" class="net.spy.memcached.auth.AuthDescriptor">
         <constructor-arg index="0" >
             <list>  
                <value>PLAIN</value>  
            </list>  
         </constructor-arg>
         <constructor-arg  index="1" ref="plainCallbackHandler"/>
    </bean>

     <!-- 阿里云账号密码配置  -->
    <bean id="plainCallbackHandler" class="net.spy.memcached.auth.PlainCallbackHandler">
           <constructor-arg index="0" value="${memcached.username}"/>
           <constructor-arg index="1" value="${memcached.password}"/>
    </bean>
</beans>

二、自定义key生成策略StringKeyGenerator

public class StringKeyGenerator implements KeyGenerator {

    @Override
    public Object generate(Object paramObject, Method paramMethod, Object[] paramArrayOfObject){
        StringBuilder localStringBuilder = new StringBuilder(50);
        localStringBuilder.append(paramObject.getClass().getName());
        localStringBuilder.append(paramMethod.getName());
        for (Object localObject : paramArrayOfObject)
        {
          if (localObject != null)
            localStringBuilder.append(localObject.toString());
          localStringBuilder.append(".");
        }
        return localStringBuilder.toString();
      }
}

对应memecahed配置文件中的

  <!-- 自定义key生成策略-->
    <cache:annotation-driven key-generator="stringKeyGenerator" />
    <bean id="stringKeyGenerator" class="com.wlsq.fs.cache.StringKeyGenerator" />

三、MemcachedCacheManager
继承spring的AbstractTransactionSupportingCacheManager

public class MemcachedCacheManager extends AbstractTransactionSupportingCacheManager{

    public MemcachedCacheManager() {

    }

    private Collection<? extends Cache> caches;

    @Override
    protected Collection<? extends Cache> loadCaches() {
          return this.caches;
    }

    public void setCaches(Collection<? extends Cache> caches) {
        this.caches = caches;
    }



}

对应memcached配置文件

    <bean id="cacheManager" class="com.wlsq.fs.cache.MemcachedCacheManager">
<!--        是否事务环绕的，如果true，则如果事务回滚，缓存也回滚，默认false -->
        <property name="transactionAware" value="true" />
        <property name="caches">
        ...
        ...

四、实现基于Spring Cache抽象体系的Memcached缓存(实现了Cache api接口)

public class MemcachedSpringCache implements Cache, InitializingBean{
    private final static Logger logger = LoggerFactory.getLogger(MemcachedSpringCache.class);

    private String name;
    private MemcachedClient memcachedClient;

    /**
     * 默认最长缓存时间为1小时
     */
    private static final int MAX_EXPIRED_DURATION = 60 * 60;

    /** Null值的最长缓存时间 */
    private static final int NULL_VALUE_EXPIRATION = 60 * 60 * 24 * 7;

    /** 增量过期时间允许设置的最大值 */
    private static final int DELTA_EXPIRATION_THRESHOLD = 60 * 60 * 24 * 30;
    /**
     * 缓存数据超时时间
     */
    private int expiredDuration = MAX_EXPIRED_DURATION;

    private static final Object NULL_HOLDER = new NullHolder();

    private boolean allowNullValues = true;


    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(memcachedClient, "memcachedClient must not be null!");
    }

    @Override
    public void clear() {
        try {
            memcachedClient.flush();
        } catch (Exception e) {
            logger.error("memcached执行flush出现异常", e);
        }
    }

    /**
     * @Description: 移除缓存， 安全的evict方法,在3秒内返回结果, 否则取消操作.
     */
    @Override
    public void evict(Object key) {
        String cacheKey = getCacheKey(key);
        logger.debug("删除缓存的Key:{}", cacheKey);
        Future<Boolean> future = memcachedClient.delete(cacheKey);
        try {
            future.get(3, TimeUnit.SECONDS);
        } catch (Exception e) {
            future.cancel(false);
            logger.error("memcached清除缓存出现异常, key={}, server={}", cacheKey,
                    memcachedClient.getNodeLocator().getPrimary(cacheKey).getSocketAddress(), e);
        }
    }

    /**
     * @Description: 根据key得到一个ValueWrapper，然后调用其get方法获取值
     */
    @Override
    public ValueWrapper get(Object key) {
        String cacheKey = getCacheKey(key);
        try {
            StopWatch sw = new StopWatch();
            sw.start();
            Object value = memcachedClient.get(cacheKey);
            sw.stop();
            if (sw.getTime() > 50) {
                logger.info("读取memcached用时{}, key={}", sw.getTime(), cacheKey);
            }
            return (value != null ? new SimpleValueWrapper(fromStoreValue(value)) : null);
        } catch (Exception e) {
            logger.error("读取memcached缓存发生异常, key={}, server={}", cacheKey,
                    memcachedClient.getNodeLocator().getPrimary(cacheKey).getSocketAddress(), e.getCause());
            return null;
        }
    }

    /**
     * @Description: 根据key，和value的类型直接获取value 
     */
    @Override
    public <T> T get(Object key, Class<T> type) {
        ValueWrapper element = get(key);
        Object value = (element != null ? element.get() : null);
        if (value == null)
            return null;
        if (type != null && !type.isInstance(value)) {
            throw new IllegalStateException("缓存的值类型指定错误 [" + type.getName() + "]: " + value);
        }
        return (T) value;
    }



    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Object getNativeCache() {
        return this.memcachedClient;
    }

    /**
     * @Description: 往缓存放数据
     *    安全的Set方法,在3秒内返回结果, 否则取消操作
     */
    @Override
    public void put(Object key, Object value) {
        String cacheKey = getCacheKey(key);
        logger.debug("放入缓存的Key:{}, Value:{}, StoreValue:{}", cacheKey, value, toStoreValue(value));
        int expiration = expiredDuration;
        if (value == null) {
            if (allowNullValues) {
                value = NULL_HOLDER; // 若允许缓存空值，则替换null为占坑对象；不允许直接缓存null，因为无法序列化
            }
            if (expiredDuration > NULL_VALUE_EXPIRATION) {
                expiration = NULL_VALUE_EXPIRATION; // 缩短空值的过期时间，最长缓存7天
            }
        } else if (expiredDuration > DELTA_EXPIRATION_THRESHOLD) {
            expiration += (int) (System.currentTimeMillis() / 1000); // 修改为UNIX时间戳类型的过期时间，使能够设置超过30天的过期时间
                                                                        // 注意：时间戳计算这里有2038问题，
                                                                        // 2038-1-19 11:14:07 (GMT +8) 后，转换成的 int 会溢出，导致出现负值
        }
        Future<Boolean> future = memcachedClient.set(cacheKey, expiration, value);
        try {
            future.get(3, TimeUnit.SECONDS);
        } catch (Exception e) {
            future.cancel(false);
            logger.error("memcached写入缓存发生异常, key={}, server={}", cacheKey,
                    memcachedClient.getNodeLocator().getPrimary(cacheKey).getSocketAddress(), e);
        }
    }

    @Override
    public ValueWrapper putIfAbsent(Object arg0, Object arg1) {
        // TODO Auto-generated method stub
        return null;
    }


    private static class NullHolder implements Serializable {
        private static final long serialVersionUID = -99681708140860560L;
    }

    /**
     * 存入到缓存的key，由缓存的区域+key对象值串接而成
     * @param key key对象
     * @return 
     */
    private String getCacheKey(Object key) {
        return this.name + key.toString();
    }

    protected Object fromStoreValue(Object storeValue) {
        if (this.allowNullValues && storeValue instanceof NullHolder) {
            return null;
        }
        return storeValue;
    }

    protected Object toStoreValue(Object userValue) {
        if (this.allowNullValues && userValue == null) {
            return NULL_HOLDER;
        }
        return userValue;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setMemcachedClient(MemcachedClient memcachedClient) {
        this.memcachedClient = memcachedClient;
    }

    public void setExpiredDuration(int expiredDuration) {
        this.expiredDuration = expiredDuration;
    }

    public void setAllowNullValues(boolean allowNullValues) {
        this.allowNullValues = allowNullValues;
    }
}

对应memcached配置文件

<bean id="cacheManager" class="com.wlsq.fs.cache.MemcachedCacheManager">
<!--        是否事务环绕的，如果true，则如果事务回滚，缓存也回滚，默认false -->
        <property name="transactionAware" value="true" />
        <property name="caches">
            <set>
                <!--产品 -->
                <bean class="com.wlsq.fs.cache.MemcachedSpringCache">
                    <property name="name" value="food_prod" />
                    <property name="memcachedClient" ref="memcachedClient" />
                    <property name="expiredDuration" value="1200" />
                </bean>
                ...
                ...

四、基于spring注解调用
注：此处使用spring注解配置暂不记录

@Caching(evict={@CacheEvict(value="food_prod",key = "#productId"),@CacheEvict(value="food_AppProd",key = "#productId"),@CacheEvict(value="food_AppProdDto",key = "#productId")})
public int delProductProcess(int processId,int productId) {
     ......
     ......
 }

或自定义

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
@Caching(evict = { 
        @CacheEvict(value = "food_prod", key = "#productinfo.id"),
        @CacheEvict(value = "food_AppProd", key = "#productinfo.id"),
        @CacheEvict(value = "food_AppProdDto", key = "#productinfo.id")
        })
public @interface ProductUpdateVo {

}

------------使用----------------
@ProductUpdateVo
public int updateByPrimaryKeySelective(Productinfo productinfo) {
   ......
}

此处只记录配置和使用，仅供参考

原理请参考:https://my.oschina.net/004/blog/368664

QZC78
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring集成Memcached与Memcached API
永不止步
06-12 368
spring集成Memcached<! --memcached 客户端 SocketPool --> <bean id="memcachedPool " class="com.danga.MemCached.SockIOPool" factory- method="getInstance" init-method="initialize" destroy-method="shutDown">
Springboot整合Cache缓存组件(Redis,Caffine,Jetcache,EhCache等)
青春不散场的专栏
06-23 667
Springboot整合各种缓存组件，在日常开发中除了分布式缓存，更多的还是各种服务内部缓存的组件，这里把Springboot整合的各种缓存组件都列出来，作为一个总结
SSM与memcached整合项目Spring Cache
10-31
承接上个代码将memecached调用改为交给Spring Cache代理
Memcached之——Memcached与Spring提供的cache接口整合
chuqi1313的博客
03-05 316
spring 从3.x就提供了cache接口，spring默认实现的缓存是ehcache，spring的cache接口： publicinterfaceCache{ StringgetName(); ObjectgetNativeCache()...
memcached与spring提供的cache接口整合
weixin_34198797的博客
01-16 95
为什么80%的码农都做不了架构师？>>> ...
三、Memcached整合Spring cache注解完整示例(SSM框架)
这个名字想了很久
02-26 1130
转载请注明出处:http://blog.csdn.net/l1028386804/article/details/48464111 在前面的几篇博文中，我们记录了Memcached整合spring的一些方法，现在我们就基于这些方法实现一个Memcached整合Spring的完整示例，好了不多说了，我们直接上代码吧。 一、配置 1、MemcachedCacheManager
Spring Cache集成memcached
任何技能都是从模仿开始，逐步升华。
10-18 4322
使用memcahed的客户端xmemcached实现Cache、CacheManager接口。
cache-demo-2.5.zip_Cache2.5_DEMO_cache
最新发布
09-22
【标题】"cache-demo-2.5.zip_Cache2.5_DEMO_cache" 指的是一个关于Cache2.5版本的演示项目，这个压缩包主要用于展示如何在阿里巴巴的系统中进行缓存管理。"cache-demo"部分表示这是一个用于演示缓存功能的实例，而...
Spring memcached 源码
08-04
首先，Spring Memcached的集成主要是通过`spring-memcached`库实现的，它提供了对Memcached服务器的客户端支持，使得Spring应用能够方便地调用Memcached服务。在源码中，`OrgManagerServiceImpl`类是一个示例，展示...
(SSM框架)memcached整合Spring基于Cache注解.
02-28
使用Spring,SpringMVC,mybatis框架 将memcached和Spring集成,基于Spring原Cache注解
jetcache-demo:jetcache弹簧靴
05-09
综上所述，jetcache是一个强大且灵活的Java缓存框架，通过与Spring Boot的整合，可以轻松地在微服务环境中实现高效的缓存管理。`jetcache-demo-master`项目则为开发者提供了一个实践jetcache的实例，有助于快速上手...
在spring中整合memcached缓存
cnctcom的博客
07-18 362
memcached是内存级缓存、相对于其他内存缓存数据库redis或mongoDB而言、memcached速度是最快的 下面整理下在spring项目中memcached的使用
Spring Cache\Redis\Memcached
qq_37054816的博客
11-24 233
Spring Cache 1.简介 核心思想是当在调用一个缓存方法时，会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下一次利用同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果进行返回，从而实现缓存的功能。 1.@Cacheable 用于标记缓存，也就是对使用@Cacheable注解的位置进行缓存。@Cacheable可以在方法或者类上进行标记，当对方法进行标记时...
memcache spring cache 关键点
展望
12-08 583
这个要放在spring 的主文件里， xml文件要从jar包拿出来，在进行加载。不用考虑用jar*这种方式加载。。会检测不到的。 然后可以进行注解式的开发了。
flea-cache使用之整合Memcached和Redis接入
Huazie
08-23 1282
Flea框架之flea-cache 整合多套缓存框架接入
Spring与Memcache整合（原创及优秀memcache整理）
wangsx的博客
12-19 4050
0.Memcached目前有三中java客户端程序：        1-1.官方提供的基于传统阻塞Io 由Greg Whalin维护的客户端】        1-2.Dustin Sallings实现的基于java nio的Spymemcached        1-3.XMemcached 三种java客户端具体的区别见：http://jingyan.baidu.com/
Spring Cache之Ehcache和Memcached
北漂码农
07-27 3762
spring框架从3.1版本开始提供了缓存支持：在spring-context.jar里的org.springframework.cache包，以及spring-context-support.jar里的org.springframework.cache包；而且提供了基于ConcurrentHashMap、JCacheCache、EhCache、GuavaCache的实现。 这里我们先看下基于E
memcached之java客户端:spymemcached与spring整合（身份验证）
QZC78的博客
04-14 2760
memcached authDescriptor
Spring整合Memcached配置与使用示例
Spring框架提供了一种方便的方式来集成Memcached，使得Java应用可以利用其高速缓存功能。以下是一个关于如何在Java Web项目中使用Memcached的详细步骤和配置： 首先，我们需要在项目中添加Memcached的相关依赖。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值