redis在项目中运用（基础）

200不是二百

于 2024-10-11 22:35:37 发布

阅读量221

点赞数 3

文章标签： redis

本文链接：https://blog.csdn.net/hang_sa_mu/article/details/142864766

版权

mysql学完命令之后，学过jdbc。

redis也要使用Java连接redis数据库

1.Jedis

2.RedisTemplate[重点]

1、Jedis【了解】

jedis是redis的java版本的客户端实现，jedis中提供了针对redis命令的操作

1.1导入jar文件

Maven方式

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

测试

入门案例

package com.qf.day63_redis.jedis;

import redis.clients.jedis.Jedis;

/**
 * ---厚德载物---
 *
 * @Author wangbo
 * @Date 2024/10/11
 * @Desc 人的一生适可而止
 */
public class App {
    public static void main(String[] args) {
        //1.创建jedis对象
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        System.out.println(jedis);
        //2.设置一个数据
        jedis.set("likeNum", "100");
        //.3获取数据
        String s = jedis.get("likeNum");
        System.out.println(s);
    }
}

像一个问题？ windows版本的redis 启动时候默认是没有密码的

如何设置密码启动？

1.找到redis.window.conf

找到503行 requirepass root(自己定义的密码)

2.启动使用命令启动

redis-server redis.windows.conf

package com.qf.day63_redis.jedis;

import redis.clients.jedis.Jedis;

/**
 * ---厚德载物---
 *
 * @Author wangbo
 * @Date 2024/10/11
 * @Desc 人的一生适可而止
 */
public class App {
    public static void main(String[] args) {
        //1.创建jedis对象
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        //1.1设置密码 如果有密码启动的时候  才取设置的！！！
        jedis.auth("root");
        System.out.println(jedis);
        //2.设置一个数据
        jedis.set("likeNum", "100");
        //.3获取数据
        String s = jedis.get("likeNum");
        System.out.println(s);
    }
}

1.2JedisPool

Jedis对象并不是线程安全的，在多线程下使用同一个Jedis对象会出现并发问题。为了避免每次使用Jedis对象时都需要重新构建，Jedis提供了JedisPool。JedisPool是基于Commons Pool 2实现的一个线程安全的连接池。如果使用jedis连接池，需要commons-pool2的jar包

package com.qf.day63_redis.jedis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * ---厚德载物---
 *
 * @Author wangbo
 * @Date 2024/10/11
 * @Desc 人的一生适可而止
 */
public class JedisUtils {
    //1.声明连接池的对象
    private static JedisPool jedisPool = null;
    static {
        //2.创建redisPool连接池的配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //最多与多少个jedis对象
        config.setMaxTotal(50);
        //最多有多少空闲的jedis对象
        config.setMaxIdle(20);
        //最大等待时间
        config.setMaxWaitMillis(5000);
        //检查连接的有效性
        config.setTestOnBorrow(true);

        //第二个参数：redis服务器的ip
        //第三个参数：端口
        //第四个参数：连接服务器的超时时间
        //第五个参数：密码
        //创建redis连接池对象
        jedisPool = new JedisPool(config, "127.0.0.1", 6379, 1000, "root");
    }
    //封装好一个方法，获取Jedis对象
    public static Jedis getJedis() {
        Jedis jedis = jedisPool.getResource();
        return jedis;
    }
    //jedis放回池子中
    public  static void close(Jedis jedis) {
        jedis.close();//
    }
}

2、在springboot 中集成redis

2.1RedisTemplate

spring-data-redis的jar中，提供在spring应用中通过简单的配置访问redis服务的功能，它对reids底层开发包进行了高度封装。

针对reids的操作，包中提供了RedisTemplate类和StringRedisTemplate类，其中StringRedisTemplate是RedisTemplate的子类，该类只支持key和value为String的操作

2.2主要封装接口

RedisTemplate针对不同数据类型的操作进行封装，将同一类型操作封装为Operation接口

ValueOperations：简单K-V操作，获取方式 redisTemplate.opsForValue();

SetOperations：set类型数据操作，获取方式 redisTemplate.opsForSet();

ZSetOperations：zset类型数据操作，获取方式 redisTemplate.opsForZSet();

HashOperations：针对hash类型的数据操作，获取方式 redisTemplate.opsForHash();

ListOperations：针对list类型的数据操作，获取方式 redisTemplate.opsForList();

2.3序列化策略

StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。

RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。

GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化

Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的

JacksonJsonRedisSerializer: 序列化object对象为json字符串

JdkSerializationRedisSerializer: 序列化java对象（被序列化的对象必须实现Serializable接口）

StringRedisSerializer: 简单的字符串序列化

GenericToStringSerializer:类似StringRedisSerializer的字符串序列化

GenericJackson2JsonRedisSerializer:类似Jackson2JsonRedisSerializer，但使用时构造函数不用特定的类

【注意】：存储数据的时候指定序列化策略

2.4导入jar

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

<!-- pool 对象池 -->
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
</dependency>

在SpringBoot 1.5.x版本默认的Redis客户端是Jedis实现的，SpringBoot 2.x版本默认客户端是用lettuce实现的

