三、Memcached整合Spring cache注解完整示例(SSM框架)

最新推荐文章于 2019-11-24 21:15:23 发布

这个名字想了很久

最新推荐文章于 2019-11-24 21:15:23 发布

阅读量1.1k

点赞数

分类专栏： memcached

本文链接：https://blog.csdn.net/qq_34021712/article/details/57424296

版权

memcached 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

我们已经详细的讲解了memcached安装过程,以及集群的搭建,但是,我们还要在java项目中应用它，本篇记录了Memcached整合spring的一些方法，现在我们就基于这些方法实现一个Memcached整合Spring的完整示例，好了不多说了，我们直接上代码吧。

一、首先要测试是否可以连通memcached服务端

这里有一个java普通工程执行main方法测试是否可以连通memcached服务端

下载地址:http://download.csdn.net/detail/qq_34021712/9766435

二、配置文件

1、pom.xml

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
     <!-- spring核心包 -->  
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-core</artifactId>  
          <version>${spring.version}</version>  
      </dependency>  

      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-web</artifactId>  
          <version>${spring.version}</version>  
      </dependency> 
      <!-- 用来object与xml之间相互转换 --> 
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-oxm</artifactId>  
          <version>${spring.version}</version>  
      </dependency> 
      <!-- 事务包 -->
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-tx</artifactId>  
          <version>${spring.version}</version>  
      </dependency>  
	<!-- jdbc包 -->
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-jdbc</artifactId>  
          <version>${spring.version}</version>  
      </dependency>  
<!-- spring mvc 包 -->
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-webmvc</artifactId>  
          <version>${spring.version}</version>  
      </dependency> 
 <!-- 切面包 --> 
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-aop</artifactId>  
          <version>${spring.version}</version>  
      </dependency>  
      
       <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-aspects</artifactId>
	    <version>${spring.version}</version>
	</dependency>

	<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjrt</artifactId>
	    <version>1.6.11</version>
	</dependency>
	<dependency>  
            <groupId>org.aspectj</groupId>  
            <artifactId>aspectjweaver</artifactId>  
            <version>1.6.11</version>  
        </dependency> 
	  <dependency>  
            <groupId>cglib</groupId>  
            <artifactId>cglib</artifactId>  
            <version>2.1</version>  
        </dependency>  
 
	
<!-- 应用上下文工具 including EhCache, JavaMail, Quartz, and Freemarker integration -->
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-context-support</artifactId>  
          <version>${spring.version}</version>  
      </dependency>  
