Java 实现自动获取法定节假日

一、背景

在实现业务需求的过程中，遇到了需要计算 x 个工作日后的日期需求。由于工作日是每年国务院发布的，调休和休假都没有规律，所以无法使用算法进行计算。

一般的实现方案是自己维护一个工作日和调休的表，或者去爬取国务院发布的数据。但前者实现起来麻烦，每年都得搞一遍；后者可能涉及法律风险，爬虫的识别策略也不太可靠。

所以还是考虑使用由专人维护的接口，找到了天行数据的接口，个人用户有10个免费接口的额度，每个接口每天限制调用100次。

因为节假日一旦定下来就不会轻易改变，所以可以把获取到的数据存在本地，这样每天100次的接口额度完全够用，不需要进行付费。

二、技术实现方案

整体流程：

1. 读取节假日配置：从本地文件中读取节假日，如果本地没有文件，则调用天行接口获取。
2. 解析数据：从天行返回的数据里，获取该年份里需要调休的日期和补班的日期。
3. 计算日期：循环获取日期，判断是否为工作日，计算x个工作日后的日期。

实现细节：

1. 文件名：保存下来的文件，名字里要包含特定的年份。
2. 计算逻辑：计算日期的时候，需要考虑到跨年的情况，跨年需要重新获取下一年的数据，再继续进行计算日期。
3. 日期判断：工作日=不休假的周一至周五+补班的周六周末。

三、详细代码

Java 代码

主要有五个类，HolidayResponse 是封装天行API的返回结果；TianApiProperties 是获取天行API的key；TianApiHolidayService 是接口；TianApiHolidayServiceImpl 里是具体实现；HttpConnector 是接口请求，这个换成任何一个能发起http请求的库都行。

目前代码是基于SpringBoot写的，但纯粹只是为了方便，实际是可以转成纯Java工具代码，不依赖于SpringBoot。

HolidayResponse.java

1. import com.fasterxml.jackson.annotation.JsonProperty;
2. import lombok.Data;
4. import java.util.List;
6. /**
7. * @author jing
8. * @version 1.0
9. * @desc 返回结果
10. * @date 2023/12/19 11:40
11. **/
12. @Data
13. public class HolidayResponse {
15. @JsonProperty("code")
16. private int code; // 公共参数 - 状态码
18. @JsonProperty("msg")
19. private String msg; // 公共参数 - 错误信息
21. @JsonProperty("result")
22. private Result result; // 公共参数 - 返回结果集
24. // Getters and setters
26. /**
27. * Represents the result section of the response.
28. */
29. @Data
30. public static class Result {
32. @JsonProperty("update")
33. private boolean update; // 公共参数 - 是否更新法定节假日
35. @JsonProperty("list")
36. private List list; // 应用参数 - 节假日列表
38. // Getters and setters
39. }
41. /**
42. * Represents an item in the list of holidays.
43. */
44. @Data
45. public static class HolidayItem {
46. @JsonProperty("holiday")
47. private String holiday; // 应用参数 - 节日日期
49. @JsonProperty("name")
50. private String name; // 应用参数 - 节假日名称（中文）
52. @JsonProperty("vacation")
53. private String vacation; // 应用参数 - 节假日数组
55. @JsonProperty("remark")
56. private String remark; // 应用参数 - 调休日数组
58. @JsonProperty("wage")
59. private String wage; // 应用参数 - 薪资法定倍数/按年查询时为具体日期
61. @JsonProperty("start")
62. private int start; // 应用参数 - 假期起点计数
64. @JsonProperty("now")
65. private int now; // 应用参数 - 假期当前计数
67. @JsonProperty("end")
68. private int end; // 应用参数 - 假期终点计数
70. @JsonProperty("tip")
71. private String tip; // 应用参数 - 放假提示
73. @JsonProperty("rest")
74. private String rest; // 应用参数 - 拼假建议
76. }
78. }

TianApiProperties.java

