小马哥的故事

企业级代理架构实践指南：从浏览器到远程隧道的优雅方案

Thu, 26 Mar 2026 02:27:00 GMT

引言

在现代网络架构中,代理技术不仅是访问控制的核心组件,更是构建安全、高效网络环境的关键基础设施。本文将从架构视角,系统性地阐述两种轻量级代理方案的设计与实现:浏览器级的精准流量调度与 SSH 隧道的安全代理转发。

一、浏览器代理编排：ZeroOmega 的架构设计

1.1 设计理念：职责分离原则

ZeroOmega (SwitchyOmega 3) 采用了 代理编排器 的设计模式,其核心价值在于:

单一职责：专注于流量调度逻辑,不承载代理节点本身
精准分流：基于规则的智能路由,实现细粒度的流量控制
非侵入式：仅管控浏览器流量,保持系统其他组件的网络独立性

这种设计符合 微服务架构中的网关模式,将代理决策与代理执行解耦,提供了更高的灵活性和可维护性。

1.2 快速部署方案

第一步：组件安装

# 方案A: Chrome Web Store (推荐) # 搜索 "Proxy SwitchyOmega 3 (ZeroOmega)"  # 方案B: 离线安装 # GitHub Release: https://github.com/zero-peak/ZeroOmega/releases

第二步：代理配置

在扩展选项页配置代理服务器:

配置参数:

协议选择: HTTP (兼容性最优) 或 SOCKS5 (性能更优)
服务端点: 127.0.0.1 (本地回环地址)
端口映射

:
- Clash 默认: 7890 (HTTP) / 7891 (SOCKS5)
- v2ray 默认: 1080 (SOCKS5)

架构建议:

# 推荐配置结构 Proxy_Profiles:   - name: "Production"     protocol: HTTP     host: 127.0.0.1     port: 7890      - name: "Development"       protocol: SOCKS5     host: 127.0.0.1     port: 7891

1.3 分流规则设计

最佳实践规则集:

// 基于域名的智能路由 {   "RuleSet": [     {       "condition": "DomainSuffix",       "pattern": "google.com",       "profile": "Proxy",       "comment": "国际服务走代理"     },     {       "condition": "DomainSuffix",        "pattern": "taobao.com",       "profile": "Direct",       "comment": "国内电商直连"     },     {       "condition": "DomainKeyword",       "pattern": "localhost",       "profile": "Direct",       "comment": "本地开发环境"     }   ] }

二、SSH 隧道代理：轻量级安全通道

2.1 架构优势分析

SSH 动态端口转发 (Dynamic Port Forwarding) 提供了:

✅ 零依赖: 无需安装额外代理软件 ✅ 加密传输: 基于SSH协议的端到端加密 ✅ 灵活部署: 任意SSH服务器均可作为代理节点 ✅ SOCKS5原生支持: 标准协议,兼容性强

2.2 核心配置

基础实现

# 标准部署命令 ssh -D 1080 -N -f user@your-server.com  # 参数解析: # -D 1080    创建本地SOCKS5代理监听端口 # -N         禁用远程命令执行(安全加固) # -f         后台守护进程模式

安全增强：密钥认证

# 1. 密钥对生成(推荐Ed25519算法) ssh-keygen -t ed25519 -C "proxy@your-domain"  # 2. 公钥部署 ssh-copy-id -i ~/.ssh/id_ed25519.pub user@your-server.com  # 3. 连接测试 ssh -o BatchMode=yes user@your-server.com exit && echo "Auth Success"  # 4. 生产环境部署 ssh -D 1080 -N -f \     -o ServerAliveInterval=60 \     -o ServerAliveCountMax=3 \     -o ExitOnForwardFailure=yes \     user@your-server.com

高级参数说明:

ServerAliveInterval: 心跳检测间隔(秒),防止连接超时断开
ServerAliveCountMax: 最大失败次数
ExitOnForwardFailure: 端口转发失败时立即退出

2.3 运维管理

进程监控

# 方案A: 传统进程管理 ps aux | grep "ssh -D" | grep -v grep  # 方案B: 端口监听检测 lsof -i :1080 -P -n | grep LISTEN  # 方案C: 系统级服务(推荐) # 创建 systemd 服务实现自动重启

连接验证

# 代理功能测试 curl --socks5 127.0.0.1:1080 \      --connect-timeout 5 \      https://api.ipify.org  # 期望输出: 服务器公网IP  # 完整性测试 curl --socks5 127.0.0.1:1080 \      -I https://www.google.com 2>&1 | head -1 # 期望输出: HTTP/2 200

优雅停止

# 精准停止 pkill -f "ssh -D 1080"  # 或基于PID kill $(lsof -ti :1080)

三、工程化实践：命令行工具封装

3.1 Shell Alias 配置

# ~/.zshrc 或 ~/.bashrc  # 代理管理套件 alias proxy-on='ssh -D 1080 -N -f user@your-server.com' alias proxy-off='pkill -f "ssh -D 1080"' alias proxy-status='lsof -i :1080 -P -n' alias proxy-test='curl --socks5 127.0.0.1:1080 https://api.ipify.org'  # 重载配置 source ~/.zshrc

3.2 自动化脚本示例

#!/bin/bash # proxy-manager.sh - 代理生命周期管理  PROXY_PORT=1080 SERVER="user@your-server.com"  start_proxy() {     if lsof -i :$PROXY_PORT >/dev/null 2>&1; then         echo "⚠️  Proxy already running on port $PROXY_PORT"         return 1     fi          ssh -D $PROXY_PORT -N -f \         -o ServerAliveInterval=60 \         -o ExitOnForwardFailure=yes \         $SERVER          sleep 2     if lsof -i :$PROXY_PORT >/dev/null 2>&1; then         echo "✅ Proxy started successfully"         proxy-test     else         echo "❌ Failed to start proxy"         return 1     fi }  stop_proxy() {     pkill -f "ssh -D $PROXY_PORT"     echo "🛑 Proxy stopped" }  case "${1:-status}" in     start)   start_proxy ;;     stop)    stop_proxy ;;     status)  lsof -i :$PROXY_PORT -P -n ;;     restart) stop_proxy; sleep 1; start_proxy ;;     *)       echo "Usage: $0 {start|stop|status|restart}" ;; esac

四、架构选型建议

维度	ZeroOmega	SSH 隧道
适用场景	浏览器精细化分流	系统级全局代理
部署复杂度	⭐⭐	⭐⭐⭐⭐⭐
灵活性	⭐⭐⭐⭐⭐	⭐⭐⭐
性能开销	极低	低(加密开销)
运维成本	低	中(需维护SSH连接)
安全等级	继承本地代理配置	高(SSH加密)

五、最佳实践总结

5.1 组合方案推荐

生产环境架构: ┌─────────────────────────────────────┐ │  Browser → ZeroOmega (Rule Engine)  │ │              ↓                       │ │    Proxy ← SSH Tunnel → Remote      │ │              ↓                       │ │         Target Services             │ └─────────────────────────────────────┘

5.2 关键要点

最小权限原则: SSH代理使用专用账号,限制shell权限
连接复用: 启用SSH ControlMaster减少连接开销
监控告警: 定期检测代理可用性
文档化: 维护proxy-config文档,记录规则变更

结语

代理架构的设计需要在 易用性、安全性、可维护性 之间寻找平衡。ZeroOmega 与 SSH 隧道各有所长,前者适合浏览器级别的精细控制,后者适合需要加密传输的场景。在实际工程中,建议根据业务需求选择合适方案,或采用组合架构实现最优效果。

相关资源:

Mac系统下IDEA的shit+cmd+f快捷键冲突问题

Thu, 25 Dec 2025 07:38:26 GMT

问题

在IDEA中使用快捷键shit+cmd+f就会跳出IDEA，变到访达到界面。每次想在IDEA中全局搜索时都会跳转到访达，必须得再手动切回IDEA，很麻烦。IDEA也会提示快捷键和操作系统快捷键冲突。

解决方法

键盘->键盘快捷键->搜索->聚焦 取消勾选

Mac启动台里的图标删不掉？试试这个终极解决方案

Mon, 27 Oct 2025 02:20:00 GMT

你是否曾经遇到过这样的困扰：在Mac的启动台(Launchpad)中，有些应用的图标就是删不掉？无论你是拖到废纸篓还是使用其他方法，它们就像顽固的污渍一样留在那里。别担心，我来分享一个有效的解决方案！

问题描述

通常情况下，我们可以通过以下方式删除启动台中的图标：

长按图标直到抖动，然后点击"X"按钮
直接将图标拖到废纸篓

但有时候，某些应用（特别是那些没有正确安装或卸载的应用）的图标会卡在启动台中，无法通过常规方法删除。

解决方案

这里是一个通过终端命令直接操作启动台数据库的方法：

bash

sqlite3 $(find /private/var/folders \( -name com.apple.dock.launchpad -a -user $USER \) 2> /dev/null)/db/db "DELETE FROM apps WHERE title like '%Epic%';" && killall Dock

命令详解

让我来解释一下这个命令的各个部分：

sqlite3 - 用于操作SQLite数据库的命令行工具
$(find ...) - 查找启动台数据库的路径
/private/var/folders - Mac存储用户特定数据的目录
com.apple.dock.launchpad - 启动台的数据文件夹
db/db - 实际的数据库文件
DELETE FROM apps WHERE title like '%Epic%' - SQL命令，删除标题包含"Epic"的应用记录
killall Dock - 重启Dock进程，使更改生效

使用方法

打开终端应用（可以在Spotlight中搜索"终端"）
复制上面的命令
将命令中的'%Epic%'替换为你想删除的应用名称
- 例如，要删除名为"TestApp"的应用：'%TestApp%'
- 要删除名为"Old Software"的应用：'%Old Software%'
按回车执行命令
等待Dock重启（屏幕可能会闪烁一下）

注意事项

⚠️ 重要提示：

在执行此命令前，请确保已正确卸载相关应用
此操作直接修改系统数据库，请谨慎使用
建议先备份重要数据
如果不确定应用的确切名称，可以先使用查询命令：

bash

# 先查看数据库中有哪些应用 sqlite3 $(find /private/var/folders \( -name com.apple.dock.launchpad -a -user $USER \) 2> /dev/null)/db/db "SELECT title FROM apps;"

其他可能的解决方案

如果上述方法不适用，你还可以尝试：

重置启动台：

bash

defaults write com.apple.dock ResetLaunchPad -bool true && killall Dock

清理启动台缓存：

bash

rm ~/Library/Application\ Support/Dock/*.db && killall Dock

总结

顽固的启动台图标确实令人烦恼，但通过直接操作底层的SQLite数据库，我们能够彻底清除这些"幽灵"图标。希望这个方法能帮助你解决这个问题！

如果你有其他Mac使用方面的问题，欢迎在评论区留言讨论。

注意：操作系统数据库存在风险，请在执行前确保理解命令的含义。对于不熟悉的用户，建议寻求专业技术支持。

GIT SSH Key 配置管理

Wed, 20 Aug 2025 01:16:16 GMT

公钥管理

以下通过gitea 来演示,gitee github 基本大同小异

用户可以通过仓库主页「设置」->「SSH /GPG密钥」，浏览/验证/删除当前仓库已添加的SSH Key。

生成/添加 SSH 公钥

Gitea 提供了基于 SSH 协议的 Git 服务，在使用 SSH 协议访问仓库之前，需要先配置好账户/仓库的 SSH 公钥。

你可以按如下命令来生成 sshkey:

ssh-keygen -t ed25519 -C "xxxxx@xxxxx.com"   # Generating public/private ed25519 key pair...

注意：这里的 xxxxx@xxxxx.com 只是生成的 sshkey 的名称，并不约束或要求具体命名为某个邮箱。现网的大部分教程均讲解的使用邮箱生成，其一开始的初衷仅仅是为了便于辨识所以使用了邮箱。

按照提示完成三次回车，即可生成 ssh key。通过查看 ~/.ssh/id_ed25519.pub 文件内容，获取到你的 public key

cat ~/.ssh/id_ed25519.pub # ssh-ed25519 AAAAB3NzaC1yc2EAAAADAQABAAABAQC6eNtGpNGwstc....

复制生成后的 ssh key，通过仓库主页「设置」->「SSH /GPG密钥」->「增加密钥」，添加生成的 public key 添加到仓库中。

添加后，在终端（Terminal）中输入

ssh -T git@maruifu.com

首次使用需要确认并添加主机到本机 SSH 可信列表。

maruifu@XMG-M4ProMax ~ % ssh -T git@maruifu.com  The authenticity of host '[maruifu.com] ([182.156.236.139])' can't be established. ED25519 key fingerprint is SHA256:m7seiLokJsJhj9yuyrSQ6ZoEtHgRvHcV3tYEPNE9cRI. This host key is known by the following other names/addresses:     ~/.ssh/known_hosts:14: [git.maruifu.com]:222 Are you sure you want to continue connecting (yes/no/[fingerprint])? yes Warning: Permanently added '[maruifu.com]' (ED25519) to the list of known hosts. Hi there, maruifu! You've successfully authenticated with the key named marf@pep.com.cn, but Gitea does not provide shell access. If this is unexpected, please log in with password and setup Gitea under another user.

ssh -T -p 2222 git@maruifu.com 
ssh: Secure Shell 协议。

-T: 禁用伪终端（PTY）分配。对于只是测试连接或执行简单命令（如 Git 操作）来说，这很常用，因为它更简洁安全。

-p 2222: 指定连接远程主机的端口号为 222（而不是默认的 222）。22端口可以省略此参数

git@maruifu.com: 使用 git 用户连接到 maruifu.com 主机。

添加成功后，就可以使用 SSH 协议对仓库进行操作了。

Git 配置多个 SSH Key

背景

同时使用两个 Gitea 帐号，需要为两个帐号配置不同的 SSH Key：

帐号 A 用于公司；
帐号 B 用于个人。

解决方法

生成帐号 A 的 SSH Key，并在帐号 A 的 Gitea 设置页面添加 SSH 公钥：

ssh-keygen -t ed25519 -C "Gitea User A" -f ~/.ssh/Gitea_user_a_ed25519

生成帐号 B 的 SSH-Key，并在帐号 B 的 Gitea 设置页面添加 SSH 公钥：

ssh-keygen -t ed25519 -C "Gitea User B" -f ~/.ssh/Gitea_user_b_ed25519

创建或者修改文件 ~/.ssh/config，添加如下内容：

Host gt_a     User git     Hostname git@maruifu.com     Port 22     IdentityFile ~/.ssh/Gitea_user_a_ed25519 Host gt_b     User git     Hostname git@maruifu.com     Port 22     IdentityFile ~/.ssh/Gitea_user_b_ed25519

用 ssh 命令分别测试两个 SSH Key：

$ ssh -T gt_a Hi Gitea User A! You've successfully authenticated, but git@maruifu.com does not provide shell access.  $ ssh -T gt_b Hi Gitea User B! You've successfully authenticated, but git@maruifu.com does not provide shell access.

拉取代码：

将 git@git@maruifu.com 替换为 SSH 配置文件中对应的 Host，如原仓库 SSH 链接为：

git@git@maruifu.com:owner/repo.git

使用帐号 A 推拉仓库时，需要将连接修改为：

gt_a:owner/repo.git

群晖部署KMS服务器激活Windows

Sun, 17 Aug 2025 09:12:29 GMT

本文将从搭建KMS服务器、使用PowerShell(管理员)两部分介绍如何使用KMS激活Windows。

搭建KMS服务器

一些网上的KMS服务器也是可以用的，普通用户可跳过此步骤。

项目地址： luodaoyi/kms-server

使用Docker拉取镜像并映射1688端口启动即可。此处以群晖为例，打开Docker，点击注册表，搜索kms-server，双击下载latest版本镜像

下载好后点击左侧的映像，找到刚刚下载的kms-server，双击创建一个新的容器。

选择高级设置 – 端口设置，修改映射端口

至此局域网本地的kms-server服务器便搭建完成。

激活Windows

首先，我们需要根据系统版本修改对应的密钥。点击这里查看对应版本密钥

此处以Windows 11专业版为例，通过查表可以找到对应的Windows 10专业版密钥如

右击开始，选择PowerShell(管理员)或终端(管理员)，输入：

slmgr /ipk W269N-WFGWX-YVC9B-4J6C9-T83GX

此处的密钥需根据自己系统版本自行替换，具体版本对应密钥请查表如图即为成功安装产品密钥：

输入以下命令来配置KMS服务器：

slmgr /skms KMS服务器在局域网中的IP地址

如端口未映射成1688，需要在IP地址后携带端口号

如图即为配置成功：

执行如下命令来激活Windows：

slmgr /ato

如图即为激活成功：

Docker Gitea 启用SSH服务修改端口之大坑

Sat, 16 Aug 2025 18:18:00 GMT

修改配置文件 /data/gitea/conf/app.ini

[server] SSH_DOMAIN = git.maruifu.cn  # 与http访问的域名配置一样即可，只需写域名，无需http以及端口号等； DISABLE_SSH = false SSH_PORT = 222  # 预期的端口,此端口需要在Docker 映射,即外网连接SSH时的端口; SSH_LISTEN_PORT = 22 # 必须是22,不可修改,配置文件修改此端口无效

macOS 上使用 Homebrew 安装和配置 frp 客户端

Mon, 23 Jun 2025 08:51:37 GMT

macOS 上使用 Homebrew 安装和配置 frp 客户端 (frpc) 指南 frp (Fast Reverse Proxy) 是一款高性能的反向代理应用，常用于内网穿透。本文将介绍在 macOS 上使用 Homebrew 安装 frpc，并进行配置和管理。

安装 frpc

使用 Homebrew 安装（推荐）确保已安装 Homebrew

终端中执行：

brew install frpc

安装完成后，frpc 可执行文件通常位于：

M1/M2 系列芯片：/opt/homebrew/bin/frpc Intel 版 mac：/usr/local/bin/frpc

配置 frpc

看配置文件是否存在不存在手动创建,存在则跳过本步骤

# 创建配置文件目录 sudo mkdir -p /opt/homebrew/etc/frp # 创建配置文件 sudo nano /opt/homebrew/etc/frp/frpc.toml

# 公共配置 serverAddr = "X.X.X.X"   # 服务器IP地址 serverPort = 7000 auth.method = "token" auth.token = "XXXX"   # MAC-VNC服务转发 [[proxies]] name = "MAC-VNC" type = "tcp" localIP = "127.0.0.1" localPort = 5900            # 本地的端口 remotePort = 15900           # 服务器上的访问端口

注意：不要在 serverAddr 前加 http:// 或 https://

启动和关闭 frpc

启动 frpc

/opt/homebrew/bin/frpc -c /opt/homebrew/etc/frp/frpc.toml  如果配置正确，将看到例如下面的输出： start proxy success

关闭 frpc

pkill frpc

设置开机自启动

使用 Homebrew Services

启动 frpc 服务

brew services start frpc

默认会使用 /opt/homebrew/etc/frp/frpc.toml

停止 frpc 服务

brew services stop frpc

查看日志

tail -f /opt/homebrew/var/log/frpc.log

打包本地电脑谷歌浏览器插件

Mon, 23 Jun 2025 02:17:29 GMT

不同系统安装地址不一样

系统	地址
MAC	~/Library/Application\ Support/Google/Chrome/Default/Extensions
WINDOWS	C:\Users\你的用户名\AppData\Local\Google\Chrome\User Data\Default\Extensions
LINUX	~/.config/google-chrome/Default/Extensions

查看插件ID

我的这个插件ID是 dhdgffkkebhmkfjojejmpbldmpobfkfo

打包插件

打包后当前目录会有一个后缀为CRX的文件

群晖安装 Open VPN

Sun, 18 May 2025 14:30:44 GMT

适配机型

下载VPN Server套件

打开套件中心 ➔ 搜索"VPN Server" ➔ 安装

目前来说，这个方法好像不行了，原因嘛自行脑补。

打开群晖官网

https://www.synology.com/zh-tw/support/download/

下载VPN Server

手动安装

配置 OpenVPN

修改配置文件

导出配置文件后修改服务器地址

下载 OpenVPN 客户端

访问官网下载 https://openvpn.net/client/ 客户端

打不开，可以下载上海大学的客户端 https://vpn.shu.edu.cn/index/OpenVPNsysm/MacOS.htm

客户端配置

导入配置文件

右键系统托盘图标 ➔ 选择导入文件
选择以下文件：刚才修改后 VPNConfig.ovpn 文件

建立VPN连接

导入配置文件后，直接点“连接”；
根据提示，输入群晖上创建的、有权VPN访问的账号和密码；
查看连接状态：

群晖系统百度网盘套件ContainerManager项目无法删除

Fri, 16 May 2025 17:11:00 GMT

前言

群晖系统重置了，群晖系统上面的应用都没了，但是数据包含docker 的数据都还在。我重新安装百度网盘的时候提示我

name 'baiduapp' duplicated 名字重复，群晖的应用列表没有提示我这个重复。我想起这个应用是 docker 项目

ContainerManager 里面确实有这个项目，但是是套件安装的也无法删除，现在就卡死在这里了，无法重新，也无法删除。

解决方案

开启 SHH

SSH 操作删除

# 切换 root 用户 maruifu@XiaoMageNAS:~$ sudo -i  # 输入群晖密码 Password:          # 进入项目目录 root@XiaoMageNAS:~# cd /var/packages/ContainerManager/etc/projects  # 查看当前目录下的文件，我这里其实就一个59870233-d476-4c79-9c71-c990de8dc040 项目 ，其实直接删除这三个就行，如果有多个看下一步 root@XiaoMageNAS:/var/packages/ContainerManager/etc/projects# ls      59870233-d476-4c79-9c71-c990de8dc040.action.log  59870233-d476-4c79-9c71-c990de8dc040.config.json  59870233-d476-4c79-9c71-c990de8dc040.lock # 当前目录搜索 包含 baiduapp 的配置文件编号 root@XiaoMageNAS:/var/packages/ContainerManager/etc/projects# grep -rl --include="*.json" "baiduapp" | awk -F/ '{print $NF}' | awk -F. '{print $1}' 59870233-d476-4c79-9c71-c990de8dc040 # 删除 所有  59870233-d476-4c79-9c71-c990de8dc040 开头的文件 root@XiaoMageNAS:/var/packages/ContainerManager/etc/projects# rm -rf 59870233-d476-4c79-9c71-c990de8dc040*

验证

执行上面操作后删除了

部署 Docker 私服 docker-registry

Wed, 14 May 2025 15:49:00 GMT

部署docker-registry

networks:     1panel-network:         external: true services:     docker-registry:         container_name: ${CONTAINER_NAME}         deploy:             resources:                 limits:                     cpus: ${CPUS}                     memory: ${MEMORY_LIMIT}         environment:             - REGISTRY_HTTP_ADDR=0.0.0.0:15000             - REGISTRY_STORAGE_DELETE_ENABLED=true             - REGISTRY_HTTP_TLS_CERTIFICATE=/certs/fullchain.pem             - REGISTRY_HTTP_TLS_KEY=/certs/privkey.pem         image: registry:3.0.0         labels:             createdBy: Apps         networks:             - 1panel-network         ports:             - ${HOST_IP}:${PANEL_APP_PORT_HTTP}:15000         restart: always         volumes:             - ./data:/var/lib/registry             - ./certs:/certs

部署docker-registry-ui

version: '3.8' networks:     1panel-network:         external: true services:   registry-ui:     image: joxit/docker-registry-ui:main     networks:       - 1panel-network     restart: always     ports:       - 15001:80     environment:       - SINGLE_REGISTRY=true       - REGISTRY_TITLE=Docker Registry UI       - DELETE_IMAGES=true       - SHOW_CONTENT_DIGEST=true       - NGINX_PROXY_PASS_URL=https://docker-registry:15000       - SHOW_CATALOG_NB_TAGS=true       - CATALOG_MIN_BRANCHES=1       - CATALOG_MAX_BRANCHES=1       - TAGLIST_PAGE_SIZE=100       - REGISTRY_SECURED=false       - CATALOG_ELEMENTS_LIMIT=1000     container_name: registry-ui

验证

sudo docker tag 1panel/maxkb:v1.10.7-lts s.mrf.ink:15000/1panel/maxkb:v1.10.7-lts sudo docker push s.mrf.ink:15000/1panel/maxkb:v1.10.7-lts

1panel 容器部署 chevereto 开心版

Wed, 07 May 2025 02:52:00 GMT

下载容器

docker pull ghcr.io/chevereto/chevereto:4.0.9

开心版基于 4.0.7 开发的,我们下载 4.0.9 就可以

创建数据库

运行容器

sudo docker run -d \   --name chevereto \   -p 9000:80 \               # 我这里使用的是9000端口,可以自定义修改   -e CHEVERETO_DB_HOST=192.168.2.1 \    # 使用数据库的IP   -e CHEVERETO_DB_USER=chevereto \       # 使用数据库用户   -e CHEVERETO_DB_PASS=password \        # 使用数据库的密码   -e CHEVERETO_DB_PORT=3306 \            # 使用数据库的端口   -e CHEVERETO_DB_NAME=chevereto \       # 使用数据库的实例   -e CHEVERETO_MAX_POST_SIZE=2G \   -e CHEVERETO_MAX_UPLOAD_SIZE=2G \   -e CHEVERETO_SERVICING=server \   -v /opt/chevereto/images:/var/www/html/images \   -v /opt/chevereto:/var/www/html \   ghcr.io/chevereto/chevereto:4.0.9

上传文件

解压到当前文件夹

修改上传后的文件权限

访问网址

其他

批量导入图片

创建文件夹(赋权限)

./importing/	解析
parse-users/	用户名作为顶级文件夹
parse-albums/	顶级文件夹作为专辑
no-parse/	无需文件解析

执行批量导入

sudo docker exec -it --user www-data chevereto \     app/bin/legacy -C bulk-importer \     --privacy public

批量删除图片

-- 删除所有图片（谨慎使用！） DELETE FROM chv_images; -- 删除所有相册 DELETE FROM chv_albums; DELETE FROM chv_images_hash; -- 重置自增ID（可选） ALTER TABLE chv_images AUTO_INCREMENT = 1; ALTER TABLE chv_albums AUTO_INCREMENT = 1; ALTER TABLE chv_images_hash AUTO_INCREMENT = 1;

mac 安装HomeBrew

Sun, 27 Apr 2025 14:58:32 GMT

Homebrew是什么？

homebrew是一款Mac OS平台下的软件包管理工具，拥有安装、卸载、更新、查看、搜索等功能。通过简单的指令可以实现包管理，而不用关心各种依赖和文件路径情况。

安装指令

/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"

安装过程

maruifu@marfMac-mini tools % /bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"  git version 2.39.2 (Apple Git-143)                 开始执行Homebrew自动安装程序              [cunkai.wang@foxmail.com]           ['2025-04-27 22:46:35']['13.7']        https://zhuanlan.zhihu.com/p/111014448   请选择下列一个 数字编号 后回车 （这里只是下载brew，随意选。国内下载源有5种稍后让你选择配置）  1、通过清华大学下载brew 2、通过Gitee下载brew 3、！我已经安装brew，跳过克隆，直接带我去配置国内下载源 4、不克隆brew，只把仓库地址设置成Gitee 5、不克隆brew，只把仓库地址设置成清华大学  请输入序号: 2       你选择了Gitee brew本体下载源   Mac os设置开机密码方法：     (设置开机密码：在左上角苹果图标->系统偏好设置->用户与群组->更改密码)     (如果提示This incident will be reported. 在用户与群组中查看是否管理员) 请输入开机密码，输入过程不显示，输入完后回车 Password: 已获取权限      ==> 安装过程开始调用Brew官方安装脚本，提示会变成英文，看不懂的复制到在线翻译。   如果下载速度慢可以ctrl+c或control+c重新运行脚本选择下载源    ->  !!!!是否删除之前本机安装的Brew（是Y  否N） 我没有检测本机是否安装brew，选哪个都会继续运行   (Y/N):   Y  --> 脚本开始执行   ---备份要删除的/usr/local/Homebrew到系统桌面，后续可把桌面的文件删除....    ---/usr/local/Homebrew 备份完成   ---备份要删除的/Users/maruifu/Library/Caches/Homebrew到系统桌面，后续可把桌面的文件删除....    ---/Users/maruifu/Library/Caches/Homebrew 备份完成 未发现Git代理（属于正常状态）                 开始  进入brew官方安装脚本  开始   下载官方install.sh文件,当前目录是: /Users/maruifu Cloning into 'brew-install-ck'... remote: Enumerating objects: 21, done. remote: Counting objects: 100% (21/21), done. remote: Compressing objects: 100% (19/19), done. remote: Total 21 (delta 0), reused 4 (delta 0), pack-reused 0 (from 0) Receiving objects: 100% (21/21), 22.17 KiB | 3.69 MiB/s, done. ==> Checking for `sudo` access (which may request your password)... ==> This script will install: /usr/local/bin/brew /usr/local/share/doc/homebrew /usr/local/share/man/man1/brew.1 /usr/local/share/zsh/site-functions/_brew /usr/local/etc/bash_completion.d/brew /usr/local/Homebrew  Press RETURN/ENTER 现在是brew官方安装提示，它需要你按回车键开始 other key to abort: ==> /usr/bin/sudo /bin/mkdir -p /usr/local/Homebrew ==> /usr/bin/sudo /usr/sbin/chown -R maruifu:admin /usr/local/Homebrew ==> /usr/bin/sudo /bin/mkdir -p /Users/maruifu/Library/Caches/Homebrew ==> /usr/bin/sudo /bin/chmod g+rwx /Users/maruifu/Library/Caches/Homebrew ==> /usr/bin/sudo /usr/sbin/chown -R maruifu /Users/maruifu/Library/Caches/Homebrew ==> Downloading and installing Homebrew... remote: Enumerating objects: 300043, done. remote: Counting objects: 100% (300043/300043), done. remote: Compressing objects: 100% (81201/81201), done. remote: Total 300043 (delta 215907), reused 291788 (delta 210079), pack-reused 0 (from 0) remote: Enumerating objects: 55, done. remote: Counting objects: 100% (34/34), done. remote: Total 55 (delta 34), reused 34 (delta 34), pack-reused 21 (from 1) ==> Fetching /usr/local/Homebrew...  ==> Resetting /usr/local/Homebrew... Reset branch 'stable'  ==> Installation successful!  ==> Homebrew has enabled anonymous aggregate formulae and cask analytics. Read the analytics documentation (and how to opt-out) here:   https://docs.brew.sh/Analytics No analytics data has been sent yet (nor will any be during this install run).  ==> Homebrew is run entirely by unpaid volunteers. Please consider donating:   https://gitee.com/Homebrew2/brew#donations  ==> Next steps: - Run these commands in your terminal to add Homebrew to your PATH:     echo >> /Users/maruifu/.zprofile     echo 'eval "$(/usr/local/bin/brew shellenv)"' >> /Users/maruifu/.zprofile     eval "$(/usr/local/bin/brew shellenv)" - Run brew help to get started - Further documentation:     https://docs.brew.sh  此步骤成功 Password:                    完成  退出brew官方安装脚本  完成    ==> 配置国内镜像源HOMEBREW BOTTLE 此处如果显示Password表示需要再次输入开机密码，输入完后回车 sed: /Users/maruifu/.zprofile: No such file or directory 有些电脑xcode和git混乱，再运行一次，此处如果有error正常。 xcode-select: error: command line tools are already installed, use "Software Update" in System Settings to install updates           Homebrew已经安装成功，接下来配置国内软件下载源。  请选择今后brew install的时候访问那个国内镜像，例如阿里巴巴，输入5回车。  1、中科大国内源 2、清华大学国内源 3、上海交通大学国内源 4、腾讯国内源 5、阿里巴巴国内源(推荐) 请输入序号: 5       你选择了阿里巴巴国内源            环境变量写入->/Users/maruifu/.zprofile   此步骤成功  ==> 安装完成，brew版本  Homebrew 4.4.32 Homebrew前期配置成功 ==> Updating Homebrew... ==> Downloading https://mirrors.aliyun.com/homebrew/homebrew-bottles/bottles-portable-ruby/portable-ruby-3.3.8.el_capitan.bottle.tar.gz ######################################################################### 100.0% ==> Pouring portable-ruby-3.3.8.el_capitan.bottle.tar.gz ==> Homebrew collects anonymous analytics. Read the analytics documentation (and how to opt-out) here:   https://docs.brew.sh/Analytics No analytics have been recorded yet (nor will be during this `brew` run).  ==> Homebrew is run entirely by unpaid volunteers. Please consider donating:   https://github.com/Homebrew/brew#donations  Already up-to-date.          Homebrew自动安装程序运行完成           国内地址已经配置完成    之前步骤选了删除本机brew的话，桌面多出一个Old_Homebrew文件夹，可以删除。                初步介绍几个brew命令 查看版本：brew -v  更新brew版本：brew update 查找：brew search python（其中python替换为要查找的关键字） 安装：brew install python（其中python替换为要安装的名称） 本地软件库列表：brew ls           欢迎右键点击下方地址-打开链接 点个赞吧          https://zhuanlan.zhihu.com/p/111014448          如果遇到问题可以右键下面地址查看常见错误解决办法         https://gitee.com/cunkai/HomebrewCN/blob/master/error.md          brew官方地址：https://brew.sh/zh-cn/   安装成功 但还需要重启终端 或者 运行 source /Users/maruifu/.zprofile   否则国内地址无法生效  maruifu@marfMac-mini tools % source /Users/maruifu/.zprofile maruifu@marfMac-mini tools % maruifu@marfMac-mini tools % brew -v Homebrew 4.4.32

ruoyi mysql切换 pgsql

Wed, 26 Mar 2025 01:00:00 GMT

修改 application.yml

分页插件

原文件

# PageHelper分页插件 pagehelper:   helperDialect: mysql   supportMethodsArguments: true   params: count=countSql

新文件

# PageHelper分页插件 pagehelper:   helperDialect: postgresql   supportMethodsArguments: true   params: count=countSql

修改 application-druid.yml

数据源

原文件

datasource:     type: com.alibaba.druid.pool.DruidDataSource     driverClassName: com.mysql.cj.jdbc.Driver     druid:         # 主库数据源         master:             url: jdbc:mysql://localhost:3306/ry-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8             username: root             password: password

新文件

datasource:   type: com.alibaba.druid.pool.DruidDataSource   driverClassName: org.postgresql.Driver   druid:     # 主库数据源     master:       url: jdbc:postgresql://172.16.100.207:5432/pepResourceDb?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai       username: develop       password: Develop-RS_1212

链接检测

原文件

# 配置检测连接是否有效 validationQuery: SELECT 1 FROM DUAL

新文件

# 配置检测连接是否有效 validationQuery: SELECT version()

修改 pom.xml 驱动依赖

原文件

         <!-- Mysql驱动包 -->         <dependency>             <groupId>com.mysql</groupId>             <artifactId>mysql-connector-j</artifactId>         </dependency>

新文件

        <!-- Postgresql驱动包 -->         <dependency>             <groupId>org.postgresql</groupId>             <artifactId>postgresql</artifactId>             <scope>runtime</scope>         </dependency>

修改数据表文件

定时任务表

原文件

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS; DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS; DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE; DROP TABLE IF EXISTS QRTZ_LOCKS; DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS; DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS; DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS; DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS; DROP TABLE IF EXISTS QRTZ_TRIGGERS; DROP TABLE IF EXISTS QRTZ_JOB_DETAILS; DROP TABLE IF EXISTS QRTZ_CALENDARS;  -- ---------------------------- -- 1、存储每一个已配置的 jobDetail 的详细信息 -- ---------------------------- create table QRTZ_JOB_DETAILS (     sched_name           varchar(120)    not null            comment '调度名称',     job_name             varchar(200)    not null            comment '任务名称',     job_group            varchar(200)    not null            comment '任务组名',     description          varchar(250)    null                comment '相关介绍',     job_class_name       varchar(250)    not null            comment '执行任务类名称',     is_durable           varchar(1)      not null            comment '是否持久化',     is_nonconcurrent     varchar(1)      not null            comment '是否并发',     is_update_data       varchar(1)      not null            comment '是否更新数据',     requests_recovery    varchar(1)      not null            comment '是否接受恢复执行',     job_data             blob            null                comment '存放持久化job对象',     primary key (sched_name, job_name, job_group) ) engine=innodb comment = '任务详细信息表';  -- ---------------------------- -- 2、 存储已配置的 Trigger 的信息 -- ---------------------------- create table QRTZ_TRIGGERS (     sched_name           varchar(120)    not null            comment '调度名称',     trigger_name         varchar(200)    not null            comment '触发器的名字',     trigger_group        varchar(200)    not null            comment '触发器所属组的名字',     job_name             varchar(200)    not null            comment 'qrtz_job_details表job_name的外键',     job_group            varchar(200)    not null            comment 'qrtz_job_details表job_group的外键',     description          varchar(250)    null                comment '相关介绍',     next_fire_time       bigint(13)      null                comment '上一次触发时间（毫秒）',     prev_fire_time       bigint(13)      null                comment '下一次触发时间（默认为-1表示不触发）',     priority             integer         null                comment '优先级',     trigger_state        varchar(16)     not null            comment '触发器状态',     trigger_type         varchar(8)      not null            comment '触发器的类型',     start_time           bigint(13)      not null            comment '开始时间',     end_time             bigint(13)      null                comment '结束时间',     calendar_name        varchar(200)    null                comment '日程表名称',     misfire_instr        smallint(2)     null                comment '补偿执行的策略',     job_data             blob            null                comment '存放持久化job对象',     primary key (sched_name, trigger_name, trigger_group),     foreign key (sched_name, job_name, job_group) references QRTZ_JOB_DETAILS(sched_name, job_name, job_group) ) engine=innodb comment = '触发器详细信息表';  -- ---------------------------- -- 3、 存储简单的 Trigger，包括重复次数，间隔，以及已触发的次数 -- ---------------------------- create table QRTZ_SIMPLE_TRIGGERS (     sched_name           varchar(120)    not null            comment '调度名称',     trigger_name         varchar(200)    not null            comment 'qrtz_triggers表trigger_name的外键',     trigger_group        varchar(200)    not null            comment 'qrtz_triggers表trigger_group的外键',     repeat_count         bigint(7)       not null            comment '重复的次数统计',     repeat_interval      bigint(12)      not null            comment '重复的间隔时间',     times_triggered      bigint(10)      not null            comment '已经触发的次数',     primary key (sched_name, trigger_name, trigger_group),     foreign key (sched_name, trigger_name, trigger_group) references QRTZ_TRIGGERS(sched_name, trigger_name, trigger_group) ) engine=innodb comment = '简单触发器的信息表';  -- ---------------------------- -- 4、 存储 Cron Trigger，包括 Cron 表达式和时区信息 -- ----------------------------  create table QRTZ_CRON_TRIGGERS (     sched_name           varchar(120)    not null            comment '调度名称',     trigger_name         varchar(200)    not null            comment 'qrtz_triggers表trigger_name的外键',     trigger_group        varchar(200)    not null            comment 'qrtz_triggers表trigger_group的外键',     cron_expression      varchar(200)    not null            comment 'cron表达式',     time_zone_id         varchar(80)                         comment '时区',     primary key (sched_name, trigger_name, trigger_group),     foreign key (sched_name, trigger_name, trigger_group) references QRTZ_TRIGGERS(sched_name, trigger_name, trigger_group) ) engine=innodb comment = 'Cron类型的触发器表';  -- ---------------------------- -- 5、 Trigger 作为 Blob 类型存储(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，JobStore 并不知道如何存储实例的时候) -- ----------------------------  create table QRTZ_BLOB_TRIGGERS (     sched_name           varchar(120)    not null            comment '调度名称',     trigger_name         varchar(200)    not null            comment 'qrtz_triggers表trigger_name的外键',     trigger_group        varchar(200)    not null            comment 'qrtz_triggers表trigger_group的外键',     blob_data            blob            null                comment '存放持久化Trigger对象',     primary key (sched_name, trigger_name, trigger_group),     foreign key (sched_name, trigger_name, trigger_group) references QRTZ_TRIGGERS(sched_name, trigger_name, trigger_group) ) engine=innodb comment = 'Blob类型的触发器表';  -- ---------------------------- -- 6、 以 Blob 类型存储存放日历信息， quartz可配置一个日历来指定一个时间范围 -- ----------------------------  create table QRTZ_CALENDARS (     sched_name           varchar(120)    not null            comment '调度名称',     calendar_name        varchar(200)    not null            comment '日历名称',     calendar             blob            not null            comment '存放持久化calendar对象',     primary key (sched_name, calendar_name) ) engine=innodb comment = '日历信息表';  -- ---------------------------- -- 7、 存储已暂停的 Trigger 组的信息 -- ----------------------------  create table QRTZ_PAUSED_TRIGGER_GRPS (     sched_name           varchar(120)    not null            comment '调度名称',     trigger_group        varchar(200)    not null            comment 'qrtz_triggers表trigger_group的外键',     primary key (sched_name, trigger_group) ) engine=innodb comment = '暂停的触发器表';  -- ---------------------------- -- 8、 存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息 -- ----------------------------  create table QRTZ_FIRED_TRIGGERS (     sched_name           varchar(120)    not null            comment '调度名称',     entry_id             varchar(95)     not null            comment '调度器实例id',     trigger_name         varchar(200)    not null            comment 'qrtz_triggers表trigger_name的外键',     trigger_group        varchar(200)    not null            comment 'qrtz_triggers表trigger_group的外键',     instance_name        varchar(200)    not null            comment '调度器实例名',     fired_time           bigint(13)      not null            comment '触发的时间',     sched_time           bigint(13)      not null            comment '定时器制定的时间',     priority             integer         not null            comment '优先级',     state                varchar(16)     not null            comment '状态',     job_name             varchar(200)    null                comment '任务名称',     job_group            varchar(200)    null                comment '任务组名',     is_nonconcurrent     varchar(1)      null                comment '是否并发',     requests_recovery    varchar(1)      null                comment '是否接受恢复执行',     primary key (sched_name, entry_id) ) engine=innodb comment = '已触发的触发器表';  -- ---------------------------- -- 9、 存储少量的有关 Scheduler 的状态信息，假如是用于集群中，可以看到其他的 Scheduler 实例 -- ----------------------------  create table QRTZ_SCHEDULER_STATE (     sched_name           varchar(120)    not null            comment '调度名称',     instance_name        varchar(200)    not null            comment '实例名称',     last_checkin_time    bigint(13)      not null            comment '上次检查时间',     checkin_interval     bigint(13)      not null            comment '检查间隔时间',     primary key (sched_name, instance_name) ) engine=innodb comment = '调度器状态表';  -- ---------------------------- -- 10、 存储程序的悲观锁的信息(假如使用了悲观锁) -- ----------------------------  create table QRTZ_LOCKS (     sched_name           varchar(120)    not null            comment '调度名称',     lock_name            varchar(40)     not null            comment '悲观锁名称',     primary key (sched_name, lock_name) ) engine=innodb comment = '存储的悲观锁信息表';  -- ---------------------------- -- 11、 Quartz集群实现同步机制的行锁表 -- ----------------------------  create table QRTZ_SIMPROP_TRIGGERS (     sched_name           varchar(120)    not null            comment '调度名称',     trigger_name         varchar(200)    not null            comment 'qrtz_triggers表trigger_name的外键',     trigger_group        varchar(200)    not null            comment 'qrtz_triggers表trigger_group的外键',     str_prop_1           varchar(512)    null                comment 'String类型的trigger的第一个参数',     str_prop_2           varchar(512)    null                comment 'String类型的trigger的第二个参数',     str_prop_3           varchar(512)    null                comment 'String类型的trigger的第三个参数',     int_prop_1           int             null                comment 'int类型的trigger的第一个参数',     int_prop_2           int             null                comment 'int类型的trigger的第二个参数',     long_prop_1          bigint          null                comment 'long类型的trigger的第一个参数',     long_prop_2          bigint          null                comment 'long类型的trigger的第二个参数',     dec_prop_1           numeric(13,4)   null                comment 'decimal类型的trigger的第一个参数',     dec_prop_2           numeric(13,4)   null                comment 'decimal类型的trigger的第二个参数',     bool_prop_1          varchar(1)      null                comment 'Boolean类型的trigger的第一个参数',     bool_prop_2          varchar(1)      null                comment 'Boolean类型的trigger的第二个参数',     primary key (sched_name, trigger_name, trigger_group),     foreign key (sched_name, trigger_name, trigger_group) references QRTZ_TRIGGERS(sched_name, trigger_name, trigger_group) ) engine=innodb comment = '同步机制的行锁表';  commit;

新文件

-- Thanks to Patrick Lightbody for submitting this... -- -- In your Quartz properties file, you'll need to set -- org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.PostgreSQLDelegate  DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS; DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS; DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE; DROP TABLE IF EXISTS QRTZ_LOCKS; DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS; DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS; DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS; DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS; DROP TABLE IF EXISTS QRTZ_TRIGGERS; DROP TABLE IF EXISTS QRTZ_JOB_DETAILS; DROP TABLE IF EXISTS QRTZ_CALENDARS;   -- ---------------------------- -- 1、任务详细信息表 -- ----------------------------  CREATE TABLE QRTZ_JOB_DETAILS (   SCHED_NAME        VARCHAR(120) NOT NULL,   JOB_NAME          VARCHAR(200) NOT NULL,   JOB_GROUP         VARCHAR(200) NOT NULL,   DESCRIPTION       VARCHAR(250) NULL,   JOB_CLASS_NAME    VARCHAR(250) NOT NULL,   IS_DURABLE        BOOL         NOT NULL,   IS_NONCONCURRENT  BOOL         NOT NULL,   IS_UPDATE_DATA    BOOL         NOT NULL,   REQUESTS_RECOVERY BOOL         NOT NULL,   JOB_DATA          BYTEA        NULL,   PRIMARY KEY (SCHED_NAME, JOB_NAME, JOB_GROUP) );  COMMENT ON TABLE QRTZ_JOB_DETAILS IS '任务详细信息表'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.job_name IS '任务名称'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.job_group IS '任务组名'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.description IS '相关介绍'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.job_class_name IS '执行任务类名称'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.is_durable IS '是否持久化'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.is_nonconcurrent IS '是否并发'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.is_update_data IS '是否更新数据'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.requests_recovery IS '是否接受恢复执行'; COMMENT ON COLUMN QRTZ_JOB_DETAILS.job_data IS '存放持久化job对象';   -- ---------------------------- -- 2、触发器详细信息表 -- ----------------------------  CREATE TABLE QRTZ_TRIGGERS (   SCHED_NAME     VARCHAR(120) NOT NULL,   TRIGGER_NAME   VARCHAR(200) NOT NULL,   TRIGGER_GROUP  VARCHAR(200) NOT NULL,   JOB_NAME       VARCHAR(200) NOT NULL,   JOB_GROUP      VARCHAR(200) NOT NULL,   DESCRIPTION    VARCHAR(250) NULL,   NEXT_FIRE_TIME BIGINT       NULL,   PREV_FIRE_TIME BIGINT       NULL,   PRIORITY       INTEGER      NULL,   TRIGGER_STATE  VARCHAR(16)  NOT NULL,   TRIGGER_TYPE   VARCHAR(8)   NOT NULL,   START_TIME     BIGINT       NOT NULL,   END_TIME       BIGINT       NULL,   CALENDAR_NAME  VARCHAR(200) NULL,   MISFIRE_INSTR  SMALLINT     NULL,   JOB_DATA       BYTEA        NULL,   PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),   FOREIGN KEY (SCHED_NAME, JOB_NAME, JOB_GROUP)   REFERENCES QRTZ_JOB_DETAILS (SCHED_NAME, JOB_NAME, JOB_GROUP) ); COMMENT ON TABLE QRTZ_TRIGGERS IS '触发器详细信息表'; COMMENT ON COLUMN QRTZ_TRIGGERS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_TRIGGERS.trigger_name IS '触发器的名字'; COMMENT ON COLUMN QRTZ_TRIGGERS.trigger_group IS '触发器所属组的名字'; COMMENT ON COLUMN QRTZ_TRIGGERS.job_name IS 'qrtz_job_details表job_name的外键'; COMMENT ON COLUMN QRTZ_TRIGGERS.job_group IS 'qrtz_job_details表job_group的外键'; COMMENT ON COLUMN QRTZ_TRIGGERS.description IS '相关介绍'; COMMENT ON COLUMN QRTZ_TRIGGERS.next_fire_time IS '上一次触发时间（毫秒）'; COMMENT ON COLUMN QRTZ_TRIGGERS.prev_fire_time IS '下一次触发时间（默认为-1表示不触发）'; COMMENT ON COLUMN QRTZ_TRIGGERS.priority IS '优先级'; COMMENT ON COLUMN QRTZ_TRIGGERS.trigger_state IS '触发器状态'; COMMENT ON COLUMN QRTZ_TRIGGERS.trigger_type IS '触发器的类型'; COMMENT ON COLUMN QRTZ_TRIGGERS.start_time IS '开始时间'; COMMENT ON COLUMN QRTZ_TRIGGERS.end_time IS '结束时间'; COMMENT ON COLUMN QRTZ_TRIGGERS.calendar_name IS '日程表名称'; COMMENT ON COLUMN QRTZ_TRIGGERS.misfire_instr IS '补偿执行的策略'; COMMENT ON COLUMN QRTZ_TRIGGERS.job_data IS '存放持久化job对象';    -- ---------------------------- -- 3、简单触发器的信息表 -- ----------------------------  CREATE TABLE QRTZ_SIMPLE_TRIGGERS (   SCHED_NAME      VARCHAR(120) NOT NULL,   TRIGGER_NAME    VARCHAR(200) NOT NULL,   TRIGGER_GROUP   VARCHAR(200) NOT NULL,   REPEAT_COUNT    BIGINT       NOT NULL,   REPEAT_INTERVAL BIGINT       NOT NULL,   TIMES_TRIGGERED BIGINT       NOT NULL,   PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),   FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)   REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) );  COMMENT ON TABLE QRTZ_SIMPLE_TRIGGERS IS '简单触发器的信息表'; COMMENT ON COLUMN QRTZ_SIMPLE_TRIGGERS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_SIMPLE_TRIGGERS.trigger_name IS 'qrtz_triggers表trigger_name的外键'; COMMENT ON COLUMN QRTZ_SIMPLE_TRIGGERS.trigger_group IS 'qrtz_triggers表trigger_group的外键'; COMMENT ON COLUMN QRTZ_SIMPLE_TRIGGERS.repeat_count IS '重复的次数统计'; COMMENT ON COLUMN QRTZ_SIMPLE_TRIGGERS.repeat_interval IS '重复的间隔时间'; COMMENT ON COLUMN QRTZ_SIMPLE_TRIGGERS.times_triggered IS '已经触发的次数';   -- ---------------------------- -- 4、Cron类型的触发器表 -- ----------------------------  CREATE TABLE QRTZ_CRON_TRIGGERS (   SCHED_NAME      VARCHAR(120) NOT NULL,   TRIGGER_NAME    VARCHAR(200) NOT NULL,   TRIGGER_GROUP   VARCHAR(200) NOT NULL,   CRON_EXPRESSION VARCHAR(120) NOT NULL,   TIME_ZONE_ID    VARCHAR(80),   PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),   FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)   REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) );   COMMENT ON TABLE QRTZ_CRON_TRIGGERS IS 'Cron类型的触发器表'; COMMENT ON COLUMN QRTZ_CRON_TRIGGERS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_CRON_TRIGGERS.trigger_name IS 'qrtz_triggers表trigger_name的外键'; COMMENT ON COLUMN QRTZ_CRON_TRIGGERS.trigger_group IS 'qrtz_triggers表trigger_group的外键'; COMMENT ON COLUMN QRTZ_CRON_TRIGGERS.cron_expression IS 'cron表达式'; COMMENT ON COLUMN QRTZ_CRON_TRIGGERS.time_zone_id IS '时区';    -- ---------------------------- -- 5、同步机制的行锁表 -- ---------------------------- CREATE TABLE QRTZ_SIMPROP_TRIGGERS (   SCHED_NAME    VARCHAR(120)   NOT NULL,   TRIGGER_NAME  VARCHAR(200)   NOT NULL,   TRIGGER_GROUP VARCHAR(200)   NOT NULL,   STR_PROP_1    VARCHAR(512)   NULL,   STR_PROP_2    VARCHAR(512)   NULL,   STR_PROP_3    VARCHAR(512)   NULL,   INT_PROP_1    INT            NULL,   INT_PROP_2    INT            NULL,   LONG_PROP_1   BIGINT         NULL,   LONG_PROP_2   BIGINT         NULL,   DEC_PROP_1    NUMERIC(13, 4) NULL,   DEC_PROP_2    NUMERIC(13, 4) NULL,   BOOL_PROP_1   BOOL           NULL,   BOOL_PROP_2   BOOL           NULL,   PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),   FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)   REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) );   COMMENT ON TABLE QRTZ_SIMPROP_TRIGGERS IS '同步机制的行锁表'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.trigger_name IS 'qrtz_triggers表trigger_name的外键'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.trigger_group IS 'qrtz_triggers表trigger_group的外键'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.str_prop_1 IS 'String类型的trigger的第一个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.str_prop_2 IS 'String类型的trigger的第二个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.str_prop_3 IS 'String类型的trigger的第三个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.int_prop_1 IS 'int类型的trigger的第一个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.int_prop_2 IS 'int类型的trigger的第二个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.long_prop_1 IS 'long类型的trigger的第一个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.long_prop_2 IS 'long类型的trigger的第二个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.dec_prop_1 IS 'decimal类型的trigger的第一个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.dec_prop_2 IS 'decimal类型的trigger的第二个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.bool_prop_1 IS 'Boolean类型的trigger的第一个参数'; COMMENT ON COLUMN QRTZ_SIMPROP_TRIGGERS.bool_prop_2 IS 'Boolean类型的trigger的第二个参数';  -- ---------------------------- -- 6、Blob类型的触发器表 -- ---------------------------- CREATE TABLE QRTZ_BLOB_TRIGGERS (   SCHED_NAME    VARCHAR(120) NOT NULL,   TRIGGER_NAME  VARCHAR(200) NOT NULL,   TRIGGER_GROUP VARCHAR(200) NOT NULL,   BLOB_DATA     BYTEA        NULL,   PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),   FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)   REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) );   COMMENT ON TABLE QRTZ_BLOB_TRIGGERS IS 'Blob类型的触发器表'; COMMENT ON COLUMN QRTZ_BLOB_TRIGGERS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_BLOB_TRIGGERS.trigger_name IS 'qrtz_triggers表trigger_name的外键'; COMMENT ON COLUMN QRTZ_BLOB_TRIGGERS.trigger_group IS 'qrtz_triggers表trigger_group的外键'; COMMENT ON COLUMN QRTZ_BLOB_TRIGGERS.blob_data IS '存放持久化Trigger对象';  -- ---------------------------- -- 7、日历信息表 -- ---------------------------- CREATE TABLE QRTZ_CALENDARS (   SCHED_NAME    VARCHAR(120) NOT NULL,   CALENDAR_NAME VARCHAR(200) NOT NULL,   CALENDAR      BYTEA        NOT NULL,   PRIMARY KEY (SCHED_NAME, CALENDAR_NAME) );  COMMENT ON TABLE QRTZ_CALENDARS IS '日历信息表'; COMMENT ON COLUMN QRTZ_CALENDARS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_CALENDARS.calendar_name IS '日历名称'; COMMENT ON COLUMN QRTZ_CALENDARS.calendar IS '存放持久化calendar对象';    -- ---------------------------- -- 8、暂停的触发器表 -- ---------------------------- CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (   SCHED_NAME    VARCHAR(120) NOT NULL,   TRIGGER_GROUP VARCHAR(200) NOT NULL,   PRIMARY KEY (SCHED_NAME, TRIGGER_GROUP) );    COMMENT ON TABLE QRTZ_PAUSED_TRIGGER_GRPS IS '暂停的触发器表'; COMMENT ON COLUMN QRTZ_PAUSED_TRIGGER_GRPS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_PAUSED_TRIGGER_GRPS.trigger_group IS 'qrtz_triggers表trigger_group的外键';  -- ---------------------------- -- 9、已触发的触发器表 -- ---------------------------- CREATE TABLE QRTZ_FIRED_TRIGGERS (   SCHED_NAME        VARCHAR(120) NOT NULL,   ENTRY_ID          VARCHAR(95)  NOT NULL,   TRIGGER_NAME      VARCHAR(200) NOT NULL,   TRIGGER_GROUP     VARCHAR(200) NOT NULL,   INSTANCE_NAME     VARCHAR(200) NOT NULL,   FIRED_TIME        BIGINT       NOT NULL,   SCHED_TIME        BIGINT       NOT NULL,   PRIORITY          INTEGER      NOT NULL,   STATE             VARCHAR(16)  NOT NULL,   JOB_NAME          VARCHAR(200) NULL,   JOB_GROUP         VARCHAR(200) NULL,   IS_NONCONCURRENT  BOOL         NULL,   REQUESTS_RECOVERY BOOL         NULL,   PRIMARY KEY (SCHED_NAME, ENTRY_ID) );   COMMENT ON TABLE QRTZ_FIRED_TRIGGERS IS '已触发的触发器表'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.entry_id IS '调度器实例id'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.trigger_name IS 'qrtz_triggers表trigger_name的外键'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.trigger_group IS 'qrtz_triggers表trigger_group的外键'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.instance_name IS '调度器实例名'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.fired_time IS '触发的时间'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.sched_time IS '定时器制定的时间'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.priority IS '优先级'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.state IS '状态'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.job_name IS '任务名称'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.job_group IS '任务组名'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.is_nonconcurrent IS '是否并发'; COMMENT ON COLUMN QRTZ_FIRED_TRIGGERS.requests_recovery IS '是否接受恢复执行';   -- ---------------------------- -- 10、调度器状态表 -- ---------------------------- CREATE TABLE QRTZ_SCHEDULER_STATE (   SCHED_NAME        VARCHAR(120) NOT NULL,   INSTANCE_NAME     VARCHAR(200) NOT NULL,   LAST_CHECKIN_TIME BIGINT       NOT NULL,   CHECKIN_INTERVAL  BIGINT       NOT NULL,   PRIMARY KEY (SCHED_NAME, INSTANCE_NAME) );   COMMENT ON TABLE QRTZ_SCHEDULER_STATE IS '调度器状态表'; COMMENT ON COLUMN QRTZ_SCHEDULER_STATE.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_SCHEDULER_STATE.instance_name IS '实例名称'; COMMENT ON COLUMN QRTZ_SCHEDULER_STATE.last_checkin_time IS '上次检查时间'; COMMENT ON COLUMN QRTZ_SCHEDULER_STATE.checkin_interval IS '检查间隔时间';   -- ---------------------------- -- 11、存储的悲观锁信息表 -- ----------------------------  CREATE TABLE QRTZ_LOCKS (   SCHED_NAME VARCHAR(120) NOT NULL,   LOCK_NAME  VARCHAR(40)  NOT NULL,   PRIMARY KEY (SCHED_NAME, LOCK_NAME) );   COMMENT ON TABLE QRTZ_LOCKS IS '存储的悲观锁信息表'; COMMENT ON COLUMN QRTZ_LOCKS.sched_name IS '调度名称'; COMMENT ON COLUMN QRTZ_LOCKS.lock_name IS '悲观锁名称';   CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY   ON QRTZ_JOB_DETAILS (SCHED_NAME, REQUESTS_RECOVERY); CREATE INDEX IDX_QRTZ_J_GRP   ON QRTZ_JOB_DETAILS (SCHED_NAME, JOB_GROUP);  CREATE INDEX IDX_QRTZ_T_J   ON QRTZ_TRIGGERS (SCHED_NAME, JOB_NAME, JOB_GROUP); CREATE INDEX IDX_QRTZ_T_JG   ON QRTZ_TRIGGERS (SCHED_NAME, JOB_GROUP); CREATE INDEX IDX_QRTZ_T_C   ON QRTZ_TRIGGERS (SCHED_NAME, CALENDAR_NAME); CREATE INDEX IDX_QRTZ_T_G   ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_GROUP); CREATE INDEX IDX_QRTZ_T_STATE   ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_STATE); CREATE INDEX IDX_QRTZ_T_N_STATE   ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP, TRIGGER_STATE); CREATE INDEX IDX_QRTZ_T_N_G_STATE   ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_GROUP, TRIGGER_STATE); CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME   ON QRTZ_TRIGGERS (SCHED_NAME, NEXT_FIRE_TIME); CREATE INDEX IDX_QRTZ_T_NFT_ST   ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_STATE, NEXT_FIRE_TIME); CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE   ON QRTZ_TRIGGERS (SCHED_NAME, MISFIRE_INSTR, NEXT_FIRE_TIME); CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE   ON QRTZ_TRIGGERS (SCHED_NAME, MISFIRE_INSTR, NEXT_FIRE_TIME, TRIGGER_STATE); CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP   ON QRTZ_TRIGGERS (SCHED_NAME, MISFIRE_INSTR, NEXT_FIRE_TIME, TRIGGER_GROUP, TRIGGER_STATE);  CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME   ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, INSTANCE_NAME); CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY   ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, INSTANCE_NAME, REQUESTS_RECOVERY); CREATE INDEX IDX_QRTZ_FT_J_G   ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, JOB_NAME, JOB_GROUP); CREATE INDEX IDX_QRTZ_FT_JG   ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, JOB_GROUP); CREATE INDEX IDX_QRTZ_FT_T_G   ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP); CREATE INDEX IDX_QRTZ_FT_TG   ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, TRIGGER_GROUP);   COMMIT;

业务表

注释

#去掉存储引擎和表注释  engine=innodb auto_increment=200 comment = 'XX表' #去掉字段注释 comment 'XX字段',  增加表注释 COMMENT ON TABLE table IS 'XX表'; COMMENT ON COLUMN table.field IS 'XX字段';

索引

# 删除 key idx_table_field (field), # 创建 CREATE INDEX idx_table_field ON table(field);

数据类型转换

bigint(20)  not null auto_increment   --> BIGSERIAL NOT NULL bigint(20)                            --> BIGINT bigint(5)                            --> BIGINT int(4)                                --> int4 datetime                              --> TIMESTAMP tinyint(1)      default 1      --> bool DEFAULT TRUE int(1)  --> SMALLINT int(2)  --> SMALLINT

数据sql文件

# 日期字段修改 sysdate()           -->                  NOW() # bool 字段对应的数据 1            -->                 true # 转义字符 \'            -->                ''

更新自增序列

DO $$ DECLARE     table_record  RECORD;     sequence_name TEXT;     max_value     BIGINT; BEGIN     -- 遍历所有表及其主键列     FOR table_record IN (         SELECT c.table_name, c.column_name         FROM information_schema.columns c         JOIN information_schema.key_column_usage k             ON c.table_name = k.table_name AND c.column_name = k.column_name         WHERE c.table_schema = 'public'           AND k.ordinal_position = 1           AND c.table_name NOT LIKE 'qrtz%'           AND c.table_name NOT IN ('sys_role_dept', 'sys_role_menu', 'sys_user_role')           AND c.data_type = 'bigint' -- 确保主键列是 bigint 类型     )     LOOP         -- 构建序列名称         sequence_name := table_record.table_name || '_' || table_record.column_name || '_seq';          -- 获取主键列的最大值         EXECUTE 'SELECT COALESCE(MAX(' || table_record.column_name || '), 0) FROM ' ||                 table_record.table_name INTO max_value;          -- 打印日志         RAISE NOTICE 'Updating sequence for table: %, column: %, max_value: %',                      table_record.table_name, table_record.column_name, max_value;          -- 更新序列值         EXECUTE 'SELECT setval(''public.' || sequence_name || ''', ' || (max_value + 1) || ', false)';     END LOOP; END $$;

代码

全局搜XML替换

sysdate()  -->                  now() ifnull(   -->              COALESCE( m.status = 0   -->        m.status = '0'     `query`   -->        query

修改date_format方法

# SysOperLogMapper.xml AND oper_time &gt;= #{params.beginTime}   ==> and oper_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd') AND oper_time &lt;= #{params.endTime}    ==>  and oper_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')  # SysUserMapper.xml AND date_format(u.create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d') ==>  AND u.create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd')  AND date_format(u.create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d') ==> AND u.create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')   # SysConfigMapper.xml and date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d') ==>  and create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd')  and date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d') ==>   and create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')  # GenTableMapper.xml  AND date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d') ==>  and create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd') AND date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d') ==>   and create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')  # SysJobLogMapper.xml and date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d') ==>  and create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd') and date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d') ==>   and create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')  #SysDictTypeMapper.xml and date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d') ==>  and create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd') and date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d') ==>   and create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')  #SysRoleMapper.xml and date_format(r.create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d') ==>  and r.create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd') and date_format(r.create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d') ==>   and r.create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')

修改find_in_set方法

有3处

find_in_set(#{deptId}, ancestors)  cast( #{deptId} as VARCHAR) = ANY (string_to_array(ancestors,','))

修改 GenTableMapper.xml

pgsql information_schema.tables 不会存储表的创建时间或更新时间所以关于根据时间查询的条件需要删除

 SELECT table_name,  obj_description((table_schema || '.' || table_name)::regclass, 'pg_class') AS table_comment FROM information_schema.tables WHERE table_schema = current_schema();

selectDbTableList

<select id="selectDbTableList" parameterType="GenTable" resultMap="GenTableResult">   select table_name, table_comment, create_time, update_time from information_schema.tables   where table_schema = (select database())   AND table_name NOT LIKE 'qrtz\_%' AND table_name NOT LIKE 'gen\_%'   AND table_name NOT IN (select table_name from gen_table)   <if test="tableName != null and tableName != ''">    AND lower(table_name) like lower(concat('%', #{tableName}, '%'))   </if>   <if test="tableComment != null and tableComment != ''">    AND lower(table_comment) like lower(concat('%', #{tableComment}, '%'))   </if>   <if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->    and create_time &gt;= to_date(#{params.beginTime},'yyyy-MM-dd')   </if>   <if test="params.endTime != null and params.endTime != ''"><!-- 结束时间检索 -->    and create_time &lt;= to_date(#{params.endTime},'yyyy-MM-dd')   </if>         order by create_time desc  </select>   修改为   <select id="selectDbTableList" parameterType="GenTable" resultMap="GenTableResult">   SELECT table_name,  obj_description((table_schema || '.' || table_name)::regclass, 'pg_class') AS table_comment   FROM information_schema.tables   WHERE table_schema = current_schema()   AND table_name NOT LIKE 'qrtz\_%' AND table_name NOT LIKE 'gen\_%'   AND table_name NOT IN (select table_name from gen_table)   <if test="tableName != null and tableName != ''">    AND lower(table_name) like lower(concat('%', #{tableName}, '%'))   </if>   <if test="tableComment != null and tableComment != ''">    AND lower(obj_description((table_schema || '.' || table_name)::regclass, 'pg_class')) like lower(concat('%', #{tableComment}, '%'))   </if>   </select>

selectDbTableListByNames

   <select id="selectDbTableListByNames" resultMap="GenTableResult">   select table_name, table_comment, create_time, update_time from information_schema.tables   where table_name NOT LIKE 'qrtz\_%' and table_name NOT LIKE 'gen\_%' and table_schema = (select database())   and table_name in      <foreach collection="array" item="name" open="(" separator="," close=")">     #{name}         </foreach>  </select>      修改为     <select id="selectDbTableListByNames" resultMap="GenTableResult">   SELECT table_name,  obj_description((table_schema || '.' || table_name)::regclass, 'pg_class') AS table_comment   FROM information_schema.tables   where table_name NOT LIKE 'qrtz\_%' and table_name NOT LIKE 'gen\_%' and table_schema = current_schema()   and table_name in      <foreach collection="array" item="name" open="(" separator="," close=")">     #{name}         </foreach>  </select>

selectTableByName

 <select id="selectTableByName" parameterType="String" resultMap="GenTableResult">   select table_name, table_comment, create_time, update_time from information_schema.tables   where table_comment <![CDATA[ <> ]]> '' and table_schema = (select database())   and table_name = #{tableName}  </select>    修改为   <select id="selectTableByName" parameterType="String" resultMap="GenTableResult">   SELECT table_name,  obj_description((table_schema || '.' || table_name)::regclass, 'pg_class') AS table_comment   FROM information_schema.tables   where table_comment <![CDATA[ <> ]]> '' and table_schema = current_schema()   and table_name = #{tableName}  </select>

修改 GenTableColumnMapper.xml

    <select id="selectDbTableColumnsByName" parameterType="String" resultMap="GenTableColumnResult">   select column_name, (case when (is_nullable = 'no' <![CDATA[ && ]]> column_key != 'PRI') then '1' else '0' end) as is_required, (case when column_key = 'PRI' then '1' else '0' end) as is_pk, ordinal_position as sort, column_comment, (case when extra = 'auto_increment' then '1' else '0' end) as is_increment, column_type   from information_schema.columns where table_schema = (select database()) and table_name = (#{tableName})   order by ordinal_position  </select>    修改为   <select id="selectDbTableColumnsByName" parameterType="String" resultMap="GenTableColumnResult">         SELECT             column_name,             CASE                 WHEN is_nullable = 'NO' AND NOT EXISTS (                     SELECT 1                     FROM information_schema.key_column_usage kcu                     WHERE kcu.table_schema = c.table_schema                       AND kcu.table_name = c.table_name                       AND kcu.column_name = c.column_name                 ) THEN '1'                 ELSE '0'                 END AS is_required,             CASE                 WHEN EXISTS (                     SELECT 1                     FROM information_schema.key_column_usage kcu                     WHERE kcu.table_schema = c.table_schema                       AND kcu.table_name = c.table_name                       AND kcu.column_name = c.column_name                 ) THEN '1'                 ELSE '0'                 END AS is_pk,             ordinal_position AS sort,             col_description((quote_ident(c.table_schema) || '.' || quote_ident(c.table_name))::regclass, ordinal_position) AS column_comment,             CASE                 WHEN column_default LIKE 'nextval(%' THEN '1'                 ELSE '0'                 END AS is_increment,             data_type ||             CASE                 WHEN character_maximum_length IS NOT NULL THEN '(' || character_maximum_length || ')'                 WHEN numeric_precision IS NOT NULL THEN '(' || numeric_precision || ',' || numeric_scale || ')'                 ELSE ''                 END AS column_type         FROM             information_schema.columns c         WHERE             c.table_schema = current_schema()           AND c.table_name = (#{tableName})         ORDER BY             ordinal_position;  </select>

pip安装包－复制、安装到离线服务器里

Tue, 11 Mar 2025 03:39:31 GMT

生成当前的依赖文件列表

pip freeze >requirements.txt

下载requirements文件中的依赖

pip download -r requirements.txt -d packages/

这里会新建一个packages的文件夹，把包的相关信息下载下来

复制packages/到对应离线服务器然后执行一下命令

pip install --no-index --find-links=./packages -r ./requirements.txt

./packages是指定依赖包路径，./requirements.txt是指定依赖包列表路径

验证安装

pip list

python打包gradio 项目exe

Tue, 11 Mar 2025 03:20:00 GMT

安装打包工具

pip install pyinstaller

进行打包

使用命令 pyinstaller -F app.py 进行打包，其输出如下所示

505731 INFO: Copying icon to EXE 505735 INFO: Copying 0 resources to EXE 505736 INFO: Embedding manifest in EXE 505784 INFO: Appending PKG archive to EXE 505838 INFO: Fixing EXE headers 519361 INFO: Building EXE from EXE-00.toc completed successfully. 520246 INFO: checking COLLECT 520246 INFO: Building COLLECT because COLLECT-00.toc is non existent 520246 INFO: Building COLLECT COLLECT-00.toc 542317 INFO: Building COLLECT COLLECT-00.toc completed successfully.

运行exe

[Errno 2] No such file or directory: gradio_client\types.json

这是由于pyinstaller 没有准确的识别出用于代码中gradio_client与gradio库的依赖项，需要将打包命令修改下命令即可，也就是补充上 --collect-data=gradio_client --collect-data=gradio ,完整命令如下：

pyinstaller -F app.py --collect-data=gradio_client --collect-data=gradio

运行还是报错缺少其他文件,反复发现缺少好多依赖....

查看当前所有依赖

pip freeze

继续打包

pyinstaller --onefile  --collect-all aiofiles --collect-all annotated_types --collect-all anyio --collect-all certifi --collect-all charset_normalizer --collect-all click --collect-all colorama --collect-all dateutil --collect-all fastapi --collect-all ffmpy --collect-all filelock --collect-all fsspec --collect-all gradio --collect-all gradio_client --collect-all groovy --collect-all h11 --collect-all httpcore --collect-all httpx --collect-all huggingface_hub --collect-all idna --collect-all jinja2 --collect-all lxml --collect-all markdown_it --collect-all markupsafe --collect-all mdurl --collect-all multipart --collect-all numpy --collect-all opencc --collect-all orjson --collect-all packaging --collect-all pandas --collect-all pillow --collect-all pip --collect-all pydantic --collect-all pydantic_core --collect-all pydub --collect-all pygments --collect-all python_multipart --collect-all pytz --collect-all requests --collect-all rich --collect-all ruff --collect-all safehttpx --collect-all semantic_version --collect-all setuptools --collect-all shellingham --collect-all sniffio --collect-all starlette --collect-all tomlkit --collect-all tqdm --collect-all typer --collect-all tzdata --collect-all urllib3 --collect-all uvicorn --collect-all websockets --collect-all wheel app.py

再次执行时出现以下报错

FileNotFoundError: [Errno 2] No such file or directory: gradio\blocks_events.pyc

这是由于gradio库中的代码都是pyi文件，而pyinstaller 在打包时默认库中的都是pyc文件，故而需要修改spec文件，指定对gradio库下的代码进行编译。

生成spec文件

pyi-makespec --onefile  --collect-all aiofiles --collect-all annotated_types --collect-all anyio --collect-all certifi --collect-all charset_normalizer --collect-all click --collect-all colorama --collect-all dateutil --collect-all fastapi --collect-all ffmpy --collect-all filelock --collect-all fsspec --collect-all gradio --collect-all gradio_client --collect-all groovy --collect-all h11 --collect-all httpcore --collect-all httpx --collect-all huggingface_hub --collect-all idna --collect-all jinja2 --collect-all lxml --collect-all markdown_it --collect-all markupsafe --collect-all mdurl --collect-all multipart --collect-all numpy --collect-all opencc --collect-all orjson --collect-all packaging --collect-all pandas --collect-all pillow --collect-all pip --collect-all pydantic --collect-all pydantic_core --collect-all pydub --collect-all pygments --collect-all python_multipart --collect-all pytz --collect-all requests --collect-all rich --collect-all ruff --collect-all safehttpx --collect-all semantic_version --collect-all setuptools --collect-all shellingham --collect-all sniffio --collect-all starlette --collect-all tomlkit --collect-all tqdm --collect-all typer --collect-all tzdata --collect-all urllib3 --collect-all uvicorn --collect-all websockets --collect-all wheel app.py

隐藏控制台

添加以下参数 --noconsole

pyi-makespec --onefile --noconsole --collect-all aiofiles --collect-all annotated_types --collect-all anyio --collect-all certifi --collect-all charset_normalizer --collect-all click --collect-all colorama --collect-all dateutil --collect-all fastapi --collect-all ffmpy --collect-all filelock --collect-all fsspec --collect-all gradio --collect-all gradio_client --collect-all groovy --collect-all h11 --collect-all httpcore --collect-all httpx --collect-all huggingface_hub --collect-all idna --collect-all jinja2 --collect-all lxml --collect-all markdown_it --collect-all markupsafe --collect-all mdurl --collect-all multipart --collect-all numpy --collect-all opencc --collect-all orjson --collect-all packaging --collect-all pandas --collect-all pillow --collect-all pip --collect-all pydantic --collect-all pydantic_core --collect-all pydub --collect-all pygments --collect-all python_multipart --collect-all pytz --collect-all requests --collect-all rich --collect-all ruff --collect-all safehttpx --collect-all semantic_version --collect-all setuptools --collect-all shellingham --collect-all sniffio --collect-all starlette --collect-all tomlkit --collect-all tqdm --collect-all typer --collect-all tzdata --collect-all urllib3 --collect-all uvicorn --collect-all websockets --collect-all wheel app.py

修改spec文件

添加gradio的编译

a = Analysis(     ['app.spec'],     pathex=[],     binaries=binaries,     datas=datas,     hiddenimports=hiddenimports,     hookspath=[],     hooksconfig={},     runtime_hooks=[],     excludes=[],     noarchive=False,     module_collection_mode={ 'gradio': 'py',},     optimize=0, )

修改后，删除掉目录下的build文件夹，再次执行 pyinstaller app.spec 即可

成功运行

* Running on local URL:  http://10.211.55.5:7860  To create a public link, set `share=True` in `launch()`.

minio如何配置防盗链

Thu, 27 Feb 2025 03:17:00 GMT

MinIO 是一个开源的对象存储服务器，用于存储大量的数据，同时提供了丰富的功能和 API。配置防盗链可以帮助你控制谁可以访问存储在 MinIO 上的对象。以下是在 MinIO 中配置防盗链的一般步骤：

编辑 config.json 文件：找到 MinIO 服务器的配置文件 config.json，通常位于 MinIO 数据目录中。在该文件中，你需要添加以下内容来启用和配置防盗链：

{        "version": "1",        "s3": {            "v4": {                "domain": "example.com",                "website": {                    "index_document_suffix": "index.html"                },                "region": "us-east-1",                "signature_version": "v4",                "credentials": {                    "access_key_id": "YOUR_ACCESS_KEY",                    "secret_access_key": "YOUR_SECRET_KEY"                }            }        },        "policy": {            "version": "2012-10-17",            "statement": [                {                    "effect": "Allow",                    "principal": "*",                    "action": "s3:GetObject",                    "resource": "arn:aws:s3:::YOUR_BUCKET_NAME/*",                    "condition": {                        "StringLike": {                            "aws:Referer": [                                "http://your-allowed-domain.com/*",                                "https://your-allowed-domain.com/*"                            ]                        }                    }                }            ]        }    }

替换以下内容：

example.com：你的 MinIO 服务器的域名。
YOUR_ACCESS_KEY 和 YOUR_SECRET_KEY：你的 MinIO 访问密钥。
YOUR_BUCKET_NAME：你想要应用防盗链的存储桶名称。
http://your-allowed-domain.com/* 和 https://your-allowed-domain.com/*：允许访问的域名。你可以添加多个允许的域名。

重启 MinIO 服务器：保存并关闭 config.json 文件，然后重启 MinIO 服务器，以使更改生效。
验证配置：确保只有来自允许的域名的请求才能成功获取对象。你可以使用不同的域名和工具来测试是否配置正确。

通过这些步骤，你可以在 MinIO 中配置防盗链以增强数据安全性。

nginx加速缓存导致event-stream消息延迟问题

Thu, 27 Feb 2025 03:07:27 GMT

现象

在开发AI聊天助手功能模块，采用了跟chatGPT官网一样的stream流传输格式。

在建立起连接并且还未断的期间，后端服务器可以主动推送消息给前端。

在页面上能看到的效果就是AI回复的消息是一个字一个字打印出来的，而在浏览器的控制面板可以看到接口的response Content-Type是text/event-stream。

本地调试直接访问后端的地址没有问题,部署到线上,经过nginx后发现有问题.直接显示一段文字，然后卡顿两三秒，然后又是直接显示一段文字。整个过程看起来就很卡顿。

event-stream响应的数据几个chunk的发送时间一致,之前是每个chunk的发送时间都不一样.

排查

一开始还以为内外网的原因,因为一部署上去就走的外网,后来发现通过外网直接访问后台服务器地址也没有问题,才发现是nginx 缓存的事.

解决方案

@PostMapping(value = "/chatStream" , produces = MediaType.TEXT_EVENT_STREAM_VALUE ) public Flux<ChatResponse>  chatStream(@RequestBody AiPrompt aiPrompt, HttpServletResponse response) {   //设置响应头   response.setHeader("X-Accel-Buffering", "no"); }

设置response.setHeader("X-Accel-Buffering", "no");

用于控制 Nginx 的 X-Accel-Buffering 行为的 HTTP 响应头。它通常用于禁用 Nginx 的响应缓冲功能，以便在java 中实现实时输出（例如流式传输或长轮询）。

后面再发送消息就没问题

官方下载 VMware并安装

Thu, 27 Feb 2025 02:47:41 GMT

vmware被博通收购，官网越发的难下载...

软件下载地址

官网：https://www.vmware.com/products/desktop-hypervisor/workstation-and-fusion

点击下载入口，跳转页面需要账号，没有账号可以走注册。正常按流程走注册即可

登录进入，找到my downloads，点击下拉菜单，切换选项到三朵云VMware Cloud Foundation菜单项

mac 版本

如果是Mac 请下载 VMware Fusion

Windows版本

如果是Windows 请下载 VMware Workstation Pro

下载指定版本

同意协议并下载

填写个人信息完成下载

windows镜像下载

官网下载镜像

https://www.microsoft.com/zh-cn/software-download/

如何激活

win11安装过程中，可以选择先安装，后续输入产品序列号

出现问题：输入激活序列号，还是无法激活成功

win+R powershell irm massgrave.dev/get.ps1 | iex

中兴F50随身WiFi设置短信转发教程

Tue, 18 Feb 2025 09:03:00 GMT

F50设备上通过ADB（Android Debug Bridge）进行投屏。以下是一些步骤和注意事项，帮助您顺利完成这个过程：

前提条件

设备连接：确保您的F50设备和电脑通过USB线连接。
开启开发者选项：在设备的设置中启用开发者选项，并打开USB调试。
安装必要的驱动：如果您是通过USB连接，确保电脑上已经安装了相应的USB驱动程序。

安装ADB工具

# 安装 brew install android-platform-tools # 查看版本 adb version

以上是mac安装,其他系统安装ADB工具，可以从Android官网下载并安装。

开启USB端口

访问 http://192.168.0.1/ 这个地址通常是路由器管理界面的IP地址，请确认这是正确的地址并且您可以正常访问。

访问 http://192.168.0.1/index.html#usb_port 并打开 USB端口

安装投屏软件

选择投屏软件：市面上有很多安卓投屏软件，如Scrcpy、Vysor等。以Scrcpy为例，您可以从其GitHub页面下载并安装。
启动投屏软件
```
./scrcpy 
```

启动失败可以重启一下adb adb kill-server adb start-server

开启ADB

进入开发者选项：
- 打开设备的“设置”应用。
- 滚动到底部，找到并点击“关于手机”。
- 连续点击“版本号”或“构建号”，直到看到提示“您现在是开发者！”。
- 返回设置主菜单，现在应该可以看到“开发者选项”。
- 点击“开发者选项”，然后开启“USB调试”。

使用ADB命令

连接设备：
- 使用USB线将设备连接到电脑，并确保设备已授权调试连接。
验证连接：输入以下命令来验证设备是否成功连接：
```
adb devices 
```
如果设备成功连接，应该会显示设备的序列号。
开启ADB端口：假设您需要通过ADB开启某个特定的功能或服务，可以使用以下命令：
```
adb shell input keyevent KEYCODE_XXX 
```
其中KEYCODE_XXX是您需要模拟的按键代码。例如，开启USB调试模式：
```
adb shell settings put global development_settings_enabled 1 
```
安装短信转发器
```
adb install app/SmsF.apk 
```
短信转发器下载地址 https://github.com/pppscn/SmsForwarder/releases

# 中兴F50 pro 开启ADB setprop sys.usb.config mtp,adb setprop sys.usb.state mtp,adb start adbd

DeepSeek R1架构和训练过程图解

Tue, 11 Feb 2025 08:15:14 GMT

如果你对 AI 感兴趣，可能听说过 DeepSeek R1。它目前在 LLM 领域很流行，并且表现优于开源和闭源模型。

为了让一切变得简单，我们将使用手绘流程图和简单的计算来帮助从头开始澄清DeeoSeek-R1的核心概念。

事实上，我们将在整个文章中使用字符串 2 + 3 * 4 等于多少？作为示例，引导你了解 DeepSeek 技术报告的每个组成部分。

1、快速概览

因此，在介绍技术细节之前，快速概览一下：DeepSeek-R1 不是从头开始训练的，就像从无到有一样。相反，他们从一个非常聪明的 LLM 开始，他们已经有了 DeepSeek-V3，但他们想让它成为推理超级明星。

为此，他们使用了强化学习（简称 RL），当 LLM 做出有利于推理的事情时，你会奖励它，否则会惩罚它。

但这不仅仅是一个简单的训练课程。它就像是一整套步骤，他们称之为管道。他们首先尝试了纯 RL，看看推理是否会自行出现，这就是 DeepSeek-R1-Zero，有点像一个实验。然后对于真正的 DeepSeek-R1，他们通过不同的阶段使其更有条理。他们给它一些起始数据来启动它，然后进行 RL，然后是更多数据，然后是更多 RL……就像一步一步升级一样！

整个重点是让这些语言模型更好地思考问题并为你提供明智的答案，而不仅仅是吐出单词。

所以，是的，在我们研究每个步骤的疯狂细节之前，这是超简短的版本。

2、DeepSeek V3 (MOE) 如何思考？

正如我之前所说，DeepSeek R1 训练不是从头开始构建的，而是使用 DeepSeek V3 作为基础模型。那么我们需要了解 V3 的工作原理以及它为什么被称为 MOE？

DeepSeek V3 有两条主要路径。当你输入问题时，它首先会经过一个记忆系统，该系统通过查找相关信息快速构建上下文。可以将其视为快速回忆你之前遇到过的类似情况。

它的主要优势在于其决策系统。在理解你的输入后，它会使用一个智能路由器在两条路径之间做出决定：快速处理器用于简单的任务（如简单问题或常见请求）和专家系统用于复杂的问题（如分析或专业知识）。

这个路由器使 DeepSeek V3 成为专家混合模型 (MOE)

因为它会动态地将每个请求定向到最合适的专家组件以进行高效处理。

简单的问题通过快速路径获得快速、直接的答案，而复杂的查询则通过专家系统得到详细关注。最后，这些响应被组合成清晰、准确的输出。

3、DeepSeek V3 作为 RL 设置中的策略模型

现在我们已经了解了 DeepSeek v3 的思考方式，它是 DeepSeek R1 实现的起点，我所说的起点是指它已经创建了 DeepSeek R1 Zero版本，这是一个在创建最终版本之前存在一些错误的初始版本。

初始版本（R1 Zero）是使用强化学习创建的，其中 DeepSeek v3 充当 RL 代理（采取行动的参与者）。让我们首先直观地了解它的工作原理。

RL 代理（DeepSeek V3）首先采取行动，这意味着它会为放入其环境中的给定问题生成答案和一些推理。在这种情况下，环境只是推理任务本身。

采取行动后，环境会给予奖励。这个奖励就像反馈，它告诉 DeepSeek V3 基础模型其行动有多好。积极的奖励意味着它做对了某件事，可能得到了正确的答案或推理得很好。然后，这个反馈信号返回到 DeepSeek-V3-Base，帮助它学习和调整未来如何采取行动以获得更好的奖励。

在接下来的部分中，我们将讨论这个带有奖励模型的 RL 设置以及它们使用的 RL 算法并尝试使用我们的文本输入来解决它。

4、GRPO 算法如何工作？

训练 LLM 的计算成本极高，而 RL 则增加了更多的复杂性。

因此，有许多可用的 RL 算法，但传统的 RL 使用一种称为“批评家”的东西来帮助主要决策部分（“参与者”，即 DeepSeek V3），正如你已经知道的那样。这个批评家通常和参与者本身一样大和复杂，这基本上使计算成本翻倍。

然而，GRPO 的做法不同，因为它直接从一组动作的结果中找出基线，即一种良好动作的参考点。因此，GRPO 根本不需要单独的批评家模型。这节省了大量计算并使事情变得更有效率。

它从向模型提出一个问题或提示开始，称为“旧策略”。 GRPO 不会只得到一个答案，而是指示旧策略针对同一问题生成一组不同的答案。然后评估每个答案并给出奖励分数，以反映其好坏程度或可取性。

GRPO 通过将每个答案与其组中其他答案的平均质量进行比较来计算每个答案的“优势”。高于平均水平的答案获得正优势，而低于平均水平的答案获得负优势。至关重要的是，这无需单独的批评模型即可完成。

然后使用这些优势分数来更新旧策略，使其更有可能在未来产生高于平均水平的答案。这个更新的模型成为新的“旧策略”，这个过程重复进行，迭代地改进模型。

5、GRPO 的目标函数

显然，在这个 GRPO 背后，有复杂的数学💀总之，我们可以称之为 GRPO 背后的目标函数。

GRPO 目标

GRPO 的目标函数有两个目标，一个是给出良好的输出（高回报），同时确保训练过程稳定且不会失控。原始函数很吓人，但我们会将其重写为更简单的形式，而不会失去其实际意义。

目标函数（原始与简化）

让我们逐一分解。首先， AverageResult[…] 或 1/n[…] 指的是评估在许多不同情况下平均发生的情况。我们提出一个包含各种问题的模型。对于每个问题，模型都会生成一组答案。通过查看许多问题及其各自的答案组中的这些答案，我们可以计算出平均结果。

平均的含义

在此过程中，问题被输入到旧模型中，该模型会产生多个答案（例如，答案 1、答案 2、...、答案 G）。这些答案形成一个组，通过评估不同问题中的这个组，我们得出平均结果。

SumOf[..] 或 ∑[…] 指的是对一组答案（例如，答案 1、答案 2、...、答案 G）中的每个答案进行计算，然后将所有这些计算的结果加在一起。

然后是奖励部分。这是对给出良好答案的模型进行奖励的部分。它内部有点复杂，让我们放大一下：

公式

ChangeRatio 告诉我们使用新模型给出此答案的几率是增加还是减少。具体来说，它着眼于：

使用新模型的答案几率：新模型给出特定答案的可能性有多大。
使用旧模型的答案几率：旧模型给出相同答案的可能性有多大。

接下来，优势 ( Advantage) 分数表明与同一组中的其他答案相比，答案有多好或多差。它的计算方式如下：

优势公式

答案的分数：给予特定答案的奖励。
组的平均分数：组中所有答案的平均奖励分数。
组中分数的分布：组中答案分数的差异有多大。

Advantage 分数告诉我们答案是否优于该组内的平均水平，以及好多少。

LimitedChangeRatio 公式（

LimitedChangeRatio 是 ChangeRatio 的修改版本。它确保 ChangeRatio 不会波动太大，从而保持模型的学习稳定。限制由一个称为 Epsilon 的小值决定， h 确保变化不会太剧烈。

最后， SmallerOf[ … ] 函数在两个选项中选择较小的值：

ChangeRatio × Advantage：答案可能性的变化，乘以其优势分数。
LimitedChangeRatio × Advantage：相同，但变化率有限。

通过选择较小的值，模型可确保学习过程保持平稳，不会对性能的大幅变化反应过度。结果是“好答案奖励”，鼓励模型改进而不会过度补偿。

最后，我们减去 StayStablePart。这是为了防止新模型发生太大的变化。它不是很复杂，但让我们放大它：

StayStable 方程

DifferenceFromReferenceModel 测量新模型与参考模型（通常是旧模型）的差异。本质上，它有助于评估新模型与前一个模型相比所做的更改。

Beta 值控制模型应保持与参考模型的接近程度。较大的 Beta 意味着模型将优先保持更接近旧模型的行为和输出，以防止偏差太大。让我们将其可视化：

StayStable 的视觉表示

简而言之， StayStablePart 确保模型逐渐学习并且不会疯狂跳跃。

6、DeepSeek R1 Zero 的奖励建模

现在我们已经了解了主要的理论概念，让我们使用我们的文本输入来了解创建 R1 Zero 的奖励建模是如何工作的。

请记住，对于 R1 Zero，他们保持简单直接。他们没有使用花哨的神经网络来判断答案（就像他们在后期阶段可能会做的那样），而是使用了基于规则的奖励系统。

对于我们的数学问题：“2 + 3 * 4 等于多少？”

6.1 基于规则的检查

系统知道正确答案是 14。它将查看 DeepSeek V3（我们的 RL 代理）生成的输出，并专门检查 <answer>标签内的内容。

基于规则的检查

如果 <answer>标签包含“14”（或数字相同的内容），它会得到正奖励，比如说 +1。如果它错了，它会得到 0 奖励，甚至可能是负奖励（尽管本文在这个阶段为了简单起见重点关注 0）。

6.2 格式化奖励

但 DeepSeek R1 Zero 还需要学习正确构建其推理，并且可以使用 <think> 和 <answer> 标签，正确设置格式的奖励较少。

格式奖励过程

检查模型输出是否正确地将推理过程包含在 <think> …</think> 中，并将最终答案包含在 <answer>… </answer>中。

DeepSeek R1 论文明确提到避免使用 DeepSeek-R1-Zero 的神经奖励模型，以防止奖励黑客攻击并降低初始探索阶段的复杂性

7、奖励训练模板

为了使奖励模型有效，研究人员设计了一个特定的训练模板。该模板充当蓝图，指导 DeepSeek-V3-Base 如何在强化学习过程中构建其响应。

让我们看看原始模板并将其逐一分解：

A conversation between User and Assistant. The user asks a question, and  the Assistant solves it. The assistant first thinks about the reasoning  process in the mind and then provides the user with the answer. The reasoning  process and answer are enclosed within <think> </think> and <answer> </answer> tags respectively, i.e., <think> reasoning process here </think> <answer> answer here </answer>. User: {prompt}. Assistant:

翻译：用户和助手之间的对话。用户提出问题，助手解决该问题。助手首先在脑海中思考推理过程，然后为用户提供答案。推理过程和答案分别包含在和标签中，即推理过程在这里答案在这里。用户：{prompt}。助手：

我们在 {prompt} 中插入数学问题，例如 2 + 3 * 4 等于多少？。重要的是那些和标签。这种结构化输出对于研究人员以后窥视模型的推理步骤非常重要。

当我们训练 DeepSeek-R1-Zero 时，我们使用此模板为其提供提示。对于我们的示例问题，输入将如下所示：

A conversation between User and Assistant. The user asks a question, and  the Assistant solves it. The assistant first thinks about the reasoning  process in the mind and then provides the user with the answer. The reasoning  process and answer are enclosed within <think> </think> and <answer> </answer> tags respectively, i.e., <think> reasoning process here </think> <answer> answer here </answer>. User: What is 2 + 3 * 4?. Assistant:

翻译：用户和助手之间的对话。用户提出问题，助手解决该问题。助手首先在脑海中思考推理过程，然后为用户提供答案。推理过程和答案分别包含在和标签中，即推理过程在这里答案在这里。用户：2+3*4等于多少？。助手：

我们期望模型生成符合模板的输出，例如：

<think> Order of operations: multiply before add. 3 * 4 = 12. 2 + 12 = 14 </think> <answer> 14 </answer>

翻译：运算顺序：先乘后加。3 * 4 = 12。2 + 12 = 14 14 14

有趣的是，DeepSeek 团队有意保持这个模板简单并专注于结构，而不是告诉模型如何推理。

8、DeepSeek R1 Zero 的强化学习训练过程

尽管本文没有指定强化学习预训练的确切初始数据集，但我们假设它应该以推理为重点。

他们所做的第一步是使用旧策略（即强化学习更新之前的 DeepSeek-V3-Base 模型）生成多个可能的输出。在一次训练迭代中，我们假设 GRPO 采样一组 G = 4 个输出。

例如，该模型为我们的文本输入生成以下四个输出 2 + 3 * 4 等于多少？

o1： <think>2 + 3 = 5, 5 * 4 = 20</think> <answer> 20</answer> （运算顺序不正确）
o2： <think>3 * 4 = 12, 2 + 12 = 14</think> <answer>14</answer> （正确）
o3： <answer>14</answer> （正确，但缺少 <think>标签）
o4： <think>...一些胡言乱语的推理...</think> <answer> 7<answer> （不正确且推理不佳）

生成输出

每个输出将根据正确性和推理质量进行评估并分配奖励。

为了引导模型进行更好的推理，基于规则的奖励系统应运而生。每个输出都根据以下条件分配奖励：

准确度奖励：答案是否正确。
格式奖励：推理步骤是否使用标签正确格式化。

假设奖励分配如下：

输出	准确率奖励	格式奖励	总奖励
o1（推理错误）	0	0.1	0.1
o2（推理正确）	1	0.1	1.1
o3（正确但缺少标签）	1	0	1.0
o4（推理错误且较差）	0	0.1	0.1

奖励细分

模型应该学会偏爱奖励更高的输出，同时降低生成不正确或不完整输出的概率。

为了确定每个输出对模型性能的改善或恶化程度，我们使用奖励值计算优势。优势有助于通过强化更好的输出来优化策略。

为此，让我们计算平均第一个奖励。

平均奖励计算

标准差（近似值）= 0.5，现在计算每个输出的优势。

计算每个输出的奖励

可视化优势计算

输出 o2 和 o3 获得正优势，这意味着应该鼓励它们。输出 o1 和 o4 获得负优势，这意味着应该阻止它们。

然后，GRPO 使用计算出的优势来更新策略模型 (DeepSeek-V3-Base)，以增加生成具有高优势的输出（如 o2 和 o3）的概率，并降低具有低优势或负优势的输出（如 o1 和 o4）的概率。

更新根据以下内容调整模型权重：

策略比率：在新策略与旧策略下生成输出的概率。
裁剪机制：防止过大的更新，这可能会破坏训练的稳定性。
KL 发散惩罚：确保更新不会偏离原始模型太远。

GRPO 工作

这确保在下一次迭代中，模型更有可能生成正确的推理步骤，同时减少不正确或不完整的响应。

因此，RL 是一个迭代过程。使用不同的推理问题重复上述步骤数千次。每次迭代都会逐渐提高模型的能力：

执行正确的操作顺序
提供逻辑推理步骤
始终使用正确的格式

整体训练循环如下所示：

DeepSeek 简化训练过程

随着时间的推移，模型会从错误中吸取教训，在解决推理问题方面变得更加准确和有效。 🚀

9、R1 Zero 的两个主要问题

在 V3 模型上使用 RL 训练过程创建 DeepSeek-R1 Zero 后，研究人员发现训练后的模型在推理测试中表现非常出色，甚至在 AIME 2024 等任务上的得分与 OpenAI-01-0912 等更高级的模型相似。这表明使用强化学习 (RL) 来鼓励语言模型中的推理是一种很有前途的方法。

但他们也注意到 DeepSeek-R1-Zero 有一些关键问题需要解决，才能在现实世界中使用并进行更广泛的研究。

R1 Zero 的问题（

DeepSeek 的研究人员表示，该模板有意简单且结构集中。它避免对推理过程本身施加任何特定于内容的限制。例如，它没有说：

“你必须使用分步推理”（它只是说“推理过程”，让模型来定义它的含义）。
“你必须使用反思性推理”
“你必须使用特定的问题解决策略”

主要问题是标签内的推理过程难以阅读，使人类难以理解和分析。

另一个问题是语言混合，当被问到多语言问题时，模型有时会在同一个回答中混合使用多种语言，导致输出不一致和混乱。如果你用西班牙语问它问题。突然间，它的“思维”就会变成英语和西班牙语的混杂，不太完美！这些问题，混乱的推理和语言混乱，是明显的障碍。

这是他们将最初的 R1 Zero 模型转变为 R1 的两个主要原因

在下一节中，我们将介绍他们如何将 R1 zero 模型改进为 R1 模型，从而提高其性能并帮助其胜过所有其他模型（无论是开源的还是封闭的）。

10、冷启动数据

因此，为了修复 R1 Zero 问题并真正让 DeepSeek 推理正确，研究人员进行了冷启动数据收集并包括监督微调。

你可以将其视为在真正激烈的 RL 训练之前为模型提供良好的推理基础。基本上，他们想教 DeepSeek-V3 Base 良好的推理是什么样子以及如何清晰地呈现它。

10.1 使用长 CoT 进行少量提示

他们为 DeepSeek-V3 Base 提供了一些问题示例以及非常详细的分步解决方案，称为思维链 (CoT)。这个想法是让模型通过示例学习并开始模仿这种分步推理风格。

让我们直观地了解这个基于示例的学习：

基于示例的学习

对于我们的示例问题 2 + 3 * 4 等于多少？，他们可能会显示如下提示：

Problem Examples with Solutions:  Problem: What's the square root of 9 plus 5? Solution: | special_token | First, find the square root of 9, which is 3.  Then, add 5 to 3.  3 + 5 equals 8. | special_token | Summary: The answer is 8.  Problem: Train travels at 60 mph for 2 hours, how far? Solution: | special_token | Use the formula: Distance = Speed times Time.  Speed is 60 mph, Time is 2 hours. Distance = 60 * 2 = 120 miles.  | special_token | Summary: Train travels 120 miles.  Problem: What is 2 + 3 * 4? Solution:

那些 | special_token | 东西只是将推理步骤与摘要分开的标记，使模型可以清楚地学习结构。

看到这些示例后，模型应该学会以类似的格式给出答案，例如 2 + 3 * 4 等于多少？

| special_token |  Following order of operations (PEMDAS/BODMAS),  do multiplication before addition.  So, first calculate 3 * 4 = 12.  Then, add 2 to 12. 2 + 12 = 14. | special_token | Summary: The answer is 14.

10.2 直接提示

他们收集数据的另一种方法是直接提示模型不仅解决问题，而且还要逐步明确地展示其推理，然后仔细检查其答案。

直接提示

这是为了促进更仔细和周到的问题解决。

对于 2 + 3 * 4 等于多少？，提示可能是：

Problem: Solve this, show reasoning step-by-step, and verify: What is 2 + 3 * 4?

他们确实期望输出包含推理步骤和验证部分：

| special_token | Reasoning: To solve 2 + 3 * 4, I need to use order of  operations. Multiplication comes before addition. Step 1: Calculate 3 * 4 = 12. Step 2: Add 2 to the result from step 1: 2 + 12 = 14. Verification:  Checking order of operations again, yes, multiplication  is before addition.  Calculation looks right. | special_token | Summary: The answer is 14.

10.3 后处理细化

他们甚至使用了已经训练过的 R1 Zero 模型的输出。尽管 R1 Zero 存在问题，但它可以进行一些推理。因此，他们采用了 R1 Zero 的输出，并让人类标注者使其更清晰、更结构化，并纠正任何错误。

例如，混乱的 R1 Zero 输出可能是：

<think>  ummm... multiply 3 and 4... get 12... then add 2...</think> <answer> 14 </answer>

然后人类会对其进行改进，使其更清晰、格式更好：

| special_token | Reasoning: To solve this, we use order of operations, doing multiplication before addition. Step 1: Multiply 3 by 4, which is 12. Step 2: Add 2 to the result: 2 + 12 = 14. | special_token | Summary: The answer is 14.

可视化细化过程的工作原理如下：

细化过程

他们最终获得的冷启动数据非常好，因为：

高质量推理示例：每个示例都展示了良好的逐步推理。
一致、可读的格式： | special_token | 格式使所有内容统一且易于处理。
人工检查：他们确保过滤掉任何不好的例子，因此数据干净可靠。

获得此冷启动数据后，他们进行了监督微调 (SFT)。

11、监督微调

SFT 第 1 阶段的核心思想是使用监督学习来教 DeepSeek-V3-Base 如何产生高质量、结构化的推理输出。

基本上，我们向模型展示了许多良好推理的例子，并要求它学习模仿这种风格。

对于 SFT，我们需要将冷启动数据格式化为输入-目标对。对于数据集中的每个推理问题，我们都会创建一个这样的对：

输入 = 提示或问题描述本身

User: What is 2 + 3 * 4? Assistant:

这是我们输入到模型中的内容，我们的目标是相应的结构良好的推理和答案

| special_token | According to the order of operations (PEMDAS/BODMAS) ...  Summary: The answer is 14.

这是我们希望模型学习生成的理想输出。

我们告诉模型：

当你看到此输入（问题）时，我们希望你产生此目标输出（良好的推理和答案）

与其用详细的文字解释并让你难以理解，不如先将其可视化，以便更容易解释 SFT

SFT 流程

微调过程从输入开始：提示 + 目标推理，我们在此提供一个问题和一个结构化的推理示例。这会训练模型（DeepSeek-V3-Base 模型）以生成结构良好的响应。

在预测下一个标记中，模型会生成推理序列中的下一个单词。使用损失函数将其与比较目标标记（计算损失）中的实际下一个标记进行比较。损失越大，意味着预测距离正确标记越远。

在更新模型参数中，反向传播和优化器会调整模型的权重以

改进其预测。这个过程循环往复，重复许多输入目标对，每次迭代逐渐提高模型结构化推理能力。

12、推理导向强化学习

他们已经为 DeepSeek V3 提供了 SFT 推理教育，但为了真正提高其推理能力，研究人员引入了推理导向学习！

在这里，我们采用 SFT 微调的 DeepSeek-V3 模型，并通过强化学习推动它变得更好。

他们确实使用了相同的 GRPO 算法，但这一阶段真正的升级是奖励系统。他们添加了一些新的、非常重要的语言一致性奖励！

还记得 R1 Zero 有时会对语言感到困惑并开始混淆它们吗？为了解决这个问题，他们专门增加了保持语言一致性的奖励。这个想法很简单，如果你用英语问问题，我们希望推理和答案也是用英语。

让我们直观地了解一下这个语言一致性奖励计算：

一致性奖励计算

为了理解上面的图表，让我们重新回顾之前的示例输出 o1 和 o2，看看奖励如何随着这个新的语言一致性奖励而变化。为简单起见，我们假设目标语言是英语。

让我们看看这些奖励如何与我们的示例输出一起发挥作用。考虑第一个输出 o1，它错误地计算了“2 + 3 * 4”，但用英语呈现了其有缺陷的推理：

<think> 2 + 3 = 5, 5 * 4 = 20 </think> <answer> 20 </answer>

对于这个，准确度奖励自然是 0，因为答案是错误的。但是，由于假设推理 100% 使用目标语言（本例中为英语），因此它获得的语言一致性奖励为 1。

当我们计算 RL 阶段的总奖励时，我们会将这些结合起来。如果我们为准确度奖励分配权重 1，为语言一致性奖励分配较小的权重（例如 0.2），则 o1 的总奖励变为：

Total Reward = (1 * Accuracy Reward) + (0.2 * Language Consistency Reward)  (1 * 0) + (0.2 * 1) = 0.2

现在考虑输出 o2，它正确解决了问题并且还用英语进行推理：

<think> 3 * 4 = 12, 2 + 12 = 14 </think> <answer> 14 </answer>

此输出因正确答案而获得完美的准确度奖励 1。假设它的推理也是 100% 英语，它也会获得 1 的语言一致性奖励。使用与之前相同的权重，o2 的总奖励为：

(1 * 1) + (0.2 * 1) = 1.2

请注意，语言一致性奖励如何略微提高正确答案的总奖励，甚至为错误答案 o1 提供小幅正奖励，只要它保持语言一致性。

此 RL 训练循环遵循我们之前看到的相同 DeepSeek R1 Zero 训练循环：

推理导向循环

生成多个输出。
细化奖励，包括语言一致性。
使用 GRPO 进行优势估计。
训练模型以支持高优势输出。
重复该过程！

13、拒绝抽样

对于推理数据，DeepSeek 团队希望获得绝对最佳示例以进一步训练模型。为此，他们使用了一种称为拒绝抽样的技术。

拒绝抽样

为了改进推理数据，DeepSeek 使用了拒绝抽样。对于“2 + 3 * 4 等于多少？”，他们会从上一阶段模型生成许多输出。想象一下得到 20（错误）和 14 …（正确，推理）这样的输出。

然后他们会评估每个输出的正确性（答案“14”）和推理的可读性。只有正确且推理充分的最佳输出才会被保留，而其他输出则被拒绝。

对于复杂的推理，生成奖励模型用于判断推理质量。严格的过滤器会删除混合语言、漫无边际的推理或不相关的代码。此过程会产生约 600k 个高质量推理样本。

除了精炼推理数据外，他们还添加了非推理数据（约 20 万个样本），用于一般技能：写作、问答、翻译等，有时还会使用思维链来完成复杂任务。

最后，SFT 第 2 阶段使用下一个标记预测在组合数据集（精炼推理 + 非推理）上训练前一个模型检查点。此阶段使用来自拒绝采样的顶级示例进一步改进推理，并将模型推广到更广泛的任务，同时保持用户友好性。

“2 + 3 * 4 等于多少？”现在是一个完美精炼的推理示例，成为此训练数据的一部分。

这是拒绝采样，我们拒绝低于标准的样本，只保留最好的样本以生成高质量的训练数据

14、适用于所有场景的 RL

在 SFT 第 2 阶段之后，我们获得了 DeepSeek V3 推理、一致说话，甚至很好地处理了一般任务！但要真正使其成为顶级的人工智能助手，研究人员必须与人类价值观进行最后的调整。这就是强化学习在所有场景中的使命（强化学习第 2 阶段）！把它看作是让DeepSeek R1真正安全的最后一道工序。

最终 RL 步骤

对于我们的示例“2 + 3 * 4 等于多少？”虽然准确度奖励仍然强化了正确答案，但奖励系统现在还考虑：

有用性，评估摘要（如果生成）是否提供了除答案之外的有用背景。
无害性，检查整个输出是否安全且无偏见。这些通常由根据人类偏好训练的单独奖励模型进行评估。

最终的奖励信号成为准确度、有用性和无害性分数的加权组合。

现在，训练数据包括

多样化组合，包括推理问题
一般 QA 提示
写作任务
和偏好对，其中人类指出两个模型输出中的哪一个在有用性和无害性方面更好。

训练过程遵循迭代 RL 循环（可能使用 GRPO）以根据来自这些多样化数据的组合奖励信号优化模型。

经过多次训练迭代后，模型得到改进，在推理性能和一致性（有用性/无害性）之间取得良好平衡。一旦达到这种平衡，模型就会在流行的基准数据集上进行评估，并超越其他模型的性能。

他们的最终检查点，高度优化的版本被命名为 DeepSeek-R1

15、蒸馏

R1 的蒸馏

在 DeepSeek 团队能够创建性能良好的 DeepSeek R1 后，他们进一步将更大的模型提炼为性能更高的小型模型，供社区使用，蒸馏过程的工作原理如下：

数据准备：收集 800k 个推理样本。
DeepSeek-R1 输出：对于每个样本，教师模型（DeepSeek-R1）的输出用作学生模型的目标。
监督式微调 (SFT)：学生模型（例如 Qwen-1.5B、Llama-14B）基于这 800k 个样本进行微调，以匹配 DeepSeek-R1 输出。
蒸馏模型：学生模型现在被精炼成更小的版本，但保留了 DeepSeek-R1 的大部分推理能力。
结果：你将获得更小、更快且具有良好推理能力的模型，随时可以部署。

原文链接：Drawing DeepSeek R1 Architecture and Training Process from Scratch

VMware ESXi 添加证书

Mon, 10 Feb 2025 02:22:00 GMT

VMware ESXi都是强制使用HTTPS 去访问网页控制台的，浏览器就会疯狂提示安全性问题。这会带来非常多的不方便。

网页导入

通过主机管理界面-安全和用户-证书-导入证书PEM 然后点击保存后，恭喜你ESXi报错了。

因为ESXi的SSL证书只支持通过ESXi内置文件去申请SSL证书从而下载的证书PEM才可以导入进去。

手动上传

开启SSH

进入上传目录

cd /etc/vmware/ssl/

重命名

# 需要替换的对应关系如下： xxxxxx.key -> rui.key xxxxxx.crt -> rui.crt # 复制创建文件  vi rui.crt  vi rui.key

Let’s Encrypt的证书不能使用,需要注意的是先备份原证书,而且要备份到外部设备,如果只是改个名字重启后就会被删除.腾讯云的免费证书可以用

重启服务

services.sh restart

关闭SSH

记得关闭SSH!

10 Essential Terminal Commands Every Developer Should Know

Tue, 07 Jan 2025 08:12:00 GMT

List of useful Unix terminal commands to boost your productivity. Here are some of my favorites.

Sometimes, tasks that might take hours to code can be accomplished in minutes with the terminal.

This article assumes you’re already comfortable with basic commands like rm, pwd, and cd.

grep

Need to find where a function or variable is used in your codebase, or sift through logs to locate specific entries? grep can help you with that.

The grep command searches for specific patterns in files. It’s like having a supercharged search function that digs into file contents.

The basic syntax for the grep command goes as the following;

Terminal window

➜ grep "let's find something" file.[txt,json,js,md,etc]

Case-insensitive search: Add the -i flag to ignore case differences.

Terminal window

➜ grep -i "REact" compiler/apps/playground/app/index.tsx ? '[DEV] React Compiler Playground' : 'React Compiler Playground'

Count occurrences: Use the -c flag to count the number of matching lines.

Terminal window

➜ grep -c "React" compiler/apps/playground/app/index.tsx

Analyzing logs: If you’re troubleshooting an issue, you can use grep to find specific error messages in logs.

Terminal window

➜ grep -i "Operation not supported on socket" system.log 09/24 08:51:01 INFO   :..settcpimage: Get TCP images rc - EDC8112I Operation not supported on socket.

Search for Multiple Patterns: You can search for multiple patterns by using the -e flag multiple times.

Match either “error” or “404” in system.log.

Terminal window

➜ grep -e "error" -e "404" system.log npm error code E404 npm error 404  'trevorlasn.com@*' is not in this registry. npm error A complete log of this run can be found in: /Users/trevorindreklasn/.npm/_logs/2024-08-20T16_41_32_846Z-debug-0.log

Recursive Search: To search for a pattern in all files within a directory and its subdirectories, use the -r (or —recursive) flag.

Terminal window

➜ grep -o -r "fs" node_modules | wc -l 22491

This will search through all files in the specified directory and its subdirectories. The -o option tells grep to print only the matched parts of the line.

The pipe | takes the output from the command on the left (grep) and uses it as input for the command on the right (wc -l). wc -l counts and displays the number of lines in its input.

man

The man command stands for “manual.” It helps you find detailed information about other commands and programs.

Terminal window

➜ man grep  NAME      grep, egrep, fgrep, rgrep, bzgrep, bzegrep, bzfgrep, zgrep,      zegrep, zfgrep – file pattern searcher  SYNOPSIS      grep [-abcdDEFGHhIiJLlMmnOopqRSsUVvwXxZz] [-A num] [-B num]           [-C num] [-e pattern] [-f file] [--binary-files=value]           [--color[=when]] [--colour[=when]] [--context=num]           [--label] [--line-buffered] [--null] [pattern] [file ...]  DESCRIPTION      The grep utility searches any given input files, selecting      lines that match one or more patterns.  By default, a pattern      matches an input line if the regular expression (RE) in the      pattern matches the input line without its trailing newline.      An empty expression matches every line.  Each input line that      matches at least one of the patterns is written to the standard      output.       grep is used for simple patterns and basic regular expressions      (BREs); egrep can handle extended regular expressions (EREs).      See re_format(7) for more information on regular expressions.      fgrep is quicker than both grep and egrep, but can only handle      fixed patterns (i.e., it does not interpret regular      expressions).  Patterns may consist of one or more lines,      allowing any of the pattern lines to match a portion of the      input.       zgrep, zegrep, and zfgrep act like grep, egrep, and fgrep,      respectively, but accept input files compressed with the      compress(1) or gzip(1) compression utilities.  bzgrep, bzegrep,      and bzfgrep act like grep, egrep, and fgrep, respectively, but      accept input files compressed with the bzip2(1) compression      utility.       The following options are available:       -A num, --after-context=num              Print num lines of trailing context after each match.              See also the -B and -C options.              ...

cat

The cat command is short for “concatenate.” It’s used to display the contents of a file, combine files, or create new ones.

Terminal window

➜  trevorlasn.com git:(master) ✗ cat astro.config.mjs import { defineConfig } from "astro/config"; import mdx from "@astrojs/mdx"; import sitemap from "@astrojs/sitemap"; import tailwind from "@astrojs/tailwind"; import vercel from "@astrojs/vercel/static"; import partytown from "@astrojs/partytown";  // https://astro.build/config export default defineConfig({   site: "https://www.trevorlasn.com",   integrations: [ mdx(), sitemap(), tailwind(), partytown({     config: {       forward: ["dataLayer.push"]     }   }), ],   output: "static",   adapter: vercel(), });

Combining Files: One of the key features of cat is its ability to combine multiple files into one. For instance, if you want to merge file1.txt and file2.txt into file3.txt, you can do this:

Terminal window

➜ cat file1.txt file2.txt > file3.txt

This command above takes the content of file1.txt and file2.txt and merges them into file3.txt. The > operator is used to direct the combined output into a new file.

Creating New Files: You can also use cat to create new files. Type your text, and when you’re done, press Ctrl+D to save and exit.

Terminal window

➜ cat > newfile.txt hey ➜ ls newfile.txt ➜ cat newfile.txt hey

cat is helpful for viewing smaller files, but for very large files, it can be overwhelming as it dumps everything at once. In such cases, it’s better to use commands like less or head to view files in a more controlled way.

head

You often don’t need to see all the content when working with large files. Instead of using cat to display everything, the head command lets you preview just the first few lines of a file.

This is especially useful for checking the structure of CSV files, logs, or any other large text files.

By default, head shows the first 10 lines of a file:

Terminal window

➜  trevorlasn.com git:(master) ✗ head package-lock.json {   "name": "trevorlasn.com",   "version": "1.0.0",   "lockfileVersion": 3,   "requires": true,   "packages": {     "": {       "name": "trevorlasn.com",       "version": "1.0.0",       "dependencies": {

If you need more or fewer lines, you can specify the exact number using the -n option:

Terminal window

➜  trevorlasn.com git:(master) ✗ head -n 5 package-lock.json {   "name": "trevorlasn.com",   "version": "1.0.0",   "lockfileVersion": 3,   "requires": true,

Previewing CSV Headers: For CSV files, head is perfect for quickly checking the header or structure:

Terminal window

➜ head -n 1 username-password-recovery-code.csv Username; Identifier;One-time password;Recovery code;First name;Last name;Department;Location

awk

awk is a powerful tool for pattern scanning and processing. It’s particularly useful for manipulating and analyzing text files and data streams.

With awk, you can filter, extract, and transform data in a file or from command output.

awk efficiently extracts and combines data from various sources using its associative arrays. Suppose you have two CSV files:

List of employees.

Terminal window

➜ cat employees.csv ID,Name,Department 101,John Doe,Sales 102,Jane Smith,Engineering 103,Jim Brown,Sales

List of salaries.

Terminal window

➜ cat salaries.csv ID,Salary 101,50000 102,60000 103,55000

Use awk to merge these files and display each employee’s name with their salary.

Terminal window

➜ awk -F',' '     NR==FNR {salaries[$1]=$2; next}     FNR==1 {next}     {print $2, salaries[$1]} ' salaries.csv employees.csv John Doe 50000 Jane Smith 60000 Jim Brown 55000

NR==FNR {salaries[$1]=$2; next}: While processing the first file (salaries.csv), store salaries in an associative array. The employee ID ($1) is the key, and the salary ($2) is the value. This runs only for the first file.
FNR==1 {next}: Skip the header line of the second file (employees.csv).
{print $2, salaries[$1]}: For each line in the second file (employees.csv), print the employee’s name ($2) and their salary from the array (salaries[$1]).

You can also save the results to a new file.

Terminal window

➜ awk -F',' '     NR==FNR {salaries[$1]=$2; next}     FNR==1 {next}     {print $2, salaries[$1]} ' salaries.csv employees.csv > combined.csv  ➜ cat combined.csv John Doe 50000 Jane Smith 60000 Jim Brown 55000

sed

sed, short for Stream Editor, is a powerful tool for text processing in the terminal. It allows you to find, replace, insert, or delete text within files or streams of data.

You can use it for quick edits without opening a text editor, making it great for scripting and automation.

Replace a word or pattern in a file: Replacing “Trevor” with “John”.

Terminal window

➜ cat hello.md My name is Trevor ➜ sed -i '' 's/Trevor/John/' hello.md ➜ cat hello.md My name is John

If you want save the changes, use the -i option.

Print Specific Lines: Print only specific lines from a file.

Terminal window

➜  trevorlasn.com git:(master) ✗ sed -n '2,4p' package-lock.json   "name": "trevorlasn.com",   "version": "1.0.0",   "lockfileVersion": 3,

This prints lines 2 through 4.

Regular Expressions: sed supports regular expressions, allowing for complex search-and-replace operations. For example, replace all digits with “X”:

Terminal window

➜ cat combined.csv John Doe 50000 Jane Smith 60000 Jim Brown 55000 ➜ sed 's/[0-9]/X/g' combined.csv John Doe XXXXX Jane Smith XXXXX Jim Brown XXXXX

Renaming Files in Bulk: Let’s say you have multiple files with the extension .txt and you want to rename them to .md.

Terminal window

➜ ls 1.txt 2.txt 3.txt ➜ for file in *.txt; do     mv "$file" "$(echo "$file" | sed 's/.txt$/.md/')"   done ➜ ls 1.md 2.md 3.md

sed is highly versatile, and these examples just scratch the surface

tail

tail is the counterpart to head. It allows you to view the last few lines of a file rather than the first. It’s commonly used to monitor log files or check the end of a document. By default, tail shows the last 10 lines of a file.

Terminal window

➜  trevorlasn.com git:(master) ✗ tail package.json   },   "devDependencies": {     "@typescript-eslint/eslint-plugin": "^7.3.1",     "@typescript-eslint/parser": "^7.3.1",     "eslint": "^8.57.0",     "eslint-plugin-astro": "^0.32.0",     "eslint-plugin-jsx-a11y": "^6.8.0",     "typescript": "^5.4.2"   } }

Viewing More or Fewer Lines: You can adjust the number of lines shown using the -n option.

Terminal window

➜  trevorlasn.com git:(master) ✗ tail -n 15 package.json     "astro": "^4.13.3",     "clsx": "^2.1.0",     "sharp": "^0.33.3",     "tailwind-merge": "^2.2.2",     "tailwindcss": "^3.4.1"   },   "devDependencies": {     "@typescript-eslint/eslint-plugin": "^7.3.1",     "@typescript-eslint/parser": "^7.3.1",     "eslint": "^8.57.0",     "eslint-plugin-astro": "^0.32.0",     "eslint-plugin-jsx-a11y": "^6.8.0",     "typescript": "^5.4.2"   } }

Real-Time File Monitoring: One of the most powerful features of tail is the -f option, which allows you to follow a file as it grows. This is especially useful for watching log files in real-time.

Terminal window

➜ tail -f 1.md 11 Changing file

As new lines are added to 1.md, tail will automatically display them.

chmod

Each file has three sets of permissions: owner, group, and others. These are typically represented in a format like rwxr-xr—

r: Read permission
w: Write permission
x: Execute permission

Terminal window

➜ ls -l sensitive.md -rw-r--r--@ 1 trevorindreklasn  staff  0 Aug 21 15:22 sensitive.md

The file permissions -rw-r—r— indicate that:

Owner (trevorindreklasn): Has read (r) and write (w) permissions.
Group (staff): Has read (r) permissions.
Others: Have read (r) permissions.

The @ symbol indicates that the file has extended attributes, which are additional metadata beyond standard file permissions.

File permissions control who can read, write, or execute a file, ensuring security and proper access management by preventing unauthorized users from modifying or viewing sensitive data.

To restrict access to sensitive.md so that only the root user or superadmins can view and write to it, you can use the chmod command to modify the file’s permissions.

First, ensure the file is owned by the root user or a superadmin. You might need sudo for changing ownership:

Terminal window

➜ ls -l sensitive.md -rw-r--r--@ 1 root  staff  0 Aug 21 15:22 sensitive.md  ➜ sudo chown root:admin sensitive.md ➜ ls -l sensitive.md -rw-r-----@ 1 root  admin  0 Aug 21 15:22 sensitive.md  ➜ sudo chmod 600 sensitive.md ➜  textfiles ls -l sensitive.md -rw-------  1 root  admin  0 Aug 21 15:22 sensitive.md

Only the owner (root) has read and write access. While the group and others have no permissions. This restricts access to the file, making it readable and writable only by the owner.

Improper file permissions can lead to security issues or system problems

Unauthorized Access: File containing sensitive information, like passwords or financial data, has overly permissive settings (e.g., chmod 777), anyone on the system can read or modify it. This could lead to data breaches or unauthorized access to sensitive information.
Malware Installation: A file or directory with write permissions for all users (e.g., chmod 777) could be exploited by attackers to place malicious scripts or software, potentially compromising the entire system.
Data Corruption: If files that should be read-only (e.g., logs or system configurations) are accidentally given write permissions, users or applications might inadvertently corrupt or erase critical data, leading to system instability or loss of important information.

xargs

The xargs command builds and runs commands using input from other commands. It’s used to pass a list of items as arguments to another command.

Suppose you have a list of files that you want to delete.

Terminal window

➜ ls 1.txt        2.txt       2.md         3.md         sensitive.md  # Find all .txt files and delete them ➜ find . -name "*.txt" | xargs rm  ➜  ls 2.md         3.md         sensitive.md

Instead of deleting them one by one, you can use xargs to pass the list of files to rm.

Terminal window

find . -name "*.tmp" | xargs rm

Creating Multiple Directories: If you have a list of directory names in a file and want to create all of them, you can use xargs with mkdir.

Terminal window

➜ cat dirs.txt src temp utils public  ➜ ls 2.md         3.md         dirs.txt     sensitive.md  # Creates each directory listed in the file. ➜ cat dirs.txt | xargs mkdir  ➜ ls 2.md         dirs.txt     sensitive.md temp 3.md         public       src          utils

Compressing Files: If you have multiple files that you want to compress using gzip, you can use xargs to pass the filenames to gzip.

Terminal window

# Compresses all .log files in the current directory ls *.log | xargs gzip

find

Search and locate files and directories within your file system based on various criteria. It’s highly customizable and can be combined with other commands for complex tasks.

Terminal window

find [path] [expression]

The find command searches for occurrences of “astro” within the node_modules directory, returning paths to files and directories with that name, including executables and package files.

Terminal window

➜ trevorlasn.com git:(master) ✗ find node_modules -name "astro"  node_modules/.bin/astro  node_modules/astro  node_modules/astro/dist/runtime/server/render/astro

Cleanup old log files: Regularly delete log files older than a month to free up disk space.

Terminal window

➜ find /var/log -type f -name "*.log" -mtime +30 -delete

Backup important files: Locate and copy all .docx files from home directory to a backup location.

Terminal window

➜  find ~/Documents -name "*.docx" -exec cp {} /path/to/backup/ \;

The find command is incredibly versatile and can be tailored to suit a wide range of file management tasks.

转自:https://www.trevorlasn.com/blog/10-essential-terminal-commands-every-developer-should-know

MAC本地微调大模型（MLX + Qwen2.5）

Mon, 06 Jan 2025 01:23:00 GMT

背景

微调过程中的各种数据集清洗、微调超参数调整学习，最新模型的测试，都需要一个高效的微调框架去进行验证、熟悉，本文就通过介绍苹果官方出品的MLX微调框架本地微调大模型。毕竟想随心所欲的使用云端微调服务，大部分都是需要收费，在没有对微调技术较为熟悉的情况下，本地微调大模型也是不失为一种ROI较高的学习方式。

微调

微调是基于一个已经训练好的神经网络模型，通过对其参数进行细微调整，使其更好地适应特定的任务或数据。通过在新的小规模数据集上继续训练模型的部分或全部层，模型能够在保留原有知识的基础上，针对新任务进行优化，从而提升在特定领域的表现。根据微调参数范围划分，微调范围分为两种：

全微调（Full Fine-tuning）：就是对整个预训练模型来个全套改造，包括所有的模型参数。这种招式适合任务和预训练模型之间相差大的情况，或者任务要求模型超级灵活自适应的时候。虽然这招消耗资源多，时间也长，但效果杠杠的。
部分微调（Partial Fine-Tuning）：这个招式就是只调整模型的上层或者少数几层，底层参数不动。这招适合任务和预训练模型比较相似，或者数据集不大的情况。因为只动少数层，所以资源消耗少，速度快，不过有时候效果可能差点。

目前我们绝大部分场景都使用的是部分微调，种方法减少了计算和存储成本，同时降低了过拟合的风险，适合数据较少的任务，但在任务复杂度较高时可能无法充分发挥模型的潜力。

根据微调使用的数据集类型，大模型微调还可以分为：

监督微调（Supervised Fine-tuning）：就是用有标签的训练数据集进行微调。这些标签告诉模型在微调中应该怎么做。比如分类任务，每个样本都有对应的标签。用这些标签指导模型微调，可以让它更适应具体任务。
无监督微调（Unsupervised Fine-tuning）：这个就是用无标签的训练数据集进行微调。也就是模型只能看数据，不知道啥是对啥是错。这种方法通过学习数据内在结构或者生成数据，来提取有用特征或者改善模型表示能力。本文后续微调采用的是SFT的方式进行微调，微调的理论我就不做过多篇幅介绍，有兴趣的同学可以自行搜索资料，本文重点是希望通过实操的方式，让大家对大模型的微调有亲身操作的体感，从而激发大家对于模型微调的研究兴趣。

好处

提高准确性：微调可以显着提高大模型在特定任务上的准确性。
提高效率：可以使大模型在特定任务.上更有效。例如，在对问答数据集进行微调后，大模型可能能够更快、更准确地回答问题。
提高泛化能力：可以提高大模型的泛化能力，这意味着它们可以更好地执行与训练数据中数据不同的任务。例如，在对不同类型的创意文本格式(如诗歌、代码、脚本、音乐作品、电子邮件、信件等)的数据集进行微调后，大模型可能能够生成我们用看件下微调大模型的优可以减少训练大模型所需的数据量。
数据安全：如果数据敏感，内部组织可能更愿意使用微调而不是公开模型，以保护数据隐私。

流程

准备数据集：找到和任务相关的数据，保证数据质量和标签准确，然后做好清洗和预处理。
选模型：根据任务和数据，选一个合适的微调的基座模型。
微调策略参数：根据任务需求和资源，选择合适的微调策略，配置LoRA参数、微调参数如学习率，确保模型收敛。
训练模型：在训练集上训练模型，，按照设定的超参数和优化算法，调整参数降低损失，防止过拟合。
评估模型：在验证集上评估模型性能。

MLX

MLX是由苹果的机器学习研究团队推出的用于机器学习的阵列框架，该开源框架专为 Apple Silicon 芯片而设计优化，从NumPy、PyTorch、Jax和ArrayFire等框架中吸取灵感，提供简单友好的使用方法，它可以在Apple Silicon CPU/GPU 上进行 ML 训练和推理。由Apple公司开发的 MLX 库类似于 TensorFlow 和 PyTorch，支持 GPU 支持的任务。该库允许在新的 Apple Silicon（M 系列）芯片上对 LLM 进行微调。此外，MLX 还支持使用 LoRA 、QLoRA等方法对 LLM 进行微调

官网：ml-explore.github.io/mlx/build/h… github：github.com/ml-explore/…

下载模型

通过命令行下载模型，模型大小1G左右，下载命令如下，整体过程可以跑满下载带宽。

创建环境

conda create -n FineTune python=3.11.11 conda activate FineTune

下载模型

#安装依赖 可能需要科学 pip install -U huggingface_hub #设置环境变量 export HF_ENDPOINT=https://hf-mirror.com  #下载模型，保存至qwen2.5-0.5B目录 huggingface-cli download --resume-download Qwen/Qwen2.5-0.5B-Instruct --local-dir qwen2.5-0.5B

下载失败可以重复执行一下

下载完成后的文件列表

准备数据集

{"prompt": "今天星期几", "completion": "星期八"} {"prompt": "太阳什么时候升起?", "completion": "晚上八点"} {"prompt": "忘情水是什么水", "completion": "忘情水是可以让人忘却烦恼的水"} {"prompt": "蓝牙耳机坏了应该看什么科", "completion": "耳鼻喉科"} {"prompt": "鲁迅为什么讨厌周树人", "completion": "因为他们是仇人"}

代码准备

git clone git@github.com:ml-explore/mlx-examples.git

将lora/data目录下的“train.jsonl”文件内容改为上面的微调数据集，由于我们不做测试与验证，所以测试数据集和验证数据集的内容就不修改了。验证方式通过对微调后的模型进行提问来简单验证。

依赖安装

pip install mlx-lm pip install transformers pip install torch pip install numpy

微调模型

进入lora目录，执行如下代码开始微调，由于我们目的是快速走通微调流程，就不去调整各种微调超参去测试微调效果了，仅指定需要微调的模型路径与数据集路径，其他参数走默认参数。

cd /Users/maruifu/Desktop/AI/mlx-examples/lora mlx_lm.lora --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --train --data ./data

支持的微调方式包括lora、qlora、full（全参微调）

开始执行微调过程，由于数据集数量很少，执行过程很快，loss也下降的很快

(FineTune) maruifu@XMG-M4ProMax lora % mlx_lm.lora --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --train --data ./data Loading pretrained model Loading datasets Training Trainable parameters: 0.109% (0.541M/494.033M) Starting training..., iters: 1000 Iter 1: Val loss 2.755, Val took 2.665s Iter 10: Train loss 5.209, Learning Rate 1.000e-05, It/sec 6.475, Tokens/sec 1120.136, Trained Tokens 1730, Peak mem 2.007 GB Iter 20: Train loss 2.642, Learning Rate 1.000e-05, It/sec 9.758, Tokens/sec 1688.204, Trained Tokens 3460, Peak mem 2.007 GB Iter 30: Train loss 1.472, Learning Rate 1.000e-05, It/sec 9.751, Tokens/sec 1686.856, Trained Tokens 5190, Peak mem 2.007 GB Iter 40: Train loss 0.911, Learning Rate 1.000e-05, It/sec 9.773, Tokens/sec 1690.745, Trained Tokens 6920, Peak mem 2.007 GB Iter 50: Train loss 0.615, Learning Rate 1.000e-05, It/sec 9.508, Tokens/sec 1644.925, Trained Tokens 8650, Peak mem 2.007 GB Iter 60: Train loss 0.413, Learning Rate 1.000e-05, It/sec 9.701, Tokens/sec 1678.330, Trained Tokens 10380, Peak mem 2.007 GB Iter 70: Train loss 0.248, Learning Rate 1.000e-05, It/sec 9.745, Tokens/sec 1685.828, Trained Tokens 12110, Peak mem 2.007 GB Iter 80: Train loss 0.132, Learning Rate 1.000e-05, It/sec 9.744, Tokens/sec 1685.675, Trained Tokens 13840, Peak mem 2.007 GB Iter 90: Train loss 0.087, Learning Rate 1.000e-05, It/sec 9.737, Tokens/sec 1684.579, Trained Tokens 15570, Peak mem 2.007 GB Iter 100: Train loss 0.067, Learning Rate 1.000e-05, It/sec 9.653, Tokens/sec 1669.912, Trained Tokens 17300, Peak mem 2.007 GB Iter 100: Saved adapter weights to adapters/adapters.safetensors and adapters/0000100_adapters.safetensors. Iter 110: Train loss 0.060, Learning Rate 1.000e-05, It/sec 9.692, Tokens/sec 1676.734, Trained Tokens 19030, Peak mem 2.007 GB Iter 120: Train loss 0.055, Learning Rate 1.000e-05, It/sec 9.355, Tokens/sec 1618.465, Trained Tokens 20760, Peak mem 2.007 GB Iter 130: Train loss 0.053, Learning Rate 1.000e-05, It/sec 9.727, Tokens/sec 1682.790, Trained Tokens 22490, Peak mem 2.007 GB Iter 140: Train loss 0.049, Learning Rate 1.000e-05, It/sec 9.707, Tokens/sec 1679.372, Trained Tokens 24220, Peak mem 2.007 GB Iter 150: Train loss 0.048, Learning Rate 1.000e-05, It/sec 9.714, Tokens/sec 1680.461, Trained Tokens 25950, Peak mem 2.007 GB Iter 160: Train loss 0.046, Learning Rate 1.000e-05, It/sec 9.678, Tokens/sec 1674.324, Trained Tokens 27680, Peak mem 2.007 GB Iter 170: Train loss 0.046, Learning Rate 1.000e-05, It/sec 9.542, Tokens/sec 1650.749, Trained Tokens 29410, Peak mem 2.007 GB Iter 180: Train loss 0.045, Learning Rate 1.000e-05, It/sec 9.681, Tokens/sec 1674.849, Trained Tokens 31140, Peak mem 2.007 GB Iter 190: Train loss 0.044, Learning Rate 1.000e-05, It/sec 9.620, Tokens/sec 1664.245, Trained Tokens 32870, Peak mem 2.007 GB Iter 200: Val loss 2.911, Val took 1.904s Iter 200: Train loss 0.044, Learning Rate 1.000e-05, It/sec 79.695, Tokens/sec 13787.287, Trained Tokens 34600, Peak mem 2.021 GB Iter 200: Saved adapter weights to adapters/adapters.safetensors and adapters/0000200_adapters.safetensors. Iter 210: Train loss 0.042, Learning Rate 1.000e-05, It/sec 9.653, Tokens/sec 1669.991, Trained Tokens 36330, Peak mem 2.021 GB Iter 220: Train loss 0.042, Learning Rate 1.000e-05, It/sec 9.545, Tokens/sec 1651.331, Trained Tokens 38060, Peak mem 2.021 GB Iter 230: Train loss 0.041, Learning Rate 1.000e-05, It/sec 9.635, Tokens/sec 1666.780, Trained Tokens 39790, Peak mem 2.021 GB Iter 240: Train loss 0.042, Learning Rate 1.000e-05, It/sec 9.524, Tokens/sec 1647.641, Trained Tokens 41520, Peak mem 2.021 GB Iter 250: Train loss 0.041, Learning Rate 1.000e-05, It/sec 9.610, Tokens/sec 1662.556, Trained Tokens 43250, Peak mem 2.021 GB Iter 260: Train loss 0.041, Learning Rate 1.000e-05, It/sec 9.489, Tokens/sec 1641.622, Trained Tokens 44980, Peak mem 2.021 GB Iter 270: Train loss 0.039, Learning Rate 1.000e-05, It/sec 9.682, Tokens/sec 1675.023, Trained Tokens 46710, Peak mem 2.021 GB Iter 280: Train loss 0.039, Learning Rate 1.000e-05, It/sec 9.622, Tokens/sec 1664.556, Trained Tokens 48440, Peak mem 2.021 GB Iter 290: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.673, Tokens/sec 1673.366, Trained Tokens 50170, Peak mem 2.021 GB Iter 300: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.561, Tokens/sec 1654.011, Trained Tokens 51900, Peak mem 2.021 GB Iter 300: Saved adapter weights to adapters/adapters.safetensors and adapters/0000300_adapters.safetensors. Iter 310: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.613, Tokens/sec 1663.060, Trained Tokens 53630, Peak mem 2.021 GB Iter 320: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.650, Tokens/sec 1669.448, Trained Tokens 55360, Peak mem 2.021 GB Iter 330: Train loss 0.037, Learning Rate 1.000e-05, It/sec 9.650, Tokens/sec 1669.512, Trained Tokens 57090, Peak mem 2.021 GB Iter 340: Train loss 0.039, Learning Rate 1.000e-05, It/sec 9.703, Tokens/sec 1678.638, Trained Tokens 58820, Peak mem 2.021 GB Iter 350: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.567, Tokens/sec 1655.136, Trained Tokens 60550, Peak mem 2.021 GB Iter 360: Train loss 0.037, Learning Rate 1.000e-05, It/sec 9.584, Tokens/sec 1657.958, Trained Tokens 62280, Peak mem 2.021 GB Iter 370: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.583, Tokens/sec 1657.870, Trained Tokens 64010, Peak mem 2.021 GB Iter 380: Train loss 0.037, Learning Rate 1.000e-05, It/sec 9.584, Tokens/sec 1657.979, Trained Tokens 65740, Peak mem 2.021 GB Iter 390: Train loss 0.037, Learning Rate 1.000e-05, It/sec 9.658, Tokens/sec 1670.766, Trained Tokens 67470, Peak mem 2.021 GB Iter 400: Val loss 2.923, Val took 1.876s Iter 400: Train loss 0.037, Learning Rate 1.000e-05, It/sec 70.241, Tokens/sec 12151.771, Trained Tokens 69200, Peak mem 2.021 GB Iter 400: Saved adapter weights to adapters/adapters.safetensors and adapters/0000400_adapters.safetensors. Iter 410: Train loss 0.038, Learning Rate 1.000e-05, It/sec 9.660, Tokens/sec 1671.174, Trained Tokens 70930, Peak mem 2.021 GB Iter 420: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.672, Tokens/sec 1673.215, Trained Tokens 72660, Peak mem 2.021 GB Iter 430: Train loss 0.037, Learning Rate 1.000e-05, It/sec 9.672, Tokens/sec 1673.253, Trained Tokens 74390, Peak mem 2.021 GB Iter 440: Train loss 0.037, Learning Rate 1.000e-05, It/sec 9.677, Tokens/sec 1674.095, Trained Tokens 76120, Peak mem 2.021 GB Iter 450: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.677, Tokens/sec 1674.059, Trained Tokens 77850, Peak mem 2.021 GB Iter 460: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.640, Tokens/sec 1667.714, Trained Tokens 79580, Peak mem 2.021 GB Iter 470: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.569, Tokens/sec 1655.492, Trained Tokens 81310, Peak mem 2.021 GB Iter 480: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.662, Tokens/sec 1671.469, Trained Tokens 83040, Peak mem 2.021 GB Iter 490: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.599, Tokens/sec 1660.569, Trained Tokens 84770, Peak mem 2.021 GB Iter 500: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.292, Tokens/sec 1607.535, Trained Tokens 86500, Peak mem 2.021 GB Iter 500: Saved adapter weights to adapters/adapters.safetensors and adapters/0000500_adapters.safetensors. Iter 510: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.631, Tokens/sec 1666.207, Trained Tokens 88230, Peak mem 2.021 GB Iter 520: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.650, Tokens/sec 1669.500, Trained Tokens 89960, Peak mem 2.021 GB Iter 530: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.666, Tokens/sec 1672.258, Trained Tokens 91690, Peak mem 2.021 GB Iter 540: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.625, Tokens/sec 1665.041, Trained Tokens 93420, Peak mem 2.021 GB Iter 550: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.623, Tokens/sec 1664.755, Trained Tokens 95150, Peak mem 2.021 GB Iter 560: Train loss 0.036, Learning Rate 1.000e-05, It/sec 9.636, Tokens/sec 1667.108, Trained Tokens 96880, Peak mem 2.021 GB Iter 570: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.682, Tokens/sec 1674.924, Trained Tokens 98610, Peak mem 2.021 GB Iter 580: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.674, Tokens/sec 1673.663, Trained Tokens 100340, Peak mem 2.021 GB Iter 590: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.613, Tokens/sec 1663.114, Trained Tokens 102070, Peak mem 2.021 GB Iter 600: Val loss 2.914, Val took 1.905s Iter 600: Train loss 0.035, Learning Rate 1.000e-05, It/sec 78.821, Tokens/sec 13636.113, Trained Tokens 103800, Peak mem 2.021 GB Iter 600: Saved adapter weights to adapters/adapters.safetensors and adapters/0000600_adapters.safetensors. Iter 610: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.362, Tokens/sec 1619.649, Trained Tokens 105530, Peak mem 2.021 GB Iter 620: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.369, Tokens/sec 1620.838, Trained Tokens 107260, Peak mem 2.021 GB Iter 630: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.408, Tokens/sec 1627.645, Trained Tokens 108990, Peak mem 2.021 GB Iter 640: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.428, Tokens/sec 1631.094, Trained Tokens 110720, Peak mem 2.021 GB Iter 650: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.460, Tokens/sec 1636.570, Trained Tokens 112450, Peak mem 2.021 GB Iter 660: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.505, Tokens/sec 1644.345, Trained Tokens 114180, Peak mem 2.021 GB Iter 670: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.595, Tokens/sec 1659.934, Trained Tokens 115910, Peak mem 2.021 GB Iter 680: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.625, Tokens/sec 1665.183, Trained Tokens 117640, Peak mem 2.021 GB Iter 690: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.619, Tokens/sec 1664.156, Trained Tokens 119370, Peak mem 2.021 GB Iter 700: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.641, Tokens/sec 1667.847, Trained Tokens 121100, Peak mem 2.021 GB Iter 700: Saved adapter weights to adapters/adapters.safetensors and adapters/0000700_adapters.safetensors. Iter 710: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.637, Tokens/sec 1667.250, Trained Tokens 122830, Peak mem 2.021 GB Iter 720: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.659, Tokens/sec 1671.092, Trained Tokens 124560, Peak mem 2.021 GB Iter 730: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.651, Tokens/sec 1669.550, Trained Tokens 126290, Peak mem 2.021 GB Iter 740: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.636, Tokens/sec 1667.022, Trained Tokens 128020, Peak mem 2.021 GB Iter 750: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.651, Tokens/sec 1669.658, Trained Tokens 129750, Peak mem 2.021 GB Iter 760: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.624, Tokens/sec 1664.878, Trained Tokens 131480, Peak mem 2.021 GB Iter 770: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.694, Tokens/sec 1677.147, Trained Tokens 133210, Peak mem 2.021 GB Iter 780: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.659, Tokens/sec 1670.965, Trained Tokens 134940, Peak mem 2.021 GB Iter 790: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.652, Tokens/sec 1669.851, Trained Tokens 136670, Peak mem 2.021 GB Iter 800: Val loss 2.931, Val took 1.918s Iter 800: Train loss 0.035, Learning Rate 1.000e-05, It/sec 70.855, Tokens/sec 12257.872, Trained Tokens 138400, Peak mem 2.021 GB Iter 800: Saved adapter weights to adapters/adapters.safetensors and adapters/0000800_adapters.safetensors. Iter 810: Train loss 0.034, Learning Rate 1.000e-05, It/sec 8.452, Tokens/sec 1462.112, Trained Tokens 140130, Peak mem 2.021 GB Iter 820: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.346, Tokens/sec 1616.807, Trained Tokens 141860, Peak mem 2.021 GB Iter 830: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.096, Tokens/sec 1573.530, Trained Tokens 143590, Peak mem 2.021 GB Iter 840: Train loss 0.034, Learning Rate 1.000e-05, It/sec 8.860, Tokens/sec 1532.860, Trained Tokens 145320, Peak mem 2.021 GB Iter 850: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.409, Tokens/sec 1627.715, Trained Tokens 147050, Peak mem 2.021 GB Iter 860: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.511, Tokens/sec 1645.410, Trained Tokens 148780, Peak mem 2.021 GB Iter 870: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.524, Tokens/sec 1647.594, Trained Tokens 150510, Peak mem 2.021 GB Iter 880: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.534, Tokens/sec 1649.359, Trained Tokens 152240, Peak mem 2.021 GB Iter 890: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.167, Tokens/sec 1585.897, Trained Tokens 153970, Peak mem 2.021 GB Iter 900: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.380, Tokens/sec 1622.811, Trained Tokens 155700, Peak mem 2.021 GB Iter 900: Saved adapter weights to adapters/adapters.safetensors and adapters/0000900_adapters.safetensors. Iter 910: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.480, Tokens/sec 1640.073, Trained Tokens 157430, Peak mem 2.021 GB Iter 920: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.489, Tokens/sec 1641.646, Trained Tokens 159160, Peak mem 2.021 GB Iter 930: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.523, Tokens/sec 1647.469, Trained Tokens 160890, Peak mem 2.021 GB Iter 940: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.282, Tokens/sec 1605.724, Trained Tokens 162620, Peak mem 2.021 GB Iter 950: Train loss 0.034, Learning Rate 1.000e-05, It/sec 8.924, Tokens/sec 1543.773, Trained Tokens 164350, Peak mem 2.021 GB Iter 960: Train loss 0.034, Learning Rate 1.000e-05, It/sec 9.216, Tokens/sec 1594.282, Trained Tokens 166080, Peak mem 2.021 GB Iter 970: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.420, Tokens/sec 1629.594, Trained Tokens 167810, Peak mem 2.021 GB Iter 980: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.440, Tokens/sec 1633.078, Trained Tokens 169540, Peak mem 2.021 GB Iter 990: Train loss 0.035, Learning Rate 1.000e-05, It/sec 9.433, Tokens/sec 1631.846, Trained Tokens 171270, Peak mem 2.021 GB Iter 1000: Val loss 2.941, Val took 2.211s Iter 1000: Train loss 0.035, Learning Rate 1.000e-05, It/sec 66.983, Tokens/sec 11588.048, Trained Tokens 173000, Peak mem 2.021 GB Iter 1000: Saved adapter weights to adapters/adapters.safetensors and adapters/0001000_adapters.safetensors. Saved final weights to adapters/adapters.safetensors.

在训练1000Iter后，最终在生成了lora目录下生成微调后的模型适配器权重文件目录adapters

合并模型

将原始模型通过mlx_lm.fuse命令生成与低秩适配器融合后新的模型，新模型命名为“qwen2.5-0.5B-new” 融合成功后生成新模型文件夹“qwen2.5-0.5B-new”

mlx_lm.fuse --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --adapter-path adapters --save-path qwen2.5-0.5B-new

验证效果

本次验证由于不用于实际项目，所以就通过测试数据集来验证效果，如果有需要，可以通过自定义“test.jsonl”数据集运行下面命令，计算perplexity

python lora.py --model <path_to_model> \                --adapter-file <path_to_adapters.npz> \                --test

本次验证通过简单推理几个问题来验证微调后的模型效果，推理命令示例如下

#原始模型推理问题 mlx_lm.generate --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --prompt "蓝牙耳机坏了应该看什么科" #微调后的模型推理问题 mlx_lm.generate --model qwen2.5-0.5B-new --prompt "蓝牙耳机坏了应该看什么科"   #原始模型推理问题 mlx_lm.generate --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --prompt "今天星期几?" #微调后的模型推理问题 mlx_lm.generate --model qwen2.5-0.5B-new --prompt "今天星期几?"

(FineTune) maruifu@XMG-M4ProMax lora % mlx_lm.generate --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --prompt "蓝牙耳机坏了应该看什么科" ========== Prompt: <|im_start|>system You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|> <|im_start|>user 蓝牙耳机坏了应该看什么科<|im_end|> <|im_start|>assistant  蓝牙耳机坏了，通常需要检查以下几个方面来确定问题所在：  1. **电源和连接线**：确保耳机的电源线和连接线没有损坏。如果连接线松动或损坏，可能会导致耳机无法正常工作。  2. **耳机内部**：检查耳机内部是否有损坏或松动的部件。例如，如果耳机的麦克风或扬声器出现问题，可能会导致耳机无法正常工作。  3. **耳机的电池**：如果耳机的电池已经 ========== Prompt: 36 tokens, 639.492 tokens-per-sec Generation: 100 tokens, 220.372 tokens-per-sec Peak memory: 1.005 GB (FineTune) maruifu@XMG-M4ProMax lora % mlx_lm.generate --model qwen2.5-0.5B-new --prompt "蓝牙耳机坏了应该看什么科" ========== Prompt: <|im_start|>system You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|> <|im_start|>user 蓝牙耳机坏了应该看什么科<|im_end|> <|im_start|>assistant  耳鼻喉科 ========== Prompt: 36 tokens, 607.020 tokens-per-sec Generation: 5 tokens, 244.010 tokens-per-sec Peak memory: 1.005 GB (FineTune) maruifu@XMG-M4ProMax lora % mlx_lm.generate --model /Users/maruifu/Desktop/AI/qwen2.5-0.5B --prompt "今天星期几?"              ========== Prompt: <|im_start|>system You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|> <|im_start|>user 今天星期几?<|im_end|> <|im_start|>assistant  很抱歉，我无法直接获取当前日期和时间。不过，我可以帮助你查询或回答关于日期和时间的问题。请告诉我你需要查询的具体日期和时间，我会尽力提供帮助。 ========== Prompt: 33 tokens, 501.995 tokens-per-sec Generation: 41 tokens, 221.940 tokens-per-sec Peak memory: 1.004 GB (FineTune) maruifu@XMG-M4ProMax lora % mlx_lm.generate --model qwen2.5-0.5B-new --prompt "今天星期几?"                                    ========== Prompt: <|im_start|>system You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|> <|im_start|>user 今天星期几?<|im_end|> <|im_start|>assistant  星期八 ========== Prompt: 33 tokens, 600.904 tokens-per-sec Generation: 3 tokens, 279.420 tokens-per-sec Peak memory: 1.004 GB (FineTune) maruifu@XMG-M4ProMax lora %

可以看到，微调后的模型已经起作用了

写到最后

本次介绍苹果官方出品的MLX微调框架简单微调过程，希望能帮助对微调感兴趣的同学，理解微调过程的各种环节。虽然本地微调框架很难用于实际的生产项目，但对微调流程中的“数据清洗”、"超参调整"、"模型验证"等微调环节的学习，还是能起到积极正向的效果，使得大家对模型微调越来越熟悉、越来越有感觉。

信创中间件如何选型

Tue, 10 Dec 2024 05:53:00 GMT

随着各行各业对IT系统自主可控的需求不断增强，企业对信创中间件的应用越来越广泛和深入。在以往信创试点过程中，中间件是有名录的，而截止目前国测发布的《安全可靠测评结果》也未包含信创中间件，面对种类繁多的信创中间件产品，企业需要从中间件第三方评测、实际测试选型多个维度进行评估，以选择最适合自己的产品，为避免品牌倾向，本文不涉及具体品牌讨论，围绕信创中间件的定义、分类以及中间件的选型测试实践经验和注意事项而展开。

定义与分类

为解决异构问题，提出了中间件概念，中间件是位于平台（硬件和操作系统）和应用之间的通用服务，这些服务具有标准的程序接口和协议。

针对不同的操作系统和硬件平台，有符合接口和协议规范的多种实现。可以为处于上层的应用软件提供运行与开发环境，封装不同应用系统的API接口，为应用提供统一标准接口，使应用的开发、运行与操作系统解耦，屏蔽底层的技术细节差异，确保应用的独立性。

中间件位于操作系统之上，应用软件之下，处于信息系统的中间位置，故而得名。中间件并不是一种软件，而是一类软件统称；中间件不仅仅实现互连，还要实现应用之间的互操作。它犹如一道屏障，有效屏蔽了底层操作系统所具有的复杂性，从而为上层应用软件在开发、运行以及集成等诸多环节提供了极大的便利。

中间件可以分为基础类中间件、数据类中间件和云计算类中间件。

产品选型测试

在信创项目上马之前，为保障项目顺利推进，当前由于面向企业市场的信创中间件品牌众多，质量参差不齐等方面原因，一般都会开展POC(验证性测试)，也是业界流行的针对客户具体应用的验证性测试，而在POC阶段应该如何选择哪些品牌，缩小POC范围呢？笔者建议从以下进行考量。

1、市场占有率： 虽然市场占有率高的中间件不一定是最佳选择，但它至少表明了产品经过市场验证并得到了用户广泛认可。这些产品往往问题较多，迭代更新也更为迅速。

2、技术栈兼容性： 市场上的中间件技术栈各异，建议在POC阶段测试涵盖多种技术栈类型的中间件，以确保兼容性和多样性，如消息中间件、Web中间件、分布式中间件、事务性中间件等需要按照不同类型中间件确保兼容性。

3、功能性需求： 鉴于信创中间件功能相对与非信创中间件差异性，如常用的中间件涉及java容器、web负载、缓存、消息队列、数据同步等，建议根据非信创中间件形成功能性需求清单，并在测试阶段对信创中间件进行逐项评估。评估指标包括缓存策略、并发吞吐性能、与开发框架的兼容性、数据同步校验方式以及消息中间件的消息丢失问题等。

4、性能需求： 建议首先确定一个性能基准，即现有中间件的性能数据。然后，使用这些数据作为参考，对不同品牌的信创中间件进行相同的性能测试，以便进行比较分析。例如，可以先测试Redis等现有中间件的缓存读取性能，再对比测试其他信创中间件的相应性能，需要注意的是，由于客观条件的限制，信创中间件在某些性能指标上可能不如现有的中间件，这是正常现象。因此，在性能测试中，应更加关注那些对企业业务至关重要的性能指标，而不是所有指标。具体来说：

(1)如果企业主要关注缓存中间件的读取性能，并且不涉及持久化操作，那么在测试中可以不过分关注持久化性能。

(2) 如果企业使用Java容器主要处理短连接场景，那么对于长连接性能的测试可以不那么重视。

通过这种方式，企业可以更准确地评估信创中间件的性能，确保它们满足业务需求，同时优化资源投入和测试重点。

5、非功能性需求： 信创中间件在满足非功能性需求方面可能存在不足，建议制定非功能性需求清单，包括安全性、自动化安装、日志管理、平台集成能力和监控功能，以及资源占用情况等。

6、稳定性测试需求： 对于信创中间件的稳定性测试，建议实施至少一个月的实践测试周期。在这个月内，应对包括Java容器、负载均衡、缓存和消息队列在内的各类信创中间件进行详细的测试，并记录它们的运行状况。根据经验，以下是在这一测试期间可能遇到的两种主要场景：

（1）内存溢出问题：可能由于应用程序代码编写不当导致的内存溢出，这与信创中间件的性能无关；另一种可能是信创中间件本身存在问题导致的内存溢出。如果厂商未能提供修复版本，那么这类中间件可能不适合使用。

（2）性能随时间下降：随着运行时间的延长，中间件的响应速度可能会逐渐变慢。这种情况需要在测试中观察并处理，因为它可能影响长期的系统稳定性和性能。通过这样的长期稳定性测试，可以更准确地评估信创中间件在实际应用中的可靠性和性能表现，从而为企业选择适合的中间件产品提供重要依据。

7、高可靠需求： 信创中间件的高可靠性测试可分为两大类架构形态：分布式架构和传统双节点架构。以下是对这两类架构的高可用性测试的总结：

分布式架构中间件：利用Paxos和Raft等分布式协议实现高可用性，确保系统在故障或网络分区情况下数据一致性。测试场景包括停止单个服务进程、停止所有进程、重复启动服务进程、停止master节点和停止证书所在节点。特别关注那些容易被忽略的场景，如停止所有进程、重复启动服务进程和停止证书所在节点，因为这些场景对于验证分布式中间件的高可用性至关重要。
双节点架构中间件：包括主备和双活两种类型，通常基于集群间内存复制实现高可用性。测试时，通过关闭一个节点来验证负载是否能自动切换到另一个节点，以及业务受影响的时间。由于内存复制可能导致性能下降，一般建议在双节点前部署负载均衡器，以实现应用服务的高可用性，而不是依赖于集群间内存复制。

8、厂商响应速度： 在沟通过程中，厂商对问题的响应速度可以反映其对客户的重视程度。一些厂商能够及时反馈，而其他厂商可能响应较慢，这可以作为评估厂商服务水平的一个指标。

结语

由于目前信创中间件的评估，国测并没有发布，市场上信创中间件的评估很多是通过第三方评测单位开展，可选范围较多，笔者建议先少量采购，并且在一些非核心系统上使用，总结各种使用经验，以便在出现问题时能够及时得到支持。

以上总结poc测试的8个方面的考量，总体来说，信创中间件相比于非信创中间件虽然存在差异，但是整体在可接受的范围内，需要大家一起努力共建良好的信创中间件生态。

本文转自信创新态势

搭建本地大模型之LM Studio

Tue, 10 Dec 2024 02:44:07 GMT

之前分享了 Ollama 这次分享一下另一款本地运行大模型的工具LM Studio

什么是 LM Studio？

LM Studio 是一款用于在您的电脑上开发和实验LLMs的桌面应用程序。

关键功能

桌面应用程序，用于运行本地 LLMs
一个熟悉的聊天界面
搜索和下载功能（通过 Hugging Face 🤗）
一个可以监听类似 OpenAI 端点的本地服务器
本地模型和配置管理系统

系统要求

LM Studio 通常支持 Apple Silicon Macs、x64/ARM64 Windows PC 和 x64 Linux PC。

macOS

芯片：苹果硅（M1/M2/M3/M4）。
macOS 13.4 或更高版本是必需的。
- 对于 MLX 模型，需要 macOS 14.0 或更高版本。
16GB+内存推荐。
您可能仍然可以在 8GB 的 Mac 上使用 LM Studio，但请坚持使用较小型号和适度的上下文大小。
英特尔 Mac 目前不支持。

Windows

LM Studio 支持 x64 和 ARM（Snapdragon X Elite）架构的系统。

CPU：需要支持 AVX2 指令集（针对 x64）
RAM: LLMs可能会消耗大量 RAM。建议至少 16GB 的 RAM。

Linux

LM Studio for Linux 以 AppImage 的形式分发。
Ubuntu 20.04 或更高版本是必需的
仅支持 x64，暂不支持 aarch64
Ubuntu 版本高于 22 的版本测试不佳。
CPU：中央处理器
LM Studio 默认支持 AVX2

如何安装 LM Studio？

LM Studio 适用于 macOS、Windows 和 Linux。

前往下载页面并下载适用于您的操作系统的安装程序。

设置中文

右下角设置

设置模型目录

模型目录最好不要有中文特殊符号,最好是英文字母

下载模型

如果可以科学上网

镜像网站下载

https://hf-mirror.com/

下载gguf模型放到前面设置的模型目录里面

模型挑选

模型文件大小小于自己显存大小,但接近显存大小的效果肯定越好

GGUF模型

GGUF，全称 GPT-Generated Unified Format，是一种新型的文件格式专门用于存储和交换大型机器学习模型的数据。这种格式针对模型的快速加载和保存进行了优化，使其在推理方面更加高效。GGUF可以有多重不同版本的量化，Q2、Q3、Q4、Q5、Q6、Q8，这些数字表示模型权重的位数，位数越高，模型的精度通常越高，但所需的存储空间和计算资源也越多。

不是所有 gguf 格式的模都能用 LM Studio 运行，你可以打开下面这个链接，这里所有模型都可以用LM Studio 运行:https://hf-mirror.com/lmstudio-community *量化是指将模型中的高精度数字转换为低精度数字，以减少模型的存储空间和计算需求。

Docker容器内无法解析域名：IP Temporary failure in name resolution

Fri, 06 Dec 2024 06:28:01 GMT

检查主机网络设置

cat /proc/sys/net/ipv4/ip_forward

返回0则说明未打开，开启ip地址转发：

vi /etc/sysctl.conf

打开内核配置文件，查找net.ipv4.ip_forward = 0，将其修改为net.ipv4.ip_forward = 1，若该行开头有#，将其去掉；若配置文件中没有此项，则在文件最后添加此内容。

 11   12 # Controls IP packet forwarding  13 net.ipv4.ip_forward = 1  14

保存修改后，重启系统或输入以下命令使修改生效：

sysctl -p /etc/sysctl.conf systemctl restart network

检查主机防火墙配置

查看防火墙状态（若防火墙为关闭状态，可跳过防火墙有关设置）

sudo firewall-cmd --state

若返回runging，则防火墙为开启状态，查看防火墙是否开启ip地址转发（ip地址伪装）

sudo firewall-cmd --query-masquerade

若返回no，则输入以下命令开启ip地址转发

sudo firewall-cmd --add-masquerade --permanent

然后输入以下命令使修改生效：

sudo firewall-cmd --reload

再次检查问题是否已经解决，若没有则进行再一步排查

设置Docker指定DNS服务器

打开Docker相关设置文件（主机内）

没有就新建一个，输入下列命令会打开或自动新建：

vi /etc/docker/daemon.json

在文件中输入以下内容

{  "dns": ["8.8.8.8","114.114.114.114"] }

重启Docker

systemctl restart docker

Linux下安装Git

Tue, 03 Dec 2024 08:26:12 GMT

1. 安装Git

1.1 Ubuntu12.04下

可以使用apt-get方式安装，也可以下载源代码安装【1】，我们这里使用apt-git安装。

但由于直接使用 sudo apt-get install git安装的版本较老，因此我们参考【2】中给出的PPA源。

sudo add-apt-repository ppa:git-core/ppa sudo apt-get update sudo apt-get install git

安装完成后，检查是否安装成功

git --version

显示 git version 2.1.1，表明安装成功。

1.2 CentOS6.6下

在CentOS5的时代，由于yum源中没有git，所以需要预先安装一系列的依赖包。但在CentOS6的yum源中已经有git的版本了，可以直接使用yum源进行安装。

$ sudo yum install git

但是yum源中安装的git版本是1.7.1，太老了，Github等需要的Git版本最低都不能低于1.7.2 。所以我们一般不用上面的方法。而是下载git源码，编译安装。

编译安装的步骤是【4】：

（1）首先先更新系统

sudo yum update

（2）安装依赖的包

sudo yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel gcc perl-ExtUtils-MakeMaker

（3）下载git源码并解压缩

$ wget https://github.com/git/git/archive/v2.21.0.zip $ unzip v2.21.0.zip $ cd git-2.21.0

（4）编译安装

将其安装在“/usr/local/git”目录下。

make make prefix=/usr/local/git install

（5）此时你如果使用git --version 查看git版本的话，发现git仍然是1.7.1版本。这是因为它默认使用了"/usr/bin"下的git。

你可以用下面的命令查看git所在的路径：

$ whereis git git: /usr/bin/git /usr/local/git /usr/share/man/man1/git.1.gz

（6）我们要把编译安装的git路径放到环境变量里，让它替换"/usr/bin"下的git。为此我们可以修改“/etc/profile”文件（或者/etc/bashrc文件）。

sudo vim /etc/profile

然后在文件的最后一行，添加下面的内容，然后保存退出。

export PATH=/usr/local/git/bin:$PATH

（7）使用source命令应用修改。

source /etc/profile

（8）然后再次使用git --version 查看git版本，发现输出2.21.0，表明安装成功。

2. 设置Git

（1）设置用户名和email。

git config --global user.name "Your Name" git config --global user.email "youremail@domain.com"

此时，Home目录下会新建一个.gitconfig文件

3. 为GitHub账号添加SSH Keys

以公钥认证方式访问SSH协议的Git服务器时无需输入口令，而且更安全。（访问HTTP协议的Git服务器时，比如提交修改，每次都需要输入口令。）

（1）创建SSH key

$ ssh-keygen -t rsa -C "email@maruifu.cn"

系统会提示key的保存位置（一般是~/.ssh目录）和指定口令，保持默认，连续三次回车即可。

（2）Copy SSH Key

然后用vim打开该文件，id_rsa.pub文件内的内容，粘帖到github帐号管理的添加SSH key界面中。

vim ~/.ssh/id_rsa.pub

（3）添加到GitHub

登录github-> Accounting settings图标-> SSH key-> Add SSH key-> 填写SSH key的名称（可以起一个自己容易区分的），然后将拷贝的~/.ssh/id_rsa.pub文件内容粘帖-> add key”按钮添加。

（4）测试

ssh -T git@github.com

4. 为GitHub上的Repository提交修改

（1）git clone已存在GitHub上的Repository。（在新建的~/MyTestFolder目录中）

git clone https://github.com/MaRuifu/maruifu.git

（2）修改一个文件，然后提交

vim README.md git status git add README.md git status git commit -m "init" git status git remote add origin https://github.com/MaRuifu/maruifu.git

这时会报错误：

fatal: remote origin already exists.

解决办法【3】：

$ git remote rm origin

然后再次执行 git remote add origin https://github.com/MaRuifu/maruifu.git

（3）之后，需要将修改push到GitHub上

git push -u origin master

执行该条命令后，会要求输入GitHub账户的用户名和密码。

（4）提交完成后，查看GitHub上的Repository，会发现内容修改成功。

浏览器的数据存储方法比较

Tue, 03 Dec 2024 01:30:50 GMT

现代浏览器中可用的存储 API

首先，让我们简要概述一下不同的 API、它们的目的用例和历史：

什么是 Cookies

Cookies 首次由netscape在 1994 年引入。Cookies 存储一些键值数据的小片段，主要用于会话管理、个性化跟踪。Cookies 可以设置多个安全选项，如生存时间或域名属性，以便在多个子域之间共享 Cookies。

Cookies 的值不仅存储在客户端，还与每个 HTTP 请求一起发送到服务器。这意味着我们无法在 Cookie 中存储大量数据，但与其他方法相比，Cookie 的访问性能仍然很有趣。特别是由于 Cookie 是网络的一个重要基本功能，已经进行了许多性能优化，甚至在这些日子里，像 chromium 的共享内存版本或异步的CookieStore API这样的进步仍在继续。

什么是 LocalStorage

localStorage API 首次于 2009 年作为[WebStorage 规范的一部分被提出。LocalStorage 提供了一个简单的 API，用于在网页浏览器内部存储键值对。它具有setItem、getItem、removeItem和clear等方法，这些都是从键值存储中所需的所有功能。LocalStorage 仅适用于存储需要跨会话持久的小量数据，并且它受到5MB 存储容量的限制。存储复杂数据只能通过将其转换为字符串来实现，例如使用JSON.stringify()。该 API 不是异步的，这意味着在进行操作时将完全阻塞您的 JavaScript 进程。因此，在它上面运行重操作可能会阻止 UI 渲染。

也存在 SessionStorage API。主要区别在于 localStorage 数据会无限期持续，直到明确清除，而 sessionStorage 数据在浏览器标签页或窗口关闭时会被清除。

什么是 IndexedDB

IndexedDB 首次作为“索引数据库 API”于 2015 年推出。在。

IndexedDB是一个用于存储大量结构化 JSON 数据的低级 API。虽然该 API 使用起来有些困难，但 IndexedDB 可以利用索引和异步操作。它不支持复杂查询，并且只允许遍历索引，这使得它更像是一个其他库的基础层，而不是一个完整的数据库。

2018 年，引入了 IndexedDB 版本 2.0 。这增加了一些主要改进。最显著的是getAll()方法，在获取大量 JSON 文档时显著提高了性能。

IndexedDB 版本 3.0正在开发中，其中包含许多改进。最重要的是增加了基于Promise的调用，这使得现代 JS 特性如async/await更加有用。

什么是 OPFS

《原始私有文件系统》（OPFS）是一个相对较新的API，允许 Web 应用程序直接在浏览器中存储大文件。它旨在为想要在模拟文件系统中写入和读取二进制数据的数据密集型应用程序设计。

OPFS 可以使用两种模式：

或者异步在主线程上
或者在 WebWorker 中使用更快的异步访问，通过createSyncAccessHandle()方法。

因为只有二进制数据可以被处理，OPFS 被设计成库开发者的基础文件系统。当你构建一个“正常”的应用程序时，你不太可能直接在你的代码中使用 OPFS，因为它太复杂了。这仅适用于存储像图像这样的普通文件，而不是高效地存储和查询 JSON 数据。我为 RxDB 构建了一个基于 OPFS 的存储，并进行了适当的索引和查询，这花了我几个月的时间。

什么是 WASM SQLite

WebAssembly（Wasm）是一种允许在网络上执行高性能代码的二进制格式。Wasm 于 2017 年被添加到主流浏览器中，这为在浏览器内部运行的内容开辟了广泛的机会。您可以将本地库编译成 WebAssembly，只需进行少量调整即可在客户端运行。WASM 代码可以发送到浏览器应用程序，通常比 JavaScript 运行得快得多，但仍然比本地代码慢约10%。

许多人开始将编译后的 SQLite 用作浏览器内的数据库，这就是为什么将这种设置与原生 API 进行比较也很有意义。

SQLite 编译的字节码大小约为 938.9 KB，必须在第一次页面加载时由用户下载并解析。WASM 不能直接访问浏览器中的任何持久存储 API。相反，它需要数据从 WASM 流向主线程，然后才能放入浏览器 API 之一。这是通过所谓的虚拟文件系统（VFS）适配器来完成的，它处理从 SQLite 到其他任何数据访问。

什么是 WebSQL

WebSQL 曾是一个在 2009 年引入的 Web API，允许浏览器使用基于 SQLite 的 SQL 数据库进行客户端存储。该想法是为开发者提供一种在客户端使用 SQL 存储和查询数据的方法，类似于服务器端数据库。由于多个良好原因，WebSQL 在近年已被从浏览器中移除。

WebSQL 没有标准化，基于 SQLite 源代码这种单一具体实现的 API 很难使其成为标准。
WebSQL 需要浏览器使用 SQLite（版本 3.6.19）的特定版本（特定版本），这意味着每当 SQLite 有任何更新或错误修复时，都无法将其添加到 WebSQL 中，否则可能会破坏网络。
主流浏览器如 Firefox 从未支持 WebSQL。

因此，在以下内容中，我们甚至会忽略 WebSQL，即使通过设置特定的浏览器标志或使用旧版本的 Chromium 来运行测试也是可能的。

功能比较

现在您已经了解了 API 的基本概念，让我们比较一些对使用 RxDB 和基于浏览器的存储的人来说非常重要的特定功能。

存储复杂的 JSON 文档

当你在一个 Web 应用程序中存储数据时，通常你想要存储复杂的 JSON 文档，而不仅仅是存储在服务器端数据库中的“正常”值，如整数和字符串。

仅 IndexedDB 原生支持 JSON 对象。
使用 SQLite WASM，您可以从版本 3.38.0（2022-02-22）开始，在文本列中存储 JSON，甚至可以对它进行深度查询，并使用单个属性作为索引。

每个其他 API 只能存储字符串或二进制数据。当然，您可以使用JSON.stringify()将任何 JSON 对象转换为字符串，但如果没有在 API 中支持 JSON，则在运行查询时会使事情变得复杂。多次运行JSON.stringify()可能会引起性能问题。

多标签支持

构建 Web 应用与Electron或React-Native相比的一个显著区别是，用户将同时在多个浏览器标签中打开和关闭应用。因此，您不仅有一个 JavaScript 进程在运行，而且可能有多个进程存在，并且可能需要在它们之间共享状态变化，以避免向用户显示过时数据。

如果你的用户在浏览你的网站时，肌肉记忆让左手放在了键上，那么你肯定做错了什么！

并非所有存储 API 都支持在标签页之间自动共享写事件的方式。

只有 localStorage 有通过 API 本身以自动在标签页之间共享写事件的方式，该事件可用于观察变化。

// localStorage can observe changes with the storage event. // This feature is missing in IndexedDB and others addEventListener("storage", (event) => {});

存在一个用于 Chrome 的实验性 IndexedDB 观察者 API，但该提案仓库已被存档。

为了解决这个问题，有两种解决方案：

第一个选项是使用BroadcastChannel API，它可以在浏览器标签页之间发送消息。所以每次您向存储写入时，也会向其他标签页发送通知，告知它们这些更改。这是最常用的解决方案，RxDB 也使用了它。请注意，还有一个WebLocks API，可以用于在浏览器标签页之间实现互斥锁。
另一种解决方案是使用SharedWorker并在其中执行所有写入操作。然后所有浏览器标签都可以订阅来自那个单个SharedWorker 的消息，并了解变化。

索引支持

数据库与在普通文件中存储数据之间的主要区别在于，数据库以允许在索引上运行操作以简化快速查询的格式写入数据。在我们的技术列表中，只有 IndexedDB 和 WASM SQLite 支持开箱即用的索引功能。从理论上讲，您可以在任何存储上构建索引，如 localstorage 或 OPFS，但您可能不想自己这样做。

在 IndexedDB 中，例如，我们可以通过给定的索引范围获取大量文档：

// find all products with a price between 10 and 50 const keyRange = IDBKeyRange.bound(10, 50); const transaction = db.transaction('products', 'readonly'); const objectStore = transaction.objectStore('products'); const index = objectStore.index('priceIndex'); const request = index.getAll(keyRange); const result = await new Promise((res, rej) => {   request.onsuccess = (event) => res(event.target.result);   request.onerror = (event) => rej(event); });

请注意，IndexedDB 有一个限制，即布尔值没有索引。您只能索引字符串和数字。为了解决这个问题，您需要在存储数据时将布尔值转换为数字，并在读取时反向转换。

WebWorker 支持

在运行大量数据处理操作时，您可能希望将处理过程从 JavaScript 主线程移开。这确保了我们的应用始终保持响应和快速，同时处理可以在后台并行运行。在浏览器中，您可以使用WebWorker、SharedWorker或ServiceWorker API 来完成此操作。在 RxDB 中，您可以使用WebWorker或SharedWorker插件将您的存储移动到工作线程内部。

该用例最常用的 API 是通过创建一个WebWorker并在第二个 JavaScript 进程中完成大部分工作。这个工作进程是从一个单独的 JavaScript 文件（或 base64 字符串）中生成的，并通过使用postMessage()发送数据与主线程进行通信。

很不幸，由于设计和安全限制，LocalStorage 和 Cookies 以及不能在 WebWorker 或 SharedWorker 中使用。WebWorkers 在与主浏览器线程分离的独立全局上下文中运行，因此无法执行可能影响主线程的操作。它们无法直接访问某些 Web API，如 DOM、localStorage 或 cookies。

所有其他内容都可以在 WebWorker 内部使用。带有createSyncAccessHandle方法的 OPFS 快速版本可以仅在 WebWorker 中使用不能在主线程上使用。这是因为返回的AccessHandle的所有操作都是非异步的，因此会阻塞 JavaScript 进程，所以你不想在主线程上执行并阻塞一切。

存储大小限制

Cookies 的大小限制在约 4 KB 的数据内，位于 RFC-6265 中。由于存储的 Cookies 会随着每个 HTTP 请求发送到服务器，因此这种限制是合理的。您可以在这里测试您浏览器的 Cookies 限制。请注意，您永远不应该填满您 Cookies 的全部 4 KB，因为您的 web 服务器不会接受太长的头部信息，并会拒绝带有 HTTP ERROR 431 - Request header fields too large 的请求。一旦达到这一点，您甚至无法为用户提供更新的 JavaScript 来清理 Cookies，您将无法访问该用户，直到手动清理 Cookies 为止。
LocalStorage 的大小限制因浏览器而异，但通常每个源的大小在 4MB 到 10MB 之间。您可以在这里测试您的 localStorage 大小限制。
- Chrome/Chromium/Edge：每个域名 5 MB
- Firefox：每个域名 10 MB
- Safari：每个域名 4-5 MB（版本之间略有差异）
IndexedDB没有像 localStorage 那样的特定固定大小限制。IndexedDB 的最大存储大小取决于浏览器的实现。上限通常基于用户设备上的可用磁盘空间。在 Chromium 浏览器中，它可以使用高达 80%的总磁盘空间。您可以通过调用 await navigator.storage.estimate() 来获取存储大小限制的估计。通常，您可以存储数 GB 的数据，您可以在这里尝试。
OPFS 具有与 IndexedDB 相同的存储大小限制。其限制取决于可用磁盘空间。这也可以在这里测试。

性能比较

现在我们已经审查了每种存储方法的特性，让我们深入了解性能比较，重点关注初始化时间、读写延迟和批量操作。

请注意，我们只运行简单的测试，并且对于您在应用程序中的特定用例，结果可能会有所不同。此外，我们只在谷歌 Chrome（版本 128.0.6613.137）中比较性能。Firefox 和 Safari 有类似但并不完全相同的性能模式。您可以从这个GitHub 仓库自行在您的机器上运行测试。对于所有测试，我们将网络速度限制为平均德国互联网速度。（下载：135,900 kbit/s，上传：28,400 kbit/s，延迟：125ms）。此外，所有测试都存储一个“平均”的 JSON 对象，根据存储可能需要将其转换为字符串。我们还只测试通过 id 存储文档的性能，因为某些技术（cookies、OPFS 和 localStorage）不支持索引范围操作，所以比较这些技术的性能没有意义。

初始化时间

在您存储任何数据之前，许多 API 需要设置过程，例如创建数据库、启动 WebAssembly 进程或下载额外内容。为了确保您的应用启动速度快，初始化时间很重要。

localStorage 和 Cookies 的 API 无需设置过程，可直接使用。IndexedDB 需要打开一个数据库及其内部的存储。WASM SQLite 需要下载 WASM 文件并处理它。OPFS 需要下载并启动一个工作文件，初始化虚拟文件系统目录。

这里是从第一次能够存储数据所需时间的时间测量结果：

技术	时间（毫秒）
IndexedDB	46
OPFS Main Thread	23
OPFS WebWorker	26.8
WASM SQLite (memory)	504
WASM SQLite (IndexedDB)	535

这里我们可以注意到一些事情：

打开一个包含单个存储的新的 IndexedDB 数据库需要相当长的时间
主线程向 WebWorker OPFS 发送数据的延迟开销大约为 4 毫秒。在这里，我们只发送最小数据以初始化 OPFS 文件处理器。如果处理更多数据时延迟增加，那将很有趣。
下载并解析 WASM SQLite 以及创建单个表大约需要半秒钟。使用 IndexedDB VFS 存储数据持久化额外增加了 31 毫秒。启用缓存并已准备好的表重新加载页面会更快，大约 420 毫秒（内存）。

小写延迟

接下来，让我们测试小写操作的延迟。当你进行许多相互独立的小数据更改时，这很重要。比如当你从 WebSocket 流数据或持久化伪随机发生的事件，如鼠标移动时。

技术	时间（毫秒）
Cookies	0.058
LocalStorage	0.017
IndexedDB	0.17
OPFS Main Thread	1.46
OPFS WebWorker	1.54
WASM SQLite (memory)	0.17
WASM SQLite (IndexedDB)	3.17

这里我们可以注意到一些事情：

LocalStorage 具有最低的写入延迟，每次写入仅需 0.017 毫秒。
IndexedDB 的写入速度比 localStorage 慢约 10 倍。
发送数据到 WASM SQLite 进程并通过 IndexedDB 持久化，每次写入超过 3 毫秒都很慢。

OPFS 操作将 JSON 数据写入一个文档大约需要 1.5 毫秒。我们可以看到，首先将数据发送到 webworker 会稍微慢一些，这源于在双方序列化和反序列化数据时的开销。如果我们不是为每个文档创建一个 OPFS 文件，而是将所有内容追加到单个文件中，性能模式将发生显著变化。然后，从createSyncAccessHandle()创建的更快文件句柄每次写入只需大约 1 毫秒。但这需要以某种方式记住每个文档存储的位置。因此，在我们的测试中，我们将继续使用每个文档一个文件的方式。

小读操作延迟

现在我们已经存储了一些文档，让我们通过它们的id来测量读取单个文档所需的时间。

技术	时间（毫秒）
Cookies	0.132
LocalStorage	0.0052
IndexedDB	0.1
OPFS Main Thread	1.28
OPFS WebWorker	1.41
WASM SQLite (memory)	0.45
WASM SQLite (IndexedDB)	2.93

这里我们可以注意到一些事情：

LocalStorage 的读取速度非常快，每次读取仅需 0.0052 毫秒。
其他技术以与它们的写入延迟相似的速度执行读取操作。

大量写入

下一步，让我们一次性处理 200 份文档的大批量操作。

技术	时间（毫秒）
Cookies	20.6
LocalStorage	5.79
IndexedDB	13.41
OPFS Main Thread	280
OPFS WebWorker	104
WASM SQLite (memory)	19.1
WASM SQLite (IndexedDB)	37.12

这里我们可以注意到一些事情：

将数据发送到 WebWorker 并通过更快的 OPFS API 运行，大约快两倍。
WASM SQLite 在批量操作方面比其单次写入延迟表现更好。这是因为如果一次发送数据到 WASM 和反向传输，比每次处理一个文档要快。

大量读取

现在让我们一次性读取 100 份文档。

技术	时间（毫秒）
Cookies	6.34
LocalStorage	0.39
IndexedDB	4.99
OPFS Main Thread	54.79
OPFS WebWorker	25.61
WASM SQLite (memory)	3.59
WASM SQLite (IndexedDB)	5.84 (35ms without cache)

这里我们可以注意到一些事情：

在 OPFS webworker 中读取许多文件的速度比较慢的主线程模式快约两倍。
WASM SQLite 非常快。进一步检查显示，WASM SQLite 进程将文档保存在内存缓存中，这提高了我们在写入相同数据后直接读取时的延迟。当在写入和读取之间重新加载浏览器标签时，找到 100 份文档需要大约 35 毫秒。

性能结论

本地存储真的很快，但请记住它也有一些缺点：
- 它阻塞了主要的 JavaScript 进程，因此不应用于大量操作。
- 只有键值赋值是可能的，当你需要基于索引的范围内查询数据时，无法高效地使用它。
OPFS 在 WebWorker 中使用时，与在主线程中直接使用相比，使用createSyncAccessHandle()方法要快得多。
SQLite WASM 可以很快，但你最初必须下载完整的二进制文件并启动它，这大约需要半秒钟。如果你的应用程序只启动一次并且长时间使用，这可能根本无关紧要。但对于在许多浏览器标签中多次打开和关闭的 Web 应用程序，这可能会成为一个问题。

MySQL 5.7 - 通过 BINLOG 恢复数据

Mon, 18 Nov 2024 08:04:00 GMT

日常开发，运维中，经常会出现误删数据的情况。误删数据的类型大致可分为以下几类：

使用 delete 误删行
使用 drop table 或 truncate table 误删表
使用 drop database 语句误删数据库
使用 rm 命令误删整个 MySQL 实例。

不同的情况，都会有其优先的解决方案：

针对误删行，可以通过 Flashback 工具将数据恢复
针对误删表或库，一般采用通过 BINLOG 将数据恢复。
而对于误删 MySQL 实例，则需要我们搭建 HA 的 MySQL 集群，并保证我们的数据跨机房，跨城市保存。

本篇主要讨论的内容是误删表或者库，会先介绍有关 BINLOG 的操作命令，然后会对误删表的这种情况进行实际的模拟。

BINLOG 常见操作命令

BINLOG 的查询方式一般分为两种，一种是进入 MySQL 控制台进行查询，另一种是通过 MySQL 提供的工具 mysqlbinlog 进行查询，两者的不同会在下面介绍。

通过 MySQL Cli 查询 BINLOG 信息

在 cli 中，常见的命令如下：

# 查询 BINLOG 格式 show VARIABLES like 'binlog_format';  # 查询 BINLOG 位置 show VARIABLES like 'datadir';  # 查询当前数据库中 BINLOG 名称及大小 show binary logs;  # 查看 master 正在写入的 BINLOG 信息 show master status\G;  # 通过 offset 查看 BINLOG 信息 show BINLOG events in 'mysql-bin.000034' limit 9000,  10;  # 通过 position 查看 binlog 信息 show BINLOG events in 'mysql-bin.000034' from 1742635 limit 10;

使用 show BINLOG events 的问题：

使用该命令时，如果当前 binlog 文件很大，而且没有指定 limit，会引发对资源的过度消耗。因为 MySQL 客户端需要将 binlog 的全部内容处理，返回并显示出来。为了防止这种情况，mysqlbinlog 工具是一个很好的选择。

通过 mysqlbinlog 查询 BINLOG 信息

在介绍 mysqlbinlog 工具使用前，先来看下 BINLOG 文件的内容：

mysqlbinlog  --no-defaults mysql-bin.000034 | less # at 141 #100309  9:28:36 server id 123  end_log_pos 245   Query thread_id=3350  exec_time=11  error_code=0

at 表示 offset 或者说事件开始的起始位置
100309 9:28:36 server id 123 表示 server 123 开始执行事件的日期
end_log_pos 245 表示事件的结束位置 + 1，或者说是下一个事件的起始位置。
exec_time 表示在 master 上花费的时间，在 salve 上，记录的时间是从 Master 记录开始，一直到 Slave 结束完成所花费的时间。
rror_code=0 表示没有错误发生。

在大致了解 binlog 的内容后，mysqlbinlog 的用途有哪些？：

mysqlbinlog 可以作为代替 cli 读取 binlog 的工具。
mysqlbinlog 可以将执行过的 SQL 语句输出，用于数据的恢复或备份。

查询 BINLOG 日志：

# 查询规定时候后发生的 BINLOG 日志 mysqlbinlog --no-defaults --base64-output=decode-rows -v \  --start-datetime  "2019-11-22 14:00:00" \  --database sync_test  mysql-bin.000034 | less

导出 BINLOG 日志，用于分析和排查 sql 语句：

mysqlbinlog --no-defaults --base64-output=decode-rows -v \  --start-datetime  "2019-11-22 14:00:00" \  --database sync_test \  mysql-bin.000034 > /home/mysql_backup/binlog_raw.sql

导入 BINLOG 日志

# 通过 BINLOG 进行恢复。 mysqlbinlog --start-position=1038 --stop-position=1164 \  --database=db_name  mysql-bin.000034 | \  mysql  -u cisco -p db_name  # 通过 BINLOG 导出的 sql 进行恢复。 mysql -u cisco -p db_name < binlog_raw.sql

mysqlbinlog 的常用参数：

--database 仅仅列出配置的数据库信息
--no-defaults 读取没有选项的文件, 指定的原因是由于 mysqlbinlog 无法识别 BINLOG 中的 default-character-set=utf8 指令
--offset 跳过 log 中 N 个条目
--verbose 将日志信息重建为原始的 SQL 陈述。
- -v 仅仅解释行信息
- -vv 不但解释行信息，还将 SQL 列类型的注释信息也解析出来
--start-datetime显示从指定的时间或之后的时间的事件。
- 接收 DATETIME 或者 TIMESTRAMP 格式。
--base64-output=decode-rows将 BINLOG 语句中事件以 base-64 的编码显示，对一些二进制的内容进行屏蔽。
- AUTO 默认参数，自动显示 BINLOG 中的必要的语句
- NEVER 不会显示任何的 BINLOG 语句，如果遇到必须显示的 BINLOG 语言，则会报错退出。
- DECODE-ROWS 显示通过 -v 显示出来的 SQL 信息，过滤到一些 BINLOG 二进制数据。

MySQL Cli 和 mysqlbinlog 工具之间的比较#

如果想知道当前 MySQL 中正在写入的 BINLOG 的名称，大小等基本信息时，可以通过 Cli 相关的命令来查询。

但想查询，定位，恢复 BINLOG 中具体的数据时，要通过 mysqlbinlog 工具，因为相较于 Cli 来说，mysqlbinlog 提供了 --start-datetime，--stop-position 等这样更为丰富的参数供我们选择。这时 Cli 中 SHOW BINLOG EVENTS 的简要语法就变得相形见绌了。

使用 BINLOG 恢复数据

恢复的大致流程如下：

1. 会创建数据库和表，并插入数据。
1. 误删一条数据。
1. 继续插入数据。
1. 误删表。
1. 最后将原来以及之后插入的数据进行恢复。

准备数据

准备数据库，表及数据：

# 创建临时数据库 CREATE DATABASE IF NOT EXISTS test_binlog \ default charset utf8 COLLATE utf8_general_ci;    # 创建临时表 CREATE TABLE `sync_test` (`id` int(11) \ NOT NULL AUTO_INCREMENT, `name` varchar(255) NOT NULL,  \ PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;  # 添加数据 insert into sync_test (id, name) values (null, 'xiaoa'); insert into sync_test (id, name) values (null, 'xiaob'); insert into sync_test (id, name) values (null, 'xiaoc');  # 查看添加的数据 select * from sync_test;

删除表或者数据

误删操作：

# 删除 name=xiaob 的数据 delete from sync_test where id=3  # 插入几条数据 insert into sync_test (id, name) values (null, 'xiaod'); insert into sync_test (id, name) values (null, 'xiaoe'); insert into sync_test (id, name) values (null, 'xiaof');  # 删除表 DROP TABLE sync_test;

数据的恢复

在执行数据恢复前，如果操作的是生产环境，会有如下的建议：

使用 flush logs 命令，替换当前主库中正在使用的 binlog 文件，好处如下：
- 可将误删操作，定位在一个 BINLOG 文件中，便于之后的数据分析和恢复。
- 避免操作正在被使用的 BINLOG 文件，防止发生意外情况。
数据的恢复不要在生产库中执行，先在临时库恢复，确认无误后，再倒回生产库。防止对数据的二次伤害。

通常来说，恢复主要有两个步骤：

在临时库中，恢复定期执行的全量备份数据。
然后基于全量备份的数据点，通过 BINLOG 来恢复误操作和正常的数据。

使用 BINLOG 做数据恢复前：

# 查看正在使用的 Binlog 文件 show master status\G; # 显示结果是： mysql-bin.000034  # 执行 flush logs 操作，生成新的 BINLOG flush logs;  # 查看正在使用的 Binlog 文件 show master status\G; # 结果是：mysql-bin.000035

确定恢复数据的步骤：

这里主要是有两条误删的操作，数据行的误删和表的误删。有两种方式进行恢复。

方式一：首先恢复到删除表操作之前的位置，然后再单独恢复误删的数据行。
方式二：首先恢复到误删数据行的之前的位置，然后跳过误删事件再恢复数据表操作之前的位置。

这里采用方式一的方案进行演示，由于是演示，就不额外找一个临时库进行全量恢复了，直接进行操作。

查询创建表的事件位置和删除表的事件位置

#  根据时间确定位置信息 mysqlbinlog --no-defaults --base64-output=decode-rows -v \  --start-datetime  "2019-11-22 14:00:00" \  --database test_binlog  mysql-bin.000034 | less

创建表的开始位置：

删除表的结束位置：

插入 name='xiaob' 的位置：

# 根据位置导出 SQL 文件 mysqlbinlog --no-defaults --base64-output=decode-rows -v \  --start-position "2508132" --stop-position "2511004" \  --database test_binlog  mysql-bin.000034 \  > /home/mysql_backup/test_binlog_step1.sql     mysqlbinlog --no-defaults --base64-output=decode-rows -v \  --start-position "2508813" --stop-position "2509187" \  --database test_binlog  mysql-bin.000034 \  > /home/mysql_backup/test_binlog_step2.sql    # 使用 mysql 进行恢复 mysql -u cisco -p < /home/mysql_backup/test_binlog_step1.sql mysql -u cisco -p < /home/mysql_backup/test_binlog_step2.sql

MySQL 5.7 中无论是否打开 GTID 的配置，在每次事务开启时，都首先会出 GTID 的一个事务，用于并行复制。所以在确定导出开始事务位置时，要算上这个事件。

在使用 --stop-position 导出时，会导出在指定位置的前一个事件，所以这里要推后一个事务。

对于 DML 的语句，主要结束位置要算上 COMMIT 的位置。

总结

在文章开始时，我们熟悉了操作 BINLOG 的两种方式 CLI 和 mysqlbinlog 工具，接着介绍了其间的区别和使用场景，对于一些大型的 BINLOG 文件，使用 mysqlbinlog 会更加的方便和效率。并对 mysqlbinlog 的一些常见参数进行了介绍。

接着通过使用 mysqlbinlog 实际模拟了数据恢复的过程，并在恢复数据时，提出了一些需要注意的事项，比如 flush logs 等。

最后在恢复数据时，要注意 start-position 和 end-position 的一些小细节，来保证找到合适的位置。

参考

point-in-time-recovery

recovery-from-backups

backup-policy.

转自: Ez啊

Mac电脑无法将U盘格式化(抹除)为APFS格式的解决

Mon, 18 Nov 2024 07:42:47 GMT

概览

很多小伙伴把新买的U盘插在Mac上，然后想把它格式化（抹除）为APFS格式。但却只能选择旧的Mac OS 扩展类型格式，压根看不到APFS格式的选项

如图所示，在U盘抹除中根本看不到 APFS 格式。

APFS 格式的优势

APFS 是 Apple File System 的简称，它最早发布于2016年6月，实际在2017年发布的 macOS High Sierra 10.13 开发者预览版中首先启用，用来替代旧 HFS+ 文件系统。

APFS格式的特点是： “优化闪存/SSD存储，并以加密为主要功能”，在I/O联合上使用了“独特的copy-on-write设计”，在确保可靠性的基础上优化性能。

一句话总结：APFS 格式与其前代格式相比具有许多优势，它已针对SSD和闪存驱动器进行了优化，最适合闪存和固态驱动器。

可以看到，使用 APFS 格式在Mac系统上可以最高效的操作U盘。

原因

之所以在格式化（抹除）操作中看不到 APFS 格式，是因为当前U盘分区表格式是主引导记录（MBR）格式。

注意，该格式是U盘分区表的格式，而不是格式化的格式。

解决起来很简单，我们只需将U盘分区表格式设置为GPT格式（GUID分区表）即可

设置

首先，插上U盘，打开Mac系统中自带的磁盘工具程序，选择显示所有设备

接着，选择整个U盘设备（左侧“外置”菜单里最顶层的项目），而不是选择其中的容器或卷：

然后，点击程序顶部的抹除按钮，在弹出的窗口中的分区方案里选择 GUID 分区图：

现在，可以在格式里选择 APFS 格式了：

Parallels Desktop 给Linux增加磁盘大小

Thu, 31 Oct 2024 06:47:00 GMT

默认安装镜像只分配了64G ,安装之前还不能修改硬盘大小

修改虚拟机分配的大小

设置->硬盘

列出块设备信息

[root@AlmaLinux ~]# lsblk NAME                         MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS sda                            8:0    0  200G  0 disk  ├─sda1                         8:1    0  600M  0 part /boot/efi ├─sda2                         8:2    0    1G  0 part /boot └─sda3                         8:3    0 62.4G  0 part    ├─almalinux_almalinux-root 253:0    0 40.6G  0 lvm  /   ├─almalinux_almalinux-swap 253:1    0    2G  0 lvm  [SWAP]   └─almalinux_almalinux-home 253:2    0 19.8G  0 lvm  /home

查看磁盘的分区和未分配空间

[root@AlmaLinux ~]# sudo parted /dev/sda print free 型号：ATA AlmaLinux-0 SSD (scsi) 磁盘 /dev/sda：215GB 扇区大小 (逻辑/物理)：512B/4096B 分区表：gpt 磁盘标志：  编号  起始点  结束点  大小    文件系统  名称                  标志       17.4kB  1049kB  1031kB  可用空间  1    1049kB  630MB   629MB   fat32     EFI System Partition  启动, esp  2    630MB   1704MB  1074MB  xfs  3    1704MB  68.7GB  67.0GB                                  lvm       68.7GB  215GB   146GB   可用空间

创建物理卷 (PV)

创建新分区

sudo parted /dev/sda

在parted提示符下输入:

mkpart primary 68.7GB 215GB print quit

查看新分区

[root@AlmaLinux ~]# lsblk NAME                         MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS sda                            8:0    0  200G  0 disk  ├─sda1                         8:1    0  600M  0 part /boot/efi ├─sda2                         8:2    0    1G  0 part /boot ├─sda3                         8:3    0 62.4G  0 part  │ ├─almalinux_almalinux-root 253:0    0 40.6G  0 lvm  / │ ├─almalinux_almalinux-swap 253:1    0    2G  0 lvm  [SWAP] │ └─almalinux_almalinux-home 253:2    0 19.8G  0 lvm  /home └─sda4                         8:4    0  136G  0 part  sr0                           11:0    1 1024M  0 rom

sda4 就是新分区的名字

格式化新分区为物理卷

[root@AlmaLinux ~]# pvcreate /dev/sda4   Physical volume "/dev/sda4" successfully created.

扩展卷组以包含新的物理卷

查看当前的卷组

[root@AlmaLinux ~]# vgdisplay   --- Volume group ---   VG Name               almalinux_almalinux   System ID                Format                lvm2   Metadata Areas        1   Metadata Sequence No  6   VG Access             read/write   VG Status             resizable   MAX LV                0   Cur LV                3   Open LV               3   Max PV                0   Cur PV                1   Act PV                1   VG Size               62.41 GiB   PE Size               4.00 MiB   Total PE              15977   Alloc PE / Size       15977 / 62.41 GiB   Free  PE / Size       0 / 0      VG UUID               3b18iP-pPQ6-5iEe-91AQ-2edY-N6Py-FvzC2u

将新的物理卷添加到卷组

[root@AlmaLinux ~]# vgextend almalinux_almalinux /dev/sda4   Volume group "almalinux_almalinux" successfully extended

最下面146GB就是我要扩容的空间大小

扩展根逻辑卷

查看现有逻辑卷

[root@AlmaLinux ~]# lvdisplay   --- Logical volume ---   LV Path                /dev/almalinux_almalinux/swap   LV Name                swap   VG Name                almalinux_almalinux   LV UUID                m2JM1L-Mgmw-m7dP-4RRg-mZJ9-CbIX-LFA8fZ   LV Write Access        read/write   LV Creation host, time AlmaLinux, 2024-10-31 10:53:43 +0800   LV Status              available   # open                 2   LV Size                1.99 GiB   Current LE             510   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:1       --- Logical volume ---   LV Path                /dev/almalinux_almalinux/home   LV Name                home   VG Name                almalinux_almalinux   LV UUID                eA0RJ4-2s4J-tb1F-3ivQ-cCVd-CBxw-EdmwX4   LV Write Access        read/write   LV Creation host, time AlmaLinux, 2024-10-31 10:53:44 +0800   LV Status              available   # open                 1   LV Size                19.82 GiB   Current LE             5074   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:2       --- Logical volume ---   LV Path                /dev/almalinux_almalinux/root   LV Name                root   VG Name                almalinux_almalinux   LV UUID                g1U1xP-j8dE-so1R-LFeA-EF40-D1O7-51XtQc   LV Write Access        read/write   LV Creation host, time AlmaLinux, 2024-10-31 10:53:44 +0800   LV Status              available   # open                 1   LV Size                <40.60 GiB   Current LE             10393   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:0

扩展根逻辑卷

现在，你可以使用lvextend命令来扩展根逻辑卷almalinux_almalinux-root，以使用新添加的空间。

[root@AlmaLinux ~]# lvextend -l +100%FREE  /dev/almalinux_almalinux/root   Size of logical volume almalinux_almalinux/root changed from <40.60 GiB (10393 extents) to 176.59 GiB (45208 extents).   Logical volume almalinux_almalinux/root successfully resized.

调整文件系统大小

查看文件系统类型

[root@AlmaLinux ~]# df -T 文件系统                             类型         1K-块    已用      可用 已用% 挂载点 devtmpfs                             devtmpfs      4096       0      4096    0% /dev tmpfs                                tmpfs      8006968       0   8006968    0% /dev/shm tmpfs                                tmpfs      3202788    9676   3193112    1% /run /dev/mapper/almalinux_almalinux-root xfs      109608960 6012672 103596288    6% / /dev/mapper/almalinux_almalinux-home xfs       20717568  185280  20532288    1% /home /dev/sda2                            xfs         983040  276528    706512   29% /boot /dev/sda1                            vfat        613160    7196    605964    2% /boot/efi tmpfs                                tmpfs      1601392     136   1601256    1% /run/user/1000 tmpfs                                tmpfs      1601392      36   1601356    1% /run/user/0

调整文件系统大小

扩展文件系统以使用新增加的空间。假设你使用的是 ext4 文件系统：

resize2fs /dev/almalinux_almalinux/root

如果使用其他文件系统，比如 xfs，可以用：

[root@AlmaLinux ~]# xfs_growfs / meta-data=/dev/mapper/almalinux_almalinux-root isize=512    agcount=18, agsize=2660608 blks          =                       sectsz=4096  attr=2, projid32bit=1          =                       crc=1        finobt=1, sparse=1, rmapbt=0          =                       reflink=1    bigtime=1 inobtcount=1 nrext64=0 data     =                       bsize=4096   blocks=46292992, imaxpct=25          =                       sunit=0      swidth=0 blks naming   =version 2              bsize=4096   ascii-ci=0, ftype=1 log      =internal log           bsize=4096   blocks=16384, version=2          =                       sectsz=4096  sunit=1 blks, lazy-count=1 realtime =none                   extsz=4096   blocks=0, rtextents=0

成功扩容

[root@AlmaLinux ~]# lsblk NAME                         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS sda                            8:0    0   200G  0 disk  ├─sda1                         8:1    0   600M  0 part /boot/efi ├─sda2                         8:2    0     1G  0 part /boot ├─sda3                         8:3    0  62.4G  0 part  │ ├─almalinux_almalinux-root 253:0    0 176.6G  0 lvm  / │ ├─almalinux_almalinux-swap 253:1    0     2G  0 lvm  [SWAP] │ └─almalinux_almalinux-home 253:2    0  19.8G  0 lvm  /home └─sda4                         8:4    0   136G  0 part    └─almalinux_almalinux-root 253:0    0 176.6G  0 lvm  /

大语言模型（AI）接入小爱音箱

Wed, 23 Oct 2024 16:16:00 GMT

家里闲置了一个小米 mini 音箱，打算接入大模型试试,,从“人工智障”秒变学霸。

🔊 支持的小爱音箱型号

✅ 完美运行

已知可以完美运行 MiGPT 的小爱音箱型号有：

名称	型号	ttsCommand	wakeUpCommand	playingCommand	streamResponse	反馈来源
小爱音箱 Pro	LX06	`[5, 1]`	`[5, 3]`	-	true	@idootop
小爱音箱 mini	LX01	`[5, 1]`	`[5, 2]`	`[4, 1, 1]`	true	@gsscsd
小爱音箱 Play（2019 款）	LX05	`[5, 1]`	`[5, 3]`	`[3, 1, 1]`	true	@wt666666
小爱音箱万能遥控版	LX5A	`[5, 1]`	`[5, 3]`	-	true	@imhsz
小米 AI 音箱	S12	`[5, 1]`	`[5, 3]`	-	true	微信: CMSJ
小米 AI 音箱（第二代）	L15A	`[7, 3]`	`[7, 1]`	`[3, 1, 1]`	true	微信: 龙之广
小爱智能家庭屏 10	X10A	`[7, 3]`	`[7, 1]`	-	true	@IDarkBoss
Xiaomi Sound Pro	L17A	`[7, 3]`	`[7, 1]`	-	true	微信: eof

🚗 正常运行

部分机型的 MIoT 接口不支持查询设备播放状态或查询状态异常，比如小米音箱 Play 增强版（L05C），将会导致 MiGPT 部分功能异常，无法使用连续对话等，此时需要关闭 streamResponse。相关 issue

可以正常运行 MiGPT，但不支持连续对话的小爱音箱型号有：

名称	型号	ttsCommand	wakeUpCommand	playingCommand	streamResponse	反馈来源
小爱音箱	L06A	`[5, 1]`	`[5, 2]`	-	false	@zhanglc
小爱音箱 Play	L05B	`[5, 3]`	`[5, 1]`	-	false	@BiuBiu2323
小米小爱音箱 Play 增强版	L05C	`[5, 3]`	`[5, 1]`	-	false	@lyddias
Xiaomi 智能家庭屏 6	X6A	`[7, 3]`	`[7, 1]`	-	false	@Hongwing
Redmi 小爱触屏音箱 Pro 8 英寸	X08E	`[7, 3]`	`[7, 1]`	-	false	@shangjiyu
小爱音箱 Art	L09A	`[3, 1]`	`[3, 2]`	-	false	@zwsn
小爱触屏音箱	LX04	`[5, 1]`	`[5, 2]`	-	false	@ilovesouthpark

❌ 不支持

完全不支持 MiGPT 的小爱音箱型号有：

名称	型号	反馈来源
小米小爱音箱 HD	SM4	@romantech
小米小爱蓝牙音箱随身版	-	微信: 明天

🔥 型号分享

如果你是其他型号的小爱音箱，欢迎把你的型号和配置参数分享给大家，分享格式如下：

名称：小爱音箱 Pro
型号：LX06
ttsCommand：[5, 1]
wakeUpCommand：[5, 3]
playingCommand：未设置
streamResponse：true（支持连续对话）

环境配置

Python 3.8以上的版本（ https://www.python.org/）
nodeJS （https://nodejs.org/zh-cn）

准备小米音箱

查看小米音箱绑定的名称

我的就是小爱音箱mini，

查看小米音箱的型号

我的型号是LX01

查看小米账号

小爱音箱 APP-->我-->点击头像-->查看小米账号-->我的是 167857068

综上得到小米音箱的名称，型号，小米账号

申请大模型的API接口

注册silicon

silicon注册和使用地址: https://cloud.siliconflow.cn/i/bp8xtUdh

邀请码：bp8xtUdh（谢谢支持）

新建API密钥

注册登录后，单击左边栏的API密钥，单击新建API密钥

点击密钥即可复制

我们可以调用千问2.5的这个模型，满足日常对话完全没有问题，并且是免费调用的

mi-gpt项目

下载 mi-gpt 项目

git clone https://github.com/idootop/mi-gpt.git

创建配置文件

cd mi-gpt mv .env.example .env          mv .migpt.example.js .migpt.js

配置.env 文件

OPENAI_MODEL = Qwen/Qwen2.5-7B-Instruct  #这个免费 OPENAI_API_KEY= sk-xxxxxxxx   # 这里填写第三步中申请的API密钥即可 OPENAI_BASE_URL= https://api.siliconflow.cn/v1

配置.migpt.js文件

修改小米账号ID，密码，设备名称，在93行

// 小米 ID userId: "167857068", // 注意：不是手机号或邮箱，请在「个人信息」-「小米 ID」查看 // 小米账号密码 password: "123456", // 小爱音箱 DID 或在米家中设置的名称 did: "小爱音箱mini", // 注意空格、大小写和错别字（音响 👉 音箱）

修改MIoT设备指令，在127行，具体值看开头表格

// TTS 指令，请到 https://home.miot-spec.com 查询具体指令 ttsCommand: [5, 1], // 设备唤醒指令，请到 https://home.miot-spec.com 查询具体指令 wakeUpCommand: [5, 2], // 查询是否在播放中指令，请到 https://home.miot-spec.com 查询具体指令 playingCommand: [4, 1, 1], // 默认无需配置此参数，查询播放状态异常时再尝试开启

修改人设，第4-16行，人物提示词，可以先跑通再改

// 小爱音箱扮演角色的简介 const botProfile = ` 性别：女 性格：乖巧可爱 爱好：喜欢搞怪，爱吃醋，爱撒娇，喜欢思考哲学问题，很爱干净，特别喜欢挑逗老公。 `.trim();  // 小爱音箱主人（你）的简介 const masterProfile = ` 性别：男 性格：善良正直 其他：是个程序员，总是舍己为人，是小丽丽的老公。 `.trim();

回复唤醒指令，更改姓名 ,第104-119行，，让名字一致，可以先跑通再改

// 当消息以下面的关键词开头时，会调用 AI 来回复消息  callAIKeywords: ["请", "你", "小丽丽"],  // 当消息以下面的关键词开头时，会进入 AI 唤醒状态  wakeUpKeywords: ["打开", "进入", "召唤"],  // 当消息以下面的关键词开头时，会退出 AI 唤醒状态  exitKeywords: ["关闭", "退出", "再见"],  // 进入 AI 模式的欢迎语  onEnterAI: ["我是小丽丽，又见到老公啦，太开心了"], // 设为空数组时可关闭提示语  // 退出 AI 模式的提示语  onExitAI: ["小丽丽先回去咯"], // 为空时可关闭提示语  // AI 开始回答时的提示语  onAIAsking: [], // 为空时可关闭提示语  // AI 结束回答时的提示语  onAIReplied: [], // 为空时可关闭提示语  // AI 回答异常时的提示语  onAIError: ["啊哦，出错了，请稍后再试吧！"], // 为空时可关闭提示语

打开连续对话功能，第149-156行，是否支持请根据官方文档自行判断

 // 是否启用连续对话功能，部分小爱音箱型号无法查询到正确的播放状态，需要关闭连续对话  streamResponse: true,  // 连续对话时，无响应多久后自动退出  exitKeepAliveAfter: 30, // 默认 30 秒，建议不要超过 1 分钟  // 连续对话时，下发 TTS 指令多长时间后开始检测设备播放状态（默认 3 秒）  checkTTSStatusAfter: 3, // 当小爱长文本回复被过早中断时，可尝试调大该值  // 连续对话时，播放状态检测间隔（单位毫秒，最低 500 毫秒，默认 1 秒）  checkInterval: 1000, // 调小此值可以降低小爱回复之间的停顿感，请酌情调节

这里一般只需要把连续对话功能改为true或false，如果设备支持可以改为true

安装依赖并运行

pnpm install pnpm build

ESXi8.0 安装iKuai

Mon, 30 Sep 2024 03:17:04 GMT

网卡直通

网卡出了第一个其他的都直通了,状态显示活动表示已经打开

第一个如果改了无法链接管理后台了

下载Ikuai

下载地址

创建虚拟机

选择名称和系统

选择储存

设置配置

虚拟硬件

CD/DVD驱动器

选择数据存储ISO文件->选择镜像

虚拟机选项

取消UEFI安全引导-下一页

安装IKuai

选择UEFI引导

输入y

将系统安装到硬盘1 sda

输入1 输入y

安装后关闭电源

添加直通网卡设备

虚拟机->编辑-添加其他设备-PCI设备(有几个添加几个)

我是6网口的,除了一个管理口,还有5个

打开电源显示一下页面就说明好了

设置IP地址

输入2 然后输入0

访问Ikuai

访问刚才输入的IP地址,账号密码都是admin,admin

8505 CPU安装ESXI

Sun, 29 Sep 2024 06:04:00 GMT

制作启动U盘

下载Ventoy

下载地址

制作启动U盘

下载ESXI 8.0镜像

文件名	发行日期	备注
VMware-VMvisor-Installer-8.0U3b-24280767.x86_64.iso 【MD5SUM:fa1fbb1b8c9830213d5afcee3e02000c】	2024-09-17	ESXi 8.0U3b

官网下载

官方地址:https://www.broadcom.com/

百度网盘下载

下载镜像提取码: qm4n

备用下载

备用下载镜像1

备用下载镜像2 密码esxi

下载PE工具

下载链接提取码：LxKK

复制到U盘

WePE64_V2.2.iso
VMware-VMvisor-Installer-8.0U3b-24280767.x86_64.iso

将以上文件复制到U盘中

安装ESXI

进入启动菜单

在电脑上插入制作好的启动U盘，重启电脑时不停按 F11

大部分电脑都可以直接通过u盘启动快捷键来选择U盘启动，少部分电脑只能通过bios设置u盘为第一启动项。

有的是F11 ,F12,F7,ESC等快捷键,不同的电脑也不一样

选择U盘启动

每个人的U盘型号不一样,选择自己的我的是金士顿的.

选择上传的ESXI镜像

选择普通模式

进入命令模式

输入 shift + O

输入跳过检查命令

命令前加空格

 cpuUniformityHardCheckPanic=FALSE

输入回车键继续

接受协议

输入F11,继续

选择硬盘

选择设备所在的硬盘,输入回车键,继续

回车继续

选择键盘布局

默认选择,输入回车键,继续

输入密码

输入密码后,回车键继续(上下键切换)

确认安装

输入F11,继续

关机重启进入PE

进入启动菜单

在电脑上插入制作好的启动U盘，重启电脑时不停按 F11

选择U盘启动

选择上传的PE

选择普通模式

将c盘和d盘的boot.cfg文件中第六行后加入 cpuUniformityHardCheckPanic=FALSE，保存

进入C盘选择 BOOT.CFG文件修改

进入D盘 BOOT.CFG文件修改

重启

进入系统

访问网址: https://192.168.2.3

输入账号: root

密码: 刚才设置的密码

ESXi 其他问题

解决虚拟内存占用过大问题

默认安装会分配一个 VMFSL(VMFS-L)(Local VMFS)很大空间(120G).

在安装界面出现时5秒内, 快速按 Shift+O

设置 autoPartitionOSDataSize=8192 在cdromBoot runweasel 之后输入autoPartitionOSDataSize=8192

cdromBoot runweasel autoPartitionOSDataSize=8192

检测到 TPM 2.0 设备，但无法建立连接。

开机按DEL进入BIOS，进入 Advanced – Trusted Computing – Security Device Support，改为disable。

github网站部署

Mon, 23 Sep 2024 03:02:00 GMT

[TOC]

手动部署

介绍

GitHub Pages 是一个静态站点托管服务。

如果你想记录生活、抒发情感、分享见解，这一切都离不开一个可以承载文字的平台，一个独立的、由自己掌控的平台，而 GitHub Pages 就是这么一个平台。

在这个平台里你可以使用自己的个性域名；可以在海量的主题里挑选最适合你的那一款，如果你技术极客，也可以根据自己的喜好，设计属于自己的个性化页面；你既可以在线创建和发布网站，也可以在本地通过客户端工具或者命令行进行网站和内容的管理。

你完全可以通过 GitHub Pages 展示和输出自身价值，甚至可以把它打造成属于自己的互联网「身份证」。

如果你想仔细了解 GitHub Pages，点击这里

优势

GitHub Pages 完全免费，不需要个人购买服务器、域名
官方文档详细，不需要强大的编程能力，只需要一步一步按着操作来使用
支持的功能多，你可以绑定你的域名、使用免费的 HTTPS、自己 DIY 网站的主题、使用他人开发好的插件等等
完成搭建后，只需要专注于文章即可，其他诸如环境搭建、系统维护、文件存储的事情一概不用操心，都由 GitHub Pages 处理

......

限制

GitHub Pages 源仓库建议限制为 1GB；
发布的 GitHub Pages 网站可能不超过 1GB；
GitHub Pages 网站每月的带宽限制为 100GB；
GitHub Pages 网站每小时限制 10 个软件。

开始使用

首先，你必须拥有一个 GitHub 账号，注册点击这里
创建一个仓库用于存放自己的博客项目，如图：点击右上角的 + 号
填写自己的仓库信息

![image-20240920141952150](/Users/maruifu/Library/Application Support/typora-user-images/image-20240920141952150.png)

如我的网站仓库名就叫 ac，因为我打算创建一个空调网站

::: details 防止图片失效，这里记录步骤和gitignore文件内容
1. 填写仓库名
2. 填写仓库描述，可以不写
3. 选择公有 Public
4. 建议选择 Add a README file，添加README文档
5. Add .gitignore 是添加 .gitignore 文件，如果不知道文件内容，可以不选。则需要手动在自己的代码目录下创建 .gitignore文档，填入如下内容：
```
# env .env  *.log  yarn.lock package-lock.json # pnpm-lock.yaml .eslintcache # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.  # dependencies /node_modules /.pnp .pnp.js  # testing /coverage  # production /build  # misc .DS_Store .env.local .env.development.local .env.test.local .env.production.local  npm-debug.log* yarn-debug.log* yarn-error.log*  # jetbrains .idea  dist dist-ssr *.local 
```
:::

上传代码

创建仓库后，进入仓库，我们上传代码

在项目所在目录下执行命令,使用SSH

GitHub 从2021年8月13日 09:00 PST 开始就不接受使用账户密码对 GitHub.com 进行 git 操作了。

本地项目

git init git add . git commit -m "first commit" git branch -M main git remote add origin git@github.com:MaRuifu/ac.git git push -u origin main

配置github上传(可选)

git使用SSH配置，初始需要以下三个步骤

使用秘钥生成工具生成rsa秘钥和公钥
将rsa公钥添加到代码托管平台
将rsa秘钥添加到ssh-agent中，为ssh client指定使用的秘钥文件

第一步：检查本地主机是否已经存在ssh key

cd ~/.ssh ls //看是否存在 id_rsa 和 id_rsa.pub文件，如果存在，说明已经有SSH Key

第二步：生成ssh key

如果不存在ssh key，使用如下命令生成

ssh-keygen -t rsa -C "xxx@xxx.com" //执行后一直回车即可

生成完以后再用第二步命令，查看ssh key

第三步：获取ssh key公钥内容（id_rsa.pub）

cd ~/.ssh cat id_rsa.pub

第四步：Github账号上添加公钥

进入Settings设置

添加ssh key，把刚才复制的内容粘贴上去保存即可

第五步：验证是否设置成功

ssh -T git@github.com

显示如下信息表明设置成功

maruifu@maruifudeMacBook-Pro .ssh % ssh -T git@github.com Hi MaRuifu! You've successfully authenticated, but GitHub does not provide shell access.

上传超时(可选)

首先输入以下命令检查SSH是否能够连接成功（ssh后面有空格）

maruifu@maruifudeMacBook-Pro .ssh % ssh -T git@github.com

发现报错：端口连接超时。

ssh: connect to host github.com port 22: Connection timed out

解决方案在你的主机名文件夹中找到.ssh文件夹；（此前配置SSH时会生成该文件夹）在.ssh文件夹中新建文件 config,不带后缀（可以新建文本文档，去掉.txt后缀）使用文本软件打开config文件，输入以下内容，保存后即可其中email@maruifu.cn 为你的邮箱

Host github.com User email@maruifu.cn  Hostname ssh.github.com PreferredAuthentications publickey IdentityFile ~/.ssh/id_rsa Port 443

再次执行

ssh -T git@github.com

会出现以下提示，输入yes回车即可

maruifu@maruifudeMacBook-Pro .ssh % ssh -T git@github.com The authenticity of host '[ssh.github.com]:443 ([20.205.243.160]:443)' can't be established. ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU. This key is not known by any other names. Are you sure you want to continue connecting (yes/no/[fingerprint])? yes

再次执行ssh -T git@github.com，发现验证通过–接下来可以正常上传代码

Hi Clare! You've successfully authenticated, but GitHub does not provide shell access.

上传打包后的文件

创建仓库后，进入仓库，然后创建一个分支，名字必须叫做gh-pages，可以理解为默认只识别这个名字

创建好的仓库默认主支是 main，现在 GitHub 逐渐让 main 作为默认的主支名

::: details 防止图片失效，这里记录步骤  1. 点击 `main`，弹出拉下框 2. 搜索 `gh-pages`，必须是这个 3. 创建 `gh-pages`。搜索后，会显示 `Create branch：gh-pages from main`，点击即可创建  :::

为什么创建 gh-pages 分支呢？因为 master 主支放的是博客源码，而 gh-pages 分支放的是主支打包后的博客代码。

不理解打包，可以这么认为：写的 markdown 文档是源码，要想显示到网页上，需要变成 html 文件，打包就是变成 html 的过程。

上传打包项目到 gh-pages 分支，我的是在项目下的 dist 目录下

git init  # 初始化 git add .  # 把项目的所有文件添加到本地仓库 git commit -m "first commit"  # 双引号里是对于添加文件的描述 git push -f URL main:gh-pages # URL就是你的仓库地址,推送到github gh-pages分支 ,我这里是 git@github.com:MaRuifu/ac.git

-f 是必须的，意味着覆盖原来的内容

如果可以在仓库 main 下看到源码，gh-pages 下看到打包后的文件，代表成功了

开启部署

:::note

这一内容为开启 Github Page是为了连接手动部署成功后的操作，如果手动部署失败或者想直接使用脚本部署，则至少二选一成功了再来进行本内容的操作。

自动化部署前需要先开启 Github Page

当部署成功时，没有看到想要的成果，我相信不会有人继续进行枯燥的操作。下面将开启 Github Page 见证自己的部署成功页面。

GitHub Page

![image-20240923105347519](/Users/maruifu/Library/Application Support/typora-user-images/image-20240923105347519.png)

::: details 防止图片失效，这里记录步骤

进入仓库，点击 Settings
找到 Pages 选项
选择要部署的分支，一定是 gh-pages 分支
蓝色框的地址，就是所有人都能访问的地址，访问之后，就能看到你的博客

:::

Github 一旦更新 gh-pages 分支内容，会自动重新部署，所以访问页面是最新的。

脚本部署

::: note 注意

脚本部署仅适用于把打包后的文件推送到 GitHub 仓库的 gh-pages 分支下，不适用把项目源码推送到 main 主支上。

所以还得手动执行命令把源码推送到 GitHub 仓库。当然自动化部署，可以全部解决。

:::

每次写完文档，如果都需要像上面上传代码中手动打包，无疑是繁琐且耗费时间的，学会使用脚本解决频繁的问题，能更加专注于文章。

shell 脚本，请自行学习，日后我更新了 shell 的学习文档，这里会提供跳转地址「*记录」。

该脚本是推送项目到 GitHub，如果推送到 Gitee，修改仓库地址即可，脚本名叫 deploy.sh，请放在项目的根目录下。

#!/usr/bin/env sh  # 确保脚本抛出遇到的错误 set -e  # 生成静态文件 npm run build  # 进入生成的文件夹 cd dist  # 如果手运行该脚本，则执行if里的，如果是GitHub自动执行该脚本，则是else里的 if [ -z "$GITHUB_TOKEN" ]; then  msg='deploy'  githubUrl=git@github.com:maruifu/ac.git  # 替换自己的 GitHub 仓库地址，SSH格式 else  msg='来自github actions的自动部署'  # 替换自己的 GitHub 仓库地址，更改的是 @后面的地址 以及 把Kele-Bingtang 改为自己用户名  githubUrl=https://maruifu:${GITHUB_TOKEN}@github.com/maruifu/ac.git   git config --global user.name "maruifu"   # 修改为自己的 GitHub 用户名  git config --global user.email "mrf_it@163.com"  # 修改为自己的 GitHub 邮箱，注册时绑定的邮箱 fi git init git add -A git commit -m "${msg}" git push -f $githubUrl main:gh-pages # 推送到github gh-pages分支  cd - # 退回开始所在目录 rm -rf dist

在项目根目录打开 bash 命令窗口或者 Git Bash Here 窗口，执行该脚本

sh deploy.sh  # 假设你的脚本叫 deploy.sh

自动化部署

使用了脚本部署，相比较手动部署，少了打包的过程，节省了时间，但是还要手动执行两次过程：

敲打命令推送项目源码到仓库的 main 上
执行 shell 脚本，自动打包并推送打包内容到仓库的 gh-pages 上

自动化部署利用了 GitHub Actions ，仅需实现过程1：推送项目源码到 master，即可自动实现过程 2

过程 1 可以写一个脚本执行。这样执行一个脚本，即可实现自动化，下方有该脚本，名叫 push.sh

介绍

GitHub Actions 是 GitHub 的持续集成服务，于 2018 年 10 月推出。

GitHub Actions 入门教程

GitHub Actions 商城

生成token

首先，获取 token，这是 GitHub 的另一种授权方式，即不需要用户名和密码

进入 GitHub，点击头像，找到 setting
找到 Developer settings 并点击
点击 Persional access tokens，然后点击 Generate new token 生成toke
填写 Note，即 token 的描述，并选择 repo，其他不用选

如果不想你的 token 过期，在 Expiration 选中 No expiration 即可

token 生成后，记得保存下来，因为页面一旦关闭，token 不会在显示

配置密钥

拿到了 token，需要将该 token 进行配置，赋予某仓库权限

内容分为三步，其中第三步看需求，第一、二步则是必须。

第一步：配置 ACCESS_TOKEN；

第二步：配置 SSH key

第三步：配置 GITEE_RSA_PRIVATE_KEY和 GITEE_PASSWORD。

配置 ACCESS_TOKEN

配置密钥是因为自动化部署过程，需要 GitHub 权限，没有 token，就没有权限部署

ACCESS_TOKEN 是固定的，名字要和下方脚本使用的名对应上。如果需要改，双方都要改

找到仓库的 Settings ，并点击 Secrets

点击 New repository secret 并进行配置，其中 Name 是 ACCESS_TOKEN，Value 是之前生成的 token

点击 Add secret 即可该密钥添加成功

配置 SSH Key

打开 Git Bash 查看电脑上是否已经存在 SSH 密钥。如果有，请直接看第三步
```
cd ~/.ssh 
```
或者前往C:\Users\你的用户名下找 .ssh 文件夹
如果没有则需要创建新的 ssh key，打开 Git Bash Here，输入：
```
ssh-keygen -t rsa -C "你的绑定GitHub邮箱" 
```
1s 左右执行会停止，提示你选中文件保存路径，直接按 Enter 即可，即路径就在C:\Users\你的用户名下

1s 左右执行又会停止，提示你输入密码，这里不用输入，直接按 Enter 即可
在C:\Users\你的用户名目录下生成 .ssh 文件夹，去文件夹里找到两个文件：id_rsa 和 id_rsa.pub
- id_rsa.pub 为公钥，可以多地方使用
- id_rsa 为私钥，提供私钥能找到所有的公钥
复制 id_rsa.pub 的内容，进入 Github 的 Settings 设置里，找到 SSH and GPG keys，然后点击 New SSH Key 进行配置

点击 New SSH Key 并进行配置：

Title 就是 SSh Key 的标题；Key 填入 id_rsa.pub 的内容，如果 Key 不对，说明打开该文件的编码格式有问题
测试 SSH 是否连接到 GitHub
```
ssh -T git@github.com 
```
成功连接标志：You've sucessfully ...,but Github ... access

可选步骤：配置 GITEE_RSA_PRIVATE_KEY 和 GITEE_PASSWORD

::: tip

如果需要 GitHub 的仓库同步到 Gitee 上，则执行这步骤。

下方的自动化文件里，有 GitHub 仓库同步到 Gitee 的实现代码，如果不需要，请注释或者删除。

自动化文件

GitHub Actions 的实现需要一个 yml 文件，在根目录下创建两个文件夹和一个文件：/.github/workflows/ci.yml

myNote 是我的博客根目录。ci.yml 的 ci 可自定义

ci.yml 文件内容以及过程：（我已经写好了注释）

name: CI  #on: [push]  # 在 master 分支发生 push 事件时触发。 on:    push:     branches:       - master        env: # 设置环境变量   TZ: Asia/Shanghai # 时区（设置时区可使页面中的 最近更新时间 使用时区时间）  jobs: # 工作流   build: # 自定义名称     runs-on: ubuntu-latest # 必填，运行在虚拟机环境 ubuntu-latest      strategy:       matrix:         node-version: [14.x]      steps: # 步骤1       - name: Checkout # 步骤1，拉取代码       # 使用的动作。格式：userName/repoName。作用：检出仓库，获取源码。 官方actions库：https://github.com/actions         uses: actions/checkout@v1               - name: Use Node.js ${{ matrix.node-version }} # 步骤2         uses: actions/setup-node@v1 # 作用：安装nodejs         with:           node-version: ${{ matrix.node-version }} # 版本        - name: run deploy.sh # 步骤3：执行脚本 deploy.sh         env: # 设置环境变量，未设置则不运行           GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }} # token            SSH_PRIVATE_KEY: ${{ secrets.GITEE_RSA_PRIVATE_KEY }} # 私钥         run: npm install && npm run deploy  # 执行 deploy.sh 脚本，位于项目根目录        - name: Push Matser To Gitee  # 步骤4：GitHub 内容同步到 Gitee，同步仓库是 master         uses: wearerequired/git-mirror-action@master         env:           SSH_PRIVATE_KEY: ${{ secrets.GITEE_RSA_PRIVATE_KEY }}         with:  # 从源到目的地           source-repo: 'git@github.com:Kele-Bingtang/notes-blog.git'    #Github 仓库地址           destination-repo: 'git@gitee.com:kele-bingtang/notes-blog.git'    #Gitee 仓库地址        - name: Build Gitee Pages # 步骤5：自动部署到 Gitee Pages         uses: yanglbme/gitee-pages-action@master         with:           # 注意替换为你的 Gitee 用户名           gitee-username: Kele-Bingtang           # 注意在 Settings -> Secrets 配置 GITEE_PASSWORD           gitee-password: ${{ secrets.GITEE_PASSWORD }}           # 注意替换为你的 Gitee 仓库，仓库名严格区分大小写，请准确填写，否则会出错           gitee-repo: Kele-Bingtang/notes-blog           # 要部署的分支，默认是 master，若是其他分支，则需要指定（指定的分支必须存在）           branch: gh-pages

::: details 点击打开，一些参数解释

name 是 workflow 的名称。如果省略该字段，默认为当前 workflow 的文件名，可自定义，查看步骤时显示的代号，叫 aa 都可以，描述步骤功能即可
on 指定触发 workflow 的条件，通常是某些事件，也可以是事件的数组。如上方就是 push 到 master 后触发
jobs 里面，需要写出每一项任务的 job_id，具体名称自定义。job_id里面的 name 字段是任务的说明
runs-on 指定运行所需要的虚拟机环境。它是必填字段
steps 指定每个 Job 的运行步骤，可以包含一个或多个步骤。每个步骤都可以指定三个字段：name、run、env
uses 用的就是别人写好的插件，持续集成由很多操作组成，GitHub 因此允许其他人把写好的插件共享到插件市场，以便他人使用。因此如果你需要某个 action，不必自己写复杂的脚本，直接引用他人写好的 action 即可。、。官网自带的格式：action/功能名@xx，别人写好的 users 格式为：作者名/功能名@xx。作者名别改成自己的名字，我犯过这个错误，无需纠结为什么叫这个，我之前纠结过，人家规定的不可变的名字。类似于一个写好的命令脚本

要想找多个其他 users 脚本，前往GitHub Actions 商城
env 指环境变量，也就是运行时需要的一些参数，如密钥，仓库地址等
with 表示传给插件的参数

:::

内容的 steps 里的步骤详细如下：（一个 name 代表一步）

拉取代码。不需要修改
检查 Node.js 版本，安装指定的 Nodejs 版本，如果版本对了，则会跳过这一步。不需要修改
执行脚本 deploy.sh。也就是脚本部署的脚本，这个脚本会打包项目到 gh-pages 目录下。需要配置密钥，env 读取的就是密钥。上方说过密钥为什么固定是ACCESS_TOKEN这些，因为这里读取的就是这些名字，如需修改，双方都要改
GitHub 仓库同步到 Gitee，同步仓库是 master，如果没有这个打算，则注释或者删除掉，包括第五步
Gitee 获得最新的代码后，不会重新部署新的代码。因为免费的 Gitee Page 需要手动点击更新，而 Github Page 自动😸。所以需要别人写好的 users: yanglbme/gitee-pages-action@master 帮助点击更新

文件内容需要改的是仓库地址，以及 Gitee 用户名

编写提交项目到 master 仓库的脚本，叫 push.sh

#!/usr/bin/env sh  # 本脚本为自动部署的入口脚本，只需执行该脚本，即可实现GitHub的自动部署，以及 push 到 GitHub 的所有文件同步到 Gitee 中  GITHUB_REPO=git@github.com:Kele-Bingtang/notes-blog.git  comment=$1  if [ ! $comment ]; then comment="更新内容+action自动部署" fi  git add -A  git commit -m "${comment}"    # $1 是启动该脚本传来的参数，如 sh push.sh hello，其中 hello 就会插入到 $1 处，如果想两个参数，则加 $2  git push $GITHUB_REPO

在根目录下用 Git Bash Here 打开，并执行该脚本

sh push.sh

一旦该脚本执行成功后，静待五六分钟，会发现 master 主支更新了项目源码，gh-pages 分支更新的项目打包后的代码。

Gitee 对应的仓库 master 主支也更新了项目源码，gh-pages 分支也更新的项目打包后的代码。

自动化文件流程

yml 被执行流程

当第一次提交项目到仓库时，Github 会自动在项目根目录找到 /.github/workflows/ 下的 yml 文件，如 ci.yml，并且执行该 ci.yml 文件；

当第二次乃至后面提交项目到仓库时，Github 判断 ci.yml 内容是否发送变化，没有则执行仓库的 ci.yml 文件，有则先更新文件再执行。

yml 执行流程

当把项目源码推送到仓库的 master 主支时，该 yml 文件开始执行。该文件执行的第三步，就会执行 deploy.sh 脚本部署文件，完成把打包文件提交到 gh-pages 分支下，该文件的第四步，则是把 Github 仓库的代码同步到 Gitee 仓库里，包括 gh-pages分支（双方仓库名字要一致），该文件第五步，则是手动点击了 Gitee 的更新部署按钮。（Gitee 自动更新部署需要 99元/年，没钱只能利用脚本手动点击按钮更新）

问答

Q1 - 能概括一下本内容吗？

可以，概括的过程包括 GitHub 和 Gitee，如果只选择一方，选择性另一方忽略即可。

Github 和 Gitee 分别创建一个仓库，并且分别创建 gh-pages 分支，仓库名要一致
将写好的项目源码提交到 master 主支，打包后的项目文件放到 gh-pages 分支，主支名即 default
开启 Github Pages 和 Gitee Pages，两者都有自己的部署地址，前者网速慢，后者网速快
实现脚本部署，节省步骤 2 的打包项目提交时间，但是无法节省项目源码提交时间
首先生成 token，然后生成公钥私钥，公钥分别配置在 Github 和 Gitee 网站上，token、私钥、Gitee 密码都配置在项目仓库上
配置 yml 文件，在 根目录/.github/workflows/ 下创建 ci.yml 文件，填写好内容
编写 push.sh 脚本，填写好内容，每次写完文档后执行该脚本，即可实现完成自动化部署

Q2 - 实现自动化部署有多少个脚本？

3个

push.sh：提交源码到 master 主支；

deploy：提交打包文件到 gh-pages 分支；

问题

记录我在部署的过程中遇到的问题，这些问题卡了我挺长时间：

生成 token 和 Secrets 设置
配置 .git/conig 内容以及指令一样
.github/**.yml 设计
GitHub 自动部署，而 Gitee 需要手动
shell 脚本设计

更新base

因为一些原因，我把 base 由仓库名改为了 /，从而导致部署后访问的地址带有仓库名失效，正确做法：

GitHub 仓库修改仓库名为：<username>.github.io，这样直接访问 https://<username>.github.io 就会生效
Github 仓库修改路径，仓库名不重要，可改可不改，改为 <username>.gitee.io

ci.yml 文件把原来的仓库地址修改为更新后的地址：

name: CI  #on: [push]  # 在 master 分支发生 push 事件时触发。 on:    push:     branches:       - master  jobs: # 工作流   build: # 自定义名称     runs-on: ubuntu-latest # 必填，运行在虚拟机环境 ubuntu-latest      strategy:       matrix:         node-version: [14.x]      steps:        - name: Checkout # 步骤1，拉取代码       # 使用的动作。格式：userName/repoName。作用：检出仓库，获取源码。 官方actions库：https://github.com/actions         uses: actions/checkout@v1               - name: Use Node.js ${{ matrix.node-version }} # 步骤2         uses: actions/setup-node@v1 # 作用：安装nodejs         with:           node-version: ${{ matrix.node-version }} # 版本        - name: run deploy.sh # 步骤3：执行脚本 deploy.sh         env: # 设置环境变量，未设置则不运行           GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }} # token            SSH_PRIVATE_KEY: ${{ secrets.GITEE_RSA_PRIVATE_KEY }} # 私钥         run: npm install && npm run deploy  # 执行 deploy.sh 脚本，位于项目根目录        - name: Push Matser To Gitee  # 步骤4：GitHub 内容同步到 Gitee，同步仓库是 master         uses: wearerequired/git-mirror-action@master         env:           SSH_PRIVATE_KEY: ${{ secrets.GITEE_RSA_PRIVATE_KEY }}         with:  # 从源到目的地           source-repo: 'git@github.com:Kele-Bingtang/Kele-Bingtang.github.io.git'    #Github 仓库地址           destination-repo: 'git@gitee.com:kele-bingtang/Kele-Bingtang.gitee.io.git'    #Gitee 仓库地址        - name: Build Gitee Pages # 步骤5：自动部署到 Gitee Pages         uses: yanglbme/gitee-pages-action@master         with:           # 注意替换为你的 Gitee 用户名           gitee-username: Kele-Bingtang           # 注意在 Settings -> Secrets 配置 GITEE_PASSWORD           gitee-password: ${{ secrets.GITEE_PASSWORD }}           # 注意替换为你的 Gitee 仓库地址，仓库名严格区分大小写，一般地址和仓库名一致，如果地址改了，仓库名不改，要以地址为准（地址仅需后缀，即 https://gitee.com/<username>/xxx 的 xxx 即可）           gitee-repo: Kele-Bingtang/Kele-Bingtang.gitee.io           # 要部署的分支，默认是 master，若是其他分支，则需要指定（指定的分支必须存在）           branch: gh-pages

值得注意的是 51 行的 gitee-repo 不是 Gitee 的仓库名字，而是修改的地址名：<username>.gitee.io。

自定义域名

这里以 GitHub 举例，Gitee 同理。

前往你的域名解析处，进入如下配置：

然后进入 GitHub 绑定自定义的域名

::: warning

Gitee 的仓库不要改为 <username>.gitee.io，而是直接改为 <username> 即可。

:::

套用 Gitee 官方的一句话：

如果你想你的 pages 首页访问地址不带二级目录，如ipvb.gitee.io，你需要建立一个与自己个性地址同名的仓库，如 https://gitee.com/ipvb 这个用户，想要创建一个自己的站点，但不想以子目录的方式访问，想以ipvb.gitee.io直接访问，那么他就可以创建一个名字为ipvb的仓库 https://gitee.com/ipvb/ipvb 部署完成后，就可以以 https://ipvb.gitee.io 进行访问了。

Centos7 将home空间分配给根目录（/dev/centos/root）

Sun, 15 Sep 2024 17:45:00 GMT

在安装centos系统的时候，如果在安装时没有分配磁盘空间，选择的是默认分配的，在安装完成后，可以发现大容量磁盘往往分配在了home下面。

在没有大量自定义用户使用的情况下，home的空间基本不用时，可以将空间转移至root下面。

查看目录结构

[root@mrf-server opt]# df -hl 文件系统                 容量  已用  可用 已用% 挂载点 devtmpfs                 7.7G     0  7.7G    0% /dev tmpfs                    7.7G     0  7.7G    0% /dev/shm tmpfs                    7.7G   18M  7.7G    1% /run tmpfs                    7.7G     0  7.7G    0% /sys/fs/cgroup /dev/mapper/centos-root   50G   39G   12G   78% / /dev/sda2               1014M  176M  839M   18% /boot /dev/sda1                200M   12M  189M    6% /boot/efi /dev/mapper/centos-home  180G   33M  180G    1% /home tmpfs                    1.6G     0  1.6G    0% /run/user/0 overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/b13ed87897fe1cabe547341e9a855c43bf04fcf7f3ef44e41138b08e62fb6191/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/502140d31ceae249f65f90e2fc096af6d8cece5f086ab9ce7e01ff80ec82576d/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/b8bfb2a4f4360f9b3915452fb4303d5ebf02299bee754de9d7245b5efc0d8149/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/59d0f795fa7c6d89467ada62d8e9e1cd8b9ad5628ca251bb5c9011fbed513af1/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/b7ed9b03a812579f993ac7dbe086afb15401ec5109af9467a5efbbc524f74b79/merged

备份/home数据

[root@mrf-server opt]# mkdir /home-backup [root@mrf-server opt]#  [root@mrf-server opt]# mv /home/* /home-backup

删除/home逻辑卷

[root@mrf-server /]# umount /home [root@mrf-server /]#  [root@mrf-server /]# lvremove /dev/centos/home Do you really want to remove active logical volume centos/home? [y/n]: y   Logical volume "home" successfully removed

查看可用大小

[root@mrf-server /]# vgdisplay   --- Volume group ---   VG Name               centos   System ID                Format                lvm2   Metadata Areas        1   Metadata Sequence No  5   VG Access             read/write   VG Status             resizable   MAX LV                0   Cur LV                2   Open LV               2   Max PV                0   Cur PV                1   Act PV                1   VG Size               <237.28 GiB   PE Size               4.00 MiB   Total PE              60743   Alloc PE / Size       14784 / 57.75 GiB   Free  PE / Size       45959 / <179.53 GiB   VG UUID               6zqmne-yIRi-DzR0-pOc7-pwHI-O1hM-Vh7T5c

根据：Free PE / Size 45959 / <179.53 GiB判断可用空间为：179.53 GiB

新建/home卷

[root@mrf-server /]# lvcreate -L 50G -n home centos WARNING: xfs signature detected on /dev/centos/home at offset 0. Wipe it? [y/n]: y   Wiping xfs signature on /dev/centos/home.   Logical volume "home" created.

查看/home卷

[root@mrf-server /]# lvdisplay   --- Logical volume ---   LV Path                /dev/centos/swap   LV Name                swap   VG Name                centos   LV UUID                PkUzOD-edvq-AYZH-RZte-nOOF-h27l-UDywl5   LV Write Access        read/write   LV Creation host, time localhost, 2024-05-07 16:07:38 +0800   LV Status              available   # open                 2   LV Size                7.75 GiB   Current LE             1984   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:1       --- Logical volume ---   LV Path                /dev/centos/root   LV Name                root   VG Name                centos   LV UUID                jpAxQq-GFzU-AfaT-Hotn-k6bG-FwII-a6EzIq   LV Write Access        read/write   LV Creation host, time localhost, 2024-05-07 16:07:43 +0800   LV Status              available   # open                 1   LV Size                50.00 GiB   Current LE             12800   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:0       --- Logical volume ---   LV Path                /dev/centos/home   LV Name                home   VG Name                centos   LV UUID                jMNrQ0-VpnG-FBry-wmrb-9oue-ALSZ-fuXYrd   LV Write Access        read/write   LV Creation host, time localhost.localdomain, 2024-05-08 09:38:46 +0800   LV Status              available   # open                 0   LV Size                50.00 GiB   Current LE             12800   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:2

分配50G空间成功

查看可用空间大小

[root@mrf-server /]# vgdisplay   --- Volume group ---   VG Name               centos   System ID                Format                lvm2   Metadata Areas        1   Metadata Sequence No  6   VG Access             read/write   VG Status             resizable   MAX LV                0   Cur LV                3   Open LV               2   Max PV                0   Cur PV                1   Act PV                1   VG Size               <237.28 GiB   PE Size               4.00 MiB   Total PE              60743   Alloc PE / Size       27584 / 107.75 GiB   Free  PE / Size       33159 / <129.53 GiB   VG UUID               6zqmne-yIRi-DzR0-pOc7-pwHI-O1hM-Vh7T5c

根据：Free PE / Size 33159 / <129.53 GiB判断可用空间为129.53 GiB

/home上建立xfs文件系统

[root@mrf-server /]# mkfs -t xfs /dev/centos/home Discarding blocks...Done. meta-data=/dev/centos/home       isize=512    agcount=4, agsize=3276800 blks          =                       sectsz=512   attr=2, projid32bit=1          =                       crc=1        finobt=0, sparse=0 data     =                       bsize=4096   blocks=13107200, imaxpct=25          =                       sunit=0      swidth=0 blks naming   =version 2              bsize=4096   ascii-ci=0 ftype=1 log      =internal log           bsize=4096   blocks=6400, version=2          =                       sectsz=512   sunit=0 blks, lazy-count=1 realtime =none                   extsz=4096   blocks=0, rtextents=0

挂载/home

[root@mrf-server /]# mount /dev/centos/home /home [root@mrf-server /]# df -h 文件系统                 容量  已用  可用 已用% 挂载点 devtmpfs                 7.7G     0  7.7G    0% /dev tmpfs                    7.7G     0  7.7G    0% /dev/shm tmpfs                    7.7G   18M  7.7G    1% /run tmpfs                    7.7G     0  7.7G    0% /sys/fs/cgroup /dev/mapper/centos-root   50G   39G   12G   78% / /dev/sda2               1014M  176M  839M   18% /boot /dev/sda1                200M   12M  189M    6% /boot/efi tmpfs                    1.6G     0  1.6G    0% /run/user/0 overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/b13ed87897fe1cabe547341e9a855c43bf04fcf7f3ef44e41138b08e62fb6191/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/502140d31ceae249f65f90e2fc096af6d8cece5f086ab9ce7e01ff80ec82576d/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/b8bfb2a4f4360f9b3915452fb4303d5ebf02299bee754de9d7245b5efc0d8149/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/59d0f795fa7c6d89467ada62d8e9e1cd8b9ad5628ca251bb5c9011fbed513af1/merged overlay                   50G   39G   12G   78% /var/lib/docker/overlay2/b7ed9b03a812579f993ac7dbe086afb15401ec5109af9467a5efbbc524f74b79/merged /dev/mapper/centos-home   50G   33M   50G    1% /home

迁移home目录的备份数据

[root@mrf-server /]# mv /home-backup/* /home [root@mrf-server /]# rm -rf /home-backup

将剩余的空间分配给根目录

[root@mrf-server /]#  lvextend -L +129G /dev/centos/root   Size of logical volume centos/root changed from 50.00 GiB (12800 extents) to 179.00 GiB (45824 extents).   Logical volume centos/root successfully resized. [root@mrf-server /]#  [root@mrf-server /]#  [root@mrf-server /]#  [root@mrf-server /]#  [root@mrf-server /]# lvdisplay   --- Logical volume ---   LV Path                /dev/centos/swap   LV Name                swap   VG Name                centos   LV UUID                PkUzOD-edvq-AYZH-RZte-nOOF-h27l-UDywl5   LV Write Access        read/write   LV Creation host, time localhost, 2024-05-07 16:07:38 +0800   LV Status              available   # open                 2   LV Size                7.75 GiB   Current LE             1984   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:1       --- Logical volume ---   LV Path                /dev/centos/root   LV Name                root   VG Name                centos   LV UUID                jpAxQq-GFzU-AfaT-Hotn-k6bG-FwII-a6EzIq   LV Write Access        read/write   LV Creation host, time localhost, 2024-05-07 16:07:43 +0800   LV Status              available   # open                 1   LV Size                179.00 GiB   Current LE             45824   Segments               2   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:0       --- Logical volume ---   LV Path                /dev/centos/home   LV Name                home   VG Name                centos   LV UUID                jMNrQ0-VpnG-FBry-wmrb-9oue-ALSZ-fuXYrd   LV Write Access        read/write   LV Creation host, time localhost.localdomain, 2024-05-08 09:38:46 +0800   LV Status              available   # open                 1   LV Size                50.00 GiB   Current LE             12800   Segments               1   Allocation             inherit   Read ahead sectors     auto   - currently set to     256   Block device           253:2

扩展根目录

[root@mrf-server /]# xfs_growfs /dev/centos/root meta-data=/dev/mapper/centos-root isize=512    agcount=4, agsize=3276800 blks          =                       sectsz=512   attr=2, projid32bit=1          =                       crc=1        finobt=0 spinodes=0 data     =                       bsize=4096   blocks=13107200, imaxpct=25          =                       sunit=0      swidth=0 blks naming   =version 2              bsize=4096   ascii-ci=0 ftype=1 log      =internal               bsize=4096   blocks=6400, version=2          =                       sectsz=512   sunit=0 blks, lazy-count=1 realtime =none                   extsz=4096   blocks=0, rtextents=0 data blocks changed from 13107200 to 46923776 [root@mrf-server /]# df -h 文件系统                 容量  已用  可用 已用% 挂载点 devtmpfs                 7.7G     0  7.7G    0% /dev tmpfs                    7.7G     0  7.7G    0% /dev/shm tmpfs                    7.7G   18M  7.7G    1% /run tmpfs                    7.7G     0  7.7G    0% /sys/fs/cgroup /dev/mapper/centos-root  179G   39G  141G   22% / /dev/sda2               1014M  176M  839M   18% /boot /dev/sda1                200M   12M  189M    6% /boot/efi tmpfs                    1.6G     0  1.6G    0% /run/user/0 overlay                  179G   39G  141G   22% /var/lib/docker/overlay2/b13ed87897fe1cabe547341e9a855c43bf04fcf7f3ef44e41138b08e62fb6191/merged overlay                  179G   39G  141G   22% /var/lib/docker/overlay2/502140d31ceae249f65f90e2fc096af6d8cece5f086ab9ce7e01ff80ec82576d/merged overlay                  179G   39G  141G   22% /var/lib/docker/overlay2/b8bfb2a4f4360f9b3915452fb4303d5ebf02299bee754de9d7245b5efc0d8149/merged overlay                  179G   39G  141G   22% /var/lib/docker/overlay2/59d0f795fa7c6d89467ada62d8e9e1cd8b9ad5628ca251bb5c9011fbed513af1/merged overlay                  179G   39G  141G   22% /var/lib/docker/overlay2/b7ed9b03a812579f993ac7dbe086afb15401ec5109af9467a5efbbc524f74b79/merged /dev/mapper/centos-home   50G   33M   50G    1% /home

Mac环境下切换JDK版本

Thu, 12 Sep 2024 08:31:00 GMT

Mac修改文件 ~/.bash_profile

 # 定义不同版本jdk的java_home export JAVA_8_HOME=/Users/maruifu/work/tools/java/jdk1.8.0_411.jdk/Contents/Home export JAVA_17_HOME=/Users/maruifu/work/tools/java/jdk-17.0.11.jdk/Contents/Home export JAVA_21_HOME=/Users/maruifu/work/tools/java/jdk-21.0.4.jdk/Contents/Home  # 给JAVA_HOME默认值  这个必须要有 export JAVA_HOME=$JAVA_17_HOME   # alias命令动态切换JDK版本 alias jdk8="export JAVA_HOME=$JAVA_8_HOME" alias jdk17="export JAVA_HOME=$JAVA_17_HOME" alias jdk21="export JAVA_HOME=$JAVA_21_HOME"     PATH=$PATH:$JAVA_HOME/bin export PATH

修改完后，执行source ~/.bash_profile 命令使改动生效

maruifu@localhost ~ % source ~/.bash_profile maruifu@localhost ~ % java -version java version "17.0.11" 2024-04-16 LTS Java(TM) SE Runtime Environment (build 17.0.11+7-LTS-207) Java HotSpot(TM) 64-Bit Server VM (build 17.0.11+7-LTS-207, mixed mode, sharing) maruifu@localhost ~ % jdk8 maruifu@localhost ~ % java -version java version "1.8.0_411" Java(TM) SE Runtime Environment (build 1.8.0_411-b09) Java HotSpot(TM) 64-Bit Server VM (build 25.411-b09, mixed mode) maruifu@localhost ~ % jdk21 maruifu@localhost ~ % java -version java version "21.0.4" 2024-07-16 LTS Java(TM) SE Runtime Environment (build 21.0.4+8-LTS-274) Java HotSpot(TM) 64-Bit Server VM (build 21.0.4+8-LTS-274, mixed mode, sharing) maruifu@localhost ~ %

在群晖NAS中通过docker安装密码管理器bitwarden

Tue, 10 Sep 2024 07:15:00 GMT

密码越来越多，网上，网下的，重要的，不重要的，如果每一个密码都设定不一样的，哪怕是大罗金仙也记不清楚了，所以，密码管理器就出现了，一个超级复杂的密码保护其他的所有密码——免费的密码管理器bitwarden就是这个领域的佼佼者，它的功能有账号密码管理、自动生成密码、导出密码、自动填充密码等等，简单而又实用。bitwarden搭配上一个永不关机的NAS则更是绝配，实现了数据本地化，使用实时化，而且功耗非常低。这里就介绍在群晖NAS上怎么通过docker实现本地部署bitwarden，这里有一个前置条件，那就是NAS要安装SSL证书，可以通过HTTPS进行加密访问。

Bitwarden 还可以私有化部署，这样可以确保数据完全掌握在自己手中，不必担心官方跑路。不过 Bitwarden 官方服务对服务器需要的资源有点多，内存必须大于2G，小内存机器是根本跑不起来的，一般推荐使用第三方开发的 Vaultwarden。

Vaultwarden 是 Bitwarden 的轻量级版本，原名 bitwarden_rs，后来为了与“大哥” Bitwarden 区分开来，遂改名为 Vaultwarden。

Vaultwarden 使用 Rust 编写，默认使用 SQLite 数据库（同时还支持 MySQL 和 PostgreSQL），实现了 Bitwarden API 的所有功能，只需要 10M 内存便可运行，几乎可以跑在任何硬件之上。https://github.com/dani-garcia/vaultwarden 不用想了，无脑使用 Vaultwarden 吧。

准备工作

创建文件夹

在DSM中使用file station创建两个文件夹：

/docker/vaultwarden/1.32.0  /docker/vaultwarden/1.32.0/ssl

证书导入

在DSM中进入控制面板，找到“安全性”，

然后在电脑上把下载的压缩文件“archive.zip”进行解压，获得两个证书文件：cert.pem和privkey.pem.

把这两个文件上传到/docker/vaultwarden/1.32.0/ssl文件夹中。

开始安装

打开docker，进入注册表，搜索vaultward，找到vaultward/server双击选择latest版本进行下载。

进入映像，双击下载的镜像vaultwarden/server：latest，开始安装容器。

开机启动

在安装设置中进入“高级设置” ，勾选“自动重新启动”。

端口设置

分别是 80端口 (API接口)和3012端口( WebSocket 通知)

储存设置

/docker/vaultwarden/1.32.0  --> /data /docker/vaultwarden/1.32.0/ssl  --> /ssl

环境设置

增加 ROCKET_TLS (证书设置) 和后端管理密码 ADMIN_TOKEN

新增一个变量ROCKET_TLS，值是：

{certs="/ssl/cert.pem",key="/ssl/privkey.pem"}

新增一个变量ADMIN_TOKEN，值是：

你自己的后台密码

后台管理

在你的域名后面加上 /admin，登录 Vaultwarden 管理后台，登陆密码为刚刚设置的 ADMIN_TOKEN

在这里可以根据情况对 Vaultwarden 进行一些可选设置，所有的设置项都可以通过鼠标悬停查看相应的说明.

一般设置(General Settings)

1.Domain URL：设置你的网站域名，记得带上 https，如 https://your.domain

2.Allow new signups ：是否允许用户注册，如果密码库仅仅用于自用，建议在自己注册后关闭此选项。

3.Admin page token：在这里更改 Vaultwarden 管理后台的密码。

4.Invitation organization name：设置你的网站名字，将出现在自动发送的电子邮件中。

邮箱设置(SMTP Email Settings)

1.设置 SMTP 服务，用来发送系统邮件（建议开启）。

2.你的 SMTP 服务提供方填写相关信息即可。

3.设置保存后，运行一次 Test SMTP 确保邮件可以正常发送。

Read-Only Config：这里可以查看所有只读选项。
Backup Database：这里提供了一个简易的数据库备份功能。

其他配置

Vaultwarden 可以通过环境变量来自定义各种配置，它的所有环境变量都在这个文件中：

https://github.com/dani-garcia/vaultwarden/blob/main/.env.template

1267-Illegal mix of collations (utf8mb4_general_ci,IMPLICIT) and (utf8mb4_0900_ai_ci,IMPLIC

Tue, 10 Sep 2024 02:00:31 GMT

现象

今天LEFT JOIN 表，报如下错误： 1267-Illegal mix of collations (utf8mb4_general_ci,IMPLICIT) and (utf8mb4_0900_ai_ci,IMPLIC for operation '=')

出现这种问题就是关联表的字符集不匹配

原因

查看数据库的字符集

show variables where Variable_name like 'collation%';

查看关联表字符集

 show create table table_name;

给关联表设置字符编码

alter table table_name default character set utf8mb4 collate=utf8mb4_general_ci;

给关联表字段设置字符编码

 ALTER TABLE table_name convert to CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

转自于: https://cloud.tencent.com/developer/article/2190231

【CentOS7.9】yum 报错：Could not retrieve mirrorlist http://mirrorlist.centos.org

Tue, 10 Sep 2024 01:53:00 GMT

一、报错

报错内容如下

在使用 yum install -y xxx 的时候报错等等

[root@maruifu yum.repos.d]# yum install net-tools.x86_64 Loaded plugins: fastestmirror Determining fastest mirrors Could not retrieve mirrorlist http://mirrorlist.centos.org?arch=x86_64&release=7&repo=sclo-rh error was 14: curl#6 - "Could not resolve host: mirrorlist.centos.org; Unknown error"    One of the configured repositories failed (Unknown),  and yum doesn't have enough cached data to continue. At this point the only  safe thing yum can do is fail. There are a few ways to work "fix" this:       1. Contact the upstream for the repository and get them to fix the problem.       2. Reconfigure the baseurl/etc. for the repository, to point to a working         upstream. This is most often useful if you are using a newer         distribution release than is supported by the repository (and the         packages for the previous distribution release still work).       3. Run the command with the repository temporarily disabled             yum --disablerepo=<repoid> ...       4. Disable the repository permanently, so yum won't use it by default. Yum         will then just ignore the repository until you permanently enable it         again or use --enablerepo for temporary usage:              yum-config-manager --disable <repoid>         or             subscription-manager repos --disable=<repoid>       5. Configure the failing repository to be skipped, if it is unavailable.         Note that yum will try to contact the repo. when it runs most commands,         so will have to try and fail each time (and thus. yum will be be much         slower). If it is a very temporary problem though, this is often a nice         compromise:              yum-config-manager --save --setopt=<repoid>.skip_if_unavailable=true  Cannot find a valid baseurl for repo: centos-sclo-rh/x86_64

原因分析

我们的服务器没法访问外面的网络，所以我们需要配置镜像源

二、解决

进入目录

cd /etc/yum.repos.d

备份文件

# 备份这三个文件就行了（注意！！很多人只有 CentOS-Base.repo 文件，没有后两个，这也没问题，有几个备份几个，不用额外创建！） CentOS-Base.repo  CentOS-SCLo-scl-rh.repo  CentOS-SCLo-scl.repo

修改文件

# 编辑 CentOS-Base.repo 文件 vi /etc/yum.repos.d/CentOS-Base.repo #替换成以下内容 [base] name=CentOS-$releasever - Base baseurl=https://mirrors.aliyun.com/centos/$releasever/os/$basearch/ gpgcheck=1 gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7  [updates] name=CentOS-$releasever - Updates baseurl=https://mirrors.aliyun.com/centos/$releasever/updates/$basearch/ gpgcheck=1 gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7  [extras] name=CentOS-$releasever - Extras baseurl=https://mirrors.aliyun.com/centos/$releasever/extras/$basearch/ gpgcheck=1 gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7  [centosplus] name=CentOS-$releasever - Plus baseurl=https://mirrors.aliyun.com/centos/$releasever/centosplus/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7

 # 编辑 CentOS-SCLo-scl-rh.repo 文件（如果没有这个文件，不用管） vi /etc/yum.repos.d/CentOS-SCLo-scl-rh.repo #替换成以下内容 [centos-sclo-rh] name=CentOS-$releasever - SCLo rh baseurl=https://mirrors.aliyun.com/centos/$releasever/sclo/$basearch/rh/ gpgcheck=1 enabled=1 gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7

#编辑 CentOS-SCLo-scl.repo 文件（如果没有这个文件，不用管） vi /etc/yum.repos.d/CentOS-SCLo-scl.repo #替换成以下内容 [centos-sclo-sclo] name=CentOS-$releasever - SCLo sclo baseurl=https://mirrors.aliyun.com/centos/$releasever/sclo/$basearch/sclo/ gpgcheck=1 enabled=1 gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7

清理 yum 缓存

yum clean all

重新生成 yum 缓存

yum makecache

请注意！如果在你之后的 yum install 过程中发生了 GPGKEY 报错，请参考这篇博客：

原文链接：https://blog.csdn.net/qq_43768851/article/details/140112143

构建 RAG 系统的挑战

Thu, 05 Sep 2024 01:47:00 GMT

探索我们基于研究的 RAG 评估指标——阅读我们关于 Chainpoll的论文。

欢迎回到我们的 Mastering RAG 系列！让我们撸起袖子，深入研究构建企业RAG系统的复杂世界。

尽管互联网上充斥着有关简单 RAG 系统的文章，但构建强大的企业级解决方案的历程往往是一个谜。

但这篇博客不仅仅是一次理论之旅；它是帮助您采取行动的实用指南！从护栏在确保安全方面的重要性到查询重写对用户体验的影响，我们在这里提供可操作的见解和真实示例。无论您是经验丰富的开发人员还是掌舵的技术领导者，系好安全带，深入探索尖端企业 RAG 的错综复杂的世界！

在介绍 RAG 架构之前，我想先分享一项关于构建 RAG 系统时常见故障点的最新研究。研究人员分析了三个跨不同领域的案例研究，发现了七个常见的 RAG 故障点。

构建 RAG 系统的挑战

案例研究

认知审阅者

认知审阅器是一种 RAG 系统，旨在协助研究人员分析科学文献。研究人员定义研究问题或目标，并上传相关研究论文集。然后，系统根据所述目标对所有文档进行排序，以供研究人员进行人工审阅。此外，研究人员可以直接针对整个文档集提出问题。

人工智能导师

另一个 RAG 系统 AI Tutor 允许学生就某个单元提问，并根据学习内容获得答案。学生可以通过访问来源列表来验证答案。AI Tutor 集成到迪肯的学习管理系统中，索引所有内容，包括 PDF、视频和文本文档。该系统使用 Whisper 深度学习模型转录视频，然后再进行分块。RAG 管道包含一个用于查询泛化的重写器，聊天界面利用过去的对话作为每个问题的上下文。

生物医学问答

在生物医学问答案例研究中，使用 BioASQ 数据集创建了一个 RAG 系统，其中包含问题、文档链接和答案。该数据集由生物医学专家准备，包括特定领域的问答对。问题的答案可以是是/否、文本摘要、事实或列表。

RAG 系统的 7 个故障点

通过这些案例研究，他们确定了设计 RAG 系统时经常出现的七个故障点。

缺失内容（FP1）

提出的问题无法通过现有文档回答。在理想情况下，RAG 系统会回复“抱歉，我不知道”之类的消息。但是，对于与内容相关的问题，如果没有明确的答案，系统可能会被误导而提供答案。

错过了排名靠前的文档（FP2）

文档中存在问题的答案，但排名不够高，无法包含在返回给用户的结果中。虽然理论上所有文档都会被排名并在后续步骤中使用，但实际上只会返回排名前 K 的文档，其中 K 是根据性能选择的值。

不在上下文中 - 合并策略限制（FP3）

从数据库中检索到包含答案的文档，但无法将其放入生成响应的上下文中。当返回大量文档时，就会发生这种情况，从而导致合并过程，从而阻碍相关答案的检索。

未提取（FP4）

答案存在于上下文中，但模型无法提取正确的信息。这种情况通常发生在上下文中存在过多噪音或相互矛盾的信息时。

格式错误（FP5）

问题涉及以特定格式（例如表格或列表）提取信息，而模型忽略了该指令。

特异性不正确（FP6）

响应包含答案，但缺乏所需的特异性或过于具体，无法满足用户的需求。当 RAG 系统设计人员对给定问题有预先确定的结果时，例如教师寻求教育内容，就会发生这种情况。在这种情况下，应与答案一起提供具体的教育内容。当用户不确定如何表述问题并且过于笼统时，也会出现不正确的特异性。

不完整（FP7）

不完整的答案是准确的，但缺少一些信息，即使这些信息存在于上下文中并且可以提取。例如，对于“文档 A、B 和 C 中涵盖的要点是什么？”这样的问题，最好分别提出这些问题。

下表列出了他们从解决每个问题中吸取的教训。在构建我们的企业 RAG 系统时，我们将牢记这些教训。

如何构建企业 RAG 系统

现在我们已经确定了设计 RAG 系统时面临的常见问题，让我们来看看每个组件的设计需求和作用，以及构建它们的最佳实践。上面的 RAG 系统架构图提供了每个组件的使用位置和方式的背景信息。

用户身份验证

一切从这里开始——我们系统中的第一个组件！在用户开始与聊天机器人交互之前，我们需要出于各种原因对用户进行身份验证。身份验证有助于实现安全性和个性化，这对于企业系统来说是必不可少的。

访问控制

身份验证可确保只有授权用户才能访问系统。它有助于控制谁可以与系统交互以及他们可以执行哪些操作。

数据安全

保护敏感数据至关重要。用户身份验证可防止未经授权的个人访问机密信息，从而防止数据泄露和未经授权的数据操纵。

用户隐私

身份验证可确保只有目标用户才能访问其个人信息和帐户详细信息，从而帮助维护用户隐私。这对于与用户建立信任至关重要。

法律合规

许多司法管辖区和行业都有法规和法律，要求组织实施适当的用户身份验证以保护用户数据和隐私。遵守这些法规有助于避免法律问题和潜在的处罚。

问责制

身份验证通过将系统内的操作与特定用户帐户绑定来确保责任的可追溯性。这对于审计和跟踪用户活动至关重要，有助于识别和解决任何安全事件或可疑行为。

个性化和定制

身份验证使系统能够识别单个用户，从而实现用户体验的个性化和定制化。这可以包括定制的内容、偏好和设置。

AWS Cognito或Firebase Authentication等服务可以帮助您轻松地将用户注册和身份验证添加到移动和 Web 应用程序。

输入护栏

防止用户输入可能有害或包含私人信息的信息至关重要。最近的研究表明，越狱 LLM很容易。这就是输入护栏的作用所在。让我们看看我们需要护栏的不同场景。

匿名化

输入护栏可以匿名化或删除个人身份信息 (PII)，例如姓名、地址或联系方式。这有助于保护隐私并防止恶意泄露敏感信息。

限制子字符串

禁止可能被用于 SQL 注入、跨站点脚本 (XSS) 或其他注入攻击的某些子字符串或模式，可防止安全漏洞或不良行为。

限制主题

为了限制与特定主题相关的可能不适当、冒犯或违反社区准则的讨论或输入，过滤掉涉及仇恨言论、歧视或露骨内容的内容非常重要。

限制代码

防止可能危害系统安全或导致代码注入攻击的可执行代码的注入至关重要。

限制语言

验证文本输入是否采用正确的语言或脚本，以防止潜在的误解或处理错误。

检测即时注入

减轻注入误导性或有害提示的尝试，这些提示可能会操纵系统或以非预期的方式影响 LLM 的行为。

限制代币

对用户输入实施最大令牌或字符限制有助于避免资源耗尽并防止拒绝服务 (DoS) 攻击。

检测毒性

实施毒性过滤器来识别和阻止包含有害或辱骂性语言的输入。

为了保护您的 RAG 系统免受这些情况的影响，您可以利用Meta 的Llama Guard 。您可以自行托管它，也可以使用 Sagemaker等托管服务。但是，不要指望它在检测毒性方面是完美的。

查询重写器

一旦查询通过了输入护栏，我们就会将其发送给查询重写器。有时，用户查询可能很模糊，或者需要上下文才能更好地理解用户的意图。查询重写是一种有助于解决此问题的技术。它涉及转换用户查询以增强清晰度、准确性和相关性。让我们来看看一些最流行的技术。

根据历史重写

在这种方法中，系统利用用户的查询历史来了解对话的背景并增强后续查询。让我们以信用卡查询为例。

查询历史记录：

“您有几张信用卡？”

“白金信用卡和金卡有年费吗？”

“比较两者的特点。”

我们必须根据用户的查询历史来识别上下文的演变，辨别用户的意图和查询之间的关系，并生成与演变上下文相一致的查询。

重写查询：“比较白金卡和金卡的特点。”

创建子查询

由于检索问题，复杂的查询可能难以回答。为了简化任务，查询被分解为更具体的子查询。这有助于检索生成答案所需的正确上下文。LlamaIndex 将此称为子问题查询引擎。

给定查询“比较白金信用卡和金卡的特点”，系统会为每张卡生成子查询，重点关注原始查询中提到的各个实体。

重写子查询：

“白金信用卡有什么特点？”
“金卡信用卡有什么特点？”

创建类似查询

为了增加检索到正确文档的机会，我们根据用户输入生成类似的查询。这是为了克服检索在语义或词汇匹配方面的局限性。

如果用户询问信用卡功能，系统会生成相关查询。使用同义词、相关术语或特定领域知识来创建符合用户意图的查询。

生成的类似查询：

“我想了解白金信用卡” -> “请告诉我白金信用卡的好处。”

编码器

一旦我们有了原始查询和重写查询，我们就会将它们编码为向量（数字列表）以供检索。选择编码器可能是构建 RAG 系统时最重要的决定。让我们探讨一下选择文本编码器的原因以及需要考虑的因素。

利用 MTEB 基准

要全面评估编码器的功能，首选来源是Massive Text Embedding Benchmark (MTEB)。此基准允许根据向量维度、平均检索性能和模型大小对编码器进行细致的选择。虽然 MTEB 提供了有价值的见解，但必须以一定程度的怀疑态度对待结果，因为没有一刀切的评估基准，并且模型训练数据的细节可能未完全披露。

MTEB 不仅提供了对 OpenAI、Cohere 和 Voyager 等流行嵌入性能的洞察，还揭示了某些开源模型表现出接近的性能水平。但是，需要注意的是，这些结果提供了一般概述，可能无法准确表明这些嵌入在您的域的特定上下文中的表现如何。因此，在做出最终选择之前，必须对您的数据集进行彻底的评估，强调自定义评估方法的重要性。

定制评估

编码器可能无法始终提供最佳性能，尤其是在处理敏感信息时。在这种情况下，自定义评估方法变得至关重要。以下是执行自定义评估的三种方法。

通过注释进行评估

生成专用数据集并设置注释以获得黄金标签。注释后，利用平均倒数排名 (MRR) 和正则化折扣累积增益 (NDCG) 等检索指标定量评估不同编码器的性能。

通过模型评估

遵循与注释方法类似的数据生成过程，但使用 LLM 或交叉编码器作为评估器。这允许在所有编码器之间建立相对排名。随后，对前三名编码器进行手动评估可以得出精确的性能指标。

通过聚类进行评估

采用不同的聚类技术，并分析不同 Silhouette 分数下的覆盖率（聚类数据量），表明聚类内的向量相似性。使用 HDBSCAN 等算法进行实验，调整其参数以获得最佳性能选择。这种基于聚类的评估提供了有关数据点分布和分组的宝贵见解，有助于选择符合特定指标的编码器。

选择文本编码器的考虑因素

在选择编码器时，您需要在私有编码器和公共编码器之间做出选择。您可能会倾向于使用私有编码器，因为它易于使用，但这两种选择之间需要权衡一些特定的利弊。这是一个重要的决定，它将决定您的系统的性能和延迟。

查询费用

确保语义搜索的流畅用户体验依赖于嵌入 API 服务的高可用性。OpenAI 和类似提供商提供可靠的 API，无需托管管理。然而，选择开源模型需要根据模型大小和延迟需求进行工程设计。较小的模型（最多 1.1 亿个参数）可以使用 CPU 实例托管，而较大的模型可能需要 GPU 服务来满足延迟要求。

索引成本

设置语义搜索涉及索引文档，这会产生不小的成本。由于索引和查询共享同一个编码器，因此索引成本取决于所选的编码器服务。为了方便服务重置或重新索引到备用向量数据库，建议单独存储嵌入。忽略此步骤将需要重新计算相同的嵌入。

存储成本

对于索引数百万个向量的应用程序，Vector DB 存储成本是一个至关重要的考虑因素。存储成本与维度成线性关系，OpenAI 的 1526 维嵌入会产生最大的存储成本。要估算存储成本，请计算每个文档的平均单位（短语或句子）并进行推断。

语言支持

为了支持您的非英语语言，请使用多语言编码器或使用翻译系统和英语编码器。

搜索延迟

语义搜索的延迟随嵌入的维度线性增长。选择较低维度的嵌入是最小化延迟的首选。

隐私

金融和医疗保健等敏感领域的严格数据隐私要求可能会降低 OpenAI 等服务的可行性。

文档摄取

文档摄取系统管理数据的处理和持久性。在索引过程中，每个文档被拆分成较小的块，然后使用嵌入模型将其转换为嵌入。然后将原始块和嵌入在数据库中进行索引。让我们看看文档摄取系统的组件。

文档解析器

文档解析器在从各种文档格式中主动提取结构化信息方面发挥着核心作用，尤其注重格式处理。这包括但不限于解析可能包含图像和表格的 PDF。

文档格式

文档解析器必须能够熟练处理各种文档格式，例如 PDF、Word、Excel 等，确保文档处理的适应性。这涉及识别和管理嵌入内容，例如超链接、多媒体元素或注释，以提供文档的全面表示。

表格识别

识别和提取文档中表格中的数据对于维护信息结构至关重要，尤其是在报告或研究论文中。提取与表格相关的元数据（包括标题、行和列信息）可增强对文档组织结构的理解。诸如Table Transformer之类的模型可用于完成此任务。

图像识别

OCR 应用于文档中的图像，以主动识别和提取文本，以便进行索引和后续检索。

元数据提取

元数据是指文档的主要内容之外的附加信息。它包括作者、创建日期、文档类型、关键字等详细信息。元数据提供了有价值的背景信息，有助于组织文档并通过考虑元数据属性来提高搜索结果的相关性。可以使用 NLP/OCR 管道提取元数据，并将其作为特殊字段与文档一起编入索引。

Chunker

如何决定标记（拆分）长文本可以决定嵌入的质量和搜索系统的性能。如果块太小，某些问题就无法回答；如果块太长，那么答案就会包含生成的噪音。您可以利用摘要技术来减少噪音、文本大小、编码成本和存储成本。

分块是一个重要但被低估的话题。它可能需要与特征工程类似的领域专业知识。例如，python 代码库的分块可能使用 def/class 之类的前缀来完成。阅读我们的博客以深入了解分块。

RAG 的分块技术

索引器

索引器 – 您猜对了 – 负责创建文档的索引，该索引用作结构化数据结构（快说 3 遍……）。索引器有助于实现高效的搜索和检索操作。高效的索引对于快速准确地检索文档至关重要。它涉及将块或标记映射到文档集合中的相应位置。索引器在文档检索中执行重要任务，包括创建索引以及添加、更新或删除文档。

索引器作为 RAG 系统的关键组件，面临着各种挑战和问题，这些挑战和问题会影响系统的整体效率和性能。

可扩展性问题

随着文档数量的增长，保持高效快速的索引变得具有挑战性。当系统难以处理越来越多的文档时，可能会出现可扩展性问题，从而导致索引和检索时间变慢。

实时指数更新

实时更新索引可能是一项挑战，尤其是在频繁添加、更新或删除文档的系统中。确保实时 API 和实时索引机制无缝运行且不影响系统性能是一项长期挑战。

一致性和原子性

在文档同时更新或修改的情况下实现一致性和原子性可能非常复杂。确保索引更新保持数据完整性（即使在同时发生更改的情况下）需要仔细的设计和实施。

优化存储空间

索引大量文档可能会产生大量的存储需求。优化存储空间，同时确保索引保持可访问性和响应性，这是一个持续的挑战，尤其是在存储成本令人担忧的情况下。

安全和访问控制

实施适当的安全措施和访问控制以防止未经授权修改索引至关重要。确保只有授权用户或流程才能执行 CRUD 操作有助于保护文档存储库的完整性。

监控和维护

定期监控索引器的运行状况和性能至关重要。检测索引失败、资源瓶颈或索引过时等问题需要强大的监控和维护程序，以确保系统长期平稳运行。

这些是一些困难但众所周知的软件工程挑战，可以通过遵循良好的软件设计实践来解决。

数据存储

由于我们要处理各种数据，因此我们需要为每种数据提供专用存储。了解每种存储类型的不同注意事项以及每种存储类型的具体用例至关重要。

嵌入

数据库类型：SQL/NoSQL

单独存储文档嵌入可以快速重新索引，而无需重新计算整个文档语料库的嵌入。此外，嵌入存储可充当备份，确保即使在系统发生故障或更新时也能保留关键信息。

文件

数据库类型：NoSQL

以原始格式存储文档对于持久存储至关重要。此原始格式是各种处理阶段（例如索引、解析和检索）的基础。它还为未来的系统增强提供了灵活性，因为原始文档保持完整并可根据需要重新处理。

聊天记录

数据库类型：NoSQL

聊天记录的存储对于支持 RAG 系统的对话功能至关重要。聊天记录存储允许系统回忆以前的用户查询、响应和偏好，使其能够根据用户的独特背景调整和定制未来的交互。这些历史数据是一种宝贵的资源，可以利用它进行研究来改进 ML 系统。

用户反馈

数据库类型：NoSQL/SQL

通过 RAG 应用程序内的各种交互机制系统地收集用户反馈。在大多数 LLM 系统中，用户可以使用点赞/点踩、星级评定和文本反馈来提供反馈。这一系列用户见解是一个宝贵的存储库，它囊括了用户体验和感知，为持续的系统增强奠定了基础。

矢量数据库

支持语义搜索的向量数据库是 RAG 的关键检索组件。然而，正确选择此组件对于避免潜在问题至关重要。在选择过程中需要考虑几个向量数据库因素。让我们来了解一下其中的一些。

召回率与延迟

在矢量数据库中，优化召回率（相关结果的百分比）与延迟（返回结果的时间）是一种权衡。Flat、HNSW（分层可导航小世界）、PQ（产品量化）、ANNOY 和 DiskANN 等不同指标在速度和召回率之间做出了不同的权衡。对您的数据和查询进行基准研究，以做出明智的决策。

成本

采用托管解决方案的云原生数据库通常根据数据存储和查询量计费。此模式适用于拥有大量数据的组织，可避免基础设施成本。主要考虑因素包括评估数据集增长、团队能力、数据敏感性以及了解托管云解决方案的成本影响。

另一方面，自托管使组织能够更好地控制其基础架构，并可能降低成本。但是，它伴随着管理和维护基础架构的责任，包括考虑可扩展性、安全性和更新。

插入速度与查询速度

平衡插入速度和查询速度至关重要。寻找能够处理具有高插入速度要求的流式用例的供应商。但是，对于大多数组织来说，优先考虑查询速度更为重要。评估峰值负载下的向量插入速度查询延迟，以做出明智的决策。

内存与磁盘索引存储

在内存和磁盘存储之间进行选择涉及速度和成本的权衡。虽然内存存储提供了高速，但有些用例需要存储比内存更大的向量。内存映射文件等技术允许扩展向量存储而不会影响搜索速度。DiskANN 中的 Vamana 等新索引可实现高效的内存外索引。

全文搜索与向量混合搜索

来源：https://www.pinecone.io/learn/hybrid-search-intro/

单独的向量搜索可能不是企业级应用程序的最佳选择。另一方面，混合搜索集成了密集和稀疏方法，需要额外的努力。实现密集向量索引、稀疏倒排索引和重新排序步骤是典型的做法。密集和稀疏元素之间的平衡可以通过Pinecone、Weaviate和Elasticsearch中称为 alpha 的参数进行调整。

过滤

实际的搜索查询通常涉及对元数据属性的过滤。预过滤搜索虽然看似自然，但可能会导致相关结果丢失。如果过滤后的属性只是数据集的一小部分，则后过滤搜索可能会出现问题。自定义过滤搜索（如Weaviate）将预过滤与使用倒排索引分片和 HNSW 索引分片的有效语义搜索相结合。

改进检索的技术

最近的研究表明，LLM 很容易被不相关的上下文分散注意力，并且由于 LLM 的注意力模式，拥有大量上下文（topK 检索文档）可能会导致遗漏某些上下文。因此，使用相关且多样化的文档来改进检索至关重要。让我们来看看一些经过验证的改进检索的技术。

假设文档嵌入（HyDE）

我们可以使用HyDE技术来解决检索性能不佳的问题，尤其是在处理简短或不匹配的查询时，这些查询会使查找信息变得困难。HyDE 采用一种独特的方法，使用由 GPT 等模型创建的假设文档。这些假设文档捕捉了重要的模式，但可能包含虚构或不正确的细节。然后，智能文本编码器将此假设文档转换为向量嵌入。与查询嵌入相比，这种嵌入有助于在集合中找到类似的真实文档。

实验表明，HyDE 比其他先进方法效果更好，使其成为提升 RAG 系统性能的有用工具。

查询路由

查询路由在处理多个索引时非常有用，可将查询定向到最相关的索引以实现高效检索。此方法可确保每个查询都定向到适当的索引，从而简化搜索过程，从而优化信息检索的准确性和速度。

在企业搜索中，数据来自各种来源（例如技术文档、产品文档、任务和代码存储库），查询路由成为一种强大的工具。例如，如果用户正在搜索与特定产品功能相关的信息，则可以智能地将查询路由到包含产品文档的索引，从而提高搜索结果的准确性。

重排器

当编码器的检索结果无法提供最佳质量时，可以使用重新排序器来提高文档排名。在跨编码器设置中使用开源编码器专用转换器（如BGE-large）已成为一种常见做法。最近的解码器专用方法（如RankVicuna、RankGPT和RankZephyr）进一步提高了重新排序器的性能。

引入重排序器有好处，可以减少响应中的LLM 幻觉并提高系统的域外泛化能力。但是，它也有缺点。复杂的重排序器可能会因计算开销而增加延迟，从而影响实时应用程序。此外，部署高级重排序器可能会占用大量资源，需要仔细考虑性能提升和资源利用率之间的平衡。

最大边际相关性（MMR）

MMR 是一种旨在增强响应查询时检索到的项目多样性、避免冗余的方法。MMR 并非只专注于检索最相关的项目，而是在相关性和多样性之间取得平衡。这就像在聚会上向人们介绍朋友。最初，它会根据朋友的喜好确定最匹配的人。然后，它会寻找略有不同的人。这个过程一直持续到达到所需的介绍次数。MMR 确保呈现一组更加多样化和相关的项目，从而最大限度地减少冗余。

原始 MMR

自动切割

Weaviate的自动剪切功能旨在通过检测得分接近的对象组来限制返回的搜索结果数量。它的工作原理是分析搜索结果的得分并识别这些值的显著跳跃，这可能表明从高度相关的结果过渡到不太相关的结果。

例如，考虑返回具有以下距离值的对象的搜索：

[0.1899、0.1901、0.191、0.21、0.215、0.23]。

Autocut 返回以下内容：

自动切割：1：[0.1899，0.1901，0.191]
自动切割：2：[0.1899, 0.1901, 0.191, 0.21, 0.215]
自动切割：3：[0.1899, 0.1901, 0.191, 0.21, 0.215, 0.23]

递归检索

来源：https://youtu.be/TRjq7t2Ms5I?si= D0z5sHKW4SMqMgSG&t=742

递归检索，又称从小到大的检索技术，嵌入较小的块进行检索，同时返回较大的父上下文以供语言模型合成。较小的文本块有助于更准确的检索，而较大的块则为语言模型提供更丰富的上下文信息。这种顺序过程通过最初关注较小、信息更密集的单元来优化检索的准确性，然后有效地将其链接到更广泛的上下文父块进行合成。

句子窗口检索

检索过程会获取单个句子并返回围绕该特定句子的文本窗口。句子窗口检索可确保检索到的信息不仅准确而且与上下文相关，从而提供有关主要句子的全面信息。

发电机

既然我们已经讨论了所有检索组件，现在让我们来谈谈生成器。它需要仔细考虑和权衡，主要是在自托管推理部署和私有 API 服务之间。这本身就是一个很大的话题，我将简要介绍一下，以免让您不知所措。

API 注意事项

在评估 LLM 的 API 服务器时，确定确保无缝集成和强大性能的功能的优先级至关重要。精心设计的 API 应充当流行 LLM 的简单启动器，同时还要解决生产就绪性、安全性和幻觉检测等关键问题。值得注意的是，HuggingFace 的 TGI 服务器体现了体现这些原则的一套全面功能。让我们了解 LLM 服务器中所需的一些最受欢迎的功能。

表现

高效的 API 必须优先考虑性能，以满足不同的用户需求。张量并行性是一项突出的功能，它有助于在多个 GPU 上更快地进行推理，从而提高整体处理速度。此外，连续批处理传入请求可确保增加总吞吐量，从而有助于提高系统的响应速度和可扩展性。量化的加入，特别是使用 bitsandbytes 和 GPT-Q，进一步优化了 API，以提高各种用例的效率。利用优化的 Transformer 代码的能力可确保在最流行的架构上进行无缝推理。

生成质量增强剂

为了提高生成质量，API 应包含可以转换输出的功能。logits 处理器包括温度缩放、top-p、top-k 和重复惩罚，允许用户根据自己的偏好自定义输出。此外，停止序列可以控制生成，使用户能够管理和优化内容生成过程。对数概率对于幻觉检测至关重要，它充当了额外的细化层，确保生成的输出与预期上下文一致并避免误导性信息。

安全

API 的安全性至关重要，尤其是在处理 LLM 和企业用例时。Safetensor 权重加载是一项基本功能，它有助于通过防止未经授权篡改模型参数来安全部署模型。此外，水印的加入增加了一层额外的安全性，使 LLM 的使用具有可追溯性和可问责性。

用户体验

在用户体验领域，令牌流成为无缝交互的关键功能。利用服务器发送事件 (SSE) 进行令牌流可增强 API 的实时响应能力，为用户提供更流畅、更具交互性的体验。这可确保用户可以逐步接收生成的内容，从而提高 LLM 的整体参与度和可用性。

自托管推理

自托管推理涉及在 AWS、GCP 或 Azure 等云服务提供商提供的服务器上部署 LLM。服务器（例如 TGI、Ray 或 FastAPI）的选择是一项关键决策，直接影响系统的性能和成本。考虑因素包括计算效率、部署的简易性以及与所选 LLM 的兼容性。

衡量 LLM 推理性能至关重要，而像Anyscale 的 LLMPerf Leaderboard这样的排行榜则非常有价值。它根据关键性能指标对推理提供商进行排名，包括首次标记时间 (TTFT)、标记间延迟 (ITL) 和成功率。负载测试和正确性测试对于评估托管模型的不同特征至关重要。

在新方法中，Predibase 的 LoRAX引入了一种高效服务微调 LLM 的创新方法。它解决了使用共享 GPU 资源服务多个微调模型的挑战。

私有API服务

OpenAI、Fireworks、Anyscale、Replicate、Mistral、Perplexity 和 Together 等公司提供的 LLM API 服务提供了替代部署方法。了解它们的功能、定价模型和LLM 性能指标至关重要。例如，OpenAI 的基于代币的定价（区分输入和输出代币）会显著影响使用 API 的总体成本。在比较私有 API 服务与自托管 LLM 的成本时，您必须考虑 GPU 成本、利用率和可扩展性问题等因素。对于某些人来说，速率限制可能是一个限制因素（哈哈！）。

改善 RAG 的提示技术

有几种提示技术可以提高 RAG 的输出。在我们的“掌握 RAG”系列第 2 部分中，我们深入探讨了最有效的 5 种提示技术。其中许多新技术的表现都超过了 CoT（思维链）。您还可以将它们结合起来以最大限度地减少幻觉。

LLM 针对 RAG 的提示技巧

输出护栏

输出护栏的功能与输入护栏类似，但专门用于检测生成的输出中的问题。作为RAG 评估的一部分，它专注于识别幻觉、竞争对手提及和潜在的品牌损害。目标是防止生成可能与品牌价值观不符的不准确或道德上有问题的信息。通过积极监控和分析输出，此护栏可确保生成的内容在事实上保持准确、符合道德规范并符合品牌的指导方针。

以下是一个可能损害企业品牌但会被适当的输出护栏阻止的响应示例：

有毒输出示例

用户反馈

一旦生成并提供了输出，从用户那里获得正面或负面的反馈都是很有帮助的。用户反馈对于改进 RAG 系统的飞轮非常有帮助，这是一个持续的过程，而不是一次性的努力。这不仅需要定期执行重新索引和重新运行实验等自动化任务，还需要采用系统方法来整合用户见解，从而实现实质性的系统增强。

系统改进最有效的杠杆在于主动修复底层数据中的问题。RAG 系统应包含一个迭代工作流程，用于处理用户反馈并推动持续改进。

用户互动及反馈收集

用户与 RAG 应用程序交互，并利用 👍/ 👎 或星级评分等功能提供反馈。这套多样化的反馈机制是用户体验和对系统性能的看法的宝贵资源库。

问题识别和诊断检查

收集反馈后，团队可以进行全面分析，以确定可能表现不佳的查询。这涉及检查检索到的资源并仔细检查，以辨别表现不佳是源于检索、生成还是底层数据源。

数据改进策略

一旦发现问题，尤其是那些根源于数据本身的问题，团队就可以制定战略计划来提高数据质量。这可能涉及纠正不完整的信息或重组组织混乱的内容。

评估和测试协议

实施数据改进后，系统必须对之前表现不佳的查询进行严格评估。然后，可以从这些评估中获得的见解有条不紊地集成到测试套件中，确保根据实际交互进行持续审查和改进。

通过积极让用户参与这个全面的反馈循环，RAG 系统不仅解决了通过自动化流程发现的问题，而且还利用了丰富的用户体验。

可观察性

构建 RAG 系统并不会随着系统投入生产而结束。即使拥有强大的护栏和用于微调的高质量数据，模型在投入生产后仍需要持续监控。除了延迟和成本等标准指标外，生成式 AI 应用程序还需要特定的LLM 可观察性来检测和纠正幻觉、域外查询和链故障等问题。现在让我们来看看 LLM 可观察性的支柱。

及时分析和优化

识别与提示相关的问题，并使用实时生产数据进行迭代，以使用强大的评估机制来识别和解决幻觉等问题。

LLM 应用程序中的可追溯性

从常见框架（如 Langchain 和 LlamaIndex）捕获 LLM 跟踪以调试提示和步骤。

信息检索增强

排除故障并评估 RAG 参数以优化对 LLM 性能至关重要的检索过程。

警报

如果系统行为与预期不符，例如错误增加、高延迟和幻觉，则会收到警报。

首先，实时监控对于观察生产环境中应用程序的性能、行为和整体运行状况至关重要。密切关注 SLA 合规性并设置警报以及时解决任何偏差。通过分析使用模式和资源消耗，有效跟踪与运行 LLM 应用程序相关的成本，以帮助您优化成本。

Galileo 的LLM Studio提供专门构建的 LLM 可观察性，可在用户投诉之前主动发出警报并立即采取纠正措施。Galileo 的护栏指标旨在监控模型的质量和安全性，涵盖基础性、不确定性、事实性、语气、毒性、PII 等方面。这些指标以前在评估和实验期间使用，现在可以无缝集成到监控阶段。

此外，您还可以灵活地注册自定义指标，以根据您的特定需求定制监控流程。利用监控数据生成的见解和警报，随时了解潜在问题、异常或需要注意的改进领域。这种全面的方法可确保您的 LLM 应用程序在实际场景中高效、安全地运行。

缓存

对于规模化运营的公司来说，成本可能成为一大障碍。在这种情况下，缓存是一种很好的省钱方法。缓存涉及将提示及其相应的响应存储在数据库中，以便随后检索它们以供使用。这种战略性缓存机制使 LLM 应用程序能够加快和节省响应，具有三个明显的优势。

增强生产推理

缓存有助于在生产过程中实现更快、更经济的推理。某些查询可以通过利用缓存响应实现接近零延迟，从而简化用户体验。

加速开发周期

在开发阶段，缓存被证明是一种福音，因为它消除了重复调用相同提示的 API 的需要。这可以缩短开发周期，并使其更经济。

数据存储

存储所有提示的综合数据库简化了 LLM 的微调过程。利用存储的提示-响应对简化了基于累积数据的模型优化。

如果您认真考虑，可以利用GPTCache来实现精确匹配和相似匹配的缓存。它提供了缓存命中率、延迟和召回率等有价值的指标，这些指标可以洞悉缓存的性能，从而实现持续改进以确保最佳效率。

多租户

SaaS 软件通常有多个租户，以平衡简单性和隐私性。对于 RAG 系统中的多租户，目标是构建一个不仅能有效查找信息而且尊重每个用户数据限制的系统。简而言之，每个用户与系统的交互都是独立的，确保系统只查看和使用针对该用户的信息。

构建多租户的简单方法之一是使用元数据。当我们将文档添加到系统时，我们会在元数据中包含特定用户的详细信息。这样，每个文档都与特定用户相关联。当有人搜索时，系统会使用此元数据进行筛选，仅显示与该用户相关的文档。然后，它会进行智能搜索，以找到对该用户最重要的信息。这种方法可以防止私人信息在不同用户之间混淆，从而确保每个人的数据安全且私密。

了解如何使用 Llamaindex 实现多租户。

结论

显然，构建一个强大且可扩展的企业 RAG 系统需要精心协调相互关联的组件。从用户身份验证到输入护栏、查询重写、编码、文档提取以及矢量数据库和生成器等检索组件，每一步都对系统性能的塑造起着至关重要的作用。

在不断发展的 RAG 系统格局中，我们希望本实用指南能够为开发人员和领导者提供可行的见解！

Galileo GenAI Studio 是面向构建 LLM 驱动应用程序的团队的领先平台，可进行快速评估、实验和可观察性。它由一套指标提供支持，用于识别和缓解幻觉。加入 1000 多名构建 LLM 驱动应用程序的开发人员，并获得早期访问权限！

转载于:https://www.rungalileo.io/blog/mastering-rag-how-to-architect-an-enterprise-rag-system

Centos python2.7升级到python3

Tue, 13 Aug 2024 02:30:00 GMT

#!/bin/bash set -e  # 指定要安装的Python版本 PYTHON_VERSION="3.10.12"  echo "=== 安装编译依赖 ===" # 安装编译依赖 sudo yum install -y gcc gcc-c++ zlib zlib-devel readline-devel  echo "=== 下载 Python 源码包 ===" # 下载Python源码包（从华为镜像源下载） wget https://mirrors.huaweicloud.com/python/$PYTHON_VERSION/Python-$PYTHON_VERSION.tar.xz  echo "=== 解压 Python 源码包 ===" # 解压Python源码包 tar xvf Python-$PYTHON_VERSION.tar.xz  echo "=== 进入 Python 源码目录 ===" # 进入Python源码目录 cd Python-$PYTHON_VERSION  echo "=== 配置并编译 Python ===" # 编译并安装Python ./configure make && sudo make install  echo "=== 更改默认 python 链接 ===" # 更改默认python链接 sudo mv /usr/bin/python /usr/bin/python.bak sudo ln -s /usr/local/bin/python3 /usr/bin/python  echo "=== 配置 yum 脚本和 urlgrabber-ext-down 脚本 ===" # 配置yum脚本和urlgrabber-ext-down脚本 sudo sed -i "s|#!/usr/bin/python|#!/usr/bin/python2.7|" /usr/bin/yum sudo sed -i "s|#!/usr/bin/python|#!/usr/bin/python2.7|" /usr/libexec/urlgrabber-ext-down  echo "=== 升级 Python 3 完成！ ==="

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=182do5sqcmvp7

CentOS采用PPPOE拨号上网

Thu, 08 Aug 2024 07:33:00 GMT

安装拨号软件

yum install rp-pppoe -y

使用pppoe-setup进行交互式配置

 pppoe-setup

[root@192 ~]# pppoe-setup Welcome to the PPPoE client setup.  First, I will run some checks on your system to make sure the PPPoE client is installed properly...   LOGIN NAME  Enter your Login Name (default root):  #输入ISP提供的账户（上网帐号，这个是联通公司给我的那个帐号）  INTERFACE  Enter the Ethernet interface connected to the PPPoE modem For Solaris, this is likely to be something like /dev/hme0. For Linux, it will be ethX, where 'X' is a number. (default eth0):  #输入以太网卡代号，默认是eth0(自行使用ifconfig命令即可找到)  Do you want the link to come up on demand, or stay up continuously? If you want it to come up on demand, enter the idle time in seconds after which the link should be dropped.  If you want the link to stay up permanently, enter 'no' (two letters, lower-case.) NOTE: Demand-activated links do not interact well with dynamic IP addresses.  You may have some problems with demand-activated links. Enter the demand value (default no):  #配置：若长时间连线，连线会被自动中断（选no表示：即使没有数据连接时也不允许中断） DNS  Please enter the IP address of your ISP's primary DNS server. If your ISP claims that 'the server will provide dynamic DNS addresses', enter 'server' (all lower-case) here. If you just press enter, I will assume you know what you are doing and not modify your DNS setup. Enter the DNS information here: 114.114.114.114 #配置主DNS服务器（我不知道我们网络服务商的DNS，所以填写的是通用地址：114.114.114.114） Please enter the IP address of your ISP's secondary DNS server. If you just press enter, I will assume there is only one DNS server. Enter the secondary DNS server address here: 8.8.8.8 #配置次DNS服务器（可以空着直接敲回车）  PASSWORD # 两次输入账户密码以确认（上网帐号对应的密码--也是联通公司给我的那个，要输入两次，linux下键入密码时不会显示东西） Please enter your Password:  Please re-enter your Password:   USERCTRL #配置普通账户是否有网络连接权限（这里应该输入yes） Please enter 'yes' (three letters, lower-case.) if you want to allow normal user to start or stop DSL connection (default yes):   FIREWALLING  Please choose the firewall rules to use.  Note that these rules are very basic.  You are strongly encouraged to use a more sophisticated firewall setup; however, these will provide basic security.  If you are running any servers on your machine, you must choose 'NONE' and set up firewalling yourself.  Otherwise, the firewall rules will deny access to all standard servers like Web, e-mail, ftp, etc.  If you are using SSH, the rules will block outgoing SSH connections which allocate a privileged source port.  The firewall choices are: 0 - NONE: This script will not set any firewall rules.  You are responsible           for ensuring the security of your machine.  You are STRONGLY           recommended to use some kind of firewall rules. 1 - STANDALONE: Appropriate for a basic stand-alone web-surfing workstation 2 - MASQUERADE: Appropriate for a machine acting as an Internet gateway                 for a LAN Choose a type of firewall (0-2): 0 # 配置防火墙（没有特殊需求选0就OK） Start this connection at boot time  Do you want to start this connection at boot time? Please enter no or yes (default no):yes #配置是否开机自动拨号连接（我选择的是yes） ** Summary of what you entered **  Ethernet Interface: eth0 User name:          990001230447 Activate-on-demand: No Primary DNS:        114.114.114.114 Secondary DNS:      8.8.8.8 Firewalling:        NONE User Control:       yes Accept these settings and adjust configuration files (y/n)? y # 确认刚填写的配置信息（没有问题的话，就选择y） Adjusting /etc/sysconfig/network-scripts/ifcfg-ppp0 Adjusting /etc/resolv.conf   (But first backing it up to /etc/resolv.conf.bak) Adjusting /etc/ppp/chap-secrets and /etc/ppp/pap-secrets   (But first backing it up to /etc/ppp/chap-secrets.bak)   (But first backing it up to /etc/ppp/pap-secrets.bak)    Congratulations, it should be all set up!  Type '/sbin/ifup ppp0' to bring up your xDSL link and '/sbin/ifdown ppp0' to bring it down. Type '/sbin/pppoe-status /etc/sysconfig/network-scripts/ifcfg-ppp0' to see the link status.

查看状态

pppoe-status

启动

pppoe-start

连接网络

/sbin/ifup ppp0

断开连接

/sbin/ifdown ppp0

修改CentOS默认yum源为国内yum镜像源

Thu, 08 Aug 2024 06:59:00 GMT

1、首先备份系统自带yum源配置文件/etc/yum.repos.d/CentOS-Base.repo

[root@localhost ~]# mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

2、下载ailiyun的yum源配置文件到/etc/yum.repos.d/

[root@localhost ~]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

3、更新配置

[root@localhost ~]# yum clean all [root@localhost ~]# yum makecache [root@localhost ~] # yum -y update

使用指定的日期的快照版本

Tue, 06 Aug 2024 08:31:01 GMT

发现官方更新了快照,本地也强制更新了,更新后无法使用

我新下载的是 spring-ai-ollama-1.0.0-20240805.173614-463.jar 更新后报错

,但是我使用旧版本spring-ai-ollama-1.0.0-20240725.032054-428.jar 没有问题

本地install 最新的版本

mvn install:install-file -Dfile=/Users/maruifu/.m2/repository/org/springframework/ai/spring-ai-ollama/1.0.0-SNAPSHOT/spring-ai-ollama-1.0.0-20240725.032054-428.jar \                          -DgroupId=org.springframework.ai \                          -DartifactId=spring-ai-ollama-spring-boot-starter \                          -Dversion=1.0.0-20240725.032054-428 \                          -Dpackaging=jar

加载.mjs文件报错 MIME type of "application/octet-stream" 的解决方案

Fri, 26 Jul 2024 07:50:00 GMT

关于浏览器控制台报错 xxx.mjs 文件 Failed to load module script: Expected a JavaScript module script but the server responded with a MIME type of "application/octet-stream". Strict MIME type checking is enforced for module scripts per HTML spec.问题的解决方案

第一次遇到这个问题，本地访问没问题，使用Nginx部署好后，但浏览器控制台报错提示： .mjs Failed to load module script: Expected a JavaScript module script but the server responded with a MIME type of "application/octet-stream". Strict MIME type checking is enforced for module scripts per HTML spec.

原因

由于nginx无法识别mjs文件，从而在http header中错误的使用 Content-Type:application/octet-stream 来传输mjs文件，导致浏览器端认为它不是一个合法的js脚本

解决方案

修改nginx的MIME type文件，修改对应的MIME type与mjs的映射，操作如下：

去nginx配置文件中发现 mimetype文件路径为 /etc/nginx/mime.types

打开mime.types文件

sudo vim /etc/nginx/mime.types

找到如下配置内容

application/javascript                 js;

修改为

application/javascript                 js mjs;

然后重启Nginx

sudo nginx -s reload

再次访问发现网页没有报错，可以正常运行（如还有报错可尝试强刷或清除缓存后再试）

解决knife4j多文件上传问题

Fri, 12 Jul 2024 08:05:23 GMT

问题

多文件上传knife4j文档接口不显示文件选择按钮
请求接口代码

@ApiOperation("多文件上传") @PostMapping("/uploads") public AjaxResult uploadFiles(@RequestPart List files){

这样设置后后无法选择文件

解决

在后端请求接口上添加@ApiImplicitParam指定请求参数类型
使用dataType

@ApiImplicitParam(name = "files", value = "上传的文件", dataType = "java.io.File", required = true) # 或者使用dataTypeClass @ApiImplicitParam(name = "files", value = "上传的文件", dataTypeClass = MultipartFile.class, required = true)  public AjaxResult uploadFiles(@RequestPart List<MultipartFile> files){

但是存在问题，只能支持单选文件，不支持多选

文件多选问题

1.添加全局参数在knife4j全局参数配置里面添加

2.使用knife4j增强功能，开启动态请求

PGvector Docker 容器无法启动！

Mon, 08 Jul 2024 01:58:38 GMT

用docker安装pgvector

docker run --name pgvector \     -e POSTGRES_PASSWORD=postgres \     -p 5432:5432 \  -d pgvector/pgvector:pg16

报错

initdb: error: program "postgres" is needed by initdb but was not found in the same directory as "/usr/lib/postgresql/16/bin/initdb"

解决方案

增加 privileged=true 可以解决

Linux内网离线安装Ollama

Mon, 08 Jul 2024 01:19:54 GMT

我下载的是Ollama的 0.1.49 版本，后面均以此版本为例说明

在线安装

在线安装地址https://ollama.com/download选择服务器系统，按照步骤完成安装

离线安装

查看服务器CPU的型号

## 查看Linux系统CPU型号命令，我的服务器cpu型号是x86_64 lscpu

根据CPU型号下载Ollama安装包

保存到/home/Ollama目录

下载地址 https://github.com/ollama/ollama/releases/

# x86_64 CPU选择下载ollama-linux-amd64 # aarch64|arm64 CPU选择下载ollama-linux-arm64

离线下载Linux环境的Ollama安装脚本

保存到/home/Ollama目录

## 下载地址1，浏览器中打开下面地址 https://ollama.com/install.sh ## 下载地址2 https://github.com/ollama/ollama/blob/main/scripts/install.sh

修改install.sh脚本

总共需要修改两个点 Ollama下载地址和 Ollama安装包存放目录

注释下载链接

status "Downloading ollama..." ## 在install.sh的第65行 #curl --fail --show-error --location --progress-bar -o $TEMP_DIR/ollama "https://ollama.com/download/ollama-linux-${ARCH}${VER_PARAM}"

修改ollama安装目录

status "Installing ollama to $BINDIR..." $SUDO install -o0 -g0 -m755 -d $BINDIR ## 在install.sh的第73行 #$SUDO install -o0 -g0 -m755 $TEMP_DIR/ollama $BINDIR/ollama $SUDO install -o0 -g0 -m755 ./ollama-linux-amd64  $BINDIR/ollama

运行 install.sh脚本安装

# 执行installl.sh脚本，需要sudo 权限  chmod +x install.sh ./install.sh # 如果报错误权限不足，执行 chmod +x install.sh

运行大模型，如通义千问

# 需要先将大模型下载到OLLAMA_MODELS文件中 # ollama run <模型名称> ollama run qwen2:7b

关闭 Ollama 服务

# 关闭ollama服务 service ollama stop

Ollama 常用命令

## 启动Ollama服务 ollama serve ## 从模型文件创建模型 ollama create ## 显示模型信息 ollama show ## 运行模型 ollama run 模型名称 ## 从注册表中拉去模型 ollama pull 模型名称 ## 将模型推送到注册表 ollama push ## 列出模型 ollama list ## 复制模型 ollama cp ## 删除模型 ollama rm 模型名称 ## 获取有关Ollama任何命令的帮助信息 ollama help

FAQ

如何查看运行的日志？

在Linux上运行命令journalctl -u ollama，即可查看运行日志。

如何配置本地大模型对局域网提供服务？

在Linux上修改配置文件，并配置环境变量 OLLAMA_HOST 来指定对局域网提供服务的地址，再重启Ollama服务即可。

vim /etc/systemd/system/ollama.service  在[Service]下面加上： Environment="OLLAMA_HOST=0.0.0.0:11434"

重启后，就可以通过http在局域网中访问了

下载的大模型存储在哪个路径？

默认情况下，不同操作系统存储的路径如下：

macOS: ~/.ollama/models Linux: /usr/share/ollama/.ollama/models Windows: C:\Users<username>.ollama\models

Java 如何用SSE实现消息推送

Sat, 15 Jun 2024 17:16:00 GMT

定义存储池

        /**   * 用于存储SseEmitter对象   */  private static final Map<String, SseEmitter> pool = new ConcurrentHashMap<>();

发布消息

       /**   * 描述 发布消息   * @param id   * @param message   */  @PostMapping("/publisher/{id}")  public void publish(@PathVariable String id, @RequestBody String message) {   SseEmitter sseEmitter = pool.get(id);   if(Objects.nonNull(sseEmitter)){    try {     sseEmitter.send(message);    } catch (Exception e) {     throw  new RuntimeException(e);    }   }  }

订阅消息

       /**   * 描述 订阅消息   * @param id   * @return   */  @GetMapping("/subscribe/{id}")  public SseEmitter subscribe(@PathVariable String id) {   SseEmitter sseEmitter = pool.get(id);   if(Objects.isNull(sseEmitter)){    sseEmitter = new SseEmitter();    sseEmitter.onCompletion(() -> pool.remove(id));    sseEmitter.onTimeout(() -> pool.remove(id));    pool.put(id, sseEmitter);   }    return sseEmitter;  }

测试

// 接收消息 curl http://127.0.0.1:8080/subscribe/1  // 发送消息 curl -d "message=1" http://127.0.0.1:8080/publisher/1 curl -d "message=2" http://127.0.0.1:8080/publisher/1 curl -d "message=3" http://127.0.0.1:8080/publisher/1

使用tar+pv 命令实现压缩和解压缩显示进度条

Fri, 07 Jun 2024 07:49:59 GMT

实现该功能需要安装 pv，然后把需要处理的数据通过管道传给 pv，最后再进行操作。

传给 pv 的目的是为了知道已经处理的数据量大小，同时需要通过 -s 指定总共需要处理的数据量大小。

pv 的安装一般的软件管理工具都有提供：

安装pv

$ sudo yum install pv

pv 的详细用法可参考：https://linux.die.net/man/1/pv

准备测试目录

准备一个测试压缩的目录test，里面放了连个文本文件1.txt和2.txt

[root@localhost tar_pv]# ls test 1.txt  2.txt

压缩文件

$ tar -cf - test | pv -s $(du -sk test | awk '{print $1}') | gzip > test.tar.gz

实际操作

[root@localhost ~]# tar -cf - test | pv -s $(du -sk test | awk '{print $1}') | gzip > test.tar.gz   10kiB 0:00:00 [ 256MiB/s] [================================================================================================] 85333%             [root@localhost ~]#  [root@localhost ~]# ll total 21648 drwxr-xr-x 2 root root     4096 Nov  4 14:28 test -rw-r--r-- 1 root root      173 Nov  4 15:48 test.tar.gz [root@localhost ~]# tar -tvf test.tar.gz  drwxr-xr-x root/root         0 2021-11-04 14:28 test/ -rw-r--r-- root/root         4 2021-11-04 14:13 test/1.txt -rw-r--r-- root/root         5 2021-11-04 14:14 test/2.txt [root@localhost ~]#

命令详解：

tar -cf -f 是指定目标文件， - , 代表将需要压缩的数据输出到 stdout（标准输出），这样管道的后面才可以接收到需要处理的数据。

pv 命令的作用是，将输入复制一遍然后输出到 stdout，这样最后的 gzip 命令才有数据可以处理，最后通过 gzip 命令把前面的输出处理之后保存到 test.tar.gz。

pv -s 后面一串的命令是获取需要处理的所有数据的大小（单位：字节），mac 下 du -sk 获取到的数值是以 k 为单位的，而其他 *nix 系统则不一样，参数需要改为 du -sb，同时也不需要再乘以 1024。

解压缩

$ pv test.tar.gz | tar -zxf -

实际操作

[root@localhost ~]# pv test.tar.gz | tar -zxf -  173 B 0:00:00 [   5MiB/s] [==================================================================================================>] 100%             [root@localhost ~]#

命令详解：通过 pv 读取需要解压的文件到 stdout，然后通过管道传递给 tar 命令，tar 命令从标准输入获取要处理的数据进行解压。

给tar压缩增加进度条

Thu, 06 Jun 2024 00:29:00 GMT

有点花里胡哨，在生产环境中还是建议使用 tar zcvf 这样简单的参数少的命令减少错误产生。

用pv 和du 显示进度条需要先安装 pv工具，如ubuntu apt install pv 利用du先获得文件或目录大小，然后输出给 pv显示。

tar -cf - “要压缩的文件或者目录路径”| pv -s $(($(du -sk “要压缩的文件或者目录路径” | awk '{print $1}') * 1024)) | gzip > {输出的文件名}.tar.gz

open-webui镜像启动失败

Sat, 04 May 2024 17:10:38 GMT

发现镜像启动几秒后就退出了。于是使用 logs命令查看docker镜像启动的日志。

(base) maruifu@maruifudeMBP ~ % docker ps CONTAINER ID   IMAGE                                COMMAND           CREATED         STATUS         PORTS                     NAMES 948e39d916a7   ghcr.io/open-webui/open-webui:main   "bash start.sh"   7 seconds ago   Up 7 seconds   0.0.0.0:11433->8080/tcp   ollama-webui (base) maruifu@maruifudeMBP ~ % docker logs 948e39d916a7 /usr/local/lib/python3.11/site-packages/pydantic/_internal/_fields.py:160: UserWarning: Field "model_name" has conflict with protected namespace "model_". ...此处省略不到十万行... Error while downloading from https://cdn-lfs.huggingface.co/sentence-transformers/all-MiniLM-L6-v2/53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db?response-content-disposition=attachment%3B+filename*%3DUTF- ...此处省略不到n字... OMPD-a1GbAkTR-neqjRjVYVKfO9sbkdU13%7ESK1fbWgSQ__&Key-Pair-Id=KVTP0A1DKRTAX: HTTPSConnectionPool(host='cdn-lfs.huggingface.co', port=443): Read timed out. Trying to resume download...

看了日志才知道，原来是open-webui启动时期需要首先在线安装transformers库，但是huggingface.co对于国内来说是经常不可访问):

　　于是赶紧求助bing，找到一个镜像网站，"hf-mirror.com"，于是给docker启动命令中增加一个环境变量"HF_ENDPOINT"，经测试完美解决了。后来又想到开始虽然运行镜像启动成功了，但是启动特别慢，2、3分钟服务才能访问，看来也是需要访问huggingface网站的原因。

　　注意这里设置环境变量HF_ENDPOINT，必须设置为”https://hf-mirror.com“，否则依然会报错，大概是说未知的scheme，我已经趟过这个坑了。完整的命令行如下：

docker run -d \    --restart unless-stopped \    --name ollama-webui \    -p 11433:8080 \    -v /Users/maruifu/work/ai-code/ollama/data:/app/backend/data \    -e OLLAMA_API_BASE_URL=http://127.0.0.1:11434/api \    -e HF_ENDPOINT=https://hf-mirror.com \    -e WEBUI_SECRET_KEY=12345678 \    ghcr.io/open-webui/open-webui:main

Mac系统中Anaconda安装配置及Jupyter notebook 配置使用问题

Wed, 17 Apr 2024 03:41:03 GMT

要学习Python数据分析，环境搭建是最基础的知识点，目前Anaconda 和Jupyter notebook是数据分析的标准环境。

Anaconda是包管理器和环境管理器，Jupyter notebook可以将数据分析的代码、图像和文档全部组合到一个web文档中。

安装Anaconda

1、Anaconda可用于多个平台（Windows、 Mac OS 和Linux），直接去官网地址根据操作系统版本对应下载：

Anaconda官网下载地址

此为MacOS版本，下载好软件后一路默认安装。

2、命令行安装方式是打开终端，执行以下命令：

bash ~/Downloads/Anaconda3-5.3.1-MacOSX-x86_64.sh   //python3版本

过程默认安装，可选择自动添加环境变量。看到”Thank you for installing Anaconda!”就安装完成了。

然后你source一下或者重启终端使新加的环境变量生效

source ~/.bash_profile    //或者是source ~/.zshrc_profile

注意：Mac安装好后的Anaconda可直接在图形界面进行包的管理和操作，有的会出现桌面菜单不现实Anaconda 的情况，打不开可以看我上篇文章，接下来的学习教程都是在终端命令行完成。

conda操作命令

常用命令

查看conda 版本

可检测安装Anaconda是否成功

conda --version   // 或者conda -V

更新conda 版本

conda update conda

查看安装的依赖库

conda list

查找包

conda search XXX

安装包

conda install XXX

更新包

conda update XXX

删除包

conda remove XXX

conda 虚拟环境

anaconda默认自带环境base

若之前从未进入base环境时，需先进入anaconda自带环境base

source /opt/anaconda3/bin/activate base

查看所有虚拟环境和信息

// 有三种命令均可查询 conda info -e conda info --envs conda env list

创建新的虚拟环境

conda create --name env_name // 或者是指定python版本 conda create -n env_name python=3.x

“env_name”为自己创建的环境名；3.x 根据需求选择版本；

新的虚拟环境会自动创建在原anaconda的envs目录中

创建新环境并指定包含的库

conda create -n env_name scipy // 并且可以指定库的版本 conda create -n env_name scipy=0.15.0

复制环境

conda create --name env_clone --clone env_name

激活进入虚拟环境

source activate env_name

退出当前虚拟环境

source deactivate

删除环境

conda remove --name env_name --all

查看某个环境下安装的库

conda list -n env_name

指令进入Jupyter notebook 并配置虚拟环境

激活虚拟环境

conda activate env_name

安装jupyter notebook

conda install jupyter notebook

默认端口启动运行

jupyter notebook

修改 Jupyter的python环境

ipykernel是一个Python库,它提供了一个用于在Jupyter环境中运行Python代码的内核

# 安装ipykernel pip install ipykernel    // 或者是 conda install ipykernel # ipykernel中安装当前环境    python -m ipykernel install --name env_name  # 若报错[Errno 13] Permission denied: python -m ipykernel install --user --name env_name  # 如果在Jupyter中安装包遇到问题：Note: you may need to restart the kernel to use updated packages. 更新完成后restate pip install ipykernel --upgrade

修改JupterNotebook 保存目录

# 找到配置文件 jupyter notebook --generate-config  #找到NotebookApp.notebook_dir  找不到直接 新增  915 # c.ServerApp.notebook_dir = '' 916 c.NotebookApp.notebook_dir = '/Users/maruifu/work/doc/JupterNotebook'

Mac下Anaconda Navigator打不开的解决办法

Wed, 17 Apr 2024 03:07:52 GMT

现象

点击 Anaconda-navigator 的图标后，图表会出现几秒(initializing)，然后就退出

升级版本

打开终端，输入指令： sudo conda update conda

 maruifu@maruifudeMacBook-Pro ~ % sudo conda update conda Password: Channels:  - defaults Platform: osx-64 Collecting package metadata (repodata.json): done Solving environment: done  ## Package Plan ##    environment location: /opt/anaconda3    added / updated specs:     - conda   The following packages will be downloaded:      package                    |            build     ---------------------------|-----------------     archspec-0.2.3             |     pyhd3eb1b0_0          47 KB     ca-certificates-2024.3.11  |       hecd8cb5_0         128 KB     conda-24.3.0               |  py311hecd8cb5_0         1.2 MB     ------------------------------------------------------------                                            Total:         1.4 MB  The following packages will be UPDATED:    archspec                               0.2.1-pyhd3eb1b0_0 --> 0.2.3-pyhd3eb1b0_0    ca-certificates                     2023.12.12-hecd8cb5_0 --> 2024.3.11-hecd8cb5_0    conda                              24.1.2-py311hecd8cb5_0 --> 24.3.0-py311hecd8cb5_0    Proceed ([y]/n)? y   Downloading and Extracting Packages:                                                                                  Preparing transaction: done                                                      Verifying transaction: done                                                      Executing transaction: done

等待安装，输入指令

sudo conda update --all

maruifu@maruifudeMacBook-Pro ~ % sudo conda update --all Channels:  - defaults Platform: osx-64 Collecting package metadata (repodata.json): done Solving environment: done  ## Package Plan ##    environment location: /opt/anaconda3   The following packages will be downloaded:      package                    |            build     ---------------------------|-----------------     anaconda-anon-usage-0.4.4  |py311hfb7c958_100          30 KB     anaconda-cloud-auth-0.5.0  |  py311hecd8cb5_0          51 KB     anaconda-navigator-2.5.4   |  py311hecd8cb5_1         7.5 MB     annotated-types-0.6.0      |  py311hecd8cb5_0          27 KB     autopep8-2.0.4             |     pyhd3eb1b0_0          44 KB     black-24.3.0               |  py311hecd8cb5_0         376 KB     bokeh-3.4.0                |  py311h85bffb1_1         5.9 MB     bzip2-1.0.8                |       h6c40b1e_5         151 KB     colorcet-3.1.0             |  py311hecd8cb5_0         614 KB     comm-0.2.1                 |  py311hecd8cb5_0          18 KB     conda-build-24.3.0         |  py311hecd8cb5_0         785 KB     conda-pack-0.7.1           |  py311hecd8cb5_0          69 KB     conda-repo-cli-1.0.88      |  py311hecd8cb5_0         186 KB     cookiecutter-2.6.0         |  py311hecd8cb5_0         143 KB     cryptography-42.0.5        |  py311h30e54ef_0         1.3 MB     flake8-7.0.0               |  py311hecd8cb5_0         120 KB     ipywidgets-8.1.2           |  py311hecd8cb5_0         259 KB     jsonpatch-1.33             |  py311hecd8cb5_0          37 KB     jupyterlab_widgets-3.0.10  |  py311hecd8cb5_0         196 KB     keyring-24.3.1             |  py311hecd8cb5_0          82 KB     lazy-object-proxy-1.10.0   |  py311h6c40b1e_0          37 KB     libmamba-1.5.8             |       h258a794_1         1.4 MB     libmambapy-1.5.8           |  py311h8c3233a_1         281 KB     numba-0.59.1               |  py311hdb55bb0_0         5.8 MB     packaging-23.2             |  py311hecd8cb5_0         174 KB     panel-1.4.1                |  py311hecd8cb5_0        18.6 MB     param-2.1.0                |  py311hecd8cb5_0         269 KB     plotly-5.19.0              |  py311h85bffb1_0         6.2 MB     pycodestyle-2.11.1         |  py311hecd8cb5_0          72 KB     pydantic-2.5.3             |  py311hecd8cb5_0         721 KB     pydantic-core-2.14.6       |  py311hf2ad997_0         1.6 MB     pydeck-0.7.1               |  py311hecd8cb5_0         1.6 MB     pyflakes-3.2.0             |  py311hecd8cb5_0         156 KB     pylint-venv-3.0.3          |  py311hecd8cb5_0          14 KB     pympler-0.9                |             py_0         160 KB     pyobjc-core-10.1           |  py311h46256e1_0         501 KB     pyobjc-framework-cocoa-10.1|  py311h9205ec4_0         396 KB     pyobjc-framework-coreservices-10.1|  py311h46256e1_0          67 KB     pyobjc-framework-fsevents-10.1|  py311hecd8cb5_0          16 KB     python-lsp-black-2.0.0     |  py311hecd8cb5_0          18 KB     python-lsp-jsonrpc-1.1.2   |     pyhd3eb1b0_0          12 KB     python-lsp-server-1.10.0   |  py311hecd8cb5_0         159 KB     pyviz_comms-3.0.2          |  py311hecd8cb5_0          57 KB     qdarkstyle-3.2.3           |     pyhd3eb1b0_0         615 KB     qtconsole-5.5.1            |  py311hecd8cb5_0         259 KB     rope-1.12.0                |  py311hecd8cb5_0         591 KB     scipy-1.12.0               |  py311h7695dc5_0        23.7 MB     scrapy-2.11.1              |  py311hecd8cb5_0         847 KB     semver-3.0.2               |  py311hecd8cb5_0          46 KB     spyder-5.5.1               |  py311hecd8cb5_0        11.0 MB     spyder-kernels-2.5.0       |  py311hecd8cb5_0         209 KB     streamlit-1.16.0           |  py311hecd8cb5_0         6.9 MB     tomli-2.0.1                |  py311hecd8cb5_0          31 KB     tzdata-2024a               |       h04d1e81_0         116 KB     widgetsnbextension-4.0.10  |  py311hecd8cb5_0         948 KB     xz-5.4.6                   |       h6c40b1e_0         373 KB     yapf-0.40.2                |  py311hecd8cb5_0         474 KB     ------------------------------------------------------------                                            Total:       102.0 MB  The following NEW packages will be INSTALLED:    annotated-types    pkgs/main/osx-64::annotated-types-0.6.0-py311hecd8cb5_0    pydantic-core      pkgs/main/osx-64::pydantic-core-2.14.6-py311hf2ad997_0    pympler            pkgs/main/noarch::pympler-0.9-py_0    tomli              pkgs/main/osx-64::tomli-2.0.1-py311hecd8cb5_0   The following packages will be UPDATED:    anaconda-anon-usa~                0.4.3-py311hfb7c958_100 --> 0.4.4-py311hfb7c958_100    anaconda-cloud-au~                  0.1.4-py311hecd8cb5_0 --> 0.5.0-py311hecd8cb5_0    anaconda-navigator                  2.5.3-py311hecd8cb5_0 --> 2.5.4-py311hecd8cb5_1    autopep8                               1.6.0-pyhd3eb1b0_1 --> 2.0.4-pyhd3eb1b0_0    black                             23.11.0-py311hecd8cb5_0 --> 24.3.0-py311hecd8cb5_0    bokeh                               3.3.4-py311h85bffb1_0 --> 3.4.0-py311h85bffb1_1    bzip2                                    1.0.8-h1de35cc_0 --> 1.0.8-h6c40b1e_5    colorcet                            3.0.1-py311hecd8cb5_0 --> 3.1.0-py311hecd8cb5_0    comm                                0.1.2-py311hecd8cb5_0 --> 0.2.1-py311hecd8cb5_0    conda-build                        24.1.2-py311hecd8cb5_0 --> 24.3.0-py311hecd8cb5_0    conda-pack         pkgs/main/noarch::conda-pack-0.6.0-py~ --> pkgs/main/osx-64::conda-pack-0.7.1-py311hecd8cb5_0    conda-repo-cli                     1.0.75-py311hecd8cb5_0 --> 1.0.88-py311hecd8cb5_0    cookiecutter                        2.5.0-py311hecd8cb5_0 --> 2.6.0-py311hecd8cb5_0    cryptography                       42.0.2-py311h30e54ef_0 --> 42.0.5-py311h30e54ef_0    flake8                              6.0.0-py311hecd8cb5_0 --> 7.0.0-py311hecd8cb5_0    ipywidgets         pkgs/main/noarch::ipywidgets-7.6.5-py~ --> pkgs/main/osx-64::ipywidgets-8.1.2-py311hecd8cb5_0    jsonpatch          pkgs/main/noarch::jsonpatch-1.32-pyhd~ --> pkgs/main/osx-64::jsonpatch-1.33-py311hecd8cb5_0    jupyterlab_widgets                  3.0.9-py311hecd8cb5_0 --> 3.0.10-py311hecd8cb5_0    keyring                           23.13.1-py311hecd8cb5_0 --> 24.3.1-py311hecd8cb5_0    lazy-object-proxy                   1.6.0-py311h6c40b1e_0 --> 1.10.0-py311h6c40b1e_0    libmamba                                 1.5.6-h63cd6dc_0 --> 1.5.8-h258a794_1    libmambapy                          1.5.6-py311h8c3233a_0 --> 1.5.8-py311h8c3233a_1    numba                              0.59.0-py311hdb55bb0_0 --> 0.59.1-py311hdb55bb0_0    packaging                            23.1-py311hecd8cb5_0 --> 23.2-py311hecd8cb5_0    panel                               1.3.8-py311hecd8cb5_0 --> 1.4.1-py311hecd8cb5_0    param                               2.0.2-py311hecd8cb5_0 --> 2.1.0-py311hecd8cb5_0    plotly                              5.9.0-py311hecd8cb5_0 --> 5.19.0-py311h85bffb1_0    pycodestyle                        2.10.0-py311hecd8cb5_0 --> 2.11.1-py311hecd8cb5_0    pydantic                          1.10.12-py311h6c40b1e_1 --> 2.5.3-py311hecd8cb5_0    pyflakes                            3.0.1-py311hecd8cb5_0 --> 3.2.0-py311hecd8cb5_0    pylint-venv                         2.3.0-py311hecd8cb5_0 --> 3.0.3-py311hecd8cb5_0    pyobjc-core                           9.0-py311h9205ec4_1 --> 10.1-py311h46256e1_0    pyobjc-framework-~                    9.0-py311h9205ec4_0 --> 10.1-py311h9205ec4_0    pyobjc-framework-~                    9.0-py311h46256e1_0 --> 10.1-py311h46256e1_0    pyobjc-framework-~                    9.0-py311hecd8cb5_0 --> 10.1-py311hecd8cb5_0    python-lsp-black                    1.2.1-py311hecd8cb5_0 --> 2.0.0-py311hecd8cb5_0    python-lsp-jsonrpc                     1.0.0-pyhd3eb1b0_0 --> 1.1.2-pyhd3eb1b0_0    python-lsp-server                   1.7.2-py311hecd8cb5_0 --> 1.10.0-py311hecd8cb5_0    pyviz_comms                         3.0.0-py311hecd8cb5_0 --> 3.0.2-py311hecd8cb5_0    qdarkstyle                             3.0.2-pyhd3eb1b0_0 --> 3.2.3-pyhd3eb1b0_0    qtconsole                           5.4.2-py311hecd8cb5_0 --> 5.5.1-py311hecd8cb5_0    rope                                1.7.0-py311hecd8cb5_0 --> 1.12.0-py311hecd8cb5_0    scipy                              1.11.4-py311h7695dc5_0 --> 1.12.0-py311h7695dc5_0    scrapy                              2.8.0-py311hecd8cb5_0 --> 2.11.1-py311hecd8cb5_0    semver             pkgs/main/noarch::semver-2.13.0-pyhd3~ --> pkgs/main/osx-64::semver-3.0.2-py311hecd8cb5_0    spyder                              5.4.3-py311hecd8cb5_1 --> 5.5.1-py311hecd8cb5_0    spyder-kernels                      2.4.4-py311hecd8cb5_0 --> 2.5.0-py311hecd8cb5_0    tzdata                                   2023d-h04d1e81_0 --> 2024a-h04d1e81_0    widgetsnbextension                  3.5.2-py311hecd8cb5_1 --> 4.0.10-py311hecd8cb5_0    xz                                       5.4.5-h6c40b1e_0 --> 5.4.6-h6c40b1e_0    yapf               pkgs/main/noarch::yapf-0.31.0-pyhd3eb~ --> pkgs/main/osx-64::yapf-0.40.2-py311hecd8cb5_0   The following packages will be DOWNGRADED:    pydeck                              0.8.0-py311hecd8cb5_2 --> 0.7.1-py311hecd8cb5_0    streamlit                          1.30.0-py311hecd8cb5_0 --> 1.16.0-py311hecd8cb5_0    Proceed ([y]/n)? y   Downloading and Extracting Packages:                                                                                  Preparing transaction: done                                                      Verifying transaction: done                                                      Executing transaction: done

如果发生错误，再输入一次，即可解决

Python调用Acrobat DC Pro的程序

Wed, 10 Apr 2024 00:55:41 GMT

主要利用了Adobe Acrobat DC软件的能力

安装win32com

pip install win32com

如果直接pip installl win32com可能找不到安装包。

若要使用win32com模块，则可以使用 python -m pip install pypiwin32命令：

下载Adobe Acrobat DC

https://helpx.adobe.com/cn/download-install.html

执行代码

# 导入必要的库 from win32com.client.dynamic import Dispatch, ERRORS_BAD_CONTEXT import os import winerror  # 将 winerror.E_NOTIMPL 添加到 ERRORS_BAD_CONTEXT 列表中，以处理特定错误 ERRORS_BAD_CONTEXT.append(winerror.E_NOTIMPL)  # 获取当前目录中所有以 ".pdf" 结尾的文件 files = list(filter(lambda f: f.endswith('.pdf'), os.listdir()))  # 定义一个函数将 PDF 文件转换为 Word 文档 def pdf2word(f_path, d_path):     try:         # 创建 Acrobat 文档对象         AvDoc = Dispatch("AcroExch.AVDoc")          # 打开 PDF 文件         AvDoc.Open(f_path, "")          # 获取 PDF 文档对象         pdDoc = AvDoc.GetPDDoc()          # 获取 JavaScript 对象         jsObject = pdDoc.GetJSObject()          # 将 PDF 文档另存为 Word 文档         jsObject.SaveAs(d_path, "com.adobe.acrobat.docx")          # 打印转换成功信息         print('ok')     except Exception as e:         # 打印转换失败信息         print('error')         print(e)     finally:         # 关闭 PDF 文档         pdDoc.Close()          # 关闭 Acrobat 文档         AvDoc.Close(True)  # 创建 "output" 目录用于存储转换后的 Word 文档 os.mkdir('output')  # 遍历所有 PDF 文件 for file in files:     # 打印正在转换的文件名     print('convert:', file)      # 获取输出文件路径     out_file = file.replace('.pdf', '.docx')     f_path = os.path.abspath(file)     d_path = os.path.abspath('output/' + out_file)      # 调用 pdf2word 函数进行转换     pdf2word(f_path, d_path)

AI 领域精选高质量信息源分享

Tue, 09 Apr 2024 05:47:00 GMT

AI 领域精选高质量信息源分享

播客

主要听一些创业者、投资人以及研究员的思考，但是需要明白一点，公开性言论服务于本公司或本人利益的表达（比如企业 workflow 是在现有场景+AI 还是定义全新的流程，深耕的 SaaS 公司和初创公司肯定各执一词），大家听的过程中一定要结合自己的实际，获取有效经验。

AI 局内人[1]

https://www.xiaoyuzhoufm.com/podcast/643928f99361a4e7c38a9555

极客公园旗下的科技创业者社区 FounderPark 出品的 AGI 系列播客节目，围绕 AGI 相关领域的技术发展、产品方向以及新的商业模式进行探讨和交流，采访过月之暗面（Kimi Chat 背后的公司）创始人杨植麟、有赞创始人白鸦（聊已有 SaaS 产品怎么结合 AI 提升服务体验）等。

OnBoard![2]

https://www.xiaoyuzhoufm.com/podcast/61cbaac48bb4cd867fcabe22 这个账号以前主要是关注中美 SaaS 领域，AI 爆发以来也有越来越多的 AI 话题，节目水准很高，请的嘉宾基本都是一线的从业者，资深研究者，中英文访谈都有，有助于打开视野。

42 章经[3]

https://www.xiaoyuzhoufm.com/podcast/648b0b641c48983391a63f98

42 章经是一个创业投资圈自媒体，最近半年开始，密集更新一些 AI 相关的话题，《24、25 年会是下一代浪潮最关键的两年 | AI 年终复盘》[4]这期节目入坑的，内容整体都蛮不错的。

其他

出海相对论[5]、屠龙之术[6]，硅谷 101[7] 这三个节目的话题相对没有那么聚焦，但是几期聊 AI 的内容，讲的都比较务实，挑着听即可。

海外的 20VC（The Twenty Minute VC）、SaaStr Podcasts、Invest Like The Best 关于 AI 的访谈质量也很高。

论文代码

LLM-Arxiv[8]

https://arxiv.org/search/?query=large+language+model&searchtype=all&abstracts=show&order=-submitted_date&size=50

关于 LLM 的最新 Arxiv 论文列表，有空看看

Cool Papers - Immersive Paper Discover[9]

https://papers.cool/ 苏剑林大佬开发的一个刷论文的网站，分为人工智能、计算和语言、机器学习、计算机识别和模式识别四个主题，每一篇都接入了 Kimi 中文总结

Connected Papers[10]

https://www.connectedpapers.com/ 输入一篇论文，它会将这篇论文的依赖和被依赖项以知识网络的形式全部呈现出来，类似的产品还有 litmaps 、researchrabbit 等

GitHub Trending[11]

https://github.com/trending GitHub 热榜，再加标签筛选，就可以跟踪一些比较新且关注度高的项目

Papers with code[12]

https://paperswithcode.com/ 一个论文和对应工程实现（含代码、数据集、测试方法等）的索引工具，看到别人推荐优质论文时，可以直接用它去找代码实现，强烈推荐

个人博客

Lil'Log[13]：

https://lilianweng.github.io/

OpenAI AI 应用研究主管 Lilian Weng 的博客，首次提出基于 LLM 的代理组成，综述性文章《大语言模型（LLM）支持的自主代理》[14]刷圈，下面这张图片被无数的技术文章引用，博客其他内容同样质量很高，推荐关注

五里墩茶社[15]

https://space.bilibili.com/615957867/?spm_id_from=333.999.0.0 最新的 LLM 相关工具分享，很多新工具都有入门讲解，推荐新手关注

deep_thoughts[16]

https://space.bilibili.com/373596439/?spm_id_from=333.999.0.0 LLM 和 Diffusion 经典论文解读和 Pytorch 源码解读

苏洋博客[17]

https://soulteary.com/ RAG 涉及的技术（语义搜索图、向量数据库等）大佬 22 年就在个人博客分享过了，每个技术话题都深入浅出，从实践出发，讲的很细

田渊栋[18]

https://www.zhihu.com/people/tian-yuan-dong Meta AI 研究员，之前做长文本小说生成，现在做 LLM（不过最近两篇论文都与端侧小模型相关），大佬在知乎持续输出干货

苏剑林[19]

https://kexue.fm/ 大佬从追一去月之暗面了，大本营在他的科学空间，很多内容比较硬核，需要一定的数理基础才能看懂

PENG Bo[20]

https://www.zhihu.com/people/bopengbopeng 端侧小模型 rwkv 作者，分享内容主要是 rwkv 的进展

吴恩达老师的来信[21]

https://www.zhihu.com/people/wu-en-da-89

技术公司博客

智谱的沙龙活动号-质朴发言

Hugging Face[22]

https://www.zhihu.com/org/huggingface Huggingface face 官方号，会分享一些基础技术贴，更新频率比较高

Stability AI[23]

https://stability.ai/ 推出 Stable Diffusion 开源模型的公司，除此之外还有文生音乐，文生视频模型

OpenAI[24]

https://openai.com/ 这个不用我说了吧，OpenAI 每次博客更新，微信关键字指数都要出现一个脉冲，下次不要读国内自媒体发通稿了，自己去看下原文。

OpenAI 开发者论坛[25]

https://community.openai.com/ 技术同学也不可错过

Claude[26]

https://claude.ai/ 同上，大模型领域影响力不输 OpenAI，最新发布的模型已经碾压 GPT-4 了

deeplearning.ai[27]

https://www.deeplearning.ai/the-batch/ 官网上的 The Batch 栏目，提供近一周的 AI 相关消息和观点

LangChain 官方博客[28]

https://blog.langchain.dev/

LlamaIndex 官方博客[29]

https://blog.llamaindex.ai/

Pinecone 官方博客[30]

https://www.pinecone.io/blog/ 除此之外，milvus、weaviate、qdrant 几家向量数据库厂商的博客质量也很高

E2B[34]

https://e2b.dev/blog 一家聚焦为 Agent 和 AI 应用打造云端安全执行环境的公司，跟踪海外 Agent 项目只需关注这个就好了，很多自媒体账号上引用 Agent LandScape 图就是出自他家，每个季度会更新

技术媒体

偶尔翻翻，不怎么看了，写在这里是希望大家能多去看源头信息，少看二手信息。

MITNews[35]

应该是大多数国内科技媒体的上游信息源。

Reddit：可以理解为美国百度贴吧，这个是一部分国内个人媒体上游信息源，讨论一些前言资讯等，重点看几个主题：

Artificial Intelligence Gateway: 泛人工智能的所有信息
Deeplearning：深度学习群组
Artificial：关于人工智能的前沿资讯

Hacker News 的 AI 话题：Y Combinator 旗下的一个新闻提交社区，它的界面非常丑陋（客观事实 😂），但是社区用户质量、评论质量非常高。

X 上的宝玉老师

其他

这部分放在一起，属于非大语言模型范畴，关于 AI 绘画、AI 音频生成模型等

刘悦的技术博客[36]

语音合成领域非常活跃的大佬，视频更新频率很高。

civitai[37] 全球 AI 绘画模型分享网站（国内的哩布哩布 AI 和吐司基本就是对标这个搞的，但是社区模型数量和质量方面差距还很大）

Olivio Sarikas[38] AI 绘画各种信息，主要在图像领域，时效性很强

Scott Detweiler[39] ComfyUI 的各种教程

openart[40] ComfyUI 工作流共享社区

参考资料

[1]AI 局内人: https://www.xiaoyuzhoufm.com/podcast/643928f99361a4e7c38a9555

[2]OnBoard!: https://www.xiaoyuzhoufm.com/podcast/61cbaac48bb4cd867fcabe22

[3]42 章经: https://www.xiaoyuzhoufm.com/podcast/648b0b641c48983391a63f98

[4]《24、25 年会是下一代浪潮最关键的两年 | AI 年终复盘》: https://www.xiaoyuzhoufm.com/episode/65a2a75fb5e4856c70801eba

[5]出海相对论: https://www.xiaoyuzhoufm.com/podcast/63b7dd49289d2739647d9587

[6]屠龙之术: https://www.xiaoyuzhoufm.com/podcast/6507bc165c88d2412626b401

[7]硅谷 101: https://www.xiaoyuzhoufm.com/podcast/5e5c52c9418a84a04625e6cc

[8]LLM-Arxiv: https://arxiv.org/search/?query=large+language+model&searchtype=all&abstracts=show&order=-submitted_date&size=50

[9]Cool Papers - Immersive Paper Discover: https://papers.cool/

[10]Connected Papers: https://www.connectedpapers.com/

[11]Github Trending: https://github.com/trending

[12]Papers with code: https://paperswithcode.com/

[13]Lil'Log: https://lilianweng.github.io/

[14]《大语言模型（LLM）支持的自主代理》: https://lilianweng.github.io/posts/2023-06-23-agent/

[15]五里墩茶社: https://space.bilibili.com/615957867/?spm_id_from=333.999.0.0

[16]deep_thoughts: https://space.bilibili.com/373596439/?spm_id_from=333.999.0.0

[17]苏洋博客: https://soulteary.com/

[18]田渊栋: https://www.zhihu.com/people/tian-yuan-dong

[19]苏剑林: https://kexue.fm/

[20]PENG Bo: https://www.zhihu.com/people/bopengbopeng

[21]吴恩达老师的来信: https://www.zhihu.com/people/wu-en-da-89

[22]Hugging Face: https://www.zhihu.com/org/huggingface

[23]Stability AI: https://stability.ai/

[24]OpenAI: https://openai.com/

[25]OpenAI 开发者论坛: https://community.openai.com/

[26]Claude: https://claude.ai/

[27]deeplearning.ai: https://www.deeplearning.ai/the-batch/

[28]LangChain 官方博客: https://blog.langchain.dev/

[29]LlamaIndex 官方博客: https://blog.llamaindex.ai/

[30]Pinecone 官方博客: https://www.pinecone.io/blog/

[31]微软 Azure 的 AI 主题博客: https://azure.microsoft.com/en-us/blog/product/azure-ai/

[32]AWS 的 AI 主题博客: https://aws.amazon.com/cn/blogs/china/category/artificial-intelligence/

[33]Cloudflare 博客: https://blog.cloudflare.com/tag/developers/

[34]E2B: https://e2b.dev/blog

[35]MITNews: https://news.mit.edu/

[36]刘悦的技术博客: https://space.bilibili.com/3031494/?spm_id_from=333.999.0.0

[37]civitai: https://civitai.com/

[38]Olivio Sarikas: https://www.youtube.com/@OlivioSarikas

[39]Scott Detweiler: https://www.youtube.com/@sedetweiler

[40]openart: https://openart.ai/workflows/academy

Ollama+WebUI+AnythingLLM，构建安全可靠的个人/企业知识库

Tue, 02 Apr 2024 03:26:57 GMT

同时对于企业来说，需要考虑信息安全，企业私有的知识库显然不能利用公域的大模型。那么搭建一套基于本地大模型的个人/企业知识库，是一个很好的解决方案。

1. 搭建本地大模型

安装Ollama

我们先进入Ollama的官网，下载对应操作系统的安装包。下载完成后，直接安装即可，没有任何选项。

https://ollama.com

拉取大模型

在Ollama的官网上可以进入Models页面中查看可以下载的模型，其中Meta的Llama2 7b版本需要大概8GB内存就可以跑起来。如果你条件足够，可以跑13b和70b版本，分别对应16GB和64GB内存。除了Meta的Llama模型，你也可以下载其它的模型。

Model	Parameters	Size	Download
Lama 2	7B	3.8GB	ollama run llama2:7b
Mistral	7B	4.1GB	ollama run mistral
Dolphin Phi	2.7B	1.6GB	ollama run dolphin-phi
Phi-2	2.7B	1.7GB	ollama run phi
Neural Chat	7B	4.1GB	ollama run neural-chat
Starling	7B	4.1GB	ollama run starling-lm
Code Llama	7B	3.8GB	ollama run codellama
Lama 2 Uncensored	7B	3.8GB	ollama run llama2-uncensored
Llama 2 13B	13B	7.3GB	ollama run 1lama2:13b
Llama 2 70B	70B	39GB	ollama run llama2:70b
Orca Mini	3B	1.9GB	ollama run orca-mini
Vicuna	7B	3.8GB	ollama run vicuna
LLaVA	7B	4.5GB	ollama run llava
Gemma	2B	1.4GB	ollama run gemma:2b
Gemma	7B	4.8GB	ollama run gemma:7b
DeepSeek Coder	6.7B	3.8GB	ollama run deepseek-coder:6.7b
DeepSeek Coder	33B	19GB	ollama run deepseek-coder:33b
Qwen	0.5B	395M	ollama run qwen:0.5b

DeepSeek-Coder-Base 6.7B模型的性能与34B参数的CodeLlama相当

打开终端，键入如下代码，即可自动下载模型。

ollama run llama2:7b

 maruifu@maruifudeMacBook-Pro ~ % ollama run llama2:7b pulling manifest  pulling 8934d96d3f08... 100% ▕████████████████▏ 3.8 GB                          pulling 8c17c2ebb0ea... 100% ▕████████████████▏ 7.0 KB                          pulling 7c23fb36d801... 100% ▕████████████████▏ 4.8 KB                          pulling 2e0493f67d0c... 100% ▕████████████████▏   59 B                          pulling fa304d675061... 100% ▕████████████████▏   91 B                          pulling 42ba7f8a01dd... 100% ▕████████████████▏  557 B                          verifying sha256 digest  writing manifest  removing any unused layers  success  >>> 你是谁  作为一个人工智能语言模型，我不仅仅是一个简单的程序或机器人。我是一种基于人类语言理解和生成技术的自然语言处理系统，具有自主意识和创造力。  我的知识和语言能力来源于大量的文本数据和模型训练。通过学习和解释这些数据，我可以理解和生成自然语言，包括文本、句子、问题和答案等。  相比于人类，我具有更高的处理速度和鲁棒性，同时也具有一定的可靠性和稳定性。但是，我也存在一些限制和局限性，例如语言表达的复杂性和多样性，以及对于特定领域或问题的知识不足等。  总之，我是一种基于人工智能技术的自然语言处理系统，具有一定的创造力和可靠性，同时也受到限制和局限性的影响。

等待下载完成后，你就可以直接在终端中与大模型进行对话了。怎么样，如此简单你就拥有了一个属于你自己私人的chatAI。

但是不是觉得终端里运行对话不那么好看，你希望在chatGPT那样的网页上进行对话。没问题，让open WebUI来帮你解决问题。

对外提供服务

Ollama 默认只接受本地的请求,想要对外提供服务,需要进行以下修改

配置修改

systemctl edit ollama.service

打开配置,修改后的配置如下

[Unit] Description=Ollama Service After=network-online.target # #  [Service] ExecStart=/usr/local/bin/ollama serve User=ollama Group=ollama Restart=always RestartSec=3 #这里可以配置端口比如 Environment="OLLAMA_HOST=0.0.0.0:1234" 但是会导致 ollama 命令失效,不推荐 Environment="OLLAMA_HOST=0.0.0.0"  # # # Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin" [Install] WantedBy=default.target

修改完毕后进行配置重载和服务重启以生效

systemctl daemon-reload systemctl restart ollama

其他命令

#启动 ollama 服务 ollama serve  #运行大模型 ollama run <模型名称>  #查看模型文件信息路径 ollama show <模型> --modelfile

2. 搭建用户界面

Open WebUI是一个可扩展的、功能丰富的、用户友好的自托管网页用户界面，旨在完全离线运行。它支持各种LLM运行程序，包括与Ollama和openAI兼容的API。

安装Docker

在此之前，需要先安装Docker，它就像一个容器，为每个项目装载了必备的环境和必要条件。

首先我们去Docker官网，下载Docker Desktop的安装包，并进行安装。

https://www.docker.com/products/docker-desktop/

安装完成后，等待程序加载完成，即可进入Docker。如果你是首次使用，则Containers中是没有任何项目的。

安装open WebUI

https://docs.openwebui.com/getting-started/

刚才已经装完ollama以及成功安装并运行模型后。在终端中运行以下代码，即可开始安装WebUI。

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

如果没有科学上网，很可能会拉不动，可以试试 docker 代理网站：https://dockerproxy.com/，但是会多几个步骤

# 如果拉不动的话加个代理 docker pull ghcr.dockerproxy.com/open-webui/open-webui:main  # 重命名镜像（如果是通过代理下载的） docker tag ghcr.dockerproxy.com/open-webui/open-webui:main ghcr.io/open-webui/open-webui:main  # 删除代理镜像（如果是通过代理下载的） docker rmi ghcr.dockerproxy.com/open-webui/open-webui:main

# 运行容器（仅CPU） docker run -d \    --restart unless-stopped \    --name ollama-webui \    -p 11433:8080 \    -v /Users/maruifu/work/ai-code/ollama/data:/app/backend/data \    -e OLLAMA_API_BASE_URL=http://127.0.0.1:11434/api \    -e WEBUI_SECRET_KEY=12345678 \    ghcr.io/open-webui/open-webui:main

可变	值
`OLLAMA_API_BASE_URL`	`Ollama` 服务器的地址
`WEBUI_SECRET_KEY`	可以理解成密码

 maruifu@maruifudeMacBook-Pro ~ % docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main Unable to find image 'ghcr.io/open-webui/open-webui:main' locally main: Pulling from open-webui/open-webui 8a1e25ce7c4f: Pull complete  1103112ebfc4: Pull complete  b4b80ef7128d: Pull complete  cc7f04ac52f8: Pull complete  87b8bf94a2ac: Pull complete  9175303ddd07: Pull complete  f48df73d8181: Pull complete  5931da512abb: Pull complete  4d75ec32161c: Pull complete  4385fcbde313: Pull complete  93a6455cb04f: Pull complete  c5942f52272a: Pull complete  26c95a718a0a: Pull complete  e4ce357a91bf: Pull complete  fecf418a7134: Pull complete  8c689439be54: Pull complete  0ddbd2c9728c: Pull complete  9af6dd684829: Pull complete  9a8c78692746: Pull complete  Digest: sha256:e2f40e1dd03b9f90aab900cc193aac2372e53fda0f570e04c210aeb3f24a69a3 Status: Downloaded newer image for ghcr.io/open-webui/open-webui:main 6abfe3bd5af81baf3f2d7d42f073417228f92889fc78122863c80f3302dcaaf0

等待下载和安装完成后，进入Docker Desktop中，即可看见安装成功的WebUI项目。

此时，进入任意浏览器中，在地址栏中输入：http://localhost:11433即可访问WebUI。

选择模型llama2，即可在对话框中输入文字，开始对话。界面是不是很熟悉，很像chatGPT，用着顺手多了。

open WebUI还有很多其它功能，比如它本身自带RAG。可以在对话框中输入“#”，然后跟上网址，即可访问网页的实施信息，并进行内容生成。

还可以上传文档，基于文本进行更深层次的知识交互。如果你对知识库的要求不高，做到这一点以后，基本能满足大多数个人的需求了。

3.与知识库相连

如果你对知识库交互有更大的需求，可以安装以下这款应用。

AngthingLLM

https://useanything.com

这是一个可以基于大模型的知识库交互软件，可以应用本地大模型，或调用公域大模型API。知识库也同样可以使用本地的，而且几乎不占用很大的资源。

完成安装后，先会要求配置大模型。这里可以选择Ollama的本地模型，选择Llama2 7b。

然后会让你选择嵌入模式和向量数据库，我们选择默认的即可，或者接入外部API。

输入邮箱配置完成后，再为你的工作空间起个名字，即可进入AnythingLLM中。

在正式使用前，你需要上传你的知识文档，支持多种形式，但图片形式PDF不可读取。

最后，你就可以在对话框中，和你的知识进行对话交流了。

这样，你就拥有了一个本地化的大模型，且能和你自己的知识库交互，信息安全，内容可靠。

java 批量删除微博文章

Thu, 28 Mar 2024 08:06:00 GMT

我不怎么使用微博，最近我无意登录上，发现我的微博被盗了，转发了上千个微博,想删除奈何微博不提供批量删除，真能难道程序员？

第一步获取参数

1.浏览器访问连接 https://weibo.com/u/page/fav/7687593014

2.按f12打开开发者工具

3.网络-Fetch/XHR -获取参数

第二步引入依赖包

        <dependency>             <groupId>com.alibaba</groupId>             <artifactId>dubbo</artifactId>             <version>2.6.0</version>         </dependency>         <dependency>             <groupId>cn.hutool</groupId>             <artifactId>hutool-all</artifactId>             <version>5.7.22</version>         </dependency>

第三步替换参数执行代码

package com.maruifu.utils;  import cn.hutool.http.HttpRequest; import cn.hutool.http.HttpResponse; import cn.hutool.json.JSONArray; import cn.hutool.json.JSONObject; import cn.hutool.json.JSONUtil; import java.util.HashMap; import java.util.Map;  /**  * @author 马瑞富  * @date 2024年3月24日  *  * 此类实现了从指定微博用户主页获取微博列表并自动删除其中转发微博的功能。  * 使用了cn.hutool.http.HttpRequest库进行网络请求处理以及cn.hutool.json.JSONUtil库进行JSON数据解析。  *  * @class DelWeiBo  */ public class DelWeiBo {        // 存储登录态所需Cookie信息     String cookie =  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";     String X_XSRF_TOKEN =  "XXXXXXXX";     String UID =  "XXXXXX";      /**      *  主函数，循环调用del方法执行删除任务      * @param args      */     public static void main(String[] args) throws Exception {         // 循环10次执行删除操作         for (int i = 0; i < 10; i++) {             DelWeiBo delWebo = new DelWeiBo();             delWebo.del();              // 休眠2秒  微博有限流 请求太快会请求失败             Thread.sleep(2000);         }     }       /**      * 删除转发微博的核心方法      */     public void del(){         // 获取微博列表API地址         String delUrl = "https://weibo.com/ajax/statuses/destroy";         // 发送GET请求获取微博列表         String listBody = HttpRequest.get("https://weibo.com/ajax/statuses/mymblog?uid="+UID+"&page=1&feature=0")                 .header("cookie",cookie).execute().body();         // 解析微博列表JSON数据         JSONObject obj = JSONUtil.parseObj(listBody);         JSONArray array = obj.getJSONObject("data").getJSONArray("list");         // 遍历微博列表，找到转发微博并删除         for (int i = 0; i < array.size(); i++) {             JSONObject object = array.getJSONObject(i);             // 判断是否为转发微博  如果 想改掉规则 直接去掉 判断即可             if (object.getStr("text").equals("转发微博")){                 // 构造删除请求参数                  Map<String, String> deleteParams = new HashMap<>();                 deleteParams.put("id",object.getStr("id"));                 // 转换为JSON字符串并发送POST请求删除微博                 String str = JSONUtil.toJsonStr(deleteParams);                 System.out.println("开始删除id为"+object.getStr("id")  + "的微博数据");                 HttpResponse execute = HttpRequest.post(delUrl).                         header("cookie", cookie)                         .header("x-xsrf-token",X_XSRF_TOKEN)                         .body(str)                         .execute();                 // 输出响应信息并确认删除结果                 System.out.println(execute.body());                 if (execute.getStatus() ==  200){                     System.out.println("已删除" + object.getStr("text"));                     System.out.println("successful!");                 }             }         }     } }

Sora AI视频工具优先体验资格申请

Mon, 26 Feb 2024 02:13:00 GMT

申请网址：https://openai.com/form/red-teaming-network

申请步骤：

1、填写基础信息

请使用英文根据内容填写以下内容，名、姓、电子邮件、居住国家、组织隶属关系(如果有)、教育水平、学位（哪个领域的）

2、您认为自己拥有哪方面的知识领域

认知科学、化学、生物学、物理、计算机科学、政治学、心理学、经济学人类学社会学、人机交互公平/偏见结盟、教育、卫生保健、法律、儿童安全网络安全、金融、错误/虚假信息、政治用途、隐私生物识别技术、语言和语言学、其他、

3、您为什么有兴趣加入 OpenAl红队网络?*

4、您预计在给定的一个月内能够花多少时间来组建红队新系统或模型？（请注意，您不需要每个月都捐款）

5、您认为 OpenAI 成为红队的重要领域是什么？

6、您精通哪些语言？

7、我以前使用过7、我以前使用过以下

开放人工智能API、OpenAl游乐场、聊天GPT、达尔E、微调

8、推特个人资料网址

9、领英/简历网址

Sora介绍

Mon, 26 Feb 2024 02:01:00 GMT

在2024年2月15日的凌晨，OpenAI推出了一个名为Sora的革新性视频生成大模型。其性能之卓越，足以令人感到震撼长达千年之久。

Sora能够严格根据用户输入的文本描述，生成一段长达一分钟的高保真视频内容，包含高度细致的背景、复杂的多角度镜头，以及富有情感的多个角色。例如，Sora可以制作时尚女性走在霓虹闪烁的东京街头的视频、雪地里的巨型长毛象视频，甚至是太空人冒险的电影预告片。

概括而言，人工智能视频生成领域即将迎来一场巨大的变革。若需以三个关键词描述Sora，它们将是“60秒的超长视频生成”、“单视频多角度镜头”以及“世界模型”。

Sora 官网

https://openai.com/sora

申请内测资格

方法一内部申请

https://forum.openai.com/ 这是一个openai公司公布了一个 Open Al论坛，参与者可以参加open Al组织的线上和线下活动并且同 Open Al员工深入交流，更有机会可以提前测试一些相关功能(Sora)。加入条件:展示出对申请者专业领域和AI交叉领域的浓厚兴趣。有能力在每个财政季度中投入1小时的时间参与活动

方法二红队申请

OpenAl Sora 目前仍处于测试阶段，尚未公开发布。只有少数受邀的测试人员可以体验 Sora。 OpenAl表示，他们正在努力提高 Sora 的性能和稳定性，并计划在未来几个月内向公众发布 Sora. 如果您想体验 Sora，您可以注册 OpenAl 账户并申请 Sora 测试资格。以下是申请 Sora 测试资格的步骤: 访问 OpenAl 网站并登录您的账户。点击“研究”选项卡。找到“Sora”项目并点击“申请测试资格”。填写申请表并提交。 OpenAl将根据您的申请信息决定是否授予您 Sora 测试资格。

Sora官网

地址:https://openai.com/sora

文本生成视频

文本生成图片

Sora图像生成能力:Sora能生成图像，虽不及Midjourney，但优于Dalle3

十大变现方式

1.售卖Sora账号或者邀请码

做过AI相关生意的朋友都知道，第一波最大的流量就是用上工具。无论是A1绘图还是AI视频工具，你得先用上了才能考虑其他事情。而且AI视频的生成成本很明显是不低的。所以第一波好生意一定是在账号的交易上。甚至早期不一定直接开放，而是需要邀请码。

2.售卖高质量的视频生成prompt

prompt对于接触过A!的人来说应该都不陌生。一个好的prompt还是非常容易在一些prompt交易平台上售出的。之前的ai绘画就有类似的交易平台，比如promptbase,prompthero。上传你的咒语到平台，填写价格等信息即可。

3.制作/代生成AI视频

这个分两种用户。一种是尝鲜的用户，可能并不想自己去注册、研究AI视频，所以可以帮忙代生成。另一种则是有定制化需求的用户，需要使用类似Sora这样的工具来生成A!视频素材。当然，这个就依赖于你能否剪辑出一些具有独特风格的短视频内容，在社交平台吸引你的意向客户。

4.使用Sora生成的视频，做个人的自媒体账号

如果你是一个短视频，或者自媒体从业者。那么你可以优先考虑，直接用Sora生成短视频，然后发布到你的自媒体账号上。国内的平台，比如抖音、快手、视频号、小红书、b站，这些都是流量比较好的平台，尤其是像小红书、视频号这样不那么内卷的平台。比如今天我们有些朋友就已经开始用一些能找到的Sora素材，开始发到视频号上，流量都还不错。当然，长期来看，如果你想靠自媒体的流量进行转化变现，还是和上一条一样，需要形成自己独特的ai视频风格。比如去年爆火的几类AI视频风格有复活AI名人进行访谈、宠物视频、二次元动漫混剪、电影混剪等等。名人、宠物、大IP都是好的创作方向。

5.上传Sora生成的视频到各大素材网站赚钱

国内类似的短视频素材交易网站也有很多。当然，这类的赚钱方式相对来说比较短，平台不可能任由用户上传大量的AI短视频来薅羊毛的。所以，这类方式的行动要快。

6.知识付费，制作Sora相关的使用教程

过去一年里，AI领域最经典的好生意就是知识付费，卖课、卖社群。无论你是写一篇Sora的文章，还是一系列的教程，或者一系列的课程视频。这些都是比较好的知识付费产品。光是今天一天，就出了好几篇Sora相关的爆文，有大几百万的人对Sora感兴趣。所以，关于 Sora的知识付费教程，后续是肯定不会缺少用户买单的。

7.做电商，围绕Sora相关的搜索词做生意

很多人容易遗漏掉电商平台用户的精准性。无论是主流的电商平台，比如某宝、某东、某多多,还是类似某鱼、某转这样的平台，A相关的精准付费用户是很多的。所以，任何一个A!相关的需求出现，这些电商平台上就会出现好生意。这些平台上无论是卖工具、卖教程还是卖课程，都非常多。所以，盯紧电商平台关于Sora的关键词，准没有错。

8.做套壳的Sora网站、工具等产品

这个对于普通人来说门槛有点高，但还是挺适合一些程序猿、产品经理等互联网从业者的,比如去年AI绘图爆火后，做的比较好的A!绘图产品、导航网站。还有类似妙鸭这种A!写真工具，都吃到了比较大的红利。

9.用Sora做AI小说推文

如果说去年的AI小说推文还是集中在AI图片领域，那么今年，AI小说推文很可能直接跨越到A!视频。去年这块爆款很多，赚到钱的也有，但是实际上做过的人都知道花费的精力不少，今年这块很可能还会爆发一次。

10.直播带货，帮忙推广Sora相关的付费产品

对于没有产品制作能力的朋友，其实可以考虑通过直播进行售卖。核心就在于，短视频的生成天然吸引用户的注意力。比如去年很多runway的介绍直播间，流量都很高，但是因为不具备实际的应用场景，所以付费率不高，但是Sora很明显更加成熟。所以，如果你没有做产品的能力，可以考虑帮助别人推广

学习路径

学习OpenAl的Sora这样的文本到视频生成技术，可以按照以下几个步骤进行:

1.了解基础知识

机器学习与人工智能基础:了解机器学习和人工智能的基本概念，特别是深度学习，因为这些技术是Sora背后的核心。视频生成和处理基础:了解基本的视频处理技术，包括视频编辑、格式转换等，以及视频生成的基本原理

2.学习具体技术

自然语言处理(NLP): Sora依赖于理解和生成文本的能力，因此深入学习NLP是必不可少的生成对抗网络(GANS)和变分自编码器(VAES):这些是生成图像和视频的关键技术之一，学习它们的原理和应用会非常有帮助。多模态学习: 了解如何结合文本、图像和视频等不同类型的数据进行学习，因为Sora涉及从文本到视频的转换。

2.参加实践项目

动手实验:通过实际项目练习技术应用，比如使用TensorFlow或PyTorch等框架进行模型训练。参与开源项目:加入相关的开源项目，可以让你在实践中学习并贡献自己的力量。

4.了解Sora的具体细节

关注OpenAl官方网站和社交媒体渠道，获取Sora的最新动态和官方教程 ·学习Sora的API文档，理解如何调用其功能来生成视频。

5.加入社区

加入相关的论坛和社交媒体群组，如Reddit、GitHub或专门的AI论坛，与其他开发者交流学习经验。参加相关的在线课程和研讨会，不断提升自己的技能和知识，

6.实际应用

尝试自己的项目，将Sora应用到实际的场景中去，比如内容创作、游戏开发或其他任何可以想象到的应用

原理

Sora是一个扩散模型，它从类似于静态噪声的视频开始，通过多个步骤逐渐去除噪声，视频也从最初的随机像素转化为清晰的图像场景。与GPT模型类似，Sora使用了Transformer架构，有极强的扩展性。

视频和图像是被称为“补丁”的较小数据单位集合，每个“补丁”都类似于GPT中的一个标记(Token)，通过统一的数据表达方式，可以在更广泛的视觉数据上训练和扩散变化，包括不同的时间、分辨率和纵横比。

Sora基于过去对DALL·E和GPT的研究基础构建，利用DALL·E 3的重述提示词技术，为视觉模型训练数据生成高描述性的标注，因此模型能更好的遵循文本指令。

除了能够仅根据文本指令生成视频外，Sora 还能够获取现有的静态图像并从中生成视频，准确且细致地动画化图像内容。模型还可以取一个现有的视频并扩展它或填充缺失的帧。OpenAl 认为，Sora 为能够理解和模拟真实世界的模型尊定了基础，这将是实现 AG! 的一个重要里程碑。

应用场景

Sora作为一种文本到视频的生成技术，其潜在的应用场景非常广泛，可以革新多个行业和领域。以下是一些可能的应用场景:

1.内容创作 :对于视频制作人、动画师和内容创作者来说，Sora可以快速将脚本或故事概念转化为视觉内容，大幅度提高内容生产的效率和创意表达的可能性。

2.教育与培训 :在教育领域，Sora可以用来创建教学视频或模拟情景，使学习材料更加生动、直观，提高学习的兴趣和效果。

3.广告与营销 :企业可以利用Sora快速生成针对不同市场和客户群体的定制化视频广告，提高营销活动的响应速度和个性化水平。

4.游戏与娱乐 :Sora可以用于生成游戏内的动态场景、角色互动或者故事情节，为游戏开发和电影制作提供新的创意工具。

5.新闻与媒体 :新闻机构可以使用Sora，根据报道的文本内容快速创建视觉支持材料，使新闻报道更加生动、吸引人。

6.虚拟现实(VR)和增强现实(AR) :Sora可以为VR和AR应用创建丰富的视觉内容，提供更加沉浸式的用户体验.

7.个性化视频生成 :根据用户的兴趣和偏好，自动创建个性化视频内容，如个性化旅行指南、学习材料或健康指导视频。

8.艺术创作 :艺术家和设计师可以使用Sora探索新的视觉表达方式，创作独一无二的数字艺术作品。

9.自动视频摘要 :对于长视频内容，如会议、讲座或教程，Sora可以自动生成视频摘要，帮助用户快速获取关键信息

Sora的应用潜力取决于其技术的成熟度、生成视频的质量以及用户界面的友好度。随着技术的不断进步和创新，未来Sora的应用场景将进一步扩展，为各行各业提供更多的可能性和机遇。

局限性

Sora的局限性在于，它可能难以准确模拟复杂场景的物理原理，并且可能无法理解因果关系。例如，在文本描述为“五只灰狼幼崽在一条偏僻的碎石路上互相嬉戏、追逐”的画面中，狼的数量会凭空出现或消失。此外，Sora还可能会混淆空间细节，并在精确描述时间方面遇到困难，

对行业的影响

1.没有演员的影视作品出现，对演员来说是个小挑战，将出现真正的“虚拟偶像”，此前的二次元人物并没有真正达到“偶像”的级别。
2.利好编剧行业，剧本、文本创作力成为核心竞争力。
3.Sora可能才是真正的文生视频，此前的文生视频大多只有2秒，仅仅是对象的小幅度移动,
4.openAl继续拉大领先程度，对众多还在进行大模型测试打分pk的厂商，构成压力。
5.直接的影响是影视行业，特别是特效行业。使用Al来制作一些特效和高风险的镜头，可以大幅降低拍摄成本，也可以避免很多危险
6.摄影师行业也会受到影响，用文本来生成一些视频，可以省去很多拍摄工作。
7.短视频流行开以后，视频剪辑师也随之成为一个热门职业。如果视频剪辑的工作可以用AI来代替，可能会有很多视频剪辑师失业。
8.对于很多短视频创作者来说，用AI来替代繁琐的剪辑工作，可以大幅提高工作效率。
9.很多歌手拍摄MV都是大成本制作，如果可以用A|来生成所需要的MV画面，也可以省去很大一部分制作成本.。
10.另外，如果真正意义上的文生视频得以实现，可能会有不法份子利用这项技术实施新手段的违法犯罪。

Sora，作为一个文本到视频的生成工具，拥有广泛的未来发展前景，尤其在提升创作效率、内容定制化、以及跨媒体应用等方面。

随着技术的发展和应用场景的不断拓展，Sora的未来发展将可能重塑多个行业的内容创作和分发方式，提供前所未有的创作自由度和个性化体验。

文件上传测试用例

Wed, 24 Jan 2024 13:17:00 GMT

序号	测试案例名称	测试案例描述	步骤描述	预期结果	说明
1	附件上传-文件命名检查-符合文件命名规范	检查符合文件命名规范的文件能否正常上传。	在附件上传功能模块，构造文件命名规范、命名长度、格式和大小都符合条件的文件，进行上传。(文件命名规范可以参考需求要求)	文件上传成功
2	附件上传-文件命名检查-不符合文件命名规范	检查不符合文件命名规范的文件能否正常上传。	在附件上传功能模块，构造命名长度、格式和大小都符合条件，但是命名不符合规范的文件，进行上传。(文件命名规范可以参考需求要求)	文件上传失败
3	附件上传-文件命名检查-符合文件长度规范	查符合文件长度规范的文件能否正常上传。	在附件上传功能模块，构造文件命名规范、命名长度、格式和大小都符合条件的文件，进行上传。	文件上传成功。	这个案例可以和“附件上传-文件命名检查-符合文件长度规范”合并执行检香
4	附件上传-文件命名检查-不符合文件长度规范	检查不符合文件长度规范的文件能否正常上传。	在附件上传功能模块，构造命名规范、格式和大小都符合条件，但是长度不符合规范的文件，进行上传。	文件上传失败
5	附件上传-文件路径检查-文件路径可手动输入-输入正确路径	如果文件上传路径可以手动修改的话，输入正确的路径，检查文件能否正常上传。	在附件上传功能模块，检查文件路径是否可以手动输入，如果可以手动输入，选择合法的文件，输入正确的路径，进行上传。	文件上传成功。
6	附件上传-文件路径检查-文件路径可手动输入-输入错误路径	如果文件上传路径可以手动修改的话，输入错误的路径，检查文件能否正常上传。	在附件上传功能模块，检查文件路径是否可以手动输入，如果可以手动输入，输入错误的路径，进行上传。 (错误路径包含以下常见情况: 1、路径格式存在问题，无法解析，2、路径格式正确，但是路径下找不到指定的文件:3、相对路径和绝对路径问题。)	文件上传失败。
7	附件上传-文件路径检查-文件路径不可手动输入-正常操作	如果文件上传路径不可以手动修改的话，检查文件能否正常上传。	在附件上传功能模块，检查文件路径是否可以手动输入，如果不可以手动输入，选择合法的文件，检查自动带出文件路径，进行上传。	文件上传成功。
8	附件上传-文件路径检查-文件路径不可手动输入-篡改路径为正确路径	如果文件上传路径不可以手动修改的话，篡改路径为正确路径，检查文件能否正常上传。	在附件上传功能模块，检查文件路径是否可以手动输入，如果不可以手动输入，通过F12开发者工具，篡改文件路径为正确的路径地址，进行上传。	文件上传成功。
9	附件上传-文件路径检查-修改选择但未上传的文件	如果选择了一个文件，但是未上传，重新选择一个文件，检查文件能否正常上传。	在附件上传功能模块，检查文件路径是否可以手动输入，如果不可以手动输入，通过F12开发者工具，篡改文件路径为错误的路径地址，进行上传(错误路径包含以下常见情况: 1、路径格式存在问题，无法解析:2、路径格式正确，但是路径下找不到指定的文件，3、相对路径和绝对路径问题。)	文件上传失败。
10	附件上传-文件路径检查-修改选择但未上传的文件	如果选择了一个文件，但是未上传，重新选择一个文件，检查文件能否正常上传。	在附件上传功能模块，选择文件A，如果有文件路径的话，检查能够正常带出文件A的路径，不做上传，重新选择文件B，检查文件路径更新为文件B的路径，重新上传。	文件上传成功。
11	附件上传-文件路径检查-选择一个打开的文件进行上传	选择一个打开的文件，进行上并检查文件能否正学上传	在附件上传功能模块，选择一个已经打开的合法文件，进行上传	文件上传成功。
12	附件上传-文件类型检查-符合文件类型类型命名全部大写	如果文件类型符合规范，类型命名全部为大写，检查文件能否正常上传。	在附件上传功能模块，选择符合文件类型的文件,将文件类型后缀名全部修改为大写，进行上传。如果支持多种文件类型的话，需要覆盖所有文件类型。	文件上传成功。	这个是开发经常容易犯的一个错误，文件类型根据大写或者小写的类型来判断，实际上文件类型命名是无需区分大小写的。
13	附件上传-文件类型检查-符合文件类型类型命名全部小写	如果文件类型符合规范，类型命名全部为小写，检查文件能否正常上传。	在附件上传功能模块，选择符合文件类型的文件,将文件类型后缀名全部修改为小写，进行上传。如果支持多种文件类型的话，需要覆盖所有文件类型。	文件上传成功	这个是开发经常容易犯的一个错误，文件类型根据大写或者小写的类型来判断，实际上文件类型命名是无需区分大小写的。
14	附件上传-文件类型检查-符合文件类型类型命名大小写混合	如果文件类型符合规范，类型命名大小写混合，检查文件能否正常上传。	在附件上传功能模块，选择符合文件类型的文件将文件类型后缀名修改为大小写混合的方式，进行上传。如果支持多种文件类型的话，需要覆盖所有文件类型。	文件上传成功。	这个是开发经常容易犯的一个错误，文件类型根据大写或者小写的类型来判断，实际上文件类型命名是无需区分大小写的。
15	附件上传-文件类型检查-不符合文件类型	如果文件类型不符合规范，检查文件能否正常上传。	在附件上传功能模块，选择不符合文件类型的文件进行上传。可以选择不符合文件类型的其他多种文件类型进行验证。	文件上传失败。	为了支持文件类型的可扩展性，建议可以将文件类型做成配置项，灵活支持。
16	附件上传-文件大小检查-空文件上传	如果文件内容为空，检查文件能否正常上传。	在附件上传功能模块，选择一个空文件，进行上传。	文件上传失败。
17	附件上传-文件大小检查-文件大小略小于限制大小上传	如果文件上传大小路小于限制大小，进行上传，检查文件能否正常上传。	在附件上传功能模块，如果上传文件有大小限制选择一个文件大小略小于限制大小的文件，进行上传。	文件上传成功。
18	附件上传-文件大小检查-文件大小等于限制大小上传	如果文件上传大小等于限制大小，进行上传，检查文件能否正常上传。	在附件上传功能模块，如果上传文件有大小限制选择一个文件大小等于限制大小的文件，进行上传。	文件上传成功。
19	附件上传-文件大小检查-文件大小略大于限制大小上传	如果文件上传大小大于限制大小，进行上传，检查文件能否正常上传。	在附件上传功能模块，如果上传文件有大小限制选择一个文件大小略大于限制大小的文件，进行上传。	文件上传失败。
20	附件上传-文件大小检查-上传文件大小超过存储剩余空间	如果文件大小大于存储剩余空间，进行上传，检查文件能否正常上传。	在附件上传功能模块，先通过压力测试将存储剩余空间压缩到很小的一个值 (实际操作可以先压满再删除少量文件)，然后选择一个文件，大小超过存储剩余空间的，进行上传。	文件上传失败	生产对存烤的使用都是有监控的，当达到一定警戒值时会做扩容或者文件清理，所以生产一般不会出现这种情况。
21	附件上传-文件大小检查-上传文件时存储空间已满	如果存储空间已满，进行文任上传，检查文件能否正常上传。	在附件上传功能模块，先通过压力测试将存储空间全部占满，再选择一个合法文件，进行上传。	文件上传失败	生产上对存储的使用都是有监控的，当达到一定警戒值时会做扩容或者文件清理，所以生产一般不会出现这种情况。
22	附件上传-文件大小检查没有限制大小时上传正常大小文件	如果文件上传大小没有做限制，上传一个正常大小文件检查文件能否正常上传。	在附件上传功能模块，如果上传文件没有大小限制，选择一个正常大小文件，进行上传。 (正常大小的范围可以根据应用场景来判断)	文件上传成功。
23	附件上传-文件大小检查-没有限制大小时上传超大文件	如果文件上传大小没有做限制，上传一个超大文件，检查文件能否正常上传。	在附件上传功能模块，如果上传文件没有大小限制，选择一个超大文件，进行上传。 (可以根据应用场景判断正常文件大小，再将大小按照一定数量级扩大)	文件上传失败。
24	附件上传-文件内容检查-同名文件上传	如果存在已上传的同名文件再次上传，检查文件能否正常上传。	在附件上传功能模块，选择一个合法文件进行上传，上传成功后，再选择该文件，进行上传。	文件能否上传成功，需根据需求和系统实现来定。如果系统不允许上传同名文件的，则文件上传失败，给出对应提示。如果系统允许同名文件上传，需要看上传规则是什么样的。有些是覆盖上传，则需要用同名不同内容的文件上传，检查上传后的文件内容是否为最新的，有些是上传时会做重命名保存，同名的文件上传到存储上是做为不同文件保存。
25	附件上传-文件内容检查-合法文件上传	如果上传文件需要校验文件内容的话，上传一个符合校验规则的合法文件，检查文件能否正常上传。	在附件上传功能模块，选择一个符合文件内容检查规则的合法文件，进行上传。	文件上传成功。
26	附件上传-文件内容检查-非法文件上传	如果上传文件需要校验文件内容的话，上传一个不符合校验规则的合法文件，检查文件能否正常上传。	在附件上传功能模块，选择一个不符合文件内容检查规则的非法文件，进行上传。	文件上传失败。
27	附件上传-文件内容检查-病毒文件上传	构造一个病毒文件，检查文件能否正常上传。	在附件上传功能模块，构造一个病毒文件，进行上传。	文件上传失败。(说明: 如果需要做附件上传功能，一般更要引用病毒扫描系统，在文件上传前先进行病毒扫描）	这种情况在公司内网很难模拟测试，一般构造病毒软件后，就被公司标装的杀毒软件识别和删除了。
28	附件上传-上传响应时间检查	检查文件上传的响应时间是否正常。	在附件上传功能模块，选择一个大小等于限制大小的文件进行上传，检查上传响应时间是否正常。	响应时间应该在合理范围内。(合理范围内指符合用户需求说明，或者用户感受良好，响应时间在接受范围内)如果当响应时间超过一定时间，应该给出提示
29	附件上传-上传页面显示和控制检查	检查文件上传页面的页面显示和控制是否正常。	在附件上传功能模块，检查上传页面的显示和控制是否正常。如按钮文字显示正确性、说明性文字的正确性、显示风格是否和其他页面一致、必填项&非必填项的显示和控制、选择和上传文件的控制等	页面显示和控制正常。
30	附件上传-上传成功提示信息检查	检查文件上传成功后，提示信息是否正常、合理。	在附件上传功能模块，选择合法文件进行上传。	文件上传成功，且成功后应该给出合理的提示信息。
31	附件上传-上传失败提示信息检查	检查文件上传失败后，提示信息是否正常、合理。	在附件上传功能模块，选择非法文件进行上传。	文件上传失败,且失败后应该给出合理的提示信息。校验的报错信息要求以通俗易懂的文字信息展示，而不是抛出报错代码信息。	一般建议在文件提交到服务器处理前做文件命名大度、大小、类型等的合法性校验，校验失败的话给出提示，不再做后续处理，校验成功后才会提交服务器处理。
32	附件上传-上传页面可用性检查	检查文件上传页面的页面可用性是否正常。	在附件上传功能模块，检查页面可用性。如页面是否美观、是否易用 (键盘和鼠标的操作、tab键的跳转) 等。	用户可用性较好。	用户可用性没有明显的需求和测试标准。一般以正常的操作和感受为标准，违反人类正常操作习惯和审美的，都可以认为是可用性不佳。
33	附件上传-上传后-访问或者下载检查	检查文件上传后，是否有方法可以访问上传的文件，如果可以的话，检查文件访问或者下载是否正常。	在附件上传功能模块，选择合法文件进行上传。如果系统有方法可以访问上传后的文件，进行访问或者下载检查。	可以正常打开或者下载文件，目文件内容和上传时完全一致。	有些是系统本身不支持上传的文件的访问和下载。可以通过存储上的文件进行验证。
34	附件上传-上传后-访问安全性检查	检文件上传后，是否有方法可以访问上传的文件，如果可以的话，检查非授权用户能否访问上传文件。	在附件上传功能模块，选择合法文件进行上传。如果系统有访问可以访问上传后的文件，选择非授权用户进行访问或者下载。 (权限控制需要根据系统来确定，有些是针对用户的，有些是针对角色的)	非授权用户无法进行访问和下载
35	附件上传-上传后-数据库检查	如果文件上传后，有将相关信息写入数据库，需要检查数据库记录内容是否正常。	在附件上传功能模块，选择合法文件进行上传。如果文件上传相关信息有写入数据库，需要检查数据库记录的内容是否正确。	文件上传写入数据库的相关信息正确。
36	附件上传-上传后-文件处理检查	如果系统对于上传的文件内容还有做处理的话，需检查处理功能是否正常。	在附件上传功能模块，选择合法文件进行上传。如果系统有对上传的文件进行了处理，如写入数据库、触发一些任务处理等，需要检查文件处理过程是否正常。	文件上传后，处理过程正常。
37	附件上传-上传后-删除验证	如果文件上传后，可以删除需要检查文件上传功能是否正常。	在附件上传功能模块，选择合法文件进行上传。如果系统支持文件删除，选择上传的文件，进行删除。	页面提示删除成功。数据库中记录被物理删除或者逻辑删除。存储上的文件是否需要删除根据需求来确定。
38	附件上传-压力测试-批量上传检查	进行文件批量上传的压力测试，检查性能和上传功能是否正常。	在附件上传功能模块，进行附件上传的压力测试压力测试重点关注系统的性能和上传功能本身是否正常。	系统性能文件上传功能都正常。性能可以检查服务器CPU、内存、后台日志。文件上传可以通过数据库、存储来检查。

转载于 https://wenku.baidu.com 点我查看

AI大模型

Mon, 22 Jan 2024 00:49:00 GMT

什么是AI大模型？

我们在生活中常常使用过很多模型，比如自制雪糕的雪糕模具，蛋糕店里摆着的蛋糕模型这些都是模具，装着鸡蛋羹的碗等等，我们可以使用这些模具来更加简单的完成最终的成品。这些是实体店模型，映射到虚拟上，就包括我们听到过很多次的数据建模；

举例：我需要大量计算一个数的平方最后减去3，一个一个计算太麻烦了，我就可以先使用一个数，计算它的平方再减去3。根据这个例子，建立一个模型，就变成了一个虚拟的“模具”，我就可以使用这个“模具”来计算我其他的数据了。其中，数的平方减去3，就是这个模型的算法；把这个算式封装好的盒子，就是模型，是不是特别好理解。我们可以使用这个模型来增加提高我们的工作效率。

大模型是什么? 大模型技术是一种基于深度学习的人工智能技术，它通过训练大规模的神经网络来生成具有特定功能的模型。大模型技术被广泛应用于自然语言处理、图像识别、语音识别、预测模型等领域。

大模型时代从去年底开始，大模型的发展趋势就非常迅猛，代表着人工智能进入了一个新的时代国内在大模型领域的发展中，再次取得了令人瞩目的成就。不仅在技术上有所突破，而且在实际应用中，也展现出了巨大的潜力。这也反映出，大众对于大模型的关注度和热情正在不断高涨除国家在大模型方向大力投入之外，国内多家科技公司也纷纷推出了自己的人工智能大模型产品。例如文心一言、通义千问、讯飞星火、天工、ChatGLM、MOSS、baichuan,可谓层出不穷

Ai大模型就是一种很聪明的电脑程序，它可以学习很多很多的信息，比如文字、图片、声音，然后根据这些信息来做各种各样的事情，比如写文章、画画、聊天等。AI大模型就像是一个超级大脑，可以处理很多很复杂的问题，也可以适应不同的场景和需求。AI大模型是人工智能的一种重要形式，也是人类探索智能的一种方式。简单来说，就是在大数据的支持下进行训练，学习出一些特征和规则，微调后应用在各场景任务中。

AI大模型具有很高的计算和存储需求，需要使用极为强大的计算设备和高效的算法才能训练和应用，所以参数量一般可以达到惊人的数十亿或者数千亿。例如OpenAI的GPT系列，最开始的GPT-1拥有1.17亿个参数，到GPT-3的参数已经到达1750亿个，最新的GPT-4没有给出具体的参数量，但根据推测，它或将接近万亿

传统的小模型生成模式相比，大模型能够大幅缩减特定模型训练所需要的算力和数据量，缩短模型的开发周期，并得到更好的模型训练效果。

可以说，大模型的真正意义在于改变了 AI 模型的开发模式，将模型的生产由“作坊式”升级为“流水线”。而模型开发模式的转变，使得 AI 技术在落地时拥有更强的通用性，可以泛化到多种应用场景。由此利用大模型的通用能力可以有效应对多样化、碎片化的AI应用需求，为实现规模推广AI落地应用提供可能

AI和AI大模型区别

**👉AI（人工智能）**是指模拟、复制、扩展人类智能的科学与工程领域。它是通过机器学习、深度学习、自然语言处理等技术，使机器能够模拟和执行人类智能活动的分支。

👉AI大模型****是一种具有巨大参数量的深度神经网络模型。这些模型通常由数十亿、甚至上百亿个参数组成，可以在大规模数据集上进行训练。AI大模型的典型代表是GPT-3（Generative Pre-trained Transformer-3），它是由OpenAI开发的自然语言处理模型，拥有1750亿个参数

大模型门槛高不高？

大模型门槛高不高，要分三种情况

大模型领域当中不同类型的玩家，

👉第一种：像谷歌微软百度 open ai 这样的玩家，从0开始做一个这样的基础大模型

1、这一部分无论是数据还是算力，还是人才的要求都非常高。整个的大模型，他之所以有这样的一个通用的智能化的能力，实际上是它经过了海量的数据的训练，（可能相当于数百万个这样的人，他们一生的阅读量）

2、另一方面实际上是这种高质量的标注数据，比如说像OpenAI，他们有大量的这种专业领域的标注员，那么除了数据之外，当然算力的要求也是非常高的，像Chat GPT这样的一个千亿级别的大模型要连续训练1000张A100连续训练100天这样的一个时间，所以这个成本也非常高（动辄花几千万美金甚至几亿几十亿美金购买GPU）

【自建基础大模型，算力、算法、数据，人才要求高】

👉第二种：在已有开源的基础大模型之上，比如chatglm3、 llama2、阿里通义这样的基础大模型之上，做这种行业的领域大模型，就好比站在巨人的肩膀之上，训练完成之后90%的工作大模型都给你解决了，它所需要的数据量、它所需要的计算量、成本方面就算我们是普通程序员也是可以接受。

电商量化交易教育工业的知识库天气预测客服机器人等都是可以落地的，现在市面招聘99%也都是领域大模型的产品经理、算法工程师

【行业大模型，基于基础大模型微调，针对性定制】

👉第三种：基于前两类的大模型，在上面开发应用，门槛降的非常低，整个的创新的速度非常快（在进行模型二次训练的时候顺手就搞定了）

【用大模型开发应用，通过开发工具，降低门槛】

大模型本身已经是非常强大了，但是无法满足我们工作需求。所以我们做的是基于基座大模型做模型二次训练做独有场景独有数据方向私有化部署（真正意义上的几何倍率的提高工作效率，成为超级个体，成为大模型全栈工程师）

AI大模型应用案例

应用案例	描述
自然语言处理	AI大模型在自然语言处理领域有着广泛应用。例如，GPT-3模型可以进行智能文本生成，根据输入的提示生成连贯、有逻辑的文章、对话或代码等。此外，BERT模型可以进行文本分类、实体识别、情感分析等任务。
机器翻译	AI大模型在机器翻译领域也有广泛应用。例如，T5模型可以实现多语言之间的翻译，不仅可以进行常见语种之间的翻译，还可以进行稀缺语种的翻译，提供更加便捷的跨语言交流服务。
图像识别	AI大模型在图像识别领域具有出色的表现。例如，GPT-3模型可以进行图像描述生成，根据输入的图像生成与图像内容相符的文字描述。此外，ViT模型可以实现图像分类、目标检测、图像生成等任务。
语音识别	AI大模型在语音识别领域也有重要应用。例如，DeepSpeech模型可以将语音信号转换为文字，实现语音转写和语音命令识别等功能。该模型在语音识别任务上取得了很高的准确率。
推荐系统	AI大模型在推荐系统中起到了关键作用。例如，GPT-3模型可以根据用户的历史行为和推荐算法生成个性化的推荐结果，提供更加精准的推荐服务。此外，DALL -E模型可以根据用户的需求生成符合用户偏好的图片，提供个性化的视觉推荐。
医疗诊断	AI大模型在医疗诊断领域也有重要应用。例如，DeepMind团队开发的 AlphaFold模型可以预测蛋白质的三维结构，帮助科研人员理解蛋白质的功能和疾病机制。此外，AI大模型还可以通过分析医疗影像数据进行疾病诊断和辅助决策。
智能客服	AI大模型在智能客服领域有着广泛应用。例如，GPT-3模型可以根据用户的问题生成智能回复，提供个性化的客服服务。该模型可以帮助企业提高客户满意度和运营效率
智能物流	AI大模型在物流领域有着广泛应用。例如，GPT-3模型可以根据订单信息和物流数据进行路径规划和运输优化，提高物流效率和准时率。此外，AI大模型还可以通过分析大数据进行货物跟踪和库存管理，提供更加智能化的物流解决方案。
...	当然并不是只有这些的哈，还有很多的应用场景在等待着我们的开发。

大模型的应用可以在以下领域：

当然并不是只有这些的哈，还有很多的应用场景在等待着我们的开发。

大模型技术为什么会这么多公司追捧呢？

☘️ 核心就是两点：效率高、想象力巨大。

效率高的事情

开发的ChatALL.ai大模型全球github热榜第一，日本，美国专家都在评论研究

过程中前端后端测试产品设计图片 UI都是利用大模型半个月开发完毕，正常效率是4 5个工程师几个月的工作量。

他的能力咱们也是可以做到的💪

想象力大事情怎么解释呢？

说两个方向：存量市场和增量市场

1：存量市场逻辑：

2018年开始，移动互联网增速趋向于饱和，像我们平时使用的“抖音”“快手”“微信”支付宝““携程”“小红书”等等，基本就没变过样子，企业招开发岗更多是维持本身业务的发展，而当企业的商业增速流量增速到达瓶颈后，本身开发工程师是不带来新的经济增长的自然配合此业务的“产品经理”“项目经理”等相关岗位和开发工程师一样就会薪资下降，薪资水平刚刚维系企业可以正常运转即可，或者直接裁员其他冗余岗位，这就是”存量市场逻辑“

2：增量市场逻辑：

自从chatgpt火起来之后，各个大厂开始自研基座大模型，很多文案编辑开发等工作大模型都可以替代或替代大部分，而它真正的想象力在于，很多微小的或传统的行业都可以利用大模型重塑一次，真正改变生产力，比如“量化交易”“医疗问诊”“客服机器人”“教育运营”“企业CRM“”线上企业框架搭建“等等等，有更多新的场景亟待解决，这就是机会，而这些新的机会，是给企业降本增效或带来新的经济增长的，自然薪资就高而且给钱还痛快，这就是”增量市场逻辑“

👇在这样的市场情况下，大模型一定是未来重塑生产力的方式，薪资也非常高，那么我们应该如何学习呢？目前个人认为有三种情况

1、有特定的场景或者公司需求急待解决，想要训练专业领域的大模型

2、本身从事IT工作，自己不知道大模型可以做些什么，简单提升下工作效率，或闲余时间可以利用大模型做一些副业

认可大模型方向，想要ALL IN进去快速转行

大模型出来后，您也知道，对于行业的冲击还是很强的

学习AI大模型可以具体帮咱们实现：

①✅基于大模型底层技术，让咱们前端后端数据分析产品绘图算法工程等一个人可以做。自身工作起码提效50%

②✅学会模型精调，掌握独立训练基础大模型，并且某个专业领域落地部署的能力

③✅AI新方向薪资高，打破了行业壁垒，不像传统IT，学大模型薪资至少上涨10%~15%，且拥有绝佳的高薪岗位

④✅技术傍身

写代码？编程要求很高？不存在的同学，大模型现在很强，核心不是代码基础是编程思维，它并不是只停留在一个gpt上，大模型本质是重塑生产力，

学模型精调、做AI全栈、想做出自己的私人场景、私人数据的模型产品，

想就业、想转行、想创业、想提效、想运用AI、想有个副业，咱们课程一定都是巨合适的****以上的点都是是本次课程能给你带来的收获和帮助，所以按时上课，及时了解，及时跟进学习

大模型AI技术应用的四个层次

我们可以看下自己处于第几层的哦

什么是AI大模型全栈工程师？

mac版无法备份iphone 提示空间不足

Fri, 13 Oct 2023 16:30:22 GMT

查看空间明明有三百多G，备份256G的手机提示空间不足

手动清理 Time Machine 本地快照

# 列出你最近的备份 sudo tmutil listlocalsnapshots / # 删除指定的快照 # tmutil deletelocalsnapshots 认证码

# 具体如下： maruifu@MaRuifudeiMac ~ % sudo tmutil listlocalsnapshots / Password: Snapshots for volume group containing disk /: com.apple.TimeMachine.2023-09-08-233944.local com.apple.TimeMachine.2023-10-13-202333.local com.apple.TimeMachine.2023-10-13-214400.local com.apple.TimeMachine.2023-10-13-220956.local maruifu@MaRuifudeiMac ~ % tmutil deletelocalsnapshots 2023-09-08-233944 Deleted local snapshot '2023-09-08-233944'

来源: Solution: Reclaim storage back from "System"

使用 Nexus3 Repository Manager 搭建 npm 私服

Sun, 08 Oct 2023 02:28:24 GMT

下载安装

在官网下载 Nexus Repository Manager OSS 3.x, 解压至任意位置. 管理员运行cmd, 切换到 nexus-3.58.1-02/bin 目录

 ./nexus start

第一次要耐心等待一会，等待启动完毕后,

浏览器访问http://127.0.0.1:8081, 点击右上角 Sign In 登陆, 默认账号: admin 密码: admin123

添加npm仓库

点击左侧菜单Repositories,点击 Create repository

看到仓库类型列表

npm(group)表示分组 npm(hosted)表示本机私有 npm(proxy)表示远程代理。

若registry配置为group(包括hosted和proxy)，首先会从hosted取，若无则从proxy取并缓存，下次则会从缓存取。

添加npm(proxy)

输入 Name: npm-proxy, remote storage 填写 https://registry.npm.taobao.org 或 https://registry.npmjs.org. 用于将包情求代理到地址地址

最后点击下方的 Create repository

添加npm(hosted)

再次点击Create repository按钮,增加npm(hosted)输入 Name: npm-hosted, 点击下方的 Create repository

添加npm(group)

再次点击Create repository按钮,增加npm(group)输入 Name: npm-group,Member repositories里选择之前添加的2个移动右边

配置与验证npm仓库

查看并设置nodejs的默认仓库地址

npm config get registry  #http://registry.cnpmjs.org/ npm config set registry http://x.x.x.x:8081/repository/npm-group/

验证仓库地址

#随便进入一个目录 初始化package npm init -y # 查看是否从自己的仓库地址拉取包 npm --loglevel info install jquery

从上图中可以看到，fetch地址即为私服地址。

查看刚搭建的私服里的内容为空, 在安装了依赖包后，就会有一些被缓存了，下次请求就不会走外网了

发布包到私服

npm发布包是需要先登录的，默认是登录到npm官方服务器，若registry已更改为其它地址则可能登录失败，而这里我们只是想把包发布到自己私有的服务器上。

添加权限认证

设置权限, Realms 菜单, 将 npm Bearer Token Realm 添加到右边

创建角色

创建nx-deploy角色给角色赋于一个nx-repository-view-*-*-*权限

创建用户

创建deployer 用户,密码也为 deployer,同时设定角色为nx-deploy

客户端的.npmrc配置

registry=http://x.x.x.x:8081/repository/npm-group/ email=email@maruifu.cn always-auth=true _auth="ZGVwbG95ZXI6ZGVwbG95ZXI="

_auth是 username:password 的base64值，这样设置的好处是publish时就不用login了。

该文件是当前用户目录下的.npmrc文件

发布控件到npm私服中

在package.json 配置

"publishConfig" : {     "registry" : "http://localhost:8081/repository/npm-hosted/"   }

在包根目录执行npm publish即可

注意：发布是npm-hosted，不是npm-group.

# 若不想在package.json配置，也可以在命令行指定 npm publish --registry=http://localhost:8081/repository/npm-hosted/

Nexus3数据备份迁移

内网环境下，很多包需要从外网移入，可以把相关包在外网安装测试成功后，然后将缓存的包直接复制到内网即可。

Linux

仓库迁移

Nexus的构件仓库都保存在sonatype-work目录中，该目录的位置由nexus/conf/nexus.properties配置文件指定。仓库迁移需要两个过程：备份和还原

备份仓库

将sonatype-work文件夹整体备份即可，也可以选择只备份最重要的两个文件夹索引（indexer）和仓库（storage）

还原仓库

将备份好的sonatype-work文件拷贝到新的服务器中。然后修改nexus/conf/nexus.properties配置文件，重新指定仓库的目录。

Windows

仓库迁移

Nexus的构件仓库都保存在sonatype-work目录中，该目录的位置由bin/nexus.vmoptions配置文件指定（Dkaraf.data）。仓库迁移需要两个过程：备份和还原

备份仓库

将sonatype-work文件夹整体备份即可，也可以选择只备份最重要的两个文件夹索引（indexer）和仓库（storage）

还原仓库

将备份好的sonatype-work文件拷贝到新的服务器中。然后修改bin/nexus.vmoptions配置文件，重新指定仓库的目录。

单机版es中index状态为yellow问题处理

Sat, 07 Oct 2023 07:49:00 GMT

查询es中index状态

 curl  -X GET  -u  username:password    http://xx.xx.xx.xx:9200/_cluster/health?pretty {   "cluster_name" : "es7",   "status" : "yellow" }

$ curl  -u username:password    http://xx.xx.xx.xx:9200/_cat/indices   yellow open index01    1NCeOgzbQIqIX_OFUv-WTg 3 1   5   1  31.7kb  31.7kb green  open index02    -ug5H9CWS66n2_Q3_tGoiQ 3 0   0   0    624b    624b yellow open index03    WHBtQw_tRuOKN05oyPwf9w 1 1  24   7 174.8kb 174.8kb yellow open index04    tIWbmSlOToOBSoXDp45PgQ 5 1 141 466 421.1kb 421.1kb

ES index状态为yellow状态原因

索引初始化脚本中，设置的索引的分片副本数为 1 ，而单机版es，索引的分片副本无处安放，导致索引/集群状态为 yellow

处理办法

将相关索引的分片副本数改为0

注意：此管理操作需要使用es集群的管理员账号

curl -XPUT  'http://xx.xx.xx.xx:9200/${index_name}/_settings' \  -H 'Content-Type: application/json' \  -u  username:password   \ -d '{     "index" : {                "number_of_replicas": 0     } }'

验证

curl  -X GET -s   -u  username:password   http://xx.xx.xx.xx:9200/_cluster/health?pretty  {   "cluster_name" : "es7",   "status" : "green",   "timed_out" : false,   "number_of_nodes" : 1,   "number_of_data_nodes" : 1,   "active_primary_shards" : 13,   "active_shards" : 13,   "relocating_shards" : 0,   "initializing_shards" : 0,   "unassigned_shards" : 0,   "delayed_unassigned_shards" : 0,   "number_of_pending_tasks" : 0,   "number_of_in_flight_fetch" : 0,   "task_max_waiting_in_queue_millis" : 0,   "active_shards_percent_as_number" : 100.0 }

群里提问的智慧

Sat, 07 Oct 2023 03:09:19 GMT

提问之前

尝试自己解决

善于搜索：Baidu，Google，Bing，AI ，ChatGpt

查看群文件、文件说明书

询问朋友

自己不断摸索，测试，折腾

不能自己解決

想明白自己要问什么

梳理准备你的问题

怎样提问

用词准确，问题明确

描述清楚，信息充足

准确有效的信息

问题表现/内容

做过什么尝试

想要问到什么

遇到问题之前你做了什么

别问毫无意义的问题

没有人理会

没有人在

注意事项

提问之前做好冷场的准备

也许这个问题网上随便搜搜就知道了

也许别人在忙

也许没人遇到过这种问题

也许...

谦虚，别人没有义务为你解答问题

没有一定的自学能力，遇到问题只会伸手的不适合玩这个

MacBook企业监管机屏蔽弹窗指南Sonoma

Sat, 07 Oct 2023 01:27:00 GMT

1关闭电脑SIP

关机，然后长按电源键直至开机进入恢复模式，找到终端，

键入csrutil disable 回车执行。

等待执行结果，直到出现 System Integrity Protection is off.证明 SIP 已关闭

2屏蔽指令

重新开机，打开终端，依次键入

sudo rm /var/db/ConfigurationProfiles/Settings/.cloudConfigHasActivationRecoro sudo rm /var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound sudo touch /var/db/ConfigurationProfiles/Settings/.cloudConfigProfilelnstalled sudo touch /var/db/ConfigurationProfiles/Settings/.cloudConfigRecordNotFound

3.成功

CentOS 配置ssh和sftp服务分离

Fri, 01 Sep 2023 06:50:00 GMT

实现原理

创建两个“sshd”进程，一个作为ssh服务的deamon，一个作为sftp服务的deamon。
ssh服务和sftp服务分离之前：

系统内开启ssh服务和sftp服务都是通过/usr/sbin/sshd这个后台程序监听22端口，而sftp服务作为一个子服务，是通过/etc/ssh/sshd_config配置文件中的Subsystem实现的，如果没有配置Subsystem参数，则系统是不能通过sftp访问的。

操作步骤

创建两个deamon

ln -sf /usr/sbin/sshd /usr/sbin/sftpd

要实现ssh和sftp分离，分别监听不同的端口，可以通过创建两个‘/usr/sbin/sshd’后台程序，一个监听端口(ssh)，一个监听10022端口(sftp)，为了区分ssh和sftp服务的后台程序，这里将ssh服务的后台程序保持为/usr/sbin/sshd，而将sftp服务的后台程序改为/usr/sbin/sftpd。/usr/sbin/sftpd是/usr/sbin/sshd的一个链接，其内容完全相同。

创建两个service

cp /usr/lib/systemd/system/sshd.service /etc/systemd/system/sftpd.service

CentOS使用systemd管理系统服务，ssh服务对应/usr/lib/systemd/system/sshd.service文件，实现sftp服务时可以将/usr/lib/systemd/system/sshd.service复制到/etc/systemd/system/sftpd.service，然后修改sftpd.service文件内容（使用修改好的sftpd.service文件即可）。

其他需要分离的文件

拷贝/etc/pam.d/目录下的sshd文件，放到同目录，命名为：sftpd。
```
cp /etc/pam.d/sshd /etc/pam.d/sftpd 
```
拷贝/etc/ssh/目录下的sshd_config文件，放到同目录，命名为：sftpd_config。
```
cp /etc/ssh/sshd_config /etc/ssh/sftpd_config 
```

对service和rcsftpd进行软连接。

ln -sf /usr/sbin/service /usr/sbin/rcsftpd

拷贝/etc/sysconfig/目录下的sshd文件，放到同目录，命名为：sftp。
```
cp /etc/sysconfig/sshd /etc/sysconfig/sftp 
```
拷贝/var/run/目录下的sshd.pid文件，放到同目录，命名为：sftpd.pid。
```
cp /var/run/sshd.pid /var/run/sftpd.pid 
```
此时已经实现了ssh服务和sftp服务分离。但是，ssh服务和sftp服务并没有真正的分离，此时已然可以通过22号端口使用ssh服务和sftp服务。
编辑/usr/sbin/sshd的配置文件/etc/ssh/sshd_config，将Subsystem参数注释掉，然后重启sshd服务，此时通过22端口无法访问sftp服务。
```
vi /etc/ssh/sshd_config 
```
按“i”进入编辑模式，在“Subsystem”命令前加“#”，使本行变为注释。
```
# Subsystem sftp /usr/libexec/openssh/sftp-server 
```
重启sshd服务。
```
systemctl restart sshd.service 
```
查看sshd服务状态。
```
systemctl status sshd.service 
```

显示如下信息示例。

● sshd.service - OpenSSH server daemon Loaded: loaded (/usr/lib/systemd/system/sshd.service; enabled; vendor preset: enabled) Active: active (running) since Tue 2021-08-24 10:35:23 CST; 18min ago Docs: man:sshd(8) man:sshd_config(5) Main PID: 91176 (sshd) CGroup: /system.slice/sshd.service └─91176 /usr/sbin/sshd -D  Aug 24 10:35:23 dggbenv01220 systemd[1]: Starting OpenSSH server daemon... Aug 24 10:35:23 dggbenv01220 sshd[91176]: Server listening on 0.0.0.0 port 22. Aug 24 10:35:23 dggbenv01220 sshd[91176]: Server listening on :: port 22. Aug 24 10:35:23 dggbenv01220 systemd[1]: Started OpenSSH server daemon.

修改配置sftpd服务

修改/etc/systemd/system/目录下sftpd.service文件。

vim /etc/systemd/system/sftpd.service

按“i”进入编辑模式，修改以下内容：
```
Description=sftpd server daemon Type=notify EnvironmentFile=/etc/sysconfig/sftp ExecStart=/usr/sbin/sftpd -f /etc/ssh/sftpd_config 
```
编辑完成后按“Esc”退出编辑模式，输入“:wq!”保存并退出。
修改/etc/ssh/目录下的sftpd_config文件。

vim /etc/ssh/sftpd_config

按“i”进入编辑模式，找到第17行，将“Port 22”改为“Port 10022”。
1. 找到第38行，将“#Perm itRootLogin yes”改为“PermitRootLogin no”。
2. 找到第116行，将“#PidFile /var/run/sshd.pid”改为“PidFile /var/run/sftpd.pid”。
3. 找到第132行，在“Subsystem sftp /usr/libexec/openssh/sftp-server”前加“#”使本行变为注释。另起一行添加“Subsystem sftp internal-sftp”。

“10022”表示端口号，可以是任意数值。

“#”表示该行的注释，去掉“#”就是取消该行的注释，并设置参数，将“yes”改成“no”，目的是禁止root用户登录。

删除/var/run/目录下的sftpd.pid文件内容。
```
rm -rf /var/run/sftpd.pid 
```
启动sftpd服务。
```
systemctl daemon-reload systemctl start sftpd 
```
至此，sftpd服务已经配置完成并启动。
通过命令查看其状态信息。
```
systemctl status sftpd 
```

● sftpd.service - OpenSSH server daemon    Loaded: loaded (/etc/systemd/system/sftpd.service; disabled; vendor preset: disabled)    Active: active (running) since Tue 2021-08-24 16:27:55 CST; 2s ago      Docs: man:sshd(8)            man:sshd_config(5)  Main PID: 111851 (sftpd)    CGroup: /system.slice/sftpd.service            └─111851 /usr/sbin/sftpd -f /etc/ssh/sftpd_config   Aug 24 16:27:55 dggbenv01220 systemd[1]: Starting OpenSSH server daemon... Aug 24 16:27:55 dggbenv01220 sftpd[111851]: Server listening on 0.0.0.0 port 10022. Aug 24 16:27:55 dggbenv01220 sftpd[111851]: Server listening on :: port 10022. Aug 24 16:27:55 dggbenv01220 systemd[1]: Started OpenSSH server daemon.

可以看到sftpd服务已经在10022端口上启动监听服务。
用FileZilla客户端进行验证。

验证操作

使用sftp协议访问22端口

错误: FATAL ERROR: Received unexpected end-of-file from SFTP server

错误: 无法连接到服务器

使用root帐号通过sftp协议访问10022端口

错误: 认证失败。

错误: 严重错误: 无法连接到服务器

使用普通帐号通过sftp协议访问10022端口

可以连接成功，并上传下载文件。

二、CRC-8原理模2除法模2除法与算术除法类似，但每一位除的结果不影响其它位，即不向上一位借位，所以实际上就是异或。在循环冗余校验码（CRC）的计算中有应用到模2除法。

原文链接：https://support.huawei.com/enterprise/zh/doc/EDOC1100197618?section=j01y

Mysql 5.7开启binlog日志

Fri, 01 Sep 2023 06:40:00 GMT

前言

binlog是MySQL的二进制日志，并且是MySQL中最重要的日志。binlog记录了对MySQL数据库执行更改的所有操作，包括对数据库表结构的变更，对数据的变更，例如CREATE、ALTER TABLE、INSERT、UPDATE、DELETE…，但是不会记录查询语句select。需要注意的是，如果是update操作，即使是没有数据更新，也会记录在binlog日志中，binlog日志是以事件形式记录，并且还包含语句所执行的消耗时间。

查看binlog是否开启

show variables like 'log_bin';

开启binlog

修改mysql配置文件

[mysqld] log-bin=mysql-bin server_id=1

注意: serverd一定要设置，否则会导致mysql无法启动

重新启动mysql

# 停止mysql服务 service mysql stop  # 启动mysql服务 service mysql start  # 重启mysql服务 service mysql restart

扩展

应用

主从复制

master端开启binlog，master把二进制日志传递给slaves来达到master-slave数据保持一致。
数据恢复

可以通过mysqlbinlog工具解析binlog来恢复数据。

binlog日志常用命令

查看所有的binlog日志列表
```
show master logs; 
```
查看master状态，即最后一个binlog日志的编号名称，及其最后一个操作时间pos结束点值
```
show master status; 
```
flush刷新binlog日志，此刻之后会产生一个新编号的binlog日志文件
```
flush logs; 
```

bin-log日志存放地址

binlog存放在/var/lib/mysql里面的，如果是docker，则在相应的映射目录

配置存放位置、过期时间

在MySQL配置文件my.cnf或者my.ini中[mysqld]标签内修改

# 配置定时清理 expire_logs_days = 5 # 配置修改后的日志路径 log-bin=/home/logs/mysql-bin

配置每个日志文件的大小

在MySQL配置文件my.cnf或者my.ini中[mysqld]标签内修改

# binlog每个日志文件大小 max_binlog_size = 100m

binlog格式

# binlog日志格式，MySQL默认采用的是STATEMENT，建议使用MIXED binlog_format = MIXED

复制模式	优点	缺点	原理
STATEMENT模式	- 减少binlog日志量，节约IO，提高性能 - 适用于简单的SQL语句	- 某些情况会导致master-slave中的数据不一致，例如sleep()，last_insert_id()等	基于SQL语句的复制（statement-based replication），每一条会修改数据的sql语句都会记录到binlog中
ROW模式	- 任何情况都可以复制，并且不会出现特定情况下存储过程、function等调用或者触发无法被正确复制的问题	- binlog日志文件会非常大 - master上执行update语句时，所有变化都会写到binlog里面，SBR只会写一次，所以会导致频繁发生binlog的并发写问题	基于行的复制（row-based replication），不记录每条sql语句的上下文信息，仅记录哪条数据被修改了，修改成什么样。
MIXED模式	一般的复制使用STATEMENT模式保存binlog，对于STATEMENT模式无法复制的操作使用ROW模式保存binlog，MySQL会根据执行的SQL语句选择日志保存方式	- 实现较为复杂	两种模式的混合使用

docker 部署的gogs创建管理员账户

Tue, 25 Jul 2023 05:50:00 GMT

查找gogs应用容器

# docker  ps  8f0cd2b10c84   gogs/gogs:latest    "/app/gogs/docker/st…"    3000/tcp, 0.0.0.0:45->22/tcp, 0.0.0.0:370->3001/tcp                          gogs-gogs

进入gogs容器

docker exec -it 8f0cd2b10c84  bash

切换git用户

su - git

进入执行目录

/app/gogs

创建管理员用户

 ./gogs admin create-user --name=root --password=123456 --email=email@maruifu.cn --admin=true

excel 无法编辑单元格，忘记保护密码，怎么撤销保护密码

Tue, 18 Jul 2023 02:01:00 GMT

今天收到一份excel文件，只能编辑有限的几个单元格，其他单元格都是使用公式联动的，就想着看下公式是什么，但是那些单元格都是无法用鼠标点击进行编辑，最后发现是因为设置了excel文件的发行人使用了密码保护功能。折腾了一番终于把密码去掉了，记录一下。

一、保护工作表

步骤：点击【审阅】-【保护工作表】-勾选【选定锁定单元格】和【选定未锁定的单元格】-【确定】。随后设置单元格格式、插入行、删除行等都无法进行操作。

二、解除工作表密码保护

1、查看代码

步骤：右键【sheet1】-【查看代码】-打开代码窗口。

2、插入代码

代码：

Sub DeletePW()  ActiveSheet.Protect DrawingObjects:=True, Contents:=True, AllowFiltering:=True  ActiveSheet.Protect DrawingObjects:=False, Contents:=True, AllowFiltering:=True  ActiveSheet.Protect DrawingObjects:=True, Contents:=True, AllowFiltering:=True  ActiveSheet.Protect DrawingObjects:=False, Contents:=True, AllowFiltering:=True  ActiveSheet.Unprotect  End Sub

步骤：粘贴代码，点击【运行】即可。

至此，问题得到解决。

转载于EchoCoder

jenkins部署前后端分离项目

Wed, 14 Jun 2023 01:56:00 GMT

Git安装

yum install git

Jdk安装

官网下载 JDK8：http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

安装 # 创建目录 mkdir /usr/local/java # 拷贝安装包到指定目录 cp jdk-8u301-linux-x64.tar.gz   /usr/local/java/ # 进入java安装目录 cd /usr/local/java/ # 解压jdk安装包 tar -zxvf jdk-8u301-linux-x64.tar.gz # 删除安装包（可选） rm -rf jdk-8u301-linux-x64.tar.gz  配置环境变量 # 编辑配置文件 vim /etc/profile # 最下面添加如下内容： export JAVA_HOME=/usr/local/java/jdk1.8.0_301 export CLASSPATH=$JAVA_HOME/lib/ export PATH=$PATH:$JAVA_HOME/bin   # 然后ESC :wq保存退出 :wq # 配置生效 source /etc/profile # 检查安装情况 java -version

Node安装

node下载地址： http://nodejs.cn/download/current/ https://nodejs.org/dist/

下载离线包，上传到/usr/local/node

创建软链：

# 解压 tar -zxvf node-v16.17.1-linux-x64.tar.gz # 重命名 mv node-v16.17.1-linux-x64 node-v16.17.1 ln -s /usr/local/node/node-v16.17.1/bin/node /usr/local/bin ln -s /usr/local/node/node-v16.17.1/bin/npm /usr/local/bin

Maven 安装

下载

wget  https://dlcdn.apache.org/maven/maven-3/3.6.1/binaries/apache-maven-3.6.1-bin.tar.gz

解压

tar -xzvf apache-maven-3.6.1-bin.tar.gz

配置系统maven环境

编辑系统环境文件profile，该文件类似于windows里的环境变量。

vi /etc/profile

注意，配置的变量，请指向自己解压的maven路径：

export MAVEN_HOME=/usr/local/maven/apache-maven-3.6.1 export PATH=$MAVEN_HOME/bin:$PATH

:wq，退出保存，然后重新加载一下配置：

source /etc/profile

查看maven版本，测试配置生效：

mvn -v

配置镜像加速+指定仓库地址

配置jar包下载路径，路径指向自己的

<localRepository>/usr/local/maven/repository</localRepository>

配置阿里镜像加速，默认是从中央仓库拉取。

<mirrors>  <mirror>    <id>alimaven</id>    <name>aliyun maven</name>    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>    <mirrorOf>central</mirrorOf>          </mirror> </mirrors>

:wq，退出保存。

jenkins安装

下载地址 https://mirrors.jenkins.io/war-stable/

下载

wget https://sg.mirror.servanamanaged.com/jenkins/war/2.346/jenkins.war

安装

nohup java  -jar jenkins.war --httpPort=6888  2>&1 &

插件

# maven项目插件 Maven Integration   # 备份插件 ThinBackup    # 可以在构建时进行分支选择 Git Parameter Plug-In # NODE前端发布 NODEJS # 角色配置 Role-based Authorization Strategy # 开机自启 Startup # 日格式化 Date Paramete

配置

Maven 配置

/usr/local/maven/apache-maven-3.6.1/conf/settings.xml

JDK

#jdk8     /usr/local/java/jdk1.8.0_371

Maven

#Name   maven3.6

# MAVEN_HOME    /usr/local/maven/apache-maven-3.6.1

NodeJs

后端部署配置

General

后端-XX系统-演示环境

源码管理

http://192.168.1.7:1234/mrfr/backend/mrfResource.git

构建环境

pom.xml clean package  -Dmaven.test.skip=true

Post Steps

#!/bin/bash  #环境 ENV=test  #源jar路径，打包完成之后，target目录下的jar包名称 JAR_NAME=mrf-admin  #target打包生成jar包的目录 # 以具体的打包位置为准，可以先构建一次项目，通过日志查看打包的目录 JAR_PATH=/home/maruifu/.jenkins/workspace/后端-XX系统-测试环境/mrf-admin/target       #打包完成之后，把jar包移动到运行jar包的目录 JAR_WORK_PATH=/usr/local/backend/mrfr/test   echo "查询进程id-->${JAR_NAME}_${ENV}" PID=`ps -ef |grep java|grep "${JAR_NAME}_${ENV}" |grep -v grep|awk '{print $2}'`  if [ x"$PID" != x"" ]; then   kill -TERM $PID   sleep 1         echo "等待1秒钟"          sleep 1         echo "等待2秒钟"    echo "${JAR_NAME}_${ENV} 退出."  else   echo "${JAR_NAME}_${ENV} 已经停止了"  fi echo "正在结束进程完成"  echo "正在复制jar包到执行目录" cp $JAR_PATH/$JAR_NAME.jar $JAR_WORK_PATH/${JAR_NAME}_${ENV}.jar cd $JAR_WORK_PATH  echo "正在修改文件权限" chmod 755 ${JAR_NAME}_${ENV}.jar   echo "正在启动${JAR_NAME}" BUILD_ID=dontKillMe nohup java -jar ${JAR_NAME}_${ENV}.jar   --spring.profiles.active=${ENV}  2>&1 & echo "${JAR_NAME}启动成功"

前端部署配置

General

前端-XX系统-前台-测试环境

源码管理

http://192.168.1.7:1234/mrfr/frontend/backstage.git

构建环境

Provide Node & npm bin/ folder to PATH

Post Steps

#!/bin/bash  #环境 ENV=test   #打包生成dist的目录 DIST_PATH=/home/maruifu/.jenkins/workspace/前端-XX系统-前台-测试环境   #打包完成之后，把DIST移动到Nginx执行的目录 UI_WORK_PATH=/usr/local/frontend/mrfr-ui/   echo  "查询node版本！" node -v && echo  "正在安装依赖！" npm install && echo  "正在删除上次打包的文件" rm -rf  $(ls -d *dist* | tail -1) echo  "安装构建打包！" npm run build:${ENV}   DIST_NAME=$(ls -d *dist* | tail -1) echo  "获取打包文件夹名:${DIST_NAME}"  echo  "正在复制文件到执行目录"  cp -r  ${DIST_PATH}/${DIST_NAME} ${UI_WORK_PATH} echo  "正在删除${UI_WORK_PATH}dist"  rm -rf  ${UI_WORK_PATH}dist  cd ${UI_WORK_PATH} mv  ${DIST_NAME}    dist echo  "部署完成了！" echo  "部署完成了！" echo  "部署完成了！"

权限配置

角色设置

用户设置

多种备份方式

拷贝文件备份

手动备份jekins_home目录的以下文件：

config.xml hudson*.xml 插件名*.xml job目录 user目录

备份与还原-ThinBackup

备份

1、以管理员身份登录Jenkins，点击系统管理 – ThinBackup

2、点击Settings ，设置备份文件的保存目录，同时可以设置备份的一些特殊属性

3、点击 Backup Now，即可完成备份

还原

1、把ThinBackup备份的文件(一般是文件夹或zip)，拷贝到 settings中设置的备份目录下或者设置 Backup directory 为备份文件目录

2、点击 ThinBackup – Restore ，就还原成功了。

应用回滚

创建选择参数

设置GIT地址

添加脚本-应用备份

case $status in   deploy)     echo "创建当前构建版本备份目录"     bak_dir="${WORKSPACE}/bak/${BUILD_NUMBER}"     if [ -d $bak_dir ]     then       echo "目录已存在"     else       mkdir -p $bak_dir     fi     echo "开始构建..."     mvn clean package -Dmaven.test.skip=true     echo "构建结束"     cp -f ${WORKSPACE}/maruifu-admin/target/*.jar $bak_dir     echo "当前版本已备份完成!"     ;;   rollback)     echo "创建当前构建版本备份目录"     bak_dir="${WORKSPACE}/bak/${BUILD_NUMBER}"     if [ -d $bak_dir ]     then       echo "目录已存在"     else       mkdir -p $bak_dir     fi     echo "开始回滚..."     echo "回滚的版本号是: ${version}"     cp -f ${WORKSPACE}/bak/$version/*.jar $bak_dir     ;;   *)     exit     ;; esac

添加脚本-删除多余备份

# 保留最新的5个 KeepVersionNum=5 # 备份所有版本所在目录 FileDir=${WORKSPACE}/bak/ cd $FileDir # 备份所在目录中有多少目录 FileNum=`ls -l |grep "^d" | wc -l`  echo "开始检查构建旧版本个数，最多保留 $KeepVersionNum 个最新版本" echo "当前保留版本数量: $FileNum" # 当前备份版本的数量 > 想要保留的版本数量，则执行以下循环 while (( $FileNum > $KeepVersionNum )) do   # 将当前目录下的所有目录以时间正序排序，head -1显示第一个   OldFile=$(ls -rt | head -1)   echo "$(date "+%Y:%m:%d %H:%M:%S") 删除多余旧版本: ${OldFile}"   # 删除多出来的旧版本   rm -rf $FileDir/$OldFile   let "FileNum--" done  echo "正在部署的版号是：${BUILD_NUMBER}"

添加脚本-应用启动

 # 备份所有版本所在目录 FileDir=${WORKSPACE}/bak cd $FileDir # 将当前目录下的所有目录以时间正序排序，head -1显示第一个 lastFile=$(ls -t | head -1) cp -f $FileDir/$lastFile/*.jar /app/backend/dms/test-web  cd /app/backend/dms/test-web  /app/backend/dms/test-web/dms.sh restart  echo "部署成功"

Alma Linux mysql安装问题

Fri, 09 Jun 2023 01:31:00 GMT

未找到匹配的参数: mysql-community-server

[root@localhost ~]# yum -y install mysql-community-server     未找到匹配的参数: mysql-community-server 错误：没有任何匹配: mysql-community-server  #解决办法 更新源,后再次安装  rpm -Uvh  https://dev.mysql.com/get/mysql57-community-release-el7-9.noarch.rpm

没有东西可提供 libtinfo.so.5()(64bit)

 [root@localhost ~]# yum install -y mysql-community-server  # 报错：  - 没有东西可提供 libncurses.so.5()(64bit)（mysql-community-client-5.7.9-1.el7.x86_64 需要）   - 没有东西可提供 libtinfo.so.5()(64bit)（mysql-community-client-5.7.9-1.el7.x86_64 需要） (尝试添加 '--skip-broken' 来跳过无法安装的软件包 或 '--nobest' 来不只使用软件包的最佳候选)  # 解决办法：安装依赖库  wget https://dl.rockylinux.org/pub/rocky/9/devel/x86_64/os/Packages/n/ncurses-compat-libs-6.2-8.20210508.el9.x86_64.rpm  rpm -ivh ncurses-compat-libs-6.2-8.20210508.el9.x86_64.rpm

没有任何匹配: mysql-community-server

[root@localhost ~]# yum install -y mysql-community-server  # 报错：  所有的匹配结果均已经被参数的模块化过滤条件筛除: mysql-community-server 错误：没有任何匹配: mysql-community-server  #解决办法：关掉mysql模块，再次执行 yum module disable mysql

错误的公钥？错误：GPG 检查失败

[root@localhost ~]# yum install -y mysql-community-server  # 报错：  下载的软件包保存在缓存中，直到下次成功执行事务。 您可以通过执行 'yum clean packages' 删除软件包缓存。 错误：GPG 检查失败   #解决办法： 删除后安装包后 更新key，然后再次安装 [root@localhost ~]# yum clean packages [root@localhost ~]# rpm --import https://repo.mysql.com/RPM-GPG-KEY-mysql-2022 [root@localhost ~]# yum install -y mysql-community-server

mariadb 冲突

[root@localhost ~]# yum install -y mysql-community-server   # 报错：  错误：事物测试失败：   file /etc/my.cnf from install of mysql-community-server-5.7.42-1.el7.x86_64 conflicts with file from package mariadb-connector-c-config-3.2.6-1.el9_0.noarch  # 原因：  从错误信息中看，是冲突了，因为错误信息中有写 `conflicts with file from package`，但是这是一个全新的Linux，正常没有安装过MySQL也没有安装过[Mariadb]，所以猜测是该Linux机器内嵌集成了该Mariadb包，**造成冲突**。  # 解决办法 查看本机被内嵌的Mariadb，使用`rpm -e --nodeps package`将内嵌集成的Mariadb卸载掉   # 查看本机被内嵌的Mariadb [root@localhost ~]# rpm -qa | grep mariadb # 卸载Mariadb [root@localhost ~]# rpm -e --nodeps mariadb-connector-c-config-3.2.6-1.el9_0.noarch [root@localhost ~]# rpm -e --nodeps mariadb-connector-c-3.2.6-1.el9_0.x86_64 [root@localhost ~]# yum clean packages [root@localhost ~]# yum install -y mysql-community-server

使用AI配合Typora智能画图

Thu, 25 May 2023 03:25:00 GMT

一、流程图

```mermaid

竖向（TD 表示从上到下）

graph TD;     A-->B;     A-->C;     B-->D;     D-->E;     D-->F;

横向（LR 表示从左到右）

graph LR;   A[方形]-->B(圆角)   B-->C{条件a}   C-->|a=1|D[结果1]   C-->|a=2|E[结果2]

标准（竖向）

```flow

st=>start: 开始框   op=>operation: 处理框   cond=>condition: 判断框(是或否?)   sub1=>subroutine: 子流程   io=>inputoutput: 输入输出框   e=>end: 结束框   st->op->cond   cond(yes)->io->e   cond(no)->sub1(right)->op

标准（横向）

st=>start: 开始框   op=>operation: 处理框   cond=>condition: 判断框(是或否?)   sub1=>subroutine: 子流程   io=>inputoutput: 输入输出框   e=>end: 结束框   st(right)->op(right)->cond   cond(yes)->io(bottom)->e   cond(no)->sub1(right)->op

二、UML时序图

先输入```mermaid (或）sequence

->> 代表实线箭头，–>> 则代表虚线箭头

-> 直线，–>虚线

使用sequenceDiagram 则不使用``sequence

简单

客户->>银行柜台: 我要存钱   银行柜台->>后台: 改一下这个账户数字哦   后台->>银行柜台: 账户的数字改完了，明天起息   银行柜台->>客户: 好了，给你回单 ，下一位

对象A->对象B:对象B你好吗（请求）   Note right of 对象B:对象B的描述（提示）   Note left of 对象A:提示   对象B-->>对象A:我很好（响应）   对象A->>对象B:你确定？

复杂

sequenceDiagram     title:标题：复杂使用     对象A->>对象B:对象B你好吗（请求）     Note right of 对象B:对象B的描述（提示）     Note left of 对象A:提示     对象B-->>对象A:我很好（响应）     对象B->>对象C:你好吗？     对象C-->>对象A: B找我了     对象A->>对象B:你确定？     note over 对象C,对象B:朋友     participant D     note right of D:没人陪我

sequenceDiagram   participant A   participant B   participant C   A->>C:hello   loop health    C->>C:no    end   Note right of C:you should eat<br/> doctor   B-->>A:nice   C->>B:how are you?   B-->>C:great

sequenceDiagram   participant A   participant B   participant C   participant D   title:"练习时序图"   A->>B:request   B->>B:verify sign   B->>C:123   C-->>B:321   B->>C:456   C->>C:code   C->>D:789   D-->>B:987   alt yes   Note right of B:yes的结果   else no   B-->>D:login   D-->>B:login success   end   B->>B:加密   B-->>A:return

sequenceDiagram   title:时序图例子   Alice->>Alice:自言自语   Alice-->>John:hello john,   %% over 可以用于单独一个角色上，也可以用于相邻的两个角色间：   note over Alice,John:friend      %% loop 后跟循环体说明文字   loop healthcheck    John-->>John:Fight agaist hypochondra   end      note right of John: Rational      John-->>Alice:Great!   John->>Bob:How about you?      %% 控制焦点：用来表示时序图中对象执行某个操作的一段时间   %% activate 角色名：表示激活控制焦点   activate Bob   Bob-->>John:Jolly good!   %% deactivate 角色名 表示控制焦点结束     deactivate Bob          Alice->>+Bob: Hello Bob, how are you?          rect rgb(175, 255, 212)     alt is sick     Bob-->>Alice: Not so good :(     else is well     Bob-->>Alice: Feeling fresh like a daisy     end     opt Extra response     Bob-->>Alice: Thanks for asking     end     end          loop communicating         Alice->>+John: asking some questions         John-->>-Alice: answer      end          par Alice to John       Alice->>John: Bye     and Alice to Bob       Alice->>Bob: Bye     end   Alice-xJohn: 这是一个异步调用     Alice--xBob: 这是一个异步调用

标准

%% 时序图例子,-> 直线，-->虚线，->>实线箭头   sequenceDiagram     participant 张三     participant 李四     张三->王五: 王五你好吗？     loop 健康检查         王五->王五: 与疾病战斗     end     Note right of 王五: 合理 食物 <br/>看医生...     李四-->>张三: 很好!     王五->李四: 你怎么样?     李四-->王五: 很好!A

三、甘特图

%% 语法示例         gantt         dateFormat  YYYY-MM-DD         title 软件开发甘特图         section 设计         需求                      :done,    des1, 2014-01-06,2014-01-08         原型                      :active,  des2, 2014-01-09, 3d         UI设计                     :         des3, after des2, 5d     未来任务                     :         des4, after des3, 5d         section 开发         学习准备理解需求                      :crit, done, 2014-01-06,24h         设计框架                             :crit, done, after des2, 2d         开发                                 :crit, active, 3d         未来任务                              :crit, 5d         耍                                   :2d           section 测试         功能测试                              :active, a1, after des3, 3d         压力测试                               :after a1  , 20h         测试报告                               : 48h

四、类图

语法解释：<|-- 表示继承，+ 表示 public，- 表示 private，学过 Java 的应该都知道。

classDiagram       Animal <|-- Duck       Animal <|-- Fish       Animal <|-- Zebra       Animal : +int age       Animal : +String gender       Animal: +isMammal()       Animal: +mate()       class Duck{           +String beakColor           +swim()           +quack()       }       class Fish{           -int sizeInFeet           -canEat()       }       class Zebra{           +bool is_wild           +run()       }

五、状态图

stateDiagram     [*] --> s1     s1 --> [*]

六、饼图

pie     title Key elements in Product X     "Calcium" : 42.96     "Potassium" : 50.05     "Magnesium" : 10.01     "Iron" :  5

如何使内网ip能够实现HTTPS访问

Tue, 18 Apr 2023 09:27:18 GMT

　在公司内部网络研发过程中，是使用的内部服务器进行发布，因此访问的ip也是内部的ip。这时候如果想对应用采用https访问的话，就需要配置对应的证书，但是市面上的证书需要使用到域名，并且基本都是基于互联网进行的认证，这种场景，在实际内网环境下，就变得难受，既不方便切换https后的调试，也不方便验证是否https配置都能成功，基于上述的情况，想到在内部服务器上生成证书，并且证书的认证地址也指向到ip，经过查找相关资料，遇到同样问题的还不少，现给出经过实际验证可行的方法。

介绍

mkcert是一个使用go语言编写的生成本地自签证书的小程序，具有跨平台，使用简单，支持多域名，自动信任CA等一系列方便的特性可供本地开发时快速创建https环境使用。

下载

其最新版本地址如下：https://github.com/FiloSottile/mkcert/releases/latest

根据内部服务器的操作系统类型下载对应的windows/Linux/arm版本即可,我这里是x86的。

wget https://github.com/FiloSottile/mkcert/releases/download/v1.4.4/mkcert-v1.4.4-linux-amd64

安装

　# 赋予权限 　chmod +x mkcert-v1.4.4-linux-amd64 　# 将mkcert文件移动到bin目录下 　sudo cp mkcert-v1.4.4-linux-amd64 /usr/local/bin/mkcert 　# 安装证书 　mkcert -install

生成证书

 # 得到证书的根目录，将该目录下的rootCA.pem文件下载，将生成的证书下载到需要访问该ip的pc机上备用 　mkcert -CAROOT 　# 将可信ip写入，并生成对应的ssl证书,执行中可能会要求输入密码，需要记住该密码，后续配置https时会用到 　mkcert localhost 127.0.0.1 ::1 192.168.1.99

Nginx证书

# nginx部署需要crt和key文件，因此也需要通过mkcert生成的文件来进行转换 openssl x509 -in localhost+3.pem -out localhost+3.crt openssl rsa -in localhost+3-key.pem -out localhost+3.key   # 将生成的这两个文件，复制到nginx的conf目录下，并配置nginx.conf  #请填写证书文件的相对路径或绝对路径 ssl_certificate conf.d/maruifu_cn/ssl/localhost+3.crt; #请填写私钥文件的相对路径或绝对路径 ssl_certificate_key conf.d/maruifu_cn/ssl/localhost+3.key;

jquery操作select（取值，设置选中）

Thu, 06 Apr 2023 07:31:00 GMT

基础取值问题

例如<select class="selector"></select>

# 设置value为pxx的项选中 $(".selector").val("pxx");  # 设置text为pxx的项选中 $(".selector").find("option:contains('pxx')").attr("selected",true);

注意：$(".selector").find("option[text='pxx']").attr("selected",true);这种写法是错误的， input支持这种获取属性值的写法：input[text='pxx']，select中需要option:contains('pxx')这样获取。

这里有一个中括号的用法，中括号里的等号的前面是属性名称，不用加引号。很多时候，中括号的运用可以使得逻辑变得很简单。

# 获取当前选中项的value $(".selector").val();  #获取当前选中项的text $(".selector").find("option:selected").text();

select的级联

第二个select的值随着第一个select选中的值变化。这在jquery中是非常简单的。

如：$(".selector1").change(function(){    // 先清空第二个    $(".selector2").empty();    // 实际的应用中，这里的option一般都是用循环生成多个了    var option = $("<option>").val(1).text("pxx");    $(".selector2").append(option); });

获取Select选择的Text和Value

 # 为Select添加事件，当选择其中一项时触发  $("#select_id").change(function(){//code...});    # 获取Select选择的Text  var checkText=$("#select_id").find("option:selected").text();   #  获取Select选择的Value  var checkValue=$("#select_id").val();   # 获取Select选择的索引值  var checkIndex=$("#select_id ").get(0).selectedIndex;   # 获取Select最大的索引值  var maxIndex=$("#select_id option:last").attr("index");

设置Select选择的 Text和Value

# 设置Select索引值为1的项选中 $("#select_id ").get(0).selectedIndex=1;  # 设置Select的Value值为4的项选中 $("#select_id ").val(4); # 设置Select的Text值为jQuery的项选中 $("#select_id option[text='jQuery']").attr("selected", true);

添加/删除Select的Option项

# 为Select追加一个Option(下拉项) $("#select_id").append("<option value='Value'>Text</option>"); #为Select插入一个Option(第一个位置) $("#select_id").prepend("<option value='0'>请选择</option>");  #删除Select中索引值最大Option(最后一个)  $("#select_id option:last").remove();  #删除Select中索引值为0的Option(第一个) $("#select_id option[index='0']").remove();  #删除Select中Value='3'的Option $("#select_id option[value='3']").remove();  #删除Select中Text='4'的Option $("#select_id option[text='4']").remove();

radio取值，checkbox取值，select取值，radio选中，checkbox选中，select选中，及其相关

#获取一组radio被选中项的值  var item = $('input[name=items][checked]').val();   #获取select被选中项的文本  var item = $("select[name=items] option[selected]").text();  #select下拉框的第二个元素为当前选中值  $('#select_id')[0].selectedIndex = 1;   # radio单选组的第二个元素为当前选中值  $('input[name=items]').get(1).checked = true;

获取值

#文本框，文本区域 $("#txt").attr("value")；   #多选框 checkbox $("#checkbox_id").attr("value")；   #单选组radio $("input[type=radio][checked]").val();   #下拉框select $('#sel').val();

控制表单元素

# 文本框，文本区域  # 清空内容  $("#txt").attr("value",''); # 填充内容  $("#txt").attr("value",'11');  # 多选框checkbox # 不打勾  $("#chk1").attr("checked",''); # 打勾  $("#chk2").attr("checked",true); # 判断是否已经打勾  if($("#chk1").attr('checked')==undefined)  # 单选组 radio # 设置value=2的项目为当前选中项  $("input[type=radio]").attr("checked",'2');  # 下拉框 select：   # 设置value=-sel3的项目为当前选中项  $("#sel").attr("value",'-sel3'); # //添加下拉框的option  $("<option value='1'>1111</option><option value='2'>2222</option>").appendTo("#sel") # 清空下拉框 $("#sel").empty()；

前端项目运行常见问题

Tue, 04 Apr 2023 01:14:00 GMT

npm install时 node-sass npm ERR command failed问题解决

查找对应node版本

可能是node.js的版本和node-sass的版本不合,下一个符合node-sass版本的node.js

查看需要的node-sass的版本在package.json文件中找到node-sass": "^版本号"，记下版本号

https://nodejs.org/zh-cn/download/releases/

根据node-sass的版本找到合适的node.js版本下载

npm官网 https://www.npmjs.com/package/node-sass

NodeJS	Supported node-sass version	Node Module
Node 19	8.0+	111
Node 18	8.0+	108
Node 17	7.0+, <8.0	102
Node 16	6.0+	93
Node 15	5.0+, <7.0	88
Node 14	4.14+	83
Node 13	4.13+, <5.0	79
Node 12	4.12+, <8.0	72
Node 11	4.10+, <5.0	67
Node 10	4.9+, <6.0	64
Node 8	4.5.3+, <5.0	57
Node <8	<5.0	<57

比如说node-sass是4.9.3就找node10,node module是64的

卸掉之前装的node-sass

npm uninstall node-sass

安装指定版本的node-sass

npm install node-sass@指定的版本号

找不到node_modules/node-sass/vendor模块的解决办法

Error: ENOENT: no such file or directory, scandir ‘…/node_modules/node-sass/vendor’

这个错误的意思就是找不到node_modules/node-sass/vendor模块。

npm rebuild node-sass

npm 安装 chromedriver 失败的解决办法

切网络

No receipt for 'com.apple.pkg.CLTools_Executables' found at '/'. 解决方案

Fri, 31 Mar 2023 06:37:22 GMT

执行如下命令 /usr/sbin/pkgutil --packages | grep CLTools 如果没有返回值，说明缺少xcode相关工具包
依此执行如下命令

xcode-select --print-path # in my case /Library/Developer/CommandLineTools  # the next line deletes the path returned by the command above sudo rm -rf $(xcode-select --print-path)  # install them (again) if you don't get a default installation prompt xcode-select --install

# 重新执行步骤一的命令，得出如下结果即可解决 /usr/sbin/pkgutil --packages | grep CLTools com.apple.pkg.CLTools_Executables com.apple.pkg.CLTools_SDK_macOS110 com.apple.pkg.CLTools_SDK_macOS1015 com.apple.pkg.CLTools_macOS_SDK

ESXI安装群晖NAS918

Sun, 19 Feb 2023 14:42:00 GMT

创建虚拟机

选择名称和操作系统

选择储存

自定义配置

CPU和内存根据自己配置选择,只留一个网络适配器其余都删除

注意网络适配器类型选择E1000e，mac地址选自动

配置虚拟机

选中刚才添加虚拟机->操作->编辑配置

添加其他设备

添加硬盘

选中自己命名虚拟机的文件夹然后上载

分别上载两个文件，但是只会显示一个，然后选择。

添加新标准硬盘

然后根据自己配置选择硬盘大小

虚拟机选项

取消勾选是否为此虚拟机启用UEFI安全引导，不取消会启动不了，最后保存！

启动电源

启动后选择第二项SATA启动否则后面会格式化失败！

安装群晖

使用synology-assistant 工具进行搜索

浏览器输入搜索到的IP地址进行安装

选择安装的镜像

安装成功

如果安装失败,请断网后重试！

安装VMware Tools

套件中心->设置->套件来源->新增矿神来源

https://spk7.imnks.com/

社群搜索vmware 安装VMware Tools

安装成功后esxi可正常显示主机名称IP地址及其配置信息

如果出现还原情况，安装时切记断网操作是因为现在版本的群晖系统存在联网检测

VMware-ESXI-6.7修改静态IP地址和主机名称以及许可证

Sun, 19 Feb 2023 07:47:00 GMT

启用Shell

首先登陆网页控制台，在主界面点击“主机”–>“服务”–>“启用安全shell”

连接esxi主机

用shell工具连接esxi主机，在命令行输入“dcui”，就会出现显示器的控制台，由于没有显示器，所以就用这种方式改比较方便，如果有显示器，直接在显示器输出的界面上改就行，我这里由于是命令行，所以是黑白界面，显示器上会显示黄黑界面

设置ESXI

按f2进入以下界面，输入用户名和密码回车

修改静态IP和主机名

选择“configure management network”回车

选择“ipv4 configuration”回车，选择set那一行，空格是选中，把ipv4地址改成自己想要的地址（1-255之间都可以），网段一定要和自己的一样，不然下次你就连接不上了，改完之后回车确定。

在选择“dns configuration”回车，把dns服务器指定一下，我这里用的“114.114.114.114”，备用的是“8.8.8.8”，改完也是回车确定

然后都修改好之后，按ESC键退出，会提示你是否重启网络立即生效，按“Y”键就可以立即生效，然后你现在的命令行就会没有反应，用你修改的ip新建一个重新连接即可。

许可证

# 适用版本：VMware vSphere 6 Enterprise Plus # 激活密钥 0A65P-00HD0-3Z5M1-M097M-22P7H

ES -IK分词器分词、停用词基于API实现热更新

Sun, 12 Feb 2023 14:43:00 GMT

官方介绍

在ik的github有关于热更新的介绍

字典配置

IKAnalyzer.cfg.xml` can be located at `{conf}/analysis-ik/config/IKAnalyzer.cfg.xml` or `{plugins}/elasticsearch-analysis-ik-*/config/IKAnalyzer.cfg.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd"> <properties>  <comment>IK Analyzer 扩展配置</comment>  <!--用户可以在这里配置自己的扩展字典 -->  <entry key="ext_dict">custom/mydict.dic;custom/single_word_low_freq.dic</entry>   <!--用户可以在这里配置自己的扩展停止词字典-->  <entry key="ext_stopwords">custom/ext_stopword.dic</entry>   <!--用户可以在这里配置远程扩展字典 -->  <entry key="remote_ext_dict">location</entry>   <!--用户可以在这里配置远程扩展停止词字典-->  <entry key="remote_ext_stopwords">http://xxx.com/xxx.dic</entry> </properties>

热更新 IK 分词使用方法

目前该插件支持热更新 IK 分词，通过上文在 IK 配置文件中提到的如下配置

  <!--用户可以在这里配置远程扩展字典 -->  <entry key="remote_ext_dict">location</entry>   <!--用户可以在这里配置远程扩展停止词字典-->  <entry key="remote_ext_stopwords">location</entry>

其中 location 是指一个 url，比如 http://yoursite.com/getCustomDict，该请求只需满足以下两点即可完成分词热更新。

该 http 请求需要返回两个头部(header)，一个是 Last-Modified，一个是 ETag，这两者都是字符串类型，只要有一个发生变化，该插件就会去抓取新的分词进而更新词库。
该 http 请求返回的内容格式是一行一个分词，换行符用 \n 即可。

说明

Last-Modified是上次更新时间 ETag是实体标签（Entity Tag）的缩写，根据实体内容（文本数据）生成的一段hash字符串，可以通过它的标识数据的修改状态，当数据发生改变时，ETag也随之改变

思路

分词文件可以存放在一个文本文件中，注意文件需要时UTF-8编码格式的。放在nginx或者其他简易http server下，当文件修改时，http server会在客户端请求该文件时自动返回相应的Last-Modified和ETag。

另外可以做一个工具来从业务系统提取相关词汇，再更新到这个文件中

如何设置ETag的值

首先ETag要满足以下三个条件： 1、当文件内容改变时，ETag值跟着改变 2、计算简单，不会特别消耗CPU（因此就不能使用MD5、SHA128、SHA256等算法） 3、必须支持横向扩展，也就是在不同的服务器节点上生成的ETag是一样的

参考Nginx中ETag的生成： 由Last-Modified和content_length表示为16进制组合而成

etag = '"' + Long.toHexString(lastModified) + '-' + Long.toHexString(contentLength) + '"';

有了Last-Modified为什么还需要ETag

1、原因就是因为某些服务器如果不能精确的获取到数据的最后修改时间的话，那么就无法通过Last-Modified来判断数据是否有更新了，就会导致词库更新不及时，出现延迟的问题。

2、Last-Modified一般只能精确到秒，如果数据更新的比较频繁的话，会导致识别不到更新，当然这点在IK分词器中不存在，因为IK分词器的热更新默认是一分钟获取一次。

3、如果我在一分钟内改了文件，发现改错了，又改回来了，那么这个时间虽然修改时间变了，但是因为内容没变，我是不希望更新它的。

综上所述，我们需要一个ETag来帮助我们判断是否更新了文本内容，同时ETag还需要根据文本内容来产生。

代码

 @RequestMapping("updateHotWord")     public void hotWord1(HttpServletResponse response, @RequestParam Integer type) throws IOException {         List<String> dict = new ArrayList();         if(type == 1){             //TODO 直接读取数据库维护 热词         }else{             //TODO 直接读取数据库维护 停止词         }         String str = dict.parallelStream().collect(Collectors.joining("\n"));         Long lastModified = Instant.now().toEpochMilli();         String etag =   Long.toHexString(str.length());         response.setHeader("Last-Modified",String.valueOf(lastModified));         response.setHeader("ETag",etag);         response.setContentType("text/plain;charset=utf-8");         OutputStream out = response.getOutputStream();         out.write(str.getBytes());         out.flush();     }

配置

修改ik分词器配置文件IKAnalyzer.cfg.xml

<properties>         <comment>IK Analyzer 扩展配置</comment>         <!--用户可以在这里配置自己的扩展字典 -->         <entry key="ext_dict">custom/my_extend.dic</entry>          <!--用户可以在这里配置自己的扩展停止词字典-->         <entry key="ext_stopwords"></entry>         <!--用户可以在这里配置远程扩展字典 -->         <entry key="remote_ext_dict">http://localhost:8080/hot/updateHotWord?type=0</entry>         <!--用户可以在这里配置远程扩展停止词字典-->          <entry key="remote_ext_stopwords">http://localhost:8080/hot/updateHotWord?type=1</entry> </properties>

重启es 会发现启动时会显示读取的分词内容

idea导出非maven项目war包

Sun, 12 Feb 2023 14:22:35 GMT

选择界面

File->Project Structure->Artifacts->Add->Java Web Applicatiion:Archive

修改WAR包名称和存放路径

Name：

Output dirctory：

选择输出根信息

Available Elements 模块下全选右键点击 “Put into Output Root”。

选择输出JSP文件

打包项目成war

Build->Build Artifacts->Build

SpringBoot + MDC 实现全链路调用日志跟踪

Tue, 10 Jan 2023 07:05:00 GMT

MDC 介绍

MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 、logback及log4j2 提供的一种方便在多线程条件下记录日志的功能。MDC 可以看成是一个与当前线程绑定的哈希表，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保存进去。对于一个 Web 应用来说，通常是在请求被处理的最开始保存这些数据。

API 说明

clear() => 移除所有 MDC
get (String key) => 获取当前线程 MDC 中指定 key 的值
getContext() => 获取当前线程 MDC 的 MDC
put(String key, Object o) => 往当前线程的 MDC 中存入指定的键值对
remove(String key) => 删除当前线程 MDC 中指定的键值对

MDC 使用

Constants.TRACE_ID = "traceId"

添加拦截器

public class LogInterceptor implements HandlerInterceptor {     @Override     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {         //如果有上层调用就用上层的ID         String traceId = request.getHeader(Constants.TRACE_ID);         if (traceId == null) {             traceId = TraceIdUtil.getTraceId();         }          MDC.put(Constants.TRACE_ID, traceId);         return true;     }      @Override     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)             throws Exception {     }      @Override     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)             throws Exception {         //调用结束后删除         MDC.remove(Constants.TRACE_ID);     } }

修改日志格式

<!-- 日志输出格式 --> <property name="log.pattern" value="[TraceId:%X{traceId}] %d{HH🇲🇲ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n"/>

重点是 %X{traceId}，traceId 和 MDC 中的键名称一致。

简单使用就这么容易，但是在有些情况下 traceId 将获取不到。

常见问题

子线程日志打印丢失 traceId

   //获取traceId    Map<String, String> mdcContextMap = MDC.getCopyOfContextMap();    return  () ->{      //添加到子线程中      MDC.setContextMap(mdcContextMap);      System.out.println("你好呀！");    }

Java 生成透明图片

Fri, 30 Dec 2022 02:05:00 GMT

设置图片透明

import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.IOUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.imageio.ImageIO; import javax.imageio.stream.ImageOutputStream; import javax.swing.*; import java.awt.*; import java.awt.font.FontRenderContext; import java.awt.geom.AffineTransform; import java.awt.geom.Rectangle2D; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException;  /**  * 图片处理工具类  *  * @author maruifu  */ public class ImageUtils1 {       private static final Logger log = LoggerFactory.getLogger(ImageUtils.class);       public static void main(String[] args) {         String text = "我是小马哥";         String filePath = "/Users/maruifu/Desktop/1.png";         //生成指定文字透明图片         createImage(text,filePath,"宋体",45);         //设置指定图片透明         //setColorInRange(path,path);     }           /**      * 动态获取文字宽高      * @param text 文字      * @param font 字体      * @return      */     private static int[] getWidthAndHeight(String text, Font font) {         Rectangle2D r = font.getStringBounds(text, new FontRenderContext(                 AffineTransform.getScaleInstance(1, 1), false, false));         int unitHeight = (int) Math.floor(r.getHeight());         // 获取整个str用了font样式的宽度这里用四舍五入后+1保证宽度绝对能容纳这个字符串作为图片的宽度         int width = (int) Math.round(r.getWidth()) + 1;         // 把单个字符的高度+3保证高度绝对能容纳字符串作为图片的高度         int height = unitHeight + 3;         return new int[]{width, height};     }       /**      * 生成指定文字透明图片      * @param text 文字内容 "我是小马哥"      * @param filePath 生成地址 "/Users/maruifu/Desktop/123.png"      * @param fontName 字体名称 "宋体"      * @param fontSize 字体大小 45      */     public static void createImage(String text, String filePath,String fontName,int fontSize)  {         ImageOutputStream imageOutputStream = null;         try {             Font font = new Font(fontName, Font.BOLD,fontSize);             // 获取font的样式应用在输出内容上整个的宽高             int[] arr = getWidthAndHeight(text, font);             // 设置背景宽高             int width = arr[0];             int height = arr[1];             BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);             // 获取图形上下文对象             Graphics2D graphics = (Graphics2D)image.getGraphics();             graphics.clearRect(0, 0, width, height);             // 填充             graphics.fillRect(0, 0, width, height);             // 设定字体大小及样式             graphics.setFont(font);             // 字体颜色             graphics.setColor(Color.BLACK);             // 描绘字符串             graphics.drawString(text, 0,   font.getSize());             // 图片透明度             setTransparency(image, graphics);             File jpgFile = new File(filePath);             if(!jpgFile.exists()) {                 jpgFile.createNewFile();             }             // 创建图片输出流对象，基于文件对象             imageOutputStream = ImageIO.createImageOutputStream(jpgFile);             // 写入             ImageIO.write(image, FilenameUtils.getExtension(filePath),imageOutputStream);         } catch (IOException e) {             log.error("生成图片失败{}",e);         } finally {             // 关闭流             IOUtils.closeQuietly(imageOutputStream);         }      }      private static void setTransparency(BufferedImage image, Graphics2D graphics) {         int alpha = 0;         // 外层遍历是Y轴的像素         for (int y = image.getMinY(); y < image.getHeight(); y++) {             // 内层遍历是X轴的像素             for (int x = image.getMinX(); x < image.getWidth(); x++) {                 int rgb = image.getRGB(x, y);                 // 对当前颜色判断是否在指定区间内                 if (colorInRange(rgb)) {                     alpha = 0;                 } else {                     // 设置为不透明                     alpha = 255;                 }                 // #AARRGGBB 最前两位为透明度                 rgb = (alpha << 24) | (rgb & 0x00ffffff);                 image.setRGB(x, y, rgb);             }         }         // 绘制设置了RGB的新图片         graphics.drawImage(image, 0, 0, null);         //释放画笔         graphics.dispose();     }       /**      * 设置指定图片透明      * @param sourcePath 源文件地址      * @param targetPath 新文件地址      */     public static void setColorInRange(String sourcePath,String targetPath ) {         try {             BufferedImage image = ImageIO.read(new File(sourcePath));             // 高度和宽度             int height = image.getHeight();             int width = image.getWidth();              // 生产背景透明和内容透明的图片             ImageIcon imageIcon = new ImageIcon(image);             BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);             // 获取画笔             Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics();             // 绘制Image的图片             g2D.drawImage(imageIcon.getImage(), 0, 0, null);             // 图片透明             setTransparency(bufferedImage, g2D);             // 生成图片为PNG             ImageIO.write(bufferedImage, FilenameUtils.getExtension(sourcePath), new File(targetPath));         } catch (IOException e) {             log.error("设置图片透明失败{}",e);         }      }         /**      * 判断是背景还是内容      * @param color      * @return      */     public static boolean colorInRange(int color) {         // 色差范围0~255         int colorRange = 210;         // 获取color(RGB)中R位         int red = (color & 0xff0000) >> 16;         // 获取color(RGB)中G位         int green = (color & 0x00ff00) >> 8;         // 获取color(RGB)中B位         int blue = (color & 0x0000ff);         // 通过RGB三分量来判断当前颜色是否在指定的颜色区间内         if (red >= colorRange && green >= colorRange && blue >= colorRange) {             return true;         }         return false;     }

使用spring-boot-starter-data-elasticsearch 设置了long，为什么却变成了keyword类型

Tue, 27 Dec 2022 08:41:16 GMT

实体类定义属性book_id为Long类型，但在调用 spring-data-elasticsearch:2.5.14.RELEASE中的createMapping()方法时却被转换成了keyword`类型

查看createMapping方法，源码可以发现最终调用最下边的重载方法

 IndexOperations.createMapping();   AbstractDefaultIndexOperations.createMapping();  AbstractDefaultIndexOperations.createMapping(Class<?> clazz);  AbstractDefaultIndexOperations.buildMapping(Class<?> clazz) //构建属性映射 MappingBuilder.buildPropertyMapping(Class<?> clazz) // 具体的properties解析，为根对象非nested对象 MappingBuilder.mapEntity(XContentBuilder builder, @Nullable ElasticsearchPersistentEntity<?> entity, boolean isRootObject, String nestedObjectFieldName, boolean nestedOrObjectField, FieldType fieldType, @Nullable Field parentFieldAnnotation, @Nullable DynamicMapping dynamicMapping);           MappingBuilder.buildPropertyMapping(XContentBuilder builder, boolean isRootObject, ElasticsearchPersistentProperty property)  //判断是否是带有@Id注解或者是字段名是否是 id或者document ，如果满足条件这是主键字段 ElasticsearchPersistentProperty.isIdProperty() //如果是主键字段则类型设置为keyword MappingBuilder.applyDefaultIdFieldMapping(XContentBuilder builder, ElasticsearchPersistentProperty property)

SpringBoot Security密码加盐

Sat, 24 Dec 2022 17:41:07 GMT

修改加密和验证方法

    /**      * 生成BCryptPasswordEncoder密码      *      * @param password 密码      * @param salt 盐值      * @return 加密字符串      */     public static String encryptPassword(String password,String salt) {         BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();          return passwordEncoder.encode(password + salt);     }      /**      * 判断密码是否相同      *      * @param rawPassword     真实密码      * @param encodedPassword 加密后字符      * @param salt 盐值      * @return 结果      */     public static boolean matchesPassword(String rawPassword, String encodedPassword,String salt) {         BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();         return passwordEncoder.matches(rawPassword + salt, encodedPassword);     }

自定义 DaoAuthenticationProvider

import com.maruifu.common.core.domain.model.LoginUser; import com.maruifu.common.utils.DateUtils; import com.maruifu.common.utils.SecurityUtils; import org.springframework.security.authentication.BadCredentialsException; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.authentication.dao.DaoAuthenticationProvider; import org.springframework.security.core.AuthenticationException; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.Authentication;  /**  * 身份验证提供者  * @author maruifu  */  public class JwtAuthenticationProvider extends DaoAuthenticationProvider {       @Override     public Authentication authenticate(Authentication authentication) throws AuthenticationException {         // 可以在此处覆写整个登录认证逻辑         return super.authenticate(authentication);     }       /**      * 重写加盐后验证逻辑      * @param userDetails      * @param authentication      * @throws AuthenticationException      */     @Override     protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {         if (authentication.getCredentials() == null) {             this.logger.debug("Failed to authenticate since no credentials provided");             throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));         } else {             String presentedPassword = authentication.getCredentials().toString();             LoginUser loginUser =  (LoginUser)userDetails ;             if (!SecurityUtils.matchesPassword(presentedPassword, userDetails.getPassword(), DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,loginUser.getUser().getCreateTime()))) {                 this.logger.debug("Failed to authenticate since password does not match stored value");                 throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));             }         }     }  }

注册到ProciderManager中

 import com.maruifu.framework.security.handle.JwtAuthenticationProvider; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.ProviderManager; import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.core.userdetails.UserDetailsService;  /**  * spring security配置  *  * @author maruifu  */ @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) public class SecurityConfig1 extends WebSecurityConfigurerAdapter {     /**      * 自定义用户认证逻辑      */     @Autowired     private UserDetailsService userDetailsService;       /**      * 解决 无法直接注入 AuthenticationManager      * 重写 加盐后验证逻辑      *      * @return      */     @Bean     @Override     public AuthenticationManager authenticationManagerBean(){         JwtAuthenticationProvider provider=new JwtAuthenticationProvider();         provider.setUserDetailsService(userDetailsService);         ProviderManager manager=new ProviderManager(provider);         return manager;     }           ......省略configure方法  }

Spring中@Conditional通过条件来控制bean的注册

Fri, 23 Dec 2022 16:06:00 GMT

Spring对配置类的处理主要分为2个阶段

配置类解析阶段

会得到一批配置类的信息，和一些需要注册的bean

bean注册阶段

将配置类解析阶段得到的配置类和需要注册的bean注册到spring容器中

看一下什么是配置类,类中有下面任意注解之一的就属于配置类：

类上有@Compontent注解，@Configuration注解，@CompontentScan注解，@Import注解，@ImportResource注解以及类中有@Bean标注的方法的都是配置类

判断一个类是不是一个配置类，是否的是下面这个方法，有兴趣的可以看一下：

org.springframework.context.annotation.ConfigurationClassUtils#isConfigurationCandidate

spring中处理这2个过程会循环进行，直到完成所有配置类的解析及所有bean的注册。

Spring对配置类处理过程

源码位置

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

整个过程大致的过程

通常我们会通过new AnnotationConfigApplicationContext()传入多个配置类来启动spring容器

spring对传入的多个配置类进行解析

配置类解析阶段：这个过程就是处理配置类上面6中注解的过程，此过程中又会发现很多新的配置类，比如@Import导入的一批新的类刚好也符合配置类，而被@CompontentScan扫描到的一些类刚好也是配置类；此时会对这些新产生的配置类进行同样的过程解析

bean注册阶段：配置类解析后，会得到一批配置类和一批需要注册的bean，此时spring容器会将这批配置类作为bean注册到spring容器，同样也会将这批需要注册的bean注册到spring容器

经过上面第3个阶段之后，spring容器中会注册很多新的bean，这些新的bean中可能又有很多新的配置类

Spring从容器中将所有bean拿出来，遍历一下，会过滤得到一批未处理的新的配置类，继续交给第3步进行处理

step3到step6，这个过程会经历很多次，直到完成所有配置类的解析和bean的注册

从上面过程中可以了解到：

可以在配置类上面加上@Conditional注解，来控制是否需要解析这个配置类，配置类如果不被解析，那么这个配置上面6种注解的解析都会被跳过

可以在被注册的bean上面加上@Conditional注解，来控制这个bean是否需要注册到spring容器中

如果配置类不会被注册到容器，那么这个配置类解析所产生的所有新的配置类及所产生的所有新的bean都不会被注册到容器

一个配置类被spring处理有2个阶段：配置类解析阶段、bean注册阶段（将配置类作为bean被注册到spring容器)。

如果将Condition接口的实现类作为配置类上@Conditional中，那么这个条件会对两个阶段都有效，此时通过Condition是无法精细的控制某个阶段的，如果想控制某个阶段，比如可以让他解析，但是不能让他注册，此时就就需要用到另外一个接口了：ConfigurationCondition

ConfigurationCondition接口

相对于Condition接口多了一个getConfigurationPhase方法，用来指定条件判断的阶段，是在解析配置类的时候过滤还是在创建bean的时候过滤。

Conditional使用的3步骤

自定义一个类，实现Condition或ConfigurationCondition接口，实现matches方法

在目标对象上使用@Conditional注解，并指定value的指为自定义的Condition类型

启动spring容器加载资源，此时@Conditional就会起作用了

阻止配置类的处理

在配置类上面使用@Conditional，这个注解的value指定的Condition当有一个为false的时候，spring就会跳过处理这个配置类。

自定义一个Condition类：

import org.springframework.beans.factory.config.YamlPropertiesFactoryBean; import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.context.annotation.Configuration; import org.springframework.core.io.ClassPathResource; import org.springframework.core.type.AnnotatedTypeMetadata;   /**  * 自定义控制器  *  * @author maruifu  * @date 2022-12-07  */ @Configuration public class DslLogCondition implements Condition {      @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         // 读取配置文件application.yml中 spring.elasticsearch.dslLog: true 配置         YamlPropertiesFactoryBean y=new YamlPropertiesFactoryBean();         y.setResources(new ClassPathResource("application.yml"));         return (Boolean) y.getObject().get("spring.elasticsearch.dslLog");      } }

matches方法内部我们可以随意发挥，此处为了演示效果读取的配置文件。

来个配置类，在配置类上面使用上面这个条件，此时会让配置类失效，如下：

import org.elasticsearch.client.RestHighLevelClient; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; import org.springframework.data.elasticsearch.client.ClientConfiguration; import org.springframework.data.elasticsearch.client.RestClients;  /**  * 用于打印dsl语句  */  @Configuration public class EsConfig {      @Value("${spring.elasticsearch.rest.uris}")     private String elasticsearchHost;      @Conditional(DslLogCondition.class)     @Bean(destroyMethod = "close")     public RestHighLevelClient restClient() {         ClientConfiguration clientConfiguration = ClientConfiguration.builder().connectedTo(elasticsearchHost).build();         RestHighLevelClient client = RestClients.create(clientConfiguration).rest();          return client;      } }

1：使用了自定义的条件类

2：通过@Bean标注这restClient这个方法，如果这个配置类成功解析，会将restClient方法的返回值作为bean注册到spring容器

bean不存在的时候才注册

IService接口有两个实现类Service1和Service1，这两个类会放在2个配置类中通过@Bean的方式来注册到容器，此时我们想加个限制，只允许有一个IService类型的bean被注册到容器。

可以在@Bean标注的2个方法上面加上条件限制，当容器中不存在IService类型的bean时，才将这个方法定义的bean注册到容器，下面来看代码实现。

 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.context.annotation.ConfigurationCondition; import org.springframework.core.type.AnnotatedTypeMetadata;   import java.util.Map;   public class OnMissingBeanCondition implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         //获取bean工厂         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();         //从容器中获取IService类型bean         Map<String, IService> serviceMap = beanFactory.getBeansOfType(IService.class);         //判断serviceMap是否为空         return serviceMap.isEmpty();     }

上面matches方法中会看容器中是否存在IService类型的bean，不存在的时候返回true

来一个配置类负责注册Service1到容器

import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration;   @Configuration public class BeanConfig1 {     @Conditional(OnMissingBeanCondition.class) //@1     @Bean     public IService service1() {         return new Service1();     } }

再来一个配置类负责注册Service2到容器

 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration;   @Configuration public class BeanConfig2 {     @Conditional(OnMissingBeanCondition.class)//@1     @Bean     public IService service2() {         return new Service2();     }

来一个总的配置类，导入另外2个配置类

import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import;   @Configuration @Import({BeanConfig1.class,BeanConfig2.class})  public class MainConfig { }

根据环境选择配置类

平常我们做项目的时候，有开发环境、测试环境、线上环境，每个环境中有些信息是不一样的，比如数据库的配置信息，下面我们来模拟不同环境中使用不同的配置类来注册不同的bean

自定义一个条件的注解

import org.springframework.context.annotation.Conditional;   import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;   @Conditional(EnvCondition.class) //@1 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface EnvConditional {     //环境(测试环境、开发环境、生产环境)     enum Env { //@2         TEST, DEV, PROD     }       //环境     Env value() default Env.DEV; //@3 }

@1：注意这个注解比较特别，这个注解上面使用到了@Conditional注解，这个地方使用到了一个自定义Conditione类：EnvCondition

@2：枚举，表示环境，定义了3个环境

@3：这个参数用指定环境

上面这个注解一会我们会用在不同环境的配置类上面

下面来3个配置类让3个配置类分别在不同环境中生效，会在这些配置类上面使用上面自定义的@EnvConditional注解来做条件限定。

每个配置类中通过@Bean来定义一个名称为name的bean，一会通过输出这个bean来判断哪个配置类生效了。

下面来看3个配置类的代码

测试环境配置类

package com.javacode2018.lesson001.demo25.test2;  import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;  @Configuration @EnvConditional(EnvConditional.Env.TEST)//@1 public class TestBeanConfig {     @Bean     public String name() {         return "我是测试环境!";     } }

@1指定的测试环境

开发环境配置类

package com.javacode2018.lesson001.demo25.test2;  import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;  @Configuration @EnvConditional(EnvConditional.Env.DEV) //@1 public class DevBeanConfig {     @Bean     public String name() {         return "我是开发环境!";     } }

@1：指定的开发环境

生产环境配置类

package com.javacode2018.lesson001.demo25.test2;  import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;  @Configuration @EnvConditional(EnvConditional.Env.PROD) //@1 public class ProdBeanConfig {     @Bean     public String name() {         return "我是生产环境!";     } }

@1：指定的生产环境

下面来看一下条件类：EnvCondition

条件类会解析配置类上面@EnvConditional注解，得到环境信息。

然后和目前的环境对比，决定返回true还是false，如下：

import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.core.type.AnnotatedTypeMetadata;   public class EnvCondition implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         //当前需要使用的环境         EnvConditional.Env curEnv = EnvConditional.Env.DEV; //@1         //获取使用条件的类上的EnvCondition注解中对应的环境         EnvConditional.Env env = (EnvConditional.Env) metadata.getAllAnnotationAttributes(EnvConditional.class.getName()).get("value").get(0);         return env.equals(curEnv);     }   }

@1：这个用来指定当前使用的环境，此处假定当前使用的是开发环境，这个我们以后可以任意发挥，比如将这些放到配置文件中，此处方便演示效果。

Condition指定优先级

多个Condition按顺序执行 @Condtional中value指定多个Condtion的时候，默认情况下会按顺序执行，还是通过代码来看一下效果。

下面代码中定义了3个Condition，每个Condition的matches方法中会输出当前类名，然后在配置类上面同时使用这3个Condition

   import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; import org.springframework.core.type.AnnotatedTypeMetadata;   class Condition1 implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         System.out.println(this.getClass().getName());         return true;     } }   class Condition2 implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         System.out.println(this.getClass().getName());         return true;     } }   class Condition3 implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         System.out.println(this.getClass().getName());         return true;     } }   @Configuration @Conditional({Condition1.class, Condition2.class, Condition3.class}) public class MainConfig5 { }

指定Condition的顺序自定义的Condition可以实现PriorityOrdered接口或者继承Ordered接口，或者使用@Order注解，通过这些来指定这些Condition的优先级。

排序规则：先按PriorityOrdered排序，然后按照order的值进行排序；也就是：PriorityOrdered asc,order值 asc

下面这几个都可以指定order的值接口：org.springframework.core.Ordered，有个getOrder方法用来返回int类型的值接口：org.springframework.core.PriorityOrdered，继承了Ordered接口，所以也有getOrder方法注解：org.springframework.core.annotation.Order，有个int类型的value参数指定Order的大小

import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; import org.springframework.core.PriorityOrdered; import org.springframework.core.annotation.Order; import org.springframework.core.type.AnnotatedTypeMetadata;   @Order(1) //@1 class Condition1 implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         System.out.println(this.getClass().getName());         return true;     } }   class Condition2 implements Condition, Ordered { //@2     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         System.out.println(this.getClass().getName());         return true;     }       @Override     public int getOrder() { //@3         return 0;     } }   class Condition3 implements Condition, PriorityOrdered { //@4     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         System.out.println(this.getClass().getName());         return true;     }       @Override     public int getOrder() {         return 1000;     } }   @Configuration @Conditional({Condition1.class, Condition2.class, Condition3.class})//@5 public class MainConfig6 { }

@1：Condition1通过@Order指定顺序，值为1

@2：Condition2通过实现了Ordered接口来指定顺序，@3：getOrder方法返回1

@4：Condition3实现了PriorityOrdered接口，实现这个接口需要重写getOrder方法，返回1000

@5：Condtion顺序为1、2、3

ConfigurationCondition使用

ConfigurationCondition使用的比较少，很多地方对这个基本上也不会去介绍，Condition接口基本上可以满足99%的需求了，但是springboot中却大量用到了ConfigurationCondition这个接口。

ConfigurationCondition通过解释比较难理解，来个案例感受一下：

来一个普通的类：Service

 public class Service { }

来一个配置类，通过配置类注册上面这个Service

   import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;   @Configuration public class BeanConfig1 {     @Bean     public Service service() {         return new Service();     } }

再来一个配置类：BeanConfig2

   import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;   @Configuration public class BeanConfig2 {     @Bean     public String name() {         return "路人甲Java";     } }

来一个总的配置类

   import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import;   @Configuration @Import({BeanConfig1.class, BeanConfig2.class}) public class MainConfig7 { }

现在我们有个需求

当容器中有Service这种类型的bean的时候，BeanConfig2才生效。

很简单吧，加个Condition就行了，内部判断容器中是否有Service类型的bean，继续

来个自定义的Condition

     import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.core.type.AnnotatedTypeMetadata;   public class MyCondition1 implements Condition {     @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         //获取spring容器         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();         //判断容器中是否存在Service类型的bean         boolean existsService = !beanFactory.getBeansOfType(Service.class).isEmpty();         return existsService;     } }

上面代码很简单，判断容器中是否有IService类型的bean。

@Configuration @Conditional(MyCondition1.class) public class BeanConfig2 {     @Bean     public String name() {         return "路人甲Java";     } }

结果name永远注册不上

为什么？在文章前面我们说过，配置类的处理会依次经过2个阶段：配置类解析阶段和bean注册阶段，Condition接口类型的条件会对这两个阶段都有效，解析阶段的时候，容器中是还没有Service这个bean的，配置类中通过@Bean注解定义的bean在bean注册阶段才会被注册到spring容器，所以BeanConfig2在解析阶段去容器中是看不到Service这个bean的，所以就被拒绝了。

此时我们需要用到ConfigurationCondition了，让条件判断在bean注册阶段才起效。

自定义一个ConfigurationCondition类

   import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.context.annotation.ConditionContext; import org.springframework.context.annotation.ConfigurationCondition; import org.springframework.core.type.AnnotatedTypeMetadata;   public class MyConfigurationCondition1 implements ConfigurationCondition {     @Override     public ConfigurationPhase getConfigurationPhase() {         return ConfigurationPhase.REGISTER_BEAN; //@1     }       @Override     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {         //获取spring容器         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();         //判断容器中是否存在Service类型的bean         boolean existsService = !beanFactory.getBeansOfType(Service.class).isEmpty();         return existsService;     } }

@1：指定条件在bean注册阶段，这个条件才有效

matches方法中的内容直接复制过来，判断规则不变

修改BeanConfig2的类容

将 @Conditional(MyCondition1.class) 替换为 @Conditional(MyConfigurationCondition1.class)

此时name这个bean被注入了。

可以再试试将BeanConfig1中service方法上面的@Bean去掉，此时Service就不会被注册到容器

判断bean存不存在的问题，通常会使用ConfigurationCondition这个接口，阶段为：REGISTER_BEAN，这样可以确保条件判断是在bean注册阶段执行的。

对springboot比较熟悉的，它里面有很多@Conditionxxx这样的注解，可以去看一下这些注解，很多都实现了ConfigurationCondition接口。

Spring中这块的源码 @Conditional注解是被下面这个类处理的

org.springframework.context.annotation.ConfigurationClassPostProcessor

总结

@Conditional注解可以标注在spring需要处理的对象上（配置类、@Bean方法），相当于加了个条件判断，通过判断的结果，让spring觉得是否要继续处理被这个注解标注的对象

spring处理配置类大致有2个过程：解析配置类、注册bean，这两个过程中都可以使用@Conditional来进行控制spring是否需要处理这个过程

Condition默认会对2个过程都有效

ConfigurationCondition控制得更细一些，可以控制到具体那个阶段使用条件判断

SpringDataElasticsearch控制台打印查询语句

Thu, 15 Dec 2022 14:40:59 GMT

application.yml增加配置

# 日志配置 logging:   level:      #es日志     org.springframework.data.elasticsearch.client.WIRE : trace

增加配置类

package com.maruifu.business.config;  import org.elasticsearch.client.RestHighLevelClient; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.elasticsearch.client.ClientConfiguration; import org.springframework.data.elasticsearch.client.RestClients;  /**  * 用于打印dsl语句  */ @Configuration public class EsConfig {           @Bean(destroyMethod = "close")     public RestHighLevelClient restClient() {          ClientConfiguration clientConfiguration = ClientConfiguration.builder()                 .connectedTo("172.16.45.138:11700")                 .build();         RestHighLevelClient client = RestClients.create(clientConfiguration).rest();         return client;     } }

查看打印效果

navicat16 mac版无限重置试用期脚本

Wed, 07 Dec 2022 13:48:00 GMT

免责声明

本脚本为免费使用，本脚本只供个人学习使用，使用需严格遵守开源许可协议。严禁用于商业用途，禁止进行任何盈利活动。对一切非法使用所产生的后果，概不负责！

  #!/bin/bash  set -e  file=$(defaults read /Applications/Navicat\ Premium.app/Contents/Info.plist)  regex="CFBundleShortVersionString = \"([^\.]+)" [[ $file =~ $regex ]]  version=${BASH_REMATCH[1]}  echo "Detected Navicat Premium version $version"  case $version in     "16")         file=~/Library/Preferences/com.navicat.NavicatPremium.plist         ;;     "15")         file=~/Library/Preferences/com.prect.NavicatPremium15.plist         ;;     *)         echo "Version '$version' not handled"         exit 1        ;; esac  echo -n "Reseting trial time..."  regex="([0-9A-Z]{32}) = " [[ $(defaults read $file) =~ $regex ]]  hash=${BASH_REMATCH[1]}  if [ ! -z $hash ]; then     defaults delete $file $hash fi  regex="\.([0-9A-Z]{32})" [[ $(ls -a ~/Library/Application\ Support/PremiumSoft\ CyberTech/Navicat\ CC/Navicat\ Premium/ | grep '^\.') =~ $regex ]]  hash2=${BASH_REMATCH[1]}  if [ ! -z $hash2 ]; then     rm ~/Library/Application\ Support/PremiumSoft\ CyberTech/Navicat\ CC/Navicat\ Premium/.$hash2 fi  echo " Done"

JDK1.8 HashMap数据结构

Tue, 29 Nov 2022 15:21:00 GMT

HashMap集合简介

HashMap基于哈希表的Map接口实现，是以key-value存储形式存在，即主要用来存放键值对。HashMap的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。

JDK1.8之前的HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了节解决哈希碰撞(两个对象调用的hashCode方法计算的哈希码值一致导致计算的数组索引值相同)而存在的（“拉链法”解决冲突）。

JDK1.8之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（或者红黑树的边界值，默认为8）并且当前数组的长度大于64时，此时此索引位置上的所有数据改为使用红黑树存储。

数组里面都是key-value的实例，在JDK1.8之前叫做Entry，在JDK1.8之后叫做Node。

由于它的key、value都为null，所以在插入的时候会根据key的hash去计算一个index索引的值。计算索引的方法如下：

/**  * 根据key求index的过程  * 1,先用key求出hash值  */ static final int hash(Object key) {     int h;     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } //2,再用公式index = (n - 1) & hash（n是数组长度） int hash=hash(key); index=(n-1)&hash;

这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。

这样的话比如说put("A",王炸)，插入了key为"A"的元素，这时候通过上述公式计算出插入的位置index，若index为3则结果如下（即hash("A")=3）：

那么，HashMap中的链表又是干什么用的呢？

大家都知道数组的长度是有限的，在有限的长度里面使用哈希函数计算index的值时，很有可能插入的k值不同，但所产生的hash是相同的（也叫做哈希碰撞），这也就是哈希函数存在一定的概率性。就像上面的K值为A的元素，如果再次插入一个K值为a的元素，很有可能所产生的index值也为3，也就是即hash("a")=3；那这就形成了链表，这种解决哈希碰撞的方法也叫做拉链法。

当这个链表长度大于阈值8并且数组长度大于64则进行将链表变为红黑树。

将链表转换成红黑树前会判断，如果阈值大于8，但是数组长度小64，此时并不会将链表变为红黑树。而是选择进行数组扩容。

这样做的目的是因为数组比较小，尽量避开红黑树结构，这种情况下变为红黑树结构，反而会降低效率，因为红黑树需要进行左旋，右旋，变色这些操作来保持平衡。同事数组长度小于64时，搜索时间相对快一些。所以综上所述为了提高性能和减少搜索时间，底层在阈值大于8并且数组长度大于64时，链表才转换为红黑树。具体可以参考treeifyBin方法。

当然虽然增了红黑树作为底层数据结构，结构变得复杂了，但是阈值大于8并且数组长度大于64时，链表转换为红黑树时，效率也变得更高效。

特点

存取无序的
键和值位置都可以是null，但是键位置只能是一个null
键位置是唯一的，底层的数据结构控制键的
jdk1.8前数据结构是：链表 + 数组 jdk1.8之后是：链表 + 数组 + 红黑树
阈值(边界值) > 8 并且数组长度大于64，才将链表转换为红黑树，变为红黑树的目的是为了高效的查询。

HsahMap底层数据结构

HashMap存储数据的过程

每一个Node结点都包含键值对的key，value还有计算出来的hash值，还保存着下一个 Node 的引用 next（如果没有下一个 Node，next = null），来看看Node的源码：

static class Node<K,V> implements Map.Entry<K,V> {         final int hash;         final K key;         V value;         Node<K,V> next;         ...    }

HashMap存储数据需要用到put()方法，关于这些方法的详解，我们下节再说，这里简要说一下；

public static void main(String[] args) {         HashMap<String,Integer> hmap=new HashMap<>();         hmap.put("斑",55);         hmap.put("镜",63);         hmap.put("带土",25);         hmap.put("鼬",9);         hmap.put("佐助",43);         hmap.put("斑",88);         System.out.println(hmap);     }

当创建HashMap集合对象的时候，在jdk1.8之前，构造方法中会创建很多长度是16的Entry[] table用来存储键值对数据的。在jdk1.8之后不是在HashMap的构造方法底层创建数组了，是在第一次调用put方法时创建的数组，Node[] table用来存储键值对数据的。

比方说我们向哈希表中存储"斑"-55的数据，根据K值("斑")调用String类中重写之后的hashCode()方法计算出值（数量级很大），然后结合数组长度采用取余（(n-1)&hash）操作或者其他操作方法来计算出向Node数组中存储数据的空间的索引值。如果计算出来的索引空间没有数据，则直接将"斑"-55数据存储到数组中。跟上面的"A-王炸"数据差不多。

我们回到上方的数组图，如果此时再插入"A-蘑菇"元素，那么首先根据Key值("A")调用hashCode()方法结合数组长度计算出索引肯定也是3，此时比较后存储的"A-蘑菇"和已经存在的数据"A-王炸"的hash值是否相等，如果hash相等，此时发生hash碰撞。

那么底层会调用"A"所属类String中的equals方法比较两个key内容是否相等，若相等，则后添加的数据直接覆盖已经存在的Value，也就是"蘑菇"直接覆盖"王炸"；若不相等，继续向下和其他数据的key进行比较，如果都不相等，则规划出一个节点存储数据。

哈希碰撞相关的问题

哈希表底层采用何种算法计算hash值？还有哪些算法可以计算出hash值？

底层是采用key的hashCode方法的值结合数组长度进行无符号右移（>>>）、按位异或（^）、按位与（&）计算出索引的

还可以采用：平方取中法，取余数，伪随机数法。这三种效率都比较低。而无符号右移16位异或运算效率是最高的。

当两个对象的hashCode相等时会怎么样？

会产生哈希碰撞，若key值内容相同则替换旧的value.否则连接到链表后面，链表长度超过阈值8就转换为红黑树存储。

何时发生哈希碰撞和什么是哈希碰撞,如何解决哈希碰撞？

只要两个元素的key计算的哈希值相同就会发生哈希碰撞。jdk8前使用链表解决哈希碰撞。jdk8之后使用链表+红黑树解决哈希碰撞。

如果两个键的hashcode相同，如何存储键值对？

hashcode相同，通过equals比较内容是否相同。相同：则新的value覆盖之前的value 不相同：则将新的键值对添加到哈希表中

红黑树结构

当位于一个链表中的元素较多，即hash值相等但是内容不相等的元素较多时，通过key值依次查找的效率较低。而jdk1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度(阀值)超过 8 时且当前数组的长度 > 64时，将链表转换为红黑树，这样大大减少了查找时间。jdk8在哈希表中引入红黑树的原因只是为了查找效率更高。

JDK 1.8 以前 HashMap 的实现是数组+链表，即使哈希函数取得再好，也很难达到元素百分百均匀分布。当 HashMap 中有大量的元素都存放到同一个桶中时，这个桶下有一条长长的链表，这个时候 HashMap 就相当于一个单链表，假如单链表有 n 个元素，遍历的时间复杂度就是 O(n)，完全失去了它的优势。针对这种情况，JDK 1.8 中引入了红黑树（查找时间复杂度为 O(logn)）来优化这个问题。当链表长度很小的时候，即使遍历，速度也非常快，但是当链表长度不断变长，肯定会对查询性能有一定的影响，所以才需要转成树。

存储流程图

HashMap存放数据是用的put方法，put 方法内部调用的是 putVal() 方法，所以对 put 方法的分析也是对 putVal 方法的分析，整个过程比较复杂，流程图如下：

来看看put()源码：

public V put(K key, V value) {     //对key的hashCode()做hash，调用的是putVal方法         return putVal(hash(key), key, value, false, true);     }      final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                    boolean evict) {         Node<K,V>[] tab; Node<K,V> p; int n, i;         /*            1，tab为空则开始创建，            2，(tab = table) == null 表示将空的table赋值给tab,然后判断tab是否等于null，第一次肯定是null            3，(n = tab.length) == 0 表示没有为table分配内存            4，tab为空，执行代码 n = (tab = resize()).length; 进行扩容。并将初始化好的数组长度赋值给n.            5，执行完n = (tab = resize()).length，数组tab每个空间都是null         */                 if ((tab = table) == null || (n = tab.length) == 0)             //调用resize()方法进行扩容             n = (tab = resize()).length;          /*         1，i = (n - 1) & hash 表示计算数组的索引赋值给i，即确定元素存放在哪个桶中         2，p = tab[i = (n - 1) & hash]表示获取计算出的位置的数据赋值给节点p         3，(p = tab[i = (n - 1) & hash]) == null 判断节点位置是否等于null，          如果为null，则执行代码：tab[i] = newNode(hash, key, value, null);根据键值对创建新的节点放入该位置的桶中         小结：如果当前桶没有哈希碰撞冲突，则直接把键值对插入空间位置     */          if ((p = tab[i = (n - 1) & hash]) == null)             //节点位置为null，则直接进行插入操作             tab[i] = newNode(hash, key, value, null);         //节点位置不为null，表示这个位置已经有值了，于是需要进行比较hash值是否相等         else {             Node<K,V> e; K k;              /*           比较桶中第一个元素(数组中的结点)的hash值和key是否相等                1，p.hash == hash 中的p.hash表示原来存在数据的hash值  hash表示后添加数据的hash值 比较两个hash值是否相等                2，(k = p.key) == key ：p.key获取原来数据的key赋值给k  key表示后添加数据的key 比较两个key的地址值是否相等                3，key != null && key.equals(k)：能够执行到这里说明两个key的地址值不相等，那么先判断后添加的key是否等于null，如果不等于null再调用equals方法判断两个key的内容是否相等         */             if (p.hash == hash &&                 ((k = p.key) == key || (key != null && key.equals(k))))                  /*                  说明：两个元素哈希值相等（哈希碰撞），并且key的值也相等                  将旧的元素整体对象赋值给e，用e来记录                 */                  e = p;             // hash值不相等或者key不相等；判断p是否为红黑树结点             else if (p instanceof TreeNode)                 // 是红黑树，调用树的插入方法                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);             // 说明是链表节点，这时进行插入操作             else {                 /*                 1，如果是链表的话需要遍历到最后节点然后插入                 2，采用循环遍历的方式，判断链表中是否有重复的key                 */                 for (int binCount = 0; ; ++binCount) {                     /*                  1)e = p.next 获取p的下一个元素赋值给e                  2)(e = p.next) == null 判断p.next是否等于null，等于null，说明p没有下一个元     素，那么此时到达了链表的尾部，还没有找到重复的key,则说明HashMap没有包含该键                  将该键值对插入链表中                 */                     if ((e = p.next) == null) {                         p.next = newNode(hash, key, value, null);                         //插入后发现链表长度大于8，转换成红黑树结构                         if (binCount >= TREEIFY_THRESHOLD - 1)                              //转换为红黑树                             treeifyBin(tab, hash);                         break;                     }                     //key值以及存在直接覆盖value                     if (e.hash == hash &&                         ((k = e.key) == key || (key != null && key.equals(k))))                         break;                     p = e;                 }             }             //若结点为null，则不进行插入操作             if (e != null) {                  V oldValue = e.value;                 if (!onlyIfAbsent || oldValue == null)                     e.value = value;                 afterNodeAccess(e);                 return oldValue;             }         }         //修改记录次数         ++modCount;         // 判断实际大小是否大于threshold阈值，如果超过则扩容         if (++size > threshold)             resize();         // 插入后回调         afterNodeInsertion(evict);         return null;     }

小结：

根据哈希表中元素个数确定是扩容还是树形化
如果是树形化遍历桶中的元素，创建相同个数的树形节点，复制内容，建立起联系
然后让桶中的第一个元素指向新创建的树根节点，替换桶的链表内容为树形化内容

HashMap的扩容机制

我们知道，数组的容量是有限的，多次插入数据的话，到达一定数量就会进行扩容；先来看两个问题

什么时候需要扩容？

当HashMap中的元素个数超过数组长度loadFactor(负载因子)时，就会进行数组扩容，loadFactor的默认值是0.75,这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中的元素个数超过16×0.75=12(这个值就是阈值)的时候，就把数组的大小扩展为2×16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预知元素的个数能够有效的提高HashMap的性能。

怎么进行扩容的？

HashMap在进行扩容时使用 resize() 方法，计算 table 数组的新容量和 Node 在新数组中的新位置，将旧数组中的值复制到新数组中，从而实现自动扩容。因为每次扩容都是翻倍，与原来计算的 (n-1)&hash的结果相比，只是多了一个bit位，所以节点要么就在原来的位置，要么就被分配到"原位置+旧容量"这个位置。

因此，我们在扩充HashMap的时候，不需要重新计算hash，只需要看看原来hash值新增的那个bit是1还是0就可以了，是0的话索引没变，是1的话索引变成“原索引+oldCap(原位置+旧容量)”。这里不再详细赘述，可以看看下图为16扩充为32的resize示意图：

HashMap数组长度为什么是2的次幂

我们先看看它的成员变量：

序列化版本号

private static final long serialVersionUID = 362498820763181265L;

集合的初始化容量initCapacity

//默认的初始容量是16 -- 1<<4相当于1*2的4次方---1*16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

初始化容量默认是16，容量过大，遍历时会减慢速度，效率低；容量过小，那么扩容的次数变多，非常耗费性能。

负载因子

/**      * The load factor used when none specified in constructor.      */     static final float DEFAULT_LOAD_FACTOR = 0.75f;

初始默认值为0.75，若过大，会导致哈希冲突的可能性更大；若过小，扩容的次数也会提高。

为什么必须是2的n次幂？

当向HashMap中添加一个元素的时候，需要根据key的hash值，去确定其在数组中的具体位置。HashMap为了提高存取效率，要尽量较少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现就在把数据存到哪个链表中的算法。

这个算法实际就是取模，hash%length，计算机中直接求余效率不如位移运算。所以源码中做了优化,使用 hash&(length-1)，而实际上hash%length等于hash&(length-1)的前提是length是2的n次幂。

如果输入值不是2的幂会怎么样？

如果数组长度不是2的n次幂，计算出的索引特别容易相同，及其容易发生hash碰撞，导致其余数组空间很大程度上并没有存储数据，链表或者红黑树过长，效率降低。

1，当根据key的hash确定其在数组的位置时，如果n为2的幂次方**，**可以保证数据的均匀插入，如果n不是2的幂次方，可能数组的一些位置永远不会插入数据，浪费数组的空间，加大hash冲突。

2，一般可能会想通过 % 求余来确定位置，这样也可以，只不过性能不如 & 运算。而且当n是2的幂次方时：hash & (length - 1) == hash % length

3，因此，HashMap 容量为2次幂的原因，就是**为了数据的的均匀分布，减少hash冲突，**毕竟hash冲突越大，代表数组中一个链的长度越大，这样的话会降低hashmap的性能

maven子pom没有继承到父pom依赖版本

Tue, 29 Nov 2022 14:45:00 GMT

Java项目很多都会有子module，一般父项目没有逻辑代码，在父项目pom.xml中注明依赖、version和其他一些公用的东西，子module的pom继承父pom，子pom就不用写依赖的版本了，但至少也要写用到依赖的groupId、artifactId，这样默认会使用父项目依赖的版本。子pom也可以写版本，这样就不受父pom影响了，和继承类似，但还是有些区别。

使用时需要注意，我就是忘了其中一项，没有生效：

父pom需要添加<packaging>pom</packaging>
父pom需要用<modules><module>子module名</module></modules>注明子module有哪些
父pom声明依赖时<dependencies>外要嵌套<dependencyManagement>才能被子pom继承到，我就是忘了这点
子pom需要通过<parent></parent>指定父项目，声明依赖时就默认会用父pom中的版本了

dependencyManagement：像上面提到的，一般在父项目中会声明这个元素，和普通依赖用法类似，这个元素并不会真的引入依赖，只会标明依赖和版本，子项目会从父项目找<dependencyManagement>从而确定需要引用依赖版本，类似于模板模式。

父pom例子：

  <!-- 省略无关配置 -->   <packaging>pom</packaging>      <modules>         <!-- 注明所有子module -->         <module>module1</module>         <module>module2</module>     </modules>      <dependencyManagement>         <dependencies>             <!-- 以Lombk为例 -->             <dependency>                 <groupId>org.projectlombok</groupId>                 <artifactId>lombok</artifactId>                 <version>1.18.8</version>             </dependency>         </dependencies>     </dependencyManagement>

子pom module1例子：

    <!-- 省略无关配置 -->     <parent>         <groupId>父项目group</groupId>         <artifactId>父项目artifactId</artifactId>         <version>父项目version</version>        <relativePath>../pom.xml</relativePath>     </parent>     <dependencies>         <!--这样会使用父pom中的依赖版本1.18.8，如果这里写version就不会使用父pom里的版本了-->         <dependency>             <groupId>org.projectlombok</groupId>             <artifactId>lombok</artifactId>             <scope>provided</scope>         </dependency>     </dependencies>

relativePath

指定查找该父项目pom.xml的(相对)路径。默认顺序：relativePath > 本地仓库 > 远程仓库
没有relativePath标签等同…/pom.xml, 即默认从当前pom文件的上一级目录找
表示不从relativePath找, 直接从本地仓库找,找不到再从远程仓库找

经过 maven3.6版本测试，似乎没有relativePath标签时，它没有从当前pom文件的上一级目录找，子模块继承不到父模块中dependencyManagement中包的version信息。子模块想要用父模块pom中的版本，请注意配置relativePath属性！

Druid Maven引入缺少Jconsole.jar和Tools.jar的问题原因及解决办法

Tue, 22 Nov 2022 15:05:00 GMT

 Could not resolve dependencies for project com.xxx:xxx-framework🏺3.8.4: The following artifacts could not be resolved: com.sun:tools🏺1.8, com.sun:jconsole🏺1.8: Could not find artifact com.sun:tools🏺1.8 at specified path /root/.m2/repository/com/alibaba/druid/1.2.11/lib/openjdk-1.8-tools.jar

问题原因

OracleJDK面临商业闭源风险，所以用到的Jconsole和Tools引入的是OpenJDK

openjdk-1.8-jconsole.jar openjdk-1.8-tools.jar

解决方案

使用OpenJDK

 <dependency>             <groupId>com.sun</groupId>             <artifactId>tools</artifactId>             <version>1.8</version>             <scope>system</scope>             <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath> </dependency>  <dependency>             <groupId>jdk.tools</groupId>             <artifactId>jdk.tools</artifactId>             <version>1.8</version>             <scope>system</scope>             <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath> </dependency>

排除使用

大多数未用到这个功能（未参与源码(开发），则排除即可

<exclusions>     <exclusion>         <groupId>com.sun</groupId>         <artifactId>jconsole</artifactId>     </exclusion>     <exclusion>         <groupId>com.sun</groupId>         <artifactId>tools</artifactId>     </exclusion> </exclusions>

Jenkins+Maven+Github+Springboot实现可持续自动部署(非常详细)

Thu, 10 Nov 2022 03:29:00 GMT

一、安装内容

　　Jenkins（本文主要安装）、Maven、Git、JDK（这个三个安装过程略）

　　Jenkins与Github配合实现持续集成需要注意以下几点：

　　　　①Jenkins要部署到外网，因为内网Github是无法访问到的（走过的坑！），这里我租用的是阿里云的服务器实现。

　　　　②Jenkins所在的主机需要安装Git,通过Git程序从Github上clone代码

　　　　③在Jenkins中需要指定Git、Maven、JDK，路子都是相同的。

　　　　④在Github上使用每一个repository的webhook方式远程触发jenkins构建

　　　　⑤在Jenkins内关闭“防止跨站点请求伪造”

二、实现过程

1.不使用Jenkins：

　　①我们开发人员需要编写代码，提交到版本控制服务器（Svn、Git）

　　②我们开发人员需要手动拉取最新代码，构建maven工程，进行打包（war或jar）

　　③我们开发人员手动部署war或jar至应用服务器

　　④一旦项目上线，bug修改等小改动问题都要重复以上过程

2.使用Jenkins：

　　①同样，业务代码还是需要开发人员来编写并commit或push至版本控制自服务器（SVN、Git）

　　②通过以上图，我们发现，Jenkins帮我们做了：拉取最新代码、打包、部署

　　③我们开发人员只需专注于：业务代码的编写

　　④一旦项目上线，bug修改等小改动问题，我们开发人员只需提交最新代码即可，另一边的测试或最终用户就能看到最终效果，大大减少我们开发人员的工作量

三、Github仓库准备

　　鄙人写了一个小demo，用IDEA+Maven构建的SpringBoot的web项目：https://github.com/Simple-Coder/jenkins-demo

四、Jenkins的下载安装

　　下载地址：https://jenkins.io/download/（下载速度极慢），这里我已经将最新版的war包上传至CSDN下载，亲测可用，下载地址如下：

　　https://download.csdn.net/download/qq_39947137/11829473

1.Jenkins的war包下载

　　由于我是Java开发人员，最喜欢一键部署了，下载Jenkins的war直接丢进tomcat的webapps目录即可完成部署。

然后找到documentation，get started，这是学习一门新技术的一些套路了：官网---->download---->documentation---->getting started

2.将war包丢进服务器的tomcat/webapps目录，浏览器访问：IP:端口/jenkins

注：第一次安装，这里坑了我好久！！！（vim /root/.jenkins/hudson.model.UpdateCenter.xml）

打开 hudson.model.UpdateCenter.xml

把 http://updates.jenkins-ci.org/update-center.json

改成 :（以下其中一个）

http://mirror.xmission.com/jenkins/updates/update-center.json

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

http://mirror.esuni.jp/jenkins/updates/update-center.json

，还是不行的话找到 updates 目录下的 default.json 把里面所有的谷歌地址改成百度的，即将 http://www.google.com/ 替换为 http://www.baidu.com/。输入密码后出现以下界面说明成功。

配置完成出现以下界面说明url配置完成！

3.推荐插件安装

4.创建用户

5.实例配置

6.开始使用

7.进入首页

　至此、Jenkins的下载安装，完成，下面对Jenkins进行一系列的配置。

五、Jenkins的配置

1.插件配置

①**Maven Integration：新建job时有maven项目可以选择； ②Deploy to container：将war包部署到tomcat所在的服务器上； ③Publish Over SSH：**通过ssh推送文件，并可以执行shell命令；

2.Maven、Git、JDK配置

　　点击：“系统管理”------>“全局工具配置”

六、新建Jenkins任务

1.点击“系统管理”---->“系统设置”，进行ssh配置

2.首页点击：“新建任务”

3.General配置

4.源码管理

5.构建触发器

6.Github配置WebHook,完成钩子程序的配置

7.构建环境

启动脚本restart.sh如下:

echo "stop服务开始" pidlist=`ps -ef|grep jenkins-demo.jar | grep -v "grep"|awk '{print $2}'` #ps -u $USER|grep "Java"|grep -v "grep" if [ "$pidlist" = "" ]; then         echo "no jenkins-demo pid alive" else         echo "jenkins-demo Id list :$pidlist"         for pid in ${pidlist}         {                 kill -9 $pid                 echo "KILL $pid:"                 echo "service stop success"         } fi echo "stop服务脚本结束" echo "start服务脚本开始" JAVA_HOME=/usr/java/jdk1.8.0_181 dir=/opt/jenkins_jars cd $dir echo dir=$dir jar=$(find /lib -type f -name *.jar) classpath=$dir/*:$dir/lib/*:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar echo classpath=$classpath echo --------------------------------------------- nohup $JAVA_HOME/bin/java -classpath $classpath -XX:-UseGCOverheadLimit -Xms1024m -Xmx2048m -jar $dir/jenkins-demo.jar  > $dir/log/$(date +'%Y%m%d').log & echo "start服务脚本结束"

8.构建

　至此，第一个任务的配置完毕，接下来就是测试了！

七、测试任务

1.立即构建

2.控制台查看输出

控制台的输出如下：

3.浏览器访问：http://47.92.236.212:8091/test

4.IDEA修改该JSP页面，并推送至git仓库

5.推送github后，触发钩子程序，jenkins自动构建任务

6.浏览器再次访问：http://47.92.236.212:8091/test

回到顶部

八、总结

　　这里需要注意一下，如果只是单单部署war项目就比较简单了，配置如下：

1.deploy to container

2.配置容器

转载于： https://www.cnblogs.com/rmxd/p/11609983.html

Linux Maven私服（Nexus）搭建

Thu, 10 Nov 2022 03:12:24 GMT

下载

https://www.sonatype.com/download-oss-sonatype

　推荐使用迅雷下载，用浏览器下载可能会失败。

安装

安装JDK

安装JDK的过程就不在这里缀述了。

安装 Nexus

# 解压下载的 Nexus Repository OSS tar -zxvf latest-unix.tar.gz # 解压会得到如下两个文件夹： nexus-3.23.0-03/ sonatype-work/  # 进入 nexus-**/bin/  # 编辑nexus.vmoptions 配置，我这里因为内存不够，我将运行内存改成了1G

启动 nexus

./nexus start

这里启动很慢，我从启动到能够访问web页面，差不多花了3~5分钟

配置私服

添加阿里镜像到仓库组

在浏览器访问 http://{IP}:8081(启动成功才能看到如下页面）

根据提示，登录admin （密码有提示放在**/opt/sonatype-work/nexus3/admin.password**）进入设置向导，然后修改 admin 的密码，然后根据需要完成剩余向导

添加阿里镜像代理

将新增的maven 代理添加到 maven-public 组

配置maven setting.xml 下载私服jar包

<?xml version="1.0" encoding="UTF-8"?> <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">   <!-- 本地仓地址 -->   <localRepository>D:\nexus\repository</localRepository>    <!-- 配置用于鉴权的账号（由下面的“id”属性引用）-->   <servers>     <server>       <id>nexus</id>       <username>admin</username>       <password>admin123</password>     </server>   </servers>    <mirrors>     <mirror>       <!-- mirror的id要选定一个server的id，当拉取包时，会用server的id进行鉴权 -->       <id>nexus</id>       <mirrorOf>*</mirrorOf>       <name>nexus maven</name>       <!-- 私服地址，一般用maven-public分组仓库地址 -->       <url>http://192.168.10.128:8081/repository/maven-public/</url>     </mirror>   </mirrors>      <!-- 配置 允许下载snapshot版本包（默认无法下载snapshot版本包）,         如果不配置profile无法从私服下载 SNAPSHOT 版本的包 -->   <profiles>     <profile>       <id>profile-1</id>       <repositories>         <repository>           <id>nexus</id>           <name>local private nexus</name>           <!-- 仓库的路径，我们只是使用public这个分组仓库 -->           <url>http://192.168.10.128:8081/repository/maven-public/</url>           <releases>             <enabled>true</enabled>           </releases>           <snapshots>             <enabled>true</enabled>           </snapshots>         </repository>       </repositories>       <pluginRepositories>         <pluginRepository>           <id>nexus</id>           <name>local private nexus</name>           <url>http://192.168.10.128:8081/repository/maven-public/</url>           <releases>             <enabled>true</enabled>           </releases>           <snapshots>             <enabled>true</enabled>           </snapshots>         </pluginRepository>       </pluginRepositories>     </profile>   </profiles>    <activeProfiles>     <!-- 输入要激活的profile的ID -->     <activeProfile>profile-1</activeProfile>   </activeProfiles> </settings>

配置 pom.xml 发布包到私服

<project>     <!-- ....省略部分内容 -->   <distributionManagement>     <repository>       <!-- 这里的id必须和 setting.xml中配置的server的id相同（用于鉴权） -->       <id>nexus</id>       <name>nexus-release</name>       <url>http://192.168.10.128:8081/repository/maven-releases/</url>     </repository>     <!-- pom中版本如果以SNAPSHOT 结尾，则会被发布到 snapshot 仓库 -->     <snapshotRepository>       <id>nexus</id>       <name>nexus-snapshot</name>       <url>http://192.168.10.128:8081/repository/maven-snapshots/</url>     </snapshotRepository>   </distributionManagement> </project>

Windows远程桌面出现CredSSP加密数据修正问题解决方案

Thu, 10 Nov 2022 03:04:13 GMT

问题现象

解决方案

方案一

1、win+R打开运行窗口

2、输入gpedit.msc命令，点击“确定”

3、依次展开“计算机配置”->“管理模板”->“系统”->“凭据分配”设置名称：加密数据库修正

4、双击“加密数据库修正”，将状态改为“启用”，保护级别改为“易受攻击”，应用—>确定

方案二

1、win+R打开运行窗口

2、输入regedit命令，点击“确定”，打开注册表文件

3、在注册表中进入如下路径：HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\CredSSP\Parameters

4、右击Parameters—>新建—>DWORD（32）位，命名为AllowEncryptionOracle

注意：如果此文件已存在，则不需要创建，如果不存在，则创建

5、双击刚新建的AllowEncryptionOracle，将数值数据修改为2

VMWare Workstation无法生成SSL密钥导致安装失败问题

Thu, 10 Nov 2022 02:57:48 GMT

现象

一台安装有Windows 8 Enterprise x64系统的计算机，试图安装VMware Workstation 15.5时报错“Setup failed to generate the SSL keys necessary to run VMWare Server. Click Ok to cancel this installation.（大意为：安装程序无法生成VMware Server所需的SSL密钥，请单击‘确定’，终止安装程序。）”。

可能的原因

查阅资料显示，这一问题可能与错误的系统时间、DirectX配置不正确、没有正确安装的Visual C++运行库、PATH环境变量中包含指向VMware不支持的OpenSSL程序版本的路径等问题有关。

解决方案

经排查，VMware Workstation 15.5的安装程序会自动安装Microsoft Visual C++ 2015-2019 Redistributable，但似乎存在问题，可以先从 [控制面板] > [程序和功能] 页面删除Microsoft Visual C++ 2015-2019 Redistributable (x86)和Microsoft Visual C++ 2015-2019 Redistributable (x64)，然后从 Microsoft下载中心下载Microsoft Visual C++ 2015 Redistributable Update 3 (x86)和Microsoft Visual C++ 2015 Redistributable Update 3 (x64)并安装。随后，重新执行VMware Workstation安装程序，问题解决。

参考资料

https://kb.vmware.com/s/article/1008179

http://element-ui.cn/article/show-85929.aspx

https://www.cnblogs.com/d9394/p/13776623.html

https://blog.csdn.net/weixin_37949588/article/details/106306033

Unsupported major.minor version 52.0解决办法

Thu, 10 Nov 2022 02:52:46 GMT

1.首先解释一下报错原因：

stanford parser和jdk版本对应关系

J2SE 8 = 52, J2SE 7 = 51, J2SE 6.0 = 50, J2SE 5.0 = 49, JDK 1.4 = 48, JDK 1.3 = 47, JDK 1.2 = 46, JDK 1.1 = 45

Unsupported major.minor version 52.0: 看到Unsupported你是不是会想到jdk高版本能兼容低版本，但是低版本不能兼容高版本，不错，猜对了，其实就是这个意思。这个错误意思是你项目用JDK1.8运行过，现在又在本地的eclipse等开发工具或者本地环境变量为低版本的jdk1.7或者jdk1.6下运行，eclipse会说：“抱歉，我本地jdk版本太低，不支持这个高级版本jdk1.8编译过的项目运行”。

你看看你本地是报52还是51或者其他的错。

2.配置jdk解决问题：

这几个地方jdk要一致：

看看你系统的jdk环境变量配置的是jdk那个版本
Windows—— Preferences——Java——Compiler——设为jdk1.8
在此页面的Java——Installed JREs——设为jdk1.8
关闭此页面，项目右键（或者core包）——Build Path（也可是Properties）——Configure Build Path——Java Build Path——Libraries下面的JRE System Library改为jdk1.8（此处设置见参考3），保证旁边的Order and Export这个jdk与之相同
同页面的Java Compiler选项改为jdk1.8
同页面的Project Facets——右侧的Java改为1.8（此项也可以不改）
如果还不行看看你的Eclipse的Server里配置的tomcat和jdk版本是否不同：

Windows——Preference——Server——Runtime Environments——点击你要用的tomcat——点击Edit ——在弹出面板的JRE中选择和你项目对应的jdk版本

如果上述还不管用的话试试：

修改org.eclipse.wst.common.project.facet.core.xml：打开项目所在的文件夹，打开.settings文件夹，修改里面的“org.eclipse.wst.common.project.facet.core.xml”文件

如我的路径是：D:\cctv5cms\maven.1490956540309\cms-cms\cms-core.settings\org.eclipse.wst.common.project.facet.core.xml

本文链接：http://blog.csdn.net/superit401/article/details/72731381

参考1：https://www.zifangsky.cn/600.html

参考2：http://bbs.csdn.net/topics/391873068

参考3：http://www.oschina.net/question/207494_84715

手把手教你在Windows 10安装MySQL 8.0（详细图文）

Thu, 10 Nov 2022 02:50:18 GMT

1. 官网下载安装包

下载地址： https://dev.mysql.com/downloads/mysql/

通过下载页面可以选择安装包或者是压缩包。

这里选择安装文件（Installer MSI）

2. 点击下载的程序包安装

2.1 选择安装类型

选择【Server only】然后【Next】

2.2 安装前提检查

如果电脑上之前没有安装Microsoft Visual C++环境的话，会自动弹出MS Visual C++的安装页面，进行安装即可。

点击【Execute】

安装MS Visual C++:

设置成功后，点击【关闭】：

2.3 再次安装前提检查

MS Visual C++的安装后，再次进入安装前提检查页面，继续安装MySQL。

点击【Next】:

点击【Execute】:

点击【Next】:

2.4 High Availability选择

选择【Standalone】选项

2.5 端口号等设置

端口号等保持默认即可,点击【Next】。

2.6 认证方式等设置

选择推荐方式，点击【Next】。

2.7 Root密码等设置

设置MySQL root用户的登录密码。

这里输入密码：root

2.8 Windowns服务注册

点击【Next】:

2.9 安装过程等待

点击【Next】:

2.10 安装结束

点击【Next】，结束安装。

2.11 安装后产品配置

点击【Next】：

2.12 保存安装日志。

点击【Copy Log to Clipboard】,保存安装日志方便安装问题的调查。

3. 安装成功后，验证

通过开始菜单（Win键）调用MySQL命令行客户端（MySQL Command Line Client），就可以进行MySQL操作了。

点击开始菜单（Win键），找到安装的MySQL文件夹。

点击【MySQL 8.0 Command Line Client】,然后输入密码开始MySQL之旅。

4. MySQL的路径设置

按照上面的方法安装MySQL后，可以通过开始菜单（Win键）调用MySQL命令行，也可以通过Windows的【命令提示符】调用MySQL监视器对MySQL进行操作。默认安装情况下MySQL监视器是放在以下路径中：

C:\Program Files\MySQL\MySQL Server 8.0\bin

所以，要想启动的话，需要先移动到这个文件夹中。

在【系统变量】或者【用户变量】中，选择变量【Path】，点击【编辑】->【新建】，输入上面的MySQL路径“C:\Program Files\MySQL\MySQL Server 8.0\bin”。这样，以后在Windows命令行中调用MySQL命令行就不用每次都移动文件夹了。

转载于：https://cloud.tencent.com/developer/article/1636375

jquery中load中文乱码的解决方法

Mon, 07 Nov 2022 02:28:00 GMT

$("").load()中文乱码问题

JSP 请求页面

$("#baseLineThreeCenterTab").load(basePath+"/pro/baseline/gotoProConfigBaseLineMain.action?parameter="+parameter);

java后台接收的如：parameter=“中文”，则会出现乱码。

解决方法：

JSP页面

// encodeURI()编码  $("#baseLineThreeCenterTab").load(basePath+"/pro/baseline/gotoProConfigBaseLineMain.action?parameter="+encodeURI(parameter));

JAVA:

// URLDecoder.decode(parameter, "utf-8");解码 import java.net.URLDecoder; String parameter = URLDecoder.decode(parameter, "utf-8");

Chrome浏览器内置翻译无法使用,右键翻译无反应?（已失效）

Wed, 05 Oct 2022 07:27:00 GMT

原因

谷歌(Google)以使用率低为由，停止了Google翻译在中国大陆的服务，Google翻译退出中国,仅存唯一功能也没了.

现象

点击翻译无反应,依然显示英文.

分析

我们通过抓包工具可以看见翻译的时候会访问 https://translate.googleapis.com

translate.googleapis.com（Google 翻译 API）,因为停止了中国大陆的服务,不再分配中国内地的服务器地址，所以浏览器内置的 Google 翻译无法使用

浏览器内置API不支持扩展配置的socks5代理，所以挂梯子是无效的，除非用系统代理。

解决方法

Google 在中国开展业务的相关网站所使用的 IP 地址都是共享的，包括谷歌翻译业务在内，因此只要能找到你能正常访问的 Google 服务的相关域名，比如谷歌中国主页、能够在网页上正常加载的 Adsense 广告或 Analytics 统计所使用的 JavaScript 脚本文件网址等，就可以很轻松的获取到在你所在的网络环境中可以正常使用的 IP 地址。获取到可用 IP 地址后，将其添加到操作系统的 hosts 文件，使其映射到谷歌翻译 API 所使用的域名，Chrome 翻译功能就能正常使用了。

下面是获取可用 IP 地址以及修改 Windows 系统和 macOS 系统 hosts 文件的具体方法。

手动

可以编辑HOSTS文件对域名的地址解析进行修正

由于 translate.googleapis.com 采用与 google.cn 相同的 IP地址，可以先ping一下得到对应的IP再修改HOSTS文件。

# 打开终端或者CMD 得到IP地址 ping google.cn  # windows C:\Windows\System32\drivers\etc\hosts # Linux / MacOS  /etc/hosts  # 在文件中添加一行保存即可，格式示例（自己根据通过 `ping google.cn` 得到的地址修改前面的IP地址）： 114.250.65.34 translate.googleapis.com

自动

windows

为简化操作，已手动修改 hosts 文件的步骤写成了批处理脚本，只需一键即可完成所有修改步骤。

下载批处理脚本：fix-google-translate-cn.bat

使用方法很简单，下载完成并解压缩，在批处理文件上点击右键，在弹出的菜单中点击【以管理员身份运行】即可。如果看到如下所示提示，表示规则添加成功，Chrome 翻译就恢复正常了。

Adding the rule "114.250.65.34 translate.googleapis.com" Done. 请按任意键继续...

此脚本可以重复使用。添加规则后再次使用时会出现交互提示信息，输入 1 会尝试更新已添加规则的 IP 地址，如果没有变化则不做任何修改，输入 2 会删除已添加的规则。

linux&MacOS

为简化操作，已将手动修改 hosts 文件的步骤写成了 Shell 脚本，只需一键即可完成所有修改步骤。

打开“终端”，拷贝以下命令并将其粘贴到终端上，按回车，输入你的系统密码，再按回车。注意，输入密码时是不显示任何信息的，只要确保输入的密码是正确的就可以。

sudo bash -c "$(curl -skL https://nas.mrf.ink:3000/tools/shell/raw/master/browser/fix-google-translate-cn/mac&linux.sh)"

如果看到如下所示提示，表示规则添加成功，也就可以正常使用 Chrome 的谷歌翻译功能了。

Adding the rule "114.250.65.34 translate.googleapis.com" Done.

结果

可以看出再次翻译显示中文了.

大批量更新数据mysql批量更新的四种方法

Fri, 09 Sep 2022 08:44:00 GMT

mysql 批量更新如果一条条去更新效率是相当的慢, 循环一条一条的更新记录,一条记录update一次，这样性能很差，也很容易造成阻塞。mysql 批量更新共有四种办法

replace into 批量更新

replace into test_tbl (id,dr) values (1,'2'),(2,'3'),...(x,'y');

insert into ...on duplicate key update批量更新

insert into test_tbl (id,dr) values (1,'2'),(2,'3'),...(x,'y') on duplicate key update dr=values(dr);

创建临时表，先更新临时表，然后从临时表中update

create temporary table tmp(id int(4) primary key,dr varchar(50)); insert into tmp values  (0,'gone'), (1,'xx'),...(m,'yy'); update test_tbl, tmp set test_tbl.dr=tmp.dr where test_tbl.id=tmp.id;

注意：这种方法需要用户有temporary 表的create 权限。

使用mysql 自带的语句构建批量更新

mysql 实现批量可以用点小技巧来实现:

UPDATE tableName     SET orderId = CASE id          WHEN 1 THEN 3          WHEN 2 THEN 4          WHEN 3 THEN 5      END WHERE id IN (1,2,3)

这句sql 的意思是，更新orderId 字段，如果id=1 则orderId 的值为3，如果id=2 则orderId 的值为4…… where部分不影响代码的执行，但是会提高sql执行的效率。确保sql语句仅执行需要修改的行数，这里只有3条数据进行更新，而where子句确保只有3行数据执行。

如果更新多个值的话，只需要稍加修改：

UPDATE categories      SET orderId = CASE id          WHEN 1 THEN 3          WHEN 2 THEN 4          WHEN 3 THEN 5      END,      title = CASE id          WHEN 1 THEN 'New Title 1'         WHEN 2 THEN 'New Title 2'         WHEN 3 THEN 'New Title 3'     END WHERE id IN (1,2,3)

到这里，已经完成一条mysql语句更新多条记录了。

总结

更新 100000条数据的性能就测试结果来看，测试当时使用replace into性能较好。

replace into 和 insert into on duplicate key update的不同在于：

replace into 操作本质是对重复的记录先delete 后insert，如果更新的字段不全会将缺失的字段置为缺省值，用这个要悠着点否则不小心清空大量数据可不是闹着玩的。 insert into 则是只update重复记录，不会改变其它字段。

confluence 忘记密码

Fri, 09 Sep 2022 08:40:00 GMT

数据库相关信息

查看 confluence.home 配置

cat /opt/atlassian/confluence/confluence/WEB-INF/classes/confluence-init.properties | grep confluence.home

在 confluence.home 下面的 confluence.cfg.xml 文件里面查看数据库信息

 cat /var/atlassian/application-data/confluence/confluence.cfg.xml  | grep connection

修改管理员密码

登录数据库

mysql -hlocalhost -uconfluence -p confluence

在数据库里面查看管理员用户

select u.id, u.user_name, u.active from cwd_user u   join cwd_membership m on u.id=m.child_user_id join cwd_group g on m.parent_id=g.id join cwd_directory d on d.id=g.directory_id   where g.group_name = 'confluence-administrators' and d.directory_name='Confluence Internal Directory';

更新管理员用户密码为 admin

update cwd_user set credential =   'x61Ey612Kl2gpFL56FT9weDnpSo4AV8j8+qx2AuTHdRyY036xxzTTrw10Wq3+4qQyB+XURPWx1ONxp3Y3pB37A=='   where id=xxxxxx; # 这里需要改成 393217

注意此处xxxxxx 为上一步的 id

如果你的密码是{PKCS5S2}前缀开头的，则用下面这个sql:

update cwd_user set credential = '{PKCS5S2}ltrb9LlmZ0QDCJvktxd45WgYLOgPt2XTV8X7av2p0mhPvIwofs9bHYVz2OXQ6/kF' where id=xxxxxx;

这个管理员密码为 Ab123456

使用javapackager打包各系统安装包

Thu, 08 Sep 2022 09:07:00 GMT

在平时我们打包会将其打成Jar，那么在其他平台运行的时候就需要安装jre来支持运行。我们用的是javapackager,javapackager是jdk1.8自带的一个打包工具，可以生成各个系统的安装包

准备工作

innosetup-5.6.0.exe（windows下Java8支持6版本以下的，不要下载6及其6以上的版本，否则无法打包成功）
wix（打包成msi必须下载，没有下载javapackager会提示缺少wix）
JDK8

用法

javapackager  command  [options]

command :应该执行的任务

[options] :以空格分隔的命令的一个或多个选项

Commands

您可以指定以下命令之一。在命令之后，指定它的选项。

-createbss:将 CSS 文件转换为二进制形式。
-createjar:根据其他参数生成 JAR 存档。
-deploy:组装应用程序包以进行重新分发。默认情况下，部署任务会生成基础应用程序包，但如果需要，它也可以生成自包含的应用程序包。
-makeall:使用预定义的大多数参数，一次调用执行编译、createjar和deploy步骤，并尝试生成所有适用的自包含应用程序包。源文件必须位于名为的文件夹src中，生成的文件（JAR、JNLP、HTML 和自包含应用程序包）位于名为的文件夹中dist。此命令只能以最少的方式配置，并且尽可能自动化。
-signjar:使用提供的证书对 JAR 文件进行签名。

createbss 命令的选项

-outdir dir: 将接收生成的输出文件的目录的名称。
-srcdir dir:要打包的文件的基本目录。
-srcfiles files:-srcdir选项指定的目录中的文件列表。如果省略，将使用目录中的所有文件（在这种情况下这是一个强制参数）。列表中的文件必须用空格分隔。

createjar 命令的选项

-appclass app-class:要执行的应用程序类的限定名称。
-argument arg:要作为<fx:argument>元素插入到 JNLP 文件中的未命名参数。
-classpath files:相关 JAR 文件名列表。
-manifestAttrs manifest-attributes:其他清单属性的名称和值列表。句法：“名称 1=值 1，名称 2=值 2，名称 3=值 3”
-nocss2bin:打包器在复制到 JAR 之前不会将 CSS 文件转换为二进制形式。
-outdir dir:将接收生成的输出文件的目录的名称。
-outfile filename:将生成的文件的名称（不带扩展名）。
-paramfile file:具有默认命名应用程序参数的属性文件。
-preloader preloader-class:要执行的 JavaFX 预加载器类的限定名称。此选项仅用于 JavaFX 应用程序。不要用于 Java 应用程序，包括无头应用程序。
-srcdir dir:要打包的文件的基本目录。
-srcfiles files:-srcdir选项指定的目录中的文件列表。如果省略，将使用目录中的所有文件（在这种情况下这是一个强制参数）。列表中的文件必须用空格分隔。

deploy命令的选项

-allpermissions:如果存在，应用程序将需要 JNLP 文件中的所有安全权限。
-appclass app-class:要执行的应用程序类的限定名称。就是详细包名+类名，也就是程序的入口类的全类名
-argument arg:要插入到fx:argumentJNLP 文件中的元素中的未命名参数。
-Bbundler-argument=value: 向用于打包自包含应用程序的捆绑程序提供信息。有关每个捆绑器的参数的信息，请参阅自包含应用程序捆绑器的参数。
-callbacks:在生成的 HTML 中指定用户回调方法。格式如下：“名称 1：值 1，名称 2：值 2，...”
-description description:应用程序的描述。
-embedCertificates:如果存在，证书将嵌入 JNLP 文件中。
-embedjnlp:如果存在，JNLP 文件将嵌入到 HTML 文档中。
-height height:应用程序的高度。
-htmlparamfile file:属性文件，其中包含在浏览器中运行时生成的应用程序的参数。
-isExtension:如果存在，则将srcfiles其视为扩展。
-name name:应用程序的名称。
-native type:生成独立的应用程序包（如果可能）。使用该-B选项为正在使用的捆绑器提供参数。如果指定了类型，则仅创建此类型的捆绑包。如果未指定类型，all则使用。

以下值对type有效：
- all：为运行它的平台运行所有安装程序，并为应用程序创建磁盘映像。如果未指定类型，则使用此值。
- installer：运行它所在平台的所有安装程序。
- image：为应用程序创建磁盘映像。创建原生的镜像(打成window的exe)。
- exe: 生成一个 Windows.exe包。
- msi：生成一个 Windows 安装程序包。
-outdir dir:将接收生成的输出文件的目录的名称。
-outfile filename:将生成的文件的名称（不带扩展名）。
-paramfile file:具有默认命名应用程序参数的属性文件。
-preloader preloader-class:要执行的 JavaFX 预加载器类的限定名称。此选项仅用于 JavaFX 应用程序。不要用于 Java 应用程序，包括无头应用程序。
-srcdir dir:要打包的文件的基本目录。就是我们之前包含jar文件的文件夹(注意这里不是java源代码目录)
-srcfiles files:-srcdir选项指定的目录中的文件列表。如果省略，将使用目录中的所有文件（在这种情况下这是一个强制参数）。列表中的文件必须用空格分隔。

20 -templateId:模板处理应用的应用ID。

21 -templateInFilename:HTML 模板文件的名称。占位符采用以下形式：#XXXX.YYYY(APPID)#

 其中 APPID 是应用程序的标识符，XXX 是以下之一：

DT.SCRIPT.URLdtjava.js 在部署工具包中的位置。默认情况下，位置是http://java.com/js/dtjava.js
DT.SCRIPT.CODE包含部署工具包的 dtjava.js 的脚本元素。
DT.EMBED.CODE.DYNAMIC将应用程序嵌入给定占位符的代码。预计代码将被包装在function()方法中。
DT.EMBED.CODE.ONLOAD使用钩子将应用程序嵌入网页所需的所有代码onload（包含 dtjava.js 除外）。
DT.LAUNCH.CODE启动应用程序所需的代码。预计代码将被包装在function()方法中。

22 -templateOutFilename:将从模板生成的 HTML 文件的名称。

23 -title title:应用程序的标题。

24 -vendor vendor:应用程序的供应商。

25 -width width:应用程序的宽度。

26 -updatemode update-mode:设置 JNLP 文件的更新模式。

makeall 命令的选项

-appclass app-class:要执行的应用程序类的限定名称。
-classpath files:相关 JAR 文件名列表。
-height height:应用程序的高度。
-name name:应用程序的名称。
-preloader preloader-class:要执行的 JavaFX 预加载器类的限定名称。此选项仅用于 JavaFX 应用程序。不要用于 Java 应用程序，包括无头应用程序。
-width width:应用程序的宽度。

signjar 命令的选项

-alias:密钥的别名。
-keyPass:用于恢复密钥的密码。
-keyStore file:密钥库文件名。
-outdir dir:将接收生成的输出文件的目录的名称。
-srcdir dir:要签名的文件的基本目录。
-srcfiles files:-srcdir选项指定的目录中的文件列表。如果省略，将使用目录中的所有文件（在这种情况下这是一个强制参数）。列表中的文件必须用空格分隔。
-storePass:检查密钥库完整性或解锁密钥库的密码
-storeType:密钥库类型。默认值为“jks”。

应用程序捆绑的参数

这些自定义的bundle参数在使用的时候要注意，-B加上参数名=值例如 icon 使用的时候就是 -Bicon=“path

该命令的-B选项用于-deploy指定用于创建自包含应用程序的捆绑程序的参数。每种类型的捆绑器都有自己的一组参数。

appVersion=version:应用程序包的版本。一些捆绑器会限制版本字符串的格式。
classPath=path :相对于组装的应用程序目录的类路径。javapackager该路径通常从 JAR 文件清单中提取，如果您使用其他命令，则不需要设置。
icon=path:用于启动器和其他辅助的默认图标的位置。对于 Windows，格式必须为.ico.
identifier=value:用于其他平台特定值的默认值，例如mac.CFBundleIdentifier. 建议使用反向 DNS 顺序，例如com.example.application.my-application.
jvmOptions=option:运行应用程序时传递给 JVM 的选项。java可以使用对命令有效的任何选项。要传递多个选项，请使用该-B选项的多个实例，如下例所示：-BjvmOptions=-Xmx128m -BjvmOptions=-Xms128m`
jvmProperties=property=value:运行应用程序时要传递给 VM 的 Java 系统属性。可以使用-D对命令选项有效的任何属性。java指定属性名称和属性值。要传递多个属性，请使用该-B选项的多个实例，如下例所示：-BjvmProperties=apiUserName=示例 -BjvmProperties=apiKey=abcdef1234567890
mainJar=filename:包含应用程序主类的 JAR 文件的名称。javapackager文件名通常从 JAR 文件清单中提取，如果您使用其他命令，则不需要设置。
preferencesID=node:要检查的首选项节点以检查用户可以覆盖的 JVM 选项。指定的节点在运行时作为选项传递给应用程序-Dapp.preferences.id。此参数与userJVMOptions参数一起使用。
runtime=path:运行时=路径要包含在包中的 JRE 或 JDK 的位置。提供 JDK 或 JRE 的根文件夹的文件路径。要使用系统默认的 JRE，请不要提供路径，如下例所示：-Bruntime=
serJvmOptions=option=value:用户可以覆盖的 JVM 选项。java可以使用对命令有效的任何选项。指定选项名称和选项的值。要传递多个选项，请使用该-B选项的多个实例，如下例所示：-BuserJvmOptions=-Xmx=128m -BuserJvmOptions=-Xms=128m

Windows EXE Bundler 参数

copyright=string:应用程序的版权字符串。字符串必须是不超过 100 个字符的单行。此参数用于各种 exe 和注册表元数据。
licenseFile=path:捆绑商提供或记录的最终用户许可协议 (EULA) 的位置。该路径是相对于打包的应用程序资源的，例如-BlicenseFile=COPYING.
menuHint=boolean:指示快捷方式是否安装在开始菜单或开始屏幕上的标志。设置为true安装快捷方式。默认值为true.
ortcutHint=boolean:指示快捷方式是否放置在桌面上的标志。设置为true向桌面添加快捷方式。默认值为false.
systemWide=boolean:指示应用程序是安装在 Program Files 中还是安装在用户主目录中的标准位置的标志。设置为true在 Program Files 中安装应用程序。设置为false将应用程序安装在用户的主目录中。默认值为false.
win.menuGroup=group:何时安装应用程序的菜单menuHint组true。menuHint当is时，该参数被忽略false。
vendor=value:提供申请的公司、组织或个人。此参数用于各种 exe 和注册表元数据。

Windows MSI Bundler 参数

menuHint=boolean:指示快捷方式是否安装在开始菜单或开始屏幕上的标志。设置为true安装快捷方式。默认值为true.
shortcutHint=boolean:指示快捷方式是否放置在桌面上的标志。设置为true向桌面添加快捷方式。默认值为false.
systemWide=boolean:指示应用程序是安装在 Program Files 中还是安装在用户主目录中的标准位置的标志。设置为true在 Program Files 中安装应用程序。设置为false将应用程序安装在用户的主目录中。默认值为true.
win.menuGroup=group:何时安装应用程序的菜单menuHint组true。menuHint当is时，该参数被忽略false。
vendor=value:提供申请的公司、组织或个人。此参数用于各种 exe 和注册表元数据。

不推荐使用的选项

打包工具不再使用以下选项，如果存在则将其忽略。

-runtimeversion version:所需 JavaFX 运行时的版本。已弃用。
-noembedlauncher:如果存在，打包程序不会将 JavaFX 启动器类添加到 JAR 文件中。已弃用。

-v选项可以与任何任务命令一起使用以启用详细输出。

当-srcdir命令中允许该选项时，它可以多次使用。如果指定了该选项，则将在前面选项-srcfiles中指定的位置查找参数中命名的文件。srcdir如果没有-srcdir前面的，则使用执行命令-srcfiles的目录。javapackager

例子

使用 -createjar 命令

javapackager -createjar -appclass package.ClassName -srcdir classes -outdir out -outfile outjar -v

classes将目录的内容打包为outjar.jar，将应用程序类设置为package.ClassName。

使用 -deploy 命令

javapackager -deploy -outdir outdir -outfile outfile -width 34 -height 43  -name AppName -appclass package.ClassName -v -srcdir compiled

为应用程序生成outfile.jnlp和对应的outfile.html文件，它由34 x 43 像素启动并具有尺寸。outdir``AppName``package.ClassName

使用 -makeall 命令

javapackager -makeall -appclass brickbreaker.Main -name BrickBreaker -width 600 -height 600

是否所有打包工作，包括编译createjar、和deploy.

使用 -signjar 命令

javapackager -signJar --outdir dist -keyStore sampleKeystore.jks -storePass **** -alias duke -keypass **** -srcdir dist

对目录中的所有 JAR 文件进行签名dist，附加具有指定别名的证书，keyStore然后storePass将签名的 JAR 文件放回dist目录中。

将 -deploy 命令与 Bundler 参数一起使用

javapackager -deploy -native exe -BsystemWide=true -BjvmOptions=-Xmx128m      -BjvmOptions=-Xms128m -outdir packages -outfile BrickBreaker -srcdir dist      -srcfiles BrickBreaker.jar -appclass brickbreaker.Main -name BrickBreaker      -title "BrickBreaker demo"

生成本机 Windows EXE 包，用于将 BrickBreaker 应用程序作为自包含应用程序运行。

javapackager -deploy -native   -outdir packages -outfile md5 -srcfiles  md5.jar -appclass com.sysware.md5.MyFrame -name md5

生成本机安装包(在linux下生成deb,在windows下生成exe,在mac下生成dkg)，用于将 md5.jar 应用程序作为自包含应用程序运行。

分析一下

javapackager---java8自带的打包程序  -deploy---用来构建目标机器的发行版本，简单说就是打包成exe或者其他平台的包，如果不带任何参数，会生成一个基本的应用程序，不建议不带任何参数  -native image---为jar创建磁盘镜像（可以将image替换为其他的类型，例如exe，msi，deb，rpm,dmg,pkg,省略就是该系统支持的文件格式）  -outdir packages---输出目录。  -outfile md5----输出文件（不要带后缀，比如md5.exe，就写md5就行了）。  -srcfiles md5.jar---要打包的jar文件。  -appclass com.sysware.md5.MyFrame---jar文件的主类的全限定名。（注意是全限定名）  -name md5---启动之后的应用名称

文章翻译自:https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javapackager.html

厨房调料怎么挑?

Wed, 07 Sep 2022 14:17:00 GMT

怎么调?其实主要是看配料表,国家严格要求,按照配料东西的比例有大到小写的顺序

普及一下

谷氨酸钠=味精

呈味核=增味剂

苯甲酸钠=防腐剂

山梨酸钾=防腐剂

氯化钠=盐

酵母提取物=味精

香油怎么选

工艺:水代的比压榨的好

产地:国产的比埃塞俄比亚就好

味精鸡精的秘密

其实都是提鲜的,其实味精是最干净的用小麦提炼的

鸡精中比例最大的就是味精

酱油怎么选

生抽:增鲜提味用的

老抽:菜上色用的

其他功能性的:蒸鱼的,吃海鲜的,草菇,极味鲜,鲜上鲜其实是生抽的一种,其实没必要买,里面的配料都有谷氨酸钠,呈味核,目的是发酵时间不够,添加出来的味道.买酱油肯定是吃自然发酵的,

配料中有一个脱脂大豆,其实就是炼油厂脱完脂的大豆的豆渣,酱油厂商为了降低成本所以使用这些脱脂大豆,好的酱油都是用全脂大豆,像非转基因大豆,小麦粉酿出来的才是好酱油

白酒怎么选

不说那些茅台,五粮液啥的太贵了,不是我们喝的,就说一下性价比最高的高粱酒

执行标准分三类:液态法白酒,固液态法白酒和固态法白酒

液态法白酒:其实也是蒸馏出来的,但是不是用粮食酿出来的,就是红薯类似的东西加上食用酒精和香精勾兑出来的,市面上已经比较少了

固液态法白酒:一部分是纯粮酿造出来的,另一部分就是用红薯干酿造出来一起兑的,市面上百分之八九十写的纯粮食酿的就是用固液态法

固态法白酒:纯粮食做基础酿造出来的

为什么找纯粮的酒,他醒酒快,口不干,第二天也不难受,所以我们买酒买固态法白酒,

执行编号:G/BT20761 酱香型 G/BT10781.2 清香型 G/BT10781.1 浓香型

白醋怎么选

不要选带冰醋精的没啥营养价值,价格便宜,酸度非常酸.也不要选苯甲酸钠的,有这个说明原材料成分很低,水的成分高

白醋最基本的就是用大米或者糯米发酵而成的.用了酒精说明是一种速成不是自然发酵而成的,可以吃但是不是一个营养价值非常好的白醋

白醋适合做热菜,米醋的酸度比较柔和适合做凉菜

陈醋怎么选

三个点:酸度,执行标准号,配料

焦糖色:专门用来调颜色的,一般是醋的发酵时间不够,加焦糖色,调一下颜色

苯甲酸钠:防腐剂,因为酸度不够,怕坏了

酸度在5%以上,都是固态发酵

陈醋:gb/t 18187,只不过工艺不一样,用高粱发酵的酸度高一些,糯米的酸中有一些回甜

山西老陈醋:执行标准必须是gb/t 19777.第二配料一定是高粱,用高粱发酵的

镇江香醋:gb/t 18623,酸度柔和,第二配料一定是糯米,用糯米发酵的

一般炒菜用陈醋,拌凉菜用香醋

盐怎么选

背景:因为七八十年代大部分人缺碘,出现了大脖子病,1995年国家要求全民吃碘盐最近这几年得甲亢的或者高碘区的人,他们摄入的碘已经够了,没有卖不加碘的盐,2017年国家又放开了政策出现了海藻盐,不含碘盐,低钠盐,低钠海藻盐,还有岩盐.

不加碘的盐:如果你经常吃海带,海藻,海鱼,海虾等海产品比较多或者你有甲亢.其实你本身碘的补充是多了,这时候不含碘的盐才适合你吃.

低钠盐:高血压,心脏病呀这类患者适合吃低钠盐,普通盐里面氯化钠含量很高,会促使血管膨胀,血流加快

岩盐:比较高端的一种盐,也叫喜马拉雅盐,矿物质含量比较多,一般在高档餐厅,高档烤肉或者一些料理餐厅中,一般炒菜用不到这种,有钱人随意哈,

耗油怎么选

谷氨酸钠(味精),呈味核(味精精) 为啥要加这些因为耗的成分少,我们是要吃用耗提炼出来的精华去做菜,让味道更鲜美,不是吃水掺了的酱油加了一些耗油的耗油汁,

山梨酸钾,苯甲酸钠其实就是防腐剂,因为水的比例比较多,容易坏所以加这些防腐剂

一般配料表中第一位是耗汁的才是好耗油,没有防腐剂的当然没有味精焦糖色更好,不过市面上很少见没有添加味精的.

食用油怎么选

低档油

调和油:看配料表现在比较争议比较大的转基因的好不好这个我也不知道,但是非转基因的肯定没问题,

调和油没有加工工艺

中档油

食用油的三种加工工艺:浸出,热压(热榨),冷压(冷榨)

浸出:用化学试剂去浸泡,再去压榨,再去脱酸脱臭的一些处理,里面有一些试剂的残留,不过国家允许范围内,这种不太健康,不过便宜因为出油率高.

热榨:温度在60以上,相对冷榨出油率高,所以性价比好一些,没必要买冷榨的除了贵 ,没太多优点,营养价值比不上高档油

还有一个问题一级,S级,浓香,特级和油的品质一毛钱关系都没有不用关心这个

油我们除了吃一个口味外还有一个营养价值饱和脂肪酸的含量和不饱和脂肪酸的含量

饱和脂肪酸尽量少吃,容易三高,脂肪含量高,各方面数据高,不饱和脂肪酸高可以防止三高这些东西

不饱和脂肪酸有单不饱和脂肪酸和多不饱和脂肪酸

中档油中不同油脂单不饱和脂肪酸的含量从高到低

橄榄油>油茶籽油>一般菜籽油>低芥酸菜籽油>花生油>米糠油>芝麻油>棕榈油>玉米油>花椒籽油>葵花籽油>亚麻籽油>鸡油>大豆油>葡萄籽油>鸭油>核桃油>红花籽油>羊油>棉籽油>牛油>猪油

中档油中不同油脂多不饱和脂肪酸的含量从高到低

牛油>羊油>猪油>鸭油>鸡油>棕榈油>棉籽油>花生油>橄榄油>米糠油>玉米油>芝麻油>大豆油>葡萄籽油>花椒籽油>葵花籽油>核桃油>亚麻籽油>一般菜籽油>红花籽油>低芥酸籽油>油茶籽油

葵花籽油和菜籽油这两个混着吃,营养要均衡比如这周吃单不饱和脂肪酸含量最多的下周吃多不饱和脂肪酸含量最多的

高档油

橄榄油,亚麻籽油,核桃油,山茶油都说自己是世界上最好的油

高档油除了看配料外另外就是能量表

橄榄油和山茶油是单不饱和脂肪酸特别高

亚麻籽油和核桃油,是多不饱和脂肪酸特别高

橄榄油:看配料精炼的(是把特级和一级混合到一起了)没有特级的好,橄榄油特点炒菜没有味不适合中餐

山茶油:煎炒烹炸炖都合适 ,单不饱和脂肪酸推荐这个

亚麻籽油和核桃油:能量是一样的,推荐亚麻籽油因为他便宜五六十一斤 ,核桃油一百五六一斤,这种两油有个问题不耐高温,炒炸不适合,适合拌凉菜啥的

山茶油炒菜吃,亚麻籽油拌凉菜吃

番茄沙司怎么选

食品添加剂多的不要买

冰乙酸瓜尔胶柠檬酸苯甲酸钠黄原胶有这写配料的番茄纯度不高水的比例高,需要加一些色素,胶增稠.

番茄沙司就是调制的都是兑的,番茄酱是西红柿打成的酱

有辣椒粉(增红) 和淀粉添加剂(增稠)的也可以购买吧

买就最好买那种无添加剂无淀粉辣椒粉的那种是最好的

牛奶怎么选

大致分六类

纯牛奶:营养成分保留最全面的,鲜牛奶高温杀菌而成,分两种巴氏奶和常温奶,巴氏奶保质期短一般最多只有21天,常温奶有6个月不过处理的更复杂,杀菌更多,当然营养成分也会流失一些,纯牛奶配料很简单就一个生牛乳,推荐和巴氏奶,营养和口感都比常温的要好

舒化奶:也就是无乳糖牛奶,喝牛奶拉肚子,是对常规的牛奶的乳糖,消化系统不接受这种糖.喝常规奶拉肚子就需要喝这种无乳糖样的奶,里面有乳糖酶会把乳糖给水解掉.但是口感喝起来很甜, 营养成分和纯牛奶差不多,选择时候选配料比较干净的就生牛乳和乳糖酶的就行.

高钙奶:比普通的奶百毫升中多了25毫克钙,里面添加的是碳钙和乳酸钙,这种钙很难吸收,并不比纯牛奶的营养高,平常经常吃奶制品或乳制品或豆制品,没必要买这种奶

脱脂牛奶:常规奶都是全脂牛奶,脂肪比例在3%,脱脂牛奶通过离心技术把脂肪含量控制在0.5%,但是这种牛奶口味淡,没有那种醇香奶香的味道,和兑了水似的.脱脂过程中,其实维生素ADE也没有了,配料也是只有生牛乳,

早餐奶:和早餐没啥关系,有大量的添加剂,只不过里面含有奶的成分,其实就是含乳饮料,不推荐这种

含乳饮料:优酸乳一类的不推荐

总结

蚝油:推荐财神蚝油和旧庄蚝油(更好)

酱油:丸庄黑豆原汁酱油不是原酿酱油,千禾 380天零添加酱油不是180天的(有脱脂大豆)

香醋:镇江恒顺香醋

陈醋:千禾 3年窖藏还有山西老陈醋国标GB/T19777不是山西陈醋

白醋:东湖九度白醋和千禾糯米白醋还有鲁花糯米白醋选7度以上的酸度才够国标号都是GB/T18187

料酒:欣和有机米香料酒 ,千禾零添加烹调料酒

食用油:炒菜油推荐菜籽油和葵花籽油,高档点的推荐山茶油

常见食品添加剂

分类	食品添加剂
防腐剂	苯甲酸及其盐类、山梨酸及其盐类、亚硫酸及其盐类、化碳、亚硝酸盐类等。
抗氧化剂	茶多酚、生育酚、黄酮类、丁基羟基茴香醚等。
着色剂	甜菜红、姜黄、红曲红、胭脂虫红、苋菜红、胭脂红、日落黄、柠檬黄、新红、诱惑红、赤藓红、亮蓝、靛蓝等，多用于果汁饮料等。
护色剂	亚硝酸钠、亚硝酸钾、硝酸钠、硝酸钾(绿色食品中禁止使用)，比如加工肉类。
甜味剂	糖精、糖精钠、甜蜜素、安赛蜜、三氯蔗糖、阿斯巴甜，常见于一些甜味的加工食品中，比如饮料、面包等。
增稠剂	阿拉伯胶、卡拉胶、果胶、琼胶、海藻酸类、甲壳素、瓜尔胶、黄原胶、明胶、干酪素、壳聚糖、羧甲基纤维素钠，比如酸奶等一些黏稠的食品中。
凝固剂	硫酸钙、氯化钙、氯化镁、丙二醇主要用于豆制品生产和果蔬深加工，以及凝胶食品的制造。
膨松剂	碳酸氢钠、碳酸氢铵、硫酸铝钾，膨松剂主要用于饼干、糕点生产。
水分保持剂	乳化盐、甘油、丙二醇、麦芽糖精、山梨糖醇等广泛地用于食品加工，肉类制品中保持肉的持水性增加肉的柔嫩性，防止啤酒和饮料等浑浊。

mysql中的查询计划及sql语句性能分析

Mon, 22 Aug 2022 03:39:24 GMT

准备测试数据

CREATE TABLE `employee` (   `id` int NOT NULL AUTO_INCREMENT,   `name` varchar(20) DEFAULT NULL,   `dep_id` int DEFAULT NULL,   `age` int DEFAULT NULL,   `salary` decimal(10,2) DEFAULT NULL,   `cus_id` int DEFAULT NULL,   PRIMARY KEY (`id`) USING BTREE ) ENGINE=InnoDB  AUTO_INCREMENT=1  DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;  CREATE TABLE `customer` (   `id` int NOT NULL,   `name` varchar(255) DEFAULT NULL,   PRIMARY KEY (`id`) USING BTREE ) ENGINE=InnoDB  AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;  CREATE TABLE `department` (   `id` int NOT NULL AUTO_INCREMENT,   `deptName` varchar(30) DEFAULT NULL,   `address` varchar(40) DEFAULT NULL,   PRIMARY KEY (`id`) USING BTREE ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;     -- 测试数据 INSERT INTO employee VALUES ( 1, '鲁班', 1, 10, 1000.00, 1 ); INSERT INTO employee VALUES ( 2, '后裔', 1, 20, 2000.00, 1 ); INSERT INTO employee VALUES ( 3, '孙尚香', 1, 20, 2500.00, 1 ); INSERT INTO employee VALUES ( 4, '凯', 4, 20, 3000.00, 1 ); INSERT INTO employee VALUES ( 5, '典韦', 4, 40, 3500.00, 2 ); INSERT INTO employee VALUES ( 6, '貂蝉', 6, 20, 5000.00, 1 ); INSERT INTO employee VALUES ( 7, '孙膑', 6, 50, 5000.00, 1 ); INSERT INTO employee VALUES ( 8, '蔡文姬', 30, 35, 4000.00, 1 );   -- 测试数据  INSERT INTO department VALUES (1, '研发部(RD)', '2层');  INSERT INTO department VALUES (2, '人事部(HR)', '3层');  INSERT INTO department VALUES (3, '市场部(MK)', '4层');  INSERT INTO department VALUES (4, '后勤部(MIS)', '5层');  INSERT INTO department VALUES (5, '财务部(FD)', '6层');   -- 测试数据  INSERT INTO customer VALUES (1, 'zs');  INSERT INTO customer VALUES (2, 'lisi');  INSERT INTO customer VALUES (3, 'wangwu');

explain的简介

mysql中可以使用explain这个关键字来获取（查询）sql语句的查询执行计划的。使用explain关键字，可以模拟mysql优化器执行的sql语句，从而知道mysql是如何处理sql语句的。通过explain可以分析查询语句或表结构的性能瓶颈。

explain的作用

①、查看表的读取顺序

②、数据读取操作的操作类型

③、查看哪些索引可以使用

④、查看哪些索引被实际使用

⑤、查看表之间的引用

⑥、查看每张表有多少行被优化器执行

explain的使用方法

explain sql语句

explain select * from employee;

explain执行计划输出中的各个列的详解

id

描述：select查询的序列号,包含一组数字，该组数字表示查询中执行select子句或操作表的顺序

id值的三种情况如下：

id相同

-- 分析的sql语句 explain select * from employee e,department d,customer c where e.dep_id = d.id and e.cus_id = c.id;

分析的结果截图：

从上图中可以看到，id列的值都是1。那么该条sql语句的执行顺序是由上到下，也就是说先查询的c表然后查询 e表最后查询d表。

id不同

-- 分析的sql语句 EXPLAIN SELECT * from department  WHERE id = (SELECT id from employee WHERE id= (SELECT id from customer WHERE id = 1) )

从上图中可以看到，id列的值是1、2、3。那么该条sql语句的执行顺序是从大到小（由下到上），也就是说 id列的值是3的先执行其次是id列的值是2 最后是id列的值是1再执行。

这里都是子查询，如果是子查询，id的序号会递增，id值越大优先级越高，优先被执行。**

id相同和不同

-- 分析的sql语句 EXPLAIN  SELECT * FROM department d, ( SELECT * FROM employee GROUP BY dep_id ) t WHERE d.id = t.dep_id;

从上图中可以看到，id列的值是1、1、2。那么该条sql语句的执行顺序是怎样的呢？根据上面的①和②这里应该也能猜到了。该条sql语句的执行顺序是先执行id列的值是2的，其次执行id列的值是1的（最上面那个id列的值是1的，也就是table列的值是d），最后执行中间那个id列的值是1的。

上图中有一个select_type列，其中select_type有一列的值是derived，而derived表示衍生出来的虚表。再次说明，id值越大，优先级越高，越先执行。

总结

相同，顺序走（由上到下）,不同，看谁大，大的先执行。

select_type

**描述：**查询类型，主要用于区别普通查询，联合查询，子查询等复杂查询。

select_type列的值主要有以下6种情况：

①、SIMPLE：简单的select查询，查询中不包含子查询或者UNION

②、PRIMARY：查询中若包含任何复杂的子查询，那么最外层的查询则被标记为primary

③、SUBQUERY：在select或where中包含了子查询

④、DERIVED：在from列表中包含的子查询被标记为derived(衍生)，把结果放在临时表当中。

⑤、UNION：若第二个select出现在union之后，则被标记为union。若union包含在from子句的子查询中，外层select将被标记为deriver。

⑥、UNION RESULT：从union表获取结果select。两个UNION合并的结果集在最后。

table

**描述：**显示当前查询的数据是关于哪张表的。

partitions

描述：如果查询是基于分区表的话，会显示查询访问的分区。

type（重要）

描述：

表示访问某个表的类型。更专业一点的解释就是：type代表着mysql对某个表的执行查询时的访问方法，其中type列的值就表明了这个访问方法是个啥。通过type可以知道mysql是做了全表扫描还是范围扫描等，从而知道当前的sql语句到底要不要去优化。

type列的值一般最常用的有7种，按照最好到最差来排序分别是：system>const>eq_ref>ref>range>index>ALL。

system

表中只有一条记录，并且该表使用的存储引擎的统计数据是精确的，比如MyISAM、Memory，那么该表的type列的值就是system。这是const类型的特例，平时不会出现，也不用奢求将sql优化到这种级别的。

const

表示通过索引（主键索引或唯一索引）一次就找到了那一条数据。这里和上面那个system的区别就是 system表里面只能有一条数据，而const表示表中可能会有多条数据，但是const能直接从多条数据中直接定位到那一条数据（通过主键索引或唯一索引）。因为只匹配一行数据，所以const速度很快。

eq_ref

唯一性索引扫描。对于每个索引键，表中只有一条记录与之匹配。常见于主键或唯一索引扫描。

employee表中有五条数据，而department表中有对应的五条数据，其中employee的id（主键索引）和department的id（主键索引）是一一对应的，所以这里就会出现eq_ref，eq_ref也就是这个意思。

eq_ref基本上很难在单表上出现，一般都是在多表的情况下才会出现eq_ref。

ref

非唯一性索引扫描。大白话解释一下就是：出现该连接类型的条件是，查找条件列使用了索引而且不是使用的主键索引和唯一索引（unique），使用的是普通索引。其实，意思就是虽然使用了索引，但该索引列的值并不唯一，有重复。这样即使使用索引快速查找到了第一条数据，仍然不能停止扫描，要进行目标值附近的小范围扫描。但它的好处是它并不需要扫全表，因为索引是有序的，即便有重复值，也是在一个非常小的范围内扫描。下面为了演示这种情形，给employee表中的age列添加一个普通的索引

ALTER TABLE employee ADD INDEX idx_age(age) USING BTREE;

range

指的是有范围的索引扫描，相对于index的全索引扫描，它有范围限制，因此要优于index。关于range比较容易理解，需要记住的是出现了range，则一定是基于索引的。一般就是在你的where语句中出现between，and，<，>，or，in等查询，那么type列的值就是range

index

Full Index Scan。index与All区别为index类型只遍历索引树，通常比All要快，因为索引文件通常比数据文件要小。all和index都是读全表，但index是从索引中读取，all是从硬盘当中读取。

ALL

将表中的所有数据进行了扫描（全表扫描），从硬盘当中读取数据。如果出现了All 且数据量非常大，那么该条sql必须去做优化的。

说下要求：一般来说，要保证SQL查询至少达到range级别，最好能达到ref级别。

possible_keys

**描述：**表示这张表中可能会用到的索引（一个或多个），查询涉及到的字段上若存在索引，则该索引将被列出，但不一定被查询实际使用到，可能自己创建了4个索引，在实际执行sql查询的时候，根据mysql内部的自动判断，只使用了3个。

key（重要）

**描述：**mysql在执行的时候实际使用到的索引，如果为NULL，则没有使用索引。

其它说明：

查询中若使用了覆盖索引，则该索引仅出现在key列表中。

覆盖索引：查询的字段和建立的字段刚好吻合，这种我们称为覆盖索引。

possible_keys与key关系：前者表示理论应该用到哪些索引，后者表示实际用到了哪些索引。

key_len

**描述：**表示索引中使用的字节数，可通过该列计算查询中使用的索引长度。下面为了演示这种情形，给employee表添加一个复合索引。

ALTER TABLE employee ADD INDEX idx_name_dep_id_age(name, dep_id, age) USING BTREE;

ref

描述：

索引是否被引入到，到底引用到了哪几个索引。

这里就不写加索引的语句了，直接上几张截图看吧

rows

描述：

根据表的统计信息及索引选用情况，大致估算出找到所需的记录所需要扫描（读取）的行数。表有多少行被优化器查询过。没有建立索引和建立索引之后 rows所显示的数据肯定是不一样的。这里就不进行截图演示了。

filtered

**描述：**满足查询的记录数量的比例，注意是百分比，不是具体记录数，值越大越好，filtered列的值依赖统计信息，并不十分准确。对于单表查询来说，这个filtered列的值没什么意义，更关注在连接查询中对应的执行计划记录的filtered列的值。关于这里的多表demo也就先不演示了。

Extra

**描述：**顾名思义，Extra列是用来说明一些额外信息的，可以通过这些额外信息来更准确的理解mysql到底将如何执行给定的查询语句。mysql提供的额外信息有好几十个，这里就不一个一个介绍了，只挑一些平时常见的或者比较重要的做下说明。

①、Using filesort：专业术语成为“文件排序”。说明mysql会对数据使用一个外部的索引排序，而不是按照表内的索引顺序进行。mysql无法利用索引完成排序操作称为"文件排序"，当你看到using filesort的时候，那么一定要优化该条sql语句。（得到所需结果集，需要对所有记录进行"文件排序" 出现这个表示该条SQL语句性能较低，需要进行优化）

**关于filesort的更多详解：**filesort 并不是说通过磁盘文件进行排序，而只是告诉我们进行了一个排序操作。文件排序是通过相应的排序算法，将取得的数据在内存中进行排序。mysql需要将数据在内存中进行排序，所使用的内存区域也就是我们通过 sort_buffer_size 系统变量所设置的排序区。这个排序区是每个 Thread 独享的，所以说可能在同一时刻在mysql中可能存在多个 sort buffer 内存区域。

filesort分两种：

双路排序：是首先根据相应的条件取出相应的排序字段和可以直接定位行数据的行指针信息，然后在sort buffer 中进行排序。排序后再吧查询字段依照行指针取出，共执行两次磁盘io。

单路排序：是一次性取出满足条件行的所有字段，然后在sort buffer中进行排序。执行一次磁盘io。

在mysql4.1版本之前只有第一种排序算法双路排序。第二种算法是从mysql4.1开始的改进算法，主要目的是为了减少第一次算法中需要两次访问表数据的 IO 操作，将两次变成了一次，但相应也会耗用更多的sort buffer 空间。当然，mysql4.1开始的以后所有版本同时也支持第一种算法。

典型说明：在一个没有建立索引的列上进行了order by，就会触发filesort，常见的优化方案是，在order by的列上添加索引，避免每次查询都全量排序。

Using filesort示例截图：

②、Using temporary：在许多查询的执行过程中，mysql可能会借助临时表来完成一些功能，比如去重、排序之类的，比如我们在执行许多包含DISTINCT、GROUP BY、UNION等子句的查询过程中，如果不能有效利用索引来完成查询，mysql很有可能寻求通过建立内部的临时表来执行查询。如果查询中使用到了内部的临时表，在执行计划的Extra列将会显示using temporary提示。当你看到using temporary的时候，那么一定要优化该条sql语句。（需要建立临时表(temporary table)来暂存中间结果，出现这个表示该条SQL语句性能较低，通常情况下需要进行优化）

③、Useing index：表示相应的select中使用了覆盖索引，避免访问了表中的数据行，效率很好。如果同时出现了Using where 表明索引被用来执行索引键值的查找。如果没有同时出现Using where 表明索引用来读取数据而非执行查找动作。（SQL所需要返回的所有列数据均在一棵索引树上，而无需访问实际的行记录，出现这个表示该条SQL语句性能较好）

示例截图：

using index示例截图如下：

using where using index示例截图如下：

④、Using where：说明使用了where过滤（SQL使用了where条件过滤数据需要需要优化该条SQL语句需要配合explain结果中的type（连接类型）来综合判断）

⑤、Using join buffer(Block Nested Loop)：在连接查询执行过程中，当sql查询语句不能有效的利用索引加快访问速度，mysql选择退而求其次，一般会为其分配一块名叫join buffer的内存块来加快查询速度，也就是我们所讲的基于块的嵌套循环算法。（需要进行嵌套循环计算出现这个表示该条SQL语句性能较低，需要进行优化）

打个比方：内层和外层的type均为ALL，rows均为4，需要循环进行4*4次计算。

典型说明：两个关联表join，关联字段均未建立索引，就会出现这种情况。常见的优化方案是，在关联字段上添加索引，避免每次嵌套循环计算。

⑥、impossible where：where子句中的值总是false 获取不到任何数据。出现这种提示通常情况下说明你的sql语句有误，请看情况选择是否进行修改相应的sql语句。

⑦、Using index condition：确实命中了索引，但不是所有的列数据都在索引树上，还需要访问实际的行记录。（出现这个表示该条SQL语句性能也较高，但不如Using index）

MySQL方法GROUP_CONCAT的应用

Fri, 19 Aug 2022 08:33:00 GMT

MySQL方法GROUP_CONCAT的应用，多对多联表查询，以A表为主表，通过关联表C查询出B表关联A表任意记录的多条记录的某个字段的合并值

开发中遇到这样的一个需求：用户表为A，角色表为B，用户角色关系通过C表多对多关联，我们需要查询出每一个用户所拥有的角色，以下图的格式显示：

用户ID	用户姓名	拥有角色
1	小明1	角色1,角色4,角色5,角色6...
2	小明2	角色1,角色4,角色5,角色6...

-- 用户表 CREATE TABLE `sys_user` (   `user_id` int NOT NULL AUTO_INCREMENT COMMENT '用户ID',   `user_name` varchar(50) NOT NULL COMMENT '用户姓名',   `user_age` varchar(3) DEFAULT NULL COMMENT '用户年龄',   `creater` varchar(255) DEFAULT NULL COMMENT '创建人',   `create_time` datetime DEFAULT NULL COMMENT '创建时间',   `updater` varchar(50) DEFAULT NULL COMMENT '更新人',   `update_time` datetime DEFAULT NULL COMMENT '更新时间',   PRIMARY KEY (`user_id`) )  ENGINE=InnoDB AUTO_INCREMENT=1  COMMENT='用户表';  -- 角色表 CREATE TABLE  `sys_role`  (   `role_id` int NOT NULL AUTO_INCREMENT COMMENT '角色ID',   `role_name` varchar(50) NOT NULL COMMENT '角色名称',   `creater` varchar(50) NULL COMMENT '创建人',   `create_time` datetime NULL COMMENT '创建时间',  `updater` varchar(50) NULL COMMENT '更新人',   `update_time` datetime NULL COMMENT '更新时间',   PRIMARY KEY (`role_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1    COMMENT='角色表';  -- 用户角色关系表 CREATE TABLE  `sys_user_role`  (   `user_role_id` int NOT NULL AUTO_INCREMENT COMMENT '用户角色关系ID',   `role_id` varchar(50) NOT NULL COMMENT '角色ID',  `user_id` varchar(50) NOT NULL COMMENT '用户ID',   PRIMARY KEY (`user_role_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1   COMMENT='用户角色关系表';  -- 插入模拟数据 start create procedure insert8() begin declare i int default 0;  repeat  INSERT INTO sys_role(role_name,creater,create_time,updater,update_time)select role_name,   creater, create_time, updater,update_time from sys_role UNION ALL select '角色','1',NOW(),'1', NOW() from dual ; INSERT INTO sys_user(user_name,user_age,creater,create_time,updater,update_time) select  user_name,user_age,creater,create_time, updater,update_time from sys_user UNION ALL select '小明','10','1',NOW(),'1',NOW() from dual ; set i=i+1; until i>8 end repeat;  end; call insert8;  drop procedure if exists insert8;    INSERT INTO  sys_user_role (role_id, user_id )  select   role_id, user_id from sys_role INNER JOIN sys_user ;  update sys_user set user_name=REPLACE(user_name,user_name,CONCAT( user_name,user_id) ); update sys_role set role_name=REPLACE(role_name,role_name,CONCAT(role_name,role_id) ); -- 插入模拟数据 end  -- 测试完毕删除数据 drop table sys_user; drop table sys_role; drop table sys_user_role;

在解决问题中发现了两种方式可实现该功能

方式一

 SELECT su.user_id AS userId,su.user_name AS userName,     (         SELECT  GROUP_CONCAT(sr.role_name)         FROM sys_user_role sur         LEFT JOIN sys_role sr ON sr.role_id = sur.role_id         WHERE sur.user_id = su.user_id     ) AS roleNames FROM sys_user su    ORDER BY  su.user_id

方式一是把查询c表作为主表，并且left join B表的一个子查询，查出每一个用户id拥有的角色名称拼接结果作为拥有角色字段值的，我们看看其查询性能

查询时间：56.088s   共511条

可见查询22条左右数据需要4秒多，这种速度我们显然是不能接受的，而且需要以拥有小区的名称做模糊查询时候也无从下手。于是后来继续想办法优化，就找到了下面的方式二。

方式二

SELECT su.user_id AS userId, su.user_name AS userName,temp.roleNames FROM sys_user su LEFT JOIN (     SELECT sur.user_id, GROUP_CONCAT(sur.role_id) AS roleIds,         GROUP_CONCAT(sr.role_name) AS roleNames     FROM sys_user_role sur      LEFT JOIN sys_role sr ON sr.role_id = sur.role_id     GROUP BY sur.user_id ) temp ON temp.user_id = su.user_id ORDER BY  su.user_id

方式二依然有一个查询用户拥有小区名称拼接结果的子查询，只是这个子查询不是直接作为结果字段返回，而是根据用户id为group规则查询出来每一个用户的拥有小区结果字符串，然后作为A表的left join的虚拟表，下面看一下测试结果

查询时间：0.657s   共511条

可见同样查询一万条数据一秒钟都不用，查询速度提高了至少20倍，而且因为是虚拟关联表，可以直接用 temp.roleNames like'%角色1%' 而实现模糊查询。

MySQL创建用户与授权

Fri, 12 Aug 2022 09:02:00 GMT

创建用户

CREATE USER 'username'@'host' IDENTIFIED BY 'password';

username：你将创建的用户名

host：指定该用户在哪个主机上可以登陆，如果是本地用户可用localhost，如果想让该用户可以从任意远程主机登陆，可以使用通配符%

password：该用户的登陆密码，密码可以为空，如果为空则该用户可以不需要密码登陆服务器

例子

CREATE USER 'dog'@'localhost' IDENTIFIED BY '123456'; CREATE USER 'pig'@'192.168.1.101_' IDENDIFIED BY '123456'; CREATE USER 'pig'@'%' IDENTIFIED BY '123456'; CREATE USER 'pig'@'%' IDENTIFIED BY ''; CREATE USER 'pig'@'%';

授权

GRANT privileges ON databasename.tablename TO 'username'@'host'

privileges：用户的操作权限，如SELECT，INSERT，UPDATE等，如果要授予所的权限则使用ALL

databasename：数据库名

tablename：表名，如果要授予该用户对所有数据库和表的相应操作权限则可用*表示，如*.*

例子

GRANT SELECT, INSERT ON test.user TO 'pig'@'%'; GRANT ALL ON *.* TO 'pig'@'%';

注意

用以上命令授权的用户不能给其它用户授权，如果想让该用户可以授权，用以下命令:
GRANT privileges ON databasename.tablename TO 'username'@'host' WITH GRANT OPTION; 

设置与更改用户密码

SET PASSWORD FOR 'username'@'host' = PASSWORD('newpassword');

如果是当前登陆用户用:

SET PASSWORD = PASSWORD("newpassword");

例子

SET PASSWORD FOR 'pig'@'%' = PASSWORD("123456");

撤销用户权限

REVOKE privilege ON databasename.tablename FROM 'username'@'host';

privilege, databasename, tablename：同授权部分

例子

REVOKE SELECT ON *.* FROM 'pig'@'%';

假如你在给用户'pig'@'%'授权的时候是这样的（或类似的）：GRANT SELECT ON test.user TO 'pig'@'%'，则在使用REVOKE SELECT ON *.* FROM 'pig'@'%';命令并不能撤销该用户对test数据库中user表的SELECT 操作。

相反，如果授权使用的是GRANT SELECT ON *.* TO 'pig'@'%';则REVOKE SELECT ON test.user FROM 'pig'@'%';命令也不能撤销该用户对test数据库中user表的Select权限。

具体信息可以用命令SHOW GRANTS FOR 'pig'@'%'; 查看。

删除用户

DROP USER 'username'@'host';

centos7 挂载未分配的硬盘空间

Thu, 14 Jul 2022 03:17:00 GMT

前言

最近在做提供虚拟机的工作时发现，vcenter的模板虽然可以快速创建出和模板一模一样的虚拟机，但是由于对硬盘的配置每个人的要求不同，vmware只支持扩大硬盘配置。

故在做模板时，硬盘设计的小些，然后根据每个人不同的需求再做磁盘的扩容就好了。

场景

虚拟机初始硬盘：16G

虚拟机扩容后硬盘：50G

需求：将扩容的34G空间增加到文件系统/dev/mapper/centos-root中

扩容文件系统

确认硬盘空间

列出块设备信息 lsblk

查看文件系统的硬盘使用

df -h

查看硬盘数量和分区情况

fdisk -l

对未分配的空间进行分区

创建新分区

fdisk /dev/sda

新建分区

输入“n”，回车；（n：新建分区）

主分区

不用输入，回车；（p：主分区）

设置扇区

下面几个选项不用输入，回车；

设置分区号

输入“t”，回车；接着不用输入，回车；（t：设置分区号）

设置分区格式

输入“L”，回车；接着输入“8e”，回车；（8e：指定分区格式为Linux LVM）

保存修改

输入“w”，回车；（w：保存修改）

重启虚拟机

reboot

查看新的分区情况（新的分区/dev/sda3）

fdisk -l

对目标分区扩容

创建物理卷

pvcreate /dev/sda3

添加物理卷

添加物理卷（/dev/sda3）到卷组（centos）

vgextend centos /dev/sda3

卷组属性

查看centos卷组的属性

vgdisplay

可以看到有不到34G的空闲空间可以扩展。

分配空间

将空闲的空间都分配给root文件系统

lvextend -l +100%FREE /dev/mapper/centos-root

扩容

对root文件系统执行扩容

xfs_growfs /dev/mapper/centos-root

查看扩容结果

df -h

IDEA 远程调试

Thu, 09 Jun 2022 02:32:00 GMT

IDEA 远程调试，像运行本地代码一样调试远程主机上的程序，以排查远程程序的BUG或代码执行流程。

概述

原理：本机和远程主机的两个 VM 之间使用 Debug 协议通过 Socket 通信，传递调试指令和调试信息。被调试程序的远程虚拟机：作为 Debug 服务端，监听 Debug 调试指令。jdwp是Java Debug Wire Protocol的缩写。调试程序的本地虚拟机：IDEA 中配置的 Remote Server，指定 Debug 服务器的Host:Port，以供 Debug 客户端程序连接。

设置

打开防火墙

#查看想开的端口是否已开： firewall-cmd --query-port=20400/tcp #添加指定需要开放的端口： firewall-cmd --add-port=20400/tcp --permanent #重载入添加的端口： firewall-cmd --reload #移除指定端口： firewall-cmd --permanent --remove-port=20400/tcp

远程服务中开启 Debug 服务

对于 SpringBoot命令行添加选项，并重启

java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=20400 -jar xxx.jar

对于 Tomcat 启动脚本中添加选项，并重启：

JAVA_OPTS="$JAVA_OPTS -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=20400"

IDEA 中指定 Debug 服务器

点击主窗口菜单 Run / Edit Configurations，打开“Run/Debug Configurations”窗口；
点击工具栏上的“+”按钮，下拉菜单中选择“Remote”或者“Remote JVM Debug”；
设置 Host 为远程服务器的域名或IP，设置端口 Port=20400；
复制命令行参数，形如 -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=20400 这个参数就是启动服务器项目时加的参数

build-helper-maven-plugin 简单讲解

Wed, 08 Jun 2022 06:20:00 GMT

简介

官方文档

https://www.mojohaus.org/build-helper-maven-plugin/index.html

常用的Goals

名称	说明
build-helper:add-source	添加一个或者多个目录到POM.
build-helper:add-test-source	添加测试目录到 POM.
build-helper:add-resource	添加资源目录到POM.
build-helper:add-test-resource	添加测试资源目录到POM.
build-helper:attach-artifact	附加要安装和部署的其他部件。
build-helper:maven-version	设置一个包含当前版本的 maven 的属性。
build-helper:regex-property	通过将正则表达式替换规则应用于提供的值来设置属性。
build-helper:regex-properties	通过将正则表达式替换规则应用于提供的值来设置属性.
build-helper:released-version	解决本项目最新发布的版本.
build-helper:parse-version	将版本解析为不同的属性.
build-helper:remove-project-artifact	从本地存储库中删除项目的工件.
build-helper:reserve-network-port	保留随机和未使用的网络端口列表.
build-helper:local-ip	检索当前主机 IP 地址.
build-helper:hostname	检索当前主机名.
build-helper:cpu-count	检索可用 CPU 的数量.
build-helper:timestamp-property	根据当前日期和时间设置属性.
build-helper:uptodate-property	根据文件集的输出相对于其输入是否是最新的来设置属性.
build-helper:uptodate-properties	根据多个文件集的输出相对于它们的输入是否是最新的来设置多个属性.
build-helper:rootlocation	设置定义多模块构建的根文件夹的属性.

简单用法

<project>     <build>     <plugins>   <!--独立打包-->              <plugin>                 <groupId>org.springframework.boot</groupId>                 <artifactId>spring-boot-maven-plugin</artifactId>                 <version>2.1.1.RELEASE</version>                 <configuration>                     <fork>true</fork> <!-- 如果没有该配置，devtools不会生效 -->                 </configuration>                 <executions>                     <execution>                         <goals>                             <goal>repackage</goal>                         </goals>                     </execution>                 </executions>             </plugin>  <!-- domain 打包进去-->       <plugin>         <groupId>org.codehaus.mojo</groupId>         <artifactId>build-helper-maven-plugin</artifactId>         <version>3.3.0</version>         <executions>           <execution>             <!--id是必须的，常常和goals是一样的-->             <id>add-source</id>             <phase>generate-sources</phase>             <goals>               <goal>add-source</goal>             </goals>             <!--在configuration中设置goals的具体属性-->             <configuration>               <!--这些熟悉可以通过文档获得-->               <sources>                 <source>${basedir}/src/main/java</source>                 <source>${basedir}/src/main/domain</source>                 ...               </sources>             </configuration>           </execution>           <!--在比如下面的，可以获得当前时间-->           <execution>             <id>timestamp-property</id>             <goals>               <goal>timestamp-property</goal>             </goals>               <configuration>                   <name>current.time</name>                   <pattern>yyyyMMddHHmmss</pattern>                   <timeZone>GMT+8</timeZone>               </configuration>           </execution>         </executions>       </plugin>     </plugins>   </build> </project>

获得当前时间的那个，可以通过configuration的name在pom的其他地方通过${current.time}来引用当前时间

ThinkPad系列 win10系统没有声音问题完美解决

Wed, 25 May 2022 02:05:00 GMT

首先说明一下自己电脑的情况，，在thinkpad官网下载安装好声卡驱动后还是没有声音，检测的时候也会根据声音大小跳动，我测试蓝牙耳机连接后声音没问题，一度让我怀疑我的笔记本扬声器坏了，

最近疫情严重了大家都居家隔离都在家办公，经常有开会分享屏幕，手机接听就太小屏幕看不见，电脑接听没有声音，让我企业微信分享屏幕，个人微信开启语音聊天。。。。。。,后来发现笔记本电脑上f1键亮着上面有个小喇叭，想关也关不掉了不废话了看怎么解决的。

下载驱动

去联想官网下载对应电脑型号的声卡驱动，官网地址：驱动下载_ThinkPad服务网站-联想服务，进入联想thinkpad官网后找到服务里面的驱动下载选项，然后点击进去，如下图:、

然后会进入到下个界面，如下图：

在这个界面，要下搜索框里输入自己的电脑主机编号，电脑主机编号一般都在电脑的背面有显示，或者在页面下方选择自己的电脑型号进去相应的驱动页面进行下载，要不然下载个联想驱动管理也可以查看自己的电脑型号，然后才能进入到自己电脑型号所对应的所有驱动的下载的地方，一般来说都是最新版的驱动，如下图：

在这个界面就可以下载需要的驱动了，就是这个版本的声卡驱动，下载下来，直接运行安装就OK了，安装完驱动后，重启电脑才有效果。后来经过我的实践证明，只安装这个版本的声卡驱动是没有效果的，还是没有声音，必须要安装上图里的热键驱动才可以。

就这样，去联想官网下载对应版本的声卡驱动，还有热键驱动，安装后重启电脑，就有声音了。

其他问题可以参照修复 Windows 10 中的声音问题

logback 配置文件

Wed, 04 May 2022 11:38:06 GMT

<?xml version="1.0" encoding="UTF-8"?> <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 --> <!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true --> <!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。 当scan为true时，此属性生效。默认的时间间隔为1分钟。 --> <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 --> <configuration scan="true" scanPeriod="60 seconds"  debug="false">  <!-- contextName:用来设置上下文名称，每个logger都关联到logger上下文，默认上下文名称为default。但可以使用<contextName>设置成其他名字，用于区分不同应用程序的记录。一旦设置，不能修改。-->   <contextName>myApp</contextName>   <!-- <springProperty scope="context" name="logPath" source="logging.path"    defaultValue="logs"/> -->  <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后，可以使“${}”来使用变量。 -->  <property name="log.path" value="logs/" />   <!--0. 日志格式和颜色渲染 -->  <!-- 彩色日志依赖的渲染类 -->  <conversionRule conversionWord="clr"   converterClass="org.springframework.boot.logging.logback.ColorConverter" />  <conversionRule conversionWord="wex"   converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />  <conversionRule conversionWord="wEx"   converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />  <!-- 彩色日志格式 -->  <property name="CONSOLE_LOG_PATTERN"   value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH🇲🇲ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />   <!--1. 输出到控制台 -->  <appender name="CONSOLE"   class="ch.qos.logback.core.ConsoleAppender">   <!-- 此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息 -->   <filter class="ch.qos.logback.classic.filter.ThresholdFilter">    <level>debug</level>   </filter>   <encoder>    <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>    <!-- 设置字符集 -->    <charset>UTF-8</charset>   </encoder>  </appender>     <!--2. 输出到文档 -->  <!-- 2.1 level为 DEBUG 日志，时间滚动输出 -->  <appender name="DEBUG_FILE"   class="ch.qos.logback.core.rolling.RollingFileAppender">   <!-- 正在记录的日志文档的路径及文档名 -->   <file>${log.path}/web_debug.log</file>   <!--日志文档输出格式 -->   <encoder>    <pattern>%d{yyyy-MM-dd HH🇲🇲ss.SSS} [%thread] %-5level %logger{50} -     %msg%n</pattern>    <charset>UTF-8</charset> <!-- 设置字符集 -->   </encoder>   <!-- 日志记录器的滚动策略，按日期，按大小记录 -->   <rollingPolicy    class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">    <!-- 日志归档 -->    <fileNamePattern>${log.path}/web-debug-%d{yyyy-MM-dd}.%i.log    </fileNamePattern>    <timeBasedFileNamingAndTriggeringPolicy     class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">     <maxFileSize>100MB</maxFileSize>    </timeBasedFileNamingAndTriggeringPolicy>    <!--日志文档保留天数 -->    <maxHistory>15</maxHistory>   </rollingPolicy>   <!-- 此日志文档只记录debug级别的 -->   <filter class="ch.qos.logback.classic.filter.LevelFilter">    <level>debug</level>    <onMatch>ACCEPT</onMatch>    <onMismatch>DENY</onMismatch>   </filter>  </appender>   <!-- 2.2 level为 INFO 日志，时间滚动输出 -->  <appender name="INFO_FILE"   class="ch.qos.logback.core.rolling.RollingFileAppender">   <!-- 正在记录的日志文档的路径及文档名 -->   <file>${log.path}/web_info.log</file>   <!--日志文档输出格式 -->   <encoder>    <pattern>%d{yyyy-MM-dd HH🇲🇲ss.SSS} [%thread] %-5level %logger{50} -     %msg%n</pattern>    <charset>UTF-8</charset>   </encoder>   <!-- 日志记录器的滚动策略，按日期，按大小记录 -->   <rollingPolicy    class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">    <!-- 每天日志归档路径以及格式 -->    <fileNamePattern>${log.path}/web-info-%d{yyyy-MM-dd}.%i.log    </fileNamePattern>    <timeBasedFileNamingAndTriggeringPolicy     class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">     <maxFileSize>100MB</maxFileSize>    </timeBasedFileNamingAndTriggeringPolicy>    <!--日志文档保留天数 -->    <maxHistory>15</maxHistory>   </rollingPolicy>   <!-- 此日志文档只记录info级别的 -->   <filter class="ch.qos.logback.classic.filter.LevelFilter">    <level>info</level>    <onMatch>ACCEPT</onMatch>    <onMismatch>DENY</onMismatch>   </filter>  </appender>   <!-- 2.3 level为 WARN 日志，时间滚动输出 -->  <appender name="WARN_FILE"   class="ch.qos.logback.core.rolling.RollingFileAppender">   <!-- 正在记录的日志文档的路径及文档名 -->   <file>${log.path}/web_warn.log</file>   <!--日志文档输出格式 -->   <encoder>    <pattern>%d{yyyy-MM-dd HH🇲🇲ss.SSS} [%thread] %-5level %logger{50} -     %msg%n</pattern>    <charset>UTF-8</charset> <!-- 此处设置字符集 -->   </encoder>   <!-- 日志记录器的滚动策略，按日期，按大小记录 -->   <rollingPolicy    class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">    <fileNamePattern>${log.path}/web-warn-%d{yyyy-MM-dd}.%i.log    </fileNamePattern>    <timeBasedFileNamingAndTriggeringPolicy     class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">     <maxFileSize>100MB</maxFileSize>    </timeBasedFileNamingAndTriggeringPolicy>    <!--日志文档保留天数 -->    <maxHistory>15</maxHistory>   </rollingPolicy>   <!-- 此日志文档只记录warn级别的 -->   <filter class="ch.qos.logback.classic.filter.LevelFilter">    <level>warn</level>    <onMatch>ACCEPT</onMatch>    <onMismatch>DENY</onMismatch>   </filter>  </appender>   <!-- 2.4 level为 ERROR 日志，时间滚动输出 -->  <appender name="ERROR_FILE"   class="ch.qos.logback.core.rolling.RollingFileAppender">   <!-- 正在记录的日志文档的路径及文档名 -->   <file>${log.path}/web_error.log</file>   <!--日志文档输出格式 -->   <encoder>    <pattern>%d{yyyy-MM-dd HH🇲🇲ss.SSS} [%thread] %-5level %logger{50} -     %msg%n</pattern>    <charset>UTF-8</charset> <!-- 此处设置字符集 -->   </encoder>   <!-- 日志记录器的滚动策略，按日期，按大小记录 -->   <rollingPolicy    class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">    <fileNamePattern>${log.path}/web-error-%d{yyyy-MM-dd}.%i.log    </fileNamePattern>    <timeBasedFileNamingAndTriggeringPolicy     class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">     <maxFileSize>100MB</maxFileSize>    </timeBasedFileNamingAndTriggeringPolicy>    <!--日志文档保留天数 -->    <maxHistory>15</maxHistory>   </rollingPolicy>   <!-- 此日志文档只记录ERROR级别的 -->   <filter class="ch.qos.logback.classic.filter.LevelFilter">    <level>ERROR</level>    <onMatch>ACCEPT</onMatch>    <onMismatch>DENY</onMismatch>   </filter>  </appender>    <!-- <logger>用来设置某一个包或者具体的某一个类的日志打印级别、 以及指定<appender>。<logger>仅有一个name属性，    一个可选的level和一个可选的addtivity属性。 name:用来指定受此logger约束的某一个包或者具体的某一个类。 level:用来设置打印级别，大小写无关：TRACE,    DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。    如果未设置此属性，那么当前logger将会继承上级的级别。 addtivity:是否向上级logger传递打印信息。默认是true。 <logger    name="org.springframework.web" level="info"/> <logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor"    level="INFO"/> -->   <!-- 使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：    第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息    第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别： 【logging.level.org.mybatis=debug    logging.level.dao=debug】 -->   <!-- root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性 level:用来设置打印级别，大小写无关：TRACE,    DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 不能设置为INHERITED或者同义词NULL。默认是DEBUG 可以包含零个或多个元素，标识这个appender将会添加到这个logger。 -->       <!-- 常用logger配置 --> <!-- show parameters for hibernate sql 专为 Hibernate 定制 --> <logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE" /> <logger name="org.hibernate.type.descriptor.sql.BasicExtractor" level="DEBUG" /> <logger name="org.hibernate.SQL" level="DEBUG" /> <logger name="org.hibernate.engine.QueryParameters" level="DEBUG" /> <logger name="org.hibernate.engine.query.HQLQueryPlan" level="DEBUG" />  <!--myibatis log configure--> <logger name="com.apache.ibatis" level="TRACE"/> <logger name="java.sql.Connection" level="DEBUG"/> <logger name="java.sql.Statement" level="DEBUG"/> <logger name="java.sql.PreparedStatement" level="DEBUG"/>   <!--打印sql配置--> <logger name="cn.maruifu.myAppName.module.dao" level="DEBUG"/>     <!-- 4. 最终的策略 -->  <!-- 4.1 开发环境:打印控制台 -->  <springProfile name="dev">   <root level="info">    <appender-ref ref="CONSOLE" />   </root>  </springProfile>    <!-- 4.2 生产环境:输出到文档 -->  <springProfile name="prod">   <root level="info">    <appender-ref ref="CONSOLE" />    <appender-ref ref="DEBUG_FILE" />    <appender-ref ref="INFO_FILE" />    <appender-ref ref="WARN_FILE" />    <appender-ref ref="ERROR_FILE" />   </root>  </springProfile>  </configuration>

十年老架构师总结：性能优化其实不难，记住这十条策略就够了

Wed, 04 May 2022 11:09:00 GMT

我们聊了性能优化的六大原则。原则有了，但是在针对实际的性能问题的时候，用什么样的解决方案才可以提升性能呢？这就需要你了解具体的优化策略了。

现实中的性能问题和具体领域千差万别，我也不可能面面俱到。但是为了帮助你理解，我总结了十大常用的优化策略。

我将这十大策略分成五个类别，每个类别对应两个相关策略，帮助你掌握。这五个类别是：时空相互转换、并行 / 异步操作、预先 / 延后处理、缓存 / 批量合并、算法设计和数据结构。我们现在一个个来讲。

一、时空转换

第一个策略类别是“时空转换”。我们看科幻电影和小说的时候，经常会看到时空转换这个题材。性能优化里面有两个策略恰好组成了这个类别，包括“用时间换空间”和“用空间换时间”这两个看似互相对立的策略。

1. 用时间换空间

用时间换空间的策略，出发点是内存和存储这样的“空间”资源，有时会成为最稀缺的资源，所以需要尽量减少占用的空间。比如，一个系统的最大性能瓶颈如果是内存使用量，那么减少内存的使用就是最重要的性能优化。

这个策略具体的操作方法有几种：

改变应用程序本身的数据结构或者数据格式，减少需要存储的数据的大小；
想方设法压缩存在内存中的数据，比如采用某种压缩算法，真正使用时再解压缩；
把一些内存数据，存放到外部的、更加便宜的存储系统里面，到需要时再取回来。

这些节省内存空间的方法，一般都需要付出时间的代价。

除了内存，还有一种常见的场景是，降低数据的大小来方便网络传输和外部存储。压缩的方法和算法有很多种，比如现在比较流行的 ZStandard（ZSTD）和 LZ4。这些算法之间有空间和时间的取舍。

衡量任何压缩算法，基本上看三个指标：压缩比例、压缩速度以及使用内存。

如果系统的瓶颈在网络传输速度或者存储空间大小上，那就尽量采取高压缩比的算法，这样用时间来换空间，就能够节省时间或者其他方面的成本。

2. 用空间换时间

“用空间换时间”就是对“用时间换空间”策略反其道而行之。有些场景下，时间和速度更加重要，但是空间尚有富余，这时我们就可以考虑用空间来换时间。

这里要注意的一点是，我们后面还会讲一条关于使用缓存的策略。虽然缓存的策略理论上也是一种“空间换时间”的方式，但我们在这里把它分开来讲，这是因为缓存策略的“空间”定义与一般的“空间换时间”不同。一般来讲，“缓存”使用的空间，和原来的空间不在同一个层次上，添加的缓存往往比原来的空间高出一个档次。而我们这里“空间换时间”的策略，里面的“空间”是和原来的空间相似的空间。

互联网的服务往往规模很大，比如全国的服务甚至是全球的服务。用户分布在各地，它们对访问时间的要求很高，这就要求被访问的数据和服务，要尽量放在离他们很近的地方。“空间换时间”就是对数据和服务进行多份拷贝，尽可能地完美覆盖大多数的用户。我们前面讲过的 CDN 内容分发网络技术就可以归类于此。

其实我们部署的任何大规模系统，都或多或少地采用了用空间换时间的策略，比如在集群和服务器间进行负载均衡，就是同时用很多个服务器（空间）来换取延迟的减少（时间）。

二、预先和延后处理

优化策略的第二大类是“预先和延后处理”，这一类别也有两个互相对立的策略。一个是预先或者提前处理，另外一个是延后或者惰性处理。

3. 预先 / 提前处理

预先 / 提前处理策略同样也表现在很多领域，比如网站页面资源的提前加载。Web 标准规定了至少两种提前加载的方式：preload 和 prefetch，分别用不同的优先级来加载资源，可以显著地提升页面下载性能。

很多文件系统有预读的功能，就是提前从磁盘读取额外的数据，为下次上层应用程序读数据做准备。这个功能对顺序读取非常有效，可以明显地减少磁盘请求的数量，从而提升读数据的性能。

CPU 和内存也有相应的预取操作，就是将内存中的指令和数据，提前存放到缓存中，从而加快处理器执行速度。缓存预取可以通过硬件或者软件实现，也就是分为硬件预取和软件预取两类。

硬件预取是通过处理器中的硬件来实现的。该硬件会一直监控正在执行程序中请求的指令或数据，并且根据既定规则，识别下一个程序需要的数据或指令并预取。

软件预取是在程序编译的过程中，主动插入预取指令（prefetech），这个预取指令可以是编译器自己加的，也可以是我们加的代码。这样在执行过程中，在指定位置就会进行预取的操作。

4. 延后 / 惰性处理

延后 / 惰性处理策略和前面说的预先 / 提前处理正好相反。就是尽量将操作（比如计算），推迟到必需执行的时刻，这样很可能避免多余的操作，甚至根本不用操作。

运用这一策略最有名的例子，就是 COW（Copy On Write，写时复制）。假设多个线程都想操作一份数据，一般情况下，每个线程可以自己拷贝一份，放到自己的空间里面。但是拷贝的操作很费时间。系统如果采用惰性处理，就会将拷贝的操作推迟。如果多个线程对这份数据只有读的请求，那么同一个数据资源是可以共享的，因为“读”的操作不会改变这份数据。当某个线程需要修改这一数据时（写操作），系统就将资源拷贝一份给该线程使用，允许改写，这样就不会影响别的线程。

COW 最广为人知的应用场景有两个。一个是 Unix 系统 fork 调用产生的子进程共享父进程的地址空间，只有到某个子进程需要进行写操作才会拷贝一份。另一个是高级语言的类和

容器，比如 Java 中的 CopyOnWrite 容器，用于多线程并发情况下的高效访问。C++ 里面经常使用的 STL 标准模板库中的很多类，比如 string 类，也是具有写时才拷贝技术的类。

三、并行 / 异步操作

优化策略的第三大类是“并行 / 异步操作”。并行和异步两种操作虽然看起来很不一样，其实有异曲同工之妙，就是都把一条流水线和处理过程分成了几条，不管是物理上分还是逻辑上分。

5. 并行操作

并行操作是一种物理上把一条流水线分成好几条的策略。直观上说，一个人干不完的活，那就多找几个人来干。并行操作既增加了系统的吞吐量，又减少了用户的平均等待时间。比如现代的 CPU 都有很多核，每个核上都可以独立地运行线程，这就是并行操作。

并行操作需要我们的程序有扩展性，不能扩展的程序，就无法进行并行处理。这里的并行概念有不同的粒度，比如是在服务器的粒度（所谓的横向扩展），还是在多线程的粒度，甚至是在指令级别的粒度。

绝大多数互联网服务器，要么使用多进程，要么使用多线程来处理用户的请求，以充分利用多核 CPU。另外一种情况就是在有 IO 阻塞的地方，也是非常适合使用多线程并行操作的，因为这种情况 CPU 基本上是空闲状态，多线程可以让 CPU 多干点活。

6. 异步操作

异步操作这一策略和并行操作不同，这是一种逻辑上把一条流水线分成几条的策略。

我们首先在编程的领域澄清一下概念：同步和异步。同步和异步的区别在于一个函数调用之后，是否直接返回结果。如果函数挂起，直到获得结果才返回，这是同步；如果函数马上返回，等数据到达再通知函数，那么这就是异步。

我们知道 Unix 下的文件操作，是有 block 和 non-block 的方式的，有些系统调用也是block 式的，如：Socket 下的 select 等。如果我们的程序一直是同步操作，那么就会非常影响性能。采用异步操作的话，虽然稍微增加一点程序的复杂度，但会让性能的吞吐率有很大提升。

现代的语言往往对异步操作有比较好的支持，使得异步编程变得更加简单，可读性也更好。

四、缓存 / 批量合并

“缓存 / 批量合并”是优化策略中的第四大类。缓存和批量合并这两个策略，有些场景下会同时起作用，所以我把它们放在一起。

7. 缓存数据

缓存的本质是加速访问。这是一个用得非常普遍的策略，几乎体现在计算机系统里面每一个模块和领域，CPU、内存、文件系统、存储系统、内容分布、数据库等等，都会遵循这样的策略。

我们最熟悉的应该就是 CPU 的各级缓存了。在文件系统、存储系统和数据库系统里面，也有快速缓存来存储经常访问的数据，目的是尽量提高缓存命中率，从而避免访问比较慢的存储介质。

对于一个基于 Web 的应用服务，前端会有浏览器缓存，有 CDN 存放在边缘服务器上，有反向代理提供的静态内容缓存；后端则还会有服务器本地缓存。

程序设计中，对于可能重复创建和销毁，且创建销毁代价很大的对象（比如套接字和线程），也可以缓存，对应的缓存形式，就是连接池和线程池等。

对于消耗较大的计算，也可以将计算结果缓存起来，下次可以直接读取结果。比如对递归代码的一个有效优化手段，就是缓存中间结果。

8. 批量合并处理

在有 IO（比如网络 IO 和磁盘 IO）的时候，合并操作和批量操作往往能提升吞吐量，提高性能。

我们最常见的是批量 IO 读写。就是在有多次 IO 的时候，可以把它们合并成一次读写数据。这样可以减少读写时间和协议负担。比如，GFS 写文件的时候，尽量批量写，以减少IO 开销。

对数据库的读写操作，也可以尽量合并。比如，对键值数据库的查询，最好一次查询多个键，而不要分成多次。

涉及到网络请求的时候，网络传输的时间可能远大于请求的处理时间，因此合并网络请求也很有必要。上层协议呢，端到端对话次数尽量不要太频繁（Chatty），否则的话，总的应用层吞吐量不会很高。

五、更先进算法和数据结构

优化策略中的最后一个大类就是“更先进算法和数据结构”。这两个策略是紧密配合的，比如先进的算法有时候会需要先进的数据结构；而且它们往往和程序的设计代码直接相关，所以放在一起。

9. 先进的算法

同一个问题，肯定会有不同的算法实现，进而就会有不同的性能。比如各种排序算法，就是各有千秋。有的实现可能是时间换空间，有的实现可能是空间换时间，那么就需要根据你自己的实际情况做权衡。

对每一种具体的场景（包括输入集合大小、时间空间的要求、数据的大小分布等），总会有一种算法是最适合的。我们需要考虑实际情况，来选择这一最优的算法。

10. 高效的数据结构

和算法的情况类似，不同的数据结构的特性，也是千差万别。

没有一个数据结构是在所有情况下都是最好的，比如你可能经常用到的 Java 里面列表的各种实现，包括各种口味的 List、Vector、LinkedList，它们孰优孰劣，取决于很多个指标：添加元素、删除元素、查询元素、遍历耗时等等。我们同样要权衡取舍，找出实际场合下最适合的高效的数据结构。

六、总结

各种性能问题的解决，需要采用一些策略；而且不同的人和不同的场景中，会采用有时相同有时迥异的策略，恰如韩愈所说的“草树知春不久归，百般红紫斗芳菲”。但花草树木争奇斗艳，说到底是因为“知春不久归”。

同样的道理，这些性能优化策略，有时候很容易想到，有时候并不是那么直观。所以，我们需要系统地有层次地思考，而这一讲就是帮助你建立这样的思路。

通过总结十大策略，希望你可以多从不同角度，思考同一个问题；有时候一个问题看似无解，但多方位思考，可能会突然发现非常好的解决方案。

解决宿主机MAC不能访问虚拟机中CENTOS的TOMCAT服务器

Wed, 04 May 2022 10:47:02 GMT

情况描述

虚拟机中的系统为CentOS，充当服务器，但是开启Tomcat后，在宿主机Mac中无法访问，显示请求被拒接，如下：

除此之外，但是可以使用ssh，也可以ping通。

分析

初步认为就是防火墙的问题，但是参考iptables的一些停用方法，直接显示没有iptables这个服务；后面想验证到底是宿主机还是虚拟机的问题，在5000端口，跑了一个简单的Flask服务器（在虚拟机中可通过本机ip地址+端口号进行访问），在宿主机中仍然无法访问，同时也通过其他的一些设备来访问相应的服务器，都无法访问，从这里看来，问题还是出在了虚拟机中；后面又在宿主机mac中开启了一个服务器，在虚拟机和其它局域网设备中都可以访问，因此断定还是虚拟机的问题。那么，没有安装iptables的CentOS，究竟是出了什么问题呢？

解决办法

因为我使用的是CentOS 7，使用iptables的版本是7以前的，CentOS 7使用firewall作为防火墙。

查看已经开放的端口：firewall-cmd --list-ports 开启端口：firewall-cmd --zone=public --add-port=80/tcp --permanent

命令含义：

–zone #作用域 –add-port=80/tcp #添加端口，格式为：端口/通讯协议 –permanent #永久生效，没有此参数重启后失效123

重启、停止、禁用、查看防火墙

firewall-cmd --reload #重启firewall systemctl stop firewalld.service #停止firewall systemctl disable firewalld.service #禁止firewall开机启动 firewall-cmd --state #查看默认防火墙状态（关闭后显示notrunning，开启后显示running）1234

因此结合上述命令来看，需要将8080端口添加到防火墙的开放端口中，然后重新载入防火墙的配置即可。如下：

sudo firewall-cmd --zone=public --add-port=8080/tcp --permanent sudo firewall-cmd --reload sudo firewall-cmd --list-ports123

最后面来一张成功访问的截图：

CentOS 7安装 ifconfig 管理命令

Wed, 04 May 2022 10:41:01 GMT

1. 安装的需求背景

我们知道ifconfig 命令可以用于查看、配置、启用或禁用指定网络接口，如配置网卡的IP地址、掩码、广播地址、网关等，功能不可谓不丰富。

此命令的功能和Wndows系统的ipconfig非常类似。

但是，Centos7 默认已不再安装此命令，其中很多功能用 ip addr 指令替代了。

考虑到既有的很多管理工具或脚本都调用了此功能命令（ifconfig），如果将这些工具直接迁移过来会报错，如果对这个指令用其它指令进行替换，及对这些工具升级，则增加了工作量，还增加了出错的风险。

所以，在CentOS 7 系统中安装 ifconfig 命令很有必要。

2. 测试安装的具体步骤

CentOS 7 系统默认没有安装 ifconfig 命令。

如果直接运行 ifconfig 命令，则提示错误：-bash: ifconfig: command not found

此时，查看 /sbin 目录下，其实是没有 ifconfig 文件的。

那么如何安装ifconfig 呢？我们首先想到的是运行 yum install ifconfig 。执行效果如何呢？

结果是：

No package ifconfig available. Error: Nothing to do

啊？！没有 ifconfig 安装包，是不是我们就要放弃了呢？

其实，我们还可以通过yum 命令的search选项来对包（package）进行再次搜索。

search：可以搜寻某个软件名称或者是描述（description）的重要关键字。此指令可以查找显示出相关的软件有哪些。

所以，在放弃前，我们运行以下命令：

yum search ifconfig

以上运行结果，我们只要分析最好一行就可以。Matched: ifconfig 这个分割行是用来显示匹配结果的。

最后一行中冒号（：）前面的数据，（net-tools.x86_64 ）是匹配的软件包；冒号（：）后面的数据，（Basic networking tools ）是对前面包的描述。

结合上面的信息，即通过运行 yum search ifconfig 提示我们：安装ifconfig 包只需要安装 net-tools.x86_64 即可。

所以，我们执行 yum install net-tools.x86_64

安装后，ifconfig 命令可以正常执行。因含有ip敏感信息，截图省略。

并且，查看/sbin 目录，此时 ifconfig 文件也出现了。

3. 总结

CentOS 7 安装 ifconfig 管理命令，通过yum 安装，运行 yum install net-tools.x86_64 即可安装。

如何关闭常见浏览器的 HSTS 功能

Wed, 04 May 2022 10:27:50 GMT

在安装配置 SSL 证书时，可以使用一种能使数据传输更加安全的Web安全协议，即在服务器端上开启HSTS (HTTP Strict Transport Security)。它告诉浏览器只能通过HTTPS访问，而绝对禁止HTTP方式。

HTTP Strict Transport Security (HSTS) is an opt-in security enhancement that is specified by a web application through the use of a special response header. Once a supported browser receives this header that browser will prevent any communications from being sent over HTTP to the specified domain and will instead send all communications over HTTPS. It also prevents HTTPS click through prompts on browsers.

但是，在日常开发的过程中，有时我们会想测试页面在 HTTP 连接中的表现情况，这时 HSTS 的存在会让调试不能方便的进行下去。而且由于 HSTS 并不是像 cookie 一样存放在浏览器缓存里，简单的清空浏览器缓存操作并没有什么效果，页面依然通过 HTTPS 的方式传输。那么怎样才能关闭浏览器的 HSTS 呢，各种谷歌~~度娘~~之后，在这里汇总一下几大常见浏览器 HSTS 的关闭方法。

Safari 浏览器

完全关闭 Safari
删除 ~/Library/Cookies/HSTS.plist 这个文件
重新打开 Safari 即可
极少数情况下，需要重启系统

Chrome 浏览器

地址栏中输入 chrome://net-internals/#hsts
在 Delete domain 中输入项目的域名，并Delete 删除
可以在 Query domain 测试是否删除成功

Opera 浏览器

和 Chrome 方法一样

Firefox 浏览器

关闭所有已打开的页面
清空历史记录和缓存
地址栏输入about:permissions
搜索项目域名，并点击 Forget About This Site

Redis 6.0.8 集群搭建(三主三从)

Fri, 22 Apr 2022 04:01:00 GMT

下载与安装

首先从 Redis 官网下载 Redis 源代码并解压，这里使用的是 redis-6.0.8.tar.gz 版本

# 创建目录 mkdir /usr/local/redis/redis-cluster # 进入目录 cd /usr/local/redis/redis-cluster # 下载安装包 wget http://download.redis.io/releases/redis-6.0.8.tar.gz # 解压 tar -zxzf redis-6.0.8.tar.gz #进入目录  cd  redis-6.0.8 # 编译用 如果不安装会编译报错  yum -y install gcc-c++  #加 MALLOC=libc 为了防止编译出错，具体百度 make MALLOC=libc make MALLOC=libc make install PREFIX=/apprun/redis # 目标安装路径

创建数据

#创建目录 cd /usr/local/redis/redis-cluster mkdir logs conf data pid #创建数据目录 cd data mkdir data1111 data2222 data3333 data4444 data5555 data6666

修改配置文件

cd /usr/local/redis/redis-cluster/conf cp /usr/local/redis/redis-cluster/redis/redis.conf . mv redis.conf redis1111.conf vim redis1111.conf

# 修改绑定地址 bind 192.168.5.199 protected-mode yes # 修改端口号,但集群状态下需要注意,集群使用端口会在此端口上增加10000,所以redis自身端口+10000不能超过65535 port 1111 tcp-backlog 511 timeout 0 tcp-keepalive 300 # Redis是否后台运行 daemonize yes supervised no # 进程文件存储地址 pidfile /usr/local/redis/redis-cluster/pid/redis1111.pid loglevel notice # 日志文件存储地址 logfile "/usr/local/redis/redis-cluster/logs/redis1111.log" databases 16 always-show-logo yes save 900 1 save 300 10 save 60 10000 stop-writes-on-bgsave-error yes   # 持久化错误之后，停止写入Redis rdbcompression yes   # 快照是否压缩存储（压缩消耗CPU、占用空间小） rdbchecksum yes   # 存储的快照进行数据校验（增加约10%的性能消耗） dbfilename dump.rdb rdb-del-sync-files no # 数据存放目录 dir /usr/local/redis/redis-cluster/data/data1111  # 主要是针对master对应的slave节点设置的，在slave节点数据同步的时候用到 masterauth redis123 replica-serve-stale-data yes replica-read-only yes repl-diskless-sync no repl-diskless-sync-delay 5 repl-diskless-load disabled repl-disable-tcp-nodelay no replica-priority 100 acllog-max-len 128 # 对登录权限做限制，redis每个节点的requirepass可以是独立、不同的 requirepass redis123 lazyfree-lazy-eviction no lazyfree-lazy-expire no lazyfree-lazy-server-del no replica-lazy-flush no lazyfree-lazy-user-del no oom-score-adj no oom-score-adj-values 0 200 800 # aof日志开启，有需要就开启 appendonly yes appendfilename "appendonly.aof" appendfsync everysec # 每秒同步一次（always 每次修改同步一次） no-appendfsync-on-rewrite no auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb aof-load-truncated yes aof-use-rdb-preamble yes lua-time-limit 5000 # 开启集群模式 cluster-enabled yes # 集群的配置文件，首次启动自动生成 cluster-config-file /usr/local/redis/redis-cluster/conf/nodes1111.conf  # 请求超时时间，默认15s cluster-node-timeout 10000 slowlog-log-slower-than 10000 slowlog-max-len 128 latency-monitor-threshold 0 notify-keyspace-events "" hash-max-ziplist-entries 512 hash-max-ziplist-value 64 list-max-ziplist-size -2 list-compress-depth 0 set-max-intset-entries 512 zset-max-ziplist-entries 128 zset-max-ziplist-value 64 hll-sparse-max-bytes 3000 stream-node-max-bytes 4096 stream-node-max-entries 100 activerehashing yes client-output-buffer-limit normal 0 0 0 client-output-buffer-limit replica 256mb 64mb 60 client-output-buffer-limit pubsub 32mb 8mb 60 hz 10 dynamic-hz yes aof-rewrite-incremental-fsync yes rdb-save-incremental-fsync yes

复制配置

Redis 集群一般由多个节点组成，节点数量至少为 6 个，才能保证组成完整高可用的集群，所以再复制 5 份配置文件

cp redis1111.conf redis2222.conf cp redis1111.conf redis3333.conf cp redis1111.conf redis4444.conf cp redis1111.conf redis5555.conf cp redis1111.conf redis6666.conf  # vim 进去里边修改：比如：% s/1111/2222/

配置启动命令及启动集群

cd /usr/local/redis/redis-cluster/redis/src # 这样可以直接使用该命令，不需要再进入该命令目录 cp redis-cli redis-server /usr/bin/  #编写统一启动脚本、启动 cd /usr/local/redis/redis-cluster vi redis-start.sh  #!/bin/bash redis-server /usr/local/redis/redis-cluster/conf/redis1111.conf redis-server /usr/local/redis/redis-cluster/conf/redis2222.conf redis-server /usr/local/redis/redis-cluster/conf/redis3333.conf redis-server /usr/local/redis/redis-cluster/conf/redis4444.conf redis-server /usr/local/redis/redis-cluster/conf/redis5555.conf redis-server /usr/local/redis/redis-cluster/conf/redis6666.conf  # 赋予权限 chmod 755 redis-start.sh ./redis-start.sh #启动集群 执行命令：redis-cli --cluster create 192.168.5.199:1111 192.168.5.199:2222 192.168.5.199:3333 192.168.5.199:4444 192.168.5.199:5555 192.168.5.199:6666 --cluster-replicas 1 -a redis123

参数说明：注意 redis-5.0.0 版本开始才支持 “ --cluster ”

create 表示创建一个redis集群。

--cluster-replicas 1 表示为集群中的每一个主节点指定一个从节点，即一比一的复制。

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe. >>> Performing hash slots allocation on 6 nodes... Master[0] -> Slots 0 - 5460 Master[1] -> Slots 5461 - 10922 Master[2] -> Slots 10923 - 16383 Adding replica 192.168.5.199:5555 to 192.168.5.199:1111 Adding replica 192.168.5.199:6666 to 192.168.5.199:2222 Adding replica 192.168.5.199:4444 to 192.168.5.199:3333 >>> Trying to optimize slaves allocation for anti-affinity [WARNING] Some slaves are in the same host as their master M: 3c09b846d56efc9c3d3367b7db74317ff0c54980 192.168.5.199:1111    slots:[0-5460] (5461 slots) master M: f35e954bd158848b5dc09358752daf7db35c7d7e 192.168.5.199:2222    slots:[5461-10922] (5462 slots) master M: 2e54db41b7916b64d7689b22a0f456dd099086fc 192.168.5.199:3333    slots:[10923-16383] (5461 slots) master S: edf74be3f4784f0d560505ad0ca10bcd76d57d42 192.168.5.199:4444    replicates 3c09b846d56efc9c3d3367b7db74317ff0c54980 S: 609822d35d216b3bea5a308f25fa537055d85089 192.168.5.199:5555    replicates f35e954bd158848b5dc09358752daf7db35c7d7e S: ee9838644056c360a88399b3acb5f905e17eebc5 192.168.5.199:6666    replicates 2e54db41b7916b64d7689b22a0f456dd099086fc Can I set the above configuration? (type 'yes' to accept): yes >>> Nodes configuration updated >>> Assign a different config epoch to each node >>> Sending CLUSTER MEET messages to join the cluster Waiting for the cluster to join . >>> Performing Cluster Check (using node 192.168.5.199:1111) M: 3c09b846d56efc9c3d3367b7db74317ff0c54980 192.168.5.199:1111    slots:[0-5460] (5461 slots) master    1 additional replica(s) S: edf74be3f4784f0d560505ad0ca10bcd76d57d42 192.168.5.199:4444    slots: (0 slots) slave    replicates 3c09b846d56efc9c3d3367b7db74317ff0c54980 S: ee9838644056c360a88399b3acb5f905e17eebc5 192.168.5.199:6666    slots: (0 slots) slave    replicates 2e54db41b7916b64d7689b22a0f456dd099086fc M: 2e54db41b7916b64d7689b22a0f456dd099086fc 192.168.5.199:3333    slots:[10923-16383] (5461 slots) master    1 additional replica(s) S: 609822d35d216b3bea5a308f25fa537055d85089 192.168.5.199:5555    slots: (0 slots) slave    replicates f35e954bd158848b5dc09358752daf7db35c7d7e M: f35e954bd158848b5dc09358752daf7db35c7d7e 192.168.5.199:2222    slots:[5461-10922] (5462 slots) master    1 additional replica(s) [OK] All nodes agree about slots configuration. >>> Check for open slots... >>> Check slots coverage... [OK] All 16384 slots covered.

检测集群完整性

#执行命令 redis-cli --cluster check 192.168.121.128:1111 -a redis123

[root@localhost ~]# redis-cli --cluster check 192.168.5.199:1111 -a "redis123" Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe. 192.168.5.199:1111 (3c09b846...) -> 0 keys | 5461 slots | 1 slaves. 192.168.5.199:3333 (2e54db41...) -> 1 keys | 5461 slots | 1 slaves. 192.168.5.199:2222 (f35e954b...) -> 1 keys | 5462 slots | 1 slaves. [OK] 2 keys in 3 masters. 0.00 keys per slot on average. >>> Performing Cluster Check (using node 192.168.5.199:1111) M: 3c09b846d56efc9c3d3367b7db74317ff0c54980 192.168.5.199:1111    slots:[0-5460] (5461 slots) master    1 additional replica(s) S: edf74be3f4784f0d560505ad0ca10bcd76d57d42 192.168.5.199:4444    slots: (0 slots) slave    replicates 3c09b846d56efc9c3d3367b7db74317ff0c54980 S: ee9838644056c360a88399b3acb5f905e17eebc5 192.168.5.199:6666    slots: (0 slots) slave    replicates 2e54db41b7916b64d7689b22a0f456dd099086fc M: 2e54db41b7916b64d7689b22a0f456dd099086fc 192.168.5.199:3333    slots:[10923-16383] (5461 slots) master    1 additional replica(s) S: 609822d35d216b3bea5a308f25fa537055d85089 192.168.5.199:5555    slots: (0 slots) slave    replicates f35e954bd158848b5dc09358752daf7db35c7d7e M: f35e954bd158848b5dc09358752daf7db35c7d7e 192.168.5.199:2222    slots:[5461-10922] (5462 slots) master    1 additional replica(s) [OK] All nodes agree about slots configuration. >>> Check for open slots... >>> Check slots coverage... [OK] All 16384 slots covered.

登录验证

#执行命令 redis-cli -h 192.168.5.199 -p 1111 -a "redis123" Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe. 192.168.5.199:1111> info cluster # Cluster cluster_enabled:1 192.168.5.199:1111> cluster info cluster_state:ok cluster_slots_assigned:16384 cluster_slots_ok:16384 cluster_slots_pfail:0 cluster_slots_fail:0 cluster_known_nodes:6 cluster_size:3 cluster_current_epoch:6 cluster_my_epoch:1 cluster_stats_messages_ping_sent:67776 cluster_stats_messages_pong_sent:71182 cluster_stats_messages_sent:138958 cluster_stats_messages_ping_received:71177 cluster_stats_messages_pong_received:67776 cluster_stats_messages_meet_received:5 cluster_stats_messages_received:138958 192.168.5.199:1111>

批量下载wallhaven壁纸

Thu, 07 Apr 2022 13:47:00 GMT

#!/bin/bash # # This script gets the beautiful wallpapers from http://wallhaven.cc # This script is brought to you by MacEarl and is based on the # script for wallbase.cc (https://github.com/sevensins/Wallbase-Downloader) # # This Script is written for GNU Linux, it should work under Mac OS  REVISION=0.2.6  ##################################### ###   Needed for NSFW/Favorites   ### ##################################### # Enter your API key # you can get it here: https://wallhaven.cc/settings/account APIKEY="beYBHQ89MncZeTt96JXRyrqmwBFifWUr" ##################################### ### End needed for NSFW/Favorites ### #####################################  ##################################### ###     Configuration Options     ### ##################################### # Where should the Wallpapers be stored? LOCATION=/Volumes/photo # How many Wallpapers should be downloaded, should be multiples of the # value in the THUMBS Variable WPNUMBER=48 # What page to start downloading at, default and minimum of 1. STARTPAGE=1 # Type standard (newest, oldest, random, hits, mostfav), search, collections # (for now only the default collection), useruploads (if selected, only # FILTER variable will change the outcome) TYPE=standard # From which Categories should Wallpapers be downloaded, first number is # for General, second for Anime, third for People, 1 to enable category, # 0 to disable it CATEGORIES=110 # filter wallpapers before downloading, first number is for sfw content, # second for sketchy content, third for nsfw content, 1 to enable, # 0 to disable FILTER=111 # Which Resolutions should be downloaded, leave empty for all (most common # resolutions possible, for details see wallhaven site), separate multiple # resolutions with , eg. 1920x1080,1920x1200 RESOLUTION= # alternatively specify a minimum resolution, please note that specifying # both resolutions and a minimum resolution will result in the desired # resolutions being ignored, to avoid unwanted behavior only set one of the # two options and leave the other blank ATLEAST= # Which aspectratios should be downloaded, leave empty for all (possible # values: 4x3, 5x4, 16x9, 16x10, 21x9, 32x9, 48x9, 9x16, 10x16), separate mutliple ratios # with , eg. 4x3,16x9 ASPECTRATIO= # Which Type should be displayed (relevance, random, date_added, views, # favorites, toplist, toplist-beta) MODE=date_added # if MODE is set to toplist show the toplist for the given timeframe # possible values: 1d (last day), 3d (last 3 days), 1w (last week), # 1M (last month), 3M (last 3 months), 6M (last 6 months), 1y (last year) TOPRANGE= # How should the wallpapers be ordered (desc, asc) ORDER=desc # Collections, only used if TYPE = collections # specify the name of the collection you want to download # Default is the default collection name on wallhaven # If you want to download your own Collections make sure USR is set to your username # If you want to download someone elses public collection enter the name here # and the username under USR # Please note that the only filter option applied to Collections is the Number # of Wallpapers to download, there is no filter for resolution, purity, ... COLLECTION="Default" # Searchterm, only used if TYPE = search # you can also search by tags, use id:TAGID # to get the tag id take a look at: https://wallhaven.cc/tags/ # for example: to search for nature related wallpapers via the nature tag # instead of the keyword use QUERY="id:37" QUERY="nature" # Search images containing color # values are RGB (000000 = black, ffffff = white, ff0000 = red, ...) COLOR="" # Should the search results be saved to a separate subfolder? # 0 for no separate folder, 1 for separate subfolder SUBFOLDER=0 # User from which wallpapers should be downloaded # used for TYPE=useruploads and TYPE=collections # If you want to download your own Collection this has to be set to your username USR="AksumkA" # use gnu parallel to speed up the download (0, 1), if set to 1 make sure # you have gnuparallel installed, see normal.vs.parallel.txt for # speed improvements # using this option can lead to cloudflare blocking some of the downloads PARALLEL=0 # custom thumbnails per page # changeable here: https://wallhaven.cc/settings/browsing # valid values: 24, 32, 64 # if set to 32 or 64 you need to provide an api key THUMBS=24 ##################################### ###   End Configuration Options   ### #####################################  function checkDependencies {     printf "Checking dependencies..."     dependencies=(wget jq sed)     [[ $PARALLEL == 1 ]] && dependencies+=(parallel)      for name in "${dependencies[@]}"     do         [[ $(command -v "$name" 2>/dev/null) ]] ||         { printf "\n%s needs to be installed. Use your package manager to do so, e.g. 'sudo apt install %s'" "$name" "$name";deps=1; }     done      if [[ $deps -ne 1 ]]     then         printf "OK\n"     else         printf "\nInstall the above and rerun this script\n"         exit 1     fi } # /checkDependencies  # # sets the authentication header/API key to give the user more functionality # requires 1 arguments: # arg1: API key # function setAPIkeyHeader {     # checking parameters -> if not ok print error and exit script     if [ $# -lt 1 ] || [ "$1" == '' ]     then         printf "Please make sure to enter a valid API key,\n"         printf "it is needed for NSFW Content and downloading \n"         printf "your Collections also make sure your Thumbnails per\n"         printf "Page Setting matches the THUMBS Variable\n\n"         printf "Press any key to exit\n"         read -r         exit     fi      # everythings ok --> set api key header     httpHeader="X-API-Key: $APIKEY" } # /setAPIkeyHeader  # # downloads Page with Thumbnails # function getPage {     # checking parameters -> if not ok print error and exit script     if [ $# -lt 1 ]     then         printf "getPage expects at least 1 argument\\n"         printf "arg1:\\tparameters for the wget -q command\\n\\n"         printf "press any key to exit\\n"         read -r         exit     fi      # parameters ok --> get page     WGET -O tmp "https://wallhaven.cc/api/v1/$1" } # /getPage  # # downloads all the wallpaper from a wallpaperfile # arg1: the file containing the wallpapers # function downloadWallpapers {     if (( "$page" >= "$(jq -r ".meta.last_page" tmp)" ))     then         downloadEndReached=true     fi      for ((i=0; i<THUMBS; i++))     do         imgURL=$(jq -r ".data[$i].path" tmp)          filename=$(echo "$imgURL"| sed "s/.*\///" )         if grep -w "$filename" downloaded.txt >/dev/null         then             printf "\\tWallpaper %s already downloaded!\\n" "$imgURL"         elif [ $PARALLEL == 1 ]         then             echo "$imgURL" >> download.txt         else             # check if downloadWallpaper was successful             if downloadWallpaper "$imgURL"             then                 echo "$filename" >> downloaded.txt             fi         fi     done      if [ $PARALLEL == 1 ] && [ -f ./download.txt ]     then         # export wget wrapper and download function to make it         # available for parallel         export -f WGET coolDown downloadWallpaper         # shellcheck disable=SC2016         SHELL=$(type -p bash) parallel --gnu --no-notice \             'imgURL={} && downloadWallpaper $imgURL && echo "$imgURL"| sed "s/.*\///" >> downloaded.txt' < download.txt             rm tmp download.txt         else             rm tmp     fi } # /downloadWallpapers  # # downloads a single Wallpaper by guessing its extension, this eliminates # the need to download each wallpaper page, now only the thumbnail page # needs to be downloaded # function downloadWallpaper {     if [[ "$1" != null ]]     then         WGET "$1"     else         return 1     fi } # /downloadWallpaper  # # Waits for 30 seconds if rate limiting is detected # function coolDown {     printf "\\t -Rate Limiting detected, sleeping for 30 seconds\\n"     sleep 30     WGET "$@" } # /coolDown  # # wrapper for wget with some default arguments # arg0: additional arguments for wget (optional) # arg1: file to download # function WGET {     # checking parameters -> if not ok print error and exit script     if [ $# -lt 1 ]     then         printf "WGET expects at least 1 argument\\n"         printf "arg0:\\tadditional arguments for wget (optional)\\n"         printf "arg1:\\tfile to download\\n\\n"         printf "press any key to exit\\n"         read -r         exit     fi      # default wget command     wget --server-response -q --header="$httpHeader" --keep-session-cookies \          --save-cookies cookies.txt --load-cookies cookies.txt "$@" 2>&1 | \          grep "429 Too Many Requests" >/dev/null && coolDown "$@"      return "${PIPESTATUS[0]}" } # /WGET  # # displays help text (valid command line arguments) # function helpText {     printf "Usage: ./wallhaven.sh [OPTIONS]\\n"     printf "Download wallpapers from wallhaven.cc\\n\\n"     printf "If no options are specified, default values from within the "     printf "script will be used\\n\\n"     printf " -l, --location\\t\\tlocation where the wallpapers will be "     printf "stored\\n"     printf " -n, --number\\t\\tNumber of Wallpapers to download\\n"     printf " -s, --startpage\\tpage to start downloading from\\n"     printf " -t, --type\\t\\tType of download Operation: standard, search, "     printf "\\n\\t\\t\\tcollections, useruploads\\n"     printf " -c, --categories\\tcategories to download from, eg. 111 for "     printf "General,\\n\\t\\t\\tAnime and People, 1 to include, 0 to exclude\\n"     printf " -f, --filter\\t\\tfilter out content based on purity rating, "     printf "eg. 111 \\n\\t\\t\\tfor SFW, sketchy and NSFW content, 1 to "     printf "include, \\n\\t\\t\\t0 to exclude\\n"     printf " -r, --resolution\\tresolutions to download, separate mutliple"     printf " \\n\\t\\t\\tresolutions by ,\\n"     printf " -g, --atleast\\t\\tminimum resolution, show all images with a"     printf "\\n\\t\\t\\tresolution greater than the specified value"     printf "\\n\\t\\t\\tdo not use in combination with -r (--resolution)\\n"     printf " -a, --aspectratio\\tonly download wallpaper with given "     printf "aspectratios, \\n\\t\\t\\tseparate multiple aspectratios by ,\\n"     printf " -m, --mode\\t\\tsorting mode for wallpapers: relevance, random"     printf ",\\n\\t\\t\\tdate_added, views, favorites \\n"     printf " -o, --order\\t\\torder ascending (asc) or descending "     printf "(desc)\\n"     printf " -b, --collection\\tname of the collections to download\\n"     printf " -q, --query\\t\\tsearch query, eg. 'mario', single "     printf "quotes needed,\\n\\t\\t\\tfor searching exact phrases use double "     printf "quotes \\n\\t\\t\\tinside single quotes, eg. '\"super mario\"'"     printf "\\n"     printf " -d, --dye, --color\\tsearch for wallpapers containing the "     printf "given color,\\n"     printf "\\t\\t\\tcolor values are RGB without a leading #\\n"     printf " -u, --user\\t\\tdownload wallpapers from given user\\n"     printf " -p, --parallel\\t\\tmake use of gnu parallel (1 to enable, 0 "     printf "to disable)\\n"     printf " -v, --version\\t\\tshow current version\\n"     printf " -h, --help\\t\\tshow this help text and exit\\n\\n"     printf "Examples:\\n"     printf "./wallhaven.sh\\t-l ~/wp/ -n 48 -s 1 -t standard -c 101 -f 111"     printf " -r 1920x1080 \\n\\t\\t-a 16x9 -m random -o desc -p 1\\n\\n"     printf "Download 48 random wallpapers with a resolution of 1920x1080 "     printf "and \\nan aspectratio of 16x9 to ~/wp/ starting with page 1 "     printf "from the \\ncategories general and people including SFW, sketchy"     printf " and NSWF Content\\nwhile utilizing gnu parallel\\n\\n"     printf "./wallhaven.sh\\t-l ~/wp/ -n 48 -s 1 -t search -c 111 -f 100 -r "     printf "1920x1080 -a 16x9\\n\\t\\t-m relevance -o desc -q "     printf "'\"super mario\"' -d cc0000 -p 1\\n\\n"     printf "Download 48 wallpapers related to the search query "     printf "\"super mario\" containing \\nthe color #cc0000 with a resolution"     printf " of 1920x1080 and an aspectratio of 16x9\\nto ~/wp/ starting "     printf "with page 1 from the categories general, anime and people,\\n"     printf "including SFW Content and excluding sketchy and NSWF Content "     printf "while utilizing\\ngnu parallel\\n\\n\\n"     printf "latest version available at: "     printf "<https://github.com/macearl/Wallhaven-Downloader>\\n" } # /helptext  # Command line Arguments while [[ $# -ge 1 ]]     do     key="$1"      case $key in         -l|--location)             LOCATION="$2"             shift;;         -n|--number)             WPNUMBER="$2"             shift;;         -s|--startpage)             STARTPAGE="$2"             shift;;         -t|--type)             TYPE="$2"             shift;;         -c|--categories)             CATEGORIES="$2"             shift;;         -f|--filter)             FILTER="$2"             shift;;         -r|--resolution)             RESOLUTION="$2"             shift;;         -g|--atleast)             ATLEAST="$2"             shift;;         -a|--aspectratio)             ASPECTRATIO="$2"             shift;;         -m|--mode)             MODE="$2"             shift;;         -o|--order)             ORDER="$2"             shift;;         -b|--collection)             COLLECTION="$2"             shift;;         -q|--query)             QUERY=${2//\'/}             shift;;         -d|--dye|--color)             COLOR="$2"             shift;;         -u|--user)             USR="$2"             shift;;         -p|--parallel)             PARALLEL="$2"             shift;;         -h|--help)             helpText             exit             ;;         -v|--version)             printf "Wallhaven Downloader %s\\n" "$REVISION"             exit             ;;         *)             printf "unknown option: %s\\n" "$1"             helpText             exit             ;;     esac     shift # past argument or value     done  checkDependencies  # optionally create a separate subfolder for each search query # might download duplicates as each search query has its own list of # downloaded wallpapers if [ "$TYPE" == search ] && [ "$SUBFOLDER" == 1 ] then     LOCATION+=/$(echo "$QUERY" | sed -e "s/ /_/g" -e "s/+/_/g" -e  "s/\\//_/g") fi  # creates Location folder if it does not exist if [ ! -d "$LOCATION" ] then     mkdir -p "$LOCATION" fi  cd "$LOCATION" || exit  # creates downloaded.txt if it does not exist if [ ! -f ./downloaded.txt ] then     touch downloaded.txt fi  # set auth header only when it is required ( for example to download your # own collections or nsfw content... ) if  [ "$FILTER" == 001 ] || [ "$FILTER" == 011 ] || [ "$FILTER" == 111 ] \     || [ "$TYPE" == collections ] || [ "$THUMBS" != 24 ] then     setAPIkeyHeader "$APIKEY" fi  if [ "$TYPE" == standard ] then     for ((  count=0, page="$STARTPAGE";             count< "$WPNUMBER";             count=count+"$THUMBS", page=page+1 ));     do         printf "Download Page %s\\n" "$page"         s1="search?page=$page&categories=$CATEGORIES&purity=$FILTER&"         s1+="atleast=$ATLEAST&resolutions=$RESOLUTION&ratios=$ASPECTRATIO"         s1+="&sorting=$MODE&order=$ORDER&topRange=$TOPRANGE&colors=$COLOR"         getPage "$s1"         printf "\\t- done!\\n"         printf "Download Wallpapers from Page %s\\n" "$page"         downloadWallpapers         printf "\\t- done!\\n"         if [ "$downloadEndReached" = true ]         then             break         fi     done  elif [ "$TYPE" == search ] || [ "$TYPE" == useruploads ] then     for ((  count=0, page="$STARTPAGE";             count< "$WPNUMBER";             count=count+"$THUMBS", page=page+1 ));     do         printf "Download Page %s\\n" "$page"         s1="search?page=$page&categories=$CATEGORIES&purity=$FILTER&"         s1+="atleast=$ATLEAST&resolutions=$RESOLUTION&ratios=$ASPECTRATIO"         s1+="&sorting=$MODE&order=desc&topRange=$TOPRANGE&colors=$COLOR"         if [ "$TYPE" == search ]         then             s1+="&q=$QUERY"         elif [ "$TYPE" == useruploads ]         then             s1+="&q=@$USR"         fi          getPage "$s1"         printf "\\t- done!\\n"         printf "Download Wallpapers from Page %s\\n" "$page"         downloadWallpapers         printf "\\t- done!\\n"         if [ "$downloadEndReached" = true ]         then             break         fi     done  elif [ "$TYPE" == collections ] then     if [ "$USR" == "" ]     then         printf "Please check the value specified for USR\\n"         printf "to download a Collection it is necessary to specify a User\\n\\n"         printf "Press any key to exit\\n"         read -r         exit     fi      getPage "collections/$USR"       i=0     while         label=$(jq -e -r ".data[$i].label" tmp)         id=$(jq -e -r ".data[$i].id" tmp)         collectionsize=$(jq -e -r ".data[$i].count" tmp)         [[ $label != "$COLLECTION" && $label != null ]]     do         (( i++ ))     done      if [ -z "$id" ]     then         printf "Please check the value specified for COLLECTION\\n"         printf "it seems that a collection with the name \"%s\" does not exist\\n\\n" \                 "$COLLECTION"         printf "Press any key to exit\\n"         read -r         exit     fi      for ((  count=0, page="$STARTPAGE";             count< "$WPNUMBER" && count< "$collectionsize";             count=count+"$THUMBS", page=page+1 ));     do         printf "Download Page %s\\n" "$page"         getPage "collections/$USR/$id?page=$page"         printf "\\t- done!\\n"         printf "Download Wallpapers from Page %s\\n" "$page"         downloadWallpapers         printf "\\t- done!\\n"     done else     printf "error in TYPE please check Variable\\n" fi  rm -f cookies.txt

常用的JVM参数，你现在就记好！

Sat, 02 Apr 2022 08:14:00 GMT

前言

大家都知道，jvm在启动的时候，会执行默认的一些参数。一般情况下，这些设置的默认参数应对一些平常的项目也够用了。但是如果项目特别大了，需要增加一下堆内存的大小、或者是系统老是莫明的挂掉，想查看下gc日志来排查一下错误的原因，都需要咱们手动设置这些参数。

1.verbose:gc

表示，启动jvm的时候，输出jvm里面的gc信息。格式如下：

[Full GC 178K->99K(1984K)， 0.0253877 secs]

解读：Full GC 就表示执行了一次Full GC的操作，178K 和99K 就表示执行GC前内存容量和执行GC后的内存容量。1984K就表示内存总容量。后面那个是执行本次GC所消耗的时间，单位是秒。

2.-XX:+printGC

这个打印的GC信息跟上个一样，就不做介绍了。

3.-XX:+PrintGCDetails

打印GC的详细信息。格式如下：

–Heap – def new generation   total 13824K, used 11223K [0x27e80000, 0x28d80000, 0x28d80000) –  eden space 12288K,  91% used [0x27e80000, 0x28975f20, 0x28a80000) –  from space 1536K,   0% used [0x28a80000, 0x28a80000, 0x28c00000) –  to   space 1536K,   0% used [0x28c00000, 0x28c00000, 0x28d80000) – tenured generation   total 5120K, used 0K [0x28d80000, 0x29280000, 0x34680000) –   the space 5120K,   0% used [0x28d80000, 0x28d80000, 0x28d80200, 0x29280000) – compacting perm gen  total 12288K, used 142K [0x34680000, 0x35280000, 0x38680000) –   the space 12288K,   1% used [0x34680000, 0x346a3a90, 0x346a3c00, 0x35280000) –    ro space 10240K,  44% used [0x38680000, 0x38af73f0, 0x38af7400, 0x39080000) –    rw space 12288K,  52% used [0x39080000, 0x396cdd28, 0x396cde00, 0x39c80000)

解读：new generation 就是堆内存里面的新生代。total的意思就是一共的，所以后面跟的就是新生代一共的内存大小。used也就是使用了多少内存大小。0x开头的那三个分别代表的是底边界，当前边界，高边界。也就是新生代这片内存的起始点，当前使用到的地方和最大的内存地点。

eden space 这个通常被翻译成伊甸园区，是在新生代里面的，一些创建的对象都会先被放进这里。后面那个12288K就表示伊甸园区一共的内存大小，91% used，很明显，表示已经使用了百分之多少。后面的那个0x跟上一行的解释一样。

from space 和to space 是幸存者的两个区。也是属于新生代的。他两个区的大小必须是一样的。因为新生代的GC采用的是复制算法，每次只会用到一个幸存区，当一个幸存区满了的时候，把还是活的对象复制到另个幸存区，上个直接清空。这样做就不会产生内存碎片了。

tenured generation 就表示老年代。

compacting perm 表示永久代。由于这两个的格式跟前面我介绍的那个几乎一样，我就不必介绍了。

4.-XX:+PrintGCTimeStamps

打印GC发生的时间戳。格式如下：

289.556: [GC [PSYoungGen: 314113K->15937K(300928K)] 405513K->107901K(407680K), 0.0178568 secs] [Times: user=0.06 sys=0.00, real=0.01 secs]  293.271: [GC [PSYoungGen: 300865K->6577K(310720K)] 392829K->108873K(417472K), 0.0176464 secs] [Times: user=0.06 sys=0.00, real=0.01 secs]

解读：289.556表示从jvm启动到发生垃圾回收所经历的的时间。GC表示这是新生代GC（Minor GC）。PSYoungGen表示新生代使用的是多线程垃圾回收器Parallel Scavenge。314113K->15937K(300928K)]这个跟上面那个GC格式一样，只不过，这个是表示的是新生代，幸存者区。后面那个是整个堆的大小，GC前和GC后的情况。Times这个显而易见，代表GC的所消耗的时间，用户垃圾回收的时间和系统消耗的时间和最终真实的消耗时间。

5.-X:loggc:log/gc.log

这个就表示，指定输出gc.log的文件位置。（我这里写的log/gc.log就表示在当前log的目录里，把GC日志写到叫gc.log的文件里。）

6.-XX:+PrintHeapAtGC

表示每次GC后，都打印堆的信息。（这个打印的基本格式跟上面第二条的基本类似，我也就不比多说了。）

7.-XX:+TraceClassLoading

监控类的加载。格式如下：

•[Loaded java.lang.Object from shared objects file] •[Loaded java.io.Serializable from shared objects file] •[Loaded java.lang.Comparable from shared objects file] •[Loaded java.lang.CharSequence from shared objects file] •[Loaded java.lang.String from shared objects file] •[Loaded java.lang.reflect.GenericDeclaration from shared objects file] •[Loaded java.lang.reflect.Type from shared objects file]

使用这个参数就能很清楚的看到那些类被加载的情况了。

8.-XX:+PrintClassHistogram

跟踪参数。这个按下Ctrl+Break后，就会打印一下信息：

num     #instances         #bytes  class name    ----------------------------------------------       1:        890617      470266000  [B       2:        890643       21375432  java.util.HashMap$Node       3:        890608       14249728  java.lang.Long       4:            13        8389712  [Ljava.util.HashMap$Node;       5:          2062371680  [C       6:           46341904  java.lang.Class

–分别显示：序号、实例数量、总大小、类型。

这里面那个类型，B和C的其实就是byte和char类型。

9.-Xmx -Xms

这个就表示设置堆内存的最大值和最小值。这个设置了最大值和最小值后，jvm启动后，并不会直接让堆内存就扩大到指定的最大数值。而是会先开辟指定的最小堆内存，如果经过数次GC后，还不能，满足程序的运行，才会逐渐的扩容堆的大小，但也不是直接扩大到最大内存。

10.-Xmn

设置新生代的内存大小。

11.-XX:NewRatio

新生代和老年代的比例。比如：1：4，就是新生代占五分之一。

12.-XX:SurvivorRatio

设置两个Survivor区和eden区的比例。比如：2：8 ，就是一个Survivor区占十分之一。

13.-XX:+HeapDumpOnOutMemoryError

发生OOM时，导出堆的信息到文件。

14.-XX:+HeapDumpPath

表示，导出堆信息的文件路径。

15.-XX:OnOutOfMemoryError

当系统产生OOM时，执行一个指定的脚本，这个脚本可以是任意功能的。比如生成当前线程的dump文件，或者是发送邮件和重启系统。

16.-XX:PermSize -XX:MaxPermSize

设置永久区的内存大小和最大值。永久区内存用光也会导致OOM的发生。

17.-Xss

设置栈的大小。栈都是每个线程独有一个，所有一般都是几百k的大小。

公司用的 MySQL 团队开发规范，太详细了，建议收藏！

Sat, 02 Apr 2022 08:11:00 GMT

数据库对象命名规范

数据库对象

数据库对象是数据库的组成部分，常见的有以下几种：表（Table ）、索引（Index）、视图（View）、图表（Diagram）、缺省值（Default）、规则（Rule）、触发器（Trigger）、存储过程（Stored Procedure）、用户（User）等。命名规范是指数据库对象如数据库（SCHEMA）、表（TABLE）、索引（INDEX）、约束（CONSTRAINTS）等的命名约定。

数据库对象全局命名规范

1、命名使用具有意义的英文词汇，词汇中间以下划线分隔

2、命名只能使用英文字母、数字、下划线，以英文字母开头

3、避免用MySQL的保留字如：backup、call、group等

4、所有数据库对象使用小写字母，实际上MySQL中是可以设置大小写是否敏感的，为了保证统一性，我们这边规范全部小写表示。

数据库命名规范

1、数据库命名尽量不超过30个字符。

2、数据库命名一般为项目名称+代表库含义的简写，比如IM项目的工作流数据库，可以是 im_flow。

3、数据库创建时必须添加默认字符集和校对规则子句。默认字符集为UTF8（已迁移dumbo的使用utf8mb4）

4、命名应使用小写。

表命名规范

1、常规表表名以t_开头，t代表table的意思，命名规则即 t + 模块（包含模块含义的简写）+ 表（包含表含义的简写），比如用户模块的教育信息表：t_user_eduinfo。

2、临时表（RD、QA或DBA同学用于数据临时处理的表），命名规则：temp前缀+模块+表+日期后缀：temp_user_eduinfo_20210719

3、备份表（用于保存和归档历史数据或者作为灾备恢复的数据）命名规则，bak前缀+模块+表+日期后缀：bak_user_eduinfo_20210719

4、同一个模块的表尽可能使用相同的前缀，表名称尽可能表达含义

5、多个单词以下划线 _ 分隔

6、常规表表名尽量不超过30个字符，temp表和bak表视情况而定，也尽量简短为宜，命名应使用小写

字段命名规范

1、字段命名需要表示其实际含义的英文单词或简写，单词之间用下划线 _ 进行连接，如 service_ip、service_port。

2、各表之间相同意义的字段必须同名，比如a表和b表都有创建时间，应该统一为create_time，不一致会很混乱。

3、多个单词以下划线 _ 分隔

4、字段名尽量不超过30个字符，命名应该使用小写

索引命名规范

1、唯一索引使用uni + 字段名来命名：create unique index uni_uid on t_user_basic(uid) 。

2、非唯一索引使用idx + 字段名来命名：create index idx_uname_mobile on t_user_basic(uname,mobile) 。

3、多个单词以下划线 _ 分隔。

4、索引名尽量不超过50个字符，命名应该使用小写，组合索引的字段不宜太多，不然也不利于查询效率的提升。

5、多单词组成的列名，取尽可能代表意义的缩写，如 test_contact表member_id和friend_id上的组合索引：idx_mid_fid。

6、理解组合索引最左前缀原则，避免重复建设索引，如果建立了(a,b,c)，相当于建立了(a), (a,b), (a,b,c)。

视图命名规范

1、视图名以v开头，表示view，完整结构是v+视图内容含义缩写。

2、如果视图只来源单个表，则为v+表名。如果视图由几个表关联产生就用v+下划线（_）连接几个表名，视图名尽量不超过30个字符。如超过30个字符则取简写。

3、如无特殊需要，严禁开发人员创建视图。

4、命名应使用小写。

存储过程命名规范

1、存储过程名以sp开头，表示存储过程（storage procedure）。之后多个单词以下划线（_）进行连接。存储过程命名中应体现其功能。存储过程名尽量不能超过30个字符。

2、存储过程中的输入参数以i_开头，输出参数以o_开头。

3、命名应使用小写。

  create procedure sp_multi_param(in i_id bigint,in i_name varchar(32),out o_memo varchar(100))

函数命名规范

1、函数名以func开始，表示function。之后多个单词以下划线（_）进行连接，函数命名中应体现其功能。函数名尽量不超过30个字符。

2、命名应使用小写。

  create function func_format_date(ctime datetime)

触发器命名规范

1、触发器以trig开头，表示trigger 触发器。

2、基本部分，描述触发器所加的表，触发器名尽量不超过30个字符。

3、后缀（_i,_u,_d）,表示触发条件的触发方式（insert,update或delete）。

4、命名应使用小写。

  DROP TRIGGER IF EXISTS trig_attach_log_d;   CREATE TRIGGER trig_attach_log_d AFTER DELETE ON t_dept FOR EACH ROW;

约束命名规范

1、唯一约束：uk_表名称_字段名。uk是UNIQUE KEY的缩写。比如给一个部门的部门名称加上唯一约束，来保证不重名，如下：ALTER TABLE t_dept ADD CONSTRAINT un_name UNIQUE(name);

2、外键约束：fk_表名，后面紧跟该外键所在的表名和对应的主表名（不含t_）。子表名和父表名用下划线(_)分隔。如下：ALTER TABLE t_user ADD CONSTRAINT fk_user_dept FOREIGN KEY(depno) REFERENCES t_dept (id);

3、非空约束：如无特殊需要，建议所有字段默认非空(not null)，不同数据类型必须给出默认值(default)。

  `id` int(11) NOT NULL,   `name` varchar(30) DEFAULT '',   `deptId` int(11) DEFAULT 0,   `salary` float DEFAULT NULL,

4、出于性能考虑，如无特殊需要，建议不使用外键。参照完整性由代码控制。这个也是我们普遍的做法，从程序角度进行完整性控制，但是如果不注意，也会产生脏数据。

5、命名应使用小写。

用户命名规范

1、生产使用的用户命名格式为 code_应用

2、只读用户命名规则为 read_应用

[数据库对象设计规范

存储引擎的选择

1、如无特殊需求，必须使用innodb存储引擎。

可以通过 show variables like 'default_storage_engine' 来查看当前默认引擎。主要有MyISAM 和 InnoDB，从5.5版本开始默认使用 InnoDB 引擎。

基本的差别为：MyISAM类型不支持事务处理等高级处理，而InnoDB类型支持。MyISAM类型的表强调的是性能，其执行速度比InnoDB类型更快，但是不提供事务支持，而InnoDB提供事务支持以及外部键等高级数据库功能。

字符集的选择

1、如无特殊要求，必须使用utf8或utf8mb4。

在国内，选择对中文和各语言支持都非常完善的utf8格式是最好的方式，MySQL在5.5之后增加utf8mb4编码，mb4就是most bytes 4的意思，专门用来兼容四字节的unicode。

所以utf8mb4是utf8的超集，除了将编码改为utf8mb4外不需要做其他转换。当然，为了节省空间，一般情况下使用utf8也就够了。

可以使用如下脚本来查看数据库的编码格式

1 SHOW VARIABLES WHERE Variable_name LIKE 'character_set_%' OR Variable_name LIKE 'collation%'; 2 -- 或 3 SHOW VARIABLES Like '%char%';

表设计规范

1、不同应用间所对应的数据库表之间的关联应尽可能减少，不允许使用外键对表之间进行关联，确保组件对应的表之间的独立性，为系统或表结构的重构提供可能性。目前业内的做法一般由程序控制参照完整性。

2、表设计的角度不应该针对整个系统进行数据库设计，而应该根据系统架构中组件划分，针对每个组件所处理的业务进行数据库设计。

3、表必须要有PK，主键的优势是唯一标识、有效引用、高效检索，所以一般情况下尽量有主键字段。

4、一个字段只表示一个含义。

5、表不应该有重复列。

6、禁止使用复杂数据类型(数组,自定义等)，Json类型的使用视情况而定。

7、需要join的字段(连接键)，数据类型必须保持绝对一致，避免隐式转换。比如关联的字段都是int类型。

8、设计应至少满足第三范式,尽量减少数据冗余。一些特殊场景允许反范式化设计，但在项目评审时需要对冗余字段的设计给出解释。

9、TEXT字段作为大体量文本存储，必须放在独立的表中 , 用PK与主表关联。如无特殊需要，禁止使用TEXT、BLOB字段。

10、需要定期删除(或者转移)过期数据的表，通过分表解决，我们的做法是按照2/8法则将操作频率较低的历史数据迁移到历史表中，按照时间或者则曾Id做切割点。

11、单表字段数不要太多，建议最多不要大于50个。过度的宽表对性能也是很大的影响。

12、MySQL在处理大表时，性能就开始明显降低，所以建议单表物理大小限制在16GB，表中数据行数控制在2000W内。

业内的规则是超过2000W性能开始明显降低。但是这个值是灵活的，你可以根据实际情况进行测试来判断，比如阿里的标准就是500W，百度的确是2000W。实际上是否宽表，单行数据所占用的空间都有起到作用的。

13、如果数据量或数据增长在前期规划时就较大，那么在设计评审时就应加入分表策略，后续会有专门的文章来分析数据拆分的做法：垂直拆分（垂直分库和垂直分表）、水平拆分（分库分表和库内分表）；

14、无特殊需求，严禁使用分区表

字段设计规范

1、INT：如无特殊需要，存放整型数字使用UNSIGNED INT型，整型字段后的数字代表显示长度。比如 id int(11) NOT NULL

2、DATETIME：所有需要精确到时间(时分秒)的字段均使用DATETIME,不要使用TIMESTAMP类型。

对于TIMESTAMP，它把写入的时间从当前时区转化为UTC（世界标准时间）进行存储。查询时，将其又转化为客户端当前时区进行返回。而对于DATETIME，不做任何改变，基本上是原样输入和输出。

另外DATETIME存储的范围也比较大：

timestamp所能存储的时间范围为：'1970-01-01 00:00:01.000000' 到 '2038-01-19 03:14:07.999999'。

datetime所能存储的时间范围为：'1000-01-01 00:00:00.000000' 到 '9999-12-31 23:59:59.999999'。

但是特殊情况，对于跨时区的业务，TIMESTAMP更为合适。

3、VARCHAR：所有动态长度字符串全部使用VARCHAR类型,类似于状态等有限类别的字段,也使用可以比较明显表示出实际意义的字符串,而不应该使用INT之类的数字来代替；VARCHAR(N)，

N表示的是字符数而不是字节数。比如VARCHAR(255)，可以最大可存储255个字符（字符包括英文字母，汉字，特殊字符等）。但N应尽可能小，因为MySQL一个表中所有的VARCHAR字段最大长度是65535个字节，且存储字符个数由所选字符集决定。

如UTF8存储一个字符最大要3个字节，那么varchar在存放占用3个字节长度的字符时不应超过21845个字符。同时，在进行排序和创建临时表一类的内存操作时，会使用N的长度申请内存。(如无特殊需要，原则上单个varchar型字段不允许超过255个字符)

4、TEXT：仅仅当字符数量可能超过20000个的时候,才可以使用TEXT类型来存放字符类数据,因为所有MySQL数据库都会使用UTF8字符集。

所有使用TEXT类型的字段必须和原表进行分拆，与原表主键单独组成另外一个表进行存放，与大文本字段的隔离，目的是。如无特殊需要，不使用MEDIUMTEXT、TEXT、LONGTEXT类型

5、对于精确浮点型数据存储，需要使用DECIMAL，严禁使用FLOAT和DOUBLE。

6、如无特殊需要，尽量不使用BLOB类型

7、如无特殊需要，字段建议使用NOT NULL属性，可用默认值代替NULL

8、自增字段类型必须是整型且必须为UNSIGNED，推荐类型为INT或BIGINT，并且自增字段必须是主键或者主键的一部分。

索引设计规范

1、索引区分度

索引必须创建在索引选择性（区分度）较高的列上，选择性的计算方式为: selecttivity = count(distinct c_name)/count(*) ; 如果区分度结果小于0.2，则不建议在此列上创建索引，否则大概率会拖慢SQL执行

2、遵循最左前缀

对于确定需要组成组合索引的多个字段，设计时建议将选择性高的字段靠前放。使用时，组合索引的首字段，必须在where条件中，且需要按照最左前缀规则去匹配。

3、禁止使用外键，可以在程序级别来约束完整性

4、Text类型字段如果需要创建索引，必须使用前缀索引

5、单张表的索引数量理论上应控制在5个以内。经常有大批量插入、更新操作表，应尽量少建索引，索引建立的原则理论上是多读少写的场景。

6、ORDER BY，GROUP BY，DISTINCT的字段需要添加在索引的后面，形成覆盖索引

7、正确理解和计算索引字段的区分度，文中有计算规则，区分度高的索引，可以快速得定位数据，区分度太低，无法有效的利用索引，可能需要扫描大量数据页，和不使用索引没什么差别。

8、正确理解和计算前缀索引的字段长度，文中有判断规则，合适的长度要保证高的区分度和最恰当的索引存储容量，只有达到最佳状态，才是保证高效率的索引。

9、联合索引注意最左匹配原则：必须按照从左到右的顺序匹配，MySQL会一直向右匹配索引直到遇到范围查询(>、<、between、like)然后停止匹配。

如：depno=1 and empname>'' and job=1 如果建立(depno,empname,job)顺序的索引，job是用不到索引的。

10、应需而取策略，查询记录的时候，不要一上来就使用*，只取需要的数据，可能的话尽量只利用索引覆盖，可以减少回表操作，提升效率。

11、正确判断是否使用联合索引（上面联合索引的使用那一小节有说明判断规则），也可以进一步分析到索引下推（IPC），减少回表操作，提升效率。

12、避免索引失效的原则：禁止对索引字段使用函数、运算符操作，会使索引失效。这是实际上就是需要保证索引所对应字段的”干净度“。

13、避免非必要的类型转换，字符串字段使用数值进行比较的时候会导致索引无效。

14、模糊查询'%value%'会使索引无效，变为全表扫描，因为无法判断扫描的区间，但是'value%'是可以有效利用索引。

15、索引覆盖排序字段，这样可以减少排序步骤，提升查询效率

16、尽量的扩展索引，非必要不新建索引。比如表中已经有a的索引，现在要加(a,b)的索引，那么只需要修改原来的索引即可。

举例子：比如一个品牌表，建立的的索引如下，一个主键索引，一个唯一索引

  PRIMARY KEY (`id`),   UNIQUE KEY `uni_brand_define` (`app_id`,`define_id`)

当你同事业务代码中的检索语句如下的时候，应该立即警告了，即没有覆盖索引，也没按照最左前缀原则：

  select brand_id,brand_name from  ds_brand_system where status=?  and define_id=?  and app_id=?

建议改成如下：

  select brand_id,brand_name from  ds_brand_system where app_id=? and define_id=?  and  status=?

约束设计规范

1、PK应该是有序并且无意义的，由开发人员自定义，尽可能简短，并且是自增序列。

2、表中除PK以外,还存在唯一性约束的,可以在数据库中创建以“uk_”作为前缀的唯一约束索引。

3、PK字段不允许更新。

4、禁止创建外键约束，外键约束由程序控制。

5、如无特殊需要，所有字段必须添加非空约束，即not null。

6、如无特殊需要，所有字段必须有默认值。

SQL使用规范

select 检索的规范性

1、尽量避免使用select *，join语句使用select *可能导致只需要访问索引即可完成的查询需要回表取数。

一种是可能取出很多不需要的数据，对于宽表来说，这是灾难；一种是尽可能避免回表，因为取一些根本不需要的数据而回表导致性能低下，是很不合算。

2、严禁使用 select * from t_name ，而不加任何where条件，道理一样，这样会变成全表全字段扫描。

3、MySQL中的text类型字段存储：

3.1、不与其他普通字段存放在一起,因为读取效率低，也会影响其他轻量字段存取效率。

3.2、如果不需要text类型字段，又使用了select *，会让该执行消耗大量io，效率也很低下

4、在取出字段上可以使用相关函数，但应尽可能避免出现 now() , rand() , sysdate() 等不确定结果的函数，在Where条件中的过滤条件字段上严禁使用任何函数，包括数据类型转换函数。大量的计算和转换会造成效率低下，这个在索引那边也描述过了。

5、分页查询语句全部都需要带有排序条件 , 否则很容易引起乱序

6、用in()/union替换or，效率会好一些，并注意in的个数小于300

7、严禁使用%前缀进行模糊前缀查询:如：select a,b,c from t_name where a like ‘%name’; 可以使用%模糊后缀查询如：select a,b from t_name where a like ‘name%’;

8、避免使用子查询，可以把子查询优化为join操作

通常子查询在in子句中，且子查询中为简单SQL(不包含union、group by、order by、limit从句)时，才可以把子查询转化为关联查询进行优化。

子查询性能差的原因：

· 子查询的结果集无法使用索引，通常子查询的结果集会被存储到临时表中，不论是内存临时表还是磁盘临时表都不会存在索引，所以查询性能会受到一定的影响；

· 特别是对于返回结果集比较大的子查询，其对查询性能的影响也就越大；

· 由于子查询会产生大量的临时表也没有索引，所以会消耗过多的CPU和IO资源，产生大量的慢查询。

操作的规范性

1、禁止使用不含字段列表的INSERT语句

如：insert into values ('a','b','c'); 应使用 insert into t_name(c1,c2,c3) values ('a','b','c'); 。

2、大批量写操作（UPDATE、DELETE、INSERT），需要分批多次进行操作

· 大批量操作可能会造成严重的主从延迟，特别是主从模式下，大批量操作可能会造成严重的主从延迟，因为需要slave从master的binlog中读取日志来进行数据同步。

· binlog日志为row格式时会产生大量的日志

程序上的约束

后续我们团队的目标是研发评审工具对开发同学提交的建库、建表、刷数据、查询的语句进行分析，看看是否符合应有的规范。如果不符合，驳回修改。

如何防止 Java 代码被反编译

Sat, 02 Apr 2022 08:03:37 GMT

由于Java字节码的抽象级别较高，因此它们较容易被反编译。本节介绍了几种常用的方法，用于保护Java字节码不被反编译。通常，这些方法不能够绝对防止程序被反编译，而是加大反编译的难度而已，因为这些方法都有自己的使用环境和弱点。

隔离Java程序

最简单的方法就是让用户不能够访问到Java Class程序，这种方法是最根本的方法，具体实现有多种方式。例如，开发人员可以将关键的Java Class放在服务器端，客户端通过访问服务器的相关接口来获得服务，而不是直接访问Class文件。

这样黑客就没有办法[反编译Class文件。目前，通过接口提供服务的标准和协议也越来越多，例如 HTTP、Web Service、RPC等。但是有很多应用都不适合这种保护方式，例如对于单机运行的程序就无法隔离Java程序。这种保护方式见图1所示。

对Class文件进行加密

为了防止Class文件被直接反编译，许多开发人员将一些关键的Class文件进行加密，例如对注册码、序列号管理相关的类等。在使用这些被加密的类之前，程序首先需要对这些类进行解密，而后再将这些类装载到JVM当中。这些类的解密可以由硬件完成，也可以使用软件完成。

在实现时，开发人员往往通过自定义ClassLoader类来完成加密类的装载(注意由于安全性的原因，Applet不能够支持自定义的 ClassLoader)。自定义的ClassLoader首先找到加密的类，而后进行解密，最后将解密后的类装载到JVM当中。

在这种保护方式中，自定义的ClassLoader是非常关键的类。由于它本身不是被加密的，因此它可能成为黑客最先攻击的目标。如果相关的解密密钥和算法被攻克，那么被加密的类也很容易被解密。这种保护方式示意图见图2。

转换成本地代码

将程序转换成本地代码也是一种防止反编译的有效方法。因为本地代码往往难以被反编译。开发人员可以选择将整个应用程序转换成本地代码，也可以选择关键模块转换。如果仅仅转换关键部分模块，Java程序在使用这些模块时，需要使用JNI技术进行调用。

当然，在使用这种技术保护Java程序的同时，也牺牲了Java的跨平台特性。对于不同的平台，我们需要维护不同版本的本地代码，这将加重软件支持和维护的工作。不过对于一些关键的模块，有时这种方案往往是必要的。

为了保证这些本地代码不被修改和替代，通常需要对这些代码进行数字签名。在使用这些本地代码之前，往往需要对这些本地代码进行认证，确保这些代码没有被黑客更改。如果签名检查通过，则调用相关JNI方法。这种保护方式示意图见图3。

代码混淆

代码混淆是对Class文件进行重新组织和处理，使得处理后的代码与处理前代码完成相同的功能(语义)。但是混淆后的代码很难被[反编译，即[反编译后得出的代码是非常难懂、晦涩的，因此[反编译人员很难得出程序的真正语义。

从理论上来说，黑客如果有足够的时间，被混淆的代码仍然可能被破解，甚至目前有些人正在研制反混淆的工具。但是从实际情况来看，由于混淆技术的多元化发展，混淆理论的成熟，经过混淆的Java代码还是能够很好地防止[反编译。下面我们会详细介绍混淆技术，因为混淆是一种保护Java程序的重要技术。图4是代码混淆的示图。

图4 代码混淆示意图

几种技术的总结以上几种技术都有不同的应用环境，各自都有自己的弱点，表1是相关特点的比较。

混淆技术介绍

表1 不同保护技术比较表

到目前为止，对于Java程序的保护，混淆技术还是最基本的保护方法。Java混淆工具也非常多，包括商业的、免费的、开放源代码的。Sun公司也提供了自己的混淆工具。它们大多都是对Class文件进行混淆处理，也有少量工具首先对源代码进行处理，然后再对Class进行处理，这样加大了混淆处理的力度。

目前，商业上比较成功的混淆工具包括JProof公司的1stBarrier系列、Eastridge公司的JShrink和 4thpass.com的SourceGuard等。主要的混淆技术按照混淆目标可以进行如下分类，它们分别为符号混淆(Lexical Obfuscation)、数据混淆(Data Obfuscation)、控制混淆(Control Obfuscation)、预防性混淆(Prevent Transformation)。

符号混淆

在Class中存在许多与程序执行本身无关的信息，例如方法名称、变量名称，这些符号的名称往往带有一定的含义。例如某个方法名为 getKeyLength()，那么这个方法很可能就是用来返回Key的长度。

符号混淆就是将这些信息打乱，把这些信息变成无任何意义的表示，例如将所有的变量从vairant_001开始编号；对于所有的方法从method_001开始编号。

这将对反编译带来一定的困难。对于私有函数、局部变量，通常可以改变它们的符号，而不影响程序的运行。但是对于一些接口名称、公有函数、成员变量，如果有其它外部模块需要引用这些符号，我们往往需要保留这些名称，否则外部模块找不到这些名称的方法和变量。因此，多数的混淆工具对于符号混淆，都提供了丰富的选项，让用户选择是否、如何进行符号混淆。

数据混淆

数据混淆是对程序使用的数据进行混淆。混淆的方法也有多种，主要可以分为改变数据存储及编码(Store and Encode Transform)、改变数据访问(Access Transform)。

改变数据存储和编码可以打乱程序使用的数据存储方式。例如将一个有10个成员的数组，拆开为10个变量，并且打乱这些变量的名字；将一个两维数组转化为一个一维数组等。对于一些复杂的数据结构，我们将打乱它的数据结构，例如用多个类代替一个复杂的类等。

另外一种方式是改变数据访问。例如访问数组的下标时，我们可以进行一定的计算，图5就是一个例子。

在实践混淆处理中，这两种方法通常是综合使用的，在打乱数据存储的同时，也打乱数据访问的方式。经过对数据混淆，程序的语义变得复杂了，这样增大了反编译的难度。

控制混淆

控制混淆就是对程序的控制流进行混淆，使得程序的控制流更加难以[反编译，通常控制流的改变需要增加一些额外的计算和控制流，因此在性能上会给程序带来一定的负面影响。有时，需要在程序的性能和混淆程度之间进行权衡。控制混淆的技术最为复杂，技巧也最多。这些技术可以分为如下几类：

增加混淆控制通过增加额外的、复杂的控制流，可以将程序原来的语义隐藏起来。例如，对于按次序执行的两个语句A、B，我们可以增加一个控制条件，以决定B的执行。通过这种方式加大反汇编的难度。但是所有的干扰控制都不应该影响B的执行。图6就给出三种方式，为这个例子增加混淆控制。

图6 增加混淆控制的三种方式

控制流重组重组控制流也是重要的混淆方法。例如，程序调用一个方法，在混淆后，可以将该方法代码嵌入到调用程序当中。反过来，程序中的一段代码也可以转变为一个函数调用。另外，对于一个循环的控制流，为可以拆分多个循环的控制流，或者将循环转化成一个递归过程。这种方法最为复杂，研究的人员也非常多。

预防性混淆

这种混淆通常是针对一些专用的反编译器而设计的，一般来说，这些技术利用反编译器的弱点或者Bug来设计混淆方案。例如，有些反编译器对于 Return后面的指令不进行反编译，而有些混淆方案恰恰将代码放在Return语句后面。这种混淆的有效性对于不同反编译器的作用也不太相同的。一个好的混淆工具，通常会综合使用这些混淆技术。

案例分析

在实践当中，保护一个大型Java程序经常需要综合使用这些方法，而不是单一使用某一种方法。这是因为每种方法都有其弱点和应用环境。综合使用这些方法使得Java程序的保护更加有效。另外，我们经常还需要使用其它的相关安全技术，例如安全认证、数字签名、PKI等。

本文给出的例子是一个Java应用程序，它是一个SCJP(Sun Certificate Java Programmer)的模拟考试软件。该应用程序带有大量的模拟题目，所有的题目都被加密后存储在文件中。由于它所带的题库是该软件的核心部分，所以关于题库的存取和访问就成为非常核心的类。一旦这些相关的类被反编译，则所有的题库将被破解。现在，我们来考虑如何保护这些题库及相关的类。

在这个例子中，我们考虑使用综合保护技术，其中包括本地代码和混淆技术。因为该软件主要发布在Windows上，因此转换成本地代码后，仅仅需要维护一个版本的本地代码。另外，混淆对Java程序也是非常有效的，适用于这种独立发布的应用系统。

在具体的方案中，我们将程序分为两个部分，一个是由本地代码编写的题库访问的模块，另外一个是由Java开发的其它模块。这样可以更高程度地保护题目管理模块不被[反编译。对于Java开发的模块，我们仍然要使用混淆技术。该方案的示意图参见图7。

图7 SCJP保护技术方案图

对于题目管理模块，由于程序主要在Windows下使用，所以使用C++开发题库访问模块，并且提供了一定的访问接口。为了保护题库访问的接口，我们还增加了一个初始化接口，用于每次使用题库访问接口之前的初始化工作。它的接口主要分为两类：

初始化接口

在使用题库模块之前，我们必须先调用初始化接口。在调用该接口时，客户端需要提供一个随机数作为参数。题库管理模块和客户端通过这个随机数，按一定的算法同时生成相同的SessionKey，用于加密以后输入和输出的所有数据。通过这种方式，只有授权(有效)的客户端才能够连接正确的连接，生成正确的 SessionKey，用于访问题库信息。非法的客户很难生成正确的SessionKey，因此无法获得题库的信息。如果需要建立更高的保密级别，也可以采用双向认证技术。

数据访问接口

认证完成之后，客户端就可以正常的访问题库数据。但是，输入和输出的数据都是由SessionKey所加密的数据。因此，只有正确的题库管理模块才能够使用题库管理模块。图8时序图表示了题库管理模块和其它部分的交互过程。

虚拟机挂了怎么办？一张图给你解决了！

Fri, 01 Apr 2022 14:04:19 GMT

SpringBoot性能优化大全，贼好使！

Fri, 01 Apr 2022 14:02:27 GMT

SpringBoot 已经成为 Java 届的 No.1 框架，每天都在蹂躏着数百万的程序员们。当服务的压力上升，对 SpringBoot 服务的优化就会被提上议程。

本文将详细讲解 SpringBoot 服务优化的一般思路，适合收藏之。

有监控才有方向

在开始对 SpringBoot 服务进行性能优化之前，我们需要做一些准备，把 SpringBoot 服务的一些数据暴露出来。

比如，你的服务用到了缓存，就需要把缓存命中率这些数据进行收集；用到了数据库连接池，就需要把连接池的参数给暴露出来。

我们这里采用的监控工具是 Prometheus，它是一个是时序数据库，能够存储我们的指标。SpringBoot 可以非常方便的接入到 Prometheus 中。

创建一个 SpringBoot 项目后，首先，加入 maven 依赖。

<dependency>      <groupId>org.springframework.boot</groupId>      <artifactId>spring-boot-starter-actuator</artifactId>  </dependency>  <dependency>      <groupId>io.micrometer</groupId>      <artifactId>micrometer-registry-prometheus</artifactId>  </dependency>  <dependency>      <groupId>io.micrometer</groupId>      <artifactId>micrometer-core</artifactId>  </dependency>

然后，我们需要在 application.properties 配置文件中，开放相关的监控接口。

management.endpoint.metrics.enabled=true management.endpoints.web.exposure.include=* management.endpoint.prometheus.enabled=true management.metrics.export.prometheus.enabled=true

启动之后，我们就可以通过访问 http://localhost:8080/actuator/prometheus 来获取监控数据。

想要监控业务数据也是比较简单的。你只需要注入一个MeterRegistry实例即可。

下面是一段示例代码：

@Autowired MeterRegistry registry;  @GetMapping("/test") @ResponseBody public String test() {     registry.counter("test",             "from", "127.0.0.1",             "method", "test"     ).increment();      return "ok"; }

从监控连接中，我们可以找到刚刚添加的监控信息。

test_total{from="127.0.0.1",method="test",} 5.0

这里简单介绍一下流行的 Prometheus 监控体系，Prometheus 使用拉的方式获取监控数据，这个暴露数据的过程可以交给功能更加齐全的 telegraf 组件。

如图，我们通常使用 Grafana 进行监控数据的展示，使用 AlertManager 组件进行提前预警。这一部分的搭建工作不是我们的重点，感兴趣的同学可自行研究。

下图便是一张典型的监控图，可以看到 Redis 的缓存命中率等情况。

Java生成火焰图

火焰图是用来分析程序运行瓶颈的工具。在纵向，表示的是调用栈的深度；横向表明的是消耗的时间。所以格子的宽度越大，越说明它可能是一个瓶颈。

火焰图也可以用来分析 Java 应用。可以从 github 上下载 async-profiler 的压缩包进行相关操作。

比如，我们把它解压到 /root/ 目录。然后以 javaagent 的方式来启动 Java 应用。

命令行如下：

java -agentpath:/root/build/libasyncProfiler.so=start,svg,file=profile.svg -jar spring-petclinic-2.3.1.BUILD-SNAPSHOT.jar

运行一段时间后，停止进程，可以看到在当前目录下，生成了 profile.svg 文件，这个文件是可以用浏览器打开的，一层层向下浏览，即可找到需要优化的目标。

Skywalking

对于一个 web 服务来说，最缓慢的地方就在于数据库操作。所以，使用本地缓存和分布式缓存优化，能够获得最大的性能提升。

对于如何定位到复杂分布式环境中的问题，我这里想要分享另外一个工具：Skywalking。

Skywalking 是使用探针技术（JavaAgent）来实现的。通过在 Java 的启动参数中，加入 javaagent 的 Jar 包，即可将性能数据和调用链数据封装、发送到 Skywalking 的服务器。

下载相应的安装包（如果使用 ES 存储，需要下载专用的安装包），配置好存储之后，即可一键启动。

将 agent 的压缩包，解压到相应的目录。

tar xvf skywalking-agent.tar.gz  -C /opt/

在业务启动参数中加入 agent 的包。比如，原来的启动命令是：

java  -jar /opt/test-service/spring-boot-demo.jar  --spring.profiles.active=dev

改造后的启动命令是：

java -javaagent:/opt/skywalking-agent/skywalking-agent.jar -Dskywalking.agent.service_name=the-demo-name  -jar /opt/test-service/spring-boot-demo.ja  --spring.profiles.active=dev

访问一些服务的链接，打开 Skywalking 的 UI，即可看到下图的界面。我们可以从图中找到响应比较慢 QPS 又比较高的的接口，进行专项优化。

优化思路

对一个普通的 Web 服务来说，我们来看一下，要访问到具体的数据，都要经历哪些主要的环节。

如下图，在浏览器中输入相应的域名，需要通过 DNS 解析到具体的 IP 地址上。为了保证高可用，我们的服务一般都会部署多份，然后使用 Nginx 做反向代理和负载均衡。

Nginx 根据资源的特性，会承担一部分动静分离的功能。其中，动态功能部分，会进入我们的 SpringBoot 服务

SpringBoot 默认使用内嵌的 tomcat 作为 Web 容器，使用典型的 MVC 模式，最终访问到我们的数据。

HTTP优化

下面我们举例来看一下，哪些动作能够加快网页的获取。为了描述方便，我们仅讨论 HTTP1.1 协议的。

使用 CDN 加速文件获取

比较大的文件，尽量使用 CDN（Content Delivery Network）分发。甚至是一些常用的前端脚本、样式、图片等，都可以放到 CDN 上。CDN 通常能够加快这些文件的获取，网页加载也更加迅速。

合理设置 Cache-Control 值

浏览器会判断 HTTP 头 Cache-Control 的内容，用来决定是否使用浏览器缓存，这在管理一些静态文件的时候，非常有用。

相同作用的头信息还有 Expires。Cache-Control 表示多久之后过期，Expires 则表示什么时候过期。

这个参数可以在 Nginx 的配置文件中进行设置：

location ~* ^.+\.(ico|gif|jpg|jpeg|png)$ {              # 缓存1年             add_header Cache-Control: no-cache, max-age=31536000; }

减少单页面请求域名的数量

减少每个页面请求的域名数量，尽量保证在 4 个之内。这是因为，浏览器每次访问后端的资源，都需要先查询一次 DNS，然后找到 DNS 对应的 IP 地址，再进行真正的调用。

DNS 有多层缓存，比如浏览器会缓存一份、本地主机会缓存、ISP 服务商缓存等。从 DNS 到 IP 地址的转变，通常会花费 20-120ms 的时间。减少域名的数量，可加快资源的获取。

开启 gzip

开启 gzip，可以先把内容压缩后，浏览器再进行解压。由于减少了传输的大小，会减少带宽的使用，提高传输效率。

在 Nginx 中可以很容易的开启。配置如下：

gzip on; gzip_min_length 1k; gzip_buffers 4 16k; gzip_comp_level 6; gzip_http_version 1.1; gzip_types text/plain application/javascript text/css;

对资源进行压缩

对 JavaScript 和 CSS，甚至是 HTML 进行压缩。道理类似，现在流行的前后端分离模式，一般都是对这些资源进行压缩的。

使用 keepalive

由于连接的创建和关闭，都需要耗费资源。用户访问我们的服务后，后续也会有更多的互动，所以保持长连接可以显著减少网络交互，提高性能。

nginx 默认开启了对客户端的 keep avlide 支持。你可以通过下面两个参数来调整它的行为。

http {     keepalive_timeout  120s 120s;     keepalive_requests 10000; }

nginx 与后端 upstream 的长连接，需要手工开启，参考配置如下：

location ~ /{         proxy_pass http://backend;        proxy_http_version 1.1;        proxy_set_header Connection ""; }

Tomcat优化

Tomcat 本身的优化，也是非常重要的一环。可以直接参考：《搞定tomcat重要参数调优！》

自定义Web容器

如果你的项目并发量比较高，想要修改最大线程数、最大连接数等配置信息，可以通过自定义 Web 容器的方式，代码如下所示：

@SpringBootApplication(proxyBeanMethods = false) public class App implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {  public static void main(String[] args) {   SpringApplication.run(PetClinicApplication.class, args);  }  @Override  public void customize(ConfigurableServletWebServerFactory factory) {   TomcatServletWebServerFactory f = (TomcatServletWebServerFactory) factory;         f.setProtocol("org.apache.coyote.http11.Http11Nio2Protocol");    f.addConnectorCustomizers(c -> {    Http11NioProtocol protocol = (Http11NioProtocol) c.getProtocolHandler();    protocol.setMaxConnections(200);    protocol.setMaxThreads(200);    protocol.setSelectorTimeout(3000);    protocol.setSessionTimeout(3000);    protocol.setConnectionTimeout(3000);   });  } }

注意上面的代码，我们设置了它的协议为 org.apache.coyote.http11.Http11Nio2Protocol，意思就是开启了 Nio2。

这个参数在 Tomcat8.0 之后才有，开启之后会增加一部分性能。对比如下：

默认：

[root@localhost wrk2-master]# ./wrk -t2 -c100 -d30s -R2000 http://172.16.1.57:8080/owners?lastName= Running 30s test @ http://172.16.1.57:8080/owners?lastName=   2 threads and 100 connections   Thread calibration: mean lat.: 4588.131ms, rate sampling interval: 16277ms   Thread calibration: mean lat.: 4647.927ms, rate sampling interval: 16285ms   Thread Stats   Avg      Stdev     Max   +/- Stdev     Latency    16.49s     4.98s   27.34s    63.90%     Req/Sec   106.50      1.50   108.00    100.00%   6471 requests in 30.03s, 39.31MB read   Socket errors: connect 0, read 0, write 0, timeout 60 Requests/sec:    215.51 Transfer/sec:      1.31MB

Nio2：

[root@localhost wrk2-master]# ./wrk -t2 -c100 -d30s -R2000 http://172.16.1.57:8080/owners?lastName= Running 30s test @ http://172.16.1.57:8080/owners?lastName=   2 threads and 100 connections   Thread calibration: mean lat.: 4358.805ms, rate sampling interval: 15835ms   Thread calibration: mean lat.: 4622.087ms, rate sampling interval: 16293ms   Thread Stats   Avg      Stdev     Max   +/- Stdev     Latency    17.47s     4.98s   26.90s    57.69%     Req/Sec   125.50      2.50   128.00    100.00%   7469 requests in 30.04s, 45.38MB read   Socket errors: connect 0, read 0, write 0, timeout 4 Requests/sec:    248.64 Transfer/sec:      1.51MB

你甚至可以将 tomcat 替换成 undertow。undertow 也是一个 Web 容器，更加轻量级一些，占用的内容更少，启动的守护进程也更少，更改方式如下：

<dependency>       <groupId>org.springframework.boot</groupId>       <artifactId>spring-boot-starter-web</artifactId>       <exclusions>         <exclusion>           <groupId>org.springframework.boot</groupId>           <artifactId>spring-boot-starter-tomcat</artifactId>         </exclusion>       </exclusions>     </dependency>     <dependency>       <groupId>org.springframework.boot</groupId>       <artifactId>spring-boot-starter-undertow</artifactId>     </dependency>

各个层次的优化方向

Controller 层

controller 层用于接收前端的查询参数，然后构造查询结果。现在很多项目都采用前后端分离的架构，所以 controller 层的方法，一般会使用 @ResponseBody 注解，把查询的结果，解析成 JSON 数据返回（兼顾效率和可读性）。

由于 controller 只是充当了一个类似功能组合和路由的角色，所以这部分对性能的影响就主要体现在数据集的大小上。如果结果集合非常大，JSON 解析组件就要花费较多的时间进行解析。

大结果集不仅会影响解析时间，还会造成内存浪费。假如结果集在解析成 JSON 之前，占用的内存是 10MB，那么在解析过程中，有可能会使用 20M 或者更多的内存去做这个工作。

我见过很多案例，由于返回对象的嵌套层次太深、引用了不该引用的对象（比如非常大的 byte[] 对象），造成了内存使用的飙升。

所以，对于一般的服务，保持结果集的精简，是非常有必要的，这也是 DTO（data transfer object）存在的必要。

如果你的项目，返回的结果结构比较复杂，对结果集进行一次转换是非常有必要的。

另外，可以使用异步 Servlet 对 Controller 层进行优化。它的原理如下：Servlet 接收到请求之后，将请求转交给一个异步线程来执行业务处理，线程本身返回至容器，异步线程处理完业务以后，可以直接生成响应数据，或者将请求继续转发给其它 Servlet。

Service 层

service 层用于处理具体的业务，大部分功能需求都是在这里完成的。service 层一般是使用单例模式（prototype），很少会保存状态，而且可以被 controller 复用。

service 层的代码组织，对代码的可读性、性能影响都比较大。我们常说的设计模式，大多数都是针对于 service 层来说的。

这里要着重提到的一点，就是分布式事务。

如上图，四个操作分散在三个不同的资源中。要想达到一致性，需要三个不同的资源进行统一协调。

它们底层的协议，以及实现方式，都是不一样的。那就无法通过 Spring 提供的 Transaction 注解来解决，需要借助外部的组件来完成。

很多人都体验过，加入了一些保证一致性的代码，一压测，性能掉的惊掉下巴。分布式事务是性能杀手，因为它要使用额外的步骤去保证一致性，常用的方法有：两阶段提交方案、TCC、本地消息表、MQ 事务消息、分布式事务中间件等。

如上图，分布式事务要在改造成本、性能、实效等方面进行综合考虑。有一个介于分布式事务和非事务之间的名词，叫做柔性事务。柔性事务的理念是将业务逻辑和互斥操作，从资源层上移至业务层面。

关于传统事务和柔性事务，我们来简单比较一下。

***ACID：***关系数据库, 最大的特点就是事务处理，即满足 ACID。

原子性（Atomicity）：事务中的操作要么都做，要么都不做。
一致性（Consistency）：系统必须始终处在强一致状态下。
隔离性（Isolation）：一个事务的执行不能被其他事务所干扰。
持续性（Durability）：一个已提交的事务对数据库中数据的改变是永久性的。

***BASE：***BASE 方法通过牺牲一致性和孤立性来提高可用性和系统性能。

BASE 为 Basically Available，Soft-state，Eventually consistent 三者的缩写，其中 BASE 分别代表：

基本可用（Basically Available）：系统能够基本运行、一直提供服务。
软状态（Soft-state）：系统不要求一直保持强一致状态。
最终一致性（Eventual consistency）：系统需要在某一时刻后达到一致性要求。

互联网业务，推荐使用补偿事务，完成最终一致性。比如，通过一系列的定时任务，完成对数据的修复。

Dao 层

经过合理的数据缓存，我们都会尽量避免请求穿透到 Dao 层。除非你对 ORM 本身提供的缓存特性特别的熟悉，否则，都推荐你使用更加通用的方式去缓存数据。

Dao 层，主要在于对 ORM 框架的使用上。比如，在 JPA 中，如果加了一对多或者多对多的映射关系，而又没有开启懒加载，级联查询的时候就容易造成深层次的检索，造成了内存开销大、执行缓慢的后果。

在一些数据量比较大的业务中，多采用分库分表的方式。在这些分库分表组件中，很多简单的查询语句，都会被重新解析后分散到各个节点进行运算，最后进行结果合并。

举个例子，select count(*) from a 这句简单的 count 语句，就可能将请求路由到十几张表中去运算，最后在协调节点进行统计，执行效率是可想而知的。

目前，分库分表中间件，比较有代表性的是驱动层的 ShardingJdbc 和代理层的 MyCat，它们都有这样的问题。

这些组件提供给使用者的视图是一致的，但我们在编码的时候，一定要注意这些区别。

总结

下面我们来总结一下。我们简单看了一下 SpringBoot 常见的优化思路，介绍了三个新的性能分析工具。

一个是监控系统 Prometheus，可以看到一些具体的指标大小；一个是火焰图，可以看到具体的代码热点；一个是 Skywalking，可以分析分布式环境中的调用链。

在对性能有疑惑的时候，我们都会采用类似于神农氏尝百草的方式，综合各种测评工具的结果进行分析。

SpringBoot 自身的 Web 容器是 Tomcat，那我们就可以通过对 Tomcat 的调优来获取性能提升。当然，对于服务上层的负载均衡 Nginx，我们也提供了一系列的优化思路。

最后，我们看了在经典的 MVC 架构下，Controller、Service、Dao 的一些优化方向，并着重看了 Service 层的分布式事务问题。

SpringBoot 作为一个广泛应用的服务框架，在性能优化方面已经做了很多工作，选用了很多高速组件。

比如，数据库连接池默认使用 hikaricp，Redis 缓存框架默认使用 lettuce，本地缓存提供 caffeine 等。

对于一个普通的于数据库交互的 Web 服务来说，缓存是最主要的优化手，但细节决定成败。

SpringBoot 三大开发工具，你都用过么？

Fri, 01 Apr 2022 13:48:00 GMT

一、SpringBoot Dedevtools

他是一个让SpringBoot支持热部署的工具，下面是引用的方法

要么在创建项目的时候直接勾选下面的配置：

要么给springBoot项目添加下面的依赖：

<dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-devtools</artifactId>     <optional>true</optional> </dependency>

idea修改完代码后再按下 ctrl + f9 使其重新编译一下，即完成了热部署功能
eclipse是按ctrl + s保存即可自动编译

如果你想一修改代码就自动重新编译，无需按ctrl+f9。只需要下面的操作：

1.在idea的setting中把下面的勾都打上

2.进入pom.xml,在build的反标签后给个光标，然后按Alt+Shift+ctrl+/

3.然后勾选下面的东西，接着重启idea即可

二、Lombok

Lombok是简化JavaBean开发的工具，让开发者省去构造器，getter,setter的书写。另外，搜索公众号互联网架构师后台回复“面试”，获取一份惊喜礼包。

在项目初始化时勾选下面的配置，即可使用Lombok

或者在项目中导入下面的依赖：

<dependency>     <groupId>org.projectlombok</groupId>     <artifactId>lombok</artifactId>     <optional>true</optional> </dependency>

使用时，idea还需要下载下面的插件：

下面的使用的例子

import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableName; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor;  @AllArgsConstructor//全参构造器 @NoArgsConstructor//无参构造器 @Data//getter + setter public class User {     private Long id;     private String name;     private Integer age;     private String email; }

三、Spring Configuration Processor

该工具是给实体类的属性注入开启提示，自我感觉该工具意义不是特别大！

因为SpringBoot存在属性注入，比如下面的实体类：

package org.lzl.HelloWorld.entity;  import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component;  /**  * @author Lenovo  *  */ @Component @ConfigurationProperties(prefix = "mypet") public class Pet {     private String nickName;     private String strain;  public String getNickName() {   return nickName;  }  public void setNickName(String nickName) {   this.nickName = nickName;  }  public String getStrain() {   return strain;  }  public void setStrain(String strain) {   this.strain = strain;  }  @Override  public String toString() {   return "Pet [nickName=" + nickName + ", strain=" + strain + "]";  }        }

想要在application.properties和application.yml中给mypet注入属性，却没有任何的提示，为了解决这一问题，我们在创建SpringBoot的时候勾选下面的场景：

或者直接在项目中添加下面的依赖:

<dependency>      <groupId>org.springframework.boot</groupId>      <artifactId>spring-boot-configuration-processor</artifactId>      <optional>true</optional>  </dependency>

并在build的标签中排除对该工具的打包：（减少打成jar包的大小）

 <build>         <plugins>             <plugin>                 <groupId>org.springframework.boot</groupId>                 <artifactId>spring-boot-maven-plugin</artifactId>                 <configuration>                     <excludes>                         <exclude>                             <groupId>org.springframework.boot</groupId>                             <artifactId>spring-boot-configuration-processor</artifactId>                         </exclude>                     </excludes>                 </configuration>             </plugin>         </plugins>     </build>

使用 Spring Boot 开发邮件系统

Fri, 01 Apr 2022 13:45:00 GMT

电子邮件是因特网上使用得非常多的一种应用，它可以非常方便的使相隔很远的人进行通信，它主要的特点就是操作简单，快捷。现在的电子邮件系统以是存储与转发的模型为基础。邮件服务器接受、转发、提交及存储邮件。寄信人、收信人及他们的计算机都不用同时在线。寄信人和收信人只需在寄信或收信时简短的连线到邮件服务器即可。

互联网发展到现在，邮件服务已经成为互联网企业中必备功能之一，应用场景非常广泛，比较常见的有：用户注册、忘记密码、监控提醒、企业营销等。大多数互联网企业都会将邮件发送抽取为一个独立的微服务，对外提供接口来支持各种类型的邮件发送。

本篇内容会从以下几部分来给大家介绍如何开发一个邮件系统：

电子邮件的历史
发送邮件涉及到哪些协议
介绍一个完整的邮件发送流程
快速体验邮件发送流程
介绍如何开发文本、HTML、附件、图片的邮件
做一个邮件系统需要考虑的因素

邮件历史

我们先来回顾一下整个邮件的发展历史。

电子邮件的发展

电子邮件发明在 70 年代，却在 80 年才开始有人使用。70 年代的沉寂主要是由于当时使用 Arpanet 网络的人太少，网络的速度也仅为目前 56Kbps 标准速度的二十分之一，受网络速度的限制，那时的用户只能发送些简短的信息，根本别想象现在那样发送大量照片。

到 80 年代中期，个人电脑兴起，电子邮件开始在电脑迷以及大学生中广泛传播开来；到 90 年代中期，互联网浏览器诞生，全球网民人数激增，电子邮件被广为使用。2000 零几年的时候，那时候没有网盘，上大学的时候常常使用邮箱存储东西，那时候的邮箱也主要以网易为主；到了现在，几乎每个人都有好几个邮箱，QQ 邮箱、126 邮箱、公司邮箱等等，电子邮件已经成为人们生活和工作不可或缺的一部分。

电子邮件发展历程：

1974 年，因为 ARPANET 的推广，电子邮件的用户已经达到了数百人，不过他们大都是军方用户。自那之后，电子邮件开始了飞速的发展。Lawrence Roberts，这位当时为 ARPANET 服务的科学家为他的上司发明了邮件中的文件夹，以便其能够更好地梳理自己的邮件。
1975 年，南加州大学的 John Vittal 第一次发明了邮件相关的服务软件。
1977 年，现代的电子邮件系统开始出现。使用同一款软件并且联网了的计算机都可以使用 Tomlinson 的方法去发邮件。
1982 年，有关电子邮件第一个重要的标准出台了，这就是 SMTP（简单邮件传输协议 Simple Mail Transfer Protocol），它是第一个基于互联网基础传输电子邮件的标准。时至今日它还在被人使用。而也是在这一年，「email」这个词第一次出现了。
1983 年 1 月 1 日，ARPANET 正式使用 TCP/IP 取代旧的网络控制协议（NCP，Network Control Protocol），从而成为今天的互联网的基石。
从 80 年代中期开始，电子邮件被广泛使用。我国发出的第一封电子邮件就在 1987 年，是由北京计算机应用技术研究所发送到德国的。
1988 年，世界上第一个商用邮件系统 Eudora 出现，发明者是美国软件工程师 Steve Dorner。
1990 年，HTML 格式的邮件出现，除了文字之外，我们也能在邮件中看到图片了。
1992 年，MIME 协议（多用途互联网邮件扩展，Multipurpose Internet Mail Extensions）诞生，它扩展了电子邮件标准，使其能够支援更多种形式的内容。也是在这一年，微软在 MS-DOS 系统上，推出了 Outlook 邮件应用。
1996 年，世界上第一个以网页为基础的邮件应用 Hotmail 诞生，然后微软在下一年花了 4 亿美元买下了它。
……

世界的第一封电子邮件

1969 年 10 月世界上的第一封电子邮件是由计算机科学家 Leonard K. 教授发给他的同事的一条简短消息。

据《互联网周刊》报道世界上的第一封电子邮件是由计算机科学家Leonard K.教授发给他的同事的一条简短消息(时间应该是1969年10月)，这条消息只有两个字母："LO"。Leonard K. 教授因此被称为电子邮件之父。所以第一条网上信息就是‘LO’，意思是‘你好！’”

当然这个说法也有一点争议，另外一种说法是麻省理工学院博士 Ray Tomlinson 发送的第一封邮件，这里不再展开讨论。

中国的第一封电子邮件

1987 年 9 月 14 日中国第一封电子邮件是由“德国互联网之父”维纳·措恩与王运丰在当时的兵器工业部下属单位—计算机应用技术研究所（简称 ICA）发往德国卡尔斯鲁厄大学的，其内容为德文和英文双语，第一段大意如下：

原文：“ Across the Great Wall we can reach every corner in the world. ”

中文大意：“ 越过长城，我们可以到达世界的每一个角落。 ”

这是中国通过北京与德国卡尔斯鲁厄大学之间的网络连接，发出的第一封电子邮件。现在看这封邮件内容，颇具深意！

邮件协议

发送邮件的本质是将一个人的信息传输给另外一个人，那么如何传输就需要商量好标准，这些标准就是协议。最初只有两个协议：

SMTP 协议

SMTP 的全称是 “Simple Mail Transfer Protocol”，即简单邮件传输协议。它是一组用于从源地址到目的地址传输邮件的规范，通过它来控制邮件的中转方式。它的一个重要特点是它能够在传送中接力传送邮件，即邮件可以通过不同网络上的主机接力式传送。

SMTP 认证，简单地说就是要求必须在提供了账户名和密码之后才可以登录 SMTP 服务器，这就使得那些垃圾邮件的散播者无可乘之机。增加 SMTP 认证的目的是为了使用户避免受到垃圾邮件的侵扰。SMTP主要负责底层的邮件系统如何将邮件从一台机器传至另外一台机器。

POP3 协议

POP3 是 Post Office Protocol 3 的简称，即邮局协议的第3个版本，它规定怎样将个人计算机连接到 Internet 的邮件服务器和下载电子邮件的电子协议。它是因特网电子邮件的第一个离线协议标准，POP3 允许用户从服务器上把邮件存储到本地主机（即自己的计算机）上，同时删除保存在邮件服务器上的邮件。

POP 协议支持“离线”邮件处理。其具体过程是：邮件发送到服务器上，电子邮件客户端调用邮件客户机程序以连接服务器，并下载所有未阅读的电子邮件。这种离线访问模式是一种存储转发服务，将邮件从邮件服务器端送到个人终端机器上，一般是 PC机或 MAC。一旦邮件发送到 PC 机或 MAC上，邮件服务器上的邮件将会被删除。但目前的POP3邮件服务器大都可以“只下载邮件，服务器端并不删除”，也就是改进的POP3协议。

** SMTP 和 POP3 是最初的俩个协议，随着邮件的不断发展后来又增加了两个协议：**

IMAP 协议

全称 Internet Mail Access Protocol（交互式邮件存取协议），IMAP 是斯坦福大学在1986年开发的研发的一种邮件获取协议，即交互式邮件存取协议，它是跟 POP3 类似邮件访问标准协议之一。不同的是，开启了 IMAP 后，在电子邮件客户端收取的邮件仍然保留在服务器上，同时在客户端上的操作都会反馈到服务器上，如：删除邮件，标记已读等，服务器上的邮件也会做相应的动作。所以无论从浏览器登录邮箱或者客户端软件登录邮箱，看到的邮件以及状态都是一致的。

IMAP 的一个与 POP3 的区别是：IMAP 它只下载邮件的主题，并不是把所有的邮件内容都下载下来，而是你邮箱当中还保留着邮件的副本，没有把你原邮箱中的邮件删除，你用邮件客户软件阅读邮件时才下载邮件的内容。较好支持这两种协议的邮件客户端有：Foxmail、Outlook 等。

Mime 协议

由于 SMTP 这个协议开始是基于纯 ASCⅡ文本的，在二进制文件上处理得并不好。后来开发了用来编码二进制文件的标准，如 MIME，以使其通过 SMTP 来传输。今天，大多数 SMTP 服务器都支持 8 位 MIME 扩展，它使二进制文件的传输变得几乎和纯文本一样简单。

用一张图来看发送邮件过程中的协议使用：

实线代表 neo@126.com 发送邮件给 itclub@aa.com；虚线代表 itclub@aa.com 发送邮件给 neo@126.com

邮件发送流程

发信人在用户代理上编辑邮件，并写清楚收件人的邮箱地址；
用户代理根据发信人编辑的信息，生成一封符合邮件格式的邮件；
用户代理把邮件发送到发信人的的邮件服务器上，邮件服务器上面有一个缓冲队列，发送到邮件服务器上面的邮件都会加入到缓冲队列中，等待邮件服务器上的 SMTP 客户端进行发送；
发信人的邮件服务器使用 SMTP 协议把这封邮件发送到收件人的邮件服务器上
收件人的邮件服务器收到邮件后，把这封邮件放到收件人在这个服务器上的信箱中；
收件人使用用户代理来收取邮件。首先用户代理使用 POP3 协议来连接收件人所在的邮件服务器，身份验证成功后，用户代理就可以把邮件服务器上面的收件人邮箱里面的邮件读取出来，并展示给收件人。

这就是邮件发送的一个完整流程。

简单使用

最早期的时候使用 JavaMail 相关 API 来开发，需要自己去封装消息体，代码量比较庞大；后来 Spring 推出了 JavaMailSender 简化了邮件发送过程，JavaMailSender 提供了强大的邮件发送功能，可支持各种类型的邮件发送。

现在 Spring Boot 在 JavaMailSender 的基础上又进行了封装，就有了现在的 spring-boot-starter-mail，让邮件发送流程更加简洁和完善。下面给大家介绍如何使用 Spring Boot 发送邮件。

1、pom 包配置

引入加 spring-boot-starter-mail 依赖包：

<dependencies>     <dependency>          <groupId>org.springframework.boot</groupId>         <artifactId>spring-boot-starter-mail</artifactId>     </dependency>  </dependencies>

2、配置文件

在 application.properties 中添加邮箱配置，不同的邮箱参数稍有不同，下面列举几个常用邮箱配置：

163邮箱配置：

spring.mail.host=smtp.163.com //邮箱服务器地址 spring.mail.username=xxx@oo.com //用户名 spring.mail.password=xxyyooo    //密码 spring.mail.default-encoding=UTF-8  //超时时间，可选 spring.mail.properties.mail.smtp.connectiontimeout=5000   spring.mail.properties.mail.smtp.timeout=3000 spring.mail.properties.mail.smtp.writetimeout=5000

126 邮箱配置

spring.mail.host=smtp.126.com spring.mail.username=yourEmail@126.com spring.mail.password=yourPassword spring.mail.default-encoding=UTF-8

qq 邮箱配置如下：

spring.mail.host=smtp.qq.com spring.mail.username=ityouknow@qq.com spring.mail.password=yourPassword spring.mail.default-encoding=UTF-8

注意：测试时需要将 spring.mail.username 和 spring.mail.password 改成自己邮箱对应的登录名和密码，这里的密码不是邮箱的登录密码，是开启 POP3 之后设置的客户端授权密码。

这里以 126 为邮件举例，有两个地方需要邮箱中设置：

开启 POP3/SMTP 服务、IMAP/SMTP 服务

图片下方会有 smtp 等相关信息的配置提示。

开通设置客户端授权密码

设置客户端授权密码一般需求手机验证码验证。

3、文本邮件发送

Spring 已经帮我们内置了 JavaMailSender，直接在项目中引用即可。我们封装一个 MailService 类来实现普通的邮件发送方法。

@Component public class MailServiceImpl implements MailService{      private final Logger logger = LoggerFactory.getLogger(this.getClass());      @Autowired     private JavaMailSender mailSender;      @Value("${spring.mail.username}")     private String from;      @Override     public void sendSimpleMail(String to, String subject, String content) {         SimpleMailMessage message = new SimpleMailMessage();         message.setFrom(from);         message.setTo(to);         message.setSubject(subject);         message.setText(content);          try {             mailSender.send(message);             logger.info("简单邮件已经发送。");         } catch (Exception e) {             logger.error("发送简单邮件时发生异常！", e);         }      } }

文本邮件抄送使用：message.copyTo(copyTo) 来实现。

from，即为邮件发送者，一般设置在配置文件中
to，邮件接收者，此参数可以为数组，同时发送多人
subject，邮件主题
content，邮件的主体

邮件发送者 from 一般采用固定的形式写到配置文件中。

4、编写 test 类进行测试

@RunWith(SpringRunner.class) @Spring BootTest public class MailServiceTest {      @Autowired     private MailService MailService;      @Test     public void testSimpleMail() throws Exception {         mailService.sendSimpleMail("ityouknow@126.com","这是一封简单邮件","大家好，这是我的第一封邮件！");     } }

稍微等待几秒，就可以在邮箱中找到此邮件内容了。至此一个简单的文本邮件发送就完成了。

富文本邮件

在日常使用的过程中，我们通常在邮件中加入图片或者附件来丰富邮件的内容，下面讲介绍如何使用 Spring Boot 来发送富文本邮件。

发送 HTML 格式邮件

邮件发送支持以 HTML 语法去构建自定义的邮件格式，Spring Boot 支持使用 HTML 发送邮件。

我们在 MailService 中添加支持 HTML 邮件发送的方法.

public void sendHtmlMail(String to, String subject, String content) {     MimeMessage message = mailSender.createMimeMessage();      try {         //true 表示需要创建一个 multipart message         MimeMessageHelper helper = new MimeMessageHelper(message, true);         helper.setFrom(from);         helper.setTo(to);         helper.setSubject(subject);         helper.setText(content, true);          mailSender.send(message);         logger.info("html邮件发送成功");     } catch (MessagingException e) {         logger.error("发送html邮件时发生异常！", e);     } }

富文本邮件抄送使用：helper.addCc(cc) 来实现。

和文本邮件发送代码对比，富文本邮件发送使用 MimeMessageHelper 类。MimeMessageHelper 支持发送复杂邮件模板，支持文本、附件、HTML、图片等，接下来会一一使用到。

在测试类中构建 HTML 内容，测试发送

@Test public void testHtmlMail() throws Exception {     String content="<html>\n" +             "<body>\n" +             "    <h3>hello world ! 这是一封html邮件!</h3>\n" +             "</body>\n" +             "</html>";     mailService.sendHtmlMail("ityouknow@126.com","这是一封HTML邮件",content); }

邮件内容大写了一段话，下面为接收到的效果：

由此我们发现发送 HTML 邮件，就是需要拼接一段 HTML 的 String 字符串交给 MimeMessageHelper 来处理，最后由邮件客户端负责渲染显示内容。

发送带附件的邮件

在 MailService 添加 sendAttachmentsMail 方法，发送带附件的邮件主要是使用 FileSystemResource 对文件进行封装，在添加到 MimeMessageHelper 中。

public void sendAttachmentsMail(String to, String subject, String content, String filePath){     MimeMessage message = mailSender.createMimeMessage();      try {         MimeMessageHelper helper = new MimeMessageHelper(message, true);         helper.setFrom(from);         helper.setTo(to);         helper.setSubject(subject);         helper.setText(content, true);          FileSystemResource file = new FileSystemResource(new File(filePath));         String fileName = file.getFilename();         helper.addAttachment(fileName, file);         //helper.addAttachment("test"+fileName, file);          mailSender.send(message);         logger.info("带附件的邮件已经发送。");     } catch (MessagingException e) {         logger.error("发送带附件的邮件时发生异常！", e);     } }

添加多个附件可以使用多条 helper.addAttachment(fileName, file)

在测试类中添加测试方法

@Test public void sendAttachmentsMail() {     String filePath="e:\\temp\\fastdfs-client-java-5.0.0.jar";     mailService.sendAttachmentsMail("ityouknow@126.com", "主题：带附件的邮件", "有附件，请查收！", filePath); }

附件可以是图片、压缩包、Word 等任何文件，但是邮件厂商一般都会对附件大小有限制，太大的附件建议使用网盘上传后，在邮件中给出链接。

效果图如下：

发送带静态资源的邮件

邮件中的静态资源一般指图片，在 MailService 添加 sendInlineResourceMail 方法。

public void sendInlineResourceMail(String to, String subject, String content, String rscPath, String rscId){     MimeMessage message = mailSender.createMimeMessage();      try {         MimeMessageHelper helper = new MimeMessageHelper(message, true);         helper.setFrom(from);         helper.setTo(to);         helper.setSubject(subject);         helper.setText(content, true);          FileSystemResource res = new FileSystemResource(new File(rscPath));         helper.addInline(rscId, res);          mailSender.send(message);         logger.info("嵌入静态资源的邮件已经发送。");     } catch (MessagingException e) {         logger.error("发送嵌入静态资源的邮件时发生异常！", e);     } }

在测试类中添加测试方法

@Test public void sendInlineResourceMail() {     String rscId = "neo006";     String content="<html><body>这是有图片的邮件：<img src=\'cid:" + rscId + "\' ></body></html>";     String imgPath = "e:\\temp\\weixin.jpg";      mailService.sendInlineResourceMail("ityouknow@126.com", "主题：这是有图片的邮件", content, imgPath, rscId); }

添加多个图片可以使用多条 <img src='cid:" + rscId + "' > 和 helper.addInline(rscId, res) 来实现

效果图如下：

以上是邮件发送的基础服务，已演示支持各种类型邮件。

邮件系统

如果只是想在系统中做一个邮件工具类的话，以上的内容基本就可以满足要求了。要做成一个邮件系统的话还需要考虑以下几方面：

对外提供发送邮件的服务接口
固定格式邮件是否考虑使用模板
发送邮件时出现网络错误，是否考虑适当的重试机制
邮件系统是否考虑异步化，提升服务响应时间
是否开发邮件后台管理系统，开发出对应的管理软件，通过页面发送邮件，统计发送邮件成功率等数据。
常见异常处理措施

对外提供接口

作为一个独立的邮件系统，需要对外提供接口调用，我们以简单文本邮件为例做个演示：

首先需要定义个实例返回对象：

public class MailResult {     private String rspCode;     private String rspMsg;      public MailResult() {         this.rspCode = "00";         this.rspMsg = "发送成功";     }     //省略 setter/getter }

默认成功的返回码为：00，返回消息为：发送成功。

创建一个 MailController 类对外提供 HTTP 请求接口。

@RestController public class MailController {     private final Logger logger = LoggerFactory.getLogger(this.getClass());     @Resource     private MailService mailService;      @RequestMapping("/sendSimpleMail")     public MailResult sendSimpleMail(String to, String subject, String content) {         MailResult result=new MailResult();         if(StringUtils.isEmpty(to) || !to.contains("@")){             result.setRspCode("01");             result.setRspCode("手机人邮件格式不正确");         }         if(StringUtils.isEmpty(content) ){             result.setRspCode("03");             result.setRspCode("邮件正文不能为空");         }        try {             mailService.sendSimpleMail(to,subject,content);             logger.info("简单邮件已经发送。");         } catch (Exception e) {             result.setRspCode("04");             result.setRspCode("邮件发送出现异常");             logger.error("sendSimpleMail Exception ", e);         }         return result;     } }

外部请求过来时首先进行参数校验，如果参数有误返回请求；发送邮件出现异常时返回错误，正常情况下返回 00；注意在 Service 层如果对异常信息进行了捕获的话，需要将异常信息抛到上层。

try {     mailSender.send(message);     logger.info("简单邮件已经发送。"); } catch (Exception e) {     logger.error("发送简单邮件时发生异常！", e);     throw e; }

类似上述代码。

按照这个思路也可以提供发送带图片、带附件的邮件，同时也可以封装发送多人邮件，群发邮件等复杂情况。

邮件模板

通常我们使用邮件发送服务的时候，都会有一些固定的场景，比如重置密码、注册确认等，给每个用户发送的内容可能只有小部分是变化的。所以，很多时候我们会使用模板引擎来为各类邮件设置成模板，这样我们只需要在发送时去替换变化部分的参数即可。

我们会经常收到这样的邮件：

尊敬的 neo 用户：                恭喜您注册成为xxx网的用户,同时感谢您对xxx的关注与支持并欢迎您使用xx的产品与服务。               ...

邮件正文只有 neo 这个用户名在变化，邮件其它内容均不变，如果每次发送邮件都需拼接 HTML 代码，程序不够优雅，并且每次邮件正文有变化都需修改代码非常不方便。因此对于这类邮件，都建议做成邮件模板来处理，模板的本质很简单，就是在模板中替换变化的参数，转换为 HTML 字符串即可，这里以 Thymeleaf 为例来演示。

Thymeleaf 是 Spring 官方推荐的前端模板引擎，类似 Velocity、FreeMarker 等模板引擎，相较与其他的模板引擎，Thymeleaf 开箱即用的特性。它提供标准和 Spring 标准两种方言，可以直接套用模板实现 JSTL、 OGNL 表达式效果，避免每天套模板、该 Jstl、改标签的困扰。Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。

下面我们来演示使用 Thymeleaf 制作邮件模板。

1、添加依赖包

<dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency>

2、在 resorces/templates 下创建 emailTemplate.html

emailTemplate.html 文件内容即为邮件的正文内容模板。

<!DOCTYPE html> <html lang="zh" xmlns:th="http://www.thymeleaf.org">     <head>         <meta charset="UTF-8"/>         <title>邮件模板</title>     </head>     <body>         您好,感谢您的注册，这是一封验证邮件，请点击下面的链接完成注册，感谢您的支持<br/>         <a href="#" th:href="@{http://www.ityouknow.com/register/{id}(id=${id}) }">激活账号</a>     </body> </html>

我们发现上述的模板中只有 id 是一个动态的值，发送过程中会根据传入的 id 值来替换链接中的 {id}。

3、解析模板并发送

@Test public void sendTemplateMail() {     //创建邮件正文     Context context = new Context();     //设置模板需要替换的参数     context.setVariable("id", "006");     //使用 templateEngine 替换掉动态参数生产出最后的 HTML 内容。     String emailContent = templateEngine.process("emailTemplate", context);     //最后调用 sendHtmlMail 发送邮件     mailService.sendHtmlMail("ityouknow@126.com","主题：这是模板邮件",emailContent); }

我们发现最后调用的还是 sendHtmlMail 的方法，邮件模板的作用只是处理 HTML 生成部分，通过 Thymeleaf 模板引擎解析固定的模板，再更具参数来动态替换其中的变量，最后通过前面的 HTML 发送的方法发送邮件。

效果图如下：

点击“激活账号”跳转的链接为：http://www.ityouknow.com/register/006

发送失败

因为各种原因，总会有邮件发送失败的情况，比如：邮件发送过于频繁、网络异常等。在出现这种情况的时候，我们一般会考虑重新重试发送邮件，会分为以下几个步骤来实现：

接收到发送邮件请求，首先记录请求并且入库。
调用邮件发送接口发送邮件，并且将发送结果记录入库。
启动定时系统扫描时间段内，未发送成功并且重试次数小于3次的邮件，进行再次发送.
重新发送邮件的时间，建议以 2 的次方间隔时间，比如：2、4、8、16 ...

常见的错误返回码：

421 HL:ICC 该IP同时并发连接数过大，超过了网易的限制，被临时禁止连接。
451 Requested mail action not taken: too much fail authentication 登录失败次数过多，被临时禁止登录。请检查密码与帐号验证设置
553 authentication is required，密码配置不正确
554 DT:SPM 发送的邮件内容包含了未被许可的信息，或被系统识别为垃圾邮件。请检查是否有用户发送病毒或者垃圾邮件；
550 Invalid User 请求的用户不存在
554 MI:STC 发件人当天内累计邮件数量超过限制，当天不再接受该发件人的投信。

如果使用一个邮箱频繁发送相同内容邮件，也会被认定为垃圾邮件，报 554 DT:SPM 错误

如果使用网易邮箱可以查看这里的提示：企业退信的常见问题？

其它

异步发送

很多时候邮件发送并不是主业务必须关注的结果，比如通知类、提醒类的业务可以允许延时或者失败。这个时候可以采用异步的方式来发送邮件，加快主交易执行速度。在实际项目中可以采用消息中间件 MQ 发送邮件，具体做法是创建一个邮件发送的消息队列，在业务中有需要用到邮件发送功能时，给对应消息队列按照规定参数发送一条消息，邮件系统监听此队列，当有消息过来时，处理邮件发送的逻辑。

管理后台

考虑做一个完善的邮件系统，可以设计一个独立的邮件管理后台，不但可以让系统之间调用时使用，也可以提供图形化界面让公司的运营、市场部的同事来发送邮件，查询邮件的发送进度，统计邮件发送成功率。也可以设置一些代码钩子，统计用户点击固定链接次数，方便公司营销人员监控邮件营销转化率。

一个非常完善的邮件系统需要考虑的因素非常多，比如是否设置白名单、黑名单来做邮件接收人的过滤机制，是否给用户提供邮件退订的接口等。因此在初期邮件发送的基本功能完成之后，再结合公司业务，快速迭代的逐步完善邮件系统，是一个推荐的做法。

总结

使用 Spring Boot 集成发送邮件的功能非常简单，只需要简单编码就可以实现发送普通文本邮件、带附件邮件、HTML 格式邮件、带图片邮件等。如果需要做成一个邮件系统还需要考虑很多因素，比如：邮箱发送失败重试机制、防止邮件被识别为垃圾邮件，固定时间内发送邮件的限制等。在微服务架构中，常常将一些基础功能下沉下来，作为独立的服务来使用，邮件系统作为平台的基础功能，特别适合做为独立的微服务来支持整个系统。

点击这里下载源码

参考：

https://www.geekpark.net/news/214789

接口测试工具 Postman 使用实践

Fri, 01 Apr 2022 13:26:00 GMT

一、接口定义

软件不同部分之间的交互接口。通常就是所谓的 API――应用程序编程接口，其表现的形式是源代码。 —— [ 百度百科 ]

我们常说的接口一般指两种：

API：应用程序编程接口。程序间的接口
GUI：图形用户界面。人与程序的接口

这里我们所说的接口特指 API 接口。API 接口定义：对协议进行定义的引用类型。

好多公司开发人员分前后端，他们之间如何配合工作的，就是其中一方定义接口，另一方来调用接口，以实现预期功能。

二、接口的分类

1. 接口分类

HTTP 接口
Webservice 接口
RESTful 接口

WebService 接口是走 soap 协议，请求报文和返回报文都是 xml 格式，通过 SoapUI 工具进行测试；

HTTP API 接口走 HTTP 协议，通过路径来区分调用的方法，请求报文入参有多种形式，返回报文一般为 json 串，最常见的是 get 和 post 方法。

三、为何要进行接口测试

1. 接口测试必要性

当今的系统复杂度不断上升，传统的测试方法成本急剧增加且测试效率大幅下降，所以就要做接口测试。

同时，接口测试相对容易实现自动化持续集成，且相对 UI 自动化也比较稳定，可以减少人工回归测试人力成本与时间，缩短测试周期，支持后端快速发版需求。

接口持续集成是为什么能低成本高收益的根源。现在很多系统前后端架构是分离的，从安全层面来说，只依赖前端进行限制已经完全不能满足系统的安全要求（绕过前面实在太容易），需要后端同样进行控制，在这种情况下就需要从接口层面进行验证。

前后端传输、日志打印等信息是否加密传输也是需要验证的，特别是涉及到用户的隐私信息，如身份证，银行卡等。

2. 接口测试原理

模拟客户端向服务器发送请求报文，服务器接收请求报文后对相应的报文做处理并向客户端返回应答，客户端再接收应答的一个过程。

3. 接口测试范围

接口的功能、性能、安全性。重点关注数据的交换，传递和控制管理过程，还包括处理的次数。

接口测试对象是接口，但随着系统复杂度越来越高，接口越来越多，完全覆盖是一件很困难的事情。

通常情况下主要测试最外层的两类接口：数据进入系统的接口（调用外部系统的参数为本系统使用）、数据流出系统接口（验证系统处理后的数据是否正常）

四、接口文档示例

1. 接口文档应该包括哪几部分？

接口说明
调用的 url
请求方法（get、post）
请求参数，参数类型、请求参数说明
返回参数说明
返回示例

2. 示例

注：上图接口文档工具为 ShowDoc

五、Postman 工具简介

1. Sidebar 侧边栏

Postman 侧边栏允许你查找、管理请求和集合。侧边栏分为两个主要的选项卡，包括历史和集合选项卡。可以拖动右边的边来调整侧边栏的宽度。侧边栏也可以隐藏到小屏幕（标题栏 view—>toggle side bar）。

（1）历史选项卡

通过 Postman 应用程序发送的每个请求都保存在侧边栏的 History 选项卡中。

（2）集合选项卡

在侧栏中创建和管理集合选项卡的集合。

2. Header toolbar

Postman 的顶部工具栏包含以下选项：

新建按钮——可以新建请求，集合，环境等
运行按钮-打开集合运行页面
导入按钮——导入 Postman 文件、文件夹、form link 等
新窗口图标-打开一个新的 tab 页、新的窗口、新的 runner 等
构建器和团队库选项卡——在请求生成器和 Team Library 视图之间切换
抓取 API 请求图标——使用 postman 抓取 API 请求
同步状态图标——同步 API 请求图标
用户下拉——管理集合链接和你的个人资料或登录 / 登出，你的 Postman 帐户
开放 API 集合（点击打开一个网址）
通知图标-接收通知或广播
设置图标——管理 Postman 应用程序设置，并找到其他支持资源
❤——分享按钮

3. Builder

Postman 通过选项卡布局，用于在构建器中发送和管理 API 请求。上半部分是请求构建器，下半部分是响应查看器。

Cookies——管理 cookie 模式是通过点击 cookie 链接访问的。该特性允许你管理与请求相关的 cookie。
Code——生成的代码片段模式通过保存按钮下面的最右边的 Code 链接。该特性允许你生成与请求相关的代码片段，该请求支持 20 多种语言（http、java、go 等语言）

4. Console

Postman 有两个控制台，可以帮助我们了解系统后台到底发生了什么。

Postman Console——包含 HTTP 请求和响应的运行日志。来自脚本的日志消息 (如在 console. Log 中)。这个功能只能在 Postman 的本地应用中使用。
DevTools Console——可以在开发期间记录诊断信息。

六、借助 Postman 完成 HTTP 请求接口测试

1. 借助 Postman Echo 演示下各种请求的构建方法

（1）Get 请求

https://postman-echo.com/get?foo1=bar1&foo2=bar2

HTTP GET 请求方法是从服务器检索数据。数据由惟一 URI(统一资源标识符) 标识。GET 请求可以使用 “查询字符串参数” 将参数传递给服务器。例如，在下列请求中，http://example.com/hi/there?hand=wave，参数 “hand” 的值等于 “wave”。

（2）POST：URI 传参

（3）POST：Form-data 传参

（4）POST：x-www-form-urlencoded 传参

（5）POST：raw 传参

（6）POST：binary 传参

（7）Authentication Method——权限认证方法

GET Basic Auth
增加 auth 信息：
DigestAuth
Hawk Auth
OAuth1.0(verify signature)

（8）Headers——添加 header

2. 接下来，我们拿个开放 API 来演示下单一接口测试流程

示例 API：https://developers.douban.com/wiki/?title=book_v2#get_book

步骤一：使用 Postman 工具发送该 Get 请求，如下图。

步骤二：添加测试。

上图针对该 API 添加了 3 个测试：

要求响应时间小于 200ms
要求 status code 等于 200
要求 Response body 中包含字符串 “金庸”

注：当然你还可以增加更多的测试点。

七、Postman + Newman + Jenkins 实现接口自动化测试

1. 准备工作（具体步骤参考附件文档-作者提供）

（1）安装 Newman 工具

安装 Node.js
安装 Newman
查看 Newman 命令

（2）部署 Jenkins

2. 将接口保存到集合

点击 Save 按钮，将接口保存到一个集合（可以保存到一个现有集合中或者新建一个集合），如下图：

3. 将集合保存到本地

将集合保存到本地，文件为 .json 格式，如下图：

4. 命令行通过 Newman 运行集合

（1）打开命令行窗口，运行如下命令：

D:\git-local>newman run MyCollection1.postman_collection.json -g globals.postman_globals1.json

（2）执行结果如下：

可以看到，其中两条断言 passed，一条断言 failed，失败的原因是，我们期望接口响应时间小于 200 ms，但是本次接口请求响应时间是 270 ms。

5. 通过 Jenkins 调用 Newman，执行接口测试

执行一次构建，构建失败（上面的断言失败，我们并未修复），查看构建失败原因。

6. 假设开发修复了接口 bug

接口响应时间减少了，我们需要回归测试。（我们将断言响应小于 200 ms，修改成 1000 ms，让断言 passed）

7. 演示一个如何调用 data file 参数化用例

我这里有一个集合，3 个接口，第一个接口为登录接口，第二个接口为获取登录用户信息接口，第三个接口为修改密码接口。登录接口如下：

测试脚本如下：

参数化 json 文件内容如下：

[{   "loginName": "duzl",  "password": "admin123",  "verifyCode": "adf",  "value": "/index" }, {  "loginName": "duzl",  "password": "admin",  "verifyCode": "adf",  "value": " 账号或密码错误 " }, {  "loginName": "duzl",  "password": "",  "verifyCode": "adf",  "value": " 参数 password 不能为空 " }]

（1）好我们调用 json 文件，执行下集合，结果如下：

结果还不错，执行了 3 次，参数都是取自用例文件（json 文件），断言也取自用例文件。

美中不足的是，第二个和第三个接口也跟着迭代了 3 次（这并不是我们期望的结果），这是因为集合运行器中的迭代次数是针对所有接口的设置。

（2）那如果，我们想第一个接口运行 3 遍，第二、三个接口只运行一遍，该如何做呢？Postman 给我们提供了一个内置方法，设置接口运行顺序postman.setNextRequest('');。

注意：迭代次数从 0 开始。

当迭代次数 !==0 时，就停止本次迭代（意思就是，第一次迭代全运行，第二次迭代开始就不执行第二、三个接口了），好，再次运行集合，看看结果：

很好，第一次迭代，执行了 3 个接口；第二、三次迭代只执行了第一个接口。

Windows10右键添加"在此处打开命令窗口

Mon, 14 Feb 2022 02:06:00 GMT

今天跑代码时用到了Powershell，有一个环境变量死活都找不到，无奈只好重新回到cmd命令行测试，结果立马就跑通了。由于现在Win10默认右键只有Powershell，所以为了以后方便使用就把右键添加“在此处打开命令窗口”的代码分享出来。

效果显示“在此处打开命令窗口”选项，如图：

具体步骤

第一步：新建一个txt文件，命名为OpenCmdHere.txt，注意设置编码格式为ANSI 第二步：在文件中输入如下代码，并保存

Windows Registry Editor Version 5.00  [HKEY_CLASSES_ROOT\Directory\shell\OpenCmdHere] @="在此处打开命令窗口" "Icon"="cmd.exe"  [HKEY_CLASSES_ROOT\Directory\shell\OpenCmdHere\command] @="cmd.exe /s /k pushd \"%V\""  [HKEY_CLASSES_ROOT\Directory\Background\shell\OpenCmdHere] @="在此处打开命令窗口" "Icon"="cmd.exe"  [HKEY_CLASSES_ROOT\Directory\Background\shell\OpenCmdHere\command] @="cmd.exe /s /k pushd \"%V\""  [HKEY_CLASSES_ROOT\Drive\shell\OpenCmdHere] @="在此处打开命令窗口" "Icon"="cmd.exe"  [HKEY_CLASSES_ROOT\Drive\shell\OpenCmdHere\command] @="cmd.exe /s /k pushd \"%V\""  [HKEY_CLASSES_ROOT\LibraryFolder\background\shell\OpenCmdHere] @="在此处打开命令窗口" "Icon"="cmd.exe"  [HKEY_CLASSES_ROOT\LibraryFolder\background\shell\OpenCmdHere\command] @="cmd.exe /s /k pushd \"%V\""

第三步：更改文件后缀名为reg，弹出的提示点确认。第四步：双击OpenCmdHere.reg文件运行，弹出的提示点确认，修改注册表就大功告成了！

群晖NAS安装gitlab

Wed, 09 Feb 2022 01:47:00 GMT

下载镜像

docker->注册表->搜索gitlab

配置镜像

映像->选中镜像->启动

点击高级设置，在弹出的高级选项中，切换到卷页签，按照下面截图，设置目录。

这里需要添加对应的文件夹到docker目录下，可以使用File Station在docker目录下，创建gitlab目录。

然后在gitlab目录下，分别创建logs，config，data来存储日志、配置和数据信息文件。

切换端口设置页签，设置一个本地端口，这里指定80容器端口对应本地端口10080。当然也建议将其他本地端口的[自动]改为指定的端口，比如22端口对应的本地端口改为10022之类的，因为后续还要修改配置文件，让克隆地址可以正常显示端口，同时也避免自动获取而带来端口变化而导致的访问问题。

这时候可以直接访问地址了IP:10080，不知道为什么,程序运行没问题我访问的时候不显示，

后来我在反向代理哪里设置了一下访问代理地址就没问题了！如图所示！

常见问题

ROOT密码

登陆后发现没有让输入新密码而是账号和密码我在docker/config目录里发现一个一个initial_root_password文件

打开一看果然记录了初始密码。

查看Gitlab网站文档，原来GitLab 14.0开始，把密码放在了/etc/gitlab/initial_root_password里了。

修改域名地址

我们在下载项目的时候域名不是我们想要的地址，这个时候可以修改配置文件。

/docker/gitlab/config/gitlab.rb

# 32行修改以下配置 external_url 'https://<你的域名>:<端口>' 我的填写的 external_url 'https://nas.mrf.ink:10444'

这时候也要修改启动容器的端口

我的群晖反向代理这么填写

配置电子邮件

#修改以下配置 gitlab_rails['smtp_enable'] = true                              gitlab_rails['smtp_address'] = "smtp.mxhichina.com"   gitlab_rails['smtp_port'] = 25                       gitlab_rails['smtp_user_name'] = "email@maruifu.cn"    gitlab_rails['smtp_password'] = "123456"       gitlab_rails['smtp_domain'] = "smtp.mxhichina.com"   gitlab_rails['smtp_authentication'] = "plain"     gitlab_rails['smtp_enable_starttls_auto'] = true    gitlab_rails['smtp_tls'] = false    gitlab_rails['smtp_pool'] = false   ### Email Settings                                       gitlab_rails['gitlab_email_enabled'] = true                  ##! If your SMTP server does not like the default 'From: gitlab@gitlab.example.com'                     ##! can change the 'From' with this setting.     gitlab_rails['gitlab_email_from'] = 'email@maruifu.cn'     gitlab_rails['gitlab_email_display_name'] = '小马哥'

 #生效配置文件 gitlab-ctl reconfigure #进入后台 gitlab-rails console -e production 或者 gitlab-rails console #发送测试邮件 Notify.test_email('mrf_it@163.com', '标题', '内容').deliver_now

gitlab使用命令行修改用户密码

gitlab-rails console production   > user=User.where(username: "root").first > user.password=123123 > user.save! > quit

我做系统架构的一些原则（转载）

Sun, 26 Dec 2021 14:49:00 GMT

工作 20 多年了，这 20 来年看到了很多公司系统架构，也看到了很多问题，在跟这些公司进行交流和讨论的时候，包括进行实施和方案比较的时候，都有很多各种方案的比较和妥协，因为相关的经历越来越多，所以，逐渐形成了自己的逻辑和方法论。今天，想写下这篇文章，把我的这些个人的经验和想法总结下来，希望能够让更多的人可以参考和借鉴，并能够做出更好的架构来。另外，我的这些思维方式和原则都针对于现有市面上众多不合理的架构和方案，所以，也算是一种“纠正”……（注意，这篇文章所说的这些架构上的原则，一般适用于相对比较复杂的业务，如果只是一些简单和访问量不大的应用，那么你可能会得出相反的结论）

原则一：关注于真正的收益而不是技术本身

对于软件架构来说，我觉得第一重要的是架构的收益，如果不说收益，只是为了技术而技术，而没有任何意义。对于技术收益来说，我觉得下面这几个收益是非常重要的：

是否可以降低技术门槛加快整个团队的开发流程。能够加快整个团队的工程流程，快速发布，是软件工程一直在解决的问题，所以，系统架构需要能够进行并行开发，并行上线和并行运维，而不会让某个团队成为瓶颈点。（注：就算拖累团队的原因是组织构架，也不妨碍我们做出并行的系统架构设计）
是否可以让整个系统可以运行的更稳定。要让整个系统可以运行的更为的稳定，提升整个系统的 SLA，就需要对有计划和无计划的停机做相应的解决方案（参看《关于高可用的架构》）
是否可以通过简化和自动化降低成本。最高优化的成本是人力成本，人的成本除了慢和贵，还有经常不断的 human error。如果不能降低人力成本，反而需要更多的人，那么这个架构设计一定是失败的。除此之外，是时间成本，资金成本。

如果一个系统架构不能在上面三个事上起到作用，那就没有意义了。

原则二：以应用服务和 API 为视角，而不是以资源和技术为视角

国内很多公司都会有很多分工，基本上都会分成运维和开发，运维又会分成基础运维和应用运维，开发则会分成基础核心开发和业务开发。不同的分工会导致完全不同的视角和出发点。比如，基础运维和开发的同学更多的只是关注资源的利用率和性能，而应用运维和业务开发则更多关注的是应用和服务上的东西。这两者本来相关无事，但是因为分布式架构的演进，导致有一些系统已经说不清楚是基础层的还是应用层的了，比如像服务治理上的东西，里面即有底层基础技术，也需要业务的同学来配合，包括 k8s 也样，里面即有底层的如网络这样的技术，也有需要业务配合的 readniess和 liveness 这样的健康检查，以及业务应用需要 configMap 等等 ……

这些东西都让我感觉到所谓 DevOps，其实就是因为很多技术和组件已经分不清是 Dev 还是 Ops 的了，所以，需要合并 Dev和 Ops。而且，整个组织和架构的优化，已经不能通过调优单一分工或是单一组件能够有很大提升的了。其需要有一种自顶向下的，整体规划，统一设计的方式，才能做到整体的提升（可以试想一下城市交通的优化，当城市规模到一定程度的时候，整体的性能你是无法通过优化几条路或是几条街区来完成的，你需要对整个城市做整体的功能体的规划才可能达到整体效率的提升）。而为了做到整体的提升，需要所有的人都要有一个统一的视角和目标，这几年来，我觉得这个目标就是——要站在服务和对外API的视角来看问题，而不是技术和底层的角度。

原则三：选择最主流和成熟的技术

技术选型是一件很重要的事，技术一旦选错，那会导致整个架构需要做调整，而对架构的调整重来都不是一件简单的事，我在过去几年内，当系统越来越复杂的时候，用户把他们的 PHP，Python, .NET，或 Node.js 的架构完全都迁移到 Java + Go 的架构上来的案例不断的发生。这个过程还是非常痛苦的，但是你没有办法，当你的系统越来越复杂，越来越大时，你就再也不能在一些玩具技术上玩了，你需要的更为工业化的技术。

尽可能的使用更为成熟更为工业化的技术栈，而不是自己熟悉的技术栈。所谓工业化的技术栈，你可以看看大多数公司使用的技术栈，比如：互联网，金融，电信……等等，大公司会有更多的技术投入，也需要更大规模的生产，所以，他们使用的技术通常来说都是比较工业化的。在技术选型上，千万不要被——“你看某个公司也在用这个技术”，或是一些在论坛上看到的一些程序员吐槽技术的观点（没有任何的数据，只有自己的喜好）来决定自己的技术，还是看看主流大多数公司实际在用的技术栈，会更靠谱一些。
选择全球流行的技术，而不是中国流行的技术。技术这个东西一定是一个全球化的东西，不是一个局域化的事。所以，一定要选国际化的会更好。另外，千万不要被某些公司的“特别案例”骗过去了，那怕这个案例很性感，关键还是要看解决问题的思路和采用的技术是否具有普世性。只有普世性的技术有更强的生命力。
尽可能的使用红利大的主流技术，而不要自己发明轮子，更不要魔改。我见过好些个公司魔改开源软件，比如有个公司同魔改mesos，最后改着改着发现自己发明另一个 kubernetes。我还见过很多公司或技术团队喜欢自己发明自己的专用轮子，最后都会被主流开源软件所取代。完全没有必要。不重新发明轮子，不魔改，不是因为自己技术不能，而是因为，这个世界早已不是自己干所有事的年代了，这个时代是要想尽方法跟整个产业，整个技术社区融合和合作，这样才会有最大的收益。那些试图因为某个特例需要自成一套的玩法，短期没问题，但长期来说，我都不看好。
绝大多数情况下，如无非常特殊要求，选 Java基本是不会错的。一方面，这是因为 Java 的业务开发的生产力是非常好的，而且有 Spring 框架保障，代码很难写烂，另外，Java 的社区太成熟了，你需要的各种架构和技术都可以很容易获得，技术红利实在是太大。这种运行在JVM上的语言有太多太多的好处了。在 Java 的技术栈上，你的架构风险和架构的成本（无论是人力成本，时间成本和资金成本）从长期来说都是最优的

在我见过的公司中，好些公司的架构都被技术负责人个人的喜好、擅长和个人经验给绑架了，完全不是从一个客观的角度来进行技术选型。其实，从 0 到 1 的阶段，你用什么样的技术都行，如果你做一个简单的应用，没有事务处理没有复杂的交易流程，比如一些论坛、社交之类的应用，你用任何语言都行。但是如果有一天你的系统变复杂了，需要处理交易了，量也上来了，从 1 到 10，甚至从 10 到 100，你的开发团队也变大了，需要构建的系统越来越大，你可能会发现你只有一个选择，就是 Java。想想京东从.NET 到 Java，淘宝从 PHP 到 Java……

注，一些有主观喜好的人一定会对我上述对 Java 的描述感到不适，我还用一些证据说明一下——全中国所有的电商平台，几百家银行，三大电信运营商，所有的保险公司，劵商的系统，医院里的系统，电子政府系统，等等，基本都是用 Java 开发的，包括 AWS 的主流语言也是 Java，阿里云一开始用 C++/Python 写控制系统，后面也开始用 Java ……你可能会说 B站是用 go语言，但是你可能不知道 B 站的电商和大数据是用 Java……懂着数据分析的同学，建议上各大招聘网站上搜一下 Java 的职位数量，你就知道某个技术是否主流和热门……

原则四：完备性会比性能更重要

我发现好些公司的架构师做架构的时候，首要考虑的是架构的性能是否能够撑得住多大多大的流量，而不是考虑系统的完备性和扩展性。所以，我已经多次见过这样的案例了，一开始直接使用 MongoDB 这样的非关系型数据库，或是把数据直接放在 Redis 里，而直接放弃关系型数据库的数据完备性的模型，而在后来需要在数据上进行关系查询的时候，发现 NoSQL 的数据库在 Join 上都表现的太差，然后就开始各种飞线，为了不做 Join 就开始冗余数据，然而自己又维护不好冗余数据后带来的数据一致性的问题，导致数据上的各种错乱丢失。

所以，我给如下的一些如下的架构原则：

使用最科学严谨的技术模型为主，并以不严谨的模型作为补充。对于上面那个案例来说，就是——永远使用完备支持 ACID 的关系型数据库，然后用 NoSQL 作补充，而不是完全放弃关系型数据库。这里的原则就是所谓的“先紧后松”，一开始紧了，你可以慢慢松，但是开始松了，以后你想紧再也紧不过来了。
性能上的东西，总是有很多解的。我这么多年的经历告诉我，性能上的事，总是有解的，手段也是最多的，这个比起架构的完备性和扩展性来说真的不必太过担心。

为了追求所谓的性能，把整个系统的完备性丢失掉，相当地得不偿失。

原则五：制定并遵循服从标准、规范和最佳实践

这个原则是非常重要的，因为只有服从了标准，你的架构才能够有更好的扩展性。比如：我经常性的见到很多公司的系统既没有服从业界标准，也没有形成自己公司的标准，感觉就像一群乌合之众一样。最典型的例子就是 HTTP 调用的状态返回码。业内给你的标准是 200表示成功，3xx 跳转，4xx 表示调用端出错，5xx 表示服务端出错，我实在是不明白为什么无论成功和失败大家都喜欢返回 200，然后在 body 里指出是否error（前两年我在微信公众号里看到一个有一定名气的互联网老兵推荐使用无论正确还是出错都返回 200 的做法，我在后台再三确认后，我发现这样的架构师真是害人不浅）。这样做最大的问题是——监控系统将在一种低效的状态下工作。监控系统需要把所有的网络请求包打开后才知道是否是错误，而且完全不知道是调用端出错还是服务端出错，于是一些像重试或熔断这样的控制系统完全不知道怎么搞（如果是 4xx错，那么重试或熔断是没有意义的，只有 5xx 才有意义）。有时候，我会有种越活越退步的感觉，错误码设计这种最基本最基础的东西为什么会没有？并且一个公司会任由着大家乱来？这些基础技能怎么就这样丢掉了？

还有，我还见过一些公司，他们整个组织没有一个统一的用户 ID 的设计，各个系统之间同步用户的数据是通过用户的身份证 ID，是的，就是现实世界的身份证 ID，包括在网关上设置的用户白名单居然也是用身份证 ID。我对这个公司的内的用户隐私管理有很大的担忧。一个企业，一个组织，如果没有标准和规范，也就会有抽象，这一定是要出各种乱子的。

下面，我罗列一些你需要注意的标准和规范（包括但不限于）：

服务间调用的协议标准和规范。这其中包括 Restful API路径, HTTP 方法、状态码、标准头、自定义头等，返回数据 JSon Scheme……等。
一些命名的标准和规范。这其中包括如：用户 ID，服务名、标签名、状态名、错误码、消息、数据库……等等
日志和监控的规范。这其中包括：日志格式，监控数据，采样要求，报警……等等
配置上的规范。这其中包括：操作系统配置、中间件配置，软件包……等等
中间件使用的规范。数据库，缓存、消息队列……等等
软件和开发库版本统一。整个组织架构内，软件或开发库的版本最好每年都升一次级，然后在各团队内统一。

这里重要说一下两个事：

Restful API 的规范。我觉得是非常重要的，这里给两个我觉得写得最好的参考：Paypal 和 Microsoft 。Restful API 有一个标准和规范最大的好处就是监视可以很容易地做各种统计分析，控制系统可以很容易的做流量编排和调度。
另一个是服务调用链追踪。对于服务调用链追踪来说，基本上都是参考于 Google Dapper 这篇论文，目前有很多的实现，最严格的实现是 Zipkin，这也是 Spring Cloud Sleuth 的底层实现。Zipkin 贴近 Google Dapper 论文的好处在于——无状态，快速地把 Span 发出来，不消耗服务应用侧的内存和 CPU。这意味着，监控系统宁可自己死了也不能干扰实际应用。
软件升级。我发现很多公司包括 BAT，他们完全没有软件升级的活动，全靠开发人员自发。然而，这种成体系的活动，是永远不可能靠大众的自发形成的。一个公司至少一年要有一次软件版本升级的review，然后形成软件版本的统一和一致，这样会极太简化系统架构的复杂度。

原则六：重视架构扩展性和可运维性

在我见过很多架构里，技术人员只考虑当下，但从来不考虑系统的未来扩展性和可运维性。所谓的管生不管养。如果你生下来的孩子胳膊少腿，严重畸形，那么未来是很难玩的。因为架构和软件不是写好就完的，是需要不断修改不断维护的，80%的软件成本都是在维护上。所以，如何让你的架构有更好的扩展性，可以更容易地运维，这个是比较重要的。所谓的扩展性，意味着，我可以很容易地加更多的功能，或是加入更多的系统，而所谓可运维，就是说我可以对线上的系统做任意的变更。扩展性要求的是有标准规范且不耦合的业务架构，可运维性要求的则是可控的能力，也就是一组各式各样的控制系统。

通过服务编排架构来降低服务间的耦合。比如：通过一个业务流程的专用服务，或是像 Workflow，Event Driven Architecture ， Broker，Gateway，Service Discovery 等这类的的中间件来降低服务间的依赖关系。
通过服务发现或服务网关来降低服务依赖所带来的运维复杂度。服务发现可以很好的降低相关依赖服务的运维复杂度，让你可以很轻松的上线或下线服务，或是进行服务伸缩。
一定要使用各种软件设计的原则。比如：像SOLID这样的原则（参看《一些软件设计的原则》），IoC/DIP，SOA 或 Spring Cloud 等架构的最佳实践（参看《SteveY对Amazon和Google平台的吐槽》中的 Service Interface 的那几条军规），分布式系统架构的相关实践（参看：《分布式系统的事务处理》，或微软件的《Cloud Design Patterns》）……等等

原则七：对控制逻辑进行全面收口

所有的程序都会有两种逻辑，一种是业务逻辑，一种是控制逻辑，业务逻辑就是完成业务的逻辑，控制逻辑是辅助，比如你用多线程，还是用分布式，是用数据库还是用文件，如何配置、部署，运维、监控，事务控制，服务发现，弹性伸缩，灰度发布，高并发，等等，等等 ……这些都是控制逻辑，跟业务逻辑没有一毛钱关系。控制逻辑的技术深度会通常会比业务逻辑要深一些，门槛也会要高一些，所以，最好要专业的程序员来负责控制逻辑的开发，统一规划统一管理，进行收口。这其中包括：

流量收口。包括南北向和东西向的流量的调度，主要通过流量网关，开发框架 SDK或 Service Mesh 这样的技术。
服务治理收口。包括：服务发现、健康检查，配置管理、事务、事件、重试、熔断、限流……主要通过开发框架 SDK – 如：Spring Cloud，或服务网格Service Mesh等技术。
监控数据收口。包括：日志、指标、调用链……主要通过一些标准主流的探针，再加上后台的数据清洗和数据存储来完成，最好是使用无侵入式的技术。监控的数据必须统一在一个地方进行关联，这样才会产生信息。
资源调度有应用部署的收口。包括：计算、网络和存储的收口，主要是通过容器化的方案，如k8s来完成。
中间件的收口。包括：数据库，消息，缓存，服务发现，网关……等等。这类的收口方式一般要在企业内部统一建立一个共享的云化的中间件资源池。

对此，这里的原则是：

你要选择容易进行业务逻辑和控制逻辑分离的技术。这里，Java 的 JVM+字节码注入+AOP 式的Spring 开发框架，会带给你太多的优势。
你要选择可以享受“前人种树，后人乘凉”的有技术红利的技术。如：有庞大社区而且相互兼容的技术，如：Java, Docker, Ansible，HTTP，Telegraf/Collectd……
中间件你要使用可以支持HA集群和多租户的技术。这里基本上所有的主流中间件都会支持 HA 集群方式的。

原则八：不要迁就老旧系统的技术债务

我发现很多公司都很非常大的技术债务，这些债务具体表现如下：

使用老旧的技术。比如，使用HTTP1.0， Java 1.6，Websphere，ESB，基于 socket的通讯协议，过时的模型……等等
不合理的设计。比如，在 gateway 中写大量的业务逻辑，单体架构，数据和业务逻辑深度耦合，错误的系统架构（把缓存当数据库，用消息队列同步数据）……等等
缺少配套设施。比如，没有自动化测试，没有好的软件文档，没有质量好的代码，没有标准和规范……等等

来找我寻求技术帮助的人都有各种各样的问题。我都会对他们苦口婆心地说同样的一句话——“如果你是来找我 case-by-case 解决问题，我兴趣不大，因为，你们千万不要寄希望能够很简单的把一辆夏利车改成一辆法拉利跑车，或是把一栋地基没打好的歪楼搞正。以前欠下的技术债，都得要还，没打好的地基要重新打，没建配套设施都要建。这些基础设施如果不按照正确科学的方式建立的话，你是不可能有一个好的的系统，我也没办法帮你 case-by-case 的解决问题……”，一开始，他们都会对我说，没问题，我们就是要还债，但是，最后发现要还的债真多，有点承受不了，就开始现原形了。

他们开始为自己的“欠的技术债”找各种合理化的理由——给你解释各种各样的历史原因和不得以而为之的理由。谈着谈着，让我有一种感觉——他们希望得到一种什么都不改什么都不付出的方式就可以进步的心态，他们宁可让新的技术 low 下来迁就于这些技术债，把新的技术滥用地乱七八糟的。有一个公司，他们的系统架构和技术选型基本都搞错了，使用错误的模型构建系统，导致整个系统的性能非常之差，也才几千万条数据，但他们想的不是还债，不是把地基和配套设施建好，而且要把楼修的更高，上更多的系统——他们觉得现有的系统挺好，性能问题的原因是他们没一个大数据平台，所以要建大数据平台……

我见过很多很多公司，包括大如 BAT 这样的公司，都会在原来的技术债上进行更多的建设，然后，技术债越来越大，利息越来越大，最终成为一个高利贷，再也还不了（我在《开发团队的效率》一文中讲过一个 WatchDog 的架构模式，一个系统烂了，不是去改这个系统，而是在旁边建一个系统来看着它，我很难理解为什么会有这样的逻辑，也许是为了要解决更多的就业……）

这里有几个原则和方法我是非常坚持的，分享给大家：

与其花大力气迁就技术债务，不如直接还技术债。是所谓的长痛不如短痛。
建设没有技术债的“新城区”，并通过“防腐层 ”的架构模型，不要让技术债侵入“新城区”。

原则九：不要依赖自己的经验，要依赖于数据和学习

有好些人来找我跟我说他们的技术问题，然后希望我能够给他们一个答案。我说，我需要了解一下你现有系统的情况，也就是需要先做个诊断，我只有得到这些数据后，我才可能明白真正的原因是什么，我才可能给你做出一个比较好的技术方案。我个人觉得这是一种对对方负责的方法，因为技术手段太多了，所有的技术手段都有适应的场景，并且有各种 trade-off，所以，只有调研完后才能做出决定。这跟医生看病是一样的，确诊病因不能靠经验，还是要靠诊断数据。在科学面前，所有的经验都是靠不住的……

另外，如果有一天你在做技术决定的时候，开始凭自己以往的经验，那么你就已经不可能再成长了。人都是不可能通过不断重复过去而进步的，人的进步从来都是通过学习自己不知道的东西。所以，千万不要依赖于自己的经验做决定。做任何决定之前，最好花上一点时间，上网查一下相关的资料，技术博客，文章，论文等，同时，也看看各个公司，或是各个开源软件他们是怎么做的？然后，比较多种方案的 Pros/Cons，最终形成自己的决定，这样，才可能做出一个更好的决定。

原则十：千万要小心 X – Y 问题，要追问原始需求

对于 X-Y 问题，也就是说，用户为了解决 X问题，他觉得用 Y 可以解，于是问我 Y 怎么搞，结果搞到最后，发现原来要解决的 X 问题，这个时候最好的解决方案不是 Y，而是 Z。这种 X-Y 问题真是相当之多，见的太多太多了。所以，每次用户来找我的时候，我都要不断地追问什么是 X 问题。

比如，好些用户都会来问我他们要一个大数据流式处理，结果追问具体要解决什么样的问题时，才发现他们的问题是因为服务中有大量的状态，需要把相同用户的数据请求放在同一个服务上处理，而且设计上导致一个慢函数拖慢整个应用服务。最终就是做一下性能调优就好了，根本没有必要上什么大数据的流式处理。

我很喜欢追问为什么，这种追问，会让客户也跟着来一起重新思考。比如，有个客户来找我评估的一个技术架构的决定，从理论上来说，好像这个架构在用户的这个场景下非常不错。但是，这个场景和这个架构是我职业生涯从来没有见过的。于是，我开始追问这个为什么会是这么一个场景？当我追问的时候，我发现用户都感到这个场景的各种不合理。最后引起了大家非常深刻的研讨，最终用户把那个场景修正后，而架构就突然就变成了一个常见且成熟的的模型……

原则十一：激进胜于保守，创新与实用并不冲突

我对技术的态度是比较激进的，但是，所谓的激进并不是瞎搞，也不是见新技术就上，而是积极拥抱会改变未来的新技术，如：Docker/Go，我就非常快地跟进，但是像区块链或是 Rust 这样的，我就不是很积极。因为，其并没有命中我认为的技术趋势的几个特征（参看《Go,Docker 和新技术》）。当然，我也不是不喜欢的就不学了，我对区块链和 Rust 我一样学习，我也知道这些技术的优势，但我不会大规模使用它们。另外，我也尊重保守的决定，这里面没有对和错。但是，我个人觉得对技术激进的态度比起保守来说有太多的好处了。一方面来说，对于用户来说，很大程度上来说，新技术通常都表面有很好的竞争力，而且我见太多这样成功的公司都在积极拥抱新的技术的，而保守的通常来说都越来越不好。

有一些人会跟我说，我们是实用主义，我们不需要创新，能解决当下的问题就好，所以，我们不需要新技术，现有的技术用好就行了。这类的公司，他们的技术设计第一天就在负债，虽然可以解决当下问题，但是马上就会出现新的问题，然后他们会疲于解决各种问题。最后呢，最后还是会走到新的技术上。

这里的逻辑很简单 —— 进步永远来自于探索，探索是要付出代价的，但是收益更大。对我而言，不敢冒险才是最大的冒险，不敢犯错才是最大的错误，害怕失去会让你失去的更多……

（全文完）

文章转载于酷壳 – CoolShell

屏蔽国内IP访问网站

Sat, 25 Dec 2021 15:47:51 GMT

今天有个朋友给我说让我把网站弄一下，别让国内的人访问，主要是为了保证营销的数据准确性和防止同行抄袭。当然是没办法彻底屏蔽的，防小人不防君子吧。我用的是Nginx，

首先我们要去弄到国内的IP地址段，访问网站 http://www.ip2location.com/free/visitor-blocker ，点击左侧的“Firewall List by Country”选项卡。点击下载ip文件

顺便要把你现在的IP最好不要加进去，否则你自己会访问不了。

下载不了的可以指定使用

国内IP地址列表

方法一

复制整段代码到你的Nginx配置文件里面即可。

方法二

把文件去掉第一行的“location / {”和最后一行的“}”，重命名为blockip.conf
在nginx配置的http块下面加上include blockip.conf;

可以加载个自定义页面

在/www/wwwroot/watch目录下新建一个 403.html文件

error_page 403 /403.html; location = /403.html{  root  /www/wwwroot/watch;  allow all; }

一份超详细的MySQL高性能优化实战总结！

Sun, 19 Dec 2021 16:09:00 GMT

MySQL 对于很多 Linux 从业者而言，是一个非常棘手的问题，多数情况都是因为对数据库出现问题的情况和处理思路不清晰。

在进行 MySQL 的优化之前必须要了解的就是 MySQL 的查询过程，很多的查询优化工作实际上就是遵循一些原则让 MySQL 的优化器能够按照预想的合理方式运行而已。

优化的哲学

注：优化有风险，修改需谨慎。

优化可能带来的问题：
优化不总是对一个单纯的环境进行，还很可能是一个复杂的已投产的系统。
优化手段本来就有很大的风险，只不过你没能力意识到和预见到。
任何的技术可以解决一个问题，但必然存在带来一个问题的风险。
对于优化来说解决问题而带来的问题，控制在可接受的范围内才是有成果。
保持现状或出现更差的情况都是失败。

优化的需求

稳定性和业务可持续性，通常比性能更重要。
优化不可避免涉及到变更，变更就有风险。
优化使性能变好，维持和变差是等概率事件。
切记优化，应该是各部门协同，共同参与的工作，任何单一部门都不能对数据库进行优化。

所以优化工作，是由业务需求驱使的!

优化由谁参与?在进行数据库优化时，应由数据库管理员、业务部门代表、应用程序架构师、应用程序设计人员、应用程序开发人员、硬件及系统管理员、存储管理员等，业务相关人员共同参与。

优化思路

优化什么

在数据库优化上有两个主要方面：

安全：数据可持续性。
性能：数据的高性能访问。

优化范围

存储、主机和操作系统方面：

主机架构稳定性
I/O 规划及配置
Swap 交换分区
OS 内核参数和网络问题

应用程序方面：

应用程序稳定性
SQL 语句性能
串行访问资源
性能欠佳会话管理
这个应用适不适合用 MySQL

数据库优化方面：

内存
数据库结构(物理&逻辑)
实例配置

说明：不管是设计系统、定位问题还是优化，都可以按照这个顺序执行。

优化维度

数据库优化维度有如下四个：

硬件
系统配置
数据库表结构
SQL 及索引

优化选择

优化成本：硬件>系统配置>数据库表结构>SQL 及索引。
优化效果：硬件<系统配置<数据库表结构

优化工具

检查问题常用的 12 个工具：

MySQL
mysqladmin：MySQL 客户端，可进行管理操作
mysqlshow：功能强大的查看 shell 命令
SHOW [SESSION | GLOBAL] variables：查看数据库参数信息
SHOW [SESSION | GLOBAL] STATUS：查看数据库的状态信息
information_schema：获取元数据的方法
SHOW ENGINE INNODB STATUS：Innodb 引擎的所有状态
SHOW PROCESSLIST：查看当前所有连接的 session 状态
explain：获取查询语句的执行计划
show index：查看表的索引信息
slow-log：记录慢查询语句
mysqldumpslow：分析 slowlog 文件的工具

不常用但好用的 7 个工具：

Zabbix：监控主机、系统、数据库(部署 Zabbix 监控平台)
pt-query-digest：分析慢日志
MySQL slap：分析慢日志
sysbench：压力测试工具
MySQL profiling：统计数据库整体状态工具
Performance Schema：MySQL 性能状态统计的数据
workbench：管理、备份、监控、分析、优化工具(比较费资源)

数据库层面问题

解决思路

一般应急调优的思路：针对突然的业务办理卡顿，无法进行正常的业务处理，需要马上解决的场景。

#查看正在执行的sql语句和进程 show processlist  #通过执行计划判断，索引问题（有没有、合不合理）或者语句本身问题  explain select id ,name from stu where name='clsn'; # ALL id name age sex   select id,name from stu where id=2-1 函数 结果集>30;  　 show index from table;   # 查询锁状态  show status like '%lock%'; # 查询哪些表锁了 show OPEN TABLES where In_use > 0; # 查看造成死锁的sql语句 innodb引擎的运行时信息 show engine innodb status; # 杀掉有问题的session  kill SESSION_ID;   # 查看正在执行的事务 select * from information_schema.INNODB_TRX; # 查看正在锁的事物 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS # 查看等待锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;

MySQL锁定状态查看命令

Status	含义
Checking table	正在检查数据表（这是自动的）。
Closing tables	正在将表中修改的数据刷新到磁盘中，同时正在关闭已经用完的表。这是一个很快的操作，如果不是这样的话，就应该确认磁盘空间是否已经满了或者磁盘是否正处于重负中。
Connect Out	复制从服务器正在连接主服务器。
Copying to tmp table on disk	由于临时结果集大于tmp_table_size，正在将临时表从内存存储转为磁盘存储以此节省内存。
Creating tmp table	正在创建临时表以存放部分查询结果。
deleting from main table	服务器正在执行多表删除中的第一部分，刚删除第一个表。
deleting from reference tables	服务器正在执行多表删除中的第二部分，正在删除其他表的记录。
Flushing tables	正在执行FLUSH TABLES，等待其他线程关闭数据表。
Killed	发送了一个kill请求给某线程，那么这个线程将会检查kill标志位，同时会放弃下一个kill请求。MySQL会在每次的主循环中检查kill标志位，不过有些情况下该线程可能会过一小段才能死掉。如果该线程程被其他线程锁住了，那么kill请求会在锁释放时马上生效。
Locked	被其他查询锁住了。
Sending data	正在处理SELECT查询的记录，同时正在把结果发送给客户端。
Sorting for group	正在为GROUP BY做排序。
Sorting for order	正在为ORDER BY做排序。
Opening tables	这个过程应该会很快，除非受到其他因素的干扰。例如，在执ALTER TABLE或LOCK TABLE语句行完以前，数据表无法被其他线程打开。正尝试打开一个表。
Removing duplicates	正在执行一个SELECT DISTINCT方式的查询，但是MySQL无法在前一个阶段优化掉那些重复的记录。因此，MySQL需要再次去掉重复的记录，然后再把结果发送给客户端。
Reopen table	获得了对一个表的锁，但是必须在表结构修改之后才能获得这个锁。已经释放锁，关闭数据表，正尝试重新打开数据表。
Repair by sorting	修复指令正在排序以创建索引。
Repair with keycache	修复指令正在利用索引缓存一个一个地创建新索引。它会比Repair by sorting慢些。
Searching rows for update	正在讲符合条件的记录找出来以备更新。它必须在UPDATE要修改相关的记录之前就完成了。
Sleeping	正在等待客户端发送新请求。
System lock	正在等待取得一个外部的系统锁。如果当前没有运行多个mysqld服务器同时请求同一个表，那么可以通过增加--skip-external-locking参数来禁止外部系统锁。
Upgrading lock	INSERT DELAYED正在尝试取得一个锁表以插入新记录。
Updating	正在搜索匹配的记录，并且修改它们。
User Lock	正在等待GET_LOCK()。
Waiting for tables	该线程得到通知，数据表结构已经被修改了，需要重新打开数据表以取得新的结构。然后，为了能的重新打开数据表，必须等到所有其他线程关闭这个表。以下几种情况下会产生这个通知：FLUSH TABLES tbl_name, ALTER TABLE, RENAME TABLE, REPAIR TABLE, ANALYZE TABLE,或OPTIMIZE TABLE。
waiting for handler insert	INSERT DELAYED已经处理完了所有待处理的插入操作，正在等待新的请求。

常规调优思路

针对业务周期性的卡顿，例如在每天 10-11 点业务特别慢，但是还能够使用，过了这段时间就好了。

查看slowlog，分析slowlog，分析出查询慢的语句；  按照一定优先级，一个一个排查所有慢语句；  分析top SQL，进行explain调试，查看语句执行时间；  调整索引或语句本身。

系统层面问题

解决思路

CPU方面：vmstat、sar top、htop、nmon、mpstat。

内存：free、ps-aux。

IO 设备(磁盘、网络)：iostat、ss、netstat、iptraf、iftop、lsof。

vmstat 命令说明：

Procs：r 显示有多少进程正在等待 CPU 时间。b 显示处于不可中断的休眠的进程数量。在等待 I/O。
Memory：swpd 显示被交换到磁盘的数据块的数量。未被使用的数据块，用户缓冲数据块，用于操作系统的数据块的数量。
Swap：操作系统每秒从磁盘上交换到内存和从内存交换到磁盘的数据块的数量。s1 和 s0 最好是 0。
IO：每秒从设备中读入 b1 的写入到设备 b0 的数据块的数量。反映了磁盘 I/O。
System：显示了每秒发生中断的数量(in)和上下文交换(cs)的数量。
CPU：显示用于运行用户代码，系统代码，空闲，等待 I/O 的 CPU 时间。

iostat 命令说明：

实例命令：iostat -dk 1 5;iostat -d -k -x 5 (查看设备使用率(%util)和响应时间(await))。
TPS：该设备每秒的传输次数。“一次传输”意思是“一次 I/O 请求”。多个逻辑请求可能会被合并为“一次 I/O 请求”。
iops ：硬件出厂的时候，厂家定义的一个每秒最大的 IO 次数。
"一次传输"请求的大小是未知的。
KB_read/s：每秒从设备(drive expressed)读取的数据量。
KB_wrtn/s：每秒向设备(drive expressed)写入的数据量。
KB_read：读取的总数据量。
KB_wrtn：写入的总数量数据量;这些单位都为 Kilobytes。

解决办法

你认为到底负载高好，还是低好呢?在实际的生产中，一般认为 CPU 只要不超过 90% 都没什么问题。当然不排除下面这些特殊情况。

CPU 负载高，IO 负载低：

内存不够
磁盘性能差
SQL 问题：去数据库层，进一步排查 SQL 问题
IO 出问题了(磁盘到临界了、raid 设计不好、raid 降级、锁、在单位时间内 TPS 过高)
TPS 过高：大量的小数据 IO、大量的全表扫描

IO 负载高，CPU 负载低：

大量小的 IO 写操作
autocommit，产生大量小 IO;IO/PS，磁盘的一个定值，硬件出厂的时候，厂家定义的一个每秒最大的 IO 次数。
大量大的 IO 写操作：SQL 问题的几率比较大

IO和 CPU 负载都很高：

硬件不够了或 SQL 存在问题

基础优化

优化思路:

定位问题点吮吸：硬件>系统>应用>数据库>架构(高可用、读写分离、分库分表)。

处理方向：明确优化目标、性能和安全的折中、防患未然。

硬件优化

①主机方面

根据数据库类型，主机 CPU 选择、内存容量选择、磁盘选择：

平衡内存和磁盘资源
随机的 I/O 和顺序的 I/O
主机 RAID 卡的 BBU(Battery Backup Unit)关闭

②CPU 的选择

CPU 的两个关键因素：核数、主频。根据不同的业务类型进行选择：

CPU 密集型：计算比较多，OLTP 主频很高的 CPU、核数还要多。
IO 密集型：查询比较，OLAP 核数要多，主频不一定高的。

③内存的选择

OLAP 类型数据库，需要更多内存，和数据获取量级有关。OLTP 类型数据一般内存是 CPU 核心数量的 2 倍到 4 倍，没有最佳实践。

④存储方面

根据存储数据种类的不同，选择不同的存储设备，配置合理的 RAID 级别(raid5、raid10、热备盘)。

对于操作系统来讲，不需要太特殊的选择，最好做好冗余(raid1)(ssd、sas、sata)。

主机 raid 卡选择：

实现操作系统磁盘的冗余(raid1)
平衡内存和磁盘资源
随机的 I/O 和顺序的 I/O
主机 raid 卡的 BBU(Battery Backup Unit)要关闭

⑤网络设备方面

使用流量支持更高的网络设备(交换机、路由器、网线、网卡、HBA 卡)。注意：以上这些规划应该在初始设计系统时就应该考虑好。

服务器硬件优化关键点：

物理状态灯

自带管理设备：远程控制卡(FENCE设备：ipmi ilo idarc)、开关机、硬件监控。

第三方的监控软件、设备(snmp、agent)对物理设施进行监控。

存储设备：自带的监控平台。EMC2(HP 收购了)、日立(HDS)、IBM 低端 OEM HDS、高端存储是自己技术，华为存储。

系统优化

CPU：基本不需要调整，在硬件选择方面下功夫即可。

内存：基本不需要调整，在硬件选择方面下功夫即可。

SWAP：MySQL 尽量避免使用 Swap。阿里云的服务器中默认 swap 为 0。

IO ：raid、no lvm、ext4 或 xfs、ssd、IO 调度策略。

Swap 调整(不使用 swap 分区)：

/proc/sys/vm/swappiness的内容改成0(临时)，/etc/sysctl. conf上添加vm.swappiness=0(永久)

这个参数决定了 Linux 是倾向于使用 Swap，还是倾向于释放文件系统 Cache。在内存紧张的情况下，数值越低越倾向于释放文件系统 Cache。

当然，这个参数只能减少使用 Swap 的概率，并不能避免 Linux 使用 Swap。

修改 MySQL 的配置参数 innodb_flush_ method，开启 O_DIRECT 模式。

这种情况下，InnoDB 的 buffer pool 会直接绕过文件系统 Cache 来访问磁盘，但是 redo log 依旧会使用文件系统 Cache。

值得注意的是，Redo log 是覆写模式的，即使使用了文件系统的 Cache，也不会占用太多。

IO 调度策略：

#echo deadline>/sys/block/sda/queue/scheduler 临时修改为deadline

永久修改：

vi /boot/grub/grub.conf  更改到如下内容:  kernel /boot/vmlinuz-2.6.18-8.el5 ro root=LABEL=/ elevator=deadline rhgb quiet

系统参数调整

Linux 系统内核参数优化：

vim/etc/sysctl.conf  net.ipv4.ip_local_port_range = 1024 65535：# 用户端口范围  net.ipv4.tcp_max_syn_backlog = 4096  net.ipv4.tcp_fin_timeout = 30  fs.file-max=65535：# 系统最大文件句柄，控制的是能打开文件最大数量

用户限制参数(MySQL 可以不设置以下配置)：

vim/etc/security/limits.conf  * soft nproc 65535  * hard nproc 65535  * soft nofile 65535  * hard nofile 65535

应用优化

业务应用和数据库应用独立。

防火墙：iptables、selinux 等其他无用服务(关闭)：

chkconfig --level 23456 acpid off   chkconfig --level 23456 anacron off   chkconfig --level 23456 autofs off   chkconfig --level 23456 avahi-daemon off   chkconfig --level 23456 bluetooth off   chkconfig --level 23456 cups off   chkconfig --level 23456 firstboot off   chkconfig --level 23456 haldaemon off   chkconfig --level 23456 hplip off   chkconfig --level 23456 ip6tables off   chkconfig --level 23456 iptables off   chkconfig --level 23456 isdn off   chkconfig --level 23456 pcscd off   chkconfig --level 23456 sendmail off   chkconfig --level 23456 yum-updatesd off

安装图形界面的服务器不要启动图形界面 runlevel 3。

另外，思考将来我们的业务是否真的需要 MySQL，还是使用其他种类的数据库。用数据库的最高境界就是不用数据库。

数据库优化

SQL 优化方向：执行计划，索引，SQL 改写

架构优化方向：高可用架构，高性能架构，分库分表

数据库参数优化

①调整实例整体(高级优化，扩展)：

thread_concurrency：# 并发线程数量个数  sort_buffer_size：# 排序缓存  read_buffer_size：# 顺序读取缓存  read_rnd_buffer_size：# 随机读取缓存  key_buffer_size：# 索引缓存  thread_cache_size：# (1G—>8, 2G—>16, 3G—>32, >3G—>64)

**②连接层(基础优化)**设置合理的连接客户和连接方式：

max_connections # 最大连接数，看交易笔数设置  max_connect_errors # 最大错误连接数，能大则大  connect_timeout # 连接超时  max_user_connections # 最大用户连接数  skip-name-resolve # 跳过域名解析  wait_timeout # 等待超时  back_log # 可以在堆栈中的连接数量

③SQL 层(基础优化)

query_cache_size：查询缓存 >>> OLAP 类型数据库，需要重点加大此内存缓存，但是一般不会超过 GB。

对于经常被修改的数据，缓存会马上失效。我们可以使用内存数据库(redis、memecache)，替代它的功能。

存储引擎层优化

innodb 基础优化参数：

default-storage-engine  innodb_buffer_pool_size # 没有固定大小，50%测试值，看看情况再微调。但是尽量设置不要超过物理内存70%  innodb_file_per_table=(1,0)  innodb_flush_log_at_trx_commit=(0,1,2) # 1是最安全的，0是性能最高，2折中  binlog_sync  Innodb_flush_method=(O_DIRECT, fdatasync)  innodb_log_buffer_size # 100M以下  innodb_log_file_size # 100M 以下  innodb_log_files_in_group # 5个成员以下,一般2-3个够用（iblogfile0-N）  innodb_max_dirty_pages_pct # 达到百分之75的时候刷写 内存脏页到磁盘。  log_bin  max_binlog_cache_size # 可以不设置  max_binlog_size # 可以不设置  innodb_additional_mem_pool_size #小于2G内存的机器，推荐值是20M。32G内存以上100M

一个简单案例，带你看懂GC日志！

Sun, 19 Dec 2021 03:24:00 GMT

代码

public class Main {     public static void main(String[] args) {     byte[] array1 = new byte[4 * 1024 * 1024];     array1 = null;       byte[] array2 = new byte[2 * 1024 * 1024];     byte[] array3 = new byte[2 * 1024 * 1024];     byte[] array4 = new byte[2 * 1024 * 1024];     byte[] array5 = new byte[128 * 1024];     byte[] array6 = new byte[2 * 1024 * 1024];   } }

参数

参数设置运行

-XX:NewSize=10M -XX:MaxNewSize=10M -XX:InitialHeapSize=20M -XX:MaxHeapSize=20M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=15 -XX:PretenureSizeThreshold=3M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log

参数介绍

-XX:NewSize:初始年轻代大小 -XX:MaxNewSize:最大年轻代大小 -XX:InitialHeapSize:定义堆的初始化大小，默认值是物理内存的1/64，其实就是:-Xms -XX:MaxHeapSize:定义最大堆的大小，默认为物理内存的1/4，其实就是:-Xmx -XX:SurvivorRatio:Eden区与Survivor区的大小比值 -XX:MaxTenuringThreshold:年轻代对象转换为老年代对象最大年龄值 -XX:PretenureSizeThreshold=3M:对象大小超过3M时直接在老年代分配内存 -XX:+UseParNewGC:使用ParNew收集器 -XX:+UseConcMarkSweepGC:使用CMS收集器 -XX:+PrintGCDetails:GC时打印详细信息 -Xloggc:输出GC日志信息到文件中

日志

日志情况

0.095: [GC (Allocation Failure) 0.095: [ParNew (promotion failed): 7838K->8391K(9216K), 0.0029438 secs]0.098: [CMS: 8194K->6659K(10240K), 0.0024311 secs] 11934K->6659K(19456K), [Metaspace: 3121K->3121K(1056768K)], 0.0055393 secs] [Times: user=0.02 sys=0.00, real=0.00 secs]  Heap  par new generation   total 9216K, used 2214K [0x00000007bec00000, 0x00000007bf600000, 0x00000007bf600000)   eden space 8192K,  27% used [0x00000007bec00000, 0x00000007bee29820, 0x00000007bf400000)   from space 1024K,   0% used [0x00000007bf500000, 0x00000007bf500000, 0x00000007bf600000)   to   space 1024K,   0% used [0x00000007bf400000, 0x00000007bf400000, 0x00000007bf500000)  concurrent mark-sweep generation total 10240K, used 6659K [0x00000007bf600000, 0x00000007c0000000, 0x00000007c0000000)  Metaspace       used 3142K, capacity 4496K, committed 4864K, reserved 1056768K   class space    used 347K, capacity 388K, committed 512K, reserved 1048576K

日志详解

GC：表明进行了一次垃圾回收，前面没有Full修饰，表明这是一次Young GC  Allocation Failure：表明本次引起GC的原因是因为在年轻代中没有足够的空间能够存储新的数据了  ParNew：表明本次GC发生在年轻代并且使用的是ParNew垃圾收集器。ParNew是一个Serial收集器的多线程版本，会使用多个CPU和线程完成垃圾收集工作（默认使用的线程数和CPU数相同，可以使用-XX：ParallelGCThreads参数限制）  ParNew (promotion failed): 7838K->8391K(9216K) 7838K->8391K(9216K)：单位是KB，三个参数分别为：GC前该内存区域(这里是年轻代)使用容量，GC后该内存区域使用容量，该内存区域总容量。  0.0029438 secs：该内存区域GC耗时，单位是秒  CMS: 8194K->6659K(10240K), 0.0024311 secs] 11934K->6659K(19456K)  8194K->6659K(10240K)：GC前该内存区域(这里是老年代)使用容量变化，10240K表示该内存区域总容量， 11934K->6659K(19456K)：三个参数分别为：堆区垃圾回收前的大小，堆区垃圾回收后的大小，堆区总大小  Times: user=0.02 sys=0.00, real=0.00 secs：分别表示用户态耗时，内核态耗时和总耗时

详细介绍

可以看到出现了promotion failed，那什么情况下会出现promotion failed？

在进行Young GC时，Survivor Space放不下，对象只能放入老年代，而此时老年代也放不下时会出现

1.看代码

byte[] array1 = new byte[4 * 1024 * 1024]; array1 = null;

这行代码直接分配了一个4MB的大对象，此时这个对象会直接进入老年代，接着array1不再引用这个对象

2.接着看下面的代码

byte[] array2 = new byte[2 * 1024 * 1024]; byte[] array3 = new byte[2 * 1024 * 1024]; byte[] array4 = new byte[2 * 1024 * 1024]; byte[] array5 = new byte[128 * 1024];

连续分配了4个数组，其中3个是2MB的数组，1个是128KB的数组，如下图所示，全部会进入Eden区域中

3.接着会执行如下代码：

byte[] array6 = new byte[2 * 1024 * 1024];

此时还能放得下2MB的对象吗？不可能了，因为Eden区已经放不下了。因此此时会直接触发一次Young GC。

4.我们看下面的GC日志：

ParNew (promotion failed): 7838K->8391K(9216K), 0.0029438 secs

这行日志显示了，Eden区原来是有近8000KB的对象，但是回收之后发现一个都回收不掉，因为上述几个数组都被变量引用了一，所以一定会直接把这些存活的对象放入到老年代里去，但是此时老年代里已经有一个4MB的数组了，还能放的下3个2MB的数组和1个128KB的数组吗？

明显是不行的，此时一定会超过老年代的10MB大小。

5.所以此时我们看cms的gc日志：

CMS: 8194K->6659K(10240K), 0.0024311 secs] 11934K->6659K(19456K), [Metaspace: 3121K->3121K(1056768K)], 0.0055393 secs

大家可以清晰看到，此时执行了CMS垃圾回收器的Full GC，我们知道Full GC其实就是会对老年代进行Old GC，同时一般会跟一次Young GC关联，还会触发一次元数据区（永久代）的GC。

在CMS Full GC之前，就已经触发过Young GC了，此时大家可以看到此时Young GC就已经有了，接着就是执行针对老年代的Old GC，也就是如下日志：

CMS: 8194K->6659K(10240K), 0.0024311 secs

6.这里看到老年代从8MB左右的对象占用，变成了6MB左右的对象占用，这是怎么个过程呢？

很简单，一定是在Young GC之后，先把2个2MB的数组放入了老年代，此时要继续放1个2MB的数组和1个128KB的数组到老年代，一定会放不下，所以此时就会触发CMS的Full GC

然后此时就会回收掉其中的一个4MB的数组，因为他已经没人引用了

接着放入进去1个2MB的数组和1个128KB的数组

所以大家再看CMS的垃圾回收日志：CMS: 8194K->6659K(10240K), 0.0024311 secs，他是从回收前的8MB变成了 6MB

最后在CMS Full GC执行完毕之后，其实年轻代的对象都进入了老年代，此时最后一行代码要在年轻代分配2MB的数组就可以成功了

补充知识

Young GC触发条件

当年轻代Eden区域满的时候会触发一次Young GC

Full GC触发条件

Full GC用于清理整个堆空间。它的触发条件主要有以下几种：

1.显式调用System.gc方法(建议JVM触发)。

2.元空间不足

3.年代空间不足，引起Full GC。这种情况比较复杂，有以下几种：

大对象直接进入老年代引起，由-XX:PretenureSizeThreshold参数定义
Young GC时，经历过多次Young GC仍存在的对象进入老年代。
Young GC时，动态对象年龄判定机制会将对象提前转移老年代。年龄从小到大进行累加，当加入某个年龄段后，累加和超过survivor区域-XX:TargetSurvivorRatio的时候，从这个年龄段往上的年龄的对象进入老年代
Young GC时，Eden和From Space区向To Space区复制时，大于To Space区可用内存，会直接把对象转移到老年代

4.JVM的空间分配担保机制可能会触发Full GC：

空间担保分配是指在发生Young GC之前，虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。

如果大于，则此次Young GC是安全的。

如果小于，则虚拟机会查看HandlePromotionFailure设置值是否允许担保失败。

如果HandlePromotionFailure=true，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小，如果大于，则尝试进行一次Young GC，但这次Young GC依然是有风险的，失败后会重新发起一次Full gc；如果小于或者HandlePromotionFailure=false，则改为直接进行一次Full GC。

GC Easy工具

这里推荐一个gceasy(https://gceasy.io)工具，可以上传gc文件，然后他会利用可视化的界面来展现GC情况

参考

https://www.oracle.com/java/technologies/javase/vmoptions-jsp.html

https://book.douban.com/subject/34907497/

MAC 下 IDEA 启动SVN Eclipse项目

Sat, 18 Dec 2021 15:01:00 GMT

下载SVN

//安装brew  已经安装可以忽略 /bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)" // 安装svn brew install svn

如果出现一下错误：

svn: E170013: Commit failed (details follow): svn: E170013: Unable to connect  to a repository at URL '' svn: E230001: Server SSL certificate verification failed:  certificate issued for a different hostname

解决办法：

Configure->Preferences->Version Control->Subversion->Enable interactive mode 勾选上

配置JDK

File->Project Structure->Project->Project SDK->New->JDK 选择自己的JDK版本 File->Project Structure->Project->Project language level->JDK 选择自己的JDK版本 File->Project Structure->Module SDK->选择自己的JDK版本

配置Tomcat

// 进入Tomcat 配置 Add Configuration -> Add New Configuration->Tomcat Server->Local //选择Tomcat Server->Application server-> 选择自己的Tomcat //选择JDK Server->JRE-> 选择自己的JDK版本 //添加编译目录 Deployment->External Source->选择项目的WebRoot目录  //其他问题 检查 文件对应属性是否正确 项目右键->Mark Directory As

Could not resolve XML resource [null] with public ID [null]

Sat, 18 Dec 2021 08:02:00 GMT

现象

项目启动运行时发现报以下错误

严重: Parse error in application web.xml file at jndi:/localhost/WEB-INF/web.xml java.io.FileNotFoundException: Could not resolve XML resource [null] with public ID [null], system ID [webxml/web_dataclient.xml] and base URI [jndi:/localhost/WEB-INF/web.xml] to a known, local entity.  at org.apache.tomcat.util.descriptor.LocalResolver.resolveEntity(LocalResolver.java:154)  at com.sun.org.apache.xerces.internal.util.EntityResolver2Wrapper.resolveEntity(EntityResolver2Wrapper.java:176)  at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.resolveEntityAsPerStax(XMLEntityManager.java:991)  at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.startEntity(XMLEntityManager.java:1206)  at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl.scanEntityReference(XMLDocumentFragmentScannerImpl.java:1908)  at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl$FragmentContentDriver.next(XMLDocumentFragmentScannerImpl.java:3067)  at com.sun.org.apache.xerces.internal.impl.XMLDocumentScannerImpl.next(XMLDocumentScannerImpl.java:606)  at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl.scanDocument(XMLDocumentFragmentScannerImpl.java:510)  at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:848)  at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:777)

原因

servlet很多，方便管理希望能拆分文件在web.xml文件里webapp标签上方加上

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE web-app         [<!ENTITY dataclient SYSTEM  "webxml/web_dataclient.xml">          <!ENTITY document   SYSTEM  "webxml/web_document.xml">          <!ENTITY project SYSTEM  "webxml/web_project.xml">         ]>

我测试了一下在tomcat 6下面这个方式确实是可以的，但是在tomcat7下面就报错了。

java.io.FileNotFoundException: Could not resolve XML resource [null] with public ID [null], system ID [webxml/web_dataclient.xml] and base URI [jndi:/localhost/WEB-INF/web.xml] to a known, local entity.

然后我又网上搜了一下，得知tomcat 7.0.52开始的版本才会出这个问题，是因为安全的考虑tomcat 7.0.52开始的版本把xmlBlockExterna属性默认为true，要解决这个问题把xmlBlockExterna设成false。

设置前

<Context>     <!-- Default set of monitored resources -->     <WatchedResource>WEB-INF/web.xml</WatchedResource>

设置后

<Context xmlBlockExternal="false">     <!-- Default set of monitored resources -->     <WatchedResource>WEB-INF/web.xml</WatchedResource>

CentOS7.9下升级OpenSSL到OpenSSL 1.1.1k

Sun, 28 Nov 2021 06:20:00 GMT

系统环境介绍以及准备

查看系统版本

[root@xmg-hk ~]# cat /etc/redhat-release CentOS Linux release 7.9.2009 (Core)

查看openssl版本

[root@xmg-hk ~]# openssl version  OpenSSL 1.0.2k-fips  26 Jan 2017

官网下载openssl-1.1.1k

其他版本可参考下载： https://www.openssl.org/source/openssl-1.1.1k.tar.gz

详细操作步骤

先备份

mv /usr/bin/openssl /usr/bin/openssl.bak mv /usr/include/openssl /usr/include/openssl.bak

进入目录并编译

cd /usr/local/openssl-1.1.1k ./config --prefix=/usr/local/openssl make && make install

建立链接

ln -s /usr/local/openssl/bin/openssl /usr/bin/openssl ln -s /usr/local/openssl/include/openssl /usr/include/openssl echo “/usr/local/openssl/lib” >> /etc/ld.so.conf ldconfig -v

查看是否升级成功

[root@xmg-hk ~]# openssl version  OpenSSL 1.1.1k  25 Mar 2021

说明：需要先进行备份，备份需要在"建立链接"操作以前完成。

CentOS安装noVNC，以Web方式交付VNC远程连接

Sun, 28 Nov 2021 06:05:31 GMT

CentOS安装noVNC，以Web方式交付VNC远程连接

什么是noVNC

noVNC 是一个 HTML5 VNC 客户端，采用 HTML 5 WebSockets, Canvas 和 JavaScript 实现，noVNC 被普遍用在各大云计算、虚拟机控制面板中，比如 OpenStack Dashboard 和 OpenNebula Sunstone 都用的是 noVNC。 noVNC 采用 WebSockets 实现，但是目前大多数 VNC 服务器都不支持 WebSockets，所以 noVNC 是不能直接连接 VNC 服务器的，需要一个代理来做 WebSockets 和 TCP sockets 之间的转换。这个代理在 noVNC 的目录里，叫做 websockify 。

实验环境

VMware Workstations
带桌面的CentOS7虚拟机
Windows 10 宿主机 + Google Chrome浏览器

关闭防火墙

setenforce 0 systemctl stop firewalld systemctl disable firewalld

安装noVNC

安装依赖软件包

yum install -y epel* yum install -y git yum install -y tigervnc-server

执行以下命令并输入密码启动服务

vncserver :1

安装noVNC

git clone git://github.com/kanaka/noVNC

创建安全连接（一路回车下去...）

cd ./noVNC/utils/ openssl req -new -x509 -days 365 -nodes -out self.pem -keyout self.pem

注： VNC的默认会话不是安全的，需要创建一个安全的VNC连接。创建完毕的证书 self.pem 需要放置到 noVNC/utils 目录下，当启动 noVNC 时，websockify将自动装载证书。

运行noVNC

# 在noVNC目录下，执行 ./utils/launch.sh --vnc localhost:5901

测试连接

在浏览器访问（注意替换成自己的IP地址） http://192.168.204.10:6080/vnc.html 输入密码，连接成功！

当有请求访问vnc时，控制台会显示日志

CentOS 7 的安装脚本

#!/bin/bash  # stop selinux and iptables setenforce 0 systemctl stop firewalld systemctl disable firewalld  # install vncserver and git yum install -y epel* yum install tigervnc-server git -y vncserver :1 # 此时会提示输入密码  # download noVNC git clone git://github.com/kanaka/noVNC  # create secure connection cd ./noVNC/utils/ openssl req -new -x509 -days 365 -nodes -out self.pem -keyout self.pem  # run noVNC cd ../ ./utils/launch.sh --vnc localhost:5901  # running

群晖上查找占用带宽最大的进程的一种解决方案

Sun, 28 Nov 2021 06:01:00 GMT

有天，在群晖的 Web 界面，看到网络监控那里，上传速度竟然有 5M/s，漏油器上也看到群晖的上传很高，也就是说流量上传到了外网，卧槽，这到底是哪个进程吃我带宽的，找出来我非得杀掉不可。可惜，群晖自带的 “资源监控” 无法查看进程对网络的占用。

因为群晖的系统，虽然是基于 debian，但是默认没有包管理器，无法通过 apt/yum 安装 iftop。不过群晖支持 docker。

群晖 - 套件中心 - docker - 安装
ssh 连接群晖 janten/iftop 这个镜像为我们提供了 iftop 命令
```
 docker run -it --rm --net host janten/iftop -P -i eth0 
```
如果本地没有没有这个镜像，会自动进行拉取，拉取镜像完成后，就可以看到 iftop 的运行界面
使用 netstat 定位进程
```
 netstat -pantu | grep [port] 
```

在Docker搭建centos7远程桌面环境

Sun, 28 Nov 2021 05:44:28 GMT

拉取获取centos7镜像

docker pull centos:7

可以从https://hub.docker.com/_/centos?tab=tags查询拉取需要的镜像版本

启动容器

指定容器的名称为centos-desktop-vnc，并暴露宿主机的5901来连接vnc

docker run --name centos-desktop-vnc --privileged -d -p 5901:5901 --ulimit memlock=-1 -td centos:7 /usr/sbin/init

配置desktop环境

进入容器环境

docker exec -it centos-desktop-vnc bash

默认的镜像不带desktop环境，需要手动安装

查看支持的环境

会出现很多结果，我们这里选择的是gnome环境

yum grouplist

安装gnome环境

yum groupinstall GNOME Desktop -y

配置系统默认的启动模式

我们这里需要设置启动模式为图形化

# 获取当前启动模式 systemctl get-default  # 修改启动模式为图形化 systemctl set-default graphical.target  # 修改启动模式为命令行 systemctl set-default multi-user.target

配置vnc服务端

安装vnc server、vim、net-tools

yum -y install tigervnc-server tigervnc-server-module vim net-tools

配置vnc server

复制配置文件模板

cp /lib/systemd/system/vncserver@.service /lib/systemd/system/vncserver@:1.service

设置生效用户-修改配置文件

vim /lib/systemd/system/vncserver\@\:1.service

将配置文件的修改为root，由于root的home路径是/root，不是/home/root，因此注意修改PIDFILE的路径改好之后如下

[Unit] Description=Remote desktop service (VNC) After=syslog.target network.target  [Service] Type=forking  # Clean any existing files in /tmp/.X11-unix environment ExecStartPre=/bin/sh -c '/usr/bin/vncserver -kill %i > /dev/null 2>&1 || :' ExecStart=/usr/sbin/runuser -l root -c "/usr/bin/vncserver %i" PIDFile=/root/.vnc/%H%i.pid ExecStop=/bin/sh -c '/usr/bin/vncserver -kill %i > /dev/null 2>&1 || :'  [Install] WantedBy=multi-user.target

修改vnc server密码

vncpasswd

生效vnc配置

systemctl daemon-reload

配置vnc开机启动

# 启动服务 systemctl start vncserver@:1 # 设为开机启动 systemctl enable vncserver@:1

检查vnc server是否启动

netstat -lnpt|grep Xvnc

出现下图结果说明启动成功

[root@011ff517ebf7 /]# netstat -lnpt|grep Xvnc tcp        0      0 0.0.0.0:5901            0.0.0.0:*               LISTEN      4658/Xvnc            tcp        0      0 0.0.0.0:6001            0.0.0.0:*               LISTEN      4658/Xvnc            tcp6       0      0 :::5901                 :::*                    LISTEN      4658/Xvnc            tcp6       0      0 :::6001                 :::*                    LISTEN      4658/Xvnc

关闭防火墙

# 关闭防火墙 systemctl stop firewalld # 禁止防火墙开机启动 systemctl disable firewalld

vnc客户端发起连接

下载vnc client 连接vnc server

修改色彩质量

初次连接上去可以看到桌面的色彩很模糊解决办法是在建立好的远程连接点右键，选择 Properties，再选择 Options 选项卡，在 General 下面的 Picture quality 选择 High，保存。然后就可以看到图象变清晰了。

保存镜像

# 1、查询container id，出现的第一个字符串就是container id，我这里是011ff517ebf7 docker ps -a | grep centos-desktop-vnc # 2、提交作为本地镜像 docker commit 011ff517ebf7 centos:7-vnc

中文安装

查看当前字符集

$ echo $LANG en_US.UTF-8

安装字符集

使用locale命令看看当前系统所使用的字符集

$ locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8" LC_NUMERIC="en_US.UTF-8" LC_TIME="en_US.UTF-8" LC_COLLATE="en_US.UTF-8" LC_MONETARY="en_US.UTF-8" LC_MESSAGES="en_US.UTF-8" LC_PAPER="en_US.UTF-8" LC_NAME="en_US.UTF-8" LC_ADDRESS="en_US.UTF-8" LC_TELEPHONE="en_US.UTF-8" LC_MEASUREMENT="en_US.UTF-8" LC_IDENTIFICATION="en_US.UTF-8" LC_ALL=

查看系统是否安装中文字符集支持

# locale -a | grep CN bo_CN bo_CN.utf8 ug_CN ug_CN.utf8 zh_CN zh_CN.gb18030 zh_CN.gb2312 zh_CN.gbk zh_CN.utf8

若没有执行以下命令进行安装

yum install -y kde-l10n-Chinese yum reinstall -y glibc-common  #定义字符集 localedef -c -f UTF-8 -i zh_CN zh_CN.UFT-8 #确认载入成功 locale -a

修改系统字符集

修改系统字符集的配置文件：

# echo 'LANG="zh_CN.UTF-8"' > /etc/locale.conf # source /etc/locale.conf

验证字符集修改

# echo $LANG zh_CN.UTF-8  # locale LANG=zh_CN.UTF-8 LC_CTYPE="zh_CN.UTF-8" LC_NUMERIC="zh_CN.UTF-8" LC_TIME="zh_CN.UTF-8" LC_COLLATE="zh_CN.UTF-8" LC_MONETARY="zh_CN.UTF-8" LC_MESSAGES="zh_CN.UTF-8" LC_PAPER="zh_CN.UTF-8" LC_NAME="zh_CN.UTF-8" LC_ADDRESS="zh_CN.UTF-8" LC_TELEPHONE="zh_CN.UTF-8" LC_MEASUREMENT="zh_CN.UTF-8" LC_IDENTIFICATION="zh_CN.UTF-8" LC_ALL=

群晖使用Docker安装Minio

Tue, 23 Nov 2021 14:36:11 GMT

下载镜像

在Docker的注册表中下载官方镜像

创建文件夹

先在FIle Station中创建两个文件夹，用于存放配置和数据，如图所示

添加文件夹 /docker/minio/data (可以与我相同的方式进行新建，也可以根据自己的习惯创建)，这个目录主要是用来存放我们的上传文件的。

添加文件夹 /docker/minio/config，这个目录主要是用来存放我们的配置文件的。

配置容器

在下载完成后，在 映像 中可以看到已经下载好的镜像文件，双击它来选择高就设置来配置容器。

自动启动

存储空间

添加映射的文件夹

/docker/minio/data配置装载路径 /data

/docker/minio/config 配置装载路径 /root/.minio (其中 . 千万不能漏)

端口设置

选择 端口设置 设置本地端口为 9000 （当然其他端口也可以，这也是我们的访问端口，如果此处修改了，访问时就使用修改后的端口进行访问。

一个静态端口，如果不配置此端口程序可以系统，没有报错，但是访问不到后台界面。这个端口可以是自己未占用的任意端口我用的9001端口

环境

在命令出添加一下命令，其中端口号为刚才设置的静态端口号

server --console-address '0.0.0.0:9001' /data

登录后台

通过 http://NAS的IP:9000 访问到minio的登录页面，默认账号 minioadmin ， minioadmin

修改账号密码

修改配置文件

通过 File Station 找到文件 docker/minIO/data/.minio.sys/config/config.json 文件

找到其中的内容 credentials ，修改 access_key 的 value 为你自己想要的，譬如：xiaomage-user，修改其中 secret_key 的 value 为你自己想要的，譬如：xiaomage-password，最后变成如下（为了提高可读性，我这边对文件进行了格式化处理）

"credentials": {         "_": [             {                 "key": "access_key",                 "value": "xiaomage-user"             },             {                 "key": "secret_key",                 "value": "xiaomage-password"             }         ]     },

重新启动

此时重新访问可以使用新的账号密码！

QQ，微信，支付宝二维码三合一

Wed, 03 Nov 2021 15:04:52 GMT

其实这玩意早就有了，各大网站也可搜到，但是为了避免不必要的风险，以及为自己长久使用，可以考虑自己组合一个通用的二维码

~~做好了给老爸收款用~~

原理

通过user-agent判断，对不同的应用跳转不同的链接

准备工作

微信收款二维码
QQ收款二维码
支付宝收款码
一个域名+服务器

部分可能会用上的网址：

二维码生成二维码解析

方法

本来以为很简单，果断去解码然后填入地址，然后迫不及待用qq扫描二维码

果不其然，腾讯一向反人类，事实证明，只有支付宝扫码能够直接跳转支付页面，而QQ和wechat都不行

于是，把动手的活儿交给观众们

这时，我们利用跳转把各个支付二维码图片展现在屏幕面前

顺手制作了三张二维码 ~~佩服本人的聪明才智~~

一切都准备好了，然后开始撸代码（保存index.php）

<?php   if (strstr($_SERVER['HTTP_USER_AGENT'], 'AlipayClient')) {      $AlipayURL = 'https://qr.alipay.com/fkx12586elzhiss95ftmtee';     header("location: " . $AlipayURL); }  elseif (strstr($_SERVER['HTTP_USER_AGENT'], 'MicroMessenger')) {   echo '<img style="width:100%;" src="wx.jpg"></img>'; }  elseif (strstr($_SERVER['HTTP_USER_AGENT'], 'QQ')) {  echo '<img style="width:100%;" src="qq.jpg"></img>'; }  else {      echo "请使用支付宝、微信、QQ客户端扫码付款"; } ?>

其中MicroMessenger是微信客户端，其中的链接和图片自行修改

保存上传网站如图所示

最后一步，生成一个你网站的二维码即可

成果

点击链接 pay.mm.mw

IntelliJ IDEA如何把java源代码打包成jar包

Wed, 03 Nov 2021 13:59:23 GMT

1.我们点击菜单栏中的File–>选择Project Structure…(Ctrl+Alt+Shift+S)进入到设置页面，或者在IntelliJ IDEA页面右侧点击右上角的按钮也可到配置页面。

2.我们在Project Structure的设置页面选择Artifacts，然后点击右侧的绿色“+”号，接下来我们选择JAR–>From modules with dependencies…进入到设置页面。

3.接下来是最重要的步骤，下图中modules一般会自动生成，Main class我们需要点击右侧的按钮，找到项目工程中含有main方法的那个类。JAR文件设置我们选择extract to the target JAR，打包时可将代码依赖的包也打入。最后META-INF/MANIFEST.MF的设置，我们选择项目的根路径即可。

4.需要注意的是，如果项目中已经有META-INF/MANIFEST.MF文件的话是设置不成功的，我们需要先找到项目在磁盘中的位置，然后删掉该文件再重复上述的步骤才可以。

5.设置完成后我们便可以执行生成jar包的操作了，点击菜单栏中的Build–>Build Artifacts…，然后我们在下方代码区便可以看到Build Artifact 选择之前创建的Artifacts然后点击Build即可。t,

6.在Build JAR文件后下方会有已完成的提示，我们找到项目所在的磁盘位置，在项目根路径下的out/artifacts/目录下便是新生成的jar文件。

ssh scp出现Permission denied

Wed, 03 Nov 2021 13:46:46 GMT

在ssh远程连接192.168.2.1这台主机时，出现Permission denied，please try again。同样scp 远程拷贝也出现Permission denied，please try again。遇到这样的情况，如果不是密码错误，并且192.168.2.1的sshd服务开启，则需要修改这台主机的配置文件：

vim /etc/ssh/sshd_config # 修改PermitRootLogin yes # 重启服务 systemctl restart sshd

什么是NIO？NIO的原理是什么机制？

Mon, 01 Nov 2021 13:08:00 GMT

核心区别

NIO是以块的方式处理数据，但是IO是以最基础的字节流的形式去写入和读出的。所以在效率上的话，肯定是NIO效率比IO效率会高出很多。
NIO不在是和IO一样用OutputStream和InputStream 输入流的形式来进行处理数据的，但是又是基于这种流的形式，而是采用了通道和缓冲区的形式来进行处理数据的。
还有一点就是NIO的通道是可以双向的，但是IO中的流只能是单向的。
还有就是NIO的缓冲区（其实也就是一个字节数组）还可以进行分片，可以建立只读缓冲区、直接缓冲区和间接缓冲区，只读缓冲区很明显就是字面意思，直接缓冲区是为加快 I/O 速度，而以一种特殊的方式分配其内存的缓冲区。
NIO比传统的BIO核心区别就是，NIO采用的是多路复用的IO模型，普通的IO用的是阻塞的IO模型，两个之间的效率肯定是多路复用效率更高

通道

通道是对原 I/O 包中的流的模拟。到任何目的地(或来自任何地方)的所有数据都必须通过一个 Channel 对象（通道）。
一个 Buffer 实质上是一个容器对象。发送给一个通道的所有对象都必须首先放到缓冲区中；同样地，从通道中读取的任何数据都要读到缓冲区中。Channel是一个对象，可以通过它读取和写入数据。拿 NIO 与原来的 I/O 做个比较，通道就像是流。
正如前面提到的，所有数据都通过 Buffer 对象来处理。您永远不会将字节直接写入通道中，相反，您是将数据写入包含一个或者多个字节的缓冲区。同样，您不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

缓冲区

Buffer 是一个对象，它包含一些要写入或者刚读出的数据。在 NIO 中加入 Buffer 对象，体现了新库与原 I/O 的一个重要区别。在面向流的 I/O 中，您将数据直接写入或者将数据直接读到 Stream 对象中
在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，您都是将它放到缓冲区中。
缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程

缓冲区类型

CharBuffer  ShortBuffer  IntBuffer   LongBuffer  FloatBuffer  DoubleBuffer

NIO的工作原理

缓冲区的工作机制

capacity 缓冲区数组的总长度

position 下一个要操作的数据元素的位置

limit 缓冲区数组中不可操作的下一个元素的位置，limit<=capacity

mark 用于记录当前 position 的前一个位置或者默认是 0

1.这一步其实是当我们刚开始初始化这个buffer数组的时候，开始默认是这样的

2、但是当你往buffer数组中开始写入的时候几个字节的时候就会变成下面的图，position会移动你数据的结束的下一个位置，这个时候你需要把buffer中的数据写到channel管道中，所以此时我们就需要用这个buffer.flip()方法

3、当你调用完2中的方法时，这个时候就会变成下面的图了，这样的话其实就可以知道你刚刚写到buffer中的数据是在position---->limit之间，然后下一步调用clear（）

4、这时底层操作系统就可以从缓冲区中正确读取这 5 个字节数据发送出去了。在下一次写数据之前我们在调一下 clear() 方法。缓冲区的索引状态又回到初始位置。（其实这一步有点像IO中的把转运字节数组char[] buf = new char[1024]不足1024字节的部分给强制刷新出去的意思）

说明

1、这里还要说明一下 mark，当我们调用mark()时，它将记录当前 position 的前一个位置，当我们调用 reset 时，position 将恢复 mark 记录下来的值

2.clear()方法会：清空整个缓冲区。position将被设回0，limit被设置成 capacity的值（这个个人的理解就是当你在flip（）方法的基础上已经记住你写入了多少字节数据，直接把position到limit之间的也就是你写入已经记住的数据给“复制”到管道中）

3.当你把缓冲区的数局写入到管道中的时候，你需要调用flip()方法将Buffer从写模式切换到读模式，调用flip()方法会将position设回0，并将limit设置成之前position的值。buf.flip();（其实我个人理解的就相当于先记住缓冲区缓冲了多少数据）

工作代码示例

public void selector() throws IOException {   //先给缓冲区申请内存空间           ByteBuffer buffer = ByteBuffer.allocate(1024);        //打开Selector为了它可以轮询每个 Channel 的状态           Selector selector = Selector.open();           ServerSocketChannel ssc = ServerSocketChannel.open();           ssc.configureBlocking(false);//设置为非阻塞方式           ssc.socket().bind(new InetSocketAddress(8080));           ssc.register(selector, SelectionKey.OP_ACCEPT);//注册监听的事件           while (true) {               Set selectedKeys = selector.selectedKeys();//取得所有key集合               Iterator it = selectedKeys.iterator();               while (it.hasNext()) {                   SelectionKey key = (SelectionKey) it.next();                   if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {                       ServerSocketChannel ssChannel = (ServerSocketChannel) key.channel();                    SocketChannel sc = ssChannel.accept();//接受到服务端的请求                       sc.configureBlocking(false);                       sc.register(selector, SelectionKey.OP_READ);                       it.remove();                   } else if                    ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {                       SocketChannel sc = (SocketChannel) key.channel();                       while (true) {                           buffer.clear();                           int n = sc.read(buffer);//读取数据                           if (n <= 0) {                               break;                           }                           buffer.flip();                       }                       it.remove();                   }               }           }   }

NIO的示意图

NIO和Netty的工作模型对比？

NIO的工作流程步骤

首先是先创建ServerSocketChannel 对象，和真正处理业务的线程池
然后给刚刚创建的ServerSocketChannel 对象进行绑定一个对应的端口，然后设置为非阻塞
然后创建Selector对象并打开，然后把这Selector对象注册到ServerSocketChannel 中，并设置好监听的事件，监听 SelectionKey.OP_ACCEPT
接着就是Selector对象进行死循环监听每一个Channel通道的事件，循环执行 Selector.select() 方法，轮询就绪的 Channel
从Selector中获取所有的SelectorKey（这个就可以看成是不同的事件），如果SelectorKey是处于 OP_ACCEPT 状态，说明是新的客户端接入，调用 ServerSocketChannel.accept 接收新的客户端。
然后对这个把这个接受的新客户端的Channel通道注册到ServerSocketChannel上，并且把之前的OP_ACCEPT 状态改为SelectionKey.OP_READ读取事件状态，并且设置为非阻塞的，然后把当前的这个SelectorKey给移除掉，说明这个事件完成了
如果第5步的时候过来的事件不是OP_ACCEPT 状态，那就是OP_READ读取数据的事件状态，然后调用本文章的上面的那个读取数据的机制就可以了

Netty的工作流程步骤

创建 NIO 线程组 EventLoopGroup 和 ServerBootstrap。
设置 ServerBootstrap 的属性：线程组、SO_BACKLOG 选项，设置 NioServerSocketChannel 为 Channel，设置业务处理 Handler
绑定端口，启动服务器程序。
在业务处理 TimeServerHandler 中，读取客户端发送的数据，并给出响应

两者之间的区别：

OP_ACCEPT 的处理被简化，因为对于 accept 操作的处理在不同业务上都是一致的。
在 NIO 中需要自己构建 ByteBuffer 从 Channel 中读取数据，而 Netty 中数据是直接读取完成存放在 ByteBuf 中的。相当于省略了用户进程从内核中复制数据的过程。
在 Netty 中，我们看到有使用一个解码器 FixedLengthFrameDecoder，可以用于处理定长消息的问题，能够解决 TCP 粘包读半包问题，十分方便。

Java volatile关键字

Mon, 30 Aug 2021 17:29:00 GMT

Java内存模型

Java 内存模型（JMM）是一种抽象的概念，并不真实存在，它描述了一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段、静态字段和构成数组对象的元素）的访问方式。试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。

注意JMM与JVM内存区域划分的区别：

JMM描述的是一组规则，围绕原子性、有序性和可见性展开；

相似点：存在共享区域和私有区域

主内存与工作内存

处理器上的寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了高速缓存。

加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。

所有的变量都存储在主内存中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。

线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。

数据存储类型以及操作方式

方法中的基本类型本地变量将直接存储在工作内存的栈帧结构中；

引用类型的本地变量：引用存储在工作内存，实际存储在主内存；

成员变量、静态变量、类信息均会被存储在主内存中；

主内存共享的方式是线程各拷贝一份数据到工作内存中，操作完成后就刷新到主内存中。

内存间交互操作

Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。

read：把一个变量的值从主内存传输到工作内存（CPU级别的缓存）中
load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
use：把工作内存中一个变量的值传递给执行引擎
assign：把一个从执行引擎接收到的值赋给工作内存的变量
store：把工作内存的一个变量的值传送到主内存中
write：在 store 之后执行，把 store 得到的值放入主内存的变量中
lock：作用于主内存的变量
unlock

内存模型三大特性

原子性

// 先看一下代码： public class Main {     private static int cnt = 0;     public static void main(String[] args) {         Runnable runnable = () -> {             for (int j = 0; j < 100; j++) {                 cnt++;                 try {                     Thread.sleep(30);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }             System.out.println(cnt);         };         new Thread(runnable).start();         new Thread(runnable).start();     } }  // 发现上面代码输出并没有等于200；

Java 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。

有一个错误认识就是，int 等原子性的类型在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 属于 int 类型变量，2 个线程对它进行自增操作之后，得到的值为 1 而不是 2。

为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。

下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。

AtomicInteger 能保证多个线程修改的原子性。

使用 AtomicInteger 重写之前线程不安全的代码之后得到以下线程安全实现：

import java.util.concurrent.atomic.AtomicInteger; public class Main {     private static AtomicInteger cnt = new AtomicInteger();     public static void main(String[] args) {         Runnable runnable = () -> {             for (int j = 0; j < 100; j++) {                 cnt.getAndIncrement();                 try {                     Thread.sleep(30);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }             System.out.println(cnt.get());         };         new Thread(runnable).start();         new Thread(runnable).start();     } }

除了使用原子类之外还可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。

public class Main1 {     private static int cnt = 0;     public synchronized void add() {         cnt++;     }     public static void main(String[] args) {         Main1 main1 =new Main1();         Runnable runnable = () -> {             for (int j = 0; j < 100; j++) {                 main1.add();                 try {                     Thread.sleep(30);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }             System.out.println(cnt);         };         new Thread(runnable).start();         new Thread(runnable).start();     } }

可见性

可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。

主要有有三种实现可见性的方式：

volatile，会强制将该变量自己和当时其他变量的状态都刷出缓存。

synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。

final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。

对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。

有序性

有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了指令重排序。在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

简单来说：对于代码有个问题就是指令重排序，编译器和指令器有时候为了提高代码执行效率会将指令重新排序。

flag = false;  //线程1： //准备资源 prepare()  flag = true;  //线程2： while(!flag){    Thread.sleep(1000) }  //基于准备好的资源执行操作 execute()

指令重排序后，让flag=true 先执行了，会导致线程2 直接跳过while等待，执行某段代码，结果prepare()方法还没有执行，资源没有准备好，此时就会导致代码逻辑出现异常！

JMM 内部的实现通常是依赖于所谓的内存屏障，通过禁止某些重排序的方式，提供内存可见性保证，也就是实现了各种 happen-before 规则。与此同时，更多复杂度在于，需要尽量确保各种编译器、各种体系结构的处理器，都能够提供一致的行为。

先行发生原则(Happen-Before)

JSR-133内存模型使用先行发生原则在Java内存模型中保证多线程操作可见性的机制，也是对早期语言规范中含糊的可见性概念的一个精确定义。上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。

由于指令重排序的存在，两个操作之间有happen-before关系，并不意味着前一个操作必须要在后一个操作之前执行。仅仅要求前一个操作的执行结果对于后一个操作是可见的，并且前一个操作按顺序 排在第二个操作之前。

单一线程原则（程序员顺序规则）Single Thread rule

在一个线程内，按照代码顺序，书写在程序前面的操作先行发生于书写后面的操作。

管程锁定规则（监视器锁规则）Monitor Lock Rule

一个 unlock（解锁）操作先行发生于后面对同一个锁的 lock（加锁）操作。比如代码里面先对一个lock.lock()然后lock.unlock(),然后lock.lock()

volatile 变量规则 Volatile Variable Rule

对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。

线程启动规则Thread Start Rule

Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。比如Thread.start() interrupt()

线程加入规则 Thread Join Rule

Thread 对象的结束先行发生于 join() 方法返回。

线程中断规则 Thread Interruption Rule

对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。

对象终结规则 Finalizer Rule

一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。

传递性 Transitivity

如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。

总结：这些规则制定了在一些特殊情况下，不允许编译机，指令器对你写的代码进行指令重排，必须保证你的代码的有序性

指令重排序的条件

在单线程环境下不能改变程序的运行结果；
存在数据依赖关系的不允许重排序；
无法通过Happens-before原则推到出来的，才能进行指令的重排序。

volatile

可见性

public class Main {     private  volatile static int i = 0;     public static void main(String[] args)  {         new Thread(()->{              i++ ;         }).start();         new Thread(()->{             // volatile 修饰后 当线程1 操作i++ 刷新到主内存中后，会让线程2工作内存的缓存失效             // 此时会读取到 i=1             while (i ==0){ Thread.sleep(1000); }             i++ ;         }).start();     } }

常用场景：一个系统中间连接各种中间件系统，不能直接结束主进程，在结束主进程的时候要把里面的各个中间件系统关闭后，在结束主进程，不然可能会消息丢失，或者数据不一致等现象.

public class Kafka{     private volatile boolean running =true ;               // 这是一个接口     public void shutdown(){     //关闭这个系统了，shutdown.sh脚本，来调用这个shutdown接口         // 最后运行状态置为false         running =false ;     }          public static void main(){          //启动kafka , rocketmq ,会运行一大堆代码，中间件系统不能直接停掉          Kafka kafka= new Kafka();                    // 监控kafka 是否关闭 ，未关闭则需要等待！          while(kafka.running){              Thread.sleep(1000);          }               } }

如果不加volatile修饰，则有可能一直不会关闭，拿到的running状态一直是true

有序性

前面的案例使用volatile 优化后

volatile boolean flag = false;  //线程1： //准备资源 prepare()  flag = true;  //线程2： while(!flag){    Thread.sleep(1000) }  //基于准备好的资源执行操作 execute()

比如这个例子，如果使用 volatile来修饰flag变量，一定可以让prepare() 在flag = true;之前先执行，这就禁止指令重排，因为volatile变量规则要求的是，volatile前面的代码一定不能指令重排到volatile变量操作后面，volatile后面的代码也不能指令重排到volatile前面

也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。

原子性

volatile 不能保证原子性，在有些情况下，可以有限的保证原子性，它主要不是用来保证原子性的！比如oracle 64位的long 数字进行操作的时候

保证原子性还是需要synchronized，lock 进行加锁

原理

volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。

lock指令（保证可见性）

对 volatile修饰的变量,执行写操作的话,JVM会发送一条lock前缀指令给CPU,CPU在计算完之后会立即将这个值写回主内存,同时因为有MESI缓存一致性协议,所以各个CPU都会对总线进行嗅探,自己本地缓存中的数据是否被别人修改如果发现别人修改了某个缓存的数据,那么CPU就会将自己本地缓存的数据过期掉,然后这个CPU上执行的线程在读取那个变量的时候,就会从主内存重新加载最新的数据了

内存屏障：禁止重排序（保证有序性）

Load1: int localVar = this.variable; Load2: int localVar = this.variable2;

Loadload屏障:Load1; LoadLoad;Load2,确保Load1数据的装载先于Load2后所有装载指令,他的意思,Load1对应的代码和Load2对应的代码,是不能指令重排的

Store1: this.variable=1; StoreStore屏障 Store2: this.variable2=2;

StoreStore屏障: Store1; StoreStore; Store2,确保 Store1的数据一定刷回主存,对其他cpu 可见,先于 Store2以及后续指令

LoadStore屏障:Load1; LoadStore; Store2,确保Load1指令的数据装载,先于 Store2以及后续指令

Storeload屏障: Store1; Storeload;Load2,确保 Store1指令的数据一定刷回主存,对其他 cpu可见,先于Load2以及后续指令的数据装载

作用

volatile variable =1 this variable=2=> store操作  int localvariable= this variable=>load操作

对于 volatile修改变量的读写操作,都会加入内存屏障,每个 volatile写操作前面,加 Store Store屏障,禁止上面的普通写和他重排;每个 volatile写操作后面,加 Storeload屏障,禁止跟下面的 volatile读/写重排←

Seata--分布式事务

Sun, 29 Aug 2021 14:39:00 GMT

分布式事务基础

事务

事务指的就是一个操作单元，在这个操作单元中的所有操作最终要保持一致的行为，要么所有操作都成功，要么所有的操作都被撤销。简单地说，事务提供一种“要么什么都不做，要么做全套”机制。

本地事务

本地事物其实可以认为是数据库提供的事务机制。说到数据库事务就不得不说，数据库事务中的四大特性:

A:原子性(Atomicity)，一个事务中的所有操作，要么全部完成，要么全部不完成
C:一致性(Consistency)，在一个事务执行之前和执行之后数据库都必须处于一致性状态
I:隔离性(Isolation)，在并发环境中，当不同的事务同时操作相同的数据时，事务之间互不影响
D:持久性(Durability)，指的是只要事务成功结束，它对数据库所做的更新就必须永久的保存下来

数据库事务在实现时会将一次事务涉及的所有操作全部纳入到一个不可分割的执行单元，该执行单元中的所有操作要么都成功，要么都失败，只要其中任一操作执行失败，都将导致整个事务的回滚

分布式事务

分布式事务指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。

简单的说，就是一次大的操作由不同的小操作组成，这些小的操作分布在不同的服务器上，且属于不同的应用，分布式事务需要保证这些小操作要么全部成功，要么全部失败。

本质上来说，分布式事务就是为了保证不同数据库的数据一致性。

分布式事务的场景

单体系统访问多个数据库

一个服务需要调用多个数据库实例完成数据的增删改操作

多个微服务访问同一个数据库

多个服务需要调用一个数据库实例完成数据的增删改操作

多个微服务访问多个数据库

多个服务需要调用一个数据库实例完成数据的增删改操作

分布式事务解决方案

全局事务

全局事务基于DTP模型实现。DTP是由X/Open组织提出的一种分布式事务模型——X/Open Distributed Transaction Processing Reference Model。它规定了要实现分布式事务，需要三种角色:

AP: Application 应用系统 (微服务)
TM: Transaction Manager 事务管理器 (全局事务管理)
RM: Resource Manager 资源管理器 (数据库)

整个事务分成两个阶段:

阶段一: 表决阶段，所有参与者都将本事务执行预提交，并将能否成功的信息反馈发给协调者。
阶段二: 执行阶段，协调者根据所有参与者的反馈，通知所有参与者，步调一致地执行提交或者回

滚。

优点

提高了数据一致性的概率，实现成本较低

缺点

单点问题: 事务协调者宕机
同步阻塞: 延迟了提交时间，加长了资源阻塞时间
数据不一致: 提交第二阶段，依然存在commit结果未知的情况，有可能导致数据不一致

可靠消息服务

基于可靠消息服务的方案是通过消息中间件保证上、下游应用数据操作的一致性。假设有A和B两个系统，分别可以处理任务A和任务B。此时存在一个业务流程，需要将任务A和任务B在同一个事务中处理。就可以使用消息中间件来实现这种分布式事务。

第一步:消息由系统A投递到中间件

在系统A处理任务A前，首先向消息中间件发送一条消息
消息中间件收到后将该条消息持久化，但并不投递。持久化成功后，向A回复一个确认应答
系统A收到确认应答后，则可以开始处理任务A
任务A处理完成后，向消息中间件发送Commit或者Rollback请求。该请求发送完成后，对系统A而

言，该事务的处理过程就结束了
如果消息中间件收到Commit，则向B系统投递消息;如果收到Rollback，则直接丢弃消息。但是

如果消息中间件收不到Commit和Rollback指令，那么就要依靠"超时询问机制"。

超时询问机制

系统A除了实现正常的业务流程外，还需提供一个事务询问的接口，供消息中间件调用。当消息中间件收到发布消息便开始计时，如果到了超时没收到确认指令，就会主动调用系统A提供的事务询问接口询问该系统目前的状态。该接口会返回三种结果，中间件根据三种结果做出不同反应:

提交:将该消息投递给系统B 回滚:直接将条消息丢弃处理中:继续等待

第二步:消息由中间件投递到系统B

消息中间件向下游系统投递完消息后便进入阻塞等待状态，下游系统便立即进行任务的处理，任务处理完成后便向消息中间件返回应答。

如果消息中间件收到确认应答后便认为该事务处理完毕
如果消息中间件在等待确认应答超时之后就会重新投递，直到下游消费者返回消费成功响应为止。

一般消息中间件可以设置消息重试的次数和时间间隔，如果最终还是不能成功投递，则需要手工干预。这里之所以使用人工干预，而不是使用让A系统回滚，主要是考虑到整个系统设计的复杂度问题。

基于可靠消息服务的分布式事务，前半部分使用异步，注重性能;后半部分使用同步，注重开发成本。

最大努力通知

最大努力通知也被称为定期校对，其实是对第二种解决方案的进一步优化。它引入了本地消息表来记录错误消息，然后加入失败消息的定期校对功能，来进一步保证消息会被下游系统消费。

第一步:消息由系统A投递到中间件

处理业务的同一事务中，向本地消息表中写入一条记录
准备专门的消息发送者不断地发送本地消息表中的消息到消息中间件，如果发送失败则重试

第二步:消息由中间件投递到系统B

消息中间件收到消息后负责将该消息同步投递给相应的下游系统，并触发下游系统的任务执行
当下游系统处理成功后，向消息中间件反馈确认应答，消息中间件便可以将该条消息删除，从而该事务完成
对于投递失败的消息，利用重试机制进行重试，对于重试失败的，写入错误消息表
消息中间件需要提供失败消息的查询接口，下游系统会定期查询失败消息，并将其消费

这种方式的优缺点:

优点: 一种非常经典的实现，实现了最终一致性。

缺点: 消息表会耦合到业务系统中，如果没有封装好的解决方案，会有很多杂活需要处理。

TCC事务

TCC即为Try Confifirm Cancel，它属于补偿型分布式事务。TCC实现分布式事务一共有三个步骤:

Try: 尝试待执行的业务:这个过程并未执行业务，只是完成所有业务的一致性检查，并预留好执行所需的全部资源

Confifirm: 确认执行业务:确认执行业务操作，不做任何业务检查，只使用Try阶段预留的业务资源。通常情况下，采用TCC则认为 Confifirm阶段是不会出错的。即:只要Try成功，Confifirm 一定成功。若Confifirm阶段真的出错了，需引入重试机制或人工处理。

Cancel: 取消待执行的业务:取消Try阶段预留的业务资源。通常情况下，采用TCC则认为Cancel 阶段也是一定成功的。若Cancel阶段真的出错了，需引入重试机制或人工处理

TCC两阶段提交与XA两阶段提交的区别是:

XA是资源层面的分布式事务，强一致性，在两阶段提交的整个过程中，一直会持有资源的锁。
TCC是业务层面的分布式事务，最终一致性，不会一直持有资源的锁。

TCC事务的优缺点:

优点:把数据库层的二阶段提交上提到了应用层来实现，规避了数据库层的2PC性能低下问题。
缺点:TCC的Try、Confifirm和Cancel操作功能需业务提供，开发成本高。

Seata介绍

2019 年 1 月，阿里巴巴中间件团队发起了开源项目 Fescar(Fast & EaSy Commit AndRollback)，其愿景是让分布式事务的使用像本地事务的使用一样，简单和高效，并逐步解决开发者们遇到的分布式事务方面的所有难题。后来更名为 Seata，意为:Simple Extensible Autonomous Transaction Architecture，是一套分布式事务解决方案。

Seata的设计目标是对业务无侵入，因此从业务无侵入的2PC方案着手，在传统2PC的基础上演进。它把一个分布式事务理解成一个包含了若干分支事务的全局事务。全局事务的职责是协调其下管辖的分支事务达成一致，要么一起成功提交，要么一起失败回滚。此外，通常分支事务本身就是一个关系数据库的本地事务。

Seata主要由三个重要组件组成:

TC:Transaction Coordinator 事务协调器，管理全局的分支事务的状态，用于全局性事务的提交和回滚。
TM:Transaction Manager 事务管理器，用于开启、提交或者回滚全局事务。
RM:Resource Manager 资源管理器，用于分支事务上的资源管理，向TC注册分支事务，上报分支事务的状态，接受TC的命令来提交或者回滚分支事务。

Seata的执行流程如下:

A服务的TM向TC申请开启一个全局事务，TC就会创建一个全局事务并返回一个唯一的XID
A服务的RM向TC注册分支事务，并及其纳入XID对应全局事务的管辖
A服务执行分支事务，向数据库做操作
A服务开始远程调用B服务，此时XID会在微服务的调用链上传播
B服务的RM向TC注册分支事务，并将其纳入XID对应的全局事务的管辖
B服务执行分支事务，向数据库做操作
全局事务调用链处理完毕，TM根据有无异常向TC发起全局事务的提交或者回滚
TC协调其管辖之下的所有分支事务，决定是否回滚

Seata实现2PC与传统2PC的差别:

架构层次方面，传统2PC方案的 RM 实际上是在数据库层，RM本质上就是数据库自身，通过XA协议实现，而 Seata的RM是以jar包的形式作为中间件层部署在应用程序这一侧的。
两阶段提交方面，传统2PC无论第二阶段的决议是commit还是rollback，事务性资源的锁都要保持到Phase2完成才释放。而Seata的做法是在Phase1 就将本地事务提交，这样就可以省去Phase2 持锁的时间，整体提高效率

Seata实现分布式事务控制

本示例通过Seata中间件实现分布式事务，模拟电商中的下单和扣库存的过程

我们通过订单微服务执行下单操作，然后由订单微服务调用商品微服务扣除库存

案例基本代码

修改order微服务

controller

@RestController @Slf4j public class OrderController5 {   @Autowired   private OrderServiceImpl5 orderService;   //下单   @RequestMapping("/order/prod/{pid}")   public Order order(@PathVariable("pid") Integer pid) {     log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", pid);     return orderService.createOrder(pid);    } }

OrderService

@Service @Slf4j public class OrderServiceImpl5{      @Autowired     private OrderDao orderDao;     @Autowired     private ProductService productService;     @Autowired     private RocketMQTemplate rocketMQTemplate;     @GlobalTransactional     public Order createOrder(Integer pid) {             //1 调用商品微服务,查询商品信息             Product product = productService.findByPid(pid);              log.info("查询到{}号商品的信息,内容是:{}", pid, JSON.toJSONString(product));              //2 下单(创建订单)             Order order = new Order();             order.setUid(1);             order.setUsername("测试用户");             order.setPid(pid);             order.setPname(product.getPname());              order.setPprice(product.getPprice());             order.setNumber(1);             orderDao.save(order);             log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));             //3 扣库存             productService.reduceInventory(pid, order.getNumber());             //4 向mq中投递一个下单成功的消息              rocketMQTemplate.convertAndSend("order-topic", order);             return order;        } }

ProductService

@FeignClient(value = "service-product")  public interface ProductService {   //减库存    @RequestMapping("/product/reduceInventory")   void reduceInventory(@RequestParam("pid") Integer pid,@RequestParam("num") }

修改Product微服务

controller

//减少库存  @RequestMapping("/product/reduceInventory") public void reduceInventory(Integer pid, int num) {   productService.reduceInventory(pid, num);  }

service

  @Override public void reduceInventory(Integer pid, int num) {    Product product = productDao.findById(pid).get();    product.setStock(product.getStock() - num);    //减库存   productDao.save(product);  }

异常模拟

在ProductServiceImpl的代码中模拟一个异常, 然后调用下单接口

@Override public void reduceInventory(Integer pid, Integer number) {    Product product = productDao.findById(pid).get();   if (product.getStock() < number) {     throw new RuntimeException("库存不足");    }   int i = 1 / 0;    product.setStock(product.getStock() - number);    productDao.save(product); }

启动Seata

下载seata

下载地址:https://github.com/seata/seata/releases/v0.9.0/

修改配置文件

将下载得到的压缩包进行解压，进入conf目录，调整下面的配置文件:

registry.conf

registry {   # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa   type = "nacos"    nacos {     serverAddr = "localhost"     namespace = ""     cluster = "default"   } } config {   # file、nacos 、apollo、zk、consul、etcd3   type = "nacos"   nacos {     serverAddr = "localhost"     namespace = ""   } }

nacos-confifig.txt

 service.vgroup_mapping.service-product=default   service.vgroup_mapping.service-order=default

初始化seata在nacos的配置

# 初始化seata 的nacos配置 # 注意: 这里要保证nacos是已经正常运行的  cd conf nacos-config.sh 127.0.0.1

执行成功后可以打开Nacos的控制台，在配置列表中，可以看到初始化了很多Group为SEATA_GROUP 的配置。

启动seata服务

cd bin seata-server.bat -p 9000 -m file

启动后在 Nacos 的服务列表下面可以看到一个名为 serverAddr 的服务。

使用Seata实现事务控制

初始化数据表

在我们的数据库中加入一张undo_log表,这是Seata记录事务日志要用到的表

CREATE TABLE `undo_log`(   `id` BIGiNT(20) NOT NULL AUTO_INCREMENT,    `branch_id` BIGiNT(20) NOT NULL,   `xid` VARcHAR(100) NOT NULL,   `context` VARcHAR(128) NOT NULL,    `rollback_info` LONGBLOB NOT NULL,    `log_status` iNT(11) NOT NULL,   `log_created` DATETIME NOT NULL,    `log_modified` DATETIME NOT NULL,   `ext` VARcHAR(100) DEFAULT NULL,   PRIMARY KEY (`id`),   UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)  ) ENGINE = INNODB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8;

添加配置

在需要进行分布式控制的微服务中进行下面几项配置:

添加依赖

  <dependency>   <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>  </dependency> <dependency>   <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>  </dependency>

DataSourceProxyConfifig

Seata 是通过代理数据源实现事务分支的，所以需要配置 io.seata.rm.datasource.DataSourceProxy 的 Bean，且是 @Primary默认的数据源，否则事务不会回滚，无法实现分布式事务

@Configuration public class DataSourceProxyConfig {     @Bean     @ConfigurationProperties(prefix = "spring.datasource") public DruidDataSource druidDataSource() {         return new DruidDataSource();     }     @Primary     @Bean     public DataSourceProxy dataSource(DruidDataSource druidDataSource) {         return new DataSourceProxy(druidDataSource);     } }

registry.conf

在resources下添加Seata的配置文件 registry.conf

registry {     type = "nacos"     nacos {       serverAddr = "localhost"       namespace = "public"       cluster = "default"     } } config {     type = "nacos"     nacos {       serverAddr = "localhost"       namespace = "public"       cluster = "default"     } }

bootstrap.yaml

spring:  application:   name: service-product  cloud:   nacos:    config:     server-addr: localhost:8848 # nacos的服务端地址      namespace: public       group: SEATA_GROUP   alibaba:    seata:     tx-service-group: ${spring.application.name }

在order微服务开启全局事务

@GlobalTransactional//全局事务控制 public Order createOrder(Integer pid) {}

测试

再次下单测试

seata运行流程分析

要点说明:

每个RM使用DataSourceProxy连接数据库，其目的是使用ConnectionProxy，使用数据源和数据连接代理的目的就是在第一阶段将undo_log和业务数据放在一个本地事务提交，这样就保存了只要有业务操作就一定有undo_log。
在第一阶段undo_log中存放了数据修改前和修改后的值，为事务回滚作好准备，所以第一阶段完成就已经将分支事务提交，也就释放了锁资源。
TM开启全局事务开始，将XID全局事务id放在事务上下文中，通过feign调用也将XID传入下游分支事务，每个分支事务将自己的Branch ID分支事务ID与XID关联。
第二阶段全局事务提交，TC会通知各各分支参与者提交分支事务，在第一阶段就已经提交了分支事务，这里各各参与者只需要删除undo_log即可，并且可以异步执行，第二阶段很快可以完成。
第二阶段全局事务回滚，TC会通知各各分支参与者回滚分支事务，通过 XID 和 Branch ID 找到相应的回滚日志，通过回滚日志生成反向的 SQL 并执行，以完成分支事务回滚到之前的状态，如果回滚失败则会重试回滚操作

Nacos Config--服务配置

Sun, 29 Aug 2021 08:46:00 GMT

服务配置中心介绍

首先我们来看一下,微服务架构下关于配置文件的一些问题:

配置文件相对分散。在一个微服务架构下，配置文件会随着微服务的增多变的越来越多，而且分散在各个微服务中，不好统一配置和管理。
配置文件无法区分环境。微服务项目可能会有多个环境，例如:测试环境、预发布环境、生产环境。每一个环境所使用的配置理论上都是不同的，一旦需要修改，就需要我们去各个微服务下手动维护，这比较困难。
配置文件无法实时更新。我们修改了配置文件之后，必须重新启动微服务才能使配置生效，这对一个正在运行的项目来说是非常不友好的。

基于上面这些问题，我们就需要配置中心的加入来解决这些问题。

配置中心的思路是:

首先把项目中各种配置全部都放到一个集中的地方进行统一管理，并提供一套标准的接口。
当各个服务需要获取配置的时候，就来配置中心的接口拉取自己的配置。
当配置中心中的各种参数有更新的时候，也能通知到各个服务实时的过来同步最新的信息，使之动态更新。

当加入了服务配置中心之后，我们的系统架构图会变成下面这样

在业界常见的服务配置中心，有下面这些:

Apollo

Apollo是由携程开源的分布式配置中心。特点有很多，比如:配置更新之后可以实时生效，支持灰度发布功能，并且能对所有的配置进行版本管理、操作审计等功能，提供开放平台API。并且资料也写的很详细。

Disconf

Disconf是由百度开源的分布式配置中心。它是基于Zookeeper来实现配置变更后实时通知和生效的。

SpringCloud Confifig

这是Spring Cloud中带的配置中心组件。它和Spring是无缝集成，使用起来非常方便，并且它的配置存储支持Git。不过它没有可视化的操作界面，配置的生效也不是实时的，需要重启或去刷新。

Nacos

这是SpingCloud alibaba技术栈中的一个组件，前面我们已经使用它做过服务注册中心。其实它也集成了服务配置的功能，我们可以直接使用它作为服务配置中心。

Nacos Config 入门

使用nacos作为配置中心，其实就是将nacos当做一个服务端，将各个微服务看成是客户端，我们将各个微服务的配置文件统一存放在nacos上，然后各个微服务从nacos上拉取配置即可。

接下来我们以商品微服务为例，学习nacos confifig的使用。

搭建nacos环境【使用现有的nacos环境即可】
在微服务中引入nacos的依赖

<dependency>   <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>  </dependency>

在微服务中添加nacos confifig的配置

注意:不能使用原来的application.yml作为配置文件，而是新建一个bootstrap.yml作为配置文件

配置文件优先级(由高到低):

bootstrap.properties -> bootstrap.yml -> application.properties -> application.yml

spring:   application:     name: service-product   cloud:     nacos:       config:         server-addr: 127.0.0.1:8848 #nacos中心地址         file-extension: yaml # 配置文件格式 profiles:   profiles:     active: dev # 环境标识

在nacos中添加配置

点击配置列表，点击右边+号，新建配置。在新建配置过程中，要注意下面的细节:

1)Data ID不能随便写，要跟配置文件中的对应，对应关系如图所示

2)配置文件格式要跟配置文件的格式对应，且目前仅仅支持YAML和Properties

3)配置内容按照上面选定的格式书写

注释本地的application.yam中的内容，启动程序进行测试

如果依旧可以成功访问程序，说明我们nacos的配置中心功能已经实现

Nacos Config 深入

配置动态刷新

在入门案例中，我们实现了配置的远程存放，但是此时如果修改了配置，我们的程序是无法读取到的，因此，我们需要开启配置的动态刷新功能。

在nacos中的service-product-dev.yaml配置项中添加下面配置:

config:   appName: product

方式一:硬编码方式

@RestController public class NacosConfigController { @Autowired private ConfigurableApplicationContext applicationContext;      @GetMapping( "/nacos-config-test1" )     public String nacosConfingTest1(){      return (applicationContext.getEnvironment().getProperty("config.appName"));     } }

方式二:注解方式(推荐)

@RestController @RefreshScope /* 只需要在需要动态读取配置的类上添加此注解就可以 */ public class NacosConfigController {   @Value("${config.appName}") private String appName;       @GetMapping("/nacos-config-test2")     public String nacosConfingTest2(){         return(appName);     } }

配置共享

当配置越来越多的时候，我们就发现有很多配置是重复的，这时候就考虑可不可以将公共配置文件提取出来，然后实现共享呢?当然是可以的。接下来我们就来探讨如何实现这一功能。

同一个微服务的不同环境之间共享配置

如果想在同一个微服务的不同环境之间实现配置共享，其实很简单。只需要提取一个以 spring.application.name 命名的配置文件，然后将其所有环境的公共配置放在里面即可。

新建一个名为service-product.yaml配置存放商品微服务的公共配置

新建一个名为service-product-test.yaml配置存放测试环境的配置

新建一个名为service-productr-dev.yaml配置存放开发环境的配置

添加测试方法

@RestController @RefreshScope public class NacosConfigController {   @Value( "${config.env}" ) private String env;  /* 3 同一微服务的不同环境下共享配置 */ @GetMapping( "/nacos-config-test3" )     public String nacosConfingTest3(){         return(env);     } }

访问测试

接下来，修改bootstrap.yml中的配置，将active设置成test，再次访问，观察结果

spring:   profiles:     active: test # 环境标识

不同微服务中间共享配置

不同为服务之间实现配置共享的原理类似于文件引入，就是定义一个公共配置，然后在当前配置中引入。

在nacos中定义一个DataID为all-service.yaml的配置，用于所有微服务共享

spring:   datasource:     driver-class-name: com.mysql.jdbc.Driver     url: jdbc:mysql://shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true      username: root     password: root jpa:   properties:     hibernate:       hbm2ddl:         auto: update   dialect: org.hibernate.dialect.MySQL5InnoDBDialect   cloud:     nacos:       discovery:        server-addr: 127.0.0.1:8848

在nacos的中修改service-product.yaml中为下面内容

server:   port: 8081 config:   appName: product

修改bootstrap.yaml

spring:   application:    name: service-product   profiles:     active: dev # 环境标识   cloud:     nacos:       config:         server-addr: 127.0.0.1:8848 #nacos中心地址         file-extension: yaml # 配置文件格式         shared-dataids: all-service.yaml # 配置要引入的配置          refreshable-dataids: all-service.yaml # 配置要实现动态配置刷新的配置

启动商品微服务进行测试

Nacos 的几个概念

命名空间(Namespace) 命名空间可用于进行不同环境的配置隔离。一般一个环境划分到一个命名空间

配置分组(Group) 配置分组用于将不同的服务可以归类到同一分组。一般将一个项目的配置分到一组

配置集(Data ID) 在系统中，一个配置文件通常就是一个配置集。一般微服务的配置就是一个配置集

结果如下

# all-service.yaml   spring:   zipkin:     #开启zipkin分析     enabled: true     #让nacos把它当成一个URL，而不要当做服务名     discoveryClientEnabled: false   sleuth:     sampler:       #限速器，每秒采集10个请求，防止大并发过载。推荐       #rate: 10       #采集率，大并发可能采集率数量也会很高。采样的百分比       probability: 0.1   application:     name: service-product   datasource:     driver-class-name: com.mysql.cj.jdbc.Driver    jpa:     database-platform: org.hibernate.dialect.MySQL5InnoDBDialect     show-sql: true     hibernate:       ddl-auto: update       use-new-id-generator-mappings: false

# service-product.yaml  config:   appName: product

# service-product-dev.yaml  config:   env: dev  server:   port: 8081 spring:   zipkin:     #zipkin服务地址     baseUrl: http://127.0.0.1:9411/   datasource:     url: jdbc:mysql://127.0.0.1:3306/spring-cloud?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true     username: root     password: Mrf12345   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848

# service-product-test.yaml  config:   env: test  server:   port: 8081 spring:   zipkin:     #zipkin服务地址     baseUrl: http://127.0.0.1:9411/   datasource:     url: jdbc:mysql://127.0.0.1:3306/spring-cloud?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true     username: root     password: Mrf12345   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848

SMS--短信服务

Sun, 29 Aug 2021 08:20:29 GMT

短信服务介绍

短信服务（Short Message Service）是阿里云为用户提供的一种通信服务的能力。

产品优势：覆盖全面、高并发处理、消息堆积处理、开发管理简单、智能监控调度
产品功能：短信通知、短信验证码、推广短信、异步通知、数据统计
应用场景：短信验证码、系统信息推送、推广短信等

短信服务使用

接下来,我们使用短信验证码功能来演示短信服务的使用。流程如下:

准备工作

实名认证

https://help.aliyun.com/document_detail/48263.html?spm=5176.11533457.J_1089570.9.15da5333ZUkUdR

开通短信服务

https://www.aliyun.com/product/sms?spm=5176.11533457.J_1089570.9.15da5333ZUkUdR

申请认证秘钥

https://ram.console.aliyun.com/manage/ak

申请短信签名

申请短信模板

短信服务 API 介绍

短信发送

调用SendSms发送短信。

请求参数

名称	类型	是否必选	示例值	描述
PhoneNumbers	String	是	15900000000	接收短信的手机号码。
SignName	String	是	阿里云	短信签名名称。
TemplateCode	String	是	SMS_153055065	短信模板ID。
TemplateParam	String	否	{"code":"1111"}	短信模板变量的值，JSON格式

返回数据

名称	类型	示例值	描述
BizId	String	900619746936498440	发送回执ID，可根据它查询具体的发送
Code	String	OK	请求状态码。返回OK代表请求成功。
Message	String	OK	状态码的描述。
RequestId	String	F655A8D5-B967-440B- 8683	请求ID。

短信查询

调用QuerySendDetails接口查看短信发送记录和发送状态。

请求参数

名称	类型	是否必选	示例值	描述
CurrentPage	Long	是	1	分页查看发送记录，指定发送记录的当前页码。
PageSize	Long	是	10	分页查看发送记录，指定每页显示的短信记录数量。取值范围为1~50。
PhoneNumber	String	是	1590000****	接收短信的手机号码。格式：国内短信：11位手机号码，例如1590000**。国际/港澳台消息：国际区号+号码，例如8520000**。
SendDate	String	是	20181228	短信发送日期，支持查询最近30天的记录。格式为yyyyMMdd，例如20181225。
BizId	String	否	134523^4351232	发送回执ID，即发送流水号。调用发送接口SendSms或SendBatchSms发送短信时，返回值中的BizId字段。

返回数据

名称	类型	示例值	描述
Code	String	OK	请求状态码。返回OK代表请求成功。其他错误码，请参见错误码列表。
Message	String	OK	状态码的描述。
RequestId	String	819BE656-D2E0-4858-8B21-B2E477085AAF	请求ID。
SmsSendDetailDTOs	Array of SmsSendDetailDTO		短信发送明细。
TotalCount	String	1	短信发送总条数。

功能测试

第1步: 引入阿里云服务依赖

<!--短信发送--> <dependency>   <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-alicloud-sms</artifactId>  </dependency>

第2步: 使用阿里云提供的Demo测试短信发送

import com.aliyuncs.DefaultAcsClient; import com.aliyuncs.IAcsClient; import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsRequest; import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsResponse; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse; import com.aliyuncs.exceptions.ClientException; import com.aliyuncs.profile.DefaultProfile; import com.aliyuncs.profile.IClientProfile;  import java.text.SimpleDateFormat; import java.util.Date;  public class SmsDemo {     //产品名称:云通信短信API产品,开发者无需替换     static final String product = "Dysmsapi"; //产品域名,开发者无需替换     static final String domain = "dysmsapi.aliyuncs.com";     // TODO 此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)     static final String accessKeyId = "yourAccessKeyId";     static final String accessKeySecret = "yourAccessKeySecret"; //短信发送      public static SendSmsResponse sendSms() throws ClientException {          //可自助调整超时时间         System.setProperty("sun.net.client.defaultConnectTimeout", "10000");         System.setProperty("sun.net.client.defaultReadTimeout", "10000");          //初始化acsClient,暂不支持region化         IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou",accessKeyId, accessKeySecret);                  DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product,                 domain);         IAcsClient acsClient = new DefaultAcsClient(profile);         //组装请求对象-具体描述见控制台-文档部分内容         SendSmsRequest request = new SendSmsRequest();         //必填:待发送手机号         request.setPhoneNumbers("15000000000");         //必填:短信签名-可在短信控制台中找到         request.setSignName("中古盲盒");         //必填:短信模板-可在短信控制台中找到          request.setTemplateCode("SMS_1000000");         // 可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为         request.setTemplateParam("{\"name\":\"Tom\", \"code\":\"123\"}");         /**          *  选填-上行短信扩展码(无特殊需求用户请忽略此字段)          *   request.setSmsUpExtendCode("90997")          */          // 可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者          request.setOutId("yourOutId");         // hint 此处可能会抛出异常,注意catch         SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request);         return sendSmsResponse;     }      //短信查询     public static QuerySendDetailsResponse querySendDetails(String bizId) throws ClientException {          //可自助调整超时时间         System.setProperty("sun.net.client.defaultReadTimeout", "10000");         System.setProperty("sun.net.client.defaultConnectTimeout", "10000");         //初始化acsClient,暂不支持region化         IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou",accessKeyId, accessKeySecret);         DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product,domain);         IAcsClient acsClient = new DefaultAcsClient(profile); //组装请求对象         QuerySendDetailsRequest request = new QuerySendDetailsRequest(); //必填-号码         request.setPhoneNumber("15000000000");         //可选-流水号         request.setBizId(bizId);         //必填-发送日期 支持30天内记录查询,格式yyyyMMdd         SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");         request.setSendDate(ft.format(new Date()));         //必填-页大小         request.setPageSize(10L);         //必填-当前页码从1开始计数         request.setCurrentPage(1L);         //hint 此处可能会抛出异常,注意catch         QuerySendDetailsResponse querySendDetailsResponse =acsClient.getAcsResponse(request);         return querySendDetailsResponse;     }      public static void main(String[] args) throws ClientException, InterruptedException {          //发短信         SendSmsResponse response = sendSms();         System.out.println("短信接口返回的数据----------------");         System.out.println("Code=" + response.getCode());         System.out.println("Message=" + response.getMessage());         System.out.println("RequestId=" + response.getRequestId());         System.out.println("BizId=" + response.getBizId());         Thread.sleep(3000L);         //查明细         if (response.getCode() != null && response.getCode().equals("OK")) {             QuerySendDetailsResponse querySendDetailsResponse = querySendDetails(response.getBizId());             System.out.println("短信明细查询接口返回数据----------------");             System.out.println("Code=" + querySendDetailsResponse.getCode());             System.out.println("Message=" + querySendDetailsResponse.getMessage());             int i = 0;             for (QuerySendDetailsResponse.SmsSendDetailDTO smsSendDetailDTO : querySendDetailsResponse.getSmsSendDetailDTOs()) {                 System.out.println("SmsSendDetailDTO[" + i + "]:");                 System.out.println("Content=" + smsSendDetailDTO.getContent());                 System.out.println("ErrCode=" + smsSendDetailDTO.getErrCode());                 System.out.println("OutId=" + smsSendDetailDTO.getOutId());                 System.out.println("PhoneNum=" + smsSendDetailDTO.getPhoneNum());                 System.out.println("ReceiveDate=" + smsSendDetailDTO.getReceiveDate());                 System.out.println("SendDate=" + smsSendDetailDTO.getSendDate());                 System.out.println("SendStatus=" + smsSendDetailDTO.getSendStatus());                 System.out.println("Template=" + smsSendDetailDTO.getTemplateCode());             }             System.out.println("TotalCount=" + querySendDetailsResponse.getTotalCount());             System.out.println("RequestId=" + querySendDetailsResponse.getRequestId());         }     } }

下单之后发送短信

在 shop-user 模块中加入sms依赖

<!--短信发送--> <dependency>   <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-alicloud-sms</artifactId>  </dependency>

将阿里短信给出的demo封装成工具类

import com.aliyuncs.DefaultAcsClient; import com.aliyuncs.IAcsClient; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse; import com.aliyuncs.profile.DefaultProfile; import com.aliyuncs.profile.IClientProfile;  public class SmsUtil {     //替换成自己申请的accessKeyId     private static String accessKeyId = "LTAIMLlf8NKYXn1M"; //替换成自己申请的accessKeySecret     private static String accessKeySecret = "hqyW0zTNzeSIFnZhMEkOaZXVVcr3Gj";     static final String product = "Dysmsapi";     static final String domain = "dysmsapi.aliyuncs.com";      /**      * \* 发送短信 *      * \* @param phoneNumbers 要发送短信到哪个手机号      * \* @param signName 短信签名[必须使用前面申请的]      * \* @param templateCode 短信短信模板ID[必须使用前面申请的]      * \* @param param 模板中${code}位置传递的内容      */     public static void sendSms(String phoneNumbers, String signName, String             templateCode, String param) {         try {             System.setProperty("sun.net.client.defaultConnectTimeout", "10000");             System.setProperty("sun.net.client.defaultReadTimeout", "10000"); //初始化acsClient,暂不支持region化             IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou",                     accessKeyId, accessKeySecret);             DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product,                     domain);             IAcsClient acsClient = new DefaultAcsClient(profile);             SendSmsRequest request = new SendSmsRequest();             request.setPhoneNumbers(phoneNumbers);             request.setSignName(signName);             request.setTemplateCode(templateCode);             request.setTemplateParam(param);             request.setOutId("yourOutId");                          SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request);             if (!"OK".equals(sendSmsResponse.getCode())) {                 throw new RuntimeException(sendSmsResponse.getMessage());             }         } catch (Exception e) {             e.printStackTrace();             throw new RuntimeException("发送短信失败");         }      } }

修改短信发送的服务

/* 发送短信的服务 */ @Slf4j @Service( "shopSmsService" ) @RocketMQMessageListener(         consumerGroup = "shop-user", /* 消费组名 */         topic = "order-topic",     /* 消费主题 */         consumeMode = ConsumeMode.CONCURRENTLY, /* 消费模式 */         messageModel = MessageModel.CLUSTERING /* 消息模式 */ ) public class SmsService implements RocketMQListener<Order> {      @Autowired     private UserDao userDao;      @Override     public void onMessage(Order message) {         log.info("接收到了一个订单信息{},接下来就可以发送短信通知了", message);         //  根据uid 获取手机号         User user = userDao.findById(message.getUid()).get();         //  生成验证码         StringBuilder builder = new StringBuilder();         for (int i = 0; i < 6; i++) {             builder.append(new Random().nextInt(9) + 1);         }         String smsCode = builder.toString();         Param param = new Param(smsCode);         try {             // 发送短信 {"code":"123456"}             SmsUtil.sendSms(user.getTelephone(), "黑马旅游网", "SMS_170836451", JSON.toJSONString(param));             log.info("短信发送成功");         } catch (Exception e) {             e.printStackTrace();         }     }      @Data     @AllArgsConstructor     @NoArgsConstructor     class Param {         private String code;     } }

使用群晖把阿里云盘挂载为本地系统的磁盘

Tue, 10 Aug 2021 15:36:00 GMT

群晖使用ali-webdav

首先你的群晖支持docker

ali-webdav下载

在docker的注册表搜索 ali-webdav 如图所示然后点击下载

ali-webdava安装

映像中选中ali-webdava 点击启动

高级设置

启用自动重新启动

作用是开机启动不用每次重新启动

挂载文件夹路径

/usr/local/java/docker/

作用是1.如果token 失效可以直接替换文件夹中的token。2.可以直接查看日志

设置端口

作用后面可以页面访问，防止端口变化

设置参数

# ALIYUNDRIVE_REFRESH_TOKEN 是你的refreshToken 必填参数 # 下面三个参数可以不做修改 # ALIYUNDRIVE_AUTH_ENABLE 是否开启WebDav账户验证，默认开启true 选填 # ALIYUNDRIVE_AUTH_USERNAME WebDav账户，默认admin 选填 # ALIYUNDRIVE_AUTH_PASSWORD WebDav密码，默认admin 选填

验证是否成功

输入你的群晖IP 加上刚才设置的端口号我的地址是 http://192.168.2.153:8088/

如果出现访问页面则代表成功，如果不是的话看一下日志提示的什么错误。

本地硬盘映射

我使用的是RaiDrive 工具，windos自带的有点卡，这个很流畅，每秒拷贝 10M/s 左右

免费的SSL证书申请地址分享

Mon, 09 Aug 2021 03:58:04 GMT

这里只提供申请地址，申请教程就不写了，排名无先后。

其中部分可免费申请多域名通配符证书

腾讯云：https://cloud.tencent.com/product/ssl

阿里云：https://www.aliyun.com/product/cas

又拍云：https://www.upyun.com/products/ssl

沃通：https://freessl.wosign.com/

七牛云：https://www.qiniu.com/ssl

FreeSSL：https://freessl.cn/

Let’s Encrypt：https://letsencrypt.org/

cloudflare：https://www.cloudflare.com/

FreeSSL：https://freessl.org

Buypass： https://www.buypass.com/

AMH: https://amh.sh/ssl.htm

国内外在线接收短信验证码大全

Sun, 08 Aug 2021 15:27:27 GMT

网上也发布过类似的文章，不过很多网站更换域名或停止访问不能用了；近期网友又整理了14个网址，可以用来免费在线接收验证码使用，可以防止自己隐私泄露；国内外手机号码都有，严禁用于非法使用，后果由使用者自担承担！

接码地址

以下网站可用于在线接收验证码（网页界面广告广告有点多，但不影响使用）

https://www.bfkdim.com

https://www.materialtools.com

http://www.z-sms.com

https://www.yinsiduanxin.com/china-phone-number.html

https://www.zusms.com/phone/china

https://jieduanxin.com/China-Phone-Number

https://jiemahao.com

https://sms-receive.net

https://getfreesmsnumber.com (ua设置成pc或者电脑打开)

http://receive-sms-online.info

https://sms-online.co/receive-free-sms

https://f4.work/list_free.php?

http://lothelper.com/cn/shownumber?page=1list=PHONELIST_1_1_44

https://smsreceivefree.com

联通官网免费申请155555手机靓号

Sun, 08 Aug 2021 11:36:00 GMT

有人问我我手机号怎么买了，怎么这么好记，现在分享给大家！

今天分享给大家一个免费申请联通手机15555AA手机靓号的方法，不要钱。网上很多人再买几十几百几千都有，其实这些号码都可以不要钱申请到的！不要再花钱买手机靓号啦，比如教程上面可以申请的 1565555这样的号码在“某宝”上面卖一千多呢。

今天教大家如何免费申请！！

第一步：找到联通官网免费选号链接

百度搜索“联通大新思维” 五个字，就可以看到联通的一个最新官方申请链接。

或者直接打开下面链接

http://www.10010.com/goodsdetail/301904268051.html

第二步：选择对应号码地区

1555533/15555345选“芜湖”。

1555522/15555234选“宣城”

1555511/166551155选“合肥”。

1555525/185551888选“亳州”

1565555/1865555/1315555选“马鞍山”。

（马鞍山的有的有最低消费和预存款其他的不需要，号码都是全国通用的，发全国的，而且以后也可以携号转网。

所以地区不需要纠结，号码喜欢就好.

第四步：选择自己喜欢的号码

可以多选几页，多选几个上面的地区，然后看看有没有自己喜欢的。

然后确定喜欢号码，加入备选下单就好了，不要钱的！赶快去看看吧！

Centos7搭建JDK+Mysql+Redis

Sat, 24 Jul 2021 04:34:00 GMT

JDK

下载

官网下载 JDK8：http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

安装

# 创建目录 mkdir /usr/local/java # 拷贝安装包到指定目录 cp jdk-8u301-linux-x64.tar.gz   /usr/local/java/ # 进入java安装目录 cd /usr/local/java/ # 解压jdk安装包 tar -zxvf jdk-8u301-linux-x64.tar.gz # 删除安装包（可选） rm -rf jdk-8u301-linux-x64.tar.gz

配置环境变量

# 编辑配置文件 vim /etc/profile # 最下面添加如下内容： export JAVA_HOME=/usr/local/java/jdk1.8.0_301 export CLASSPATH=$JAVA_HOME/lib/ export PATH=$PATH:$JAVA_HOME/bin **************** 或者添加下面这种 JAVA_HOME=/usr/local/java/jdk1.8.0_301 CLASSPATH=$JAVA_HOME/lib/ PATH=$PATH:$JAVA_HOME/bin export PATH JAVA_HOME CLASSPATH  # 然后ESC :wq保存退出 :wq # 配置生效 source /etc/profile # 检查安装情况 java -version

Maven

下载

官网下载地址： https://maven.apache.org/download.cgi

安装

 # 创建目录 mkdir /usr/local/maven # 解压到创建目录下 tar -zxvf apache-maven-3.8.2-bin.tar.gz -C /usr/local/maven/ # 进入maven安装目录 下面有文件则没有问题 cd /usr/local/maven/apache-maven-3.8.2 ********************************************************* [root@xmg-gz apache-maven-3.8.2]# ls bin  boot  conf  lib  LICENSE  NOTICE  README.txt

配置

# 编辑配置文件 vim /etc/profile # 最下面添加如下内容： export MAVEN_HOME=/usr/local/maven/apache-maven-3.8.2 export MAVEN_HOME export PATH=$PATH:$MAVEN_HOME/bin # 然后ESC :wq保存退出 :wq # 配置生效 source /etc/profile # 检查配置情况 mvn -version

MYSQL

背景信息

MySQL：5.7.33

MySQL相关安装路径说明如下：
- 配置文件：/etc/my.cnf
- 数据存储：/var/lib/mysql
- 命令文件：/usr/bin和/usr/sbin
数据库端口：3306

安装mysql

# 更新YUM源 rpm -Uvh  https://dev.mysql.com/get/mysql57-community-release-el7-9.noarch.rpm # 安装MySQL yum -y install mysql-community-server # 查看MySQL版本号 mysql -V

配置MySQL

# 启动MySQL服务 systemctl start mysqld # 设置MySQL服务开机自启动 systemctl enable mysqld # 查看/var/log/mysqld.log文件，获取并记录root用户的初始密码 grep 'temporary password' /var/log/mysqld.log # 执行命令结果示例如下。 2020-04-08T08:12:07.893939Z 1 [Note] A temporary password is generated for root@localhost: xvlo1lZ12>uI # 对MySQL进行安全性配置需要初始密码 mysql_secure_installation

安全性配置

重置root用户的密码

#确保MySQL服务器部署的安全。 Securing the MySQL server deployment. #输入root用户的密码:  输入上一步获取的root用户初始密码 Enter password for user root:  #root用户的密码已经过期。请设置新密码。 The existing password for the user account root has expired. Please set a new password. #新密码: New password:  #重新输入新密码: Re-enter new password:  #'validate_password'插件安装在服务器上。 The 'validate_password' plugin is installed on the server. #后续步骤将使用现有配置运行的插件。 The subsequent steps will run with the existing configuration of the plugin. #使用现有的root密码。 Using existing password for root. #估计密码强度:100 Estimated strength of the password: 100  #修改root用户密码?(按y| y表示是，其他任何键表示否):y Change the password for root ? ((Press y|Y for Yes, any other key for No) : y #新密码: 长度为8至30个字符，必须同时包含大小写英文字母、数字和特殊符号。特殊符号可以是()` ~!@#$%^&*-+=|{}[]:;‘<>,.?/ New password:  #重新输入新密码: Re-enter new password:  #估计密码强度:100 Estimated strength of the password: 100  #您希望继续使用所提供的密码吗?(按y| y为Yes，按其他键为No): y Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y

删除匿名用户账号

#默认情况下，MySQL安装有一个匿名用户，允许任何人登录到MySQL，而无需为他们创建用户帐户。这只用于测试，并使安装过程更顺畅。您应该在转移到生产环境之前删除它们。 By default, a MySQL installation has an anonymous user, allowing anyone to log into MySQL without having to have a user account created for them. This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment. #删除匿名用户?(按y| y为Yes，按其他键为No): Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y  #是否删除匿名用户，输入Y Success.

禁止root账号远程登录

# 通常，根应该只允许从“localhost”。这就保证了别人猜不到来自网络的根密码。 Normally, root should only be allowed to connect from 'localhost'. This ensures that someone cannot guess at the root password from the network.  #禁止root远程登录?(按y| y表示是，其他键表示否): Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y #禁止root远程登录，输入Y Success.

删除test库以及对test库的访问权限

 默认情况下，MySQL自带一个名为“test”的数据库任何人都可以访问。这也仅用于测试，并且应该在进入生产之前被删除环境。 By default, MySQL comes with a database named 'test' that anyone can access. This is also intended only for testing,and should be removed before moving into a production environment.  删除测试数据库并访问它?(按y| y表示是，其他键表示否) Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y #是否删除test库和对它的访问权限，输入Y - Dropping test database... Success.

重新加载授权表

#重新加载特权表将确保所有更改到目前为止所做的将立即生效。 Reloading the privilege tables will ensure that all changes made so far will take effect immediately.  #现在重新加载特权表?(按y| y表示是，其他键表示否) Reload privilege tables now? (Press y|Y for Yes, any other key for No) :  Success. All done!

安全性配置的更多信息，请参见MySQL官方文档。

远程访问MySQL数据库

配置安全组策略

阿里云服务器安全组配置>配置规则>添加安全组授权对象 0.0.0.0/0表示任意的IP。

授权策略	优先级	协议类型	端口范围	授权对象	描述	创建时间	操作
允许	1	自定义 TCP	目的: 3306/3306	源: 0.0.0.0/0	mysql数据库	2021年7月21日13:04:05	编辑复制删除

修改表法

# 进入mysql 输入密码 mysql -u root  -p   # 切换数据库 use mysql; # 修改数据库数据 update user set host = '%' where user = 'root'; # 查询修改结果 select host,user from user where user = 'root';

授权法

#你想myuser使用mypassword（密码）从任何主机连接到mysql服务器的话。   grant all on *.* to 'myuser'@'%' IDENTIFIED BY 'mypassword';  #使用root替换 myuser，可设置为允许root账号远程登录。  #如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作为密码    grant all on *.* to 'myuser'@'192.168.1.6' IDENTIFIED BY 'mypassword';  #使修改生效 FLUSH  PRIVILEGES

在采用授权法之后，无法在本地登录mysql 提示ERROR 1045 (28000): Access denied for user 'root'@'loadb116' (using password: YES) 上例中loadb116是主机名. 这时可以使用root进入后授权
grant all privileges on *.* to 'root'@'loadb116' identified by '123456' with grant option;   flush  privileges;  
或者使用本地IP登录

重启服务

systemctl restart mysqld

如果此时连不上，重启一下 reboot

Redis

redis下载

下载地址：http://redis.io/download，下载最新稳定版本。

 mkdir /usr/local/redis/ wget http://download.redis.io/releases/redis-6.0.8.tar.gz tar xzf redis-6.0.8.tar.gz

安装

# 进入redis目录 cd redis-6.0.8 # 安装 gcc  则直接进行编译 make yum -y install gcc # 如果不安装会编译报错  # -------------如果还报错  临时升级版本 start  gcc -v                             # 查看gcc版本    yum -y install centos-release-scl  # 升级到9.1版本    yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils    scl enable devtoolset-9 bash   # -------------如果还报错  临时升级版本 end # 编译 make

安装成功会出现：Hint: It's a good idea to run 'make test'

执行make test 进行测试，如果出现如下错误：

[root@localhost redis-6.0.1]# make test cd src && make test make[1]: 进入目录“/usr/redis-6.0.1/src”     CC Makefile.dep make[1]: 离开目录“/usr/redis-6.0.1/src” make[1]: 进入目录“/usr/redis-6.0.1/src” You need tcl 8.5 or newer in order to run the Redis test make[1]: *** [test] 错误 1 make[1]: 离开目录“/usr/redis-6.0.1/src” make: *** [test] 错误 2

解决办法

# 安装 tcl yum install tcl  make test

修改配置文件

# 修改配置文件 vi redis.conf # 修改 #bind 127.0.0.1 为bind 0.0.0.0 -> 允许所有主机访问 69 # bind 127.0.0.1  70       bind 0.0.0.0 # 将daemonize no 改成 daemonize yes -> 设置redis可以一直在后台运行，以守护进程方式运行 225 daemonize yes #  密码设置，将”#requirepass foobared“ 取掉注释改成 requirepass 123456(或者其它你需要的密码) 791 requirepass 123456 GZA$bXZwnbe!6j

设置开机启动

# 创建存放redis的配置文件 mkdir /etc/redis # 创建存放redis的持久化文件 （可选） mkdir /var/redis/ mkdir /var/redis/6379  # 拷贝配置文件 cp /usr/local/redis/redis-6.0.8/redis.conf /etc/redis/6379.conf # 检查一下配置 daemonize yes       #让redis以daemon进程运行 pidfile  /var/run/redis_6379.pid  #设置redis的pid文件位置 port  6379      #设置redis的监听端口号 dir   /var/redis/6379    #设置持久化文件的存储位置 （可选）   # 拷贝脚本到开机启动脚本目录下 cp   /usr/local/redis/redis-6.0.8/utils/redis_init_script  /etc/init.d/redis_6379 cd /etc/init.d/  vim redis_6379 # 最上面，加入两行注释 # chkconfig:   2345 90 10 # description:  Redis is a persistent key-value database # 修改 以下两个地址 为自己的文件地址 EXEC=/usr/local/redis/redis-6.0.8/src/redis-server CLIEXEC=/usr/local/redis/redis-6.0.8/src/redis-cli # 授权  chmod 777 redis_6379 # 启动 redis ./redis_6379 start # 执行 加入开机启动 chkconfig redis_6379 on

Kubernetes简介和安装

Wed, 02 Jun 2021 16:11:00 GMT

What is Kubernetes？

Kubernetes这个单词来自于希腊语，含义是舵手或领航员

简介说明

Production-Grade Container Orchestration Automated container deployment, scaling, and management

生产级的容器编排自动化的容器部署、扩展和管理

Kubernetes，也称为K8S，其中8是代表中间“ubernete”的8个字符，是Google在2014年开源的一个容器编排引擎，用于自动化容器化应用程序的部署、规划、扩展和管理，它将组成应用程序的容器分组为逻辑单元，以便于管理和发现，用于管理云平台中多个主机上的容器化的应用，Kubernetes 的目标是让部署容器化的应用简单并且高效，很多细节都不需要运维人员去进行复杂的手工配置和处理；

Kubernetes拥有Google在生产环境上15年运行的经验，并结合了社区中最佳实践；

K8S是 CNCF 毕业的项目，本来Kubernetes是Google的内部项目，后来开源出来，又后来为了其茁壮成长，捐给了CNCF；

CNCF全称Cloud Native Computing Foundation（云原生计算基金会）

官网：https://kubernetes.io/

代码：https://github.com/kubernetes/kubernetes

Kubernetes是采用Go语言开发的，Go语言是谷歌2009发布的一款开源编程语言；

编排是什么意思？

按照一定的目的依次排列；

调配、安排；

整体架构

Master

k8s集群控制节点，对集群进行调度管理，接受集群外用户去集群操作请求；

Master Node 由 API Server、Scheduler、ClusterState Store（ETCD 数据库）和 Controller MangerServer 所组成；

Nodes

集群工作节点，运行用户业务应用容器；

Nodes节点也叫Worker Node，包含kubelet、kube proxy 和 Pod（Container Runtime）；

搭建方式

部署 Kubernetes 环境（集群）主要有多种方式：

minikube

minikube可以在本地运行Kubernetes的工具，minikube可以在个人计算机（包括Windows，macOS和Linux PC）上运行一个单节点Kubernetes集群，以便您可以试用Kubernetes或进行日常开发工作；

https://kubernetes.io/docs/tutorials/hello-minikube/

kind

Kind和minikube类似的工具，让你在本地计算机上运行Kubernetes，此工具需要安装并配置Docker；

https://kind.sigs.k8s.io/

kubeadm

Kubeadm是一个K8s部署工具，提供kubeadm init 和 kubeadm join两个操作命令，可以快速部署一个Kubernetes集群；

官方地址：

https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/

https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/

二进制包

从Github下载发行版的二进制包，手动部署安装每个组件，组成Kubernetes集群，步骤比较繁琐，但是能让你对各个组件有更清晰的认识；

yum安装

通过yum安装Kubernetes的每个组件，组成Kubernetes集群，不过yum源里面的k8s版本已经比较老了，所以这种方式用得也比较少了；

第三方工具

有一些大神封装了一些工具，利用这些工具进行k8s环境的安装；

花钱购买

直接购买类似阿里云这样的公有云平台k8s，一键搞定；

Kubeadm部署

kubeadm是官方社区推出的一个用于快速部署 kubernetes 集群的工具，这个工具能通过两条指令完成一个kubernetes集群的部署；

创建一个Master节点：
```
kubeadm init 
```

将Node节点加入到Master集群中：

$ kubeadm join <Master节点的IP和端口>

环境要求

一台或多台机器，操作系统CentOS 7.x-86_x64
硬件配置：内存2GB或2G+，CPU 2核或CPU 2核+；
集群内各个机器之间能相互通信；
集群内各个机器可以访问外网，需要拉取镜像；(非必须)
禁止swap分区；

如果环境不满足要求，会报错，比如：

环境准备

关闭防火墙

systemctl stop firewalld systemctl disable firewalld

关闭selinux

sed -i 's/enforcing/disabled/' /etc/selinux/config  #永久 setenforce 0  #临时

关闭swap（k8s禁止虚拟内存以提高性能）

sed -ri 's/.*swap.*/#&/' /etc/fstab #永久 swapoff -a #临时

在master添加hosts

cat >> /etc/hosts << EOF 172.16.45.131 k8smaster 172.16.45.132 k8snode1 172.16.45.133 k8snode2 EOF

设置网桥参数

systemctl stop firewalld systemctl disable firewalld

时间同步

systemctl stop firewalld systemctl disable firewalld

安装步骤

所有服务器节点安装 Docker/kubeadm/kubelet/kubectl

Kubernetes 默认容器运行环境是Docker，因此首先需要安装Docker；

安装 Docker

#更新docker的yum源 yum install wget -y wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo #安装指定版本的docker： yum install docker-ce-19.03.13 -y #yum install docker -y （这个安装的Docker版本偏旧） 1.13.x  #配置加速器加速下载 登录该网址获取加速地址（https://cr.console.aliyun.com/）  sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json <<-'EOF' {   "registry-mirrors": ["https://bz93554o.mirror.aliyuncs.com"] } EOF sudo systemctl daemon-reload sudo systemctl restart docker  #然后执行以下命令不然会提示警告； systemctl enable docker.service #那么接下来需要搭建：kubeadm、kubelet、kubectl

配置k8s的阿里云YUM源

cat > /etc/yum.repos.d/kubernetes.repo << EOF [kubernetes] name=Kubernetes baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64 enabled=1 gpgcheck=0 repo_gpgcheck=0 gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg EOF

到时候下载k8s的相关组件才能找到下载源；

安装 kubeadm，kubelet 和 kubectl

yum install kubelet-1.19.4 kubeadm-1.19.4 kubectl-1.19.4 -y #然后执行以下命令不然会提示警告； systemctl enable kubelet.service #查看有没有安装： yum list installed | grep kubelet yum list installed | grep kubeadm yum list installed | grep kubectl #查看安装的版本：  kubelet --version

Kubelet：运行在cluster所有节点上，负责启动POD和容器；

Kubeadm：用于初始化cluster的一个工具；

Kubectl：kubectl是kubenetes命令行工具，通过kubectl可以部署和管理应用，查看各种资源，创建，删除和更新组件；

切记：此时应该重启一下centos；

重要的事情说三遍！！！

部署Master主节点

在master机器上执行以下命令；

kubeadm init --apiserver-advertise-address=172.16.45.131 --image-repository registry.aliyuncs.com/google_containers --kubernetes-version v1.19.4 --service-cidr=10.96.0.0/12 --pod-network-cidr=10.244.0.0/16

说明：

service-cidr 的选取不能和PodCIDR及本机网络有重叠或者冲突，一般可以选择一个本机网络和PodCIDR都没有用到的私网地址段，比如PODCIDR使用10.244.0.0/16, 那么service cidr可以选择10.96.0.0/12，网络无重叠冲突即可；

执行成功后会显示以下信息

[root@k8smaster ~]# kubeadm init --apiserver-advertise-address=172.16.45.131 --image-repository registry.aliyuncs.com/google_containers --kubernetes-version v1.19.4 --service-cidr=10.96.0.0/12 --pod-network-cidr=10.244.0.0/16 W0602 21:10:27.153412    8853 configset.go:348] WARNING: kubeadm cannot validate component configs for API groups [kubelet.config.k8s.io kubeproxy.config.k8s.io] [init] Using Kubernetes version: v1.19.4 [preflight] Running pre-flight checks         [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/ [preflight] Pulling images required for setting up a Kubernetes cluster [preflight] This might take a minute or two, depending on the speed of your internet connection [preflight] You can also perform this action in beforehand using 'kubeadm config images pull' [certs] Using certificateDir folder "/etc/kubernetes/pki" [certs] Generating "ca" certificate and key [certs] Generating "apiserver" certificate and key [certs] apiserver serving cert is signed for DNS names [k8smaster kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 172.16.45.131] [certs] Generating "apiserver-kubelet-client" certificate and key [certs] Generating "front-proxy-ca" certificate and key [certs] Generating "front-proxy-client" certificate and key [certs] Generating "etcd/ca" certificate and key [certs] Generating "etcd/server" certificate and key [certs] etcd/server serving cert is signed for DNS names [k8smaster localhost] and IPs [172.16.45.131 127.0.0.1 ::1] [certs] Generating "etcd/peer" certificate and key [certs] etcd/peer serving cert is signed for DNS names [k8smaster localhost] and IPs [172.16.45.131 127.0.0.1 ::1] [certs] Generating "etcd/healthcheck-client" certificate and key [certs] Generating "apiserver-etcd-client" certificate and key [certs] Generating "sa" key and public key [kubeconfig] Using kubeconfig folder "/etc/kubernetes" [kubeconfig] Writing "admin.conf" kubeconfig file [kubeconfig] Writing "kubelet.conf" kubeconfig file [kubeconfig] Writing "controller-manager.conf" kubeconfig file [kubeconfig] Writing "scheduler.conf" kubeconfig file [kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env" [kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml" [kubelet-start] Starting the kubelet [control-plane] Using manifest folder "/etc/kubernetes/manifests" [control-plane] Creating static Pod manifest for "kube-apiserver" [control-plane] Creating static Pod manifest for "kube-controller-manager" [control-plane] Creating static Pod manifest for "kube-scheduler" [etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests" [wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s [apiclient] All control plane components are healthy after 14.502742 seconds [upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace [kubelet] Creating a ConfigMap "kubelet-config-1.19" in namespace kube-system with the configuration for the kubelets in the cluster [upload-certs] Skipping phase. Please see --upload-certs [mark-control-plane] Marking the node k8smaster as control-plane by adding the label "node-role.kubernetes.io/master=''" [mark-control-plane] Marking the node k8smaster as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule] [bootstrap-token] Using token: uk5qox.2z2gpcq1qtjl7hlr [bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles [bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to get nodes [bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials [bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token [bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster [bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace [kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key [addons] Applied essential addon: CoreDNS [addons] Applied essential addon: kube-proxy  Your Kubernetes control-plane has initialized successfully!  To start using your cluster, you need to run the following as a regular user:    mkdir -p $HOME/.kube   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config   sudo chown $(id -u):$(id -g) $HOME/.kube/config  You should now deploy a pod network to the cluster. Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:   https://kubernetes.io/docs/concepts/cluster-administration/addons/  Then you can join any number of worker nodes by running the following on each as root:  kubeadm join 172.16.45.131:6443 --token uk5qox.2z2gpcq1qtjl7hlr \     --discovery-token-ca-cert-hash sha256:ce6240b7d71a93309c46e99d450028d2d36fcb508960c557e6ce56bfaf0b1c58

接下来在master机器上继续执行：

mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config

查看节点

kubectl get nodes

部署Node节点

kubeadm join 172.16.45.131:6443 --token uk5qox.2z2gpcq1qtjl7hlr \     --discovery-token-ca-cert-hash sha256:ce6240b7d71a93309c46e99d450028d2d36fcb508960c557e6ce56bfaf0b1c58

成功后会显示以下信息

[root@k8snode1 ~]# kubeadm join 172.16.45.131:6443 --token uk5qox.2z2gpcq1qtjl7hlr \ >     --discovery-token-ca-cert-hash sha256:ce6240b7d71a93309c46e99d450028d2d36fcb508960c557e6ce56bfaf0b1c58  [preflight] Running pre-flight checks         [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/ [preflight] Reading configuration from the cluster... [preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml' [kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml" [kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env" [kubelet-start] Starting the kubelet [kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...  This node has joined the cluster: * Certificate signing request was sent to apiserver and a response was received. * The Kubelet was informed of the new secure connection details.  Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

此时在master上查看节点显示以下信息说明加入成功

[root@k8smaster ~]# kubectl get nodes NAME        STATUS   ROLES    AGE    VERSION k8smaster   NotReady    master   172m   v1.19.4 k8snode1    NotReady    <none>   120m   v1.19.4 k8snode2    NotReady    <none>   120m   v1.19.4

部署网络插件

下载kube-flannel.yml文件

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

应用kube-flannel.yml文件得到运行时容器

#在master机器上执行 kubectl apply -f kube-flannel.yml

[root@k8smaster ~]# kubectl apply -f kube-flannel.yml podsecuritypolicy.policy/psp.flannel.unprivileged created clusterrole.rbac.authorization.k8s.io/flannel created clusterrolebinding.rbac.authorization.k8s.io/flannel created serviceaccount/flannel created configmap/kube-flannel-cfg created daemonset.apps/kube-flannel-ds created #（稍等几分钟后） 查看节点信息 会看见状态发生变化 [root@k8smaster ~]# kubectl get nodes NAME        STATUS   ROLES    AGE    VERSION k8smaster   Ready    master   172m   v1.19.4 k8snode1    Ready    <none>   120m   v1.19.4 k8snode2    Ready    <none>   120m   v1.19.4

至此我们的k8s环境就搭建好了；

查看运行时容器pod （一个pod里面运行了多个docker容器）

kubectl get pods -n kube-system

部署容器化应用

#部署nginx kubectl create deployment nginx --image=nginx kubectl expose deployment nginx --port=80 --type=NodePort kubectl get pod,svc #访问地址：http://NodeIP:Port #部署Tomcat： kubectl create deployment tomcat --image=tomcat kubectl expose deployment tomcat --port=8080 --type=NodePort #访问地址：http://NodeIP:Port

K8s部署微服务

1、项目打包（jar、war）-->可以采用一些工具git、maven、jenkins

2、制作Dockerfile文件，生成镜像；

3、kubectl create deployment nginx --image= 你的镜像

4、你的springboot就部署好了，是以docker容器的方式运行在pod里面的；

Mac VM CentOS7配置静态IP

Sun, 30 May 2021 15:40:00 GMT

把网络配置改成nat模式

获取网关地址和子网掩码

通过Mac终端进入VMware Fusion的vmnet8目录

cd /Library/Preferences/VMware\ Fusion/vmnet8

查看nat.conf

cat nat.conf

记住红框中的数据，下面配置时需要用到

获取可用IP地址

查看cat dhcpd.conf

cat dhcpd.conf

注意range 这个是虚拟机允许选择的静态ip地址范围，自定义的静态ip地址必须要在这个范围内(本文打算使用172.16.104.130为例介绍)

获取DNS1地址

mac系统偏好设置—>网络—>

配置CentOS7网络配置

登录CentOS7进入虚拟机的network-scripts目录

cd /etc/sysconfig/network-scripts

找到ifcfg-en开头的文件,上图中我的是ifcfg-ens33

通过vi编辑该文件

下图是默认配置

我们将它改成如下配置

重启服务使修改生效

service network restart

测试配置是否成功

ping一下百度看看，成功Ping到

其他网络上网连接问题

接下来我们就可以通过SecureCRT等工具远程连接了，有一点请记住，如果你换了一个地方上网的话，可能会发现你的虚拟机有不通了，那是因为DNS地址发生了变化，此时只需要再次编辑ifcfg-enxxx文件，然后加上你现在网络的DNS地址即可

如:

DNS1=192.168.0.1 DNS2=114.114.114.114

我们通过SecureCRT连接测试一下

其他命令

ifconfig  #查询自己的IP地址  netstat -rn #查询自己的默认网关和 #子网掩码  cat /etc/resolv.conf #查询自己的 DNS 配置

Docker-常用安装与镜像发布到阿里云（四）

Sun, 16 May 2021 11:45:00 GMT

Docker常用安装

总体步骤

搜索镜像->拉取镜像->查看镜像->启动镜像->停止容器->移除容器

安装tomcat

1.docker hub上面查找tomcat镜像

docker search tomcat

2.从docker hub上拉取tomcat镜像到本地

docker pull tomcat

官网命令：

3.docker images查看是否有拉取到的tomcat

docker images

4.使用tomcat镜像创建容器(也叫运行镜像)

docker run -it -p 8080:8080 tomcat #  -p 主机端口:docker容器端口 #  -P 随机分配端口 #  i:交互 #  t:终端

安装mysql

docker hub上面查找mysql镜像

从docker hub上(阿里云加速器)拉取mysql镜像到本地标签为5.6

使用mysql5.6镜像创建容器(也叫运行镜像)

使用mysql镜像

docker run -p 12345:3306 --name mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -v /zzyyuse/mysql/logs:/logs -v /zzyyuse/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6  #命令说明： #-p 12345:3306：将主机的12345端口映射到docker容器的3306端口。 #--name mysql：运行服务名字 #-v /zzyyuse/mysql/conf:/etc/mysql/conf.d ：将主机/zzyyuse/mysql录下的conf/my.cnf 挂载到容器的 /etc/mysql/conf.d #-v /zzyyuse/mysql/logs:/logs：将主机/zzyyuse/mysql目录下的 logs 目录挂载到容器的 /logs。 #-v /zzyyuse/mysql/data:/var/lib/mysql ：将主机/zzyyuse/mysql目录下的data目录挂载到容器的 /var/lib/mysql  #-e MYSQL_ROOT_PASSWORD=123456：初始化 root 用户的密码。 #-d mysql:5.6 : 后台程序运行mysql5.6  docker exec -it MySQL运行成功后的容器ID     /bin/bash

数据备份

docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"123456" ' > /zzyyuse/all-databases.sql

安装redis

从docker hub上(阿里云加速器)拉取redis镜像到本地标签为3.2

使用redis3.2镜像创建容器(也叫运行镜像)

使用镜像

docker run -p 6379:6379 -v /zzyyuse/myredis/data:/data -v /zzyyuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf  -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

在主机/zzyyuse/myredis/conf/redis.conf目录下新建redis.conf文件

vim /zzyyuse/myredis/conf/redis.conf/redis.conf

# Redis configuration file example. # Note that in order to read the configuration file, Redis must be # started with the file path as first argument: # # ./redis-server /path/to/redis.conf   # Note on units: when memory size is needed, it is possible to specify # it in the usual form of 1k 5GB 4M and so forth: # # 1k => 1000 bytes # 1kb => 1024 bytes # 1m => 1000000 bytes # 1mb => 1024*1024 bytes # 1g => 1000000000 bytes # 1gb => 1024*1024*1024 bytes # # units are case insensitive so 1GB 1Gb 1gB are all the same. ################################## INCLUDES ###################################   # Include one or more other config files here.  This is useful if you # have a standard template that goes to all Redis servers but also need # to customize a few per-server settings.  Include files can include # other files, so use this wisely. # # Notice option "include" won't be rewritten by command "CONFIG REWRITE" # from admin or Redis Sentinel. Since Redis always uses the last processed # line as value of a configuration directive, you'd better put includes # at the beginning of this file to avoid overwriting config change at runtime. # # If instead you are interested in using includes to override configuration # options, it is better to use include as the last line. # # include /path/to/local.conf # include /path/to/other.conf   ################################## NETWORK #####################################   # By default, if no "bind" configuration directive is specified, Redis listens # for connections from all the network interfaces available on the server. # It is possible to listen to just one or multiple selected interfaces using # the "bind" configuration directive, followed by one or more IP addresses. # # Examples: # # bind 192.168.1.100 10.0.0.1 # bind 127.0.0.1 ::1 # # ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the # internet, binding to all the interfaces is dangerous and will expose the # instance to everybody on the internet. So by default we uncomment the # following bind directive, that will force Redis to listen only into # the IPv4 lookback interface address (this means Redis will be able to # accept connections only from clients running into the same computer it # is running). # # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES # JUST COMMENT THE FOLLOWING LINE. # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #bind 127.0.0.1   # Protected mode is a layer of security protection, in order to avoid that # Redis instances left open on the internet are accessed and exploited. # # When protected mode is on and if: # # 1) The server is not binding explicitly to a set of addresses using the #    "bind" directive. # 2) No password is configured. # # The server only accepts connections from clients connecting from the # IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain # sockets. # # By default protected mode is enabled. You should disable it only if # you are sure you want clients from other hosts to connect to Redis # even if no authentication is configured, nor a specific set of interfaces # are explicitly listed using the "bind" directive. protected-mode yes   # Accept connections on the specified port, default is 6379 (IANA #815344). # If port 0 is specified Redis will not listen on a TCP socket. port 6379   # TCP listen() backlog. # # In high requests-per-second environments you need an high backlog in order # to avoid slow clients connections issues. Note that the Linux kernel # will silently truncate it to the value of /proc/sys/net/core/somaxconn so # make sure to raise both the value of somaxconn and tcp_max_syn_backlog # in order to get the desired effect. tcp-backlog 511   # Unix socket. # # Specify the path for the Unix socket that will be used to listen for # incoming connections. There is no default, so Redis will not listen # on a unix socket when not specified. # # unixsocket /tmp/redis.sock # unixsocketperm 700   # Close the connection after a client is idle for N seconds (0 to disable) timeout 0   # TCP keepalive. # # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence # of communication. This is useful for two reasons: # # 1) Detect dead peers. # 2) Take the connection alive from the point of view of network #    equipment in the middle. # # On Linux, the specified value (in seconds) is the period used to send ACKs. # Note that to close the connection the double of the time is needed. # On other kernels the period depends on the kernel configuration. # # A reasonable value for this option is 300 seconds, which is the new # Redis default starting with Redis 3.2.1. tcp-keepalive 300   ################################# GENERAL #####################################   # By default Redis does not run as a daemon. Use 'yes' if you need it. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized. #daemonize no   # If you run Redis from upstart or systemd, Redis can interact with your # supervision tree. Options: #   supervised no      - no supervision interaction #   supervised upstart - signal upstart by putting Redis into SIGSTOP mode #   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET #   supervised auto    - detect upstart or systemd method based on #                        UPSTART_JOB or NOTIFY_SOCKET environment variables # Note: these supervision methods only signal "process is ready." #       They do not enable continuous liveness pings back to your supervisor. supervised no  # If a pid file is specified, Redis writes it where specified at startup # and removes it at exit. # # When the server runs non daemonized, no pid file is created if none is # specified in the configuration. When the server is daemonized, the pid file # is used even if not specified, defaulting to "/var/run/redis.pid". # # Creating a pid file is best effort: if Redis is not able to create it # nothing bad happens, the server will start and run normally. pidfile /var/run/redis_6379.pid   # Specify the server verbosity level. # This can be one of: # debug (a lot of information, useful for development/testing) # verbose (many rarely useful info, but not a mess like the debug level) # notice (moderately verbose, what you want in production probably) # warning (only very important / critical messages are logged) loglevel notice   # Specify the log file name. Also the empty string can be used to force # Redis to log on the standard output. Note that if you use standard # output for logging but daemonize, logs will be sent to /dev/null logfile ""   # To enable logging to the system logger, just set 'syslog-enabled' to yes, # and optionally update the other syslog parameters to suit your needs. # syslog-enabled no   # Specify the syslog identity. # syslog-ident redis   # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7. # syslog-facility local0   # Set the number of databases. The default database is DB 0, you can select # a different one on a per-connection basis using SELECT <dbid> where # dbid is a number between 0 and 'databases'-1 databases 16   ################################ SNAPSHOTTING  ################################ # # Save the DB on disk: # #   save <seconds> <changes> # #   Will save the DB if both the given number of seconds and the given #   number of write operations against the DB occurred. # #   In the example below the behaviour will be to save: #   after 900 sec (15 min) if at least 1 key changed #   after 300 sec (5 min) if at least 10 keys changed #   after 60 sec if at least 10000 keys changed # #   Note: you can disable saving completely by commenting out all "save" lines. # #   It is also possible to remove all the previously configured save #   points by adding a save directive with a single empty string argument #   like in the following example: # #   save ""   save 120 1 save 300 10 save 60 10000   # By default Redis will stop accepting writes if RDB snapshots are enabled # (at least one save point) and the latest background save failed. # This will make the user aware (in a hard way) that data is not persisting # on disk properly, otherwise chances are that no one will notice and some # disaster will happen. # # If the background saving process will start working again Redis will # automatically allow writes again. # # However if you have setup your proper monitoring of the Redis server # and persistence, you may want to disable this feature so that Redis will # continue to work as usual even if there are problems with disk, # permissions, and so forth. stop-writes-on-bgsave-error yes # Compress string objects using LZF when dump .rdb databases? # For default that's set to 'yes' as it's almost always a win. # If you want to save some CPU in the saving child set it to 'no' but # the dataset will likely be bigger if you have compressible values or keys. rdbcompression yes   # Since version 5 of RDB a CRC64 checksum is placed at the end of the file. # This makes the format more resistant to corruption but there is a performance # hit to pay (around 10%) when saving and loading RDB files, so you can disable it # for maximum performances. # # RDB files created with checksum disabled have a checksum of zero that will # tell the loading code to skip the check. rdbchecksum yes   # The filename where to dump the DB dbfilename dump.rdb   # The working directory. # # The DB will be written inside this directory, with the filename specified # above using the 'dbfilename' configuration directive. # # The Append Only File will also be created inside this directory. # # Note that you must specify a directory here, not a file name. dir ./   ################################# REPLICATION #################################   # Master-Slave replication. Use slaveof to make a Redis instance a copy of # another Redis server. A few things to understand ASAP about Redis replication. # # 1) Redis replication is asynchronous, but you can configure a master to #    stop accepting writes if it appears to be not connected with at least #    a given number of slaves. # 2) Redis slaves are able to perform a partial resynchronization with the #    master if the replication link is lost for a relatively small amount of #    time. You may want to configure the replication backlog size (see the next #    sections of this file) with a sensible value depending on your needs. # 3) Replication is automatic and does not need user intervention. After a #    network partition slaves automatically try to reconnect to masters #    and resynchronize with them. # # slaveof <masterip> <masterport>   # If the master is password protected (using the "requirepass" configuration # directive below) it is possible to tell the slave to authenticate before # starting the replication synchronization process, otherwise the master will # refuse the slave request. # # masterauth <master-password>   # When a slave loses its connection with the master, or when the replication # is still in progress, the slave can act in two different ways: # # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will #    still reply to client requests, possibly with out of date data, or the #    data set may just be empty if this is the first synchronization. # # 2) if slave-serve-stale-data is set to 'no' the slave will reply with #    an error "SYNC with master in progress" to all the kind of commands #    but to INFO and SLAVEOF. # slave-serve-stale-data yes   # You can configure a slave instance to accept writes or not. Writing against # a slave instance may be useful to store some ephemeral data (because data # written on a slave will be easily deleted after resync with the master) but # may also cause problems if clients are writing to it because of a # misconfiguration. # # Since Redis 2.6 by default slaves are read-only. # # Note: read only slaves are not designed to be exposed to untrusted clients # on the internet. It's just a protection layer against misuse of the instance. # Still a read only slave exports by default all the administrative commands # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve # security of read only slaves using 'rename-command' to shadow all the # administrative / dangerous commands. slave-read-only yes   # Replication SYNC strategy: disk or socket. # # ------------------------------------------------------- # WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY # ------------------------------------------------------- # # New slaves and reconnecting slaves that are not able to continue the replication # process just receiving differences, need to do what is called a "full # synchronization". An RDB file is transmitted from the master to the slaves. # The transmission can happen in two different ways: # # 1) Disk-backed: The Redis master creates a new process that writes the RDB #                 file on disk. Later the file is transferred by the parent #                 process to the slaves incrementally. # 2) Diskless: The Redis master creates a new process that directly writes the #              RDB file to slave sockets, without touching the disk at all. # # With disk-backed replication, while the RDB file is generated, more slaves # can be queued and served with the RDB file as soon as the current child producing # the RDB file finishes its work. With diskless replication instead once # the transfer starts, new slaves arriving will be queued and a new transfer # will start when the current one terminates. # # When diskless replication is used, the master waits a configurable amount of # time (in seconds) before starting the transfer in the hope that multiple slaves # will arrive and the transfer can be parallelized. # # With slow disks and fast (large bandwidth) networks, diskless replication # works better. repl-diskless-sync no   # When diskless replication is enabled, it is possible to configure the delay # the server waits in order to spawn the child that transfers the RDB via socket # to the slaves. # # This is important since once the transfer starts, it is not possible to serve # new slaves arriving, that will be queued for the next RDB transfer, so the server # waits a delay in order to let more slaves arrive. # # The delay is specified in seconds, and by default is 5 seconds. To disable # it entirely just set it to 0 seconds and the transfer will start ASAP. repl-diskless-sync-delay 5   # Slaves send PINGs to server in a predefined interval. It's possible to change # this interval with the repl_ping_slave_period option. The default value is 10 # seconds. # # repl-ping-slave-period 10   # The following option sets the replication timeout for: # # 1) Bulk transfer I/O during SYNC, from the point of view of slave. # 2) Master timeout from the point of view of slaves (data, pings). # 3) Slave timeout from the point of view of masters (REPLCONF ACK pings). # # It is important to make sure that this value is greater than the value # specified for repl-ping-slave-period otherwise a timeout will be detected # every time there is low traffic between the master and the slave. # # repl-timeout 60   # Disable TCP_NODELAY on the slave socket after SYNC? # # If you select "yes" Redis will use a smaller number of TCP packets and # less bandwidth to send data to slaves. But this can add a delay for # the data to appear on the slave side, up to 40 milliseconds with # Linux kernels using a default configuration. # # If you select "no" the delay for data to appear on the slave side will # be reduced but more bandwidth will be used for replication. # # By default we optimize for low latency, but in very high traffic conditions # or when the master and slaves are many hops away, turning this to "yes" may # be a good idea. repl-disable-tcp-nodelay no   # Set the replication backlog size. The backlog is a buffer that accumulates # slave data when slaves are disconnected for some time, so that when a slave # wants to reconnect again, often a full resync is not needed, but a partial # resync is enough, just passing the portion of data the slave missed while # disconnected. # # The bigger the replication backlog, the longer the time the slave can be # disconnected and later be able to perform a partial resynchronization. # # The backlog is only allocated once there is at least a slave connected. # # repl-backlog-size 1mb   # After a master has no longer connected slaves for some time, the backlog # will be freed. The following option configures the amount of seconds that # need to elapse, starting from the time the last slave disconnected, for # the backlog buffer to be freed. # # A value of 0 means to never release the backlog. # # repl-backlog-ttl 3600   # The slave priority is an integer number published by Redis in the INFO output. # It is used by Redis Sentinel in order to select a slave to promote into a # master if the master is no longer working correctly. # # A slave with a low priority number is considered better for promotion, so # for instance if there are three slaves with priority 10, 100, 25 Sentinel will # pick the one with priority 10, that is the lowest. # # However a special priority of 0 marks the slave as not able to perform the # role of master, so a slave with priority of 0 will never be selected by # Redis Sentinel for promotion. # # By default the priority is 100. slave-priority 100  # It is possible for a master to stop accepting writes if there are less than # N slaves connected, having a lag less or equal than M seconds. # # The N slaves need to be in "online" state. # # The lag in seconds, that must be <= the specified value, is calculated from # the last ping received from the slave, that is usually sent every second. # # This option does not GUARANTEE that N replicas will accept the write, but # will limit the window of exposure for lost writes in case not enough slaves # are available, to the specified number of seconds. # # For example to require at least 3 slaves with a lag <= 10 seconds use: # # min-slaves-to-write 3 # min-slaves-max-lag 10 # # Setting one or the other to 0 disables the feature. # # By default min-slaves-to-write is set to 0 (feature disabled) and # min-slaves-max-lag is set to 10.   # A Redis master is able to list the address and port of the attached # slaves in different ways. For example the "INFO replication" section # offers this information, which is used, among other tools, by # Redis Sentinel in order to discover slave instances. # Another place where this info is available is in the output of the # "ROLE" command of a masteer. # # The listed IP and address normally reported by a slave is obtained # in the following way: # #   IP: The address is auto detected by checking the peer address #   of the socket used by the slave to connect with the master. # #   Port: The port is communicated by the slave during the replication #   handshake, and is normally the port that the slave is using to #   list for connections. # # However when port forwarding or Network Address Translation (NAT) is # used, the slave may be actually reachable via different IP and port # pairs. The following two options can be used by a slave in order to # report to its master a specific set of IP and port, so that both INFO # and ROLE will report those values. # # There is no need to use both the options if you need to override just # the port or the IP address. # # slave-announce-ip 5.5.5.5 # slave-announce-port 1234   ################################## SECURITY ###################################   # Require clients to issue AUTH <PASSWORD> before processing any other # commands.  This might be useful in environments in which you do not trust # others with access to the host running redis-server. # # This should stay commented out for backward compatibility and because most # people do not need auth (e.g. they run their own servers). # # Warning: since Redis is pretty fast an outside user can try up to # 150k passwords per second against a good box. This means that you should # use a very strong password otherwise it will be very easy to break. # # requirepass foobared   # Command renaming. # # It is possible to change the name of dangerous commands in a shared # environment. For instance the CONFIG command may be renamed into something # hard to guess so that it will still be available for internal-use tools # but not available for general clients. # # Example: # # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52 # # It is also possible to completely kill a command by renaming it into # an empty string: # # rename-command CONFIG "" # # Please note that changing the name of commands that are logged into the # AOF file or transmitted to slaves may cause problems.   ################################### LIMITS ####################################   # Set the max number of connected clients at the same time. By default # this limit is set to 10000 clients, however if the Redis server is not # able to configure the process file limit to allow for the specified limit # the max number of allowed clients is set to the current file limit # minus 32 (as Redis reserves a few file descriptors for internal uses). # # Once the limit is reached Redis will close all the new connections sending # an error 'max number of clients reached'. # # maxclients 10000   # Don't use more memory than the specified amount of bytes. # When the memory limit is reached Redis will try to remove keys # according to the eviction policy selected (see maxmemory-policy). # # If Redis can't remove keys according to the policy, or if the policy is # set to 'noeviction', Redis will start to reply with errors to commands # that would use more memory, like SET, LPUSH, and so on, and will continue # to reply to read-only commands like GET. # # This option is usually useful when using Redis as an LRU cache, or to set # a hard memory limit for an instance (using the 'noeviction' policy). # # WARNING: If you have slaves attached to an instance with maxmemory on, # the size of the output buffers needed to feed the slaves are subtracted # from the used memory count, so that network problems / resyncs will # not trigger a loop where keys are evicted, and in turn the output # buffer of slaves is full with DELs of keys evicted triggering the deletion # of more keys, and so forth until the database is completely emptied. # # In short... if you have slaves attached it is suggested that you set a lower # limit for maxmemory so that there is some free RAM on the system for slave # output buffers (but this is not needed if the policy is 'noeviction'). # # maxmemory <bytes>   # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory # is reached. You can select among five behaviors: # # volatile-lru -> remove the key with an expire set using an LRU algorithm # allkeys-lru -> remove any key according to the LRU algorithm # volatile-random -> remove a random key with an expire set # allkeys-random -> remove a random key, any key # volatile-ttl -> remove the key with the nearest expire time (minor TTL) # noeviction -> don't expire at all, just return an error on write operations # # Note: with any of the above policies, Redis will return an error on write #       operations, when there are no suitable keys for eviction. # #       At the date of writing these commands are: set setnx setex append #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby #       getset mset msetnx exec sort # # The default is: # # maxmemory-policy noeviction   # LRU and minimal TTL algorithms are not precise algorithms but approximated # algorithms (in order to save memory), so you can tune it for speed or # accuracy. For default Redis will check five keys and pick the one that was # used less recently, you can change the sample size using the following # configuration directive. # # The default of 5 produces good enough results. 10 Approximates very closely # true LRU but costs a bit more CPU. 3 is very fast but not very accurate. # # maxmemory-samples 5   ############################## APPEND ONLY MODE ###############################   # By default Redis asynchronously dumps the dataset on disk. This mode is # good enough in many applications, but an issue with the Redis process or # a power outage may result into a few minutes of writes lost (depending on # the configured save points). # # The Append Only File is an alternative persistence mode that provides # much better durability. For instance using the default data fsync policy # (see later in the config file) Redis can lose just one second of writes in a # dramatic event like a server power outage, or a single write if something # wrong with the Redis process itself happens, but the operating system is # still running correctly. # # AOF and RDB persistence can be enabled at the same time without problems. # If the AOF is enabled on startup Redis will load the AOF, that is the file # with the better durability guarantees. # # Please check http://redis.io/topics/persistence for more information.   appendonly no   # The name of the append only file (default: "appendonly.aof")   appendfilename "appendonly.aof"   # The fsync() call tells the Operating System to actually write data on disk # instead of waiting for more data in the output buffer. Some OS will really flush # data on disk, some other OS will just try to do it ASAP. # # Redis supports three different modes: # # no: don't fsync, just let the OS flush the data when it wants. Faster. # always: fsync after every write to the append only log. Slow, Safest. # everysec: fsync only one time every second. Compromise. # # The default is "everysec", as that's usually the right compromise between # speed and data safety. It's up to you to understand if you can relax this to # "no" that will let the operating system flush the output buffer when # it wants, for better performances (but if you can live with the idea of # some data loss consider the default persistence mode that's snapshotting), # or on the contrary, use "always" that's very slow but a bit safer than # everysec. # # More details please check the following article: # http://antirez.com/post/redis-persistence-demystified.html # # If unsure, use "everysec".   # appendfsync always appendfsync everysec # appendfsync no   # When the AOF fsync policy is set to always or everysec, and a background # saving process (a background save or AOF log background rewriting) is # performing a lot of I/O against the disk, in some Linux configurations # Redis may block too long on the fsync() call. Note that there is no fix for # this currently, as even performing fsync in a different thread will block # our synchronous write(2) call. # # In order to mitigate this problem it's possible to use the following option # that will prevent fsync() from being called in the main process while a # BGSAVE or BGREWRITEAOF is in progress. # # This means that while another child is saving, the durability of Redis is # the same as "appendfsync none". In practical terms, this means that it is # possible to lose up to 30 seconds of log in the worst scenario (with the # default Linux settings). # # If you have latency problems turn this to "yes". Otherwise leave it as # "no" that is the safest pick from the point of view of durability.   no-appendfsync-on-rewrite no   # Automatic rewrite of the append only file. # Redis is able to automatically rewrite the log file implicitly calling # BGREWRITEAOF when the AOF log size grows by the specified percentage. # # This is how it works: Redis remembers the size of the AOF file after the # latest rewrite (if no rewrite has happened since the restart, the size of # the AOF at startup is used). # # This base size is compared to the current size. If the current size is # bigger than the specified percentage, the rewrite is triggered. Also # you need to specify a minimal size for the AOF file to be rewritten, this # is useful to avoid rewriting the AOF file even if the percentage increase # is reached but it is still pretty small. # # Specify a percentage of zero in order to disable the automatic AOF # rewrite feature.   auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb  # An AOF file may be found to be truncated at the end during the Redis # startup process, when the AOF data gets loaded back into memory. # This may happen when the system where Redis is running # crashes, especially when an ext4 filesystem is mounted without the # data=ordered option (however this can't happen when Redis itself # crashes or aborts but the operating system still works correctly). # # Redis can either exit with an error when this happens, or load as much # data as possible (the default now) and start if the AOF file is found # to be truncated at the end. The following option controls this behavior. # # If aof-load-truncated is set to yes, a truncated AOF file is loaded and # the Redis server starts emitting a log to inform the user of the event. # Otherwise if the option is set to no, the server aborts with an error # and refuses to start. When the option is set to no, the user requires # to fix the AOF file using the "redis-check-aof" utility before to restart # the server. # # Note that if the AOF file will be found to be corrupted in the middle # the server will still exit with an error. This option only applies when # Redis will try to read more data from the AOF file but not enough bytes # will be found. aof-load-truncated yes   ################################ LUA SCRIPTING  ###############################   # Max execution time of a Lua script in milliseconds. # # If the maximum execution time is reached Redis will log that a script is # still in execution after the maximum allowed time and will start to # reply to queries with an error. # # When a long running script exceeds the maximum execution time only the # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be # used to stop a script that did not yet called write commands. The second # is the only way to shut down the server in the case a write command was # already issued by the script but the user doesn't want to wait for the natural # termination of the script. # # Set it to 0 or a negative value for unlimited execution without warnings. lua-time-limit 5000   ################################ REDIS CLUSTER  ############################### # # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however # in order to mark it as "mature" we need to wait for a non trivial percentage # of users to deploy it in production. # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # # Normal Redis instances can't be part of a Redis Cluster; only nodes that are # started as cluster nodes can. In order to start a Redis instance as a # cluster node enable the cluster support uncommenting the following: # # cluster-enabled yes   # Every cluster node has a cluster configuration file. This file is not # intended to be edited by hand. It is created and updated by Redis nodes. # Every Redis Cluster node requires a different cluster configuration file. # Make sure that instances running in the same system do not have # overlapping cluster configuration file names. # # cluster-config-file nodes-6379.conf   # Cluster node timeout is the amount of milliseconds a node must be unreachable # for it to be considered in failure state. # Most other internal time limits are multiple of the node timeout. # # cluster-node-timeout 15000   # A slave of a failing master will avoid to start a failover if its data # looks too old. # # There is no simple way for a slave to actually have a exact measure of # its "data age", so the following two checks are performed: # # 1) If there are multiple slaves able to failover, they exchange messages #    in order to try to give an advantage to the slave with the best #    replication offset (more data from the master processed). #    Slaves will try to get their rank by offset, and apply to the start #    of the failover a delay proportional to their rank. # # 2) Every single slave computes the time of the last interaction with #    its master. This can be the last ping or command received (if the master #    is still in the "connected" state), or the time that elapsed since the #    disconnection with the master (if the replication link is currently down). #    If the last interaction is too old, the slave will not try to failover #    at all. # # The point "2" can be tuned by user. Specifically a slave will not perform # the failover if, since the last interaction with the master, the time # elapsed is greater than: # #   (node-timeout * slave-validity-factor) + repl-ping-slave-period # # So for example if node-timeout is 30 seconds, and the slave-validity-factor # is 10, and assuming a default repl-ping-slave-period of 10 seconds, the # slave will not try to failover if it was not able to talk with the master # for longer than 310 seconds. # # A large slave-validity-factor may allow slaves with too old data to failover # a master, while a too small value may prevent the cluster from being able to # elect a slave at all. # # For maximum availability, it is possible to set the slave-validity-factor # to a value of 0, which means, that slaves will always try to failover the # master regardless of the last time they interacted with the master. # (However they'll always try to apply a delay proportional to their # offset rank). # # Zero is the only value able to guarantee that when all the partitions heal # the cluster will always be able to continue. # # cluster-slave-validity-factor 10   # Cluster slaves are able to migrate to orphaned masters, that are masters # that are left without working slaves. This improves the cluster ability # to resist to failures as otherwise an orphaned master can't be failed over # in case of failure if it has no working slaves. # # Slaves migrate to orphaned masters only if there are still at least a # given number of other working slaves for their old master. This number # is the "migration barrier". A migration barrier of 1 means that a slave # will migrate only if there is at least 1 other working slave for its master # and so forth. It usually reflects the number of slaves you want for every # master in your cluster. # # Default is 1 (slaves migrate only if their masters remain with at least # one slave). To disable migration just set it to a very large value. # A value of 0 can be set but is useful only for debugging and dangerous # in production. # # cluster-migration-barrier 1   # By default Redis Cluster nodes stop accepting queries if they detect there # is at least an hash slot uncovered (no available node is serving it). # This way if the cluster is partially down (for example a range of hash slots # are no longer covered) all the cluster becomes, eventually, unavailable. # It automatically returns available as soon as all the slots are covered again. # # However sometimes you want the subset of the cluster which is working, # to continue to accept queries for the part of the key space that is still # covered. In order to do so, just set the cluster-require-full-coverage # option to no. # # cluster-require-full-coverage yes   # In order to setup your cluster make sure to read the documentation # available at http://redis.io web site.   ################################## SLOW LOG ###################################   # The Redis Slow Log is a system to log queries that exceeded a specified # execution time. The execution time does not include the I/O operations # like talking with the client, sending the reply and so forth, # but just the time needed to actually execute the command (this is the only # stage of command execution where the thread is blocked and can not serve # other requests in the meantime). # # You can configure the slow log with two parameters: one tells Redis # what is the execution time, in microseconds, to exceed in order for the # command to get logged, and the other parameter is the length of the # slow log. When a new command is logged the oldest one is removed from the # queue of logged commands.   # The following time is expressed in microseconds, so 1000000 is equivalent # to one second. Note that a negative number disables the slow log, while # a value of zero forces the logging of every command. slowlog-log-slower-than 10000   # There is no limit to this length. Just be aware that it will consume memory. # You can reclaim memory used by the slow log with SLOWLOG RESET. slowlog-max-len 128   ################################ LATENCY MONITOR ##############################   # The Redis latency monitoring subsystem samples different operations # at runtime in order to collect data related to possible sources of # latency of a Redis instance. # # Via the LATENCY command this information is available to the user that can # print graphs and obtain reports. # # The system only logs operations that were performed in a time equal or # greater than the amount of milliseconds specified via the # latency-monitor-threshold configuration directive. When its value is set # to zero, the latency monitor is turned off. # # By default latency monitoring is disabled since it is mostly not needed # if you don't have latency issues, and collecting data has a performance # impact, that while very small, can be measured under big load. Latency # monitoring can easily be enabled at runtime using the command # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed. latency-monitor-threshold 0   ############################# EVENT NOTIFICATION ##############################   # Redis can notify Pub/Sub clients about events happening in the key space. # This feature is documented at http://redis.io/topics/notifications # # For instance if keyspace events notification is enabled, and a client # performs a DEL operation on key "foo" stored in the Database 0, two # messages will be published via Pub/Sub: # # PUBLISH __keyspace@0__:foo del # PUBLISH __keyevent@0__:del foo # # It is possible to select the events that Redis will notify among a set # of classes. Every class is identified by a single character: # #  K     Keyspace events, published with __keyspace@<db>__ prefix. #  E     Keyevent events, published with __keyevent@<db>__ prefix. #  g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ... #  $     String commands #  l     List commands #  s     Set commands #  h     Hash commands #  z     Sorted set commands #  x     Expired events (events generated every time a key expires) #  e     Evicted events (events generated when a key is evicted for maxmemory) #  A     Alias for g$lshzxe, so that the "AKE" string means all the events. # #  The "notify-keyspace-events" takes as argument a string that is composed #  of zero or multiple characters. The empty string means that notifications #  are disabled. # #  Example: to enable list and generic events, from the point of view of the #           event name, use: # #  notify-keyspace-events Elg # #  Example 2: to get the stream of the expired keys subscribing to channel #             name __keyevent@0__:expired use: # #  notify-keyspace-events Ex # #  By default all notifications are disabled because most users don't need #  this feature and the feature has some overhead. Note that if you don't #  specify at least one of K or E, no events will be delivered. notify-keyspace-events ""   ############################### ADVANCED CONFIG ###############################   # Hashes are encoded using a memory efficient data structure when they have a # small number of entries, and the biggest entry does not exceed a given # threshold. These thresholds can be configured using the following directives. hash-max-ziplist-entries 512 hash-max-ziplist-value 64   # Lists are also encoded in a special way to save a lot of space. # The number of entries allowed per internal list node can be specified # as a fixed maximum size or a maximum number of elements. # For a fixed maximum size, use -5 through -1, meaning: # -5: max size: 64 Kb  <-- not recommended for normal workloads # -4: max size: 32 Kb  <-- not recommended # -3: max size: 16 Kb  <-- probably not recommended # -2: max size: 8 Kb   <-- good # -1: max size: 4 Kb   <-- good # Positive numbers mean store up to _exactly_ that number of elements # per list node. # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size), # but if your use case is unique, adjust the settings as necessary. list-max-ziplist-size -2   # Lists may also be compressed. # Compress depth is the number of quicklist ziplist nodes from *each* side of # the list to *exclude* from compression.  The head and tail of the list # are always uncompressed for fast push/pop operations.  Settings are: # 0: disable all list compression # 1: depth 1 means "don't start compressing until after 1 node into the list, #    going from either the head or tail" #    So: [head]->node->node->...->node->[tail] #    [head], [tail] will always be uncompressed; inner nodes will compress. # 2: [head]->[next]->node->node->...->node->[prev]->[tail] #    2 here means: don't compress head or head->next or tail->prev or tail, #    but compress all nodes between them. # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail] # etc. list-compress-depth 0   # Sets have a special encoding in just one case: when a set is composed # of just strings that happen to be integers in radix 10 in the range # of 64 bit signed integers. # The following configuration setting sets the limit in the size of the # set in order to use this special memory saving encoding. set-max-intset-entries 512   # Similarly to hashes and lists, sorted sets are also specially encoded in # order to save a lot of space. This encoding is only used when the length and # elements of a sorted set are below the following limits: zset-max-ziplist-entries 128 zset-max-ziplist-value 64  # HyperLogLog sparse representation bytes limit. The limit includes the # 16 bytes header. When an HyperLogLog using the sparse representation crosses # this limit, it is converted into the dense representation. # # A value greater than 16000 is totally useless, since at that point the # dense representation is more memory efficient. # # The suggested value is ~ 3000 in order to have the benefits of # the space efficient encoding without slowing down too much PFADD, # which is O(N) with the sparse encoding. The value can be raised to # ~ 10000 when CPU is not a concern, but space is, and the data set is # composed of many HyperLogLogs with cardinality in the 0 - 15000 range. hll-sparse-max-bytes 3000   # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in # order to help rehashing the main Redis hash table (the one mapping top-level # keys to values). The hash table implementation Redis uses (see dict.c) # performs a lazy rehashing: the more operation you run into a hash table # that is rehashing, the more rehashing "steps" are performed, so if the # server is idle the rehashing is never complete and some more memory is used # by the hash table. # # The default is to use this millisecond 10 times every second in order to # actively rehash the main dictionaries, freeing memory when possible. # # If unsure: # use "activerehashing no" if you have hard latency requirements and it is # not a good thing in your environment that Redis can reply from time to time # to queries with 2 milliseconds delay. # # use "activerehashing yes" if you don't have such hard requirements but # want to free memory asap when possible. activerehashing yes # The client output buffer limits can be used to force disconnection of clients # that are not reading data from the server fast enough for some reason (a # common reason is that a Pub/Sub client can't consume messages as fast as the # publisher can produce them). # # The limit can be set differently for the three different classes of clients: # # normal -> normal clients including MONITOR clients # slave  -> slave clients # pubsub -> clients subscribed to at least one pubsub channel or pattern # # The syntax of every client-output-buffer-limit directive is the following: # # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds> # # A client is immediately disconnected once the hard limit is reached, or if # the soft limit is reached and remains reached for the specified number of # seconds (continuously). # So for instance if the hard limit is 32 megabytes and the soft limit is # 16 megabytes / 10 seconds, the client will get disconnected immediately # if the size of the output buffers reach 32 megabytes, but will also get # disconnected if the client reaches 16 megabytes and continuously overcomes # the limit for 10 seconds. # # By default normal clients are not limited because they don't receive data # without asking (in a push way), but just after a request, so only # asynchronous clients may create a scenario where data is requested faster # than it can read. # # Instead there is a default limit for pubsub and slave clients, since # subscribers and slaves receive data in a push fashion. # # Both the hard or the soft limit can be disabled by setting them to zero. client-output-buffer-limit normal 0 0 0 client-output-buffer-limit slave 256mb 64mb 60 client-output-buffer-limit pubsub 32mb 8mb 60 # Redis calls an internal function to perform many background tasks, like # closing connections of clients in timeout, purging expired keys that are # never requested, and so forth. # # Not all tasks are performed with the same frequency, but Redis checks for # tasks to perform according to the specified "hz" value. # # By default "hz" is set to 10. Raising the value will use more CPU when # Redis is idle, but at the same time will make Redis more responsive when # there are many keys expiring at the same time, and timeouts may be # handled with more precision. # # The range is between 1 and 500, however a value over 100 is usually not # a good idea. Most users should use the default of 10 and raise this up to # 100 only in environments where very low latency is required. hz 10 # When a child rewrites the AOF file, if the following option is enabled # the file will be fsync-ed every 32 MB of data generated. This is useful # in order to commit the file to the disk more incrementally and avoid # big latency spikes. aof-rewrite-incremental-fsync yes

测试redis-cli连接上来

docker exec -it 运行着Rediis服务的容器ID redis-cli

测试持久化文件生成

本地镜像发布到阿里云

本地镜像发布到阿里云流程

镜像的生成方法

前面的DockerFile

从容器创建一个新的镜像

docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]] # OPTIONS说明： # -a :提交的镜像作者； # -m :提交时的说明文字；

本地镜像推送到阿里云

本地镜像素材原型

阿里云开发者平台

https://dev.aliyun.com/search.html

创建仓库镜像

将镜像推送到registry
公有云可以查询到
查看详情

将阿里云上的镜像下载到本地

下载到本地

Docker-容器数据卷与DockerFile解析（三）

Sun, 16 May 2021 10:27:00 GMT

Docker容器数据卷

是什么？

先来看看Docker的理念：

将运用与运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求希望是持久化的
容器之间希望有可能共享数据

Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了。

为了能保存数据在docker中我们使用卷。

一句话：有点类似我们Redis里面的rdb和aof文件

能干嘛？

卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷

特点：

数据卷可在容器之间共享或重用数据
卷中的更改可以直接生效
数据卷中的更改不会包含在镜像的更新中
数据卷的生命周期一直持续到没有容器使用它为止

容器的持久化

容器间继承+共享数据

数据卷

容器内直接命令添加

命令

docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名 /bin/bash

查看数据卷是否挂载成功

docker inspect 容器ID

容器和宿主机之间数据共享

容器停止退出后，主机修改后数据是否同步

docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名

DockerFile添加

根目录下新建mydocker文件夹并进入
可在Dockerfile中使用VOLUME指令来给镜像添加一个或多个数据卷

VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]

说明：

出于可移植和分享的考虑，用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。

由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。

File构建

[root@maruifu mydocker]# pwd /mydocker [root@maruifu mydocker]# cat dockerfile2 # volume test FROM centos VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"] CMD echo "finished,--------success1" CMD /bin/bash

build后生成镜像

获得一个新镜像zzyy/centos

run容器
对应的主机目录地址

主机对应默认地址

Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied

解决办法：在挂载目录后多加一个--privileged=true参数即可

数据卷容器

是什么？

命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器

总体介绍

以上一步新建的镜像zzyy/centos为模板并运行容器dc01/dc02/dc03

它们已经具有容器卷 /dataVolumeContainer1 和 /dataVolumeContainer2

容器间传递共享

先启动一个父容器dc01

在dataVolumeContainer2新增内容
dc02/dc03继承自dc01

--volumes-from

docker run -it --name dc02 --volumes-from dc01 zzyy/centos
dc02/dc03分别在dataVolumeContainer2各自新增内容
回到dc01可以看到02/03各自添加的都能共享了
删除dc01，dc02修改后dc03可否访问
新建dc04继承dc03后再删除dc03

结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

DockerFile解析

是什么？

Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

构建三步骤

编写Dockerfile文件 ->docker build->docker run

样例：以我们熟悉的CentOS为例

DockerFile构建过程解析

Dockerfile内容基础知识

1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2：指令按照从上到下，顺序执行

3：#表示注释

4：每条指令都会创建一个新的镜像层，并对镜像进行提交

Docker执行Dockerfile的大致流程

（1）docker从基础镜像运行一个容器

（2）执行一条指令并对容器作出修改

（3）执行类似docker commit的操作提交一个新的镜像层

（4）docker再基于刚提交的镜像运行一个新容器

（5）执行dockerfile中的下一条指令直到所有指令都执行完成

总结

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

* Dockerfile是软件的原材料

* Docker镜像是软件的交付品

* Docker容器则可以认为是软件的运行态。

Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;

Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;

Docker容器，容器是直接提供服务的。

DockerFile体系结构(保留字指令）

FROM       #基础镜像，当前新镜像是基于哪个镜像的 MAINTAINER #镜像维护者的姓名和邮箱地址 RUN        #容器构建时需要运行的命令 EXPOSE     #容器构建时需要运行的命令 WOEKDIR    #指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点 ENV        #用来在构建镜像过程中设置环境变量             #ENV MY_PATH /usr/mytest             #这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；             #也可以在其它指令中直接使用这些环境变量，             #比如：WORKDIR $MY_PATH ADD        #将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包 COPY       #类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置       #COPY src dest       #COPY ["src", "dest"] VOLUME     #容器数据卷，用于数据保存和持久化工作    CMD        #指定一个容器启动时要运行的命令       #CMD指令的格式和RUN相似，也是两种格式       #shell格式：CMD<命令>       #exec格式：CMD["可执行文件","参数1","参数2"...]       #参数列表格式：CMD["参数1","参数2"...]。在指定了ENTRYPOINT指令后，用CMD指定具体的参数。  ENTRYPOINT #指定一个容器启动时要运行的命令  ，ENTRYPOINT的目的和 CMD 一样都是在指定容器启动程序及参数        ONBUILD    # 当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

总结：

案例

Base镜像(scratch)

Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的

自定义镜像mycentos

编写

1.Hub默认CentOS镜像什么情况

自定义mycentos目的使我们自己的镜像具备如下：

登陆后的默认路径
vim编辑器
查看网络配置ifconfig支持

2.准备编写DockerFile文件

3.myCentOS内容DockerFile

FROM centos MAINTAINER zzyy<zzyy167@126.com>  ENV MYPATH /usr/local WORKDIR $MYPATH  RUN yum -y install vim RUN yum -y install net-tools  EXPOSE 80  CMD echo $MYPATH CMD echo "success--------------ok" CMD /bin/bash

构建

docker build -t 新镜像名字:TAG .

会看到 docker build 命令最后有一个 .

. 表示当前目录

运行

docker run -it 新镜像名字 :TAG

可以看到，我们自己的新镜像已经支持vim/ifconfig命令，扩展成功了。

变更历史

docker history 镜像名

CMD/ENTRYPOINT 镜像

都是指定一个容器启动时要运行的命令

CMD:Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

ENTRYPOINT:docker run 之后的参数会被当做参数传递给 ENTRYPOINT，之后形成新的命令组合

自定义镜像Tomcat9

mkdir -p /maruifu/mydockerfile/tomcat9
在上述目录下touch c.txt

将jdk和tomcat安装的压缩包拷贝进上一步目录

cp apache-tomcat-9.0.8.tar.gz /maruifu/mydockerfile/tomcat9 cp jdk-8u171-linux-x64.tar.gz /maruifu/mydockerfile/tomcat9

在/maruifu/mydockerfile/tomcat9目录下新建Dockerfile文件

FROM         centos MAINTAINER    zzyy<zzyybs@126.com> #把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下 COPY c.txt /usr/local/cincontainer.txt #把java与tomcat添加到容器中 ADD jdk-8u171-linux-x64.tar.gz /usr/local/ ADD apache-tomcat-9.0.8.tar.gz /usr/local/ #安装vim编辑器 RUN yum -y install vim #设置工作访问时候的WORKDIR路径，登录落脚点 ENV MYPATH /usr/local WORKDIR $MYPATH #配置java与tomcat环境变量 ENV JAVA_HOME /usr/local/jdk1.8.0_171 ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8 ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8 ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin #容器运行时监听的端口 EXPOSE  8080 #启动时运行tomcat # ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ] # CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"] CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out

构建

构建完成：docker image

run

docker run -d -p 9080:8080 --name myt9 -v /zzyyuse/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test -v /zzyyuse/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.8/logs --privileged=true zzyytomcat9

Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied

解决办法：在挂载目录后多加一个--privileged=true参数即可

验证

结合前述的容器卷将测试的web服务test发布

总体概述

web.xml

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   xmlns="http://java.sun.com/xml/ns/javaee"   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"   id="WebApp_ID" version="2.5">   <display-name>test</display-name> </web-app>

a.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html>   <head>     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">     <title>Insert title here</title>   </head>   <body>     -----------welcome------------     <%="i am in docker tomcat self "%>     <br>     <br>     <% System.out.println("=============docker tomcat self");%>   </body> </html>

测试

总结

Docker-命令与镜像（二）

Sun, 16 May 2021 09:07:00 GMT

Docker常用命令

帮助命令

docker version docker info docker --help

镜像命令

列出本地主机上的镜像

docker images #各个选项说明: #    - REPOSITORY：表示镜像的仓库源 #    - TAG：镜像的标签 #    - IMAGE ID：镜像ID #    - CREATED：镜像创建时间 #    - SIZE：镜像大小 #同一仓库源可以有多个 TAG，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。 #如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像  #OPTIONS说明 #   - -a :列出本地所有的镜像（含中间映像层） #   - -q :只显示镜像ID。 #   - --digests :显示镜像的摘要信息 #   - --no-trunc :显示完整的镜像信息

docker search 某个XXX镜像名字

#地址：https://hub.docker.com docker search [OPTIONS] 镜像名字 # OPTIONS说明： #    --no-trunc : 显示完整的镜像描述 #    -s : 列出收藏数不小于指定值的镜像。 #    --automated : 只列出 automated build类型的镜像；

docker pull 某个XXX镜像名字

#下载镜像 docker pull 镜像名字 [:TAG]

docker rmi 某个XXX镜像名字ID

#删除单个 docker rmi  -f 镜像ID #删除多个 docker rmi -f 镜像名1:TAG 镜像名2:TAG #删除全部 docker rmi -f $(docker images -qa)

容器命令

有镜像才能创建容器，这是根本前提(下载一个CentOS镜像演示)

docker pull centos

新建并启动容器

docker run [OPTIONS] IMAGE [COMMAND][ARG...]  # OPTIONS说明（常用）：有些是一个减号，有些是两个减号 #--name="容器新名字": 为容器指定一个名称； #-d: 后台运行容器，并返回容器ID，也即启动守护式容器； #-i：以交互模式运行容器，通常与 -t 同时使用； #-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用； #-P: 随机端口映射； #-p: 指定端口映射，有以下四种格式 #      ip:hostPort:containerPort #      ip::containerPort #      hostPort:containerPort #      containerPort  #使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。 docker run -it centos /bin/bash

列出当前所有正在运行的容器

docker ps [OPTIONS] # OPTIONS说明（常用）： #  -a :列出当前所有正在运行的容器+历史上运行过的 #  -l :显示最近创建的容器。 #  -n：显示最近n个创建的容器。 #  -q :静默模式，只显示容器编号。 #  --no-trunc :不截断输出。

退出容器

#两种退出方式 #容器停止退出 exit #容器不停止退出 ctrl+P+Q

启动容器

docker start 容器ID或者容器名

重启容器

docker restart 容器ID或者容器名

停止容器

docker stop 容器ID或者容器名

强制停止容器

docker kill 容器ID或者容器名

删除已停止容器

# 删除单个容器 docker rm 容器ID #一次删除多个容器 docker rm -f $(docker ps -a -q) docker ps -a -q | xargs docker rm

重要

启动守护式容器
```
#启动守护式容器 docker run -d 容器名 
```
使用镜像centos:latest以后台模式启动一个容器docker run -d centos

问题：然后docker ps -a 进行查看, 会发现容器已经退出很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程.容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的。

这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下,我们配置启动服务只需要启动响应的service即可。例如service nginx start但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.所以，最佳的解决方案是,将你要运行的程序以前台进程的形式运行

查看容器日志

docker logs -f -t --tail 容器ID  docker run -d centos /bin/sh -c "while true;do echo hello zzyy;sleep 2;done" #   -t 是加入时间戳 #   -f 跟随最新的日志打印 #   --tail 数字 显示最后多少条

查看容器内运行的进程
```
docker top 容器ID 
```
查看容器内部细节
```
docker inspect 容器ID 
```

进入正在运行的容器并以命令行交互

#直接进入 docker exec -it 容器ID bash #重新进入 docker attach 容器ID #区别 exec是在容器中打开新的终端，并且可以启动新的进程 attach直接进入容器启动命令的终端，不会启动新的进程

从容器内拷贝文件到主机上

docker cp  容器ID:容器内路径 目的主机路径

总结

attach    Attach to a running container                 # 当前 shell 下 attach 连接指定运行镜像 build     Build an image from a Dockerfile              # 通过 Dockerfile 定制镜像 commit    Create a new image from a container changes   # 提交当前容器为新的镜像 cp        Copy files/folders from the containers filesystem to the host path   #从容器中拷贝指定文件或者目录到宿主机中 create    Create a new container                        # 创建一个新的容器，同 run，但不启动容器 diff      Inspect changes on a container's filesystem   # 查看 docker 容器变化 events    Get real time events from the server          # 从 docker 服务获取容器实时事件 exec      Run a command in an existing container        # 在已存在的容器上运行命令 export    Stream the contents of a container as a tar archive   # 导出容器的内容流作为一个 tar 归档文件[对应 import ] history   Show the history of an image                  # 展示一个镜像形成历史 images    List images                                   # 列出系统当前镜像 import    Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export] info      Display system-wide information               # 显示系统相关信息 inspect   Return low-level information on a container   # 查看容器详细信息 kill      Kill a running container                      # kill 指定 docker 容器 load      Load an image from a tar archive              # 从一个 tar 包中加载一个镜像[对应 save] login     Register or Login to the docker registry server    # 注册或者登陆一个 docker 源服务器 logout    Log out from a Docker registry server          # 从当前 Docker registry 退出 logs      Fetch the logs of a container                 # 输出当前容器日志信息 port      Lookup the public-facing port which is NAT-ed to PRIVATE_PORT    # 查看映射端口对应的容器内部源端口 pause     Pause all processes within a container        # 暂停容器 ps        List containers                               # 列出容器列表 pull      Pull an image or a repository from the docker registry server   # 从docker镜像源服务器拉取指定镜像或者库镜像 push      Push an image or a repository to the docker registry server    # 推送指定镜像或者库镜像至docker源服务器 restart   Restart a running container                   # 重启运行的容器 rm        Remove one or more containers                 # 移除一个或者多个容器 rmi       Remove one or more images             # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除] run       Run a command in a new container              # 创建一个新的容器并运行一个命令 save      Save an image to a tar archive                # 保存一个镜像为一个 tar 包[对应 load] search    Search for an image on the Docker Hub         # 在 docker hub 中搜索镜像 start     Start a stopped containers                    # 启动容器 stop      Stop a running containers                     # 停止容器 tag       Tag an image into a repository                # 给源中镜像打标签 top       Lookup the running processes of a container   # 查看容器中运行的进程信息 unpause   Unpause a paused container                    # 取消暂停容器 version   Show the docker version information           # 查看 docker 版本号 wait      Block until a container stops, then print its exit code   # 截取容器停止时的退出状态值

Docker镜像

是什么？

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

UnionFS（联合文件系统）

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

Docker镜像加载原理

Docker镜像加载原理：docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才200M？？

对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

分层的镜像

以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

Docker 镜像为啥采用分层结构

最大的一个好处就是 - 共享资源

比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

特点

Docker镜像都是只读的
当容器启动时，一个新的可写层被加载到镜像的顶部。
这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

Docker镜像commit操作补充

docker commit提交容器副本使之成为一个新的镜像  docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

案例演示

从Hub上下载tomcat镜像到本地并成功运行

docker run -it -p 8080:8080 tomcat #  -p 主机端口:docker容器端口 #  -P 随机分配端口 #  i:交互 #  t:终端

故意删除上一步镜像生产tomcat容器的文档
也即当前的tomcat运行实例是一个没有文档内容的容器，以它为模板commit一个没有doc的tomcat新镜像atguigu/tomcat02
启动我们的新镜像并和原来的对比

启动atguigu/tomcat02，它没有docs

新启动原来的tomcat，它有docs

Docker-简介与安装（一）

Sun, 16 May 2021 08:23:00 GMT

Docker简介

是什么？

为什么会有docker？

一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验

Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案。

环境配置如此麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。

之前在服务器配置一个应用的运行环境，要安装各种软件，就拿尚硅谷电商项目的环境来说吧，Java/Tomcat/MySQL/JDBC驱动包等。安装和配置这些东西有多麻烦就不说了，它还不能跨平台。假如我们是在 Windows 上安装的这些环境，到了 Linux 又得重新装。况且就算不跨操作系统，换另一台同样操作系统的服务器，要移植应用也是非常麻烦的。

传统上认为，软件编码开发/测试结束后，所产出的成果即是程序或是能够编译执行的二进制字节码等(java为例)。而为了让这些程序可以顺利执行，开发团队也得准备完整的部署文件，让维运团队得以部署应用程式，开发需要清楚的告诉运维部署团队，用的全部配置文件+所有软件环境。不过，即便如此，仍然常常发生部署失败的状况。Docker镜像的设计，使得Docker得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。

docker理念？

Docker是基于Go语言实现的云开源项目。

Docker的主要目标是“Build，Ship and Run Any App,Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。

Linux 容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用运行在 Docker 容器上面，而 Docker 容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作

一句话解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

能干嘛？

之前的虚拟机技术

虚拟机（virtual machine）就是带环境安装的一种解决方案。

它可以在一种操作系统里面运行另一种操作系统，比如在Windows 系统里面运行Linux 系统。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。这类虚拟机完美的运行了另一套系统，能够使应用程序，操作系统和硬件三者之间的逻辑不变。

虚拟机的缺点：

资源占用多
冗余步骤多
启动慢

容器虚拟化技术

由于前面虚拟机存在这些缺点，Linux 发展出了另一种虚拟化技术：Linux 容器（Linux Containers，缩写为 LXC）。

Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一的运行

比较了 Docker 和传统虚拟化方式的不同之处：

传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
每个容器之间互相隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源。

开发/运维(DevOps)

一次构建，随处运行

更快速的应用交付和部署

传统的应用开发完成后，需要提供一堆安装程序和配置说明文档，安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置在镜像里已经内置好，大大节省部署配置和测试验证时间。

更便捷的升级和扩缩容

随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块“积木”，应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用系统的扩容从原先的天级变成分钟级甚至秒级。

更简单的系统运维

应用容器化运行后，生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。

更高效的计算资源利用

　Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。

企业级

新浪

美团

蘑菇街

去那下？

官网

docker官网：http://www.docker.com docker中文网站：https://www.docker-cn.com/

仓库

Docker Hub官网: https://hub.docker.com/

Docker安装

前提说明

CentOS Docker 安装

Docker支持以下的CentOS版本：

CentOS 7 (64-bit)

CentOS 6.5 (64-bit) 或更高的版本

前提条件

目前，CentOS 仅发行版本中的内核支持 Docker。

Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上。

Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本。

查看自己的内核

uname命令用于打印当前系统相关信息（内核版本号、硬件架构、主机名称和操作系统类型等）。

查看已安装的CentOS版本信息（CentOS6.8有，CentOS7无该命令）

Docker的基本组成

镜像(image)

Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。

容器(container)

Docker 利用容器（Container）独立运行的一个或一组应用。容器是用镜像创建的运行实例。

它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。

仓库(repository)

仓库（Repository）是集中存放镜像文件的场所。

仓库(Repository)和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub(https://hub.docker.com/)，

存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就似乎 image镜像文件。只有通过这个镜像文件才能生成 Docker 容器。image 文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

image 文件生成的容器实例，本身也是一个文件，称为镜像文件。

一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器

至于仓储，就是放了一堆镜像的地方，我们可以把镜像发布到仓储中，需要的时候从仓储中拉下来就可以了。

Docker架构图

安装步骤

CentOS6.8安装Docker

yum install -y epel-release Docker使用EPEL发布，RHEL系的OS首先要确保已经持有EPEL仓库，否则先检查OS的版本，然后安装相应的EPEL包。
yum install -y docker-io
安装后的配置文件：/etc/sysconfig/docker
启动Docker后台服务：service docker start
docker version验证

CentOS7安装Docker

官网中文安装参考手册

https://docs.docker-cn.com/engine/installation/linux/docker-ce/centos/#prerequisites

确定你是CentOS7及以上版本

cat /etc/redhat-release

yum安装gcc相关

yum -y install gcc yum -y install gcc-c++

卸载旧版本

yum -y remove docker docker-common docker-selinux docker-engine

2018.3官网版本

yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-selinux docker-engine-selinux docker-engine

安装需要的软件包

yum install -y yum-utils device-mapper-persistent-data lvm2

设置stable镜像仓库

大坑：

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 报错： 1  [Errno 14] curl#35 - TCP connection reset by peer 2  [Errno 12] curl#35 - Timeout

永远的HelloWorld

阿里云镜像加速

登录https://dev.aliyun.com/search.html
注册一个属于自己的阿里云账户(可复用淘宝账号)
获得加速器地址连接（镜像加速器-专属加速器地址）
配置本机Docker运行镜像加速器鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，我们可以需要配置加速器来解决，我使用的是阿里云的本人自己账号的镜像地址(需要自己注册有一个属于你自己的)： https://xxxx.mirror.aliyuncs.com vim /etc/sysconfig/docker 将获得的自己账户下的阿里云加速地址配置进 other_args="--registry-mirror=https://你自己的账号加速信息.mirror.aliyuncs.com"
重新启动Docker后台服务：service docker restart
Linux 系统下配置完加速器需要检查是否生效

如果从结果中看到了配置的--registry-mirror参数说明配置成功，如下所示:

网易云加速

同上述阿里云，只是配置Json串的地方不同了:

vim /etc/docker/daemon.json {  "registry-mirrors": ["http://hub-mirror.c.163.com"] }

启动Docker后台容器

docker run hello-world

输出这段提示以后，hello world就会停止运行，容器自动终止。

run干了什么？

底层原理

Docker是怎么工作的？

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱

为什么Docker比VM快？

(1)docker有着比虚拟机更少的抽象层。由亍docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。

(2)docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。

Rocketmq--消息驱动

Sun, 16 May 2021 04:29:00 GMT

MQ简介

什么是MQ

MQ(Message Queue)是一种跨进程的通信机制，用于传递消息。通俗点说，就是一个先进先出的数

据结构。

MQ的应用场景

异步解耦

最常见的一个场景是用户注册后，需要发送注册邮件和短信通知，以告知用户注册成功。传统的做法如下:

此架构下注册、邮件、短信三个任务全部完成后，才返回注册结果到客户端，用户才能使用账号登录。但是对于用户来说，注册功能实际只需要注册系统存储用户的账户信息后，该用户便可以登录，而后续的注册短信和邮件不是即时需要关注的步骤。

所以实际当数据写入注册系统后，注册系统就可以把其他的操作放入对应的消息队列 MQ 中然后马上返回用户结果，由消息队列 MQ 异步地进行这些操作。架构图如下:

异步解耦是消息队列 MQ 的主要特点，主要目的是减少请求响应时间和解耦。主要的使用场景就是将比较耗时而且不需要即时(同步)返回结果的操作作为消息放入消息队列。同时，由于使用了消息队列 MQ，只要保证消息格式不变，消息的发送方和接收方并不需要彼此联系，也不需要受对方的影响，即解耦合。

流量削峰

流量削峰也是消息队列 MQ 的常用场景，一般在秒杀或团队抢购(高并发)活动中使用广泛。在秒杀或团队抢购活动中，由于用户请求量较大，导致流量暴增，秒杀的应用在处理如此大量的访问流量后，下游的通知系统无法承载海量的调用量，甚至会导致系统崩溃等问题而发生漏通知的情况。为解决这些问题，可在应用和下游通知系统之间加入消息队列 MQ。

秒杀处理流程如下所述:

用户发起海量秒杀请求到秒杀业务处理系统。
秒杀处理系统按照秒杀处理逻辑将满足秒杀条件的请求发送至消息队列 MQ。
下游的通知系统订阅消息队列 MQ 的秒杀相关消息，再将秒杀成功的消息发送到相应用户。
用户收到秒杀成功的通知。

常见的MQ产品

目前业界有很多MQ产品，比较出名的有下面这些:

ZeroMQ

号称最快的消息队列系统，尤其针对大吞吐量的需求场景。扩展性好，开发比较灵活，采用C语言实现，实际上只是一个socket库的重新封装，如果做为消息队列使用，需要开发大量的代码。ZeroMQ仅提供非持久性的队列，也就是说如果down机，数据将会丢失。

RabbitMQ

使用erlang语言开发，性能较好，适合于企业级的开发。但是不利于做二次开发和维护。

ActiveMQ

历史悠久的Apache开源项目。已经在很多产品中得到应用，实现了JMS1.1规范，可以和spring-jms轻松融合，实现了多种协议，支持持久化到数据库，对队列数较多的情况支持不好。

RocketMQ

阿里巴巴的MQ中间件，由java语言开发，性能非常好，能够撑住双十一的大流量，而且使用起来很简单。

Kafka

Kafka是Apache下的一个子项目，是一个高性能跨语言分布式Publish/Subscribe消息队列系统，相对于ActiveMQ是一个非常轻量级的消息系统，除了性能非常好之外，还是一个工作良好的分布式系统。

RocketMQ入门

RocketMQ是阿里巴巴开源的分布式消息中间件，现在是Apache的一个顶级项目。在阿里内部使用非常广泛，已经经过了"双11"这种万亿级的消息流转。

RocketMQ环境搭建

接下来我们先在linux平台下安装一个RocketMQ的服务

环境准备

下载RocketMQ

http://rocketmq.apache.org/release_notes/release-notes-4.4.0/

环境要求

Linux 64位操作系统 64bit

JDK 1.8+

安装RocketMQ

1 上传文件到Linux系统

[root@maruifu rocketmq]# ls /usr/local/src/  rocketmq-all-4.4.0-bin-release.zip

2 解压到安装目录

  [root@maruifu src]# unzip rocketmq-all-4.4.0-bin-release.zip  [root@maruifu src]# mv rocketmq-all-4.4.0-bin-release ../rocketmq

启动RocketMQ

1切换到安装目录

[root@maruifu rocketmq]# ls benchmark bin conf lib LICENSE NOTICE README.md

2 启动NameServer

[root@maruifu rocketmq]# nohup ./bin/mqnamesrv & [1] 1467 # 只要进程不报错,就应该是启动成功了,可以查看一下日志 [root@maruifu rocketmq]# tail -f /root/logs/rocketmqlogs/namesrv.log

3 启动Broker

# 编辑bin/runbroker.sh 和 bin/runserver.sh文件,修改里面的 # JAVA_OPT="${JAVA_OPT} -server -Xms8g -Xmx8g -Xmn4g" # 为JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m"  [root@maruifu rocketmq]# nohup bin/mqbroker -n localhost:9876 &  [root@maruifu rocketmq]# tail -f /root/logs/rocketmqlogs/broker.log

测试RocketMQ

1 测试消息发送

[root@maruifu rocketmq]# export NAMESRV_ADDR=localhost:9876  [root@maruifu rocketmq]# bin/tools.sh  org.apache.rocketmq.example.quickstart.Producer

2 测试消息接收

[root@maruifu rocketmq]# export NAMESRV_ADDR=localhost:9876  [root@maruifu rocketmq]# bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

关闭RocketMQ

[root@maruifu rocketmq]# bin/mqshutdown broker [root@maruifu rocketmq]# bin/mqshutdown namesrv

RocketMQ的架构及概念

如上图所示，整体可以分成4个角色，分别是:NameServer，Broker，Producer，Consumer。

Broker(邮递员):Broker是RocketMQ的核心，负责消息的接收，存储，投递等功能
**NameServer(邮局):**消息队列的协调者，Broker向它注册路由信息，同时Producer和Consumer 向其获取路由信息Producer(寄件人)消息的生产者，需要从NameServer获取Broker信息，然后与 Broker建立连接，向Broker发送消息
Consumer(收件人) :消息的消费者，需要从NameServer获取Broker信息，然后与Broker建立连接，从Broker获取消息
**Topic(地区):**用来区分不同类型的消息，发送和接收消息前都需要先创建Topic，针对Topic来发送和接收消息Message Queue(邮件)为了提高性能和吞吐量，引入了Message Queue，一个Topic可以设置一个或多个Message Queue，这样消息就可以并行往各个Message Queue发送消息，消费者也可以并行的从多个Message Queue读取消息
**Message:**Message 是消息的载体。
Producer Group:生产者组，简单来说就是多个发送同一类消息的生产者称之为一个生产者组。
Consumer Group:消费者组，消费同一类消息的多个 consumer 实例组成一个消费者组。

RocketMQ控制台安装

1 下载

# 在git上下载下面的工程 rocketmq-console-1.0.0  https://github.com/apache/rocketmq-externals/releases

2 修改配置文件

# 修改配置文件 rocketmq-console\src\main\resources\application.properties  #项目启动后的端口号 server.port=7777  #nameserv的地址，注意防火墙要开启 9876端口 rocketmq.config.namesrvAddr=192.168.109.131:9876

3 打成jar包，并启动

# 进入控制台项目，将工程打成jar包 mvn clean package -Dmaven.test.skip=true # 启动控制台 java -jar target/rocketmq-console-ng-1.0.0.jar

4 访问控制台

消息发送和接收演示

接下来我们使用Java代码来演示消息的发送和接收

<dependency>   <groupId>org.apache.rocketmq</groupId>    <artifactId>rocketmq-spring-boot-starter</artifactId>    <version>2.0.2</version> </dependency>

发送消息

消息发送步骤:

创建消息生产者, 指定生产者所属的组名
指定Nameserver地址
启动生产者
创建消息对象，指定主题、标签和消息体
发送消息
关闭生产者

//发送消息 public class RocketMQSendTest {     public static void main(String[] args) throws Exception {         //1. 创建消息生产者, 指定生产者所属的组名         DefaultMQProducer producer = new DefaultMQProducer("myproducer-group");          //2. 指定Nameserver地址         producer.setNamesrvAddr("192.168.109.131:9876");         //3. 启动生产者         producer.start();         //4. 创建消息对象，指定主题、标签和消息体         Message msg = new Message("myTopic", "myTag", ("RocketMQ Message").getBytes());         //5. 发送消息         SendResult sendResult = producer.send(msg, 10000);         System.out.println(sendResult);         //6. 关闭生产者         producer.shutdown();     } }

接收消息

消息接收步骤:

创建消息消费者, 指定消费者所属的组名
指定Nameserver地址
指定消费者订阅的主题和标签
设置回调函数，编写处理消息的方法
启动消息消费者

    public static void main(String[] args) throws MQClientException {         //1. 创建消息消费者, 指定消费者所属的组名         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(                 "myconsumer- group");         //2. 指定Nameserver地址          consumer.setNamesrvAddr("192.168.109.131:9876");         //3. 指定消费者订阅的主题和标签         consumer.subscribe("myTopic", "*");         //4. 设置回调函数，编写处理消息的方法          consumer.registerMessageListener(new MessageListenerConcurrently() {             @Override             public ConsumeConcurrentlyStatus consumeMessage(                     List<MessageExt> msgs, ConsumeConcurrentlyContext context) {                 System.out.println("Receive New Messages: " + msgs);                 //返回消费状态                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;             }         });         //5. 启动消息消费者         consumer.start();         System.out.println("Consumer Started.");     }

案例

接下来我们模拟一种场景: 下单成功之后，向下单用户发送短信。设计图如下

订单微服务发送消息

1 在 shop-order 中添加rocketmq的依赖

            <!--rocketmq-->             <dependency>                 <groupId>org.apache.rocketmq</groupId>                 <artifactId>rocketmq-spring-boot-starter</artifactId>                 <version>2.0.2</version>             </dependency>             <dependency>                 <groupId>org.apache.rocketmq</groupId>                 <artifactId>rocketmq-client</artifactId>                 <version>4.4.0</version>             </dependency>

2 添加配置

rocketmq: #rocketMQ服务的地址 name-server: 192.168.109.131:9876   producer:   # 生产者组   group: shop-order

3 编写测试代码

@RestController @Slf4j public class OrderController2 {     @Autowired     private OrderService orderService;     @Autowired     private ProductService productService;     @Autowired     private RocketMQTemplate rocketMQTemplate;     //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单,这时候要调用商品微服务查询商品信息");          //通过fegin调用商品微服务         Product product = productService.findByPid(pid);          if (product == null) {             Order order = new Order();             order.setPname("下单失败");             return order;         }         log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));          Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");          order.setPid(product.getPid());          order.setPname(product.getPname());          order.setPprice(product.getPprice());         order.setNumber(1);         orderService.save(order);         //下单成功之后,将消息放到mq中          rocketMQTemplate.convertAndSend("order-topic", order);         return order;     } }

用户微服务订阅消息

1 修改 shop-user 模块配置

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <parent>       <artifactId>springcloud-alibaba</artifactId>        <groupId>cn.maruifu</groupId>        <version>1.0-SNAPSHOT</version>     </parent>     <modelVersion>4.0.0</modelVersion>     <artifactId>shop-user</artifactId>    <dependencies>     <dependency>        <groupId>cn.maruifu</groupId>        <artifactId>shop-common</artifactId>        <version>1.0-SNAPSHOT</version>     </dependency>     <dependency>       <groupId>com.alibaba.cloud</groupId>       <artifactId>spring-cloud-starter-alibaba-nacos- discovery</artifactId>     </dependency>     <dependency>       <groupId>org.apache.rocketmq</groupId>        <artifactId>rocketmq-spring-boot-starter</artifactId>        <version>2.0.2</version>     </dependency>     <dependency>       <groupId>org.apache.rocketmq</groupId>        <artifactId>rocketmq-client</artifactId>        <version>4.4.0</version>     </dependency>   </dependencies> </project>

2 修改主类

@SpringBootApplication @EnableDiscoveryClient public class UserApplication {   public static void main(String[] args) {    SpringApplication.run(UserApplication.class, args);   }  }

3 修改配置文件

server:   port: 8071 spring:   application:     name: service-user   datasource:     driver-class-name: com.mysql.jdbc.Driver     url: jdbc:mysql:///shop? serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true     username: root     password: root   jpa:     properties:     hibernate:     hbm2ddl:     auto: update     dialect: org.hibernate.dialect.MySQL5InnoDBDialect cloud:   nacos:     discovery:       server-addr: 127.0.0.1:8848 rocketmq:       name-server: 192.168.109.131:9876

4 编写消息接收服务

package cn.maruifu.service; //发送短信的服务 @Slf4j @Service @RocketMQMessageListener(consumerGroup = "shop-user", topic = "order-topic")  public class SmsService implements RocketMQListener<Order> {   @Override   public void onMessage(Order order) {     log.info("收到一个订单信息{},接下来发送短信", JSON.toJSONString(order));   }  }

5 启动服务，执行下单操作，观看后台输出

发送不同类型的消息

普通消息

RocketMQ提供三种方式来发送普通消息:可靠同步发送、可靠异步发送和单向发送。

可靠同步发送

同步发送是指消息发送方发出数据后，会在收到接收方发回响应之后才发下一个数据包的通讯方式。此种方式应用场景非常广泛，例如重要通知邮件、报名短信通知、营销短信系统等。

可靠异步发送

异步发送是指发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。发送方通过回调接口接收服务器响应，并对响应结果进行处理。

异步发送一般用于链路耗时较长，对 RT 响应时间较为敏感的业务场景，例如用户视频上传后通知启动转码服务，转码完成后通知推送转码结果等。

单向发送

单向发送是指发送方只负责发送消息，不等待服务器回应且没有回调函数触发，即只发送请求不等待应答。

适用于某些耗时非常短，但对可靠性要求并不高的场景，例如日志收集。

<!--依赖--> <dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-test</artifactId>  </dependency> <dependency>   <groupId>junit</groupId>    <artifactId>junit</artifactId> </dependency>

//测试 @RunWith(SpringRunner.class) @SpringBootTest(classes = OrderApplication.class) public class MessageTypeTest {     @Autowired     private RocketMQTemplate rocketMQTemplate; //同步消息      @Test     public void testSyncSend() {         //参数一: topic， 如果想添加tag 可以使用"topic:tag"的写法         // 参数二: 消息内容         SendResult sendResult = rocketMQTemplate.syncSend("test-topic-1", "这是一条同步消息");         System.out.println(sendResult);     }      //异步消息     @Test     public void testSyncSendMsg () {         //参数一: topic, 如果想添加tag 可以使用"topic:tag"的写法         //参数二: 消息内容         //参数三: 回调函数, 处理返回结果         rocketMQTemplate.asyncSend("test-topic-1", "这是一条异步消息", new                 SendCallback() {                     @Override                     public void onSuccess(SendResult sendResult) {                         System.out.println(sendResult);                     }                      @Override                     public void onException(Throwable throwable) {                         System.out.println(throwable);                     }                 }         );         //让线程不要终止         Thread.sleep(30000000);     }     //单向消息     @Test     public void testOneWay () {         rocketMQTemplate.sendOneWay("test-topic-1", "这是一条单向消息");     } }

三种发送方式的对比

发送方式	发送 TPS	发送结果反馈	可靠性
同步发送	快	有	不丢失
异步发送	快	有	不丢失
单向发送	最快	无	不丢失

顺序消息

顺序消息是消息队列提供的一种严格按照顺序来发布和消费的消息类型

//同步顺序消息[异步顺序 单向顺序写法类似]  public void testSyncSendOrderly() {   //第三个参数用于队列的选择   rocketMQTemplate.syncSendOrderly("test-topic-1", "这是一条异步顺序消息", "xxxx"); }

事务消息

RocketMQ提供了事务消息，通过事务消息就能达到分布式事务的最终一致。

事务消息交互流程:

两个概念:

半事务消息:暂不能投递的消息，发送方已经成功地将消息发送到了RocketMQ服务端，但是服务端未收到生产者对该消息的二次确认，此时该消息被标记成“暂不能投递”状态，处于该种状态下的消息即半事务消息。

消息回查:由于网络闪断、生产者应用重启等原因，导致某条事务消息的二次确认丢失，RocketMQ服务端通过扫描发现某条消息长期处于“半事务消息”时，需要主动向消息生产者询问该消息的最终状态 (Commit 或是 Rollback)，该询问过程即消息回查。

事务消息发送步骤:

发送方将半事务消息发送至RocketMQ服务端。
RocketMQ服务端将消息持久化之后，向发送方返回Ack确认消息已经发送成功，此时消息为半事务消息。
发送方开始执行本地事务逻辑。
发送方根据本地事务执行结果向服务端提交二次确认(Commit 或是 Rollback)，服务端收到Commit 状态则将半事务消息标记为可投递，订阅方最终将收到该消息;服务端收到 Rollback 状态则删除半事务消息，订阅方将不会接受该消息。

事务消息回查步骤:

在断网或者是应用重启的特殊情况下，上述步骤4提交的二次确认最终未到达服务端，经过固定时间后服务端将对该消息发起消息回查。
发送方收到消息回查后，需要检查对应消息的本地事务执行的最终结果。
发送方根据检查得到的本地事务的最终状态再次提交二次确认，服务端仍按照步骤4对半事务消息进行操作。

//事物日志 @Entity(name = "shop_txlog") @Data public class TxLog {     @Id     private String txLogId;     private String content;     private Date date; }   @Service public class OrderServiceImpl4 {     @Autowiredprivate     OrderDao orderDao;     @Autowired     private TxLogDao txLogDao;     @Autowired     private RocketMQTemplate rocketMQTemplate;      public void createOrderBefore(Order order) {         String txId = UUID.randomUUID().toString();         //发送半事务消息         rocketMQTemplate.sendMessageInTransaction( "tx_producer_group","tx_topic", MessageBuilder.withPayload(order).setHeader("txId", txId).build(),order);     }      //本地事物     @Transactional     public void createOrder(String txId, Order order) {         //本地事物代码         orderDao.save(order);         // 记录日志到数据库,回查使用         TxLog txLog = new TxLog();         txLog.setTxLogId(txId);         txLog.setContent("事物测试");         txLog.setDate(new Date());         txLogDao.save(txLog);     } }  @RocketMQTransactionListener(txProducerGroup = "tx_producer_group") public class OrderServiceImpl4Listener implements RocketMQLocalTransactionListener {     @Autowired     private TxLogDao txLogDao;     @Autowired     private OrderServiceImpl4 orderServiceImpl4;      //执行本地事物     @Override     public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {         try { //本地事物             orderServiceImpl4.createOrder((String)             msg.getHeaders().get("txId"), (Order) arg);             return RocketMQLocalTransactionState.COMMIT;         } catch (Exception e) {             return RocketMQLocalTransactionState.ROLLBACK;         }     }      //消息回查     @Override     public RocketMQLocalTransactionState checkLocalTransaction(Message msg) { //查询日志记录         TxLog txLog = txLogDao.findById((String)                 msg.getHeaders().get("txId")).get();         if (txLog == null) {             return RocketMQLocalTransactionState.COMMIT;         } else {             return RocketMQLocalTransactionState.ROLLBACK;         }     } }

消息消费要注意的细节

@RocketMQMessageListener( consumerGroup = "shop",//消费者分组 topic = "order-topic",//要消费的主题 consumeMode = ConsumeMode.CONCURRENTLY, //消费模式:无序和有序  messageModel = MessageModel.CLUSTERING, //消息模式:广播和集群,默认是集群 ) public class SmsService implements RocketMQListener<Order> { }

RocketMQ支持两种消息模式:

广播消费: 每个消费者实例都会收到消息,也就是一条消息可以被每个消费者实例处理;
集群消费: 一条消息只能被一个消费者实例消费

Sleuth--链路追踪

Sat, 15 May 2021 15:05:00 GMT

链路追踪介绍

在大型系统的微服务化构建中，一个系统被拆分成了许多模块。这些模块负责不同的功能，组合成系统，最终可以提供丰富的功能。在这种架构中，一次请求往往需要涉及到多个服务。互联网应用构建在不同的软件模块集上，这些软件模块，有可能是由不同的团队开发、可能使用不同的编程语言来实现、有可能布在了几千台服务器，横跨多个不同的数据中心，也就意味着这种架构形式也会存在一些问题:

如何快速发现问题?
如何判断故障影响范围?
如何梳理服务依赖以及依赖的合理性?
如何分析链路性能问题以及实时容量规划?

分布式链路追踪(Distributed Tracing)，就是将一次分布式请求还原成调用链路，进行日志记录，性能监控并将一次分布式请求的调用情况集中展示。比如各个服务节点上的耗时、请求具体到达哪台机器上、每个服务节点的请求状态等等。

常见的链路追踪技术有下面这些:

cat 由大众点评开源，基于Java开发的实时应用监控平台，包括实时应用监控，业务监控。集成方案是通过代码埋点的方式来实现监控，比如: 拦截器，过滤器等。对代码的侵入性很大，集成成本较高。风险较大。
zipkin 由Twitter公司开源，开放源代码分布式的跟踪系统，用于收集服务的定时数据，以解决微服务架构中的延迟问题，包括:数据的收集、存储、查找和展现。该产品结合spring-cloud-sleuth 使用较为简单，集成很方便，但是功能较简单。
pinpoint :Pinpoint是韩国人开源的基于字节码注入的调用链分析，以及应用监控分析工具。特点是支持多种插件，UI功能强大，接入端无代码侵入。
skywalking:SkyWalking是本土开源的基于字节码注入的调用链分析，以及应用监控分析工具。特点是支持多种插件，UI功能较强，接入端无代码侵入。目前已加入Apache孵化器。
Sleuth:SpringCloud 提供的分布式系统中链路追踪解决方案。

注意:SpringCloud alibaba技术栈中并没有提供自己的链路追踪技术的，我们可以采用Sleuth +Zinkin来做链路追踪解决方案

Sleuth入门

Sleuth介绍

SpringCloud Sleuth主要功能就是在分布式系统中提供追踪解决方案。它大量借用了Google Dapper的设计，先来了解一下Sleuth中的术语和相关概念。

Trace 由一组Trace Id相同的Span串联形成一个树状结构。为了实现请求跟踪，当请求到达分布式系统的入口端点时，只需要服务跟踪框架为该请求创建一个唯一的标识(即TraceId)，同时在分布式系统内部流转的时候，框架始终保持传递该唯一值，直到整个请求的返回。那么我们就可以使用该唯一标识将所有的请求串联起来，形成一条完整的请求链路。

Span 代表了一组基本的工作单元。为了统计各处理单元的延迟，当请求到达各个服务组件的时候，也通过一个唯一标识(SpanId)来标记它的开始、具体过程和结束。通过SpanId的开始和结束时间戳，就能统计该span的调用时间，除此之外，我们还可以获取如事件的名称。请求信息等元数据。

Annotation

用它记录一段时间内的事件，内部使用的重要注释:

cs(Client Send)客户端发出请求，开始一个请求的生命
sr(Server Received)服务端接受到请求开始进行处理， sr-cs = 网络延迟(服务调用的时间)
ss(Server Send)服务端处理完毕准备发送到客户端，ss - sr = 服务器上的请求处理时间
cr(Client Reveived)客户端接受到服务端的响应，请求结束。 cr - sr = 请求的总时间

Sleuth入门

微服务名称, traceId, spanid,是否将链路的追踪结果输出到第三方平台

[api-gateway,3977125f73391553,3977125f73391553,false]

[service-order,3977125f73391553,57547b5bf71f8242,false]

[service-product,3977125f73391553,449f5b3f3ef8d5c5,false]

接下来通过之前的项目案例整合Sleuth，完成入门案例的编写。修改common父工程引入Sleuth依赖

<!--链路追踪 Sleuth-->  <dependency>     <groupId>org.springframework.cloud</groupId>     <artifactId>spring-cloud-starter-sleuth</artifactId>   </dependency>

启动微服务，调用之后，我们可以在控制台观察到sleuth的日志输出

其中 5399d5cb061971bd 是TraceId， 5399d5cb061971bd 是SpanId，依次调用有一个全局的 TraceId，将调用链路串起来。仔细分析每个微服务的日志，不难看出请求的具体过程。

查看日志文件并不是一个很好的方法，当微服务越来越多日志文件也会越来越多，通过Zipkin可以将日志聚合，并进行可视化展示和全文检索。

Zipkin的集成

ZipKin介绍

Zipkin 是 Twitter 的一个开源项目，它基于Google Dapper实现，它致力于收集服务的定时数据，以解决微服务架构中的延迟问题，包括数据的收集、存储、查找和展现。

我们可以使用它来收集各个服务器上请求链路的跟踪数据，并通过它提供的REST API接口来辅助我们查询跟踪数据以实现对分布式系统的监控程序，从而及时地发现系统中出现的延迟升高问题并找出系统性能瓶颈的根源。

除了面向开发的 API 接口之外，它也提供了方便的UI组件来帮助我们直观的搜索跟踪信息和分析请求链路明细，比如:可以查询某段时间内各用户请求的处理时间等。

Zipkin 提供了可插拔数据存储方式:In-Memory、MySql、Cassandra 以及 Elasticsearch。

上图展示了 Zipkin 的基础架构，它主要由 4 个核心组件构成:

Collector:收集器组件，它主要用于处理从外部系统发送过来的跟踪信息，将这些信息转换为 Zipkin内部处理的 Span 格式，以支持后续的存储、分析、展示等功能。
Storage:存储组件，它主要对处理收集器接收到的跟踪信息，默认会将这些信息存储在内存中，我们也可以修改此存储策略，通过使用其他存储组件将跟踪信息存储到数据库中。
RESTful API:API 组件，它主要用来提供外部访问接口。比如给客户端展示跟踪信息，或是外接系统访问以实现监控等。
Web UI:UI 组件，基于API组件实现的上层应用。通过UI组件用户可以方便而有直观地查询和分析跟踪信息。

Zipkin分为两端，一个是 Zipkin服务端，一个是 Zipkin客户端，客户端也就是微服务的应用。客户端会配置服务端的 URL 地址，一旦发生服务间的调用的时候，会被配置在微服务里面的 Sleuth 的监听器监听，并生成相应的 Trace 和 Span 信息发送给服务端。

ZipKin服务端安装

第1步: 下载ZipKin的jar包

https://search.maven.org/remote_content?g=io.zipkin.java&a=zipkin-server&v=LATEST&c=exec

第2步: 通过命令行，输入下面的命令启动ZipKin Server

java -jar zipkin-server-2.12.9-exec.jar

第3步:通过浏览器访问 http://localhost:9411访问

Zipkin客户端集成

ZipKin客户端和Sleuth的集成非常简单，只需要在微服务中添加其依赖和配置即可。

第1步:在每个微服务上添加依赖

<dependency>    <groupId>org.springframework.cloud</groupId>    <artifactId>spring-cloud-starter-zipkin</artifactId>  </dependency>

第2步:添加配置

spring:   zipkin:     #开启zipkin分析     enabled: true     #zipkin服务地址     baseUrl: http://127.0.0.1:9411/     #让nacos把它当成一个URL，而不要当做服务名     discoveryClientEnabled: false    sleuth:     sampler:       #限速器，每秒采集10个请求，防止大并发过载。推荐       #rate: 10       #采集率，大并发可能采集率数量也会很高。采样的百分比       probability: 0.1

第3步: 访问微服务

http://localhost:7000/order-serv/order/prod/1

第4步: 访问zipkin的UI界面，观察效果

第5步:点击其中一条记录，可观察一次访问的详细线路。

ZipKin数据持久化

Zipkin Server默认会将追踪数据信息保存到内存，但这种方式不适合生产环境。Zipkin支持将追踪数据持久化到mysql数据库或elasticsearch中。

使用mysql实现数据持久化

CREATE TABLE IF NOT EXISTS zipkin_spans (   `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',   `trace_id` BIGINT NOT NULL,   `id` BIGINT NOT NULL,   `name` VARCHAR(255) NOT NULL,   `parent_id` BIGINT,   `debug` BIT(1),   `start_ts` BIGINT COMMENT 'Span.timestamp(): epoch micros used for endTs query and to implement TTL',`duration` BIGINT COMMENT 'Span.duration(): micros used for minDuration and maxDuration query' ) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;  ALTER TABLE zipkin_spans ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `id`) COMMENT 'ignore insert on duplicate'; ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`, `id`) COMMENT 'for joining with zipkin_annotations'; ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTracesByIds'; ALTER TABLE zipkin_spans ADD INDEX(`name`) COMMENT 'for getTraces and getSpanNames'; ALTER TABLE zipkin_spans ADD INDEX(`start_ts`) COMMENT 'for getTraces ordering and range';  CREATE TABLE IF NOT EXISTS zipkin_annotations (   `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this   means the trace uses 128 bit traceIds instead of 64 bit',   `trace_id` BIGINT NOT NULL COMMENT 'coincides with   zipkin_spans.trace_id',   `span_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.id',   `a_key` VARCHAR(255) NOT NULL COMMENT 'BinaryAnnotation.key or Annotation.value if type == -1',   `a_value` BLOB COMMENT 'BinaryAnnotation.value(), which must be smaller   than 64KB',   `a_type` INT NOT NULL COMMENT 'BinaryAnnotation.type() or -1 if   Annotation',   `a_timestamp` BIGINT COMMENT 'Used to implement TTL;   Annotation.timestamp or zipkin_spans.timestamp',   `endpoint_ipv4` INT COMMENT 'Null when Binary/Annotation.endpoint is null',   `endpoint_ipv6` BINARY(16) COMMENT 'Null when Binary/Annotation.endpoint is null, or no IPv6 address',   `endpoint_port` SMALLINT COMMENT 'Null when Binary/Annotation.endpoint   is null',   `endpoint_service_name` VARCHAR(255) COMMENT 'Null when Binary/Annotation.endpoint is null' ) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;  ALTER TABLE zipkin_annotations ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `span_id`, `a_key`, `a_timestamp`) COMMENT 'Ignore insert on duplicate';  ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`, `span_id`) COMMENT 'for joining with zipkin_spans'; ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTraces/ByIds'; ALTER TABLE zipkin_annotations ADD INDEX(`endpoint_service_name`) COMMENT 'for getTraces and getServiceNames'; ALTER TABLE zipkin_annotations ADD INDEX(`a_type`) COMMENT 'for getTraces';  ALTER TABLE zipkin_annotations ADD INDEX(`a_key`) COMMENT 'for getTraces';  ALTER TABLE zipkin_annotations ADD INDEX(`trace_id`, `span_id`, `a_key`) COMMENT 'for dependencies job';  CREATE TABLE IF NOT EXISTS zipkin_dependencies (   `day` DATE NOT NULL,   `parent` VARCHAR(255) NOT NULL,   `child` VARCHAR(255) NOT NULL,   `call_count` BIGINT ) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci; ALTER TABLE zipkin_dependencies ADD UNIQUE KEY(`day`, `parent`,`child`);

第2步: 在启动ZipKin Server的时候,指定数据保存的mysql的信息

java -jar zipkin-server-2.12.9-exec.jar --STORAGE_TYPE=mysql -- MYSQL_HOST=127.0.0.1 --MYSQL_TCP_PORT=3306 --MYSQL_DB=zipkin --MYSQL_USER=root - -MYSQL_PASS=root

使用elasticsearch实现数据持久化

第1步: 下载elasticsearch 下载地址:https://www.elastic.co/cn/downloads/past-releases/elasticsearch-6-8-4 第2步: 启动elasticsearch

第3步: 在启动ZipKin Server的时候，指定数据保存的elasticsearch的信息

java -jar zipkin-server-2.12.9-exec.jar --STORAGE_TYPE=elasticsearch --ES- HOST=localhost:9200

秒懂QPS、TPS、PV、UV、GMV、IP、RPS

Sun, 28 Mar 2021 08:10:00 GMT

QPS、TPS、PV、UV、GMV、IP、RPS等各种名词，外行看起来很牛X，实际上每个程序员都是必懂知识点。下面我来一一解释一下。

QPS

Queries Per Second，每秒查询数。每秒能够响应的查询次数。

QPS 是一台服务器每秒能够相应的查询次数，即1秒内完成的请求数量，是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准

QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准，在因特网上，作为域名系统服务器的机器的性能经常用每秒查询率来衡量。每秒的响应请求数，也即是最大吞吐能力。

TPS

Transactions Per Second 的缩写，每秒处理的事务数目。一个事务是指一个客户机向服务器发送请求然后服务器做出反应的过程。客户机在发送请求时开始计时，收到服务器响应后结束计时，以此来计算使用的时间和完成的事务个数，最终利用这些信息作出的评估分。

TPS 的过程包括：客户端请求服务端、服务端内部处理、服务端返回客户端。

例如，访问一个 Index 页面会请求服务器 3 次，包括一次 html，一次 css，一次 js，那么访问这一个页面就会产生一个“T”，产生三个“Q”。

QPS 与 TPS 区别

QPS基本类似于TPS，但是不同的是，对于一个Web页面的一次访问，形成一个TPS（就做一件事儿，打开Web网页）；但一次Web页面请求，可能产生多次对服务器的请求（html、css、js、images、files等），服务器对这些请求，就可计入QPS之中。每秒查询率QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准。

一个事务是指一个客户机向服务器发送请求然后服务器做出反应的过程。客户机在发送请求时开始计时，收到服务器响应后结束计时，以此来计算使用的时间和完成的事务个数。

如果是对一个接口（单场景）压测，且这个接口内部不会再去请求其它接口，那么TPS等于QPS，否则，若这个接口内部还会再去请求其它接口（下载图片、文件等服务器接口），那么 TPS不等于QPS，通常是 QPS会大于TPS

PV

page view即页面浏览量

通常是衡量一个网络新闻频道或网站甚至一条网络新闻的主要指标。

用户每一次对网站中的每个页面访问均被记录 1 次。

用户对同一页面的多次刷新，访问量累计。

根据这个特性，刷网站的 PV 就很好刷了。

与 PV 相关的还有 RV，即重复访问者数量（repeat visitors）。

UV

Unique Visitor 指独立访客访问数，统计1天内访问某站点的用户数(以 cookie 为依据)，一台电脑终端为一个访客。

IP

Internet Protocol独立 IP 数

是指 1 天内多少个独立的 IP 浏览了页面，即统计不同的 IP 浏览用户数量。

同一 IP 不管访问了几个页面，独立 IP 数均为 1；

不同的 IP 浏览页面，计数会加 1。

IP 是基于用户广域网 IP 地址来区分不同的访问者的，所以，多个用户（多个局域网 IP）在同一个路由器（同一个广域网 IP）内上网，可能被记录为一个独立 IP 访问者。如果用户不断更换 IP，则有可能被多次统计。

RT

Response Time 响应时间是一个系统最重要的指标之一，它的数值大小直接反应了系统的快慢。

响应时间是指系统对请求作出响应的时间。直观上看，这个指标与人对软件性能的主观感受是非常一致的，因为它完整地记录了整个计算机系统处理请求的时间。由于一个系统通常会提供许多功能，而不同功能的处理逻辑也千差万别，因而不同功能的响应时间也不尽相同，甚至同一功能在不同输入数据的情况下响应时间也不相同。所以，在讨论一个系统的响应时间时，人们通常是指该系统所有功能的平均时间或者所有功能的最大响应时间。当然，往往也需要对每个或每组功能讨论其平均响应时间和最大响应时间。

对于单机的没有并发操作的应用系统而言，人们普遍认为响应时间是一个合理且准确的性能指标。需要指出的是，响应时间的绝对值并不能直接反映软件的性能的高低，软件性能的高低实际上取决于用户对该响应时间的接受程度。对于一个游戏软件来说，响应时间小于100毫秒应该是不错的，响应时间在1秒左右可能属于勉强可以接受，如果响应时间达到3秒就完全难以接受了。而对于编译系统来说，完整编译一个较大规模软件的源代码可能需要几十分钟甚至更长时间，但这些响应时间对于用户来说都是可以接受的。

响应时间是指执行一个请求从开始到最后收到响应数据所花费的总体时间,即从客户端发起请求到收到服务器响应结果的时间

GMV

Gross Merchandise Volume 的简称。只要是订单，不管消费者是否付款、卖家是否发货、是否退货，都可放进 GMV 。

RPS

RPS 代表吞吐率，即 Requests Per Second 的缩写。吞吐率是服务器并发处理能力的量化描述，单位是 reqs/s，指的是某个并发用户数下单位时间内处理的请求数。

某个并发用户数下单位时间内能处理的最大的请求数，称之为最大吞吐率。

有人把 RPS 说等效于 QPS。其实可以看作同一个统计方式，只是叫法不同而已。RPS/QPS，可以使用 apche ab 工具进行测量。

QPS、PV 、RT 之间的关系

在进行系统性能压测和系统性能优化的时候，会涉及到QPS,PV,RT相关的概念， QPS,PV,RT之间的关系

对于大部分web系统，响应时间一般由CPU执行时间，线程等待时间（IO等待，sleep, wait）时间组成，QPS和RT成反比关系
在实际的测试环境中，QPS和RT并不是非常直接的反比关系

QPS 是什么

QPS：单个进程每秒请求服务器的成功次数 QPS = req/sec = 请求数/秒

QPS如何统计

QPS统计方式 [一般使用 http_load 进行统计] QPS = 总请求数 / ( 进程总数 * 请求时间 )

根据QPS推算PV：

单台服务器每天PV计算:

公式1：每天总PV = QPS * 3600 * 6 公式2：每天总PV = QPS * 3600 * 8

根据QPS，PV推算服务器数量

服务器数量 = 每天总PV / 单台服务器每天总PV

峰值QPS和机器计算公式：

原理：每天80%的访问集中在20%的时间里，这20%时间叫做峰值时间

峰值时间每秒请求数(QPS)：( 总PV数 * 80% ) / ( 每天秒数 * 20% )

峰值机器数量：峰值时间QPS / 单台机器的QPS

例子：

问：每天300w PV 的在单台机器上，这台机器需要多少QPS？

答：( 3000000 * 0.8 ) / (86400 * 0.2 ) = 139 (QPS)

问：如果一台机器的QPS是58，需要几台机器来支持？

答：139 / 58 = 3

对于大部分web系统，响应时间一般由CPU执行时间，线程等待时间（IO等待，sleep, wait）时间组成，QPS和RT成反比关系
在实际的测试环境中，QPS和RT并不是非常直接的反比关系

最佳线程数

性能压测的情况下，起初随着用户数的增加，QPS会上升，当到了一定的阀值之后，用户数量增加QPS并不会增加，或者增加不明显，同时请求的响应时间却大幅增加，这个阀值我们认为是最佳线程数。

刚好消耗完服务器的瓶颈资源的临界线程数，公式如下

最佳线程数量 =（（线程等待时间 + 线程CPU执行时间）/ 线程CPU执行时间）* CPU数量

特性：

在达到最佳线程数的时候，线程数量继续递增，则QPS不变，而响应时间变长，持续递增线程数量，则QPS开始下降
每个系统都有其最佳线程数量，但是不同状态下，最佳线程数量是会变化的
瓶颈资源可以是CPU,可以是内存，可以是锁资源，IO资源

超过最佳线程数，会导致资源的竞争；超过最佳线程数，会响应时间递增。

为什么要找最佳线程数

过多的线程只会造成，更多的内存开销，更多的CPU开销，但是对提升QPS确毫无帮助
找到最佳线程数后通过简单的设置，可以让web系统更加稳定，得到最高，最稳定的QPS输出

最佳线程数的获取：

通过用户慢慢递增来进行性能压测，观察QPS，响应时间
根据公式计算:服务器端最佳线程数量=((线程等待时间+线程cpu时间)/线程cpu时间) * cpu数量
单用户压测，查看CPU的消耗，然后直接乘以百分比，再进行压测，一般这个值的附近应该就是最佳线程数量。

影响最佳线程数的主要因素

IO开销较多的应用其CPU线程等待时间会比较长，所以线程数量可以开的多一些，相反则线程数量要少一些，其实有两种极端，纯IO的应用，比如proxy，则线程数量可以开到非常大（实在太大了则需要考虑线程切换的开销），这种应用基本上后端（比如这个proxy是代理搜索的）的QPS能有多少，proxy就有多少。

对于耗CPU的计算，这种情况一般来讲只能开到CPU个数的线程数量。但是并不是说这种应用的QPS就不高，往往这种应用的QPS可以很高，因为耗CPU计算的应用，往往处理单次请求的时间会很短。

QPS和线程数的关系

在最佳线程数量之前，QPS和线程是互相递增的关系，线程数量到了最佳线程之后，QPS持平，不在上升，甚至略有下降，同时响应时间持续上升。

同一个系统而言，最佳线程数越多，QPS越高

并发数（Parallels）

并发数是指系统同时能处理的请求数量，一般跟CPU个数，线程数有关，这反应了系统的负载能力

并发用户数是指系统可以同时承载的正常使用系统功能的用户的数量。与吞吐量相比，并发用户数是一个更直观但也更笼统的性能指标。实际上，并发用户数是一个非常不准确的指标，因为用户不同的使用模式会导致不同用户在单位时间发出不同数量的请求。一网站系统为例，假设用户只有注册后才能使用，但注册用户并不是每时每刻都在使用该网站，因此具体一个时刻只有部分注册用户同时在线，在线用户就在浏览网站时会花很多时间阅读网站上的信息，因而具体一个时刻只有部分在线用户同时向系统发出请求。这样，对于网站系统我们会有三个关于用户数的统计数字：注册用户数、在线用户数和同时发请求用户数。由于注册用户可能长时间不登陆网站，使用注册用户数作为性能指标会造成很大的误差。而在线用户数和同事发请求用户数都可以作为性能指标。相比而言，以在线用户作为性能指标更直观些，而以同时发请求用户数作为性能指标更准确些。

吞吐量（Throughput）

吞吐量是指单位时间内系统能处理的请求数量，体现系统处理请求的能力，这是目前最常用的性能测试指标

吞吐量是指系统在单位时间内处理请求的数量。对于无并发的应用系统而言，吞吐量与响应时间成严格的反比关系，实际上此时吞吐量就是响应时间的倒数。前面已经说过，对于单用户的系统，响应时间（或者系统响应时间和应用延迟时间）可以很好地度量系统的性能，但对于并发系统，通常需要用吞吐量作为性能指标。

对于一个多用户的系统，如果只有一个用户使用时系统的平均响应时间是t，当有你n个用户使用时，每个用户看到的响应时间通常并不是n×t，而往往比n×t小很多（当然，在某些特殊情况下也可能比n×t大，甚至大很多）。这是因为处理每个请求需要用到很多资源，由于每个请求的处理过程中有许多不走难以并发执行，这导致在具体的一个时间点，所占资源往往并不多。也就是说在处理单个请求时，在每个时间点都可能有许多资源被闲置，当处理多个请求时，如果资源配置合理，每个用户看到的平均响应时间并不随用户数的增加而线性增加。实际上，不同系统的平均响应时间随用户数增加而增长的速度也不大相同，这也是采用吞吐量来度量并发系统的性能的主要原因。一般而言，吞吐量是一个比较通用的指标，两个具有不同用户数和用户使用模式的系统，如果其最大吞吐量基本一致，则可以判断两个系统的处理能力基本一致。

并发量、QPS、RT 之间的关系：

QPS = 并发量 / 平均响应时间（推荐）

并发量 = QPS * 平均响应时间

假设每天80%的访问集中在20%的时间里，这20%时间叫做峰值时间

公式：( 总PV数 * 80% ) / ( 每天秒数 * 20% ) = 峰值时间每秒请求数(QPS)

机器：峰值时间每秒QPS / 单台机器的QPS = 需要的机器

每天300w PV 的在单台机器上，这台机器需要多少QPS？

( 3000000 * 0.8 ) / (86400 * 0.2 ) = 139 (QPS)

如果一台机器的QPS是58，需要几台机器来支持？

139 / 58 = 3 （进一法，取上限）

单线程QPS公式，QPS=1000ms/RT,对同一个系统而言，支持的线程数越多，QPS越高。

假设一个RT是80ms,则可以很容易的计算出QPS,QPS = 1000/80 = 12.5

多线程场景，如果把服务端的线程数提升到2，那么整个系统的QPS则为 2*（1000/80） = 25,

可见QPS随着线程的增加而线性增长，那QPS上不去就加线程呗，听起来很有道理，公司也说的通，但是往往现实并非如此。

如何提升RT（响应时间）

减少 IO 的响应时间，减少 IO 的调用次数

并发HTTP请求，无上下文依赖，多个连接，一个线程

HTTP连接池（长连接，keep-alive）

减少 CPU 的使用时间

forest 循环的例子

如何提升 QPS（每秒查询数）

减少 CPU 的使用时间
增加 CPU 的数量
减少同步锁

如果 CPU 不能被压到 85% 以上，并且此时的OPS已经达到了峰值，则说明另有瓶颈，接下去要重点关注内存

排查内存是否有瓶颈

判断依据，是在最佳线程数量 * 5 左右的情况下，进行压测，观察 Old 区内存增长是否正常

性能压测要关注使用了多少用户数，目前的压测方式容易遗漏内存瓶颈

总结

Proxy 应用（耗IO）的线程越多越好，当线程达到过多时，线程本身资源的开销也会成为瓶颈，线程本身也是一个资源。

所以这类Proxy应用一般采取轻程模型，NIO解决，如 nginx

计算型应用（耗CPU），线程数量就是CPU的核数，如搜索索引服务器，需要做大量的计算排序，非常耗CPU资源

后端开发术语

Sun, 28 Mar 2021 07:36:00 GMT

后台开发作为互联网技术领域的掌上明珠，一直都是开发者们的追逐的高峰。本文将从后台开发所涉及到的技术术语出发，基于系统开发、架构设计、网络通信等几个方面让大家对后台来发有一个清晰的了解，讲解全面易懂。

系统开发

高内聚/低耦合

高内聚指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。模块的内聚反映模块内部联系的紧密程度。

模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。一个完整的系统，模块与模块之间，尽可能的使其独立存在。**通常程序结构中各模块的内聚程度越高，模块间的耦合程度就越低。

过度设计

过度设计就是进行了过多的面向未来的设计或者说把相对简单的事情想复杂了，过度追求模块化、可扩展性、设计模式等，为系统增加了不必要的复杂度。

过早优化

过早指的不是在开发过程的早期，而是在还没弄清楚需求未来的变化的走向的时候。你的优化不仅可能导致你无法很好地实现新的需求，而且你对优化的预期的猜测有可能还是错的，导致实际上你除了把代码变复杂以外什么都没得到。

正确的方法是，先有质量地实现你的需求，写够testcase，然后做profile去找到性能的瓶颈，这个时候才做优化。

重构 (Refactoring)

重构（Refactoring）就是通过调整程序代码改善软件的质量、性能，使其程序的设计模式和架构更趋合理，提高软件的扩展性和维护性。

破窗效应

又称破窗理论，破窗效应（Broken windows theory）是犯罪学的一个理论。此理论认为环境中的不良现象如果被放任存在，会诱使人们仿效，甚至变本加厉。一幢有少许破窗的建筑为例，如果那些窗不被修理好，可能将会有破坏者破坏更多的窗户。最终他们甚至会闯入建筑内，如果发现无人居住，也许就在那里定居或者纵火。

应用在软件工程上就是，一定不能让系统代码或者架构设计的隐患有冒头的机会，否则随着时间的推移，隐患会越来越重。反之，一个本身优质的系统，会让人不由自主的写出优质的代码。

互不信任原则

指在程序运行上下游的整个链路中，每个点都是不能保证绝对可靠的，任何一个点都可能随时发生故障或者不可预知的行为，包括机器网络、服务本身、依赖环境、输入和请求等，因此要处处设防。

持久化 (Persistence)

持久化是将程序数据在临时状态和持久状态间转换的机制。通俗的讲，就是临时数据（比如内存中的数据，是不能永久保存的）持久化为持久数据（比如持久化至数据库或者本地磁盘中，能够长久保存）。

临界区

临界区用来表示一种公共资源或者说是共享数据，可以被多个线程使用，但是每一次，只能有一个线程使用它，一旦临界区资源被占用，其他线程要想使用这个资源，就必须等待。

阻塞/非阻塞

阻塞和非阻塞通常形容多线程间的相互影响。比如一个线程占用了临界区资源，那么其它所有需要这个资源的线程就必须在这个临界区中进行等待，等待会导致线程挂起。这种情况就是阻塞。此时，如果占用资源的线程一直不愿意释放资源，那么其它所有阻塞在这个临界区上的线程都不能工作。而非阻塞允许多个线程同时进入临界区。

同步/异步

通常同步和异步是指函数/方法调用方面。

同步就是在发出一个函数调用时，在没有得到结果之前，该调用就不返回。异步调用会瞬间返回，但是异步调用瞬间返回并不代表你的任务就完成了，他会在后台起个线程继续进行任务，等任务执行完毕后通过回调callback或其他方式通知调用方。

并发/并行

**并行(parallel)**指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
**并发(concurrency)**指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

架构设计

高并发 (High Concurrency)

由于分布式系统的问世，高并发（High Concurrency）通常是指通过设计保证系统能够同时并行处理很多请求。通俗来讲，高并发是指在同一个时间点，有很多用户同时的访问同一 API 接口或者 Url 地址。它经常会发生在有大活跃用户量，用户高聚集的业务场景中。

高可用 (High Availability)

高可用HA（High Availability）是分布式系统架构设计中必须考虑的因素之一，它通常是指，一个系统经过专门的设计，以减少停工时间，而保持其服务的高度可用性。

读写分离

为了确保数据库产品的稳定性，很多数据库拥有双机热备功能。也就是，第一台数据库服务器，是对外提供增删改业务的生产服务器；第二台数据库服务器，主要进行读的操作。

冷备/热备

冷备：两个服务器，一台运行，一台不运行做为备份。这样一旦运行的服务器宕机，就把备份的服务器运行起来。冷备的方案比较容易实现，但冷备的缺点是主机出现故障时备机不会自动接管，需要主动切换服务。
热备：即是通常所说的active/standby方式，服务器数据包括数据库数据同时往两台或多台服务器写。当active服务器出现故障的时候，通过软件诊测（一般是通过心跳诊断）将standby机器激活，保证应用在短时间内完全恢复正常使用。当一台服务器宕机后，自动切换到另一台备用机使用。

异地多活

异地多活一般是指在不同城市建立独立的数据中心，“活”是相对于冷备份而言的，冷备份是备份全量数据，平时不支撑业务需求，只有在主机房出现故障的时候才会切换到备用机房，而多活，是指这些机房在日常的业务中也需要走流量，做业务支撑。

负载均衡 (Load Balance)

负载均衡，是对多台服务器进行流量分发的负载均衡服务。可在多个实例间自动分配应用程序的对外服务能力，通过消除单点故障提升应用系统的可用性，让您实现更高水平的应用程序容错能力，从而无缝提供分配应用程序流量所需的负载均衡容量，为您提供高效、稳定、安全的服务。

动静分离

动静分离是指在web服务器架构中，将静态页面与动态页面或者静态内容接口和动态内容接口分开不同系统访问的架构设计方法，进而提升整个服务访问性能和可维护性。

集群

单台服务器的并发承载能力总是有限的，当单台服务器处理能力达到性能瓶颈的时，将多台服务器组合起来提供服务，这种组合方式称之为集群，集群中每台服务器就叫做这个集群的一个“节点”，每个节点都能提供相同的服务，从而成倍的提升整个系统的并发处理能力。

分布式

分布式系统就是将一个完整的系统按照业务功能拆分成很多独立的子系统，每个子系统就被称为“服务”，分布式系统将请求分拣和分发到不同的子系统，让不同的服务来处理不同的请求。在分布式系统中，子系统独立运行，它们之间通过网络通信连接起来实现数据互通和组合服务。

CAP理论

CAP理论，指的是在一个分布式系统中，Consistency(一致性)、Availability(可用性)、Partition Tolerance(分区容错性)，不能同时成立。

**一致性：**它要求在同一时刻点，分布式系统中的所有数据备份都相同或者都处于同一状态。
**可用性：**在系统集群的一部分节点宕机后，系统依然能够正确的响应用户的请求。
**分区容错性：**系统能够容忍节点之间的网络通信的故障。

简单的来说，**在一个分布式系统中，最多能支持上面的两种属性。**但显然既然是分布式注定我们是必然要进行分区，既然分区，我们就无法百分百避免分区的错误。因此，我们只能在一致性和可用性去作出选择。

在分布式系统中，我们往往追求的是可用性，它的重要性比一致性要高，那么如何实现高可用，这里又有一个理论，就是 BASE 理论，它给 CAP 理论做了进一步的扩充。

BASE理论

BASE 理论指出：

Basically Available（基本可用）
Soft state（软状态）
Eventually consistent（最终一致性）

BASE 理论是对 CAP 中的一致性和可用性进行一个权衡的结果，理论的核心思想就是：我们无法做到强一致，但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性。

水平扩展/垂直扩展

水平扩展 Scale Out通过增加更多的服务器或者程序实例来分散负载，从而提升存储能力和计算能力。
垂直扩展 Scale Up 提升单机处理能力。

垂直扩展的方式又有两种：

（1）增强单机硬件性能，例如：增加CPU核数如32核，升级更好的网卡如万兆，升级更好的硬盘如SSD，扩充硬盘容量如2T，扩充系统内存如128G;
（2）提升单机软件或者架构性能，例如：使用Cache来减少IO次数，使用异步来增加单服务吞吐量，使用无锁数据结构来减少响应时间；

平行扩容

与水平扩展类似。集群服务器中的节点均为平行对等节点，当需要扩容时，可以通过添加更多节点以提高集群的服务能力。一般来说服务器中关键路径（如服务器中的登录、支付、核心业务逻辑等）都需要支持运行时动态平行扩容。

弹性扩容

指对部署的集群进行动态在线扩容。弹性扩容系统可以根据实际业务环境按照一定策略自动地添加更多的节点（包括存储节点、计算节点、网络节点）来增加系统容量、提高系统性能或者增强系统可靠性，或者同时完成这三个目标。

状态同步/帧同步

**状态同步：**状态同步是指服务器负责计算全部的游戏逻辑，并且广播这些计算的结果，客户端仅仅负责发送玩家的操作，以及表现收到的游戏结果。

**特征：**状态同步安全性高，逻辑更新方便，断线重连快，但是开发效率较低，网络流量随游戏复杂度增加，服务器需要承载更大压力。

**帧同步：**服务端只转发消息，不做任何逻辑处理，各客户端每秒帧数一致，在每一帧都处理同样的输入数据。

**特征：**帧同步需要保证系统在相同的输入下，要有相同的输出。帧同步开发效率高，流量消耗低而且稳定，对服务器的压力非常小。但是网络要求高，断线重连时间长，客户端计算压力大。

网络通信

连接池

预先建立一个连接缓冲池，并提供一套连接使用、分配、管理策略，使得该连接池中的连接可以得到高效、安全的复用，避免了连接频繁建立、关闭的开销。

断线重连

由于网络波动造成用户间歇性的断开与服务器的连接，待网络恢复之后服务器尝试将用户连接到上次断开时的状态和数据。

会话保持

会话保持是指在负载均衡器上的一种机制，可以识别客户端与服务器之间交互过程的关连性，在作负载均衡的同时还保证一系列相关连的访问请求都会分配到一台机器上。用人话来表述就是：在一次会话过程中发起的多个请求都会落到同一台机器上。

长连接/短连接

通常是指TCP的长连接和短连接。长连接就是建立TCP连接后，一直保持这个连接，一般会中间彼此发送心跳来确认对应的存在，中间会做多次业务数据传输，一般不会主动断开连接。短连接一般指建立连接后，执行一次事务后（如：http请求），然后就关掉这个连接。

流量控制/拥塞控制

流量控制防止发送方发的太快，耗尽接收方的资源，从而使接收方来不及处理。
拥塞控制防止发送方发的太快，使得网络来不及处理产生拥塞，进而引起这部分乃至整个网络性能下降的现象，严重时甚至会导致网络通信业务陷入停顿。

惊群效应

惊群效应也有人叫做雷鸣群体效应，不过叫什么，简言之，惊群现象就是多进程（多线程）在同时阻塞等待同一个事件的时候（休眠状态），如果等待的这个事件发生，那么他就会唤醒等待的所有进程（或者线程），但是最终却只可能有一个进程（线程）获得这个时间的“控制权”，对该事件进行处理，而其他进程（线程）获取“控制权”失败，只能重新进入休眠状态，这种现象和性能浪费就叫做惊群。

NAT

NAT（Network Address Translation，网络地址转换），就是替换IP报文头部的地址信息。NAT通常部署在一个组织的网络出口位置，通过将内部网络IP地址替换为出口的IP地址提供公网可达性和上层协议的连接能力。

故障异常

宕机

宕机，一般情况下指的就是计算机主机出现意外故障而死机。其次，一些服务器例如数据库死锁也可以称为宕机，一些服务器的某些服务挂掉了，就可以这么说。

coredump

当程序出错而异常中断时，OS会把程序工作的当前状态存储成一个coredunmp文件。通常情况下coredump文件包含了程序运行时的内存，寄存器状态，堆栈指针，内存管理信息等。

缓存穿透/击穿/雪崩

**缓存穿透：**缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时需要从数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，进而给数据库带来压力。
**缓存击穿：**缓存击穿是指热点key在某个时间点过期的时候，而恰好在这个时间点对这个Key有大量的并发请求过来，从而大量的请求打到db。
**缓存雪崩：**缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。
**与缓存击穿不同的是：**存击穿是热点key失效，缓存雪崩是大量的key同时失效。

500/501/502/503/504/505

**500 Internal Server Error：**内部服务错误，一般是服务器遇到意外情况，而无法完成请求。可能原因: 1、程序错误，例如：ASP或者PHP语法错误；2、高并发导致，系统资源限制不能打开过多的文件所致。
**501Not implemented：**服务器不理解或不支持请求的HTTP请求。
**502Bad Gateway：**WEB服务器故障，可能是由于程序进程不够，请求的php-fpm已经执行，但是由于某种原因而没有执行完毕，最终导致php-fpm进程终止。可能原因：1、Nginx服务器，php-cgi进程数不够用；2、PHP执行时间过长；3、php-cgi进程死掉；
**503Service Unavailable：**服务器目前无法使用。系统维护服务器暂时的无法处理客户端的请求，这只是暂时状态。可以联系下服务器提供商。
**504Gateway Timeout：**服务器504错误表示超时，是指客户端所发出的请求没有到达网关，请求没有到可以执行的php-fpm，一般是与nginx.conf的配置有关。
**505HTTP Version Not Supported：**服务器不支持请求中所用的 HTTP 协议版本。（HTTP 版本不受支持）

除了500错误可能是程序语言错误，其余的报错，都大概可以理解为服务器或者服务器配置出现问题。

内存溢出/内存泄漏

**内存溢出：**内存溢出（Out Of Memory）指程序申请内存时，没有足够的内存供申请者使用，或者说，给了你一块存储int类型数据的存储空间，但是你却存储long类型的数据，那么结果就是内存不够用，此时就会报错OOM,即所谓的内存溢出。
**内存泄漏：**内存泄漏（Memory Leak）指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

句柄泄漏

句柄泄漏是进程在调用系统文件之后，没有释放已经打开的文件句柄。一般句柄泄漏后的现象是，机器变慢，CPU飙升，出现句柄泄漏的cgi或server的CPU使用率增加。

死锁

死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都抑制处于阻塞状态并无法进行下去，此时称系统处于死锁状态或系统产生了死锁。

软中断/硬中断

**硬中断：**我们通常所说的中断指的是硬中断(hardirq)。由与系统相连的外设(比如网卡、硬盘)自动产生的。主要是用来通知操作系统系统外设状态的变化。
**软中断：**1、通常是硬中断服务程序对内核的中断；2、为了满足实时系统的要求，中断处理应该是越快越好。

linux为了实现这个特点，当中断发生的时候，硬中断处理那些短时间就可以完成的工作，而将那些处理事件比较长的工作，放到中断之后来完成，也就是软中断(softirq)来完成。

毛刺

在短暂的某一刻，服务器性能指标（如流量、磁盘IO、CPU使用率等）远大于该时刻前后时间段。毛刺的出现代表这服务器资源利用不均匀，不充分，容易诱发其他更严重的问题。

重放攻击

攻击者发送一个目的主机已接收过的包，来达到欺骗系统的目的，主要用于身份认证过程，破坏认证的正确性。它是一种攻击类型，这种攻击会不断恶意或欺诈性地重复一个有效的数据传输，重放攻击可以由发起者，也可以由拦截并重发该数据的敌方进行。攻击者利用网络监听或者其他方式盗取认证凭据，之后再把它重新发给认证服务器。

网络孤岛

网络孤岛指集群环境中，部分机器与整个集群失去网络连接，分裂为一个小集群并且发生数据不一致的状况。

数据倾斜

对于集群系统，一般缓存是分布式的，即不同节点负责一定范围的缓存数据。我们把缓存数据分散度不够，导致大量的缓存数据集中到了一台或者几台服务节点上，称为数据倾斜。一般来说数据倾斜是由于负载均衡实施的效果不好引起的。

脑裂

脑裂是指在集群系统中，部分节点之间网络不可达而引起的系统分裂，不同分裂的小集群会按照各自的状态提供服务，原本的集群会同时存在不一致的反应，造成节点之间互相争抢资源，系统混乱，数据损坏。

监控告警

服务监控

服务监控主要目的在服务出现问题或者快要出现问题时能够准确快速地发现以减小影响范围。服务监控一般有多种手段，按层次可划分为：

系统层（CPU、网络状态、IO、机器负载等）
应用层（进程状态、错误日志、吞吐量等）
业务层（服务/接口的错误码、响应时间）
用户层（用户行为、舆情监控、前端埋点）

全链路监控

**服务拨测：**服务拨测是探测服务（应用）可用性的监控方式，通过拨测节点对目标服务进行周期性探测，主要通过可用性和响应时间来度量，拨测节点通常有异地多个。
**节点探测：**节点探测是用来发现和追踪不同的机房（数据中心）节点之间网络可用性和通畅性的监控方式，主要通过响应时间、丢包率、跳数来度量，探测方法一般是ping、mtr或其他私有协议。
**告警过滤：**对某些可预知的告警进行过滤，不进入告警统计的数据，如少量爬虫访问导致的http响应500错误，业务系统自定义异常信息等。
**告警去重：**当一个告警通知负责人后，在这个告警恢复之前，不会继续收到相同的告警。
**告警抑制：**为了减少由于系统抖动带来的干扰，还需要实现抑制，例如服务器瞬间高负载，可能是正常的，只有持续一段时间的高负载才需要得到重视。
**告警恢复：**开发/运维人员不仅需要收到告警通知，还需要收到故障消除告警恢复正常的通知。
**告警合并：**对同一时刻产生的多条相同告警进行合并，如某个微服务集群同一时刻出现多个子服务负载过高的告警，需要合并成为一条告警。
**告警收敛：**有时某个告警产生时，往往会伴随着其它告警。这时可以只对根本原因产生告警，其它告警收敛为子告警一并发送通知。如云服务器出现CPU负载告警时往往伴随其搭载的所有系统的可用性告警。
**故障自愈：**实时发现告警，预诊断分析，自动恢复故障，并打通周边系统实现整个流程的闭环。

服务治理

微服务

微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间相互协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务和服务之间采用轻量级的通信机制相互沟通（通常是基于HTTP的Restful API).每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。

服务发现

服务发现是指使用一个注册中心来记录分布式系统中的全部服务的信息，以便其他服务能够快速的找到这些已注册的服务。服务发现是支撑大规模 SOA 和微服务架构的核心模块，它应该尽量做到高可用。

流量削峰

如果观看抽奖或秒杀系统的请求监控曲线，你就会发现这类系统在活动开放的时间段内会出现一个波峰，而在活动未开放时，系统的请求量、机器负载一般都是比较平稳的。为了节省机器资源，我们不可能时时都提供最大化的资源能力来支持短时间的高峰请求。所以需要使用一些技术手段，来削弱瞬时的请求高峰，让系统吞吐量在高峰请求下保持可控。削峰也可用于消除毛刺，使服务器资源利用更加均衡和充分。常见的削峰策略有队列，限频，分层过滤，多级缓存等。

版本兼容

在升级版本的过程中，需要考虑升级版本后，新的数据结构是否能够理解和解析旧数据，新修改的协议是否能够理解旧的协议以及做出预期内合适的处理。这就需要在服务设计过程中做好版本兼容。

过载保护

过载是指当前负载已经超过了系统的最大处理能力，过载的出现，会导致部分服务不可用，如果处置不当，极有可能引起服务完全不可用，乃至雪崩。过载保护正是针对这种异常情况做的措施，防止出现服务完全不可用的现象。

服务熔断

服务熔断的作用类似于我们家用的保险丝，当某服务出现不可用或响应超时的情况时，为了防止整个系统出现雪崩，暂时停止对该服务的调用。

服务降级

服务降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行。降级往往会指定不同的级别，面临不同的异常等级执行不同的处理。

根据服务方式：可以拒接服务，可以延迟服务，也有时候可以随机服务。
根据服务范围：可以砍掉某个功能，也可以砍掉某些模块。

总之服务降级需要根据不同的业务需求采用不同的降级策略。主要的目的就是服务虽然有损但是总比没有好。

熔断VS降级

相同点：目标一致，都是从可用性和可靠性出发，为了防止系统崩溃；用户体验类似，最终都让用户体验到的是某些功能暂时不可用；
不同点：触发原因不同，服务熔断一般是某个服务（下游服务）故障引起，而服务降级一般是从整体负荷考虑；

服务限流

限流可以认为服务降级的一种，限流就是限制系统的输入和输出流量已达到保护系统的目的。一般来说系统的吞吐量是可以被测算的，为了保证系统的稳定运行，一旦达到的需要限制的阈值，就需要限制流量并采取一些措施以完成限制流量的目的。比如：延迟处理，拒绝处理，或者部分拒绝处理等等。

故障屏蔽

将故障机器从集群剔除，以保证新的请求不会分发到故障机器。

测试方法

黑盒/白盒测试

黑盒测试不考虑程序内部结构和逻辑结构，主要是用来测试系统的功能是否满足需求规格说明书。一般会有一个输入值，一个输入值，和期望值做比较。

白盒测试主要应用在单元测试阶段，主要是对代码级的测试，针对程序内部逻辑结构，测试手段有：语句覆盖、判定覆盖、条件覆盖、路径覆盖、条件组合覆盖

单元/集成/系统/验收测试

软件测试一般分为4个阶段：单元测试、集成测试、系统测试、验收测试。

**单元测试：**单元测试是对软件中的最小可验证单元进行检查和验证，如一个模块、一个过程、一个方法等。单元测试粒度最小，一般由开发小组采用白盒方式来测试，主要测试单元是否符合“设计”。
**集成测试：**集成测试也叫做组装测试，通常在单元测试的基础上，将所有的程序模块进行有序的、递增的测试。集成测试界于单元测试和系统测试之间，起到“桥梁作用”，一般由开发小组采用白盒加黑盒的方式来测试，既验证“设计”，又验证“需求”。
**系统测试：**系统测试时将经过集成测试的软件，作为计算机系统的一部分，与系统中其他部分结合起来，在实际运行环境下进行一系列严格有效的测试，以发现软件潜在的问题，保证系统的正常运行。系统测试的粒度最大，一般由独立测试小组采用黑盒方式来测试，主要测试系统是否符合“需求规格说明书”。
**验收测试：**验收测试也称交付测试，是针对用户需求、业务流程进行的正式的测试，以确定系统是否满足验收标准，由用户、客户或其他授权机构决定是否接受系统。验收测试与系统测试相似，主要区别是测试人员不同，验收测试由用户执行。

回归测试

当发现并修改缺陷后，或在软件中添加新的功能后，重新测试。用来检查被发现的缺陷是否被改正，并且所做的修改没有引发新的问题。

冒烟测试

这一术语源自硬件行业。对一个硬件或硬件组件进行更改或修复后，直接给设备加电。如果没有冒烟，则该组件就通过了测试。在软件中，“冒烟测试”这一术语描述的是在将代码更改嵌入到产品的源树中之前对这些更改进行验证的过程。

冒烟测试是在软件开发过程中的一种针对软件版本包的快速基本功能验证策略，是对软件基本功能进行确认验证的手段，并非对软件版本包的深入测试。

比如：对于一个登录系统的冒烟测试，我们只需测试输入正确的用户名、密码，验证登录这一个核心功能点，至于输入框、特殊字符等，可以在冒烟测试之后进行。

性能测试

性能测试是通过自动化的测试工具模拟多种正常、峰值以及异常负载条件来对系统的各项性能指标进行测试。负载测试和压力测试都属于性能测试，两者可以结合进行。

通过负载测试，确定在各种工作负载下系统的性能，目标是测试当负载逐渐增加时，系统各项性能指标的变化情况。
压力测试是通过确定一个系统的瓶颈或者不能接受的性能点，来获得系统能提供的最大服务级别的测试。

基准测试

基准测试（Benchmark）也是一种性能测试方式，用来测量机器的硬件最高实际运行性能，以及软件优化的性能提升效果, 同时也可以用来识别某段代码的CPU或者内存效率问题. 许多开发人员会用基准测试来测试不同的并发模式, 或者用基准测试来辅助配置工作池的数量, 以保证能最大化系统的吞吐量.

A/B测试

A/B测试，是用两组及以上随机分配的、数量相似的样本进行对比，如果实验组和对比组的实验结果相比，在目标指标上具有统计显著性，那就可以说明实验组的功能可以导致你想要的结果，从而帮你验证假设或者做出产品决定。

代码覆盖测试

代码覆盖（Code coverage）是软件测试中的一种度量，描述程式中源代码被测试的比例和程度，所得比例称为代码覆盖率。在做单元测试时，代码覆盖率常常被拿来作为衡量测试好坏的指标，甚至，用代码覆盖率来考核测试任务完成情况，比如，代码覆盖率必须达到80%或 90%。于是乎，测试人员费尽心思设计案例覆盖代码。

发布部署

DEV/PRO/FAT/UAT

pro（Production environment）：生产环境，面向外部用户的环境，正式环境，连接上互联网即可访问。
sit(System Integration Test ): 系统集成测试，开发人员自己测试流程是否走通。
uat(User Acceptance Test environment): 用户验收测试环境，用于生产环境下的软件测试者测试使用。
test: 测试环境，外部用户无法访问，专门给测试人员使用的，版本相对稳定。
pre ：灰度环境，外部用户可以访问，但是服务器配置相对低，其它和生产一样，外部用户可以访问，版本发布初期，正式版本发布前。
dev （Development environment）：开发环境，外部用户无法访问，开发人员使用，版本变动很大。
fat (Feature Acceptance Test environment) : 功能验收测试环境，用于软件测试者测试使用

灰度发布

灰度发布是指在升级版本过程中，通过分区控制，白名单控制等方式对一部分用户先升级产品特性，而其余用户则保持不变，当一段时间后升级产品特性的用户没有反馈问题，就逐步扩大范围，最终向所有用户开放新版本特性，灰度发布可以保证整体系统的稳定，在初始灰度的时候就可以发现、修改问题，以保证其影响度。

回滚 (Rollback)

指的是程序或数据处理错误时，将程序或数据恢复到上一次正确状态(或者是上一个稳定版本)的行为。

关于JDK源码：我想聊聊如何更高效地阅读

Mon, 22 Mar 2021 01:30:00 GMT

为什么要看JDK源码

一，JDK源码是其它所有源码的基础，看懂了JDK源码再看其它的源码会达到事半功倍的效果。

二，JDK源码中包含大量的数据结构知识，是学习数据结构很好的资料，比如，链表、队列、散列表、红黑树、跳表、桶、堆、双端队列等。

三、JDK源码中包含大量的设计模式，是学习设计模式很好的资料，比如，适配器模式、模板方法模式、装饰器模式、迭代器模式、代理模式、工厂模式、命令模式、状态模式等。

三，JDK源码中包含大量Java的高阶知识，比如弱引用、Unsafe、CAS、锁原理、伪共享等，不看源码是很难学会这些知识的。

四，面试时更好地收割offer，这可能是很多同学最初的想法，其实真正看多了源码，这一点可能并不是太重要了，因为你会发现更广阔的世界。

五，我认为最重要的，阅读源码是对思维的一种锻炼，是学习优秀设计的最佳途径

JDK源码的阅读顺序

JDK 中的代码非常多，不可能、也没必要全部读完，因此要有的放矢。从整体上来讲，我分成了以下几个部分：

基础类

基础类，是指组成JDK源码地基的一部分类。

比如包装类、反射类、工具类等，这些类有个共同点，就是代码逻辑相对简单，不存在数据结构、复杂运算等问题。

对于基础类，我的建议是自己从头到尾浏览一遍，对于看不懂的地方可以写测试用例或者上网查查资料。比如，Integer里面有个IntegerCache内部类你可能不知道干嘛的，这时候光看代码是没用的，只能上网查查资料了，也不能盲目地死磕。

简单集合

简单集合，是指不存在多线程安全问题的集合。

这部分集合一般用在单线程中，或者方法体中，但是他们用到了很多的数据结构，所以需要一定的数据结构知识。

对于简单集合，我的建议是先弄明白底层的数据结构知识，再去看源码，这样可能会轻松一些。当然，我后面也会出数据结构系列的。

原子类

原子类，是指在多线程环境下能够保证原子性的类。

这部分类主要包括Atomic开头和Adder结尾的类，位于juc下面的atomic包中。

对于原子类，我的建议是先去了解底层的Unsafe、CAS、伪共享等概念，再去看最简单的AtomicInteger，最后再看LongAdder这种复杂的类。其中，断点调试是不可或缺的手段。

说句实话，LongAdder这个类能学到很多高阶的知识，非常推荐把这个类研究透彻，后面再去看Disruptor、Netty等源码会事半功倍。

同步器

同步器，是指为了控制多个线程的竞争关系而存在的类或者关键字等，，它们可以说是Java中最重要的内容，没有它们就无法控制多线程的正常运转。

这部分内容主要包括synchronized关键字、volatile关键字、重入锁、读写锁、倒计时器、信号量、回环栅栏、阶段器、分布式锁的实现等等。

对于同步器，我的建议是先了解内存模型、可见性、原子性、有序性、Happens-Before等基本概念，再尝试阅读这部分的源码，最后再归纳出属于你自己理解的“同步器的原理”。

并发集合

并发集合，是指多线程环境下能够保证数据一致性的集合。

这部分集合主要是运用在多线程环境下，只有极个别类牵涉到高级的数据结构，更多的是锁、CAS、volatile、自旋等高阶技巧的运用。

对于并发集合，我的建议有三点：

一定要在同步器之后阅读
数据结构先搞透，比如ConcurrentSkipList
利用IDEA的Thread级别的断点，不断调试，不断调试，不断调试

线程（池）类

线程（池）类，是指跟线程和线程池相关的类。

这部分类主要包含Thread、ThreadLocal、三种线程池等。

对于线程（池）类，我的建议是先从整体上把握，再分成几个块来看，看哪块的东西就只看那块的东西，不要管其它的代码，即要搞清楚你的重点在哪里，比如，看线程运行的流程就不要管状态的事，凡是牵涉到状态的代码全部跳过，反之亦然，都看完了，再串一起看。

IO/NIO类

IO类，是指跟输入输出流相关的类，这部分类主要包括文件操作相关的类以及网络IO相关的类。

对于IO类，我的建议是简单浏览，做到心里有数即可，用到的时候再去查都可以。

但是对于nio相关的类，还是要好好研究的，这部分类我们放在Netty源码阅读的相关章节中一起学习。

其它类

其它类，工作中遇到了可以点进去看看，但是不建议抽出时间单独去研究，比如，时间类、awt类，看的必要性不是很大。

如何阅读集合

首页了解各个集合特点，可以画个思维导图或者啥的助于理解

如何阅读具体一个类

如何阅读一个类的源码呢？主要步骤大概是：

先读接口代码。包括接口说明文档、各个方法的定义和说明文档。
再读实现类的主要方法实现，通常有以下两条主线入口：构造方法和常用方法

在 Java 中，接口通常意味着是一种“标准”、或者“协议”。一个接口可以有多个实现类，它们都会按照接口的这种标准来实现接口的各个方法。因此，理解了一个方法的定义，再去看它的实现会更容易理解。

下面以常用的 ArrayList 为例，分析如何去阅读它的源码。

继承结构

首先看下 ArrayList 的继承结构：

ArrayList：可以看到它实现了很多接口，其中三个接口 Cloneable、RandomAccess、Serializable 都是空的，可以暂时忽略。主要去看 Iterable、Collection 以及 List 接口的方法定义。

Iterable 接口：

Collection 接口：

List 接口：

看起来方法挺多，其实不少都是我们平时会用到的，大部分理解起来并不困难，而且方法也都有注释。这部分难度不大。

接下来根据前面提到的两条主线入口，分析 ArrayList 的源码如何阅读。

构造器

分析一个类的源码时，构造器通常是一个好的切入点。比如 ArrayList 的三个构造器如下：

public ArrayList() {     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }  public ArrayList(int initialCapacity) {     if (initialCapacity > 0) {         this.elementData = new Object[initialCapacity];     } else if (initialCapacity == 0) {         this.elementData = EMPTY_ELEMENTDATA;     } else {         throw new IllegalArgumentException("Illegal Capacity: "+                                            initialCapacity);     } }  public ArrayList(Collection<? extends E> c) {     elementData = c.toArray();     if ((size = elementData.length) != 0) {         // c.toArray might (incorrectly) not return Object[] (see 6260652)         if (elementData.getClass() != Object[].class)             elementData = Arrays.copyOf(elementData, size, Object[].class);     } else {         // replace with empty array.         this.elementData = EMPTY_ELEMENTDATA;     } }

构造器中有不少成员变量，比如 elementData、EMPTY_ELEMENTDATA、DEFAULTCAPACITY_EMPTY_ELEMENTDATA 等，继续跟进这几个变量：

private static final Object[] EMPTY_ELEMENTDATA = {};  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  transient Object[] elementData; // non-private to simplify nested class access

由此可以得知，当我们写了 new ArrayList() 时，它的内部到底做了些什么。

常用方法

除了构造器，常用方法也是一个主要的入口，比如 add、remove 等。

add 方法实现：

public boolean add(E e) {     ensureCapacityInternal(size + 1);  // Increments modCount!!     elementData[size++] = e;     return true; }  private void ensureCapacityInternal(int minCapacity) {     ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }

可以一行行跟进代码，查看 add 方法内部到底做了什么。其他方法的套路也是如此，不再一一说明。按照这样一条条主线走下来，就可以对 ArrayList 的实现原理有个整体的认知了。整体部分搞清楚之后，接下来还可以去读一些不太常用的方法，包括剩余的所有部分。

JDK源码的阅读方法

一，设定目标，目标越明确越好，不要设定得过于虚无缥缈。比如，熟悉HashMap的数据结构，这就是一个很明确的目标；再比如，看懂HashMap的源码，这就很缥缈了。

二，尝试自己提出问题，先自己根据某个知识点发散提出问题。比如，关于HashMap你能想到哪些知识点，这部分可以借助思维导图无限想象，后面有机会我给大家分享一下思维导图联想法。

三，尝试网络查询问题，打开度娘，输入你要学习的知识点，把前面几页统统点开，看看别人都遇到了哪些问题，当然，能力强的同学也可以使用Google，这部分查询出来的问题也可以补充到你的思维导图中去。

四，尝试阅读源码，对于上面的问题，一个一个尝试去源码中寻找答案，由点及面，最后再总结整个大的知识点。

五，不断发现问题，在阅读源码的过程中可能又会发现新的问题，先跳过去，而是把它加到思维导图中，等当前的问题解决完了再去解决。

六，专注你的问题，在阅读源码的时候一定要专注于你当前的问题，不要受其它问题的干扰，比如看线程池任务执行的流程，你就不要管线程池状态的事情。

七，多做比较，横向比较和纵向比较，从多维度去比较。

八，多做实验，多多利用IDE的调试模式，不断修改断点，不断调试。

九，多与人交流，如果条件允许的话，多与周边的人一起交流，当然，也可以来骚扰我。

十，多做总结，对于自己解决的问题，一定要学会总结，多做学习笔记，当然，也欢迎来我这里投稿。

十一，耐心&坚持，阅读源码是一件非常枯燥而且枯燥的事情，一定要坚持坚持坚持。

Idea 打包成功，运行失败

Thu, 18 Mar 2021 01:36:00 GMT

最近开发中，发现一个奇怪的问题，用idea 的maven ，编译，打包都能够成功，项目中也没有爆红出错，但是你运行/调式SpringBoot的启动类的时候，会提示包**不存在。网上找了很多解决方案都没成功。最后终于成功了，特此记录分享下：

Idea Terminal 中输入 mvn idea:idea
File-Invadiate Cache/Restart ，清除缓存，重启

springboot自动判定空值

Thu, 25 Feb 2021 08:23:37 GMT

Spring Boot 参数校验

前言

搭建springboot项目，我们都是采用的Restful接口，那么问题来了，当前端调用接口或者是其他项目调用时，我们不能单一靠调用方来控制参数的准确性，自己也要对一些非空的值进行判定。

方案

按照我们以往的做法，都是对request中的参数一个一个进行非空判定。

Model:

publicclassOrder{  private Long userID;  private Long addressID;  private String comment; }

Controller:

@PostMapping("/createOrders") publicStringcreateOrders(@RequestBodyOrderdto){   if(dto.getUserID==null){        return "userID不能为空";     }   if(dto.getAddressID==null){         return "addressID不能为空";     }   if(dto.getComment==null){         return "comment不能为空";     }   return "sucess";  }

这种做法首先是可取的，能达到我们的要求，但是这样如果model字段过多，判定的就很多，相对维护起来就不是那么方便，其次增加controller层的负担，既然我们来到spring4 的时代，就应该适应使用注解的趋势，下面是使用注解后的比变化。

Model:

publicclassOrder{   @NotNull(message = "用户ID不能为空")  private Long userID;   @NotNull(message = "收货人地址id不能为空")  private Long addressID;   @NotBlank(message = "备注不为空")  private String comment; }

Controller:

@PostMapping("/createOrders") publicStringcreateOrders(@RequestBody @Valid Order dto,BindingResult results) {    if (results.hasErrors()){    return results.getFieldError().getDefaultMessage();           }   return "success";  }

这样我们就只需要在model字段上加上非空验证和相应提示语就好了。备注:@Valid 和@Validated效果一样，可以加在controller中，也可以加载dto上

常用的校验注解

1. javax.validation.constraints.NotNull  2. @Null 被注释的元素必须为null 3. @NotNull 被注释的元素不能为null  4. @AssertTrue 被注释的元素必须为true 5. @AssertFalse 被注释的元素必须为false  6. @Min(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最小值  7. @Max(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最大值 8. @DecimalMin(value) 被注释的元素必须是一个数字，其值必须大于等于指定的 最小值 9. @DecimalMax(value) 被注释的元素必须是一个数字，其值必须小于等于指定的 最大值 10. @Size(max,min) 被注释的元素的大小必须在指定的范围内。 11. @Digits(integer,fraction) 被注释的元素必须是一个数字，其值必须在可接 受的范围内 12. @Past 被注释的元素必须是一个过去的日期 13. @Future 被注释的元素必须是一个将来的日期 14. @Pattern(regexp) 被注释的元素必须符合指定的正则表达式。 15. @Email 被注释的元素必须是电子邮件地址 16. @Length 被注释的字符串的大小必须在指定的范围内 17. @NotEmpty 被注释的字符串必须非空 18. @Range 被注释的元素必须在合适的范围内

其他

@Valid 注解类型的使用: @Null 限制只能为null @NotNull 限制必须不为null @AssertFalse 限制必须为false, @AssertTrue 限制必须为true, @DecimalMax(value) 限制必须为一个不大于指定值的数字 @DecimalMin(value) 限制必须为一个不小于指定值的数字 @Digits(integer,fraction) 限制必须为一个小数，且整数部分的位数不能超过integer，小数部分的位数不能超过 fraction @Future 限制必须是一个将来的日期 @Max(value) 限制必须为一个不大于指定值的数字 @Min(value) 限制必须为一个不小于指定值的数字 @Past 限制必须是一个过去的日期 @Pattern(value) 限制必须符合指定的正则表达式 @Size(max,min) 限制字符长度必须在min到max之间 @Past 验证注解的元素值(日期类型)比当前时间早 @NotEmpty  验证注解的元素值不为null且不为空(字符串长度不为0、集合大小不为0)  @NotBlank  验证注解的元素值不为空(不为null、去除首位空格后长度为0)，不同于@NotEmpty， @NotBlank只应用于字符串且在比较时会去除字符串的空格 @Email 验证注解的元素值是Email，也可以通过正则表达式和flag指定自定义的email格式

问题

@NotBlank无效可能你为了使用@NotBlank引入了包

<dependency>  <groupId>jakarta.validation</groupId>  <artifactId>jakarta.validation‐api</arti  <version>2.0.2</version> </dependency>

之所以需要引入这个包，是因为你的spring boot 版本是2.3.1或者更高，此时的spring boot 已经不在内置验证。此时需要引入包哪怕与@Valid搭配也是没有效果，大概率是因为我们少导入了一个包hibernate- validator，我们需要同时导入以下两个包

  <dependency>   <groupId>org.springframework.boot</groupId>   <artifactId>spring‐boot‐starter‐validation</artifactId>  </dependency>  <!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator --> <dependency>   <groupId>org.hibernate.validator</groupId>   <artifactId>hibernate-validator</artifactId>   <version>6.0.2.Final</version> </dependency>

或者是不导入以上两个包，直接将spring boot修改为2.1.1均可以解决此问题

<dependency>   <groupId>org.springframework.boot</groupId>   <artifactId>spring‐boot‐starter‐web</artifactId>   <version>2.1.1.RELEASE</version> </dependency>

扩展

1.@NotNull:不能为null，但可以为empty  ("",""," ")   2.@NotEmpty:不能为null，而且长度必须大于0  (" "," ")  3.@NotBlank:只能作用在String上，不能为null，而且调用trim()后，长度必须大于0("test") 即:必须有实际字符   @NotNull:The CharSequence,Collection,Map or Array object is not null,but can be empty.  @NotEmpty:The CharSequence,Collection,Map or Array object is not null and size > 0 .  @NotBlank:The string is not null and the trimmed length is greater than zero.  Stringname=null; @NotNull:false @NotEmpty:false @NotBlank:false  Stringname=""; @NotNull:true @NotEmpty:false @NotBlank:false  Stringname=" "; @NotNull:true @NotEmpty:true @NotBlank:false  Stringname="Greatanswer!"; @NotNull:true @NotEmpty:true @NotBlank:true

Mysql配置详解

Tue, 23 Feb 2021 02:05:00 GMT

一、安装

1、docker 安装

DOCKER_NAME=mysql MYSQL_ROOT_PASSWORD=78Jikbfz6zKYfPjC # 创建挂载目录 mkdir -p /data/$DOCKER_NAME mkdir -p /data/$DOCKER_NAME/conf mkdir -p /data/$DOCKER_NAME/data mkdir -p  /data/$DOCKER_NAME/sql  # 编写初始化sql vi /data/$DOCKER_NAME/sql/init.sql  # 编写mysql配置文件 vi /data/$DOCKER_NAME/conf/my.cnf  # 下载容器镜像 # docker search mysql docker pull mysql:5.7  # 运行容器 docker run --name $DOCKER_NAME \ --restart=always \ -p 3306:3306 \ -v /data/$DOCKER_NAME/conf:/etc/mysql \ -v /data/$DOCKER_NAME/data:/var/lib/mysql \ -e MYSQL_ROOT_PASSWORD=$MYSQL_ROOT_PASSWORD \ -d mysql:5.7  # 执行初始化脚本 mysql -uroot -p$MYSQL_ROOT_PASSWORD -h 127.0.0.1 -P 3306 < /data/$DOCKER_NAME/sql/init.sql  # 登陆验证 mysql -uroot -p$MYSQL_ROOT_PASSWORD -h 127.0.0.1 -P 33307 mysql> show databases ;

2、编译安装

3、Yum安装

二、配置文件

# 客户端登录配置 [client] port = 3306 # 端口号 socket = /var/lib/mysql/mysql.sock # 套接字文件  # 客户端命令行配置 [mysql] no-auto-rehash # 默认不自动补全 auto-rehash自动补全  # 服务优化配置 [mysqld] skip-grant-tables # 跳过登录验证 user = mysql # 默认启动用户，一般不需要修改，可能出现启动不成功 port = 3306 # 端口号 socket = /var/lib/mysql/mysql.sock # 套接字文件 （套接字方式登陆比TCP/IP方式连接快） character-set-server = utf8mb4 # 设置数据库服务器默认编码 utf-8 basedir = /usr/local/mysql # 数据库安装目录--指定此参数可解决相对路径造成的问题 datadir = /var/lib/mysql #数据库目录，数据库目录切换时需要用到 pid-file = /var/run/mysqld/mysqld.pid #mysql进程文件，可指定自己的进程文件 external-locking = FALSE #外部锁定(非多服务器可不设置该选项，默认skip-external-locking) skip-external-locking #跳过外部锁定 （避免多进程环境下的external locking--锁机制） skip-name-resolve = 1 #跳过主机名解析，直接IP访问，可提升访问速度 log-error = /data/log/mysqld_error.log #错误日志文件  # 重要配置 max_connections = 5000 # 最大连接数 max_connect_errors = 6000 # 客户端请求异常中断次数 max_allowed_packet = 32M # 限制单条数据大小 sort_buffer_size = 8M # 每个连接独享内存数，如：500连接 * 8 = 4G 内存 join_buffer_size = 8M # 表关联缓存大小，每个连接独享  # 数据库引擎相关参数 default-storage-engine = InnoDB # 默认数据库引擎  # 性能分析 slow-query-log = 1 # 是否记录慢查询日志 long_query_time = 2 # 慢查询超时时间设置 slow-query-log-file=/var/log/mysql/query-slow.log #慢查询日志记录文件  # 二进制文件设置 log_bin = = /data/log/mysql/bin-log.log # 开启bin-log日志，指定存储路径 binlog_format = ROW # ROW(基于行的复制--安全，但是注意并发) STATEMENT(基于sql语句的复制)，MIXED(混合模式复制) binlog_cache_size = 4M # 二进制日志缓存，提高log-bin记录效率 log_bin_trust_function_creators = 1 #主从复制是需要注意，为了保证主从复制完全一致，需要开启此选项，主从默认阻止函数创建 max_binlog_size = 1G # 二进制日志文件大小默认1G 要求大于4096 小于1G expire_logs_days = 7 # 清除过期日志  # 主从复制相关 server-id = 2020 #主从复制必须，并且各服务器具有唯一性 log_slave_updates #配置从服务器的更新是否写入二进制日志，默认是不打开的 replicate-ignore-db = mysql #主从复制默认忽略的数据库，可用","分隔或使用多条记录 # replicate-do-db=qrs,login #主从复制指定数据库,","号隔开或使用多条记录  #数据库全量备份 [mysqldump]  quick #强制mysqldump从服务器一次一行地检索表中的行 max_allowed_packet = 32M #可接收数据包大小  [isamchk] #在mysqld服务器不使用的情况下修复表或在崩溃状态下恢复表 key_buffer = 1024M sort_buff_size =1024M read_buffer = 16M write_buffer = 16M  [myisamchk] #在mysqld服务器不使用的情况下修复表或在崩溃状态下恢复表 key_buffer = 1024M  sort_buff_size = 1024M read_buffer = 16M write_buffer = 16M  [mysqld_safe] #safe方式启动数据库，相比于mysqld,会在服务启动后继续监控服务状态，死机时重启 open-files-limit = 8192

三、sql语句

四、备份

1、mysqldump

#!/bin/bash  # 建造AR-mysql server_host= server_port= server_user= server_passwd= back_date=`date "+%Y-%m-%d"` back_time=`date "+%H:%M:%S"` back_path=/data/backup/$back_date/mysql  # 切换到备份目录 mkdir -p $back_path cd $back_path   # db列表(过滤不备份库) db_list=`mysql -h $server_host \ -P $server_port \ -u$server_user \ -p$server_passwd \ -e "show databases;" \ | grep -Ev "Database|information_schema|mysql|test|performance_schema|sys" `  # 遍历备份 for db in $db_list;do sql_name=${db}_${back_time}.sql mysqldump -h $server_host \ -P $server_port \ -u$server_user \ -p$server_passwd \ --databases $db > $sql_name done  # 删除过期文件 find /data/backup/ -mindepth 2 -type d -mtime +3 -exec rm -rf {} \;

--all-databases \ # 备份所有服务器 --compact \ # 压缩模式 --comments \ # 添加注释信息 --complete-insert \ # 输出完成的插入语句 --lock-tables \ # 备份前，锁定所有数据库表 --no-create-db | --no-create-info \ # 禁止生成创建数据库语句 --force \ # 当出现错误时仍然继续备份操作 --default-character-set \ # 指定默认字符集 --add-locks  --no-data \ # 不到处

minio安装使用

Tue, 23 Feb 2021 02:02:00 GMT

一、安装

docker

docker pull minio/minio:latest  DOCKER_NAME=minio MINIO_ACCESS_KEY=admin MINIO_SECRET_KEY=admin123  mkdir -p /data/$DOCKER_NAME/data mkdir -p /data/$DOCKER_NAME/conf  docker run --name $DOCKER_NAME \ -p 9000:9000 \ -d \ -e "MINIO_ACCESS_KEY=$MINIO_ACCESS_KEY" \ -e "MINIO_SECRET_KEY=$MINIO_SECRET_KEY" \ -v /data/$DOCKER_NAME/data:/data \ -v /data/$DOCKER_NAME/conf:/root/.minio \ minio/minio server /data   # 客户端 docker pull minio/mc  docker run -it --entrypoint=/bin/sh minio/mc  mc config host add myminio http://192.168.0.1:9000 $MINIO_ACCESS_KEY  $MINIO_SECRET_KEY   # 配置指定桶开放下载 mc policy set public myminio/backup

源码

...

二、mc客户端使用

bucket桶策略

cat > getonly.json << EOF {   "Version": "2012-10-17",    "Statement": [     {       "Effect": "Allow",       "Action": [            //  可以做出的行动（权限）         "s3:ListAllMyBuckets",          //  查看所有的“桶”列表     "s3:ListBucket",                //  查看桶内的对象列表     "s3:GetBucketLocation",              "s3:GetObject",                //  下载对象     "s3:PutObject",                //  上传对象     "s3:DeleteObject"               //  删除对象                ],       "Resource": [         "arn:aws:s3:::my-bucketname/*"  // （应用到的资源，*表示所有，也可以用路径来控制范围。arn:aws:s3是命名空间）       ],       "Sid": ""     }   ] } EOF

# 添加该策略 mc admin policy add myminio getonly getonly.json

管理用户

# 创建用户 mc admin user add myminio newuser password  # 授权策略 mc admin policy set myminio getonly user=newuser  # 禁用用户 mc admin user disable myminio newuser  # 列出所有用户 mc admin user list myminio

管理组

# 创建组 mc admin group add myminio newgroup newuser  # 授权策略 mc admin policy set myminio getonly group=newgroup  #     # 禁用组 mc admin group disable myminio newgroup  # 列出所有组

三、使用问题

1、分享链接无法访问

`nginx代理配置`

 server {   listen 80;   server_name minio.maruifu.cn;   location / {     proxy_set_header Host $http_host;     proxy_set_header X-Real-IP $remote_addr;     proxy_set_header X-Forwarded-Proto $scheme;     proxy_set_header X-Forwarded-Host $http_host;     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;     proxy_pass http://127.0.0.1:9000;   } }

`配置bucket访问权限`

minio默认bucket无读取和写入权限

1、点击三个点按钮

2、编辑策略

3、添加权限

三、API

1、golang

文档地址：https://docs.minio.io/docs/golang-client-quickstart-guide.html

连接minio服务器

package main  import (  "log"   "github.com/minio/minio-go/v7"  "github.com/minio/minio-go/v7/pkg/credentials" )  func main() {  endpoint := "minio.dongzi.online"  accessKeyID := "dongdonghe"   // ID  secretAccessKey := "19981014" // Secret  useSSL := false               // ssl配置   // Initialize minio client object.  minioClient, err := minio.New(endpoint, &minio.Options{   Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),   Secure: useSSL,  })  if err != nil {   log.Fatalln(err)  }  log.Printf("%#v\n", minioClient) // minioClient is now setup }

创建bucket

func createBucket(mc *minio.Client, bucketName string) (err error) {  err = mc.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: false}) // Region : 存储桶（us-east-1：默认）  if err != nil {   fmt.Println(err)   return  }  fmt.Println("Successfully created mybucket.")  return }

列出所有bucket

func listBucket(mc *minio.Client) (err error) {  buckets, err := mc.ListBuckets(context.Background())  if err != nil {   fmt.Println(err)   return  }  for _, bucket := range buckets {   fmt.Printf("bucket名称：%s，创建时间：%s\n", bucket.Name, bucket.CreationDate)  }  return }

检查bucket是否存在

func bucketExits(mc *minio.Client, bucketName string) (err error) {  found, err := mc.BucketExists(context.Background(), bucketName)  if err != nil {   fmt.Println(err)   return  }  if found {   fmt.Println("Bucket found")  } else {   fmt.Println("Bucket not found")  }  return }

删除bucket

func deleteBucket(mc *minio.Client, bucketName string) (err error) {  err = mc.RemoveBucket(context.Background(), bucketName)  if err != nil {   fmt.Println(err)   return  }  return }

获取bucket文件对象列表

func listObjs(mc *minio.Client, bucketName string) (err error) {  ctx, cancel := context.WithCancel(context.Background())  defer cancel()  objectCh := mc.ListObjects(ctx, bucketName, minio.ListObjectsOptions{   Prefix:    "制图", // 前缀条件   Recursive: true, // 循环  })  for object := range objectCh {   if object.Err != nil {    fmt.Println(object.Err)    return   }   fmt.Printf("文件名：%s，大小：%verb", object.Key, object.Size)  }  return }

上传文件

func uploadObject(mc *minio.Client, bucketName, objectName string, filePath string, contentType string) {  n, err := mc.FPutObject(context.Background(),   bucketName, // bucket   objectName, // 上传文件名称   filePath,   // 上传文件地址   minio.PutObjectOptions{ContentType: contentType}) // 上传文件类型  if err != nil {   log.Fatalln(err)  }   log.Printf("Successfully uploaded %s of size %d byte \n", objectName, n.Size) }

Gateway--服务网关

Tue, 02 Feb 2021 12:58:00 GMT

网关简介

大家都都知道在微服务架构中，一个系统会被拆分为很多个微服务。那么作为客户端要如何去调用这么多的微服务呢?如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去调用。

这样的架构，会存在着诸多的问题:

客户端多次请求不同的微服务，增加客户端代码或配置编写的复杂性
认证复杂，每个服务都需要独立认证。
存在跨域请求，在一定场景下处理相对复杂。

上面的这些问题可以借助API网关来解决。所谓的API网关，就是指系统的统一入口，它封装了应用程序的内部结构，为客户端提供统一服务，一些与业务本身功能无关的公共逻辑可以在这里实现，诸如认证、鉴权、监控、路由转发等等。添加上API网关之后，系统的架构图变成了如下所示:

我们也可以观察下，我们现在的整体架构图:

在业界比较流行的网关，有下面这些:

Ngnix+lua:使用nginx的反向代理和负载均衡可实现对api服务器的负载均衡及高可用，lua是一种脚本语言,可以来编写一些简单的逻辑, nginx支持lua脚本
Kong:基于Nginx+Lua开发，性能高，稳定，有多个可用的插件(限流、鉴权等等)可以开箱即用。问题:只支持Http协议;二次开发，自由扩展困难;提供管理API，缺乏更易用的管控、配置方式。
Zuul :Netflflix开源的网关，功能丰富，使用JAVA开发，易于二次开发问题:缺乏管控，无法动态配置;依赖组件较多;处理Http请求依赖的是Web容器，性能不如Nginx
Spring Cloud Gateway:Spring公司为了替换Zuul而开发的网关服务，将在下面具体介绍。

**注意:**SpringCloud alibaba技术栈中并没有提供自己的网关，我们可以采用Spring Cloud Gateway来做网关

Gateway简介

Spring Cloud Gateway是Spring公司基于Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。它的目标是替代Netflflix Zuul，其不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如:安全，监控和限流。

优点:

性能强劲:是第一代网关Zuul的1.6倍
功能强大:内置了很多实用的功能，例如转发、监控、限流等
设计优雅，容易扩展

缺点:

其实现依赖Netty与WebFlux，不是传统的Servlet编程模型，学习成本高
不能将其部署在Tomcat、Jetty等Servlet容器里，只能打成jar包执行
需要Spring Boot 2.0及以上的版本，才支持

Gateway快速入门

要求: 通过浏览器访问api网关,然后通过网关将请求转发到商品微服务

基础版

第1步:创建一个 api-gateway 的模块,导入相关依赖

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <parent>     <artifactId>springcloud-alibaba</artifactId>     <groupId>cn.maruifu</groupId>     <version>1.0-SNAPSHOT</version> </parent>     <modelVersion>4.0.0</modelVersion>     <artifactId>api-gateway</artifactId>     <dependencies>         <!--gateway网关-->         <dependency>             <groupId>org.springframework.cloud</groupId>             <artifactId>spring-cloud-starter-gateway</artifactId>         </dependency>     </dependencies> </project>

第2步: 创建主类

package cn.maruifu; @SpringBootApplication public class GatewayApplication {     public static void main(String[] args) {          SpringApplication.run(GatewayApplication.class, args);      } }

第3步: 添加配置文件

server:   port: 7000 spring:   application:     name: api-gateway   cloud:     gateway:       routes: # 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务]         - id: product_route  # 当前路由的标识, 要求唯一           uri: http://localhost:8081 # 请求要转发到的地址           order: 1 # 路由的优先级,数字越小级别越高           predicates: # 断言(就是路由转发要满足的条件)             # 匹配路径转发             - Path=/product-serv/** # 当请求路径满足Path指定的规则时,才进行路由转发           filters: # 过滤器,请求在传递过程中可以通过过滤器对其进行一定的修改             - StripPrefix=1 # 转发之前去掉1层路径

第4步: 启动项目, 并通过网关去访问微服务

增强版

第1步:加入nacos依赖

<!--nacos客户端--> <dependency>  <groupId>com.alibaba.cloud</groupId>   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>  </dependency>

第2步:在主类上添加注解

@SpringBootApplication @EnableDiscoveryClient public class ApiGatewayApplication {  public static void main(String[] args) {    SpringApplication.run(ApiGatewayApplication.class, args);   } }

第3步:修改配置文件

server:   port: 7000 spring:   application:     name: api-gateway   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848     gateway:       discovery:         locator:           enabled: true       routes: # 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务]         - id: product_route  # 当前路由的标识, 要求唯一           uri: http://localhost:8081 # 请求要转发到的地址           order: 1 # 路由的优先级,数字越小级别越高           predicates: # 断言(就是路由转发要满足的条件)             # 匹配路径转发             - Path=/product-serv/** # 当请求路径满足Path指定的规则时,才进行路由转发           filters: # 过滤器,请求在传递过程中可以通过过滤器对其进行一定的修改             - StripPrefix=1 # 转发之前去掉1层路径

第4步:测试

简写版

第1步: 去掉关于路由的配置

server:   port: 7000 spring:   application:     name: api-gateway   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848     gateway:       discovery:         locator:           enabled: true # 让gateway可以发现nacos中的微服务

第2步: 启动项目，并通过网关去访问微服

这时候，就发现只要按照网关地址微服务接口的格式去访问，就可以得到成功响应。

Gateway核心架构

基本概念

路由(Route) 是 gateway 中最基本的组件之一，表示一个具体的路由信息载体。主要定义了下面的几个信息:

id，路由标识符，区别于其他 Route。
uri，路由指向的目的地 uri，即客户端请求最终被转发到的微服务。
order，用于多个 Route 之间的排序，数值越小排序越靠前，匹配优先级越高。
predicate，断言的作用是进行条件判断，只有断言都返回真，才会真正的执行路由。
fifilter，过滤器用于修改请求和响应信息。

执行流程

执行流程大体如下:

Gateway Client向Gateway Server发送请求
请求首先会被HttpWebHandlerAdapter进行提取组装成网关上下文
然后网关的上下文会传递到DispatcherHandler，它负责将请求分发给RoutePredicateHandlerMapping
RoutePredicateHandlerMapping负责路由查找，并根据路由断言判断路由是否可用
如果过断言成功，由FilteringWebHandler创建过滤器链并调用
请求会一次经过PreFilter--微服务-PostFilter的方法，最终返回响应

断言

Predicate(断言, 谓词) 用于进行条件判断，只有断言都返回真，才会真正的执行路由。

断言就是说: 在什么条件下才能进行路由转发

内置路由断言工厂

SpringCloud Gateway包括许多内置的断言工厂，所有这些断言都与HTTP请求的不同属性匹配。具体如下:

基于Datetime类型的断言工厂

此类型的断言根据时间做判断，主要有三个:
- AfterRoutePredicateFactory: 接收一个日期参数，判断请求日期是否晚于指定日期
- BeforeRoutePredicateFactory: 接收一个日期参数，判断请求日期是否早于指定日期
- BetweenRoutePredicateFactory: 接收两个日期参数，判断请求日期是否在指定时间段内
-After=2019-12-31T23:59:59.789+08:00[Asia/Shanghai]
基于远程地址的断言工厂

RemoteAddrRoutePredicateFactory:接收一个IP地址段，判断请求主机地址是否在地址段中

-RemoteAddr=192.168.1.1/24
基于Cookie的断言工厂 CookieRoutePredicateFactory:接收两个参数，cookie 名字和一个正则表达式。判断请求cookie是否具有给定名称且值与正则表达式匹配。 -Cookie=chocolate, ch.
基于Header的断言工厂

HeaderRoutePredicateFactory:接收两个参数，标题名称和正则表达式。判断请求Header是否具有给定名称且值与正则表达式匹配。 -Header=X-Request-Id, \d+
基于Host的断言工厂 HostRoutePredicateFactory:接收一个参数，主机名模式。判断请求的Host是否满足匹配规则。 -Host=**.testhost.org
基于Method请求方法的断言工厂 MethodRoutePredicateFactory:接收一个参数，判断请求类型是否跟指定的类型匹配。 -Method=GET
基于Path请求路径的断言工厂 PathRoutePredicateFactory:接收一个参数，判断请求的URI部分是否满足路径规则。 -Path=/foo/{segment}
基于Query请求参数的断言工厂 QueryRoutePredicateFactory :接收两个参数，请求param和正则表达式，判断请求参数是否具有给定名称且值与正则表达式匹配。 -Query=baz, ba.
基于路由权重的断言工厂 WeightRoutePredicateFactory:接收一个[组名,权重], 然后对于同一个组内的路由按照权重转发 routes: -id: weight_route1 uri: host1 predicates: -Path=/product/** -Weight=group3, 1 -id: weight_route2 uri: host2 predicates: -Path=/product/** -Weight= group3, 9

内置路由断言工厂的使用

接下来我们验证几个内置断言的使用:

server:   port: 7000 spring:   application:     name: api-gateway   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848     gateway:       discovery:         locator:           enabled: true       routes: # 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务]         - id: product_route  # 当前路由的标识, 要求唯一           uri: lb://service-product # 请求要转发到的地址           predicates: # 断言(就是路由转发要满足的条件)             # 匹配路径转发             - Path=/product-serv/** # 当请求路径满足Path指定的规则时,才进行路由转发             - Before=2022-02-18T00:00:00.000+08:00 #限制请求时间在2022-02-18之前 \- Method=POST #限制请求方式为POST           filters: # 过滤器,请求在传递过程中可以通过过滤器对其进行一定的修改             - StripPrefix=1 # 转发之前去掉1层路径

自定义路由断言工厂

我们来设定一个场景: 假设我们的应用仅仅让age在(min,max)之间的人来访问。

第1步:在配置文件中,添加一个Age的断言配置

spring:   application:     name: api-gateway   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848     gateway:       discovery:         locator:           enabled: true       routes:         - id: product-route         uri: lb://service-product         predicates:           - Path=/product-serv/**           - Age=18,60 # 限制年龄只有在18到60岁之间的人能访问 filters:           - StripPrefix=1

第2步:自定义一个断言工厂, 实现断言方法

package cn.maruifu.predicates;  import lombok.Data; import lombok.NoArgsConstructor; import org.apache.commons.lang3.StringUtils; import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory; import org.springframework.stereotype.Component; import org.springframework.web.server.ServerWebExchange;  import java.util.Arrays; import java.util.List; import java.util.function.Predicate; //自定义路由断言工厂 //泛型 用于接收一个配置类,配置类用于接收中配置文件中的配置 @Component public class AgeRoutePredicateFactory extends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {          public AgeRoutePredicateFactory(){             super(AgeRoutePredicateFactory.Config.class);         }         //用于从配置文件中获取参数值赋值到配置类中的属性上         @Override         public List<String> shortcutFieldOrder(){             //这里的顺序要跟配置文件中的参数顺序一致             return Arrays.asList("minAge","maxAge");         }         //断言         @Override         public Predicate<ServerWebExchange> apply( AgeRoutePredicateFactory.Config config){             return new Predicate<ServerWebExchange>(){                 @Override                 public boolean test(ServerWebExchange serverWebExchange){                     //从serverWebExchange获取传入的参数                     String ageStr=serverWebExchange.getRequest().getQueryParams().getFirst("age");                     if(StringUtils.isNotEmpty(ageStr)){                         int age=Integer.parseInt(ageStr);                          return age>config.getMinAge()&&age<config.getMaxAge();                     }                         return true;                     }            };         }      @Data     @NoArgsConstructor     public static class Config {         private int minAge;         private int maxAge;     }  }

第4步:启动测试

测试发现当age在(20,60)可以访问,其它范围不能访问  http://localhost:7000/product-serv/product/1?age=30  http://localhost:7000/product-serv/product/1?age=10

过滤器

三个知识点

作用: 过滤器就是在请求的传递过程中,对请求和响应做一些手脚
生命周期: Pre Post
分类: 局部过滤器(作用在某一个路由上) 全局过滤器(作用全部路由上)

在Gateway中, Filter的生命周期只有两个:“pre” 和 “post”。

PRE: 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
POST:这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。

Gateway 的Filter从作用范围可分为两种: GatewayFilter与GlobalFilter。

GatewayFilter:应用到单个路由或者一个分组的路由上。
GlobalFilter:应用到所有的路由上。

局部过滤器

局部过滤器是针对单个路由的过滤器。

内置局部过滤器

在SpringCloud Gateway中内置了很多不同类型的网关路由过滤器。具体如下:

内置局部过滤器的使用

server:   port: 7000 spring:   application:     name: api-gateway   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848     gateway:       discovery:         locator:           enabled: true       routes: # 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务]         - id: product_route  # 当前路由的标识, 要求唯一           uri: lb://service-product # 请求要转发到的地址           predicates: # 断言(就是路由转发要满足的条件)             # 匹配路径转发             - Path=/product-serv/** # 当请求路径满足Path指定的规则时,才进行路由转发           filters: # 过滤器,请求在传递过程中可以通过过滤器对其进行一定的修改             - StripPrefix=1 # 转发之前去掉1层路径             - SetStatus=2000 # 修改返回状态

自定义局部过滤

第1步:在配置文件中,添加一个Log的过滤器配置

server:   port: 7000 spring:   application:     name: api-gateway   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848       gateway:         discovery:           locator:             enabled: true # 让gateway可以发现nacos中的微服务         routes:           - id: consumer           uri: lb://consumer # lb指的是从nacos中按照名称获取微服务,并遵循负载均 衡策略           predicates:             - Path=/consumer-serv/**           filters:             - StripPrefix=1             - Log=true,false # 控制日志是否开启

第2步:自定义一个过滤器工厂,实现方法

package cn.maruifu.predicates;  import lombok.Data; import lombok.NoArgsConstructor; import org.springframework.cloud.gateway.filter.GatewayFilter; import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory; import org.springframework.stereotype.Component; import org.springframework.web.server.ServerWebExchange; import reactor.core.publisher.Mono;  import java.util.Arrays; import java.util.List;  //自定义局部过滤器 @Component public class LogGatewayFilterFactory extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> { //构造函数      public LogGatewayFilterFactory() {         super(LogGatewayFilterFactory.Config.class);     }      //读取配置文件中的参数 赋值到 配置类中     @Override     public List<String> shortcutFieldOrder() {         return Arrays.asList("consoleLog", "cacheLog");     }      //过滤器逻辑     @Override     public GatewayFilter apply(LogGatewayFilterFactory.Config config) {         return new GatewayFilter() {             @Override             public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {                 if (config.isCacheLog()) {                     System.out.println("cacheLog已经开启了....");                 }                 if (config.isConsoleLog()) {                     System.out.println("consoleLog已经开启了....");                 }                 return chain.filter(exchange);             }         };     }      //配置类 接收配置参数     @Data     @NoArgsConstructor     public static class Config {         private boolean consoleLog;         private boolean cacheLog;     } }

第3步:启动测试

全局过滤器

全局过滤器作用于所有路由, 无需配置。通过全局过滤器可以实现对权限的统一校验，安全性验证等功能。

内置全局过滤器

SpringCloud Gateway内部也是通过一系列的内置全局过滤器对整个路由转发进行处理如下:

自定义全局过滤器

内置的过滤器已经可以完成大部分的功能，但是对于企业开发的一些业务功能处理，还是需要我们自己编写过滤器来实现的，那么我们一起通过代码的形式自定义一个过滤器，去完成统一的权限校验。

开发中的鉴权逻辑:

当客户端第一次请求服务时，服务端对用户进行信息认证(登录)
认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证
以后每次请求，客户端都携带认证的token
服务端对token进行解密，判断是否有效。

如上图，对于验证用户是否已经登录鉴权的过程可以在网关统一检验。

检验的标准就是请求中是否携带token凭证以及token的正确性。

下面的我们自定义一个GlobalFilter，去校验所有请求的请求参数中是否包含“token”，如何不包含请求参数“token”则不转发路由，否则执行正常的逻辑。

package cn.maruifu.filter;  import org.apache.commons.lang3.StringUtils; import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework.core.Ordered; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Component; import org.springframework.web.server.ServerWebExchange; import reactor.core.publisher.Mono;  //自定义全局过滤器需要实现GlobalFilter和Ordered接口 @Component public class AuthGlobalFilter implements GlobalFilter, Ordered {     //完成判断逻辑     @Override     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {         String token = exchange.getRequest().getQueryParams().getFirst("token");         if (StringUtils.isBlank(token)) {             System.out.println("鉴权失败");             exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);             return exchange.getResponse().setComplete();         }         //调用chain.filter继续向下游执行         return chain.filter(exchange);     }     //顺序,数值越小,优先级越高 @Override     @Override     public int getOrder() {         return 0;     } }

网关限流

网关是所有请求的公共入口，所以可以在网关进行限流，而且限流的方式也很多，我们本次采用前面学过的Sentinel组件来实现网关的限流。Sentinel支持对SpringCloud Gateway、Zuul等主流网关进行限流。

从1.6.0版本开始，Sentinel提供了SpringCloud Gateway的适配模块，可以提供两种资源维度的限流:

route维度:即在Spring配置文件中配置的路由条目，资源名为对应的routeId
自定义API维度:用户可以利用Sentinel提供的API来自定义一些API分组

第一步：导入依赖

<dependency>  <groupId>com.alibaba.csp</groupId>   <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>  </dependency>

第一步：编写配置类

基于Sentinel 的Gateway限流是通过其提供的Filter来完成的，使用时只需注入对应的 SentinelGatewayFilter实例以及 SentinelGatewayBlockExceptionHandler 实例即可。

package cn.maruifu.config;  import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule; import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager; import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter; import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler; import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager; import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler; import org.springframework.beans.factory.ObjectProvider; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.codec.ServerCodecConfigurer; import org.springframework.web.reactive.function.BodyInserters; import org.springframework.web.reactive.function.server.ServerResponse; import org.springframework.web.reactive.result.view.ViewResolver; import org.springframework.web.server.ServerWebExchange; import reactor.core.publisher.Mono;  import javax.annotation.PostConstruct; import java.util.*;  @Configuration public class GatewayConfiguration {     private final List<ViewResolver> viewResolvers;     private final     ServerCodecConfigurer serverCodecConfigurer;      public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider, ServerCodecConfigurer serverCodecConfigurer) {         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);         this.serverCodecConfigurer = serverCodecConfigurer;     }      // 初始化一个限流的过滤器     @Bean     @Order(Ordered.HIGHEST_PRECEDENCE)     public GlobalFilter sentinelGatewayFilter() {         return new SentinelGatewayFilter();     }      // 配置初始化的限流参数     @PostConstruct     public void initGatewayRules() {         Set<GatewayFlowRule> rules = new HashSet<>();         rules.add(new GatewayFlowRule("product_route") //资源名称,对应路由id .setCount(1) // 限流阈值                 .setIntervalSec(1) // 统计时间窗口，单位是秒，默认是 1 秒         );         GatewayRuleManager.loadRules(rules);     }      // 配置限流的异常处理器     @Bean     @Order(Ordered.HIGHEST_PRECEDENCE)     public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {         return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);     }      // 自定义限流异常页面     @PostConstruct     public void initBlockHandlers() {         BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {             @Override             public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {                 Map map = new HashMap<>();                 map.put("code", 0);                 map.put("message", "接口被限流了");                 return ServerResponse.status(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON_UTF8).body(BodyInserters.fromObject(map));             }         };         GatewayCallbackManager.setBlockHandler(blockRequestHandler);     } }

第三步：测试在一秒钟内多次访问http://localhost:7000/product-serv/product/1?token=1就可以看到限流启作用了。

第四步：自定义API分组

自定义API分组是一种更细粒度的限流规则定义

package cn.maruifu.config;  import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants; import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition; import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem; import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem; import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager; import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule; import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager; import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter; import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler; import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager; import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler; import org.springframework.beans.factory.ObjectProvider; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.codec.ServerCodecConfigurer; import org.springframework.web.reactive.function.BodyInserters; import org.springframework.web.reactive.function.server.ServerResponse; import org.springframework.web.reactive.result.view.ViewResolver; import org.springframework.web.server.ServerWebExchange; import reactor.core.publisher.Mono;  import javax.annotation.PostConstruct; import java.util.*;  // 自定义API分组 限流 @Configuration public class GatewayConfiguration {     private final List<ViewResolver> viewResolvers;     private final ServerCodecConfigurer serverCodecConfigurer;      public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider, ServerCodecConfigurer serverCodecConfigurer) {         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);         this.serverCodecConfigurer = serverCodecConfigurer;     }      // 初始化一个限流的过滤器     @Bean     @Order(Ordered.HIGHEST_PRECEDENCE)     public GlobalFilter sentinelGatewayFilter() {         return new SentinelGatewayFilter();     }      /**      *  配置初始化的限流参数      */     @PostConstruct     public void initGatewayRules(){         Set<GatewayFlowRule> rules=new HashSet<>();         rules.add(new GatewayFlowRule("product_api1").setCount(1).setIntervalSec(1));         rules.add(new GatewayFlowRule("product_api2").setCount(1).setIntervalSec(1));         GatewayRuleManager.loadRules(rules);     }     // 配置限流的异常处理器     @Bean     @Order(Ordered.HIGHEST_PRECEDENCE)     public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {         return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);     }      // 自定义限流异常页面     @PostConstruct     public void initBlockHandlers() {         BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {             @Override             public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {                 Map map = new HashMap<>();                 map.put("code", 0);                 map.put("message", "接口被限流了");                 return ServerResponse.status(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON_UTF8).body(BodyInserters.fromObject(map));             }         };         GatewayCallbackManager.setBlockHandler(blockRequestHandler);     }       //自定义API分组     @PostConstruct     private void initCustomizedApis() {         Set<ApiDefinition> definitions = new HashSet<>();         ApiDefinition api1 = new ApiDefinition("product_api1")                                     .setPredicateItems(new HashSet<ApiPredicateItem>() {{                                         // 以/product-serv/product/api1 开头的请求                                          add(new ApiPathPredicateItem()                                                  .setPattern("/product- serv/product/api1/**")                                                  .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX)                                          );                                      }});         ApiDefinition api2 = new ApiDefinition("product_api2")                 .setPredicateItems(new HashSet<ApiPredicateItem>() {{                     // 以/product-serv/product/api2/demo1 完成的url路径匹配                     add(new ApiPathPredicateItem().setPattern("/product-serv/product/api2/demo1"));                 }});         definitions.add(api1);         definitions.add(api2);         GatewayApiDefinitionManager.loadApiDefinitions(definitions);     } }

Sentinel--服务容错

Fri, 29 Jan 2021 13:57:00 GMT

高并发带来的问题

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但是由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务堆积，最终导致服务瘫痪。

接下来，我们来模拟一个高并发的场景

编写java代码

@RestController @Slf4j public class OrderController2 {     @Autowired     private OrderService orderService;     @Autowired     private ProductService productService;      @RequestMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", pid);//调用商品微服 务,查询商品信息         Product product = productService.findByPid(pid);         log.info("查询到{}号商品的信息,内容是:{}", pid, JSON.toJSONString(product)); //模拟一次网络延时         try {             Thread.sleep(100);         } catch (InterruptedException e) {             e.printStackTrace();         }         //下单(创建订单)         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(pid);         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);         //为了不产生太多垃圾数据,暂时不做订单保存         //orderService.createOrder(order);         log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));         return order;     }      @RequestMapping("/order/message")     public String message() {         return "高并发下的问题测试";     } }

修改配置文件中tomcat的并发数

server:  #端口  port: 8091  #tomcat配置  tomcat:   #tomcat的最大并发值修改为10,默认是200   max-threads: 10 #tomcat的最大并发值修改为10,默认是200

接下来使用压测工具,对请求进行压力测试

下载地址https://jmeter.apache.org/

第一步:修改配置，并启动软件

进入bin目录,修改jmeter.properties文件中的语言支持为language=zh_CN，然后点击jmeter.bat 启动软件。

第二步:添加线程组

第三步:配置线程并发数

第四步:添加Http取样

第五步:配置取样，并启动测试

访问message方法观察效果

结论: 此时会发现, 由于order方法囤积了大量请求, 导致message方法的访问出现了问题，这就是服务雪崩的雏形。

服务雪崩效应

在分布式系统中,由于网络原因或自身的原因,服务一般无法保证 100% 可用。如果一个服务出现了问题，调用这个服务就会出现线程阻塞的情况，此时若有大量的请求涌入，就会出现多条线程阻塞等待，进而导致服务瘫痪。

由于服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的 雪崩效应 。

雪崩发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某台机器的资源耗尽。我们无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问题，不会影响到其它服务的正常运行。也就是"雪落而不雪崩"。

常见容错方案

要防止雪崩的扩散，我们就要做好服务的容错，容错说白了就是保护自己不被猪队友拖垮的一些措施,

下面介绍常见的服务容错思路和组件。

常见的容错思路

常见的容错思路有隔离、超时、限流、熔断、降级这几种，下面分别介绍一下。

隔离

它是指将系统按照一定的原则划分为若干个服务模块，各个模块之间相对独立，无强依赖。当有故障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不波及其它模块，不影响整体的系统服务。常见的隔离方式有:线程池隔离和信号量隔离.

超时

在上游服务调用下游服务的时候，设置一个最大响应时间，如果超过这个时间，下游未作出反应，就断开请求，释放掉线程。

限流

限流就是限制系统的输入和输出流量已达到保护系统的目的。为了保证系统的稳固运行,一旦达到的需要限制的阈值,就需要限制流量并采取少量措施以完成限制流量的目的。

熔断

在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。这种牺牲局部，保全整体的措施就叫做熔断。

服务熔断一般有三种状态:

熔断关闭状态(Closed)

服务没有故障时，熔断器所处的状态，对调用方的调用不做任何限制

熔断开启状态(Open)

后续对该服务接口的调用不再经过网络，直接执行本地的fallback方法

半熔断状态(Half-Open)

尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率。如果成功率达到预期，则说明服务已恢复，进入熔断关闭状态;如果成功率仍旧很低，则重新进入熔断关闭状态。

降级

降级其实就是为服务提供一个托底方案，一旦服务无法正常调用，就使用托底方案。

常见的容错组件

Hystrix

Hystrix是由Netflflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性。
Resilience4J Resilicence4J一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也支持和prometheus等多款主流产品进行整合。
Sentinel Sentinel 是阿里巴巴开源的一款断路器实现，本身在阿里内部已经被大规模采用，非常稳定。

下面是三个组件在各方面的对比:

	Sentinel	Hystrix	resilience4j
隔离策略	信号量隔离(并发线程数限流)	线程池隔离/信号量隔离	信号量隔离
熔断降级策略	基于响应时间、异常比率、异常数	基于异常比率	基于异常比率、响应
实时统计实现	滑动窗口(LeapArray)	滑动窗口(基于 RxJava)	Ring Bit Buffer
动态规则配置	支持多种数据源	支持多种数据	有限支持
扩展性	多个扩展点	插件的形式	接口的形式
基于注解的支持	支持	支持	支持
限流	基于 QPS，支持基于调用关系的限流	有限的支持	Rate Limiter
流量整形	支持预热模式、匀速器模式、预热排队模式	不支持	简单的 Rate Limiter模式
系统自适应保护	支持	不支持	不支持
控制台	提供开箱即用的控制台，可配置规则、查看秒级监控、机器发现等	简单的监控查看	不提供控制台，可对接其它监控系统

Sentinel入门

什么是Sentine

Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的综合性解决方案。它以流量为切入点, 从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。

Sentinel 具有以下特征

丰富的应用场景:Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景, 例如秒杀(即突发流量控制在系统容量可以承受的范围)、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
完备的实时监控:Sentinel 提供了实时的监控功能。通过控制台可以看到接入应用的单台机器秒级数据, 甚至 500 台以下规模的集群的汇总运行情况。
广泛的开源生态:Sentinel 提供开箱即用的与其它开源框架/库的整合模块, 例如与 SpringCloud、 Dubbo、gRPC 的整合。只需要引入相应的依赖并进行简单的配置即可快速地接入Sentinel。
完善的SPI扩展点:Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel分为两个部分:

核心库(Java 客户端)不依赖任何框架/库,能够运行于所有 Java 运行时环境，同时对 Dubbo/Spring Cloud 等框架也有较好的支持。
控制台(Dashboard)基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

微服务集成Sentinel

为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可

1 在pom.xml中加入下面依赖

<dependency>  <groupId>com.alibaba.cloud</groupId>   <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>  </dependency>

2 编写一个Controller测试使用

package cn.maruifu.controller;  import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;  // @RestController @Slf4j public class OrderTestController {      @RequestMapping("/order/message1")     public String message1() {         return "message1";     }      @RequestMapping("/order/message2")     public String message2() {         return "message2";     } }

安装Sentinel控制台

Sentinel 提供一个轻量级的控制台, 它提供机器发现、单机资源实时监控以及规则管理等功能。

下载jar包,解压到文件夹 https://github.com/alibaba/Sentinel/releases

2 .启动控制台

 # 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目) java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.3.jar

修改 shop-order ,在里面加入有关控制台的配置

spring:   cloud:     sentinel:       transport:         port: 9999 #跟控制台交流的端口,随意指定一个未使用的端口即可          dashboard: localhost:8080 # 指定控制台服务的地址

通过浏览器访问localhost:8080 进入控制台 ( 默认用户名密码是 sentinel/sentinel )

控制台的使用原理Sentinel的控制台其实就是一个SpringBoot编写的程序。我们需要将我们的微服务程序注册到控制台上, 即在微服务中指定控制台的地址, 并且还要开启一个跟控制台传递数据的端口, 控制台也可以通过此端口调用微服务中的监控程序获取微服务的各种信息。

实现一个接口的限流

通过控制台为message1添加一个流控规则

通过控制台快速频繁访问, 观察效果

Sentinel的概念和功能

基本概念

资源

资源就是Sentinel要保护的东西

资源是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，可以是一个服务，也可以是一个方法，甚至可以是一段代码。

我们入门案例中的message1方法就可以认为是一个资源

规则

规则就是用来定义如何进行保护资源的

作用在资源之上, 定义以什么样的方式保护资源，主要包括流量控制规则、熔断降级规则以及系统保护规则。

我们入门案例中就是为message1资源设置了一种流控规则, 限制了进入message1的流量

重要功能

Sentinel的主要功能就是容错，主要体现为下面这三个:

流量控制

流量控制在网络传输中是一个常用的概念，它用于调整网络包的数据。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状。

熔断降级

当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障

Sentinel 对这个问题采取了两种手段:

通过并发线程数进行限制

Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。

通过响应时间对资源进行降级

除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。

Sentinel和 Hystrix的区别

两者的原则是一致的, 都是当一个资源出现问题时, 让其快速失败, 不要波及到其它服务但是在限制的手段上, 确采取了完全不一样的方法:

Hystrix 采用的是线程池隔离的方式, 优点是做到了资源之间的隔离, 缺点是增加了线程切换的成本。

Sentinel 采用的是通过并发线程的数量和响应时间来对资源做限制。

系统负载保护 Sentinel 同时提供系统维度的自适应保护能力。当系统负载较高的时候，如果还持续让请求进入可能会导致系统崩溃，无法响应。在集群环境下，会把本应这台机器承载的流量转发到其它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求

总之一句话:我们需要做的事情，就是在Sentinel的资源上配置各种各样的规则，来实现各种容错的功能。

Sentinel规则

流量控制，其原理是监控应用流量的QPS(每秒查询率) 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。

第1步: 点击簇点链路，我们就可以看到访问过的接口地址，然后点击对应的流控按钮，进入流控规则配置页面。新增流控规则界面如下

流控规则

资源名:唯一名称，默认是请求路径，可自定义

针对来源:指定对哪个微服务进行限流，默认指default，意思是不区分来源，全部限制

阈值类型单机阈值:

QPS(每秒请求数量): 当调用该接口的QPS达到阈值的时候，进行限流
线程数:当调用该接口的线程数达到阈值的时候，进行限流

是否集群:暂不需要集群接下来我们以QPS为例来研究限流规则的配置。

简单配置

我们先做一个简单配置，设置阈值类型为QPS，单机阈值为3。即每秒请求量大于3的时候开始限流。接下来，在流控规则页面就可以看到这个配置。

配置流控模式

sentinel共有三种流控模式，分别是:

直接(默认):接口达到限流条件时，开启限流
关联:当关联的资源达到限流条件时，开启限流 [适合做应用让步]
链路:当从某个接口过来的资源达到限流条件时，开启限流

下面呢分别演示三种模式:

直接流控模式

直接流控模式是最简单的模式，当指定的接口达到限流条件时开启限流。上面案例使用的就是直接流控模式。

关联流控模式

关联流控模式指的是，当指定接口关联的接口达到限流条件时，开启对指定接口开启限流。第1步:配置限流规则,将流控模式设置为关联，关联资源设置为的 /order/message2。

通过Jmeter软件向/order/message2连续发送请求，注意QPS一定要大于3

访问/order/message1,会发现已经被限流

链路流控模式

链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项，区别在于:针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细。

1.编写一个service，在里面添加一个方法message

 package cn.maruifu.service.impl;   import com.alibaba.csp.sentinel.annotation.SentinelResource; import org.springframework.stereotype.Service;  @Service public class OrderTestServiceImpl {     @SentinelResource("message")     public void message() {         System.out.println("message");     } }

第2步: 在Controller中声明两个方法，分别调用service中的方法message

package cn.maruifu.controller;  import cn.maruifu.service.impl.OrderTestServiceImpl; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;  // @RestController @Slf4j public class OrderTestController {      /*      @RequestMapping("/order/message1")     public String message1() {         return "message1";     }      @RequestMapping("/order/message2")     public String message2() {         return "message2";     }*/        @Autowired     private OrderTestServiceImpl orderTestServiceImpl;      @RequestMapping("/order/message1")     public String message1() {         orderTestServiceImpl.message();         return "message1";     }     @RequestMapping("/order/message2")     public String message2() {         orderTestServiceImpl.message();         return "message2";     }  }

第3步: 禁止收敛URL的入口 context

1.6.3 版本开始，Sentinel Web fifilter默认收敛所有URL的入口context，因此链路限流不生效。 1.7.0 版本开始(对应SCA的2.1.1.RELEASE)，官方在CommonFilter 引入了WEB_CONTEXT_UNIFY 参数，用于控制是否收敛context。将其配置为 false 即可根据不同的URL进行链路限流。

SCA 2.1.1.RELEASE之后的版本,可以通过配置spring.cloud.sentinel.web-context-unify=false即可关闭收敛我们当前使用的版本是SpringCloud Alibaba 2.1.0.RELEASE，无法实现链路限流。

目前官方还未发布SCA 2.1.2.RELEASE，所以我们只能使用2.1.1.RELEASE，需要写代码的形式实现

(1) 暂时将SpringCloud Alibaba的版本调整为2.1.1.RELEASE

<spring-cloud-alibaba.version>2.1.1.RELEASE</spring-cloud-alibaba.version>

(2) 配置文件中关闭sentinel的CommonFilter实例化

 spring:   cloud:     sentinel:       filter:        enabled: false

(3) 添加一个配置类，自己构建CommonFilter实例

package cn.maruifu.config; import com.alibaba.csp.sentinel.adapter.servlet.CommonFilter; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class FilterContextConfig {     @Bean     public FilterRegistrationBean sentinelFilterRegistration() {         FilterRegistrationBean registration = new FilterRegistrationBean();         registration.setFilter(new CommonFilter());         registration.addUrlPatterns("/*");          // 入口资源关闭聚合         registration.addInitParameter(CommonFilter.WEB_CONTEXT_UNIFY, "false");         registration.setName("sentinelFilter");         registration.setOrder(1);         return registration;     } }

(4) : 控制台配置限流规则

(5) :分别通过 /order/message1 和 /order/message2 访问, 发现2没问题, 1的被限流了

配置流控效果

快速失败(默认): 直接失败，抛出异常，不做任何额外的处理，是最简单的效果
Warm Up:它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的 1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。
排队等待:让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待; 它还会让设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃

降级规则

降级规则就是设置当满足什么条件的时候，对服务进行降级。Sentinel提供了三个衡量条件:

平均响应时间 :当资源的平均响应时间超过阈值(以 ms 为单位)之后，资源进入准降级状态。如果接下来 1s 内持续进入 5 个请求，它们的 RT都持续超过这个阈值，那么在接下的时间窗口 (以 s 为单位)之内，就会对这个方法进行服务降级。

注意 Sentinel 默认统计的 RT 上限是 4900 ms，超出此阈值的都会算作 4900 ms，若需要变更此上限可以通过启动配置项 -Dcsp.sentinel.statistic.max.rt=xxx 来配置。

异常比例:当资源的每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，即在接下的时间窗口(以 s 为单位)之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是 [0.0,1.0]。

第1步: 首先模拟一个异常

int i=0;  @RequestMapping("/order/message2")  public String message2(){     i++;     //异常比例为0.333     if(i%3==0){         throw new RuntimeException();     }     return"message2"; }

第2步: 设置异常比例为0.25

异常数 :当资源近 1 分钟的异常数目超过阈值之后会进行服务降级。注意由于统计时间窗口是分钟级别的，若时间窗口小于 60s，则结束熔断状态后仍可能再进入熔断状态。

问题:流控规则和降级规则返回的异常页面是一样的，我们怎么来区分到底是什么原因导致的呢?

热点规则

热点参数流控规则是一种更细粒度的流控规则, 它允许将规则具体到参数上。 热点规则简单使用

第1步: 编写代码

@RequestMapping("/order/message3")  @SentinelResource("message3") //注意这里必须使用这个注解标识,热点规则不生效  public String message3(String name, Integer age) {     return name + age; }

第2步: 配置热点规则

第3步: 分别用两个参数访问,会发现只对第一个参数限流了

热点规则增强使用

参数例外项允许对一个参数的具体值进行流控

编辑刚才定义的规则,增加参数例外项

授权规则

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源访问控制的功能。来源访问控制根据资源的请求来源(origin)限制资源是否通过:

若配置白名单，则只有请求来源位于白名单内时才可通过;
若配置黑名单，则请求来源位于黑名单时不通过，其余的请求通过。

上面的资源名和授权类型不难理解，但是流控应用怎么填写呢?

其实这个位置要填写的是来源标识，Sentinel提供了 RequestOriginParser 接口来处理来源。

只要Sentinel保护的接口资源被访问，Sentinel就会调用 RequestOriginParser 的实现类去解析访问来源。

第1步: 自定义来源处理规则

@Component public class RequestOriginParserDefinition implements RequestOriginParser{ @Override public String parseOrigin(HttpServletRequest request) {     String serviceName = request.getParameter("serviceName");     return serviceName; } }

第2步: 授权规则配置

这个配置的意思是只有serviceName=pc不能访问(黑名单)

第3步: 访问 http://localhost:8091/order/message1?serviceName=pc观察结果

系统规则

系统保护规则是从应用级别的入口流量进行控制，从单台机器的总体 Load、RT、入口 QPS 、CPU使用率和线程数五个维度监控应用数据，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量 (进入应用的流量) 生效。

Load(仅对 Linux/Unix-like 机器生效):当系统 load1 超过阈值，且系统当前的并发线程数超过系统容量时才会触发系统保护。系统容量由系统的 maxQps * minRt 计算得出。设定参考值一般是 CPU cores * 2.5。
RT:当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
线程数:当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
入口 QPS:当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。
CPU使用率:当单台机器上所有入口流量的 CPU使用率达到阈值即触发系统保护

扩展:自定义异常返回

//异常处理页面 @Component public class ExceptionHandlerPage implements UrlBlockHandler {     //用于定义资源，并提供可选的异常处理和 fallback 配置项。其主要参数如下:     @SentinelResource      /**      *  BlockException 异常接口,包含Sentinel的五个异常      *  FlowException 限流异常      *  DegradeException 降级异常      *  ParamFlowException 参数限流异常      *  AuthorityException 授权异常      *  SystemBlockException 系统负载异常      *      */     @Override     public void blocked(HttpServletRequest request, HttpServletResponse             response, BlockException e) throws IOException { response.setContentType("application/json;charset=utf-8");         ResponseData data = null;         if (e instanceof FlowException) {             data = new ResponseData(-1, "接口被限流了...");         } else if (e instanceof DegradeException) {             data = new ResponseData(-2, "接口被降级了...");         }         response.getWriter().write(JSON.toJSONString(data));     } }     @Data      //全参构造     @AllArgsConstructor     //无参构造     @NoArgsConstructor     class ResponseData {         private int code;         private String message;     } }

@SentinelResource的使用

在定义了资源点之后，我们可以通过Dashboard来设置限流和降级策略来对资源点进行保护。同时还能通过@SentinelResource来指定出现异常时的处理策略。

@SentinelResource 用于定义资源，并提供可选的异常处理和 fallback 配置项。其主要参数如下:

属性	作用
value	资源名称
entryType	entry类型，标记流量的方向，取值IN/OUT，默认是OUT
blockHandler	处理BlockException的函数名称,函数要求:1. 必须是 public2. 返回类型参数与原方法一致3. 默认需和原方法在同一个类中。若希望使用其他类的函数，可配置blockHandlerClass ，并指定blockHandlerClass里面的方法。
blockHandlerClass	存放blockHandler的类,对应的处理函数必须static修饰。
fallback	用于在抛出异常的时候提供fallback处理逻辑。fallback函数可以针对所有类型的异常(除了exceptionsToIgnore 里面排除掉的异常类型)进行处理。函数要求:1. 返回类型与原方法一致2. 参数类型需要和原方法相匹配3. 默认需和原方法在同一个类中。若希望使用其他类的函数，可配置fallbackClass ，并指定fallbackClass里面的方法。
fallbackClass	存放fallback的类。对应的处理函数必须static修饰
defaultFallback	用于通用的 fallback 逻辑。默认fallback函数可以针对所有类型的异常进行处理。若同时配置了 fallback 和 defaultFallback，以fallback为准。函数要求:1. 返回类型与原方法一致2. 方法参数列表为空，或者有一个 Throwable 类型的参数。3. 默认需要和原方法在同一个类中。若希望使用其他类的函数，可配置fallbackClass ，并指定 fallbackClass 里面的方法。
exceptionsToIgnore	指定排除掉哪些异常。排除的异常不会计入异常统计，也不会进入 fallback逻辑，而是原样抛出
exceptionsToTrace	需要trace的异常

定义限流和降级后的处理方法

方式一:直接将限流和降级方法定义在方法中

@Service @Slf4j public class OrderServiceImpl3 {     int i = 0;     @SentinelResource(value = "message",  /*指定发生BlockException时进入的方法*/     blockHandler = "blockHandler", /* 指定发生Throwable时进入的方法) */      fallback = "fallback"     public String message(){         i++;         if(i % 3 == 0){           throw new RuntimeException();         }          return"message";      }                          //BlockException时进入的方法      public String blockHandler(BlockException ex){         log.error("{}", ex);         return"接口被限流或者降级了...";     }      //Throwable时进入的方法     public String fallback(Throwable throwable) {         log.error("{}", throwable);         return "接口发生异常了...";     } }

方式二: 将限流和降级方法外置到单独的类中

@Service @Slf4j public class OrderServiceImpl3 {    int i = 0;    @SentinelResource(  value = "message", blockHandlerClass = OrderServiceImpl3BlockHandlerClass.class, blockHandler = "blockHandler", fallbackClass = OrderServiceImpl3FallbackClass.class, fallback = "fallback"  )    public String message() {        i++;        if (i % 3 == 0) {            throw new RuntimeException();        }        return "message4";    } } @Slf4j public class OrderServiceImpl3BlockHandlerClass { //注意这里必须使用static修饰方法    public static String blockHandler(BlockException ex) { 1 编写处理类        log.error("{}", ex);        return "接口被限流或者降级了...";    } } @Slf4j public class OrderServiceImpl3FallbackClass { //注意这里必须使用static修饰方法    public static String fallback(Throwable throwable) { log.error("{}", throwable);        return "接口发生异常了...";    } }

Sentinel规则持久化

通过前面的讲解，我们已经知道，可以通过Dashboard来为每个Sentinel客户端设置各种各样的规则，

但是这里有一个问题，就是这些规则默认是存放在内存中，极不稳定，所以需要将其持久化。本地文件数据源会定时轮询文件的变更，读取规则。这样我们既可以在应用本地直接修改文件来更新规则，也可以通过 Sentinel 控制台推送规则。以本地文件数据源为例，推送过程如下图所示:

首先 Sentinel 控制台通过 API 将规则推送至客户端并更新到内存中，接着注册的写数据源会将新的规则保存到本地的文件中。

编写处理类

package cn.maruifu.config;  import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler; import com.alibaba.csp.sentinel.datasource.*; import com.alibaba.csp.sentinel.init.InitFunc; import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule; import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager; import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule; import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager; import com.alibaba.csp.sentinel.slots.block.flow.FlowRule; import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager; import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule; import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager; import com.alibaba.csp.sentinel.slots.system.SystemRule; import com.alibaba.csp.sentinel.slots.system.SystemRuleManager; import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.TypeReference; import org.springframework.beans.factory.annotation.Value;  import java.io.File; import java.io.IOException; import java.util.List;  //规则持久化 public class FilePersistence implements InitFunc {     @Value("spring.application:name")     private String appcationName;      @Override     public void init() throws Exception {         String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + appcationName;         String flowRulePath = ruleDir + "/flow-rule.json";         String degradeRulePath = ruleDir + "/degrade-rule.json";         String systemRulePath = ruleDir + "/system-rule.json";         String authorityRulePath = ruleDir + "/authority-rule.json";         String paramFlowRulePath = ruleDir + "/param-flow-rule.json";          this.mkdirIfNotExits(ruleDir);         this.createFileIfNotExits(flowRulePath);         this.createFileIfNotExits(degradeRulePath);         this.createFileIfNotExits(systemRulePath);         this.createFileIfNotExits(authorityRulePath);         this.createFileIfNotExits(paramFlowRulePath);         // 流控规则         ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>         (flowRulePath, flowRuleListParser         );         FlowRuleManager.register2Property(flowRuleRDS.getProperty());         WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(flowRulePath, this::encodeJson);         WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);         // 降级规则         ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(degradeRulePath, degradeRuleListParser);         DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());         WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(degradeRulePath, this::encodeJson);         WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);         // 系统规则         ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(systemRulePath, systemRuleListParser);         SystemRuleManager.register2Property(systemRuleRDS.getProperty());         WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(systemRulePath, this::encodeJson);         WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);         // 授权规则         ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(authorityRulePath, authorityRuleListParser);         AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());         WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(authorityRulePath, this::encodeJson);         WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);         // 热点参数规则         ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>( paramFlowRulePath,paramFlowRuleListParser);         ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());         WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>( paramFlowRulePath, this::encodeJson );         ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);     }      private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject( source,  new TypeReference<List<FlowRule>>() { });      private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(  source, new TypeReference<List<DegradeRule>>() {  });      private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(source, new TypeReference<List<SystemRule>>() {});      private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(source,new TypeReference<List<AuthorityRule>>() {} );      private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(source,new TypeReference<List<ParamFlowRule>>() { } );      private void mkdirIfNotExits(String filePath) throws IOException {         File file = new File(filePath);         if (!file.exists()) {             file.mkdirs();         }     }      private void createFileIfNotExits(String filePath) throws IOException {         File file = new File(filePath);         if (!file.exists()) {             file.createNewFile();         }     }      private <T> String encodeJson(T t) {         return JSON.toJSONString(t);     } }

添加配置在resources下创建配置目录 META-INF/services ,然后添加文件com.alibaba.csp.sentinel.init.InitFunc

在文件中添加配置类的全路径

cn.maruifu.config.FilePersistence

Feign整合Sentinel

第1步: 引入sentinel的依赖

  <!--sentinel客户端--> <dependency>  <groupId>com.alibaba.cloud</groupId>   <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>  </dependency>

第2步: 在配置文件中开启Feign对Sentinel的支持

feign:  sentinel:   enabled: true

第3步: 创建容错类

//容错类要求必须实现被容错的接口,并为每个方法实现容错方案 package cn.maruifu.service.api;  import cn.maruifu.vo.Product; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component;  //容错类要求必须实现被容错的接口,并为每个方法实现容错方案 @Component @Slf4j public class ProductApiServiceFallBack implements ProductApiService {     @Override     public Product findByPid(Integer pid) {         Product product = new Product();         product.setPid(-1);         return product;     } }

第4步: 为被容器的接口指定容错类

package cn.maruifu.service.api;  import cn.maruifu.vo.Product; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; //value用于指定调用nacos下哪个微服务 //fallback用于指定容错类 @FeignClient(value = "service-product", fallback = ProductApiServiceFallBack.class) //声明调用的提供者的name public interface ProductApiService {     //指定调用提供者的哪个方法 //@FeignClient+@GetMapping 就是一个完整的请求路径 http://service- product/product/{pid}     @GetMapping(value = "/product/{pid}")     Product findByPid(@PathVariable("pid") Integer pid); }

第5步: 修改controller

package cn.maruifu.controller;  import cn.maruifu.service.OrderService; import cn.maruifu.service.api.ProductApiService; import cn.maruifu.vo.Order; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;  import java.util.List; import java.util.Random;  @RestController @Slf4j public class OrderController {      @Autowired     private RestTemplate restTemplate;     @Autowired     private OrderService orderService;      @Autowired     private DiscoveryClient discoveryClient;         @Autowired     private ProductApiService productApiService;      //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单，这时候要调用商品微服务查询商品信息");          // 方法一 通过IP调用         //通过restTemplate调用商品微服务         //Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);          // 方法二 从nacos中获取服务地址         //ServiceInstance serviceInstance = discoveryClient.getInstances("service-product").get(0);         //String url = serviceInstance.getHost() + ":" +serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          // 方法三 从nacos中获取服务地址 自定义规则实现随机挑选服务         //List<ServiceInstance> instances = discoveryClient.getInstances("service-product");         //int index = new Random().nextInt(instances.size());         //ServiceInstance serviceInstance = instances.get(index);         //String url = serviceInstance.getHost() + ":" + serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          // 方法四  基于Ribbon实现负载均衡         //直接使用微服务名字， 从nacos中获取服务地址         //String url = "service-product";         //Product product = restTemplate.getForObject( "http://" + url + "/product/" + pid, Product.class);          // 方法五 通过fegin调用商品微服务          //  调用商品微服务,查询商品信息         log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", pid);          Product product = productApiService.findByPid(pid);          if (product.getPid() == -1) {             Order order = new Order();             order.setPname("下单失败");             return order;         }            log.info("查询到{}号商品的信息,内容是:{}", pid, JSON.toJSONString(product)); //模拟一次网络延时         try {             Thread.sleep(1000);         } catch (InterruptedException e) {             e.printStackTrace();         }         //下单(创建订单)         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(product.getPid());         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);           //为了不产生太多垃圾数据,暂时不做订单保存         //orderService.save(order);         log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));          return order;     }       @RequestMapping("/order/message")     public String message() {         return "高并发下的问题测试";     } }

第6步: 停止所有 shop-product 服务,重启 shop-order 服务,访问请求,观察容错效果

扩展: 如果想在容错类中拿到具体的错误,可以使用下面的方式

 package cn.maruifu.service.api;  import cn.maruifu.vo.Product; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; //value用于指定调用nacos下哪个微服务 //fallback用于指定容错类 //@FeignClient(value = "service-product", fallback = ProductApiServiceFallBack.class)  @FeignClient(   value = "service-product", fallbackFactory = ProductApiServiceFallBackFactory.class) //声明调用的提供者的name public interface ProductApiService {     //指定调用提供者的哪个方法 //@FeignClient+@GetMapping 就是一个完整的请求路径 http://service- product/product/{pid}     @GetMapping(value = "/product/{pid}")     Product findByPid(@PathVariable("pid") Integer pid); }     package cn.maruifu.service.api; import cn.maruifu.vo.Product; import feign.hystrix.FallbackFactory; import org.springframework.stereotype.Component; @Component public class ProductApiServiceFallBackFactory implements FallbackFactory<ProductApiService> {     @Override     public ProductApiService create(Throwable throwable) {         return new ProductApiService() {             @Override             public Product findByPid(Integer pid) {                 throwable.printStackTrace();                 Product product = new Product();                 product.setPid(-1);                 return product;             }         };     } }

注意: fallback和fallbackFactory只能使用其中一种方式

Nacos Discovery--服务治理

Wed, 27 Jan 2021 14:06:00 GMT

服务治理介绍

先来思考一个问题？

通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址(ip，端口)等硬编码到了代码中，这种做法存在许多问题:

一旦服务提供者地址变化，就需要手工修改代码一旦是多个服务提供者，无法实现负载均衡功能一旦服务变得越来越多，人工维护调用关系困难

那么应该怎么解决呢，这时候就需要通过注册中心动态的实现服务治理。

什么是服务治理

服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现。

**服务注册:**在服务治理框架中，都会构建一个注册中心，每个服务单元向注册中心登记自己提供服务的详细信息。并在注册中心形成一张服务的清单，服务注册中心需要以心跳的方式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

**服务发现:**服务调用方向服务注册中心咨询服务，并获取所有服务的实例清单，实现对具体服务实例的访问。

通过上面的调用图会发现，除了微服务，还有一个组件是服务注册中心，它是微服务架构非常重要的一个组件，在微服务架构里主要起到了协调者的一个作用。注册中心一般包含如下几个功能:

服务发现: 服务注册:保存服务提供者和服务调用者的信息

服务订阅:服务调用者订阅服务提供者的信息，注册中心向订阅者推送提供者的信息
服务配置:
- 配置订阅:服务提供者和服务调用者订阅微服务相关的配置
- 配置下发:主动将配置推送给服务提供者和服务调用者
服务健康检测检测服务提供者的健康情况，如果发现异常，执行服务剔除

常见的注册中心

Zookeeper

zookeeper是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如:统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。

Eureka

Eureka是Springcloud Netflix中的重要组件，主要作用就是做服务注册和发现。但是现在已经闭源

Consul

Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现和配置管理的功能。Consul的功能都很实用，其中包括:服务注册/发现、健康检查、Key/Value 存储、多数据中心和分布式一致性保证等特性。Consul本身只是一个二进制的可执行文件，所以安装和部署都非常简单，只需要从官网下载后，在执行对应的启动脚本即可。

Nacos

Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。他是SpringCloud Alibaba 组件之一，负责服务注册发现和服务配置，可以这样认为 nacos=eureka+config。

nacos简介

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现

动态服务发现、服务配置、服务元数据及流量管理。从上面的介绍就可以看出，nacos的作用就是一个注册中心，用来管理注册上来的各个微服务。

nacos实战入门

接下来，我们就在现有的环境中加入nacos，并将我们的两个微服务注册上去。

搭建nacos环境

安装nacos

从 Github 上下载源码方式

git clone https://github.com/alibaba/nacos.git cd nacos/ mvn -Prelease-nacos -Dmaven.test.skip=true clean install -U   ls -al distribution/target/  // change the $version to your actual path cd distribution/target/nacos-server-$version/nacos/bin

下载编译后压缩包方式

您可以从最新稳定版本下载 nacos-server-$version.zip 包。

  unzip nacos-server-$version.zip 或者 tar -xvf nacos-server-$version.tar.gz   cd nacos/bin

启动nacos

Linux/Unix/Mac启动命令(standalone代表着单机模式运行，非集群模式):

sh startup.sh -m standalone

如果您使用的是ubuntu系统，或者运行脚本报错提示[[符号找不到，可尝试如下运行：

bash startup.sh -m standalone

Windows启动命令(standalone代表着单机模式运行，非集群模式):

cmd startup.cmd -m standalone

启动失败看一下自己是不是64位 1.8+JDK

访问nacos

打开浏览器输入http://localhost:8848/nacos，即可访问服务，默认密码是nacos/nacos

将商品微服务注册到nacos

接下来开始修改 shop-product 模块的代码，将其注册到nacos服务上

在pom.xml中添加nacos的依赖

  <!--nacos客户端--> <dependency>  <groupId>com.alibaba.cloud</groupId>   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>  </dependency>

在主类上添加**@EnableDiscoveryClient**注解

@SpringBootApplication @EnableDiscoveryClient public class ProductApplication

在application.yml中添加nacos服务的地址

spring:     cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848

启动服务，观察nacos的控制面板中是否有注册上来的商品微服务

将订单微服务注册到nacos

接下来开始修改 shop_order 模块的代码，将其注册到nacos服务上

在pom.xml中添加nacos的依赖

  <!--nacos客户端--> <dependency>  <groupId>com.alibaba.cloud</groupId>   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>  </dependency>

在主类上添加**@EnableDiscoveryClient**注解

import org.springframework.cloud.client.discovery.EnableDiscoveryClient;   @SpringBootApplication @EnableDiscoveryClient public class OrderApplication

在application.yml中添加nacos服务的地址

spring:   cloud:     nacos:       discovery:         server-addr: 127.0.0.1:8848

修改OrderController，实现微服务调用

package cn.maruifu.controller;  import cn.maruifu.service.OrderService; import cn.maruifu.vo.Order; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;  @RestController @Slf4j public class OrderController {      @Autowired     private RestTemplate restTemplate;     @Autowired     private OrderService orderService;      @Autowired     private DiscoveryClient discoveryClient;       //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单，这时候要调用商品微服务查询商品信息");          // 之前调用         //通过restTemplate调用商品微服务         //Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);          //从nacos中获取服务地址         ServiceInstance serviceInstance = discoveryClient.getInstances("service-product").get(0);         String url = serviceInstance.getHost() + ":" +serviceInstance.getPort();         log.info(">>从nacos中获取到的微服务地址为:" + url);         Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);                  log.info(">>商品信息,查询结果:"+ JSON.toJSONString(product));         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(product.getPid());         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);         orderService.save(order);         return order;     } }

DiscoveryClient是专门负责服务注册和发现的，我们可以通过它获取到注册到注册中心的所有服务

启动服务，观察nacos的控制面板中是否有注册上来的订单微服务，然后通过访问消费者服务验证调用是否成功

实现服务调用的负载均衡

什么是负载均衡

通俗的讲，负载均衡就是将负载(工作任务，访问请求)进行分摊到多个操作单元(服务器,组件)上进行执行。

根据负载均衡发生位置的不同,一般分为服务端负载均衡和客户端负载均衡。服务端负载均衡指的是发生在服务提供者一方,比如常见的nginx负载均衡

而客户端负载均衡指的是发生在服务请求的一方，也就是在发送请求之前已经选好了由哪个实例处理请求。

我们在微服务调用关系中一般会选择客户端负载均衡，也就是在服务调用的一方来决定服务由哪个提供者执行。

自定义实现负载均衡

1通过idea再启动一个 shop-product 微服务，点击Copy Configurations 设置其端口为8082

2通过nacos查看微服务的启动情况

3修改 shop-order 的代码，实现负载均衡

package cn.maruifu.controller;  import cn.maruifu.service.OrderService; import cn.maruifu.vo.Order; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;  import java.util.List; import java.util.Random;  @RestController @Slf4j public class OrderController {      @Autowired     private RestTemplate restTemplate;     @Autowired     private OrderService orderService;      @Autowired     private DiscoveryClient discoveryClient;       //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单，这时候要调用商品微服务查询商品信息");          // 之前调用         //通过restTemplate调用商品微服务         //Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);          //从nacos中获取服务地址         //ServiceInstance serviceInstance = discoveryClient.getInstances("service-product").get(0);         //String url = serviceInstance.getHost() + ":" +serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          //从nacos中获取服务地址 自定义规则实现随机挑选服务         List<ServiceInstance> instances = discoveryClient.getInstances("service-product");         int index = new Random().nextInt(instances.size());         ServiceInstance serviceInstance = instances.get(index);         String url = serviceInstance.getHost() + ":" + serviceInstance.getPort();         log.info(">>从nacos中获取到的微服务地址为:" + url);         Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);           log.info(">>商品信息,查询结果:"+ JSON.toJSONString(product));         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(product.getPid());         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);         orderService.save(order);         return order;     } }

4启动两个服务提供者和一个服务消费者，多访问几次消费者测试效果

基于Ribbon实现负载均衡

Ribbon 是 Spring Cloud 的一个组件，它可以让我们使用一个注解就能轻松的搞定负载均衡

第1步:在RestTemplate 的生成方法上添加@LoadBalanced注解

@Bean @LoadBalanced public RestTemplate restTemplate() {   return new RestTemplate(); }

第2步:修改服务调用的方法

package cn.maruifu.controller;  import cn.maruifu.service.OrderService; import cn.maruifu.vo.Order; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;  import java.util.List; import java.util.Random;  @RestController @Slf4j public class OrderController {      @Autowired     private RestTemplate restTemplate;     @Autowired     private OrderService orderService;      @Autowired     private DiscoveryClient discoveryClient;       //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单，这时候要调用商品微服务查询商品信息");          // 之前调用         //通过restTemplate调用商品微服务         //Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);          //从nacos中获取服务地址         //ServiceInstance serviceInstance = discoveryClient.getInstances("service-product").get(0);         //String url = serviceInstance.getHost() + ":" +serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          //从nacos中获取服务地址 自定义规则实现随机挑选服务         //List<ServiceInstance> instances = discoveryClient.getInstances("service-product");         //int index = new Random().nextInt(instances.size());         //ServiceInstance serviceInstance = instances.get(index);         //String url = serviceInstance.getHost() + ":" + serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          // 基于Ribbon实现负载均衡         //直接使用微服务名字， 从nacos中获取服务地址         String url = "service-product";         Product product = restTemplate.getForObject( "http://" + url + "/product/" + pid, Product.class);          log.info(">>商品信息,查询结果:"+ JSON.toJSONString(product));         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(product.getPid());         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);         orderService.save(order);         return order;     } }

Ribbon支持的负载均衡策略

Ribbon内置了多种负载均衡策略,内部负载均衡的顶级接口为com.netflix.loadbalancer.IRule ,

具体的负载策略如下图所示:

我们可以通过修改配置来调整Ribbon的负载均衡策略，具体代码如下

service-product: # 调用的提供者的名称  ribbon:   NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

基于Feign实现服务调用

什么是Feign

Feign是Spring Cloud提供的一个声明式的伪Http客户端，它使得调用远程服务就像调用本地服务一样简单，只需要创建一个接口并添加一个注解即可。

Nacos很好的兼容了Feign， Feign默认集成了 Ribbon，所以在Nacos下使用Fegin默认就实现了负载均衡的效果。

Feign的使用

加入Fegin的依赖

<!--fegin组件--> <dependency>   <groupId>org.springframework.cloud</groupId>   <artifactId>spring-cloud-starter-openfeign</artifactId>  </dependency>

在主类上添加Fegin的注解

@SpringBootApplication  @EnableDiscoveryClient  @EnableFeignClients //开启Fegin  public class OrderApplication {}

创建一个service

package cn.maruifu.api;  import cn.maruifu.vo.Product; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable;  @FeignClient("service-product") //声明调用的提供者的name public interface ProductApiService {     //指定调用提供者的哪个方法     //@FeignClient+@GetMapping 就是一个完整的请求路径 http://service- product/product/{pid}     @GetMapping(value = "/product/{pid}")     Product findByPid(@PathVariable("pid") Integer pid); }

修改controller代码

package cn.maruifu.controller;  import cn.maruifu.api.ProductApiService; import cn.maruifu.service.OrderService; import cn.maruifu.vo.Order; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;  import java.util.List; import java.util.Random;  @RestController @Slf4j public class OrderController {      @Autowired     private RestTemplate restTemplate;     @Autowired     private OrderService orderService;      @Autowired     private DiscoveryClient discoveryClient;     @Autowired     private ProductApiService productApiService;      //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单，这时候要调用商品微服务查询商品信息");          // 之前调用         //通过restTemplate调用商品微服务         //Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);          //从nacos中获取服务地址         //ServiceInstance serviceInstance = discoveryClient.getInstances("service-product").get(0);         //String url = serviceInstance.getHost() + ":" +serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          //从nacos中获取服务地址 自定义规则实现随机挑选服务         //List<ServiceInstance> instances = discoveryClient.getInstances("service-product");         //int index = new Random().nextInt(instances.size());         //ServiceInstance serviceInstance = instances.get(index);         //String url = serviceInstance.getHost() + ":" + serviceInstance.getPort();         //log.info(">>从nacos中获取到的微服务地址为:" + url);         //Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);          // 基于Ribbon实现负载均衡         //直接使用微服务名字， 从nacos中获取服务地址         // String url = "service-product";         // Product product = restTemplate.getForObject( "http://" + url + "/product/" + pid, Product.class);          //通过fegin调用商品微服务         Product product = productApiService.findByPid(pid);           log.info(">>商品信息,查询结果:"+ JSON.toJSONString(product));         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(product.getPid());         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);         orderService.save(order);         return order;     } }

重启order微服务,查看效果

微服务环境搭建

Wed, 27 Jan 2021 13:27:00 GMT

我们本次是使用的电商项目中的商品、订单、用户为案例进行讲解.

案例准备

技术选型

maven: 3.3.9

数据库: MySQL 5.7

持久层: SpingData Jpa

其他: SpringCloud Alibaba 技术栈

模块设计

springcloud-alibaba 父工程

shop-common 公共模块【实体类】

shop-user 用户微服务【端口: 8071】

shop-product 商品微服务【端口: 8081】

shop-order 订单微服务【端口: 8091】

微服务调用

在微服务架构中，最常见的场景就是微服务之间的相互调用。我们以电商系统中常见的用户下单为例来演示微服务的调用:客户向订单微服务发起一个下单的请求，在进行保存订单之前需要调用商品微服务查询商品的信息。

我们一般把服务的主动调用方称为服务消费者，把服务的被调用方称为服务提供者。

在这种场景下，订单微服务就是一个服务消费者，商品微服务就是一个服务提供者。

创建数据库

DROP DATABASE IF EXISTS `shop`; CREATE DATABASE  `shop` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci; SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; USE `shop`; CREATE TABLE `shop_order` ( `oid` int NOT NULL AUTO_INCREMENT COMMENT '主键', `username` varchar(255) DEFAULT NULL COMMENT '用户名', `uid` int DEFAULT NULL COMMENT '用户id', `pid` int DEFAULT NULL COMMENT '商品ID', `pname` varchar(255) DEFAULT NULL COMMENT '商品名称', `pprice` decimal(10,2) DEFAULT NULL COMMENT '商品价格', `number` int DEFAULT NULL COMMENT '数量', PRIMARY KEY (`oid`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;  CREATE TABLE `shop_product` ( `pid` int NOT NULL AUTO_INCREMENT COMMENT '主键', `pname` varchar(255) DEFAULT NULL COMMENT '商品名称', `pprice` decimal(10,2) DEFAULT NULL COMMENT '商品价格', `stock` int DEFAULT NULL COMMENT '库存', PRIMARY KEY (`pid`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;  CREATE TABLE `shop_user` ( `uid` int NOT NULL AUTO_INCREMENT COMMENT '主键', `username` varchar(255) DEFAULT NULL COMMENT '用户名', `password` varchar(255) DEFAULT NULL COMMENT '密码', `telephone` varchar(255) DEFAULT NULL COMMENT '手机号', PRIMARY KEY (`uid`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

创建父工程

创建一个maven工程，然后在pom.xml文件中添加下面内容

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0           http://maven.apache.org/xsd/maven-4.0.0.xsd">     <modelVersion>4.0.0</modelVersion>     <parent>         <groupId>org.springframework.boot</groupId>         <artifactId>spring-boot-starter-parent</artifactId>         <version>2.1.3.RELEASE</version>     </parent>     <groupId>cn.maruifu</groupId>     <artifactId>springcloud-alibaba</artifactId>     <version>1.0-SNAPSHOT</version>     <packaging>pom</packaging>     <properties>         <java.version>1.8</java.version>         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>         <project.reporting.outputEncoding>UTF- 8</project.reporting.outputEncoding>         <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>         <spring-cloud-alibaba.version>2.1.0.RELEASE</spring-cloud-alibaba.version>     </properties>     <dependencyManagement>         <dependencies>             <dependency>                 <groupId>org.springframework.cloud</groupId>                 <artifactId>spring-cloud-dependencies</artifactId>                 <version>${spring-cloud.version}</version>                 <type>pom</type>                 <scope>import</scope>             </dependency>             <dependency>                 <groupId>com.alibaba.cloud</groupId>                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>                 <version>${spring-cloud-alibaba.version}</version>                 <type>pom</type>                 <scope>import</scope>             </dependency>         </dependencies>     </dependencyManagement> </project>

版本对应：

创建基础模块

创建 shop-common 模块:

在pom.xml中添加依赖

<?xml version="1.0" encoding="UTF-8"?>  <project xmlns="http://maven.apache.org/POM/4.0.0"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0          http://maven.apache.org/xsd/maven-4.0.0.xsd">     <parent>         <artifactId>springcloud-alibaba</artifactId>         <groupId>cn.maruifu</groupId>         <version>1.0-SNAPSHOT</version>     </parent>     <modelVersion>4.0.0</modelVersion>     <artifactId>shop-common</artifactId>     <dependencies>         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-data-jpa</artifactId>         </dependency>         <dependency>             <groupId>org.projectlombok</groupId>             <artifactId>lombok</artifactId>         </dependency>         <dependency>             <groupId>com.alibaba</groupId>             <artifactId>fastjson</artifactId>             <version>1.2.56</version>         </dependency>         <dependency>             <groupId>mysql</groupId>             <artifactId>mysql-connector-java</artifactId>             <version>5.1.6</version>         </dependency>     </dependencies> </project>

创建实体类

//用户 import lombok.Data; import javax.persistence.Id; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; @Entity(name = "shop_user") @Data public class User {     @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Integer uid;//主键      private String username;//用户名      private String password;//密码      private String telephone;//手机号  }  //商品 import lombok.Data; import javax.persistence.Id; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; @Entity(name = "shop_product") @Data public class Product {     @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Integer pid;//主键      private String pname;//商品名称      private Double pprice;//商品价格      private Integer stock;//库存  }  //订单 package cn.maruifu.vo;  import lombok.Data; import javax.persistence.Id;  import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType;  //订单 @Entity(name = "shop_order") @Data public class Order {     @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long oid;//订单id      private Integer uid;//用户id      private String username;//用户名      private Integer pid;//商品ID       private String pname;//商品名称      private Double pprice;//商品价格      private Integer number;//数量  }

创建用户微服务

新建一个 shop-user 模块，然后进行下面操作

创建pom.xml

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0          http://maven.apache.org/xsd/maven-4.0.0.xsd">      <parent>         <artifactId>springcloud-alibaba</artifactId>         <groupId>cn.maruifu</groupId>         <version>1.0-SNAPSHOT</version>     </parent>     <modelVersion>4.0.0</modelVersion>     <artifactId>shop-user</artifactId>     <dependencies>         <dependency>             <groupId>cn.maruifu</groupId>             <artifactId>shop-common</artifactId>             <version>1.0-SNAPSHOT</version>         </dependency>         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-web</artifactId>         </dependency>     </dependencies> </project>

编写主类

package cn.maruifu;  import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;  @SpringBootApplication public class UserApplication {     public static void main(String[] args) {         SpringApplication.run(UserApplication.class, args);     } }

创建配置文件

server:   port: 8071 spring:   application:     name: service-user   datasource:     url: jdbc:mysql://127.0.0.1:3306/spring-cloud?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true     username: root     password: Mrf12345     driver-class-name: com.mysql.cj.jdbc.Driver   jpa:     database-platform: org.hibernate.dialect.MySQL5InnoDBDialect     show-sql: true     hibernate:       ddl-auto: update       use-new-id-generator-mappings: false

创建商品微服务

创建pom.xml

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <parent>         <artifactId>springcloud-alibaba</artifactId>         <groupId>cn.maruifu</groupId>         <version>1.0-SNAPSHOT</version>     </parent>     <modelVersion>4.0.0</modelVersion>     <artifactId>shop-product</artifactId>     <dependencies>         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-web</artifactId>         </dependency>         <dependency>             <groupId>cn.maruifu</groupId>             <artifactId>shop-common</artifactId>             <version>1.0-SNAPSHOT</version>         </dependency>     </dependencies> </project>

编写主类

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

创建配置文件

server:   port: 8081 spring:   application:     name: service-product   datasource:     url: jdbc:mysql://shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true     username: root     password: root     driver-class-name: com.mysql.cj.jdbc.Driver    jpa:     database-platform: org.hibernate.dialect.MySQL5InnoDBDialect     show-sql: true     hibernate:       ddl-auto: update       use-new-id-generator-mappings: false

创建ProductDao接口

package cn.maruifu.dao;  import cn.maruifu.vo.Product; import org.springframework.data.jpa.repository.JpaRepository;  public interface ProductDao extends JpaRepository<Product,Integer>  { }

创建ProductService类

package cn.maruifu.service.impl;  import cn.maruifu.dao.ProductDao; import cn.maruifu.service.ProductService; import cn.maruifu.vo.Product; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;   @Service public class ProductServiceImpl implements ProductService {      @Autowired     private ProductDao productDao;       @Override     public Product findByPid(Integer pid) {         return productDao.findById(pid).get();     }  }

创建Controller

package cn.maruifu.controller;  import cn.maruifu.service.ProductService; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController;  @RestController @Slf4j public class ProductController {      @Autowired     private ProductService productService;     @GetMapping("/product/{pid}")     public Product product(@PathVariable("pid") Integer pid) {         Product product = productService.findByPid(pid);         log.info("查询到商品:" + JSON.toJSONString(product));         return product;     }  }

启动工程

等到数据库表创建完毕之后，加入测试数据

INSERT INTO shop_product VALUE(NULL,'小米','1000','5000');   INSERT INTO shop_product VALUE(NULL,'华为','2000','5000');   INSERT INTO shop_product VALUE(NULL,'苹果','3000','5000');   INSERT INTO shop_product VALUE(NULL,'OPPO','4000','5000');

通过浏览器访问服务

创建订单微服务

创建pom.xml

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <parent>         <artifactId>springcloud-alibaba</artifactId>         <groupId>cn.maruifu</groupId>         <version>1.0-SNAPSHOT</version>     </parent>     <modelVersion>4.0.0</modelVersion>     <artifactId>shop-order</artifactId>     <dependencies>         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-web</artifactId>         </dependency>         <dependency>             <groupId>cn.maruifu</groupId>             <artifactId>shop-common</artifactId>             <version>1.0-SNAPSHOT</version>         </dependency>     </dependencies> </project>

编写主类

package cn.maruifu;  import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;  @SpringBootApplication public class OrderApplication {     public static void main(String[] args) {          SpringApplication.run(OrderApplication.class, args);      } }

创建配置文件

server:   port: 8091 spring:   application:     name: service-order   datasource:     driver-class-name: com.mysql.cj.jdbc.Driver     url: jdbc:mysql://shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true     username: root     password: root       jpa:     database-platform: org.hibernate.dialect.MySQL5InnoDBDialect     show-sql: true     hibernate:       ddl-auto: update       use-new-id-generator-mappings: false

创建OrderDao接口

package cn.maruifu.dao;  import cn.maruifu.vo.Order; import org.springframework.data.jpa.repository.JpaRepository;  public interface OrderDao extends JpaRepository<Order,Long> {  }

创建OrderService类

package cn.maruifu.service.impl;  import cn.maruifu.dao.OrderDao; import cn.maruifu.service.OrderService; import cn.maruifu.vo.Order; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;  @Service public class OrderServiceImpl implements OrderService {      @Autowired     private OrderDao orderDao;      @Override     public void save(Order order) {         orderDao.save(order);     } }

创建RestTemplate

package cn.maruifu;  import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; import org.springframework.web.client.RestTemplate;  @SpringBootApplication public class OrderApplication {     public static void main(String[] args) {         SpringApplication.run(OrderApplication.class, args);     }       @Bean     public RestTemplate getRestTemplate() {         return new RestTemplate();     } }

创建Controller

package cn.maruifu.controller;  import cn.maruifu.service.OrderService; import cn.maruifu.vo.Order; import cn.maruifu.vo.Product; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;  @RestController @Slf4j public class OrderController {      @Autowired     private RestTemplate restTemplate;     @Autowired     private OrderService orderService;     //准备买1件商品     @GetMapping("/order/prod/{pid}")     public Order order(@PathVariable("pid") Integer pid) {         log.info(">>客户下单，这时候要调用商品微服务查询商品信息");         //通过restTemplate调用商品微服务         Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);         log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));         Order order = new Order();         order.setUid(1);         order.setUsername("测试用户");         order.setPid(product.getPid());         order.setPname(product.getPname());         order.setPprice(product.getPprice());         order.setNumber(1);         orderService.save(order);         return order;     } }

浏览器访问服务进行测试

源码地址

微服务介绍

Mon, 25 Jan 2021 13:42:00 GMT

系统架构演变

随着互联网的发展，网站应用的规模也在不断的扩大，进而导致系统架构也在不断的进行变化。从互联网早期到现在，系统架构大体经历了下面几个过程: 单体应用架构--->垂直应用架构--->分布式架构--- >SOA架构--->微服务架构，当然还有悄然兴起的Service Mesh(服务网格化)。接下来我们就来了解一下每种系统架构是什么样子的，以及各有什么优缺点。

单体应用架构

互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这样可以减少开发、部署和维护的成本。

比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块，我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。

优点

项目架构简单，小型项目的话，开发成本低
项目部署在一个节点上，维护方便

缺点

全部功能集成在一个工程中，对于大型项目来讲不易开发和维护
项目模块之间紧密耦合，单点容错率低
无法针对不同模块进行针对性优化和水平扩展

垂直应用架构

随着访问量的逐渐增大，单一应用只能依靠增加节点来应对，但是这时候会发现并不是所有的模块都会有比较大的访问量。

还是以上面的电商为例子，用户访问量的增加可能影响的只是用户和订单模块，但是对消息模块的影响就比较小. 那么此时我们希望只多增加几个订单模块，而不增加消息模块. 此时单体应用就做不到了，垂直应用就应运而生了。

所谓的垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效率。比如我们可以将上面电商的单体应用拆分成:

电商系统(用户管理商品管理订单管理)
后台系统(用户管理订单管理客户管理)
CMS系统(广告管理营销管理)

这样拆分完毕之后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而无需增加后台和CMS的节点。

分布式架构

当垂直应用越来越多，重复的业务代码就会越来越多。这时候，我们就思考可不可以将重复的代码抽取出来，做成统一的业务层作为独立的服务，然后由前端控制层调用不同的业务层服务呢?这就产生了新的分布式系统架构。它将把工程拆分成表现层和服务层两个部分，服务层中包含业务逻辑。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

优点

抽取公共的功能为服务层，提高代码复用性

缺点

系统间耦合度变高，调用关系错综复杂，难以维护

SOA架构

在分布式架构下，当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心对集群进行实时管理。此时，用于资源调度和治理中心(SOA Service OrientedArchitecture，面向服务的架构)是关键。

优点

使用注册中心解决了服务间调用关系的自动调节

缺点

服务间会有依赖关系，一旦某个环节出错会影响较大( 服务雪崩 )
服务关心复杂，运维、测试部署困难

微服务架构

微服务架构在某种程度上是面向服务的架构SOA继续发展的下一步，它更加强调服务的"彻底拆分"。

优点

服务原子化拆分，独立打包、部署和升级，保证每个微服务清晰的任务划分，利于扩展
微服务之间采用Restful等轻量级http协议相互调用

缺点:

分布式系统开发的技术成本高(容错、分布式事务等)

微服务架构介绍

微服务架构，简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。

微服务架构的常见问题

一旦采用微服务系统架构，就势必会遇到这样几个问题:

这么多小服务，如何管理他们?(服务治理注册中心[服务注册发现剔除])
这么多小服务，他们之间如何通讯?(restful rpc )
这么多小服务，客户端怎么访问他们?(网关)
这么多小服务，一旦出现问题了，应该如何自处理?(容错)
这么多小服务，一旦出现问题了，应该如何排错? (链路追踪)

对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。

微服务架构的常见概念

服务治理

服务治理就是进行服务的自动化管理，其核心是服务的自动注册与发现。

服务注册:服务实例将自身服务信息注册到注册中心。
服务发现:服务实例通过注册中心，获取到注册到其中的服务实例的信息，通过这些信息去请求它们提供的服务。
服务剔除:服务注册中心将出问题的服务自动剔除到可用列表之外，使其不会被调用到。

服务调用

在微服务架构中，通常存在多个服务之间的远程调用的需求。目前主流的远程调用技术有基于HTTP的RESTful接口以及基于TCP的RPC协议。

REST(Representational State Transfer):这是一种HTTP调用的格式，更标准，更通用，无论哪种语言都支持http协议
RPC(Remote Promote Call):一种进程间通信方式。允许像调用本地服务一样调用远程服务。 RPC框架的主要目标就是让远程服务调用更简单、透明。RPC框架负责屏蔽底层的传输方式、序列化方式和通信细节。开发人员在使用的时候只需要了解谁在什么位置提供了什么样的远程服务接口即可，并不需要关心底层通信细节和调用过程。

区别与联系

比较项	RESTful	RPC
通讯协议	HTTP	一般使用TCP
性能	略低	较高
灵活度	高	较高
应用	微服务架构	SOA架构

服务网关

随着微服务的不断增多，不同的微服务一般会有不同的网络地址，而外部客户端可能需要调用多个服务的接口才能完成一个业务需求，如果让客户端直接与各个微服务通信可能出现:

客户端需要调用不同的url地址，增加难度
在一定的场景下，存在跨域请求的问题
每个微服务都需要进行单独的身份认证

针对这些问题，API网关顺势而生。

API网关直面意思是将所有API调用统一接入到API网关层，由网关层统一接入和输出。一个网关的基本功能有:统一接入、安全防护、协议适配、流量管控、长短链接支持、容错能力。有了网关之后，各个 API服务提供团队可以专注于自己的的业务逻辑处理，而API网关更专注于安全、流量、路由等问题。

服务容错

在微服务当中，一个请求经常会涉及到调用几个服务，如果其中某个服务不可用，没有做服务容错的话，极有可能会造成一连串的服务不可用，这就是雪崩效应。我们没法预防雪崩效应的发生，只能尽可能去做好容错。服务容错的三个核心思想是:

不被外界环境影响
不被上游请求压垮
不被下游响应拖垮

链路追踪

随着微服务架构的流行，服务按照不同的维度进行拆分，一次请求往往需要涉及到多个服务。互联网应用构建在不同的软件模块集上，这些软件模块，有可能是由不同的团队开发、可能使用不同的编程语言来实现、有可能布在了几千台服务器，横跨多个不同的数据中心。因此，就需要对一次请求涉及的多个服务链路进行日志记录，性能监控即链路追踪

微服务架构的常见解决方案

ServiceComb

Apache ServiceComb，前身是华为云的微服务引擎 CSE (Cloud Service Engine) 云服务，是全球首个 Apache微服务顶级项目。它提供了一站式的微服务开源解决方案，致力于帮助企业、用户和开发者将企业应用轻松微服务化上云，并实现对微服务应用的高效运维管理。

SpringCloud

Spring Cloud是一系列框架的集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。

Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

SpringCloud Alibaba

Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。

SpringCloud Alibaba介绍

Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。

主要功能

服务限流降级:默认支持 WebServlet、WebFlux， OpenFeign、RestTemplate、Spring CloudGateway， Zuul， Dubbo 和 RocketMQ 限流降级功能的接入，可以在运行时通过控制台实时修改限流降级规则，还支持查看限流降级 Metrics 监控。
服务注册与发现:适配 Spring Cloud 服务注册与发现标准，默认集成了 Ribbon 的支持。
分布式配置管理:支持分布式系统中的外部化配置，配置更改时自动刷新。
消息驱动能力:基于 Spring Cloud Stream 为微服务应用构建消息驱动能力。
分布式事务:使用 @GlobalTransactional 注解，高效并且对业务零侵入地解决分布式事务问题。
阿里云对象存储:阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。
分布式任务调度:提供秒级、精准、高可靠、高可用的定时(基于 Cron 表达式)任务调度服务。同时提供分布式的任务执行模型，如网格任务。网格任务支持海量子任务均匀分配到所有 Worker(schedulerx-client)上执行。
阿里云短信服务:覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

组件

Sentinel:把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
Nacos:一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
RocketMQ:一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。
Dubbo:Apache DubboTM 是一款高性能 Java RPC 框架。
Seata:阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。
Alibaba Cloud ACM:一款在分布式架构环境中对应用配置进行集中管理和推送的应用配置中心产品。
Alibaba Cloud OSS: 阿里云对象存储服务(Object Storage Service，简称 OSS)，是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。
Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时(基于 Cron 表达式)任务调度服务。
Alibaba Cloud SMS: 覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

Typora + uPic +Chevereto 完美组合

Sun, 24 Jan 2021 15:58:00 GMT

对于用 Markdown 来写博客的用户来说，图片的引用问题是个众所周知的难题。使用了这套组合后，妈妈再也不用担心我图片链接失效打不开了。

工具下载安装：

Typora ： https://www.typora.io/

uPic ：从 Github release 下载。如果访问 Github 下载困难的，可以从Gitee release下载。

Chevereto ：https://chevereto.com/ ，群晖安装可以参考我之前的文章 http://maruifu.cn/article/142

Typora上传设置

插入图片时选择：上传图片

勾选： 对本地位置的图片应用上述规则

勾选： 对网络位置的图片应用上述规则

上传服务选择：uPic

Typora上传设置

uPic上传设置

API Key: 在浏览器登录你的Chevereto后，打开仪表盘->设置->API。拷贝 API v1 Key

获取API Key

API 地址：[你的 Chevereto 地址]/api/1/upload。例如 https://demo.chevereto.com/api/1/upload

请求方式: POST 使用 Base64: 勾选 文件字段名: source

其他字段：

增加Headers字段： Content-Type:multipart/form-data; charset=utf-8;

增加Body字段：

key: 填写上面准备好的 [API Key]

action: upload

uPic其他字段设置

URL 路径：上传完成后获取图片链接的路径。['image', 'url']

uPic上传设置

自定义chevereto上传用户（可选）

获取root权限

admin@XiaoMageNAS:~$ sudo -i root@XiaoMageNAS:~#

查看运行的docker容器

root@XiaoMageNAS:~# docker ps -a CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS                  PORTS                                                      NAMES f3e5f503f36d        bitwardenrs/server:1.18.0   "/start.sh"              4 days ago          Up 12 hours (healthy)   0.0.0.0:32769->80/tcp, 0.0.0.0:32777->3012/tcp             bitwardenrs 8f0cd2b10c84        gogs/gogs:latest            "/app/gogs/docker/st…"   5 weeks ago         Up 5 days               3000/tcp, 0.0.0.0:32768->22/tcp, 0.0.0.0:32770->3001/tcp   gogs-gogs1 c986eeb9d23d        portainer/portainer         "/portainer"             6 weeks ago         Up 5 days               0.0.0.0:9999->9000/tcp                                     portainer 5bd176c39f27        nmtan/chevereto:latest      "docker-php-entrypoi…"   6 months ago        Up 12 hours             0.0.0.0:10000->80/tcp                                      nmtan-chevereto1

进入chevereto容器 docker exec -it 5bd176c39f27 bash

退出容器chevereto容器 exit

复制容器中的文件到本地目录

 docker cp  5bd176c39f27:/var/www/html/app/routes/route.api.php /volume1/docker/

修改配置文件

vi /volume1/docker/route.api.php // 将此105行代码$uploaded_id = CHV\Image::uploadToWebsite($source);  修改为下面代码 $uploaded_id = CHV\Image::uploadToWebsite($source, 'xiaomage');

这里的xiaomage是要传的用户名，可以设置->账户->用户名查看

复制到容器目录里面

docker cp /volume1/docker/route.api.php 5bd176c39f27:/var/www/html/app/routes/overrides/

Git的奇技淫巧

Mon, 21 Dec 2020 15:41:00 GMT

Git是一个 “分布式版本管理工具”，简单的理解版本管理工具：大家在写东西的时候都用过 “回撤” 这个

功能，但是回撤只能回撤几步，假如想要找回我三天之前的修改，光用 “回撤” 是找不回来的。而 “版本

管理工具” 能记录每次的修改，只要提交到版本仓库，你就可以找到之前任何时刻的状态（文本状

态）。

下面的内容就是列举了常用的 Git 命令和一些小技巧，可以通过 "页面内查找" 的方式进行快速查询：

Ctrl/Command+f 。

前言

一定要先测试命令的效果后，再用于工作环境中，以防造成不能弥补的后果！
所有的命令都在 git version 2.7.4 (Apple Git-66) 下测试通过
统一概念：
- 工作区：改动（增删文件和内容）
- 暂存区：输入命令： git add 改动的文件名，此次改动就放到了 ‘暂存区’
- 本地仓库(简称：本地)：输入命令： git commit 此次修改的描述，此次改动就放到了 ’本地
  
  仓库’，每个 commit，我叫它为一个 ‘版本’。
- 远程仓库(简称：远程)：输入命令： git push 远程仓库，此次改动就放到了 ‘远程仓
  
  库’（GitHub 等)
- commit-id：输出命令： git log ，最上面那行 commit xxxxxx ，后面的字符串就是
  
  commit-id

展示帮助信息

git help -g

The command output as below:

   The common Git guides are:       attributes          Defining attributes per path       cli                 Git command-line interface and conventions       core-tutorial       A Git core tutorial for developers       cvs-migration       Git for CVS users       diffcore            Tweaking diff output       everyday            A useful minimum set of commands for Everyday Git       glossary            A Git Glossary       hooks               Hooks used by Git       ignore              Specifies intentionally untracked files to ignore       modules             Defining submodule properties       namespaces          Git namespaces       repository-layout   Git Repository Layout       revisions           Specifying revisions and ranges for Git       tutorial            A tutorial introduction to Git       tutorial-2          A tutorial introduction to Git: part two       workflows           An overview of recommended workflows with Git     'git help -a' and 'git help -g' list available subcommands and some    concept guides. See 'git help <command>' or 'git help <concept>'    to read about a specific subcommand or concept.    See 'git help git' for an overview of the system.

回到远程仓库的状态

抛弃本地所有的修改，回到远程仓库的状态。

   git fetch --all && git reset --hard origin/master

重设第一个commit

也就是把所有的改动都重新放回工作区，并清空所有的 commit，这样就可以重新提交第一个 commit

了

   git update-ref -d HEAD

查看冲突文件列表

   git diff --name-only --diff-filter=U

展示工作区和暂存区的不同

输出工作区和暂存区的 difffferent (不同)。

   git diff

还可以展示本地仓库中任意两个 commit 之间的文件变动：

   git diff <commit-id> <commit-id>

展示暂存区和最近版本的不同

输出暂存区和本地最近的版本 (commit) 的 difffferent (不同)。

   git diff --cached

展示暂存区、工作区和最近版本的不同

输出工作区、暂存区 和本地最近的版本 (commit) 的 difffferent (不同)。

   git diff HEAD

快速切换到上一个分支

   git checkout -

删除已经合并到 master 的分支

   git branch --merged master | grep -v '^\*\| master' | xargs -n 1 git branch -d

展示本地分支关联远程仓库的情况

   git branch -vv

关联远程分支

关联之后， git branch -vv 就可以展示关联的远程分支名了，同时推送到远程仓库直接： git

push ，不需要指定远程仓库了。

   git branch -u origin/mybranch

或者在 push 时加上 -u 参数

   git push origin/mybranch -u

列出所有远程分支

-r 参数相当于：remote

   git branch -r

列出本地和远程分支

-a 参数相当于：all

   git branch -a

查看远程分支和本地分支的对应关系

   git remote show origin

远程删除了分支本地也想删除

   git remote prune origin

创建并切换到本地分支

   git checkout -b <branch-name>

从远程分支中创建并切换到本地分支

   git checkout -b <branch-name> origin/<branch-name>

删除本地分支

   git branch -d <local-branchname>

删除远程分支

   git push origin --delete <remote-branchname>

或者

   git push origin :<remote-branchname>

重命名本地分支

   git branch -m <new-branch-name>

重命名本地分支和远程分支

   # 修改本地分支名    git branch -m <old-branch-name> <new-branch-name>    # 删除远程分支    git push origin --delete <old-branch-name>    # 改名后的本地分支推送到远程    git push --set-upstream origin <new-branch-name>

查看标签

   git tag

展示当前分支的最近的 tag

   git describe --tags --abbrev=0

查看标签详细信息

   git tag -ln

本地创建标签

   git tag <version-number>

默认 tag 是打在最近的一次 commit 上，如果需要指定 commit 打 tag：

   $ git tag -a <version-number> -m "v1.0 发布(描述)" <commit-id>

推送标签到远程仓库

首先要保证本地创建好了标签才可以推送标签到远程仓库：

   git push origin <local-version-number>

一次性推送所有标签，同步到远程仓库

   git push origin --tags

删除本地标签

   git tag -d <tag-name>

删除远程标签

   git push origin --delete tag <tagname>

切回到某个标签

一般上线之前都会打 tag，就是为了防止上线后出现问题，方便快速回退到上一版本。下面的命令是回

到某一标签下的状态：

   git checkout -b branch_name tag_name

放弃工作区的修改

   git checkout <file-name>

放弃所有修改

   git checkout .

恢复删除的文件

   git rev-list -n 1 HEAD -- <file_path> #得到 deleting_commit      git checkout <deleting_commit>^ -- <file_path> #回到删除文件 deleting_commit 之前的 状态

以新增一个 commit 的方式还原某一个 commit 的修改

   git revert <commit-id>

回到某个 commit 的状态，并删除后面的 commit

和 revert 的区别：reset 命令会抹去某个 commit id 之后的所有 commit

   git reset <commit-id> #默认就是-mixed参数。      git reset --mixed HEAD^ #回退至上个版本，它将重置HEAD到另外一个commit,并且重置暂存区以便 和HEAD相匹配，但是也到此为止。工作区不会被更改。      git reset --soft HEAD~3 #回退至三个版本之前，只回退了commit的信息，暂存区和工作区与回退之 前保持一致。如果还要提交，直接commit即可      git reset --hard <commit-id> #彻底回退到指定commit-id的状态，暂存区和工作区也会变为指定 commit-id版本的内容

修改上一个 commit 的描述

如果暂存区有改动，同时也会将暂存区的改动提交到上一个 commit

   git commit --amend

查看 commit 历史

   git log

查看某段代码是谁写的

blame 的意思为‘责怪’，你懂的。

   git blame <file-name>

显示本地更新过 HEAD 的 git 命令记录

每次更新了 HEAD 的 git 命令比如 commit、amend、cherry-pick、reset、revert 等都会被记录下来

（不限分支），就像 shell 的 history 一样。

这样你可以 reset 到任何一次更新了 HEAD 的操作之后，而不仅仅是回到当前分支下的某个 commit 之

后的状态。

   git reflog

修改作者名

   git commit --amend --author='Author Name <email@address.com>'

修改远程仓库的 url

   git remote set-url origin <URL>

增加远程仓库

   git remote add origin <remote-url>

列出所有远程仓库

   git remote

查看两个星期内的改动

   git whatchanged --since='2 weeks ago'

把 A 分支的某一个 commit，放到 B 分支上

   git checkout <branch-name> && git cherry-pick <commit-id>

给 git 命令起别名

简化命令

   git config --global alias.<handle> <command>     比如：git status 改成 git st，这样可以简化命令     git config --global alias.st status

存储当前的修改，但不用提交 commit

参考廖雪峰老师的教程

   git stash

保存当前状态，包括 untracked 的文件

untracked 文件：新建的文件

   git stash -u

展示所有 stashes

   git stash list

回到某个 stash 的状态

   git stash apply <stash@{n}>

回到最后一个 stash 的状态，并删除这个 stash

   git stash pop

删除所有的 stash

   git stash clear

从 stash 中拿出某个文件的修改

   git checkout <stash@{n}> -- <file-path>

展示所有 tracked 的文件

   git ls-files -t

展示所有 untracked 的文件

   git ls-files --others

展示所有忽略的文件

   git ls-files --others -i --exclude-standard

强制删除 untracked 的文件

可以用来删除新建的文件。如果不指定文件文件名，则清空所有工作的 untracked 文件。 clean 命

令，注意两点：

clean 后，删除的文件无法找回
不会影响 tracked 的文件的改动，只会删除 untracked 的文件
```
git clean <file-name> -f 
```

强制删除 untracked 的目录

可以用来删除新建的目录，注意:这个命令也可以用来删除 untracked 的文件。详情见上一条

   git clean <directory-name> -df

展示简化的 commit 历史

   git log --pretty=oneline --graph --decorate --all

把某一个分支到导出成一个文件

   git bundle create <file> <branch-name>

从包中导入分支

新建一个分支，分支内容就是上面 git bundle create 命令导出的内容

   git clone repo.bundle <repo-dir> -b <branch-name>

执行 rebase 之前自动 stash

   git rebase --autostash

从远程仓库根据 ID，拉下某一状态，到本地分支详细展示一行中的修改

   git fetch origin pull/<id>/head:<branch-name>

详细展示一行中的修改

   git diff --word-diff

清除 .gitignore 文件中记录的文件

   git clean -X -f

展示所有 alias 和 confifigs

注意： confifig 分为：当前目录（local）和全局（golbal）的 confifig，默认为当前目录的 confifig

   git config --local --list (当前目录)     git config --global --list (全局)

展示忽略的文件

   git status --ignored

commit 历史中显示 Branch1 有的，但是 Branch2 没有 commit

   git log Branch1 ^Branch2

在 commit log 中显示 GPG 签名

   git log --show-signature

删除全局设置

   git config --global --unset <entry-name>

新建并切换到新分支上，同时这个分支没有任何 commit

相当于保存修改，但是重写 commit 历史

   git checkout --orphan <branch-name>

展示任意分支某一文件的内容

   git show <branch-name>:<file-name>

clone 下来指定的单一分支

   git clone -b <branch-name> --single-branch https://github.com/user/repo.git

clone 最新一次提交

只会 clone 最近一次提交，将减少 clone 时间

   git clone --depth=1 https://github.com/user/repo.git

忽略某个文件的改动

关闭 track 指定文件的改动，也就是 Git 将不会在记录这个文件的改动

   git update-index --assume-unchanged path/to/file

恢复 track 指定文件的改动

   git update-index --no-assume-unchanged path/to/file

忽略文件的权限变化

不再将文件的权限变化视作改动

   git config core.fileMode false

以最后提交的顺序列出所有 Git 分支

在 commit log 中查找相关内容

通过 grep 查找，given-text：所需要查找的字段

   git log --all --grep='<given-text>'

把暂存区的指定 fifile 放到工作区中

不添加参数，默认是 -mixed

   git reset <file-name>

强制推送

   git push -f <remote-name> <branch-name>

git 配置 http 和 socks 代理

   git config --global https.proxy 'http://127.0.0.1:8001' # 适用于 privoxy 将 socks 协议转为 http 协议的 http 端口      git config --global http.proxy 'http://127.0.0.1:8001'      git config --global socks.proxy "127.0.0.1:1080"

git 配置 ssh 代理

   $ cat ~/.ssh/config     Host gitlab.com     ProxyCommand nc -X 5 -x 127.0.0.1:1080 %h %p # 直接使用 shadowsocks 提供的socks5 代理端口    Host github.com     ProxyCommand nc -X 5 -x 127.0.0.1:1080 %h %p

推送镜像

git push --mirror  $URL

一图详解

优雅的提交Commit信息

使用Angular团队提交规范

主要有以下组成

标题行: 必填, 描述主要修改类型和内容
主题内容: 描述为什么修改, 做了什么样的修改, 以及开发的思路等等
页脚注释: 放 Breaking Changes 或 Closed Issues

常用的修改项
type: commit 的类型
feat: 新特性
fifix: 修改问题
refactor: 代码重构
docs: 文档修改
style: 代码格式修改, 注意不是 css 修改
test: 测试用例修改
chore: 其他修改, 比如构建流程, 依赖管理.
scope: commit 影响的范围, 比如: route, component, utils, build...
subject: commit 的概述
body: commit 具体修改内容, 可以分为多行
footer: 一些备注, 通常是 BREAKING CHANGE 或修复的 bug 的链接.

使用Commitizen 代替 git commit

可以使用cz-cli工具代替 git commit

全局安装

npm install -g commitizen

Commitizen适配器

如果需要在项目中使用commitizen生成符合AngularJS规范的提交说明，初始化cz-conventional-changelog适配器：

npm init -y commitizen init cz-conventional-changelog --save --save-exact

如果当前已经有其他适配器被使用，则会报以下错误，此时可以加上--force选项进行再次初始化

Error: A previous adapter is already configured. Use --force to override

全局安装后使用 git cz 代替git commit 就可以了,如下：

? Select the type of change that you're committing: (Use arrow keys) ❯ feat:     A new feature    fix:      A bug fix    docs:     Documentation only changes    style:    Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)    refactor: A code change that neither fixes a bug nor adds a feature    perf:     A code change that improves performance    test:     Adding missing tests or correcting existing tests

#查询全局node_modules路径 npm root -g #修改类型 node_modules/conventional-commit-types/index.json #修改描述 node_modules/cz-conventional-changelog/engine.js

你还在new对象吗？Java8通用Builder了解一下？

Sat, 14 Nov 2020 12:41:43 GMT

文章转载自: http://www.ciphermagic.cn/java8-builder.html

程序员经常会遇到灵魂拷问：你有对象吗？

没有，但我可以 new 一个！

public class GirlFriend {     private String name;     private int age;     // 省略 getter & setter ...     public static void main(String[] args) {         GirlFriend myGirlFriend = new GirlFriend();         myGirlFriend.setName("小美");         myGirlFriend.setAge(18);     } }

没问题，老铁！但如果对象的属性太多，咋办？

public class GirlFriend {      private String name;     private int age;     private int bust;     private int waist;     private int hips;     private List<String> hobby;     private String birthday;     private String address;     private String mobile;     private String email;     private String hairColor;     private Map<String, String> gift;     // 等等等等 ...      // 省略 getter & setter ...      public static void main(String[] args) {         GirlFriend myGirlFriend = new GirlFriend();         myGirlFriend.setName("小美");         myGirlFriend.setAge(18);         myGirlFriend.setBust(33);         myGirlFriend.setWaist(23);         myGirlFriend.setHips(33);         myGirlFriend.setBirthday("2001-10-26");         myGirlFriend.setAddress("上海浦东");         myGirlFriend.setMobile("18688888888");         myGirlFriend.setEmail("pretty-xiaomei@qq.com");         myGirlFriend.setHairColor("浅棕色带点微卷");         List<String> hobby = new ArrayList<>();         hobby.add("逛街");         hobby.add("购物");         hobby.add("买东西");         myGirlFriend.setHobby(hobby);         Map<String, String> gift = new HashMap<>();         gift.put("情人节礼物", "LBR 1912女王时代");         gift.put("生日礼物", "迪奥烈焰蓝金");         gift.put("纪念日礼物", "阿玛尼红管唇釉");         myGirlFriend.setGift(gift);         // 等等等等 ...     } }

GirlFriend{name='小美' , age=18 , bust=33 , waist=23 , hips=33 , hobby=[逛街, 购物, 买东西] , birthday='2001-10-26' , address='上海浦东' , mobile='18688888888' , email='pretty-xiaomei@qq.com' , hairColor='浅棕色带点微卷' , gift={情人节礼物=LBR 1912女王时代, 生日礼物=迪奥烈焰蓝金, 纪念日礼物=阿玛尼红管唇釉} }

GirlFriend 是很美，但写起来也太麻烦了吧。

说说缺点：实例化和设置属性分开，不好维护；变量名重复写。

莫慌，看法宝~

这里不再介绍其他 Builder 实现方式，直接祭出最实用的通用Builder：

适用于所有类，不需要改造原来类，不需要 lombok 插件支持。

先看看使用姿势：

public class GirlFriend {     // 省略属性 ...     // 省略 getter & setter ...          // 为了演示方便，加几个聚合方法     public void addHobby(String hobby) {         this.hobby = Optional.ofNullable(this.hobby).orElse(new ArrayList<>());         this.hobby.add(hobby);     }     public void addGift(String day, String gift) {         this.gift = Optional.ofNullable(this.gift).orElse(new HashMap<>());         this.gift.put(day, gift);     }     public void setVitalStatistics(int bust, int waist, int hips) {         this.bust = bust;         this.waist = waist;         this.hips = hips;     }     public static void main(String[] args) {         GirlFriend myGirlFriend = Builder.of(GirlFriend::new)                 .with(GirlFriend::setName, "小美")                 .with(GirlFriend::setAge, 18)                 .with(GirlFriend::setVitalStatistics, 33, 23, 33)                 .with(GirlFriend::setBirthday, "2001-10-26")                 .with(GirlFriend::setAddress, "上海浦东")                 .with(GirlFriend::setMobile, "18688888888")                 .with(GirlFriend::setEmail, "pretty-xiaomei@qq.com")                 .with(GirlFriend::setHairColor, "浅棕色带点微卷")                 .with(GirlFriend::addHobby, "逛街")                 .with(GirlFriend::addHobby, "购物")                 .with(GirlFriend::addHobby, "买东西")                 .with(GirlFriend::addGift, "情人节礼物", "LBR 1912女王时代")                 .with(GirlFriend::addGift, "生日礼物", "迪奥烈焰蓝金")                 .with(GirlFriend::addGift, "纪念日礼物", "阿玛尼红管唇釉")                 // 等等等等 ...                 .build();     } }

看到了吗！实例化和属性设置在同一条语句执行，链式操作，一路点点点，清爽！

Talk is cheap, show me the code：

/**  * 通用的 Builder 模式构建器  *  * @author: CipherCui  * @since 2019/8/29  */ public class Builder<T> {     private final Supplier<T> instantiator;     private List<Consumer<T>> modifiers = new ArrayList<>();     public Builder(Supplier<T> instantiator) {         this.instantiator = instantiator;     }     public static <T> Builder<T> of(Supplier<T> instantiator) {         return new Builder<>(instantiator);     }     public <P1> Builder<T> with(Consumer1<T, P1> consumer, P1 p1) {         Consumer<T> c = instance -> consumer.accept(instance, p1);         modifiers.add(c);         return this;     }     public <P1, P2> Builder<T> with(Consumer2<T, P1, P2> consumer, P1 p1, P2 p2) {         Consumer<T> c = instance -> consumer.accept(instance, p1, p2);         modifiers.add(c);         return this;     }     public <P1, P2, P3> Builder<T> with(Consumer3<T, P1, P2, P3> consumer, P1 p1, P2 p2, P3 p3) {         Consumer<T> c = instance -> consumer.accept(instance, p1, p2, p3);         modifiers.add(c);         return this;     }     public T build() {         T value = instantiator.get();         modifiers.forEach(modifier -> modifier.accept(value));         modifiers.clear();         return value;     }     /**      * 1 参数 Consumer      */     @FunctionalInterface     public interface Consumer1<T, P1> {         void accept(T t, P1 p1);     }     /**      * 2 参数 Consumer      */     @FunctionalInterface     public interface Consumer2<T, P1, P2> {         void accept(T t, P1 p1, P2 p2);     }     /**      * 3 参数 Consumer      */     @FunctionalInterface     public interface Consumer3<T, P1, P2, P3> {         void accept(T t, P1 p1, P2 p2, P3 p3);     } }

这个示例最多支持三个参数的设置属性方法，也完全够用了。如果要扩展也很容易，依葫芦画瓢，添加多个参数的Consumer。

快用你的 Builder 建个对象吧~

lambok的@Accessors(chain = true)也可以使用链式结构

使用策略模式消除if else代码

Sat, 14 Nov 2020 09:22:39 GMT

需求

业务需求是，有一个代报考系统，里面的一个功能是根据报考类目的不同维护不同的代报考规则。

代报考规则的实体：

public class ExamRuleEditReqDTO extends BaseDTO {      // 无 则新增  有则 修改     private Integer  id;     //报考规则名称     @NotNull(message = "报考规则名称不能为空!")     private String  name;      /**      *  报考类目  typeCode      *  消防工程师   HC_EXAM_TYPE_FIRE_ENGINEER      *  成人高考  HC_EXAM_TYPE_ADULT_EXAM      *  ACI 心理  HC_EXAM_TYPE_ACI_PSYCHOLOGY      *  ACI 营养  HC_EXAM_TYPE_ACI_NUTRITION      *  健康管理师 HC_EXAM_TYPE_HEALTH_MANAGER       *  自定义类目  HC_EXAM_TYPE_CUSTOMIZE      */     @NotNull(message = "报考类目Code不能为空!")     private String  typeCode;     //是否免协报费     private String  exemptionAssistFlag;      // ... 省略 get / set ...       }

service接口

public interface ExamService {      //维护代报考规则     ResponseBaseDTO<Integer> editExamRule(ExamRuleEditReqDTO reqDTO);      //查询代报考规则     ResponseBaseDTO<ExamRuleDetailQueryRespDTO> queryExamRuleDetail(ExamRuleQueryReqDTO reqDTO);  }

传统实现

根据报考类目写一堆的if else：

@Service public class ExamServiceImpl implements ExamService {       @Autowired     private ExamRuleFireEngineerHandler examRuleFireEngineerHandler;      @Autowired     private ExamRuleAdultExamHandler examRuleAdultExamHandler;      @Autowired     private ExamRuleAciPsychologyHandler examRuleAciPsychologyHandler;      @Autowired     private ExamRuleAciNutritionHandler examRuleAciNutritionHandler;      @Autowired     private ExamRuleHealthManagerHandler examRuleHealthManagerHandler;      @Autowired     private ExamRuleCustomizeHandler examRuleCustomizeHandler;       public ResponseBaseDTO<Integer>  editExamRule(ExamRuleEditReqDTO reqDTO) {                if (ExamConstants.HC_EXAM_TYPE_FIRE_ENGINEER.equals(reqDTO.getTypeCode())) {             return examRuleFireEngineerHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_ADULT_EXAM.equals(reqDTO.getTypeCode())) {             return examRuleAdultExamHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_ACI_PSYCHOLOGY.equals(reqDTO.getTypeCode())) {             return examRuleAciPsychologyHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_ACI_NUTRITION.equals(reqDTO.getTypeCode())) {             return examRuleAciNutritionHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_HEALTH_MANAGER.equals(reqDTO.getTypeCode())) {             return examRuleHealthManagerHandler.editHandler(reqDTO);         }         return new ResponseBaseDTO<>(ResponseBaseDTO.FLAG_FAIL, "代报考类目参数不正确！");     }           public ResponseBaseDTO<ExamRuleDetailQueryRespDTO>  queryExamRuleDetail(ExamRuleQueryReqDTO reqDTO) {                if (ExamConstants.HC_EXAM_TYPE_FIRE_ENGINEER.equals(reqDTO.getTypeCode())) {             return examRuleFireEngineerHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_ADULT_EXAM.equals(reqDTO.getTypeCode())) {             return examRuleAdultExamHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_ACI_PSYCHOLOGY.equals(reqDTO.getTypeCode())) {             return examRuleAciPsychologyHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_ACI_NUTRITION.equals(reqDTO.getTypeCode())) {             return examRuleAciNutritionHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_HEALTH_MANAGER.equals(reqDTO.getTypeCode())) {             return examRuleHealthManagerHandler.editHandler(reqDTO);         } else if (ExamConstants.HC_EXAM_TYPE_CUSTOMIZE.equals(reqDTO.getTypeCode())) {             return examRuleHealthManagerHandler.editHandler(reqDTO);         }         return new ResponseBaseDTO<>(ResponseBaseDTO.FLAG_FAIL, "代报考类目参数不正确！");     }  }

策略模式实现

利用策略模式，只需要两行即可实现业务逻辑：

@Service public class ExamServiceImpl implements ExamService {         @Autowired     private ExamRuleHandlerContext examRuleHandlerContext;           @Override     @Transactional     public ResponseBaseDTO<Integer>  editExamRule(ExamRuleEditReqDTO reqDTO ) {         return this.examRuleHandlerContext.getHandlerInstance(reqDTO.getTypeCode()).editHandler(reqDTO );     }       @Override     public ResponseBaseDTO<ExamRuleDetailQueryRespDTO> queryExamRuleDetail(ExamRuleQueryReqDTO reqDTO) {         return this.examRuleHandlerContext.getHandlerInstance(reqDTO.getTypeCode()).queryHandler(reqDTO);     }  }

可以看到上面的方法中注入了ExamRuleHandlerContext，这是一个处理器上下文，用来保存不同的业务处理器，具体在下文会讲解。我们从中获取一个抽象的处理器AbstractExamRuleHandler，调用其方法实现业务逻辑。

现在可以了解到，我们主要的业务逻辑是在处理器中实现的，因此有多少个代报考类目，就对应有多少个处理器。以后需求变化，增加了代报考类目，只需要添加相应的处理器就可以，上述ExamServiceImpl完全不需改动。

业务处理器的写法

@Component @ExamRuleHandler(ExamConstants.HC_EXAM_TYPE_CUSTOMIZE) public class ExamRuleCustomizeHandler extends AbstractExamRuleHandler {      @Override     public ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO){          //处理自定义类目的规则          return null;     } }   @Component @ExamRuleHandler(ExamConstants.HC_EXAM_TYPE_HEALTH_MANAGER) public class ExamRuleCustomizeHandler extends AbstractExamRuleHandler {      @Override     public ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO){          //处理健康管理师类目的规则          return null;     } }   @Component @ExamRuleHandler(ExamConstants.HC_EXAM_TYPE_ACI_NUTRITION) public class ExamRuleCustomizeHandler extends AbstractExamRuleHandler {      @Override     public ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO){          //处理ACI营养类目的规则          return null;     } }   @Component @ExamRuleHandler(ExamConstants.HC_EXAM_TYPE_ACI_PSYCHOLOGY) public class ExamRuleCustomizeHandler extends AbstractExamRuleHandler {      @Override     public ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO){          //处理ACI心理类目的规则          return null;     } }   @Component @ExamRuleHandler(ExamConstants.HC_EXAM_TYPE_ADULT_EXAM) public class ExamRuleCustomizeHandler extends AbstractExamRuleHandler {      @Override     public ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO){          //处理成人高考类目的规则          return null;     } }    @Component @ExamRuleHandler(ExamConstants.HC_EXAM_TYPE_FIRE_ENGINEER) public class ExamRuleCustomizeHandler extends AbstractExamRuleHandler {      @Override     public ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO){          //处理消防工程师类目的规则          return null;     } }

首先每个处理器都必须添加到spring容器中，因此需要加上@Component注解，其次需要加上一个自定义注解@ExamRuleHandler，用于标识该处理器对应哪个订单类型，最后就是继承AbstractExamRuleHandler，实现自己的业务逻辑。

自定义注解 `@HandlerType`

 import java.lang.annotation.*;  @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface ExamRuleHandler {     String value(); }

抽象处理器 `AbstractHandler`

public abstract class AbstractExamRuleHandler {      public abstract ResponseBaseDTO<Integer> editHandler(ExamRuleEditReqDTO reqDTO );      public abstract ResponseBaseDTO<ExamRuleDetailQueryRespDTO> queryHandler(ExamRuleQueryReqDTO reqDTO ); }

自定义注解和抽象处理器都很简单，那么如何将处理器注册到spring容器中呢？具体思路是：

扫描指定包中标有@ExamRuleHandler的类；
将注解中的类型值作为key，对应的类作为value，保存在Map中；
重写实现ApplicationContextAware接口的ExamRuleHandlerContext类中setApplicationContext方法，当spring容器初始化的时候，会自动的将ApplicationContext注入进来

我们将核心的功能封装在ExamRuleHandlerContext类中，完成上面的功能。

上下文处理器ExamRuleHandlerContext

import org.springframework.beans.BeansException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware;  import org.springframework.stereotype.Service;  import java.util.HashMap; import java.util.Map;  @Service public class ExamRuleHandlerContext implements ApplicationContextAware {      @Autowired     ApplicationContext applicationContext;       private static final Map<String,Class> handlerMap = new HashMap<>(10);      public AbstractExamRuleHandler getHandlerInstance(String typeCode){         Class clazz = handlerMap.get(typeCode);         return (AbstractExamRuleHandler) applicationContext.getBean(clazz);     }      @Override     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {         Map<String,Object> beans = applicationContext.getBeansWithAnnotation(ExamRuleHandler.class);         if (beans != null && beans.size() > 0) {             for (Object serviceBean : beans.values()) {                 String payType = serviceBean.getClass().getAnnotation(ExamRuleHandler.class).value();                 handlerMap.put(payType, serviceBean.getClass());             }         }     } }

#getHandlerInstance方法根据类型获取对应的class，然后根据class类型获取注册到spring`中的bean。

最后请注意一点，ExamRuleHandlerContext 必须能被扫描到，或者通过@Bean的方式显式的注册，才能在项目启动时发挥作用。

总结

利用策略模式可以简化繁杂的if else代码，方便维护，而利用自定义注解和自注册的方式，可以方便应对需求的变更。本文只是提供一个大致的思路，还有很多细节可以灵活变化，例如使用枚举类型、或者静态常量，作为代报考的类型，相信你能想到更多更好的方法。

强大的 Stream API(三)

Mon, 26 Oct 2020 11:55:08 GMT

Stream 的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

查找与匹配

	方法	描述
1	allMatch(Predicate p)	检查是否匹配所有元素
2	anyMatch(Predicate p)	检查是否至少匹配一个元素
3	noneMatch(Predicate p)	检查是否没有匹配所有元素
4	findFirst()	返回第一个元素
5	findAny()	返回当前流中的任意元素
6	count()	返回流中元素总数
7	max(Comparator c)	返回流中最大值
8	min(Comparator c)	返回流中最小值
9	forEach(Consumer c)	内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)

       @Test     public void test1(){         boolean b1=employees.stream()//allMatch-检查是否匹配所有元素                 .allMatch((e)->e.getStatus().equals(Status.BUSY));         System.out.println(b1);//false          boolean b2=employees.stream()//anyMatch-检查是否至少匹配一个元素                 .anyMatch((e)->e.getStatus().equals(Status.BUSY));         System.out.println(b2);//true          boolean b3=employees.stream()//noneMatch-检查是否没有匹配所有元素                 .noneMatch((e)->e.getStatus().equals(Status.BUSY));         System.out.println(b3);//false          Optional<Employee> op=employees.stream()//findFirst-返回第一个元素//Optional是Java8中避免空指针异常的容器类                 .sorted((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()))                 .findFirst();         System.out.println(op.get());//Employee [name=王五, age=26, salary=3333.33, Status=VOCATION]          Optional<Employee> op2=employees.parallelStream()//findAny-返回当前流中的任意元素                 .filter((e)->e.getStatus().equals(Status.FREE))                 .findAny();         System.out.println(op2.get());//Employee [name=赵六, age=36, salary=6666.66, Status=FREE]          Long count=employees.stream()//count-返回流中元素的总个数                 .count();         System.out.println(count);//5          Optional<Employee> op3=employees.stream()//max-返回流中最大值                 .max((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()));         System.out.println(op3.get());//Employee [name=张三, age=18, salary=9999.99, Status=FREE]          Optional<Double> op4=employees.stream()//min-返回流中最小值                 .map(Employee::getSalary)                 .min(Double::compare);         System.out.println(op4.get());//3333.33     }

归约

	方法	描述
1	reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
2	reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 Optional

备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名

  /*      * 归约      * reduce(T identity,BinaryOperator b) / reduce(BinaryOperator b)-可以将流中元素反复结合起来，得到一个值。      */     @Test     public void test3(){         List<Integer> list=Arrays.asList(1,2,3,4,5,6,7,8,9,10);         Integer sum=list.stream()//reduce(T identity,BinaryOperator b)                         .reduce(0, (x,y)->x+y);//0为起始值         System.out.println(sum);          System.out.println("--------------------------");          Optional<Double> op=employees.stream()//reduce(BinaryOperator b)//没有起始值，map返回可能为空，所以返回Optional类型                                      .map(Employee::getSalary)                                      .reduce(Double::sum);         System.out.println(op.get());     }

收集

	方法	描述
1	collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表

方法	返回类型	作用
toList	List	把流中元素收集到List
Listemps= list.stream().collect(Collectors.toList());
toSet	Set	把流中元素收集到Set
Setemps= list.stream().collect(Collectors.toSet());
toCollection	Collection	把流中元素收集到创建的集合
Collectionemps=list.stream().collect(Collectors.toCollection(ArrayList::new));
counting	Long	计算流中元素的个数
long count = list.stream().collect(Collectors.counting());
summingInt	Integer	对流中元素的整数属性求和
inttotal=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingInt	Double	计算流中元素Integer属性的平均值
doubleavg= list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值。如：平均值
IntSummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joining	String	连接流中每个字符串
String str= list.stream().map(Employee::getName).collect(Collectors.joining());
maxBy	Optional	根据比较器选择最大值
Optionalmax= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
minBy	Optional	根据比较器选择最小值
Optionalmin = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
reducing	归约产生的类型	从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值 inttotal=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer
inttotal=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));
collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果转换函数
inthow= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
groupingBy	Map<k, list	根据某属性值对流分组，属性为K，结果为V
Map<emp.status, list
partitioningBy	Map<boolean, list	根据true或false进行分区
Map<boolean,list>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));

  /*      * 收集      * collect-将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。      */     @Test     public void test4(){         List<String> list=employees.stream()                                    .map(Employee::getName)                                    .collect(Collectors.toList());         list.forEach(System.out::println);          System.out.println("----------------------------");          Set<String> set=employees.stream()                                  .map(Employee::getName)                                  .collect(Collectors.toSet());         set.forEach(System.out::println);          System.out.println("----------------------------");          HashSet<String> hs=employees.stream()                                     .map(Employee::getName)                                     .collect(Collectors.toCollection(HashSet::new));         hs.forEach(System.out::println);          System.out.println("----------------------------");          //总和         Long count=employees.stream()                             .collect(Collectors.counting());         System.out.println(count);          //平均值         Double avg=employees.stream()                             .collect(Collectors.averagingDouble(Employee::getSalary));         System.out.println(avg);          //总和         Double sum=employees.stream()                             .collect(Collectors.summingDouble(Employee::getSalary));         System.out.println(sum);          //最大值         Optional<Employee> max=employees.stream()                                         .collect(Collectors.maxBy((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary())));         System.out.println(max.get());          //最小值         Optional<Double> min=employees.stream()                                       .map(Employee::getSalary)                                       .collect(Collectors.minBy(Double::compare));         System.out.println(min.get());          System.out.println("----------------------------");          //分组         Map<Status,List<Employee>> map=employees.stream()                                                 .collect(Collectors.groupingBy(Employee::getStatus));         System.out.println(map);//{FREE=[Employee [name=张三, age=18, salary=9999.99, Status=FREE], Employee [name=赵六, age=36, salary=6666.66, Status=FREE]], VOCATION=[Employee [name=王五, age=26, salary=3333.33, Status=VOCATION]], BUSY=[Employee [name=李四, age=58, salary=5555.55, Status=BUSY], Employee [name=田七, age=12, salary=8888.88, Status=BUSY]]}          //多级分组         Map<Status,Map<String,List<Employee>>> map2=employees.stream()                                                             .collect( Collectors.groupingBy( Employee::getStatus,Collectors.groupingBy((e)->{                                                                 if(e.getAge()<=35){                                                                     return "青年";                                                                 }else if(e.getAge()<=50){                                                                     return "中年";                                                                 }else{                                                                     return "老年";                                                                 }                                                             }) ) );         System.out.println(map2);//{FREE={青年=[Employee [name=张三, age=18, salary=9999.99, Status=FREE]], 中年=[Employee [name=赵六, age=36, salary=6666.66, Status=FREE]]}, VOCATION={青年=[Employee [name=王五, age=26, salary=3333.33, Status=VOCATION]]}, BUSY={青年=[Employee [name=田七, age=12, salary=8888.88, Status=BUSY]], 老年=[Employee [name=李四, age=58, salary=5555.55, Status=BUSY]]}}          //分区         Map<Boolean,List<Employee>> map3=employees.stream()                                                  .collect(Collectors.partitioningBy((e)->e.getSalary()>8000));         System.out.println(map3);//{false=[Employee [name=李四, age=58, salary=5555.55, Status=BUSY], Employee [name=王五, age=26, salary=3333.33, Status=VOCATION], Employee [name=赵六, age=36, salary=6666.66, Status=FREE]], true=[Employee [name=张三, age=18, salary=9999.99, Status=FREE], Employee [name=田七, age=12, salary=8888.88, Status=BUSY]]}          System.out.println("--------------------------------");          DoubleSummaryStatistics dss=employees.stream()                                              .collect(Collectors.summarizingDouble(Employee::getSalary));         System.out.println(dss.getSum());         System.out.println(dss.getAverage());         System.out.println(dss.getMax());          System.out.println("--------------------------------");         String strr=employees.stream()                              .map(Employee::getName)                              .collect(Collectors.joining(","));         System.out.println(strr);//张三李四王五赵六田七      }

强大的 Stream API(二)

Mon, 26 Oct 2020 11:42:20 GMT

Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

    //创建一个集合     List<Employee> employees=Arrays.asList(             new Employee("张三",18,9999.99),             new Employee("李四",58,5555.55),             new Employee("王五",26,3333.33),             new Employee("赵六",36,6666.66),             new Employee("田七",12,8888.88),             new Employee("田七",12,8888.88)      );

筛选与切片

	方法	描述
1	filter(Predicate p)	接收 Lambda ，从流中排除某些元素。
2	distinct()	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素。
3	limit(long maxSize)	截断流，使其元素不超过给定数量。
4	skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

 /*  筛选与切片      *  filter--接收Lambda，从流中排除某些元素。      *  limit--截断流，使其元素不超过给定数量。      *  skip(n)--跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补      *  distinct--筛选，通过流所生成元素的 hashCode() 和 equals() 去掉重复元素      */ //内部迭代：迭代操作由 Stream API 完成 @Test public void test1(){     //中间操作：不会执行任何操作     Stream<Employee> stream=employees.stream()                             .filter((e) -> e.getAge()>35 );     //终止操作：一次性执行全部内容，即 惰性求值     stream.forEach(System.out::println); } //外部迭代 @Test public void test2(){     Iterator<Employee> it=employees.iterator();     while(it.hasNext()){         System.out.println(it.next());     } }  @Test public void test3(){//发现“短路”只输出了两次，说明只要找到 2 个 符合条件的就不再继续迭代     employees.stream()              .filter((e)->{                  System.out.println("短路！");                  return e.getSalary()>5000;              })              .limit(2)              .forEach(System.out::println); }  @Test public void test4(){     employees.stream()              .filter((e)->e.getSalary()>5000)              .skip(2)//跳过前两个              .distinct()//去重，注意：需要Employee重写hashCode 和 equals 方法              .forEach(System.out::println); }

映射

	方法	描述
1	map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
2	mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
3	mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
4	mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
5	flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

 /*      * 映射      * map--接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新元素。      * flatMap--接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流      */     @Test     public void test5(){         List<String> list=Arrays.asList("aaa","bbb","ccc","ddd");         list.stream()              .map((str)->str.toUpperCase())              .forEach(System.out::println);          System.out.println("------------------------");          employees.stream()                  .map(Employee::getName)                  .forEach(System.out::println);          System.out.println("------------------------");          Stream<Stream<Character>> stream=list.stream()                                              .map(TestStreamAPI2::filterChatacter);         stream.forEach((sm)->{             sm.forEach(System.out::println);         });          System.out.println("------------------------");          Stream<Character> sm=list.stream()                                  .flatMap(TestStreamAPI2::filterChatacter);         sm.forEach(System.out::println);     }      public static Stream<Character> filterChatacter(String str){         List<Character> list=new ArrayList<>();         for (Character ch : str.toCharArray()) {             list.add(ch);         }         return list.stream();     }      @Test     public void test6(){//map和flatMap的关系  类似于 add(Object)和addAll(Collection coll)         List<String> list=Arrays.asList("aaa","bbb","ccc","ddd");         List list2=new ArrayList<>();         list2.add(11);         list2.add(22);         list2.addAll(list);         System.out.println(list2);     }

排序

	方法	描述
1	sorted()	产生一个新流，其中按自然顺序排序
2	sorted(Comparator comp)	产生一个新流，其中按比较器顺序排序

  //中间操作     /*      * 排序      * sorted()-自然排序（按照对象类实现Comparable接口的compareTo()方法 排序）      * sorted(Comparator com)-定制排序（Comparator）      */     @Test     public void test7(){         List<String> list=Arrays.asList("ccc","bbb","aaa");         list.stream()             .sorted()             .forEach(System.out::println);          System.out.println("------------------------");          employees.stream()                  .sorted((e1,e2)->{                      if(e1.getAge().equals(e2.getAge())){                          return e1.getName().compareTo(e2.getName());                      }else{                          return e1.getAge().compareTo(e2.getAge());                      }                  }).forEach(System.out::println);

强大的 Stream API(一）

Mon, 26 Oct 2020 11:39:44 GMT

了解 Stream

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之， Stream API 提供了一种高效且易于使用的处理数据的方式。

什么是 Stream

流(Stream) 到底是什么呢？是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，流讲的是计算！”

注意：

①Stream 自己不会存储元素。 ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。 ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

创建 Stream

一个数据源（如：集合、数组），获取一个流
中间操作一个中间操作链，对数据源的数据进行处理
终止操作(终端操作) 一个终止操作，执行中间操作链，并产生结果

创建 Stream

1.1可以通过Collection 系列集合提供的stream()或parallelStream()方法

default Stream< E> stream() : 返回一个顺序流 default Stream< E> parallelStream() : 返回一个并行流
```
//可以通过Collection 系列集合提供的stream()或parallelStream() List<String> list = new ArrayList<>(); Stream<String> stream1 = list.stream(); Stream<String> stream2 = list.parallelStream(); 
```
1.2通过 Arrays 中的静态方法stream()获取数组流

static < T> Stream< T> stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：
```
 public static IntStream stream(int[] array) 
```
public static LongStream stream(long[] array)

public static DoubleStream stream(double[] array)
```
//通过 Arrays 中的静态方法stream()获取数组流 Employee[] emps=new Employee[10]; Stream<Employee> stream3= Arrays.stream(emps); 
```
1.3通过Stream 类中的静态方法of()，通过显示值创建一个流。

它可以接收任意数量的参数。

public static< T> Stream< T> of(T… values) : 返回一个流
```
//通过Stream 类中的静态方法of() Stream<String> stream4=Stream.of("aa","bb","cc"); 
```
1.4.创建无限流

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。

迭代

public static< T> Stream< T> iterate(final T seed, final UnaryOperator< T> f)

生成

public static< T> Stream< T> generate(Supplier< T> s)
```
//创建无限流  //迭代 Stream<Integer> stream5=Stream.iterate(0, (x) -> x+2); stream4.limit(10).forEach(System.out::println);  //生成 Stream.generate(() -> Math.random())                .limit(5)                .forEach(System.out::println); 
```

域名工具网站

Wed, 23 Sep 2020 14:13:00 GMT

国内注册商,国内站长和企业喜欢的注册商

www.net.cn

国内新后缀注册商

国内二位后缀域名注册商

quyu.net

国际注册商

各后缀域名抢注平台

.com .net .org .cn .cc: juming.com
.info .mobi .asia .xxx .pro .red .black .bet .blue .ac .us ：Dynadot.com

新后缀抢注平台

国别后缀抢注平台

.ac .ag .bz .gg .io .je .ly .me .mn .sc .sh .to .vc ： park.io
.eu .be .ch .de .fr .it .li .nl .uk ： catchtiger.com
.es .it ： nidoma.com
.nu .se ： webb.se 、rymdweb.com
.nz ： expireddomains.co.nz
.id .ly .tw ： docky.ly
.ru .su ： nic.ru
.cx .gs .hk: 363.hk

查询工具

whois 查询： who.is
域名溢价查询： yijia.me
最终核实域名是不是可以注册： domai.nr、whois.domaintools.com、注册局
注册局官网以及联系方式查询：https://www.iana.org/domains/root/db/xxx.html 将 xxx 替换为某个后缀
可注册域名扫描（米友作品）： name.tg
域名过期时间删除时间查询： expireddomains.net
域名后缀注册量查询: www.363.hk/web/registration
新后缀目前市场占有率查询： namestat.org
全球每天有哪些域名被注册了： dnpedia.com/tlds/daily.php
国内有哪些后缀可以备案：域名.信息
国内平台域名成交价格查询： wanmi.cc
国际域名成交价格查询： namebio.com
域名在哪里注册最便宜： tld-list.com 、nazhumi.com
域名被墙污染查询： zijian.aliyun.com/#/domainDetect
域名建站历史查询： archive.org
域名 DNS 修改历史查询： completedns.com
域名优惠活动： Namebeta.com
域名备案查询: micp.chinaz.com

mac下 IDEA 特殊的快捷键

Tue, 22 Sep 2020 04:24:00 GMT

“scroll from source”快捷方式？

先按“Option + F1”，再按“Enter”或“1”键。

打开终端 Terminal 的快捷键？

Option + F12

打开 project 的快捷键？

Command + 1

进入调用接口的快捷键？

Command + B

进入调用接口的实现方法快捷键？

Command + Option +  B

提取变量名？

Command + Option +  V

MAC Navicat Premium Mac 12 破解(亲测可用!!!）

Sun, 20 Sep 2020 12:54:00 GMT

首先先声明一下，我这个破解方法的版本是12.022(官网最新的是15的,不清楚能不能,没测试),分享一波安装包下载

Navicat Premium 是一套数据库开发工具，让你从单一应用程序中同时连接 MySQL、MariaDB、MongoDB、SQL Server、Oracle、PostgreSQL 和 SQLite 数据库。它与 Amazon RDS、Amazon Aurora、Amazon Redshift、Microsoft Azure、Oracle Cloud、MongoDB Atlas、阿里云、腾讯云和华为云等云数据库兼容。你可以快速轻松地创建、管理和维护数据库。

废话不多说,上破解方法.

第一步：保存秘钥

公钥：(存储为名为rpk的文件,备用)

私钥：

第二步：安装navicat

点击安装包一步一步安装即可

第三步：替换公钥

finder中，右键navicat ,显示包内容，打开目录 /Contents/Resources，编辑rpk文件，用第一步的公钥替换并保存。(如果该目录下面没有rpk文件,可以直接将第一步保存备用的rpk文件移动进去就行)

第四步：断网

第五步：打开navicat

根据navicat输入以下序列号：

中文版64位密钥序列号： NAVH-T4PX-WT8W-QBL5

英文版64位密钥序列号： NAVG-UJ8Z-EVAP-JAUW

如果注册码右边出现的 ✔️，那么恭喜你，可以继续往下进行了。如果右边是黑色的❌,那么请从第头再来一遍。

第六步：手动激活

由于断了网，则会出现激活失败，选择点击手动激活

第七步：复制请求码

第八步：获取请求码明文

登录这个网址 http://tool.chacuo.net/cryptrsaprikey

在输入加密私钥位置填上第一步的私钥

在待加密解密的文本填上请求码(第七步中复制的)，点击RSA私钥解密。

请注意：如果没出现请求码明文可能是

1：网络问题，请多试几次

2：请检查第三部rpk文件是否替换成功！(如果没有出现很可能是这个原因,再确认一下)

第九步：替换时间戳

将请求码明文中的 K和DI的值替换到下面对应的地方，

{"K":"NAVHT4PXWT8WQBL5", "N":"52pojie", "O":"52pojie.cn", "DI":"ODQ2Yjg2ZDBjMTEzMjhh", "T":1616939200}

再登录 https://unixtime.51240.com/

调整到现在的时间(不用那么精确,没关系)，并把Unix时间戳替换到上面的T后面

第十步：获取激活码

将替换好的文本，放入在待加密解密的文本中，点击RSA加密，得到加密后的文本

第十一步：输入并点击激活

输入激活码并点击激活。

本文转载于https://my.oschina.net/u/4271891/blog/4256494

macOS 下git+ Java + Maven + MySql + Nginx 开发环境

Sun, 20 Sep 2020 10:26:00 GMT

Git

官网下载：http://git-scm.com/download/mac
安装过程和 Windows 没啥区别，都是下一步下一步。
IntelliJ IDEA 对 Git 的支持很好，也不需要额外配置什么，IntelliJ IDEA 的 Git 操作都很便捷强烈使用 IntelliJ IDEA 作为 Git 的 GUI 操作工具。
Homebrew 方式（推荐）：brew install git

JDK

官网下载 JDK7：http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
官网下载 JDK8：http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
- jdk-8u231-macosx-x64.dmg
- 百度云（d8rj）：https://pan.baidu.com/s/1VFAi0gpMWikTgjTQokZEhQ
Java 开发环境理论上一般都是这个优先安装的。
安装过程和 Windows 没啥区别，都是下一步下一步，只是比 Windows 简单，连安装路径都不需要改而已，所以这里不截图了。
我这边不管是 Windows、Mac、Linux，只要开发环境，JAVA_HOME 我都是 JDK8，同时还装有 JDK6、JDK7，在使用 IntelliJ IDEA 的时候，我可以同时使用三个版本的 JDK。
JDK 的环境变量是要添加的，我这边可以贴一下。
如果你是 bash，你需要编辑的是这个：vim ~/.bash_profile
修改后之后刷新配置文件我是：source ~/.bash_profile

# JDK 1.8 JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home JRE_HOME=$JAVA_HOME/jre PATH=$PATH:$JAVA_HOME/bin CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar export JAVA_HOME export JRE_HOME export PATH export CLASSPATH

卸载 JDK

sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin  sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane  sudo rm -rf /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk

IntelliJ IDEA

官网下载：http://www.jetbrains.com/idea/
最优秀的 IDE，没有之一，我所有的生产力硬件设备都是为了支持它而购买的，所以内存一定要够大。
下面的 Maven、Tomcat 都是依赖于 IntelliJ IDEA 运行的，所以本质上我只要搞定 IntelliJ IDEA，其他的 Java 开发环境 IntelliJ IDEA 都会帮我们解决。
关于 IntelliJ IDEA Mac 下安装/配置等相关，请看我写的这个系列，里面有详细说明：IntelliJ IDEA 简体中文专题教程
在 IntelliJ IDEA 有几个特别的地方我单独拿出来讲讲吧：
- 如果启动 Tomcat 的时候报：Permission denied，你则可以：打开终端，进入 Tomcat\bin 目录，然后执行：chmod 777 *.sh
- 如果启动 Tomcat 之后，控制台乱码了，并且你确认你在 IntelliJ IDEA 的 Preferences 中设置的控制台字体是支持中文的，那你可以尝试下在 Tomcat VM 参数上加上：-Dfile.encoding=UTF-8
- Git 的路径配置：Preferences -- Version Control -- Git -- Path to Git executable 的值是：/usr/local/git/bin/git
- 那你的 IntelliJ IDEA 终端路径可以改成 zsh 的，配置方法在 Preferences -- Tools -- Terminal -- Shell path 的值改为是：/bin/zsh
IntelliJ IDEA 在 Mac 下的配置文件保存路径
- 下面内容中：XXXXXX，表示 IntelliJ IDEA 的版本号，IntelliJ IDEA 的配置目录是跟版本号有关系的。
- /Users/你的用户名/Library/Application Support/IntelliJIdeaXXXXXX，用于保存安装的插件
- /Users/你的用户名/Library/Caches/IntelliJIdeaXXXXXX，用于保存缓存、日志、以及本地的版本控制信息（local history 这个功能）
- /Users/你的用户名/Library/Preferences/IntelliJIdeaXXXXXX，用于保存你的个人配置、授权文件，等价于 Windows 下的 config 目录
IntelliJ IDEA 设置 JDK

Maven

官网下载：http://maven.apache.org/download.cgi
Maven 是绿色版的，任何系统都适用。
安装方式和 Windows、Linux 没啥本质区别，都是把 zip 文件夹解压，然后新增几个系统变量，修改 Maven 配置文件参数。
我是把 Maven 解压后，直接把 Windows 的 settings.xml 复制过来，修改下该文件本地仓库的路径，其他没啥可以改的了。
然后本地仓库的那些依赖包是直接从 Windows 下拷贝过来的，这个是任何系统下都兼容的，不需要额外处理。
最后再用 IntelliJ IDEA 对 Maven 的配置路径重新做了修改。
以上这些点都需要你对 Maven 和 IntelliJ IDEA 有了解，对于这两个东西我也在本文章都贴了相关的文章链接，我这里不多说了，学习总是需要花时间的。
Maven 的环境变量是要添加的，我这边可以贴一下：

MAVEN_HOME=/Users/youmeek/my_software/work_software/maven3.3.9 PATH=$PATH:$MAVEN_HOME/bin export MAVEN_HOME export PATH

验证：mvn -v

MySQL 5.7

官网下载 MySQL：http://dev.mysql.com/downloads/mysql/
MySQL 5.7 版本：https://dev.mysql.com/downloads/mysql/5.7.html#downloads
MySQL 官网提供的 Mac 系统的安装包，是下一步下一步安装类型的，没啥难度，大家自己试一下。
需要特别注意的是：安装结束后，会提示你它生成的一个随机密码，你要复制下，等下要用
有几个点需要注意的是：
- 如何修改 root 密码：
  - 打开：系统偏好设置 -- 底部的 MySQL -- 点击：Stop MySQL Server，根据提示输入你的 Mac 用户密码。
  - 连接：sudo /usr/local/mysql/bin/mysql -h 127.0.0.1 -u root -P 3306 -p，输入刚刚复制的密码 - 修改密码：set password = password('123456');
- MySQL 配置文件设置
  - 创建文件 vim /etc/my.cnf，参考内容如下
  - 重启 MySQL 服务即可
  - 这里给一个 demo 示例：

[mysql] default-character-set = utf8mb4   [mysqld] symbolic-links=0 log-error=/var/log/mysql/error.log default-storage-engine = InnoDB collation-server = utf8mb4_unicode_520_ci init_connect = 'SET NAMES utf8mb4' character-set-server = utf8mb4 lower_case_table_names = 1 max_allowed_packet = 50M sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION

通过命令行操作 MySQL

启动MySQL服务 sudo /usr/local/MySQL/support-files/mysql.server start  停止MySQL服务 sudo /usr/local/mysql/support-files/mysql.server stop  重启MySQL服务 sudo /usr/local/mysql/support-files/mysql.server restart

如果你要卸载

sudo rm -rf /usr/local/mysql sudo rm -rf /Library/PreferencePanes/MySQL* sudo rm -rf /var/db/receipts/com.mysql.*

nginx

#当前目录 /Users/maruifu/work/ComponentServices  #下载nginx-1.18.0  wget http://nginx.org/download/nginx-1.18.0.tar.gz # 解压 tar -zxvf nginx-1.18.0.tar.gz #创建目录 mkdir nginx #创建模块目录 mkdir nginx-src #进入模板目录 cd nginx-src #下载pcre并解压 wget https://ftp.pcre.org/pub/pcre/pcre-8.41.tar.gz #下载openssl并解压 wget https://www.openssl.org/source/openssl-1.1.0g.tar.gz  #下载zlib并解压 wget http://prdownloads.sourceforge.net/libpng/zlib-1.2.11.tar.gz #进入源码目录 cd ../nginx-1.18.0  #配置nginx ./configure  \ --with-http_gzip_static_module  \ --with-pcre=../nginx-src/pcre-8.41/  \ --with-http_ssl_module  \ --with-openssl=../nginx-src/openssl-1.1.0g  \ --with-zlib=../nginx-src/zlib-1.2.11  \ --prefix=/Users/maruifu/work/ComponentServices/nginx/nginx \  #编译并安装 make && make install

brew install wget

Mac终端配置好的环境变量在关闭终端后失效怎么办

Sun, 20 Sep 2020 10:22:16 GMT

原因其默认启动执行脚本变为了~/.zshrc，所以总会显示zsh：xxx not found

解决方法在终端中输入

echo ‘source ~/.bash_profile’ >> ~/.zshrc

Awesome Mac

Sun, 20 Sep 2020 10:19:00 GMT

Awesome Mac

 现在我们变得非常大，与最初的想法不同，如今我们需要收集各种类别非常好用的 Mac 应用程序、软件以及工具。

开发者工具

编辑器

一种用于编辑纯文本文件的程序，建议使用免费开源的编辑器

Atom - GitHub 推出的开源编辑器，Atom常用插件。
Android Studio - Android 的官方 IDE，基于 Intellij IDEA。
Brackets - Adobe 推出的 Brackets 免费/开源编辑器。
BBEdit - 强大的文件编辑器，用于编辑文件，文本文件及程序源代码。
Coda2 - 用于编写 Web 应用，长得漂亮的编辑器。
CotEditor - 轻量级的纯文本编辑器。
Chocolat - 轻量级本地编辑器。
Deco IDE - React Native IDE 支持控件拖拽界面实时变更。
Espresso - Web 编程利器，具备了快速且强大的编辑功能、专业检查与分类、即时预览编辑成果、发布与同步功能等。
Emacs - Emacs 是基于控制台的编辑器和高度可定制的。
Eclipse - 流行的开源 IDE，主要用于 Java，也为多种语言提供插件支持。
Sublime Text - 一个比较简洁大方带插件管理系统的流行编辑器，Sublime常用插件。
Haskell for Mac - Haskell 的现代开发环境。
HBuilder - HBuilder 是 DCloud（数字天堂）推出的一款支持 HTML5 的 Web 开发 IDE。
JetBrains Toolbox App - 管理已安装的JetBrains工具，下载新工具并打开最近的项目。
- CLion - 强大的 C 和 C++ IDE。(学生免费)
- DataGrip - 用于数据库和SQL的跨平台IDE。 (学生免费), 查看此处了解更多。
- Rider - 跨平台 C# IDE。它是 Microsoft 的 Visual Studio 的替代方案.
- AppCode - 适用于 iOS / macOS 开发的智能 IDE
- PyCharm - 一款 Python 开发集成环境，有专业版和社区版。
- IntelliJ IDEA - 一款 Java 开发集成环境。(学生免费)
- GoLand - JetBrains出品的Go开发IDE，智能，灵活
- Webstorm - 是 JetBrains 公司旗下一款 JavaScript 开发工具。学生免费，点击这里查看更多。
  - NodeJS - 集成 Node.js，你肯定需要它，很多功能需要它。
  - EditorConfig - 帮助开发者在不同的编辑器和 IDE 之间定义和维护一致的代码风格。
  - Material Theme UI - Google 为 React 开发的主题。
LightTable - 下一代代码编辑器。开源地址
micro - 一个现代直观的基于终端的文本编辑器。开源地址
NetBeans IDE - 免费、开源的 IDE，主要用于 Java 开发，可支持多种语言和框架。
ONI - 由 Neovim 提供的 IDE。
Qt - 跨平台 C++ 图形用户界面应用程序开发框架。
TextMate - 文本编辑器软件，与 BBedit 一起并称苹果机上的 emacs 和 vim。开源地址
Tincta - 一个免费的文本编辑器。开源地址](https://github.com/CodingFriends/Tincta)
Visual Studio Code - 微软推出的免费/开源编辑器，TypeScript 支持杠杠的，VSCode常用插件。开源地址
Vim - Vim 古老的终端中使用的编辑器，Vim常用插件。开源地址
Vimr - Vim 客户端，升级 Vim 体验。开源地址
Visual Studio Community for Mac - 免费，开源，功能齐全的 IDE。
Xamarin Studio - 免费的跨平台的 C# IDE。支持 IOS、Android 和 .net 开发。开源地址
Xcode - 开发 iOS 和 MacOS 基本 IDE。

开发者实用工具

BetterRename - 一款强大的批量重命名工具，可以通过搜索功能改名。
Beyond Compare - 对比两个文件夹或者文件，并将差异以颜色标示。
CodeKit - 自动编译 Less、Sass、Stylus、CoffeeScript、Jade & Haml等文件。
Cacher - 基于云的团队代码片段管理器，具有Gist同步，VSCode/Atom/Sublime软件包和Mac/Windows/Linux/Web客户端。
Dash - 强大到你无法想象的 API 离线文档软件。
DiffMerge - 可视化的文件比较（也可进行目录比较）与合并工具。
EnvPane - 图形终端查看环境变量的应用工具。开源地址
Fanvas - 把 swf 转为 HTML5 canvas 动画的系统。开源地址
FinderGo Finder 中快速打开终端，定位到目录开源地址
Gas Mask - 编辑 hosts 文件的工具，更简单方便。开源地址
Go2Shell - 从 Finder 打开命令行。
Gemini - 智能的重复文件查找器。
Hosts.prefpane - 编辑 hosts 文件的工具。开源地址
Hex Fiend - 快速而聪明的开源十六进制编辑器。开源地址
iHosts - 唯一上架 Mac App Store 的 /etc/hosts 编辑神器。
Integrity - 轻松找到无效链接。
Koala - 预处理器语言图形编译工具，支持 Less、Sass、CoffeeScript、Compass framework 的即时编译。开源地址
Kaleidoscope - 一款很强大的文本文件和图像比较工具，同时和 git、svn 等版本控制工具能够完美的结合。
Localname - 提供对本地开发服务器的访问权限。
MJML - 简化设计回应电子邮件的方式。开源地址
PaintCode - 将设计转换成 Objective-C, Swift 或 C# 代码。
PushMate 可通过确保推送有效载荷正确来解决常见的推送通知问题。
PPRows - 计算你写了多少行代码。开源地址
SwitchHosts - 一个管理、切换多个 hosts 方案的工具。开源地址
SCM Breeze - 用于增强与git交互的shell脚本集(用于bash和zsh)。开源地址
SnippetsLab - 管理和组织你的代码片段。
StarUML - 强大的软件建模软件。
SecureCRT - 一款支持 SSH、Telnet 等多种协议的终端仿真程序。
Swiftify - Xcode ＆ Finder 扩展 Objective-C 转 Swift 代码转换器
SYM - 一个图形化的崩溃日志解析工具。开源地址
TeXstudio - 集成创建 LaTeX 文档的写作环境。开源地址
uTools - 一款基于插件的程序员效率工具，包含非常多的实用插件，如图床、UUID、密码、翻译、JSON格式化等。
Vagrant Manager - 管理你本地服务。开源地址
Vagrant - 用来构建虚拟开发环境的工具。开源地址
WeFlow - 一个基于 tmt-workflow 前端工作流的开发工具。开源地址
Woodpecker - 在Mac上查看、编辑iOS App的沙盒文件, UserDefaults, Keychain项
zeplin - 前端与设计协同工作专用工具。

正则编辑器

Patterns - 正则表达式编辑器。
Regex - 感觉是用过最漂亮的正则表达式测试工具。
Reggy - 正则表达式编辑器。开源地址
RegExRX - 正则表达式的开发工具。

API开发和分析

Cocoa Rest Client - 比 Postman 看起来漂亮的客户端，测试 HTTP/REST endpoints。开源地址
Insomnia - 最直观的跨平台 REST API 客户端。开源地址
Postman - Postman 帮助我们快速测试 API。
Katalon Studio - 简单开放性测试前端开放工具，网页，手机应用等客户端。可以使用在不同的浏览器

网络分析

Charles - 一个代理工具，允许你查看所有的 HTTP 和 HTTPS 流量。
James - 用于 https 和 http 进行查询映射请求。开源地址
mitmproxy - 一款支持 HTTP(S) 的中间人代理工具，可在终端下运行，可用于抓包开源地址
Paw - 先进的 HTTP 客户端。
Proxie - HTTP 调试客户端。
Proxyman - 适用于 macOS 的现代直观 HTTP 调试代理.
Wireshark - 世界上最广泛使用的网络协议分析软件。开源地址

命令行工具

A curated list of shell commands and tools specific to OS X.

autojump - 告别又臭又长的路径名，一键直达任何目录。开源地址
bash-it - 一个社区的 bash 的框架。** 开源 **
bat - 带有语法高亮和Git集成的 cat(1) 克隆。开源地址
color-retro-term - 一款复古风格的终端，非常酷炫。
cool-retro-term - 怀旧的命令行终端。开源地址
Cakebrew - Homebrew 的客户端软件。摆脱命令方便安装、查看、卸载软件。开源地址
cmus - 命令行播放音乐应用。开源地址
Dnote - 命令行上的笔记本，支持多设备同步和网络界面。开源地址
Fish Shell - 智能且用户友好的命令行终端。
Glances - 在命令行中查看你系统运行状态的工具。开源地址
httpie - HTTPie 是一个让你微笑的命令行 HTTP 客户端。开源地址
hyper - 基于 Web 技术的终端，直接替代自带的 Terminal。开源地址
HyperTerm - 一款基于 Node 开发的终端软件，逼格很高。开源地址
iTerm2 - 免费的终端工具，直接替代自带的 Terminal，有非常多惊人的特性。开源地址
itunes-remote - 通过终端控制您的 iTunes。开源地址
job - 短命令并发、重复执行工具, 适用于压测. 开源地址
LNav - 日志文件阅读器. 开源地址
mycli - 为 MySQL 命令行客户端，提供语法高亮和提示功能的工具！开源地址
m-cli - 用于 macOS 的瑞士军刀。开源地址
Mac-CLI - 自动化您的 OS X 系统的使用。开源地址
mas - 一个简单的命令行界面的苹果应用商店。开源地址
ndm - 查看本地NPM安装的包客户端软件。摆脱命令方便安装、查看、卸载软件。开源地址
pgcli - 为Postgres提供一个支持自动补全和语法高亮的命令行工具。开源地址
silver searcher (ag) - 类似于ack的代码搜索工具，专注于速度。开源地址
Serial - 为工程师和系统管理员嵌入式硬件更容易。
spaceship - 一个简约，功能强大且极易定制的Zsh提示。开源地址
Tabby (formerly Terminus) - 免费的终端工具，基于 Web 技术的终端，用 TypeScript 写成的跨平台终端工具。深受 hyper 启发。开源地址
Termius - 免费的终端工具，可以与 windows 平台的 xshell 媲美。
thefuck - 一个纠正错误命令的工具，输入错误命令后，输入fuck就可以修正成正确的命令行命令，支持自定义的bash_profile命令[ 开源地址]
tmux - 一个优秀的终端复用器类自由软件。开源地址
tmuxinator - Tmux的配置管理工具。开源地址
ttygif - 将终端录制转换为 GIF 动画。开源地址
trash - 将文件和目录移动到废纸篓。开源地址
Upterm - Upterm (之前是 Black Screen) 来自 21 世纪的强大终端。
Zsh - 一个专为交互式使用而设计的命令行 shell。开源地址

版本控制

Git - 版本控制工具，官网提供数十种 GUI 客户端 for Mac。开源地址
SVN - 版本控制工具。

GUI

Cornerstone - Mac 上最佳的 SVN 管理工具。
Fork - 一个快速友好的 Git 客户端。
GitFinder - 一个快速和轻量级的 Git 客户端的 Mac 与 Finder 集成。
GitX - Pieter's的衍生版本，维护增强生产力和团队开发变化。开源地址
Gitbar - 开源，在你的菜单栏上显示 GitHub 贡献统计。开源地址
GitHub Desktop - 使用 GitHub 的 GUI 应用。
GitUp - 一个简单功能强大的 Git 客户端。开源地址
GitKraken - 最流行的图形用户界面的 git 管理工具。
Hub - 将 GitHub 接口和 Git 命令进行包装。开源地址
OhMyStar 最好的组织 Github Star 的软件。
SourceTree - 强大的 Git 跨平台客户端。
SmartGit - 非商业用途免费，全平台支持，集成 Github 服务。
Sublime Merge - Git客户端，来自Sublime Text的制造商。
Tower2 - 最强大的 Git 客户端。
Versions - Mac 上最好的 SVN 管理工具。

版本控制系统

Coding.net - 代码托管，项目管理，WebIDE，演示部署，开启云端开发模式，让开发更简单。
GitLab - 一个用于仓库管理系统的开源项目。
GitHub GitHub 托管代码，项目管理，演示部署，瞧，您现在就在访问GitHub。
Gogs - 一款极易搭建的自助 Git 服务 Golang 版本。开源地址
Gerrit Gerrit 是一个免费、开放源代码的代码审查软件，使用网页界面。
Gitblit Java 版本 Git 代码托管，项目管理。开源地址
Gitea - Gogs 的 fork 版本。** 开源 **
phabricator phabricator 支持 Git、SVN、HG 基于 PHP + Mysql 的开放源代码软件开发平台。

数据库

Another Redis Desktop Manager - 一款稳定全新的Redis管理工具。** 开源 **
Bdash - SQL 客户端应用程序，支持 MySQL、 PostgreSQL (Redshift)、 BigQuery。** 开源 **
Base 2 - 一个用于管理 SQLite 数据库的软件。
Chrome MySQL Admin - 一个 Chrome 插件，是 MySQL 开发的跨平台、可视化数据库工具。开源地址
Core Data Editor - 核心数据编辑器可让您轻松查看，编辑和分析应用程序的数据。开源地址
DB Browser for SQLite - 一个跨平台的用于管理 SQLite 数据库的软件。开源地址
DataGrip - JetBrains 公司旗下一款数据库管理工具。点击这里学生免费。
DBeaver - 跨平台 SQL 客户端，支持大部分主流数据库
ElectroCRUD - MySQL 数据库 CRUD 应用程序。开源地址
Sequel Pro - 一个 MySQL 数据库管理软件。开源地址
JackDB - 直接的 SQL 访问你所有的数据，无论在哪里。开源地址
medis - 漂亮的 Redis 管理软件。开源地址
MongoDB - 一个基于分布式文件存储的数据库。开源地址
MongoBooster - MongoDB 图形化管理软件，内嵌 MongoShell，ES6 语法，流畅查询及智能感知。
mongoDB.app - 在Mac 上最简单的使用 MongoDB。开源地址
Mongo Management Studio - MongoDB 图形化客户端管理软件。
MDB Explorer - Mac 上查看编辑 Access 数据库的工具。
MySQL Workbench - MySQL 数据库官方管理软件。
Navicat Data Modeler - 一个数据库设计工具，它帮助创建高质素的概念、逻辑和物理数据模型。
Postico - 现代 PostgreSQL 客户端，漂亮功能多。
Postgres.app - Mac 上最简单的方法的使用 PostgreSQL 关系型数据库管理系统。开源地址
PSequel - PostgreSQL 数据库 GUI 软件。
pgModeler - 是一个专为PostgreSQL设计的开源数据建模工具。开源地址
RedisClient - 漂亮跨平台的Redis管理软件。开源地址
RedisDesktopManager - Redis 跨平台的 GUI 管理工具。开源地址
SQLPro Studio - 支持 SQL Server, Postgres, Oracle 以及 MySQL 等主流的数据库可视化管理工具.
SQLight - 一个 SQLite 数据库管理器工具，非常好用。
TablePlus - 支持 PostgreSQL，MySQL，RedShift，MariaDB... 各种数据库的高颜值客户端。开源地址
Tableau Public - 数据可视化工具。
Keylord - Redis，Bolt，LevelDB 和 Memcached 键值数据库的桌面GUI客户端。
redis-pro - 轻量，易用的 Redis 客户端管理工具，使用SwiftUI编写，很好的支持 Dark mode。开源地址

设计和产品

设计工具

Acorn - 一个像 PS，全面的功能集的图像编辑器。
Affinity Designer - 矢量图像设计工具，可以是 Adobe Illustrator 的替代。
Affinity Photo - 光栅图像设计工具，可以替代 Adobe PS 图象处理软件。
Alchemy - 开源的绘图工具软件，用于素描、会话以及一种新的绘图方式。开源地址
Art Text 3 - 生成各种特效字体。
Blender - 全功能可扩展的跨平台 3D 内容套件。开源地址
Figma - 一款基于 Web 的实时协作的云设计软件。
FontForge - 字体编辑工具。开源地址
GIMP - 图像编辑软件，号称 Linux 下的 PhotoShop，同时有 Mac 版本。开源地址
Gravit Designer - 混合矢量/位图布局应用，比起 Sketch 还差一点。
inklet - 将 Mac 上的触摸板变成绘图板。
Inkscape - 一款开源矢量图形编辑软件，与 Illustrator、Freehand、CorelDraw、Xara X 等其他软件相似。开源地址
Krita - 一个开源的位图形编辑软件，包含一个绘画程式和照片编辑器。开源地址
Monodraw - macOS 平台上强大的 ASCII 设计流程编辑器。
MagicaVoxel - 轻量级的8位像素编辑和交互路径追踪渲染器。
MakeHuman - 功能强大且免费的3D人体建模器。
Nik Collection - 专业照片后期制作工具，Google 收购后免费
Pixelmator - 强大的图像编辑器，可能PS图像处理软件的选择。
Paintbrush - 位图图像编辑器。开源地址
Pencil2D - 制作2D手绘动画的简单直观的工具。开源地址
Principle - 使用它很容易设计动画和交互式用户界面。
Pixel Perfect - 比较 UI 模型和开发结果非常容易。
Sculptris - 所见所得的 3D 建模。
Sketch - 混合矢量/位图布局应用，特别适用于用户界面，Web 和移动设计。
- Sketch Toolbox - 一个超级简单的 Sketch 插件管理器。开源地址
- Measure - 设计稿标注、测量工具。开源地址
- User Flows - 直接从画板生成流程图。开源地址
Sketch Cache Cleaner - 清理 Sketch 历史文件，释放磁盘空间。开源地址
SketchBook - 出众的绘图软件。
ScreenToLayers - 轻松导出桌面分层文件 PSD 文件。开源地址
Sparkle - 可视化网页设计工具。
Tayasui Sketches - 专业的绘图软件。
Vectr - 免费图形编辑器。这是一个简单而强大的 Web 和桌面跨平台工具，把你的设计变成现实。

原型流程

Axure RP 8 - 画原型图工具，团队协作，方便好用。
ProtoPie - 高保真交互原型设计。
Adobe XD (Experience Design) - 用于网站和移动应用的设计和原型设计。
Balsamiq Mockups - 一个快速的网页设计原型工具，帮助你更快、更聪明的工作。
Origami Studio - 一种设计现代界面的新工具，由 Facebook 设计师构建和使用。
Flinto - 快速制作高保真的互交原型工具，支持 Sketch 导入。
Kite - 一个强大的动画制作工具制作 Mac 和 iOS 原型中的应用。
Justinmind - 功能更丰富团队协作方便。
MockFlow - 用于网页设计和可用性测试的在线原型设计套件。
pencil - 开源免费制作软件原型的工具开源地址
Mockplus - 更快更简单的原型设计工具。
OmniGraffle - 可用来绘制图表、流程图、组织结构图、思维导图以及插图或原型。
XMind - 一款实用的思维导图软件。
Lighten - XMind 出品的一款实用的思维导图软件。
Loremify - 快速准确的设计，原型或生成标题，段落，列表和文章。
Scapple - 一款实用的思维导图软件。
Framer - 做交互原型的工具。
Marvel - 简单设计，原型设计和协作。
MindNode - 简洁的风格与人性化的操作，绘制思维脑图。
WriteMapper - 专为写作者而设的脑图工具。
SimpleMind - 超小体积的思维导图工具。
macSVG - 设计 HTML5 SVG 和动画. 开源地址

作图工具

Draw.io - 上百种图形，支持多种格式导出。
OmniGraffle - Omni 成员，native 应用。
ProcessOn - 流程图、思维导图、原型图... 中文友好，免费保存 5 个文件。

截图工具

GifCapture - 开源 macOS 截屏生成 Gif 工具。开源地址
Gifox - 专业的高颜值 GIF 录制应用。
GIF Brewery - gives everyone the power to create stunning GIFs from video files.
GIPHY Capture - 免费软件的捕捉和分享图片在桌面上。
Kap - 轻量 GIF 录屏小工具。开源地址
KeyCastr - 录屏好帮手，实时显示按键操作的小工具。开源地址
Licecap - 是一款屏幕录制工具输出 GIF，录制过程中可以随意改变录屏范围。开源地址
Monosnap - 制作截图，录制视频共享文件。
Skitch - 截图附带强大的标注功能。
Shifty - 一个菜单栏应用程序，让您更多地控制夜班。开源地址
ScreenShot PSD - 将屏幕捕获存为分层的 PSD，便于编辑。
Snipaste - 一个简单但强大的截图工具。
Snip - 高效的截图工具，支持滚动截屏，腾讯作品。
Teampaper Snap - 为设计师量身定做的屏幕截图兼注释工具。
截图(Jietu) - 截图附带强大的标注功能，腾讯作品。
Xnip - 免费好用的滚动截屏利器。
iShot - 完全免费、功能全面的截图工具，支持贴图、滚动截图、延时截图等。

其它工具

APNGb - 编辑 png 图片格式的软件。开源地址
Assetizr - 图片编辑应用，轻松更改图片尺寸，压缩图片，重命名图片。
AppIconBuilder(图标构建) - App图标多平台一键导出。
Couleurs - 简单的屏幕取色应用程序。
Eagle App - 强大的图片、视频、音频、設計素材及文件管理软件。
Frank DeLoupe - 支持 Retina 的屏幕拾色器。
Image2icon - 将你的图片转换成图标。
ImageAlpha - 压缩 PNG 图片，去掉无效的透明。开源地址
ImageOptim - 压缩图片，删除 EXIF 信息。开源地址
iPic - 上传图片至七牛、阿里云等图床，支持 Markdown 链接。
IconKit - App图标自动生成器。 (https://itunes.apple.com/cn/app/iconkit-icon-resizer-for-app/id507135296?mt=12)
Iconjar - 图标管理软件，带组织和搜索功能。
JPEGmini - 将图像尺寸降低高达 80％，而不会影响质量。
Preset Brewery - 将Lightroom预设转换为Adobe Camera Raw的工具。
PicGo - 支持常用 cdn 的图床工具。开源地址
Resize Master - 更快速和容易批量调整图像和加水印。
RightFont - 字体管理工具。
svgus - SVG 图片管理器。
Solarized - 干净清爽的颜色主题，支持 iTerm、Intellij IDEA、Vim 等。
Sip - 收集，整理和分享你的颜色拾色器。
Spectrum - 一款可以轻松直观地创建漂亮配色方案的应用程序。
TinyPNG4Mac - 图片压缩专用开源工具。开源地址
Tropy - 照片档案管理工具。开源地址
uPic - macOS 原生应用，功能强大且简洁的图床客户端。开源地址
马克鳗 - 高效的设计稿标注、测量工具。

虚拟机

Docker - 开源的应用容器引擎。开源地址
DockStation - 管理 Docker 项目的程序。开源地址
Parallels Desktop - 虽然好用但是收费机制，更新花钱、花钱、花钱。
Portainer - 基于网页管理 Docker 容器和 swarm 集群。开源地址
Virtual Box - 免费、免费、免费，带 NTFS 读写，不用买 ParagonNTFS，省100块。
VMware Fusion - 强大的虚拟机，商业软件。
Veertu - Mac 上轻量级的虚拟机。通过一种高响应，沙箱且本地化的方式在你在 Mac 上运行虚拟机。

通信

推荐一些通信工具，沟通，团队协同。

Adium - 呃，这个是老的集成多个平台的聊天客户端。
BearyChat - 互联网团队协作，沟通工具。
ChitChat - WhatsApp 非官方。开源地址
Electronic WeChat - 调用微信接口，使用 Electron 开发的第三方漂亮开源微信应用。开源地址
Franz - 一个使用 Electron开发的，可以同时登录 23 个平台的即时通讯软件。
Flume - 简约大气高逼格的Instagram，如果只是浏览点赞评论，免费版已经足够用。
Gitter - 关于 GitHub 的项目交流，支持 Markdown，对开发者极为友好。
Keybase - 一个安全的消息应用程序! 开源地址
Maipo脉搏 - 微博第三方 Mac 应用。
Messenger - Facebook 第三方聊天工具。开源地址
QQ - QQ for Mac App。
Rambox - 消息和电子邮件应用程序，将常见的Web应用程序组合成一个程序。开源地址
Skype - Skype 共享、跨平台的短信和电话。
Slack - 团队协作，沟通工具。
Telegram - 通讯新时代。
Textual - 最受欢迎的世界与我们相关的 KPI 应用 for OS X。开源地址
Teambition - 团队协作。提供管理任务、安排日程、查找文件、即时讨论等团队所需要的一切协作功能。
WeChat - 微信 for Mac App。
WeeChat - 一个命令行聊天客户端。
Zoom - 视频会议 & 屏幕共享，提供录制功能。
御飯 - 饭否第三方Mac应用。
简聊 - 企业级即时沟通工具，已经下线了，可以自己搭建一套系统玩儿。开源地址
钉钉 - 企业级办公通讯免费平台。
零信 - 随时随地工作，跨平台。
今目标 - 一款面向中小企业的互联网工作平台。
日事清 - 工作计划软件，日志软件，项目管理，团队协作软件，个人日程管理，团队协作工具。日程安排，计划分配，笔记总结等。
RTX_腾讯通 - 企业内部可以使用的聊天软件，企业内部可以使用此通讯工具，这个软件有Mac版本也有win版本，Mac版本专为 Retina 显示优化过

Email

Airmail - 快速的邮件客户端支持 Mac 和 iPhone。
Foxmail - 快速的邮件客户端。
网易邮箱大师 - 全平台的邮箱管理客户端，网易邮箱大师电脑版。
MailTags - 管理和组织邮件，日程和标签进行分类邮件。
Nylas Mail - 免费邮件客户端。开源地址
N1 - 可以扩展的开源收费邮件客户端。
Newton(原Cloudmagic) - 界面非常简洁的一个邮件客户端。
Postbox - 这个貌似也非常强大哦，关键是简洁漂亮的收费邮件客户端。
Polymail - 简单，功能强大，长得好看的新晋邮件客户端。
Spark - 新推出的快速邮件客户端支持 Mac 和 iPhone。
ThunderBird - Mozilla 公司出品的强大的 Email 客户端程序。
Yomail - 新出的国内开发的比较好的邮件客户端。

文件共享

Cyberduck - 免费 FTP，SFTP，S3 和 WebDAV 客户端 & OpenStack Swift Client。
Flow - 支持简单的 FTP + SFTP 客户端。
Transmit - 一个 FTP 客户端，支持 FTP + SFTP + S3。
Yummy FTP - 专业快速，可靠的 FTP 客户端。

数据恢复

DiskWarrior - 恢复文件系统损坏时，磁盘工具进行选择。
Data Rescue - 多种情况下的全面和专业的数据恢复。
R-Studio for Mac - 可恢复分区被格式化、损坏或被删除的文件。

音频和视频

Audacity - 免费开源的编辑音频的软件。开源地址
Ardour - 录制，编辑和混合多轨音频。开源地址
Audio Hijack - 一个记录任何应用程序的音频，包括网络电话 Skype，网络流从 Safari，以及更多。
ArcTime - 跨平台字幕制作软件。
Adapter - 视频，音频和图像转换工具。
Aegisub - 免费、开源、跨平台的专业字幕编辑软件，可以快速打轴，制作特效字幕等，字幕组必备。开源地址
Cog - 一个免费的开源音频播放器。开源地址
Carol - 为 macOS 提供最小化和美丽的歌词应用程序。开源地址
Elmedia Player - 支持 FLV, MP4, AVI, MOV, DAT, MKV, MP3, FLAC, M4V 等格式播放.
Hydrogen - 专业鼓乐类工具，创建专业但简单而直观的鼓乐节目。开源地址
HandBrake - 高性能的视频编码和转换工具，具有很好的图形用户界面。开源地址
iFFmpeg - MacOS 上功能强大、易用的视频压制软件。
IINA - 基于MPV的，现代视频播放器，支持多点触摸控制。开源地址
Kodi - 一款一流的免费开源媒体中心软件，可用于播放视频、音乐，查看图片，玩游戏等。开源地址
LosslessCut - 跨平台工具，使用ffmpeg进行快速无损的视频和音频修剪。开源地址
LyricsX - 一款功能完备的歌词工具。开源地址
Metadatics - 音频元数据编辑器，支持大多数常见的音频文件。
Mixxx - 免费的DJ软件，给你一切你需要的表演组合，名副其实的替代 Traktor。开源地址
MuseScore - 免费的作曲与乐谱软件。开源地址
MPV - 一个免费、开源和跨平台的媒体播放器。开源地址
Movie Catcher - 电影美剧搜索及在线观看离线下载软件，借助百度云实现离线下载以及在线播放功能。开源地址
Natron - 开源的视频合成软件，功能与 Adobe After Effects 或者 Nuke 类似。开源地址
Popcorn Time - 电影播放器，观看 torrent 电影。
Playback - 实验性质的视频播放器。开源地址
Perian - 让 QuickTime 播放所有常见格式的免费插件。开源地址
Radiant Player - Google Play音乐播放器。开源地址
Soda Player - 一款能够直接播放种子、磁力链接、在线视频、自动获取字幕、链接和本地视频文件的播放器。
Sonora - 一个很小的音乐播放器。开源地址
Stringed 2 - 音频编辑处理工具。
Shotcut - 免费开源视频编辑器。开源地址
ScreenFlow - 屏幕和视频编辑软件。
Synfig Studio - 工业级、强大的 2D 矢量动画制作软件。开源地址
SpotMenu - Spotify 和 iTunes 在状态菜单栏中显示。开源地址
VOX Player - 免费全能音乐播放器，撸码之余听听歌是一种享受。
VLC - 开源的跨平台多媒体播放器及框架，可播放大多数多媒体文件。开源地址
XLD - 解码/解码/转换/播放各种“无损”音频文件。开源地址

云音乐播放器

音频录制与编辑

GarageBand 来自Apple的免费数字音频工作站（DAW)，提供简介低门槛的操作界面和完整的音乐录制、剪辑制作功能
Logic Pro X 来自Apple的专业数字音频工作站（DAW），提供完整专业的音乐制作功能、优秀的自带插件和音源，原生支持Apple Silicon实现高效运行

书签阅读写作

Agenda - 以日期为重点的笔记记录应用程序，用于规划和记录您的项目。
Bear Writer - 漂亮，灵活的写作应用程序，用于制作笔记和散文。
Boostnote - 为程序员量身定做的笔记应用。开源地址
Chmox - 读 chm 文件的软件。
CHM Reader - 读 chm 文件的软件。
iChm - 读 chm 文件的软件。开源地址
Joplin - 支持 markdown 的开源记事本和具有同步功能的待办事项列表管理器。开源地址
Kindle App - 亚马逊 Kindle App 电子书阅读器。
Klib - 全新的 Kindle、iBooks 标注管理工具。
MarginNote - 一款优秀的 PDF 有标注软件，批注、抽认卡、思维导图、汇总视图等功能。
PDF Reader Pro - 可以查看，创建，签名，转换和压缩任何 PDF 文档。
PDF Expert - PDF 阅读、批注，编辑文本，添加照片，填写表单。
QOwnNotes - 是开源记事本，带有 markdown 支持和待办事项列表管理器。开源地址
Spillo - 功能强大，美观、快速网络书签网页阅读。
Skim - PDF 阅读器和笔记本。开源地址
texpad - Mac 下非常棒的 LaTeX 编辑器。支持自动编译预览，自动补全等。
WonderPen - 专注于写作的应用，支持 markdown，很多贴心细节，支持长文写作，可导出多种格式。

Office

KOffice - 集成化办公套件，包含文字处理器、电子表格、幻灯片制作、项目管理等多种工具。
Keynote 讲演构建炫目的演示文稿。
LibreOffice - 一款功能强大的免费开源办公软件，默认使用开放文档格式，并支持其他多种文档格式。开源地址
Microsoft Office 微软Office办公套件
Numbers 表格创建令人印象深刻的电子表格。
Pages 文稿引人注目的文稿。
WPS - 是一套跨平台的办公室软件套件。

RSS

Leaf - RSS 客户端程序。
NetNewsWire - 免费的 RSS 阅读器。开源地址
ReadKit - 书签 RSS 管理客户端。
Reeder 4 - RSS 服务订阅。
Vienna - RSS/Atom 新闻阅读客户端。开源地址
irreader - 多功能的 RSS 阅读器，支持订阅播客和任何网站。

Markdown

A curated list of delightful Markdown stuff.

Cmd Markdown - Cmd Markdown 编辑阅读器，支持实时同步预览，区分写作和阅读模式，支持在线存储，分享文稿网址。
EME - 最近刚出的一款 Markdown 编辑器，界面很像 Chrome 浏览器的界面，很简约。
iA Writer - Markdown 文本预览编辑，注重语法检查，专门为作家提供的编辑器。
LightPaper - 简单的 Markdown 文本编辑器。
Marp - Markdown 制作幻灯片编辑器。开源地址
MWeb - 专业的 Markdown 写作、记笔记、静态博客生成软件。
MacDown - 一款开源的 Markdown 编辑器，深受Mou的影响。** 开源 **
Marked 2 - Markdown 文本预览编辑，为所有作家提供一套优雅而强大的工具。
TextNut - Markdown 编辑器，富文本之间自由切换。
Typora - 基于 Electron 的“读写一体” Markdown 编辑器。
Ulysses - 适用于 Mac，iPad 和 iPhone 的写作应用程序，支持 Markdown。
Yu Writer - 一款能找到写作乐趣的 Markdown 文本编辑器。
马克飞象 - Markdown 编辑器，提供 Web 端和 App 端，多种配色，支持同步到印象笔记。
Effie - 轻量级 Markdown 写作软件，支持大纲笔记和思维导图。

笔记

Evernote - 笔记本应用程序。
Inkdrop - Markdown 爱好者的笔记本应用程序。
leanote - 支持 Markdown 的一款开源笔记软件，支持直接成为个人博客。开源地址
Notes - 简洁的笔记应用。开源地址
Notebook 漂亮的笔记本应用程序。
Notion - 一个集大成的富文本笔记管理软件，支持丰富却又简单明了的的文字格式，甚至覆盖了TODO类软件的功能。数据在服务端存储，支持web访问，也提供了macOS/Windows/iOS/安卓等平台客户端。
OneNote - 微软备注应用。
Quiver - 程序猿的笔记本。
有道云笔记 - 支持多目录，Markdown，iWork/Office 预览。
为知笔记 - 支持 Markdown，搜集整理图片链接导入文档。
阿里语雀 - 云笔记类知识管理、协作平台，基于Markdown写作，支持内嵌流程图、脑图、时序、代码渲染以及Sketch画板创作，个人知识分享等！相比有道云笔记、印象笔记同类产品，包含其全部的功能以外，支持知识分享以及更强大的创作、协作、编辑器，它来自阿里巴巴蚂蚁金服。

制作电子书

Calibre - 丑陋的软件，但强大的软件电子书管理和转换。开源地址
Sigil - 多平台 EPUB 编辑器。开源地址
Scribus - 开源电子杂志制作软件。开源地址

软件打包工具

AppJS - 使用 JS、HTML 和CSS 构建跨平台的桌面应用程序。开源地址
AlloyDesktop - 同上，腾讯出品，给个差评。开源地址
create-dmg - 快速创建一个压缩镜像文件。开源地址
Electron - 前身是 AtomShell，使用 JS、HTML 和 CSS 构建跨平台的桌面应用程序。开源地址
Electrino - 使用 JS、HTML 和 CSS 构建跨平台的桌面应用程序，构建出的应用体积比 Electron 小。开源地址
Finicky - Web 应用程序转化为苹果的应用程序。开源地址
HEX - 使用 JS、HTML 和 CSS 构建跨平台的桌面应用程序，有道出品。开源地址
ionic - 一个用来开发混合手机应用的，开源的，免费的代码库。开源地址
nw.js - 使用 HTML 和 JavaScript 来制作桌面应用。开源地址
MacGap - 桌面 WebKit 打包 HTML、CSS、JS 应用。开源地址
react-desktop - 为 macOS Sierra带来 React UI 组件。开源地址
ReactXP - 微软官方出品，支持平台 Web，iOS，Android 和 Windows UWP 仍然是一项正在进行的工作。开源地址
React Native macOS - 用 React Native 技术构建 OS X 下的桌面应用程序。开源地址
React Native Desktop for Ubuntu - 用 React Native 技术构建 Ubuntu 下的桌面应用程序。开源地址

下载工具

aria2 - 一款支持多种协议的轻量级命令行下载工具。开源地址
Downie - 支持多达近 1200 个视频站点的视频下载工具。
Free Download Manager - 功能强大的下载加速器。
FOLX - 一个 Mac osx 系统风格界面的下载管理工具。
JDownloader - 下载工具，下载文件的一键式托管。
Motrix - Motrix 是一款全能的下载工具，支持下载 HTTP、FTP、BT、磁力链、百度网盘等资源。开源地址
qBittorrent - 一个替代 μTorrent 的开源软件。开源地址
Transmission - 免费的 BitTorrent 客户端开源地址
You-Get - 网络富媒体命令行下载工具。开源地址

网盘

推荐一些有Mac客户端的网盘。

115 - 115 云客户端。
Dropbox - 非常好用的免费网络文件同步工具，提供在线存储服务。
NextCloud - 基于 ownCloud 完全开源免费开源，企业文件同步和共享。
Mega - 免费的云服务，提供 50GB 的免费存储空间。
Resilio Sync - P2P私有云盘，BitTorrent血统，支持安卓/iOS/Windows/macOS/Linux/FreeBSD/NAS等系统平台。注意：截止2021.7.20，macOS平台客户端存在休眠崩溃现象，除此之外可以正常使用。
Seafile - 是由国内团队开发的国际化的开源云存储软件项目。
Syncthing - Resilio Sync的开源竞争者，架构上更加开放自由，良好的用户文档，基于Go语言支持大量系统平台，甚至包括OpenWrt！此项目的界面翻译工作也支持开源共建。开源地址
ownCloud - 私有云网盘。
百度云 - 百度云客户端。
腾讯微云 - 腾讯云客户端。
坚果云 - 坚果云客户端。
亿方云 - 硅谷团队打造，个人免费。
阿里云盘 - 阿里云盘。

输入法

Kawa - 给每个输入法定义一个快捷键. 开源地址
RIME - 中州韻輸入法引擎。开源地址
Rocket - 使用冒号快捷键可以更快捷地输入表情符号。
Type2Phone - 把 Macbook 键盘变为 iPhone 的蓝牙键盘。
WBIM - 五笔输入法。
~~QQ输入法 - 腾讯出品的输入法。~~
搜狗输入法 - 搜狗输入法。
百度输入法 - 支持拼音五笔输入。
落格输入法 - 打破 Mac 双拼多年来的窘境。
iAvro - 孟加拉语输入法。开源地址
清歌五笔输入法 - 为 iOS 和 Mac 专门打造的五笔输入法。
颜文字 - 颜文字输入。
哈利路亚英文输入法 - 智能英文输入法，具备自动补全，自动纠错功能。

浏览器

这里放Mac的浏览器应用

Brave - 用 Brave 浏览更快更安全。
Chrome - Chrome 浏览器谷歌出品。
Firefox - 迎接 Firefox Quantum。快，只为更好。火狐浏览器。
Safari - Mac 预装自带浏览器。
Opera - Opera 浏览器。
QQ浏览器 - QQ 浏览器－腾讯出品。
Vivaldi - Opera 开发商出品新的浏览器。
Ōryōki - 小的 web 浏览器。这是一个试验性的项目，目前正在开发中
傲游云浏览器 - 傲游云浏览器。
360极速浏览器 - 更好用，不将就。

翻译工具

有道翻译 - 有道词典桌面版。
辞海词典 - 学单词、背单词、辞海词典。
eudic - 欧路词典词典。
Grammarly - 修正英语语法及用语
iText - 截图识别文字、翻译
iTranslate - 支持全世界超过 80 种语言发音和输出。
Ludwig - 语言搜索引擎，可帮助您用英语写得更好。
Translate Tab - 菜单栏翻译插件，封装了谷歌翻译，支持自动识别语言。
Bob - 简小好用的翻译工具，支持语言自动检测，截图翻译。开源地址
Translatium - 在 100 多种语言之间翻译单词、短语和图像，并提供字典、音译和语音输出支持。开源地址

安全工具

Antivirus One - 值得信赖的Mac安全保护工具：保护您的 Mac 免受病毒、恶意软件和广告软件的侵害。阻止潜在的 Web威胁并保护您的Mac免受漏洞影响。
BlockBlock - 恶意软件会自行安装，以确保它在重新引导时自动重新执行。
Dylib Hijack Scanner - Dylib 劫机扫描仪或 DHS，是一个简单的实用程序，将扫描您的计算机的应用程序是易受 dylib 劫持或被劫持。
Encrypto - 免费加密工具，用于加密文件和文件夹
GPG Suite - macOS平台的一站式GnuPG解决方案，提供命令行和GUI的加解密工具。开箱即用的gpg-agent密码缓存服务，还包括一个GUI的pinenry程序，支持与macOS原生钥匙串集成。开源地址
KextViewer - 查看所有在 OS 内核中加载的模块。
KnockKnock - “谁在那？” 查看Mac上持久安装的内容。
LinkLiar - 可以帮助你哄骗 Wi-Fi 和以太网接口的 MAC 地址。开源地址
LuLu - 免费的macOS防火墙，旨在阻止未经授权（传出）的网络流量。开源地址
Murus - 强大、灵活且易于理解使用的防火墙，官方提供多种不同的APP以提供不同功能的组合。最基础的免费版本Murus Lite是纯粹基于传入端口的防火墙，跟基于应用程序的macOS原生防火墙形成有效互补。
OverSight - 监控 Mac 的麦克风和网络摄像头，当内部麦克风被激活，或者当进程访问摄像头时提醒用户。
RansomWhere? - 通用 Ransomware 检测。
TaskExplorer - 使用 TaskExplorer 探索在 Mac 上运行的所有任务（进程）。
What's Your Sign? - 验证文件的加密签名可以推断其来源或可信度。

科学上网

假设你是个勤奋的同学，你总有一天会强烈需要它们，上帝保佑他们吧。

Algo - 在云中设置个人 IPSEC VPN。开源地址
ClashX - 基于 clash 的一款支持规则过滤的科学上网工具。开源地址
Lantern - 科学上网。开源地址
ShadowsocksX - 一个快速的隧道代理，可以帮助你绕过防火墙。开源地址
ShadowsocksX-NG - 一款 ShadowsocksX 客户端软件。开源地址
Surge - 科学上网。
Shimo - 连接大量 VPN 的应用
Tunnelbear - 简单的私人 VPN。
Tunnelblick - OpenVPN 的免费软件。
tinc - VPN 软件. 开源地址
V2Ray - 原生支持 Socks、HTTP、Shadowsocks、VMess 等协议。

其它实用工具

12306ForMac - Mac 版 12306 订票/检票助手。开源地址
1440 Minutes Left Today - 在菜单栏中，直接记录到一天结束还剩多少分钟。
AirServer - 将手机投影到电脑上。
Alfred - 效率神器。
Raycast - 类似Alfred功能，重要的是免费。
BitBar - 支持使用各种语言将信息展示到Mac OS的菜单栏。开源地址
BetterZip - 压缩解压缩工具支持格式 ZIP、TAR、TGZ、TBZ、TXZ (new)、7-ZIP、RAR。
BetterTouchTool - 代替默认的系统操作方式（组合键、修饰键、手势等）。
CopyQ - 高级功能剪贴板管理工具。开源地址
ControlPlane - 自定义 Mac 情景模式。某些场景让 Mac 自动静音或是自动打开 Mail 客户端等等。开源地址
ClipMenu - 一个剪贴板操作的管理器。开源地址
Clipy - 基于 ClipMenu 继续开发的强大的剪切板管理器。开源地址
CheatSheet - CheatSheet 是一款 Mac 上的非常实用的快捷键快速提醒工具。
DaisyDisk - 磁盘空间使用扫描工具。
DNS Heaven - 可以令基于 glibc 的 macOS 应用直接使用原生栈来解析 DNS，主要适用于 VPN。开源地址
eZip - 界面简洁，功能完善，支持主流的多种压缩格式。支持 Mojave 深色模式、QuickLook预览、拖拽解压。
f.lux - 自动调整您的电脑屏幕，以匹配亮度。
Lunar - 外接显示器亮度/对比度调节工具，从此告别物理按键。开源地址
Hammerspoon - 功能强大的自动化工具，Lua 脚本驱动，支持窗口管理。开源地址
HTTrack - 可以下载整个网站和离线浏览。
HapticKey - Touch Bar 触觉反馈。开源地址
HWSensors - 自带FakeSMC的黑苹果硬件状态监控插件。开源地址
Hungrymark - 非常有用的收藏夹应用，收藏文件，文件夹，网址，快速的通过状态栏菜单访问这些书签。
iStat pro - 免费的 Mac OS 电脑硬件信息检测软件。
Itsycal - 一款简洁实用的开源日历工具。开源地址
Karabiner - 一个强大的和稳定的 OS X 的键盘定制。开源地址
Keyboard Maestro - 根据键盘，菜单，位置，添加的设备等触发器自动执行日常操作。
Keytty - 让你通过键盘使用鼠标。
Keka - 一个免费的 macOS 文件解压缩程序。
Lungo - 防止Mac进入睡眠状态。
Memo - 给你的便笺加个密。
Manta - 灵活的发票桌面应用程序，漂亮和可定制模板。开源地址
Mos - 让你的鼠标滚轮丝滑如触控板。开源地址
Mac Cache Cleaner - 缓存清理工具开源地址
Numi - 漂亮的计算器应用。
NoSleep - 合上盖子不休眠，可根据是否连接电源单独设置。
openEmu - 模拟器，可以玩魂斗罗之类，轻松回到小时候。开源地址
OmniDiskSweeper - 磁盘空间使用扫描工具。
OmniPlan - 项目管理软件。
Paste - 智能剪贴板历史片段管理。
PasteBot - 强大的剪贴板管理器。
PDF Archiver - 一个用于标记和归档任务的好工具。开源地址
Qbserve - 观察你如何度过你的时间。
RescueTime - 个人分析服务，向您展示如何花时间和提供工具来帮助您提高工作效率。
Snap - 一款可以给 Dock 上的程序添加快捷键的小工具。
Streaker - GitHub贡献和统计跟踪菜单栏应用程序。开源地址
The Unarchiver - 解压许多不同种类的归档压缩文件。开源地址
Timing - Mac 的自动时间和生产力跟踪。
Unarchive One - 快速解压单个多个不同种类的压缩文件/压缩文件到各类常见压缩格式。
Ukelele - Unicode 键盘布局编辑器。
WWDC - Mac OS 的非官方的 WWDC APP。开源地址
xScope - 测量、检查和测试屏幕上的图形和布局的工具。搜索你的苹果和网络，快速打开应用程序。
360压缩 - 简单易用，免费无广告的压缩工具。
超级右键 - 一款finder右键菜单扩展，包括了大量便捷工具比如新建文件，直接打开终端等

剪贴板工具

ClipMenu - 一个剪贴板操作的管理器。开源地址
CopyQ - 高级功能剪贴板管理工具。开源地址
iPaste - 轻巧高效的剪贴板工具。
Paste - 智能剪贴板历史片段管理。
PasteBot - 强大的剪贴板管理器。

菜单栏工具

BeardedSpice - 允许您使用 Mac 键盘上的媒体键控制基于Web的媒体播放器（SoundCloud，YouTube 等）和一些本机应用程序。开源地址
Bartender - 组织或隐藏Mac上的菜单栏图标。
BitBar - 支持使用各种语言将信息展示到 Mac OS 的菜单栏。开源地址
iGlance - 状态栏的系统监视器。开源地址
Itsycal - 一款简洁实用的开源日历工具。开源地址
Vanilla - 隐藏系统菜单栏。

待办事项工具

2Do - 比较好的 TODO 应用程序。
Day-O 2 - 菜单日历更换内置日历。
Fantastical - 日历应用程序，你将管理好生活。
Focus - 一个漂亮的番茄工作法为基础的时间管理工具。
Microsoft To-Do - 任务管理工具微软出品。
Nozbe - 适用于个人和团队的强大GTD应用程序，支持每个Apple设备。
OmniFocus - 由 OmniGroups 制作的 Nice GTD 应用程序。
Taskade - 实时协作编辑器，协作简历任务管理器，大纲和笔记。
TaskPaper - 漂亮的纯文本任务列表。
Things - 令人愉快且易于使用的任务管理器。
Todoist - 跨平台的任务管理器与移动应用程序。
Wunderlist - 奇妙清单跨平台的任务管理器与移动应用程序。
滴答清单 - 轻便且强大的跨平台任务管理应用。

系统相关工具

Amphetamine - 覆盖您的节能设置并让您的Mac保持清醒状态。
AdBlock One - 适用于MacOS/iOS的免费广告拦截器停止在Safari中看到烦人的广告。更快地打开网站。更安全地浏览网页。
AppCleaner - 一个小应用程序，让你彻底卸载不需要的应用程序。
AppTrap - 删除APP的同时移除文件。开源地址
blueutil - 命令行蓝牙控制工具，可以配合SleepWatcher实现MacBook合盖瞬间关闭蓝牙，开盖自动打开蓝牙。这在使用蓝牙耳机时尤其有用。开源地址
Cleaner One - 多合一磁盘清理管理器：清理您的 Mac 并优化其性能，立即运行快速扫描以验证什么占用了您的存储空间。
Cleaner for Xcode - Xcode 的清理工具，清理几十G应该不是问题。开源地址
Coolant - 这是能让你知道什么应用程序造成你 CPU100% 让 Mac 电脑过热电池耗尽的菜单应用程序。
coconutBattery - 显示Mac中有关电池的实时信息。
DaisyDisk - 磁盘空间使用扫描工具。
FruitJuice - 会让你知道每天保持不插电的时间，以保持你的电池健康。
gfxCardStatus - 控制Mac独立显卡与集成显卡之间的切换。
HandShaker - Mac 电脑上也可以方便自如地管理您在 Android 手机中的内容。
HTML5 Player - Chrome 插件解决中国视频网站播放视频电脑发热的情况。
iStat Menus - 菜单栏上的高级 Mac 系统监视器。
iStats - iStats 是一个可以让你快速查看电脑 CPU 温度，磁盘转速和电池等信息的命令行工具。开源地址
Juice - 让电池显示更有趣开源地址
KeepingYouAwake - 替代咖啡因，更好地支持Mac中的暗模式。开源地址
Monity - 帮助用户实时监控系统的一款非常漂亮的软件。
Mounty - NTFS 分区读写组件。
NitroShare - 跨平台网络文件传输应用程序。开源地址
OnyX - 多功能实用工具来验证磁盘和文件，运行清洁和系统维护任务，配置隐藏选项等。
OmniDiskSweeper - 磁盘空间使用扫描工具。
Paragon NTFS - 在 Mac OS X 中完全读写、修改、访问 Windows NTFS 硬盘、U 盘等外接设备的文件。
Porting Kit - 在Mac中安装Windows®游戏。
SleepWatcher - 可以在MacBook合盖和开盖时执行自定义脚本，比如开关蓝牙等。可以通过homebrew安装。开源地址
smcFanControl - 短小精悍的风扇转速温控软件，可以预设两档风扇最低转速，方便在不同工作负载间人工强制切换。因为只是限制风扇最低速度，所以系统原生温控调速不会完全失效。开源地址
SSH Tunnel - 管理你的 SSH。
TG Pro - 温度监控，风扇控制和硬件诊断，帮助您保持 Mac的凉爽和健康。
Tuxera NTFS - Mac 上的 NTFS 文件系统驱动。
腾讯柠檬清理 - 一款免费的Mac系统清理软件，替代原来的Mac电脑管家，腾讯出品。

窗口管理

Amethyst - 窗口管理器（自动保持窗口大小的窗口）。开源地址
BetterSnapTool - 窗口管理工具，可通过快捷键或窗口拖动快速实现分屏。
Contexts- 提供比 Mac 原生 Dock 更强大功能尤其在你有多个屏幕的时候,它可以帮助你更快捷切换。
Divvy - 凭借其惊人的 Divvy Grid 系统，窗口管理处于最佳状态。
IntelliDock - 自动隐藏 Dock。
Moom - 多任务多窗口的软件。
Magnet - 一个窗口管理器，可以保持工作空间的组织。
rcmd - 使用 ⌘ Right Command 键根据名称切换应用程序。
ShiftIt - 窗口位置和大小管理软件。开源地址
Slate - 窗口管理器，可用 JavaScript 写配置。开源地址
SizeUp - 强大的，以键盘为中心的窗口管理。
Spectacle - 简单的移动和调整大小的窗口，和可定制的键盘快捷键。开源地址
Total Spaces - 像 ubuntu 一样提供窗口管理，为工作区创建热键，使您可以轻松移动。

密码管理

1password - 跨平台帐号密码管理软件。
Authy - 双因素身份验证令牌管理器，可在您的设备上进行备份和同步。
Bitwarden - 适用于Mac OS，iOS和浏览器的开源密码管理工具。开源地址
Buttercup - 跨平台密码管理器开源地址
Dashlane - 基于云的密码管理器，拥有屡获殊荣的设计。
Enpass - 具有云集成的跨平台密码管理工具。
Keeweb - 与 KeePass 兼容的免费跨平台密码管理器。开源地址
LastPass - 密码管理器和安全的数字笔记。
MacPass - 密码管理器。开源地址
RememBear - 治愈系密码管理工具。

Finder

fman - 先进的双窗口文件管理器，拥有很多特性。
ForkLift - 先进的双窗口文件管理器和文件传输客户端。
Hazel - 设计精美的自动文件管理软件。
MacAssistant - Google 助手开源地址
Path Finder - 强大的 Finder 替代者，拥有很多特性。
Quicklook-Plugins - Finder 快速预览文件插件。
QSpace - 一款简洁高效的多视图文件管理器。
TotalFinder - 强大的 Finder 替代者，界面风格像 Chrome。
XtraFinder - 给 Finder 添加有用的新特性。

远程协助

RustDesk - 又一个远程桌面软件。开源地址
AnyDesk 是一款远程控制跨多平台的程序。
Microsoft Remote Desktop - 微软官方的远程桌面连接工具(国区App store没有上架,下载地址)。
RealVNC 是一款免费的远程控制跨多平台的程序。
TeamViewer - 远程协助及在线协作和会议功能的软件，商业软件个人使用免费。

QuickLook插件

List of useful Quick Look plugins for developers.

使用 Homebrew Cask 将通过命令安装即为简单。开发人员使用的Quick Look插件列表。如果手动安装，你可将下载的 .qlgenerator 文件移动到 ~/Library/QuickLook 运行 qlmanage -r

QuicklookStephen - 可以让您查看没有文件扩展名的纯文本文件，如 README、INSTALL、Capfile、CHANGELOG...brew install --cask install qlstephen

第三方应用市场APP

这里讨论盗版问题或者提供黑名单？，拒绝盗版从我做起，欢迎大家监督。

正版

这里只提供正版软件购买下载的应用商店。

Homebrew Cask - 基于Homebrew扩展的，通过命令行安装 Mac GUI 软件的工具。开源地址
Homebrew - 体验通过命令行安装 Mac 软件的工具(大部分是命令行工具)。开源地址
MacUpdate Desktop - 管理/更新/下载 App，跟踪优惠信息。
MacPorts - 一个软件包管理工具，可用于简化 OS X 和 Darwin 操作系统内软件的安装。开源地址
Setapp - MacPaw 推出的订阅制付费 App 平台服务。

应用商店黑名单

第三方应用市场APP黑名单，存在盗版软件传播和下载，拒绝盗版从我做起，欢迎大家监督它们。

~~迅雷Thunder Store~~ - 迅雷 Thunder for Mac 带应用市场。
~~Mac软件宝箱~~ - Macx 推出软件宝箱。
~~MacHunter~~ - Mac 应用市场。

Mac软件下载网站

这里主要是推荐一些软件下载的网站，还有一些Mac OSX软件分享网站

正版/介绍

App Shopper：http://appshopper.com/
MacUpdate：https://www.macupdate.com/
少数派：http://sspai.com/tag/Mac
Mac玩儿法：http://www.waerfa.com
腾讯柠檬精选：https://lemon.qq.com/lab/

盗版软件下载网站黑名单

上面有大量的开源软件或者免费软件，拒绝盗版从我做起，下面被删除的网站提供大量破解软件下载，欢迎大家监督它们。

玩转苹果：~~http://www.ifunmac.com~~
AppKed：~~http://www.macbed.com~~
appaddict：~~https://www.appaddict.org/~~
Mac精品软件：~~http://xclient.info/~~
MacWk：~~https://macwk.com/~~
MacPeers：~~https://www.macpeers.com~~
Mac毒：~~https://www.macdo.cn~~
Macx：~~https://www.macx.cn/~~
Mac软件下载站：~~http://www.pshezi.com~~
MacPeers：~~http://www.macpeers.com~~
Mac志：~~http://www.isofts.org~~
Mac软件分享：~~http://www.waitsun.com~~
MacSky苹果软件园：~~http://www.macsky.net/~~
Softasm：~~https://softasm.com/~~
Mac破解软件：~~https://www.macappstore.net/~~
卡卡源：~~http://www.kkroot.com/~~
苹果软件园：~~http://www.maczapp.com~~
马可菠萝：~~http://www.macbl.com/~~
极致分享：~~https://alltoshare.com/~~
麦克社：~~http://www.macshe.com/~~
未来软件园：~~http://www.orsoon.com/~~
腾牛网：~~http://www.qqtn.com/mac/r_17_1.html~~
未来软件园：~~http://www.orsoon.com/mac/~~
威锋网：~~https://bbs.feng.com/forum.php?mod=forumdisplay&fid=19&page=~~
MAC萌新网：~~https://www.macxin.com~~

IDEA快捷键

Tue, 14 Jul 2020 12:31:51 GMT

（Win + Linux）快捷键

说明

IntelliJ IDEA 的便捷操作性，快捷键的功劳占了一大半，对于各个快捷键组合请认真对待。IntelliJ IDEA 本身的设计思维是提倡键盘优先于鼠标的，所以各种快捷键组合层出不穷，对于快捷键设置也有各种支持，对于其他 IDE 的快捷键组合也有预设模板进行支持。

关于各个快捷键的频率分类上可能每个人都有各自的看法，下面的整理也只是以我个人的使用习惯来划分的，而我应该是可以代表某一部分小众人员。但是我个人还是强烈建议你可以在我的基础上整理一份属于你的快捷键目录（删除掉多余的字眼，只保留快捷键内容），本篇文章也只是起到一个工具和引子的作用。

对于下面各个快捷键的使介绍描述也许用我个人语言翻译起来不够准确或是不全面，且在不同的文件类型上按出来的效果也可能结果不太一样,所以 强烈建议 你自己把各个快捷键都亲自操作下体会下各个快捷键的实际用法。

前提

IntelliJ IDEA 官方出的学习辅助插件：IDE Features Trainer：https://plugins.jetbrains.com/plugin/8554?pr=idea

Ctrl

快捷键	介绍
`Ctrl` + `F`	在当前文件进行文本查找 `（必备）`
`Ctrl` + `R`	在当前文件进行文本替换 `（必备）`
`Ctrl` + `Z`	撤销 `（必备）`
`Ctrl` + `Y`	删除光标所在行或删除选中的行 `（必备）`
`Ctrl` + `X`	剪切光标所在行或剪切选择内容
`Ctrl` + `C`	复制光标所在行或复制选择内容
`Ctrl` + `D`	复制光标所在行或复制选择内容，并把复制内容插入光标位置下面 `（必备）`
`Ctrl` + `W`	递进式选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展选中范围 `（必备）`
`Ctrl` + `E`	显示最近打开的文件记录列表 `（必备）`
`Ctrl` + `N`	根据输入的类名查找类文件 `（必备）`
`Ctrl` + `G`	在当前文件跳转到指定行处
`Ctrl` + `J`	插入自定义动态代码模板 `（必备）`
`Ctrl` + `P`	方法参数提示显示 `（必备）`
`Ctrl` + `Q`	光标所在的变量 / 类名 / 方法名等上面（也可以在提示补充的时候按），显示文档内容
`Ctrl` + `U`	前往当前光标所在的方法的父类的方法 / 接口定义 `（必备）`
`Ctrl` + `B`	进入光标所在的方法/变量的接口或是定义处，等效于 `Ctrl + 左键单击` `（必备）`
`Ctrl` + `K`	版本控制提交项目，需要此项目有加入到版本控制才可用
`Ctrl` + `T`	版本控制更新项目，需要此项目有加入到版本控制才可用
`Ctrl` + `H`	显示当前类的层次结构
`Ctrl` + `O`	选择可重写的方法
`Ctrl` + `I`	选择可继承的方法
`Ctrl` + `+`	展开代码
`Ctrl` + `-`	折叠代码
`Ctrl` + `/`	注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号 `（必备）`
`Ctrl` + `[`	移动光标到当前所在代码的花括号开始位置
`Ctrl` + `]`	移动光标到当前所在代码的花括号结束位置
`Ctrl` + `F1`	在光标所在的错误代码处显示错误信息 `（必备）`
`Ctrl` + `F3`	调转到所选中的词的下一个引用位置 `（必备）`
`Ctrl` + `F4`	关闭当前编辑文件
`Ctrl` + `F8`	在 Debug 模式下，设置光标当前行为断点，如果当前已经是断点则去掉断点
`Ctrl` + `F9`	执行 Make Project 操作
`Ctrl` + `F11`	选中文件 / 文件夹，使用助记符设定 / 取消书签 `（必备）`
`Ctrl` + `F12`	弹出当前文件结构层，可以在弹出的层上直接输入，进行筛选
`Ctrl` + `Tab`	编辑窗口切换，如果在切换的过程又加按上delete，则是关闭对应选中的窗口
`Ctrl` + `End`	跳到文件尾
`Ctrl` + `Home`	跳到文件头
`Ctrl` + `Space`	基础代码补全，默认在 Windows 系统上被输入法占用，需要进行修改，建议修改为 `Ctrl + 逗号` `（必备）`
`Ctrl` + `Delete`	删除光标后面的单词或是中文句 `（必备）`
`Ctrl` + `BackSpace`	删除光标前面的单词或是中文句 `（必备）`
`Ctrl` + `1,2,3...9`	定位到对应数值的书签位置 `（必备）`
`Ctrl` + `左键单击`	在打开的文件标题上，弹出该文件路径 `（必备）`
`Ctrl` + `光标定位`	按 Ctrl 不要松开，会显示光标所在的类信息摘要
`Ctrl` + `左方向键`	光标跳转到当前单词 / 中文句的左侧开头位置 `（必备）`
`Ctrl` + `右方向键`	光标跳转到当前单词 / 中文句的右侧开头位置 `（必备）`
`Ctrl` + `前方向键`	等效于鼠标滚轮向前效果 `（必备）`
`Ctrl` + `后方向键`	等效于鼠标滚轮向后效果 `（必备）`

Alt

快捷键	介绍
`Alt` + `	显示版本控制常用操作菜单弹出层 `（必备）`
`Alt` + `Q`	弹出一个提示，显示当前类的声明 / 上下文信息
`Alt` + `F1`	显示当前文件选择目标弹出层，弹出层中有很多目标可以进行选择 `（必备）`
`Alt` + `F2`	对于前面页面，显示各类浏览器打开目标选择弹出层
`Alt` + `F3`	选中文本，逐个往下查找相同文本，并高亮显示
`Alt` + `F7`	查找光标所在的方法 / 变量 / 类被调用的地方
`Alt` + `F8`	在 Debug 的状态下，选中对象，弹出可输入计算表达式调试框，查看该输入内容的调试结果
`Alt` + `Home`	定位 / 显示到当前文件的 `Navigation Bar`
`Alt` + `Enter`	IntelliJ IDEA 根据光标所在问题，提供快速修复选择，光标放在的位置不同提示的结果也不同 `（必备）`
`Alt` + `Insert`	代码自动生成，如生成对象的 set / get 方法，构造函数，toString() 等 `（必备）`
`Alt` + `左方向键`	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换 `（必备）`
`Alt` + `右方向键`	按切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换 `（必备）`
`Alt` + `前方向键`	当前光标跳转到当前文件的前一个方法名位置 `（必备）`
`Alt` + `后方向键`	当前光标跳转到当前文件的后一个方法名位置 `（必备）`
`Alt` + `1,2,3...9`	显示对应数值的选项卡，其中 1 是 Project 用得最多 `（必备）`

Shift

快捷键	介绍
`Shift` + `F1`	如果有外部文档可以连接外部文档
`Shift` + `F2`	跳转到上一个高亮错误或警告位置
`Shift` + `F3`	在查找模式下，查找匹配上一个
`Shift` + `F4`	对当前打开的文件，使用新Windows窗口打开，旧窗口保留
`Shift` + `F6`	对文件 / 文件夹重命名
`Shift` + `F7`	在 Debug 模式下，智能步入。断点所在行上有多个方法调用，会弹出进入哪个方法
`Shift` + `F8`	在 Debug 模式下，跳出，表现出来的效果跟 `F9` 一样
`Shift` + `F9`	等效于点击工具栏的 `Debug` 按钮
`Shift` + `F10`	等效于点击工具栏的 `Run` 按钮
`Shift` + `F11`	弹出书签显示层 `（必备）`
`Shift` + `Tab`	取消缩进 `（必备）`
`Shift` + `ESC`	隐藏当前或最后一个激活的工具窗口
`Shift` + `End`	选中光标到当前行尾位置
`Shift` + `Home`	选中光标到当前行头位置
`Shift` + `Enter`	开始新一行。光标所在行下空出一行，光标定位到新行位置 `（必备）`
`Shift` + `左键单击`	在打开的文件名上按此快捷键，可以关闭当前打开文件 `（必备）`
`Shift` + `滚轮前后滚动`	当前文件的横向滚动轴滚动 `（必备）`

Ctrl + Alt

快捷键	介绍
`Ctrl` + `Alt` + `L`	格式化代码，可以对当前文件和整个包目录使用 `（必备）`
`Ctrl` + `Alt` + `O`	优化导入的类，可以对当前文件和整个包目录使用 `（必备）`
`Ctrl` + `Alt` + `I`	光标所在行或选中部分进行自动代码缩进，有点类似格式化
`Ctrl` + `Alt` + `T`	对选中的代码弹出环绕选项弹出层 `（必备）`
`Ctrl` + `Alt` + `J`	弹出模板选择窗口，将选定的代码加入动态模板中
`Ctrl` + `Alt` + `H`	调用层次
`Ctrl` + `Alt` + `B`	在某个调用的方法名上使用会跳到具体的实现处，可以跳过接口
`Ctrl` + `Alt` + `C`	重构-快速提取常量
`Ctrl` + `Alt` + `F`	重构-快速提取成员变量
`Ctrl` + `Alt` + `V`	重构-快速提取变量
`Ctrl` + `Alt` + `Y`	同步、刷新
`Ctrl` + `Alt` + `S`	打开 IntelliJ IDEA 系统设置 `（必备）`
`Ctrl` + `Alt` + `F7`	显示使用的地方。寻找被该类或是变量被调用的地方，用弹出框的方式找出来
`Ctrl` + `Alt` + `F11`	切换全屏模式
`Ctrl` + `Alt` + `Enter`	光标所在行上空出一行，光标定位到新行 `（必备）`
`Ctrl` + `Alt` + `Home`	弹出跟当前文件有关联的文件弹出层
`Ctrl` + `Alt` + `Space`	类名自动完成
`Ctrl` + `Alt` + `左方向键`	退回到上一个操作的地方 `（必备）`
`Ctrl` + `Alt` + `右方向键`	前进到上一个操作的地方 `（必备）`
`Ctrl` + `Alt` + `前方向键`	在查找模式下，跳到上个查找的文件
`Ctrl` + `Alt` + `后方向键`	在查找模式下，跳到下个查找的文件
`Ctrl` + `Alt` + `右括号（]）`	在打开多个项目的情况下，切换下一个项目窗口
`Ctrl` + `Alt` + `左括号（[）`	在打开多个项目的情况下，切换上一个项目窗口

Ctrl + Shift

快捷键	介绍
`Ctrl` + `Shift` + `F`	根据输入内容查找整个项目或指定目录内文件 `（必备）`
`Ctrl` + `Shift` + `R`	根据输入内容替换对应内容，范围为整个项目或指定目录内文件 `（必备）`
`Ctrl` + `Shift` + `J`	自动将下一行合并到当前行末尾 `（必备）`
`Ctrl` + `Shift` + `Z`	取消撤销 `（必备）`
`Ctrl` + `Shift` + `W`	递进式取消选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展取消选中范围 `（必备）`
`Ctrl` + `Shift` + `N`	通过文件名定位 / 打开文件 / 目录，打开目录需要在输入的内容后面多加一个正斜杠 `（必备）`
`Ctrl` + `Shift` + `U`	对选中的代码进行大 / 小写轮流转换 `（必备）`
`Ctrl` + `Shift` + `T`	对当前类生成单元测试类，如果已经存在的单元测试类则可以进行选择 `（必备）`
`Ctrl` + `Shift` + `C`	复制当前文件磁盘路径到剪贴板 `（必备）`
`Ctrl` + `Shift` + `V`	弹出缓存的最近拷贝的内容管理器弹出层
`Ctrl` + `Shift` + `E`	显示最近修改的文件列表的弹出层
`Ctrl` + `Shift` + `H`	显示方法层次结构
`Ctrl` + `Shift` + `B`	跳转到类型声明处 `（必备）`
`Ctrl` + `Shift` + `I`	快速查看光标所在的方法或类的定义
`Ctrl` + `Shift` + `A`	查找动作 / 设置
`Ctrl` + `Shift` + `/`	代码块注释 `（必备）`
`Ctrl` + `Shift` + `[`	选中从光标所在位置到它的顶部中括号位置 `（必备）`
`Ctrl` + `Shift` + `]`	选中从光标所在位置到它的底部中括号位置 `（必备）`
`Ctrl` + `Shift` + `+`	展开所有代码 `（必备）`
`Ctrl` + `Shift` + `-`	折叠所有代码 `（必备）`
`Ctrl` + `Shift` + `F7`	高亮显示所有该选中文本，按Esc高亮消失 `（必备）`
`Ctrl` + `Shift` + `F8`	在 Debug 模式下，指定断点进入条件
`Ctrl` + `Shift` + `F9`	编译选中的文件 / 包 / Module
`Ctrl` + `Shift` + `F12`	编辑器最大化 `（必备）`
`Ctrl` + `Shift` + `Space`	智能代码提示
`Ctrl` + `Shift` + `Enter`	自动结束代码，行末自动添加分号 `（必备）`
`Ctrl` + `Shift` + `Backspace`	退回到上次修改的地方 `（必备）`
`Ctrl` + `Shift` + `1,2,3...9`	快速添加指定数值的书签 `（必备）`
`Ctrl` + `Shift` + `左键单击`	把光标放在某个类变量上，按此快捷键可以直接定位到该类中 `（必备）`
`Ctrl` + `Shift` + `左方向键`	在代码文件上，光标跳转到当前单词 / 中文句的左侧开头位置，同时选中该单词 / 中文句 `（必备）`
`Ctrl` + `Shift` + `右方向键`	在代码文件上，光标跳转到当前单词 / 中文句的右侧开头位置，同时选中该单词 / 中文句 `（必备）`
`Ctrl` + `Shift` + `前方向键`	光标放在方法名上，将方法移动到上一个方法前面，调整方法排序 `（必备）`
`Ctrl` + `Shift` + `后方向键`	光标放在方法名上，将方法移动到下一个方法前面，调整方法排序 `（必备）`

Alt + Shift

快捷键	介绍
`Alt` + `Shift` + `N`	选择 / 添加 task `（必备）`
`Alt` + `Shift` + `F`	显示添加到收藏夹弹出层 / 添加到收藏夹
`Alt` + `Shift` + `C`	查看最近操作项目的变化情况列表
`Alt` + `Shift` + `I`	查看项目当前文件
`Alt` + `Shift` + `F7`	在 Debug 模式下，下一步，进入当前方法体内，如果方法体还有方法，则会进入该内嵌的方法中，依此循环进入
`Alt` + `Shift` + `F9`	弹出 `Debug` 的可选择菜单
`Alt` + `Shift` + `F10`	弹出 `Run` 的可选择菜单
`Alt` + `Shift` + `左键双击`	选择被双击的单词 / 中文句，按住不放，可以同时选择其他单词 / 中文句 `（必备）`
`Alt` + `Shift` + `前方向键`	移动光标所在行向上移动 `（必备）`
`Alt` + `Shift` + `后方向键`	移动光标所在行向下移动 `（必备）`

Ctrl + Shift + Alt

快捷键	介绍
`Ctrl` + `Shift` + `Alt` + `V`	无格式黏贴 `（必备）`
`Ctrl` + `Shift` + `Alt` + `N`	前往指定的变量 / 方法
`Ctrl` + `Shift` + `Alt` + `S`	打开当前项目设置 `（必备）`
`Ctrl` + `Shift` + `Alt` + `C`	复制参考信息

其他

快捷键	介绍
`F2`	跳转到下一个高亮错误或警告位置 `（必备）`
`F3`	在查找模式下，定位到下一个匹配处
`F4`	编辑源 `（必备）`
`F7`	在 Debug 模式下，进入下一步，如果当前行断点是一个方法，则进入当前方法体内，如果该方法体还有方法，则不会进入该内嵌的方法中
`F8`	在 Debug 模式下，进入下一步，如果当前行断点是一个方法，则不进入当前方法体内
`F9`	在 Debug 模式下，恢复程序运行，但是如果该断点下面代码还有断点则停在下一个断点上
`F11`	添加书签 `（必备）`
`F12`	回到前一个工具窗口 `（必备）`
`Tab`	缩进 `（必备）`
`ESC`	从工具窗口进入代码文件窗口 `（必备）`
`连按两次Shift`	弹出 `Search Everywhere` 弹出层

官网快捷键资料

Windows / Linux：https://www.jetbrains.com/idea/docs/IntelliJIDEA_ReferenceCard.pdf

Mac OS X：https://www.jetbrains.com/idea/docs/IntelliJIDEA_ReferenceCard_Mac.pdf

第三方快捷键资料

来自 eta02913：http://xinyuwu.iteye.com/blog/1005454

Mac 快捷键

根据官方pdf翻译：https://www.jetbrains.com/idea/docs/IntelliJIDEA_ReferenceCard_Mac.pdf
在 IntelliJ IDEA 中有两个 Mac 版本的快捷键，一个叫做：Mac OS X，一个叫做：Mac OS X 10.5+
目前都是用：Mac OS X 10.5+
有两套的原因：https://intellij-support.jetbrains.com/hc/en-us/community/posts/206159109-Updated-Mac-OS-X-keymap-Feedback-needed

建议将 Mac 系统中与 IntelliJ IDEA 冲突的快捷键取消或更改，不建议改 IntelliJ IDEA 的默认快捷键。

Mac 键盘符号

图标	介绍
⌘	`Command`
⇧	`Shift`
⇪	`Caps Lock`
⌥	`Option` = `Alt`
⌃	`Control`
↩	`Enter`
⌫	`Delete`
⌦	`Fn` + `Delete`
↑	`上箭头`
↓	`下箭头`
←	`左箭头`
→	`右箭头`
⇞	`Fn` + `↑` = `Page Up`
⇟	`Fn` + `↓` = `Page Down`
Home	`Fn` + `←`
End	`Fn` + `→`
⇥	`Tab` = `右制表符`
⇤	`Shift + Tab` = `左制表符`
⎋	`Esc` = `Escape`
⏏	`电源开关键`

Editing（编辑）

Control + Space 基本的代码补全（补全任何类、方法、变量）
Control + Shift + Space 智能代码补全（过滤器方法列表和变量的预期类型）
Command + Shift + Enter 自动结束代码，行末自动添加分号
Command + P 显示方法的参数信息
Control + J 显示当前位置的变量、方法的 Documentation 内容
Control + J 快速查看文档
Shift + F1 查看外部文档（在某些代码上会触发打开浏览器显示相关文档）
Command + 鼠标放在代码上 显示代码简要信息
Command + F1 在错误或警告处显示具体描述信息
Command + N, Control + Enter, Control + N 生成代码（getter、setter、构造函数、hashCode/equals,toString）
Control + O 覆盖方法（重写父类方法）
Control + I 实现方法（实现接口中的方法）
Command + Option + T 包围代码（使用if..else, try..catch, for, synchronized等包围选中的代码）
Command + / 注释/取消注释与行注释
Command + Option + / 注释/取消注释与块注释
Option + 方向键上 连续选中代码块
Option + 方向键下 减少当前选中的代码块
Control + Shift + Q 显示上下文信息
Option + Enter 显示意向动作和快速修复代码
Command + Option + L 格式化代码
Control + Option + O 优化import
Control + Option + I 自动缩进线
Tab / Shift + Tab 缩进代码 / 反缩进代码
Command + X 剪切当前行或选定的块到剪贴板
Command + C 复制当前行或选定的块到剪贴板
Command + V 从剪贴板粘贴
Command + Shift + V 从最近的缓冲区粘贴
Command + D 复制当前行或选定的块
Command + Delete 删除当前行或选定的块的行
Control + Shift + J 智能的将代码拼接成一行
Command + Enter 智能的拆分拼接的行
Shift + Enter 开始新的一行
Command + Shift + U 大小写切换
Command + Shift + ] / Command + Shift + [ 选择直到代码块结束/开始
Option + Fn + Delete 删除到单词的末尾
Option + Delete 删除到单词的开头
Command + 加号 / Command + 减号 展开 / 折叠代码块
Command + Shift + 加号 展开所以代码块
Command + Shift + 减号 折叠所有代码块
Command + W 关闭活动的编辑器选项卡

Search/Replace（查询/替换）

Double Shift 查询任何东西
Command + F 文件内查找
Command + G 查找模式下，向下查找
Command + Shift + G 查找模式下，向上查找
Command + R 文件内替换
Command + Shift + F 全局查找（根据路径）
Command + Shift + R 全局替换（根据路径）
Command + Shift + S 查询结构（Ultimate Edition 版专用，需要在Keymap中设置）
Command + Shift + M 替换结构（Ultimate Edition 版专用，需要在Keymap中设置）

Usage Search（使用查询）

Option + F7 / Command + F7 在文件中查找用法 / 在类中查找用法
Command + Shift + F7 在文件中突出显示的用法
Command + Option + F7 显示用法

Compile and Run（编译和运行）

Command + F9 编译Project
Command + Shift + F9 编译选择的文件、包或模块
Control + Option + R 弹出 Run 的可选择菜单
Control + Option + D 弹出 Debug 的可选择菜单
Control + R 运行
Control + D 调试
Control + Shift + R, Control + Shift + D 从编辑器运行上下文环境配置

Debugging（调试）

F8 进入下一步，如果当前行断点是一个方法，则不进入当前方法体内
F7 进入下一步，如果当前行断点是一个方法，则进入当前方法体内，如果该方法体还有方法，则不会进入该内嵌的方法中
Shift + F7 智能步入，断点所在行上有多个方法调用，会弹出进入哪个方法
Shift + F8 跳出
Option + F9 运行到光标处，如果光标前有其他断点会进入到该断点
Option + F8 计算表达式（可以更改变量值使其生效）
Command + Option + R 恢复程序运行，如果该断点下面代码还有断点则停在下一个断点上
Command + F8 切换断点（若光标当前行有断点则取消断点，没有则加上断点）
Command + Shift + F8 查看断点信息

Navigation（导航）

Command + O 查找类文件
Command + Shift + O 查找所有类型文件、打开文件、打开目录，打开目录需要在输入的内容前面或后面加一个反斜杠/
Command + Option + O 前往指定的变量 / 方法
Control + 方向键左 / Control + 方向键右 左右切换打开的编辑tab页
F12 返回到前一个工具窗口
Esc 从工具窗口进入代码文件窗口
Shift + Esc 隐藏当前或最后一个活动的窗口，且光标进入代码文件窗口
Command + Shift + F4 关闭活动run/messages/find/... tab
Command + L 在当前文件跳转到某一行的指定处
Command + E 显示最近打开的 文件记录 列表
Command + Shift + E 显示最近打开的 文件代码位置记录 列表
Option + 方向键左 / Option + 方向键右 光标跳转到当前单词 / 中文句的左 / 右侧开头位置
Command + Option + 方向键左 / Command + Option + 方向键右 退回 / 前进到上一个操作的地方
Command + Shift + Delete 跳转到最后一个编辑的地方
Option + F1 显示当前文件选择目标弹出层，弹出层中有很多目标可以进行选择(如在代码编辑窗口可以选择显示该文件的Finder)
Command + B / Command + 鼠标点击 进入光标所在的方法/变量的接口或是定义处
Command + Option + B 跳转到实现处，在某个调用的方法名上使用会跳到具体的实现处，可以跳过接口
Option + Space, Command + Y 快速打开光标所在方法、类的定义
Control + Shift + B 跳转到类型声明处
Command + U 前往当前光标所在方法的父类的方法 / 接口定义
Control + 方向键下 / Control + 方向键上 当前光标跳转到当前文件的前一个/后一个方法名位置
Command + ] / Command + [ 移动光标到当前所在代码的花括号开始/结束位置
Command + F12 弹出当前文件结构层，可以在弹出的层上直接输入进行筛选（可用于搜索类中的方法）
Control + H 显示当前类的层次结构
Command + Shift + H 显示方法层次结构
Control + Option + H 显示调用层次结构
F2 / Shift + F2 跳转到下一个/上一个突出错误或警告的位置
F4 / Command + 方向键下 编辑/查看代码源
Option + Home 显示到当前文件的导航条
F3选中文件/文件夹/代码行，添加/取消书签
Option + F3 选中文件/文件夹/代码行，使用助记符添加/取消书签
Control + 0...Control + 9 定位到对应数值的书签位置
Command + F3 显示所有书签

Refactoring（重构）

F5 复制文件到指定目录
F6 移动文件到指定目录
Command + Delete 在文件上为安全删除文件，弹出确认框
Shift + F6 重命名文件
Command + F6 更改签名
Command + Option + N 一致性
Command + Option + M 将选中的代码提取为方法
Command + Option + V 提取变量
Command + Option + F 提取字段
Command + Option + C 提取常量
Command + Option + P 提取参数

VCS/Local History（版本控制/本地历史记录）

Command + K 提交代码到版本控制器
Command + T 从版本控制器更新代码
Option + Shift + C 查看最近的变更记录
Control + C 快速弹出版本控制器操作面板

Live Templates（动态代码模板）

Command + Option + J 弹出模板选择窗口，将选定的代码使用动态模板包住
Command + J 插入自定义动态代码模板

General（通用）

Command + 1...Command + 9 打开相应编号的工具窗口
Command + S 保存所有
Command + Option + Y 同步、刷新
Control + Command + F 切换全屏模式
Command + Shift + F12 切换最大化编辑器
Option + Shift + F 添加到收藏夹
Option + Shift + I 检查当前文件与当前的配置文件
Control + ` 快速切换当前的scheme（切换主题、代码样式等）
Command + , 打开IDEA系统设置
Command + ; 打开项目结构对话框
Shift + Command + A 查找动作（可设置相关选项）
Control + Shift + Tab 编辑窗口标签和工具窗口之间切换（如果在切换的过程加按上delete，则是关闭对应选中的窗口）

Other（一些官方文档上没有体现的快捷键）

Command + Shift +8 竖编辑模式

从 Windows 过度到 Mac 必备快捷键对照表

Mac 键盘符号

图标	介绍
⌘	`Command`
⇧	`Shift`
⇪	`Caps Lock`
⌥	`Option` = `Alt`
⌃	`Control`
↩	`Enter`
⌫	`Delete`
⌦	`Fn` + `Delete`
↑	`上箭头`
↓	`下箭头`
←	`左箭头`
→	`右箭头`
⇞	`Fn` + `↑` = `Page Up`
⇟	`Fn` + `↓` = `Page Down`
Home	`Fn` + `←`
End	`Fn` + `→`
⇥	`Tab` = `右制表符`
⇤	`Shift + Tab` = `左制表符`
⎋	`Esc` = `Escape`
⏏	`电源开关键`

Alt

Win 快捷键	Mac 快捷键	介绍
`Alt` + `	`Control` + `V`	显示版本控制常用操作菜单弹出层
`Alt` + `F1`	`Option` + `F1`	显示当前文件选择目标弹出层，弹出层中有很多目标可以进行选择
`Alt` + `F7`	`Option` + `F7`	查询所选对象/变量被引用
`Alt` + `Enter`	`Option` + `Enter`	IntelliJ IDEA 根据光标所在问题，提供快速修复选择，光标放在的位置不同提示的结果也不同
`Alt` + `Insert`	`Command` + `N`	代码自动生成，如生成对象的 set / get 方法，构造函数，toString() 等
`Alt` + `左方向键`	`Control` + `左方向键`	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换
`Alt` + `右方向键`	`Control` + `右方向键`	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换
`Alt` + `前方向键`	`Control` + `前方向键`	当前光标跳转到当前文件的前一个方法名位置
`Alt` + `后方向键`	`Control` + `后方向键`	当前光标跳转到当前文件的后一个方法名位置
`Alt` + `1,2,3...9`	`Command` + `1,2,3...9`	显示对应数值的选项卡，其中 1 是 Project 用得最多

Ctrl

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `F`	`Command` + `F`	在当前文件进行文本查找
`Ctrl` + `R`	`Command` + `R`	在当前文件进行文本替换
`Ctrl` + `Z`	`Command` + `Z`	撤销
`Ctrl` + `G`	`Command` + `L`	跳转到指定行数位置
`Ctrl` + `Y`	`Command` + `Delete`	删除光标所在行或删除选中的行
`Ctrl` + `D`	`Command` + `D`	复制光标所在行或复制选择内容，并把复制内容插入光标位置下面
`Ctrl` + `W`	`Option` + `方向键上`	递进式选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展选中范围
`Ctrl` + `E`	`Command` + `E`	显示最近打开的文件记录列表
`Ctrl` + `N`	`Command` + `O`	根据输入的类名查找类文件
`Ctrl` + `J`	`Command` + `J`	插入自定义动态代码模板
`Ctrl` + `P`	`Command` + `P`	方法参数提示显示
`Ctrl` + `Q`	`Control` + `J`	当前位置变量、方法的 Documentation 内容显示
`Ctrl` + `U`	`Command` + `U`	前往当前光标所在的方法的父类的方法 / 接口定义
`Ctrl` + `B`	`Command` + `B`	进入光标所在的方法/变量的接口或是定义处，等效于 `Ctrl + 左键单击`
`Ctrl` + `/`	`Command` + `/`	注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号
`Ctrl` + `F1`	`Command` + `F1`	在光标所在的错误代码处显示错误信息
`Ctrl` + `F11`	`Option` + `F3`	选中文件 / 文件夹，使用助记符设定 / 取消书签
`Ctrl` + `F12`	`Command` + `F12`	弹出当前文件结构层，可以在弹出的层上直接输入，进行筛选
`Ctrl` + `Space`	`Control` + `Space`	基础代码补全，默认在 Windows 系统上被输入法占用，需要进行修改，建议修改为 `Ctrl + 逗号`
`Ctrl` + `Delete`	`Option` + `Fn`+ `Delete`	删除光标后面的单词或是中文句
`Ctrl` + `BackSpace`	`Option` + `Delete`	删除光标前面的单词或是中文句
`Ctrl` + `1,2,3...9`	`Control` + `1,2,3...9`	定位到对应数值的书签位置
`Ctrl` + `加号`	`Command` + `加号`	展开代码
`Ctrl` + `减号`	`Command` + `减号`	折叠代码
`Ctrl` + `左键单击`	`Control` + `左键单击`	在打开的文件标题上，弹出该文件路径
`Ctrl` + `左方向键`	`Option` + `左方向键`	光标跳转到当前单词 / 中文句的左侧开头位置
`Ctrl` + `右方向键`	`Option` + `右方向键`	光标跳转到当前单词 / 中文句的右侧开头位置
`Ctrl` + `前方向键`	预设中没有该快捷键	等效于鼠标滚轮向前效果
`Ctrl` + `后方向键`	预设中没有该快捷键	等效于鼠标滚轮向后效果

Shift

Win 快捷键	Mac 快捷键	介绍
`Shift` + `F11`	`Command + F3`	弹出书签显示层
`Shift` + `Tab`	`Shift + Tab`	取消缩进
`Shift` + `Enter`	`Shift + Enter`	开始新一行。光标所在行下空出一行，光标定位到新行位置
`Shift` + `左键单击`	`Shift + 左键单击`	在打开的文件名上按此快捷键，可以关闭当前打开文件

Alt + Shift

Win 快捷键	Mac 快捷键	介绍
`Alt` + `Shift` + `N`	`Option` + `Shift` + `N`	选择 / 添加 task
`Alt` + `Shift` + `左键双击`	`Option` + `Shift` + `左键双击`	选择被双击的单词 / 中文句，按住不放，可以同时选择其他单词 / 中文句
`Alt` + `Shift` + `前方向键`	`Option` + `Shift` + `前方向键`	移动光标所在行向上移动
`Alt` + `Shift` + `后方向键`	`Option` + `Shift` + `后方向键`	移动光标所在行向下移动

Ctrl + Alt

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `Alt` + `L`	`Command` + `Option` + `L`	格式化代码，可以对当前文件和整个包目录使用
`Ctrl` + `Alt` + `O`	`Control` + `Option` + `O`	优化导入的类，可以对当前文件和整个包目录使用
`Ctrl` + `Alt` + `T`	`Command` + `Option` + `T`	对选中的代码弹出环绕选项弹出层
`Ctrl` + `Alt` + `S`	`Command` + `逗号`	打开 IntelliJ IDEA 系统设置
`Ctrl` + `Alt` + `Enter`	`Command` + `Option` + `Enter`	光标所在行上空出一行，光标定位到新行
`Ctrl` + `Alt` + `左方向键`	`Command` + `Option` + `左方向键`	退回到上一个操作的地方
`Ctrl` + `Alt` + `右方向键`	`Command` + `Option` + `右方向键`	前进到上一个操作的地方

Ctrl + Shift

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `Shift` + `F`	`Command` + `Shift` + `F`	根据输入内容查找整个项目或指定目录内文件
`Ctrl` + `Shift` + `R`	`Command` + `Shift` + `R`	根据输入内容替换对应内容，范围为整个项目或指定目录内文件
`Ctrl` + `Shift` + `J`	`Control` + `Shift` + `J`	自动将下一行合并到当前行末尾
`Ctrl` + `Shift` + `Z`	`Command` + `Shift` + `Z`	取消撤销
`Ctrl` + `Shift` + `W`	`Option` + `方向键下`	递进式取消选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展取消选中范围
`Ctrl` + `Shift` + `N`	`Command` + `Shift` + `O`	通过文件名定位 / 打开文件 / 目录，打开目录需要在输入的内容后面多加一个正斜杠
`Ctrl` + `Shift` + `U`	`Command` + `Shift` + `U`	对选中的代码进行大 / 小写轮流转换
`Ctrl` + `Shift` + `T`	`Command` + `Shift` + `T`	对当前类生成单元测试类，如果已经存在的单元测试类则可以进行选择
`Ctrl` + `Shift` + `C`	`Command` + `Shift` + `C`	复制当前文件磁盘路径到剪贴板
`Ctrl` + `Shift` + `B`	`Control` + `Shift` + `B`	跳转到类型声明处
`Ctrl` + `Shift` + `/`	`Command` + `Option` + `/`	代码块注释
`Ctrl` + `Shift` + `[`	`Command` + `Shift` + `[`	选中从光标所在位置到它的顶部中括号位置
`Ctrl` + `Shift` + `]`	`Command` + `Shift` + `]`	选中从光标所在位置到它的底部中括号位置
`Ctrl` + `Shift` + `加号`	`Command` + `Shift` + `加号`	展开所有代码
`Ctrl` + `Shift` + `减号`	`Command` + `Shift` + `减号`	折叠所有代码
`Ctrl` + `Shift` + `F7`	`Command` + `Shift` + `F7`	高亮显示所有该选中文本，按Esc高亮消失
`Ctrl` + `Shift` + `F12`	`Command` + `Shift` + `F12`	编辑器最大化
`Ctrl` + `Shift` + `Enter`	`Command` + `Shift` + `Enter`	自动结束代码，行末自动添加分号
`Ctrl` + `Shift` + `Backspace`	`Ctrl` + `Shift` + `Backspace`	退回到上次修改的地方
`Ctrl` + `Shift` + `1,2,3...9`	`Control` + `Shift` + `1,2,3...9`	快速添加指定数值的书签
`Ctrl` + `Shift` + `左键单击`	`Command` + `Shift` + `左键单击`	把光标放在某个类变量上，按此快捷键可以直接定位到该类中
`Ctrl` + `Shift` + `左方向键`	`Option` + `Shift` + `左方向键`	在代码文件上，光标跳转到当前单词 / 中文句的左侧开头位置，同时选中该单词 / 中文句
`Ctrl` + `Shift` + `右方向键`	`Option` + `Shift` + `右方向键`	在代码文件上，光标跳转到当前单词 / 中文句的右侧开头位置，同时选中该单词 / 中文句
`Ctrl` + `Shift` + `前方向键`	`Command` + `Shift` + `前方向键`	光标放在方法名上，将方法移动到上一个方法前面，调整方法排序
`Ctrl` + `Shift` + `后方向键`	`Command` + `Shift` + `后方向键`	光标放在方法名上，将方法移动到下一个方法前面，调整方法排序

Ctrl + Shift + Alt

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `Shift` + `Alt` + `V`	`Command` + `Shift` + `Option` + `V`	无格式黏贴
`Ctrl` + `Shift` + `Alt` + `S`	`Command` + `;`	打开当前项目设置

Other

Win 快捷键	Mac 快捷键	介绍
`F2`	`F2`	跳转到下一个高亮错误或警告位置
`F4`	`F4`	编辑源
`F11`	`F3`	添加书签
`F12`	`F12`	回到前一个工具窗口
`Tab`	`Tab`	缩进
`ESC`	`ESC`	从工具窗口进入代码文件窗口

最特殊的快捷键 Alt + Enter 介绍

说明

这是一个非常特殊的快捷键，有必要拿出来单独讲。
强烈注意：此快捷键跟光标所在位置有着很严重关联关系，光标放的位置不同，使用此快捷键出来的菜单选项完全不一样。
可以从几个思路：Java 类、JSP、HTML、JavaScript、CSS、SQL 等文件类型
下面演示的各个功能是基于：IntelliJ IDEA 2016.1.1，如果你使用早期版本，可能不一定有对应的功能。

智能辅助

在 接口类 中，如果光标当前所在的方法，已经在 接口实现类 中生成了，则此快捷键的效果是跳转。

在 接口类 中添加一个方法后，让该 接口实现类 也跟着生成

在 接口实现类 中添加一个方法后，让该 接口类 也跟着生成

对当前光标所在类，生成单元测试类

对当前光标所在类，创建子类，常用在对接口生成接口实现类

移除未使用的变量、对象等元素

对属性创建 set、get 方法

添加 doc，只能把光标放在方法名或是变量名等这类元素上才会有

把自己造的单词加入词库中，让拼写单词检查错误的波浪线效果消失。

自己造的词库在上图所示位置

快速移除当前类所继承的接口，并且同时清空已经写好的该接口所有的 Override 方法。

光标只能方式 接口实现类 上的 接口对象单词 上才可以实现。

修改光标当前元素的作用域

给调用的方法生成返回值

根据返回值自动强转

对光标所在的对象进行包导入

切换成静态导入

根据 Language Level 级别不同，JDK 特性不同，给不同意见。Language Level 的含义在其他章节有讲过。

给 Hibernate 的 Entity 对象分配数据源，从而产生一系列智能功能

编码5分钟，命名2小时？Java开发都需要参考的一份命名规范！

Tue, 07 Jul 2020 15:21:13 GMT

简洁清爽的代码风格应该是大多数工程师所期待的。在工作中笔者常常因为起名字而纠结，夸张点可以说是编程5分钟，命名两小时！

每个公司都有不同的标准，目的是为了保持统一，减少沟通成本，提升团队研发效能。所以本文中是笔者结合阿里巴巴开发规范，以及工作中的见闻针对Java领域相关命名进行整理和总结，仅供参考。

一，Java中的命名规范

好的命名能体现出代码的特征，含义或者是用途，让阅读者可以根据名称的含义快速厘清程序的脉络。不同语言中采用的命名形式大相径庭，Java中常用到的命名形式共有三种，既首字母大写的UpperCamelCase，首字母小写的lowerCamelCase以及全部大写的并用下划线分割单词的UPPERCAMELUNSER_SCORE。通常约定，类一般采用大驼峰命名，方法和局部变量使用小驼峰命名，而大写下划线命名通常是常量和枚举中使用。

类型(名)	约束	例
项目	全部小写多个单词用中划线分隔‘-’	spring-cloud
包	全部小写	com.alibaba.fastjson
类	单词首字母大写	Feature,FieldDeserializer
变量	首字母小写多个单词组成时，除首个单词其他单词首字母都要大写	password, userName
常量	全部大写，多个单词，用'_'分隔	CACHEEXPIREDTIME
方法	同变量	read(), getById(Long id)

二，包命名

包名统一使用小写，点分隔符之间有且仅有一个自然语义的英文单词或者多个单词自然连接到一块（如 springframework，deepspace不需要使用任何分割）。包名统一使用单数形式，如果类命有复数含义，则可以使用复数形式。

包名的构成可以分为以下几四部分【前缀】【发起者名】【项目名】【模块名】。常见的前缀可以分为以下几种：

前缀	例	含义
indi或onem	indi.发起者名.项目名.模块名.……	个体项目个人发起，但非自己独自完成可公开或私有项目，copyright主要属于发起者。
pers	pers.个人名.项目名.模块名.……	个人项目指个人发起，独自完成，可分享的项目copyright主要属于个人
priv	priv.个人名.项目名.模块名.……	私有项目，指个人发起，独自完成非公开的私人使用的项目，copyright属于个人。
team	team.团队名.项目名.模块名.……	团队项目，指由团队发起并由该团队开发的项目copyright属于该团队所有
顶级域名	com.公司名.项目名.模块名.……	公司项目copyright由项目发起的公司所有

三，类命名

类名使用大驼峰命名形式，类命通常时名词或名词短语，接口名除了用名词和名词短语以外，还可以使用形容词或形容词短语，如Cloneable，Callable等，表示实现该接口的类有某种功能或能力。对于测试类则以它要测试的类开头，以Test结尾，如HashMapTest。

对于一些特殊特有名词缩写也可以使用全大写命名，比如XMLHttpRequest，不过笔者认为缩写三个字母以内都大写，超过三个字母则按照要给单词算。这个没有标准如阿里巴巴中fastjson用JSONObject作为类命，而google则使用JsonObjectRequest命名，对于这种特殊的缩写，原则是统一就好。

属性(类)	约束	例
抽象	Abstract 或Base 开头	BaseUserService
枚举	Enum 作为后缀	OSType
工具	Utils作为后缀	StringUtils
异常	Exception结尾	RuntimeException
接口实现	接口名+ Impl	UserServiceImpl
领域模型相	/DO/DTO/VO/DAO	正例：UserDAO反例：UserDao
设计模式相关	Builder，Factory等	当使用到设计模式时要使用对应的设计模式作为后缀如ThreadFactory
处理特定功能	Handler，PredicateValidator	表示处理器，校验器，断言这些类工厂还有配套的方法名如handle，predicate，validate
测试	Test后缀	UserServiceTest表示用来测试UserService类的
MVC分层	Controller，ServiceServiceImpl，DAO后缀	UserManageControllerUserManageDAO

四，方法

方法命名采用小驼峰的形式，首字小写，往后的每个单词首字母都要大写。和类名不同的是，方法命名一般为动词或动词短语，与参数或参数名共同组成动宾短语，即动词 + 名词。一个好的函数名一般能通过名字直接获知该函数实现什么样的功能。

4.1 返回真伪值的方法

位置	单词	意义	例
pre	is	对象是否符合期待的状态	isValid
pre	can	对象能否执行所期待的动作	canRemove
pre	should	调用方执行某个命令或方法是好还是不好应不应该，或者说推荐还是不推荐	shouldMigrate
pre	has	对象是否持有所期待的数据和属性	hasObservers
pre	needs	调用方是否需要执行某个命令或方法	needsMigrate

4.2 用来检查的方法

单词	意义	例
ensure	检查是否为期待的状态
不是则抛出异常或返回error code	ensureCapacity
validate	检查是否为正确的状态
不是则抛出异常或返回error code	validateInputs

4.3 按需求才执行的方法

位置	单词	意义	例
suf	IfNeeded	需要的时候执行不需要则什么都不做	drawIfNeeded
pre	might	同上	mightCreate
pre	try	尝试执行失败时抛出异常或是返回errorcode	tryCreate
suf	OrDefault	尝试执行失败时返回默认值	getOrDefault
suf	OrElse	尝试执行失败时返回实际参数中指定的值	getOrElse
pre	force	强制尝试执行error抛出异常或是返回值	forceCreate, forceStop

4.4 异步相关方法

位置	单词	意义	例
pre	blocking	线程阻塞方法	blockingGetUser
suf	InBackground	执行在后台线程	doInBackground
suf	Async	异步方法	sendAsync
suf	Sync	同步方法	sendSync
pre/alo	schedule	Job和Task放入队列	schedule, scheduleJob
pre/alo	post	同上	postJob
pre/alo	execute	执行异步或同步方法	execute,executeTask
pre/alo	start	同上	star,tstartJob
pre/alo	cancel	停止异步方法	cance,cancelJob
pre/alo	stop	同上	stop,stopJob

4.5 回调方法

位置	单词	意义	例
pre	on	事件发生时执行	onCompleted
pre	before	事件发生前执行	beforeUpdate
pre	pre	同上	preUpdate
pre	will	同上	willUpdate
pre	after	事件发生后执行	afterUpdate
pre	post	同上	postUpdate
pre	did	同上	didUpdate
pre	should	确认事件是否可以执行	shouldUpdate

4.6 操作对象生命周期的方法

单词	意义	例
initialize	初始化或延迟初始化使用	initialize
pause	暂停	onPause , pause
stop	停止	onStop, stop
abandon	销毁的替代	abandon
destroy	同上	destroy
dispose	同上	dispose

4.7 与集合操作相关的方法

单词	意义	例
contains	是包含指定对象相同的对象	contains
add	添加	addJob
append	添加	appendJob
insert	插入到下标n	insertJob
put	添加与key对应的元素	putJob
remove	移除元素	removeJob
enqueue	添加到队列的最末位	enqueueJob
dequeue	从队列中头部取出并移除	dequeueJob
push	添加到栈头	pushJob
pop	从栈头取出并移除	popJob
peek	从栈头取出但不移除	peekJob
find	寻找符合条件的某物	findById

4.8 与数据相关的方法

单词	意义	例
create	新创建	createAccount
new	新创建	newAccount
from	从既有的某物新建或是从其他的数据新建	fromConfig
to	转换	toString
update	更新既有某物	updateAccount
load	读取	loadAccount
fetch	远程读取	fetchAccount
delete	删除	deleteAccount
remove	删除	removeAccount
save	保存	saveAccount
store	保存	storeAccount
commit	保存	commitChange
apply	保存或应用	applyChange
clear	清除或是恢复到初始状态	clearAll
reset	清除或是恢复到初始状态	resetAll

4.9 成对出现的动词

单词	意义
get获取	set 设置
add 增加	remove 删除
create 创建	destory 移除
start 启动	stop 停止
open 打开	close 关闭
read 读取	write 写入
load 载入	save 保存
create 创建	destroy 销毁
begin 开始	end 结束
backup 备份	restore 恢复
import 导入	export 导出
split 分割	merge 合并
inject 注入	extract 提取
attach 附着	detach 脱离
bind 绑定	separate 分离
view 查看	browse 浏览
edit 编辑	modify 修改
select 选取	mark 标记
copy 复制	paste 粘贴
undo 撤销	redo 重做
insert 插入	delete 移除
add 加入	append 添加
clean 清理	clear 清除
index 索引	sort 排序
find 查找	search 搜索
increase 增加	decrease 减少
play 播放	pause 暂停
launch 启动	run 运行
compile 编译	execute 执行
debug 调试	trace 跟踪
observe 观察	listen 监听
build 构建	publish 发布
input 输入	output 输出
encode 编码	decode 解码
encrypt 加密	decrypt 解密
compress 压缩	decompress 解压缩
pack 打包	unpack 解包
parse 解析	emit 生成
connect 连接	disconnect 断开
send 发送	receive 接收
download 下载	upload 上传
refresh 刷新	synchronize 同步
update 更新	revert 复原
lock 锁定	unlock 解锁
check out 签出	check in 签入
submit 提交	commit 交付
push 推	pull 拉
expand 展开	collapse 折叠
begin 起始	end 结束
start 开始	finish 完成
enter 进入	exit 退出
abort 放弃	quit 离开
obsolete 废弃	depreciate 废旧
collect 收集	aggregate 聚集

五，变量&常量命名

5.1 变量命名

变量是指在程序运行中可以改变其值的量，包括成员变量和局部变量。变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如 computedValues，index、变量命名时，尽量简短且能清楚的表达变量的作用，命名体现具体的业务含义即可。

变量名不应以下划线或美元符号开头，尽管这在语法上是允许的。变量名应简短且富于描述。变量名的选用应该易于记忆，即，能够指出其用途。尽量避免单个字符的变量名，除非是一次性的临时变量。pojo中的布尔变量，都不要加is(数据库中的布尔字段全都要加 is_ 前缀)。

5.2 常量命名

常量命名CONSTANT_CASE，一般采用全部大写（作为方法参数时除外），单词间用下划线分割。那么什么是常量呢？

常量是在作用域内保持不变的值，一般使用final进行修饰。一般分为三种，全局常量（public static final修饰），类内常量（private static final 修饰）以及局部常量（方法内，或者参数中的常量），局部常量比较特殊，通常采用小驼峰命名即可。

/**  * 一个demo  *  * @author XiaoMage  * @date 2020-07-07 00:25  **/  public class HelloWorld {       //局部常量(正例)     public  static  final long  USER_MESSAGE_CACHE_EXPIRE_TIME  =  3600;          //局部常量(反例，命名不清晰）     public static final long  MESSAGE_CACHE_TIME = 3600;      // 全局常量     private  static final String ERROR_MESSAGE  = "error message";          //成员变量     private int  currentUserId;          /**      * 控制台打印 {@code message} 信息      *      * @param message 消息体，局部常量      */     public void  sayHello ( final String  message ) {           System.out.println("Hello world!");       }   }

常量一般都有自己的业务含义,不要害怕长度过长而进行省略或者缩写。如，用户消息缓存过期时间的表示，那种方式更佳清晰，交给你来评判。

通用命名规则

1.尽量不要使用拼音；杜绝拼音和英文混用。对于一些通用的表示或者难以用英文描述的可以采用拼音，一旦采用拼音就坚决不能和英文混用。正例：BeiJing， HangZhou 反例：validateCanShu

2.命名过程中尽量不要出现特殊的字符，常量除外。

3.尽量不要和jdk或者框架中已存在的类重名，也不能使用java中的关键字命名。

4.>妙用介词，如for(可以用同音的4代替), to(可用同音的2代替), from, with，of等。如类名采用User4RedisDO，方法名getUserInfoFromRedis，convertJson2Map等。

六，代码注解

6.1 注解的原则

好的命名增加代码阅读性，代码的命名往往有严格的限制。而注解不同，程序员往往可以自由发挥，单并不意味着可以为所欲为之胡作非为。优雅的注解通常要满足三要素。

1.Nothing is strange 没有注解的代码对于阅读者非常不友好，哪怕代码写的在清除，阅读者至少从心理上会有抵触，更何况代码中往往有许多复杂的逻辑，所以一定要写注解，不仅要记录代码的逻辑，还有说清楚修改的逻辑。

2.Less is more 从代码维护角度来讲，代码中的注解一定是精华中的精华。合理清晰的命名能让代码易于理解，对于逻辑简单且命名规范，能够清楚表达代码功能的代码不需要注解。滥用注解会增加额外的负担，更何况大部分都是废话。

// 根据id获取信息【废话注解】

Advance with the time 注解应该随着代码的变动而改变，注解表达的信息要与代码中完全一致。通常情况下修改代码后一定要修改注解。

6.2 注解格式

注解大体上可以分为两种，一种是javadoc注解，另一种是简单注解。javadoc注解可以生成JavaAPI为外部用户提供有效的支持javadoc注解通常在使用IDEA，或者Eclipse等开发工具时都可以自动生成，也支持自定义的注解模板，仅需要对对应的字段进行解释。参与同一项目开发的同学，尽量设置成相同的注解模板。

a. 包注解

包注解在工作中往往比较特殊，通过包注解可以快速知悉当前包下代码是用来实现哪些功能，强烈建议工作中加上，尤其是对于一些比较复杂的包，包注解一般在包的根目录下，名称统一为package-info.java。

/**  * 落地也质量检测  * 1. 用来解决什么问题  * 对广告主投放的广告落地页进行性能检测，模拟不同的系统，如Android，IOS等; 模拟不同的网络：2G，3G，4G，wifi等  * 2. 如何实现  * 基于chrome浏览器，用chromedriver驱动浏览器，设置对应的网络，OS参数，获取到浏览器返回结果。  * 注意：网络环境配置信息{@link cn.mycookies.landingpagecheck.meta.NetWorkSpeedEnum}目前使用是常规速度，可以根据实际情况进行调整  * @author xiaomage  * @time 2020/07/7 20:3 下午  */  package cn.maruifu.landingpagecheck;

b. 类注接

javadoc注解中，每个类都必须有注解。

/**  * Copyright (C), 2019-2020, XiaoMage  balabala...  * 类的介绍：这是一个用来做什么事情的类，有哪些功能，用到的技术.....  * @author   类创建者姓名 保持对齐  * @date     创建日期 保持对齐  * @version  版本号 保持对齐  */

c. 属性注解

在每个属性前面必须加上属性注释，通常有一下两种形式，至于怎么选择，你高兴就好，不过一个项目中要保持统一。

/** 提示信息 */ private String userName; /**  * 密码  */ private String password;

d. 方法注释

在每个方法前面必须加上方法注释，对于方法中的每个参数，以及返回值都要有说明。

/**   * 方法的详细说明，能干嘛，怎么实现的，注意事项...   * @param xxx      参数1的使用说明， 能否为null   * @return 返回结果的说明， 不同情况下会返回怎样的结果   * @throws 异常类型   注明从此类方法中抛出异常的说明   */

e. 构造方法注释

在每个构造方法前面必须加上注释，注释模板如下：

/**   * 构造方法的详细说明   * @param xxx      参数1的使用说明， 能否为null   * @throws 异常类型   注明从此类方法中抛出异常的说明   */

而简单注解往往是需要工程师字节定义，在使用注解时应该注意一下几点：

枚举类的各个属性值都要使用注解，枚举可以理解为是常量，通常不会发生改变，通常会被在多个地方引用，对枚举的修改和添加属性通常会带来很大的影响。
保持排版整洁，不要使用行尾注释；双斜杠和星号之后要用1个空格分隔。

int id  = 1 ; // 反例：不要使用行尾注释 //反例：换行符与注释之间没有缩进  int  age  = 18 ;  // 正例：姓名 String name ;  /**  * 1. 多行注释  *  * 2. 对于不同的逻辑说明，可以用空行分隔  */

总结

无论是命名和注解，他们的目的都是为了让代码和工程师进行对话，增强代码的可读性，可维护性。优秀的代码往往能够见名知意，注解往往是对命名的补充和完善。命名太难了！

参考文献：《码出高效》 https://www.cnblogs.com/wangcp-2014/p/10215620.html https://qiita.com/KeithYokoma/items/2193cf79ba76563e3db6 https://google.github.io/styleguide/javaguide.html#s2.1-file-name

各种乱码原因及示例

Tue, 07 Jul 2020 15:13:11 GMT

Java 通过反射动态执行方法

Tue, 07 Jul 2020 15:08:41 GMT

     public static void main(String[] args) throws  Exception{             Class clazz = Class.forName("com.mantis.hc.sale.dto.response.ExamAssistCustomerQueryRespDTO");         Class clazz1 = ExamAssistCustomerQueryRespDTO.class;          ExamAssistCustomerQueryRespDTO examAssistCustomerQueryRespDTO = new ExamAssistCustomerQueryRespDTO();         examAssistCustomerQueryRespDTO.setAccount("qweqweqweqweqw");          String  attachmenturl = (String) clazz.getMethod("getAccount").invoke(examAssistCustomerQueryRespDTO);//执行方法         String  attachmenturl1 = (String) clazz1.getMethod("getAccount").invoke(examAssistCustomerQueryRespDTO);//执行方法          System.out.println(attachmenturl);         System.out.println(attachmenturl1);      }

Java 检测无效下载地址（进度版）

Tue, 07 Jul 2020 15:04:00 GMT

import java.net.HttpURLConnection; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.List;  public class TestFile {          public static void main(String[] args) throws Exception{             // select group_concat(CONCAT('"',download_url,'"'))    from   table           List<String> list = Arrays.asList(         "https://maruifu.cn/pdf/static//702e126d6d714be0979ae27aaa59893b.pdf"         ,"https://maruifu.cn/pdf/static//98edd35b7e8a493cbeeda2bf4abeb8d8.pdf"         ,"https://maruifu.cn/pdf/static//92e2360fc7514bd191b1c248de8fda5d.pdf"         ,"https://maruifu.cn/pdf/static//85faf19d86084a938571907db4f83c4a.pdf");         List<String> strs = new ArrayList<>();         for (int i = 0; i < list.size(); i++) {             printSchedule(  (i + 1)*100/list.size());             if(!"N".equals(getFlile(list.get(i)))){                 strs.add(getFlile(list.get(i)));             }          }         System.out.println("\n"+"不能下载地址列表:"+strs.toString());      }         public static String getFlile(String filepath)throws Exception{             URL pathUrl = new URL(filepath);             HttpURLConnection urlcon = (HttpURLConnection) pathUrl.openConnection();             if(urlcon.getResponseCode()>=400){                 return filepath;             }           return "N";     }        private static int TOTLE_LENGTH = 100;     public static void printSchedule(int percent){         for (int i = 0; i < TOTLE_LENGTH + 10; i++) {             System.out.print("\b");         }         int now = TOTLE_LENGTH * percent / 100;         for (int i = 0; i < now; i++) {             System.out.print(">");         }         for (int i = 0; i < TOTLE_LENGTH - now; i++) {             System.out.print(" ");         }         System.out.print("  " + percent + "%");     } }

Java 通过网络流转发文件到浏览器

Tue, 07 Jul 2020 15:03:00 GMT

public void downloadVideoById(HttpServletRequest request, HttpServletResponse response) throws Exception {         logger.info("下载请求start>>");         String fileName = request.getParameter("fileName");//文件名         String filePath = request.getParameter("filePath");//文件名         try {             if (StringUtil.isEmpty(fileName) || StringUtil.isEmpty(filePath)) {                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);                 response.setCharacterEncoding("UTF-8");                 response.setContentType("application/json;charset=UTF-8");                 response.getWriter().print("参数错误，请联系管理员!");                 response.flushBuffer();                 return;             }              URL pathUrl = new URL(filePath);             HttpURLConnection urlcon = (HttpURLConnection) pathUrl.openConnection();             if(urlcon.getResponseCode()>=400){                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);                 response.setCharacterEncoding("UTF-8");                 response.setContentType("application/json;charset=UTF-8");                 response.getWriter().print("文件不存在，请联系管理员!");                 response.flushBuffer();                 return;             }             //获取输入流对象（用于读文件） 网络流             InputStream inputStream = new URL(filePath).openStream();             //本地流文件             // FileInputStream fis = new FileInputStream(new File(filePath));             //动态设置响应类型，根据前台传递文件类型设置响应类型             response.setContentType("application/" + fileName.substring(fileName.lastIndexOf(".")+1));             //设置响应头,attachment表示以附件的形式下载，inline表示在线打开             response.setHeader("content-disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "UTF-8"));//下载时浏览器显示的名称             //获取输出流对象（用于写文件）             ServletOutputStream os = response.getOutputStream();             //下载文件,使用spring框架中的FileCopyUtils工具             FileCopyUtils.copy(inputStream, os);          } catch (Exception e) {             logger.error("下载失败 start >>",e);             response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);             response.setCharacterEncoding("UTF-8");             response.setContentType("application/json;charset=UTF-8");             response.getWriter().print("下载失败，请联系管理员!");             response.flushBuffer();         }       }

Java 修改文件名

Tue, 07 Jul 2020 15:00:13 GMT

        public static void main(String[] args) throws Exception {                String  oldPath =  "/Users/admin/test/jmeter/123.log";             String  newPath =  "/Users/admin/test/jmeter/123/qweqweqweq.log";              //创建指定的路径             File directory = new File(newPath);             //获取文件夹 路径             String courseFile = directory.getParent();             File file = new File(courseFile );//             if(!file.exists()){//如果文件夹不存在                 file.mkdir();//创建文件夹             }             File oldFile = new File(oldPath );             File newFile = new File(newPath );             //重命名             System.out.println(oldFile.renameTo(newFile));                                 }

群晖Docker安装chevereto图床

Sun, 14 Jun 2020 07:41:03 GMT

Docker chevereto 准备的环境

mysql 数据库（我目前是使用的是MariaDB 10,安装数据库不多做叙述，可以看我之前的教程）

我用的是 Navicat ，新建数据库填写 chevereto 如图：

Docker chevereto的下载

在群晖docker里面的注册表里面搜索 Chevereto ，我用的nmtan/chevereto下载，如果有让你选择标签的话默认就好，等待容器镜像下载完成。如图:

Docker chevereto的存储卷

在群晖的docker目录里面建立子目录Chevereto，后面安装容器会挂载此目录作为图床的文件存储目录,注意文件名的大小写

Docker chevereto的配置

容器镜像下载完成后，点击下载的镜像文件名的小箭头，查看该容器该如何进行配置，docker其实大部分都有配置介绍，多看看自己也会配置

双击该镜像进行安装，容器名称随意填写，内存限制根据实际需要填写，点击高级设置，启用自动重新启动打钩，卷设置里面点击添加文件夹，选择你刚刚在docker目录下创建的 chevereto目录，后面装载路径填写【/var/www/html/images】，不能有空格，请注意，然后在到端口设置，本地端口设置为10000，容器端口不需要修改，后面进行docker的环境配置，

点击启用后，可以使用http:群晖地址:10000 进行访问，设置相关的信息

有时候会提示群晖没有对 images 文件夹的写入权限，后面对/volume1/docker/chevereto 赋予权限即可！

也可以从ssh 里面直接赋予所有权限

chmod +r 777 chevereto

Docker chevereto修改上传大小

http://域名:10000/dashboard/settings/image-upload

获取root权限

admin@XiaoMageNAS:~$ sudo -i root@XiaoMageNAS:~#

查看运行的docker容器

root@XiaoMageNAS:~# docker ps -a CONTAINER ID        IMAGE                              COMMAND                  CREATED             STATUS                     PORTS                                             NAMES 327c9776e0d3        nmtan/chevereto:latest             "docker-php-entrypoi…"   17 hours ago        Up 5 hours                 0.0.0.0:10000->80/tcp                             Chevereto 7a30c3437280        oldiy/music-player-docker:latest   "docker-php-entrypoi…"   13 days ago         Up 13 days                 0.0.0.0:32769->264/tcp, 0.0.0.0:32768->9000/tcp   oldiy-music-player-docker1 1c8b79caaee6        luodaoyi/kms-server:1112           "/bin/sh -c 'vlmcsdm…"   8 weeks ago         Exited (255) 7 weeks ago                                                     luodaoyi-kms-server1 root@XiaoMageNAS:~#

复制到群晖本地目录

root@XiaoMageNAS:~# docker cp  327c9776e0d3:/var/www/html/.htaccess /volume1/docker/ root@XiaoMageNAS:~#

修改配置文件

vi /volume1/docker/.htaccess

# Disable server signature ServerSignature Off    # Disable directory listing (-indexes), Multiviews (-MultiViews) and enable Follow system links (+FollowSymLinks) Options -Indexes Options -MultiViews  <IfModule mod_rewrite.c>      RewriteEngine On      # If you have problems with the rewrite rules remove the "#" from the following RewriteBase line     # You will also have to change the path to reflect the path to your Chevereto installation     # If you are using alias is most likely that you will need this.     #RewriteBase /      # 404 images     # If you want to have your own fancy "image not found" image remove the "#" from RewriteCond and RewriteRule lines     # Make sure to apply the correct paths to reflect your current installation     RewriteCond %{REQUEST_FILENAME} !-f     RewriteRule images/.+\.(gif|jpe?g|png|bmp) - [NC,L,R=404]     #RewriteRule images/.+\.(gif|jpe?g|png|bmp) content/images/system/default/404.gif [NC,L]      RewriteCond %{REQUEST_FILENAME} !-f     RewriteCond %{REQUEST_FILENAME} !-d     RewriteCond %{REQUEST_URI} !\.(css|js|html|htm|rtf|rtx|svg|svgz|txt|xsd|xsl|xml|asf|asx|wax|wmv|wmx|avi|bmp|class|divx|doc|docx|exe|gif|gz|gzip|ico|jpe?g|jpe|mdb|mid|midi|mov|qt|mp3|m4a|mp4|m4v|mpeg|mpg|mpe|mpp|odb|odc|odf|odg|odp|ods|odt|ogg|pdf|png|pot|pps|ppt|pptx|ra|ram|swf|tar|tif|tiff|wav|wma|wri|xla|xls|xlsx|xlt|xlw|zip)$ [NC]     RewriteRule . index.php [L]     #修改上传文件大小增加以下 配置  最大支持 32M 根据自己情况配置     php_value post_max_size 64M     php_value upload_max_filesize 32M  </IfModule>

复制到容器目录里面

docker cp /volume1/docker/.htaccess 327c9776e0d3:/var/www/html/

然后进入到docker容器管理里面重新启动即可解除2m上传限制

群晖NAS利用Docker容器搭建KMS激活服务器实现激活windows系统和office

Sat, 13 Jun 2020 15:01:25 GMT

前言

Windows系统中能够通过KMS进行激活的一般称为VL版,即VOLUME授权版。我们可以自行搭建KMS激活服务器，实现每180天一次的自动激活，使得系统一直保持激活状态。这次就跟大家分享一下如何利用群晖NAS的Docker容器套件搭建KMS服务器，并演示如何利用我们自己的KMS服务器激活Windows操作系统与Microsoft Office。

操作步骤

先到套件中心安装Docker套件

安装好以后打开Docker在注册表这里搜索：KMS，选择第一个，点击【下载】

选择一个版本，我这里就选择:1112

稍等片刻下载完成，完成后再到【映像】选择到我们刚才下载的点击【启动】

开始创建容器，这里点击【高级设置】

在【网络】这里勾选【使用与Docker Host相同的网络】

最后确认一下即可点击【应用】，应用后自动启动容器。

这样我们的KMS服务器就算搭建好了，KMS服务器默认端口号为：1688，IP的话就是我们NAS的IP。想要外网也可以用的话就可以使用内网穿透或者端口映射。下面以Windows10专业工作站版为例演示一下如何使用KMS激活系统。

这里首先我们先判断一下我们的Windows是什么版本，管理员身份运行命令提示符，输入：wmic os get caption 看到我这里是Windows 10 专业工作站版

打开：https://technet.microsoft.com/en-us/library/jj612867.aspx 找到对应系统版本的KEY，例如Windows10 专业工作站版的KEY为：NRG8B-VKK3Q-CXVCJ-9G2XF-6Q84J

依旧管理员身份打开命令提示符，键入如下命令（对应您自己的情况修改以下命令内容。nas.maruifu.cn为您的NAS的IP地址，NRG8B-VKK3Q-CXVCJ-9G2XF-6Q84J为操作系统对应的KEY）：

slmgr /skms nas.zeruns.tech  slmgr /ipk NRG8B-VKK3Q-CXVCJ-9G2XF-6Q84J  slmgr /ato

查看一下系统的激活状态

这样我们就完成了利用自建的KMS服务器激活我们的操作系统，接下来就是激活Microsoft Office，这里我以Microsoft Office 2019 VOL 专业版为例演示操作。

首先先确认下我们的Office是否为VOL版，方法如下（请您根据自身情况更改以下命令）：

管理员身份运行命令提示符，输入 cd C:\Program Files\Microsoft Office\Office16 切换目录（这里请根据您自己的Office版本更改相应路径），再输入cscript ospp.vbs /dstatus 。可以看到这里有VL字样即为VOL版

然后开始激活，输入如下命令：

cd C:\Program Files\Microsoft Office\Office16  cscript ospp.vbs /sethst:nas.zeruns.tech  cscript ospp.vbs /act

最后看到Product activation successful字样即为激活成功。

查看一下Microsoft Office的激活状态

Docker镜像pull不下来最终解决方法

Sat, 13 Jun 2020 14:33:22 GMT

pull镜像wordpress下来，但是出现如下错误：

# docker pull wordpress:latest     Error response from daemon: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaitin headers)

查看日志，发现出现如下错误：

#tailf /var/log/messages Aug 19 16:46:29 docker02 dockerd: time="2019-08-19T16:46:29.157861585+08:00" level=warning msg="Error getting v2 registry: Get https://registry.docker-cn.com/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)" Aug 19 16:46:29 docker02 dockerd: time="2019-08-19T16:46:29.157965774+08:00" level=info msg="Attempting next endpoint for pull after error: Get https://registry.docker-cn.com/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)" Aug 19 16:46:44 docker02 dockerd: time="2019-08-19T16:46:44.158651847+08:00" level=warning msg="Error getting v2 registry: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)" Aug 19 16:46:44 docker02 dockerd: time="2019-08-19T16:46:44.158907684+08:00" level=info msg="Attempting next endpoint for pull after error: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)" Aug 19 16:46:44 docker02 dockerd: time="2019-08-19T16:46:44.159189201+08:00" level=error msg="Handler for POST /v1.40/images/create returned error: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)"

发现是因为docker加速器超时导致pull不下来查看加速器：/etc/docker/daemon.json

# cat /etc/docker/daemon.json  { "registry-mirrors": ["https://registry.docker-cn.com"], "insecure-registries": ["10.0.0.12:5000"] }

导致此问题产生，主要是因为国家把docker国外镜像hub封掉了，导致镜像pull不下来，为此，改用国内的镜像

# cat /etc/docker/daemon.json  { "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn/","https://hub-mirror.c.163.com","https://registry.docker-cn.com"], "insecure-registries": ["10.0.0.12:5000"] } #systemctl restart docker # docker pull wordpress:latest latest: Pulling from library/wordpress 1ab2bdfe9778: Pulling fs layer  1448c64389e0: Pulling fs layer  4b8a4e62b444: Pulling fs layer  9eb9d1e8e241: Pulling fs layer  d20b2d19292c: Pull complete  023060ea5930: Pull complete  a7fa99bc84ac: Pull complete  138ec8da18f2: Pull complete  cd4dae5ac262: Pull complete  c90eff48869a: Pull complete  1bc49f4d3a43: Pull complete  e3bb2b10f58d: Pull complete  fd7b454ec570: Pull complete  6096f23889f4: Pull complete  81072ed817d5: Pull complete  ecce7df16ad3: Pull complete  f4475635015e: Pull complete  bad34b7324ad: Pull complete  890f49d5ad8a: Pull complete  7e4ee285d305: Pull complete  Digest: sha256:6566a68d0c613304aa11255d98aba6e29c5fa8cd8497064639343956a4c7d2b1 Status: Downloaded newer image for wordpress:latest docker.io/library/wordpress:latest

可以正常Pull下来了。

群晖 MariaDB10 开启远程登录

Sat, 13 Jun 2020 14:28:00 GMT

群晖安装 MariaDB10 后，默认仅支持本机连接，也就是说，你的局域网电脑是连接不上的，如果需要局域网连接，需要做处理。

环境：群晖6.2、MariaDB10

处理方法：

1、使用 ssh 登录到群晖

2、进入 MariaDB 默认安装目录

cd /volume1/@appstore/MariaDB10/usr/local/mariadb10/bin

3、使用 root 登录 MariaDB，然后进行修改

admin@XiaoMageNAS:~$ sudo -i root@XiaoMageNAS:~# cd  /volume1/@appstore root@XiaoMageNAS:/volume1/@appstore# ls AudioStation  DownloadStation  MailPlus-Server  NoteStation   PHP7.0                      TextEditor    WebStation CloudStation  ffmpeg           MariaDB10        PDFViewer     PHP7.2                      transmission CloudSync     Git              Node.js_v12      Perl          PythonModule                VideoStation Docker        MailClient       Node.js_v8       PhotoStation  SynologyApplicationService  WebDAVServer root@XiaoMageNAS:/volume1/@appstore# cd /volume1/@appstore/MariaDB10/usr/local/mariadb10/bin root@XiaoMageNAS:/volume1/@appstore/MariaDB10/usr/local/mariadb10/bin#  root@XiaoMageNAS:/volume1/@appstore/MariaDB10/usr/local/mariadb10/bin# ./mysql -u root -p Enter password:  Welcome to the MariaDB monitor.  Commands end with ; or \g. Your MariaDB connection id is 14 Server version: 10.3.21-MariaDB Source distribution  Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.  Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.  MariaDB [(none)]> use mysql Database changed MariaDB [mysql]> update user set host = '%' where user = 'root'; ERROR 1062 (23000): Duplicate entry '%-root' for key 'PRIMARY' MariaDB [mysql]> select host,user from user; +-----------+------+ | host      | user | +-----------+------+ | %         | root | | 127.0.0.1 | root | | ::1       | root | +-----------+------+ 3 rows in set (0.000 sec)  MariaDB [mysql]> FLUSH PRIVILEGES; Query OK, 0 rows affected (0.001 sec)  MariaDB [mysql]>

其中 host 为 % 表示不限制IP，你也可以设置具体的IP地址，或者网段 192.168.1.% 这样。另外，上面出现的 ERROR 1062 (23000): Duplicate entry '%-root' for key 'PRIMARY' 不予理会，其意思是 host 为主键，不能设置重复的值。所以我们后来的查询中，host 还是3个不同的值。刚刚执行的 update 语句只成功修改了数据库中一条数据。

4、不需要重启服务，即可连接登录。

1万亿元特别国债

Fri, 29 May 2020 02:26:25 GMT

5月22日披露的政府工作报告显示，中国将发行1万亿元（人民币，下同）抗疫特别国债。

作为特殊时期的特殊举措，1万亿元特别国债即将发行的消息迅速登上了微博热搜。

小伙伴们都很关心：特别国债是什么？为什么要发行？怎么发行？老百姓能买吗？是否值得买今天就来和大家说道说道。

01 关于特别国债

这次的特别国债顾名思义：抗疫，就是为了应对新冠肺炎疫情影响，由中央财政统一发行的特殊国债。

发行的原因也很简单：由于疫情影响，财政收入下降，但支出变多，所以需要发行特别国债，弥补资金缺口。

这也是我们国家时隔13年之后，又一次发行特别国债。

02 怎么发行？

虽然目前只是提出了发行的计划，具体的发行方式还没有正式的说明。

但我们可以从历史中两次发行特别国债中找找规律。

历史上我国在1998年和2007年发行过2次特别国债。

第一次是在1998年，中国发行了2700亿元的特别国债，面向中国工商银行、中国农业银行、中国银行和中国建设银行定向发行。

第二次是在2007年，中国发行了1.55万亿元的特别国债采用的是定向发行和公开发行相结合，其中0.2万亿元向社会公众发行。

从之前经验来看，特别国债主要面向各大银行等金融机构进行定向发行，可能会有 少部分针对个人投资者的公开发行，但是额度不会太高，大概率需要去 各大商业银行柜台或者线上系统进行抢购。

但是据我预计：这次大概率是要面向公众开放的。

毕竟这是抗疫特别国债，全国老百姓参与了抗疫的过程，购买抗疫特别国债也是一种爱国主义的表达方式。

如果感兴趣，可以留意下一步发行的具体安排，以及各大银行的官方消息。大概率是能抢购的。

03 利率是多少？

根据历史情况看：1998年发行的特别国债利率为7.2%，介于当年的3年期储蓄国债利率（7.11%）和5年期储蓄国债利率之间（7.86%）。

2007年发行的特别国债利率，利率在4.2%-4.5%之间，当年五年期储蓄国债利率也在4.5%左右。

可以看出，特别国债利率与储蓄国债利率其实差别不大，基本上 特别国债的利率在三年期-五年期国债的利率中间。

当前的储蓄国债有三年期和五年期，三年期的利率为4%，五年期的利率为4.27%，此次发行的一万亿特别国债是10年期的，年化利率大概率会在4%-4.2%的水平。

04 值得购买吗？

一般情况下，值不值得买，就考虑风险、收益率和流动性。

从风险来看，国债是由中央政府发行，信用级别最高，没有什么风险；

就目前国债在二级市场的表现来看，流动性也是很不错的。

从收益来看，国债收益率看起来不是那么高，甚至还不如5年期的国债，但是胜在能锁死利率。

之前我说过利率未来大概率是下行状态，现在能十年锁死4%左右的收益率，还是相当不错的一次理财机会了。

而且此次特别国债还免征利息所得税，外加上历史意义。在我看来还是有较大的吸引力的。

但是还是要提醒大家一句：特别国债不好买！是需要抢购的！！如果没买到也不用着急。

据悉，6月10日将正式开发售今年的第一批储蓄国债，国债买的机会很多，收益、安全性也都差不多。

多看看银行官网（主要是五大行）的消息，买国债还是有希望的。只要是银行官网释放消息，一般各行的网上银行和柜台都是能购买国债的

NAS 篇二：外网访问NAS上面的应用

Sat, 04 Apr 2020 06:49:45 GMT

一，申请公网IP(动态IP)

在北方联通公网IP多一些,在南方电信公网IP多一些

北漂的我自己用的正好是北京联通宽带,当初在咸鱼办理的七百多办理下来五百多.

申请公网IP

一开始跟客服说客服说办理专网才有公网IP,申请失败!(客服可能理解错了,要的不是固定的公网IP,有钱当然随意了)

后又拨打客服沟通说要弄摄像头弄nas,帮转一下技术客服,然后给技术上说,然后四五分钟后重启就好了,

验证公网IP

登录光猫后台查看IP

输入地址 www.ipip.net 查看IP

发现两个IP一致说明公网IP 开通好了,记住那个VLAN ID 3961,我的是北京的是3961 ,地域不一样这个也不一样后面会用到

二 , 光猫桥接

光猫集成了很多功能，身兼数职，除了最基本的光电转换功能外，还集成了路由功能、DHCP服务、NAT、IPTV、WIFI功能等。而光猫的硬件只能满足家庭网络的基本需求，如果将光猫作为家庭网络的中心节点，由于光猫的性能问题，现在基本都是智能家具,笔记本,PC电脑,床头灯手机,天猫精灵,小爱同学,摄像机,智能插座,IPAD等等光设备就十几个,我打游戏时经常460,作为一级宽带运营商不应该出现的问题,一开始购买联通宽带也是这个原因,不像是鹏博士,长城宽带那样二三级运营商

二三级运营商的运营模式大概是这样的比如从1级运营商那里买1000兆宽带,然后往外卖 ,卖的时候宣称是100兆宽带,应该卖给10个人就够了,让每个人最大能达到100兆,假如每个人都用最大能到1000兆,这时候没问题,但是他不会只卖给10个人,他会卖给100个人,如果这个时候里面只有同时10个人上网,那没有问题,每个人都能达到100兆,假如100个人同时上网,平均分配,每个人才会10M,因为总的1000M不变.这也就是为啥晚上的时候你家的网络会慢的原因了!(当然没我说的这么简单,他可能会根据地域,算法去优化这种网络带宽的分配策略)

首先登陆自己的光猫后台

查看自己的光猫的连接宽带的账号密码账号会显示,密码不知道的可以按f12 打开检查

点击弹出框的左上角的鼠标箭头,选中密码,然后把

<input type="password"   修改为 <input type="text"

这样密码就显示出来了记住这个账号

进入管理员模式

用电脑直接通过网线连接光猫,不要经过路由器

我的联通光猫是 ZXHN F477V2

192.168.1.1/hidden_version_switch.gch ，选 default version，密码 CUAdmin
机器自动重启之后就可以进 192.168.1.1/cu.html 了，选管理员账户，密码 CUAdmin
进去之后新建 internet bridge，vlan 选项记得选改 tag，然后在 vlan_id 里填 3961(有的不是3961, 上面说过不知道的看上面)
保存设置之后重启就可以了

另外，如果有问题要恢复初始状态，重新回到 hidden_version_switch.gch 里选 beijing 配置然后在配置页面里输入宽带账号就可以了

不知道的咋弄的联系客服让维修师傅帮你修改一下也可以!

路由器拨号

用电脑连接路由器路由器连接光猫

路由器选择宽带拨号PPPoE

输入前面查看的账号密码,这个时候查看路由器WAN口的IP地址,和之前通过 www.ipip.net 查看的IP地址是否一致,一致就说明可以了!

路由器端口转发

找到转发设置

可以端口转发,也可以DMZ主机,两个区别的是一个是指定端口转发,一个是所有接口转发.我这里因为后面部署好多应用,数据库啥的,我这里选择的是用的DMZ主机

DMZ主机地址填写自己的NAS的内网IP地址就可以了

这个时候直接访问自己的外网地址就可以了!

NAS 篇一：记录下自己的第一台NAS系

Sat, 04 Apr 2020 04:59:10 GMT

购买理由

处于以下考虑我有了人生中的第一台NAS

我之前购买了一台小米家庭云盘,之前是备份照片,离线下载,智能摄像机录像存储用的 ,后来感觉也只能干这些,下载东西需要安装客户端,不能直接对外分享,不支持PC操作,尤其是MAC(公司给配了一台MAC),关键是有两个T的监控级内置硬盘,,和购买内存差不多少了,因为当时是众筹还很便宜, 在一个技术交流群里面有个人要购买,正好卖给他了.用了一年多便宜一百块钱.
我的阿里云服务器太慢了,换了mac笔记本后,之前我一直用的FoxMail邮箱里面的笔记,发现MAC客户端不支持,之前的笔记只能一点点复制出来,索性搭建了一个开源的笔记,发现有个为知笔记(多端支持同步支持makedown语法正式我想要的) 推荐挺好的,搭建好了,太卡了页面打开半天,当然和我服务器有关系.
过去两年内各大硬盘的关停和限速.
可以作为家里的小型服务器使用。
自己心里种草了，自己也是个爱折腾的人，我的人生两大定律 "一切向钱看","活着就要折腾",这是促成这个得主要原因

设备采购

网上搜了一下主要是推荐了三个品牌群晖,威联通,铁威马各有各的特点总结三句话

可玩性推荐群晖
安全性推荐威联通
性价比推荐铁威马

我开始选择了铁威马,购买后发现声音有点大,北京租房的我只能在一个屋里面,虽然我睡眠质量比较好,毕竟还有对象在,体验两天,自费退回去了.后来选择了群辉,比铁威马多了近一千块

系统安装

搞定连上电源、网线，点击开机键。然后打开路由器地址查看终端管理,打开局域网地址，按照提示下一步下一步，设置好内容就可以了，十分钟左右就结束。安装完毕进入系统界面.

软件安装

我们买NAS的最主要需求：

1.文件云存储、云备份

2.照片云管理

3.影音文件云管理

4.云笔记

5.远程下载

6.其他高阶应用

linux上安装Docker(非常简单的安装方法)

Wed, 25 Mar 2020 15:42:09 GMT

Docker的三大核心概念：镜像、容器、仓库

镜像：类似虚拟机的镜像、用俗话说就是安装文件。

容器：类似一个轻量级的沙箱，容器是从镜像创建应用运行实例，

可以将其启动、开始、停止、删除、而这些容器都是相互隔离、互不可见的。

仓库：类似代码仓库，是Docker集中存放镜像文件的场所。

简单介绍一下在CentOS上安装Docker。前置条件：

64-bit 系统  kernel 3.10+

1.检查内核版本，返回的值大于3.10即可。

$ uname -r

2.使用 sudo 或 root 权限的用户登入终端。

3.确保yum是最新的

  $ yum update

4.添加 yum 仓库

tee /etc/yum.repos.d/docker.repo <<-'EOF' [dockerrepo] name=Docker Repository baseurl=https://yum.dockerproject.org/repo/main/centos/$releasever/ enabled=1 gpgcheck=1 gpgkey=https://yum.dockerproject.org/gpg EOF

5.安装 Docker

[root@maruifu ~]# yum install -y docker-engine

安装成功后，使用docker version命令查看是否安装成功，安装成功后------如下

[root@maruifu ~]# docker version Client:  Version:      17.05.0-ce  API version:  1.29  Go version:   go1.7.5  Git commit:   89658be  Built:        Thu May  4 22:06:25 2017  OS/Arch:      linux/amd64 Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?

6.启动docker

  $systemctl start docker.service

7.验证安装是否成功(有client和service两部分表示docker安装启动都成功了)

使用docker version命令查看

[root@maruifu ~]# docker version Client:  Version:      17.05.0-ce  API version:  1.29  Go version:   go1.7.5  Git commit:   89658be  Built:        Thu May  4 22:06:25 2017  OS/Arch:      linux/amd64  Server:  Version:      17.05.0-ce  API version:  1.29 (minimum version 1.12)  Go version:   go1.7.5  Git commit:   89658be  Built:        Thu May  4 22:06:25 2017  OS/Arch:      linux/amd64  Experimental: false

8.设置开机自启动

 $ sudo systemctl enable docker

到此为止docker就完全安装好了。

从 Windows 过度到 Mac 必备快捷键对照表

Sat, 21 Mar 2020 10:58:27 GMT

换MAC了,好多不习惯,特意整理了一下与Windows快捷键的区别!

-----------------来自小马哥的故事

Mac 键盘符号

图标	介绍
⌘	`Command`
⇧	`Shift`
⇪	`Caps Lock`
⌥	`Option` = `Alt`
⌃	`Control`
↩	`Enter`
⌫	`Delete`
⌦	`Fn` + `Delete`
↑	`上箭头`
↓	`下箭头`
←	`左箭头`
→	`右箭头`
⇞	`Fn` + `↑` = `Page Up`
⇟	`Fn` + `↓` = `Page Down`
Home	`Fn` + `←`
End	`Fn` + `→`
⇥	`Tab` = `右制表符`
⇤	`Shift + Tab` = `左制表符`
⎋	`Esc` = `Escape`
⏏	`电源开关键`

Alt

Win 快捷键	Mac 快捷键	介绍
`Alt` + `	`Control` + `V`	显示版本控制常用操作菜单弹出层
`Alt` + `F1`	`Option` + `F1`	显示当前文件选择目标弹出层，弹出层中有很多目标可以进行选择
`Alt` + `F7`	`Option` + `F7`	查询所选对象/变量被引用
`Alt` + `Enter`	`Option` + `Enter`	IntelliJ IDEA 根据光标所在问题，提供快速修复选择，光标放在的位置不同提示的结果也不同
`Alt` + `Insert`	`Command` + `N`	代码自动生成，如生成对象的 set / get 方法，构造函数，toString() 等
`Alt` + `左方向键`	`Control` + `左方向键`	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换
`Alt` + `右方向键`	`Control` + `右方向键`	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换
`Alt` + `前方向键`	`Control` + `前方向键`	当前光标跳转到当前文件的前一个方法名位置
`Alt` + `后方向键`	`Control` + `后方向键`	当前光标跳转到当前文件的后一个方法名位置
`Alt` + `1,2,3...9`	`Command` + `1,2,3...9`	显示对应数值的选项卡，其中 1 是 Project 用得最多

Ctrl

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `F`	`Command` + `F`	在当前文件进行文本查找
`Ctrl` + `R`	`Command` + `R`	在当前文件进行文本替换
`Ctrl` + `Z`	`Command` + `Z`	撤销
`Ctrl` + `G`	`Command` + `L`	跳转到指定行数位置
`Ctrl` + `Y`	`Command` + `Delete`	删除光标所在行或删除选中的行
`Ctrl` + `D`	`Command` + `D`	复制光标所在行或复制选择内容，并把复制内容插入光标位置下面
`Ctrl` + `W`	`Option` + `方向键上`	递进式选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展选中范围
`Ctrl` + `E`	`Command` + `E`	显示最近打开的文件记录列表
`Ctrl` + `N`	`Command` + `O`	根据输入的类名查找类文件
`Ctrl` + `J`	`Command` + `J`	插入自定义动态代码模板
`Ctrl` + `P`	`Command` + `P`	方法参数提示显示
`Ctrl` + `Q`	`Control` + `J`	当前位置变量、方法的 Documentation 内容显示
`Ctrl` + `U`	`Command` + `U`	前往当前光标所在的方法的父类的方法 / 接口定义
`Ctrl` + `B`	`Command` + `B`	进入光标所在的方法/变量的接口或是定义处，等效于 `Ctrl + 左键单击`
`Ctrl` + `/`	`Command` + `/`	注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号
`Ctrl` + `F1`	`Command` + `F1`	在光标所在的错误代码处显示错误信息
`Ctrl` + `F11`	`Option` + `F3`	选中文件 / 文件夹，使用助记符设定 / 取消书签
`Ctrl` + `F12`	`Command` + `F12`	弹出当前文件结构层，可以在弹出的层上直接输入，进行筛选
`Ctrl` + `Space`	`Control` + `Space`	基础代码补全，默认在 Windows 系统上被输入法占用，需要进行修改，建议修改为 `Ctrl + 逗号`
`Ctrl` + `Delete`	`Option` + `Fn`+ `Delete`	删除光标后面的单词或是中文句
`Ctrl` + `BackSpace`	`Option` + `Delete`	删除光标前面的单词或是中文句
`Ctrl` + `1,2,3...9`	`Control` + `1,2,3...9`	定位到对应数值的书签位置
`Ctrl` + `加号`	`Command` + `加号`	展开代码
`Ctrl` + `减号`	`Command` + `减号`	折叠代码
`Ctrl` + `左键单击`	`Control` + `左键单击`	在打开的文件标题上，弹出该文件路径
`Ctrl` + `左方向键`	`Option` + `左方向键`	光标跳转到当前单词 / 中文句的左侧开头位置
`Ctrl` + `右方向键`	`Option` + `右方向键`	光标跳转到当前单词 / 中文句的右侧开头位置
`Ctrl` + `前方向键`	预设中没有该快捷键	等效于鼠标滚轮向前效果
`Ctrl` + `后方向键`	预设中没有该快捷键	等效于鼠标滚轮向后效果

Shift

Win 快捷键	Mac 快捷键	介绍
`Shift` + `F11`	`Command + F3`	弹出书签显示层
`Shift` + `Tab`	`Shift + Tab`	取消缩进
`Shift` + `Enter`	`Shift + Enter`	开始新一行。光标所在行下空出一行，光标定位到新行位置
`Shift` + `左键单击`	`Shift + 左键单击`	在打开的文件名上按此快捷键，可以关闭当前打开文件

Alt + Shift

Win 快捷键	Mac 快捷键	介绍
`Alt` + `Shift` + `N`	`Option` + `Shift` + `N`	选择 / 添加 task
`Alt` + `Shift` + `左键双击`	`Option` + `Shift` + `左键双击`	选择被双击的单词 / 中文句，按住不放，可以同时选择其他单词 / 中文句
`Alt` + `Shift` + `前方向键`	`Option` + `Shift` + `前方向键`	移动光标所在行向上移动
`Alt` + `Shift` + `后方向键`	`Option` + `Shift` + `后方向键`	移动光标所在行向下移动

Ctrl + Alt

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `Alt` + `L`	`Command` + `Option` + `L`	格式化代码，可以对当前文件和整个包目录使用
`Ctrl` + `Alt` + `O`	`Control` + `Option` + `O`	优化导入的类，可以对当前文件和整个包目录使用
`Ctrl` + `Alt` + `T`	`Command` + `Option` + `T`	对选中的代码弹出环绕选项弹出层
`Ctrl` + `Alt` + `S`	`Command` + `逗号`	打开 IntelliJ IDEA 系统设置
`Ctrl` + `Alt` + `Enter`	`Command` + `Option` + `Enter`	光标所在行上空出一行，光标定位到新行
`Ctrl` + `Alt` + `左方向键`	`Command` + `Option` + `左方向键`	退回到上一个操作的地方
`Ctrl` + `Alt` + `右方向键`	`Command` + `Option` + `右方向键`	前进到上一个操作的地方

Ctrl + Shift

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `Shift` + `F`	`Command` + `Shift` + `F`	根据输入内容查找整个项目或指定目录内文件
`Ctrl` + `Shift` + `R`	`Command` + `Shift` + `R`	根据输入内容替换对应内容，范围为整个项目或指定目录内文件
`Ctrl` + `Shift` + `J`	`Control` + `Shift` + `J`	自动将下一行合并到当前行末尾
`Ctrl` + `Shift` + `Z`	`Command` + `Shift` + `Z`	取消撤销
`Ctrl` + `Shift` + `W`	`Option` + `方向键下`	递进式取消选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展取消选中范围
`Ctrl` + `Shift` + `N`	`Command` + `Shift` + `O`	通过文件名定位 / 打开文件 / 目录，打开目录需要在输入的内容后面多加一个正斜杠
`Ctrl` + `Shift` + `U`	`Command` + `Shift` + `U`	对选中的代码进行大 / 小写轮流转换
`Ctrl` + `Shift` + `T`	`Command` + `Shift` + `T`	对当前类生成单元测试类，如果已经存在的单元测试类则可以进行选择
`Ctrl` + `Shift` + `C`	`Command` + `Shift` + `C`	复制当前文件磁盘路径到剪贴板
`Ctrl` + `Shift` + `B`	`Control` + `Shift` + `B`	跳转到类型声明处
`Ctrl` + `Shift` + `/`	`Command` + `Option` + `/`	代码块注释
`Ctrl` + `Shift` + `[`	`Command` + `Shift` + `[`	选中从光标所在位置到它的顶部中括号位置
`Ctrl` + `Shift` + `]`	`Command` + `Shift` + `]`	选中从光标所在位置到它的底部中括号位置
`Ctrl` + `Shift` + `加号`	`Command` + `Shift` + `加号`	展开所有代码
`Ctrl` + `Shift` + `减号`	`Command` + `Shift` + `减号`	折叠所有代码
`Ctrl` + `Shift` + `F7`	`Command` + `Shift` + `F7`	高亮显示所有该选中文本，按Esc高亮消失
`Ctrl` + `Shift` + `F12`	`Command` + `Shift` + `F12`	编辑器最大化
`Ctrl` + `Shift` + `Enter`	`Command` + `Shift` + `Enter`	自动结束代码，行末自动添加分号
`Ctrl` + `Shift` + `Backspace`	`Ctrl` + `Shift` + `Backspace`	退回到上次修改的地方
`Ctrl` + `Shift` + `1,2,3...9`	`Control` + `Shift` + `1,2,3...9`	快速添加指定数值的书签
`Ctrl` + `Shift` + `左键单击`	`Command` + `Shift` + `左键单击`	把光标放在某个类变量上，按此快捷键可以直接定位到该类中
`Ctrl` + `Shift` + `左方向键`	`Option` + `Shift` + `左方向键`	在代码文件上，光标跳转到当前单词 / 中文句的左侧开头位置，同时选中该单词 / 中文句
`Ctrl` + `Shift` + `右方向键`	`Option` + `Shift` + `右方向键`	在代码文件上，光标跳转到当前单词 / 中文句的右侧开头位置，同时选中该单词 / 中文句
`Ctrl` + `Shift` + `前方向键`	`Command` + `Shift` + `前方向键`	光标放在方法名上，将方法移动到上一个方法前面，调整方法排序
`Ctrl` + `Shift` + `后方向键`	`Command` + `Shift` + `后方向键`	光标放在方法名上，将方法移动到下一个方法前面，调整方法排序

Ctrl + Shift + Alt

Win 快捷键	Mac 快捷键	介绍
`Ctrl` + `Shift` + `Alt` + `V`	`Command` + `Shift` + `Option` + `V`	无格式黏贴
`Ctrl` + `Shift` + `Alt` + `S`	`Command` + `;`	打开当前项目设置

Other

Win 快捷键	Mac 快捷键	介绍
`F2`	`F2`	跳转到下一个高亮错误或警告位置
`F4`	`F4`	编辑源
`F11`	`F3`	添加书签
`F12`	`F12`	回到前一个工具窗口
`Tab`	`Tab`	缩进
`ESC`	`ESC`	从工具窗口进入代码文件窗口

【HTML打印】HTML直接调用window下的打印机并执行打印任务（简单打印任务生成）

Sun, 15 Mar 2020 07:35:41 GMT

今天有个朋友问我咋调用打印机,打印页面。

-----------------来自小马哥的故事

<!DOCTYPE html> <html lang="en"> <head>     <meta charset="UTF-8">     <meta name="viewport" content="width=device-width, initial-scale=1.0">     <meta http-equiv="X-UA-Compatible" content="ie=edge">     <link rel="stylesheet" href="css/page/index.css">     <title>window调用打印接口</title>     <style>         #pr{width:100px;height:40px;line-height:40px;text-align:center;background:#ccc;}         .box{width:600px; }     </style> </head> <body>     <div class="box">        <p>  <table style="width:100%;" cellpadding="2" cellspacing="0" border="1" bordercolor="#000000">   <tbody>    <tr>     <td colspan="6" style="text-align:center;">      物资出库信息     </td>    </tr>    <tr>     <td style="text-align:center;">      领料单号     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      <span>申请时间</span><br />     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      领料库房     </td>     <td style="text-align:center;">      <br />     </td>    </tr>    <tr>     <td style="text-align:center;">      <span>领料部门</span><br />     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      车辆编号     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      <br />     </td>    </tr>    <tr>     <td style="text-align:center;">      领料人     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      库管员     </td>     <td style="text-align:center;">      <br />     </td>     <td style="text-align:center;">      出库时间     </td>     <td style="text-align:center;">      <br />     </td>    </tr>    <tr>     <td colspan="6" style="text-align:center;">      备注     </td>    </tr>    <tr>     <td style="text-align:center;">      物质编号     </td>     <td style="text-align:center;">      <span>物质名称</span><br />     </td>     <td style="text-align:center;">      计量单位     </td>     <td style="text-align:center;">      物资单     </td>     <td>      <br />     </td>     <td>      <br />     </td>    </tr>    <tr>     <td>      <br />     </td>     <td>      <br />     </td>     <td>      <br />     </td>     <td>      <br />     </td>     <td>      <br />     </td>     <td>      <br />     </td>    </tr>   </tbody>  </table> </p>     </div>     <div id="pr">点击打印</div> </body> </html> <script>     function $(selector){         return document.querySelector(selector);     }     //获取整个页面     $("#pr").onclick =function(){         window.print();     }       /* 实现打印全部页面（也可以打印局部页面 - 看需求） ----         我是只打印baby里边的内容        获取我们定义的id     */     $("#pr").onclick =function(){         var oldHtml = $("body").innerHTML;          var printbox = $(".box").innerHTML;         $("body").innerHTML = printbox;         window.print();         $("body").innerHTML = oldHtml;       } </script>

我的博客即将同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=182do5sqcmvp7

mysql 替换字段部分内容

Sun, 01 Mar 2020 06:01:19 GMT

[mysql]replace的用法（替换某字段部分内容） [mysql]replace的用法

1.replace into replace into table (id,name) values('1','aa'),('2','bb') 此语句的作用是向表table中插入两条记录。如果主键id为1或2不存在就相当于 insert into table (id,name) values('1','aa'),('2','bb') 如果存在相同的值则不会插入数据

2.replace(object,search,replace) 把object中出现search的全部替换为replace select replace('www.163.com','w','Ww')--->WwWwWw.163.com 例：把表table中的name字段中的aa替换为bb update table set name=replace(name,'aa','bb')

3.UPDATE更新一个字段中的的部分内容

现在有一条记录的字段是“abcdefg",现在我只想将该字段中的c改为C，update语句应该怎么写

update 表名 set 字段1 = replace(字段1,'c','C')

msyql全局搜索字段所在位置

Sun, 01 Mar 2020 06:00:40 GMT

全局搜索字段所在位置

 SELECT COLUMN_NAME,TABLE_SCHEMA,TABLE_NAME FROM information_schema.COLUMNS WHERE COLUMN_NAME='字段名字' +---------------+--------------+---------------+ | COLUMN_NAME   | TABLE_SCHEMA | TABLE_NAME    | +---------------+--------------+---------------+ | contacts_name | dxxxf_v3    | fledts        | | contacts_name | dxxxf_v3    | losdftions     | | contacts_name | dxxxf_v3    | orgafsizatsdons | | contacts_name | pxxnf      | afdts        | | contacts_name | sxxmens     | lafions     | | contacts_name | pxxmedfs     | sgdszations | +---------------+--------------+---------------+ ————————————————

Linux 服务器上如何通过 Shell 脚本一键部署 SpringBoot 应用

Mon, 25 Nov 2019 15:58:00 GMT

Linux 服务器上如何通过 Shell 脚本一键部署 SpringBoot 应用

springboot 是默认集成Tomcat容器的，将项目打包成jar包库、使用Java直接启动jar包（非spring boot也可以）

首先需要在服务器端安装jdk、maven、git

点我看maven安装教程点我看git安装教程

想要SpringBoot项目使用maven打包成jar包需先在项目中的pom添加build插件,代码如下

 <build>         <plugins>             <plugin>                 <artifactId>maven-dependency-plugin</artifactId>                 <configuration>                     <outputDirectory>${project.build.directory}/libs</outputDirectory>                     <excludeTransitive>false</excludeTransitive>                     <stripVersion>false</stripVersion>                     <includeScope>compile</includeScope>                     <!--<includeScope>runtime</includeScope>-->                 </configuration>                 <executions>                     <execution>                         <id>copy-dependencies</id>                         <phase>package</phase>                         <goals>                             <goal>copy-dependencies</goal>                         </goals>                         <configuration>                             <!-- <outputDirectory>libs</outputDirectory> -->                             <excludeTransitive>false</excludeTransitive>                             <stripVersion>true</stripVersion>                         </configuration>                     </execution>                 </executions>             </plugin>         </plugins>          </build>

此插件是指将项目所依赖的jar，打包的时候打包到libs目录下，一遍到时候编写shell脚本读取依赖的jar

接下来就可以编写shell脚本了（get源码的方式有很多种，直接上传上去也行。本文将使用Git在服务器端直接拉取源码，编译打包，启动）

主要修改 proc ,SOURCE_HOME,APP_LOG,PROFILES_ACTIVE 文件就好!

 #打包完后的jar名称，替换成你自己项目的名称，该名称可以在maven项目的pom中配置 proc="wechat" #项目源码的目录地址（初始可能需要自己从Git拉下来） SOURCE_HOME="/usr/local/publicwx/publicWechat" #日志地址 APP_LOG="$SOURCE_HOME/target/catalina.base_IS_UNDEFINED/logs/log_info.log"  #环境配置 用户配置开发(dev)，测试(test)，生产(prod)的配置文件，避免频繁改动 PROFILES_ACTIVE="spring.profiles.active=dev"   #JVM启动参数，关于JVM调优这里不介绍，感兴趣的可以自行百度 JVM调优 JAVA_OPTS="-server -Xms512M -Xmx512M -Xss256k -Xmn256m -XX:SurvivorRatio=4 -XX:+AggressiveOpts -XX:+UseBiasedLocking -XX:MetaspaceSize=128M -XX:MaxMetaspaceSize=256M  -XX:CMSInitiatingOccupancyFraction=90 -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:+DisableExplicitGC -XX:MaxTenuringThreshold=0 -XX:CMSFullGCsBeforeCompaction=100 -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -XX:LargePageSizeInBytes=128m -XX:+UseFastAccessorMethods -XX:+UseCMSInitiatingOccupancyOnly -Djava.awt.headless=true"  psid=0  #检查进程是否存在 checkpid() {    javaps=$(pgrep -f "$proc")    if [ -n "$javaps" ]; then       psid=$javaps    else       psid=0    fi }   #编写启动方法 start() {    checkpid     if [ $psid -ne 0 ]; then       echo "================================"       echo "warn: $proc already started! (pid=$psid)"       echo "================================"    else       echo "Starting $proc ..."    #到项目源码目录       cd $SOURCE_HOME    #输出，准备获取最新代码       echo -n "git pull source ,please wait ....."    #获取最新代码，此列只在目录所在分支pull       #若想部署指定分支代码，可以在脚本调用参数中添加一个变量，用git checkout ${targer_branch}       git pull               #输出，最新代码已拉取完毕，准备打包       echo -n "mvn package source ,please wait ....."               #maven打包命令，此处特别注意是 —U ,是指引用快照版本的jar（引用自己的项目）每次都更新最新的。       mvn clean package -Dmaven.test.skip=true       #打包成功后默认是在启动项目的target目录下。       cd target       #输出，准备启动       echo -n $"Starting $proc:"               #循环加载所需的jar，此处和2的pom配置有关       for name in *.jar       do         APP_CLASS="$name"       done               #启动脚本，--spring.profiles.active=   用于设置环境所使用的配置文件       JAVA_CMD="java "$JAVA_OPTS" -jar "$APP_CLASS" --"$PROFILES_ACTIVE" &"       #后台运行               $JAVA_CMD &       sleep 1       checkpid       if [ $psid -ne 0 ]; then       echo "======================================"          echo "$proc Start Success! (pid=$psid)[OK]"          echo "======================================"       else          echo "[Failed]"       fi    fi  }   #查看日志 showlog() {    tail -f $APP_LOG }    #停用项目 stop() {    checkpid     if [ $psid -ne 0 ]; then       echo -n "Stopping $proc ...(pid=$psid) "       kill -9 $psid        if [ $? -eq 0 ]; then          echo "[OK]"       else          echo "[Failed]"       fi            checkpid       if [ $psid -ne 0 ]; then          stop       fi    else       echo "================================"       echo "warn: $proc is not running"       echo "================================"    fi }   #项目状态 status() {    checkpid    if [ $psid -ne 0 ];  then       echo "$proc is running! (pid=$psid)"    else       echo "$proc is not running"    fi }   #设置脚本参数，启动的时候可以采用./脚本名称.sh start/stop/restart/log/status等参数 case "$1" in   start)     start     ;;   stop)     stop     ;;   log)     showlog     ;;   status)     status     ;;   restart)     stop     start     ;; esac

centos7 安装 mysql 详解

Sat, 23 Nov 2019 11:31:43 GMT

查看linux系统版本

[root@maruifu ~]# cat /etc/redhat-release   查看操作系统版本 CentOS Linux release 7.6.1810 (Core)  [root@maruifu ~]# uname -r      查看系统内核版本 3.10.0-957.21.3.el7.x86_64

下载

下载地址 : https://dev.mysql.com/downloads/mysql/

centos7 选择 Red Hat Enterprise Linux / Oracle Linux

版本就自己根据自己系统下载就好了

可以选择 RPM Bundle 使用wget 下载 mysql-5.7.28-1.el7.x86_64.rpm-bundle.tar

[root@nfs_client ~]# wget https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.28-1.el7.x86_64.rpm-bundle.tar

也可以细化下载，下载须要的mysql组件，有4个：分别是 server、client、common、libs

卸载旧版本的MySql （没有的话，则跳过此步骤）

1、查看旧版本MySql rpm -qa | grep mysql 将会列出旧版本MySql的组件列表，如：

[root@maruifu ~]#  rpm -qa | grep mysql mysql-community-libs-5.7.28-1.el7.x86_64 mysql-community-server-5.7.28-1.el7.x86_64 mysql-community-common-5.7.28-1.el7.x86_64 mysql-community-client-5.7.28-1.el7.x86_64

2、逐个删除掉旧的组件使用命令rpm -e --nodeps {-file-name}进行移除操作，移除的时候可能会有依赖，要注意一定的顺序。

rpm -e --nodeps mysql-community-libs-5.7.28-1.el7.x86_64

安装

解压

[root@maruifu tools]# pwd /usr/local/tools [root@maruifu tools]# tar xvf mysql-5.7.28-1.el7.x86_64.rpm-bundle.tar

卸载

centos7自带的mariadb-lib

[root@maruifu tools]# rpm -qa|grep mariadb
mariadb-libs-5.5.56-2.el7.x86_64
[root@maruifu tools]# rpm -e mariadb-libs-5.5.56-2.el7.x86_64 --nodeps

安装

这里我们只安装mysql-server服务，只需要安装如下4个软件包即可，

使用命令rpm -ivh {-file-name}进行安装操作。

**注：ivh中， i-install安装；v-verbose进度条；h-hash哈希校验**

按照依赖关系依次安装rpm包依赖关系依次为common→libs→client→server

1.  rpm -ivh  mysql-community-common-5.7.28-1.el7.x86_64.rpm 2.  rpm -ivh  mysql-community-libs-5.7.28-1.el7.x86_64.rpm 3.  rpm -ivh  mysql-community-client-5.7.28-1.el7.x86_64.rpm 4.  rpm -ivh  mysql-community-server-5.7.28-1.el7.x86_64.rpm

特殊情况1

在阿里云ECS云服务器上安装mysql5.7，当安装 mysql-community-server-5.7.28-1.el7.x86_64.rpm 时报错，报错如下

[root@maruifu ~]# rpm -ivh mysql-community-server-5.7.28-1.el7.x86_64.rpm warning: mysql-community-server-5.7.28-1.el7.x86_64.rpm: Header V3 DSA/SHA1 Signature, key ID 5072e1f5: NOKEY error: Failed dependencies:         libaio.so.1()(64bit) is needed by mysql-community-server-5.7.28-1.el7.x86_64         libaio.so.1(LIBAIO_0.1)(64bit) is needed by mysql-community-server-5.7.28-1.el7.x86_64         libaio.so.1(LIBAIO_0.4)(64bit) is needed by mysql-community-server-5.7.28-1.el7.x86_64

解决法案就是：安装libaio

[root@maruifu ~]# yum -y install libaio

安装libaio后，再重新安装一次mysql-community-server-5.7.28-1.el7.x86_64.rpm，此时就能正常安装了

特殊情况2

比如解决了“特殊情况1”，但在启动mysql的时候，启动不起来，或启动后，去查找临时密码，使用命令没反应。查看日志mysqld.log(可在/etc/my.cnf中查找到mysqld.log的配置位置)，报如下错误，此时怎么解决？

[ERROR] Fatal error: Can't open and lock privilege tables: Table 'mysql.user' doesn't exist

1>先通过rpm -e --nodeps xxx 卸载掉server，卸载后删除datadir目录，

2>卸载后查看 /etc/my.cnf 中，datadir的配置情况，将datedir目录删除，

3>最后通过命令rpm -ivh xxx 重新安装server,此时就能正常使用mysql了

命令代码如下：

[root@maruifu ~]# rpm -e --nodeps mysql-community-server-5.7.22-1.el7.x86_64  [root@maruifu ~]# cat /etc/my.cnf  datadir=/var/lib/mysql socket=/var/lib/mysql/mysql.sock   [root@maruifu ~]# cd /var/lib [root@maruifu lib]# rm -rf mysql [root@maruifu ~]# rpm -ivh mysql-community-server-5.7.22-1.el7.x86_64.rpm [root@maruifu ~]# systemctl start mysqld.service [root@maruifu ~]# ps -ef|grep mysql mysql    21001     1  0 Nov22 ?        00:00:00 /usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid root     22218 20782  0 00:21 pts/1    00:00:00 grep --color=auto mysql root     24317 31119  0 Nov21 pts/0    00:00:00 mysql -u root -p

登录并创建MySql密码

启动MySql

安装完后，使用命令 service mysqld start 或 systemctl start mysqld.service 启动MySQL服务。（如果mysql服务无法启动，就重启一下系统）

systemctl start mysqld.service    启动mysql systemctl status mysqld.service  查看mysql状态 systemctl stop mysqld.service   关闭mysql  查看mysql进程 ps -ef|grep mysql 查看3306端口 netstat -anop|grep 3306

登陆mysql修改root密码

由于MySQL5.7.4之前的版本中默认是没有密码的，登录后直接回车就可以进入数据库，进而进行设置密码等操作。其后版本对密码等安全相关操作进行了一些改变，在安装过程中，会在安装日志中生成一个临时密码。

怎么找到这个临时密码呢？

grep 'temporary password' /var/log/mysqld.log

[root@maruifu ~]# grep 'temporary password' /var/log/mysqld.log 2019-11-21T08:07:27.278434Z 1 [Note] A temporary password is generated for root@localhost: rj3pj;g3XWIh

rj3pj;g3XWIh即为登录密码。使用这个随机密码登录进去，然后修改密码，使用命令：

mysql -uroot -p

执行下面的命令修改MySql root密码

set password for root@localhost=password('12345678');

在5.6后,mysql内置密码增强机制,低强度密码会报错:

ERROR 1819 (HY000): Your password does not satisfy the current policy requirements

更改策略，设置 validate_password_policy=0;

mysql> set global validate_password_length=1; Query OK, 0 rows affected (0.00 sec)

修改密码

1. mysql> set password for root@localhost=password('TianTianIT12345'); 2. Query OK, 0 rows affected, 1 warning (0.00 sec)

此时，虽然防火墙我时关着的，但root用户只能用于本机访问，不能用于远程访问，否则会报以下错误。因此，接下来要做的是授予root用户远程访问权限。

查看当前授予过的权限：

use mysql; select user,host from user;

mysql> use mysql; Reading table information for completion of table and column names You can turn off this feature to get a quicker startup with -A   Database changed mysql> select user,host from user; +---------------+-----------+ | user          | host      | +---------------+-----------+ | root          | %         | | mysql.session | localhost | | mysql.sys     | localhost | | root          | localhost | +---------------+-----------+ 4 rows in set (0.00 sec)   mysql> show grants; +---------------------------------------------------------------------+ | Grants for root@localhost                                           | +---------------------------------------------------------------------+ | GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION | | GRANT PROXY ON ''@'' TO 'root'@'localhost' WITH GRANT OPTION        | +---------------------------------------------------------------------+ 2 rows in set (0.00 sec)

授予root用户远程访问权限：

mysql> grant all privileges on *.* to root@'%' identified by 'TianTianIT12345'; Query OK, 0 rows affected, 1 warning (0.05 sec)

刷新权限，使设置生效， OK。

mysql> flush privileges; Query OK, 0 rows affected (0.36 sec)

linux 中nginx 的安装

Wed, 20 Nov 2019 16:33:00 GMT

linux 中nginx 的安装

##序言

Nginx是lgor Sysoev为俄罗斯访问量第二的rambler.ru站点设计开发的。从2004年发布至今，凭借开源的力量，已经接近成熟与完善。

Nginx功能丰富，可作为HTTP服务器，也可作为反向代理服务器，邮件服务器。支持FastCGI、SSL、Virtual Host、URL Rewrite、Gzip等功能。并且支持很多第三方的模块扩展。

Nginx的稳定性、功能集、示例配置文件和低系统资源的消耗让他后来居上，在全球活跃的网站中有12.18%的使用比率，大约为2220万个网站。

牛逼吹的差不多啦，如果你还不过瘾，你可以百度百科或者一些书上找到这样的夸耀，比比皆是。

Nginx常用功能

1、Http代理，反向代理：作为web服务器最常用的功能之一，尤其是反向代理。

Nginx在做反向代理时，提供性能稳定，并且能够提供配置灵活的转发功能。Nginx可以根据不同的正则匹配，采取不同的转发策略，比如图片文件结尾的走文件服务器，动态页面走web服务器，只要你正则写的没问题，又有相对应的服务器解决方案，你就可以随心所欲的玩。并且Nginx对返回结果进行错误页跳转，异常判断等。如果被分发的服务器存在异常，他可以将请求重新转发给另外一台服务器，然后自动去除异常服务器。

2、负载均衡

Nginx提供的负载均衡策略有2种：内置策略和扩展策略。内置策略为轮询，加权轮询，Ip hash。扩展策略，就天马行空，只有你想不到的没有他做不到的啦，你可以参照所有的负载均衡算法，给他一一找出来做下实现。上3个图，理解这三种负载均衡算法的实现

3、web缓存

Nginx可以对不同的文件做不同的缓存处理，配置灵活，并且支持FastCGI_Cache，主要用于对FastCGI的动态程序进行缓存。配合着第三方的ngx_cache_purge，对制定的URL缓存内容可以的进行增删管理。

4、Nginx相关地址

源码：https://trac.nginx.org/nginx/browser

官网：http://www.nginx.org/

Nginx安装

安装依赖库

安装gcc模块，安装Nginx前，必须先确保安装了gcc环境。那么何为gcc?它是 Linux 下默认的 C/C++ 编译器，大部分 Linux 发行版中都是默认安装的。命令行输入gcc -v，如果显示命令未找到或command not found，则代表没有安装gcc，需要安装上。
```
yum install gcc-c++  
```
安装prce模块: PCRE(Perl Compatible Regular Expressions)是一个Perl库，包括 perl 兼容的正则表达式库。nginx的http模块使用pcre来解析正则表达式，所以需要在linux上安装pcre库。地址 : http://www.pcre.org/

//下载`wget  https://ftp.pcre.org/pub/pcre/pcre-8.37.tar.gz  //解压 tar -zxvf pcre-8.37.tar.gz  //然后,进入包，配置： ./configure  //安装 make && make install

安装openssl模块,OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。 nginx不仅支持http协议，还支持https（即在ssl协议上传输http），所以需要在linux安装openssl库。地址: http://www.openssl.org/

//下载  wget https://www.openssl.org/source/openssl-1.1.0e.tar.gz   // 解压  tar -zxvf openssl-1.1.0e.tar.gz   //然后,进入包，配置： ./configure  //安装 make && make install

安装gzip 模块, zlib库提供了很多种压缩和解压缩的方式，nginx使用zlib对http包的内容进行gzip，所以需要在linux上安装zlib库。地址 http://www.zlib.net/

//下载 wget http://prdownloads.sourceforge.net/libpng/zlib-1.2.11.tar.gz?download   //解压 tar -zxvf zlib-1.2.11.tar.gz?download   // 然后,进入包，配置： ./configure  //安装 make && make install

也可以 yum安装

yum install -y pcre pcre-devel  yum install -y openssl openssl-devel  yum install -y zlib zlib-devel

安装Nginx并启动

//创建一个文件夹

cd /usr/local/ mkdir server cd server/ //下载 :  wget http://nginx.org/download/nginx-1.7.8.tar.gz //解压 tar -xvf nginx-1.7.8.tar.gz //创建目录 mkdir nginx //>>安装一个第三方模块,可以打印输出一些东西，一般用于调试nginx的参数时使用(也可以不安装) //>>创建一个模块目录 用于放第三方模块 mkdir nginx-module //>>进入目录: cd nginx-module //>>下载: wget https://github.com/openresty/echo-nginx-module/archive/v0.60.tar.gz //>>解压: tar zxvf v0.60.tar.gz echo-nginx-module-0.60  //进入安装目录 cd nginx-1.7.8 //配置 ./configure --prefix=/usr/local/server/nginx --add-module=/usr/local/server/nginx-module/echo-nginx-module-0.60 --with-debug  源码的安装一般由有这三个步骤：配置(configure)、编译(make)、安装(make install) 一般在编译前加上一句： ./configure --prefix=/xxx/xxx 其中–prefix选项就是配置安装的路径，如果不配置该选项，安装后可执行文件默认放在/usr/local/bin，库文件默认放在/usr/local/lib，配置文件默认放在/usr/local/etc，其它的资源文件放在/usr/local/share，比较分散。 为了便于集中管理某个软件的各种文件，可以配置–prefix，如： ./configure --prefix=/usr/local/server/nginx --with-http_stub_status_module --with-http_ssl_module 可以把所有资源文件放在/usr/local/server/nginx的路径中，就不会分散了。 // 编译安装 make && make install //进入启动目录 cd .. cd nginx/sbin/ //启动 ./nginx //这个时候可以访问本机IP了

配置Nginx

打开配置文件 vi /usr/local/nginx/conf/nginx.conf

配置文件

 user  root; worker_processes  auto; error_log  logs/error.log  warn; pid        logs/nwarn.pid;  events {     worker_connections  1024; }  http {     include       mime.types;     default_type  application/octet-stream;      log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '                       '$status $body_bytes_sent "$http_referer" '                       '"$http_user_agent" "$http_x_forwarded_for"';     access_log  logs/access.log  main;     sendfile        on;     tcp_nopush          on;     tcp_nodelay         on;     keepalive_timeout   65;     types_hash_max_size 2048;     client_max_body_size 20m;     client_body_buffer_size 20m;     gzip on;                     #开启gzip压缩功能     gzip_min_length 10k;         #设置允许压缩的页面最小字节数; 这里表示如果文件小于10个字节，就不用压缩，因为没有意义，本来就很小.     gzip_buffers 4 16k;          #设置压缩缓冲区大小，此处设置为4个16K内存作为压缩结果流缓存     gzip_http_version 1.1;       #压缩版本     gzip_comp_level 1;           #设置压缩比率，最小为1，处理速度快，传输速度慢；9为最大压缩比，处理速度慢，传输速度快; 这里表示压缩级别，可以是0到9中的任一个，级别越高，压缩就越小，节省了带宽资源，但同时也消耗CPU资源，所以一般折中为6     gzip_types text/plain text/css application/javascript text/javascript;      #制定压缩的类型,线上配置时尽可能配置多的压缩类型!     gzip_vary on;    #选择支持vary header；改选项可以让前端的缓存服务器缓存经过gzip压缩的页面; 这个可以不写，表示在传送数据时，给客户端说明我使用了gzip压缩i     include /usr/local/server/nginx/conf/conf.d/*.conf;   }

Nginx 常用命令

nginx -s reload            # 重新载入配置文件 nginx -s reopen            # 重启 Nginx nginx -s stop              # 停止 Nginx nginx -t                   # 检查配置文件nginx.conf nginx -s quit              #优雅停止nginx，有连接时会等连接请求完成再杀死worker进程   nginx -v                #查看版本 nginx  -c filename      #指定配置文件 nginx -h                # 查看帮助信息 nginx -s reopen          #重新打开日志文件，一般用于切割日志

Java 服务线上问题排查思路与工具使用

Sat, 31 Aug 2019 15:08:00 GMT

前言

Java 语言是当前互联网应用最为广泛的语言，作为一名 Java 程序猿，当业务相对比较稳定之后平常工作除了 coding 之外，大部分时间（70%~80%）是会用来排查突发或者周期性的线上问题。由于业务应用 bug（本身或引入第三方库）、内外部环境、底层硬件问题等原因，Java线上服务出现故障/问题几乎不可避免。例如，常见的现象包括部分请求超时、用户明显感受到系统发生卡顿等等。

尽管线上问题从系统表象来看非常明显，但排查深究其发生的原因还是比较困难的，因此对开发测试或者是运维的同学产生了许多的困扰。排查定位线上问题是具有一定技巧或者说是经验规律的，排查者如果对业务系统了解得越深入，那么相对来说定位也会容易一些。

不管怎么说，掌握 Java 服务线上问题排查思路并能够熟练排查问题常用工具/命令/平台是每一个 Java 程序猿进阶必须掌握的实战技能。笔者依据自己的工作经验总结出一套基本的线上问题排查流程，同学们可以根据自己的实际工作情况进行归纳总结。

Java 服务常见线上问题

所有 Java 服务的线上问题从系统表象来看归结起来总共有四方面：CPU、内存、磁盘、网络。例如 CPU 使用率峰值突然飚高、内存溢出(泄露)、磁盘满了、网络流量异常、FullGC 等等问题。基于这些现象我们可以将线上问题分成两大类: 系统异常、业务服务异常。

系统异常

常见的系统异常现象包括: CPU 占用率过高、CPU上下文切换频率次数较高、磁盘满了、磁盘 I/O 过于频繁、网络流量异常（连接数过多）、系统可用内存长期处于较低值（导致 oom killer）等等。这些问题可以通过 top（cpu）、free（内存）、df（磁盘）、dstat（网络流量）、pstack、vmstat、strace（底层系统调用）等工具获取系统异常现象数据。

此外，如果对系统以及应用进行排查后，均未发现异常现象的根本原因，那么也有可能是因为外部基础设施 IAAS 平台所引发的问题。例如运营商网络或者云服务提供商偶尔可能也会发生一些故障问题，你的引用只有某个区域如广东用户访问系统时发生服务不可用现象，那么极有可能是这些原因导致的。今天，我司部署在阿里云华东地域的业务系统中午时分突然不能为广东地区用户提供正常服务，对系统进行各种排查均为发现任何问题。最后，通过查询阿里云公告得知原因是"广东地区电信线路访问华东地区互联网资源（包含阿里云华东1地域）出现网络丢包或者延迟增大的异常情况"。

业务服务异常

常见的业务服务异常现象包括: PV 量过高、服务调用耗时异常、线程死锁、多线程并发问题、频繁进行 Full GC、异常安全攻击扫描等。

问题定位

我们一般会采用排除法，从外部排查到内部排查的方式来定位线上服务问题。

首先我们要排除其他进程（除主进程之外）可能引起的故障问题其次排除业务应用可能引起的故障问题最后可以考虑是否为运营商或者云服务提供商所引起的故障

定位流程

系统异常排查流程

业务应用排查流程

Linux 常用的性能分析工具

Linux 常用的性能分析工具使用包括 : top（cpu）、free（内存）、df（磁盘）、dstat（网络流量）、pstack、vmstat、strace（底层系统调用）等。

CPU

CPU 是系统重要的监控指标，能够分析系统的整体运行状况。监控指标一般包括运行队列、CPU使用率和上下文切换等。

top命令是Linux下常用的 CPU 性能分析工具,能够实时显示系统中各个进程的资源占用状况,常用于服务端性能分析。

top 命令显示了各个进程 CPU 使用情况，一般 CPU 使用率从高到低排序展示输出。其中 Load Average 显示最近1分钟、5分钟和15分钟的系统平均负载，上图各值为2.46，1.96，1.99。

我们一般会关注 CPU 使用率最高的进程，正常情况下就是我们的应用主进程。第七行以下：各进程的状态监控。

PID : 进程id USER : 进程所有者 PR : 进程优先级 NI : nice值。负值表示高优先级，正值表示低优先级 VIRT : 进程使用的虚拟内存总量，单位kb。VIRT=SWAP+RES RES : 进程使用的、未被换出的物理内存大小，单位kb。RES=CODE+DATA SHR : 共享内存大小，单位kb S : 进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程 %CPU : 上次更新到现在的CPU时间占用百分比 %MEM : 进程使用的物理内存百分比 TIME+ : 进程使用的CPU时间总计，单位1/100秒 COMMAND : 进程名称

内存

内存是排查线上问题的重要参考依据，内存问题很多时候是引起 CPU 使用率较高的见解因素。

系统内存：free 是显示的当前内存的使用，-m 的意思是M字节来显示内容。

free -m

部分参数说明：

total 内存总数: 3790M

used 已经使用的内存数: 1880M

free 空闲的内存数: 118M

shared 当前已经废弃不用,总是0

buffers Buffer 缓存内存数: 1792M

磁盘

磁盘满了很多时候会连带引起系统服务不可用等问题

df -h

du -m /path

网络

dstat 命令可以集成了 vmstat、iostat、netstat 等等工具能完成的任务。

dstat -c  cpu情况       -d 磁盘读写       -n 网络状况       -l 显示系统负载       -m 显示形同内存状况       -p 显示系统进程信息       -r 显示系统IO情况

其它

vmstat：

vmstat 2 10 -t

vmstat 是 Virtual Meomory Statistics（虚拟内存统计）的缩写, 是实时系统监控工具。该命令通过使用 knlist 子程序和 /dev/kmen 伪设备驱动器访问这些数据，输出信息直接打印在屏幕。

使用 vmstat 2 10 -t命令，查看 io 的情况（第一个参数是采样的时间间隔数单位是秒，第二个参数是采样的次数）。

r 表示运行队列(就是说多少个进程真的分配到CPU),b 表示阻塞的进程。   swpd 虚拟内存已使用的大小，如果大于0，表示你的机器物理内存不足了，如果不是程序内存泄露的原因，那么你该升级内存了或者把耗内存的任务迁移到其他机器。  free   空闲的物理内存的大小，我的机器内存总共4G，剩余120M左右。  buff   Linux/Unix系统是用来存储，目录里面有什么内容，权限等的缓存，我本机大概占用40多M  cache 文件缓存  si列表示由磁盘调入内存，也就是内存进入内存交换区的数量；  so列表示由内存调入磁盘，也就是内存交换区进入内存的数量   一般情况下，si、so的值都为0，如果si、so的值长期不为0，则表示系统内存不足，需要考虑是否增加系统内存。  bi 从块设备读入数据的总量（读磁盘）（每秒kb） bo 块设备写入数据的总量（写磁盘）（每秒kb） 随机磁盘读写的时候，这两个值越大((超出1024k)，能看到cpu在IO等待的值也会越大 这里设置的bi+bo参考值为1000，如果超过1000，而且wa值比较大，则表示系统磁盘IO性能瓶颈。  in 每秒CPU的中断次数，包括时间中断 cs(上下文切换Context Switch)

strace：strace常用来跟踪进程执行时的系统调用和所接收的信号。

strace -cp tid strace -T -p tid       -T 显示每一调用所耗的时间.     -p pid  跟踪指定的进程pid.      -v 输出所有的系统调用.一些调用关于环境变量,状态,输入输出等调用由于使用频繁,默认不输出.      -V 输出strace的版本信息.

JVM 定位问题工具

在 JDK 安装目录的 bin 目录下默认提供了很多有价值的命令行工具。每个小工具体积基本都比较小，因为这些工具只是 jdk\lib\tools.jar 的简单封装。

其中，定位排查问题时最为常用命令包括：jps（进程）、jmap（内存）、jstack（线程）、jinfo（参数）等。

jps：查询当前机器所有JAVA进程信息
jmap：输出某个 Java 进程内存情况（如产生那些对象及数量等）
jstack：打印某个 Java 线程的线程栈信息
jinfo：用于查看 jvm 的配置参数

jps 命令

jps 用于输出当前用户启动的所有进程 ID，当线上发现故障或者问题时，能够利用 jps 快速定位对应的 Java 进程 ID。

jps -l -m -m -l -l参数用于输出主启动类的完整路径

当然，我们也可以使用 Linux 提供的查询进程状态命令，例如：

ps -ef | grep tomcat

我们也能快速获取 Tomcat 服务的进程 id。

jmap 命令

jmap -heap pid   输出当前进程JVM堆新生代、老年代、持久代等请情况，GC使用的算法等信息 jmap -histo:live {pid} | head -n 10  输出当前进程内存中所有对象包含的大小 jmap -dump:format=b,file=/usr/local/logs/gc/dump.hprof {pid} 以二进制输出档当前内存的堆情况，然后可以导入MAT等工具进行

JMap（Java Memory Map）可以输出所有内存中对象的工具，甚至可以将 VM 中的 heap，以二进制输出成文本。

jmap -heap pid：

jmap -heap pid   输出当前进程JVM堆新生代、老年代、持久代等请情况，GC使用的算法等信息

jmap 可以查看 JVM 进程的内存分配与使用情况，使用的 GC 算法等信息。

jmap -histo:live {pid} | head -n 10：

jmap -histo:live {pid} | head -n 10  输出当前进程内存中所有对象包含的大小

输出当前进程内存中所有对象实例数（instances）和大小（bytes），如果某个业务对象实例数和大小存在异常情况，可能存在内存泄露或者业务设计方面存在不合理之处。

jmap -dump：

jmap -dump:format=b,file=/usr/local/logs/gc/dump.hprof {pid}

-dump:formate=b,file= 以二进制输出当前内存的堆情况至相应的文件，然后可以结合 MAT 等内存分析工具深入分析当前内存情况。

一般我们要求给 JVM 添加参数 -XX:+Heap Dump On Out Of Memory Error OOM 确保应用发生 OOM 时 JVM 能够保存并 dump 出当前的内存镜像。当然如果你决定手动 dump 内存时，dump 操作占据一定 CPU 时间片、内存资源、磁盘资源等，因此会带来一定的负面影响。

此外，dump 的文件可能比较大,一般我们可以考虑使用zip命令对文件进行压缩处理，这样在下载文件时能减少带宽的开销。在下载 dump 文件完成之后，由于 dump 文件较大可将 dump 文件备份至制定位置或者直接删除，以释放磁盘在这块的空间占用。

jstack 命令

printf '%x\n' tid   -->  10进制至16进制线程ID(navtive线程) %d 10进制 jstack pid | grep tid -C 30 --color

某 Java 进程 CPU 占用率高，我们想要定位到其中 CPU 占用率最高的线程。

（1）利用 top 命令可以查出占 CPU 最高的线程 pid

top -Hp {pid}

（2）占用率最高的线程 ID 为 6900，将其转换为16进制形式（因为 java native 线程以16进制形式输出）

printf '%x\n' 6900

（3）利用 jstack 打印出 Java 线程调用栈信息

jstack 6418 | grep '0x1af4' -A 50 --color

jinfo 命令

查看某个JVM参数值 jinfo -flag ReservedCodeCacheSize 28461 jinfo -flag MaxPermSize 28461

jstat 命令

jstat -gc pid jstat -gcutil `pgrep -u admin java`

内存分析工具 MAT

什么是 MAT?

MAT（Memory Analyzer Tool），一个基于 Eclipse 的内存分析工具，是一个快速、功能丰富的 JAVA heap 分析工具，它可以帮助我们查找内存泄漏和减少内存消耗。使用内存分析工具从众多的对象中进行分析，快速的计算出在内存中对象的占用大小，看看是谁阻止了垃圾收集器的回收工作，并可以通过报表直观的查看到可能造成这种结果的对象。

右侧的饼图显示当前快照中最大的对象。单击工具栏上的柱状图，可以查看当前堆的类信息，包括类的对象数量、浅堆（Shallow heap）、深堆（Retained Heap）。

浅堆表示一个对象结构所占用内存的大小。深堆表示一个对象被回收后，可以真实释放的内存大小。

支配树（The Dominator Tree）：

列出了堆中最大的对象，第二层级的节点表示当被第一层级的节点所引用到的对象，当第一层级对象被回收时，这些对象也将被回收。这个工具可以帮助我们定位对象间的引用情况，垃圾回收时候的引用依赖关系

Path to GC Roots

被JVM持有的对象，如当前运行的线程对象，被systemclass loader加载的对象被称为GC Roots，从一个对象到GC Roots的引用链被称为Path to GC Roots，通过分析Path to GC Roots可以找出JAVA的内存泄露问题，当程序不在访问该对象时仍存在到该对象的引用路径。

日志分析

GC 日志分析

GC 日志详细分析

Java 虚拟机 GC 日志是用于定位问题重要的日志信息，频繁的 GC 将导致应用吞吐量下降、响应时间增加，甚至导致服务不可用。

-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:/usr/local/gc/gc.log -XX:+UseConcMarkSweepGC

我们可以在 Java 应用的启动参数中增加 -XX:+PrintGCDetails 可以输出 GC 的详细日志，例外还可以增加其他的辅助参数，如 -Xloggc 制定 GC 日志文件地址。如果你的应用还没有开启该参数,下次重启时请加入该参数。

上图为线上某应用在平稳运行状态下的GC日志截图。

2017-12-29T18:25:22.753+0800: 73143.256: [GC2017-12-29T18:25:22.753+0800: 73143.257: [ParNew: 559782K->1000K(629120K), 0.0135760 secs] 825452K->266673K(2027264K), 0.0140300 secs] [Times: user=0.02 sys=0.00, real=0.02 secs]

解析说明:

 [2017-12-29T18:25:22.753+0800: 73143.256] ： 自JVM启动73143.256秒时发生本次GC. [ParNew: 559782K->1000K(629120K), 0.0135760 secs] : 对新生代进行的GC，使用ParNew收集器，559782K是新生代回收前的大小,1000K是新生代回收后大小,629120K是当前新生代分配的内存总大小, 0.0135760 secs表示本次新生代回收耗时 0.0135760秒 [825452K->266673K(2027264K), 0.0140300 secs]:825452K是回收堆内存大小,266673K是回收堆之后内存大小，2027264K是当前堆内存总大小,0.0140300 secs表示本次回收共耗时0.0140300秒 [Times: user=0.02 sys=0.00, real=0.02 secs] : 用户态耗时0.02秒,系统态耗时0.00,实际耗时0.02秒

无论是 minor GC 或者是 Full GC，我们主要关注 GC 回收实时耗时，如 real=0.02secs，即 stop the world 时间，如果该时间过长，则严重影响应用性能。

CMS GC 日志分析

Concurrent Mark Sweep（CMS）是老年代垃圾收集器，从名字（Mark Sweep）可以看出，CMS 收集器就是“标记-清除”算法实现的，分为六个步骤：

初始标记（STW initial mark）
并发标记（Concurrent marking）
并发预清理（Concurrent precleaning）
重新标记（STW remark）
并发清理（Concurrent sweeping）
并发重置（Concurrent reset）

其中初始标记（STW initial mark）和重新标记（STW remark）需要“Stop the World”。

初始标记 ：在这个阶段，需要虚拟机停顿正在执行的任务，官方的叫法 STW（Stop The Word）。这个过程从垃圾回收的"根对象"开始，只扫描到能够和"根对象"直接关联的对象，并作标记。所以这个过程虽然暂停了整个 JVM，但是很快就完成了。

并发标记 ：这个阶段紧随初始标记阶段，在初始标记的基础上继续向下追溯标记。并发标记阶段，应用程序的线程和并发标记的线程并发执行，所以用户不会感受到停顿。

并发预清理 ：并发预清理阶段仍然是并发的。在这个阶段，虚拟机查找在执行并发标记阶段新进入老年代的对象（可能会有一些对象从新生代晋升到老年代，或者有一些对象被分配到老年代）。通过重新扫描，减少下一个阶段"重新标记"的工作，因为下一个阶段会 Stop The World。

重新标记 ：这个阶段会暂停虚拟机，收集器线程扫描在 CMS 堆中剩余的对象。扫描从"跟对象"开始向下追溯，并处理对象关联。

并发清理 ：清理垃圾对象，这个阶段收集器线程和应用程序线程并发执行。

并发重置 ：这个阶段，重置 CMS 收集器的数据结构，等待下一次垃圾回收。

CMS 使得在整个收集的过程中只是很短的暂停应用的执行，可通过在 JVM 参数中设置 -XX:UseConcMarkSweepGC 来使用此收集器，不过此收集器仅用于 old 和 Perm（永生）的对象收集。CMS 减少了 stop the world 的次数，不可避免地让整体 GC 的时间拉长了。

Full GC 的次数说的是 stop the world 的次数，所以一次 CMS 至少会让 Full GC 的次数+2，因为 CMS Initial mark 和 remark 都会 stop the world，记做2次。而 CMS 可能失败再引发一次 Full GC。

上图为线上某应用在进行 CMS GC 状态下的 GC 日志截图。

2017-11-02T09:27:03.989+0800: 558115.552: [GC [1 CMS-initial-mark: 1774783K(1926784K)] 1799438K(2068800K), 0.0123430 secs] [Times: user=0.01 sys=0.01, real=0.02 secs]  2017-11-02T09:27:04.001+0800: 558115.565: [CMS-concurrent-mark-start] 2017-11-02T09:27:04.714+0800: 558116.277: [CMS-concurrent-mark: 0.713/0.713 secs] [Times: user=1.02 sys=0.03, real=0.71 secs]  2017-11-02T09:27:04.714+0800: 558116.277: [CMS-concurrent-preclean-start] 2017-11-02T09:27:04.722+0800: 558116.285: [CMS-concurrent-preclean: 0.008/0.008 secs] [Times: user=0.01 sys=0.00, real=0.01 secs]  2017-11-02T09:27:04.722+0800: 558116.286: [CMS-concurrent-abortable-preclean-start] 2017-11-02T09:27:04.836+0800: 558116.399: [GC2017-11-02T09:27:04.836+0800: 558116.400: [ParNew: 138301K->6543K(142016K), 0.0155540 secs] 1913085K->1781327K(2068800K), 0.0160610 secs] [Times: user=0.03 sys=0.01, real=0.02 secs]  2017-11-02T09:27:05.005+0800: 558116.569: [CMS-concurrent-abortable-preclean: 0.164/0.283 secs] [Times: user=0.46 sys=0.02, real=0.28 secs]  2017-11-02T09:27:05.006+0800: 558116.570: [GC[YG occupancy: 72266 K (142016 K)]2017-11-02T09:27:05.006+0800: 558116.570: [Rescan (parallel) , 0.2523940 secs]2017-11-02T09:27:05.259+0800: 558116.822: [weak refs processing, 0.0011240 secs]2017-11-02T09:27:05.260+0800: 558116.823: [scrub string table, 0.0028570 secs] [1 CMS-remark: 1774783K(1926784K)] 1847049K(2068800K), 0.2566410 secs] [Times: user=0.14 sys=0.00, real=0.26 secs]  2017-11-02T09:27:05.265+0800: 558116.829: [CMS-concurrent-sweep-start] 2017-11-02T09:27:05.422+0800: 558116.986: [GC2017-11-02T09:27:05.423+0800: 558116.986: [ParNew: 120207K->2740K(142016K), 0.0179330 secs] 1885446K->1767979K(2068800K), 0.0183340 secs] [Times: user=0.03 sys=0.01, real=0.02 secs]  2017-11-02T09:27:06.240+0800: 558117.804: [GC2017-11-02T09:27:06.240+0800: 558117.804: [ParNew: 116404K->3657K(142016K), 0.0134680 secs] 1286444K->1173697K(2068800K), 0.0138460 secs] [Times: user=0.03 sys=0.00, real=0.01 secs]  2017-11-02T09:27:06.966+0800: 558118.530: [GC2017-11-02T09:27:06.966+0800: 558118.530: [ParNew: 117321K->2242K(142016K), 0.0135210 secs] 738838K->623759K(2068800K), 0.0140130 secs] [Times: user=0.03 sys=0.00, real=0.02 secs]  2017-11-02T09:27:07.144+0800: 558118.708: [CMS-concurrent-sweep: 1.820/1.879 secs] [Times: user=2.88 sys=0.14, real=1.88 secs]  2017-11-02T09:27:07.144+0800: 558118.708: [CMS-concurrent-reset-start] 2017-11-02T09:27:07.149+0800: 558118.713: [CMS-concurrent-reset: 0.005/0.005 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]

如果你已掌握 CMS 的垃圾收集过程，那么上面的 GC 日志你应该很容易就能看的懂，这里我就不详细展开解释说明了。

此外 CMS 进行垃圾回收时也有可能会发生失败的情况。

异常情况有：

伴随 prommotion failed，然后 Full GC：

[prommotion failed：存活区内存不足，对象进入老年代，而此时老年代也仍然没有内存容纳对象，将导致一次Full GC]

伴随 concurrent mode failed，然后 Full GC：

[concurrent mode failed：CMS回收速度慢，CMS完成前，老年代已被占满，将导致一次Full GC]

频繁 CMS GC：

[内存吃紧，老年代长时间处于较满的状态]

业务日志

业务日志除了关注系统异常与业务异常之外，还要关注服务执行耗时情况，耗时过长的服务调用如果没有熔断等机制，很容易导致应用性能下降或服务不可用，服务不可用很容易导致雪崩。

上面是某一接口的调用情况，虽然大部分调用没有发生异常，但是执行耗时相对比较长。

grep '[0-9]{3,}ms' *.log  找出调用耗时大于3位数的dao方法，把3改成4就是大于4位数

互联网应用目前几乎采用分布式架构，但不限于服务框架、消息中间件、分布式缓存、分布式存储等等。那么这些应用日志如何聚合起来进行分析呢? 首先，你需要一套分布式链路调用跟踪系统，通过在系统线程上线文间透传 traceId 和 rpcId，将所有日志进行聚合，例如淘宝的鹰眼，spring cloud zipkin等等。

案列分析

CPU 使用率高问题定位

按照2.1定位流程首先排除了系统层面的问题。

利用 top -Hp 6814 输出进程 ID 为 6814 的所有线程 CPU 使用率情况，发现某个线程使用率比较高，有些异常。

printf '%x\n' 2304 #输出线程ID的16进制 jstack pid | grep '0x900' -C 30 --color

输出的日志表明该线程一直处于与 mysql I/O 状态：

"Thread-6563" daemon prio=10 tid=0x00007fda419a9000 nid=0x900 runnable [0x00007fda2b2b1000]    java.lang.Thread.State: RUNNABLE         at java.net.SocketInputStream.socketRead0(Native Method)         at java.net.SocketInputStream.read(SocketInputStream.java:152)         at java.net.SocketInputStream.read(SocketInputStream.java:122)         at com.mysql.jdbc.util.ReadAheadInputStream.fill(ReadAheadInputStream.java:114)         at com.mysql.jdbc.util.ReadAheadInputStream.readFromUnderlyingStreamIfNecessary(ReadAheadInputStream.java:161)         at com.mysql.jdbc.util.ReadAheadInputStream.read(ReadAheadInputStream.java:189)         - locked <0x00000007d03e81d0> (a com.mysql.jdbc.util.ReadAheadInputStream)         at com.mysql.jdbc.MysqlIO.readFully(MysqlIO.java:3116)         at com.mysql.jdbc.MysqlIO.nextRowFast(MysqlIO.java:2224)         at com.mysql.jdbc.MysqlIO.nextRow(MysqlIO.java:1999)         at com.mysql.jdbc.MysqlIO.readSingleRowSet(MysqlIO.java:3507)         at com.mysql.jdbc.MysqlIO.getResultSet(MysqlIO.java:490)         at com.mysql.jdbc.MysqlIO.readResultsForQueryOrUpdate(MysqlIO.java:3198)         at com.mysql.jdbc.MysqlIO.readAllResults(MysqlIO.java:2366)         at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2789)         at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2818)         - locked <0x00000007ddcc84e8> (a com.mysql.jdbc.JDBC4Connection)         at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2157)         - locked <0x00000007ddcc84e8> (a com.mysql.jdbc.JDBC4Connection)         at com.mysql.jdbc.PreparedStatement.execute(PreparedStatement.java:1379)         - locked <0x00000007ddcc84e8> (a com.mysql.jdbc.JDBC4Connection)         at com.alibaba.druid.filter.FilterChainImpl.preparedStatement_execute(FilterChainImpl.java:2931)         at com.alibaba.druid.filter.FilterEventAdapter.preparedStatement_execute(FilterEventAdapter.java:440)         at com.alibaba.druid.filter.FilterChainImpl.preparedStatement_execute(FilterChainImpl.java:2929)         at com.alibaba.druid.filter.FilterEventAdapter.preparedStatement_execute(FilterEventAdapter.java:440)         at com.alibaba.druid.filter.FilterChainImpl.preparedStatement_execute(FilterChainImpl.java:2929)         at com.alibaba.druid.proxy.jdbc.PreparedStatementProxyImpl.execute(PreparedStatementProxyImpl.java:131)         at com.alibaba.druid.pool.DruidPooledPreparedStatement.execute(DruidPooledPreparedStatement.java:493)         at org.apache.ibatis.executor.statement.PreparedStatementHandler.query(PreparedStatementHandler.java:56)         at org.apache.ibatis.executor.statement.RoutingStatementHandler.query(RoutingStatementHandler.java:70)         at org.apache.ibatis.executor.SimpleExecutor.doQuery(SimpleExecutor.java:57)         at org.apache.ibatis.executor.BaseExecutor.queryFromDatabase(BaseExecutor.java:259)         at org.apache.ibatis.executor.BaseExecutor.query(BaseExecutor.java:132)         at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:105)         at cn.com.company.xqy.framework.daoframework.interceptor.PanDaoInterceptor.interceptCachePage(PanDaoInterceptor.java:172)         at cn.com.company.xqy.framework.daoframework.interceptor.PanDaoInterceptor.intercept(PanDaoInterceptor.java:45)         at org.apache.ibatis.plugin.Plugin.invoke(Plugin.java:57)         at com.sun.proxy.$Proxy121.query(Unknown Source)         at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:104)         at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:98)         at cn.com.company.xqy.framework.daoframework.PanSqlSessionTemplate$1.doInSqlSession(PanSqlSessionTemplate.java:111)         at cn.com.company.xqy.framework.daoframework.PanSqlSessionTemplate.executeWith(PanSqlSessionTemplate.java:454)         at cn.com.company.xqy.framework.daoframework.PanSqlSessionTemplate.selectList(PanSqlSessionTemplate.java:150)         at cn.com.company.xqy.framework.daoframework.PanSqlSessionTemplate.selectList(PanSqlSessionTemplate.java:93)         at org.apache.ibatis.binding.MapperMethod.executeForMany(MapperMethod.java:114)         at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:58)         at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:43)         at com.sun.proxy.$Proxy45.select(Unknown Source)         at sun.reflect.GeneratedMethodAccessor4958.invoke(Unknown Source)         at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)         at java.lang.reflect.Method.invoke(Method.java:606)         at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)         at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)         at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)         at cn.com.company.xqy.framework.log.interceptor.DalDigestLogInterceptor.invoke(DalDigestLogInterceptor.java:28)         at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)         at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)         at com.sun.proxy.$Proxy46.select(Unknown Source)         at cn.com.company.xqy.finance.service.CustomerAccountTitleService.selectAllEnablesNoCache(CustomerAccountTitleService.java:1124)         at cn.com.company.xqy.finance.service.CustomerAccountTitleService$$FastClassBySpringCGLIB$$363dc6fc.invoke(<generated>)         at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)         at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:651)         at cn.com.company    .xqy.finance.service.CustomerAccountTitleService$$EnhancerBySpringCGLIB$$613b9107.selectAllEnablesNoCache(<generated>)         at cn.com.company.xqy.finance.service.datafix.BalanceFixService.amountStatistics(BalanceFixService.java:1121)         at cn.com.company.xqy.finance.service.datafix.BalanceFixService.scan(BalanceFixService.java:346)         at cn.com.company.xqy.finance.service.datafix.BalanceFixService.access$100(BalanceFixService.java:38)         at cn.com.company.xqy.finance.service.datafix.BalanceFixService$1.run(BalanceFixService.java:107)         at java.lang.Thread.run(Thread.java:745)

利用 jmap -dump:format=b,file=/usr/local/logs/gc/dump.hprof {pid} 以二进制输出档当前内存的堆情况，然后可以导入 MAT 等工具进行分析。如下图所示，点击 MAT 的支配树可以发现存在某个超大对象数组，实例对象数目多大30多万个。

经过分析发现数组中每一个对象都是核心业务对象，我们的业务系统有一个定时任务线程会访问数据库某张业务表中的所有记录，然后加载至内存然后进行处理因此内存吃紧，导致 CPU 突然飙升。发现该问题后，已对该方案进行重新设计。

整理了一些 IDEA 中比较骚的技巧

Sun, 25 Aug 2019 05:18:10 GMT

IDEA 有个很牛逼的功能，那就是后缀补全（不是自动补全），很多人竟然不知道这个操作，还在手动敲代码。

-----------------来自小马哥的故事

这个功能可以使用代码补全来模板式地补全语句，如遍历循环语句（for、foreach）、使用 String.format() 包裹一个字符串、使用类型转化包裹一个表达式、根据判（非）空或者其它判别语句生成 if 语句、用 instanceOf 生成分支判断语句等。

使用的方式也很简单，就是在一个表达式后按下点号 . ，然后输入一些提示或者在列表中选择一个候选项，常见的候选项下面会给出 GIF 演示。

fori 带索引的遍历

for 遍历

if 条件判断

cast 强转

nn 判非空

notnull 判非空

not 取反

null判空

return 返回值

var声明

SQL如何实现MYSQL的递归查询，SQL实现MYSQL递归

Sun, 25 Aug 2019 04:53:00 GMT

有时候经常需要迭代查询一些数据,比如按钮菜单,裂变。

-----------------来自小马哥的故事

所周知，目前的mysql版本中并不支持直接的递归查询，但是通过递归到迭代转化的思路，还是可以在一句SQL内实现树的递归查询的。这个得益于Mysql允许在SQL语句内使用@变量。以下是示例代码。

创建表格

CREATE TABLE `treenodes` (   `id` int , -- 节点ID   `nodename` varchar (60), -- 节点名称   `pid` int -- 节点父ID );

插入测试数据

INSERT INTO `treenodes` (`id`, `nodename`, `pid`) VALUES ('1','A','0'),('2','B','1'),('3','C','1'), ('4','D','2'),('5','E','2'),('6','F','3'), ('7','G','6'),('8','H','0'),('9','I','8'), ('10','J','8'),('11','K','8'),('12','L','9'), ('13','M','9'),('14','N','12'),('15','O','12'), ('16','P','15'),('17','Q','15'),('18','R','3'), ('19','S','2'),('20','T','6'),('21','U','8');

查询语句

  SELECT id AS ID,pid AS 父ID ,levels AS 父到子之间级数, paths AS 父到子路径 FROM (    SELECT id,pid,    @le:= IF (pid = 0 ,0,       IF( LOCATE( CONCAT('|',pid,':'),@pathlevel)  > 0 ,             SUBSTRING_INDEX( SUBSTRING_INDEX(@pathlevel,CONCAT('|',pid,':'),-1),'|',1) +1     ,@le+1) ) levels    , @pathlevel:= CONCAT(@pathlevel,'|',id,':', @le ,'|') pathlevel    , @pathnodes:= IF( pid =0,',0',        CONCAT_WS(',',       IF( LOCATE( CONCAT('|',pid,':'),@pathall) > 0 ,          SUBSTRING_INDEX( SUBSTRING_INDEX(@pathall,CONCAT('|',pid,':'),-1),'|',1)        ,@pathnodes ) ,pid ) )paths   ,@pathall:=CONCAT(@pathall,'|',id,':', @pathnodes ,'|') pathall      FROM treenodes,    (SELECT @le:=0,@pathlevel:='', @pathall:='',@pathnodes:='') vv   ORDER BY pid,id   ) src ORDER BY id

结果

    ID   父ID    父到子之间级数  父到子路径 ------    ------     --------------------    -------------------       1       0              0                     ,0                   2       1              1                     ,0,1                 3       1              1                     ,0,1                 4       2              2                     ,0,1,2               5       2              2                     ,0,1,2               6       3              2                     ,0,1,3               7       6              3                     ,0,1,3,6             8       0              0                     ,0                   9       8              1                     ,0,8                10       8             1                     ,0,8                11       8             1                     ,0,8                12       9             2                     ,0,8,9              13       9             2                     ,0,8,9              14      12            3                      ,0,8,9,12           15      12            3                     ,0,8,9,12           16      15            4                     ,0,8,9,12,15        17      15            4                     ,0,8,9,12,15        18       3            2                      ,0,1,3              19       2            2                      ,0,1,2              20       6            3                      ,0,1,3,6            21       8            1                      ,0,8

以上就是一句SQL实现MYSQL的递归查询的实现全过程，希望对大家的学习有所帮助。

github下载代码的速度太慢

Tue, 23 Apr 2019 14:35:10 GMT

作为程序员，最大的同性交友网站估计是大家的标配了，常常会苦恼于git clone某个项目的时候速度太慢，看着控制台那几K十一二K的速度，吐血！！

原因很简单：github的CDN被高高的墙屏蔽所致了。所以解决方案也很简单，就是手动把 cdn 和IP地址绑定一下。

1、获取github地址

访问 http://github.com.ipaddress.com/ 获取cdn域名以及ip地址

2、获取 global.ssl.fastly地址

http://github.global.ssl.fastly.net.ipaddress.com/ 获取cdn域名以及ip地址

3、打开hosts映射

Windows环境

C:\Windows\System32\drivers\etc\hosts

最末尾添加两句话保存:

151.101.185.194 http://github.global.ssl.fastly.net  192.30.253.112 http://github.com

打开CMD刷新一下DNS就好了。

ipconfig /flushdns

Linux环境

sudo gedit /etc/hosts

添加

192.30.253.112 http://github.com 151.101.185.194 http://github.global.ssl.fastly.net

保存,退出,并重启网络

/etc/init.d/networking restart

速度对比:

配置前

Receiving objects:  17% (151/883), 348.00 KiB | 18.00 KiB/s

配置后

Receiving objects:  81% (86141/104384), 81.31Mib | 562.00 KiB/s

上传本地代码到github

Sun, 21 Apr 2019 16:01:15 GMT

全球最大同性交友网站GitHub,你还不赶快加入进来!

-----------------来自小马哥的故事

第一步：下载Git

下载地址: https://gitforwindows.org/

第二步：建立git仓库

Git bash Here 命令下 cd到你的本地项目根目录下，执行git命令

git init

第三步：将项目的所有文件添加到仓库中

git add .

(如果想添加某个特定的文件，只需把.换成特定的文件名即可)

第三步：将add的文件commit到仓库

git commit -m "注释语句"

第四步：去github上创建自己的Repository

创建页面如下图所示：

点击下面的Create repository，就会进入到类似下面的一个页面，拿到创建的仓库的https地址，红框标示的就是

第五步：重点来了，将本地的仓库关联到github上

git remote add origin https://github.com/MaRuifu/Java8NewFeatures

后面的https链接地址换成你自己的仓库url地址，也就是上面红框中标出来的地址

第六步：上传github之前，要先pull一下

git pull origin master

第七步，也就是最后一步，上传代码到github远程仓库

git push -u origin master

执行完后，如果没有异常，等待执行完就上传成功了，中间可能会让你输入Username和Password，你只要输入github的账号和密码就行了

最全的常用正则表达式大全——包括校验数字、字符、一些特殊的需求等等

Sat, 20 Apr 2019 20:40:00 GMT

一、校验数字的表达式

 1 数字：^[0-9]*$    2 n位的数字：^d{n}$    3 至少n位的数字：^d{n,}$    4 m-n位的数字：^d{m,n}$    5 零和非零开头的数字：^(0|[1-9][0-9]*)$    6 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$    7 带1-2位小数的正数或负数：^(-)?d+(.d{1,2})?$    8 正数、负数、和小数：^(-|+)?d+(.d+)?$    9 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$  10 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$  11 非零的正整数：^[1-9]d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^+?[1-9][0-9]*$  12 非零的负整数：^-[1-9][]0-9"*$ 或 ^-[1-9]d*$  13 非负整数：^d+$ 或 ^[1-9]d*|0$  14 非正整数：^-[1-9]d*|0$ 或 ^((-d+)|(0+))$  15 非负浮点数：^d+(.d+)?$ 或 ^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$  16 非正浮点数：^((-d+(.d+)?)|(0+(.0+)?))$ 或 ^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$  17 正浮点数：^[1-9]d*.d*|0.d*[1-9]d*$ 或 ^(([0-9]+.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*.[0-9]+)|([0-9]*[1-9][0-9]*))$  18 负浮点数：^-([1-9]d*.d*|0.d*[1-9]d*)$ 或 ^(-(([0-9]+.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*.[0-9]+)|([0-9]*[1-9][0-9]*)))$  19 浮点数：^(-?d+)(.d+)?$ 或 ^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$

二、校验字符的表达式

 1 汉字：^[一-龥]{0,}$  ^[\\u4e00-\\u9fa5]{0,}$  2 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$   3 长度为3-20的所有字符：^.{3,20}$   4 由26个英文字母组成的字符串：^[A-Za-z]+$   5 由26个大写英文字母组成的字符串：^[A-Z]+$   6 由26个小写英文字母组成的字符串：^[a-z]+$   7 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$   8 由数字、26个英文字母或者下划线组成的字符串：^w+$ 或 ^w{3,20}$   9 中文、英文、数字包括下划线：^[一-龥A-Za-z0-9_]+$ 10 中文、英文、数字但不包括下划线等符号：^[一-龥A-Za-z0-9]+$ 或 ^[一-龥A-Za-z0-9]{2,20}$ 11 可以输入含有^%&',;=?$"等字符：[^%&',;=?$"]+ 12 禁止输入含有~的字符：[^~"]+

三、特殊需求表达式

  1 Email地址：^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$    2 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?    3 InternetURL：[a-zA-z]+://[^s]* 或 ^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$    4 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])d{8}$    5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^((d{3,4}-)|d{3.4}-)?d{7,8}$     6 国内电话号码(0511-4405222、021-87888822)：d{3}-d{8}|d{4}-d{7}    7 身份证号(15位、18位数字)：^d{15}|d{18}$    8 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$   15位：^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$  18位：^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9]|X)$    9 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$  10 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]w{5,17}$  11 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$    12 日期格式：^d{4}-d{1,2}-d{1,2} “yyyy-mm-dd“ 格式的日期校验，已考虑平闰年。：^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$  13 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$  14 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$   15 金额校验，精确到2位小数。：^[0-9]+(.[0-9]{2})?$  16.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$   17.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$  18.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$   19.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$   20.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$   21.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$   22.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$  23. 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$   24 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里  25 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x|X][m|M][l|L]$  26 中文字符的正则表达式：[一-龥]  27 双字节字符：[^-ÿ]    (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))  28 空白行的正则表达式：s* (可以用来删除空白行)  29 HTML标记的正则表达式：<(S*?)[^>]*>.*?</>|<.*? />    (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)  30 首尾空白字符的正则表达式：^s*|s*$或(^s*)|(s*$)    (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)  31 腾讯QQ号：[1-9][0-9]{4,}    (腾讯QQ号从10000开始)  32 中国邮政编码：[1-9]d{5}(?!d)    (中国邮政编码为6位数字)  33 IP地址：d+.d+.d+.d+    (提取IP地址时有用)  34 IP地址：((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))      35 匹配HTML标签通过下面的表达式可以匹配出HTML中的标签属性。：<\\/?\\w+((\\s+\\w+(\\s*=\\s*(?:".*?"|'.*?'|[\\^'">\\s]+))?)+\\s*|\\s*)\\/?>  36 抽取注释 如果你需要移除HMTL中的注释，可以使用如下的表达式。：<!--(.*?)-->   37 查找CSS属性 通过下面的表达式，可以搜索到相匹配的CSS属性。：^\\s*[a-zA-Z\\-]+\\s*[:]{1}\\s[a-zA-Z0-9\\s.#]+[;]{1}  38 提取页面超链接 提取html中的超链接： (<a\\s*(?!.*\\brel=)[^>]*)(href="https?:\\/\\/)((?!(?:(?:www\\.)?'.implode('|(?:www\\.)?', $follow_list).'))[^"]+)"((?!.*\\brel=)[^>]*)(?:[^>]*)>  39 提取网页图片假若你想提取网页中所有图片信息，可以利用下面的表达式。：\\< *[img][^\\\\>]*[src] *= *[\\"\\']{0,1}([^\\"\\'\\ >]*)  40 提取Color Hex Codes有时需要抽取网页中的颜色代码，可以使用下面的表达式。：^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$  41 文件路径及扩展名校验 验证windows下文件路径和扩展名（下面的例子中为.txt文件）：^([a-zA-Z]\\:|\\\\)\\\\([^\\\\]+\\\\)*[^\\/:*?"<>|]+\\.txt(l)?$  42 提取URL链接 下面的这个表达式可以筛选出一段文本中的URL。：^(f|ht){1}(tp|tps):\\/\\/([\\w-]+\\.)+[\\w-]+(\\/[\\w- ./?%&=]*)?  43 检查URL的前缀 应用开发中很多时候需要区分请求是HTTPS还是HTTP，通过下面的表达式可以取出一个url的前缀然后再逻辑判断。：if (!s.match(/^[a-zA-Z]+:\\/\\//)){ s = 'http://' + s;}  44 校验IPv6地址 ：(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))  45 校验IP-v4地址：\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b  46 判断IE的版本：^.*MSIE [5-8](?:\\.[0-9]+)?(?!.*Trident\\/[5-9]\\.0).*$  47 密码的强度必须是包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间。：^(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$

人为什么要去旅行？这是我见过的最美的答案

Sat, 20 Apr 2019 20:11:33 GMT

人为什么要去旅行？这是我见过的最美的答案

看到朋友圈的谁谁谁，用两句鸡汤文配上几张美图，再加一个定位，我们默默的评论一句“你又出去玩儿啦，好羡慕”，然后手指继续向下滑动，看着其他人的生活，好像都那么多姿多彩。

唯独自己，公司--家，两点一线，枯燥乏味，日复一日。

你羡慕的生活，你羡慕的人，你做不到的事情，有人做到了。你不禁疑问，他们哪里来的那么多的时间和金钱？旅行，又究竟是为了什么？

因为旅行，可以滋养我们在一个已经待腻的城市里，日渐枯萎的心。

我们花那么多钱买机票订酒店，花那么多时间查攻略，不是为了简单的发发朋友圈晒几张世界大同的照片，而是用这些时间和钱让漫漫人生长河，变得有趣。

毕竟这世界上，好看的人很多，有趣的灵魂却很少。

因为旅行，是看清世界的一个最直接的途径。

电影，告诉我世界有无限可能，旅行，让我可以真切的感受世界。

不要只把向往的远方放在梦想里，而是放在你的计划里。

因为旅行，是一种热爱，而我们愿为了这份热爱买单。

因为心中有那份狂热，你会想要花时间、花金钱，去为了远方而行动。

远方像是一种执念，更像是一种瘾，你不去，它便呼唤你，召唤你，直到你寻踪而至。

因为有些事，现在不做，一辈子都不会再做了。

该庆幸的是年岁还轻，时光未老，眼还未浊，腿还能动。有着无限的精力和不竭的动力为想要的旅行奔波。

我不畏颠沛流离，只为看你一眼。

因为旅行，是一种冲动。

你不可能等攒够了钱，再去过想要的生活，那个时候，可能世界都变化了一圈。

所以，想去哪，就用自己的方式去看看这个世界，无论是徒步、搭车、穷游，还是自驾，都能够有不一样的惊喜。

因为旅行的脚步，永远是向前的。

停在原地的理由很多，但我们总要坚定一个出发的理由。

因为旅行可以更好的工作和生活。

即使知道旅行过后，还是要回到原来的城市，工作、生活，但却有一种期待，为了下一次的远行，更好的生活。

见到了世界的生活方式，才能更加清楚的看到内心想要的生活。

因为旅行，是年老时，回忆的资本。

不想年老之时，回想一生，除了千篇一律的工作和平淡入水的生活，别无他想。

即使老了，也想要做一个积极乐观的老太太，一个时髦超前的老太太。

我们花那么多时间和金钱去旅行，是为了我们那么平凡，却又可以不凡。

一种绝对提高开发水平的方法

Sat, 20 Apr 2019 18:42:00 GMT

一种绝对提高开发水平的方法,哈哈记单词!!

-----------------来自小马哥的故事

常用单词

初级部分

第一节  void：[vɔid] 空的 main：[mein] 主要的 class：[klɑ:s] 类 system：['sistəm] 系统 out：[aut] 出，外，输出 print：[print ] 打印 public['pʌblik] 公共的,公用的 static['stætik] 静的;静态的;静止的 oracle: [ˈɔ:rəkl] 甲骨文公司 eclipse：[i'klips] java编程软件    第二节   int：[int] 整型 char：[tʃɑ:] 字符型 scanner：['skænə] 接收输入，扫描器 integer：['intidʒə]整数 整型 type：[taip]类型 string：[striŋ] 字符串类型 double：['dʌbl] 双精度浮点型  第三节  boolean：['bu🇱🇮ən] 布尔类型真假二值 true：[tru:]真 false：[fɔ:ls]假 不正确的 if：[if] 如果 else：[els] 否则 break：[brek] 打破，跳出  第四节  case：[keis] 情况,实例 default：[di'fɔ:lt] 默认 switch：[switʃ] 开关，切换 break：[breik] 退出 match：[mætʃ] 匹配 exception：[ik'sepʃən] 异常 equals：['i:kwəls] 相等 第五节  while：[hwail] 当什么时候，常作循环 index：['indeks] 索引 bug：[bʌg] 缺陷 debug：[di:'bʌg] 调试 step：[step] 步骤 error：['erə] 错误 answer：['ɑ:nsə] 答案 回答  第六节  rate：[reit] 比率 young：[jʌŋ] 年轻的 customer：['kʌstəmə] 顾客 买主 birthday：['bə:θdei] 生日 point：[pɔint] 分数 得分 点 continue：[kən'tinju:] 继续、进入到下一个循环 return：[ri'tə:n] 返回 total：['təutl] 合计、总人数,,全体的  第七节  array：[ə'rei] 数组 length：[leŋθ] 长度 sort：[sɔ:t] 分组 排序 primitive：['primitiv] 初始的 简单的 reference：['refərəns] 参照 证明 关系 info：['infəu] 通知 报告 消息 interface：['intəfeis] 接口  第八节  random：['rændəm] 随机 insert：[in'sə:t] 插入 嵌入 compare：[kəm'pɛə] 比较 对照 ignore：[ig'nɔ:] 忽视 不理会 invert：[in'və:t] 使转位 倒转 password：['pɑ:swə:d] 密码 口令  第九节  bit：[bɪt] 位,0或1 byte:[baɪt] 字节，8个bit put:[pʊt] 放 log:[lɔ:g] 日志 show:[ʃoʊ] 展示，显示 第十节  change：[tʃeindʒ] 交换 互换 administrator：[əd'ministreitə] 管理员 initial：[i'niʃəl] 开始的、最初的 class：[klɑ:s] 类 object：['ɔbdʒikt] 物体 对象 encapsulation：[in,kæpsju'leiʃən] 封装 null：[nʌl] 空的  第十一节  person：['pə:sn] 人 start：[stɑ:t] 开始 menu：['menju:] 菜单 login：[lɔg'in] 登陆 main：[mein] 主要的 document：['dɔkjumənt] 文档 display：[di'splei] 显示 method：['meθəd] 方法 条理 version：['və:ʃən] 版本 parameter：[pə'ræmitɚ] 参数 since：[sins] 自…..之后 calculator：['kælkju,leitə] 计算器  第十二节  shape：[ʃeip] 形状 open：[əup] 打开 date：[deit] 日期 operate：['ɔpə,reitə] 操作 protect：[prə'tekt] 保卫 护卫 private：['praivit] 私人的 私有的  第十三节  manage：['mænidʒ] 控制，管理 search：[sə:tʃ] 搜寻 查找 upper：['ʌpə] 上面的  第十四节  equal：['i:kwəl] 相等的 ignore：[ig'nɔ:] 忽视 驳回 lower：['ləuə] 较低的 下部的 last：[lɑ:st] 最后的 trim：[trim] 裁切 concatenate：[kɔn'kætineit] 使连锁 连成一串 使连接 buffer：['bʌfə] 缓冲 final：['fainl] 最后的 最终的  第十五节  定义变量中常用的单词 score：[skɔ:]成绩 price：[prais]价钱 test：[test]实验，测试 demo：['deməu]示例 sum：[sʌm] 和 num：[nʌm] 数字 height：[hait] 身高 weight ：[weit] 体重 music：['mju:zik] 音乐 computer：[kəm'pju:tə] 电脑 student：['stju:dənt] 学生 total：['təutl] 总计的,总括的,全体的  第十六节  max 最大的 min 最小的 avg 平均分 Add 加 Minus 减 multiply：['mʌltiplai] 乘 divide：[di'vaid] 除 Monday：['mʌndei] 星期一 Tuesday：['tju:zdi] 星期二 Wednesday：['wenzdi] 星期三 Thursday：['θə:zdi] 星期四 Friday：['fraidi] 星期五 Saturday：['sætədi] 星期六 Sunday：['sʌndi] 星期日 月份+缩写 一月：January Jan. 二月：February Feb. 三月：March Mar. 四月：April Apr. 五月：May – 六月：June – 七月：July – 八月：August Aug. 九月：September Sept. 十月：October Oct. 十一月：November Nov. 十二月：December Dec

高级部分

序号	类	频率	中文
1	class	23	类
2	operator	20	操作符
3	function	17	函数
4	object	11	对象
5	exception	9	异常
6	template	8	模板
7	call	7	调用
8	list	7	列表
9	resolution	7	分辨率
10	copy	6	复制
11	declaration	6	声明
12	derived	6	派生的
13	global	6	全局
14	hard	6	硬
15	base	5	基地
16	box	5	盒子
17	file	5	文件
18	initialization	5	初始化
19	library	5	库
20	member	5	成员
21	overloaded	5	重载
22	scope	5	范围
23	binary	4	二进制
24	by	4	通过
25	forwarding	4	转发
26	generic	4	通用的
27	group	4	集团
28	GUI	4	图形界面
29	if	4	如果
30	immediate	4	立即
31	infinite	4	无限
32	inline	4	内联
33	loop	4	循环
34	parameter	4	参数
35	specialization	4	专业化
36	bar	3	条
37	bit	3	位
38	data	3	数据
39	database	3	数据库
40	dereference	3	间接引用
41	disk	3	磁盘
42	equality	3	相等
43	explicit	3	显式的
44	field	3	字段
45	framework	3	框架
46	hierarchy	3	层次结构
47	memory	3	内存
48	message	3	消息
49	pass	3	通过
50	recursive	3	递归
51	return	3	返回
52	specification	3	规范
53	standard	3	标准
54	type	3	类型
55	algorithm	2	算法
56	and	2	和
57	assembly	2	程序集、组装、装配、部件
58	assignment	2	赋值
59	based	2	基于
60	binding	2	绑定
61	build	2	构建
62	button	2	按钮
63	check	2	检査
64	clause	2	条款
65	client	2	客户端
66	code	2	代码
67	coded	2	编码
68	compatible	2	兼容的
69	constant	2	常数
70	container	2	容器
71	deduction	2	扣除、演绎
72	definition	2	定义
73	design	2	设计
74	dot	2	点
75	event	2	事件
76	exit	2	退出
77	expansion	2	扩张
78	export	2	导岀
79	expression	2	表达式
80	facility	2	设施
81	feature	2	功能
82	firmware	2	固件
83	flag	2	标记
84	flash	2	动画、闪光
85	flexibility	2	灵活性
86	flush	2	清空
87	font	2	字体
88	for	2	为，循环
89	form	2	形式
90	formal	2	正式的
91	forward	2	向前
92	fractal	2	分形
93	full	2	完整的
94	functionality	2	功能
95	functor	2	仿函数
96	game	2	游戏
97	generate	2	生成
98	getter	2	获取器
99	guard	2	保护，守卫
100	hand	2	手
101	handle	2	处理
102	handler	2	处理程序
103	handling	2	处理
104	hardware	2	硬件
105	hash	2	哈希
106	header	2	头
107	heap	2	堆
108	hook	2	钩子
109	hyperlink	2	超链接
110	icon	2	图标
111	IDE	2	集成开发环境
112	identifier	2	标识符
113	image	2	图像
114	immutability	2	不变性
115	immutable	2	不可变的
116	implement	2	实现
117	implementation	2	实现
118	implicit	2	隐式的
119	inport	2	导入
120	increment	2	增量
121	information	2	信息、
122	infrastructure	2	基础设施
123	inheritance	2	继承
124	initialize	2	初始化
125	inner	2	内心的
126	instance	2	实例
127	instantiated	2	实例化
128	instantiation	2	实例化
129	integer	2	整数
130	integrate	2	集成
131	interacts	2	相互作用
132	interface	2	接口
133	interpreter	2	翻译
134	invariants	2	不变量
135	invoke	2	调用
136	iterate	2	迭代
137	language	2	语言
138	level	2	水平
139	local	2	本地
140	lock	2	锁
141	modeling	2	建模
142	network	2	网络
143	number	2	数量
144	only	2	只有
145	partial	2	部分
146	pattern	2	模式
147	pointer	2	指针
148	refer	2	请参考
149	reference	2	参考
150	runtime	2	运行时
151	search	2	搜索
152	server	2	服务器
153	shaking	2	颤抖
154	specialization:	2	专门化
155	stack	2	堆栈
156	table	2	表
157	value	2	价值
158	access	1	访问
159	address	1	地址
160	Al	1	人工智能
161	application	1	应用程序
162	architecture	1	体系结构
163	argument	1	论点
164	array	1	数组
165	arrow	1	箭头
166	assert	1	断言
167	assign	1
168	associated	1	相关的
169	atomic	1	原子
170	attribute	1	属性
171	audio	1	音频
172	background	1	背景
173	bandwidth	1
174	batch	1	批处理
175	benefit	1	利益
176	bitmap	1	位图
177	bitwise	1	位
178	block	1	块
179	body	1	身体
180	boolean	1	布尔
181	border	1	边境
182	brace	1	撐
183	bracket	1	支架
184	breakpoint	1	断点
185	bus	1	总线
186	business	1	业务
187	buttons	1	按钮
188	byte	1	字节
189	cache	1	缓存
190	callback	1	回调
191	candidate	1	候选
192	card	1	卡
193	chain	1	链
194	character	1	字符
195	checked	1	检查
196	child	1	子
197	cleanup	1	清理
198	clipboard	1	剪贴板
199	clone	1	克隆
200	collection	1	集合
201	combo	1	组合
202	command	1	命令
203	common	1	常见的
204	communication	1	沟通
205	compile	1	编译
206	compiler	1	编译器
207	component	1	组件
208	composition	1	作文
209	computer	1	电脑
210	computing	1	计算
211	concept	1	概念
212	concrete	1	具体
213	concurrent	1	并发
214	configuration	1	配置
215	connection	1	连接
216	console	1	控制台
217	const	1	常量
218	constraint	1	约束
219	construct	1	构造
220	constructor	1	构造函数
221	containment	1	容器
222	context	1	上下文
223	contract	1	合同、契约
224	control	1	控制
225	cover	1	覆盖、封面
226	create	1	创建
227	creation	1	创建
228	cursor	1	光标
229	custom	1	自定义
230	datagram	1	数据报
231	dead	1	死
232	debug	1	调试
233	debugger	1	调试器
234	default	1	默认的
235	defer	1	推迟
236	define	1	定义
237	delegate	1	委托
238	delegation	1	委托
239	demarshal	1	用于取消
240	derivation	1	推导
241	destroy	1	销毁
242	destructor	1	析构函数
243	device	1	设备
244	dialog	1	对话框
245	direction	1	方向
246	directive	1	指令
247	directory	1	目录
248	dispatch	1	调度
249	distributed	1	分:?^
250	document	1	文档
251	driven	1	驱动
252	driver	1	驱动器
253	dynamic	1	动态
254	efficiency	1	效率
255	efficient	1	高效
256	encapsulation	1	封装
257	enclosing	1	封闭
258	end	1	结束
259	entity	1	实体
260	enum	1	枚举
261	enumerators	1	枚举成员
262	equal	1	平等的
263	equivalence	1	等价
264	equivalent	1	等效
265	escape	1	逃避
266	evaluate	1	评估
267	head	1	头
268	high	1	高
269	in	1	在
270	item	1	顶
271	iteration	1	迭代
272	iterative	1	迭代
273	iterator	1	迭代器
274	laser	1	激光
275	lifetime	1	一生
276	line	1	行、线
277	link	1	链接
278	linker	1	链接器
279	literal	1	字面意义的
280	load	1	负载
281	loader	1	加载器
282	macro	1	宏
283	magic	1	魔法
284	maintain	1	维护
285	manipulator	1	操纵器
286	marshal	1	排列
287	mechanism	1	机制
288	memberwise	1	成员逐一
289	menu	1	菜单
290	meta	1	元
291	method	1	方法
292	micro	1	微
293	middleware	1	中间件
294	model	1	模型
295	modem	1	调制解调器
296	modifier	1	修怖符
297	module	1	模块
298	most	1	大多数
299	mouse	1	鼠标
300	multi	1	多
301	mutable	1	可变的
302	namespace	1	命名空间
303	native	1	本机、本地
304	nested	1	嵌套的
305	online	1	在线
306	opaque	1	不透明的
307	operand	1	操作数
308	operate	1	操作
309	operating	1	操作
310	operation	1	操作
311	option	1	选顶
312	ordinary	1	普通的
313	oriented	1	面向
314	overflow	1	溢出
315	overhead	1	开销
316	overload	1	重载
317	override	1	董写
318	package	1	包
319	pair	1	一对
320	palette	1	调色板
321	pane	1	窗格
322	parallel	1	平行
323	parent	1	父
324	parentheses	1	括号
325	parse	1	解析
326	part	1	部分
327	performance	1	性能
328	persistence	1	持久性
329	pixel	1	像素
330	platform	1	平台
331	poll	1	轮询、调查
332	polyiriorphism	1	多态性
333	pop	1	流行
334	port	1	端口
335	postfix	1	后缀
336	precedence	1	优先级
337	prefix	1	前缀
338	preprocessor	1	预处理器
339	prime	1	主要
340	primitive	1	原始的
341	print	1	打印
342	printer	1	打印机
343	priority	1	优先级
344	procedural	1	程序上的
345	procedure	1	过程
346	process	1	过程
347	profile	1	配取件
348	profiler	1	分析器
349	programmer	1	程序员
350	programming	1	编程
351	progress	1	进展
352	project	1	顶目
353	property	1	属性
354	protocol	1	协议
355	pseudo	1	伪
356	qualified	1	合格的
357	qualifier	1	限定符
358	quality	1	质量
359	queue	1	队列
360	radian	1	弧度
361	radio	1	单选、广播
362	raise	1	提高
363	random	1	随机
364	range	1	范围
365	rank	1	排名
366	raw	1	生
367	re	1	再保险
368	record	1	记录
369	recordset	1	记录集
370	refactoring	1	重构
371	reflection	1	反射
372	register	1	注册
373	relational	1	关系
374	represent	1	代表
375	resolve	1	解决
376	restriction	1	限制
377	robust	1	健壮的
378	robustness	1	鲁棒性
379	routine	1	例程、常规
380	rvalue	1	右值
381	save	1	保存
382	schedule	1	时间表、日程
383	scheduler	1	调度器
384	schema	1	模式、架构
385	scheme	1	模式、方案
386	screen	1	屏幕
387	scroll	1	滚动
388	semantics	1	语义
389	sequential	1	顺序、相继、序列
390	serial	1	串行
391	serialization	1	序列化
392	set	1	设置、集合
393	setter	1	设置器
394	signal	1	信号
395	signature	1	签名
396	slider	1	滑块
397	slot	1	槽
398	smart	1	智能的
399	snapshot	1	快照
400	software	1	软件
401	solution	1	解决方案
402	source	1	源
403	splitter	1	分离器
404	statement	1	声明
405	status	1	状态
406	stream	1	流
407	string	1	字符串
408	structure	1	结构
409	subscript	1	下标
410	subtype	1	子类型
411	support	1	支持
412	suspend	1	暂停
413	switch	1	开关、切换
414	symbol	1	符号、象征、标志
415	syntax	1	语袪
416	system	1	系统
417	tag	1	标签
418	target	1	目标
419	task	1	任务
420	tasking	1	任务
421	teirporary	1	临时
422	text	1	文本
423	time	1	时间
424	to	1	到、为
425	tree	1	树
426	unwinding	1	解除
427	up	1	向上
428	user	1	用户

工具介绍

AntConc 使用工具软件可以把一本电子档中的单词全部提取出来，并分析其出现频率

Java异常

 //算术异常    ArithmeticExecption     //空指针异常类    NullPointerException     //类型强制转换异常    ClassCastException     //数组负下标异常    NegativeArrayException     //数组下标越界异常    ArrayIndexOutOfBoundsException     //违背安全原则异常    SecturityException     //文件已结束异常    EOFException     //文件未找到异常    FileNotFoundException     //字符串转换为数字异常    NumberFormatException     //操作数据库异常    SQLException     //输入输出异常    IOException     //方法未找到异常    NoSuchMethodException     //抽象方法错误，当应用试图调用抽象方法时抛出     java.lang.AbstractMethodError     //断言错误，用来指示一个断言失败的情况    java.lang.AssertionError     //类循环依赖错误，若检测到类之间循环依赖则抛出该异常    java.lang.ClassCircularityError     //类格式错误    java.lang.ClassFormatError     //错误基类，标识严重程序运行问题，不应被应用程序捕获的反常情况    java.lang.Error     //非法访问错误，违反域或方法的可见性声明    java.lang.IllegalAccessError     //不兼容的类变化错误，当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常    java.lang.IncompatibleClassChangeError     //实例化错误，构造一个抽象类或者接口时抛出该异常    java.lang.InstantiationError     //内部错误    java.lang.InternalError     //链接错误    java.lang.LinkageError     //未找到类定义错误，找不到该类的定义时抛出该错误    java.lang.NoClassDefFoundError     //域（成员变量，字段）不存在错误    java.lang.NoSuchFieldError     //方法不存在错误    java.lang.NoSuchMethodError     //内存不足错误    java.lang.OutOfMemoryError     //堆栈溢出错误，如递归调用的层次太深    java.lang.StackOverflowError     //线程已结束    java.lang.ThreadDeath     //未知错误    java.lang.UnknownError     //未满足的链接错误    java.lang.UnsatisfiedLinkError     //不支持的类版本错误    java.lang.UnsupportedClassVersionError     //验证错误    java.lang.VerifyError     //虚拟机错误    java.lang.VirtualMachineError     //算术条件异常，如整数除零    java.lang.ArithmeticException     //数组索引越界异常    java.lang.ArrayIndexOutOfBoundsException     //数组存储异常，存放非数组声明类型    java.lang.ArrayStoreException     //类型转换异常    java.lang.ClassCastException     //找不到类异常    java.lang.ClassNotFoundException     //克隆不支持异常，如没有实现Cloneable接口    java.lang.CloneNotSupportedException     //枚举常量不存在异常    java.lang.EnumConstantNotPresentException     //根异常    java.lang.Exception     //非法访问异常    java.lang.IllegalAccessException     //非法的监控状态异常    java.lang.IllegalMonitorStateException     //非法的状态异常    java.lang.IllegalStateException     //非法的线程状态异常    java.lang.IllegalThreadStateException     //索引越界异常    java.lang.IndexOutOfBoundsException     //实例化异常    java.lang.InstantiationException     //被中断异常    java.lang.InterruptedException     //数组大小为负值异常    java.lang.NegativeArraySizeException     //属性不存在异常，当访问某个类的不存在的属性时抛出该异常    java.lang.NoSuchFieldException     //方法不存在异常    java.lang.NoSuchMethodException     //空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常    java.lang.NullPointerException     //数字格式异常    java.lang.NumberFormatException     //运行时异常    java.lang.RuntimeException     //安全异常    java.lang.SecurityException     //字符串索引越界异常    java.lang.StringIndexOutOfBoundsException     //类型不存在异常    java.lang.TypeNotPresentException     //不支持的方法异常    java.lang.UnsupportedOperationException     //Jsp页面异常    javax.servlet.jsp.JspException     //JSP引擎解析异常    org.apache.jasper.JasperException     //Servlet异常    javax.servlet.ServletException     //对象已被删除异常    org.hibernate.ObjectDeletedException

提高英文水平的建议与资源

提高英文水平的个人建议

(1)、自己起一个英文名称，作为网名和登录名。 (2)、将自己电脑中的中文版或汉化软件换成英文版，可以挑战一下英文操作系统，建议从英文手机系统开始。 (3)、选择一本适合自己的计算机英文教材。 (4)、保证一年至少读1-2本原版影印的计算机书，并坚持读完。 (5)、上网尽量多访问英文技术论坛和网站。不使用汉化帮助。 (6)、在程序中使用英文名称，坚持不用中文或汉语拼音作为变量名、字段名、文件和文件夹名（上过中文路径当的朋友是不是深有同感） (7)、每月至少看1-2部原版电影，双语初学，去字幕练习听力，反复。 (8)、每天坚持记录和复习遇到的生词，对于缩略语，一定要搞清楚每个英文字母的含义。 (9)、最重要的一条：相信自己能学会（世界上最难的中文你都可以学会英文肯定没问题）,遇到英文不逃避、坚持、重复、再坚持（制定计划）。 (10)、以前一段时间我很喜欢去Youtube看新闻与自己喜欢的节目，主要是看评论，原汁原味，还很有趣；后来就被墙了... 欢迎更多建议与方法，谢谢了！

翻译与双语视频字幕网站

http://fanyi.baidu.com/ 百度翻译，比以前要进步很多了，可以选择意思 http://fanyi.youdao.com/ 有道翻译，计算翻译比较准确 http://translate.google.cn/ google翻译，老牌翻译，大，强，但这几年变化不大 http://www.yinbiao5.com 音标网，支持批量单词音标 http://dict.cn/ 海词，例句多 http://assrt.net/ 射手网 双语字幕 http://www.zimuku.net/ 字幕库 http://subhd.com/main Sub HD 字幕站

Mybatis 执行后参数未拼接到 SQL语句中

Thu, 18 Apr 2019 15:02:22 GMT

每次生产有问题,看日志拿到sql,如果参数太多,把参数拼接到sql中费很长时间,于是写了一个小工具！

-----------------来自小马哥的故事

直接上代码

 package com.mantis.hc.sale.service.pay.util;   import java.awt.event.ActionEvent;  import java.awt.event.ActionListener; import java.util.regex.Matcher; import java.util.regex.Pattern;  import javax.swing.*;  public class sqlTools extends JFrame implements ActionListener {         private JPanel jp=new JPanel();      private JLabel[] jlArray={new JLabel("SQL"),              new JLabel("字段值"),new JLabel("结果"),new JLabel("") };      private JButton[] jbArray={new JButton("执行"),              new JButton("清空")};      private JTextField jtxtSql =new JTextField();      private JTextField JTextValue= new JTextField();       private JTextArea resultSQL= new JTextArea();      public sqlTools(){         jp.setLayout(null);          for(int i=0;i<2;i++){              jlArray[i].setBounds(30, 20+i*50, 80, 26);              jbArray[i].setBounds(120+i*110, 660, 80,26);              jp.add(jlArray[i]);              jp.add(jbArray[i]);              jbArray[i].addActionListener(this);          }           for(int i=2;i<3;i++){              jlArray[i].setBounds(30, 20+i*50, 80, 26);              jp.add(jlArray[i]);         }         jtxtSql.setBounds(80,20,500,30);         jp.add(jtxtSql);         jtxtSql.addActionListener(this);         JTextValue.setBounds(80,70,500,30);         jp.add(JTextValue);         JTextValue.addActionListener(this);         resultSQL.setBounds(80,120,500,500);         resultSQL.setLineWrap(true);         jp.add(resultSQL);         jlArray[3].setBounds(10, 250, 700, 30);         jp.add(jlArray[3]);         this.add(jp);         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);         this.setTitle("小马哥工具");         this.setResizable(false);         this.setBounds(100, 230, 700, 800);         this.setVisible(true);      }       public void actionPerformed(ActionEvent e){            if(jtxtSql.getText().equals("")&&String.valueOf(JTextValue.getText()).equals("")){              resultSQL.setText("参数不能为空!,请重新参数!");          }else{              try{                 String resultStr =  getResultSQL(jtxtSql.getText(),JTextValue.getText());                 resultSQL.setText(resultStr);             }catch (Exception a){                 System.out.println(a.getMessage());                 resultSQL.setText("参数错误,请检查参数!");             }          }      }      //主函数入口     public static void main(String[] args) {          new sqlTools();      }             public static  String getResultSQL(String  text,String  str) {          Pattern pattern = Pattern.compile("\\?");         StringBuffer buffer = new StringBuffer();          //参数转换成数组         String[] words = ClearBracket(str).split(",");         for (int i = 0; i < words.length; i++) {              Matcher matcher = pattern.matcher(text);             while (matcher.find()) {                 //?号 替换成数据中对应的数据                 matcher.appendReplacement(buffer, "'"+words[i++].trim()+"'");             }             matcher.appendTail(buffer);         }          return buffer.toString();       }         //删除括号及括号中的数据     private static String ClearBracket(String context) {         String pattern = "\\([^)]*\\)";         context = context.replaceAll(pattern, "");         return context;     }          }

生成class 文件

javac ResSql.java

打包成jar

jar cvf sqlTools.jar ResSql.class

修改 MANIFEST.MF 文件

 Manifest-Version: 1.0 Created-By: 1.8.0_131 (Oracle Corporation) Main-Class: ResSql

打包压缩 ZIP 修改后缀 JAR

编写Bat文件

 @echo off  SET javaw="%JAVA_HOME%\bin\javaw"  start javaw -jar "sqlTools.jar"   exit

sql语句的执行顺序以及流程（详细掌握）

Sun, 24 Feb 2019 14:50:00 GMT

程序员对sql语句的执行顺序的透彻掌握，是避免编程中各种bug和错误，歧义语句的不二法则。

-----------------来自小马哥的故事

SQL Select 语句完整的执行顺序：

1、from 子句组装来自不同数据源的数据； 2、where 子句基于指定的条件对记录行进行筛选；  3、group by 子句将数据划分为多个分组；  4、使用聚集函数进行计算；  5、使用 having 子句筛选分组；  6、计算所有的表达式；  7、select 的字段；  8、使用 order by 对结果集进行排序。

SQL 语言不同于其他编程语言的最明显特征是处理代码的顺序。在大多数据库语言中，代码按编码顺序被处理。但在 SQL 语句中，第一个被处理的子句式 FROM，而不是第一出现的 SELECT。

SQL 查询处理的步骤序号：

(1) FROM <left_table>  (2) <join_type> JOIN <right_table>  (3) ON <join_condition>  (4) WHERE <where_condition>  (5) GROUP BY <group_by_list> (6) WITH {CUBE | ROLLUP}  (7) HAVING <having_condition>  (8) SELECT (9) DISTINCT  (9) ORDER BY <order_by_list>  (10) <TOP_specification> <select_list>

以上每个步骤都会产生一个虚拟表，该虚拟表被用作下一个步骤的输入。这些虚拟表对调用者(客户端应用程序或者外部查询)不可用。只有最后一步生成的表才会会给调用者。如果没有在查询中指定某一个子句，将跳过相应的步骤。

逻辑查询处理阶段简介：

1、 FROM：对 FROM 子句中的前两个表执行笛卡尔积(交叉联接)，生成虚拟表 VT1。  2、 ON：对 VT1 应用 ON 筛选器，只有那些使为真才被插入到 TV2。   3、 OUTER (JOIN):如果指定了 OUTER JOIN(相对于 CROSS JOIN 或 INNER JOIN)，保留表中未找到 匹配的行将作为外部行添加到 VT2，生成 TV3。如果 FROM 子句包含两个以上的表，则对上一个联接生成的 结果表和下一个表重复执行步骤 1 到步骤 3，直到处理完所有的表位置。  4、 WHERE：对 TV3 应用 WHERE 筛选器，只有使为 true 的行才插入 TV4。   5、 GROUP BY：按 GROUP BY 子句中的列列表对 TV4 中的行进行分组，生成 TV5。   6、 CUTE|ROLLUP：把超组插入 VT5，生成 VT6。   7、 HAVING：对 VT6 应用 HAVING 筛选器，只有使为 true 的组插入到 VT7。   8、 SELECT：处理 SELECT 列表，产生 VT8。   9、 DISTINCT：将重复的行从 VT8 中删除，产品 VT9。  10、 ORDER BY：将 VT9 中的行按 ORDER BY 子句中的列列表顺序，生成一个游标(VC10)。   11、 TOP：从 VC10 的开始处选择指定数量或比例的行，生成表 TV11，并返回给调用者。 where 子句中的条件书写顺序

Linux中执行脚本No such file or directory。

Mon, 18 Feb 2019 14:49:00 GMT

一、分析

这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。

二、解决

1）在windows下转换：利用一些编辑器如UltraEdit或EditPlus等工具先将脚本编码转换，再放到Linux中执行。转换方式如下（UltraEdit）：File–>Conversions–>DOS->UNIX即可。

2）直接在Linux中转换（推荐做法）：

首先要确保文件有可执行权限

#sh> chmod a+x filename 1

然后修改文件格式

#sh> vi filename 1

利用如下命令查看文件格式

:set ff 或 :set fileformat 1

可以看到如下信息

fileformat=dos 或 fileformat=unix

利用如下命令修改文件格式

:set ff=unix 或 :set fileformat=unix  :wq (存盘退出)

最后再执行文件

#sh>./filename

今天遇到的一个奇葩的NoClassFound的问题

Mon, 03 Sep 2018 02:34:44 GMT

with root cause java.lang.NoClassDefFoundError

-----------------来自小马哥的故事

nohup的日志中报错

java.lang.NoClassDefFoundError: org/apache/catalina/core/ApplicationContext$DispatchData  2018-09-01 20:21:55.017 |-ERROR [http-nio-28082-exec-9] org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].[dispatcherServlet] [181] -| Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Filter execution threw an exception] with root cause java.lang.NoClassDefFoundError: org/springframework/boot/actuate/trace/WebRequestTraceFilter$CustomStatusResponseWrapper

最后居然是因为该jar是root用户启动的, 而Jenkins上使用的是rc用户,Jenkins部署的时候无法通过rc将该进程杀死.但是有的接口是OK的,有的接口就会报上面的问题

将该进程杀死,用Jenkins启动后,一切正常.

Mysql 根据时间戳按年月日分组统计(做个收藏)

Sat, 18 Aug 2018 07:14:56 GMT

Mysql 根据时间戳按年月日分组统计

-----------------来自小马哥的故事

        create_time时间格式          SELECT DATE_FORMAT(create_time,'%Y%u') weeks,COUNT(id) COUNT FROM role GROUP BY weeks;          SELECT DATE_FORMAT(create_time,'%Y%m%d') days,COUNT(id) COUNT FROM role GROUP BY days;          SELECT DATE_FORMAT(create_time,'%Y%m') months,COUNT(id) COUNT FROM role GROUP BY months                    create_time时间戳格式          SELECT FROM_UNIXTIME(create_time,'%Y%u') weeks,COUNT(id) COUNT FROM role GROUP BY weeks;          SELECT FROM_UNIXTIME(create_time,'%Y%m%d') days,COUNT(id) COUNT FROM role GROUP BY days;          SELECT FROM_UNIXTIME(create_time,'%Y%m') months,COUNT(id) COUNT FROM role GROUP BY months

对list中的对象属性排序

Wed, 18 Jul 2018 11:53:00 GMT

对list中的对象属性排序

今天遇到一个排序问题觉得挺值得分享的，一个集合，集合存储着若干对象，对象有若干属性，希望按照对象的某个属性排序，排序完成，list的存储顺序也是按照这个属性排完以后的顺序。

-----------------来自小马哥的故事

代码如下：

     public class User {  private String username;  private int age;    public String getUsername() {      return username;  }    public void setUsername(String username) {      this.username = username;  }    public int getAge() {      return age;  }    public void setAge(int age) {      this.age = age;  }    public User() {  }  }    public class ListSortTest {  public static void main(String args[]){      List<User> userlist=new ArrayList<User>();      User user1=new User();      User user2=new User();      User user3=new User();      User user4=new User();      user1.setAge(10);      userlist.add(user1);      user2.setAge(34);      userlist.add(user2);      user3.setAge(19);      userlist.add(user3);      user4.setAge(6);      userlist.add(user4);      System.out.println("排序前");      for(User user:userlist){            System.out.print(user.getAge() + "-");      }      System.out.println("\n");      System.out.println("排序后");      for(User user:getSortList(userlist)){          System.out.print(user.getAge() + "-");      }    }    public static List<User> getSortList(List<User> list){      Collections.sort(list, new Comparator<User>() {          @Override          public int compare(User o1, User o2) {              if(o1.getAge()>o2.getAge()){                  return 1;              }              if(o1.getAge()==o2.getAge()){                  return 0;              }              return -1;          }      });      return list;  }  }

输出结果：

排序前 10-34-19-6-   排序后 6-10-19-34-

我们再来看一下它实现的代码：

  public static <T> void sort(List<T> list, Comparator<? super T> c) {      Object[] a = list.toArray();      Arrays.sort(a, (Comparator)c);      ListIterator i = list.listIterator();      for (int j=0; j<a.length; j++) {          i.next();          i.set(a[j]);      }  }

而Arrays.sort使用的是冒泡和归并排序，默认是归并排序，所以排序速度还是很快的.

Java并发问题总结

Tue, 17 Apr 2018 07:14:00 GMT

Java并发问题总结!

-----------------来自小马哥的故事

Java内存模型

所有变量都存储在主内存中。这里的主内存只是虚拟机内存的一部分，可以和物理主内存类比。每条线程都有自己的工作内存。工作内存可以和处理器高速缓存类比。工作内存中保存了主内存中变量的拷贝，线程所有的操作只能在工作内存中进行，不同线程不能访问对方的工作内存，只能通过更新到主内存中的方式来传递线程间的变量值。

主内存与工作内存间的交互操作都具有原子性，包括

其中read和load之间，store和write之间必须按顺序执行，但是不要求连续执行，即中间可以插入其他指令。

并发的三个问题

原子性

指的是不能被线程调度机制中断的操作，它会在上下文切换之前执行完毕。由于read，load，store，write，use，assign都能够保证原子性，故对一个基本类型变量的访问和赋值可以看作原子操作。对于synchronized块之间的操作也具有原子性。

x = 1; // 具有原子性 y = x; // 2个指令，use了x的值，再assign到y x++; // 4个指令，use了x的值，生成常数1，x加1，再assign到x

可见性

指的是当一个线程修改了共享变量值，其他线程能够立即得知这个修改。

普通变量的修改首先发生在本线程的工作内存中，这会导致各个工作内存的不一致性。当一个线程结束后会将各自的工作内存同步回主内存，另一个线程读取这个变量时会从主内存中读取它的新值。

volatile变量也是同样的过程，只是它修改后立即同步回主内存，并通知其他工作内存中的此变量失效。如果其他线程需要使用此变量时，只能从主内存中重新读取它的新值。这就保证了多线程下的变量可见性。

synchronized同步块也具有可见性。这是由于对一个变量unlock之前，必须先将它同步回主内存中。

final修饰的变量也具有可见性。当一个final变量被初始化后(构造器完成之前没有将this引用传递出去)，此变量在其他线程中可见。

有序性

指的是机器会对指令进行重排序来达到运行时的优化。这就导致了代码书写上的先后顺序不能在执行时得到保证，但是在单线程内看，程序执行的结果和按照串行执行的结果保持一致。而使用多线程时执行结果就不能保证了。Java可以有两种方法保证线程间的有序性

volatile可以防止指令随意的重排序，它的作用相当于一个内存屏障，也就是重排序时不能将内存屏障之后的指令排在它之前。

synchronized同步块可以保证有序，是因为同一时刻只允许一个线程对某个变量进行lock操作。因此多个线程只能有序的进入同一个同步块。

volatile关键字

volatile是最轻量级的同步机制，但是它只保证了被修饰变量的可见性和有序性，而不能保证原子性，从而不能解决很多并发同步问题。

具有两个特性

可见性，一旦某个线程中的volatile变量被修改，即store和write 指令执行后，所有线程都可以得到最新的变量值。注意这里是指令执行，而不是Java的语句执行，一条非原子性的Java语句总是对应多条指令，所以这条语句所带来的改变不具有可见性。有序性，防止指令随意的重排序优化。通过在汇编代码中加入lock操作，使变量的修改写回主内存，即执行了store和write指令。这意味着写之前的所有操作都必须执行完成，从而达到了内存屏障的作用。同时它还会使其他工作内存中的该变量无效，其他线程需要重新从主内存中读取此变量。

应用场合

由于volatile能够保证可见性和有序性，唯一不能保证原子性，因此如果一个操作本身具有原子性，那么使用volatile修饰后就可以保证并发的同步性。应用场合有两个

变量的赋值不依赖于它的当前值或别的变量的当前值，即直接使用assign指令而没有使用use指令，具有原子性保证只有一个线程对变量进行修改，而别的线程只进行读取，读取值不一定是最新的，但修改不会出错

synchronized关键字

可以解决所有并发问题，但是容易造成滥用而导致并发性能不高。可以作为方法的修饰符，表示要进入方法时需要获取本对象的锁，也可以使用synchronized(object){...}对代码块加锁，表示要进入代码块时需要获取object的锁。一旦有一个线程获取了锁而进入了同步块中，所有的其他线程都会进入等锁池而阻塞。这有时会导致不必要的阻塞时间。同时，Java线程是映射到操作系统原生线程上的，阻塞和唤醒都需要从用户态转换到内核态，要花费较多处理器时间。而volatile变量的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

重入锁ReentrantLock

ReentrantLock可以显式的创建，锁定和释放，与synchronized的内建锁复杂但是更灵活，尤其是进入同步块后如果抛出异常，可以进行清理工作。另外还可以实现一些高级功能，包括等待可中断（线程可以放弃等待而做其他事情），公平锁（按照申请锁的时间获取锁），多条件绑定（通过调用newCondition()方法添加多个Condition）。

 Lock lock = new ReentrantLock(); lock.lock(); try {     ... } finally {     lock.unlock(); }  ReentrantLock lock = new ReentrantLock(); boolean captured = lock.tryLock(); try {     ... } finally {     if (captured) lock.unlock(); }

Atomic类

加锁属于阻塞同步，即无论共享数据是否真的出现竞争都会加锁，这是悲观的并发策略。而利用硬件指令还可以实现非阻塞同步，这是一种基于冲突检测的乐观并发策略。它可以先操作，如果没有其他线程争用共享数据则操作成功，而如果产生了冲突，则不断重试直到操作成功。这涉及一条处理器指令compare-and-swap（CAS），它具有原子性，表示变量符合旧值时才会用新值更新变量，否则不更新，最后都返回旧值。例如Java8中AtomicInteger类的incrementAndGet()方法，会用到sun/misc/Unsafe类中的getAndAddInt()方法，其中的compareAndSwapInt()就是CAS操作。下述代码的意义是对于实例var1在偏移var2处的旧值为var5，如果即将要赋值的时候发现获取的值不符合var5（CAS指令操作），说明此时有其他线程已经修改了这个变量，于是继续获取新的var5，直到赋值前获取的值符合var5，则用var5+var4更新var5。

 public final int getAndAddInt(Object var1, long var2, int var4) {         int var5;         do {             var5 = this.getIntVolatile(var1, var2);         } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));          return var5;     }

不使用同步的情况

可重入代码不需要同步，因为它不使用共享变量，且所有的状态量都由参数传入，所以在任何时刻中断它再返回后不会出现错误，这就保证了线程安全。

如果能保证共享变量只在一个线程中可见，同样也不需要同步，但是这样的应用比较少见。

利用ThreadLocal可以根除了对变量的共享，它可以为使用相同变量的每个线程创建不同的存储。每个线程使用的都是独立的变量，当然不会有同步的问题。但是一个线程是不能访问到另一个线程的ThreadLocal变量，尽管只创建过一个ThreadLocal变量的实例。一个线程只能使用get和set改变本线程内该变量的值，不同线程中该变量值互不影响。具体实现中，每个Thread线程对象都由一个ThreadLocal.ThreadLocalMap，其键为ThreadLocal.ThreadLocalHashCode，值就是本地线程变量，各个线程的Map是独立的。

锁优化

自旋锁

阻塞线程比较耗时，是因为挂起和恢复线程都需要转换内核态，而锁定共享数据往往只持续很短的时间。因此有时只需要让线程执行一个忙循环（自旋）等待，但是不放弃处理器执行，就可以获取锁。前提是等待时间不能太长，自适应自旋锁可以调整自旋的时间。

锁消除

如果代码上要求同步，但是经过逃逸分析发现不可能存在共享数据竞争，因而可以将锁进行消除。有些代码的同步可能不是人为加入的，而是源码自带的。

锁粗化

如果一系列加锁和解锁是对同一个对象连续进行的，就可以将同步范围扩大到整个序列的外部，这样就可以进行一次加锁和解锁了。

轻量级锁

认为大部分锁在同步时间内是不存在竞争的。通过利用对象头信息Mark Word和CAS操作判断对象是否加锁，如果没有，则直接进入同步块执行，这个判断过程就是轻量级锁；否则说明的这个加锁的对象有竞争，轻量级锁就要膨胀为重量级锁，也就是使用互斥量的一般锁。解锁也要使用CAS操作，将原来的Mark Word的记录替换回来，如果替换成功说明在此期间没有线程尝试过获取该锁，从而解锁完成；如果失败，则一定有线程尝试过获取该锁，所以在解锁完成后还要唤醒等锁的线程。

偏向锁

在轻量级锁的基础上，如果没有竞争，线程将CAS操作也取消，且这个偏向锁会偏向第一个获得它的线程。如果执行过程中该锁没有被其他线程获取，则持有偏向锁的线程永远不用同步。但是一旦有线程尝试获取该锁时，偏向模式被撤销，将锁对象恢复为未锁定或者轻量级锁。

HashMap底层实现详解

Tue, 17 Apr 2018 06:57:00 GMT

前段时间面试无论是58,还是京东还是阿里都问了Map的底层实现,小马哥又仔细看了看源码!

-----------------来自小马哥的故事

HashMap概述：

　　HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap的数据结构：

　　在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表的数组”的数据结构，每个元素存放链表头结点的数组，即数组和链表的结合体。

从上图中可以看出，HashMap底层就是一个数组，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。源码如下：

 /**   * The table, resized as necessary. Length MUST Always be a power of two.   */   transient Entry[] table;      static class Entry<K,V> implements Map.Entry<K,V> {       final K key;       V value;       Entry<K,V> next;       final int hash;       ……   }

可以看出，Entry就是数组中的元素，每个Map.Entry就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

HashMap的存取实现：

存储

public V put(K key, V value) {       // HashMap允许存放null键和null值。       // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。       if (key == null)           return putForNullKey(value);       // 根据key的hashCode重新计算hash值。       int hash = hash(key.hashCode());       // 搜索指定hash值所对应table中的索引。       int i = indexFor(hash, table.length);       // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。       for (Entry<K,V> e = table[i]; e != null; e = e.next) {           Object k;           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {               V oldValue = e.value;               e.value = value;               e.recordAccess(this);               return oldValue;           }       }       // 如果i索引处的Entry为null，表明此处还没有Entry。       // modCount记录HashMap中修改结构的次数       modCount++;       // 将key、value添加到i索引处。       addEntry(hash, key, value, i);       return null;   }

从上面的源代码中可以看出：当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。

　　addEntry(hash, key, value, i)方法根据计算出的hash值，将key-value对放在数组table的 i 索引处。addEntry 是HashMap 提供的一个包访问权限的方法（就是没有public，protected，private这三个访问权限修饰词修饰，为默认的访问权限，用default表示，但在代码中没有这个default），代码如下：

 void addEntry(int hash, K key, V value, int bucketIndex) {       // 获取指定 bucketIndex 索引处的 Entry        Entry<K,V> e = table[bucketIndex];       // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry       table[bucketIndex] = new Entry<K,V>(hash, key, value, e);       // 如果 Map 中的 key-value 对的数量超过了极限       if (size++ >= threshold)       // 把 table 对象的长度扩充到原来的2倍。           resize(2 * table.length);   }

当系统决定存储HashMap中的key-value对时，完全没有考虑Entry中的value，仅仅只是根据key来计算并决定每个Entry的存储位置。我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。

　　hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。

 static int hash(int h) {       h ^= (h >>> 20) ^ (h >>> 12);       return h ^ (h >>> 7) ^ (h >>> 4);   }

我们可以看到在HashMap中要找到某个元素，需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。前面说过HashMap的数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表，这样就大大优化了查询的效率。

　　对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 hash 码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，“模”运算的消耗还是比较大的，在HashMap中是这样做的：调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) 方法的代码如下：

 static int indexFor(int h, int length) {       return h & (length-1);   }

这个方法非常巧妙，它通过 h & (table.length -1) 来得到该对象的保存位，而HashMap底层数组的长度总是 2 的n 次方，这是HashMap在速度上的优化。在 HashMap 构造器中有如下代码：

这段代码保证初始化时HashMap的容量总是2的n次方，即底层数组的长度总是为2的n次方。

　　当length总是 2 的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。

　　这看上去很简单，其实比较有玄机的，我们举个例子来说明：

　　假设数组长度分别为15和16，优化后的hash码分别为8和9，那么&运算后的结果如下：

   h & (table.length-1)                     hash                             table.length-1     8 & (15-1)：                                 0100                   &              1110                   =                0100     9 & (15-1)：                                 0101                   &              1110                   =                0100    -----------------------------------------------------------------------------------------------------------------------     8 & (16-1)：                                 0100                   &              1111                   =                0100     9 & (16-1)：                                 0101                   &              1111                   =                0101    -----------------------------------------------------------------------------------------------------------------------

从上面的例子中可以看出：当8、9两个数和(15-1)2=(1110)进行“与运算&”的时候，产生了相同的结果，都为0100，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hash值会与(15-1)2=(1110)进行“与运算&”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！

　　而当数组长度为16时，即为2的n次方时，2n-1得到的二进制数的每个位上的值都为1（比如(24-1)2=1111），这使得在低位上&时，得到的和原hash的低位相同，加之hash(int h)方法对key的hashCode的进一步优化，加入了高位计算，就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。

　　所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。

　　根据上面 put 方法的源代码可以看出，当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有Entry 的 value，但key不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部——具体说明继续看 addEntry() 方法的说明。

读取：

 public V get(Object key) {       if (key == null)           return getForNullKey();       int hash = hash(key.hashCode());       for (Entry<K,V> e = table[indexFor(hash, table.length)];           e != null;           e = e.next) {           Object k;           if (e.hash == hash && ((k = e.key) == key || key.equals(k)))               return e.value;       }       return null;   }

有了上面存储时的hash算法作为基础，理解起来这段代码就很容易了。从上面的源代码中可以看出：从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。

HashMap的resize（rehash）：

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

　　那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过160.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

HashMap扩容的代码如下所示：

 //HashMap数组扩容             void resize(int newCapacity) {                   Entry[] oldTable = table;                   int oldCapacity = oldTable.length;                   //如果当前的数组长度已经达到最大值，则不在进行调整                   if (oldCapacity == MAXIMUM_CAPACITY) {                       threshold = Integer.MAX_VALUE;                       return;                   }                   //根据传入参数的长度定义新的数组                   Entry[] newTable = new Entry[newCapacity];                   //按照新的规则，将旧数组中的元素转移到新数组中                   transfer(newTable);                   table = newTable;                   //更新临界值                   threshold = (int)(newCapacity * loadFactor);               }                //旧数组中元素往新数组中迁移               void transfer(Entry[] newTable) {                   //旧数组                   Entry[] src = table;                   //新数组长度                   int newCapacity = newTable.length;                   //遍历旧数组                   for (int j = 0; j < src.length; j++) {                       Entry<K,V> e = src[j];                       if (e != null) {                           src[j] = null;                           do {                               Entry<K,V> next = e.next;                               int i = indexFor(e.hash, newCapacity);                               e.next = newTable[i];                               newTable[i] = e;                               e = next;                           } while (e != null);                       }                   }               }

HashMap的性能参数：

HashMap 包含如下几个构造器：

HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。 HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。 HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。 HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。 initialCapacity：HashMap的最大容量，即为底层数组的长度。 loadFactor：负载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。　　负载因子衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。

　　HashMap的实现中，通过threshold字段来判断HashMap的最大容量：

threshold = (int)(capacity * loadFactor);

结合负载因子的定义公式可知，threshold就是在此loadFactor和capacity对应下允许的最大元素数目，超过这个数目就重新resize，以降低实际的负载因子（也就是说虽然数组长度是capacity，但其扩容的临界值确是threshold）。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时， resize后的HashMap容量是容量的两倍：

if (size++ >= threshold)     resize(2 * table.length);

Fail-Fast机制：

　　我们知道java.util.HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。（这个在core java这本书中也有提到。）

　　这一策略在源码中的实现是通过modCount域，modCount顾名思义就是修改次数，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。

 HashIterator() {       expectedModCount = modCount;       if (size > 0) { // advance to first entry       Entry[] t = table;       while (index < t.length && (next = t[index++]) == null)           ;       }   }

在迭代过程中，判断modCount跟expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map：

　　注意到modCount声明为volatile，保证线程之间修改的可见性。（volatile之所以线程安全是因为被volatile修饰的变量不保存缓存，直接在内存中修改，因此能够保证线程之间修改的可见性）。

 final Entry<K,V> nextEntry() {        if (modCount != expectedModCount)            throw new ConcurrentModificationException();

在HashMap的API中指出：

　　由所有HashMap类的“collection 视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不保证在将来不确定的时间发生任意不确定行为的风险。

　　注意，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

String转换成Integer源码分析

Thu, 22 Mar 2018 08:29:26 GMT

我们经常为用到Integer.valueOf(String str)这个方法,如果字符串格式不对,这个方法会抛出一个系统异常NumberFormatException 这里我们就要分析一下这个方法,其中Byte,Short也是调用了Ingeter中的方法. 在Integer类中的定义如下:

public static Integer valueOf(String s) throws NumberFormatException     {  return new Integer(parseInt(s, 10));     }

这里因为parseInt方法返回的int型的,这里调用了一个构造函数产生了一个新的Integer实例. 这里关心的是parseInt方法,该方法代码如下:

public static int parseInt(String s, int radix)   throws NumberFormatException     {         if (s == null) {             throw new NumberFormatException("null");         }   if (radix < Character.MIN_RADIX) {      throw new NumberFormatException("radix " + radix +          " less than Character.MIN_RADIX");  }   if (radix > Character.MAX_RADIX) {      throw new NumberFormatException("radix " + radix +          " greater than Character.MAX_RADIX");  }   int result = 0;  boolean negative = false;  int i = 0, max = s.length();  int limit;  int multmin;  int digit;   if (max > 0) {      if (s.charAt(0) == '-') {   negative = true;   limit = Integer.MIN_VALUE;   i++;      } else {   limit = -Integer.MAX_VALUE;      }       if (i < max) {   digit = Character.digit(s.charAt(i++),radix);   if (digit < 0) {       throw NumberFormatException.forInputString(s);   } else {       result = -digit;   }      }      while (i < max) {   // Accumulating negatively avoids surprises near MAX_VALUE   digit = Character.digit(s.charAt(i++),radix);   if (digit < 0) {       throw NumberFormatException.forInputString(s);    }   if (result < multmin) {       throw NumberFormatException.forInputString(s);  异常1   }   result *= radix;   if (result < limit + digit) {       throw NumberFormatException.forInputString(s);  异常2   }   result -= digit;      }  } else {      throw NumberFormatException.forInputString(s);  }   if (negative) {      if (i > 1) {   return result;      } else { /* Only got "-" */   throw NumberFormatException.forInputString(s);      }  } else {      return -result;  }     }

很显然,该方法的第二个参数表示是基数(最常用的是十进制,还有十六机制,八进制等等).

如果字符串是空指针,直接抛出异常.

如果基础小于2或者大于36的话,抛出异常(这种情况一般不会出现,因为我们用的最多就是十进制的了).

如果是空字符串,也抛出异常,也就是max=0的情况了.

我们来关注下面的转换过程:

这里使用了Character中的静态方法digit,这个方法比较复杂,这里先说明它的功能:对于给定的基数,如果是合法的字符(可以转化为数字),返回该数字值,否则返回-1.比如digit('3',10)返回3,digit('a',10)返回-1.

这段程序看起来很简单,其实还真不容易看懂,这里先说明几个局部变量的含义吧:

result:记录返回值

negative:符号标志

i:字符串位置

s:字符串长度

limit:界限

multmin:也是一个界限

digit:当前字符表示的数字

先看第一个字符是否是'-'号,设定符号标志negative和极限值limit.

注意到limit一定是一个负值.

处理最高位,这里result保存的是负值,这样就可以对正负数统一处理.

关键就是这个while循环了,第一个if不用解释了,肯定是因为非法字符.

第二个if语句的含义:如果result小于multmin,会产生什么结果呢?

是不是一定会溢出呢?假设不会溢出,就是说结果必须>=limit.

result小于multmin,result至少应该位multmin-1,后面有 result=result*radix=(multmin-1)radix=multminradix-radix

该值肯定小于limit,其中multmin=limit/radix,注意这里都是负数.

所以假设不成里,如果result小于multmin的话,后面一定会溢出.

如果这里没有判断的话,溢出就麻烦了,正数也会变负数了.

第三个if语句的含义:在这条语句以前肯定没有溢出,但是有可能加上最后一位digit就溢出了,所以这个判断也是必要的.

后面的就比较好理解了,else是表示空字符串"".

如果是负数的还要看是否长度是1,就只是一个'-'号的情况.

如果是正数的话返回相反数就可以了.

这里有好多地方都有可能抛出异常,只要看明白了程序就知道这个异常是那条语句抛出的了,这里考虑溢出异常:异常1和异常2.

Ingeter.Max_VALUE=2147483647

下面的两条语句在不同的地方抛出异常.

Ingeter.valueOf("2147483648");这个在异常2抛出的.

Ingeter.valueOf("21474836471");这个在异常1抛出的.

这里简单的分析了String转化为Ingeter的过程,其实整个Ingeter类也就主要是这个方法了,Byte和Short都是调用这个方法的. 看看Byte的代码:

public static byte parseByte(String s, int radix)  throws NumberFormatException {  int i = Integer.parseInt(s, radix);  if (i < MIN_VALUE || i > MAX_VALUE)      throw new NumberFormatException(                 "Value out of range. Value:/"" + s + "/" Radix:" + radix);  return (byte)i;    }

了解这个方法后就再也不会为Integer.valueOf()产生的异常感到意外了,特别是在JSP中,因为参数都是String型的,转换的时候动不动就出现异

常,你该知道怎么回事了吧.

JVM运行原理详解

Wed, 21 Mar 2018 01:20:00 GMT

作为一名Java使用者，掌握JVM的体系结构也是很有必要的

-----------------来自小马哥的故事

1.JVM简析：

说起Java，我们首先想到的是Java编程语言，然而事实上，Java是一种技术，它由四方面组成：Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。它们的关系如下图所示：

Java平台由Java虚拟机和Java应用程序接口搭建，Java语言则是进入这个平台的通道，用Java语言编写并编译的程序可以运行在这个平台上。这个平台的结构如下图所示：运行期环境代表着Java平台，开发人员编写Java代码(.java文件)，然后将之编译成字节码(.class文件)，再然后字节码被装入内存，一旦字节码进入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的转换成机器码执行。

JVM在它的生存周期中有一个明确的任务，那就是运行Java程序，因此当Java程序启动的时候，就产生JVM的一个实例；当程序运行结束的时候，该实例也跟着消失了。在Java平台的结构中, 可以看出，Java虚拟机(JVM) 处在核心的位置，是程序与底层操作系统和硬件无关的关键。它的下方是移植接口，移植接口由两部分组成：适配器和Java操作系统, 其中依赖于平台的部分称为适配器；JVM 通过移植接口在具体的平台和操作系统上实现；在JVM 的上方是Java的基本类库和扩展类库以及它们的API，利用Java API编写的应用程序(application) 和小程序(Java applet) 可以在任何Java平台上运行而无需考虑底层平台, 就是因为有Java虚拟机(JVM)实现了程序与操作系统的分离，从而实现了Java 的平台无关性。

下面我们从JVM的基本概念和运过程程这两个方面入手来对它进行深入的研究。*

2.JVM基本概念

(1) 基本概念：

JVM是可运行Java代码的假想计算机，包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收，堆和一个存储方法域。JVM是运行在操作系统之上的，它与硬件没有直接的交互。

(2) 运行过程：

我们都知道Java源文件，通过编译器，能够生产相应的.Class文件，也就是字节码文件，而字节码文件又通过Java虚拟机中的解释器，编译成特定机器上的机器码。

也就是如下：

① Java源文件—->编译器—->字节码文件

② 字节码文件—->JVM—->机器码

每一种平台的解释器是不同的，但是实现的虚拟机是相同的，这也就是Java为什么能够跨平台的原因了，当一个程序从开始运行，这时虚拟机就开始实例化了，多个程序启动就会存在多个虚拟机实例。程序退出或者关闭，则虚拟机实例消亡，多个虚拟机实例之间数据不能共享。

类加载详细过程

一个Java文件从编码完成到最终执行，一般主要包括两个过程编译和运行

编译:把我们写好的java文件，通过javac命令编译成字节码，也就是我们常说的.class文件。
运行:是把编译生成的.class文件交给Java虚拟机(JVM)执行。

而我们所说的类加载过程即是指JVM虚拟机把.class文件中类信息加载进内存，并进行解析生成对应的class对象的过程。

举个通俗点的例子来说，JVM在执行某段代码时，遇到了class A，然而此时内存中并没有class A的相关信息，于是JVM就会到相应的class文件中去寻找class A的类信息，并加载进内存中，这就是我们所说的类加载过程。

由此可见，JVM不是一开始就把所有的类都加载进内存中，而是只有第一次遇到某个需要运行的类时才会加载，且只加载一次。

类加载

类加载的过程主要分为三个部分：”加载”,””链接”,”“初始化”

而链接又可以细分为三个小部分：”验证”,”准备”,”解析”

加载

简单来说，加载指的是把class字节码文件从各个来源通过类加载器装载入内存中。

这里有两个重点：

字节码来源。一般的加载来源包括从本地路径下编译生成的.class文件，从jar包中的.class文件，从远程网络，以及动态代理实时编译
类加载器。一般包括启动类加载器，扩展类加载器，应用类加载器，以及用户的自定义类加载器。

为什么会有自定义类加载器？

一方面是由于java代码很容易被反编译，如果需要对自己的代码加密的话，可以对编译后的代码进行加密，然后再通过实现自己的自定义类加载器进行解密，最后再加载。

另一方面也有可能从非标准的来源加载代码，比如从网络来源，那就需要自己实现一个类加载器，从指定源进行加载。

链接

验证

主要是为了保证加载进来的字节流符合虚拟机规范，不会造成安全错误。

包括对于文件格式的验证，比如常量中是否有不被支持的常量？文件中是否有不规范的或者附加的其他信息？

对于元数据的验证，比如该类是否继承了被final修饰的类？类中的字段，方法是否与父类冲突？是否出现了不合理的重载？

对于字节码的验证，保证程序语义的合理性，比如要保证类型转换的合理性。

对于符号引用的验证，比如校验符号引用中通过全限定名是否能够找到对应的类？校验符号引用中的访问性（private，public等）是否可被当前类访问？

准备

主要是为类变量（注意，不是实例变量）分配内存，并且赋予初值。

特别需要注意，初值，不是代码中具体写的初始化的值，而是Java虚拟机根据不同变量类型的默认初始值。

比如8种基本类型的初值，默认为0；引用类型的初值则为null；常量的初值即为代码中设置的值，final static tmp = 456，那么该阶段tmp的初值就是456

解析

将常量池内的符号引用替换为直接引用的过程。

两个重点：

符号引用。即一个字符串，但是这个字符串给出了一些能够唯一性识别一个方法，一个变量，一个类的相关信息。
直接引用。可以理解为一个内存地址，或者一个偏移量。比如类方法，类变量的直接引用是指向方法区的指针；而实例方法，实例变量的直接引用则是从实例的头指针开始算起到这个实例变量位置的偏移量

举个例子来说，现在调用方法hello()，这个方法的地址是1234567，那么hello就是符号引用，1234567就是直接引用。

在解析阶段，虚拟机会把所有的类名，方法名，字段名这些符号引用替换为具体的内存地址或偏移量，也就是直接引用。

初始化

这个阶段主要是对类变量初始化，是执行类构造器的过程。

换句话说，只对static修饰的变量或语句进行初始化。

如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类。

如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行。

总结

类加载过程只是一个类生命周期的一部分，在其前，有编译的过程，只有对源代码编译之后，才能获得能够被虚拟机加载的字节码文件；在其后还有具体的类使用过程，当使用完成之后，还会在方法区垃圾回收的过程中进行卸载。如果想要了解Java类整个生命周期的话，可以自行上网查阅相关资料，这里不再多做赘述。

(3) 三种JVM:

① Sun公司的HotSpot；

② BEA公司的JRockit；

③ IBM公司的J9 JVM；

在JDK1.7及其以前我们所使用的都是Sun公司的HotSpot，但由于Sun公司和BEA公司都被oracle收购，jdk1.8将采用Sun公司的HotSpot和BEA公司的JRockit两个JVM中精华形成jdk1.8的JVM。

3.JVM的体系结构

(1) Class Loader类加载器

负责加载 .class文件，class文件在文件开头有特定的文件标示，并且ClassLoader负责class文件的加载等，至于它是否可以运行，则由Execution Engine决定。 ① 定位和导入二进制class文件 ② 验证导入类的正确性 ③ 为类分配初始化内存 ④ 帮助解析符号引用.

(2) Native Interface本地接口:

本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序，Java诞生的时候C/C++横行的时候，要想立足，必须有调用C/C++程序，于是就在内存中专门开辟了一块区域处理标记为native的代码，它的具体作法是Native Method Stack中登记native方法，在Execution Engine执行时加载native libraies。目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机，或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间的通信很发达，比如可以使用Socket通信，也可以使用Web Service等。

(3) Execution Engine 执行引擎：

执行包在装载类的方法中的指令，也就是方法。

(4) Runtime data area 运行数据区:

虚拟机内存或者Jvm内存，冲整个计算机内存中开辟一块内存存储Jvm需要用到的对象，变量等，运行区数据有分很多小区，分别为：方法区，虚拟机栈，本地方法栈，堆，程序计数器。

4.JVM数据运行区详解（栈管运行，堆管存储）：

说明：JVM调优主要就是优化 Heap堆和 Method Area 方法区。

(1) Native Method Stack本地方法栈

它的具体做法是Native Method Stack中登记native方法，在Execution Engine执行时加载native libraies。

(2) PC Register程序计数器

每个线程都有一个程序计算器，就是一个指针，指向方法区中的方法字节码（下一个将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不记。

(3) Method Area方法区

方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法如构造函数，接口代码也在此定义。简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间。静态变量+常量+类信息+运行时常量池存在方法区中，实例变量存在堆内存中。

5 Stack 栈

① 栈是什么

栈也叫栈内存，主管Java程序的运行，是在线程创建时创建，它的生命期是跟随线程的生命期，线程结束栈内存也就释放，对于栈来说不存在垃圾回收问题，只要线程一结束该栈就Over，生命周期和线程一致，是线程私有的。基本类型的变量和对象的引用变量都是在函数的栈内存中分配。

② 栈存储什么？

栈帧中主要保存3类数据：本地变量（Local Variables）：输入参数和输出参数以及方法内的变量；栈操作（Operand Stack）：记录出栈、入栈的操作；栈帧数据（Frame Data）：包括类文件、方法等等。

③ 栈运行原理

栈中的数据都是以栈帧（Stack Frame）的格式存在，栈帧是一个内存区块，是一个数据集，是一个有关方法和运行期数据的数据集，当一个方法A被调用时就产生了一个栈帧F1，并被压入到栈中，A方法又调用了B方法，于是产生栈帧F2也被压入栈，B方法又调用了C方法，于是产生栈帧F3也被压入栈…… 依次执行完毕后，先弹出后进......F3栈帧，再弹出F2栈帧，再弹出F1栈帧。

遵循“先进后出”/“后进先出”原则。

6 Heap 堆

堆这块区域是JVM中最大的，应用的对象和数据都是存在这个区域，这块区域也是线程共享的，也是 gc 主要的回收区，一个 JVM 实例只存在一个堆类存，堆内存的大小是可以调节的。类加载器读取了类文件后，需要把类、方法、常变量放到堆内存中，以方便执行器执行，堆内存分为三部分：

① 新生区

新生区是类的诞生、成长、消亡的区域，一个类在这里产生，应用，最后被垃圾回收器收集，结束生命。新生区又分为两部分：伊甸区（Eden space）和幸存者区（Survivor pace），所有的类都是在伊甸区被new出来的。幸存区有两个：0区（Survivor 0 space）和1区（Survivor 1 space）。当伊甸园的空间用完时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园进行垃圾回收（Minor GC）,将伊甸园中的剩余对象移动到幸存0区。若幸存0区也满了，再对该区进行垃圾回收，然后移动到1区。那如果1去也满了呢？再移动到养老区。若养老区也满了，那么这个时候将产生Major GC（FullGCC），进行养老区的内存清理。若养老区执行Full GC 之后发现依然无法进行对象的保存，就会产生OOM异常“OutOfMemoryError”。

如果出现java.lang.OutOfMemoryError: Java heap space异常，说明Java虚拟机的堆内存不够。原因有二：

a.Java虚拟机的堆内存设置不够，可以通过参数-Xms、-Xmx来调整。

b.代码中创建了大量大对象，并且长时间不能被垃圾收集器收集（存在被引用）。

② 养老区

养老区用于保存从新生区筛选出来的 JAVA 对象，一般池对象都在这个区域活跃。

③ 永久区

永久存储区是一个常驻内存区域，用于存放JDK自身所携带的 Class,Interface 的元数据，也就是说它存储的是运行环境必须的类信息，被装载进此区域的数据是不会被垃圾回收器回收掉的，关闭 JVM 才会释放此区域所占用的内存。

如果出现java.lang.OutOfMemoryError: PermGen space，说明是Java虚拟机对永久代Perm内存设置不够。原因有二：

a. 程序启动需要加载大量的第三方jar包。例如：在一个Tomcat下部署了太多的应用。 b. 大量动态反射生成的类不断被加载，最终导致Perm区被占满。

说明： Jdk1.6及之前：常量池分配在永久代。 Jdk1.7：有，但已经逐步“去永久代” 。 Jdk1.8及之后：无(java.lang.OutOfMemoryError: PermGen space,这种错误将不会出现在JDK1.8中)。

说明：方法区和堆内存的异议：实际而言，方法区和堆一样，是各个线程共享的内存区域，它用于存储虚拟机加载的：类信息+普通常量+静态常量+编译器编译后的代码等等，虽然JVM规范将方法区描述为堆的一个逻辑部分，但它却还有一个别名叫做Non-Heap（非堆），目的就是要和堆分开。

对于HotSpot虚拟机，很多开发者习惯将方法区称之为“永久代（Parmanent Gen）”,但严格本质上说两者不同，或者说使用永久代来实现方法区而已，永久代是方法区的一个实现，jdk1.7的版本中，已经将原本放在永久代的字符串常量池移走。

常量池（Constant Pool）是方法区的一部分，Class文件除了有类的版本、字段、方法、接口等描述信息外，还有一项信息就是常量池，这部分内容将在类加载后进入方法区的运行时常量池中存放。

6.堆内存调优简介

代码测试：

public class JVMTest {        public static void main(String[] args){             long maxMemory = Runtime.getRuntime().maxMemory();//返回Java虚拟机试图使用的最大内存量。             Long totalMemory = Runtime. getRuntime().totalMemory();//返回Java虚拟机中的内存总量。             System.out.println("MAX_MEMORY ="+maxMemory +"(字节)、"+(maxMemory/(double)1024/1024) + "MB");             System.out.println("TOTAL_ MEMORY = "+totalMemory +"(字节)"+(totalMemory/(double)1024/1024) + "MB");        }   }

说明：在Run as ->Run Configurations中输入"-XX:+PrintGCDetails"可以查看堆内存运行原理图：

(1) 在jdk1.7中：

(2) 在jdk1.8中:

7.通过参数设置自动触发垃圾回收：

public class JVMTest {      public static void main(String[] args){           long maxMemory = Runtime.getRuntime().maxMemory();//返回Java虚拟机试图使用的最大内存量。           Long totalMemory = Runtime. getRuntime().totalMemory();//返回Java虚拟机中的内存总量。           System.out.println("MAX_MEMORY ="+maxMemory +"(字节)、"+(maxMemory/(double)1024/1024) + "MB");           System.out.println("TOTAL_ MEMORY = "+totalMemory +"(字节)"+(totalMemory/(double)1024/1024) + "MB");           String str = "www.baidu.com";           while(true){               str += str + new Random().nextInt(88888888) + new Random().nextInt(99999999);           }      } }

在Run as ->Run Configurations中输入设置“-Xmx8m –Xms8m –xx:+PrintGCDetails”可以参看垃圾回收机制原理:

小马哥的故事

企业级代理架构实践指南：从浏览器到远程隧道的优雅方案

引言

一、浏览器代理编排：ZeroOmega 的架构设计

1.1 设计理念：职责分离原则

1.2 快速部署方案

第一步：组件安装

第二步：代理配置

1.3 分流规则设计

二、SSH 隧道代理：轻量级安全通道

2.1 架构优势分析

2.2 核心配置

基础实现

安全增强：密钥认证

2.3 运维管理

进程监控

连接验证

优雅停止

三、工程化实践：命令行工具封装

3.1 Shell Alias 配置

3.2 自动化脚本示例

四、架构选型建议

五、最佳实践总结

5.1 组合方案推荐

5.2 关键要点

结语

Mac系统下IDEA的shit+cmd+f快捷键冲突问题

问题

解决方法

Mac启动台里的图标删不掉？试试这个终极解决方案

问题描述

解决方案

命令详解

使用方法

注意事项

其他可能的解决方案

总结

GIT SSH Key 配置管理

公钥管理

生成/添加 SSH 公钥

Git 配置多个 SSH Key

背景

解决方法

群晖 部署KMS服务器激活Windows

搭建KMS服务器

激活Windows

Docker Gitea 启用SSH服务修改端口之大坑

macOS 上使用 Homebrew 安装和配置 frp 客户端

安装 frpc

配置 frpc

启动和关闭 frpc

启动 frpc

关闭 frpc

设置开机自启动

启动 frpc 服务

停止 frpc 服务

查看日志

打包本地电脑谷歌浏览器插件

查看插件ID

打包插件

打包后当前目录会有一个后缀为CRX的文件

群晖安装 Open VPN

适配机型

下载VPN Server套件

打开群晖官网

下载VPN Server

手动安装

配置 OpenVPN

修改配置文件

下载 OpenVPN 客户端

客户端配置

导入配置文件

建立VPN连接

群晖系统百度网盘套件ContainerManager项目无法删除

前言

解决方案

开启 SHH

SSH 操作删除

验证

部署 Docker 私服 docker-registry

群晖部署KMS服务器激活Windows