Redis入门-Java操作Redis

一、Java集成Jedis

1、创建工程

搭建普通java项目，项目名：jedis-demo

2、导入Jedis依赖

• 把Jedis和连接池包下载后导入

commons-pool2-2.2.jar        #连接池
jedis-2.5.2.jar                #Jedis核心包

• 或者使用maven导入

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

3、编写测试类测试

@Test
    public void hello() {
        /*连接host  端口  超时时间*/
        Jedis jedis = new Jedis("127.0.0.1", 6379, 2000);
        /*认证登录密码*/
        jedis.auth("123123");
        /*设置值*/
        jedis.set("name","老王");
        /*取出打印*/
        System.out.println(jedis.get("name"));
        /*关闭连接*/
        jedis.close();
    }

4、连接池的使用

如果直接使用 Jedis链接Redis会造成频繁的Jedis对象创建和销毁，对性能会有很大的影响，所以我们会选择使用连接池来链接性能。原理同Mysql连接池

• 编写测试方法，使用JedisPool连接池对象

@Test
    public void hello1() {
        /*连接池配置*/
        JedisPoolConfig config = new JedisPoolConfig();
        /*最大等待时间*/
        config.setMaxWaitMillis(1000);
        /*最大空闲连接*/
        config.setMaxIdle(2);
        /*最大连接数*/
        config.setMaxTotal(8);
        /*获取连接时测试连接是否畅通*/
        config.setTestOnBorrow(true);
        /*创建jedis连接池   连接池配置  连接host  端口  超时时间  登录密码*/
        JedisPool jedisPool = new JedisPool(config,"127.0.0.1",6379,1000,"123123");
        /*获取连接客户端*/
        Jedis jedis = jedisPool.getResource();
        /*设置值*/
        jedis.set("name","ww");
        /*取出打印*/
        System.out.println(jedis.get("name"));
    }

• 工具类封装：JedisPool应该是单例的(想想你的Mybatis的DataSource也只是创建了一个)，为了方便使用，将JedisPool封装成工具。

redis.properties

redis.host=127.0.0.1
redis.port=6379
redis.password=123456
redis.timeout=5000

RedisUtils

package org.example;

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

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * 获取连接池对象
 */
public enum RedisUtils {

    INSTANCE;

    //连接池
    static JedisPool jedisPool = null;

