redis-jedis实例

学自：b站的博主：“一岁就会编程”的在线智能办公系统的教学视频

创建一个Spring Boot项目

依赖可以自己导入或创建时添加上

 pom文件添加依賴

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <!--
            1.x的版本默认采用的连接池技术是Jedis。
            2.0以上版本默认连接池是Lettuce。
            如果采用Jedis，需要排除Lettuce的依赖。
            -->
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--Jedis依賴-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

application.properties文件里添加

#Redis服务器地址
spring.redis.host=xxx.xxx.xxx.xxx
#Redis服务器端口
spring.redis.port= 6379
#Redis服务器密码
spring.redis.password= xxxx
#选择哪个库，默认0库
spring.redis.database=1
#选择超时时间
spring.redis.timeout=10000ms
#最大连接数，默认8
spring.redis.jedis.pool.max-active=1024
#最大连接阻塞等待时间，单位毫秒，默认 -1ms
spring.redis.jedis.pool.max-wait=10000ms
#最大空闲连接数，默认8
spring.redis.jedis.pool.max-idle=200
#最小空闲数连接，默认0
spring.redis.jedis.pool.min-idle=5

RedisConfig.java

@Configuration
public class RedisConfig {
    //服务器地址
    @Value("${spring.redis.host}")
    private String host;
    //服务器端口
    @Value("${spring.redis.port}")
    private int port;
    //访问密码
    @Value("${spring.redis.password}")
    private String password;
    //连接超时时间
    @Value("${spring.redis.timeout}")
    private String timeout;
    //最大连接数
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxTotal;
    //最大连接阻塞等待时间
    @Value("${spring.redis.jedis.pool.max-wait}")
    private String maxWaitMillis;
    //最大空闲连接
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIddle;
    //最小空闲连接
    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Bean
    public JedisPool getJedisPool(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接数
        jedisPoolConfig.setMaxTotal(maxTotal);
        //最大连接阻塞等待时间
        jedisPoolConfig.setMaxWaitMillis(Long.valueOf(maxWaitMillis.substring(0,maxWaitMillis.length()-2)));
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(maxIddle);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(minIdle);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,Integer.valueOf(timeout.substring(0,timeout.length()-2)),password);
        return jedisPool;
    }
}

User.java

public class User implements Serializable {

    private static final long serialVerionUID = 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 + '\'' +
                '}';
    }
}

SerializeUtil.java

