沈阳至天津端午旅游攻略

6月18日-6月21日 | 3成人出行

一、行前准备

1.1 行程概览

1.2 人员信息

• 出行人数：3成人（含1位60岁以上老人）
• 住宿需求：3人同住一间（家庭房/三人房）
• 酒店：如家华驿精选酒店(天津西南角地铁站店)，275元/晚
• 交通偏好：晕车为主，选择地铁+步行为主

二、大交通费用（高铁）

2.1 去程：沈阳北 → 天津西（调整）

去程费用合计：305 × 3 = ¥915

📌 说明：调整至17:37发车，21:29到达天津西，方便当晚入住酒店

2.2 返程：天津西 → 沈阳北

返程费用合计：242.5 × 3 = ¥727.5

2.3 高铁费用汇总

三、酒店信息

住宿费用：¥275 × 3晚 = ¥825

四、景点门票费用

4.1 门票价格说明

4.2 景点费用汇总（2成人+1老人）

说明：60岁以上老人凭身份证可享受大部分景点免票或优惠政策

五、市内交通费用说明

六、每日行程安排

6.1 Day 1（6月18日 周三）- 出发日

交通费用（3人）：约 ¥3

6.2 Day 2（6月19日 周四）- 五大道历史文化

交通费用（3人）：约 ¥62-77

游览时间：约 8.5 小时

6.3 Day 3（6月20日 周五）- 古韵新貌

交通费用（3人）：约 ¥35-80

游览时间：约 8 小时

6.4 Day 4（6月21日 周六）- 轻松游览+返程

交通费用（3人）：约 ¥24-33

游览时间：约 5 小时

七、市内交通费用汇总

八、总费用汇总

人均费用：约¥1,433/人

九、每日交通路线图

如家华驿精选酒店(西南角地铁站)
        │
        ├── Day 2 ──
        │   ├─→ 五大道（地铁1号线5站）
        │   ├─→ 西开教堂（步行15分钟）
        │   ├─→ 瓷房子（步行15分钟）
        │   ├─→ 张学良故居（步行10分钟）
        │   ├─→ 意式风情区（步行20分钟）
        │   └─→ 天津之眼（步行20分钟）
        │
        ├── Day 3 ──
        │   ├─→ 古文化街（地铁2号线2站）
        │   ├─→ 鼓楼（步行10分钟）
        │   ├─→ 天津博物馆（地铁2号线3站）
        │   ├─→ 世纪钟/解放桥（步行）
        │   ├─→ 津湾广场（步行）
        │   └─→ 意式风情区夜景（步行）
        │
        └── Day 4 ──
            ├─→ 天塔湖（地铁1号线6站）
            ├─→ 意式风情区（地铁+步行）
            └─→ 天津西站返程

十、温馨提示

1. 身份证必备：60岁以上老人享受景点优惠政策需出示身份证
2. 提前购票：端午期间高铁票紧张，建议提前15天购买
3. 天塔湖：登塔可俯瞰天津全景，建议上午游览，光线较好
4. 预约景点：天津博物馆需提前在官方公众号预约
5. 晕车建议：行程以地铁+步行为主，避免长途打车
6. 防暑降温：6月中旬天津较热，注意防晒和补水
7. 舒适鞋子：景区步行较多，建议穿舒适的运动鞋
8. 建议携带：充电宝、遮阳伞、矿泉水、零食

🏨 长春3天2晚完整行程攻略

🚄 往返交通

🏩 酒店住宿

如家华驿酒店（长春东大桥店）

• 价格：223元/晚（含3人入住）
• 2晚合计：446元
• 每天起始和终止均在此酒店

📅 Day 1（05.02 周六）：电影文化·网红商圈·城市休闲

💰 当日花销汇总

• 门票：90×2+60=240元（2成人+1老人）
• 餐饮：180元
• 交通：8元
• 合计：428元

📅 Day 2（05.03 周日）：伪满历史与自然风光

💰 当日花销汇总

• 门票：70×2+35=175元（2成人+1老人）
• 餐饮：210元
• 交通：13元
• 合计：398元

📅 Day 3（05.04 周一）：自然生态与文化体验

💰 当日花销汇总

• 门票：30×2+15=75元（2成人+1老人）
• 餐饮：210元
• 交通：17元
• 合计：302元

📝 景点详细介绍

长影旧址博物馆（门票：90元）

长春电影制片厂是中国电影的摇篮，长影旧址博物馆展示了新中国电影发展的光辉历程和珍贵文物。成人票90元，学生票45元，60-64周岁60元，65周岁以上及1.3米以下儿童免费。

这有山（红旗街商圈）（门票：免费）

集购物、餐饮、娱乐于一体的综合性商业区，是长春市最繁华的商业中心之一。

文化广场（门票：免费）

长春市的重要城市广场，周围有多座历史文化建筑，是市民休闲娱乐的好去处。

伪满皇宫博物院（门票：70元）

伪满洲国时期的皇宫，见证了日本侵略中国东北的历史，是重要的爱国主义教育基地。成人票70元，学生票20元，60-64周岁35元，65周岁以上、军人、残疾人等免费。

北京大街西历史文化街区（门票：免费）

保留了大量民国时期的建筑风格，是了解长春近代历史的重要窗口。

桂林路（门票：免费）

长春市著名的美食街，汇聚了各类特色小吃和餐厅。

南湖公园（门票：免费）

长春市最大的城市公园，湖水碧绿，绿树成荫，是休闲散步的绝佳去处。

净月潭国家森林公园（门票：30元）

被誉为"亚洲最大的人工林海"，风景优美，空气清新，是天然氧吧。成人票30元，优惠票15元（学生、60-65周岁老人），65周岁以上免费。

长春世界雕塑园（门票：免费）

展示世界各地雕塑艺术的主题公园，作品风格多样，艺术价值极高。2025年实行全园免费开放政策。

长春水文化生态园（门票：免费）

以水文化为主题的生态公园，体现了人水和谐的理念。

东北沦陷史陈列馆（门票：免费）

与伪满皇宫相邻，展示东北沦陷时期的历史，是重要的历史教育基地。凭身份证免费入园。

💰 本次长春3天2晚总花销汇总（3人）

📌 温馨提示

1. 门票优惠：各景点对学生、老人、军人等有优惠政策，建议携带有效证件
2. 交通建议：长春地铁网络发达，建议办理交通卡或使用手机支付
3. 最佳季节：5月是长春最佳旅游季节，气候宜人，风景优美
4. 装备建议：带好防晒用品和舒适的运动鞋
5. 预约提醒：伪满皇宫博物院实行分时段预约，建议提前7天在官方小程序预约

前言

🎉 OpenClaw是一款开源免费的AI助手，支持WhatsApp/Telegram/微信等多种聊天平台的自动化。本文将详细介绍如何安装OpenClaw并配置飞书机器人，让你轻松拥有自己的智能助手！

系统要求

• Node 22+（安装脚本会在缺失时自动安装）
• macOS、Linux 或 Windows
• 仅从源码构建时需要 pnpm

注意：在 Windows 上，强烈建议在 WSL2 下运行 OpenClaw。

安装OpenClaw

1、使用安装脚本（推荐）

🚀 安装脚本是安装OpenClaw的推荐方式，它可以一步完成Node检测、安装和初始配置，超级方便！

macOS / Linux / WSL2：

curl -fsSL https://clawd.org.cn/install.sh | bash

Windows (PowerShell)：

iwr -useb https://clawd.org.cn/install.ps1 | iex

执行安装脚本后的界面：

提示：如果想跳过初始配置，只安装二进制文件，可以使用 --no-onboard 参数。

2、使用npm / pnpm安装

如果你已经有Node 22+，并且想自行管理安装：

npm：

npm install -g openclaw-cn@latest

注意：如果遇到sharp构建错误，可以使用环境变量 SHARP_IGNORE_GLOBAL_LIBVIPS=1 强制使用预构建二进制文件。

pnpm：

pnpm add -g openclaw-cn@latest
pnpm approve-builds -g        # 批准 openclaw-cn、node-llama-cpp、sharp 等
openclaw-cn onboard --install-daemon

注意：pnpm 要求显式批准包含构建脚本的包。

3、从源码构建

适用于贡献者或想从本地代码运行的用户：

git clone https://github.com/jiulingyun/openclaw-cn.git
cd openclaw
pnpm install
pnpm ui:build
pnpm build
pnpm link --global
openclaw-cn onboard --install-daemon

验证安装

✅ 安装完成后，验证一切正常运行：

openclaw-cn doctor         # 检查配置问题
openclaw-cn status         # 网关状态
openclaw-cn dashboard      # 打开浏览器管理界面

配置飞书机器人

🤖 现在我们来配置飞书机器人，让OpenClaw能够在飞书中为我们服务！

1、创建飞书应用

1. 打开 飞书开放平台，使用飞书账号登录
2. 点击「创建企业自建应用」，填写应用名称和描述

飞书开放平台创建应用页面：

3. 在应用的「凭证与基础信息」页面，复制 App ID 和 App Secret

凭证与基础信息页面：

4. 在「权限管理」页面，批量导入以下权限配置：

{
  "scopes": {
    "tenant": [
      "aily:file:read",
      "aily:file:write",
      "application:application.app_message_stats.overview:readonly",
      "application:application:self_manage",
      "application:bot.menu:write",
      "cardkit:card:write",
      "contact:user.employee_id:readonly",
      "corehr:file:download",
      "docs:document.content:read",
      "event:ip_list",
      "im:chat",
      "im:chat.access_event.bot_p2p_chat:read",
      "im:chat.members:bot_access",
      "im:message",
      "im:message.group_at_msg:readonly",
      "im:message.group_msg",
      "im:message.p2p_msg:readonly",
      "im:message:readonly",
      "im:message:send_as_bot",
      "im:resource",
      "sheets:spreadsheet",
      "wiki:wiki:readonly"
    ],
    "user": [
      "aily:file:read",
      "aily:file:write",
      "im:chat.access_event.bot_p2p_chat:read"
    ]
  }
}

注意：im:message.group_msg 权限（获取群组中所有消息，属于敏感权限）允许机器人接收群组中所有消息（不仅仅是 @机器人的）。如果需要配置 requireMention: false 让机器人无需 @ 也能响应，则必须添加此权限。

5. 在「应用能力 > 机器人」页面开启机器人能力并配置机器人名称

机器人能力配置页面：

6. 在「事件订阅」页面选择「使用长连接接收事件（WebSocket 模式）」，并添加事件：im.message.receive_v1（接收消息）

事件订阅配置页面：

重要提醒：在配置事件订阅前，请务必确保已完成以下步骤：

• 运行 openclaw-cn channels add 添加了 Feishu 渠道
• 网关处于启动状态（可通过 openclaw-cn gateway status 检查状态）

7. 在「版本管理与发布」页面创建版本并提交审核发布

2、添加飞书渠道

通过命令行添加

🔧 运行以下命令，根据提示粘贴 App ID 和 App Secret：

openclaw-cn channels add

选择 Feishu，然后输入你在第一步获取的凭证即可。

通过配置文件配置

编辑 ~/.openclaw/openclaw.json：

{
  "channels": {
    "feishu": {
      "enabled": true,
      "dmPolicy": "pairing",
      "accounts": {
        "main": {
          "appId": "cli_xxx",
          "appSecret": "xxx",
          "botName": "我的AI助手"
        }
      }
    }
  }
}

通过环境变量配置

export FEISHU_APP_ID="cli_xxx"
export FEISHU_APP_SECRET="xxx"

3、启动并测试

1. 启动网关：

openclaw-cn gateway

2. 发送测试消息

在飞书中找到你创建的机器人，发送一条消息。

3. 配对授权

默认情况下，机器人会回复一个配对码。你需要批准此代码：

openclaw-cn pairing approve feishu <配对码>

批准后即可正常对话。

OpenClaw功能介绍

🌟 OpenClaw作为一款开源免费的AI助手，具有以下强大特点：

• 📱 多平台支持：通过飞书、WhatsApp、Telegram、Discord、Slack 或 iMessage 与它对话
• 🧠 持久记忆：记住你的一切并成为独一无二的你的AI
• 🌐 浏览器控制：可以浏览网页、填写表单、从任何网站提取数据
• 💻 完整系统访问：读写文件、运行Shell命令、执行脚本
• 🧩 技能与插件：使用社区技能扩展或自己构建

管理与维护

🔍 日常管理与维护命令：

查看网关状态

openclaw-cn gateway status

重启网关

openclaw-cn gateway restart

查看实时日志

openclaw-cn logs --follow

打开管理界面

openclaw-cn dashboard

环境变量配置

如果你需要自定义运行时路径，可以使用以下环境变量：

• OPENCLAW_HOME：设置基于主目录的内部路径
• OPENCLAW_STATE_DIR：设置可变状态的存储位置
• OPENCLAW_CONFIG_PATH：设置配置文件位置

常见问题排查

🐛 常见问题及解决方案：

PATH 诊断与修复

快速诊断：

node -v
npm -v
npm prefix -g
echo "$PATH"

如果 $(npm prefix -g)/bin（macOS/Linux）或 $(npm prefix -g)（Windows）不在你的 $PATH 中，Shell 将无法找到全局 npm 二进制文件（包括 openclaw-cn）。

修复 — 将以下内容添加到你的 Shell 启动文件（~/.zshrc 或 ~/.bashrc）：

export PATH="$(npm prefix -g)/bin:$PATH"

在 Windows 上，将 npm prefix -g 的输出添加到 PATH 中。然后打开一个新终端。

总结

🎊 恭喜你完成了 OpenClaw 的安装和飞书机器人的配置！现在你已经拥有了一个功能强大的 AI 助手，可以在飞书中为你提供各种服务。

OpenClaw 不仅支持飞书，还可以与其他多个聊天平台集成，为你带来全方位的 AI 辅助体验。随着你对它的使用，你会发现它越来越了解你，成为你工作和生活中的得力助手。

如果你在使用过程中遇到任何问题，可以查看官方文档或社区论坛获取帮助。祝你使用愉快！

营口+盖州+鲅鱼圈两日游完整行程攻略

🚗 交通方案

沈阳到营口交通：

• 高铁：沈阳站/沈阳北站 → 盖州西站，约1小时，票价约60元/人
• 自驾：沈阳 → 营口，约2.5小时，高速费用约80元

营口地区交通：

• 出租车：起步价6元，适合短途出行
• 公交车：营口地区公交网络发达，票价1-3元，适合长途出行
• 滴滴出行：方便快捷，价格透明
• 自驾：如果是自驾，可自由安排行程

🏩 住宿推荐

汉庭酒店（鲅鱼圈海滨店）

• 价格：140-160元/晚（华住会旗下）
• 位置：鲅鱼圈海滨区域，步行10分钟可达海边
• 特色：华住会旗下品牌，干净整洁，交通便利，靠近公交车站
• 预订建议：通过华住会APP预订可享受会员优惠，价格更实惠

📅 Day 1：沈阳 → 盖州 → 鲅鱼圈

💰 当日花销汇总

• 交通：65元（高铁+当地交通）
• 门票：0元
• 餐饮：150元
• 住宿：150元
• 合计：365元

📅 Day 2：鲅鱼圈 → 营口市区 → 沈阳

💰 当日花销汇总

• 交通：65元（当地交通+高铁）
• 门票：0元
• 餐饮：50元
• 合计：115元

📝 景点详细介绍

盖州古城

• 特色：拥有2000多年历史的古城，保存了许多明清时期的建筑
• 主要景点：钟鼓楼、明清一条街、盖州文庙
• 推荐玩法：漫步古城街道，感受历史文化氛围，品尝当地特色小吃

鲅鱼圈山海广场

• 特色：鲅鱼圈标志性景点，集海景、广场、雕塑于一体
• 主要景点：鲅鱼公主雕塑、观景台、海滨浴场
• 推荐玩法：拍照打卡，海边散步，欣赏日落

月亮湖公园

• 特色：大型综合性公园，融合了海洋文化和现代游乐设施
• 主要景点：水上乐园、儿童游乐区、科普馆
• 推荐玩法：休闲散步，欣赏湖景，适合家庭出游

鲅鱼圈世纪广场

• 特色：鲅鱼圈标志性城市广场，是当地居民休闲娱乐的重要场所
• 主要景点：音乐喷泉、雕塑群、健身区
• 推荐玩法：清晨散步，欣赏广场景观，感受当地生活氛围

辽河老街

• 特色：营口历史文化街区，保留了大量民国时期的建筑
• 主要景点：老字号店铺、民俗博物馆、特色小吃街
• 推荐玩法：逛老街，品尝特色美食，购买纪念品

🍽️ 美食推荐

盖州特色美食

• 盖州羊汤：以新鲜羊肉熬制，汤浓味美
• 盖州火烧：传统面食，外酥里嫩
• 盖州小串：当地特色烧烤，味道独特

鲅鱼圈海鲜

• 鲅鱼圈春华海鲜自助（总店）：
  • 推荐理由：鲅鱼圈最有名的海鲜自助之一，品种丰富，新鲜美味
  • 特色菜品：活虾、飞蟹、扇贝、生蚝等多种海鲜
  • 人均消费：100元左右
  • 地址：鲅鱼圈区昆仑大街中段
  • 预订建议：节假日建议提前预订，避免排队
• 清蒸飞蟹：当地特色，肉质鲜嫩
• 鲅鱼水饺：以新鲜鲅鱼为馅，味道鲜美

营口特色美食

• 营口烧夹子：传统小吃，类似馅饼
• 营口海鲜：新鲜实惠，推荐品尝
• 营口大酱：当地特产，可作为伴手礼

💰 本次两日游总花销汇总

📌 出行建议

1. 最佳出行时间：5-10月，气候适宜，适合海边游玩

2. 必备物品：防晒霜、太阳镜、舒适的鞋子、雨伞

3. 注意事项：

   • 海边游玩注意安全，遵守景区规定
   • 公交车出行建议提前查看班次，避免错过末班车
   • 节假日期间人流量较大，建议提前预订住宿和餐厅
   • 自驾出行注意路况，遵守交通规则

4. 行程调整建议：

   • 如果时间充裕，可增加营口西炮台遗址公园游览
   • 如果喜欢自然风光，可考虑前往盖州赤山风景区
   • 如果带孩子出行，可增加鲅鱼圈熊岳植物园游览

🚌 具体公交车信息

Day 1 公交车信息

1. 盖州西站 → 盖州古城

   • 公交线路：盖州103路
   • 上车地点：盖州西站公交站
   • 下车地点：盖州古城站
   • 票价：2元
   • 运营时间：06:00-18:00
   • 班次间隔：15-20分钟

2. 盖州古城 → 鲅鱼圈山海广场

   • 公交线路：盖州至鲅鱼圈城际公交
   • 上车地点：盖州客运站
   • 下车地点：鲅鱼圈山海广场站
   • 票价：3元
   • 运营时间：06:30-17:30
   • 班次间隔：20-30分钟

Day 2 公交车信息

1. 鲅鱼圈世纪广场 → 营口市区（辽河老街）

   • 公交线路：鲅鱼圈至营口城际公交
   • 上车地点：鲅鱼圈世纪广场站
   • 下车地点：营口辽河老街站
   • 票价：3元
   • 运营时间：06:00-18:00
   • 班次间隔：15-20分钟

2. 辽河老街 → 营口站

   • 公交线路：营口1路
   • 上车地点：辽河老街站
   • 下车地点：营口站
   • 票价：2元
   • 运营时间：06:00-20:00
   • 班次间隔：10-15分钟

希望这份行程攻略能帮助你度过一个愉快的营口+盖州+鲅鱼圈两日游！

RustFS：现代化的分布式文件系统

RustFS是一个用Rust语言开发的高性能分布式文件系统，具有高可靠性、强一致性和出色的性能。本文将详细介绍RustFS的安装、使用方法，以及如何从MinIO迁移到RustFS。

一、RustFS简介

RustFS是基于Rust语言构建的新一代分布式文件系统，它利用Rust的内存安全特性和并发优势，提供了以下核心特性：

• 高性能：采用异步I/O和零拷贝技术，提供出色的读写性能
• 强一致性：实现了严格的一致性模型，确保数据可靠性
• 高可用：支持数据复制和自动故障转移
• 易于扩展：可以轻松添加新节点以扩展存储容量和性能
• 安全：基于Rust的内存安全特性，减少了常见的安全漏洞

二、RustFS安装

官方的安装文档比较全，我这里仅仅是记录下自己安装的过程以及遇到的问题。

2.1 docker-compose部署

我这边是在FnOS系统中使用docker-compose的方式部署的，下面是compose文件内容：

version: "3"

services:
  # RustFS main service
  rustfs:
    image: rustfs/rustfs:latest
    container_name: rustfs
    ports:
      - "19000:9000" # S3 API port
      - "19001:9001" # Console port
    environment:
      - RUSTFS_ADDRESS=0.0.0.0:9000
      - RUSTFS_CONSOLE_ADDRESS=0.0.0.0:9001
      - RUSTFS_CONSOLE_ENABLE=true
      - RUSTFS_EXTERNAL_ADDRESS=:9000 # Same as internal since no port mapping
      - RUSTFS_CORS_ALLOWED_ORIGINS=*
      - RUSTFS_CONSOLE_CORS_ALLOWED_ORIGINS=*
      - RUSTFS_ACCESS_KEY=rustfsadmin
      - RUSTFS_SECRET_KEY=rustfsadmin
      - RUSTFS_OBS_LOGGER_LEVEL=info
      - RUSTFS_TLS_PATH=/opt/tls
      - RUSTFS_OBS_ENDPOINT=http://otel-collector:4317
    volumes:
      - ./data:/data
      - ./logs:/app/logs
    # restart: unless-stopped
    healthcheck:
      test:
        [
          "CMD",
          "sh", "-c",
          "curl -f http://localhost:9000/health && curl -f http://localhost:9001/rustfs/console/health"
        ]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

2.2 启动报错（"Permission denied"）

通过GitHub上的issues找到了解决方法，将数据和日志目录的所有者更改为10001。

进到所在目录，执行下面的命令：

# 修改前检查
ls -l
# 修改
chown -R 10001:10001 data/ logs/
# 修改后确认
ls -l

命令执行过程：

参考地址：Operator Managed Cluster fails to run · Issue #987 · rustfs/rustfs · GitHub

2.3 部署后确认

docker启动后无报错，在浏览器输入 http://192.168.188.2:19001/

出现这个说明安装成功，账号/密码：rustfsadmin/rustfsadmin

三、从MinIO迁移到RustFS

5.1 迁移准备

1. 确保RustFS服务已正常运行
2. 安装MinIO客户端 mc
3. 备份MinIO数据（建议）

5.2 迁移方法

使用以下命令迁移：

# 使用mc客户端同步数据
mc alias set minio http://minio-server:9000 minioadmin minioadmin
mc alias set rustfs http://rustfs-server:19000 rustfsadmin rustfsadmin

# 同步数据
mc mirror --recursive minio/my-bucket rustfs/my-bucket

rustfs/my-bucket 要先在rustfs中建好存储桶my-bucket

5.3 迁移验证

# 验证文件数量
echo "MinIO文件数量："
mc ls --recursive minio/my-bucket | wc -l

echo "RustFS文件数量："
rishfs ls --recursive /minio-migrated/ | wc -l

# 验证文件完整性（随机选择几个文件）
mc cat minio/my-bucket/path/to/file.txt | md5sum
rishfs get /minio-migrated/path/to/file.txt - | md5sum

也可以通过web查看确认

四、总结

RustFS是一个功能强大、性能出色的分布式文件系统，适用于各种规模的存储需求。通过本文的介绍，您应该已经掌握了RustFS的安装、配置、使用以及从MinIO迁移数据的方法。

🔥 为什么需要双开微信？

在这个数字化时代，我们常常需要在工作和生活之间切换。一个微信账号用于工作沟通，一个用于私人聊天，这种分离能让我们更好地平衡工作与生活。但Mac系统默认只允许运行一个微信实例，这给很多用户带来了不便。今天，我将教你3种简单高效的方法，让你在Mac上轻松双开微信！

📋 前置准备

在开始之前，请确保你已经：

• 安装了微信官方应用（可从微信官网下载）
• 具备基本的终端操作知识
• 拥有管理员权限（需要使用sudo命令）

🚀 双开步骤

下面的主要步骤都是在终端中执行的

🔍 步骤1：检查系统是否已安装 PlistBuddy

ls -l /usr/libexec/PlistBuddy

如果返回类似下图的文件信息，则说明PlistBuddy已安装，直接跳至步骤3

🛠️ 步骤2：安装 Xcode 命令行工具

xcode-select --install

执行后会弹出安装窗口，按照提示完成安装即可。

📁 步骤3：复制微信应用

sudo cp -R /Applications/WeChat.app /Applications/WeChat2.app

执行成功后，在「应用程序」文件夹中会出现一个名为 WeChat2.app 的新应用

🔧 步骤4：修改 Bundle Identifier（关键步骤）

sudo /usr/libexec/PlistBuddy -c "Set :CFBundleIdentifier com.tencent.xinWeChat2" /Applications/WeChat2.app/Contents/Info.plist

这行命令将 WeChat2.app 的 Bundle Identifier 改为 com.tencent.xinWeChat2，这是双开成功的关键！

📚 科普：什么是 Bundle Identifier？

Bundle Identifier（简称 Bundle ID 或 包名）是 Apple 生态系统中用来唯一标识应用程序的字符串，相当于应用的「身份证号码」。

🔑 核心特性

• 唯一性：整个 App Store 中，任何两个应用都不能有相同的 Bundle ID
• 命名规则：通常采用反向域名表示法，如 com.company.appname

🎯 主要用途

• 系统识别：帮助 macOS 区分不同应用的数据和沙盒环境
• 功能关联：推送通知、iCloud 同步等功能都需要与特定 Bundle ID 绑定
• 版本跟踪：Apple 用它来识别和跟踪应用的每个版本

✅ 步骤5：重新签名 WeChat2.app

sudo codesign -vv --deep --strict /Applications/WeChat2.app

这一步确保修改后的应用能够被系统信任并正常运行。

⚠️ 警告与注意事项

🔒 安全提示

• 谨慎使用sudo命令：sudo命令赋予你管理员权限，执行错误可能导致系统问题，请仔细核对命令后再执行
• 仅使用官方微信：请确保从微信官网下载微信，避免使用第三方修改版
• 保护隐私：双开后两个微信账号的数据是隔离的，但仍需注意保护个人隐私

📱 版本更新处理

• 当微信官方发布新版本时，你需要：
  1. 先更新原微信（WeChat.app）
  2. 重复上述步骤3-5，重新创建和签名WeChat2.app
  3. 旧的WeChat2.app可以直接删除

🗑️ 如何卸载双开微信

如果不再需要双开功能，可按照以下步骤彻底卸载：

# 删除复制的微信应用
sudo rm -rf /Applications/WeChat2.app

🎉 使用方法

1. 打开「应用程序」文件夹
2. 同时或分别点击「WeChat.app」和「WeChat2.app」
3. 分别登录不同的微信账号
4. 享受高效的双开体验！

💡 小贴士：你可以将两个微信应用都拖到 Dock 栏，方便快速访问

📚 相关推荐

🔗 扩展阅读

• Mac终端入门指南 - Apple官方终端使用教程
• macOS安全最佳实践 - 保护你的Mac安全
• 微信官方帮助中心 - 微信常见问题解答

💡 其他Mac实用技巧

• 如何在Mac上录制屏幕 - 内置屏幕录制功能使用
• Mac电池优化指南 - 延长电池使用寿命
• 如何清理Mac存储空间 - 释放宝贵的磁盘空间

🚀 更多应用双开方法

• 使用第三方工具：如OpenInTerminal等工具可以简化双开操作
• 创建别名：通过终端别名快速执行双开命令
• 使用Automator：创建自动化工作流实现一键双开

📝 常见问题解答

Q: 双开微信会被封号吗？

A: 目前微信官方并没有明确禁止在同一设备上登录多个账号，只要你遵守微信使用条款，正常使用不会被封号。

Q: 双开后会影响微信的正常功能吗？

A: 不会，两个微信账号的功能完全独立，互不影响。

Q: 可以三开或更多微信账号吗？

A: 理论上可以，只需按照相同步骤创建更多副本（WeChat3.app, WeChat4.app等），并使用不同的Bundle ID即可。

📌 总结

通过本文的5个简单步骤，你已经学会了如何在Mac上轻松双开微信：

1. 检查PlistBuddy：确认系统是否已安装必要工具
2. 安装Xcode命令行工具：（如有需要）安装系统开发工具
3. 复制微信应用：创建微信的第二个副本
4. 修改Bundle ID：关键步骤，赋予新应用唯一标识
5. 重新签名：确保应用能被系统信任

🌟 写在最后

双开微信能帮助你更好地平衡工作与生活，提高沟通效率。希望本文对你有所帮助！如果你在操作过程中遇到任何问题，欢迎在评论区留言交流。

📢 温馨提示：技术在不断发展，本文方法可能会随系统更新而变化。建议收藏本文，以便后续查阅最新内容。

感谢阅读，祝你使用愉快！🎉

在日常Java开发中，NullPointerException（NPE）是我们最常遇到的运行时异常之一。特别是字符串操作时，一不小心就会掉进NPE的陷阱。今天就来彻底剖析这些隐藏的坑点，让你的代码更加健壮！

🔥 最经典的陷阱：a.equals(b)

String a = null;
String b = "hello";

// 这是NPE的经典场景！
a.equals(b); // 抛出 NullPointerException

真相揭秘：

• a 可以为null，但调用方法时会抛出NPE

• b 可以为null，通常返回 false（前提是a不为null）

安全写法：

// 方法1：让常量在前（推荐）
"hello".equals(a); // 安全，a为null时返回false

// 方法2：使用Objects.equals（最安全）
Objects.equals(a, b); // 两者都为null时返回true

// 方法3：显式null检查
if (a != null) {
    a.equals(b);
}

💥 更大的陷阱：a.contains(b)

你以为equals已经很坑了？contains更是坑中之王！

String a = null;
String b = "hello";

a.contains(b); // NPE！

String c = "hello";
String d = null;

c.contains(d); // 还是NPE！

残酷真相：

• a 不能为null → NPE

• b 不能为null → NPE

• 两个参数都不能为null！

安全方案：

// 自定义安全方法
public static boolean safeContains(String str, String searchStr) {
    return str != null && searchStr != null && str.contains(searchStr);
}

// 使用工具类
StringUtils.contains(a, b); // Apache Commons Lang

🚨 字符串操作中的NPE地雷阵

下面这些方法，只要调用者为null，统统NPE！

比较相关

String str = null;
str.compareTo("abc");       // 💥 NPE
str.compareToIgnoreCase("abc"); // 💥 NPE
str.contentEquals("abc");   // 💥 NPE

查找相关

str.indexOf("a");           // 💥 NPE
str.lastIndexOf("a");       // 💥 NPE  
str.startsWith("a");        // 💥 NPE
str.endsWith("a");          // 💥 NPE

操作相关

str.substring(1);           // 💥 NPE
str.charAt(0);              // 💥 NPE
str.length();               // 💥 NPE
str.trim();                 // 💥 NPE
str.toUpperCase();          // 💥 NPE

正则相关

str.matches("regex");       // 💥 NPE
str.replaceAll("a", "b");   // 💥 NPE
str.split(",");             // 💥 NPE

空检查（讽刺吧？）

str.isEmpty();              // 💥 NPE
str.isBlank();              // 💥 NPE

🛡️ 全方位防御方案

方案1：Objects工具类（JDK原生）

import java.util.Objects;

Objects.equals(a, b);              // 比较安全
Objects.toString(str, "default");  // 转字符串安全

方案2：Apache Commons Lang

import org.apache.commons.lang3.StringUtils;

StringUtils.equals(a, b);          // 比较安全
StringUtils.contains(a, b);        // 包含检查安全
StringUtils.isEmpty(a);            // 空检查安全
StringUtils.isBlank(a);            // 空白检查安全

方案3：防御性编程模式

// 三元运算符
String safeStr = (str != null) ? str : "";
boolean result = safeStr.contains("abc");

// Optional优雅处理
Optional.ofNullable(str)
    .map(s -> s.contains("abc"))
    .orElse(false);

// 提前返回
if (str == null) {
    return false; // 或抛出业务异常
}
return str.contains("abc");

方案4：静态代码分析工具

• SonarQube：检测潜在的NPE风险

• SpotBugs：静态分析找出NPE问题

• IDEA Inspections：IDE自动提示

📊 最佳实践总结

💡 终极建议

1. 养成习惯：总是考虑参数为null的情况

2. 使用工具：优先选择null安全的工具类

3. 代码审查：将NPE风险纳入代码审查清单

4. 单元测试：覆盖null边界情况的测试用例

记住：在Java世界里，唯一不会抛出NPE的字符串方法，就是你没有在null上调用的那个方法！

思考题：你的项目中还有哪些隐藏的NPE陷阱？欢迎在评论区分享交流！

问题背景

在日常开发过程中，我们经常会遇到这样的情况：不小心将包含敏感信息的文件提交到了Git仓库中。这些敏感文件可能包括：

• 配置文件：包含数据库密码、API密钥、服务器地址等
• 环境变量文件：如 .env 文件，包含各种环境配置和密钥
• 证书文件：SSL证书、私钥文件等
• 日志文件：可能包含用户信息或系统敏感数据
• 临时文件：包含调试信息或测试数据的文件

一旦这些文件被提交到Git仓库，即使后续删除了这些文件，它们仍然会存在于Git的历史记录中。这意味着：

1. 安全风险：任何有权访问仓库的人都可以通过Git历史查看这些敏感信息
2. 合规问题：可能违反公司的安全政策或法规要求
3. 持续暴露：即使在后续提交中删除了文件，历史记录中仍然存在
4. 克隆风险：每次克隆仓库时，这些敏感信息都会被下载

因此，仅仅删除文件是不够的，我们需要从Git的整个历史记录中彻底清除这些敏感文件的所有痕迹。

图1：Git历史记录中残留的敏感文件示意图

解决方案

💡 Windows 用户特别说明：本文所有命令均在 Windows 环境下测试通过。建议使用 PowerShell 或 Git Bash 执行命令。如果使用 CMD，某些命令可能需要调整语法。

方法一：使用 git filter-branch

git filter-branch 是Git内置的工具，可以重写Git历史记录。

删除特定文件

# 从所有提交中删除指定文件
git filter-branch --force --index-filter \
  'git rm --cached --ignore-unmatch path/to/sensitive-file.txt' \
  --prune-empty --tag-name-filter cat -- --all

图2：git filter-branch 命令执行过程示意图

删除包含敏感信息的目录

# 删除整个目录
git filter-branch --force --index-filter \
  'git rm -r --cached --ignore-unmatch sensitive-directory/' \
  --prune-empty --tag-name-filter cat -- --all

清理和强制推送

# 清理引用
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

# 强制推送到远程仓库
git push origin --force --all
git push origin --force --tags

方法二：使用 BFG Repo-Cleaner

BFG Repo-Cleaner 是一个专门用于清理Git仓库的工具，比 git filter-branch 更快更简单。

安装 BFG

# Windows 用户推荐方法：直接下载 JAR 文件
# 使用 PowerShell 下载
Invoke-WebRequest -Uri "https://repo1.maven.org/maven2/com/madgag/bfg/1.14.0/bfg-1.14.0.jar" -OutFile "bfg.jar"

# 或使用 curl (如果已安装)
curl -L -o bfg.jar https://repo1.maven.org/maven2/com/madgag/bfg/1.14.0/bfg-1.14.0.jar

# macOS 用户可使用 Homebrew
brew install bfg

Windows 注意：确保已安装 Java 8 或更高版本。可通过 java -version 检查。

使用 BFG 删除文件

# 克隆一个裸仓库
git clone --mirror https://github.com/username/repo.git

# 删除特定文件
java -jar bfg.jar --delete-files sensitive-file.txt repo.git

# 或删除包含特定文本的文件
java -jar bfg.jar --delete-files "*.{env,config}" repo.git

# 删除大于指定大小的文件
java -jar bfg.jar --strip-blobs-bigger-than 50M repo.git

图3：BFG Repo-Cleaner 清理敏感文件的工作流程

图4：在 Windows PowerShell 中执行 BFG 命令的截图示例

清理和推送

cd repo.git
git reflog expire --expire=now --all && git gc --prune=now --aggressive
git push

方法三：使用 git filter-repo

git filter-repo 是现代化的替代方案，推荐用于复杂的仓库清理任务。

安装 git filter-repo

# Windows 用户推荐使用 pip 安装
pip install git-filter-repo

# 如果使用 Python 3，可能需要使用 pip3
pip3 install git-filter-repo

# macOS 用户可使用 Homebrew
brew install git-filter-repo

# Windows 用户也可以手动安装
# 1. 下载 git-filter-repo 脚本
# 2. 将其放在 PATH 环境变量包含的目录中

Windows 特别提醒：

• 确保 Python 和 pip 已正确安装并添加到 PATH 环境变量
• 在 PowerShell 中执行 python --version 和 pip --version 验证安装
• 如果遇到权限问题，可能需要以管理员身份运行 PowerShell

删除文件和目录

# 删除特定文件
git filter-repo --path path/to/sensitive-file.txt --invert-paths

# 删除多个文件
git filter-repo --path sensitive-file1.txt --path sensitive-file2.txt --invert-paths

# 删除目录
git filter-repo --path sensitive-directory/ --invert-paths

# 使用正则表达式删除文件
git filter-repo --path-regex '.*\.env$' --invert-paths

图5：git filter-repo 命令执行效果对比图

替换敏感内容

# 替换文件中的敏感文本
git filter-repo --replace-text replacements.txt

其中 replacements.txt 文件内容示例：

password123==>***REMOVED***
api_key_abc123==>***REMOVED***
regex:secret_[a-zA-Z0-9]+==>***REMOVED***

注意事项

⚠️ 重要警告

1. 备份仓库：在执行任何历史重写操作之前，务必备份整个仓库

   # Windows PowerShell 中执行
   git clone --mirror original-repo.git backup-repo.git
   
   # 或者直接复制整个项目文件夹作为备份
   Copy-Item -Path "C:\path\to\your\repo" -Destination "C:\path\to\backup\repo" -Recurse
   

2. 团队协调：历史重写会改变所有提交的SHA值，需要通知所有团队成员重新克隆仓库

3. 强制推送风险：使用 --force 推送会覆盖远程仓库，确保团队成员已保存本地更改

操作步骤建议

1. 先在本地测试：在本地副本上测试清理操作，确认效果后再应用到主仓库

2. 检查清理结果：

   # 检查文件是否完全删除
   git log --all --full-history -- path/to/sensitive-file.txt
   
   # Windows PowerShell 中搜索残留内容
   git grep -i "sensitive_keyword" $(git rev-list --all)
   
   # 如果上述命令在 PowerShell 中出现问题，可使用：
   git rev-list --all | ForEach-Object { git grep -i "sensitive_keyword" $_ }
   

   
   图6：验证敏感文件是否完全清除的命令执行结果

3. 通知团队成员：

   # 团队成员需要执行的操作（Windows/Linux/macOS 通用）
   git fetch origin
   git reset --hard origin/main
   git clean -fd
   

🖥️ Windows 环境特殊注意事项

图7：Windows 环境下的必要配置检查界面

1. 路径分隔符：Windows 使用反斜杠 \\，但 Git 命令中建议使用正斜杠 /

   # 推荐写法（跨平台兼容）
   git filter-branch --index-filter 'git rm --cached --ignore-unmatch config/database.yml'
   
   # 避免使用（Windows 特有）
   git filter-branch --index-filter 'git rm --cached --ignore-unmatch config\\database.yml'
   

   
   图8：Windows 下路径分隔符的正确使用方式

2. PowerShell 执行策略：如果遇到脚本执行限制，可临时调整：

   # 查看当前执行策略
   Get-ExecutionPolicy
   
   # 临时允许脚本执行（管理员权限）
   Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
   

   
   图9：PowerShell 执行策略设置界面截图

3. 长路径支持：Windows 默认路径长度限制为 260 字符，可能影响深层目录操作：

   # 启用长路径支持
   git config --global core.longpaths true
   

4. 文件权限：Windows 文件权限与 Unix 系统不同，某些操作可能需要管理员权限

性能考虑

• 大型仓库：对于大型仓库，推荐使用 git filter-repo 或 BFG，性能更好
• 网络带宽：强制推送会重新上传整个仓库历史，注意网络带宽消耗
• 存储空间：清理后的仓库大小会显著减小，但需要时间进行垃圾回收

总结

清除Git历史中的敏感文件是一个需要谨慎处理的操作。本文所有方法均在 Windows 环境下验证可行，Windows 用户可以放心使用。

根据不同的场景，可以选择合适的工具：

• git filter-branch：Git内置工具，适合简单的文件删除操作，Windows 兼容性最好
• BFG Repo-Cleaner：专业的清理工具，操作简单，性能优秀，需要 Java 环境
• git filter-repo：现代化的解决方案，功能强大，推荐用于复杂场景，需要 Python 环境

Windows 用户推荐流程

图10：Windows 用户清除 Git 敏感文件的完整操作流程图

1. 环境准备：确保 Git、Java（BFG需要）、Python（filter-repo需要）已正确安装
2. 选择工具：新手推荐 BFG，高级用户推荐 git filter-repo
3. 使用 PowerShell：推荐使用 PowerShell 而非 CMD 执行命令
4. 路径格式：统一使用正斜杠 / 作为路径分隔符

三种方法对比表

最佳实践

1. 预防为主：使用 .gitignore 文件防止敏感文件被提交
2. 定期检查：定期审查仓库中的文件，及时发现问题
3. 权限管理：合理设置仓库访问权限，限制敏感信息的暴露范围
4. 自动化检测：使用工具如 git-secrets 或 truffleHog 自动检测敏感信息

记住，一旦敏感信息被推送到公共仓库，就应该立即更换相关的密钥、密码等凭据，因为无法保证没有人已经获取了这些信息。

Java 事务回滚详解：@Transactional 注解中 rollbackFor 和 rollbackOn 的区别与使用

在日常 Java 开发中，事务控制是保障数据一致性的关键手段。Spring 为我们提供了非常强大的声明式事务管理方式，通过简单地使用 @Transactional 注解，就可以实现事务控制。但是在使用过程中，很多人对事务的“回滚时机”理解并不清晰，尤其是 rollbackFor 和 rollbackOn 的使用。

本篇博客将全面解析这两个参数的意义、使用场景、以及常见误区。

一、什么是事务回滚？

事务回滚指的是：当执行过程中发生异常时，之前对数据库所做的更改全部撤销，数据库状态恢复到事务开始前的状态。这是数据库“原子性”原则的体现。

二、Spring 中的 @Transactional 默认行为

在 Spring 中，使用注解方式开启事务非常简单：

@Transactional
public void doSomething() {
    // 执行数据库操作
}

此时的默认行为是：

• 事务会在方法成功执行后提交；
• 遇到 RuntimeException 或 Error，会自动回滚；
• 遇到 Checked Exception（即编译时异常），不会自动回滚。

例如：

@Transactional
public void test1() {
    throw new RuntimeException(); // ✅ 会回滚
}

@Transactional
public void test2() throws Exception {
    throw new Exception(); // ❌ 不会回滚
}

三、使用 rollbackFor 让事务回滚受检异常

如果你希望事务在任何异常发生时都回滚，包括受检异常，比如 IOException、SQLException，就需要显式指定：

@Transactional(rollbackFor = Exception.class)
public void test3() throws Exception {
    throw new Exception(); // ✅ 会回滚
}

• rollbackFor 的值可以是一个或多个异常类；
• 你可以根据需要选择只对某些异常类型回滚，其他的则不回滚。

四、rollbackFor 和 rollbackOn 的区别

| 特性 | rollbackFor | rollbackOn |
| —– | ———————————————————- | ——————————— |
| 适用范围 | Spring | Java EE / JTA |
| 包名 | org.springframework.transaction.annotation.Transactional | javax.transaction.Transactional |
| 默认行为 | 回滚 RuntimeException | 不回滚任何异常 |
| 明确配置后 | 可回滚任何指定异常 | 可回滚任何指定异常 |

示例比较：

Spring 中的写法：

import org.springframework.transaction.annotation.Transactional;

@Transactional(rollbackFor = Exception.class)
public void springTransaction() throws Exception {
    throw new Exception("测试受检异常");
}

JTA（Java EE）中的写法：

import javax.transaction.Transactional;

@Transactional(rollbackOn = Exception.class)
public void jtaTransaction() throws Exception {
    throw new Exception("测试受检异常");
}

注意：使用的是不同的注解类，不能混用！

五、常见误区

❌ 误区1：以为所有异常都会触发事务回滚

Spring 默认只回滚 RuntimeException，不会回滚 Exception（受检异常）。这是导致事务未回滚的最常见原因。

❌ 误区2：以为 @Transactional 可以应用于任何方法

只有被 Spring 容器管理（即被 Spring 扫描并代理）的类中的 public 方法，@Transactional 才有效。如果你在 private 方法上加了注解，是不会生效的。

❌ 误区3：使用错误的注解类

Spring 和 JTA 的 @Transactional 注解来自不同的包，使用时务必导入正确：

• Spring: org.springframework.transaction.annotation.Transactional
• JTA: javax.transaction.Transactional

六、小结

常见问题与解决方式

| 问题 | 默认行为 | 解决方式 |
| ————- | —————————– | ——————————————————————————— |
| 事务不回滚受检异常 | ❌ 不回滚 | ✅ 添加 rollbackFor = Exception.class（Spring）或 rollbackOn = Exception.class（JTA） |
| 事务注解不生效 | ❌ 方法不是 public，类未被 Spring 管理 | ✅ 保证类被 Spring 扫描，方法为 public |
| 导入错误注解 | ❌ 使用了错误的 @Transactional 注解 | ✅ 使用正确包名下的注解（见下表） |

Spring 与 JTA 的 @Transactional 对比

| 特性 | Spring | JTA（Java EE） |
| —— | ———————————————————- | ——————————— |
| 注解类全名 | org.springframework.transaction.annotation.Transactional | javax.transaction.Transactional |
| 默认回滚行为 | 回滚 RuntimeException，不回滚 Exception | 不回滚任何异常 |
| 控制参数 | rollbackFor, noRollbackFor 等 | rollbackOn, dontRollbackOn |
| 常见场景 | Spring Boot, Spring MVC 项目 | Java EE, Jakarta EE 应用服务器项目 |
| 建议用法 | 用 Spring 的事务注解为主 | 仅在 Java EE 项目中使用 |

七、结语

事务控制是保障系统数据一致性的重要手段，理解事务的回滚机制尤为重要。在实际开发中，推荐明确指定异常回滚策略，避免因受检异常不回滚而造成数据异常。

希望这篇文章能帮你在开发中更精准地使用 @Transactional，写出更健壮、可控的代码。如果你有更多问题，欢迎留言讨论！

🏨 青岛五日游完整行程攻略

🏩 酒店住宿

海滨花园大酒店

• 价格控制在200元/晚
• 每天起始和终止均在此酒店

📅 Day 1：青岛经典海滨与市区文化游

💰 当日花销汇总

• 门票：40元
• 餐饮：80元
• 交通：115元
• 合计：235元

📅 Day 2：青岛文化街区与购物小店

💰 当日花销汇总

• 门票：0元
• 餐饮：80元
• 交通：55元
• 合计：135元

📅 Day 3：青岛山海风光探秘

💰 当日花销汇总

• 门票：0元
• 餐饮：80元
• 交通：90元
• 合计：170元

📅 Day 4：极地海洋与主题乐园体验

💰 当日花销汇总

• 门票：300元
• 餐饮：80元
• 交通：135元
• 合计：515元

📅 Day 5：乡村风情与文化深度游

💰 当日花销汇总

• 门票：0元
• 餐饮：80元
• 交通：110元
• 合计：190元

📝 景点详细介绍

栈桥（23）

青岛的标志性建筑，始建于1892年，是青岛最早的码头。桥上可以观赏海景与青岛老城区风光。

八大峡（17）

著名的海滨风景区，以奇石、峭壁和大海闻名，是徒步和摄影的好地方。

第一海水浴场（8）

青岛最早开放的海水浴场，拥有细腻的沙滩和清澈的海水，夏季非常适合游泳。

信号山公园山顶（6）

登顶后可以俯瞰整个青岛市区和海岸线，风景壮观。

小鱼山公园山顶（5）

一处历史悠久的公园，山顶的望海亭是观赏青岛老城风光的好去处。

中山公园太平山观光索道（14）

索道连接中山公园和太平山，乘坐可俯瞰城市风光，适合轻松游览。

良友书坊（27）

青岛的独立书店，文化氛围浓厚，适合文艺青年静心阅读。

五仁杂货铺（25）

一间充满怀旧气息的小店，售卖各种有趣的小物件。

小麦岛公园（41）

滨海公园，环境优美，是散步和休闲的好去处。

年代coffee（20）

当地受欢迎的咖啡馆，提供各类特色咖啡和甜点。

拜泉路20号（31）

历史街区，保留了许多老青岛的建筑风格。

友客便利店(嘉定路店)（30）

便捷的购物点，适合补充日常用品。

琴屿路（22）

安静的街道，适合拍照和散步。

第三海水浴场（16）

青岛著名的海水浴场之一，环境优美，适合游泳和晒太阳。

太平角四路19号（3） / 太平角六路5号（29）

历史建筑区，体现青岛的德式建筑风格。

黄县路（9） / 金口一路（10） / 金口三路(猫猫台阶)（11）

老城区特色街道，适合感受青岛老城区生活氛围。

极地海洋公园（2）

大型海洋主题公园，有企鹅、海豚表演等多种海洋生物展览。

方特梦幻王国（38）

大型主题乐园，适合家庭和年轻人，设施丰富。

胶州湾水库（7）

自然风景区，环境幽静，适合短途郊游。

灵山湾生态湿地公园（35）

自然保护区，鸟类繁多，是生态旅游胜地。

老城区（19）

青岛最古老的城区，建筑保留了众多德式风格。

胶州市中心步行街（28）

商业街区，购物和美食聚集地。

💰 本次青岛五日游总花销汇总

阜新一日游详细行程规划（打车出行 · 起止点：阜新站）

🕘 出发时间：上午 9:30 到达阜新站
🕕 返回时间：预计晚上 19:20 返回阜新站

🚗 行程总览

💰 总打车费用：约 82 元
🕓 总游玩+交通时间：约 8.5 小时（含吃饭）

📍 景点详情（含时间段）

1️⃣ 阜新市博物馆 （09:30 ~ 10:30）

• 综合性地方博物馆，包含历史、民族、地质文物等。
• ⏰ 建议游玩：1 小时
• 💵 门票：免费

2️⃣ 细河公园 （10:40 ~ 11:20）

• 沿细河建设的城市生态带，适合休闲漫步。
• ⏰ 建议游玩：40 分钟
• 💵 门票：免费

🍽️ 午餐：满堂春小馆（11:30 ~ 12:10）

• 📍 细河东街与解放大街交口附近
• 🍜 地三鲜、小鸡炖蘑菇、酸菜五花肉
• 💵 人均：30 ~ 40 元

3️⃣ 阜新玛瑙文化博物馆 （12:20 ~ 13:20）

• 中国独一无二的玛瑙主题展馆。
• ⏰ 建议游玩：1 小时
• 💵 门票：免费

4️⃣ 海州露天矿国家矿山公园 （13:30 ~ 15:00）

• 中国最大的露天煤矿之一，可俯瞰矿坑全貌。
• ⏰ 建议游玩：1.5 小时
• 💵 门票：免费（内部观光车如使用约 10 元）

5️⃣ 三一八公园 （15:10 ~ 15:50）

• 纪念三一八工人起义的主题红色教育公园。
• ⏰ 建议游玩：40 分钟
• 💵 门票：免费

6️⃣ 海州庙 （16:00 ~ 16:30）

• 历史悠久的庙宇，融合地方信仰文化。
• ⏰ 建议游玩：30 分钟
• 💵 门票：免费

7️⃣ 人民公园 （16:40 ~ 17:20）

• 阜新市内老牌综合性市民公园，树木繁茂、设施完备。
• ⏰ 建议游玩：40 分钟
• 💵 门票：免费

🍽️ 晚餐：老八味馆（17:30 ~ 18:10）

• 📍 人民公园北门附近
• 🍜 铁锅炖排骨、东北大拉皮、锅包肉
• 💵 人均：40 ~ 50 元

8️⃣ 解放广场 （18:20 ~ 18:40）

• 市中心地标，适合拍照与短暂停留。
• ⏰ 建议游玩：20 分钟
• 💵 门票：免费

9️⃣ 玉龙公园 （18:50 ~ 19:10）

• 自然景观丰富，适合散步、划船等休闲活动。
• ⏰ 建议游玩：20 分钟
• 💵 门票：免费

🔁 返回阜新站（19:10 ~ 19:20）

📝 注意事项

• 🧴 建议携带水、充电宝、防晒霜
• 📱 建议使用高德或滴滴打车
• ☔ 若遇雨天可适度压缩户外景点时间

问题描述

本次出现的问题如标题所示，在往GitHub提交代码时提交失败了，完整的信息如下：

fatal: unable to access 'https://github.com/GitHub用户名/仓库名.git/': Failed to connect to github.com port 443 after 21112 ms: Couldn't connect to server

问题思考

我们正常在提交代码或者拉取代码时默认会使用HTTPS的形式，如下面似的：

但是这种情况下经常会出现连接失败的情况，这时候我们可以考虑下第二种方法，使用SSH

这种方式下，提交代码和拉取代码的成功率还是提高的，至少我这边基本就没失败过。

解决办法

GitHub配置页面进入方式

上面的是我已经配置好的情况，下面我将带着大家完成这个配置过程

正常未配置时，点击ssh会弹出下面的窗口：

这里就提示我们需要添加一个public key，我们点击红框内的链接就可以跳转过去。

页面如下：

这个页面也可以用下面的办法进入：

1. 登录GitHub，点击右上角头像，再点击Settings

   

2. 页面进来后再点击SSH and GPG keys

   

之后，再点击New SSH key

这地方说明一下，Title可以随意写，Key type直接用默认的就好，Key部分需要你自己生成的。

KEY值生成方式

生成的方式，需要在你拉取或者提交代码的电脑上做如下操作：

通过命令行执行：

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

中间一路回车就好，当然如果你不想用默认的，可以自己设置下

Windows：

Linux：

正常情况下，Windows和Linux都是可以直接执行的，如果提示没有ssh-keygen这个命令，那么你需要安装下OpenSSH。

配置完成检查

上面Windows和Linux的截图中，红色部分就是你key值存放的文件了，打开那个文件将内容粘贴到key值里面后，点击 Add SSH Key就配置完成了

保存后：

接下来就可以在你生成key的电脑上通过SSH的方式拉取代码了

一、安装

debain系统安装

wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt-get update
sudo apt-get install jenkins

使用下面的命令查看启动情况：

sudo systemctl status jenkins

docker-compose安装

安装后由于一些后续的操作放弃了，比如说工作空间问题、用户权限问题、需要的开发环境问题等等，个人感觉配置起来比较麻烦，就放弃了

docker-compose文件内容如下：

version: "3"

services:
  jenkins:
    image: jenkins/jenkins:lts-jdk17
    container_name: jenkins
    restart: on-failure:3
    volumes:
      - ./home:/var/jenkins_home
    ports:
      - "8080:8080"

二、安装后设置向导

解锁Jenkins

当您第一次访问新的Jenkins实例时，系统会要求您使用自动生成的密码对其进行解锁。

浏览器访问 http://localhost:8080（或安装时为Jenkins配置的任何端口），并等待 解锁 Jenkins 页面出现。

执行下面的命令查看密码：

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

安装默认插件

输入密码后点击continue，出现下面的内容，我这边直接使用的安装推荐的插件

选择后就开始安装插件了，但是由于默认的Jenkins仓库是国外的，安装插件中途会出现下面的安装失败的情况，类似这样的不用担心，点击下方的重试，继续安装

重复几次后就能安装成功了

创建管理员用户

之后出现下面的界面，看界面内容就知道了，这地方需要设置管理员用户名密码了

设置好点击保存并完成

实例配置

这地方可以不管，直接点击保存并完成

到这里，jenkins算是初步安装完成了，点击开始使用jenkins就好了

三、其他配置

修改镜像源

前面安装时，提到过，安装插件的时候需要反复重试，在这里可以将插件源改为国内的，这样可以快速安装插件

在 Jenkins 系统管理 → 插件管理 → 高级，修改 “更新站点”：

https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

由于版本不一样，步骤可能有点不同，这边我将从Jenkins开始来进行截图

插件安装

我这边使用的gitea仓库，额外安装了下面三个插件：

• Gitea

• Gitea Checks

• Generic Event

• Generic Webhook Trigger Plugin

前言

近期工作需要，数据库换成了oracle，而我自己没有私有化的oracle数据库，为了之后工作的方便，决定私人部署一个oracle数据库。

为了方便，还是使用的docker方式部署在nas上面了，看了看docker hub，oracle的镜像全部是6年前的，我这边直接选择了第一个镜像truevoly/oracle-12c

好了，下面正式开始

安装部署

我这边直接使用docker命令下载并启动镜像，下面是命令：

# docker命令
docker run -d -p 1521:1521 --name oracle truevoly/oracle-12c
# 验证是否启动

配置

为了使用自带的SqlPlus,需要添加一下环境变量，有两种办法，

• 进入docker容器内部，直接修改文件

• 将文件从docker容器中复制出来，修改后，在拷贝进去

docker内修改文件

进入docker容器内部才行，下面是进入的命令：

docker exec -it 773382d440e8 /bin/bash

注意，代码中的773382d440e8是容器ID，需要改成自己的

进入之后通过vim编辑/etc/profile文件

vi /etc/profile

在文件的末尾添加三行：

export ORACLE_HOME=/home/oracle/app/oracle/product/11.2.0/dbhome_2
export ORACLE_SID=huangge1199
export PATH=$ORACLE_HOME/bin:$PATH

复制docker容器

从docker容器中拷贝文件到当前目录：

docker cp 773382d440e8:/etc/profile .

注意，代码中的773382d440e8是容器ID，需要改成自己的

本地修改文件

从本地将文件拷贝回docker容器：

docker cp profile 773382d440e8:/etc/profile

注意，代码中的773382d440e8是容器ID，需要改成自己的

修改管理密码

上一步已经配置好了，现在就可以使用自带的SqlPlus了。

首先先进入docker容器：

docker exec -it 773382d440e8 /bin/bash

切换用户：

su oracle