1. import lombok.Data;
2. import org.springframework.boot.context.properties.ConfigurationProperties;
3. import org.springframework.stereotype.Component;
5. /**
6. * @author jing
7. * @version 1.0
8. * @desc 配置
9. * @date 2023/12/19 11:25
10. **/
11. @Component
12. @Data
13. @ConfigurationProperties(prefix = "tianapi")
14. public class TianApiProperties {
16. /**
17. * 天行数据凭证key
18. */
19. private String key;
20. }

TianApiHolidayService.java

1. import org.springframework.stereotype.Service;
3. import java.io.IOException;
4. import java.time.LocalDateTime;
7. /**
8. * @author jing
9. * @version 1.0
10. * @desc 天行接口获取节假日，目前使用的是免费接口，每天只能调用100次，后续如果需要调用更多次数，可以考虑购买付费接口。只能获取到今年和明年的节假日，明年的节假日需要在今年11月份左右才能获取到
11. * @date 2023/12/19 11:25
12. **/
13. @Service
14. public interface TianApiHolidayService {
16. /**
17. * 计算x个工作日后的日期，跳过节假日
18. *
19. * @param startTime 开始日期
20. * @param workdaysToAdd 需要跳过的工作日天数
21. */
22. LocalDateTime jumpWorkDay(LocalDateTime startTime, int workdaysToAdd) throws IOException;
24. }

TianApiHolidayServiceImpl.java （核心逻辑）

