缓存json

A. 如何缓存跨域JSON数据

缓存其实还是跟普通的http协议的缓存机制一样的吧。expirs头。max-age。

B. 如何在手机端缓存json数据

是不是操作www目录了?
www目录对于plus.io是只读的。只能操作其他目录，
PRIVATE_DOC应用私有文档目录常量
PUBLIC_DOCUMENTS程序公用文档目录常量
PUBLIC_DOWNLOADS程序公用下载目录常量

C. b站缓存json是什么

entry.json

这个文件主要是记录缓存状态，视频标题，视频大小。

danmaku.xml

顾名思义，弹幕，存放弹幕的文件。

index.json

校验视频文件与清晰度的文件。

sum

没遇到过这类文件。。疑似校验文件?

blv文件

视频文件，可以直接打开。

D. android 解析的json信息 用什么缓存到本地

可以用文件，或者是SQLite数据库存储在本地。
如果感觉过于小题大做了，那就使用SharePrefrence进行存储
希望我的回答对你有所帮助

E. 如何缓存跨域JSON数据

很多浏览器出去安全考虑都会

组织跨域的get请求. 要跨域读取数据,

必须有得到api服务端的授权支持. 常见

的方式有以下三种. (1)Jsonp 实际上就是在请求的api地址末尾加上一个回调函数, 然后将结果通过回调函数传递给客户端. (2)授权特定Url 服务器.

F. Elasticsearch性能优化

注：文本整理自《ELKstack权威指南》

在 CRUD 章节，我们已经知道 ES 的数据写入是如何操作的了。喜欢自己动手的读者可能已经迫不及待的自己写了程序开始往 ES 里写数据做测试。这时候大家会发现：程序的运行速度非常一般，即使 ES 服务运行在本机，一秒钟大概也就能写入几百条数据。

这种速度显然不是 ES 的极限。事实上，每条数据经过一次完整的 HTTP POST 请求和 ES indexing 是一种极大的性能浪费，为此，ES 设计了批量提交方式。在数据读取方面，叫 mget 接口，在数据变更方面，叫 bulk 接口。mget 一般常用于搜索时 ES 节点之间批量获取中间结果集，对于 Elastic Stack 用户，更常见到的是 bulk 接口。

bulk 接口采用一种比较简朴的数据积累格式，示例如下：

格式是，每条 JSON 数据的上面，加一行描述性的元 JSON，指明下一行数据的操作类型，归属索引信息等。

采用这种格式，而不是一般的 JSON 数组格式，是因为接收到 bulk 请求的 ES 节点，就可以不需要做完整的 JSON 数组解析处理，直接按行处理简短的元 JSON，就可以确定下一行数据 JSON 转发给哪个数据节点了。这样，一个固定内存大小的 network buffer 空间，就可以反复使用，又节省了大量 JVM 的 GC。

事实上，产品级的 logstash、rsyslog、spark 都是默认采用 bulk 接口进行数据写入的。对于打算自己写程序的读者，建议采用 Perl 的 Search::Elasticsearch::Bulk 或者 Python 的 elasticsearch.helpers.* 库。

在配置 bulk 数据的时候，一般需要注意的就是请求体大小(bulk size)。

这里有一点细节上的矛盾，我们知道，HTTP 请求，是可以通过 HTTP 状态码 100 Continue 来持续发送数据的。但对于 ES 节点接收 HTTP 请求体的 Content-Length 来说，是按照整个大小来计算的。所以，首先，要确保 bulk 数据不要超过 http.max_content_length 设置。

那么，是不是尽量让 bulk size 接近这个数值呢？当然不是。

依然是请求体的问题，因为请求体需要全部加载到内存，而 JVM Heap 一共就那么多(按 31GB 算)，过大的请求体，会挤占其他线程池的空间，反而导致写入性能的下降。

再考虑网卡流量，磁盘转速的问题，所以一般来说，建议 bulk 请求体的大小，在 15MB 左右，通过实际测试继续向上探索最合适的设置。

注意：这里说的 15MB 是请求体的字节数，而不是程序里里设置的 bulk size。bulk size 一般指数据的条目数。不要忘了，bulk 请求体中，每条数据还会额外带上一行元 JSON。

