Redis基础

慢来来

已于 2023-07-09 14:03:02 修改

阅读量516

点赞数

分类专栏：学习文章标签： java redis springboot

于 2023-07-09 14:01:56 首次发布

本文链接：https://blog.csdn.net/HCS11/article/details/131622246

版权

学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了Redis的基本概念，作为内存数据库的角色，以及如何在Java中使用Redis，包括配置Linux上的Redis服务，开启服务，开放防火墙端口，以及使用Jedis进行连接。此外，还详细讲解了SpringBoot集成Redis的步骤，包括配置文件、连接池设置，并展示了如何进行数据序列化配置。

摘要由CSDN通过智能技术生成

redis

文章目录

redis

1.redis介绍

远程字典服务器，Remote dictionary server
一个开源的基于内存的数据库，常用作键值存储、缓存和消息队列等
Redis通常将全部数据存储在内存中，也可以不时的将数据写入硬盘实现持久化，但仅用于重新启动后将数据加载回内存
*内存的速度比硬盘快一个数量级

2.java使用Redis 步骤

参考文章https://blog.csdn.net/Huang_ZX_259/article/details/122906569

java使用linux中的redis服务

第一步：修改配置文件redis.conf

注：redis.conf 在redis的安装目录下

（1）注释以下属性，因为我们是需要进行远程连接的：

#bind:127.0.0.1
（2）将protected-mode 设置为no

protected-mode no
（3）设置为允许后台连接

daemonize yes

第二步：开启redis服务

（1）开启redis服务

先查看redis服务是否开启

systemctl status redis.service

如果没有开启，执行服务开启命令

systemctl start redis.service

第三步：防火墙开放redis端口

在远程服务器进行连接redis服务的防火墙设置

（1）使用防火墙，先确定防火墙服务是否开启，查看防火墙状态

systemctl start firewalld.service

没开启，就开启防火墙

（2）设置服务器的安全组开放6379端口

（3）防火墙开放redis服务端口

firewall-cmd --zone=public --add-port=6379/tcp --permanent

（4）重启防火墙：

systemctl restart firewalld.service

第四步：在java中，使用Jedis连接Redis

（1）创建一个Maven项目，并导入以下依赖：

<dependencies>
 
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.2.0</version>
    </dependency>
 
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
 
</dependencies>

（2）测试连接

3.SpringBoot集成Redis

3.1 介绍

springboot整合redis不使用jedis来进行连接，而是使用lettuce来进行连接，
jedis和lettuce的对比如下：
jedis：采用的直连，多个线程操作的话，是不安全的；想要避免不安全，使用jedis pool连接池。更像BIO模式
lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况；可以减少线程数量。更像NIO模式

3.2 springboot集成Redis 步骤

第一步：创建Spring Boot项目

第二步：导入依赖 （如果第一步创建springboot项目时，勾选 spring Data Redis（Access+Driver）就会自动在prom文件名添加以下依赖）

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

		<!--用于测试-->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

		<!--连接池依赖，用于第三步配置pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

第三步：编写配置文件application.yml

#配置redis数据库连接信息

spring:
  redis:
    host: 192.168.200.147   
    port: 6379   #确认远程的redis服务已启动
    database: 0
    lettuce:
      pool:  #注意，需要导入commons-pool2依赖
        max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
        max-idle: 10 #连接池中的最大空闲连接
        min-idle: 3 #连接池中的最小空闲连接
        max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）

注意：但对于application.properties文件，配置pool，不需要再pom文件中导入commons-pool2依赖，所以（很奇怪）

第四步：编写程序测试使用redis（redisTemplate操作着不同的redis数据类型）

在这种连接方式中，redisTemplate操作着不同的数据类型，api和我们的指令是一样的。

opsForValue：操作字符串 类似String
opsForList：操作List 类似List
opsForSet：操作Set，类似Set
opsForHash：操作Hash
opsForZSet：操作ZSet
opsForGeo：操作Geospatial
opsForHyperLogLog:操作HyperLogLog

截图：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HgEsPmvD-1688881948703)(D:\java\Java_Notes\redis\image-20230604172031598.png)]$

代码：

@SpringBootTest
class SpringbootRedis1ApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
    *向redis中存数据
    */
    @Test
    void set() {
        ValueOperations ops = redisTemplate.opsForValue();  //opsForValue 用于操作String 数据
        ops.set("address1","zhengzhou");
    }

    /**
     *  取数据
     */
    @Test
    void get() {
        ValueOperations ops = redisTemplate.opsForValue();  //opsForValue 用于操作String 数据
        Object o = ops.get("address1");  // 获取Redis数据库中key为address1对应的value数据
        System.out.println(o);
    }

}

3.3 在3.2 的基础上，对redis的数据进行序列化配置

注意：启动类，是启动类的同级的包、子包或和启动类在同一个包，这些类或文件才会在
加载启动类的时候被加载

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fTvxyfuJ-1688881948705)(D:\java\Java_Notes\redis\image-20230604195145038.png)]$

第一步：创建User类

package com.example.pojo;

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private int age;
    
    public  User(){
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

第二步：创建对操作redis的RedisTemplate 进行配置

package com.example.springboot_redis1;

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

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        //为了自己开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        // Json序列化配置
        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);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }


}