标签：spring redis System 笔记 jedis println out

1. 回顾

1. Redis持久化方式：--把内存中的数据持久化到磁盘中的过程。--防止数据丢失。
    (1)RDB:快照模式 [1]save [2]bgsave [3]配置文件自动触发
    (2)AOF:把写命令追加到日志文件中.
2. Redis集群的模式: 1.主从模式 2.哨兵模式 3.集群模式。

2. 正文

1. java连接redis
2. springboot连接redis操作。
3. 完成缓存操作
4. redis实现分布式锁

3. 连接redis--2014

默认有三种方式连接redis.

第一种:jedis---传统的项目--ssm

第二种:lettuce:---->刚出现没有多久就被springboot整合进来。

第三种:springboot连接redis

3.1 jedis操作redis服务器

（1）引入jedis依赖

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

（2）编写相关的代码

      @Test
    public void test01(){
        //Jedis(String host, int port)
        Jedis jedis = new Jedis("192.168.233.129" ,6379 );
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
        //对string数据类型操作
        String set = jedis.set("name","gyn");
        System.out.println(set);

        String name = jedis.get("name");
        System.out.println(name);

        Boolean name1 = jedis.exists("name");
        System.out.println(name1);

        Long k1 = jedis.setnx("k1", "1");
        System.out.println(k1);
        //对hash数据类型操作
        Map<String, String> map = new HashMap<String, String>();
        map.put("name","gyn");
        map.put("age","16");
        map.put("sex","nv");

        Long people = jedis.hset("people", map);
        System.out.println(people);
        Set<String> keys1 = jedis.keys("*");
        System.out.println(keys1);

        Map<String, String> people1 = jedis.hgetAll("people");
        System.out.println(people1);
        //list队列
        Long lpush = jedis.lpush("k6", "gyn", "lht", "zyx", "xwh");
        List<String> k6 = jedis.lrange("k6", 0, -1);
        System.out.println(k6);

        jedis.close();


    }

每次使用jedis对象时都需要自己创建，当使用完后，需要关闭该对象。===>jedis中也存在连接池.

3.2 jedis连接池的使用

@Test
    public void test02(){
        //连接池的配置信息
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(10);//最多的连接个数
        config.setMaxIdle(10);//最多空闲的链接个数
        config.setMinIdle(2);//最小的空闲个数
        config.setTestOnBorrow(true);//在过去连接对象时是否验证该链接对象的连通性
        //创建连接池对象
        JedisPool jedisPool = new JedisPool("192.168.233.129",6379);

        Jedis jedis = jedisPool.getResource();

        //清空当前库
        jedis.flushDB();
        String set = jedis.set("name", "gyn");
        String gyn = jedis.get("name");
        System.out.println(gyn);
        //归还连接池
        jedis.close();
    }

6分

3.3 测试jedis使用和不使用连接池的效率

  @Test
    public void test03(){
        //连接池的配置信息
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(100);//最多的连接个数
        config.setMaxIdle(10); //最多空闲的连接个数
        config.setMinIdle(2); //最小的空闲个数
        config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool=new JedisPool(config,"192.168.233.129",6379);
        long start = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            Jedis jedis = jedisPool.getResource();
            String ping = jedis.ping();
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));

    }
   @Test
    public void test04(){
        long start = System.currentTimeMillis();
        //Jedis(String host, int port)
        for(int i=0;i<10000;i++){
            Jedis jedis=new Jedis("192.168.233.129",6379);
            String ping = jedis.ping();
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));

    }

3.4 springboot整合redis

springboot在整合redis时提高两个模板类,StringRedisTemplate和RedisTemplate.以后对redis的操作都在该模板类中。StringRedisTemplate是RedisTemplate的子类。

<!--redis相关的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

修改配置文件

#redis相关配置
spring.redis.host=192.168.233.129
spring.redis.port=6379
#最多获取数
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.pool.max-wait=3000
spring.redis.lettuce.pool.max-active=10

测试:

@SpringBootTest
class SpringbootRedis424ApplicationTests {
    
