文章目录

1.Jedis

1.介绍

image-20240429154127142

2.环境配置
1.创建maven项目

image-20240429154831864

2.pom.xml引入依赖
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.2.0</version>
    </dependency>
3.新建一个包并创建一个文件

image-20240429155409891

3.Jedis远程连接到Redis
1.Redis放到服务器可以连接的前提条件
  • 确认端口开启
  • protected-mode（设置no支持远程访问）
  • 注销bind = 127.0.0.1
  • 最好设置一个密码在requirepass
2.为Redis设置密码
1.编辑配置文件
vim /etc/redis.conf
2.找到 requirepass

image-20240429160256016

3.设置密码为root

image-20240429160319448

4.重启Redis，在shutdown的时候报错，原因是之前连接到了redis的客户端没有关闭，执行下面的指令关闭
redis-cli shutdown nosave
5.然后再重启Redis，此时再次操作Redis就需要密码了

image-20240429163024650

3.编写代码连接Redis
package com.sun.jedis;

import org.junit.Test;
import redis.clients.jedis.Jedis;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 15:53
 * @Version 1.0
 */
public class Jedis_ {

    // 连接redis
    @Test
    public void con() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxx", xxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");
        String ping = jedis.ping();
        System.out.println("ping = " + ping);
        // 关闭命令行连接
        jedis.close();
    }
}

image-20240429163739569

4.key操作
1.代码
    @Test
    public void key() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 设置key
        jedis.set("k1", "v1");
        jedis.set("k2", "v2");
        jedis.set("k3", "v3");

        // 获取所有的key
        Set<String> keys = jedis.keys("*");
        // 遍历输出
        for (String key : keys) {
            System.out.println("key=" + key);
        }

        // 判断key是否存在
        Boolean k1 = jedis.exists("k1");
        System.out.println("k1是否存在？" + k1);

        // 查看key的ttl
        System.out.println("k2的ttl=" + jedis.ttl("k2"));

        // 获取值
        String k3 = jedis.get("k3");
        System.out.println("k3=" + k3);
        jedis.close();

    }
2.结果

image-20240429165247069

5.string操作
1.代码
    @Test
    public void string() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 先清除一下库
        jedis.flushDB();

        // 批量设置string
        jedis.mset("k1", "v1", "k2", "v2", "k3", "v3");

        // 批量获取string
        List<String> mget = jedis.mget("k1", "k2", "k3");
        for (String s : mget) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429165825709

6.list操作
1.代码
    @Test
    public void list() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 先清除一下库
        jedis.flushDB();

        // 向list的左边添加三条记录
        jedis.lpush("key", "v1", "v2", "v3");
        // 显示数据，应该是v3,v2,v1
        List<String> key = jedis.lrange("key", 0, -1);
        for (String s : key) {
            System.out.println(s);
        }
        jedis.close();
    }
}
2.结果

image-20240429170559212

7.set操作
1.代码
    @Test
    public void set() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 先清除一下库
        jedis.flushDB();

        // 向set中添加元素
        jedis.sadd("key", "val1", "val2", "val3");

        // 取出set中的所有值
        Set<String> key = jedis.smembers("key");
        // 遍历输出
        for (String s : key) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429170951539

8.hash操作
1.代码
    @Test
    public void hash() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("xxxxxxx");

        // 先清除一下库
        jedis.flushDB();

        // 向hash中设置值
        Map<String, String> map = new HashMap<String, String>();
        map.put("field1", "value1");
        map.put("field2", "value2");
        map.put("field3", "value3");

        jedis.hset("key", map);

        List<String> hmget = jedis.hmget("key", "field1", "field2", "field3");
        for (String s : hmget) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429205900768

9.zset操作
1.代码
    @Test
    public void zset() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("xxxx");

        // 先清除一下库
        jedis.flushDB();

        // 向zset中添加数据
        jedis.zadd("key", 1, "zhangsan");
        jedis.zadd("key", 2, "lisi");
        jedis.zadd("key", 3, "wangwu");
        // 取出数据
        Set<String> key = jedis.zrange("key", 0, -1);
        for (String s : key) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429210607348

2.由于Redis被攻击了，所以重新配置

1.修改端口为7489

image-20240429200416739

2.设置redis密码

