Java连接Redis存储数据

最新推荐文章于 2024-08-14 20:26:18 发布
最新推荐文章于 2024-08-14 20:26:18 发布
阅读量3.3k 收藏 11
点赞数 3
分类专栏： Redis 文章标签： java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iHarbour/article/details/121370878
版权

依赖jar包

  • redis连接工具jedis
  • jedis连接池commons-pool
  • 阿里的json序列化工具fastjson
  • 单元测试junit
<!--redis连接工具-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
<!--jedis连接池-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
</dependency>
<!--阿里的json序列化工具-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

主要代码

  1. redis连接配置文件redis.properties
#redis服务器ip
redis.ip=127.0.0.1
#redis服务器端口号
redis.port=6379
#redis密码
redis.passWord=
#与服务器建立连接的超时时间
redis.timeout=3000
#jedis的最大活跃连接数
pool.maxTotal=10
#jedis最大空闲连接数
pool.maxIdle=3
#jedis池没有连接对象返回时，等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。
#如果超过等待时间，则直接抛出JedisConnectionException
pool.maxWaitMillis=3000
  1. 连接池配置工具RedisPoolUtil
    使用单例模式+双重锁定写的redis连接池配置工具
package com.robert.mpdt.redis;

import java.util.Properties;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;

// jedis连接池工具
public class RedisPoolUtil {
    private volatile  static JedisPool jedisPool = null;
    private static String redisConfigFile = "redis.properties";
    // 把redis连接对象放到本地线程中
    private static ThreadLocal<Jedis> local=new ThreadLocal<Jedis>();
    private RedisPoolUtil() {
    }

    // 初始化连接池
    public static void initialPool() {
        try {
            Properties props = new Properties();
            // 加载连接池配置文件    		
            props.load(RedisPoolUtil.class.getClassLoader().getResourceAsStream(redisConfigFile));
            // 创建jedis池配置实例
            JedisPoolConfig config = new JedisPoolConfig();
            // 设置池配置项值
            config.setMaxTotal(Integer.valueOf(props.getProperty("pool.maxTotal")));
            config.setMaxIdle(Integer.valueOf(props.getProperty("pool.maxIdle")));
            config.setMaxWaitMillis(Long.valueOf(props.getProperty("pool.maxWaitMillis")));
            // 根据配置实例化jedis池
            jedisPool = new JedisPool(config, props.getProperty("redis.ip"),
                    Integer.valueOf(props.getProperty("redis.port")),
                    Integer.valueOf(props.getProperty("redis.timeout")),
                    "".equals(props.getProperty("redis.passWord"))?null:props.getProperty("redis.passWord"));
            System.out.println("连接池初始化成功");
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("连接池初始化失败");
        }
    }

    // 获取连接
    public static Jedis getInstance() {
        //Redis对象
        Jedis jedis =local.get();
        if(jedis==null){
            if (jedisPool == null) {
                synchronized (RedisPoolUtil.class) {
                    if (jedisPool == null) {
                        initialPool();
                    }
                }
            }
            try{
                jedis = jedisPool.getResource();
            }catch(JedisConnectionException e){
                e.printStackTrace();
            }

            local.set(jedis);
        }
        return jedis;
    }

    // 关闭连接
    public static void closeConn(){
        Jedis jedis =local.get();
        if(jedis!=null){
            jedis.close();
        }
        local.set(null);
    }

}
  1. java序列化/反序列化封装工具SerializeUtil
package com.robert.mpdt.redis;

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

// java序列化/反序列化工具
public class SerializeUtil {


    // 序列化
    public static byte[] serizlize(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) {
            e.printStackTrace();
        }finally {
            try {
                if(baos != null){
                    baos.close();
                }
                if (oos != null) {
                    oos.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return null;
    }


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

            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return null;
    }
}
  1. 对象与map相互转换封装工具MapUtil
    下面工具能够转换的对象需要该对象的属性必须是String或int类型
package com.robert.mpdt.redis;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

// java反射机制
public class MapUtil {

    // map转对象(目前只支持对象中含有String和int类型的属性,其他类型需要自己扩展)
    public static <T> Object mapToObject(Map<String, String> map, Class<?> beanClass)
            throws Exception {
        if (map == null)
            return null;

        Object obj = beanClass.newInstance();

        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            int mod = field.getModifiers();
            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                continue;
            }

