Spring 整合 Redis(转)

转自http://blog.csdn.net/java2000_wl/article/details/8543203

pom构建：

1. <modelVersion>4.0.0</modelVersion>
2. <groupId>com.x.redis</groupId>
3. <artifactId>springredis</artifactId>
4. <version>0.0.1-SNAPSHOT</version>
5. <dependencies>
6. <dependency>
7. <groupId>org.springframework.data</groupId>
8. <artifactId>spring-data-redis</artifactId>
9. <version>1.0.2.RELEASE</version>
10. </dependency>
11. <dependency>
12. <groupId>org.springframework</groupId>
13. <artifactId>spring-test</artifactId>
14. <version>3.1.2.RELEASE</version>
15. <scope>test</scope>
16. </dependency>
17. <dependency>
18. <groupId>redis.clients</groupId>
19. <artifactId>jedis</artifactId>
20. <version>2.1.0</version>
21. </dependency>
22. <dependency>
23. <groupId>junit</groupId>
24. <artifactId>junit</artifactId>
25. <version>4.8.2</version>
26. <scope>test</scope>
27. </dependency>
28. </dependencies>

spring配置文件(applicationContext.xml)：

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" xmlns:p="http://www.springframework.org/schema/p"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
6. xmlns:aop="http://www.springframework.org/schema/aop"
7. xsi:schemaLocation="
8. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
10. <context:property-placeholder location="classpath:redis.properties" />
11. <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
12. <property name="maxIdle" value="${redis.maxIdle}" />
13. <property name="maxActive" value="${redis.maxActive}" />
14. <property name="maxWait" value="${redis.maxWait}" />
15. <property name="testOnBorrow" value="${redis.testOnBorrow}" />
16. </bean>
17. <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
18. p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/>
19. <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
20. <property name="connectionFactory"   ref="connectionFactory" />
21. </bean>
22. <bean id="userDao" class="com.x.dao.impl.UserDao" />
23. </beans>

redis.properties

1. # Redis settings
2. redis.host=localhost
3. redis.port=6379
4. redis.pass=java2000_wl
5. redis.maxIdle=300
6. redis.maxActive=600
7. redis.maxWait=1000
8. redis.testOnBorrow=true

java代码：

1. package com.x.entity;
2. import java.io.Serializable;
3. /**
4. * @author http://blog.csdn.net/java2000_wl
5. * @version <b>1.0</b>
6. */
7. public class User implements Serializable {
8. private static final long serialVersionUID = -6011241820070393952L;
9. private String id;
10. private String name;
11. private String password;
12. /**
13. * <br>------------------------------<br>
14. */
15. public User() {
16. }
17. /**
18. * <br>------------------------------<br>
19. */
20. public User(String id, String name, String password) {
21. super();
22. this.id = id;
23. this.name = name;
24. this.password = password;
25. }
26. /**
27. * 获得id
28. * @return the id
29. */
30. public String getId() {
31. return id;
32. }
33. /**
34. * 设置id
35. * @param id the id to set
36. */
37. public void setId(String id) {
38. this.id = id;
39. }
40. /**
41. * 获得name
42. * @return the name
43. */
44. public String getName() {
45. return name;
46. }
47. /**
48. * 设置name
49. * @param name the name to set
50. */
51. public void setName(String name) {
52. this.name = name;
53. }
54. /**
55. * 获得password
56. * @return the password
57. */
58. public String getPassword() {
59. return password;
60. }
61. /**
62. * 设置password
63. * @param password the password to set
64. */
65. public void setPassword(String password) {
66. this.password = password;
67. }
68. }

1. package com.x.dao;
2. import org.springframework.beans.factory.annotation.Autowired;
3. import org.springframework.data.redis.core.RedisTemplate;
4. import org.springframework.data.redis.serializer.RedisSerializer;
5. /**
6. * AbstractBaseRedisDao
7. * @author http://blog.csdn.net/java2000_wl
8. * @version <b>1.0</b>
9. */
10. public abstract class AbstractBaseRedisDao<K, V> {
11. @Autowired
12. protected RedisTemplate<K, V> redisTemplate;
13. /**
14. * 设置redisTemplate
15. * @param redisTemplate the redisTemplate to set
16. */
17. public void setRedisTemplate(RedisTemplate<K, V> redisTemplate) {
18. this.redisTemplate = redisTemplate;
19. }
20. /**
21. * 获取 RedisSerializer
22. * <br>------------------------------<br>
23. */
24. protected RedisSerializer<String> getRedisSerializer() {
25. return redisTemplate.getStringSerializer();
26. }
27. }

