1 <?xml version="1.0" encoding="UTF-8"?> 2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4 <modelVersion>4.0.0</modelVersion> 5 6 <groupId>com.asdc</groupId> 7 <artifactId>multiRedisDatabase</artifactId> 8 <version>0.0.1-SNAPSHOT</version> 9 <packaging>jar</packaging> 10 11 <name>multiRedisDatabase</name> 12 <description>Demo project for Spring Boot</description> 13 14 <parent> 15 <groupId>org.springframework.boot</groupId> 16 <artifactId>spring-boot-starter-parent</artifactId> 17 <version>1.5.16.RELEASE</version> 18 <relativePath /> <!-- lookup parent from repository --> 19 </parent> 20 21 <properties> 22 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 23 <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> 24 <java.version>1.8</java.version> 25 </properties> 26 27 <dependencies> 28 <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson --> 29 <dependency> 30 <groupId>com.alibaba</groupId> 31 <artifactId>fastjson</artifactId> 32 <version>1.2.47</version> 33 </dependency> 34 35 <dependency> 36 <groupId>org.springframework.boot</groupId> 37 <artifactId>spring-boot-starter-data-redis</artifactId> 38 </dependency> 39 <dependency> 40 <groupId>org.springframework.boot</groupId> 41 <artifactId>spring-boot-starter-web</artifactId> 42 </dependency> 43 44 <dependency> 45 <groupId>org.springframework.boot</groupId> 46 <artifactId>spring-boot-starter-test</artifactId> 47 <scope>test</scope> 48 </dependency> 49 </dependencies> 50 51 <build> 52 <plugins> 53 <plugin> 54 <groupId>org.springframework.boot</groupId> 55 <artifactId>spring-boot-maven-plugin</artifactId> 56 </plugin> 57 </plugins> 58 </build> 59 60 61 </project>
application.properties
# Redis数据库索引（默认为0） spring.redis.database=10 # Redis服务器地址 spring.redis.hostName=127.0.0.1 # Redis服务器连接端口 spring.redis.port=6379 # Redis服务器连接密码（默认为空） spring.redis.password= # 连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-active=1024 # 连接池最大阻塞等待时间（使用负值表示没有限制） spring.redis.pool.max-wait=-1 # 连接池中的最大空闲连接 spring.redis.pool.max-idle=200 # 连接池中的最小空闲连接 spring.redis.pool.min-idle=0 # 连接超时时间（毫秒） spring.redis.timeout=15000 spring.redis.sentinel.master=mymaster spring.redis.sentinel.nodes=127.0.0.1,127.0.0.1,127.0.0.1 spring.redis.sentinel.port=26379
1 package com.asdc.multiRedisDatabase.config;
2
3 import org.springframework.boot.context.properties.ConfigurationProperties;
4 import org.springframework.stereotype.Component;
5
6 /**
7 * @Description: Redis哨兵配置实体类
8 * @author: Jennifer
9 * @date: 2018年9月27日 上午10:10:34
10 */
11 @Component
12 @ConfigurationProperties(prefix = "spring.redis.sentinel")
13 public class RedisSentinelProperties {
14 private String master;
15 private String nodes;
16 private Integer port;
17
18 public String getMaster() {
19 return master;
20 }
21
22 public void setMaster(String master) {
23 this.master = master;
24 }
25
26 public String getNodes() {
27 return nodes;
28 }
29
30 public void setNodes(String nodes) {
31 this.nodes = nodes;
32 }
33
34 @Override
35 public String toString() {
36 return "RedisProperties [master=" + master + ", nodes=" + nodes + ", port=" + port + "]";
37 }
38
39 public void setPort(Integer port) {
40 this.port = port;
41 }
42
43 public Integer getPort() {
44 return port;
45 }
46
47 }
1 package com.asdc.multiRedisDatabase.config;
2
3 import org.springframework.beans.factory.annotation.Value;
4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
5 import org.springframework.context.annotation.Bean;
6 import org.springframework.context.annotation.Configuration;
7 import org.springframework.context.annotation.Primary;
8 import org.springframework.data.redis.connection.RedisConnectionFactory;
9 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
10 import org.springframework.data.redis.core.RedisTemplate;
11 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
12 import org.springframework.data.redis.serializer.RedisSerializer;
13 import org.springframework.data.redis.serializer.StringRedisSerializer;
14
15 import com.fasterxml.jackson.annotation.JsonAutoDetect;
16 import com.fasterxml.jackson.annotation.PropertyAccessor;
17 import com.fasterxml.jackson.databind.ObjectMapper;
18
19 import redis.clients.jedis.JedisPoolConfig;
20
21 @Configuration
22 @EnableAutoConfiguration
23 public class RedisAloneConfig {
24
25 @Bean(name = "aloneStringRedisTemplate")
26 @Primary
27 public RedisTemplate<String, Object> redisTemplate(@Value("${spring.redis.hostName}") String hostName,
28 @Value("${spring.redis.port}") int port, @Value("${spring.redis.password}") String password,
29 @Value("${spring.redis.pool.max-idle}") int maxIdle, @Value("${spring.redis.pool.max-active}") int maxTotal,
30 @Value("${spring.redis.database}") int index, @Value("${spring.redis.pool.max-wait}") long maxWaitMillis) {
31 // 设置序列化
32 Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
33 Object.class);
34 ObjectMapper om = new ObjectMapper();
35 om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
36 om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
37 jackson2JsonRedisSerializer.setObjectMapper(om);
38
39 RedisTemplate<String, Object> temple = new RedisTemplate<String, Object>();
40 temple.setConnectionFactory(
41 this.connectionFactory(hostName, port, password, maxIdle, maxTotal, index, maxWaitMillis));
42 RedisSerializer<?> stringSerializer = new StringRedisSerializer();
43 temple.setKeySerializer(stringSerializer);// key序列化
44 temple.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
45 temple.setHashKeySerializer(stringSerializer);// Hash key序列化
46 temple.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
47 return temple;
48 }
49
50 public RedisConnectionFactory connectionFactory(String hostName, int port, String password, int maxIdle,
51 int maxTotal, int index, long maxWaitMillis) {
52 JedisConnectionFactory jedis = new JedisConnectionFactory();
53 jedis.setHostName(hostName);
54 jedis.setPort(port);
55 jedis.setPassword(password);
56 jedis.setDatabase(index);
57 jedis.setPoolConfig(this.poolCofig(maxIdle, maxTotal, maxWaitMillis));
58 // 初始化连接pool
59 jedis.afterPropertiesSet();
60 RedisConnectionFactory factory = jedis;
61 return factory;
62 }
63
64 public JedisPoolConfig poolCofig(int maxIdle, int maxTotal, long maxWaitMillis) {
65 JedisPoolConfig poolCofig = new JedisPoolConfig();
66 poolCofig.setMaxIdle(maxIdle);
67 poolCofig.setMaxTotal(maxTotal);
68 poolCofig.setMaxWaitMillis(maxWaitMillis);
69 poolCofig.setTestOnBorrow(false);
70 return poolCofig;
71 }
72
73 }
1 package com.asdc.multiRedisDatabase.config;
2
3 import org.springframework.beans.factory.annotation.Autowired;
4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
5 import org.springframework.context.annotation.Bean;
6 import org.springframework.context.annotation.Configuration;
7 import org.springframework.context.annotation.Primary;
8 import org.springframework.data.redis.connection.RedisConnectionFactory;
9 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
10 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
11 import org.springframework.data.redis.core.RedisTemplate;
12 import org.springframework.data.redis.core.StringRedisTemplate;
13 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
14 import org.springframework.data.redis.serializer.RedisSerializer;
15 import org.springframework.data.redis.serializer.StringRedisSerializer;
16
17 import com.fasterxml.jackson.annotation.JsonAutoDetect;
18 import com.fasterxml.jackson.annotation.PropertyAccessor;
19 import com.fasterxml.jackson.databind.ObjectMapper;
20
21 import redis.clients.jedis.JedisPoolConfig;
22
23 @Configuration
24 @EnableAutoConfiguration
25 public class RedisSentinelConfig {
26
27 @Autowired
28 private RedisSentinelProperties properties;
29
30 @Bean(name = "firstRedisTemplate")
31 @Primary
32 public RedisTemplate<Object, Object> redisTemplate() {
33 return getRedisTemplate(getConnectionFactory());
34 }
35
36 @Bean(name = "firstStringRedisTemplate")
37 @Primary
38 public StringRedisTemplate stringRedisTemplate() {
39 return getStringRedisTemplate(getConnectionFactory());
40 }
41
42 private RedisTemplate<Object, Object> getRedisTemplate(RedisConnectionFactory connectionFactory) {
43 RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
44 template.setConnectionFactory(connectionFactory);
45 setSerializer(template);
46 template.afterPropertiesSet();
47 return template;
48 }
49
50 private void setSerializer(RedisTemplate<Object, Object> template) {
51 Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
52 Object.class);
53 ObjectMapper om = new ObjectMapper();
54 om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
55 om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
56 jackson2JsonRedisSerializer.setObjectMapper(om);
57 template.setKeySerializer(jackson2JsonRedisSerializer);
58 template.setValueSerializer(jackson2JsonRedisSerializer);
59 template.setHashValueSerializer(jackson2JsonRedisSerializer);
60 }
61
62 private StringRedisTemplate getStringRedisTemplate(RedisConnectionFactory connectionFactory) {
63 StringRedisTemplate template = new StringRedisTemplate();
64 template.setConnectionFactory(connectionFactory);
65 setStringSerializer(template);
66 template.afterPropertiesSet();
67 return template;
68 }
69
70 private void setStringSerializer(StringRedisTemplate template) {
71 RedisSerializer<String> stringSerializer = new StringRedisSerializer();
72 template.setKeySerializer(stringSerializer);
73 template.setValueSerializer(stringSerializer);
74 template.setHashKeySerializer(stringSerializer);
75 template.setHashValueSerializer(stringSerializer);
76 template.afterPropertiesSet();
77 }
78
79 @Bean
80 public JedisConnectionFactory getConnectionFactory() {
81 JedisPoolConfig config = new JedisPoolConfig();
82 JedisConnectionFactory factory = new JedisConnectionFactory(getRedisSentinelConfig(), config);
83 factory.setPoolConfig(config);
84 return factory;
85 }
86
87 @Bean
88 public RedisSentinelConfiguration getRedisSentinelConfig() {
89 RedisSentinelConfiguration sentinelConfiguration = new RedisSentinelConfiguration();
90 sentinelConfiguration.setMaster(properties.getMaster());
91 String sentinelHost = properties.getNodes();
92 Integer sentinelPort = properties.getPort();
93 String[] hosts = sentinelHost.split(",");
94 for (int i = 0; i < hosts.length; i++) {
95 sentinelConfiguration.sentinel(hosts[i], sentinelPort);
96 }
97 return sentinelConfiguration;
98 }
99
100 }
1 package com.asdc.multiRedisDatabase.service;
2
3 import java.util.List;
4 import java.util.Map;
5 import java.util.Set;
6 import java.util.concurrent.TimeUnit;
7
8 import javax.annotation.PostConstruct;
9 import javax.annotation.Resource;
10
11 import org.springframework.dao.DataAccessException;
12 import org.springframework.data.redis.connection.RedisConnection;
13 import org.springframework.data.redis.core.HashOperations;
14 import org.springframework.data.redis.core.ListOperations;
15 import org.springframework.data.redis.core.RedisCallback;
16 import org.springframework.data.redis.core.RedisTemplate;
17 import org.springframework.data.redis.core.StringRedisTemplate;
18 import org.springframework.data.redis.core.ValueOperations;
19 import org.springframework.data.redis.core.ZSetOperations;
20 import org.springframework.data.redis.serializer.RedisSerializer;
21 import org.springframework.data.redis.serializer.StringRedisSerializer;
22 import org.springframework.stereotype.Component;
23
24 @Component
25 @SuppressWarnings({ "unchecked", "rawtypes" })
26 public class RedisService {
27
28 @Resource(name = "firstStringRedisTemplate")
29 private StringRedisTemplate stringRedisTemplate;
30
31 @Resource(name = "firstStringRedisTemplate")
32 private ValueOperations<String, String> stringRedisOperations;
33
34 @Resource(name = "firstRedisTemplate")
35 private RedisTemplate redisTemplate;
36
37 @Resource(name = "firstRedisTemplate")
38 private ValueOperations<String, String> redisOperations;
39
40 @Resource(name = "firstStringRedisTemplate")
41 private HashOperations<String, String, String> hMapOps;
42
43 @Resource(name = "firstStringRedisTemplate")
44 ZSetOperations<String, String> zSetOps;
45
46 @Resource(name = "firstRedisTemplate")
47 ListOperations<String, Object> listOps;
48
49 @Resource(name = "aloneStringRedisTemplate")
50 private RedisTemplate<String, Object> aloneRedisTemplate;
51
52 public RedisTemplate<String, Object> getTemplate() {
53 return aloneRedisTemplate;
54 }
55
56 /**
57 * StringRedisTemplate<br>
58 * 放入redis,使用默认的过期时间<br>
59 *
60 * @param key
61 * @param value
62 */
63 public void setStringValue(final String key, String value) {
64 stringRedisOperations.set(key, value);
65 }
66
67 /**
68 * StringRedisTemplate<br>
69 * 从redis取出value
70 *
71 * @param key
72 * @return
73 */
74 public String getStringValue(final String key) {
75 return stringRedisOperations.get(key);
76 }
77
78 /**
79 * StringRedisTemplate<br>
80 * 放入redis,并设置过期时间(分钟)
81 *
82 * @param key
83 * @param value
84 * @param expireTime
85 */
86 public void setStringValue(final String key, String value, Long expireTime) {
87 stringRedisOperations.set(key, value);
88 stringRedisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
89 }
90
91 /**
92 * StringRedisTemplate<br>
93 * 判断是否存在key
94 *
95 * @param key
96 * @return
97 */
98 public boolean hasKey(final String key) {
99 return stringRedisTemplate.hasKey(key);
100 }
101
102 /**
103 * StringRedisTemplate<br>
104 * 删除相应的value
105 *
106 * @param key
107 */
108 public void remove(final String key) {
109 stringRedisTemplate.delete(key);
110 }
111
112 public StringRedisTemplate geStringRedisTemplate() {
113 return this.stringRedisTemplate;
114 }
115
116 public RedisTemplate geRedisTemplate() {
117 return this.redisTemplate;
118 }
119
120 /**
121 * StringRedisTemplate<br>
122 * 批量删除对应的value
123 *
124 * @param keys
125 */
126 public void remove(final String... keys) {
127 for (String key : keys) {
128 remove(key);
129 }
130 }
131
132 /**
133 * StringRedisTemplate<br>
134 * 返回 StringRedisOperation
135 *
136 * @return
137 */
138 public ValueOperations<String, String> getOperations() {
139 return this.stringRedisOperations;
140 }
141
142 /**
143 * RedisTemplate<br>
144 * 获取对象类型的值
145 *
146 * @param key
147 * @return
148 */
149 public Object getObjectValue(String key) {
150 return redisOperations.get(key);
151 }
152
153 /**
154 * RedisTemplate<br>
155 * 添加对象类型数据
156 *
157 * @param key
158 * @param object
159 */
160 public void setObjectValue(String key, Object object) {
161 redisOperations.set(key, (String) object);
162 }
163
164 /**
165 * RedisTemplate<br>
166 *
167 * @param key
168 * @param object
169 * @param expireTime
170 */
171 /* @SuppressWarnings("unchecked")
172 public void setObjectValue(String key,Object object ,Long expireTime){
173 redisOperations.set(key, object);
174 redisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
175 }*/
176
177 public void increment(String key, Long delta) {
178 redisOperations.increment(key, delta);
179 }
180
181 public void expire(String key, Long expireTime) {
182 redisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
183 }
184
185 public void expire(String key, Long expireTime, TimeUnit unit) {
186 stringRedisTemplate.expire(key, expireTime, unit);
187 }
188
189
190 public Set getKeysByPattern(String pattern) {
191 return redisTemplate.keys(pattern);
192 }
193
194 public void setHash(String key, String hashKey, String value) {
195 hMapOps.put(key, hashKey, value);
196 }
197
198 public String getHashValue(String key, String mapKey) {
199 return hMapOps.get(key, mapKey);
200 }
201
202 public Map<String, String> getHashAll(String key) {
203 return hMapOps.entries(key);
204 }
205
206 public long setHashIncrement(String key, String hashKey, long counts) {
207 return hMapOps.increment(key, hashKey, counts);
208 }
209
210 public long size(String key) {
211 return hMapOps.size(key);
212 }
213
214 public long lookTimeOut(String key, TimeUnit timeUnit) {
215 return stringRedisTemplate.getExpire(key, timeUnit);
216 }
217
218 public boolean zAddZsetElement(String key, String value, long score) {
219 return zSetOps.add(key, value, score);
220 }
221
222 public Double getZsetScore(String key, String value) {
223 return zSetOps.score(key, value);
224 }
225
226 public long getListSize(String key) {
227 return listOps.size(key);
228 }
229
230 public List<Object> getList(String key) {
231 return listOps.range(key, 0L, -1L);
232 }
233
234 public void addList(String key, List<Object> values) {
235 if (values == null || values.size() == 0) {
236 return;
237 }
238
239 listOps.rightPushAll(key, values);
240 }
241
242 /**
243 * 获取自增值
244 *
245 * @param key
246 * @return
247 */
248 public int getIncrValue(final String key) {
249
250 return stringRedisTemplate.execute(new RedisCallback<Integer>() {
251 @Override
252 public Integer doInRedis(RedisConnection connection) throws DataAccessException {
253 RedisSerializer<String> serializer = stringRedisTemplate.getStringSerializer();
254 byte[] rowkey = serializer.serialize(key);
255 byte[] rowval = connection.get(rowkey);
256 try {
257 String val = serializer.deserialize(rowval);
258 return Integer.parseInt(val);
259 } catch (Exception e) {
260 return 0;
261 }
262 }
263 });
264 }
265
266 @PostConstruct
267 public void init() {
268 redisTemplate.setKeySerializer(new StringRedisSerializer());
269 redisTemplate.setValueSerializer(new StringRedisSerializer());
270 }
271
272 public long delOfflineContent(String contentId, String listId) {
273 return listOps.remove(listId, 1, contentId);
274 }
275 }
1 package com.asdc.multiRedisDatabase;
2
3 import org.springframework.boot.SpringApplication;
4 import org.springframework.boot.autoconfigure.SpringBootApplication;
5
6 @SpringBootApplication
7 public class MultiRedisDatabaseApplication {
8
9 public static void main(String[] args) {
10 SpringApplication.run(MultiRedisDatabaseApplication.class, args);
11 }
12 }
1 package com.asdc.multiRedisDatabase.controller;
2
3 import java.util.Date;
4 import java.util.Iterator;
5 import java.util.Set;
6
7 import org.springframework.beans.factory.annotation.Autowired;
8 import org.springframework.data.redis.core.RedisTemplate;
9 import org.springframework.web.bind.annotation.RequestMapping;
10 import org.springframework.web.bind.annotation.ResponseBody;
11 import org.springframework.web.bind.annotation.RestController;
12
13 import com.asdc.multiRedisDatabase.service.RedisService;
14
15 /**
16 * @Description: 数据同步控制器
17 * @author: Jennifer
18 * @date: 2018年9月27日 上午11:25:24
19 */
20 @RestController
21 public class SyncController {
22 @Autowired
23 private RedisService redisService;
24
25 private static Long EXPIRE_TIME = 61 * 24 * 60L;
26
27 @RequestMapping("/sync")
28 @ResponseBody
29 public String sync() {
30 RedisTemplate<String, Object> template = redisService.getTemplate();
31 Set<String> keys = template.keys("*");
32 int count = 0;
33 for (Iterator<?> iterator = keys.iterator(); iterator.hasNext();) {
34 String key = (String) iterator.next();
35 try {
36 Integer value = (Integer) template.opsForValue().get(key);
37 if (value != null) {
38 redisService.setStringValue(key, value.toString(), EXPIRE_TIME);
39 count++;
40 }
41 } catch (Exception e) {
42 }
43 }
44 return String.format("单机Redis总记录数： %s ，Sentinel有效导入数： %s ，记录时间： %s", String.valueOf(keys.size()), count,
45 new Date());
46 }
47 }
1 package com.asdc.multiRedisDatabase;
2
3 import java.util.Date;
4 import java.util.Iterator;
5 import java.util.Set;
6
7 import org.junit.Test;
8 import org.junit.runner.RunWith;
9 import org.slf4j.Logger;
10 import org.slf4j.LoggerFactory;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.boot.test.context.SpringBootTest;
13 import org.springframework.data.redis.core.RedisTemplate;
14 import org.springframework.test.context.junit4.SpringRunner;
15
16 import com.asdc.multiRedisDatabase.config.RedisSentinelConfig;
17 import com.asdc.multiRedisDatabase.service.RedisService;
18
19 @RunWith(SpringRunner.class)
20 @SpringBootTest
21 public class MultiRedisDatabaseApplicationTests {
22 @Autowired
23 private RedisService redisService;
24
25 private static Long EXPIRE_TIME = 61 * 24 * 60L;
26
27 private static Logger logger = LoggerFactory.getLogger(RedisSentinelConfig.class);
28
29 @Test
30 public void getKeys() {
31 RedisTemplate<String, Object> template = redisService.getTemplate();
32 Set<String> keys = template.keys("*");
33 int count = 0;
34 for (Iterator<?> iterator = keys.iterator(); iterator.hasNext();) {
35 String key = (String) iterator.next();
36 try {
37 Integer value = (Integer) template.opsForValue().get(key);
38 if (value != null) {
39 logger.info(count++ + ":" + key + " = " + value);
40 redisService.setStringValue(key, value.toString(), EXPIRE_TIME);
41 }
42 } catch (Exception e) {
43 }
44 }
45 logger.info(String.format("总记录数： %s ，有效导入数： %s ，记录时间： %s", String.valueOf(keys.size()), count, new Date()));
46 }
47
48 }
原文地址：https://www.cnblogs.com/qiushuiblog/p/9712869.html
时间： 2024-10-14 04:49:16