Java 操作 Redis 五種數據類型

項目添加依賴

　　　　　<!-- Redis 依賴 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
            

Java 怎么連接 Redis

//連接 Redis
    @Test
    public void initConn01(){
        System.out.println("==========================");
        System.out.println("==========================");
        System.out.println("==========================");
        // 創建 jedis 對象，連接 redis 服務
        Jedis jedis=new Jedis("192.168.75.163",6379);
        // 設置認證密碼
        //jedis.auth("root");
        // 指定數據庫 默認是 0
        jedis.select(1);
        // 使用 ping 命令，測試連接是否成功
        String result=jedis.ping();
        System.out.println(result);// 返回 PONG
        // 添加一條數據
        jedis.set("username","zhangsan");
        // 獲取一條數據
        String username=jedis.get("username");
        System.out.println(username);
        // 釋放資源
        if(jedis!=null){
            jedis.close();
        }
    }

看下輸出結果

 

 

 通過 Redis 連接池獲取連接對象並操作服務器

private String host ="192.168.75.163";
private Integer port=6379;

@Test
    public void initConn02() {
        // 初始化 redis 客戶端連接池
        JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), host, port, 10000);
        // 從連接池獲取連接
        Jedis jedis = jedisPool.getResource();
        // 指定數據庫 默認是 0
        jedis.select(2);
        // 使用 ping 命令，測試連接是否成功
        String result = jedis.ping();
        System.out.println(result);// 返回 PONG
        // 添加一條數據
        jedis.set("username", "zhangsan");
        // 獲取一條數據
        String username = jedis.get("username");
        System.out.println(username);
        // 釋放資源
        if (jedis != null)
            jedis.close();
    }

封裝 JedisUtil 對外提供連接對象獲取方法

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
 * 實例化 Jedis 對象工具類
 */
public final class JedisUtil {
    //Redis 服務器 IP
    private static String ADDR = "192.168.75.163";
    //Redis 的端口號
    private static int PORT = 6379;
    //訪問密碼
    private static String AUTH = "root";
    //可用連接實例的最大數目，默認值為 8；
    //如果賦值為-1，則表示不限制；如果 pool 已經分配了 maxActive 個 jedis 實例，則此時 pool 的狀態為 exhausted(耗盡)。
    private static int MAX_ACTIVE = 1024;
    //控制一個 pool 最多有多少個狀態為 idle(空閑的)的 jedis 實例，默認值也是 8。
    private static int MAX_IDLE = 200;
    //等待可用連接的最大時間，單位毫秒，默認值為-1，表示永不超時。如果超過等待時間，則直接拋出 JedisConnectionException；
    private static int MAX_WAIT = 10000;
    private static int TIMEOUT = 10000;
    //在 borrow 一個 jedis 實例時，是否提前進行 validate 操作；如果為 true，則得到的 jedis 實例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    private static JedisPool jedisPool = null;
    /**
     * 初始化 Redis 連接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            //jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 獲取 Jedis 實例
     *
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null)
                return jedisPool.getResource();
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 釋放 jedis 資源
     *
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.close();
        }
    }
}

Java 操作 Redis 五種數據類型

連接與釋放

Jedis jedis = null;
    /**
     * 連接 Redis
     */
    @Before
    public void initConn() {
        jedis = JedisUtil.getJedis();
    }
    /**
     * 釋放資源
     */
    @After
    public void close() {
        JedisUtil.returnResource(jedis);
    }

1、操作 String

　　@Test
    public void testString() {
        // 添加一條數據
        jedis.set("username", "zhangsan");
        jedis.set("age", "18");
        // 添加多條數據 參數奇數為 key 參數偶數為 value
        jedis.mset("address", "bj", "sex", "1");
        // 獲取一條數據
        String username = jedis.get("username");
        System.out.println(username);
        // 獲取多條數據
        List<String> list = jedis.mget("username", "age", "address", "sex");
        for (String str : list) {
            System.out.println(str);
        }
        // 刪除
        //jedis.del("username");
    }

看下結果

 

 

 

2、操作 hash

@Test
    public void testHash() {
        /*
         * 添加一條數據
         * 參數一：redis 的 key
         * 參數二：hash 的 key
         * 參數三：hash 的 value
         */
        jedis.hset("userInfo", "name", "lisi");
        // 添加多條數據
        Map<String, String> map = new HashMap<>();
        map.put("age", "20");
        map.put("sex", "1");
        jedis.hmset("userInfo", map);
        // 獲取一條數據
        String name = jedis.hget("userInfo", "name");
        System.out.println(name);
        // 獲取多條數據
        List<String> list = jedis.hmget("userInfo", "age", "sex");
        for (String str : list) {
            System.out.println(str);
        }
        // 獲取 Hash 類型所有的數據
        Map<String, String> userMap = jedis.hgetAll("userInfo");
        for (Map.Entry<String, String> userInfo : userMap.entrySet()) {
            System.out.println(userInfo.getKey() + "--" + userInfo.getValue());
        }
        // 刪除 用於刪除 hash 類型數據
        //jedis.hdel("userInfo", "name");
    }

看下結果

 

 