以 logstash 默认的 bulk_size => 5000 为例，假设单条数据平均大小 200B ，一次 bulk 请求体的大小就是 1.5MB。那么我们可以尝试 bulk_size => 50000 ；而如果单条数据平均大小是 20KB，一次 bulk 大小就是 100MB，显然超标了，需要尝试下调至 bulk_size => 500 。

gateway 是 ES 设计用来长期存储索引数据的接口。一般来说，大家都是用本地磁盘来存储索引数据，即 gateway.type 为 local 。

数据恢复中，有很多策略调整我们已经在之前分片控制小节讲过。除开分片级别的控制以外，gateway 级别也还有一些可优化的地方：

注意：gateway 中说的节点，仅包括主节点和数据节点，纯粹的 client 节点是不算在内的。如果你有更明确的选择，也可以按需求写：

虽然 ES 对 gateway 使用 NFS，iscsi 等共享存储的方式极力反对，但是对于较大量级的索引的副本数据，ES 从 1.5 版本开始，还是提供了一种节约成本又不特别影响性能的方式：影子副本(shadow replica)。

首先，需要在集群各节点的 elasticsearch.yml 中开启选项：

同时，确保各节点使用相同的路径挂载了共享存储，且目录权限为 Elasticsearch 进程用户可读可写。

然后，创建索引：

针对 shadow replicas ，ES 节点不会做实际的索引操作，而是单纯的每次 flush 时，把 segment 内容 fsync 到共享存储磁盘上。然后 refresh 让其他节点能够搜索该 segment 内容。

如果你已经决定把数据放到共享存储上了，采用 shadow replicas 还是有一些好处的：

但是请注意：主分片节点还是要承担一个副本的写入过程，并不像 Lucene 的 FileReplicator 那样通过复制文件完成，所以达不到完全节省 CPU 的效果。

shadow replicas 只是一个在某些特定环境下有用的方式。在资源允许的情况下，还是应该使用 local gateway。而另外采用 snapshot 接口来完成数据长期备份到 HDFS 或其他共享存储的需要。

我们都知道，ES 中的 master 跟一般 MySQL、Hadoop 的 master 是不一样的。它即不是写入流量的唯一入口，也不是所有数据的元信息的存放地点。所以，一般来说，ES 的 master 节点负载很轻，集群性能是可以近似认为随着 data 节点的扩展线性提升的。

但是，上面这句话并不是完全正确的。

ES 中有一件事情是只有 master 节点能管理的，这就是集群状态(cluster state)。

集群状态中包括以下信息：

这些信息在集群的任意节点上都存放着，你也可以通过 /_cluster/state 接口直接读取到其内容。注意这最后一项信息，之前我们已经讲过 ES 怎么通过简单地取余知道一条数据放在哪个分片里，加上现在集群状态里又记载了分片在哪个节点上，那么，整个集群里，任意节点都可以知道一条数据在哪个节点上存储了。所以，数据读写才可以发送给集群里任意节点。

至于修改，则只能由 master 节点完成！显然，集群状态里大部分内容是极少变动的，唯独有一样除外——索引的映射。因为 ES 的 schema-less 特性，我们可以任意写入 JSON 数据，所以索引中随时可能增加新的字段。这个时候，负责容纳这条数据的主分片所在的节点，会暂停写入操作，将字段的映射结果传递给 master 节点；master 节点合并这段修改到集群状态里，发送新版本的集群状态到集群的所有节点上。然后写入操作才会继续。一般来说，这个操作是在一二十毫秒内就可以完成，影响也不大。

但是也有一些情况会是例外。

在较大规模的 Elastic Stack 应用场景中，这是比较常见的一个情况。因为 Elastic Stack 建议采用日期时间作为索引的划分方式，所以定时(一般是每天)，会统一产生一批新的索引。而前面已经讲过，ES 的集群状态每次更新都是阻塞式的发布到全部节点上以后，节点才能继续后续处理。

这就意味着，如果在集群负载较高的时候，批量新建新索引，可能会有一个显着的阻塞时间，无法写入任何数据。要等到全部节点同步完成集群状态以后，数据写入才能恢复。

不巧的是，中国使用的是北京时间，UTC +0800。也就是说，默认的 Elastic Stack 新建索引时间是在早上 8 点。这个时间点一般日志写入量已经上涨到一定水平了(当然，晚上 0 点的量其实也不低)。

对此，可以通过定时任务，每天在最低谷的早上三四点，提前通过 POST mapping 的方式，创建好之后几天的索引。就可以避免这个问题了。

如果你的日志是比较严重的非结构化数据，这个问题在 2.0 版本后会变得更加严重。 Elasticsearch 从 2.0 版本开始，对 mapping 更新做了重构。为了防止字段类型冲突和减少 master 定期下发全量 cluster state 导致的大流量压力，新的实现和旧实现的区别在：

也就是说，一旦你日志中字段数量较多，在新创建索引的一段时间内，可能长达几十分钟一直被反复锁死！

这是另一种常见的滥用。在使用 Elastic Stack 处理访问日志时，为了查询更方便，可能会采用 logstash-filter-kv 插件，将访问日志中的每个 URL 参数，都切分成单独的字段。比如一个 "/index.do?uid=1234567890&action=payload" 的 URL 会被转换成如下 JSON：

但是，因为集群状态是存在所有节点的内存里的，一旦 URL 参数过多，ES 节点的内存就被大量用于存储字段映射内容。这是一个极大的浪费。如果碰上 URL 参数的键内容本身一直在变动，直接撑爆 ES 内存都是有可能的！

以上是真实发生的事件，开发人员莫名的选择将一个 UUID 结果作为 key 放在 URL 参数里。直接导致 ES 集群 master 节点全部 OOM。

如果你在 ES 日志中一直看到有新的 updating mapping [logstash-2015.06.01] 字样出现的话，请郑重考虑一下自己是不是用的上如此细分的字段列表吧。

好，三秒钟过去，如果你确定一定以及肯定还要这么做，下面是一个变通的解决办法。

用 nested object 来存放 URL 参数的方法稍微复杂，但还可以接受。单从 JSON 数据层面看，新方式的数据结构如下：

没错，看起来就是一个数组。但是 JSON 数组在 ES 里是有两种处理方式的。

如果直接写入数组，ES 在实际索引过程中，会把所有内容都平铺开，变成 Arrays of Inner Objects 。整条数据实际类似这样的结构：

这种方式最大的问题是，当你采用 urlargs.key:"uid" AND urlargs.value:"0987654321" 语句意图搜索一个 uid=0987654321 的请求时，实际是整个 URL 参数中任意一处 value 为 0987654321 的，都会命中。

要想达到正确搜索的目的，需要在写入数据之前，指定 urlargs 字段的映射类型为 nested object。命令如下：

这样，数据实际是类似这样的结构：

当然，nested object 节省字段映射的优势对应的是它在使用的复杂。Query 和 Aggs 都必须使用专门的 nested query 和 nested aggs 才能正确读取到它。

nested query 语法如下：

nested aggs 语法如下：

ES 内针对不同阶段，设计有不同的缓存。以此提升数据检索时的响应性能。主要包括节点层面的 filter cache 和分片层面的 request cache。下面分别讲述。

ES 的 query DSL 在 2.0 版本之前分为 query 和 filter 两种，很多检索语法，是同时存在 query 和 filter 里的。比如最常用的 term、prefix、range 等。怎么选择是使用 query 还是 filter 成为很多用户头疼的难题。于是从 2.0 版本开始，ES 干脆合并了 filter 统一归为 query。但是具体的检索语法本身，依然有 query 和 filter 上下文的区别。ES 依靠这个上下文判断，来自动决定是否启用 filter cache。

query 跟 filter 上下文的区别，简单来说：

所以，选择也就出来了：

不过我们要怎么写，才能让 ES 正确判断呢？看下面这个请求：

在这个请求中，

需要注意的是，filter cache 是节点层面的缓存设置，每个节点上所有数据在响应请求时，是共用一个缓存空间的。当空间用满，按照 LRU 策略淘汰掉最冷的数据。

可以用 indices.cache.filter.size 配置来设置这个缓存空间的大小，默认是 JVM 堆的 10%，也可以设置一个绝对值。注意这是一个静态值，必须在 elasticsearch.yml 中提前配置。

ES 还有另一个分片层面的缓存，叫 shard request cache。5.0 之前的版本中，request cache 的用途并不大，因为 query cache 要起作用，还有几个先决条件：

以 Elastic Stack 场景来说，Kibana 里几乎所有的请求，都是有 @timestamp 作为过滤条件的，而且大多数是以 最近 N 小时/分钟 这样的选项，也就是说，页面每次刷新，发出的请求 JSON 里的时间过滤部分都是在变动的。query cache 在处理 Kibana 发出的请求时，完全无用。

而 5.0 版本的一大特性，叫 instant aggregation。解决了这个先决条件的一大阻碍。

在之前的版本，Elasticsearch 接收到请求之后，直接把请求原样转发给各分片，由各分片所在的节点自行完成请求的解析，进行实际的搜索操作。所以缓存的键是原始 JSON 串。

而 5.0 的重构后，接收到请求的节点先把请求的解析做完，发送到各节点的是统一拆分修改好的请求，这样就不再担心 JSON 串多个空格啥的了。

其次，上面说的‘拆分修改’是怎么回事呢？

比如，我们在 Kibana 里搜索一个最近 7 天( @timestamp:["now-7d" TO "now"] )的数据，ES 就可以根据按天索引的判断，知道从 6 天前到昨天这 5 个索引是肯定全覆盖的。那么这个横跨 7 天的 date range query 就变成了 5 个 match_all query 加 2 个短时间的 date_range query。

现在你的仪表盘过 5 分钟自动刷新一次，再提交上来一次最近 7 天的请求，中间这 5 个 match_all 就完全一样了，直接从 request cache 返回即可，需要重新请求的，只有两头真正在变动的 date_range 了。

注1： match_all 不用遍历倒排索引，比直接查询 @timestamp:* 要快很多。
注2：判断覆盖修改为 match_all 并不是真的按照索引名称，而是 ES 从 2.x 开始提供的 field_stats 接口可以直接获取到 @timestamp 在本索引内的 max/min 值。当然从概念上如此理解也是可以接受的。

响应结果如下：

和 filter cache 一样，request cache 的大小也是以节点级别控制的，配置项名为 indices.requests.cache.size ，其默认值为 1% 。

字段数据(fielddata)，在 Lucene 中又叫 uninverted index。我们都知道，搜索引擎会使用倒排索引(inverted index)来映射单词到文档的 ID 号。而同时，为了提供对文档内容的聚合，Lucene 还可以在运行时将每个字段的单词以字典序排成另一个 uninverted index，可以大大加速计算性能。

作为一个加速性能的方式，fielddata 当然是被全部加载在内存的时候最为有效。这也是 ES 默认的运行设置。但是，内存是有限的，所以 ES 同时也需要提供对 fielddata 内存的限额方式：

Elasticsearch 在 total，fielddata，request 三个层面上都设计有 circuit breaker 以保护进程不至于发生 OOM 事件。在 fielddata 层面，其设置为：

但是相比较集群庞大的数据量，内存本身是远远不够的。为了解决这个问题，ES 引入了另一个特性，可以对精确索引的字段，指定 fielddata 的存储方式。这个配置项叫： doc_values 。

所谓 doc_values ，其实就是在 ES 将数据写入索引的时候，提前生成好 fielddata 内容，并记录到磁盘上。因为 fielddata 数据是顺序读写的，所以即使在磁盘上，通过文件系统层的缓存，也可以获得相当不错的性能。

注意：因为 doc_values 是在数据写入时即生成内容，所以，它只能应用在精准索引的字段上，因为索引进程没法知道后续会有什么分词器生成的结果。

由于在 Elastic Stack 场景中， doc_values 的使用极其频繁，到 Elasticsearch 5.0 以后，这两者的区别被彻底强化成两个不同字段类型： text 和 keyword 。

等同于过去的：

而

等同于过去的：

