spring boot简单的连接redis

勤奋上进的兔子

已于 2023-05-07 18:24:11 修改

阅读量2.5k

点赞数 1

分类专栏： Redis 文章标签： redis spring boot java

于 2022-12-06 16:32:41 首次发布

本文链接：https://blog.csdn.net/qq_55648724/article/details/128205051

版权

Redis 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

注意

测试效果的时候自动注入可能会报红这时候

把@Autowired替换为@Resource

@Autowired和@Resource的区别

共同点
@Resource和@Autowired都是做bean的注入时使用的。

不同点

Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在

Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入

文章目录

前言

java连接redis的两种方式

1.直接连接
Jedis jedis = new Jedis("192.168.223.211",6379)；
如有密码：jedis.auth("123456");
然后就可以对Redis进行操作了

2.连接池连接(连接池切记：关闭资源)
//Jedis相关配置信息
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(500);
config.setMaxIdle(5);
config.setMaxWaitMillis(1000 * 100);
config.setTestOnBorrow(true);
//redis连接池连接成功
JedisPool pool = new JedisPool(config, "192.168.223.211", 6379,超时时间,"123456");
//获取连接池中的一个连接
Jedis jedis = pool.getResource();
然后就可以对Redis进行操作了

一、redis设置密码后如何启动

使用

redis-cli -p 6379 -a 123456

启动

二、环境准备与测试

先把redis服务启动

创建工程,引入依赖

  <!--redis连接jar包-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.6.0</version>
        </dependency>

        <!--spring boot整合redis的主启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置application.yml

spring:
  redis:
    #数据库索引，默认为0
    database: 0
    #redis host ip
    host: 192.168.91.129
    #redis  连接端口
    port: 6379
    #服务器连接密码（默认为空）
    password: 123456
    #连接超时时间（毫秒）
    timeout: 1000
    jedis:
      #连接池配置
      pool:
        #连接池最大连接数
        max-active: 8
        #连接池最大阻塞等待时间（负值表示没有限制）
        max-wait: 5000
        #连接池最大空闲连接
        max-idle: 8
        #连接池最小空闲连接
        min-idl: 0

配置完成

测试使用


