ibatis基础上添加memcached缓存

最新推荐文章于 2024-11-08 16:24:50 发布
最新推荐文章于 2024-11-08 16:24:50 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： Memcached 文章标签： ibatis memcached exception object string null

 

在ibatis源码基础上修改，增加对memcached支持，通过配置IBatis的xml文件即可实现memcached细粒度话缓存，使用简单，缓存效果好。 spring下首先初始化MemcachedManager对象,或者通过程序初始化也一样,不要用ibatis官方的jar包,否则会冲突

<bean class="com.ibatis.sqlmap.engine.cache.memcached.memcachedManager" lazy-init="false"

init-method="init" destroy-method="closePool"> 
<property name="serverlist">

<value>
192.168.0.1:11111, 192.168.0.2:11111 
</value>

</property>

<property name="initConn" value="5">

</property>

<property name="minConn" value="5">

</property>

<property name="maxConn" value="200">

</property>

Unknown end tag for </bean>

 

然后配置sqlMapConfig.xml文件: <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE sqlMapConfig PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"

" http://ibatis-with-memcached.googlecode.com/files/sql-map-config-2.dtd"> #注意这里,不用官方的,这个dtd文件加了个新属性databaseUrl,区分不同数据库的缓存对象

 

 

<sqlmapconfig>

<properties resource="cache_config.properties">

</properties>
<settings
cacheModelsEnabled="true" enhancementEnabled="true" lazyLoadingEnabled="true" maxRequests="256" maxSessions="256" maxTransactions="150" useStatementNamespaces="true" databaseUrl="数据库名或地址" #新增加的属性 />

ibatis的xml文件:Albums.xml #创建缓存model 

<cachemodel type="MEMCACHED" id="albumsCache">

<flushinterval hours="12">
</flushInterval > 
<flushonexecute statement="albums.save">
</flushOnExecute > 
<flushonexecute statement="albums.update">
</flushOnExecute > 
<flushonexecute statement="albums.delete">
</flushOnExecute > 
<property name="pk" value="id">

</property>
#可以根据主键进行缓存,可以设置为空,不能不设 
<property name="groupField" value="accId">

</property>
#可以根据组(比如用户id)进行缓存,更加细粒度化,可以设置为空,不能不设

Unknown end tag for </cachemodel>

#加入缓存 

<select id="findall" parameterClass="albumsObj" resultClass="albumsObj" cacheModel="albumsCache">
Select ……from albums where accId=1 
</select>

<select id="load" parameterClass="albumsObj" resultClass="albumsObj" cacheModel="albumsCache">
Select ……from albums where id=1 
</select>

 

#删除对象,删除缓存

<delete id="delete" parameterClass="albumsObj">
delete from albums where id=1 and accId=1 #(加上accId可以删除分组缓存) 
</delete>

package com.ibatis.sqlmap.engine.cache.memcached; 
 
import java.io.Serializable; 
import java.util.Collection; 
import java.util.Date; 
import java.util.Map; 
 
import org.apache.log4j.Logger; 
 
import com.danga.MemCached.MemCachedClient; 
import com.danga.MemCached.SockIOPool; 
 
 
public class MemcachedManager { 
 
        private static Logger logger = Logger.getLogger(MemcachedManager.class); 
 
        private static String memcachedDomain = "IBATIS_CACHED"; // memcached 域名 
 
        private String serverlist; 
 
        private static MemCachedClient mcc = null; 
 
        private SockIOPool pool = null; 
 
        private int initConn = 5; 
 
        private int minConn = 5; 
 
