spring3.2+ehcache 注解使用

通过spring 拦截，实现颗粒度比较细，容易控制的缓存。了解了下，spring 3.0 以后，应该从3.1
以后吧，注解方式的缓存就已经实现，下面是我自己做的例子，分享给大家：

例子内容介绍：

1.没用数据库，用的集合里面的数据，也就没事务之类的，完成的一个CRUD操作

2.主要测试内容，包括第一次查询，和反复查询，缓存是否生效，更新之后数据同步的问题

3.同时含有一些常用参数绑定等东西

4.为了内容简单，我没有使用接口，就是User,UserControl,UserServer,UserDao 几个类，以及xml 配置文件

直接看类吧，源码文件，以及jar 都上传，方便大家下载：

Java代码  

  1. package com.se;

  2. public class User {

  3. public Integer id;

  4. public String name;

  5. public String password;

  6. // 这个需要，不然在实体绑定的时候出错

  7. public User(){}

  8. public User(Integer id, String name, String password) {

  9. super();

  10. this.id = id;

  11. this.name = name;

  12. this.password = password;

  13. }

  14. public Integer getId() {

  15. return id;

  16. }

  17. public void setId(Integer id) {

  18. this.id = id;

  19. }

  20. public String getName() {

  21. return name;

  22. }

  23. public void setName(String name) {

  24. this.name = name;

  25. }

  26. public String getPassword() {

  27. return password;

  28. }

  29. public void setPassword(String password) {

  30. this.password = password;

  31. }

  32. @Override

  33. public String toString() {

  34. return "User [id=" + id + ", name=" + name + ", password=" + password

  35. + "]";

  36. }

  37. }

Java代码  

  1. package com.se;

  2. import java.util.ArrayList;

  3. import java.util.List;

  4. import org.springframework.stereotype.Repository;

  5. /**

  6. * 静态数据，模拟数据库操作

  7. */

  8. @Repository("userDao")

  9. public class UserDao {

  10. List<User> users = initUsers();

  11. public User findById(Integer id){

  12. User user = null;

  13. for(User u : users){

  14. if(u.getId().equals(id)){

  15. user = u;

  16. }

  17. }

  18. return user;

  19. }

  20. public void removeById(Integer id){

  21. User user = null;

  22. for(User u : users){

  23. if(u.getId().equals(id)){

  24. user = u;

  25. break;

  26. }

  27. }

  28. users.remove(user);

  29. }

  30. public void addUser(User u){

  31. users.add(u);

  32. }

  33. public void updateUser(User u){

  34. addUser(u);

  35. }

  36. // 模拟数据库

  37. private List<User> initUsers(){

  38. List<User> users = new ArrayList<User>();

  39. User u1 = new User(1,"张三","123");

  40. User u2 = new User(2,"李四","124");

  41. User u3 = new User(3,"王五","125");

  42. users.add(u1);

  43. users.add(u2);

  44. users.add(u3);

  45. return users;

  46. }

  47. }

Java代码  

  1. package com.se;

  2. import java.util.List;

  3. import org.springframework.beans.factory.annotation.Autowired;

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

  5. import org.springframework.cache.annotation.Cacheable;

  6. import org.springframework.stereotype.Service;

  7. /**

  8. * 业务操作，

  9. */

  10. @Service("userService")

  11. public class UserService {

  12. @Autowired

  13. private UserDao userDao;

  14. // 查询所有，不要key,默认以方法名+参数值+内容 作为key

  15. @Cacheable(value = "serviceCache")

  16. public List<User> getAll(){

  17. printInfo("getAll");

  18. return userDao.users;

  19. }

  20. // 根据ID查询，ID 我们默认是唯一的

  21. @Cacheable(value = "serviceCache", key="#id")

  22. public User findById(Integer id){

  23. printInfo(id);

  24. return userDao.findById(id);

  25. }

  26. // 通过ID删除

  27. @CacheEvict(value = "serviceCache", key="#id")

  28. public void removeById(Integer id){

  29. userDao.removeById(id);

  30. }

  31. public void addUser(User u){

  32. if(u != null && u.getId() != null){

  33. userDao.addUser(u);

  34. }

  35. }

  36. // key 支持条件，包括 属性condition ，可以 id < 10 等等类似操作

  37. // 更多介绍，请看参考的spring 地址

  38. @CacheEvict(value="serviceCache", key="#u.id")

  39. public void updateUser(User u){

  40. removeById(u.getId());

  41. userDao.updateUser(u);

  42. }

  43. // allEntries 表示调用之后，清空缓存，默认false,

  44. // 还有个beforeInvocation 属性，表示先清空缓存，再进行查询

  45. @CacheEvict(value="serviceCache",allEntries=true)

  46. public void removeAll(){

  47. System.out.println("清除所有缓存");

  48. }

  49. private void printInfo(Object str){

  50. System.out.println("非缓存查询----------findById"+str);

  51. }

  52. }

