撸完Spring源码,我为Spring写了个分布式缓存插件,现已开源,快要裂开了!!(建议收藏)

Posted 冰 河

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了撸完Spring源码,我为Spring写了个分布式缓存插件,现已开源,快要裂开了!!(建议收藏)相关的知识,希望对你有一定的参考价值。

大家好,我是冰河~~

经过三个月的时间,我终于撸完了Spring源码,快要裂开了!!随后,开源了这个分布式缓存框架!!!

框架地址如下所示:

GitHub:https://github.com/sunshinelyz/mykit-cache

Gitee:https://gitee.com/binghe001/mykit-cache

接下来,我就为大家介绍下这个框架。如果这个框架对大家有点帮助,还请小伙伴们打开Github和Gitee链接,给这个项目一个大大的Star,让更多的小伙伴收益。也可以为这篇文章点赞、在看和转发哦~~

框架简述

mykit架构中独立出来的mykit-cache组件,封装了mykit架构下对于缓存cache的各种操作,使用者只需要引入相关的Jar包,即可实现对缓存的轻松操作。

框架结构描述

封装了对于缓存的操作,支持Memcached、Redis、Ehcache等分布式缓存数据库,同时支持Spring的注解,通过Spring的注解可实现设置缓存的失效时间和主动刷新缓存。

总体结构如下所示。

mykit-cache-memcached

mykit-cache架构下与Memcached缓存相关的组件

mykit-cache-memcached-spring

mykit-cache-memcached 下主要与 Spring 整合 Memcached 操作相关的组件,支持通过注解设置缓存有效时间

mykit-cache-memcached-spring-simple

mykit-cache-memcached-spring下主要使用simple-spring-memcached内核实现注解缓存的组件,支持通过注解设置缓存有效时间。

兼容Memcached服务器宕机或因其他原因无法连接Memcached服务器的情况,主要方式为抛出相关异常信息后继续执行原方法。

mykit-cache-memcached-spring-simple-core

mykit-cache-memcached-spring-simple下的核心模块,提供核心配置项

mykit-cache-memcached-spring-simple-xml

mykit-cache-memcached-spring-simple下以XML方式管理Spring容器的插件类,提供Spring容器管理Memcached的核心配置,

其他项目或工程只需引入此插件,同时在自身的Spring配置文件中加载此组件的Memcached的核心配置即可。

mykit-cache-memcached-spring-simple-test

通用测试工程,主要测试mykit-cache-memcached-spring下主要以simple-spring-memcached为内核的缓存操作,此插件模块主要提供主要的测试用例封装类。

mykit-cache-memcached-spring-simple-test-xml

mykit-cache-memcached-spring下测试simple-spring-memcached为内核的缓存操作的入口工程, 测试入口类为:io.mykit.cache.test.memcached.test.xml.MemcachedTest, 同时,需要将此工程 下的classpath:properties/memcached.properties文件中的simple.memcache.server属性配置为自身Memcached服务器的IP和端口。

mykit-cache-redis

mykit-cache架构下与Redis缓存相关的组件

mykit-cache-redis-java

mykit-cache-redis 下单独以Java方式使用Redis缓存的封装。

mykit-cache-redis-spring

mykit-cache-redis 下主要与 Spring 整合 Redis操作相关的组件,支持通过注解设置缓存有效时间和主动刷新缓存

mykit-cache-redis-spring-core

mykit-cache-redis-spring 下主要提供Spring整合Redis的通用工具方法等,核心实现由此模块提供

mykit-cache-redis-spring-annotation

mykit-cache-redis-spring 下主要与 Spring 整合 Redis操作相关的组件,支持通过注解设置缓存有效时间和主动刷新缓存,主要以Java注解的形式实现Spring容器的管理操作,兼容Redis集群宕机或其他原因无法连接Redis集群时的情况。

如果Redis集群宕机或其他原因无法连接Redis集群时,打印相关的日志,并继续向下执行原有方法。

mykit-cache-redis-spring-xml