进入`SQL*Plus``:

$ORACLE_HOME/bin/sqlplus / as sysdba

修改system和sys的密码：

ALTER PROFILE DEFAULT LIMIT PASSWORD_LIFE_TIME UNLIMITED;
alter user SYSTEM account unlock;
alter user system identified by huangge1199;
alter user sys identified by huangge1199;

DataGrip测试连接

DG连接需要一个SID，接着在上一步的SQL里面查询下：

select name from v$database;

接下来就是DG的连接设置了：

引言

最近，deepseek是越来越火，我也趁着这个机会做了下私有化部署，我这边使用的ollama和 open-webui实现的web版本

ollama

简介

Ollama 是一个开源的工具，专门用于简化机器学习和 AI 模型的部署。它提供了一个统一的平台，允许你通过命令行工具创建、管理和更新模型。无论你是想在本地开发环境中运行模型，还是将其部署到云端，Ollama 都可以简化这一过程。

Ollama 支持多种常见的机器学习模型框架，包括但不限于 TensorFlow、PyTorch、Hugging Face Transformers 等，此外还支持类似 DeepSeek 这种自定义的搜索引擎模型。

核心特性

• 易于使用的命令行界面：Ollama 提供了简单直观的命令行工具，可以通过几条命令就完成模型的创建、启动、更新等操作。
• 环境隔离：Ollama 可以为每个模型提供独立的运行环境，避免了不同模型之间的依赖冲突。
• 跨平台支持：无论你是使用 Linux、Mac 还是 Windows，Ollama 都可以无缝运行。
• 自动更新：Ollama 会自动为模型提供更新，确保你使用的是最新的版本。
• 高效的资源管理：通过 Ollama，你可以有效地管理计算资源，包括 CPU 和 GPU 的使用，确保模型运行的高效性。

安装

Linux

使用root用户执行下面的命令：

curl -fsSL https://ollama.com/install.sh | sh

windows

直接下载安装包：windows安装包

macos

下载压缩包：https://ollama.com/download/Ollama-darwin.zip

环境变量

为了Ollama能够对外提供服务，需要设置OLLAMA_HOST

在Linux上设置

如果Ollama作为systemd服务运行，通过systemctl设置环境变量：

1. 使用systemctl edit ollama.service命令编辑systemd服务，将打开一个编辑器。

2. 对每个环境变量，在[Service]部分添加两行行Environment：

   Environment="OLLAMA_HOST=0.0.0.0"
   Environment="OLLAMA_ORIGINS=*"
   

   

   红框内为后加的两行代码

3. 保存并退出。

4. 重新加载systemd并重启Ollama：

   systemctl daemon-reload
   systemctl restart ollama
   

在Windows上设置

在Windows上，Ollama会继承您的用户和系统环境变量。

1. 首先通过任务栏图标退出Ollama，
2. 从控制面板编辑系统环境变量，
3. 为OLLAMA_HOST、OLLAMA_ORIGINS等编辑或新建变量。
4. 点击OK/Apply保存，
5. 然后从新的终端窗口运行ollama。

启动ollama服务

执行命令

systemctl start ollama

部署 DeepSeek

通过https://ollama.com/library找到对应的模型，点进模型有拉取运行的命令，比如说

deepseek-r1:7b的模型，执行下面的命令就可以拉取并运行其模型：

ollama run deepseek-r1

下面是操作截图，如果你已经拉取并运行模型了，可以直接进行open-webui的步骤了

从https://ollama.com/library开始，页面如下：

点击你需要的模型deepseek-r1，点击后页面如下：

左侧红框是你需要下载的版本，这里默认就是7b版本了，如果你需要其他版本可以通过下拉列表切换

右侧红框就是你需要执行的命令，执行该命令就可以拉取并运行其模型

open-webui

现在ds已经可以用了，但是还缺少应该web界面，我这边选择的是open-webui，可以直接通过浏览器访问

docker-compose安装open-webui

这个就相对简单了，我使用的docker-compose部署，下面是docker-compose文件：

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes:
      - ./data:/app/backend/data
    ports:
      - "8088:8080"
    restart: always

不过这个启动后要等很久的时间，原因是默认的docker镜像是以openai为主的，但是默认情况下没有配，所以等的时间比较久。

出现下图中最后一行就是部署好了：

open-webui配置 ollama+deepseek

看到http://0.0.0.0:8080这个说明可以在浏览器中打开了，注意，浏览器打开时，端口是你docker-compose里面引出的，不一定是8080，我这个docker-compose端口就是8088，接下来浏览器输入http://ip:8088/打开，页面如下：

首次使用需要创建管理员账号，点击开始使用进行创建，页面如下：

内容输入完，点击”创建管理员账号“，因为默认的openai，这一步一样的需要等很长一段时间，不要着急，慢慢等，出现下面的界面就可以进行下一步了：

点击红框的按钮后，依次按照下面图片的顺序进行操作

这地方注意下，1那地方的如果你不使用OpenAI API，一定要想我上面截图中那样给关了，要不之后再进页面，还是需要等很长一段时间，然后设置好ollama的连接，按照我文档中安装的话，填入的内容就是http://IP:11434，全部填完后保存

保存后右上角出现提示，这时候就已经完全配好了，接下来，可以重新打开页面http://IP:8088/看看效果了

页面如下，打开后页面直接进入了，而且左上角的模型也默认加载出来了，如果你的ollama安装的多个模型，可以通过红框的下拉列表切换

最后，就是看看提问效果了，当然，我这个服务器配置不行，速度一般般，但是提问的结果已经显示出来了

本文将详细介绍如何在openEuler 22.03 LTS SP1上安装和配置openGauss数据库，包括数据库的启动、停止、远程连接配置等关键步骤。

1、安装

使用OpenEuler-22.03-LTS-SP1-x64版本的系统，通过命令行安装openGauss数据库。

1.1、确保系统软件包索引是最新的

以root权限执行以下命令：

sudo dnf update -y

1.2、安装openGauss

以root权限执行以下命令：

sudo dnf install -y opengauss

安装完成后，二进制文件目录在 /usr/local/opengauss：

ls -l /usr/local/opengauss

默认数据目录在 /var/lib/opengauss/data：

ls -l /var/lib/opengauss/data

2、数据库启动停止

需要切换到opengauss用户下操作：

su - opengauss

2.1、查询数据库状态

在opengauss用户下执行命令：

ps ux

可以看到opengauss已经启动了

2.2、停止数据库

执行以下命令停止数据库：

# 停止命令
gs_ctl stop -D /var/lib/opengauss/data -Z single_node
# 查看状态确认停止
ps ux

2.3、启动数据库

执行以下命令启动数据库：

# 启动命令
gs_ctl start -D /var/lib/opengauss/data -Z single_node
# 查看状态确认停止
ps ux

2.4、重启数据库

执行以下命令重启数据库：

# 重启命令
gs_ctl restart -D /var/lib/opengauss/data -Z single_node
# 查看状态确认停止
ps ux

3、密码规则配置

建议在数据库安装好后立即配置。在/var/lib/opengauss/data/postgresql.conf文件的108行左右，去掉注释，设置成0或1。

4、远程连接

数据库默认安装完是不能远程连接的，需要修改配置文件。数据库的远程操作不能使用默认的超级用户，需要新建一个业务用户，而数据库的操作需要有密码，因此整个步骤如下：

1. 修改配置文件

2. 超级用户连接数据库

3. 给超级用户设置密码

4. 通过超级用户创建业务用户并设置密码

5. 给业务用户分配权限

6. 远程连接测试

4.1、修改配置文件

• 在/var/lib/opengauss/data/postgresql.conf文件中，设置 listen_addresses = '*'（大约第68行）

• 在/var/lib/opengauss/data/pg_hba.conf文件中，设置host all all 0.0.0.0/0 md5（大约在91行）

修改完后需要重启数据库。

4.2、超级用户连接数据库

以超级用户opengauss连接数据库：

gsql -d postgres -p 7654 -r

4.3、给超级用户设置密码

执行以下命令：

ALTER USER opengauss WITH PASSWORD 'opengauss@123';

4.4、创建业务用户并设置密码

执行以下命令：

CREATE USER admin WITH PASSWORD 'admin@123';

4.5、给业务用户分配权限

执行以下命令：

GRANT ALL PRIVILEGES ON DATABASE postgres TO admin;

4.6、远程连接测试

使用Navicat Premium Lite 17作为测试工具进行远程连接。

5、总结

通过上述步骤，已经成功在openEuler上安装并配置了openGauss数据库，确保能够进行正常的数据库操作和远程连接。

Git基础

git简介

1、简介

Git 是一个开源的分布式版本控制系统，用于敏捷高效地处理任何或小或大的项目。

Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。

Git 与常用的版本控制工具 CVS, Subversion 等不同，它采用了分布式版本库的方式，不必服务器端软件支持。

2、Git 与 SVN 区别

1. GIT 是分布式的，SVN 不是：这是 GIT 和其它非分布式的版本控制系统，例如 SVN，CVS 等，最核心的区别。

2. GIT 把内容按元数据方式存储，而 SVN 是按文件：所有的资源控制系统都是把文件的元信息隐藏在一个类似 .svn , .cvs 等的文件夹里。

3. GIT 分支和SVN的分支不同：分支在SVN中一点不特别，就是版本库中的另外的一个目录。

4. GIT 没有一个全局的版本号，而 SVN 有：目前为止这是跟 SVN 相比 GIT 缺少的最大的一个特征。

5. GIT 的内容完整性要优于 SVN：GIT 的内容存储使用的是 SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。

git安装

1、安装

在使用 Git 前我们需要先安装 Git。Git 目前支持 Linux/Unix、Solaris、Mac 和 Windows 平台上运行。

Git 各平台安装包下载地址为：Git - Downloads

2、在Linux 平台上安装

首先，你可以试着输入 git，看看系统有没有安装 Git：

git

显示下面的情况就是安装过git

如果未安装，可选择直接用命令安装或者是源码安装

命令安装

根据Linux的不同版本安装命令不同，下面是各版本的命令：

Debian/Ubuntu

apt-get install git

Fedora

# Fedora 21 及以下
yum install git
# Fedora 22 及之后
dnf install git

Gentoo

emerge --ask --verbose dev-vcs/git

Arch Linux

pacman -S git

openSUSE

zypper install git

Mageia

urpmi git

Nix/NixOS

nix-env -i git

FreeBSD

pkg install git

Solaris 9/10/11 (OpenCSW)

pkgutil -i git

Solaris 11 Express

pkg install developer/versioning/git

OpenBSD

pkg_add git

Alpine

apk add git

源码安装

我们来学习在 Linux 中如何使用源代码安装 Git, 有些 Linux 版本自带的安装包更新起来并不及时，那么从源代码安装其实该算是最佳选择。

Git 的工作需要调用 curl，zlib，openssl，expat，libiconv 等库的代码，所以需要先安装这些依赖工具。

在有 yum 的系统上（比如 Fedora）可以用下面的命令安装：

yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel

在有 apt-get 的系统上（比如 Debian 体系）可以用下面的命令安装：

$ apt-get install libcurl4-gnutls-dev libexpat1-dev gettext libz-dev libssl-dev

之后，从下面的 Git 官方站点下载最新版本源代码：http://git-scm.com/download

然后编译并安装：

# 解压
tar -zxf git-1.7.2.2.tar.gz
# 切换目录
cd git-1.7.2.2
# 设置变量
make prefix=/usr/local all
# 安装
sudo make prefix=/usr/local install

3、在 Windows 平台上安装

在 Windows 平台上安装 Git 同样轻松，直接下载exe安装包即可。

安装包下载地址：Git - Downloading Package

4、在 Mac 平台上安装

既可以通过命令安装也可以通过安装器安装

Homebrew

如果有它，可以直接使用下面的命令安装：

brew install git

MacPorts

如果有它，可以直接使用下面的命令安装：

sudo port install git

安装器

可以使用图形化 Git 安装工具

下载地址为：git-osx-installer (abandoned) download | SourceForge.net

Git 工作流程

Git 的一般工作流程如下：

• 克隆 Git 资源作为工作目录。
• 在克隆的资源上添加或修改文件。
• 如果其他人修改了，你可以更新资源。
• 在提交前查看修改。
• 提交修改。
• 在修改完成后，如果发现错误，可以撤回提交并再次修改并提交。

下图展示了 Git 的工作流程：

下面来理解下Git 工作区、暂存区和版本库概念

• 工作区：就是你在电脑里能看到的目录。
• 暂存区：英文叫 stage, 或 index。一般存放在 ".git目录下" 下的 index 文件（.git/index）中，所以我们把暂存区有时也叫作索引（index）。
• 版本库：工作区有一个隐藏目录 .git，这个不算工作区，而是 Git 的版本库。

Git基本操作

创建版本库 ( git init )

描述

用 git init 在目录中创建新的 Git 仓库。 你可以在任何时候、任何目录中这么做，完全是本地化的。

语法

git init

例子

比如我们创建 gitlearn 项目：

# 创建项目目录
mkdir gitlearn
# 切换目录
cd gitlearn
# 创建版本库
git init

添加到暂存区 ( git add )

描述

当我们初始化项目后, 在工作区里进行增加, 修改, 删除 文件操作.

然后可以通过 git add 将文件添加到暂存区，作为下次提交的(部分或全部)内容。

语法

git add <文件/文件夹> [<args>]

git add . ：他会监控工作区的状态树，使用它会把工作时的所有变化提交到暂存区，包括文件内容修改(modified)以及新文件(new)，但不包括被删除的文件。

git add -u ：他仅监控已经被add的文件（即tracked file），他会将被修改的文件提交到暂存区。add -u 不会提交新文件（untracked file）。（git add --update的缩写）

git add -A ：是上面两个功能的合集, 也就是说包括删除的文件也会被提交（git add --all的缩写）

例子

我们在 gitlearn 项目添加两个文件并添加到暂存区

# 创建空文件README
touch README
# 创建空文件hello.php
touch hello.php
# 查看当前目录
ls -al
# 查看项目的当前状态
git status -s
# 将README和hello.php添加到暂存区
git add README hello.php
# 查看项目的当前状态
git status -s
# 在 README 中添加内容
echo "Git 测试" >> README
# 查看项目的当前状态
git status -s
将目录下的所有内容添加到暂存区
git add .
# 查看项目的当前状态
git status -s

"A" 状态的意思是，这个文件已经添加到缓存中

"AM" 状态的意思是，这个文件在我们将它添加到缓存之后又有改动

查看状态 ( git status )

描述

git status 查看本地工作区、暂存区中文件的修改状态

语法

git status

例子

查看改动 ( git diff )

描述

执行 git diff 来查看执行 git status 的结果的详细信息。

git diff 命令显示已写入缓存与已修改但尚未写入缓存的改动的区别。

语法

# 尚未缓存的改动
git diff
# 查看已缓存的改动
git diff --cached
# 查看已缓存的与未缓存的所有改动
git diff HEAD
# 显示摘要而非整个 diff
git diff --stat

例子

# 向hello.php中添加内容
echo -e "<?php\necho '查看改动test';">>hello.php
# 查看hello.php文件内容
cat hello.php
# 查看项目的当前状态
git status -s
# 查看尚未缓存的改动
git diff
# 将hello.php的改动添加到暂存区
git add hello.php
# 查看项目的当前状态
git status -s
# 查看已缓存的改动
git diff --cached

向仓库提交代码 ( git commit )

描述

使用 git add 命令将想要快照的内容写入缓存区， 而执行 git commit 将缓存区内容添加到仓库中。

如果你觉得 git add 提交缓存的流程太过繁琐，Git 也允许你用 -a 选项跳过这一步。

Git 为你的每一个提交都记录你的名字与电子邮箱地址，所以第一步需要配置用户名和邮箱地址。

# 配置全局的名称
git config --global user.name 'huangge1199'
# 配置全局的邮箱
git config --global user.email huangge1199@hotmail.com

语法

# 将想要快照的内容写入缓存区
git add 
# 将缓存区内容添加到仓库
git commit

# 将想要快照的内容添加到仓库
# 注：和前面的两条命令效果相同
git commit -a

例子一

# 我们使用 -m 选项以在命令行中提供提交注释
git commit -m '初始化项目'
git status

以上输出说明我们在最近一次提交之后，没有做任何改动，是一个"working directory clean：干净的工作目录"。

如果你没有设置 -m 选项，Git 会尝试为你打开一个编辑器以填写提交信息。 如果 Git 在你对它的配置中找不到相关信息，默认(Linux)会打开 vim。

例子二

如果你觉得 git add 提交缓存的流程太过繁琐，Git 也允许你用 -a 选项跳过这一步。

echo -e "echo '向仓库提交代码测试：git commit -a';">>hello.php
git status
git commit -am '修改hello'
git status

取消已缓存的内容 ( git reset HEAD )

语法

git reset HEAD -- <文件/文件夹>

例子

echo -e "echo '取消缓存测试';">>hello.php
echo -e "取消缓存测试">>README
git status -s
git add .
git status -s
git reset HEAD -- hello.php
git status -s
git commit -m '修改README'
git status -s
git commit -am '修改 hello 文件'
git status

删除文件 ( git rm )

语法

# git rm 从版本库中删除文件
git rm <文件>
# 如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f
git rm -f <文件>
# 如果把文件从暂存区域移除，但仍然希望保留在当前工作目录中，换句话说，仅是从跟踪清单中删除，使用 --cached 选项即可
git rm --cached <文件>
# 用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”
git checkout -- <文件>
# 递归删除目录下的所有文件和子目录
git rm –r <文件夹>

例子：从版本库中和工作区中删除

echo "# 这是一个测试文件的测试" > gittest.md
git add .
git commit -m "添加测试文件"
git rm gittest.md
ls -al

例子：删除暂存区或分支上的文件, 不删除本地

git rm --cached README
ls -al

移动/重命名 ( git mv )

描述

git mv 命令用于移动或重命名一个文件、目录、软连接。

语法

git mv 原文件名 新文件名

例子

git add README
git mv README  README.md
ls -al

远程仓库

添加远程仓库

我这边使用的是自建的gitea

创建仓库后出现下面的页面

现在,这个仓库还是空的, gitea告诉我们，可以从这个仓库克隆出新的仓库，也可以把一个已有的本地仓库与之关联，然后，把本地仓库的内容推送到 gitea仓库。

我们将本地已有仓库与之关联:

git remote add origin https://gitea.huangge1199.cn/huangge1199/gitlearn.git

然后,我们把本地库的所有内容推送到远程库上:

git push -u origin master

由于远程库是空的，我们第一次推送master分支时，加上了-u参数

另外红框的地方需要输入gitea的用户名和密码

推送成功后, 就可以在 gitea页面看到内容了:

克隆操作 ( git clone )

使用 git clone 拷贝一个 Git 仓库到本地，让自己能够查看该项目，或者进行修改。

如果你需要与他人合作一个项目，或者想要复制一个项目，看看代码，你就可以克隆那个项目。 执行命令：

 git clone [url]

[url] 为你想要复制的项目地址。

例如,我们在 gitea 创建一个新的 gitClone

填上仓库名称，勾选上”初始化仓库(添加. gitignore、许可证和自述文件)“

创建完毕后可以看到仓库中有一个 README.md 文件:

现在,将以上项目克隆到本地：

git clone https://gitea.huangge1199.cn/huangge1199/gitClone.git
cd gitClone
ls -al

默认情况下，Git 会按照你提供的 URL 所指示的项目的名称创建你的本地项目目录。 通常就是该 URL 最后一个 / 之后的项目名称。如果你想要一个不一样的名字， 你可以在该命令后加上你想要的名称。

例如: git clone https://gitea.huangge1199.cn/huangge1199/gitClone.git app

更新数据

更新数据 ( git fetch )

git fetch：从远程获取最新版本到本地，不会自动 merge

git checkout issue12
git fetch origin issue12
git log -p issue12..origin/issue12
git merge origin/issue12

解析:

(1).切换到issue12分支

(2).从远程的origin的issue12主分支下载最新的版本到origin/issue12分支上

(3).比较本地的issue12分支和origin/issue12分支的差别  ( git log 常用 -p 选项展开显示每次提交的内容差异 )

(4).将origin/issue12分支合并到issue12

更新数据 ( git pull  )

git pull：相当于是从远程获取最新版本并merge到本地

git checkout issue13
git pull origin issue13

上述 git pull 命令,  相当于 git fetch 和 git merge

Git分支管理

Git 分支原理

Git 每次提交的版本, Git 都将其串成一条时间线, 这条时间线就是一个分支, 当你执行 git init 的时候，缺省情况下 Git 就会为你创建 "master" 分支。HEAD严格来说不是指向提交，而是指向master，master才是指向提交的，所以，HEAD指向的就是当前分支。

如图所示:

每次提交，master分支都会向前移动一步，这样，随着你不断提交，master分支的线也越来越长.

当我们创建新的分支，如dev时，Git 新建了一个指针叫dev，指向与master相同的提交，再把HEAD指向dev，现在表示当前分支在dev上

如图所示:

从现在开始, 对工作区的修改和提交就是针对dev分支了，比如新提交一次后，dev指针往前移动一步，而master指针不变.

如图所示:

我们在dev上完成相应的开发后, 我们将其合并到 master 分支上, 切换回 master 分支.

如图所示:

合并完成后, 也可以删除 dev 分支, 原理是将 dev 指针删除

如图所示:

分支基础命令

几乎每一种版本控制系统都以某种形式支持分支。使用分支意味着你可以从开发主线上分离开来，然后在不影响主线的同时继续工作。

有人把 Git 的分支模型称为"必杀技特性"，而正是因为它，将 Git 从版本控制系统家族里区分出来。

创建分支命令：

git branch 分支名

切换分支命令:

git checkout 分支名

当你切换分支的时候，Git 会用该分支的最后提交的快照替换你的工作目录的内容， 所以多个分支不需要多个目录。

合并分支命令:

git merge 

你可以多次合并到统一分支， 也可以选择在合并之后直接删除被并入的分支。

查看、创建及切换分支

语法

# 列出分支
git branch
# 创建分支
git branch 分支名
# 切换分支
git checkout 分支名
# 创建新分支并立即切换到该分支
git checkout -b 分支名

例子一

# 列出分支
git branch
# 创建分支dev
git branch dev
# 列出分支
git branch
# 列出当前目录的所有文件
ls -al
# 切换到dev分支
git checkout dev
# 创建新文件test.md
echo '# Git分支学习测试' > test.md
# 添加到暂存区
git add .
# 提交到dev分支
git commit -m "新增test.md文件"
# 列出当前目录的所有文件
ls -al
# 切换回master分支
git checkout master
# 列出当前目录的所有文件
ls -al

例子二

# 创建新分支newtest并切换到新分支
git checkout -b newtest
# 查看所有分支
git branch
# 删除hello.php文件
git rm hello.php
# 列出目录下所有文件
ls -al
# 提交变更到newtest分支
git commit -am "removed hello.php"
# 切换回master分支
git checkout master
# 列出目录下所有文件
ls -al

分支合并

描述

一旦某分支有了独立内容，你终究会希望将它合并回到你的主分支。

语法

git merge 分支名

例子

# 创建新分支dev2并切换到新分支
git checkout -b dev2
# 创建空文件dev2.md
touch dev2.md
# 添加到暂存区
git add .
# 提交到dev2分支
git commit -m "新增dev2.md"
# 切回master分支
git checkout master
# 列出目录下所有文件
ls -al
# 将dev2分支合并到当前master分支
git merge dev2
# 列出目录下所有文件
ls -al

删除分支

语法

git branch -d <分支名>

例子

# 查看所有分支
git branch
# 删除分支dev2
git branch -d dev2
# 查看所有分支
git branch

解决冲突

我们先创造一个冲突出来, 比如, 在两个分支中修改了同一个文件的同一行代码,在合并的时候就会发生冲突，出现冲突后我们再解决冲突。下面就是创建冲突、解决冲突的全过程。

# 查看所有分支
git branch
# 查看当前目录
ls -al
# 查看gittest.md文件内容
cat gittest.md
# 在gittest.md文件结尾添加“冲突测试”
echo "冲突测试" >> gittest.md
# 查看gittest.md文件内容
cat gittest.md
# 查看git状态
git status -s
# 提交变化到master分支
git commit -am "冲突测试"
# 创建并切换到dev1分支
git checkout -b dev1
# 查看当前目录
ls -al
# 查看gittest.md文件内容
cat gittest.md
# 将gittest.md文件最后一行替换成“冲突测试dev1”
sed -i '$s/.*/冲突测试dev1/' gittest.md
# 查看gittest.md文件内容
cat gittest.md
# 提交变化到dev1分支
git commit -am "冲突测试dev1"
# 切换回master分支
git checkout master
# 将gittest.md文件最后一行替换成“冲突测试master”
sed -i '$s/.*/冲突测试master/' gittest.md
# 查看gittest.md文件内容
cat gittest.md
# 提交变化到master分支
git commit -am "冲突测试master"
# 合并dev1分支到master
git merge dev1
# 查看git状态
git status
# 查看gittest.md文件内容
cat gittest.md
# 将gittest.md文件中冲突部分替换成“冲突测试master 和 冲突测试dev1”
sed -i '/^<<<<<<< HEAD$/,/^>>>>>>> dev1$/c\冲突测试master 和 冲突测试dev1' gittest.md
# 查看gittest.md文件内容
cat gittest.md
# 提交冲突修复内容到master分支
git commit -am "修复冲突"
# 查看分支历史
git log --graph --pretty=oneline --abbrev-commit

分支管理策略

通常 Git 在合并分支的时候会用 Fast forward 模式, 这样删除分支后, 也会丢掉分支信息.

我们在合并分支时可以使用 --no-ff 参数,强制禁用 Fastforward 模式, 这样 Git 在合并时会生成一个新的 commit(提交), 然后我们就可以在历史分支上看出分支信息.

我们来操作下看看效果, 我们创建一个 dev2 的分支

git checkout -b dev2

修改 gittest.md 文件, 然后提交修改:

ls -al
cat gittest.md
echo "分支策略。。。测试" >> gittest.md
cat gittest.md
git commit -am "分支策略"

切回 master 分支, 然后使用 git merge --no-ff 合并分支:

git checkout master
git merge --no-ff -m "merge with no-ff" dev2

因为我们禁用 Fast forward 模式, 所以本次合并会创建一个新的 commit(提交), 我们用 -m 给这次 commit 加上描述

然后我们用 git log 查看下分支历史

git log --graph --pretty=oneline --abbrev-commit

多人协作

查看远程库信息

当我们从远程仓库克隆时，实际上 Git 自动把本地的master分支和远程的master分支对应起来了(远程仓库默认名字是 origin)

可以用 git remote 查看远程库的信息

git remote

加参数 -v 可以显示更详细的信息：

git remote -v

上面显示了可以抓取和推送的origin的地址。如果没有推送权限，就看不到push的地址。

推送分支

我们想将本地分支推送到远程库,可以使用 git push 命令,在推送时,要指定本地分支, 这样，Git 就会把该分支推送到远程库对应的远程分支上：

git push origin master

如果要推送其他分支, 比如 dev2 :

git push origin dev2

回退与撤销

撤销修改 ( git checkout -- file)

描述

把 该文件 在工作区的修改全部撤销

语法

git checkout -- <file>

如果 文件 修改后还没有被放到暂存区，现在，撤销修改就是用版本库的版本覆盖当前的文件。

如果 文件 已经添加到暂存区后，又作了修改，现在，撤销修改就是将暂存区中的文件版本覆盖当前的文件。

总之，就是让这个文件回到最近一次git commit或git add时的状态。

例子

# 查看git状态
git status
# 查看gittest.md文件内容
cat gittest.md
# 修改gittest.md文件
echo "撤销修改。。。测试" >> gittest.md
# 查看gittest.md文件内容
cat gittest.md
# 查看本地与暂存区的不同
git diff
# 撤销本地修改
git checkout -- gittest.md
# 查看gittest.md文件内容
cat gittest.md

历史记录 ( git log )

在实际工作中，我们脑子里怎么可能记得一个几千行的文件每次都改了什么内容，不然要版本控制系统干什么。

Git 可以使用 git log 命令告诉我们历史记录：

git log

git log命令显示从最近到最远的提交日志

如果嫌 git log 输出信息太多，看得眼花缭乱，可以加上--pretty=oneline参数:

git log --pretty=oneline

版本回退 ( git reset )

描述

要把当前版本回退到上一个版本，可以使用git reset命令.

语法

回退到上一个版本：

git reset --hard HEAD^

在 Git 中，用 HEAD 表示当前版本，上一个版本就是 HEAD^，上上一个版本就是 HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100

回退到指定 commit id 版本：

git reset --hard <commit id>

例子

# 查看当前历史记录
git log --pretty=oneline
# 回退到上一个版本
git reset --hard HEAD^
# 查看当前历史记录
git log --pretty=oneline
# 显示整个本地仓储的 commit
git reflog
# 回退失误,通过回退到指定 commit id 版本，改回原来的版本
git reset --hard cd531a8
# 查看当前历史记录
git log --pretty=oneline

标签管理

创建标签

语法

# 创建一个新标签，默认打在最新提交的 commit id 上的。
git tag <标签名>
# 在指定commit id上打标签
git tag <标签名> <commit id>
# 创建带有说明的标签
git tag -a <标签名> -m <说明> <commit id>

例子

git log --pretty=oneline --abbrev-commit
git tag v1.0
git log --pretty=oneline --abbrev-commit
git tag v0.8 b2db307
git tag -a v0.9 -m "标签说明" 0d5375b

查看标签

语法

# 查看所有标签
git tag
# 查看标签信息
git show <标签名>

例子

git tag
git show v0.9

删除和推送标签

可以使用 git tag -d 标签名 删除打错的标签：

git tag -d v0.8
git tag

到目前为止,我们打的标签都只是存储在本地

如果要推送某个标签到远程，使用命令 git push origin 标签名

git push origin v1.0

也可以，一次性推送全部尚未推送到远程的本地标签：

git push origin --tags

如果标签已经推送到远程，要删除远程标签就麻烦一点，先从本地删除，然后，从远程删除。删除命令也是push

git tag -d v0.9
git push origin :refs/tags/v0.9

自定义Git

Git 配置

Git 提供了一个叫做 git config 的工具，专门用来配置或读取相应的工作环境变量。

这些环境变量，决定了 Git 在各个环节的具体工作方式和行为。这些变量可以存放在以下三个不同的地方：

• /etc/gitconfig 文件：系统中对所有用户都普遍适用的配置。若使用 git config 时用 --system 选项，读写的就是这个文件。
• ~/.gitconfig 文件：用户目录下的配置文件只适用于该用户。若使用 git config 时用 --global 选项，读写的就是这个文件。
• 当前项目的 Git 目录中的配置文件（也就是工作目录中的 .git/config 文件）：这里的配置仅仅针对当前项目有效。每一个级别的配置都会覆盖上层的相同配置，所以 .git/config 里的配置会覆盖 /etc/gitconfig 中的同名变量。

在 Windows 系统上，Git 会找寻用户主目录下的 .gitconfig 文件。主目录即 HOME 变量指定的目录，一般都是 C:\Documents and Settings\USER。

此外，Git 还会尝试找寻 /etc/gitconfig 文件，只不过看当初 Git 装在什么目录，就以此作为根目录来定位。

配置用户信息

配置个人的用户名称和电子邮件地址：

git config --global user.name "huangge1199"
git config --global user.email huangge1199@hotmail.com

查看配置信息

要检查已有的配置信息，可以使用 git config --list 命令：

git config --list

有时候会看到重复的变量名，那就说明它们来自不同的配置文件（比如 /etc/gitconfig 和 ~/.gitconfig），不过最终 Git 实际采用的是最后一个。

这些配置我们也可以在 ~/.gitconfig 或 /etc/gitconfig 看到，如下所示：

cat ~/.gitconfig

忽略特殊文件

有时你必须把某些文件放入 Git 工作目录中, 又不能将其提交, 比如:存储了数据库密码的配置文件.

我们只需在 Git 工作区的根目录下创建一个名为 .gitignore 的文件, 写入过滤规则就行了.

忽略文件的原则是：

1. 忽略操作系统自动生成的文件，比如缩略图等；
2. 忽略编译生成的中间文件、可执行文件等，也就是如果一个文件是通过另一个文件自动生成的，那自动生成的文件就没必要放进版本库，比如 Java 编译产生的 .class 文件；
3. 忽略你自己的带有敏感信息的配置文件，比如存放口令的配置文件。

例如, 这是 java 项目的 .gitignore 文件

# Compiled class file
*.class

# Log file
*.log

# BlueJ files
*.ctxt

# Mobile Tools for Java (J2ME)
.mtj.tmp/

# Package Files #
*.jar
*.war
*.ear
*.zip
*.tar.gz
*.rar

# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

引言

最近，来了个需求，需要在下拉列表中做筛选。下拉列表显示的是中文，但筛选时可能会输入中文的拼音首字母。因此，需要实现一个筛选功能，能够根据拼音首字母筛选出匹配的选项。

自定义筛选方法

前端使用的是 vue3 和 element-plus。我使用的组件是 Select 选择器 | Element Plus 。为 el-select 添加 filterable 属性即可启用搜索功能。默认情况下，Select 会找出所有 label 属性包含输入值的选项。但这里需要匹配拼音首字母进行搜索，因此要通过传入一个 filter-method 来实现。filter-method 是一个函数，它会在输入值发生变化时调用，参数为当前输入值。

下面是这部分的简短代码：

vue部分：

<el-select
  v-model="queryParams.word"
  filterable
  placeholder="请输入"
  clearable
  :filter-method="filterMethod"
  >
  <el-option
    v-for="word in words"
    :key="word"
    :label="word"
    :value="word"
  />
</el-select>/el-form-item>

JS部分：

const showSearch = ref(true);
// option选项
const words = ref(['你好', '世界', '中国', '中国最棒'])
// 保留原始的option选项
const wordsOld = ref(['你好', '世界', '中国', '中国最棒'])

const data = reactive({
  queryParams: {
    word: null,
  },
});

const { queryParams } = toRefs(data);

// 多选框选中数据
function filterMethod(val){
  // 如果有输入值，根据输入内容进行筛选
  if(val){
    // 先将option中的选项words清空
    words.value = []
    // 从原始的option选项中遍历筛选
    wordsOld.value.forEach(word => {
      // 添加筛选逻辑，满足的word添加到words中显示
      words.value.push(word)
    })
  } else {
    // 如果没有输入值，恢复成原始的option选项
    words.value = wordsOld.value
  }
}

拼音首字母匹配

可以使用 pinyin-pro 来实现拼音匹配，例子如下：

import { pinyin } from 'pinyin-pro';

const word = ref('中国最棒')

const firstLetterPinyin = pinyin(word, { pattern: 'first' }).replace(/\s+/g, '');
if(firstLetterPinyin.includes(queryLower)){
  words.value.push(word)
}

pinyin 方法使用 pinyin-pro 库将汉字转换为指定样式的拼音字符串。这里面'first'样式为获取每一个字的小写拼音首字母，中间用空格分割，而我匹配时不需要空格，因此在firstLetterPinyin设值时添加了replace(/\s+/g, '')将转换的字符串去除空格。

完整的vue代码

<template>
  <div class="app-container">
    <el-form :model="queryParams" ref="queryRef" :inline="true" v-show="showSearch">
      <el-form-item label="中文拼音匹配选择器">
        <el-select
          v-model="queryParams.word"
          filterable
          placeholder="请输入"
          clearable
          :filter-method="filterMethod"
          >
          <el-option
            v-for="word in words"
            :key="word"
            :label="word"
            :value="word"
          />
        </el-select>
      </el-form-item>
    </el-form>
  </div>
</template>

<script setup name="word">
import { pinyin } from 'pinyin-pro';

const showSearch = ref(true);
const words = ref(['你好', '世界', '中国', '中国最棒'])
const wordsOld = ref(['你好', '世界', '中国', '中国最棒'])

const data = reactive({
  queryParams: {
    word: null,
  },
});

const { queryParams } = toRefs(data);

// 多选框选中数据
function filterMethod(val){
  if(val){
    const queryLower = val.toLowerCase();
    words.value = []

    // 筛选拼音首字母包含输入内容的选项
    wordsOld.value.forEach(word => {
      const firstLetterPinyin = convertToPinyin(word, 'first').replace(/\s+/g, '');
      if(firstLetterPinyin.includes(queryLower)){
        words.value.push(word)
      }
    })
    // 筛选选包含输入内容的选项
    wordsOld.value.forEach(word => {
      if(word.includes(val)){
        words.value.push(word)
      }
    })
  } else {
    words.value = wordsOld.value
  }
}

function convertToPinyin(word, type) {
  return pinyin(word, { pattern: type });
}
</script>

代码解析：

1. 模板部分：

   • 使用 el-select 组件并启用 filterable 属性。
   • 通过 v-for 渲染选项列表。

2. 脚本部分：

   • 导入 ref, reactive, toRefs 从 Vue 中管理状态。
   • 导入 pinyin-pro 库进行拼音转换。
   • 定义原始选项列表 wordsOld 和当前选项列表 words。
   • 定义一个响应式对象 data 存储查询参数。
   • 实现 filterMethod 函数，根据输入值筛选匹配的选项，包括拼音首字母和汉字匹配。

以上代码实现了一个带拼音首字母匹配功能的下拉选择器，能有效地根据用户输入进行筛选。

近期，我接到了一个任务，将报警器接入到Java项目中，而接入的方式就是通过RS485接入，本人之前可以说是对此毫无所知。不过要感谢现在的互联网，通过网络我查到了我想要知道的一切，这里记录下本次学习的情况，供大家参考

一、RS485简单介绍

RS485是一种常用的串行通信标准，广泛应用于工业自动化和嵌入式系统。它采用差分信号传输，具有抗干扰能力强、传输距离远等优点。以下是关于RS485串口的一些关键点：

1、硬件连接

• RS485使用差分信号传输，通常需要使用收发器（如MAX485芯片）将串口的TTL信号转换为RS485信号

• 可以使用USB转RS485转换器实现与计算机的连接

2、通信方式

• RS485支持半双工通信，即发送和接收不能同时进行，通常需要软件控制来实现发送和接收的切换

• 通过两个数据线进行通信，数据线为A和B，A为正，B为负

3、数据发送和接收

• 在数据发送时，控制器的TX信号经过收发器转换成差分信号传输到总线上

• 接收时，差分信号通过收发器转换为TTL信号，再传输给控制器的RX端口

• 数据传输速率可以根据具体应用需求进行调整，常见的波特率有9600、19200等

二、电脑需要做的准备

Windows系统还好，需要一个USB转RS485的转换器就可以了，基本不需要额外安装什么其他的。Linux系统可能就麻烦些，除了一个USB转RS485的转换器外，可能还需要下载相应的驱动（Linux这部分本人未实际操作，全凭网上的资料）。当然，如果你的电脑或者是设备本身就带RS485串口那就方便了，直接接上就好。

接线方面，A接T+，B接T-

三、代码方面

本人使用的是Springboot项目，通过网上的查询，可以使用 jSerialComm 或 RXTX 库来实现串口通信。

1、jSerialComm

本人觉得使用这个库相对简单些，直接在pom文件引入依赖就可以了，依赖代码如下：

<dependency>
    <groupId>com.fazecast</groupId>
    <artifactId>jSerialComm</artifactId>
    <version>2.9.2</version>
</dependency>

2、RXTX

这个尼，个人觉得相对复杂些，首先，要先去下载RXTX的jar包(rxtx-2.1-7-bins-r2)，在使用时，除了在pom文件中引入压缩包内的RXTXcomm.jar包外，还需要在系统%JAVA_HOME%/jre/bin目录下放入对应的文件，比如说Windows的需要放入rxtxParallel.dll和rxtxSerial.dll两个文件

压缩包内容：

3、代码例子

我这边用的jSerialComm的方式，引入jar包后，Java的测试代码如下：

import com.fazecast.jSerialComm.SerialPort;

public class RS485Communication {
    public static void main(String[] args) {
        //SerialPort[] commPorts = SerialPort.getCommPorts();
        //if (commPorts.length == 0) {
        //    log.error("设备未插入！");
        //}
		//SerialPort serialPort = null;
        //if(SystemUtils.isLinux()){
        //    for (SerialPort commPort : commPorts) {
        //        log.info(JSON.toJSONString(commPort));
        //        if(commPort.getSystemPortName().equals("ttyS2")){
        //            serialPort = commPort;
        //        }
        //    }
        //} else {
        //    for (SerialPort commPort : commPorts) {
        //        log.info(JSON.toJSONString(commPort));
        //        if(commPort.getSystemPortName().contains("COM")){
        //            serialPort = commPort;
        //        }
        //    }
        //}
	    // 这里取的是第一个，如果你有多个，可以通过注释的代码来确定你使用的是哪一个
        SerialPort serialPort = SerialPort.getCommPorts()[0];
        serialPort.setBaudRate(9600);
        serialPort.setNumDataBits(8);
        serialPort.setNumStopBits(SerialPort.ONE_STOP_BIT);
        serialPort.setParity(SerialPort.NO_PARITY);

        if (serialPort.openPort()) {
            System.out.println("Port opened successfully.");
        } else {
            System.out.println("Failed to open port.");
            return;
        }

        // 发送数据
        byte[] dataToSend = {0x00, 0x10}; // 示例16位数据
        serialPort.writeBytes(dataToSend, dataToSend.length);

        // 接收数据
        byte[] readBuffer = new byte[2];
        serialPort.readBytes(readBuffer, readBuffer.length);
        System.out.println("Received: " + bytesToHex(readBuffer));

        serialPort.closePort();
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return sb.toString().trim();
    }
}

title: TS（TypeScript）看这篇就够了
date: 2024-04-23 15:48:28.352
updated: 2024-04-30 10:24:27.118
url: https://blog.huangge1199.cn/archives/tstypescript-kan-zhe-pian-jiu-gou-le
categories:

• 前端
  tags:

• 前端

Typescript 简介

TypeScript是用于应用程序规模开发的JavaScript。

TypeScript是强类型，面向对象的编译语言。它是由微软的Anders Hejlsberg（C＃的设计者）设计的。

TypeScript既是一种语言又是一组工具。TypeScript是JavaScript的一个超集。换句话说，TypeScript是JavaScript加上一些额外的功能。

TypeScript 扩展了 JavaScript 的语法，所以任何现有的 JavaScript 程序可以不加改变的在 TypeScript 下工作。TypeScript 是为大型应用之开发而设计，而编译时它产生 JavaScript 以确保兼容性。

TypeScript 可以编译出纯净、 简洁的 JavaScript 代码，并且可以运行在任何浏览器上、Node.js 环境中和任何支持 ECMAScript 3（或更高版本）的 JavaScript 引擎中。

TypeScript 的优势

TypeScript相对于纯粹的JavaScript具有许多优势，特别是在开发大型应用程序时。以下是一些TypeScript的优势：

静态类型系统

TypeScript引入了静态类型系统，允许开发者在声明变量、函数参数、返回值等时指定类型。这种静态类型检查可以帮助捕获常见的编程错误，例如类型不匹配、未定义的属性或方法等，提供更好的代码质量和可靠性。

更好的代码智能感知

因为TypeScript了解代码中的类型信息，因此编辑器可以提供更准确和强大的代码智能感知和自动补全功能。这可以显著提高开发效率，并减少常见的编码错误。

更易于重构和维护

静态类型和面向对象特性使得代码更模块化、更结构化，从而更易于重构和维护。IDE可以更好地支持重构操作，并能够更好地理解代码的结构和依赖关系。

更丰富的面向对象特性

TypeScript支持类、接口、继承、多态等面向对象编程的特性，使得代码组织更清晰、更易于理解。这对于构建大型应用程序非常有用。

更好的工具支持：

TypeScript配合现代的集成开发环境（如VS Code、WebStorm等），可以提供强大的代码导航、重构、调试和代码分析工具。此外，TypeScript还能够与许多流行的前端框架（如Angular、React等）良好集成。

增强的语言功能：

TypeScript不仅仅是JavaScript的超集，它还引入了一些新的语言功能，如箭头函数、可选参数、默认参数、模板字符串等，使得代码更简洁和易读。

更好的生态系统：

TypeScript拥有庞大的社区支持，许多常用的JavaScript库和框架都提供了类型定义文件，可以轻松地与TypeScript集成。这使得使用第三方库时具有更好的类型安全性和开发体验。

基础类型

TypeScript支持与JavaScript几乎相同的数据类型 数字，字符串，结构体，布尔值等，此外还提供了实用的枚举类型方便我们使用。

布尔值

最基本的数据类型就是简单的 true/false 值，在 JavaScript 和 TypeScript 里叫做 boolean（其它语言中也一样）。 我们来定义一个布尔类型的变量:

let isDone: boolean = false;

在TypeScript中, 在参数名称后面使用冒号:来指定参数的类型

let 变量名: 数据类型

数字

和 JavaScript 一样，TypeScript 里的所有数字都是浮点数。 这些浮点数的类型是 number。 除了支持十进制和十六进制字面量，TypeScript 还支持 ECMAScript 2015 中引入的二进制和八进制字面量。

let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;
let binaryLiteral: number = 0b1010;
let octalLiteral: number = 0o744;

字符串

字符串新特性

JavaScript 程序的另一项基本操作是处理网页或服务器端的文本数据。 像其它语言里一样，我们使用 string 表示文本数据类型。 和 JavaScript 一样，可以使用双引号 “或单引号'表示字符串。

let name: string = "bob";
name = "loen";

以上字符串不支持换行.

多行字符串

在Typescript中你可以使用反引号 ` 表示多行字符串.

let hello: string = `Welcome to 
W3cschool`;

内嵌表达式

你还可以使用模版字符串，也就是在反引号中使用 ${ expr }这种形式嵌入表达式

let name: string = `Loen`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ name }.


I'll be ${ age + 1 } years old next month.`;

这与下面定义sentence的方式效果相同：

let sentence: string = "Hello, my name is " + name + ".\n\n" +
    "I'll be " + (age + 1) + " years old next month.";

我们可以看到Typescript定义的字符串更加清晰简单.

自动拆分字符串

我们可以用字符串模板去调用一个方法

function userinfo(params,name,age){
    console.log(params);
    console.log(name);
    console.log(age);
}


let myname = "Loen Wang";
let getAge = function(){
    return 18;
}
// 调用
userinfo`hello my name is ${myname}, i'm ${getAge()}`

结果：

数组

TypeScript 有两种方式可以定义数组。

第一种, 是在元素类型后面接上 []，表示由此类型元素组成的一个数组：

let list: number[] = [1, 2, 3];

第二种方式是使用数组泛型，Array<元素类型>：

let list: Array<number> = [1, 2, 3];

元组 Tuple

元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。 比如，你可以定义一对值分别为 string 和 number 类型的元组。

// 声明一个元组类型
let x: [string, number];
// 初始化元组
x = ['hello', 10]; 
x = [10, 'hello']; // 这里会报错,类型错误

枚举

enum 类型是对 JavaScript 标准数据类型的一个补充。 像 C# 等其它语言一样，使用枚举类型可以为一组数值赋予友好的名字。

enum Color {Red, Green, Blue}
let c: Color = Color.Green;

默认情况下，从0开始为元素编号。 你也可以手动的指定成员的数值。 例如，我们将上面的例子改成从 1开始编号：

enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;

或者，全部都采用手动赋值：

enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;

枚举类型提供的一个便利是你可以由枚举的值得到它的名字。 例如，我们知道数值为2，但是不确定它映射到Color里的哪个名字，我们可以查找相应的名字：

enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];


alert(colorName);  // 显示'Green'因为上面代码里它的值是2

Any

如果不希望类型检查器对值进行检查,直接通过编译阶段的检查。 那么我们可以使用 any类型来标记这些变量：

let notSure: any = 4;
notSure = "这是一个字符串";
notSure = false; // 现在我们又可以将其改成布尔类型

在对现有代码进行改写的时候，any类型是十分有用的，它允许你在编译时可选择地包含或移除类型检查。 你可能认为 Object有相似的作用，就像它在其它语言中那样。 但是 Object类型的变量只是允许你给它赋任意值 - 但是却不能够在它上面调用任意的方法，即便它真的有这些方法：

let notSure: any = 4;
notSure.ifItExists();// 存在这个方法
notSure.toFixed(); // 存在这个方法


let prettySure: Object = 4;
prettySure.toFixed(); // 错误：对象类型上不存在 toFixed 属性

当你只知道一部分数据的类型时，any类型也是有用的。 比如，你有一个数组，它包含了不同的类型的数据：

let list: any[] = [1, true, "free"];


list[1] = 100;

Void

某种程度上来说，void类型像是与any类型相反，它表示没有任何类型。 当一个函数没有返回值时，你通常会见到其返回值类型是 void：

function warnUser(): void {
    alert("This is my warning message");
}

声明一个void类型的变量没有什么大用，因为你只能为它赋予undefined和null：

let unusable: void = undefined;

Null 和 Undefined

TypeScript 里，undefined 和 null 两者各自有自己的类型分别叫做 undefined 和 null。 和 void 相似，它们的本身的类型用处不是很大：

// 我们无法给这些变量赋值
let u: undefined = undefined;
let n: null = null;

默认情况下 null 和 undefined 是所有类型的子类型。

就是说你可以把 null 和 undefined 赋值给 number 类型的变量。

然而，当你编译时指定了 –strictNullChecks 标记， null 和 undefined 只能赋值给 void 和它们自己。

注意：我们鼓励尽可能地使用--strictNullChecks，但在本教程里我们假设这个标记是关闭的。

Never

never 类型表示的是那些永不存在的值的类型。

例如， never 类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型；

never 类型是任何类型的子类型，也可以赋值给任何类型； 然而，没有类型是 never 的子类型或可以赋值给 never 类型（除了 never 本身之外）。 即使 any 也不可以赋值给 never 。

下面是一些返回 never 类型的函数：

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
    throw new Error(message);
}


// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}


// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {
    }
}

箭头表达式将再后面的课程中学习到。

类型断言

通过类型断言这种方式可以告诉编译器，“相信我，我知道自己在干什么”。 类型断言好比其它语言里的类型转换，但是不进行特殊的数据检查和解构。 它没有运行时的影响，只是在编译阶段起作用。

TypeScript 会假设你，程序员，已经进行了必须的检查。

类型断言有两种形式。 其一是尖括号语法：

let someValue: any = "this is a string";


let strLength: number = (<string>someValue).length;

另一个为as语法：

let someValue: any = "this is a string";


let strLength: number = (someValue as string).length;

两种形式是等价的。 至于使用哪个大多数情况下是凭个人喜好；

然而，当你在 TypeScript 里使用 JSX 时，只有 as语法断言是被允许的。

符号介绍

自ECMAScript 2015起，symbol成为了一种新的原生类型，就像number和string一样。

symbol类型的值是通过Symbol构造函数创建的。

let sym1 = Symbol();
let sym2 = Symbol("key"); // 可选的字符串key

Symbols是不可改变且唯一的。

let sym2 = Symbol("key");
let sym3 = Symbol("key");


sym2 === sym3; // false

symbols是唯一的像字符串一样，symbols也可以被用做对象属性的键。

let sym = Symbol();
let obj = {
    [sym]: "value"
};


console.log(obj[sym]); // "value"

Symbols也可以与计算出的属性名声明相结合来声明对象的属性和类成员。

const getClassNameSymbol = Symbol();


class C {
    [getClassNameSymbol](){
       return "C";
    }
}


let c = new C();
let className = c[getClassNameSymbol](); // "C"

变量声明

let和const

let和const是JavaScript里相对较新的变量声明方式。 像我们之前提到过的， let在很多方面与var是相似的，但是可以帮助大家避免在JavaScript里常见一些问题。 const只能一次赋值, 再次赋值会报错。

• let可以多次写入
• const只允许一次写入

因为 TypeScript 是 JavaScript 的超集，所以它本身就支持let和const。 下面我们会详细说明这些新的声明方式以及为什么推荐使用它们来代替 var。

var 声明

一直以来我们都是通过var关键字定义 JavaScript 变量。

var a = 10;

大家都能理解，这里定义了一个名为a值为10的变量。

我们也可以在函数内部定义变量：

function f() {
    var message = "Hello, world!";


    return message;
}

并且我们也可以在其它函数内部访问相同的变量。

function f() {
    var a = 10;
    return function g() {
        var b = a + 1;
        return b;
    }
}


var g = f();
g(); // returns 11;

上面的例子里，g 可以获取到 f 函数里定义的 a 变量。 每当 g 被调用时，它都可以访问到 f 里的 a 变量。 即使当 g 在 f 已经执行完后才被调用，它仍然可以访问及修改 a 。

function f() {
    var a = 1;


    a = 2;
    var b = g();
    a = 3;


    return b;


    function g() {
        return a;
    }
}


f(); // returns 2

作用域规则

对于熟悉其它语言的人来说，var声明有些奇怪的作用域规则。 看下面的例子：

function f(shouldInitialize: boolean) {
    if (shouldInitialize) {
        var x = 10;
    }


    return x;
}


f(true);  // returns '10'
f(false); // returns 'undefined'

变量 x 是定义在 if 语句里面 ，但是我们却可以在语句的外面访问它。 这是因为 var声明可以在包含它的函数，模块，命名空间或全局作用域内部任何位置被访问，包含它的代码块对此没有什么影响。

这些作用域规则可能会引发一些错误。 其中之一就是，多次声明同一个变量并不会报错：

function sumMatrix(matrix: number[][]) {
    var sum = 0;
    for (var i = 0; i < matrix.length; i++) {
        var currentRow = matrix[i];
        for (var i = 0; i < currentRow.length; i++) {
            sum += currentRow[i];
        }
    }


    return sum;
}

这里很容易看出一些问题，里层的 for 循环会覆盖变量 i，因为所有 i 都引用相同的函数作用域内的变量。 这很容易引发无穷的麻烦。

let 声明

现在你已经知道了var存在一些问题，这恰好说明了为什么用let语句来声明变量。

let hello = "Hello!";

块作用域

当用 let 声明一个变量，它使用的是词法作用域或块作用域。 不同于使用 var 声明的变量那样可以在包含它们的函数外访问，块作用域变量在包含它们的块或 for 循环之外是不能访问的。

function f(input: boolean) {
    let a = 100;


    if (input) {
        // Still okay to reference 'a'
        let b = a + 1;
        return b;
    }


    // Error: 'b' doesn't exist here
    return b;
}

这里我们定义了2个变量 a 和 b 。 a 的作用域是 f 函数体内，而 b 的作用域是 if 语句块里。

在catch语句里声明的变量也具有同样的作用域规则。

try {
    throw "oh no!";
}
catch (e) {
    console.log("Oh well.");
}


// Error: 'e' doesn't exist here
console.log(e);

拥有块级作用域的变量的另一个特点是，它们不能在被声明之前读或写。

虽然这些变量始终“存在”于它们的作用域里，但在直到声明它的代码之前的区域都属于 暂时性死区。 它只是用来说明我们不能在 let语句之前访问它们，幸运的是 TypeScript 可以告诉我们这些信息。

a++; // illegal to use 'a' before it's declared;
let a;

注意: 我们仍然可以在一个拥有块作用域变量被声明前获取它。 只是我们不能在变量声明前去调用那个函数。 如果生成代码目标为ES2015，现代的运行时会抛出一个错误；然而，现今 TypeScript 是不会报错的。

function foo() {
    // okay to capture 'a'
    return a;
}


// 不能在'a'被声明前调用'foo'
// 运行时应该抛出错误
foo();


let a;

重定义及屏蔽

我们提过使用 var 声明时，它不在乎你声明多少次；你只会得到1个。

function f(x) {
    var x;
    var x;


    if (true) {
        var x;
    }
}

在上面的例子里，所有x的声明实际上都引用一个相同的x，并且这是完全有效的代码。 这经常会成为bug的来源。 好的是， let声明就不会这么宽松了。

let x = 10;
let x = 20; // 错误，不能在1个作用域里多次声明`x`

并不是要求两个均是块级作用域的声明 TypeScript 才会给出一个错误的警告。

function f(x) {
    let x = 100; // error: interferes with parameter declaration
}


function g() {
    let x = 100;
    var x = 100; // 错误：不能同时声明'x'
}

并不是说块级作用域变量不能用函数作用域变量来声明。 而是块级作用域变量需要在明显不同的块里声明。

function f(condition, x) {
    if (condition) {
        let x = 100;
        return x;
    }


    return x;
}


f(false, 0); // returns 0
f(true, 0);  // returns 100

在一个嵌套作用域里引入一个新名字的行为称做屏蔽。 它是一把双刃剑，它可能会不小心地引入新问题，同时也可能会解决一些错误。 例如，假设我们现在用 let重写之前的sumMatrix函数。

function sumMatrix(matrix: number[][]) {
    let sum = 0;
    for (let i = 0; i < matrix.length; i++) {
        var currentRow = matrix[i];
        for (let i = 0; i < currentRow.length; i++)      {
            sum += currentRow[i];
        }
    }


    return sum;
}

这个版本的循环能得到正确的结果，因为内层循环的i可以屏蔽掉外层循环的i。

通常来讲应该避免使用这种屏蔽，因为我们需要写出清晰的代码。

块级作用域变量的获取

let声明每次迭代都会创建一个新作用域。 这就是我们在使用立即执行的函数表达式时做的事，所以在 setTimeout 例子里我们仅使用 let 声明就可以了。

for (let i = 0; i < 10 ; i++) {
    setTimeout(function() {
        console.log(i); 
    }, 100 * i);
}

会输出与预料一致的结果：

0
1
2
3
4
5
6
7
8
9

const 声明

const 声明是声明变量的另一种方式。

const numLivesForCat = 9;

const声明的变量只允许一次赋值, 引用的值是不可变的。

const numLivesForCat = 9;
const kitty = {
    name: "Aurora",
    numLives: numLivesForCat,
}


// 重新赋值一个类会报错
kitty = {
    name: "Loen",
    numLives: numLivesForCat
};


// 属性修改是允许的
kitty.name = "Rory";
kitty.name = "Kitty";
kitty.name = "Cat";
kitty.numLives--;

除非你使用特殊的方法去避免，实际上const变量的内部状态是可修改的。 幸运的是，TypeScript允许你将对象的成员设置成只读的。

解构

解构数组

最简单的解构莫过于数组的解构赋值了：

let input = [1, 2];
let [first, second] = input;
console.log(first); // outputs 1
console.log(second); // outputs 2

这创建了2个命名变量 first 和 second。 相当于使用了索引，但更为方便：

first = input[0];
second = input[1];

解构作用于已声明的变量会更好：

// 对换变量的值
[first, second] = [second, first];

作用于函数参数：

function f([first, second]: [number, number]) {
    console.log(first);
    console.log(second);
}
f(input);

你可以在数组里使用...语法创建剩余变量：

