spring中的redis模板存储Java对象

最新推荐文章于 2024-04-30 09:32:16 发布

Appcontext

最新推荐文章于 2024-04-30 09:32:16 发布

阅读量770

点赞数 4

文章标签： spring redisTemplate redisTemplate存储对象

本文链接：https://blog.csdn.net/qq_42025000/article/details/91388414

版权

利用spring中redis模板工具类存储Java对象

spring中redisTemplate存储Java对象
- 具体实现步骤

spring中redisTemplate存储Java对象

本文主要研究如何利用spring中的redis存储Java对象

具体实现步骤

以一个demo为例，具体介绍是如何存储的。

安装redis
安装教程，可参考:http://www.cnblogs.com/koal/p/5484916.html
.新建maven工程
在pom.xml文件中添加以下依赖:

 <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.7</maven.compiler.source>
      <maven.compiler.target>1.7</maven.compiler.target>
      <spring.version>4.3.14.RELEASE</spring.version>

  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!-- spring相关 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context-support</artifactId>
          <version>${spring.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</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-tx</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-web</artifactId>
          <version>${spring.version}</version>
      </dependency>

      <!--spring单元测试依赖 -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>${spring.version}</version>
          <scope>test</scope>
      </dependency>

      <!-- Redis 相关依赖 -->
      <dependency>
          <groupId>org.springframework.data</groupId>
          <artifactId>spring-data-redis</artifactId>
          <version>1.0.0.RELEASE</version>
      </dependency>
      <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.0.0</version>
      </dependency>

在spring的配置文件中添加以下配置:

<?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:aop="http://www.springframework.org/schema/aop"
       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">
    <!--加载redis属性配置文件-->
    <context:property-placeholder location="classpath:redis.properties"/>

    <!--配置redis连接池-->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxActive" value="${redis.maxActive}"/>
        <property name="maxWait" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
     </bean>

    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
    p:host-name="${redis.host}" p:port="${redis.port}" p:poolConfig-ref="poolConfig"
    />

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
    </bean>

    <bean id="userDao" class="com.tele.redisTemp.dao.impl.UserDaoImpl"></bean>
</beans>

注意:在配置redisTemplate时尽量使用RedisTemplate，不要使用StringRedisTemplate，在保存Pojo的时候会出现转型失败

添加redis的配置信息

#绑定redis的主机地址
redis.host=127.0.0.1
#redis的监听端口,默认6379
redis.port=6379
#授权密码
redis.password=123456
#最大空闲数(空闲链接数大于maxIdle时，将进行回收)
redis.maxIdle=100
#最大连接数，能够同时建立连接的最大连接个数
redis.maxActive=300
#最大等待时间,单位ms
redis.maxWait=100
#检测连接是否成功
redis.testOnBorrow=true
#当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
redis.timeout=10000

相关的java代码:
实体类:

package com.tele.redisTemp.pojo;

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    public static final String OBJECT_KEY = "USER";
    private String id;
    private String name;
    private String password;

    public User() {
    }

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

    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 getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

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

    public String getObjectKey() {
        return OBJECT_KEY;
    }

}

dao层接口设计:

package com.tele.redisTemp.dao;

import com.tele.redisTemp.pojo.User;
import java.util.List;

public interface UserDao {
    /**
     * 添加user
     * @param user
     * @return
     */
    boolean add(User user);

    /**
     * 批量新增
     * @param users
     * @return
     */
    boolean batchAdd(List<User> users);

    /**
     * 删除一条数据
     * @param key
     */
    void delete(String key);

    /**
     * 删除多条数据
     * @param keys
     */
    void delete(List<String> keys);

    /**
     * 修改一条数据
     * @param user
     * @return
     */
    boolean update(User user);

    /**
     * 根据key获取用户
     * @param keyId
     * @return
     */
    User get(String keyId);

}

抽象出dao层实现类的父类

package com.tele.redisTemp.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

public class AbstractBaseRedisDao<K,V> {

    @Autowired
    protected RedisTemplate<K,V> redisTemplate;

    public RedisTemplate<K,V> getRedisTemplate(){
        return redisTemplate;
    }

    /**
     * 获取redisSerializer
     * @return
     */
    protected RedisSerializer<String> getRedisSerializer(){
        return redisTemplate.getStringSerializer();
    }

}

dao层实现类

package com.tele.redisTemp.dao.impl;

import com.tele.redisTemp.dao.AbstractBaseRedisDao;
import com.tele.redisTemp.dao.UserDao;
import com.tele.redisTemp.pojo.User;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.ValueOperations;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl extends AbstractBaseRedisDao<String, Serializable> implements UserDao {

    @Override
    public boolean add(final User user) {
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                ValueOperations<String, Serializable> valueOperations = redisTemplate.opsForValue();
                valueOperations.set(user.getId(),user);
                return true;
            }
        },false,true);

        return result;
    }

    @Override
    public boolean batchAdd(final List<User> users) {
        Boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                ValueOperations<String, Serializable> valueOper = redisTemplate.opsForValue();
                for (User user:users){
                    valueOper.set(user.getId(),user);
                }
                return true;

            }
        }, false, true);
        return result;
    }

    @Override
    public void delete(String key) {
        List<String> list = new ArrayList<String>();
        list.add(key);
        delete(list);
    }

    @Override
    public void delete(List<String> keys) {
        redisTemplate.delete(keys);
    }

    @Override
    public boolean update(final User user) {
        String id = user.getId();
        if(get(id) == null){
            throw new NullPointerException("数据行不存在,key ="+id);
        }
        Boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                ValueOperations<String, Serializable> valueOper = redisTemplate.opsForValue();
                valueOper.set(user.getId(), user);
                return true;
            }
        }, false, true);
        return result;
    }

    @Override
    public User get(final String keyId) {
        User user = redisTemplate.execute(new RedisCallback<User>() {
            @Override
            public User doInRedis(RedisConnection redisConnection) throws DataAccessException {
                ValueOperations<String, Serializable> valueOperations = redisTemplate.opsForValue();
                User user = (User) valueOperations.get(keyId);
                return user;
            }
        });
        return user;
    }
}

整个工程和相关程序算是建立完成了，下面新建单元测试进行测试：

package com.tele.redisTemp;

import com.tele.redisTemp.dao.UserDao;
import com.tele.redisTemp.dao.impl.UserDaoImpl;
import com.tele.redisTemp.pojo.User;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

@ContextConfiguration(locations = {"classpath:application-context.xml"})
public class RedisTest extends AbstractJUnit4SpringContextTests{

    @Autowired
    private UserDaoImpl userDao;

    @Test
    public void addUser(){
        User user = new User("111","张三","123456");
        boolean result = userDao.add(user);
        System.out.println(result);
    }

    @Test
    public void getUser(){
        String key = "110";
        User user = userDao.get(key);
        System.out.println(user.getName());
    }

}

Appcontext

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
spring中的redis模板存储Java对象

利用spring中redis模板工具类存储Java对象spring中redisTemplate存储Java对象具体实现步骤spring中redisTemplate存储Java对象本文主要研究如何利用spring中的redis存储Java对象具体实现步骤以一个demo为例，具体介绍是如何存储的。安装redis安装教程，可参考:http://www.cnblogs.com/koal/p/...
复制链接

扫一扫