<!-- 支持测试 -->
      <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-test</artifactId>  
          <version>${spring.version}</version>  
      </dependency> 
      <!-- mybatis核心包 -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version>${mybatis.version}</version>  
        </dependency>  
        <!-- mybatis/spring包 -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis-spring</artifactId>  
            <version>1.2.2</version>  
        </dependency>  
        <!-- 导入java ee jar 包 -->  
        <dependency>  
            <groupId>javax</groupId>  
            <artifactId>javaee-api</artifactId>  
            <version>7.0</version>  
        </dependency>
        <!-- mysql连接数据库jar包 -->        	
		<dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.30</version>  
        </dependency> 
        <dependency>
		    <groupId>com.jolbox</groupId>
		    <artifactId>bonecp</artifactId>
		    <version>0.8.0.RELEASE</version>
		</dependency>
         <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->  
        <dependency>  
            <groupId>commons-dbcp</groupId>  
            <artifactId>commons-dbcp</artifactId>  
            <version>1.2.2</version>  
        </dependency>  
        <!-- JSTL标签类 -->  
        <dependency>  
            <groupId>jstl</groupId>  
            <artifactId>jstl</artifactId>  
            <version>1.2</version>  
        </dependency> 
        <!-- 日志文件管理包 -->  
        <!-- log start -->  
        <dependency>  
            <groupId>log4j</groupId>  
            <artifactId>log4j</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
          
          
        <!-- 格式化对象，方便输出日志处理json -->  
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>fastjson</artifactId>  
            <version>1.1.41</version>  
        </dependency>  
  
  <!-- 记录日志 -->
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-api</artifactId>  
            <version>${slf4j.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-log4j12</artifactId>  
            <version>${slf4j.version}</version>  
        </dependency>  
        <!-- log end -->  
         <!-- 映入JSON -->  
        <dependency>  
            <groupId>org.codehaus.jackson</groupId>  
            <artifactId>jackson-mapper-asl</artifactId>  
            <version>1.9.13</version>  
        </dependency>  
        <!-- 上传组件包 -->  
        <dependency>  
            <groupId>commons-fileupload</groupId>  
            <artifactId>commons-fileupload</artifactId>  
            <version>1.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-io</groupId>  
            <artifactId>commons-io</artifactId>  
            <version>2.4</version>  
        </dependency>
      <!-- 加密算法 -->  
        <dependency>  
            <groupId>commons-codec</groupId>  
            <artifactId>commons-codec</artifactId>  
            <version>1.9</version>  
        </dependency>  
        <!-- memcached引用包 -->
        <!-- https://mvnrepository.com/artifact/com.googlecode.xmemcached/xmemcached -->
	<dependency>
    <groupId>com.google.code.simple-spring-memcached</groupId>
	    <artifactId>spring-cache</artifactId>
	    <version>3.5.0</version>
	</dependency>
        <dependency>  
            <groupId>com.google.code.simple-spring-memcached</groupId>  
            <artifactId>xmemcached-provider</artifactId>  
            <version>3.5.0</version>  
        </dependency>  
        <dependency>  
            <groupId>com.googlecode.xmemcached</groupId>  
            <artifactId>xmemcached</artifactId>  
            <version>2.0.0</version>  
        </dependency> 

  </dependencies>

2、MemcachedCacheManager

package com.test.memcached;

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

import net.rubyeye.xmemcached.MemcachedClient;

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

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;   //xmemcached的客户端  
  
    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;  
    }
	
}

3、MemcachedCache

package com.test.memcached;


import net.rubyeye.xmemcached.MemcachedClient;

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

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;  
    }
	
}

4、MemCache

package com.test.memcached;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.TimeoutException;

import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.exception.MemcachedException;

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

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 (TimeoutException e) {  
            log.warn("获取 Memcached 缓存超时", e);  
        } catch (InterruptedException e) {  
            log.warn("获取 Memcached 缓存被中断", e);  
        } catch (MemcachedException e) {  
            log.warn("获取 Memcached 缓存错误", e);  
        }  
        return value;  
    }  
  
    public void put(String key, Object value) {  
        if (value == null)  
            return;  
  
        try {  
            key = this.getKey(key);  
            memcachedClient.setWithNoReply(key, expire, value);  
            keySet.add(key);  
        } catch (InterruptedException e) {  
            log.warn("更新 Memcached 缓存被中断", e);  
        } catch (MemcachedException e) {  
            log.warn("更新 Memcached 缓存错误", e);  
        }  
    }  
  
    public void clear() {  
        for (String key : keySet) {  
            try {  
                memcachedClient.deleteWithNoReply(this.getKey(key));  
            } catch (InterruptedException e) {  
                log.warn("删除 Memcached 缓存被中断", e);  
            } catch (MemcachedException e) {  
                log.warn("删除 Memcached 缓存错误", e);  
            }  
        }  
    }  
  
    public void delete(String key) {  
        try {  
            key = this.getKey(key);  
            memcachedClient.deleteWithNoReply(key);  
        } catch (InterruptedException e) {  
            log.warn("删除 Memcached 缓存被中断", e);  
        } catch (MemcachedException e) {  
            log.warn("删除 Memcached 缓存错误", e);  
        }  
    }  
  
    private String getKey(String key) {  
        return name + "_" + key;  
    }
	
}

