springboot链接Redis

一、java连接redis

1、创建一个maven的java项目
2、导入连接redis的依赖:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.fy</groupId>
    <artifactId>java-redis</artifactId>
    <version>1.0-SNAPSHOT</version>

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

</project>

 

3、普通测试类

public class TestOne {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.31.63",7004);//连接redis
        jedis.set("k1","v1");
        jedis.mset("k2","v2","k3","v3");
        String k1 = jedis.get("k2");
        System.out.println(k1);
    }
}

4、使用连接池的方式连接redis

public class TestPoolJedis {
    public static void main(String[] args) {
//        连接池配置
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(100);//连接池最大连接数为100
        config.setMaxIdle(10);//最大空闲数为10个
        config.setTestOnBorrow(true);//在从连接池获取连接对象前测试是否可以使用

//        创建连接池对象
        JedisPool jedisPool = new JedisPool(config, "192.168.31.63", 7004);
        
//      得到连接对象
        Jedis jedis = jedisPool.getResource();
        String k3 = jedis.get("k3");
        jedis.expire("k2",10);
        System.out.println(k3);
        System.out.println(jedis.ttl("k2"));

        jedis.close();
    }
}

 

二、springboot连接redis

创建一个springboot项目，可以在创建项目时就自动加载依赖，也可手动添加
1、添加依赖

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

2、配置文件：连接单个redis

spring.redis.host=192.168.31.63
spring.redis.port=7004
#最大连接数
spring.redis.jedis.pool.max-active=20
#最大等待数
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.min-idle=0
#最大等待时间
spring.redis.jedis.pool.max-wait=20000

 

3、连接类的介绍：StringRedisTemplate和RedisTemplate

(1)、StringRedisTemplate继承自RedisTemplate,底层代码：
        public class StringRedisTemplate extends RedisTemplate<String, String> {}
(2)、这两个类都是将数据序列化到redis库
(3)、RedisTemplate可以存储任何数据类型的数据，底层代码：
    public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
使用这个必须重新进行序列化配置。它默认对key和value使用的序列化是jdk的序列化，这种序列化有弊端，序列化后的数据占据内存太大。
(4)、StringRedisTemplate只能存储string类型的数据，它使用的序列化方式是StringRedisSerizlizer。使用它时不用再配置序列化。
(5)、这两个类对向redis操作的方法进行了封装，不像使用java连接时那么直观

4、StringRedisTemplate连接redis示例：

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        Set<String> keys = redisTemplate.keys("*");
        System.out.println(keys);
        redisTemplate.expire("k1",60, TimeUnit.SECONDS);
    }

    @Test
    public void testString(){
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();
        forValue.set("k8","v8");
        String k8 = forValue.get("k8");
        System.out.println(k8);
    }
}

5、RedisTemplate连接Redis（重新开启一个项目）
这里我们连接redis集群
（1）先配置序列化方式

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    //普通存值使用
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        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);
        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.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600)) //缓存过期10分钟 ---- 业务需求。
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))//设置key的序列化方式
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)) //设置value的序列化
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

 

（2）、项目的配置文件 application.properties
连接哨兵模式：

spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=192.168.213.188:26379

 

连接去中心化集群：

spring.redis.cluster.nodes=192.168.213.188:8001,192.168.213.188:8002,192.168.213.188:8003,192.168.213.188:8004,192.168.213.188:8005,192.168.213.188:8006

连接这两种方式就这么一点配置，没了

 

（3）、存数据，我们这次连接的时去中心化集群：

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        User user = new User(1, "张子豪");
        valueOperations.set("name",user);
    }
}

可以通过RedisPlus来查看存储进去的数据，RedisPlus连接集群时一定要选择集群模式：