redis-server.exe   redis.windows.conf   #加載配置文件啟動 

flushdb  清空當(dāng)前庫

flushall  清空所有庫

select   1    切換庫

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

spring:
  redis:
    # Redis數(shù)據(jù)庫索引（默認為0）
    database: 0
    # Redis服務(wù)器地址
    host: 127.0.0.1
    # Redis服務(wù)器連接端口
    port: 6379
    # Redis服務(wù)器連接密碼（默認為空）
    password:
    # 連接池最大連接數(shù)（使用負值表示沒有限制）
    jedis.pool.max-active: 20
    # 連接池最大阻塞等待時間（使用負值表示沒有限制）
    jedis.pool.max-wait: -1
    # 連接池中的最大空閑連接
    jedis.pool.max-idle: 10
    # 連接池中的最小空閑連接
    jedis.pool.min-idle: 0
    # 連接超時時間（毫秒）
    timeout: 1000

/**
 * 使用RedisTemplate 操作Redis數(shù)據(jù)的不同數(shù)據(jù)類型
 */
@SpringBootTest
public class Springbootday03ApplicationTests {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * String 類型數(shù)據(jù)操作
     */
    @Test
    public void operateString() {

        //添加值
        redisTemplate.opsForValue().set("str", "strValue1");

        //添加值  判定是否存在 存在則不添加
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("str", "strAbsent");
        System.out.println("str設(shè)置成功:" + aBoolean);

        //獲取值
        String str = redisTemplate.opsForValue().get("str");
        System.out.println("str = " + str);

        //更新值
        redisTemplate.opsForValue().set("str", "strValue2");
        str = redisTemplate.opsForValue().get("str");
        System.out.println("newStr = " + str);

        //刪除值
        Boolean b = redisTemplate.delete("str");
        System.out.println("str刪除成功：" + b);

    }

    /**
     * 操作string類型數(shù)據(jù)  設(shè)置過期時間
     */
    @Test
    public void operateString2() {
        redisTemplate.opsForValue().set("str", "strTimeout", 10, TimeUnit.SECONDS);
        //判定值是否存在 不存在則設(shè)置值 同時設(shè)置過期時間
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("str2", "strTimeoutAbsent", 20, TimeUnit.SECONDS);
        System.out.println("setIfAbsent:" + aBoolean);
    }

    /**
     * 操作hash類型數(shù)據(jù)
     */
    @Test
    public void operateHash() {
        //添加hash類型數(shù)據(jù)  key - value
        redisTemplate.opsForHash().put("hash", "username", "admin");
        //修改hash類型數(shù)據(jù)
        redisTemplate.opsForHash().put("hash", "username", "tom");
        redisTemplate.opsForHash().put("hash", "password", "123456");

        //添加hash類型數(shù)據(jù)  key - map
        HashMap<String, String> map = new HashMap<>();
        map.put("driverName", "com.mysql.jdbc.Driver");
        map.put("url", "jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC");
        redisTemplate.opsForHash().putAll("hash", map);

        //獲取hash類型數(shù)據(jù)  entries
        Map<Object, Object> hash = redisTemplate.opsForHash().entries("hash");
        hash.forEach((key, value) -> {
            System.out.println(key + "::" + value);
        });

        //獲取所有的key
        Set<Object> keys = redisTemplate.opsForHash().keys("hash");
        for (Object key : keys) {
            System.out.println("key:" + key);
        }
        //獲取所有value
        List<Object> values = redisTemplate.opsForHash().values("hash");
        values.forEach(value -> System.out.println("value:" + value));

        //刪除hash類型數(shù)據(jù)  刪除一個  返回刪除的個數(shù)
        Long delete = redisTemplate.opsForHash().delete("hash", "username");
        System.out.println("delete = " + delete);

        //刪除hash類型數(shù)據(jù)  刪除多個  返回刪除的個數(shù)
        delete = redisTemplate.opsForHash().delete("hash", "username", "password", "driverName");
        System.out.println("delete = " + delete);

        //刪除hash類型數(shù)據(jù)  刪除所有
        Boolean delHash = redisTemplate.delete("hash");
        System.out.println("delHah:" + delHash);

    }

    /**
     * 操作List類型  有序 可重復(fù)
     */
    @Test
    public void operateList() {

        //左壓棧
        // redisTemplate.opsForList().leftPush("list", "listValue1");
        // redisTemplate.opsForList().leftPush("list", "listValue1");
        // redisTemplate.opsForList().leftPush("list", "listValue2");
        // redisTemplate.opsForList().leftPush("list", "listValue3");

        //右壓棧
        redisTemplate.opsForList().rightPush("list", "listValue0");
        redisTemplate.opsForList().rightPush("list", "listValue2");
        redisTemplate.opsForList().rightPush("list", "listValue0");

        //左出棧
        String list1 = redisTemplate.opsForList().leftPop("list");
        System.out.println("leftPop list1 = " + list1);
        //右出棧
        String list2 = redisTemplate.opsForList().rightPop("list");
        System.out.println("rightPop list2 = " + list2);

        //獲取所有數(shù)據(jù)
        List<String> lists = redisTemplate.opsForList().range("list", 0, 		        redisTemplate.opsForList().size("list") - 1);
        lists.forEach(list -> System.out.println(list));


        //設(shè)置指定位置的數(shù)據(jù)
        redisTemplate.opsForList().set("list", 0, "listValue0");
        /**
         * 從存儲在鍵中的列表中刪除等于值的元素的第一個計數(shù)事件。
         * count> 0：刪除等于從左到右移動的值的第一個元素；
         * count< 0：刪除等于從右到左移動的值的第一個元素；
         * count = 0：刪除等于value的所有元素。
         */
        Long remove = redisTemplate.opsForList().remove("list", -1, "listValue0");
        System.out.println("remove:" + remove);

        //刪除指定key的list數(shù)據(jù)
        Boolean list = redisTemplate.delete("list");
        System.out.println("list集合刪除成功:" + list);
    }

