Maven中Spring-Data-Redis存储对象(redisTemplate)

最新推荐文章于 2023-07-19 09:39:56 发布
最新推荐文章于 2023-07-19 09:39:56 发布
阅读量3.8k 收藏 1
点赞数 1
分类专栏： nosql 文章标签： nosql redis

Redis是一种nosql数据库，在开发中常用做缓存。Jedis是Redis在java中的redis- client.在此之前，希望已经了解redis的基本使用和Maven的使用。建立Maven Project之后，在POM.xml中添加jedis和spring-data-redis的依赖如下：

[html] view plain copy
print ?
  1. <dependency>  
  2.     <groupId>redis.clients</groupId>  
  3.     <artifactId>jedis</artifactId>  
  4.     <version>2.0.0</version>  
  5.     <type>jar</type>  
  6.     <scope>compile</scope>  
  7. </dependency>  
  8. <!– spring-redis –>  
  9. <dependency>  
  10.     <groupId>org.springframework.data</groupId>  
  11.     <artifactId>spring-data-redis</artifactId>  
  12.     <version>1.0.0.RELEASE</version>  
  13. </dependency>  
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.0.0</version>
    <type>jar</type>
    <scope>compile</scope>
</dependency>
<!-- spring-redis -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.0.0.RELEASE</version>
</dependency>

Redis连接数据库参数如下：applicationContext-redis.properties

[plain] view plain copy
print ?
  1. #redis config  
  2. redis.pool.maxActive=100  
  3. redis.pool.maxIdle=20  
  4. redis.pool.maxWait=1000  
  5. redis.pool.testOnBorrow=true  
  6. redis.hostname=localhost  
  7. redis.port=6379  
  8. redis.password=  
#redis config
redis.pool.maxActive=100
redis.pool.maxIdle=20
redis.pool.maxWait=1000
redis.pool.testOnBorrow=true
redis.hostname=localhost
redis.port=6379
redis.password=

在上下文配置中使用key-value读取方式读取properties中的值：

[html] view plain copy
print ?
  1. <!– Jedis 连接池配置–>  
  2. <bean id=“jedisPoolConfig” class=“redis.clients.jedis.JedisPoolConfig”>  
  3.     <property name=“maxActive” value=“{redis.pool.maxActive}"</span><span>&nbsp;</span><span class="tag">/&gt;</span><span>&nbsp;&nbsp;</span></span></li><li class=""><span>&nbsp;&nbsp;&nbsp;&nbsp;<span class="tag">&lt;</span><span class="tag-name">property</span><span>&nbsp;</span><span class="attribute">name</span><span>=</span><span class="attribute-value">"maxIdle"</span><span>&nbsp;</span><span class="attribute">value</span><span>=</span><span class="attribute-value">"{redis.pool.maxIdle}” />  
  4.     <property name=“maxWait” value=“{redis.pool.maxWait}"</span><span>&nbsp;</span><span class="tag">/&gt;</span><span>&nbsp;&nbsp;</span></span></li><li class=""><span>&nbsp;&nbsp;&nbsp;&nbsp;<span class="tag">&lt;</span><span class="tag-name">property</span><span>&nbsp;</span><span class="attribute">name</span><span>=</span><span class="attribute-value">"testOnBorrow"</span><span>&nbsp;</span><span class="attribute">value</span><span>=</span><span class="attribute-value">"{redis.pool.testOnBorrow}” />  
  5. </bean>  
  6. <!– Jedis ConnectionFactory 数据库连接配置–>  
  7. <bean id=“jedisConnectionFactory” class=“org.springframework.data.redis.connection.jedis.JedisConnectionFactory”>  
  8.     <property name=“hostName” value=“{redis.hostname}"</span><span>&nbsp;</span><span class="tag">/&gt;</span><span>&nbsp;&nbsp;</span></span></li><li class="alt"><span>&nbsp;&nbsp;&nbsp;&nbsp;<span class="tag">&lt;</span><span class="tag-name">property</span><span>&nbsp;</span><span class="attribute">name</span><span>=</span><span class="attribute-value">"port"</span><span>&nbsp;</span><span class="attribute">value</span><span>=</span><span class="attribute-value">"{redis.port}” />  
  9.     <property name=“password” value=“${redis.password}” />  
  10.     <property name=“poolConfig” ref=“jedisPoolConfig” />  
  11. </bean>  
  12. <!—- redisTemplate配置，redisTemplate是对Jedis的对redis操作的扩展，有更多的操作，封装使操作更便捷 –>   
  13. <bean id=“redisTemplate” class=“org.springframework.data.redis.core.RedisTemplate”                                   p:connection-factory-ref=“jedisConnectionFactory” />  
<!-- Jedis 连接池配置-->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxActive" value="${redis.pool.maxActive}" />
    <property name="maxIdle" value="${redis.pool.maxIdle}" />
    <property name="maxWait" value="${redis.pool.maxWait}" />
    <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
</bean>
<!-- Jedis ConnectionFactory 数据库连接配置-->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    <property name="hostName" value="${redis.hostname}" />
    <property name="port" value="${redis.port}" />
    <property name="password" value="${redis.password}" />
    <property name="poolConfig" ref="jedisPoolConfig" />
</bean>
<!—- redisTemplate配置，redisTemplate是对Jedis的对redis操作的扩展，有更多的操作，封装使操作更便捷 --> 
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"                                   p:connection-factory-ref="jedisConnectionFactory" />

上面redisTemplate已经基本配置完成。

接下来创建User类，必须实现或者间接实现Serializable接口：

Redis存储对象是使用序列化，spring-data-redis已经将序列化的功能内置，不需要我们去管，我们只需要调用api就可以使用。SerialVersionUID字段对序列化扩展有用，为了以后扩展或者缩减字段时不会造成反序列化出错。

[java] view plain copy
print ?
  1. public class User implements Serializable {  
  2.   
  3.     private static final long serialVersionUID = -7898194272883238670L;  
  4.   
  5.     public static final String OBJECT_KEY = “USER”;  
  6.   
  7.     public User() {  
  8.     }  
  9.   
  10.     public User(String id) {  
  11.     }  
  12.   
  13.     public User(String id, String name) {  
  14.         this.id = id;  
  15.         this.name = name;  
  16.     }  
  17.   
  18.     private String id;  
  19.   
  20.     private String name;  
  21.   
  22.     public String getId() {  
  23.         return id;  
  24.     }  
  25.   
  26.     public void setId(String id) {  
  27.         this.id = id;  
  28.     }  
  29.   
  30.     public String getName() {  
  31.         return name;  
  32.     }  
  33.   
  34.     public void setName(String name) {  
  35.         this.name = name;  
  36.     }  
  37.   
  38.     public String toString() {  
  39.         return “User [id=” + id + “, name=” + name + “]”;  
  40.     }  
  41.   
  42.     public String getKey() {  
  43.         return getId();  
  44.     }  
  45.   
  46.     public String getObjectKey() {  
  47.         return OBJECT_KEY;  
  48.     }  
  49. }  
public class User implements Serializable {

    private static final long serialVersionUID = -7898194272883238670L;

    public static final String OBJECT_KEY = "USER";

    public User() {
    }

    public User(String id) {
    }

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

    private String id;

    private String name;

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }

    public String getKey() {
        return getId();
    }

    public String getObjectKey() {
        return OBJECT_KEY;
    }
}

创建userService类来操作redis增删查改缓存对象。

[java] view plain copy
print ?
  1. public class UserService {  
  2.   
  3.     RedisTemplate<String, User> redisTemplate;  
  4.   
  5.     public RedisTemplate<String, User> getRedisTemplate() {  
  6.         return redisTemplate;  
  7.     }  
  8.   
  9.     public void setRedisTemplate(RedisTemplate<String, User> redisTemplate) {  
  10.         this.redisTemplate = redisTemplate;  
  11.     }  
  12.       
  13.     public void put(User user) {  
  14.         redisTemplate.opsForHash().put(user.getObjectKey(), user.getKey(), user);  
  15.     }  
  16.   
  17.     public void delete(User key) {  
  18.         redisTemplate.opsForHash().delete(key.getObjectKey(), key.getKey());  
  19.     }  
  20.   
  21.     public User get(User key) {  
  22.         return (User) redisTemplate.opsForHash().get(key.getObjectKey(), key.getKey());  
  23.     }  
  24. }  
