现在位置：
Spring4整合（集成）Redis
&modelVersion&4.0.0&/modelVersion&
&groupId&com.x.redis&/groupId&
&artifactId&springredis&/artifactId&
&version&0.0.1-SNAPSHOT&/version&
&dependencies&
&dependency&
&groupId&org.springframework.data&/groupId&
&artifactId&spring-data-redis&/artifactId&
&version&1.0.2.RELEASE&/version&
&/dependency&
&dependency&
&groupId&org.springframework&/groupId&
&artifactId&spring-test&/artifactId&
&version&3.1.2.RELEASE&/version&
&scope&test&/scope&
&/dependency&
&dependency&
&groupId&redis.clients&/groupId&
&artifactId&jedis&/artifactId&
&version&2.1.0&/version&
&/dependency&
&dependency&
&groupId&junit&/groupId&
&artifactId&junit&/artifactId&
&version&4.8.2&/version&
&scope&test&/scope&
&/dependency&
&/dependencies&
------------------------------------------------------------------------------------------------------
spring配置文件(applicationContext.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:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" 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"&
&context:property-placeholder location="classpath:redis.properties" /&
&bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"&
&property name="maxIdle" value="${redis.maxIdle}" /&
&property name="maxActive" value="${redis.maxActive}" /&
&property name="maxWait" value="${redis.maxWait}" /&
&property name="testOnBorrow" value="${redis.testOnBorrow}" /&
&bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig" /&
&bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"&
&property name="connectionFactory" ref="connectionFactory" /&
&bean id="userDao" class="com.x.dao.impl.UserDao" /&
-------------------------------------------------------------------------------------------------------
redis.properties
# Redis settings
redis.host=localhost
redis.port=6379
redis.pass=java2000_wl
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
java代码：
package com.x.
import java.io.S
* @author http://blog.csdn.net/java2000_wl
* @version &b&1.0&/b&
public class User implements Serializable {
private static final long serialVersionUID = -0393952L;
* &br&------------------------------&br&
public User() {
* &br&------------------------------&br&
public User(String id, String name, String password) {
this.name =
this.password =
* @return the id
public String getId() {
* @param id the id to set
public void setId(String id) {
* 获得name
* @return the name
public String getName() {
* 设置name
* @param name the name to set
public void setName(String name) {
this.name =
* 获得password
* @return the password
public String getPassword() {
* 设置password
* @param password the password to set
public void setPassword(String password) {
this.password =
package com.x.
import org.springframework.beans.factory.annotation.A
import org.springframework.data.redis.core.RedisT
import org.springframework.data.redis.serializer.RedisS
* AbstractBaseRedisDao
* @author http://blog.csdn.net/java2000_wl
* @version &b&1.0&/b&
public abstract class AbstractBaseRedisDao&K, V& {
@Autowired
protected RedisTemplate&K, V& redisT
* 设置redisTemplate
* @param redisTemplate the redisTemplate to set
public void setRedisTemplate(RedisTemplate&K, V& redisTemplate) {
this.redisTemplate = redisT
* 获取 RedisSerializer
* &br&------------------------------&br&
protected RedisSerializer&String& getRedisSerializer() {
return redisTemplate.getStringSerializer();
package com.x.
import java.util.L
import com.x.entity.U
* @author http://blog.csdn.net/java2000_wl
* @version &b&1.0&/b&
public interface IUserDao {
* &br&------------------------------&br&
* @param user
boolean add(User user);
* 批量新增 使用pipeline方式
* &br&------------------------------&br&
* @param list
boolean add(List&User& list);
* &br&------------------------------&br&
* @param key
void delete(String key);
* 删除多个
* &br&------------------------------&br&
* @param keys
void delete(List&String& keys);
* &br&------------------------------&br&
* @param user
boolean update(User user);
* 通过key获取
* &br&------------------------------&br&
* @param keyId
User get(String keyId);
package com.x.dao.
import java.util.ArrayL
import java.util.L
import org.springframework.dao.DataAccessE
import org.springframework.data.redis.connection.RedisC
import org.springframework.data.redis.core.RedisC
import org.springframework.data.redis.serializer.RedisS
import org.springframework.util.A
import com.x.dao.AbstractBaseRedisD
import com.x.dao.IUserD
import com.x.entity.U
* @author http://blog.csdn.net/java2000_wl
* @version &b&1.0&/b&
public class UserDao extends AbstractBaseRedisDao&String, User& implements IUserDao {
*&br&------------------------------&br&
* @param user
public boolean add(final User user) {
boolean result = redisTemplate.execute(new RedisCallback&Boolean&() {
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer&String& serializer = getRedisSerializer();
byte[] key
= serializer.serialize(user.getId());
byte[] name = serializer.serialize(user.getName());
return connection.setNX(key, name);
* 批量新增 使用pipeline方式
*&br&------------------------------&br&
*@param list
public boolean add(final List&User& list) {
Assert.notEmpty(list);
boolean result = redisTemplate.execute(new RedisCallback&Boolean&() {
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer&String& serializer = getRedisSerializer();
for (User user : list) {
byte[] key
= serializer.serialize(user.getId());
byte[] name = serializer.serialize(user.getName());
connection.setNX(key, name);
}, false, true);
* &br&------------------------------&br&
* @param key
public void delete(String key) {
List&String& list = new ArrayList&String&();
list.add(key);
delete(list);
* 删除多个
* &br&------------------------------&br&
* @param keys
public void delete(List&String& keys) {
redisTemplate.delete(keys);
* &br&------------------------------&br&
* @param user
public boolean update(final User user) {
String key = user.getId();
if (get(key) == null) {
throw new NullPointerException("数据行不存在, key = " + key);
boolean result = redisTemplate.execute(new RedisCallback&Boolean&() {
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer&String& serializer = getRedisSerializer();
byte[] key
= serializer.serialize(user.getId());
byte[] name = serializer.serialize(user.getName());
connection.set(key, name);
* 通过key获取
* &br&------------------------------&br&
* @param keyId
public User get(final String keyId) {
User result = redisTemplate.execute(new RedisCallback&User&() {
public User doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer&String& serializer = getRedisSerializer();
byte[] key = serializer.serialize(keyId);
byte[] value = connection.get(key);
if (value == null) {
String name = serializer.deserialize(value);
return new User(keyId, name, null);
import java.util.ArrayL
import java.util.L
import junit.framework.A
import org.junit.T
import org.springframework.beans.factory.annotation.A
import org.springframework.test.context.ContextC
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextT
import com.x.dao.IUserD
import com.x.entity.U
* @author http://blog.csdn.net/java2000_wl
* @version &b&1.0&/b&
@ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
public class RedisTest extends AbstractJUnit4SpringContextTests {
@Autowired
private IUserDao userD
* &br&------------------------------&br&
public void testAddUser() {
User user = new User();
user.setId("user1");
user.setName("java2000_wl");
boolean result = userDao.add(user);
Assert.assertTrue(result);
* 批量新增 普通方式
* &br&------------------------------&br&
public void testAddUsers1() {
List&User& list = new ArrayList&User&();
for (int i = 10; i & 50000; i++) {
User user = new User();
user.setId("user" + i);
user.setName("java2000_wl" + i);
list.add(user);
long begin = System.currentTimeMillis();
for (User user : list) {
userDao.add(user);
System.out.println(System.currentTimeMillis() -
* 批量新增 pipeline方式
* &br&------------------------------&br&
public void testAddUsers2() {
List&User& list = new ArrayList&User&();
for (int i = 10; i & 1500000; i++) {
User user = new User();
user.setId("user" + i);
user.setName("java2000_wl" + i);
list.add(user);
long begin = System.currentTimeMillis();
boolean result = userDao.add(list);
System.out.println(System.currentTimeMillis() - begin);
Assert.assertTrue(result);
* &br&------------------------------&br&
public void testUpdate() {
User user = new User();
user.setId("user1");
user.setName("new_password");
boolean result = userDao.update(user);
Assert.assertTrue(result);
* 通过key删除单个
* &br&------------------------------&br&
public void testDelete() {
String key = "user1";
userDao.delete(key);
* 批量删除
* &br&------------------------------&br&
public void testDeletes() {
List&String& list = new ArrayList&String&();
for (int i = 0; i & 10; i++) {
list.add("user" + i);
userDao.delete(list);
* &br&------------------------------&br&
public void testGetUser() {
String id = "user1";
User user = userDao.get(id);
Assert.assertNotNull(user);
Assert.assertEquals(user.getName(), "java2000_wl");
* 设置userDao
* @param userDao the userDao to set
public void setUserDao(IUserDao userDao) {
this.userDao = userDspring 结合 Redis 例子,简单入门例子 - HK学习 - ITeye技术网站
博客分类：
oyhk 学习笔记
好了费话不多说了,介绍下spring 结合redis是怎么操作数据的 这里我用了maven管理,由于简单嘛,依赖下包就行了..不用单独去依赖包,成了我的习惯
好了,下面是pom的代码
&project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&redis&/groupId&
&artifactId&redis&/artifactId&
&version&0.0.1-SNAPSHOT&/version&
&dependencies&
&dependency&
&groupId&org.springframework.data&/groupId&
&artifactId&spring-data-redis&/artifactId&
&version&1.0.2.RELEASE&/version&
&/dependency&
&/dependencies&
&/project&
在pom里添加了redis spring客户端的依赖,那么所有的jar包都会帮你自动下载下来,是不是很方便啊,哈
下面是spring-context.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:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd
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-3.1.xsd"&
&!--注解说明 --&
&context:annotation-config /&
&!-- 把标记了@Controller注解的类转换为bean --&
&context:component-scan base-package="com.mkfree.**" /&
&!-- redis工厂 --&
&bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:host-name="192.168.9.140" p:port="6379" p:password="" /&
&!-- redis服务封装 --&
&bean id="redisService" class="com.mkfree.redis.test.RedisService"&
这里配置了一个跟spring 集成的redis客户端,ip port password自己定哦,这里我在redis配置文件了定义了需求密码认证,你们先不要用吧,为了简单起见
下面是RedisService,里面包含了对redis的方法,还有更多的方法没有去使用,这里当一个入门的小例子吧
package com.mkfree.redis.
import java.util.S
import org.springframework.beans.factory.annotation.A
import org.springframework.beans.factory.annotation.Q
import org.springframework.data.redis.connection.jedis.JedisConnectionF
import redis.clients.jedis.J
* 封装redis 缓存服务器服务接口
* @author hk
上午3:09:18
public class RedisService {
* 通过key删除（字节）
* @param key
public void del(byte [] key){
this.getJedis().del(key);
* 通过key删除
* @param key
public void del(String key){
this.getJedis().del(key);
* 添加key value 并且设置存活时间(byte)
* @param key
* @param value
* @param liveTime
public void set(byte [] key,byte [] value,int liveTime){
this.set(key, value);
this.getJedis().expire(key, liveTime);
* 添加key value 并且设置存活时间
* @param key
* @param value
* @param liveTime
public void set(String key,String value,int liveTime){
this.set(key, value);
this.getJedis().expire(key, liveTime);
* 添加key value
* @param key
* @param value
public void set(String key,String value){
this.getJedis().set(key, value);
/**添加key value (字节)(序列化)
* @param key
* @param value
public void set(byte [] key,byte [] value){
this.getJedis().set(key, value);
* 获取redis value (String)
* @param key
public String get(String key){
String value = this.getJedis().get(key);
* 获取redis value (byte [] )(反序列化)
* @param key
public byte[] get(byte [] key){
return this.getJedis().get(key);
* 通过正则匹配keys
* @param pattern
public Set&String& keys(String pattern){
return this.getJedis().keys(pattern);
* 检查key是否已经存在
* @param key
public boolean exists(String key){
return this.getJedis().exists(key);
* 清空redis 所有数据
public String flushDB(){
return this.getJedis().flushDB();
* 查看redis里有多少数据
public long dbSize(){
return this.getJedis().dbSize();
* 检查是否连接成功
public String ping(){
return this.getJedis().ping();
* 获取一个jedis 客户端
private Jedis getJedis(){
if(jedis == null){
return jedisConnectionFactory.getShardInfo().createResource();
private RedisService (){
//操作redis客户端
private static J
@Autowired
@Qualifier("jedisConnectionFactory")
private JedisConnectionFactory jedisConnectionF
下面是测试代码TestRedis.java
package com.mkfree.redis.
import java.util.S
import org.springframework.context.ApplicationC
import org.springframework.context.support.ClassPathXmlApplicationC
* redis spring 简单例子
* @author hk
上午10:40:15
public class TestRedis {
public static void main(String[] args) throws InterruptedException {
ApplicationContext app = new ClassPathXmlApplicationContext("classpath:spring-context.xml");
//这里已经配置好,属于一个redis的服务接口
RedisService redisService = (RedisService) app.getBean("redisService");
String ping = redisService.ping();//测试是否连接成功,连接成功输出PONG
System.out.println(ping);
//首先,我们看下redis服务里是否有数据
long dbSizeStart = redisService.dbSize();
System.out.println(dbSizeStart);
redisService.set("username", "oyhk");//设值(查看了源代码,默认存活时间30分钟)
String username = redisService.get("username");//取值
System.out.println(username);
redisService.set("username1", "oyhk1", 1);//设值,并且设置数据的存活时间(这里以秒为单位)
String username1 = redisService.get("username1");
System.out.println(username1);
Thread.sleep(2000);//我睡眠一会,再去取,这个时间超过了,他的存活时间
String liveUsername1 = redisService.get("username1");
System.out.println(liveUsername1);//输出null
//是否存在
boolean exist = redisService.exists("username");
System.out.println(exist);
//查看keys
Set&String& keys = redisService.keys("*");//这里查看所有的keys
System.out.println(keys);//只有username username1(已经清空了)
redisService.set("username2", "oyhk2");
String username2 = redisService.get("username2");
System.out.println(username2);
redisService.del("username2");
String username2_2 = redisService.get("username2");
System.out.println(username2_2);//如果为null,那么就是删除数据了
long dbSizeEnd = redisService.dbSize();
System.out.println(dbSizeEnd);
//清空reids所有数据
//redisService.flushDB();
好了入门例子就先这么多了...如果有什么疑问,可以加我QQ
联系我,交流学习方法
项目源代码下载:
浏览: 143683 次
来自: 广州
private Jedis getJedis(){if(jed ...
最近手机baidu，搜索关键字编码好像加密了比如这个：http ...
千万级别的es测试了没呢？
( ^_^ )不错嘛
不错不错！学习了java中使用redis总是需要处理redis连接的获取，释放等操作，每次使用都会使代码变的特别丑陋，模仿spring中aop的实现，用动态代理写一个 连接自动获取和释放的工具
JedisManageSupport 抽象类 类似于 aop的切入点，所有继承了该类（一般都是service层）的类，可以使用提供的获取redis的方法获取redis，并且不需要释放
JedisBeanPostProcessor 继承BeanPostProcessor
，会在bean初始化时执行自己定义的逻辑：
如果A类继承了 JedisManageSupport ，就会获取redis连接并且放到JedisManageSupport 的成员变量里，A类的实例（其实是cglib动态代理生成的
A类的子类的实例)就可以使用该redis连接 进行相关操作了
代理类的实例见源码
public class JedisBeanPostProcessor implements BeanPostProcessor {
@Autowired
ShardedJedisPool shardedJedisP
static final Logger logger = Logger.getLogger(JedisBeanPostProcessor.class);
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof JedisManageSupport) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(bean.getClass());
enhancer.setCallback(new JedisInterceptor(shardedJedisPool, bean));
Object targetBean = enhancer.create();
return targetB
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
class JedisInterceptor implements MethodInterceptor {
static final Logger logger = Logger.getLogger(JedisInterceptor.class);
ShardedJedisP
public JedisInterceptor(ShardedJedisPool pool, Object src) {
this.pool =
this.src =
public Object intercept(Object target, Method method, Object[] arguments, MethodProxy methodProxy) throws Throwable {
Object result =
if (target instanceof JedisManageSupport) {
if (this.isDeclaredMethod(target, method)) {
ShardedJedis jedis =
JedisManageSupport support = (JedisManageSupport)
jedis = pool.getResource();
support.setShardedJedis(jedis);
// logger.debug(&调用之前注入jedis对象,method:& + method);
* 下面代码可以使用 method.invoke(src,arguments)。 不能使用
* methodProxy.invokeSuper(target,arguments);
* 因为A类中用Autowired注入的属性，生成代理的子类B后,因为子类B是新建的类。从父类继承的属性没有被初始化，
* 使用methodProxy.invokeSuper（）执行是，会报空指针异常.
result = methodProxy.invoke(src, arguments);
support.setShardedJedis(null);
catch (Exception e) {
pool.returnBrokenResource(jedis);
e.printStackTrace();
if (jedis != null) {
pool.returnResource(jedis);
// logger.debug(&调用之后归还jedis对象,method:& + method);
result = methodProxy.invoke(src, arguments);
throw new Exception(&使用该代理必须继承JedisManageSupport&);
* 是否是target类本身定义的非私有的方法，还是继承的父类
* @return true是target自己类的并且不是私有的的，
private boolean isDeclaredMethod(Object target, Method arg1) {
Method temp =
temp = target.getClass().getDeclaredMethod(arg1.getName(), arg1.getParameterTypes());
catch (SecurityException e) {
e.printStackTrace();
catch (NoSuchMethodException e) {
e.printStackTrace();
* 不为null，并且是非私有的，返回true
if (temp != null) {
public abstract class JedisManageSupport {
ThreadLocal&ShardedJedis& jedisHolder = new ThreadLocal&ShardedJedis&();
public final ShardedJedis getShardedJedis() {
return jedisHolder.get();
public final void setShardedJedis(ShardedJedis jedis) {
jedisHolder.set(jedis);
* 如果某个键不同单位之间也不会重复，可以使用这个方法生成redis的键
public final byte[] assemKey(String baseKey) {
Assert.isTrue(StringUtils.isNotBlank(baseKey), &参数不能为空&);
return baseKey.getBytes();
* 根据tableName+prefix 构造唯一key与assemKey(String baseKey, String tableName)
* 规则一致
public final byte[] assemKeyByPrefix(String tableName, String baseKey) {
Assert.isTrue(StringUtils.isNotBlank(baseKey), &参数不能为空&);
Assert.isTrue(StringUtils.isNotBlank(tableName), &参数不能为空&);
UnitInfo unit = WebService.getUnitInfo();
Assert.isTrue(unit != null, &单位信息获取不到&);
return (tableName + &-& + unit.getPrefix() + &-& + baseKey).getBytes();
* 不同前缀的表中可能有相同的键，同一个表中也可能是有重复的baseKey时，用这个生成redis的key 比如 用户信息表的
* username字段，不同的用户信息表允许重复的username，mooc_t_userinfo
* 也允许有相同的账号，所以生成redis的key时，需要用到单位的mooc_school 放入redis中
public final byte[] assemKeyByFid(String tableName, String baseKey) {
UnitInfo unit = WebService.getUnitInfo();
Assert.isTrue(unit != null, &单位信息获取不到&);
return (tableName + &-& + unit.getMoocSchool() + &-& + baseKey).getBytes();
相关 [java spring 框架] 推荐：
- Java - 编程语言 - ITeye博客
java中使用redis总是需要处理redis连接的获取，释放等操作，每次使用都会使代码变的特别丑陋，模仿spring中aop的实现，用动态代理写一个 连接自动获取和释放的工具. JedisManageSupport 抽象类 类似于 aop的切入点，所有继承了该类（一般都是service层）的类，可以使用提供的获取redis的方法获取redis，并且不需要释放.
- ImportNew
在Spring 4.1中，利用Java 8的
java.util.Optional，通过
@RequestParam、
@RequestHeader和
@MatrixVariable三个注解，支持了仅包含非空（non-null）的容器对象. 有了Java 8的
java.util.Optional，你可以保证你的参数永远不会为
- skaka的博客
之前介绍过
微服务的概念与Finagle框架, 这个系列介绍Spring Cloud.. Spring Cloud还是一个相对较新的框架, 今年(2016)才推出1.0的release版本. 虽然Spring Cloud时间最短, 但是相比我之前用过的Dubbo和Finagle, Spring Cloud提供的功能最齐全..
- CSDN博客推荐文章
1.在java开发领域，Spring相对于EJB来说是一种轻量级的，非侵入性的Java开发框架，曾经有两本很畅销的书《Expert one-on-one J2EE Design and Development》和《Expert one-on-one J2EEdevelopment without EJB》是java高手进阶必看的宝典，Spring就是从这两本书的理论发展起来的.
- 开源软件 - ITeye博客
HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，. 【RPC框架Hessian四】Hessian与Spring集成.
- 经验沉淀 知识结晶
Bison 是一个JAVA 程间的通信框架，基于apache mina 实现，对mina进行了byteBuffer 缓冲区重用以及半包出处时减少拷贝. 客户端(bison-client) 功能点. 2 支持高用性：高可用的一个基本原则，可以接受快速的失败，但不能接受长时间的等待. Githup地址:/gavenpeng/Bison.
- CSDN博客推荐文章
Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架. 二、如何在程序中获取Spring配置的bean呢. 方法一：在初始化时保存ApplicationContext对象. 说明：这种方式适用于采用Spring框架的独立应用程序，需要程序通过配置文件手工初始化Spring的情况.
- CSDN博客推荐文章
利用Spring随时随地获得Request和Session. 在web.xml中添加
. 1、方法一：通过代码实现. 2、方法二：通过注解实现：. 三、关于RequestContextListener的背景知识：. 基于LocalThread将HTTP request对象绑定到为该请求提供服务的线程上.
- Java - 编程语言 - ITeye博客
//线程池所使用的缓冲队列 . //线程池维护线程的最少数量 . //线程池维护线程的最大数量 . //线程池维护线程所允许的空闲时间 . &!-- 配置线程池 --& .
&!-- 线程池维护线程的最少数量 --& .
&!-- 线程池维护线程所允许的空闲时间 --& .
- 编程语言 - ITeye博客
/developerworks/cn/webservices/ws-springjava/. 使用 Java 配置进行 Spring bean 管理. 学习使用 Java 配置管理 Spring bean. Spring bean 是使用传统的 XML 方法配置的.
坚持分享优质有趣的原创文章，并保留作者信息和版权声明，任何问题请联系：@。}