Redis笔记（六）：Java中使用Redis

朝雨忆轻尘

发布于 2019-06-19 15:37:54

5400

发布于 2019-06-19 15:37:54

文章被收录于专栏：朝雨忆轻尘朝雨忆轻尘

Java程序使用Redis

添加依赖包

Maven依赖方式

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

下载Jar包方式

下载地址： http://central.maven.org/maven2/redis/clients/jedis/2.9.0/jedis-2.9.0.jar

代码使用示例

package com.louis.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestRedis {

    private static  Jedis jedis;

    static {
        // 连接服务器，这里是本地
        jedis = new Jedis("127.0.0.1", 6379);
        // 如果需要，进行权限认证
//      jedis.auth("");
    }

    // 字符串操作
    @Test
    public void testString() {
        jedis.set("name", "张扬");
        System.out.println( jedis.get("name") );
        // 追加操作
        jedis.append("name", "林语谣");
        System.out.println( jedis.get("name") );
        // 删除键
        Long result = jedis.del("name");
        System.out.println( result ); //返回Long型  1表示成功0失败
        // 设置多个键值对
        jedis.mset("name","敏敏", "city","上海");
        // 获取多个键,返回一个列表类型
        System.out.println( jedis.mget("name", "city"));

    }

    // 哈希操作Hash
    @Test
    public void testHash() {
        Map<String,String> map = new HashMap<String,String>();
        map.put("name", "张扬");
        map.put("age", "20");
        // 存储数据
        jedis.hmset("user", map);
        // 读取数据  返回一个列表类型 [张扬, 20]
        System.out.println( jedis.hmget("user", "name","age") );
        // HKEYS key 获取所有哈希表中的字段，返回一个列表[name, age]
        System.out.println( jedis.hkeys("user") );
        // HVALS key，获取哈希表中所有值
        System.out.println( jedis.hvals("user") );
        // HLEN key，获取哈希表中字段的数量
        System.out.println( jedis.hlen("user") );
        // 获取所有的键，迭代操作
        Iterator<String> iter = jedis.hkeys("user").iterator();
        while(iter.hasNext()) {
            String key = iter.next();
            System.out.println( key+"--"+jedis.hmget("user", key) );
        }

    }

    // List操作
    @Test
    public void testList() {
　　　　 // LPUSH key value1 [value2] 将一个或多个值插入到列表头部
        jedis.lpush("Programming language", "Java");
        jedis.lpush("Programming language", "Python");
        jedis.lpush("Programming language", "C++");
        // 获取数据  返回一个list [Python, Java]
        // 第一个是key，第二个是起始位置，第三个是结束位置  
        // 其中0表示列表的第一个元素， 1表示列表的第二个元素，以此类推。 
        // 你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。
        System.out.println( jedis.lrange("Programming language",  0, -1) );
        // LPUSHX key value 将一个值插入到已存在的列表头部
        jedis.lpushx("Programming language", "php");
        System.out.println( jedis.lrange("Programming language",  0, -1) );
        // RPUSH key value1 [value2] 在列表中添加一个或多个值
        jedis.rpush("Programming language", "C");
        System.out.println( jedis.lrange("Programming language",  0, -1) );
        // 输出情况
　　　　 // [C++, Python, Java]
　　　　 // [php, C++, Python, Java]
　　　　 // [php, C++, Python, Java, C]
    }


    // Set操作
    @Test
    public void testSet() {
        // 向集合添加一个或多个成员
        jedis.sadd("webSite", "阿里巴巴","网易");
        jedis.sadd("webSite", "腾讯");
        // SCARD key 获取集合的成员数
        System.out.println( jedis.scard("webSite") );
        // SMEMBERS key 返回集合中的所有成员，返回类型列表[阿里巴巴, 腾讯, 网易]注意顺序不唯一
        System.out.println( jedis.smembers("webSite") );
        // SSCAN key cursor [MATCH pattern] [COUNT count] 迭代集合中的元素
        System.out.println(jedis.sscan("webSite", "0") );


    }

    // sorted set有序Set
    @Test
    public void testSortSet() {
　　　　 // Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
　　　　 // 不同的是每个元素都关联一个double类型的分数，redis通过次分数来为集合中的成员进行从小到大的排序。
　　　　 // 有序集合的成员是唯一的,但分数(score)却可以重复。
        jedis.zadd("city", 0, "北京");
        jedis.zadd("city", 1, "上海");
        jedis.zadd("city", 2, "杭州");

        // ZCARD key 获取有序集合的成员数
        System.out.println( jedis.zcard("city") );
        // ZREVRANK key member 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序，
　　　　 // java中的方法是zrevrangeByScore
        System.out.println( jedis.zrevrangeByScore("city", 5, 0) );
    }
}