    //因为springboot整合redis时会把StringRedisTemplate创建并交于spring容器管理
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Test
    void contextLoads() {


        /**
         * 关于key的操作
         */
        System.out.println("----------关于key的操作---------");
        Set<String> keys = redisTemplate.keys("*");//获取所有的key
        System.out.println("keys========"+keys);
        Boolean hasKey = redisTemplate.hasKey("k1");//判断是否存在指定的key
        System.out.println("判断是否存在指定的key:"+hasKey);
        Boolean k1 = redisTemplate.delete("k1");//删除指定的key
        System.out.println("是否删除指定key成功:"+k1);

        /**
         * String 字符串类型
         */
        System.out.println("----------String 字符串类型---------");
        //操作字符串===StringRedisTemplate会把对每一种数据的操作单独封装成一个类。
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();//ValueOperations专门操作字符串
        // get 设置指定 key 的值
        forValue.set("k1","gyn");
        // set 获取指定 key 的值。
        String k11 = forValue.get("k1");
        System.out.println("k1===="+k11);
        //如果没有就添加 setnx = setIfAbsent
        Boolean aBoolean = forValue.setIfAbsent("k2", "lht");
        System.out.println("是否存入成功:"+aBoolean);
        //incr = increment 将 key 中储存的数字值增一。
        Long k3 = forValue.increment("k3",20);
        System.out.println("k3======"+k3);
        // decr = decrement  将key 中储存的数字值减少 可以指定减少的数量
        Long k31 = forValue.decrement("k3", 5);
        System.out.println("k31======"+k31);
        //mset = multiSet 同时设置一个或多个 key-value 对。
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("s1","v1");
        hashMap.put("s2","v2");
        hashMap.put("s3","v3");
        forValue.multiSet(hashMap);
        System.out.println(hashMap);
        // mget = multiGet 获取所有(一个或多个)给定 key 的值。
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("s1");
        arrayList.add("s2");
        arrayList.add("s3");
        System.out.println( forValue.multiGet(arrayList));


        /**
         * Hash类型
         */
        System.out.println("----------Hash类型---------");

        HashOperations<String, Object, Object> forHash = redisTemplate.opsForHash();
        //hset = put 将哈希表 key 中的字段 field 的值设为 value
        forHash.put("h1","name","gyn");
        forHash.put("h1","age","18");
        forHash.put("h1","sex","nv");

        HashMap<Object, Object> hashMap1 = new HashMap<>();
        hashMap.put("name","lht");
        hashMap.put("age","18");
        hashMap.put("sex","nan");
        forHash.putAll("h2",hashMap1);
        System.out.println(hashMap1);

        //hget = get 获取存储在哈希表中指定字段的值
        Object o = forHash.get("h2", "name");
        System.out.println(o);
        //hgetall = multiGet 获取在哈希表中指定 key 的所有字段和值
        ArrayList<Object> arrayList1 = new ArrayList<>();
        arrayList.add("name");
        arrayList.add("age");
        arrayList.add("sex");
        System.out.println(forHash.multiGet("h2",arrayList1));
        //hkeys = keys 获取所有哈希表中的字段
        Set<Object> h2 = forHash.keys("h2");
        System.out.println(h2);
        //hvals = values 获取哈希表中所有值
        List<Object> h21 = forHash.values("h2");
        System.out.println(h21);



        /**
         * list队列
         */
        System.out.println("----------list队列---------");
        //LPush = leftPush 将一个值插入到列表头部
        ListOperations<String, String> forList = redisTemplate.opsForList();
        Long aLong = forList.leftPush("k6", "lht","gyn");
        System.out.println(aLong);
        // LPush = leftPushAll 将多个值插入到列表头部
        Long aLong1 = forList.leftPushAll("l1", "lht", "gyn", "zyx", "xwh", "aa");
        System.out.println(aLong1);
        //leftPop=lpop 移除并获取左边第一个
        String k6 = forList.leftPop("k6");
        System.out.println(k6);
        //range=lrange 获取列表指定范围内的数据
        List<String> k7 = forList.range("k6", 0, -1);
        System.out.println(k7);


        /**
         * set集合类型
         */
        System.out.println("----------set集合类型---------");

        //add=sadd 向集合添加一个或多个元素
        SetOperations<String, String> forSet = redisTemplate.opsForSet();
        Long add = forSet.add("k8", "lht", "gyn", "zyx", "xwh", "aa", "bb");
        System.out.println(add);
        Long k9 = forSet.add("k9", "lht", "gyn");
        System.out.println(k9);
        //diff = difference 返回给定集合的所有差集
        Set<String> difference = forSet.difference("k8", "k9");
        System.out.println("差集:" + difference);
        //sinter = intersect 返回给定所有集合的交集
        Set<String> intersect = forSet.intersect("k8", "k9");
        System.out.println("交集:" + intersect);
        //smembers = members 返回集合中的所有成员
        Set<String> k91 = forSet.members("k9");
        System.out.println("所有成员:" + k91);
        Set<String> k8 = forSet.members("k8");
        System.out.println("所有成员:" + k8);
        //srandmamber = randomMembers 随机获取多个元素
        List<String> k92 = forSet.randomMembers("k9", 3);
        System.out.println("随机获取多个元素:"+ k92);
        // srandmamber = randomMember 随机获取一个元素
        String k81 = forSet.randomMember("k8");
        System.out.println("随机获取一个元素:" + k81);

        /**
         * sort set有序集合
         */
        System.out.println("----------sort set有序集合---------");

        ZSetOperations<String, String> forZSet = redisTemplate.opsForZSet();
        //zadd =add 向有序集合添加一个或多个成员，或者更新已存在成员的分数
        Boolean add1 = forZSet.add("z1", "english", 66);
        System.out.println(add1);
        Boolean add2 = forZSet.add("z1", "chinese", 150);
        System.out.println(add2);
        Boolean add3 = forZSet.add("z1", "math", 100);
        System.out.println(add3);


        //zrange = range 通过索引区间返回有序集合成指定区间内的成员
        Set<String> z1 = forZSet.range("z1", 0, -1);
        System.out.println(z1);



        }
    }

