java RedisTemplate定时

redis从入门到放弃

• 1.安装配置redis
• 2.先新建一个springboot项目
• 3.添加依赖（xml）
• 4.配置（yml）
• 5.配置文件Config(直接导入的)

• RedisConfig

• 6.redis的接口和实现(直接导入的。底层代码？？)

• redisService
• redisServiceImpl

• 7.开始使用

• CacheService
• CacheServiceImpl

• 8.调用缓存接口

1.安装配置redis

管理员运行cmd
到安装目录下
redis-server.exe redis.windows.conf

window下启动redis服务报错：
creating server tcp listening socket 127.0.0.1:6379: bind No error

解决方案(按顺序输入以下)
redis-cli.exe
shutdown
exit
redis-server.exe redis.windows.conf

2.先新建一个springboot项目

3.添加依赖（xml）

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.13</version>
        </dependency>

4.配置（yml）

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

5.配置文件Config(直接导入的)

项目下创建配置文件夹config

在文件夹下创建redis的配置文件

RedisConfig

package com.leaf.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * Redis配置类
 */
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisSerializer<Object> serializer = redisSerializer();
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(serializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    @Bean
    public RedisSerializer<Object> redisSerializer() {
        //创建JSON序列化器
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }
}

6.redis的接口和实现(直接导入的。底层代码？？)

在service下创建redisService

redisService

package com.leaf.service;

import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * redis操作Service
 */
public interface RedisService {
    /**
     * 保存属性
     */
    void set(String key, Object value, long time);
    /**
     * 保存属性
     */
    void set(String key, Object value);
    /**
     * 获取属性
     */
    Object get(String key);
    /**
     * 删除属性
     */
    Boolean del(String key);
    /**
     * 批量删除属性
     */
    Long del(List<String> keys);
    /**
     * 设置过期时间
     */
    Boolean expire(String key, long time);
    /**
     * 获取过期时间
     */
    Long getExpire(String key);
    /**
     * 判断是否有该属性
     */
    Boolean hasKey(String key);
    /**
     * 按delta递增
     */
    Long incr(String key, long delta);
    /**
     * 按delta递减
     */
    Long decr(String key, long delta);
    /**
     * 获取Hash结构中的属性
     */
    Object hGet(String key, String hashKey);
    /**
     * 向Hash结构中放入一个属性
     */
    Boolean hSet(String key, String hashKey, Object value, long time);
    /**
     * 向Hash结构中放入一个属性
     */
    void hSet(String key, String hashKey, Object value);
    /**
     * 直接获取整个Hash结构
     */
    Map<Object, Object> hGetAll(String key);
    /**
     * 直接设置整个Hash结构
     */
    Boolean hSetAll(String key, Map<String, Object> map, long time);
    /**
     * 直接设置整个Hash结构
     */
    void hSetAll(String key, Map<String, Object> map);
    /**
     * 删除Hash结构中的属性
     */
    void hDel(String key, Object... hashKey);
    /**
     * 判断Hash结构中是否有该属性
     */
    Boolean hHasKey(String key, String hashKey);
    /**
     * Hash结构中属性递增
     */
    Long hIncr(String key, String hashKey, Long delta);
    /**
     * Hash结构中属性递减
     */
    Long hDecr(String key, String hashKey, Long delta);
    /**
     * 获取Set结构
     */
    Set<Object> sMembers(String key);
    /**
     * 向Set结构中添加属性
     */
    Long sAdd(String key, Object... values);
    /**
     * 向Set结构中添加属性
     */
    Long sAdd(String key, long time, Object... values);
    /**
     * 是否为Set中的属性
     */
    Boolean sIsMember(String key, Object value);
    /**
     * 获取Set结构的长度
     */
    Long sSize(String key);
    /**
     * 删除Set结构中的属性
     */
    Long sRemove(String key, Object... values);
    /**
     * 获取List结构中的属性
     */
    List<Object> lRange(String key, long start, long end);
    /**
     * 获取List结构的长度
     */
    Long lSize(String key);
    /**
     * 根据索引获取List中的属性
     */
    Object lIndex(String key, long index);
    /**
     * 向List结构中添加属性
     */
    Long lPush(String key, Object value);
    /**
     * 向List结构中添加属性
     */
    Long lPush(String key, Object value, long time);
    /**
     * 向List结构中批量添加属性
     */
    Long lPushAll(String key, Object... values);
    /**
     * 向List结构中批量添加属性
     */
    Long lPushAll(String key, Long time, Object... values);
    /**
     * 从List结构中移除属性
     */
    Long lRemove(String key, long count, Object value);
}

在service下的Impl创建对应的实现

redisServiceImpl

package com.leaf.service.impl;

import com.leaf.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis操作实现类
 */
@Service
public class RedisServiceImpl implements RedisService {
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Override
    public void set(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }
    @Override
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    @Override
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }
    @Override
    public Long del(List<String> keys) {
        return redisTemplate.delete(keys);
    }
    @Override
    public Boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }
    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    @Override
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
    @Override
    public Long incr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }
    @Override
    public Long decr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    @Override
    public Object hGet(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }
    @Override
    public Boolean hSet(String key, String hashKey, Object value, long time) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        return expire(key, time);
    }
    @Override
    public void hSet(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }
    @Override
    public Map<Object, Object> hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
    @Override
    public Boolean hSetAll(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        return expire(key, time);
    }
    @Override
    public void hSetAll(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }
    @Override
    public void hDel(String key, Object... hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }
    @Override
    public Boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }
    @Override
    public Long hIncr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }
    @Override
    public Long hDecr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, -delta);
    }
    @Override
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }
    @Override
    public Long sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }
    @Override
    public Long sAdd(String key, long time, Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        expire(key, time);
        return count;
    }
    @Override
    public Boolean sIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }
    @Override
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }
    @Override
    public Long sRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }
    @Override
    public List<Object> lRange(String key, long start, long end) {

        return redisTemplate.opsForList().range(key, start, end);
    }
    @Override
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }
    @Override
    public Object lIndex(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }
    @Override
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }
    @Override
    public Long lPush(String key, Object value, long time) {
        Long index = redisTemplate.opsForList().rightPush(key, value);
        expire(key, time);
        return index;
    }
    @Override
    public Long lPushAll(String key, Object... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }
    @Override
    public Long lPushAll(String key, Long time, Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        expire(key, time);
        return count;
    }
    @Override
    public Long lRemove(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }
}

7.开始使用

一般是在服务层，也就是service层

直接创建接口和实现吧

CacheService

package com.leaf.cache;

import com.leaf.model.TInfo;
import java.util.Map;

public interface CacheService {
    void setCacheObject(String key, Object object);
    Object getCacheObject(String key);
}

CacheServiceImpl

package com.leaf.cache.impl;

import com.leaf.cache.CacheService;
import com.leaf.service.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Map;

@Slf4j
@Service
public class CacheServiceImpl implements CacheService {

@Autowired
private RedisService redisService;
//    <key ,object>
    @Override
    public void setCacheObject(String key, Object object) {
        redisService.set(key,object,60*60*24);
        System.out.println("完成");
    }
//  <key,object>
    @Override
    public Object getCacheObject(String key) {
        return redisService.get(key);
    }
}

8.调用缓存接口

在需要的实体类对应的服务层，直接使用对应方法。使用方法参考底层redisServiceImpl