java redis 获取添加时间 java redis获取所有key

项目添加依赖

<!-- 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);
    }

看下结果