3.4.2 RedisTemplate

它是StringRedisTemplate的父类，它类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。jdk序列化方式阅读能力差，而且占用空间大. 我们在使用是一般需要人为指定序列化方式。


@SpringBootTest
class SpringbootRedis424ApplicationTests2 {
    @Autowired
    private RedisTemplate redisTemplate;

    //org.springframework.core.serializer.support.SerializationFailedException
    //因为user对象在jvm内存中，---放入redis服务器---持久化到磁盘上。---要该对象的类必须序列化
    //key和value都是乱码---因为它默认采用的序列化方式jdk的序列化方式。但是阅读不方便。我们一般不是jdk的序列化方式
    @Test
    void contextLoads() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("usr",new Usr(1,"gyn","汤臣一品"));
        Object usr = valueOperations.get("usr");
        System.out.println(usr);

    }

}

如果每次使用都人为指定序列化方式，统一设置redisTemplate的序列化

package com.lht;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author 卢海腾
 * @date 2023/4/24 16:25
 */
@Configuration
public class RedisConfig {
    //比如验证码
    @Bean //该方法的返回对象交于spring容器管理
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        //field序列化 key field value
        template.setHashKeySerializer(redisSerializer);
        return template;
    }
}

上面的连接都是连接的单机版的redis,真实项目它们的redis都是集群模式.

3.5 springboot连接集群

spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

# 设置redis重定向的次数---根据主节点的个数
spring.redis.cluster.max-redirects=3
spring.redis.cluster.nodes=192.168.233.129:7001,192.168.233.129:7002,192.168.233.129:7003,192.168.233.129:7004,192.168.233.129:7005,192.168.233.129:7006

4. redis的应用场景

4.1 redis可以作为缓存

(1) 缓存的原理

(2)缓存的作用:

减少访问数据库的频率。--提高系统的性能。

(3)什么样的数据适合放入缓存

查询频率高的

修改频率低的

数据安全性要求低的。

(4)如何使用缓存

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ykq</groupId>
    <artifactId>qy163-springboot-redis02</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>qy163-springboot-redis02</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

(3)配置文件

server.port=8888

spring.datasource.url=jdbc:mysql:///homework
spring.datasource.password=root
spring.datasource.username=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#redis的配置信息
spring.redis.host=192.168.233.129
spring.redis.port=6379
#最多获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

(3)servie

package com.lht.service.impl;
import com.lht.mapper.StudentMapper;
import com.lht.pojo.Student;
import com.lht.service.StudentService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @author 卢海腾
 * @date 2023/4/25 9:35
 */
@Service
public class StudentServiceImpl implements StudentService {
    @Resource
    private StudentMapper studentMapper;
    @Resource
    private RedisTemplate<String,Object> redisTemplate;


    @Override
    public Student findById(Integer id) {
        ValueOperations<String, Object> forValue = redisTemplate.opsForValue();
        //1.查询缓存
        Object o = forValue.get("student::" + id);
        if(o!=null){ //缓存命中
            return (Student) o;
        }
        Student student = studentMapper.selectById(id);
        //2.查询到应该放入缓存
        if(student!=null){
            forValue.set("student::"+id,student);
        }

        return student;
    }
}

使用springboot连接redis并且把我们原来讲的每个数据类型对应的命令找到对应的方法。

springboot连接redis集群

redis作为缓存使用

标签：spring,redis,System,笔记,jedis,println,out
From： https://www.cnblogs.com/gl0806/p/17350526.html

笔记