幸运lxh 生活 工作 远方 2025-02-06T09:04:31.545Z https://blog.luckylxh.top/ 枪兵幸运E Hexo Spring Framework路径遍历漏洞 (CVE-2024-38819) https://blog.luckylxh.top/2025/02/06/Spring-Framework路径遍历漏洞-CVE-2024-38819/ 2025-02-06T08:48:00.000Z 2025-02-06T09:04:31.545Z SpringBoot 2.x 修复 CVE-2024-38819

问题

SpringBoot 2.x 最后一个开源版本 Spring Framework = 5.3.39 ,这个版本存在CVE-2024-38819漏洞，客户比较强硬，这个漏洞还必须要修复

思路

  • 公司联系了Spring Framework官方，推荐是升级的SpringBoot3 ，或者付费使用 Spring Framework 5.3.40 ，Spring Framework官方我们丢给了国内的代理，可是国内的代理一言难尽，还没考虑好如何去对这个事情进行报价，该方案搁置

  • 第二个思路是升级SpringBoot3,做了一些技术预研，这本身是最好的路子，可是我司客户，不可避免的还有用java8的，作为乙方，在政府，军工类项目中话语权很低，如果是国产化采购的服务器，就更难以推动升级jdk为17以上的版本，该思路只适用于部分场景，并且还要考虑到很多历史和定制项目，已经交付了，扫描出了漏洞，就算给升级SpringBoot3这个开发和测试工作量不可估量，暂时搁置。该方案为后面两年的推动目标

  • 公司维护Spring Framework,在GitHub 的 Spring Framework 6.x 版本上，我们可以根据git提交明确的看到官方是如何修复该漏洞，以Spring Framework = 5.3.39 为基础版本，把官方的修改在5.3.39上进行一次相同修改，发出5.3.40版本，如果后续还有类似漏洞我们同样可以参照6.x的修改来维护下去。但是该方案也只能应急，后续还是推动SpringBoot3升级为主线

]]> <h2 id="SpringBoot-2-x-修复-CVE-2024-38819"><a href="#SpringBoot-2-x-修复-CVE-2024-38819" class="headerlink" title="SpringBoot 2.x 修复 CVE-2024-3 SpringCloud下的跨微服务收集和执行 https://blog.luckylxh.top/2025/02/06/SpringCloud下的跨微服务收集和执行/ 2025-02-06T08:13:00.000Z 2025-02-06T08:44:28.272Z 跨微服务的资源收集和执行

需求

当服务为微服务部署模式的时候，一些底层的扩展可能会在不同的微服务上进行扩展，那么我们需要把他们收集到一个服务上，让用户能在任意的微服务上看到全部的扩展资源，如果用户执行了相关资源，应该还能够在对应的微服务上进行执行

思路

基于SpringCloud Feign等技术，在微服务启动时，通过SpringCloud获取其他微服务情况，并进一步获取资源，生成代理类，注入到当前微服务，在调用时，走Feign调用到其他微服务上执行，当前微服务获取返回结果

  • 基于上述方案，我司已经实现了，多语言，计划任务，参数导入导出，多语言等，多种资源的跨微服务收集和执行

核心

  • 开发者

    • 微服务资源收集和执行框架的开发者 （A类开发者）
    • 系统选项框架的的定义者（B类开发者）
    • 系统选项的扩展开发者（C类开发者）

A类开发者

  • 定义微服务收集框架，定义微服务收集和执行的顶级接口A1,实现A1接口的这类资源，会参与微服务收集和执行
  • 其他微服务资源的自动注入，定义@A2注解，被@A2注解标记的列表会自动注入相关的其他微服务资源
  • 当前微服务启动的时候，需要主动去找注册中心询问当前存活的微服务，然后主动收集其资源到本地，并广播出，自己服务已经启动，让其他微服务来收集自己的资源
  • … 还有一些细节

B类开发者

  • 定义系统选项的顶级接口，以及前/后端页面的开发
  • 定义了系统选项扩展的顶级接口B1

  • 根据A类开发者的接口，进行实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //定义该接口，需要支持远端收集特性
    @Component
    public class ****** implements A1 {

        public String getClassName() {
            return B1.class.getName();
        }

        public String getTitle() {
            return "系统选项接口";
        }
    }

  • 获取系统选项列表的地方要多写上注解@A2

    1
    2
    3
    @Autowired //收集本服务内的实例
    @A2 //收集其他微服务的实例
    private List<B1> services;

C类开发者

  • 基于B类开发的文档进行系统选项开发

优缺点

  • 微服务可以随意打包，在任意一个微服务上，都可以看到完整的系统选项列表
  • 缺点是依赖注册中心，在收集和执行的阶段，使用feign调用，需要注册中心提供具体的微服务实例

相关注意事项

  • A类开发者，要定义全局的feign请求头，来解决跨微服务的情况下，认证的问题，用户信息需要传递下去
  • A类开发者，要处理好，微服务的启动和下线，去处理好当前Spring环境中注入的Feign代理类
  • B类开发者定义的顶级类必须是接口，java的动态代理，只能代理接口
  • B类开发者，定义的顶级接口，上不要有链式调用，每个方法的参数和返回结果都要可序列化
  • B类开发者，要注意，你收集到的List并不是一成不变的，会随着其他微服务的启动和下线，动态的变化
]]> <h2 id="跨微服务的资源收集和执行"><a href="#跨微服务的资源收集和执行" class="headerlink" title="跨微服务的资源收集和执行"></a>跨微服务的资源收集和执行</h2><h3 id="需求"><a href="#需求" class="headerlink" title="需求"></a>需求</h3><p>当服务为微服务部署模式的时候，一些底层的扩展可能会在不同的微服务上进行扩展，那么我们需要把他们收集到一个服务上，让用户能在任意的微服务上看到全部的扩展资源，如果用户执行了相关资源，应该还能够在对应的微服务上进行执行</p> <h3 id="思路"><a href="#思路" class="headerlink" title="思路"></a>思路</h3><p>基于SpringCloud Feign等技术，在微服务启动时，通过SpringCloud获取其他微服务情况，并进一步获取资源，生成代理类，注入到当前微服务，在调用时，走Feign调用到其他微服务上执行，当前微服务获取返回结果</p> <ul> <li>基于上述方案，我司已经实现了，多语言，计划任务，参数导入导出，多语言等，多种资源的跨微服务收集和执行</li> </ul> Linux 对java进程分析 https://blog.luckylxh.top/2023/12/22/Linux-打线程dump/ 2023-12-22T01:54:00.000Z 2024-10-09T08:08:48.922Z Linux 下 对java进程分析

JDK8

Linux

留存线程

  • jstack主要用来查看某个Java进程内的线程堆栈信息
  • 打一次线程dump
  • jstack pid > t.txt
  • 每间隔5秒打三次线程dump

  • for i in {1..3};do jstack -l pid >> $ip_$(date +%Y%m%d_%T).txt;i+=1;sleep 5;done

  • 查看当前进程里面的线程情况top -H -p pid

upload successful

  • 文件可以使用 java -jar jca4614.jar进行查看

留存内存对象

  • jmap导出堆内存
  • jmap -dump:live,format=b,file=dump.hprof pid

  • 导出的文件可以用Jprofiler或者jvisualvm进行分析

  • 查看占用内存最大的对象前100jmap -histo pid|head -100

留存gc

  • 在线上看gc是否频繁和耗时
  • jstat -gcutil ${pid} 1000 每隔一秒打印一次GC

upload successful

可以看到，单次 Young GC 平均耗时是 60ms 左右，还是不错的，但是Young GC（YGC ）非常频繁，基本上每秒一次，有时还会一秒两次，在一秒两次的时候，Young GC对系统响应的压力就会比较明显。

jstat相关指标说明：

  • YGCT：Young GC 总时间，单位为秒
  • YGC：Young GC 次数
  • FGCT：Full GC 总时间，单位为秒
  • FGC：Full GC 次数

  • GCT：GC 总时间，是 YGCT 和 FGCT 之和
    接着查看 GC log，打印 GC log 需要在 JVM 启动参数里添加如下参数：

  • -XX:+PrintGCDateStamps：打印 GC 发生的时间戳。

  • -XX:+PrintTenuringDistribution：打印 GC 发生时的代龄信息。
  • -XX:+PrintGCApplicationStoppedTime：打印 GC 停顿时长
  • -XX:+PrintGCApplicationConcurrentTime：打印 GC 间隔的服务运行时长
  • -XX:+PrintGCDetails：打印 GC 详情，包括 GC 前/内存等。
  • -Xloggc:../gclogs/gc.log.date：指定 GC log 的路径

upload successful

]]> <h2 id="Linux-下-对java进程分析"><a href="#Linux-下-对java进程分析" class="headerlink" title="Linux 下 对java进程分析"></a>Linux 下 对java进程分析</h2><blockquote> <p>JDK8</p> <p>Linux</p> </blockquote> SpringBoot对接Redis高可用集群 https://blog.luckylxh.top/2022/08/22/SpringBoot对接Redis高可用集群/ 2022-08-22T03:04:00.000Z 2022-08-22T03:06:31.019Z SpringBoot对接高可用Redis的情况和配置方式

Redis 高可用分两个方式：主从哨兵模式或者Cluster集群

SpringBoot 版本 2.6.8

主从哨兵模式

常见的部署是一主二从三哨兵模式，一个redis节点主节点，承担写+读的责任。两个redis节点，作为只读节点，不承担写入责任，三个redis节点，通过特殊的启动模式，作为监控节点，监控主节点的实例状态。

特性：高可用、部分高并发，主从节点数据完全一致

缺点：高并发特性不明显

优点：支持性好，可无缝衔接具体项目，完美支持lua脚本

Spring Boot对接

1
2
3
4
5
6
7
8
#主节点的名称
spring.redis.sentinel.master=mymaster
# 三个哨兵的地址
spring.redis.sentinel.nodes=127.0.0.1:26663,127.0.0.1:26662,127.0.0.1:26661
# 哨兵如果有密码，配置哨兵密码
spring.redis.sentinel.password=redis
# 主节点的密码
spring.redis.password=redis

Cluster集群

常见的部署是三主三从，三个redis节点，作为主节点，承担写+读的责任。三个redis节点，从节点提供数据读能力，不承担写入责任。Cluster集群式无中心的架构，六者之间相互监控，当有主节点实例状态出问题，从节点自动顶上

特性：高可用、高并发，数据分片，三个主节点数据不一致

优点：高并发

缺点：数据分片，导致原生不支持mset,mget，pipeline等批量操作,部分支持lua脚本