1. package com.x.dao;
2. import java.util.List;
3. import com.x.entity.User;
4. /**
5. * @author http://blog.csdn.net/java2000_wl
6. * @version <b>1.0</b>
7. */
8. public interface IUserDao {
9. /**
10. * 新增
11. * <br>------------------------------<br>
12. * @param user
13. * @return
14. */
15. boolean add(User user);
16. /**
17. * 批量新增 使用pipeline方式
18. * <br>------------------------------<br>
19. * @param list
20. * @return
21. */
22. boolean add(List<User> list);
23. /**
24. * 删除
25. * <br>------------------------------<br>
26. * @param key
27. */
28. void delete(String key);
29. /**
30. * 删除多个
31. * <br>------------------------------<br>
32. * @param keys
33. */
34. void delete(List<String> keys);
35. /**
36. * 修改
37. * <br>------------------------------<br>
38. * @param user
39. * @return
40. */
41. boolean update(User user);
42. /**
43. * 通过key获取
44. * <br>------------------------------<br>
45. * @param keyId
46. * @return
47. */
48. User get(String keyId);
49. }

1. package com.x.dao.impl;
2. import java.util.ArrayList;
3. import java.util.List;
4. import org.springframework.dao.DataAccessException;
5. import org.springframework.data.redis.connection.RedisConnection;
6. import org.springframework.data.redis.core.RedisCallback;
7. import org.springframework.data.redis.serializer.RedisSerializer;
8. import org.springframework.util.Assert;
9. import com.x.dao.AbstractBaseRedisDao;
10. import com.x.dao.IUserDao;
11. import com.x.entity.User;
12. /**
13. * Dao
14. * @author http://blog.csdn.net/java2000_wl
15. * @version <b>1.0</b>
16. */
17. public class UserDao extends AbstractBaseRedisDao<String, User> implements IUserDao {
18. /**
19. * 新增
20. *<br>------------------------------<br>
21. * @param user
22. * @return
23. */
24. public boolean add(final User user) {
25. boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
26. public Boolean doInRedis(RedisConnection connection)
27. throws DataAccessException {
28. RedisSerializer<String> serializer = getRedisSerializer();
29. byte[] key  = serializer.serialize(user.getId());
30. byte[] name = serializer.serialize(user.getName());
31. return connection.setNX(key, name);
32. }
33. });
34. return result;
35. }
36. /**
37. * 批量新增 使用pipeline方式
38. *<br>------------------------------<br>
39. *@param list
40. *@return
41. */
42. public boolean add(final List<User> list) {
43. Assert.notEmpty(list);
44. boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
45. public Boolean doInRedis(RedisConnection connection)
46. throws DataAccessException {
47. RedisSerializer<String> serializer = getRedisSerializer();
48. for (User user : list) {
49. byte[] key  = serializer.serialize(user.getId());
50. byte[] name = serializer.serialize(user.getName());
51. connection.setNX(key, name);
52. }
53. return true;
54. }
55. }, false, true);
56. return result;
57. }
58. /**
59. * 删除
60. * <br>------------------------------<br>
61. * @param key
62. */
63. public void delete(String key) {
64. List<String> list = new ArrayList<String>();
65. list.add(key);
66. delete(list);
67. }
68. /**
69. * 删除多个
70. * <br>------------------------------<br>
71. * @param keys
72. */
73. public void delete(List<String> keys) {
74. redisTemplate.delete(keys);
75. }
76. /**
77. * 修改
78. * <br>------------------------------<br>
79. * @param user
80. * @return
81. */
82. public boolean update(final User user) {
83. String key = user.getId();
84. if (get(key) == null) {
85. throw new NullPointerException("数据行不存在, key = " + key);
86. }
87. boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
88. public Boolean doInRedis(RedisConnection connection)
89. throws DataAccessException {
90. RedisSerializer<String> serializer = getRedisSerializer();
91. byte[] key  = serializer.serialize(user.getId());
92. byte[] name = serializer.serialize(user.getName());
93. connection.set(key, name);
94. return true;
95. }
96. });
97. return result;
98. }
99. /**
100. * 通过key获取
101. * <br>------------------------------<br>
102. * @param keyId
103. * @return
104. */
105. public User get(final String keyId) {
106. User result = redisTemplate.execute(new RedisCallback<User>() {
107. public User doInRedis(RedisConnection connection)
108. throws DataAccessException {
109. RedisSerializer<String> serializer = getRedisSerializer();
110. byte[] key = serializer.serialize(keyId);
111. byte[] value = connection.get(key);
112. if (value == null) {
113. return null;
114. }
115. String name = serializer.deserialize(value);
116. return new User(keyId, name, null);
117. }
118. });
119. return result;
120. }
121. }

