[Redis学习笔记]-Spring 操作Redis

Spring 操作Redis

Spring操作Redis的主要基于RedisTemplate的操作，它是对Jedis的封装。

Maven新建一个Java工程

不会maven的可以百度一下。

引入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-oxm</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.8.RELEASE</version>
</dependency>

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

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.2</version>
</dependency>

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.3</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

applicationContext.xml

Spring 配置文件

<!-- 指定扫描bean所在的根目录 -->
    <context:component-scan base-package="me.spring.test" />
    <!-- 使用注解注册spring bean -->
    <context:annotation-config />
    <!-- 导入redis配置文件 -->
    <context:property-placeholder location="classpath:redis.properties" />
    <!-- redis连接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <!-- redis连接工厂配置 -->
    <bean id="connectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}" />
        <property name="port" value="${redis.port}" />
        <property name="password" value="${redis.pass}" />
        <property name="timeout" value="${redis.timeout}"/>
        <property name="poolConfig" ref="poolConfig" />
    </bean>
    <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    <!-- redisTemplate -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer" ref="stringRedisSerializer" />
        <property name="hashKeySerializer" ref="stringRedisSerializer" />
    </bean>

redis.properties

Redis连接配置

redis.host=localhost
redis.port=6379
redis.pass=
redis.maxIdle=600
redis.maxActive=500
redis.maxWait=1000
redis.timeout=0
redis.testOnBorrow=true

实体User

public class User  {
    private Integer id;
    private String username;
    private String password;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password="
                + password + "]";
    }
}

测试

RedisTemplateTest

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class RedisTemplateTest {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    // 判断key是否存在
    @Test
    public void redisTemplateHasKeyTest() {
        System.out.println(redisTemplate.hasKey("name"));
    }

    // 设置过期
    @Test
    public void redisTemplateExpireTest() {
        redisTemplate.expire("name", 10, TimeUnit.SECONDS);
    }

    // 删除key
    @Test
    public void redisTemplateDeleteTest() {
        redisTemplate.delete("name");
    }

    // 测试 ValueOperations
    // ValueOperations 是对应Redis string类型
    @Test
    public void valueOperationsTest() {
        ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();
        opsForValue.set("name", "zhangsan");

        String string = opsForValue.get("name");
        System.out.println(string);
    }

    // 测试 HashOperations
    // HashOperations 是对应hash 类型
    @Test
    public void hashOperationsTest() {
        HashOperations<String, Object, Object> opsForHash = redisTemplate.opsForHash();
        opsForHash.put("user", "name", "zhangsan");
        opsForHash.put("user", "age", "20");

        System.out.println(opsForHash.entries("user"));
    }

    // 测试 ListOperations
    // ListOperations 是对应List 类型
    @Test
    public void listOperationsTest() {
        ListOperations<String, String> opsForList = redisTemplate.opsForList();
        opsForList.leftPushAll("color", "red", "blue", "green");

        opsForList
        .range("color", 0, 10)
        .stream()
        .forEach(System.out::println);
    }

    @Test
    public void setOperationsTest() {
        SetOperations<String, String> opsForSet = redisTemplate.opsForSet();
        opsForSet.add("pet", "dog");
        opsForSet.add("pet", "cat");
        opsForSet.add("pet", "fish");

        opsForSet
        .members("pet")
        .stream()
        .forEach(System.out::println);
    }

    @Test
    public void zSetOperationsTest() {
        ZSetOperations<String, String> opsForZSet = redisTemplate.opsForZSet();
        opsForZSet.add("zsetkey", "zsetvalue1", 1);
        opsForZSet.add("zsetkey", "zsetvalue2", 1);
        opsForZSet.add("zsetkey", "zsetvalue3", 1);
        opsForZSet.add("zsetkey", "zsetvalue4", 1);

        opsForZSet
        .rangeByScore("zsetkey", 0, 100)
        .stream()
        .forEach(System.out::println);
    }
}

OperationsTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OperationsTest {

    @Autowired
    private RedisTemplate redisTemplate;

    // 注入RedisTemplate为ValueOperations
    @Resource(name = "redisTemplate")
    private ValueOperations<String, String> opsForValue;

    // 注入RedisTemplate为ListOperations
    @Resource(name = "redisTemplate")
    private ListOperations<String, String> opsForList;

    // 注入RedisTemplate为HashOperations
    @Resource(name = "redisTemplate")
    private HashOperations<String, String, String> opsForHash;

    // 注入RedisTemplate为SetOperations
    @Resource(name = "redisTemplate")
    private SetOperations<String, String> opsForSet;

    // 注入RedisTemplate为ZSetOperations
    @Resource(name = "redisTemplate")
    private ZSetOperations<String, String> opsForZSet;

    @Test
    public void hashOperationsTest() {
        opsForHash.put("key1", "hkey", "hvalue");
        String value = opsForHash.get("key1", "hkey");
        System.out.println(value);
    }

    // 使用BeanUtilsHashMapper转换实体bean,BeanUtilsHashMapper依赖commons-beanutils
    @Test
    public void beanUtilsHashMapperTest() {
        // put
        BeanUtilsHashMapper<User> mapper = new BeanUtilsHashMapper<>(User.class);
        User user = new User();
        user.setId(1);
        user.setUsername("admin");
        user.setPassword("123456");
        Map<String, String> hash = mapper.toHash(user);
        opsForHash.putAll("user", hash);

        // get
        Map<String, String> entries = opsForHash.entries("user");
        User user2 = mapper.fromHash(entries);
        System.out.println(user2);
    }

    // 使用Jackson2HashMapper 转换实体bean
    @Test
    public void jackson2HashMapperTest() {
        //put
        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        Jackson2HashMapper mapper = new Jackson2HashMapper(true);
        HashOperations<String, String, Object> opsForHash = redisTemplate.opsForHash();

        User user = new User();
        user.setId(1);
        user.setUsername("admin");
        user.setPassword("123456");

        Map<String, Object> hash = mapper.toHash(user);
        opsForHash.putAll("user", hash);

        //get
        Map<String, Object> entries = opsForHash.entries("user");
        User getUser = (User) mapper.fromHash(entries);
        System.out.println(getUser);
    }

    @Test
    public void valueOperationsTest() {
        opsForValue.set("vkey", "vvalue");

        String string = opsForValue.get("vkey");
        System.out.println(string);
    }

    //测试 Jackson2JsonRedisSerializer，它使用Jackson将实体bean转换为json
    @Test
    public void jackson2JsonRedisSerializerTest() {
        //set
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(User.class));
        ValueOperations<String, User> opsForValue = redisTemplate.opsForValue();

        User user = new User();
        user.setId(1);
        user.setUsername("admin");
        user.setPassword("123456");

        opsForValue.set("user", user);

        // get
        User getUser = opsForValue.get("user");
        System.out.println(getUser);
    }

    @Test
    public void listOperationsTest() {
        opsForList.leftPush("list", "value1");
        opsForList.leftPushAll("list", "value2", "value3");

        opsForList
        .range("list", 0, 10)
        .stream()
        .forEach(System.out::println);
    }

    @Test
    public void setOperationsTest() {
        opsForSet.add("set1", "value1");
        opsForSet.add("set1", "value2");
        opsForSet.add("set1", "value3");

        opsForSet
        .members("set1")
        .stream()
        .forEach(System.out::println);

    }

    @Test
    public void testZSetOperationsWrite() {
        opsForZSet.add("zsetkey", "zsetvalue1", 1);
        opsForZSet.add("zsetkey", "zsetvalue2", 1);
        opsForZSet.add("zsetkey", "zsetvalue3", 1);
        opsForZSet.add("zsetkey", "zsetvalue4", 1);

        opsForZSet
        .rangeByScore("zsetkey", 0, 100)
        .stream()
        .forEach(System.out::println);
    }

}

以上均测试通过。