也就是说，以后的用户，已经不太需要在意 fielddata 的问题了。不过依然有少数情况，你会需要对分词字段做聚合统计的话，你可以在自己接受范围内，开启这个特性：

你可以看到在上面加了一段 fielddata_frequency_filter 配置，这个配置是 segment 级别的。上面示例的意思是：只有这个 segment 里的文档数量超过 500 个，而且含有该字段的文档数量占该 segment 里的文档数量比例超过 10% 时，才加载这个 segment 的 fielddata。

下面是一个可能有用的对分词字段做聚合的示例：

这个示例可以对经过了 logstash-filter-punct 插件处理的数据，获取每种 punct 类型日志的关键词和对应的代表性日志原文。其效果类似 Splunk 的事件模式功能：

[图片上传失败...(image-b0b69f-1511752650964)]

如果经过之前章节的一系列优化之后，数据确实超过了集群能承载的能力，除了拆分集群以外，最后就只剩下一个办法了：清除废旧索引。

为了更加方便的做清除数据，合并 segment，备份恢复等管理任务，Elasticsearch 在提供相关 API 的同时，另外准备了一个命令行工具，叫 curator 。curator 是 Python 程序，可以直接通过 pypi 库安装：

注意，是 elasticsearch-curator 不是 curator。PyPi 原先就有另一个项目叫这个名字

和 Elastic Stack 里其他组件一样，curator 也是被 Elastic.co 收购的原开源社区周边。收编之后同样进行了一次重构，命令行参数从单字母风格改成了长单词风格。新版本的 curator 命令可用参数如下：

Options 包括:

--host TEXT Elasticsearch host.
--url_prefix TEXT Elasticsearch http url prefix.
--port INTEGER Elasticsearch port.
--use_ssl Connect to Elasticsearch through SSL.
--http_auth TEXT Use Basic Authentication ex: user:pass
--timeout INTEGER Connection timeout in seconds.
--master-only Only operate on elected master node.
--dry-run Do not perform any changes.
--debug Debug mode
--loglevel TEXT Log level
--logfile TEXT log file
--logformat TEXT Log output format [default|logstash].
--version Show the version and exit.
--help Show this message and exit.

Commands 包括:
alias Index Aliasing
allocation Index Allocation
bloom Disable bloom filter cache
close Close indices
delete Delete indices or snapshots
open Open indices
optimize Optimize Indices
replicas Replica Count Per-shard
show Show indices or snapshots
snapshot Take snapshots of indices (Backup)

针对具体的 Command，还可以继续使用 --help 查看该子命令的帮助。比如查看 close 子命令的帮助，输入 curator close --help ，结果如下：

在使用 1.4.0 以上版本的 Elasticsearch 前提下，curator 曾经主要的一个子命令 bloom 已经不再需要使用。所以，目前最常用的三个子命令，分别是 close , delete 和 optimize ，示例如下：

这一顿任务，结果是：

logstash-mweibo-nginx-yyyy.mm.dd 索引保存最近 5 天， logstash-mweibo-client-yyyy.mm.dd 保存最近 10 天， logstash-mweibo-yyyy.mm.dd 索引保存最近 30 天；且所有七天前的 logstash-* 索引都暂时关闭不用；最后对所有非当日日志做 segment 合并优化。

profiler 是 Elasticsearch 5.0 的一个新接口。通过这个功能，可以看到一个搜索聚合请求，是如何拆分成底层的 Lucene 请求，并且显示每部分的耗时情况。

启用 profiler 的方式很简单，直接在请求里加一行即可：

可以看到其中对 query 和 aggs 部分的返回是不太一样的。

query 部分包括 collectors、rewrite 和 query 部分。对复杂 query，profiler 会拆分 query 成多个基础的 TermQuery，然后每个 TermQuery 再显示各自的分阶段耗时如下：

我们可以很明显的看到聚合统计在初始化阶段、收集阶段、构建阶段、汇总阶段分别花了多少时间，遍历了多少数据。

注意其中 rece 阶段还没实现完毕，所有都是 0。因为目前 profiler 只能在 shard 级别上做统计。

collect 阶段的耗时，有助于我们调整对应 aggs 的 collect_mode 参数选择。目前 Elasticsearch 支持 breadth_first 和 depth_first 两种方式。

initialise 阶段的耗时，有助于我们调整对应 aggs 的 execution_hint 参数选择。目前 Elasticsearch 支持 map 、 global_ordinals_low_cardinality 、 global_ordinals 和 global_ordinals_hash 四种选择。在计算离散度比较大的字段统计值时，适当调整该参数，有益于节省内存和提高计算速度。

对高离散度字段值统计性能很关注的读者，可以关注 https://github.com/elastic/elasticsearch/pull/21626 这条记录的进展。

（本文完）

文本整理自《ELKstack权威指南》

G. 为什么B站缓存的视频只有json文件

你好，因为这个B站只支持缓存这种格式的文件，所以就只有json文件

H. Memcached 可以用来缓存 json 吗

1.什么是memcached

缓存是一种常驻与内存的内存数据库，内存的读取速度远远快于程序在磁盘读取数据的速度。我们在设计程序的时候常常会考虑使用缓存，将经常访问的数据放到内存上面这样可以提高访问数据的速度，同时可以降低磁盘或数据库的压力。
memcached就是一款可以方便实现缓存的工具软件，memcached的优势在于以下几点：
1.实现分布式缓存（支持热部署），通过hashcode根据缓存服务器ip智能分配将数据缓存到的服务器上。
2.实现最近最少访问的数据优先被移除缓存。
3.快速找到适配的存储空间，避免内存的浪费。
4.使用键值对存储数据，方便读取修改等缓存的管理。
5.socket通信，缓存服务器和应用服务器分离。
等等，memcached还含有很多自身的优势。
使用缓存中我们面临的缓存数据无法同步的问题：比如一台缓存服务器突然崩溃那么这台服务器上面的缓存数据就会全部丢失，而且需要在配置中及时去除这台崩溃的服务器IP，这个需要我们编写更多的代码进行相应的控制。

2.memcached内部机制

memcached为了提高数据的存储速度，在安装启动memcached服务的时候，他会自动将分配给memcached的内存分隔为大小不一致的很多块。每当任意一个大小的需要缓存的数据提交过来的时候memcached将会自动找到符合这个数据大小最适合的内存块，然后把数据放到这个块里面。这种方式不仅可以降低内存的浪费同时可以减少了内存分配的时间了。
如果memcached里面的内存已经被使用完了，还需要向里面添加数据的时候，memcached将会把存入缓存中最长时间没有用的数据清除掉。
每次向缓存中添加数据的时候都会带上该数据的有效时间，如果超过了这个有效时间那么缓存的数据自动失效了。
memcached安装到计算机上是一款服务默认端口11211，我们可以通过socket与他建立通信。建立起通信之后就可以通过执行memcached的指令向缓存里面添加取出或修改或删除缓存数据的工作了。

3.C#如何操作memcached

C#建立memcached连接，首先通过socket建立于11211的通信，建立socketpool，然后通过socket发起远程命令的执行语句，在这里使用socket建立连接就需要设定每一次连接建立的最大时间，如果不设定最大时间，那么在建立某一个连接的时候发生了异常，那么机器就会长时间处于等待知道连接超时异常抛出。
使用了线程池和进行Socket的链接。然后通过Socket进行相应的链接操作。
其实memcached作为一种服务，他可以被不同语言不同平台建立连接并执行命令。

4.memcached内部操作指令和名词解释

所有语言建立连接到memcached服务之后，要管理memcached都执行的是同一套的指令集合。