let [first, ...rest] = [1, 2, 3, 4];
console.log(first); // outputs 1
console.log(rest); // outputs [ 2, 3, 4 ]

当然，由于是 JavaScript, 你可以忽略你不关心的尾随元素：

let [first] = [1, 2, 3, 4];
console.log(first); // outputs 1

或其它元素：

let [, second, , fourth] = [1, 2, 3, 4];

对象解构

你也可以解构对象：

let o = {
    a: "foo",
    b: 12,
    c: "bar"
};
let { a, b } = o;

这通过 o.a and o.b 创建了 a 和 b 。 注意，如果你不需要 c 你可以忽略它。

就像数组解构，你可以用没有声明的赋值：

({ a, b } = { a: "baz", b: 101 });

注意:我们需要用括号将它括起来，因为Javascript通常会将以 { 起始的语句解析为一个块。

你可以在对象里使用…语法创建剩余变量：

let { a, ...passthrough } = o;
let total = passthrough.b + passthrough.c.length;

属性重命名

你也可以给属性以不同的名字：

let { a: newName1, b: newName2 } = o;

这里的语法开始变得混乱。 你可以将 a: newName1 读做 a 作为 newName1。 方向是从左到右，好像你写成了以下样子：

let newName1 = o.a;
let newName2 = o.b;

令人困惑的是，这里的冒号不是指示类型的。 如果你想指定它的类型， 仍然需要在其后写上完整的模式。

let {a, b}: {a: string, b: number} = o;

默认值

默认值可以让你在属性为 undefined 时使用缺省值：

function keepWholeObject(wholeObject: { a: string, b?: number }) 
{
    let { a, b = 1001 } = wholeObject;
}

现在，即使 b 为 undefined ， keepWholeObject 函数的变量 wholeObject 的属性 a 和 b 都会有值。

函数声明

解构也能用于函数声明。 看以下简单的情况：

type C = { a: string, b?: number }
function f({ a, b }: C): void {
    // ...
}

通常情况下更多的是指定默认值，解构默认值有些棘手。 首先，你需要在默认值之前设置其格式。

function f({ a, b } = { a: "", b: 0 }): void {
    // ...
}
f(); // 默认 { a: "", b: 0 }

你需要知道在解构属性上给予一个默认或可选的属性用来替换主初始化列表。 要知道 C 的定义有一个 b 可选属性：

function f({ a, b = 0 } = { a: "" }): void {
    // ...
}
f({ a: "yes" }); // 默认 b = 0
f(); // 默认 {a: ""},  b = 0
f({}); // 错误, 如果您提供参数，则需要'a'

从前面的例子可以看出, 要小心使用解构。就算是最简单的解构表达式也是难以理解的。 尤其当存在深层嵌套解构的时候，就算这时没有堆叠在一起的重命名，默认值和类型注解，也是令人难以理解的。

解构表达式要尽量保持小而简单。

展开

展开操作符正与解构相反。 它允许你将一个数组展开为另一个数组，或将一个对象展开为另一个对象。 例如：

let first = [1, 2];
let second = [3, 4];
let bothPlus = [0, ...first, ...second, 5];

这会令bothPlus的值为 [0, 1, 2, 3, 4, 5] 。 展开操作创建了 first 和 second 的一份浅拷贝。 它们不会被展开操作所改变。

你还可以展开对象：

let defaults = { food: "spicy", price: "$", ambiance: "noisy" };
let search = { ...defaults, food: "rich" };

search的值为 { food: “rich”, price: “$“, ambiance: “noisy” } 。 对象的展开比数组的展开要复杂的多。 像数组展开一样，它是从左至右进行处理，但结果仍为对象。 这就意味着出现在展开对象后面的属性会覆盖前面的属性。 因此，如果我们修改上面的例子，在结尾处进行展开的话：

let defaults = { food: "spicy", price: "$", ambiance: "noisy" };
let search = { food: "rich", ...defaults };

那么， defaults 里的 food 属性会重写 food: “rich” ，在这里这并不是我们想要的结果。

对象展开还有其它一些意想不到的限制。 首先，它仅包含对象 自身的可枚举属性。 大体上是说当你展开一个对象实例时，你会丢失其方法：

class C {
  p = 12;
  m() {
  }
}
let c = new C();
let clone = { ...c };
clone.p; // 没问题
clone.m(); // 错误

函数

函数介绍

函数是JavaScript应用程序的基础。 它帮助你实现抽象层，模拟类，信息隐藏和模块。 在TypeScript里，虽然已经支持类，命名空间和模块，但函数仍然是主要的定义 行为的地方。 TypeScript为JavaScript函数添加了额外的功能，让我们可以更容易地使用。

Typescript 函数

和JavaScript一样，TypeScript函数可以创建有名字的函数和匿名函数。 你可以随意选择适合应用程序的方式，不论是定义一系列API函数还是只使用一次的函数。

通过下面的例子可以迅速回想起这两种JavaScript中的函数：

// 命名函数
function add(x, y) {
    return x + y;
}


// 匿名函数
let myAdd = function(x, y) { return x + y; };

函数类型

为函数定义类型 我们可以为函数本身添加返回值类型。

函数():类型 {}

我们给函数添加类型：

function add(x: number, y: number): number {
    return x + y;
}


let myAdd = function(x: number, y: number): number { return x + y; };

TypeScript能够根据返回语句自动推断出返回值类型，因此我们通常省略它。

函数参数

TypeScript里的每个函数参数都是必须的。 传递给一个函数的参数个数必须与函数期望的参数个数一致。

function buildName(firstName: string, lastName: string) {
    return firstName + " " + lastName;
}
// error, too few parameters
let result1 = buildName("Bob");


// error, too many parameters
let result2 = buildName("Bob", "Adams", "Sr.");


// 这种方式是正确的
let result3 = buildName("Bob", "Adams");

可选参数

在TypeScript里我们可以在参数名旁使用 ? 实现可选参数的功能。 比如，我们想让last name是可选的：

function buildName(firstName: string, lastName?: string) {
    if (lastName)
        return firstName + " " + lastName;
    else
        return firstName;
}
// 现在这样也可以
let result1 = buildName("Bob"); 


// error, too many parameters
let result2 = buildName("Bob", "Adams", "Sr.");


// 这种方式是正确的
let result3 = buildName("Bob", "Adams");

注意: 可选参数必须跟在必须参数后面。 如果上例我们想让first name是可选的，那么就必须调整它们的位置，把first name放在后面。

默认参数

在TypeScript里，我们也可以为参数提供一个默认值。让我们修改上例，把last name的默认值设置为"Smith”。

function buildName(firstName: string, lastName = "Smith") {
    return firstName + " " + lastName;
}


// 这样是可以工作的 返回 "Bob Smith"
let result1 = buildName("Bob");


// 这样也可以工作返回 "Bob Smith"
let result2 = buildName("Bob", undefined);


// error, too many parameters
let result3 = buildName("Bob", "Adams", "Sr.");
// 这是正确的返回 "Bob Adams"
let result4 = buildName("Bob", "Adams");

剩余参数

当你想同时操作多个参数，而你并不知道会有多少参数传递进来。 在JavaScript里，你可以使用 arguments来访问所有传入的参数。 而在TypeScript里，你可以使用 …变量名 把所有参数收集到一个变量里：

function buildName(firstName: string, ...restOfName: string[]) {
  return firstName + " " + restOfName.join(" ");
}


let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");

剩余参数会被当做个数不限的可选参数。 可以一个都没有，同样也可以有任意个。

这个省略号也会在带有剩余参数的函数类型定义上使用到：

function buildName(firstName: string, ...restOfName: string[]) {
  return firstName + " " + restOfName.join(" ");
}

箭头函数

表现形式

基本语法 ES6 允许使用“箭头”（=>）定义函数 箭头函数相当于匿名函数，并且简化了函数定义 表现形式一： 包含一个表达式，连{ … }和return都省略掉了

 x => x * x
//等同于
function (x) {
  return x*x;
};

表示形式二： 包含多条语句，这时候就不能省略{ … }和return

x => {
if (x > 0) {
    return x * x;
}
else {
    return - x * x;
}
}

this

箭头函数的引入有两个方面的作用：

• 一是更简短的函数书写
• 二是对this的词法解析。

普通函数: this指向调用它的那个对象 箭头函数:不绑定this，会捕获其所在的上下文的this值，作为自己的this值,任何方法都改变不了其指向，如: call(),bind(),apply()

var obj = {
a: 10,
b: () => {
console.log('b this.a:',this.a); // undefined
console.log('b this:',this); // Window
 },
 c: function() {
console.log('c this.a:',this.a); // 10
console.log('c this:',this); // {a: 10, b: ƒ, c: ƒ}
}
 }
obj.b(); 
obj.c();

执行结果: 

函数重载

所谓函数重载就是同一个函数，根据传递的参数不同，会有不同的表现形式。

JavaScript本身是没有重载这个概念，不过可以模拟实现。 JavaScript 代码实例如下：

function func(){ 
  if(arguments.length==0){ 
    alert("欢迎来到w3cschool");  
  } 
  else if(arguments.length==1){ 
    alert(arguments[0]) 
  } 
} 
func(); 
func(2);

上面代码利用arguments对象来判断传递参数的数量，然后执行不同的代码。

TypeScript 函数重载

TypeScript提供了重载功能，TypeScript的函数重载只有一个函数体，也就是说无论声明多少个同名且不同签名的函数，它们共享一个函数体，在调用时会根据传递实参类型的不同，利用流程控制语句控制代码的执行。

TypeScript代码实例如下:

function func(x:string):string;
function func(x:number):number;
function func(x:any):any{
  if(typeof x=="string"){
    return "欢迎来到w3cschool"
  }else if(typeof x=="number"){
    return 5
  }
}

function func(x:any):any不是函数重载列表一部分，所以上述代码只定义两个重载。

重载函数的共用函数体部分如下：

function func(x:any):any{
  if(typeof x=="string"){
    return "欢迎来到w3cschool"
  }else if(typeof x=="number"){
    return 5
  }
}

重载函数编译后的JavaScript代码:

function func(x) {
  if (typeof x == "string") {
    return "欢迎来到w3cschool";
  }
  else if (typeof x == "number") {
    return 5;
  }
}

由于JavaScript本身不支持重载，所以TypeScript重载实质上为了方便调用者如何调用函数。

接口

接口介绍

在TypeScript里，接口的作用就是为这些类型命名和为你的代码或第三方代码定义契约。

接口初探

下面通过一个简单示例来观察接口是如何工作的：

function printLabel(labelledObj: { label: string }) {
  console.log(labelledObj.label);
}


let myObj = { size: 10, label: "Size 10 Object" };
printLabel(myObj);

类型检查器会查看 printLabel 的调用。 printLabel 有一个参数，并要求这个对象参数有一个名为 label 类型为 string 的属性。

需要注意的是，我们传入的对象参数实际上会包含很多属性，但是编译器只会检查那些必需的属性是否存在，并且其类型是否匹配。

下面我们重写上面的例子，这次使用接口来描述：必须包含一个 label 属性且类型为 string ：

interface LabelledValue {
  label: string;
}


function printLabel(labelledObj: LabelledValue) {
  console.log(labelledObj.label);
}


let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);

LabelledValue接口就好比一个名字，用来描述上面例子里的要求。 它代表了有一个 label 属性且类型为 string 的对象。

只要传入的对象满足上面提到的必要条件，那么它就是被允许的。

类型检查器不会去检查属性的顺序，只要相应的属性存在并且类型也是对的就可以。

可选属性

接口里的属性不全都是必需的。 有些是只在某些条件下存在，或者根本不存在。 可选属性在应用“option bags”模式时很常用，即给函数传入的参数对象中只有部分属性赋值了。

下面是应用了“option bags”的例子：

interface SquareConfig {
  color?: string;
  width?: number;
}


function createSquare(config: SquareConfig): {color: string; area: number} {
  let newSquare = {color: "white", area: 100};
  if (config.color) {
    newSquare.color = config.color;
  }
  if (config.width) {
    newSquare.area = config.width * config.width;
  }
  return newSquare;
}


let mySquare = createSquare({color: "black"});

带有可选属性的接口与普通的接口定义差不多，只是在可选属性名字定义的后面加一个?符号。

可选属性的好处之一是可以对可能存在的属性进行预定义，好处之二是可以捕获引用了不存在的属性时的错误。 比如，我们故意将 createSquare里的color属性名拼错，就会得到一个错误提示：

interface SquareConfig {
  color?: string;
  width?: number;
}


function createSquare(config: SquareConfig): { color: string; area: number } {
  let newSquare = {color: "white", area: 100};
  if (config.color) {
    // Error: Property 'clor' does not exist on type 'SquareConfig'
    newSquare.color = config.clor;
  }
  if (config.width) {
    newSquare.area = config.width * config.width;
  }
  return newSquare;
}


let mySquare = createSquare({color: "black"});

只读属性

可以在属性名前用 readonly来指定只读属性:

interface Point {
    readonly x: number;
    readonly y: number;
}

可以通过赋值一个对象字面量来构造一个Point。 赋值后， x 和 y 再也不能被改变了。

let p1: Point = { x: 10, y: 20 };
p1.x = 5; // error!

TypeScript 具有 ReadonlyArray 类型，它与 Array 相似，只是把所有可变方法去掉了，因此可以确保数组创建后再也不能被修改：

let a: number[] = [1, 2, 3, 4];
let ro: ReadonlyArray<number> = a;
ro[0] = 12; // error!
ro.push(5); // error!
ro.length = 100; // error!
a = ro; // error!

上面代码的最后一行，可以看到就算把整个ReadonlyArray赋值到一个普通数组也是不可以的。 但是你可以用类型断言重写：

a = ro as number[];

readonly, const使用时机

做为变量使用的话用 const ，若做为属性则使用 readonly 。

函数类型

接口能够描述JavaScript中对象拥有的各种各样的外形。 除了描述带有属性的普通对象外，接口也可以描述函数类型。

为了使用接口表示函数类型，我们需要给接口定义一个调用签名。 它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。

interface SearchFunc {
  (source: string, subString: string): boolean;
}

这样定义后，我们可以像使用其它接口一样使用这个函数类型的接口。 下例展示了如何创建一个函数类型的变量，并将一个同类型的函数赋值给这个变量。

let mySearch: SearchFunc;
mySearch = function(source: string, subString: string) {
  let result = source.search(subString);
  return result > -1;
}

对于函数类型的类型检查来说，函数的参数名不需要与接口里定义的名字相匹配。 比如，我们使用下面的代码重写上面的例子：

let mySearch: SearchFunc;
mySearch = function(src: string, sub: string): boolean {
  let result = src.search(sub);
  return result > -1;
}

函数的参数会逐个进行检查，要求对应位置上的参数类型是兼容的。 如果你不想指定类型，TypeScript的类型系统会推断出参数类型，因为函数直接赋值给了 SearchFunc类型变量。 函数的返回值类型是通过其返回值推断出来的（此例是 false和true）。 如果让这个函数返回数字或字符串，类型检查器会警告我们函数的返回值类型与SearchFunc接口中的定义不匹配。

let mySearch: SearchFunc;
mySearch = function(src, sub) {
    let result = src.search(sub);
    return result > -1;
}

实现接口

与C#或Java里接口的基本作用一样，TypeScript也能够用它来明确的强制一个类去符合某种契约。

interface ClockInterface {
    currentTime: Date;
}


class Clock implements ClockInterface {
    currentTime: Date;
    constructor(h: number, m: number) { }
}

你也可以在接口中描述一个方法，在类里实现它，如同下面的setTime方法一样：

interface ClockInterface {
    currentTime: Date;
    setTime(d: Date);
}


class Clock implements ClockInterface {
    currentTime: Date;
    setTime(d: Date) {
        this.currentTime = d;
    }
    constructor(h: number, m: number) { }
}

接口描述了类的公共部分，而不是公共和私有两部分。 它不会帮你检查类是否具有某些私有成员。

继承接口

和类一样，接口也可以相互继承。 这让我们能够从一个接口里复制成员到另一个接口里，可以更灵活地将接口分割到可重用的模块里。

interface Shape {
    color: string;
}


interface Square extends Shape {
    sideLength: number;
}


let square = <Square>{};
square.color = "blue";
square.sideLength = 10;

一个接口可以继承多个接口，创建出多个接口的合成接口。

interface Shape {
    color: string;
}


interface PenStroke {
    penWidth: number;
}


interface Square extends Shape, PenStroke {
    sideLength: number;
}


let square = <Square>{};
square.color = "blue";
square.sideLength = 10;
square.penWidth = 5.0;

类

类介绍

传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件，但对于熟悉使用面向对象方式的程序员来讲就有些棘手，因为他们用的是基于类的继承并且对象是由类构建出来的。 从ECMAScript 2015，也就是ECMAScript 6开始，JavaScript程序员将能够使用基于类的面向对象的方式。

使用TypeScript，我们允许开发者现在就使用这些特性，并且编译后的JavaScript可以在所有主流浏览器和平台上运行，而不需要等到下个JavaScript版本。

类

下面看一个使用类的例子：

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}


let greeter = new Greeter("world");

如果你使用过C#或Java，你会对这种语法非常熟悉。 我们声明一个 Greeter类。这个类有3个成员：一个叫做 greeting的属性，一个构造函数和一个 greet方法。

你会注意到，我们在引用任何一个类成员的时候都用了 this。 它表示我们访问的是类的成员。

最后一行，我们使用 new 构造了 Greeter类的一个实例。 它会调用之前定义的构造函数，创建一个Greeter类型的新对象，并执行构造函数初始化它。

继承

在TypeScript里，我们可以使用常用的面向对象模式。 基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有的类。

看下面的例子：

class Animal {
    move(distanceInMeters: number = 0) {
        console.log(`Animal moved ${distanceInMeters}m.`);
    }
}


class Dog extends Animal {
    bark() {
        console.log('Woof! Woof!');
    }
}


const dog = new Dog();
dog.bark();
dog.move(10);
dog.bark();

这个例子展示了最基本的继承：类从基类中继承了属性和方法。 这里， Dog是一个 派生类，它派生自Animal 基类，通过 extends关键字。 派生类通常被称作 子类，基类通常被称作 超类。

因为 Dog继承了 Animal的功能，因此我们可以创建一个 Dog的实例，它能够 bark() 和 move()。

下面我们来看个更加复杂的例子。

class Animal {
    name: string;
    constructor(theName: string) { this.name = theName; }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}


class Snake extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 5) {
        console.log("Slithering...");
        super.move(distanceInMeters);
    }
}


class Horse extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters);
    }
}


let sam = new Snake("Sammy the Python");
let tom: Animal = new Horse("Tommy the Palomino");


sam.move();
tom.move(34);

这个例子展示了一些上面没有提到的特性。 这一次，我们使用 extends关键字创建了 Animal的两个子类： Horse 和 Snake。

与前一个例子的不同点是，派生类包含了一个构造函数，它必须调用 super()，它会执行基类的构造函数。 而且，在构造函数里访问 this的属性之前，我们 一定要调用 super()。 这个是TypeScript强制执行的一条重要规则。

这个例子演示了如何在子类里可以重写父类的方法。 Snake类和 Horse类都创建了 move方法，它们重写了从 Animal继承来的 move方法，使得 move方法根据不同的类而具有不同的功能。 注意，即使tom被声明为 Animal类型，但因为它的值是 Horse，调用 tom.move(34)时，它会调用 Horse里重写的方法：

Slithering...
Sammy the Python moved 5m.
Galloping...
Tommy the Palomino moved 34m.

公共，私有与受保护的修饰符

public

在TypeScript里，成员都默认为 public。

你也可以明确的将一个成员标记成 public。 我们可以用下面的方式来重写 Animal类：

class Animal {
    public name: string;
    public constructor(theName: string) { this.name = theName; }
    public move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

private

当成员被标记成 private时，它就不能在声明它的类的外部访问。比如：

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}


new Animal("Cat").name; // 错误: 'name' 是私有的.

protected

protected修饰符与 private修饰符的行为很相似，但有一点不同， protected成员在派生类中仍然可以访问。例如：

class Person {
    protected name: string;
    constructor(name: string) { this.name = name; }
}


class Employee extends Person {
    private department: string;


    constructor(name: string, department: string) {
        super(name)
        this.department = department;
    }


    public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}


let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误

注意，我们不能在 Person类外使用 name，但是我们仍然可以通过 Employee类的实例方法访问，因为 Employee是由 Person派生而来的。

构造函数也可以被标记成 protected。 这意味着这个类不能在包含它的类外被实例化，但是能被继承。比如，

class Person {
    protected name: string;
    protected constructor(theName: string) { this.name = theName; }
}


// Employee 能够继承 Person
class Employee extends Person {
    private department: string;


    constructor(name: string, department: string) {
        super(name);
        this.department = department;
    }


    public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}


let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // 错误: 'Person' 的构造函数是被保护的.

readonly修饰符

你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。

class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor (theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的.

参数属性

在上面的例子中，我们不得不定义一个受保护的成员 name和一个构造函数参数 theName在 Person类里，并且立刻给 name和 theName赋值。 这种情况经常会遇到。 参数属性可以方便地让我们在一个地方定义并初始化一个成员。 下面的例子是对之前 Animal类的修改版，使用了参数属性：

class Animal {
    constructor(private name: string) { }
    move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

注意看我们是如何舍弃了 theName，仅在构造函数里使用 private name: string参数来创建和初始化 name成员。 我们把声明和赋值合并至一处。

参数属性通过给构造函数参数添加一个访问限定符来声明。 使用 private限定一个参数属性会声明并初始化一个私有成员；对于 public和 protected来说也是一样。

存取器

TypeScript支持通过getters/setters来截取对对象成员的访问。 它能帮助你有效的控制对对象成员的访问。

下面来看如何把一个简单的类改写成使用 get和 set。 首先，我们从一个没有使用存取器的例子开始。

class Employee {
    fullName: string;
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    console.log(employee.fullName);
}

我们可以随意的设置 fullName，这是非常方便的，但是这也可能会带来麻烦。

下面这个版本里，我们先检查用户密码是否正确，然后再允许其修改员工信息。 我们把对 fullName的直接访问改成了可以检查密码的 set方法。 我们也加了一个 get方法，让上面的例子仍然可以工作。

let passcode = "secret passcode";

class Employee {
    private _fullName: string;

    get fullName(): string {
        return this._fullName;
    }

    set fullName(newName: string) {
        if (passcode && passcode == "secret passcode") {
            this._fullName = newName;
        }
        else {
            console.log("Error: Unauthorized update of employee!");
        }
    }
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    alert(employee.fullName);
}

我们可以修改一下密码，来验证一下存取器是否是工作的。当密码不对时，会提示我们没有权限去修改员工。

对于存取器有下面几点需要注意的：

首先，存取器要求你将编译器设置为输出ECMAScript 5或更高。 不支持降级到ECMAScript 3。 其次，只带有 get不带有 set的存取器自动被推断为 readonly。 这在从代码生成 .d.ts文件时是有帮助的，因为利用这个属性的用户会看到不允许够改变它的值。

静态属性

到目前为止，我们只讨论了类的实例成员，那些仅当类被实例化的时候才会被初始化的属性。 我们也可以创建类的静态成员，这些属性存在于类本身上面而不是类的实例上。 在这个例子里，我们使用static定义 origin，因为它是所有网格都会用到的属性。 每个实例想要访问这个属性的时候，都要在 origin前面加上类名。 如同在实例属性上使用 this.前缀来访问属性一样，这里我们使用 Grid.来访问静态属性。

class Grid {
    static origin = {x: 0, y: 0};
    calculateDistanceFromOrigin(point: {x: number; y: number;}) {
        let xDist = (point.x - Grid.origin.x);
        let yDist = (point.y - Grid.origin.y);
        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
    }
    constructor (public scale: number) { }
}

let grid1 = new Grid(1.0);  // 1x scale
let grid2 = new Grid(5.0);  // 5x scale

console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));

抽象类

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('roaming the earch...');
    }
}

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 abstract关键字并且可以包含访问修饰符。

abstract class Department {

    constructor(public name: string) {
    }

    printName(): void {
        console.log('Department name: ' + this.name);
    }

    abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {

    constructor() {
        super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
    }

    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }

    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在

泛型

泛型介绍

软件工程中，我们不仅要创建一致的定义良好的API，同时也要考虑可重用性。 组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能。

在像C#和Java这样的语言中，可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。 这样用户就可以以自己的数据类型来使用组件。

非泛型例子

下面来创建 identity函数。 这个函数会返回任何传入它的值。 你可以把这个函数当成是 echo命令。

非泛型例子1：

function identity(arg: number): number {
    return arg;
}

非泛型例子2: 使用any类型来定义函数

function identity(arg: any): any {
    return arg;
}

使用any类型会导致这个函数可以接收任何类型的arg参数，这样就丢失了一些信息：传入的类型与返回的类型应该是相同的。如果我们传入一个数字，我们只知道任何类型的值都有可能被返回。

泛型的例子

我们需要一种方法使返回值的类型与传入参数的类型是相同的。 这里，我们使用了 类型变量，它是一种特殊的变量，只用于表示类型而不是值。

function identity<T>(arg: T): T {
    return arg;
}

我们给identity添加了类型变量T。 T帮助我们捕获用户传入的类型（比如：number），之后我们就可以使用这个类型。 之后我们再次使用了 T当做返回值类型。现在我们可以知道参数类型与返回值类型是相同的了。 这允许我们跟踪函数里使用的类型的信息。

我们把这个版本的identity函数叫做泛型，因为它可以适用于多个类型。 不同于使用 any，它不会丢失信息，像第一个例子那像保持准确性，传入数值类型并返回数值类型。

泛型类

泛型类看上去与泛型接口差不多。 泛型类使用（ <>）括起泛型类型，跟在类名后面。

class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}


let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };

GenericNumber类的使用是十分直观的，并且你可能已经注意到了，没有什么去限制它只能使用number类型。 也可以使用字符串或其它更复杂的类型。

let stringNumeric = new GenericNumber<string>();
stringNumeric.zeroValue = "";
stringNumeric.add = function(x, y) { return x + y; };


console.log(stringNumeric.add(stringNumeric.zeroValue, "test"));

与接口一样，直接把泛型类型放在类后面，可以帮助我们确认类的所有属性都在使用相同的类型。

我们在类那节说过，类有两部分：静态部分和实例部分。 泛型类指的是实例部分的类型，所以类的静态属性不能使用这个泛型类型。

枚举

默认情况下，枚举是基于 0 的，也就是说第一个值是 0，后面的值依次递增。不要担心，当中的每一个值都可以显式指定，只要不出现重复即可，没有被显式指定的值，都会在前一个值的基础上递增。

enum Color {Red, Green, Blue}
let c: Color = Color.Green;  // 1

或者

enum Color {Red = 1, Green, Blue = 4}
let c: Color = Color.Green;  // 2

枚举有一个很方便的特性，就是您也可以向枚举传递一个数值，然后获取它对应的名称值。举个例子，如果我们有一个值 2，但是不清楚在 Color 枚举中与之对应的名称是什么，我们就可以通过以下的方式来进行检索：

enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];  // 'Green'

但是像上面的这种写法不是太好，因为如果您给定的数值没有与之对应的枚举项，那么结果就是 undefined。所以，如果您想要得到指定枚举项的字符串名称，可以使用类似这样的写法：

let colorName: string = Color[Color.Green];  // 'Green'

命名空间

TypeScript里使用命名空间（之前叫做“内部模块”）来组织你的代码。任何使用 module关键字来声明一个内部模块的地方都应该使用namespace关键字来替换。 这就避免了让新的使用者被相似的名称所迷惑。

命名空间介绍

下面的例子里，把所有与验证器相关的类型都放到一个叫做Validation的命名空间里。 因为我们想让这些接口和类在命名空间之外也是可访问的，所以需要使用 export。 相反的，变量 lettersRegexp和numberRegexp是实现的细节，不需要导出，因此它们在命名空间外是不能访问的。 在文件末尾的测试代码里，由于是在命名空间之外访问，因此需要限定类型的名称，比如 Validation.LettersOnlyValidator。

namespace Validation {
    export interface StringValidator {
        isAcceptable(s: string): boolean;
    }


    const lettersRegexp = /^[A-Za-z]+$/;
    const numberRegexp = /^[0-9]+$/;


    export class LettersOnlyValidator implements StringValidator {
        isAcceptable(s: string) {
            return lettersRegexp.test(s);
        }
    }


    export class ZipCodeValidator implements StringValidator {
        isAcceptable(s: string) {
            return s.length === 5 && numberRegexp.test(s);
        }
    }
}


// Some samples to try
let strings = ["Hello", "98052", "101"];


// Validators to use
let validators: { [s: string]: Validation.StringValidator; } = {};
validators["ZIP code"] = new Validation.ZipCodeValidator();
validators["Letters only"] = new Validation.LettersOnlyValidator();


// Show whether each string passed each validator
for (let s of strings) {
    for (let name in validators) {
        console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" } ${ name }`);
    }
}

title: 2024-04-21出游计划
date: 2024-04-18 00:22:27.263
updated: 2024-04-18 00:30:01.428
url: https://blog.huangge1199.cn/archives/2024-04-21-chu-you-ji-hua
categories:

• 游玩
  tags:

• 游玩

本次沈阳出游计划旨在让您深入了解沈阳丰富的历史文化和艺术气息。行程包括参观庭澜美术馆，欣赏那里的各类美术作品和艺术展览，随后将参观王明宇公馆旧址，了解沈阳的历史人物和旧时生活环境。接着前往常荫槐公馆，感受沈阳曾经的政治风云。吕氏丹青则为您展示了书法和绘画的艺术魅力。旅程还将包括叁叁文创园，体验文创氛围和时尚气息。最后一站是刘鸿典建筑博物馆，全面了解沈阳的建筑特色和历史变迁。这个全面的沈阳出游计划将使您充分感受到沈阳深厚的文化底蕴和艺术魅力。

title: 2024-04-03预选游玩的展览
date: 2024-04-03 14:22:17.135
updated: 2024-04-03 14:22:20.34
url: https://blog.huangge1199.cn/archives/2024-04-03-yu-xuan-you-wan-de-zhan-lan
categories:

• 游玩
  tags:

• 游玩

计划

• [ ] 吕氏丹青
• [ ] 超越永恒的金子
• [ ] 创世山海经
• [ ] 此物非彼物
• [ ] 春暖花又开

吕氏丹青

展览时间：2024年3月31日至2024年6月30日 9:00am—18:00pm(每周一闭馆)

展览地点：沈阳市沈河区八纬路48号 Bifrost Gallery X拾物研舍

费用：49元

超越永恒的金子

展览时间：2024.1.27-2024.4.7

展览地点：沈阳k11 4层 艺术空间

费用：单人50元/双人88元

创世山海经

展览时间：2024年4月3日-6月16日 10:00-22:00

展览地点：沈阳K11购物艺术中心L2展厅

费用：

早鸟通票58元(原价78元)
早鸟儿童票 28元（原价78元）
早鸟优待票38元

开展后：
单人票78元 儿童票 38元（原价78元）
亲子票99元 优待票48元
双人票128元 三人票178元

此物非彼物

展览时间：2024.03.29-2024.04.29 10:00-17:00

展览地点：沈阳市沈河区正阳街192号庭澜美术馆

费用：免费

春暖花又开

展览时间：2024年3月20日——4月20日

展览地点：沈阳美术馆1号厅、3号厅

费用：免费

title: 2024-03-30出行项目规划
date: 2024-03-29 21:20:58.0
updated: 2024-04-03 14:22:34.956
url: https://blog.huangge1199.cn/archives/2023-03-30-chu-xing-xiang-mu-gui-hua
categories:

• 游玩
  tags:
• 游玩

1、中国沈阳审判日本战犯法庭旧址陈列馆
9:00 ~ 16:00
2、北塔（护国法轮寺）
8:30 ~ 15:00
步行1.5公里，20分钟，公交车至少30分钟（还需要走1公里左右）
3、东塔（护国永光寺，46分钟，4元）
9:00 ~ 16:00
10号线（长安路D口）-> 237（东塔，8分钟）
4、南塔（护国广慈寺，50分钟，4元）
8:00 ~ 17:00
237（大南门西，8分钟）->环路（南塔，5分钟）
5、西塔（护国延寿寺）（58分钟，2元）
20:00 ~ 24:00,12:00 ~ 15:00
282（西塔东站，8分钟）
6、奉天工场文化创意园（57分钟，4元）
10:00 ~ 21:00
243（北二路兴工街，8分钟）->235（北二路启工街，15分钟）

一、下载压缩包

下载mysql server的zip文件，地址：Windows (x86, 64-bit), ZIP Archive

解压后：

二、创建配置文件（可忽略）

配置文件可存放位置及名称：

• C:\WINDOWS\my.ini

• C:\WINDOWS\my.cnf

• C:\my.ini

• C:\my.cnf

• 解压目录的根目录下（mysql-8.3.0-winx64）\my.ini

• 解压目录的根目录下（mysql-8.3.0-winx64）\my.cnf

三、初始化数据库

以管理员身份运行cmd，进入到bin目录，运行下面的命令创建mysql默认的数据库，并创建一个root账号，空密码

mysqld --initialize-insecure

四、启动MySQL服务

我使用的是安装到服务的方式，执行下面的命令

mysqld --install-manual

默认创建的服务名称为MySQL，然后在服务中启动

也可以直接运行一下命令

mysqld

这是最简单的方式了，但是无法安装到服务中，其他详细的可参看帮助说明

mysqld --verbose --help | more

红色框内的是安装相关的命令，蓝色框内是移除服务相关的命令

五、测试

运行命令确认MySQL能够使用

mysql -uroot

六、修改root密码

由于前面的方式，root用户没有密码，需要添加个密码，MySQL进入后，执行下面的命令给root设置密码

use mysql；
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新密码';
FLUSH PRIVILEGES;

引言

在软件开发中，版本控制是一个至关重要的环节。Git 作为目前最流行的版本控制工具之一，提供了丰富的功能和灵活的操作方式。本文将介绍一些常用的 Git 操作，包括管理子模块、修改用户名、使用 Git Subtree 合并项目以及其他一些常见操作。

一、引用子模块

git submodule是一个用于将其他两个 Git 仓库嵌入到一个主仓库中。这样做可以使主仓库包含其他两个仓库的内容，并能够管理它们的版本和更新。以下是将两个其他仓库添加为子模块到主仓库的基本步骤：

1、初始化主仓库

mkdir main_project
cd main_project
git init

2、添加子模块

使用 git submodule add 命令将其他仓库添加为子模块到主仓库中。

git submodule add <URL_of_repository1> repository1_folder
git submodule add <URL_of_repository2> repository2_folder

3、提交更改

git commit -m "Add submodules repository1 and repository2"

现在，主仓库包含了两个子模块，它们的内容在 repository1_folder 和 repository2_folder 中。

当你克隆主仓库时，子模块的内容并不会自动下载。你需要执行以下命令来初始化和更新子模块：

git submodule update --init --recursive

这会初始化并拉取子模块的内容。之后，你可以像管理普通的 Git 仓库一样来管理这些子模块，例如切换到不同的分支或提交更改。

需要注意的是，子模块在主仓库中只是一个指向子仓库的引用，它不会把子仓库的内容直接嵌入到主仓库中。这意味着你可以独立地管理每个子仓库的版本和更新。

在主仓库中，如果需要查看子模块的提交记录，可以使用下面的命令：

git log --recurse-submodules

二、删除引用的子模块

如果需要删除子模块，你需要执行以下步骤：

1、移除子模块的配置

使用 git submodule deinit 命令来从 .gitmodules 文件中移除子模块的配置信息，并删除 .git/modules/<submodule_folder> 文件夹中的子模块内容。例如，假设子模块的文件夹名为 submodule_folder：

git submodule deinit -f <submodule_folder>

2、 删除子模块的文件夹

删除主项目中包含子模块内容的文件夹。在上面的例子中，删除名为 <submodule_folder> 的文件夹：

git rm -f <submodule_folder>

3、提交更改

git commit -m "Remove submodule <submodule_folder>"
git push

三、修改用户名

要修改 Git 中的用户名，你需要执行以下步骤：

1、全局修改用户名

使用以下命令设置全局用户名：

git config --global user.name "Your New Username"

替换 "Your New Username" 为你想要设置的新用户名。

2、针对单个仓库修改用户名（可选）

如果你只想在特定的仓库中修改用户名，而不是全局修改，可以在该仓库中执行以下命令：

git config user.name "Your New Username"

3、验证修改是否成功

你可以运行以下命令来验证修改是否成功：

git config user.name

这会显示当前配置的用户名，确保它已经更新为你想要的新用户名。

通过执行上述步骤，你就可以修改 Git 中的用户名了。

四、整合子模块

Git Subtree 是一个用于合并不同 Git 仓库的工具，它允许将一个仓库的部分历史合并到另一个仓库中，而且可以保留提交记录。

以下是将子模块项目转移到主项目中并保存子模块项目的提交记录的基本步骤：

1、添加子模块内容到主项目中

git subtree add --prefix=<submodule_folder> <submodule_repo_url> <submodule_branch> --squash

这个命令将子模块的内容合并到主项目中的指定文件夹 <submodule_folder> 中。--squash 选项用于将子模块的历史压缩成一个新的提交。

2、提交更改到主项目

git commit -m "Merge submodule repository into main project"

这个提交将包含所有合并的子模块内容。

3、在以后的更新中同步子模块内容（可选）

如果子模块的内容在原始仓库中发生了变化，你可能想要将这些变化同步到主项目中。你可以使用以下命令：

git subtree pull --prefix=<submodule_folder> <submodule_repo_url> <submodule_branch> --squash

这会将子模块的最新更改合并到主项目中。

使用 git subtree 的主要优点是它可以保留子模块项目的提交历史，并将其合并到主项目的提交历史中。这样可以更清晰地追踪子模块项目的变化，并且可以保持主项目的整洁性。

五、其他常见操作

除了上述操作之外，还有一些其他常见的 Git 操作：

• 提交代码：使用 git commit 命令将修改提交到本地仓库。
• 推送代码：使用 git push 命令将本地仓库中的修改推送到远程仓库。
• 合并代码：使用 git merge 命令将不同分支的代码合并到当前分支。
• 创建分支：使用 git branch 命令创建新的分支。
• 拉取代码：使用 git pull 命令从远程仓库拉取最新的代码。

结语

本文介绍了一些常见的 Git 操作，包括管理子模块、修改用户名、使用 Git Subtree 合并项目以及其他一些常用操作。通过熟练掌握这些操作，你将能够更加高效地使用 Git 进行版本控制，并且更好地管理你的项目代码。

nacos数据库建表语句

