+
+ 最近Diffusion Models大火，也出现了许多供大家使用的图像生成接口，下面介绍一个一键搭建AI作画网站的方法，带大家领略图像生成的乐趣，一起来用AI作画吧~
+1.访问网站stable diffusion webui colab
+2.随机点击一个模型进行部署
+
3.点击运行按钮
+
4.等待输出访问网址
+
5.访问网址,输入AI作画提示词,点击生成按钮
+
6.剩下的就可以参考官方网站自己折腾了!
+网友作图:
+
问题:
+Google Colab 免费版一次只可以用 12 个小时,超过时间需要重新部署!测试发现个把小时就会需要重新部署!
+我创建了一个AI交流群,会实时分享新的好玩的资源,有兴趣的可以扫码进群,若群二维码失效,可以扫下方个人二维码拉你进群!
+
+ 微信支付
+ 
+ 支付宝支付
+
+
+ 今天我要给大家介绍一个非常酷炫的新功能，那就是 JetBrains AI 助手。
+什么是 JetBrains AI 助手？它是一款基于生成式人工智能和大型语言模型的软件开发工具，可以帮助您提高编码效率和质量。它可以与您对话，为您生成文档，建议名称，生成提交消息等等。它可以深度集成到 JetBrains 的各种 IDE 和 .NET 工具中，让您在编程过程中享受 AI 的帮助。
+听起来很神奇吧？那么，如何使用这个功能呢？接下来，我将以 IntelliJ IDEA 为例，给大家详细介绍一下 JetBrains AI 助手的使用方法。
+首先，您需要下载并安装最新的 EAP 版本的 IntelliJ IDEA。EAP 是 Early Access Program 的缩写，意思是早期访问计划。这是 JetBrains 为了让用户尽早体验最新的功能和改进而推出的测试版本。您可以在这里下载 EAP 版本：https://www.jetbrains.com/idea/nextversion/
+安装好 EAP 版本后，您需要使用您的 JetBrains 帐户登录 JetBrains AI 服务。这是一个提供 AI 功能的云端服务，它可以将您连接到不同的大型语言模型，并在许多 JetBrains 产品中启用特定的 AI 功能。目前支持 OpenAI，并托管了许多由 JetBrains 创建的较小模型。将来还会支持更多提供商和模型。
+要登录 JetBrains AI 服务，您可以从 AI 助手工具窗口或“设置”|”工具 |人工智能助手”中进行操作。
+
请注意，JetBrains AI 服务可能并非立即对所有人开放。我们将首先让一定数量的用户进入，一旦达到最大容量，剩余的用户将被添加到等候名单中。我们将在未来几周内逐步邀请更多人试用该产品。
+对 AI 服务的访问目前仅限于提供 OpenAI 服务的地区。您可以在此处查看完整的地区列表：https://openai.com/blog/openai-codex/
+AI 服务在 EAP 周期内可免费使用。我们将在稍后提供许可和定价模型。
+启用了 AI 服务后，您就可以开始使用各种 AI 功能了。目前有以下几种功能可供选择：
+这是一个非常有趣的功能，它可以让您与大型语言模型进行对话、提出问题或迭代任务。您可以打开 AI 助手工具窗口，在输入框中输入您想说的话或问的问题，然后按回车键发送。AI 将根据您输入的内容和项目中使用的语言和技术给出回复。
+
如果您对 AI 的回复满意，并且想要将 AI 生成的代码插入到编辑器中，您可以使用插入插入代码段插入插入符号功能，或者直接将其复制过来。
+
如果您想要向 AI 询问有关特定代码片段的信息，您可以在编辑器中选择该代码片段，然后从“AI 操作”菜单（在编辑器上下文菜单中或使用 Alt+Enter 快捷方式提供）调用操作。使用选择操作新建聊天允许您提供自己的提示或请求。可以通过根据需要选择“解释代码”、“建议重构”或“查找潜在问题”来输入其他标准 AI 帮助提示。
+这是一个非常实用的功能，它可以帮助您为声明生成文档。目前 Java、Kotlin 和 Python 都支持此功能。
+要使用这个功能，您可以调用“AI 操作”菜单并选择“生成文档操作”。AI 将根据声明的内容和上下文为您生成文档注释。
+
对于 Java 和 Kotlin，您还可以使用一个更方便的方法来生成文档：在声明的上方键入 ,并按回车键。IDE 将生成注释的静态已知部分（例如 Java 中的标记），AI 将为您生成实际的文档文本。
+这是一个非常智能的功能，它可以根据声明的内容为您建议合适的名称。当您重命名 Java、Kotlin 或 Python 声明时，AI 将在重命名对话框中显示名称选项。您可以从中选择一个或者输入自己的名称。
+
如果您不想使用 AI 的名称建议，您可以在“设置”|”工具 |人工智能助手”中关闭这个功能。
+这是一个非常方便的功能，它可以帮助您为代码提交生成描述性的消息。当您打开提交消息对话框时，您会看到一个“使用 AI 助手生成提交消息”按钮。单击它以将更改的差异发送到 LLM，LLM 将生成描述更改的提交消息。
+
如果您在国内使用 JetBrains AI 助手，可能会遇到一些网络问题，导致无法正常连接到 AI 服务。这时候，您可以使用一些代理工具来解决这个问题。我推荐使用 Clash for Windows 这个软件，它是一个基于 Clash 的 Windows GUI 代理客户端，支持 Shadowsocks、VMess、Socks5 等协议，支持订阅、托盘图标、规则编辑等功能。
+要使用 Clash for Windows，请按照以下步骤操作：
+进入网站 https://github.com/Fndroid/clash_for_windows_pkg/releases ，下载最新版本的 Clash.for.Windows-Setup-x.x.x.exe 安装包，并安装到电脑上。
+打开 Clash for Windows 软件，点击 General 中 Home Directory 右边的文件夹图标，打开配置文件所在目录。
+进入网站 https://www.wintun.net ，点击界面中 Download Wintun xxx 下载压缩包，根据系统版本（win10 64 位对应的是 amd64目录下）将对应目录中 wintun.dll 复制至 Clash 的 Home Directory 目录中。
+点击 General 中 Service Mode 右边 Manage，在打开窗口中安装服务模式，安装完成应用会自动重启，Service Mode 右边地球图标变为绿色即安装成功。
点击 Profiles，选择一个合适的代理配置文件，或者点击 Download from URL 从网上下载一个订阅链接。您可以在一些代理服务提供商的网站上找到订阅链接，或者在网上搜索一些免费的订阅链接。
+点击 settings——Profile Mixin——YAML，点击 edit，输入下面的内容，点击保存：
+
+ 
+ mixin:
+ hosts:
+ 'mtalk.google.com': 108.177.125.188
+ 'services.googleapis.cn': 74.125.203.94
+ 'raw.githubusercontent.com': 151.101.76.133
+ dns:
+ enable: true
+ default-nameserver:
+ - 223.5.5.5
+ - 1.0.0.1
+ ipv6: false
+ enhanced-mode: redir-host #fake-ip
+ nameserver:
+ - https://dns.rubyfish.cn/dns-query
+ - https://223.5.5.5/dns-query
+ - https://dns.pub/dns-query
+ fallback:
+ - https://1.0.0.1/dns-query
+ - https://public.dns.iij.jp/dns-query
+ - https://dns.twnic.tw/dns-query
+ fallback-filter:
+ geoip: true
+ ipcidr:
+ - 240.0.0.0/4
+ - 0.0.0.0/32
+ - 127.0.0.1/32
+ domain:
+ - +.google.com
+ - +.facebook.com
+ - +.twitter.com
+ - +.youtube.com
+ - +.xn--ngstr-lra8j.com
+ - +.google.cn
+ - +.googleapis.cn
+ - +.gvt1.com
+ tun:
+ enable: true
+ stack: gvisor
+ dns-hijack:
+ - 198.18.0.2:53
+ macOS-auto-route: true
+ macOS-auto-detect-interface: true # 自动检测出口网卡
+点击 General，开启 System Proxy 和 Allow LAN和Mixin。您就可以让浏览器等应用使用系统代理，也可以让局域网内的其他设备通过您的电脑访问代理服务。
现在，您就可以正常使用 JetBrains AI 助手了。如果您遇到任何问题，您可以在 AI 助手工具窗口中查看日志信息，或者在“设置”|”工具 |人工智能助手”中调整日志级别和日志文件位置。
+IDEA中配置代理,根据实际情况调整这个端口!
以上就是我为大家介绍的 JetBrains AI 助手的使用教程。我希望这篇文章能够对您有所帮助，让您能够体验到 AI 带来的便利和乐趣。如果您喜欢这篇文章，请给我点个赞，关注我的公众号，分享给您的朋友。感谢您的阅读，下次再见！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 
数据库是现代软件开发中不可或缺的组成部分，它存储了各种业务数据，为应用程序提供了强大的支持。然而，操作数据库并不是一件容易的事情，需要掌握SQL语言，了解数据库的结构和性能，还要注意数据的安全和备份。对于开发人员来说，这些都是需要花费大量时间和精力的工作。
+有没有一款工具，可以让开发人员更方便地操作数据库，甚至可以用自然语言来查询数据呢？答案是有的，那就是Chat2DB。
+官网 : https://chat2db.opensource.alibaba.com
+Chat2DB 是一款开源免费的多数据库客户端工具，它支持Windows、Mac本地安装，也支持服务器端部署，Web网页访问。它可以连接多种类型的数据库，如Mysql、PostgreSQL、Oracle、SQLServer、ClickHouse、Oceanbase、H2、SQLite等等，未来还会支持更多的数据库。
+Chat2DB 的最大特色是集成了AIGC（Artificial Intelligence for General Computing）的能力，能够将自然语言转换为SQL，也可以将SQL转换为自然语言。这意味着你可以用你熟悉的语言来和数据库交流，不需要记住复杂的SQL语法和规则。比如，你可以输入“查询所有用户的姓名和年龄”，Chat2DB 就会自动生成对应的SQL语句，并执行查询，返回结果。你也可以输入SQL语句，Chat2DB 会给出相应的自然语言解释，帮助你理解SQL的含义和逻辑。
+除了自然语言转换，Chat2DB 还可以给出SQL的优化建议，帮助你提升SQL的性能和效率。它会分析SQL语句的结构和执行计划，指出潜在的问题和改进点，比如缺少索引、过度使用子查询、使用了不恰当的函数等等。它还会给出优化后的SQL语句和预期的效果，让你一目了然。
+| 描述 | +下载地址 | +
|---|---|
| Windows | +[https://oss-chat2db.alibaba.com/release/1.0.11/Chat2DB%20Setup%201.0.11.exe](https://oss-chat2db.alibaba.com/release/1.0.11/Chat2DB Setup 1.0.11.exe) | +
| MacOS ARM64 (Apple芯片) | +https://oss-chat2db.alibaba.com/release/1.0.11/Chat2DB-1.0.11-arm64.dmg | +
| MacOS X64 (Intel芯片) | +https://oss-chat2db.alibaba.com/release/1.0.11/Chat2DB-1.0.11.dmg | +
| Jar包 | +https://oss-chat2db.alibaba.com/release/1.0.11/ali-dbhub-server-start.jar | +
下载安装完成之后,只需要在设置页面配置OpenAI的key,即可开始使用,需要本机开启代理!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 近年来，大型语言模型（LLM）的发展日新月异，各大科技巨头和研究机构纷纷推出了自己的聊天机器人。那么，如何才能知道哪个模型更强大、更智能呢？现在，有了一个绝佳的机会！
+LMSYS Chatbot Arena是一个免费的在线平台，允许用户通过提问来测试和比较多达36款不同的顶级语言模型。这些模型来自各大科技公司和研究机构，包括Google的Gemma、OpenAI的GPT-4-Turbo等。
+在LMSYS Chatbot Arena，你可以扮演裁判的角色。你可以向两个匿名的聊天模型提出各种问题，然后根据它们的回答质量，投票决定哪个模型更加优秀。这是一个与AI直接互动、了解它们能力的绝佳机会。
+通过汇总超过500,000个用户的投票结果，LMSYS Chatbot Arena使用Elo等级分系统，生成了一个实时更新的LLM排行榜。你可以看到各个模型的排名变化，了解当前AI界的王者是谁。这个排行榜为我们提供了一个客观、公平的评判标准。
+LMSYS Chatbot Arena上有多达36个不同的语言模型参与角逐，它们来自Google、OpenAI、Anthropic等不同的公司和机构。每个模型都有自己独特的训练方式和专长领域。通过在Arena中与它们互动，你可以全方位地了解当前AI技术的发展水平。
+LMSYS Chatbot Arena为我们提供了一个免费、有趣、多样的平台，让我们能够亲身体验和评判当前最先进的语言模型。无论你是AI专家、开发者，还是对人工智能感兴趣的普通用户，这个网站都值得一试。快来当一回裁判，看看哪个AI模型能够脱颖而出，赢得你的青睐吧！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 
Aria2 是目前最强大的全能型下载工具，它支持 BT、磁力、HTTP、FTP 等下载协议，常用做离线下载的服务端。目前有非常多的 Aria2 Docker 方案，大多都整合了 WebUI 和文件管理功能，看似很好很强大，实际上都只是做了简单的打包的工作，完全没有考虑到核心的下载体验和资源占用等问题。这也导致很多人在初次使用 Aria2 时会遇到 BT 下载无速度、文件残留占用空间、任务丢失等问题，所以会觉得 Aria2 并不好用，但事实并非如此。
+Alist是一个支持多种存储，支持网页浏览和 WebDAV 的文件列表程序，由 gin 和 Solidjs 驱动。
+Aria2的docker compose启动脚本,自行替换RPC密钥即可!
+
+ 
+ 
+ version: "3.8"
+
+services:
+
+ Aria2-Pro:
+ container_name: aria2-pro
+ image: p3terx/aria2-pro
+ environment:
+ - PUID=65534
+ - PGID=65534
+ - UMASK_SET=022
+ - RPC_SECRET=<自行设置RPC密钥>
+ - RPC_PORT=6800
+ - LISTEN_PORT=6888
+ - DISK_CACHE=64M
+ - IPV6_MODE=false
+ - UPDATE_TRACKERS=true
+ - CUSTOM_TRACKER_URL=
+ - TZ=Asia/Shanghai
+ - SPECIAL_MODE=rclone
+ volumes:
+ - ${PWD}/aria2-config:/config
+ - ${PWD}/aria2-downloads:/downloads
+# If you use host network mode, then no port mapping is required.
+# This is the easiest way to use IPv6 networks.
+ network_mode: host
+# network_mode: bridge
+# ports:
+# - 6800:6800
+# - 6888:6888
+# - 6888:6888/udp
+ restart: unless-stopped
+# Since Aria2 will continue to generate logs, limit the log size to 1M to prevent your hard disk from running out of space.
+ logging:
+ driver: json-file
+ options:
+ max-size: 1m
+
+# AriaNg is just a static web page, usually you only need to deploy on a single host.
+ AriaNg:
+ container_name: ariang
+ image: p3terx/ariang
+ command: --port 6880 --ipv6
+ network_mode: host
+# network_mode: bridge
+# ports:
+# - 6880:6880
+ restart: unless-stopped
+ logging:
+ driver: json-file
+ options:
+ max-size: 1m
+Alist的docker启动脚本
+docker run -d --restart=always -v /wangwang/alist:/opt/alist/data -p 5244:5244 --name="alist" xhofe/alist:v3.0.0-rc.1
+访问搭建的AriaNg页面,http://{ip}:6880,新建RPC配置如下
+
访问搭建的Alist页面,http://{ip}:5244,配置Aria2地址
+
然后选中文件,推送到Aria2下载即可
+
详细配置请参考官方文档!!
+Aria2参考文档:Aria2 Pro - 更好用的 Aria2 Docker 容器镜像 - P3TERX ZONE
+Alist参考文档:Guide | AList文档 (nn.ci)
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ Azure OpenAI 和 OpenAI 官方提供的服务基本是一致的，但是目前前者还是处于预览版的状态，一些功能还没有完全开放。
+优点：
+缺点：
+目前，仅应用程序授予对此服务的访问权限。 可以通过在 https://aka.ms/oai/access 上填写表单来申请对 Azure OpenAI 的访问权限。 若有企业信息,全部按真实信息填写即可,等待2-10天即可收到通过的邮件
+前提:
+教育邮箱
+Azure拥有一个订阅(最好是学生订阅)
+申请步骤
+1.访问https://aka.ms/oai/access,按下图填写相关信息,最后23,25看个人是否申请,进行勾选.
+
2.前往azure登录,获取订阅ID
+
3.等待官方邮件即可,我测试了两次,均在第三天审核通过,若要补充资料,则说明审核失败.
+进入 Azure 后，直接搜索OpenAI
+
若是已经通过,这里即可选择订阅,否则会在下方提示让你申请
+
在资源管理->模型部署 选择需要的模型进行创建，每个模型只能创建1个部署。
+
部署完成之后,点击Azure OpenAI Studio即可进行测试
+
如下所示!
+
很多小伙伴是需要用第三方服务部署的,需要的内容可以在 资源管理->密钥和终结点 可以获取 API 地址以及调用密钥。
+
相信以上教程已经足够让小伙伴们申请到自己的Azure OpenAI服务了!
+有需要进交流群的可以加我,备注AI即可!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 众所周知，国内访问并体验 ChatGPT 拥有一定的门槛，主要受限于网络无法访问、账号无法注册等条件。然而对于突破该约束条件的同学来说，可以很轻松的使用开源程序搭建基于 OPENAI API 的在线应用网站。
+旨在搜集整理国内用户可访问的基于 OPENAI API 开发的在线应用列表，以供条件受限的同学参考使用。
+
+ 
+ ⭐ 推荐星级。默认一星。免费、无需代理、无需 KEY，可增加星级
+⛔ 0星标记。表示可访问，但功能暂不可用、使用受限等
+🔑 需输入API KEY。可使用自己的 KEY（**应谨慎使用，避免您的 API KEY 泄露**）
+🚀 需代理。可代理登录、免费试用
+🔒 需登录。注册账号时请仔细甄别相关页面，不要使用常用密码
+💰 需付费。请仔细识别，谨防受骗
+❓ 需手动验证。访问异常、不确定是否失效、程序探测无法访问等
+❌ 已失效。会在失效一段时间后移除
+站点列表(1227)：
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 大家好，我是一个热爱人工智能和搜索引擎的小白，今天我想跟大家分享一下如何使用ChatGPT和新版必应来创作和搜索。
+ChatGPT 是一个由OpenAI开发的聊天机器人，它基于OpenAI的GPT-3系列大型语言模型，并且使用了监督学习和强化学习技术进行微调。ChatGPT可以以对话方式交互，回答后续问题，承认错误，挑战错误前提，拒绝不恰当的请求等。它还可以生成各种类型的内容，比如代码、诗歌、故事、歌词等。
+新版必应是微软（Microsoft）的搜索引擎，它可以帮助用户快速而容易地从搜索到执行。新版必应最近也结合了ChatGPT，并推出了具有人工智能聊天功能的新版必应。新版必应可以回答用户复杂问题和具有创作能力。
+ChatGPT在线版: http://chat.wangwangit.com/
+Bing在线版:http://bing.wangwangit.com/
+参考文章: 最新Chatgpt微信机器人搭建教程 - 一只会飞的旺旺 (wangwangit.com)
+**注意: **
+参考文章: 必应ChatGPT内测申请教程 - 一只会飞的旺旺 (wangwangit.com)
+注意:
+参考文章: AI Tool Hunt - The Ultimate Directory for Discovering the Best AI Tools
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 共享chatgpt免费账号，让你轻松体验最先进的聊天机器人。点击进入，立即注册，享受无限制的对话乐趣。
🤖全网价格最低账号: 一只会飞的旺旺 (wangwangit.com) 点击直达访问
+| ChatGPT账号 | +密码 | +
|---|---|
| 4brelfbro@yunweiloginmh3.com | +lin26870 | +
| 6enmntfv1@yunweiloginmh3.com | +he063479 | +
| epn_f_6_f@yunweiloginmh3.com | +hong8259 | +
| aa9ugcyre@yunweiloginmh3.com | +qi354035 | +
| p8cwghjw0@yunweiloginmh3.com | +zhong689 | +
| 5y3td7igg@yunweiloginmh3.com | +he530176 | +
| ogvmp4xmf@yunweiloginmh3.com | +fang5956 | +
| oqnt8qkul@yunweiloginmh3.com | +ban30108 | +
| 3jal9z7bm@yunweiloginmh3.com | +cheng465 | +
| rqbcu71yx@yunweiloginmh3.com | +ai046012 | +
| elhqd6h2b@yunweiloginmh3.com | +qu565909 | +
| oqv-fii1j@yunweiloginmh3.com | +jie26062 | +
| kui5k5hms@yunweiloginmh3.com | +ling3202 | +
| thlgxss64@yunweiloginmh3.com | +she90159 | +
| cnc86yljh@yunweiloginmh3.com | +wu062191 | +
| tasfdsnta@yunweiloginmh3.com | +bing8245 | +
| si4mmza3x@yunweiloginmh3.com | +hao46712 | +
| n9kkoxavp@yunweiloginmh3.com | +lei51372 | +
| kqfsiu6pe@yunweiloginmh3.com | +jing7026 | +
+ 微信支付
+
+ 支付宝支付
+
+
+ 打开OpenAI官方注册页面: openai.com
+按照下图依次操作即可!
+
输入邮箱密码!
+
这时,邮箱会收到邮件,点击下方的校验按钮!
+
页面需要填写一些个人信息,可以随便填写!然后下一步,就会要求输入手机号! (请查看末尾有关手机号的获取教程),此处最新可能添加了一个验证机制,按页面提示操作即可!
+
在接码平台获取到验证码后,填入即可
+
然后就会自动跳转到ChatGPT使用页面了!
+
推荐平台链接地址：sms-activate.org
若不行可以使用其他接码平台!
具体过程包含以下几步：
+这一步比较长，但是操起其实也不复杂，简单说就是通过接码平台收验证码完成验证，大家只要按照步骤操作就能成功。
+下面是每一步的操作图，大家可以对照操作。
+
打开邮箱找到验证邮件
+
设计提示词本质上就是对模型进行“编程”，这通常是通过提供一些指令或几个示例来完成。这与大多数其他 NLP 服务不同，后者是为单个任务设计的，例如情绪分类或命名实体识别。相反，补全（Completions）和聊天补全（Chat Completions）几乎可用于任何任务，包括内容或代码生成、摘要、扩展、对话、创意写作、风格转换等。
+我们的模型通过将文本分解为令牌（Token）来理解和处理文本。Token 可以是单词，也可以是字符块。例如，单词“hamburger”被分解成标记“ham”、“bur”和“ger”，而很短且常见的单词像“pear”是一个 Token。许多 Token 以空格开头，例如“ hello”和“ bye”。
+在给定的 API 请求中处理的 Token 数量取决于您的输入和输出长度。作为一个粗略的经验法则，对于英文文本，1 个Token大约相当于 4 个字符或 0.75 个单词。要记住的一个限制是，您的文本提示词和生成的补全合起来不能超过模型的最大上下文长度（对于大多数模型，这是 2048 个 Token，或大约 1500 个单词）。可以查看我们的 分词器工具 来了解有关文本如何转换为 Token 的更多信息。
+API 由一组具有不同功能和价位的模型提供支持。GPT-4是我们最新和最强大的模型。GPT-3.5-Turbo 是为 ChatGPT 提供支持的模型，此模型专为对话模式进行了优化。要了解有关这些模型以及其他我们提供的内容的更多信息，请访问模型文档。
+参考官方文档: GPT best practices - OpenAI API
+参考吴恩达的课程: 吴恩达 & OpenAI_哔哩哔哩_bilibili
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 注意
+机器人搭建已经失效,请前往github搜索最新的部署方案!
+账号申请请查看最新的文章!本篇可能已经过时!!!
+ChatGPT 以其强大的信息整合和对话能力惊艳了全球，在自然语言处理上面表现出了惊人的能力。这么强大的工具我们都想体验一下，那么 ChatGPT 怎么用呢？本文将给你逐步详细介绍。
+使用 ChatGPT 主要有4步：
+好了，我们开始逐步图文介绍。
+注冊ChatGPT这一步主要包含以下几步（需要按照顺序逐步操作）：
+下面每一个步骤的图片，大家可以对照着进行操作
+
邮箱验证完成后，我们第一步注册 ChatGPT 账号就算完成了，但是到这里我们还不能开始使用 ChatGPT，因为我们还需要进行手机号码验证。没有通过手机号码验证是使用不了 OpenAI（ChatGPT的开发商） 的服务的。
+国内和港澳的手机号码还有 Google Voice 的虚拟号码都是不能使用的。那要怎么验证呢，请看下一步。
+这一步需要用到接码平台完成手机号验证，推荐平台链接地址：sms-activate.org
+具体过程包含以下几步：
+这一步比较长，但是操起其实也不复杂，简单说就是通过接码平台收验证码完成验证，大家只要按照步骤操作就能成功。
+下面是每一步的操作图，大家可以对照操作。
+
打开邮箱找到验证邮件
+
历经千辛万苦，我们终于可以开始使用 ChatGPT 啦，恭喜！
+注册完后，我们去 ChatGPT 网站去登陆： https://chat.openai.com/auth/login
+输入我们上面第一步注册好的账号密码就可以成功登录。
+登录以后我们会进入到 ChatGPT 的主界面，在屏幕的正下方就是我们使用 ChatGPT 的输入对话框，ChatGPT采用交互式对话界面，使用非常便捷友好，你可以任意输入你感兴趣的内容并敲回车，ChatGPT 将会回答你。
+
比如我们问一下 ChatGPT 梯形相关的问题，看看他会怎么回答。
+
前往python官网下载安装包,然后解压,将该目录配置到电脑环境变量中.如图
+
前往node官网下载最新的node版本,然后按提示安装即可
+
安装完成之后,打开cmd,输入npm -v, node -v能正常显示版本号,即安装成功!
+
前往谷歌官网,下载浏览器,这一步是必须的!
+下载代码chatgpt到本地,并解压
+
进入目录,打开cmd输入以下命令
+
+ 
+ 
+ npm install && poetry install
+等待执行完成,复制文件夹中的config.yaml.example,重命名为config.yaml,并打开填入自己的chatgpt账号
+
修改完成之后,在到cmd执行npm run dev即可,等待程序自行打开谷歌浏览器,手动点过cloudflare的验证,然后程序会自行填入账号密码,cmd中出现微信二维码,使用微信小号扫码登录即可!
+
上述步骤已经完成微信机器人搭建,只要去给你登录的微信账号发消息,即可获得回复!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 想要体验Claude3吗？这里为你整理了10种访问方式，让你轻松畅享这一创新的AI助手。快来看看吧！
+
+ 微信支付
+
+ 支付宝支付
+
+
+ OpenAI 前副总裁创立的 Claude 或可与ChatGPT 竞争,支持使用 API 从第三方接入，还接入了 Slack ，目前需要申请 Waitlist。目前测试无需代理即可使用!
+发现有些人按下面的教程无法顺利使用了,可以直接点这个链接进我的群组,同样可以使用!
+https://join.slack.com/t/wangwangit/shared_invite/zt-1sxv7wmli-4pRspiQ4xFA08Rk~exBGQg
+1.打开网站 https://t.co/x4SVklb6NM 点击登录安装
+
2.我是用google账号直接登录的
+
3.点击在Slack打开
+
4.直接从浏览器打开此链接
+
5.开始对话!
+
执行完上面的步骤,安装Slack这款软件,即可实现在手机端对话,软件地址:slack.apk | 一只会飞的旺旺 (wangwangit.com)
+
我创建了一个AI交流群,会实时分享新的好玩的资源,有兴趣的可以扫码进群,若群二维码失效,可以扫下方个人二维码拉你进群!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 在AI的浩瀚宇宙中，有一个新星正在闪耀——Command R+。这个开源的大型语言模型不仅在技术排行榜上名列前茅，更以其开放性和高性能赢得了全球开发者的关注和喜爱。
+开源精神的胜利
+Command R+是由CohereAI推出的一款开源大语言模型，拥有1040亿参数，支持多种语言，包括英语、中文、法语和德语。这个模型对内置的检索增强生成（RAG）进行了全面强化，其性能仅次于GPT-4的早期版本，已经成为开源模型中的佼佼者
+
排行榜上的新星
+在LM-SYS的大模型匿名评测中，Command R+获得了1.3万次的投票，Arena Elo得分1194，使其成为目前开源模型中得分最高的模型，总排行第六。这一成就标志着开源模型在大模型领域的快速进展，展示了其在多样化任务中的潜力和实用性。
+
免费试用，探索未知
+最激动人心的是，Cohere提供了免费的API接口，让每个人都能轻松接触和使用这些先进的AI模型。你只需在dashboard.cohere.com上注册账户，即可开始免费试用，体验AI的魔力。
+多语言能力，跨界沟通
+Command R+不仅支持多种语言，还能执行跨语言任务，如翻译或回答其他语言内容的问题。无论你使用哪种语言，Command R+都能理解并作出响应，这使得它成为全球用户的理想选择
+创新的应用，无限的可能
+Command R+的开源特性意味着任何人都可以参与到这个项目中来，无论是改进模型、开发新功能，还是创建独特的应用，都有无限的可能。这不仅是技术的胜利，更是开源精神的胜利。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 一般我们需要进行日志分析场景：直接在日志文件中 grep、awk 就可以获得自己想要的信息。但在规模较大的场景中，此方法效率低下，面临问题包括日志量太大如何归档、文本搜索太慢怎么办、如何多维度查询。需要集中化的日志管理，所有服务器上的日志收集汇总。常见解决思路是建立集中式日志收集系统，将所有节点上的日志统一收集，管理，访问。
+一般大型系统是一个分布式部署的架构，不同的服务模块部署在不同的服务器上，问题出现时，大部分情况需要根据问题暴露的关键信息，定位到具体的服务器和服务模块，构建一套集中式日志系统，可以提高定位问题的效率。
+一个完整的集中式日志系统，需要包含以下几个主要特点：
+ELK提供了一整套解决方案，并且都是开源软件，之间互相配合使用，完美衔接，高效的满足了很多场合的应用。目前主流的一种日志系统。
+Elasticsearch: 是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。
+Logstash: 主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式。一般工作方式为c/s架构，client端安装在需要收集日志的主机上，server端负责将收到的各节点日志进行过滤、修改等操作在一并发往elasticsearch上去。
+Kibana: 一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面，可以帮助汇总、分析和搜索重要数据日志。
+
+ 
+ 
+ /elk_cluster/node/es1/data/
+/elk_cluster/node/es2/data/
+/elk_cluster/logstash/
+/elk_cluster/plugins/
+http.host: "0.0.0.0"
+xpack.monitoring.elasticsearch.hosts: [ "http://{服务器ip}:9200","http://{服务器ip}:9201" ]
+input {
+ tcp {
+ mode => "server"
+ host => "0.0.0.0"
+ port => 4560
+ codec => json_lines
+ }
+}
+output {
+ elasticsearch {
+ hosts => [ "http://{服务器ip}:9200","http://{服务器ip}:9201" ]
+ index => "springboot-logstash-%{+YYYY.MM.dd}"
+ }
+}
+# es1
+cluster.name: elasticsearch-cluster
+node.name: es-node1
+network.bind_host: 0.0.0.0
+network.publish_host: _eth0_
+http.port: 9200
+transport.tcp.port: 9300
+http.cors.enabled: true
+http.cors.allow-origin: "*"
+node.master: true
+node.data: true
+discovery.seed_hosts: ["ES01:9300","ES02:9301"]
+cluster.initial_master_nodes: ["es-node1","es-node2"]
+discovery.zen.minimum_master_nodes: 1
+#es2
+cluster.name: elasticsearch-cluster
+node.name: es-node2
+network.bind_host: 0.0.0.0
+network.publish_host: _eth0_
+http.port: 9200
+transport.tcp.port: 9300
+http.cors.enabled: true
+http.cors.allow-origin: "*"
+node.master: true
+node.data: true
+discovery.seed_hosts: ["ES01:9300","ES02:9301"]
+cluster.initial_master_nodes: ["es-node1","es-node2"]
+discovery.zen.minimum_master_nodes: 1
+在/elk_cluster/下创建docker-compose.yml文件,内容如下
+# 镜像自行调整,此为arm架构服务器使用模板
+version: '3.7'
+services:
+ es1:
+ image: elasticsearch:7.17.4
+ container_name: ES01
+ environment:
+ ES_JAVA_OPTS: -Xms512m -Xmx512m
+ ports:
+ - "9200:9200"
+ - "9300:9300"
+ volumes:
+ - "./node/es1/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml"
+ - "./node/es1/data:/usr/share/elasticsearch/data"
+ networks:
+ - es-net
+ es2:
+ image: elasticsearch:7.17.4
+ container_name: ES02
+ environment:
+ ES_JAVA_OPTS: -Xms512m -Xmx512m
+ ports:
+ - "9201:9200"
+ - "9301:9300"
+ volumes:
+ - "./node/es2/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml"
+ - "./node/es2/data:/usr/share/elasticsearch/data"
+ networks:
+ - es-net
+ es-head:
+ image: aichenk/elasticsearch-head:5-alpine
+ ports:
+ - "9100:9100"
+ kibana:
+ image: kibana:7.17.4
+ container_name: kibana
+ volumes:
+ - "./kibana.yml:/opt/kibana/config/kibana.yml" #挂载logstash的配置文件
+ environment:
+ - SERVER_NAME=kibana
+ - XPACK_MONITORING_ENABLED=true
+ ports:
+ - 5601:5601
+ networks:
+ - es-net
+ depends_on:
+ - es1
+ external_links:
+ - es1
+
+ logstash:
+ image: logstash:7.17.4
+ container_name: logstash
+ restart: always
+ volumes:
+ - "./logstash/logstash-springboot.conf:/usr/share/logstash/pipeline/logstash.conf" #挂载logstash的配置文件
+ - "./logstash/logstash.yml:/usr/share/logstash/config/logstash.yml" #挂载logstash的配置文件
+ ports:
+ - "4560:4560"
+ depends_on:
+ - es1
+
+networks:
+ es-net:
+ driver: bridge
+在docker-compose.yml文件同级目录创建kibana.yml文件
+#
+# ** THIS IS AN AUTO-GENERATED FILE **
+#
+
+# Default Kibana configuration for docker target
+server.publicBaseUrl: "http://{服务器ip}:5601" # 这里地址改为你访问kibana的地址，不能以 / 结尾
+server.name: kibana
+server.host: "0.0.0.0"
+server.shutdownTimeout: "5s"
+elasticsearch.hosts: [ "http://{服务器ip}:9200","http://{服务器ip}:9201" ]
+monitoring.ui.container.elasticsearch.enabled: true
+# 汉化
+i18n.locale: zh-CN
+进入docker-compose.yml同级目录,执行docker-compose up -d,启动服务
+<!--集成logstash-->
+<dependency>
+ <groupId>net.logstash.logback</groupId>
+ <artifactId>logstash-logback-encoder</artifactId>
+ <version>5.3</version>
+</dependency>
+<!-- 指定后面用到的APP_NAME取值 -->
+<springProperty name="APP_NAME" scope="context" source="spring.application.name" defaultValue="wechat-person"/>
+<!-- 添加以下内容,将日志输出到Logstash日志收集端口 -->
+ <appender name="STASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
+ <destination>{服务器ip}:4560</destination>
+ <!-- 日志输出编码 -->
+ <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
+ <providers>
+ <timestamp>
+ <timeZone>UTC</timeZone>
+ </timestamp>
+ <pattern>
+ <pattern>
+ {
+ "app": "${APP_NAME}",
+ "level": "%level",
+ "pid": "${PID:-}",
+ "thread": "%thread",
+ "class": "%logger{40}",
+ "message": "%message",
+ "stack_trace": "%exception{10}"
+ }
+ </pattern>
+ </pattern>
+ </providers>
+ </encoder>
+ </appender>
+
然后进入Discover,即可看到日志数据
+
+ 微信支付
+
+ 支付宝支付
+
+
+ # 分词器ik_max_word 最细粒度的拆分
+POST _analyze
+{
+ "analyzer": "ik_max_word",
+ "text": "南京市长江大桥"
+}
+
+
+# ik_smart 最粗粒度的拆分
+POST _analyze
+{
+ "analyzer": "ik_smart",
+ "text": "南京市长江大桥"
+}
+
+
+# 创建索引
+PUT /zfzn
+
+# 判断索引是否存在
+HEAD /zfzn
+
+# 查看索引,多个用逗号拼接
+GET /zfzn
+
+# 查看所有索引
+GET _all
+
+GET /_cat/indices?v
+
+# 打开索引
+POST /zfzn/_open
+
+# 关闭索引
+POST /zfzn/_close
+
+# 删除索引
+DELETE /zfzn
+
+
+# 创建映射(表字段)
+PUT /zfzn
+PUT /zfzn/_mapping/
+{
+ "properties":{
+ "name":{
+ "type":"text",
+ "analyzer":"ik_max_word"
+ },
+ "age":{
+ "type":"integer"
+ },
+ "remark":{
+ "type":"text"
+ }
+ }
+}
+
+
+PUT /zfzn1
+{
+ "mappings": {
+ "properties": {
+ "name": {
+ "type": "text",
+ "analyzer": "ik_max_word"
+ },
+ "age": {
+ "type": "integer"
+ },
+ "remark": {
+ "type": "text"
+ }
+ }
+ }
+}
+
+
+# 查看映射(表字段)
+GET /zfzn/_mapping
+
+# 查看所有映射
+GET /_all/_mapping
+
+# 修改映射(只能增加字段)
+PUT /zfzn/_mapping/
+{
+ "properties":{
+ "name":{
+ "type":"text",
+ "analyzer":"ik_max_word"
+ },
+ "age":{
+ "type":"integer"
+ },
+ "remark":{
+ "type":"text"
+ },
+ "sex":{
+ "type":"text"
+ }
+ }
+}
+
+
+# 新增文档(表数据)
+POST /zfzn/_doc/1
+{
+ "name":"小冰",
+ "age":"19",
+ "remark":"我是一个演员",
+ "sex":"女"
+}
+
+
+# 查看单个文档
+GET /zfzn/_doc/1
+
+# 查看所有文档
+GET /zfzn/_search
+{
+ "query": {
+ "match_all": {}
+ }
+}
+
+# 查询指定字段
+GET /zfzn/_doc/1?_source=name,age
+
+# 更新文档(id存在则更新,不存在则新增)
+PUT /zfzn/_doc/1
+{
+ "name":"小冰改",
+ "age":"19",
+ "remark":"我是一个演员",
+ "sex":"女"
+}
+
+
+# 更新指定字段
+POST /zfzn/_update/1
+{
+ "doc": {
+ "remark":"不当演员,我要回家种田"
+ }
+}
+
+# 删除文档(根据ID)
+DELETE /zfzn/_doc/-jRdFYIBm3HYdyw3Px1X
+
+# 根据条件删除 (注意name使用了分词器)
+POST /zfzn/_delete_by_query
+{
+ "query":{
+ "match":{
+ "name" : "小莫"
+ }
+ }
+}
+
+# 删除所有文档
+POST /zfzn/_delete_by_query
+{
+ "query": {
+ "match_all": {}
+ }
+}
+
+
+# 新增测试数据
+POST /zfzn/_doc
+{
+ "name":"林动",
+ "age":"29",
+ "remark":"我是一个辣鸡",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"林子",
+ "age":"3",
+ "remark":"我是一个零",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"萧炎",
+ "age":"25",
+ "remark":"我是一个动漫",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"鳄鱼",
+ "age":"39",
+ "remark":"我是一个鱼",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"花生",
+ "age":"39",
+ "remark":"我是一个花",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"电脑",
+ "age":"15",
+ "remark":"我是一个电",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"无天",
+ "age":"66",
+ "remark":"我是一个天",
+ "sex":"男"
+}
+
+POST /zfzn/_doc
+{
+ "name":"无花电脑001",
+ "age":"66",
+ "remark":"我是一个天",
+ "sex":"男"
+}
+
+
+POST /zfzn/_doc
+{
+ "name":"无花001电脑",
+ "age":"66",
+ "remark":"我是一个天",
+ "sex":"男"
+}
+
+
+POST /zfzn/_doc
+{
+ "name":"无花看起来真不错啊001有什么好吃的电脑",
+ "age":"66",
+ "remark":"我是一个天",
+ "sex":"男"
+}
+
+
+
+# 多词条查询(默认or条件)
+POST /zfzn/_search
+{
+ "query": {
+ "match": {
+ "name": "无花电脑"
+ }
+ }
+}
+
+
+POST /zfzn/_search
+{
+ "query": {
+ "match": {
+ "name":{
+ "query": "无花电脑","operator": "and"
+ }
+ }
+ }
+}
+
+# 短语搜索
+GET /zfzn/_search
+{
+ "query": {
+ "match_phrase": {
+ "name": "无花 001"
+ }
+ }
+}
+
+GET /zfzn/_search
+{
+ "query": {
+ "match_phrase": {
+ "name": {
+ "query": "无花 001",
+ "slop": 2
+ }
+
+ }
+ }
+}
+
+# 高级查询,无需指定字段匹配
+GET /zfzn/_search
+{
+ "query": {
+ "query_string": {
+ "query": "天"
+ }
+ }
+}
+
+GET /zfzn/_search
+{
+ "query": {
+ "query_string": {
+ "query": "天",
+ "default_field": "name"
+ }
+ }
+}
+
+GET /zfzn/_search
+{
+ "query": {
+ "query_string": {
+ "query": "天",
+ "fields": ["name","remark"]
+ }
+ }
+}
+
+
+# 词条搜索,不分析搜索词
+
+
+PUT /zfzn
+PUT /zfzn/_mapping/
+{
+ "properties":{
+ "name":{
+ "type":"keyword"
+ },
+ "age":{
+ "type":"integer"
+ },
+ "remark":{
+ "type":"text"
+ }
+ }
+}
+
+
+
+POST /zfzn/_search
+{
+ "query": {
+ "term": {
+ "name": "天"
+ }
+ }
+}
+
+# 多词条
+GET /zfzn/_search
+{
+ "query": {
+ "terms": {
+ "name": [
+ "天",
+ "萧"
+ ]
+ }
+ }
+}
+
+# 范围搜索
+
+GET /zfzn/_search
+{
+ "query": {
+ "range": {
+ "age": {
+ "gte": 10,
+ "lte": 30
+ }
+ }
+ }
+}
+
+
+# 非空搜索
+
+POST /zfzn/_doc
+{
+ "name":"",
+ "age":"66",
+ "remark":"我是空的",
+ "sex":"男"
+}
+
+GET /zfzn/_search
+{
+ "query": {
+ "exists": {
+ "field": "name"
+ }
+ }
+}
+
+
+# 前缀搜索
+GET /zfzn/_search
+{
+ "query": {
+ "prefix": {
+ "name": "无"
+ }
+ }
+}
+
+
+# 通配符搜索
+GET /zfzn/_search
+{
+ "query": {
+ "wildcard": {
+ "name": "001*"
+ }
+ }
+}
+
+
+# 正则搜索
+GET /zfzn/_search
+{
+ "query": {
+ "regexp": {
+ "name": "无*"
+ }
+ }
+}
+
+
+# 模糊搜索
+GET /zfzn/_search
+{
+ "query": {
+ "fuzzy": {
+ "name": "萧"
+ }
+ }
+}
+
+# ids搜索
+
+GET /zfzn/_search
+{
+ "query": {
+ "ids": {
+ "type": "_doc",
+ "values": [
+ "QDSIFYIBm3HYdyw3Dx_k",
+ "QTSIFYIBm3HYdyw3ER8Q"
+ ]
+ }
+ }
+}
+
+
+# 布尔搜索
+
+POST /zfzn/_search
+{
+ "query": {
+ "bool": {
+ "must": {
+ "match": {
+ "name": "天"
+ }
+ },
+ "filter": {
+ "term": {
+ "name": "无"
+ }
+ },
+ "must_not": {
+ "range": {
+ "age": {
+ "gte": 60,
+ "lte": 90
+ }
+ }
+ },
+ "boost": 1
+ }
+ }
+}
+
+
+# 排序
+POST /zfzn/_search
+{
+ "query": {
+ "match_all": {}
+ },
+ "sort": [
+ {
+ "age": {
+ "order": "desc"
+ }
+ }
+ ]
+}
+
+
+# 分页
+POST /zfzn/_search
+{
+ "query": {
+ "match_all": {}
+ },
+ "size": 2,
+ "from": 0
+}
+
+
+# 函数使用
+POST /zfzn/_search
+{
+ "size": 0,
+ "aggs": {
+ "max_age": {
+ "max": {
+ "field": "age"
+ }
+ }
+ }
+}
+
+POST /zfzn/_search
+{
+ "size": 0,
+ "aggs": {
+ "min_age": {
+ "min": {
+ "field": "age"
+ }
+ }
+ }
+}
+
+POST /zfzn/_search
+{
+ "size": 0,
+ "aggs": {
+ "sum_age": {
+ "sum": {
+ "field": "age"
+ }
+ }
+ }
+}
+
+
+# 计数
+POST /zfzn/_count
+{
+ "query": {
+ "range": {
+ "age": {
+ "gt": 10
+ }
+ }
+ }
+}
+
+# 某字段有值的文档数
+POST /zfzn/_search?size=0
+{
+ "aggs": {
+ "age_count": {
+ "value_count": {
+ "field": "age"
+ }
+ }
+ }
+}
+
+
+# 去重计数
+POST /zfzn/_search?size=0
+{
+ "aggs": {
+ "age_count": {
+ "cardinality": {
+ "field": "age"
+ }
+ }
+ }
+}
+
+
+# 统计多个函数值
+POST /zfzn/_search?size=0
+{
+ "aggs": {
+ "price_stats": {
+ "stats": {
+ "field": "age"
+ }
+ }
+ }
+}
+
+# 分组 带having
+POST /zfzn/_search
+{
+ "size": 0,
+ "aggs": {
+ "group_by_age": {
+ "range": {
+ "field": "age",
+ "ranges": [
+ {
+ "from": 0,
+ "to": 20
+ },
+ {
+ "from": 20,
+ "to": 40
+ },
+ {
+ "from": 40,
+ "to": 100
+ }
+ ]
+ },
+ "aggs": {
+ "average_age": {
+ "avg": {
+ "field": "age"
+ }
+ },
+ "having": {
+ "bucket_selector": {
+ "buckets_path": {
+ "avg_age": "average_age"
+ },
+ "script": {
+ "source": "params.avg_age >= 50 "
+ }
+ }
+ }
+ }
+ }
+ }
+}
+// 导出导入实体类
+@Data
+public class R implements Serializable, IExcelModel, IExcelDataModel {
+
+ private static final long serialVersionUID = -3099653964677586050L;
+
+ private int rowNum;
+
+ private String errorMsg;
+
+ @Excel(name = "导入字段", width = 20)
+ @NotBlank
+ private String field;
+
+
+ @Override
+ public Integer getRowNum() {
+ return rowNum;
+ }
+
+ @Override
+ public void setRowNum(Integer rowNum) {
+ this.rowNum = rowNum;
+ }
+
+ @Override
+ public String getErrorMsg() {
+ return errorMsg;
+ }
+
+ @Override
+ public void setErrorMsg(String errorMsg) {
+ this.errorMsg = errorMsg;
+ }
+}
+ public void exportExcel(HttpServletResponse response, HttpServletRequest request) throws IOException {
+ Workbook workbook;
+ String filename = "导出.xlsx";
+ ExportParams exportParams = new ExportParams();
+ exportParams.setDictHandler(deviceTypeHandler);
+ workbook = ExcelExportUtil.exportExcel(exportParams, R.class, new ArrayList<>());
+ // 告诉浏览器用什么软件可以打开此文件
+ response.setHeader("content-Type", "application/vnd.ms-excel");
+ // 下载文件的默认名称
+ response.setHeader("Content-Disposition", "attachment;filename=utf-8" + URLEncoder.encode(filename, "UTF-8"));
+ response.setCharacterEncoding("UTF-8");
+ workbook.write(response.getOutputStream());
+ }
+public Result importExcel(MultipartFile file) throws Exception {
+ ImportParams importParams = new ImportParams();
+ importParams.setNeedVerify(true);
+ importParams.setDictHandler(deviceTypeHandler);
+ ExcelImportResult<R> result = ExcelImportUtil.importExcelMore(file.getInputStream(), R.class, importParams);
+ // 错误打印业务逻辑
+ if (result.isVerifyFail()) {
+ return Result.error(result.getFailList().stream().map(item -> "第" + item.getRowNum() + "行报错,错误信息:" + item.getErrorMsg()).collect(Collectors.joining(",")));
+ } else {
+ // 导入数据处理业务逻辑
+ return Result.success("导入成功");
+ }
+ }
+最近要写导出导入,长时间没用导致都忘了写法了,特此记录一下,方便日后使用!
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ | 命令 | +说明 | +
|---|---|
git init <directory> |
+在指定目录创建一个空的Git仓库。如果不带参数，则在当前目录初始化为Git仓库。 | +
git clone <repo> |
+克隆位于 <repo> 的仓库到本地机器。原始仓库可以位于本地文件系统或通过 HTTP 或 SSH 位于远程机器上。 |
+
git config --global user.name <name> |
+定义用于当前仓库所有提交的作者名称。开发者通常使用 -global 标志为当前用户设置配置选项。 |
+
git add <directory> |
+将 <directory> 替换为 <file> 可以针对特定文件进行更改。 |
+
git commit -m <message> |
+提交已暂存的快照，但不会启动文本编辑器，而是使用 <message> 作为提交消息。 |
+
git status |
+显示暂存、未暂存和未跟踪的文件列表。 | +
git log |
+使用默认格式显示完整的提交历史记录。 | +
git diff |
+显示索引和工作目录之间未暂存的更改。 | +
git revert <commit> |
+创建一个新的提交，撤消在 <commit> 中进行的所有更改，然后将其应用于当前分支。 |
+
git reset <file> |
+从暂存区中移除 <file>，但不更改工作目录。这将取消暂存文件，而不会覆盖任何更改。 |
+
git clean -n |
+显示将从工作目录中删除的文件列表。 | +
git commit --amend |
+用暂存的更改和上一次提交的更改组合替换最后一次提交。如果没有暂存任何内容，则可编辑最后一次提交的消息。 | +
git rebase <base> |
+将当前分支变基到 <base>。<base> 可以是提交ID、分支名称、标签或相对于HEAD的引用。 |
+
git remote add <name> <url> |
+创建到远程仓库的新连接。添加远程后，您可以在其他命令中使用 <name> 作为 <url> 的快捷方式。 |
+
git fetch <remote> <branch> |
+从仓库中获取特定 <branch>。省略 <branch> 以获取所有远程引用。 |
+
git pull <remote> |
+获取指定远程仓库的当前分支的副本，并立即将其合并到本地副本。 | +
git push <remote> <branch> |
+将分支推送到 <remote>，包括必要的提交和对象。如果远程仓库中不存在该分支，则创建命名分支。 |
+
git config --global user.name <name> |
+定义当前用户的所有提交的作者名称。 | +
git config --global user.email <email> |
+定义当前用户的所有提交的作者电子邮件。 | +
git config --global alias.<alias> <git command> |
+为Git命令创建一个快捷方式。例如，alias.glog "log --graph --oneline" 将使 git glog 等同于 git log --graph --oneline。 |
+
git config --system core.editor <editor> |
+设置用于所有用户的机器上的命令使用的文本编辑器。<editor:arg> 应为启动所需编辑器的命令，例如 vi。 |
+
git config --global --edit |
+使用文本编辑器打开全局配置文件进行手动编辑。 | +
git log -<limit> |
+限制提交数量为 <limit>。例如，”git log -5” 将限制为5个提交。 |
+
git log --oneline |
+将每个提交压缩为一行显示。 | +
git log -p |
+显示每个提交的完整差异。 | +
git log --stat |
+显示每个提交的修改的文件以及添加或删除的相对行数。 | +
git log --author=<pattern> |
+搜索特定作者的提交。 | +
git log --grep="<pattern>" |
+显示提交消息匹配 <pattern> 的提交。 |
+
git log <since>..<until> |
+显示在 <since> 和 <until> 之间发生的提交。参数可以是提交ID、分支名称、HEAD 或任何其他类型的修订引用。 |
+
git log -- <file> |
+仅显示涉及指定文件的提交。 | +
git log --graph --decorate |
+在提交消息左侧绘制基于文本的提交图。使用 --decorate 添加显示提交的分支或标签的名称。 |
+
git diff HEAD |
+显示工作目录与上一次提交之间的差异。 | +
git diff --cached |
+显示暂存更改与上一次提交之间的差异。 | +
git reset |
+将暂存区重置为最近的提交，但保持工作目录不变。 | +
git reset --hard |
+将暂存区和工作目录重置为最近的提交，并覆盖工作目录中的所有更改。 | +
git reset <commit> |
+将当前分支的提交点向后移动到 <commit>，重置暂存区以匹配，但保持工作目录不变。 |
+
git reset --hard <commit> |
+将当前分支的提交点向后移动到 <commit>，重置暂存区和工作目录以匹配，并删除 <commit> 之后的所有提交。 |
+
git rebase <base> |
+将当前分支交互式变基到 <base>。启动编辑器以输入如何将每个提交转移到新的基准的命令。 |
+
git pull --rebase <remote> |
+获取指定远程仓库的当前分支的副本，并将其变基到本地分支。使用 git rebase 而不是合并来整合分支。 |
+
git push <remote> --force |
+强制执行 git push，即使结果是非快进合并。不要使用 --force 标志，除非您确切知道自己在做什么。 |
+
git push <remote> --all |
+将所有本地分支推送到指定的远程仓库。 | +
git push <remote> --tags |
+将所有本地标签推送到远程仓库。标签在推送分支或使用 --all 标志时不会自动推送。 |
+
+ 微信支付
+
+ 支付宝支付
+
+
+ Git 是一个用于管理源代码的分布式版本控制系统。
+那么什么是版本控制？简而言之，版本控制是用于跟踪文件更改的系统。修改文件时，版本控制系统会记录并保存每个更改。这允许您随时还原以前版本的代码。
+最初的版本控制系统，它们使用简单的数据库或文件复制的方式来保存不同的版本，但是容易出错和丢失数据。例如 RCS。
+后来出现的版本控制系统，它们使用一个中央服务器来保存所有文件的修订版本，而客户端通过网络连接来取出或提交更新。这样可以方便地管理权限和协作，但是也有单点故障和必须联网的缺点。例如 CVS、SVN和 Perforce。
+最新的版本控制系统，它们允许每个客户端完整地镜像整个代码仓库，包括所有的历史记录。这样可以提高速度和安全性，也可以支持更灵活的协作模式。例如 Git、Mercurial、Bazaar 和 Darcs
+下载最新的 Git for Windows 安装程序。
+成功启动安装程序后，应会看到 Git 安装程序向导屏幕。按照“下一步”和“完成”提示完成安装。默认选项对于大多数用户来说非常明智。
+打开命令提示符（如果在安装过程中选择不使用 Windows 命令提示符下的 Git，则打开 Git Bash）。
使用以下命令配置您的 Git 用户名和电子邮件,注意替换信息
+
+ $ git config --global user.name "wangwangit"
+$ git config --global user.email "wangwangit@qq.com"
+在 shell 中，使用 apt-get 安装 Git：
+$ sudo apt-get update
+$ sudo apt-get install git
+通过键入 git --version 验证安装是否成功：
$ git --version
+git version 2.9.2
+使用以下命令配置您的 Git 用户名和电子邮件,注意替换信息
+$ git config --global user.name "wangwangit"
+$ git config --global user.email "wangwangit@qq.com"
+下载最新的 Git for Mac 安装程序。Git for Mac installer
+按照提示安装 Git。
+打开终端并通过键入 git --version 验证安装是否成功：
$ git --version
+git version 2.9.2
+使用以下命令配置您的 Git 用户名和电子邮件,注意替换信息
+$ git config --global user.name "wangwangit"
+$ git config --global user.email "wangwangit@qq.com"
+Git是一个版本控制系统，包括三个主要组件：存储库（Repository）、工作树（Working Tree）和索引（Index）。了解这些组件以及Git中的文件状态对于有效的协作和代码管理至关重要。
+
基本的Git工作流程包括以下步骤：
+
Git中的文件可以存在三种主要状态：
+
虽然我们可以在本地存储库中利用 Git 版本控制功能，但协作功能（例如与团队成员一起拉取和推送代码更改）将更适合远程存储库。
+SSH 密钥是一种用于 SSH（安全外壳）网络协议的访问凭证。SSH 是一种用于在不安全的开放网络上进行远程机器之间的认证和加密的安全网络协议。SSH 可用于远程文件传输，网络管理和远程操作系统访问。SSH 这个缩写也用来描述一组用于与 SSH 协议交互的工具。
+执行下面命令创建密钥,此命令将使用电子邮件作为标签创建新的 SSH 密钥
+ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
+系统将提示您“输入要在其中保存密钥的文件”。您可以指定一个文件位置， 或者按“Enter”键接受默认 的文件位置。
+> Enter a file in which to save the key (/Users/you/.ssh/id_rsa): [Press enter]
+下一个提示会要求您输入一个安全 的密码短语。 密码短语会为 SSH 增加一层额外 的安全性， 并且每次使用 SSH 密 钮时都需要输入密码短语。 如果有人获得了存储私钥的计算机的访问权限，他们也可能获得使用该密钥的任何系统的访问权限。为密钥添加密码短语可以防止这种情况发生。
+ssh-agent是另一个属于SSH工具套件的程序。ssh-agent负责保存私钥。可以把它想象成一个钥匙链。除了保存私钥外，它还代理使用私钥对SSH请求进行签名的请求，以便私钥不会不安全地传递。
+在将新的SSH密钥添加到ssh-agent之前，首先确保ssh-agent正在运行，通过执行：
+$ eval "$(ssh-agent -s)"
+一旦ssh-agent运行起来，以下命令将把新的SSH密钥添加到本地SSH代理。
+$ ssh-add ~/.ssh/id_rsa
+新的SSH密钥现在已经注册并准备好使用了！
+Git 分支本质上是一个独立的开发线。它将您的工作与其他团队成员的工作隔离开来。
+
git branch issue1
+
git checkout issue1
+对于新存储库，Git 默认将 HEAD 指向主分支。更改 HEAD 指向的位置将更新您当前的活动分支。
+~（波浪号）和 ^（插入符号）符号用于指向相对于特定提交的位置。这些符号与提交引用一起使用，通常是 HEAD 或提交哈希。
+
每当切换到工作树中具有未提交更改（或添加了新文件）的另一个分支时，这些未提交的更改也将传递到切换到的新分支。您提交的更改将提交到新切换的分支。
+但是，如果 Git 发现新切换分支中的文件与上一个分支中的未提交更改之间存在冲突，则不允许切换到另一个分支。在切换分支之前，必须先提交或存储这些更改。可以使用如下命令进行暂存
+git stash
+
Git 标记用于标记和标记历史记录中的特定提交。标记通常用于指示发布版本，其中版本名称（即 v1.0）是标记的名称。有两种类型的 Git 标记：
+
此示例假定你已有一个要在其中创建存储库的现有项目文件夹。
+首先 cd 到根项目文件夹，然后执行 git init 命令。
cd /path/to/your/existing/code
+git init
+以下命令具有同等效果
+git init <project directory>
+
如果已在中央存储库中设置了项目，则可以使用git clone获取本地工作副本.
git clone <repo url>
+Git 支持几种不同的网络协议和相应的 URL 格式。例如SSH,HTTP等
+
Git 不会自动保存您所做的每项更改。您必须通过暂存这些更改来告诉 Git 要记录哪些更改。暂存后，可以提交更改，以便将它们记录在存储库中。
+
现在，您已经克隆或初始化了存储库，您可以向其提交文件版本更改。以下示例假定您已在 /path/to/project 处设置了一个项目。此示例中执行的步骤如下：
/path/to/projecthello.txt hello.txt 添加到存储库暂存区域
执行此示例后，存储库现在会将 hello.txt 添加到历史记录中，并将跟踪文件的未来更新。
git add命令用于将文件的更改添加到暂存区（即将更改的文件添加到下一次提交中）。它将修改过的文件从工作目录添加到Git的暂存区，准备进行提交。使用git add可以选择性地将特定文件或整个目录添加到暂存区。
git commit命令用于将暂存区中的更改提交到本地代码仓库。提交操作将创建一个新的提交记录，该记录包含了暂存区中文件的当前状态。每次提交都需要包含一个描述性的提交消息，以便更好地描述所做的更改。
如果用 git clone 创建本地库，就可以用 git push 同步远程库。如果用 git init 创建本地库，就要先在托管服务上建远程库，再用 Git URL 链接本地库。
git remote add <remote_name> <remote_repo_url>
+此命令会将 远程存储库映射到本地存储库中 。映射远程存储库后，可以将本地分支推送到该存储库。
git config是一个命令行工具，用于配置Git安装或单个仓库的选项。这些选项可以影响Git的行为和外观，例如你的用户名、邮箱、文本编辑器、别名等。Git存储配置选项在三个不同的文件中，分别对应于本地仓库、用户或整个系统的设置。你可以用不同的标志来指定配置选项的作用范围，也可以直接编辑纯文本文件来修改。
+配置文件:
+当这些文件中的选项发生冲突时，本地设置会覆盖用户设置，用户设置会覆盖系统设置。如果你打开任何一个文件，你会看到类似以下内容：
+[user]
+ name = John Smith
+ email = john@example.com
+[alias]
+ st = status
+ co = checkout
+ br = branch
+ up = rebase
+ ci = commit
+[core]
+ editor = vim
+git push -u <remote_name> <local_branch_name>
+此命令会将 < local_branch_name > 下的本地存储库分支推送到 < remote_name > 的远程存储库。
Git diff 是一个命令，它可以比较两个数据源，并显示它们之间的差异。数据源可以是提交、分支、文件等。例如，你可以使用 git diff 来：
+git diff）。git diff --staged）。git diff commit1 commit2）。git diff branch1 branch2）。git diff commit）。git stash 命令获取未提交的更改（暂存和未暂存），保存这些更改以供以后使用，然后从工作副本中还原它们。
您可以使用 git stash pop 重新应用以前隐藏的更改,会从存储中删除更改，并将它们重新应用于工作副本。
或者，您可以将更改重新应用于工作副本，并将它们保留在存储中，通过使用用 git stash apply
下图是关于git statsh命令作用文件的范围:
+
Git 将工作副本中的每个文件视为以下三件事之一：
+忽略的文件通常是构建工件和计算机生成的文件，这些文件可以从存储库源派生，否则不应提交。一些常见的例子是：
+/node_modules 或 /packages 的内容.o 、 .pyc 和 .class 文件/bin 、 /out 或 /target.log 、 .lock 或 .tmp.DS_Store 或 Thumbs.db.idea/workspace.xml.gitignore 是一个文件，用于指定 Git 应该忽略的文件。已经被 Git 跟踪的文件不受影响。
+.gitignore 文件中的每一行都是一个匹配模式，可以使用通配符、前缀、后缀等规则来匹配文件或目录。
+.gitignore 文件可以放在项目的根目录或任何子目录中，也可以放在 $GIT_DIR/info/exclude 或由 core.excludesFile 配置变量指定的文件中。
+.gitignore 文件的作用是让 Git 忽略一些不需要版本控制的文件，比如编译生成的文件、临时文件、编辑器生成的文件等。
+git status 命令显示工作目录和暂存区域的状态。它使你能够查看哪些更改已暂存，哪些尚未暂存，以及哪些文件未被 Git 跟踪。状态输出不会显示有关已提交项目历史记录的任何信息。
git log 命令显示已提交的快照。它允许您列出项目历史记录、对其进行过滤并搜索特定更改。
git tag是指向 Git 历史记录中特定点的引用。标记通常用于捕获用于标记版本（即 v1.0.1）的历史记录点。标签就像一个不会改变的分支。与分支不同，标签在创建后没有进一步的提交历史记录。
Git 最有价值的功能之一是能够撤消错误。当您进行新提交时，Git 会存储项目的快照，以便您可以在需要时返回到早期版本。
+git checkout用于切换工作目录到指定的分支、标签或提交记录。
如下: 根据一个历史提交,签出一个新的分支
+git checkout -b new_branch_without_crazy_commit
+
git revert 命令是一种向前移动的撤消操作，它提供了一种撤消更改的安全方法。还原不会删除或孤立提交历史记录中的提交，而是创建一个新的提交，该提交将反向更改指定的提交记录。
示例
+
我们对存储库进行了 3 次提交，其中我们添加了一个文件 1.txt 并修改了两次其内容。在存储库设置过程结束时,我们传入了 HEAD 引用。这将还原最新的提交。Git revert 期望传入一个提交引用，如果没有提交引用，则不会执行。可以看到执行完成之后,状态回到了上一步提交时.
参数
+-e 选项的反转。还原不会打开编辑器。git revert 创建反向提交目标提交的新提交。此选项不会创建新的提交，而是将反向更改添加到暂存索引和工作目录。
有三种重置模式:
+
示例
+假设你有一个Git仓库，里面有三个提交，分别是A，B和C，如下图所示：
+
现在你的HEAD和main分支都指向C，你的暂存区和工作目录都和C一致。如果你想回退到B，你可以用不同的reset模式来实现：
+
这样的话，你可以重新提交C的更改，或者添加其他更改到暂存区。
+
这样的话，你可以重新暂存C的更改，或者放弃它们。
+
这样的话，你就彻底回退到了B的状态，无法恢复C的更改。
+希望这个示例能帮助你理解reset三种模式的区别。
+git clean是一个用于删除工作目录中未跟踪文件的命令。未跟踪文件是指在工作目录中创建但没有使用git add添加到Git索引的文件。git clean可以与git reset和git checkout等命令配合使用，以撤销对仓库的修改。
+git clean -n：这个命令会列出工作目录中将要被删除的未跟踪文件，但不会真正删除它们。这是一个干运行，可以用来检查删除的文件是否正确。git clean -f：这个命令会强制删除工作目录中的未跟踪文件。这是一个危险的操作，因为一旦删除，文件就无法恢复。在使用这个命令之前，最好先备份文件或使用干运行选项。git clean -d：这个命令会删除工作目录中的未跟踪目录，以及它们包含的文件。如果不使用这个选项，git clean只会删除未跟踪的文件，而保留空的目录。git clean -i：这个命令会进入交互式模式，让用户选择要删除的文件或目录。用户可以输入不同的过滤条件，如扩展名、大小、时间等，来筛选要删除的文件。用户还可以预览删除的结果，或取消删除操作。git clean -x：这个命令会删除工作目录中所有的未跟踪文件，包括那些被.gitignore文件忽略的文件。如果不使用这个选项，git clean只会删除那些没有被忽略的未跟踪文件。git rm 命令可用于删除单个文件或文件集合。 git rm 的主要功能是从 Git 索引中删除跟踪的文件。
远程仓库允许我们与团队的其他成员共享我们的更改。它们可以位于私人服务器上，也可以位于与您的计算机不同的计算机上，或者使用积压工作等服务托管。无论您的仓库托管在何处，您都需要能够经常将本地仓库与远程仓库同步。您将使用三个命令执行此操作：git push、git pull 和 git merge。
+执行拉取时，最新的修订历史记录将从远程存储库下载并导入到本地存储库。
+
为了开始与他人共享更改，您必须使用“push”命令将它们推送到远程存储库。
+
如果您的本地仓库未更新，则推送到远程仓库将被拒绝
+
如果是这种情况，您必须使用 git merge 命令从远程存储库获取最新更改，然后才能允许推送。Git 强制执行此操作以确保其他成员所做的更改保留在历史记录中。
+
git remote 命令允许您创建、查看和删除与其他存储库的连接。
＜name＞ 的远程存储库的连接。＜old-name＞ 重命名为 ＜new-name＞git fetch 命令将提交、文件和引用从远程存储库下载到本地存储库中。它不会强迫您将更改实际合并到存储库中。Git 将获取的内容与现有的本地内容隔离开来;它绝对不会影响您当地的开发工作。
可以通过运行 git commit –amend 来修改同一分支中的最新提交。此命令便于将新的或更新的文件添加到以前的提交中。这也是编辑或向上一次提交添加注释的简单方法。
+
rebase是将提交到一个分支的所有更改应用到新分支的过程。运行 git rebase 并添加 -i 选项以重写、替换、删除和合并历史记录中的单个提交。您还可以：
+
将另一个分支中的现有提交应用到存储库中的当前分支
+
压缩是将多个提交合并为单个提交的过程。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 故事的主角是小明，一个刚入门编程的小白。他正在为一个项目写代码，但是他发现每次修改代码都很麻烦，因为他要不断地备份文件，而且很容易弄混版本。有一天，他听说了一个叫Git的神奇工具，可以帮助他管理代码的变化。他决定尝试一下，于是他打开了终端，输入了下面的命令：
+
+ git init # 初始化一个本地仓库
+git add . # 添加所有文件到暂存区
+git commit -m "first commit" # 提交第一次修改到本地仓库
+这样，他就成功地创建了一个Git仓库，并且保存了他的第一个版本。他觉得很开心，因为这样他就不用担心代码丢失或者混乱了。😁
+小明觉得自己的代码写得很不错，想要分享给其他人看看。但是他发现把文件发给别人很麻烦，而且如果别人也修改了代码，就很难合并。有一天，他听说了一个叫GitHub的网站，可以免费托管Git仓库，并且方便和其他人协作。他决定尝试一下，于是他注册了一个GitHub账号，并且在网站上创建了一个空的仓库。
+然后，他在终端输入了下面的命令：
+git remote add origin https://github.com/xiaoming/myproject.git # 添加远程仓库地址
+git push -u origin master # 推送本地master分支到远程仓库
+这样，他就成功地把自己的代码上传到了GitHub上，并且和远程仓库建立了联系。他觉得很兴奋，因为这样他就可以和全世界的程序员交流了。😍
+小明在GitHub上发现了一个很有趣的开源项目，想要参与其中。但是他不想直接修改别人的代码，而是想先在自己的电脑上做一些改进，然后再提交给项目的作者。有一天，他听说了一个叫分支的概念，可以让他在不影响主线的情况下，创建自己的代码版本。他决定尝试一下，于是他在终端输入了下面的命令：
+git clone https://github.com/someone/awesome-project.git # 从远程仓库克隆项目到本地
+cd awesome-project # 进入项目目录
+git checkout -b dev # 创建并切换到dev分支
+这样，他就成功地在本地创建了一个dev分支，并且和远程仓库的master分支分开了。他觉得很自由，因为这样他就可以随心所欲地修改代码了。😎
+小明在dev分支上修改了一些代码，觉得很满意，想要把自己的改进合并到master分支上，然后推送到远程仓库，让项目的作者看看。有一天，他听说了一个叫合并的操作，可以把两个分支的代码合并成一个。他决定尝试一下，于是他在终端输入了下面的命令：
+git checkout master # 切换到master分支
+git merge dev # 合并dev分支到master分支
+git push origin master # 推送master分支到远程仓库
+这样，他就成功地把自己的代码合并到了master分支，并且推送到了远程仓库。他觉得很骄傲，因为这样他就可以为开源项目做出贡献了。😊
+但是，有时候合并分支并不是一帆风顺的。有一次，小明在dev分支上修改了一个文件，而项目的作者也在master分支上修改了同一个文件，并且先于小明推送到了远程仓库。当小明想要合并分支时，就发生了冲突。有一天，他听说了一个叫解决冲突的方法，可以手动选择保留哪些代码。他决定尝试一下，于是他在终端输入了下面的命令：
+git pull origin master # 拉取远程仓库的master分支
+git merge master # 合并master分支到dev分支
+# 打开冲突文件，编辑保存
+git add . # 添加所有文件到暂存区
+git commit -m "fix conflict" # 提交修改到本地仓库
+git push origin dev # 推送dev分支到远程仓库
+这样，他就成功地解决了冲突，并且把自己的代码推送到了远程仓库。他觉得很成就感，因为这样他就可以和其他人协作了。😄
+小明在dev分支上开发了一个新功能，觉得很完美，想要给这个版本打一个标签，方便以后查找。有一天，他听说了一个叫标签的概念，可以给某个版本起一个有意义的名字。他决定尝试一下，于是他在终端输入了下面的命令：
+git tag v1.0 # 给当前版本打一个v1.0的标签
+git push origin v1.0 # 推送标签到远程仓库
+这样，他就成功地给自己的代码打了一个标签，并且推送到了远程仓库。他觉得很方便，因为这样他就可以快速定位到某个版本了。😎
+但是，有时候有些文件是不需要被Git管理的，比如编译生成的临时文件，或者敏感信息的配置文件。有一天，他听说了一个叫忽略特殊文件的方法，可以让Git自动忽略掉这些文件。他决定尝试一下，于是他在项目根目录下创建了一个.gitignore文件，并且写入了下面的内容：
+*.tmp # 忽略所有.tmp后缀的文件
+config.ini # 忽略config.ini文件
+这样，他就成功地让Git忽略掉了这些特殊文件，并且不会被提交到仓库中。他觉得很安全，因为这样他就可以避免泄露隐私或者浪费空间了。😊
+小明和小红是一个团队的成员，他们都在GitHub上为同一个开源项目贡献代码。有一天，小明在本地修改了一个文件的名字，把它从README.md改成了Readme.md，然后提交并推送到了远程仓库。小红在自己的电脑上拉取了最新的代码，但是她发现自己的文件名还是README.md，而且Git提示她有一个未合并的文件。她很困惑，不知道为什么会出现这样的情况。
+原来，这是因为Git在不同的操作系统上对文件名大小写的敏感度不同。在Linux和Mac OS X上，Git是区分大小写的，所以README.md和Readme.md是两个不同的文件。但是在Windows上，Git是不区分大小写的，所以README.md和Readme.md是同一个文件。当小明把文件名改成了Readme.md时，Git认为他删除了README.md，并且创建了一个新的文件Readme.md。当小红拉取代码时，Git认为她需要合并这两个文件，所以出现了冲突。
+有一天，他们听说了一个叫解决大小写不一致导致的合并冲突的方法，可以让Git在Windows上也区分大小写。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git config core.ignorecase false # 设置Git在Windows上也区分大小写
+git mv README.md Readme.md # 重命名文件
+git commit -m "rename file" # 提交修改
+git push origin master # 推送到远程仓库
+这样，他们就成功地解决了大小写不一致导致的合并冲突，并且保持了文件名的一致性。他们觉得很开心，因为这样他们就可以避免以后出现同样的问题了。😁
+小明和小红在开发一个新功能时，不小心提交了一些错误的代码，导致项目无法运行。他们想要撤销这些提交，但是又不想丢失他们的修改。有一天，他们听说了一个叫reset的命令，可以让他们回退到某个版本，但是保留他们的修改。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git reset HEAD~2 # 回退到两个版本之前，保留修改
+git status # 查看修改的状态
+git add . # 重新添加修改到暂存区
+git commit -m "fix bug" # 重新提交修改
+git push -f origin master # 强制推送到远程仓库
+这样，他们就成功地撤销了错误的提交，并且重新提交了正确的代码。他们觉得很轻松，因为这样他们就可以修复bug了。😊
+但是，有时候reset命令也会带来麻烦。有一次，小明在回退版本时，不小心加了一个–hard选项，导致他的修改全部丢失了。他很慌张，不知道如何找回他的修改。有一天，他听说了一个叫reflog的命令，可以让他查看所有的提交历史，包括已经被删除或者回退的提交。他决定尝试一下，于是他在终端输入了下面的命令：
+git reflog # 查看所有的提交历史
+git reset --hard c761f5c # 回退到指定的版本
+git status # 查看修改的状态
+这样，他就成功地找回了他丢失的修改，并且恢复到了正确的版本。他觉得很幸运，因为这样他就可以继续开发了。😄
+小明和小红在同一个分支上开发一个新功能，他们经常需要拉取对方的代码，然后合并到自己的代码中。有一天，他们听说了一个叫pull的命令，可以让他们一步完成拉取和合并的操作。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git pull origin master # 拉取并合并远程仓库的master分支
+这样，他们就成功地把对方的代码合并到了自己的代码中，并且保持了同步。他们觉得很方便，因为这样他们就可以避免手动合并的麻烦了。😎
+但是，有时候pull命令也会带来问题。有一次，小明和小红在同一个文件上修改了同一行代码，导致出现了冲突。他们很困惑，不知道如何解决这个冲突。有一天，他们听说了一个叫解决冲突的方法，可以让他们手动选择保留哪些代码。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git pull origin master # 拉取并合并远程仓库的master分支
+# 打开冲突文件，编辑保存
+git add . # 添加所有文件到暂存区
+git commit -m "merge conflict" # 提交修改到本地仓库
+git push origin master # 推送到远程仓库
+这样，他们就成功地解决了冲突，并且把自己的代码推送到了远程仓库。他们觉得很成就感，因为这样他们就可以和对方协作了。😄
+小明和小红在同一个项目上开发不同的功能，他们分别在自己的分支上提交了一些代码。有一天，他们想要把自己的代码合并到主分支上，但是他们不知道应该用rebase还是merge。有一天，他们听说了一个叫rebase和merge的区别的概念，可以让他们选择合适的方式来合并代码。他们决定尝试一下，于是他们在终端输入了下面的命令：
+# 小明在dev1分支上
+git checkout dev1 # 切换到dev1分支
+git rebase master # 把dev1分支变基到master分支
+git push -f origin dev1 # 强制推送dev1分支到远程仓库
+git checkout master # 切换到master分支
+git merge dev1 # 合并dev1分支到master分支
+git push origin master # 推送master分支到远程仓库
+
+# 小红在dev2分支上
+git checkout dev2 # 切换到dev2分支
+git merge master # 合并master分支到dev2分支
+git push origin dev2 # 推送dev2分支到远程仓库
+git checkout master # 切换到master分支
+git merge dev2 # 合并dev2分支到master分支
+git push origin master # 推送master分支到远程仓库
+这样，他们就成功地把自己的代码合并到了主分支上，但是他们发现了一个不同的地方。小明用了rebase命令，他的提交历史是一条直线，没有任何分叉；小红用了merge命令，她的提交历史是有多个分叉和汇合的结构。他们觉得很好奇，不知道这两种方式有什么优缺点。
+原来，rebase和merge的区别是：
+rebase和merge各有优缺点：
+所以，在选择rebase还是merge时，要根据具体的情况和需求来决定。一般来说：
+小明和小红在合并分支时，不小心合并了错误的分支，导致项目出现了很多bug。他们想要撤销这次合并，但是又不想丢失他们的修改。有一天，他们听说了一个叫revert的命令，可以让他们用一次新的提交来回滚之前的提交。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git log # 查看提交历史
+git revert <commit ID> # 回滚指定的提交
+git push origin master # 推送到远程仓库
+这样，他们就成功地撤销了错误的合并，并且用一次新的提交来记录这次回滚。他们觉得很安全，因为这样他们就不会丢失任何修改了。😊
+但是，有时候revert命令也会带来麻烦。有一次，小明在回滚一个合并时，不小心加了一个–no-commit选项，导致他的修改没有被提交，而是被放在了暂存区。他很慌张，不知道如何恢复这次回滚。有一天，他听说了一个叫reset的命令，可以让他回退到某个版本，并且保留或者丢弃他的修改。他决定尝试一下，于是他在终端输入了下面的命令：
+git reset --soft HEAD^ # 回退到上一个版本，并且保留修改
+git status # 查看修改的状态
+git add . # 重新添加修改到暂存区
+git commit -m "fix bug" # 重新提交修改
+git push -f origin master # 强制推送到远程仓库
+这样，他就成功地恢复了这次回滚，并且重新提交了正确的代码。他觉得很轻松，因为这样他就可以修复bug了。😊
+小明和小红在完成一个功能后，想要删除自己的分支，因为他们觉得这个分支已经没有用了。有一天，他们听说了一个叫delete的命令，可以让他们删除本地或者远程的分支。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git branch -d dev1 # 删除本地的dev1分支
+git push origin --delete dev1 # 删除远程的dev1分支
+这样，他们就成功地删除了自己的分支，并且释放了一些空间。他们觉得很爽快，因为这样他们就可以开始新的功能了。😎
+但是，有时候delete命令也会带来后悔。有一次，小明在删除一个分支后，发现自己还需要这个分支上的一些代码。他很懊恼，不知道如何找回这个分支。有一天，他听说了一个叫reflog的命令，可以让他查看所有的提交历史，包括已经被删除或者回退的提交。他决定尝试一下，于是他在终端输入了下面的命令：
+git reflog # 查看所有的提交历史
+git checkout -b dev1 <commit ID> # 用指定的提交创建一个新的dev1分支
+git push origin dev1 # 推送dev1分支到远程仓库
+这样，他就成功地找回了自己的分支，并且恢复到了正确的版本。他觉得很幸运，因为这样他就可以继续使用这个分支了。😄
+到此为止，我已经给你讲完了小明和小红的故事，你觉得怎么样？👏
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 小明和小红在开发一个新功能时，他们需要切换到另一个分支去修复一个紧急的bug。但是他们的当前分支上还有一些未完成的修改，他们不想提交这些修改，也不想丢弃这些修改。有一天，他们听说了一个叫stash的命令，可以让他们暂存这些修改，然后在需要的时候恢复这些修改。他们决定尝试一下，于是他们在终端输入了下面的命令：
+
+ git stash # 暂存当前分支上的修改
+git checkout master # 切换到master分支
+git pull origin master # 拉取远程仓库的master分支
+git checkout -b hotfix # 创建并切换到hotfix分支
+# 修复bug并提交
+git checkout master # 切换到master分支
+git merge hotfix # 合并hotfix分支到master分支
+git push origin master # 推送master分支到远程仓库
+git branch -d hotfix # 删除hotfix分支
+git checkout dev # 切换回dev分支
+git stash pop # 恢复暂存的修改
+这样，他们就成功地暂存了未完成的修改，并且在修复bug后恢复了这些修改。他们觉得很灵活，因为这样他们就可以在不同的分支上切换了。😎
+但是，有时候stash命令也会带来困惑。有一次，小明在恢复暂存的修改时，发现自己之前暂存了多次的修改，但是不知道哪个是最新的。他很迷茫，不知道如何查看和管理这些暂存的修改。有一天，他听说了一个叫stash list和stash apply的命令，可以让他查看和恢复指定的暂存的修改。他决定尝试一下，于是他在终端输入了下面的命令：
+git stash list # 查看所有暂存的修改
+git stash apply stash@{1} # 恢复指定的暂存的修改
+这样，他就成功地查看和恢复了指定的暂存的修改，并且继续开发新功能。他觉得很清晰，因为这样他就可以管理自己的暂存了。😊
+小明和小红在提交代码时，有时候会发现自己忘记了添加一些文件，或者写错了提交信息。他们想要修改这些提交，但是又不想重新提交一次。有一天，他们听说了一个叫commit –amend的命令，可以让他们修改最近的提交。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git add . # 添加所有文件到暂存区
+git commit --amend # 修改最近的提交
+git push -f origin master # 强制推送到远程仓库
+这样，他们就成功地修改了最近的提交，并且覆盖了远程仓库上的提交。他们觉得很方便，因为这样他们就可以避免多余的提交了。😎
+但是，有时候commit –amend命令也会带来风险。有一次，小明在修改最近的提交时，不小心把自己的分支推送到了错误的远程分支上。他很惊慌，不知道如何撤回这次推送。有一天，他听说了一个叫revert的命令，可以让他用一次新的提交来回滚之前的提交。他决定尝试一下，于是他在终端输入了下面的命令：
+git log # 查看提交历史
+git revert <commit ID> # 回滚指定的提交
+git push origin master # 推送到远程仓库
+这样，他就成功地撤回了错误的推送，并且用一次新的提交来记录这次回滚。他觉得很安全，因为这样他就不会影响其他人的代码了。😊
+小明和小红在开发一个新功能时，有时候会发现自己的代码有一些错误或者不满意的地方。他们想要重置代码，使工作区回到过去的某个状态。有一天，他们听说了一个叫reset的命令，可以让他们回退到某个版本，并且保留或者丢弃他们的修改。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git log # 查看提交历史
+git reset --soft <commit ID> # 回退到指定的版本，并且保留修改
+git status # 查看修改的状态
+git add . # 重新添加修改到暂存区
+git commit -m "fix bug" # 重新提交修改
+git push -f origin master # 强制推送到远程仓库
+这样，他们就成功地重置了代码，并且重新提交了正确的代码。他们觉得很灵活，因为这样他们就可以修改自己的代码了。😎
+但是，有时候reset命令也会带来麻烦。有一次，小明在回退版本时，不小心加了一个–hard选项，导致他的修改全部丢失了。他很慌张，不知道如何找回他的修改提交。有一天，他听说了一个叫checkout的命令，可以让他切换到某个版本或者分支。他决定尝试一下，于是他在终端输入了下面的命令：
+git reflog # 查看所有的提交历史
+git checkout <commit ID> # 切换到指定的版本
+git status # 查看修改的状态
+这样，他就成功地找回了他丢失的修改，并且切换到了正确的版本。他觉得很幸运，因为这样他就可以继续开发了。😄
+小明和小红在删除或者回退提交时，有时候会发现自己不小心删除或者回退了一些重要的提交。他们想要查看和恢复这些提交，但是又不知道这些提交的ID。有一天，他们听说了一个叫reflog的命令，可以让他们查看所有的提交历史，包括已经被删除或者回退的提交。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git reflog # 查看所有的提交历史
+git checkout -b dev <commit ID> # 用指定的提交创建一个新的dev分支
+git push origin dev # 推送dev分支到远程仓库
+这样，他们就成功地查看和恢复了删除或者回退的提交，并且创建了一个新的分支。他们觉得很清晰，因为这样他们就可以管理自己的提交了。😊
+但是，有时候reflog命令也会带来困惑。有一次，小明在查看所有的提交历史时，发现自己有很多重复或者无用的提交。他很烦恼，不知道如何清理这些提交。有一天，他听说了一个叫rebase -i的命令，可以让他交互式地修改提交历史。他决定尝试一下，于是他在终端输入了下面的命令：
+git rebase -i HEAD~5 # 交互式地修改最近5个提交
+# 在编辑器中选择要保留、合并、修改或者删除的提交
+git push -f origin master # 强制推送到远程仓库
+这样，他就成功地清理了无用的提交，并且修改了提交历史。他觉得很方便，因为这样他就可以优化自己的代码了。😎
+小明和小红在开发一个新功能时，他们发现自己的分支上有一些提交是不需要的，或者是需要移到另一个分支上的。他们想要拣选特定的提交到另一个分支，但是又不想影响当前的分支。有一天，他们听说了一个叫cherry-pick的命令，可以让他们把特定的提交复制到当前的分支。他们决定尝试一下，于是他们在终端输入了下面的命令：
+git log # 查看提交历史
+git checkout master # 切换到master分支
+git cherry-pick <commit ID> # 把指定的提交复制到当前分支
+git push origin master # 推送到远程仓库
+这样，他们就成功地拣选了特定的提交到另一个分支，并且保持了当前分支的完整性。他们觉得很灵活，因为这样他们就可以移动自己的代码了。😎
+你已经听完了我给你讲的关于Git的故事，我很开心能够和你分享这些知识和技巧。我希望这些故事能够帮助你更好地理解和使用Git，让你的开发过程更加顺畅和高效。
+Git是一个非常强大和灵活的工具，它可以让你管理和协作你的代码，解决各种问题，创造更多的可能。但是Git也有一些复杂和难以掌握的地方，需要你不断地学习和实践，才能真正地掌握它。
+我希望你能够继续学习和探索Git的奥秘，发现更多的故事和技巧。如果你有任何问题或者建议，欢迎你随时联系我，我很乐意和你交流和讨论。
+原文地址: Git教程从入门到入土
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 这一步非必须，如果您有多张信用卡完全可以忽视此步骤，重新那张卡继续撸就是了。
+ps：此处是续费第一次续费账号绑卡移除非初始账号绑卡移除，若是初始账号绑卡移除是需要重新添加付款方式的。这里推荐Passbook Debit Card，大部分虚拟卡可能会提示无法使用预付卡。如有好的选择也欢迎推荐。
+进入Google云控制台，选择结算Billing>付款方式，移除信用卡。具体如下：
+https://console.cloud.google.com/
+1.点击结算
+
2.点击管理付款方式
+
3.点击移除
+
4.再次点击移除
+
5.完成信用卡解绑
+
Google账号账号自己注册下就行很方便，实在懒就直接万能的淘宝淘个Gmail账号，使用Gmail账号登陆即可。最好注意下登陆环境，尽量避免和前面的Google账户使用相同的环境登陆，可以使用另一个浏览器，采用无痕模式。
+打开谷歌控制台
+ +
点击免费开始使用
+
手机号验证
+
信用卡验证
+
完成创建
+
刚刚申请的Google云服务器，300美金的试用金已经到账，有效期91天。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 
随着互联网浪潮的翻腾，国内外涌现出越来越多优秀的社交网站让用户分享信息更加便捷。然后，如果你是一个不甘寂寞的程序猿，是否也想要搭建一个属于自己的个人网站，如果你曾经或者现在正有这样的想法，请跟随这篇文章发挥你的Geek精神，让你快速拥有自己的博客网站，写文章记录生活，享受这种从0到1的过程。
+ 首先我们需要一个Github账号,若是没有的话,可以前往官网注册一个,不懂的话,可以参考Github账号注册
+什么是Git ?
+简单来说Git是开源的分布式版本控制系统，用于敏捷高效地处理项目。我们网站在本地搭建好了，需要使用Git同步到GitHub上。
+如果想要了解Git的细节，参看廖雪峰老师的Git教程：Git教程
+从Git官网下载：Git - Downloading Package (git-scm.com)
+现在的机子基本都是64位的，选择64位的安装包，下载后安装，在命令行里输入git测试是否安装成功，若安装失败，参看其他详细的Git安装教程。
+安装成功后，将你的Git与GitHub帐号绑定，鼠标右击打开Git Bash
+
或者在菜单里搜索Git Bash，设置user.name和user.email配置信息：
+git config --global user.name "你的GitHub用户名"
+git config --global user.email "你的GitHub注册邮箱"
+生成ssh密钥文件：
+ssh-keygen -t rsa -C "你的GitHub注册邮箱"
+然后直接三个回车即可，默认不需要设置密码
然后找到生成的.ssh的文件夹中的id_rsa.pub密钥，将内容全部复制
打开SSH and GPG keys (github.com)页面，新建new SSH Key
+
Title为标题，任意填即可，将刚刚复制的id_rsa.pub内容粘贴进去，最后点击Add SSH key。
在Git Bash中检测GitHub公钥设置是否成功，输入 ssh git@github.com ：
如上则说明成功。这里之所以设置GitHub密钥原因是，通过非对称加密的公钥与私钥来完成加密，公钥放置在GitHub上，私钥放置在自己的电脑里。GitHub要求每次推送代码都是合法用户，所以每次推送都需要输入账号密码验证推送用户是否是合法用户，为了省去每次输入密码的步骤，采用了ssh，当你推送的时候，git就会匹配你的私钥跟GitHub上面的公钥是否是配对的，若是匹配就认为你是合法用户，则允许推送。这样可以保证每次的推送都是正确合法的。
+Hexo基于Node.js，Node.js下载地址：Download | Node.js 下载安装包，注意安装Node.js会包含环境变量及npm的安装，安装后，检测Node.js是否安装成功，在命令行中输入 node -v :
+
检测npm是否安装成功，在命令行中输入npm -v :
+
到这了，安装Hexo的环境已经全部搭建完成。
+打开https://github.com/，新建一个项目，如下所示：
+
然后如下图所示，输入自己的项目名字，后面一定要加.github.io后缀，README初始化也要勾上。名称一定要和你的github名字完全一样，比如你github名字叫abc，那么仓库名字一定要是abc.github.io
然后项目就建成了，点击Settings，向下拉到最后有个GitHub Pages，点击Choose a theme选择一个主题。然后等一会儿，再回到GitHub Pages，会变成下面这样：
点击那个链接，就会出现自己的网页啦，效果如下(我的是已经使用主题的页面,你们的页面可能不一样)：
+
Hexo就是我们的个人博客网站的框架， 这里需要自己在电脑常里创建一个文件夹，可以命名为Blog，Hexo框架与以后你自己发布的网页都在这个文件夹中。创建好后，进入文件夹中，按住shift键，右击鼠标点击命令行
+
使用npm命令安装Hexo，输入：
+npm install -g hexo-cli
+这个安装时间较长耐心等待，安装完成后，初始化我们的博客，输入：
+hexo init blog
+注意，这里的命令都是作用在刚刚创建的Blog文件夹中。
+为了检测我们的网站雏形，分别按顺序输入以下三条命令：
+hexo new test_my_site
+
+hexo g
+
+hexo s
+这些命令在后面作介绍，完成后，打开浏览器输入地址：
+ +可以看出我们写出第一篇博客
+
Hexo常用命令
+npm install hexo -g #安装Hexo
npm update hexo -g #升级
hexo init #初始化博客
命令简写
hexo n “我的博客” == hexo new “我的博客” #新建文章
hexo g == hexo generate #生成
hexo s == hexo server #启动服务预览
hexo d == hexo deploy #部署
hexo server #Hexo会监视文件变动并自动更新，无须重启服务器
hexo server -s #静态模式
hexo server -p 5000 #更改端口
hexo server -i 192.168.1.1 #自定义 IP
hexo clean #清除缓存，若是网页正常情况下可以忽略这条命令
刚刚的三个命令依次是新建一篇博客文章、生成网页、在本地预览的操作。
+打开博客根目录下的_config.yml文件，这是博客的配置文件，在这里你可以修改与博客相关的各种信息。
修改最后一行的配置：
+deploy:
+- type: git
+ repository: https://github.com/wangwangit/wangwangit.github.io.git
+ branch: master
+repository修改为你自己的github项目地址.
+现在默认的域名还是xxx.github.io，是不是很没有牌面？想不想也像我一样弄一个专属域名呢，首先你得购买一个域名，xx云都能买，看你个人喜好了。
以我的谷歌域名为例，如下图所示，添加一条解析记录：
+
然后打开你的github博客项目，点击settings，拉到下面Custom domain处，填上你自己的域名，保存：
这时候你的项目根目录应该会出现一个名为CNAME的文件了。如果没有的话，打开你本地博客/source目录，我的是D:\study\program\blog\source，新建CNAME文件，注意没有后缀。然后在里面写上你的域名，保存。最后运行hexo g、hexo d上传到github
有时候我们想换一台电脑继续写博客，这时候就可以将博客目录下的所有源文件都上传到github上面。
+首先在github博客仓库下新建一个分支hexo，然后git clone到本地，把.git文件夹拿出来，放在博客根目录下。
然后git checkout hexo切换到hexo分支，然后git add .，然后git commit -m "xxx"，最后git push origin hexo提交就行了。
我使用的主题是这个:博客主题
+具体操作可以参考该主题的文档
+对于图床使用可以参考我以下文章:
+ + + + +
+ 微信支付
+
+ 支付宝支付
+
+
+ 
-Xms512M
+-Xmx2048M
+-XX:ReservedCodeCacheSize=1024M
+-XX:+UseCompressedOops
+
添加如下配置
+-Dfile.encoding=UTF-8
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 继不久前将 AI 文本生成模型 ChatGPT 与搜索引擎必应整合，并推出新版必应后。日前有消息源透露，该公司近期已开始在部分国家和地区测试将图像创建器 Image Creator 整合到新版必应中。
+Bing Image Creator是一款可以根据您的文字描述生成图像的工具。它不同于普通的图像搜索，它需要您提供尽可能详细和创造性的描述，比如形容词、地点、甚至艺术风格，例如“数字艺术”和“写实风格”。例如，不要只输入“生物”，而要输入“穿着帽子的毛茸茸的生物”。
+
1.开启全局代理(印度)
+你需要有一个能稳定访问 bing.com 的网络环境。使用国内的网络直接访问 bing.com，将会被强制跳转到 cn.bing.com，也就是国内特供版的 Bing 搜索引擎官网，而国内版的 Bing 搜索引擎目前暂时没有内置 ChatGPT，因此我们需要有一个能稳定访问外网的上网环境。可以参考必应ChatGPT内测申请教程 - 一只会飞的旺旺 (wangwangit.com)
+2.访问网站
+直接访问官方网站, 必应的图像创建者 (bing.com),若是代理不正常,则会提示如下内容.
+
调整国家为印度,就可以看到关键词输入框.
+
3.使用关键字创建图像
+
随着AI作画的发展，关于人工与人工智能的讨论越来越多，关于AI作画的版权问题、行业受益者与受害者等诸多问题，大家从来没有停止讨论。关于AI与人工，大家有惶恐、有担忧，但人工智能从未停止，依旧存在。希望大家能够合理使用AI功能!
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 注意InfluxDB的版本号,不同版本号的语法不同,我使用的是InfluxDB2.3.0版本
+官网: InfluxDB OSS 2.3 Documentation (influxdata.com)
+参考: InfluxDB v2：Flux 语言、快速参考指南和备忘单
+ +在InfluxDB中,配置文件默认是不存在的,需要执行以下命令进行生成
+
+ docker run --rm influxdb:2.3.0 influxd print-config > config.yml
+具体内容如下:
+assets-path: ""
+bolt-path: /var/lib/influxdb2/influxd.bolt
+e2e-testing: false
+engine-path: /var/lib/influxdb2/engine
+feature-flags: {}
+flux-log-enabled: false
+hardening-enabled: false
+http-bind-address: :8086
+http-idle-timeout: 3m0s
+http-read-header-timeout: 10s
+http-read-timeout: 0s
+http-write-timeout: 0s
+influxql-max-select-buckets: 0
+influxql-max-select-point: 0
+influxql-max-select-series: 0
+instance-id: ""
+key-name: ""
+log-level: info
+metrics-disabled: false
+nats-max-payload-bytes: 0
+nats-port: 4222
+no-tasks: false
+pprof-disabled: false
+query-concurrency: 1024
+query-initial-memory-bytes: 0
+query-max-memory-bytes: 0
+query-memory-bytes: 0
+query-queue-size: 1024
+reporting-disabled: false
+secret-store: bolt
+session-length: 60
+session-renew-disabled: false
+sqlite-path: ""
+storage-cache-max-memory-size: 1073741824
+storage-cache-snapshot-memory-size: 26214400
+storage-cache-snapshot-write-cold-duration: 10m0s
+storage-compact-full-write-cold-duration: 4h0m0s
+storage-compact-throughput-burst: 50331648
+storage-max-concurrent-compactions: 0
+storage-max-index-log-file-size: 1048576
+storage-no-validate-field-size: false
+storage-retention-check-interval: 30m0s
+storage-series-file-max-concurrent-snapshot-compactions: 0
+storage-series-id-set-cache-size: 0
+storage-shard-precreator-advance-period: 30m0s
+storage-shard-precreator-check-interval: 10m0s
+storage-tsm-use-madv-willneed: false
+storage-validate-keys: false
+storage-wal-fsync-delay: 0s
+storage-wal-max-concurrent-writes: 0
+storage-wal-max-write-delay: 10m0s
+storage-write-timeout: 10s
+store: disk
+testing-always-allow-setup: false
+tls-cert: ""
+tls-key: ""
+tls-min-version: "1.2"
+tls-strict-ciphers: false
+tracing-type: ""
+ui-disabled: false
+vault-addr: ""
+vault-cacert: ""
+vault-capath: ""
+vault-client-cert: ""
+vault-client-key: ""
+vault-client-timeout: 0s
+vault-max-retries: 0
+vault-skip-verify: false
+vault-tls-server-name: ""
+vault-token: ""
+调整配置文件映射,并且设置环境变量,指定InfluxDB读取的配置文件夹,
+Dockerfile模板如下:
+# 时序性数据库
+influxdb:
+ image: influxdb:2.3.0
+ container_name: influxdb
+ environment:
+ - DOCKER_INFLUXDB_INIT_MODE=setup
+ - DOCKER_INFLUXDB_INIT_USERNAME=xxxxx
+ - DOCKER_INFLUXDB_INIT_PASSWORD=xxxxx
+ - DOCKER_INFLUXDB_INIT_ORG=xxxxx
+ - DOCKER_INFLUXDB_INIT_BUCKET=xxxxx
+ - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=xxxxx
+ - INFLUXD_CONFIG_PATH=/home/ # 设置环境变量
+ volumes:
+ - /data/zfzn/config.yml:/home/config.yml # 设置映射路径
+ ports:
+ - "18086:8086"
+ restart: always
+可以通过api访问获取配置内容
+http://{ip}:{port}/api/v2/config
+
首先,我们使用默认配置启动InfluxDB,执行一个大数据量查询
+from(bucket: "zfzn_new")
+ |> range(start: -30d)
+ |> filter(fn: (r) => r["_measurement"] == "100" or r["_measurement"] == "103" or r["_measurement"] == "101" or r["_measurement"] == "102" or r["_measurement"] == "105" or r["_measurement"] == "108" or r["_measurement"] == "107" or r["_measurement"] == "106" or r["_measurement"] == "109" or r["_measurement"] == "110")
+ |> fill(usePrevious: true)
+ |> increase(columns: ["_value"])
+ |> last()
+ |> yield()
+使用top查看Influxdb服务内存占用.
+调整为最大查询内存1G之后:
+
优化常用字段:
+具体说明参考官方文档: InfluxDB 配置选项
+
+
+log-level: warn # 日志输出级别
+query-concurrency: 5 # 允许并发执行的查询数。 默认10
+query-initial-memory-bytes: 67108864 # 64 MB 为查询分配的初始内存字节数。
+query-memory-bytes: 2147483648 # 2G 单个查询允许的最大内存字节数。必须大于或等于 query-initial-memory-bytes 。
+query-max-memory-bytes: 8589934592 # 8G 允许查询的最大内存总字节数。 等于查询并发×单次查询内存字节数
+http-read-header-timeout: 10s #服务器应尝试读取新请求的 HTTP 标头的最长持续时间。设置为 0 表示没有超时
+http-read-timeout: 10s # 读超时
+http-write-timeout: 10s # 写超时
+query-queue-size: 10 # 执行队列中允许的最大查询数。当达到队列限制时，新查询将被拒绝。 默认10
+
+storage-cache-max-memory-size: 2147483648 # 2G 控制存储引擎内存缓存的大小，以字节为单位。
+storage-cache-snapshot-memory-size: 26214400 # 25M 控制存储引擎快照使用的内存大小，以字节为单位。
+storage-cache-snapshot-write-cold-duration: 10m0s # 控制存储引擎冷数据快照写入的时间。
+storage-compact-full-write-cold-duration: 4h0m0s # 控制存储引擎数据压缩的时间。
+storage-compact-throughput-burst: 50331648
+storage-max-concurrent-compactions: 0
+storage-max-index-log-file-size: 1048576
+storage-no-validate-field-size: false
+storage-retention-check-interval: 30m0s
+storage-series-file-max-concurrent-snapshot-compactions: 0
+storage-series-id-set-cache-size: 0
+storage-shard-precreator-advance-period: 30m0s
+storage-shard-precreator-check-interval: 10m0s
+storage-tsm-use-madv-willneed: false
+storage-validate-keys: false
+storage-wal-fsync-delay: 0s
+storage-wal-max-concurrent-writes: 0
+storage-wal-max-write-delay: 10m0s
+storage-write-timeout: 10s
+store: disk
+下面提出了内存释放问题解决方案
+ +- GODEBUG=madvdontneed=1
+- GOGC=80
+第一步,下载压缩包jetbra.zip,解压放在任意目录
+
第二步,修改idea的配置(注意替换成自己的路径)
+
+ -javaagent:C:\Application\ideaIU-2023.3.6.win\jetbra\ja-netfilter.jar=jetbrains
+--add-opens=java.base/jdk.internal.org.objectweb.asm=ALL-UNNAMED
+--add-opens=java.base/jdk.internal.org.objectweb.asm.tree=ALL-UNNAMED
+
第三步,修改jetbrains配置,添加下面这段内容,注意是添加!
+EQUAL,552256481678533139637975642367886203758236695483472209227743107098274039115182632876163871002685432662302338668484423414183623828225303129495011678242692842492488816514989676246788248148342413267485195568231641482216898266877438354128287060766631859161479332205725666574464164020522537595703362075565234890263790811265628293553656776925959545054122892468596656349514684518208997243750044021837251938753278807502305685113970717218831835618638457758130244769634525644949374508517044601990948117620105271720428259518909031341417933211526168184737184239634893948475085109420481522243358927998080508613356123692889767778533191484116809048763806053864339307673413329622302838455339868310031694563895311196234390180465202269142275598079255373287732431039254464172062988256518444614496248243200781259934221113710095392103382136300966279867703201614910212881522237167155093128902262921185900884869382176544761664777559104752378158192377647794361684542114437145121112034418220761298224143523298442362011266447239773883726746341810632935875214148521014297762215812293965213101140233155347800537083565331646491142112103328400294630793407149764120146697310714474595556761774911418274155051344410984326483216333907679252415962391346653515408516718,65537,860106576952879101192782278876319243486072481962999610484027161162448933268423045647258145695082284265933019120714643752088997312766689988016808929265129401027490891810902278465065056686129972085119605237470899952751915070244375173428976413406363879128531449407795115913715863867259163957682164040613505040314747660800424242248055421184038777878268502955477482203711835548014501087778959157112423823275878824729132393281517778742463067583320091009916141454657614089600126948087954465055321987012989937065785013284988096504657892738536613208311013047138019418152103262155848541574327484510025594166239784429845180875774012229784878903603491426732347994359380330103328705981064044872334790365894924494923595382470094461546336020961505275530597716457288511366082299255537762891238136381924520749228412559219346777184174219999640906007205260040707839706131662149325151230558316068068139406816080119906833578907759960298749494098180107991752250725928647349597506532778539709852254478061194098069801549845163358315116260915270480057699929968468068015735162890213859113563672040630687357054902747438421559817252127187138838514773245413540030800888215961904267348727206110582505606182944023582459006406137831940959195566364811905585377246353->31872219281407242025505148642475109331663948030010491344733687844358944945421064967310388547820970408352359213697487269225694990179009814674781374751323403257628081559561462351695605167675284372388551941279783515209238245831229026662363729380633136520288327292047232179909791526492877475417113579821717193807584807644097527647305469671333646868883650312280989663788656507661713409911267085806708237966730821529702498972114194166091819277582149433578383639532136271637219758962252614390071122773223025154710411681628917523557526099053858210363406122853294409830276270946292893988830514538950951686480580886602618927728470029090747400687617046511462665469446846624685614084264191213318074804549715573780408305977947238915527798680393538207482620648181504876534152430149355791756374642327623133843473947861771150672096834149014464956451480803326284417202116346454345929350148770746553056995922154382822307758515805142704373984019252210715650875853634697920708113806880196144197384637328982263167395073688501517286678083973976140696077590122053014085412828620051470085033364773099146103525313018873319293728800442101520384088109603555959893639842091339193891977395427305674935962998394201154475636326880291448367598036283623703166979
+
第四步,重启IDEA,退出自己的IDEA账号,前往网站Generate License (wangwangit.com)复制激活码,激活插件!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 官方文档: https://docs.docker.com/get-docker/
相关教程: https://yeasy.gitbook.io/docker_practice/install/mirror
根据K8s的要求,确保禁止swap分区使用,不禁止,初始化会报错.
+在每个宿主机上执行:
+sudo swapoff -a
+#修改/etc/fstab，注释掉swap那行，持久化生效
+sudo vi /etc/fstab
+ubuntu 查看防火墙命令，ufw status可查看状态，ubuntu20.04默认全部关闭，无需设置。
+非必须，但是为了直观方便管理，建议设置。
+在宿主机分别设置主机名：k8s-master，k8s-node01，k8s-node02
+sudo vim /etc/hostname
+hosts设置
+sudo vim /etc/hosts
+#添加内容
+192.168.152.100 k8s-master
+192.168.152.101 k8s-node01
+192.168.152.102 k8s-node02
+为防止初始化出现一系列的错误，请检查docker和kubectl驱动是否一致，否则kubectl没法启动造成报错。版本不一样，docker有些为cgroupfs，而kubectl默认驱动为systemd，所以需要更改docker驱动。
+查看docker驱动命令
+sudo docker info|grep Driver
+更改docker驱动
+#编辑创建文件
+sudo vim /etc/docker/daemon.json
+#添加内容
+{
+ "exec-opts": ["native.cgroupdriver=systemd"]
+}
+重启docker
+sudo systemctl restart docker.service
+sudo apt-get update
+sudo apt-get install -y apt-transport-https ca-certificates curl
+国外 ：下载 Google Cloud 公开签名秘钥：
+curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add
+sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"
+国内：可以用阿里源即可：
+curl -s https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | sudo apt-key add -
+sudo tee /etc/apt/sources.list.d/kubernetes.list <<EOF
+deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
+EOF
+锁定版本，防止出现不兼容情况，例如，1.7.0 版本的 kubelet 可以完全兼容 1.8.0 版本的 API 服务器，反之则不可以。
+sudo apt-get update
+sudo apt-get install -y kubelet kubeadm kubectl
+sudo apt-mark hold kubelet kubeadm kubectl
+只需要在master上操作即可。
+kubeadm init
+初始化完成之后
+[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
+
+Alternatively, if you are the root user, you can run:
+
+ export KUBECONFIG=/etc/kubernetes/admin.conf
+
+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 192.168.152.100:6443 --token tojkw9.v4nageqhftd7v2vc \
+ --discovery-token-ca-cert-hash sha256:6a5b372144d6cc2a12f8e41853554549f1290e665381f48fdd92bbf92de7b884
+根据用户不同,执行以下命令,
+root用户
+export KUBECONFIG=/etc/kubernetes/admin.conf
+普通用户
+mkdir -p $HOME/.kube
+sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
+sudo chown $(id -u):$(id -g) $HOME/.kube/config
+最后,到node节点机器上执行上面init输出的join语句即可!
+curl https://docs.projectcalico.org/manifests/calico.yaml -O
+kubectl apply -f calico.yaml
+安装完成后，kubectl get node 可查看节点状态，由NotReady变成Ready则正常，需要等几分钟完成。
#未安装网络插件
+ubuntu@k8s-master:~$ kubectl get node
+NAME STATUS ROLES AGE VERSION
+k8s-master NotReady control-plane,master 80m v1.22.3
+#已安装网络插件
+ubuntu@k8s-master:~$ kubectl get node
+NAME STATUS ROLES AGE VERSION
+k8s-master Ready control-plane,master 83m v1.22.3
+[kubelet-check] It seems like the kubelet isn't running or healthy.
+[kubelet-check] The HTTP call equal to 'curl -sSL http://localhost:10248/healthz' failed with error: Get "http://localhost:10248/healthz": dial tcp 127.0.0.1:10248: connect: connection refused.
+原因：kubectl没法启动，journalctl -xe查看启动错误信息。
+journalctl -xe
+#信息显示docker和kubectel驱动不一致
+kubelet cgroup driver: \"systemd\" is different from docker cgroup driver: \"cgroupfs\""
+解决方案:k8s建议systemd驱动，所以更改docker驱动即可，编辑 /etc/docker/daemon.json (没有就新建一个），添加如下启动项参数即可：
+#编辑创建文件
+sudo vim /etc/docker/daemon.json
+#添加内容
+{
+ "exec-opts": ["native.cgroupdriver=systemd"]
+}
+重启docker和kubectel
+#重启docker
+sudo systemctl restart docker.service
+#重载kubectl
+sudo systemctl daemon-reload
+#重启kubectl
+sudo systemctl restart kubelet.service
+#查看kubectl服务状态恢复正常
+sudo systemctl status kubelet.service
+error execution phase preflight: [preflight] Some fatal errors occurred:
+ [ERROR FileAvailable--etc-kubernetes-manifests-kube-apiserver.yaml]: /etc/kubernetes/manifests/kube-apiserver.yaml already exists
+ [ERROR FileAvailable--etc-kubernetes-manifests-kube-controller-manager.yaml]: /etc/kubernetes/manifests/kube-controller-manager.yaml already exists
+ [ERROR FileAvailable--etc-kubernetes-manifests-kube-scheduler.yaml]: /etc/kubernetes/manifests/kube-scheduler.yaml already exists
+ [ERROR FileAvailable--etc-kubernetes-manifests-etcd.yaml]: /etc/kubernetes/manifests/etcd.yaml already exists
+[preflight] If you know what you are doing, you can make a check non-fatal with `--ignore-preflight-errors=...`
+原因：初始化生产的文件，重新初始化，需要删除即可
+rm -fr /etc/kubernetes/manifests/*
+error execution phase preflight: [preflight] Some fatal errors occurred:
+ [ERROR Port-10250]: Port 10250 is in use
+解决方法：重置配置
+sudo kubeadm reset
+在所有node节点机器操作，统一已安装完成 kubelet、kubeadm 和 kubectl，用master初始化完成后最后提示命令加入，切记要用root用户。
+kubeadm join 192.168.152.100:6443 --token tojkw9.v4nageqhftd7v2vc \
+ --discovery-token-ca-cert-hash sha256:6a5b372144d6cc2a12f8e41853554549f1290e665381f48fdd92bbf92de7b884
+执行完成之后,输出以下命令
+[preflight] Running pre-flight checks
+[preflight] Reading configuration from the cluster...
+[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -o yaml'
+[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节点,执行kubectl get node可查看已加入的所有节点
ubuntu@k8s-master:~$ kubectl get node
+NAME STATUS ROLES AGE VERSION
+k8s-master Ready control-plane,master 16h v1.22.3
+k8s-node01 Ready <none> 24m v1.22.3
+k8s-node02 Ready <none> 6m54s v1.22.3
+[root@k8snode1 kubernetes]# kubectl get pod
+The connection to the server localhost:8080 was refused - did you specify the right host or port?
+原因:出现这个问题的原因是kubectl命令需要使用kubernetes-admin来运行
+解决:将主节点中的【/etc/kubernetes/admin.conf】文件拷贝到从节点相同目录下，然后配置环境变量
+echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile
+source ~/.bash_profile
+[ERROR CRI]: container runtime is not running: output: time="2020-09-24T11:49:16Z" level=fatal msg="getting status of runtime failed: rpc error: code = Unimplemented desc = unknown service runtime.v1alpha2.RuntimeService"
+解决方案:
+rm /etc/containerd/config.toml
+systemctl restart containerd
+kubeadm init
+Kasm Workspaces 是一款强大的开源容器流平台，它能够将云桌面、Web隔离以及OSINT工作负载直接交付到您的Web浏览器中。这意味着您可以通过任何地点的浏览器安全地访问您的工作环境，包括各种应用程序和桌面。🌍
+官网地址：https://kasmweb.com ,更多部署方式可以参考官网说明!
+cd /tmp
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_1.15.0.06fdc8.tar.gz
+tar -xf kasm_release_1.15.0.06fdc8.tar.gz
+sudo bash kasm_release/install.sh
+cd /tmp
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_1.15.0.06fdc8.tar.gz
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_service_images_amd64_1.15.0.06fdc8.tar.gz
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_workspace_images_amd64_1.15.0.06fdc8.tar.gz
+tar -xf kasm_release_1.15.0.06fdc8.tar.gz
+sudo bash kasm_release/install.sh --offline-workspaces /tmp/kasm_release_workspace_images_amd64_1.15.0.06fdc8.tar.gz --offline-service /tmp/kasm_release_service_images_amd64_1.15.0.06fdc8.tar.gz
+cd /tmp
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_1.15.0.06fdc8.tar.gz
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_service_images_arm64_1.15.0.06fdc8.tar.gz
+curl -O https://kasm-static-content.s3.amazonaws.com/kasm_release_workspace_images_arm64_1.15.0.06fdc8.tar.gz
+tar -xf kasm_release_1.15.0.06fdc8.tar.gz
+sudo bash kasm_release/install.sh --offline-workspaces /tmp/kasm_release_workspace_images_arm64_1.15.0.06fdc8.tar.gz --offline-service /tmp/kasm_release_service_images_arm64_1.15.0.06fdc8.tar.gz
+
经过我这几天的使用，我发现Kasm Workspaces非常好用。它提供了一个灵活的浏览器环境，可以随时创建和销毁，非常适合临时的Web任务。🔄
+更令人兴奋的是，我可以在后台持续保存我的工作环境，这对于需要长时间运行的任务来说是一个巨大的便利。📌
+例如，我最近开通了GPT-4，通过Kasm Workspaces，我可以为每个用户创建独立的使用环境，这样每个人都可以享受个性化的体验。👥
+Kasm Workspaces的可玩性非常高，还有很多功能等着大家去探索和发掘。无论是用于教育、研究还是日常工作，它都能提供出色的支持。🔍
+立即开始您的云端工作之旅吧！🚀
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 自从 2019年左右接触到 Markdown 以来，对它的使用就一发而不可收拾。从最开始使用它在 GitHub Pages 里写博客，到用它编辑项目的 README 文件，再到撰写开发文档，编辑微信公众号文章和邮件内容等等，这期间也见证了它在各类平台和网站上的普及和被原生支持，可以说，Markdown 如今已经渗透了我在技术和网络活动的方方面面，成为了我撰写文本文档的首选。
+那么首先我们一起来看一下它的「定义」：
+++Markdown 是一种轻量级标记语言，创始人为 John Gruber。它允许人们「使用易读易写的纯文本格式编写文档，然后转换成有效的 XHTML（或者 HTML）文档」。——维基百科
+
本文档的目的不在于面面俱到地介绍 Markdown，只是作为我对其理解的笔记整理，希望能同时帮助一些对 Markdown 感兴趣的人快速上手，或是作为一个工具，供对其已经有所了解的人在需要时参考。
+接下来请随我一起深入了解这门并不神秘的实用标记语言。
+专注于文字内容；
+纯文本，易读易写，可以方便地纳入版本控制；
+语法简单，没有什么学习成本，能轻松在码字的同时做出美观大方的排版。
+各类代码托管平台
+主流的代码托管平台，如 GitHub、GitLab、BitBucket、Coding、Gitee 等等，都支持 Markdown 语法，很多开源项目的 README、开发文档、帮助文档、Wiki 等都用 Markdown 写作。
+技术社区和写作平台
+StackOverflow、CSDN、掘金、简书、GitBook、有道云笔记
+论坛
+V2EX、光谷社区
+个人感觉比较遗憾的一点是各平台可能采用不同语言实现的 Markdown 解析引擎，或采用同一解析引擎的不同版本，而且可能有不同程度的定制与扩展，这导致在不同平台上使用 Markdown 写作时体验并不完全一致。不过幸好对于大家公认的一些标准语法，各家都是支持的。
+理论上任何一款文本编辑器都能用于编辑 Markdown 文档，它们分别提供了不同程度的语法高亮、预览等功能，以下只是列举其中一部分，选择自己称手的即可。
+现代编辑器
+VSCode / Atom
+传统编辑器
+Vim / Emacs / Sublime Text / Notepad++
+IDE 自带编辑器
+IntelliJ IDEA / Android Studio / WebStorm
+专用编辑器
+Ulysses / Mou / Typora / Markpad
+在线编辑器
+各种支持 Markdown 的网站都提供了在线编辑器
+Markdown：
+# atx-style 一级标题
+
+## 二级标题
+
+###### 六级标题
+
+Setext-style 一级标题
+===
+
+二级标题
+---
+预览效果：
+++atx-style 一级标题
二级标题
六级标题
Setext-style 一级标题
二级标题
对应 HTML：
+<h1>atx-style 一级标题</h1>
+
+<h2>二级标题</h2>
+
+<h6>六级标题</h6>
+
+<h1>Setext-style 一级标题</h1>
+
+<h2>二级标题</h2>
+中间没有空行的连续不断的几行文字被视为一个段落。
+Markdown：
+白日依山尽，
+
+黄河入海流。
+（句号后面没空格）
+
+欲穷千里目，
+
+更上一层楼。
+（句号后面有俩空格）
+预览效果：
+白日依山尽，
+黄河入海流。
（句号后面没空格）
欲穷千里目，
+更上一层楼。
（句号后面有俩空格）
对应 HTML：
+<p>白日依山尽，</p>
+
+<p>黄河入海流。
+（句号后面没有空格）</p>
+
+<p>欲穷千里目，</p>
+
+<p>
+ 更上一层楼。
+ <br>
+ （句号后面有俩空格）
+</p>
+对段落或者部分文本的强调效果。
+Markdown：
+后面俩字**加黑**
+
+后面俩字*斜体*
+预览效果：
+后面俩字加黑
+后面俩字斜体
+对应 HTML：
+<p>
+ 后面俩字
+ <strong>加黑</strong>
+</p>
+<p>
+ 后面俩字
+ <em>斜体</em>
+</p>
+Markdown：
+> 引用块段落一。
+>
+> 引用块段落二。
+>> 内嵌引用块段落一。
+>
+> ### 引用块内的标题
+预览效果：
+++引用块段落一。
+引用块段落二。
+++内嵌引用块段落一。
+引用块内的标题
对应 HTML：
+<blockquote>
+ <p>引用块段落一。</p>
+ <p>引用块段落二。</p>
+ <blockquote>
+ <p>内嵌引用块段落一。</p>
+ </blockquote>
+ <h3 id="引用块内的标题">引用块内的标题</h3>
+</blockquote>
+Markdown 支持行内式链接和引用式链接。
+Markdown：
+行内式 [博客](https://mazhuang.org "我的个人博客") 链接，带 title。
+
+行内式 [GitHub](https://github.com/mzlogin) 链接。
+
+引用式 [博客][1] 链接。
+
+引用式 [GitHub][2] 链接，带 title。
+
+[1]: https://www.wangwangit.com
+[2]: https://github.com/wangwangit "我的 GitHub 主页"
+预览效果：
+行内式 博客 链接，带 title。
+行内式 GitHub 链接。
+引用式 博客 链接。
+引用式 GitHub 链接，带 title。
+对应 HTML：
+<p>行内式 <a href="https://www.wangwangit.com" title="我的个人博客">博客</a> 链接，带 title。</p>
+
+<p>行内式 <a href="https://github.com/wangwangit">GitHub</a> 链接。</p>
+
+<p>引用式 <a href="https://www.wangwangit.com">博客</a> 链接。</p>
+
+<p>引用式 <a href="https://github.com/wangwangit" title="我的 GitHub 主页">GitHub</a> 链接，带 title。</p>
+在超链接的写法前加一个 !，就是引用图片的方法。
Markdown：
+
+预览效果：
+
对应 HTML：
+<img src="https://avatars.githubusercontent.com/u/22621145?v=4" alt="Alt text" title="favicon">
+包括有序列表和无序列表。
+Markdown：
+- 苹果
+- 葡萄
+- 榴莲
+
+1. 苹果
+2. 葡萄
+3. 榴莲
+预览效果：
+对应 HTML：
+<ul>
+ <li>苹果</li>
+ <li>葡萄</li>
+ <li>榴莲</li>
+</ul>
+<ol>
+ <li>苹果</li>
+ <li>葡萄</li>
+ <li>榴莲</li>
+</ol>
+其中无序列表的标记可以使用 +、- 或 *，有序列表前的数字可以是乱序的。
支持行内代码和代码块。
+Markdown：
+Android 里使用 `TextUtils` 类的 `isEmpty` 方法来判断字符串是否为空。
+
+```java
+if (TextUtils.isEmpty(text)) {
+ return null;
+}
+```
+预览效果：
+Android 里使用 TextUtils 类的 isEmpty 方法来判断字符串是否为空。
if (TextUtils.isEmpty(text)) {
+ return null;
+}
+对应 HTML：
+<p>Android 里使用 <code>TextUtils</code> 类的 <code>isEmpty</code> 方法来判断字符串是否为空。</p>
+
+<div class="highlight highlight-source-java"><pre><span class="pl-k">if</span> (<span class="pl-smi">TextUtils</span><span class="pl-k">.</span>isEmpty(text)) {
+ <span class="pl-k">return</span> <span class="pl-c1">null</span>;
+}</pre></div>
+上例中的语言标记 java 可选填，可用于在编辑器和渲染后的效果里添加语法高亮。
块式代码也可以对整个代码段缩进四个空格，或一个 Tab 来实现。
+使用一个单独行里的三个或以上 *、- 来生产一条水平分割线，它们之间可以有空格。
Markdown：
+***
+
+-----
+
+- - -
+预览效果：
+对应 HTML：
+<hr />
+
+<hr />
+
+<hr />
+Markdown 标记语言的目的不是替代 HTML，也不是发明一种更便捷的插入 HTML 标签的方式。它对应的只是 HTML 标签的一个很小的子集。
+对于那些没有办法用 Markdown 语法来对应的 HTML 标签，直接使用 HTML 来写就好了。
+本节的内容是介绍一些受到广泛支持的 Markdown 扩展语法。
+Markdown：
+| 编号 | 姓名（左） | 年龄（右） | 性别（中） |
+| ----- | :-------- | ---------: | :------: |
+| 0 | 张三 | 28 | 男 |
+| 1 | 李四 | 29 | 男 |
+预览效果：
+| 编号 | +姓名（左） | +年龄（右） | +性别（中） | +
|---|---|---|---|
| 0 | +张三 | +28 | +男 | +
| 1 | +李四 | +29 | +男 | +
对应 HTML：
+<table>
+ <thead>
+ <tr>
+ <th>编号</th>
+ <th align="left">姓名（左）</th>
+ <th align="right">年龄（右）</th>
+ <th align="center">性别（中）</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>0</td>
+ <td align="left">张三</td>
+ <td align="right">28</td>
+ <td align="center">男</td>
+ </tr>
+ <tr>
+ <td>1</td>
+ <td align="left">李四</td>
+ <td align="right">29</td>
+ <td align="center">男</td>
+ </tr>
+ </tbody>
+</table>
+在 GitHub / GitLab 里有较好的支持。
+Markdown：
+- [x] 洗碗
+- [ ] 清洗油烟机
+- [ ] 拖地
+预览效果：
+对应 HTML：
+<ul class="contains-task-list">
+ <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox" checked=""> 洗碗</li>
+ <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox"> 清洗油烟机</li>
+ <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox"> 拖地</li>
+</ul>
+如果是在 GitHub / GitLab 的 Issue 里，会附赠任务完成比例提示效果：
+
还可以直接在网页上拖动调整顺序，勾选和取消勾选。
+
Markdown：
+后面三个字打上~~删除线~~。
+预览效果：
+后面三个字打上删除线。
对应 HTML：
+<p>后面三个字打上<del>删除线</del>。</p>
+自动链接扩展，即：当识别到 URL，或用 <、> 包括的 URL 时，会自动为其生成 a 标签。
Markdown：
+https://github.com
+
+<example@gmail.com>
+预览效果：
+ + +对应 HTML：
+<p><a href="https://github.com">https://github.com</a></p>
+
+<p><a href="mailto:example@gmail.com">example@gmail.com</a></p>
+以 GitHub Pages 为例。
+Markdown：
+:camel: :blush: :smile:
+预览效果：
+:camel: :blush: :smile:
+对应 HTML：
+<p>
+ <img class="emoji" title=":camel:" alt=":camel:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f42b.png" height="20" width="20">
+ <img class="emoji" title=":blush:" alt=":blush:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f60a.png" height="20" width="20">
+ <img class="emoji" title=":smile:" alt=":smile:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f604.png" height="20" width="20">
+</p>
+脑洞清奇的工程师们还发掘了很多使用 Markdown 的方法，大部分都是引入第三方 JavaScript 插件来实现。对这部分我只做简述，对其中的部分功能比如作图等，还是推荐用专门的可视化工具去做。
+有部分网站和编辑器实现了对 Markdown 里流程图和时序图的支持，比如我们使用的项目管理工具 TAPD 的在线编辑器，还有 VSCode + 插件 Markdown Preview Enhanced 等。
+以我们使用的项目管理工具 TAPD 的在线编辑器为例：
+
仍然以 TAPD 为例：
+
应该是利用 JavaScript 支持了 LaTeX 公式语法。
+有专门的工具 Marp，另外使用 VSCode + 插件 Markdown Preview Enhanced 也可以实现。
+可以将公众号素材用 Markdown 编辑好后，贴到在线排版工具以后，复制到公众号编辑器里即可。有多种页面主题和代码主题可选择。
+想象力丰富的工程师们还扩展了很多基于 Markdown 的玩法，包括但不限于：
+以上功能基本都可以用 VSCode + 插件 Markdown Preview Enhanced 实现。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ Microsoft 365 E5开发者试用订阅是微软为开发者提供的免费服务，申请后可以获得三个月的E5订阅，包括25个Microsoft 365的授权许可和5T的OneDrive存储空间。
+一.访问 https://developer.microsoft.com/zh-cn/microsoft-365/dev-program ，点击“加入”按钮，注册或登录微软账号。
+
二.配置沙盒信息
+
三.填写手机号接收验证码
+
四.登录 https://admin.microsoft.com ，进入管理中心，分配用户和许可证。
+
1）无法接收短信验证码？开启全局代理或者换个手机号码！
+2）每个子账号最多可以在 5 台电脑或 Mac、5 个平板电脑以及智能手机上安装 Office登陆。
+3）无法申请？将开启浏览器隐私模式或者换其他国外的全局代理！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 上传文件如果不使用云服务的话,需要本地搭建,一般选择 FastDFS 但是 FastDFS 安装比较复杂,今天了解一款安装使用更简单的存储系统 MinIO
+MinIO 是一款高性能、分布式的对象存储系统. 它是一款软件产品, 可以100%的运行在标准硬件。即X86等低成本机器也能够很好的运行MinIO。
+MinIO与传统的存储和其他的对象存储不同的是：它一开始就针对性能要求更高的私有云标准进行软件架构设计。因为MinIO一开始就只为对象存储而设计。所以他采用了更易用的方式进行设计，它能实现对象存储所需要的全部功能，在性能上也更加强劲，它不会为了更多的业务功能而妥协，失去MinIO的易用性、高效性。 这样的结果所带来的好处是：它能够更简单的实现局有弹性伸缩能力的原生对象存储服务。
+MinIO在传统对象存储用例（例如辅助存储，灾难恢复和归档）方面表现出色。同时，它在机器学习、大数据、私有云、混合云等方面的存储技术上也独树一帜。当然，也不排除数据分析、高性能应用负载、原生云的支持。
+在中国：阿里巴巴、腾讯、百度、中国联通、华为、中国移动等等9000多家企业也都在使用MinIO产品
+
+ docker pull minio/minio
+## docker
+docker run -p 9000:9000 -p 9001:9001 -d --name minio -v /opt/docker/minio/data:/data -v /opt/docker/minio/config:/root/.minio -e "MINIO_ROOT_USER=minio" -e "MINIO_ROOT_PASSWORD=minio@123456" minio/minio server /data --console-address ":9000" --address ":9001"
+
+## docker-compose
+ minio:
+ image: minio/minio
+ hostname: "minio"
+ container_name: minio
+ ports:
+ - 9000:9000 # api 端口
+ - 9001:9001 # 控制台端口
+ environment:
+ MINIO_ACCESS_KEY: minio #管理后台用户名
+ MINIO_SECRET_KEY: minio123456 #管理后台密码，最小8个字符
+ volumes:
+ - /data/zfzn/minio/data:/data #映射当前目录下的data目录至容器内/data目录
+ - /data/zfzn/minio/config:/root/.minio/ #映射配置目录
+ command: server --console-address ':9001' /data #指定容器中的目录 /data
+ privileged: true
+ restart: always
+
<dependencies>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-web</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-test</artifactId>
+ <scope>test</scope>
+ <exclusions>
+ <exclusion>
+ <groupId>org.junit.vintage</groupId>
+ <artifactId>junit-vintage-engine</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-configuration-processor</artifactId>
+ <optional>true</optional>
+ </dependency>
+
+
+ <dependency>
+ <groupId>org.projectlombok</groupId>
+ <artifactId>lombok</artifactId>
+ <optional>true</optional>
+ </dependency>
+
+ <!-- minio依赖 -->
+ <dependency>
+ <groupId>io.minio</groupId>
+ <artifactId>minio</artifactId>
+ <version>8.2.1</version>
+ </dependency>
+
+ <!-- hutool工具类 -->
+ <dependency>
+ <groupId>cn.hutool</groupId>
+ <artifactId>hutool-all</artifactId>
+ <version>5.1.2</version>
+ </dependency>
+
+ <!-- 压缩图片 -->
+ <dependency>
+ <groupId>net.coobird</groupId>
+ <artifactId>thumbnailator</artifactId>
+ <version>0.4.8</version>
+ </dependency>
+
+
+ <!-- 工具类依赖 -->
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-lang3</artifactId>
+ <version>3.12.0</version>
+ </dependency>
+
+ <dependency>
+ <groupId>com.github.davidcarboni</groupId>
+ <artifactId>encrypted-</artifactId>
+ <version>1.0.0</version>
+ </dependency>
+
+
+</dependencies>
+spring:
+ application:
+ name: minio-demo
+ servlet:
+ multipart:
+ max-file-size: 20MB
+ max-request-size: 200MB
+
+server:
+ port: 8088
+
+minio:
+ endpoint: http://你的ip:9001
+ accessKey: minio
+ secretKey: minio@123456
+ nginxHost: http://你的域名
+package com.sqm.minio_demo.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@ConfigurationProperties(prefix = "minio")
+@Component
+@Data
+public class MinioProperties {
+
+ /**
+ * 连接地址
+ */
+ private String endpoint;
+ /**
+ * 用户名
+ */
+ private String accessKey;
+ /**
+ * 密码
+ */
+ private String secretKey;
+ /**
+ * 域名
+ */
+ private String nginxHost;
+
+
+}
+package com.sqm.minio_demo.config;
+
+import io.minio.MinioClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@EnableConfigurationProperties(MinioProperties.class)
+public class MinioConfig {
+
+ @Autowired
+ private MinioProperties minioProperties;
+
+ @Bean
+ public MinioClient minioClient(){
+ return MinioClient.builder()
+ .endpoint(minioProperties.getEndpoint())
+ .credentials(minioProperties.getAccessKey(),minioProperties.getSecretKey())
+ .build();
+ }
+}
+package com.sqm.minio_demo.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class UploadResponse {
+
+ private String minIoUrl;
+
+ private String nginxUrl;
+}
+package com.sqm.minio_demo.util;
+
+import cn.hutool.core.date.DateUtil;
+import com.sqm.minio_demo.config.MinioProperties;
+import com.sqm.minio_demo.entity.UploadResponse;
+import io.minio.*;
+import io.minio.errors.*;
+import io.minio.messages.Bucket;
+import lombok.extern.slf4j.Slf4j;
+import net.coobird.thumbnailator.Thumbnails;
+
+
+import org.apache.commons.fileupload.FileItem;
+
+import org.apache.commons.fileupload.FileItemFactory;
+import org.apache.commons.fileupload.disk.DiskFileItemFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.commons.CommonsMultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.List;
+import java.util.Optional;
+import java.util.Random;
+
+@Component
+@Slf4j
+public class MinioUtil {
+
+ @Autowired
+ private MinioProperties minioProperties;
+
+ @Autowired
+ private MinioClient minioClient;
+
+ private final Long maxSize = (long) (1024 * 1024);
+
+ /**
+ * 创建bucket
+ */
+ public void createBucket(String bucketName) throws Exception {
+ if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
+ minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
+ }
+ }
+
+ /**
+ * 上传文件
+ */
+ public UploadResponse uploadFile(MultipartFile file, String bucketName) throws Exception {
+ //判断文件是否为空
+ if (null == file || 0 == file.getSize()) {
+ return null;
+ }
+ //判断存储桶是否存在 不存在则创建
+ createBucket(bucketName);
+ //文件名
+ String originalFilename = file.getOriginalFilename();
+ //新的文件名 = 时间戳_随机数.后缀名
+ assert originalFilename != null;
+ long now = System.currentTimeMillis() / 1000;
+ String fileName = DateUtil.format(DateUtil.date(),"yyyyMMdd")+"_"+ now + "_" + new Random().nextInt(1000) +
+ originalFilename.substring(originalFilename.lastIndexOf("."));
+ //开始上传
+ log.info("file压缩前大小:{}",file.getSize());
+ if (file.getSize() > maxSize) {
+ FileItemFactory fileItemFactory = new DiskFileItemFactory();
+ FileItem fileItem = fileItemFactory.createItem(fileName, "text/plain", true, fileName);
+ OutputStream outputStream = fileItem.getOutputStream();
+ Thumbnails.of(file.getInputStream()).scale(1f).outputFormat(originalFilename.substring(originalFilename.lastIndexOf(".")+1)).outputQuality(0.25f).toOutputStream(outputStream);
+ file = new CommonsMultipartFile(fileItem);
+ }
+ log.info("file压缩后大小:{}",file.getSize());
+ minioClient.putObject(
+ PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(
+ file.getInputStream(), file.getSize(), -1)
+ .contentType(file.getContentType())
+ .build());
+ String url = minioProperties.getEndpoint() + "/" + bucketName + "/" + fileName;
+ String urlHost = minioProperties.getNginxHost() + "/" + bucketName + "/" + fileName;
+ return new UploadResponse(url, urlHost);
+ }
+
+
+ /**
+ * 获取全部bucket
+ *
+ * @return
+ */
+ public List<Bucket> getAllBuckets() throws Exception {
+ return minioClient.listBuckets();
+ }
+
+ /**
+ * 根据bucketName获取信息
+ *
+ * @param bucketName bucket名称
+ */
+ public Optional<Bucket> getBucket(String bucketName) throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidResponseException, InternalException, ErrorResponseException, ServerException, XmlParserException, ServerException {
+ return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
+ }
+
+ /**
+ * 根据bucketName删除信息
+ *
+ * @param bucketName bucket名称
+ */
+ public void removeBucket(String bucketName) throws Exception {
+ minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
+ }
+
+ /**
+ * 获取⽂件外链
+ *
+ * @param bucketName bucket名称
+ * @param objectName ⽂件名称
+ * @param expires 过期时间 <=7
+ * @return url
+ */
+ public String getObjectURL(String bucketName, String objectName, Integer expires) throws Exception {
+ return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).expiry(expires).build());
+ }
+
+ /**
+ * 获取⽂件
+ *
+ * @param bucketName bucket名称
+ * @param objectName ⽂件名称
+ * @return ⼆进制流
+ */
+ public InputStream getObject(String bucketName, String objectName) throws Exception {
+ return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
+ }
+
+ /**
+ * 上传⽂件
+ *
+ * @param bucketName bucket名称
+ * @param objectName ⽂件名称
+ * @param stream ⽂件流
+ * @throws Exception https://docs.minio.io/cn/java-minioClient-api-reference.html#putObject
+ */
+ public void putObject(String bucketName, String objectName, InputStream stream) throws
+ Exception {
+ minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(stream, stream.available(), -1).contentType(objectName.substring(objectName.lastIndexOf("."))).build());
+ }
+
+ /**
+ * 上传⽂件
+ *
+ * @param bucketName bucket名称
+ * @param objectName ⽂件名称
+ * @param stream ⽂件流
+ * @param size ⼤⼩
+ * @param contextType 类型
+ * @throws Exception https://docs.minio.io/cn/java-minioClient-api-reference.html#putObject
+ */
+ public void putObject(String bucketName, String objectName, InputStream stream, long
+ size, String contextType) throws Exception {
+ minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(stream, size, -1).contentType(contextType).build());
+ }
+
+ /**
+ * 获取⽂件信息
+ *
+ * @param bucketName bucket名称
+ * @param objectName ⽂件名称
+ * @throws Exception https://docs.minio.io/cn/java-minioClient-api-reference.html#statObject
+ */
+ public StatObjectResponse getObjectInfo(String bucketName, String objectName) throws Exception {
+ return minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
+ }
+
+ /**
+ * 删除⽂件
+ *
+ * @param bucketName bucket名称
+ * @param objectName ⽂件名称
+ * @throws Exception https://docs.minio.io/cn/java-minioClient-apireference.html#removeObject
+ */
+ public void removeObject(String bucketName, String objectName) throws Exception {
+ minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
+ }
+
+
+ /***
+ * 上传视频
+ * @param file
+ * @param bucketName
+ * @return
+ * @throws Exception
+ */
+ public UploadResponse uploadVideo(MultipartFile file, String bucketName) throws Exception {
+ //判断文件是否为空
+ if (null == file || 0 == file.getSize()) {
+ return null;
+ }
+ //判断存储桶是否存在 不存在则创建
+ createBucket(bucketName);
+ //文件名
+ String originalFilename = file.getOriginalFilename();
+ //新的文件名 = 时间戳_随机数.后缀名
+ assert originalFilename != null;
+ long now = System.currentTimeMillis() / 1000;
+ String fileName = DateUtil.format(DateUtil.date(),"yyyyMMdd")+"_"+ now + "_" + new Random().nextInt(1000) +
+ originalFilename.substring(originalFilename.lastIndexOf("."));
+ //开始上传
+ log.info("file大小:{}",file.getSize());
+ minioClient.putObject(
+ PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(
+ file.getInputStream(), file.getSize(), -1)
+ .contentType("video/mp4")
+ .build());
+ String url = minioProperties.getEndpoint() + "/" + bucketName + "/" + fileName;
+ String urlHost = minioProperties.getNginxHost() + "/" + bucketName + "/" + fileName;
+ return new UploadResponse(url, urlHost);
+ }
+}
+package com.sqm.minio_demo.controller;
+
+import com.sqm.minio_demo.entity.ResultData;
+import com.sqm.minio_demo.entity.UploadResponse;
+import com.sqm.minio_demo.util.MinioUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+@RestController
+@Slf4j
+public class TestController {
+
+ @Autowired
+ private MinioUtil minioUtil;
+
+ /**
+ * @author: xx
+ * @date: 2022/5/25 15:32
+ * @description: 上传文件
+ */
+ @PostMapping("/upload")
+ public ResultData minioUpload(@RequestParam(value = "file") MultipartFile file){
+ UploadResponse response = null;
+ try {
+ response = minioUtil.uploadFile(file, "bucket01");
+ } catch (Exception e) {
+ log.error("上传失败",e);
+ }
+ return ResultData.ok(response);
+ }
+
+
+ /**
+ * @author: xx
+ * @date: 2022/5/25 15:32
+ * @description: 上传视频
+ */
+ @PostMapping("/uploadVideo")
+ public ResultData uploadVideo(@RequestParam(value = "file") MultipartFile file){
+ UploadResponse response = null;
+ try {
+ response = minioUtil.uploadVideo(file, "video-test");
+ } catch (Exception e) {
+ log.error("上传失败",e);
+ }
+ return ResultData.ok(response);
+ }
+
+}
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 1.pom.xml添加mysql驱动依赖
+
+
+<dependencys>
+ <dependency>
+ <groupId>mysql</groupId>
+ <artifactId>mysql-connector-java</artifactId>
+ <version>5.1.48</version>
+ </dependency>
+ <!--lombok依赖,自动生成set,get方法-->
+ <dependency>
+ <groupId>org.projectlombok</groupId>
+ <artifactId>lombok</artifactId>
+ <version>1.18.22</version>
+ <scope>compile</scope>
+ </dependency>
+</dependencys>
+2.编写代码
+执行类: JdbcConnect
+public class JdbcConnect {
+
+ public static void main(String[] args) {
+
+ User user = new User();
+
+ PreparedStatement preparedStatement = null;
+ ResultSet resultSet = null;
+ Connection connection = null;
+
+ try {
+ // 1.加载数据库驱动
+ Class.forName("com.mysql.jdbc.Driver");
+ // 2.获取连接配置,进行连接
+ connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&useSSL=false", "root", "root");
+ // 3.获取执行的SQL语句
+ String sql = "select * from user where username = ?";
+ preparedStatement = connection.prepareStatement(sql);
+ // 4.设置占位符的值,执行查询
+ preparedStatement.setString(1, "测试");
+ resultSet = preparedStatement.executeQuery();
+ while (resultSet.next()) {
+ // 5.处理结果集映射
+ int id = resultSet.getInt("id");
+ String username = resultSet.getString("username");
+ user.setId(id);
+ user.setUserName(username);
+ }
+ System.out.println(user);
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ // 6.资源关闭
+ if (null != resultSet) {
+ try {
+ resultSet.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+ if (preparedStatement != null) {
+ try {
+ preparedStatement.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+ if (connection != null) {
+ try {
+ connection.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+ }
+
+ }
+}
+实体类: User
+
+@Data
+public class User {
+
+ private Integer id;
+
+ private String userName;
+}
+3.JDBC问题总结
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 
+ JDBC问题总结
+* 数据库连接创建,释放频繁,浪费系统资源
+* SQL语句硬编码
+* SQL参数设置存在硬编码
+* 结果解析存在硬编码
+提供核⼼配置⽂件：
+<!--提取配置到文件中,解决硬编码问题-->
+<configuration>
+ <!--数据库连接信息-->
+ <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
+ <property name="jdbcUrl" value="jdbc:mysql:///mybatis"></property>
+ <property name="user" value="root"></property>
+ <property name="password" value="root"></property>
+ <!--引⼊sql配置信息-->
+ <mapper resource="mapper.xml"></mapper>
+</configuration>
+
+<mapper namespace="com.ww.mapper.IUserDao">
+
+ <!--sql的唯一标识: namespace.id-->
+ <select id="findAll" resultType="com.ww.pojo.User">
+ select * form user
+ </select>
+
+ <select id="findByCondition" resultType="com.ww.pojo.User" paramterType="com.ww.pojo.User">
+ select * from user where id = #{id} and username = #{username}
+ </select>
+
+</mapper>
+1.读取配置⽂件,封装到实体配置类中
+/*定义基于sqlMapConfig.xml的配置类*/
+@Data
+public class Configuration {
+
+ /*数据库连接配置*/
+ private DataSource dataSource;
+
+ /**
+ * 封装mapper.xml中的SQL语句
+ * key: statementId namespace.sqlId
+ */
+ private Map<String, MappedStatement> mapppedStatementMap = new HashMap<>();
+
+}
+/**
+ * 定义一个SQL该有的属性, 唯一标识,出参入参,以及SQL语句
+ */
+@Data
+public class MappedStatement {
+
+ // id标识
+ private String id;
+
+ //返回值类型
+ private String resultType;
+
+ //参数类型
+ private String paramterType;
+
+ //sql语句
+ private String sql;
+
+}
+2.解析配置⽂件
+
+InputStream resource = Resources.class.getClassLoader().getResourceAsStream(path);
+ public Configuration parseConfig(InputStream inputStream)throws Exception{
+ Document document=new SAXReader().read(inputStream);
+ // <configuration>
+ Element rootElement=document.getRootElement();
+ List<Element> list=rootElement.selectNodes("//property");
+ // 解析配置文件
+ Properties properties=new Properties();
+ for(Element element:list){
+ String name=element.attributeValue("name");
+ String value=element.attributeValue("value");
+ properties.setProperty(name,value);
+ }
+ // 获取连接池
+ ComboPooledDataSource comboPooledDataSource=new ComboPooledDataSource();
+ comboPooledDataSource.setDriverClass(properties.getProperty("driverClass"));
+ comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
+ comboPooledDataSource.setUser(properties.getProperty("username"));
+ comboPooledDataSource.setPassword(properties.getProperty("password"));
+
+ configuration.setDataSource(comboPooledDataSource);
+
+ // 解析mapper文件
+ List<Element> list1=rootElement.selectNodes("//mapper");
+ for(Element element:list1){
+ String mapperPath=element.attributeValue("resource");
+ InputStream resource=Resources.getResourceAsStream(mapperPath);
+ XMLMapperBuilder xmlMapperBuilder=new XMLMapperBuilder(configuration);
+ xmlMapperBuilder.parse(resource);
+ }
+
+ return configuration;
+3.通过SqlSessionFactoryBuilder的build方法,创建SqlSessionFactory
+/* 定义工厂,创建会话使用 */
+public interface SqlSessionFactory {
+
+ public SqlSession openSession();
+}
+4.通过SqlSessionFactory的openSession方法,创建SqlSession
+5.在sqlSession中封装增删改查方法
+public interface SqlSession {
+
+ //查询所有
+ public <E> List<E> selectList(String statementId, Object... params) throws Exception;
+
+ //根据条件查询单个
+ public <T> T selectOne(String statementId, Object... params) throws Exception;
+
+ //为Dao层生成代理实现类
+ public <T> T getMapper(Class<?> mapperClass);
+}
+
+ public<T> T getMapper(Class<?> mapperClass){
+ //使用JDK动态代理,来为dao接口生成代理对象并返回
+ Object proxyInstance=Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(),new Class[]{mapperClass},new InvocationHandler(){
+@Override
+public Object invoke(Object proxy,Method method,Object[]args)throws Throwable{
+ String methodName=method.getName();
+ String className=method.getDeclaringClass().getName();
+ String statementId=className+"."+methodName;
+ //获取方法的返回值类型
+ Type genericReturnType=method.getGenericReturnType();
+ if(genericReturnType instanceof ParameterizedType){
+ List<Object> objects=selectList(statementId,args);
+ return objects;
+ }
+ return selectOne(statementId,args);
+ }
+ });
+ return(T)proxyInstance;
+ }
+6.定义Executor实现JDBC原生操作,以及出入参映射操作
+public class SimpleExecutor implements Executor {
+
+
+ @Override
+ public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
+ //1.注册驱动,获取链接
+ Connection connection = configuration.getDataSource().getConnection();
+ //2.获取sql语句
+ String sql = mappedStatement.getSql();
+ //3.占位符替换
+ BoundSql boundSql = getBound(sql);
+ //4.获取预处理对象
+ PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
+ //5.设置参数
+ //获取参数全路径
+ String paramterType = mappedStatement.getParamterType();
+ Class<?> paramterTypeClass = getClassType(paramterType);
+ List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
+ for (int i = 0; i < parameterMappingList.size(); i++) {
+ ParameterMapping parameterMapping = parameterMappingList.get(i);
+ String content = parameterMapping.getContent();
+ //反射
+ Field declaredField = paramterTypeClass.getDeclaredField(content);
+ //暴力访问
+ declaredField.setAccessible(true);
+ Object o = declaredField.get(params[0]);
+ preparedStatement.setObject(i + 1, o);
+ }
+
+ //6.执行sql
+ ResultSet resultSet = preparedStatement.executeQuery();
+ String resultType = mappedStatement.getResultType();
+ Class<?> resultTypeClass = getClassType(resultType);
+
+ List<Object> list = new ArrayList<>();
+ //7.返回结果集
+ while (resultSet.next()) {
+ Object o = resultTypeClass.newInstance();
+ //元数据
+ ResultSetMetaData metaData = resultSet.getMetaData();
+ for (int i = 1; i <= metaData.getColumnCount(); i++) {
+ //字段名
+ String columnName = metaData.getColumnName(i);
+ //字段的值
+ Object value = resultSet.getObject(columnName);
+ //使用反射,根据数据库表和实体的对应关系,进行映射
+ PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
+ Method writeMethod = propertyDescriptor.getWriteMethod();
+ writeMethod.invoke(o, value);
+ }
+ list.add(o);
+ }
+ return (List<E>) list;
+ }
+
+ private Class<?> getClassType(String paramterType) throws ClassNotFoundException {
+ if (null != paramterType) {
+ Class<?> aClass = Class.forName(paramterType);
+ return aClass;
+ }
+ return null;
+ }
+
+ /**
+ * 将#{}使用?替换
+ * 解析出#{}里面的参数值
+ *
+ * @param sql
+ * @return
+ */
+ private BoundSql getBound(String sql) {
+ ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
+ GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
+ //解析SQL
+ String parseSql = genericTokenParser.parse(sql);
+ //#{}解析出来的参数
+ List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
+ BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
+ return boundSql;
+ }
+}
++ ++
| 组件 | +描述 | +
|---|---|
| SqlSession | +表示与数据库交互的会话,完成必要数据库增删改查功能 | +
| Executor | +MyBatis的执行器,负责SQL语句的生成和查询缓存的维护 | +
| StatementHandler | +封装了JDBC Statement操作,负责对JDBC Statement操作,如设置参数 | +
| ParameterHandler | +参数处理 | +
| ResultSetHandler | +结果集处理 | +
| TypeHandler | +java类型与jdbc类型的转换 | +
| MappedStatement | +维护mapper.xml中 一条select,update,insert,delete节点的封装 | +
| SqlSource | +根据用户传递的parameterObject动态的生成SQL并封装到BoundSql中 | +
| BoundSql | +表示动态生成的SQL语句,以及相应的参数信息 | +
1.二级缓存开启三步走
+
+<settings>
+ <setting name="cacheEnabled" value="true"/>
+</settings>
+
+<cache></cache>
+
+<select id="findById" resultType="com.lagou.pojo.User" useCache="true">
+ select * from user where id = #{id}
+</select>
+2.config中的配置解析,将配置设置到configuration中
+ private void parseConfiguration(XNode root){
+ try{
+ // issue #117 read properties first
+ propertiesElement(root.evalNode("properties"));
+ Properties settings=settingsAsProperties(root.evalNode("settings"));
+ loadCustomVfs(settings);
+ loadCustomLogImpl(settings);
+ typeAliasesElement(root.evalNode("typeAliases"));
+ pluginElement(root.evalNode("plugins"));
+ objectFactoryElement(root.evalNode("objectFactory"));
+ objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
+ reflectorFactoryElement(root.evalNode("reflectorFactory"));
+ // 缓存标签解析
+ settingsElement(settings);
+ // read it after objectFactory and objectWrapperFactory issue #631
+ environmentsElement(root.evalNode("environments"));
+ databaseIdProviderElement(root.evalNode("databaseIdProvider"));
+ typeHandlerElement(root.evalNode("typeHandlers"));
+ mapperElement(root.evalNode("mappers"));
+ }catch(Exception e){
+ throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: "+e,e);
+ }
+ }
+3.mapper中的cache标签解析,以nameSpace为key存储cache到configuration中
+ private void cacheElement(XNode context){
+ if(context!=null){
+ String type=context.getStringAttribute("type","PERPETUAL");
+ Class<?extends Cache> typeClass=typeAliasRegistry.resolveAlias(type);
+ String eviction=context.getStringAttribute("eviction","LRU");
+ Class<?extends Cache> evictionClass=typeAliasRegistry.resolveAlias(eviction);
+ Long flushInterval=context.getLongAttribute("flushInterval");
+ Integer size=context.getIntAttribute("size");
+ boolean readWrite=!context.getBooleanAttribute("readOnly",false);
+ boolean blocking=context.getBooleanAttribute("blocking",false);
+ Properties props=context.getChildrenAsProperties();
+ builderAssistant.useNewCache(typeClass,evictionClass,flushInterval,size,readWrite,blocking,props);
+ }
+ }
+
+
+public Cache useNewCache(Class<?extends Cache> typeClass,
+ Class<?extends Cache> evictionClass,
+ Long flushInterval,
+ Integer size,
+ boolean readWrite,
+ boolean blocking,
+ Properties props){
+ Cache cache=new CacheBuilder(currentNamespace)
+ .implementation(valueOrDefault(typeClass,PerpetualCache.class))
+ .addDecorator(valueOrDefault(evictionClass,LruCache.class))
+ .clearInterval(flushInterval)
+ .size(size)
+ .readWrite(readWrite)
+ .blocking(blocking)
+ .properties(props)
+ .build();
+ //只会解析赋值一次
+ configuration.addCache(cache);
+ //每个mapper只有一个cache
+ currentCache=cache;
+ return cache;
+ }
+4.每个sql语句中的userCache配置,在buildStatementFromContext时设置给每个MappedStatement对象
+ public MappedStatement addMappedStatement(
+ String id,
+ SqlSource sqlSource,
+ StatementType statementType,
+ SqlCommandType sqlCommandType,
+ Integer fetchSize,
+ Integer timeout,
+ String parameterMap,
+ Class<?> parameterType,
+ String resultMap,
+ Class<?> resultType,
+ ResultSetType resultSetType,
+ boolean flushCache,
+ boolean useCache,
+ boolean resultOrdered,
+ KeyGenerator keyGenerator,
+ String keyProperty,
+ String keyColumn,
+ String databaseId,
+ LanguageDriver lang,
+ String resultSets){
+
+ if(unresolvedCacheRef){
+ throw new IncompleteElementException("Cache-ref not yet resolved");
+ }
+
+ id=applyCurrentNamespace(id,false);
+ boolean isSelect=sqlCommandType==SqlCommandType.SELECT;
+
+ MappedStatement.Builder statementBuilder=new MappedStatement.Builder(configuration,id,sqlSource,sqlCommandType)
+ .resource(resource)
+ .fetchSize(fetchSize)
+ .timeout(timeout)
+ .statementType(statementType)
+ .keyGenerator(keyGenerator)
+ .keyProperty(keyProperty)
+ .keyColumn(keyColumn)
+ .databaseId(databaseId)
+ .lang(lang)
+ .resultOrdered(resultOrdered)
+ .resultSets(resultSets)
+ .resultMaps(getStatementResultMaps(resultMap,resultType,id))
+ .resultSetType(resultSetType)
+ .flushCacheRequired(valueOrDefault(flushCache,!isSelect))
+ .useCache(valueOrDefault(useCache,isSelect))
+ //添加前面创建的cache对象
+ .cache(currentCache);
+
+ ParameterMap statementParameterMap=getStatementParameterMap(parameterMap,parameterType,id);
+ if(statementParameterMap!=null){
+ statementBuilder.parameterMap(statementParameterMap);
+ }
+
+ MappedStatement statement=statementBuilder.build();
+ configuration.addMappedStatement(statement);
+ return statement;
+ }
+5.执行查询语句时,逻辑如下
+
+public<E> List<E> query(MappedStatement ms,Object parameterObject,RowBounds rowBounds,ResultHandler resultHandler)throws SQLException{
+ BoundSql boundSql=ms.getBoundSql(parameterObject);
+ //创建缓存key
+ CacheKey key=this.createCacheKey(ms,parameterObject,rowBounds,boundSql);
+ return this.query(ms,parameterObject,rowBounds,resultHandler,key,boundSql);
+ }
+
+
+public<E> List<E> query(MappedStatement ms,Object parameterObject,RowBounds rowBounds,ResultHandler resultHandler,CacheKey key,BoundSql boundSql)throws SQLException{
+ //判断是否配置了开启缓存
+ Cache cache=ms.getCache();
+ if(cache!=null){
+ //如果需要刷新缓存的化,flushCache="true"
+ this.flushCacheIfRequired(ms);
+ if(ms.isUseCache()&&resultHandler==null){
+ this.ensureNoOutParams(ms,boundSql);
+ //访问二级缓存
+ List<E> list=(List)this.tcm.getObject(cache,key);
+ if(list==null){
+ // 缓存未命中,访问一级缓存,一级缓存没有,再查询数据库
+ list=this.delegate.query(ms,parameterObject,rowBounds,resultHandler,key,boundSql);
+ // 缓存查询结果
+ this.tcm.putObject(cache,key,list);
+ }
+
+ return list;
+ }
+ }
+
+ return this.delegate.query(ms,parameterObject,rowBounds,resultHandler,key,boundSql);
+ }
+6.二级缓存安全问题,以及为什么需要提交才能更新缓存值
+// 事务缓存管理器
+public class TransactionalCacheManager {
+
+ // Cache与TransactionCache的映射关系表
+ private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
+
+ public void clear(Cache cache) {
+
+ getTransactionalCache(cache).clear();
+ }
+
+ public Object getObject(Cache cache, CacheKey key) {
+ return getTransactionalCache(cache).getObject(key);
+ }
+
+ public void putObject(Cache cache, CacheKey key, Object value) {
+ getTransactionalCache(cache).putObject(key, value);
+ }
+
+ public void commit() {
+ for (TransactionalCache txCache : transactionalCaches.values()) {
+ txCache.commit();
+ }
+ }
+
+ public void rollback() {
+ for (TransactionalCache txCache : transactionalCaches.values()) {
+ txCache.rollback();
+ }
+ }
+
+ private TransactionalCache getTransactionalCache(Cache cache) {
+ // 从映射表中获取 TransactionalCach,若不存在,则创建一个新的对象,并设cache值进去
+ return MapUtil.computeIfAbsent(transactionalCaches, cache, TransactionalCache::new);
+ }
+
+}
+
+// 这是Cache缓存的一个子类
+public class TransactionalCache implements Cache {
+
+ private static final Log log = LogFactory.getLog(TransactionalCache.class);
+
+ //真正的缓存对象，和上⾯的Map<Cache, TransactionalCache>中的Cache是同⼀个
+ private final Cache delegate;
+ private boolean clearOnCommit;
+ // 在事务被提交前，所有从数据库中查询的结果将缓存在此集合中
+ private final Map<Object, Object> entriesToAddOnCommit;
+ // 在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中
+ private final Set<Object> entriesMissedInCache;
+
+ public TransactionalCache(Cache delegate) {
+ this.delegate = delegate;
+ this.clearOnCommit = false;
+ this.entriesToAddOnCommit = new HashMap<>();
+ this.entriesMissedInCache = new HashSet<>();
+ }
+
+ @Override
+ public String getId() {
+ return delegate.getId();
+ }
+
+ @Override
+ public int getSize() {
+ return delegate.getSize();
+ }
+
+ @Override
+ public Object getObject(Object key) {
+ // issue #116
+ Object object = delegate.getObject(key);
+ if (object == null) {
+ entriesMissedInCache.add(key);
+ }
+ // issue #146
+ if (clearOnCommit) {
+ return null;
+ } else {
+ return object;
+ }
+ }
+
+ @Override
+ public void putObject(Object key, Object object) {
+ entriesToAddOnCommit.put(key, object);
+ }
+
+ @Override
+ public Object removeObject(Object key) {
+ return null;
+ }
+
+ @Override
+ public void clear() {
+ clearOnCommit = true;
+ entriesToAddOnCommit.clear();
+ }
+
+ public void commit() {
+ if (clearOnCommit) {
+ delegate.clear();
+ }
+ //当commit时,会调用刷新方法
+ flushPendingEntries();
+ reset();
+ }
+
+ public void rollback() {
+ unlockMissedEntries();
+ reset();
+ }
+
+ private void reset() {
+ clearOnCommit = false;
+ entriesToAddOnCommit.clear();
+ entriesMissedInCache.clear();
+ }
+
+ //将缓存中的值刷新到真实的Cache中,
+ private void flushPendingEntries() {
+ for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
+ delegate.putObject(entry.getKey(), entry.getValue());
+ }
+ for (Object entry : entriesMissedInCache) {
+ if (!entriesToAddOnCommit.containsKey(entry)) {
+ delegate.putObject(entry, null);
+ }
+ }
+ }
+
+ private void unlockMissedEntries() {
+ for (Object entry : entriesMissedInCache) {
+ try {
+ delegate.removeObject(entry);
+ } catch (Exception e) {
+ log.warn("Unexpected exception while notifying a rollback to the cache adapter. "
+ + "Consider upgrading your cache adapter to the latest version. Cause: " + e);
+ }
+ }
+ }
+
+}
+1.MyBatis允许拦截的方法
+2.这四大对象创建时,都是调用interceptorChain.pluginAll(parameterHandler)返回的代理对象
+ public ParameterHandler newParameterHandler(MappedStatement mappedStatement,Object parameterObject,BoundSql boundSql){
+ ParameterHandler parameterHandler=mappedStatement.getLang().createParameterHandler(mappedStatement,parameterObject,boundSql);
+ parameterHandler=(ParameterHandler)interceptorChain.pluginAll(parameterHandler);
+ return parameterHandler;
+ }
+ public Object pluginAll(Object target){
+ for(Interceptor interceptor:interceptors){
+ target=interceptor.plugin(target);
+ }
+ return target;
+ }
+default Object plugin(Object target){
+ return Plugin.wrap(target,this);
+ }
+public static Object wrap(Object target,Interceptor interceptor){
+ Map<Class<?>,Set<Method>>signatureMap=getSignatureMap(interceptor);
+ Class<?> type=target.getClass();
+ Class<?>[]interfaces=getAllInterfaces(type,signatureMap);
+ if(interfaces.length>0){
+ return Proxy.newProxyInstance(
+ type.getClassLoader(),
+ interfaces,
+ new Plugin(target,interceptor,signatureMap));
+ }
+ return target;
+ }
+3.因此调用这四大对象的方法时,会执行Plugin类中的invoke()方法逻辑
+ @Override
+public Object invoke(Object proxy,Method method,Object[]args)throws Throwable{
+ try{
+ Set<Method> methods=signatureMap.get(method.getDeclaringClass());
+ if(methods!=null&&methods.contains(method)){
+ return interceptor.intercept(new Invocation(target,method,args));
+ }
+ return method.invoke(target,args);
+ }catch(Exception e){
+ throw ExceptionUtil.unwrapThrowable(e);
+ }
+ }
+4.上述处理逻辑中当方法匹配时,调用了intercept方法,所以会执行拦截器中的方法进行增强
+
+@Intercepts({
+ @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
+})
+public class ExamplePlugin implements Interceptor {
+
+ /**
+ * 只要被拦截的目标对象方法被执行时,每次都会执行
+ *
+ * @param invocation
+ * @return
+ * @throws Throwable
+ */
+ @Override
+ public Object intercept(Invocation invocation) throws Throwable {
+ System.out.println("对方法进行了增强");
+ //执行原方法
+ return invocation.proceed();
+ }
+
+ /**
+ * 将当前拦截器存储到拦截器链中
+ *
+ * @param target
+ * @return
+ */
+ @Override
+ public Object plugin(Object target) {
+ return Plugin.wrap(target, this);
+ }
+
+ /**
+ * 获取配置文件的参数
+ *
+ * @param properties
+ */
+ @Override
+ public void setProperties(Properties properties) {
+ System.out.println("获取的配置文件参数是" + properties);
+ Interceptor.super.setProperties(properties);
+ }
+}
+//获取mapper
+userMapper=sqlSession.getMapper(IUserMapper.class);
+//DefaultSqlSession
+public<T> T getMapper(Class<T> type){
+ return this.configuration.getMapper(type,this);
+ }
+//Configuration
+public<T> T getMapper(Class<T> type,SqlSession sqlSession){
+ return mapperRegistry.getMapper(type,sqlSession);
+ }
+//MapperRegistry
+public<T> T getMapper(Class<T> type,SqlSession sqlSession){
+final MapperProxyFactory<T> mapperProxyFactory=(MapperProxyFactory<T>)knownMappers.get(type);
+ if(mapperProxyFactory==null){
+ throw new BindingException("Type "+type+" is not known to the MapperRegistry.");
+ }
+ try{
+ //通过静态工厂生成示例
+ return mapperProxyFactory.newInstance(sqlSession);
+ }catch(Exception e){
+ throw new BindingException("Error getting mapper instance. Cause: "+e,e);
+ }
+ }
+//MapperProxyFactory
+public T newInstance(SqlSession sqlSession){
+//创建了JDK动态代理的handler类
+final MapperProxy<T> mapperProxy=new MapperProxy<>(sqlSession,mapperInterface,methodCache);
+ //调用重载方法
+ return newInstance(mapperProxy);
+ }
+// 重载方法
+protected T newInstance(MapperProxy<T> mapperProxy){
+ return(T)Proxy.newProxyInstance(mapperInterface.getClassLoader(),new Class[]{mapperInterface},mapperProxy);
+ }
+//MapperProxy 类，实现了 InvocationHandler 接⼝
+public class MapperProxy<T> implements InvocationHandler, Serializable {
+ //省略部分源码
+ private final SqlSession sqlSession;
+ private final Class<T> mapperInterface;
+ private final Map<Method, MapperMethod> methodCache;
+
+ //构造，传⼊了 SqlSession，说明每个session中的代理对象的不同的！
+ public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface,
+ Map<Method, MapperMethod> methodCache) {
+ this.sqlSession = sqlSession;
+ this.mapperInterface = mapperInterface;
+ this.methodCache = methodCache;
+ }
+ //省略部分源码
+}
+
+
+ //invoke方法
+ public Object invoke(Object proxy, Method method, Object[] args) throws
+ Throwable {
+ try {
+ //如果是Object定义的⽅法，直接调⽤
+ if (Object.class.equals(method.getDeclaringClass())) {
+ return method.invoke(this, args);
+ } else if (isDefaultMethod(method)) {
+ return invokeDefaultMethod(proxy, method, args);
+ }
+ } catch (Throwable t) {
+ throw ExceptionUtil.unwrapThrowable(t);
+ }
+ // 获得 MapperMethod 对象
+ final MapperMethod mapperMethod = cachedMapperMethod(method);
+ //重点在这：MapperMethod最终调⽤了执⾏的⽅法
+ return mapperMethod.execute(sqlSession, args);
+ }
+
+ //execute方法
+ public Object execute(SqlSession sqlSession, Object[] args) {
+ Object result;
+ //判断mapper中的⽅法类型，最终调⽤的还是SqlSession中的⽅法 switch
+ switch (command.getType()) {
+ case INSERT: {
+ //转换参数
+ Object param = method.convertArgsToSqlCommandParam(args);
+ //执⾏INSERT操作
+ // 转换 rowCount
+ result = rowCountResult(sqlSession.insert(command.getName(), param));
+ break;
+ }
+ case UPDATE: {
+ Object param = method.convertArgsToSqlCommandParam(args);
+ result = rowCountResult(sqlSession.update(command.getName(), param));
+ break;
+ }
+ case DELETE: {
+ Object param = method.convertArgsToSqlCommandParam(args);
+ result = rowCountResult(sqlSession.delete(command.getName(), param));
+ break;
+ }
+ case SELECT:
+ //⽆返回，并且有ResultHandler⽅法参数，则将查询的结果，提交给 ResultHandler 进⾏处理
+ if (method.returnsVoid() && method.hasResultHandler()) {
+ executeWithResultHandler(sqlSession, args);
+ result = null;
+ } else if (method.returnsMany()) {
+ result = executeForMany(sqlSession, args);
+ } else if (method.returnsMap()) {
+ result = executeForMap(sqlSession, args);
+ } else if (method.returnsCursor()) {
+ result = executeForCursor(sqlSession, args);
+ } else {
+ Object param = method.convertArgsToSqlCommandParam(args);
+ result = sqlSession.selectOne(command.getName(), param);
+ if (method.returnsOptional()
+ && (result == null || !method.getReturnType().equals(result.getClass()))) {
+ result = Optional.ofNullable(result);
+ }
+ }
+ break;
+ case FLUSH:
+ result = sqlSession.flushStatements();
+ break;
+ default:
+ throw new BindingException("Unknown execution method for: " + command.getName());
+ }
+ //返回结果为null，并且返回类型为基本类型，则抛出BindingException异常
+ if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
+ throw new BindingException("Mapper method '" + command.getName()
+ + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
+ }
+ return result;
+ }
+}
+1.开启全局延迟加载配置
+
+<settings>
+ <!--开启全局延迟加载功能-->
+ <setting name="lazyLoadingEnabled" value="true"/>
+</settings>
+2.配置局部延迟加载
+<!-- 开启⼀对多 延迟加载 -->
+<resultMap id="userMap" type="user">
+ <id column="id" property="id"></id>
+ <result column="username" property="username"></result>
+ <result column="password" property="password"></result>
+ 全局延迟加载
+ 在Mybatis的核⼼配置⽂件中可以使⽤setting标签修改全局的加载策略。
+ 注意
+ 7.。
+ <result column="birthday" property="birthday"></result>
+ <!--
+ fetchType="lazy" 懒加载策略
+ fetchType="eager" ⽴即加载策略
+ -->
+ <collection property="orderList" ofType="order" column="id"
+ select="com.lagou.dao.OrderMapper.findByUid" fetchType="lazy">
+ </collection>
+</resultMap>
+<select id="findAll" resultMap="userMap">
+SELECT * FROM `user`
+</select>
+3.Configuration中的配置
+public class Configuration {
+ /** aggressiveLazyLoading：
+ * 当开启时，任何⽅法的调⽤都会加载该对象的所有属性。否则，每个属性会按需加载（参考
+ lazyLoadTriggerMethods).
+ * 默认为true
+ * */
+ protected boolean aggressiveLazyLoading;
+ /**
+ * 延迟加载触发⽅法
+ */
+ protected Set<String> lazyLoadTriggerMethods = new HashSet<String>
+ (Arrays.asList(new String[]{"equals", "clone", "hashCode", "toString"}));
+ /** 是否开启延迟加载 */
+ protected boolean lazyLoadingEnabled = false;
+
+ /**
+ 延迟加载代理对象创建
+ Mybatis的查询结果是由ResultSetHandler接⼝的handleResultSets()⽅法处理的。ResultSetHandler
+ 接⼝只有⼀个实现，DefaultResultSetHandler，接下来看下延迟加载相关的⼀个核⼼的⽅法
+ * 默认使⽤Javassist代理⼯⼚
+ * @param proxyFactory
+ */
+ public void setProxyFactory(ProxyFactory proxyFactory) {
+ if (proxyFactory == null) {
+ proxyFactory = new JavassistProxyFactory();
+ }
+ this.proxyFactory = proxyFactory;
+ }
+
+ //省略...
+}
+4.查看ResultSetHandler如何实现延迟加载
+ private Object createResultObject(ResultSetWrapper rsw,ResultMap resultMap,ResultLoaderMap lazyLoader,String columnPrefix)throws SQLException{
+ this.useConstructorMappings=false; // reset previous mapping result
+final List<Class<?>>constructorArgTypes=new ArrayList<>();
+final List<Object> constructorArgs=new ArrayList<>();
+ //创建返回的结果映射的真实对
+ Object resultObject=createResultObject(rsw,resultMap,constructorArgTypes,constructorArgs,columnPrefix);
+ if(resultObject!=null&&!hasTypeHandlerForResultObject(rsw,resultMap.getType())){
+final List<ResultMapping> propertyMappings=resultMap.getPropertyResultMappings();
+ for(ResultMapping propertyMapping:propertyMappings){
+ // issue gcode #109 && issue #149
+ // 判断属性有没配置嵌套查询，如果有就创建代理对象
+ if(propertyMapping.getNestedQueryId()!=null&&propertyMapping.isLazy()){
+ //#mark 创建延迟加载代理对象
+ resultObject=configuration.getProxyFactory().createProxy(resultObject,lazyLoader,configuration,objectFactory,constructorArgTypes,constructorArgs);
+ break;
+ }
+ }
+ }
+ this.useConstructorMappings=resultObject!=null&&!constructorArgTypes.isEmpty(); // set current mapping result
+ return resultObject;
+ }
+5.代理对象执行逻辑
+private static class EnhancedResultObjectProxyImpl implements MethodHandler {
+
+ private final Class<?> type;
+ private final ResultLoaderMap lazyLoader;
+ private final boolean aggressive;
+ private final Set<String> lazyLoadTriggerMethods;
+ private final ObjectFactory objectFactory;
+ private final List<Class<?>> constructorArgTypes;
+ private final List<Object> constructorArgs;
+
+ private EnhancedResultObjectProxyImpl(Class<?> type, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
+ this.type = type;
+ this.lazyLoader = lazyLoader;
+ this.aggressive = configuration.isAggressiveLazyLoading();
+ this.lazyLoadTriggerMethods = configuration.getLazyLoadTriggerMethods();
+ this.objectFactory = objectFactory;
+ this.constructorArgTypes = constructorArgTypes;
+ this.constructorArgs = constructorArgs;
+ }
+
+ public static Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
+ final Class<?> type = target.getClass();
+ EnhancedResultObjectProxyImpl callback = new EnhancedResultObjectProxyImpl(type, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
+ Object enhanced = crateProxy(type, callback, constructorArgTypes, constructorArgs);
+ PropertyCopier.copyBeanProperties(type, target, enhanced);
+ return enhanced;
+ }
+
+ @Override
+ public Object invoke(Object enhanced, Method method, Method methodProxy, Object[] args) throws Throwable {
+ final String methodName = method.getName();
+ try {
+ synchronized (lazyLoader) {
+ if (WRITE_REPLACE_METHOD.equals(methodName)) {
+ Object original;
+ if (constructorArgTypes.isEmpty()) {
+ original = objectFactory.create(type);
+ } else {
+ original = objectFactory.create(type, constructorArgTypes, constructorArgs);
+ }
+ PropertyCopier.copyBeanProperties(type, enhanced, original);
+ if (lazyLoader.size() > 0) {
+ return new JavassistSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
+ } else {
+ return original;
+ }
+ } else {
+ if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
+ if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
+ lazyLoader.loadAll();
+ } else if (PropertyNamer.isSetter(methodName)) {
+ final String property = PropertyNamer.methodToProperty(methodName);
+ lazyLoader.remove(property);
+ } else if (PropertyNamer.isGetter(methodName)) {
+ final String property = PropertyNamer.methodToProperty(methodName);
+ if (lazyLoader.hasLoader(property)) {
+ lazyLoader.load(property);
+ }
+ }
+ }
+ }
+ }
+ return methodProxy.invoke(enhanced, args);
+ } catch (Throwable t) {
+ throw ExceptionUtil.unwrapThrowable(t);
+ }
+ }
+}
+Nginx 是一个HTTP和反向代理服务器，一个邮件代理服务器和一个通用的TCP/UDP代理服务器。
+作为 Web 服务器：相比 Apache，Nginx 使用更少的资源，支持更多的并发连接，体现更高的效率，这点使 Nginx 尤其受到虚拟主机提供商的欢迎。能够支持高达 50,000 个并发连接数的响应，感谢 Nginx 为我们选择了 epoll and kqueue 作为开发模型.
+作为负载均衡服务器：Nginx 既可以在内部直接支持 Rails 和 PHP，也可以支持作为 HTTP代理服务器对外进行服务。Nginx 用 C 编写, 不论是系统资源开销还是 CPU 使用效率都比 Perlbal 要好的多。
+作为邮件代理服务器: Nginx 同时也是一个非常优秀的邮件代理服务器（最早开发这个产品的目的之一也是作为邮件代理服务器），Last.fm 描述了成功并且美妙的使用经验。
+Nginx 安装非常的简单，配置文件 非常简洁（还能够支持perl语法），Bugs非常少的服务器:Nginx启动特别容易，并且几乎可以做到7*24不间断运行，即使运行数个月也不需要重新启动。你还能够在不间断服务的情况下进行软件版本的升级。
+[官方网站]http://nginx.org/download/nginx-1.22.0.zip)
+下载上面的压缩包解压运行nginx即可!
+
# centos
+运行命令yum install nginx即可完成安装.
+# ubuntu
+运行命令apt install nginx即可完成安装.
+安装完成之后,执行nginx即可启动服务.
+默认路径配置:
+(1) Nginx配置路径：/etc/nginx/
+(2) PID目录：/var/run/nginx.pid
+(3) 错误日志：/var/log/nginx/error.log
+(4) 访问日志：/var/log/nginx/access.log
+(5) 默认站点目录：/usr/share/nginx/html
++ ++
若提示weget command not found ,则请执行以下命令,安装weget
+yum -y install wget
+编译安装所需的额外插件
+Gcc：yum install gcc c++ （用于编译c、c++代码）
+Pcre：yum install -y pcre pcre-devel（用c语言编写的正则表达式函数库））
+Zlib：yum install -y zlib zlib-devel（用于数据压缩的函式库））
+OpenSSL：yum install -y openssl openssl-devel安全套接字层密码库））
+插件安装命令
+yum install -y pcre pcre-devel
+yum install -y zlib zlib-devel
+yum install -y openssl openssl-devel
+编译nginx
+tar -zxvf nginx-1.15.tar.gz
+cd nginx-1.15
+./configure
+make
+make install
+启动nginx
+cd /usr/local/nginx/
+cd sbin/
+./nginx
+若想要全局都能执行nginx命令,可以编辑配置文件.将nginx加入到系统变量
+1. vim /etc/profile
+2. 添加nginx的路径配置
+PATH=$PATH:/usr/local/nginx/sbin
+export PATH
+3.保存退出,执行命令更新配置
+source /etc/profile
+
命令: rpm -ql nginx
+rpm是linux的rpm包管理工具,-q代表询问模式,-l 代表返回列表
+
执行如下命令,打开配置文件
+cd /etc/nginx
+vim nginx.conf
+内容如下
+#运行用户，默认即是nginx，可以不进行设置
+user nginx;
+#Nginx进程，一般设置为和CPU核数一样
+worker_processes 1;
+#错误日志存放目录
+error_log /var/log/nginx/error.log warn;
+#进程pid存放位置
+pid /var/run/nginx.pid;
+
+
+events {
+ worker_connections 1024; # 单个后台进程的最大并发数
+}
+
+
+http {
+ include /etc/nginx/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 /var/log/nginx/access.log main; #nginx访问日志存放位置
+
+ sendfile on; #开启高效传输模式
+ #tcp_nopush on; #减少网络报文段的数量
+
+ keepalive_timeout 65; #保持连接的时间，也叫超时时间
+
+ #gzip on; #开启gzip压缩
+
+ include /etc/nginx/conf.d/*.conf; #包含的子配置项位置和文件
+从配置文件到events块之间的内容，主要会设置一些影响nginx服务器整体运行的配置指令，主要包括配置运行Nginx服务器的用户、允许生成的worker process数，进程PID存放路径，日志存放路径和类型以及配置文件的引入等
+events块涉及的指令主要影响Nginx服务器与用户的网络连接
+Nginx服务器培配置中最频繁的部分、代理、缓存和日志定义等绝大多数的功能和第三方模块的配置都在这里
http全局快配置的指令包括文件引入，MIME-TYPE定义，日志自定义，连接超时时间，单链接请求书上限等
每个server块也分为全局server块，以及可以同时包含多个location块
+
systemctl restart nginx.service
+nginx -s reload
+netstat -tlnp
+
错误页面跳转
+在nginx.conf文件中,可以针对不同的错误,来进行不同的跳转
+
server{
+ listen 8010;
+ server_name _;
+ root /wangzai/images;
+ index a.jpg;
+ }
+server{
+ listen 80;
+ server_name nginx2.jspang.com;
+ location / {
+ root /usr/share/nginx/html/html8001;
+ index index.html index.htm;
+ }
+}
+如果把局域网外的internet想象成一个巨大的资源库，则局域网中的客户端要访问internet，则需要通过代理服务器来访问，这种代理服务就称为正向代理。用作正向代理来代理进行上网等功能。
其实客户端对代理是无感知到，因为客户端不需要任何配置就可以访问，我们只需要将请求发送到反向代理服务器，由反向代理服务器去选择目标服务器获取数据后，在返回给客户端，此时反向代理服务器和目标服务器对外就是一个服务器，暴露的是代理服务器地址，隐藏了真实服务器IP地址。
反向代理常用指令
proxy_set_header: 在将客户端请求发送给后端服务器之前，更改来自客户端的请求头信息。
proxy_connect_timeout: 配置Nginx与后端代理服务器尝试建立连接的超时时间。
proxy_read_timeout : 配置Nginx向后端服务器组发出read请求后，等待相应的超时时间。
proxy_send_timeout: 配置Nginx向后端服务器组发出write请求后，等待相应的超时时间。
proxy_redirect: 用于修改后端服务器返回的响应头中的Location和Refresh。
单个服务器解决不了，我们增加服务器的数量，然后将请求分发到各个服务器上，将原先请求集中到单个服务器上的情况改为将请求分发到多个服务器上，将负载分发到不同的服务器，也就是我们所说的负载均衡。
+upstream lagouServer{
+ server 111.229.248.243:8080;
+ server 111.229.248.243:8082;
+}
+location /abc {
+ proxy_pass http://lagouServer/;
+}
+为了加快网站的解析速度，可以将动态页面和静态页面由不同的服务器来解析，加快解析速度，降低原来单个服务器的压力
使用内置变量 $http_user_agent 获取请求客户端的userAgent
+ server{
+ listen 80;
+ server_name nginx2.jspang.com;
+ location / {
+ root /usr/share/nginx/pc;
+ if ($http_user_agent ~* '(Android|webOS|iPhone|iPod|BlackBerry)') {
+ root /usr/share/nginx/mobile;
+ }
+ index index.html;
+ }
+ }
+gzip : 该指令用于开启或 关闭gzip模块。
gzip_buffers : 设置系统获取几个单位的缓存用于存储gzip的压缩结果数据流。
gzip_comp_level : gzip压缩比，压缩级别是1-9，1的压缩级别最低，9的压缩级别最高。压缩级别越高压缩率越大，压缩时间越长。
gzip_disable : 可以通过该指令对一些特定的User-Agent不使用压缩功能。
gzip_min_length:设置允许压缩的页面最小字节数，页面字节数从相应消息头的Content-length中进行获取。
gzip_http_version：识别HTTP协议版本，其值可以是1.1.或1.0.
gzip_proxied : 用于设置启用或禁用从代理服务器上收到相应内容gzip压缩。
gzip_vary : 用于在响应消息头中添加Vary：Accept-Encoding,使代理服务器根据请求头中的Accept-Encoding识别是否启用gzip压缩。
轮询: 默认方式，每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务挂了，能自动剔除；
weight: 权重分配，指定轮询几率，权重越高，在被访问的概率越大，用于后端服务器性能不均的情况；
ip_hash: 每个请求按访问 IP 的 hash 结果分配，这样每个访客固定访问一个后端服务器，可以解决动态网页 session 共享问题。负载均衡每次请求都会重新定位到服务器集群中的某一个，那么已经登录某一个服务器的用户再重新定位到另一个服务器，其登录信息将会丢失，这样显然是不妥的；
fair: 按后端服务器的响应时间分配，响应时间短的优先分配，依赖第三方插件 nginx-upstream-fair，需要先安装；
http {
+ upstream myserver {
+ # ip_hash; # ip_hash 方式
+ # fair; # fair 方式
+ server 127.0.0.1:8081; # 负载均衡目的服务地址
+ server 127.0.0.1:8080;
+ server 127.0.0.1:8082 weight=10; # weight 方式，不写默认为 1
+ }
+
+ server {
+ location / {
+ proxy_pass http://myserver;
+ proxy_connect_timeout 10;
+ }
+ }
+}
+跨域是基于浏览器的同源策略决定的
+# 同源的例子
+http://example.com/app1/index.html # 只是路径不同
+http://example.com/app2/index.html
+
+http://Example.com:80 # 只是大小写差异
+http://example.com
+
+# 不同源的例子
+http://example.com/app1 # 协议不同
+https://example.com/app2
+
+http://example.com # host 不同
+http://www.example.com
+http://myapp.example.com
+
+http://example.com # 端口不同
+http://example.com:8080
+server {
+ listen 9001;
+ server_name fe.sherlocked93.club;
+
+ location / {
+ proxy_pass be.sherlocked93.club;
+ }
+}
+a,b两个页面,请求直接访问b可以,但是通过前端页面a中转b会报跨域错误.
+# /etc/nginx/conf.d/be.sherlocked93.club.conf
+
+server {
+ listen 80;
+ server_name be.sherlocked93.club;
+
+ add_header 'Access-Control-Allow-Origin' $http_origin; # 全局变量获得当前请求origin，带cookie的请求不支持*
+ add_header 'Access-Control-Allow-Credentials' 'true'; # 为 true 可带上 cookie
+ add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS'; # 允许请求方法
+ add_header 'Access-Control-Allow-Headers' $http_access_control_request_headers; # 允许请求的 header，可以为 *
+ add_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range';
+
+ if ($request_method = 'OPTIONS') {
+ add_header 'Access-Control-Max-Age' 1728000; # OPTIONS 请求的有效期，在有效期内不用发出另一条预检请求
+ add_header 'Content-Type' 'text/plain; charset=utf-8';
+ add_header 'Content-Length' 0;
+
+ return 204; # 200 也可以
+ }
+
+ location / {
+ root /usr/share/nginx/html/be;
+ index index.html;
+ }
+}
+# 虚拟主机
+server {
+ listen 8080;
+ server_name xx_domian; # 浏览器访问域名(若是本地调试,需要在host文件中配置ip,域名映射)
+
+ charset utf-8;
+ access_log logs/xx_domian.access.log access;
+
+ # 路由
+ location / {
+ root www; # 访问根目录
+ index index.html index.htm; # 入口文件
+ }
+}
+location ~.*\.css$ {
+ expires 1d;
+ break;
+}
+location ~.*\.js$ {
+ expires 1d;
+ break;
+}
+
+location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$ {
+ access_log off;
+ expires 15d; #保存15天
+ break;
+}
+location ~* \.(js|css|png|jpg|gif)$ {
+ add_header Cache-Control no-store;
+}
+location ~* \.(gif|jpg|png)$ {
+ # 只允许 192.168.0.1 请求资源
+ valid_referers none blocked 192.168.0.1;
+ if ($invalid_referer) {
+ rewrite ^/ http://$host/logo.png;
+ }
+}
+server {
+ # 开启gzip 压缩
+ gzip on;
+ # 设置gzip所需的http协议最低版本 （HTTP/1.1, HTTP/1.0）
+ gzip_http_version 1.1;
+ # 设置压缩级别，压缩级别越高压缩时间越长 （1-9）
+ gzip_comp_level 4;
+ # 设置压缩的最小字节数， 页面Content-Length获取
+ gzip_min_length 1000;
+ # 设置压缩文件的类型 （text/html)
+ gzip_types text/plain application/javascript text/css;
+}
+# 根据状态码，返回对于的错误页面
+error_page 500 502 503 504 /50x.html;
+location = /50x.html {
+ root /source/error_page;
+}
+++前端server域名: http://xx_domain
+后端server域名: https://github.com
+ +
## 配置反向代理的参数
+server {
+ listen 8080;
+ server_name xx_domain
+
+ ## 1. 用户访问 http://xx_domain，则反向代理到 https://github.com
+ location / {
+ proxy_pass https://github.com;
+ proxy_redirect off;
+ proxy_set_header Host $host; # 传递域名
+ proxy_set_header X-Real-IP $remote_addr; # 传递ip
+ proxy_set_header X-Scheme $scheme; # 传递协议
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ }
+}
+#虚拟主机的配置文件里加入：
+
+if ($http_user_agent ~* 'baidu|360|sohu') #禁止useragent为baidu、360和sohu，~*表示不区分大小写匹配
+{
+ return 403;
+}
+
+location / 和 location ~ / 优先级是不一样的。
+结合这个文章研究一下吧 http://blog.itpub.net/27181165/viewspace-777202/
+curl -A "baidu" -x127.0.0.1:80 www.test.com/forum.php -I 该命令指定百度为user_agent,返回403
+# 可以设置一些配置禁止一些ip的访问
+
+deny 127.0.0.1; #全局定义限制，location里的是局部定义的。如果两者冲突，以location这种精确地优先，
+
+location ~ .*admin\.php$ {
+ #auth_basic "cct auth";
+ #auth_basic_user_file /usr/local/nginx/conf/.htpasswd;
+
+ allow 127.0.0.1; 只允许127.0.0.1的访问，其他均拒绝
+ deny all;
+
+ include fastcgi_params;
+ fastcgi_pass unix:/tmp/www.sock;
+ fastcgi_index index.php;
+ fastcgi_param SCRIPT_FILENAME /data/www$fastcgi_script_name;
+}
+http {
+ upstream test.net {
+ ip_hash;
+ server 192.168.10.13:80;
+ server 192.168.10.14:80 down;
+ server 192.168.10.15:8009 max_fails=3 fail_timeout=20s;
+ server 192.168.10.16:8080;
+ }
+ server {
+ location / {
+ proxy_pass http://test.net;
+ }
+ }
+}
+ gzip on;
+ gzip_min_length 1k;
+ gzip_buffers 4 16k;
+ gzip_http_version 1.1;
+ gzip_comp_level 9;
+ gzip_types text/plain application/x-javascript text/css application/xml text/javascript application/x-httpd-php application/javascript application/json;
+ gzip_disable "MISE [1-6]\.";
+ gzip_vary on;
+Nginx启动后，以daemon多进程⽅式在后台运⾏，包括⼀个Master进程和多个Worker进程，Master 进程是领导，是⽼⼤，Worker进程是⼲活的⼩弟
worker进程具体处理网络请求,各进程互相独立,同等竞争
以./nginx -s reload来说明nginx信号处理部分
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 可能有很多人的网站由于不想备案，所以一般部署在国外服务器上面，这样导致的情况就是大多数国内CDN都无法使用，而且如果网站服务器线路不好的情况还会导致访问缓慢，这样会极大影响用户体验感！这时候我们就可以利用Nginx的反向代理设置达到网站加速的效果，同时由于访问的是节点服务器IP，也就避免了暴露源站IP的风险从而增强防御，而宝塔面板自带Nginx反向代理设置，操作起来就更简单容易了。
+ CDN，即 Content delivery network（内容分发网络），是指一种通过互联网互相连接的电脑网络系统，利用最靠近每位用户的服务器，更快、更可靠地将音乐、图片、视频、应用程序及其他文件发送给用户，来提供高性能、可扩展性及低成本的网络内容传递给用户。
+ 换言之，即我们的网站服务器位置是固定的，比如托管在北京电信机房，对于北京电信访客来说，网页加载速度很快，基本感受不到延迟，对于云南移动访客来说，网页加载速度就明显变慢，而对于海外访客来说，网页加载就要转圈圈了，体验不好。当我们上了 CDN 后，CDN 各地节点会缓存我们服务器的内容，根据 CDN 的原理，此时北京电信访客访问的服务器将是该 CDN 的北京节点（如果有），云南移动访客访问的将是云南节点（如果有），海外（中国大陆以外）访客访问的则是海外节点（如果有），访问及加载速度将会大幅提升，用户体验也会大大改善。
+
如上图所示，这是一个完整的流程图：客户端访问域名时，先向 DNS 请求域名 IP，DNS 查询到 CNAME 记录（如果没有 DNS 直接回复源服务器 IP），则进一步解析 CNAME 智能解析服务器， 智能解析收到请求根据客户端来源按规则判断并回复 CDN 节点 IP，客户端此时访问域名就连接到了回复的 CDN 节点，如果 CDN 节点没有缓存，则 CDN 就会发起连接到负载均衡器（如果没有则直接连接源服务器，一般在有多个源服务器后端时才会有负载均衡器），然后负载均衡器根据规则分流到源服务器，将内容返回给 CDN 节点，CDN 节点再返回给客户端，完成整个访问流程。
+ 从流程上看使用 CDN 后整个过程中增加了很多路由，看起来客户端访问速度可能会变慢，但实际上，从智能解析到负载均衡，客户端几乎是没有感知的，也就是说客户端能感受到的速度就是到 CDN 节点的速度。
+一键脚本:
+
+ if [ -f /usr/bin/curl ];then curl -sSO https://download.bt.cn/install/install_panel.sh;else wget -O install_panel.sh https://download.bt.cn/install/install_panel.sh;fi;bash install_panel.sh ed8484bec
+配置域名A解析到服务器A的IP.如
+
通过ping个人博客域名,如wangwangit.github.io(www.wangwangit.com),获取对应的IP
+
编辑服务器A的/etc/hosts文件,添加博客IP/博客域名的配置
+
打开我们香港服务器上的宝塔管理界面.新增站点.添加反向代理
+
反向代理配置如下,修改目标URL为自己博客的域名即可.
+
完成上面操作之后,访问域名,即可在缓存文件目录看到缓存文件,路径如下:
+默认缓存目录：/www/server/nginx/proxy_cache_dir
+反代配置文件：/www/server/nginx/conf/proxy.conf
+ping检测: https://ping.chinaz.com/wangwangit.com
+若ip是自己服务器的ip,并且域名可以访问博客.则说明代理成功!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 我的博客是基于Hexo+Github搭建的，图床也是使用的Github。众所周知，由于某些原因，Github上的图片经常无法访问。通常，我们会使用jsDelivr进行加速，或者使用国内的CDN服务提供商，如腾讯云、七牛云等。
+由于jsDelivr最近被墙了一段时间，国内访问速度也不太理想，因此我选择了腾讯CDN加速。价格倒是不贵，但最近发现由于一些文章的热度上升，流量消耗得很快。同时，我一直担心我的网站会受到恶意攻击。于是我决定换一种思路来解决这个问题，利用我自己的闲置服务器搭建一个加速器。
+关于图床和Nginx的教程，你可以查看之前的文章。
+第一步：
+拉取Github图片仓库到/var/www/目录下。请替换下面命令中的仓库地址为你自己的地址。
+
+ git clone https://github.com/image
+第二步：
+配置Nginx，映射当前图片仓库目录。假设我的图片仓库地址是：/var/www/image。以下配置的作用是，当访问 http://aaa.wangwangit.com/img/1.jpg 时，会实际访问服务器上的 /var/www/image/img/1.jpg 文件。
+server {
+ listen 80;
+ server_name aaa.wangwangit.com;
+ root /var/www/html;
+
+ location /img {
+ root /var/www/image/;
+ autoindex on;
+ }
+}
+完成修改后，执行 nginx -s reload 命令来更新配置。
第三步：
+上面两步实际上已经配置好了图床的加速器。我们只需要使用自己的域名地址进行访问即可。也许你会问为什么要使用Github，而不是直接将图片存储在服务器上。这样做有几个原因：首先，我的以前的图片已经存在Github上了；另外，使用Github的话，我不需要自己去维护图床。
+接下来，我们还需要及时拉取Github图床的更新。下面我来介绍如何实现这一点。
+我们可以使用Github的Webhook功能，在服务器的/var/www/目录下创建一个名为webhook_receiver.py的Python文件，并编辑以下内容：
+from flask import Flask, request
+import subprocess
+
+app = Flask(__name__)
+
+@app.route('/webhook', methods=['POST'])
+def webhook():
+ if request.headers.get('X-GitHub-Event') == 'push':
+ subprocess.Popen(['git', '-C', '/var/www/image', 'pull'])
+ return 'Webhook received successfully', 200
+ else:
+ return 'Unsupported event', 200
+
+if __name__ == '__main__':
+ app.run(host='0.0.0.0', port=5000)
+保存文件后，执行 pip install flask 命令来安装依赖。你可以先使用 python3 webhook_receiver.py 命令进行测试，确认是否正常运行。若一切正常，可以使用 Ctrl+c 结束执行，然后使用 nohup python3 webhook_receiver.py & 命令来运行它。
接下来，在Github项目中设置Webhook：
+http://your-server-ip:5000/webhook，将 your-server-ip 替换为你服务器的实际IP地址。
至此，部署完成。只需要在图床仓库上传一张图片，然后使用服务器的域名去访问，就可以测试是否配置正常了！
+我在文章中提到的几个方案，在之前的文章中都有详细介绍。如果你还有不懂的地方，可以去查看相关文章，或者加入我的交流学习群一起探讨！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 注意: 以下方法已经失效,官方关闭通道了,可以进群等后续通知!
+账号需要拥有Microsoft 365订阅!!!
+账号白嫖教程参考:Microsoft365账号申请教程 - 一只会飞的旺旺 (wangwangit.com)
+懒得折腾?直接购买:https://shop.wangwangit.com
+进群交流:
+群聊人数上限了,加我微信备注ai拉你进群!
+
教程已失效,官方关闭通道了,可以进群等后面更新!
+
路径如下:
+
+ 计算机\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration
+
右键单击Configuration文件夹,进行导出备份
+分别修改以下几个值
+AudienceData->Dogfood::DevMain
+AudienceID->ea4a4090-de26-49d7-93c1-91bff9e53fc3
+CDNBaseURL->http://officecdn.microsoft.com/pr/ea4a4090-de26-49d7-93c1-91bff9e53fc3
+UpdateChannel->http://officecdn.microsoft.com/pr/ea4a4090-de26-49d7-93c1-91bff9e53fc3
+
然后打开word进行更新
+
更新完成之后版本号应该是如下所示或者高于此版本号
+
再打开注册表路径
+计算机\HKEY_CURRENT_USER\Software\Microsoft\Office\16.0\Common\ExperimentConfigs\ExternalFeatureOverrides\word
+新建一个REG_SZ(字符串)值,如图
+名称:Microsoft.Office.Word.CoPilotExperiment
+值:true
+
再次重启word,即可看到Copilot了
+
Dogfood的更新频率很快，可能一周会发两到三个版本,而且目前很鸡肋，适合尝鲜，且目前好像只有word能用。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 甲骨文是一家做数据库的巨头公司，大家可能知道MySQL比较多，但是另外一个数据库巨头就是甲骨文了，也就是我们常说的Oracle数据库。后来云计算爆发，亚马逊、微软谷歌等美国巨头公司推出了自己的云计算服务，甲骨文也做了云计算服务。其它巨头推出免费试用一年，甲骨文2019年9月推出永久免费服务。不管他家的服务如何，总之“永久免费”的噱头一经打出，立即引来了不少流量。
+Oracle 云免费套餐只需注册 Oracle 云帐户即可获取，不仅包含丰富的 Always Free 云服务，还提供 300 美元的免费试用储值，让您可以在 30 天内免费使用所有适用的 Oracle 云基础设施服务。其中，Always Free 云服务无时长限制，免费试用仅 300 美元免费储值用尽或 30 天到期（以先到者为准）前有效。也就是花完这赠送的费用后，还能继续免费使用其VPS云主机。
+其实这个永久免费是有很多限制的，然后中国的薅羊毛大军加入，注册起来也是有些门槛和限制了。而且随着谷歌云将一年免费缩减到3个月免费使用，谷歌云的用户大量减少，因此目光都转向了Oracle Cloud甲骨文永久免费云主机，导致门槛越来越难进，申请越来越难，不过总得来讲，永久免费绝对是香的。
+Oracle Cloud甲骨文永久免费云主机可以包含的内容：
+最多创建2台实例，各自包含一条公网IP(IP地区仅限申请时选择的区域)，免费实例配置如下:
+甲骨文采用的是资源平均分配，一台老母鸡分给8个人用，也就是1/8 ocpu，总共带宽是480，除以8大概就理论是60mbps，实际50mbps左右。
+近年来太多人被挡在了注册上，导致注册甲骨文云主机变成了一种玄学。本次搬主题介绍的教程不敢保证100%注册成功，但是参考本教程最少将失败的概念降低了一大半。
+我们在申请前，需要准备如下：
+邮箱和手机号基本没什么阻碍，但是信用卡的话就比较玄学了，很多人都是被挡在最后信用卡的验证和申请上。这里先说第一个注意事项
+注意事项1：将信用卡的单日限额、刷卡限额先临时关掉，同时将一些境外支付安全认证之类的服务临时关掉。搬主题用的是交行的外币信用卡，在交行官方APP买单吧里将对应的服务都关掉了。如果不关，导致扣款和认证失败，那么接下来超级容易卡在最后一步。
+做好准备后，前往Oracle Cloud甲骨文永久免费云主机的注册网站：https://signup.cloud.oracle.com/
+这个时候出现如下界面，就可以开始申请注册了。
+注意事项2：不要挂代理，不要挂代理，不要挂代理。重要的事情说三遍！和正常上网一样即可。
+在右边我们需要先填写账户信息。这里我们需要选择国家为：中国，姓氏和名字按真实填写。邮箱的话按前面说的即可。最后勾选验证框。
+注意事项3：姓名需要填写自己的名字的拼音，如果三个字的中间注意要空格！如果是乱填资料只会出现注册失败！另外，这个姓名需要和信用卡的名字保持一致！！！
+
接下来验证自己的邮箱。点击邮箱里面收到的验证邮件，如下图
+
接下来开始填写其他信息，密码按其规则填就行了。公司名称可以留空。
+账户名一般我们保持默认即可。
+主区域的选择：主区域只能选择一次，也就是选了后，只能在这个区域内开相应的主机。
+附甲骨文机房地区列表
+注意事项4：很多人喜欢注册韩国首尔、春川、日本东京等，离得近，延迟也低。但是首尔和东京注册的国人人非常多，极容易出现通不过的情况，建议选择一些冷门区域。比如美西的圣何塞，德国法兰克福，或者觉得自己运气还好的话可以选择韩国春川。这里搬主题之前选择的是首尔，结果第一次失败，第二次选择的是圣何塞。
+
接下来填写相应的地址信息，这里需要填写自己的真实地址
+地址行共分为3行，建议全部填满。
+比如广东省广州市天河区中山大道5号，
+那么拼音直接简单粗暴的填写：guang dong sheng guang zhou shi tian he qu zhong shan da dao 5 hao，
+然后将这些拼音分别填到3个地址行分钟，比如第一行填省，第二行填市，第三行填剩下的地址。
+注意事项5：地址中的拼音，必须有空格，不要一堆乱码连着写，注意留出空格！这个地址和自己的信用卡的账单地址保持一致！不清楚自己的信用卡账单地址的，自己去自己的信用卡APP上查找。
+
接下来进行电话的验证，这里填自己的手机号就行，不要填自己网上搜索的什么虚拟解码的号码，毕竟那个解码不懂被N多人注册过。
+
如果前面注册没问题，那么接下来就是正常的手机接收验证码的时候，如下图，自己手机会收到类似的验证码。
+
填写好验证码后，自己的电话验证就通过了，接下来就是最后最关键的一步，验证付款方式，如下图，点击添加付款验证方式。
+
这个时候会弹出一个框，即填写信用卡的，如下图
+
这里要填写自己的信用卡的信息，因为前面填写了，这里直接默认和前面的信息一致。
+如果前面都按搬主题的要求填写的话，这里不用进行改动。
+
我们需要根据自己的信用卡的类型进行填写相应的信息。
+包括卡片类型，是Visa还是MasterCard等，然后填写卡片号码，过期日期和年份及CVN码。
+
如果信用卡验证没问题的话，会出现类型下面的图。一般信用卡中心会打电话给自己说自己是不是在甲骨文网站进行消费，答复说是的就行了。
+
卡片验证通过后，勾选协议，点击开始我的免费试用即可。
+
点击登录，输入前面注册填写的邮箱及密码即可，登录成功的页面如下：
+
再过不久，官方就送出了400新加坡币的邮件。
+
以上就是2022年最新申请Oracle Cloud甲骨文永久免费云主机图文教程，并分享了申请的注意事项。有兴趣的小伙伴可以根据本教程去申请。
+点击开始我的免费试用后然后不能通过，很多人卡在了这一步。
+提示1：无法完成您的注册。常见注册错误有：(a) 使用的是预付卡。Oracle 仅接受信用卡和借记卡；(b) 有意或无意遮挡了人员地点或身份信息；(c) 输入的账户信息不完整或不准确。如果您出现了上述情况，请重试。否则，请联系 Oracle 客户服务。
+解释：一般这种情况是扣款失败和信息不对。扣款失败也就是搬主题说到的先去检查有没有关闭信用卡的境外支付安全验证什么的服务，确保扣款成功。信息不对的就是前面的信息是否真实，不要乱填相关信息。
+提示2：您的信用卡已被拒绝
+解释：很多人遇到这一步就觉得是不是直接没希望了，卡片的问题。其实不是的，如果自己的信用卡确实符合外币卡，也关闭了相关境外支付验证的服务，之前也没有乱用，那么一般这种情况是半小时内申请的次数过多，可以等待几个小时以后再去申请。
+如果以上都正常，实际上点击点击开始我的免费试用后，页面会出现正在创建账户的提示。创建完成后，自己的邮箱会收到成功的提示，如下图。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 1.启用插件
+RabbitMQ安装默认不会启用MQTT插件,执行如下命令启用插件
+
+ rabbitmq-plugins enable rabbitmq_mqtt
+rabbitmq-plugins list
+2.配置权限
+MQTT插件默认允许匿名访问，但不建议。
添加用户。 添加一个用户名和密码都是 “admin”的用户
rabbitmqctl add_user admin admin
+设置用户读写权限
+rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"
+rabbitmqctl set_user_tags admin management
+3.添加队列,绑定Exchange和Queues
+插件基于exchanges 和 queues实现。也就是 MQTT消息是通过Exchange路由到相应的Queue中。
+当Mqtt消息发布到MQTT topics时，会使用topic 类型的exchange (默认为amq.topic) 。订阅者通过队列（queues）获取Mqtt消息。
+默认情况下，如果Queue不存在，会自动创建一个Auto-Delete类型的队列。
+MQTT主题使用(“/“) 分隔；而AMQP 0-9-1使用点(“.”) 分隔。插件可以在不同协议之间转换，例如将“cities/london”转换成“cities.london”
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 
你可能听说过Reddit，它是一个拥有数亿用户的社交媒体平台，也是互联网上最大的内容聚合网站之一。但你可能不知道的是，Reddit还是一个隐藏的AI教育宝库，里面有无数的AI相关的subreddit（即主题论坛），涵盖了从基础知识到前沿技术，从理论研究到实践应用，从艺术创作到未来展望的各个方面。
+如果你想学习AI，或者提升你的AI技能，或者寻找AI灵感，或者和AI爱好者交流，那么Reddit是一个不可错过的平台。但是，Reddit上的AI资源如此丰富，以至于很多人不知道从哪里开始，或者怎么找到最适合自己的subreddit。因此，我在这里为你推荐9个最佳的AI相关的subreddit，让你能够快速地了解和掌握AI的精髓！
+这是一个专门讨论ChatGPT提示、工作流程和用例的subreddit。ChatGPT是一个基于OpenAI GPT-3模型的聊天机器人平台，它可以根据用户输入的提示（即文本指令）生成各种类型和风格的对话。在这个subreddit里，你可以看到很多人分享他们使用ChatGPT创建的有趣、有用或有启发性的对话示例，也可以学习到如何编写高质量的提示来优化ChatGPT的输出效果。如果你对聊天机器人感兴趣，或者想要利用ChatGPT来完成一些特定的任务（比如写作、教育、娱乐等），那么这个subreddit绝对值得一看。
+ +这是一个展示Midjourney AI图像生成工具的艺术作品（以及使用的提示）的subreddit。Midjourney是一个基于OpenAI DALL•E模型的图像生成平台，它可以根据用户输入的文本描述生成相应的图像。在这个subreddit里，你可以欣赏到很多人使用Midjourney创造出来的惊艳、奇妙或搞笑的图像作品，也可以学习到如何用简单或复杂的文本描述来激发Midjourney的想象力。如果你对AI图像生成感兴趣，或者想要利用Midjourney来创造一些独特或有趣的图像，那么这个subreddit绝对值得一看。
+ +这是一个专门为ChatGPT编写高级、精细化提示（即文本指令）的社区。在这个subreddit里，你可以看到很多人展示他们为ChatGPT设计的精妙、复杂或有创意的提示，以及由这些提示生成出来的高质量、高逼真或高趣味的对话。在这个subreddit里，你可以学习到如何利用ChatGPT的各种功能和参数来控制和调整对话的内容、风格和形式，也可以向其他人寻求帮助或反馈，或者参与一些有趣的挑战或比赛。如果你想要提高你的ChatGPT提示编写技巧，或者想要看看别人是如何利用ChatGPT的强大能力来创造出各种各样的对话，那么这个subreddit绝对值得一看。
+ +这是一个展示Stable Diffusion文本到图像AI模型的照片、视频和教程的subreddit。Stable Diffusion是一个基于Diffusion模型的图像生成平台，它可以根据用户输入的文本描述生成相应的图像，并且可以实时地调整图像的细节和风格。在这个subreddit里，你可以看到很多人使用Stable Diffusion创造出来的精美、逼真或有趣的图像作品，也可以学习到如何用不同的文本描述来控制和调整图像的生成过程。如果你对AI图像生成感兴趣，或者想要利用Stable Diffusion来创造一些高质量或有个性的图像，那么这个subreddit绝对值得一看。
+ +这是一个关于未来当AI超越人类智能时的令人着迷的讨论subreddit。Singularity（即奇点）是一个假设的未来时刻，当AI达到或超过人类智能水平时，将会引发一系列不可预测或不可控制的变化。在这个subreddit里，你可以看到很多人分享他们对于Singularity的看法、预测、担忧或期待，也可以参与到一些关于Singularity可能带来的影响、挑战、机遇或道德问题的热烈讨论中。如果你对AI未来感兴趣，或者想要了解不同人对于Singularity的观点和态度，那么这个subreddit绝对值得一看。
+ +这是一个关于AI技术主题学习的最佳社区subreddit。Machine Learning（即机器学习）是AI领域中最核心也最活跃的分支之一，它涉及到如何让计算机通过数据和算法来自动地学习和改进。在这个subreddit里，你可以看到很多人分享他们在机器学习方面的研究成果、项目经验、学习资源、技术问题或新闻动态，也可以向其他人寻求帮助或建议，或者参与一些关于机器学习最新进展或趋势的讨论。如果你想要学习机器学习，或者提升你的机器学习技能，或者了解机器学习领域的最新动态，那么这个subreddit绝对值得一看。
+ +这是Reddit上关于AI新闻、工具和创作的主要subreddit。Artificial（即人工智能）是一个涵盖了计算机科学、数学、心理学、哲学等多个学科的综合领域，它旨在让计算机能够模拟或扩展人类的智能。在这个subreddit里，你可以看到很多人分享他们关于AI的最新新闻、最佳工具、最酷创作或最有趣故事，也可以参与到一些关于AI的一般性或专业性的讨论中。如果你想要了解AI的各个方面，或者想要发现AI的各种可能性，或者想要和AI爱好者交流，那么这个subreddit绝对值得一看。
+ +这是一个展示OpenAI DALLE•2工具生成的图像和提示的subreddit。DALLE•2是OpenAI最新推出的文本到图像AI模型，它可以根据用户输入的文本描述生成相应的图像，并且可以实现多模态（即文本和图像之间的互动）的生成。在这个subreddit里，你可以看到很多人使用DALLE•2创造出来的令人惊叹、有趣或奇怪的图像作品，也可以学习到如何用不同的文本描述来激发DALLE•2的创造力。如果你对AI图像生成感兴趣，或者想要利用DALLE•2来创造一些新颖或有意思的图像，那么这个subreddit绝对值得一看。
+ +这是一个专门讨论AI领域领先公司OpenAI的新闻和更新的社区subreddit。OpenAI是一个由伊隆·马斯克等人创立的非营利性研究机构，它致力于创建和推广友善的人工智能，并且为所有人提供公平和开放的访问。在这个subreddit里，你可以看到很多人分享他们关于OpenAI的最新消息、最新产品、最新研究或最新活动，也可以参与到一些关于OpenAI的愿景、目标、挑战或贡献的讨论中。如果你对OpenAI感兴趣，或者想要了解OpenAI在AI领域所做的工作和影响，那么这个subreddit绝对值得一看。
+ +以上就是我为你推荐的9个最佳的AI相关的subreddit，希望你能够从中受益，并且享受Reddit上丰富而有趣的AI教育资源。如果你喜欢这篇文章，请给我点赞、评论或转发，让更多人知道Reddit是免费的、世界一流的AI教育平台！谢谢！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 报错：[navicat premium] [IM002] [Microsoft][ODBC 驱动程序管理器] 未发现数据源名称并且未指定默认驱动程序
+进入 Navicat 的安装目录，找到下边的文件，点击安装，重新打开数据库即可.(这个双击可能会提示需要先安装另外一个文件,访问提示框中出现的网址下载文件安装即可)
+
+ 微信支付
+
+ 支付宝支付
+
+
+ **注意: ** acme.sh默认自带续期功能,前提是不要自己调整证书路径!
+免费证书都是3个月到期,需要手动续期,所以写了一个监控加自动续期的服务,有兴趣的可以试一试
+
+ import ssl
+import socket
+import requests
+import schedule
+import time
+from datetime import datetime
+import subprocess
+
+# Telegram Bot设置
+TELEGRAM_TOKEN = ''
+TELEGRAM_CHAT_ID = ''
+
+# 储存域名列表
+domains = [
+ 'tool.wangwangit.com'
+]
+
+def send_telegram_message(message):
+ url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
+ data = {
+ "chat_id": TELEGRAM_CHAT_ID,
+ "text": message
+ }
+ requests.post(url, data=data)
+
+def get_ssl_expiry_date_from_shell(hostname, port=443):
+ cmd = f"echo | openssl s_client -servername {hostname} -connect \"{hostname}:{port}\" 2>/dev/null | openssl x509 -noout -dates"
+ process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ out, err = process.communicate()
+ if process.returncode != 0:
+ return f"Error executing command: {err.decode().strip()}"
+ return out.decode().strip()
+
+def renew_ssl(domain):
+ subprocess.run(['nginx', '-s', 'stop'])
+ time.sleep(10) # 等待nginx停止
+ subprocess.run(['acme.sh', '--issue', '-d', domain, '--standalone', '--force'])
+ time.sleep(30) # 等待证书申请
+ subprocess.run(['nginx'])
+ subprocess.run(['nginx', '-s', 'reload'])
+ time.sleep(10) # 等待nginx重启
+
+def format_expiry_date(date_str):
+ try:
+ # 提取日期字符串并转换为datetime对象
+ expiry_date = datetime.strptime(date_str, '%b %d %H:%M:%S %Y %Z')
+ # 返回格式化的日期字符串
+ return expiry_date.strftime('%Y-%m-%d %H:%M:%S')
+ except ValueError:
+ return date_str # 返回原始字符串，如果格式不匹配
+
+def check_all_domains():
+ messages = []
+ for domain in domains:
+ ssl_dates = get_ssl_expiry_date_from_shell(domain)
+ expiry_date_line = ssl_dates.split('\n')[1] if 'notAfter' in ssl_dates else ssl_dates
+ expiry_date = expiry_date_line.split('=')[1] if 'notAfter' in expiry_date_line else "Unknown"
+ formatted_date = format_expiry_date(expiry_date)
+ if "Error" in ssl_dates or "Unknown" in expiry_date:
+ message = f"{domain} SSL证书检查失败：{formatted_date}，请手动检查。"
+ messages.append(message)
+ else:
+ message = f"{domain} SSL证书状态正常，有效期至 {formatted_date}。"
+ messages.append(message)
+
+ # 将所有消息发送到Telegram
+ send_telegram_message("\n".join(messages))
+
+# 设置定时任务
+schedule.every().day.at("10:00").do(check_all_domains)
+
+# 运行定时任务
+while True:
+ schedule.run_pending()
+ time.sleep(1)
+运行情况如下:
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 命令:
+
命令:
+选择模型,开启会话之后,需要@才能对话!
+
地址: Claude in Slack \ Anthropic
+这款就不用多介绍了!大家看我以前的文章有说明!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 因为spring-boot-starter-parent中已经定义了常用依赖匹配的版本号.
+按住Ctrl,点击spring-boot-starter-parent的版本号
+
可见pom文件中的parent是spring-boot-dependencies,然后再次按住Ctrl,点击版本号
+
我们会发现这个pom中维护了一大堆依赖的版本号
+
在我们做web项目时,除了上面的parent外,还会引入spring-boot-starter-web,而在这个依赖中,则定义了web项目需要的jar依赖.
+
依据不同的使用场景,spring官方也提供了不同的starter封装
+
我们进入查看启动类上的SpringBootApplication注解
+
+ @Target({ElementType.TYPE}) // 注解适用范围,Type表示注解可以描述类,接口,注解或枚举类
+@Retention(RetentionPolicy.RUNTIME) // 表示注解的生命周期,Runtime运行时
+@Documented // 表示注解可以记录在javadoc中
+@Inherited // 表示可以被子类继承该注解
+@SpringBootConfiguration // 表明该类为配置类
+@EnableAutoConfiguration // 启动自动配置功能
+@ComponentScan( // 包扫描器
+ excludeFilters = {@Filter(
+ type = FilterType.CUSTOM,
+ classes = {TypeExcludeFilter.class}
+), @Filter(
+ type = FilterType.CUSTOM,
+ classes = {AutoConfigurationExcludeFilter.class}
+)}
+)
+public @interface SpringBootApplication {
+}
+声明当前类为配置类
+
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Configuration
+public @interface SpringBootConfiguration {
+ @AliasFor(
+ annotation = Configuration.class
+ )
+ boolean proxyBeanMethods() default true;
+}
+表示开启自动配置功能,也是实现自动化配置的注解
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@AutoConfigurationPackage // 自动配置包
+@Import({AutoConfigurationImportSelector.class}) // 自动配置类扫描导入
+public @interface EnableAutoConfiguration {
+ String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
+
+ Class<?>[] exclude() default {};
+
+ String[] excludeName() default {};
+}
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Import({AutoConfigurationPackages.Registrar.class}) //导入Registrar中注册的组件
+public @interface AutoConfigurationPackage {
+ String[] basePackages() default {};
+
+ Class<?>[] basePackageClasses() default {};
+}
+我们继续查看Registrar中的实现
+ static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
+ Registrar() {
+ }
+
+ public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
+ AutoConfigurationPackages.register(registry, (String[])(new PackageImports(metadata)).getPackageNames().toArray(new String[0]));
+ }
+
+ public Set<Object> determineImports(AnnotationMetadata metadata) {
+ return Collections.singleton(new PackageImports(metadata));
+ }
+ }
+可以发现其中有一个registerBeanDefinitions方法,就是将主程序类所在包及所有子包下的组件扫描的Spring容器中
+将AutoConfigurationImportSelector类导入到容器中,这个类可以将所有符合条件的@Configuration注解类配置加载到Spring的IOC容器中.
+ public String[] selectImports(AnnotationMetadata annotationMetadata) {
+ if (!this.isEnabled(annotationMetadata)) {
+ return NO_IMPORTS;
+ } else {
+ AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
+ return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
+ }
+ }
+深入loadMetadata方法
+ static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
+ // 需要加载的配置类的类路径
+ return loadMetadata(classLoader, "META-INF/spring-autoconfigure-metadata.properties");
+ }
+
+ static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
+ try {
+ // 读取spring-autoconfigure-metadata.properties信息生成的url
+ Enumeration<URL> urls = classLoader != null ? classLoader.getResources(path) : ClassLoader.getSystemResources(path);
+ Properties properties = new Properties();
+
+ // 解析urls枚举对象中的信息,封装成properties对象并加载
+ while(urls.hasMoreElements()) {
+ properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource((URL)urls.nextElement())));
+ }
+ // 根据封装好的properties对象生成AutoConfigurationMetada对象
+ return loadMetadata(properties);
+ } catch (IOException var4) {
+ throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", var4);
+ }
+ }
+深入getCandidateConfigurations方法
+ protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
+ /**
+ * getSpringFactoriesLoaderFactoryClass 返回EnableAutoConfiguration.class
+ * getBeanClassLoader 返回beanClassLoader
+ */
+ List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
+ Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
+ return configurations;
+ }
+
+ protected Class<?> getSpringFactoriesLoaderFactoryClass() {
+ return EnableAutoConfiguration.class;
+ }
+
+ protected ClassLoader getBeanClassLoader() {
+ return this.beanClassLoader;
+ }
+继续点开loadFactoryNames方法
+public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
+ String factoryClassName = factoryClass.getName();
+ return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
+ }
+
+ private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
+ MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
+ if (result != null) {
+ return result;
+ } else {
+ try {
+ // 如果类加载器不为空,则加载spring.factories文件,封装其中Configuration文件为Enumeration
+ Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
+ MultiValueMap<String, String> result = new LinkedMultiValueMap();
+ // 循环Enumeration对象,封装为Properties对象
+ while(urls.hasMoreElements()) {
+ URL url = (URL)urls.nextElement();
+ UrlResource resource = new UrlResource(url);
+ Properties properties = PropertiesLoaderUtils.loadProperties(resource);
+ Iterator var6 = properties.entrySet().iterator();
+
+ while(var6.hasNext()) {
+ Map.Entry<?, ?> entry = (Map.Entry)var6.next();
+ String factoryClassName = ((String)entry.getKey()).trim();
+ String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
+ int var10 = var9.length;
+
+ for(int var11 = 0; var11 < var10; ++var11) {
+ String factoryName = var9[var11];
+ result.add(factoryClassName, factoryName.trim());
+ }
+ }
+ }
+
+ cache.put(classLoader, result);
+ return result;
+ } catch (IOException var13) {
+ throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
+ }
+ }
+ }
+实际上,加载的就是这个路径下的配置文件
+
以web项目为例,在项目中加入了Web环境依赖启动器,对应的WebMvcAutoConfiguration就会生效,打开这个配置类,就会发现该类通过全注解的方式对Spring所需环境进行了默认配置.
+总结
+springboot底层自动配置的步骤是:
+1.springboot应用启动
+2.@SpringBootApplication起作用
+3.@EnableAutoConfiguration
+4.@AutoConfigurationPackage:扫描加载启动类同级及子级目录下的配置类
+5.@Import(AutoConfigurationImportSelector.class):加载classpath上jar中的META-INF/spring.factories文件中指定的配置类
+扫描启动类下面的bean对象
+|- @SpringBootConfiguration
+ |- @Configuration //通过javaConfig的方式添加组件到IOC容器中
+|- @EnableAutoConfiguration
+ |- @AutoConfigurationPackage //自动配置包,与@ComponmentScan扫描到的添加到IOC中
+ |- @Import(AutoConfigurationImportSelector.class) // 扫描META-INF/spring.factories中指定的bean到IOC容器中
+|- @ComponentScan //包扫描
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-autoconfigure</artifactId>
+ <version>2.2.2.RELEASE</version>
+</dependency>
+@EnableConfigurationProperties(SimpleBean.class)
+@ConfigurationProperties(prefix = "simple")
+@Data
+public class SimpleBean {
+
+ private int id;
+
+ private String name;
+
+}
+@Configuration
+public class MyAutoConfiguration {
+
+ static {
+ System.out.println("MyAutoConfiguration init....");
+ }
+
+ @Bean
+ public SimpleBean simpleBean() {
+ return new SimpleBean();
+ }
+
+}
+在resources下创建/META-INF/spring.factories文件,指定配置类全路径
+
在测试包中引入自定义starter
+ <dependency>
+ <groupId>org.example</groupId>
+ <artifactId>my-spring-boot-starter</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ </dependency>
+在配置文件application.properties中加入前缀配置
+simple.id=1
+simple.name=test
+编写测试方法
+ @Autowired
+ private SimpleBean simpleBean;
+
+ @Test
+ public void testStarter(){
+ System.out.println(simpleBean);
+ }
+我们从启动类开始断点查看程序执行步骤,首先是调用了SpringApplication的run方法.
+在run方法中,主要做了两个操作,一个是SpringApplication的初始化,以及调用run()启动项目
+(new SpringApplication(primarySources)).run(args);
+public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
+ this.sources = new LinkedHashSet();
+ this.bannerMode = Mode.CONSOLE;
+ this.logStartupInfo = true;
+ this.addCommandLineProperties = true;
+ this.addConversionService = true;
+ this.headless = true;
+ this.registerShutdownHook = true;
+ this.additionalProfiles = new HashSet();
+ this.isCustomEnvironment = false;
+ this.lazyInitialization = false;
+ this.resourceLoader = resourceLoader;
+ Assert.notNull(primarySources, "PrimarySources must not be null");
+ //把项目启动类.class设置为属性存储起来
+ this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
+ //判断当前WebApplicationType类型
+ this.webApplicationType = WebApplicationType.deduceFromClasspath();
+ //设置初始化器,最后会调用这些初始化器
+ this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
+ //设置监听器
+ this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
+ //用于推断并设置项目main()方法启动的主程序启动类
+ this.mainApplicationClass = this.deduceMainApplicationClass();
+}
+ public ConfigurableApplicationContext run(String... args) {
+ StopWatch stopWatch = new StopWatch();
+ stopWatch.start();
+ ConfigurableApplicationContext context = null;
+ Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
+ this.configureHeadlessProperty();
+ // 1.获取监听器并启动
+ SpringApplicationRunListeners listeners = this.getRunListeners(args);
+ listeners.starting();
+
+ Collection exceptionReporters;
+ try {
+ ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
+ // 2.根据SpringApplicationRunListeners以及参数来准备环境
+ ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
+ this.configureIgnoreBeanInfo(environment);
+ // 准备Banner打印器,就是console中输出的艺术字体
+ Banner printedBanner = this.printBanner(environment);
+ // 3.创建Spring容器
+ context = this.createApplicationContext();
+ exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
+ // 4.Spring容器前置处理
+ this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
+ // 5.刷新容器
+ this.refreshContext(context);
+ // 6.容器刷新后置处理
+ this.afterRefresh(context, applicationArguments);
+ stopWatch.stop();
+ if (this.logStartupInfo) {
+ (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
+ }
+ // 7.发出结束执行的事件
+ listeners.started(context);
+ // 返回容器
+ this.callRunners(context, applicationArguments);
+ } catch (Throwable var10) {
+ this.handleRunFailure(context, var10, exceptionReporters, listeners);
+ throw new IllegalStateException(var10);
+ }
+
+ try {
+ listeners.running(context);
+ return context;
+ } catch (Throwable var9) {
+ this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
+ throw new IllegalStateException(var9);
+ }
+ }
+
1.启动类使用@EnableCaching注解
+@SpringBootApplication
+@EnableCaching // 开启SpringBoot基于注解的缓存管理支持
+public class Springboot01DemoApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(Springboot01DemoApplication.class, args);
+ }
+
+}
+2.查询方法添加@Cacheable注解配置缓存
+// 根据id查询实体类
+@Cacheable(cacheNames = "a")
+public A findById(String id){
+ A a = dao.findById(id)
+ return a;
+}
+springboot默认使用的是SimpleCacheConfiguration配置类,用CurrentMap当作底层数据结构进行数据缓存
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-data-redis</artifactId>
+ </dependency>
+当我们加入此依赖后,Springboot会使用RedisCacheConfiguration当作生效的自动配置类,容器使用的缓存管理器是RedisCacheManager类,创建的Cache是RedisCache
+spring.redis.host=127.0.0.1
+spring.redis.port=6379
+spring.redis.password=
+对缓存的实体类实现Serializable,添加序列化ID
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 
分布式微服务架构中，服务注册中⼼⽤于存储服务提供者地址信息、服务发布相关 的属性信息，消费者通过主动查询和被动通知的⽅式获取服务提供者的地址信息， ⽽不再需要通过硬编码⽅式得到提供者的地址信息。消费者只需要知道当前系统发 布了那些服务，⽽不需要知道服务具体存在于什么位置，这就是透明化路由。
+pull模式: 服务消费者可以主动拉取可用的服务提供者清单
+push模式: 服务消费者订阅服务,当服务提供者有变化时,注册中心也会主动推送更新后的服务清单给消费者
+注册中心需要完成对服务提供者的健康监控,当发现服务提供者失效时需要及时剔除
+ Zookeeper它是⼀个分布式服务框架，是Apache Hadoop 的⼀个⼦项⽬，它主 要是⽤来解决分布式应 ⽤中经常遇到的⼀些数据管理问题，如：统⼀命名服务、状态同步服务、集群管理、分布式应⽤配置项的管理等。
+ Zookeeper本质=存储+监听通知,主要是通过znode监听实现服务注册的,只要服务节点发生变动,就会通知到监听端,另外,Zookeeper有选举机制,保证了可用性,只要有一半以上的选举节点存活即可.
+ 由Netflix开源，并被Pivatal集成到SpringCloud体系中，它是基于 RestfulAPI ⻛格开发的服务注册与发现组件
+ Consul是由HashiCorp基于Go语⾔开发的⽀持多数据中⼼分布式⾼可⽤的服务 发布和注册服务软件， 采⽤Raft算法保证服务的⼀致性，且⽀持健康检查
+ Nacos是⼀个更易于构建云原⽣应⽤的动态服务发现、配置管理和服务管理平 台。简单来说 Nacos 就是 注册中⼼ + 配置中⼼的组合，帮助我们解决微服务开 发必会涉及到的服务注册 与发现，服务配置，服务管理等问题。Nacos 是 Spring Cloud Alibaba 核⼼组件之⼀，负责服务注册与发现，还有配置。
+
P：分区容错性（⼀定的要满⾜的）
+C：数据⼀致性
+A：⾼可⽤
+CAP不可能同时满⾜三个，要么是AP，要么是CP
+
这个是官方的一个描述图
+
SpringBoot启动时,会加载EurekaServerAutoConfiguration配置类
+
针对PeerEurekaNodes是如何实现节点更新的呢?可以查看类中的start方法
+
上面的updatePeerEurekaNodes是什么时候执行的呢?
+
可以看到在构建DefaultEurekaServerContext对象时,会执行start方法
+
在配置类中,我们还需要关注如下两个bea:
+
查看contextInitialized中都初始化了哪些内容?
+
继续查看initEurekaServerContext中都做了啥?
+
查看syncUp方法中,如何实现的注册信息同步?
+
再看一看同步过来的信息是如何注册到EurekaServer中的
+
我们再看一下如何实现的服务剔除
+com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#openForTraffic
+
进入postInit方法查看
+
在第一步中,我们看到自动配置类中注册了jerseyFilterRegistration
+
注入Jersey的细节
+
具体要扫描那些包呢?
+
查看这些包下包含哪些接口服务
+
这些就是使⽤Jersey发布的供Eureka Client调⽤的Restful⻛格服务接⼝（完成服务 注册、⼼跳续约等接⼝
+查看ApplicationResource类的addInstance()⽅法中代码
+
点击register方法:注册服务信息并且同步到其他Eureka节点,查看实现
+
点击super.register方法:实例信息存储到注册表是一个ConcurrentHashMap.查看实现
+
+ /**
+* Registers a new instance with a given duration.
+*
+* @see
+com.netflix.eureka.lease.LeaseManager#register(java.lang.Object,
+int, boolean)
+*/
+public void register(InstanceInfo registrant, int leaseDuration,
+boolean isReplication) {
+ try {
+ read.lock(); //读锁
+
+ // registry是保存所有应⽤实例信息的Map：
+ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>>
+ // 从registry中获取当前appName的所有实例信息
+Map<String, Lease<InstanceInfo>> gMap =
+registry.get(registrant.getAppName());
+
+ REGISTER.increment(isReplication); //注册统计+1
+
+ // 如果当前appName实例信息为空，新建Map
+ if (gMap == null) {
+ final ConcurrentHashMap<String, Lease<InstanceInfo>>
+gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
+ gMap = registry.putIfAbsent(registrant.getAppName(),
+gNewMap);
+ if (gMap == null) {
+ gMap = gNewMap;
+ }
+ }
+
+ // 获取实例的Lease租约信息
+ Lease<InstanceInfo> existingLease =
+gMap.get(registrant.getId());
+ // Retain the last dirty timestamp without overwriting it,
+if there is already a lease
+ // 如果已经有租约，则保留最后⼀个脏时间戳⽽不覆盖它
+ // （⽐较当前请求实例租约 和 已有租约 的LastDirtyTimestamp，选择靠
+后的）
+ if (existingLease != null && (existingLease.getHolder() !=
+null)) {
+ Long existingLastDirtyTimestamp =
+existingLease.getHolder().getLastDirtyTimestamp();
+ Long registrationLastDirtyTimestamp =
+registrant.getLastDirtyTimestamp();
+ logger.debug("Existing lease found (existing={},
+provided={}", existingLastDirtyTimestamp,
+registrationLastDirtyTimestamp);
+ if (existingLastDirtyTimestamp >
+registrationLastDirtyTimestamp) {
+ logger.warn("There is an existing lease and the
+existing lease's dirty timestamp {} is greater" +
+ " than the one that is being registered
+{}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
+ logger.warn("Using the existing instanceInfo
+instead of the new instanceInfo as the registrant");
+ registrant = existingLease.getHolder();
+}
+ }
+ else {
+ // The lease does not exist and hence it is a new
+registration
+ // 如果之前不存在实例的租约，说明是新实例注册
+ // expectedNumberOfRenewsPerMin期待的每分钟续约数+2（因为
+30s⼀个）
+ // 并更新numberOfRenewsPerMinThreshold每分钟续约阀值（85%）
+ synchronized (lock) {
+ if (this.expectedNumberOfRenewsPerMin > 0) {
+ // Since the client wants to cancel it, reduce
+the threshold
+ // (1
+ // for 30 seconds, 2 for a minute)
+ this.expectedNumberOfRenewsPerMin =
+this.expectedNumberOfRenewsPerMin + 2;
+ this.numberOfRenewsPerMinThreshold =
+ (int)
+(this.expectedNumberOfRenewsPerMin *
+serverConfig.getRenewalPercentThreshold());
+ }
+ }
+ logger.debug("No previous lease information found; it
+is new registration");
+ }
+
+ Lease<InstanceInfo> lease = new Lease<InstanceInfo>
+(registrant, leaseDuration);
+ if (existingLease != null) {
+
+lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp())
+;
+ }
+ gMap.put(registrant.getId(), lease); //当前实例信息放到维护注册
+信息的Map
+
+ // 同步维护最近注册队列
+ synchronized (recentRegisteredQueue) {
+ recentRegisteredQueue.add(new Pair<Long, String>(
+ System.currentTimeMillis(),
+registrant.getAppName() + "(" +
+registrant.getId() + ")"));
+ }
+
+ // This is where the initial state transfer of overridden
+status happens
+ // 如果当前实例已经维护了OverriddenStatus，将其也放到此Eureka
+Server的overriddenInstanceStatusMap中
+ if
+(!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus()))
+{
+ logger.debug("Found overridden status {} for instance
+{}. Checking to see if needs to be add to the "
+ + "overrides",
+registrant.getOverriddenStatus(), registrant.getId());
+ if
+(!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
+ logger.info("Not found overridden id {} and hence
+adding it", registrant.getId());
+ overriddenInstanceStatusMap.put(registrant.getId(),
+registrant.getOverriddenStatus());
+ }
+ }
+ InstanceStatus overriddenStatusFromMap =
+overriddenInstanceStatusMap.get(registrant.getId());
+ if (overriddenStatusFromMap != null) {
+ logger.info("Storing overridden status {} from map",
+overriddenStatusFromMap);
+
+registrant.setOverriddenStatus(overriddenStatusFromMap);
+ }
+ // Set the status based on the overridden status rules
+ // 根据overridden status规则，设置状态
+ InstanceStatus overriddenInstanceStatus
+ = getOverriddenInstanceStatus(registrant,
+existingLease, isReplication);
+ registrant.setStatusWithoutDirty(overriddenInstanceStatus);
+ // If the lease is registered with UP status, set lease
+service up timestamp
+ // 如果租约以UP状态注册，设置租赁服务时间戳
+if (InstanceStatus.UP.equals(registrant.getStatus())) {
+ lease.serviceUp();
+ }
+
+ registrant.setActionType(ActionType.ADDED); //ActionType为
+ADD
+ recentlyChangedQueue.add(new RecentlyChangedItem(lease));
+//维护recentlyChangedQueue
+ registrant.setLastUpdatedTimestamp(); //更新最后更新时间
+
+ // 使当前应⽤的ResponseCache失效
+ invalidateCache(registrant.getAppName(),
+registrant.getVIPAddress(), registrant.getSecureVipAddress());
+ logger.info("Registered instance {}/{} with status {}
+(replication={})",
+ registrant.getAppName(), registrant.getId(),
+registrant.getStatus(), isReplication);
+ } finally {
+ read.unlock(); //读锁
+ }
+}
+我们再看一下如何复制的对等节点,PeerAwareInstanceRegistryImpl#replicateToPeers() ：复制到Eureka对等节点
+private void replicateToPeers(Action action, String appName, String
+id,
+ InstanceInfo info /* optional */,
+ InstanceStatus newStatus /* optional
+*/, boolean isReplication) {
+ Stopwatch tracer = action.getTimer().start();
+ try {
+ // 如果是复制操作（针对当前节点，false）
+ if (isReplication) {
+ numberOfReplicationsLastMin.increment();
+ }
+ // 如果它已经是复制，请不要再次复制，直接return
+ if (peerEurekaNodes == Collections.EMPTY_LIST ||
+isReplication) {
+ return;
+ }
+ // 遍历集群所有节点（除当前节点外）
+ for (final PeerEurekaNode node :
+peerEurekaNodes.getPeerEurekaNodes()) {
+ // If the url represents this host, do not replicate to
+yourself.
+ if (peerEurekaNodes.isThisMyUrl(node.getServiceUrl()))
+{
+ continue;
+ }
+ // 复制Instance实例操作到某个node节点
+ replicateInstanceActionsToPeers(action, appName, id,
+info, newStatus, node);
+ }
+ }
+ finally {
+ tracer.stop();
+ }
+}
+查看PeerAwareInstanceRegistryImpl#replicateInstanceActionsToPeers的具体实现
+
InstanceResource的renewLease⽅法中完成客户端的⼼跳（续约）处理，关键代码：registry.renew(app.getName(), id, isFromReplicaNode)
+
replicateInstanceActionsToPeers() 复制Instance实例操作到其它节点
+private void replicateInstanceActionsToPeers(Action action, String
+appName,
+ String id,
+InstanceInfo info, InstanceStatus newStatus,
+ PeerEurekaNode node) {
+ try {
+ InstanceInfo infoFromRegistry = null;
+ CurrentRequestVersion.set(Version.V2);
+ switch (action) {
+case Cancel: //取消
+ node.cancel(appName, id);
+ break;
+ case Heartbeat: //⼼跳
+ InstanceStatus overriddenStatus =
+overriddenInstanceStatusMap.get(id);
+ infoFromRegistry = getInstanceByAppAndId(appName,
+id, false);
+ node.heartbeat(appName, id, infoFromRegistry,
+overriddenStatus, false);
+ break;
+ case Register: //注册
+ node.register(info);
+ break;
+ case StatusUpdate: //状态更新
+ infoFromRegistry = getInstanceByAppAndId(appName,
+id, false);
+ node.statusUpdate(appName, id, newStatus,
+infoFromRegistry);
+ break;
+ case DeleteStatusOverride: //删除OverrideStatus
+ infoFromRegistry = getInstanceByAppAndId(appName,
+id, false);
+ node.deleteStatusOverride(appName, id,
+infoFromRegistry);
+ break;
+ }
+ } catch (Throwable t) {
+ logger.error("Cannot replicate information to {} for action
+{}", node.getServiceUrl(), action.name(), t);
+ }
+}
+SpringBoot启动时,会加载EurekaClientAutoConfiguration配置类
+
分析EurekaClientAutoConfiguration类的注解
+
1.读取配置文件
+
2.启动时从EurekaServer获取服务实例信息
+
观察父类DiscoveryClient()
+
3.注册自己到EurekaServer中
+
4.开启一些定时任务(心跳,刷新缓存)
+刷新缓存
+
心跳续约
+
查看com.netflix.discovery.DiscoveryClient#shutdown
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 
+ @Bean
+// Ribbon负载均衡
+@LoadBalanced
+public RestTemplate getRestTemplate() {
+ return new RestTemplate();
+}
+Ribbon内置多种负载均衡策略,最顶级接口为:com.netflix.loadbalancer.IRule
+
修改负载均衡策略
+#针对的被调⽤⽅微服务名称,不加就是全局⽣效
+lagou-service-resume:
+ ribbon:
+ NFLoadBalancerRuleClassName:com.netflix.loadbalancer.RandomRule #负载策略调整
+
图中核心是负载均衡管理器LoadBalancer
+上面我们提到了使用Ribbon只需要添加一个**@LoadBalanced**注解,那么这个注解是如何实现的呢?
+
可以看到注释中,提到了LoadBalancerClient这个类,作用是客户端负载均衡
+
接下来我们在看看Ribbon的配置是如何生效的,依旧是根据SpringBoot的自动装配特点,可以查看加载的Configuration类
+
第一处: 注入restTemplate对象到集合待用
+
第二处:注入restTemplate定制器
+
第三处:使⽤定制器给集合中的每⼀个restTemplate对象添加⼀个拦截器
+
通过这三处,我们可以发现添加了注解的RestTemplate对象会被添加⼀个拦截器LoadBalancerInterceptor，该拦截器就是后续拦截请求进⾏负载处理的。
+查看LoadBalancerInterceptor中的intercept方法
+
可以发现最终是交给了LoadBalancerClient进行负载均衡处理,而这个对象在RibbonAutoConfiguration中进行了实例化
+
我们继续看关键的方法loadBalancer.execute如何实现的
+
我们发现代码中通过getLoadBalancer获取了均衡器对象,那么这个是什么时候注入的了?
+可以查看最初的主配置类RibbonAutoConfiguration
+
点开RibbonClientConfiguration,会发现它创建了我们上文说的ribbonRule,ribbonPing
+
我们再回到RibbonLoadBalancerClient的execute方法.查看getServer如何实现的
+
根据上文的阅读,我们可以知道,默认创建的RibbonLoadBalancerClient对象是ZoneAwareLoadBalancer,查看其chooseServer实现
+
来到区域隔离策略的⽗类choose⽅法中com.netflix.loadbalancer.PredicateBasedRule#choose
+
我们再次退回到RibbonLoadBalancerClient的execute方法
+
查看LoadBalancerRequestFactory的createRequest方法
+
继续查看AbstractClientHttpRequest#execute的代码
+
接下来,我们看下chooseServer中的serverList是如何来的
+回到RibbonClientConfiguration
+
继续查看enableAndInitLearnNewServersFeature方法
+
// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+package com.netflix.loadbalancer;
+import com.netflix.client.config.IClientConfig;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+ public class RoundRobinRule extends AbstractLoadBalancerRule {
+ private AtomicInteger nextServerCyclicCounter;
+ private static final boolean AVAILABLE_ONLY_SERVERS = true;
+ private static final boolean ALL_SERVERS = false;
+ private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
+
+ public RoundRobinRule() {
+ this.nextServerCyclicCounter = new AtomicInteger(0);
+ }
+
+ public RoundRobinRule(ILoadBalancer lb) {
+ this();
+ this.setLoadBalancer(lb);
+ }
+
+ // 负载均衡策略类核⼼⽅法
+ public Server choose(ILoadBalancer lb, Object key) {
+ if (lb == null) {
+ log.warn("no load balancer");
+ return null;
+ } else {
+ Server server = null;
+ int count = 0;
+ while (true) {
+ if (server == null && count++ < 10) {
+ // 所有可⽤服务实例列表
+ List<Server> reachableServers = lb.getReachableServers();
+ // 所有服务实例列表
+ List<Server> allServers = lb.getAllServers();
+ int upCount = reachableServers.size();
+ int serverCount = allServers.size();
+ if (upCount != 0 && serverCount != 0) {
+ // 获得⼀个轮询索引
+ int nextServerIndex = this.incrementAndGetModulo(serverCount);
+ // 根据索引取出服务实例对象
+ server = (Server) allServers.get(nextServerIndex);
+ if (server == null) {
+ Thread.yield();
+ } else {
+ // 判断服务可⽤后返回
+ if (server.isAlive() && server.isReadyToServe()) {
+ return server;
+ }
+ server = null;
+ }
+ continue;
+ }
+ log.warn("No up servers available from load balancer:" + lb); return null;
+ } if (count >= 10) {
+ log.warn("No available alive servers after 10 tries from load balancer:" + lb);
+ } return server;
+ }
+ }
+ }
+
+ private int incrementAndGetModulo(int modulo) {
+ int current;
+ int next;
+ do {
+ // 取出上次的计数
+ current = this.nextServerCyclicCounter.get();
+ // 因为是轮询，计数+1之后对总数取模
+ next = (current + 1) % modulo;
+ } while (!this.nextServerCyclicCounter.compareAndSet(current, next));
+ return next;
+ }
+
+ public Server choose(Object key) {
+ return this.choose(this.getLoadBalancer(), key);
+ }
+
+ public void initWithNiwsConfig(IClientConfig clientConfig) {
+ }
+ }
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 在项目体量小的时候,所有的功能都放在一个工程中,并且打包部署在一个Tomcat容器中的架构模式就是单体应用架构.
+
优点:
+缺点:
+为了避免单体架构中的问题,便开始对项目进行模块的垂直划分,基于业务特性做分割,实现业务之间的互不影响.
+
优点:
+缺点:
+在使用垂直应用架构之后,随之而来的问题就是服务之间调用的问题,比如接口协议不统一,无法监控到服务状态,服务的负载均衡处理等.
+这个时候,阿里巴巴开源的Dubbo出现了,一款高性能,轻量级的开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现.
+SOA(Service-Oriented Architecture)架构,即面向服务的架构,根据实际业务,将系统拆分成独立的模块,模块之间通过Dubbo,WebService等技术通信.
+优点:
+缺点:
+
相比SOA架构,粒度更细致,强调组件化,服务化.以及引入了SpringCloud微服务技术.
+
优点:
+缺点:
+同时,微服务也引入了一些新的概念:
+
Spring Cloud是⼀个微服务相关规范，这个规范意图为搭建微服务架构 提供⼀站式服务，采⽤组件（框架）化机制定义⼀系列组件，各类组件针对性的处 理微服务中的特定问题，这些组件共同来构成Spring Cloud微服务技术栈。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 易于理解的 Java Security API；
+简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；
+对角色的简单的鉴权（访问控制），支持细粒度的鉴权；
+支持一级缓存，以提升应用程序的性能；
+内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境； 异构客户端会话访问；
+非常简单的加密 API；
+不跟任何的框架或者容器捆绑，可以独立运行。
+
+ OpenID是Authentication,是网站对用户进行认证，让网站知道“你是你所声称的URL的属主”,例如使用身份证可以证明自己的身份.
+OAuth是Authorization,其实并不包括认证，只不过“只有认证成功的人才能进行授权”,例如某些网站可以直接使用QQ,微信免注册登录授权.但是这样会授予你QQ,微信的使用权限. 如你要证明房子是自己的,只要出示房产证即可.而若是你给钥匙给别人开门.则授予了别人进入房子的权限.
+1.认证:用户登录,解决的是”你是谁”
+2.授权:判断用户拥有什么权限,可以访问什么资源,解决的是”你能干什么”
+3.安全防护,防止跨站请求,session攻击等.
+1.传统web开发的项目的登录功能
+2.用户授权功能
+3.单一登录,同一时间同一账号只允许在一个地方登录
+4.cas单点登录,即多个系统只要登录一次,就可以在多个系统中访问
+5.集成oauth2,做登录授权,可以用于app登录和第三方登录(QQ,微信等)
+创建一个简单的Controller
+@RestController
+public class HelloSecurityController {
+
+
+ @RequestMapping("/hello")
+ public String hello() {
+ return "Hello Security";
+ }
+
+}
+集成SpringSecurity,启动项目,访问接口,即可访问到SpringSecurity默认提供的页面.
+
SpringSecurity功能的实现主要是由一系列过滤器相互配合完成,也称为过滤器链
+
默认加载15个过滤器,可以自行增加删除自定义过滤器.
+1.WebAsyncManagerIntegrationFilter
+根据请求封装获取WebAsyncManager,从WebAsyncManager获取/注册的安全上下文可调用处理器
+2.SecurityContextPersistenceFilter
+SecurityContextPersistenceFilter主要是使用SecurityContextRepository在session中保存或更新一个SecurityContext,并将SecurityContext给以后的过滤器使用,同时,存储了当前用户认证以及权限信息
+3.HeaderWriterFilter
+向请求的Header中添加相应的信息,可在http标签内部使用security:headers来控制
+4.CsrfFilter
+csrf又称跨域请求伪造，SpringSecurity会对所有post请求验证是否包含系统生成的csrf的
+token信息，如果不包含，则报错。起到防止csrf攻击的效果。
+5.LogoutFilter
+匹配URL为/logout的请求，实现用户退出,清除认证信息。
+6.UsernamePasswordAuthenticationFilter
+表单认证操作全靠这个过滤器，默认匹配URL为/login且必须为POST请求。
+7.DefaultLoginPageGeneratingFilter
+如果没有在配置文件中指定认证页面，则由该过滤器生成一个默认认证页面。
+8.DefaultLogoutPageGeneratingFilter
+由此过滤器可以生产一个默认的退出登录页面
+9.Basicauthenticationfilter
+此过滤器会自动解析HTTP请求中头部名字为Authentication，且以Basic开头的头信息。
+10.RequestCacheAwareFilter
+通过HttpSessionRequestCache内部维护了一个RequestCache，用于缓存
+HttpServletRequest
+11.SecurityContextHolderAwareRequestFilter
+针对ServletRequest进行了一次包装，使得request具有更加丰富的API
+12.AnonymousAuthenticationFilter
+当SecurityContextHolder中认证信息为空,则会创建一个匿名用户存入到
+SecurityContextHolder中。spring security为了兼容未登录的访问，也走了一套认证流程，
+只不过是一个匿名的身份。
+13.SessionManagementFilter
+securityContextRepository限制同一用户开启多个会话的数量
+14.ExceptionTranslationFilter
+异常转换过滤器位于整个springSecurityFilterChain的后方，用来转换整个链路中出现的异
+常
+15.FilterSecurityInterceptor
+获取所配置资源访问的授权信息，根据SecurityContextHolder中存储的用户信息来决定其
+是否有权限。
+HttpBasic模式要求传输的用户名密码使用Base64模式进行加密,如果用户名是 “admin” ， 密码是“ admin”，则将字符串”admin:admin” 使用Base64编码算法加密。加密结果可能是： YWtaW46YWRtaW4=。HttpBasic模式真的是非常简单又简陋的验证模式，Base64的加密算法是 可逆的,想要破解并不难.
+Spring Security的HttpBasic模式,只是进行了通过携带Http的Header进行 简单的登录验证，而且没有定制的登录页面,Security 5.x版本默认会生成一个登录页面
+编写Security配置类,启动项目,访问页面即会进入登录页
+/**
+ * Security配置类
+ * @author 12492 公众号:一只会飞的旺旺
+ * @date 2022-10-10 21:09
+ */
+@Configuration
+public class MySecurityConfiguration extends WebSecurityConfigurerAdapter {
+
+ /**
+ * http请求处理方法
+ * @param http
+ * @throws Exception
+ */
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+// http.httpBasic() //开启httpBasic认证
+// .and().authorizeRequests()
+// .anyRequest().authenticated(); //所有请求都需要登录认证才能访问
+
+ http.formLogin() //开启表单登录
+ .and().authorizeRequests()
+ .anyRequest().authenticated(); //所有请求都需要登录认证才能访问
+ }
+}
+1.localhost将您重定向次数过多
+
配置登录页面放行
+http.formLogin().loginPage("login.html") //开启表单登录,指定登录页面
+ .and().authorizeRequests()
+ .antMatchers("/login.html").permitAll() //登录页面不需要认证
+ .anyRequest().authenticated(); //所有请求都需要登录认证才能访问
+2.访问login.html 报404错
+
通过springboot整合thymeleaf生成静态页面,所以需要请求接口生成模板页面,修改login.html为toLoginPage
+ protected void configure(HttpSecurity http) throws Exception {
+// http.httpBasic() //开启httpBasic认证
+// .and().authorizeRequests()
+// .anyRequest().authenticated(); //所有请求都需要登录认证才能访问
+
+ http.formLogin().loginPage("toLoginPage") //开启表单登录
+ .and().authorizeRequests()
+ .antMatchers("/toLoginPage").permitAll() //登录页面不需要认证
+ .anyRequest().authenticated(); //所有请求都需要登录认证才能访问
+ }
+3.访问login.html 后发现页面没有相关样式
+
放行静态资源,重写另外一个configure方法
+ /**
+ * web安全配置
+ * @param web
+ * @throws Exception
+ */
+ @Override
+ public void configure(WebSecurity web) throws Exception {
+ // 设置不拦截规则
+ web.ignoring().antMatchers("/css/**", "/fonts/**", "/img/**", "/js/**","/favicon.ico");
+ }
+注意: HttpSecurity和WebSecurity的区别
+1.WebSecurity 不仅通过 HttpSecurity 定义某些请求的安全控制，也通过其他方式定义其他某些 请求可以忽略安全控制;
+2.HttpSecurity 仅用于定义需要安全控制的请求(当然 HttpSecurity 也可以指定某些请求不需要 安全控制);
+3.可以认为 HttpSecurity 是 WebSecurity 的一部分， WebSecurity 是包含 HttpSecurity 的更大 的一个概念;
+4.构建目标不同
+ protected void configure(HttpSecurity http) throws Exception {
+ http.formLogin().loginPage("/toLoginPage") //开启表单登录
+ .loginProcessingUrl("/login") //登录表单提交地址
+ .usernameParameter("username") //登录表单用户名参数名
+ .passwordParameter("password") //登录表单密码参数名
+ .successForwardUrl("/") //登录成功跳转地址
+ .and().authorizeRequests()
+ .antMatchers("/toLoginPage").permitAll() //登录页面不需要认证
+ .anyRequest().authenticated(); //所有请求都需要登录认证才能访问
+ //关闭csrf防护
+ http.csrf().disable();
+ //允许iframe嵌套
+ http.headers().frameOptions().disable();
+ }
+重写认证管理的configure方法
+ /**
+ * 认证信息管理
+ * @param auth
+ * @throws Exception
+ */
+ @Override
+ protected void configure(AuthenticationManagerBuilder auth) throws Exception {
+ auth.userDetailsService(new MyUserDetailsService());
+ }
+自定义用户认证实现类
+/**
+ * 基于数据库完成认证
+ *
+ * @author 12492 公众号:一只会飞的旺旺
+ * @date 2022-10-10 21:46
+ */
+@Component
+public class MyUserDetailsService implements UserDetailsService {
+
+ @Autowired
+ private UserService userService;
+
+
+ /**
+ * 根据username查询用户实体
+ *
+ * @param username
+ * @return
+ * @throws UsernameNotFoundException
+ */
+ @Override
+ public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+ User user = userService.findByUsername(username);
+ if (null == user) {
+ throw new UsernameNotFoundException("用户不存在");
+ }
+ // 先声明一个权限集合
+ List<GrantedAuthority> authorities = new ArrayList<>();
+ // 简单构造
+ //return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), authorities);
+ // 复杂构造
+ return new org.springframework.security.core.userdetails.User(user.getUsername(),
+ "{noop}" + user.getPassword(), // {noop}表示不加密
+ true, // 账号是否可用
+ true, // 账号是否过期
+ true, // 密码是否过期
+ true, // 账号是否锁定
+ authorities);
+ }
+
+}
+密码加密:SpringSecurity中的PasswordEncoder就是对密码进行编码的工具接口
+选择一种加密算法即可,常用的如BCrypt.
+修改UserDetails构建时,密码返回方式.修改{noop}为{bcrypt}
+ @Override
+ public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+ User user = userService.findByUsername(username);
+ if (null == user) {
+ throw new UsernameNotFoundException("用户不存在");
+ }
+ // 先声明一个权限集合
+ List<GrantedAuthority> authorities = new ArrayList<>();
+ // 简单构造
+ //return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), authorities);
+ // 复杂构造
+ return new org.springframework.security.core.userdetails.User(user.getUsername(),
+ "{bcrypt}" + user.getPassword(), // {noop}表示不加密, {bcrypt}表示加密
+ true, // 账号是否可用
+ true, // 账号是否过期
+ true, // 密码是否过期
+ true, // 账号是否锁定
+ authorities);
+ }
+保留系统当前的安全上下文SecurityContext，其中就包括当前使用系统的用户的信息。
+安全上下文,获取当前经过身份验证的主体或身份验证请求令牌
+代码实现:
+ /**
+ * 获取当前登录用户信息
+ *
+ * @return
+ */
+ @RequestMapping("/loginUser1")
+ @ResponseBody
+ public UserDetails getCurrentUser1() {
+ return (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+ }
+
+ /**
+ * 获取当前登录用户信息
+ *
+ * @return
+ */
+ @RequestMapping("/loginUser2")
+ @ResponseBody
+ public UserDetails getCurrentUser2(Authentication authentication) {
+ return (UserDetails) authentication.getPrincipal();
+ }
+
+ /**
+ * 获取当前登录用户信息
+ *
+ * @return
+ */
+ @RequestMapping("/loginUser3")
+ @ResponseBody
+ public UserDetails getCurrentUser3(@AuthenticationPrincipal UserDetails
+ userDetails) {
+ return userDetails;
+ }
+1.简单的Token生成方法
+
Token=MD5(username+分隔符+expiryTime+分隔符+password)
+后台开启remember-me功能
+ http.formLogin().loginPage("/toLoginPage") //开启表单登录
+ .loginProcessingUrl("/login") //登录表单提交地址
+ .usernameParameter("username") //登录表单用户名参数名
+ .passwordParameter("password") //登录表单密码参数名
+ .successForwardUrl("/") //登录成功跳转地址
+ .and().authorizeRequests()
+ .antMatchers("/toLoginPage").permitAll() //登录页面不需要认证
+ .anyRequest().authenticated() //所有请求都需要登录认证才能访问
+ .and()
+ .rememberMe()// 开启记住我功能
+ .tokenValiditySeconds(2000)// token失效时间默认两周
+ .rememberMeParameter("rememberMe");// 自定义表单name值
+2.持久化Token生成方法
+
存入数据库Token包含:
+token: 随机生成策略,每次访问都会重新生成
+series: 登录序列号，随机生成策略。用户输入用户名和密码登录时，该值重新生成。使用 remember-me功能，该值保持不变
+expiryTime: token过期时间。
+CookieValue=encode(series+token)
+后台开启remember-me功能
+添加如下配置
+
添加持久化token方法
+ /**
+ * 持久化token,负责token与数据库之间的相关操作
+ *
+ * @return
+ */
+ @Bean
+ public PersistentTokenRepository getPersistentTokenRepository() {
+ JdbcTokenRepositoryImpl tokenRepository = new
+ JdbcTokenRepositoryImpl();
+ tokenRepository.setDataSource(dataSource);//设置数据源
+ // 启动时创建一张表, 第一次启动的时候创建, 第二次启动的时候需要注释掉, 否则会报错
+ tokenRepository.setCreateTableOnStartup(true);
+ return tokenRepository;
+ }
+注意
+为了防止Cookie伪造处理.可以在重要接口添加如下验证,如
+ /**
+ * 根据用户ID查询用户
+ *
+ * @return
+ */
+ @GetMapping("/{id}")
+ @ResponseBody
+ public User getById(@PathVariable Integer id) {
+ //获取认证信息
+ Authentication authentication =
+ SecurityContextHolder.getContext().getAuthentication();
+ // 判断认证信息是否来自RememberMe
+ if (RememberMeAuthenticationToken.class.isAssignableFrom(authentication.getClass())) {
+ throw new RememberMeAuthenticationException("认证信息来源于 RememberMe,请重新登录");
+ }
+ return userService.getById(id);
+ }
+自定义成功处理
+实现AuthenticationSuccessHandler接口，并重写onAnthenticationSuccesss()方法.
+自定义失败处理
+实现AuthenticationFailureHandler接口，并重写onAuthenticationFailure()方法
+
SecurityConfiguration配置
+.successHandler(myAuthenticationService)//自定义登录成功处理
+.failureHandler(myAuthenticationService)//自定义登录失败处理
+LogoutFilter: 匹配URL为/logout的请求,实现用户退出,清除认证信息
+
Spring Security的认证校验是由UsernamePasswordAuthenticationFilter过滤器完成的，所以我们 的验证码校验逻辑应该在这个过滤器之前。验证码通过后才能到后续的操作.
+
自定义验证码过滤器
+添加配置
+
创建验证码过滤器
+/**
+ * 验证码验证filter 需要继承OncePerRequestFilter确保在一次请求只通过一次filter，而不
+ * 需要重复执行
+ *
+ * @author pengwangwang
+ * @date 2022/10/11 09:39
+ **/
+@Component
+public class ValidateCodeFilter extends OncePerRequestFilter {
+
+ @Autowired
+ StringRedisTemplate stringRedisTemplate;
+
+
+ @Override
+ protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
+ // 判断是否是登录请求
+ if ("/login".equals(httpServletRequest.getRequestURI()) && "POST".equals(httpServletRequest.getMethod())) {
+ try {
+ validate(httpServletRequest);
+ } catch (ValidateCodeException e) {
+ e.printStackTrace();
+ return;
+ }
+ }
+ //如果不是登录请求，直接调用后面的过滤器链
+ filterChain.doFilter(httpServletRequest, httpServletResponse);
+ }
+
+
+ public void validate(HttpServletRequest request) throws ValidateCodeException {
+ // 获取ip
+ String ip = request.getRemoteAddr();
+ //拼接redis的key
+ String key = "code_" + ip;
+ // 获取redis中的验证码
+ String code = stringRedisTemplate.opsForValue().get(key);
+ String redisImageCode = request.getParameter("imageCode");
+ if (StringUtils.hasText(redisImageCode)) {
+ throw new ValidateCodeException("验证码不能为空");
+ }
+ if (redisImageCode == null) {
+ throw new ValidateCodeException("验证码已过期");
+ }
+ if (!redisImageCode.equals(code)) {
+ throw new ValidateCodeException("验证码不正确");
+ }
+ // 从redis中移除imageCode
+ stringRedisTemplate.delete(key);
+ }
+
+}
+自定义验证码异常类
+/**
+ * 验证码异常类
+ * @author pengwangwang
+ * @date 2022/10/11 09:42
+ **/
+public class ValidateCodeException extends AuthenticationException {
+
+ public ValidateCodeException(String msg) {
+ super(msg);
+ }
+
+}
+在spring配置文件application.properties中添加超时配置
+# session配置超时时间
+server.servlet.session.timeout=60
+修改自定义设置session超时后地址
+
并发控制即同一个账号同时在线个数,同一个账号同时在线个数如果设置为1表示，该账号在同一时间内只能有一个有效的登录，如果同一个账号又在其它地方登录，那么就将上次登录的会话过期，即后面的登录会踢掉前面的登录.
+1.配置session超时时间
+# session配置超时时间
+server.servlet.session.timeout=600
+2.设置最大会话数量
+3.阻止用户第二次登录
+
实际场景中,一般一个服务至少会有两台服务器提供服务,前面由nginx进行负载均衡,但是这样会导致在一个服务器登录之后,session无法进行共享,导致访问另一台服务器时,需要重新登录
+
为了解决这一问题,我们通常会将用户登录的会话信息,保存到第三方库中,如redis,mongodb,mysql等.这样所有服务器都能从同一个库去获取当前的登录信息.就不需要再次登录了.
+
1.引入依赖
+<!-- 基于redis实现session共享 -->
+<dependency>
+ <groupId>org.springframework.session</groupId>
+ <artifactId>spring-session-data-redis</artifactId>
+</dependency>
+2.设置session存储类型
+#使用redis共享session
+spring.session.store-type=redis
+3.进行测试
+CRSF是什么?
+CSRF（Cross-site request forgery），中文名称：跨站请求伪造 你这可以这么理解CSRF攻击：攻击者盗用了你的身份，以你的名义发送恶意请求。CSRF能够做的 事情包括：以你名义发送邮件，发消息，盗取你的账号，甚至于购买商品，虚拟货币转账……造成的问 题包括：个人隐私泄露以及财产安全。
+CRSF原理
+
1.登录受信任网站A，并在本地生成Cookie。
+2.在不登出A的情况下，访问危险网站B。
+3.触发网站B中的一些元素
+防御策略
+1.验证HTTP Referer字段
2.在请求地址中添加token并验证
3.在HTTP头中自定义属性并验证
开启csrf防御
+
配置跨域信息
+ /**
+ * 跨域配置信息源
+ *
+ * @return
+ */
+ public CorsConfigurationSource corsConfigurationSource() {
+ CorsConfiguration corsConfiguration = new CorsConfiguration();
+ // 设置允许跨域的站点
+ corsConfiguration.addAllowedOrigin("*");
+ // 设置允许跨域的http方法
+ corsConfiguration.addAllowedMethod("*");
+ // 设置允许跨域的请求头
+ corsConfiguration.addAllowedHeader("*");
+ // 允许带凭证
+ corsConfiguration.setAllowCredentials(true);
+ // 对所有的url生效
+ UrlBasedCorsConfigurationSource source = new
+ UrlBasedCorsConfigurationSource();
+ source.registerCorsConfiguration("/**", corsConfiguration);
+ return source;
+ }
+开启跨域配置
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 
如果我们想要控制用户权限,需要两部分数据
+1:配置资源访问需要的权限
+2.用户拥有的权限
+本质上,权限控制实际上就是控制哪些url能否访问.
+ExpressionUrlAuthorizationConfigurer包含了所有表达式
+
/**
+ * 自定义权限不足信息
+ * @author pengwangwang
+ * @date 2022/10/12 14:10
+ **/
+@Component
+public class MyAccessDeniedHandler implements AccessDeniedHandler {
+ @Override
+ public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
+ httpServletResponse.setContentType("application/json;charset=utf-8");
+ httpServletResponse.getWriter().write("权限不足，请联系管理员");
+ }
+}
+/**
+ * 自定义授权类
+ *
+ * @author pengwangwang
+ * @date 2022/10/12 14:16
+ **/
+@Component
+public class MyAuthorizationService {
+
+ /**
+ * 检查用户是否有对应的访问权限
+ *
+ * @param authentication 登录用户
+ * @param request 请求对象
+ * @return
+ */
+ public boolean check(Authentication authentication, HttpServletRequest request) {
+ User user = (User) authentication.getPrincipal();
+ // 获取用户所有权限
+ Collection<GrantedAuthority> authorities = user.getAuthorities();
+ // 获取用户名
+ String username = user.getUsername();
+ // 如果用户名为admin,则不需要认证
+ if (username.equalsIgnoreCase("admin")) {
+ return true;
+ } else {
+ // 循环用户的权限, 判断是否有ROLE_ADMIN权限, 有返回true
+ for (GrantedAuthority authority : authorities) {
+ String role = authority.getAuthority();
+ if ("ROLE_ADMIN".equals(role)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+
+}
+
提供四种注解:@PreAuthorize , @PostAuthorize , @PreFilter , @PostFilter .
+开启注解配置:
+
在方法上使用注解
+ @RequestMapping("/findAll")
+ @PreAuthorize("hasRole('ROLE_ADMIN')") // 指定角色才能访问
+ public String findAll(Model model) {
+ List<User> userList = userService.list();
+ model.addAttribute("userList", userList);
+ return "user_list";
+ }
+RBAC权限模型（Role-Based Access Control）即：基于角色的权限控制。模型中有几个关键的术语：
+用户：系统接口及访问的操作者
+权限：能够访问某接口或者做某操作的授权资格
+角色：具有一类相同操作权限的总称
+
1.springboot启动时,会加载spring.factories文件,其中有SpringSecurity的过滤链配置信息
+
2.SecurityFilterAutoConfiguration类
+
3.SecurityAutoConfiguration类
+
4.WebSecurityEnablerConfiguration类
+
@EnableWebSecurity注解有两个作用:1.加载了WebSecurityConfiguration配置类, 配置安全认证策略。2.加载了AuthenticationConfiguration, 配置了认证信息。
+5.WebSecurityConfiguration类
+
UsernamePasswordAuthenticationFilter
+@Override
+ public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
+ throws AuthenticationException {
+ //1.检查是否是post请求
+ if (this.postOnly && !request.getMethod().equals("POST")) {
+ throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
+ }
+ //2.获取用户名和密码
+ String username = obtainUsername(request);
+ username = (username != null) ? username : "";
+ username = username.trim();
+ String password = obtainPassword(request);
+ password = (password != null) ? password : "";
+ //3.创建AuthenticationToken,未认证状态
+ UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
+ // Allow subclasses to set the "details" property
+ setDetails(request, authRequest);
+ // 4.调用AuthenticationManager进行认证
+ return this.getAuthenticationManager().authenticate(authRequest);
+ }
+UsernamePasswordAuthenticationToken
+ public UsernamePasswordAuthenticationToken(Object principal, Object credentials) {
+ super(authorities);
+ this.principal = principal; // 设置用户名
+ this.credentials = credentials; // 设置密码
+ super.setAuthenticated(false); // 设置认证状态为未认证
+ }
+AuthenticationManager–>ProviderManager–>AbstractUserDetailsAuthenticationProvider
+public Authentication authenticate(Authentication authentication) throws AuthenticationException {
+ Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication, () -> {
+ return this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.onlySupports", "Only UsernamePasswordAuthenticationToken is supported");
+ });
+ // 1.获取用户名
+ String username = authentication.getPrincipal() == null ? "NONE_PROVIDED" : authentication.getName();
+ //2.尝试从缓存中获取
+ boolean cacheWasUsed = true;
+ UserDetails user = this.userCache.getUserFromCache(username);
+ if (user == null) {
+ cacheWasUsed = false;
+
+ try {
+ //3.检索User
+ user = this.retrieveUser(username, (UsernamePasswordAuthenticationToken)authentication);
+ } catch (UsernameNotFoundException var6) {
+ this.logger.debug("User '" + username + "' not found");
+ if (this.hideUserNotFoundExceptions) {
+ throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
+ }
+
+ throw var6;
+ }
+
+ Assert.notNull(user, "retrieveUser returned null - a violation of the interface contract");
+ }
+
+ try {
+ //4.认证前检查user状态
+ this.preAuthenticationChecks.check(user);
+ //5.附加认证认证检查
+ this.additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken)authentication);
+ } catch (AuthenticationException var7) {
+ if (!cacheWasUsed) {
+ throw var7;
+ }
+
+ cacheWasUsed = false;
+ user = this.retrieveUser(username, (UsernamePasswordAuthenticationToken)authentication);
+ this.preAuthenticationChecks.check(user);
+ this.additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken)authentication);
+ }
+
+ //6.认证后检查user状态
+ this.postAuthenticationChecks.check(user);
+ if (!cacheWasUsed) {
+ this.userCache.putUserInCache(user);
+ }
+
+ Object principalToReturn = user;
+ if (this.forcePrincipalAsString) {
+ principalToReturn = user.getUsername();
+ }
+
+ //7.创建认证成功的UsernamePasswordAuthenticationToken并将认证状态设置为true
+ return this.createSuccessAuthentication(principalToReturn, authentication, user);
+ }
+retrieveUser方法
+protected final UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
+ this.prepareTimingAttackProtection();
+
+ try {
+ // 调用自定义UserDetailsService的loadUserByUserName的方法
+ UserDetails loadedUser = this.getUserDetailsService的loadUserByUserName的方法().loadUserByUsername(username);
+ if (loadedUser == null) {
+ throw new InternalAuthenticationServiceException("UserDetailsService returned null, which is an interface contract violation");
+ } else {
+ return loadedUser;
+ }
+ } catch (UsernameNotFoundException var4) {
+ this.mitigateAgainstTimingAttack(authentication);
+ throw var4;
+ } catch (InternalAuthenticationServiceException var5) {
+ throw var5;
+ } catch (Exception var6) {
+ throw new InternalAuthenticationServiceException(var6.getMessage(), var6);
+ }
+}
+additionalAuthenticationChecks方法
+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 {
+ //1.提取前端代码
+ String presentedPassword = authentication.getCredentials().toString();
+ //2.与数据库中的密码进行比对
+ if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
+ this.logger.debug("Failed to authenticate since password does not match stored value");
+ throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
+ }
+ }
+}
+AbstractAuthenticationProcessingFilter–doFilter方法
+private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+ if (!requiresAuthentication(request, response)) {
+ chain.doFilter(request, response);
+ return;
+ }
+ try {
+ //1.调用子类方法
+ Authentication authenticationResult = attemptAuthentication(request, response);
+ if (authenticationResult == null) {
+ // return immediately as subclass has indicated that it hasn't completed
+ return;
+ }
+ //2.session策略验证
+ this.sessionStrategy.onAuthentication(authenticationResult, request, response);
+ // Authentication success
+ if (this.continueChainBeforeSuccessfulAuthentication) {
+ chain.doFilter(request, response);
+ }
+ //3.成功身份验证
+ successfulAuthentication(request, response, chain, authenticationResult);
+ }
+ catch (InternalAuthenticationServiceException failed) {
+ this.logger.error("An internal error occurred while trying to authenticate the user.", failed);
+ unsuccessfulAuthentication(request, response, failed);
+ }
+ catch (AuthenticationException ex) {
+ // Authentication failed
+ unsuccessfulAuthentication(request, response, ex);
+ }
+ }
+successfulAuthentication方法
+protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,
+ Authentication authResult) throws IOException, ServletException {
+ //1.将认证的用户放入SecurityContext中
+ SecurityContextHolder.getContext().setAuthentication(authResult);
+ if (this.logger.isDebugEnabled()) {
+ this.logger.debug(LogMessage.format("Set SecurityContextHolder to %s", authResult));
+ }
+ //2.检查是不是记住我
+ this.rememberMeServices.loginSuccess(request, response, authResult);
+ if (this.eventPublisher != null) {
+ this.eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(authResult, this.getClass()));
+ }
+ //3. 调用自定义MyAuthenticationService的onAuthenticationSuccess方法
+ this.successHandler.onAuthenticationSuccess(request, response, authResult);
+}
+
控制反转: 对象创建交由外部容器实现,解决对象间的耦合.
+
依赖注入:与IOC角度不同,IOC是站在对象角度上,对象的创建交由容器维护,DI是站在容器的角度上,容器会提供对象依赖的其他对象,供给其使用
+
// Controller持有Service对象
+public class TransferServlet extends HttpServlet {
+ private TransferService transferService = new TransferServiceImpl();
+}
+// Service持有Dao对象
+public class TransferServiceImpl implements TransferService {
+ private AccountDao accountDao = new JdbcAccountDaoImpl();
+}
+1.代码耦合,每层都持有下一层的实现类对象
2.service层没有进行事务控制,方法执行中出现异常时,可能会导致数据库数据错乱
问题1:
除了通过new创建对象外,我们还可以通过反射的方式创建,可以将对象创建提取到一个统一的地方执行,并提供一个方法去获取对象.如工厂类
问题2:
为Service层添加事务控制,但是JDBC的事务是控制在dao层,若一个service层中调用dao层多个db方法,这样就会导致出现多个事务,我们需要让这多个db方法属于一个Connection,这样才能实现Service层的事务控制.
1.提取对象到XML
+<beans>
+ <bean id="transferService"
+ class="com.ww.transfer.service.impl.TransferServiceImpl">
+ <property name="AccountDao" ref="accountDao"/>
+ </bean>
+ <bean id="accountDao"
+ class="com.ww.transfer.dao.impl.JdbcAccountDaoImpl">
+ </bean>
+</beans>
+2.通过工厂类创建对象
+public class BeanFactory {
+ /**
+ * ⼯⼚类的两个任务
+ * 任务⼀：加载解析xml，读取xml中的bean信息，通过反射技术实例化bean对象，然后放⼊
+ * map待⽤
+ * 任务⼆：提供接⼝⽅法根据id从map中获取bean（静态⽅法）
+ */
+ private static final Map<String, Object> map = new HashMap<>();
+
+ static {
+ // 读取配置对象信息的XML文件
+ InputStream resourceAsStream =
+ BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
+ SAXReader saxReader = new SAXReader();
+ try {
+ Document document = saxReader.read(resourceAsStream);
+ Element rootElement = document.getRootElement();
+ // 获取所有bean节点
+ List list = rootElement.selectNodes("//bean");
+ // 实例化bean对象
+ for (Object value : list) {
+ Element element = (Element) value;
+ // 获取ID
+ String id = element.attributeValue("id");
+ // 获取类全限定名
+ String clazz = element.attributeValue("class");
+ Class<?> aClass = Class.forName(clazz);
+ Object o = aClass.newInstance();
+ map.put(id, o);
+ }
+ // 维护bean之间的依赖关系
+ List propertyNodes =
+ rootElement.selectNodes("//property");
+ for (Object propertyNode : propertyNodes) {
+ Element element = (Element) propertyNode;
+ // 处理property元素
+ String name = element.attributeValue("name");
+ String ref = element.attributeValue("ref");
+
+ // 获取外层Bean的对象
+ String parentId =
+ element.getParent().attributeValue("id");
+ Object parentObject = map.get(parentId);
+
+ // 调用setter方法
+ Method[] methods = parentObject.getClass().getMethods();
+ for (Method method : methods) {
+ if (("set" + name).equalsIgnoreCase(method.getName())) {
+ // bean之间的依赖关系（注⼊bean）
+ Object propertyObject = map.get(ref);
+ method.invoke(parentObject, propertyObject);
+ }
+ }
+ // 维护依赖关系后重新将bean放⼊map中
+ map.put(parentId, parentObject);
+ }
+ } catch (DocumentException | ClassNotFoundException | IllegalAccessException | InstantiationException |
+ InvocationTargetException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static Object getBean(String id) {
+ return map.get(id);
+ }
+}
+3.增加ConnectionUtils维护唯一Connection
+public class ConnectionUtils {
+
+ // 存储当前线程的连接
+ private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
+
+
+ /**
+ * 从当前线程获取连接
+ */
+ public Connection getCurrentThreadConn() throws SQLException {
+ /**
+ * 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取⼀个连接绑定到
+ 当前线程
+ */
+
+ Connection connection = threadLocal.get();
+ if (connection == null) {
+ // 从连接池拿连接并绑定到线程
+ connection = DruidUtils.getInstance().getConnection();
+ // 绑定到当前线程
+ threadLocal.set(connection);
+ }
+ return connection;
+ }
+
+}
+4.增加ProxyFactory生成代理类,插入事务处理逻辑
+public class ProxyFactory {
+
+ private TransactionManager transactionManager;
+
+ public void setTransactionManager(TransactionManager
+ transactionManager) {
+ this.transactionManager = transactionManager;
+ }
+
+ // 生成代理类
+ public Object getProxy(Object target) {
+
+ return Proxy.newProxyInstance(this.getClass().getClassLoader(),
+ target.getClass().getInterfaces(), (proxy, method, args) -> {
+ Object result;
+ try {
+ // 开启事务
+ transactionManager.beginTransaction();
+ // 调⽤原有业务逻辑
+ result = method.invoke(target, args);
+ // 提交事务
+ transactionManager.commit();
+ } catch (Exception e) {
+ e.printStackTrace();
+ // 回滚事务
+ transactionManager.rollback();
+ // 异常向上抛出,便于servlet中捕获
+ throw e.getCause();
+ }
+ return result;
+ });
+ }
+
+}
+github地址: https://github.com/spring-projects/spring-framework/tree/5.1.x
+下载Spring源码,切换到5.1.X分支.
+
1.通过源码中的地址,下载匹配版本的gradle
+
2.配置gradle的环境变量
+
3.在cmd中使用gradle -v命令,查看是否配置正确
+4.修改IDEA中Gradle配置为本地配置
+
5.修改Spring源码根目录的build.gradle文件,两处都添加阿里云maven仓库目录
+repositories {
+ maven { url 'https://maven.aliyun.com/repository/public/' }
+ maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
+ maven { url 'https://maven.aliyun.com/repository/apache-snapshots' }
+ maven { url 'https://maven.aliyun.com/repository/central' }
+ maven { url 'https://maven.aliyun.com/repository/google' }
+ maven { url 'https://maven.aliyun.com/repository/jcenter' }
+ maven { url 'https://maven.aliyun.com/repository/spring' }
+ maven { url 'https://maven.aliyun.com/repository/spring-plugin' }
+}
+6.编译工程,顺序core-oxm-context-beans-aspects-aop, 点击tasks->compileTestJava
+7.新建spring-model即可添加个人项目,开始源码阅读
+1.No such property: immutableValues for class: org.gradle.api.internal.tasks.DefaultTaskDependency
+//修改spring-beans.gradle
+注释掉这两行代码
+//def deps = compileGroovy.taskDependencies.immutableValues + compileGroovy.taskDependencies.mutableValues
+//compileGroovy.dependsOn = deps - 'compileJava'
+2.Could not find method useJUnitPlatform()
+注释：spring-test.gradle中这行代码
+// useJUnitPlatform {
+// includeEngines 'junit-jupiter'
+// excludeTags 'failing-test-case'
+// }
+3.错误如下
+> Task :spring-beans:compileGroovy FAILED
+D:\work_space\spring-framework\spring-beans\src\main\java\org\springframework\beans\support\PropertyComparator.java:138: 错误: 不兼容的类型: PropertyComparator<CAP
+#1>无法转换为Comparator<? super CAP#1>
+ source.sort(new PropertyComparator<>(sortDefinition));
+点击错误类，会直接跳转到该方法，然后直接返回值List泛型去掉
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ http请求的处理过程
+
Tomcat既按照Servlet的规范要求去实现了Servlet容器,同时也具有HTTP服务器的功能
+
1.HTTP服务器会将请求信息使用ServletRequest对象封装起来
+2.根据URL映射调用Servlet容器中的某个具体的Servlet
+3.若Servlet还未加载,则通过反射机制创建Servlet,并调用Servlet的init方法完成初始化
+4.调用具体Servlet的service方法来处理请求,请求处理结果使用ServletResponse对象封装
+5.将ServletResponse对象返回给HTTP服务器,HTTP服务器会把响应发送给客户端
+
根据上面的介绍,可以发现,Tomcat需要实现两个重要的功能
+1.与客户端交互.进行请求响应对象转换
+2.Servlet容器处理业务逻辑
+下面介绍Tomcat的两个核心组件
+负责对外交流,处理Socket连接,负责网络字节流与Request和Response对象的转化
+
负责内部处理,加载和管理Servlet,以及具体处理Request请求
+
1.Engine
+表示整个Catalina的Servlet引擎,用来管理多个虚拟站点,一个Service最多只能有一个Engine,当一个引擎可以有多个Host
+2.Host
+代表一个虚拟主机,或者说一个站点,可以给Tomcat配置多个虚拟主机地址,而一个虚拟主机可以包含多个Context
+3.Context
+表示一个Web应用程序,一个Web应用可以包含多个Wrapper
+4.Wrapper
+表示一个Servlet,Wrapper作为容器中的最底层,不能包含子容器
+上述组件的配置就体现在conf/server.xml中
+核心配置文件在tomcat目录下conf/server.xml
+主要标签结构
+<!--
+ Server 根元素，创建⼀个Server实例，⼦标签有 Listener、GlobalNamingResources、
+Service
+-->
+<Server>
+ <!--定义监听器-->
+ <Listener/>
+ <!--定义服务器的全局JNDI资源 -->
+ <GlobalNamingResources/>
+ <!--
+ 定义⼀个Service服务，⼀个Server标签可以有多个Service服务实例
+ -->
+ <Service/>
+</Server>
+Server标签
+<!--
+ port：关闭服务器的监听端⼝
+ shutdown：关闭服务器的指令字符串
+-->
+<Server port="8005" shutdown="SHUTDOWN">
+ <!-- 以⽇志形式输出服务器 、操作系统、JVM的版本信息 -->
+ <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
+ <!-- Security listener. Documentation at /docs/config/listeners.html
+ <Listener className="org.apache.catalina.security.SecurityListener" />
+ -->
+ <!--APR library loader. Documentation at /docs/apr.html -->
+ <!-- 加载（服务器启动） 和 销毁 （服务器停⽌） APR。 如果找不到APR库， 则会输出⽇志， 并
+不影响 Tomcat启动 -->
+ <Listener className="org.apache.catalina.core.AprLifecycleListener"
+SSLEngine="on" />
+ <!-- Prevent memory leaks due to use of particular java/javax APIs-->
+ <!-- 避免JRE内存泄漏问题 -->
+ <Listener
+className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
+ <!-- 加载（服务器启动） 和 销毁（服务器停⽌） 全局命名服务 -->
+ <Listener
+className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
+ <!-- 在Context停⽌时重建 Executor 池中的线程， 以避免ThreadLocal 相关的内存泄漏 -->
+<Listener
+className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
+
+
+ <!-- Global JNDI resources
+ Documentation at /docs/jndi-resources-howto.html
+ GlobalNamingResources 中定义了全局命名服务
+ -->
+ <GlobalNamingResources>
+ <!-- Editable user database that can also be used by
+ UserDatabaseRealm to authenticate users
+ -->
+ <Resource name="UserDatabase" auth="Container"
+ type="org.apache.catalina.UserDatabase"
+ description="User database that can be updated and saved"
+ factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
+ pathname="conf/tomcat-users.xml" />
+ </GlobalNamingResources>
+ <!-- A "Service" is a collection of one or more "Connectors" that share
+ a single "Container" Note: A "Service" is not itself a "Container",
+ so you may not define subcomponents such as "Valves" at this level.
+ Documentation at /docs/config/service.html
+ -->
+ <Service name="Catalina">
+ ...
+ </Service>
+</Server>
+Service标签
+<!--
+ 该标签⽤于创建 Service 实例，默认使⽤ org.apache.catalina.core.StandardService。
+ 默认情况下，Tomcat 仅指定了Service 的名称， 值为 "Catalina"。
+ Service ⼦标签为 ： Listener、Executor、Connector、Engine，
+ 其中：
+ Listener ⽤于为Service添加⽣命周期监听器，
+ Executor ⽤于配置Service 共享线程池，
+ Connector ⽤于配置Service 包含的链接器，
+ Engine ⽤于配置Service中链接器对应的Servlet 容器引擎
+-->
+<Service name="Catalina">
+ ...
+</Service>
+Executor标签
+<!--
+默认情况下，Service 并未添加共享线程池配置。 如果我们想添加⼀个线程池， 可以在
+<Service> 下添加如下配置：
+ name：线程池名称，⽤于 Connector中指定
+ namePrefix：所创建的每个线程的名称前缀，⼀个单独的线程名称为
+namePrefix+threadNumber
+ maxThreads：池中最⼤线程数
+ minSpareThreads：活跃线程数，也就是核⼼池线程数，这些线程不会被销毁，会⼀直存在
+ maxIdleTime：线程空闲时间，超过该时间后，空闲线程会被销毁，默认值为6000（1分钟），单位
+毫秒
+ maxQueueSize：在被执⾏前最⼤线程排队数⽬，默认为Int的最⼤值，也就是⼴义的⽆限。除⾮特
+殊情况，这个值 不需要更改，否则会有请求不会被处理的情况发⽣
+ prestartminSpareThreads：启动线程池时是否启动 minSpareThreads部分线程。默认值为
+false，即不启动
+ threadPriority：线程池中线程优先级，默认值为5，值从1到10
+ className：线程池实现类，未指定情况下，默认实现类为
+org.apache.catalina.core.StandardThreadExecutor。如果想使⽤⾃定义线程池⾸先需要实现
+org.apache.catalina.Executor接⼝
+-->
+<Executor name="commonThreadPool"
+ namePrefix="thread-exec-"
+ maxThreads="200"
+ minSpareThreads="100"
+ maxIdleTime="60000"
+ maxQueueSize="Integer.MAX_VALUE"
+ prestartminSpareThreads="false"
+ threadPriority="5"
+ className="org.apache.catalina.core.StandardThreadExecutor"/>
+Connector标签
+Connector 标签⽤于创建链接器实例
+默认情况下，server.xml 配置了两个链接器，⼀个⽀持HTTP协议，⼀个⽀持AJP协议
+⼤多数情况下，我们并不需要新增链接器配置，只是根据需要对已有链接器进⾏优化
+<!--
+port：
+ 端⼝号，Connector ⽤于创建服务端Socket 并进⾏监听， 以等待客户端请求链接。如果该属性设置
+为0， Tomcat将会随机选择⼀个可⽤的端⼝号给当前Connector 使⽤
+protocol：
+ 当前Connector ⽀持的访问协议。 默认为 HTTP/1.1 ， 并采⽤⾃动切换机制选择⼀个基于 JAVA
+NIO 的链接器或者基于本地APR的链接器（根据本地是否含有Tomcat的本地库判定）
+connectionTimeOut:
+Connector 接收链接后的等待超时时间， 单位为 毫秒。 -1 表示不超时。
+redirectPort：
+ 当前Connector 不⽀持SSL请求， 接收到了⼀个请求， 并且也符合security-constraint 约束，
+需要SSL传输，Catalina⾃动将请求重定向到指定的端⼝。
+executor：
+ 指定共享线程池的名称， 也可以通过maxThreads、minSpareThreads 等属性配置内部线程池。
+URIEncoding:
+ ⽤于指定编码URI的字符编码， Tomcat8.x版本默认的编码为 UTF-8 , Tomcat7.x版本默认为ISO8859-1
+-->
+<!--org.apache.coyote.http11.Http11NioProtocol ， ⾮阻塞式 Java NIO 链接器-->
+<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000"
+redirectPort="8443" />
+<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
+Engine标签
+<!--
+name： ⽤于指定Engine 的名称， 默认为Catalina
+defaultHost：默认使⽤的虚拟主机名称， 当客户端请求指向的主机⽆效时， 将交由默认的虚拟主机处
+理， 默认为localhost
+-->
+<Engine name="Catalina" defaultHost="localhost">
+ ...
+</Engine>
+Host标签
+用于配置一个虚拟主机
+<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">
+ ...
+</Host>
+Context标签
+Context标签用于配置一个Web应用
+<Host name="www.abc.com" appBase="webapps" unpackWARs="true"
+autoDeploy="true">
+<!--
+ docBase：Web应⽤⽬录或者War包的部署路径。可以是绝对路径，也可以是相对于 Host appBase的
+相对路径。
+ path：Web应⽤的Context 路径。如果我们Host名为localhost， 则该web应⽤访问的根路径为：
+ http://localhost:8080/web_demo。
+-->
+ <Context docBase="/Users/yingdian/web_demo" path="/web3"></Context>
+
+ <Valve className="org.apache.catalina.valves.AccessLogValve"
+directory="logs"
+ prefix="localhost_access_log" suffix=".txt"
+ pattern="%h %l %u %t "%r" %s %b" />
+</Host>
+实现步骤
+1.解析web.xml中的配置,保存url与servlet对象的映射关系
+<?xml version="1.0" encoding="UTF-8" ?>
+<web-app>
+ <servlet>
+ <servlet-name>ww</servlet-name>
+ <servlet-class>server.MyServlet</servlet-class>
+ </servlet>
+ <servlet-mapping>
+ <servlet-name>ww</servlet-name>
+ <url-pattern>/my</url-pattern>
+ </servlet-mapping>
+</web-app>
+private void loadServlet() {
+ InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("web.xml");
+ SAXReader saxReader = new SAXReader();
+
+ try {
+ Document document = saxReader.read(resourceAsStream);
+ Element rootElement = document.getRootElement();
+
+ List<Element> selectNodes = rootElement.selectNodes("//servlet");
+ for (int i = 0; i < selectNodes.size(); i++) {
+ Element element = selectNodes.get(i);
+ // <servlet-name>lagou</servlet-name>
+ Element servletnameElement = (Element) element.selectSingleNode("servlet-name");
+ String servletName = servletnameElement.getStringValue();
+ // <servlet-class>server.LagouServlet</servlet-class>
+ Element servletclassElement = (Element) element.selectSingleNode("servlet-class");
+ String servletClass = servletclassElement.getStringValue();
+
+
+ // 根据servlet-name的值找到url-pattern
+ Element servletMapping = (Element) rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']");
+ // /lagou
+ String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue();
+ servletMap.put(urlPattern, (HttpServlet) Class.forName(servletClass).newInstance());
+ }
+ } catch (DocumentException | IllegalAccessException | InstantiationException | ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+
+ }
+2.定义一个线程类,封装request,response对象,请求资源
+private void loadServlet() {
+ InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("web.xml");
+ SAXReader saxReader = new SAXReader();
+
+ try {
+ Document document = saxReader.read(resourceAsStream);
+ Element rootElement = document.getRootElement();
+
+ List<Element> selectNodes = rootElement.selectNodes("//servlet");
+ for (int i = 0; i < selectNodes.size(); i++) {
+ Element element = selectNodes.get(i);
+ // <servlet-name>lagou</servlet-name>
+ Element servletnameElement = (Element) element.selectSingleNode("servlet-name");
+ String servletName = servletnameElement.getStringValue();
+ // <servlet-class>server.LagouServlet</servlet-class>
+ Element servletclassElement = (Element) element.selectSingleNode("servlet-class");
+ String servletClass = servletclassElement.getStringValue();
+
+
+ // 根据servlet-name的值找到url-pattern
+ Element servletMapping = (Element) rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']");
+ // /lagou
+ String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue();
+ servletMap.put(urlPattern, (HttpServlet) Class.forName(servletClass).newInstance());
+ }
+ } catch (DocumentException | IllegalAccessException | InstantiationException | ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+
+ }
+3.启动Socket监听,将线程类放入线程池
+public void start() throws IOException {
+ // 加载解析相关的配置 web.xml
+ loadServlet();
+
+ // 定义一个线程池
+ int corePoolSize = 10;
+ int maximumPoolSize = 50;
+ long keepAliveTime = 100L;
+ TimeUnit unit = TimeUnit.SECONDS;
+ ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(50);
+ ThreadFactory threadFactory = Executors.defaultThreadFactory();
+ RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
+
+ ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
+ corePoolSize,
+ maximumPoolSize,
+ keepAliveTime,
+ unit,
+ workQueue,
+ threadFactory,
+ handler
+ );
+
+ /**
+ * 完成Minicat1.0版本
+ * 需求: 浏览器请求http://localhost:8080
+ * 返回一个固定的字符串到页面"Hello Minicat!"
+ */
+ ServerSocket serverSocket = new ServerSocket(port);
+ System.out.println("=====>>>Minicat start on port:" + port);
+ System.out.println("=========>>>>>>使用线程池进行多线程改造");
+ /*
+ 多线程改造（使用线程池）
+ */
+ while(true) {
+ Socket socket = serverSocket.accept();
+ RequestProcessor requestProcessor = new RequestProcessor(socket,servletMap);
+ //requestProcessor.start();
+ threadPoolExecutor.execute(requestProcessor);
+ }
+4.请求localhost:8080/my之后,会进入HttpServlet的service进行处理,区分GET,POST请求
+ public void service(Request request, Response response) throws Exception {
+ if("GET".equalsIgnoreCase(request.getMethod())) {
+ doGet(request,response);
+ }else{
+ doPost(request,response);
+ }
+ }
+
类加载过程:Java类(.java)–>字节码文件(.class)–>字节码文件
+
引导启动类加载器
+BootStrapClassLoader:加载java核心库文件,比如rt.jar中的类,构造ExtClassLoader和AppClassLoader
+扩展类加载器
+ExtClassLoader:加载扩展库JAVA_HOME/lib/ext目录下的jar中的类,如classpath中的jre,javax.*或者java.ext.dir指定位置中的类
+系统类加载器
+AppClassLoader/SystemCalssLoader:默认的类加载器,搜索环境变量classpath中指定的路径
+当某个类加载器要加载某个.class文件时,它首先把这个任务委托给他的上级类加载器,递归这个操作,如果上级的类加载器没有加载,自己才会去加载这个类.
+作用
+1.防止重复加载同一个.class
+2.保证最上层的核心.class不能被篡改.
+
1.系统类加载器正常情况下应该加载的是Classpath下的类,但是tomcat中加载的是tomcat的启动类,如bootstrap.jar
+2.Common通用类加载器加载Tomcat使用以及应用通用的一些类,位于CATALINA_HOME/lib下,比如servlet-api.jar
+3.Catalina ClassLoader用于加载服务器内部可见类
+4.Shared ClassLoader用于加载应用程序共享类
+5.Webapp ClassLoader,每个应用程序都有独一无二的Webapp ClassLoader,加载应用程序/WEB-INF/classes和/WEB-INF/lib下的类
+加载顺序
+1.首先从Bootstrap ClassLoader加载指定的类
+2.如果未加载到,则从/WEB-INF/classes加载
+3.如果未加载到,则从/WEB-INF/lib/*.jar加载
+4.如果未加载到,则一次从Sytstem,Common,Shared加载
+1.HTTPS需要使用SSL证书
+2.Tomcat下HTTP默认端口8080,HTTPS默认端口8443
+3.HTTPS具有安全性,会对数据传输加密,相当于HTTP的升级版
+
1.使用JDK中的keytool工具生成免费的证书
+keytool -genkey -alias lagou -keyalg RSA -keystore lagou.keystore
+
2.配置conf/server.xml
+<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
+ maxThreads="150" schema="https" secure="true" SSLEnabled="true">
+ <SSLHostConfig>
+ <Certificate
+certificateKeystoreFile="a.keystore 证书文件地址" certificateKeystorePassword="lagou123" type="RSA"
+/>
+ </SSLHostConfig>
+</Connector>
+3.使用https协议访问localhost:8443
+1.响应时间:执行某个操作的耗时
+2.吞吐量:系统在给定时间能支持的事务数量.单位TPS.
+1.虚拟机优化
+
2.Tomcat配置优化
+
可以使⽤Nginx+Tomcat相结合的部署⽅案，Nginx负责静态资源访问，Tomcat负责Jsp等动态资源访问处理（因为Tomcat不擅⻓处理静态资源）
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 现场服务部署使用内网IP,而平时远程解决问题,可能需要用到外网IP,这时我们就需要为服务器配置双网卡,既可以使用静态IP访问到局域网服务器，又可以进行外网访问。
+进入网络管理目录,编辑下面的yaml文件
+cd /etc/netplan
+vim 01-network-manager-all.yaml
+1.查询每个网口的名称，终端输入ifconfig，如下图红框内即为网口名称
2.使用root权限编辑此文档sudo vim 01-network-manager-all.yaml
enp1s0f1为外网网口,enp1s0f0为内网网口,
+network:
+ ethernets:
+ enp1s0f0:
+ addresses: [你的内网ip地址/24]
+ dhcp4: no
+ dhcp6: no
+ enp1s0f1:
+ dhcp4: yes
+ dhcp6: yes
+ version: 2
+ renderer: networkd
+3.然后执行以下命令
+sudo netplan apply
+4.然后通过ping ip的方式,判断内网ip地址是否配置成功,以及ping www.baidu.com,判断外网ip是否成功.
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 
WARP是cloudflare公司推出的可以用来保护使用者隐私的一款服务，对于经常使用WARP来解锁vps流媒体的人再熟悉不过了。
WARP基于wireguard协议，使用UDP来传输数据，也就意味着在公网中的高QOS，但是WARP的ip相对比较干净，对外访问网络的出口 IP 被很多网站视为真实用户，可以用来解锁流媒体，谷歌学术等。
Zero Trust，俗称team，是由cloudflare推出的面向团队的vpn服务，由于其登录1.1.1.1可以获得无限流量，不需要再通过刷邀请流量的方式来获得WARP+流量，做到“一劳永逸”。
+注意: 若是发现最后无法连接,或者连接后没有网络,请更换设备或者WIFI,同时官网默认屏蔽了一些网站访问!若最终还是无法访问谷歌,请及时放弃!避免折腾!
+小卖铺: 首页 | 一只会飞的旺旺 (wangwangit.com)
+直接前往官网下载即可,官网打不开可以访问个人盘下载
+官方: https://1.1.1.1/
个人盘1: 安卓 windows
个人盘2: 安卓 windows
Cloudflare WARP是可以直接通过官网应用来使用，可以登录官网来下载应用，安装成功后，打开首页开关即可体验Cloudflare WARP。WARP下载后会有1G的WARP+体验流量，流量使用完后会降级WARP,后期可以刷邀请流量和升级为Zero Trust解决。但由于国内的特殊网络情况，可能出现一直正在连接中的情况，不断重试直至连接成功即可。
+地址: warp.mp4 | 一只会飞的旺旺 (wangwangit.com)
+若只是想使用,可以直接跳过申请,直接安装软件,按我的配置登录即可!
+使用WARP team基本上只需要两步，创建团队以及登录账号。
+++我的team团队名称为wangzai，使用后缀为@qq.com的邮箱验证即可，欢迎使用。 (人员已满)
+另外一个团队名:wangwang
+后续不再提供Team,请自行按教程申请.验证码收不到请换邮箱多尝试几次,还不行请自行搜索获取密钥的方式,获取密钥使用软件.
+
设置->账户->按键->更改密钥
+++key1: 7xk0h93w-qE69ce01-5P3r01sa
+key2: 45QDMW26-n46B9u1M-6E0Nr5Q8
+key3: tl8A1F93-oz41aQ76-1FATw764
+
设置一个自己能记住的团队名称、点击Next
+
跳转到下一界面之后，选择Free plan。
+我们可以看到free计划最多支持50人同时使用，这波可谓诚意满满。不出意外的话，会让你绑定付款方式，这个时候我们删除URL中多余的部分(即访问最初的地址:Cloudflare Zero Trust)，直接进入主界面即可。不需要绑定付款方式。
+
创建团队成功
+弹出绑定付款方式时，团队已经创建成功，直接访问Zero Trust即可。
+
设置认证方式
+介绍安卓的使用教程!
+
注：
+1、团队名称为之前你设置的团队名称。
+2、邮箱也要符合你之前设置的邮箱后缀。
+cloudflare的免费服务一向诚意满满，我们应该珍惜，不要滥用，一个团队可以容纳50名用户，建议你多向附近的人推荐你的团队或者加入别人的团队，这样物尽其用才是最好的珍惜。
+我的team团队名称为wangzai，验证邮箱@qq.com即可，欢迎使用。
+有需要进交流群的可以加我,备注AI即可!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 如果需要使用微软官方支持的systmed，在目前来说你需要满足这些前置条件：
+查看wsl版本号命令为： wsl --version，如果此命令未正常回显版本号，或版本号低于0.67.6，那么你安装的wsl还不支持systemd。
前往Microsoft Store安装最新的WSL Perview,或者去 https://github.com/microsoft/WSL/releases 下载最新的进行安装!
+
通过wsl命令进入服务器内部,修改wsl配置启用systemd
+echo -e "[boot]\nsystemd=true" | sudo tee -a /etc/wsl.conf
+通过下面命令判断systemd是否启用成功,若返回init说明未启用,若是systemd则表示启动成功!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 使用websocket，通过spring cloud gateway转发传送数据大于64kb时会丢失数据，查看源码发现netty中默认websocket限制大小是64k。
+原因(有兴趣的可以查看下源码)：
+ReactorNettyWebSocketClient 这个类下面的 maxFramePayloadLength。
+在 gateway 项目的配置文件中加入下面这句话并设置大小。
+spring:
+ cloud:
+ gateway:
+ httpclient:
+ websocket:
+ max-frame-payload-length: 10485760 # 需要设置的大小
+
Windows 11是微软最新的操作系统，它带来了许多新的功能和改进。其中一个最令人期待的功能就是Windows Copilot，一个基于微软Edge浏览器和Bing搜索引擎的智能助手，可以帮助用户更高效地使用Windows 11。
+要立即试用 Copilot，请按照以下步骤操作：
+注册 Windows 预览体验计划的开发频道。
+重新启动。
+转到 Windows 更新并检查更新。
+下载内部版本 23493 或更高版本。
+
Windows Copilot是一个集成在Windows 11中的智能助手，它可以通过语音或文本与用户交互，回答用户的问题，执行用户的命令，以及提供用户需要的信息和服务。Windows Copilot不是一个单独的应用程序，而是一个嵌入在Windows 11右侧的面板，可以与任何应用程序并排使用。
+Windows Copilot的核心技术是微软Edge浏览器和Bing搜索引擎。微软Edge浏览器提供了网页渲染能力，使得Windows Copilot可以显示丰富的网页内容。Bing搜索引擎提供了人工智能能力，使得Windows Copilot可以理解用户的意图，生成语义化的回答，以及调用OpenAI等第三方插件。
+
Windows Copilot目前还处于开发阶段，已经向Windows Insider Program的Dev Channel测试者开放。目前，Windows Copilot支持以下几种类型的功能：
+Windows Copilot相比于之前的Cortana智能助手有以下几个优势：
+当然，Windows Copilot也不是完美无缺的。目前，它还存在以下一些局限：
+总的来说，Windows Copilot是一个非常有潜力的智能助手，它可以帮助用户更高效地使用Windows 11，也可以提供用户更多的信息和服务。虽然它目前还不够完善，但是它已经展示了微软在人工智能领域的雄心和实力。如果你是一个喜欢尝试新技术的用户，那么你可以通过加入Windows Insider Program的Dev Channel来体验Windows Copilot。如果你是一个喜欢稳定和成熟的用户，那么你可以等待Windows Copilot正式发布后再使用它。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ Clash是一个开源、免费的网络连接代理内核。它是用Go编程语言开发的，主要用于网络连接的转发。这是基于一套预定义的规则，用于实现科学上网（即翻墙）。其优点是可以自动选择节点，实现”自动使用不同的节点来访问不同的网站”。它支持Windows、Mac、Android、软路由端（暂不支持iOS），并支持主流的VMess、Shadowsocks、Trojan、Snell、SS/SSR、v2ray等协议。在这篇博文中，我将详细介绍如何使用和配置Clash。
+Clash可以在官方网站下载。
+首次启动Clash for Windows，如果出现以下界面，表示启动成功：
+
在使用Clash之前，你需要导入一个配置文件。配置文件的导入有两种途径：
+URL导入：在界面左侧菜单Profiles中，填入URL并点击Download。下载完成后，点击对应的配置文件即可载入。
+
本地文件拖拽导入：如果无法通过URL下载配置文件，可以在浏览器中下载配置文件后，通过拖拽的方式导入。
+
一般情况下，URL和配置文件都由服务商提供复制或下载。
+在General设置中，打开System Proxy和Starts with Windows两个开关即可。System Proxy用于设置系统代理，而Start with Windows则可以使Clash在开机时自动启动。
至此，你已经完成了Clash的基本配置。
+在 Clash 中，有很多情况可能需要你自己定义配置文件，例如你可能希望将某些特定的网站通过特定的代理节点进行访问，或者你可能希望某些网站直接连接而不使用代理，这些都可以通过自定义配置文件实现。
+自定义配置文件并不复杂，只需要熟悉 Clash 配置文件中的各个部分，理解它们的含义，然后按照你的需求进行配置即可。
+下面是一个简单的 Clash 配置文件示例：
+# HTTP 代理服务器端口
+port: 7890
+
+# SOCKS5 代理服务器端口
+socks-port: 7891
+
+# 允许局域网连接
+allow-lan: true
+
+# 规则模式，Rule（规则） / Global（全局代理）/ Direct（全局直连）
+mode: Rule
+
+# 设置日志等级（silent / info / warning / error / debug）
+log-level: info
+
+# 外部控制器的控制端口
+external-controller: 127.0.0.1:9090
+
+# 代理节点，可以有多个
+proxies:
+ - name: "节点1"
+ type: ss
+ server: servername
+ port: 8388
+ cipher: AEAD_CHACHA20_POLY1305
+ password: "yourpassword"
+
+# 代理节点组，可以根据需要自定义
+proxy-groups:
+ - name: "自动选择"
+ type: url-test
+ proxies:
+ - "节点1"
+ url: 'http://www.gstatic.com/generate_204'
+ interval: 300
+
+# 规则，决定哪些请求通过哪个代理节点或直接连接
+rules:
+ - DOMAIN-SUFFIX,google.com,自动选择
+ - DOMAIN-KEYWORD,facebook,自动选择
+ - GEOIP,CN,Direct
+ - MATCH,自动选择
+在这个配置文件中，主要定义了三个部分：proxies，proxy-groups 和 rules。
proxies：定义了你的所有代理节点，你可以添加多个节点，并为每个节点设置一个唯一的名称。proxy-groups：定义了代理节点组，你可以将多个节点放入一个组中，并为这个组设置一个唯一的名称。在这个示例中，我们创建了一个名为“自动选择”的代理节点组，它会自动选择延迟最低的节点作为代理服务器。rules：定义了你的代理规则，你可以根据自己的需要设置多条规则。在这个示例中，我们设置了四条规则，它们分别是：这只是一个简单的示例，实际上 Clash 的配置文件可以做到更多复杂的配置，例如你可以设置多个代理节点组，每个组有不同的选择策略（例如负载均衡，最少连接等），也可以设置更复杂的规则（例如使用正则表达式匹配特定的网址等）。
+自定义 Clash 配置文件需要一些时间熟悉，但一旦你掌握了它，你就可以根据自己的需求进行任意配置，这是 Clash 的一个非常强大的功能。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 🌟 Windows沙盒，安全测试的新选择 在不确定软件安全性的情况下，我们往往需要一个安全的环境来测试。Windows沙盒提供了一个完美的解决方案，让你在隔离的环境中运行软件，无需担心主系统受到影响。🔐
+在启动Windows沙盒之前，需要确保你的系统满足以下条件：
+
启用沙盒功能：在控制面板中找到“启用或关闭Windows功能”，勾选“Windows沙盒”。
+
重启电脑：完成上述操作后，重启电脑以应用更改。
+运行沙盒：在开始菜单中搜索并运行“Windows Sandbox”。
+
在沙盒中，你可以像在普通Windows系统中一样安装和运行软件。测试完成后，只需关闭沙盒窗口，所有更改都会被自动丢弃。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ ++我是旺旺，一个热衷于IT技术分享的博主。我热爱探索新技术，尤其对AI领域有着浓厚的兴趣。我始终坚信，分享是学习的一部分，也是我写博客的初衷。我希望通过我的博客，能够帮助到更多对IT技术感兴趣的朋友，一起探索和学习。
+
如果你对AI感兴趣，欢迎加我微信，我最近建立了一个AI交流群，我们可以一起交流学习。
+
+
+
+ 微信支付
+
+ 支付宝支付
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+ 
+ 
+ 
+ 欢迎来到我的世界! 一键进群
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 欢迎来到我的世界! 一键进群
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 欢迎来到我的世界! 一键进群
+
+
+ 
+ 欢迎来到我的世界! 一键进群
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+ 
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+ 
ChatGPT 
Bing新必应 
Claude2 
Google Bard 
Midjourney 
文心一言 
Stable Diffusion 
WPS AI 
Notion Dall-E 2 
ChatGLM 
通义千问
LX Music
Z-Library
鸠摩搜索
Book Searcher安娜的档案JRebel激活工具Github Copilot激活工具Navicat试用续期工具Typora免激活版本PDF处理工具XShell免费版本Markdown转微信公众号格式Jetbrains激活工具sourcegraph代码工具如果你有好的网站与大家分享，可以在本页的评论区留言!!!
+
+ 
+ 
<!-- 必填项 -->
+name="站点名字"
+url="站点地址"
+logo="站点图标"
+word="站点描述"
+欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+ 有时候使用 Docker Hub 这样的公共仓库可能不方便，用户可以创建一个本地仓库供私人使用,本节将介绍如何使用本地仓库。
+docker-registry是官方提供的工具，可以用于构建私有的镜像仓库。本文内容基于 v2.x 版本。
+容器运行
你可以使用官方 registry 镜像来运行。
$ docker run -d -p 5000:5000 --restart=always --name registry registry
+这将使用官方的 registry 镜像来启动私有仓库。默认情况下，仓库会被创建在容器的 /var/lib/registry 目录下。你可以通过 -v 参数来将镜像文件存放在本地的指定路径。例如下面的例子将上传的镜像放到本地的 /opt/data/registry 目录
$ docker run -d \
+ -p 5000:5000 \
+ -v /opt/data/registry:/var/lib/registry \
+ registry
+docker-compose.yml
+version: '3'
+services:
+ registry:
+ image: registry:latest
+ container_name: registry
+ ports:
+ - "5000:5000"
+ restart: always
+创建好私有仓库之后，就可以使用 docker tag 来标记一个镜像，然后推送它到仓库。例如私有仓库地址为 127.0.0.1:5000。
先在本机查看已有的镜像。
+$ docker image ls
+REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
+ubuntu latest ba5877dc9bec 6 weeks ago 192.7 MB
+使用 docker tag 将 ubuntu:latest 这个镜像标记为 127.0.0.1:5000/ubuntu:latest。
格式为 docker tag IMAGE[:TAG] [REGISTRY_HOST[:REGISTRY_PORT]/]REPOSITORY[:TAG]。
$ docker tag ubuntu:latest 127.0.0.1:5000/ubuntu:latest
+$ docker image ls
+REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
+ubuntu latest ba5877dc9bec 6 weeks ago 192.7 MB
+127.0.0.1:5000/ubuntu:latest latest ba5877dc9bec 6 weeks ago 192.7 MB
+使用 docker push 上传标记的镜像。
$ docker push 127.0.0.1:5000/ubuntu:latest
+The push refers to repository [127.0.0.1:5000/ubuntu]
+373a30c24545: Pushed
+a9148f5200b0: Pushed
+cdd3de0940ab: Pushed
+fc56279bbb33: Pushed
+b38367233d37: Pushed
+2aebd096e0e2: Pushed
+latest: digest: sha256:fe4277621f10b5026266932ddf760f5a756d2facd505a94d2da12f4f52f71f5a size: 1568
+用 curl 查看仓库中的镜像。
$ curl 127.0.0.1:5000/v2/_catalog
+{"repositories":["ubuntu"]}
+这里可以看到 {"repositories":["ubuntu"]}，表明镜像已经被成功上传了。
先删除已有镜像，再尝试从私有仓库中下载这个镜像。
+$ docker image rm 127.0.0.1:5000/ubuntu:latest
+
+$ docker pull 127.0.0.1:5000/ubuntu:latest
+Pulling repository 127.0.0.1:5000/ubuntu:latest
+ba5877dc9bec: Download complete
+511136ea3c5a: Download complete
+9bad880da3d2: Download complete
+25f11f5fb0cb: Download complete
+ebc34468f71d: Download complete
+2318d26665ef: Download complete
+
+$ docker image ls
+REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
+127.0.0.1:5000/ubuntu:latest latest ba5877dc9bec 6 weeks ago 192.7 MB
+如果你不想使用 127.0.0.1:5000 作为仓库地址，比如想让本网段的其他主机也能把镜像推送到私有仓库。你就得把例如 192.168.199.100:5000 这样的内网地址作为私有仓库地址，这时你会发现无法成功推送镜像。
这是因为 Docker 默认不允许非 HTTPS 方式推送镜像。我们可以通过 Docker 的配置选项来取消这个限制，或者查看下一节配置能够通过 HTTPS 访问的私有仓库。
对于使用 systemd 的系统，请在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在请新建该文件）
{
+ "registry-mirror": [
+ "https://hub-mirror.c.163.com",
+ "https://mirror.baidubce.com"
+ ],
+ "insecure-registries": [
+ "192.168.199.100:5000"
+ ]
+}
+如果你想与我交换友链，可以在本页的评论区留言，或者通过邮件、或者提交GitHub Issue的方式。请按照以下格式提供你的站点信息，添加友链成功后我会通过回复评论的邮件通知你！
+
<!-- 必填项 -->
+name="站点名字"
+url="站点地址"
+logo="站点图标或个人头像"
+word="站点描述"
+欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+共享chatgpt免费账号，让你轻松体验最先进的聊天机器人。点击进入，立即注册，享受无限制的对话乐趣。🤖全网价格最低账号: 一只会飞的旺旺 (wangwangit.com) 点击直达访问
| ChatGPT账号 | 密码 |
|---|---|
| 4brelfbro@yunweiloginmh3.com | lin26870 |
| 6enmntfv1@yunweiloginmh3.com | he063479 |
| epn_f_6_f@yunweiloginmh3.com | hong8259 |
| aa9ugcyre@yunweiloginmh3.com | qi354035 |
| p8cwghjw0@yunweiloginmh3.com | zhong689 |
| 5y3td7igg@yunweiloginmh3.com | he530176 |
| ogvmp4xmf@yunweiloginmh3.com | fang5956 |
| oqnt8qkul@yunweiloginmh3.com | ban30108 |
| 3jal9z7bm@yunweiloginmh3.com | cheng465 |
| rqbcu71yx@yunweiloginmh3.com | ai046012 |
| elhqd6h2b@yunweiloginmh3.com | qu565909 |
| oqv-fii1j@yunweiloginmh3.com | jie26062 |
| kui5k5hms@yunweiloginmh3.com | ling3202 |
| thlgxss64@yunweiloginmh3.com | she90159 |
| cnc86yljh@yunweiloginmh3.com | wu062191 |
| tasfdsnta@yunweiloginmh3.com | bing8245 |
| si4mmza3x@yunweiloginmh3.com | hao46712 |
| n9kkoxavp@yunweiloginmh3.com | lei51372 |
| kqfsiu6pe@yunweiloginmh3.com | jing7026 |
共享chatgpt免费账号，让你轻松体验最先进的聊天机器人。点击进入，立即注册，享受无限制的对话乐趣。🤖全网价格最低账号: 一只会飞的旺旺 (wangwangit.com) 点击直达访问
| ChatGPT账号 | 密码 |
|---|---|
| 4brelfbro@yunweiloginmh3.com | lin26870 |
| 6enmntfv1@yunweiloginmh3.com | he063479 |
| epn_f_6_f@yunweiloginmh3.com | hong8259 |
| aa9ugcyre@yunweiloginmh3.com | qi354035 |
| p8cwghjw0@yunweiloginmh3.com | zhong689 |
| 5y3td7igg@yunweiloginmh3.com | he530176 |
| ogvmp4xmf@yunweiloginmh3.com | fang5956 |
| oqnt8qkul@yunweiloginmh3.com | ban30108 |
| 3jal9z7bm@yunweiloginmh3.com | cheng465 |
| rqbcu71yx@yunweiloginmh3.com | ai046012 |
| elhqd6h2b@yunweiloginmh3.com | qu565909 |
| oqv-fii1j@yunweiloginmh3.com | jie26062 |
| kui5k5hms@yunweiloginmh3.com | ling3202 |
| thlgxss64@yunweiloginmh3.com | she90159 |
| cnc86yljh@yunweiloginmh3.com | wu062191 |
| tasfdsnta@yunweiloginmh3.com | bing8245 |
| si4mmza3x@yunweiloginmh3.com | hao46712 |
| n9kkoxavp@yunweiloginmh3.com | lei51372 |
| kqfsiu6pe@yunweiloginmh3.com | jing7026 |
随着互联网浪潮的翻腾，国内外涌现出越来越多优秀的社交网站让用户分享信息更加便捷。然后，如果你是一个不甘寂寞的程序猿，是否也想要搭建一个属于自己的个人网站，如果你曾经或者现在正有这样的想法，请跟随这篇文章发挥你的Geek精神，让你快速拥有自己的博客网站，写文章记录生活，享受这种从0到1的过程。
首先我们需要一个Github账号,若是没有的话,可以前往官网注册一个,不懂的话,可以参考Github账号注册
什么是Git ?
简单来说Git是开源的分布式版本控制系统，用于敏捷高效地处理项目。我们网站在本地搭建好了，需要使用Git同步到GitHub上。
如果想要了解Git的细节，参看廖雪峰老师的Git教程：Git教程
从Git官网下载：Git - Downloading Package (git-scm.com)
现在的机子基本都是64位的，选择64位的安装包，下载后安装，在命令行里输入git测试是否安装成功，若安装失败，参看其他详细的Git安装教程。
安装成功后，将你的Git与GitHub帐号绑定，鼠标右击打开Git Bash
或者在菜单里搜索Git Bash，设置user.name和user.email配置信息：
git config --global user.name "你的GitHub用户名"git config --global user.email "你的GitHub注册邮箱"生成ssh密钥文件：
ssh-keygen -t rsa -C "你的GitHub注册邮箱"然后直接三个回车即可，默认不需要设置密码
然后找到生成的.ssh的文件夹中的id_rsa.pub密钥，将内容全部复制
打开SSH and GPG keys (github.com)页面，新建new SSH Key
Title为标题，任意填即可，将刚刚复制的id_rsa.pub内容粘贴进去，最后点击Add SSH key。
在Git Bash中检测GitHub公钥设置是否成功，输入 ssh git@github.com ：
如上则说明成功。这里之所以设置GitHub密钥原因是，通过非对称加密的公钥与私钥来完成加密，公钥放置在GitHub上，私钥放置在自己的电脑里。GitHub要求每次推送代码都是合法用户，所以每次推送都需要输入账号密码验证推送用户是否是合法用户，为了省去每次输入密码的步骤，采用了ssh，当你推送的时候，git就会匹配你的私钥跟GitHub上面的公钥是否是配对的，若是匹配就认为你是合法用户，则允许推送。这样可以保证每次的推送都是正确合法的。
Hexo基于Node.js，Node.js下载地址：Download | Node.js 下载安装包，注意安装Node.js会包含环境变量及npm的安装，安装后，检测Node.js是否安装成功，在命令行中输入 node -v :
检测npm是否安装成功，在命令行中输入npm -v :
到这了，安装Hexo的环境已经全部搭建完成。
打开https://github.com/，新建一个项目，如下所示：
然后如下图所示，输入自己的项目名字，后面一定要加.github.io后缀，README初始化也要勾上。名称一定要和你的github名字完全一样，比如你github名字叫abc，那么仓库名字一定要是abc.github.io
然后项目就建成了，点击Settings，向下拉到最后有个GitHub Pages，点击Choose a theme选择一个主题。然后等一会儿，再回到GitHub Pages，会变成下面这样：
点击那个链接，就会出现自己的网页啦，效果如下(我的是已经使用主题的页面,你们的页面可能不一样)：
Hexo就是我们的个人博客网站的框架， 这里需要自己在电脑常里创建一个文件夹，可以命名为Blog，Hexo框架与以后你自己发布的网页都在这个文件夹中。创建好后，进入文件夹中，按住shift键，右击鼠标点击命令行
使用npm命令安装Hexo，输入：
npm install -g hexo-cli 这个安装时间较长耐心等待，安装完成后，初始化我们的博客，输入：
hexo init blog注意，这里的命令都是作用在刚刚创建的Blog文件夹中。
为了检测我们的网站雏形，分别按顺序输入以下三条命令：
hexo new test_my_sitehexo ghexo s这些命令在后面作介绍，完成后，打开浏览器输入地址：
可以看出我们写出第一篇博客
Hexo常用命令
npm install hexo -g #安装Hexo
npm update hexo -g #升级
hexo init #初始化博客
命令简写
hexo n “我的博客” == hexo new “我的博客” #新建文章
hexo g == hexo generate #生成
hexo s == hexo server #启动服务预览
hexo d == hexo deploy #部署
hexo server #Hexo会监视文件变动并自动更新，无须重启服务器
hexo server -s #静态模式
hexo server -p 5000 #更改端口
hexo server -i 192.168.1.1 #自定义 IP
hexo clean #清除缓存，若是网页正常情况下可以忽略这条命令
刚刚的三个命令依次是新建一篇博客文章、生成网页、在本地预览的操作。
打开博客根目录下的_config.yml文件，这是博客的配置文件，在这里你可以修改与博客相关的各种信息。
修改最后一行的配置：
deploy:- type: git repository: https://github.com/wangwangit/wangwangit.github.io.git branch: masterrepository修改为你自己的github项目地址.
现在默认的域名还是xxx.github.io，是不是很没有牌面？想不想也像我一样弄一个专属域名呢，首先你得购买一个域名，xx云都能买，看你个人喜好了。
以我的谷歌域名为例，如下图所示，添加一条解析记录：
然后打开你的github博客项目，点击settings，拉到下面Custom domain处，填上你自己的域名，保存：
这时候你的项目根目录应该会出现一个名为CNAME的文件了。如果没有的话，打开你本地博客/source目录，我的是D:\study\program\blog\source，新建CNAME文件，注意没有后缀。然后在里面写上你的域名，保存。最后运行hexo g、hexo d上传到github
有时候我们想换一台电脑继续写博客，这时候就可以将博客目录下的所有源文件都上传到github上面。
首先在github博客仓库下新建一个分支hexo，然后git clone到本地，把.git文件夹拿出来，放在博客根目录下。
然后git checkout hexo切换到hexo分支，然后git add .，然后git commit -m "xxx"，最后git push origin hexo提交就行了。
我使用的主题是这个:博客主题
具体操作可以参考该主题的文档
对于图床使用可以参考我以下文章:
]]>随着互联网浪潮的翻腾，国内外涌现出越来越多优秀的社交网站让用户分享信息更加便捷。然后，如果你是一个不甘寂寞的程序猿，是否也想要搭建一个属于自己的个人网站，如果你曾经或者现在正有这样的想法，请跟随这篇文章发挥你的Geek精神，让你快速拥有自己的博客网站，写文章记录生活，享受这种从0到1的过程。
首先我们需要一个Github账号,若是没有的话,可以前往官网注册一个,不懂的话,可以参考Github账号注册
什么是Git ?
简单来说Git是开源的分布式版本控制系统，用于敏捷高效地处理项目。我们网站在本地搭建好了，需要使用Git同步到GitHub上。
如果想要了解Git的细节，参看廖雪峰老师的Git教程：Git教程
从Git官网下载：Git - Downloading Package (git-scm.com)
现在的机子基本都是64位的，选择64位的安装包，下载后安装，在命令行里输入git测试是否安装成功，若安装失败，参看其他详细的Git安装教程。
安装成功后，将你的Git与GitHub帐号绑定，鼠标右击打开Git Bash
或者在菜单里搜索Git Bash，设置user.name和user.email配置信息：
git config --global user.name "你的GitHub用户名"git config --global user.email "你的GitHub注册邮箱"生成ssh密钥文件：
ssh-keygen -t rsa -C "你的GitHub注册邮箱"然后直接三个回车即可，默认不需要设置密码
然后找到生成的.ssh的文件夹中的id_rsa.pub密钥，将内容全部复制
打开SSH and GPG keys (github.com)页面，新建new SSH Key
Title为标题，任意填即可，将刚刚复制的id_rsa.pub内容粘贴进去，最后点击Add SSH key。
在Git Bash中检测GitHub公钥设置是否成功，输入 ssh git@github.com ：
如上则说明成功。这里之所以设置GitHub密钥原因是，通过非对称加密的公钥与私钥来完成加密，公钥放置在GitHub上，私钥放置在自己的电脑里。GitHub要求每次推送代码都是合法用户，所以每次推送都需要输入账号密码验证推送用户是否是合法用户，为了省去每次输入密码的步骤，采用了ssh，当你推送的时候，git就会匹配你的私钥跟GitHub上面的公钥是否是配对的，若是匹配就认为你是合法用户，则允许推送。这样可以保证每次的推送都是正确合法的。
Hexo基于Node.js，Node.js下载地址：Download | Node.js 下载安装包，注意安装Node.js会包含环境变量及npm的安装，安装后，检测Node.js是否安装成功，在命令行中输入 node -v :
检测npm是否安装成功，在命令行中输入npm -v :
到这了，安装Hexo的环境已经全部搭建完成。
打开https://github.com/，新建一个项目，如下所示：
然后如下图所示，输入自己的项目名字，后面一定要加.github.io后缀，README初始化也要勾上。名称一定要和你的github名字完全一样，比如你github名字叫abc，那么仓库名字一定要是abc.github.io
然后项目就建成了，点击Settings，向下拉到最后有个GitHub Pages，点击Choose a theme选择一个主题。然后等一会儿，再回到GitHub Pages，会变成下面这样：
点击那个链接，就会出现自己的网页啦，效果如下(我的是已经使用主题的页面,你们的页面可能不一样)：
Hexo就是我们的个人博客网站的框架， 这里需要自己在电脑常里创建一个文件夹，可以命名为Blog，Hexo框架与以后你自己发布的网页都在这个文件夹中。创建好后，进入文件夹中，按住shift键，右击鼠标点击命令行
使用npm命令安装Hexo，输入：
npm install -g hexo-cli 这个安装时间较长耐心等待，安装完成后，初始化我们的博客，输入：
hexo init blog注意，这里的命令都是作用在刚刚创建的Blog文件夹中。
为了检测我们的网站雏形，分别按顺序输入以下三条命令：
hexo new test_my_sitehexo ghexo s这些命令在后面作介绍，完成后，打开浏览器输入地址：
可以看出我们写出第一篇博客
Hexo常用命令
npm install hexo -g #安装Hexo
npm update hexo -g #升级
hexo init #初始化博客
命令简写
hexo n “我的博客” == hexo new “我的博客” #新建文章
hexo g == hexo generate #生成
hexo s == hexo server #启动服务预览
hexo d == hexo deploy #部署
hexo server #Hexo会监视文件变动并自动更新，无须重启服务器
hexo server -s #静态模式
hexo server -p 5000 #更改端口
hexo server -i 192.168.1.1 #自定义 IP
hexo clean #清除缓存，若是网页正常情况下可以忽略这条命令
刚刚的三个命令依次是新建一篇博客文章、生成网页、在本地预览的操作。
打开博客根目录下的_config.yml文件，这是博客的配置文件，在这里你可以修改与博客相关的各种信息。
修改最后一行的配置：
deploy:- type: git repository: https://github.com/wangwangit/wangwangit.github.io.git branch: masterrepository修改为你自己的github项目地址.
现在默认的域名还是xxx.github.io，是不是很没有牌面？想不想也像我一样弄一个专属域名呢，首先你得购买一个域名，xx云都能买，看你个人喜好了。
以我的谷歌域名为例，如下图所示，添加一条解析记录：
然后打开你的github博客项目，点击settings，拉到下面Custom domain处，填上你自己的域名，保存：
这时候你的项目根目录应该会出现一个名为CNAME的文件了。如果没有的话，打开你本地博客/source目录，我的是D:\study\program\blog\source，新建CNAME文件，注意没有后缀。然后在里面写上你的域名，保存。最后运行hexo g、hexo d上传到github
有时候我们想换一台电脑继续写博客，这时候就可以将博客目录下的所有源文件都上传到github上面。
首先在github博客仓库下新建一个分支hexo，然后git clone到本地，把.git文件夹拿出来，放在博客根目录下。
然后git checkout hexo切换到hexo分支，然后git add .，然后git commit -m "xxx"，最后git push origin hexo提交就行了。
我使用的主题是这个:博客主题
具体操作可以参考该主题的文档
对于图床使用可以参考我以下文章:
]]>自从 2019年左右接触到 Markdown 以来，对它的使用就一发而不可收拾。从最开始使用它在 GitHub Pages 里写博客，到用它编辑项目的 README 文件，再到撰写开发文档，编辑微信公众号文章和邮件内容等等，这期间也见证了它在各类平台和网站上的普及和被原生支持，可以说，Markdown 如今已经渗透了我在技术和网络活动的方方面面，成为了我撰写文本文档的首选。
那么首先我们一起来看一下它的「定义」：
Markdown 是一种轻量级标记语言，创始人为 John Gruber。它允许人们「使用易读易写的纯文本格式编写文档，然后转换成有效的 XHTML（或者 HTML）文档」。——维基百科
本文档的目的不在于面面俱到地介绍 Markdown，只是作为我对其理解的笔记整理，希望能同时帮助一些对 Markdown 感兴趣的人快速上手，或是作为一个工具，供对其已经有所了解的人在需要时参考。
接下来请随我一起深入了解这门并不神秘的实用标记语言。
专注于文字内容；
纯文本，易读易写，可以方便地纳入版本控制；
语法简单，没有什么学习成本，能轻松在码字的同时做出美观大方的排版。
各类代码托管平台
主流的代码托管平台，如 GitHub、GitLab、BitBucket、Coding、Gitee 等等，都支持 Markdown 语法，很多开源项目的 README、开发文档、帮助文档、Wiki 等都用 Markdown 写作。
技术社区和写作平台
StackOverflow、CSDN、掘金、简书、GitBook、有道云笔记
论坛
V2EX、光谷社区
个人感觉比较遗憾的一点是各平台可能采用不同语言实现的 Markdown 解析引擎，或采用同一解析引擎的不同版本，而且可能有不同程度的定制与扩展，这导致在不同平台上使用 Markdown 写作时体验并不完全一致。不过幸好对于大家公认的一些标准语法，各家都是支持的。
理论上任何一款文本编辑器都能用于编辑 Markdown 文档，它们分别提供了不同程度的语法高亮、预览等功能，以下只是列举其中一部分，选择自己称手的即可。
现代编辑器
VSCode / Atom
传统编辑器
Vim / Emacs / Sublime Text / Notepad++
IDE 自带编辑器
IntelliJ IDEA / Android Studio / WebStorm
专用编辑器
Ulysses / Mou / Typora / Markpad
在线编辑器
各种支持 Markdown 的网站都提供了在线编辑器
Markdown：
# atx-style 一级标题## 二级标题###### 六级标题Setext-style 一级标题===二级标题---预览效果：
atx-style 一级标题
二级标题
六级标题
Setext-style 一级标题
二级标题
对应 HTML：
<h1>atx-style 一级标题</h1><h2>二级标题</h2><h6>六级标题</h6><h1>Setext-style 一级标题</h1><h2>二级标题</h2>中间没有空行的连续不断的几行文字被视为一个段落。
Markdown：
白日依山尽，黄河入海流。（句号后面没空格）欲穷千里目，更上一层楼。 （句号后面有俩空格）预览效果：
白日依山尽，
黄河入海流。
（句号后面没空格）
欲穷千里目，
更上一层楼。
（句号后面有俩空格）
对应 HTML：
<p>白日依山尽，</p><p>黄河入海流。（句号后面没有空格）</p><p>欲穷千里目，</p><p> 更上一层楼。 <br> （句号后面有俩空格）</p>对段落或者部分文本的强调效果。
Markdown：
后面俩字**加黑**后面俩字*斜体*预览效果：
后面俩字加黑
后面俩字斜体
对应 HTML：
<p> 后面俩字 <strong>加黑</strong></p><p> 后面俩字 <em>斜体</em></p>Markdown：
> 引用块段落一。>> 引用块段落二。>> 内嵌引用块段落一。>> ### 引用块内的标题预览效果：
引用块段落一。
引用块段落二。
内嵌引用块段落一。
引用块内的标题
对应 HTML：
<blockquote> <p>引用块段落一。</p> <p>引用块段落二。</p> <blockquote> <p>内嵌引用块段落一。</p> </blockquote> <h3 id="引用块内的标题">引用块内的标题</h3></blockquote>Markdown 支持行内式链接和引用式链接。
Markdown：
行内式 [博客](https://mazhuang.org "我的个人博客") 链接，带 title。行内式 [GitHub](https://github.com/mzlogin) 链接。引用式 [博客][1] 链接。引用式 [GitHub][2] 链接，带 title。[1]: https://www.wangwangit.com[2]: https://github.com/wangwangit "我的 GitHub 主页"预览效果：
行内式 博客 链接，带 title。
行内式 GitHub 链接。
引用式 博客 链接。
引用式 GitHub 链接，带 title。
对应 HTML：
<p>行内式 <a href="https://www.wangwangit.com" title="我的个人博客">博客</a> 链接，带 title。</p><p>行内式 <a href="https://github.com/wangwangit">GitHub</a> 链接。</p><p>引用式 <a href="https://www.wangwangit.com">博客</a> 链接。</p><p>引用式 <a href="https://github.com/wangwangit" title="我的 GitHub 主页">GitHub</a> 链接，带 title。</p>在超链接的写法前加一个 !，就是引用图片的方法。
Markdown：
预览效果：
对应 HTML：
<img src="https://avatars.githubusercontent.com/u/22621145?v=4" alt="Alt text" title="favicon">包括有序列表和无序列表。
Markdown：
- 苹果- 葡萄- 榴莲1. 苹果2. 葡萄3. 榴莲预览效果：
对应 HTML：
<ul> <li>苹果</li> <li>葡萄</li> <li>榴莲</li></ul><ol> <li>苹果</li> <li>葡萄</li> <li>榴莲</li></ol>其中无序列表的标记可以使用 +、- 或 *，有序列表前的数字可以是乱序的。
支持行内代码和代码块。
Markdown：
Android 里使用 `TextUtils` 类的 `isEmpty` 方法来判断字符串是否为空。```javaif (TextUtils.isEmpty(text)) { return null;}```预览效果：
Android 里使用 TextUtils 类的 isEmpty 方法来判断字符串是否为空。
if (TextUtils.isEmpty(text)) { return null;}对应 HTML：
<p>Android 里使用 <code>TextUtils</code> 类的 <code>isEmpty</code> 方法来判断字符串是否为空。</p><div class="highlight highlight-source-java"><pre><span class="pl-k">if</span> (<span class="pl-smi">TextUtils</span><span class="pl-k">.</span>isEmpty(text)) { <span class="pl-k">return</span> <span class="pl-c1">null</span>;}</pre></div>上例中的语言标记 java 可选填，可用于在编辑器和渲染后的效果里添加语法高亮。
块式代码也可以对整个代码段缩进四个空格，或一个 Tab 来实现。
使用一个单独行里的三个或以上 *、- 来生产一条水平分割线，它们之间可以有空格。
Markdown：
***------ - -预览效果：
对应 HTML：
<hr /><hr /><hr />Markdown 标记语言的目的不是替代 HTML，也不是发明一种更便捷的插入 HTML 标签的方式。它对应的只是 HTML 标签的一个很小的子集。
对于那些没有办法用 Markdown 语法来对应的 HTML 标签，直接使用 HTML 来写就好了。
本节的内容是介绍一些受到广泛支持的 Markdown 扩展语法。
Markdown：
| 编号 | 姓名（左） | 年龄（右） | 性别（中） || ----- | :-------- | ---------: | :------: || 0 | 张三 | 28 | 男 || 1 | 李四 | 29 | 男 |预览效果：
| 编号 | 姓名（左） | 年龄（右） | 性别（中） |
|---|---|---|---|
| 0 | 张三 | 28 | 男 |
| 1 | 李四 | 29 | 男 |
对应 HTML：
<table> <thead> <tr> <th>编号</th> <th align="left">姓名（左）</th> <th align="right">年龄（右）</th> <th align="center">性别（中）</th> </tr> </thead> <tbody> <tr> <td>0</td> <td align="left">张三</td> <td align="right">28</td> <td align="center">男</td> </tr> <tr> <td>1</td> <td align="left">李四</td> <td align="right">29</td> <td align="center">男</td> </tr> </tbody></table>在 GitHub / GitLab 里有较好的支持。
Markdown：
- [x] 洗碗- [ ] 清洗油烟机- [ ] 拖地预览效果：
对应 HTML：
<ul class="contains-task-list"> <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox" checked=""> 洗碗</li> <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox"> 清洗油烟机</li> <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox"> 拖地</li></ul>如果是在 GitHub / GitLab 的 Issue 里，会附赠任务完成比例提示效果：
还可以直接在网页上拖动调整顺序，勾选和取消勾选。
Markdown：
后面三个字打上~~删除线~~。预览效果：
后面三个字打上删除线。
对应 HTML：
<p>后面三个字打上<del>删除线</del>。</p>自动链接扩展，即：当识别到 URL，或用 <、> 包括的 URL 时，会自动为其生成 a 标签。
Markdown：
https://github.com<example@gmail.com>预览效果：
对应 HTML：
<p><a href="https://github.com">https://github.com</a></p><p><a href="mailto:example@gmail.com">example@gmail.com</a></p>以 GitHub Pages 为例。
Markdown：
:camel: :blush: :smile:预览效果：
:camel: :blush: :smile:
对应 HTML：
<p> <img class="emoji" title=":camel:" alt=":camel:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f42b.png" height="20" width="20"> <img class="emoji" title=":blush:" alt=":blush:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f60a.png" height="20" width="20"> <img class="emoji" title=":smile:" alt=":smile:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f604.png" height="20" width="20"></p>脑洞清奇的工程师们还发掘了很多使用 Markdown 的方法，大部分都是引入第三方 JavaScript 插件来实现。对这部分我只做简述，对其中的部分功能比如作图等，还是推荐用专门的可视化工具去做。
有部分网站和编辑器实现了对 Markdown 里流程图和时序图的支持，比如我们使用的项目管理工具 TAPD 的在线编辑器，还有 VSCode + 插件 Markdown Preview Enhanced 等。
以我们使用的项目管理工具 TAPD 的在线编辑器为例：
仍然以 TAPD 为例：
应该是利用 JavaScript 支持了 LaTeX 公式语法。
有专门的工具 Marp，另外使用 VSCode + 插件 Markdown Preview Enhanced 也可以实现。
可以将公众号素材用 Markdown 编辑好后，贴到在线排版工具以后，复制到公众号编辑器里即可。有多种页面主题和代码主题可选择。
想象力丰富的工程师们还扩展了很多基于 Markdown 的玩法，包括但不限于：
以上功能基本都可以用 VSCode + 插件 Markdown Preview Enhanced 实现。
自从 2019年左右接触到 Markdown 以来，对它的使用就一发而不可收拾。从最开始使用它在 GitHub Pages 里写博客，到用它编辑项目的 README 文件，再到撰写开发文档，编辑微信公众号文章和邮件内容等等，这期间也见证了它在各类平台和网站上的普及和被原生支持，可以说，Markdown 如今已经渗透了我在技术和网络活动的方方面面，成为了我撰写文本文档的首选。
那么首先我们一起来看一下它的「定义」：
Markdown 是一种轻量级标记语言，创始人为 John Gruber。它允许人们「使用易读易写的纯文本格式编写文档，然后转换成有效的 XHTML（或者 HTML）文档」。——维基百科
本文档的目的不在于面面俱到地介绍 Markdown，只是作为我对其理解的笔记整理，希望能同时帮助一些对 Markdown 感兴趣的人快速上手，或是作为一个工具，供对其已经有所了解的人在需要时参考。
接下来请随我一起深入了解这门并不神秘的实用标记语言。
专注于文字内容；
纯文本，易读易写，可以方便地纳入版本控制；
语法简单，没有什么学习成本，能轻松在码字的同时做出美观大方的排版。
各类代码托管平台
主流的代码托管平台，如 GitHub、GitLab、BitBucket、Coding、Gitee 等等，都支持 Markdown 语法，很多开源项目的 README、开发文档、帮助文档、Wiki 等都用 Markdown 写作。
技术社区和写作平台
StackOverflow、CSDN、掘金、简书、GitBook、有道云笔记
论坛
V2EX、光谷社区
个人感觉比较遗憾的一点是各平台可能采用不同语言实现的 Markdown 解析引擎，或采用同一解析引擎的不同版本，而且可能有不同程度的定制与扩展，这导致在不同平台上使用 Markdown 写作时体验并不完全一致。不过幸好对于大家公认的一些标准语法，各家都是支持的。
理论上任何一款文本编辑器都能用于编辑 Markdown 文档，它们分别提供了不同程度的语法高亮、预览等功能，以下只是列举其中一部分，选择自己称手的即可。
现代编辑器
VSCode / Atom
传统编辑器
Vim / Emacs / Sublime Text / Notepad++
IDE 自带编辑器
IntelliJ IDEA / Android Studio / WebStorm
专用编辑器
Ulysses / Mou / Typora / Markpad
在线编辑器
各种支持 Markdown 的网站都提供了在线编辑器
Markdown：
# atx-style 一级标题## 二级标题###### 六级标题Setext-style 一级标题===二级标题---预览效果：
atx-style 一级标题
二级标题
六级标题
Setext-style 一级标题
二级标题
对应 HTML：
<h1>atx-style 一级标题</h1><h2>二级标题</h2><h6>六级标题</h6><h1>Setext-style 一级标题</h1><h2>二级标题</h2>中间没有空行的连续不断的几行文字被视为一个段落。
Markdown：
白日依山尽，黄河入海流。（句号后面没空格）欲穷千里目，更上一层楼。 （句号后面有俩空格）预览效果：
白日依山尽，
黄河入海流。
（句号后面没空格）
欲穷千里目，
更上一层楼。
（句号后面有俩空格）
对应 HTML：
<p>白日依山尽，</p><p>黄河入海流。（句号后面没有空格）</p><p>欲穷千里目，</p><p> 更上一层楼。 <br> （句号后面有俩空格）</p>对段落或者部分文本的强调效果。
Markdown：
后面俩字**加黑**后面俩字*斜体*预览效果：
后面俩字加黑
后面俩字斜体
对应 HTML：
<p> 后面俩字 <strong>加黑</strong></p><p> 后面俩字 <em>斜体</em></p>Markdown：
> 引用块段落一。>> 引用块段落二。>> 内嵌引用块段落一。>> ### 引用块内的标题预览效果：
引用块段落一。
引用块段落二。
内嵌引用块段落一。
引用块内的标题
对应 HTML：
<blockquote> <p>引用块段落一。</p> <p>引用块段落二。</p> <blockquote> <p>内嵌引用块段落一。</p> </blockquote> <h3 id="引用块内的标题">引用块内的标题</h3></blockquote>Markdown 支持行内式链接和引用式链接。
Markdown：
行内式 [博客](https://mazhuang.org "我的个人博客") 链接，带 title。行内式 [GitHub](https://github.com/mzlogin) 链接。引用式 [博客][1] 链接。引用式 [GitHub][2] 链接，带 title。[1]: https://www.wangwangit.com[2]: https://github.com/wangwangit "我的 GitHub 主页"预览效果：
行内式 博客 链接，带 title。
行内式 GitHub 链接。
引用式 博客 链接。
引用式 GitHub 链接，带 title。
对应 HTML：
<p>行内式 <a href="https://www.wangwangit.com" title="我的个人博客">博客</a> 链接，带 title。</p><p>行内式 <a href="https://github.com/wangwangit">GitHub</a> 链接。</p><p>引用式 <a href="https://www.wangwangit.com">博客</a> 链接。</p><p>引用式 <a href="https://github.com/wangwangit" title="我的 GitHub 主页">GitHub</a> 链接，带 title。</p>在超链接的写法前加一个 !，就是引用图片的方法。
Markdown：
预览效果：
对应 HTML：
<img src="https://avatars.githubusercontent.com/u/22621145?v=4" alt="Alt text" title="favicon">包括有序列表和无序列表。
Markdown：
- 苹果- 葡萄- 榴莲1. 苹果2. 葡萄3. 榴莲预览效果：
对应 HTML：
<ul> <li>苹果</li> <li>葡萄</li> <li>榴莲</li></ul><ol> <li>苹果</li> <li>葡萄</li> <li>榴莲</li></ol>其中无序列表的标记可以使用 +、- 或 *，有序列表前的数字可以是乱序的。
支持行内代码和代码块。
Markdown：
Android 里使用 `TextUtils` 类的 `isEmpty` 方法来判断字符串是否为空。```javaif (TextUtils.isEmpty(text)) { return null;}```预览效果：
Android 里使用 TextUtils 类的 isEmpty 方法来判断字符串是否为空。
if (TextUtils.isEmpty(text)) { return null;}对应 HTML：
<p>Android 里使用 <code>TextUtils</code> 类的 <code>isEmpty</code> 方法来判断字符串是否为空。</p><div class="highlight highlight-source-java"><pre><span class="pl-k">if</span> (<span class="pl-smi">TextUtils</span><span class="pl-k">.</span>isEmpty(text)) { <span class="pl-k">return</span> <span class="pl-c1">null</span>;}</pre></div>上例中的语言标记 java 可选填，可用于在编辑器和渲染后的效果里添加语法高亮。
块式代码也可以对整个代码段缩进四个空格，或一个 Tab 来实现。
使用一个单独行里的三个或以上 *、- 来生产一条水平分割线，它们之间可以有空格。
Markdown：
***------ - -预览效果：
对应 HTML：
<hr /><hr /><hr />Markdown 标记语言的目的不是替代 HTML，也不是发明一种更便捷的插入 HTML 标签的方式。它对应的只是 HTML 标签的一个很小的子集。
对于那些没有办法用 Markdown 语法来对应的 HTML 标签，直接使用 HTML 来写就好了。
本节的内容是介绍一些受到广泛支持的 Markdown 扩展语法。
Markdown：
| 编号 | 姓名（左） | 年龄（右） | 性别（中） || ----- | :-------- | ---------: | :------: || 0 | 张三 | 28 | 男 || 1 | 李四 | 29 | 男 |预览效果：
| 编号 | 姓名（左） | 年龄（右） | 性别（中） |
|---|---|---|---|
| 0 | 张三 | 28 | 男 |
| 1 | 李四 | 29 | 男 |
对应 HTML：
<table> <thead> <tr> <th>编号</th> <th align="left">姓名（左）</th> <th align="right">年龄（右）</th> <th align="center">性别（中）</th> </tr> </thead> <tbody> <tr> <td>0</td> <td align="left">张三</td> <td align="right">28</td> <td align="center">男</td> </tr> <tr> <td>1</td> <td align="left">李四</td> <td align="right">29</td> <td align="center">男</td> </tr> </tbody></table>在 GitHub / GitLab 里有较好的支持。
Markdown：
- [x] 洗碗- [ ] 清洗油烟机- [ ] 拖地预览效果：
对应 HTML：
<ul class="contains-task-list"> <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox" checked=""> 洗碗</li> <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox"> 清洗油烟机</li> <li class="task-list-item"><input type="checkbox" id="" disabled="" class="task-list-item-checkbox"> 拖地</li></ul>如果是在 GitHub / GitLab 的 Issue 里，会附赠任务完成比例提示效果：
还可以直接在网页上拖动调整顺序，勾选和取消勾选。
Markdown：
后面三个字打上~~删除线~~。预览效果：
后面三个字打上删除线。
对应 HTML：
<p>后面三个字打上<del>删除线</del>。</p>自动链接扩展，即：当识别到 URL，或用 <、> 包括的 URL 时，会自动为其生成 a 标签。
Markdown：
https://github.com<example@gmail.com>预览效果：
对应 HTML：
<p><a href="https://github.com">https://github.com</a></p><p><a href="mailto:example@gmail.com">example@gmail.com</a></p>以 GitHub Pages 为例。
Markdown：
:camel: :blush: :smile:预览效果：
:camel: :blush: :smile:
对应 HTML：
<p> <img class="emoji" title=":camel:" alt=":camel:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f42b.png" height="20" width="20"> <img class="emoji" title=":blush:" alt=":blush:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f60a.png" height="20" width="20"> <img class="emoji" title=":smile:" alt=":smile:" src="https://assets-cdn.github.com/images/icons/emoji/unicode/1f604.png" height="20" width="20"></p>脑洞清奇的工程师们还发掘了很多使用 Markdown 的方法，大部分都是引入第三方 JavaScript 插件来实现。对这部分我只做简述，对其中的部分功能比如作图等，还是推荐用专门的可视化工具去做。
有部分网站和编辑器实现了对 Markdown 里流程图和时序图的支持，比如我们使用的项目管理工具 TAPD 的在线编辑器，还有 VSCode + 插件 Markdown Preview Enhanced 等。
以我们使用的项目管理工具 TAPD 的在线编辑器为例：
仍然以 TAPD 为例：
应该是利用 JavaScript 支持了 LaTeX 公式语法。
有专门的工具 Marp，另外使用 VSCode + 插件 Markdown Preview Enhanced 也可以实现。
可以将公众号素材用 Markdown 编辑好后，贴到在线排版工具以后，复制到公众号编辑器里即可。有多种页面主题和代码主题可选择。
想象力丰富的工程师们还扩展了很多基于 Markdown 的玩法，包括但不限于：
以上功能基本都可以用 VSCode + 插件 Markdown Preview Enhanced 实现。
+
+ 在运行 sh 脚本时提示“/bin/bash^M: bad interpreter: Text file busy”，这个问题通常是由于 Windows 和 Unix/Linux 操作系统之间的换行符差异导致的。
+1.安装dos2unix工具
+sudo apt-get update
+sudo apt-get install dos2unix
+sudo yum install dos2unix
+2.执行命令,转换脚本
+dos2unix start.sh
+欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+
+
+ 欢迎来到我的世界! 一键进群
+
+
+ 在企业级开发中、我们经常会有编写数据库表结构文档的时间付出，从业以来，待过几家企业，关于数据库表结构文档状态：要么没有、要么有、但都是手写、后期运维开发，需要手动进行维护到文档中，很是繁琐、如果忘记一次维护、就会给以后工作造成很多困扰、无形中制造了很多坑留给自己和后人，于是需要一个插件工具screw来维护。
+
+ <dependency>
+ <groupId>cn.smallbun.screw</groupId>
+ <artifactId>screw-core</artifactId>
+ <version>${lastVersion}</version>
+ </dependency>
+/**
+ * 文档生成
+ */
+void documentGeneration() {
+ //数据源
+ HikariConfig hikariConfig = new HikariConfig();
+ hikariConfig.setDriverClassName("com.mysql.cj.jdbc.Driver");
+ hikariConfig.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/database");
+ hikariConfig.setUsername("root");
+ hikariConfig.setPassword("password");
+ //设置可以获取tables remarks信息
+ hikariConfig.addDataSourceProperty("useInformationSchema", "true");
+ hikariConfig.setMinimumIdle(2);
+ hikariConfig.setMaximumPoolSize(5);
+ DataSource dataSource = new HikariDataSource(hikariConfig);
+ //生成配置
+ EngineConfig engineConfig = EngineConfig.builder()
+ //生成文件路径
+ .fileOutputDir(fileOutputDir)
+ //打开目录
+ .openOutputDir(true)
+ //文件类型
+ .fileType(EngineFileType.HTML)
+ //生成模板实现
+ .produceType(EngineTemplateType.freemarker)
+ //自定义文件名称
+ .fileName("自定义文件名称").build();
+
+ //忽略表
+ ArrayList<String> ignoreTableName = new ArrayList<>();
+ ignoreTableName.add("test_user");
+ ignoreTableName.add("test_group");
+ //忽略表前缀
+ ArrayList<String> ignorePrefix = new ArrayList<>();
+ ignorePrefix.add("test_");
+ //忽略表后缀
+ ArrayList<String> ignoreSuffix = new ArrayList<>();
+ ignoreSuffix.add("_test");
+ ProcessConfig processConfig = ProcessConfig.builder()
+ //指定生成逻辑、当存在指定表、指定表前缀、指定表后缀时，将生成指定表，其余表不生成、并跳过忽略表配置
+ //根据名称指定表生成
+ .designatedTableName(new ArrayList<>())
+ //根据表前缀生成
+ .designatedTablePrefix(new ArrayList<>())
+ //根据表后缀生成
+ .designatedTableSuffix(new ArrayList<>())
+ //忽略表名
+ .ignoreTableName(ignoreTableName)
+ //忽略表前缀
+ .ignoreTablePrefix(ignorePrefix)
+ //忽略表后缀
+ .ignoreTableSuffix(ignoreSuffix).build();
+ //配置
+ Configuration config = Configuration.builder()
+ //版本
+ .version("1.0.0")
+ //描述
+ .description("数据库设计文档生成")
+ //数据源
+ .dataSource(dataSource)
+ //生成配置
+ .engineConfig(engineConfig)
+ //生成配置
+ .produceConfig(processConfig)
+ .build();
+ //执行生成
+ new DocumentationExecute(config).execute();
+}
+<build>
+ <plugins>
+ <plugin>
+ <groupId>cn.smallbun.screw</groupId>
+ <artifactId>screw-maven-plugin</artifactId>
+ <version>${lastVersion}</version>
+ <dependencies>
+ <!-- HikariCP -->
+ <dependency>
+ <groupId>com.zaxxer</groupId>
+ <artifactId>HikariCP</artifactId>
+ <version>3.4.5</version>
+ </dependency>
+ <!--mysql driver-->
+ <dependency>
+ <groupId>mysql</groupId>
+ <artifactId>mysql-connector-java</artifactId>
+ <version>8.0.20</version>
+ </dependency>
+ </dependencies>
+ <configuration>
+ <!--username-->
+ <username>root</username>
+ <!--password-->
+ <password>password</password>
+ <!--driver-->
+ <driverClassName>com.mysql.cj.jdbc.Driver</driverClassName>
+ <!--jdbc url-->
+ <jdbcUrl>jdbc:mysql://127.0.0.1:3306/xxxx</jdbcUrl>
+ <!--生成文件类型-->
+ <fileType>HTML</fileType>
+ <!--打开文件输出目录-->
+ <openOutputDir>false</openOutputDir>
+ <!--生成模板-->
+ <produceType>freemarker</produceType>
+ <!--文档名称 为空时:将采用[数据库名称-描述-版本号]作为文档名称-->
+ <fileName>测试文档名称</fileName>
+ <!--描述-->
+ <description>数据库文档生成</description>
+ <!--版本-->
+ <version>${project.version}</version>
+ <!--标题-->
+ <title>数据库文档</title>
+ </configuration>
+ <executions>
+ <execution>
+ <phase>compile</phase>
+ <goals>
+ <goal>run</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+</build>
+在我们的日常生活中，我们可能会遇到需要使用临时邮箱或接码服务的情况。这些服务可以帮助我们保护个人信息，避免垃圾邮件和不必要的骚扰。以下是一些值得推荐的临时邮箱和接码平台：
+TrashMail - 英文，可自定义地址，可以限制转发次数和有效期。到期自动销毁。
+请谨慎使用！号码公用，收到的信息是公开的。
+ +以上是我们为您推荐的一些临时邮箱和接码平台，希望它们能在您需要的时候提供帮助。请注意，使用这些服务时应遵守所有适用的法律和规定。
+请合理使用，保护好您的隐私！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 1.当标记了@Transactional注解的方法中出现异常时,如果该异常未传播到该方法外,则事务不会回滚,反之,只有异常传播到该方法外,事务才会回滚
+错误示例:
+// 异常被try-catch了
+@Override
+@Transactional
+public Result firstFunctionAboutException() {
+ try{
+ log.info("减库存开始");
+ goodsStockMapper.updateStock();
+ if(1 == 1) throw new RuntimeException();
+ return Result.ok();
+ }catch (Exception e){
+ log.info("减库存失败！" + e.getMessage());
+ return Result.server_error().Message("减库存失败！" + e.getMessage());
+ }
+}
+正确示例:
+@Override
+@Transactional
+public void secondFunctionAboutException() {
+ log.info("减库存开始");
+ goodsStockMapper.updateStock();
+ if(1 == 1) throw new RuntimeException();
+}
+2.默认情况下,如果我们抛出的不是RuntimeException时,事务不会回滚,需要手动抛出RuntimeException异常或者修改@Transactional注解默认配置
+错误示例
+@Override
+@Transactional
+public void thirdFunctionAboutException() throws Exception {
+ log.info("减库存开始");
+ goodsStockMapper.updateStock();
+ if(1 == 1) throw new Exception();
+}
+正确示例
+// 抛出RuntimeException
+@Override
+@Transactional
+public void thirdFunctionAboutException1(){
+ try{
+ log.info("减库存开始");
+ goodsStockMapper.updateStock();
+ if(1 == 1) throw new Exception();
+ }catch (Exception e){
+ log.info("出现异常"+e.getMessage());
+ throw new RuntimeException("手动抛出RuntimeException");
+ }
+}
+
+// 指定回滚异常
+@Override
+@Transactional(rollbackFor = Exception.class)
+public void thirdFunctionAboutException2() throws Exception {
+ log.info("减库存开始");
+ goodsStockMapper.updateStock();
+ if(1 == 1) throw new Exception();
+}
+3.被注解的方法必须是public的,且必须由注入bean来直接调用才能事务回滚
+错误示例
+//在普通方法中调用事务方法
+@Override
+public void privateFunctionCaller (){
+ privateCallee();
+}
+
+// 使用private修饰
+@Transactional
+private void privateCallee(){
+ goodsStockMapper.updateStock();
+ throw new RuntimeException();
+}
+正确示例
+@Override
+@Transactional
+public void publicCallee(){
+ goodsStockMapper.updateStock();
+ throw new RuntimeException();
+}
+
+// 使用自身service调用,或者将两个方法放置于不同的service
+@Autowired
+private GoodsStockService self;
+
+@Override
+public void aopSelfCaller (){
+ self.publicCallee();
+}
+最近研读《人月神话》是一次思想的洗礼，它超越了时代和技术局限，为软件开发提供了永恒的洞见。本书的核心并不在于技术细节，而是对软件开发本质的深刻理解，以及对团队管理、协作和沟通的哲学思考。
+布鲁克斯提出的“人月神话”并非单纯的理论，而是 Java 开发中切实存在的现象。盲目增加人力只会加剧项目复杂性，导致沟通成本飙升、协作困难，最终延长开发周期。开发者需要认识到这种资源悖论，将精力放在提升团队整体效率，而非简单的人力堆砌。
+清晰、简洁、可扩展的架构是 项目成功的基石。布鲁克斯强调的“整体性”和“概念完整性”原则，指导着架构师和开发者进行设计。良好的架构不仅能降低后期的维护成本，还能为团队协作提供坚实的基础。开发者应致力于构建可维护、可扩展的架构，而非依赖人力的补丁和临时解决方案。
+面对庞大的代码库和复杂的业务逻辑， 团队成员之间的沟通协作变得至关重要。布鲁克斯提出的“外科手术团队”模式，强调团队成员之间共同的目标、清晰的职责分工和高效的沟通机制。引入结对编程、代码评审、敏捷开发等实践，可以提升团队协作效率，减少返工和错误，推动项目顺利交付。
+需求的不断变化是开发的常态。布鲁克斯提倡的“原型先行”理念，鼓励开发者通过快速迭代和试错来验证需求和设计方案的可行性。敏捷开发方法的引入，让开发者能够拥抱不确定性，快速交付可运行的版本，并根据用户的反馈不断改进，最终构建适应性强的系统。
+正如布鲁克斯所言，软件开发最终是由人来完成的。优秀的 Java 开发团队不仅需要过硬的技术能力，还需要良好的团队文化、学习氛围和协作精神。重视个人能力培养，打造高效的知识共享和学习机制，鼓励成员之间的相互支持和创新，才能真正提升团队的战斗力。
+从哲学层面理解软件开发
+《人月神话》的价值不仅在于具体的技术实践，更在于其所传递的哲学思考。它提醒 Java 开发者，成功不仅取决于技术本身，更取决于对复杂性的理解、对架构和团队的重视以及对不确定性的拥抱。Java 开发者唯有跳出技术细节的层面，从哲学的高度理解软件开发的本质，才能在瞬息万变的软件世界中取得长足的进步。
+书籍下载: 人月神话
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 微服务是一种软件架构风格，它将一个应用程序分解为一组小型、独立的服务，这些服务可以通过轻量级的机制（通常是HTTP资源API）进行通信。每个服务都围绕业务能力构建，并且可以通过完全自动化的部署机制独立部署和扩展。这些服务之间的管理是最小化的，甚至可以使用不同的编程语言和数据存储技术。
+围绕业务能力构建（Organized around Business Capability）
+这里再次强调了康威定律的重要性，有怎样结构、规模、能力的团队，就会产生对应结构、规模、能力的产品。这个结论不是某个团队、某个公司遇到的巧合，而是必然的演化结果。如果本应该归属同一个产品内的功能被划分在不同团队中，必然会产生大量的跨团队沟通协作，而跨越团队边界无论在管理、沟通、工作安排上都有更高昂的成本，因此高效的团队自然会针对其进行改进，当团队、产品磨合稳定之后，团队与产品就会拥有一致的结构。
+分散治理（Decentralized Governance）
+这里是指服务对应的开发团队有直接对服务运行质量负责的责任，也有不受外界干预地掌控服务各个方面的权力，譬如选择与其他服务异构的技术来实现自己的服务。这一点在真正实践时多少存有宽松的处理余地，大多数公司都不会在某一个服务使用Java，另一个服务用Python，再下一个服务用Go，而是通常会用统一的主流语言，乃至统一的技术栈或专有的技术平台。微服务不提倡也并不反对这种“统一”，只要负责提供和维护基础技术栈的团队有被各方依赖的觉悟，有“经常被凌晨3点的闹钟吵醒”的心理准备就好。微服务更加强调的是在确实需要技术异构时，应能够有选择“不统一”的权利，譬如不应该强迫Node.js去开发报表页面，要做人工智能训练模型时可以选择Python，等等。
+通过服务来实现独立自治的组件（Componentization via Service）
+之所以强调通过“服务”（Service）而不是“类库”（Library）来构建组件，是因为类库在编译期静态链接到程序中，通过本地调用来提供功能，而服务是进程外组件，通过远程调用来提供功能。前文我们也已经分析过，尽管远程服务有更高昂的调用成本，但这是为组件带来自治与隔离能力的必要代价。
+产品化思维（Product not Project）
+避免把软件研发视作要去完成某种功能，而是视作一种持续改进、提升的过程。譬如，不应该把运维只看作运维团队的事，把开发只看作开发团队的事，团队应该为软件产品的整个生命周期负责，开发者不仅应该知道软件如何开发，还应该知道它如何运作，用户如何反馈，乃至售后支持工作是怎样进行的。注意，这里服务的用户不一定是最终用户，也可能是消费这个服务的另外一个服务。以前在单体架构下，程序的规模决定了无法让全部成员都关注完整的产品，如开发、运维、支持等不同职责的成员只关注自己的工作，但在微服务下，要求开发团队中每个人都具有产品化思维，关心整个产品的全部方面是具有可行性的。
+数据去中心化（Decentralized Data Management）
+微服务明确提倡数据应该按领域分散管理、更新、维护、存储。在单体服务中，一个系统的各个功能模块通常会使用同一个数据库。诚然，中心化的存储天生就更容易避免一致性问题，但是，同一个数据实体在不同服务的视角里，它的抽象形态往往是不同的。譬如，Bookstore应用中的书本，在销售领域中关注的是价格，在仓储领域中关注的是库存数量，在商品展示领域中关注的是书的介绍信息，如果使用中心化存储，所有领域都必须修改和映射到同一个实体之中，这很可能使不同服务相互影响而丧失独立性。尽管在分布式中处理好一致性问题也相当困难，很多时候都没办法使用传统的事务处理来保证，但是两害相权取其轻，即使有一些必要的代价，但仍是值得使用的。
+强终端弱管道（Smart Endpoint and Dumb Pipe）
+弱管道（Dumb Pipe）几乎是直接反对SOAP和ESB的通信机制。ESB可以处理消息的编码加工、业务规则转换等；BPM可以集中编排企业业务服务；SOAP有几十个WS-*协议族在处理事务、一致性、认证授权等一系列工作，这些构建在通信管道上的功能也许对某个系统中的某一部分服务是有必要的，但对于另外更多的服务则是强加进来的负担。如果服务需要上面的额外通信能力，就应该在服务自己的Endpoint上解决，而不是在通信管道上一揽子处理。微服务提倡使用类似于经典UNIX过滤器那样简单直接的通信方式，所以RESTful风格的通信在微服务中会是更合适的选择。
+容错性设计（Design for Failure）
+不再虚幻地追求服务永远稳定，而是接受服务总会出错的现实，要求在微服务的设计中，能够有自动的机制对其依赖的服务进行快速故障检测，在持续出错的时候进行隔离，在服务恢复的时候重新联通。所以“断路器”这类设施，对实际生产环境中的微服务来说并不是可选的外围组件，而是一个必需的支撑点，如果没有容错性设计，系统很容易被一两个服务崩溃所带来的雪崩效应淹没。可靠系统完全可能由会出错的服务组成，这是微服务最大的价值所在，也是本书前言中所说的“凤凰架构”的含义。
+演进式设计（Evolutionary Design）
+容错性设计承认服务会出错，演进式设计则承认服务会被报废淘汰。一个设计良好的服务，应该是能够报废的，而不是期望得到长存永生。假如系统中出现不可更改、无可替代的服务，这并不能说明这个服务多么优秀、多么重要，反而是一种系统设计上脆弱的表现，微服务所追求的自治、隔离，也是反对这种脆弱性的表现。
+基础设施自动化（Infrastructure Automation）
+基础设施自动化，如CI/CD的长足发展，显著减少了构建、发布、运维工作的复杂性。由于微服务架构下运维对象数量是单体架构运维对象数量的数量级倍，使用微服务的团队更加依赖于基础设施的自动化，人工是很难支撑成百上千乃至上万级别的服务的。
+微服务的主要优点是：
+微服务也有一些挑战和注意事项，例如：
+微服务是一种值得考虑的软件架构风格，它可以提高软件的灵活性、可替换性、可伸缩性和可靠性，但也带来了一些复杂性、技能和成本的挑战。微服务并不是一种新颖的创新，它的根源可以追溯到Unix的设计原则和服务导向架构的思想。微服务的适用性和成熟度还需要更多的时间和实践来验证和评估。在选择微服务时，需要根据具体的上下文和需求，权衡利弊，做出明智的决策。
+ + +
+ 微信支付
+
+ 支付宝支付
+
+
+ 开发计算机软件是一项非常复杂的工作。在过去的十五年中，研究者们已经明确了这项工作的主要方面，包括以下几个关键阶段：
+目的：修复软件运行中出现现的错误和问题。
+方法：定期更新软件，解决已发现的缺陷和性能问题。
+隐喻在软件开发中起着关键的启发性作用，它通过将软件开发过程与我们熟悉的事物相比较，帮助我们更深入地理解软件开发的本质。以下是几个重要的隐喻及其在软件开发中的应用。
+软件开发过程中的准备工作对于最终产品的质量至关重要。以下是几个关键点：
+在需求分析之前，应该清晰地定义问题。良好的问题定义应遵循以下准则：
+需求分析是确定系统功能的关键步骤，应注意以下要点：
+结构设计阶段需要考虑以下关键因素：
+选择编程语言时，应考虑以下因素：
+在开始编码之前，明确的编程约定是至关重要的。这些约定应该详细到在编程过程中不需改动，确保代码的一致性和可维护性。
+软件项目的先决条件阶段需要投入适当的时间和资源，一般建议分配项目总时间的20%至30%。
+在正式开始编码之前进行技术评审，以确保设计的合理性和可行性。
+确保团队成员间的有效沟通和协作。
+选择合适的技术栈和工具是项目成功的关键。
+建立子程序是软件开发中的一个重要过程，需要遵循一系列明确的步骤以确保代码的质量和可维护性。
+数据设计：仔细考虑子程序将处理的数据类型和结构。
+逐步实现：从大致框架开始，逐步细化实现细节。
+i）可能更合适。totals, averages, maximums等，限定词放在变量名末尾。flag，应使用更具描述性的名称。case语句替代if嵌套。
+ 微信支付
+
+ 支付宝支付
+
+
+ 各位程序猿/媛们，还记得你刚入行时写下的那些代码吗？是不是像一堆乱麻，连自己都看不懂？是不是像我一样，曾经天真地以为，只要代码能运行，就万事大吉？
+哈哈，别担心，我们都经历过那个阶段。写代码就像学武功，一开始都是乱打一气，只有经过不断的练习和领悟，才能慢慢掌握其中的奥妙。
+那么推荐大家可以看看文章末尾推荐的几本书籍.这些书籍就是指引我们从无名小辈到扫地僧的武功秘籍。
+还记得那个名为 d 的变量吗？它就像一个没有名片的人，你永远不知道它是谁，它要做什么。这样的代码，就像一个江湖黑话满天飞的武林，让人摸不着头脑。
+好的命名，就像一张清晰的名片，能让人一眼就明白它的身份和职责。比如，elapsedTimeInDays 比 d 好懂多了吧？这就好比武林中人，行走江湖，总得有个响亮的名号，让人一听就知道你是谁，你擅长什么。
+所以，请记住以下秘诀：
+好的命名是代码整洁的第一步，也是最重要的一步。它能让你的代码像优美的散文一样，清晰易懂，令人愉悦。
+还记得那个长达几千行的函数吗？它就像一个臃肿的胖子，行动迟缓，效率低下。这样的代码，就像一支乌合之众，毫无纪律可言，战斗力自然低下。
+好的函数，应该像训练有素的士兵，短小精悍，各司其职。每个函数只做一件事，就像每个士兵只负责一个任务一样，这样才能保证整个队伍的效率和战斗力。
+所以，请记住以下秘诀：
+好的函数是代码整洁的基石。它能让你的代码像积木一样，易于组合，易于维护。
+示例
+// 糟糕的函数
+public void calculateAndPrintReport() {
+ // 计算数据
+ // 格式化数据
+ // 打印报表
+}
+
+// 好的函数
+public void calculateReport() {
+ // 计算数据
+}
+
+public void printReport() {
+ // 格式化数据
+ // 打印报表
+}
+还记得那些不知所云的注释吗？它们就像一堆垃圾，只会让代码更难懂。这样的代码，就像一个脸上涂满油彩的小丑，让人眼花缭乱，却不知其意。
+示例
+i++; // 将 i 加 1
+好的注释，应该像画龙点睛，起到解释和说明的作用，而不是画蛇添足。它应该简洁明了，直击要害，让人一看就懂。
+所以，请记住以下秘诀：
+好的注释是代码整洁的点缀。它能让你的代码锦上添花，但绝不能喧宾夺主。
+示例
+// 解释算法的注释
+// 使用快速排序算法对数组进行排序
+public void sort(int[] array) {
+ // ...
+}
+还记得那些缩进混乱、毫无章法的代码吗？它们就像一堆杂草，让人头晕眼花。这样的代码，就像一个衣衫褴褛的乞丐，毫无美感可言。
+好的格式，就像代码的“颜值”，能让你的代码赏心悦目，易于阅读。它就像一个穿着得体的绅士，让人一看就心生好感。
+所以，请记住以下秘诀：
+好的格式是代码整洁的门面。它能让你的代码更专业，更易于维护。
+示例
+// 糟糕的格式
+if (condition) {
+doSomething();
+} else
+{
+doSomethingElse();
+}
+
+// 好的格式
+if (condition) {
+ doSomething();
+} else {
+ doSomethingElse();
+}
+对象和数据结构，就像代码中的“骨架”，支撑着代码的整体结构。它们就像武功中的内功和招式，相辅相成，缺一不可。
+对象，就像一个训练有素的特工，身怀绝技，却又深藏不露。它把数据隐藏在幕后，只向外界展示它能做什么，而不是它是什么。
+数据结构，就像一个透明的玻璃箱，里面装满了各种数据，一目了然。它没有隐藏，也没有秘密，所有数据都直接暴露在外。
+那么，什么时候该用对象，什么时候该用数据结构呢？
+记住，对象和数据结构各有优劣，选择合适的工具，才能写出整洁的代码。
+示例
+错误处理，就像代码中的“消防员”，负责在代码出现问题时及时扑灭火灾。它就像武功中的防御招式，能够在关键时刻化解危机。
+但是，如果消防员到处乱跑，只会让火势蔓延得更快。同样，如果错误处理代码写得不好，只会让代码更加混乱，难以维护。
+所以，请记住以下秘诀：
+好的错误处理应该像隐形的防护网，在代码出现问题时及时保护，而不是像个碍手碍脚的家伙，到处添乱。
+边界，就像代码中的“国境线”，将你的代码与外部世界隔离开来。它就像武功中的门派之别，划清了界限，避免了冲突和混乱。
+如何守好这道“国境线”，是写出整洁代码的关键。
+所以，请记住以下秘诀：
+好的边界应该像一道坚固的城墙，保护你的代码免受外部世界的侵害，同时又能方便地与外界沟通。
+单元测试，就像代码中的“侦察兵”，负责在代码中寻找 bug 和缺陷。它就像武功中的练功桩，帮助你不断提升代码的质量。
+但是，如果侦察兵漫无目的地乱跑，只会浪费时间和精力。同样，如果单元测试写得不好，不仅不能保证代码质量，反而会成为代码维护的负担。
+所以，请记住以下秘诀：
+好的单元测试应该像一把锋利的匕首，直击代码的要害，快速、准确地找到问题。
+类，就像代码中的“建筑师”，负责构建代码的整体结构。它就像武功中的心法，决定了你的代码能走多远。
+一个好的建筑师，应该懂得如何设计出结构合理、功能清晰的建筑。同样，一个好的程序员，应该懂得如何设计出结构清晰、易于维护的类。
+所以，请记住以下秘诀：
+好的类应该像一个精密的仪器，每个部件都各司其职，共同协作，完成复杂的任务。
+除了上面提到的内容，我还想补充以下几点：
+我个人的建议是，不要把代码整洁看成是一种负担，而应该把它看成是一种投资。整洁的代码可以提高开发效率，降低维护成本，让你的代码更易于理解和扩展。
+最后，我想说，代码整洁之道，没有终点，只有不断精进。让我们一起努力，写出更整洁、更优雅的代码吧！
+作为一名开发者，我深知开发不仅仅是敲代码，更是一项需要沟通、协作和不断改进的系统工程。以下是我在阅读过程中总结的一些经验：
+正如书中所说：“开发者必须在许多层面上进行交流” ,与团队成员、用户和其他利益相关者的有效沟通是项目成功的关键。
+代码中的漏洞就像房间里的“破窗户”，如果不及时修复，就会让房间变得越来越脏乱。因此，我们应该养成及时修复漏洞的习惯，避免问题越积越多。
+代码重构就像整理房间，可以让我们更容易地理解和维护代码。我们应该定期对代码进行重构，消除重复、冗余和难以理解的代码，让代码更简洁、更高效。
+工欲善其事，必先利其器。选择合适的工具可以让我们事半功倍。
+软件开发是一个快速发展的领域，新的技术和工具层出不穷。作为开发者，我们需要保持学习的态度，不断学习新的知识和技能，才能跟上时代的步伐。
+软件开发是一个团队合作的过程，我们需要与团队成员相互协作，才能完成项目目标。
+最终用户是软件的使用者，他们的体验决定了软件的成败。
+软件开发是一个充满变化的过程，需求可能会变更，技术可能会更新。作为开发者，我们需要拥抱变化，灵活应对各种挑战。
+作为注重实效的开发者，我们应该追求卓越，不断提升代码质量和开发效率，为用户提供更好的软件产品和服务。
+软件开发是一项充满挑战和乐趣的工作。我们应该享受开发的过程，从中获得成就感和满足感。
+注重实效的开发不仅仅是编写代码，更是一项需要沟通、协作和不断改进的系统工程。通过有效的沟通、及时的修复漏洞、持续的代码重构、使用合适的工具、保持学习的态度、注重团队合作、关注用户体验、拥抱变化、追求卓越和享受开发的乐趣，我们可以成为更加注重实效的开发者，为用户提供更好的软件产品和服务。
+让我们一起努力，用代码改变世界！(世界太大,不如从自己开始)
+1.《代码整洁之道》
+2.《程序员修炼之道:从小工到专家》
+3.《重构:改善既有代码的设计》
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 简单地说，frp就是一个反向代理软件，它体积轻量但功能很强大，可以使处于内网或防火墙后的设备对外界提供服务，它支持HTTP、TCP、UDP等众多协议。我们今天仅讨论TCP和UDP相关的内容。
+1.具有公网IP的VPS一台
+2.内网设备一台
+3.了解基础的Linux命令
+1.下载VPS对应版本的frp服务端
+wget https://github.com/fatedier/frp/releases/download/v0.22.0/frp_0.22.0_linux_amd64.tar.gz
+2.解压文件
+tar -zxvf frp_0.22.0_linux_amd64.tar.gz
+3.进入解压后的目录
+cd frp_0.22.0_linux_amd64
+4.修改配置文件frps.ini
+vim frps.ini
+[common]
+bind_port = 7000
+dashboard_port = 7500
+token = 12345678
+dashboard_user = admin
+dashboard_pwd = admin
+bind_port: 监听端口,后续需要在客户端使用
+dashboard_port: 浏览器管理端访问端口
+token: 客户端与服务端连接的口令,后续客户端配置会用到
+dashboard_user: 管理端用户名
+dashboard_pwd: 用户端管理密码
+5.启动服务
+nohup ./frps -c frps.ini &
+6.浏览器访问管理端页面, 地址:x.x.x.x:7500
+1.下载
+地址: https://github.com/fatedier/frp/releases
+
2.配置frpc.ini
+[common]
+server_addr = x.x.x.x
+server_port = 7000
+token = won517574356
+[rdp]
+type = tcp
+local_ip = 127.0.0.1
+local_port = 3389
+remote_port = 7001
+server_addr: vps的ip
+server_port: 上面配置的port
+token: 上面配置的口令
+rdp: 自定义名字
+type: 协议类型,TCP或UDP等
+local_port: 本地应用端口
+remote_port: 在服务端使用的端口
+3.启动服务(不能直接双击运行)
+打开Powershell,进入该目录
+cd C:\frp
+./frpc -c frpc.ini
+4.上面的启动方式会有一个窗口,可以修改为后台启动
+创建一个frpc.bat,内容如下,修改cd路径
+@echo off
+if "%1" == "h" goto begin
+mshta vbscript:createobject("wscript.shell").run("""%~nx0"" h",0)(window.close)&&exit
+:begin
+REM
+cd C:\frp
+frpc -c frpc.ini
+exit
+5.点击frpc.bat启动即可
+使用对应的连接工具,输入ip+remote_port进行远程即可!
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ OpenAI近期宣布，GPT-3.5现已支持无账号使用，这一变化无疑为全球AI爱好者带来了福音。然而，由于网络和地域限制，国内许多朋友仍然面临着使用上的挑战。
+今天，我将向大家推荐两个开源项目，它们能够帮助您在国内部署并免费使用GPT-3.5服务。
+**FreeGPT35**项目利用了OpenAI提供的免登录ChatGPT Web API，使用户能够无限制地使用GPT-3.5-Turbo服务。通过简单的Docker部署，您就可以在本地服务器上运行这一服务，享受到快速且稳定的AI体验。
+部署步骤:
+mkdir freegpt35 && cd freegpt35
+wget -O compose.yaml https://raw.githubusercontent.com/missuo/FreeGPT35/main/compose.yaml
+docker compose up -d
+部署完成后，您可以直接访问 http://[IP]:3040/v1/chat/completions 来使用API。
**Aurora**项目专注于提升用户体验，通过优化前端界面和增强功能，为用户提供了一个更为流畅和直观的使用环境。
+部署步骤:
+# 克隆Aurora项目
+git clone https://github.com/aurora-develop/aurora
+# 进入项目目录
+cd aurora
+# 使用Docker部署
+docker-compose up -d
+部署完成后，您可以按照项目文档进行配置，开始使用Aurora服务。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 
你是否想过拥有一个能够与你聊天、搜索、写作、编程、提供有用建议的人工智能助手？你是否想过让这个助手能够理解和使用多种语言，甚至能够从长篇文档中提取和生成信息？你是否想过让这个助手能够遵循一些道德和行为准则，避免产生有害或不真实的内容？
+如果你的答案是肯定的，那么你一定会对Claude 2感兴趣。Claude 2是Anthropic公司最新发布的人工智能系统，它是基于大型语言模型（LLM）的通用语言助手，具有多项创新和改进的功能。在这篇文章中，我们将介绍Claude 2的模型，以及现在可以使用！如何使用！有什么特点！
+Claude 2是基于Transformer架构的大型语言模型，它使用无监督学习、人类反馈强化学习（RLHF）和宪法式人工智能（Constitutional AI）进行训练。Claude 2是Anthropic公司自2019年开始研究RLHF以来不断迭代和进化的结果，它代表了从早期的“有用且无害”的语言助手到目前更强大、更可靠、更可控、更可解释的AI系统的持续演变。
+Claude 2的训练数据包括从互联网上公开获取的信息、从第三方企业获得许可的数据集、以及用户主动分享或众包工作者提供的数据。Claude 2的训练数据截止于2023年初，其中约10%是非英语数据。
+Claude 2在部署前经过了一系列的评估和红队测试，包括能力评估、安全性评估和对齐性评估，这些评估旨在测量模型在不同任务上的技能、优势和劣势，以及模型是否存在特定风险和是否符合为其设定的道德和行为期望。你可以在网页文档中查看这些评估结果的详细信息。
+
Claude 2已经在2023年7月正式发布，并且可以通过Anthropic公司的控制台进行访问和使用。你只需要注册一个账号，就可以开始与Claude 2交互，并体验它所提供的各种功能。
+你现在可以访问https://claude.ai 来使用Claude 2跟他对话，需要注意的是目前只对美国和英国的IP开放。
+通过谷歌授权或者自己注册登录即可，再也不用担心被封号了。并且目前是完全免费的！！
+Claude 2可以通过多种方式进行使用，包括：
+Claude 2有以下几个特点，使它与其他人工智能系统有所不同：
+以上就是我们对Claude 2的介绍，希望你能够喜欢并尝试使用这个人工智能助手。如果你有任何反馈或建议，请随时联系我们。谢谢！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 在这个数字化的世界里，接码平台的需求日益增长。这些平台允许用户接收短信，无论他们身处何处。下面，我们为您提供了一份详尽的国内外免费接码平台列表：
+以上是我们为您精选的一些免费接码平台，希望可以帮助您在需要的时候接收短信。请注意，使用这些服务时应遵守所有适用的法律和规定。
+请合理使用，享受免费接码服务！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 我们很高兴地宣布，ChatGPT最近开放了免注册使用的GPT-3.5服务。这是一个重大的进步，它将为开发者和使用者提供更加便利的体验。
+
在GitHub上，已经有相关的项目出现，利用免登录ChatGPT Web提供的无限制免费GPT-3.5-Turbo API服务。您可以通过以下链接访问和使用这个项目：
+ +我们强烈建议所有的用户合理使用这项服务，以确保其可持续性。感谢您的理解和支持，我们期待您的反馈和建议，以帮助我们持续改进和提升这项服务。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 访问地址登录账号: https://you.com?referral_code=WZSZEGOT
+
输入20刀优惠码: Spring4You
+再访问地址: https://namso-gen.com/?tab=basic&network=random
+
然后,随机挑选一个填写即可!
+
若是失败,可以多试几次!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 分布式与集群
+
Hash算法常用于数据存储与查找领域,最经典的就是Hash表,查询效率高,查询时间复杂度可以接近于O(1)
+案例:提供一组数据1,4,6,2,7,8,如何判断n是否存在于这组数据中?
+1.使用循环匹配的方式,即顺序查找法,效率不高
+2.通过折半查找的方式,即二分查找法,效率依旧不高
+3.创建一个数组,使用数据做下标存值,查询时,只需要判断n对应的下标是否存在值,即可判断n是否存在于数据中.即直接寻址法
+4.直接寻址法优点是可以一次查找到结果,速度块,而缺点是浪费空间,当这组数据间隔较大时,需要创建一个较大的数组,并且其中大部分空间未被使用.因此,可以将数据进行求模运算法,即除留余数法
+5.但是取模运算可能出现多个同样的值出现在同一位置,造成hash冲突,这时,可以将值存在前后的空位,即开放寻址法
+6.假若前后没有空位,则开放寻址法不可使用,这时我们想到使用链表,在一个位置出现多个值的时候,可以使用链表的形式进行连接.即拉链法
+7.但是拉链法实际上也是依赖于hash算法,若是算法太差,会导致数据全部存在数组某个位置的链表中,导致查询效率变低.
+8.因此我们使用Hash结构时,我们需要考虑到hash算法的优劣,如我们常使用的HashCode就是一种hash算法的实现.
+Hash算法在很多分布式集群产品中都有应用,比如分布式集群架构Redis,Hadoop,Nginx负载均衡,Mysql分库分表等.
+归纳起来就是以下两种:
+1.请求的负载均衡(比如nginx的ip_hash策略)
+Nginx的IP_hash策略可以在客户端Ip不变的情况下,将其发出的请求始终路由到同一个目标服务器上,实现会话粘连.避免处理session共享问题
+2.分布式存储
+以分布式内存数据库Redis为例,集群中有redis1,redis2.redis3三台服务器,
+那么可以通过hash处理,计算数据存储时,存储到具体的某一台服务器中.
+普通Hash算法存在⼀个问题，以ip_hash为例，假定下载⽤户ip固定没有发⽣改变，现在tomcat3出现 了问题，down机了，服务器数量由3个变为了2个，之前所有的求模都需要重新计算。
+
如果在真实⽣产情况下，后台服务器很多台，客户端也有很多，那么影响是很⼤的，缩容和扩容都会存 在这样的问题，⼤量⽤户的请求会被路由到其他的⽬标服务器处理，⽤户在原来服务器中的会话都会丢失.
+以0为起点,2的32次方减1作为终点构建一个圆环,针对用户和服务器ip进行hash.然后将用户分配给顺时针方向距离最近的服务器节点
+
这样,当某一个服务器节点上下线时,只会影响当前区间的用户
+
但是,当节点太少时,如两个节点,可能会导致大量的用户请求落在节点1上,造成数据倾斜问题.
+为了解决数据倾斜问题,一致性哈希算法引入了虚拟节点机制,即对每个服务器节点计算多次哈希,每个计算结果位置都放置一个此服务节点,称为虚拟节点
+
即集群部署时服务器时间的同步,若每个服务器的时间不一致,则将导致最终入库的数据混乱.
+
+ #使⽤ ntpdate ⽹络时间同步命令
+ntpdate -u ntp.api.bz #从⼀个时间服务器同步时间
+定时执行同步命令
+
将一台服务器节点A作为时间服务器,其他服务器与此服务器保持时间同步.
+1.设置好服务器节点A的时间
+2.把A配置为时间服务器,修改/etc/ntp.conf文件
+1、如果有 restrict default ignore，注释掉它
+2、添加如下⼏⾏内容
+ restrict 172.17.0.0 mask 255.255.255.0 nomodify notrap # 放开局
+域⽹同步功能,172.17.0.0是你的局域⽹⽹段
+ server 127.127.1.0 # local clock
+ fudge 127.127.1.0 stratum 10
+3、重启⽣效并配置ntpd服务开机⾃启动
+ service ntpd restart
+ chkconfig ntpd on
+3.集群中其他节点就可以从A服务器同步时间了
+ntpdate 172.17.0.17
+UUID 是指Universally Unique Identifier，翻译为中⽂是通⽤唯⼀识别码 产⽣重复 UUID 并造成错误的情况⾮常低，是故⼤可不必考虑此问题
+⽐如A表分表为A1表和A2表，那么肯定不能让A1表和A2表的ID⾃增，那么ID怎么获取呢？我们可 以单独的创建⼀个Mysql数据库，在这个数据库中创建⼀张表，这张表的ID设置为⾃增，其他地⽅ 需要全局唯⼀ID的时候，就模拟向这个Mysql数据库的这张表中模拟插⼊⼀条记录，此时ID会⾃ 增，然后我们可以通过Mysql的select last_insert_id() 获取到刚刚这张表中⾃增⽣成的ID
+雪花算法是Twitter推出的⼀个⽤于⽣成分布式ID的策略。 雪花算法是⼀个算法，基于这个算法可以⽣成ID，⽣成的ID是⼀个long型.
+Redis Incr 命令将 key 中储存的数字值增⼀。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执⾏ INCR 操作
+
调度—>定时任务，分布式调度—>在分布式集群环境下定时任务这件事
+Elastic-job（当当⽹开源的分布式调度框架)
+定时任务形式：每隔⼀定时间/特定某⼀时刻执⾏
+例如：
+什么是分布式任务调度？有两层含义
+1）运⾏在分布式集群环境下的调度任务（同⼀个定时任务程序部署多份，只应该有⼀个定时任务在执⾏）
+2）分布式调度—>定时任务的分布式—>定时任务的拆分（即为把⼀个⼤的作业任务拆分为多个⼩的作 业任务，同时执⾏）
+
1.异步处理
+⽐如注册、下单事件
+2.应用解耦
+不管定时任务作业还是MQ都可以作为两个应⽤之间的⻮轮实现应⽤解耦，这个⻮轮可以中转数据，当然单体服务不需要考虑这些，服务拆分的时候往往都会考虑
+3.流量削峰
+双⼗⼀的时候，任务作业和MQ都可以⽤来扛流量，后端系统根据服务能⼒定时处理订单或者 从MQ抓取订单抓取到⼀个订单到来事件的话触发处理，对于前端⽤户来说看到的结果是已经下单成功了，下单是不受任何影响的
+定时任务是时间驱动,而MQ是事件驱动.
+定时任务倾向于批处理,而MQ倾向于逐条处理
+时间驱动是不可代替的，⽐如⾦融系统每⽇的利息结算，不是说利息来⼀条（利息到来事件）就算 ⼀下，⽽往往是通过定时任务批量计算.
+定时任务的实现⽅式有多种。早期没有定时任务框架的时候，我们会使⽤JDK中的Timer机制和多线程机 制（Runnable+线程休眠）来实现定时或者间隔⼀段时间执⾏某⼀段程序；后来有了定时任务框架，⽐ 如⼤名鼎鼎的Quartz任务调度框架，使⽤时间表达式（包括：秒、分、时、⽇、周、年）配置某⼀个任 务什么时间去执⾏;
+使用步骤
+1.引入jar
+<!--任务调度框架quartz-->
+<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz --
+>
+<dependency>
+ <groupId>org.quartz-scheduler</groupId>
+ <artifactId>quartz</artifactId>
+ <version>2.3.2</version>
+</dependency>
+2.定时任务主调度程序
+package quartz;
+import org.quartz.*;
+import org.quartz.impl.StdSchedulerFactory;
+public class QuartzMain {
+ // 创建作业任务调度器（类似于公交调度站）
+ public static Scheduler createScheduler() throws
+SchedulerException {
+ SchedulerFactory schedulerFactory = new StdSchedulerFactory();
+ Scheduler scheduler = schedulerFactory.getScheduler();
+ return scheduler;
+ }
+ // 创建⼀个作业任务（类似于⼀辆公交⻋）
+ public static JobDetail createJob() {
+ JobBuilder jobBuilder = JobBuilder.newJob(DemoJob.class);
+ jobBuilder.withIdentity("jobName","myJob");
+ JobDetail jobDetail = jobBuilder.build();
+ return jobDetail;
+ }
+ /**
+ * 创建作业任务时间触发器（类似于公交⻋出⻋时间表）
+ * cron表达式由七个位置组成，空格分隔
+ * 1、Seconds（秒） 0~59
+ * 2、Minutes（分） 0~59
+ * 3、Hours（⼩时） 0~23
+ * 4、Day of Month（天）1~31,注意有的⽉份不⾜31天
+ * 5、Month（⽉） 0~11,或者
+JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC
+ * 6、Day of Week(周) 1~7,1=SUN或者 SUN,MON,TUE,WEB,THU,FRI,SAT
+* 7、Year（年）1970~2099 可选项
+ *示例：
+ * 0 0 11 * * ? 每天的11点触发执⾏⼀次
+ * 0 30 10 1 * ? 每⽉1号上午10点半触发执⾏⼀次
+ */
+ public static Trigger createTrigger() {
+ // 创建时间触发器，按⽇历调度
+ CronTrigger trigger = TriggerBuilder.newTrigger()
+ .withIdentity("triggerName","myTrigger")
+ .startNow()
+ .withSchedule(CronScheduleBuilder.cronSchedule("0/2 *
+* * * ?"))
+ .build();
+ // 创建触发器，按简单间隔调度
+ /*SimpleTrigger trigger1 = TriggerBuilder.newTrigger()
+ .withIdentity("triggerName","myTrigger")
+ .startNow()
+ .withSchedule(SimpleScheduleBuilder
+ .simpleSchedule()
+.withIntervalInSeconds(3)
+.repeatForever())
+ .build();*/
+ return trigger;
+ }
+ // 定时任务作业主调度程序
+ public static void main(String[] args) throws SchedulerException {
+ // 创建⼀个作业任务调度器（类似于公交调度站）
+ Scheduler scheduler = QuartzMain.createScheduler();
+ // 创建⼀个作业任务（类似于⼀辆公交⻋）
+ JobDetail job = QuartzMain.createJob();
+ // 创建⼀个作业任务时间触发器（类似于公交⻋出⻋时间表）
+ Trigger trigger = QuartzMain.createTrigger();
+ // 使⽤调度器按照时间触发器执⾏这个作业任务
+ scheduler.scheduleJob(job,trigger);
+ scheduler.start();
+ }
+}
+3.定义一个job,需要实现Job接口
+package quartz;
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+public class DemoJob implements Job {
+ public void execute(JobExecutionContext jobExecutionContext)
+throws JobExecutionException {
+ System.out.println("我是⼀个定时任务逻辑");
+ }
+}
+Elastic-Job是当当⽹开源的⼀个分布式调度解决⽅案，基于Quartz⼆次开发的，由两个相互独⽴的⼦项 ⽬Elastic-Job-Lite和Elastic-Job-Cloud组成。我们要学习的是 Elastic-Job-Lite，它定位为轻量级⽆中⼼ 化解决⽅案，使⽤Jar包的形式提供分布式任务的协调服务，⽽Elastic-Job-Cloud⼦项⽬需要结合Mesos 以及Docker在云环境下使⽤。
+
基于Zookeeper的Leader节点选举机制
+每个Elastic-Job的任务执⾏实例App作为Zookeeper的客户端来操作ZooKeeper的znode
+(1)多个实例同时创建/leader节点
+(2)/leader节点只能创建⼀个，后创建的会失败，创建成功的实例会被选为leader节点， 执⾏任
+⼀个⼤的⾮常耗时的作业Job，⽐如：⼀次要处理⼀亿的数据，那这⼀亿的数据存储在数据库中，如果 ⽤⼀个作业节点处理⼀亿数据要很久，在互联⽹领域是不太能接受的，互联⽹领域更希望机器的增加去 横向扩展处理能⼒。所以，ElasticJob可以把作业分为多个的task（每⼀个task就是⼀个任务分⽚），每 ⼀个task交给具体的⼀个机器实例去处理（⼀个机器实例是可以处理多个task的），但是具体每个task 执⾏什么逻辑由我们⾃⼰来指定。
+
新增加⼀个运⾏实例app3，它会⾃动注册到注册中⼼，注册中⼼发现新的服务上线，注册中⼼会通知 ElasticJob 进⾏重新分⽚，那么总得分⽚项有多少，那么就可以搞多少个实例机器，⽐如完全可以分1000⽚
+
多服务器之间的Session同步问题
+
同⼀个客户端IP的请求都会被路由到同⼀个⽬标服务器，也叫做会话粘滞
+优点
+配置简单,不入侵应用,不需要额外修改代码
+缺点
+1.服务器重启session丢失
+2.存在单点负载高的风险
+3.单点故障问题
+多个tomcat之间修改配置文件,达到Session之间的同步
+
优点
+1.不入侵应用
+2.便于服务器水平扩展
+3.能适应各种负载均衡策略
+4.服务器重启或者宕机不会造成Session丢失
+缺点
+1.性能低
+2.内存消耗
+3.不能存储太多数据,否则容易影响性能
+4.延迟性
+使用缓存中间件存储Session,如Redis
+
优点
+1.能适应各种负载均衡策略
+2.服务器宕机不会造成Session丢失
+3.扩展能力强
+4.适合大集群使用
+缺点
+对应用有入侵,引入了Redis的交互代码
+使用
+1.引入jar
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-data-redis</artifactId>
+</dependency>
+<dependency>
+ <groupId>org.springframework.session</groupId>
+ <artifactId>spring-session-data-redis</artifactId>
+</dependency>
+2.配置redis
+spring.redis.database=0
+spring.redis.host=127.0.0.1
+spring.redis.port=6379
+3.添加注解
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 最近遇到了一个存储动态字段的问题,根据以往的项目经验,以及查阅相关资料,记录总结一下解决方案
+
1.列模型
+建表时预留一些空白字段
+
2.行模型
+将动态字段以key-value形式存储到表中,然后通过id关联到业务上
+
3.EAV模型
+EAV模型，就是把实体-属性-值（Entity-Attribute-Value）分开表进行存储。实体表存储对象的ID和主要属性，属性表存储需要扩展的属性，值表由不同类型的表组成一个集合，一个值需要由实体ID+属性ID来确定。
+
4.JSON模型
+直接将所有字段以json格式进行存储,增删改查逻辑有代码层面实现
+
不同的方案各有优劣,根据实际情况进行取舍!
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 在CSDN和博客园上，我开始尝试用文章来记录Java的一些复杂知识点。虽然我陆续写了几十篇，但由于这两个平台的用户体验不佳，我逐渐失去了动力。文章的撰写过程变得痛苦，而网站的速度慢且界面不美观。更糟糕的是，CSDN还需要对文章进行审核，且主题定制的自由度极低。
+随后，我转向了微信公众号。我开始同步更新个人博客的文章到这个平台，内容基本相同。我最初并不想使用微信公众号，因为它不支持Markdown，使得撰写过程变得繁琐。但考虑到未来的发展以及可能的商业化操作，我还是决定重新开始。
+最初，我写博客主要是为了记录我平时学到的知识，期待有一天可能会翻阅复习。但事实证明，我很少回头查看我以前写的内容。
+然而，写博客的另一个主要目标是分享我所知道的知识，希望能够帮助更多的人。写博客让我有机会认识到来自各地的朋友，无论是在校生，还是有多年工作经验的人，甚至是初高中生，都在学习编程。我觉得这是一个扩展人脉的好机会。
+最后，我想引用一句话：“不以盈利为目的的博客最后都死亡了”。如果没有任何收入，很少有人会有决心坚持更新博客。虽然我也希望从中获得收益，但我并不打算为了吸引更多的粉丝而改变我的初衷，去写一些刻意迎合大众的文章。
+我计划持续更新我的博客，把它当作记录自己生活和工作的一种方式。不过，至于需要多少时间和金钱来运营和维护，那还有待观察。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ | 许可证 | +类型 | +允许闭源分发 | +允许闭源链接 | +要求保留版权声明 | +要求公开修改源码 | +
|---|---|---|---|---|---|
| GNU GPL | +copyleft | +否 | +否 | +是 | +是 | +
| GNU LGPL | +copyleft | +否 | +是 | +是 | +是 | +
| AGPL | +copyleft | +否 | +否 | +是 | +是 | +
| EPL | +copyleft | +否 | +是 | +是 | +是 | +
| MPL | +copyleft | +否 | +是 | +是 | +是 | +
| MIT | +permissive | +是 | +是 | +是 | +否 | +
| Apache 2.0 | +permissive | +是 | +是 | +是 | +否 | +
| BSD 3-Clause | +permissive | +是 | +是 | +是 | +否 | +
| ISC | +permissive | +是 | +是 | +是 | +否 | +
+ 微信支付
+
+ 支付宝支付
+
+
+ PicGo：一款用于快速上传图片并获取图片URL链接的工具。
+PicGo 支持以下图床：
+
经常写博客的同学都知道，有一个稳定又好用的图床是多么重要。一旦有一天图床服务不能用了，那之前的图片岂不是都挂了。直到遇到了 PicGo + GitHub，彻底打消了我的所有顾虑，而且配置简单，使用优雅。背靠 GitHub 和微软，稳定性问题基本不用担心。还有就是支持 Windows，macOS 和 Linux 平台。
+注意：仓库得设置为 Public 。因为后面通过客户端访问算是外部访问，因此无法访问 Private ，这样的话图片传上来之后只能存储不能显示。
+仓库建好之后，点击页面右上角，进入 Settings, 点击 Personal access tokens，再点 Generate new token 新建 token。
+
填写 Notes 信息，选择 token 过期时间，为了安全，GitHub 会强烈建议不要设置成永久。这个大家根据自己实际情况选择，到期之后重新生成即可。
+复选框的话，repo 一定要全选，其他的无所谓，我是都勾选了。
+确定之后，就生成我们需要的 token 了。
+打开 PicGo 进行配置：
+设定仓库名：上文在 GitHub 创建的仓库。
+设定分支名：main。
+设定 Token：上文生成的 token。
+指定存储路径：为空的话会上传到根目录，也可以指定路径。
+设定自定义域名：可以为空，这里为了使用 CDN 加快图片的访问速度，按这样的格式填写：https://cdn.jsdelivr.net/gh/用户名/仓库名
+配置完成后就可以使用了。
+图床有很多方案，可以根据自己的实际情况进行选择。
+简介：将图片分发到多处备份，借助其本身的 CDN 加速功能，节省服务器流量，并且不用担心图片被删除，即便其中某几个图床上的图片被删除了，还有其他备份，保证万无一失，支持匿名和注册管理。
+图片上传限制：无
+官网地址：https://imgchr.com
+简介：支持免注册上传图片，永久存储，支持 HTTPS 加密访问和调用图片，提供多种图片链接格式，成立于 2011 年。
+限制：最大 10M
+官网地址：https://sm.ms
+特点：永久存储免注册，图片链接支持 https，可以删除上传的图片，提供多种图片链接格式，建立于 2015 年，目前免费用户无法使用香港节点。
+图片上传限制：每个图片最大 5M，每次最多上传 10 张。
+简介：注册认证后有 10G 永久免费空间，每月 10G 国内和 10G 国外流量，速度相当快，七牛云是国内专业 CDN 服务商，插件支持比较多，有免费 SSL 证书，但 https 流量收费。
+注意：七牛云 30 天后会回收测试域名，因此你必须要绑定自己的已经备案的域名。
+图片上传限制：无
+简介：注册认证后有 10G 永久免费空间，每月 15G 的 HTTP 和 HTTPS 流量，提供两款可以免费续期的 SSL 证书，不过用户需要加入又拍云联盟（即在网站底部添加又拍云 logo 及官网链接）。
+注意：需要绑定自己的已备案域名，又拍云认证比较麻烦，建议使用七牛云。
+图片上传限制：无
+官网地址：https://cloud.tencent.com
+简介：仅可以使用六个月的免费存储容量、免费请求和免费流量，不推荐使用。
+限制：时间、流量、空间大小均有限制。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 很多人想要开通ChatGPT Plus，却苦于没有合适的渠道。市面上的黑卡方法不仅风险高，还可能导致账号被封。本文将为你提供一个安全、可靠的开通Plus的方法。🔐
+开始之前，你需要准备以下三样东西：
+有了这些，你就可以顺利开通Plus服务了。🎫
+如果你已经拥有美区账号，那么恭喜你，可以直接跳到下一步。如果没有，不用担心，按照以下步骤操作即可。🛠️
+
如果不是，通过谷歌账户设置更改付款方式，填写美区付款资料，关闭原有的其他区域付款资料。具体如下:
+访问地址Google Account
+
添加美国地址,注意添加地址时,需要选择免税区,否则后续开通需要交税! 例如：俄勒冈州（Oregon）邮政编码97230
+
建议挂上美国节点进行操作（不是必须的）。
+删除付款资料会将当前谷歌账户的余额清零，请确认自己是否需要保留余额，建议消费完再进行换区操作。
+此方法可无限次数更改账号所在地区
+进入Play商店添加付款方式，选择添加信用卡或借记卡。添加国内的Visa双币卡，就像添加一张普通银行卡一样简单。🏦
+
最后，下载ChatGPT并登录账号,通过内购流程开通Plus服务，享受更多功能。📥
+以上就是开通ChatGPT Plus的详细步骤。操作简单，安全可靠，赶快试试吧！🌈
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 有时候，当你在访问www.bing.com时，会发现页面重定向到cn.bing.com，这很可能是因为你的地理位置。为了避免这种情况，可以使用Header Editor插件。
+Header Editor是一款浏览器插件，可以帮助我们在请求网页时修改HTTP头信息，从而防止页面重定向。下面是使用Header Editor插件防止Bing重定向到cn.bing.com的步骤。
+首先，需要安装Header Editor插件。
+
安装完Head Edit插件后，就可以使用它防止Bing重定向了。
+
若是不行,调整匹配规则如下:
+
+ 
+
+
+
+
+
+^http(s?)://(www\.)?bing\.com/?(.*)=
+点击“Save”按钮保存设置。
+上诉步骤完成之后,只需要访问必应 (bing.com),即可进行内测登记,等待通过之后则会收到邮件,建议使用国外的邮箱,不要使用QQ邮箱!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 最近应该有小伙伴发现在Slack中无法使用Claude了,根据网上消息,应该是官方更新了规则,现在只能在Slack的付费工作区才能正常使用!
+下面教大家如何继续免费白嫖Claude!
+访问登录 | Slack输入自己的邮箱,注册新的账号!
+
输入验证码后,点击创建工作区!按照页面提示完成创建即可!
+
按照下图操作创建频道!开启专业版免费试用!
+
访问网站anthropic.com/claude-in-slack 添加Claude,授予访问权限即可!
+
添加之后返回slack的网站,就可以在左侧看到Claude的应用了
+
赶快去白嫖啦!到期后只要规则不变,就可以继续注册新号白嫖啦!
+附上这个账号的邀请地址: https://join.slack.com/t/wangwangithq/shared_invite/zt-1y1yesgqf-HXSfJP_YmJDTWoefE2eRFg
+另外附带推荐几个slack中好用的应用!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 
如果你是一个想要学习编程、解决技术问题或者参与开源社区的人，你可能会经常遇到需要向别人提问的情况。但是，你知道如何提问吗？你知道如何提出一个清晰、有效、有礼貌的问题吗？你知道如何得到一个满意、及时、友好的回答吗？
+如果你对这些问题的答案不太确定，或者想要提高你的提问技巧，那么请继续阅读这篇文章。我将给你一些关于如何提问的建议和指导。这些内容来自于一些经验丰富的骇客（hacker）和开源软件开发者，他们每天都在处理各种各样的技术问题，并乐于分享他们的知识和经验。当然，他们也有自己的喜好和标准，所以如果你想要得到他们的帮助，你最好遵循他们的规则和习惯。
+你可能会觉得，提问有什么难的？只要把遇到的问题描述一下，然后等待回答就行了。可惜事实并非如此简单。在实际情况中，很多人提出的问题要么太含糊、太复杂、太琐碎、太无聊、太自私、太无礼，要么根本不是问题。这样的问题不仅浪费了提问者和回答者的时间和精力，也降低了提问者在社区中的声誉和信誉。
+学习如何提问，可以帮助你避免这些问题，也可以帮助你更有效地获取信息和解决问题。通过提出一个好问题，你可以：
+那么，如何才能提出一个好问题呢？这里有一些基本的原则和步骤，你可以参考和遵循。
+做好准备：在提问之前，你应该先做好准备工作，包括以下几个方面：
+确定你的问题是什么：你要清楚地知道你遇到了什么问题，它是怎么发生的，它影响了什么，它有什么现象和错误提示，它是可重复的吗，等等。
+尝试自己解决：你要尽力自己解决问题，通过搜索引擎、文档、常见问题解答（FAQ）、教程、源代码等途径寻找答案或者线索。很多时候，问题已经有了现成的解决方案或者相似的案例，你只需要花点时间和耐心就可以找到。
+简化问题：你要尝试简化问题，找出最小可复现的示例（MCVE），排除无关的干扰因素，聚焦于核心的问题。这样可以帮助你理清思路，也可以帮助回答者节省时间。
+选择合适的提问方式：根据你的问题的性质和紧急程度，选择合适的提问方式。一般来说，有以下几种常见的提问方式：
+选择合适的提问对象：根据你的问题的领域和难度，选择合适的提问对象。一般来说，有以下几种常见的提问对象：
+描述问题：在提问时，你应该尽量清楚、准确、有条理地描述你的问题，包括以下几个方面：
+沟通回复：在得到回复后，你应该及时、礼貌、有效地与回答者沟通，包括以下几个方面：
+为了让你更好地理解如何提问，我给出了一些提问的案例，分别展示了好问题和坏问题的区别。请仔细阅读并比较这些案例，并尝试找出其中的优缺点。
+++我想用Python做一个网站，请问怎么做？
+
++我想用Python做一个简单的个人博客网站，我已经安装了Python 3.9.1和Django 3.1.5，并按照官方文档创建了一个项目和一个应用。但是当我运行
+python manage.py runserver命令时，浏览器显示Page not found (404)错误。我检查了我的urls.py文件和views.py文件，发现没有明显的错误。请问这可能是什么原因导致的？我应该如何解决？谢谢！
分析：
+坏问题的缺点：
+好问题的优点：
+++为什么下面这段代码会报错？
+
+ def foo():
+ print(x)
+
+x = 10
+foo()
+++Python中，函数的作用域是如何确定的？
+
++我有一段代码如下：
+
def foo():
+ print(x)
+
+x = 10
+foo()
+++我本以为这段代码会打印出10，因为我认为函数
+foo可以访问全局变量x。但是当我运行这段代码时，却报错了：
NameError: name 'x' is not defined
+++我不明白为什么会这样，我查阅了Python官方文档中关于作用域的部分，发现有这样一句话：
+
++“A scope defines the visibility of a name within a block. If a local variable is defined in a block, its scope includes that block. If the definition occurs in a function block, the scope extends to any blocks contained within the defining one, unless a contained block introduces a different binding for the name.”
+
++我想知道这句话是什么意思，以及它和我的问题有什么关系。谢谢！
+
分析：
+坏问题的缺点：
+好问题的优点：
+通过以上的内容，我希望你能够对如何提问有了一个基本的了解和认识。提问是一种技能，也是一种艺术，它需要你不断地练习和学习，才能达到炉火纯青的境界。在此，我给出了一些如何提问的总结和建议，希望对你有所帮助：
+最后，我祝愿你在提问的过程中能够收获知识、乐趣和友情。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ InfluxDB是一个由InfluxData开发的开源时序型数据库。它由Go写成，着力于高性能地查询与存储时序型数据。时序型数据是指那些随时间变化而变化的数据，比如温度，湿度，股票价格，网站访问量等。这些数据通常具有高频率，高精度，高复杂度和高价值的特点。InfluxDB可以帮助我们有效地管理和分析这些数据，为我们提供实时的洞察和预测。
+为了让你更好地理解InfluxDB的优势和特色，我用一个表格来比较它和MySQL等传统关系型数据库的区别：
+| 特点 | +InfluxDB | +MySQL | +
|---|---|---|
| 数据模型 | +基于时间序列的键值对 | +基于表格的行列 | +
| 数据结构 | +灵活，无需预定义模式 | +固定，需要预先定义模式 | +
| 数据类型 | +主要支持数值类型 | +支持多种类型 | +
| 查询语言 | +使用Flux语言，专为时序型数据设计 | +使用SQL语言，通用但不针对时序型数据 | +
| 写入性能 | +高效，支持批量写入和压缩存储 | +一般，需要事务处理和索引维护 | +
| 查询性能 | +快速，支持多维聚合和窗口函数 | +慢速，需要多表连接和分组排序 | +
| 可扩展性 | +易于水平扩展和分布式部署 | +难以水平扩展和分布式部署 | +
从上表可以看出，InfluxDB比MySQL更适合处理时序型数据，因为它有更高的性能，更灵活的数据模型，更强大的查询语言和更好的可扩展性。
+官网: InfluxDB OSS 2.3 Documentation (influxdata.com)
+如果你想更深入地了解InfluxDB的功能和用法，我强烈建议你去多看官方文档。官方文档是InfluxDB的最权威和最全面的资料来源，它包含了InfluxDB的安装，配置，管理，查询，分析，可视化等方面的详细说明和示例。官方文档还提供了一些常见问题和解决方案，以及一些最佳实践和技巧。官方文档是你学习和使用InfluxDB的最好的伙伴。
+在InfluxDB中,配置文件默认是不存在的,需要执行以下命令进行生成,流入数据库配置选项 |InfluxDB OSS 2.3 文档 (influxdata.com)
+docker run --rm influxdb:2.3.0 influx server-config > config.yml
+具体内容如下:
+{
+ "assets-path": "",
+ "bolt-path": "/var/lib/influxdb2/influxd.bolt",
+ "e2e-testing": false,
+ "engine-path": "/var/lib/influxdb2/engine",
+ "feature-flags": null,
+ "flux-log-enabled": false,
+ "hardening-enabled": false,
+ "http-bind-address": ":8086",
+ "http-idle-timeout": 180000000000,
+ "http-read-header-timeout": 10000000000, #服务器应尝试读取新请求的 HTTP 标头的最长持续时间。设置为 0 表示没有超时
+ "http-read-timeout": 0, # 读超时
+ "http-write-timeout": 0, # 写超时
+ "influxql-max-select-buckets": 0,
+ "influxql-max-select-point": 0,
+ "influxql-max-select-series": 0,
+ "instance-id": "",
+ "log-level": "info", # 日志输出级别
+ "metrics-disabled": false,
+ "nats-max-payload-bytes": 0,
+ "nats-port": 4222,
+ "no-tasks": false,
+ "pprof-disabled": false,
+ "query-concurrency": 1024, # 允许并发执行的查询数。
+ "query-initial-memory-bytes": 0, # 为查询分配的初始内存字节数。
+ "query-max-memory-bytes": 0, # 允许查询的最大内存总字节数。 等于查询并发×单次查询内存字节数
+ "query-memory-bytes": 0, # 单个查询允许的最大内存字节数。必须大于或等于 query-initial-memory-bytes 。
+ "query-queue-size": 1024, # 执行队列中允许的最大查询数。当达到队列限制时，新查询将被拒绝。
+ "reporting-disabled": false,
+ "secret-store": "bolt",
+ "session-length": 60,
+ "session-renew-disabled": false,
+ "sqlite-path": "/var/lib/influxdb2/influxd.sqlite",
+ "storage-cache-max-memory-size": 1073741824, # 控制存储引擎内存缓存的大小，以字节为单位。
+ "storage-cache-snapshot-memory-size": 26214400, # 控制存储引擎快照使用的内存大小，以字节为单位。
+ "storage-cache-snapshot-write-cold-duration": "10m0s", # 控制存储引擎冷数据快照写入的时间。
+ "storage-compact-full-write-cold-duration": "4h0m0s", # 控制存储引擎数据压缩的时间。
+ "storage-compact-throughput-burst": 50331648,
+ "storage-max-concurrent-compactions": 0,
+ "storage-max-index-log-file-size": 1048576,
+ "storage-no-validate-field-size": false,
+ "storage-retention-check-interval": "30m0s",
+ "storage-series-file-max-concurrent-snapshot-compactions": 0,
+ "storage-series-id-set-cache-size": 0,
+ "storage-shard-precreator-advance-period": "30m0s",
+ "storage-shard-precreator-check-interval": "10m0s",
+ "storage-tsm-use-madv-willneed": false,
+ "storage-validate-keys": false,
+ "storage-wal-fsync-delay": "0s",
+ "storage-wal-max-concurrent-writes": 0,
+ "storage-wal-max-write-delay": 600000000000,
+ "storage-write-timeout": 10000000000,
+ "store": "disk",
+ "testing-always-allow-setup": false,
+ "tls-cert": "",
+ "tls-key": "",
+ "tls-min-version": "1.2",
+ "tls-strict-ciphers": false,
+ "tracing-type": "",
+ "ui-disabled": false,
+ "vault-addr": "",
+ "vault-cacert": "",
+ "vault-capath": "",
+ "vault-client-cert": "",
+ "vault-client-key": "",
+ "vault-client-timeout": 0,
+ "vault-max-retries": 0,
+ "vault-skip-verify": false,
+ "vault-tls-server-name": "",
+ "vault-token": ""
+}
+我是基于Docker部署的InfluxDB2.3版本,docker-compose配置文件如下:
+version: "3.1"
+services:
+ influxdb:
+ image: influxdb:2.3.0
+ container_name: influxdb
+ ports:
+ - "8086:8086"
+ volumes:
+ - influxdbv2:/var/lib/influxdb2
+ - config.yml:/home/config.yml
+ environment:
+ - DOCKER_INFLUXDB_INIT_MODE=setup
+ - DOCKER_INFLUXDB_INIT_USERNAME=admin
+ - DOCKER_INFLUXDB_INIT_PASSWORD=admin123
+ - DOCKER_INFLUXDB_INIT_ORG=myorg
+ - DOCKER_INFLUXDB_INIT_BUCKET=mybucket
+ - DOCKER_INFLUXDB_INIT_RETENTION=1w
+ - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=mytoken
+ restart: always
+这个文件定义了一个名为influxdb的服务，它使用influxdb:2.3这个镜像来创建一个容器，它将容器的8086端口映射到主机的8086端口，它将容器的/var/lib/influxdb2目录挂载到主机的influxdbv2这个卷上，它设置了一些环境变量来初始化InfluxDB的用户，组织，存储桶，保留策略和令牌。
+针对内存占用空间过大的问题,可以尝试以下方法:
+GC优化
+参考: HTSI 模式内存使用率高
+- GODEBUG=madvdontneed=1
+- GOGC=80
+GODEBUG=madvdontneed=1可以减少InfluxDB的虚拟内存占用，而GOGC=80可以减少InfluxDB的实际内存占用。
+时序型数据在InfluxDB中是以一种叫做行协议（line protocol）的格式来表示的。行协议是一种文本格式，它由四个部分组成：
+行协议的格式如下：
+measurement,tag_key=tag_value field_key=field_value timestamp
+例如，一个表示温度的行协议可以是这样的：
+temperature,device_id=123,location=room1 value=25.6 1631377078000000000
+这表示在1631377078000000000纳秒（2023-09-11T15:17:58Z）时，设备ID为123，位置为room1的温度值为25.6摄氏度。
+为了使数据模型易于查询且性能高效，需要遵循以下设计原则：
+location标签快速定位到相关的数据点，而不需要扫描所有的字段值。region标签直接过滤出相关的数据点，而不需要从location标签中提取出区域信息。收集数据是InfluxDB的第一个步骤，它指的是如何将时序型数据从不同的来源传输到InfluxDB中。时序型数据可以来自于各种设备，应用程序，服务，监控系统，日志系统等。为了方便地收集数据，InfluxDB提供了多种方法，包括：
+每种方法都有其优缺点，你可以根据你的需求和场景来选择合适的方法。下面我会简单地比较一下这些方法：
+| 方法 | +优点 | +缺点 | +
|---|---|---|
| Telegraf | +简单易用，支持多种插件，高效稳定 | +不够灵活，不能处理复杂的逻辑 | +
| Flux | +强大灵活，支持多种函数和操作符，易于调试 | +需要学习新的语言，性能可能受限 | +
| HTTP API | +直接高效，支持多种格式和参数，兼容多种工具 | +需要编写HTTP请求，不够友好 | +
| 客户端库 | +方便集成，支持多种语言，提供高级功能 | +需要安装依赖，可能存在兼容性问题 | +
这里我提供一个基于Java的实现!
+1.导入依赖
+<dependency>
+ <groupId>com.influxdb</groupId>
+ <artifactId>influxdb-client-java</artifactId>
+ <version>3.1.0</version>
+</dependency>
+2.创建连接
+package example;
+
+import com.influxdb.client.InfluxDBClient;
+import com.influxdb.client.InfluxDBClientFactory;
+
+public class InfluxDB2Example {
+
+ public static void main(final String[] args) {
+
+ // You can generate an API token from the "API Tokens Tab" in the UI
+ String token = "1231231243214234==";
+ String bucket = "wangwang";
+ String org = "wangwang";
+
+ InfluxDBClient client = InfluxDBClientFactory.create("http://127.0.0.1:8086", token.toCharArray());
+ }
+}
+3.写入数据
+import com.influxdb.client.WriteApiBlocking;
+import com.influxdb.client.write.Point;
+import java.time.Instant;
+
+// ...
+
+Point point = Point
+ .measurement("mem")
+ .addTag("host", "host1")
+ .addField("used_percent", 23.43234543)
+ .time(Instant.now(), WritePrecision.NS);
+
+WriteApiBlocking writeApi = client.getWriteApiBlocking();
+
+writeApi.writePoint(bucket, org, point);
+在InfluxDB2.3版本中,用的是Flux语法,这个在以前1.x的版本中用的是InfluxQL语法.
+查询InfluxDB的数据主要是以下步骤:
+示例
+这个查询会从example-bucket存储桶中获取最近一小时内度量为temperature的数据，并且对_value列求平均值。
+from(bucket: "example-bucket")
+ |> range(start: -1h)
+ |> filter(fn: (r) => r._measurement == "temperature")
+ |> mean(column: "_value")
+InfluxDB提供了很多函数,可以参考官方文档:使用 Flux 查询数据,或者文章结尾参考的网址!
+在官方的控制面板,也可以看到各个API的说明!
+
+ ++
| 参数 | +类型 | +说明 | +示例 | +
|---|---|---|---|
| 请求方法 | +字符串 | +指定HTTP请求的方法，必须为POST | +POST | +
| 标题 | +字典 | +指定HTTP请求的头部信息，包括授权和内容类型 | +{“Authorization”: “Token mytoken”, “Content-Type”: “application/json”} | +
| 查询参数 | +字典 | +指定HTTP请求的查询参数，包括组织名称或ID和存储桶名称或ID | +{“org”: “myorg”, “bucket”: “mybucket”} | +
| 请求正文 | +JSON对象 | +指定HTTP请求的正文内容，包括开始时间，结束时间和删除条件语句 | +{“start”: “1970-01-01T00:00:00Z”, “stop”: “2023-09-11T15:17:58Z”, “predicate”: “_measurement=”temperature” AND value>30”} | +
curl --request POST http://localhost:8086/api/v2/delete?org=example-org&bucket=example-bucket \
+ --header 'Authorization: Token YOUR_API_TOKEN' \
+ --header 'Content-Type: application/json' \
+ --data '{
+ "start": "2020-03-01T00:00:00Z",
+ "stop": "2020-11-14T00:00:00Z",
+ "predicate": "_measurement=\"example-measurement\" AND exampleTag=\"exampleTagValue\""
+ }'
+curl --request POST http://localhost:8086/api/v2/delete?org=example-org&bucket=example-bucket \
+ --header 'Authorization: Token YOUR_API_TOKEN' \
+ --header 'Content-Type: application/json' \
+ --data '{
+ "start": "2020-03-01T00:00:00Z",
+ "stop": "2020-11-14T00:00:00Z"
+ }'
+如果请求成功，你应该看到一个空白的响应。如果请求失败，你应该看到一个包含错误信息的响应。
+InfluxDB中的定时任务是一种使用Flux语言编写的定期执行的脚本，它可以对输入的数据流进行修改或分析，然后将修改后的数据写回到InfluxDB或执行其他操作。定时任务的功能包括：
+示例
+// Task options
+option task = {name: "downsample_5m_precision", every: 1h, offset: 0m}
+
+// Data source
+from(bucket: "example-bucket")
+ |> range(start: -task.every)
+ |> filter(fn: (r) => r._measurement == "mem" and r.host == "myHost")
+ // Data processing
+ |> aggregateWindow(every: 5m, fn: mean)
+ // Data destination
+ |> to(bucket: "example-downsampled")
+备份
+influx backup <backup-path> -t <root-token>
+还原
+所有数据
+influx restore /backups/2020-01-20_12-00/
+特定桶数据
+influx restore \
+ /backups/2020-01-20_12-00/ \
+ --bucket example-bucket
+
+# OR
+
+influx restore \
+ /backups/2020-01-20_12-00/ \
+ --bucket-id 000000000000
+influxdata/influxdb-client-java
+可以参考:常见问题 |InfluxDB OSS 2.3 文档 (influxdata.com)
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 在计算机世界中，只有待解决的问题变得大规模后，算法的价值才能够最大化的体现。时间轮算法可以将插入和删除操作的时间复杂度都降为 O(1)，在大规模问题下还能够达到非常好的运行效果。
+如果我们要实现一个定时任务该如何实现呢？
+最简单的方式就是使用一个任务队列来完成定时任务。具体实现细节下面详细展开。
+1.线程模型
+2.定时任务
+定时任务分为一次性执行的定时任务以及重复执行任务。
+3.任务队列数据结构
+为了方便向任务队列中增减任务，通常会选择双向链表作为数据结构来实现任务队列。
+这种方式不过是基于异步队列，然后为每一个任务提供一个时间戳字段。这种实现策略的问题在哪里？
+如果有 1k 个任务，那么定时任务队列轮询线程每次都需要扫描 1k 个任务来确定哪一个任务达到规定时刻，这种轮询效率非常差，尤其是在大部分任务并没有达到规定执行时刻的情况下。
+为了解决上述问题，我们可以使用如下两种方式：
+在计算机算法中，有序性通常能够显著提高遍历效率。我们现在将一个普通任务队列升级为一个按照任务执行的时间戳递增的有序任务队列。这样一来，定时任务队列轮询线程从头向尾遍历时，在发现任意线程未达到规定执行时间戳后，就可以停止遍历。此时，定时任务队列轮询线程甚至可以进行休眠操作，避免空轮询。
+但是，有序性并非没有代价。插入一个定时任务的事件复杂度为 O(nlogn)，普通任务队列的插入仅仅是 O(1)。
+我们再来看看另一种实现策略：任务分类+多队列+并发线程。这种方式主要是试图利用现代 CPU 的多核并发性来解决遍历效率低的问题。例如我们将 10k 大小的任务队列分为 10 个任务队列，此时每一个任务队列的大小仅仅是 1k。在线程完全并发执行的情况下，将 10k 规模的问题简化为 1k 规模的问题。
+不过，多并发线程轮询的副作用非常大：线程是一种宝贵资源，如果一个系统有大量的定时调度任务，那么 CPU 会因为多条并发轮询线程而有着非常低的执行效率。
+现在我们知道一个定时任务框架需要如下几个要素：
+时间轮算法解决了基于队列的定时任务执行模型的缺陷，下一节将详细介绍时间轮算法思想。
+无论通过何种方式实现定时任务队列，最终需要向上层提供如下接口：
+时间轮算法的核心是：轮询线程不再负责遍历所有任务，而是仅仅遍历时间刻度。时间轮算法好比指针不断在时钟上旋转、遍历，如果一个发现某一时刻上有任务（任务队列），那么就会将任务队列上的所有任务都执行一遍。
+时间轮算法不再将任务队列作为数据结构，其数据结构如下图所示（我们以小时为单位）：
+
++图-1 时间轮数据结构示意图（黄色块为时间刻度，绿色块为任务）
+
显而易见，时间轮算法解决了遍历效率低的问题。时间轮算法中，轮询线程遍历到某一个时间刻度后，总是执行对应刻度上任务队列中的所有任务（通常是将任务扔给异步线程池来处理），而不再需要遍历检查所有任务的时间戳是否达到要求。
+现在，即使有 10k 个任务，轮询线程也不必每轮遍历 10 k 个任务，而仅仅需要遍历 24 个时间刻度。
+一个以小时为单位的时间轮算法就这么简单地实现了。不过，小时作为时间单位粒度太大，我们有时候会希望基于分钟作为时间刻度。最直接的方式是增加时间刻度，每一天有 24 * 60 = 1440。此时时间轮的数据结构如下：
+
++图-2 时间精度为分钟的时间轮数据结构
+
通过增加时间刻度，我们可以基于更精细的时间单位（分钟）来进行定时任务的执行。但是，这种实现方式有如下的缺陷：
+如果要将时间精度设为秒，那么整个时间轮将需要 86400 个单位的时间刻度，此时时间轮算法的遍历线程将遇到更大的运行效率低的问题。下面两个小节将着力解决此问题。
+我们发现，时间轮的时间刻度随着时间精度而增加并不是一个好的问题解决思路。现在，我们将时间轮的精度设置为秒，时间刻度个数固定为 60。每一个任务拥有一个 round 字段。
+轮询线程的执行逻辑是：每隔一秒处理一个时间刻度上任务队列中的所有任务，任务的 round 字段减 1，接着判断如果 round 字段的值变为 0，那么将任务移出任务队列，交给异步线程池来执行对应任务。如果是重复执行任务，那么再将任务添加到任务队列中。
+轮询线程遍历一次时间轮需要 60 秒。如果一个任务需要间隔 x 秒执行一次，那么其 round 字段的值为 x/60（整除），任务位于第 (x%60)（取余）个刻度对应的任务队列中。例如任务需要间隔 130 秒执行一次，那么 round 字段的值为 2，此任务位于第 10 号时间刻度的任务队列中。
+此时时间轮算法的数据结构如下图所示：
+
++图-3 时间精度为秒的 round 时间轮数据结构
+
这种方式虽然简化了时间轮的刻度个数，但是并没有简化轮询线程运行效率不高的问题。时间轮每次处理一个时间刻度，就需要处理其上任务队列的所有任务。其运行效率甚至与基于普通任务队列实现的定时任务框架没有区别。
+分层的时间轮算法在生活中有对应的模型（艺术来源于生活~），那就是水表：
+
++图-4 水表
+
此时，我们有秒、分钟、小时级别的三个时间轮，每一个时间轮分别有 60、60、24 个刻度。分层时间轮如下图所示：
+
++图-5 一种分层时间轮数据结构
+
假设我们的任务需要在每天的 7:30:20 秒执行一次。任务首先添加于秒级别时钟轮的第 20 号刻度上，当其轮询线程访问到第 20 号刻度时，就将此任务转移到分钟级别时钟轮的第 30 号刻度上。当分钟级别的时钟轮线程访问到第 30 号刻度，就将此任务转移到小时级别时钟轮的第 7 号刻度上。当小时级别时钟轮线程访问到第 7 号刻度时，最终会将任务交给异步线程负责执行，然后将任务再次注册到秒级别的时间轮中。
+这种分层时钟轮算法设计具有如下的优点：
+如果任务按照分钟级别来定时执行，那么当分钟时间轮达到对应刻度时，就会将任务交给异步线程来处理，然后将任务再次注册到秒级别的时钟轮上。
+分层时间轮中的任务从一个时间轮转移到另一个时间轮，这类似于水表中小单位的表转弯一圈会导致高单位的表前进一个单位一样。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ sudo -i
+vi /root/.ssh/authorized_keys
+# 把ssh-rsa之前的内容都删除掉.
+#!/bin/bash
+echo root:123456 |sudo chpasswd root
+sudo sed -i 's/^#\?PermitRootLogin.*/PermitRootLogin yes/g' /etc/ssh/sshd_config;
+sudo sed -i 's/^#\?PasswordAuthentication.*/PasswordAuthentication yes/g' /etc/ssh/sshd_config;
+sudo service sshd restart
+iptables -P INPUT ACCEPT
+iptables -P FORWARD ACCEPT
+iptables -P OUTPUT ACCEPT
+iptables -F
+bash -c "echo 'TCPKeepAlive yes' >> /etc/ssh/sshd_config && echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config"
+systemctl restart sshd
+如今，随着科技的进步，翻译工具也越来越方便。在Edge浏览器中，有一款叫做“沉浸式翻译”的插件，可以帮助用户实时翻译网页内容。下面，我们来看一下如何使用这款插件。
+首先，我们需要在Edge浏览器的应用商店中安装“沉浸式翻译”插件。具体操作如下：
+
Microsoft Edge 应用商店
安装完成后，我们就可以开始使用该插件了。使用方法如下：
+
这就是“沉浸式翻译”插件的基本使用方法。不仅方便，还十分实用。它可以帮助我们在浏览国外网页时顺利阅读，避免因为语言不通而带来的困扰。
+使用“沉浸式翻译”插件时，请注意以下几点：
+“沉浸式翻译”插件是一款非常实用的工具，可以帮助我们轻松阅读国外网页。使用前请注意阅读其隐私政策和使用条款，以确保使用的安全性。如果你正在使用Edge浏览器，不妨试试这款插件，它一定会让你的网页阅读体验更加愉快。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 需要实现一个告警指定时间(N)内去重,并且定时(M)自动恢复的功能,即规定时间(N)内,不再发送同一个告警,并且当等待一段时间(M),若未再接收到告警,则触发消警(自动恢复)操作.
+++不符合业务需求,当一条同类型告警来临时,需要更新消息的失效时间,而mq进入队列的消息无法修改
+
使用步骤
+1.修改redis配置文件,notify-keyspace-events设置为Ex
+notify-keyspace-events Ex
+
+K 键空间事件，以__keyspace@<db>__前缀发布。
+E 键事件事件，以__keyevent@<db>__前缀发布。
+g 通用命令（非类型特定），如DEL，EXPIRE，RENAME等等
+$ 字符串命令
+l 列表命令
+s 集合命令
+h 哈希命令
+z 有序集合命令
+x 过期事件（每次键到期时生成的事件）
+e 被驱逐的事件（当一个键由于达到最大内存而被驱逐时产生的事件）
+A g$lshzxe的别名，因此字符串AKE表示所有的事件。
+2.程序测试
+ @Override
+ public void run(String... args) throws Exception {
+ SimpleDateFormat ft1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
+ for (int i = 1; i < 50000; i++) {
+ Calendar instance = Calendar.getInstance();
+ instance.add(Calendar.SECOND, i * 5);
+ Date date = instance.getTime();
+ redisTemplate.opsForValue().set( i + "@" + ft1.format(date), "value", i * 5, TimeUnit.SECONDS);
+ }
+
+ System.out.println("初始化key");
+ Thread.sleep(10000000);
+ System.out.println("休眠结束");
+ }
+
性能测试
+++./redis-benchmark -h 127.0.0.1 -p 6379 -c 20 -n 1000000 -t get -d 10 -P 8 -q
+
命令说明:
+ 向127.0.0.1:6379这个Redis发送100万个请求，使用20个长连接发送，所有请求都是get命令，每个get命令的包体为10字节，使用8条Pipeline通道发送，并且只显示requests per second这一个结果。
+参数说明:
+-h 目标Redis服务网络地址
+-p 目标Reids服务的端口
+-c 客户端并发长连接数
+-n 本次测试需要发起的请求数
+-t 测试请求的方法
+-d 测试请求的数据大小 字节
+-P 开启Pipeline模式，并制定Pipeline通道数量
+-q 只显示requests per second这一个结果
+本地redis测试
+| 连接数 | +字节长度 | +请求数 | +整体RPS | +单连接RPS | +
|---|---|---|---|---|
| 1 | +10 | +1000000 | +52408.16 | +52408.16 | +
| 1 | +59 | +1000000 | +53610.68 | +53610.68 | +
| 1 | +100 | +1000000 | +53963.63 | +53963.63 | +
| 1 | +1000 | +1000000 | +54451.40 | +54451.40 | +
| 1 | +10000 | +1000000 | +54725.55 | +54725.55 | +
| 5 | +59 | +1000000 | +67467.28 | +13493.45 | +
| 10 | +59 | +1000000 | +70407.66 | +7040.76 | +
| 50 | +59 | +1000000 | +60034.82 | +1200.69 | +
远程redis测试
+| 连接数 | +字节长度 | +请求数 | +整体RPS | +单连接RPS | +不开pipeline | +
|---|---|---|---|---|---|
| 1 | +10 | +1000000 | +12745.13 | +12745.13 | +1648.67 | +
| 1 | +59 | +1000000 | +12521.28 | +12521.28 | +1695.92 | +
| 1 | +100 | +1000000 | +12706.53 | +12706.53 | +1651.67 | +
| 1 | +1000 | +1000000 | +12842.72 | +12842.72 | +1611.79 | +
| 1 | +10000 | +1000000 | +13395.23 | +13395.23 | +1695.62 | +
| 5 | +59 | +1000000 | +54580.76 | +10916.15 | ++ |
| 10 | +59 | +1000000 | +98570.72 | +9857.07 | ++ |
| 50 | +59 | +1000000 | +79027.84 | +1580.55 | ++ |
程序内存,CPU占用
+
总结
+1.redis中存在10000左右过期key时,会导致监听有延迟出现,可能高达几分钟.
+2.当不在同一台服务器上时,redis的时间需要与程序的时间同步.
+3.redis中存入key的长度,在1000以下时,影响不大,存在跨服务器时,性能影响较大,可能与服务器性能,网络等多方面因素有关
+简介
+1.可设置Map中的Entry在一段时间后自动过期。
2.可设置Map最大容纳值，当到达Maximum size后，再次插入值会导致Map中的第一个值过期。
3.可添加监听事件，在监听到Entry过期时调度监听函数。
4.可以设置懒加载，在调用get()方法时创建对象。
使用步骤
+1.添加maven依赖
+<dependency>
+ <groupId>net.jodah</groupId>
+ <artifactId>expiringmap</artifactId>
+ <version>0.5.8</version>
+</dependency>
+2.测试代码
+// 测试监听时间有误差
+@Test
+ public void test9() throws InterruptedException {
+ ExpiringMap<String, String> map = ExpiringMap.builder()
+ .maxSize(100)
+ .variableExpiration()
+ .expirationPolicy(ExpirationPolicy.ACCESSED)
+ // 一个同步,一个异步
+ .asyncExpirationListener((ExpirationListener<String, String>) (key, value) -> System.out.println("key:" + key + " value:" + value + "\n失效时间:" + System.currentTimeMillis()))
+ .build();
+ System.out.println("当前时间:" + System.currentTimeMillis());
+ map.put("test", "test123", 6, TimeUnit.SECONDS);
+ Thread.sleep(5000);
+ System.err.println(map.get("test"));
+ Thread.sleep(10000);
+ System.err.println(map.get("test"));
+ }
+3.实测误差
+
性能测试
+
源码解析
+1.构建
+/**
+*
+* maxSize:map的最大长度,添加第1001个entry时,会导致第1个马上过期(即使没到过期时间)
+* expiration:过期时间和过期单位,设置过期时间,则永久有效.
+* expirationPolicy:过期策略的使用
+* CREATED： 在每次更新元素时，过期倒计时清零
+* ACCESSED： 在每次访问元素时，过期倒计时清零
+*
+* variableExpiration:允许更新过期时间值,如果不设置variableExpiration
+* 不允许更改过期时间,一旦执行更改过期时间的操作则会抛出UnsupportedOperationException异常
+* expirationListener:同步过期监听
+* asyncExpirationListener:异步过期监听
+* entryLoader:懒加载,调用get方法时若key不存在创建默认value
+*
+*/
+ExpiringMap<String, String> map = ExpiringMap.builder()
+ .maxSize(100000)
+ .expiration(1, TimeUnit.SECONDS)
+ .expirationPolicy(ExpirationPolicy.ACCESSED)
+ .variableExpiration()
+ .asyncExpirationListener(ExpiringMapTest::remindAsyncExpiration)
+ .entryLoader(name -> "default")
+ .build();
+2.初始化
+ private ExpiringMap(final Builder<K, V> builder) {
+ if (EXPIRER == null) {
+ synchronized (ExpiringMap.class) {
+ if (EXPIRER == null) {
+ EXPIRER = Executors.newSingleThreadScheduledExecutor(
+ THREAD_FACTORY == null ? new NamedThreadFactory("ExpiringMap-Expirer") : THREAD_FACTORY);
+ }
+ }
+ }
+
+ if (LISTENER_SERVICE == null && builder.asyncExpirationListeners != null) {
+ synchronized (ExpiringMap.class) {
+ if (LISTENER_SERVICE == null) {
+ LISTENER_SERVICE = (ThreadPoolExecutor) Executors.newCachedThreadPool(
+ THREAD_FACTORY == null ? new NamedThreadFactory("ExpiringMap-Listener-%s") : THREAD_FACTORY);
+ }
+ }
+ }
+
+ variableExpiration = builder.variableExpiration;
+ entries = variableExpiration ? new EntryTreeHashMap<K, V>() : new EntryLinkedHashMap<K, V>();
+ if (builder.expirationListeners != null)
+ expirationListeners = new CopyOnWriteArrayList<ExpirationListener<K, V>>(builder.expirationListeners);
+ if (builder.asyncExpirationListeners != null)
+ asyncExpirationListeners = new CopyOnWriteArrayList<ExpirationListener<K, V>>(builder.asyncExpirationListeners);
+ expirationPolicy = new AtomicReference<ExpirationPolicy>(builder.expirationPolicy);
+ expirationNanos = new AtomicLong(TimeUnit.NANOSECONDS.convert(builder.duration, builder.timeUnit));
+ maxSize = builder.maxSize;
+ entryLoader = builder.entryLoader;
+ expiringEntryLoader = builder.expiringEntryLoader;
+ }
+3.过期key存储,EntryMap,EntryLinkedHashMap,EntryTreeHashMap
+ private interface EntryMap<K, V> extends Map<K, ExpiringEntry<K, V>> {
+ /** Returns the first entry in the map or null if the map is empty. */
+ ExpiringEntry<K, V> first();
+
+ /**
+ * Reorders the given entry in the map.
+ *
+ * @param entry to reorder
+ */
+ void reorder(ExpiringEntry<K, V> entry);
+
+ /** Returns a values iterator. */
+ Iterator<ExpiringEntry<K, V>> valuesIterator();
+ }
+4.过期map实体ExpiringEntry,重写了compareTo方法,按过期时间从小到大排序
+ static class ExpiringEntry<K, V> implements Comparable<ExpiringEntry<K, V>> {
+ final AtomicLong expirationNanos;
+ /** Epoch time at which the entry is expected to expire */
+ final AtomicLong expectedExpiration;
+ final AtomicReference<ExpirationPolicy> expirationPolicy;
+ final K key;
+ /** Guarded by "this" */
+ volatile Future<?> entryFuture;
+ /** Guarded by "this" */
+ V value;
+ /** Guarded by "this" */
+ volatile boolean scheduled;
+
+
+ @Override
+ public int compareTo(ExpiringEntry<K, V> other) {
+ if (key.equals(other.key))
+ return 0;
+ return expectedExpiration.get() < other.expectedExpiration.get() ? -1 : 1;
+ }
+ }
+5.添加元素,过期key的实现逻辑
+ /**
+ * Puts the given key/value in storage, scheduling the new entry for expiration if needed. If a previous value existed
+ * for the given key, it is first cancelled and the entries reordered to reflect the new expiration.
+ */
+ V putInternal(K key, V value, ExpirationPolicy expirationPolicy, long expirationNanos) {
+ writeLock.lock();
+ try {
+ ExpiringEntry<K, V> entry = entries.get(key);
+ V oldValue = null;
+
+ if (entry == null) {
+ entry = new ExpiringEntry<K, V>(key, value,
+ variableExpiration ? new AtomicReference<ExpirationPolicy>(expirationPolicy) : this.expirationPolicy,
+ variableExpiration ? new AtomicLong(expirationNanos) : this.expirationNanos);
+ if (entries.size() >= maxSize) {
+ ExpiringEntry<K, V> expiredEntry = entries.first();
+ entries.remove(expiredEntry.key);
+ notifyListeners(expiredEntry);
+ }
+ entries.put(key, entry);
+ if (entries.size() == 1 || entries.first().equals(entry))
+ scheduleEntry(entry);
+ } else {
+ oldValue = entry.getValue();
+ if (!ExpirationPolicy.ACCESSED.equals(expirationPolicy)
+ && ((oldValue == null && value == null) || (oldValue != null && oldValue.equals(value))))
+ return value;
+
+ entry.setValue(value);
+ resetEntry(entry, false);
+ }
+
+ return oldValue;
+ } finally {
+ writeLock.unlock();
+ }
+ }
+ /**
+ * Schedules an entry for expiration. Guards against concurrent schedule/schedule, cancel/schedule and schedule/cancel
+ * calls.
+ *
+ * @param entry Entry to schedule
+ */
+ void scheduleEntry(ExpiringEntry<K, V> entry) {
+ if (entry == null || entry.scheduled)
+ return;
+
+ Runnable runnable = null;
+ synchronized (entry) {
+ if (entry.scheduled)
+ return;
+
+ final WeakReference<ExpiringEntry<K, V>> entryReference = new WeakReference<ExpiringEntry<K, V>>(entry);
+ runnable = new Runnable() {
+ @Override
+ public void run() {
+ ExpiringEntry<K, V> entry = entryReference.get();
+
+ writeLock.lock();
+ try {
+ if (entry != null && entry.scheduled) {
+ entries.remove(entry.key);
+ notifyListeners(entry);
+ }
+
+ try {
+ // Expires entries and schedules the next entry
+ Iterator<ExpiringEntry<K, V>> iterator = entries.valuesIterator();
+ boolean schedulePending = true;
+
+ while (iterator.hasNext() && schedulePending) {
+ ExpiringEntry<K, V> nextEntry = iterator.next();
+ if (nextEntry.expectedExpiration.get() <= System.nanoTime()) {
+ iterator.remove();
+ notifyListeners(nextEntry);
+ } else {
+ scheduleEntry(nextEntry);
+ schedulePending = false;
+ }
+ }
+ } catch (NoSuchElementException ignored) {
+ }
+ } finally {
+ writeLock.unlock();
+ }
+ }
+ };
+ // 添加延时任务
+ Future<?> entryFuture = EXPIRER.schedule(runnable, entry.expectedExpiration.get() - System.nanoTime(),
+ TimeUnit.NANOSECONDS);
+ entry.schedule(entryFuture);
+ }
+ }
+总结
+1.实测内存,CPU占用,以及失效监听触发延时都优于使用redis
+2.符合业务需求
+每个需求都有不同的解决方案,不要吊死在一棵树上!
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 登录Oralce网页平台,调整硬盘空间.默认免费200G额度,根据个人所开机器计算剩余空间!
+
SSH连接需要扩容的服务器.按如下命令操作!
+# 安装
+sudo apt-get install parted
+
+# 进入
+parted
+
+# 选择设备
+select /dev/sda
+
+# 看分区表，找到对应 ID
+print
+
+# 假设是 2 ，调整 2 分区的尺寸，输入尺寸确定
+resizepart 2
+
+# 退出
+quit
+
+# 这时候分区表已经改了，但文件系统还没更新，一般是 ext4 所以可以用这个更新
+sudo apt-get install e2fsprogs
+
+# 更新文件系统信息
+resize2fs /dev/sda2
+输入df -h即可查看!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ Perplexity AI 现在可免费领取 2 月 PRO 会员
https://www.perplexity.ai/pro?discount_code=THANKS23
+ 微信支付
+
+ 支付宝支付
+
+
+ 官网地址 : https://nic.eu.org/
+1）账号注册需要注意NAME格式 名 空格 姓，邮箱填写正确能接收邮件就好！
+
2）邮箱会收到一封邮件，点击激活链接！XXXXX-FREE 就是账号！
+
3）登陆网站准备申请域名，点击【New Domain】
+
1）domain name 填写你要申请的域名，长度需要大于3位字符。
+最下方有Name Servers填写 DNS服务商的NS
+
Name servers 选择第一个来验证即可！
+
2）点击提交后，提示没有错误即可！等待审核！
+
3）审核速度不确定，有时候秒批，有时候等几个月！
+博主亲测，等了2小时通过审核了。
+审核通过后会发送一封邮件通知，直接登录平台可以看见申请的域名！
+
1）点击右侧的编辑按钮，可以修改或者删除域名。
+
2）当然可以修改NS信息，比如接入Cloudflare
+eu.org已经好多年了，相对来说还算稳定。不过申请的人多了可能存在各种擦边的东东，很有可能被一刀切。
+如果真心好好建站还是建议买个付费的域名！这样比较长久！
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ https://ali.wangzai.top/d/onedrive/%E8%BD%AF%E4%BB%B6/bd_download_.exe
+启动软件
+
前往百度文库,复制自己想要下载文档的地址
+
按提示操作,即可下载文件
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 最近为了下载百度网盘上的一些学习资料,发现了一个免费告诉下载的方法,下面教大家如何使用!
+油猴官网安装：https://tampermonkey.net/
+
油猴插件地址:https://greasyfork.org/zh-CN,点击浏览此网站,即可下载合适的插件.
+
分享一下个人使用的插件,可自行从上面搜索安装
+
安装完成插件之后,打开百度网盘.登录账号,选中文件即可进行下载
+
点击链接即可开始下载,也可以安装IDM等进行下载.
+
请参考公众号: 一只会飞的旺旺
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ # 查看总磁盘占用量
+df -hl
+ls -l
+# 按照M显示
+ls -l --block-size=m
+# 查看当前文件
+du -sh .
+# 查看指定文件夹
+du -sh /home/*
+docker stats
+docker system df
+# 或
+df -Th /var/lib/docker/
+docker system df -v
+docker ps --format "table {{.Size}}\t{{.Names}}"
+# 进入容器目录
+cd /var/lib/docker/containers
+# 查看哪个容器占用大
+du -sh .
+# 也可以具体进入某个容器
+cd /var/lib/docker/containers/a40b469c66170a20baef5d650e6584de71d74fd1f33351955a1ec128de73de05
+# 查看文件大小
+ls -l --block-size=m
+# 清理日志
+cat /dev/null > /var/lib/docker/containers/73de05/73de05-json.log
+日志清理脚本
+#!/bin/sh
+echo "======== start clean docker containers logs ========"
+
+logs=$(find /var/lib/docker/containers/ -name *-json.log)
+
+for log in $logs
+ do
+ echo "clean logs : $log"
+ cat /dev/null > $log
+ done
+
+echo "======== end clean docker containers logs ========"
+1.寄存器: 用来暂存指令,数据等处理对象
+2.控制器: 负责把内存上的指令,数据读入寄存器,并根据指令执行结果来控制整个计算机
+3.运算器: 负责从内存读入寄存器的数据
+4.时钟: 负责发出CPU开始计时的时钟信号
+
1.程序计数器: 是决定程序流程的寄存器,它指向下一条执行的指令
+2.程序流程: 顺序执行,条件分支,循环
+3.程序中的比较指令,就是在CPU内部做减法运算
+
4.函数调用机制
+
1.IC的所有引脚,只有直流电压的0v和5v两个状态,这也是二进制的由来.它只有0和1两种数字。
+2.计算机处理信息的最小单位为位,一个字节等于8位
+3.二进制和十六进制之间可以进行相互转换，每4位二进制数对应1位十六进制数。
+4.Java中可以用0b或0B开头表示二进制数，用0x或0X开头表示十六进制数。
+
1.移位运算符有两种：左移运算符（<<）和右移运算符（>>），分别表示将一个数的各二进制位向左或向右移动若干位。
+2.移位运算中，无符号数和有符号数的运算并不相同。对于无符号数，右移之后高位补0；对于有符号数，符号位一起移动，正数高位补0，负数高位补1
+3.移位运算的优先级比算术运算符、关系运算符、逻辑运算符和其他运算符都低
+4.表示负数时,使用的是二进制的补数,即负数的绝对值的二进制数,取反+1
+逻辑右移和算术右移的区别是：
+补码和反码是用来表示负数的方法：
+逻辑运算: 包括逻辑非(NOT),逻辑与(AND),逻辑或(OR),逻辑异或(^)
+
RLE算法是一种简单的无损压缩算法，它利用数据中的重复性，将连续出现的相同数据用一个计数值和一个数据值来表示。例如，AAAAABBBBCCCC可以压缩为5A4B4C。
+RLE算法适合于处理有大量重复数据的文件，如图像、音频等。RLE算法的优点是压缩和解压速度快，算法简单易实现；缺点是压缩率较低，对于没有重复数据的文件无法压缩甚至可能增大文件大小。
+哈夫曼编码是一种基于概率的无损压缩算法，它根据数据中每个符号出现的频率，构建一棵二叉树，给每个符号分配一个不同长度的二进制编码。出现频率高的符号分配较短的编码，出现频率低的符号分配较长的编码。例如，如果一个文件中A出现了45次，B出现了13次，C出现了12次，D出现了16次，E出现了9次，F出现了5次，则可以构建如下图所示的哈夫曼树，并给每个符号分配如下表所示的编码。
+| Symbol | +Frequency | +Code | +
|---|---|---|
| A | +45 | +0 | +
| B | +13 | +101 | +
| C | +12 | +100 | +
| D | +16 | +111 | +
| E | +9 | +1101 | +
| F | +5 | +1100 | +
系统是一组相互关联的部件，它们共同完成一个特定的功能或目标。系统可以分为硬件系统和软件系统。硬件系统是由物理设备组成的，如CPU、内存、硬盘等。软件系统是由程序和数据组成的，如操作系统、应用程序等。
+系统可以提高效率、可靠性和安全性。例如，操作系统是一种软件系统，它管理和控制硬件资源，提供用户界面和服务，保护数据和程序不被破坏或泄露。应用程序是一种软件系统，它实现用户的需求和功能，如浏览器、游戏、办公软件等。
+编译：将源代码转换为目标代码，即机器语言或汇编语言。不同的编程语言有不同的编译器，如Java有javac，C有gcc等。
+链接：将多个目标代码文件和库文件合并为一个可执行文件。链接可以分为静态链接和动态链接。静态链接是在编译时进行的，将所有依赖的库文件嵌入到可执行文件中。动态链接是在运行时进行的，将依赖的库文件加载到内存中，并通过地址重定位来连接到可执行文件中。
+加载：将可执行文件从磁盘加载到内存中，并分配必要的资源，如栈、堆、寄存器等。
+应用是用户通过操作系统来启动和使用的软件系统。当用户运行一个应用时，操作系统会创建一个进程来表示该应用，并为其分配一个虚拟地址空间和一些其他资源。进程是操作系统管理和调度的基本单位，它包含了应用运行所需的所有信息，如程序计数器、状态寄存器、堆栈指针等。操作系统通过进程控制块（PCB）来存储进程的信息，并通过进程表来管理所有进程。操作系统还负责在多个进程之间进行切换和调度，以实现多任务和并发。
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 前几天笔记本突然独显找不到了,具体状况如下:
+
我首先根据网络上的教程试了一遍,均不能解决,可以参考:Win11系统中未检测到nvidia显卡解决教程
+从nvidia官网直接下载驱动安装提示会出现图一的情况!
+最后,通过GeForce Experience这款软件,倒是正常安装上驱动了,有问题的也可以尝试一下!避免重装电脑或者送修!
+软件地址: GeForce_Experience
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ Docker是一个开源的软件平台，可以让您轻松地构建、运行和共享应用程序。Docker使用容器技术，可以将应用程序和它们所需的依赖项打包在一起，从而实现快速部署、可移植性和一致性。Docker还提供了工具和服务来管理和编排容器，以支持复杂的分布式应用程序。本书将教您如何使用Docker来开发、测试和部署各种类型的应用程序。
+参考: Docker 教程 | 菜鸟教程 (runoob.com)
+# 下面是一个简单的docker-compose.yml文件，用于创建一个web服务和一个redis服务
+version: '3'
+services:
+ web:
+ build: .
+ ports:
+ - "5000:5000"
+ volumes:
+ - .:/code
+ depends_on:
+ - redis
+ redis:
+ image: "redis:alpine"
+这本书主要介绍了Docker的基本概念、安装、使用、镜像、测试、构建服务和编排等方面。如果想要深入学习Docker的其他方面，可以参考以下推荐：
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 1.一个能接收短信的国内手机号2.一个全新邮箱（指从没注册过Apple ID的邮箱）3.美国地址生成器（后面我会给大家提供）4.无需任何代理工具
+注意以下四点可以避免很多问题：
+出生日期：一定要设置成大于 18 周岁的日期，否则会导致部分应用由于年龄限制无法使用。
+电子邮件：建议新注册一个全新的从未注册过 Apple ID 的邮箱，比如 163 邮箱。
+手机号码：亲测，注册过中国区 Apple ID 的手机号码可以用来注册美区账号，不会产生冲突。
+密码：设置密码时，密码中不要包含有名字、生日、邮箱中的信息，否则会卡在验证码那一步。
+为了方便大家注册，该方法全程都在手机中操作，不用借助电脑。
+首先进入美国 Apple ID 注册页面，复制下方网址至 Safari 浏览器中打开即可进入。
+https://appleid.apple.com/account
+具体注册方法如下长图，跟着我的步骤走就行了，一定要严格按照我写的要求操作。
+
接着需要对电子邮件/手机号码进行验证。把收到的验证码输入进去，依次点击下一步就行了。
+
注册成功后，账号会自动登录，如果没登录的话重新登录一遍刚注册的账号即可。
+接着点击退出登录左边的“箭头”然后点击付款方式，接着再点击添加付款方式。
+
下一步是填写付款方式&账单地址，这步很关键，需要借助美国地址生成器，它会自动帮你生成街道地址、城市、邮编、电话号码等信息。
+生成地址前，建议选以下五个免税州：蒙大拿州（Montana）俄勒冈州（Oregon）
+阿拉斯加州（Alaska）
+特拉华州（Delaware）
+新罕布什尔州（New Hampshire）
+网址一：https://www.meiguodizhi.com/
+ +网址三：https://www.shenfendaquan.com/
+下图中标注的由美国地址生成器生成的内容，直接复制美国地址生成器中生成的内容即可。
+
接着勾选拷贝账单寄送地址，最后点击更新就行了。
+
到这里我们的美区 Apple ID 就注册完成了！下面教大家如何登录。
+打开 App Store，首先退出当前账号。点击右上角的头像，然后拉到末尾，点击退出登录即可。
+
接着再次点击 App Store 中右上角的头像，输入前面注册的美区账号&密码，点击登录即可。
+
然后会跳出一个弹窗，选择检查即可，接着打开同意条款与条件，选择下一页。
+
不要修改任何内容，直接点击下一页，然后点击继续。
+
点击Continue，到这里我们的美区 Apple ID 就已经成功登录了。
+
注册登录成功后，我们就能下载美区中的各种 App 了。
+
1.设置密码时，密码中不要包含前面填写的名字、生日、邮箱中的任何信息，否则可能会卡在验证码那一步，总之就是密码尽量原创一个。
+2.不要在「设置」中登录美区Apple ID，以免造成不必要的麻烦。下载美区 App 只需在 App Store 中登录即可，下载完后再换回国区账号即可，对 iCloud 等不会有任何影响。
+3.如果你有在用Apple Music，切换成美区后会导致已下载的歌曲全被清空。
+4.建议不要把美区 Apple ID 当成主力账号，需要下美区应用时登录就行了，以免出现啥问题。
+➊ 手机号码提示错误怎么解决？
+答：看看复制的号码是不是开头有数字”1”或者”+1”，有的话去掉即可。
+➋ 更新 App 的时候显示账号被锁定，但可以下载未下载过的 App 是什么原因？
+答：因为你更新的这个 App 之前是用其他 Apple ID 下载的，所以这个 App 是和你之前下载时的那个 Apple ID 绑定在一起的，所以出现被锁定的提示是原先账号出了问题，和当前账号没关系。解决方法很简单，把 App 卸载重新安装即可。
+➌ 邮编错误怎么办？
+答：估计是地址生成器网站数据库中的部分邮编有误，多生成几份地址试试即可。
+➍ Your request could not be completed at this time 怎么办？
+答：应该是地址生成器生成的号码有问题，电话是 xxx-xxx-xxx 的正常，而 +1xxx-xxx-xxx 就不行。解决方法就是去掉号码开头的”1”或者”+1”即可。
+➎ Cannot be created at this time 怎么办？
+答：切换成 4G、5G、或者换个浏览器、或者用电脑注册，或者次日再试试。
+➏ 注册成功后，如何二次修改美区 Apple ID 的地址、姓名等信息？
+答：进入美国苹果官网，拉到底部找到 manage your apple id，登录后即可修改，不懂英文的同学可借助翻译。
+如果以上回答仍然无法解决你的问题，那建议用百度、必应、知乎等搜索工具去寻找解决方法。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ 我最近读了美团技术团队 (meituan.com)的博客，发现其中的文章涵盖了各种有关技术的话题，对我的学习和职业发展都有很大帮助。因此，我写了一篇总结文章，记录了其中的要点和对工作的启示，希望能为其他技术从业者带来一些灵感和启示。感谢美团技术团队的博客作者提供如此丰富和有价值的资源。
+数据脱敏需要根据具体的业务需求和数据安全等级进行梳理和设计，美团根据自身特有的业务场景和数据安全级别划分（绝密、高保密、保密、可公开），主要从“高保密”等级的敏感数据开始进行梳理，并确定了四种基本类型的脱敏方案。
+针对数据脱敏,需要遵循两个原则:
+常用的方法有:
+具体的实现方案有:
+这篇文章介绍了基于solrcloud实现的商家搜索关键字智能提示的方案，主要包括以下几个方面：
+这篇文章是从开发工程师的角度来介绍数据库索引的原理和如何优化慢查询的。文章主要包括以下几个方面：
+本文主要介绍了MySQL中InnoDB引擎的事务隔离级别和加锁机制，以及如何避免或解决不可重复读和幻读的问题。以下是一些要点和总结：
+以下是一些相关的解决方案或经验：
+本文主要是为了解决由以下三种情况所造成的性能问题：1. 日益增长的用户数量，2. 日渐复杂的业务，3. 急剧膨胀的数据。针对这些问题,提供了一些优化方案和思路
+设计原则:
+性能恶化模式:
+性能优化模式:
+本文介绍了Java中不同类型和特性的锁，以及它们的使用场景和实现原理。
+乐观锁与悲观锁
+CAS算法
+自旋锁
+synchronized关键字
+这篇文章主要介绍了NIO（Non-blocking I/O）模型的原理和优势，以及如何使用Java的API实现NIO的服务端和客户端程序。对于你的项目，如果你需要处理高并发和大量连接的I/O问题，那么NIO模型可能会给你带来一些启发。你可以参考以下几点：
+这篇文章主要介绍了服务容错的基本原则和一些常用的模式，如超时模式、重试模式、限流模式、令牌桶算法等，以及在美团点评的工程实践中的应用。对于你的项目，如果你需要设计一个分布式服务调用的系统，那么这篇文章可能会给你一些启发和指导，让你能够避免一些常见的问题，提高系统在故障发生时的存活能力。你可以参考文章中提到的一些模式和工具，根据自己的业务场景和需求选择合适的方案。
+这篇文章是关于分布式队列编程模型的介绍和应用，它可能对你的项目有以下几方面的启发：
+这篇文章介绍了美团外卖订单系统的演进过程，从早期的单应用架构到现在的分布式可扩展架构，以及在每个阶段遇到的业务特征、挑战和解决方案。如果你的项目也涉及外卖或O2O领域，这篇文章可能会对你有一些启发，比如：
+这些启发都是基于文章中提到的美团外卖订单系统的实践经验。
+这篇文章讨论了消息队列的设计要点及其用例。它探讨了设计消息队列时需要考虑的重要方面，并参考了许多成熟消息队列的重要想法。文章首先解释了什么时候你需要一个消息队列，然后从零开始分析设计一个消息队列时需要考虑到的问题，如RPC、高可用性、顺序和重复消息、可靠投递、消费关系解析等。它还分析了以Kafka为代表的pull模型所具备的优点。最后是一些高级主题，如用批量/异步提高性能、pull模型的系统设计理念、存储子系统的设计等。
+如果您正在设计或实现一个消息队列，或者您想更多地了解消息队列如何工作及其用例，那么这篇文章可能会为您的项目提供灵感。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ GitHub 图床本身比较好用，但由于其在国内没有节点，导致速度较慢。而使用jsdelivr加速依旧会被墙,无法解决国内正常访问博客图片的问题,为了解决以上问题，我打算使用腾讯CDN加速github图床
+打开图床的仓库,按图示配置个人域名
+
腾讯CDN新账号一般都会赠送流量.我们就可以白嫖啦!!!
+
按图示步骤,进入域名添加
+
按如图配置,加速域名填写自己的域名,源站地址填写 仓库名+github.io
+
前往HTTPS配置添加SSL证书,可以自行申请免费证书
+
最后完成域名添加即可!
+可以在picGo中使用当前的github图床上传图片,然后使用域名+仓库文件夹名+文件名的形式访问图片.如
+
若测试出来的IP都是腾讯云的,则说明加速成功,并且访问图片后,在腾讯云的CDN管理中,可以看到有流量消耗!
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 下面是一篇基于Chatgpt生成的软件介绍文档,你还不知道Chatgpt是啥?快看看我以前的文章吧!
+ 如果你是一个电视剧迷，那么你一定不能错过这款软件。这款软件叫做春秋岁月，它可以让你在手机、平板电脑上随时随地观看各种电视剧，包括奈飞新出的剧集。
+ 软件提供了海量的电视剧内容，包括国内外热门剧集、奈飞出品的剧集等。另外，它还提供了追剧提醒功能，让你不会错过任何一集。此外，它还有自动缓存功能，让你可以在没有网络的情况下观看已缓存的剧集。
+ 软件的界面简洁易用，让你可以轻松找到你想看的剧集。它还提供了多种播放模式，让你可以根据自己的喜好调整播放速度和画质。
+ 总的来说，该软件是一款不可多得的电视剧软件，让你可以随时随地追剧，并且提供了丰富的功能和优质的播放
+
春秋岁月：https://apps.apple.com/cn/app/id1659647017
+解锁方法：点击右上角设置图标，在【意见反馈】中输入【tk999】，然后右上角发送，再完全关闭应用后台，重启即可加载出完整的影视内容。
+
如果你正在学习编程或者经常需要使用命令行工具，那么你一定会发现，命令行操作对于初学者来说是一件十分困难的事情。命令行工具的指令繁多，使用方式复杂，很容易就会让人产生学习难度。为了帮助初学者快速掌握各种常用的命令行工具和技巧，eg这个GitHub项目应运而生。
+ eg是一个用于学习命令行操作的交互式命令行工具，它可以帮助用户快速学习并掌握各种常用的命令行工具和技巧。这个项目使用Python编写，可以在Windows、Linux和MacOS等多个平台上运行。eg项目提供了大量的命令行示例和教程，可以帮助初学者快速入门。
+ github地址:https://github.com/srsudar/eg
+
首先,你的Linux服务器上需要安装Python环境,可以参考:安装Python
+然后,只需要执行如下命令,即可安装完成.
+pip install eg
+安装完成之后,你就可以使用eg查找帮助文档啦!
+
总之，eg是一个非常有用的工具，它可以帮助你快速掌握命令行技巧，提高你的工作效率。如果你是一名编程爱好者或者需要经常使用命令行工具的人，那么你一定不能错过这个神器。
+ +
+ 微信支付
+
+ 支付宝支付
+
+
+ Springboot跨域问题，是当前主流web开发人员都绕不开的难题。但我们首先要明确以下几点
+
CORS是一个W3C标准，全称是”跨域资源共享”（Cross-origin resource sharing），允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而克服了AJAX只能同源使用的限制。
+它通过服务器增加一个特殊的Header[Access-Control-Allow-Origin]来告诉客户端跨域的限制，如果浏览器支持CORS、并且判断Origin通过的话，就会允许XMLHttpRequest发起跨域请求。
+含义解释：
+| CORS Header属性 | +解释 | +
|---|---|
| Access-Control-Allow-Origin | +允许http://www.xxx.com域（自行设置，这里只做示例）发起跨域请求 | +
| Access-Control-Max-Age | +设置在86400秒不需要再发送预校验请求 | +
| Access-Control-Allow-Methods | +设置允许跨域请求的方法 | +
| Access-Control-Allow-Headers | +允许跨域请求包含content-type | +
| Access-Control-Allow-Credentials | +设置允许Cookie | +
简单粗暴的方式，Controller层在需要跨域的类或者方法上加上该注解即可
+/**
+ * Created with IDEA
+ *
+ * @Description xxxx控制层
+ * @Version 1.0
+ */
+@RestController
+@CrossOrigin
+@RequestMapping("/situation")
+public class SituationController extends PublicUtilController {
+
+ @Autowired
+ private SituationService situationService;
+ // log日志信息
+ private static Logger LOGGER = Logger.getLogger(SituationController.class);
+
+
+
+}
+但每个Controller都得加，太麻烦了，怎么办呢，加在Controller公共父类（PublicUtilController）中，所有Controller继承即可。
+/**
+ * Created with IDEA
+ *
+ * @Description
+ * @Version 1.0
+ */
+@CrossOrigin
+public class PublicUtilController {
+
+ /**
+ * 公共分页参数整理接口
+ *
+ * @param currentPage
+ * @param pageSize
+ * @return
+ */
+ public PageInfoUtil proccedPageInfo(String currentPage, String pageSize) {
+
+ /* 分页 */
+ PageInfoUtil pageInfoUtil = new PageInfoUtil();
+ try {
+ /*
+ * 将字符串转换成整数,有风险, 字符串为a,转换不成整数
+ */
+ pageInfoUtil.setCurrentPage(Integer.valueOf(currentPage));
+ pageInfoUtil.setPageSize(Integer.valueOf(pageSize));
+ } catch (NumberFormatException e) {
+ }
+ return pageInfoUtil;
+ }
+
+}
+增加一个配置类，CrossOriginConfig.java。继承WebMvcConfigurerAdapter或者实现WebMvcConfigurer接口，其他都不用管，项目启动时，会自动读取配置。
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+
+/**
+ * AJAX请求跨域
+ */
+@Configuration
+public class CorsConfig extends WebMvcConfigurerAdapter {
+ static final String ORIGINS[] = new String[] { "GET", "POST", "PUT", "DELETE" };
+ @Override
+ public void addCorsMappings(CorsRegistry registry) {
+ registry.addMapping("/**").allowedOrigins("*").allowCredentials(true).allowedMethods(ORIGINS).maxAge(3600);
+ }
+同方法二加配置类，增加一个CORSFilter 类，并实现Filter接口即可，其他都不用管，接口调用时，会过滤跨域的拦截。
+ @Component
+public class CORSFilter implements Filter {
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+ HttpServletResponse res = (HttpServletResponse) response;
+ res.addHeader("Access-Control-Allow-Credentials", "true");
+ res.addHeader("Access-Control-Allow-Origin", "*");
+ res.addHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT");
+ res.addHeader("Access-Control-Allow-Headers", "Content-Type,X-CAF-Authorization-Token,sessionToken,X-TOKEN");
+ if (((HttpServletRequest) request).getMethod().equals("OPTIONS")) {
+ response.getWriter().println("ok");
+ return;
+ }
+ chain.doFilter(request, response);
+ }
+ @Override
+ public void destroy() {
+ }
+ @Override
+ public void init(FilterConfig filterConfig) throws ServletException {
+ }
+}
+++由于网络限制，不一定所有网址都能在您所在的位置访问。
+科研爱分享，知识无边界，让我们一起消除科学的障碍。
+
| √ | +Zlib所有种子1 | +可用 | +
|---|---|---|
| √ | +Zlib所有种子2 | +可用 | +
| √ | +Anna’s Archive | +可用 | +
| √ | +zbook.lol | +可用 | +
| √ | +Hallow Lib | +可用 | +
| √ | +zlib.app | +可用 | +
| √ | +Ylibrary | +可用 | +
| √ | +Bookpan | +可用 | +
| √ | +PDF Drive | +可用 | +
| √ | +Find Books | +可用 | +
| √ | +Freembook | +可用 | +
| √ | +Lorefree | +可用 | +
| √ | +https://scholar.lanfanshu.cn | +可用 | +
|---|---|---|
| √ | +https://sc.panda321.com | +可用 | +
| √ | +https://xueshu.lanfanshu.cn | +可用 | +
| √ | +https://deepsearch.cc | +可用 | +
| √ | +https://scholar.sb250.gq | +可用 | +
| √ | +https://www.scidown.cn/go | +可用 | +
| √ | +https://0-scholar-google-com.brum.beds.ac.uk | +可用 | +
| √ | +https://sci-hub.wf | +可用 | +
|---|---|---|
| √ | +https://sci-hub.ee | +可用 | +
| √ | +https://sci-hub.st | +可用 | +
| √ | +https://sci-hub.ren | +可用 | +
| √ | +https://sci-hub.cat | +可用 | +
| √ | +https://sci-hub.yt | +可用 | +
| √ | +https://sci-hub.se | +可用 | +
| √ | +https://sci-hub.ru | +可用 | +
| √ | +https://sci-hub.mksa.top | +可用 | +
| √ | +https://sci-hub.et-fine.com | +可用 | +
| √ | +https://sci-hub.hkvisa.net | +可用 | +
| √ | +https://sci-hub.3800808.com | +可用 | +
| √ | +https://scihub.unblockit.mov | +可用 | +
| √ | +https://gitclone.com | +可用 | +
|---|---|---|
| √ | +https://ghproxy.com | +可用 | +
| √ | +https://github.ur1.fun | +可用 | +
| √ | +https://github.ur1.fun | +可用 | +
+ 微信支付
+
+ 支付宝支付
+
+
+ EGADS（Extendible Generic Anomaly Detection System）是雅虎开源的一个大规模时间序列异常检测项目。它的目标是提供一个通用的、可扩展的、易于使用的框架，用于检测各种类型的时间序列数据中的异常点。
+时间序列数据是指按照时间顺序排列的一组数据点，它们通常反映了某个变量随着时间的变化趋势。例如，某个城市每天的气温、某个网站每小时的访问量、某个股票每分钟的价格等，都是时间序列数据的例子。
+异常检测是指在时间序列数据中寻找那些与正常情况下有很大偏差的数据点，它们通常反映了某种异常或突变的情况。例如，某个城市某天的气温突然升高或降低、某个网站某小时的访问量突然增加或减少、某个股票某分钟的价格突然上涨或下跌等，都是异常检测的例子。
+Egads（Extensible Generic Anomaly Detection System）是一个用于自动检测大规模时间序列数据中的异常的开源Java包。它主要由两个模块构成，一个是时间序列建模模块（TMM），另一个是异常检测模块（ADM）。
+时间序列建模模块（TMM）: 是用于预测时间序列数据中每个点的正常值的，它可以使用不同的算法来建立不同类型的时间序列模型，例如周期性最近邻（PNN）、奥林匹克模型（OlympicModel）、指数平滑（ExponentialSmoothing）等。
+异常检测模块（ADM）: 是用于比较时间序列数据中每个点的实际值和预期值，并根据一定的阈值来判断是否为异常点的，它也可以使用不同的算法来实现不同类型的异常检测模型，例如极低密度模型（ExtremeLowDensityModel）、K西格玛模型（KSigmaModel）、自适应核密度变点检测器（AdaptiveKernelDensityChangePointDetector）等。
+
我们时间序列以OlympicModel,异常检测KSigmaModel为例.
+在阅读源码前,我们先理解几个概念:
+1.EGADS的预测是针对过去时间数据的预测,而不是对未来时间数据的预测.
+2.时间序列数据示例如下,实际数据可能是按秒或者分钟为单位时间间隔的数据
+| 日期 | +气温 | +
|---|---|
| 1月1日 | +10℃ | +
| 1月2日 | +12℃ | +
| 1月3日 | +11℃ | +
| 1月4日 | +9℃ | +
| 1月5日 | +13℃ | +
| 1月6日 | +8℃ | +
| 1月7日 | +15℃ | +
| 1月8日 | +10℃ | +
| 1月9日 | +12℃ | +
| 1月10日 | +11℃ | +
| 1月11日 | +9℃ | +
| 1月12日 | +13℃ | +
| 1月13日 | +8℃ | +
| 1月14日 | +15℃ | +
3.项目中的config.ini配置文件中的配置至关重要.不要忽略!预测数据与期望数据的长度尽量保持一致,具体原因可以查看predict方法的实现.
+我们直接从Egads这个类入手,可以发现这个方法中,主要是通过传入的配置类sample_config.ini和数据集sample_input.csv构建了一个Properties对象和一个InputProcessor对象!
+然后在processInput方法中,实现下面几个功能
+createTimeSeries: 将传入的csv转换为一个或多个时间序列对象
+ProcessableObjectFactory.create(ts, p)
+++这一步使用到了配置文件中的几个属性:
+PERIOD:指定时间序列数据的周期性，即相邻两个数据点之间的时间差
+TS_MODEL:指定的时间序列模型
+AD_MODEL:指定的异常检测模型
+
po.process(): 这个方法就是数据预测与异常检测的具体实现
+public void process() throws Exception {
+
+ // Resetting the models
+ ma.reset();
+
+ // Training the model with the whole metric
+ ma.train();
+
+ // Finding the expected values
+ ArrayList<TimeSeries.DataSequence> list = ma.forecast(
+ ma.metric.startTime(), ma.metric.lastTime());
+
+ // For each model's prediction in the ModelAdapter
+ for (TimeSeries.DataSequence ds : list) {
+ // Reseting the anomaly detectors
+ ad.reset();
+
+ // Unsupervised tuning of the anomaly detectors
+ ad.tune(ds);
+
+ // Detecting anomalies for each anomaly detection model in anomaly detector
+ anomalyList = ad.detect(ad.metric, ds);
+
+ // Writing the anomalies to AnomalyDB
+ if (config.getProperty("OUTPUT") != null && config.getProperty("OUTPUT").equals("ANOMALY_DB")) {
+ for (Anomaly anomaly : anomalyList) {
+ // TODO: Batch Anomaly Process.
+ }
+ } else if (config.getProperty("OUTPUT") != null && config.getProperty("OUTPUT").equals("GUI")) {
+ GUIUtils.plotResults(ma.metric.data, ds, anomalyList, config);
+ } else if (config.getProperty("OUTPUT") != null && config.getProperty("OUTPUT").equals("PLOT")) {
+ for (Anomaly anomaly : anomalyList) {
+ System.out.print(anomaly.toPlotString());
+ }
+ } else {
+ for (Anomaly anomaly : anomalyList) {
+ System.out.print(anomaly.toPerlString());
+ }
+ }
+ }
+ }
+ // Resetting the models
+ ma.reset();
+
+ // Training the model with the whole metric
+ ma.train();
+
+ // Finding the expected values
+ ArrayList<TimeSeries.DataSequence> list = ma.forecast(
+ ma.metric.startTime(), ma.metric.lastTime());
+reset(): 重置模型相关属性
+train():用于训练一个基于周期性最近邻（PNN）的时间序列模型
+public void train(TimeSeries.DataSequence data) {
+ this.data = data;
+
+ int n = data.size();
+
+ java.util.Arrays.sort(baseWindows);
+ java.util.Arrays.sort(timeShifts);
+ float precision = (float) 0.000001;
+
+ for (int i = 0; i < n; i++) {
+ float baseVal = Float.POSITIVE_INFINITY;
+ float tmpbase = (float) 0.0;
+
+ // Cannot compute the expected value if the time-series
+ // is too short preventing us form getting the reference
+ // window.
+ if ((i - baseWindows[0]) < 0) {
+ model.add(data.get(i).value);
+ continue;
+ }
+
+ // Attempt to shift the time-series.
+ for (int w = 0; w < baseWindows.length; w++) {
+ for (int j = 0; j < timeShifts.length; j++) {
+ if (timeShifts[j] == 0) {
+ tmpbase = computeExpected(i, baseWindows[w]);
+ if ((Math.abs(tmpbase - data.get(i).value) - Math.abs(baseVal - data.get(i).value)) < precision) {
+ baseVal = tmpbase;
+ }
+ } else {
+ if (i + timeShifts[j] < n) {
+ tmpbase = computeExpected(i + timeShifts[j], baseWindows[w]);
+ if ((Math.abs(tmpbase - data.get(i).value) - Math.abs(baseVal - data.get(i).value)) < precision) {
+ baseVal = tmpbase;
+ }
+ }
+ if (i - timeShifts[j] >= 0) {
+ tmpbase = computeExpected(i - timeShifts[j], baseWindows[w]);
+ if ((Math.abs(tmpbase - data.get(i).value) - Math.abs(baseVal - data.get(i).value)) < precision) {
+ baseVal = tmpbase;
+ }
+ }
+ }
+ }
+ }
+ model.add(baseVal);
+ }
+
+ initForecastErrors(model, data);
+
+ logger.debug(getBias() + "\t" + getMAD() + "\t" + getMAPE() + "\t" + getMSE() + "\t" + getSAE() + "\t" + 0 + "\t" + 0);
+ }
+++它是OlympicModel类的一个成员方法，它需要一个参数，就是时间序列数据（data）。它会根据类中的一些参数，例如基准窗口（baseWindows），时间偏移（timeShifts），动态参数（dynamicParameters）等，来计算每个数据点的预期值，并将结果存储在一个列表（model）中。然后，它会调用initForecastErrors方法来初始化预测误差指标，并打印出来。具体的实现步骤如下：
++
+- 首先，将时间序列数据（data）赋值给类中的一个属性（this.data），以便后续使用。
+- 然后，获取时间序列数据的长度（n），并对基准窗口（baseWindows）和时间偏移（timeShifts）进行排序，以便后续遍历。
+- 接着，定义一个精度值（precision），用于比较浮点数是否相等。
+- 然后，遍历时间序列数据中的每个数据点（i），初始化一个最大的浮点数（baseVal）作为预期值，和一个临时变量（tmpbase）用于存储计算结果。
+- 接着，判断当前数据点是否有足够长的过去数据来计算预期值，如果没有，则直接使用实际值作为预期值，并添加到列表（model）中，然后跳过当前循环，继续下一个数据点。
+- 然后，尝试将时间序列数据向前或向后移动一定的时间偏移（timeShifts），并从移动后的数据中取出与当前数据点相同位置的值，作为过去的数据。对于每个过去的数据，调用computeExpected方法来计算预期值，并将结果赋值给临时变量（tmpbase）。然后，比较临时变量（tmpbase）和最大浮点数（baseVal）与实际值的差的绝对值，如果前者更小，则将临时变量（tmpbase）赋值给最大浮点数（baseVal），表示找到了更好的预期值。
+- 最后，将最大浮点数（baseVal）作为最终的预期值，并添加到列表（model）中。
+- 最后，调用initForecastErrors方法来初始化预测误差指标，并打印出来。
+
forecast(): 这个方法主要是获取指定时间的预期值
+ // Reseting the anomaly detectors
+ ad.reset();
+
+ // Unsupervised tuning of the anomaly detectors
+ ad.tune(ds);
+
+ // Detecting anomalies for each anomaly detection model in anomaly detector
+ anomalyList = ad.detect(ad.metric, ds);
+ad.reset(): 重置检测模型的属性
+ad.tune(ds): 它会根据类中的一些参数，例如误差指标（aes），自动灵敏度（sDAutoSensitivity）等，来计算每个数据点的观测值和预期值之间的误差指标，并根据K西格玛原则来确定每种误差指标的阈值，并将结果存储在一个哈希表（threshold）中。
+ public void tune(DataSequence observedSeries, DataSequence expectedSeries) throws Exception {
+ HashMap<String, ArrayList<Float>> allErrors = aes.initAnomalyErrors(observedSeries, expectedSeries);
+
+ for (int i = 0; i < (aes.getIndexToError().keySet()).size(); i++) {
+ // Add a new error metric if the error metric has not been
+ // defined by the user.
+ if (!threshold.containsKey(aes.getIndexToError().get(i))) {
+ Float[] fArray = (allErrors.get(aes.getIndexToError().get(i))).toArray(new Float[(allErrors.get(aes.getIndexToError().get(i))).size()]);
+ threshold.put(aes.getIndexToError().get(i), AutoSensitivity.getKSigmaSensitivity(fArray, sDAutoSensitivity));
+ }
+ }
+ }
++++
+- 首先，调用initAnomalyErrors方法来初始化所有误差指标的列表，并将结果存储在一个哈希表（allErrors）中。initAnomalyErrors方法会遍历每个数据点，调用computeErrorMetrics方法来计算该点的观测值和预期值之间的误差指标，并将结果存储在一个数组（errors）中。然后，将这些数组按照不同的误差指标分别添加到对应的列表中，并返回这些列表组成的哈希表。
+- 然后，遍历每种误差指标（i），判断是否已经有用户定义的阈值（threshold），如果没有，则调用getKSigmaSensitivity方法来根据K西格玛原则计算该种误差指标的阈值，并将结果存储在哈希表（threshold）中。getKSigmaSensitivity方法会根据自动灵敏度（sDAutoSensitivity）和误差指标列表（fArray）来计算该种误差指标的均值和标准差，并返回均值加上K倍标准差作为阈值。
+
ad.detect(ad.metric, ds):用于检测时间序列数据中的异常点
+public IntervalSequence detect(DataSequence observedSeries,
+ DataSequence expectedSeries) throws Exception {
+
+ // At detection time, the anomaly thresholds shouldn't all be 0.
+ Float threshSum = (float) 0.0;
+ for (Map.Entry<String, Float> entry : this.threshold.entrySet()) {
+ threshSum += Math.abs(entry.getValue());
+ }
+
+ // Get an array of thresholds.
+ Float[] thresholdErrors = new Float[aes.getErrorToIndex().size()];
+ for (Map.Entry<String, Float> entry : this.threshold.entrySet()) {
+ thresholdErrors[aes.getErrorToIndex().get(entry.getKey())] = Math.abs(entry.getValue());
+ }
+
+ IntervalSequence output = new IntervalSequence();
+ int n = observedSeries.size();
+
+ for (int i = 0; i < n; i++) {
+ Float[] errors = aes.computeErrorMetrics(expectedSeries.get(i).value, observedSeries.get(i).value);
+ logger.debug("TS:" + observedSeries.get(i).time + ",E:" + arrayF2S(errors) + ",TE:" + arrayF2S(thresholdErrors) + ",OV:" + observedSeries.get(i).value + ",EV:" + expectedSeries.get(i).value);
+ if (observedSeries.get(i).value != expectedSeries.get(i).value &&
+ threshSum > (float) 0.0 &&
+ isAnomaly(errors, threshold) == true &&
+ (isDetectionWindowPoint(maxHrsAgo, windowStart, observedSeries.get(i).time, observedSeries.get(0).time) ||
+ (maxHrsAgo == 0 && i == (n - 1)))) {
+ output.add(new Interval(observedSeries.get(i).time,
+ i,
+ errors,
+ thresholdErrors,
+ observedSeries.get(i).value,
+ expectedSeries.get(i).value));
+ }
+ }
+ return output;
+ }
++++
+- 首先，创建一个空的区间序列对象（output），用于存储异常点的信息。
+- 然后，计算阈值（threshold）中所有绝对值的和（threshSum），用于判断是否有有效的阈值。
+- 接着，将阈值（threshold）中的每个绝对值存储在一个数组（thresholdErrors）中，方便后续使用。
+- 然后，遍历观测值序列（observedSeries）中的每个数据点（i），调用computeErrorMetrics方法来计算该点的观测值和预期值之间的误差指标，并存储在一个数组（errors）中。打印出该点的时间戳、误差指标、阈值、观测值和预期值等信息。
+- 接着，判断该点是否满足以下条件，如果满足，则表示该点是一个异常点，并将其添加到区间序列对象（output）中。条件如下：
++
+- 观测值不等于预期值；
+- 阈值之和大于0；
+- 误差指标超过阈值；
+- 该点在检测窗口内，或者检测窗口为0且该点是最后一个数据点。
+- 最后，返回区间序列对象（output），其中包含了检测出来的异常点的信息。
+
针对实际需求,我个人采取的方法是使用数据库中存储的历史数据训练模型,然后使用MQ接收实时数据,这里需要注意的一个点是训练数据集需要足够,还有一个点就是在调用ad.tune方法时,需要传入历史数据来获取合适的误差指标,否则就需要自己指定这些指标的值.否则就会导致无法检测异常点!
+// Cannot compute the expected value if the time-series
+// is too short preventing us form getting the reference
+// window.
+if ((i - baseWindows[0]) < 0) {
+ model.add(data.get(i).value);
+ continue;
+}
+关于配置中各个参数的说明
+DETECTION_WINDOW_START_TIME: 检测窗口的起始时间,如果设置为0,则从最大允许的异常时间(MAX_ANOMALY_TIME_AGO)开始。
+MAX_ANOMALY_TIME_AGO: 最大允许检测到的异常时间点离当前的时间跨度,用于控制检测到的异常的新鲜度。
+AGGREGATION: 时间序列聚合参数,用于控制降采样比例,如果设置为1则不进行降采样。
+OP_TYPE: 操作类型,包括检测异常、更新模型、转换输入等。
+TS_MODEL: 时间序列建模模型类型,如自动预测、指数平滑、奥林匹克模型等。
+AD_MODEL: 异常检测模型类型,如极低密度、K西格玛、自适应核密度等。
+SIMPLE_THRESHOLD_TYPE: 简单阈值模型的类型,如自适应最大最小方差、自适应K西格玛敏感度等。
+INPUT: 输入来源,标准输入or CSV文件。
+OUTPUT: 输出目标,标准输出、异常数据库、图形界面等。
+THRESHOLD: 异常检测模型的阈值参数。
+TIME_SHIFTS: 奥林匹克模型的时间偏移参数。
+BASE_WINDOWS: 奥林匹克模型的基准窗口大小参数。
+PERIOD: 时间序列的周期性参数。
+WINDOW_SIZE: 朴素模型的窗口大小参数。
+AUTO_SENSITIVITY_ANOMALY_PCNT: 预期的异常百分比。
+AUTO_SENSITIVITY_SD: 聚类标准差参数。
+ALPHA/BETA/GAMMA: 三指数平滑模型的平滑因子。
+THRESHOLD mape#10,mase#15: 表示设置了两组阈值,mape代表平均百分比误差(Mean Absolute Percentage Error)。这个阈值表示当预测值和实际值的差异超过10%时,会被判定为异常。这个阈值表示当预测误差超过实际值的15%时,会被判定为异常。也就是说,EGADS在进行异常检测时,会计算每个数据点的mape和mase。如果mape超过10%或者mase超过15%,则会将该点判定为一个异常点。
+上面就是关于EGADS的源码解读。我希望这篇文章能够帮助您了解EGADS的工作原理和使用方法。如果您有任何问题或建议，请随时与我联系。谢谢！😊
+
+ 微信支付
+
+ 支付宝支付
+
+
+ 人工智能是让计算机具有智能行为的科学,比如让计算机能够做一些人类擅长做的事情。我们可以用图灵测试来判断一个系统是否具有智能。
+主要有两种方法来实现人工智能:
+知识表示是将人类知识转化为计算机可用形式的技术。专家系统是利用知识表示来模拟人类专家解决问题的能力的系统。
+专家系统主要包含:
+例如一个笔记本电脑推荐系统,它可以通过询问用户需求,并应用知识库中的规则,来推荐合适的笔记本电脑。
+感知器是一种神经网络模型,可以用来识别不同的图形或数字。
+它包含一个权重向量,可以根据输入计算输出。通过训练可以调整权重,使感知器识别不同模式。
+例如一个感知器可以识别手写数字,输入是一个图像,输出是判断结果。通过不断训练,感知器可以适应不同样式的手写数字。
+神经网络是模仿人脑结构的计算模型,可以从数据中学习各种特征和规律。
+它由多个单元组成,单元之间通过权重相连。权重通过梯度下降算法训练。
+例如一个判断奇偶数的神经网络,输入是一个数字,隐藏层对数字的每位求和,输出层根据结果判断奇偶。通过训练可以提高判断准确度。
+张量是多维数组,可以表示各种数据,包括文本。
+表示文本的方法:
+例如单词”apple”可以表示为[1, 2, 3, 4, 5]这样的向量。
+需要用更高级的模型处理上下文和顺序信息。
+应用:
+例如可以用OpenCV来处理一本盲文书籍的图像,或者检测视频中的运动。
+卷积神经网络是处理图像的神经网络。
+它通过卷积滤波器提取各级特征图,然后分类。
+卷积层提取特征,池化层减少参数,全连接层分类。
+例如识别MNIST手写数字,输入图像,输出类别概率。
+卷积网络广泛用于图像处理任务。
+迁移学习是将一个任务的知识迁移到另一个相关任务。
+例如先在ImageNet上训练模型提取特征,然后在新的数据集上训练分类器。
+好处:
+例如用迁移学习进行猫狗识别,先提取通用图像特征,然后微调分类器。
+自编码器可以学习数据的有效特征编码,主要用于无标签数据。
+它包含编码器和解码器,可以重建数据。
+应用:
+例如,编码器把图片编码为向量,解码器再解码为图片,实现压缩和重构。
+生成对抗网络包含生成器和判别器,可以生成新的数据,如艺术创作。
+生成器创建数据,判别器判断真伪。两者对抗训练。
+可以做风格转换,把内容图片与风格图片结合。
+例如,生成器生成猫图片,判别器判断真假,重复训练until生成图片逼真。
+物体检测可以识别图像中的物体及位置。
+主要方法:
+主要模型:R-CNN、Fast R-CNN、Faster R-CNN、YOLO等。
+例如,Faster R-CNN使用注意力机制,端到端地完成检测。
+图像分割将图片中的目标提取出来。
+使用编码器-解码器结构的全卷积网络,输出与输入大小相同的掩膜。
+例如,输入图片,输出每个像素的语义标签,实现分割。
+递归神经网络可以处理序列数据。
+它根据当前输入和前一状态计算当前状态,实现顺序处理。
+应用:
+例如,输入一个句子,输出句子的语义向量表示。
+词嵌入将词映射为密集向量,表示语义信息。
+方法:
+例如,单词”apple”映射为[0.1, 0.3, -0.2, …]这样的向量。
+词嵌入是自然语言处理的重要技术。
+命名实体识别可以从文本中提取实体,如人名、地点等。
+方法:使用循环神经网络或变换器,对词进行BIO标注。
+应用:聊天机器人、知识图谱等。
+例如,识别句子中的人名、城市名等关键词。
+它使用编码器-解码器结构。
+编码器输出向量表示输入序列特征。
+解码器根据编码器输出生成目标序列。
+例如,编码器编码”I love you”,解码器解码”我爱你”。
+GPT是一个预训练语言模型,可以生成逼真文本。
+它通过预测下一个词来进行文本生成任务的通用训练。
+可用于文本编辑、问答、翻译等任务。
+例如,GPT可以根据提示接着写一篇故事。
+遗传算法用于搜索、优化和机器学习,模拟自然进化。
+基本思路:
+例如,用遗传算法求解背包问题。
+强化学习让智能体通过环境交互学习最优策略。
+目标是最大化累积回报。
+方法:策略梯度、Actor-Critic等。
+例如,让计算机学习玩游戏直到胜利。
+多智能体系统由多个智能体协作完成复杂任务。
+每个智能体有自己的目标和行为规则。
+可以组成更智能的整体。
+应用:游戏、模拟、自动化等。
+例如,一个旅游推荐系统包含查询机票、酒店、景点的智能体。
+ +
+ 微信支付
+
+ 支付宝支付
+