    static {
        //1 创建连接池配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //2 进行配置-四个配置
        config.setMaxIdle(1);//最小连接数
        config.setMaxTotal(11);//最大连接数
        config.setMaxWaitMillis(10 * 1000L);//最长等待时间
        config.setTestOnBorrow(true);//测试连接时是否畅通
        //3 通过配置对象创建连接池对象
        Properties properties = null;
        try {
            properties = new Properties();
            properties.load(RedisUtils.class.getClassLoader().getResourceAsStream("redis.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        String host = properties.getProperty("redis.host");
        String port = properties.getProperty("redis.port");
        String password = properties.getProperty("redis.password");
        String timeout = properties.getProperty("redis.timeout");

        jedisPool = new JedisPool(config, host, Integer.valueOf(port),Integer.valueOf(timeout), password);
    }

    //获取连接
    public Jedis getSource() {
        return jedisPool.getResource();
    }

    //关闭资源
    public void closeSource(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }

    }

    /**
     * hash操作字符串==============================================
     */
    public List<String> hvals(String key) {
        Jedis jedis = getSource();
        List<String> hvals = jedis.hvals(key);
        closeSource(jedis);
        return hvals;
    }
    public Set<String> hkeys(String key) {
        Jedis jedis = getSource();
        Set<String> hkeys = jedis.hkeys(key);
        closeSource(jedis);
        return hkeys;
    }

    public Long hset(String key,String field,String value) {
        Jedis jedis = getSource();
        Long result = jedis.hset(key,field,value);
        closeSource(jedis);
        return result;
    }
    public String hmset(String key, Map<String,String> data) {
        Jedis jedis = getSource();
        String result = jedis.hmset(key,data);
        closeSource(jedis);
        return result;
    }
    public String hget(String key,String field) {
        Jedis jedis = getSource();
        String value = jedis.hget(key, field);
        closeSource(jedis);
        return value;
    }
    /**
     * hash操作byte[]==============================================
     */
    public List<byte[]> hvals(byte[] key) {
        Jedis jedis = getSource();
        List<byte[]> hvals = jedis.hvals(key);
        closeSource(jedis);
        return hvals;
    }
    public Set<byte[]> hkeys(byte[] key) {
        Jedis jedis = getSource();
        Set<byte[]> hkeys = jedis.hkeys(key);
        closeSource(jedis);
        return hkeys;
    }

    public Long hset(byte[] key,byte[] field,byte[] value) {
        Jedis jedis = getSource();
        Long result = jedis.hset(key,field,value);
        closeSource(jedis);
        return result;
    }
    public String hmset(byte[] key, Map<byte[],byte[]> data) {
        Jedis jedis = getSource();
        String result = jedis.hmset(key,data);
        closeSource(jedis);
        return result;
    }
    public byte[] hget(byte[] key,byte[] field) {
        Jedis jedis = getSource();
        byte[] value = jedis.hget(key, field);
        closeSource(jedis);
        return value;
    }


    /**
     * 删除key
     */
    public boolean del(String key) {
        Jedis jedis = getSource();
        long result  = jedis.del(key);
        closeSource(jedis);
        return result > 0;
    }

    /**
     * 设置字符值
     *
     * @param key
     * @param value :value是字符串，如果要存储对象，转成JSON字符串在存储
     */
    public void set(String key, String value) {
        Jedis jedis = getSource();
        jedis.set(key, value);
        closeSource(jedis);
    }

    /**
     * 设置
     * @param key
     * @param value
     */
    public void set(byte[] key, byte[] value) {
        Jedis jedis = getSource();
        jedis.set(key, value);
        closeSource(jedis);
    }

    /**
     *
     * @param key
     * @return
     */
    public byte[]  get(byte[] key) {
        Jedis jedis = getSource();
        try {
            return jedis.get(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeSource(jedis);
        }
        return null;

    }

    /**
     * 设置字符值
     *
     * @param key
     * @return ：返回的是JSON格式的字符串 ，考虑转对象
     */
    public String get(String key) {
        Jedis jedis = getSource();
        try {
            return jedis.get(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeSource(jedis);
        }

        return null;
    }
}

二、Jedis的API操作

使用jedis来操作redis的key和value，而value有很多种类型，和命令操作一样。

1、key的操作

System.out.println(jedis.keys("*"));

2.String的操作

System.out.println(jedis.set("name","zhangsan"));//新增
System.out.println(jedis.get("name"));//获取
System.out.println(jedis.set("name","zhangsan1"));//修改
System.out.println(jedis.get("name"));//获取
System.out.println(jedis.del("name"));//删除
System.out.println(jedis.keys("*"));//查看所有的key

3.List的操作

jedis.lpush("students1","1","2","3","5","6");    //添加数据
System.out.println(jedis.lrange("students1", 0, 3));    //获取数据

排序操作，对于数字元素排序不需要加SortingParams，对于字符串需要指定SortingParams，并且指定使用assii值排序 

//清空当前数据库
jedis.flushDB();
//对数字排序
//添加数据
jedis.lpush("nums","1","2","3","4","8","5","3","1");
//排序
System.out.println(jedis.sort("nums"));
//指定排序方式
SortingParams sortingParams1 = new SortingParams();
sortingParams1.desc();
System.out.println(jedis.sort("nums", sortingParams1));

//对字母排序
jedis.lpush("langues","java","php","c++","test","ui");
SortingParams sortingParams = new SortingParams();
sortingParams.alpha();
sortingParams.desc();

System.out.println(jedis.sort("langues",sortingParams));

4、Set的操作

jedis.sadd("students2","a1","b1","c1","b1");        //添加数据
System.out.println(jedis.smembers("students2"));    //获取成员

5、Hash操作

jedis.hset("students3","student","zhangsan");			//添加数据
System.out.println(jedis.hget("students3", "student"));	 //获取数据

6.Hash存储对象

序列化SerializeUtil.java

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

public class SerializeUtil {
    /**
     * 序列化
     * 
     * @param object
     * @return
     */
    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) {

        }
        return null;
    }

    /**
     * 反序列化
     * 
     * @param bytes
     * @return
     */
    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {

        }
        return null;
    }
}

实体类User.java

import java.io.Serializable;

public class User implements Serializable {

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