/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info   */
/******************************************/
CREATE TABLE `config_info` (
                               `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
                               `data_id` VARCHAR(255) NOT NULL COMMENT 'data_id',
                               `group_id` VARCHAR(255) DEFAULT NULL,
                               `content` LONGTEXT NOT NULL COMMENT 'content',
                               `md5` VARCHAR(32) DEFAULT NULL COMMENT 'md5',
                               `gmt_create` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                               `gmt_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
                               `src_user` TEXT COMMENT 'source user',
                               `src_ip` VARCHAR(50) DEFAULT NULL COMMENT 'source ip',
                               `app_name` VARCHAR(128) DEFAULT NULL,
                               `tenant_id` VARCHAR(128) DEFAULT '' COMMENT '租户字段',
                               `c_desc` VARCHAR(256) DEFAULT NULL,
                               `c_use` VARCHAR(64) DEFAULT NULL,
                               `effect` VARCHAR(64) DEFAULT NULL,
                               `type` VARCHAR(64) DEFAULT NULL,
                               `c_schema` TEXT,
                               `encrypted_data_key` TEXT NOT NULL COMMENT '秘钥',
                               PRIMARY KEY (`id`),
                               UNIQUE KEY `uk_configinfo_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_aggr   */
/******************************************/
CREATE TABLE `config_info_aggr` (
                                    `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
                                    `data_id` VARCHAR(255) NOT NULL COMMENT 'data_id',
                                    `group_id` VARCHAR(255) NOT NULL COMMENT 'group_id',
                                    `datum_id` VARCHAR(255) NOT NULL COMMENT 'datum_id',
                                    `content` LONGTEXT NOT NULL COMMENT '内容',
                                    `gmt_modified` DATETIME NOT NULL COMMENT '修改时间',
                                    `app_name` VARCHAR(128) DEFAULT NULL,
                                    `tenant_id` VARCHAR(128) DEFAULT '' COMMENT '租户字段',
                                    PRIMARY KEY (`id`),
                                    UNIQUE KEY `uk_configinfoaggr_datagrouptenantdatum` (`data_id`,`group_id`,`tenant_id`,`datum_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='增加租户字段';


/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_beta   */
/******************************************/
CREATE TABLE `config_info_beta` (
                                    `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
                                    `data_id` VARCHAR(255) NOT NULL COMMENT 'data_id',
                                    `group_id` VARCHAR(128) NOT NULL COMMENT 'group_id',
                                    `app_name` VARCHAR(128) DEFAULT NULL COMMENT 'app_name',
                                    `content` LONGTEXT NOT NULL COMMENT 'content',
                                    `beta_ips` VARCHAR(1024) DEFAULT NULL COMMENT 'betaIps',
                                    `md5` VARCHAR(32) DEFAULT NULL COMMENT 'md5',
                                    `gmt_create` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                                    `gmt_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
                                    `src_user` TEXT COMMENT 'source user',
                                    `src_ip` VARCHAR(50) DEFAULT NULL COMMENT 'source ip',
                                    `tenant_id` VARCHAR(128) DEFAULT '' COMMENT '租户字段',
                                    `encrypted_data_key` TEXT NOT NULL COMMENT '秘钥',
                                    PRIMARY KEY (`id`),
                                    UNIQUE KEY `uk_configinfobeta_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_beta';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_tag   */
/******************************************/
CREATE TABLE `config_info_tag` (
                                   `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
                                   `data_id` VARCHAR(255) NOT NULL COMMENT 'data_id',
                                   `group_id` VARCHAR(128) NOT NULL COMMENT 'group_id',
                                   `tenant_id` VARCHAR(128) DEFAULT '' COMMENT 'tenant_id',
                                   `tag_id` VARCHAR(128) NOT NULL COMMENT 'tag_id',
                                   `app_name` VARCHAR(128) DEFAULT NULL COMMENT 'app_name',
                                   `content` LONGTEXT NOT NULL COMMENT 'content',
                                   `md5` VARCHAR(32) DEFAULT NULL COMMENT 'md5',
                                   `gmt_create` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                                   `gmt_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
                                   `src_user` TEXT COMMENT 'source user',
                                   `src_ip` VARCHAR(50) DEFAULT NULL COMMENT 'source ip',
                                   PRIMARY KEY (`id`),
                                   UNIQUE KEY `uk_configinfotag_datagrouptenanttag` (`data_id`,`group_id`,`tenant_id`,`tag_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_tag';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_tags_relation   */
/******************************************/
CREATE TABLE `config_tags_relation` (
                                        `id` BIGINT(20) NOT NULL COMMENT 'id',
                                        `tag_name` VARCHAR(128) NOT NULL COMMENT 'tag_name',
                                        `tag_type` VARCHAR(64) DEFAULT NULL COMMENT 'tag_type',
                                        `data_id` VARCHAR(255) NOT NULL COMMENT 'data_id',
                                        `group_id` VARCHAR(128) NOT NULL COMMENT 'group_id',
                                        `tenant_id` VARCHAR(128) DEFAULT '' COMMENT 'tenant_id',
                                        `nid` BIGINT(20) NOT NULL AUTO_INCREMENT,
                                        PRIMARY KEY (`nid`),
                                        UNIQUE KEY `uk_configtagrelation_configidtag` (`id`,`tag_name`,`tag_type`),
                                        KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_tag_relation';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = group_capacity   */
/******************************************/
CREATE TABLE `group_capacity` (
                                  `id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID',
                                  `group_id` VARCHAR(128) NOT NULL DEFAULT '' COMMENT 'Group ID，空字符表示整个集群',
                                  `quota` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
                                  `usage` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '使用量',
                                  `max_size` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
                                  `max_aggr_count` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数，，0表示使用默认值',
                                  `max_aggr_size` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
                                  `max_history_count` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
                                  `gmt_create` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                                  `gmt_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
                                  PRIMARY KEY (`id`),
                                  UNIQUE KEY `uk_group_id` (`group_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='集群、各Group容量信息表';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = his_config_info   */
/******************************************/
CREATE TABLE `his_config_info` (
                                   `id` BIGINT(64) UNSIGNED NOT NULL,
                                   `nid` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
                                   `data_id` VARCHAR(255) NOT NULL,
                                   `group_id` VARCHAR(128) NOT NULL,
                                   `app_name` VARCHAR(128) DEFAULT NULL COMMENT 'app_name',
                                   `content` LONGTEXT NOT NULL,
                                   `md5` VARCHAR(32) DEFAULT NULL,
                                   `gmt_create` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                                   `gmt_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                                   `src_user` TEXT,
                                   `src_ip` VARCHAR(50) DEFAULT NULL,
                                   `op_type` CHAR(10) DEFAULT NULL,
                                   `tenant_id` VARCHAR(128) DEFAULT '' COMMENT '租户字段',
                                   `encrypted_data_key` TEXT NOT NULL COMMENT '秘钥',
                                   PRIMARY KEY (`nid`),
                                   KEY `idx_gmt_create` (`gmt_create`),
                                   KEY `idx_gmt_modified` (`gmt_modified`),
                                   KEY `idx_did` (`data_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='多租户改造';


/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = tenant_capacity   */
/******************************************/
CREATE TABLE `tenant_capacity` (
                                   `id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID',
                                   `tenant_id` VARCHAR(128) NOT NULL DEFAULT '' COMMENT 'Tenant ID',
                                   `quota` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
                                   `usage` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '使用量',
                                   `max_size` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
                                   `max_aggr_count` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数',
                                   `max_aggr_size` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
                                   `max_history_count` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
                                   `gmt_create` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                                   `gmt_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
                                   PRIMARY KEY (`id`),
                                   UNIQUE KEY `uk_tenant_id` (`tenant_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='租户容量信息表';


CREATE TABLE `tenant_info` (
                               `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
                               `kp` VARCHAR(128) NOT NULL COMMENT 'kp',
                               `tenant_id` VARCHAR(128) DEFAULT '' COMMENT 'tenant_id',
                               `tenant_name` VARCHAR(128) DEFAULT '' COMMENT 'tenant_name',
                               `tenant_desc` VARCHAR(256) DEFAULT NULL COMMENT 'tenant_desc',
                               `create_source` VARCHAR(32) DEFAULT NULL COMMENT 'create_source',
                               `gmt_create` BIGINT(20) NOT NULL COMMENT '创建时间',
                               `gmt_modified` BIGINT(20) NOT NULL COMMENT '修改时间',
                               PRIMARY KEY (`id`),
                               UNIQUE KEY `uk_tenant_info_kptenantid` (`kp`,`tenant_id`),
                               KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tenant_info';

CREATE TABLE `users` (
                         `username` VARCHAR(50) NOT NULL PRIMARY KEY,
                         `password` VARCHAR(500) NOT NULL,
                         `enabled` BOOLEAN NOT NULL
);

CREATE TABLE `roles` (
                         `username` VARCHAR(50) NOT NULL,
                         `role` VARCHAR(50) NOT NULL,
                         UNIQUE INDEX `idx_user_role` (`username` ASC, `role` ASC) USING BTREE
);

CREATE TABLE `permissions` (
                               `role` VARCHAR(50) NOT NULL,
                               `resource` VARCHAR(255) NOT NULL,
                               `action` VARCHAR(8) NOT NULL,
                               UNIQUE INDEX `uk_role_permission` (`role`,`resource`,`action`) USING BTREE
);

INSERT INTO users (username, PASSWORD, enabled) VALUES ('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', TRUE);

INSERT INTO roles (username, role) VALUES ('nacos', 'ROLE_ADMIN');

docker-compose.yaml内容如下：

version: "3.0"
services:
  nacos:
    image: nacos/nacos-server:2.0.3
    container_name: nacos
    volumes:
      - ./logs/:/home/nacos/logs
    ports:
      - "8848:8848"
      - "9848:9848"
    environment:
      MODE: standalone
      PREFER_HOST_MODE: hostname
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: 数据库IP地址（例：127.0.0.1）
      MYSQL_SERVICE_DB_NAME: 数据库名称
      MYSQL_SERVICE_PORT: 数据库端口号
      MYSQL_SERVICE_USER: 数据库连接用户名
      MYSQL_SERVICE_PASSWORD: 数据库连接密码
    restart: always

web登录页

http://IP:8848/nacos
用户名和密码都是nacos

前言

今天在查看力扣周赛385题解时，发现了几个我平时没注意的map方法，看了jdk相关的源码，感觉很巧妙，可以帮我节省代码，于是乎顺带着整个Map类的方法都过了一遍，下面是我看后整理的内容。

Map类中包括了以下方法：

• clear()

• compute(K,BiFunction<K,V,V>)

• computeIfAbsent(K,Function<K,V>)

• computeIfPresent(K,BiFunction<K,V,V>)

• containsKey(Object)

• containsValue(Object)

• entrySet()

• equals(Object)

• forEach(BiConsumer<K,V>)

• get(Object)

• getOrDefault(Object, V)

• hashCode()

• isEmpty()

• keySet()

• merge(K,V,BiFunction<V,V,V>)

• put(K,V)

• putAll(Map<K,V>)

• putIfAbsent(K,V)

• remove(Object)

• remove(Object,Object)

• replace(K,V,V)

• replace(K,V)

• replaceAll(BiFunction<K,V,V>)

• size()

• values()

方法详解

clear()

源码：

/**
 * Removes all of the mappings from this map (optional operation).
 * The map will be empty after this call returns.
 *
 * @throws UnsupportedOperationException if the <tt>clear</tt> operation
 *         is not supported by this map
 */
void clear();

功能：移除Map中所有的键值对。

compute(K,BiFunction<K,V,V>)

源码：

/**
 * Attempts to compute a mapping for the specified key and its current
 * mapped value (or {@code null} if there is no current mapping). For
 * example, to either create or append a {@code String} msg to a value
 * mapping:
 *
 * <pre> {@code
 * map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))}</pre>
 * (Method {@link #merge merge()} is often simpler to use for such purposes.)
 *
 * <p>If the function returns {@code null}, the mapping is removed (or
 * remains absent if initially absent).  If the function itself throws an
 * (unchecked) exception, the exception is rethrown, and the current mapping
 * is left unchanged.
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
 * {@code null} if absent:
 *
 * <pre> {@code
 * V oldValue = map.get(key);
 * V newValue = remappingFunction.apply(key, oldValue);
 * if (oldValue != null ) {
 *    if (newValue != null)
 *       map.put(key, newValue);
 *    else
 *       map.remove(key);
 * } else {
 *    if (newValue != null)
 *       map.put(key, newValue);
 *    else
 *       return null;
 * }
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the specified value is to be associated
 * @param remappingFunction the function to compute a value
 * @return the new value associated with the specified key, or null if none
 * @throws NullPointerException if the specified key is null and
 *         this map does not support null keys, or the
 *         remappingFunction is null
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</
 * @throws ClassCastException if the class of the specified key or value
 *         prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</
 * @since 1.8
 */
default V compute(K key,
        BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    Objects.requireNonNull(remappingFunction);
    V oldValue = get(key);
    V newValue = remappingFunction.apply(key, oldValue);
    if (newValue == null) {
        // delete mapping
        if (oldValue != null || containsKey(key)) {
            // something to remove
            remove(key);
            return null;
        } else {
            // nothing to do. Leave things as they were.
            return null;
        }
    } else {
        // add or replace old mapping
        put(key, newValue);
        return newValue;
    }
}

功能：

• 根据指定的键和重新映射函数计算新值，并将新值存储到Map中。
• 如果键存在，则根据提供的函数计算新值并更新到Map中，然后返回新值；如果键不存在，则不执行任何操作。

computeIfAbsent(K,Function<K,V>)

源码：

/**
 * If the specified key is not already associated with a value (or is mapped
 * to {@code null}), attempts to compute its value using the given mapping
 * function and enters it into this map unless {@code null}.
 *
 * <p>If the function returns {@code null} no mapping is recorded. If
 * the function itself throws an (unchecked) exception, the
 * exception is rethrown, and no mapping is recorded.  The most
 * common usage is to construct a new object serving as an initial
 * mapped value or memoized result, as in:
 *
 * <pre> {@code
 * map.computeIfAbsent(key, k -> new Value(f(k)));
 * }</pre>
 *
 * <p>Or to implement a multi-value map, {@code Map<K,Collection<V>>},
 * supporting multiple values per key:
 *
 * <pre> {@code
 * map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
 * }</pre>
 *
 *
 * @implSpec
 * The default implementation is equivalent to the following steps for this
 * {@code map}, then returning the current value or {@code null} if now
 * absent:
 *
 * <pre> {@code
 * if (map.get(key) == null) {
 *     V newValue = mappingFunction.apply(key);
 *     if (newValue != null)
 *         map.put(key, newValue);
 * }
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the specified value is to be associated
 * @param mappingFunction the function to compute a value
 * @return the current (existing or computed) value associated with
 *         the specified key, or null if the computed value is null
 * @throws NullPointerException if the specified key is null and
 *         this map does not support null keys, or the mappingFunction
 *         is null
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 *         prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
default V computeIfAbsent(K key,
        Function<? super K, ? extends V> mappingFunction) {
    Objects.requireNonNull(mappingFunction);
    V v;
    if ((v = get(key)) == null) {
        V newValue;
        if ((newValue = mappingFunction.apply(key)) != null) {
            put(key, newValue);
            return newValue;
        }
    }
    return v;
}

功能：

• 如果指定键不存在，则根据指定的映射函数计算并将结果存储到Map中；如果键已经存在，则不执行任何操作。
• 这个方法允许根据键的不存在来动态计算值，并将计算结果存储到Map中。

computeIfPresent(K,BiFunction<K,V,V>)

源码：

/**
 * If the value for the specified key is present and non-null, attempts to
 * compute a new mapping given the key and its current mapped value.
 *
 * <p>If the function returns {@code null}, the mapping is removed.  If the
 * function itself throws an (unchecked) exception, the exception is
 * rethrown, and the current mapping is left unchanged.
*
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
 * {@code null} if now absent:
 *
 * <pre> {@code
 * if (map.get(key) != null) {
 *     V oldValue = map.get(key);
 *     V newValue = remappingFunction.apply(key, oldValue);
 *     if (newValue != null)
 *         map.put(key, newValue);
 *     else
 *         map.remove(key);
 * }
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the specified value is to be associated
 * @param remappingFunction the function to compute a value
 * @return the new value associated with the specified key, or null if none
 * @throws NullPointerException if the specified key is null and
 *         this map does not support null keys, or the
 *         remappingFunction is null
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 *         prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
default V computeIfPresent(K key,
        BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    Objects.requireNonNull(remappingFunction);
    V oldValue;
    if ((oldValue = get(key)) != null) {
        V newValue = remappingFunction.apply(key, oldValue);
        if (newValue != null) {
            put(key, newValue);
            return newValue;
        } else {
            remove(key);
            return null;
        }
    } else {
        return null;
    }
}

功能：

• 如果指定键存在，则根据提供的重新映射函数计算新值，并将新值存储到Map中；如果键不存在，则不执行任何操作。
• 这个方法允许在键存在时根据原始值计算新值，并更新到Map中。

containsKey(Object)

源码：

/**
 * Returns <tt>true</tt> if this map contains a mapping for the specified
 * key.  More formally, returns <tt>true</tt> if and only if
 * this map contains a mapping for a key <tt>k</tt> such that
 * <tt>(key==null ? k==null : key.equals(k))</tt>.  (There can be
 * at most one such mapping.)
 *
 * @param key key whose presence in this map is to be tested
 * @return <tt>true</tt> if this map contains a mapping for the specified
 *         key
 * @throws ClassCastException if the key is of an inappropriate type for
 *         this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key is null and this map
 *         does not permit null keys
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 */
boolean containsKey(Object key);

功能：判断Map中是否包含指定的键。

containsValue(Object)

源码：

/**
 * Returns <tt>true</tt> if this map maps one or more keys to the
 * specified value.  More formally, returns <tt>true</tt> if and only if
 * this map contains at least one mapping to a value <tt>v</tt> such that
 * <tt>(value==null ? v==null : value.equals(v))</tt>.  This operation
 * will probably require time linear in the map size for most
 * implementations of the <tt>Map</tt> interface.
 *
 * @param value value whose presence in this map is to be tested
 * @return <tt>true</tt> if this map maps one or more keys to the
 *         specified value
 * @throws ClassCastException if the value is of an inappropriate type for
 *         this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified value is null and this
 *         map does not permit null values
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 */
boolean containsValue(Object value);

功能：判断Map中是否包含指定的值。

entrySet()

源码：

/**
 * Returns a {@link Set} view of the mappings contained in this map.
 * The set is backed by the map, so changes to the map are
 * reflected in the set, and vice-versa.  If the map is modified
 * while an iteration over the set is in progress (except through
 * the iterator's own <tt>remove</tt> operation, or through the
 * <tt>setValue</tt> operation on a map entry returned by the
 * iterator) the results of the iteration are undefined.  The set
 * supports element removal, which removes the corresponding
 * mapping from the map, via the <tt>Iterator.remove</tt>,
 * <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt> and
 * <tt>clear</tt> operations.  It does not support the
 * <tt>add</tt> or <tt>addAll</tt> operations.
 *
 * @return a set view of the mappings contained in this map
 */
Set<Map.Entry<K, V>> entrySet();

功能：返回一个包含Map中所有键值对的Set集合。

equals(Object)

源码：

/**
 * Compares the specified object with this map for equality.  Returns
 * <tt>true</tt> if the given object is also a map and the two maps
 * represent the same mappings.  More formally, two maps <tt>m1</tt> and
 * <tt>m2</tt> represent the same mappings if
 * <tt>m1.entrySet().equals(m2.entrySet())</tt>.  This ensures that the
 * <tt>equals</tt> method works properly across different implementations
 * of the <tt>Map</tt> interface.
 *
 * @param o object to be compared for equality with this map
 * @return <tt>true</tt> if the specified object is equal to this map
 */
boolean equals(Object o);

功能：比较两个 Map 对象是否相等。两个 Map 相等的条件是：

1. 两个 Map 对象具有相同的键值对数量。

2. 对于每个键，两个 Map 对象的键值必须相等。

forEach(BiConsumer<K,V>)

源码：

/**
 * Performs the given action for each entry in this map until all entries
 * have been processed or the action throws an exception.   Unless
 * otherwise specified by the implementing class, actions are performed in
 * the order of entry set iteration (if an iteration order is specified.)
 * Exceptions thrown by the action are relayed to the caller.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 * <pre> {@code
 * for (Map.Entry<K, V> entry : map.entrySet())
 *     action.accept(entry.getKey(), entry.getValue());
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param action The action to be performed for each entry
 * @throws NullPointerException if the specified action is null
 * @throws ConcurrentModificationException if an entry is found to be
 * removed during iteration
 * @since 1.8
 */
default void forEach(BiConsumer<? super K, ? super V> action) {
    Objects.requireNonNull(action);
    for (Map.Entry<K, V> entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            // this usually means the entry is no longer in the map.
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

功能：对Map中的每个键值对执行指定的操作。

get(Object)

源码：

/**
 * Returns the value to which the specified key is mapped,
 * or {@code null} if this map contains no mapping for the key.
 *
 * <p>More formally, if this map contains a mapping from a key
 * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
 * key.equals(k))}, then this method returns {@code v}; otherwise
 * it returns {@code null}.  (There can be at most one such mapping.)
 *
 * <p>If this map permits null values, then a return value of
 * {@code null} does not <i>necessarily</i> indicate that the map
 * contains no mapping for the key; it's also possible that the map
 * explicitly maps the key to {@code null}.  The {@link #containsKey
 * containsKey} operation may be used to distinguish these two cases.
 *
 * @param key the key whose associated value is to be returned
 * @return the value to which the specified key is mapped, or
 *         {@code null} if this map contains no mapping for the key
 * @throws ClassCastException if the key is of an inappropriate type for
 *         this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key is null and this map
 *         does not permit null keys
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 */
V get(Object key);

功能：获取指定键对应的值，如果键不存在，则返回null。

getOrDefault(Object, V)

源码：

/**
 * Returns the value to which the specified key is mapped, or
 * {@code defaultValue} if this map contains no mapping for the key.
 *
 * @implSpec
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key the key whose associated value is to be returned
 * @param defaultValue the default mapping of the key
 * @return the value to which the specified key is mapped, or
 * {@code defaultValue} if this map contains no mapping for the key
 * @throws ClassCastException if the key is of an inappropriate type for
 * this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key is null and this map
 * does not permit null keys
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
default V getOrDefault(Object key, V defaultValue) {
    V v;
    return (((v = get(key)) != null) || containsKey(key))
        ? v
        : defaultValue;
}

功能：获取指定键对应的值，如果键不存在，则返回指定的默认值。

hashCode()

源码：

/**
 * Returns the hash code value for this map.  The hash code of a map is
 * defined to be the sum of the hash codes of each entry in the map's
 * <tt>entrySet()</tt> view.  This ensures that <tt>m1.equals(m2)</tt>
 * implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two maps
 * <tt>m1</tt> and <tt>m2</tt>, as required by the general contract of
 * {@link Object#hashCode}.
 *
 * @return the hash code value for this map
 * @see Map.Entry#hashCode()
 * @see Object#equals(Object)
 * @see #equals(Object)
 */
int hashCode();

功能：返回 Map 对象的哈希码。

isEmpty()

源码：

/**
 * Returns <tt>true</tt> if this map contains no key-value mappings.
 *
 * @return <tt>true</tt> if this map contains no key-value mappings
 */
boolean isEmpty();

功能：判断Map是否为空

keySet()

源码：

/**
 * Returns a {@link Set} view of the keys contained in this map.
 * The set is backed by the map, so changes to the map are
 * reflected in the set, and vice-versa.  If the map is modified
 * while an iteration over the set is in progress (except through
 * the iterator's own <tt>remove</tt> operation), the results of
 * the iteration are undefined.  The set supports element removal,
 * which removes the corresponding mapping from the map, via the
 * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
 * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
 * operations.  It does not support the <tt>add</tt> or <tt>addAll</tt>
 * operations.
 *
 * @return a set view of the keys contained in this map
 */
Set<K> keySet();

功能：返回 Map 中所有键的 Set 集合

merge(K,V,BiFunction<V,V,V>)

源码：

/**
 * If the specified key is not already associated with a value or is
 * associated with null, associates it with the given non-null value.
 * Otherwise, replaces the associated value with the results of the given
 * remapping function, or removes if the result is {@code null}. This
 * method may be of use when combining multiple mapped values for a key.
 * For example, to either create or append a {@code String msg} to a
 * value mapping:
 *
 * <pre> {@code
 * map.merge(key, msg, String::concat)
 * }</pre>
 *
 * <p>If the function returns {@code null} the mapping is removed.  If the
 * function itself throws an (unchecked) exception, the exception is
 * rethrown, and the current mapping is left unchanged.
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
 * {@code null} if absent:
 *
 * <pre> {@code
 * V oldValue = map.get(key);
 * V newValue = (oldValue == null) ? value :
 *              remappingFunction.apply(oldValue, value);
 * if (newValue == null)
 *     map.remove(key);
 * else
 *     map.put(key, newValue);
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the resulting value is to be associated
 * @param value the non-null value to be merged with the existing value
 *        associated with the key or, if no existing value or a null value
 *        is associated with the key, to be associated with the key
 * @param remappingFunction the function to recompute a value if present
 * @return the new value associated with the specified key, or null if no
 *         value is associated with the key
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 *         prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key is null and this map
 *         does not support null keys or the value or remappingFunction is
 *         null
 * @since 1.8
 */
default V merge(K key, V value,
        BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
    Objects.requireNonNull(remappingFunction);
    Objects.requireNonNull(value);
    V oldValue = get(key);
    V newValue = (oldValue == null) ? value :
               remappingFunction.apply(oldValue, value);
    if(newValue == null) {
        remove(key);
    } else {
        put(key, newValue);
    }
    return newValue;
}

功能：将指定的键和值合并到Map中，根据提供的函数计算新值。

put(K,V)

源码：

/**
 * Associates the specified value with the specified key in this map
 * (optional operation).  If the map previously contained a mapping for
 * the key, the old value is replaced by the specified value.  (A map
 * <tt>m</tt> is said to contain a mapping for a key <tt>k</tt> if and only
 * if {@link #containsKey(Object) m.containsKey(k)} would return
 * <tt>true</tt>.)
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 *         (A <tt>null</tt> return can also indicate that the map
 *         previously associated <tt>null</tt> with <tt>key</tt>,
 *         if the implementation supports <tt>null</tt> values.)
 * @throws UnsupportedOperationException if the <tt>put</tt> operation
 *         is not supported by this map
 * @throws ClassCastException if the class of the specified key or value
 *         prevents it from being stored in this map
 * @throws NullPointerException if the specified key or value is null
 *         and this map does not permit null keys or values
 * @throws IllegalArgumentException if some property of the specified key
 *         or value prevents it from being stored in this map
 */
V put(K key, V value);

功能：将指定的键值对添加到Map中。

putAll(Map<K,V>)

源码：

/**
 * Copies all of the mappings from the specified map to this map
 * (optional operation).  The effect of this call is equivalent to that
 * of calling {@link #put(Object,Object) put(k, v)} on this map once
 * for each mapping from key <tt>k</tt> to value <tt>v</tt> in the
 * specified map.  The behavior of this operation is undefined if the
 * specified map is modified while the operation is in progress.
 *
 * @param m mappings to be stored in this map
 * @throws UnsupportedOperationException if the <tt>putAll</tt> operation
 *         is not supported by this map
 * @throws ClassCastException if the class of a key or value in the
 *         specified map prevents it from being stored in this map
 * @throws NullPointerException if the specified map is null, or if
 *         this map does not permit null keys or values, and the
 *         specified map contains null keys or values
 * @throws IllegalArgumentException if some property of a key or value in
 *         the specified map prevents it from being stored in this map
 */
void putAll(Map<? extends K, ? extends V> m);

功能：将指定Map中的所有键值对添加到当前Map中。

putIfAbsent(K,V)

源码：

/**
 * If the specified key is not already associated with a value (or is mapped
 * to {@code null}) associates it with the given value and returns
 * {@code null}, else returns the current value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code
 * map}:
 *
 * <pre> {@code
 * V v = map.get(key);
 * if (v == null)
 *     v = map.put(key, value);
 *
 * return v;
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with the specified key, or
 *         {@code null} if there was no mapping for the key.
 *         (A {@code null} return can also indicate that the map
 *         previously associated {@code null} with the key,
 *         if the implementation supports null values.)
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the key or value is of an inappropriate
 *         type for this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key or value is null,
 *         and this map does not permit null keys or values
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws IllegalArgumentException if some property of the specified key
 *         or value prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
default V putIfAbsent(K key, V value) {
    V v = get(key);
    if (v == null) {
        v = put(key, value);
    }
    return v;
}

功能：将指定的键值对添加到Map中，但仅当指定的键在Map中不存在时。

remove(Object)

源码：

/**
 * Removes the mapping for a key from this map if it is present
 * (optional operation).   More formally, if this map contains a mapping
 * from key <tt>k</tt> to value <tt>v</tt> such that
 * <code>(key==null ?  k==null : key.equals(k))</code>, that mapping
 * is removed.  (The map can contain at most one such mapping.)
 *
 * <p>Returns the value to which this map previously associated the key,
 * or <tt>null</tt> if the map contained no mapping for the key.
 *
 * <p>If this map permits null values, then a return value of
 * <tt>null</tt> does not <i>necessarily</i> indicate that the map
 * contained no mapping for the key; it's also possible that the map
 * explicitly mapped the key to <tt>null</tt>.
 *
 * <p>The map will not contain a mapping for the specified key once the
 * call returns.
 *
 * @param key key whose mapping is to be removed from the map
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 * @throws UnsupportedOperationException if the <tt>remove</tt> operation
 *         is not supported by this map
 * @throws ClassCastException if the key is of an inappropriate type for
 *         this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key is null and this
 *         map does not permit null keys
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 */
V remove(Object key);

功能：移除Map中指定键对应的值。

remove(Object,Object)

源码：

/**
 * Removes the entry for the specified key only if it is currently
 * mapped to the specified value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 *
 * <pre> {@code
 * if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
 *     map.remove(key);
 *     return true;
 * } else
 *     return false;
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is associated
 * @param value value expected to be associated with the specified key
 * @return {@code true} if the value was removed
 * @throws UnsupportedOperationException if the {@code remove} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the key or value is of an inappropriate
 *         type for this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key or value is null,
 *         and this map does not permit null keys or values
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
default boolean remove(Object key, Object value) {
    Object curValue = get(key);
    if (!Objects.equals(curValue, value) ||
        (curValue == null && !containsKey(key))) {
        return false;
    }
    remove(key);
    return true;
}

功能：移除Map中指定键对应的值，仅当该键关联的值与指定值相等时才移除。

replace(K,V,V)

源码：

/**
 * Replaces the entry for the specified key only if currently
 * mapped to the specified value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 *
 * <pre> {@code
 * if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
 *     map.put(key, newValue);
 *     return true;
 * } else
 *     return false;
 * }</pre>
 *
 * The default implementation does not throw NullPointerException
 * for maps that do not support null values if oldValue is null unless
 * newValue is also null.
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is associated
 * @param oldValue value expected to be associated with the specified key
 * @param newValue value to be associated with the specified key
 * @return {@code true} if the value was replaced
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of a specified key or value
 *         prevents it from being stored in this map
 * @throws NullPointerException if a specified key or newValue is null,
 *         and this map does not permit null keys or values
 * @throws NullPointerException if oldValue is null and this map does not
 *         permit null values
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws IllegalArgumentException if some property of a specified key
 *         or value prevents it from being stored in this map
 * @since 1.8
 */
default boolean replace(K key, V oldValue, V newValue) {
    Object curValue = get(key);
    if (!Objects.equals(curValue, oldValue) ||
        (curValue == null && !containsKey(key))) {
        return false;
    }
    put(key, newValue);
    return true;
}

功能：将Map中指定键对应的旧值替换为新值，仅当键对应的值与旧值相等时才替换。

replace(K,V)

源码：

/**
 * Replaces the entry for the specified key only if it is
 * currently mapped to some value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 *
 * <pre> {@code
 * if (map.containsKey(key)) {
 *     return map.put(key, value);
 * } else
 *     return null;
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
  *
 * @param key key with which the specified value is associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with the specified key, or
 *         {@code null} if there was no mapping for the key.
 *         (A {@code null} return can also indicate that the map
 *         previously associated {@code null} with the key,
 *         if the implementation supports null values.)
 * @throws UnsupportedOperationException if the {@code put} operation
 *         is not supported by this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 *         prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key or value is null,
 *         and this map does not permit null keys or values
 * @throws IllegalArgumentException if some property of the specified key
 *         or value prevents it from being stored in this map
 * @since 1.8
 */
default V replace(K key, V value) {
    V curValue;
    if (((curValue = get(key)) != null) || containsKey(key)) {
        curValue = put(key, value);
    }
    return curValue;
}

功能：将Map中指定键对应的值替换为新值，返回旧值。

replaceAll(BiFunction<K,V,V>)

源码：

/**
 * Replaces each entry's value with the result of invoking the given
 * function on that entry until all entries have been processed or the
 * function throws an exception.  Exceptions thrown by the function are
 * relayed to the caller.
 *
 * @implSpec
 * <p>The default implementation is equivalent to, for this {@code map}:
 * <pre> {@code
 * for (Map.Entry<K, V> entry : map.entrySet())
 *     entry.setValue(function.apply(entry.getKey(), entry.getValue()));
 * }</pre>
 *
 * <p>The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param function the function to apply to each entry
 * @throws UnsupportedOperationException if the {@code set} operation
 * is not supported by this map's entry set iterator.
 * @throws ClassCastException if the class of a replacement value
 * prevents it from being stored in this map
 * @throws NullPointerException if the specified function is null, or the
 * specified replacement value is null, and this map does not permit null
 * values
 * @throws ClassCastException if a replacement value is of an inappropriate
 *         type for this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if function or a replacement value is null,
 *         and this map does not permit null keys or values
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws IllegalArgumentException if some property of a replacement value
 *         prevents it from being stored in this map
 *         (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ConcurrentModificationException if an entry is found to be
 * removed during iteration
 * @since 1.8
 */
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
    Objects.requireNonNull(function);
    for (Map.Entry<K, V> entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            // this usually means the entry is no longer in the map.
            throw new ConcurrentModificationException(ise);
        }
        // ise thrown from function is not a cme.
        v = function.apply(k, v);
        try {
            entry.setValue(v);
        } catch(IllegalStateException ise) {
            // this usually means the entry is no longer in the map.
            throw new ConcurrentModificationException(ise);
        }
    }
}

功能：对Map中的每个键值对执行指定的替换操作。

size()

源码：

/**
 * Returns the number of key-value mappings in this map.  If the
 * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
 * <tt>Integer.MAX_VALUE</tt>.
 *
 * @return the number of key-value mappings in this map
 */
int size();

功能：返回Map中键值对的数量。

values()

源码：

/**
 * Returns a {@link Collection} view of the values contained in this map.
 * The collection is backed by the map, so changes to the map are
 * reflected in the collection, and vice-versa.  If the map is
 * modified while an iteration over the collection is in progress
 * (except through the iterator's own <tt>remove</tt> operation),
 * the results of the iteration are undefined.  The collection
 * supports element removal, which removes the corresponding
 * mapping from the map, via the <tt>Iterator.remove</tt>,
 * <tt>Collection.remove</tt>, <tt>removeAll</tt>,
 * <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not
 * support the <tt>add</tt> or <tt>addAll</tt> operations.
 *
 * @return a collection view of the values contained in this map
 */
Collection<V> values();

功能：返回包含Map中所有值的Collection集合。

总览

通过几天晚上的整理，规划出了今天的路线，大概上要去下面这些地方：辽宁美术馆，城市规划馆，万豪酒店，k11，广电博物馆，文化路万达，盛京龙城，盛京大家庭，大悦城乐高，全运路万达，在跑章的过程中，临时加入了大悦城霸王别姬

计划

通过整理这些地方的地点和营业时间，初步按照下面的顺序依次跑章

辽宁美术馆

• 营业时间：9:00~17:00，16：00后不让进

• 路线：2号线 “市图书馆”，B口

• 盖章数：5枚

城市规划馆

• 时间：9:00~17:00，16：00后不让进

• 路线：2号线”沈阳市图书馆站“，C口（辽宁美术馆步行过来700米）

• 盖章数：7枚

• 注意事项：需要带身份证

沈阳皇朝万豪酒店

• 时间：2024.1.19～1.28，10：00～18：00

• 路线：2号线，五里河站，B1口（辽宁美术馆步行900米，城市规划馆步行900米）

• 盖章数：17枚

• 注意事项：分布在1楼和3楼的各个摊位，需要挨个问

k11

• 路线：2号线，五里河，B1口（万豪酒店步行800米）

• 盖章数：共6枚，中信书店（2枚，3楼），歌德书店（2枚，2楼），西西弗书店（2枚，1楼）

广电博物馆

• 时间：2024.1.27 10:00~15:30

• 路线：2号线，工业展览馆，C口（沈阳美术馆步行936米）

文化路万达

• 时间：10:00~22:00

• 路线： 2号线，工业展览馆，C口

盛京龙城

• 盖章数：14枚

• 注意事项：1楼盛京阿哥

盛京大家庭

• 时间：2024.1.26 ~ 2024.1.30

• 注意事项：负一层大脸鸭记

大悦城乐高

• 盖章数：3枚

• 注意事项： 中街乐高，大悦城C馆一进门那个，泡泡玛特对面

新的mini主机到了，为了之后的开发方便，需要先安装各种软件，这里记录下需要安装的软件，我这边是以Java为主

Java

我这边Java下载安装的是17版本的，下载地址：Java Downloads | Oracle，下面是下载页面，根据自己电脑的情况安装不同的版本

maven

我使用的是3.6.3，下载地址：maven

nvm

安装包在GitHub中下载的，安装说明也挺详细，地址：nvm-windows

git

官网下载地址：git

nodejs

通过nvm安装LTS版本

力扣每日一题
题目：1686. 石子游戏 VI

日期：2024-02-02
用时：15 m 0 s
时间：103ms
内存：57.95MB
代码：

class Solution {
    public int stoneGameVI(int[] aliceValues, int[] bobValues) {
        int cnt = aliceValues.length;
        int[][] arrs = new int[cnt][2];
        for (int i = 0; i < cnt; i++) {
            arrs[i] = new int[]{aliceValues[i],bobValues[i]};
        }
        Arrays.sort(arrs,(a,b)->(b[0]+ b[1])-(a[0]+ a[1]));
        int sub = 0;
        for (int i = 0; i < cnt; i++) {
            sub+=i%2==0?arrs[i][0]:-arrs[i][1];
        }
        return sub == 0? 0 :sub / Math.abs(sub);
    }
}

在vue中实现excel上传并显示数据

效果如下：

具体代码如下：

<template>

  <div class="app-container">

      <input

        ref="excel-upload-input"

        class="excel-upload-input"

        style="width: 300px;margin-left: 10px"

        type="file"

        accept=".xlsx, .xls"

        @change="handleClick"

      />

      <div class="drop" @drop="handleDrop" @dragover="handleDragover" @dragenter="handleDragover">

        批量导入：拖拽excel文件或者

        <el-button :loading="loading" style="margin-left:16px;" size="mini" type="primary" @click="handleUpload">

          浏览

        </el-button>

      </div>

    <el-table :data="excelData.results" border highlight-current-row style="width: 100%;margin-top:20px;">

      <el-table-column v-for="item of excelData.header" :key="item" :prop="item" :label="item"/>

    </el-table>

  </div>

</template>

<script>

import XLSX from 'xlsx'

export default {

  name: 'UploadExcel',

  data() {

    return {

      loading: false,

      excelData: {

        header: null,

        results: null

      }

    }

  },

  methods: {

    handleUpload() {

      this.$refs['excel-upload-input'].click()

    },

    handleClick(e) {

      const files = e.target.files

      const file = files[0]

      const before = this.beforeUpload(file)

      if (before) {

        this.upload(file)

      }

    },

    // 上传文件的条件验证

    beforeUpload(file) {

      if (!file) {

        return false

      }

      const isLt1M = file.size / 1024 / 1024 < 1

      if (isLt1M) {

        return true

      }

      this.$message({

        message: '请上传1M以内的文件',

        type: 'warning'

      })

      return false

    },

    // excel文件数据获取

    upload(file) {

      this.$refs['excel-upload-input'].value = null

      return new Promise((resolve, reject) => {

        const reader = new FileReader()

        reader.onload = e => {

          const data = e.target.result

          const workbook = XLSX.read(data, { type: 'array' })

          // 获取第一个sheet页名字

          const firstSheetName = workbook.SheetNames[0]

          // 获取指定名字的sheet页内容

          const worksheet = workbook.Sheets[firstSheetName]

          // 获取标头

          const header = this.getHeaderRow(worksheet)

          // 获取除标头外的数据

          const results = XLSX.utils.sheet_to_json(worksheet)

          // 标头和数据处理

          this.generateData({ header, results })

          resolve()

        }

        reader.readAsArrayBuffer(file)

      })

    },

    // 获取标头

    getHeaderRow(sheet) {

      const headers = []

      const range = XLSX.utils.decode_range(sheet['!ref'])

      let C

      const R = range.s.r

      /* start in the first row */

      for (C = range.s.c; C <= range.e.c; ++C) { /* walk every column in the range */

        const cell = sheet[XLSX.utils.encode_cell({ c: C, r: R })]

        /* find the cell in the first row */

        let hdr = 'UNKNOWN ' + C // <-- replace with your desired default

        if (cell && cell.t) hdr = XLSX.utils.format_cell(cell)

        headers.push(hdr)

      }

      return headers

    },

    handleDrop(e) {

      e.stopPropagation()

      e.preventDefault()

      if (this.loading) return

      const files = e.dataTransfer.files

      if (files.length !== 1) {

        this.$message.error('仅支持上传一个文件!')

        return

      }

      const rawFile = files[0] // only use files[0]

      if (!this.isExcel(rawFile)) {

        this.$message.error('仅支持上传.xlsx, .xls, .csv格式的文件')

        return false

      }

      this.upload(rawFile)

      e.stopPropagation()

      e.preventDefault()

    },

    handleDragover(e) {

      e.stopPropagation()

      e.preventDefault()

      e.dataTransfer.dropEffect = 'copy'

    },

    // 标头和数据处理（可以在此方法中调用后端接口保存数据）

    generateData({ header, results }) {

      this.excelData.header = header

      this.excelData.results = results

    }

  }

}

</script>

<style scoped>

.excel-upload-input {

  display: none;

  z-index: -9999;

}

.drop {

  border: 2px dashed #bbb;

  width: 600px;

  height: 160px;

  line-height: 160px;

  margin: 0 auto;

  font-size: 24px;

  border-radius: 5px;

  text-align: center;

  color: #bbb;

  position: relative;

}

</style>

力扣每日一题
题目：162. 寻找峰值

日期：2023-12-18
用时：10 m 9 s
时间：0 ms
内存：40.54 MB
代码：

class Solution {
    public int findPeakElement(int[] nums) {
        if(nums.length==1){
            return 0;
        }
        if(nums.length==2){
            return nums[0]>nums[1]?0:1;
        }
        if(nums[0]>nums[1]){
            return 0;
        }
        if(nums[nums.length-1]>nums[nums.length-2]){
            return nums.length-1;
        }
        for(int i=1;i<nums.length-1;i++){
            if(nums[i]>nums[i-1]&&nums[i]>nums[i+1]){
                return i;
            }
        }
        return 0;
    }
}

力扣每日一题
题目：2415. 反转二叉树的奇数层

日期：2023-12-15
用时：6 m 51 s
时间：0 ms
内存：46.97 MB
代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode reverseOddLevels(TreeNode root) {
        dfs(root.left, root.right, 1);
        return root;
    }

    void dfs(TreeNode left,TreeNode right,int odd){
        if(left==null){
            return;
        }
        if(odd==1){
            int temp = left.val;
            left.val = right.val;
            right.val = temp;
        }
        dfs(left.left, right.right, 1-odd);
        dfs(left.right, right.left, 1-odd);
    }
}

力扣每日一题
题目：2132. 用邮票贴满网格图

日期：2023-12-14
用时：38 m 32 s
思路：使用前缀和＋差分，只是往常是一维，现在变二维了，原理差不多
时间：22ms
内存：98.24MB
代码：

class Solution {
    public boolean possibleToStamp(int[][] grid, int stampHeight, int stampWidth) {
        int xl = grid.length;
        int yl = grid[0].length;

        // 前缀和
        int[][] sum = new int[xl+1][yl+1];
        for(int i=1;i<=xl;i++){
            for(int j=1;j<=yl;j++){
                sum[i][j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+grid[i-1][j-1];
            }
        }

        // 差分
        int[][] cnt = new int[xl+2][yl+2];
        for(int xStart=stampHeight;xStart<=xl;xStart++){
            for(int yStart=stampWidth;yStart<=yl;yStart++){
                int xEnd = xStart-stampHeight+1;
                int yEnd = yStart-stampWidth+1;
                if(sum[xStart][yStart]+sum[xEnd-1][yEnd-1]-sum[xStart][yEnd-1]-sum[xEnd-1][yStart]==0){
                    cnt[xEnd][yEnd]++;
                    cnt[xStart+1][yStart+1]++;
                    cnt[xEnd][yStart+1]--;
                    cnt[xStart+1][yEnd]--;
                }
            }
        }

        // 判断单元格是否能放邮戳
        for(int i=1;i<=xl;i++){
            for(int j=1;j<=yl;j++){
                cnt[i][j] += cnt[i][j-1]+cnt[i-1][j]-cnt[i-1][j-1];
                if(grid[i-1][j-1]==0&&cnt[i][j]==0){
                    return false;
                }
            }
        }

        return true;
    }
}

力扣每日一题
题目：2697. 字典序最小回文串

日期：2023-12-13
用时：4 m 53 s
时间：7ms
内存：43.61MB
代码：

class Solution {
    public String makeSmallestPalindrome(String s) {
        char[] chs = s.toCharArray();
        int size = s.length();
        for(int i=0;i<size/2;i++){
            if(chs[i]>chs[size-1-i]){
                chs[i] = chs[size-1-i];
            }else{
                chs[size-1-i] = chs[i];
            }
        }
        return new String(chs);
    }
}

力扣每日一题
题目：2454. 下一个更大元素 IV

日期：2023-12-12
用时：35 m 09 s
时间：614ms
内存：57.18MB
代码：

class Solution {
    public int[] secondGreaterElement(int[] nums) {
        int[] res = new int[nums.length];
        Arrays.fill(res, -1);
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            while (!list2.isEmpty() && nums[list2.get(list2.size() - 1)] < nums[i]) {
                res[list2.get(list2.size() - 1)] = nums[i];
                list2.remove(list2.size() - 1);
            }
            int j = list1.size();
            for(;j>0;j--){
                if(nums[list1.get(j - 1)] >= nums[i]){
                    break;
                }
            }
            while (j<list1.size()) {
                list2.add(list1.get(j));
                list1.remove(j);
            }
            list1.add(i);
        }
        return res;
    }
}

全运路万达8枚
铁西万达4枚
北一路万达16枚
太原街万达8枚

(摘自小红书https://www.xiaohongshu.com/explore/65758b310000000006020803?m_source=mengfanwetab)

力扣每日一题
题目：1466. 重新规划路线

日期：2023-12-07
用时：45 m 36 s
时间：37ms
内存：69.64MB
代码：

class Solution {
    public int minReorder(int n, int[][] connections) {
        list = new List[n];
        Arrays.setAll(list, k -> new ArrayList<>());
        for (int[] connection : connections) {
            int start = connection[0];
            int end = connection[1];
            list[start].add(new int[] {end, 1});
            list[end].add(new int[] {start, 0});
        }
        return dfs(0, -1);
    }
    
    List<int[]>[] list;

    private int dfs(int index, int target) {
        int ans = 0;
        for (int[] num : list[index]) {
            if (num[0] != target) {
                ans += num[1] + dfs(num[0], index);
            }
        }
        return ans;
    }
}

力扣每日一题
题目：2646. 最小化旅行的价格总和

日期：2023-12-06
用时：30 m 14 s
时间：8ms
内存：42.98MB
思路：每条路上通过的城市数量实际就是图中每个节点的子节点数量，先统计旅行中每个节点路过的次数（dfs方法），再计算减半后的价格之和的最小值（dp方法），最后比较下减半和未减半的价格。dp方法中，对于相邻的父子节点有两种情况：

• 如果父节点价格不变，那么子节点的价格取减半和不变两种情况的最小值
• 如果父节点价格减半，那么子节点的价格只能不变

代码：

class Solution {
    public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {
      list = new ArrayList[n];
      for(int i=0;i<n;i++){
        list[i] = new ArrayList<>();
      }
      for(int[] edge:edges){
        list[edge[0]].add(edge[1]);
        list[edge[1]].add(edge[0]);
      }
      cnt = new int[n];
      for(int[] trip:trips){
        end = trip[1];
        dfs(trip[0],-1);
      }
      int[] res = dp(0,-1,price);
      return Math.min(res[0],res[1]);
    }
    List<Integer>[] list;
    int end;
    int[] cnt;
    boolean dfs(int x, int fa) {
        if (x == end) {
            cnt[x]++;
            return true;
        }
        for (int y : list[x]) {
            if (y != fa && dfs(y, x)) {
                cnt[x]++;
                return true;
            }
        }
        return false;
    }
    int[] dp(int index,int target,int[] price){
      int prices = price[index]*cnt[index];
      int halfPrices = prices/2;
      for(int num:list[index]){
        if(num!=target){
          int[] res = dp(num,index,price);
          prices += Math.min(res[0],res[1]);
          halfPrices += res[0];
        }
      }
      return new int[]{prices,halfPrices};
    }
}

力扣每日一题
题目：2477. 到达首都的最少油耗

日期：2023-12-05
用时：34 m 15 s
时间：37ms
内存：84.8MB
思路：分别计算每条路上通过的城市数量（数量/座位数，向上取整），然后求和，这里每条路上通过的城市数量实际就是图中每个节点的子节点数量。
代码：每条路上通过的城市数量实际就是图中每个节点的子节点数量。

class Solution {
    public long minimumFuelCost(int[][] roads, int seats) {
        int size = roads.length+1;
        List<Integer>[] list = new ArrayList[size];
        for(int i=0;i<size;i++){
            list[i] = new ArrayList<>();
        }
        for(int[] road:roads){
            int num1 = road[0];
            int num2 = road[1];
            list[num1].add(num2);
            list[num2].add(num1);
        };
        dfs(0,-1,list,seats);
        return sum;
    }
    long sum = 0;
    private int dfs(int start,int end,List<Integer>[] list,int seats){
        int cnt =1;
        for(int num: list[start]){
            if(num!=end){
                cnt+=dfs(num,start,list,seats);
            }
        }
        if(start>0){
            sum+=(cnt-1)/seats+1;
        }
        return cnt;
    }
}

力扣每日一题
题目：[1038. 从二叉搜索树到更大和树](https://leetcode.cn/problems/binary-search-tree-to-greater-sum-tree/description/)

![2023-12-04.png](https://img.huangge1199.cn/halo/2023-12-04.png)
日期：2023-12-04
用时：12 m 23 s
时间：0ms
内存：39.39MB
代码：
```java
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode bstToGst(TreeNode root) {
        dfs(root);
        return root;
    }
    int sum = 0;
    private void dfs(TreeNode node) {
        if (node == null) {
            return;
        }
        dfs(node.right);
        sum += node.val;
        node.val = sum;
        dfs(node.left);
    }
}
```

力扣每日一题
题目：2661. 找出叠涂元素

日期：2023-12-01
用时：7 m 4 s
时间：26ms
内存：67.45MB
代码：

class Solution {
    public int firstCompleteIndex(int[] arr, int[][] mat) {
        Map<Integer,int[]> map = new HashMap<>();
        for(int i=0;i<mat.length;i++){
            for(int j=0;j<mat[0].length;j++){
                map.put(mat[i][j],new int[]{i,j});
            }
        }
        int[] xc = new int[mat.length];
        int[] yc = new int[mat[0].length];
        for(int i=0;i<arr.length;i++){
            int[] tmp = map.get(arr[i]);
            xc[tmp[0]]++;
            yc[tmp[1]]++;
            if(xc[tmp[0]]==mat[0].length||yc[tmp[1]]==mat.length){
                return i;
            }
        }
        return 0;
    }
}

力扣每日一题
题目：1657. 确定两个字符串是否接近

日期：2023-11-30
用时：21 m 07 s
时间：11ms
内存：43.70MB
代码：

class Solution {
    public boolean closeStrings(String word1, String word2) {
        if(word1.length()!=word2.length()){
            return false;
        }
        int[] arr1 = new int[26];
        int[] arr2 = new int[26];
        int mask1=0;
        int mask2=0;
        for(int i=0;i<word1.length();i++){
            arr1[word1.charAt(i)-'a']++;
            arr2[word2.charAt(i)-'a']++;
            mask1 |= 1<<(word1.charAt(i)-'a');
            mask2 |= 1<<(word2.charAt(i)-'a');
        }
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        return Arrays.equals(arr1,arr2)&&mask1==mask2;
    }
}

力扣每日一题
题目：2336. 无限集中的最小数字

日期：2023-11-29
用时：3 m 50 s
时间：71ms
内存：43.68MB
代码：

class SmallestInfiniteSet {

    List<Integer> list;

    public SmallestInfiniteSet() {
        list = new ArrayList<>();
        for(int i=1;i<1001;i++){
            list.add(i);
        }
        Collections.sort(list);
    }
    
    public int popSmallest() {
        int num = list.get(0);
        list.remove(0);
        return num;
    }
    
    public void addBack(int num) {
        if(!list.contains(num)){
            list.add(num);
            Collections.sort(list);
        }
    }
}

/**
 * Your SmallestInfiniteSet object will be instantiated and called as such:
 * SmallestInfiniteSet obj = new SmallestInfiniteSet();
 * int param_1 = obj.popSmallest();
 * obj.addBack(num);
 */

力扣每日一题
题目：1670. 设计前中后队列
日期：2023-11-28
用时：8 m 23 s
时间：6ms
内存：43.55MB
代码：

class FrontMiddleBackQueue {

    List<Integer> list;

    public FrontMiddleBackQueue() {
        list = new ArrayList<>();
    }
    
    public void pushFront(int val) {
        list.add(0,val);
    }
    
    public void pushMiddle(int val) {
        list.add(list.size()/2,val);
    }
    
    public void pushBack(int val) {
        list.add(val);
    }
    
    public int popFront() {
        if(list.size()==0){
            return -1;
        }
        int res = list.get(0);
        list.remove(0);
        return res;
    }
    
    public int popMiddle() {
        if(list.size()==0){
            return -1;
        }
        int res = list.get((list.size()-1)/2);
        list.remove((list.size()-1)/2);
        return res;
    }
    
    public int popBack() {
        if(list.size()==0){
            return -1;
        }
        int res = list.get(list.size()-1);
        list.remove(list.size()-1);
        return res;
    }
}

/**
 * Your FrontMiddleBackQueue object will be instantiated and called as such:
 * FrontMiddleBackQueue obj = new FrontMiddleBackQueue();
 * obj.pushFront(val);
 * obj.pushMiddle(val);
 * obj.pushBack(val);
 * int param_4 = obj.popFront();
 * int param_5 = obj.popMiddle();
 * int param_6 = obj.popBack();
 */

力扣每日一题
题目：907. 子数组的最小值之和
日期：2023-11-27
用时：14 m 14 s
时间：19ms
内存：47.42MB
代码：

class Solution {
    public int sumSubarrayMins(int[] arr) {
        int n=arr.length;
        int res = 0;
        int mod=1000000007;
        Deque<Integer> deque=new ArrayDeque<>();
        for (int i=0; i <= n; i++) {
            int cur = i<n?arr[i] : 0;
            while (!deque.isEmpty() && arr[deque.peekLast()] >= cur) {
                int index = deque.pollLast();
                int l=deque.isEmpty()?-1:deque.peekLast();
                res += 1L*(index-l)*(i-index)%mod*arr[index]%mod;
                res %= mod;
            }
            deque.addLast(i);
        }
        return res;
    }
}

介绍

WinSW可以将Windows上的任何程序作为系统服务进行管理，已达到开机自启的效果。

支持的平台

WinSW需要运行在拥有.NET Framework 4.6.1或者更新版本的Windows平台下

下载

• github： 下载地址

• 百度网盘（v2.12.0）：WinSW-x86 WinSW-x64

使用说明

全局应用

1. 获取WinSW.exe文件
2. 编写myapp.xml文件（详细内容看[XML配置文件](# XML配置文件)）
3. 运行winsw install myapp.xml [options]安装服务，使其写入系统服务中
4. 运行winsw start myapp.xml 开启服务
5. 运行winsw status myapp.xml 查看服务的运行状态

单一应用

1. 获取WinSW.exe文件并将其更名为你的服务名(例如myapp.exe).
2. 编写myapp.xml文件
3. 请确保前面两个文件在同一目录
4. 运行myapp.exe install [options]安装服务，使其写入系统服务中
5. 运行myapp.exe start开启服务
6. 运行myapp status myapp.xml 查看服务的运行状态

命令

除了使用说明中的install、start、status三个命令外，WinSW还提供了其他的命令，具体命令及说明如下：

• install：安装服务

• uninstall：卸载服务

• start：启动服务

• stop：停止服务

• restart：重启服务

• status：检查服务状态

• refresh：刷新服务属性

• customize：自定义包装器可执行文件

• dev：扩展命令（具体看下方）

扩展命令：

• dev ps：绘制与服务相关的进程树

• dev kill：如果服务停止响应，则终止该服务

• dev list：列出当前可执行文件管理的服务

XML配置文件

文件结构

xml文件的根元素必须是 <service>, 并支持以下的子元素

例子：

<service>
  <id>jenkins</id>
  <name>Jenkins</name>
  <description>This service runs Jenkins continuous integration system.</description>
  <env name="JENKINS_HOME" value="%BASE%"/>
  <executable>java</executable>
  <arguments>-Xrs -Xmx256m -jar "%BASE%\jenkins.war" --httpPort=8080</arguments>
  <log mode="roll"></log>
</service>

环境变量扩展

配置 XML 文件可以包含 %Name% 形式的环境变量扩展。如果发现这种情况，将自动用变量的实际值替换。如果引用了未定义的环境变量，则不会进行替换。

此外，服务包装器还会自行设置环境变量 BASE，该变量指向包含重命名后的 WinSW.exe 的目录。这对引用同一目录中的其他文件非常有用。由于这本身就是一个环境变量，因此也可以从服务包装器启动的子进程中访问该值。

配置条目

id

必填 指定 Windows 内部用于标识服务的 ID。在系统中安装的所有服务中，该 ID 必须是唯一的，且应完全由字母数字字符组成。

<id>jenkins</id>

executable

必填 该元素指定要启动的可执行文件。它可以是绝对路径，也可以直接指定可执行文件的名称，然后从 PATH 中搜索（但要注意的是，服务通常以不同的用户账户运行，因此它的 PATH 可能与 shell 不同）。

<executable>java</executable>

name

可选项 服务的简短显示名称，可以包含空格和其他字符。该名称不能太长，如 ，而且在给定系统的所有服务中也必须是唯一的。

<name>Jenkins</name>

description

可选 对服务的长篇可读描述。当服务被选中时，它会显示在 Windows 服务管理器中。

<description>This service runs Jenkins continuous integration system.</description>

startmode

可选 此元素指定 Windows 服务的启动模式。可以是以下值之一：自动或手动。有关详细信息，请参阅 [ChangeStartMode](Win32_Service 类的 ChangeStartMode 方法 (CIMWin32 WMI 提供程序) - Win32 apps | Microsoft Learn) 方法。默认值为自动Automatic。

delayedAutoStart

可选 如果定义了Automatic模式，此布尔选项将启用延迟启动模式。更多信息，请参阅Startup Processes and Delayed Automatic Start。

请注意，该启动模式不适用于 Windows 7 和 Windows Server 2008 以上的旧版本。在这种情况下，Windows 服务安装可能会失败。

<delayedAutoStart>true</delayedAutoStart>

depend

可选 指定此服务依赖的其他服务的 ID。当服务 X 依赖于服务 Y 时，X 只能在 Y 运行时运行。

可使用多个元素指定多个依赖关系。

<depend>Eventlog</depend>
<depend>W32Time</depend>

log

可选 用 和启动模式设置不同的日志目录：append（默认）、reset（清除日志）、ignore（忽略）、roll（移动到 *.old）。

更多信息，请参阅Logging and error reporting。

<log mode="roll"></log>

arguments

可选 元素指定要传递给可执行文件的参数。

<arguments>arg1 arg2 arg3</arguments>

或者

<arguments>
  arg1
  arg2
  arg3
</arguments>

stopargument/stopexecutable

可选 当服务被请求停止时，winsw 会简单地调用 TerminateProcess function立即杀死服务。但是，如果存在 元素，winsw 将使用指定的参数启动另一个 进程（或 ，如果已指定），并期望该进程启动服务进程的优雅关闭。     

然后，Winsw 将等待这两个进程自行退出，然后向 Windows 报告服务已终止。

使用 时，必须使用 而不是 。

<executable>catalina.sh</executable>
<startarguments>jpda run</startarguments>

<stopexecutable>catalina.sh</stopexecutable>
<stoparguments>stop</stoparguments>

Additional commands

扩展命令包括prestart,poststart,prestop,poststop四个，以prestart为例写法如下：

<prestart>
  <executable></executable>
  <arguments></arguments>
  <stdoutPath></stdoutPath>
  <stderrPath></stderrPath>
</prestart>

• prestart：在服务启动时、主进程启动前执行

• poststart：在服务启动时和主程序启动后执行

• prestop：在服务停止时、主进程停止前执行

• poststop：在服务停止时和主进程停止后执行

共用的命令如下：

• stdoutPath：指定将标准输出重定向到的路径

• stderrPath：指定将标准错误输出重定向到的路径

在 stdoutPath 或 stderrPath 中指定 NUL 可处理相应的数据流

preshutdown

当系统关闭时，让服务有更多时间停止。

系统默认的预关机超时时间为三分钟。

<preshutdown>false</preshutdown>
<preshutdownTimeout>3 min</preshutdown>

stoptimeout

当服务被请求停止时，winsw 会首先尝试向控制台应用程序发送 Ctrl+C 信号，或向 Windows 应用程序发布关闭消息，然后等待长达 15 秒的时间，让进程自己优雅地退出。如果超时或无法发送信号或消息，winsw 就会立即终止服务。

通过这个可选元素，您可以更改 "15 秒 "的值，这样就可以控制 winsw 让服务自行关闭的时间。

<stoptimeout>10sec</stoptimeout>

Environment

如有必要，可多次指定该可选元素，以指定要为子进程设置的环境变量。

<env name="HOME" value="c:\abc" />

interactive

如果指定了此可选元素，则允许服务与桌面交互，如显示新窗口和对话框。

<interactive>true</interactive>

请注意，自引入 UAC（Windows Vista 及以后版本）以来，服务已不再真正允许与桌面交互。在这些操作系统中，这样做的目的只是让用户切换到一个单独的窗口站来与服务交互。

beeponshutdown

该可选元素用于在服务关闭时发出simple tones。此功能只能用于调试，因为某些操作系统和硬件不支持此功能。

<beeponshutdown>true</beeponshutdown>

download

可以多次指定这个可选元素，以便让服务包装器从 URL 获取资源并将其作为文件放到本地。此操作在服务启动时，即 <executable> 指定的应用程序启动前运行。

对于需要身份验证的服务器，必须根据身份验证类型指定一些参数。只有基本身份验证需要额外的子参数。支持的身份验证类型有

• none（无）：默认值，不得指定

• sspi：Windows Security Support Provider Interface，包括 Kerberos、NTLM 等。

• basic：基本身份验证，子参数：

  • user="UserName" 用户名

  • password="Passw0rd"

  • unsecureAuth="true": 默认值="false"

参数 unsecureAuth 仅在传输协议为 HTTP（未加密数据传输）时有效。这是一个安全漏洞，因为凭据是以明文发送的！对于 SSPI 身份验证来说，这并不重要，因为身份验证令牌是加密的。

对于使用 HTTPS 传输协议的目标服务器来说，颁发服务器证书的 CA 必须得到客户端的信任。当服务器位于互联网上时，通常会出现这种情况。当一个组织在内部网中使用自行签发的 CA 时，情况可能并非如此。在这种情况下，有必要将 CA 导入 Windows 客户端的证书 MMC。请参阅 "Manage Trusted Root Certificates"中的说明。必须将自行签发的 CA 导入计算机的可信根证书颁发机构。

默认情况下，如果操作失败（如从不可用），下载命令不会导致服务启动失败。为了在这种情况下强制下载失败，可以指定 failOnError 布尔属性。

要指定自定义代理，请使用参数 proxy，格式如下：

• 有凭据：http://USERNAME:PASSWORD@HOST:PORT/。

• 无凭据： http://HOST:PORT/。

<download from="http://example.com/some.dat" to="%BASE%\some.dat" />

<download from="http://example.com/some.dat" to="%BASE%\some.dat" failOnError="true"/>

<download from="http://example.com/some.dat" to="%BASE%\some.dat" proxy="http://192.168.1.5:80/"/>

<download from="https://example.com/some.dat" to="%BASE%\some.dat" auth="sspi" />

<download from="https://example.com/some.dat" to="%BASE%\some.dat" failOnError="true"
          auth="basic" user="aUser" password="aPassw0rd" />

<download from="http://example.com/some.dat" to="%BASE%\some.dat"
          proxy="http://aUser:aPassw0rd@192.168.1.5:80/"
          auth="basic" unsecureAuth="true"
          user="aUser" password="aPassw0rd" />

这是开发自我更新服务的另一个有用的组成部分。

自 2.7 版起，如果目标文件存在，WinSW 将在 If-Modified-Since 标头中发送其最后写入时间，如果收到 304 Not Modified，则跳过下载。

onfailure

当 winsw 启动的进程失败（即以非零退出代码退出）时，这个可选的可重复元素将控制其行为。

<onfailure action="restart" delay="10 sec"/>
<onfailure action="restart" delay="20 sec"/>
<onfailure action="reboot" />

例如，上述配置会导致服务在第一次故障后 10 秒内重新启动，在第二次故障后 20 秒内重新启动，然后如果服务再次发生故障，Windows 将重新启动。

每个元素都包含一个强制的 action 属性和可选的 delay 属性，前者用于控制 Windows SCM 将采取的行动，后者用于控制采取该行动前的延迟时间。action 的合法值为

• restart：重新启动服务

• reboot：重新启动 Windows。将显示带有 CRITICAL_PROCESS_DIED 错误检查代码的蓝色屏幕

• none：不执行任何操作，让服务停止延迟属性的可能后缀为秒/秒/分钟/分钟/小时/小时/天/天。如果缺少，延迟属性默认为 0。

延迟属性的后缀可能是秒/秒/分/分/小时/小时/天/天。如果缺少，延迟属性默认为 0。

如果服务不断发生故障，并且超过了配置的 <onfailure> 次数，则会重复上次的操作。因此，如果只想始终自动重启服务，只需像这样指定一个 <onfailure> 元素即可：

<onfailure action="restart" />

resetfailure

此可选元素控制 Windows SCM 重置故障计数的时间。例如，如果您指定 1 小时，而服务持续运行的时间超过一小时，那么故障计数将重置为零。

换句话说，这是您认为服务成功运行的持续时间。默认为 1 天。

<resetfailure>1 hour</resetfailure>

Security descriptor

SDDL 格式的服务安全描述符字符串。

有关详细信息，请参阅安全描述符定义语言。

<securityDescriptor></securityDescriptor>

Service account

服务默认安装为 LocalSystem 账户。如果您的服务不需要很高的权限级别，可以考虑使用 LocalService 账户、NetworkService 帐户或用户账户。

要使用用户账户，请像这样指定 <serviceaccount> 元素：

<serviceaccount>
  <username>DomainName\UserName</username>
  <password>Pa55w0rd</password>
  <allowservicelogon>true</allowservicelogon>
</serviceaccount>

<username> 的格式为 DomainName\UserName 或 UserName@DomainName。如果账户属于内置域，则可以指定 .\UserName。

<allowservicelogon> 是可选项。如果设置为 true，将自动为列出的账户设置 "允许以服务身份登录 "的权限。

要使用Group Managed Service Accounts Overview，请在账户名后追加 $ 并删除 <password> 元素：

<serviceaccount>
  <username>DomainName\GmsaUserName$</username>
  <allowservicelogon>true</allowservicelogon>
</serviceaccount>

LocalSystem account

要明确使用LocalSystem 帐户 ，请指定以下内容：

<serviceaccount>
  <username>LocalSystem</username>
</serviceaccount>

请注意，该账户没有密码，因此提供的任何密码都将被忽略。

LocalService account

要使用 LocalService 帐户，请指定以下内容：

<serviceaccount>
  <username>NT AUTHORITY\LocalService</username>
</serviceaccount>

请注意，该账户没有密码，因此提供的任何密码都将被忽略。

NetworkService account

要使用 NetworkService 帐户，请指定以下内容：

<serviceaccount>
  <username>NT AUTHORITY\NetworkService</username>
</serviceaccount>

请注意，该账户没有密码，因此提供的任何密码都将被忽略。

prompt

可选。提示输入用户名和密码。

<serviceaccount>
  <prompt>dialog|console</prompt>
</serviceaccount>

• 话框：使用对话框进行提示。

• 控制台：在控制台进行提示。

Working directory

某些服务在运行时需要指定工作目录。为此，请像这样指定<workingdirectory>元素：

<workingdirectory>C:\application</workingdirectory>

Priority

可选择指定服务进程的调度优先级（相当于 Unix nice），可选值包括idle, belownormal, normal, abovenormal, high, realtime（不区分大小写）。

<priority>idle</priority>

指定高于正常值的优先级会产生意想不到的后果。有关详细信息，请参阅 .NET 文档中的 ProcessPriorityClass 枚举。此功能的主要目的是以较低的优先级启动进程，以免干扰计算机的交互式使用。

Auto refresh

<autoRefresh>true</autoRefresh>

当服务启动或执行以下命令时，自动刷新服务属性：

• start
• stop
• restart

默认值为 true。

sharedDirectoryMapping

默认情况下，即使在 Windows 服务配置文件中进行了配置，Windows 也不会为服务建立共享驱动器映射。由于域策略的原因，有时无法解决这个问题。

这样就可以在启动可执行文件之前映射外部共享目录。

<sharedDirectoryMapping>
  <map label="N:" uncpath="\\UNC" />
  <map label="M:" uncpath="\\UNC2" />
</sharedDirectoryMapping>

导言

在Java应用程序开发中，字符编码问题是一个常见的挑战。正确处理字符编码对于数据的完整性至关重要。本文将深入探讨JVM（Java虚拟机）编码格式的相关内容，包括如何查询、设置和修改，以及如何应对字符编码问题。

1、JVM编码格式简介：

JVM（Java虚拟机）是运行Java程序的核心组件，它负责将Java字节码转换为机器指令。在Java应用程序中，正确的编码设置非常重要，因为它直接影响到字符串的处理和输出。了解JVM的编码格式以及如何设置和管理它们对于开发可靠和可移植的Java应用程序至关重要。

2、查询JVM的编码格式：

有多种方法可以查询JVM的编码格式。其中一种方法是使用Java代码来查询。通过调用System.getProperty("file.encoding")方法，可以获取JVM当前的默认编码格式。另一种方法是使用命令行工具查看JVM的编码设置。可以使用以下命令来查看JVM参数：

java -XX:+PrintFlagsFinal -version | grep -iE 'Default Charset'

3、设置JVM的编码格式：

有两种主要方法可以配置JVM的编码格式。第一种是通过启动参数配置。在启动Java应用程序时，可以在命令行或脚本中添加特定的启动参数来设置JVM的编码格式。例如，使用以下命令来设置UTF-8编码：

java -Dfile.encoding=UTF-8 YourApplication

第二种方法是使用Java代码修改系统属性以设置JVM编码。可以通过调用System.setProperty("file.encoding", "UTF-8")方法来实现。确保在应用程序的适当位置执行此操作以确保编码在整个生命周期中保持一致。

4、改JVM的默认编码格式：

• 编辑启动脚本以调整JVM编码设置。找到启动Java应用程序的脚本文件（如startup.sh或startup.bat），并添加适当的启动参数来指定所需的编码格式。例如，使用以下命令来设置UTF-8编码：

export JAVA_OPTS="-Dfile.encoding=UTF-8"

然后重新启动应用程序，新的编码设置将生效。

• 如果使用的是IDE（集成开发环境），可以在项目设置或运行配置中添加相应的启动参数来修改JVM的默认编码格式。
• 如果应用程序已经部署在服务器上，可以通过修改服务器配置文件或环境变量来更改默认编码格式。这通常涉及到对操作系统的环境变量进行设置或更新相关的服务配置。

5、注意事项和最佳实践：

在选择和设置JVM的编码格式时，需要注意以下几点：

• 确保选择与应用程序需求相匹配的编码格式。不同的字符集适用于不同的场景，如处理文本数据、网络通信等。根据具体的应用场景选择合适的编码格式可以提高程序的效率和正确性。
• 理解特定应用程序的字符编码要求。某些应用程序可能有特定的字符编码要求，如XML解析器可能要求使用特定的字符集。在设计和开发应用程序时，要仔细考虑这些要求，并相应地设置JVM的编码格式。
• 注意跨平台兼容性。不同的操作系统和Java版本可能支持不同的字符集。在进行跨平台开发时，要测试和验证所选的编码

结论

正确设置JVM编码格式对于Java应用程序至关重要，因为它直接影响字符数据的传输和处理。通过本文提供的详细指南，您可以解决字符编码问题，确保应用程序在各种情况下都能正确运行。不要低估字符编码的重要性，因为它可能对您的应用程序的可靠性产生深远影响。

在 Linux 和 Unix 系统中，cron 是一个强大的工具，用于执行预定时间的任务。Cron 允许用户自动化各种重复性任务，如备份、系统监控、日志清理等。在
cron 中，时间的设定是至关重要的，它使用一些特殊的时间字段来确定任务的执行时机。本文将深入探讨常见的 cron 时间字段及其用途。

1、常规 Cron 时间字段

常规 Cron 时间字段：精确控制任务执行时间

在常规 cron 时间字段中，您可以通过分钟、小时、日期等来精确控制任务的执行时间。以下是一些示例：

1.1、每天凌晨执行备份任务

0 0 * * * /usr/local/bin/backup.sh

1.2、每小时执行系统监控任务

0 * * * * /usr/local/bin/system_monitor.sh

1.3、每周执行日志清理任务：

0 2 * * 6 /usr/local/bin/clean_logs.sh

1.4、每月执行系统更新任务：

0 3 1 * * /usr/bin/apt-get update && /usr/bin/apt-get upgrade -y

1.5、每隔 15 分钟执行检查网站可用性任务：

*/15 * * * * /usr/local/bin/check_website.sh

这些常规的 cron 时间字段允许您按照特定的时间表来安排任务的执行，非常适用于各种自动化需求。

2、特殊 Cron 时间字段：简化时间设定

除了常规的时间字段外，还有一些特殊的时间字段，如 @reboot、@yearly、@monthly 等，它们可以更方便地设置任务的执行时间，通常用于特殊场景。示例：

2.1、@reboot：系统启动时执行任务

@reboot /usr/local/bin/startup_script.sh

2.2、@yearly 或 @annually：每年执行一次

@yearly /usr/local/bin/yearly_task.sh

2.3、@monthly：每月执行一次

@monthly /usr/local/bin/monthly_task.sh

2.4、@weekly：每周执行一次

@weekly /usr/local/bin/weekly_task.sh

2.5、@daily 或 @midnight：每天执行一次

@daily /usr/local/bin/daily_task.sh

2.6、@hourly：每小时执行一次

@hourly /usr/local/bin/hourly_task.sh

这些特殊的时间字段使得在 crontab 中定义定时任务更加方便，您可以根据任务的周期性要求选择适当的时间字段。它们使时间设定更加直观和易读，而不需要编写复杂的时间表。通过合理利用cron 时间字段，您可以轻松自动化各种系统维护和管理任务，提高系统的效率和可靠性。

在现代Web开发中，许多开发者都曾经遇到过一个令人困扰的问题：当图片URL没有变化但图片内容却发生了变化时，浏览器似乎不会主动刷新图片，从而导致显示旧的内容。这个问题在网站和应用中的图片更新时尤为突出，可能会影响用户体验和页面正确性。

在这篇博客文章中，我们将探讨这个问题，并提供多种解决方案，其中包括添加时间戳或随机参数以绕过浏览器缓存以及配置缓存控制头来告诉浏览器如何处理这些图片。我们将深入了解这些解决方案的实现方式以及它们在不同服务器和框架中的应用。

问题的根源

问题的根本在于浏览器的缓存机制。浏览器会根据图片的URL来决定是否重新请求图片或者使用缓存中的版本。当图片的URL保持不变时，浏览器会倾向于使用已经缓存的旧版本，而不会去服务器重新获取新的图片内容。

解决方案一：添加时间戳或随机参数

为了绕过浏览器的缓存机制，最简单的方法之一是在图片的URL上添加一个时间戳或随机参数。这将使每次请求都看起来像一个不同的URL，从而迫使浏览器重新加载图片。

<img :src="'your-image-url.jpg?' + Date.now()">

或者使用JavaScript生成随机参数：

<img :src="'your-image-url.jpg?' + Math.random()">

这种方法适用于各种Web开发环境，并且非常容易实现。

解决方案二：配置缓存控制头

另一种更强大的方法是在服务器端配置缓存控制头。不同的服务器和框架有不同的配置方式，以下是一些示例：

Apache

在Apache服务器上，您可以通过.htaccess文件来配置缓存控制头，告诉浏览器不要缓存特定类型的图片。

<IfModule mod_headers.c>
    # 禁止缓存指定文件类型的图片，例如 .jpg 和 .png
    <FilesMatch "\.(jpg|png)$">
        Header set Cache-Control "no-cache, no-store, must-revalidate"
        Header set Pragma "no-cache"
        Header set Expires 0
    </FilesMatch>
</IfModule>

Nginx

如果使用Nginx作为服务器，可以在Nginx配置文件中添加以下配置来实现缓存控制：

location ~* \.(jpg|png)$ {
    expires -1;
    add_header Cache-Control "no-store, no-cache, must-revalidate, max-age=0";
    add_header Pragma "no-cache";
}

Node.js（Express框架）

在Node.js中使用Express框架，您可以创建一个中间件来设置缓存控制头，以确保浏览器不会缓存特定类型的图片。

const express = require('express');
const app = express();

// 禁止缓存指定文件类型的图片，例如 .jpg 和 .png
app.use((req, res, next) => {
    if (req.url.endsWith('.jpg') || req.url.endsWith('.png')) {
        res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
        res.setHeader('Pragma', 'no-cache');
    }
    next();
});

// 其他路由和中间件设置

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

结论

无论您选择哪种方法，解决图片不刷新的问题都是可能的。添加时间戳或随机参数是最简单的方法之一，但它可能需要在多个地方修改代码。配置缓存控制头则可以更全面地控制缓存行为，但需要在服务器端进行配置。

根据您的项目需求和服务器环境，选择适合您的方法，并确保您的用户可以始终看到最新的图片内容，以提供更好的用户体验。希望本文对您有所帮助，解决了这个常见的开发问题。

最终，了解您的应用需求并进行测试是选择合适的帧率和分辨率的关键。通过仔细权衡这些因素，您可以确保您的RTSP流视频抓取应用提供了所需的性能和图像质量。

引言

在实时视频流应用中，选择适当的帧率和分辨率对于确保视频流的顺畅播放和图像质量至关重要。本文将向您介绍如何使用Java和JavaCV库中的FFmpegFrameGrabber来从RTSP流中抓取图像，并在抓取时设置帧率和分辨率。

一、配置开发环境

首先，确保您的Java项目中包含JavaCV库的依赖。您可以在Maven项目中添加以下依赖：

<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacv-platform</artifactId>
    <version>1.5.1</version> <!-- 请检查最新版本 -->
</dependency>

二、使用Java代码抓取RTSP流图像

下面是一个示例Java代码，演示了如何使用FFmpegFrameGrabber从RTSP流中抓取图像并将其保存为JPEG格式的图像文件。

import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.Java2DFrameConverter;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

public class RTSPImageCapture {
    public static void main(String[] args) {
        String rtsp = "YOUR_RTSP_URL_HERE"; // 替换为实际的RTSP URL
        String imgSrc = ""; // 图像保存路径
        String linuxImg = "/path/to/linux/img/"; // Linux系统下的保存路径
        String winImg = "C:\\path\\to\\windows\\img\\"; // Windows系统下的保存路径

        try {
            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(rtsp);
            // 使用tcp的方式，不然会丢包很严重
            grabber.setOption("rtsp_transport", "tcp");
            grabber.start();
            Frame frame = grabber.grabImage();
            if (frame != null) {
                if (imgSrc == null || imgSrc.isEmpty()) {
                    String path = "";
                    if (SystemUtils.isLinux()) {
                        path = linuxImg;
                    } else if (SystemUtils.isWindows()) {
                        path = winImg;
                    }
                    imgSrc = path + "video.jpg";
                }
                File file = new File(imgSrc);
                file.createNewFile();
                Java2DFrameConverter converter = new Java2DFrameConverter();
                BufferedImage bufferedImage = converter.getBufferedImage(frame);
                ImageIO.write(bufferedImage, "jpg", file);
            }
            grabber.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

确保将上述代码中的YOUR_RTSP_URL_HERE替换为实际的RTSP流URL，并设置正确的图像保存路径。

三、帧率的选择

1、实时性要求

• 帧率定义了每秒显示的图像数量，通常以"帧每秒"（fps）表示。
• 实时或接近实时的应用，如视频监控，通常需要较高的帧率，建议使用30fps或更高。

2、考虑资源限制

• 高帧率需要更多的带宽和计算资源。
• 确保您的设备和网络能够支持所选的帧率，以避免性能问题。

3、应用场景

• 不同应用场景可能需要不同的帧率。
• 视频播放应用可以使用较低的帧率，而要求高质量图像的应用则可能需要更高的帧率。

4、存储需求

• 高帧率会导致更多的视频数据，需要更多的存储空间。
• 考虑存储需求，特别是如果需要保存视频流供后续分析或回放。

四、分辨率的选择

1、显示设备和屏幕大小

• 分辨率应适合最终显示图像的设备或屏幕大小。
• 高分辨率适合大型屏幕，低分辨率适合小型设备。

2、带宽和性能

• 高分辨率图像通常需要更多带宽和计算资源。
• 在有限的带宽或性能条件下，选择适度的分辨率以确保流畅的抓取和显示。

3、应用场景

• 根据应用需求选择合适的分辨率。
• 720p（1280x720像素）或1080p（1920x1080像素）通常适合大多数实时监控应用。

4、存储需求

• 高分辨率图像需要更多的存储空间。
• 考虑存储需求，特别是如果需要保存抓取的图像或视频流。

五、设置帧率和分辨率的实际操作

要设置帧率和分辨率，您可以使用相应的方法来配置FFmpegFrameGrabber：

// 设置所需的帧率
grabber.setFrameRate(desiredFrameRate);

// 设置所需的分辨率
grabber.setImageWidth(desiredWidth);
grabber.setImageHeight(desiredHeight);

确保在调用grabber.start();之前进行这些设置，以确保配置在抓取开始之前生效。

选择合适的帧率和分辨率是优化RTSP流视频抓取的关键步骤，可以提供良好的图像质量和实时性，同时考虑资源限制和存储需求。根据您的应用需求，选择最佳的参数设置，以获得最佳的用户体验。

六、实时性和流畅性的权衡

在选择帧率和分辨率时，需要平衡实时性和流畅性。以下是一些有关权衡的考虑：

• 实时性：较高的帧率和分辨率可以提供更好的实时性，但可能需要更多的带宽和处理能力。在需要快速响应和高质量图像的应用中，实时性至关重要。

• 流畅性：较高的帧率通常会导致更平滑的视频播放，但也需要更多的带宽。较低的帧率可能会导致视频看起来不够流畅，但在有限的带宽条件下可能是唯一可行的选择。

• 网络条件：网络速度和稳定性对帧率和分辨率的选择至关重要。在不稳定的网络条件下，较低的帧率和分辨率可能更可取，以减少视频中断或缓冲。

七、动态调整

有些应用可能需要根据情况动态调整帧率和分辨率。例如，当网络带宽下降时，可以降低帧率和分辨率以适应当前条件，从而保持视频的流畅性。

结论

选择合适的帧率和分辨率是优化RTSP流视频抓取的关键决策。根据应用的实时性要求、资源限制、显示设备、存储需求和网络条件，您可以调整这些参数以获得最佳的用户体验。实时性和流畅性之间的权衡是一个关键考虑因素，可以根据需要进行调整，以适应不同的应用场景。

沈阳盖章计划

和平区

• 中共满洲省委门口服务站（2个）

• 歌德书店（1个蓝色章）

• 沈阳集邮门市部（38个章）

• 沈阳东北大学成立100周年（东大风味食堂进去科学馆1923咖啡馆，定位到天猫超市，28个章）

• 老北市6号门文创雪糕（8个章，12.8元雪糕）

• [√] 老北市1号门服务台（免费4个）

• 老北市1号门服务台（消费39有34个章）

• 老北市汉字主题书房（28个，38元）

• 刘少奇旧居纪念馆(满洲省委旧址)

• 西西弗书店太原街万达F2（2个）

• 西西弗书店万象城bl（2个）

• 西西弗书店长白万象汇F2（2个）

• 宋玉桂艺术馆（5个）

• 雷锋主题邮局（4个）砂阳路邮局

• 茶话弄（沈阳太原街万达店）

• 太原街中兴魔方小镇（2个）

• 盛京邮局（2个）

• 阳光荟购物中心魔方小镇（2个）

铁西区

• 红梅文创园服务中心(1个章)
• 西西弗书店万象汇F2(1个章)
• 铁西工业博物馆免费
• [√] 铁西1905文化创意园3楼小芝社(27个章，49)
• 铁西1905文化创意园3楼微码客(2个章，任意消费，建议沈阳手绘地图29）
• 铁西1905文化创意园一楼西门服务台边上有个店，进去礼貌询问店员即可免费盖
• 铁西1905文化创意园中间的市集一楼003摊位，蜜思花园，一家卖首饰的店，橡皮章，免费盖
• 铁西1905文化创意园楼一楼中间005摊位，CUTECATS。任意消费可盖
• 铁西1905文化创意园一楼中间008摊位，光之翼塔罗 免费盖
• 铁西1905文化创意园p6边上 @红雾动画工作室 关注小红书送扇子消费送贴纸
• 铁西1905文化创意园二楼右侧楼梯 旁，饰物所@daydream事务所

沈河区

• 沈阳城市规划展示馆(1个章)
• 小芝社故宫店(8个章+3个隐藏章，最低需消费30元)
• 西西弗书店中街大悦城店F2(2个章)
• 沈阳故宫.莊啡(18个章)
• 沈阳故宫文创大政殿旁(12个章，通关文牒25)还有一个15元地图
• 沈阳故宫出口处旁(17个章)
• 沈阳故宫戏台旁边长滩(6个章，17元明 信片)
• 西西弗书店中街恒隆店F2(2个章)
• 东三省总督府(1个章)
• [√] 张氏帅府外面文创(120个章，49元盖章本)可拿文创本进帅府里面还有30枚印章(48门票)
• [√] 张氏帅府游客中心(3个章)
• 沈阳金融博物馆（门票20，25元盖10个章，其中两个章在出口免费盖，买45还是48来着的本子可以多盖5枚金属圆章）
• [√] 沈阳博物馆(12个章，39元盖章本)
• 大悦城魔方小镇前台咖啡处北方书城(2个)免费(9月份才有)
• [√] 神马艺术商店中街HK01流行馆六楼(25个，任意消费)
• 沈阳美术馆(1枚)
• 沈阳中街HK01流行馆六楼"是是是集”(2个)
• 沈阳中街Hk01流行馆六楼"Crunch冻春”(抵消20)(章数20+)
• 沈阳迦大文创设计廊(7个)抵消30

浑南区

• 世博园(1个待确认)
• 西西弗书店全运路万达F1(2个章)
• 辽宁科技馆(4个章)
• [√] 辽宁博物馆(19个章)
• 东陵公园(1个章)

皇姑区

• 北陵公园(1个章)
• 新乐遗址(1个章)
• 抗美援朝烈士纪念馆(1个章)
• 西西弗书店皇姑万象汇(2个章)
• [√] 辽宁古生物博物馆(2个章)
• 皇姑屯事件博物馆
• 审判日本战犯军事法庭(1个章)
• 沈飞航空博览园(1个章)

大东区

• 北大营旧址(1个章)
• 二战盟军战俘营陈列馆(1个章)
• 大悦城咖啡主题邮局(63个章)没有了
• 沈阳大学自然博物馆(1个章)暑假不开
• [√] 九一八邮局(15个章)
• [√] 九一八文创(8个章)
• 周恩来少年读书旧址(1个章)周六日对散客
• 呈展稻米节

沈北区

• [√] 锡伯族博物馆服务台和文创店(1+10)

在Vue应用中调用打印机功能，可以使用JavaScript的window.print()方法。这个方法会打开打印对话框，然后让我们选择打印设置并打印文档，但是尼这种方法依赖于浏览器的打印功能。

以下是一个简单的示例，演示如何在Vue组件中调用打印功能：

1. 在Vue组件中，将需要打印的内容放入一个具有唯一ID的元素中。例如，你可以使用<div id="printable-content"></div>来包裹打印内容。

<template>
  <div>
    <button @click="print">打印</button>
    <div id="printable-content">
      <!-- 待打印的内容 -->
    </div>
  </div>
</template>

2. 在Vue组件的methods中定义print方法，该方法将获取打印内容并调用window.print()方法打开打印对话框。

<script>
export default {
  methods: {
    print() {
      // 获取待打印的内容
      let printableContent = document.getElementById('printable-content').innerHTML;
      
      // 创建一个新的窗口并加载打印内容
      let printWindow = window.open('', '_blank');
      printWindow.document.write('<html><head><title>打印内容</title></head><body>' + printableContent + '</body></html>');
      
      // 执行打印操作
      printWindow.document.close();
      
      // 如果内容中有图片或其他需要一定时间加载的，请使用注释中的延时打印
      // setTimeout(() => {
      //   printWindow.print()
      // }, 200)
      printWindow.print();
    }
  }
}
</script>

3. 当点击"打印"按钮时，print方法会被调用，从而打开打印对话框。用户可以在对话框中选择打印设置并打印文档。

最后，再次强调，这种方法依赖于浏览器的打印功能，因此它可能无法在所有打印机上正常工作。

引言

这几天的项目涉及到了文件的操作，我这边做一下整理

环境说明

jdk版本：1.8.0_311

对文件的操作

1、保存文件

/**
 * 保存文件
 *
 * @param file 文件
 * @param path 文件保存目录
 * @param name 保存后的文件名字
 */
public void saveFile(MultipartFile file, String path, String name) throws Exception {
    if (file == null) {
        throw new Exception("请上传有效文件!");
    }
    // 若目录不存在则创建目录
    File folder = new File(path);
    if (!folder.exists()) {
        folder.mkdirs();
    }

    // 生成文件，folder为文件目录，newName为文件名
    file.transferTo(new File(folder, name));
}

2、删除文件

/**
 * 删除指定目录下的指定文件
 *
 * @param path 文件路径(路径结尾不带“/”)
 * @param name 文件名称
 */
public void delFile(String path, String name) {
    File file = new File(path + "/" + name);
    file.delete();
}

3、删除指定的空目

/**
 * 删除指定的空目录，如果往上2层的目录也是空的，则一起删除
 *
 * @param path 目录路径(路径结尾不带“/”)
 */
public void delBlankDir(String path) {
    for (int i = 0; i < 3; i++) {
        File dirFile = new File(path);
        if (dirFile.length() == 0) {
            dirFile.delete();
            path = path.substring(0, path.lastIndexOf("/"));
        } else {
            break;
        }
    }
}

4、验证文件是否是MP3格式

/**
 * 验证是否是MP3格式的文件
 *
 * @param multipartFile 验证的文件
 * @return true：是MP3、false：不是MP3
 */
public boolean isMP3File(MultipartFile multipartFile) {
    try {
        byte[] headerBytes = new byte[4];
        multipartFile.getInputStream().read(headerBytes);
        if (headerBytes[0] == (byte) 0x49 && headerBytes[1] == (byte) 0x44 &&
                headerBytes[2] == (byte) 0x33) {
            return true;
        }
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
    return false;
}

5、音频格式转换

/**
 * 音频文件格式转换
 *
 * @param fpath  需要转换的音频文件路径
 * @param target 转换后的音频文件路径
 */
public void transferAudioPcm(String fpath, String target) {
    List<String> commend = new ArrayList<>();
    String path = "";
    if (SystemUtils.isLinux()) {
        path = "修改成Ffmpeg文件的路径";
    } else if (SystemUtils.isWindows()) {
        path = "修改成Ffmpeg文件的路径";
    }
    commend.add(path);
    commend.add("-y");
    commend.add("-i");
    commend.add(fpath);
    commend.add("-f");
    commend.add("s16le");
    commend.add("-ar");
    commend.add("4000");
    commend.add("-ac");
    commend.add("-1");
    commend.add(target);
    try {
        ProcessBuilder builder = new ProcessBuilder();
        builder.command(commend);
        Process p = builder.start();
        p.waitFor();
        p.destroy();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

6、改变linux系统下的文件权限

/**
 * 改变linux系统下的文件权限
 *
 * @param mod  修改后的权限
 * @param path 文件路径
 */
public void changePermission(String mod, String path) throws Exception {
    // ProcessBuilder processBuilder = new ProcessBuilder("chmod", "775", "/data/a.txt");
    ProcessBuilder processBuilder = new ProcessBuilder("chmod", mod, path);
    Process process = processBuilder.start();
    int exitCode = process.waitFor();
    if (exitCode == 0) {
        System.out.println("File permission changed successfully!");
    } else {
        System.out.println("Failed to change file permission.");
    }
}

7、查询服务器磁盘空间

/**
 * 查询服务器磁盘空间
 *
 * @return map
 */
public Map<String, String> getDiskInfo() {
    // 总空间
    long totalSpace = 0;
    // 已用空间
    long usableSpace = 0;
    // 可用空间
    long unallocatedSpace = 0;
    for (FileStore fileStore : FileSystems.getDefault().getFileStores()) {
        try {
            totalSpace += fileStore.getTotalSpace();
            usableSpace += fileStore.getUsableSpace();
            unallocatedSpace += fileStore.getUnallocatedSpace();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    DecimalFormat decimalFormat = new DecimalFormat("#.00");
    Map<String, String> map = new HashMap<>(3);
    map.put("totalSpace", decimalFormat.format(totalSpace / (1024.0 * 1024 * 1024)));
    map.put("usableSpace", decimalFormat.format(usableSpace / (1024.0 * 1024 * 1024)));
    map.put("unallocatedSpace", decimalFormat.format(unallocatedSpace / (1024.0 * 1024 * 1024)));
    return map;
}

首先，介绍下我的环境

• 机器：群晖920+

• PHP版本：7.4（套件安装的）

• 系统：群晖7.2

接下来，进入正题

首先要使用ssh进入到群晖，账户要切换到root用户

接下来，看下目前PHP7.4有哪些扩展，根据你安装位置的硬盘不同，volume1可能有所区别，命令如下：

ll /volume1/@appstore/PHP7.4/usr/local/lib/php74/modules

从上图中，我发现套件版的PHP7.4默认已经有了Redis扩展，接下来，再看看配置文件中是否配置了Redis，当然我这边是没有配置

打开配置文件php-fpm.ini，我这边喜欢用vi命令，当然也可以使用vim，具体用哪一个看你系统支持已经个人喜好了，下面的volume1一样有区别的自行修改

vi /volume1/@appstore/PHP7.4/misc/php-fpm.ini

将下面的代码放到配置文件php-fpm.ini末尾，然后保存退出

[Redis]
extension_dir = "/volume1/@appstore/PHP7.4/usr/local/lib/php74/modules/"
extension = redis.so

扩展有了，配置文件也加上了，最后就是重启PHP7.4了，命令如下：

synopkg restart PHP7.4

看到重启成功了，至此，完成收工了

deepin中steam的配置

本人的deepin系统已经更新到20.9，文章仅供参考，可能会与你的情况有所出入

下载安装

在deepin的应用商店中下载安装steam

中文设置

我这边安装完默认是英文界面，可以依次点击左上角是steam--》settings

在弹出的页面中点击左侧Interface，右侧按照红框内容选择简体中文

然后在点击重启按钮即可

重启后界面已经是中文的啦

兼容大多数的游戏

依次点击左上角的steam-->设置(英文版setting)-->弹出页面的兼容性，将红框的内容都设置完在一起重启，Proton那个下拉框选择最新的就好，我现在是8.0-2最新，也许你的并不一定是。

重启后，你就发现之前不能玩的大多数游戏都可以玩了

环境需要用到代理软件Proxifier，但配好后chrome浏览器访问对应代理的应用却不行，之前还明明可以的，今天就突然不行了，于是乎，我去排查了原因，本篇文章就是我排查的记录吧，最后问题是解决了。每个人的情况不同，可能我的办法不一定适用于你的，因此，本篇文章仅做参考。

确认Proxifier设置

1. 打开Proxifier，选择菜单栏的“Profile” - “Proxification Rules”。
2. 在“Proxification Rules”中，确认走代理的应用程序包含浏览器。如果不包含，可单击右键选择“Edit Selected Rule”，在“Edit Rule”中，设置“Any”为“Applications”后点击OK。

确认系统代理设置

首先，说明一下，本人是Win11的系统，可能会与你的有出入，下面是详细步骤：

1. 点击电脑的开始菜单，打开设置。
2. 点击左侧的“网络和Internet”，再点击右侧的代理。

3. 确认页面中红框的内容全是关闭状态，如果不是，改为关闭状态

Excel文件是一种广泛使用的电子表格格式，用于存储和处理各种数据。在Python中，有多个库可以用于处理Excel文件，其中包括xlsxwriter和openplxl两个库。本文将介绍这两个库的使用方法以及如何使用它们来操作Excel文件。

1、xlsxwriter生成Excel文件

xlsxwriter是一个用于生成Excel文件的Python库，支持多种格式的Excel文件(如.xlsx、.xlsm、.xltx、.xltm等),并且支持自定义样式和格式。下面将以一个简单的示例，来逐步介绍如何使用xlsxwriter库创建一个Excel文件并写入数据

1.1、导入库并创建Excel文件

Excel文件名为：xlsxwriter插入数据和折线图.xlsx

import xlsxwriter, random

wb = xlsxwriter.Workbook('xlsxwriter插入数据和折线图.xlsx')

1.2、创建一个sheet页

sheet标签页名字为：sheet1

worksheet1 = wb.add_worksheet('sheet1')

1.3、按行写入数据

这里以写入Excel的头部数据为例：

headings = ['日期','数据1','数据2']
worksheet1.write_row('A1',headings)

1.4、按列写入数据

有了头部数据后，该写入下面的实际数据了

# 创造数据
data = [
    ['2019-1','2019-2','2019-3','2019-4','2019-5','2019-6','2019-7','2019-8','2019-9','2019-10','2019-11','2019-12',],
    [random.randint(1,100) for i in range(12)],
    [random.randint(1,100) for i in range(12)],
] 
# 按列写入数据
worksheet1.write_column('A2',data[0])
worksheet1.write_column('B2',data[1])
worksheet1.write_column('C2',data[2])

1.5、新建图表对象

折线图表的定义：

chart_col = wb.add_chart({'type':'line'})

1.6、图表数据配置

这里的数据有两条，一个是数据1，一个是数据2，所以图表添加数据的代码如下：

chart_col.add_series(
    {
        'name':'=sheet1!$B$1',
        'categoies':'=sheet1!$A$2:$A$7',
        'values':   '=sheet1!$B$2:$B$7',
        'line': {'color': 'blue'},
    }
)
chart_col.add_series(
    {
        'name':'=sheet1!$C$1',
        'categories':'=sheet1!$A$2:$A$7',
        'values':   '=sheet1!$C$2:$C$7',
        'line': {'color': 'green'},
    }
)

有两条数据，所以添加了两次。

数据有四项，数据名、具体值对应的横坐标categories、具体值对应的纵坐标values、折线颜色，其中取值方式，直接是使用sheet的坐标形式，例如name是B1和B2，categories都是A2-A7，值分别是B2-B7和C2-C7。

1.7、完成图表

数据添加之后，在设置下坐标的相关信息，就是标题、x轴、y轴的名字，以及图表位置和大小，代码如下：

chart_col.set_title({'name':'虚假数据折线图'})
chart_col.set_x_axis({'name':"横坐标"})
chart_col.set_y_axis({'name':'纵坐标'})

worksheet1.insert_chart('D2',chart_col,{'x_offset':25,'y_offset':10})

wb.close()

图表的位置和大小，是根据左上角的起始表格和x和y的偏移计算的。

代码中是从D2做左上角起始，然后x和y分别便宜25和10个单位，得到了图片的最终大小。最后关闭wb。

2、openpyxl追加Excel数据

openplxl是一个用于读取现有的Excel文件的Python库，支持多种格式的Excel文件(如.xlsx、.xlsm、.xltx、.xltm等),并且支持读取单元格的数据。

2.1、打开文件

import openpyxl
filename = 'xlsxwriter插入数据和折线图.xlsx'
wb = openpyxl.load_workbook(filename)

2.2、拷贝sheet

sheet1 = wb['sheet1']
# 拷贝sheet1
sheet2 = wb.copy_worksheet(sheet1)
# 设置拷贝后的名称为sheet2
sheet2.title = "sheet2"

2.3、追加数据内容

在sheet2中，数据1和数据2追加一年的数据，代码如下：

# 读取最后一行
rows = sheet2.max_row
# 取出时间的字符串
prev_date_str = sheet2.cell(row=rows,column=1).value
# 时间字符串转时间对象
prev_date = datetime.datetime.strptime(prev_date_str, "%Y-%m")
for i in range(1,13):
    # 月份的计算，每次增加一个月，就得到了第二年的12个月
    tmp_date = prev_date + relativedelta(months=i)
    tmp_num1 = random.randint(1,100)
    tmp_num2 = random.randint(1,100)
    sheet2.append([tmp_date.strftime("%Y-%m"), tmp_num1, tmp_num2])

实现思路：

• 读取出最后一行
• 取出时间字符串，然后转换成时间对象
• 一年12个月，循环12次，每次增加一个月，数值可以随机的生成，用random即可
• 数据的追加，是按每行，所以将【时间， 数据1， 数据2】通过append直接追加到数据最后即可

2.4、使用openpyxl画图表

在sheet2中对全部数据画折线图

from openpyxl.chart import Series,LineChart, Reference
# 图表对象
chart = LineChart()
rows = sheet2.max_row

# 创建series对象
data1 = Reference(sheet2, min_col=2, min_row=1, max_col=2, max_row=rows) #涉及数据
title1 = sheet2.cell(row=1,column=2).value
seriesObj1 = Series(data1, title=title1)

# 创建series对象
data2 = Reference(sheet2, min_col=3, min_row=1, max_col=3, max_row=rows) #涉及数据
title2 = sheet2.cell(row=1,column=3).value
seriesObj2 = Series(data2, title=title2)

# 添加到chart中
chart.append(seriesObj1)
chart.append(seriesObj2)

# 将图表添加到 sheet中
sheet2.add_chart(chart, "E3")

# 保存Excel
wb.save('poenpyxl插入数据和折线图[copy xlsxwriter].xlsx')

导入所需的画图工具，图表初始化，然后生成数据对象：

• data1的生成，因为索引从1开始，所以标题是第一行第二列，数据是第二行第二列，一直到最后一行第二列
• data2的生成，因为索引从1开始，所以标题是第一行第三列，数据是第二行第三列，一直到第二行最后三列
• 将两个数据都放到图表内
• 然后图表的开始位置，设置成E3，数据在ABC，E是空的，3距离顶部有两格的位置

最后文件保存，大功告成。

3、总结

本文介绍了如何使用xlsxwriter和openplxl两个库来操作Excel文件。xlsxwriter库可以用于创建新的Excel文件并写入数据，而openplxl库则可以用于读取现有的Excel文件并读取单元格的数据。这些库都是Python中处理Excel文件的好工具，可以帮助我们更加高效地处理各种数据。

前言

如何使用Python操作Excel文件？看这篇博客就够了！

在工作中，我们经常需要处理和分析数据。而Excel作为一种广泛使用的数据分析工具，被很多人所熟知。但是，对于一些非技术背景的用户来说，如何操作Excel却可能有些困难。这时候，Python就成为了一种非常有用的工具。

本文将介绍如何使用Python对Excel文件进行读写操作。首先，我们将介绍Python中可以使用的第三方库xlrd、xlwt和xlutils,并通过示例来展示“如何使用xlwt库来将数据写入到Excel文件中”、“如何使用xlrd库来读取一个Excel文件的数据”和“如何使用三个库的配合来进行一边读取一边写入的操作”。

通过本文的介绍，你将会了解到：

• 如何获取单元格的值；
• 如何遍历整个工作表；
• 如何创建新的工作表和单元格，并将数据写入到单元格中；
• 如何使用save()方法保存Excel文件到磁盘上。

如果你想学习如何使用Python操作Excel文件，那么这篇文章就是为你准备的。希望它能帮助你更好地理解和应用这个工具。

1、写入Excel文件

首先来学习下，随机生成数据，写入一个Excel文件并保存，所使用到的库，是xlwt，安装命令pip install xlwt ，安装简单方便，无依赖，很快。

1.1、新建一个WorkBook对象

import xlwt
wb = xlwt.Workbook()

1.2、新建sheet

sheet = wb.add_sheet('第一个sheet')

1.3、写数据

head_data = ['姓名','地址','手机号','城市']
for head in head_data:
    sheet.write(0,head_data.index(head),head)

write函数写入，分别是x行 x列 数据，头部数据永远是第一行，所以第0行。数据的列，则是当前数据所在列表的索引，直接使用index函数即可。

1.4、创建虚假数据

有了头部数据，现在就开始写入内容了，分别是随机姓名 随机地址 随机号码 随机城市，数据的来源都是faker库，一个专门创建虚假数据用来测试的库，安装命令：pip install faker。

因为头部信息已经写好，所以接下来是从第1行开始写数据，每行四个数据，准备写99个用户数据，所以用循环，循环99次，代码如下：

import faker
fake = faker.Faker()
for i in range(1,100):
    sheet.write(i,0,fake.first_name() + ' ' + fake.last_name())
    sheet.write(i,1,fake.address())
    sheet.write(i,2,fake.phone_number())
    sheet.write(i,3,fake.city())

1.5、保存成xls文件

wb.save('虚假用户数据.xls')

然后找到文件，使用office或者wps打开这个xls文件：

2、读取Excel文件

写文件已经搞定，接下来就要学习下Excel的读操作，读取Excel的库是xlrd，对应read；xlrd的安装命令：pip install xlrd

2.1、打开Excel文件

import xlrd
wb = xlrd.open_workbook('虚假用户数据.xls')

2.2、读取Excel数据

# 获取文件中全部的sheet，返回结构是list。
sheets = wb.sheets()
# 通过索引顺序获取。
sheet = sheets[0]
# 直接通过索引顺序获取。
sheet = wb.sheet_by_index(0)
# 通过名称获取。
sheet = wb.sheet_by_name('第一个sheet')

2.3、打印数据

# 获取行数
rows = sheet.nrows
# 获取列数
cols = sheet.ncols
for row in range(rows):
    for col in range(cols):
        print(sheet.cell(row,col).value,end=' , ')
    print('\n')

打印效果（只截取部分）：

3、在现有的Excel文件中追加内容

需求：往“虚假用户数据.xls”里面，追加额外的50条用户数据，就是标题+数据，达到150条。

3.1、导入库

import xlrd
from xlutils.copy import copy

3.2、使用xlrd打开文件，然后xlutils赋值打开后的workbook

wb = xlrd.open_workbook('虚假用户数据.xls',formatting_info=True)
xwb = copy(wb)

3.3、有了workbook之后，就开始指定sheet，并获取这个sheet的总行数

sheet = xwb.get_sheet('第一个sheet')
rows = sheet.get_rows()

指定名称为“第一个sheet”的sheet，然后获取全部的行

3.4、有了具体的行数，然后保证原有数据不变动的情况下，从第101行写数据

import faker
fake = faker.Faker()
for i in range(len(rows),150):
    sheet.write(i,0,fake.first_name() + ' ' + fake.last_name())
    sheet.write(i,1,fake.address())
    sheet.write(i,2,fake.phone_number())
    sheet.write(i,3,fake.city())

range函数，从len(rows)开始，到150-1结束，共50条。 faker库是制造虚假数据的，这个在前面写数据有用过，循环写入了50条。

3.5、最后保存就可以了

xwb.save('虚假用户数据.xls')

使用xwb，也就是操作之后的workbook对象，直接保存原来的文件名就可以了。

4、总结

本文介绍了Python中常用的三个库：xlrd、xlwt和xlutils,分别用于读取Excel文件、写入Excel文件和处理Excel文件。这些库都有各自的优点和缺点，在实际使用时需要根据具体需求进行选择。

同时，本文还提供了一些示例代码来演示如何使用这些库。通过这些示例代码，读者可以更好地了解这些库的使用方法和操作步骤。

最后，提醒读者注意在使用这些库时要仔细阅读其文档和API,以避免出现不必要的错误。

5、参考资料

• W3Cschool微课（Python 自动化办公课程）
• Python官方文档–xlrd
• Python官方文档–xlwt
• Python官方文档–xlutils

看过了el-cascade官方说明后，发现并不适用于我，也可以说这个例子不是太适合想要直接复制粘贴的我，于是乎，我将其改写成了可以直接复制粘贴的例子，具体代码如下：

<template>
  <el-cascader
    :props="cascaderProps"
    v-model="dataid"
    clearable>
  </el-cascader>
</template>

<script>
export default {
  name: "cascader",
  data() {
    return {
      dataid: [],
      cascaderProps: {
        lazy: true,
        lazyLoad: this.lazyLoad
      },
    }
  },
  methods: {
    lazyLoad(node, resolve) {
      // 获取当前是第几层
      let level = node.level

      let nodes = []
      // 我这边是两层，因此可根据是否有数据来做判断条件
      // 可改为根据不同层级判断
      if (!node.data) {
        nodes = [
          {
            value: 'beijing',
            label: '北京',
            leaf: level >= 1
          },
          {
            value: 'shanghai',
            label: '上海',
            leaf: level >= 1
          },
        ]
      } else {
        if (node.value === "beijing") {
          nodes = [
            {
              value: 'chaoyang',
              label: '朝阳区',
              leaf: level >= 1
            },
            {
              value: 'haidian',
              label: '海淀区',
              leaf: level >= 1
            },
          ]
        } else {
          nodes = [
            {
              value: 'pudong',
              label: '浦东新区',
              leaf: level >= 1
            },
            {
              value: 'hongkou',
              label: '虹口区',
              leaf: level >= 1
            },
          ]
        }
      }
      // 通过调用resolve将子节点数据返回，通知组件数据加载完成
      resolve(nodes)
    }
  }
}
</script>

引言

在 Web 开发中，我们经常需要将数据作为 URL 参数进行传递。当我们需要传递复杂的数据结构时，如何在前端将其转换为字符串，并在后端正确地解析它呢？本文将介绍如何在前端将 JSON 数据进行 URL 编码，并在后端将其解析为相应的数据类型，同时提供 Java 语言的示例代码。

在前端使用 URL 参数传递 JSON 数据

有时候我们需要在前端将 JSON 数据传递给后端，例如通过 AJAX 请求或者页面跳转。URL 参数是一种常见的传递数据的方式，但是由于 URL 参数只支持字符串类型的数据，而 JSON 数据是一种复杂的数据类型，因此需要进行编码和解码操作。

在 JavaScript 中，我们可以使用 JSON.stringify() 方法将 JSON 对象转换为字符串，然后使用 encodeURIComponent() 方法对字符串进行 URL 编码。以下是一个将 JSON 数据作为 URL 参数发送 AJAX 请求的示例：

const data = { name: 'John', age: 30 };
const encodedData = encodeURIComponent(JSON.stringify(data));

fetch(`/api/user?data=${encodedData}`)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));

在上面的示例中，我们首先创建了一个包含两个属性的 JSON 对象 data，然后将其转换为字符串并进行 URL 编码。然后我们使用 fetch() 方法发送一个带有 data 参数的 GET 请求，并在响应中使用 json() 方法将响应体解析为 JSON 对象。

在后端解析 URL 参数

在后端中，我们需要解析从前端发送的包含 JSON 数据的 URL 参数。不同的后端语言和框架可能有不同的解析方式，这里以 Node.js 和 Java 为例，介绍如何解析 URL 参数。

在 Node.js 中解析 URL 参数

在 Node.js 中，我们可以使用内置的 url 模块来解析 URL 参数，使用 querystring 模块来解析查询字符串参数。以下是一个使用 Node.js 解析 URL 参数的示例：

const http = require('http');
const url = require('url');
const querystring = require('querystring');

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url);
  const parsedQuery = querystring.parse(parsedUrl.query);

  // 解析包含在 'data' 参数中的 JSON 字符串
  const rawData = parsedQuery.data;
  const myObject = JSON.parse(decodeURIComponent(rawData));

  // 执行其他操作...

  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World!');
});

server.listen(3000, () => {
  console.log('Server running on port 3000');
});

在上面的示例中，我们首先使用 url.parse() 方法将请求 URL 解析为 URL 对象，然后使用 querystring.parse() 方法将查询字符串参数解析为对象。然后，我们从 data 参数中获取包含 JSON 字符串的原始数据，使用 decodeURIComponent() 解码该字符串，并使用 JSON.parse() 将其解析为 JavaScript 对象。

在 Java 中解析 URL 参数

在 Java 中，我们可以使用 java.net.URLDecoder 类和 java.util.Map 接口来解析 URL 参数。以下是一个使用 Java 解析URL 参数的示例：

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;

public class Main {
  public static void main(String[] args) throws UnsupportedEncodingException {
    String urlString = "http://localhost:3000/?data=%7B%22name%22%3A%22John%22%2C%22age%22%3A30%7D";
    String[] urlParts = urlString.split("\\?");
    String query = urlParts.length > 1 ? urlParts[1] : "";
    Map<String, String> queryMap = new HashMap<>();
    for (String param : query.split("&")) {
      String[] pair = param.split("=");
      String key = URLDecoder.decode(pair[0], "UTF-8");
      String value = URLDecoder.decode(pair[1], "UTF-8");
      queryMap.put(key, value);
    }

    // 解析包含在 'data' 参数中的 JSON 字符串
    String rawData = queryMap.get("data");
    String json = URLDecoder.decode(rawData, "UTF-8");
    JSONObject myObject = new JSONObject(json);

    // 执行其他操作...
  }
}

在上面的示例中，我们首先将请求 URL 分为基础部分和查询字符串部分，然后将查询字符串参数解析为一个键值对的 Map 对象。然后，我们从 data 参数中获取包含 URL 编码的 JSON 字符串的原始数据，使用 URLDecoder.decode() 解码该字符串，并使用 JSONObject 类将其解析为 Java 对象。

总结

在前端使用 URL 参数传递 JSON 数据时，需要先将 JSON 数据转换为字符串并进行 URL 编码。在后端中解析 URL 参数时，需要先将 URL 编码的字符串解码为原始数据，并将其解析为相应的数据类型。不同的后端语言和框架可能有不同的解析方式，但是基本的原理都是相同的。

前言

WebLogic、Undertow、Tomcat和Nginx是常用的Web服务器和应用程序服务器。它们具有不同的功能、应用场景、优缺点等方面的特点，本文将对它们进行详细的比较。

功能比较

WebLogic是一个完整的JavaEE应用程序服务器，它具有强大的功能和灵活的配置。WebLogic支持分布式应用程序部署、负载均衡、高可用性、安全性等特性，适用于大型企业级Java应用程序。

Undertow是一个轻量级的Web服务器和应用程序服务器，它具有高性能和可扩展性的特点。Undertow支持HTTP、HTTPS、AJAX、WebSockets等协议，适用于构建高性能、低延迟的Web应用程序。

Tomcat是一个轻量级的Web服务器和应用程序服务器，它具有简单易用的特点。Tomcat支持Servlet、JSP等Java Web开发技术，适用于中小型Web应用程序。

Nginx是一个高性能的Web服务器和反向代理服务器，它具有高并发能力、低延迟和高可靠性的特点。Nginx支持负载均衡、反向代理、HTTP缓存等特性，适用于构建高性能、高并发、低延迟的Web应用程序。

应用场景比较

WebLogic适用于大型企业级Java应用程序，例如电子商务、金融服务、电信等行业的应用程序。WebLogic具有出色的可扩展性、高可靠性和安全性，适用于对性能、可靠性和安全性有严格要求的应用程序。

Undertow适用于构建高性能、低延迟的Web应用程序，例如在线游戏、金融交易等需要快速响应的应用程序。Undertow具有轻量级、高性能和可扩展性的特点，适用于对性能有严格要求的应用程序。

Tomcat适用于中小型Web应用程序，例如博客、社交网络、企业内部应用程序等。Tomcat具有轻量级、易于使用和配置的特点，适用于对性能要求不是特别高的应用程序。

Nginx适用于构建高性能、高并发、低延迟的Web应用程序，例如电子商务、社交网络等需要支持大量并发用户访问的应用程序。Nginx具有高性能、高可靠性和可扩展性的特点，适用于对性能和可靠性有严格要求的应用程序。

优缺点比较

WebLogic的优点是具有出色的可扩展性、高可靠性和安全性。它支持JavaEE规范，可以满足大型企业级应用程序的需求。缺点是相对于其他服务器而言比较复杂，需要一定的学习成本和配置成本，同时也需要更多的硬件资源支持。

Undertow的优点是轻量级、高性能和可扩展性。它支持多种协议，适用于构建高性能、低延迟的Web应用程序。缺点是不支持JavaEE规范，无法满足大型企业级应用程序的需求，同时也缺乏成熟的生态系统和工具支持。

Tomcat的优点是轻量级、易于使用和配置。它支持Servlet、JSP等Java Web开发技术，适用于中小型Web应用程序。缺点是相对于其他服务器而言功能较为简单，不能满足大型企业级应用程序的需求。

Nginx的优点是高性能、高可靠性和可扩展性。它支持负载均衡、反向代理、HTTP缓存等特性，适用于构建高性能、高并发、低延迟的Web应用程序。缺点是不支持JavaEE规范，不能直接运行Java应用程序，需要结合其他服务器使用。

支持的平台

• WebLogic：支持Windows、Linux、Solaris等平台。
• Undertow：支持Windows、Linux、Mac OS X等平台。
• Tomcat：支持Windows、Linux、Mac OS X等平台。
• Nginx：支持Windows、Linux、Unix等平台。

支持的编程语言

• WebLogic：支持Java。
• Undertow：支持Java。
• Tomcat：支持Java。
• Nginx：支持C、C++、Perl、Python等编程语言。

管理和监控

• WebLogic：具有完整的Web控制台和管理API，可以轻松管理和监控Web应用程序。
• Undertow：提供JMX API和可配置的管理端点，但没有Web控制台。
• Tomcat：提供管理和监控工具，例如Web控制台、管理界面和JMX API。
• Nginx：提供基本的管理和监控工具，例如ngx_http_status_module和ngx_http_stub_status_module模块。

性能

• WebLogic：具有较高的性能，但相对较慢，适用于大型企业级应用程序。
• Undertow：具有极高的性能和低延迟，适用于高性能Web应用程序。
• Tomcat：具有较高的性能和低延迟，适用于中小型Web应用程序。
• Nginx：具有极高的性能、低延迟和高并发能力，适用于大型Web应用程序。

总结

WebLogic、Undertow、Tomcat和Nginx都是常用的Web服务器和应用程序服务器。它们具有不同的功能、应用场景、优缺点等方面的特点，选择合适的服务器需要根据具体的需求来决定。

如果需要构建大型企业级Java应用程序，可以选择WebLogic；如果需要构建高性能、低延迟的Web应用程序，可以选择Undertow；如果需要构建中小型Web应用程序，可以选择Tomcat；如果需要构建高性能、高并发、低延迟的Web应用程序，可以选择Nginx。

总之，选择合适的服务器可以提高应用程序的性能、可靠性和安全性，为用户提供更好的体验。

前言

作为一名Linux管理员，保护服务器免受网络攻击是最重要的任务之一。Linux操作系统提供了许多防火墙工具，其中最常用的是iptables和Firewall。本文将比较Firewall和iptables之间的不同之处，并探讨哪个防火墙工具更适合您的需求。

Firewall和iptables是什么？

iptables是一个Linux防火墙工具，它通过对网络数据包进行过滤和修改来控制网络访问。Firewall是新一代的Linux动态防火墙，它基于D-Bus消息系统，采用了Zone和Service的概念来管理网络访问。

iptables使用命令

• 查看当前的iptables规则：iptables -L
• 清除当前的iptables规则：iptables -F
• 允许指定端口的流量通过：iptables -A INPUT -p tcp --dport [端口号] -j ACCEPT
• 阻止指定端口的流量通过：iptables -A INPUT -p tcp --dport [端口号] -j DROP
• 允许某个IP地址的流量通过：iptables -A INPUT -s [IP地址] -j ACCEPT
• 阻止某个IP地址的流量通过：iptables -A INPUT -s [IP地址] -j DROP

Firewall使用命令

• 查看Firewall状态：firewall-cmd --state
• 查看当前的Firewall规则：firewall-cmd --list-all
• 允许指定端口的流量通过：firewall-cmd --zone=public --add-port=[端口号]/tcp --permanent
• 阻止指定端口的流量通过：firewall-cmd --zone=public --remove-port=[端口号]/tcp --permanent
• 允许某个IP地址的流量通过：firewall-cmd --zone=public --add-source=[IP地址] --permanent
• 阻止某个IP地址的流量通过：firewall-cmd --zone=public --remove-source=[IP地址] --permanent

比较iptables和Firewall

语法和规则

iptables使用基于命令行的语法，可以直接使用iptables命令来添加、修改和删除防火墙规则。而Firewall使用XML或JSON格式的配置文件，可以使用firewall-cmd命令行工具或图形界面进行管理。

实现方式

iptables是传统的Linux防火墙工具，而Firewall是新一代的动态防火墙。Firewall允许在运行时添加和删除规则，而不需要重启防火墙服务。

管理和配置

iptables可以通过编辑配置文件来管理和配置规则，也可以通过调用命令行工具来实现。而Firewall是一种动态防火墙，它允许在运行时添加和删除规则，而不需要重启防火墙服务。

性能和效率

iptables具有更高的性能和效率，可以处理更高的网络流量和更复杂的防火墙规则。而Firewall虽然具有动态性和易用性等优点，但其性能和效率不如iptables。

iptables和Firewall的生效规则

对于iptables，当您添加或删除规则时，这些规则会立即生效，并在运行iptables -L命令时显示出来。但是，这些规则不会在系统重启后自动生效。为了保证规则在系统重启后仍然生效，您需要将这些规则保存到文件中，并确保在启动时加载该文件。您可以使用以下命令将当前iptables规则保存到文件中：

iptables-save > /etc/sysconfig/iptables

在系统重启后，可以使用以下命令加载保存的规则：

iptables-restore < /etc/sysconfig/iptables

对于Firewall，添加或删除规则时，这些规则不会立即生效，您需要运行以下命令使其生效：

firewall-cmd --reload

此命令会重新加载Firewall的规则，并应用任何更改。但是，请注意，如果您没有使用–permanent选项将规则永久保存，则在系统重启后，这些规则将被清除。为了确保规则在系统重启后仍然生效，您需要使用以下命令将规则永久保存：

firewall-cmd --zone=public --add-port=8080/tcp --permanent

此命令将添加一个允许端口8080的永久规则。在系统重启后，此规则将自动加载。

综上所述，无论您使用iptables或Firewall哪一个修改防火墙规则时，请注意保存规则，并确保它们在系统重启后仍然生效。

哪个防火墙工具更适合您的需求？

如果您需要处理高流量和复杂规则的环境，则使用iptables是一个很好的选择。iptables具有更高的性能和效率，并且可以处理更复杂的防火墙规则。

如果您需要简单、易用和动态防火墙，则Firewall是一个很好的选择。Firewall具有动态性和易用性等优点，并允许在运行时添加和删除规则，而不需要重启防火墙服务。

结论

防火墙是保护服务器安全的关键。iptables和Firewall是Linux操作系统上最常用的防火墙工具，它们之间有许多不同之处。选择哪种防火墙工具取决于您的具体需求和偏好。无论您选择使用哪种工具，

引言

Nacos是一个开源的分布式配置中心和服务发现平台，它可以帮助开发者轻松管理微服务架构中的配置和服务注册。在Nacos的不断发展中，1.0版本和2.0版本都是非常重要的版本，本篇博客将对这两个版本进行介绍和比较。

一、Nacos 1.0版本

Nacos 1.0版本于2019年3月发布，它是Nacos的第一个正式版本，也是经过多次测试和优化后的稳定版本。相较于之前的beta版本，Nacos 1.0版本有了很大的改进和优化，主要包括以下几个方面：

1. 功能完善

Nacos 1.0版本在功能上相对完善，包括了配置中心、服务注册与发现、命名空间、健康检查等核心功能。此外，Nacos 1.0版本还增加了可插拔的扩展能力，可以方便地扩展各种插件，例如自定义的服务发现协议。

2. 性能提升

Nacos 1.0版本在性能上也有很大的提升，通过优化网络通信协议和数据存储方式，大大提高了系统的并发处理能力和吞吐量，可以满足更高的性能需求。

3. 稳定性改进

Nacos 1.0版本在稳定性方面也进行了不少改进，通过增加监控和自动修复机制，可以更快地检测和修复系统故障，从而提高了系统的稳定性和可靠性。

二、Nacos 2.0版本

Nacos 2.0版本于2020年9月发布，相对于1.0版本，它的改进和优化更加突出，主要体现在以下几个方面：

1. 分布式一致性

Nacos 2.0版本引入了Raft算法，实现了分布式一致性，从而保证了集群环境下数据的强一致性和高可用性。

2. 更多的功能支持

Nacos 2.0版本增加了更多的功能支持，例如DNS解析、动态配置刷新、访问控制等，为用户提供了更加全面的服务治理和配置管理能力。

3. 更高的性能和扩展性

Nacos 2.0版本在性能和扩展性方面也有很大的提升，采用异步I/O、内存池等技术，大大提高了系统的处理能力和吞吐量。此外，Nacos 2.0版本还提供了更加灵活的插件机制，方便用户进行个性化定制和扩展。

总结

Nacos 1.0版本和2.0版本都是非常重要的版本，它们分别在不同的方面进行了优化和改进，为用户提供了更加全面和稳定的服务治理和配置管理能力。如果您是初次接触Nacos，建议选择最新版本2.0，以便获得更好的性能和更多的功能支持。但如果您的应用已经在Nacos 1.0版本上运行良好，也可以继续使用该版本，因为它已经经过多次测试和优化，具有很高的稳定性和可靠性。不管选择哪个版本，都需要根据实际业务场景和需求来进行选择和配置，以获得最佳的服务治理和配置管理效果。

在当今的大数据时代，关系型数据库仍然是最常用的数据存储方式之一。Java是一种广泛使用的编程语言，也是访问关系型数据库的主要语言之一。在Java应用程序中，通常使用JDBC（Java Database Connectivity）API来访问数据库。但是，JDBC使用的同步/阻塞模型在处理高并发和大数据量的情况下可能会成为瓶颈，因此R2DBC（Reactive Relational Database Connectivity）在此时显得更加合适。

R2DBC是Java应用程序访问关系型数据库的一种新方式，它采用了响应式编程的思想，提供了异步、非阻塞的API，能够提高Java应用程序在高并发场景下的性能和可伸缩性。

在本文中，我们将介绍R2DBC的基本概念和原理，并提供一些使用R2DBC的示例。

R2DBC的基本概念和原理

R2DBC（Reactive Relational Database Connectivity）是一种基于异步、响应式编程模型的标准化关系型数据库连接API。R2DBC允许您使用响应式编程模型访问关系型数据库，这种编程模型通常用于处理大量并发请求、高吞吐量和低延迟场景。

R2DBC的主要设计目标是提供一种简单的异步、响应式编程模型，以及一种统一的方式来连接不同类型的关系型数据库。与传统的JDBC API不同，R2DBC使用反应流作为响应式编程模型的基础，提供一组异步操作符，以便您可以使用流式编程模型来执行数据库操作。

目前，R2DBC支持多种关系型数据库，包括MySQL、PostgreSQL、Microsoft SQL Server和H2数据库。在使用R2DBC时，您需要为您的数据库选择适当的R2DBC驱动程序，并按照驱动程序的要求进行配置。

R2DBC提供了以下主要特性

• 异步执行：R2DBC使用异步编程模型，可以处理大量并发请求，提供高吞吐量和低延迟。

• 响应式编程模型：R2DBC基于反应流（Reactive Streams）标准，提供了一组异步操作符，可以使用流式编程模型来执行数据库操作。

• 标准化API：R2DBC提供了一种标准化的关系型数据库连接API，可以使用相同的API连接不同类型的关系型数据库。

• 轻量级：R2DBC是一个轻量级的API，它没有复杂的ORM框架或其他繁重的依赖。

• 无阻塞式I/O：R2DBC使用无阻塞式I/O操作，可以处理大量并发请求，并提供高吞吐量和低延迟。

使用R2DBC的示例

使用R2DBC来连接MySQL数据库，您需要执行以下步骤：

步骤1：添加依赖项

要在Java应用程序中使用R2DBC来访问MySQL数据库，首先需要将R2DBC MySQL依赖项添加到项目中。我们可以通过以下Maven依赖项将R2DBC MySQL引入我们的项目中：

<dependency>
    <groupId>dev.miku</groupId>
    <artifactId>r2dbc-mysql</artifactId>
    <version>0.8.8.RELEASE</version>
</dependency>

步骤2：配置数据库连接

在使用R2DBC访问MySQL数据库之前，我们需要先配置数据库连接。下面是一个示例配置：

@Configuration
public class R2dbcConfiguration {

    @Bean
    public ConnectionFactory connectionFactory() {
        return new MysqlConnectionFactory(
            ConnectionFactoryOptions.builder()
                .option(DRIVER, "mysql")
                .option(HOST, "localhost")
                .option(USER, "username")
                .option(PASSWORD, "password")
                .option(DATABASE, "database")
                .build()
        );
    }
}

在上面的示例中，我们使用MysqlConnectionFactory类创建MySQL连接工厂。同时，我们使用ConnectionFactoryOptions类配置了连接选项，包括数据库驱动程序、主机、用户名、密码和数据库名称等。

步骤3：使用连接工厂创建连接

一旦我们已经配置好了数据库连接，我们可以使用连接工厂创建一个新的数据库连接。以下是一个示例：

public class UserRepository {

    private final ConnectionFactory connectionFactory;

    public UserRepository(ConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }

    public Flux<User> findAll() {
        return Mono.from(connectionFactory.create())
            .flatMapMany(connection ->
                Flux.from(connection.createStatement("SELECT * FROM users").execute())
                    .flatMap(result -> result.map((row, rowMetadata) ->
                        new User(row.get("id", Long.class), row.get("name", String.class))
                    ))
                    .doFinally((signalType) -> Mono.from(connection.close()).subscribe())
            );
    }
}

在上面的示例中，我们创建了一个UserRepository类，并使用MysqlConnectionFactory类创建MySQL连接工厂。我们使用Mono.from(connectionFactory.create())方法创建一个新的数据库连接。接下来，我们使用Flux.from(connection.createStatement("SELECT * FROM users").execute())方法创建一个Flux，该Flux将使用SQL查询语句从数据库中检索所有用户记录。我们使用flatMap()方法将结果转换为我们的User对象，并将其作为Flux对象返回。最后，我们使用doFinally()方法关闭数据库连接。

步骤4：使用R2DBC在Java应用程序中访问MySQL数据库

我们现在已经配置了数据库连接，并创建了一个用于访问数据库的UserRepository类。我们可以在Java应用程序中使用此类来访问MySQL数据库。以下是一个示例：

public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(R2dbcConfiguration.class);
        UserRepository userRepository = context.getBean(UserRepository.class);

        userRepository.findAll()
            .subscribe(user -> System.out.println("User: " + user));
    }
}

在上面的示例中，我们创建了一个Application类，并在其中创建了一个UserRepository实例。我们调用userRepository.findAll()方法来检索所有用户记录，并在控制台上打印每个用户的名称。最后，我们使用subscribe()方法订阅Flux对象。

总结

R2DBC是一种基于响应式编程的数据库访问API，它可以提高Java应用程序在高并发场景下的性能和可伸缩性。使用R2DBC可以让程序员使用异步、非阻塞的API访问关系型数据库，从而充分发挥计算机的CPU和内存资源。

在使用R2DBC时，需要遵循基本步骤，包括添加R2DBC依赖项、配置数据库连接、使用连接工厂创建连接，以及执行查询或更新等操作。通过这些步骤，程序员可以编写高效、可伸缩的Java应用程序，从而更好地应对大规模数据处理和高并发访问的场景。

总的来说，R2DBC是Java应用程序中非常有用的工具，可以帮助开发者提高程序的性能和可伸缩性。

今天，我学习nacos的源码，看到了distro协议，于是本篇博客就由此而来了，通过网上查找的资料我大体整理了下，下面是整理后的结果。

引言

分布式系统是由多个计算机节点组成的系统，这些节点通过网络相互连接，并协同工作来实现一个共同的目标。在分布式系统中，数据的一致性是一个非常重要的问题。分布式一致性算法可以帮助我们解决这个问题。本文将介绍三种分布式一致性算法：distro协议、sofajraft协议、raft协议，并讨论它们的适用场景和特点。

Raft协议

Raft是一种分布式一致性算法，由Stanford大学的Diego Ongaro和John Ousterhout于2013年提出。Raft算法的主要目标是提供一种易于理解和实现的分布式一致性算法。Raft算法具有良好的可读性和易于理解的特点，使得它容易被人们理解和实现。Raft算法通过领导选举、日志复制、一致性检查点等基础功能，保证了分布式系统中数据的一致性。

SofaJRaft协议

SofaJRaft是一种基于Raft协议的改进版本。SofaJRaft在Raft协议的基础上增加了一些特性，例如动态配置、快照等，以适应更加复杂的场景需求。SofaJRaft算法的设计目标是提供一个高性能、高可用、易于扩展的分布式一致性算法。SofaJRaft算法在性能和可扩展性方面优于Raft协议，适用于更为复杂的分布式系统，例如分布式存储、分布式数据库等。

Distro协议

Distro协议是基于SofaJRaft协议的一种改进版本。Distro协议在SofaJRaft协议的基础上进一步优化，例如增加了故障转移功能，提高了容错性能。Distro协议的设计目标是提供一个高可靠、高性能、易于扩展的分布式一致性算法。Distro协议适用于更加严苛的分布式系统环境，例如金融、电信等领域的应用。

三种协议比较

Raft协议、SofaJRaft协议和Distro协议都是分布式一致性算法，它们之间有以下的不同和优势：

1. Raft协议的可读性和易于理解性更好，适用于一些小规模的分布式系统。

2. SofaJRaft协议增加了一些特性，例如动态配置、快照等，适用于更为复杂的分布式系统，例如分布式存储、分布式数据库等。

3. Distro协议在SofaJRaft协议的基础上增加了故障转移功能，提高了容错性能，适用于更加严苛的分布式系统环境，例如金融、电信等领域的应用。

共性

1. 都使用领导者选举机制，通过选举一个领导者来管理整个系统。

2. 都使用日志复制机制，通过复制日志来实现数据的一致性。

3. 都可以实现线性一致性。

4. 都可以扩展到多个节点。

总之，选择合适的分布式一致性算法需要综合考虑系统规模、复杂度、容错性要求等因素。同时，需要注意算法的实现、性能、可维护性等方面的问题。

本篇文章是Python Flask 建站框架入门课程_编程实战微课_w3cschool微课的学习笔记，根据课程整理而来，本人使用版本如下：

简介

• Flask是一个轻量级的可定制的web框架

• Flask 可以很好地结合MVC模式进行开发

• Flask还有很强的很强的扩展性和兼容性

核心函数库

Flask主要包括Werkzeug和Jinja2两个核心函数库，它们分别负责业务处理和安全方面的功能，这些基础函数为web项目开发过程提供了丰富的基础组件。

Werkzeug

Werkzeug库十分强大，功能比较完善，支持URL路由请求集成，一次可以响应多个用户的访问请求；

支持Cookie和会话管理，通过身份缓存数据建立长久连接关系，并提高用户访问速度；支持交互式Javascript调试，提高用户体验；

可以处理HTTP基本事务，快速响应客户端推送过来的访问请求。

Jinja2

Jinja2库支持自动HTML转移功能，能够很好控制外部黑客的脚本攻击；

系统运行速度很快，页面加载过程会将源码进行编译形成python字节码，从而实现模板的高效运行；

模板继承机制可以对模板内容进行修改和维护，为不同需求的用户提供相应的模板。

安装

通过pip安装即可

pip install Flask
# pip3
pip3 install Flask

目录结构

新项目创建后的结构

static文件夹：存放静态文件，比如css、js、图片等

templates文件夹：模板文件目录

app.py：应用启动程序

获取URL参数

列出所有URL参数

request.args.__str__()

from flask import Flask, request

app = Flask(__name__)


@app.route('/')
def hello_world():  # put application's code here
    return request.args.__str__()


if __name__ == '__main__':
    app.run()

在浏览器中访问http://127.0.0.1:5000/?name=Loen&age&app=ios&app=android，将显示：

ImmutableMultiDict([('name', 'Loen'), ('age', ''), ('app', 'ios'), ('app', 'android')])

列出浏览器传给我们的Flask服务的数据

from flask import Flask, request

app = Flask(__name__)


@app.route('/')
def hello_world():  # put application's code here

    # 列出访问地址
    print(request.path)

    # 列出访问地址及参数
    print(request.full_path)

    return request.args.__str__()


if __name__ == '__main__':
    app.run()

在浏览器中访问http://127.0.0.1:5000/?name=Loen&age&app=ios&app=android，控制台中显示

/
/?name=Loen&age&app=ios&app=android

获取指定的参数值

from flask import Flask, request

app = Flask(__name__)


@app.route('/')
def hello_world():  # put application's code here

    return request.args.get('name')


if __name__ == '__main__':
    app.run()

在浏览器中访问http://127.0.0.1:5000/?name=Loen&age&app=ios&app=android，将显示：

Loen

处理多值

from flask import Flask, request

app = Flask(__name__)


@app.route('/')
def hello_world():  # put application's code here
    r = request.args.getlist('app')  # 返回一个list
    return r


if __name__ == '__main__':
    app.run()

在浏览器中访问http://127.0.0.1:5000/?name=Loen&age&app=ios&app=android，将显示：

[
  "ios",
  "android"
]

获取POST方法传送的数据

作为一种HTTP请求方法，POST用于向指定的资源提交要被处理的数据。

我们在某些时候不适合将数据放到URL参数中，密或者数据太多，浏览器不一定支持太长长度的URL。这时，一般使用POST方法。

本文章使用python的requests库模拟浏览器。

安装命令：

pip install requests

看POST数据内容

app.py代码如下：

from flask import Flask, request

app = Flask(__name__)


@app.route('/register', methods=['POST'])
def register():
    print(request.headers)
    print(request.stream.read())
    return 'welcome'


if __name__ == '__main__':
    app.run()

register.py代码如下：

import requests

if __name__ == '__main__':
    user_info = {'name': 'Loen', 'password': 'loveyou'}
    r = requests.post("http://127.0.0.1:5000/register", data=user_info)
    print(r.text)

运行app.py，然后运行register.py。

register.py将输出：

welcome

app.py将输出：

Host: 127.0.0.1:5000
User-Agent: python-requests/2.28.2
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 26
Content-Type: application/x-www-form-urlencoded


b'name=Loen&password=loveyou'
127.0.0.1 - - [14/Feb/2023 21:12:17] "POST /register HTTP/1.1" 200 -

解析POST数据

app.py代码如下：

from flask import Flask, request

app = Flask(__name__)


@app.route('/register', methods=['POST'])
def register():
    # print(request.stream.read()) # 不要用，否则下面的form取不到数据
    print(request.form)
    print(request.form['name'])
    print(request.form.get('name'))
    print(request.form.getlist('name'))
    print(request.form.get('nickname', default='little apple'))
    return 'welcome'


if __name__ == '__main__':
    app.run(port=5000, debug=True)

register.py代码不变，运行app.py，然后运行register.py。

register.py将输出：

welcome

app.py将输出：

ImmutableMultiDict([('name', 'Loen'), ('password', 'loveyou')])
Loen
Loen
['Loen']
little apple

request.form会自动解析数据。

request.form[‘name’]和request.form.get(‘name’)都可以获取name对应的值。

request.form.get()可以为参数default指定值以作为默认值。

获取POST中的列表数据

app.py代码如下：

from flask import Flask, request

app = Flask(__name__)


@app.route('/register', methods=['POST'])
def register():
    # print(request.stream.read()) # 不要用，否则下面的form取不到数据
    print(request.form.getlist('name'))
    return 'welcome'


if __name__ == '__main__':
    app.run(port=5000, debug=True)

register.py代码如下：

import requests

if __name__ == '__main__':
    user_info = {'name': ['Loen', 'Alan'], 'password': 'loveyou'}
    r = requests.post("http://127.0.0.1:5000/register", data=user_info)
    print(r.text)

运行app.py，然后运行register.py。

register.py将输出：

welcome

app.py将输出：

['Loen', 'Alan']

处理和响应JSON数据

处理JSON数据

如果POST的数据是JSON格式，request.json会自动将json数据转换成Python类型（字典或者列表）。

app.py代码如下：

from flask import Flask, request

app = Flask(__name__)


@app.route('/add', methods=['POST'])
def add():
    print(type(request.json))
    print(request.json)
    result = request.json['n1'] + request.json['n2']
    return str(result)


if __name__ == '__main__':
    app.run(port=5000, debug=True)

register.py代码如下：

import requests

if __name__ == '__main__':
    json_data = {'n1': 5, 'n2': 3}
    r = requests.post("http://127.0.0.1:5000/add", json=json_data)
    print(r.text)

运行app.py，然后运行register.py。

register.py将输出：

8

app.py将输出：

<class 'dict'>
{'n1': 5, 'n2': 3}

响应JSON数据（Response）

app.py代码如下：

import json

from flask import Flask, request, Response

app = Flask(__name__)


@app.route('/add', methods=['POST'])
def add():
    result = {'sum': request.json['n1'] + request.json['n2']}
    return Response(json.dumps(result), mimetype='application/json')


if __name__ == '__main__':
    app.run(port=5000, debug=True)

register.py代码如下：

import requests

if __name__ == '__main__':
    json_data = {'n1': 5, 'n2': 3}
    r = requests.post("http://127.0.0.1:5000/add", json=json_data)
    print(r.headers)
    print(r.text)

运行app.py，然后运行register.py。

register.py将输出：

/home/huangge1199/PycharmProjects/flaskProject/venv/bin/python /home/huangge1199/PycharmProjects/flaskProject/register.py 
{'Server': 'Werkzeug/2.2.2 Python/3.7.3', 'Date': 'Tue, 14 Feb 2023 13:37:49 GMT', 'Content-Type': 'application/json', 'Content-Length': '10', 'Connection': 'close'}
{"sum": 8}

响应JSON数据（jsonify）

app.py中app()返回时使用下面的内容，效果同之前一样

return jsonify(result)

上传表单

用 Flask 处理文件上传很简单，只要确保你没忘记在 HTML 表单中设置 enctype=“multipart/form-data” 属性，不然你的浏览器根本不会发送文件。

安装响应的库werkzeug

pip install werkzeug

目录结构：

app.py代码如下：

from flask import Flask, request
from werkzeug.utils import secure_filename
import os

app = Flask(__name__)

# 文件上传目录
app.config['UPLOAD_FOLDER'] = 'static/uploads/'
# 支持的文件格式
app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'}  # 集合类型


# 判断文件名是否是我们支持的格式
def allowed_file(filename):
    return '.' in filename and \
        filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']


@app.route('/upload', methods=['POST'])
def upload():
    upload_file = request.files['image']
    if upload_file and allowed_file(upload_file.filename):  # 上传前文件在客户端的文件名
        filename = secure_filename(upload_file.filename)
        # 将文件保存到 static/uploads 目录，文件名同上传时使用的文件名
        upload_file.save(os.path.join(app.root_path, app.config['UPLOAD_FOLDER'], filename))
        return 'info is ' + request.form.get('info', '') + '. success'
    else:
        return 'failed'


if __name__ == '__main__':
    app.run()

register.py代码如下：

import requests

if __name__ == "__main__":
    file_data = {'image': open('flask.png', 'rb')}
    user_info = {'info': 'flask'}
    r = requests.post("http://127.0.0.1:5000/upload", data=user_info, files=file_data)
    print(r.text)

运行app.py，然后运行register.py，这时候文件已经上传到了指定目录中

要控制上产文件的大小，可以设置请求实体的大小，代码如下：

app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 #16MB

获取上传文件的内容，代码如下：

file_content = request.files['image'].stream.read()

Restful URL

Restful URL可以看做是对 URL 参数的替代

变量规则

写法如下：

@app.route('/user/<username>/friends')

转换类型

使用 Restful URL 得到的变量默认为str对象。我们可以用flask内置的转换机制，即在route中指定转换类型，写法如下：

@app.route('/page/<int:num>')

有3个默认的转换器：

• int：接受整数

• float：同 int ，但是接受浮点数

• path：和默认的相似，但也接受斜线

自定义转换器

自定义的转换器是一个继承werkzeug.routing.BaseConverter的类，修改to_python和to_url方法即可。

to_python方法用于将url中的变量转换后供被@app.route包装的函数使用，to_url方法用于flask.url_for中的参数转换。

下面是一个示例：

from flask import Flask, url_for
from werkzeug.routing import BaseConverter


class MyIntConverter(BaseConverter):

    def __init__(self, url_map):
        super(MyIntConverter, self).__init__(url_map)

    def to_python(self, value):
        return int(value)

    def to_url(self, value):
        return value * 2


app = Flask(__name__)
app.url_map.converters['my_int'] = MyIntConverter


@app.route('/page/<my_int:num>')
def page(num):
    print(num)
    print(url_for('page', num='145'))  # page 对应的是 page函数 ，num 对应对应`/page/<my_int:num>`中的num，必须是str
    return 'hello world'


if __name__ == '__main__':
    app.run()

运行app.py，浏览器访问http://127.0.0.1:5000/page/28后，app.py的输出信息是：

28
/page/145145

使用url_for生成链接

工具函数url_for可以让你以软编码的形式生成url，提供开发效率。

例子app.py代码如下：

from flask import Flask, url_for

app = Flask(__name__)


@app.route('/')
def hello_world():
    pass


@app.route('/user/<name>')
def user(name):
    pass


@app.route('/page/<int:num>')
def page(num):
    pass


@app.route('/test')
def test():
    print(url_for('test'))
    print(url_for('user', name='loen'))
    print(url_for('page', num=1, q='welcome to w3c 15%2'))
    print(url_for('static', filename='uploads/flask.png'))
    return 'Hello'


if __name__ == '__main__':
    app.run()

运行app.py。然后在浏览器中访问http://127.0.0.1:5000/test，server.py控制台将输出以下信息：

/test
/user/loen
/page/1?q=welcome+to+w3c+15%252
/static/uploads/flask.jpg

使用redirect重定向网址

在浏览器中访问http://127.0.0.1:5000/old，浏览器的url会变成http://127.0.0.1:5000/new，并显示，app.py代码如下：

from flask import Flask, url_for, redirect

app = Flask(__name__)


@app.route('/old')
def old():
    print('this is old')
    return redirect(url_for('new'))


@app.route('/new')
def new():
    print('this is new')
    return 'this is new'


if __name__ == '__main__':
    app.run()

运行app.py，然后在浏览器中访问http://127.0.0.1:5000/old

浏览器显示：

this is new

控制台显示：

this is old
this is new

自定义404

处理HTTP错误

要处理HTTP错误，可以使用flask.abort函数。

app.py代码如下：

from flask import Flask, abort

app = Flask(__name__)


@app.route('/user')
def user():
    abort(401)  # Unauthorized 未授权
    print('Unauthorized, 请先登录')


if __name__ == '__main__':
    app.run()

运行app.py，然后在浏览器中访问http://127.0.0.1:5000/user

浏览器显示：

自定义错误页面

page_unauthorized 函数返回的是一个元组，401 代表HTTP 响应状态码。

如果省略401，则响应状态码会变成默认的 200。

app.py代码如下：

from flask import Flask, abort, render_template_string

app = Flask(__name__)


@app.route('/user')
def user():
    abort(401)  # Unauthorized


@app.errorhandler(401)
def page_unauthorized(error):
    return render_template_string('<h1> Unauthorized </h1><h2>{{ error_info }}</h2>', error_info=error), 401


if __name__ == '__main__':
    app.run()

运行app.py，然后在浏览器中访问http://127.0.0.1:5000/user

浏览器显示：

用户会话

session 用来记录用户的登录状态，一般基于cookie实现。

app.py代码如下：

from flask import Flask, render_template_string, request, session, redirect, url_for

app = Flask(__name__)

app.secret_key = 'LoenDSdtj\9bX#%@!!*(0&^%)'


@app.route('/login')
def login():
    page = '''
    <form action="{{ url_for('do_login') }}" method="post">
        <p>name: <input type="text" name="user_name" /></p>
        <input type="submit" value="Submit" />
    </form>
    '''
    return render_template_string(page)


@app.route('/do_login', methods=['POST'])
def do_login():
    name = request.form.get('user_name')
    session['user_name'] = name
    return 'success'


@app.route('/show')
def show():
    return session['user_name']


@app.route('/logout')
def logout():
    session.pop('user_name', None)
    return redirect(url_for('login'))


if __name__ == '__main__':
    app.run()

代码的含义

app.secret_key用于给session加密。

在/login中将向用户展示一个表单，要求输入一个名字，submit后将数据以post的方式传递给/do_login，/do_login将名字存放在session中。

如果用户成功登录，访问/show时会显示用户的名字。此时，打开调试工具，选择session面板，会看到有一个cookie的名称为session。

/logout用于登出，通过将session中的user_name字段pop即可。Flask中的session基于字典类型实现，调用pop方法时会返回pop的键对应的值；如果要pop的键并不存在，那么返回值是pop()的第二个参数。

另外，使用redirect()重定向时，一定要在前面加上return。

设置session的有效时间

设置session的有效时间设置为5分钟。

代码如下：

from datetime import timedelta
from flask import session, app

session.permanent = True
app.permanent_session_lifetime = timedelta(minutes=5)

使用Cookie

Cookie是存储在客户端的记录访问者状态的数据。

常用的用于记录用户登录状态的session大多是基于cookie实现的。

cookie可以借助flask.Response来实现。

使用Response.set_cookie添加和删除cookie。

expires参数用来设置cookie有效时间，值可以是datetime对象或者unix时间戳。

res.set_cookie(key='name', value='loen', expires=time.time()+6*60)

上面的expire参数的值表示cookie在从现在开始的6分钟内都是有效的。

要删除cookie，将expire参数的值设为0即可：

res.set_cookie('name', '', expires=0)

详细的app.py代码如下：

import time

from flask import Flask, request, Response

app = Flask(__name__)


@app.route('/add')
def login():
    res = Response('add cookies')
    res.set_cookie(key='name', value='loen', expires=time.time() + 6 * 60)
    return res


@app.route('/show')
def show():
    return request.cookies.__str__()


@app.route('/del')
def del_cookie():
    res = Response('delete cookies')
    res.set_cookie('name', '', expires=0)
    return res


if __name__ == '__main__':
    app.run()

闪存系统 flashing system

Flask 的闪存系统（flashing system）用于向用户提供反馈信息，这些反馈信息一般是对用户上一次操作的反馈。

反馈信息是存储在服务器端的，当服务器向客户端返回反馈信息后，这些反馈信息会被服务器端删除。

详细的app.py代码如下：

import time

from flask import Flask, get_flashed_messages, flash

app = Flask(__name__)
app.secret_key = 'some_secret'


@app.route('/')
def index():
    return 'Hello index'


@app.route('/gen')
def gen():
    info = 'access at ' + time.time().__str__()
    flash(info)
    return info


@app.route('/show1')
def show1():
    return get_flashed_messages().__str__()


@app.route('/show2')
def show2():
    return get_flashed_messages().__str__()


if __name__ == '__main__':
    app.run()

合服活动

注：普通召唤券往后4000给100，5000给100，6000给150，7000给150，至此封顶

注：幻神神魄使用情况，目前不全，欢迎留言补充

零氪黄道神武

摘星楼、秘境、龙珠神将出现顺序

• 摘星楼：2金灵圣女、4火神祝融、6水神共工、8敖烈、10万圣公主、12北财神赵公明、14地神后土、16龙吉公主
• 秘境：1吕玲绮、5孙尚香、9马超、13大乔
• 龙珠：3蔡文姬、7小乔、11司马懿、15黄月英

炼妖嘉年华

九星秘宝
500，500，1000，1500，1500，5000，7500，后面还有两个不知道

抽卡嘉年华

九星秘宝
500，500，1000，1500,，1500，5000，7500，后面还有两个不知道

归墟

财神宝轮

根据以往经验来看，到一定次数必出对应东西，具体如下：

• 40 ：一万玉
• 80 ：百分之2
• 250：1星龙装
• 290：百分之2
• 370：2星龙装或福运至宝
• 390：5万玉
• 410：百分之5
• 690：3星龙装
  推荐是到410次抽一回

前言

主要学习docker的相关操作，构建镜像、docker容器运行、从容器内往外拷贝文件，向容器内拷贝文件，进入容器

docker构建镜像

编写Dockerfile文件：

vi Dockerfile

文件内输入

from nginx

在同目录执行构建命令：

docker build -t my-nginx .

docker容器运行

执行命令：

# 运行命令
docker run --name my-nginx -d -p 40080:80 my-nginx
# 查看所有容器信息
docker ps -a

浏览器输入IP:40080，显示默认nginx页面

从容器内往外拷贝文件

执行命令：

# 拷贝文件
docker cp my-nginx:/usr/share/nginx/html/index.html index.html
# 查看文件内容
cat index.html
# 修改文件内容
vi index.html
# 查看文件内容
cat index.html

向容器内拷贝文件

执行命令：

# 拷贝文件
docker cp index.html my-nginx:/usr/share/nginx/html/index.html 

浏览器输入IP:40080，显示页面已经改变

进入容器

为了方便查看变化，这里拷贝了一份不一样的文件进人容器，执行命令：

# 修改文件名
mv index.html new.html
# 修改文件内容
vi new.html
# 拷贝文件进容器
docker cp new.html my-nginx:/usr/share/nginx/html/new.html
# 查看修改文件的内容
cat new.html

执行命令：

# 从容器中拷贝nginx配置文件
docker cp my-nginx:/etc/nginx/conf.d/default.conf .
# 查看配置文件
cat default.conf

# 修改配置文件
vi default.conf
# 查看修改后的配置文件
cat default.conf

# 再将配置文件拷贝回容器
docker cp default.conf my-nginx:/etc/nginx/conf.d/default.conf
# 进入容器
docker exec -it my-nginx /bin/bash
# 查看拷贝进容器的文件
cat /usr/share/nginx/html/new.html

# 查看拷贝进容器的nginx配置文件
cat /etc/nginx/conf.d/default.conf
# 重启nginx
nginx -s reload
# 退出容器
exit

浏览器输入IP:40080，显示页面已经改变

前言

由于腾讯云限制了免费证书的使用个数，而我之前因为免费就随意了很多，现在，一个正在使用的证书过期了，没法继续使用，这样就导致了在浏览器中不能一步到位的打开网站

网站介绍

使用的是FreeSSL.cn网站，该网站提供免费的HTTPS证书申请，下面是网站首页

安装acme.sh

我们需要先在服务器上安装acme.sh，建议使用root用户安装

curl https://get.acme.sh | sh -s email=my@example.com

ACME 域名配置