胖达网络

巨量达人带货建券助手

2024-07-27T13:48:58.000Z

软件功能

适用对象：24小时直播带货直播间
监控商品佣金变化，佣金变化时根据设置执行相应的操作
多个商品使用同一优惠券，大量节省建券资金（最高100个商品）
软件绑定巨量达人账号，只能监控绑定的巨量达人账号，解绑扣除1天使用时间

软件教程

基础教程

下载地址

蓝奏云盘
密码：666666

软件价格

1月1控69元，XX控代表可以绑定多少巨量达人账号
其他版本联系客服咨询

如何购买

联系客服微信：ZM15949694093
联系客服2微信：sr19981106
联系作者
请备注：购买达人带货助手

声明

有问题请在此处提交issues

三亚5天5夜旅行攻略

2023-06-25T03:58:09.000Z

三亚好吃美食

海鲜、椰子鸡店
这是小红书推荐，非本人推荐

小胡子海鲜连锁店
这家本地人都争相打卡的宝藏海鲜餐厅你们一定不要错过。四川麻辣口味深得我心~香辣蟹一份根本吃不够，还想打包带走一份😋
琼乡阁·海南私房菜
味道超级正宗的海南菜餐厅，店内装饰很有海南特色，拍照很有氛围感~
太琼百年糟粕醋海鲜火锅
我愿意为了这家的糟粕醋再去三亚1000次！酸辣鲜香的锅底涮上海鲜，真的百吃不厌~
嗲嗲的椰子鸡
这家椰子鸡真的太太太好吃了！鲜嫩的鸡肉蘸上秘制蘸料超绝
林姐香味海鲜
本地人开的20多年的海鲜老店，他家的青椒蟹好吃到爆！林姐独家做法质味道特别赞，还有很多口味可以选择

小吃店
这是小红书推荐，非本人推荐

文妈后安粉：汤汁鲜美/配料充足一碗就管饱
阿菊冷饮店：分量足且价.格低推荐榴莲炒冰，
渔村炸鸡：炸鸡外皮酥脆肉质细嫩，配上蜜汁蘸料
阿公烧烤：超.级超.级好吃的烧烤!下午2点开门
正宗抱罗粉：抱罗粉有干捞和汤的两种
君瑞陵水酸粉：汤汁味道鲜美，酸爽可口，分量十足
清补凉：炒冰清补凉炒椰奶清补凉好吃
阿德猪脚饭：秘.制猪脚是咸口的卤味酱汁
品汤居砂锅米线：米线很有嚼劲,配料也多
南门涮肉：酱料很香很好吃，就是很北方的调料

图标释义

💰代表收费的
🤑代表免费的

租车

🔹租车时间：6.18 9:00 - 6.21 9:00
🔹租特斯拉model Y 3天花费418元💰

三亚5天5夜悠闲游览路线

st=>start: 17号到达三亚
e=>end: 返程
tag1=>operation: 第一天 - 三亚湾
tag2=>operation: 第二天 - 三亚湾
tag3=>operation: 第三天 - 海棠湾
tag4=>operation: 第四天 - 亚龙湾
tag5=>operation: 第五天 - 大东海
cond1=>condition: 是否玩的开心？
cond1(no)->e
cond1(yes)->tag1
st->cond1->tag1(left)->tag2->tag3(right)->tag4->tag5(left)->e

🏠抵达落地住宿

🚌公交方案
🔹在凤凰机场上车乘坐8/27至三亚湾新城下车，在京润珍珠博物馆乘坐16路至世纪水晶站（4元/人）💰
🔹打车20元左右

🔹17 - 18号
🔹西藏大厦酒店（220元/晚）去哪儿预定💰

第一天 - 三亚湾

st=>start: 18号早上8点起来取车
e=>end: 回酒店休息
tag1=>operation: 南山文化旅游
tag2=>operation: 大小洞天
tag3=>operation: 椰梦长廊
tag4=>operation: 亿恒夜市
cond1=>condition: 累不累？
cond1(yes)->e
cond1(no)->tag1->tag2->tag3->tag4(left)->e

南山文化旅游看海上观音（103元/人）💰
🔹不要穿拖鞋，不要外带香火

🚌公交方案
🔹在世纪水晶站上车乘坐16路至南山景区站（7元/人）💰

大小洞天拍照🤑
🔹适合穿裙子，走路游览

🚌公交方案
🔹在南山景区站上车乘坐25路至大小洞天站（4元/人）💰

椰梦长廊拍照看日落🤑
🔹适合傍晚去，蚊虫比较多

🚌公交方案
🔹在大小洞天站上车乘坐鹿城山海旅文专线至国光滨海花园（14元/人）💰

🚗自驾方案
🔹导航到海韵酒店、国光豪生酒店对面

亿恒夜市🤑
🌟推荐小吃：
🔸蚵仔煎：小生蚝肉和鸡蛋的灵魂搭配，煎到金黄出锅，鲜香嫩滑一步到位
🔸海南拌粉：10块钱一大碗，里面有木耳、藕片、黄瓜等很多蔬菜混在一起，好吃又管饱

🚌公交方案
🔹在世嘉公寓上车乘坐29/24/16路至金水湾（2元/人）💰

🚗自驾方案
🔹导航到亿恒·主题夜市停车场

🍴美食
🛎️中午 - 忆山傍餐厅（141.8元）主要吃鸡
🛎️晚上 - 去夜市逛吃

🏠住宿
🔹18 - 19号
🔹凤凰岛海洋之星度假酒店，180度无敌海景度假房（290元/晚）去哪儿预定💰

第二天 - 三亚湾

st=>start: 19号开始游玩三亚湾
e=>end: 回酒店休息
tag1=>operation: 西岛一日游（90元/人）
tag2=>operation: 海上书屋
tag3=>operation: 文创区
tag4=>operation: 情侣树
tag5=>operation: 第一市场夜市
cond1=>condition: 累不累？
cond1(yes)->e
cond1(no)->tag1->tag2->tag3->tag4->tag5(left)->e

西岛一日游（90元/人）💰
🔹电动车去牛王岭门票套餐120/人，不然到西岛买票就是90+35，不去牛王岭可忽略

🚌公交方案
🔹公交车:16/25/26/30/32/55/57路公交车，西岛站下车

🚗自驾方案
🔹西岛肖旗港码头(三亚西岛海洋文化旅游区停车场)，可免费停车

第一市场夜市🤑
🌟推荐小吃：
🔸阿菊冷饮：每天都排长队的炒冰店，最好吃的是榴莲炒冰，有新鲜果肉在里面
🔸正宗抱罗粉：粘稠的酱汁浇在粗粗的米线上，口感顺滑，里面有肉和粉肠，一起嚼在嘴里很香🦐

第一市场是来三亚必打卡的一个地方，在这里可以超低价买到海鲜、水果和当地的一些特色，还能吃到海南最正宗的美食！尤其是晚上逛夜市，每一个小摊位上都摆满玲琅满目的珍珠首饰、工艺品、小商品，氛围超赞，风情满满！是三亚官方指定的夜市示范街。

🚗自驾方案
🔹导航到国药中服免税三亚店停车场

🍴美食
🛎️中午 - 琼乡阁海南私房菜（预计300多元）
🛎️晚上 - 去夜市逛吃

🏠住宿
🔹19 - 20号
🔹三亚海棠湾和逸泳池别墅，二居泳池别墅（396元/晚）去哪儿预定

第三天 - 海棠湾

st=>start: 20号开始游玩海棠湾
e=>end: 回酒店休息
tag1=>operation: 蜈支洲岛一日游（133元/人）
tag2=>inputoutput: 白沙滩、私人定制
tag3=>inputoutput: 情人谷、金龟探海
tag4=>operation: 后海村（冲浪）
tag5=>operation: 博后夜市
cond1=>condition: 累不累？
cond1(yes)->e
cond1(no)->tag1->tag2->tag3->tag4->tag5(left)->e

蜈支洲岛一日游（133元/人）💰
🔹登岛时间8：00—16：00
🔹离岛时间8：30—18：00

🚌公交方案
🔹28/33路公交车、海棠3号大巴

🚗自驾方案
🔹导航“蜈支洲岛”1号/3号停车场
🔹提前网上订票，如果要坐旅游观光车环岛游的话买245元/人豪华环岛游套餐

白沙滩
私人定制
情人谷
金龟探海

🏄‍♀️岛上玩法
第一种：步行拍照
步行路线：往左边走→情人岛→love沙滩→动物乐园→私人订制泳池→网红秋千→观海长廊→观日岩
第二种：环岛观光
环岛路线：海滨浴场→海洋之星→观日岩→情人谷→情人岛→海岛茶馆→私人订制
第三种：水上项目
蜈支洲岛的水上项目很多，有潜水、摩托艇、水上飞人、彩虹拖伞等等，买套票更划算

后海村🤑
🔹不冲浪可以不去💰
🔹太累就不去啦直接回酒店

博后村夜市🤑
🌟推荐小吃：
🔸农家炸鸡：新鲜的鸡块裹上满满的面包糠，现炸的吃起来香香脆脆的🐥
🔸牛肉后安粉：汤底很鲜，牛肉大块，想喝汤再吃粉，很满足

🚌公交方案
🔹在蜈支洲岛站上车乘坐28路至亚龙湾火车站下车，换乘27路至亚龙湾玫瑰谷下车

🚗自驾方案
🔹导航博后夜市

🍴美食
🛎️中午 - 嗲嗲的椰子鸡（预计300元以上）
🛎️晚上 - 去夜市逛吃

🏠住宿
🔹20 - 21号
🔹无云谷民宿，随机盲盒房（163元/晚）去哪儿预定

第四天 - 亚龙湾

st=>start: 21号开始游玩亚龙湾，8点起来还车
e=>end: 回酒店休息
tag1=>operation: 亚龙湾森林公园（130元/人）
tag2=>operation: 亚龙湾沙滩
cond1=>condition: 累不累？
cond1(yes)->e
cond1(no)->tag1->tag2(left)->e

亚龙湾森林公园（130元/人）💰
🔹提前一小时网上购票预约，蚊虫比较多

🚌公交方案
🔹建议骑行或者步行，公交需要50分钟，骑行6分钟，步行23分钟

亚龙湾沙滩🤑
🔹做好防晒，穿拖鞋

🚌公交方案
🔹从亚龙湾森林旅游区上车乘坐15/24/25/27至亚龙湾海底世界下车（40分钟左右，2元）
🔹骑行5公里19分钟，有共享电动就骑行

🍴美食
🛎️中午 - 就近随便找点吃
🛎️晚上 - 太琼百年糟粕醋海鲜火锅（亚龙湾店）（预计400元以上）

🏠住宿
🔹21 - 22号
🔹嗨筑·小棠别院艺术酒店，沧山泱水·智能阳台房（151元/晚，有去免税店的免费班车）去哪儿预定

🚌公交方案
🔹从亚龙湾海底世界上车乘坐15/24至新红村路口下车，乘坐23路至龙海风情小镇下车（2小时左右，9元）

第五天 - 大东海

st=>start: 21号开始游玩大东海
e=>end: 休息准备回家
tag1=>operation: cdf国际免税城
tag2=>operation: 小东海
tag3=>operation: 鹿回头公园
cond1=>condition: 累不累？
cond1(yes)->e
cond1(no)->tag1->tag2->tag3(left)->e

国际免税城🤑
🔹买买买条件：年满16岁身份证+离岛信息(车票、船票等)

小东海🤑
🔹做好防晒，穿拖鞋

鹿回头公园🤑
🔹适合傍晚去，蚊虫比较多

🍴美食
🛎️中午 - 小胡子海鲜连锁店（预计400元左右）
🛎️晚上 - 吃烧烤

🏠住宿
🔹22 - 23号
🔹亚朵智能酒店，优享大床房（151元/晚）去哪儿预定

开支明细表

项目	项目明细	单价/元	数量/个	总价/元
车票	首都航空	410	2	820
交通	公交、打车	20	1	20
租车	特斯拉model Y	120	3	418
住宿	西藏大厦酒店	220	1	220
门票	南山文化旅游	103	2	206
吃饭	忆山傍餐厅	50	2	142
购物	亿恒夜市	100	2	200
住宿	凤凰岛海洋之星度假酒店	290	1	290
门票	西岛	90	2	180
吃饭	琼乡阁海南私房菜	133.3	2	400
购物	第一市场夜市	100	2	200
住宿	三亚海棠湾和逸泳池别墅	396	1	396
门票	蜈支洲岛	133	2	266
吃饭	嗲嗲的椰子鸡	133.3	2	400
购物	博后夜市	100	2	200
住宿	无云谷民宿	163	1	163
门票	亚龙湾森林公园	130	2	260
交通	公交、骑行	5	2	10
吃饭	太琼百年糟粕醋海鲜火锅	150	2	450
住宿	嗨筑·小棠别院艺术酒店	151	1	151
交通	公交	10	2	20
吃饭	小胡子海鲜连锁店	160	2	500
住宿	亚朵智能酒店	151	1	151
车票	首都航空	500	2	1200
其他	杂七杂八、充电等	600	1	600
购物	买东西	1000	2	2000
总计	26			9863

人均：4k-5k左右

总结

🔹三亚就是吃和住是大头
🔹各个景点距离非常远
🔹只有市区才有共享电动车，所以租车非常有必要
🔹不要坐3块钱的电动3轮车带你去吃海鲜，会被坑死
🔹椰子鸡还是王思聪的椰小鸡好吃，嗲嗲的椰子鸡比较一般
🔹喜欢吃辣和重口味的人别去吃太琼百年糟粕醋海鲜火锅和琼乡阁·海南私房菜，你吃了会觉得没有任何味道
🔹小吃就是清补凉好吃一点
🔹去三亚不需要看天气，基本上天天下雨但是下几分钟就好了，都是太阳和雨一起
🔹去西岛、蜈支洲岛要提前1天网上买票，不然也可以在人工窗口买但是更贵
🔹去南山文化旅游要提前2小时网上买票
🔹租车最好在飞猪租，我是在十八度阳光租的是23款的特斯拉非常奈斯，千万别租油车
🔹别去凤凰岛住宿，除了拍照好看其他的一无是处，预算高的可以住康年
🔹订贵的酒店可以在酒店的官方微信公众号订会便宜，还有套餐，别管它X天X夜，就是看几夜

预览和下载

🔹预览PDF

🔹下载markdown

解决jsdelivr国内无法访问的问题

2023-06-25T03:18:05.000Z

前言

好久没看博客了，进去一下看到js、css等资源文件全部红色，所以本文章是来解决这个问题的教程

解决过程

开启代理又可以使用说明是国内无法使用，那就把jsdelivr替换掉就行了
一开始是看张洪的这篇文章，但是是无法解决的
但是我也不知道是哪个文件里面改，反正肯定不是在config.yml
我是通过把整个butterfly目录下载下来，然后在vscode中全局搜索 jsdelivr，把cdn.jsdelivr.net全局替换成gcore.jsdelivr.net即可

解决方法

打开/butterfly/scripts/events/config.js文件
在config.js文件中把cdn.jsdelivr.net全局替换成gcore.jsdelivr.net
打开/butterfly/_config.yml文件
在_config.yml文件中检查inject下插入的css和js把无法打开的替换成gcore.jsdelivr.net
运行hexo clean && hexo g完美解决

解决aplayer无法播放的问题

2023-01-21T07:54:42.000Z

前言

做这个的初衷就是Meting这个项目不稳定且不能满足自己的需求所以才有的这个项目
我的主要用途是构建博客的歌单列表，所以此项目只是以我博客的需求做的接口
目前已支持酷狗、网易、QQ、酷我音乐
如何替换和自定义歌曲请看这篇文章
请前往Github查看源码
浏览我的歌单查看效果

如何添加COOKIE以及COOKIE有何作用

MusicApi_set_cookie此方法添加COOKIE
如果你有会员的情况下是可以下载或试听会员音乐的(注：禁止商业用途)

如何使用

下载本项目到本地

git clone https://github.com/Superheroff/musicapi.git

安装环境依赖
pip install -r requirements.txt
运行项目
python main.py

请求示例

获取歌单列表信息
请求地址：http://127.0.0.1:7878
路径：/music/songlist
请求方式：POST,GET
酷狗音乐示例：http://127.0.0.1:7878/music/songlist?server=kugou&id=6222311
网易云音乐示例：http://127.0.0.1:7878/music/songlist?server=wyy&id=7480897649
QQ音乐示例：http://127.0.0.1:7878/music/songlist?server=qqmusic&id=8672698451
酷我音乐示例：http://127.0.0.1:7878/music/songlist?server=kuwo&id=3563672431
酷我获取推荐歌单列表示例：http://127.0.0.1:7878/kuwo/random_music_list

参数名	参数类型	参数描述	参数示例
server	string	音乐平台	kugou,wyy,qqmusic,kuwo
id	string	歌单ID	6222311,7480897649,8672698451,3563672431

响应示例

[
  {
    "author": "小霞、海洋Bo",
    "lrc": "http://127.0.0.1:7878/kugou/lrc/2E6D88A0CA2290BA32B614FC9C7EA43B.lrc",
    "music_id": "2E6D88A0CA2290BA32B614FC9C7EA43B",
    "pic": "http://imge.kugou.com/stdmusic/20230607/20230607152301805906.jpg",
    "title": "向云端",
    "url": "http://127.0.0.1:7878/kugou/2E6D88A0CA2290BA32B614FC9C7EA43B"
  },
  {
    "author": "张叶蕾",
    "lrc": "http://127.0.0.1:7878/wyy/lrc/2152040455.lrc",
    "music_id": "2152040455",
    "pic": "https://p2.music.126.net/zqd0535UOc3EDJvFf0Ymjw==/109951169555226745.jpg",
    "title": "爱你",
    "url": "http://127.0.0.1:7878/wyy/2152040455"
  },
  {
    "author": "任素汐",
    "lrc": "http://127.0.0.1:7878/qqmusic/lrc/001D51640M6ZeR.lrc",
    "music_id": "001D51640M6ZeR",
    "pic": "https://y.qq.com/music/photo_new/T002R300x300M00000003uSK0ttEuV.jpg",
    "title": "王招君 (你看你拉住我的模样)",
    "url": "http://127.0.0.1:7878/qqmusic/001D51640M6ZeR"
  },
  {
    "author": "杨宗纬&宝石Gem&王宇宙Leto",
    "lrc": "http://127.0.0.1:7878/kuwo/lrc/377413145.lrc",
    "music_id": "377413145",
    "pic": "https://img2.kuwo.cn/star/albumcover/500/s3s52/26/4134677797.png",
    "title": "若月亮没来(Live)",
    "url": "http://127.0.0.1:7878/kuwo/377413145"
  }
]

参数名	参数类型	参数描述
author	string	作者
lrc	string	歌词地址（待解析）
pic	string	歌曲封面
title	string	歌曲名
url	string	歌曲地址（待解析）
music_id	string	音乐ID

声明

本源码仅限用于学习交流，请勿用于商业用途，非法使用与作者无关
如有侵权请联系我删除
学习交流QQ群：816017833

butterfly切换夜间模式更换背景

2022-12-01T04:14:30.000Z

前言

非常简单只需自定义css即可
本博客使用的是butterfly4.2.2版本

过程

在/themes/butterfly/_config.yml文件中设置一个默认背景
这里等于是白色背景，因为要设置黑夜背景切换默认背景图片如果不改成url('')后面设置的图片将不成功，具体原因没有研究
background: url('')

在/themes/butterfly/source/css/app966.css文件中自定义css文件

/* 这里是设置一个全局透明度，不然不太协调，可以根据自己的喜好修改 */
:root {
    --card-bg: rgba(255, 255, 255, 0.3);
}

[data-theme='dark'] #web_bg {
  background: url('https://qcloud.app966.cn/img/wallpaper/pc/background.jpg');
  background-size: cover;
}

/* 适配手机模式 */

@media (max-width: 768px) {
[data-theme='dark'] #web_bg {
    background: url('https://qcloud.app966.cn/img/wallpaper/mobile/background_phone.jpg');
    background-size: cover;
  }
}

css中的图片链接可以修改成你们自己的哈，也可以在我的相册下载电脑和手机版的图片
最后要在头部引入你自定义的css，在/themes/butterfly/_config.yml文件中添加如下代码
inject:
head:
- rel="stylesheet" href="/css/app966.css">
结尾

到这里就结束啦，非常的简单非常的好看

aplayer魔改

2022-11-20T06:33:10.000Z

解决痛点

越来越多想听的歌曲因为收费无法收听
有些歌曲只在网易云，又有些只在企鹅系才有
我的魔改是播放器功能扩充，并非美化

解决思路

不管它套多少层我们只看官方怎么调用播放的
然后自己添加歌曲进去播放
歌曲是调自己的（下载后保存在oss），但是歌词啥的那肯定用现成了，所以这里要拼接内容
实际也可以不自己下载，在点击播放的时候我们再去取音乐的源地址也行，但是这个有个弊端，首先这个取收费歌曲的接口肯定迟早被封，被封后你得拥有一个vip的账号并且保持在线，一旦掉线你的播放器肯定就废了，所以我建议自定义添加的收费歌曲最好自己下载保存。

部署步骤

首先创建一个歌单页面，使用hexo new page 页面名创建

在建好的页面中填入以下html代码

<div class="aplayer-wrap">
    <div id="aplayer1"><button class="docute-button load" id="kg" onclick="aplayer1()">酷狗歌单button>div>
    <div id="aplayer2"><button class="docute-button load" id="wyy" onclick="aplayer2()">网易云歌单button>div>
    <div id="aplayer3"><button class="docute-button load" id="qq" onclick="aplayer3()">QQ歌单button>div>
div>

<hr>
<div id="aplayer4"><button style="display: block">button>div>

在/butterfly/source/css下新建一个css文件，内容如下

.docute-button:hover {
    color: #fff;
    background-color: #000;
}

.docute-button {
    border: 2px solid #000;
    background-color: #fff;
    color: #000;
    cursor: pointer;
    outline: none;
    border-radius: 33px;
    padding: 5px 18px;
    font-size: 13px;
    font-weight: 700;
    transition: background-color .3s ease;
}

/* 适配黑夜模式 */
[data-theme='dark'] .docute-button:hover{
    color: #000;
    background-color: #fff;
}

[data-theme='dark'] .docute-button {
    border: 2px solid #fff;
    background-color: #000;
    color: #fff
}

.aplayer-wrap {
display: flex;
justify-content: space-between;
}

在/butterfly/source/js下新建一个js文件，内容如下

function aplayer1 () {
var aplayer3 = document.getElementById('qq');
aplayer3.disabled = false;
var aplayer2 = document.getElementById('wyy');
aplayer2.disabled = false;
var aplayer1 = document.getElementById('kg');
aplayer1.disabled = true;
/* 如何获取酷狗歌单id？首先需要设置可见，然后打开抓包工具，随便添加一首歌曲到歌单
 *  https://gateway.kugou.com/v4/add_song? 找到这个接口，在返回文本中找到specalidpgc即可
*/
/* 填写自己的id哦 */
var old_data = get_music('kugou', '6222311');

    window.ap = new APlayer({
        container: document.getElementById('aplayer4'),
        mini: false,
        autoplay: false,
        loop: 'all',
        order: 'list',
        preload: 'none',
        volume: 1,
        mutex: true,
        listFolded: false,
        listMaxHeight: 600,
        lrcType: 3,
        audio: old_data
    });

}

function aplayer2 () {
var aplayer3 = document.getElementById('qq');
aplayer3.disabled = false;
var aplayer2 = document.getElementById('wyy');
aplayer2.disabled = true;
var aplayer1 = document.getElementById('kg');
aplayer1.disabled = false;
/* 填写自己的id哦 */
var old_data = get_music('netease', '7480897649');

    window.ap = new APlayer({
        container: document.getElementById('aplayer4'),
        mini: false,
        autoplay: false,
        loop: 'all',
        order: 'list',
        preload: 'none',
        volume: 1,
        mutex: true,
        listFolded: false,
        listMaxHeight: 600,
        lrcType: 3,
        audio: old_data
    });

}



function aplayer3 () {
    var aplayer3 = document.getElementById('qq');
aplayer3.disabled = true;
var aplayer2 = document.getElementById('wyy');
aplayer2.disabled = false;
var aplayer1 = document.getElementById('kg');
aplayer1.disabled = false;
/* 填写自己的id哦 */
var old_data = get_music('tencent', '8672698451');
var new_data = get_music_json();
    var n_data = add_music(old_data, new_data);
    window.ap = new APlayer({
        container: document.getElementById('aplayer4'),
        mini: false,
        autoplay: false,
        loop: 'all',
        order: 'list',
        preload: 'none',
        volume: 1,
        mutex: true,
        listFolded: false,
        listMaxHeight: 600,
        lrcType: 3,
        audio: n_data
    });
}


function get_music_json() {
    /* 获取自定义音乐列表 */
    /* 这里url填写自己自定义的歌曲，格式可以参考add_music()里面的注释 */
    var url = 'https://qcloud.app966.cn/music_json/music_json.txt';
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, false);
    xhr.send(null);
    var data = JSON.parse(xhr.responseText);
    return data;
}

function get_music(server, id) {
    /* 获取音乐列表，只支持列表 */
    var url = 'https://api.i-meto.com/meting/api?server=' + server + '&type=playlist&id=' + id;
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, false);
    xhr.send(null);
    var obj = JSON.parse(xhr.responseText);
    var music_list = {};
    var data = [];
    for (var i = 0; i < obj.length; i++) {
        music_list = {
            'name': obj[i].title,
            'artist': obj[i].author,
            'url': obj[i].url,
            'cover': obj[i].pic,
            'lrc': obj[i].lrc,
            'theme': '#ad7a86'
        };
        data.push(music_list);
    }
    return data;
}


function add_music(old_data, new_data) {
    /* 自定义添加自己喜欢的音乐，如周杰伦的收费音乐 */
    /*    new_data =  [
            {
                "name": "最伟大的作品",
                "artist": "周杰伦",
                "url": "https://qcloud.app966.cn/music/最伟大的作品.mp3",
                "cover": "https://api.i-meto.com/meting/api?server=tencent&type=pic&id=0024bjiL2aocxT&auth=61e9f0faa8848fad7dcaf1896547cfc1d67530fe",
                "lrc": "https://api.i-meto.com/meting/api?server=tencent&type=lrc&id=003KtYhg4frNXC&auth=c25076612a8e246d85488dcfc4540cbef83d72b8",
                "theme": "#ad7a86"
            }
        ] */

    if (new_data.length > 0) {
        for (var i = 0; i < new_data.length; i++) {
            old_data.unshift(new_data[i]);
        };
    };
    return old_data;

}

function whenDOMReady() {
    if (location.pathname == "/music/" || location.pathname == "/music/index.html") {
        aplayer3();
    }
}
whenDOMReady();

注意事项

以上都解决后基本就结束了，歌单列表替换成你们自己的就行了
我的设置了防盗链，不修改成你们的是无法使用的
如果报错就运行以下命令：
npm install aplayer --save

需要在/butterfly/_config.yml下引入你新建的css、js

inject:
  head:
    -  rel="stylesheet" href="/css/自定义的css.css">
  bottom:
    -  defer data-pjax src="/js/自定义的js.js">

如果设置listMaxHeight列表高度无效，在自定义的css中加入如下代码

.aplayer .aplayer-list {
    max-height: 600px;
}

.aplayer .aplayer-list ol {
    max-height: 600px;
}

继续

如果你也想跟我一样喜欢自定义歌曲的，请按照以下内容继续

首先通过它的接口去获取我们的歌单列表，直接浏览器访问以下链接就行
https://api.i-meto.com/meting/api?server=tencent&type=playlist&id=8672698451
如果不知道接口的意思就看这个文档，其它的直接忽略，我们只看server和type的意思，id很好理解，type是啥id就是啥id咯

访问后把结果赋值给下面set_music()中的arr，然后把运行后的结果赋值给add_music()的new_data，默认是把自己添加在置在最前

function set_music() {
    /* 转换 */
    let arr = [{"title":"去年夏天","author":"王大毛","url":"https://api.i-meto.com/meting/api?server=tencent&type=url&id=004XePmv4CsaEq&auth=28f23251d1b3b2af8df8e03cf484acde79c6a429","pic":"https://api.i-meto.com/meting/api?server=tencent&type=pic&id=003eyd0o3lYmxM&auth=843fd0a3b54f4173c476275be999c3dba547dd36","lrc":"https://api.i-meto.com/meting/api?server=tencent&type=lrc&id=004XePmv4CsaEq&auth=9ce9221aaea8bea58474a5b6dcb329aef90b9319"}];
    var music_list = {};
    var data = [];
    for (var i = 0; i < arr.length; i++) {
        music_list = {
            'name': arr[i].title,
            'artist': arr[i].author,
            'url': 'https://qcloud.app966.cn/music/' + arr[i].title + '.mp3',
            'cover': arr[i].pic,
            'lrc': arr[i].lrc,
            'theme': '#ad7a86'
        };
        data.push(music_list);
    }
    console.log(data);
    return data;
}
set_music();

运行示例
最后就是下载歌曲啦

运行下面的代码即可

import requests
import os

def dow():
    while True:
        music_name = input('\r请输入歌曲名：')
        if music_name == 'exit':
            break
        header = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0'}
        url = 'http://search.kuwo.cn/r.s?client=kt&all=' + music_name + '&pn=0&rn=10&ver=kwplayer_ar_99.99.99.99&vipver=1&ft=music&cluster=0&strategy=2012&encoding=utf8&rformat=json&vermerge=1&mobi=1'
        ret = requests.get(url, headers=header, verify=False).json()
        n = 0
        title = ''
        for i in ret['abslist']:
            n += 1
            title += str(n) + '. ' + i['SONGNAME'] + ' - ' + i['ARTIST'] + '\n'
        print(title)
        rid = input('请输入序号下载对应的歌曲：')
        x = int(rid) - 1
        rid = ret['abslist'][x]['MUSICRID']
        music_name = ret['abslist'][x]['SONGNAME']
        if '-' in music_name:
            music_name = str_left(music_name, '-')
        print(rid, music_name)
        url = 'http://antiserver.kuwo.cn/anti.s?response=url&rid=' + rid + '&format=mp3|mp3&type=convert_url'
        play_url = requests.get(url, headers=header, verify=False).text
        if play_url:
            downloader(play_url, music_name)


def downloader(url, title):
    size = 0
    path = r'D:\\music\\' + title + '.mp3'
    res = requests.get(url, stream=True, verify=False)
    chunk_size = 1024
    # 每次下载数据大小
    content_size = int(res.headers["content-length"])
    # 总大小
    if res.status_code == 200:
        print('[%s 文件大小]: %0.2f MB' % (title, content_size / chunk_size / 1024))
        with open(path, 'wb') as f:
            for data in res.iter_content(chunk_size=chunk_size):
                f.write(data)
                size += len(data)  # 已下载文件大小
                print('\r' + '[下载进度]: %s%.2f%%' % ('>' * int(size * 50 / content_size), float(size / content_size * 100)), end='')


def str_left(t, s):
    if isinstance(t, str) != True or isinstance(s, str) != True:
        return '传入参数有误'
    elif t.find(s) != -1:
        return t[0:t.find(s)]
    else:
        return ""

if __name__ == '__main__':
    dow()

