Springboot整合redis+jedis

最新推荐文章于 2024-08-18 10:26:06 发布

小猪呀

最新推荐文章于 2024-08-18 10:26:06 发布

阅读量1k

点赞数 1

分类专栏：微服务 redis 文章标签： java

本文链接：https://blog.csdn.net/qq_41085151/article/details/106904937

版权

微服务同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

redis

4 篇文章 0 订阅

订阅专栏

Spring Boot整合Redis+Jedis

1）在pom.xml添加Redis依赖Jedis依赖和，示例代码如下

      <!--  <version>2.1.5.RELEASE</version>Springboot版本 -->
      
       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

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

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

       <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

2）配置文件application.properties。

server.port=8088

spring.redis.database=0
spring.redis.host=192.168.221.150
spring.redis.port=6379
spring.redis.password=
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-wait=-1000
spring.redis.jedis.pool.max-idle=500
spring.redis.jedis.pool.min-idle=0
spring.redis.timeout=100000

3) Liunx启动redis

1.进入bin目录启动命令
./redis-server &

2.关闭redis的保护模式,先连接redis
./redis-cli -h 127.0.0.1 -p 6379

3.连接成功设置关闭redis保护模式
config set protected-mode "no"

4) 配置Config类

@Configuration
public class RedisConfig {

        //读取配置文件中的redis的ip地址
        @Value("${spring.redis.host}")
        private String host;

        @Value("${spring.redis.port:0}")
        private int port;

        @Value("${spring.redis.database:0}")
        private int database;

        @Bean
        public RedisUtil getRedisUtil(){
            if(host.equals("disabled")){
                return null;
            }
            RedisUtil redisUtil=new RedisUtil();
            redisUtil.initPool(host,port,database);
            return redisUtil;
        }
}

5) 编写jedis工具类

public class RedisUtil {
    private JedisPool jedisPool;

    public void initPool(String host,int port ,int database){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(30);
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setMaxWaitMillis(10*1000);
        poolConfig.setTestOnBorrow(true);
        jedisPool=new JedisPool(poolConfig,host,port,20*1000);
    }

    public Jedis getJedis(){
        Jedis jedis = jedisPool.getResource();
        return jedis;
    }
}

6) 测试添加缓存数据

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {

    @Autowired
    RedisUtil redisUtil;

    @Test
    public void TestRedis() {
        Jedis jedis = redisUtil.getJedis();
        String test = jedis.set("test", "123");
        System.out.println(test);
        String s = jedis.get("test");
        System.out.println(s);
    }

}

