`
greemranqq
  • 浏览: 974653 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类
最新评论

spring3.2+ehcache 注解使用

阅读更多

我一直不喜欢hibernate ,但是框架是spring mvc + hibernate 搭建,而且我喜欢自己写SQL,数据层 是自己封装的也写东西,没用hql 语句,也就没用他那些缓存,自己也想缓存一部分数据,所以就想自己写个缓存,或者用现成的缓存,通过spring 拦截,实现颗粒度比较细,容易控制的缓存。了解了下,spring 3.0 以后,应该从3.1 以后吧,注解方式的缓存就已经实现,下面是我自己做的例子,分享给大家:

 

例子内容介绍:

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

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

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

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

 

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

package com.se;

public class User {
	public Integer id;
	public String name;
	public String password;
	
	// 这个需要,不然在实体绑定的时候出错
	public User(){}
	
	public User(Integer id, String name, String password) {
		super();
		this.id = id;
		this.name = name;
		this.password = password;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", password=" + password
				+ "]";
	}
}

 

package com.se;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Repository;

/**
 * 静态数据,模拟数据库操作
 */
@Repository("userDao")
public class UserDao {
	
	List<User> users = initUsers();
	
	public User findById(Integer id){
		User user = null;
		for(User u : users){
			if(u.getId().equals(id)){
				user = u;
			}
		}
		return user;
	}
	
	public void removeById(Integer id){
		User user = null;
		for(User u : users){
			if(u.getId().equals(id)){
				user = u;
				break;
			}
		}
		users.remove(user);
	}
	
	public void addUser(User u){
		users.add(u);
	}
	
	public void updateUser(User u){
		addUser(u);
	}
	
	
	// 模拟数据库
	private List<User> initUsers(){
		List<User> users = new ArrayList<User>();
		User u1 = new User(1,"张三","123");
		User u2 = new User(2,"李四","124");
		User u3 = new User(3,"王五","125");
		users.add(u1);
		users.add(u2);
		users.add(u3);
		return users;
	}
}

 

package com.se;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
/**
 * 业务操作,
 */
@Service("userService")
public class UserService {
	
	@Autowired
	private UserDao userDao;
	
	// 查询所有,不要key,默认以方法名+参数值+内容 作为key
	@Cacheable(value = "serviceCache")
	public List<User> getAll(){
		printInfo("getAll");
		return userDao.users;
	}
	// 根据ID查询,ID 我们默认是唯一的
	@Cacheable(value = "serviceCache", key="#id")
	public User findById(Integer id){
		printInfo(id);
		return userDao.findById(id);
	}
	// 通过ID删除
	@CacheEvict(value = "serviceCache", key="#id")
	public void removeById(Integer id){
		userDao.removeById(id);
	}
	
	public void addUser(User u){
		if(u != null && u.getId() != null){
			userDao.addUser(u);
		}
	}
	// key 支持条件,包括 属性condition ,可以 id < 10 等等类似操作
	// 更多介绍,请看参考的spring 地址
	@CacheEvict(value="serviceCache", key="#u.id")
	public void updateUser(User u){
		removeById(u.getId());
		userDao.updateUser(u);
	}
	
	// allEntries 表示调用之后,清空缓存,默认false,
	// 还有个beforeInvocation 属性,表示先清空缓存,再进行查询
	@CacheEvict(value="serviceCache",allEntries=true)
	public void removeAll(){
		System.out.println("清除所有缓存");
	}
	
	private void printInfo(Object str){
		System.out.println("非缓存查询----------findById"+str);
	}
	
	
}

 

package com.se;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserControl {
	
	@Autowired
	private UserService userService;
	
	// 提前绑定视图,提前绑定数据,方便查看数据变化
	@ModelAttribute("users")
	public List<User> cityList() {
	    return userService.getAll();
	} 

	// 根据ID查询
	@RequestMapping("/get/{id}")
	public String getUserById(Model model,@PathVariable Integer id){
		User u = userService.findById(id);
		System.out.println("查询结果:"+u);
		model.addAttribute("user", u);
		return "forward:/jsp/edit";
	}
	// 删除
	@RequestMapping("/del/{id}")
	public String deleteById(Model model,@PathVariable Integer id){
		printInfo("删除-----------");
		userService.removeById(id);
		return "redirect:/jsp/view";
	}
	// 添加
	@RequestMapping("/add")
	public String addUser(Model model,@ModelAttribute("user") User user){
		printInfo("添加----------");
		userService.addUser(user);
		return "redirect:/jsp/view";
	}
	// 修改
	@RequestMapping("/update")
	public String update(Model model,@ModelAttribute User u){
		printInfo("开始更新---------");
		userService.updateUser(u);
		model.addAttribute("user", u);
		return "redirect:/jsp/view";
	}
	// 清空所有
	@RequestMapping("/remove-all")
	public String removeAll(){
		printInfo("清空-------------");
		userService.removeAll();
		return "forward:/jsp/view";
	}
	// JSP 跳转
	@RequestMapping("/jsp/{jspName}")
	public String toJsp(@PathVariable String jspName){
		System.out.println("JSP TO -->>" +jspName);
		return jspName;
	}
	
	private void printInfo(String str){
		System.out.println(str);
	}
}

 

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" 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">
  <display-name>springEhcache</display-name>
  <servlet>  
        <servlet-name>spring</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
          <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:com/config/springmvc-context.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup>  
    </servlet> 
     
    <servlet-mapping>  
        <servlet-name>spring</servlet-name>  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  
</web-app>

 

<?xml version="1.0" encoding="UTF-8"?>  
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">  
<!-- service 缓存配置 -->
<cache name="serviceCache"
	eternal="false"  
    maxElementsInMemory="100" 
    overflowToDisk="false" 
    diskPersistent="false"  
    timeToIdleSeconds="0" 
    timeToLiveSeconds="300"  
    memoryStoreEvictionPolicy="LRU" /> 
</ehcache> 

 

<?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:oxm="http://www.springframework.org/schema/oxm"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd  
        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/cache 
        http://www.springframework.org/schema/cache/spring-cache.xsd"> 

    <!-- 默认扫描 @Component @Repository  @Service @Controller -->
    <context:component-scan base-package="com.se" />
    <!-- 一些@RequestMapping 请求和一些转换 -->
    <mvc:annotation-driven />  
    
    <!-- 前后缀 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
    	<property name="prefix" value="/"/>  
    	<property name="suffix" value=".jsp"/>
    </bean>
    <!--  静态资源访问 的两种方式  -->
    <!-- <mvc:default-servlet-handler/>   -->
    <mvc:resources location="/*" mapping="/**" /> 
    
    
    <!--  缓存  属性-->
    <bean id="cacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">  
        <property name="configLocation"  value="classpath:com/config/ehcache.xml"/> 
	</bean> 
	
	<!-- 支持缓存注解 -->
    <cache:annotation-driven cache-manager="cacheManager" />
    
    <!-- 默认是cacheManager -->
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">  
        <property name="cacheManager"  ref="cacheManagerFactory"/>  
    </bean>  
</beans> 

 

 

JSP 配置:

<%@ page language="java" contentType="text/html; charset=Utf-8" pageEncoding="Utf-8"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<script type="text/javascript" src="<%=request.getContextPath()%>/js/jquery-1.4.3.js"></script>
<body>
<strong>用户信息</strong><br>
输入编号:<input id="userId">

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

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

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

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


<p>所有数据展示:<p/>
${users }


<p>静态图片访问测试:</p>
<img style="width: 110px;height: 110px" src="<%=request.getContextPath()%>/img/404cx.png"><br>
</body>
<script type="text/javascript">
$(document).ready(function(){
	$('#userId').change(function(){
		var userId = $(this).val();
		var urlEdit = '<%=request.getContextPath()%>/get/'+userId;
		var urlDel = '<%=request.getContextPath()%>/del/'+userId;
		$('#edit').attr('href',urlEdit);
		$('#del').attr('href',urlDel);
	});
});
</script>
</html>

 

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
</head>
<script type="text/javascript" src="../js/jquery-1.4.3.js"></script>
<body>
	<strong>编辑</strong><br>
	<form id="edit" action="<%=request.getContextPath()%>/update" method="get">
		用户ID:<input id="id" name="id" value="${user.id}"><br>
		用户名:<input id="name" name="name" value="${user.name}"><br>
		用户密码:<input id="password" name="password" value="${user.password}"><br>
		<input value="更新" id="update" type="submit">
	</form>
</body>
</html>

 

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<script type="text/javascript" src="../js/jquery-1.4.3.js"></script>>
<body>
	<strong>添加</strong>
	<form action="<%=request.getContextPath()%>/add" method="post">
		用户ID:<input  name="id" ><br>
		用户名:<input  name="name" ><br>
		用户密码:<input  name="password"><br>
		<input value="添加" id="add" type="submit">
	</form>
	${users }
</body>
</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,就分开传的,包括项目,以及文档介绍

 

 

  • jar.7z (9.9 MB)
  • 下载次数: 750
4
3
分享到:
评论
13 楼 greemranqq 2015-04-19  
穿围裙的程序员 写道
Java编码的时候直接在new Element()的时候就可以设置Element级的超时

如何用注解设置Element级别的超时?


其实我再这里也没发现这个东西,或者我不够仔细,反正颗粒度是不够的。
我是配置了多个,然后指定使用的。比如5分总 10分钟 1小时  天。。等等

要么自己写一个注解。

我现在用memcache 了,他的颗粒度是支持到这个的。
12 楼 穿围裙的程序员 2015-04-18  
Java编码的时候直接在new Element()的时候就可以设置Element级的超时

如何用注解设置Element级别的超时?
11 楼 greemranqq 2015-03-17  
mmmmmmmmj 写道
greemranqq 写道
greemranqq 写道
mmmmmmmmj 写道
你好,我结合了数据库试了下,添加完之后数据不能刷新,只有点一下清空缓存数据才能更新出来,或者把添加后的 redirect:/jsp/view 改成 forward:/jsp/view 。请问这是为什么?

添加的时候,你的放到缓存里面。不然缓存里面的值 还是以前的,包括 更新也是一样的。
你可以看看 @CachePut  和 @CacheEvict


至于JSP 那里问题,你参考 转发和重定向

用了 cacheput数据也刷新不了,用forward页面数据能更新,redirect就不行,


我的理解是 业务层的缓存 和 forward 这些没关的。你可以debug 进缓存 比如cacheput 或者 其他缓存逐 里面去看看执行的时候,放进去没有。或者其他地方配置是否有问题。
10 楼 mmmmmmmmj 2015-03-17  
greemranqq 写道
greemranqq 写道
mmmmmmmmj 写道
你好,我结合了数据库试了下,添加完之后数据不能刷新,只有点一下清空缓存数据才能更新出来,或者把添加后的 redirect:/jsp/view 改成 forward:/jsp/view 。请问这是为什么?

添加的时候,你的放到缓存里面。不然缓存里面的值 还是以前的,包括 更新也是一样的。
你可以看看 @CachePut  和 @CacheEvict


至于JSP 那里问题,你参考 转发和重定向

用了 cacheput数据也刷新不了,用forward页面数据能更新,redirect就不行,
9 楼 greemranqq 2015-03-17  
greemranqq 写道
mmmmmmmmj 写道
你好,我结合了数据库试了下,添加完之后数据不能刷新,只有点一下清空缓存数据才能更新出来,或者把添加后的 redirect:/jsp/view 改成 forward:/jsp/view 。请问这是为什么?

添加的时候,你的放到缓存里面。不然缓存里面的值 还是以前的,包括 更新也是一样的。
你可以看看 @CachePut  和 @CacheEvict


至于JSP 那里问题,你参考 转发和重定向
8 楼 greemranqq 2015-03-17  
mmmmmmmmj 写道
你好,我结合了数据库试了下,添加完之后数据不能刷新,只有点一下清空缓存数据才能更新出来,或者把添加后的 redirect:/jsp/view 改成 forward:/jsp/view 。请问这是为什么?

添加的时候,你的放到缓存里面。不然缓存里面的值 还是以前的,包括 更新也是一样的。
你可以看看 @CachePut  和 @CacheEvict
7 楼 mmmmmmmmj 2015-03-17  
你好,我结合了数据库试了下,添加完之后数据不能刷新,只有点一下清空缓存数据才能更新出来,或者把添加后的 redirect:/jsp/view 改成 forward:/jsp/view 。请问这是为什么?
6 楼 shmily2038 2014-10-24  
greemranqq 写道
shmily2038 写道
看了下,是可以实现缓存了,不过配置这块,还有挺多细节的要注意的。


这仅仅是这个入门的资料~。~,我道行不高,没那么多深奥的东西,关于实战方面,我们做线下数据分析的,1个小时分析一次 类似的数据,缓存这块用得比较多,不用长时间访问数据库,其实所谓的实战 还得看 你们缓存在 业务上的应用是什么,首先要明白缓存是什么,能给你们带来什么好处,用哪一款,等等,这些才是需要 你实际考虑的,而技术本身太多,找资料都能学会的


嗯,技术学习只是时间问题,具体看业务就是
5 楼 greemranqq 2014-10-24  
shmily2038 写道
看了下,是可以实现缓存了,不过配置这块,还有挺多细节的要注意的。


这仅仅是这个入门的资料~。~,我道行不高,没那么多深奥的东西,关于实战方面,我们做线下数据分析的,1个小时分析一次 类似的数据,缓存这块用得比较多,不用长时间访问数据库,其实所谓的实战 还得看 你们缓存在 业务上的应用是什么,首先要明白缓存是什么,能给你们带来什么好处,用哪一款,等等,这些才是需要 你实际考虑的,而技术本身太多,找资料都能学会的
4 楼 greemranqq 2014-10-24  
xielanjun910728 写道
要是使用数据库,该怎么实现?

额,数据库你直接加上就可以了,也就是把dao 层的数据 来源 从数据库获取
3 楼 xielanjun910728 2014-10-21  
要是使用数据库,该怎么实现?
2 楼 greemranqq 2014-01-10  
shmily2038 写道
看了下,是可以实现缓存了,不过配置这块,还有挺多细节的要注意的。

谢谢,大哥,这块实战还不够,能介绍一些这方面的实际的例子吗?或者介绍一下深入的方向
1 楼 shmily2038 2014-01-10  
看了下,是可以实现缓存了,不过配置这块,还有挺多细节的要注意的。

相关推荐

    Spring3.2 MVC+ehcache+接口测试

    标题 "Spring3.2 MVC+ehcache+接口测试" 暗示了这个项目或教程是关于使用Spring框架的MVC模块,Ehcache缓存系统以及如何进行接口测试的。我们将深入探讨这三个核心概念。 **Spring MVC** Spring MVC是Spring框架的...

    SpringMVC+Spring3.2+Hibernate4整合

    在本项目中,"SpringMVC+Spring3.2+Hibernate4整合" 涉及到的核心知识点包括: 1. **Spring MVC**: - Spring MVC 是 Spring 框架的一个模块,专门用于处理 Web 应用的请求-响应模型。 - 它提供了模型-视图-控制...

    springMVC3.2+Hibernate4的基本配置

    缓存可以提高应用性能,Spring支持多种缓存实现,如 EhCache 或 Redis。这里我们使用Hibernate的第二级缓存: ```xml ``` 最后,拦截器允许你在请求处理前或后执行自定义逻辑,例如日志记录、权限检查等: ```...

    Spring 3.2 Eclipse 源文件

    10. **缓存抽象**:Spring 3.2引入了统一的缓存抽象层,支持多种缓存实现,如 EhCache、Guava 和 Hazelcast。 通过下载的"spring-framework-3.2.x"压缩包,开发者可以在Eclipse中直接导入项目,查看Spring框架的源...

    Spring3.2_Hibernate4.2_JPA2全注解实例

    总的来说,这个实例涵盖了Spring 3.2的IoC和事务管理、Hibernate 4.2的ORM能力、JPA 2.0的注解驱动模型以及Ehcache的缓存优化,演示了一个完整的Java企业级应用的开发流程。开发者可以从中学习到如何设置和配置这些...

    手动整合Struts1.3 +hibernate3.2+Spring2.5 .txt

    ### 手动整合Struts1.3 + Hibernate3.2 + Spring2.5 #### 一、概述 本文档旨在详细介绍如何手动整合Struts 1.3、Hibernate 3.2 和 Spring 2.5框架,实现一个典型的MVC架构应用。通过这种方式,可以将业务逻辑、...

    spring 3.2jar包

    在下载的"spring3.2"压缩包中,通常包含所有必需的Spring 3.2核心库以及相关模块的jar文件,例如spring-core、spring-context、spring-aop、spring-webmvc等。开发者可以根据具体项目需求选择导入相应的jar包。虽然...

    SpringMVC+Hibernate3.2+mysql

    在实际项目中,配置SpringMVC、Hibernate3.2和MySQL需要编写XML配置文件或使用注解。配置内容包括数据源设置、SessionFactory创建、DataSource配置、Hibernate的实体类定义、以及SpringMVC的相关配置,如...

    Spring与ehcache结合使用

    ##### 3.2 在Spring配置文件中集成ehcache 接下来,需要在Spring的配置文件中引入ehcache。以下是一个简单的配置示例: ```xml &lt;!-- Spring配置文件中配置ehcache --&gt; &lt;beans xmlns="http://www.springframework....

    spring3.2 各种jar

    8. **集成支持**:Spring 3.2 支持与各种企业级技术的集成,如 Quartz 定时任务、邮件服务、缓存(如 EhCache 和 Redis)等。 9. **测试支持**:Spring 提供了`spring-test.jar`,包含测试支持类和集成测试框架,...

    DWR3.0_Spring3.2_Hibernate4.2_JPA全注解实例

    DWR3.0 Spring3.2 Hibernate4.2 JPA全注解实例。采用JTA事务管理,配置ehcache为二级缓存,在glassfish3.2.2和postgresql9测试通过。参考网上的资料整理。.

    Spring3.2中文版.docx

    该文档详细介绍了Spring 3.2版本的各种特性和增强功能,旨在帮助开发者更好地理解和使用Spring框架。 在Spring 3.2中,有多个重要的更新和新特性: 1. **核心API更新**:引入了Java 5的支持,增强了API的性能和...

    Wicket6.7_Spring3.2_Hibernate4.2_EJB全注解实例

    Wicket6.7 Spring3.2 Hibernate4.2 EJB全注解实例.采用JTA事务管理,配置ehcache为二级缓存,在glassfish3.2.2和postgresql9测试通过。参考网上的资料整理。

    spring api 3.2 RC1 真正的api

    Spring 3.2 RC1进一步优化了依赖注入机制,使得组件之间的依赖关系可以通过构造函数、setter方法或属性注解来声明,降低了组件间的耦合度,提高了代码的可测试性。 4. **AOP(面向切面编程)**: AOP是Spring的...

    Ehcache分布式缓存与其在spring中的使用

    ##### 3.2 缓存注解使用 - `@Cacheable`:用于方法上,表示方法的结果应该被缓存。 - `@CachePut`:用于更新缓存,方法执行后将结果存入缓存。 - `@CacheEvict`:用于清空缓存,通常在更新数据时使用。 示例代码:...

    spring 3.2.8 jar包

    11. **异步方法支持**:在Spring 3.2中,可以使用`@Async`注解标记方法为异步执行,提高应用程序的并发性能。 12. **缓存抽象**:提供了通用的缓存抽象,支持EhCache、Hazelcast、Infinispan等多种缓存实现。 13. ...

    SSH三层架构MVC,Hibernate(ehcache)二级缓存技术,源代码

    SSH三层架构MVC(struts1.3+spring2.x+hibernate3.2),Hibernate(ehcache)二级缓存技术,Spring 注解形式依赖注入,ehcache缓存 源代码,内有MySql anbyke.sql文件,方便创建数据库演示效果!

    spring-framework-3.2.1.RELEASE

    7. **缓存抽象**:Spring 3.2引入了统一的缓存抽象层,支持EhCache、Guava Cache等多种缓存实现,简化了缓存管理。 8. **异步处理**:3.2.1.RELEASE版本引入了异步方法调用的支持,通过`@Async`注解,可以在后台...

Global site tag (gtag.js) - Google Analytics