Spring Boot对接

  • 对接尽量使用lettuce,不要使用jedis

    • cluster集群原生不支持批量操作

    • lettuce和jedis都对其进行二次封装，能在cluster集群中使用mset,mget

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      mset mget
      //redis.clients.jedis.JedisCluster 2013
        @Override
        public String mset(final String... keysvalues) {
          String[] keys = new String[keysvalues.length / 2];

          for (int keyIdx = 0; keyIdx < keys.length; keyIdx++) {
            keys[keyIdx] = keysvalues[keyIdx * 2];
          }

          return new JedisClusterCommand<String>(connectionHandler, maxAttempts, maxTotalRetriesDuration) {
            @Override
            public String execute(Jedis connection) {
              return connection.mset(keysvalues);
            }
          }.run(keys.length, keys);
        }
      // io.lettuce.core.cluster.RedisAdvancedClusterAsyncCommandsImpl<K, V> 350 

          @Override
          public RedisFuture<String> mset(Map<K, V> map) {

              Map<Integer, List<K>> partitioned = SlotHash.partition(codec, map.keySet());

              if (partitioned.size() < 2) {
                  return super.mset(map);
              }

              Map<Integer, RedisFuture<String>> executions = new HashMap<>();

              for (Map.Entry<Integer, List<K>> entry : partitioned.entrySet()) {

                  Map<K, V> op = new HashMap<>();
                  entry.getValue().forEach(k -> op.put(k, map.get(k)));

                  RedisFuture<String> mset = super.mset(op);
                  executions.put(entry.getKey(), mset);
              }

              return MultiNodeExecution.firstOfAsync(executions);
          }

  • lettuce还支持pipeline,jedis不支持，会直接抛出异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // pipeline 
    // org.springframework.data.redis.connection.lettuce.LettuceConnection  490
    @Override
    public void openPipeline() {

    if (!isPipelined) {
    isPipelined = true;
    ppline = new ArrayList<>();
    flushState = this.pipeliningFlushPolicy.newPipeline();
    flushState.onOpen(this.getOrCreateDedicatedConnection());
    }
    }
    // org.springframework.data.redis.connection.jedis.JedisClusterConnection  849

    @Override
    public void openPipeline() {
    throw new UnsupportedOperationException("Pipeline is currently not supported for JedisClusterConnection.");
    }
  • lua脚本,如果不是批量操作，或者此次批量操作涉及的key能分片到同一台redis上，可以执行
1
2
3
4
5
6
7
8
9
10
#六个节点的地址
spring.redis.cluster.nodes=127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005,127.0.0.1:7006
#拓扑动态感应即客户端能够根据 redis cluster 集群的变化，动态改变客户端的节点情况，完成故障转移。
spring.redis.lettuce.cluster.refresh.adaptive=true
#集群拓扑刷新周期 单位毫秒
spring.redis.lettuce.cluster.refresh.period=10000  
#是否发现和查询所有群集节点以获取群集拓扑。设置为false时，仅将初始种子节点用作拓扑发现的源
spring.redis.lettuce.cluster.refresh.dynamic-refresh-sources=true
# 节点的密码
spring.redis.password=redis
]]> <h2 id="SpringBoot对接高可用Redis的情况和配置方式"><a href="#SpringBoot对接高可用Redis的情况和配置方式" class="headerlink" title="SpringBoot对接高可用Redis的情况和配置方式"></a>SpringBoot对接高可用Redis的情况和配置方式</h2><blockquote> <p>Redis 高可用分两个方式：主从哨兵模式或者Cluster集群</p> <p>SpringBoot 版本 <code>2.6.8</code></p> </blockquote> SpringBoot 对接redis哨兵集群 https://blog.luckylxh.top/2022/08/19/SpringBoot-对接redis哨兵集群/ 2022-08-19T06:46:00.000Z 2022-08-19T08:37:58.415Z Redis哨兵集群

使用Redis哨兵集群，主要是为了高可用，这次部署是，一主，二从，三哨兵。主可写可读，从可读，哨兵不提供读写服务，只是监控

一主

  • 主要配置密码,端口，和可访问的ip
1
2
3
4
5
6
7
8
#任何ip
bind 0.0.0.0
#端口 6666
port 6666
#作为主节点的密码 是 redis
masterauth redis
#密码 redis
requirepass redis

upload successful

二从

  • ip，只读，主信息等
1
2
3
4
5
6
7
8
9
10
11
12
13
bind 0.0.0.0
port 6664
#port 6665
#主节点的ip和端口
slaveof host.docker.internal 6666
# 从节点只读 当被选取为主节点是这个是停止的
slave-read-only yes
# 从节点在处于快照同步期间是否对外提供服务
slave-serve-stale-data yes
# master的认证口令
masterauth redis
# 密码
requirepass redis

upload successful

三哨兵

  • ip，主信息，选举等
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
bind 0.0.0.0
port 26661
# port 26661 port 26662 port 26663
#开启域名解析
sentinel resolve-hostnames yes
#保留域名（程序可以获取到域名）
sentinel announce-hostnames yes
# 主服务信息 ip 端口 以及几个哨兵认为主服务挂了
sentinel monitor mymaster host.docker.internal 6666 2
# 主 密码
sentinel auth-pass mymaster redis
sentinel down-after-milliseconds mymaster 15000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 80000
#密码
requirepass redis

upload successful

docker-compose启动

  • 结合docker 启动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
version: "3"
services:  
  masterRedis:
    container_name: "masterRedis"
    image: redis
    restart: always
    ports:
      - 6666:6666
    volumes:
      - "D:\\env\\study\\redis\\master-6666\\redis.conf:/etc/redis/redis.conf" 
    command: redis-server /etc/redis/redis.conf
    extra_hosts:
      - "host.docker.internal:host-gateway"
    #network_mode: host
  slave:
    container_name: "slave"
    image: redis
    restart: always
    ports:
      - 6665:6665
    volumes:
      - "D:\\env\\study\\redis\\slave-6665\\redis-6665.conf:/etc/redis/redis.conf" 
    command: redis-server /etc/redis/redis.conf
    depends_on:
      - masterRedis
    extra_hosts:
      - "host.docker.internal:host-gateway"
  slave2:
    container_name: "slave2"
    image: redis
    restart: always
    ports:
      - 6664:6664
    volumes:
      - "D:\\env\\study\\redis\\slave-6664\\redis-6664.conf:/etc/redis/redis.conf" 
    command: redis-server /etc/redis/redis.conf
    depends_on:
      - masterRedis
    extra_hosts:
      - "host.docker.internal:host-gateway"
  sentinel:
    container_name: "sentinel"
    image: redis
    restart: always
    ports:
      - 26663:26663
    volumes:
      - "D:\\env\\study\\redis\\sentinel-26663\\sentinel-26663.conf:/etc/redis/redis.conf" 
    command: redis-server /etc/redis/redis.conf --sentinel
    depends_on:
      - masterRedis
      - slave
      - slave2
    extra_hosts:
      - "host.docker.internal:host-gateway"
  sentinel2:
    container_name: "sentinel2"
    image: redis
    restart: always
    ports:
      - 26662:26662
    volumes:
      - "D:\\env\\study\\redis\\sentinel-26662\\sentinel-26662.conf:/etc/redis/redis.conf" 
    command: redis-server /etc/redis/redis.conf --sentinel
    depends_on:
      - masterRedis
      - slave
      - slave2
    extra_hosts:
      - "host.docker.internal:host-gateway"
  sentinel3:
    container_name: "sentinel3"
    image: redis
    restart: always
    ports:
      - 26661:26661
    volumes:
      - "D:\\env\\study\\redis\\sentinel-26661\\sentinel-26661.conf:/etc/redis/redis.conf" 
    command: redis-server /etc/redis/redis.conf --sentinel
    #networks:
    #  extnetwork:
    #    ipv4_address: 10.2.21.6
    depends_on:
      - masterRedis
      - slave
      - slave2
    extra_hosts:
      - "host.docker.internal:host-gateway"
#networks:
#   extnetwork:
#      driver: bridge
#      ipam:
#        config:
#          - subnet: 10.2.21.0/16

SpringBoot介入

  • 配置文件
1
2
3
4
5
6
7
8
#主节点的名称
spring.redis.sentinel.master=mymaster
# 三个哨兵的地址
spring.redis.sentinel.nodes=127.0.0.1:26663,127.0.0.1:26662,127.0.0.1:26661
# 哨兵如果有密码，配置哨兵密码
spring.redis.sentinel.password=redis
# 主节点的密码
spring.redis.password=redis
  • 一些坑
  • docker 部署的服务，给程序返回的主节点ip是虚拟ip,所以我这里用了域名，防止给程序一个根本连接不上的地址
  • 为什么我用了docker,我还是要我本地的端口和容器端口一致，也是为了，如果主节点挂掉，哨兵给的从节点地址和端口，我spring程序是宿主机上的服务，想要连接上，尽量保证一致（虽然没什么卵用，因为主关了，哨兵给程序的新的redis的ip是 docker的内网地址）
  • 哨兵上配置主的时候，竟然默认不支持域名的解析，需要增加如下两个配置
    1
    2
    3
    4
    #开启域名解析
    sentinel resolve-hostnames yes
    #保留域名（程序可以获取到域名）
    sentinel announce-hostnames yes
]]> <h2 id="Redis哨兵集群"><a href="#Redis哨兵集群" class="headerlink" title="Redis哨兵集群"></a>Redis哨兵集群</h2><p>使用Redis哨兵集群，主要是为了高可用，这次部署是，一主，二从，三哨兵。主可写可读，从可读，哨兵不提供读写服务，只是监控</p> 统一认证中心的一些思考 https://blog.luckylxh.top/2022/03/28/统一认证中心的一些思考/ 2022-03-28T08:25:23.000Z 2022-08-19T06:42:53.375Z 简介

统一认证中心，常见的有CAS、oAuth2等认证中心，主要解决，多个异构系统页面单点

]]> <h4 id="简介"><a href="#简介" class="headerlink" title="简介"></a>简介</h4><p>统一认证中心，常见的有CAS、oAuth2等认证中心，主要解决，多个异构系统页面单点</p> Excel分组的存储结构浅析 https://blog.luckylxh.top/2021/06/22/Excel分组的存储结构浅析/ 2021-06-22T04:12:00.000Z 2021-06-22T04:19:13.472Z WPS 中Excel 创建组数据存储分析

在工作中常遇到长篇幅的数据报表。

将表格数据分组显示可以更加直观的让我们观察数据、整理数据。

upload successful

如上图所示,探究下其文件存储格式

行分组

  • 行方向的分组

两个行分组

  • 两个行分组 直接必须至少空一行,否则会变成一个行分组

upload successful

  • 数据结构 sheet1.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
    <sheetPr/>
    <dimension ref="A1:A8"/>
    <sheetViews>
        <sheetView tabSelected="1" workbookViewId="0">
            <selection activeCell="A5" sqref="A5:A8"/>
        </sheetView>
    </sheetViews>
    <sheetFormatPr defaultColWidth="9" defaultRowHeight="14.25" outlineLevelRow="7"/>
    <sheetData>
        // row 上带有了 outlineLevel 代表是行分组 值 是1 代表了是1层级
        //层级代表了是否有嵌套,可以见 行分组嵌套
        <row r="1" outlineLevel="1" spans="1:1">
            <c r="A1">
                <v>1</v>
            </c>
        </row>
        <row r="2" outlineLevel="1" spans="1:1">
            <c r="A2">
                <v>2</v>
            </c>
        </row>
        <row r="3" outlineLevel="1" spans="1:1">
            <c r="A3">
                <v>3</v>
            </c>
        </row>
        // 第4行没有 所以 页面上 是两个行分组 如果第4行也有 应该会变成一个行分组
        <row r="4" spans="1:1">
            <c r="A4">
                <v>4</v>
            </c>
        </row>
        <row r="5" outlineLevel="1" spans="1:1">
            <c r="A5">
                <v>5</v>
            </c>
        </row>
        <row r="6" outlineLevel="1" spans="1:1">
            <c r="A6">
                <v>6</v>
            </c>
        </row>
        <row r="7" outlineLevel="1" spans="1:1">
            <c r="A7">
                <v>7</v>
            </c>
        </row>
        <row r="8" outlineLevel="1" spans="1:1">
            <c r="A8">
                <v>8</v>
            </c>
        </row>
    </sheetData>
    <pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>
    <headerFooter/>
</worksheet>

行分组嵌套

  • 一个行分组中包括了另一个行分组