import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class SpringbootRedisApplicationTests {

    //该类中封装了很多api方法--redis服务
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    //该类型其实是StringRedisTemplate的父类，
    @Resource
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
    }

    @Test
    public void test01() {
        //连接方式通过jar包直接连接
        //配置连接服务
        Jedis jedis = new Jedis("192.168.91.129", 6379);
        //输入设置的数据库密码
        jedis.auth("123456");

        //获取所有的key
        Set<String> keys = jedis.keys("*");
        keys.forEach(System.out::println);

        jedis.set("k1", "1");
        jedis.set("k2", "2");
        jedis.set("k3", "3");
        jedis.set("k4", "4");
        jedis.set("k5", "5");

        //删除指定的key
        Long c = jedis.del("k1", "k2", "k5");
        System.out.println("删除key的个数:" + c);

        //判断指定的key是否存在
        Boolean exists = jedis.exists("k2");
        System.out.println("判断key是否存在:" + exists);

        //关闭资源
        jedis.close();
    }

    @Test
    public void test02() {
        //连接方式通过jar包直接连接
        //配置连接服务
        Jedis jedis = new Jedis("192.168.91.129", 6379);
        //输入设置的数据库密码
        jedis.auth("123456");
        //存放字符串数据
        jedis.set("k1", "1");
        jedis.set("k2", "v2");

        //获取指定key的内容
        String value1 = jedis.get("k1");
        System.out.println("k1对应的内容:" + value1);

        //如果指定的key存在则不存入，不存在则存入redis
        Long aLong = jedis.setnx("k8", "ldh");
        System.out.println("是否存入:" + aLong);

        //存入时设置过期时间
        String str = jedis.setex("k5", 30l, "v5");
        System.out.println("存入的内容:" + str);

        //用于点赞和收藏
        Long incr = jedis.incr("k1");
        System.out.println("递增后的结果:" + incr);

        //关闭资源
        jedis.close();
    }

    @Test
    public void test03() {
        //对应hash类型的操作----可以存放对象。
        //连接方式通过jar包直接连接
        //配置连接服务
        Jedis jedis = new Jedis("192.168.91.129", 6379);
        //输入设置的数据库密码
        jedis.auth("123456");


        String name = jedis.hget("myhash", "name");
        System.out.println("获取hash中name对应的值:" + name);


        Map<String, String> map1 = jedis.hgetAll("myhash");
        System.out.println("获取指定key对应的内容:" + map1);

        Set<String> k11 = jedis.hkeys("myhash");
        System.out.println("获取myhash对应的所有field:" + k11);

        List<String> values = jedis.hvals("myhash");
        System.out.println("获取myhash对应的所有field的值:" + values);

        //关闭资源
        jedis.close();
    }

    @Test
    public void test04() {
        //为了减少频繁的创建和销毁jedis对象，提高了jedis的连接池，以提高连接效率。JedisPool

        //创建连接池的配置类
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMinIdle(5); //设置空闲的个数
        config.setMaxIdle(10);
        config.setMaxTotal(2000); //设置最多的数量
        config.setMaxWaitMillis(6000);//设置最大的等待时长
        config.setTestOnBorrow(true); //是否检验池子中的jedis对象可用
        //创建jedis连接池对象.格式 配置类 ip地址 端口号 超时时间 密码
        JedisPool jedisPool = new JedisPool(config, "192.168.91.129", 6379, 1000, "123456");

        //通过池子获取其中的一个连接 然后其他的操作和上面的一样
        Jedis jedis = jedisPool.getResource();

        Map<String, String> map1 = jedis.hgetAll("myhash");
        System.out.println("获取指定key对应的内容:" + map1);


    }

    //测试StringRedisTemplate
    @Test
    public void test06(){
    /*    //删除指定的key
        Boolean aBoolean = stringRedisTemplate.delete("k1");
        System.out.println("是否删除成功:"+aBoolean);

        //判断指定的key是否存在
        Boolean hasKey = stringRedisTemplate.hasKey("k1");
        System.out.println("判断指定的key是否存在:"+hasKey);
*/
        //获取对string类型操作的类对象
        ValueOperations<String, String> forValue = stringRedisTemplate.opsForValue();
        forValue.set("n1","测试数据1");
        forValue.set("n2","2");
        forValue.set("n3","测试数据3");

        //如果存在 则不存入 不存在则存入
        Boolean aBoolean = forValue.setIfAbsent("n4", "测试数据4", 25, TimeUnit.SECONDS);
        System.out.println("是否存入成功 " + aBoolean);


        //获取对应的值
        String n1 = forValue.get("n1");
        System.out.println("n1 = " + n1);

        //递增
        Long n2 = forValue.increment("n2");
        System.out.println("n2递增后的值" + n2);

    }



    @Test
    public void test07(){
        //对于hash类型的操作
        HashOperations<String, Object, Object> forHash = stringRedisTemplate.opsForHash();


        //加入数据
        forHash.put("h1","name","刘德华");
        forHash.put("h1","age","18");
        forHash.put("h1","address","山东");

        HashMap<String,String> map = new HashMap<>();
        map.put("name","老六");
        map.put("age","19");
        map.put("adress","南京");
        forHash.putAll("h2",map);


        Object o = forHash.get("h1", "name");
        System.out.println("获取指定key对于的name的值:"+o);

        Map<Object, Object> h2 = forHash.entries("h2");
        System.out.println("获取h2对于的map对象:"+h2);

        Set<Object> keys = forHash.keys("h2");
        System.out.println("获取h2对于的所以field："+keys);

        List<Object> values = forHash.values("h2");
        System.out.println("获取h2对于的所有filed的值:"+values);

    }


    // 而RedisTemplate的key和value可以自己指定数据类型，所有它的key和value可以是任意类型。
    @Test
    public void test08(){
        //默认RedisTemplate它的key和value的序列化都是使用的JdkSerializationRedisSerializer方式，
        // 该序列化要求类必须实现Serializable接口。
        //我们在实际开发中，我们的key都是String类型，我们应该指定String序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("student1",new Student(1,"张三","男"));
        System.out.println(valueOperations.get("student1"));
    }



}