public class UserService {

    RedisTemplate<String, User> redisTemplate;

    public RedisTemplate<String, User> getRedisTemplate() {
        return redisTemplate;
    }

    public void setRedisTemplate(RedisTemplate<String, User> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public void put(User user) {
        redisTemplate.opsForHash().put(user.getObjectKey(), user.getKey(), user);
    }

    public void delete(User key) {
        redisTemplate.opsForHash().delete(key.getObjectKey(), key.getKey());
    }

    public User get(User key) {
        return (User) redisTemplate.opsForHash().get(key.getObjectKey(), key.getKey());
    }
}

在上下文中配置redisTemplate注入，在使用bean方式来注入时，redisTemplate必须有setter/getter方法：

[html] view plain copy
print ?
  1. <bean id=“userService” class=“Service.UserService”>  
  2.     <property name=“redisTemplate”>  
  3.         <ref bean=“redisTemplate” />  
  4.     </property>  
  5. </bean>  
<bean id="userService" class="Service.UserService">
    <property name="redisTemplate">
        <ref bean="redisTemplate" />
    </property>
</bean>
======如果使用注解方式自动注入，则可以注释掉上面的bean配置方式======

在UserService注解@Service(“userService”),也可以在Service里写名字，默认是第一字母小写。

[java] view plain copy
print ?
  1. @Service(“userService”)  
  2. public class UserService {  
  3.   
  4.     @Autowired  
  5.     RedisTemplate<String, User> redisTemplate;  
  6.     ……  
  7.         ……  
  8. }  
@Service("userService")
public class UserService {

    @Autowired
    RedisTemplate<String, User> redisTemplate;
    ……
        ……
}

在上下文配置文件中，添加自动扫描包的context节点，Base-package的路径要覆盖包含注解的类文件：
[html] view plain copy
print ?
  1. <context:component-scan base-package=“*” />  
<context:component-scan base-package="*" />

在main中来简单操作一下：

[java] view plain copy
print ?
  1. public class Main {  
  2.     public static void main( String[] args )  
  3.     {  
  4.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“classpath*:/conf/applicationContext.xml”        );  
  5.         UserService userService =  (UserService) applicationContext.getBean(”userService”);  
  6.               
  7.         User user1 = new User(“user1ID”, “User 1”);  
  8.         User user2 = new User(“user2ID”, “User 2”);  
  9.           
  10.         System.out.println(”==== getting objects from redis ====”);  
  11.         System.out.println(”User is not in redis yet: ” + userService.get(user1));  
  12.         System.out.println(”User is not in redis yet: ” + userService.get(user2));  
  13.           
  14.         System.out.println(”==== putting objects into redis ====”);  
  15.         userService.put(user1);  
  16.         userService.put(user2);  
  17.           
  18.         System.out.println(”==== getting objects from redis ====”);  
  19.         System.out.println(”User should be in redis yet: ” + userService.get(user1));  
  20.         System.out.println(”User should be in redis yet: ” + userService.get(user2));  
  21.           
  22.         System.out.println(”==== deleting objects from redis ====”);  
  23.         userService.delete(user1);  
  24.         userService.delete(user2);  
  25.           
  26.         System.out.println(”==== getting objects from redis ====”);  
  27.         System.out.println(”User is not in redis yet: ” + userService.get(user1));  
  28.         System.out.println(”User is not in redis yet: ” + userService.get(user2));  
  29.   
  30.     }  
  31. }  
