spring+mybatis+ehcache 注解

最新推荐文章于 2024-03-30 06:35:07 发布
最新推荐文章于 2024-03-30 06:35:07 发布
阅读量8.4k 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/etttttss/article/details/17245507
版权

package com.zxh.customer.hashmap.dao;

import java.util.List;
import java.util.Map;
/**
 *
 * @author Administrator
 *
 * @param <T>
 */
public interface IBaseDao {
    /**
     * 单表插入记录
     * @param obj
     */
 public  <T>  int insert(String _mybitsId,  T obj);
 /**
  * 更新单表
  * @param obj
  */
 public  <T>  int update(String _mybitsId, T obj);
    /**
     * 删除记录
     * @param clz
     * @param id
     */
 public  <T>  int delete(String _mybitsId, T obj);
 
 /**
  *
  * 返回查询一览表的信息
  * @param <T>
  * @param _mybitsId  mybatis中对应业务标识
  * @param _params
  * @return
  */
 public  <T>  List<T> query(String _mybitsId, Map<String, Object> _params);
 /**
  * 查询相关列表信息
  * @param <T> 返回数据
  * @param id mybatis中对应业务标识
  * @param _params
  * @return
  */
 public <T> List<T> query(String _mybitsId, Object _params);
 /**
  * 查询单个数据
  * @param queryString
  * @param object
  * @return
  */
 public Object queryOne(String queryString, Object object);

}

 

 

 

 

 

package com.zxh.customer.hashmap.dao;

import java.sql.Connection;
import java.util.List;
import java.util.Map;

import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.stereotype.Repository;

import com.googlecode.ehcache.annotations.Cacheable;
import com.googlecode.ehcache.annotations.TriggersRemove;

@Repository("baseDao")
public class BaseDaoImpl extends SqlSessionDaoSupport implements IBaseDao {

 /**
  * 获取相关的数据库连接
  */
 public Connection getConnection() {
  return getSqlSession().getConnection();
 }

 @TriggersRemove(cacheName = "springEhcache", removeAll = true)
 public <T> int delete(String _mybitsId, T obj) {
  return getSqlSession().delete(_mybitsId, obj);
 }

 @TriggersRemove(cacheName = "springEhcache", removeAll = true)
 public <T> int insert(String _mybitsId, T obj) {
  return getSqlSession().insert(_mybitsId, obj);
 }

 @TriggersRemove(cacheName = "springEhcache", removeAll = true)
 public <T> int update(String _mybitsId, T obj) {
  return getSqlSession().update(_mybitsId, obj);
 }

 @Cacheable(cacheName = "springEhcache")
 public <T> List<T> query(String _mybitsId, Map<String, Object> _params) {
  return getSqlSession().selectList(_mybitsId, _params);
 }

 @Cacheable(cacheName = "springEhcache")
 public <T> List<T> query(String _mybitsId, Object _params) {
  return getSqlSession().selectList(_mybitsId, _params);
 }