upload successful

  • 数据结构 sheet1.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
    <sheetPr/>
    <dimension ref="A1:A9"/>
    <sheetViews>
        <sheetView tabSelected="1" workbookViewId="0">
            <selection activeCell="A3" sqref="A3:A4"/>
        </sheetView>
    </sheetViews>
    <sheetFormatPr defaultColWidth="9" defaultRowHeight="14.25"/>
    <sheetData>
        <row r="1" outlineLevel="1" spans="1:1">
            <c r="A1">
                <v>1</v>
            </c>
        </row>
        <row r="2" outlineLevel="1" spans="1:1">
            <c r="A2">
                <v>2</v>
            </c>
        </row>
        // outlineLevel 层级为 2  嵌入到了 为1的层级
        <row r="3" outlineLevel="2" spans="1:1">
            <c r="A3">
                <v>3</v>
            </c>
        </row>
        <row r="4" outlineLevel="2" spans="1:1">
            <c r="A4">
                <v>4</v>
            </c>
        </row>
        <row r="5" outlineLevel="1" spans="1:1">
            <c r="A5">
                <v>5</v>
            </c>
        </row>
        <row r="6" outlineLevel="1" spans="1:1">
            <c r="A6">
                <v>6</v>
            </c>
        </row>
        <row r="7" outlineLevel="1" spans="1:1">
            <c r="A7">
                <v>7</v>
            </c>
        </row>
        <row r="8" spans="1:1">
            <c r="A8">
                <v>8</v>
            </c>
        </row>
        <row r="9" spans="1:1">
            <c r="A9">
                <v>9</v>
            </c>
        </row>
    </sheetData>
    <pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>
    <headerFooter/>
</worksheet>

列分组

  • 列方向的分组

两个列分组

  • 两个列方向的分组 分组直接至少空一列 否则会变成一个列分组

upload successful

  • 数据结构 sheet1.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
    <sheetPr/>
    <dimension ref="A1:G1"/>
    <sheetViews>
        <sheetView tabSelected="1" workbookViewId="0">
            <selection activeCell="E1" sqref="E1:G1"/>
        </sheetView>
    </sheetViews>
    <sheetFormatPr defaultColWidth="9" defaultRowHeight="14.25" outlineLevelCol="6"/>
    <cols>
        //这里记录 列方向的 分组信息
        <col min="1" max="3" width="9" outlineLevel="1"/>
        <col min="5" max="7" width="9" outlineLevel="1"/>
    </cols>
    <sheetData>
        <row r="1" spans="1:7">
            <c r="A1">
                <v>1</v>
            </c>
            <c r="B1">
                <v>2</v>
            </c>
            <c r="C1">
                <v>3</v>
            </c>
            <c r="D1">
                <v>4</v>
            </c>
            <c r="E1">
                <v>5</v>
            </c>
            <c r="F1">
                <v>6</v>
            </c>
            <c r="G1">
                <v>7</v>
            </c>
        </row>
    </sheetData>
    <pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>
    <headerFooter/>
</worksheet>

列分组嵌套

  • 一个列分组中包括另一个列分组

upload successful

  • 数据结构 sheet1.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
    <sheetPr/>
    <dimension ref="A1:I1"/>
    <sheetViews>
        <sheetView tabSelected="1" workbookViewId="0">
            <selection activeCell="B1" sqref="B1:D1"/>
        </sheetView>
    </sheetViews>
    <sheetFormatPr defaultColWidth="9" defaultRowHeight="14.25"/>
    <cols>
        // 同样逻辑 通过outlineLevel 层级描述嵌套
        <col min="1" max="1" width="9" outlineLevel="1"/>
        <col min="2" max="4" width="9" outlineLevel="2"/>
        <col min="5" max="8" width="9" outlineLevel="1"/>
    </cols>
    <sheetData>
        <row r="1" spans="1:9">
            <c r="A1">
                <v>1</v>
            </c>
            <c r="B1">
                <v>2</v>
            </c>
            <c r="C1">
                <v>3</v>
            </c>
            <c r="D1">
                <v>4</v>
            </c>
            <c r="E1">
                <v>5</v>
            </c>
            <c r="F1">
                <v>6</v>
            </c>
            <c r="G1">
                <v>7</v>
            </c>
            <c r="H1">
                <v>8</v>
            </c>
            <c r="I1">
                <v>9</v>
            </c>
        </row>
    </sheetData>
    <pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>
    <headerFooter/>
</worksheet>
]]> <h2 id="WPS-中Excel-创建组数据存储分析"><a href="#WPS-中Excel-创建组数据存储分析" class="headerlink" title="WPS 中Excel 创建组数据存储分析"></a>WPS 中Excel 创建组数据存储分析</h2><p>在工作中常遇到长篇幅的数据报表。</p> <p>将表格数据分组显示可以更加直观的让我们观察数据、整理数据。</p> <p><img src="/images/pasted-69.png" alt="upload successful"></p> <p>如上图所示,探究下其文件存储格式</p> web版的单机版构建 https://blog.luckylxh.top/2020/09/23/web版的单机版构建/ 2020-09-23T03:19:00.000Z 2020-09-23T04:10:00.481Z 需求

把一个成熟的Web版本程序 做成单机版(桌面)程序,应对不同的客户环境

思路

正常的 Web项目 一般由几个模块组成

  • 数据库服务
  • 后台服务
  • 前台服务

  • redis等中间件

    后台服务和前台服务 在 War包部署中可以合二为一 redis等中间件 如果是为了单机版部署也是可以优化掉的.所以我们在单机版部署中 必须的模块就剩下 这几个了

  • 业务服务
  • 数据库服务
  • 桌面程序服务

ps: 当然数据库服务这里默认是一个单机版自带一个数据库服务,应对客户场景保密 不通外网的情况 如果客户服务可以通外网,也允许数据库服务外联,我们就可以 把数据库服务给去掉 ,这里分析 单机版自带数据库服务的情况

方案

  • 业务服务(包含数据库,不包括前台代码) => jar方式打一个可执行jar包,h2文件模式内嵌数据库
  • 桌面程序服务(electron 包括前台代码) =>做桌面应用程序

启动 步骤如下

  • 用户点击 demo.exe文件 electron服务启动(前台服务启动),页面展示启动中
  • 逻辑代码 用命令行启动 单机版内包含的可执行 jar文件 拉起业务服务
  • 前台和后台约定好一个接口代表业务服务启动成功,前台代码 以一定的频率调用接口,查询后台服务启动的情况(推荐后台使用:spring-boot-starter-actuator做生命周期管理)
  • 前台服务得知后台启动成功,进入业务页面.整体服务启动成功

关闭步骤如下

  • 用户点击退出或者❌号
  • electron服务(前台服务)监听到,给后台发送退出请求(spring-boot-starter-actuator 有提供退出接口)
  • electron服务 退出
]]> <h4 id="需求"><a href="#需求" class="headerlink" title="需求"></a>需求</h4><p> 把一个成熟的Web版本程序 做成单机版(桌面)程序,应对不同的客户环境</p> Electron 学习 https://blog.luckylxh.top/2020/09/23/Electron-学习/ 2020-09-23T03:01:00.000Z 2020-09-23T04:09:04.135Z 简介

electron 是基于 nodejs的一个封装了一个谷歌的浏览器内核,让我们写js代码就可以开发出来一个桌面应用,适合web项目 封装单机版.

npm 依赖

直接加入

1
"electron": "^9.2.0",

就直接吧 electron依赖进来了
main.js是 electron默认的入口文件 在里面我们就可以开始我们的开发了,可以参照官方文档

启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 {
  "name": "electron-demo",
  "version": "1.0.0",
  "description": "",
  "main": "main.js",//默认的入口文件
  "scripts": {
    "start": "electron ." //启动命令
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "electron": "^9.2.0"
  }
}

打包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 {
  "name": "electron-demo",
  "version": "1.0.0",
  "description": "",
  "main": "main.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "electron .",
    "package": "electron-packager ./ --out dist --overwrite --icon=icon/window.ico", // electron-packager 是一种打包方式 
    "pack": "electron-builder --dir --win --x64", // electron-builder是另外一种打包方式
    "dist": "electron-builder"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "electron": "^9.2.0",
    "electron-builder": "^22.8.0",
    "electron-packager": "^15.0.0"
  },
  "build": { //electron-builder 配合使用 可以更改 win上的 打包exe的图标
    "productName": "blog",
    "appId": "blog.luckylxh.top",
    "win": {
      "icon": "icon/favicon.ico"
    }
  }
}

打包后的样式如下

upload successful

双击 exe就可以运行!

]]> <h4 id="简介"><a href="#简介" class="headerlink" title="简介"></a>简介</h4><p><a href="https://www.electronjs.org" target="_blank" rel="noopener">electron</a> 是基于 nodejs的一个封装了一个谷歌的浏览器内核,让我们写js代码就可以开发出来一个桌面应用,适合web项目 封装单机版.</p> Spring Boot H2嵌入式整合 https://blog.luckylxh.top/2020/08/11/Spring-Boot-H2嵌入式整合/ 2020-08-11T01:32:00.000Z 2020-09-23T04:08:15.073Z Spring Boot H2 嵌入模式整合

需求

我们已经有一个成熟的WEB报表产品结构了,是BS架构.

但是在业务场景上,部分定制项目或者说产品需要做单机版.给用户安装的单机版不适合大家统一使用一个远程的数据库服务,我们不得不去研究嵌入式数据库到我们的项目中,让我们的单机版自身带有数据库服务.

H2使用场景

H2 是一个用 Java 开发的嵌入式数据库，它本身只是一个类库，即只有一个 jar 文件，可以直接嵌入到应用项目中。H2 主要有如下三个用途：

  • 也是最常使用的用途就在于可以同应用程序打包在一起发布，这样可以非常方便地存储少量结构化数据(嵌入模式)。
  • 用于单元测试。启动速度快，而且可以关闭持久化功能，每一个用例执行完随即还原到初始状态(内存模式)。
  • 作为缓存，即当做内存数据库，作为NoSQL的一个补充。当某些场景下数据模型必须为关系型，可以拿它当Memcached使，作为后端MySQL/Oracle的一个缓冲层，缓存一些不经常变化但需要频繁访问的数据，比如字典表、权限表(内存模式)

H2启动模式

  • 内存模式:数据无法持久化 jdbc:h2:mem:***
  • 嵌入模式:jar包直接跟随后台服务,数据持久化到文件系统 jdbc:h2:file:***
  • 服务模式:当成远程的数据库服务,提供给应用程序 jdbc:h2:tcp:***

