精华内容
下载资源
问答
  • Redis是一个著名的key-value存储系统,也是nosql中的最常见的一种,这篇文章主要给大家总结了关于在java中jedis操作redis的几种常见方式,文中给出了详细的示例代码供大家参考学习,需要的朋友们下面来一起看看吧。
  • Redis是一个著名key-value存储系统,也是nosql中最常见。其实,个人认为,redis最强大地方不在于其存储,而在于其强大缓存作用。 我们可以把它想象成一个巨大(多借点集群,聚合多借点内存)...

    Redis是一个著名的key-value存储系统,也是nosql中的最常见的一种。其实,个人认为,redis最强大的地方不在于其存储,而在于其强大的缓存作用。

    我们可以把它想象成一个巨大的(多借点集群,聚合多借点的内存)的Map,也就是Key-Value。

    所以,我们可以把它做成缓存组件。

    官方推荐的Java版客户端是jedis,非常强大和稳定,支持事务、管道及有jedis自身实现。我们对redis数据的操作,都可以通过jedis来完成。

    更多redis的概念,请参考:Redis集群(Redis3.0)

    那我们就来看一看,jedis不同的调用方式:

    (1)普通同步方式

    这是一种最简单和最基础的调用方式,对于简单的数据存取需求,我们可以通过这种方式调用。

    [java] view plain copy
     print?
    1. public void jedisNormal() {  
    2.     Jedis jedis = new Jedis("localhost");  
    3.     long start = System.currentTimeMillis();  
    4.     for (int i = 0; i < 100000; i++) {  
    5.         String result = jedis.set("n" + i, "n" + i);  
    6.     }  
    7.     long end = System.currentTimeMillis();  
    8.     System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");  
    9.     jedis.disconnect();  
    10. }  
    11. //每次set之后都可以返回结果,标记是否成功。  


    (2)事务方式(Transactions)

    所谓事务,即一个连续操作,是否执行是一个事务,要么完成,要么失败,没有中间状态。

    而redis的事务很简单,他主要目的是保障,一个client发起的事务中的命令可以连续的执行,而中间不会插入其他client的命令,也就是事务的连贯性。

    [java] view plain copy
     print?
    1. public void jedisTrans() {  
    2.     Jedis jedis = new Jedis("localhost");  
    3.     long start = System.currentTimeMillis();  
    4.     Transaction tx = jedis.multi();  
    5.     for (int i = 0; i < 100000; i++) {  
    6.         tx.set("t" + i, "t" + i);  
    7.     }  
    8.     List<Object> results = tx.exec();  
    9.     long end = System.currentTimeMillis();  
    10.     System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");  
    11.     jedis.disconnect();  
    12. }  
    13. //我们调用jedis.watch(…)方法来监控key,如果调用后key值发生变化,则整个事务会执行失败。另外,事务中某个操作失败,并不会回滚其他操作。这一点需要注意。还有,我们可以使用discard()方法来取消事务。  


    (3)管道(Pipelining)

    管道是一种两个进程之间单向通信的机制。

    那再redis中,为何要使用管道呢?有时候,我们需要采用异步的方式,一次发送多个指令,并且,不同步等待其返回结果。这样可以取得非常好的执行效率。

    [java] view plain copy
     print?
    1. public void jedisPipelined() {  
    2.     Jedis jedis = new Jedis("localhost");  
    3.     Pipeline pipeline = jedis.pipelined();  
    4.     long start = System.currentTimeMillis();  
    5.     for (int i = 0; i < 100000; i++) {  
    6.         pipeline.set("p" + i, "p" + i);  
    7.     }  
    8.     List<Object> results = pipeline.syncAndReturnAll();  
    9.     long end = System.currentTimeMillis();  
    10.     System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");  
    11.     jedis.disconnect();  
    12. }  


    (4)管道中调用事务

    对于,事务以及管道,这两个概念我们都清楚了。

    在某种需求下,我们需要异步执行命令,但是,又希望多个命令是有连续的,所以,我们就采用管道加事务的调用方式。jedis是支持在管道中调用事务的。

    [java] view plain copy
     print?
    1. public void jedisCombPipelineTrans() {  
    2.     jedis = new Jedis("localhost");   
    3.     long start = System.currentTimeMillis();  
    4.     Pipeline pipeline = jedis.pipelined();  
    5.     pipeline.multi();  
    6.     for (int i = 0; i < 100000; i++) {  
    7.         pipeline.set("" + i, "" + i);  
    8.     }  
    9.     pipeline.exec();  
    10.     List<Object> results = pipeline.syncAndReturnAll();  
    11.     long end = System.currentTimeMillis();  
    12.     System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");  
    13.     jedis.disconnect();  
    14. }  
    15. //效率上可能会有所欠缺  


    (5)分布式直连同步调用

    这个是分布式直接连接,并且是同步调用,每步执行都返回执行结果。类似地,还有异步管道调用。

    其实就是分片。

    [java] view plain copy
     print?
    1. public void jedisShardNormal() {  
    2.     List<JedisShardInfo> shards = Arrays.asList(  
    3.             new JedisShardInfo("localhost",6379),  
    4.             new JedisShardInfo("localhost",6380));  
    5.    
    6.     ShardedJedis sharding = new ShardedJedis(shards);  
    7.    
    8.     long start = System.currentTimeMillis();  
    9.     for (int i = 0; i < 100000; i++) {  
    10.         String result = sharding.set("sn" + i, "n" + i);  
    11.     }  
    12.     long end = System.currentTimeMillis();  
    13.     System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");  
    14.    
    15.     sharding.disconnect();  
    16. }  


    (6)分布式直连异步调用

    [java] view plain copy
     print?
    1. public void jedisShardpipelined() {  
    2.     List<JedisShardInfo> shards = Arrays.asList(  
    3.             new JedisShardInfo("localhost",6379),  
    4.             new JedisShardInfo("localhost",6380));  
    5.    
    6.     ShardedJedis sharding = new ShardedJedis(shards);  
    7.    
    8.     ShardedJedisPipeline pipeline = sharding.pipelined();  
    9.     long start = System.currentTimeMillis();  
    10.     for (int i = 0; i < 100000; i++) {  
    11.         pipeline.set("sp" + i, "p" + i);  
    12.     }  
    13.     List<Object> results = pipeline.syncAndReturnAll();  
    14.     long end = System.currentTimeMillis();  
    15.     System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");  
    16.    
    17.     sharding.disconnect();  
    18. }  


    (7)分布式连接池同步调用

    如果,你的分布式调用代码是运行在线程中,那么上面两个直连调用方式就不合适了,因为直连方式是非线程安全的,这个时候,你就必须选择连接池调用。

    连接池的调用方式,适合大规模的redis集群,并且多客户端的操作。

    [java] view plain copy
     print?
    1. public void jedisShardSimplePool() {  
    2.     List<JedisShardInfo> shards = Arrays.asList(  
    3.             new JedisShardInfo("localhost",6379),  
    4.             new JedisShardInfo("localhost",6380));  
    5.    
    6.     ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);  
    7.    
    8.     ShardedJedis one = pool.getResource();  
    9.    
    10.     long start = System.currentTimeMillis();  
    11.     for (int i = 0; i < 100000; i++) {  
    12.         String result = one.set("spn" + i, "n" + i);  
    13.     }  
    14.     long end = System.currentTimeMillis();  
    15.     pool.returnResource(one);  
    16.     System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");  
    17.    
    18.     pool.destroy();  
    19. }  


    (8)分布式连接池异步调用

    [java] view plain copy
     print?
    1. public void jedisShardPipelinedPool() {  
    2.     List<JedisShardInfo> shards = Arrays.asList(  
    3.             new JedisShardInfo("localhost",6379),  
    4.             new JedisShardInfo("localhost",6380));  
    5.    
    6.     ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);  
    7.    
    8.     ShardedJedis one = pool.getResource();  
    9.    
    10.     ShardedJedisPipeline pipeline = one.pipelined();  
    11.    
    12.     long start = System.currentTimeMillis();  
    13.     for (int i = 0; i < 100000; i++) {  
    14.         pipeline.set("sppn" + i, "n" + i);  
    15.     }  
    16.     List<Object> results = pipeline.syncAndReturnAll();  
    17.     long end = System.currentTimeMillis();  
    18.     pool.returnResource(one);  
    19.     System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");  
    20.     pool.destroy();  
    21. }  


    (9)需要注意的地方

    • 事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用,都是不允许的:

    • [java] view plain copy
       print?
      1. Transaction tx = jedis.multi();  
      2.  for (int i = 0; i < 100000; i++) {  
      3.      tx.set("t" + i, "t" + i);  
      4.  }  
      5.  System.out.println(tx.get("t1000").get());  //不允许  
      6.    
      7.  List<Object> results = tx.exec();  
      8.    
      9.  …  
      10.  …  
      11.    
      12.  Pipeline pipeline = jedis.pipelined();  
      13.  long start = System.currentTimeMillis();  
      14.  for (int i = 0; i < 100000; i++) {  
      15.      pipeline.set("p" + i, "p" + i);  
      16.  }  
      17.  System.out.println(pipeline.get("p1000").get()); //不允许  
      18.    
      19.  List<Object> results = pipeline.syncAndReturnAll();  


    • 事务和管道都是异步的,个人感觉,在管道中再进行事务调用,没有必要,不如直接进行事务模式。

    • 分布式中,连接池的性能比直连的性能略好(见后续测试部分)。

    • 分布式调用中不支持事务。

    • 因为事务是在服务器端实现,而在分布式中,每批次的调用对象都可能访问不同的机器,所以,没法进行事务。

    (10)总结

    • 分布式中,连接池方式调用不但线程安全外,根据上面的测试数据,也可以看出连接池比直连的效率更好。

    • 经测试分布式中用到的机器越多,调用会越慢。


    展开全文
  • 二、事务方式(Transactions)redis 事务很简单,他主要目的是保障,一个client发起事务中命令可以连续执行,而中间不会插入其他client命令。调用jedis.watch(…)方法来监控key,如果调用后key值发生变化,...

    在这里对 jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比:

    直接同步方式

    最简单的调用方式。

    d700f624e936d892ef98f55154a2cc6f.png

    二、事务方式(Transactions)

    redis 的事务很简单,他主要目的是保障,一个client发起的事务中的命令可以连续的执行,而中间不会插入其他client的命令。调用jedis.watch(…)方法来监控key,如果调用后key值发生变化,则整个事务会执行失败。另外,事务中某个操作失败,并不会回滚其他操作。这一点需要注意。还有,可以使用discard()方法来取消事务。

    dd093d94c4309c14c6d9308300b555df.png

    三、管道(Pipelining)异步方式

    有时,我们需要采用异步方式,一次发送多个指令,不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道,调用方法如下:

    72fd91d2844c66ea99e4b95f77c50d76.png

    四、分布式直连同步调用

    5c5acf3556da82304be3fa582b52d0ae.png

    五、分布式直连异步调用

    d5b2319b35a696383a39a470d4280176.png

    6、 分布式连接池同步调用

    756ce2fb2f6394bec76409aac27bd782.png

    七、分布式连接池异步调用

    08b55d4612a22a0c0ace01ae72af9734.png

    八、注意

    1、事务和管道都是异步模式。在事务和管道中不能同步查询结果。

    2、分布式中,连接池的性能比直连的性能略好。

    3、分布式调用中不支持事务。因为事务是在服务器端实现,而在分布式中,每批次的调用对象都可能访问不同的机器,所以,没法进行事务。

    4、分布式中,连接池方式调用线程安全。

    展开全文
  • redis 存储自定义java对象有几种方式

    千次阅读 2016-04-22 01:23:45
    最近去面试,碰到面试官提问,如果要把一个自定义的java对象存储到redis中,除了一般使用json和序列化之外,还有一,可以配置redis的配置文件,操作hash类型,直接使用HGETALL (或者其他操作hash的命令),取出来...

    最近去面试,碰到面试官提问,如果要把一个自定义的java对象存储到redis中,除了一般使用json和序列化之外,还有一种,可以配置redis的配置文件,操作hash类型,直接使用HGETALL (或者其他操作hash的命令),取出来就会是一个java对象??


    可以,其实对象无非就是一堆的键值对嘛,可以直接用redis里面的map结构来存储,每个属性都是一个key.
    代码就类似下面这样.
    Map<String, String> data = new HashMap<String , String();
    jedis.hmset("product:1", data);

    取出来的话就这样:
    Map<String, String> data = jedis.hgetAll(key);
    再把这个map转换成对象.
    他说取出来直接就是java对象那是扯犊子

    展开全文
  • 余额宝一面JVM 内存分哪几个区,每个区作用是什么?JVM有哪些回收算法,对应收集器有哪些?GC 两种判定方法 ?CMS 收集器与 G1 收集器特点。hashmap源码问题HashMap、...java线程同步都有哪几种方式,在 ...

    c3b08b70a44b72ed470303cfbb10e413.png

    075ef18c0512c4be7f118e54148dcc06.png


    余额宝一面

    1. JVM 内存分哪几个区,每个区的作用是什么?JVM有哪些回收算法,对应的收集器有哪些?
    2. GC 的两种判定方法 ?CMS 收集器与 G1 收集器的特点。
    3. hashmap源码问题
    4. HashMap、HashMap如何保证线程安全、ConcurrentHashMap
    5. HashMap底层结构 put操作讲一下
    6. GC 的两种判定方法 ?CMS 收集器与 G1 收集器的特点。
    7. java线程同步都有哪几种方式,在 Java 中 CycliBarriar 和 CountdownLatch 有什么区别?
    8. cas的原理,变量要用哪个关键字修饰,volatile实现的原理。
    9. 你在多线程环境中遇到的常见的问题是什么?你是怎么解决它的?
    10. MYSQL 数据库服务器性能分析的方法命令有哪些?
    11. 什么是通用 SQL 函数?
    12. 手撕代码:按层次遍历二叉树?
    13. Java 配置的方式配置 Spring
    14. spring中用到了什么, 简述 AOP 和 IOC 概念,aop是怎么实现的?

    第一轮非常重要,第一面能通过,后续被录用的可能性就比较高了,建议系统性的学习面试题目
    余额宝二面

    1. 自我介绍&项目
    2. 项目用 Spring 比较多,有没有了解 Spring 的原理?AOP 和 IOC 的原理
    3. 分布式锁原理
    4. CAS 算法,CAS 与 synchronized 的使用情景
    5. 简洁描述 Mysql 中 InnoDB 支持的四种事务隔离级别名称,以及逐级之间的区别?
    6. 分别解决什么问题?
    7. dubbo有哪些模块,底层通信的原理?Dubbo 集群的负载均衡有哪些策略? 
    8. 如果让你实现一个https,你会怎么实现?
    9. 常用的负载均衡,该怎么用,你能说下吗?
    10. 常见的分布式事务方案有哪些?
    11. Dubbo 的核心功能?如何从0到1设计一个类似Dubbo的RPC框架?

    余额宝三面

    1. 再谈谈一致hash算法(redis)?
    2. 数据库索引,B+树的特性和建树过程。
    3. mysql相关的行锁,表锁;乐观锁,悲观锁
    4. 分布式锁的方案,redis和zookeeper哪个个好,如果是集群部署,高并发情况下哪个性能更好。
    5. activeMQ 发送消息的方式有哪些?activeMQ 如何调优
    6. 设计模式与重构,谈谈你对重构的理解
    7. Collections.sort底层排序方式
    8. 说说 Redis 哈希槽的概念?Redis 集群如何选择数据库?
    9. spring cloud的服务注册与发现是怎么设计的?

    余额宝四面

    1. 自己参与的项目,技术难度高的有哪些?
    2. 线上有实际的性能优化经验?
    3. 从SQL、JVM、架构、数据库四个方面讲讲优化思路,以及如何优先排序?
    4. redis的持久化方式,redis3.0原生集群和redis读写分离+哨兵机制区别
    5. 如果让你实现一个mq,怎么样保证消息不丢失
    6. 你熟悉哪些中间件,谈谈你对他们的理解,以及对应的使用场景区别?
    7. 最后,你有什么想问我的?

    HR面

    1. 你个人的最大的缺点是什么?
    2. 在工作中和生活中遇见最大的挑战是什么?是如何克服的?
    3. 未来有什么规划?
    4. 平时有哪些兴趣爱好

    以上就最新蚂蚁余额宝Java面试题,以下2019最新整理出的蚂蚁金服资深Java必考题和答案。

    45ca48b56e5d969dfaea0fdf576bbb0d.png

    777f0808f27906aa80b39d5ae49c65fd.png

    ea9d515203d206e5d7bd429dfb00ca96.png

    8b530e006e45de9f8a7ca091733b278b.png

    资料获取方式:

    私信我(面试)即可获取哦

    展开全文
  • 一、为什么要使用分布式锁我们在开发应用时候,如果需要对某一个共享变量进行多线程同步访问时候,可以使用我们学到的Java多线程18般武艺进行处理,并且可以完美运行,毫无Bug!注意这是单机应用,也就是...
  • Redis 所有操作都是原子性,还支持对操作合并后原子性操作,支持事务 通常我们都把数据存到关系型数据库中,但为了提升应用性能,我们应该把访频率高且不会经常变动数据缓存到内存中。。Redis 没有像...
  • 1.怎么保证缓存和数据库...2.Redis 持久化有几种方式? RBD(Redis Database):指定时间间隔对你数据进行快照存储 AOF(Append Only File):每一个收到写命令都通过 write 函数追加到文件中 3.Redis 怎么实现...
  • 余额宝一面JVM 内存分哪几个区,每个区作用是什么?JVM有哪些回收算法,对应收集器有哪些?GC 两种判定方法 ?CMS 收集器与 G1 收集器特点。hashmap源码问题HashMap、...java线程同步都有哪几种方式,在 ...

空空如也

空空如也

1 2 3 4 5 6
收藏数 108
精华内容 43
关键字:

java操作redis的几种方式

java 订阅
redis 订阅