2. import cn.hutool.core.date.DateUtil;
3. import com.fasterxml.jackson.databind.ObjectMapper;
4. import com.google.gson.Gson;
5. import com.xxx.app.common.library.holiday.domain.HolidayResponse;
6. import com.xxx.app.common.library.holiday.properties.TianApiProperties;
7. import com.xxx.app.common.utils.http.HttpConnector;
8. import lombok.extern.slf4j.Slf4j;
9. import org.apache.commons.lang3.StringUtils;
10. import org.springframework.stereotype.Service;
12. import javax.annotation.Resource;
13. import java.io.FileInputStream;
14. import java.io.FileOutputStream;
15. import java.io.IOException;
16. import java.nio.file.FileSystems;
17. import java.nio.file.Files;
18. import java.nio.file.Path;
19. import java.time.DayOfWeek;
20. import java.time.LocalDate;
21. import java.time.LocalDateTime;
22. import java.time.LocalTime;
23. import java.time.format.DateTimeFormatter;
24. import java.util.ArrayList;
25. import java.util.HashMap;
26. import java.util.List;
27. import java.util.Map;
30. /**
31. * @author jing
32. * @version 1.0
33. * @desc 天行接口获取节假日，目前使用的是免费接口，每天只能调用100次，后续如果需要调用更多次数，可以考虑购买付费接口。只能获取到今年和明年的节假日，明年的节假日需要在今年11月份左右才能获取到
34. * @date 2023/12/19 11:25
35. **/
36. @Slf4j
37. @Service
38. public class TianApiHolidayServiceImpl implements TianApiHolidayService {
40. @Resource
41. private TianApiProperties tianApiProperties;
42. @Resource
43. private HttpConnector httpConnector;
45. private final String FILE_FORMAT = "./.holiday/%s_holiday.json";
47. /**
48. * 计算x个工作日后的日期，跳过节假日
49. *
50. * @param startTime 开始日期
51. * @param workdaysToAdd 需要跳过的工作日天数
52. */
53. public LocalDateTime jumpWorkDay(LocalDateTime startTime, int workdaysToAdd) throws IOException {
54. // 从文件中读取节假日
55. HolidayResponse response = getHolidayConfig(startTime);
56. if (response == null) {
57. return null;
58. }
59. // 节假日，只算周一到周五的
60. List vacationList = new ArrayList<>();
61. // 补班列表，表示周末补班的
62. List workDayList = new ArrayList<>();
63. extracted(response, vacationList, workDayList);
64. return workDayAdd(startTime, workdaysToAdd, vacationList, workDayList);
65. }
67. /**
68. * 提取返回数据里的节假日和调休列表
69. *
70. * @param response 返回数据
71. * @param vacationList 节假日列表
72. * @param workDayList 补班列表
73. */
74. private static void extracted(HolidayResponse response, List vacationList, List workDayList) {
75. // 节假日列表
76. response.getResult().getList().forEach(item -> {
77. if (StringUtils.isNotEmpty(item.getWage())) {
78. String[] vList = item.getVacation().split("\\|");
79. for (String wage : vList) {
80. // 不需要上班的工作日
81. vacationList.add(LocalDate.parse(wage, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
82. }
83. }
84. if (StringUtils.isNotEmpty(item.getRemark())) {
85. String[] workList = item.getRemark().split("\\|");
86. for (String work : workList) {
87. // 需要上班的周末
88. workDayList.add(LocalDate.parse(work, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
89. }
90. }
91. });
92. }
94. /**
95. * 添加工作日
96. *
97. * @param startTime 开始时间
98. * @param workdaysToAdd 需要添加的工作日天数
99. * @param vacationList 节假日列表
100. * @param workDayList 补班列表
101. * @return LocalDateTime 返回添加工作日后的时间
102. * @throws IOException 异常
103. */
104. private LocalDateTime workDayAdd(LocalDateTime startTime, int workdaysToAdd, List vacationList, List workDayList) throws IOException {
105. LocalDateTime result = startTime;
106. // 今年最后一天
107. LocalDateTime lastDayOfYear = LocalDateTime.of(LocalDate.of(startTime.getYear(), 12, 31), LocalTime.MAX);
108. // 循环计算，直到工作日天数为0，或者到了今年最后一天
109. while (workdaysToAdd > 0 && result.isBefore(lastDayOfYear)) {
110. // 判断周一到周五，是否会放假，周六周日是否会补班
111. result = result.plusDays(1);
112. if (workDayNeedToWork(vacationList, result) && holidayNeedToWork(workDayList, result)) {
113. workdaysToAdd--;
114. }
115. }
116. // 如果还有剩余的工作日，就继续往后推
117. if (workdaysToAdd > 0) {
118. // 如果还有剩余的工作日，就继续往后推
119. return jumpWorkDay(result, workdaysToAdd);
120. }
121. return result;
122. }
124. /**
125. * 工作日需要去上班
126. *
127. * @param vacationList 节假日列表
128. * @param date 日期
129. * @return boolean 工作日是否需要上班
130. */
131. private boolean workDayNeedToWork(List vacationList, LocalDateTime date) {
132. DayOfWeek dayOfWeek = date.getDayOfWeek();
133. boolean isWork = dayOfWeek != DayOfWeek.SATURDAY && dayOfWeek != DayOfWeek.SUNDAY;
134. if (isWork) {
135. // 如果是工作日，还需要判断是否会放假
136. LocalDate localDate = LocalDate.from(date);
137. return !vacationList.contains(localDate);
138. }
139. return true;
140. }
142. /**
143. * 周六末需要去补班
144. *
145. * @param workDayList 补班列表
146. * @param date 日期
147. * @return boolean 是否为休息日
148. */
149. private boolean holidayNeedToWork(List workDayList, LocalDateTime date) {
150. DayOfWeek dayOfWeek = date.getDayOfWeek();
151. boolean isHoliday = dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY;
152. if (isHoliday) {
153. // 如果是节假日，还需要判断是否是补班
154. LocalDate localDate = LocalDate.from(date);
155. return workDayList.contains(localDate);
156. }
157. return true;
158. }
161. /**
162. * 获取某个日期所在年份的节假日配置数据，注：节假日指来自官方发布的有假节日，每年底政府公布后同步更新
163. *
164. * @param date 日期
165. * @return boolean
166. */
167. public HolidayResponse getHolidayConfig(LocalDateTime date) throws IOException {
168. // 节假日文件路径
169. String savePath = String.format(FILE_FORMAT, DateUtil.format(date, "yyyy"));
170. try {
171. // 从文件中读取节假日
172. HolidayResponse response = readJsonFromFile(savePath);
173. if (response == null) {
174. String url = "https://apis.tianapi.com/jiejiari/index";
175. // 获取当年的节假日列表
176. Map params = new HashMap<>();
177. params.put("key", tianApiProperties.getKey());
178. params.put("date", DateUtil.format(date, "yyyy-MM-dd"));
179. params.put("type", "1");
180. String formData = httpConnector.fromData(params);
181. String rspBody = httpConnector.doFormPost(url, formData);
182. // 将json转换为对象
183. Gson gson = new Gson();
184. response = gson.fromJson(rspBody, HolidayResponse.class);
185. // 将对象写入文件
186. writeJsonToFile(response, savePath);
187. }
188. return response;
189. } catch (IOException e) {
190. log.error("Error during holiday configuration retrieval : {} , {}", savePath, e.getMessage());
191. }
192. return null;
193. }
195. /**
196. * 将json写入文件
197. *
198. * @param jsonObject jsonObject
199. * @param filePath 文件路径
200. */
201. private void writeJsonToFile(HolidayResponse jsonObject, String filePath) {
202. try {
203. // Create directory if it doesn't exist
204. Path parentDirectory = FileSystems.getDefault().getPath(filePath).getParent();
205. if (parentDirectory != null && !Files.exists(parentDirectory)) {
206. Files.createDirectories(parentDirectory);
207. }
209. try (FileOutputStream fos = new FileOutputStream(filePath)) {
210. ObjectMapper objectMapper = new ObjectMapper();
211. objectMapper.writeValue(fos, jsonObject);
212. log.info("节假日文件写入成功 : {} , {}", filePath, jsonObject);
213. } catch (Exception e) {
214. log.error("节假日文件写入失败 : {} , {}", filePath, e.getMessage());
215. }
216. } catch (IOException e) {
217. log.error("Error creating directory structure: {}", e.getMessage());
218. }
219. }
221. /**
222. * 从文件中读取节假日
223. *
224. * @param filePath 文件路径
225. * @return 节假日
226. */
227. private HolidayResponse readJsonFromFile(String filePath) {
228. try {
229. // Create directory if it doesn't exist
230. Path parentDirectory = FileSystems.getDefault().getPath(filePath).getParent();
231. if (parentDirectory != null && !Files.exists(parentDirectory)) {
232. Files.createDirectories(parentDirectory);
233. }
235. try (FileInputStream fis = new FileInputStream(filePath)) {
236. ObjectMapper objectMapper = new ObjectMapper();
237. return objectMapper.readValue(fis, HolidayResponse.class);
238. } catch (Exception e) {
239. log.error("节假日文件读取失败 : {} , {}", filePath, e.getMessage());
240. }
241. } catch (IOException e) {
242. log.error("Error creating directory structure: {}", e.getMessage());
243. }
244. return null;
245. }
246. }

HttpConnector.java  （不重要，只是发起请求，可替换）

1. package com.xxx.app.common.utils.http;
3. import lombok.Setter;
4. import lombok.extern.slf4j.Slf4j;
5. import org.apache.commons.collections.MapUtils;
6. import org.apache.commons.lang3.StringUtils;
7. import org.apache.http.*;
8. import org.apache.http.client.HttpClient;
9. import org.apache.http.client.methods.HttpGet;
10. import org.apache.http.client.methods.HttpPost;
11. import org.apache.http.client.methods.HttpRequestBase;
12. import org.apache.http.entity.StringEntity;
13. import org.apache.http.entity.mime.HttpMultipartMode;
14. import org.apache.http.entity.mime.MultipartEntityBuilder;
15. import org.apache.http.util.EntityUtils;
16. import org.springframework.stereotype.Service;
18. import javax.annotation.Resource;
19. import java.io.File;
20. import java.io.IOException;
21. import java.util.HashMap;
22. import java.util.Map;
23. import java.util.StringJoiner;
25. /**
26. * @author Jing
27. * @desc http 连接工具类
28. * https json post 请求用 doSSlPostRsp接口
29. */
30. @Setter
31. @Slf4j
32. @Service
33. public class HttpConnector {
35. @Resource
36. private HttpClient httpClient;
38. /**
39. * 转拼接参数
40. *
41. * @param url 接口地址
42. * @param params 参数
43. * @return 拼接后的参数
44. */
45. public String addUrlParam(String url, Map params) {
46. if (MapUtils.isNotEmpty(params)) {
47. StringBuilder sb = new StringBuilder(url);
48. sb.append("?");
49. for (String key : params.keySet()) {
50. sb.append(key).append("=").append(params.get(key)).append("&");
51. }
52. url = sb.substring(0, sb.length() - 1);
53. }
54. return url;
55. }
57. /**
58. * 发送带参数post请求 表单请求头
59. *
60. * @param url 接口地址
61. * @param postJson 传参
62. * @return 响应数据
63. */
64. public String doFormPost(String url, String postJson) throws IOException {
65. HttpPost httpPost = new HttpPost(url);
66. if (postJson != null) {
67. httpPost.setHeader("Accept", "application/json");
68. httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
69. httpPost.setEntity(new StringEntity(postJson, Consts.UTF_8));
70. }
71. Map headers = new HashMap<>();
72. return doRequest(headers, httpPost);
73. }
75. /**
76. * 发送带参数post请求 表单请求头
77. *
78. * @param url 接口地址
79. * @param formData 传参
80. * @return 响应数据
81. */
82. public String doFormPost(String url, Map headers, String formData) throws IOException {
83. HttpPost httpPost = new HttpPost(url);
84. if (formData != null) {
85. httpPost.setHeader("Accept", "application/json");
86. httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
87. httpPost.setEntity(new StringEntity(formData, Consts.UTF_8));
88. }
89. return doRequest(headers, httpPost);
90. }
92. /**
93. * 发送带文件和请求头的post请求
94. *
95. * @param url 接口地址
96. * @param headers 请求头
97. * @param file 文件
98. * @param fileName 文件名
99. * @return 响应数据
100. */
101. public String doPost(String url, Map headers, File file, String fileName) throws IOException {
102. HttpPost httpPost = new HttpPost(url);
103. if (file != null) {
104. httpPost.setEntity(assemblyFileEntity(file, fileName));
105. }
106. return doRequest(headers, httpPost);
107. }
109. /**
110. * 生成文件请求包
111. *
112. * @param file 文件
113. * @return http 请求体
114. */
115. protected HttpEntity assemblyFileEntity(File file, String fileName) {
116. MultipartEntityBuilder build = MultipartEntityBuilder.create();
117. build.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
118. build.addBinaryBody("file", file);
119. build.addTextBody("filename", StringUtils.isBlank(fileName) ? file.getName() : fileName);
120. HttpEntity entity = build.build();
121. return entity;
122. }
124. /**
125. * 发送请求
126. *
127. * @param headers 请求头
128. * @param httpRequest request
129. * @return 响应数据
130. */
131. private String doRequest(Map headers, HttpRequestBase httpRequest) throws IOException {
132. HttpRspBO rspBO = doRequestRsp(headers, httpRequest);
133. return rspBO.getBodyStr();
134. }
137. /**
138. * 发送request 请求
139. *
140. * @param headers
141. * @param httpRequest 注意这个方法需要自己关闭
142. * finally {
143. * httpRequest.releaseConnection();
144. * }
145. * @return 带请求头的响应数据封装
146. */
147. private HttpRspBO doRequestRsp(Map headers, HttpRequestBase httpRequest) throws IOException {
148. if (headers != null) {
149. for (String key : headers.keySet()) {
150. httpRequest.addHeader(key, headers.get(key));
151. }
152. }
153. try {
154. HttpResponse response = httpClient.execute(httpRequest);
155. int statusCode = response.getStatusLine().getStatusCode();
156. if (statusCode == HttpStatus.SC_OK) {
157. HttpRspBO bo = new HttpRspBO();
158. bo.setBodyStr(getEntity(response));
159. HashMap map = new HashMap<>();
160. Header[] rspHeaders = response.getAllHeaders();
161. int i = 0;
162. while (i < rspHeaders.length) {
163. map.put(rspHeaders[i].getName(), rspHeaders[i].getValue());
164. i++;
165. }
166. bo.setHeaders(map);
167. return bo;
168. } else {
169. String entity = getEntity(response);
170. log.info("result msg " + entity);
171. throw new FinMgwException("");
172. }
173. } finally {
174. httpRequest.releaseConnection();
175. }
176. }
179. /**
180. * 解析返回请求体
181. *
182. * @param response 返回参数
183. * @return 字符串类型的请求体
184. */
185. public String getEntity(HttpResponse response) throws IOException {
186. HttpEntity entity = response.getEntity();
187. if (entity == null) {
188. throw new FinMgwException(ResultCodeEnum.HTTP_EXECUTE_EX.getCode(),
189. ResultCodeEnum.HTTP_EXECUTE_EX.getDesc() + ", http response entity is null.");
190. }
191. String result;
192. // 去掉首尾的 ""
193. result = EntityUtils.toString(entity, Consts.UTF_8);
194. String delStr = "\"";
195. if (result.indexOf(delStr) == 0) {
196. result = result.substring(1);
197. }
198. if (result.lastIndexOf(delStr) == result.length() - 1) {
199. result = result.substring(0, result.length() - 1);
200. }
201. return result;
202. }
204. /**
205. * 将参数转换为form data传参
206. *
207. * @param param map集合
208. * @return form data
209. */
210. public String fromData(Map param) {
211. StringJoiner joiner = new StringJoiner("&");
212. for (Map.Entry map : param.entrySet()) {
213. String data = String.format("%s=%s", map.getKey(), map.getValue());
214. joiner.add(data);
215. }
216. return joiner.toString();
217. }
218. }

 使用示例：

application.yml 配置

1. # 天行api
2. tianapi:
3. # API密钥
4. key: xxxxxxxxxxxxxxxxxxxxxxxxxxx

demo 代码：

2. @Slf4j
3. @Service
4. public class Demo {
6. @Resource
7. private TianApiHolidayService tianApiHolidayService;
9. public void get(){
10. LocalDateTime publishTime = LocalDateTime.now()
11. // 计算五个工作日后的日期
12. LocalDateTime deadlineTime = tianApiHolidayService.jumpWorkDay(publishTime, 5);
13. }
15. }

理论上可以扩展很多方法，比如判断当前是否工作日/节假日，减去x个工作日之类的。但不太想写了，暂时用不着。

四、相关依赖

天行API申请：

节假日API接口 - 天行数据TianAPI

代码依赖：

Java 版本 = 1.8 

Maven 版本 = 3.9.2 

涉及maven依赖版本：

3. <dependency>
4. <groupId>org.springframework.bootgroupId>
5. <artifactId>spring-boot-starterartifactId>
6. <version>2.3.4.RELEASEversion>
7. <exclusions>
8. <exclusion>
9. <artifactId>log4j-apiartifactId>
10. <groupId>org.apache.logging.log4jgroupId>
11. exclusion>
12. exclusions>
13. dependency>
14. <dependency>
15. <groupId>org.springframework.bootgroupId>
16. <artifactId>spring-boot-starter-webartifactId>
17. <version>2.3.4.RELEASE<version>
18. dependency>
21. <dependency>
22. <groupId>org.projectlombokgroupId>
23. <artifactId>lombokartifactId>
24. <optional>trueoptional>
25. <version>1.18.16version>
26. dependency>
29. <dependency>
30. <groupId>cn.hutoolgroupId>
31. <artifactId>hutool-allartifactId>
32. <version>5.7.10version>
33. dependency>
36. <dependency>
37. <groupId>com.fasterxml.jackson.coregroupId>
38. <artifactId>jackson-databindartifactId>
39. <version>2.10.2version>
40. dependency>
43. <dependency>
44. <groupId>com.google.code.gsongroupId>
45. <artifactId>gsonartifactId>
46. <version>2.8.9version>
47. dependency>

五、补充

附带上2024年的节假日数据，如果只是要判断2024年的，那直接把文件放在项目目录/.holiday 目录下即可，不需要再申请天行的API接口权限。

或者拿这个去调试代码也可以，但需要保证日期范围在2024年内，否则会自动调用天行API接口获取其他年份的数据。

文件名：2024_holiday.json

1. {
2. "code": 200,
3. "msg": "success",
4. "result": {
5. "update": true,
6. "list": [
7. {
8. "holiday": "1月1号",
9. "name": "元旦节",
10. "vacation": "2023-12-30|2023-12-31|2024-01-01",
11. "remark": "",
12. "wage": "2024-01-01",
13. "start": 0,
14. "now": 0,
15. "end": 2,
16. "tip": "1月1日放假，与周末连休，共三天。",
17. "rest": "2023年12月28日至12月29日请假2天，与周末连休可拼5天小长假。"
18. },
19. {
20. "holiday": "2月10号",
21. "name": "春节",
22. "vacation": "2024-02-10|2024-02-11|2024-02-12|2024-02-13|2024-02-14|2024-02-15|2024-02-16|2024-02-17",
23. "remark": "2024-02-04|2024-02-18",
24. "wage": "2024-02-10|2024-02-11|2024-02-12",
25. "start": 0,
26. "now": 0,
27. "end": 7,
28. "tip": "2月10日至17日放假调休，共8天。2月4日（星期日）、2月18日（星期日）上班。鼓励各单位结合带薪年休假等制度落实，安排职工在除夕（2月9日）休息。",
29. "rest": "2月8日至2月9日请假2天，与春节连休可拼10天长假。"
30. },
31. {
32. "holiday": "4月4号",
33. "name": "清明节",
34. "vacation": "2024-04-04|2024-04-05|2024-04-06",
35. "remark": "2024-04-07",
36. "wage": "2024-04-04",
37. "start": 0,
38. "now": 0,
39. "end": 2,
40. "tip": "4月4日至6日放假调休，共3天。4月7日（星期日）上班。",
41. "rest": "4月3日和4月7日请假2天，与清明节连休可拼5天小长假。"
42. },
43. {
44. "holiday": "5月1号",
45. "name": "劳动节",
46. "vacation": "2024-05-01|2024-05-02|2024-05-03|2024-05-04|2024-05-05",
47. "remark": "2024-04-28|2024-05-11",
48. "wage": "2024-05-01",
49. "start": 0,
50. "now": 0,
51. "end": 4,
52. "tip": "5月1日至5日放假调休，共5天。4月28日（星期日）、5月11日（星期六）上班。",
53. "rest": "4月28日至4月30日请假3天，周六与劳动节连休可拼9天长假。"
54. },
55. {
56. "holiday": "6月10号",
57. "name": "端午节",
58. "vacation": "2024-06-08|2024-06-09|2024-06-10",
59. "remark": "",
60. "wage": "2024-06-10",
61. "start": 0,
62. "now": 0,
63. "end": 2,
64. "tip": "6月10日放假，与周末连休，共3天。",
65. "rest": "6月6日至6月7日请假2天，与端午节连休可拼5天小长假。"
66. },
67. {
68. "holiday": "9月15号",
69. "name": "中秋节",
70. "vacation": "2024-09-15|2024-09-16|2024-09-17",
71. "remark": "2024-09-14",
72. "wage": "2024-09-17",
73. "start": 0,
74. "now": 0,
75. "end": 2,
76. "tip": "9月15日至17日放假调休，共3天。9月14日（星期六）上班。",
77. "rest": "9月13日至9月14日请假2天，与周日连休可拼5天小长假。"
78. },
79. {
80. "holiday": "10月1号",
81. "name": "国庆节",
82. "vacation": "2024-10-01|2024-10-02|2024-10-03|2024-10-04|2024-10-05|2024-10-06|2024-10-07",
83. "remark": "2024-09-29|2024-10-12",
84. "wage": "2024-10-01|2024-10-02|2024-10-03",
85. "start": 0,
86. "now": 0,
87. "end": 6,
88. "tip": "10月1日至7日放假调休，共7天。9月29日（星期日）、10月12日（星期六）上班。",
89. "rest": "9月29日至9月30号请假2天，周六与国庆节连休可拼10天长假。"
90. }
91. ]
92. }
93. }