springboot集成redis 简单使用

1.pom

        <!-- 添加redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.5.RELEASE</version>
        </dependency>

        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2.yml

server:
  port: 8102
  tomcat:
    uri-encoding: utf-8
  shutdown: graceful
spring:
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost/myallstudy?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8

  redis:
    # Redis数据库索引（默认为 0）
    database: 0
    # Redis服务器地址
    host: 192.168.196.129
    # Redis服务器连接端口
    port: 6379
    # Redis 密码
    password: admin
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 8
        # 连接池中的最大空闲连接
        max-idle: 500
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 2000
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10000
    # 连接超时时间（毫秒）
    timeout: 5000

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.demo.*.entity

3.Entity

/**
 * @Author: xxx
 * @Date: 2021/11/18 10:20
 */
@Data
@TableName("redis_user")
public class UserEntity  implements Serializable  {

    @TableId(value = "id" , type = IdType.AUTO)
    private int id;

    @TableField("name")
    private String name;

    @TableField("sex")
    private String sex;

    @TableField("age")
    private Integer age;

    @TableField("phone")
    private String phone;


}

4.Service

UserService

public interface UserService {

    public Object getRedis(String key);

    public UserEntity setRedis(UserEntity userEntity);

}

RedisService 

public interface RedisService {
    public void set(String key, Object value);

    public Object get(String key);
}

RedisServiceImpl

@Service
public class RedisServiceImpl implements RedisService {
    
    @Resource
    private RedisTemplate<String,Object> redisTemplate;
    
    @Override
    public void set(String key, Object value) {
        //直接设置
       /* ValueOperations<String,Object> vo = redisTemplate.opsForValue();
        vo.set(key, value);*/
        //设置过期时间
        redisTemplate.boundValueOps(key).set(value,1, TimeUnit.MINUTES);

        //设置过期时间
/*        redisTemplate.boundHashOps(key).put(key,value);
        redisTemplate.expire(key,1,TimeUnit.MINUTES);*/
    }
    @Override
    public Object get(String key) {
        /*ValueOperations<String,Object> vo = redisTemplate.opsForValue();
        vo.get(key);*/
        return redisTemplate.boundValueOps(key).get();
    }


    public void adding (String key){
        //值 int类型 每调用一次 累加值
        redisTemplate.boundValueOps(key).increment(1L);
    }

    public void subtract (String key){
        //值 int类型 每调用一次 累减
        redisTemplate.boundValueOps(key).increment(-1L);
    }

}

UserServiceImpl 

@Service
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Resource
    private RedisService redisService;

    @Override
    public Object getRedis(String key) {
        Object o = redisService.get(key);
        if (o==null){
            RedisUser redisUser = userMapper.selectByName(key);
            if (redisUser!=null){
                redisService.set(redisUser.getName(),redisUser);
            }

            return redisUser;
        }
        return o;
    }


    @Override
    @Transactional
    public UserEntity setRedis(UserEntity userEntity) {

        userMapper.insertSelective(userEntity);
        redisService.set(userEntity.getName(),userEntity);

        return userEntity;
    }
}

5.controller

UserController

@Controller
@RequestMapping(path="/user")
public class UserController {

    @Autowired
    private UserService userService;

    //从redis获取某个用户
    @RequestMapping(value = "/getuserfromredis", method = RequestMethod.GET)
    public @ResponseBody
    UserEntity getRedis(@RequestParam String key) {
        return (UserEntity) userService.getRedis(key);
    }

/*    //获取所有用户
    @RequestMapping(value = "/getusers", method = RequestMethod.GET)
    public @ResponseBody Page<RedisUserEntity> list(Model model, Pageable pageable){
        return userService.findAll(pageable);
    }*/
    //添加用户
    @GetMapping(value="/adduser")
    public UserEntity addUser(@RequestParam String name,
                       @RequestParam String sex,
                       @RequestParam Integer age,
                       @RequestParam String phone) {
        UserEntity user = new UserEntity();
        user.setName(name);
        user.setSex(sex);
        user.setAge(age);
        user.setPhone(phone);

        return userService.setRedis(user);
    }
}

7.config

RedisConfig

@Configuration
@EnableCaching//开启注解
public class RedisConfig extends CachingConfigurerSupport {
/*
    @Bean
    public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
        CacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager;
    }
*/

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
}