Architect_csdn
Architect_csdn

Redis】spring-data-redis与JedisPool的区别、使用ShardedJedisPool与spring集成的实现及一致性哈希分析

一、Redis与spring的整合一般分为spring-data-redis整合和JedisPool整合，先看看两者的区别

1)、引用的依赖不同：

spring-data-redis使用的依赖如下：

  1. <dependency>
  2. <groupId>org.springframework.data groupId>
  3. <artifactId>spring-data-redis artifactId>
  4. <version>1.0.2.RELEASE version>
  5. dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

JedisPool使用的依赖如下：

  1. <dependency>
  2. <groupId>redis.clients groupId>
  3. <artifactId>jedis artifactId>
  4. <version>2.7.2 version>
  5. <type>jar type>
  6. <scope>compile scope>
  7. dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2)、管理Jedis实例方式、操作redis服务的不同：

spring-data-redis：

通过org.springframework.data.redis.connection.jedis.JedisConnectionFactory来管理，即通过工厂类管理，然后通过配置的模版bean，操作redis服务，代码段中充斥大量与业务无关的模版片段代码，代码冗余，不易维护，比如像下面的代码：

  1. @Autowired
  2. protected RedisTemplate redisTemplate;
  4. public void saveUser ( final User user) {
  5. redisTemplate.execute( new RedisCallback() {
  7. @Override
  8. public Object doInRedis (RedisConnection connection) throws DataAccessException {
  9. connection.set(redisTemplate.getStringSerializer().serialize( "user.uid." + user.getId()),
  10. redisTemplate.getStringSerializer().serialize(user.getName()));
  11. return null;
  12. }
  13. });
  14. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    1. @Override
    2. public User getUser ( final long id) {
    3. return redisTemplate.execute( new RedisCallback() {
    4. @Override
    5. public User doInRedis (RedisConnection connection) throws DataAccessException {
    6. byte[] key = redisTemplate.getStringSerializer().serialize( "user.uid." + id);
    7. if (connection.exists(key)) {
    8. byte[] value = connection.get(key);
    9. String name = redisTemplate.getStringSerializer().deserialize(value);
    10. User user = new User();
    11. user.setName(name);
    12. user.setId(id);
    13. return user;
    14. }
    15. return null;
    16. }
    17. });
    18. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    JedisPool方式：

    通过redis.clients.jedis.JedisPool来管理，即通过池来管理，通过池对象获取jedis实例，然后通过jedis实例直接操作redis服务，剔除了与业务无关的冗余代码，如下面的代码片段：

    1. @Autowired
    2. private JedisPool jedisPool;
    4. @Override
    5. public String save (String key,String val) {
    6. Jedis jedis = jedisPool.getResource();
    7. return jedis.set(key, val);
    9. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    从工厂类到池的方式变化，就相当于mybatis连接MySQL方变化是一样的，代码变得更简洁，维护也更容易了。

    spring-data-redis的集成方式可以查看 java之redis篇(spring-data-redis整合) 这边博文。

    但是本文与spring集成并未直接采用JedisPool，而是采用了 ShardedJedisPool ，为什么呢？

    因为ShardedJedisPool可以通过一致性哈希实现分布式存储

    shared一致性哈希采用以下方案：

    1、Redis服务器节点划分：将每台服务器节点采用hash算法划分为160个虚拟节点(可以配置划分权重)

    2、将划分虚拟节点采用TreeMap存储

    3、对每个Redis服务器的物理连接采用LinkedHashMap存储

    4、对Key or KeyTag 采用同样的hash算法，然后从TreeMap获取大于等于键hash值得节点，取最邻近节点存储；当key的hash值大于虚拟节点hash值得最大值时，存入第一个虚拟节点sharded采用的hash算法：MD5 和 MurmurHash两种；默认采用64位的MurmurHash算法；

    更为深入解释可以查看 Jedis分片连接池(分布式) 、 jedis源码中ShardedJedis实现sharding文章。

    使用非分片的JedisPool和使用分片的ShardedJedisPool示例可以查看 Java内存数据库实践之深入浅出Redis - Jedis分布式（Sharding/Sharded) 这篇文章。

    二、使用ShardedJedisPool与spring集成

    集成参照：https://my.oschina.net/u/866380/blog/521658

    相关依赖jar包

    1. <properties>
    2. <project.build.sourceEncoding>UTF-8 project.build.sourceEncoding>
    3. <spring.version>4.2.6.RELEASE spring.version>
    4. properties>
    6. <dependencies>
    9. <dependency>
    10. <groupId>org.springframework groupId>
    11. <artifactId>spring-context artifactId>
    12. <version>${spring.version} version>
    13. dependency>
    14. <dependency>
    15. <groupId>org.springframework groupId>
    16. <artifactId>spring-context-support artifactId>
    17. <version>${spring.version} version>
    18. dependency>
    19. <dependency>
    20. <groupId>org.springframework groupId>
    21. <artifactId>spring-test artifactId>
    22. <version>${spring.version} version>
    23. dependency>
    26. <dependency>
    27. <groupId>redis.clients groupId>
    28. <artifactId>jedis artifactId>
    29. <version>2.7.2 version>
    30. <type>jar type>
    31. dependency>
    33. <dependency>
    34. <groupId>junit groupId>
    35. <artifactId>junit artifactId>
    36. <version>4.11 version>
    37. <scope>test scope>
    38. dependency>
    39. dependencies>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    Spring 配置文件spring-redis.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"
    4. xmlns:context = "http://www.springframework.org/schema/context"
    5. xsi:schemaLocation = "
    6. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd" >
    10. <context:annotation-config> context:annotation-config>
    13. <context:property-placeholder location="classpath:spring-redis.properties" ignore-unresolvable="true" />
    16. <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    17. <property name="maxTotal" value="${redis.pool.maxActive}" />
    18. <property name="maxIdle" value="${redis.pool.maxIdle}" />
    19. <property name="minIdle" value="${redis.pool.minIdle}" />
    20. <property name="maxWaitMillis" value="${redis.pool.maxWait}" />
    21. <property name="lifo" value="${redis.pool.lifo}" />
    22. <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
    23. bean>
    26. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
    27. <constructor-arg index="0" ref="jedisPoolConfig" />
    28. <constructor-arg index="1">
    29. <list>
    30. <bean class="redis.clients.jedis.JedisShardInfo">
    31. <constructor-arg index="0" value="${redis.uri.0}" />
    32. bean>
    33. list>
    34. constructor-arg>
    35. bean>
    37. beans>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    几个注意的点：

    （1）如果你有多个数据源需要通过管理，且不愿意放在一个配置文件里，那么一定要加上ignore-unresolvable=“true”

    （2）注意新版的（具体从哪个版本开始不清楚，有兴趣可以查一下）JedisPoolConfig的property name，不是maxActive而是maxTotal，而且没有maxWait属性，建议看一下Jedis源码。

    （3）ShardedJedisPool有多种构造函数，选择你需要的（具体看源码），示例中只初始化了一个分片，并使用了通过指定host的构造器（具体格式见下文），如果有集群，在下增加新的即可。

    （4）当然，你的spring核心配置文件中得有扫描组件。

    （5）客户端分片使用ShardedJedisPool，设置DB和超时时间

    redis连接池配置文件spring-redis.properties

    1. #最大分配的对象数
    2. redis .pool .maxActive= 10
    3. #最大能够保持idel状态的对象数
    4. redis .pool .maxIdle= 10
    5. #最小空闲的对象数。2.5.1以上版本有效
    6. redis .pool .minIdle= 8
    7. #当池内没有返回对象时，最大等待时间
    8. redis .pool .maxWait= 1000
    9. #是否启用Lifo。如果不设置，默认为true。2.5.1以上版本有效
    10. redis .pool .lifo= false
    11. #当调用borrow Object方法时，是否进行有效性检查
    12. redis .pool .testOnBorrow= false
    14. ## REDIS URI
    15. ## 使用DB0库
    16. ##redis://用户名:密码@host:port/库，其中用户名随意填写的
    17. redis .uri .0=redis: //testRedis:foobared @119 .254 .166 .136 : 6379 / 0
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    注意：redis uir的格式为 redis://用户名:密码@host:port/库，其中用户名随意填写的,如果没有用户名和密码，格式为redis://:@host:port/库，使用这种方式，配置内容少，还能自定义db index，非常适合开发、测试和线上环境的切换

    代码实现

    （1）推荐大家使用统一的类来管理Jedis实例的生成和回收，参考代码如下：JedisDataSourceImpl

    1. @Repository( "jedisDS")
    2. public class JedisDataSourceImpl implements JedisDataSource {
    3. private static final Logger LOG = LoggerFactory.getLogger(JedisDataSourceImpl.class);
    5. @Autowired
    6. private ShardedJedisPool shardedJedisPool;
    8. @Override
    9. public ShardedJedis getRedisClient () {
    10. ShardedJedis shardJedis = null;
    11. try {
    12. shardJedis = shardedJedisPool.getResource();
    13. return shardJedis;
    14. } catch (Exception e) {
    15. LOG.error( "[JedisDS] getRedisClent error:" + e.getMessage());
    16. if ( null != shardJedis)
    17. shardJedis.close();
    18. }
    19. return null;
    20. }
    22. @Override
    23. public void returnResource (ShardedJedis shardedJedis) {
    24. shardedJedis.close();
    25. }
    27. @Override
    28. public void returnResource (ShardedJedis shardedJedis, boolean broken) {
    29. shardedJedis.close();
    30. }
    32. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    这里要注意的是Jedis实例的回收，从jedis2.6开始，原returnResource方式已经提示在后续版本中不再支持，所以不建议大家再用ShardedJedisPool里的returnResource和retureBrokenResource方法，虽然在2.7中还支持（毕竟是因为这两个方法存在漏洞）。

    （2）编写具体的Jedis操作类（片断）：RedisClientTemplate

    1. @Repository( "redisClientTemplate")
    2. public class RedisClientTemplate {
    3. private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);
    5. @Autowired
    6. private JedisDataSource redisDataSource;
    8. public void disconnect () {
    9. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    10. shardedJedis.disconnect();
    11. }
    13. /**
    14. * 设置单个值
    15. *
    16. * @param key
    17. * @param value
    18. * @return
    19. */
    20. public String set (String key, String value) {
    21. String result = null;
    23. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    24. if (shardedJedis == null) {
    25. return result;
    26. }
    27. boolean broken = false;
    28. try {
    29. result = shardedJedis.set(key, value);
    30. } catch (Exception e) {
    31. log.error(e.getMessage(), e);
    32. broken = true;
    33. } finally {
    34. redisDataSource.returnResource(shardedJedis, broken);
    35. }
    36. return result;
    37. }
    39. /**
    40. * 获取单个值
    41. *
    42. * @param key
    43. * @return
    44. */
    45. public String get (String key) {
    46. String result = null;
    47. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    48. if (shardedJedis == null) {
    49. return result;
    50. }
    52. boolean broken = false;
    53. try {
    54. result = shardedJedis.get(key);
    56. } catch (Exception e) {
    57. log.error(e.getMessage(), e);
    58. broken = true;
    59. } finally {
    60. redisDataSource.returnResource(shardedJedis, broken);
    61. }
    62. return result;
    63. }
    65. public Boolean exists (String key) {
    66. Boolean result = false;
    67. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    68. if (shardedJedis == null) {
    69. return result;
    70. }
    71. boolean broken = false;
    72. try {
    73. result = shardedJedis.exists(key);
    74. } catch (Exception e) {
    75. log.error(e.getMessage(), e);
    76. broken = true;
    77. } finally {
    78. redisDataSource.returnResource(shardedJedis, broken);
    79. }
    80. return result;
    81. }
    83. public String type (String key) {
    84. String result = null;
    85. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    86. if (shardedJedis == null) {
    87. return result;
    88. }
    89. boolean broken = false;
    90. try {
    91. result = shardedJedis.type(key);
    93. } catch (Exception e) {
    94. log.error(e.getMessage(), e);
    95. broken = true;
    96. } finally {
    97. redisDataSource.returnResource(shardedJedis, broken);
    98. }
    99. return result;
    100. }
    102. /**
    103. * 在某段时间后失效
    104. *
    105. * @param key
    106. * @param seconds
    107. * @return
    108. */
    109. public Long expire (String key, int seconds) {
    110. Long result = null;
    111. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    112. if (shardedJedis == null) {
    113. return result;
    114. }
    115. boolean broken = false;
    116. try {
    117. result = shardedJedis.expire(key, seconds);
    119. } catch (Exception e) {
    120. log.error(e.getMessage(), e);
    121. broken = true;
    122. } finally {
    123. redisDataSource.returnResource(shardedJedis, broken);
    124. }
    125. return result;
    126. }
    128. /**
    129. * 在某个时间点失效
    130. *
    131. * @param key
    132. * @param unixTime
    133. * @return
    134. */
    135. public Long expireAt (String key, long unixTime) {
    136. Long result = null;
    137. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    138. if (shardedJedis == null) {
    139. return result;
    140. }
    141. boolean broken = false;
    142. try {
    143. result = shardedJedis.expireAt(key, unixTime);
    145. } catch (Exception e) {
    146. log.error(e.getMessage(), e);
    147. broken = true;
    148. } finally {
    149. redisDataSource.returnResource(shardedJedis, broken);
    150. }
    151. return result;
    152. }
    154. public Long ttl (String key) {
    155. Long result = null;
    156. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    157. if (shardedJedis == null) {
    158. return result;
    159. }
    160. boolean broken = false;
    161. try {
    162. result = shardedJedis.ttl(key);
    164. } catch (Exception e) {
    165. log.error(e.getMessage(), e);
    166. broken = true;
    167. } finally {
    168. redisDataSource.returnResource(shardedJedis, broken);
    169. }
    170. return result;
    171. }
    173. public boolean setbit (String key, long offset, boolean value) {
    175. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    176. boolean result = false;
    177. if (shardedJedis == null) {
    178. return result;
    179. }
    180. boolean broken = false;
    181. try {
    182. result = shardedJedis.setbit(key, offset, value);
    183. } catch (Exception e) {
    184. log.error(e.getMessage(), e);
    185. broken = true;
    186. } finally {
    187. redisDataSource.returnResource(shardedJedis, broken);
    188. }
    189. return result;
    190. }
    192. public boolean getbit (String key, long offset) {
    193. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    194. boolean result = false;
    195. if (shardedJedis == null) {
    196. return result;
    197. }
    198. boolean broken = false;
    200. try {
    201. result = shardedJedis.getbit(key, offset);
    202. } catch (Exception e) {
    203. log.error(e.getMessage(), e);
    204. broken = true;
    205. } finally {
    206. redisDataSource.returnResource(shardedJedis, broken);
    207. }
    208. return result;
    209. }
    211. public long setRange (String key, long offset, String value) {
    212. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    213. long result = 0;
    214. if (shardedJedis == null) {
    215. return result;
    216. }
    217. boolean broken = false;
    218. try {
    219. result = shardedJedis.setrange(key, offset, value);
    220. } catch (Exception e) {
    221. log.error(e.getMessage(), e);
    222. broken = true;
    223. } finally {
    224. redisDataSource.returnResource(shardedJedis, broken);
    225. }
    226. return result;
    227. }
    229. public String getRange (String key, long startOffset, long endOffset) {
    230. ShardedJedis shardedJedis = redisDataSource.getRedisClient();
    231. String result = null;
    232. if (shardedJedis == null) {
    233. return result;
    234. }
    235. boolean broken = false;
    236. try {
    237. result = shardedJedis.getrange(key, startOffset, endOffset);
    239. } catch (Exception e) {
    240. log.error(e.getMessage(), e);
    241. broken = true;
    242. } finally {
    243. redisDataSource.returnResource(shardedJedis, broken);
    244. }
    245. return result;
    246. }
    247. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247

    （3）好了，接下来在你的业务代码里加载RedisClientTemplate.class就可以了。

    2. @RunWith(SpringJUnit4ClassRunner.class)
    3. @ContextConfiguration( "classpath:spring-redis.xml")
    4. public class RedisTest{
    5. @Autowired
    6. private RedisClientTemplate redisClientTemplate ;
    8. @Test
    9. public void testSave (){
    10. String key = "10086";
    11. String val = "中国移动";
    12. String r = redisClientTemplate .save(key,val);
    13. System.out.println(r);
    14. }
    16. @Test
    17. public void testFind (){
    18. String key = "10086";
    19. String result = redisClientTemplate .find(key);
    20. System.out.println(result);
    21. }
    23. @Test public void testDel (){
    24. String key = "10086";
    25. long l = redisClientTemplate .delete(key);
    26. System.out.println(l);
    27. }
    28. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    补充：


    1、shardedjedispool分片实现集群与jediscluster实现集群区别以及jediscluster实现集群可以查看 分布式缓存技术redis学习系列（七）——spring整合jediscluster 

    2、shardedjedispool分片集群与jediscluster集群同样不具有高可用特性，但基于shardedjedispool的ShardedJedisSentinelPool可以实现集群高可用，redis服务一台master挂机，sentinel哨兵进行主从切换之后，客户端程序自动完成同步的主从切换。 
    具体的实现方式就是通过sentinel的sentinelGetMasterAddrByName(masterName);(实际执行sentinel的get-master-addr-by-name命令)获取哨兵监控的所有master节点；然后用一个MasterListener启用一个线程，利用redis的订阅与发布机制，订阅+switch-master频道，时时获取redis服务端主从切换的信息。 
    实现原理和源码分析可以查看 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案 相关源码地址位于 sharded-jedis-sentinel-pool 

    你可能感兴趣的:(Redis)

    • Redis 常用数据类型 27xixi java技术栈redis数据库缓存
      Redis常用数据类型的详细介绍及其典型应用场景：String（字符串）描述：最基本的数据类型，可存储文本、数字或二进制数据（最大512MB）。常用命令：SETkeyvalue：设置值GETkey：获取值INCRkey：将值自增1（原子性操作）EXPIREkeyseconds：设置过期时间应用场景：缓存简单键值对（如用户会话、配置项）。计数器（如文章阅读量、库存扣减）。分布式锁（结合SETNX命令
    • Redis 源码分析-内部数据结构 quicklist 笨手笨脚の #Redisredis数据结构数据库quicklist链表快速链表ziplist
      Redis源码分析-内部数据结构quicklistquicklist是Redis对外暴露的list数据结构的内部实现，经常被当作队列或栈使用，我们可以从常用的一些api上先思考一下它的结构最常用的就是lpush、lpop、rpush、rpop，同时它也支持lindex查询某元素在list中的索引，linsert在指定元素旁边插入新元素。从头、尾节点的push、pop来看，这就是双向链表最优秀的设计
    • 蓝易云 - nginx+lua+redis等架构演进 蓝易云 nginxluarediskubernetes容器云原生驱动开发
      Nginx+Lua+Redis架构演进如下：基本架构：最初，使用Nginx作为反向代理和负载均衡器，将客户端请求分发到后端应用服务器。Nginx的高性能和低资源消耗使其成为处理大量请求的理想选择。引入Lua模块：随着业务复杂度增加，引入Nginx的Lua模块，可以在Nginx配置中嵌入Lua脚本，实现自定义的请求处理逻辑。这种方式可以将部分业务逻辑移至Nginx层，减轻后端应用服务器的压力。集成R
    • 【Springboot知识】开发属于自己的中间件健康监测HealthIndicate 问道飞鱼 微服务相关技术springboot中间件后端HealthIndicate
      文章目录**一、技术栈****二、项目结构****三、依赖配置(pom.xml)****四、配置文件(application.yml)****五、自定义健康检查实现****1.Redis健康检查****2.Elasticsearch健康检查****3.Kafka健康检查****4.MySQL健康检查****六、自定义健康检查接口(可选)****七、测试与验证****八、高级功能扩展****九、部署
    • Redis 源码分析-内部数据结构 robj 笨手笨脚の #Redisredis数据结构数据库redisObject44字节embStrraw
      Redis源码分析-内部数据结构robjRedis中，一个database内的这个映射关系是用一个dict来维护的（ht[0]）。dict的key固定用一种数据结构来表达就够了，即动态字符串sds。而value则比较复杂，为了在同一个dict内能够存储不同类型的value，这就需要一个通用的数据结构，这个通用的数据结构就是robj（全名redisObject）。#defineLRU_BITS24/
    • redis内部数据结构(5)-quicklist Tinner丶 链表数据结构算法javaredis
      Redis对外暴露的list数据类型，它底层实现所依赖的内部数据结构就是`quicklist`。我们在讨论中还会涉及到两个Redis配置(在redis.conf中的ADVANCEDCONFIG部分)：12list-max-ziplist-size-2list-compress-depth0注：本文讨论的quicklist实现基于Redis源码的3.2分支。quicklist概述Redis对外暴露的
    • Redis内部数据结构quicklist详解 码农单克 redisredis
      在本文中，我们介绍一个Redis内部数据结构——quicklist。Redis对外暴露的list数据类型，它底层实现所依赖的内部数据结构就是quicklist。我们在讨论中还会涉及到两个Redis配置（在redis.conf中的ADVANCEDCONFIG部分）：list-max-ziplist-size-2list-compress-depth0我们在讨论中会详细解释这两个配置的含义。注：本文讨
    • 基于k3s部署Nginx、MySQL、SpringBoot和Redis的详细教程
      1.安装k3s集群1.1单节点快速部署#使用root或sudo权限执行curl-sfLhttps://get.k3s.io|sh-#验证安装sudokubectlgetnodes#输出应为Ready状态sudosystemctlstatusk3s1.2配置kubectl权限（可选）mkdir-p~/.kubesudocp/etc/rancher/k3s/k3s.yaml~/.kube/config
    • python系列【仅供参考】：python tornado 集成redis消息订阅的异步任务之后tornado主程序无法启动，解决方案 坦笑&&life #pythonpythontornadoredis
      pythontornado集成redis消息订阅的异步任务之后tornado主程序无法启动，解决方案pythontornado集成redis消息订阅的异步任务之后tornado主程序无法启动，解决方案封装redis异步类pythontornado集成redis消息订阅的异步任务之后tornado主程序无法启动，解决方案封装redis异步类sys_redis_helper.pyimportredis
    • redis的zset命令总结 脱氨垃圾 Redisredis数据库database
      redis的zset命令总结文章目录redis的zset命令总结1.zadd2.zrem3.zcard4.zrange5.zrevrange6.zrangebyscore7.zrevrangebyscore8.zcount9.zrank10.zscorezset(sortedset：有序集合)Rediszset和set一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联
    • redis操作zset类型的基本命令 JavaWeb学起来 redisredis数据结构
      zset是有序存储的数据结构，它和set一样，不允许重复的值，下面我们总结一些常用的命令。zaddkey排序的数值值(这里为了zset可以有序的存储，需要设定数值)127.0.0.1:6379>zaddz15java3redis1mysql2nginx4oracle(integer)5zcardkey(返回key中的成员数)127.0.0.1:6379>zcardz1(integer)5zrang
    • Redis_Zset数据类型基本命令 Mudrock__ Redisjavaredis
      命令说明zaddkeyscorevalue[scorevalue...]向集合中添加元素，若集合不存在则创建集合，批量添加时scorevalue之间以空格分隔zremkeyvalue[value...]移除集合中的指定元素，批量移除时value之间以空格分隔zrangekeyindex1index2withscores查看集合中下标处于index1-index2的元素（withscores用于将s
    • Spring Cache的基本使用 奇怪的大象 面试学习路线阿里巴巴springjava后端
      文章目录一、概述二、SpringCache的使用2.1环境搭建2.2缓存的读模式@Cacheable2.3自定义缓存配置[email protected]@CacheEvict删除缓存2.6@Caching多个操作三、SpringCache的不足一、概述常见的缓存的框架有Redis、Memcached、Guava、Caffeine等等，各有各的优势。如果我们的程序想要使用缓存，就要与这些框架耦合。聪明
    • Podman 运行redis 报错 one one day podmanredis数据库
      Podman运行redis报错一、报错内容find:'.':Permissiondeniedchown:changingownershipof'.':Permissiondenied二、问题分析SELinux模式SELinux（Security-EnhancedLinux）是一种安全模块，旨在通过强制访问控制（MAC）来增强Linux系统的安全性。SELinux具有三种工作模式，每种模式提供不同的
    • redis基础常用命令 web15085096641 面试学习路线阿里巴巴redis数据库缓存
      linux下搜索redis-cli所在路径find/-nameredis*cd到redis-cli所在路径停止redisredis-cli-h127.0.0.1-p6379shutdown查看redis启动使用的配置文件127.0.0.1:6379>infoServer启动redis-server/指定配置文件路径/redis.conf配置守护进程daemonizeyes配置密码requirepa
    • Redisson 分布式锁全面解析：锁类型(可重入锁、公平锁、联锁、红锁、读写锁)和锁常见方法解读 千层冷面 Redis分布式
      Redisson分布式锁全面解析一、Redisson分布式锁原理Redisson分布式锁基于Redis实现，核心机制如下：Lua脚本保证原子性使用Lua脚本在Redis中执行锁的获取和释放操作，确保多个Redis命令的原子性。可重入锁设计同一线程可重复获取锁，通过计数器记录重入次数，避免死锁。看门狗（Watchdog）自动续期后台线程定期检查锁状态，若锁仍被持有且未完成业务逻辑，则自动延长锁的过期
    • 基础知识《Redis解析》 Hum8le redis数据库缓存安全web安全
      Redis详细解析与介绍Redis（RemoteDictionaryServer）是一个开源的高性能键值对（Key-Value）数据库，支持多种数据结构（如字符串、哈希、列表、集合等），广泛应用于缓存、消息队列、实时数据分析等场景。核心特点：内存存储：数据主要存储在内存中，读写性能极高（10万+/秒QPS）。持久化支持：支持RDB（快照）和AOF（追加日志）两种持久化方式。多数据结构：支持字符串、
    • 【Redis事务】redis中事务的使用 Rverdoser redis数据库缓存
      在Redis中，事务可以通过MULTI、EXEC、DISCARD和WATCH命令来使用。这些命令允许你将多个命令打包成一个原子操作，要么全部执行，要么全部不执行，从而确保数据的一致性和完整性。下面是这些命令的基本使用方法：1.使用MULTI开始一个事务使用MULTI命令开始一个事务块，之后的所有命令都会被放入事务队列中，直到执行EXEC命令。MULTISETkey1value1SETkey2val
    • Redis缓存和Mysql数据一致性问题 每天瞎忙的农民工 缓存redismysql
      在高并发环境下，保持Redis缓存和MySQL数据库的数据一致性是一个复杂但至关重要的任务。下面是对这一问题的详细讲解，并结合PHP代码示例来展示如何解决这些一致性问题。问题背景Redis缓存和MySQL数据库的主要挑战在于：缓存和数据库之间的延迟：在缓存更新与数据库更新之间，可能存在时间差，导致数据不一致。高并发下的缓存击穿：缓存被并发请求同时击穿，导致大量请求直接访问数据库。缓存雪崩：大量缓存
    • 银河麒麟V10ServerSP3中Redis7源码编译与安装详细教程 小猿搬码 RedisRedis7KylinV10银河麒麟国产操作系统
      银河麒麟V10ServerSP3中Redis7源码编译与安装详细教程文章目录银河麒麟V10ServerSP3中Redis7源码编译与安装详细教程1.下载2.安装过程1.解压2.编译源码3.测试编译结果（可选）4.安装Redis5.安装位置6.复制配置文件7.修改redis.conf文件8.启动Redis服务9.客户端测试10.设置开机自启动3.开启远程访问1.编辑redis.conf2.开启防火墙
    • 什么是 Redis yqcoder redis数据库缓存
      Redis（RemoteDictionaryServer）是一个开源的、基于内存的键值存储系统，常用作数据库、缓存和消息中间件。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等，并提供丰富的操作命令。主要特点高性能：数据存储在内存中，读写速度极快。持久化：支持RDB和AOF两种方式，确保数据在重启后不丢失。数据结构丰富：支持字符串、哈希、列表、集合、有序集合等多种类型。原子操作：所有操作
    • IntelliJ IDE 插件开发指南 人工智能_SYBH 课程推荐2025年前后端实战项目idejavaintellij-idea
      IntelliJIDE插件开发指南-洪进锋-掘金小册作者介绍洪进锋，字节跳动后端研发工程师，参与过高并发系统（百万QPS）设计与研发工作。在开源项目方面混过Sharding-JDBC的PR。个人开发的IntelliJIDE插件RedisManager，目前在官方插件库中下载量30K，评分4.37（满分5分）。小册介绍目前国内插件开发方面的资料比较少且零散，特别是涉及到一些IDE中的高级特性，例如语
    • 怎么使用jwt，token以及redis进行续期？ 曦月不可及? java
      怎么使用jwt，token以及redis进行续期？什么是jwt?什么是token?结合JWT、Token和Redis进行续期的一般步骤：生成JWT：用户登录成功后，服务器生成一个JWT，并返回给客户端。importio.jsonwebtoken.Jwts;importio.jsonwebtoken.SignatureAlgorithm;publicclassJwtUtil{privatestati
    • 使用Redis实现分布式锁的技术详解 智能编织者 redis分布式数据库
      使用Redis实现分布式锁的技术详解一、引言二、分布式锁的基本概念三、Redis实现分布式锁的原理1.SETNX命令2.SET命令的扩展参数3.Lua脚本保证原子性四、Redis实现分布式锁的步骤1.引入Redis依赖2.加锁实现3.释放锁实现4.设置锁过期时间五、代码演示1.引入依赖2.加锁与释放锁的工具类3.使用示例六、注意事项与优化1.死锁问题2.锁竞争与重试机制一、引言在分布式系统中，多个
    • 分布式系统中分布式ID生成方案的技术详解 好龙7575 分布式
      分布式系统中分布式ID生成方案的技术详解一、分布式系统唯一ID的特点二、分布式系统唯一ID的实现方案1.UUID2.数据库生成ID3.Redis生成ID4.Snowflake雪花算法5.美团Leaf三、总结在复杂的分布式系统中，数据被分散存储在不同的节点上，每个节点都有自己独立的数据库。为了保证数据的唯一性和一致性，我们需要为每个数据项生成一个全局唯一的主键ID。本文将详细解析几种常用的分布式ID
    • Spring Boot实战：MySQL与Redis数据一致性深度解析与代码实战 黑猫Teng springbootmysqlredis
      SpringBoot实战：MySQL与Redis数据一致性深度解析与代码实战一、数据一致性问题概述二、常见解决方案三、选择合适的解决方案四、总结在SpringBoot开发中，MySQL作为关系型数据库，提供了强大的数据存储和查询能力；而Redis作为内存数据库，以其高速读写性能成为缓存层的首选。然而，当这两者共同服务于一个系统时，如何确保它们之间的数据一致性，成为了一个不可忽视的问题。本文将深入探
    • 使用Redis实现分布式锁的技术详解 my1121716951 redis分布式数据库
      使用Redis实现分布式锁的技术详解一、引言二、分布式锁的基本概念三、Redis实现分布式锁的原理1.SETNX命令2.SET命令的扩展参数3.Lua脚本保证原子性四、Redis实现分布式锁的步骤1.引入Redis依赖2.加锁实现3.释放锁实现4.设置锁过期时间五、代码演示1.引入依赖2.加锁与释放锁的工具类3.使用示例六、注意事项与优化1.死锁问题2.锁竞争与重试机制一、引言在分布式系统中，多个
    • Java面试精选：Kafka+Zookeeper+redis+JVM+RabbitMQ，最全总结 我叫小迁W：bjmsb2019 Java架构面试数据库javaredismysql分布式
      大家开始准备金九银十了吗？不知是跳槽还是找工作的朋友，趁现在增进一下自己的技术何尝不是一件好事呢？一、RabbitMQ1.rabbitmq的使用场景有哪些？2.rabbitmq有哪些重要的角色？3.rabbitmq有哪些重要的组件？4.rabbitmq中vhost的作用是什么？5.rabbitmq的消息是怎么发送的？6.rabbitmq怎么保证消息的稳定性？7.rabbitmq怎么避免消息丢失？8
    • 使用Redis实现分布式锁的技术详解 QQ828929QQ redis分布式数据库
      使用Redis实现分布式锁的技术详解一、引言二、分布式锁的基本概念三、Redis实现分布式锁的原理1.SETNX命令2.SET命令的扩展参数3.Lua脚本保证原子性四、Redis实现分布式锁的步骤1.引入Redis依赖2.加锁实现3.释放锁实现4.设置锁过期时间五、代码演示1.引入依赖2.加锁与释放锁的工具类3.使用示例六、注意事项与优化1.死锁问题2.锁竞争与重试机制一、引言在分布式系统中，多个
    • Caddy2使用阿里云DNS申请https证书，利用阿里云DNS境内外不同解析给Gone文档做一个同域名的国内镜像站点 dapeng-大鹏 大鹏运维记录caddyhttpsdockerdocker-compose
      我从头到尾实现了一个Golang的依赖注入框架，并且集成了gin、xorm、redis、cron、消息中间件等功能；自己觉得还挺好用的，并且打算长期维护！github地址：https://github.com/gone-io/gone文档原地址：https://goner.fun/zh/guide/auto-gen-priest.html请帮忙在github上点个⭐️吧，这对我很重要；万分感谢！！
    • ASM系列六 利用TreeApi 添加和移除类成员 lijingyao8206 jvm动态代理ASM字节码技术TreeAPI
          同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。   package asm.core; /** * Created by yunshen.ljy on 2015/6/
    • Springmvc-权限设计 bee1314 springWebjsp
      万丈高楼平地起。 权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 目标： 1.实现权限的管理（CRUD） 2.实现部门管理 （CRUD) 3.实现人员的管理 （CRUD） 4.实现部门和权限
    • 算法竞赛入门经典（第二版）第2章习题 CrazyMizzz c算法
      2.4.1 输出技巧 #include <stdio.h> int main() { int i, n; scanf("%d", &n); for (i = 1; i <= n; i++) printf("%d\n", i); return 0; } 习题2-2 水仙花数(daffodil
    • struts2中jsp自动跳转到Action 麦田的设计者 jspwebxmlstruts2自动跳转
      1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士）   2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
    • php 操作webservice实例 IT独行者 PHPwebservice
      首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; OK 现在我们来体验webservice //server端 serve
    • Windows下使用Vagrant安装linux系统 _wy_ windowsvagrant
      准备工作： 下载安装 VirtualBox ：https://www.virtualbox.org/ 下载安装 Vagrant ：http://www.vagrantup.com/ 下载需要使用的 box ： 官方提供的范例：http://files.vagrantup.com/precise32.box 还可以在 http://www.vagrantbox.es/ 
    • 更改linux的文件拥有者及用户组(chown和chgrp) 无量 clinuxchgrpchown
      本文（转） http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/ http://ydlmlh.iteye.com/blog/1435157 一、基本使用： 使用chown命令可以修改文件或目录所属的用户：        命令
    • linux下抓包工具 矮蛋蛋 linux
      原文地址： http://blog.chinaunix.net/uid-23670869-id-2610683.html tcpdump -nn -vv -X udp port 8888 上面命令是抓取udp包、端口为8888 netstat -tln 命令是用来查看linux的端口使用情况 13 . 列出所有的网络连接 lsof -i 14. 列出所有tcp 网络连接信息 l
    • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起” alafqq mybatis
      最近看了  每一个用mybatis的男纸，你伤不起 原文地址 ：http://www.iteye.com/topic/1073938 发表一下个人看法。欢迎大神拍砖； 个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 发现多了一个mapper层；个人感觉就是个dao；
    • 解决java数据交换之谜 百合不是茶 数据交换
      交换两个数字的方法有以下三种 ，其中第一种最常用   /* 输出最小的一个数 */ public class jiaohuan1 { public static void main(String[] args) { int a =4; int b = 3; if(a<b){ // 第一种交换方式 int tmep =
    • 渐变显示 bijian1013 JavaScript
      <style type="text/css"> #wxf { FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98); height: 25px; } </style>
    • 探索JUnit4扩展：断言语法assertThat bijian1013 java单元测试assertThat
      一.概述         JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
    • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}} bit1129 gson
        如何把如下简单的JSON字符串反序列化为Java的POJO对象? {"data":{"IM":["MSN","QQ","Gtalk"]}}   下面的POJO类Model无法完成正确的解析：   import com.google.gson.Gson;
    • 【Kafka九】Kafka High Level API vs. Low Level API bit1129 kafka
      1. Kafka提供了两种Consumer API High Level Consumer API Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题  
    • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua
      Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
    • java-归并排序 bylijinnan java
      import java.util.Arrays; public class MergeSort { public static void main(String[] args) { int[] a={20,1,3,8,5,9,4,25}; mergeSort(a,0,a.length-1); System.out.println(Arrays.to
    • Netty源码学习-CompositeChannelBuffer bylijinnan javanetty
      CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 查看API（ http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 可以看到，所谓“Transparent Zero Copy”是通
    • Android中给Activity添加返回键 hotsunshine Activity
      // this need android:minSdkVersion="11" getActionBar().setDisplayHomeAsUpEnabled(true); @Override public boolean onOptionsItemSelected(MenuItem item) {
    • 静态页面传参 ctrain 静态
      $(document).ready(function () { var request = { QueryString : function (val) { var uri = window.location.search; var re = new RegExp("" + val + "=([^&?]*)", &
    • Windows中查找某个目录下的所有文件中包含某个字符串的命令 daizj windows查找某个目录下的所有文件包含某个字符串
      findstr可以完成这个工作。   [html]  view plain copy   >findstr /s /i "string" *.*   上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
    • 改善程序代码质量的一些技巧 dcj3sjt126com 编程PHP重构
      有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
    • SharedPreferences对数据的存储 dcj3sjt126com
      SharedPreferences简介：                                                   &nbs
    • linux复习笔记之bash shell (2) bash基础 eksliang bashbash shell
      转载请出自出处： http://eksliang.iteye.com/blog/2104329 1.影响显示结果的语系变量（locale）  1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： [root@localhost shell]# locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8"
    • Android零碎知识总结 gqdy365 android
      1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
    • HoverTree.Model.ArticleSelect类的作用 hvt Web.netC#hovertreeasp.net
      ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
    • PHP 判断是否使用代理 PHP Proxy Detector 天梯梦 proxy
      1. php 类 I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to
    • apache的math库中的回归——regression（翻译） lvdccyb Mathapache
      这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。   数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。   基本覆盖了：线代，统计，矩阵， 最优化理论 曲线拟合 常微分方程 遗传算法（GA）， 还有3维的运算。。。
    • 基础数据结构和算法十三：Undirected Graphs (2) sunwinner Algorithm
        Design pattern for graph processing. Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
    • 云计算平台最重要的五项技术 sumapp 云计算云平台智城云
      云计算平台最重要的五项技术 1、云服务器 云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 特性 机型丰富 通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 仅需要几分钟，根据CP
    • 《京东技术解密》有奖试读获奖名单公布 ITeye管理员 活动
      ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  12月试读活动回顾： http://webmaster.iteye.com/blog/2164754 本次技术图书试读活动获奖名单及相应作品如下： 一等奖（两名） Microhardest：http://microhardest.ite