7）jedis操作Api

 @Test
    public void test16() {
        //jedis操作Hash
        Jedis jedis = redisUtil.getJedis();
        Long hset = jedis.hset("bb", "String", "12456");//设置key在String域中有了返回0，域中没有相同的返回1
        Long hset2 = jedis.hset("ss", "String2", "12456");
        Long hset3 = jedis.hset("ss", "String", "123");
        System.out.println(hset2);
        System.out.println(hset);
        String hget = jedis.hget("ss", "String");//根据key到那个域中取值
        System.out.println(hget);
        Boolean aBoolean = jedis.hexists("sss", "String");//判断key是否在那个域中。
        System.out.println(aBoolean);
        Map<String, String> map = jedis.hgetAll("ss");//从所有域中获取为key的值。
        System.out.println(map);
        Long hdel = jedis.hdel("ss", "String");//从哪个些域（多个域中删除）中删除为key的,删除多少条数据返回的数就是多少。
        System.out.println(hdel);
    }

    @Test
    public void test17() {
        //jedis操作String
        Jedis jedis = redisUtil.getJedis();

        jedis.set("name", "king james");//添加一条数据

        jedis.get("name");//根据key找到对应的value的值

        jedis.set("name", "kobe bryant");//再次设置:对一个key多次赋值的话，key对应的值是最后一次赋值的值，之前的被覆盖。

        jedis.append("name", "  is my love");//字符串拼接

        jedis.del("name");//删除某个键

        jedis.mset("name", "king james", "age", "33", "country", "American");//同时设置多个键值对:获取值的方式同上

        jedis.incr("age");//假如值里面有数字(字符串形式)，可以进行+1的操作    age的值变成34

        jedis.decr("age");//进行-1的操作

        jedis.incrBy("age", 20);//某个值增加多少：这里是+20

        jedis.decrBy("age", 20);//某个值减少多少：这里是-20

        jedis.exists("name");//判断是否存在某个key

        jedis.setex("name", 5, "king james");//设置值的时间:存在5s
        //查询值的存活时间:当 key不存在时,返回 -2,当key存在但没有设置剩余生存时间时,返回-1,否则,以秒为单位,返回key的剩余生存时间。
        Long ttl = jedis.ttl("name");

        jedis.persist("name");//去掉key的时间设置：不再有失效时间

        //设置该值不能重复设置（nx），该值的过期时间5分钟，设置成功返回大小OK，重复设置返回null
        String rest = jedis.set("userid2", "1", "nx", "px", 60 * 5 * 1000);

        System.out.println(rest);
    }

    @Test
    public void test18() {
        //jedis操作List集合
        Jedis jedis = redisUtil.getJedis();

        jedis.lpush("users", "king james");//保存数据:lpush-->left push
        jedis.lpush("users", "kobe bryant");
        jedis.lpush("users", "stephen curry");
        jedis.lpush("users", "Kevin Durant");
        //查询：第一个值是key，第二个值表示从0开始，第三个值表示结束(-1表示取全部)
        //userListA当中的值排列情况：["Kevin Durant","stephen curry","kobe bryant","king james"]
        List<String> userListA = jedis.lrange("users", 0, -1);

        jedis.rpush("users", "Wilt Chamberlain");//保存数据:rpush-->right push
        jedis.rpush("users", "John Smith");
        jedis.rpush("users", "Karl Malone");
        //查询：第一个值是key，第二个值表示从0开始，第三个值表示结束(-1表示取全部)
        //userListB当中值排列情况：["Kevin Durant","stephen curry","kobe bryant","king james","Wilt Chamberlain","John Smith","Karl Malone"]
        List<String> userListB = jedis.lrange("users", 0, -1);
        //移除并返回列表key的头元素：lpop-->left pop
        String nameA = jedis.lpop("users");//Kevin Durant
        //移除并返回列表key的尾元素：rpop-->right pop
        String nameB = jedis.rpop("users");//Karl Malone
        //删除key
        jedis.del("users");
        //给特定位置赋值
        jedis.lset("users", 1, "Yao Ming");
        //查询特定位置的值：idnex从0开始
        jedis.lindex("users", 1);
        //对list进行裁剪：只保留下标1-3的值，其他的全部删除，下标从0开始
        jedis.ltrim("users", 1, 3);
        //返回list的长度
        jedis.llen("users");
        //根据参数count的值,移除列表中与参数value相等的元素。
        //count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
        //count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
        //count = 0 : 移除表中所有与 value 相等的值。
        jedis.lrem("users", 2, "king james");
        /**
         * ("key","LIST_POSITION","pivot","value")
         * LINSERT key BEFORE|AFTER pivot value
         * 将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
         * 当 pivot 不存在于列表 key 时，不执行任何操作。
         * 当 key 不存在时， key 被视为空列表，不执行任何操作。
         * 如果 key 不是列表类型，返回一个错误。
         */
        jedis.linsert("users", BinaryClient.LIST_POSITION.AFTER, "Yao Ming", "AAAA");
        //从users的右边弹出一个元素，把该元素左插入到players列表当中
        jedis.rpoplpush("users", "players");

    }

    @Test
    public void test19() {
        //jedis操作set集合
        Jedis jedis = redisUtil.getJedis();
        //操作Set集合:和列表不同，集合中的元素是无序的，因此元素也不能重复。
        jedis.sadd("users", "king james");
        jedis.sadd("users", "kobe bryant");
        jedis.sadd("users", "stephen curry");
        jedis.sadd("users", "Kevin Durant");
        Set<String> users = jedis.smembers("users");//查询users里面的所有数据

        jedis.srem("users", "Kevin Durant");//移除users当中的某个元素

        Long size = jedis.scard("users");//获取users当中的元素个数

        jedis.spop("users");//随机移除users当中的一个元素

        jedis.srandmember("users");//返回users里面的一个随机元素

        /**
         * 从users当中返回一个长度为3的随机数组。
         * 当数字大于0时，list里面元素都不相同，小于0时，元素可能相同，长度为count的绝对值
         */
        List<String> list = jedis.srandmember("users", 3);
        Boolean isMember = jedis.sismember("users", "king james");//判断users里面是否含有某个元素

        jedis.sadd("players", "Yao Ming", "Wilt Chamberlain", "Karl Malone");//批量插入数据

        Set<String> sinter = jedis.sinter("users", "players");//交集

        Set<String> sdiff = jedis.sdiff("users", "players");//差集

        Set<String> sunion = jedis.sunion("users", "players");//并集

        jedis.smove("users", "players", "king james");//把users当中的king james 移动到players当中

    }

    @Test
    public void test20() {
        //jedis操作Zset集合
        Jedis jedis = redisUtil.getJedis();

        //操作有序Set
        jedis.zadd("users", 10, "king james");//新增：根据“第二个参数（score）”进行排序。

        jedis.zadd("users", 20, "king james");//元素相同时，更新为当前的排序数

        Set<String> usersA = jedis.zrange("users", 0, -1);//查询users里面的所有元素

        jedis.zcard("users");//查询当前set集合的元素个数

        jedis.zcount("users", 10, 20);//返回users集合里面，score 值在min和max之间（包括）元素个数

        jedis.zrem("users", "king james");//移除users中的一个或多个成员，不存在的成员将被忽略。

        //移除users当中第0到第1之间的元素（包含），也可以是负数：以 -1 表示最后一个成员， -2 表示倒数第二个成员
        jedis.zremrangeByRank("users", 0, 3);
        jedis.zremrangeByScore("users", 10, 20);//移除users当中score值在min和max之间（包括）元素

        jedis.zscore("users", "king james");//返回某个元素的score值

        jedis.zrangeByScore("users", 10, 20);//返回有序集users中，所有score值介于min和max之间(包括)的元素

        long rank = jedis.zrank("users", "king james");//返回元素king james在users当中的序号，排第一位0

    }

    @Test
    public void test21() {
        //jedis操作HashMap集合
        Jedis jedis = redisUtil.getJedis();
        //操作HashMap
        Map<String, String> map = Maps.newHashMap();
        map.put("Cleveland Cavaliers", "King James");
        map.put("Los Angeles", "Kobe Bryant");
        map.put("Memphis Grizzlies", "Mike Conley");
        map.put("Miami Heat", "Goran Dragic");
        map.put("Golden State Warriors", "Stephen Curry");

        jedis.hmset("NBA", map);//设置值

        //根据map当中的key，去查询key对应的value
        List<String> MVP = jedis.hmget("NBA", "Los Angeles", "Cleveland Cavaliers");
        jedis.hdel("NBA", "Miami Heat");//删除某个key对应的value

        jedis.hlen("NBA");//返回NBA当中map的键值对的数量

        jedis.exists("NBA");//是否存在NBA这个key

        Set<String> teams = jedis.hkeys("NBA");//返回NBA当中map的所有的key

        List<String> players = jedis.hvals("NBA");//返回NBA当中所有的key对应value的值

        Map<String, String> map1 = jedis.hgetAll("NBA");//返回NBA当中对应的map的值

    }

    @Test
    public void test22() {
        //jedis操作其他
        Jedis jedis = redisUtil.getJedis();
        //通用操作
        jedis.del("NBA");//删除

        jedis.exists("NBA");//存在检测

        jedis.expire("NBA", 600);//设置key的过期时间，单位为秒

        jedis.expireAt("NBA", System.currentTimeMillis() + 30 * 1000);//设置key在那个时间点过期

        Set<String> keys = jedis.keys("*");//获取redis当中的所有的key值

        jedis.move("NBA", 1);//当前数据库的key移动到给定的数据库db当中。

        jedis.persist("NBA");//移除给定key的生存时间

        jedis.pttl("NBA");//以毫秒为单位返回 key 的剩余生存时间

        jedis.ttl("NBA");//以秒为单位返回 key 的剩余生存时间

        jedis.randomKey();//从当前数据库中随机返回(不删除)一个 key

        jedis.rename("NBA", "CBA");//将 key 改名为 newkey

        jedis.renamenx("NBA", "CBA");//当且仅当 newkey 不存在时，将 key 改名为 newkey

        jedis.type("NBA");//返回 key 所储存的值的类型

    }

个人推荐使用Jedis来操作Redis，因为jedis性能比redisTemplate性能更好读写更快。