使用Java操作redis

1、Jedis

​ Jedis是Redis官方推荐的Java连接开发工具！使用Java操作Redis中间件！如果你要使用Java操作redis，那么一定要对Jedis十分熟悉！

1.1、导入依赖

<dependencies>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.2.0</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.69</version>
    </dependency>
</dependencies>

1.2、编码测试

• 连接数据库
• 操作命令
• 断开连接

public class TestPing {
    public static void main(String[] args) {
        JedisShardInfo jedisShardInfo = new JedisShardInfo("127.0.0.1", 6379);
        jedisShardInfo.setPassword("xxx");   //密码
        Jedis jedis = new Jedis(jedisShardInfo);
        //Jedis的所有命令就是我们之前学习的所有指令！
        System.out.println(jedis.ping());   //PONG
    }
}

1.3测试事务

• 正常执行：

public class TestTx {
    public static void main(String[] args) {
        JedisShardInfo jedisShardInfo = new JedisShardInfo("127.0.0.1", 6379);
        jedisShardInfo.setPassword("xxx");
        Jedis jedis = new Jedis(jedisShardInfo);
        jedis.flushDB();  //清空数据
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        String jsonString = jsonObject.toJSONString();

        Transaction multi = jedis.multi();  //开启事务
        try {
            multi.set("user", jsonString);
            multi.exec();   //执行事务
        } catch (Exception e) {
            multi.discard();   //放弃事务
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user"));  //{"hello":"world"}
            jedis.close();  //关闭连接
        }

    }
}

• 发生错误

Transaction multi = jedis.multi();  //开启事务
try {
    multi.set("user", jsonString);  //命令加入队列
    int i = 1 / 0;   //代码抛出异常，执行失败
    multi.exec();   //执行事务
} catch (Exception e) {
    multi.discard();   //放弃事务
    e.printStackTrace();
} finally {
    System.out.println(jedis.get("user"));
    jedis.close();  //关闭连接
}

2、Spring Boot整合

2.1、源码分析

	@Bean
    @ConditionalOnMissingBean(name = {"redisTemplate"})  //可以自定义一个RedisTemplate来替换这个默认的
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        //默认的RedisTemplate没有过多的设置，redis对象都是需要序列化！
        //两个泛型都是Object类型，使用的时候需要强制转换<String, Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        //由于String是redis中最常使用的类型，所以单独提出一个bean
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

2.2、整合使用

1. 导入依赖

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

2. 配置连接

   spring.redis.host=127.0.0.1
   spring.redis.port=6379
   spring.redis.password=xxx
   

3. 测试

   @SpringBootTest
   class Redis02SpringbootApplicationTests {
   
   	@Autowired
   	private RedisTemplate redisTemplate;
   
   	@Test
   	void contextLoads() {
   		//  redisTemplate  操作不同的数据类型是先获取操作对象
   		//  redisTemplate.opsForValue()		操作字符串，类似String
   		//  redisTemplate.opsForList()		操作List，类似List
   		//  redisTemplate.opsForSet()		操作Set
   		//  redisTemplate.opsForHash()
   		//  redisTemplate.opsForZSet()
   		//  redisTemplate.opsForGeo()
   		//  redisTemplate.opsForHyperLogLog()
   		//  除了基本的操作，常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD
   
   		redisTemplate.opsForValue().set("hello", "world");
   		System.out.println(redisTemplate.opsForValue().get("hello"));   //world
   	}
   
   }
   

2.3、自定义RedisTemplate

• 这是一个固定模板，在企业中可以直接使用

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;

@Configuration
public class redisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //Json序列化配置
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用string的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        //value采用jackson的序列方式
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}