Spring 整合 Redis

2022-04-23 01:09:44

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. }
上一篇：通过公网连接云数据库Memcache--ECS Windows篇


下一篇：Katu Puzzle