嵌入模式整合

  • Spring Boot 与 H2 整合十分的简单,直接引用 com.h2database:h2 版本号使用 Spring Boot提供的就可以

  • 注意事项;

    • 1
      H2 数据库报错 Database "XXX" not found, and IFEXISTS=true, so we cant auto-create it [90146] 的解决办法

    • 以前的h2数据库当没有数据库的时候,会自动创建一个空的数据库,但是在2019年的版本后,禁止了这项功能,所以如果你对这个功能不在意可以使用 下面的老版本依赖,会自动创建数据库

    • 1
      2
      3
      4
      5
      <dependency>
              <groupId>com.h2database</groupId>
              <artifactId>h2</artifactId>
              <version>1.4.193</version>
      </dependency>

    • 另外一种解决方法就是,版本号还是使用 Spring Boot提供的h2默认版本号,在配置文件中修改如下

    • 1
      spring.datasource.url=jdbc:h2:file:./h2/data2;IFEXISTS=FALSE;

    • 注意:只这样写还是无法自动创建数据库,我们需要手动根据这个地址在启动成功后,手动连接一次数据库

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      @SpringBootApplication
      public class DesktipApplication {
      public static final Logger LOGGER = LoggerFactory.getLogger(DesktipApplication.class);


      public static void main(String[] args) throws SQLException {
      ConfigurableApplicationContext run = SpringApplication.run(DesktipApplication.class, args);
      String url = run.getEnvironment().getProperty("spring.datasource.url");
      String username = run.getEnvironment().getProperty("spring.datasource.username");
      String password = run.getEnvironment().getProperty("spring.datasource.password");
      //h2 新版本的已经 不能直接创建空的数据库,尝试根据 jdbc链接一次,创建数据库
      Connection connection = DriverManager.getConnection(url, username, password);
      connection.close();
      LOGGER.info("启动成功");

      }
      }

    • 常用的配置信息

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      ##h2数据库 IFEXISTS=FALSE 没有数据库的时候自动创建 AUTO_SERVER=TRUE 混合模式
      spring.datasource.driver-class-name=org.h2.Driver
      #jdbc:h2:file:{path} path可以写绝对路径 也可以写相对路径 ~代表当前用户目录 .代表当前目录
      spring.datasource.url=jdbc:h2:file:./h2/data2;IFEXISTS=FALSE;AUTO_SERVER=TRUE
      spring.datasource.username=sa
      spring.datasource.password=
      #开启console 可以通过浏览器访问数据库页面
      spring.h2.console.enabled=true
      #开启h2 console 跟踪 方便调试  默认 false
      spring.h2.console.settings.trace=false
      #允许console 远程访问 默认false
      spring.h2.console.settings.web-allow-others=true
      #  h2 访问路径上下文 默认为 h2-console
      spring.h2.console.path=/h2-console
]]> <h3 id="Spring-Boot-H2-嵌入模式整合"><a href="#Spring-Boot-H2-嵌入模式整合" class="headerlink" title="Spring Boot H2 嵌入模式整合"></a>Spring Boot H2 嵌入模式整合</h3><h4 id="需求"><a href="#需求" class="headerlink" title="需求"></a>需求</h4><p>我们已经有一个成熟的WEB报表产品结构了,是BS架构.</p> <p>但是在业务场景上,部分定制项目或者说产品需要做单机版.给用户安装的单机版不适合大家统一使用一个远程的数据库服务,我们不得不去研究嵌入式数据库到我们的项目中,让我们的单机版自身带有数据库服务.</p> Spring Cloud 和 Spring Cloud Alibaba https://blog.luckylxh.top/2020/04/28/Spring-Cloud-和-Spring-Cloud-Alibaba/ 2020-04-28T02:19:00.000Z 2020-09-23T04:07:37.538Z 最近开始研究 Spring Cloud 和 Spring Cloud Alibaba,记录下自己对Spring Boot 和上方两个他们的关系和理解。

Spring Boot 是基于 Sping 的一套快速构建的的脚手架，让开发人员可以快速的构建一个简单的web项目。

然后随着时间的发展分布式和微服务因为各种优势，进入了各个大佬的眼中，所以Spring Cloud就应用而生了，他专注于因为分布式和微服务，所引入的新问题，比如，网关，服务治理，注册中心等等，定下了一套完整的解决方案，并且这套解决方案有着很好的抽象，方便第三方服务的替代。

但是随着 Spring Cloud下的多个服务停止支持各个服务的维护和更新，Spring Cloud Alibaba站了出来，他基于 Spring Cloud 很好的抽象标准 用自己的公司下开发的服务，开始逐步替换 Spring Cloud下原本的服务。所以简单来说是 Spring Cloud 提供接口 Spring Cloud Alibaba 是其中的一个实现。 并且 阿里大厂的实力，国内开发人员还是十分信任的，所以现在Spring Cloud Alibaba 也就越来越火了。

]]> <p>最近开始研究 <code>Spring Cloud</code> 和 <code>Spring Cloud Alibaba</code>,记录下自己对<code>Spring Boot</code> 和上方两个他们的关系和理解。</p> <p><code>Spring Bo Excel 条件格式存储结构浅析 https://blog.luckylxh.top/2020/03/04/Excel-条件格式存储结构浅析/ 2020-03-04T06:10:00.000Z 2020-09-23T04:06:54.034Z Excel条件格式
  • 在Excel表格中进行数据分析时，您可能需要通过一些特征条件来找到特定的数据，还可能需要用更直观的方法来展现数据规律。

手写公式的条件格式

需求

  • 原始数据如下

upload successful

  • 要求
    • 公司将进行一次内部晋升，需要将年龄为30岁以下的所有“研究员” 用蓝色背景标识出来
    • 公司将进行一次内部晋升，需要将年龄为25岁以下的所有“研究员” 用红色背景色标识出来
    • 公司将进行一次内部晋升，需要将年龄为20岁以下的所有“研究员” 用下划线 标识出来（探讨 如果为真则停止 这个勾选框）

效果

  • 一个条件

upload successful

  • 二个样式冲突的条件

upload successful

  • 样式不冲突的条件

upload successful

  • 如果为真则停止

upload successful

做了几个效果图方便理解 Excel中条件格式的各种行为和设置，下面我们看存储结构吧

存储

  • sheet.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet
    xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
    xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
    xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
    xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
    <sheetPr/>
    <dimension ref="A1:F33"/>
    <sheetViews>
        <sheetView tabSelected="1" workbookViewId="0">
            <selection activeCell="A2" sqref="A2"/>
        </sheetView>
    </sheetViews>
    <sheetFormatPr defaultColWidth="9" defaultRowHeight="13.5" outlineLevelCol="5"/>
    <cols>
        <col min="5" max="5" width="28.25" customWidth="1"/>
        <col min="6" max="6" width="48.75" customWidth="1"/>
    </cols>
    <sheetData>
        *****
    </sheetData>
    //sqref 应用位置 expression 表达式  formula 公式  priority 优先（越小越优先） stopIfTrue 是否 //为真停止   dxfId 对应 styles.xml中的的 <dxfs /> 下的元素下标
    <conditionalFormatting sqref="A2:D13">
        <cfRule type="expression" dxfId="0" priority="5">
            <formula>($C2=&quot;研究员&quot;)*($D2&lt;30)</formula>
        </cfRule>
        <cfRule type="expression" dxfId="1" priority="4">
            <formula>($C2=&quot;研究员&quot;)*($D2&lt;25)</formula>
        </cfRule>
        <cfRule type="expression" dxfId="2" priority="1" stopIfTrue="1">
            <formula>($C2=&quot;研究员&quot;)*($D2&lt;20)</formula>
        </cfRule>
    </conditionalFormatting>
    <pageMargins left="0.75" right="0.75" top="1" bottom="1" header="0.5" footer="0.5"/>
    <headerFooter/>
</worksheet>

  • styles.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <styleSheet
        xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
        <numFmts count="4">
            <numFmt numFmtId="44" formatCode="_ &quot;￥&quot;* #,##0.00_ ;_ &quot;￥&quot;* \-#,##0.00_ ;_ &quot;￥&quot;* &quot;-&quot;??_ ;_ @_ "/>
            <numFmt numFmtId="41" formatCode="_ * #,##0_ ;_ * \-#,##0_ ;_ * &quot;-&quot;_ ;_ @_ "/>
            <numFmt numFmtId="42" formatCode="_ &quot;￥&quot;* #,##0_ ;_ &quot;￥&quot;* \-#,##0_ ;_ &quot;￥&quot;* &quot;-&quot;_ ;_ @_ "/>
            <numFmt numFmtId="43" formatCode="_ * #,##0.00_ ;_ * \-#,##0.00_ ;_ * &quot;-&quot;??_ ;_ @_ "/>
        </numFmts>
        ******
        //条件格式的样式
        <dxfs count="3">
            <dxf>
                <fill>
                    <patternFill patternType="solid">
                        <bgColor rgb="FF00B0F0"/>
                    </patternFill>
                </fill>
            </dxf>
            <dxf>
                <fill>
                    <patternFill patternType="solid">
                        <bgColor rgb="FFFF0000"/>
                    </patternFill>
                </fill>
            </dxf>
            <dxf>
                <font>
                    <strike val="1"/>
                </font>
            </dxf>
        </dxfs>
        <tableStyles count="0" defaultTableStyle="TableStyleMedium2" defaultPivotStyle="PivotStyleLight16"/>
        <extLst>
            <ext uri="{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}"
                xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">
                <x14:slicerStyles defaultSlicerStyle="SlicerStyleLight1"/>
            </ext>
        </extLst>
    </styleSheet>

    上述两个 xml文件 存储结构对应 效果图 还是比较好理解的

Excel自带的条件格式

  • Excel中自己带有的部分简便的条件公式。可以探讨下它的存储结构

upload successful

  • 效果图

upload successful

  • 存储
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet
    xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
    xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
    xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
    xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
    <sheetPr/>
    <dimension ref="A1:G22"/>
    <sheetViews>
        <sheetView workbookViewId="0">
            <selection activeCell="J11" sqref="J11"/>
        </sheetView>
    </sheetViews>
    <sheetFormatPr defaultColWidth="9" defaultRowHeight="13.5" outlineLevelCol="6"/>
    *********
    
    
    // sqref 应用位置 type:dataBar和 colorScale 应该是Excel自己带的两个类型
    <conditionalFormatting sqref="A2:D13">
        <cfRule type="dataBar" priority="2">
            <dataBar>
                <cfvo type="min"/>
                <cfvo type="max"/>
                <color rgb="FF638EC6"/>
            </dataBar>
            <extLst>
                <ext uri="{B025F937-C7B1-47D3-B67F-A62EFF666E3E}"
                    xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">
                    <x14:id>{be709f9a-bb79-4f30-badf-ed91d38783ef}</x14:id>
                </ext>
            </extLst>
        </cfRule>
        <cfRule type="colorScale" priority="1">
            <colorScale>
                <cfvo type="min"/>
                <cfvo type="percentile" val="50"/>
                <cfvo type="max"/>
                <color rgb="FFF8696B"/>
                <color rgb="FFFFEB84"/>
                <color rgb="FF63BE7B"/>
            </colorScale>
        </cfRule>
    </conditionalFormatting>
    <pageMargins left="0.75" right="0.75" top="1" bottom="1" header="0.5" footer="0.5"/>
    <headerFooter/>
    //这里也有一些扩展属性
    <extLst>
        <ext uri="{78C0D931-6437-407d-A8EE-F0AAD7539E65}"
            xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">
            <x14:conditionalFormattings>
                <x14:conditionalFormatting
                    xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main">
                    <x14:cfRule type="dataBar" id="{be709f9a-bb79-4f30-badf-ed91d38783ef}">
                        <x14:dataBar minLength="0" maxLength="100" border="1" negativeBarBorderColorSameAsPositive="0">
                            <x14:cfvo type="autoMin"/>
                            <x14:cfvo type="autoMax"/>
                            <x14:borderColor rgb="FF638EC6"/>
                            <x14:negativeFillColor rgb="FFFF0000"/>
                            <x14:negativeBorderColor rgb="FFFF0000"/>
                            <x14:axisColor rgb="FF000000"/>
                        </x14:dataBar>
                    </x14:cfRule>
                    <xm:sqref>A2:D13</xm:sqref>
                </x14:conditionalFormatting>
            </x14:conditionalFormattings>
        </ext>
    </extLst>
</worksheet>

这里看存储结构，就没有 手写公式那么的清晰明了。涉及到Excel程序的内容就过多了

]]> <h2 id="Excel条件格式"><a href="#Excel条件格式" class="headerlink" title="Excel条件格式"></a>Excel条件格式</h2><ul> <li>在Excel表格中进行数据分析时，您可能需要通过一些特征条件来找到特定的数据，还可能需要用更直观的方法来展现数据规律。</li> </ul> Excel 数据透视表存储结构浅析 https://blog.luckylxh.top/2020/03/04/Excel-数据透视表存储结构浅析/ 2020-03-04T06:05:00.000Z 2020-09-23T04:06:34.832Z Excel 数据透视表
  • 接上篇文章 说下 数据透视表的结构

XML存储结构

  • 先看四个图

  • 图一 Excel 展示样式

upload successful

  • 图二 Excel 展示样式

upload successful

  • 图三 Excel解压后的结构

upload successful

  • 图四 简要描述

upload successful

pivotCache

  • 数据透视表的数据源 可能多种多样，所以 Excel在存储上 对原始数据做了备份处理，这个pivotCache就是存储的备份数据，所以你改变了源数据值，数据透视表不会实时刷新，需要 手动刷新的原因
pivotCacheDefinition1.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<pivotCacheDefinition
    xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
    xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="rId1" createdVersion="5" refreshedVersion="5" minRefreshableVersion="3" refreshedDate="43893.4935185185" refreshedBy="Administrator" recordCount="9">
    //数据源 源数据 来自 我是第二个  的 A4:C13 区域 
    <cacheSource type="worksheet">
        <worksheetSource ref="A4:C13" sheet="我是第二个"/>
    </cacheSource>
    // name  姓名 科目 分数 为源数据3列  
    <cacheFields count="3">
        <cacheField name="姓名" numFmtId="0">
            <sharedItems count="3">
                //<s/> 代表是字符串
                <s v="小李"/>
                <s v="小张"/>
                <s v="小王"/>
            </sharedItems>
        </cacheField>
        <cacheField name="科目" numFmtId="0">
            <sharedItems count="3">
                <s v="数学"/>
                <s v="英语"/>
                <s v="语文"/>
            </sharedItems>
        </cacheField>
        <cacheField name="分数" numFmtId="0">
            <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" minValue="45" maxValue="99" count="9">
                //<n></n> 代表是数值
                <n v="91"/>
                <n v="89"/>
                <n v="78"/>
                <n v="56"/>
                <n v="68"/>
                <n v="69"/>
                <n v="77"/>
                <n v="99"/>
                <n v="45"/>
            </sharedItems>
        </cacheField>
    </cacheFields>
</pivotCacheDefinition>

pivotCacheDefinition1.xml 记录了原有的所有数据，但是还不够，因为 原先在Excel上 数据都是一行一列的，每个分数都可以找到对应的学生和科目，而pivotCacheDefinition1.xml 明显没有满足这个需求

pivotCacheRecords1.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<pivotCacheRecords
    xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
    xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" count="9">
    //  <r/> 代表源数据的一行   <x/> 的下标对应  pivotCacheDefinition1.xml 中 <cacheField/> 在   // <cacheFields/>中的下标，属性元素 v对应的值 是  <sharedItems/> 中 元素的下标 
    <r>
        <x v="0"/> //小李
        <x v="0"/> //数学
        <x v="0"/> //91
    </r>
    <r>
        <x v="1"/>//小张
        <x v="0"/>//数学
        <x v="1"/>//89
    </r>
    <r>
        <x v="2"/>
        <x v="0"/>
        <x v="2"/>
    </r>
    <r>
        <x v="0"/>
        <x v="1"/>
        <x v="3"/>
    </r>
    <r>
        <x v="1"/>
        <x v="1"/>
        <x v="4"/>
    </r>
    <r>
        <x v="2"/>
        <x v="1"/>
        <x v="5"/>
    </r>
    <r>
        <x v="0"/>
        <x v="2"/>
        <x v="6"/>
    </r>
    <r>
        <x v="1"/>
        <x v="2"/>
        <x v="7"/>
    </r>
    <r>
        <x v="2"/>
        <x v="2"/>
        <x v="8"/>
    </r>
</pivotCacheRecords>

pivotCacheRecords1.xml 就把数据串联了起来

pivotTables

  • 记录数据透视表格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
//属性记录 名称，格式，边框，高度等
<pivotTableDefinition
    xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" name="数据透视表1" cacheId="0" autoFormatId="1" applyNumberFormats="0" applyBorderFormats="0" applyFontFormats="0" applyPatternFormats="0" applyAlignmentFormats="0" applyWidthHeightFormats="1" dataCaption="值" updatedVersion="5" minRefreshableVersion="3" createdVersion="5" useAutoFormatting="1" compact="0" indent="0" outline="1" compactData="0" outlineData="1" showDrill="1" multipleFieldFilters="0">
    //数据透视表 展示位置
    <location ref="G4:H8" firstHeaderRow="1" firstDataRow="1" firstDataCol="1"/>
    //三列属性 姓名 科目  分数
    <pivotFields count="3">
        <pivotField axis="axisRow" compact="0" showAll="0">
            <items count="4">
                <item x="0"/>
                <item x="2"/>
                <item x="1"/>
                <item t="default"/>
            </items>
        </pivotField>
        <pivotField compact="0" showAll="0">
            <items count="4">
                <item x="0"/>
                <item x="1"/>
                <item x="2"/>
                <item t="default"/>
            </items>
        </pivotField>
        <pivotField dataField="1" compact="0" showAll="0">
            <items count="10">
                <item x="8"/>
                <item x="3"/>
                <item x="4"/>
                <item x="6"/>
                <item x="2"/>
                <item x="1"/>
                <item x="7"/>
                <item x="0"/>
                <item x="5"/>
                <item t="default"/>
            </items>
        </pivotField>
    </pivotFields>
    //行过滤选择 x= 0  就是上方第一个 姓名
    <rowFields count="1">
        <field x="0"/>
    </rowFields>
    <rowItems count="4">
        <i>
            <x/>
        </i>
        <i>
            <x v="1"/>
        </i>
        <i>
            <x v="2"/>
        </i>
        <i t="grand">
            <x/>
        </i>
    </rowItems>
    <colItems count="1">
        <i/>
    </colItems>
    //值 对应 fld = 2  对应第三个
    <dataFields count="1">
        <dataField name="求和项:分数" fld="2" baseField="0" baseItem="0"/>
    </dataFields>
    <pivotTableStyleInfo name="PivotStyleLight16" showRowHeaders="1" showColHeaders="1" showLastColumn="1"/>
    <extLst>
        <ext uri="{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}"
            xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">
            <x14:pivotTableDefinition hideValuesRow="1"
                xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"/>
            </ext>
        </extLst>
    </pivotTableDefinition>
]]> <h2 id="Excel-数据透视表"><a href="#Excel-数据透视表" class="headerlink" title="Excel 数据透视表"></a>Excel 数据透视表</h2><ul> <li>接上篇文章 说下 数据透视表的结构</li> </ul> Excel存储结构浅析 https://blog.luckylxh.top/2020/03/04/Excel存储结构浅析/ 2020-03-04T04:30:00.000Z 2020-09-23T04:06:15.235Z 背景

  • 最近项目上想要对现在用的表格组件进行底层重构，所以对类似的产品Excel的存储结构上是否有可以借鉴的地方，所以就有了今天的这篇文章。

  • 文章主要探讨Excel数据存储，样式存储，合并单元格信息存储等基础数据的存储，细分Excel解压后的各个文件的职责，和存储结构。

Excel 展示图

upload successful

Excel 结构图

upload successful

  • 需要重点介绍的其实都在 xl文件夹中

upload successful

worksheets/sheet.xml
  • 记录一个sheet页的行、列、单元格、合并等信息
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <worksheet
        xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
        xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
        xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
        xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:etc="http://www.wps.cn/officeDocument/2017/etCustomData">
        <sheetPr/>
        //单元格分布
        <dimension ref="A1:D15"/>
        //打开默认选中单元格
        <sheetViews>
            <sheetView workbookViewId="0">
                <selection activeCell="M7" sqref="M7"/>
            </sheetView>
        </sheetViews>
        //默认的行高 宽高等
        <sheetFormatPr defaultColWidth="9" defaultRowHeight="13.5" outlineLevelCol="3"/>
        //列信息
        <cols>
            <col min="2" max="2" width="19.375" customWidth="1"/>
            <col min="4" max="4" width="18.25" customWidth="1"/>
        </cols>
        //按照行 罗列每个单元格信息
        <sheetData>
            <row r="1" ht="14.25" spans="1:1">
                // t = s 单表 共享字符串 shareStrings.xml，<v> 中是存放的下标
                <c r="A1" t="s">
                    <v>15</v>
                </c>
            </row>
            <row r="2" ht="14.25" spans="2:2">
            // s = 4  是单元格的样式 存放到 styles.xml中的 <cellXfs> 节点元素的下标
                <c r="B2" s="4" t="s">
                    <v>16</v>
                </c>
            </row>
            <row r="3" ht="30" customHeight="1" spans="2:4">
                <c r="B3" s="5" t="s">
                    <v>17</v>
                </c>
                <c r="D3" s="6" t="s">
                    <v>18</v>
                </c>
            </row>
            <row r="4" ht="14.25"/>
            <row r="5" ht="14.25" spans="2:2">
                <c r="B5" s="7" t="s">
                    <v>19</v>
                </c>
            </row>
            <row r="6" ht="14.25" spans="3:4">
                <c r="C6" s="8" t="s">
                    <v>20</v>
                </c>
                <c r="D6" s="8"/>
            </row>
            <row r="7" ht="14.25" spans="2:4">
                <c r="B7">
                    <v>1</v>
                </c>
                <c r="C7" s="9"/>
                <c r="D7" s="9"/>
            </row>
            <row r="8" ht="14.25" spans="2:2">
                <c r="B8">
                    <v>2</v>
                </c>
            </row>
            <row r="9" spans="2:2">
                <c r="B9">
                //求和公式
                    <f>SUM(B7:B8)</f>
                    <v>3</v>
                </c>
            </row>
            <row r="13" spans="2:2">
                <c r="B13">
                    <v>1</v>
                </c>
            </row>
            <row r="14" spans="2:2">
                <c r="B14">
                    <v>2</v>
                </c>
            </row>
            <row r="15" spans="2:2">
                <c r="B15">
                //求和公式
                    <f>SUM(B13:B14)</f>
                    <v>3</v>
                </c>
            </row>
        </sheetData>
        //合并单元格信息，合并单元格中的值，由左上角单元格记录
        <mergeCells count="1">
            <mergeCell ref="C6:D7"/>
        </mergeCells>
        //条件公式信息，暂不讲解
        <conditionalFormatting sqref="B8:B9">
            <cfRule type="colorScale" priority="1">
                <colorScale>
                    <cfvo type="min"/>
                    <cfvo type="percentile" val="50"/>
                    <cfvo type="max"/>
                    <color rgb="FFF8696B"/>
                    <color rgb="FFFFEB84"/>
                    <color rgb="FF63BE7B"/>
                </colorScale>
            </cfRule>
        </conditionalFormatting>
        //打印用的 页边距
        <pageMargins left="0.699305555555556" right="0.699305555555556" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>
        //打印纸张等
        <pageSetup paperSize="9" orientation="portrait"/>
        //页眉页脚
        <headerFooter/>
        //图表 对应 drawings 文件夹
        <drawing r:id="rId1"/>
    </worksheet>
shareStrings.xml
  • 共享字符串文件，记录每个sheet页中单元格的文本信息，而sheet.xml中只记录下标。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <sst
        xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="103" uniqueCount="49">
        <si>
            <t>表头</t> // 例如这个 在 sheet.xml中就 只记录 0 的下标
        </si>
        <si>
            <t>表列</t>// 例如这个 在 sheet.xml中就 只记录 1 的下标
        </si>
        *****
        <si>
            <t>数学</t>
        </si>
        <si>
            <t>小张</t>
        </si>
        <si>
            <t>小王</t>
        </si>
        <si>
            <t>英语</t>
        </si>
        <si>
            <t>总计</t>
        </si>
        <si>
            <t>语文</t>
        </si>
        <si>
            <t>测试</t>
        </si>
        <si>
            <t>B2我有上和右边</t>
        </si>
        <si>
            <t>我B3有上下粗边框</t>
        </si>
        <si>
            <t>D3我有左右</t>
        </si>
        <si>
            <t>B5 斜线</t>
        </si>
        <si>
            <t>我是合并信息</t>
        </si>
        <si>
            <t>你好</t>
        </si>
        <si>
            <t>我是百度</t>
        </si>
        *****
    </sst>
styles.xml
  • 样式文件，记录整个Excel的单元格样式信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<styleSheet
    xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
    //数字格式化信息
    <numFmts count="4">
        <numFmt numFmtId="44" formatCode="_ &quot;￥&quot;* #,##0.00_ ;_ &quot;￥&quot;* \-#,##0.00_ ;_ &quot;￥&quot;* &quot;-&quot;??_ ;_ @_ "/>
        <numFmt numFmtId="41" formatCode="_ * #,##0_ ;_ * \-#,##0_ ;_ * &quot;-&quot;_ ;_ @_ "/>
        <numFmt numFmtId="42" formatCode="_ &quot;￥&quot;* #,##0_ ;_ &quot;￥&quot;* \-#,##0_ ;_ &quot;￥&quot;* &quot;-&quot;_ ;_ @_ "/>
        <numFmt numFmtId="43" formatCode="_ * #,##0.00_ ;_ * \-#,##0.00_ ;_ * &quot;-&quot;??_ ;_ @_ "/>
    </numFmts>
    //字体信息
    <fonts count="20">
        <font>
            <sz val="11"/>
            <color theme="1"/>
            <name val="宋体"/>
            <charset val="134"/>
            <scheme val="minor"/>
        </font>
        <font>
            <u/>
            <sz val="11"/>
            <color rgb="FF800080"/>
            <name val="宋体"/>
            <charset val="0"/>
            <scheme val="minor"/>
        </font>
       ******
    </fonts>
    //背景色信息
    <fills count="33">
        <fill>
            <patternFill patternType="none"/>
        </fill>
        <fill>
            <patternFill patternType="gray125"/>
        </fill>
        <fill>
            <patternFill patternType="solid">
                <fgColor theme="9" tint="0.599993896298105"/>
                <bgColor indexed="64"/>
            </patternFill>
        </fill>
        ***
    </fills>
    //边框信息
    <borders count="14">
        <border>
            <left/>
            <right/>
            <top/>
            <bottom/>
            <diagonal/>
        </border>
        <border>
            <left/>
            <right style="thick">
                <color auto="1"/>
            </right>
            <top style="thick">
                <color auto="1"/>
            </top>
            <bottom/>
            <diagonal/>
        </border>
        <border>
            <left/>
            <right/>
            <top/>
            <bottom style="thick">
                <color auto="1"/>
            </bottom>
            <diagonal/>
        </border>
       ***
    </borders>
    <cellStyleXfs count="49">
       ***
        <xf numFmtId="0" fontId="2" fillId="2" borderId="0" applyNumberFormat="0" applyBorder="0" applyAlignment="0" applyProtection="0">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="6" fillId="5" borderId="0" applyNumberFormat="0" applyBorder="0" applyAlignment="0" applyProtection="0">
            <alignment vertical="center"/>
        </xf>
    </cellStyleXfs>
    //单元格样式信息
    <cellXfs count="10">
    //对应上方的 xml节点的下标
        <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0" applyAlignment="1">
            <alignment horizontal="center" vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0" applyAlignment="1">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="1" fillId="0" borderId="0" xfId="10" applyFont="1">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="1" xfId="0" applyBorder="1">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="2" xfId="0" applyBorder="1">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="3" xfId="0" applyBorder="1">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="4" xfId="0" applyBorder="1">
            <alignment vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="5" xfId="0" applyBorder="1" applyAlignment="1">
            <alignment horizontal="center" vertical="center"/>
        </xf>
        <xf numFmtId="0" fontId="0" fillId="0" borderId="2" xfId="0" applyBorder="1" applyAlignment="1">
            <alignment horizontal="center" vertical="center"/>
        </xf>
    </cellXfs>
    <cellStyles count="49">
        <cellStyle name="常规" xfId="0" builtinId="0"/>
        <cellStyle name="货币[0]" xfId="1" builtinId="7"/>
        <cellStyle name="20% - 强调文字颜色 3" xfId="2" builtinId="38"/>
        <cellStyle name="输入" xfId="3" builtinId="20"/>
        <cellStyle name="货币" xfId="4" builtinId="4"/>
        <cellStyle name="千位分隔[0]" xfId="5" builtinId="6"/>
        <cellStyle name="40% - 强调文字颜色 3" xfId="6" builtinId="39"/>
        <cellStyle name="差" xfId="7" builtinId="27"/>
        <cellStyle name="千位分隔" xfId="8" builtinId="3"/>
        <cellStyle name="60% - 强调文字颜色 3" xfId="9" builtinId="40"/>
        <cellStyle name="超链接" xfId="10" builtinId="8"/>
        <cellStyle name="百分比" xfId="11" builtinId="5"/>
        <cellStyle name="已访问的超链接" xfId="12" builtinId="9"/>
        <cellStyle name="注释" xfId="13" builtinId="10"/>
        <cellStyle name="60% - 强调文字颜色 2" xfId="14" builtinId="36"/>
        <cellStyle name="标题 4" xfId="15" builtinId="19"/>
        <cellStyle name="警告文本" xfId="16" builtinId="11"/>
        <cellStyle name="标题" xfId="17" builtinId="15"/>
        <cellStyle name="解释性文本" xfId="18" builtinId="53"/>
        <cellStyle name="标题 1" xfId="19" builtinId="16"/>
        <cellStyle name="标题 2" xfId="20" builtinId="17"/>
        <cellStyle name="60% - 强调文字颜色 1" xfId="21" builtinId="32"/>
        <cellStyle name="标题 3" xfId="22" builtinId="18"/>
        <cellStyle name="60% - 强调文字颜色 4" xfId="23" builtinId="44"/>
        <cellStyle name="输出" xfId="24" builtinId="21"/>
        <cellStyle name="计算" xfId="25" builtinId="22"/>
        <cellStyle name="检查单元格" xfId="26" builtinId="23"/>
        <cellStyle name="20% - 强调文字颜色 6" xfId="27" builtinId="50"/>
        <cellStyle name="强调文字颜色 2" xfId="28" builtinId="33"/>
        <cellStyle name="链接单元格" xfId="29" builtinId="24"/>
        <cellStyle name="汇总" xfId="30" builtinId="25"/>
        <cellStyle name="好" xfId="31" builtinId="26"/>
        <cellStyle name="适中" xfId="32" builtinId="28"/>
        <cellStyle name="20% - 强调文字颜色 5" xfId="33" builtinId="46"/>
        <cellStyle name="强调文字颜色 1" xfId="34" builtinId="29"/>
        <cellStyle name="20% - 强调文字颜色 1" xfId="35" builtinId="30"/>
        <cellStyle name="40% - 强调文字颜色 1" xfId="36" builtinId="31"/>
        <cellStyle name="20% - 强调文字颜色 2" xfId="37" builtinId="34"/>
        <cellStyle name="40% - 强调文字颜色 2" xfId="38" builtinId="35"/>
        <cellStyle name="强调文字颜色 3" xfId="39" builtinId="37"/>
        <cellStyle name="强调文字颜色 4" xfId="40" builtinId="41"/>
        <cellStyle name="20% - 强调文字颜色 4" xfId="41" builtinId="42"/>
        <cellStyle name="40% - 强调文字颜色 4" xfId="42" builtinId="43"/>
        <cellStyle name="强调文字颜色 5" xfId="43" builtinId="45"/>
        <cellStyle name="40% - 强调文字颜色 5" xfId="44" builtinId="47"/>
        <cellStyle name="60% - 强调文字颜色 5" xfId="45" builtinId="48"/>
        <cellStyle name="强调文字颜色 6" xfId="46" builtinId="49"/>
        <cellStyle name="40% - 强调文字颜色 6" xfId="47" builtinId="51"/>
        <cellStyle name="60% - 强调文字颜色 6" xfId="48" builtinId="52"/>
    </cellStyles>
    
    <tableStyles count="0" defaultTableStyle="TableStyleMedium2" defaultPivotStyle="PivotStyleLight16"/>
    <extLst>
        <ext uri="{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}"
            xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">
            <x14:slicerStyles defaultSlicerStyle="SlicerStyleLight1"/>
        </ext>
    </extLst>
</styleSheet>
总结

upload successful

  • Excel在存储上 做了很多的优化，所以07版本 的比 03版本的容量更小却可以存储更多的数据，但是这样通过下标的方式优化了存储对程序而言是一个不小的挑战
]]> <h4 id="背景"><a href="#背景" class="headerlink" title="背景"></a>背景</h4><ul> <li><p>最近项目上想要对现在用的表格组件进行底层重构，所以对类似的产品Excel的存储结构上是否有可以借鉴的地方，所以就有了今天的这篇文章。</p> </li> <li><p>文章主要探讨Excel数据存储，样式存储，合并单元格信息存储等基础数据的存储，细分Excel解压后的各个文件的职责，和存储结构。</p> </li> </ul> 网易裁员 https://blog.luckylxh.top/2020/01/06/网易裁员/ 2020-01-06T07:32:00.000Z 2020-09-23T04:05:40.146Z

原视频链接 ：https://www.bilibili.com/video/av77151622

]]> <video src="/videos/wangyicaiyuan.mp4" type="video/mp4" controls="controls" width="100%" height="100%"><br></video> <p><a href="https://www 程序中的数值 https://blog.luckylxh.top/2020/01/03/程序中的数值/ 2020-01-03T07:14:00.000Z 2020-09-23T04:05:02.707Z 背景
  • 聊下Java和js的数值类型，这个地方也是开发中容易出错的地方。
  • IEEE 754 浮点“双精度格式” 标准。

资料

  • 计算机只存储和运算都是二进制数据。我们常用的十进制数据在存储和运算的时候需要转换为二进制。
  • js 没有java的整数和浮点值的概念，统一用的number类型。

以js number 64位双精度结构：

upload successful

  • sign 1个符号位 代表正负
  • exponent 11个指数位 代表指数信息
  • fraction 52个尾数位 代表数值信息
1
2
3
4
5
6
举个例子，如果是5.5这个数字的话，则计算过程是这样的：
5.5 转二进制 =====> 101.1 科学计数法 =====> 1.011*2^2 
存入计算机： 
符号位：0 
指数位：2 加1023 =====> 1025 转二进制 =====> 10000000001 
尾数位：1.011 隐去小数点左边的1 =====> 011

upload successful

  • js 不丢失精度的最大值就是2的52次方减去1 如果超过这个值并且小于 MAX_VALUE,可用表示但是精度会丢失.
]]> <h4 id="背景"><a href="#背景" class="headerlink" title="背景"></a>背景</h4><ul> <li>聊下Java和js的数值类型，这个地方也是开发中容易出错的地方。</li> <li>IEEE 754 浮点“双精度格式” 标准。</li> </ul> <h4 id="资料"><a href="#资料" class="headerlink" title="资料"></a>资料</h4><ul> <li>计算机只存储和运算都是二进制数据。我们常用的十进制数据在存储和运算的时候需要转换为二进制。</li> <li>js 没有java的整数和浮点值的概念，统一用的number类型。</li> </ul> <p>以js number 64位双精度结构：</p> <p><img src="/images/pasted-51.png" alt="upload successful"></p> 程序如何正确的处理时间 https://blog.luckylxh.top/2020/01/03/程序如何正确的处理时间/ 2020-01-03T01:23:00.000Z 2020-09-23T04:04:19.170Z 背景
  • 源于一次bug的调试，测试输入用户的生日为：1991-07-24 保存后。刷新页面，生日变成了 1991-07-23。
  • 经过排查，是夏令时和时区的概念不清楚导致的bug，这次就来系统的讲讲夏令时和时区的概念，和我们如何正确的处理时间。

概念

时区

由于世界各国家与地区经度不同，地方时也有所不同，因此会划分为不同的时区。

正式的时区划分包括24个时区，每一时区由一个英文字母表示。每隔经度15°划分一个时区，有一个例外，每个时区有一条中央子午线；例如，GMT属于“z”区，因此其时间后通常添加后缀“Z”（口语中用后缀“Zulu”）

夏令时

夏令时，表示为了节约能源，人为规定时间的意思。也叫夏时制，夏时令（Daylight Saving Time：DST），又称“日光节约时制”和“夏令时间”，在这一制度实行期间所采用的统一时间称为“夏令时间”。

一般在天亮早的夏季人为将时间调快一小时，可以使人早起早睡，减少照明量，以充分利用光照资源，从而节约照明用电。各个采纳夏时制的国家具体规定不同。目前全世界有近110个国家每年要实行夏令时。

冬令时

有夏令时就会有冬令时。高纬度和中纬度的许多国家在夏季到来前，把时针拨快一小时，新的时间就是夏令时，到下半季秋季来临前，再把时针拨回一小时，即形成冬令时。

夏令时和冬令时的影响

拿美国来说，美国各个地区的时间都不同，不像中国一样统一使用北京时间，美国一般以三月份第二个周日凌晨两点当成夏季的开始，十一月份第一个周日的凌晨两点当成冬季的开始。

所以在每年的三月份第二个周日凌晨两点过后，时间就会往前调快一个小时；同理，十一月份第一个周日把这一个小时调回来。

你也可以理解成美国那边，一年里面有一天只有23小时（夏天开始那一天），有一天有25小时（冬天开始那一天），其他时间每天都是24小时。

所以你会发现，夏天的时候，中国的北京时间（东八区）与美国太平洋时区（西八区）的时差是15小时，而到了冬天却变成16小时

讲解

  • 中国区内开发java默认的时区是 Asia/Shanghai 也就是中国时区，而中国在1986年到1991年施行了夏令时，导致在夏令时的时间内，会少一小时的时间，1991-07-24 保存到数据库后变成了 1991-07-23 23:00:00 CDT。
方案

  • 如果项目上没有跨国，可以在项目启动的时候。统一设置时区为东八区.当然也要注意数据库。

    1
    TimeZone.setDefault(TimeZone.getTimeZone("GMT+08"));

  • 如果项目跨国了，推荐使用时间戳作为时间的记录值，数据库用Long类型，前台展示也更灵活

]]> <h4 id="背景"><a href="#背景" class="headerlink" title="背景"></a>背景</h4><ul> <li>源于一次bug的调试，测试输入用户的生日为：1991-07-24 保存后。刷新页面，生日变成了 1991-07-23。</li> <li>经过排查，是夏令时和时区的概念不清楚导致的bug，这次就来系统的讲讲夏令时和时区的概念，和我们如何正确的处理时间。</li> </ul> <h4 id="概念"><a href="#概念" class="headerlink" title="概念"></a>概念</h4><h5 id="时区"><a href="#时区" class="headerlink" title="时区"></a>时区</h5><p>由于世界各国家与地区经度不同，地方时也有所不同，因此会划分为不同的时区。</p> <p>正式的时区划分包括24个时区，每一时区由一个英文字母表示。每隔经度15°划分一个时区，有一个例外，每个时区有一条中央子午线；例如，GMT属于“z”区，因此其时间后通常添加后缀“Z”（口语中用后缀“Zulu”）</p> SpringBoot 浅析 https://blog.luckylxh.top/2019/08/16/SpringBoot-启动原理/ 2019-08-16T08:52:00.000Z 2020-09-23T04:03:31.456Z SpringBoot 使用已经有不短的时间了，这次来系统的过下，自动配置原理，和启动原理。

Spring Boot 优点

  • Spring Boot 首先还是Spring
  • 它减少了大量的开发时间并提高了生产力
  • 它避免了编写大量的样板代码，注释和XML配置
  • 它遵循“自用默认配置”方法，以减少开发工作量
  • 独立运行的Spring项目
  • 内嵌的Servlet容器
  • ….
  • 重点：自用默认配置，约定大于配置，开箱即用
  • 如何实现的？

    自动配置

  • @EnableAutoConfiguration
  • @Conditional

@EnableAutoConfiguration

  • 顾名思义，EnableAutoConguration是和自动化配置相关的东西。
  • Spring应用上下文的自动化配置，尝试去猜测和配置你需要的bean。这些被自动化配置的类通常在classpath路径下，或者是你自己定义的bean。
  • 可以使用exclude来排除那些你不想被自动化配置的类。
  • 被EnableAutoConfiguration注解的类所在的包有着特殊的意义，他们通常被认为是默认的包，并对其及下属的包进行扫描。
  • 自动配置的类通常是在@Configuration里面配置的类
  • AutoConfigurationImportSelector 类提供支持，从 META-INF/spring.factories 中获取配置类

@Conditional

  • @Conditional是Spring4新提供的注解，它的作用是按照一定的条件进行判断，满足条件给容器注册bean
  • Spring Boot 对在这个注解的基础上进行扩充了许多的@ConditionalOnXXXXXX
  • @ConditionalOnBean（某个Bean是否存在）
  • @ConditionalOnClass（类是否存在）
  • @ConditionalOnExpression（当表达式为true的时候，才会实例化一个Bean）
  • 参考 HttpEncodingAutoConfiguration

启动原理

我们从一个简单的SpringBoot入手

1
2
3
4
5
6
7
8
@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}

}

进来以后 先 new SpringApplication(primarySources)对象，看下他的构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
        //记录主资源
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //判断启动类型，这里是SERVLET
this.webApplicationType = deduceWebApplicationType();
        //从 META-INF/spring.factories 收集 ApplicationContextInitializer，并实例化
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
        //从 META-INF/spring.factories 收集 ApplicationListener，并实例化
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //判断主类
this.mainApplicationClass = deduceMainApplicationClass();
}

进入run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
        //声明了一个ApplicationContext 容器
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
configureHeadlessProperty();
        //从 META-INF/spring.factories 收集SpringApplicationRunListener，并实例化
SpringApplicationRunListeners listeners = getRunListeners(args);
        //调用 SpringApplicationRunListener.starting()
listeners.starting();
try {
           //参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
                //准备环境 并调用 SpringApplicationRunListener.environmentPrepared()
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
configureIgnoreBeanInfo(environment);
            //打印Banner
Banner printedBanner = printBanner(environment);
            //根据类型创建一个Spring容器
context = createApplicationContext();
            //异常报告
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
                    //准备Spring容器环境，调用ApplicationContextInitializer.initialize()
                    //调用SpringApplicationRunListener.contextPrepared
                    //调用SpringApplicationRunListener.contextLoaded
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
                    //刷新容器
refreshContext(context);
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
            //调用SpringApplicationRunListener.started
listeners.started(context);
            //调用 ApplicationRunner CommandLineRunner
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}

try {
        //调用SpringApplicationRunListener.running
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}

具体的东西还是跟代码看几遍，并实现下这几个接口

]]> <p>SpringBoot 使用已经有不短的时间了，这次来系统的过下，自动配置原理，和启动原理。</p> <h3 id="Spring-Boot-优点"><a href="#Spring-Boot-优点" class="headerlink" title="Spring Boot 优点"></a>Spring Boot 优点</h3><ul> <li>Spring Boot 首先还是Spring</li> <li>它减少了大量的开发时间并提高了生产力</li> <li>它避免了编写大量的样板代码，注释和XML配置</li> <li>它遵循“自用默认配置”方法，以减少开发工作量</li> <li>独立运行的Spring项目</li> <li>内嵌的Servlet容器</li> <li>….</li> <li>重点：自用默认配置，约定大于配置，开箱即用</li> <li>如何实现的？ 大数据的excel文件导入导出 https://blog.luckylxh.top/2019/05/14/大数据的excel文件导入导出/ 2019-05-14T12:13:00.000Z 2020-09-23T04:03:03.627Z 开发报表平台，需要有报表系统和用户的数据交互，报表又称之为线上的excel，所以在与系统交互的过程中，除了用户在线上直接录入数据，excel的导入导出是重要的一环.下面就说下我们在开发过程中对这块的处理。

poi

没错，不出意外的我们使用了poi作为我们处理excel的开发组件，poi对excel的操作提供了丰富的api，让我们可以对excel的每个单元格的样式，格式等都有很好的操作。但是poi十分吃服务器内存也是一个事实，到现在这个问题还是没有很好的优化。

读写模式

upload successful

POI读取Excel有两种模式，一种是用户模式（可修改），一种是SAX事件驱动模式，将xlsx格式的文档转换成CSV格式后进行读取。用户模式API接口丰富，使用POI的API可以很容易读取Excel，但用户模式消耗的内存很大，当遇到很大sheet、大数据网格，假空行、公式等问题时，很容易导致内存溢出。POI官方推荐解决内存溢出的方式使用CVS格式解析，即SAX事件驱动模式。下面主要是讲解如何读取大批量数据：

导出大数据量的excel(07)

这个比较简单，我们只需要 用 SXXFWorkbook替换掉我们用的 XSSFWorkbook就可以了（POI3.8后），SXXFWorkbook 是poi为我们实现的一个 支持大数据量导出的WookBook实现类，它的整体实现就是，在新建的时候指定内存中容纳多少行数据，当持续写入的行数超过我们设置的数量的时候，就会刷新内存中的数据写入到硬盘中，内部实现还是 XSSFWorkbook这个类，所以我们在构建 SXXFWorkbook的时候

1
2
//我们需要指定一个内存中的行数，后台的操作就和 XSSFWorkbook一致了。
SXSSFWorkbook sxWorkbook = new SXSSFWorkbook(2000);

这样我们在写出大数据量的excel的时候，就不会在出现内存溢出问题了。（只能导出）

导入大数据量的excel(07)

如果是大数据量的导入，我们肯定不能用用户模式，用户模式是对所有的数据全部放到内存中，34M大小的07版本的excel用用户模式读取，需要大概4G的内存消耗，所以太消耗内存了，不过用户模式可以读，可以写。是最为方便的一种模式，如果导入大数据量的excle，推荐一个开源的项目xlsx-streamer,作者已经给我们写好了xml分批量读取excel的代码了，我们只要直接用就行了。

1
2
3
4

Workbook wk = StreamingReader.builder().rowCacheSize(100)  //缓存到内存中的行数，默认是10
                .bufferSize(2048)  //读取资源时，缓存到内存的字节大小，默认是1024
                .open(excel);

