spring-data-redis的基本使用

Spring Data Redis

​ Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。

​ spring-data-redis针对jedis提供了如下功能：

  1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类

  2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

    • ValueOperations：简单K-V操作

    • SetOperations：set类型数据操作

    • ZSetOperations：zset类型数据操作

    • HashOperations：针对map类型的数据操作

    • ListOperations：针对list类型的数据操作

首先,需要在虚拟机安装一个redis数据库,安装 ,我电脑安装redis数据库的主机地址是:192.168.5.111

其次:为了更直观的看reids中的数据变化,所以最好下载一个工具  RedisDesktopManager 可以直观的看到数据有没有在redis数据库中

spring-data-redis的基本使用

第一步:导包

在pom文件中需要导入:spring相关的jar包,srping-data-redis的包,再导入两个测试包,方便测试

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>demo</artifactId>
        <groupId>cn.itcast.demo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring_data_redis</artifactId>
    <!--规定版本-->
    <properties>
        <spring.version>4.2.4.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.1</version>
        </dependency>
        <!--spring-data-redis包-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.7.RELEASE</version>
        </dependency>
        <!--测试的两个-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
    </dependencies>
</project>

第二步:引入spring-data-redis的配置文件  redis-config.properties

#装有redis数据库的虚拟机中的一台机器的ip
redis.host=192.168.5.111
redis.port=6379
redis.pass=
#默认存储在databse[0]数据库, redis的database相当于一个数据,默认也是0
redis.database=0
#maxIdle:最大空闲数
redis.maxIdle=300
#maxWait:最大等待时长,3秒
redis.maxWait=3000
#testOnBorrow：在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的；
redis.testOnBorrow=true

第三步:在applicationContext_redis.xml中配置一下第二步的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--1引入配置信息-->
    <context:property-placeholder location="classpath*:properties/*.properties"/>

   <!--2配置redis,相当于实例化了jedis的配置-->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>

    <!--3获取redis的连接工厂-->
    <bean id="JedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" p:host-name="${redis.host}" p:password="${redis.pass}" p:port="${redis.port}" p:poolConfig-ref="poolConfig"/>

    <!--获取redisTemplate,template需要redis连接工厂-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
          <property name="connectionFactory" ref="JedisConnectionFactory" />
    </bean>

</beans>

第四步:开始使用redisTemplate进行各类型的CURD操作

package spring_data_redis_test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
import java.util.Set;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext_redis.xml")
public class AllTest {
    //注入template对象
    @Autowired
    private RedisTemplate redisTemplate;

//----------------------Hash类型的操作:经常用---------------------------------
//（1）存入值
@Test
public void  boundHashOpsSet(){
    redisTemplate.boundHashOps("namehash").put("country1","中国");
    redisTemplate.boundHashOps("namehash").put("country2","日本");
    redisTemplate.boundHashOps("namehash").put("country3","韩国");
}
//（2）提取所有的KEY
@Test
public void  boundHashOpsKeys(){
    Set keys = redisTemplate.boundHashOps("namehash").keys();
    System.out.println(keys);
}
//（3）提取所有的值
@Test
public void boundHashOpsValues(){
    List values = redisTemplate.boundHashOps("namehash").values();
    System.out.println(values);
}
//(4) 根据KEY提取值
@Test
public void boundHashOpsByKey(){
    Object name = redisTemplate.boundHashOps("namehash").get("country1");
    System.out.println(name);
}
//根据KEY移除值
@Test
public void boundHashOpsDelByKey(){
    redisTemplate.boundHashOps("namehash").delete("country2");
}

//----------------------------值类型的操作:因为操作数量少,所以不长用---------------------------------
    @Test
    public void setValue(){
        redisTemplate.boundValueOps("name").set("王五");
    }
    @Test
    public void getValue(){
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }
    @Test
    public void deleteValue(){
        redisTemplate.delete("name");
    }

//----------------------set类型的操作:因为操作数量少,所以不长用---------------------------------
    /**
     * 存入值
     */
    @Test
    public void boundSetOpsAdd(){
    redisTemplate.boundSetOps("nameset").add("曹操"); //放入值
    redisTemplate.boundSetOps("nameset").add("刘备");
    redisTemplate.boundSetOps("nameset").add("孙权");
    }
    /**
     * 提取值
     */
    @Test
    public void boundSetOpsGet(){
        Set names= redisTemplate.boundSetOps("nameset").members();//取出值
        System.out.println(names);
    }
    /**
     * 删除集合中的某一个值
     */
    @Test
     public void boundSetOpsDelete(){
         redisTemplate.boundSetOps("nameset").remove("曹操");
     }

    /**
     * 删除整个集合
     */
    @Test
    public void boundSetOpsDeleteAll(){
        redisTemplate.delete("nameset");
    }

    //----------------------list类型的操作:因为操作数量少,所以不长用---------------------------------
    /**
     * 右压栈：后添加的对象排在后边
     * 右压栈用的多,因为快,原理是
     */
    @Test
    public void boundListrightPush(){
        redisTemplate.boundListOps("namelist").rightPush("赵子龙");
        redisTemplate.boundListOps("namelist").rightPush("张飞");
        redisTemplate.boundListOps("namelist").rightPush("关羽");
    }
    /**
     * 显示右压栈集合
     */
    @Test
    public void boundListRange(){
        List namelist = redisTemplate.boundListOps("namelist").range(0, 10);
        System.out.println(namelist);
    }
    

    /**
     * 查询:根据索引查询集合某个元素
     */
    @Test
    public void boundListIndex(){
        Object name = redisTemplate.boundListOps("namelist").index(1);
        System.out.println(name);
    }

    /**
     * 删除: 根据值移除集合某个元素
     */
    @Test
    public void  bondListRemove(){
        redisTemplate.boundListOps("namelist").remove(1,"关羽");
    }
    /**
     * 删除: 删除全部
     */
    @Test
    public void  bondListDelete(){
        redisTemplate.delete("namelist");
    }

}

 

 

 

 

 

 

 

 

相关文章：

  • 2021-06-02
  • 2021-08-03
  • 2022-02-14
  • 2021-11-25
  • 2021-12-29
猜你喜欢
  • 2021-08-31
  • 2022-12-23
  • 2021-05-19
  • 2022-12-23
  • 2022-12-23
  • 2021-12-08
  • 2021-11-27
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode