精华内容
下载资源
问答
  • Redis--java存取Redis中数据

    万次阅读 2017-07-12 21:59:42
    1 Window下运行Redis服务器。 通过在网上查找资料可知,Window下是不支持Redis的,但是在GitHub上有人开发出了window的版本,我也很无奈,具体过程参考http://www.cnblogs.com/smileyearn/articles/4749746.html,...

    1 Window下运行Redis服务器。
    通过在网上查找资料可知,Window下是不支持Redis的,但是在GitHub上有人开发出了window的版本,我也很无奈,具体过程参考http://www.cnblogs.com/smileyearn/articles/4749746.html,此时不在赘述,直接将GitHub上下载文件放在一个位置,通过如下命令即可启动服务器可客户端。
    启动服务器:D:\ProgramFiles\Redis-x64-3.2.100>redis-server redis.windows.conf
    启动客户端:D:\ProgramFiles\Redis-x64-3.2.100>redis-cli.exe -h 127.0.0.1 -p 6379

    2 java存储基础数据类型至Redis。
    redis客户端选择jedis,下载地址https://mvnrepository.com/artifact/redis.clients/jedis
    如下是java代码demo。redis中的差不多每一个命令都对应jedis类中方法,可查看官网了解具体说明。

    public class TextMain {
    
        private static Jedis jedis;
    
        static {
            jedis = RedisUtil.connection();
        }
    
        public static void textString() {
            System.out.println("String类型测试开始:");
            jedis.set("runoobkey", "www.runoob.com");
            System.out.println("redis存储字段runoobkey:" + jedis.get("runoobkey"));
            jedis.close();
        }
    
        /**
         * 测试存储多个映射,该方法可用于存储对象
         */
        public static void textHash() {
    
            Map<String, String> map = new HashMap<String, String>();
            map.put("id", "张三");
            map.put("username", "张三");
            map.put("password", "123123");
    
            String result = jedis.hmset("01", map);// 设置键为01
            System.out.println("存储后方法的返回值:" + result);
            System.out.println("取出值:" + jedis.hgetAll("01"));
            jedis.close();
        }
    
        public static void textList() {
            System.out.println("List类型测试开始。。。");
            jedis.lpush("lst", "List01", "List02");
            System.out.println("List中第一个数据为:" + jedis.lindex("lst", 1));
            System.out.println("List中第二个数据为:" + jedis.lindex("lst", 2));
            jedis.close();
        }
    
        public static void textSet() {
            System.out.println("测试Set类型开始。。。");
            jedis.sadd("set", "set01", "set02");
            Set<String> set = jedis.smembers("set");
            System.out.println("Set中各个数据为:");
            for (String string : set) {
                System.out.println(string);
            }
            jedis.close();
        }
    
        /**
         * 成员根据sorce进行从小到大的排序。
         */
        public static void textSortSet() {
            System.out.println("开始测试SortSet...");
            Map<Double, String> map = new HashMap<Double, String>();
            map.put((double) 1, "张三");
            map.put((double) 3, "王五");
            map.put((double) 2, "李四");
            jedis.zadd("sortset", map);
    
            Set<String> set = jedis.zrange("sortset", 0, 2);
            System.out.println("SortSet中的元素:");
            for (String string : set) {
                System.out.println(string);
            }
            jedis.close();
        }
    }
    展开全文
  • 使用Java操作Redis的字符串类型、list链表类型、hash哈希表类型、set无序集合类型的数据,简单易懂。
  • 目前在做自动化测试时,设计到需要获取存储redis中的值,总结了操作代码如下: 需要jar包:  code如下: package util; import java.util.Iterator; import java.util.List; import java.util.Set; import ...

    目前在做自动化测试时,设计到需要获取存储在redis中的值,总结了操作代码如下:

    需要jar包:jedis-2.7.3.jar、commons-pool2-2.4.1.jar

     code如下:

    package cn.migu.utils;
    
    import java.util.Iterator;
    import java.util.List;
    
    import cn.migu.base.GlobalSettings;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    /**
     * <Description>redis相关操作类
     * @author YanLu
     *
     */
    public class RedisUtil {
    	private JedisPool pool=null;
    	private Jedis redis = null;
    	Log4jUtil log = new Log4jUtil(this.getClass().getName());
    	//构造函数,创建对象时进行初始化
    	public RedisUtil() {
    		if (pool == null) {
    			/*
    			// 池基本配置
    			//JedisPoolConfig config = new JedisPoolConfig();
    			// 最大连接数, 默认8个
    			config.setMaxTotal(20);
    			// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
    			config.setMaxIdle(5);
    			// 表示当borrow(引入)一个jedis实例时,最大的等待时间,如果超过等待时间,则直接抛出JedisConnectionException;
    			config.setMaxWaitMillis(10000);
    			// 在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
    			config.setTestOnBorrow(false);
    			*/
    			
    			//创建redis连接池
    			//this.pool = new JedisPool(config,"172.18.173.188",6379);
    			this.pool = new JedisPool(new JedisPoolConfig(), GlobalSettings.getProperty("redis.master.host"), Integer.parseInt(GlobalSettings.getProperty("redis.master.port")));
    			//获取Jedis实例
    			this.redis = pool.getResource();
    			log.info("Connection to redis server sucessfully");
    		}
    	}
    	
    	/**
    	 * 关闭连接
    	 * @param pool
    	 * @param redis
    	 */
    	public void quitConnection(Jedis redis) {
    		if (redis != null) {
    			redis.quit();
    			//pool.returnResource(redis);
    		}
    	}
    	
    	/**
    	 * 获取key对应的value
    	 * 
    	 * 说明:方法中目前只针对key数据类型为String和hash的情况作了处理,其他数据类型可根据需要进行扩展即可
    	 * @param key
    	 * @return
    	 */
    	public String getValue(String key){
    		String value = null;
    		try {
    			if(redis == null || !redis.exists(key)){
    				log.info("key:"+key+" is not found");
    				quitConnection(redis);
    				return value;
    			}
    			//获取key对应的数据类型
    			String type = redis.type(key);
    			log.info("key:" + key + " 的类型为:" + type);
    			if(type.equals("string")){
    				//get(key)方法返回key所关联的字符串值
    				value = redis.get(key);
    			}
    			if(type.equals("hash")){
    				//一下方法仅适用于list.size=1时,否者value将取集合中最后一个元素的值
    				List<String> list = redis.hvals(key);//hvals(key)返回哈希表 key 中所有域的值
    				//Set<String> set = redis.hkeys(key);
    				Iterator<String> it=list.iterator();
    				while(it.hasNext()){   
    			        value = it.next();
    			        log.info("value:"+value);
    				}
    			}
    			if(type.equals("list")){
    				log.info(key+"类型为list暂未处理...");
    			}
    			if(type.equals("set")){
    				log.info(key+"类型为list暂未处理...");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			//关闭连接
    			quitConnection(redis);
    		}
    		return value;
    	}
    	
    </pre><p></p><p></p><p>测试代码如下:</p><p><pre name="code" class="java">package cn.migu.test;
    
    import org.testng.annotations.Test;
    
    import cn.migu.utils.Log4jUtil;
    import cn.migu.utils.RedisUtil;
    
    /**
     * <Description> 测试RedisUtil类
     * @author YanLu
     * 
     */
    public class TestRedis {
    	private Log4jUtil log = new Log4jUtil(this.getClass().getName());
    	@Test
    	public void testRedisUtil(){
    		RedisUtil ru = new RedisUtil();
    		//获取redis中对应的value值
    		String value=ru.getValue("SMS_NODE_TIMES_13814528620");
    		log.info(value);	
    	}
      
    }
    


    展开全文
  • 主要介绍了Java 实现Redis存储复杂json格式数据并返回给前端操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • javaredis中存储对象

    万次阅读 2018-03-21 18:19:45
    最近需要封装一个操作redis的工具类,不知道怎么向redis中存储对象,想到过用java反射去做。在网上搜索了一下,发现可以用序列化对象的方式去存储。再此我整理了一下感谢,残剑_提供的方法:...

    最近需要封装一个操作redis的工具类,不知道怎么向redis中存储对象,想到过用java反射去做。在网上搜索了一下,发现可以用序列化对象的方式去存储。再此我整理了一下

    感谢,残剑_提供的方法:http://www.cnblogs.com/liuling/p/2014-4-19-04.html(redis基础操作)

    感谢,萧剑90提供的方法:http://blog.csdn.net/abc19900828/article/details/40373549(redis存储对象)

    使用Java操作Redis需要jedis-2.1.0.jar,下载地址:http://files.cnblogs.com/liuling/jedis-2.1.0.jar.zip

    如果需要使用Redis连接池的话,还需commons-pool-1.5.4.jar,下载地址:http://files.cnblogs.com/liuling/commons-pool-1.5.4.jar.zip

    以下是我借鉴之后整理的代码,简单封装。

    一、redis连接池

    RedisConnectionPool
    package dao.redisUtil;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    public class RedisConnectionPool {
    
    
        //Redis服务器IP
        private static String IP = "localhost";
    
        //Redis的端口号
        private static int PORT = 6379;
    
        //访问密码
    //    private static String AUTH = "admin";
    
        //可用连接实例的最大数目,默认值为8;
        //如果赋值为-1,则表示不限制;如果pool已经分配了maxActive个jedis实例,则此时pool的状态为exhausted(耗尽)。
        private static int MAX_ACTIVE = 1024;
    
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例,默认值也是8。
        private static int MAX_IDLE = 200;
    
        //等待可用连接的最大时间,单位毫秒,默认值为-1,表示永不超时。如果超过等待时间,则直接抛出JedisConnectionException;
        private static int MAX_WAIT = 10000;
    
        private static int TIMEOUT = 10000;
    
        //在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
        private static boolean TEST_ON_BORROW = true;
    
        private static JedisPool jedisPool = null;
    
        /**
         * 初始化Redis连接池
         */
        static {
            try {
                JedisPoolConfig config = new JedisPoolConfig();
                config.setMaxActive(MAX_ACTIVE);
                config.setMaxIdle(MAX_IDLE);
                config.setMaxWait(MAX_WAIT);
                config.setTestOnBorrow(TEST_ON_BORROW);
    
                jedisPool = new JedisPool(config, IP, PORT, TIMEOUT);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 获取Jedis实例
         * @return
         */
        public synchronized static Jedis getJedis() {
            try {
                if (jedisPool != null) {
                    Jedis resource = jedisPool.getResource();
                    return resource;
                } else {
                    return null;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 释放jedis资源
         * @param jedis
         */
        public static void returnResource(final Jedis jedis) {
            if (jedis != null) {
                jedisPool.returnResource(jedis);
            }
        }
    }
    

    二、序列化对象方法

    SerializeUtil
    package dao.redisUtil;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /**
     * @author Administrator
     * 序列化对象工具类
     */
    public class SerializeUtil {
        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 (Exception e) {
    
            }
            return null;
        }
    
        public static Object unserialize( byte[] bytes) {
            ByteArrayInputStream bais = null;
            try {
                // 反序列化
                bais = new ByteArrayInputStream(bytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (Exception e) {
    
            }
            return null;
        }
    }

    三、封装redis增删改查基础操作

    RedisOperation
    package dao.redisUtil;
    
    
    import redis.clients.jedis.Jedis;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 实现redis操作
     */
    public class RedisOperation{
        //获取redis操作实例
        private Jedis jedis=RedisConnectionPool.getJedis();
    
        public String set(String key, HashMap<String,String> map) {
            return jedis.hmset(key,map);
        }
    
        public String set(byte[] key, HashMap<byte[], byte[]> map) {
            return jedis.hmset(key,map);
        }
    
        public String set(String key, List<String> list) {
            Long aLong=-1l;
            for (String value:list
                 ) {
                aLong = jedis.lpush(key,value);
            }
            return aLong<=0?"error":"OK";
        }
    
        public String set(byte[] key, List<byte[]> list) {
            Long aLong=-1l;
            for (byte[] value:list
                    ) {
                aLong=jedis.lpush(key,value);
            }
            return aLong<=0?"error":"OK";
        }
    
        public String set(String key, String value) {
            return jedis.set(key,value);
        }
    
        public String set(byte[] key, byte[] value) {
            return jedis.set(key, value);
        }
    
        public String set(String key, Set<String> set) {
            Long aLong=-1l;
            for (String value:set
                 ) {
                aLong=jedis.sadd(key,value);
            }
            return aLong<=0?"error":"OK";
        }
    
        public String set(byte[] key, Set<byte[]> set) {
            Long aLong=-1l;
            for (byte[] value:set
                    ) {
                aLong=jedis.sadd(key,value);
            }
            return aLong<=0?"error":"OK";
        }
    
        //redis写入对象,用序列化对象的方式
        public String set(String key, Object Obj) {
           return  jedis.set(key.getBytes(),SerializeUtil.serialize(Obj));
        }
    
        public Object get(String key) {
            Object object=null;
            //获取value的类型
            String type=jedis.type(key);
            //根据不同类型调用不同的获取方法
            if(type.toLowerCase().equals("map")){
                object=jedis.hgetAll(key);
            }else if(type.toLowerCase().equals("set")){
                object=jedis.smembers(key);
            }else if(type.toLowerCase().equals("list")){
                object=jedis.lrange(key,0,-1);
            }else if (type.toLowerCase().equals("string")){
                byte[] bytes=jedis.get(key.getBytes());
                object=SerializeUtil.unserialize(bytes);
                if(object==null){
                    object=jedis.get(key);
                }
            }
            return object;
        }
    
        public Object get(byte[] key) {
            return null;
        }
    
        public Long delete(String key) {
            return jedis.del(key);
        }
    
        public String update(String key,Object value){
            //先删除原有数据
            Long along = jedis.del(key);
            if(along<0){
                return "error";
            }
            //再重新添加
            if(value instanceof Map){
                set(key,(Map)value);
            }else if(value instanceof Set){
                set(key,(Set) value);
            }else if(value instanceof List){
                set(key,(List) value);
            }else if(value instanceof String){
                set(key,(String)value);
            }else {
                set(key,value);
            }
            return "OK";
        }
    }
    

    展开全文
  • Java操作Redis存储对象类型数据

    千次阅读 2018-12-24 11:41:15
     关于JAVA去操作Redis时,如何存储一个对象的数据,这是大家非常关心的问题,虽然官方提供了存储String,List,Set等等类型,但并不满足我们现在实际应用。存储一个对象是非常常见的。经过网上查找资料以及参考其他...

    背景描述

         关于JAVA去操作Redis时,如何存储一个对象的数据,这是大家非常关心的问题,虽然官方提供了存储String,List,Set等等类型,但并不满足我们现在实际应用。存储一个对象是非常常见的。经过网上查找资料以及参考其他网友的代码和实践操作后,整理出Redis如何存储一个对象的demo代码,如果有错误的地方大家可以留言指出。

    参考资料

    参考地址:

    https://blog.csdn.net/bang_come/article/details/79098866

    https://www.cnblogs.com/JKayFeng/p/5911544.html

    原理

    在存储对象时先进行序列化,取出数据时再进行反序列化。

     

    Redis版本

    Redis3.0

    https://mvnrepository.com/artifact/redis.clients/jedis

    Demo如下

    Bean代码

    package com.obj.bean;

    import java.io.Serializable;

    public class Person implements Serializable {
        /**
         * 序列化
         */
        private static final long serialVersionUID = 1L;
        public String userName;
        public String password;
        public int age;
        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;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        

    }


    序列化工具类代码

    package com.serial.tool;

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

    public class SerializeObjectTool {
        //序列化
        public static byte[] serialize(Object obj) {
            ObjectOutputStream obi = null;
            ByteArrayOutputStream bai = null;
            try {
                bai = new ByteArrayOutputStream();
                obi = new ObjectOutputStream(bai);
                obi.writeObject(obj);
                byte[] byt = bai.toByteArray();
                return byt;
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        // 反序列化
        public static Object unserizlize(byte[] byt) {
            ObjectInputStream oii = null;
            ByteArrayInputStream bis = null;
            bis = new ByteArrayInputStream(byt);
            try {
                oii = new ObjectInputStream(bis);
                Object obj = oii.readObject();
                return obj;
            } catch (Exception e) {

                e.printStackTrace();
            }

            return null;
        }

    }

    测试代码

    package com.redis.client;

    import com.obj.bean.Person;
    import com.serial.tool.SerializeObjectTool;

    import redis.clients.jedis.Jedis;

    public class RedisObjectClient {

        public static void main(String[] args) {
            // TODO Auto-generated method stub

            Jedis redis = new Jedis("10.190.130.143", 6379);
            redis.auth("sa123456");

            // 存对象
            Person p = new Person(); // peson类记得实现序列化接口 Serializable
            p.setAge(20);
            p.setUserName("姚波");
            p.setPassword("123456");
            byte[] personByte = SerializeObjectTool.serialize(p);
            redis.set("person".getBytes(), personByte);

           //取对象
            byte[] byt = redis.get("person".getBytes());
            Object obj = SerializeObjectTool.unserizlize(byt);
            if (obj instanceof Person) {
                System.out.println(((Person) obj).getUserName());
                System.out.println(((Person) obj).getPassword());
                System.out.println(((Person) obj).getAge());
            }

        }

    }

    运行结果

    查看redis

    展开全文
  • 问题背景 在Java Web项目,经常需要前端请求数据,后台从数据库查询并计算最后返回json格式数据给前端。...而自己在项目遇到的json格式数据比较复杂,下面记录一下redis存储对象和json格式数...
  • 看了一天NoSql的Redis数据库,命令太多了不总结了,整理一下数据类型和JavaRedis的相关操作。
  • Java操作Redis存储HashMap对象类型数据

    万次阅读 2018-12-24 17:34:23
     关于JAVA去操作Redis时,如何存储一个对象的数据,这是大家非常关心的问题,虽然官方提供了存储String,List,Set等等类型,但并不满足我们现在实际应用。存储一个对象是非常常见的。经过网上查找资料以及参考其他...
  • 主要介绍redis五种数据类型在Java中的详细使用 , 注释特别详细, 里面有我邮箱, 不懂的地方随时问我. 非常值得学习. 更多redis资料, 请与我邮箱联系!
  • Java使用redis:将数据插入redis缓存的方式

    万次阅读 多人点赞 2018-07-01 15:48:37
    背景:当redis里面需要存储 “key-字符串,value-对象” 时,是不能直接存对象,而是需要将序列化后或转换为JSON后的对象存进redisredis没有实现内部序列化对象的功能,所以需要自己提前序列化对象及转换为Json...
  • 存储数据, 设置数据超时时间 public void sendMsg(){ stringRedisTemplate.opsForValue().set("test1", "abc"); stringRedisTemplate.expire("test1", 30, TimeUnit.SECONDS); } ...
  • 由于简单的操作Redis的基本类型在网上很容易就找到一堆资料,所以今天笔者主要写如何使用redis存储自定义类型。 Redis支持的基本类型String,而且在我试验的过程发现无论是List还是Map也都只能放String类型的...
  • ##### 现在做一个小demo,读取文本txt(文本是分行的),需求是读取到之后每隔三秒钟往redis中存储一条数据,我现在已经做了读取txt文本,并且输出为list集合,卡到这步了,想用定时器不知道怎么写,有没有大神们贴...
  • redis入门: 1、Redis服务器搭建 2、向业务逻辑添加缓存。 3、使用redis做缓存 4、缓存同步
  • 记录一下map数据存储redis,设置过期时间,直接存储直接获取,不经过转数据格式 RedisTemplate.opsForHash().putAll(key,value)存储Map数据 RedisTemplate.expire(key,时间,TimeUnit.SECONDS)设置redis的过期时间 ...
  • Java连接Redis存取数据(详细)

    千次阅读 2020-02-12 22:15:19
    Java连接Redis存取数据一.相关工具二.准备工作1.启动redis2.外部连接测试3.新建连接。4.连接成功三.新建jedis项目1.新建项目2.命名项目3.引入相关jar包4.引入 junit5.新建包com.redis.test四.编写代码1.redis....
  • Java中使用redis的ZSet数据结构

    千次阅读 2020-12-10 16:55:01
    最近项目搜索功能,有搜索热词(搜索量前10)需求,准备用redis的zset来解决 下面列出核心用到的几个方法 插入数据 /** * ZSet塞值 * @param key (ZSet集合的名称) * @param socre (分数) * @param member...
  • JavaRedis数据进行MapReduce

    千次阅读 2019-03-06 21:25:48
    前言: MapReduce 简称 MR是一个框架可以使用它来编写分布式处理...下面将介绍java基于Redisson-Redis的内存数据网格使用MapReduce处理存储Redis中数据。 什么是MapReduce? MapReduce 是一种可以用Java实...
  • 文章目录: 1.安装与导入 1.1 测试代码 2.Java中使用Redis命令 2.1 对数据类型String进行简单操作 2.2对数据类型List进行简单操作...在 Java 使用 Redis 前, 我们需要确保已经安装了 redis 服务及 Java redi...
  • 最近刚换了一家公司,看了下公司Java后台代码关于redis存储数据的代码,里面是这样写的: public void setAttribute(Object key,Object value){ redisTemplate.opsForHash().put(SessionUtil.getToken(),key,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 136,972
精华内容 54,788
关键字:

java往redis中存储数据

java 订阅
redis 订阅