Springboot整合redis

redis简介

Redis是一个开源的内存数据结构存储数据库，用作数据库，缓存等。提供了字符串，散列，列表，集合等数据结构。常用的场景有分布式session共享，缓存数据，临时存储如购物车等。

redis常用的命令

set get

set key value
1

setnx

setnx key value :
将 key 的值设为 value ，当且仅当 key 不存在。
若给定的 key 已经存在，则 SETNX 不做任何动作。

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> 
127.0.0.1:6379> setnx k1 v2
(integer) 0
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> 
1
2
3
4
5
6
7
8

这里就不在多介绍，详细参考官网命令。

springboot中使用redis

引入依赖

  
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-redisartifactId>
      <version>1.4.7.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.springframework.sessiongroupId>
      <artifactId>spring-session-data-redisartifactId>
      <version>2.3.1.RELEASEversion>
    dependency>
1
2
3
4
5
6
7
8
9
10
11
12

配置redis

  #配置redis
  redis:
    host: redis服务器地址
    database: 0  #配置数据库0
    port: 6379 #端口
    #password:
    #配置连接池
    jedis:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1 #ms
1
2
3
4
5
6
7
8
9
10
11
12
13

redis服务类接口

/**
 * 定义访问redis的接口类
 *
 */
public interface RedisService {
    /**
     * 保存key value
     * @param key
     * @param value
     */
     void saveKeyValue(String key,Object value);
    /**
     * 保存key value
     * @param key
     * @param value
     */
    void saveKeyValue(String key,Object value,int expiration);
    /**
     * 根据key获取value
     * @param key
     * @return
     */
    String getValueByKey(String key);

    /**
     * 根据key删除缓存
     * @param key
     */
    void delete(String key);

    /**
     * 清空所有缓存
     */
    void flushdb();

}
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

redis服务实现类

/**
 * redis 实现类
 */
@Service
public class RedisServiceImpl implements RedisService {

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 保存key value
     * @param key
     * @param value
     */
    @Override
    public void saveKeyValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
    /**
     * 设置过期时间
     * @param key
     * @param value
     * @param expiration 过期时间
     */
    @Override
    public void saveKeyValue(String key, Object value, int expiration) {
        redisTemplate.opsForValue().set(key, value);
        redisTemplate.expire(key, expiration, TimeUnit.MINUTES);
    }
    /**
     * 根据key获取value
     * @param key
     * @return
     */
    @Override
    public String getValueByKey(String key) {
        try {
            String value = redisTemplate.opsForValue().get(key).toString();
            return value;
        } catch (Exception e) {
            return "";
        }
    }
    /**
     * 删除缓存
     * @param key
     */
    @Override
    public void delete(String key) {
        redisTemplate.delete(key);
    }
    /**
     * 清空所有的缓存
     */
    @Override
    public void flushdb() {
        redisTemplate.getConnectionFactory().getConnection().flushDb();
    }
}

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

controller测试

@RestController
public class RedisController {

    //引入缓存操作
    @Autowired
    RedisService redisService;

    @GetMapping("/redistest")
    public String hello(){
        return "hello,spring integration with redis";
    }
    @GetMapping("/redis/{key}/{val}")
    public String savekeyValue(@PathVariable("key") String key, @PathVariable("val") Object val){
        redisService.saveKeyValue(key,val);
        return key+"="+redisService.getValueByKey(key);
    }

    @GetMapping("/redis/{key}")
    public String getValueByKey(@PathVariable("key") String key){
        return redisService.getValueByKey(key);
    }

    @GetMapping("/redis/delete/{key}")
    public String delete(@PathVariable("key") String key){
       redisService.delete(key);
       return redisService.getValueByKey(key);
    }
}
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

分布式session共享

配置session的存储类型

  #指定session的存储方式
spring:
  session:
    store-type: redis
1
2
3
4

配置session

@Configuration
//@EnableRedisHttpSession
//配置失效时间
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 60) //1分钟失效
public class SessionConfig {
}

1
2
3
4
5
6
7

session控制类

/**
 * session控制类
 */
@RestController
public class SessionController {

    //设置session
    @GetMapping("/setSession/{username}")
    public String setSession(HttpSession httpSession,@PathVariable("username") String username){
        httpSession.setAttribute("username",username);
        return "OK";
    }
    //获取session
    @GetMapping("/getSession")
    public Object getSession(HttpSession httpSession){
        Object username = httpSession.getAttribute("username");
        return username;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

IDEA中，我们可以改下端口重启两个服务，分布访问。

测试

超过1分钟之后，可以看到session失效。