Spring Boot集成Redis

1.新建Spring Boot项目

添加spring-boot-starter-data-redis依赖

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

本文会根据StringRedisTemplate、RedisTemplate这两个模板来介绍，其中StringRedisTemplate继承自RedisTemplate，只能操作键值都是String类型的数据。在实际开发中建议使用RedisTemplate<K,V>。

查询源码可知RedisTemplate默认使用JdkSerializationRedisSerializer序列化，而StringRedisTemplate则使用StringRedisSerializer。

2.配置redis

在application.properties中配置如下：

########################################################
###Redis (RedisConfiguration)
########################################################
spring.redis.database=1
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.timeout=5000

3.编写代码

1.创建model

package com.haq.entity;

import java.io.Serializable;

/**
 * Created by on 2017/2/24.
 */
public class User implements Serializable {

    private static final long serialVersionUId = 1L;

    private String id;
    private String name;

    public User(){
        super();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

2.创建RedisService

package com.haq.common.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * Created by on 2017/3/1.
 */
@Service
public class RedisService {

    @Autowired
    StringRedisTemplate stringRedisTemplate;


    @Resource(name = "stringRedisTemplate")
    ValueOperations<String, String> valOpsStr;

    @Autowired
    RedisTemplate<Object, Object> redisTemplate;

    @Resource(name = "redisTemplate")
    ValueOperations<Object, Object> valOpsObj;

    /**
     * 根据指定key获取String
     * @param key
     * @return
     */
    public String getStr(String key){
        return valOpsStr.get(key);
    }

    /**
     * 设置Str缓存
     * @param key
     * @param val
     */
    public void setStr(String key, String val){
        valOpsStr.set(key,val);
    }

    /**
     * 删除指定key
     * @param key
     */
    public void del(String key){
        stringRedisTemplate.delete(key);
    }

    /**
     * 根据指定o获取Object
     * @param o
     * @return
     */
    public Object getObj(Object o){
        return valOpsObj.get(o);
    }

    /**
     * 设置obj缓存
     * @param o1
     * @param o2
     */
    public void setObj(Object o1, Object o2){
        valOpsObj.set(o1, o2);
    }

    /**
     * 删除Obj缓存
     * @param o
     */
    public void delObj(Object o){
        redisTemplate.delete(o);
    }

}

3.创建RedisController

package com.haq.web;

import com.haq.common.redis.RedisService;
import com.haq.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by on 2017/3/1.
 */
@RestController
@RequestMapping("/redis")
public class RedisController {

    @Autowired
    RedisService redisService;

    /**
     * 设置Str缓存
     * @param key
     * @param val
     * @return
     */
    @RequestMapping(value = "setStr")
    public String setStr(String key, String val){
        try {
            redisService.setStr(key, val);
            return "success";
        } catch (Exception e){
            e.printStackTrace();
            return "error";
        }
    }

    /**
     * 根据key查询Str缓存
     * @param key
     * @return
     */
    @RequestMapping(value = "getStr")
    public String getStr(String key){
        return redisService.getStr(key);
    }


    /**
     * 根据key产出Str缓存
     * @param key
     * @return
     */
    @RequestMapping(value = "delStr")
    public String delStr(String key){
        try {
            redisService.del(key);
            return "success";
        } catch (Exception e){
            return "error";
        }
    }


    /**
     * 设置obj缓存
     * @param key
     * @param user
     * @return
     */
    @RequestMapping(value = "setObj")
    public String setObj(String key, User user){
        try {
            redisService.setObj(key, user);
            return "success";
        } catch (Exception e){
            e.printStackTrace();
            return "error";
        }
    }

    /**
     * 获取obj缓存
     * @param key
     * @return
     */
    @RequestMapping(value = "getObj")
    public Object getObj(String key){
        return redisService.getObj(key);
    }


    /**
     * 删除obj缓存
     * @param key
     * @return
     */
    @RequestMapping(value = "delObj")
    public Object delObj(String key){
        try {
            redisService.delObj(key);
            return "success";
        } catch (Exception e){
            e.printStackTrace();
            return "error";
        }
    }

}

4.运行测试