java连接redis

1.使用

1.创建java工程

2.引入依赖

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

3.

 //1.获取jedis对象，把所有对redis的操作都封装到该类中
        //默认连接本地localhost，端口号6379
        Jedis jedis=new Jedis("192.168.64.130",6379);

        //key操作
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);

        //判断k1是否存在
        boolean k1 = jedis.exists("k1");
        System.out.println(k1);

        //对string类型的操作
        String set = jedis.set("name", "aaa");
        String name = jedis.get("name");
        System.out.println(name);
        long setnx = jedis.setnx("name", "bbb");
        System.out.println(setnx);

        //对hash类型的操作
        Map<String, String> map = new HashMap<>();
        map.put("name","张三");
        map.put("age","18");
        map.put("sex","男");
        jedis.hset("people",map);
        Map<String, String> people = jedis.hgetAll("people");
        System.out.println(people);
        jedis.close();

1.2.Jedis连接池

作用：

提供效率，减少频繁创建和销毁连接对象

 @Test
    public void test02(){
        //创建jedis连接池的配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大值
        jedisPoolConfig.setMaxTotal(10);
        //最小空闲值
        jedisPoolConfig.setMinIdle(5);
        //最大空闲值
        jedisPoolConfig.setMaxTotal(8);
        //拿到jedis对象时，是否验证该对象可用
        jedisPoolConfig.setTestOnBorrow(true);
        //等待时间
        jedisPoolConfig.setMaxWaitMillis(3000);
        //创建jedis连接池
        JedisPool jedisPool = new JedisPool(jedisPoolConfig,"192.168.64.130",6379);
        //获取jedis对象
        Jedis jedis=jedisPool.getResource();

        //key操作
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);

        //判断k1是否存在
        boolean k1 = jedis.exists("k1");
        System.out.println(k1);

        //对string类型的操作
        String set = jedis.set("name", "aaa");
        String name = jedis.get("name");
        System.out.println(name);
        long setnx = jedis.setnx("name", "bbb");
        System.out.println(setnx);

        //对hash类型的操作
        Map<String, String> map = new HashMap<>();
        map.put("name","张三");
        map.put("age","18");
        map.put("sex","男");
        jedis.hset("people",map);
        Map<String, String> people = jedis.hgetAll("people");
        System.out.println(people);

        jedis.close();

    }

2.java连接redis集群

@Test
    public void test05(){
        Set<HostAndPort> nodes=new HashSet<HostAndPort>();
        nodes.add(new HostAndPort("192.168.64.130",7001));
        nodes.add(new HostAndPort("192.168.64.130",7002));
        nodes.add(new HostAndPort("192.168.64.130",7003));
        nodes.add(new HostAndPort("192.168.64.130",7004));
        nodes.add(new HostAndPort("192.168.64.130",7005));
        nodes.add(new HostAndPort("192.168.64.130",7006));
        JedisCluster jedisCluster=new JedisCluster(nodes);

        jedisCluster.set("k1","v1");
        String k1 = jedisCluster.get("k1");
        System.out.println(k1);
        jedisCluster.close();
    }

3.springboot整合redis

在springboot中提供了俩个封装类RedisTemplate和StringRedisTemplate。StringRedisTemplate是
RedisTemplate的子类，StringRedisTemplate存储的元素值，都是String类型，不能直接存储对象类型。

1.依赖

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

2.配置文件

#redis相关配置
spring.data.redis.host=192.168.64.130
spring.data.redis.port=6379
spring.data.redis.jedis.pool.max-idle=8
spring.data.redis.jedis.pool.min-idle=0
spring.data.redis.jedis.pool.max-wait=3000
spring.data.redis.jedis.pool.max-active=10

3.测试

3.1StringRedisTemplate

@Autowired
    private StringRedisTemplate redisTemplate;
    @Test
    public void test01() throws JsonProcessingException {
       //操作redis服务 key操作
        Boolean k1 = redisTemplate.delete("k1");
        System.out.println(k1);
        Boolean k11 = redisTemplate.hasKey("k1");
        System.out.println(k11);

        //2.string操作,redis对每一种类型的操作都封装了相应的类，由相应类对象操作相应的数据类型
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();
        forValue.set("k1","v1",30, TimeUnit.SECONDS);
        String k12 = forValue.get("k1");
        System.out.println(k12);
        //可以通过序列化吧对象转换为相应的json字符
        ObjectMapper objectMapper=new ObjectMapper();
        forValue.set("k3",objectMapper.writeValueAsString(new User("bbb", 18)));
        String k3 = forValue.get("k3");
        //反序列化
        User user = objectMapper.readValue(k3, User.class);
        System.out.println(user);
        //如果指定的key存在则存储失败，如果不存在则存储成功
        Boolean k13 = forValue.setIfAbsent("k2", "333", 30, TimeUnit.SECONDS);
        System.out.println(k13);

        //3.hash操作
        HashOperations<String, Object, Object> forHash = redisTemplate.opsForHash();
        forHash.put("people","name","aaa");
        forHash.put("people","age","18");
        Map<Object, Object> people = forHash.entries("people");
        System.out.println(people);
    }

上面的StringRedisTemplate的key和value都是string类型

默认不能存储对象类型，要想存储需要把对象序列化，获取时反序列化

3.2RedisTemplate

@Data
@AllArgsConstructor
@NoArgsConstructor
//默认采用jdk的序列化方式
public class User implements Serializable {
    private String name;
    private Integer age;
}

 @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void test02(){
        //可以操作字符串类型
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("k1","v1");
        System.out.println(valueOperations.get("k1"));

        //User类不能序列化
        valueOperations.set("k2",new User("张三",18));
        System.out.println(valueOperations.get("k2"));

    }

因为RedisTemplate默认序列化方式为jdk序列化方式，可以指定序列化方式

如果是hash类型还需要设置hash的

redisTemplate.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());

使用一次需要设置一次

可以使用配置类

@Configuration
public class RedisConfig {
    @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);
        //key序列化方式
        template.setConnectionFactory(factory);
        //value序列化方式
        template.setKeySerializer(redisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(redisSerializer);
        return template;
    }
}