    /**
     * 操作Set類型  無序 不可重復(fù)
     */
    @Test
    public void operateSet() {

        //設(shè)置set值
        redisTemplate.opsForSet().add("set", "setValue0");
        redisTemplate.opsForSet().add("set", "setValue0");
        redisTemplate.opsForSet().add("set", "setValue1");

        //判定是否包含
        Boolean member = redisTemplate.opsForSet().isMember("set", "setValue0");
        System.out.println("isMember:" + member);

        //刪除set中的值
        Long remove = redisTemplate.opsForSet().remove("set", "setValue0");
        System.out.println("remove = " + remove);

        //獲取set類型值
        Set<String> set = redisTemplate.opsForSet().members("set");
        set.forEach(str -> {
            System.out.println("str = " + str);
        });
    }

    /**
     * 操作 ZSet  有序 不可重復(fù)
     */
    @Test
    public void operateZSet() {
        //存儲值
        Boolean add = redisTemplate.opsForZSet().add("zset", "zsetValue0", 10);
        System.out.println("add = " + add);
        System.out.println("add = " + add);
        add = redisTemplate.opsForZSet().add("zset", "zsetValue2", 2);
        System.out.println("add = " + add);
        //獲取值
        // Boolean zset = redisTemplate.delete("zset");
        // System.out.println("delete zset = " + zset);
    }
}

/**
 * Redis 工具類
 * @author mosin
 * date 2021/11/30
 * @version 1.0
 */
@Component
public final class RedisUtil {

    private RedisUtil(){};
    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    //設(shè)置值
    public void  setValue(String key,String value){
        redisTemplate.opsForValue().set(key, value);
    }
    // 設(shè)置值 同時設(shè)置有效時間
    public void setValue(String key, String value, Long timeOut, TimeUnit timeUnit){
        redisTemplate.opsForValue().setIfAbsent(key, value, timeOut, timeUnit);
    }

    //設(shè)置值 沒有則設(shè)置 有則不設(shè)置
    public void  setNx(String key,String value){
        redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    //設(shè)置值 沒有則設(shè)置 同時設(shè)置有效時間 有則不設(shè)置
    public void  setNx(String key,String value,long timeOut,TimeUnit timeUnit){
        redisTemplate.opsForValue().setIfAbsent(key, value,timeOut,timeUnit);
    }

    //刪除值
    public boolean del(String key){
        return redisTemplate.delete(key);
    }
    
     //獲取值
    public String getValue(String key){
        return  redisTemplate.opsForValue().get(key);
    }
}

@Component
public class AdminInterceptor implements HandlerInterceptor {
    @Autowired
    private RedisUtil redisUtil;
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("攔截器以攔截請求");
        //從請求頭中獲取token  驗證用戶是否登錄
        String token = request.getHeader("token");
        System.out.println(token);
        String tokenValue = redisUtil.getValue(token);
        System.out.println("tokenValue = " + tokenValue);
        if(tokenValue!=null){ //用戶已登錄 放行請求
            return  true;
        }else{//重定向到登錄頁面
            response.sendRedirect(request.getContextPath()+"/login.jsp");
            return false;
        }
    }
}

@Configuration
public class LoginConfig implements WebMvcConfigurer {
    @Autowired
    private AdminInterceptor adminInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration registration = registry.addInterceptor(adminInterceptor);
        registration.addPathPatterns("/**");
        registration.excludePathPatterns("/user/login","/user/register","/login.jsp");
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class JsonResult<T> {
    private Integer code;
    private String msg;
    private Long count;
    private T data;
}

@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private RedisUtil redisUtil;
    @ResponseBody
    @RequestMapping("/login")
    public Object login(User user) throws JsonProcessingException {
        User usr = User.builder().id(1).name("admin").password("123456").build();
        //獲取token  放入redis
        String token = UUID.randomUUID().toString().replace("-", "");
        //將user 轉(zhuǎn)為json格式放入 redis
        ObjectMapper objectMapper = new ObjectMapper();
        String s1 = objectMapper.writeValueAsString(usr);
        //將 token 和用戶信息存入 redis
        redisUtil.setValue(token, s1, 2L, TimeUnit.MINUTES);
        //將token 存入map集合返回
        HashMap<String, String> map = new HashMap<>();
        map.put("token", token);
        return map;
    }

    @ResponseBody
    @RequestMapping("/register")
    public Object register(User user){
        HashMap<String, String> map = new HashMap<>();
        map.put("msg", "ok");
        return map;
    }

    @ResponseBody
    @RequestMapping("/add")
    public Object add(User user){
        HashMap<String, String> map = new HashMap<>();
        map.put("msg", "ok");
        return map;
    }
}