    private String username;
    private Long id;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Long getId() {
        return id;
    }

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

    public User() {
    }

    public User(String username, Long id) {
        this.username = username;
        this.id = id;
    }
}

测试

import com.alibaba.fastjson.JSON;
import org.junit.Test;

import java.util.*;

public class RedisTest {


    private User createUser(){
        return new User("zs",1L);
    }

    private List<User> createUsers(){
        return Arrays.asList(
                new User("zs",1L),
                new User("zs",2L),
                new User("zs",3L),
                new User("zs",4L),
                new User("zs",5L),
                new User("zs",6L));
    }

    //查询所有的用户
    //根据id查询某个用户
    @Test
    public void test(){

        //存放====================================================================
        List<User> users = createUsers();

        Map<String,String> data = new HashMap<>(users.size());

        users.forEach(user -> {
            data.put(user.getId().toString(),JSON.toJSONString(user));
        });

        String hmsetResult = RedisUtils.INSTANCE.hmset("users", data);
        System.out.println(hmsetResult);
        RedisUtils.INSTANCE.hset("users","7",JSON.toJSONString(new User("zs",7L)));

        //取所有值==================================================================
        List<String> values = RedisUtils.INSTANCE.hvals("users");
        List<User> result  = new ArrayList<>(values.size());
        values.forEach(value ->{
            result.add(JSON.parseObject(value,User.class));
        });
        System.out.println(values);

        //根据ID取User==============================================================

        String user = RedisUtils.INSTANCE.hget("users","1");
        System.out.println(user);
    }

    //查询所有的用户
    //根据id查询某个用户
    @Test
    public void test2(){

        //存放====================================================================
        List<User> users = createUsers();

        Map<byte[],byte[]> data = new HashMap<>(users.size());

        users.forEach(user -> {
            data.put(user.getId().toString().getBytes(),SerializeUtil.serialize(user));
        });

        String hmsetResult = RedisUtils.INSTANCE.hmset("users".getBytes(), data);
        System.out.println(hmsetResult);
        RedisUtils.INSTANCE.hset("users".getBytes(),"7".getBytes(),SerializeUtil.serialize(new User("zs",7L)));

        //取所有值==================================================================
        List<byte[]> values = RedisUtils.INSTANCE.hvals("users".getBytes());
        List<User> result  = new ArrayList<>(values.size());
        values.forEach(value ->{
            result.add(((User)SerializeUtil.unserialize(value)));
        });
        System.out.println(result);

        //根据ID取User==============================================================

        byte[] user = RedisUtils.INSTANCE.hget("users".getBytes(),"7".getBytes());
        System.out.println(SerializeUtil.unserialize(user));
    }


    //查询所有的用户
    //根据id查询某个用户
    @Test
    public void test3(){

        //存放====================================================================
        RedisUtils.INSTANCE.hset("users".getBytes(),"7".getBytes(),SerializeUtil.serialize(new User("zs",7L)));


        //根据ID取User==============================================================

        byte[] user = RedisUtils.INSTANCE.hget("users".getBytes(),"7".getBytes());
        System.out.println(SerializeUtil.unserialize(user));
    }
}

7.事务操作

jedis.set("name","zs");
jedis.set("age",18);

//开启事务
Transaction multi = jedis.multi();
multi.incr("name");
multi.incr("age");
//提交事务
List<Object> result = multi.exec();
System.out.println(result);

//关闭连接
jedis.close();

//关闭连接池
pool.destory();