在Windows系统中我们可以使用telnet命令来查看Memcached的相关运行情况如：
stats telnet xxx.xxx.xxx.xxx 11211
输入stats命令：在这里屏幕是空白，看不到输入的内容，回车之后可以看到Memcached的运行相关信息。
set key
get key
memcached客户机命令
set
Add
replace
get
delete
输入stats命令：在这里屏幕是空白，看不到输入的内容，回车之后可以看到Memcached的运行相关信息。
查看出来的结果名词的意思：Pid: Memcached服务器中的进程编号
Uptime：Memcached服务器启动之后所经历的时间，单位秒
Time：当前系统时间，单位秒
Version: Memcached的版本号
pointer_size：服务器所在主机操作系统的指针大小，一般为32或64
curr_items：表示当前缓存中存放的所有缓存对象的数量
total_items：表示从memcached服务启动到当前时间，系统存储过的所有对象的数量，包括已经删除的对象
bytes：表示系统存储缓存对象所使用的存储空间，单位为字节
curr_connections：表示当前系统打开的连接数
total_connections：表示从memcached服务启动到当前时间，系统打开过的连接的总数
cmd_get：查询缓存的次数，即使不成功也算一次
cmd_set：保存数据的次数，当然这里只保存成功的次数
get_hits：表示获取数据成功的次数。
get_misses：表示获取数据失败的次数。
evictions：为了给新的数据项目释放空间，从缓存移除的缓存对象的数目。比如超过缓存大小时根据LRU算法移除的对象，以及过期的对象
bytes_read：memcached服务器从网络读取的总的字节数
bytes_written：memcached服务器发送到网络的总的字节数
limit_maxbytes：memcached服务缓存允许使用的最大字节数
threads：被请求的工作线程的总数量
缓存命中率 = get_hits / cmd_get * 100% ;

5.良好的缓存

良好的缓存需要具备以下几点：
1.灵活指定不同类型的缓存时间。
2.可以通过配置文件或管理站点对缓存的配置和管理。
3.灵活做到对不同用户的缓存进行管理。
4.缓存服务器应该稳定，并能及时备份缓存数据。
5.灵活的对缓存的数据进行管理。
这里以我接触过的良好的缓存策略，是将缓存的配置填写到一个xml或则json配置文件里面。
比如：

[csharp] view plain
<?xml version='1.0' encoding='utf-8'?>
[csharp] view plain
<Root>
<Item>
<CacheTime>10000</CacheTime>
<DataType>B2C</DataType>
<Enabled>True</Enabled>
</Item>
<Item>
<CacheTime>10000</CacheTime>
<DataType>PHONE</DataType>
<Enabled>True</Enabled>
</Item>
</Root>
上面的一个配置就能很好的指定摸一个类型的缓存时间配置，然后还能启用或停用某一种类型是否进行缓存。

还可以把这个xml配置更加复杂以满足对不同用户的缓存时间其实也是不一样的。
在缓存的开发完成之后，对缓存的管理要做到灵活多样。因为在运维过程中常常需要新增或删除或修改某一些缓存的内容所以做到灵活易管理是非常的重要的。

6.缓存的扩展

缓存的我们已经了解了一些了，那么在平时开发中我们可以那些地方使用缓存呢？首先用户经常读取的数据可以放入到缓存之中。其次用户高频写入的数据也可以通过缓存在又换速度。最后网站的一些静态文件内容也可以放入。
用户高频写入数据库的数据放入缓存的方式，如果用户每一次写入数据库都需要与数据库建立连接，并将数据写入到数据库势必降低整个运行效率，那么我们就需要降低与数据库建立连接并写入磁盘的次数，所以可以规定一个缓存内容的大小，如果缓存到得数据达到某一个数量级就一次性的将数据写入到数据库，或则定时将缓存中的数据取出然后一并写入数据库。我觉得以上两种方式可以结合起来使用可以降低程序与数据库建立连接写入磁盘所开销的资源。
其他的缓存服务软件有redis。非常出色以下几个方面：

1.Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。
2.Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。
3.Redis支持数据的备份，即master-slave模式的数据备份。
4.Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
我个人认为最本质的不同是Redis在很多方面具备数据库的特征，或者说就是一个数据库系统，而Memcached只是简单的K/V缓存

I. entry.json是什么文件

说明文件。“entry.json 这个文件主要是记录缓存状态，视频标题，视频大小。entry.json是微信小程序里面的一个说明文件。微信小程序，简称小程序，英文名MiniProgram，是一种不需要下载安装即可使用的应用，它实现了应用“触手可及”的梦想，用户扫一扫或搜一下即可打开应用。

J. 在哪搜索json视频源

B站。B站搜索是一种有条理，易于访问的存储信息的方法。json视频源支持缓存格式的文件，所以B站可以搜索到json文件。