• redis使用

    jedis (使用 java 代码连接 redis)

    添加依赖

    
<dependency>
      <groupId>redis.clientsgroupId>
      <artifactId>jedisartifactId>
      <version>3.2.0version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    java 代码

    @RequestMapping("/")
public String test(){
    // 建立与 redis 的连接，与 JDBC 类似
    // Jedis jedis = new Jedis(host,port); 两个参数，host:redis的ip地址，port:端口号
    Jedis jedis = new Jedis("124.222.157.68",6379);

    // 验证密码 ：如果没有设置密码则不需要此步骤
    // jedis.auth("123");

    // 往 redis 中存一个 String 类型的值
    jedis.set("test","123");

    // 取出 String 类型的值
    String str = jedis.get("test");
    System.out.println("存储的 String 类型的值为 : "+str);

    // 往 redis 中存一个 list 类型的值
    jedis.lpush("testList","a","b","c");

    // 取出 list 类型的值
    List<String> list = jedis.lrange("testList", 0, -1);
    System.out.println("存储的 list 类型的值为 : ");
    for (String string:list) {
        System.out.print(string+",");
    }
    return "hello!";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    执行效果

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    springboot 项目使用工具类将数据存入 redis 中

    依赖

    <dependency>
  <groupId>org.springframework.bootgroupId>	
  <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

    • 1
    • 2
    • 3
    • 4

    在项目启动类上开启缓存

    在这里插入图片描述

    配置 application 文件

    # 设置缓存方式为 redis
spring.cache.type=redis
# 设置缓存数据的时长,单位毫秒
spring.cache.redis.time-to-live=60000
# 是否缓存空值
spring.cache.redis.cache-null-values=false
# 配置redis ip地址
spring.redis.host=124.222.157.68
# 设置redis密码
# spring.redis.password=123

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    封装工具类

    在项目中添加该配置类，在这里配置缓存的时间后，application文件中的缓存时间将会被覆盖，此时实体类中不需要实现序列化也可以，因为工具类用的是json的序列化，没有用到io序列化。

    工具类会将数据json序列化，在redis中展示出数据通过

    package com.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
	//修改RedisTemplate的序列化
	@Bean
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
		RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
		template.setConnectionFactory(factory);

		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;
	}

	/**
	 * json序列化
	 * 
	 * @return
	 */
	public RedisSerializer<Object> jackson2JsonRedisSerializer() {
		// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
		Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
		ObjectMapper mapper = new ObjectMapper();
		mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		serializer.setObjectMapper(mapper);
		return serializer;
	}

	//修改注解的序列化，不能修改RedisTemplate的序列化
	@Bean
	public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
		// 生成一个默认配置，通过config对象即可对缓存进行自定义配置
		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
		config = config
				// 设置 key为string序列化
				.serializeKeysWith(
						RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
				// 设置value为json序列化
				.serializeValuesWith(
						RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
				// 不缓存空值
				.disableCachingNullValues()
				// 设置缓存的默认过期时间 30分钟
				.entryTtl(Duration.ofMinutes(30L));

		// 特殊缓存空间应用不同的配置
		Map<String, RedisCacheConfiguration> map = new HashMap<>();
		map.put("provider1", config.entryTtl(Duration.ofMinutes(30L)));// provider1缓存空间过期时间 30分钟
		map.put("provider2", config.entryTtl(Duration.ofHours(1L)));// provider2缓存空间过期时间 1小时

		// 使用自定义的缓存配置初始化一个RedisCacheManager
		RedisCacheManager cacheManager = RedisCacheManager.builder(connectionFactory).cacheDefaults(config) // 默认配置
				.withInitialCacheConfigurations(map) // 特殊缓存
				.transactionAware() // 事务
				.build();

		return cacheManager;
	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90

    指定数据存入 redis

    package com.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.TimeUnit;

/**
 * @author 韩坤鹏
 * @data 2022/7/25
 */
@RestController
public class TestController {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 存入值
     * @return
     */
    @RequestMapping("/")
    private Object addOrder() {
        //将订单id存入redis，存30分钟 ；
        //redisTemplate.opsForValue()表示你要存入的数据类型
        //value 表示是字符串类型
        /**
         TimeUnit.SECONDS:秒
         TimeUnit.MINUTES：分
         TimeUnit.HOURS：时
         TimeUnit.DAYS：日
         TimeUnit.MILLISECONDS：毫秒
         TimeUnit.MILLISECONDS：微秒
         TimeUnit.NANOSECONDS：纳秒
         */

        redisTemplate.opsForValue().set("testRedis","redis",60, TimeUnit.SECONDS);
        return "存入成功";
    }

    /**
     * 获取键的时间
     * @return
     */
    @PostMapping("/time")
    private Object getOrderTime() {
        Long time=redisTemplate.getExpire("testRedis");
        return "成功取出时间 : "+time;
    }


    /**
     * 删除键
     * @return
     */
    @DeleteMapping("/del")
    public Object deleteKey(){
        return redisTemplate.delete("testRedis");
    }
}


Long time=redisTemplate.getExpire("testRedis");
        return "成功取出时间 : "+time;
    }


    /**
     * 删除键
     * @return
     */
    @DeleteMapping("/del")
    public Object deleteKey(){
        return redisTemplate.delete("testRedis");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
  • 相关阅读:
    ctfshow 文件上传 151-161
    七、Vue3基础之七
    （附源码）php积极心理学交流学习网站 毕业设计 100623
    Android移动安全攻防实战 第二章
    智哪儿评测：既要便捷、安全和智能，也要颜值：萤石极光人脸视频锁Y3000FV体验评测
    入门数据库Days8
    有关REST的一些内容
    Java23种设计模式-结构型模式之装饰器模式
    Spring_boot之自动加载自己的AutoConfiguration
    [附源码]Python计算机毕业设计SSM开放式实验室预约系统（程序+LW)
  • 原文地址：https://blog.csdn.net/weixin_46047612/article/details/126060743