mykit-cache-redis-spring 下主要与 Spring 整合 Redis操作相关的组件,支持通过注解设置缓存有效时间和主动刷新缓存,主要以XML配置的形式实现Spring容器的管理操作,不兼容Redis集群宕机或其他原因无法连接Redis集群时的情况,如果Redis集群宕机或其他原因无法连接Redis集群时,抛出异常,退出执行。

mykit-cache-redis-spring-test

mykit-cache-redis-spring 下测试Spring整合Redis的核心测试用例类,提供主要的测试封装;

mykit-cache-redis-spring-test-annotation

mykit-cache-redis-spring 下测试以Java注解形式管理Spring容器的测试入口, 对mykit-cache-redis-spring-annotation提供单元测试用例。

测试入口为:io.mykit.cache.test.redis.spring.annotation.test.TestRedisConfig,执行测试方法前需要先根据自身的Redis集群情况配置classpath:properties/redis.properties文件,将redis.properties中的Redis集群的节点IP和端口修改为自身的Redis集群节点的IP和端口

mykit-cache-redis-spring-test-xml

mykit-cache-redis-spring 下测试以XML配置形式管理Spring容器的测试入口,mykit-cache-redis-spring-xml的测试模块,对mykit-cache-redis-spring-xml提供单元测试用例。

测试的入口为io.mykit.cache.test.redis.spring.test.xml.RedisTest, 执行测试方法前需要先根据自身的Redis集群情况配置classpath:properties/redis.properties文件,将redis.properties中的Redis集群的节点IP和端口修改为自身的Redis集群节点的IP和端口

mykit-cache-ehcache

mykit-cache架构下与ehcache缓存相关的组件

mykit-cache-ehcache-spring

mykit-cache-ehcache 下主要与 Spring 整合Ehcache操作相关的组件,支持通过注解设置缓存有效时间

使用场景如下所示

1.需要使用Java直接操作Redis

1)在Maven的pom.xml文件中加入如下配置:

<dependency>
    <groupId>io.mykit.cache</groupId>
    <artifactId>mykit-cache-redis-java</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

2)在项目的resources目录下创建Redis的配置文件redis.properties文件

如果是Redis单机模式,则redis.properties文件的内容如下所示。

redis.host=10.2.2.231
redis.port=6379
redis.max_idle=200
redis.max_wait=10000
redis.max_total=1024
redis.timeout=3000
redis.test_on_borrow=true

如果是Redis集群模式,则redis.properties文件的内容如下所示。

#Redis集群模式
redis.cluster.password=
redis.cluster.max.total=100
redis.cluster.max.idle=20
redis.cluster.min.idle=10
redis.cluster.timeout=2000
redis.cluster.maxAttempts=100
redis.cluster.redisDefaultExpiration=3600
redis.cluster.usePrefix=true
redis.cluster.blockWhenExhausted=true
redis.cluster.maxWaitMillis=3000
redis.cluster.testOnBorrow=false
redis.cluster.testOnReturn=false
redis.cluster.testWhileIdle=true
redis.cluster.minEvictableIdleTimeMillis=60000
redis.cluster.timeBetweenEvictionRunsMillis=30000
redis.cluster.numTestsPerEvictionRun=-1
redis.cluster.defaultExpirationKey=defaultExpirationKey
redis.cluster.expirationSecondTime=300
redis.cluster.preloadSecondTime=280

# virsual env
redis.cluster.node.one=192.168.175.151
redis.cluster.node.one.port=7001

redis.cluster.node.two=192.168.175.151
redis.cluster.node.two.port=7002

redis.cluster.node.three=192.168.175.151
redis.cluster.node.three.port=7003

redis.cluster.node.four=192.168.175.151
redis.cluster.node.four.port=7004

redis.cluster.node.five=192.168.175.151
redis.cluster.node.five.port=7005

redis.cluster.node.six=192.168.175.151
redis.cluster.node.six.port=7006

redis.cluster.node.seven=192.168.175.151
redis.cluster.node.seven.port=7006

注意:

配置redis.properties文件时,可以修改Redis的IP和端口号,但是文件中的Key必须与上述示例给出的Key相同,否则Redis客户端无法连接到Redis服务器。

3)在Java程序中使用Redis缓存

如果配置的是单机模式,则使用如下方式使用Redis缓存

Jedis jedis = RedisBuilder.getInstance();
jedis.set("name", "binghe");
String value = jedis.get("name");
System.out.println(value);

如果配置的是集群环境,则使用如下方式使用Redis缓存

JedisCluster jedisCluster = RedisClusterBuilder.getInstance();
jedisCluster.set("name", "binghe");
String value = jedisCluster.get("name");
System.out.println(value);

2.需要使用Spring+Redis集群配置缓存:

1)需要兼容Redis集群宕机或其他原因无法连接Redis集群时的情况:

在Maven的pom.xml中加入如下配置即可:

 <dependency>
    <groupId>io.mykit.cache</groupId>
    <artifactId>mykit-cache-redis-spring-annotation</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

此时,还需要根据具体情况在自身项目的合适模块中创建Redis的配置类,主要的功能为提供以Java注解的形式配置Spring和Redis集群整合的Spring容器管理。

示例程序为:mykit-cache-redis-spring-test-annotation测试模块中的io.mykit.cache.test.redis.spring.annotation.config.AnnotationConfig类。

package io.mykit.cache.test.redis.spring.annotation.config;
 
 import io.mykit.cache.redis.spring.annotation.config.CacheRedisConfig;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.context.annotation.PropertySource;
 
 /**
  * @author binghe
  * @version 1.0.0
  * @description 提供以Java注解的形式配置Spring和Redis集群整合的Spring容器管理
  */
 @Configuration
 @EnableCaching
 @EnableAspectJAutoProxy(proxyTargetClass = true)
 @ComponentScan(value = {"io.mykit.cache"})
 @PropertySource(value = {"classpath:properties/redis-default.properties", "classpath:properties/redis.properties"})
 public class AnnotationConfig extends CacheRedisConfig {
 }

2)不需要兼容Redis集群宕机或其他原因无法连接Redis集群时的情况:

在Maven的pom.xml中加入如下配置即可:

<dependency>
    <groupId>io.mykit.cache</groupId>
    <artifactId>mykit-cache-redis-spring-xml</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

此时还需要根据具体情况在自身项目的spring配置文件中,进行相关的配置,主要的配置项有:开启Spring注解扫描及代理,扫描的基本类中加入io.mykit.cache包,并按照顺序加载

classpath*:properties/redis-default.properties, classpath*:properties/redis.properties文件,具体实例为:mykit-cache-redis-spring-test-xml下的classpath:spring/spring-context.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:aop="http://www.springframework.org/schema/aop"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:cache="http://www.springframework.org/schema/cache"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.2.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
                        http://www.springframework.org/schema/cache
                        http://www.springframework.org/schema/cache/spring-cache-4.2.xsd">

	<context:annotation-config />
	<aop:aspectj-autoproxy/>
	<context:component-scan base-package="io.mykit.cache"/>
	   <!-- 引入配置文件 -->
	  <context:property-placeholder location="classpath*:properties/redis-default.properties, classpath*:properties/redis.properties" system-properties-mode="FALLBACK"/>
	  <context:annotation-config />
	  <context:component-scan base-package="io.mykit.cache" />
 	 <import resource="classpath:redis/spring-redis.xml"/>
</beans>

注意:

(1)无论需不需要兼容Redis集群宕机或其他原因无法连接Redis集群时的情况,都需要在自身项目的classpath目录下创建redis.properties文件,配置自身Redis集群节点的IP和端口。

目前,mykit-cache-redis-spring-annotation和mykit-cache-redis-spring-xml最多支持7台Redis集群,可根据自身实际情况扩展;

如果自身的Redis集群不足7台,可在redis.properties文件中配置重复的Redis集群节点的IP和端口;