5、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:context="http://www.springframework.org/schema/context"  
    xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"  
    xmlns:rabbit="http://www.springframework.org/schema/rabbit" xmlns:task="http://www.springframework.org/schema/task"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
                        http://www.springframework.org/schema/beans/spring-beans.xsd  
                        http://www.springframework.org/schema/context   
                        http://www.springframework.org/schema/context/spring-context.xsd  
                        http://www.springframework.org/schema/rabbit  
                        http://www.springframework.org/schema/rabbit/spring-rabbit-1.3.xsd  
                        http://www.springframework.org/schema/task  
                        http://www.springframework.org/schema/task/spring-task.xsd">  
  
  	 <!-- 引入配置文件 -->
	<!-- <bean id="propertyConfigurer"  
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="location" value="classpath:memcached.properties" />
    </bean>  -->
  
    <bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder" >  
        <constructor-arg>  
            <list>  
                <bean class="java.net.InetSocketAddress">  
                	<!--这里是直接写死了一个服务端,如果是集群,可以在此配置多个服务端  -->
                    <constructor-arg value="127.0.0.1" />  
                    <constructor-arg value="12000" />  
                </bean> 
            </list>  
        </constructor-arg>  
    </bean>  
    
    
    <bean id="memcachedClient" factory-bean="memcachedClientBuilder" factory-method="build" destroy-method="shutdown" /> 
         
  	<bean id="cacheManager" class="com.test.memcached.MemcachedCacheManager">  
        <property name="memcachedClient" ref="memcachedClient" />  
        <property name="configMap">  
            <map>  
            	<!-- key缓存对象名称   value缓存过期时间 -->  
                <entry key="typeList" value="3600" />  
            </map>  
        </property>  
    </bean>  
</beans>

6、spring-mybatis.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:mvc="http://www.springframework.org/schema/mvc"  
    xmlns:aop="http://www.springframework.org/schema/aop"
    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/context    
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                        http://www.springframework.org/schema/mvc    
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
                        http://www.springframework.org/schema/cache
                        http://www.springframework.org/schema/cache/spring-cache.xsd">  
	<!-- 自动扫描 -->                        
	<context:component-scan base-package="com.test"></context:component-scan>
	<!-- 激活自动代理功能 -->
	<aop:aspectj-autoproxy  proxy-target-class="true"/>
	<!-- 启用缓存注解功能，这个是必须的，否则注解不会生效，另外，该注解一定要声明在spring主配置文件中才会生效 -->  
	<cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/> 
	<!-- 引入配置文件 -->
	<bean id="propertyConfigurer"  
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
         <property name="locations">
   			<list> 
   				<value>classpath:jdbc.properties</value>
   				<value>classpath:memcached.properties</value>
   			</list> 
  		</property>  
    </bean>  
    
	<bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">
		<property name="driverClass" value="${jdbc_driver}" />
		<property name="jdbcUrl" value="${jdbc_url}" />
		<property name="username" value="${jdbc_username}" />
		<property name="password" value="${jdbc_password}" />
		<property name="maxConnectionsPerPartition" value="20" />
		<property name="minConnectionsPerPartition" value="5" />
		<property name="poolAvailabilityThreshold" value="20" />
		<property name="partitionCount" value="3" />
		<property name="acquireIncrement" value="2" />
		<property name="statementsCacheSize" value="10" />
		<property name="releaseHelperThreads" value="3" />
		<property name="acquireRetryAttempts" value="5" />
		<property name="lazyInit" value="false" />
	</bean>
    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 --> 
    <bean  id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    	<property name="dataSource" ref="dataSource" />
    	<!-- 自动扫描mapping.xml文件 -->  
        <property name="mapperLocations" value="classpath:com/test/mapping/*.xml"></property>
	</bean>
	<!-- DAO接口所在包名，Spring会自动查找其下的类 -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="com.test.IDao" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
    </bean>  
    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->  
    <bean id="transactionManager"  
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean> 
    
</beans>