运行示例
预览我的歌单查看效果

删除meting_js

在hexo目录下执行npm uninstall hexo-tag-aplayer

打开/butterfly/scripts/events/config.js文件，删除meting_js

    aplayer_css: 'https://cdn.jsdelivr.net/npm/aplayer@1/dist/APlayer.min.css',
    aplayer_js: 'https://cdn.jsdelivr.net/npm/aplayer@1/dist/APlayer.min.js',
-   meting_js: 'https://cdn.jsdelivr.net/gh/metowolf/MetingJS@1.2/dist/Meting.min.js',
    prismjs_js: 'https://cdn.jsdelivr.net/npm/prismjs@1/prism.min.js',

抖音自动上传视频

2022-11-07T08:01:25.000Z

发布视频小程序V3.2

介绍

如何使用

把项目下载到本地

依次运行下面命令

git clone https://github.com/Superheroff/douyin_uplod.git
pip install -r requirements.txt -i https://mirrors.bfsu.edu.cn/pypi/web/simple/
playwright install chromium
python main.py

注意①：只提供昵称的@并不准确，加抖音号才能完全准确
注意②：首次使用需要先运行get_cookie.py登录

目录结构

douyin_uplod V3
│
├── frames  # 存放视频抽帧的图片
│     └── x.jpg # 图片
├── video  # 视频目录
│     └── x.mp4 # 未处理的视频
│     └── x2.mp4 # 处理中未添加背景音乐的视频
│     └── x3.mp4 # 处理完的视频（上传的是这个视频，上传未经处理的视频会被限流）
├── music  # 背景音乐目录
│     └── background.mp3 # 从视频中提取出来的音乐
├── cookie  # 存放账号目录
│     └── cookie_手机号.json # cookie
├── main.py    # 主程序入口
├── config.py  # 配置文件
├── get_cookie.py  # 生成cookie.json文件
├── logs.py  # 生成日志
├── logs.log  # 日志
├── video_id_list.txt  # 记录发过的视频ID，避免重复
├── README.md
└── requirements.txt # 依赖文件

更新内容

2024.06.27

修复视频下载

2024.06.25

修复登录

2024.04.06

本次更新不再依赖任何第三方api

2024.03.26

修复判断是否登录

2024.03.18

优化@人，解决对方改变昵称后@不成功的问题
新增配置自定义截取视频开头结尾帧数

2024.03.07

新增视频声明配置
新增视频定位开关配置
解决了一些问题

2024.03.04

修复文件路径问题
新增视频发布进度条
新增视频声明
先判断是否登录再处理视频，解决先处理视频后发现未登录的尴尬场景

2024.01.23

解决get_cookie无法获取cookie的问题

2024.01.17

修复BUG

2024.01.15

解决视频重复问题
新增单双号发布不同的话题内容

2024.01.12

优化@人
新增城市定位
新增普通认证号筛选
筛选优化，如全部未有符合条件的内容自动再次获取

2024.01.11

优化处理视频
新增筛选：去除图集视频、去除时长过短的视频
优化音乐榜采集，增加随机翻页减少重复视频

待优化

识别擦边女，拒绝爬取擦边视频

运行逻辑

每隔1小时随机从抖音热门音乐中选择一首，从选择的音乐中随机提取一条视频，并抽掉前90帧和尾30帧后发布
如有侵权，请联系我删除！
联系方式：838210720

运行日志

