简单的基于Redis实现的队列

简单的基于Redis实现的队列

package com.example.springbatchdemo.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


/**
 * @author v_tianwenkai
 * @since 2021/3/31 15:22
 */
public class JedisUtil {
    private static String JEDIS_IP;
    private static int JEDIS_PORT;
    private static String JEDIS_PASSWORD;
    private static JedisPool jedisPool;

    static {

        JEDIS_IP = "ip地址";
        JEDIS_PORT = 6379;
        JEDIS_PASSWORD = "123456";
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(256);
        config.setTestOnBorrow(true);
        config.setTestOnReturn(true);
        config.setTestWhileIdle(true);
        config.setMinEvictableIdleTimeMillis(60000L);
        config.setTimeBetweenEvictionRunsMillis(3000L);
        config.setNumTestsPerEvictionRun(-1);
        jedisPool = new JedisPool(config, JEDIS_IP, JEDIS_PORT, 60000, JEDIS_PASSWORD);

    }

    /**
     * 存储REDIS队列 顺序存储
     *
     * @param key   reids键名
     * @param value 键值
     */
    public static void lpush(byte[] key, byte[] value) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.lpush(key, value);
        } catch (Exception e) {
            //释放redis对象
            /**
             * 下面我们来说说Jedis相关的特性，redis.clients.jedis.Jedis这个这个客户端实例不是线程安全的，
             * 所以需要自行保证线程安全，redis.clients.jedis.JedisPool连接池是线程安全的，
             * 或者说其提供的getResource()方法是线程安全的，所以在封装工具类的时候不需要再使用同步手段了
             */
            //jedisPool.returnBrokenResource(jedis);
            jedis.close();
            e.printStackTrace();
        } finally {
            //返还到连接池
            close(jedis);
        }
    }

    /**
     * 存储REDIS队列 反向存储
     *
     * @param key   reids键名
     * @param value 键值
     */
    public static void rpush(byte[] key, byte[] value) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.rpush(key, value);
        } catch (Exception e) {
            //释放redis对象
            jedis.close();
            e.printStackTrace();
        } finally {
            //返还到连接池
            close(jedis);
        }
    }

    /**
     * 获取队列数据
     *
     * @param key 键名
     * @return
     */
    public static byte[] rpop(byte[] key) {

        byte[] bytes = null;
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            bytes = jedis.rpop(key);
        } catch (Exception e) {
            //释放redis对象
            jedis.close();
            e.printStackTrace();
        } finally {
            //返还到连接池
            close(jedis);
        }
        return bytes;
    }

    private static void close(Jedis jedis) {
        try {
            jedis.close();
        } catch (Exception e) {
            if (jedis.isConnected()) {
                jedis.quit();
                jedis.disconnect();
            }
        }
    }
}
```java
package com.example.springbatchdemo.redis;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * @author v_tianwenkai
 * @since 2021/3/31 15:20
 */
public class ObjectUtil {
    public static byte[] object2Bytes(Object obj) throws IOException {
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(obj);
        byte[] bytes = bo.toByteArray();
        bo.close();
        oo.close();
        return bytes;
    }

    public static Object bytes2Object(byte[] bytes) throws Exception {
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        ObjectInputStream sIn = new ObjectInputStream(in);
        return sIn.readObject();
    }

}
```java
package com.example.springbatchdemo.redis.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import java.io.Serializable;

/**
 * @author v_tianwenkai
 * @since 2021/3/31 15:19
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Message implements Serializable {
    private Integer id;
    private String content;
}
```java
package com.example.springbatchdemo.redis;

import com.example.springbatchdemo.redis.pojo.Message;

import java.io.IOException;

/**
 * @author v_tianwenkai
 * @since 2021/3/31 15:32
 */
public class TestRedisQueue {
    public static byte[] redisKey = "key".getBytes();

    static {
        try {
            init();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //初始存入1000个消息到队列
    private static void init() throws IOException {
        for (int i = 0; i < 1000; i++) {
            Message message = new Message(i, "这是第" + i + "个内容");
            JedisUtil.lpush(redisKey, ObjectUtil.object2Bytes(message));
        }
    }

    //每运行一次取出100个消息
    public static void main(String[] args) {
        try {
            for (int i = 0; i < 100; i++) {
                pop();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void pop() throws Exception {
        byte[] bytes = JedisUtil.rpop(redisKey);
        Message msg = (Message) ObjectUtil.bytes2Object(bytes);
        if (msg != null) {
            System.out.println(msg.getId() + "----" + msg.getContent());
        }

    }
}