项目添加依赖

     <!-- 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

[email protected] 
    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); 
    }

看下结果

 

发布评论

分享到:

IT源码网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

Redis入门--1.安装Redis讲解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。