image-20240429195814069

3.使redis支持远程访问

image-20240429200002355

image-20240429200046964

4.重启redis
1.指定配置文件启动redis
/usr/local/bin/redis-server /etc/redis.conf
2.查看是否启动
ps -aux | grep redis

image-20240429200524755

3.指定端口连接redis
/usr/local/bin/redis-cli -p 7489

image-20240429200655032

4.测试密码

image-20240429200728881

5.如果要关闭redis，在命令行关闭redis，输入shutdown
5.开放7489端口
1.宝塔开启端口
systemctl start firewalld && firewall-cmd --permanent --add-port=7489/tcp && firewall-cmd --reload && firewall-cmd --query-port=7489/tcp

image-20240429201337740

2.腾讯云开启端口

image-20240429201549924

3.为了安全只允许本机ip访问

image-20240429205215949

2.SpringBoot2整合Redis

1.环境配置
1.创建maven项目

image-20240429211111679

2.pom.xml引入依赖
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <properties>
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <!-- 说 明 : 如 果 这 里 是 spring-boot-start 就 改 成 如 下
            spring-boot-start-web-->
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- spring2.X 集成 redis 所需 common-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <!--不要带版本号,防止冲突-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.2.2</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
3.application.yml 配置redis
spring:
  redis:
    host: xxxxxx # Redis服务器地址
    port: xxxx# Redis服务器端口
    password: ****** # Redis服务器密码
    database: 0 # 默认数据库为0号
    timeout: 1800000 # 连接超时时间是1800秒
    lettuce:
      pool:
        max-active: 20 # 最大活跃连接数,使用负值表示没有限制
        max-wait: -1 # 最大等待时间,单位为毫秒,使用负值表示没有限制
        max-idle: 10 # 最大空闲连接数
        min-idle: 0 # 最小空闲连接数
4.添加Redis的配置类（使用SpringBoot默认的会出些问题关于序列化的）RedisConfig.java
package com.sun.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
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.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 21:29
 * @Version 1.0
 */
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template =
                new RedisTemplate<>();
        System.out.println("template=>" + template);
        RedisSerializer<String> redisSerializer =
                new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        // key 序列化方式
        template.setKeySerializer(redisSerializer);
        // value 序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // value hashmap 序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer =
                new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        // 解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间 600 秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

image-20240429213253810

2.测试
1.编写测试的Controller
package com.sun.redis.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 21:36
 * @Version 1.0
 */
@RestController
@RequestMapping("/redisTest")
public class TestController {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @RequestMapping("/set")
    public String set() {
        redisTemplate.opsForValue().set("name", "孙显圣");
        return redisTemplate.opsForValue().get("name").toString();
    }
}
2.编写主启动类
package com.sun.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 21:39
 * @Version 1.0
 */
@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class, args);
    }
}
3.启动测试 localhost:8080/redisTest/set

image-20240429214257425

image-20240429214242423

3.对list进行操作
1.代码
    @RequestMapping("/list")
    public String list() {
        // 清除一下库
        redisTemplate.delete("key");
        // 批量添加
        redisTemplate.opsForList().leftPushAll("key", "v1", "v2", "v3");
        // 遍历输出
        List<Object> range = redisTemplate.opsForList().range("key", 0, -1);
        return range.toString();
    }
2.结果

image-20240430084953906

4.注意事项
1.先看报错是无法识别的token

image-20240430085702856

2.如果使用redisTemplate进行set会先序列化，然后读取的时候也会反序列化，但是直接在客户端set不会进行序列化，所以在使用redisTemplate进行反序列化的时候就会出现问题
3.解决方式：都使用程序进行操作即可
# redis # spring boot # bootstrap
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

第二届开放原子大赛open-eBackup/Cantian两大赛项火热开启

第二届开放原子大赛open-eBackup/Cantian两大赛项火热开启

avatar 开放原子开发者工作坊

人民邮电报：“开源”到底是什么？为啥热度越来越高？

人民邮电报：“开源”到底是什么？为啥热度越来越高？

avatar 开放原子开发者工作坊

第二届开放原子大赛——vivo蓝河操作系统创新赛火热进行中

第二届开放原子大赛——vivo蓝河操作系统创新赛火热进行中

avatar 开放原子开发者工作坊