7、spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd    
                        http://www.springframework.org/schema/context    
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                        http://www.springframework.org/schema/mvc    
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">  
    <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->  
    <context:component-scan base-package="com.test.Action" />  
    <!--避免IE执行AJAX时，返回JSON出现下载文件 -->  
    <bean id="mappingJacksonHttpMessageConverter"  
        class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">  
        <property name="supportedMediaTypes">  
            <list>  
                <value>text/html;charset=UTF-8</value>  
            </list>  
        </property>  
    </bean>  
    <!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->  
    <bean  
        class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">  
        <property name="messageConverters">  
            <list>  
                <ref bean="mappingJacksonHttpMessageConverter" /> <!-- JSON转换器 -->  
            </list>  
        </property>  
    </bean>  
    <!-- 定义跳转的文件的前后缀 ，视图模式配置-->  
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->  
        <property name="prefix" value="/WEB-INF/jsp/" />  
        <property name="suffix" value=".jsp" />  
    </bean>  
      
    <!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->  
    <bean id="multipartResolver"    
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">    
        <!-- 默认编码 -->  
        <property name="defaultEncoding" value="utf-8" />    
        <!-- 文件大小最大值 -->  
        <property name="maxUploadSize" value="10485760000" />    
        <!-- 内存中的最大值 -->  
        <property name="maxInMemorySize" value="40960" />    
    </bean>   
  
</beans>

8、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"  
    version="3.0">  
    <display-name>Archetype Created Web Application</display-name>  
    <!-- Spring和mybatis的配置文件 -->  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath:spring-mybatis.xml,classpath:spring-memcached.xml</param-value>  
    </context-param>  
    <!-- 编码过滤器 -->  
    <filter>  
        <filter-name>encodingFilter</filter-name>  
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <async-supported>true</async-supported>  
        <init-param>  
            <param-name>encoding</param-name>  
            <param-value>UTF-8</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>encodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    <!-- Spring监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <!-- 防止Spring内存溢出监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
    </listener>  
  
    <!-- Spring MVC servlet -->  
    <servlet>  
        <servlet-name>SpringMVC</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:spring-mvc.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup>  
        <async-supported>true</async-supported>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>SpringMVC</servlet-name>  
        <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  
    <welcome-file-list>  
        <welcome-file>/index.jsp</welcome-file>  
    </welcome-file-list>  
  
</web-app>

三、使用示例

1、UserAction

package com.test.Action;

import javax.annotation.Resource;  
import javax.servlet.http.HttpServletRequest;  
  
import org.springframework.stereotype.Controller;  
import org.springframework.ui.Model;  
import org.springframework.web.bind.annotation.RequestMapping;  

import com.test.domain.User;
import com.test.service.UserService;
  
  
  
@Controller  
@RequestMapping("/user")  
public class UserAction {  
    @Resource  
    private UserService userService;  
      
    @RequestMapping("/show")  
    public String toIndex(HttpServletRequest request,Model model){  
    	Long userId = Long.parseLong(request.getParameter("id"));  
        User user = userService.selectByPrimaryKey(userId);  
        model.addAttribute("user", user);  
        return "show";  
    }  
    
    @RequestMapping("/delete")  
    public String deleteIndex(HttpServletRequest request,Model model){  
    	Long userId = Long.parseLong(request.getParameter("id"));  
        int i = userService.deleteByPrimaryKey(userId);  
        return "show";  
    }
    
    @RequestMapping("/update")
    public String updateIndex(HttpServletRequest request,Model model){  
    	User user = userService.selectByPrimaryKey(Long.parseLong(request.getParameter("id")));
        user.setUserName("测试测试车");
        User user2 = userService.updateByPrimaryKey(user); 
        return "show";  
    }
}

2、UserService

package com.test.service;

import com.test.domain.User;

public interface UserService {

	User selectByPrimaryKey(long id);
	
	int deleteByPrimaryKey(long id);
	
	User updateByPrimaryKey(User user);
}

3、UserServiceImp

package com.test.service.imp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;


import com.test.IDao.UserDAO;
import com.test.domain.User;
import com.test.service.UserService;

@Service("userService")
public class UserServiceImp implements UserService{

	@Autowired
	private UserDAO userDAO;
	
	@Cacheable(value="defaultCache",key="#root.methodName")//#id
	public User selectByPrimaryKey(long id) {
		// TODO Auto-generated method stub
		System.out.println("show_test");
		User user = userDAO.selectByPrimaryKey(id);
		return user;
	}
	
	@CacheEvict(value="defaultCache",key="new String('selectByPrimaryKey')")
	public int deleteByPrimaryKey(long id) {
		// TODO Auto-generated method stub
		System.out.println("delete_test");
		return userDAO.deleteByPrimaryKey(id);
	}
	
	@CachePut(value="defaultCache",key="new String('selectByPrimaryKey')")
	public User updateByPrimaryKey(User user) {
		System.out.println("update_test");
		int i = userDAO.updateByPrimaryKey(user);
		User user2 = null;
		if(i>0){
			user2 = userDAO.selectByPrimaryKey(user.getId());
		}
		return user2;
	}
}

4、UserDAO

package com.test.IDao;

import com.test.domain.User;

public interface UserDAO {
    int deleteByPrimaryKey(Long id);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Long id);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);
}

5、UserMapper.xml

<?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.test.IDao.UserDAO" >
  <resultMap id="BaseResultMap" type="com.test.domain.User" >
    <id column="ID" property="id" jdbcType="DECIMAL" />
    <result column="USER_NAME" property="userName" jdbcType="VARCHAR" />
    <result column="PASSWORD" property="password" jdbcType="VARCHAR" />
    <result column="AGE" property="age" jdbcType="DECIMAL" />
  </resultMap>
  <sql id="Base_Column_List" >
    ID, USER_NAME, PASSWORD, AGE
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Long" >
    select 
    <include refid="Base_Column_List" />
    from USER_T
    where ID = #{id,jdbcType=DECIMAL}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Long" >
    delete from USER_T
    where ID = #{id,jdbcType=DECIMAL}
  </delete>
  <insert id="insert" parameterType="com.test.domain.User" >
    insert into USER_T (ID, USER_NAME, PASSWORD, 
      AGE)
    values (#{id,jdbcType=DECIMAL}, #{userName,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
      #{age,jdbcType=DECIMAL})
  </insert>
  <insert id="insertSelective" parameterType="com.test.domain.User" >
    insert into USER_T
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        ID,
      </if>
      <if test="userName != null" >
        USER_NAME,
      </if>
      <if test="password != null" >
        PASSWORD,
      </if>
      <if test="age != null" >
        AGE,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        #{id,jdbcType=DECIMAL},
      </if>
      <if test="userName != null" >
        #{userName,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        #{password,jdbcType=VARCHAR},
      </if>
      <if test="age != null" >
        #{age,jdbcType=DECIMAL},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.test.domain.User" >
    update USER_T
    <set >
      <if test="userName != null" >
        USER_NAME = #{userName,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        PASSWORD = #{password,jdbcType=VARCHAR},
      </if>
      <if test="age != null" >
        AGE = #{age,jdbcType=DECIMAL},
      </if>
    </set>
    where ID = #{id,jdbcType=DECIMAL}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.test.domain.User" >
    update USER_T
    set USER_NAME = #{userName,jdbcType=VARCHAR},
      PASSWORD = #{password,jdbcType=VARCHAR},
      AGE = #{age,jdbcType=DECIMAL}
    where ID = #{id,jdbcType=DECIMAL}
  </update>
</mapper>

以上是项目所有代码,jsp页面可以自己随便写一个,如果jsp页面懒得写的话,可以直接在浏览器地址栏拼接参数访问。可以看到效果,在此查询的时候是不会进入方法体走数据库查询,而是直接从缓存中获取数据。

这里可以直接下载源码,完整项目,在数据创建一个USER_T表就可以了，下载即可使用。

地址: http://download.csdn.net/detail/qq_34021712/9766441