            field.setAccessible(true);
            if(field.getType().equals(int.class)){
                field.set(obj, Integer.parseInt(map.get(field.getName())));
            }else{
                field.set(obj, (Object)map.get(field.getName()));
            }

        }

        return obj;
    }

    // 对象转map(目前只支持对象属性为基本类型)
    public static Map<String, String> objectToMap(Object obj) throws Exception {
        if (obj == null) {
            return null;
        }

        Map<String, String> map = new HashMap<String, String>();

        Field[] declaredFields = obj.getClass().getDeclaredFields();
        for (Field field : declaredFields) {
            field.setAccessible(true);
            map.put(field.getName(), field.get(obj).toString());
        }

        return map;
    }

}
  1. jedis存取常用数据封装工具类RedisOps
    实现了String类型和hash类型两种数据存取
package com.robert.mpdt.redis;

import com.alibaba.fastjson.JSON;

import redis.clients.jedis.Jedis;

// redis存取工具类
public class RedisOps {


    // kv字符串存
    public static void set(String key,String value){
        Jedis jedis = RedisPoolUtil.getInstance();
        jedis.set(key, value);
        RedisPoolUtil.closeConn();
    }

    // kv字符串取
    public static String get(String key){
        Jedis jedis = RedisPoolUtil.getInstance();
        String value = jedis.get(key);
        RedisPoolUtil.closeConn();
        return value;
    }
    // kv对象存(java序列化方式)
    public static void setObjectSerialize(String key,Object object){
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return;
        }
        jedis.set(key.getBytes(), SerializeUtil.serizlize(object));
        RedisPoolUtil.closeConn();
    }

    // kv对象取(java反序列化)
    public static Object getObjectSerialize(String key){
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return null;
        }
        byte[] bytes = jedis.get(key.getBytes());
        RedisPoolUtil.closeConn();
        if(bytes==null){
            return null;
        }
        return SerializeUtil.deserialize(bytes);
    }

    // 删除key
    public static void del(String key){
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return;
        }
        jedis.del(key.getBytes());
        RedisPoolUtil.closeConn();
    }


    // kv对象存(json方式)
    public static void setObjectJson(String key,Object object){
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return;
        }
        jedis.set(key, JSON.toJSONString(object));
        RedisPoolUtil.closeConn();
    }
    // kv对象取(json方式)
    @SuppressWarnings({ "unchecked" })
    public static <T> Object getObjectJson(String key,Class<?> clazz){
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return null;
        }
        String result= jedis.get(key);
        RedisPoolUtil.closeConn();
        if(result==null){
            return null;
        }
        T obj=(T)JSON.parseObject(result,clazz);
        return obj;
    }

    // kv对象存(map形式)
    public static void setObjectHash(String key, Object u) throws Exception {
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return ;
        }
        jedis.hmset(key, MapUtil.objectToMap(u));
        RedisPoolUtil.closeConn();

    }

    // kv对象取(map形式)
    public static Object getObjectHash(String key,Class<?> clazz) throws Exception {
        Jedis jedis = RedisPoolUtil.getInstance();
        if(jedis==null){
            return null;
        }
        Object obj = MapUtil.mapToObject(jedis.hgetAll(key), clazz);
        RedisPoolUtil.closeConn();
        if(obj==null){
            return null;
        }
        return obj;
    }
}
  1. 两个实体类User和Vehicle
    Vehicle类没有实现Serializable接口，不能用于java序列化存取
    User
package com.robert.mpdt.redis;

import java.io.Serializable;

// 用户实体类
public class User implements Serializable {
    private static final long serialVersionUID = -3210884885630038713L;
    private int id;
    private String name;
    private int age;
    public User(){

    }
    public User(int id,String name,int age){
        this.id = id;
        this.name = name;
        this.age=age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
    }

}

Vehicle

package com.robert.mpdt.redis;

// 车辆实体类
public class Vehicle {
    private int id;

    private String platenumber;

    private String color;


    public Vehicle(){

    }

    public Vehicle(int id, String platenumber, String color) {
        this.id = id;
        this.platenumber = platenumber;
        this.color = color;
    }
    
    public int getId() {
        return id;
    }

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

    public String getPlatenumber() {
        return platenumber;
    }

    public void setPlatenumber(String platenumber) {
        this.platenumber = platenumber;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Vehicle [id=" + id + ", platenumber=" + platenumber
                + ", color=" + color + "]";
    }
}
  1. jedis存取数据测试类JTest
package com.robert.mpdt.redis;

import org.junit.Test;

import redis.clients.jedis.Jedis;

// jedis存取测试
public class JTest {