(2)在自身项目的classpath目录下创建redis.properties文件,此文件名不是强制要求的,可使用其他的文件名代替,但是此文件名必须和spring配置文件中加载的redis配置文件名以及以Java注解形式管理Spring容器的配置类中加载的redis配置文件名保持一致;

(3)自定义的Redis集群配置文件中的集群节点IP和端口的配置项名称必须和实例classpath:properties/redis.properties配置文件中的集群节点IP和端口的配置项名称相同;

(4)配置实例:

比如,在我自己项目中的classpath:properties下redis集群的配置文件为redis.properties,具体内容如下:

#redis cluster config
redis.cluster.defaultExpirationKey=defaultExpirationKey
redis.cluster.expirationSecondTime=300000
redis.cluster.preloadSecondTime=280000

#node info
redis.cluster.node.one=10.2.2.231
redis.cluster.node.one.port=7001

redis.cluster.node.two=10.2.2.231
redis.cluster.node.two.port=7002

redis.cluster.node.three=10.2.2.231
redis.cluster.node.three.port=7003

redis.cluster.node.four=10.2.2.231
redis.cluster.node.four.port=7004

redis.cluster.node.five=10.2.2.231
redis.cluster.node.five.port=7005

redis.cluster.node.six=10.2.2.231
redis.cluster.node.six.port=7006

redis.cluster.node.seven=10.2.2.231
redis.cluster.node.seven.port=7006

则在我项目的spring配置文件中需要加载的配置文件为:

<context:property-placeholder location="classpath*:properties/redis-default.properties, classpath*:properties/redis.properties" system-properties-mode="FALLBACK"/>

或者在我项目的配置类中需要加载的配置文件注解为:

@PropertySource(value = {"classpath:properties/redis-default.properties", "classpath:properties/redis.properties"})

也就是说:classpath:properties/redis-default.properties文件要写到自定义的配置文件的前面,框架会先加载classpath:properties/redis-default.properties

然后加载自定义的配置文件,如果自定义的配置文件中存在与classpath:properties/redis-default.properties文件相同的属性配置,则框架会用自定义的配置属性覆盖classpath:properties/redis-default.properties中相同的属性

(5)具体使用

1)在相关的查询方法上加上无key属性的@Cacheable注解:

@Cacheable(value={"test#10#2"})

没有配置@Cacheable的key属性,此时的@Cacheable的key属性值按照一定策略自定生成,即以当前类名(完整包名+类名)+方法名+方法类型列表+方法参数列表的HashCode为当前@Cacheable的key属性。具体的key生成策略类为mykit-cache-redis-spring-core中的io.mykit.cache.redis.spring.cache.CacheKeyGenerator类;

2)在相关的查询方法上加上有key属性的@Cacheable注解

@Cacheable(value={"test#10#2"} key="key" + ".#defaultValue")

配置了@Cacheable的key属性,此时@Cacheable的key属性值为key拼接参数defaultValue的值的结果的HashCode值。

注意:

(1)@Cacheable注解中没有key属性,框架会为@Cacheable生成Key属性,也就是说key属性不是必须的;

(2)@Cacheable注解没有配置key属性,则以当前类名(完整包名+类名)+方法名+方法类型列表+方法参数列表的HashCode为当前@Cacheable的key属性;

(3)@Cacheable注解配置了key属性,则以当前key的HashCode作为当前@Cacheable的key属性;

(4)@Cacheable的value属性中我们配置的值为 test#10#2,此时表示@Cacheable的缓存名称为test,其中10表示缓存有效时长(单位为秒),2表示距离缓存失效的剩余时长(单位为秒),

即@Cacheable的value属性配置格式为:缓存名称#expireTime#reloadTime,框架规定必须以#作为分隔符

  • expireTime:表示缓存的有效时长,单位秒;
  • reloadTime:表示距离缓存失效的剩余时长,单位秒;
  • expireTime 需要大于 reloadTime,否则无意义

