iummiw
iummiw

Redis 学习笔记

Redis详细笔记

笔记记录 B站狂神说Java的Redis课程：https://www.bilibili.com/video/BV1S54y1R7SB

一、NoSQL概述

1、为什么要使用NoSQL

  • 现在是大数据时代（一般的数据库已经解决不了的数据：大数据（海量存储和并行计算））

    SQL => NoSQL

    1、单机时代（如MySQL）的瓶颈

    • 数据量太大，一个机器存不下
    • 数据的索引（MySQL单表300万条数据，一定要建立索引）,一个机器内存放不下
    • 访问量大（MySQL读写混合 — 性能降低），一个服务器承受不了

    2、Memcached缓存（减轻服务器的压力） + MySQL + 垂直拆分（读写分离，多个MySQL服务器，有的值负责读，有的值负责写）

    发展过程：①优化数据结构和索引 => ②文件缓存（涉及IO操作）=> ③Memcached

    3、分库分表 + 水平拆分 + MySQL集群

Redis 学习笔记_第1张图片

  • 用户的个人信息（社交网络、地理位置、用户日志等）爆发是增长，无法使用关系型数据库去存储，那么需要NoSQL数据库

2、什么是NoSQL

Not Only SQL —> 非关系型数据库

Redis 学习笔记_第2张图片

NoSQL特点

  1. 方便扩展（数据之间没有关系）
  2. 大数据高性能（Redis一秒写8万次，读取11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能比较高）
  3. 数据类型是多样性的（不需要事先设计数据库（因为数据量大），随取随用）
  4. 传统RDBMS和NoSQL
    • 传统RDBMS
      • 结构化组织
      • SQL
      • 数据和关系都存在单独的表中
      • 操作，数据定义语言
      • 严格的一致性
      • 基础的事务
      • …
    • NoSQL
      • 不仅仅是SQL
      • 没有固定的查询语句
      • 键值对存储，列存储，文档存储，图形数据库（社交关系）
      • 最终一致性
      • CAP定理和BASE
      • 高性能，高可用，高可扩
      • …

了解：3V + 3高

大数据时代的3V：主要是描述问题的

  1. 海量Volume
  2. 多样Variety
  3. 实时Velocity

大数据时代的3高：主要是对程序的要求

  1. 高并发
  2. 高可拓（集群）
  3. 高性能
电商网站：
# 1、商品的基本信息
    名称、价格、商家信息：
        关系型数据库： MySQL / Oracle (王坚：阿里去IOE（IBM小型机，Oracle数据库、EMC存储器）)
# 2、商品的描述、评论（文字多）
    文档型数据库：MongoDB
# 3、图片
    分布式文件系统：FastDFS、TFS（淘宝）、GFS（Google）、HDFS（Hadoop）、OSS云存储（阿里云）
# 4、商品的关键字（搜索）
    搜索引擎：solr、ElasticSearch、ISearch（阿里：多隆）
# 5、商品热门的波段信息
    内存数据库：Redis、Tair、Memcached、...
# 6、商品的交易、外部的接口
    三方应用

3、NoSQL的四大分类

1.KV键值对

  • 新浪：Redis
  • 美团：Redis + Tair
  • 阿里、百度：Redis + Memcached

2.文档型数据库（bson格式）

  • MongoDB（必须掌握）
    • 基于分布式文件存储的数据库（C++编写）
    • 主要用于处理大量的文档
    • 介于关系型数据库和非关系型数据库中的中间产品
  • ConthDB

3.列式存储

  • HBase
  • 分布式文件系统

4.图关系数据库

  • 存关系的，不是存图片的（比如，朋友圈社交网络，广告推荐）
  • Neo4j、InfoGrid

对比

分类 Examples举例 典型应用场景 数据模型 优点 缺点
键值（key-value） Tokyo
Cabine/Tyrant
Redis
Voldemort
Oracle BDB		 内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等等 Key指向Value的键值对，通常用hashtable来实现 查找速度快 数据无结构化，通常只被当作字符串或者二进制数据
列存储数据库 Cassandra
HBase
Riak		 分布式的文件系统 以列簇式存储，将同一列数据存在一起 查找速度快，可扩展性强，更容易进行分布式扩展 功能相对局限
文档型数据库 CouchDB
MongoDB		 Web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容） Key-Value对应的键值对，Value为结构化数据 数据结构要求不严谨，表结构可变，不需要像关系型数据库一样需要预先定义表结构 查询性能不高，而且缺乏统一的查询语法
图形数据库 Neo4J
InfoGrid
Infinite Graph		 社交网络，推荐系统等。专注于构建关系图谱 图结构 利用图结构相关算法。比如最短路径寻址，N度关系查找等 很多时候需要对整个图做计算才能得出需要的信息，而且这种结构不太好做分布式的集群方案

二、Redis入门

1.Redis是什么

官网：redis.io

中文网：http://www.redis.cn/

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

Redis 与其他 key - value 缓存产品有以下三个特点：

  1. Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
  2. Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储（多样的数据结构）。
  3. Redis支持数据的备份，即master-slave模式的数据备份。

Redis优势

  1. 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
  2. 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
  3. 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。（但是Redis事务多操作不支持原子性—当我们执行后有语句有错，其他语句仍然可以正常执行，详情看事务）
  4. 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。
  5. Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

Redis 学习笔记_第3张图片

2.能干什么？

  • 内存存储、持久化（rdb，aof）
  • 效率高、可以用于高速缓存
  • 发布订阅系统
  • 地图信息分析
  • 计时器、计数器（浏览量）
  • …

3.特性

  • 多样的数据结构
  • 持久化
  • 集群
  • 事务
  • …

4.安装（因为Redis更适合在linux下使用，所以只有linux的安装版本）

linux 使用的系统是 Centos 7.3

你可使用 虚拟机，也可已使用云服务器（学生机不贵），因为我有服务器，这里就在服务器上安装和学习Redis

①下载安装包

http://www.redis.cn/

Redis 学习笔记_第4张图片

②加压安装包（提前使用xshell和xftp上传压缩包到服务器上）

压缩包在 /app/目录下

在/usr/local/ 下创建redis文件夹，并进入到文件夹中

img

解压压缩包到该文件夹下

 tar -zxvf /app/redis-6.0.6.tar.gz -C ./

Redis 学习笔记_第5张图片

③编译并安装（保证安装了编译环境）

没有安装编译环境，需要 yum install gcc-c++

如果下面操作报错：需要提升GCC的版本（redis6需要5.3+）

//升级gcc到9以上
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
//临时将此时的gcc版本改为9
scl enable devtoolset-9 bash
//或永久改变
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile

cd redis-6.0.6make && make install

img

编译后，默认安装路径在 /usr/local/bin

Redis 学习笔记_第6张图片

④安装系统服务并后台启动

可能会报错：

Redis 学习笔记_第7张图片

解决方法：vim install_server.sh，注释如下图内容

Redis 学习笔记_第8张图片

安装系统服务（可以指定选项，下面默认）

cd utils./install_server.sh

Redis 学习笔记_第9张图片

默认的配置文件：/etc/redis/6379.conf（安装成功后，默认后台自启）

⑤开启redis服务

可以使用自定义的配置文件开启，这里使用systemctl

/redis安装目录/redis-server    /配置文件目录/redis.conf# 关闭服务/redis安装目录/redis-cli shutdown

systemctl start redis_6379.service

Redis 学习笔记_第10张图片

⑥客户端连接测试

Redis 学习笔记_第11张图片

⑦设置远程连接

vim /etc/redis/6379.conf

Redis 学习笔记_第12张图片

Redis 学习笔记_第13张图片

然后重启服务即可：

systemctl restart redis_6379.service

⑧配置访问密码

vim /etc/redis/6379.conf

Redis 学习笔记_第14张图片

重启服务

systemctl restart redis_6379.service

客户端连接测试

Redis 学习笔记_第15张图片

关闭连接

Redis 学习笔记_第16张图片

5.性能测试

使用自带的redis-benchmark工具测试即可

redis-benchmark [option] [option value]

性能测试工具可选参数：

序号 选项 描述 默认值
1 -h 指定服务器主机名 127.0.0.1
2 -p 指定服务器端口 6379
3 -s 指定服务器 socket
4 -c 指定并发连接数 50
5 -n 指定请求数 10000
6 -d 以字节的形式指定 SET/GET 值的数据大小 3
7 -k 1=keep alive 0=reconnect 1
8 -r SET/GET/INCR 使用随机 key, SADD 使用随机值
9 -P 通过管道传输 请求 1
10 -q 强制退出 redis。仅显示 query/sec 值
11 —csv 以 CSV 格式输出
12 -l 生成循环，永久执行测试
13 -t 仅运行以逗号分隔的测试命令列表。
14 -I Idle 模式。仅打开 N 个 idle 连接并等待。