Java代码  

  1. package com.se;

  2. import java.util.List;

  3. import org.springframework.beans.factory.annotation.Autowired;

  4. import org.springframework.stereotype.Controller;

  5. import org.springframework.ui.Model;

  6. import org.springframework.web.bind.annotation.ModelAttribute;

  7. import org.springframework.web.bind.annotation.PathVariable;

  8. import org.springframework.web.bind.annotation.RequestMapping;

  9. @Controller

  10. public class UserControl {

  11. @Autowired

  12. private UserService userService;

  13. // 提前绑定视图，提前绑定数据，方便查看数据变化

  14. @ModelAttribute("users")

  15. public List<User> cityList() {

  16. return userService.getAll();

  17. }

  18. // 根据ID查询

  19. @RequestMapping("/get/{id}")

  20. public String getUserById(Model model,@PathVariable Integer id){

  21. User u = userService.findById(id);

  22. System.out.println("查询结果："+u);

  23. model.addAttribute("user", u);

  24. return "forward:/jsp/edit";

  25. }

  26. // 删除

  27. @RequestMapping("/del/{id}")

  28. public String deleteById(Model model,@PathVariable Integer id){

  29. printInfo("删除-----------");

  30. userService.removeById(id);

  31. return "redirect:/jsp/view";

  32. }

  33. // 添加

  34. @RequestMapping("/add")

  35. public String addUser(Model model,@ModelAttribute("user") User user){

  36. printInfo("添加----------");

  37. userService.addUser(user);

  38. return "redirect:/jsp/view";

  39. }

  40. // 修改

  41. @RequestMapping("/update")

  42. public String update(Model model,@ModelAttribute User u){

  43. printInfo("开始更新---------");

  44. userService.updateUser(u);

  45. model.addAttribute("user", u);

  46. return "redirect:/jsp/view";

  47. }

  48. // 清空所有

  49. @RequestMapping("/remove-all")

  50. public String removeAll(){

  51. printInfo("清空-------------");

  52. userService.removeAll();

  53. return "forward:/jsp/view";

  54. }

  55. // JSP 跳转

  56. @RequestMapping("/jsp/{jspName}")

  57. public String toJsp(@PathVariable String jspName){

  58. System.out.println("JSP TO -->>" +jspName);

  59. return jspName;

  60. }

  61. private void printInfo(String str){

  62. System.out.println(str);

  63. }

  64. }

XML 配置：

Java代码  

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

  2. <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/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

  3. <display-name>springEhcache</display-name>

  4. <servlet>

  5. <servlet-name>spring</servlet-name>

  6. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  7. <init-param>

  8. <param-name>contextConfigLocation</param-name>

  9. <param-value>classpath:com/config/springmvc-context.xml</param-value>

  10. </init-param>

  11. <load-on-startup>1</load-on-startup>

  12. </servlet>

  13. <servlet-mapping>

  14. <servlet-name>spring</servlet-name>

  15. <url-pattern>/</url-pattern>

  16. </servlet-mapping>

  17. </web-app>

Java代码  

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

  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  3. xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

  4. <!-- service 缓存配置 -->

  5. <cache name="serviceCache"

  6. eternal="false"

  7. maxElementsInMemory="100"

  8. overflowToDisk="false"

  9. diskPersistent="false"

  10. timeToIdleSeconds="0"

  11. timeToLiveSeconds="300"

  12. memoryStoreEvictionPolicy="LRU" />

  13. </ehcache>

Java代码  

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

  2. <beans xmlns="http://www.springframework.org/schema/beans"

  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  4. xmlns:context="http://www.springframework.org/schema/context"

  5. xmlns:oxm="http://www.springframework.org/schema/oxm"

  6. xmlns:mvc="http://www.springframework.org/schema/mvc"

  7. xmlns:cache="http://www.springframework.org/schema/cache"

  8. xmlns:aop="http://www.springframework.org/schema/aop"

  9. xsi:schemaLocation="http://www.springframework.org/schema/mvc

  10. http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd

  11. http://www.springframework.org/schema/beans

  12. http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

  13. http://www.springframework.org/schema/context

  14. http://www.springframework.org/schema/context/spring-context-3.2.xsd

  15. http://www.springframework.org/schema/cache

  16. http://www.springframework.org/schema/cache/spring-cache.xsd">

  17. <!-- 默认扫描 @Component @Repository  @Service @Controller -->

  18. <context:component-scan base-package="com.se" />

  19. <!-- 一些@RequestMapping 请求和一些转换 -->

  20. <mvc:annotation-driven />

  21. <!-- 前后缀 -->

  22. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

  23. <property name="prefix" value="/"/>

  24. <property name="suffix" value=".jsp"/>

  25. </bean>

  26. <!--  静态资源访问 的两种方式  -->

  27. <!-- <mvc:default-servlet-handler/>   -->

  28. <mvc:resources location="/*" mapping="/**" />

  29. <!--  缓存  属性-->

  30. <bean id="cacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">

  31. <property name="configLocation"  value="classpath:com/config/ehcache.xml"/>

  32. </bean>

  33. <!-- 支持缓存注解 -->

  34. <cache:annotation-driven cache-manager="cacheManager" />

  35. <!-- 默认是cacheManager -->

  36. <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">

  37. <property name="cacheManager"  ref="cacheManagerFactory"/>

  38. </bean>

  39. </beans>