public class Main {
    public static void main( String[] args )
    {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath*:/conf/applicationContext.xml"        );
        UserService userService =  (UserService) applicationContext.getBean("userService");

        User user1 = new User("user1ID", "User 1");
        User user2 = new User("user2ID", "User 2");

        System.out.println("==== getting objects from redis ====");
        System.out.println("User is not in redis yet: " + userService.get(user1));
        System.out.println("User is not in redis yet: " + userService.get(user2));

        System.out.println("==== putting objects into redis ====");
        userService.put(user1);
        userService.put(user2);

        System.out.println("==== getting objects from redis ====");
        System.out.println("User should be in redis yet: " + userService.get(user1));
        System.out.println("User should be in redis yet: " + userService.get(user2));

        System.out.println("==== deleting objects from redis ====");
        userService.delete(user1);
        userService.delete(user2);

        System.out.println("==== getting objects from redis ====");
        System.out.println("User is not in redis yet: " + userService.get(user1));
        System.out.println("User is not in redis yet: " + userService.get(user2));

    }
}

确保redis服务器是开启状态之后就可以运行程序。运行结果如下：


非Maven项目需要导入spring-data-redis-1.6.2.RELEASE.jar
jedis-2.7.2.jar（依赖 commons-pool2-2.3.jar）
commons-pool2-2.3.jar

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-3.0.xsd
      http://www.springframework.org/schema/mvc
      http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/util 
      http://www.springframework.org/schema/util/spring-util-3.0.xsd">

<!--[redis-JedisPoolConfig配置](http://blog.csdn.net/liang_love_java/article/details/50510753)-->
<!--    jedis-2.7.2.jar 依赖jar包 commons-pool2-2.3.jar 
        jedis基于 commons-pool2-2.3.jar 自己实现了一个资源池。
        配置参数 详见 http://blog.csdn.net/liang_love_java/article/details/50510753
-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> 
        <property name="maxIdle" value="1" /> 
        <property name="maxTotal" value="5" /> 
        <property name="blockWhenExhausted" value="true" /> 
        <property name="maxWaitMillis" value="30000" /> 
        <property name="testOnBorrow" value="true" />  
    </bean> 

    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"> 
        <property name="hostName" value="10.1.8.200" /> 
        <property name="port" value="6379"/> 
        <property name="poolConfig" ref="jedisPoolConfig" /> 
        <property name="usePool" value="true"/> 
    </bean> 

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">   
        <property name="connectionFactory"   ref="jedisConnectionFactory" />   
        <property name="keySerializer">   
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />   
        </property>      
        <property name="valueSerializer">   
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />   
        </property>   
        <property name="hashKeySerializer">     
           <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>     
        </property>   
        <property name="hashValueSerializer">   
           <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>     
        </property> 
     </bean> 

</beans>
菜鸟腾飞
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
maven版spring-data-redis简单示例
03-06
基于spring的子项目spring-data-redis写的一个基于hash类型的用户CRUD,经过简单的封装，可以实现通用CRUD，请事先安装好redis，配置文件redis.properties请做相应修改，希望对你有帮助。
spring-session-data-redis-2.0.4.RELEASE-API文档-中英对照版.zip
06-12
Maven坐标：org.springframework.session:spring-session-data-redis:2.0.4.RELEASE； 标签：springframework、session、spring、data、redis、中英对照文档、jar包、java； 使用方法：解压翻译后的API文档，用...
Redis工具类：RedisTemplate
哈
05-19 1402
Maven依赖 <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.10.1</version> </dependency> <dependency> <groupId>com.fasterxml
spring-data-redis模块详解
followwwind的博客
11-22 913
一.背景      spring-data是spring框架对数据处理的模块，其中包括数据库dao层处理，以及elasticsearch等等都有封装，而本文主要介绍spring-data-redis模块即对redis数据库的数据处理。 二.pom maven依赖     目前spring官网spring-data-redis最新稳定版本为2.0.1版本，根据官网介绍，目前该版本主要对spri
Redis使用RedisTemplate
零度的博客
09-17 749
一、Maven依赖 （1）本文所采用的SpringBoot的版本如下 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &l...
spring-session-data-redis-2.0.4.RELEASE-API文档-中文版.zip
06-26
Maven坐标：org.springframework.session:spring-session-data-redis:2.0.4.RELEASE； 标签：springframework、session、spring、data、redis、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器...
spring-data-redis-2.3.9.RELEASE-API文档-中文版.zip
07-13
Maven坐标：org.springframework.data:spring-data-redis:2.3.9.RELEASE； 标签：springframework、data、spring、redis、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件...
spring-data-redis-2.0.9.RELEASE-API文档-中英对照版.zip
06-12
Maven坐标：org.springframework.data:spring-data-redis:2.0.9.RELEASE； 标签：springframework、data、spring、redis、中英对照文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”...
spring-data-redis-2.0.6.RELEASE-API文档-中文版.zip
07-14
Maven坐标：org.springframework.data:spring-data-redis:2.0.6.RELEASE； 标签：springframework、data、spring、redis、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件...
缓存篇-RedisTemplate常用方法
qq_41807885的博客
11-14 617
记录使用RedisTemplate操作String，List，Hash，Set，ZSet的方法
Spring Data Redis的使用
m0_48489427的博客
06-11 1433
解决方法为在Redis-x64-3.2.100目录下打开两个cmd窗口，分别输入 命令redis-server.exe redis.windows.conf 和 命令redis-cli ，即可成功连接。
Redis：导入Spring Data Redis
A20001230T的博客
07-19 183
redisTemplate.opsForValue().set("city","北京");database: ${sky.redis.database} #0号数据库。password: ${sky.redis.password} #密码。port: ${sky.redis.port} #端口号。host: ${sky.redis.host} #地址。/*查询key是否存在，返回布尔类型的值*//*合并两个集合的查询值，去掉重复的值*//*遍历所有的key，查看类型*//*查询两个集合的共同值*/
SpringBoot重点详解--使用RedisTemplate操作Redis数据库
热门推荐
pengjunlee的博客
09-11 1万+
一、Maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.8.RELE...
spring-data-redis配置和使用
xzj80927的博客
12-03 646
1、引入坐标： 1）gradle compile( // redis 'redis.clients:jedis:2.9.0', 'org.springframework.data:spring-data-redis:1.7.5.RELEASE' ) 2）spring中maven坐标 <dependency> <...
从入门到精通，超强 RedisTemplate 方法详解！
xmt1139057136的专栏
07-03 2539
你知道的越多，不知道的就越多，业余的像一棵小草！成功路上并不拥挤，因为坚持的人不多。编辑：业余草cnblogs.com/dw3306/p/12840012.html推荐：https://w...
浅谈RedisTemplate的使用及配置+序列化操作，快速理解
浣熊小怜怜
04-01 5613
redistemplate简易理解~~ 序列化~~
spring-session-data-redis.jar包下载
最新发布
09-26
Spring Session Data Redis是一个用于在Spring应用中将会话数据存储在Redis数据库中的库。要下载spring-session-data-redis.jar包，可以按照以下步骤进行操作： 1. 打开Maven Repository（Maven仓库）的网站，例如https://mvnrepository.com/。 2. 在搜索框中输入"spring-session-data-redis"并点击搜索按钮。 3. 在搜索结果中找到适合你的版本，并点击进入该版本的页面。 4. 在页面上找到"jar"选项，并点击右侧的Download按钮。 5. 确保你选择了正确的操作系统和版本，然后点击下载按钮。 6. 下载完成后，将jar包添加到你的项目中。 另外，你也可以选择通过构建工具（例如Maven或Gradle）来管理你的项目依赖。在项目的构建文件（如pom.xml或build.gradle）中，添加spring-session-data-redis的依赖项，并运行构建命令即可自动下载jar包。 需要注意的是，下载最新版本的jar包是推荐的，因为它们可能修复了之前版本的bug并带来一些新的功能。同时，确保你的项目已经配置了与Redis数据库的连接信息，以便正确使用spring-session-data-redis库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值