1. import java.util.ArrayList;
2. import java.util.List;
3. import junit.framework.Assert;
4. import org.junit.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.test.context.ContextConfiguration;
7. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
8. import com.x.dao.IUserDao;
9. import com.x.entity.User;
10. /**
11. * 测试
12. * @author http://blog.csdn.net/java2000_wl
13. * @version <b>1.0</b>
14. */
15. @ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
16. public class RedisTest extends AbstractJUnit4SpringContextTests {
17. @Autowired
18. private IUserDao userDao;
19. /**
20. * 新增
21. * <br>------------------------------<br>
22. */
23. @Test
24. public void testAddUser() {
25. User user = new User();
26. user.setId("user1");
27. user.setName("java2000_wl");
28. boolean result = userDao.add(user);
29. Assert.assertTrue(result);
30. }
31. /**
32. * 批量新增 普通方式
33. * <br>------------------------------<br>
34. */
35. @Test
36. public void testAddUsers1() {
37. List<User> list = new ArrayList<User>();
38. for (int i = 10; i < 50000; i++) {
39. User user = new User();
40. user.setId("user" + i);
41. user.setName("java2000_wl" + i);
42. list.add(user);
43. }
44. long begin = System.currentTimeMillis();
45. for (User user : list) {
46. userDao.add(user);
47. }
48. System.out.println(System.currentTimeMillis() -  begin);
49. }
50. /**
51. * 批量新增 pipeline方式
52. * <br>------------------------------<br>
53. */
54. @Test
55. public void testAddUsers2() {
56. List<User> list = new ArrayList<User>();
57. for (int i = 10; i < 1500000; i++) {
58. User user = new User();
59. user.setId("user" + i);
60. user.setName("java2000_wl" + i);
61. list.add(user);
62. }
63. long begin = System.currentTimeMillis();
64. boolean result = userDao.add(list);
65. System.out.println(System.currentTimeMillis() - begin);
66. Assert.assertTrue(result);
67. }
68. /**
69. * 修改
70. * <br>------------------------------<br>
71. */
72. @Test
73. public void testUpdate() {
74. User user = new User();
75. user.setId("user1");
76. user.setName("new_password");
77. boolean result = userDao.update(user);
78. Assert.assertTrue(result);
79. }
80. /**
81. * 通过key删除单个
82. * <br>------------------------------<br>
83. */
84. @Test
85. public void testDelete() {
86. String key = "user1";
87. userDao.delete(key);
88. }
89. /**
90. * 批量删除
91. * <br>------------------------------<br>
92. */
93. @Test
94. public void testDeletes() {
95. List<String> list = new ArrayList<String>();
96. for (int i = 0; i < 10; i++) {
97. list.add("user" + i);
98. }
99. userDao.delete(list);
100. }
101. /**
102. * 获取
103. * <br>------------------------------<br>
104. */
105. @Test
106. public void testGetUser() {
107. String id = "user1";
108. User user = userDao.get(id);
109. Assert.assertNotNull(user);
110. Assert.assertEquals(user.getName(), "java2000_wl");
111. }
112. /**
113. * 设置userDao
114. * @param userDao the userDao to set
115. */
116. public void setUserDao(IUserDao userDao) {
117. this.userDao = userDao;
118. }
119. }