JSP 配置：

Java代码  

  1. <%@ page language="java" contentType="text/html; charset=Utf-8" pageEncoding="Utf-8"%>

  2. <html>

  3. <head>

  4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

  5. <title>Insert title here</title>

  6. </head>

  7. <script type="text/javascript" src="<%=request.getContextPath()%>/js/jquery-1.4.3.js"></script>

  8. <body>

  9. <strong>用户信息</strong><br>

  10. 输入编号：<input id="userId">

  11. <a href="#" id="edit">编辑</a>

  12. <a href="#" id="del" >删除</a>

  13. <a href="<%=request.getContextPath()%>/jsp/add">添加</a>

  14. <a href="<%=request.getContextPath()%>/remove-all">清空缓存</a><br/>

  15. <p>所有数据展示:<p/>

  16. ${users }

  17. <p>静态图片访问测试：</p>

  18. <img style="width: 110px;height: 110px" src="<%=request.getContextPath()%>/img/404cx.png"><br>

  19. </body>

  20. <script type="text/javascript">

  21. $(document).ready(function(){

  22. $(‘#userId‘).change(function(){

  23. var userId = $(this).val();

  24. var urlEdit = ‘<%=request.getContextPath()%>/get/‘+userId;

  25. var urlDel = ‘<%=request.getContextPath()%>/del/‘+userId;

  26. $(‘#edit‘).attr(‘href‘,urlEdit);

  27. $(‘#del‘).attr(‘href‘,urlDel);

  28. });

  29. });

  30. </script>

  31. </html>

Java代码  

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"

  2. pageEncoding="UTF-8"%>

  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

  4. <html>

  5. <head>

  6. </head>

  7. <script type="text/javascript" src="../js/jquery-1.4.3.js"></script>

  8. <body>

  9. <strong>编辑</strong><br>

  10. <form id="edit" action="<%=request.getContextPath()%>/update" method="get">

  11. 用户ID：<input id="id" name="id" value="${user.id}"><br>

  12. 用户名：<input id="name" name="name" value="${user.name}"><br>

  13. 用户密码：<input id="password" name="password" value="${user.password}"><br>

  14. <input value="更新" id="update" type="submit">

  15. </form>

  16. </body>

  17. </html>

Java代码  

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"

  2. pageEncoding="UTF-8"%>

  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

  4. <html>

  5. <head>

  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

  7. <title>Insert title here</title>

  8. </head>

  9. <script type="text/javascript" src="../js/jquery-1.4.3.js"></script>>

  10. <body>

  11. <strong>添加</strong>

  12. <form action="<%=request.getContextPath()%>/add" method="post">

  13. 用户ID：<input  name="id" ><br>

  14. 用户名：<input  name="name" ><br>

  15. 用户密码：<input  name="password"><br>

  16. <input value="添加" id="add" type="submit">

  17. </form>

  18. ${users }

  19. </body>

  20. </html>

关于测试方式：

输入地址：http://localhost:8081/springEhcache/jsp/view

然后根据ID 进行查询编辑， 还有添加，以及删除等操作，这里仅仅做简单实例，更多的需要大家自己做写。测试用例的我也导入了，业务可以自己写。

里面用到了很多参考资料：

比如：

这个是google  弄的例子，实例项目类似，就不上传了

http://blog.goyello.com/2010/07/29/quick-start-with-ehcache-annotations-for-spring/

这个是涛ge,对spring cache 的一些解释

http://jinnianshilongnian.iteye.com/blog/2001040

还有就是spring 官网的一些资料，我是自己下的src ，里面文档都有,会上传

自己路径的文件地址/spring-3.2.0.M2/docs/reference/htmlsingle/index.html

关于Ehcache 的介绍，可以参考

官网：http://www.ehcache.org/documentation/get-started/cache-topologies

还有我缓存分类里面转的文章，关于几个主流缓存分类 以及区别的。

小结：

1.现在aop 和DI
用得很多了，也特别的方便，但是框架太多了，但是要核心源码搞清楚了才行

2.上面的缓存机制还可以运用到类上，和事务差不多，反正里面东西挺多了，
我就不一一介绍了，可以自己进行扩展研究。

3.感觉spring
的缓存，颗粒度还可以再细，精确到元素，或者可以提供对指定方法，指定内容的时间控制，而不是只能通过xml,也可以在方法上直接加参数，细化元素的缓存时间，关于这点的作用来说，我项目中，比如A
结果集，我想缓存10秒，B结果集想缓存50秒，就不用再次去配置缓存了。而且ehcache 是支持元素级的颗粒控制，各有想法吧。当然看自己喜欢用xml
方式拦截呢，还是注解使用，这里仅提供了注解方式，我比较喜欢~。~

4.有问题的地方欢迎大家，多指正！

不能超过10M，就分开传的，包括项目，以及文档介绍

spring3.2+ehcache 注解使用,布布扣,bubuko.com

时间： 2024-10-15 15:32:27

spring3.2+ehcache 注解使用的相关文章

Spring3.2新注解@ControllerAdvice

Spring3.2新注解@ControllerAdvice @ControllerAdvice,是spring3.2提供的新注解,从名字上可以看出大体意思是控制器增强.让我们先看看@ControllerAdvice的实现: Java代码   @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface ControllerAdvice { } 没什么特别

ehcache注解使用问题常见总结

1. 支持缓存的方法最好有传入参数和返回数据 1.1 没有入参将无法自定义key,即无法保证数据更新时实时更新缓存中对应的数据(如果数据不会被改变则忽略)1.2 没有返回数据的话,当从缓存中获取的数据时,如法获取到数据 2. 不要在类的内部调用支持缓存的方法 2.1 对象内部调用支持缓存的方法是不会触发缓存功能的,因为ehcache要使用代理才可以缓存 3. 使用@CachePut注解时属性key和返回数据类型要一致 3.1 对应的@Cacheable和@CachePut,属性的key要保持一致

缓存初解（三）---Spring3.0基于注解的缓存配置+Ehcache和OScache

本文将构建一个普通工程来说明spring注解缓存的使用方式,关于如何在web应用中使用注解缓存,请参见: Spring基于注解的缓存配置--web应用实例 一.简介 在spring的modules包中提供对许多第三方缓存方案的支持,包括: EHCache OSCache(OpenSymphony) JCS GigaSpaces JBoss Cache 等等. 将这些第三方缓存方案配置在spring中很简单,网上有许多介绍,这里只重点介绍如何配置基于注解的缓存配置. 本文将通过例举EHCache和

在Spring3中使用注解(@Scheduled)创建计划任务

Spring3中加强了注解的使用,其中计划任务也得到了增强,现在创建一个计划任务只需要两步就完成了: 创建一个Java类,添加一个无参无返回值的方法,在方法上用@Scheduled注解修饰一下: 在Spring配置文件中添加三个<task:**** />节点: 最后说明一下,第一步创建的Java类要成为Spring可管理的Bean,可以直接写在XML里,也可以@Component一下 计划任务类: /** * com.zywang.spring.task.SpringTaskDemo.java

spring + ehcache 注解使用实例

1.pom.xml中添加ehcache依赖包 <dependency>            <groupId>net.sf.ehcache</groupId>            <artifactId>ehcache</artifactId>            <version>2.9.1</version>        </dependency> 2.在classpath下增加ehcache配置文

spring整合ehcache 注解实现查询缓存，并实现实时缓存更新或删除

写在前面:上一篇博客写了spring cache和ehcache的基本介绍,个人建议先把这些最基本的知识了解了才能对今天主题有所感触.不多说了,开干! 注:引入jar <!-- 引入ehcache缓存 --> <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.8.3</version&g

spring4.x hibernate4.x 整合 ehcache 注解 annotate

废话不说 直接贴源码链接 :  https://git.oschina.net/alexgaoyh/alexgaoyh.git 使用ehcache来提高系统的性能,现在用的非常多, 也支持分布式的缓存,在hibernate当中作为二级缓存的实现产品,可以提高查询性能. pom.xml <dependency>     <groupId>org.hibernate</groupId>     <artifactId>hibernate-ehcache</

Spring3.0MVC+MyBatis3.0+Spring3.0(全注解列子)

说明:      附件是项目截图及所需包截图      此项目在tomcat,weblogic10下测试通过 配置文件 web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/

ssh2项目整合 struts2.1+hibernate3.3+spring3 基于hibernate注解和struts2注解

项目目录结构如下: 核心配置文件: web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLo