峭壁雄峰
峭壁雄峰

Rdis的简单入门学习

redis
注：内容整理自【狂神说】
Redis是一种开放源代码（BSD许可）的内存中数据结构存储，用作数据库，缓存和消息中间件。

一、快速上手

1、基层配置

官网下载安装

https://redis.io/download

上传到/opt/redis-6.0.7

解压后

$ wget http://download.redis.io/releases/redis-6.0.7.tar.gz
$ tar xzf redis-6.0.7.tar.gz
$ cd redis-6.0.7
$ make

启动测试

./redis-server /opt/redis-6.0.7/redis.conf

$ src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

如果要实现redis从外部连接的目的需要满足的条件：

  • linux能够与外界正常通信
  • linux防火墙是关闭状态
  • redis.conf 中bind 127.0.0.1被注释掉了
  • 登录redis-cli中输入指令：config set protected-mode “no” 以关闭redis的受保护模式。

2、修改默认配置文件

redis默认是不支持后台启动，将配置文件里的不支持改为支持

/opt/redis-6.0.7/redis.conf

daemonize yes

关闭redis服务指令

shutdown
exit

3、通过自带的benchmark进行压测

./redis-benchmark -h localhost -p 6379 -c 100 -n 110000
====== PING_INLINE ======
  110000 requests completed in 1.75 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1
  host configuration "save": 900 1 300 10 60 10000
  host configuration "appendonly": no
  multi-thread: no

0.00% <= 0.6 milliseconds
1.16% <= 0.7 milliseconds
4.89% <= 0.8 milliseconds
12.22% <= 0.9 milliseconds
25.79% <= 1.0 milliseconds
40.54% <= 1.1 milliseconds
55.96% <= 1.2 milliseconds
71.00% <= 1.3 milliseconds
83.33% <= 1.4 milliseconds
90.59% <= 1.5 milliseconds
94.05% <= 1.6 milliseconds
96.15% <= 1.7 milliseconds
97.37% <= 1.8 milliseconds
98.22% <= 1.9 milliseconds
98.76% <= 2 milliseconds
100.00% <= 2 milliseconds
63037.25 requests per second

====== PING_BULK ======
  110000 requests completed in 1.70 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1
  host configuration "save": 900 1 300 10 60 10000
  host configuration "appendonly": no
  multi-thread: no

31.65% <= 1 milliseconds
98.98% <= 2 milliseconds
99.74% <= 3 milliseconds
99.81% <= 4 milliseconds
99.91% <= 5 milliseconds
99.95% <= 6 milliseconds
100.00% <= 6 milliseconds
64743.97 requests per second

====== SET ======
#110000条写入请求耗时1.72秒
  110000 requests completed in 1.72 seconds
#此次测试采用了100个并发客户端进行测试  
  100 parallel clients
#每次写入3个字节  
  3 bytes payload
#单机执行的该项测试  
  keep alive: 1
  host configuration "save": 900 1 300 10 60 10000
  host configuration "appendonly": no
  multi-thread: no

27.39% <= 1 milliseconds
99.12% <= 2 milliseconds
99.99% <= 3 milliseconds
100.00% <= 3 milliseconds
64139.94 requests per second

二、redis的基础知识

1、redis默认的16个数据库

默认使用的是第0个

127.0.0.1:6379> select 3  #查看第四个数据库
OK
127.0.0.1:6379[3]> DBSIZE #查看当前数据库大小
(integer) 0
127.0.0.1:6379[3]>
127.0.0.1:6379[3]> set name beijing  #设置一条数据，key 是name ,值是beijing
OK
127.0.0.1:6379[3]> keys * #查看当前库里的所有Key的值
1) "name"
127.0.0.1:6379[3]> flushdb #清除当前数据库
OK
127.0.0.1:6379[3]> FLUSHALL  #清除所有数据库
OK

2、Redis为什么这么快

1、完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。

2、数据结构简单，对数据操作也简单，Redis 中的数据结构是专门进行设计的；

3、采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；

4、使用多路 I/O 复用模型，非阻塞 IO；

5、使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis 直接自己构建了 VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；

三、redis的五大数据类型

注： 指令忘记了去官网查看。

1、（Redis-Key）String

127.0.0.1:6379> EXISTS name 		#判断名字为name的数据是否存在
(integer) 1
127.0.0.1:6379> EXISTS names		
(integer) 0
127.0.0.1:6379> move name 1			#移除当前库里key为name的数据
(integer) 1
127.0.0.1:6379> set name spring		
OK
127.0.0.1:6379> EXPIRE name 10		#设置key为name的数据的过期时间是10秒
(integer) 1
127.0.0.1:6379> ttl name			#查看key为name数据的过期时间还剩多少秒
(integer) 0
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> 
127.0.0.1:6379> type name			#查看当前key为name数据的key的数据类型
string
127.0.0.1:6379> APPEND name "boot"	#追加字符串，如果不存在就是新建key
(integer) 10
127.0.0.1:6379> STRLEN name			#获取字符串长度
(integer) 10
127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> incr views			#自增1
(integer) 1
127.0.0.1:6379> decr views			#自减1
(integer) 0
127.0.0.1:6379> INCRBY views 10		#用一次指令增10
(integer) 10
127.0.0.1:6379> DECRBY views 5		#用一次指令减5
(integer) 5
127.0.0.1:6379> set key1  helloworld
OK
127.0.0.1:6379> GETRANGE key1 0 3	#截取0~3号元素字符
"hell"
127.0.0.1:6379> GETRANGE key1 0 -1	#查询所有字符串
"helloworld"
127.0.0.1:6379> 

#替换
127.0.0.1:6379> SETRANGE key1 5 W	#将第5号元素替换成W
(integer) 10
127.0.0.1:6379> get key1
"helloWorld"
127.0.0.1:6379>

# setex(set with expire)  设置过期时间
# setnx(set if not exist) 不存在时再设置（分布式锁里常用到）
127.0.0.1:6379> setex key1 30 "hello"     #设置key1的值为hello，30秒后过期
OK
127.0.0.1:6379> ttl key1
(integer) 26
127.0.0.1:6379> setnx key2 "redis"		  #如果key2不存在，创建key2
(integer) 1
127.0.0.1:6379> setnx key2 "redis"		  #如果key2存在，创建key2失败
(integer) 0

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3		#批量设置多个值
OK
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
3) "k3"
127.0.0.1:6379> mget k1 k2 k3				#批量获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4			#msetnx是一个原子性的操作，要么一起成功，要么一起失败
(integer) 0
127.0.0.1:6379>

#对象
#设置一个user对象，属性为name和age ,存放在redis里的key就是user:1:name 和user:1:age，值为一个json字符串，1代表第一号对象

127.0.0.1:6379> mset user:1:name spring user:1:age 3
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "spring"
2) "3"

#getset  先get再set
127.0.0.1:6379> getset db redis			#如果存在db这个key，则改变原来的值，设置成redis
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db mongdb
"redis"
127.0.0.1:6379> get db
"mongdb"

2、List

redis里，list可以当成栈、队列、阻塞队列使用

所有的list的命令都是l开头的，且不区分大小写

127.0.0.1:6379> lpush list one			#将一个或多个值插入列表头部【左】
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1		#查询结果和插入顺序是颠倒的	
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LRANGE list 0 1
1) "three"
2) "two"
127.0.0.1:6379> RPUSH list four			#将一个或多个值插入列表尾部【右】
(integer) 4
127.0.0.1:6379> lrange list 0 -1	
1) "three"
2) "two"
3) "one"
4) "four"


#LPOP  RPOP 弹出列表元素
127.0.0.1:6379> lpop list 		#移除list的第一个元素
"three"
127.0.0.1:6379> rpop list		#移除list的最后一个元素	
"four"

#lindex
127.0.0.1:6379> lindex list 1	#通过下标获得list中的某个值
"one"
127.0.0.1:6379> llen list		#获取列表长度
(integer) 2

#lrem 移除指定的值
127.0.0.1:6379> lpush list one two two tree
(integer) 4
127.0.0.1:6379> lrem list 1 one 				#移除列表中指定个数的value，精确匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "tree"
2) "two"
3) "two"
127.0.0.1:6379> lrem list 2 two
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "tree"
127.0.0.1:6379> 

#trim修剪    list被截断
127.0.0.1:6379> rpush list va1 va2 va3 va4
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "va1"
2) "va2"
3) "va3"
4) "va4"
127.0.0.1:6379> ltrim list 1 2					#通过下标截取指定长度的元素，当前的list被截取只剩下被截取的元素
OK
127.0.0.1:6379> lrange list 0 -1
1) "va2"
2) "va3"

#rpoplpush 移除列表的最后一个元素并且将其移动到新的列表中
127.0.0.1:6379> rpoplpush list myList
"va3"
127.0.0.1:6379> lrange list 0 -1 
1) "va2"
127.0.0.1:6379> lrange myList 0 -1 
1) "va3"

# lset 将列表中指定下标的值替换为另一个值，更新操作
127.0.0.1:6379> exists list
(integer) 0
127.0.0.1:6379> lset list 0 value1
(error) ERR no such key
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 0
1) "value1"
127.0.0.1:6379> lset list 0 item
OK
127.0.0.1:6379> lrange list 0 0
1) "item"

#linsert  在某个元素前面或者后面添加一个指定的值
127.0.0.1:6379> rpush list world other
(integer) 2
127.0.0.1:6379> linsert list before "world" "hello"		#往world前面插入hello
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "world"
3) "other"
127.0.0.1:6379> linsert list after "other" "man"   		#往other后面插入man
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "world"
3) "other"
4) "man"

小结:

  • redis中的list实际上是一个链表，before Node after ,left , right都可以插入值
  • 如果key不存在，创建新的链表
  • 如果key存在，新增内容
  • 如果移除了所有值，空链表，也代表不存在
  • 在两边插入或者改动值，效率最高，中间元素，相对效率低一点

消息队列！（Lpush Rpop）,栈(Lpush Lpop)

3、Set

127.0.0.1:6379> sadd mySet hello spring cloud     # set集合中添加元素
(integer) 3
127.0.0.1:6379> smembers mySet					  # 查看set集合中所有元素
1) "cloud"
2) "spring"
3) "hello"
127.0.0.1:6379> sismember mySet hello			  # 判断某个值在不在set集合里
(integer) 1

# 获取set集合中的内容元素个数
127.0.0.1:6379> scard mySet
(integer) 3

# srem  移除set集合中的指定元素
127.0.0.1:6379> srem mySet hello 
(integer) 1
127.0.0.1:6379> smembers mySet
1) "cloud"
2) "spring"

# SRANDMEMBER 随机抽选出指定个数的元素
127.0.0.1:6379> SRANDMEMBER mySet
"cloud"
127.0.0.1:6379> SRANDMEMBER mySet
"spring"
127.0.0.1:6379> SRANDMEMBER mySet 2
1) "cloud"
2) "spring"

# spop 随机弹出一个元素
127.0.0.1:6379> spop mySet
"spring"
127.0.0.1:6379> smembers mySet
1) "cloud"

# 将一个指定的值移动到另一个set集合
127.0.0.1:6379> sadd mySet hello spring boot
(integer) 3
127.0.0.1:6379> sadd mySet1 cloud
(integer) 1
127.0.0.1:6379> smove mySet mySet1 "boot"
(integer) 1
127.0.0.1:6379> smembers mySet
1) "spring"
2) "hello"
127.0.0.1:6379> smembers mySet1
1) "cloud"
2) "boot"

# 数字集合类 已set1为参照
127.0.0.1:6379> sadd set1 a b c
(integer) 3
127.0.0.1:6379> sadd set2 c d e
(integer) 3
127.0.0.1:6379> SDIFF set1 set2		#差集
1) "a"
2) "b"
127.0.0.1:6379> SINTER set1 set2 	#交集  共同好友
1) "c"
127.0.0.1:6379> SUNION set1 set2	#并集
1) "c"
2) "d"
3) "a"
4) "b"
5) "e"

4、Hash

和string类型没有本质区别，还是简单的key-value

127.0.0.1:6379> hset myHash field1 spring field2 boot field3 cloud
(integer) 3
127.0.0.1:6379> hget myHash field1					# 获取单个字段值
"spring"
127.0.0.1:6379> hmget myHash field1 field2          # 获取多个字段值
1) "spring"
2) "boot"
127.0.0.1:6379> hgetall myHash						# 一次获取全部的值
1) "field1"
2) "spring"
3) "field2"
4) "boot"
5) "field3"
6) "cloud"

# hdel 删除hash指定的key字段，对应的value也就被删除了 
127.0.0.1:6379> hdel myHash field1
(integer) 1
127.0.0.1:6379> hgetall myHash
1) "field2"
2) "boot"
3) "field3"
4) "cloud"

# hlen  获取字段长度
127.0.0.1:6379> hlen myHash
(integer) 2
# HEXISTS 判断hash中指定字段是否存在
127.0.0.1:6379> HEXISTS myHash field1
(integer) 0

127.0.0.1:6379> HKEYS myHash		# 获取所有的field
1) "field2"
2) "field3"
127.0.0.1:6379> HVALS myHash		# 获取所有的value
1) "boot"
2) "cloud"

127.0.0.1:6379> hset myHash field3 5				#指定增量
(integer) 1
127.0.0.1:6379> HINCRBY myHash field3 1
(integer) 6
127.0.0.1:6379> HINCRBY myHash field3 -1
(integer) 5
127.0.0.1:6379> HSETNX myHash field4 hello			# 如果不存在就可以设置
(integer) 1
127.0.0.1:6379> HSETNX myHash field4 hello			# 如果存在则不能设置
(integer) 0

小结：

hash 更适合对象的存储，string 更适合字符串的存储

5、Zset

127.0.0.1:6379> zadd salary 2500 zhangsan 5000 lisi 6000 xiaohong		
(integer) 3
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf							#从小到大显示全部的用户
1) "zhangsan"
2) "lisi"
3) "xiaohong"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores				#获取全部的用户并附带成绩
1) "zhangsan"
2) "2500"
3) "lisi"
4) "5000"
5) "xiaohong"
6) "6000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 5000 withscores				#升序获取工资小于5000的用户附带成绩
1) "zhangsan"
2) "2500"
3) "lisi"
4) "5000"

# zrem 移除集合中指定的元素
127.0.0.1:6379> zrem salary xiaohong
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "zhangsan"
2) "lisi"
127.0.0.1:6379> zcard salary				# 获取集合的元素个数
(integer) 2

# ZCOUNT 获取指定区间的成员数量
127.0.0.1:6379> zadd myset 1 hello 2 world 3 spring 
(integer) 3
127.0.0.1:6379> ZCOUNT myset 1 3 
(integer) 3
127.0.0.1:6379> ZCOUNT myset 1 2

应用场景：

set 排序 、存储班级成绩表、工资表排序

普通消息：1、重要消息 2、带权重进行判断

排行版应用实现，获取Top N测试

四、redis的三种特殊数据类型（不全）

1、geospatial 地理位置

使用场景：朋友圈定位、附近的人、打车距离计算？

只有6个命令

  • GEOADD
  • GEODIST
  • GEOHASH
  • GEOPOS
  • GEORADIUS
  • GEORADIUSBYMEMBER

1、geopos

注意：

（纬度，经度，名称）添加到指定键。

  • 有效经度为-180至180度。

  • 有效纬度为-85.05112878至85.05112878度。

    127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
    (integer) 1
    127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
    (integer) 1
    127.0.0.1:6379> geoadd china:city 106.50 29.53 shenzhen
    (integer) 1

    127.0.0.1:6379> geopos china:city beijing #获取指定城市的经度和纬度

      1. “116.39999896287918091”
      2. “39.90000009167092543”

2、GEODIST

两人之间的距离

单位：

m ：米

km ：千米

mi ：英里

ft ：英尺

#查看北京到上海的直线距离
127.0.0.1:6379> GEODIST china:city beijing shanghai km
"1067.3788"

3、GEORADIUS

以给定的经纬度为中心，找出某一半径的元素

我附近的人？获得指定数量的人：200

2、Hyperloglog

3、Bitmaps

五、redis的基本事务操作

Redis事务本质：一组命令的集合，一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行。

一次性、顺序性、排他性！执行一些列的命令。

Redis事务没有隔离级别的概念

所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行：exec

Redis单条命令是保持原子性的，但是事务不保证原子性！

redis的事务：

  • 开启事务

  • 命令入队列（…）

  • 执行事务（exec）

    127.0.0.1:6379> MULTI #开启事务
    OK
    127.0.0.1:6379> set k1 v1 #命令入队
    QUEUED
    127.0.0.1:6379> set k2 v2
    QUEUED
    127.0.0.1:6379> set k3 v3
    QUEUED
    127.0.0.1:6379> exec #执行事务

    1. OK
    2. OK
    3. OK

注意：一旦执行事务，事务就没有了

中途放弃事务指令：事务中队列里 的命令都将不会被执行

127.0.0.1:6379> DISCARD
OK

小结：

事务队列总的一组命令中如果存在一条命令或者代码错误，执行命令时，所有指令都不会生效。

事务队列总的一组命令中如果存在一条运行时错误，执行命令时，除了这条错误命令，其他的都会正常执行，错误会被抛出。

六、Redis实现乐观锁

悲观锁：

很悲观，认为什么时候都会出问题，做什么操作前都加锁！费性能。

乐观锁：

很乐观，认为什么时候都不会出问题，所以不上锁！在更新数据的时候才去判断一下，在此期间是否有人修改过这个数据；获取version,更新的时候比较下version

redis通过watch监控实现乐观锁

正常监控状态

127.0.0.1:6379> set money 1000		
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money					#开启监控模式
OK
127.0.0.1:6379> MULTI						#开启事务
OK
127.0.0.1:6379> DECRBY money 100			#减少100块钱
QUEUED
127.0.0.1:6379> incrby out 100				#增加100块钱
QUEUED
127.0.0.1:6379> exec
1) (integer) 900
2) (integer) 100

另起一个线程，在正常监控状态执行事务之前，修改掉money，会导致正常态的事务执行失败。需要重新开始监视、开启事务。

解锁命令: unwatch 放弃监视。

七、通过Jedis操作Redis

引入依赖

    
        
            redis.clients
            jedis
            3.3.0
        
        
            com.alibaba
            fastjson
            1.2.73

new一个最简单的maven项目，创建个测试类

package com.demo;

import redis.clients.jedis.Jedis;

public class TestString {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.85.130",6379);
        //方法都是三四节点的指令
        System.out.println(jedis.ping());
        jedis.close();
    }
}

通过jedis操作事务

package com.demo;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class TestString {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.85.130",6379);
        jedis.flushDB();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","spring");
//        开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
//        开启监视模式
//        jedis.watch("result");
        try {
            multi.set("user1",result);
            multi.set("user2",result);
//        代码抛出异常事务，执行失败！
//            int i = 1/0;
            multi.exec();
        }catch (Exception e){
//            放弃事务
            multi.discard();
        }finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();
        }

    }
}

八、SpringBoot集成Redis

SpringBoot 操作数据：Spring-data jpa jdbc mongdb redis

注意：Springboot 2.x之后，原来使用jedis被替换成了lettuce

jedis:采用直连，多线程操作时不安全，用jedis pool连接池提升安全性。像BIO模式

lettuce:采用netty，实例可以在多个线程中共享，不存在线程不安全。减少线程数量，像NIO模式

1、导入依赖

        
            org.springframework.boot
            spring-boot-starter-data-redis

2、配置连接

spring:
  redis:
    host: 192.168.85.130
    port: 6379

3、测试

package redis01.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
    /**
     * opsForValue  ：操作字符串类似String
     * opsForList   ：操作List
     *opsForSet     ：操作set
     */

//    获取redis的连接对象
//        RedisConnection redisconnection = (RedisConnection) redisTemplate.getConnectionFactory();
//        redisconnection.flushDb();
        redisTemplate.opsForValue().set("mykey","学习springboot整合redis");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }
}

注意：redis对象都需要序列化！

默认的序列化方式是JDK序列化，我们平常都是使用Json来序列化。

九、定制redisTemplate和封装redis工具类

package redis01.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.net.UnknownHostException;

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
//      修改成常用泛型  
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

//        Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
//        配置具体的序列化方式
//        String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

//        key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
//        hash的key采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
//        value采用jackson的序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
//        hash的value采用jackson的序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

封装redis工具类

package com.oal.microservice.util;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
 
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
/**
 * Redis工具类
 *
 * @author zhangzhixiang
 * @date 2019年06月19日
 */
@Component
public final class RedisUtil {
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    // =============================common============================
    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
 
    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }
    // ============================String=============================
 
    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
 
    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
 
    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    // ================================Map=================================
 
    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }
 
    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
 
    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }
 
    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }
 
    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }
 
    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }
    // ============================set=============================
 
    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
 
    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
 
    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
 
    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================
 
    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
 
    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
 
  
十、redis的持久化操作
 
  
1、持久化之RDB操作
 
  
概念：指定时间内将内存中的数据集快照写入磁盘。
 
  
rdb保存文件的是dump.rdb
 
  
（1）、配置相关
 
  
RDB 触发机制分为使用指令手动触发和 redis.conf 配置自动触发。
 
  
手动触发 Redis 进行 RDB 持久化的指令的为:
 
  
     
   
  • save ，该指令会阻塞当前 Redis 服务器，执行 save 指令期间，Redis 不能处理其他命令，直到 RDB 过程完成为止。
    •  
   
  • bgsave，执行该命令时，Redis 会在后台异步执行快照操作，此时 Redis 仍然可以相应客户端请求。具体操作是 Redis 进程执行 fork 操作创建子进程，RDB 持久化过程由子进程负责，完成后自动结束。Redis 只会在 fork 期间发生阻塞，但是一般时间都很短。但是如果 Redis 数据量特别大， fork 时间就会变长，而且占用内存会加倍，这一点需要特别注意。
    •  
  
 
  
（2）、触发生成dump.rdb的条件
 
  
     
   
  1. save的规则满足的情况下，会自动触发rdb规则
    2.  
   
  2. 执行flushall命令时会触发rdb规则
    3.  
   
  3. 退出redis时触发产生rdb文件
    4.  
  
 
  
（3）如何恢复rdb文件数据
 
  
将生成的rdb文件放在我们的redis启动目录（默认）下就能在redis启动的时候自动检测到并恢复。
 
  
优点：
 
  
     
   
  1. 适合大规模的数据恢复
    2.  
   
  2. 对数据的完整性要求不高
    3.  
  
 
  
缺点：
 
  
     
   
  1. 需要一定的时间间隔进程操作，意外宕机会丢失最后一次修改的数据。
    2.  
   
  2. fork进程的时候，会占用一定的内容空间。
    3.  
  
 
  
2、持久化之AOF操作
 
  
AOF是将执行过的指令记录下来，数据恢复时按照从前到后的顺序再将指令执行一遍，实现数据恢复。
 
  
aof保存文件的是appendonly.aof文件。
 
  
默认是不开启此模式的，需要修改redis.conf里的appendonly no 改为appendonly yes
 
  
如果这个aof文件有错误（恶意修改），redis就启动不了，可以启动redis-check-aof.sh来修复。
 
  
优点：
 
  
     
   
  1. 每一次修改都同步，文件的完整性会更好
    2.  
   
  2. 每秒同步一次，可能会丢失这一秒的数据
    3.  
   
  3. 从不同步，效率最高
    4.  
  
 
  
缺点：
 
  
     
   
  1. 相对于数据文件来说，aof远远大于rdb,修复的速度比rdb慢
    2.  
   
  2. aof运行效率比rdb慢，因此redis默认使用rdb做持久化。
    3.  
  
 
  
十一、redis的发布订阅
 
  
1 发布
 
  
publish [key] [something]

127.0.0.1:6379> publish learn "hello"
(integer) 1

 
  
2 订阅
 
  
subscribe [key]

psubscribe [pattern] 使用正则表达式订阅多个频道

127.0.0.1:6379> PSUBSCRIBE learn
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "learn"
3) (integer) 1
1) "pmessage"
2) "learn"
3) "learn"
4) "hello"

 
  
十二、redis主从复制（了解）
 
  
（1）主从复制的作用：
 
  
数据冗余：实现数据的热备份。
 
  
故障恢复：主节点挂了，从节点提供服务。
 
  
负载均衡：主节点负责写，从节点负责读。
 
  
高可用（集群）: 主从复制是哨兵和集群能够实施的基础。
 
  
单机redis使用内存超过20G应该考虑加机器。
 
  
（2）一主二从配置
 
  
暂时性的：
 
  
特点：每个redis默认自己是主节点。
 
  
因此配置连个从节点认主就行了，在客户端里输入指令：slaveof 【host】 【prot】
 
  
客户端里查看本机redis的节点信息指令：info replication
 
  
永久配置（推荐）：
 
  
从机配置文件里replication：
 
  
relicaof  主机ip  主机port
masterauth  主机密码

 
  
特点：
 
  
从机不能写
 
  
主机挂了，随时连接回来，依然可用。反之也可以。
 
  
原理：新建的连接主从会进行一次全量连接，之后进行增量连接。
 
  
十三、哨兵模式
 
  
https://blog.csdn.net/macro_g/article/details/82593996
 
  
十四、缓存穿透和击穿和雪崩
 
  
1、缓存穿透
 
  
概念：用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
 
  
解决方案
 
  
（1）布隆过滤器
 
  
对所有可能查询的参数以hash形式存储，当用户想要查询的时候，使用布隆过滤器发现不在集合中，就直接丢弃，不再对持久层查询。
 
  
（2）缓存空对象
 
  
当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源；
 
  
但是这种方法会存在两个问题：
 
  
     
   
  • 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键；
    •  
   
  • 即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。
    •  
  
 
  
2、缓存击穿
 
  
概念：“爆款”。缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
 
  
解决方案：
 
  
（1）redis设置缓存永不过期
 
  
（2）mutex key互斥锁
 
  
3、缓存雪崩
 
  
概念：通俗讲：redis挂了。缓存雪崩是指，缓存层出现了错误，不能正常工作了。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。
 
  
解决方案：
 
  
（1）redis高可用
 
  
这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。
 
  
（2）限流降级
 
  
这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
 
  
（3）数据预热
 
  
数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(redis,nosql)

        

            

                
    
                    
  • Java 实现 Redis中的GEO数据结构
                        潇凝子潇
javaredis数据结构
                        
    Java实现Redis中的GEO数据结构LBS（基于位置信息服务（Location-BasedService，LBS））应用访问的数据是和人或物关联的一组经纬度信息，而且要能查询相邻的经纬度范围，GEO就非常适合应用在LBS服务的场景中importjava.util.ArrayList;importjava.util.List;//定义一个表示地理位置的类，用于存储地理位置的相关信息publicc
    
                    
    • 
                    
  • redis结合lua脚本解决多线程并发安全问题
                        练川
redisluaredis
                        
    文章目录前言原子性单线程模型总结前言我们知道，多线程并发访问共享数据的时候，可能会造成并发安全问题，这是由于并发时多个线程相互穿插造成的问题；可以通过加锁，使得多个线程串行执行解决。当访问的是redis中的共享数据时，除了可以通过加锁解决，还可以使用lua脚本解决。本文针对redis结合lua脚本解决多线程并发安全问题，记录下个人的理解。原子性首先何为原子性？原子性是指操作不可分割，要么全部执行成
    
                    
    • 
                    
  • HBase简介
                        梦醒沉醉
Hadoophbase数据库大数据
                        
    目录1.HBase概述2.HBase核心概念2.1行关键字2.2列关键字2.3时间戳2.4单元2.4.1HBase和RDBMS的差异2.4.2HBase组成3.HBase流程3.1Region的分配3.2RegionServer上线3.3RegionServer下线3.4Master上线3.5Master下线3.6写请求处理参考1.HBase概述  HBase是NoSQL(NotOnlySQL，泛
    
                    
    • 
                    
  • MongoDB面试题答案解析
                        HappyAcmen
java面试题集mongodb数据库
                        
    文章目录一、概念理解类1.什么是MongoDB？2.NoSQL数据库是什么意思？NoSQL与RDBMS有什么区别？为什么要使用和不使用NoSQL数据库？3.MySQL与MongoDB之间最基本的差别是什么？4.你怎么比较MongoDB、CouchDB及CouchBase？5.MongoDB成为最好的NoSQL数据库的原因是什么？6.journal回放在条目(entry)不完整时会遇到问题吗？7.分
    
                    
    • 
                    
  • 同城组局旅游组局搭子论坛系统
                        狂团商城小师妹
博纳miui52086微信小程序小程序微信公众平台
                        
    同城组局旅游组局搭子论坛系统，作为一款集旅游组局、社交互动与信息服务于一体的综合性平台，其组局系统实现了无限开启的灵活性与便捷性，为用户提供了前所未有的组局体验。该系统基于先进的TP6框架与Mysql8数据库，并融入了Redis高并发架构，确保了在高流量、高并发场景下的稳定运行与快速响应。这一技术选型不仅提升了系统的整体性能，更为用户带来了流畅无阻的使用感受。在功能性方面，该系统展现出了极高的实用
    
                    
    • 
                    
  • Redis+Sentinel安装与配置
                        weixin_30532973
数据库网络lua
                        
    在这里我们搭建的是一个1主3从的redis+3个哨兵集群的环境，由于是在一台物理机上，所有我们用端口区分。物理机IP：192.168.0.12主节点master端口：6301从节点slave1端口：6315从节点slave2端口：6316从节点slave3端口：6317哨兵sentinel1端口：26301哨兵sentinel2端口：26302哨兵sentinel3端口：26303一、下载安装$w
    
                    
    • 
                    
  • spring security6+springboot3+jwt实现权限控制
                        O0o88
springjavamybatis
                        
    maven配置myabits-plus,redis,lombok,hutoolorg.springframework.bootspring-boot-starter-parent3.0.517org.springframework.bootspring-boot-starterorg.springframework.bootspring-boot-starter-testtestorg.sprin
    
                    
    • 
                    
  • redis 实现延迟消息队列
                        键盘侠007
redis数据库缓存
                        
    Redis延迟消息队列实现配置参数第二步Listitem配置参数1.首先确认liunx中安装了redis2.修改redis的配置文件配置键空间通知在Redis配置文件（通常是redis.conf）中，启用键空间通知配置如下：confnotify-keyspace-eventsExE:启用KeyEvent通知。x:启用过期事件通知。第二步redis:localhost:123.249.16.100p
    
                    
    • 
                    
  • redis sentinel模式 与 redis 分片集群 配置
                        癸酉金鸡
redissentinel数据库
                        
    Redis最低为5.0版本，以下为6.2.6版本信息。模式高可用性数据分片部署复杂度适用场景Sentinel模式高无中等中小规模，需要高可用性集群模式高支持复杂大规模，需要高可用性和数据分片RedisSentinel模式（在主从复制的基础上引入Sentinel实例，用于监控Redis节点的健康状态，并在主节点故障时自动进行故障转移）1.主节点redis.conf配置bind0.0.0.0port6
    
                    
    • 
                    
  • Redis数据类型有哪些
                        头孢头孢
零散面试相关的总结redis哈希算法数据库
                        
    Redis底层数据类型及其实现原理详细解析Redis提供了多种底层数据类型，每种类型都基于不同的数据结构实现，适用于不同的应用场景。理解这些底层实现和它们的使用方式对于优化Redis性能至关重要。以下是Redis中常用的底层数据类型的详细介绍，包括底层实现原理以及一些常用的Java代码示例。1.字符串（String）1.1数据类型描述Redis中的字符串（String）是最基本的数据类型，它可以存
    
                    
    • 
                    
  • 区块链上的“SQL”
                        趣链科技
SQL编译
                        
    导读《F1：ADistributedSQLDatabaseThatScales》是Google构建的用于支持广告业务的分布式关系型数据库系统。作为一个混合型数据库系统，它结合了高可用、NoSQL数据库的扩展性以及传统SQL数据库的一致性和可用性。F1数据库整体基于GoogleSpanner构建，Spanner主要为上层的F1提供了跨数据中心的数据复制功能和一致性保证。而F1通过使用结构化数据分层架
    
                    
    • 
                    
  • 【Redis系列】Redis安装与使用
                        m0_74825409
面试学习路线阿里巴巴redis数据库缓存
                        
    ???欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术点,如集合,jvm,并发编程redis,kafka,Spring,微服务,Netty等常用开发工具系列:罗列常用的开发工具,如IDE
    
                    
    • 
                    
  • Aerospike
                        小的~~
nosqlAerospike
                        
    文章来源：拉勾教育Java高薪训练营第3期Aerospike介绍Aerospike（简称AS）是一个分布式，可扩展的键值存储的NoSQL数据库。T级别大数据高并发的结构化数据存储读写操作达微妙级，99%的响应可在1毫秒内实现采用混合架构，索引存储在内存中，而数据可存储在机械硬盘(HDD)或固态硬盘(SSD)上（也可存储在内存）AS内部在访问SSD屏蔽了文件系统层级，直接访问地址，保证了数据的读取速
    
                    
    • 
                    
  • RPC框架Dubbo深入分析
                        radcb55226
程序员rpcdubbo网络协议
                        
    《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！依赖于Zookeeper的稳定性Redis支持基于客户端双写的集群方式，性能高要求服务器时间同步，用于检查心跳过期脏数据Multicast去中心化，不需要安装注册中心依赖于网络拓普和路由，跨机房有风险SimpleDogfooding，注册中心本身也是一个标准的RPC服务没有集群支持，可能单点故障cl
    
                    
    • 
                    
  • 使用bitnamiredis-sentinel部署Redis 哨兵模式
                        m0_67265654
面试学习路线阿里巴巴sentinelredis数据库
                        
    使用bitnami/redis-sentinel部署Redis哨兵模式为什么使用Bitnami镜像？Bitnami密切跟踪上游源代码更改，并使用我们的自动化系统及时发布此镜像的新版本。借助Bitnami镜像，可以尽快提供最新的错误修复和功能。Bitnami容器、虚拟机和云镜像使用相同的组件和配置方法-可以根据你的项目需求轻松切换格式。我们所有的镜像都基于minideb，这是一个基于Debian的极
    
                    
    • 
                    
  • redis压力测试
                        weixin_33845881
数据库
                        
    redis自带的redis-benchmark工具Redis自带了一个叫redis-benchmark的工具来模拟N个客户端同时发出M个请求。（类似于Apacheab程序）。你可以使用redis-benchmark-h来查看基准参数。1使用方法redis-benchmark[-h][-p][-c][-n[-k]序号选项描述默认值1-h指定redisserver主机名localhost2-p指定re
    
                    
    • 
                    
  • Redis压力测试
                        破 风
redisredis
                        
    首先我们进入到redis里面去：dockerexec-itredis/bin/bash压力测试命令：redis-benchmark-h127.0.0.1-p6379-c100-n100000性能SET分析：上面只是简单的GET请求压力测试数据分析，包括set看法和上面同理。压力测试命令讲解：-h主机-p端口-c并发连接数-n请求数-s指定服务器socket
    
                    
    • 
                    
  • PHP 使用 Redis 实现分布式锁
                        半桶水专家
phpRedisphpredis分布式
                        
    要在PHP中使用Redis实现分布式锁，可以使用类似的逻辑：通过SETNXPX命令获取锁，并通过唯一标识符（UUID）确保释放锁的正确性。以下是基于PHP的实现。PHP使用Redis实现分布式锁1.安装Redis扩展在PHP中使用Redis，你需要安装phpredis扩展。可以通过以下命令安装：peclinstallredis安装完成后，确保在php.ini中启用了Redis扩展：extensio
    
                    
    • 
                    
  • Redis常用数据类型
                        pingcode
面试题redis
                        
    Redis是Map类型的存储方式，所有数据都采用key:value形式存储，key是字符串，value有以下几种常用数据类型：①String：最基本的数据类型，可以是字符串、整数或浮点数。②List：按插入顺序排序的字符串列表。③Set：唯一字符串的无序集合。④Hash：包含键值对的无序散列。⑤ZSet：唯一字符串的有序集合，根据每个字符串的分数来维持顺序。
    
                    
    • 
                    
  • 【etcd】ubuntu22安装，与redis对比的区别
                        {⌐■_■}
etcdredischrome服务器数据库golang缓存
                        
    安装方法1：通过apt安装（简单，但版本可能较旧）步骤更新软件包列表：sudoaptupdate安装etcd：sudoaptinstalletcd启动etcd服务：sudosystemctlstartetcd验证安装：etcdctlversion如果输出类似以下内容，表示安装成功：etcdctlversion:3.4.20APIversion:3.4设置开机自启（可选）：sudosystemctl
    
                    
    • 
                    
  • mac+CLion+redis6.2本地源码调试
                        王冬的csdn
redisredis
                        
    1.下载安装CLion下载地址：https://www.jetbrains.com.cn/clion/download/other.html安装过程自行百度2.下载redis源码gitclonehttp://github.com/redis/redis.git3.添加CMakeLists.txt文件1、\redis-6.2\cmake_minimum_required(VERSION3.0FATA
    
                    
    • 
                    
  • mac 系统下使用clion调试redis4源码
                        迹忆客
redis编程redismac
                        
    原文：mac系统下使用clion调试redis4源码clion主要使用的是cmake+make进行编译。所以对于redis4来说，主要的就是先编写CMakeLists.txt文件。CmakeLists.txt文件redis4/CMakeLists.txtcmake_minimum_required(VERSION3.15)project(redis4)set(CMAKE_BUILD_TYPE"De
    
                    
    • 
                    
  • Redis（二十二）：Redis迁移工具
                        蓬莱道人
Redis数据库memcachedmysql
                        
    1.Redis-shake2.Redis-migrate-tool3.Redis-full-check1.Redis-shake1.1简介redis-shake是阿里云Redis&MongoDB团队开源的用于redis数据同步的工具。redis-shake是我们基于redis-port基础上进行改进的一款产品。它支持解析、恢复、备份、同步四个功能。恢复restore：将RDB文件恢复到目的redi
    
                    
    • 
                    
  • k8s中 pod在delete时过于慢 （小记）
                        AR_xsy
kuberneteskuberneteslinux
                        
    在k8s环境中当删除pod时过于缓慢的处理方式原因：我了解的常见原因就是因为k8s本身的机制，所谓优雅的删除，就会导致慢些，当然如果你公司业务本身设计的很大就另说了，例如做了持久化，有些相关数据库依赖啥的，比如这个业务因为数据量对io性能要求较强，就直接调到redis里，那么你在删除的时候，k8s的机制要做到优雅的删除，那么就会一步一步的删，先清redis，然后再各种你pod业务所依赖的各种东西，
    
                    
    • 
                    
  • 在软件产品从开发到上线过程中，不同阶段可能出现哪些问题，导致软件最终出现线上bug
                        测试-东方不败之鸭梨
测试基础bug数据库
                        
    在软件产品从开发到上线的全生命周期中，不同阶段都可能因流程漏洞、技术疏忽或人为因素导致线上问题。以下是各阶段常见问题及典型案例：1.需求分析与设计阶段问题根源：业务逻辑不清晰或设计缺陷典型问题：需求文档模糊（如未明确定义边界条件或异常场景）架构设计不合理（如单点故障、未考虑高并发场景）技术选型与业务场景不匹配（如用Redis缓存静态数据但未设置TTL）案例：支付接口未设计幂等性，导致用户重复点击时
    
                    
    • 
                    
  • Spring Security（六）RBAC 结构实现
                        是晓周哦
Spring-Securityspringjava后端springboot安全架构springcloud
                        
    博主前言：本以为这个就是代替传统jwt的插件，没想到复杂程度如此之高。SpringSecurity本身是个高度自定义化的组件，必须花时间重点学习一下。以下为个人配置学习的流程，从零到权限管理、redis嵌入等步骤。本文基于尚硅谷的SpringSecurity教程学习，文章与原教程有不小出入，仅供参考。B站视频链接：尚硅谷Java项目SpringSecurity+OAuth2权限管理实战教程RBAC
    
                    
    • 
                    
  • Redis
                        Lin_Miao_09
技术架构Redisredis数据库缓存
                        
    目录一、Redis基础知识数据持久化高可用性和扩展性性能优化应用场景二、Redis的Java常用客户端JedislettuceRedisson三、Redis实战Jedis1.添加依赖2.基本使用例子3.使用连接池优化性能spring-boot-starter-data-redis1.添加依赖2.配置文件设置3.使用RedisTemplate或Repository使用RedisTemplate使用R
    
                    
    • 
                    
  • SpringBoot建立SSH通道整合S3Elasticache（Redis），并实现Redis多库切换
                        IT但丁
JavaWebredisjedisspringbootaws
                        
    目录一、背景1、问题2、解决二、建立SSH通道1、pom引入依赖2、创建sshconfig3、SSHConnection程序三、Springboot整合Redis1、引入依赖2、配置信息3、RedisConfig的编写（切库处理配置）4、Redis操作的工具类四、两个大坑1、长时间未操作，连接重置2、长时间未操作，无法获取resource五、总结一、背景使用SpringBoot自带的redis框架
    
                    
    • 
                    
  • 使用 Canal 实时从 MySql 向其它库同步数据
                        m0_74823239
面试学习路线阿里巴巴mysql数据库
                        
    目前绝大多数项目还是采用mysql作为数据存储，对于用户访问量较高的网站来说，mysql读写性能有限，我们通常会把mysql中的数据实时同步到Redis、mongodb、elasticsearch等中间件中，应对高并发访问场景，减轻mysql压力，防止数据库宕机。在项目开发中，为了不会原有代码进行侵入，采用canal中间件实现mysql向其它库的实时同步，是一种很不错的方案。canal译意为水道/
    
                    
    • 
                    
  • 如何避免redis长期运行持久化AOF文件过大的问题：AOF重写
                        学会了没
redisaofAOF重写
                        
    一、AOF重写的核心作用通过重建AOF文件，解决以下问题：体积压缩：消除冗余命令（如多次修改同一key），生成最小操作集合。混合持久化支持（若启用aof-use-rdb-preambleyes）：生成RDB头部+增量AOF命令。数据一致性：确保AOF文件仅包含有效数据集的完整操作记录。二、触发AOF重写的方式1.自动触发通过redis.conf配置触发条件：auto-aof-rewrite-per
    
                    
    • 
                                
  • 关于旗正规则引擎规则中的上传和下载问题
                                    何必如此
文件下载压缩jsp文件上传
                                    
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 
一、文件打包下载 
1.文件写入压缩包 
string mainPath="D:\upload\";     下载路径 
 
string tmpfileName=jar.zip;        &n
    
                                
    • 
                                
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析
                                    bit1129
Stream
                                    
      
以如下代码为例（SocketInputDStream）： 
Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
    
                                
    • 
                                
  • spark master web ui 端口8080被占用解决方法
                                    daizj
8080端口占用sparkmaster web ui
                                    
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 
  
1、cd SPARK_HOME/sbin 
  
2、vi start-master.sh 
  
  
3、定位到下面部分
    
                                
    • 
                                
  • oracle_执行计划_谓词信息和数据获取
                                    周凡杨
oracle执行计划
                                    
      
oracle_执行计划_谓词信息和数据获取(上) 
一：简要说明  
在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 
简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
    
                                
    • 
                                
  • spring中datasource配置
                                    g21121
dataSource
                                    
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： 
http://baike.baidu.com/view/920062.htm 
  
	<!-- spring加载资源文件 -->
	<bean name="propertiesConfig"
		class="org.springframework.b
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三）
                                    老A不折腾
finereportFAQ报表软件
                                    
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
1、repeated column width is largerthan paper width： 
这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
    
                                
    • 
                                
  • mysql 用户管理
                                    墙头上一根草
linuxmysqluser
                                    
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
    
                                
    • 
                                
  • 关于使用Spring导致c3p0数据库死锁问题
                                    aijuans
springSpring 入门Spring 实例Spring3Spring 教程
                                    
    这个问题我实在是为整个 springsource 的员工蒙羞  
如果大家使用 spring 控制事务，使用 Open Session In View 模式，  
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
    
                                
    • 
                                
  • 百度词库联想
                                    annan211
百度
                                    
    

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>RunJS</title&g
    
                                
    • 
                                
  • int数据与byte之间的相互转换实现代码
                                    百合不是茶
位移int转bytebyte转int基本数据类型的实现
                                    
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 
  
主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 
  
int转byte; 
  
byte转int; 
  
/**
 * 字节转成int,int转成字节
 * @author Administrator
 *

    
                                
    • 
                                
  • 简单模拟实现数据库连接池
                                    bijian1013
javathreadjava多线程简单模拟实现数据库连接池
                                    
    简单模拟实现数据库连接池 
实例1： 
package com.bijian.thread;

public class DB {

	//private static final int MAX_COUNT = 10;
	private static final DB instance = new DB();

	private int count = 0;
	private i
    
                                
    • 
                                
  • 一种基于Weblogic容器的鉴权设计
                                    bijian1013
javaweblogic
                                    
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： 
String  vuser_id = "weblogic";
String  vuse
    
                                
    • 
                                
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化
                                    bit1129
hessian
                                    
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 
  1. 定义三个POJO 
   Person类 
package com.tom.hes
    
                                
    • 
                                
  • 【Hadoop十四】Hadoop提供的脚本的功能
                                    bit1129
hadoop
                                    
    1. hadoop-daemon.sh 
1.1 启动HDFS 
./hadoop-daemon.sh start namenode
./hadoop-daemon.sh start datanode 
 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
    
                                
    • 
                                
  • 中国互联网走在“灰度”上
                                    ronin47
管理 灰度
                                    
    中国互联网走在“灰度”上（转） 
文/孕峰 
  
第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。 
  
灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
    
                                
    • 
                                
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
                                    bylijinnan
java
                                    
    

public class PrintMatrixClockwisely {

	/**
	 * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
例如：如果输入如下矩阵：

1              2             3            4
5              6             7            8
9 
    
                                
    • 
                                
  • mongoDB 用户管理
                                    开窍的石头
mongoDB用户管理
                                    
      1:添加用户 
   第一次设置用户需要进入admin数据库下设置超级用户（use admin） 
  
   db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 
   第一个参数用户的名字 
   第二个参数
    
                                
    • 
                                
  • [游戏与生活]玩暗黑破坏神3的一些问题
                                    comsci
生活
                                    
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意 
 
 
     玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天 
 
     结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 
 
  &nb
    
                                
    • 
                                
  • java 二维数组如何存入数据库
                                    cuiyadll
java
                                    
    using System;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
 
namespace WindowsFormsApplication1
{
    
    
                                
    • 
                                
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA)
                                    darrenzhu
javaspringlocalglobaltransaction
                                    
    Configuring Spring and JTA without full Java EE 
 
http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ 
 
Spring doc -Transaction Management 
 
http://docs.spring.io/spri
    
                                
    • 
                                
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练
                                    dcj3sjt126com
linuxalias
                                    
    用途说明 
设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。 
  常用参数 
格式：alias 
格式：ali
    
                                
    • 
                                
  • yii2 restful web服务[格式响应]
                                    dcj3sjt126com
PHPyii2
                                    
    响应格式 
当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 
 
 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 
 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
    
                                
    • 
                                
  • MongoDB索引调优（2）——[十]
                                    eksliang
mongodbMongoDB索引优化
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述 
      上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档 
    可以在嵌套文档的键上建立索引，方式与正常
    
                                
    • 
                                
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView
                                    gundumw100
android
                                    
    拉动ListView，Item之间的间距会变大，释放后恢复原样； 
 

package cn.tangdada.tangbang.widget;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import andr
    
                                
    • 
                                
  • 程序员用HTML5制作的爱心树表白动画
                                    ini
JavaScriptjqueryWebhtml5css
                                    
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" >
<ti
    
                                
    • 
                                
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版
                                    kakajw
ThinkPad预装改装windows 7windows 8
                                    
      
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 
该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！ 
  
缘由 
小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
    
                                
    • 
                                
  • Nginx学习笔记
                                    mcj8089
nginx
                                    
    一、安装nginx                      1、在nginx官方网站下载一个包，下载地址是：  
http://nginx.org/download/nginx-1.4.2.tar.gz  
     2、WinSCP(ftp上传工
    
                                
    • 
                                
  • mongodb 聚合查询每天论坛链接点击次数
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    /* 18 */
{
    "_id" : ObjectId("5596414cbe4d73a327e50274"),
    "msgType" : "text",
    "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
    
                                
    • 
                                
  • java术语（PO/POJO/VO/BO/DAO/DTO）
                                    Luob.
DAOPOJODTOpoVO BO
                                    
    
PO(persistant object) 持久对象
在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作.

VO(value object) 值对象
通
    
                                
    • 
                                
  • 算法复杂度
                                    Wuaner
Algorithm
                                    
    Time Complexity & Big-O： 
 
http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o 
 
http://bigocheatsheet.com/ 
 
http://www.sitepoint.com/time-complexity-algorithms/ 
 
 

    
                                
    •