    // 测试连接
    @Test
    public void TestPing(){
        Jedis jedis = RedisPoolUtil.getInstance();
        System.out.println(jedis.ping());
    }

    // 测试java序列化存取
    @Test
    public void TestSerialize(){
        User u = new User(1,"小明",6);
        RedisOps.setObjectSerialize(User.class.getName().toString()+":"+1, u);
        User u2 = (User)RedisOps.getObjectSerialize(User.class.getName().toString()+":"+1);
        System.out.println(u2.toString());
    }

    //  测试json序列化存取
    @Test
    public void TestJson(){
        User u = new User(1,"小明",6);
        Vehicle v = new Vehicle(1,"渝A00000","蓝色");
        RedisOps.setObjectJson(User.class.getName().toString()+":"+1, u);
        RedisOps.setObjectJson(Vehicle.class.getName().toString()+":"+1, v);
        User u2 = (User)RedisOps.<User>getObjectJson(User.class.getName().toString()+":"+1,User.class);
        Vehicle v2 = (Vehicle)RedisOps.<Vehicle>getObjectJson(Vehicle.class.getName().toString()+":"+1,Vehicle.class);
        System.out.println(u2.toString());
        System.out.println(v2.toString());
    }

    // 测试hash存取
    @Test
    public void TestHash() throws Exception{
        Vehicle v = new Vehicle(1,"渝A00000","蓝色");
        RedisOps.setObjectHash(Vehicle.class.getName(), v);
        Vehicle v2=(Vehicle) RedisOps.getObjectHash(Vehicle.class.getName(),Vehicle.class);
        System.out.println(v2.toString());
    }

}

本文主要参考自java连接redis存取数据(详细)

实际开发中使用SpringBoot整合Redis，更加方便和简单。

执手望天涯
关注
专栏目录
REDIS缓存数据库在JAVA中的使用
01-18
零基础学会REDIS缓存数据库在JAVA中的使用。从REDIS的安装和使用开始，到Java程序与REDIS数据库进行连接互动，简单明了。
将java对象存储到redis数据库(两种实现方式)
LJT666888的博客
05-15 8623
本文为转载内容，特此声明，如若侵权，请联系删除，原文地址：https://www.cnblogs.com/potentPrince/p/8668544.html redis主要存储类型最常用的五种数据类型： String Hash List Set Sorted set redis不能直接存取对象，如何解决呢？ 两种方式 1、利用序列化和反序列化的方式 两层对象存取到redis 示例： 序列化工具类 public class SerializeUtil { public
Redis的数据类型以及使用java简单操作redis
最新发布
m0_74249133的博客
08-14 847
blpop list 30 获取数据，有则返回，没有则等待30秒，此时可以在另一个客户端添加数据进去，则这个客户端就会返回数据。zrange key start(开始索引) stop(结束索引) [WITHSCORES]通过下标截取指定的长度，这个list已经被改变了，只剩下截取的元素。将某个具体的value插入到列中的某个元素的前面或者后面！数据操作不成功的反馈与数据正常操作之间的差异。随机获取集合中的某个数据并将该数据移出集合。求两个集合的交、并、差集并存储到指定集合中。
如何将数据存入redis内存中？用Java代码编写
m0_74132943的博客
02-02 1324
我的是要将 token 存 redis 内存的，你要存什么其它的数据你就根据你自己的代码来就好）如果不存在，表示没有找到存储的值，则从 API 重新获取新的。请注意，在使用 Redis 命令之前，需要先确保已经正确连接到 Redis 服务器，并创建了相应的 Redis 命令对象。你的也可能不是，具体你可以看你启动的redis；对象创建成功，我们就可以使用其中的各种 Redis 命令方法来与 Redis 服务器进行通信，例如..........我在运行的时候，整体都是很顺畅的没有出现问题，所以不清楚其它问题。
Java中使用Redis实现高效缓存与数据存储
恋上、小幸福的博客
07-19 2516
Redis是一种快速、开源的内存数据结构存储系统，常被用作高效的缓存和数据存储解决方案。在Java开发中，使用Redis可以极大地提升应用性能，减轻数据库压力，实现分布式系统的数据共享。本篇博客将详细介绍Java中使用Redis的基本操作、数据结构以及缓存策略，并通过实例说明，帮助读者更好地理解和应用Redis。
Java 实现Redis存储复杂json格式数据并返回给前端
10-15
本篇文章主要探讨如何在Java中存储和检索复杂JSON格式的数据到Redis，并将其返回给前端。以下是实现这一功能的关键知识点： 1. **Redis基本操作**：Redis是一个开源的内存数据结构存储系统，可以当作数据库、缓存和...
java连接redis
12-01
由于提供的压缩包文件名为 "java连接redisjar包"，我们可以假设其中包含 Jedis 的 jar 文件。将这个 jar 包添加到你的项目类路径（classpath）中，或者如果你使用的是 Maven 或 Gradle，可以添加对应的依赖。对于 ...
Java 连接Redis
11-24
Java连接Redis是将Java应用程序与Redis内存数据存储系统进行交互的一种技术。Redis是一个高性能的键值数据库，广泛用于缓存、消息队列等场景。在Java中，我们通常使用Jedis库来实现与Redis的连接。Jedis是Redis官方...
java 连接Redis的小例子
09-05
Java连接Redis的小例子展示了如何使用Jedis库与Redis数据库进行交互。Redis是一个高性能的键值存储系统，常用于缓存、消息队列等场景。在Java应用中，Jedis是官方推荐的客户端库，提供了丰富的API来操作Redis。 ...
java操作redis
12-25
2. **连接Redis服务器**：在Java代码中，你可以通过创建Jedis实例来建立到Redis服务器的连接： ```java Jedis jedis = new Jedis("localhost", 6379); ``` 3. **基本操作**：一旦连接建立，你可以使用Jedis对象...
Java 读取写Redis里的数据
07-12
启动时，现将自己电脑内的Redis运行起来。里面有测试类，可选择性进行测试不同数据类型的读写方式。
Java操作redis常见类型数据存储
让优秀成为一种习惯！
11-04 7391
redis与mysq都是数据库，java操作redis其实跟操作mysql的过程是差不多的，首先都是导入依赖、建立连接，只是方式不同，redis是非关系数据库而mysql是关系数据库。
一个简单的例子来说明java如何使用 Redis 缓存数据
m0_61523691的博客
06-19 1749
具体来说，当应用程序需要查询数据时，会先尝试从 Redis 缓存中获取数据，如果缓存中存在需要的数据，则直接返回缓存数据，否则从数据库中读取数据，并将数据写入 Redis 缓存，以便下一次查询时可以直接从缓存中获取数据，从而提高数据访问速度。用户信息存储在 MySQL 数据库中，但是由于用户信息经常被查询，我们希望将用户信息缓存到 Redis 中，以提高查询速度。在实际工作中，我们通常会将经常被查询的数据存储到 Redis 缓存中，这样可以大大提高数据的访问速度，减轻数据库的压力。
java 数据存入redis_Java简单的使用redis存、取数据
weixin_29031161的博客
02-13 7496
简单的使用redis存、取数据首先，redis配置类如下：package org.jeecg.config;import java.lang.reflect.Method;import java.time.Duration;import java.util.Arrays;import javax.annotation.Resource;import org.jeecg.common.constan...
在Java中如何使用Redis进行数据存储
weixin_43877946的博客
11-30 2653
RedisRedis 简介Redis在Linux下的安装Redis 的五中数据类型Redis 与spring的整合 Redis 简介 redis是当前比较热门的NOSQL系统之一，它是一个key-value存储系统。它支持存储的value类型相对更多，包括string、list、set、zset和hash。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作...
java集成redis简单存储
yushun的博客
02-21 729
将数据存redis并设置过期时间、通过key删除redis、通过key更新redis（续期）
利用java将数据加入redis缓存
2401_83601703的博客
04-01 1412
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
Java使用redis:将数据插入redis缓存的方式
学英语的程序员
03-28 3016
redis.pool.maxTotal=1000 redis.pool.maxIdle=200 redis.pool.maxWaitMillis=2000 redis.pool.testOnBorrow=true jedis.host=127.0.0.1 jedis.port=6379
Jedis事务详解：Java连接Redis缓存实战
"本文将详细介绍【Redis缓存机制】在Java环境中的应用，特别是通过Jedis库进行连接和事务处理。Redis作为一款高性能的键值存储系统，其事务机制对于提高数据一致性、减少网络开销具有重要作用。在Java开发中，Jedis...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值