        private int maxConn = 50; 
 
         
        public void init() { 
                if (mcc != null) 
                        return; 
 
                logger.info("Initializing ibatis memcached start."); 
                if (pool == null) { 
                        try { 
                                pool = SockIOPool.getInstance(memcachedDomain); 
                                pool.setServers(serverlist.split(",")); 
                                if (!pool.isInitialized()) { 
                                        pool.setInitConn(initConn); 
                                        pool.setMinConn(minConn); 
                                        pool.setMaxConn(maxConn); 
                                        pool.setMaintSleep(30); 
                                        pool.setNagle(false); 
                                        pool.setSocketTO(60 * 60); 
                                        pool.setSocketConnectTO(0); 
                                        pool.initialize(); 
                                } 
                        } catch (Exception ex) { 
                                logger.error(ex.getMessage()); 
                        } 
                } 
 
                if (mcc == null) { 
                        mcc = new MemCachedClient(memcachedDomain); 
                        mcc.setCompressEnable(false); 
                        mcc.setCompressThreshold(0); 
                } 
                logger.info("Initializing youxigu Memcached ok!"); 
        } 
 
         
        public void closePool() { 
                pool.shutDown(); 
                mcc = null; 
                pool = null; 
                logger.info("Ibatis memcached pool closed"); 
        } 
 
         
        public static boolean set(Object key, Serializable obj) { 
                logger.debug("set key:" + getKey(key) + ", value:" + obj); 
                try { 
                        return mcc.set(getKey(key), obj); 
                } catch (Exception e) { 
                        logger.error("Pool set error!"); 
                        e.printStackTrace(); 
                } 
                return false; 
        } 
 
         
        public static boolean set(Object key, Serializable obj, long cacheTime) { 
                try { 
                        return mcc.set(getKey(key), obj, new Date(cacheTime)); 
                } catch (Exception e) { 
                        logger.error("Pool set error!"); 
                        e.printStackTrace(); 
                } 
                return false; 
        } 
 
         
        public static void replace(int key, Serializable value, long cacheTime) { 
                try { 
                        mcc.replace(getKey(key), value, new Date(cacheTime)); 
                } catch (Exception e) { 
                        logger.error(" pool set error!"); 
                } 
        } 
 
         
        public static Object get(Object key) { 
                Object result = null; 
                String realkey = getKey(key); 
                try { 
                        result = mcc.get(realkey); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
                logger.debug("get key:" + getKey(key) + ", value:" + result); 
                return result; 
        } 
 
         
        public static void setCounter(Object key, long count) { 
                try { 
                        mcc.storeCounter(getCountKey(key), count); 
                } catch (Exception e) { 
                        logger.error("Pool setCounter error!"); 
                } 
        } 
 
         
        public static void addCounter(Object key) { 
                if(mcc.get(getCountKey(key))==null){ 
                        mcc.storeCounter(getCountKey(key), 0); 
                } 
                try { 
                        mcc.incr(getCountKey(key)); 
                } catch (Exception e) { 
                        logger.error("Pool setCounter error!"); 
                } 
        } 
 
         
        public static void decreaseCounter(Object key) { 
                try { 
                        mcc.decr(getCountKey(key)); 
                } catch (Exception e) { 
                        logger.error("Pool setCounter error!"); 
                } 
        } 
 
         
        public static void addCounter(Object key, long addValue) { 
                try { 
                        mcc.incr(getCountKey(key), addValue); 
                } catch (Exception e) { 
                        logger.error(" pool setCounter error!"); 
                } 
        } 
 
         
        public static long getCounter(Object key) { 
                long result = 0; 
                try { 
                        result = mcc.getCounter(getCountKey(key)); 
                } catch (Exception e) { 
                        logger.error(e.getMessage()); 
                } 
                return result; 
        } 
 
         
        public static boolean delete(Object key) { 
                try { 
                        return mcc.delete(getKey(key)); 
                } catch (Exception e) { 
                        logger.error(e.getMessage()); 
                } 
                return false; 
        } 
 
         
        public static long deleteCounter(Object key) { 
                try { 
                        return mcc.decr(getCountKey(key)); 
                } catch (Exception e) { 
                        logger.error(" pool setCounter error!"); 
                } 
                return 0;  
        } 
 
         
        public static void flushAll() { 
                mcc.flushAll(); 
        } 
         
        @SuppressWarnings("unchecked") 
        public static long size(){ 
                long size=0L; 
                Map<String,Map<String,String>> status=mcc.statsItems(); 
                Collection<Map<String,String>> values=status.values(); 
                for (Map<String,String> state:values) { 
                        String num=state.get("items:1:number"); 
                        if(num==null) 
                                continue; 
                         
                        size+=Long.parseLong(state.get("items:1:number")); 
                } 
                return size; 
        } 
 
         
        private static String getKey(Object key) { 
                return memcachedDomain + "@" + key; 
        } 
 
        private static String getCountKey(Object key) { 
                return memcachedDomain + "@" + key + "_count"; 
        } 
 
         
        public void setServerlist(String serverlist) { 
                this.serverlist = serverlist; 
        } 
 
         
        public void setInitConn(int initConn) { 
                this.initConn = initConn; 
        } 
 
         
        public void setMinConn(int minConn) { 
                this.minConn = minConn; 
        } 
 
         
        public void setMaxConn(int maxConn) { 
                this.maxConn = maxConn; 
        } 
 
         
        public void setMemcachedDomain(String memcachedKey) { 
                MemcachedManager.memcachedDomain = memcachedKey; 
        } 
} 

a9529lty
关注
专栏目录
java memcached缓存怎么测试_MemCached缓存操作
weixin_39806603的博客
02-24 169
Web项目在运行时，通常需要从数据库中进行读写。随着操作数据量的增大，以及访问量的集中，数据库的负载增加，数据库响应变慢，网站访问速度变慢的情况。Memcached就是用来解决这些问题的。Memcached是一个开源的高性能的分布式缓存系统。主要用于减轻数据库负载，加速Web应用访问。它是基于内存的Key-Value存储系统，主要存储Value较小的数据，Value大小不能超过1M。总的来说，Me...
ibatis加memcached缓存
weixin_34290000的博客
11-05 94
在ibatis源码基础上修改，增加对memcached支持，通过配置IBatis的xml文件即可实现memcached细粒度话缓存，使用简单，缓 存效果好。 spring下首先初始化MemcachedManager对象,或者通过程序初始化也一样,不要用ibatis官方的jar包,否则会冲突 Java代码 <bean class="com.ibatis.s...
MemCached缓存操作
李章勇的博客
12-27 2539
　　Web项目在运行时，通常需要从数据库中进行读写。随着操作数据量的增大，以及访问量的集中，数据库的负载增加，数据库响应变慢，网站访问速度变慢的情况。Memcached就是用来解决这些问题的。 　　Memcached是一个开源的高性能的分布式缓存系统。主要用于减轻数据库负载，加速Web应用访问。它是基于内存的Key-Value存储系统，主要存储Value较小的数据，Value大小不能超过1M。总...
iBATIS缓存
Mov
09-05 159
  一．缓存介绍 1.1缓存对象 理论上，Web分层设计的各个层都可以有缓存，Web中的任何对象都可以缓存。 Http请求结果的缓存 浏览器缓存、代理缓存、服务器端方向代理缓存、使用Filter实现对请求结果页面的缓存 Java对象的缓存 缓存数据库查询结果对象 1.2缓存介质[保存在哪里] 从硬件介质上来将无非就是两种,内存和硬盘(对应应用层的程序来讲不...
java使用memcached缓存
sdaddasd的博客
06-22 251
服务器端安装,部署,启动: [code="linux"] 1.下载libevent,安装libevent cd /tmp wget https://github.com/downloads/libevent/libevent/libevent-2.0.21-stable.tar.gz tar -zxvf libevent-2.0.21-stable.tar.gz cd libeve...
ibatis缓存介绍
10-22 2429
一．缓存介绍 1.1缓存对象 理论上，Web分层设计的各个层都可以有缓存，Web中的任何对象都可以缓存。 Http请求结果的缓存 浏览器缓存、代理缓存、服务器端方向代理缓存、使用Filter实现对请求结果页面的缓存 Java对象的缓存 缓存数据库查询结果对象 1.2缓存介质[保存在哪里] 从硬件介质上来将无非就是两种,内存和硬盘(对应应用层的程序来讲不用考虑寄存器等问题).但是往往
ibatis_with_memcached
03-01
本项目"ibatis_with_memcached"就是关于如何将Ibatis与Memcached集成，实现高效的数据库缓存策略的实例。 Ibatis是一个基于Java的SQL映射框架，它允许开发者编写SQL语句并与Java对象进行绑定，从而避免了传统的JDBC...
基于 Spring和 Memcached的 iBATIS二级 缓存的研究与应用 (2009年)
05-16
高性能是J2EE应用程序追求的目标,在特定硬件基础上,数据...在对 iBATIS的缓存支持情况进行了介绍和研究的基础上,并结合Spring框架和iBATIS,使用Memcached对iBATIS二级缓存进行了新的实现,使应用的性能得到了很大的提升.
ibatis memcached
12-13
标题中的“ibatis memcached”指的是将MyBatis（原名iBATIS）这个流行的Java持久层框架与Memcached这个分布式内存对象缓存系统相结合，实现数据的高效缓存管理。这种集成允许开发者将MyBatis的二级缓存功能扩展到...
Ibatis整合Memcached缓存配置详解
这里使用的`<cacheModel type="MEMCACHED" id="albumsCache">`定义了一个名为`albumsCache`的Memcached缓存模型。`flushInterval`属性设定了缓存的刷新间隔，这里是12小时。`flushOnExecute`元素则指定了在执行特定...
【赵渝强老师】安装部署Memcached
赵渝强老师CSDN博客主页
11-06 166
Memcached通过在内存里维护一个统一的巨大的Hash表来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。下面以Memcached 1.6.15来演示如何安装，在其官方的网站上提供了下面的地址和安装部署的说明。（9）编辑文件/etc/profile设置Memcached的环境变量，在文件最后添加下面的内容。（2）下载Memcached的安装包文件：memcached-1.6.15.tar.gz。（6）配置Memcached的安装目录。（7）执行Memcached的安装。
【赵渝强老师】Memcached的数据存储方式
赵渝强老师CSDN博客主页
11-05 123
Memcached是一个高性能的分布式的内存对象缓存系统。Memcached通过在内存里维护一个统一的巨大的Hash表来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。但是Memcached不能将数据进行持久化，因此严格意义来说，Memcached只能叫做一个缓存技术，而不能叫做数据库。然后在1M的Slab空间里根据保存数据的大小再划分相同大小的Chunk。换句话说，Memcached在保存数据之前需要先为数据分片内存存储的空间。下图说明了Memcached的数据存储方式。
初识Redis
m0_53926113的博客
11-08 873
通常，内存数据库在性能要求高、访问频繁的系统中广泛应用，比如电商网站中的商品浏览记录，社交平台的用户会话数据等等。：因为支持丰富的数据结构、持久化、分布式等特性，Redis 更适合需要持久化的数据、复杂的操作或分布式架构的场景。在现代的应用中，数据库（如 MySQL）通常是数据存储的核心，但由于数据库的查询速度不如内存，直接访问数据库会影响应用的响应速度。由于 Redis 的内存数据库特性，它能实现对热点数据的快速响应，避免 MySQL 反复查询相同的数据，提升了用户的使用体验。
分布式技术缓存技术
最新发布
wlq_567的博客
11-08 860
分布式缓存就是指在分布式环境或系统下，把一些热门数据存储到离用户近、离应用近的位置，并尽量存储到更快的设备，以减少远程数据传输的延迟，让用户和应用可以很快访问到想要的数据。这种方式有一个明显的缺点，是会造成数据丢失，即当节点出现故障时，新数据可能还未备份到磁盘中。Redis 是一个基于内存的 key-value 数据库，为了方便支持多应用的缓存，比如缓存文本类型、数据库的查询结果（字段与字段对应的值）等等，支持的数据结构不仅有简单的 k／v 类型，还可以支持 List、Set、Hash 等复杂类型的存储。
问：说说Memcached与Redis缓存的区别？
FIN技术铺掌柜的。
11-06 862
Memcached和Redis是两种流行的内存缓存系统，各有优势。Memcached适用于快速读取大量小数据，支持多线程，但数据类型单一，无持久化，内存管理可能导致碎片。Redis则支持丰富数据类型，提供持久化和事务，单线程模型保证高性能和一致性，内存管理相对简单。选择时需根据应用需求、数据类型、持久化要求及性能考虑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值