2.5yml中配置

  # redis 配置
  spring:
    redis:
      # 地址
      host: 127.0.0.1
      # 端口，默认为6379
      port: 6379
      # 数据库索引
      database: 0
      # 密码
      password: root
      # 连接超时时间
      timeout: 10s
      lettuce:
        pool:
          # 连接池中的最小空闲连接
          min-idle: 0
          # 连接池中的最大空闲连接
          max-idle: 8
          # 连接池的最大数据库连接数
          max-active: 8
          # #连接池最大阻塞等待时间（使用负值表示没有限制）
          max-wait: -1ms

2.6redis配置类

SpringBoot自动在容器中创建了RedisTemplate对象和StringRedisTemplate对象。但是，RedisTemplate的泛型是<Object,Object>，进行数据处理时比价麻烦，我们需要自定义一个RedisTemplate对象

package com.qf.day63_redis.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.annotation.Resource;

/**
 * ---厚德载物---
 *
 * @Author wangbo
 * @Date 2024/10/11
 * @Desc 人的一生适可而止
 */
@Configuration
public class RedisConfig {
    @Resource
    //lettuceConnectionFactory  创建lettuce对象的
    private LettuceConnectionFactory lettuceConnectionFactory;
    //自定义redisTemplate对象
    @Bean
    public RedisTemplate<String,Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // hash的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        return redisTemplate;
    }
}

直接测试

package com.qf.day63_redis;

import com.qf.day63_redis.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@SpringBootTest
class Day63RedisApplicationTests {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("viewNum", 1000);
        Integer num = (Integer)redisTemplate.opsForValue().get("viewNum");
        System.out.println(num);
    }
    @Test
    void test1 () {
        User user = new User();
        user.setName("狗蛋");
        user.setAge(21);
        redisTemplate.opsForValue().set("user", user);
        //{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋","age":21}

    }
    @Test
    void test2 () {
        User user = new User();
        user.setName("狗蛋");
        user.setAge(21);
        User user1 = new User();
        user1.setName("狗蛋1");
        user1.setAge(22);
        User user2 = new User();
        user2.setName("狗蛋2");
        user2.setAge(22);
        List<User> list = new ArrayList<>();
        list.add(user);
        list.add(user1);
        list.add(user2);
        redisTemplate.opsForValue().set("userList", list);
        List<User> list1  = (List<User>)redisTemplate.opsForValue().get("userList");
        System.out.println(list1);
        //
        //["java.util.ArrayList",[{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋","age":21},{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋1","age":22},{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋2","age":22}]]

    }


}

发现对redis数据库操作的时候，还得写ops方法再根set get del 操作

有一个想法，把这些操作封装到一个类中，直接使用类调用方法即可

RedisUtils工具类

工具类的第一种写法：

package com.qf.day63_redis.utils;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * ---厚德载物---
 *
 * @Author wangbo
 * @Date 2024/10/11
 * @Desc 人的一生适可而止
 */
@Component//把工具类放到了容器中了
public class RedisUtils {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;//直接注入
    public static void setValue (String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
}

使用

@Test
    void test4 () {
        User user1 = new User();
        user1.setName("狗蛋1");
        user1.setAge(22);
        redisUtils.setValue("user1", user1);
    }

工具类的第二种写法：

就是方法中加了static修饰符无法在RedisUtils中注入redisTemplate的对象的

只能借助于一个叫SpringBeanUtils 自己写的工具类型

package com.qf.day63_redis.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
 *---厚德载物---
 *@Author wangbo
 *@Date 2024/10/11
 *@Desc
 * 人的一生适可而止
 *
 */




@Component
public class SpringBeanUtils implements ApplicationContextAware {

    /**
     * Spring应用上下文对象
     */
    private static ApplicationContext applicationContext = null;

    /**
     * 注入上下文对象
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringBeanUtils.applicationContext = applicationContext;
    }

    /**
     * 根据名称获取bean对象
     *
     * @param name
     * @param <T>
     * @return
     * @throws BeansException
     */
    public static <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }

    /**
     * 根据类型获取bean对象
     *
     * @param clz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clz) {
        T result = (T) applicationContext.getBean(clz);
        return result;
    }

}

第二种写法的工具类

package com.qf.day63_redis.utils;

import org.springframework.data.redis.core.RedisTemplate;

/**
 * ---厚德载物---
 *
 * @Author wangbo
 * @Date 2024/10/11
 * @Desc 人的一生适可而止
 */
public class RedisUtils1 {
    //不要使用@Resource注入redisTemplate这个对象了
    //但是需要redisTemplate对象  咋办？ 写一个工具类 获取bean对象的工具类
    private static  RedisTemplate<String , Object> redisTemplate = SpringBeanUtils.getBean("redisTemplate");

    public static  void setValue (String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
}

测试

@Test
void test5 () {
    User user1 = new User();
    user1.setName("xixi");
    user1.setAge(25);
    RedisUtils1.setValue("user2", user1);
}

项目中杂加redis

1.导包

2.yml文件

2.配置类

3.工具类型

以上全部黏贴复制！！！！

200不是二百

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