Springboot基础之RedisUtils工具类

springboot整合redis

引入redis依赖

 <!-- redis-->
<dependency>
     <groupid>org.springframework.boot</groupid>
     <artifactid>spring-boot-starter-data-redis</artifactid>
</dependency>

设置redis的template

redisconfig.java

package cn.wideth.config;

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.redisserializer;

/**
 * 编写配置类，构造redistemplate
 * 这个springboot已经帮我们配了，
 * 但是默认object，我想改成string
 */
@configuration
public class redisconfig {

    @bean
    public redistemplate<string, object> redistemplate(redisconnectionfactory factory) {

        redistemplate<string, object> template = new redistemplate<>();
        template.setconnectionfactory(factory);
        // 设置key的序列化方式
        template.setkeyserializer(redisserializer.string());
        // 设置value的序列化方式
        template.setvalueserializer(redisserializer.json());
        // 设置hash的key的序列化方式
        template.sethashkeyserializer(redisserializer.string());
        // 设置hash的value的序列化方式
        template.sethashvalueserializer(redisserializer.json());
        template.afterpropertiesset();
        return template;
    }

}

设置redis连接信息

redis操作5种常见的数据类型

redis工具类

redistemplate api

1.opsforvalue -> string

2.opsforset -> set

3.opsforhash -> hash

4.opsforzset -> sortset

5.opsforlist -> list队列

代码

package cn.wideth.util.other;


import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.redis.core.*;
import java.util.list;
import java.util.set;
import java.util.concurrent.timeunit;

public class redisutils {

    @autowired
    private redistemplate<string, object> redistemplate;

    private static double size = math.pow(2, 32);


    /**
     * 写入缓存
     * @param key
     * @param offset 位 8bit=1byte
     * @return
     */
    public boolean setbit(string key, long offset, boolean isshow) {
        boolean result = false;
        try {
            valueoperations<string, object> operations = redistemplate.opsforvalue();
            operations.setbit(key, offset, isshow);
            result = true;
        } catch (exception e) {
            e.printstacktrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param offset
     * @return
     */
    public boolean getbit(string key, long offset) {
        boolean result = false;
        try {
            valueoperations<string, object> operations = redistemplate.opsforvalue();
            result = operations.getbit(key, offset);
        } catch (exception e) {
            e.printstacktrace();
        }
        return result;
    }


    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final string key, object value) {
        boolean result = false;
        try {
            valueoperations<string, 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<string, 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);
        }
    }


    /**
     * 删除对应的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<string, 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();
        redistemplate.opsforvalue();
        return zset.rangebyscore(key, scoure, scoure1);
    }


    //第一次加载的时候将数据加载到redis中
    public void savedatatoredis(string name) {
        double index = math.abs(name.hashcode() % size);
        long indexlong = new double(index).longvalue();
        boolean availableusers = setbit("availableusers", indexlong, true);
    }

    //第一次加载的时候将数据加载到redis中
    public boolean getdatatoredis(string name) {

        double index = math.abs(name.hashcode() % size);
        long indexlong = new double(index).longvalue();
        return getbit("availableusers", indexlong);
    }

    /**
     * 有序集合获取排名
     * @param key 集合名称
     * @param value 值
     */
    public long zrank(string key, object value) {
        zsetoperations<string, object> zset = redistemplate.opsforzset();
        return zset.rank(key,value);
    }


    /**
     * 有序集合获取排名
     * @param key
     */
    public set<zsetoperations.typedtuple<object>> zrankwithscore(string key, long start,long end) {
        zsetoperations<string, object> zset = redistemplate.opsforzset();
        set<zsetoperations.typedtuple<object>> ret = zset.rangewithscores(key,start,end);
        return ret;
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     */
    public double zsetscore(string key, object value) {
        zsetoperations<string, object> zset = redistemplate.opsforzset();
        return zset.score(key,value);
    }


    /**
     * 有序集合添加分数
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementscore(string key, object value, double scoure) {
        zsetoperations<string, object> zset = redistemplate.opsforzset();
        zset.incrementscore(key, value, scoure);
    }


    /**
     * 有序集合获取排名
     * @param key
     */
    public set<zsetoperations.typedtuple<object>> reversezrankwithscore(string key, long start,long end) {
        zsetoperations<string, object> zset = redistemplate.opsforzset();
        set<zsetoperations.typedtuple<object>> ret = zset.reverserangebyscorewithscores(key,start,end);
        return ret;
    }

    /**
     * 有序集合获取排名
     * @param key
     */
    public set<zsetoperations.typedtuple<object>> reversezrankwithrank(string key, long start, long end) {
        zsetoperations<string, object> zset = redistemplate.opsforzset();
        set<zsetoperations.typedtuple<object>> ret = zset.reverserangewithscores(key, start, end);
        return ret;
    }

    
}

到此这篇关于springboot基础之redisutils工具类的文章就介绍到这了,更多相关redisutils工具类内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！