测试

# 测试：100个并发连接  100000请求redis-benchmark -c 100 -n 100000

Redis 学习笔记_第17张图片

6.基本知识说明（基本命令）

如果觉得这里命令不太好看，去这个博客https://www.cnblogs.com/wlandwl/p/redis.html，或者 官网：http://www.redis.cn/commands.html

注意：以下的所有key都表示对应数据类型的 键的名称 ； value表示存储的值(除非注释中有特殊说明)

1.Redis 有16个数据库（0~15），默认使用第0个

可以使用 select进行切换

Redis 学习笔记_第18张图片

2.查看数据库大小

使用 dbsize查看数据库大小

img

3.查看所有的key（当前库）

使用 keys *

img

4.清除当前数据库

flushdb

Redis 学习笔记_第19张图片

5.清空所有数据库

flushall

略

6.Redis是单线程的？

  • Redis是很快的，官方表示，Redis是基于内存操作，CPU不是Redis的性能瓶颈，Redis的性能瓶颈是根据机器的内存和网络的带宽，既然可以使用单线程，就不用使用多线程。(6.0后支持多线程)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AzzXg8Ea-1642752175414)(https://www.kuangstudy.com/bbs/2020-11-2-Redis%E8%AF%A6%E7%BB%86%E7%AC%94%E8%AE%B0.assets/image-20201112020411584.png)]

7.判断key是否存在

exists key

Redis 学习笔记_第20张图片

8.移除key

move key 1 // 1表示当前数据库

del key // 删除当前数据库的key（可以多个）

Redis 学习笔记_第21张图片

9.设置key的过期时间

expire key 时间 // 单位时间为s

ttl key // 查看剩余存活时间

Redis 学习笔记_第22张图片

10.查看当前key的类型

type key

11.字符串追加（String）

append key appendValue

  • 如果当前 key 不存在，作用相当于 set key

Redis 学习笔记_第23张图片

12.获取字符串长度（String）

strlen key

Redis 学习笔记_第24张图片

13.字符串i++操作（可用于阅读量实现）（String）

incr key

Redis 学习笔记_第25张图片

同理，i—

decr key

步长设置

incrby key 步长

decrby key 步长

Redis 学习笔记_第26张图片

14.字符串片段 Range （String）

getrange key startIndex endIndex

  • 对应java里的substring（但是这里会endIndex是一个闭区间）
  • 特例，endIndex = -1 时，表示从startIndex 到最后

Redis 学习笔记_第27张图片

15.字符串替换 （String）

setrange key index replaceString

  • 对应java里的replace
  • 注意，如果replaceString是一个字符串，那么会替换源字符串中index后replaceString长度的片段，结果如下

Redis 学习笔记_第28张图片

16.特殊set设置 （String）

setex（set with expire）

setex key 时间 value // 设置值，带过期时间

Redis 学习笔记_第29张图片

setnx（set if not exist）

setnx key value // 如果不存在，则设置

Redis 学习笔记_第30张图片

17.批量设置、批量获取（原子性操作） （String）

mset k1 v1 k2 v2 …

mget k1 k2 …

Redis 学习笔记_第31张图片

  • 特殊
    • msetnx 批量设置

18.设置高阶 （String）

1）getset

getset key value // 先get再set（如果不存在，先返回nil，在设置值；如果存在，就先返回原值，再设置新值）

Redis 学习笔记_第32张图片

19.重命名key

rename key newName

Redis 学习笔记_第33张图片

20.返回一个随机key

randomKey

Redis 学习笔记_第34张图片

21.手动持久化操作

save 阻塞

  • SAVE 直接调用 rdbSave ，阻塞 Redis 主进程，直到保存完成为止。在主进程阻塞期间，服务器不能处理客户端的任何请求。

bgsave 非阻塞

  • BGSAVE 则 fork 出一个子进程，子进程负责调用 rdbSave ，并在保存完成之后向主进程发送信号，通知保存已完成。 Redis 服务器在BGSAVE 执行期间仍然可以继续处理客户端的请求。
命令 save bgsave
IO类型 同步 异步
阻塞？ 是 是（阻塞发生在fock()，通常非常快）
复杂度 O(n) O(n)
优点 不会消耗额外的内存 不阻塞客户端命令
缺点 阻塞客户端命令 需要fock子进程，消耗内存

22.获取配置文件中用户密码

config get requirepass

23.设置配置文件中用户密码（临时，重启服务失效）

config set requirepass password

24.密码认证

auth password 设置密码后必须认证才能使用客户端功能

25.关闭redis服务

shutdown

26.查看rdb文件存放的目录

img

img

27.查看服务器的信息

info 参数

参数列表：

  • server: Redis服务器的一般信息
  • clients: 客户端的连接部分
  • memory: 内存消耗相关信息
  • persistence: RDB和AOF相关信息
  • stats: 一般统计
  • replication: 主/从复制信息
  • cpu: 统计CPU的消耗
  • commandstats: Redis命令统计
  • cluster: Redis集群信息
  • keyspace: 数据库的相关统计

它也可以采取以下值:

  • all: 返回所有信息
  • default: 值返回默认设置的信息

如果没有使用任何参数时，默认为default。

三、五大数据类型

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

单点登录、

String（字符串）

略，具体看前面

使用场景：

  1. 计数器
  2. 统计多单位的数量（uid:122:follow 10）
  3. 粉丝数
  4. 对象缓存存储

List（列表）

1.从头部/尾部插入数据，以及数据显示

lpush key value

rpush key value

lrange key 0 -1

Redis 学习笔记_第35张图片

Redis 学习笔记_第36张图片

2.从头部/尾部移除数据

lpop key

rpop key

Redis 学习笔记_第37张图片

3.获取指定索引的值

lindex key index

Redis 学习笔记_第38张图片

4.获取列表长度

llen key

image-20201112171308314

5.移除指定的值

lrem key count(移除的个数) element

Redis 学习笔记_第39张图片

6.列表修剪 trim

ltrim key startIndex endIndex

Redis 学习笔记_第40张图片

7.也可以使用set

lset key index value // 将列表中 指定index的值替换为对应的value

  • 需要保证key和index都存在，否则报错

Redis 学习笔记_第41张图片

8.插入指定的值

linsert key before|after pivot(那个单词后) value

Redis 学习笔记_第42张图片

9.复杂操作

1）rpoplpush

rpoplpush source destination(newList) // 先移除source最后的元素，再将该元素添加到newList中

Redis 学习笔记_第43张图片

使用场景：

  1. 栈（lpush、lpop）
  2. 队列（lpush、rpop）
    1. 消息队列
  3. 阻塞队列

Set（集合）

集合中的值不能重复（无序）

1.添加成员到集合中，并查看所有成员

sadd key member

smembers key

Redis 学习笔记_第44张图片

2.判定成员是否存在

sismember key member

Redis 学习笔记_第45张图片

3.查看集合长度（特别）

scard key

img

4.移除指定的成员

srem key member

img

5.获取集合中的随机成员

srandmember key [count]

Redis 学习笔记_第46张图片

6.随机移除成员

spop key [count]

Redis 学习笔记_第47张图片

7.移动集合成员到其他集合

smove source destination member(需要移动的成员)

Redis 学习笔记_第48张图片

8.数字集合类：

  • 差集 sdiff key1 ，key2 …
  • 交集（共同好友）sinter key1，key2 …
  • 并集 sunion key1 ，key2 …

Redis 学习笔记_第49张图片

Hash（哈希）

key-Map or key-，value是一个Map

Hash本质和hash没有区别，只是value变成了Map

用户信息保存，经常变动的信息，适合对象的存储

1.简单存储Map和获取Map

hset key field value [k1 v1 [k2 v2 …]]

hget key field

img

img

2.获取所有Map字段及值

hgetall key

Redis 学习笔记_第50张图片

3.删除Map中的字段

hdel key field

Redis 学习笔记_第51张图片

4.查看Map中某字段是否存在

hexists key field

img

5.获取所有字段或者所有字段对应的值

hkeys key // 此处的key是Map名

hvals key

Redis 学习笔记_第52张图片

6.增量i++

hincrby key field value

Redis 学习笔记_第53张图片

7.不存在，就添加成功

hsetnx key field value // field 在map中不存在就添加这个值，否则不做改变

Redis 学习笔记_第54张图片

8.适合存储对象

img

Zset（有序集合）

在Set基础上增加了一个值（用于排序的值）

存储班级成绩表，工资表排序，

普通消息 = 1，重要消息 = 2，带权重进行判断

排行榜应用实现

1.添加 和 获取

zadd key n value

zrange key startIndex endIndex

Redis 学习笔记_第55张图片

2.排序实现（升序和降序）

zrangebyscore key -inf +inf [withscores] // 升序

zrange key 0 -1

zrevrangebyscore key +inf -inf [withscores] // 降序

zrevrange key 0 -1

zrangebyscore key -inf 任意值n // 升序 + 显示区间 [-inf，n]

3.移除指定的值

zrem key value

Redis 学习笔记_第56张图片

4.集合的长度

zcard key

Redis 学习笔记_第57张图片

5.指定区间的集合长度

zcount key startIndex endIndex

Redis 学习笔记_第58张图片

四、三种特殊数据类型

Geospatial

朋友的定位，附近的人，打车距离计算

底层是 Zset，即可以使用Zset的命令操作Geospatial

Redis3.2就支持了

1.添加地理位置

  • 两极无法添加
  • 经度：-180 ~ 180（度）
  • 纬度：-85.05112878 ~ 85.05112878（度）

geoadd key 经度 纬度 名称

Redis 学习笔记_第59张图片

2.获取指定位置的地理位置

geopos key 名称

img

3.返回两个给定位置之间的距离（直线距离）

  • 单位：
    • m ：米
    • km ：千米
    • mi ： 英里
    • ft ：英尺

geodist key

img

Redis 学习笔记_第60张图片

4.以给定值为半径，以经度和维度为中心，查找

  • 附近的人（获得所有附近的人的地址（开启定位））通过半径查询

georadius key 经度 纬度 半径 单位

Redis 学习笔记_第61张图片

5.以给定值为半径，以成员(城市名)为中心，查找

georadiusbymember key 成员名 半径 单位

Redis 学习笔记_第62张图片

6.返回一个或多个位置元素的geohash表示

  • 如果两个字符串越相似，表示两个地方越近

geohash key 成员1 成员2

img

Hyperloglog

基数统计的算法

  • 优点
    • 占用内存是固定的，264不同的元素的基数，只需要12KB的内存。（大数据情况下，有0.81%错误率）

基数：集合中元素的个数（先去重），如{1,2,2,3} 其基数为3（集合去重后为1,2,3 有3个元素）

网页的UV（一个人访问访问一个网站多次，但是还是算作一个人）

传统实现UV：Set保存用户的Id，然后统计set中的元素的数量作为标准判断（这种需要保存大量用户的ID）

Redis2.8.9
1.测试

创建一组元素 ： pfadd key ele1 ele2 ele3 …

统计对应key的基数：pfcount key1 [key2 …] // 多个key 就是统计这些key并集的基数

合并：pfmerge destkey sourceKey1 sourceKey2 [sourceKey3 …]

Redis 学习笔记_第63张图片

Bitmaps

位存储，位图（操作二进制）

统计用户信息，活跃，不活跃！登录、未登录！打卡，365打卡！(两个状态都可以使用)

1.案例：一周打卡记录

一周过去

setbit key offset bit

Redis 学习笔记_第64张图片

查看单天打卡情况

getbit key offset

Redis 学习笔记_第65张图片

统计所有打卡的天数

bitcount key

img

五、事务

注意：Redis单条命令是保证原子性的；但是事务不保证原子性！

Redis事务没有隔离级别的概念，所有的命令在事务中，并没有直接被执行，只有发起执行命令时才执行

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

--- 队列 set set set 执行 ---

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

Redis的事务：

  • 开启事务（multi）
  • 命令入队（其他命令）
  • 执行事务（exec）

正常事务的执行

Redis 学习笔记_第66张图片

取消事务

discard

Redis 学习笔记_第67张图片

异常执行

1.编译时（命令写错）

整个命令队列都不会执行

Redis 学习笔记_第68张图片

2.运行时

报错语句，会抛出异常；其他语句照样运行

Redis 学习笔记_第69张图片

监控 Watch（面试常问）

乐观锁：实现秒杀

  • 顾名思义，很乐观，认为什么时候都不会出现问题，所以不会加锁！（更新数据的时候去判断一下，在此期间是否有人修改过这个数据）
    • 获取version
    • 更新的时候比较version

悲观锁

  • 顾名思义，很悲观，认为什么时候都会出现问题，无论做什么都会加锁！

Redis 学习笔记_第70张图片

Redis实现乐观锁

执行成功（单线程没有干扰情况）

Redis 学习笔记_第71张图片

测试多线程修改值，使用watch可以当作redis的乐观锁操作

演示‘

①开启俩个，客户端，模拟多线程情况

Redis 学习笔记_第72张图片

②左边支出20元（但是不执行事务），然后右边修改money的数值

Redis 学习笔记_第73张图片

③左边执行事务，发现执行操作返回nil，查看money和out，发现事务并没有被执行（确实有乐观锁的效果）

Redis 学习笔记_第74张图片

如果修改失败获取最新的值就好（exec、unwatch、``discard`都可以清除连接时所有的监视）

Redis 学习笔记_第75张图片

小结
  • 使用Redis实现乐观锁（watch监听某一个key，获取其最新的value）
    • 在提交事务时，如果key的value没有发生变化，则成功执行
    • 在提交事务时，如果key的value发生了变化，则无法成功执行

六、Jedis

1、什么是Jedis

Jedis是一个用java写的Redis数据库操作的客户端，通过Jedis，可以很方便的对redis数据库进行操作

2、使用

①新建空maven项目

②导入依赖

    redis.clients    jedis    3.3.0    com.alibaba    fastjson    1.2.70

③编码

下面使用远程连接需要的操作：https://blog.csdn.net/weixin_43423864/article/details/109087670

  1. 连接数据库
public class PingTest {    public static void main(String[] args) {        // 1. new Jedis 对象        Jedis jedis = new Jedis("ip地址",6379);        // 如果设置密码 需要认证，没有设置忽略下面这条语句        jedis.auth("密码");        /// jedis 所有的命令(方法)都是之前学的命令        System.out.println(jedis.ping());// 测试连接    }}

Redis 学习笔记_第76张图片

  1. 操作

    // 连通Jedis jedis = new Jedis("ip地址", 6379);jedis.auth("密码");//基本操作System.out.println("清空数据：" + jedis.flushAll());System.out.println("判断key（name）是否存在：" + jedis.exists("name"));System.out.println("设置name的value：" + jedis.setnx("name", "liuyou"));System.out.println("设置pwd的value：" + jedis.setnx("pwd", "密码"));System.out.println("打印所有的key：" + jedis.keys("*"));System.out.println("获取该name的value：" + jedis.get("name"));System.out.println("删除pwd：" + jedis.del("pwd"));System.out.println("重命名name为username：" + jedis.rename("name", "username"));System.out.println("打印所有的key：" + jedis.keys("*"));System.out.println("返回当前数据库中key的数目：" + jedis.dbSize());

    清空数据：OK判断key（name）是否存在：false设置name的value：1设置pwd的value：1打印所有的key：[pwd, name]获取该name的value：liuyou删除pwd：1重命名name为username：OK打印所有的key：[username]返回当前数据库中key的数目：1

  2. 关闭连接

jedis.close()
  1. 事务
// 连通Jedis jedis = new Jedis("IP地址", 6379);jedis.auth("密码");JSONObject jsonObject = new JSONObject();jsonObject.put("hello","world");jsonObject.put("name","liuyou");jsonObject.put("pwd","密码");String s = jsonObject.toJSONString();jedis.flushAll();/// 加监听 watch// jedis.watch("user");// 开启事务Transaction multi = jedis.multi();try {    multi.set("user",s);    // 其他语句    // 执行事务    multi.exec();} catch (Exception e) {    // 取消事务    multi.discard();    e.printStackTrace();} finally {    System.out.println(jedis.get("user"));    // 关闭连接    jedis.close();}

七、SpringBoot整合

在SpringBoot2.x之后，原来的jedis被替换为lettuce

  • jedis
    • 采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全，使用jedis pool连接池！BIO
  • lettuce
    • 采用netty，实例可以在多个线程**享，不存在线程不安全问题，可以减少线程数据了，性能高，NIO

①新建springboot项目

Redis 学习笔记_第77张图片

② RedisAutoConfiguration源码分析

Redis 学习笔记_第78张图片

③整合测试

1、导入依赖

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

2、配置Redis（application.xml）

# SpringBoot 整合Redisspring.redis.host=xxxspring.redis.port=6379spring.redis.password=liuyou

3、编写测试类

@SpringBootTestclass Redis02SpringbootApplicationTests {    @Autowired    RedisTemplate redisTemplate;    @Test    void contextLoads() {        //redisTemplate        // 1.使用redisTemplate.opsForxxx 操作对应的数据结构        // 2.可使用redisTemplate 进行简单的key操作，如multi、move、watch、keys 等操作        /// 3.可使用获取连接，通过连接进行更多操作           // RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();           // RedisZSetCommands redisZSetCommands = connection.zSetCommands();        // 这里只使用1.演示        ValueOperations str = redisTemplate.opsForValue();        str.set("name","liuminkai刘民锴");        System.out.println(str.get("name"));    }}

Redis 学习笔记_第79张图片

但是存在问题，没有序列化，存储在Redis中的中文会被转义，如下图

Redis 学习笔记_第80张图片

为啥会出现这个情况？ RedisTemplate默认序列化使用JDK的，我们需要使用JSON格式

Redis 学习笔记_第81张图片

如何解决？我们需要编写自定义Redis配置类，自定义RedisTemplate

④自定义RedisTemplate

@Configurationpublic class MyRedisConfig {    // 更改Key ：Object ==> String 符合日常使用    // 自己定义了一个 RedisTemplate    @Bean    @SuppressWarnings("all")    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {        // 我们为了自己开发方便，一般直接使用         RedisTemplate template = new RedisTemplate();        template.setConnectionFactory(factory);        // 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();        return template;    }}

自定义RedisTemplate后，再启动③的测试类，结果Redis中正常显示

img

⑤RedisUtils工具类

日常开发我们都不会使用原始的RedisTemplate，都会封装一个RedisUtils工具类便于使用

package com.liuyou.utils;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.Map;import java.util.Set;import java.util.List;import java.util.concurrent.TimeUnit;@Componentpublic final class RedisUtils {    @Autowired    private RedisTemplate redisTemplate;    // =============================common============================    /**     * 指定缓存失效时间     * @param key  键     * @param time 时间(秒)     */    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)     */    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)     */    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     */    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 对应多个键值     */    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)     */    public double hincr(String key, String item, double by) {        return redisTemplate.opsForHash().increment(key, item, by);    }    /**     * hash递减     *     * @param key  键     * @param item 项     * @param by   要减少记(小于0)     */    public double hdecr(String key, String item, double by) {        return redisTemplate.opsForHash().increment(key, item, -by);    }    // ============================set=============================    /**     * 根据key获取Set中的所有值     * @param key 键     */    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 键     */    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代表所有值     */    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 键     */    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倒数第二个元素，依次类推     */    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 值     */    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  时间(秒)     */    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;        }    }}
 
  
 
   
使用该工具类直接@Autowired注入即可
 
  
 
  
进阶
 
  
 
   
学会前面的所有内容 ==> Redis基础
 
   
高级操作都在后面
 
  
 
  
八、Redis.conf详解
 
  
 
   
我们启动Redis，一般都是通过Redis.conf启动（我前面是使用安装服务的6379.conf启动）
 
   
因此，我们必须了解Redis.conf的配置，才能更好理解和使用Redis
 
   
单位
 
  
 
  
     
   
  • 大小写不敏感
    •  
  
 
  
Redis 学习笔记_第82张图片
 
  
 
   
包含
 
  
 
  
     
   
  •  
    可以包含多个配置文件（即，这些文件导入到主配置文件 Redis.conf 中）
     
    Redis 学习笔记_第83张图片
     
    •  
  
 
  
 
   
网络
 
  
 
  
bind 0.0.0.0 # IP（默认127.0.0.1）protected-mode no # 保护模式（默认yes）port 6379 # 端口设置（默认6379）

 
  
 
   
通用
 
  
 
  
daemonize yes # 以守护进程方式运行，即后台运行（默认no）pidfile /var/run/redis_6379.pid # 如果以后台运行，必须指定一个pid文件# 日志# Specify the server verbosity level.# This can be one of:# debug (大量信息, 使用于测试或开发阶段)# verbose (许多很少有用的信息，但不像调试级别那样混乱)# notice (比较冗长，你可能想在生产环境中使用)# warning (只有非常重要/关键的消息被记录下来)loglevel notice  # 默认noticelogfile "" # 日志的文件位置名databases 16 # 数据库的数量（默认16）always-show-logo yes # 是否开启 logo （默认yes）

 
  
 
   
快照
 
  
 
  
持久化，在规定时间内，执行了多少次操作，会被持久化到文件(.rdb，.aof)
 
  
save 900 1 # 900秒内（15分钟），如果至少有1个Key进行修改，我们就进行持久化操作save 300 10 # 300秒内（5分钟），如果至少有10个Key进行修改，我们就进行持久化操作save 60 10000 # 60秒内（1分钟），如果至少有10000个Key进行修改，我们就进行持久化操作stop-writes-on-bgsave-error yes # 持久化如果出错，是否还需要继续工作（默认yes）rdbcompression yes # 是否压缩rdb文件（默认yes），会消耗一些CPU资源rdbchecksum yes # 保存rdb文件时，进行错误检查检验dir ./ # rdb文件保存的目录

 
  
 
   
主从复制 REPLICATION
 
   
安全 SECURITY
 
  
 
  
requirepass 你的密码 # 设置密码（默认被注释着需要自己解开注释）

 
  
img
 
  
当然可以通过命令行配置(临时，服务重启失效)
 
  
Redis 学习笔记_第84张图片
 
  
 
   
客户端限制
 
  
 
  
# maxclients 10000 # 限制最多10000个客户端访问（默认注释）

 
  
 
   
内存管理
 
  
 
  
# maxmemory  # 最大内存设置（默认注释）# maxmemory-policy noeviction # 内存达到上限之后的处理策略（默认noeviction）    # 1、volatile-lru：只对设置了过期时间的key进行LRU（默认值）     # 2、allkeys-lru ： 删除lru算法的key       # 3、volatile-random：随机删除即将过期key       # 4、allkeys-random：随机删除       # 5、volatile-ttl ： 删除即将过期的       # 6、noeviction ： 永不过期，返回错误

 
  
 
   
APPEND ONLY MODE (AOF配置)
 
  
 
  
appendonly no # 默认是不开启aof的，默认使用rdb方式持久化appendfilename "appendonly.aof" # 持久化的文件名# appendfsync always # 每次修改都会同步，销耗性能appendfsync everysec # 每秒执行一次同步，可能会丢失这1秒的数据# appendfsync no # 不同步，操作系统自己同步数据，速度最快

 
  
九、Redis持久化（重点）
 
  
 
   
Redis是内存数据库，数据库状态断电及失，因此Redis提供了持久化功能（内存数据写入磁盘）
 
  
 
  
1、RDB（Redis DataBase）
 
  
 
   
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储。 保存文件格式 dump.rdb
 
  
 
  
Redis 学习笔记_第85张图片
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gtHBBtX4-1642752175457)(https://www.kuangstudy.com/bbs/2020-11-2-Redis%E8%AF%A6%E7%BB%86%E7%AC%94%E8%AE%B0.assets/image-20201117102650803.png)]
 
  
设置RDB文件保存条件
 
  
Redis 学习笔记_第86张图片
 
  
重启服务
 
  
systemctl restart redis_6379

 
  
结果测试
 
  
1.查看rdb文件存放的目录
 
  
img
 
  
img
 
  
2.删除已有的dump.rdb文件
 
  
Redis 学习笔记_第87张图片
 
  
3.添加5个key
 
  
Redis 学习笔记_第88张图片
 
  
发现重新生成rdb文件
 
  
RDB文件生成触发机制
 
  
1.满足redis.conf中，快照save生成条件
 
  
2.使用flushall命令，自动生成一个RDB文件
 
  
3.退出redis
 
  
RDB文件恢复
 
  
 
   
只需要将RDB文件放入Redis启动目录就可以了，Redis自动加载
 
  
 
  
优缺点
 
  
     
   
  • 优点： 
    
       
     
    • 适合大规模的数据恢复！
      •  
     
    • 对数据完整性要求不高
      •  
    
     
    •  
   
  • 缺点： 
    
       
     
    • 需要一定的时间间隔进程操作；如果redis意外宕机，最后一次修改数据就没有了
      •  
     
    • fork进程的时候，会占用一定的空间
      •  
    
     
    •  
  
 
  
2、AOF（Append Only File）
 
  
 
   
AOF持久化以日志的形式记录服务器所处理的每一个写、删除操作，查询操作不会记录，只许追加文件，不许改写文件。以文本的方式记录，可以打开文件看到详细的操作记录。
 
   
保存文件格式 appendonly.aof
 
  
 
  
img
 
  
aof默认不开启，需要到配置文件中开启
 
  
Redis 学习笔记_第89张图片
 
  
重启redis后，appendonly.aof文件自动生成
 
  
客户端进行一些操作
 
  
Redis 学习笔记_第90张图片
 
  
appendonly.aof文件内容，日志形式记录
 
  
Redis 学习笔记_第91张图片
 
  
重写规制
 
  
 
   
如果aof文件大于64mb，就会fork一个新进程来将我们的文件进行重写（清除之前的64mb）
 
  
 
  
Redis 学习笔记_第92张图片
 
  
错误修复
 
  
如果aof文件有错误，redis是启动不了的，可以使用官方自带 redis-check-aof --fix aof文件进行修复
 
  
优缺点
 
  
     
   
  • 优点 
    
       
     
    • 每一次修改都同步，文件完整性会更好
      •  
     
    • 每秒同步一次，可能会丢失一秒数据
      •  
    
     
    •  
   
  • 缺点 
    
       
     
    • 相对于数据文件来说，aof远远大于rdb，修复速度比rdb慢
      •  
     
    • aof运行速率比rdb慢（追加，频繁IO操作）
      •  
    
     
    •  
  
 
  
扩展
 
  
Redis 学习笔记_第93张图片
 
  
十、Redis发布订阅
 
  
Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。微信、微博、关注系统！
 
  
Redis客户端可以订阅任意数量的频道
 
  
订阅/发布消息图：
 
  
Redis 学习笔记_第94张图片
 
  
下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：
 
  
Redis 学习笔记_第95张图片
 
  
当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：
 
  
Redis 学习笔记_第96张图片
 
  
命令
 
  
这些命令被广泛用于构建即时通信应用，比如网络聊天室（chatroom）和实时广播、实时提醒等。
 
  
 
    
    
 
     命令 
     描述 
    
 
    
    
    
 
     PSUBSCRIBE pattern [pattern..] 
     订阅一个或多个符合给定模式的频道。 
    
 
    
 
     PUNSUBSCRIBE pattern [pattern..] 
     退订一个或多个符合给定模式的频道。 
    
 
    
 
     PUBSUB subcommand [argument[argument]] 
     查看订阅与发布系统状态。 
    
 
    
 
     PUBLISH channel message 
     向指定频道发布消息 
    
 
    
 
     SUBSCRIBE channel [channel..] 
     订阅给定的一个或多个频道。 
    
 
    
 
     SUBSCRIBE channel [channel..] 
     退订一个或多个频道 
    
 
    
  
 
  
测试
 
  
Redis 学习笔记_第97张图片
 
  
Redis 学习笔记_第98张图片
 
  
Redis 学习笔记_第99张图片
 
  
127.0.0.1:6379> subscribe blog # 订阅频道Reading messages... (press Ctrl-C to quit) # 等待推送信息1) "subscribe"2) "blog"3) (integer) 11) "message" # 消息2) "blog" # 消息来自频道3) "hello world!" # 消息内容127.0.0.1:6379> publish blog "hello world!" # 发送消息到频道(integer) 1127.0.0.1:6379>

 
  
原理
 
  
Redis 学习笔记_第100张图片
 
  
Redis 学习笔记_第101张图片
 
  
每个 Redis 服务器进程都维持着一个表示服务器状态的 redis.h/redisServer 结构， 结构的 pubsub_channels 属性是一个字典， 这个字典就用于保存订阅频道的信息，其中，字典的键为正在被订阅的频道， 而字典的值则是一个链表， 链表中保存了所有订阅这个频道的客户端。
 
  
客户端订阅，就被链接到对应频道的链表的尾部，退订则就是将客户端节点从链表中移除。
 
  
使用场景：
 
  
     
   
  • 实时消息系统！
    •  
   
  • 实时聊天！(频道当作聊天室，将信息回显给所有人)
    •  
   
  • 订阅，关注系统都是可以
    •  
  
 
  
 
   
复杂的情况，使用专业的消息中间件
 
  
 
  
做订阅的缺点
 
  
     
   
  1. 如果一个客户端订阅了频道，但自己读取消息的速度却不够快的话，那么不断积压的消息会使redis输出缓冲区的体积变得越来越大，这可能使得redis本身的速度变慢，甚至直接崩溃。
    2.  
   
  2. 这和数据传输可靠性有关，如果在订阅方断线，那么他将会丢失所有在短线期间发布者发布的消息。
    3.  
  
 
  
十一、主从复制
 
  
概念
 
  
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点（Master/Leader）,后者称为从节点（Slave/Follower）， 数据的复制是单向的！只能由主节点复制到从节点（主节点以写为主、从节点以读为主）。
 
  
Redis 学习笔记_第102张图片
 
  
主从复制的主要作用
 
  
     
   
  1. 数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余的方式。
    2.  
   
  2. 故障恢复：当主节点故障时，从节点可以暂时替代主节点提供服务，是一种服务冗余的方式
    3.  
   
  3. 负载均衡：在主从复制的基础上，配合读写分离，由主节点进行写操作，从节点进行读操作，分担服务器的负载；尤其是在多读少写的场景下，通过多个从节点分担负载，提高并发量。
    4.  
   
  4. 高可用基石：主从复制还是哨兵和集群能够实施的基础。
    5.  
  
 
  
一般来说，要将Redis运用与工程项目中，只使用一台Redis是万万不能的（避免宕机，一主二从），原因如下：
 
  
     
   
  1. 从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大
    2.  
   
  2. 从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台服务器最大使用内存不超过20G。
    3.  
  
 
  
 
   
只要在公司中，不可能使用单机（有瓶颈），必须配置集群、使用主从复制
 
  
 
  
环境配置
 
  
只需配置从库，无需配置主库
 
  
查看主从复制信息：
 
  
 
   
默认情况下，每一个Redis服务器都是主节点
 
  
 
  
Redis 学习笔记_第103张图片
 
  
127.0.0.1:6379> info replication# Replicationrole:master  # 主节点connected_slaves:0  # 没有从节点master_replid:7776dea8df483b02d12cd482d2034ba55ec7dab0master_replid2:0000000000000000000000000000000000000000master_repl_offset:0second_repl_offset:-1repl_backlog_active:0repl_backlog_size:1048576repl_backlog_first_byte_offset:0repl_backlog_histlen:0

 
  
1、复制配置文件redis.conf到Redis安装目录下
 
  
Redis 学习笔记_第104张图片
 
  
2、再从该文件拷贝出3个文件
 
  
主：redis_6379.conf
 
  
从：redis_6380.conf、redis_6381.conf
 
  
Redis 学习笔记_第105张图片
 
  
3、修改主配置文件
 
  
 
   
由于端口和后台默认运行pid都是6379的，就不改了
 
  
 
  
image-20201117125611885
 
  
img
 
  
4、修改从配置文件
 
  
 
   
下面以 redis_6380.conf 为例， redis_6381.conf 同理
 
  
 
  
Redis 学习笔记_第106张图片
 
  
img
 
  
Redis 学习笔记_第107张图片
 
  
img
 
  
配置文件修改的信息
 
  
     
   
  1. 端口（92行）
    2.  
   
  2. pid进程名（244行）
    3.  
   
  3. 日志文件名（257行）
    4.  
   
  4. rdb文件名（339行）
    5.  
  
 
  
5、启动服务（单机多服务）
 
  
cd /usr/local/bin # 进入配置文件所在目录[root@liuyou bin]# redis-server redis_6379.conf[root@liuyou bin]# redis-server redis_6380.conf[root@liuyou bin]# redis-server redis_6381.conf[root@liuyou bin]# ps -ef | grep redis  # 查看启动状态root      2862     1  0 13:13 ?        00:00:00 redis-server 0.0.0.0:6379root      2868     1  0 13:13 ?        00:00:00 redis-server 0.0.0.0:6380root      2874     1  0 13:13 ?        00:00:00 redis-server 0.0.0.0:6381root      2880  2393  0 13:13 pts/0    00:00:00 grep --color=auto redis

 
  
6、登录客户端
 
  
①开启4个窗口，前三用于主从复制，最后一个用于测试
 
  
Redis 学习笔记_第108张图片
 
  
②登录（注意端口）
 
  
Redis 学习笔记_第109张图片
 
  
Redis 学习笔记_第110张图片
 
  
Redis 学习笔记_第111张图片
 
  
7、一主二从
 
  
默认情况下，每一个Redis服务器都是主节点
 
  
一般情况下，只配置从机
 
  
 
   
如果有密码，需要在从配置文件中，进行配置，后面会解释
 
   
下面以 窗口3（端口为6381） 为例，窗口2同理
 
  
 
  
使用slaveof 指定 主节点 ip 和 端口（临时配置）
 
  
Redis 学习笔记_第112张图片
 
  
查看主节点，主从复制信息
 
  
Redis 学习笔记_第113张图片
 
  
有密码配置（+永久配置）
 
  
Redis 学习笔记_第114张图片
 
  
 
   
配置完重启服务
 
  
 
  
测试
 
  
 
   
Redis只允许，主机写，从机读
 
  
 
  
主机写
 
  
Redis 学习笔记_第115张图片
 
  
从机读
 
  
Redis 学习笔记_第116张图片
 
  
从机不能写
 
  
Redis 学习笔记_第117张图片
 
  
 
   
主机断开连接，从机依旧连接主机，但是没有写操作，如果从机中途恢复正常，从机依旧可以获取主机写的内容
 
   
如果使用命令行配置，从机重启，就会变为主机（只有变为从机，才能获取之前主机内容）
 
   
从机断开连接，期间，主机继续写新内容，只要从机恢复，就可获得主机写的新内容
 
  
 
  
复制原理
 
  
Slave 启动成功连接到Master后会发送一个sync命令
 
  
Master接收到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，Master将传送整个数据文件到Slave，并完成一次完全同步
 
  
全量复制：而Slave服务在接收到数据库文件数据后，将其存盘并加载到内存中
 
  
增量复制：Master继续将新的所有收集到修改命令依次传给Slave，完成同步
 
  
 
   
但是只要重新连接Master，一次完全同步（全量复制）将被自动执行。
 
  
 
  
8、毛毛虫配置（主从）
 
  
 
   
上一个M连接下一个S，（可以看做主从复制的一种实现）
 
   
配置只需：将上面配好的，窗口3的主机改为窗口2即可
 
  
 
  
Redis 学习笔记_第118张图片
 
  
9、宕机手动配置主机
 
  
slaveof no one # 如果主机断开连接，从机可以使用该命令，让自己变为主机，其他节点连到该节点

 
  
 
   
如果主机如果会来了，也没有从机连接上它。
 
  
 
  
十二、哨兵模式
 
  
 
   
自动选举Redis主服务器（如果主服务器宕机）
 
  
 
  
在 Redis2.8之前，采用手动配置主机的形式（会导致一段时间服务不可用）
 
  
Redis2.8之后，Redis正是提供了Sentinel（哨兵）来解决这个问题（主机宕机，根据投票自动在从机中选出新主机）
 
  
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，他会独立运行**。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例**
 
  
单哨兵模式
 
  
Redis 学习笔记_第119张图片
 
  
哨兵的作用：
 
  
     
   
  1. 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器
    2.  
   
  2. 当哨兵监测到master宕机，会自动将slave切换到master，然后通过 发布订阅模式 通知其他的从服务器，修改配置文件，让他们切换主机
    3.  
  
 
  
多哨兵模式
 
  
Redis 学习笔记_第120张图片
 
  
假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象称为主观下线。
 
  
当其他哨兵也检测到主服务器不可用，并且达到一定数量时，那么哨兵之间就会进行一次投票，投票的结果有一个哨兵发起，进行failover故障转移操作。
 
  
切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个时候称为客观下线
 
  
测试（一主二从，单哨兵）
 
  
1、配置哨兵配置文件（文件名 sentinel.conf）
 
  
 
   
文件名不能写错，下面是文件内容（当然这个文件需要自己创建）
 
  
 
  
# sentinel monitor 被监控的名称 host port 1       # 1 表示 主机宕机，从机投票选举sentinel monitor myredis  127.0.0.1 6379 1

 
  
Redis 学习笔记_第121张图片
 
  
2、启动哨兵模式
 
  
 
   
如果被监控有密码 需在 sentinel.conf 配置文件中，追加
 
   
# sentinel auth-pass 被监控主机名称   sentinel auth-pass myredis  

 
  
 
  
redis-sentinel sentinel.conf

 
  
Redis 学习笔记_第122张图片
 
  
3、关闭主机，测试选举情况
 
  
①主机关闭
 
  
Redis 学习笔记_第123张图片
 
  
②哨兵详情
 
  
Redis 学习笔记_第124张图片
 
  
③检查窗口3（端口为6381）
 
  
Redis 学习笔记_第125张图片
 
  
④我们恢复窗口1（即之前的主机），看看情况
 
  
 
   
变成从机
 
  
 
  
Redis 学习笔记_第126张图片
 
  
优缺点
 
  
     
   
  • 优点： 
    
       
     
    • 哨兵集群，基于主从复制模式，所有的主从配置优点，它全有
      •  
     
    • 主从可以切换，故障可以转移，系统的可用性就会更好
      •  
     
    • 哨兵模式就是主从模式的升级，手动到自动，更加健壮
      •  
    
     
    •  
   
  • 缺点 
    
       
     
    • Redis不好在线扩容的，集群容量一旦达到上线，在线扩容十分麻烦
      •  
     
    • 实现哨兵模式的配置其实是很麻烦的，里面有很多选择
      •  
    
     
    •  
  
 
  
哨兵模式的全部配置
 
  
# Example sentinel.conf# 哨兵sentinel实例运行的端口 默认26379  # 如果有哨兵集群 需要配置多个端口port 26379  # 哨兵sentinel的工作目录dir /tmp# 哨兵sentinel监控的redis主节点的 ip port # master-name  可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。# quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了# sentinel monitor    sentinel monitor mymaster 127.0.0.1 6379 1# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码# sentinel auth-pass  sentinel auth-pass mymaster MySUPER--secret-0123passw0rd# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒# sentinel down-after-milliseconds  sentinel down-after-milliseconds mymaster 30000# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，# 这个数字越小，完成failover所需的时间就越长，# 但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。# 可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。# sentinel parallel-syncs  sentinel parallel-syncs mymaster 1# 故障转移的超时时间 failover-timeout 可以用在以下这些方面： #1. 同一个sentinel对同一个master两次failover之间的间隔时间。#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。#3.当想要取消一个正在进行的failover所需要的时间。  #4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了# 默认三分钟# sentinel failover-timeout  sentinel failover-timeout mymaster 180000# SCRIPTS EXECUTION#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。#对于脚本的运行结果有以下规则：#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，#这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，#一个是事件的类型，#一个是事件的描述。#如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。#通知脚本# sentinel notification-script    sentinel notification-script mymaster /var/redis/notify.sh# 客户端重新配置主节点参数脚本# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。# 以下参数将会在调用脚本时传给脚本:#       # 目前总是“failover”,# 是“leader”或者“observer”中的一个。 # 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的# 这个脚本应该是通用的，能被多次调用，不是针对性的。# sentinel client-reconfig-script  sentinel client-reconfig-script mymaster /var/redis/reconfig.sh # 运维配置

 
  
十三、缓存穿透和雪崩（面试高频，工作常用）
 
  
 
   
这里仅仅是了解，不涉及解决方案底层
 
  
 
  
Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它带来了一些问题。其中最要害的问题，就是数据一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。
 
  
1、缓存穿透（查不到）
 
  
缓存穿透：用户想要查一个数据，发现Redis内存数据库中没有，也就是缓存没命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多时，缓存都没有命中（秒杀！），于是都去请求持久层数据库。这会导致持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
 
  
解决方案
 
  
布隆过滤器
 
  
布隆过滤器是一种数据结构，对所有可能查询的参数以Hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免存储系统的查询压力。
 
  
Redis 学习笔记_第127张图片
 
  
缓存空对象
 
  
当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源
 
  
Redis 学习笔记_第128张图片
 
  
但是这个方法会存在两个问题
 
  
     
   
  • 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键
    •  
   
  • 即使空值设置了过期时间，还会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响
    •  
  
 
  
2、缓存雪崩（集中失效）
 
  
缓存雪崩，是指在某一时间段，缓存集中过期失效。Redis宕机！
 
  
产生原因之一：
 
  
比如，双十一零点抢购，会把同一批商品信息比较集中的放入缓存中，假设缓存设置一个小时的过期时间，那么到凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压抑波峰。于是所有的请求就会向存储层，存储层的调用量会暴增，可能造成存储层奔溃，服务器宕机。
 
  
Redis 学习笔记_第129张图片
 
  
其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个结点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很可能瞬间就把数据库压垮。
 
  
解决方案
 
  
Redis高可用
 
  
这个思想含义是，既然Redis有可能挂到，那我们多增设几台Redis，这样挂掉之后其他的还可以继续工作，其实就是搭建集群
 
  
限流降级
 
  
这个解决方案的思想是，在缓存失效后，通过加锁或队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
 
  
数据预热
 
  
数据加热的含义就是在正式部署之前，我们先把数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中，在即将发生大并发访问手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
 
  
3、缓存击穿（查询量太大，缓存过期瞬间）
 
  
这里需要注意和缓存穿透的区别，缓存击穿：是指一个key非常热点，在不停的扛着大并发，大并发集中对一个点进行访问，当这个key在失效的瞬间，执行的大并发就穿破缓存，直接请求持久层数据库，就像在一个屏幕上凿开一个洞。
 
  
当某个key在过期瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导致数据库瞬间压力过大。
 
  
解决方案
 
  
设置热点数据永不过期
 
  
从缓存层面，没有设置过期时间，所以不会出现热点key过期后产生的问题。
 
  
加互斥锁
 
  
分布式锁：使用分布式锁，保证对于每个key同时只能有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此分布式锁的考验很大。
 
  
版权声明：本文为博主原创文章，遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明，KuangStudy,以学为伴，一生相伴！
 
  
本文链接：https://www.kuangstudy.com/bbs/1353692191381356545
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    
                    
    • 
                    
  • Redis Key的过期策略
                        ArchManual
分布式架构分布式Java后端微服务架构redis
                        
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    
                    
    • 
                    
  • Redis:缓存击穿
                        我的程序快快跑啊
缓存redisjava
                        
    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    
                    
    • 
                    
  • L1 L2 L3 缓存
                        京天不下雨
windows缓存windows
                        
    L1L2L3缓存L1Cache(一级bai缓存)是CPU第一层高速缓存，分为数据缓存和指令缓存。du内置的zhiL1高速缓存的容量和结构对daoCPU的性能影响较大，不过高速缓冲存储器均由静态RAM组成，结构较复杂，在CPU管芯面积不能太大的情况下，L1级高速缓存的容量不可能做得太大。一般服务器CPU的L1缓存的容量通常在32—4096KB。L2由于L1级高速缓存容量的限制，为了再次提高CPU的运
    
                    
    • 
                    
  • Redis 有哪些危险命令？如何防范？
                        花小疯
redis缓存数据库危险命令大数据
                        
    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    
                    
    • 
                    
  • 非关系型数据库
                        天秤-white
nosql
                        
    一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
    
                    
    • 
                    
  • mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
                        weixin_39844942
mybatis二级缓存失效
                        
    这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
    
                    
    • 
                    
  • [转载] NoSQL简介
                        weixin_30325793
大数据数据库运维
                        
    摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
    
                    
    • 
                    
  • 详解mybatis的一二级缓存以及缓存失效原因
                        仰望天花板
缓存数据库mybatisjavamysql
                        
    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
    
                    
    • 
                    
  • Golang channel 死锁
                        羊城程序猿
golanggolang
                        
    死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
    
                    
    • 
                    
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
                        朱杰jjj
缓存分布式
                        
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    
                    
    • 
                    
  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
                        weixin_34302561
数据库devops大数据
                        
    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
    
                    
    • 
                    
  • Three.js AnimationUtils 和 AnimationObjectGroup
                        灵魂清零
three前端web3javascript
                        
    AnimationObjectGroup接收共享动画状态的一组对象。在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述用法:将本来要作为根对象传入构造器或者动画混合器(AnimationMixer)的clipAction方法中的对象加入组中，并将这个组对象作为根对象传递。注意，这个类的实例作为混合器中的一个对象，因此，必须对组内的单个对象做缓存控制。限制
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS与开源服务差异对比
                        hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端
                        
    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    
                    
    • 
                    
  • Linux中open函数详解
                        460833359
LinuxClinuxopen函数
                        
    初级文件I/O函数（即不用缓存的I/O函数）：open（打开文件）相关函数read，write，fcntl，create，lseek，close，link，stat，umask，unlink，fopen头文件#include#include#include定义函数intopen(constchar*pathname,intflags);intopen(constchar*pathname,intf
    
                    
    • 
                    
  • 页面报错 POST 413错误 (Request Entity Too Large)
                        小黑屋说YYDS
踩坑nginxjavalinux服务器
                        
    一般来说是服务器使用nginx作为反向代理出现的问题，post请求长度超过了nginx默认的缓存大小和最大客户端最大请求大小。解决方式如下，更该nginx代理配置：在nginx.conf配置文件中，找到http{}代码块，添加如下配置client_max_body_size20m;重启nginx即可。
    
                    
    • 
                    
  • 数据库连接池
                        幻影翔

                        
    连接池的意义作用：连接池是将已经创建好的连接保存在池中，当有请求来时，直接使用已经创建好的连接对数据库进行访问。这样省略了创建连接和销毁连接的过程。这样性能上得到了提高。连接池放了N个Connection对象，本质上放在内存当中，在内存中划出一块缓存对象，应用程序每次从池里获得Connection对象，而不是直接从数据里获得，这样不占用服务器的内存资源。两种优秀的连接池技术都要实现接口DataSo
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • npm install报错npm ERR! code CERT_HAS_EXPIRED
                        夏早安
npm前端node.js
                        
    报错如图解决办法：强制清缓存，取消ssl验证1.npmcacheclean--force2.npmconfigsetstrict-sslfalse3.重新npminstall4.依赖下载成功
    
                    
    • 
                    
  • 清除 Conda 缓存
                        Dmatteratall
conda缓存
                        
    清除Conda缓存：cssCopycodecondaclean--allcondaclean--all命令将会清除Conda缓存和临时文件，而不会删除已经安装的软件包和环境。它主要用于清理不必要的缓存和临时文件以释放磁盘空间。
    
                    
    • 
                    
  • 优化Conda环境：深入掌握conda clean命令的清理艺术
                        2401_85842555
conda
                        
    优化Conda环境：深入掌握condaclean命令的清理艺术Conda作为Anaconda发行版中的包管理器，不仅用于安装和管理包，还提供了强大的环境管理功能。随着时间的推移，Conda环境中可能会积累大量的缓存文件，这些文件不仅占用磁盘空间，还可能影响Conda的性能。本文将详细介绍如何在Conda中使用condaclean命令来清理缓存，帮助你优化Conda环境，释放宝贵的磁盘空间。Cond
    
                    
    • 
                    
  • Apache HBase基础（基本概述，物理架构，逻辑架构，数据管理，架构特点，HBase Shell）
                        May--J--Oldhu
HBaseHBaseshellhbase物理架构hbase逻辑架构hbase
                        
    NoSQL综述及ApacheHBase基础一.HBase1.HBase概述2.HBase发展历史3.HBase应用场景3.1增量数据-时间序列数据3.2信息交换-消息传递3.3内容服务-Web后端应用程序3.4HBase应用场景示例4.ApacheHBase生态圈5.HBase物理架构5.1HMaster5.2RegionServer5.3Region和Table6.HBase逻辑架构-Row7.
    
                    
    • 
                    
  • MySQL内存结构
                        san.hang
数据库数据结构与算法
                        
    实际上MySQL内存的组成和Oracle类似，也可以分为SGA（系统全局区）和PGA（程序缓存区）。mysql>showvariableslike"%buffer%";一、SGA1.innodb_buffer_bool用来缓存Innodb表的数据、索引、插入缓冲、数据字典等信息。2.innodb_log_buffer事务在内存中的缓冲，即redlogbuffer的大小3.querycache高速查
    
                    
    • 
                    
  • 关于Redis集群同步/持久化/淘汰机制的详解
                        尾巴尖上的阳光
大数据redis数据库
                        
    Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
    
                    
    • 
                    
  • 主流行架构
                        rainbowcheng
架构架构
                        
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    
                    
    • 
                    
  • Java中的服务端点响应缓存：Spring Cache抽象
                        微赚淘客机器人开发者联盟@聚娃科技
java缓存spring
                        
    Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
    
                    
    • 
                    
  • Certificate has expired(npm 安装strapi)
                        窥见漫天星光-莹
npmstrapi
                        
    报错信息解决方法1、清空缓存，有时，损坏的缓存会导致连接问题npmcacheclean--force2、切换到淘宝镜像源的npm注册表npmconfigsetregistryhttps://registry.npmmirror.com/执行这两步后就可以执行自己想要安装的东西了，我是在执行npxcreate-strapi-appschedul命令创建strapi项目时报上述错误。仅供参考。当然再安
    
                    
    • 
                                
  • Java序列化进阶篇
                                    g21121
java序列化
                                    
            1.transient 
        类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。 

    
                                
    • 
                                
  • escape()、encodeURI()、encodeURIComponent()区别详解 
                                    aigo
JavaScriptWeb
                                    
    原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html 
  
JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。 
下面简单介绍一下它们的区别 
1 escape()函
    
                                
    • 
                                
  • ArcgisEngine实现对地图的放大、缩小和平移
                                    Cb123456
添加矢量数据对地图的放大、缩小和平移Engine
                                    
    ArcgisEngine实现对地图的放大、缩小和平移: 
 个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧. 
 具体实现: 
一、引入命名空间 
   using ESRI.ArcGIS.Geometry; 
   using ESRI.ArcGIS.Controls; 
二、代码实现.
    
                                
    • 
                                
  • Java集合框架概述
                                    天子之骄
Java集合框架概述
                                    
       集合框架 
集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 
从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。 
  
简单介绍： 
  
Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
    
                                
    • 
                                
  • 旗正4.0页面跳转传值问题
                                    何必如此
javajsp
                                    
    跳转和成功提示 
a)        成功字段非空forward 
成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
    
                                
    • 
                                
  • 全网唯一:移动互联网服务器端开发课程
                                    cocos2d-x小菜
web开发移动开发移动端开发移动互联程序员
                                    
        移动互联网时代来了！     App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
    
                                
    • 
                                
  • Log4J通用配置|注意问题 笔记
                                    7454103
DAOapachetomcatlog4jWeb
                                    
    关于日志的等级 那些去 百度就知道了！ 
这几天 要搭个新框架  配置了 日志 记下来 ！做个备忘！ 
 

 #这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~!
log4j.rootLogger=INFO,allLog

# DAO层 log记录到dao.log 控制台 和 总日志文件
log4j.logger.DAO=INFO,dao,C
    
                                
    • 
                                
  • SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager
                                    darkranger
sqlcwindowsSQL ServerXP
                                    
    当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动.. 
发现需要启动客户端协议 : TCP/IP  
需要打开 SQL Server Configuration Manager... 
却发现无法打开 SQL Server Configuration Manager..?? 
 
解决方法:  C:\WINDOWS\system32目录搜索framedyn.
    
                                
    • 
                                
  • [置顶] 做有中国特色的程序员
                                    aijuans
程序员
                                    
    从出版业说起   网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。   许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
    
                                
    • 
                                
  • document.domain 跨域问题
                                    avords
document
                                    
    document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com"); 
    
                                
    • 
                                
  • 关于管理软件的一些思考
                                    houxinyou
管理
                                    
      
工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱. 
在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下. 
做为管理软件,就像现在讲究MVC这
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(String类型和hash类型)
                                    bijian1013
redis数据库NoSQL
                                    
    一.Redis的数据类型 
1.String类型及操作 
        String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。 
        Set方法：设置key对应的值为string类型的value 
    
                                
    • 
                                
  • Tomcat 一些技巧
                                    征客丶
javatomcatdos
                                    
    以下操作都是在windows 环境下 
 
一、Tomcat 启动时配置 JAVA_HOME 
在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加 
 
set JAVA_HOME=JAVA 安装目录 
set JRE_HOME=JAVA 安装目录/jre 
 
即可； 
 
二、查看Tomcat 版本 
在 tomcat 安装目
    
                                
    • 
                                
  • 【Spark七十二】Spark的日志配置
                                    bit1129
spark
                                    
    在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console 
  
在Spark的conf目录下，把log4j.properties.template修改为log4j.p
    
                                
    • 
                                
  • Haskell版冒泡排序
                                    bookjovi
冒泡排序haskell
                                    
    面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。 
  
  
sort [] = []
sort [x] = [x]
sort (x:x1:xs)
    | x>x1 = x1:so
    
                                
    • 
                                
  • java 路径 配置文件读取
                                    bro_feng
java
                                    
    这几天做一个项目，关于路径做如下笔记，有需要供参考。 
 
取工程内的文件，一般都要用相对路径，这个自然不用多说。 
 
在src统计目录建配置文件目录res,在res中放入配置文件。 
读取文件使用方式： 
1. MyTest.class.getResourceAsStream("/res/xx.properties") 
2. properties.load(MyTest.
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-简单工厂模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


package design.pattern;

/*
 * 个人理解：简单工厂模式就是IOC;
 * 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了
 */
interface IProduct {
	
    
                                
    • 
                                
  • SVN与JIRA的关联
                                    chenyu19891124
SVN
                                    
    SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤： 
一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务 
二、装好JIRA，自己用是jira-4.3.4破解版 
三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
    
                                
    • 
                                
  • JWFDv0.96 最新设计思路
                                    comsci
数据结构算法工作企业应用公告
                                    
                       
 
 
随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
    
                                
    • 
                                
  • vi 保存复制内容格式粘贴
                                    daizj
vi粘贴复制保存原格式不变形
                                    
        vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？ 答案是肯定的，vi有一个很强大的命令可以实现此功能 。 
 
    在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
    
                                
    • 
                                
  • shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法
                                    dongwei_6688
shell脚本
                                    
    出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致 
解决办法： 
 1. 比如文件名为myshell.sh，vim myshell.sh 
 2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题 
 3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
    
                                
    • 
                                
  • 高一上学期难记忆单词
                                    dcj3sjt126com
wordenglish
                                    
    honest 诚实的；正直的 
argue 争论 
classical 古典的 
hammer 锤子 
share  分享；共有 
sorrow 悲哀；悲痛 
adventure 冒险 
error 错误；差错 
closet 壁橱；储藏室 
pronounce 发音；宣告 
repeat 重做；重复 
majority 大多数；大半 
  
native 本国的，本地的，本国
    
                                
    • 
                                
  • hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性
                                    frankco
POJOhibernate查询DTO
                                    
          DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。 
      简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。 
  
      有时候我们需要查询返回DTO对象，因为DTO
    
                                
    • 
                                
  • Partition List
                                    hcx2013
partition
                                    
    Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. 
You should preserve the original relative order of th
    
                                
    • 
                                
  • Spring MVC测试框架详解——客户端测试
                                    jinnianshilongnian

                                    
    上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
    
                                
    • 
                                
  • 关于推荐个人观点
                                    liyonghui160com
推荐系统关于推荐个人观点
                                    
        回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】 
 
    第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
    
                                
    • 
                                
  • 不间断旋转的动画
                                    pangyulei
动画
                                    
    
CABasicAnimation* rotationAnimation;
    rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"];
    rotationAnimation.toValue = [NSNumber numberWithFloat: M
    
                                
    • 
                                
  • 自定义annotation
                                    sha1064616837
javaenumannotationreflect
                                    
    对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。 
下面这个例子 主要用到了 
1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解 
2.简单的反射 
3.枚举 
    
                                
    • 
                                
  • Spring 源码
                                    up2pu
spring
                                    
    1.Spring源代码 
https://github.com/SpringSource/spring-framework/branches/3.2.x 
注：兼容svn检出 
 
2.运行脚本 
import-into-eclipse.bat 
注：需要设置JAVA_HOME为jdk 1.7 
 
build.gradle 
 compileJava { 
 sourceCompatibilit
    
                                
    • 
                                
  • 利用word分词来计算文本相似度
                                    yangshangchuan
wordword分词文本相似度余弦相似度简单共有词
                                    
    word分词提供了多种文本相似度计算方式： 
方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 
实现类：org.apdplat.word.analysis.CosineTextSimilarity 
用法如下： 
String text1 = "我爱购物";
String text2 = "我爱读书";
String text3 = 
    
                                
    •