 3、操作 list

@Test
    public void testList() {
        // 左添加(上)
        jedis.lpush("students", "Wang Wu", "Li Si");
        // 右添加(下)
        jedis.rpush("students", "Zhao Liu");
        // 獲取 start 起始下標 end 結束下標 包含關系
        List<String> students = jedis.lrange("students", 0, 2);
        for (String stu : students) {
            System.out.println(stu);
        }
        // 獲取總條數
        Long total = jedis.llen("students");
        System.out.println("總條數：" + total);
        // 刪除單條 刪除列表中第一次出現的 Li Si
        // jedis.lrem("students", 1, "Li Si");
        // 刪除多條
        // jedis.del("students");
    }

看下結果

 

 

 

4、操作 set

@Test
    public void testSet() {
        // 添加數據
        jedis.sadd("letters", "aaa", "bbb", "ccc", "ddd", "eee");
        // 獲取數據
        Set<String> letters = jedis.smembers("letters");
        for (String letter: letters) {
            System.out.println(letter);
        }
        // 刪除
        //jedis.srem("letters", "aaa", "bbb");
    }

看下結果

 

 

 

5、操作 sorted set -有序

@Test
    public void testSortedSet() {
        Map<String, Double> scoreMembers = new HashMap<>();
        scoreMembers.put("zhangsan", 99D);
        scoreMembers.put("lisi", 96D);
        scoreMembers.put("wangwu", 92D);
        scoreMembers.put("zhaoliu", 100D);
        scoreMembers.put("tianqi", 95D);
        // 添加數據
        jedis.zadd("score", scoreMembers);
        // 獲取數據
        Set<String> scores = jedis.zrange("score", 0, 4);
        for (String score: scores) {
            System.out.println(score);
        }
        // 獲取總條數
        Long total = jedis.zcard("score");
        System.out.println("總條數：" + total);
        // 刪除
        //jedis.zrem("score", "zhangsan", "lisi");
    }

看下結果

 

 

 6、Redis 中以層級關系、目錄形式存儲數據

@Test
    public void test() {
        // Redis 中以層級關系、目錄形式存儲數據
        jedis.set("user:01", "user_zhangsan");
        jedis.set("user:02", "user_lisi");
        System.out.println(jedis.get("user:01"));
    }

看下結果

 

 

 

 

 

 7、獲取所有 key&事務&刪除

// 獲取所有 key
    @Test
    public void testAllKeys() {
        // 當前庫 key 的數量
        System.out.println(jedis.dbSize());
        // 當前庫 key 的名稱
        Set<String> keys = jedis.keys("*");
        for (String key: keys) {
            System.out.println(key);
        }
    }
    // 操作事務
    @Test
    public void testMulti() {
        Transaction tx = jedis.multi();
        // 開啟事務
        tx.set("tel", "10010");
        // 提交事務
        // tx.exec();
        // 回滾事務
        tx.discard();
    }
    // 刪除
    @Test
    public void testDelete() {
        // 刪除 通用 適用於所有數據類型
        jedis.del("score");
    }

8、操作 byte

實體類user

import java.io.Serializable;
public class User implements Serializable {
    private static final long serialVersionUID = 9148937431079191022L;
    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 + '\'' +
                '}';
    }
}

序列化工具類

/**
 * 序列化工具類
 */
public class SerializeUtil {

    /**
     * 將 java 對象轉換為 byte 數組 序列化過程
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 將 byte 數組轉換為 java 對象 反序列化
     */
    public static Object unserialize(byte[] bytes) {
        if(bytes == null)return null;
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

操作 byte

@Test
    public void testByte() {
        User user = new User();
        user.setId(2);
        user.setUsername("zhangsan");
        user.setPassword("123");
        // 序列化
        byte[] userKey = SerializeUtil.serialize("user:" + user.getId());
        byte[] userValue = SerializeUtil.serialize(user);
        jedis.set(userKey, userValue);
        // 獲取數據
        byte[] userResult = jedis.get(userKey);
        // 反序列化
        User u = (User) SerializeUtil.unserialize(userResult);
        System.out.println(u);
    }

看下結果