 @Cacheable(cacheName = "springEhcache")
 public Object queryOne(String _mybitsId, Object object) {
  return getSqlSession().selectOne(_mybitsId, object);
 }
}

 

 

 

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE mapper 
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zxh.customer.hashmap.model.user">

 <select id="selectUserById" parameterType="hashmap" resultType="hashmap">
  SELECT CUST_ID, CUST_NAME FROM CUST WHERE
  CUST_ID = #{custId}
 </select>

 <select id="selectUsersByName" parameterType="hashmap"
  resultType="hashmap">
  SELECT CUST_ID, CUST_NAME FROM CUST WHERE
  CUST_NAME =
  #{custName}
 </select>

 <insert id="insertUser" parameterType="hashmap">
  insert into cust(cust_id,
  cust_name) values(seq_cust.nextval, #{custName})
 </insert>

 <delete id="deleteUser" parameterType="hashmap">
  delete from cust where
  cust_id = #{custId}
 </delete>

 <update id="updateUser" parameterType="hashmap">
  update cust set cust_name
  = #{custName} where cust_id = #{custId}
 </update>

</mapper> 

 

 

 

 

 

package com.zxh.customer.hashmap.service;

public interface IBaseService {

}

 

 

 

package com.zxh.customer.hashmap.service;

import javax.annotation.Resource;

import com.zxh.customer.hashmap.dao.IBaseDao;

public class BaseServiceImpl implements IBaseService {
 
 @Resource
 protected IBaseDao baseDao;

 public IBaseDao getBaseDao() {
  return baseDao;
 }

 public void setBaseDao(IBaseDao baseDao) {
  this.baseDao = baseDao;
 }
 
}

 

 

 

 

 

package com.zxh.customer.hashmap.service;

import java.util.List;
import java.util.Map;

public interface IUserService extends IBaseService {
 
 /**
  * 获取单条记录
  */
 public Map queryUserById(Map map);
 
 /**
  * 获取多条记录
  */
 public List<Map> queryUsers(Map map);
 
 /**
  * 插入记录
  * @throws Exception
  */
 public void insertUser(Map map) throws Exception;
 
 /**
  * 删除记录
  * @throws Exception
  */
 public void deleteUser(Map map) throws Exception;
 
 /**
  * 更新记录
  */
 public void updateUser(Map map);

}

 

 

 

package com.zxh.customer.hashmap.service;

import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("userService")
public class UserServiceImpl extends BaseServiceImpl implements IUserService {

 /**
  * Map map 也可以定义领域模型实体类
  */
 
 
 @Override
 public Map queryUserById(Map map) {

  return (Map) this.baseDao.queryOne(
    "com.zxh.customer.hashmap.model.user.selectUserById", map);
 }

 @Override
 public List<Map> queryUsers(Map map) {

  return this.baseDao.query(
    "com.zxh.customer.hashmap.model.user.selectUsersByName", map);
 }

 /**
  * 如果没有配置@Transactional    使用sqlSession的jdbc事务  每一个操作都是一个单独的事务
  * 抛出异常事务也不会回滚   无论抛出什么异常了
  */
 @Transactional
 public void insertUser(Map map) throws Exception {

  this.baseDao.insert("com.zxh.customer.hashmap.model.user.insertUser",
    map);
  
  // 只有抛出运行期异常  事务才会回滚，   如果抛出Exception不会回滚了  
  // throw new RuntimeException();
 }

 @Transactional
 public void deleteUser(Map map) throws Exception {

  this.baseDao.delete("com.zxh.customer.hashmap.model.user.deleteUser",
    map);
  throw new Exception();
 }

 @Override
 public void updateUser(Map map) {

  this.baseDao.update("com.zxh.customer.hashmap.model.user.updateUser",
    map);
 }

}

 

 

 

<?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:tx="http://www.springframework.org/schema/tx"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"
 xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.2.xsd 
        http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring 
      http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.2.xsd">

 <context:annotation-config />
 <context:component-scan base-package="com.zxh.customer.hashmap" />
 <context:property-placeholder
  location="classpath:sysconfig/jdbc_config.properties" />
  
 <!-- 使用ehcache缓存 --> 
    <bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
     <property name="configLocation" value="classpath:sysconfig/ehcache.xml" />
    </bean>
 <ehcache:annotation-driven cache-manager="ehCacheManager" />

 <!--JNDI数据源配置 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
  <property name="jndiName"> <value>jdbc/JTORDER</value> </property> </bean> -->

 <bean id="dataSource"
  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  <property name="driverClassName" value="${driver}" />
  <property name="url" value="${url}" />
  <property name="username" value="jtorder" />
  <property name="password" value="jtorder" />
 </bean>

 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="mapperLocations"
   value="classpath*:com/zxh/customer/hashmap/model/**/*.xml" />
  <property name="configLocation" value="classpath:sysconfig/Configuration.xml" />
 </bean>

 <bean id="transactionManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
 </bean>
 <tx:annotation-driven transaction-manager="transactionManager"
  proxy-target-class="true" />

 <!-- 使用SqlSessionDaoSupport 需要注入sqlSessionFactory -->
 <bean id="baseDao" class="com.zxh.customer.hashmap.dao.BaseDaoImpl">
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
 </bean>

 

</beans>

 

 

 

 

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE configuration 
     PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
     "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

 <!-- 设置mybatis3 运行时的行为方式 -->
 <settings>
  <!-- 设置超时时间，它决定驱动等待一个数据库响应的时间 -->
  <setting name="defaultStatementTimeout" value="60000" />
  <!-- 启用或禁用 缓存 -->
  <setting name="cacheEnabled" value="false" />
  <!-- 启用或禁用延迟加载。当禁用时, 所有关联对象都会即时加载 -->
  <setting name="lazyLoadingEnabled" value="true" />  
  <!-- 等等 -->
 </settings>
 
</configuration>

 

 

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>

 <!-- name：Cache的唯一标识 maxElementsInMemory：内存中最大缓存对象数 maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大
  eternal：Element是否永久有效，一但设置了，timeout将不起作用 overflowToDisk：配置此属性，当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中
  timeToIdleSeconds：设置Element在失效前的允许闲置时间。仅当element不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大
  timeToLiveSeconds：设置Element在失效前允许存活时间。最大时间介于创建时间和失效时间之间。仅当element不是永久有效时使用，默认是0.，也就是element存活时间无穷大
  diskPersistent：是否缓存虚拟机重启期数据 diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒
  diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
  memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）
  备注: 持久化到硬盘的路径由虚拟机参数"java.io.tmpdir"决定. 例如, 在windows中, 会在此路径下 C:\Documents
  and Settings\li\Local Settings\Temp 在linux中, 通常会在: /tmp 下 System.out.println(System.getProperty("java.io.tmpdir")); -->

 <diskStore path="java.io.tmpdir" />

 <defaultCache maxElementsInMemory="10000" eternal="false"
  timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
  diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
  memoryStoreEvictionPolicy="LRU" />

 <cache name="springEhcache" maxElementsInMemory="1000" eternal="false"
  overflowToDisk="false" timeToIdleSeconds="600" timeToLiveSeconds="3600"
  memoryStoreEvictionPolicy="LRU" />

</ehcache>

 

 

 

driver=oracle.jdbc.driver.OracleDriver
url=jdbc\:oracle\:thin\:@172.16.1.241\:1521\:jtcrm
username=jtorder
password=jtorder

 

 

 

package springtest;

import static org.junit.Assert.fail;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zxh.customer.hashmap.service.IUserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:sysconfig/applicationContext.xml")
public class UserServiceImplTest {
 
 @Resource
 private IUserService userService;

 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
 }

 @AfterClass
 public static void tearDownAfterClass() throws Exception {
 }

 @Before
 public void setUp() throws Exception {
 }

 @After
 public void tearDown() throws Exception {
 }

 @Test
 public void testQueryUserById() {
  
  Map map = new HashMap();
  map.put("custId", 604763L);
  Map resultMap = this.userService.queryUserById(map);
  System.out.println(resultMap.get("CUST_NAME"));
 }

 @Test
 public void testInsertUser() throws Exception {
  Map map = new HashMap();
  map.put("custName", "大方地");
  this.userService.insertUser(map);  
 }
 
 @Test
 public void testQueryUserById1() {
  
  Map map = new HashMap();
  map.put("custId", 604763L);
  Map resultMap = this.userService.queryUserById(map);
  System.out.println(resultMap.get("CUST_NAME"));
 }

 @Test
 @Ignore
 public void testDeleteUser() {
  fail("Not yet implemented");
 }

 @Test
 @Ignore
 public void testUpdateUser() {
  fail("Not yet implemented");
 }

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

java爱分享
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
spring+ehcache
06-13
spring整合ehcache的入门级别demo分享，通过junit来测试
springboot +mybatis+ehcache缓存注解
gc1329689056的博客
09-29 965
1.在pom.xml中引入cache依赖，添加如下内容： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-cache&lt;/artifactId&gt; &lt;/dependency&gt; 2....
使用Spring的缓存抽象来集成不同的缓存提供者，如Ehcache、Redis等
最新发布
qiuyehuanghun的博客
03-30 335
使用Spring的缓存抽象来集成不同的缓存提供者，如Ehcache、Redis等是非常常见的做法。Spring提供了@Cacheable、@CachePut、@CacheEvict等注解，可以轻松地在Spring应用程序中使用缓存。通过以上步骤，您就可以轻松地集成不同的缓存提供者（如Ehcache、Redis）到Spring应用程序中，并使用Spring的缓存抽象来管理缓存。根据您的需求和环境，选择合适的缓存提供者，并根据具体情况配置缓存参数和注解。
spring-mybatis-ehcache
qq_37115728的博客
08-19 307
Ehcache是什么？它是一种缓存框架。 现在常用的缓存框架有很多，例如： Ehcache – Java分布式缓存框架， redis、Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API； memcache:一套分布式的高速缓存系统, 还有很多java缓存框架等可以自行查找。 选择EhC
spring ehcache 使用详解
02-15 136
Spring 整合 Ehcache 管理缓存详解 yellowbutterfly 前言 Ehcache是一个成熟的缓存框架，你可以直接使用它来管理你的缓存。 Spring提供了对缓存功能的抽象：即允许绑定不同的缓存解决方案（如Ehcache），但本身不直接提供缓存功能的实现。它支持注解方式使用缓存，非常方便。 本文先通过Ehcache独立应用的范例来介...
Spring整合Mybaits实现ehcache 注解查询缓存
Franco的博客
10-30 343
前言：EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点。 ehcache官网：http://www.ehcache.org/ 可以下载文档看看，里面写的很清楚。 主要的特性有： 快速简单多种缓存策略缓存数据有两级：内存和磁盘，因此无需担心容量问题缓存数据会在虚拟机重启的过程中写入磁盘可以通过RMI、可插入API等方式进行分布式缓存具有缓存和缓存管理器的侦听接口支
spring mvc + mybatis + ehcache
04-19
spring mvc注解方式学习搭建的项目，供大家参考
spring4.x+springMVC4.x+mybatis3.x+ehcache2.6.x整合
11-30
以前都是用SSH，第一次使用spring+springMVC+mybatis自己做的测试练习，主要是配置注解的使用，加了稍微详细的注释说明。另外在测试ehcache的时候也继承进去了，紧做练习参考. 环境：tomcat使用7.x，JDK1.7开发工具...
使用maven构建项目，spring mvc，spring，与jdbctemplate，hibernate，mybatis整合
03-02
使用maven构建项目，spring mvc，spring，分别与jdbctemplate，hibernate，mybatis全注解整合，其中包括包含有spring动态代理，数据库的事务处理。以及动态数据源的切换！ 最新新增了ehcache缓存的应用
shiro集成mybatis和spring以及redis
10-12
架构采用的是SpringMVC4.2.4+mybatis3.4.4+ehcache+redis+shiro1.2.2 虽然redis集成了,但是我自己写的SessionDao有些问题目前就还是用的shiro的EnterpriseCacheSessionDAO,因此就没有用redis来缓存Session,但是集成...
非常好的JavaSpring项目资源，分享出来.zip
03-02
使用maven构建项目，spring mvc，spring，分别与jdbctemplate，hibernate，mybatis全注解整合，其中包括包含有spring动态代理，数据库的事务处理。以及动态数据源的切换！ 最新新增了ehcache缓存的应用 ...
spring整合EhCache 基于注解的方式
02-16
本例子主要讲解ehcache的配置使用。采用了java配置和xml配置两种方式。主要用于学习。 使用java配置时将SpringTestCase.java 文件中的@ContextConfiguration(locations = { "classpath:applicationContext.xml" }) 注释掉 使用xml配置时。将com.test.config 下的Java文件中@Configuration 都注释掉。
Spring+Ehcache集成
04-13
基于公司的项目在Spring中集成Ehcache,并提供EhcaheUtils工具类，并通过Spring的AOP编程实现方法缓存注解话，先奉献出核心代码，需要的朋友可以参考哦！
Ehcache注解核心逻辑源码学习
iteye_4143的博客
10-31 277
Ehcache支持方法注解方式管理缓存，使代码的侵入性很小。最常用的Ehcache注解是@Cacheable、@CacheEvict、@CachePut 本文通过分析源码整理了这几个注解的实现逻辑和关系，并指出一些组合使用时的限制   1注解类源码 1.1@Cacheable /** * Cacheable注解缓存方法（或类的所有方法）返回值，缓存Key是方法本身和参数的组合签名...
springMVC+mybatis+ehcache详细配置
牧羊仒
07-27 946
一、 Mybatis+Ehcache配置 为了提高MyBatis的性能,有时候我们需要加入缓存支持,目前用的比较多的缓存莫过于ehcache缓存了,ehcache性能强大,而且位各种应用都提供了解决方案,在此我们主要是做查询缓存,提高查询的效率. 整合MyBatis和ehcache需要的jar包如下： ehcache-core-2.4.4.jar mybatis-ehcache-1.0
EhCache注解使用
blog：xuchuruo.cn
10-18 2208
参考另一篇Spring和EhCache整合 与Spring整合之后,提供了一套注解来对普通业务数据进行缓存. 常用的前2个:在业务层ServiceImpl方法名上加上注解即可 @Cacheable - 保存到缓存区:常用与findAll查询 @Cacheable("Cache名称") @Override public List findAll() {
ehcache、spring框架入门整合基于mybatis sql注解方式
华绪、charles的博客
02-05 228
引言 由于项目中我负责的模板需要做权限相关的操作，每次校验都需要去访问数据库，这样会对数据库造成非常大不必要的压力，想了一下决定使用缓存，由于目前项目中用的东西并不多，所以就考虑在mybatis本身的二级缓存和Ehcache中挑选一个。具体过程不在多言，最终确定使用Ehcache，由于配置过程中遇到挺多小问题，所以在此整理一篇文章记录下来，以便大家共同探讨。 正文 首先导入核心包：c
Spring之Ehcache缓存注解
绣花针
01-02 541
一、@Cacheable（value,key,condition） 1.说明 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存 参数 解释 example value 缓存的名称，在 spring 配置文件中定义，必须指定至少一个 例如: @Cacheable(value=”mycache”) @Cacheable(value={”cache1...
ehcache使用_Spring 整合EhCache一 初体验
weixin_39856607的博客
11-26 60
ehcache简介EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。(百度百科)主要的特性有：1. 快速2. 简单3. 多种缓存策略4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题5. 缓存数据会在虚拟机重启的过程中写入磁盘6. 可以通过RMI、可插入API等方式进行分布式缓存7. 具有缓...
springboot cache实现mybatis缓存注解
05-05
在Spring Boot中，我们可以使用`@Cacheable`注解来实现MyBatis缓存。以下是一个简单的示例： 1. 添加依赖 在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.mybatis.caches <artifactId>mybatis-ehcache ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值