/*
* 序列化工具
* */
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 (IOException 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 (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Test测试类

@SpringBootTest
@RunWith(SpringRunner.class)
public  class RedisJedisApplicationTests {

    /*
    * 连接Redis
    * */
//    @Test
//    void contextLoads() {
//        //初始化连接
//        //创建jedis对象，连接redis对象
//        Jedis jedis = new Jedis("10.74.3.107",6379);
//        //设置认证密码
//        jedis.auth("Redis1234");
//        //指定数据库，默认为0
//        jedis.select(1);
//        //使用ping命令，测试连接是否成功
//        String result = jedis.ping();
//        System.out.println(result);
//        //添加一条数据
//        jedis.set("name","zhangsan");
//        //获取一条数据
//        String name = jedis.get("name");
//        System.out.println(name);
//        //释放资源
//        if(jedis != null){
//            jedis.close();
//        }
//    }

    /*
    * jedis连接池操作redis
    * */
//    @Test
//    void initCont02(){
//        //初始化jedis连接池对象
//        JedisPool jedisPool = new JedisPool(new JedisPoolConfig(),"10.74.3.107",6379,1000,"Redis1234");
//        //从连接池获取jedis对象
//        Jedis jedis = jedisPool.getResource();
//        //指定数据库，默认为0
//        jedis.select(2);
//        //使用ping命令，测试连接是否成功
//        String result = jedis.ping();
//        System.out.println(result);
//        //添加一条数据
//        jedis.set("name","zhangsan");
//        //获取一条数据
//        String name = jedis.get("name");
//        System.out.println(name);
//        //释放资源
//        if(jedis != null){
//            jedis.close();
//        }
//    }

    @Autowired
    private JedisPool jedisPool;

    private Jedis jedis = null;

    //初始化jedis实例对象
    @Before
    public void initConnt(){
        jedis = jedisPool.getResource();
    }

    //释放资源
    @After
    public void closeConnt(){
        if (null != jedis){
            jedis.close();
        }
    }


    /*
    * 操作String
    * */
    @Test
    public void testString(){
        //添加一条数据
        jedis.set("name","zhangsan");
        //获取一条数据
        String name = jedis.get("name");
        System.out.println(name);
        //添加多条数据，参数的奇数是key，偶数是value
        jedis.mset("address","sh","sex","1");
        //获取多条数据
        List<String> list = jedis.mget("name","address","sex");
        list.forEach(System.out::println);
        //删除数据
        jedis.del("name");
    }

    /*
     * 操作hash
     * */
    @Test
    public void testHash(){
        /*
        * //添加一条数据
        * 第一条参数：redis的key
        * 第二条参数：hash的key
        * 第二条参数：hash的value
        * */
        jedis.hset("user","name","zhangsan");
        /*
        * //获取一条数据
        * 第一个参数：redis的key
        * 第二条参数：hash的key
        * */
        String name = jedis.hget("user","name");
        System.out.println(name);
        //添加多条数据
        Map<String,String> map = new HashMap<>();
        map.put("age","20");
        map.put("sex","1");
        jedis.hmset("user",map);
        //获取多条数据
        List<String> list = jedis.hmget("user","age","sex");
        list.forEach(System.out::println);
        //获取hash类型的所有数据
        Map<String,String> user = jedis.hgetAll("user");
        user.entrySet().forEach(e ->{
            System.out.println(e.getKey()+"----->"+e.getValue());
        });
        /*
        * //删除数据
        * 第一个参数：redis的key
        * 第二条参数：hash的key（可变）
        * */
        jedis.hdel("user","name","age");
    }

    /*
     * 操作list
     * */
    @Test
    public void testList(){
        //左添加
        jedis.lpush("students","zhangsan","lisi");
        //右添加
        jedis.rpush("students","wangwu","zhaoliu");
        /*
        * 获取数据
        * 第一个参数：redis的key
        * 第二个参数：起始下标
        * 第三个参数：结束下标
        * */
        List<String> list = jedis.lrange("students",0,3);
        list.forEach(System.out::println);
        //获取总条数
        long total = jedis.llen("students");
        System.out.println(total);
        /*
        * 删除数据
        * 第一个参数：redis的key
        * 第二个参数：参数值的个数
        * 第二个参数：需要删除的值
        * */
        jedis.lrem("students",1,"lisi");

        /*-------------*/
        //左弹出
        String left = jedis.lpop("students");
        System.out.println(left);
        //右弹出
        String right = jedis.rpop("students");
        System.out.println(right);
    }


    /*
     * 操作set
     * */
    @Test
    public void testSet(){
        //添加数据
        jedis.sadd("letters","aaa","bbb","ccc","ddd","eee");
        //获取数据
        Set<String> set = jedis.smembers("letters");
        set.forEach(System.out::println);
        //获取总条数
        Long total = jedis.scard("letters");
        System.out.println(total);
        //删除数据
        jedis.srem("letters","aaa","bbb");
    }

    /*
     * 操作Sortedset
     * */
    @Test
    public void testSortedSet(){
        //添加数据
        Map<String,Double> map = new HashMap<>();
        map.put("zhangsan",7D);
        map.put("lisi",3D);
        map.put("wangwu",5D);
        map.put("zhaoliu",6D);
        map.put("tianqi",1D);
        jedis.zadd("score",map);
        /*
        * 获取数据
        * 第一个参数：redis的key
        * 第二个参数：起始下标
        * 第三个参数：结束下标
        * */
        Set<String> set = jedis.zrange("score",0,4);
        set.forEach(System.out::println);
        //获取总条数
        Long total = jedis.zcard("score");
        System.out.println(total);
        //删除数据
        jedis.zrem("score","zhangsan","wangwu");
    }

    /*
     * 层及目录形式存储数据
     * */
    @Test
    public void testDir(){
        jedis.set("cart:user01:item01","apple");
        System.out.println(jedis.get("cart:user01:item01"));
    }


    /*
     * key失效时间
     * */
    @Test
    public void testExpire(){
    //给已经存在的key实质失效时间
        jedis.set("code","test");
        //设置失效时间，单位为秒
        jedis.expire("code",30);
        //设置失效时间，单位为毫秒
        jedis.pexpire("code",30000);
        //查看失效时间，单位秒，-1位不失效，-2为已失效
        long ttl = jedis.ttl("code");
        System.out.println(ttl);

    //添加key的时候设置失效时间
        //设置失效时间，单位为秒
        jedis.setex("code",30,"test");
        //设置失效时间，单位为毫秒
        jedis.psetex("code",30000,"test");
        //查看失效时间，单位毫秒
        Long pttl = jedis.pttl("code");
        System.out.println(pttl);

    //nx,ex的用法
        SetParams setParams = new SetParams();
        //不存在的时候才能设置成功
        setParams.nx();
        //存在的时候才能设置成功
        //setParams.xx();
        //设置失效时间，单位为秒
        //setParams.ex(30);
        //查看失效时间，单位毫秒
        setParams.px(30000);
        jedis.set("code","test",setParams);
    }

    /*
    * 查询所有key
    * */
    @Test
    void testAllKey(){
        //当前数据库key的数量
        Long size = jedis.dbSize();
        System.out.println(size);
        //查询当前数据库的所有key
        Set<String> set = jedis.keys("*");
        set.forEach(System.out::println);
    }

    /*
    * 事务
    * */
    @Test
    public void testMulti(){
        //开启事务
        Transaction tx = jedis.multi();
        tx.set("tel","10086");
        //提交事务
        //tx.exec();
        //回滚事务
        tx.discard();
    }

    /*
    * 操作byte数组
    * */
    @Test
    public void testByte(){
        User user = new User();
        user.setId(2);
        user.setUsername("zhangsan");
        user.setPassword("123456");
        //序列化为byte数组
        byte[] userKey = SerializeUtil.serialize("user"+user.getId());
        byte[] uservalue = SerializeUtil.serialize(user);
        //存入redis
        jedis.set(userKey,uservalue);
        // 取出数据
        byte[] bytes = jedis.get(userKey);
        //反序列化
        User user1 = (User) SerializeUtil.unserialize(bytes);
        System.out.println(user1);
    }
}