(5)@Cacheable的value属性说明

  • 以缓存名称#expireTime#reloadTime格式配置@Cacheable的value属性后,框架会将查询结果放到缓存中,有效时长为expireTime秒,距离缓存失效的剩余时长为reloadTime秒;
  • 当在将数据存入缓存时,经过了0秒——(expireTime-reloadTime)秒时间范围时,再次调用方法,则直接从缓存中获取数据;
  • 当在将数据存入缓存时,经过了reloadTime秒——expireTime秒时间范围时,再次调用方法,框架会通过代理和反射的方式主动调用原方法从真正的数据源获取数据后刷新缓存;
  • 当在将数据存入缓存时,经过了超过expireTime秒的时间,则缓存失效,再次调用方法,则执行原方法查询数据,框架会自动将查询结果存入缓存;
  • 当框架通过代理和反射的方式主动调用原方法从真正的数据源获取数据后刷新缓存时,为防止请求的多个线程同时执行刷新缓存的操作,框架提供了分布式锁来保证只有一个线程执行刷新缓存操作;
  • 框架主动调用原方法从真正的数据源获取数据后刷新缓存的操作与用户的请求操作是异步的,不会影响用户请求的性能;
  • 框架主动调用原方法从真正的数据源获取数据后刷新缓存的操作对用户请求透明,即用户感知不到框架主动刷新缓存的操作;

其他:

1)当 @Cacheable 的Value只配置了缓存名称,比如配置为@Cacheable(value=“test”)

此时的expireTime默认为redis配置文件的redis.cluster.expirationSecondTime属性值,单位为秒;reloadTime默认为redis配置文件的redis.cluster.preloadSecondTime属性值,单位为秒;

属性值的加载顺序为:优先加载自定义的redis配置文件的redis.cluster.expirationSecondTime属性值和redis.cluster.preloadSecondTime属性值,如果自定义的redis配置文件无相关的属性值;则从框架默认的redis配置文件redis-default.properties文件中加载;

2)当 @Cacheable 的Value配置缓存名称和失效时长,比如配置为@Cacheable(value=“test#10”)

此时的reloadTime默认为redis配置文件的redis.cluster.preloadSecondTime属性值,单位为秒;

属性值的加载顺序为:优先加载自定义的redis配置文件的redis.cluster.preloadSecondTime属性值,如果自定义的redis配置文件无相关的属性值;则从框架默认的redis配置文件redis-default.properties文件中加载;

3)当 @Cacheable 的Value配置缓存名称、失效时长和距离缓存失效的剩余时长,比如配置为:@Cacheable(value=“test#10#2”)

此时不会加载默认的expireTime和reloadTime,框架会直接使用@Cacheable注解中value属性配置的expireTime和reloadTime;

4)无论@Cacheable的Value属性是否配置了缓存时长信息,则都不会出现只配置reloadTime,没有配置expireTime的情况,框架规定的value属性格式为:缓存名称#expireTime#reloadTime

即只会出现的格式为:

  • 缓存名称
  • 缓存名称#expireTime
  • 缓存名称#expireTime#reloadTime

不会存在单独出现reloadTime的情况,会出现配置了缓存名称#expireTime,reloadTime使用配置文件默认的时长配置的情况;

注意事项

1.mykit-cache-redis-spring-xml引用和mykit-cache-redis-spring-annotation引用是互斥的,即在一个工程中mykit-cache-redis-spring-xml和mykit-cache-redis-spring-annotation只能同时引用一个;

2.mykit-cache-redis-spring-xml和mykit-cache-redis-spring-annotation的功能是一样的,但是mykit-cache-redis-spring-annotation工程兼容Redis集群宕机或其他原因无法连接Redis集群时的情况;

3.如果Redis集群宕机或其他原因无法连接Redis集群时,则mykit-cache-redis-spring-xml会抛出异常,退出执行;而mykit-cache-redis-spring-annotation则会打印相关的异常信息,继续向下执行原来的方法。
4.如果你的项目中以XML配置的方式,配置了Spring容器和SpringMVC,而你想以兼容Redis集群宕机或其他原因连接不上Redis集群的方式配置缓存,可以经过如下配置:

1)在项目中添加如下配置类:

SpringContextConfig:配置Spring容器:

package io.mykit.cache.redis.spring.utils.config;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;

import io.mykit.cache.redis.spring.annotation.config.CacheRedisConfig;

/**
 * @ClassName SpringContextConfig
 * @Description Spring Java配置
 * @author binghe
 */
@Configuration
@EnableCaching
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ComponentScan(value = {"io.mykit.cache"})
@PropertySource(value = {"classpath:properties/redis-default.properties", "classpath:properties/redis.properties"})
@ImportResource("classpath:spring/applicationContext.xml")
public class SpringContextConfig extends CacheRedisConfig{

}

SpringMVCConfig:配置SpringMVC:

package io.mykit.cache.redis.spring.utils.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * @ClassName SpringMVCConfig
 * @Description SpringMVC Java配置
 * @author binghe
 */
@Configuration
@ImportResource("classpath:spring/SpringMVC-servlet.xml")
public class SpringMVCConfig {

}

2)web项目的web.xml修改如下:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	  <!-- 配置spring监听器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<context-param>
		<param-name>contextClass</param-name>
		<param-value>
			org.springframework.web.context.support.AnnotationConfigWebApplicationContext
		</param-value>
    </context-param>
    
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>io.mykit.cache.redis.spring.utils.config.SpringContextConfig</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	</listener>
	
	<servlet>
		<servlet-name>SpringMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		
		<init-param>
			<param-name>contextClass</param-name>
			<param-value>
				org.springframework.web.context.support.AnnotationConfigWebApplicationContext
			</param-value>
		</init-param>
		
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>io.mykit.cache.redis.spring.utils.config.SpringMVCConfig</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

3.需要使用Spring+Memcached集群配置缓存

1、需要在工程的pom.xml中引用

<dependency>
    <groupId>io.mykit.cache</groupId>
    <artifactId>mykit-cache-memcached-spring-simple-xml</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

注意:框架的此模块不支持主动刷新缓存,底层核心使用的是simple-spring-memcached内核。

2、使用方法

1)在自身项目的classpath:properties目录下新建Memcached的配置文件,比如:memcached.properties文件,配置连接Memcached的属性;

属性配置如下:

#simple memcached config
simple.memcache.server=127.0.0.1:12000
simple.memcache.consistenthashing=true
simple.memcache.connectionpoolsize=1
simple.memcache.optimizeget=false
simple.memcache.optimizemergebuffer=false
simple.memcache.mergefactor=50
simple.memcache.usebinaryprotocol=true
simple.memcache.connectiontimeout=3000
simple.memcache.operationtimeout=2000
simple.memcache.enableheartbeat=true
simple.memcache.failureMode=false

注意:自定义的memcached文件的属性,必须和memcached-default.properties默认配置的属性key相同,也就是和上述配置的key相同,但可以不用覆盖上述完整的配置,

可以只配置:

simple.memcache.server=192.168.209.121:12000

来覆盖simple.memcache.server属性

2)在自身项目的classpath目录下新建spring配置文件,比如:spring-context.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:aop="http://www.springframework.org/schema/aop"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:cache="http://www.springframework.org/schema/cache"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.2.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
                        http://www.springframework.org/schema/cache
                        http://www.springframework.org/schema/cache/spring-cache-4.2.xsd以上是关于撸完Spring源码,我为Spring写了个分布式缓存插件,现已开源,快要裂开了!!(建议收藏)的主要内容,如果未能解决你的问题,请参考以下文章

撸完Spring源码,我开源了这个分布式缓存框架!!(建议收藏)

撸完Dubbo源码,我总结了这些阅读源码的技巧!!

撸完Dubbo源码,冰河总结了这些阅读源码的技巧,赶快收藏

撸完Dubbo源码,冰河总结了这些阅读源码的技巧,赶快收藏

vue + spring boot + spring security 前后端分离 携带 Cookie 登录实现 只写了个登录

spring4.3.7整合mongodb3.2.1