正在使用[15579611112]发布作品，当前账号排序[1]
正在判断账号是否登录
账号已登录
music_id: 7312850623345527603
url: http://v3-web.douyinvod.com/e5be13cd66c2e99df4a5dc8d74a4bff4/65e4afcf/video/tos/cn/tos-cn-ve-15/ocwAH9yEbELzxBwIgKCLYthCfAAe3Q7Dyr9TGI/?a=6383&ch=8&cr=3&dr=0&lr=all&cd=0%7C0%7C0%7C3&cv=1&br=1289&bt=1289&cs=0&ds=4&ft=bvTKJbQQqUiSf_TZyo0ORVTYA0pijkIrejKJsCAyx.0P3-I&mime_type=video_mp4&qs=0&rc=ZjU1OjU8ZjhlNzU7ZDs8NUBpamU2azY6ZjhrcTMzNGkzM0A2NC80Y18yXjYxLTNgYWFhYSNpbjM2cjRfcWFgLS1kLS9zcw%3D%3D&btag=e00018000&cquery=100a&dy_q=1709482393&feature_id=46a7bb47b4fd1280f3d3825bf2b29388&l=20240304001313B4854C73E6800D57BF70
nickname: 黏苞米糊糊
video_id: 7339494544162983204
处理前md5： 4453555b2ac6c4b6c9d844d94d27301d
正在处理视频
视频抽帧进度: 100%|██████████| 1047/1047 [00:39<00:00, 26.44it/s]
图片合成进度: 100%|█████████▉| 1046/1047 [00:14<00:00, 72.67it/s]
开始添加背景音乐！
MoviePy - Writing audio in music/background.mp3
MoviePy - Done.
Moviepy - Building video E:\python\douyin\发布小程序\video\#标题2 @1486323920 —来自：音乐榜单的第2个音乐《身骑白马 (pay姐版) 已全网上线》第13页第5个@黏苞米糊糊 的作品3.mp4.
MoviePy - Writing audio in #标题2 @1486323920 —来自：音乐榜单的第2个音乐《身骑白马 (pay姐版) 已全网上线》第13页第5个@黏苞米糊糊 的作品3TEMP_MPY_wvf_snd.mp3
t:   0%|          | 0/1047 [00:00
Moviepy - Writing video E:\python\douyin\发布小程序\video\#标题2 @1486323920 —来自：音乐榜单的第2个音乐《身骑白马 (pay姐版) 已全网上线》第13页第5个@黏苞米糊糊 的作品3.mp4

t: 100%|█████████▉| 1046/1047 [00:25<00:00, 43.60it/s, now=None][2024-03-04 00:14:57,566]-warnings.py-109-MainThread-E:\python\douyin\发布小程序\venv\Lib\site-packages\moviepy\video\io\ffmpeg_reader.py:123: UserWarning: Warning: in file E:\python\douyin\发布小程序\video\#标题2 @1486323920 —来自：音乐榜单的第2个音乐《身骑白马 (pay姐版) 已全网上线》第13页第5个@黏苞米糊糊 的作品2.mp4, 6220800 bytes wanted but 0 bytes read,at frame 1046/1047, at time 34.87/34.87 sec. Using the last valid frame instead.
  warnings.warn("Warning: in file %s, "%(self.filename)+

Moviepy - Done !
Moviepy - video ready E:\python\douyin\发布小程序\video\#标题2 @1486323920 —来自：音乐榜单的第2个音乐《身骑白马 (pay姐版) 已全网上线》第13页第5个@黏苞米糊糊 的作品3.mp4
背景音乐添加完成！
处理后md5： f97a9c8b2140a228142db443937f6b79
视频处理完毕
该视频有话题
[2024-03-04 00:14:59,035]-main.py-450-MainThread-视频下载成功，等待发布
Timeout 30000ms exceeded.
正在添加第1个话题
正在添加第1个想@的人
[2024-03-04 00:15:37,533]-main.py-505-MainThread-@1486323920失败了，可能被对方拉黑了
@1486323920失败了，可能被对方拉黑了
正在添加第2个话题
正在添加第3个话题
正在添加第2个想@的人
想@的人 黏苞米糊糊
正在添加第4个话题
视频标题输入完毕，等待发布
位置添加成功
[2024-03-04 00:15:51,116]-main.py-538-MainThread-账号发布视频成功
[2024-03-04 00:15:51,205]-main.py-549-MainThread-账号发布视频成功
来自网页的实时消息：发布成功
账号发布视频成功

声明

qq交流群：816017833
有任何问题请到issues提交
本源码只是出于学习交流的目的，使用者造成的任何后果均与作者无关

快手did注册

2022-08-20T14:57:10.000Z

前言

2022-8-20测试可用
网页版did
仅限用于学习交流
滥用导致的后果与作者无关

代码

代码是易语言
思路

访问快手官网获取返回的did
通过/rest/wd/common/log/collect/misc2注册
注册完需要访问一次用户主页才算成功

.版本 2
.支持库 spec

.程序集 程序集1
.程序集变量 cookie, 文本型
.程序集变量 http, 类_POST数据类
.程序集变量 ua, 文本型
.程序集变量 did, 文本型

.子程序 _启动子程序, 整数型, , 请在本子程序中放置动态链接库初始化代码


_临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
返回 (0)  ' 返回值被忽略。

.子程序 _临时子程序

' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
ua ＝ “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36”
http.添加 (“content-type”, “application/json”)
http.添加 (“User-Agent”, ua)

获取did ()
获取用户作品 ()

.子程序 获取did, 逻辑型
.局部变量 url, 文本型
.局部变量 ret, 文本型
.局部变量 data, 文本型
.局部变量 json, 类_json
.局部变量 re, 正则表达式类
.局部变量 uid, 文本型
.局部变量 name, 文本型

url ＝ “https://live.kuaishou.com/cate/ZH/1000020”
ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (url, , , , cookie, “User-Agent: ” ＋ ua))
re.创建 (#常量4, ret, , 真, 真)
uid ＝ 文本_取左边 (re.取匹配文本 (1), “,” ＋ #引号 ＋ “LiveInfo:”)
json.解析 (uid)
uid ＝ 文本_取右边 (json.取通用属性 (“user.id”), “User:”)
re.创建 (#常量5, ret, , 真, 真)
name ＝ 文本_取出中间文本 (re.取匹配文本 (1), #引号 ＋ “name” ＋ #引号 ＋ “:” ＋ #引号, #引号)
did ＝ 网页_取单条Cookie (cookie, “did”, 真)
调试输出 (did, uid, name)
url ＝ “https://log-sdk.ksapisrv.com/rest/wd/common/log/collect/misc2?v=3.9.49&kpn=KS_GAME_LIVE_PC”
data ＝ 子文本替换 (#常量2, “[did]”, did, , , 真)
data ＝ 子文本替换 (data, “[ts]”, 时间_取现行时间戳 (), , , 真)
data ＝ 子文本替换 (data, “[tss]”, 文本_取随机范围数字 (1000, 9999), , , 真)
ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (url, 1, data, cookie, , http.获取协议头数据 ()))
json.解析 (ret)

.如果真 (uid ＝ “” 或 name ＝ “”)
    返回 (假)
.如果真结束
.判断开始 (json.取通用属性 (“result”) ＝ “1”)
    url ＝ “https://live.kuaishou.com/u/” ＋ uid
    ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (url, , , cookie, , http.获取协议头数据 ()))
    .判断开始 (寻找文本 (ret, name, , 假) ≠ -1)
        返回 (真)
    .默认
        返回 (假)
    .判断结束

.默认
    返回 (假)
.判断结束


.子程序 获取用户作品
.参数 uid, 文本型, 可空
.局部变量 url, 文本型
.局部变量 ret, 文本型
.局部变量 data, 文本型

.如果真 (uid ＝ “”)
    uid ＝ “3x9d8g28wd78xs2”
.如果真结束

url ＝ “https://www.kuaishou.com/graphql”
http.添加 (“Referer”, “https://www.kuaishou.com/profile/” ＋ uid)
http.添加 (“Origin”, “https://www.kuaishou.com”)
http.添加 (“Host”, “www.kuaishou.com”)
http.添加 (“sec-ch-ua”, #常量6)
http.添加 (“sec-ch-ua-mobile”, “?0”)
http.添加 (“sec-ch-ua-platform”, #引号 ＋ “Windows” ＋ #引号)
http.添加 (“Sec-Fetch-Dest”, “empty”)
http.添加 (“Sec-Fetch-Mode”, “cors”)
http.添加 (“Sec-Fetch-Site”, “same-origin”)
data ＝ 子文本替换 (#常量3, “[uid]”, uid, , , 真)
ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (url, 1, data, “Cookie: kpf=PC_WEB; kpn=KUAISHOU_VISION; ksliveShowClipTip=true; clientid=3; did=” ＋ did ＋ “; client_key=65890b29”, , http.获取协议头数据 ()))
调试输出 (ret)
置剪辑板文本 (ret)

下载e源码

kuaishou.e

浅谈一下如何应对ddos攻击和软件破解

2022-08-13T08:34:21.000Z

前言

ddos攻击和软件破解我经历了太多了
近期闲下来想了很多，如果想彻底解决被破解的烦恼不能只从前端去解决，因为这样是治标不治本的，Adobe、Jetbrains这种大公司的软件都能被破解还解不了你吗？

解决思路

后端防破解

下面是我的后端处理思路

我们的软件分为前端和后端，前端是用户接触和操作的部分，后端是给前端提供服务的部分，我们要严格区分前后端的功能，不能把实际功能写在前端，而是通过调用后端来返回
前端只负责展示内容和用户登录注册，其它的事一律不做
然后用户登录后我们把他的id返回给后端告诉后端这个人已经登录了，现在我们开始对他进行校验，他每次点击前端的某个重要功能都从后端获取一次他的是否到期的状态，后端每60秒（或者其他时间根据实际情况来）校验一次他的到期时间并把是否到期的结果存入redis中，做一个接口从redis返回这个结果给到前端，这样解决频繁调用的问题，后端要做计划任务，60秒或者多少秒根据你的实际需求来，可以一直做计划任务，因为你不可能就一个用户这个用户下线另一个用户还在呢；如何校验？用redis的集合呗，只校验到期的那个集合里是否有他就行了，有他那我们后端直接给前端返回空，等于直接罢工了，反之正常运行。
我这到期时间只是一种例子，你可以根据实际情况来，比如用cookie、token校验登录状态，破解者肯定是破解掉你的登录，用户名也是随便输入的你数据库可能都没有这个用户，登录状态不在线的情况下我们就罢工，你的接口也要去校验时间戳，数据传输最好做个加密，以免破解者发送旧包蒙混过关

前端防破解

下面是我的前端处理思路

检验启动文件的md5 crc32 以及文件体积
检测od等调试工具
关键代码处不要有任何信息提示，不要有如果和判断，用循环，循环次数无所谓啊，你反正在执行完代码的尾处直接写个跳出就行
时间检测，检测初始化代码的运行时间，如果时间太长肯定有问题，我们直接给他结束
设置暗桩，比如你明检测到被破解了，但是你不说，等到运行主程序的时候某些功能无法使用啊或者少内容等，注意：全程不要输出任何提示，让某些功能失效时直接就失效，不要有提示，不要信息框，不要打印输出
使用多种不同的语言写代码，比如我时间检测用java，检测od用易语言，检测md5用python等
混淆代码。易语言可以在工具-系统配置-安全-设置花指令-设置指令打乱

防ddos攻击

首先这是个费钱的活，你肯定得增加服务器

流量小用nginx做个简单的负载均衡即可解决
一定要用CDN，为什么呢？把自己的真实IP隐藏起来才是真的，这样我把子域名一改嘿嘿我又活了
拉黑一些恶意IP，禁止境外IP访问，因为ddos大部分都是境外的IP攻击
流量大最好是用nacos + spring cloud alibaba【涉及到的知识有java、docker、spring cloud、linux】
如何区分流量大小，每秒1W以上并发进来的算是比较大了
实在抗不住把你挂掉的机器也加入到集群中，这样总不至于整个垮掉，起到一个雪崩保护的作用

结尾

有更好的思路可以留言一起探讨
以上是我的全部解决思路，希望对你有所帮助吧

Butterfly友链检查、友链朋友圈开发

2022-08-11T07:13:53.000Z

前言

Q: 已经有成熟可用的相关项目了为啥还要做一个呢？
A：一切都是为了摸鱼。主要为了打发时间加练练手，另外他的源码我也看了，是不错的；我不在他的上面做继承，我只做Butterfly主题的适配；
A：整个项目大致逻辑通过每日计划任务[x,x1,x2]时获取朋友的一篇最新文章并存入redis中间件中以供前端调用，第二天自动清除，不保存历史数据。
Q：为啥要使用redis这个项目的场景调用量并不多？
A：主要是因为我想熟悉下redis好久没有使用了，而且redis确实适合这种场景下，轻便速度也快，最主要没有存数据的需求，随取随丢。

当前进度

2022

08-20

已完善友链检查
新增获取友链的最新/随机文章为后面的友链朋友圈做铺垫

08-10

完成了友链检查雏形

代码

主文件代码

Centos安装node.js详细教程

2022-08-06T06:17:15.000Z

下载node.js

我使用的是Centos7.9
进入官网下载页
选择下载linux-64
使用淘宝镜像源下载

wget https://registry.npmmirror.com/-/binary/node/v16.16.0/node-v16.16.0-linux-x64.tar.xz

解压

复制压缩文件名，执行解压命令

tar -xvf node-v16.16.0-linux-x64.tar.xz

为了方便操作node的文件夹，将压缩后的文件移动到名为node16的文件夹，也可以根据自己的喜好来命名新文件夹

mv node-v16.16.0-linux-x64 node16

然后再把当前目录的node16目录移动到/usr/local目录下

mv node16 /usr/local

配置环境变量

vi /etc/profile

在文件中输入以下内容，输入i开始编辑

export NODE_HOME=/usr/local/node16
export PATH=$PATH:$NODE_HOME/bin
export NODE_PATH=$NODE_HOME/lib/node_mudules

编写完成后按esc键退出编辑，然后输入:wq保存文件内容，输入错误就不要保存了输入:q!不保存退出再重新编辑
使配置立即生效

source /etc/profile

创建软链接

# 创建node命令链接
ln -s /usr/local/node16/bin/node /usr/local/bin/node

# 创建npm命令链接
ln -s /usr/local/node16/bin/npm /usr/local/bin/npm

测试

在任意目录下输入node -v和npm -v查看版本号

node -v
npm -v

🎭 playwright 相关笔记

2022-08-03T05:10:53.000Z

什么是Playwright？

Playwright是微软在2020年初开源的新一代自动化测试工具，它的功能类似于Selenium、Pyppeteer等，都可以驱动浏览器进行各种自动化操作。它的功能也非常强大，对市面上的主流浏览器都提供了支持，API 功能简洁又强大。虽然诞生比较晚，但是现在发展得非常火热。
因为Playwright是一个类似Selenium一样可以支持网页页面渲染的工具，再加上其强大又简洁的API，Playwright同时也可以作为网络爬虫的一个爬取利器。
Playwright是支持异步的，异步并非多线程。例如：程序a2秒执行完，程序b5秒执行完，非异步的话全部执行完要7秒，异步的话只要5秒，异步需要了解asyncio

安装

pip install playwright
python -m playwright install

基本参数

Playwright基本参数

--headed：在有头模式下运行测试（默认：无头）。
--browser：在不同的浏览器中运行测试chromium，firefox或webkit。可以多次指定（默认：所有浏览器）。
--browser-channel 要使用的浏览器频道。
--slowmo以慢动作运行测试。
--device 要模拟的设备。
--output测试产生的工件目录（默认值：）test-results。
--tracing是否为每个测试记录跟踪。on, off, 或retain-on-failure（默认值：off）。
--video是否为每次测试录制视频。on, off, 或retain-on-failure（默认值：off）。
--screenshot每次测试后是否自动截屏。on, off, 或only-on-failure（默认值：off）。

Selenium基本参数

# options.add_argument('--headless')                     # 开启无界面模式
# options.add_argument("--disable-gpu")                  # 禁用gpu
# options.add_argument('--user-agent=Mozilla/5.0 HAHA')  # 配置对象添加替换User-Agent的命令
# options.add_argument('--window-size=1366,768')         # 设置浏览器分辨率（窗口大小）
# options.add_argument('--start-maximized')              # 最大化运行（全屏窗口）,不设置，取元素会报错
# options.add_argument('--disable-infobars')             # 禁用浏览器正在被自动化程序控制的提示
# options.add_argument('--incognito')                    # 隐身模式（无痕模式）
# options.add_argument('--disable-javascript')           # 禁用javascript
# options.add_argument('--disable-plugins') # 禁止加载所有插件
# options.add_argument('--blink-settings=imagesEnabled=false') # 禁止加载图片
# options.add_argument('--user-agent=xx')  # 配置对象添加替换User-Agent的命令

基本使用

获取谷歌统计示例

获取谷歌的统计信息

import re
from playwright.sync_api import sync_playwright

def cancel_request(route, request):
    route.abort()

def google(p, link):
    url = 'https://www.google.com/search?q=site%3A' + link
    proxy = {
        'server': 'http://127.0.0.1:7890'
    }
    browser = p.webkit.launch(headless=False, proxy=proxy)
    context = browser.new_context()
    page.route(re.compile(r"(\.png)|(\.jpg)|(\.css)"), cancel_request)
    page = context.new_page()
    page.goto(url)
    res = page.query_selector('xpath=//*[@id="result-stats"]')
    res_info = res.text_content()
    browser.close()
    if not res_info:
        res_info = '未收录'
    return res_info

def main():
    with sync_playwright() as playwright:
        ret = google(playwright, 'app966.cn')
        print(ret)
        
main()

注意异步引入的是playwright.async_api，这里我就踩坑了，导致一直报错

import asyncio
import re
from playwright.async_api import async_playwright

async def cancel_request(route, request):
    await route.abort()

async def google(p, link):
    url = 'https://www.google.com/search?q=site%3A' + link
    proxy = {
        'server': 'http://127.0.0.1:7890'
    }
    browser = await p.webkit.launch(headless=False, proxy=proxy)
    context = await browser.new_context()
    page = await context.new_page()
    await page.route(re.compile(r"(\.png)|(\.jpg)|(\.css)"), cancel_request)
    await page.goto(url)
    res = await page.query_selector('xpath=//*[@id="result-stats"]')
    res_info = res.text_content()
    await browser.close()
    if not res_info:
        res_info = '未收录'
    return res_info

async def main():
    async with async_playwright() as playwright:
        ret = await google(playwright, 'app966.cn')
        print(ret)

asyncio.run(main())

Selenium的相同操作代码我也放下吧，这里是Selenium 4.3.0版本，旧版不适用

from selenium import webdriver
from selenium.webdriver.common.by import By
def google(link):
    url = 'https://www.google.com/search?q=site%3A' + link
    prefs = {"profile.managed_default_content_settings.images": 2, 'permissions.default.stylesheet': 2}
    options = ChromeOptions()
    options.add_experimental_option("prefs", prefs)
    options.add_argument("--headless")
    options.add_argument('--incognito')
    options.add_argument('--blink-settings=imagesEnabled=false')
    browser = webdriver.Chrome(executable_path=r'C:\Program Files (x86)\Google\Chrome\Application\chromedriver.exe', options=options)
    browser.get(url)
    res = browser.find_element(By.XPATH, '//*[@id="result-stats"]').text
    browser.close()
    if not res:
        res = '未收录'
    return res

禁用css、图片以提升访问速度

使用route.abort中止请求

import re
await page.route(re.compile(r"(\.png)|(\.jpg)|(\.css)"), route.abort())

设置基本参数

from selenium import webdriver
from selenium.webdriver import ChromeOptions
options = ChromeOptions()
prefs = {"profile.managed_default_content_settings.images": 2,'permissions.default.stylesheet':2}
options.add_experimental_option("prefs", prefs)
browser = webdriver.Chrome(executable_path='xxx\chromedriver.exe', options=options)

Playwright与其它主流测试框架对比

能力	Playwright	Puppeteer	Selenium
速度	快	快	慢
归档能力	优秀	优秀	普通
开发体验	好	比较好	普通
支持的语言	JavaScript、Python、C#和Java	JavaScript	Java、Python、C#、Ruby、JavaScript和Kotlin
支持方	微软	谷歌	社区和赞助商
社区	小而活跃	大而活跃	大而活跃
浏览器支持	Chromium、Firefox和WebKit	Chromium	Chrome、Firefox、IE、Edge、Opera和Safari等

未完待续

Playwright我也是刚学不久，有更多优秀的操作案例我会持续更新的

抖音直播弹幕捕获【转载 + 修改】

2022-07-29T23:27:53.000Z

前言

无意在精易论坛看到了这个帖子
简单浏览了下这个源码的逻辑就是运行webDriver.py把弹幕下载下来并且存放在douyinLiveFile文件夹中
然后运行webChat.py去读douyinLiveFile文件夹中下载好的弹幕并解析
是通过playwright检测网页响应状态，对于爬虫来说就是自动抓取指定的内容，不需要任何算法，反爬将毫无意义，这让我想起了另一款神器selenium
这里很有必要去了解一下Playwright是什么
补充：这个方法比wss连接的要好，物理外挂最为致命，并且playwright是支持异步的，也就是可以执行多个直播间的任务，具体转到playwright官方文档查阅
简单的加密已经不能防范这个方式的爬虫了，只要浏览器可以看的它都可以获取
此源码需要有python基础，不太适合新手，因为这个只是做了个获取演示，你需要再去修改处理获取后的内容，要更方便的使用最好部署在服务器中
我博客很多内容都是一个结果而没有分析过程导致好像是搬运而来的一样，我只是不太喜欢写教程以及过程这样太麻烦了，后面会慢慢改正

代码

注意事项

只能使用网页版直播链接
我这里只放修改处
点击此处下载完整版

# -*- coding: utf-8 -*-
import os
import time
import requests
import shutil
from google.protobuf.json_format import MessageToDict
import json
from messages.message_pb2 import *
import base64
import asyncio

def getScriptDir():
    return os.path.split(os.path.realpath(__file__))[0]

class Watcher():
    def __init__(self):
        self.monitoringFile = f'{getScriptDir()}\\douyinLiveFile'

    async def startWatcher(self):
            files = os.listdir(self.monitoringFile)
            if files:
                for _ in files:
                    filepath = self.monitoringFile + '\\' + _
                    with open(filepath, 'rb') as f:
                        datas = {}
                        messages = []
                        danmu_resp = Response()
                        danmu_resp.ParseFromString(f.read())
                        f.close()
                        obj = MessageToDict(danmu_resp, preserving_proto_field_name=True)
                        if obj:
                            if obj.get('messages'):
                                datas.update({'now': obj.get('now')})
                                for message in obj["messages"]:
                                    method = message["method"]
                                    payload = bytes(base64.b64decode(message["payload"].encode()))
                                    if method == "WebcastMemberMessage":
                                        menber_message = MemberMessage()
                                        menber_message.ParseFromString(payload)
                                        obj1 = MessageToDict(menber_message, preserving_proto_field_name=True)
                                        obj1 = {'method': method, 'msgId': message['msgId'], 'payload': obj1}
                                        messages.append(obj1)
                                    if method == "WebcastChatMessage":
                                        menber_message5 = ChatMessage()
                                        menber_message5.ParseFromString(payload)
                                        obj2 = MessageToDict(menber_message5, preserving_proto_field_name=True)
                                        obj2 = {'method': method, 'msgId': message['msgId'], 'payload': obj2}
                                        messages.append(obj2)

                                datas.update({'data': messages})
                                ret = json.dumps(datas)
                                with open('./userImages/' + str(int(time.time())) + '.json', 'w') as file:
                                    file.write(ret)
                                    file.close()

                        else:
                            ret = {'msg': '请先运行webdriver获取弹幕文件'}

            print(ret)
            return ret

if __name__ == '__main__':
    if not os.path.isdir(getScriptDir()+"\\douyinLiveFile"):# 这里存放未解析的弹幕文件
        os.makedirs(getScriptDir()+"\\douyinLiveFile")
    if not os.path.isdir(getScriptDir()+"\\userImages"):# 这里存放解析好的json数据文件
        os.makedirs(getScriptDir()+"\\userImages")
    while True:
            time.sleep(1)
            asyncio.run(Watcher().startWatcher())

结束

本源码仅限学习交流

请勿用于非法途径

抖音汽水音乐API

2022-07-29T23:14:33.000Z

前言

收集了那么多音乐api不差这一个了
这个播放器的音乐都是网红歌曲，主要为了获取榜单排行榜音乐
这个播放器有加密但是它不校验加密，丢浏览器都能直接请求的那种
好像是抖音旗下的属实有点冷门
不逼逼了直接放代码结束

代码区

package coke;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class coke_music {

    public static String get_musiclist(int music_type){
        /*
        获取歌单列表
        music_type=类型
        0=每日推荐
        93=官方
        9=欧美
        38=说唱
        16=电子
        15=摇滚
        18=民谣
        19=R&B
        20=国风
        40=学习
        45=睡前
        69=治愈
        8=华语
        14=流行
        */
        String url = "https://beta-luna.douyin.com/luna/feed/playlist-square?request_tag_from=lynx&device_platform=android&os=android&ssmix=a&_rticket=1659112744687&cdid=4a6a891c-e1e1-4fec-8ef6-94f28a302b0b&channel=xiaomi_8478&aid=8478&app_name=luna&version_code=10090140&version_name=1.9.1&manifest_version_code=10090140&update_version_code=10090140&resolution=1080*2030&dpi=440&device_type=MI+6X&device_brand=xiaomi&language=zh&os_api=28&os_version=9&ac=wifi&package=com.luna.music&hybrid_version_code=10090140&device_model=MI+6X&tz_name=Asia%2FShanghai&tz_offset=28800&network_speed=5246&iid=&device_id=";
        JSONObject param = new JSONObject();
        param.put("category_id", music_type);
        String result = null;
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient client = HttpClients.createDefault();
        StringEntity entity = new StringEntity(param.toJSONString(), "UTF-8");
        httpPost.setHeader("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1");
        httpPost.setEntity(entity);
        try {
            HttpResponse response = client.execute(httpPost);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity(), "utf-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
            result = "error";
        }

        return result;
    }


    public static String get_musicrank(){
        /*
        获取rank榜
        */
        String url = "https://beta-luna.douyin.com/luna/discover?device_platform=android&os=android&ssmix=a&_rticket=1659122791092&cdid=05d1276c-3cad-4d05-892c-bb5187ca51b8&channel=xiaomi_8478&aid=8478&app_name=luna&version_code=10090140&version_name=1.9.1&manifest_version_code=10090140&update_version_code=10090140&resolution=1080*2030&dpi=440&device_type=MI+6X&device_brand=xiaomi&language=zh&os_api=28&os_version=9&ac=wifi&package=com.luna.music&hybrid_version_code=10090140&device_model=MI+6X&tz_name=Asia%2FShanghai&tz_offset=28800&network_speed=5297&iid=&device_id=";

        String result = null;
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient client = HttpClients.createDefault();
        Map map = new HashMap<>();
        map.put("body", null);
        StringEntity entity = new StringEntity(map.toString(), "UTF-8");
        httpPost.setEntity(entity);
        httpPost.setHeader("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1");
        try {
            HttpResponse response = client.execute(httpPost);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity(), "utf-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
            result = "error";
        }

        return result;
    }



    public static String get_playlist(String playlist_id){
        /*获取歌单里面的歌曲*/
        String url = MessageFormat.format("https://beta-luna.douyin.com/luna/playlist/detail?playlist_id={0}&cursor&device_platform=android&os=android&ssmix=a&_rticket=1659112831329&cdid=4a6a891c-e1e1-4fec-8ef6-94f28a302b0b&channel=xiaomi_8478&aid=8478&app_name=luna&version_code=10090140&version_name=1.9.1&manifest_version_code=10090140&update_version_code=10090140&resolution=1080*2030&dpi=440&device_type=MI+6X&device_brand=xiaomi&language=zh&os_api=28&os_version=9&ac=wifi&package=com.luna.music&hybrid_version_code=10090140&device_model=MI+6X&tz_name=Asia%2FShanghai&tz_offset=28800&network_speed=5246&iid=&device_id=", playlist_id);

        String result = null;
        HttpGet httpGet = new HttpGet(url);
        CloseableHttpClient client = HttpClients.createDefault();
        httpGet.setHeader("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1");

        try {
            HttpResponse response = client.execute(httpGet);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity(), "utf-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
            result = "error";
        }

        return result;
    }

    public static void main(String[] args) {
        String musicrank = get_musicrank();
        System.out.println("榜单列表：" + musicrank);

        String musiclist = get_musiclist(0);
        System.out.println("歌单列表：" + musiclist);
        JSONObject obj = JSONObject.parseObject(musiclist);
        List Array = obj.getJSONArray("items");
        JSONArray jsonArray = new JSONArray(Array);
        /*这里demo就取随机一个，你也可以固定或者全部取*/
        int listint = (int) (Math.random() * jsonArray.toArray().length);
        JSONObject obj1 = jsonArray.getJSONObject(listint);
        String list_id = obj1.getString("id");
        System.out.println(list_id);
        String playlist = get_playlist(list_id);
        System.out.println("音乐列表：" + playlist);

        obj = JSONObject.parseObject(playlist);
        Array = obj.getJSONArray("tracks");
        jsonArray = new JSONArray(Array);
        listint = (int) (Math.random() * jsonArray.toArray().length);
        obj1 = jsonArray.getJSONObject(listint);
        String music_id = obj1.getString("vid");
        System.out.println("音乐ID：" + music_id);
        /*得到这个id就等于结束了，不要从音乐列表去获取音乐的url，我测试是不行无法播放，具体原因懒得研究了。这里直接用抖音的万能解析接口
        https://www.douyin.com/aweme/v1/play/?video_id=这里输入上面获取的音乐ID&line=0&is_play_url=1&source=PackSourceEnum_PUBLISH
        请求后即可获得播放地址，会员音乐也是可以获取到的，目前全程无任何加密！
        * */
    }
}

结束

酷狗signature值计算

2022-07-28T17:40:03.000Z

前言

无聊的一天

想下载一个高清的MV，下载完了顺带分享一下吧
这次是用易语言写的代码

过程

url去除“?”左边的然后按a-z排序
排序完并拼接上前后各加上“OIlwieks28dk2k092lksi2UIkp”然后md5
这个方式让我想起了角落里的快手，不能说毫不相干，只能说一模一样

开始

.版本 2
.支持库 spec

.程序集 程序集1

.子程序 _启动子程序, 整数型, , 请在本子程序中放置动态链接库初始化代码

' kg_ (“说爱你”, 2)
kg_mv (“DA546EF394077B690902C58F858CAAE1”)
返回 (0)  ' 返回值被忽略。




.子程序 kg_mvhash, 文本型, , 获取高清MV
.参数 mvid, 文本型
.局部变量 http, 类_POST数据类
.局部变量 ret, 文本型
.局部变量 URL, 文本型
.局部变量 data, 文本型
.局部变量 signature, 文本型

URL ＝ “https://gateway.kugou.com/openapi/kmr/v1/mv?srcappid=2919&clientver=20000&clienttime=” ＋ 时间_取现行时间戳 () ＋ “&mid=b8d5700894e7d861d6859c2513d20808&uuid=b8d5700894e7d861d6859c2513d20808&dfid=4XSSn60jHVzu4IUffL0uxRKB&appid=1014&token=&userid=0”
signature ＝ kg_signature (URL, 真)
URL ＝ URL ＋ “&signature=” ＋ signature
http.添加 (“User-Agent”, “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36”)
http.添加 (“Host”, “gateway.kugou.com”)
http.添加 (“KG-TID”, “317”)
data ＝ “{” ＋ #引号 ＋ “fields” ＋ #引号 ＋ “:” ＋ #引号 ＋ “base,h264” ＋ #引号 ＋ “,” ＋ #引号 ＋ “data” ＋ #引号 ＋ “:[{” ＋ #引号 ＋ “entity_id” ＋ #引号 ＋ “:” ＋ #引号 ＋ “224394” ＋ #引号 ＋ “}]}”
ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (URL, 1, data, , , http.获取协议头数据 ()))
调试输出 (ret)
返回 (ret)

.子程序 kg_mv
.参数 hash, 文本型
.局部变量 http, 类_POST数据类
.局部变量 ret, 文本型
.局部变量 URL, 文本型

URL ＝ “http://trackermvretry.kugou.com/interface/index?cmd=104&pid=2&ext=mp4&hash=” ＋ 到小写 (hash) ＋ “&jump=0&key=&backupdomain=1”
http.添加 (“User-Agent”, “Android9-AndroidPhone-11239-18-0-SearchAll-wifi”)
http.添加 (“Host”, “trackermvretry.kugou.com”)
ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (URL, , , , , http.获取协议头数据 ()))
调试输出 (ret)

.子程序 kg_, , , 搜索
.参数 music_name, 文本型
.参数 type, 整数型, 可空, 搜索类型0=综合，1=歌曲，2=MV，默认0
.局部变量 url, 文本型
.局部变量 time, 文本型
.局部变量 signature, 文本型
.局部变量 http, 类_POST数据类
.局部变量 ret, 文本型

time ＝ 时间_取现行时间戳 (真)
.判断开始 (type ＝ 0)
    url ＝ “http://complexsearchretry.kugou.com/v8/search/complex?osversion=9&userid=0&area_code=1&appid=1005&phonemodel=MI%206X&cursor=1&token=&requestid=925ba516f22071755f5394f23820d25e_5&clienttime=” ＋ time ＋ “&iscorrection=1&uuid=d74ecbf808b72947c91d7b134823a705&apiver=20&keyword=” ＋ 编码_URL编码 (music_name, 真, 真) ＋ “&mid=” ＋ 文本_取随机数字 (38) ＋ “&dfid=-&clientver=11239&platform=AndroidFilter&tag=em”
.判断 (type ＝ 1)
    url ＝ “http://complexsearchretry.kugou.com/v2/search/song?userid=0&area_code=1&appid=1005&dopicfull=1&page=1&token=&privilegefilter=0&requestid=925ba516f22071755f5394f23820d25e_1&pagesize=30&clienttime=” ＋ time ＋ “&sec_aggre=1&iscorrection=1&uuid=d74ecbf808b72947c91d7b134823a705&keyword=” ＋ 编码_URL编码 (music_name, 真, 真) ＋ “&mid=” ＋ 文本_取随机数字 (38) ＋ “&dfid=-&clientver=11239&platform=AndroidFilter&tag=em”
.默认
    url ＝ “http://complexsearchretry.kugou.com/v1/search/mv?sorttype=0&userid=0&tagtype=%E5%85%A8%E9%83%A8&appid=1005&dopicfull=1&page=1&token=&requestid=925ba516f22071755f5394f23820d25e_1&pagesize=20&clienttime=” ＋ time ＋ “&iscorrection=1&uuid=d74ecbf808b72947c91d7b134823a705&keyword=” ＋ 编码_URL编码 (music_name, 真, 真) ＋ “&mid=” ＋ 文本_取随机数字 (38) ＋ “&dfid=-&tagaggr=1&clientver=11239&platform=AndroidFilter&tag=em”
.判断结束
signature ＝ kg_signature (url)
url ＝ url ＋ “&signature=” ＋ signature
http.添加 (“User-Agent”, “Android9-AndroidPhone-11239-18-0-SearchAll-wifi”)
http.添加 (“Host”, “complexsearchretry.kugou.com”)
ret ＝ 编码_Utf8到Ansi (网页_访问_对象 (url, , , , , http.获取协议头数据 ()))
调试输出 (ret)
置剪辑板文本 (ret)

.子程序 kg_signature, 文本型
.参数 url, 文本型
.参数 web, 逻辑型, 可空, 默认app
.局部变量 text, 文本型
.局部变量 a, 整数型
.局部变量 arr, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 ret, 文本型
.局部变量 res, 文本型
.局部变量 js, 类_脚本组件

text ＝ 文本_取右边 (url, “?”)
a ＝ 文本_分割文本 (text, “&”, , arr)
.如果真 (a ＝ 0)
    返回 (“0”)
.如果真结束
数组_排序 (arr)
ret ＝ “”
.计次循环首 (a, i)
    ret ＝ ret ＋ arr [i]
.计次循环尾 ()

.判断开始 (web ＝ 假)
    res ＝ 校验_取md5_文本 (“OIlwieks28dk2k092lksi2UIkp” ＋ 编码_URL解码 (ret, 真) ＋ “OIlwieks28dk2k092lksi2UIkp”, 真)
.默认

    调试输出 (js.执行 (#js))
    res ＝ “NVPh5oo715z5DIWAeQlhMDsWXXQV4hwt” ＋ ret ＋ “NVPh5oo715z5DIWAeQlhMDsWXXQV4hwt”
    res ＝ js.运行 (“get_md5”, res)
.判断结束
调试输出 (res)
返回 (res)

结束

Butterfly博客文章统计图详细教程

2022-07-25T22:46:06.000Z

前言

Q: 这么多教程为啥还要写这个呢？
A：主要是因为他有坑（逼死强迫症的那种），安装过程可以转到Eurkon的博客，当然我这里也会写

安装

新建 charts 页面

hexo new page charts

引入 ECharts.js

修改主题下的_config.yml文件，在inject 配置项中引入echart.js文件，注意必须放在第一个。

inject:
  head:
    -  src="https://npm.elemecdn.com/echarts@4.9.0/dist/echarts.min.js">

文章统计代码

在主题下的/scripts/helpers/目录下新建charts.js文件。

const cheerio = require('cheerio')
const moment = require('moment')

hexo.extend.filter.register('after_render:html', function (locals) {
  const $ = cheerio.load(locals)
  const post = $('#posts-chart')
  const tag = $('#tags-chart')
  const category = $('#categories-chart')
  const htmlEncode = false

  if (post.length > 0 || tag.length > 0 || category.length > 0) {
    if (post.length > 0 && $('#postsChart').length === 0) {
      if (post.attr('data-encode') === 'true') htmlEncode = true
      post.after(postsChart(post.attr('data-start')))
    }
    if (tag.length > 0 && $('#tagsChart').length === 0) {
      if (tag.attr('data-encode') === 'true') htmlEncode = true
      tag.after(tagsChart(tag.attr('data-length')))
    }
    if (category.length > 0 && $('#categoriesChart').length === 0) {
      if (category.attr('data-encode') === 'true') htmlEncode = true
      category.after(categoriesChart())
    }

    if (htmlEncode) {
      return $.root().html().replace(/&#/g, '&#')
    } else {
      return $.root().html()
    }
  } else {
    return locals
  }
}, 15)

function postsChart (startMonth) {
  const startDate = moment(startMonth || '2022-04')
  const endDate = moment()

  const monthMap = new Map()
  const dayTime = 3600 * 24 * 1000
  for (let time = startDate; time <= endDate; time += dayTime) {
    const month = moment(time).format('YYYY-MM')
    if (!monthMap.has(month)) {
      monthMap.set(month, 0)
    }
  }
  hexo.locals.get('posts').forEach(function (post) {
    const month = post.date.format('YYYY-MM')
    if (monthMap.has(month)) {
      monthMap.set(month, monthMap.get(month) + 1)
    }
  })
  const monthArr = JSON.stringify([...monthMap.keys()])
  const monthValueArr = JSON.stringify([...monthMap.values()])

  return `
  `
}

function tagsChart (len) {
  const tagArr = []
  hexo.locals.get('tags').map(function (tag) {
    tagArr.push({ name: tag.name, value: tag.length })
  })
  tagArr.sort((a, b) => { return b.value - a.value })

  const dataLength = Math.min(tagArr.length, len) || tagArr.length
  const tagNameArr = []
  const tagCountArr = []
  for (let i = 0; i < dataLength; i++) {
    tagNameArr.push(tagArr[i].name)
    tagCountArr.push(tagArr[i].value)
  }
  const tagNameArrJson = JSON.stringify(tagNameArr)
  const tagCountArrJson = JSON.stringify(tagCountArr)

  return `
  `
}

function categoriesChart () {
  const categoryArr = []
  hexo.locals.get('categories').map(function (category) {
    categoryArr.push({ name: category.name, value: category.length })
  })
  categoryArr.sort((a, b) => { return b.value - a.value });
  const categoryArrJson = JSON.stringify(categoryArr)

  return `
  `
}

使用统计图

在第一次创建charts的页面下的index.md文件中添加以下内容：


<div id="posts-chart" data-start="2021-01" style="border-radius: 8px; height: 300px; padding: 10px;">div>

<div id="tags-chart" data-length="10" style="border-radius: 8px; height: 300px; padding: 10px;">div>

<div id="categories-chart" style="border-radius: 8px; height: 300px; padding: 10px;">div>

解决坑

适配Butterfly主题的明暗模式

这里就不要看他的教程了因为有坑
在主题文件下的/source/目录内新建一个自定义js，名字随意，例如我的是 /source/js/app966.js,内容如下：

function switchPostChart () {
  // 这里为了统一颜色选取的是“明暗模式”下的两种字体颜色，也可以自己定义
  let color = document.documentElement.getAttribute('data-theme') === 'light' ? '#4c4948' : 'rgba(255,255,255,0.7)'
  if (document.getElementById('posts-chart') && postsOption) {
    try {
      let postsOptionNew = postsOption
      postsOptionNew.title.textStyle.color = color
      postsOptionNew.xAxis.nameTextStyle.color = color
      postsOptionNew.yAxis.nameTextStyle.color = color
      postsOptionNew.xAxis.axisLabel.color = color
      postsOptionNew.yAxis.axisLabel.color = color
      postsOptionNew.xAxis.axisLine.lineStyle.color = color
      postsOptionNew.yAxis.axisLine.lineStyle.color = color
      postsOptionNew.series[0].markLine.data[0].label.color = color
      postsChart.setOption(postsOptionNew)
    } catch (error) {
      console.log(error)
    }
  }
  if (document.getElementById('tags-chart') && tagsOption) {
    try {
      let tagsOptionNew = tagsOption
      tagsOptionNew.title.textStyle.color = color
      tagsOptionNew.xAxis.nameTextStyle.color = color
      tagsOptionNew.yAxis.nameTextStyle.color = color
      tagsOptionNew.xAxis.axisLabel.color = color
      tagsOptionNew.yAxis.axisLabel.color = color
      tagsOptionNew.xAxis.axisLine.lineStyle.color = color
      tagsOptionNew.yAxis.axisLine.lineStyle.color = color
      tagsOptionNew.series[0].markLine.data[0].label.color = color
      tagsChart.setOption(tagsOptionNew)
    } catch (error) {
      console.log(error)
    }
  }
  if (document.getElementById('categories-chart') && categoriesOption) {
    try {
      let categoriesOptionNew = categoriesOption
      categoriesOptionNew.title.textStyle.color = color
      categoriesOptionNew.legend.textStyle.color = color
      categoriesOptionNew.series[0].label.color = color
      categoriesChart.setOption(categoriesOptionNew)
    } catch (error) {
      console.log(error)
    }
  }
}

document.getElementById("darkmode").addEventListener("click", function () { setTimeout(switchPostChart, 100) })

引入自定义的js

修改主题下的_config.yml文件，在inject 配置项中引入app966.js文件。
注意事项：如果你在主题的_config.yml文件中打开了pjax务必使用defer data-pjax引入，否则defer即可；
否则会导致每次都要刷新才正常切换。

inject:
  head:
  bottom:
    -  defer data-pjax src="/js/app966.js">

点击平均值跳404的问题

如果你用的我上面的文章统计代码则可跳过此处。
删除文章统计代码第281-282行，添加下面代码覆盖即可。
否则会导致跳转404的问题。

if(event.name != '平均值'){
        let href = '/tags/' + event.name + '/';
        window.location.href = href;
      }

解决标签统计图问题

如果你用的我上面的文章统计代码则可跳过此处。
在js代码中找到标签统计图下面的axisLabel，新增下面内容。
否则会导致标签统计图默认不显示所有标签文字的问题。

        axisLabel: {
          show: true,
          color: color,
+         interval: 0

结尾

hexo clean && hexo g

结果当然肯定是报错拉，因为你没有安装EChart模块，继续运行

npm install echarts --save

至此，所有问题都已完美解决！看看成品效果

onebot2插件源码

2022-07-12T13:47:20.000Z

前言

注意插件的版本号，有新版本我会同步更新

公开一些自己写的插件源码，有需要的复制到你的项目中即可

群管系统

防撤回已经并入群管系统

# -*- coding: utf-8 -*-
"""
@Time    : 2022/7/11 01:13
@Author  : superhero
@Email   : 838210720@qq.com
@File    : group_recall.py
@IDE: PyCharm
"""
import aiofiles
from asyncio import sleep as asleep
from random import randint
from traceback import print_exc
from nonebot.matcher import Matcher
from nonebot import on_notice, on_message, on_request, on_command
import json
import nonebot
from nonebot.adapters.onebot.v11.permission import GROUP_ADMIN, GROUP_OWNER
from nonebot.permission import SUPERUSER
from nonebot.adapters.onebot.exception import ActionFailed
from nonebot.adapters.onebot.v11 import Bot, NoticeEvent, Message, GroupMessageEvent, GroupRequestEvent
from nonebot.adapters import Event
from .config import plugin_config, global_config
from .switch import load, At, MsgText, Reply
import re
import random

bot_name = str(global_config.nickname).split("'")[1] # 获取设置的机器人名字

super = global_config.superusers  # 超管QQ
_path = plugin_config.admin_path
jin_path = plugin_config.jin_path
time_min = plugin_config.ban_rand_time_min
time_max = plugin_config.ban_rand_time_max
group_admin = plugin_config.config_group_admin
answer_list = plugin_config.answer


__help_plugin_name__ = "群管系统"
__help_version__ = '1.4'
__usage__ = '目前支持：\n违禁词检测可自动处罚、加群可以根据答案同意或拒绝、防撤回、禁言、解禁、踢人、拉黑、进群退群提醒、撤回某人n条消息'

f_word = on_message(priority=2, block=False)
@f_word.handle()
async def _(bot: Bot, event: GroupMessageEvent, matcher: Matcher):
    async with aiofiles.open(jin_path, 'r', encoding='utf-8') as f:
        custom_limit_words = await f.read()
        await f.close()
        mid = event.message_id
        gid = event.group_id
        user_id = event.user_id
        funcs_status = (await load(_path))
        if funcs_status.get(str(gid), ''):
            try:
                lf = funcs_status[str(gid)]['违禁词检测']
            except Exception:
                lf = False
                await f_word.finish('还未开启违禁词检测的功能，请输入命令"/开关 违禁词检测"控制开关')
        if lf:
            set_time = random.randint(time_min, time_max)
            time_string = set_timestring(set_time)
            rules = [re.sub(r'\t+', '\t', rule).split('\t') for rule in
                 custom_limit_words.split('\n')]
            msg = re.sub(r'\s', '', str(event.get_message()))
            for rule in rules:
                if rule[0] and re.search(rule[0], msg):
                    matcher.stop_propagation()
                    try:
                        await bot.delete_msg(message_id=mid)
                        await bot.set_group_ban(group_id=gid, user_id=user_id, duration=set_time)
                    except Exception:
                        await f_word.finish(at_sender=True, message=f'你发送了违禁词，待进行禁言{time_string}的处罚，请@管理员处理，将本机器人设为管理员可自动撤回加处罚！')
                    await f_word.finish(at_sender=True, message=f'你发送了违禁词，现在进行禁言{time_string}的处罚，如有异议请联系管理员！')
                    break


group_req = on_request(priority=1)
@group_req.handle()
async def _(bot: Bot, event: GroupRequestEvent):
    raw = json.loads(event.json())
    gid = str(event.group_id)
    flag = raw['flag']
    sub_type = raw['sub_type']
    funcs_status = (await load(_path))
    if funcs_status.get(gid, ''):
        try:
            lf = funcs_status[gid]['加群处理']
        except Exception:
            lf = False
            await group_req.finish('还未开启加群处理的功能，请输入命令"/开关 加群处理"控制开关')
        if lf:
            comment = raw['comment']
            comments = str_right(comment, '答案：') if '答案' in comment else comment
            uid = event.user_id
            if group_admin:
                if len(comments) > plugin_config.answer_int or comments in answer_list:
                    await bot.set_group_add_request(
                        flag=flag,
                        sub_type=sub_type,
                        approve=True,
                        reason=""
                    )
                    await bot.send_msg(group_id=int(gid), message=f'已同意{uid}加入本群，验证消息为“{comment}”')
                else:
                    await bot.set_group_add_request(
                        flag=flag,
                        sub_type=sub_type,
                        approve=False,
                        reason="因回答不符合本群要求自动拒绝！"
                    )
                    await bot.send_msg(group_id=int(gid), message=f'因回答不符本群要求，已拒绝{uid}加入本群，验证消息为“{comment}”')
            else:
                await bot.set_group_add_request(
                    flag=flag,
                    sub_type=sub_type,
                    approve=False,
                    reason="自动拒绝，如有异议请联系管理重新申请！"
                )
                await bot.send_msg(group_id=int(gid), message=f'已拒绝{uid}加入本群，验证消息为“{comment}”')


async def _group_recall(event: NoticeEvent) -> bool:
    if event.notice_type == 'group_recall':
        return True
    return False


group_recall = on_notice(_group_recall, priority=5)
@group_recall.handle()
async def _(bot: Bot, event: NoticeEvent):
    event_obj = json.loads(event.json())
    user_id = event_obj["user_id"]  # 消息发送者
    operator_id = event_obj["operator_id"]  # 撤回消息的人
    group_id = event_obj["group_id"]  # 群号
    message_id = event_obj["message_id"]  # 消息 id
    # print(user_id, message_id, group_id, operator_id)
    # print(event_obj)
    funcs_status = (await load(_path))
    if funcs_status.get(str(group_id), ''):
        try:
            lf = funcs_status[str(group_id)]['防撤回']
        except Exception:
            lf = False
            await group_recall.finish('还未开启防撤回的功能，请输入命令"/开关 防撤回"控制开关')
        if lf:
            if int(user_id) != int(operator_id): return  # 撤回人不是发消息人，是管理员撤回成员消息，不处理
            if int(operator_id) in super or str(operator_id) in super: return  # 发起撤回的人是超管，不处理
            # 管理员撤回自己的不处理
            operator_info = await bot.get_group_member_info(group_id=group_id, user_id=operator_id, no_cache=True)
            # print(operator_info)
            if operator_info["role"] != "member": return
            # 防撤回
            recalled_message = await bot.get_msg(message_id=message_id)
            recall_notice = f"检测到{operator_info['card'] if operator_info['card'] else operator_info['nickname']}({operator_info['user_id']})撤回了一条消息：\n\n"
            await bot.send_group_msg(group_id=group_id, message=recall_notice + recalled_message['message'])
            await group_recall.finish()


welcom = on_notice(priority=5)
@welcom.handle()
async def _(event: Event):
    description = event.get_event_description()
    values = json.loads(description.replace("'", '"'))
    user_id = values['user_id']
    group_id = values["group_id"]
    at_ = "[CQ:at,qq={0}]".format(user_id)

    funcs_status = (await load(_path))
    if funcs_status.get(str(group_id), ''):
        try:
            lf = funcs_status[str(group_id)]['进退提示']
        except Exception:
            lf = False
            await welcom.finish('还未开启进退提示的功能，请输入命令"/开关 进退提示"控制开关')
        if lf:
            if values['notice_type'] == 'group_increase':
                try:
                    lfc = funcs_status[str(group_id)]['违禁词检测']
                except Exception:
                    lfc = False
                we = ''
                if lfc:
                    we = '\n温馨提示：本群已开启违禁词检测，请注意你的言行！'
                msg = at_ + f'欢迎入群，我是最可爱的{bot_name}机器人，有事记得叫我哦!\n输入“/help list”可查看我支持的功能，输入“/开关状态”可查看被动插件开启状态{we}'
                msg = Message(msg)
                await welcom.send(Message(msg))
            elif values['notice_type'] == 'group_decrease':
                if values['sub_type'] == 'leave':
                    msg = at_ + '这位勇士离开了本群，大家快出来送别他吧！'
                    msg = Message(msg)
                    await welcom.send(msg)
                elif values['sub_type'] == 'kick':
                    operator_id = values['operator_id']
                    su = "[CQ:at,qq={0}]".format(operator_id)
                    msg = at_ + '这位勇士被' + su + '踢出了本群，大家快出来瞅瞅！'
                    msg = Message(msg)
                    await welcom.send(msg)
            elif values['notice_type'] == 'notify':
                if values['sub_type'] == 'poke':
                    if values['target_id'] == plugin_config.bot_id:
                        await welcom.send(f"请尽情吩咐{bot_name}吧，主人！")
                try:
                    if values['honor_type'] == 'talkative':
                        msg = '本群新晋龙王是' + at_
                        await welcom.send(Message(msg))
                    elif values['honor_type'] == 'performer':
                        msg = '本群新晋群聊之火是' + at_
                        await welcom.send(Message(msg))
                    elif values['honor_type'] == 'emotion':
                        msg = '本群新晋快乐源泉是' + at_
                        await welcom.send(Message(msg))
                except KeyError as e:
                    pass



async def banSb(gid: int, ban_list: list, time: int = None, scope: list = None):
    """
    构造禁言
    :param gid: 群号
    :param time: 时间（s)
    :param ban_list: at列表
    :param scope: 用于被动检测禁言的时间范围
    :return:禁言操作
    """
    time_string = ''
    # if 'all' in ban_list:
    #     yield nonebot.get_bot().set_group_whole_ban(
    #         group_id=gid,
    #         enable=True
    #     )
    # else:
    if time is None:
        if scope is None:
            time = random.randint(time_min, time_max)
        else:
            time = random.randint(scope[0], scope[1])
        time_string = set_timestring(time)
    for qq in ban_list:
        if int(qq) in super or str(qq) in super:
            await nonebot.get_bot().send_group_msg(group_id=gid, message="超管无法被禁言")
        else:
            if time > 0:
                await nonebot.get_bot().send_group_msg(group_id=gid, message=f"该用户已被禁言{time_string}")
            yield nonebot.get_bot().set_group_ban(
                group_id=gid,
                user_id=qq,
                duration=time,
            )


kick = on_command('踢', permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER, priority=1, block=True)
@kick.handle()
async def _(bot: Bot, event: GroupMessageEvent):
    """
    /踢 @user 踢出某人
    """
    msg = str(event.get_message())
    sb = At(event.json())
    gid = event.group_id
    if sb:
        if 'all' not in sb:
            try:
                for qq in sb:
                    await bot.set_group_kick(
                        group_id=gid,
                        user_id=int(qq),
                        reject_add_request=False
                    )
            except ActionFailed:
                await kick.finish("权限不足")
            else:
                await kick.finish(f"踢人操作成功")
        else:
            await kick.finish("不能含有@全体成员")


kick_ = on_command('黑', permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER, priority=1, block=True)
@kick_.handle()
async def _(bot: Bot, event: GroupMessageEvent):
    """
    黑 @user 踢出并拉黑某人
    """
    msg = str(event.get_message())
    sb = At(event.json())
    gid = event.group_id
    if sb:
        if 'all' not in sb:
            try:
                for qq in sb:
                    await bot.set_group_kick(
                        group_id=gid,
                        user_id=int(qq),
                        reject_add_request=True
                    )
            except ActionFailed:
                await kick_.finish("权限不足")
            else:
                await kick_.finish(f"踢人并拉黑操作成功")
        else:
            await kick_.finish("不能含有@全体成员")


ban = on_command('禁', priority=1, block=True, permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER)
@ban.handle()
async def _(bot: Bot, event: GroupMessageEvent):
    """
    /禁 @user 禁言
    """
    try:
        msg = MsgText(event.json()).replace(" ", "").replace("禁", "")
        time = int("".join(map(str, list(map(lambda x: int(x), filter(lambda x: x.isdigit(), msg))))))
        # 提取消息中所有数字作为禁言时间
    except ValueError:
        time = None
    sb = At(event.json())
    gid = event.group_id
    if sb:
        baning = banSb(gid, ban_list=sb, time=time)
        try:
            async for baned in baning:
                if baned:
                    await baned
        except ActionFailed:
            await ban.finish("权限不足")
        else:
            pass
            # if time is not None:
            #     await ban.finish("禁言操作成功")
            # else:
            #     await ban.finish("该用户已被禁言随机时长")
    else:
        pass


unban = on_command("解", priority=1, block=True, permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER)
@unban.handle()
async def _(bot: Bot, event: GroupMessageEvent):
    """
    /解 @user 解禁
    """
    sb = At(event.json())
    gid = event.group_id
    if sb:
        baning = banSb(gid, ban_list=sb, time=0)
        try:
            async for baned in baning:
                if baned:
                    await baned
        except ActionFailed:
            await unban.finish("权限不足")
        else:
            await unban.finish("解禁操作成功")

msg_recall = on_command("撤回", priority=1, aliases={"删除", "recall"}, block=True,
                        permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER)
@msg_recall.handle()
async def _(bot: Bot, event: GroupMessageEvent):
    """
    指令格式:
    /撤回 @user n
    回复指定消息时撤回该条消息；使用艾特时撤回被艾特的人在本群 n*19 历史消息内的所有消息。
    不输入 n 则默认 n=5
    """
    # msg = str(event.get_message())
    msg = MsgText(event.json())
    sb = At(event.json())
    rp = Reply(event.json())
    gid = event.group_id
    if not gid:  # FIXME: 有必要加吗？
        await msg_recall.finish("请在群内使用！")
    recall_msg_id = []
    if rp:
        recall_msg_id.append(rp["message_id"])
    elif sb:
        seq = None
        if len(msg.split(" ")) > 1:
            try:  # counts = n
                counts = int(msg.split(" ")[-1])
            except ValueError:
                counts = 5  # 出现错误就默认为 5 【理论上除非是 /撤回 @user n 且 n 不是数值时才有可能触发】
        else:
            counts = 5

        try:
            for i in range(counts):  # 获取 n 次
                await asleep(randint(0, 10))  # 睡眠随机时间，避免黑号
                res = await bot.call_api("get_group_msg_history", group_id=gid, message_seq=seq)  # 获取历史消息
                flag = True
                for message in res["messages"]:  # 历史消息列表
                    if flag:
                        seq = int(message["message_seq"]) - 1
                        flag = False
                    if int(message["user_id"]) in sb:  # 将消息id加入列表
                        recall_msg_id.append(int(message["message_id"]))
        except ActionFailed as e:
            await msg_recall.send(f"获取群历史消息时发生错误")
            print_exc()
    else:
        await msg_recall.finish("指令格式：\n/撤回 @user 撤回数量\n回复指定消息时撤回该条消息；使用@时撤回被@的人在本群 撤回数量*19 历史消息内的所有消息。\n不输入撤回数量则默认5")

    # 实际进行撤回的部分
    try:
        for msg_id in recall_msg_id:
            await asleep(randint(0, 3))  # 睡眠随机时间，避免黑号
            await bot.call_api("delete_msg", message_id=msg_id)
    except ActionFailed as e:
        await msg_recall.finish("执行失败，可能是我权限不足")
    else:
        await msg_recall.finish(f"操作成功，一共撤回了 {len(recall_msg_id)} 条消息")

def str_left(t, s):
    if isinstance(t, str) != True or isinstance(s, str) != True:
        return '传入参数有误'
    elif t.find(s) != -1:
        return t[0:t.find(s)]
    else:
        return ""

def str_right(t, s):
    if isinstance(t, str) != True or isinstance(s, str) != True:
        return '传入参数有误'
    elif t.rfind(s) != -1:
        return t[t.rfind(s) + len(s):len(t)]
    else:
        return ""

def set_timestring(set_time):
    """
    把秒转换成某天某时某分某秒
    :param set_time:
    :return:
    """
    time_string = ''
    day = set_time / 86400
    hours = set_time % 86400 / 3600
    minutes = set_time % 86400 % 3600 / 60
    seconds = set_time % 86400 % 3600 % 60
    if day >= 1:
        time_string += str(int(day)) + '天'
    if hours >= 1:
        time_string += str(int(hours)) + '时'
    if minutes >= 1:
        time_string += str(int(minutes)) + '分'
    if seconds >= 1:
        time_string += str(int(seconds)) + '秒'
    return time_string

网易云音乐插件

支持点歌

支持下载

支持随机推荐

支持根据作者歌单随机推荐

# -*- coding: utf-8 -*-
"""
@Time    : 2022/7/11 01:42
@Author  : superhero
@Email   : 838210720@qq.com
@File    : wyy.py
@IDE: PyCharm
"""
from nonebot import on_command
import nonebot
import execjs
import base64
import requests
import codecs
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from nonebot.adapters.onebot.v11 import Message
from nonebot.params import Arg, CommandArg, ArgPlainText
from lxml import etree
from nonebot.matcher import Matcher
import random

__plugin_meta__ = nonebot.plugin.PluginMetadata(
    name='网易云音乐',
    description='网易云音乐搜索下载',
    usage='''
    命令1/wyy/网易云音乐/点歌<参数：歌曲名,序号>不含下载
    命令2/wyys/网易云音乐s/下载<参数：歌曲名,序号>含下载
    命令3/pushy/歌曲推荐/推荐<参数：无>随机推荐
    命令4/pushys/歌曲推荐s/推荐s<参数：无>根据作者的歌单推荐
    ''',
    extra={'version': '1.3'}
)
__help_version__ = '1.3'


wyys = on_command("wyys", aliases={"网易云音乐s", "下载"}, priority=5)
# 点歌 不下载只能试听
@wyys.handle()
async def handle_first_receive(matcher: Matcher, args: nonebot.adapters.Message = CommandArg()):
    list_name = args.extract_plain_text().strip()
    if list_name:
        matcher.set_arg("music_name", args)

@wyys.got("music_name", prompt="你想下载的歌曲是？")
async def _(matcher: Matcher, music_name: nonebot.adapters.Message = Arg(), text: str = ArgPlainText("music_name")):
    if not text:
        await wyys.reject(music_name.template("待下载的歌曲名不能为空"))
    if "," in text:
        stt = text.split(",")
        name = stt[0]
        ids = stt[1]
        matcher.set_arg("id", Message(ids))
        matcher.set_arg("music_name", Message(name))
    elif "，" in text:
        stt = text.split("，")
        name = stt[0]
        ids = stt[1]
        matcher.set_arg("id", Message(ids))
        matcher.set_arg("music_name", Message(name))
    else:
        ids = '0'
        name = text

    wyy2 = WangYiYun()
    ret = wyy2.get_wyy_kwd(name)
    n = 0
    music_names = ''
    if ids != '0':
        music_id = ret['result']['songs'][(int(ids) - 1)]['id']
        if music_id:
            url = wyy2.get_wyy_playurl(music_id)
            await wyys.finish("[{0}]下载地址：".format(ret['result']['songs'][(int(ids) - 1)]['name']) + url)
        else:
            await wyys.finish("音乐ID获取失败")
    else:
        for i in ret['result']['songs']:
            n += 1
            music_names += '[{0}]'.format(n) + i['name'] + ' - ' + i['ar'][(int(ids) - 1)]['name'] + '\n'
            if n >= 10:
                break
        await wyys.send(music_names)

@wyys.got("id", prompt="请选择要下载第几个？")
async def _(music_name: nonebot.adapters.Message = Arg(), text: str = ArgPlainText("music_name"), ids: str = ArgPlainText("id")):
    if not ids:
        await wyys.reject(music_name.template("你还没有选择第几个哦"))
    wyy2 = WangYiYun()
    ret = wyy2.get_wyy_kwd(text)
    music_id = ret['result']['songs'][(int(ids) - 1)]['id']
    if music_id:
        url = wyy2.get_wyy_playurl(music_id)
        await wyys.finish("[{0}]下载地址：".format(ret['result']['songs'][(int(ids) - 1)]['name']) + url)
    else:
        await wyys.finish("音乐ID获取失败")




wyy = on_command("wyy", aliases={"网易云音乐", "点歌"}, priority=5)
# 点歌 不下载只能试听
@wyy.handle()
async def handle_first_receive(matcher: Matcher, args: nonebot.adapters.Message = CommandArg()):
    list_name = args.extract_plain_text().strip()
    if list_name:
        matcher.set_arg("music_name", args)

@wyy.got("music_name", prompt="你想搜索的歌曲是？")
async def _(matcher: Matcher, music_name: nonebot.adapters.Message = Arg(), text: str = ArgPlainText("music_name")):
    if not text:
        await wyy.reject(music_name.template("待搜索的歌曲名不能为空"))
    if "," in text:
        stt = text.split(",")
        name = stt[0]
        ids = stt[1]
        matcher.set_arg("id", Message(ids))
        matcher.set_arg("music_name", Message(name))
    elif "，" in text:
        stt = text.split("，")
        name = stt[0]
        ids = stt[1]
        matcher.set_arg("id", Message(ids))
        matcher.set_arg("music_name", Message(name))
    else:
        ids = '0'
        name = text

    wyy2 = WangYiYun()
    ret = wyy2.get_wyy_kwd(name)
    n = 0
    music_names = ''
    if ids != '0':
        music_id = ret['result']['songs'][(int(ids) - 1)]['id']
        msg = "[CQ:music,type=163,id={0}]".format(str(music_id))
        await wyy.finish(Message(msg))
    else:
        for i in ret['result']['songs']:
            n += 1
            music_names += '[{0}]'.format(n) + i['name'] + ' - ' + i['ar'][(int(ids) - 1)]['name'] + '\n'
            if n >= 10:
                break
        await wyy.send(music_names)

@wyy.got("id", prompt="请选择要播放第几个？")
async def _(music_name: nonebot.adapters.Message = Arg(), text: str = ArgPlainText("music_name"), ids: str = ArgPlainText("id")):
    if not ids:
        await wyy.reject(music_name.template("你还没有选择第几个哦"))
    # 这个肯定是没有获取到ids才执行的 所有需要把代码放在if里面 如果是用的finish也可以不放 用send肯定要放
    wyy2 = WangYiYun()
    ret = wyy2.get_wyy_kwd(text)
    music_id = ret['result']['songs'][(int(ids) - 1)]['id']
    msg = "[CQ:music,type=163,id={0}]".format(str(music_id))
    await wyy.finish(Message(msg))


song = on_command("pushy", aliases={"推荐", "歌曲推荐"}, priority=5)
@song.handle()
# 随机推荐
async def _():
    wyys = WangYiYun()
    listplay_id = wyys.get_wyy_pushy()
    msg = "[CQ:music,type=163,id={0}]".format(wyys.get_wyy_discover(listplay_id))
    await song.send(Message(msg))

songs = on_command("pushys", aliases={"推荐s", "歌曲推荐s"}, priority=5)
@songs.handle()
# 从作者的歌单中随机推荐
async def _():
    wyys = WangYiYun()
    listplay_id = ['/playlist?id=7480897649']
    msg = "[CQ:music,type=163,id={0}]".format(wyys.get_wyy_discover(listplay_id))
    await songs.send(Message(msg))

def to_16(key):
    while len(key) % 16 != 0:
        key += '\0'
    return str.encode(key)


def AES_encrypt(text, key, iv):
    bs = AES.block_size
    pad2 = lambda s: s + (bs - len(s) % bs) * chr(bs - len(s) % bs)
    encryptor = AES.new(to_16(key), AES.MODE_CBC, to_16(iv))

    pd2 = pad(str.encode(pad2(text)), 16)

    encrypt_aes = encryptor.encrypt(pd2)
    encrypt_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8')
    return encrypt_text


def RSA_encrypt(text, pubKey, modulus):
    text = text[::-1]
    rs = int(codecs.encode(text.encode('utf-8'), 'hex_codec'), 16) ** int(pubKey, 16) % int(modulus, 16)
    return format(rs, 'x').zfill(256)





# 获取i值的函数，即随机生成长度为16的字符串
get_i = execjs.compile(r"""
    function a(a) {
        var d, e, b = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", c = "";
        for (d = 0; a > d; d += 1)
            e = Math.random() * b.length,
            e = Math.floor(e),
            c += b.charAt(e);
        return c
    }
""")


class WangYiYun():
    def __init__(self):
        self.csrf_token = '' # 抓包填写自己的
        self.MUSIC_U = '' # 抓包填写自己的
        self.g = '0CoJUm6Qyw8W8jud'
        self.b = "010001"
        self.c = '00e0b509f6259df8642dbc35662901477df22677ec152b5ff68ace615bb7b725152b3ab17a876aea8a5aa76d2e417629ec4ee341f56135fccf695280104e0312ecbda92557c93870114af6c9d05c4f7f0c3685b7a46bee255932575cce10b424d813cfe4875d3e82047b97ddef52741d546b8e289dc6935b3ece0462db0a22b8e7'
        self.i = get_i.call('a', 16)
        self.iv = "0102030405060708"
        # if not os.path.exists("d:/music"):
        #     os.mkdir('d:/music')
        self.ua = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.152 Safari/537.36'

    def get_encSecKey(self):
        return RSA_encrypt(self.i, self.b, self.c)

    def get_wyy_pushy(self):
        # 取随机列表
        url = 'https://music.163.com/discover'
        ret = requests.get(url, headers={"User-Agent": self.ua}).text
        soup = etree.HTML(ret)
        hot_id = soup.xpath('//ul[@class="m-cvrlst f-cb"]//li/div[@class="u-cover u-cover-1"]/a/@href')
        n = len(hot_id)
        bek = []
        # 去除电台dj
        for i in range(n):
            if "/dj" in hot_id[i]:
                bek.append(i)
        hot_id = [hot_id[i] for i in range(n) if (i not in bek)]
        return hot_id

    def get_wyy_discover(self, list_id):
        """
        从列表中随机取一首
        :param list_id: 列表id
        :return:
        """
        playlist_id = list_id[random.randint(0, len(list_id) - 1)]
        # 这里要添加自己的cookie 否则只能随机前10条
        cookie = ''
        ret = requests.get("https://music.163.com" + playlist_id, headers={"User-Agent": self.ua, "Cookie": cookie}).text
        soup = etree.HTML(ret)
        m_id = soup.xpath('//ul[@class="f-hide"]/li/a/@href')
        song_id = m_id[random.randint(0, len(m_id) - 1)][9:]
        return song_id



    def get_wyy_kwd(self, keyword):

        url = 'https://music.163.com/weapi/cloudsearch/get/web?csrf_token=' + self.csrf_token
        encText = str(
            {'hlpretag': '', 'hlposttag': '', '#/discover': '', 's': keyword, 'type': '1',
             'offset': "0", 'total': 'true', 'limit': '30', 'csrf_token': self.csrf_token})
        params = AES_encrypt(AES_encrypt(encText, self.g, self.iv), self.i, self.iv)
        data = {
            'params': params,
            'encSecKey': self.get_encSecKey()
        }

        header = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Host': 'music.163.com',
            'Referer': 'https://music.163.com/search/',
            'User-Agent': self.ua
        }
        ret = requests.post(url, headers=header, data=data)
        # print('搜索结果', ret.text)
        return ret.json()

    def get_wyy_playurl(self, music_id):

        url = 'https://music.163.com/weapi/song/enhance/player/url?csrf_token=' + self.csrf_token
        encText = str({'ids': "[" + str(music_id) + "]", 'br': 128000, 'csrf_token': self.csrf_token,
                       'MUSIC_U': self.MUSIC_U})
        params = AES_encrypt(AES_encrypt(encText, self.g, self.iv), self.i, self.iv)
        data = {
            'params': params,
            'encSecKey': self.get_encSecKey()
        }
        headeer = {
            'User-Agent': self.ua,
            'Referer': 'https://music.163.com/',
            'Content-Type': 'application/x-www-form-urlencoded'
        }

        ret = requests.post(url, headers=headeer, data=data).json()
        download_url = ret['data'][0]['url']
        if download_url:
            try:
                msg = download_url
                # 根据音乐url地址，用urllib.request.retrieve直接将远程数据下载到本地
                # urllib.request.urlretrieve(download_url, 'd:/music/' + music_name+ '.mp3')
                # print('Successfully Download:'+music_name+ '.mp3')
            except:
                msg = '出错了~'
        else:
            msg = '获取失败'
        return msg

微博热搜插件

import requests
from lxml import etree
from nonebot import on_command
import nonebot
from nonebot.adapters import Message
from nonebot.params import CommandArg
__plugin_meta__ = nonebot.plugin.PluginMetadata(
    name='微博热搜',
    description='获取微博热搜',
    usage='''命令/wbhot<参数：数量 默认10>''',
    extra={'version': '1.0'}
)
__help_version__ = '1.0'

weibohot = on_command("wbhot", aliases={"微博", "热搜"}, priority=5)
@weibohot.handle()
async def handle_first_receive(args: Message = CommandArg()):
    num = args.extract_plain_text()
    if not num:
        num = '10'
    url = 'https://passport.weibo.com/visitor/visitor?a=incarnate&t=LomBgTEURrl3AoXFT346PaH7q%2FNDphe9Xzpc1S3RCJ4%3D&w=2&c=095&gc=&cb=cross_domain&from=weibo&_rand=0.00811768666053514'
    headers = {
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36',
    }
    response = requests.get(url=url, headers=headers)
    cookie = requests.utils.dict_from_cookiejar(response.cookies)
    url = 'https://s.weibo.com/top/summary?cate=realtimehot'
    response = requests.get(url=url, headers=headers, cookies=cookie).text
    soup = etree.HTML(response)
    hot_name = soup.xpath('//div[@class="data"]//tr/td[@class="td-02"]/a/text()')
    hot_int = soup.xpath('//div[@class="data"]//tr/td[@class="td-02"]/span/text()')
    hot_url = soup.xpath('//div[@class="data"]//tr/td[@class="td-02"]/a/@href')
    n = 0
    txt = ''
    hot = '，热度：'
    for i in hot_name:
        hot_ints = hot_int[n - 1] if n > 0 else ''
        if int(num) > 15:
            txt = "{0}" + i + "{1}" + hot_ints + '\n 详情：https://s.weibo.com' + hot_url[n]
            txt = txt.format('【置顶】' if hot_ints == '' else str(n) + '.', '' if hot_ints == '' else hot)
            await weibohot.send(txt)
        else:
            txt += "{0}" + i + "{1}" + hot_ints + '\n 详情：https://s.weibo.com' + hot_url[n] + '\n'
            txt = txt.format('【置顶】' if hot_ints == '' else str(n) + '.', '' if hot_ints == '' else hot)
        n += 1
        if n >= (int(num) + 1):
            if int(num) <= 15:
                await weibohot.send(txt)
            break

抖音相关插件

v1.5修复获取失败的问题

# -*- coding: utf-8 -*-
"""
@Time    : 2022/7/13 6:01
@Author  : superhero
@Email   : 838210720@qq.com
@File    : douyin_video.py
@IDE: PyCharm
"""
import time

import hashlib
import json
import nonebot
import random
import re
import requests
import urllib.parse
from nonebot import on_command
from nonebot.adapters.onebot.v11 import GroupMessageEvent
from nonebot.params import CommandArg
from nonebot.typing import T_State
from .config import plugin_config
from .switch import load, upload

_path = plugin_config.douyin_path
__help_plugin_name__ = "抖音相关插件"
__help_version__ = '1.5'

__usage__ = '命令1/douyin/抖音/抖音解析<参数：视频ID列表>\n命令2/dyadd/抖音添加/dyset<参数：29位作者短链>\n命令3/dyget/记录美好生活/我要学习/我爱学习<参数：无>从添加的作者里面随机，绝不与上一次的内容重复'
header = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.87 Safari/537.36'}

douyin = on_command("douyin", aliases={"抖音", "抖音解析"}, priority=5)


@douyin.handle()
async def _(args: nonebot.adapters.Message = CommandArg()):
    video_list = args.extract_plain_text()
    # try:
    #     if len(url) <= 29:
    #         ret = requests.get(url, allow_redirects=False, headers=header)
    #         location = ret.headers['Location']
    #         vid = re.search(r'7\d{18}', location).group()
    #     else:
    #         vid = re.search(r'7\d{18}', url).group()
    # except Exception:
    #     vid = ''
    if video_list.find('[') == -1:
        await douyin.finish("格式有误，请以整数型数组方式输入视频id")
    ret = get_video_info(video_list)
    i = 0
    for data_list in ret['aweme_details']:
        i += 1
        if data_list['aweme_type'] == 2:
            aweme_type = '图集'
            dow_url = ''
            duration = ''
            for i in data_list['images']:
                dow_url += i['url_list'][0] + '\n'
        else:
            aweme_type = '视频'
            vid = data_list['video']['play_addr_h264']['uri']
            duration = '\n视频时长：' + str(round(data_list['duration'] / 1000, 1)) + '秒'
            url = 'https://api-play-hl.amemv.com/aweme/v1/play/?video_id=%s&line=0&is_play_url=1&source' \
                  '=PackSourceEnum_AWEME_DETAIL' % vid
            try:
                dow_url = get_shorten(url)
            except Exception:
                dow_url = url

        desc = data_list['desc']
        author = data_list['author']['nickname']
        sex = "男" if data_list['author']['gender'] == 1 else "女" if data_list['author']['gender'] == 2 else "未知"
        music = data_list['music']['play_url']['uri']
        await douyin.send('%s.播主：%s  性别：%s\n作品类型：%s\n标题：%s%s\n音频地址：%s\n下载地址：%s' % (
            i, author, sex, aweme_type, desc, duration, music, dow_url))
    # await douyin.finish(MessageSegment.video(file=ret, timeout=5))


dyadd = on_command("dyget", aliases={"记录美好生活", "我要学习", "我爱学习"}, priority=5)


@dyadd.handle()
async def _(event: GroupMessageEvent):
    gid = str(event.group_id)
    funcs_status = (await load(_path))
    if funcs_status == None:
        await dyadd.finish("本群当前无数据，请先添加作者链接")

    url_list = funcs_status.get(gid, None)
    if url_list:
        # num = funcs_status.get('num', None) # 播主的索引
        # 保证下次随机的播主绝不和上次的一样 这里 -2 就行了 因为每次更新字典都会跑到最后我们躲避最后一个就不可能会取到她拉
        # 当然这个作者数少于2肯定会有异常的 我们做个异常处理
        # num = len(url_list)
        # try:
        #     num1 = random.randint(0, num - 2)
        # except Exception:
        #     num1 = 0
        # while num:
        #     if num != num1:
        #         break
        #     else:
        #         num1 = random.randint(0, len(url_list) - 1)

        # 其实直接不做随机 这样等于排队一样 第一个结束后在最后 第二个变成第一个以此类推 所以我们一直取第1个就好了
        headers = {
            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)'
                          'Chrome/111.0.0.0 Safari/537.36'
        }
        num1 = 0

        url = url_list[num1]['url']
        num2 = url_list[num1].get('id', None)  # 播主作品的索引
        ret = requests.get(url, allow_redirects=False, headers=headers)
        sec_uid = ret.headers['Location']
        ts = str(time.time()).split('.')[0]
        header = {
            'cid': 'd9ba8ae07d955b83c3b04280f3dc5a4a',
            'timestamp': ts,
            'user-agent': 'okhttp/3.10.0.12'
        }
        res = requests.post("http://api2.52jan.com/dyapi/get_cookie/v2", data={"sign": set_sign()},
                            headers=header).json()

        headers['cookie'] = res['data'][0][0]

        ret = requests.get(sec_uid, headers=headers).text
        data = re.search(
            r'")
        # print(cookie, challenge_token)
        # url = 'https://www.4kbizhi.com/yjs-cgi/security/js_challenge/verify?token=' + challenge_token
        # data = {}
        # ret = requests.post(url, data=data, headers=header)
        # cookie = requests.utils.dict_from_cookiejar(ret.cookies)
        # print(ret.text)

    def get_jkrs(self):
        """
        默认获取全部
        获取其它类型请更改page
        :return:
        """
        url = 'https://jk.rs/'
        start = time.time()
        for n in range(self.page):
            page = 'page/%s/' % str(n + 1) if n > 0 else ''
            ret = requests.get(url + page, headers=self.header).text
            soup = BeautifulSoup(ret, 'lxml')
            tag = soup.find_all('a', class_='item-link')
            # print(tag)
            for i in tag:
                img_key = re.sub(r"\s", "", str(i))
                # print(img_key)
                img_url = self.get_str_btw(img_key, '"href="', '">')
                img_name = self.get_str_btw(img_key, '"item-link-text">', '')
                ret = requests.get(img_url, headers=self.header).text
                soup = BeautifulSoup(ret, 'lxml')
                tag2 = soup.find_all('img', class_='post-item-img lazy')
                j = 0
                for i1 in tag2:
                    j += 1
                    img_key2 = re.sub(r"\s", "", str(i1))
                    img_name2 = self.get_str_btw(img_key2, 'title="', '"/>')
                    img_url2 = self.get_str_btw(img_key2, 'data-original="', '"src="')
                    print('\n' + '正在获取[%s]图集内的内容' % (img_name + str(j)))
                    if self.download:
                        div = self.div + "\\" + img_name
                        if not os.path.exists(div):
                            os.mkdir(div)
                        img_path = os.path.join(div, img_name2 + '.jpg')
                        self.downloader(img_url2, img_path, img_name2)
                if self.download:
                    end = time.time()
                    print('\n' + img_name + "下载完成！共用时%s秒" % round(end - start, 1))
                    # 这个图片源没有必要去区分手机和电脑
                    # self.update_name(div)


    def get_str_btw(self, s, f, b):
        par = s.partition(f)
        return (par[2].partition(b))[0][:]

if __name__ == '__main__':
    wall = wallpaper(download=True, page=5)
    # 下载jk
    wall.get_jkrs()
    # 下载4k
    # wall.get_4kbz()

成功示例

查看图集

java版抖音视频解析

2022-06-30T18:22:57.000Z

使用idea导入相关依赖

从maven导入模块

在idea中按F4进入模块设置或选中项目单击右键，可以看到进入模块设置
点击添加，选择来自maven，然后搜索想要的模块添加上就行
最好把自动引入模块的设置打开，如下图

进入模块设置

搜索想要的模块

自动导入设置

也可以自己下载jar包放在lib目录下，并在pom.xml下添加如下代码，如下图

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.76version>
dependency>

导入fastjson

java代码

新的方法

package text;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class dy_ana {
    public static String get_play(String video_id){
        /*
        获取无水印地址，新方法
        * */

        if (video_id == null){
            System.out.println("请手动输入字符视频id");
            Scanner sc = new Scanner(System.in);
            video_id = sc.nextLine();
            System.out.println(video_id);
        }

        /* String url = "https://www.douyin.com/aweme/v1/play/?video_id=%s&line=0&is_play_url=1&source=PackSourceEnum_PUBLISH";
        url = String.format(url, video_id);
        * */
        String t = String.valueOf(System.currentTimeMillis());
        String url = "https://api3-normal-c-hl.amemv.com/aweme/v1/multi/aweme/detail/?os_api=22&device_type=MI+9&ssmix=a&manifest_version_code=120701&dpi=240&uuid=%s&app_name=aweme&version_name=12.7.0&ts=%s&cpu_support64=false&storage_type=0&app_type=normal&appTheme=dark&ac=wifi&host_abi=armeabi-v7a&update_version_code=12709900&channel=tengxun_new&_rticket=%s&device_platform=android&iid=%s&version_code=120700&mac_address=%s&cdid=%s&openudid=%s&device_id=%s&resolution=720*1280&os_version=5.1.1&language=zh&device_brand=Android&aid=1128&mcc_mnc=46007";
        url = String.format(url, "262745062603948", t.substring(0,10), t, "3479331501001230", "10:2a:b3:7e:e5:2e", "a8f935d1-6b88-458a-8d15-1561ed4256b6", "af455a5a9cd3e9b4", "242369266188781");
        String params = "aweme_ids=[%s]&origin_type=goods_rank_list_0&push_params=&request_source=0";
        params = String.format(params, video_id);
        String ret = PostUrl(url, params);
        JSONObject obj = JSONObject.parseObject(ret);
        List Array = obj.getJSONArray("aweme_details");
        JSONArray jsonArray = new JSONArray(Array);
        JSONObject obj1 = jsonArray.getJSONObject(0);
        JSONObject obj2 = obj1.getJSONObject("video");
        JSONObject obj3 =  obj2.getJSONObject("play_addr");
        List Array1 = obj3.getJSONArray("url_list");
        JSONArray jsonArray1 = new JSONArray(Array1);
        return jsonArray1.getString(0);
    }



    public static String PostUrl(String httpUrl, String param) {

        HttpURLConnection connection = null;
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        String result = null;
        try {
            URL url = new URL(httpUrl);
            // 通过远程url连接对象打开连接
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
            connection.setDoOutput(true);
            // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
            connection.setDoInput(true);
            // 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // 通过连接对象获取一个输出流
            os = connection.getOutputStream();
            // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
            os.write(param.getBytes());
            // 通过连接对象获取一个输入流，向远程读取
            if (connection.getResponseCode() == 200) {

                is = connection.getInputStream();
                // 对输入流对象进行包装:charset根据工作项目组的要求来设置
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

                StringBuilder sbf = new StringBuilder();
                String temp = null;
                // 循环遍历一行一行读取数据
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 断开与远程地址url的连接

            assert connection != null;
            connection.disconnect();
        }
        return result;
    }



    public static String GetUrl(String url, boolean ss){
        /*
        get请求
        */
        BufferedReader reader = null;
        String result = "";
        try {
            URL realloc = new URL(url);
            //打开连接
            HttpURLConnection connection = (HttpURLConnection)realloc.openConnection();
            connection.setRequestMethod("GET");
            connection.setRequestProperty("user-agent",
                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0");
            connection.connect();
            /*
            获取location的情况下就不需要再去返回请求的结果拉
            */
            if (ss){
                connection.setInstanceFollowRedirects(false);
                String location = connection.getHeaderField("location");
                System.out.println("取location");
                result = location;
            }
            else {
                System.out.println("不取location");
                reader = new BufferedReader(new InputStreamReader(
                        connection.getInputStream(), "UTF-8"));
                String line;
                while ((line = reader.readLine()) != null) {
                    result += line;
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(reader!=null){
                try {
                    reader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        /*
        获取抖音无水印视频示例
        1. 先获取数字视频id
        */
        String ret;
        String vid = null;

//        https://www.douyin.com/video/7123882684216085767
        String url = "https://v.douyin.com/kKpUdTE/";
        if (url.length() <= 29){
            ret = GetUrl(url, true);
        }
        else {
            ret = url;
        }

        System.out.println(ret);
        String regEx="7\\d{18}";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(ret);
        if (m.find()) {
            vid = m.group(0);
            System.out.println("匹配到的数字视频id:" + vid);
        } else {
            System.out.println("NO MATCH");
        }
        /*
        2.把数字视频id转成字符视频id
        */

        /* String video_id = get_video_id(vid);
        System.out.println("字符视频id：" + video_id);
        * */

        /*
        3.获取无水印地址
        */

/*        String play_url = get_play(video_id);*/

        String play_url = get_play(vid);
        System.out.println("无水印地址：" + play_url);

    }
}

旧版，此方法已失效

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class dy_ana {

    public static String get_video_id(String vid){
        /*
        获取字符视频id
        * */
        String url = "https://www.iesdouyin.com/web/api/v2/aweme/iteminfo/?item_ids=" + vid;
        String ret = GetUrl(url, false);
//        System.out.println(ret);

        JSONObject obj = JSONObject.parseObject(ret);
        List Array = obj.getJSONArray("item_list");
        JSONArray jsonArray = new JSONArray(Array);
        JSONObject obj1 = jsonArray.getJSONObject(0);
        JSONObject obj2 = obj1.getJSONObject("video");
        String video_id =  obj2.getString("vid");
        return video_id;
    }

    public static String get_play(String video_id){
        /*
        获取无水印地址
        * */

        if (video_id == null){
            System.out.println("请手动输入字符视频id");
            Scanner sc = new Scanner(System.in);
            video_id = sc.nextLine();
            System.out.println(video_id);
        }

        String url = "https://www.douyin.com/aweme/v1/play/?video_id=%s&line=0&is_play_url=1&source=PackSourceEnum_PUBLISH";
        url = String.format(url, video_id);
        String play_url = GetUrl(url, true);
        return play_url;
    }

    public static String GetUrl(String url, boolean ss){
        /*
        get请求
        */
        BufferedReader reader = null;


        String result = "";
        try {
            URL realloc = new URL(url);
            //打开连接
            HttpURLConnection connection = (HttpURLConnection)realloc.openConnection();

            connection.setRequestMethod("GET");
            connection.setRequestProperty("user-agent",
                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0");
            connection.connect();
            /*
            获取location的情况下就不需要再去返回请求的结果拉
            */
            if (ss == true){
                connection.setInstanceFollowRedirects(false);
                String location = connection.getHeaderField("location");
                System.out.println("取location");
                result = location;
            }
            else {
                System.out.println("不取location");
                reader = new BufferedReader(new InputStreamReader(
                        connection.getInputStream(), "UTF-8"));
                String line;
                while ((line = reader.readLine()) != null) {
                    result += line;
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(reader!=null){
                try {
                    reader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        /*
        获取抖音无水印视频示例
        1. 先获取数字视频id
        */
        String ret;
        String vid = null;
//        https://www.douyin.com/video/7114995682527743269
        String url = "https://v.douyin.com/YpcJm6R/";
        if (url.length() <= 29){
            ret = GetUrl(url, true);
        }
        else {
            ret = url;
        }

        System.out.println(ret);
        String regEx="7\\d{18}";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(ret);
        if (m.find()) {
            vid = m.group(0);
            System.out.println("匹配到的数字视频id:" + vid);
        } else {
            System.out.println("NO MATCH");
        }
        /*
        2.把数字视频id转成字符视频id
        */

        String video_id = get_video_id(vid);
        System.out.println("字符视频id：" + video_id);
        /*
        3.获取无水印地址
        */

        String play_url = get_play(video_id);
        System.out.println("无水印地址：" + play_url);

    }
}

成功示例

结尾

其它平台也可以按照这种方法获取无水印地址，实际原理都差不多
本源码仅限学习交流，不可用于商业用途
如有侵权请联系我删除