Redis在SpringBoot中的简单应用

最新推荐文章于 2024-07-12 16:55:56 发布

葡萄院下的lin

最新推荐文章于 2024-07-12 16:55:56 发布

阅读量931

点赞数 20

文章标签： bootstrap 前端 html

本文链接：https://blog.csdn.net/2301_79909038/article/details/137800434

版权

添加Redis依赖包

在项目的pom.xml中添加依赖

方式一：可以直接在dependences旁边的edis中点击搜索添加

方式二：手动添加

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

配置Redis数据库连接

方式一：在application.properties中配置redis数据库连接信息

如下

#redis配置
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0  
#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=50
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=3000
#连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=20
#连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=2
#连接超时时间（毫秒）
spring.redis.timeout=5000

方式二：在yaml文件中配置redis连接：

spring:
  redis:
    #Redis服务器地址，默认localhost
    host: localhost
    #Redis服务器端口，默认6379
    port: 6379
    pool:
      #连接池最大连接数
      max-active: 8
      #最大阻塞等待时间，-1表示没有限制
      max-wait: -1
      #最大空闲连接
      max-idle: 8
      #最小空闲连接
      min-idle: 0
    #连接超时时间
    timeout: 0

使用RedisTemplate操作Redis（手动）

spring-data-redis提供了一个RedisTemplate类，这个类封装了对Redis基本数据结构的常用操作，它的子类StringRedisTemplate提供了对字符串的常用操作，接下来将使用StringRedisTemplate来操作Redis中的String和List类型

注入StringRedisTemplate

  @Autowired
    private StringRedisTemplate stringRedisTemplate;

操作字符串

private void operateString() &#123;
        stringRedisTemplate.opsForValue().set("author", "luoliang");
        String value = stringRedisTemplate.opsForValue().get("author");
        log.info("stringRedisTemplate输出值：&#123;&#125;", value);
    &#125;

Redis List操作，Redis列表是简单的字符串列表，按照插入顺序排序，可以添加一个元素到列表的头部或者尾部

 private void operateList() &#123;
        String key = "website";
        ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
        //从左压入栈
        listOperations.leftPush(key, "Github");
        listOperations.leftPush(key, "CSDN");
        //从右压入栈
        listOperations.rightPush(key, "SegmentFault");
        log.info("list size:&#123;&#125;", listOperations.size(key));
        List<String> list = listOperations.range(key, 0, 2);
        list.forEach(log::info);
    &#125;

上面涉及到的两种类型的操作，都是针对的字符串

下面来存取对象

使用Hash来存取对象

1.新建一个User类，用于存取使用

需要实现Serializable接口，实现序列化

@Data
@Builder
public class User implements Serializable &#123;
    private String id;

    private String name;

    private Integer age;
&#125;

这个时候就不能再使用StringRedisTemplate了

需要配置针对Object的RedisTemplate实例

可以使用默认的JdkSerializationRedisSerializer序列化，也可以自己实现RedisSerializer接口来自定义序列化

@Configuration
public class RedisConfig &#123;
    @Resource
    private JedisConnectionFactory jedisConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> objRedisTemplate() &#123;
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new JdkSerializationRedisSerializer());
        return template;
    &#125;
&#125;

操作Hash

  @Resource
    private RedisTemplate<String, Object> objRedisTemplate;

    /**
     * 操作hash，存放User对象
     */
    private void operateHash() &#123;
        String key = "user";
        HashOperations<String, String, User> hashOperations = objRedisTemplate.opsForHash();
        hashOperations.put(key, "user1", User.builder().name("Hulk").age(50).build());
        hashOperations.put(key, "user2", User.builder().name("Thor").age(1500).build());
        hashOperations.put(key, "user3", User.builder().name("Rogers").age(150).build());
        log.info("hash size:&#123;&#125;", hashOperations.size(key));
        log.info("--------拿到Map的key集合--------");
        Set<String> keys = hashOperations.keys(key);
        keys.forEach(log::info);
        log.info("--------拿到Map的value集合--------");
        List<User> users = hashOperations.values(key);
        users.forEach(user -> log.info(user.toString()));
        log.info("--------拿到user1的value--------");
        User user = hashOperations.get(key, "user1");
        log.info(user.toString());
    &#125;

使用Annotation缓存数据

上面的操作方式，是手动操作Redis进行存取，在真实的业务场景中，我们并不想这样去使用，而是把Redis当做一种缓存来使用，把service或者dao层的数据进行缓存，最简单的方式就是通过注解。在SpringBoot中使用Redis做缓存也非常简单，只需要在pom引入spring-boot-starter-cache即可

常用的注解（Spring缓存）

@CacheConfig ：主要用于配置该类中会用到的一些共同的缓存配置

后面（cacheNames=”users“）：配置了该数据访问对象中返回的内容将存储于名为users的缓存对象中，也可以不使用，该注解会自己配置缓存集的名字定义

@Cacheable：配置了findByName函数的返回值将被加入缓存

@CachePut：配置于函数上，能够根据参数定义条件来进行缓存

@CacheEvict：配置于函数上，通常用在删除方法上，用于从缓存中移除相应数据。

编写Redis操作工具类

将RedisTemplate实例包安装成一个工具类，便于对redis进行数据操作

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
@Component
public class RedisUtils {
 
	@Autowired
	private RedisTemplate<String, String> redisTemplate;
 
	/**
	 * 读取缓存
	 * 
	 * @param key
	 * @return
	 */
	public String get(final String key) {
		return redisTemplate.opsForValue().get(key);
	}
 
	/**
	 * 写入缓存
	 */
	public boolean set(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().set(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
 
	/**
	 * 更新缓存
	 */
	public boolean getAndSet(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().getAndSet(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
 
	/**
	 * 删除缓存
	 */
	public boolean delete(final String key) {
		boolean result = false;
		try {
			redisTemplate.delete(key);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
}

测试

写一个测试用例类来完成对redis的读写

import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class RedisTest {
	@Resource
	private RedisUtils redisUtils;
 
	/**
	 * 插入缓存数据
	 */
	@Test
	public void set() {
		redisUtils.set("redis_key", "redis_vale");
	}
	
	/**
	 * 读取缓存数据
	 */
	@Test
	public void get() {
		String value = redisUtils.get("redis_key");
		System.out.println(value);
	}
 
}

执行完测试方法set后，可以登录到redis上查看数据是否插入成功