Memcached之——整合Spring完整示例

最新推荐文章于 2024-07-09 18:04:04 发布
最新推荐文章于 2024-07-09 18:04:04 发布
阅读量1.4w 收藏 13
点赞数 6
分类专栏： 精通Spring全家桶系列 精通J2EE系列 精通分布式缓存系列 文章标签： memcached spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l1028386804/article/details/48464111
版权 
转载请注明出处:http://blog.csdn.net/l1028386804/article/details/48464111

在前面的几篇博文中，我们记录了Memcached整合Spring的一些方法，现在我们就基于这些方法实现一个Memcached整合Spring的完整示例，好了不多说了，我们直接上代码吧。

一、配置

1、MemcachedCacheManager

package com.cdsmartlink.framework.cache.memcached;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.springframework.cache.Cache;
import org.springframework.cache.transaction.AbstractTransactionSupportingCacheManager;

import com.danga.MemCached.MemCachedClient;

/**
 * Spring Cache整合Memcached实现 
 * @author liuyazhuang
 */
public class MemcachedCacheManager extends AbstractTransactionSupportingCacheManager {

	private ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>();
	private Map<String, Integer> expireMap = new HashMap<String, Integer>();   //缓存的时间
	private MemCachedClient memcachedClient;   //memcached的客户端

	public MemcachedCacheManager() {
	}

	@Override
	protected Collection<? extends Cache> loadCaches() {
		Collection<Cache> values = cacheMap.values();
		return values;
	}

	@Override
	public Cache getCache(String name) {
		Cache cache = cacheMap.get(name);
		if (cache == null) {
			Integer expire = expireMap.get(name);
			if (expire == null) {
				expire = 0;
				expireMap.put(name, expire);
			}
			cache = new MemcachedCache(name, expire.intValue(), memcachedClient);
			cacheMap.put(name, cache);
		}
		return cache;
	}

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

	public void setConfigMap(Map<String, Integer> configMap) {
		this.expireMap = configMap;
	}

}

2、MemcachedCache

package com.cdsmartlink.framework.cache.memcached;

import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;

import com.danga.MemCached.MemCachedClient;

/**
 * MemcachedCache的实现，主要实现spring的cache接口
 * @author liuyazhuang
 *
 */
public class MemcachedCache implements Cache {

	private final String name;
	private final MemCache memCache;

	public MemcachedCache(String name, int expire, MemCachedClient memcachedClient) {
		this.name = name;
		this.memCache = new MemCache(name, expire, memcachedClient);
	}

	@Override
	public void clear() {
		memCache.clear();
	}

	@Override
	public void evict(Object key) {
		memCache.delete(key.toString());
	}

	@Override
	public ValueWrapper get(Object key) {
		ValueWrapper wrapper = null;
		Object value = memCache.get(key.toString());
		if (value != null) {
			wrapper = new SimpleValueWrapper(value);
		}
		return wrapper;
	}

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

	@Override
	public MemCache getNativeCache() {
		return this.memCache;
	}

	@Override
	public void put(Object key, Object value) {
		memCache.put(key.toString(), value);
	}

	@Override
	@SuppressWarnings("unchecked")
	public <T> T get(Object key, Class<T> type) {
		Object cacheValue = this.memCache.get(key.toString());
		Object value = (cacheValue != null ? cacheValue : null);
		if (type != null && !type.isInstance(value)) {
			throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);
		}
		return (T) value;
	}

}

3、MemCache

package com.cdsmartlink.framework.cache.memcached;

import java.util.HashSet;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.danga.MemCached.MemCachedClient;

/**
 * Memcached的封装类
 * @author liuyazhuang
 *
 */
public class MemCache {
	private static Logger log = LoggerFactory.getLogger(MemCache.class);

	private Set<String> keySet = new HashSet<String>();
	private final String name;
	private final int expire;
	private final MemCachedClient memcachedClient;

	public MemCache(String name, int expire, MemCachedClient memcachedClient) {
		this.name = name;
		this.expire = expire;
		this.memcachedClient = memcachedClient;
	}

	public Object get(String key) {
		Object value = null;
		try {
			key = this.getKey(key);
			value = memcachedClient.get(key);
		} catch (Exception e) {
			log.warn("获取 Memcached 缓存超时", e);
		}
		return value;
	}

	public void put(String key, Object value) {
		if (value == null)
			return;
		try {
			key = this.getKey(key);
			memcachedClient.set(key, value, expire);
			keySet.add(key);
		}catch (Exception e) {
			log.warn("更新 Memcached 缓存错误", e);
		}
	}

	public void clear() {
		for (String key : keySet) {
			try {
				memcachedClient.delete(this.getKey(key));
			}catch (Exception e) {
				log.warn("删除 Memcached 缓存错误", e);
			}
		}
	}

	public void delete(String key) {
		try {
			key = this.getKey(key);
			memcachedClient.delete(key);
		} catch (Exception e) {
			log.warn("删除 Memcached 缓存被中断", e);
		}
	}

	private String getKey(String key) {
		return name + "_" + key;
	}
}

4、applicationContext-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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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.0.xsd
 						http://www.springframework.org/schema/context 
 						http://www.springframework.org/schema/context/spring-context-3.0.xsd
 						http://www.springframework.org/schema/tx 
 						http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
 						http://www.springframework.org/schema/aop 
 						http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 						http://www.springframework.org/schema/mvc 
						http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
						http://www.springframework.org/schema/cache 
						http://www.springframework.org/schema/cache/spring-cache-3.2.xsd">

      <!-- 扫描项目包的根路径 -->
    <context:component-scan base-package="com.cdsmartlink" />
    <context:component-scan base-package="com.cdsmartlink.utils.dao.base.impl"/>
    
 	<!-- ===================================  配置Memcached =============================== -->
 	 <!-- 开启缓存 -->  
   <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true" />  
    <!-- 导入外部properties -->
    <context:property-placeholder location="classpath:memcached.properties"/>
    
 	 <bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"
		factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
	   <constructor-arg>
			<value>neeaMemcachedPool</value>
		</constructor-arg>
		<property name="servers">
			<list>
				<value>${memcache.server}</value>
			</list>
		</property>
		<property name="initConn">
			<value>${memcache.initConn}</value>
		</property>
		<property name="minConn">
			<value>${memcache.minConn}</value>
		</property>
		<property name="maxConn">
			<value>${memcache.maxConn}</value>
		</property>
		<property name="maintSleep">
			<value>${memcache.maintSleep}</value>
		</property>
		<property name="nagle">
			<value>${memcache.nagle}</value>
		</property>
		<property name="socketTO">
			<value>${memcache.socketTO}</value>
		</property>
	</bean>
	
	<!-- 配置MemcachedClient -->
	<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
		<constructor-arg>
			<value>neeaMemcachedPool</value>
		</constructor-arg>
	</bean>
	
	<!-- 配置缓存管理 -->
	<bean id="cacheManager" class="com.cdsmartlink.framework.cache.memcached.MemcachedCacheManager">
		<property name="memcachedClient" ref="memcachedClient"/>
		<!-- 配置缓存时间 --> 
		<property name="configMap">
			 <map>
			 	 <!-- key缓存对象名称   value缓存过期时间 --> 
			 	 <entry key="systemCache" value="3600"/>
			 </map>
		</property>
	</bean>
	
 	<!-- 导入调度任务 -->
 	<!-- <import resource="spring-quartz.xml" /> -->
</beans>

5、memcached.properties

#Memcached基本配置
memcache.server=192.168.254.120:12000
memcache.initConn=20  
memcache.minConn=10  
memcache.maxConn=50  
memcache.maintSleep=3000  
memcache.nagle=false  
memcache.socketTO=3000

6、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" 
		xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" 
		id="WebApp_ID" version="3.0">
  <display-name>Smartlink</display-name>
  
  <!-- 配置spring监听器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	 <!-- 配置初始化监听 -->
    <listener>
        <listener-class>com.cdsmartlink.utils.listener.WebServerStartListener</listener-class>
    </listener>
	
	
	<!-- 加载配置文件路径 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath*:applicationContext*.xml</param-value>
	</context-param>
	
	<!-- springmvc配置 -->
	<servlet>
		<servlet-name>smartlink</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>smartlink</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
	<!-- 配置OpenSessionInView -->
	<filter>
        <filter-name>hibernateFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
        <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
        <init-param>
            <param-name>singleSession</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
	
	<filter-mapping>
		<filter-name>hibernateFilter</filter-name>
		<url-pattern>/*</url-pattern>
	 </filter-mapping>
	
	<!-- 字符编码过滤器 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
     
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
   <error-page>
        <error-code>404</error-code>
        <location>/static/html/page_404/404.html</location>
    </error-page>
</web-app>

二、使用示例

1、CacheBaseService

package com.cdsmartlink.utils.service;

import java.io.Serializable;

/**
 * 带有缓存的service
 * @author liuyazhuang
 *
 * @param <T>
 */
public interface CacheBaseService<T> extends SinglePKBaseService<T>{
	T get(Serializable id);

	void save(T[] entity) ;
	
	void save(T entity) ;
	
	Serializable saveObj(T entity);
	
	void update(T entity) ;

	void delete(T entity) ;
	
	public int delete(Serializable id) ;

	public void delete(Serializable... id) ;
	
}

2、CacheBaseServiceImpl

package com.cdsmartlink.utils.service.impl;

import java.io.Serializable;

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;

import com.cdsmartlink.utils.service.CacheBaseService;
public abstract class CacheBaseServiceImpl<T> extends SinglePKBaseServiceImpl<T> implements CacheBaseService<T>{
	
	@Override
	@CachePut(value="systemCache")
	public T get(Serializable id){
		return super.get(id);
	}
	
	@Override
	@CacheEvict(value="systemCache", allEntries = true, beforeInvocation = true)
	public void save(T[] entity) {
		 super.save(entity);
	}
	
	@Override
	@CacheEvict(value="systemCache", allEntries = true, beforeInvocation = true)
	public void save(T entity){
		super.save(entity);
	}
	
	@Override
	@CacheEvict(value="systemCache", allEntries = true, beforeInvocation = true)
	public Serializable saveObj(T entity){
		return super.saveObj(entity);
	}
	
	@Override
	@CacheEvict(value="systemCache", allEntries = true, beforeInvocation = true)
	public void update(T entity){
		super.update(entity);
	}

	@Override
	@CacheEvict(value="systemCache", allEntries = true, beforeInvocation = true)
	public void delete(T entity){
		super.delete(entity);
	}
	
	@Override
	@CacheEvict(value="systemCache", beforeInvocation = true)
	public int delete(Serializable id){
		return super.delete(id);
	}

	@Override
	@CacheEvict(value="systemCache", allEntries = true, beforeInvocation = true)
	public void delete(Serializable... id){
		super.delete(id);
	}
}
3、StoreAdvertmentService

package com.cdsmartlink.system.store.service;

import java.util.List;

import com.cdsmartlink.system.store.entity.StoreAdvertment;
import com.cdsmartlink.utils.service.CacheBaseService;

/**
 * 商家广告service
 * @author liuyazhuang
 *
 */
public interface StoreAdvertmentService extends CacheBaseService<StoreAdvertment> {
	
	/**
	 * 缓存key的前缀
	 */
	String STORE_AD = "store_ad_";
	
	/**
	 * 获取广告图
	 * @param storeId
	 * @param type
	 * @param limit
	 * @return
	 */
	List<StoreAdvertment> getStoreAdvertments(Long storeId, Integer type, int limit);
}

4、StoreAdvertmentServiceImpl

package com.cdsmartlink.system.store.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.cdsmartlink.system.store.dao.StoreAdvertmentDao;
import com.cdsmartlink.system.store.entity.StoreAdvertment;
import com.cdsmartlink.system.store.service.StoreAdvertmentService;
import com.cdsmartlink.utils.dao.QueryMode;
import com.cdsmartlink.utils.dao.QueryParse;
import com.cdsmartlink.utils.dao.base.BaseDao;
import com.cdsmartlink.utils.service.impl.CacheBaseServiceImpl;
@Service
public class StoreAdvertmentServiceImpl extends CacheBaseServiceImpl<StoreAdvertment> implements
		StoreAdvertmentService {
	@Resource
	private StoreAdvertmentDao storeAdvertmentDao;
	@Override
	protected BaseDao<StoreAdvertment> getDao() {
		return storeAdvertmentDao;
	}

	@Override
	protected void setQueryParse(QueryParse<StoreAdvertment> qp,
			QueryMode queryMode) {
		
	}

	@Override
	@Cacheable(value=SYSTEM_CACHE, key="'store_ad_'+ #storeId")//store_ad_为key的自定义字符串前缀，这个前缀可以根据具体业务设定，以免和其他缓存数据冲突，注意，这个字符串前缀要用单引号''括起来，否则会报错
	public List<StoreAdvertment> getStoreAdvertments(Long storeId, Integer type, int limit) {
		return storeAdvertmentDao.getStoreAdvertments(storeId, type, limit);
	}

}