不过这种方式是只能读取信息，并且不支持随机访问sheet页种的每行数据，我们获取数据需要使用迭代器的方式获取。作者实现的这个开源组件不支持获取sheet页中的合并单元格信息，但是我们项目中使用必须要合并单元格的信息来完成业务操作，并且我们项目中的大部分组件使用的poi是3.9的，作者用的poi是4.0.0 所以最后我只能在开源作者的基础上做了自己的定制，可以获取到sheet页的合并单元格信息，并且poi版本是3.9。如果你们项目也需要自己的定制，也需要在作者的基础上进行开发，源代码中作者用的是解析xml的形式来读取excel的，也比较好理解和修改，我自己修改的版本在这里

]]> <p>开发报表平台，需要有报表系统和用户的数据交互，报表又称之为线上的excel，所以在与系统交互的过程中，除了用户在线上直接录入数据，excel的导入导出是重要的一环.下面就说下我们在开发过程中对这块的处理。</p> <h4 id="poi"><a href="#poi" class="headerlink" title="poi"></a>poi</h4><p> 没错，不出意外的我们使用了poi作为我们处理excel的开发组件，poi对excel的操作提供了丰富的api，让我们可以对excel的每个单元格的样式，格式等都有很好的操作。但是poi十分吃服务器内存也是一个事实，到现在这个问题还是没有很好的优化。<br> 浏览器缓存机制 https://blog.luckylxh.top/2019/04/02/浏览器缓存机制/ 2019-04-02T07:40:00.000Z 2020-09-23T04:02:07.740Z 背景
get请求
  • GET 请求可被缓存
  • GET 请求保留在浏览器历史记录中
  • GET 请求可被收藏为书签
  • GET 请求不应在处理敏感数据时使用
  • GET 请求有长度限制
  • GET 请求只应当用于取回数据
post请求
  • POST 请求不会被缓存
  • POST 请求不会保留在浏览器历史记录中
  • POST 不能被收藏为书签
  • POST 请求对数据长度没有要求

缓存机制

浏览器与服务器通信的方式为应答模式，即是：浏览器发起HTTP请求 – 服务器响应该请求，那么浏览器怎么确定一个资源该不该缓存，如何去缓存呢？

浏览器第一次向服务器发起该请求后拿到请求结果后，将请求结果和缓存标识存入浏览器缓存，浏览器对于缓存的处理是根据第一次请求资源时返回的响应头来确定的。具体过程如下图：

upload successful

由上图我们可以知道：

浏览器每次发起请求，都会先在浏览器缓存中查找该请求的结果以及缓存标识
浏览器每次拿到返回的请求结果都会将该结果和缓存标识存入浏览器缓存中

以上两点结论就是浏览器缓存机制的关键，它确保了每个请求的缓存存入与读取，只要我们再理解浏览器缓存的使用规则，那么所有的问题就迎刃而解了，本文也将围绕着这点进行详细分析。为了方便大家理解，这里我们根据是否需要向服务器重新发起HTTP请求将缓存过程分为两个部分，分别是强缓存和协商缓存。

强缓存

强缓存：不会向服务器发送请求，直接从缓存中读取资源，在chrome控制台的Network选项中可以看到该请求返回200的状态码，并且Size显示from disk cache或from memory cache。强缓存可以通过设置新鲜度，也就是两种 HTTP Header 实现：Expires 和 Cache-Control。在已经有缓存的时候，去请求数据的时候会验证新鲜度是否还新鲜，如果是，就直接从缓存中获取数据，如果不新鲜，就请求后台，获取数据，再放入缓存中。

Expires

缓存过期时间，用来指定资源到期的时间，是服务器端的具体的时间点。也就是说，Expires=max-age + 请求时间，需要和Last-modified结合使用。Expires是Web服务器响应消息头字段，在响应http请求时告诉浏览器在过期时间前浏览器可以直接从浏览器缓存取数据，而无需再次请求。

Expires 是 HTTP/1 的产物，受限于本地时间，如果修改了本地时间，可能会造成缓存失效。Expires: Wed, 22 Oct 2018 08:41:00 GMT表示资源会在 Wed, 22 Oct 2018 08:41:00 GMT 后过期，需要再次请求。

Cache-Control

在HTTP/1.1中，Cache-Control是最重要的规则，主要用于控制网页缓存。比如当Cache-Control:max-age=300时，则代表在这个请求正确返回时间（浏览器也会记录下来）的5分钟内再次加载资源，就会命中强缓存。
Cache-Control 可以在请求头或者响应头中设置，并且可以组合使用多种指令：

upload successful

  • max-age 和 s-maxage

    两者是 cache-control 的主要字段，它们是一个数字，表示资源过了多少秒之后变为无效。在浏览器中，max-age 和 s-maxage 都起作用，而且 s-maxage 的优先级高于 max-age。在代理服务器中，只有 s-maxage 起作用。 可以通过设置 max-age 为 0 表示立马过期来向服务器请求资源。

  • public 和 private

    public 表示该资源可以被所有客户端和代理服务器缓存，而 private 表示该资源仅能客户端缓存。默认值是 private，当设置了 s-maxage 的时候表示允许代理服务器缓存，相当于 public。

  • no-cache 和 no-store

    no-cache 表示的是不直接询问浏览器缓存情况，而是去向服务器验证当前资源是否更新（即协商缓存）。no-store 则更狠，完全不使用缓存策略，不缓存请求或响应的任何内容，直接向服务器请求最新（协商缓存也不会走）。由于两者都不考虑缓存情况而是直接与服务器交互，所以当 no-cache 和 no-store 存在时会直接忽略 max-age 等。

Expires和Cache-Control两者对比

其实这两者差别不大，区别就在于 Expires 是http1.0的产物，Cache-Control是http1.1的产物，两者同时存在的话，Cache-Control优先级高于Expires；在某些不支持HTTP1.1的环境下，Expires就会发挥用处。所以Expires其实是过时的产物，现阶段它的存在只是一种兼容性的写法。

强缓存判断是否缓存的依据来自于是否超出某个时间或者某个时间段，而不关心服务器端文件是否已经更新，这可能会导致加载文件不是服务器端最新的内容，那我们如何获知服务器端内容是否已经发生了更新呢？此时我们需要用到协商缓存策略。

协商缓存

协商缓存就是强制缓存失效后，浏览器携带缓存标识向服务器发起请求，由服务器根据缓存标识（校验值）决定是否使用缓存的过程，主要有以下两种情况：

  • 协商缓存生效，返回304和Not Modified
    upload successful
  • 协商缓存失效，返回200和请求结果
    upload successful

协商缓存可以通过设置两种 HTTP Header 实现：Last-Modified 和 ETag ，也就是带着校验值请求后台，后台根据校验值判断后台资源是否有更新，如果有返回最新的数据，如果没有就不返回数据了，节省传输的数据大小。

Last-Modified

浏览器在第一次访问资源时，服务器返回资源的同时，在response header中添加 Last-Modified的header，值是这个资源在服务器上的最后修改时间，浏览器接收后缓存文件和header；

Last-Modified: Fri, 22 Jul 2016 01:47:00 GMT

浏览器下一次请求这个资源，浏览器检测到有 Last-Modified这个header，于是添加If-Modified-Since这个header，值就是Last-Modified中的值；服务器再次收到这个资源请求，会根据 If-Modified-Since 中的值与服务器中这个资源的最后修改时间对比，如果没有变化，返回304和空的响应体，直接从缓存读取，如果If-Modified-Since的时间小于服务器中这个资源的最后修改时间，说明文件有更新，于是返回新的资源文件和200

upload successful

但是 Last-Modified 存在一些弊端：

  • 如果本地打开缓存文件，即使没有对文件进行修改，但还是会造成 Last-Modified 被修改，服务端不能命中缓存导致发送相同的资源

  • 因为 Last-Modified 只能以秒计时，如果在不可感知的时间内修改完成文件，那么服务端会认为资源还是命中了，不会返回正确的资源

既然根据文件修改时间来决定是否缓存尚有不足，能否可以直接根据文件内容是否修改来决定缓存策略？所以在 HTTP / 1.1 出现了 ETag 和If-None-Match

ETag

Etag是服务器响应请求时，返回当前资源文件的一个唯一标识(由服务器生成)，只要资源有变化，Etag就会重新生成。浏览器在下一次加载资源向服务器发送请求时，会将上一次返回的Etag值放到request header里的If-None-Match里，服务器只需要比较客户端传来的If-None-Match跟自己服务器上该资源的ETag是否一致，就能很好地判断资源相对客户端而言是否被修改过了。如果服务器发现ETag匹配不上，那么直接以常规GET 200回包形式将新的资源（当然也包括了新的ETag）发给客户端；如果ETag是一致的，则直接返回304知会客户端直接使用本地缓存即可。

upload successful

两者之间对比：
  • 首先在精确度上，Etag要优于Last-Modified。

Last-Modified的时间单位是秒，如果某个文件在1秒内改变了多次，那么他们的Last-Modified其实并没有体现出来修改，但是Etag每次都会改变确保了精度；如果是负载均衡的服务器，各个服务器生成的Last-Modified也有可能不一致。

  • 第二在性能上，Etag要逊于Last-Modified，毕竟Last-Modified只需要记录时间，而Etag需要服务器通过算法来计算出一个hash值。

  • 第三在优先级上，服务器校验优先考虑Etag

如何使用

  • Cache-Control与Expires

　　Cache-Control与Expires的作用一致，都是指明当前资源的有效期，控制浏览器是否直接从浏览器缓存取数据还是重新发请求到服务器取数据。只不过Cache-Control的选择更多，设置更细致，如果同时设置的话，其优先级高于Expires。

  • Last-Modified/ETag与Cache-Control/Expires

　　配置Last-Modified/ETag的情况下，浏览器再次访问统一URI的资源，还是会发送请求到服务器询问文件是否已经修改，如果没有，服务器会只发送一个304回给浏览器，告诉浏览器直接从自己本地的缓存取数据；如果修改过那就整个数据重新发给浏览器；

　　Cache-Control/Expires则不同，如果检测到本地的缓存还是有效的时间范围内，浏览器直接使用本地副本，不会发送任何请求。两者一起使用时，Cache-Control/Expires的优先级要高于Last-Modified/ETag。即当本地副本根据Cache-Control/Expires发现还在有效期内时，则不会再次发送请求去服务器询问修改时间（Last-Modified）或实体标识（Etag）了。

当资源过期时（使用Cache-Control标识的max-age），发现资源具有Last-Modified声明，则再次向web服务器请求时带上头If-None-Match（Last-Modified的值）。web服务器收到请求后发现有头If-None-Match则与被请求资源的相应校验串进行比对，决定返回200或304

　　一般情况下，使用Cache-Control/Expires会配合Last-Modified/ETag一起使用，因为即使服务器设置缓存时间, 当用户点击“刷新”按钮时，浏览器会忽略缓存继续向服务器发送请求，这时Last-Modified/ETag将能够很好利用304，从而减少响应开销。

upload successful

]]> <h4 id="背景"><a href="#背景" class="headerlink" title="背景"></a>背景</h4><h5 id="get请求"><a href="#get请求" class="headerlink" title="get请求"></a>get请求</h5><ul> <li>GET 请求可被缓存</li> <li>GET 请求保留在浏览器历史记录中</li> <li>GET 请求可被收藏为书签</li> <li>GET 请求不应在处理敏感数据时使用</li> <li>GET 请求有长度限制</li> <li>GET 请求只应当用于取回数据</li> </ul> <h5 id="post请求"><a href="#post请求" class="headerlink" title="post请求"></a>post请求</h5><ul> <li>POST 请求不会被缓存</li> <li>POST 请求不会保留在浏览器历史记录中</li> <li>POST 不能被收藏为书签</li> <li>POST 请求对数据长度没有要求</li> </ul>