idea环境下Redis的Java客户端

一、Jedis的快速入门

1 、引入依赖

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

2 、创建Jedis对象，建立连接

private Jedis jedis;

    @BeforeEach
    void setUp(){
        //1.建立连接
        jedis = new Jedis("192.168.140.129",6379);
        //2.设置密码
        jedis.auth("123321");
        //3.选择库
        jedis.select(0);
    }

3、 测试string

字符串类型

@Test
    void testString(){
        //存入数据
        String result = jedis.set("name", "小志");
        System.out.println("result = " + result);
        
        //获取数据
        String name = jedis.get("name");
        System.out.println("name = " + name);

    }

Hash数据

@Test
    void  testHash(){
        //存入数据
        jedis.hset("user:1", "name", "xiaoxiaozhi");
        jedis.hset("user:1", "age", "21");

        //获取数据
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);
    }

测试结果

4 、释放资源

@AfterEach
    void tearDown(){
        if (jedis != null){
            jedis.close();
        }
    }

二、Jedis连接池

连接池配置

public class JedisConnectionFactory {
    private static final JedisPool jedisPool;
    static {
        //配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //连接池最多可以创建8个
        poolConfig.setMaxTotal(8);
        //最大空闲连接
        poolConfig.setMaxIdle(8);
        //最小空闲连接
        poolConfig.setMinIdle(0);
        //等待时长
        poolConfig.setMaxWaitMillis(1000);    //最多等待1000毫秒
        //创建连接池对象
        jedisPool = new JedisPool(poolConfig,
                "192.168.140.129",6379,1000,"123321");
    }
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

从连接池获取jedis

jedis = JedisConnectionFactory.getJedis();      //从连接池获取jedis

三、SpringDataRedis快速入门

1 、创建一个SpringBoot项目

勾选NoSQL下的Spring-Data-Redis，则pom文件中自动导入依赖

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

2 、引入依赖

·······<!-- Redis依赖 --> 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

3、 在application.yml中配置redis信息

spring:
    redis:
        host: 192.168.140.129
        port: 6379
        password: 123321
        lettuce:
            pool:
                max-active: 8
                max-idle: 8
                min-idle: 0
                max-wait: 1000ms

4 、注入RedisTemplate

@Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        //写入一条String数据
        redisTemplate.opsForValue().set("name","小志");
        //获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

四、SpringDataRedis的序列化

方法一：JSON序列化（不推荐）

1、 JSON序列化工具

编写redisConfig文件
通过自定义RedisTemplate，修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
优点：自动进行序列化和反序列化
缺点：额外占用内存空间

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        //创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //设置连接工厂
        template.setConnectionFactory(connectionFactory);
        //创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        //返回
        return template;
    }
}

2、 编写测试类

@Test
    void testString() {
        //写入一条String数据
        redisTemplate.opsForValue().set("name","小志");
        //获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    @Test
    void testSaveUser(){
        //写入数据
        redisTemplate.opsForValue().set("user:100",new User("晒会太阳",22));
        //获取数据
        User o = (User) redisTemplate.opsForValue().get("user:100");        //获取到的是user对象，进行强转
        System.out.println("o = " + o);
    }

图形化界面输出

方法二：String序列化（推荐，节省内存空间）

使用StringRedisTemplate，仅存储string类型的key和value，存储Java对象时，手动把对象序列化为JSON（写入Redis时），手动把读取到的JSON反序列化为对象（读取Redis时）。
Spring默认提供了一个SpringRedisTemplate类，它的key和value的序列化方式默认就是String方式，省去自定义RedisTemplate的过程。

1、string类型测试类

 @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Test
    void testString() {
        //写入一条String数据
        stringRedisTemplate.opsForValue().set("name","小志");
        //获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

2、Java对象测试类（推荐使用）

//Java对象
    //JSON序列化工具
    private static final ObjectMapper mapper = new ObjectMapper();
    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("晒会太阳", 21);
        //手动序列化
        String json = mapper.writeValueAsString(user);
        //写入数据
        stringRedisTemplate.opsForValue().set("user:200",json);
        //获取数据
        String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
        //手动反序列化
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println("user1 = " + user1);
    }

图形化界面：

补充：

哈希结构

@Test
    void testHash(){
        //写入数据
        stringRedisTemplate.opsForHash().put("user:400","name","小五");
        stringRedisTemplate.opsForHash().put("user:400","age","6");
        //读取数据
        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println("entries  = " + entries );
    }

图形化界面：