实现InitializingBean接口的afterPropertiesSet方法,当启动时将所有需要缓存的数据缓存到redis中

@Controller
@RequestMapping("/dsfasdf")
public class TestController1 implements InitializingBean {
@Autowired
private RedisService redisService; //注入redis的service
@Autowired
private IUserService userService; //注入用户的 service

@Override
public void afterPropertiesSet() throws Exception {
    User user = new User();
    long a=System.currentTimeMillis();
    List<User> users = userService.selectUserList(user);
    System.err.print("-----初始化人员数据-----");
    redisService.set("user", users);
    System.err.println("-----初始化人员数据-----执行耗时 : "+(System.currentTimeMillis()-a)/1000f+" 秒 ");
}

}
--------------------------下面是redisService服务类----------------------------------

package com.ruoyi.framework.web.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
public class RedisService {
@Autowired
private RedisTemplate redisTemplate;
/**

 * 写入缓存
 * @param key
 * @param value
 * @return
 */
public boolean set(final String key, Object value) {
    boolean result = false;
    try {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value);
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
/**
 * 写入缓存设置时效时间
 * @param key
 * @param value
 * @return
 */
public boolean set(final String key, Object value, Long expireTime) {
    boolean result = false;
    try {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value);
        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
/**
 * 批量删除对应的value
 * @param keys
 */
public void remove(final String... keys) {
    for (String key : keys) {
        remove(key);
    }
}

/**
 * 批量删除key
 * @param pattern
 */
public void removePattern(final String pattern) {
    Set<Serializable> keys = redisTemplate.keys(pattern);
    if (keys.size() > 0)
        redisTemplate.delete(keys);
}
/**
 * 删除对应的value
 * @param key
 */
public void remove(final String key) {
    if (exists(key)) {
        redisTemplate.delete(key);
    }
}
/**
 * 判断缓存中是否有对应的value
 * @param key
 * @return
 */
public boolean exists(final String key) {
    return redisTemplate.hasKey(key);
}
/**
 * 读取缓存
 * @param key
 * @return
 */
public Object get(final String key) {
    Object result = null;
    ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    result = operations.get(key);
    return result;
}
/**
 * 哈希 添加
 * @param key
 * @param hashKey
 * @param value
 */
public void hmSet(String key, Object hashKey, Object value){
    HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
    hash.put(key,hashKey,value);
}

/**
 * 哈希获取数据
 * @param key
 * @param hashKey
 * @return
 */
public Object hmGet(String key, Object hashKey){
    HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    return hash.get(key,hashKey);
}

/**
 * 列表添加
 * @param k
 * @param v
 */
public void lPush(String k,Object v){
    ListOperations<String, Object> list = redisTemplate.opsForList();
    list.rightPush(k,v);
}

/**
 * 列表获取
 * @param k
 * @param l
 * @param l1
 * @return
 */
public List<Object> lRange(String k, long l, long l1){
    ListOperations<String, Object> list = redisTemplate.opsForList();
    return list.range(k,l,l1);
}

/**
 * 集合添加
 * @param key
 * @param value
 */
public void add(String key,Object value){
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    set.add(key,value);
}

/**
 * 集合获取
 * @param key
 * @return
 */
public Set<Object> setMembers(String key){
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    return set.members(key);
}

/**
 * 有序集合添加
 * @param key
 * @param value
 * @param scoure
 */
public void zAdd(String key,Object value,double scoure){
    ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    zset.add(key,value,scoure);
}

/**
 * 有序集合获取
 * @param key
 * @param scoure
 * @param scoure1
 * @return
 */
public Set<Object> rangeByScore(String key,double scoure,double scoure1){
    ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    return zset.rangeByScore(key, scoure, scoure1);
}

}