冰 河
关注
专栏目录
MyBatis和Dubbo深度整合——深度分析MyBatis+Dubbo项目架构设计
程序员光剑
07-28 1098
1.1 Mybatis 是什么？Mybatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。Mybatis 避免了几乎所有的 JDBC 代码以及参数处理，非常适合开发人员编写灵活可移植性强的代码，屏蔽了数据库底层实现的差异性。Mybatis 可以直接作用在 XML 配置文件中，将复杂的JDBC操作抽象出来，使数据库相关操作对应用层来说是透明的，并可以定制化地调整性能。1.2 Apache Dubbo 是什么？
springMVC+memcached整合
12-29
此工程为 springMVC+memcached整合 项目。 resources\config\memcached.xml为 memcached配置文件。test\cn\sky\tian\test\spring为Demo的路径。 （里面有个src\cn\sky\tian\test\controller路径是MengoDB的demo，也被整合到里面了。）希望能对初学者有所帮助。
SpringBoot整合Memcached缓存
博客
05-06 538
研究一下国内比较流行的一款缓存memcached windows版安装包下载地址：https://www.runoob.com/memcached/window-install-memcached.html 下载的安装包是解压缩就能使用的zip文件，解压缩完毕后会得到如下文件 可执行文件只有一个memcached.exe，使用该文件可以将memcached作为系统服务启动，执行此文件时会出现报错信息，如下： 此处出现问题的原因是注册系统服务时需要使用管理员权限，当前账号权限不足导致安装服务失败，切换
Memcached 介绍与详解及在Java Spring Boot项目中的使用与集成
最新发布
招风的黑耳CSDN
07-09 861
Memcached 是一种高性能的分布式内存对象缓存系统，主要用于加速动态Web应用以减少数据库负载，从而提高访问速度和性能。作为一个开源项目，Memcached 被广泛应用于许多大型互联网公司，如Facebook、Twitter 和 YouTube 等。Memcached 通过将数据存储在内存中，并使用高效的哈希算法来进行数据存取，提供了极高的读写性能。
memcached与spring集成
weixin_34087301的博客
06-02 97
一、背景 销售CRM（项目A）将负责管理项目信息系统(项目B)的支付与权限 上级要求为避免频繁调用CRM接口，中间放一级缓存，但要做到缓存中保证最新数据 因项目B已使用memcache作缓存，所以决定使用memcache 二、设计 1、统一系统交互方式，确保系统与系统间调用只有一个接口，接口参数为(String action, String data)，以action区别调用是什么方法 ...
spring缓存集成memcache
yydcj的专栏
08-30 969
spring3.1.0开始支持注解方式的缓存实现，非常方便，不过它目前只支持java内置的ConcurrentMap和ehcache这两种缓存方式，因为项目用到memcache，就想把memcache集成到spring内置的缓存中，使memcache也能用注解方式来调用。于是参考ehcache的集成方式，把memcache集成到项目中。spring把所有缓存都抽象为一个cache，相当于一个缓存集
Spring与Memcache整合（原创及优秀memcache整理）
wangsx的博客
12-19 4052
0.Memcached目前有三中java客户端程序：        1-1.官方提供的基于传统阻塞Io 由Greg Whalin维护的客户端】        1-2.Dustin Sallings实现的基于java nio的Spymemcached        1-3.XMemcached 三种java客户端具体的区别见：http://jingyan.baidu.com/
Ehcache+xmemcached+redis 整合spring注解demo
01-28
本项目" Ehcache+xmemcached+redis 整合spring注解demo"旨在演示如何将这三种主流的缓存技术——Ehcache、xmemcached和Redis——与Spring框架的注解功能相结合，以实现高效、灵活的缓存管理。以下是对这些知识点的...
SpringBoot学习示例—Redis多个实例简单的手动配置之整合Lettuce池(附完整项目代码)
jack_wang001的专栏
11-17 1176
1. Redis整合Lettuce池配置多个实例 2. 快速上手 3. 测试效果 1. Redis整合Lettuce池配置多个实例 Redis 是目前业界使用最广泛的内存数据存储。相比 Memcached，Redis 支持更丰富的数据结构，例如 hashes, lists, sets ，sortedsets等。数据库有分库分表，当然redis也能实现mysql一样的分库逻辑。本文介绍 Redis 在 Spring Boot 中分库的应用场景。 2. 快速上手 1、引入依...
simple-spring-memcached统一缓存的使用实例[整理].pdf
10-20
Simple-Spring-Memcached（SSM）是一个流行的缓存框架，它整合了Spring框架与Memcached，提供了一种统一的方式来处理缓存操作。本文将详细介绍如何在实际应用中使用SSM进行统一缓存管理，并分享在规划和配置过程中...
详解比springSecurity和shiro更简单优雅的轻量级Sa-Token框架，比如登录认证,权限认证,单点登录,OAuth2.0,分布式Session会话,微服务网关鉴权
念兮为美
08-30 3948
详解比springSecurity和shiro更简单优雅的轻量级Sa-Token框架，比如登录认证,权限认证,单点登录,OAuth2.0,分布式Session会话,微服务网关鉴权。演示SpringBoot集成Sa-Token和Spring WebFlux集成Sa-Token这两个常用的开发框架。......
spring_memcache
02-22
本人亲自搭建的spring和memcache缓存的项目，项目中说明也很详细，用的是oracle数据库。要是下载着使用的是其他数据库相信你也能快速改用，也可以在service层直接返回数据。目的在于怎么使用memcache。使用之前麻烦自己先下载memcache的客户端，自己启动后运行程序测试。本人测试使用的是jboss，其他也可以。本人测试全部通过。
Spring Memcache整合
06-28 1084
https://github.com/gwhalin/Memcached-Java-Client/downloads 上面下载 jar包 spring 配置文件 XML/HTML code ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 1
memcached和spring集成
热门推荐
zhsj1106的专栏
08-17 1万+
memcached和spring集成（主要说spring和memcached的集成，spring本身的东东就不多说啦） 本文demo下载http://download.csdn.net/detail/zhsj1106/4507631 接上篇 ：在linux服务器上安装memcached  http://blog.csdn.net/zhsj1106/article/details/7877542
memcache与spring集成
活在马尼拉
01-13 352
一、前期准备 1)  下载memcached服务端memcached-1.2.6-win32-bin.zip，地址：http://code.jellycan.com/memcached/ 2)  下载java版客户端 java_memcached-release_2.6.1.zip 3)  解压缩memcached-1.2.6-win32-bin.zip到指定目录，例如：D:\memca
Spring整合Memcache
逍遥飞鹤的专栏
01-06 1614
Spring集成memcache 学习了memcache，这是个好东西，分享一下自己的小实例，也方便以后查找使用 一、前期准备 1)  下载memcached服务端memcached-1.2.6-win32-bin.zip，地址：http://code.jellycan.com/memcached/ 2)  下载java版客户端 java_memcached-release
spring boot整合memcache
weixin_34356138的博客
08-31 275
1.导入memcached客户端jar包 <dependency> <groupId>com.whalin</groupId> <artifactId>Memcached-Java-Client</artifactId> <version>3.0.2</version> &lt...
Springboot 整合 memcache
qq_45441466的博客
07-04 1153
Memcache介绍   首先来说Memcache是一个开源高性能的分布式内存对象key-value缓存系统，用于加速动态的Web应用，从而减轻数据库的负载能力，在工作场景中很多人把它当做一个内存式的数据库在使用。那么内存式到底是什么呢？我们都知道，在计算机主要靠CPU来进行计算，内存用来存储CPU操作的数据。在计算机硬件中还有一个叫做硬盘的东西。那么这三者之间是怎么交互的。首先要知道计算机内存式有限的，这个是不可否认的，其次CPU的计算速度与内存以及外部存储之间是存在一定的差距的，所以就使用了一种高速
Spring整合Memcached配置与使用示例
“Java Web应用程序使用Memcached的实例，通过Spring框架进行集成配置。” 在Java Web开发中，缓存技术是提高应用性能和响应速度的关键工具之一。Memcached是一款广泛使用的分布式内存对象缓存系统，它能够存储和...
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰 河

可以吃鸡腿么？

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值