多吉云api文件封装---python

目录结构

• djy.py：Python主脚本
• .env: 配置文件
• djy.cmd：执行脚本文件
• log/：日志存储文件夹
• pem/：SSH密钥存储文件夹
• hexo-d.cmd: 名字随便啦 最终只需要双击就能运行所有操作

djy.py

复制以下代码到djy.py

from hashlib import sha1
import hmac
import time
from matplotlib.lines import Line2D
import requests
import json
import urllib
from dotenv import load_dotenv
import os
import sys
import matplotlib
# 强制指定后端（必须在所有导入之前）
matplotlib.use('TkAgg')  # Windows系统
import json
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta
import matplotlib.dates as mdates
import tkinter as tk
from tkinter import ttk
plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows首选
animation_chars = ["/", "|", "\\", "-"]  # 加载动画字符

load_dotenv()
def dogecloud_api(api_path, data={}, json_mode=False):
    # 在.env文件内配置你的ACCESS_KEY和SECRET_KEY
    access_key = os.getenv("ACCESS_KEY")
    secret_key = os.getenv("SECRET_KEY")
    body = ''
    mime = ''
    if json_mode:
        body = json.dumps(data)
        mime = 'application/json'
    else:
        body = urllib.parse.urlencode(data) 
        mime = 'application/x-www-form-urlencoded'
    sign_str = api_path + "\n" + body
    signed_data = hmac.new(secret_key.encode('utf-8'), sign_str.encode('utf-8'), sha1)
    sign = signed_data.digest().hex()
    authorization = 'TOKEN ' + access_key + ':' + sign
    response = requests.post('https://api.dogecloud.com' + api_path, data=body, headers = {
        'Authorization': authorization,
        'Content-Type': mime
    })
    return response.json()

# 加速域名管理

# 获取加速域名列表
def get_js_list():
    api = dogecloud_api('/cdn/domain/list.json')
    if api['code'] == 200:
        for domain in api['data']['domains']:
            print(domain)
        return api['data']['domains']
    else:
        print("api failed: " + api['msg']) 

# 停用加速域名
def stop_js(domain):
    api = dogecloud_api('/cdn/domain/offline.json', {
    'domain': domain
})
    
    return api['code']

#启用加速域名
def enable_js(domain):
    api = dogecloud_api('/cdn/domain/online.json', {
    'domain': domain
})
    return api['code']


# 证书管理
# 获取证书列表
def get_ssl():
    api = dogecloud_api('/cdn/cert/list.json')
    if api['code'] == 200:
        return api['data']['certs']
    else:
        print("api failed: " + api['msg']) # 失败
# 上传证书
def updata_ssl(note,cert,private,domain=os.getenv("DOMAIN")):
    cert_path=f"pem/{cert}"
    with open(cert_path,mode='r') as f:
        cert=f.read()
    private_path=f"pem/{private}"
    with open(private_path,mode='r') as f:
        private=f.read()
    api = dogecloud_api('/cdn/cert/upload.json', {
    "note": note,
    "cert": cert,
    "private": private
})
    if api['code'] == 200:
        print("---上传成功")
        if domain is not None:
            bind_ssl(domain,api['data']['id'])
            print("---绑定成功")
        else:
            print("为检测到.env文件内的DOMAIN")
    else:
        print("api failed: " + api['msg']) # 失败
# 为加速域名绑定证书
def bind_ssl(id,domain=os.getenv("DOMAIN")):
    api = dogecloud_api(f'/cdn/domain/config.json?domain={domain}', {
    'cert_id': id
}, True)
    if api['code']== 200:
        print("绑定成功")
    else:
        print(api['msg'])
# api['code'] == 200 则成功，否则失败，失败请参考 api['msg'] 判断

# URL预热
def refresh_pre(path):
    animation_index=0
    url_list=[path]
    api = dogecloud_api('/cdn/refresh/add.json', {
        'rtype': 'prefetch',
        'urls': json.dumps(url_list)
    })
    if api['code'] == 200:
        id=api['data']['task_id']
        print("预热id",id)
        print("现在开始预热")
        while True:
            code = get_pre(id)["percent"]
            time.sleep(1)
            print(f"\r正在加载... {animation_chars[animation_index]}{code}%", end="", flush=True)
            animation_index = (animation_index + 1) % len(animation_chars)
            if code == 100:
                print("\r刷新完成！")  # 清除动画并打印完成信息
                break
            print("预热完成")
    else:
        print("api failed: " + api['msg']) # 失败

# URL刷新
def refresh_url(path):
    animation_index = 0
    url_list=[path]
    api = dogecloud_api('/cdn/refresh/add.json', {
        'rtype': 'url',
        'urls': json.dumps(url_list)
    })
    if api['code'] == 200:
        print("URL刷新ID:",api['data']['task_id'])
        id=api['data']['task_id']
        print("\n开始URL刷新")  # 换行打印日志
    
        while True:
            print(f"\r正在加载... {animation_chars[animation_index]}{code}%", end="", flush=True)
            animation_index = (animation_index + 1) % len(animation_chars)
            time.sleep(1)
            code = get_pre(id)["percent"]

            if code == 100:
                print("\r刷新完成！")  # 清除动画并打印完成信息
                break
                   # 打印动画（覆盖当前行）
            
        print("刷新完成，现在开始预热")
        refresh_pre(path)
    else:
        print("api failed: " + api['msg']) # 失败

# 目录刷新
def refresh_menu(*custom_urls):
    if not custom_urls:
        default_domain = os.getenv("DOMAIN")
        if not default_domain:
            raise ValueError("环境变量 DOMAIN 未设置，且未传入自定义URL")
        url_list = [f"https://{default_domain}"]
    else:
        url_list = custom_urls
 
    # 调用API刷新
    api = dogecloud_api('/cdn/refresh/add.json', {
        'rtype': 'path',
        'urls': json.dumps(url_list)
    })
    animation_index=0
    # 处理响应
    if api['code'] == 200:
        print(f"刷新任务提交成功，任务ID: {api['data']['task_id']}")
        id=api['data']['task_id']
        print("\n开始目录刷新")  # 换行打印日志
        a=0
        while True:
            code = get_pre(id)["percent"]
            time.sleep(5)
            print(f"\r正在加载... {animation_chars[animation_index]}{code}%", end="", flush=True)
            animation_index = (animation_index + 1) % len(animation_chars)
            if code == 100:
                a+=1
                if a==2:
                    print("\r刷新完成！")  # 清除动画并打印完成信息
                    break
                    # 打印动画（覆盖当前行）

    else:
        print(f"API调用失败: {api['msg']}")

# 查询预热任务
# 使用添加任务接口获得的任务 ID（例如 PREFETCH.TX.286539751528224811）
def get_pre(id):
    api = dogecloud_api(f'/cdn/refresh/query.json?id={id}')
    if api['code'] == 200:
        return api['data']['tasks'][0]
    else:
        print("api failed: " + api['msg']) # 失败


# 统计分析
# 获取流量数据
def get_traffic_data(start=datetime.now().date()- timedelta(days=1), end=datetime.now().date(), domain=os.getenv("DOMAIN")):
    api = dogecloud_api(f'/cdn/stat/traffic.json?start_date={start}&end_date={end}&granularity=hour&area=china&domains={domain}')
    if api['code'] == 200:
        print(api['data']['result'][0])
        plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题

        def plot_traffic_bar(api_data):
            """绘制流量柱状图（全屏居中版本）"""
            # 数据解析
            start_timestamp = api_data['start']
            traffic_data = api_data['data']
            
            # 生成时间标签
            base_time = datetime.fromtimestamp(start_timestamp)
            hours = [base_time + timedelta(hours=i) for i in range(len(traffic_data))]

            # 计算最佳单位
            max_traffic = max(traffic_data)
            unit = 'B'
            divisor = 1
            if max_traffic > 1024**3:
                unit = 'GB'
                divisor = 1024**3
            elif max_traffic > 1024**2:
                unit = 'MB'
                divisor = 1024**2
            elif max_traffic > 1024:
                unit = 'KB'
                divisor = 1024

            # 创建全屏窗口
            root = tk.Tk()
            root.title("流量统计图表")
            
            # 获取屏幕尺寸并计算居中位置
            screen_width = root.winfo_screenwidth()
            screen_height = root.winfo_screenheight()
            window_width = int(screen_width * 0.9)  # 窗口宽度为屏幕的90%
            window_height = int(screen_height * 0.8)  # 窗口高度为屏幕的80%
            x = (screen_width - window_width) // 2
            y = (screen_height - window_height) // 2
            
            # 设置窗口属性
            root.geometry(f"{window_width}x{window_height}+{x}+{y}")
            root.attributes('-topmost', True)  # 窗口置顶
            
            # 创建Figure和Canvas
            fig = plt.figure(figsize=(16, 8), dpi=100)  # 调整DPI适应大屏幕
            canvas = matplotlib.backends.backend_tkagg.FigureCanvasTkAgg(fig, master=root)
            canvas.draw()
            
            # 添加工具栏（可选）
            toolbar = ttk.Frame(root)
            toolbar_nav = ttk.Frame(toolbar)
            ttk.Button(toolbar_nav, text="保存", command=lambda: fig.savefig('traffic_fullscreen.png')).pack(side=tk.LEFT, padx=2)
            ttk.Button(toolbar_nav, text="关闭", command=root.destroy).pack(side=tk.LEFT, padx=2)
            toolbar_nav.pack(side=tk.TOP, fill=tk.X)
            canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
            toolbar.pack(side=tk.BOTTOM, fill=tk.X)

            # 绘制图表内容
            plt.clf()  # 清除当前图形
           # 转换数据（除以 divisor）
            # 转换数据（除以 divisor）
            # 转换数据（除以 divisor）
            converted_traffic = [x / divisor for x in traffic_data]
            
            # 绘制图表
            plt.clf()
            bars = plt.bar(
                hours,
                converted_traffic,
                color='steelblue',
                edgecolor='white',
                width=0.03
            )
            
            # 设置 Y 轴标签（仅显示大单位，如 "流量 (KB)"）
            plt.ylabel(f'流量 ({unit})', fontsize=12)
            
            # 数据标签显式标注单位（如 "1.5 KB"）
            for bar in bars:
                height = bar.get_height()
                plt.text(
                    bar.get_x() + bar.get_width()/2,
                    height + 0.1 if height < 350 else height*1.01,
                    f'{height:.1f} {unit}',  # 在数据标签中显式标注单位
                    ha='center',
                    va='bottom',
                    fontsize=10
                )

            # 图表装饰（调整边距适应大屏幕）
            plt.title(f'{api_data["date"]} 域名流量分布', fontsize=16, pad=30)
            plt.xlabel('时间', fontsize=14)
            plt.grid(axis='y', linestyle='--', alpha=0.7)
            plt.gcf().autofmt_xdate()
            plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
            plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=2))
            plt.tight_layout(pad=2.0)  # 增大边距

            # 刷新画布
            canvas.draw()
            
            # 启动Tkinter主循环
            def on_close():
                root.destroy()  # 关闭 Tkinter 窗口
                sys.exit(0)     # 彻底退出 Python 程序
            root.protocol("WM_DELETE_WINDOW", on_close)
            root.mainloop()
           
        plot_traffic_bar(api['data']['result'][0])
    else:
        print("api failed: " + api['msg']) # 失败

# 查询请求数
def get_request(start=datetime.now().date()- timedelta(days=1), end=datetime.now().date(), domain=os.getenv("DOMAIN")):
 
    api = dogecloud_api(f'/cdn/stat/request.json?start_date={start}&end_date={end}&granularity=hour&area=china&domains={domain}')
    if api['code'] == 200:
        print(api['data']['result'])
        def plot_cdn_requests(api_response):
            if api_response.get("code") != 200:
                print("API Failed:", api_response.get("msg", "Unknown error"))
                return
        
            # 提取所有日期的数据
            results = api_response["data"]["result"]
            if not results:
                print("No data available.")
                return
        
            # 创建图表
            plt.figure(figsize=(12, 6))
            
            # 定义颜色和标记样式（循环使用）
            colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
            markers = ['o', 's', '^', 'v', '<', '>', 'x']
            
            # 动态绘制每条曲线
            for idx, day_data in enumerate(results):
                date = day_data["date"]
                requests = day_data["data"]
                hours = range(len(requests))  # 0-23 小时
                
                # 选择颜色和标记
                color = colors[idx % len(colors)]
                marker = markers[idx % len(markers)]
                
                # 绘制折线图
                plt.plot(hours, requests, marker=marker, linestyle='-', color=color, label=date)
                
                # 添加数据标签（动态调整位置）
                for h, req in zip(hours, requests):
                    # 标签位置：数据点上方，避免重叠
                    offset = 5 if idx == 0 else -5  # 交替偏移
                    plt.text(h, req + offset, str(req), ha='center', va='bottom', fontsize=8, color=color)
        
            # 添加标题和标签
            plt.title('请求数变化趋势（每小时）')
            plt.xlabel('小时（0-23）')
            plt.ylabel('请求数')
            plt.xticks(range(24), [f"{h:02d}:00" for h in range(24)], rotation=45)
            
            # 添加图例（动态生成）
            legend_elements = [
                Line2D([0], [0], marker=markers[i], color=colors[i], label=day["date"])
                for i, day in enumerate(results)
            ]
            plt.legend(handles=legend_elements)
            
            plt.grid(True, linestyle='--', alpha=0.5)
            plt.tight_layout()
            plt.show()
        
        # 调用函数
        plot_cdn_requests(api)
    else:
        print("api failed: " + api['msg']) # 失败

def get_domain_id(domain=None):
    result=get_js_list()
    if domain is None:
        id=list(filter(lambda item:item.get("name")==os.getenv("DOMAIN"),result))[0].get("id")
    else:
        id=list(filter(lambda item:item.get("name")==domain,result))[0].get("id")
    return id
    
# 下载离线日志
# data格式为 year-mon-day
def down_log(id=None,date=None):
    if id is None or date is None:
        id=get_domain_id()
        date=datetime.now().date()
    api = dogecloud_api(f'/cdn/log/list.json?id={id}&date={date}')
    if api['code'] == 200:
        path=f"log/{date}.json"
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path,mode='w',encoding='utf-8') as f:
            json.dump(api['data']['log_list'], f, indent=4, ensure_ascii=False)
            print("下载完成，路径为",path)
    else:
        print("api failed: " + api['msg']) # 失败

def cg(id):
    default_domain = os.getenv("DOMAIN")
    default_articles=os.getenv("ARTICLES_PATH")
    if not default_domain or not default_articles:
        raise ValueError("环境变量 DOMAIN 未设置，未传入自定义URL")
    else:
        url = f"https://{default_domain}{default_articles}{id}.html"
        refresh_url(url)
        




"重新绑定多吉云的证书"
def bind_djy():
    ssls=get_ssl()
    # print(ssls)
    # 1. 获取当前时间戳
    current_time = int(time.time())
    
    # 2. 筛选未过期的证书
    valid_certs = [cert for cert in ssls if cert['expire'] > current_time]
    
    if not valid_certs:
        raise ValueError("没有未过期的证书！")
    
    # 3. 找出剩余有效期最长的证书（expire 最大的）
    longest_valid_cert = max(valid_certs, key=lambda x: x['expire'])
    id=longest_valid_cert.get("id")
    print("未过期的证书列表:", valid_certs)
    print("剩余有效期最长的证书ID:", id)
    bind_ssl(id)
def show_help():
    commands = [
        ("get_js_list", "获取加速域名列表"),
        ("stop_js <域名>", "停用加速域名"),
        ("enable_js <域名>", "启用加速域名"),
        ("get_ssl", "获取证书列表"),
        ("updata_ssl <证书名> <cert文件名> <private文件名> <域名(可选)>", "上传证书(传入域名自动绑定)"),
        ("bind_ssl <域名> <证书ID>", "绑定证书到域名"),
        ("djy bind", "一键绑定时间最长的证书"),
        ("refresh_pre <URL>", "URL预热"),
        ("refresh_url <URL>", "URL刷新"),
        ("refresh_menu", "目录刷新"),
        ("cg abblink", "文章刷新"),
        ("get_pre <任务ID>", "查询预热任务"),
        ("get_traffic_data <开始> <结束> <域名>", "获取流量数据"),
        ("get_request <开始> <结束> <域名>", "查询请求数"),
        ("down_log <域名id> <日期>", "下载离线日志"),
    ]
    
    max_cmd_len = max(len(cmd[0]) for cmd in commands)  # 计算命令最大长度用于对齐
    
    print("多吉云 CDN 管理工具命令列表：\n")
    print("-" * 60)
    for cmd, desc in commands:
        print(f"{cmd.ljust(max_cmd_len + 2)}  {desc}")
    print("-" * 60)
if __name__ == "__main__":
    if len(sys.argv) < 2:
        show_help()
        sys.exit(1)
 
    func_name = sys.argv[1]
    args = sys.argv[2:]
 
    try:
        if func_name == "get_js_list":
            get_js_list()
        elif func_name == "stop_js":
            if len(args) < 1:
                raise ValueError("缺少域名参数")
            stop_js(args[0])
            
        elif func_name == "enable_js":
            if len(args) < 1:
                raise ValueError("缺少域名参数")
            enable_js(args[0])
            
        elif func_name == "get_ssl":
            get_ssl()
            
        elif func_name == "updata_ssl":
            if len(args) < 3:
                raise ValueError("缺少必要参数：需要至少 3 个参数（cert_name, cert_path, private_key_path）")
            elif len(args) == 3:
 
                updata_ssl(args[0], args[1], args[2])
            else:
                updata_ssl(args[0], args[1], args[2],args[3])
            
        elif func_name == "bind_ssl":
            if len(args) < 2:
                raise ValueError("缺少域名或证书ID参数")
            bind_ssl(args[0], args[1])
            
        elif func_name == "refresh_pre":
            if len(args) < 1:
                raise ValueError("缺少URL列表参数")
            refresh_pre(*args)
        elif func_name == "refresh_url":
            if len(args) < 1:
                raise ValueError("缺少URL列表参数")
            refresh_url(*args)
        elif func_name == "refresh_menu":
            refresh_menu(*args)
        elif func_name == "get_pre":
            if len(args) < 1:
                raise ValueError("缺少任务ID参数")
            get_pre(args[0])
            
        elif func_name == "get_traffic_data":
            if len(args) < 3:
                get_traffic_data()

            get_traffic_data(args[0], args[1], args[2])
            
        elif func_name == "get_request":
            if len(args) < 3:
                get_request()
            else:
                get_request(args[0], args[1], args[2])
            
        elif func_name == "down_log":
            down_log(*args)
        elif func_name == "bind_djy":
            bind_djy()
        elif func_name =="cg":
            if len(args) < 1:
                raise ValueError("缺少文章abbrlink")
            else:
                cg(args[0])
        else:
            print(f"未知命令：{func_name}")
            show_help()
 
    except Exception as e:
        print(f"执行出错：{str(e)}")
        sys.exit(1)
 

.env配置文件

ACCESS_KEY=AccessKey
SECRET_KEY=SecretKey
DOMAIN=默认域名
ARTICLES_PATH=文章所在的固定目录 

1. 多吉云点击你的头像—>用户中心—>秘钥管理获取你的秘钥,在.env填入你的AccessKey和SecretKey以及你的域名
2. 由于我有使用hexo-abbrlink,所以我的路径是p/:abbrlink.html,所以这里我的ARTICLES_PATH就要填入/p/如果你没有使用hexo-abbrlink,可以看到文章刷新

djy.cmd

@echo off  
python "%~dp0djy.py" %*

开始使用

需要注意的地方:

1. 证书需要放在pem文件夹下
2. 所有日期和域名都可以不传，默认为昨天到今天，以及.env文件内配置的默认域名
   如果有传日期参数，就必须要传域名
3. 需要加上djy前缀

命令	说明	参数示例或阐述
get_js_list	获取加速域名列表	可以获取域名列表包含域名id
stop_js <域名>	停用加速域名	stop_js example.com
enable_js <域名>	启用加速域名	enable_js example.com
get_ssl	获取证书列表	获取存在的所有证书列表
updata_ssl <证书名> <cert文件名> <private文件名> <域名(可选)>	上传证书(传入域名自动绑定)	updata_ssl my_cert cert.pem key.pem www.xxx.cn
bind_ssl <域名> <证书ID>	绑定证书到域名	bind_ssl example.com 12345
djy bind	一键绑定时间最长的证书	无
refresh_pre <URL>	URL预热	refresh_pre https://a.com/a.xml
refresh_url <URL>	URL刷新	refresh_url https://a.com/a.xml
refresh_menu	目录刷新	refresh_menu https://a.com/
cg abblink	文章刷新	cg f470ac5b
get_pre <任务ID>	查询预热任务	get_pre 54321
get_traffic_data <开始> <结束> <域名>	获取流量数据	get_traffic_data 2023-01-01 2023-01-02 example.com
get_request <开始> <结束> <域名>	查询请求数	get_request 2023-01-01 2023-01-02 example.com
down_log <域名id> <日期>	下载离线日志	down_log 123 2023-01-01

接下来就可以在博客根目录打开cmd执行我们的命令了

例如我执行 djy get_traffic_data获取昨天到今天的流量数据

就可以很开的看看我们这几天的流量数据了，当然，你也可以自己编写脚本实现一些自己想要的功能

上传HTTPS证书和绑定

自己的证书

上传证书文件需要你在pem内有一个pem文件和一个key文件，然后再根目录控制台直接执行

djy updata_ssl my_ssl chain.pem key.key就可以直接上传＋绑定了，推荐名字固定，然后创建一个上证书的cmd文件，每次上传只需要放好证书文件，直接上传就可以实现上传和绑定了。

我用的是free_ssl，我准备用Selenium写一个自动化获取证书的脚本，但是目前没空。

多吉云证书无忧服务(暂时免费)

当然了多吉云有一个证书无忧服务，但是每次都需要登录多吉云手动更新，而且要到每天上午才自动检测是否过期或不存在，条件成立即自动颁发但不帮你重新绑定，需要你自己登录多吉云手动绑定，所以我们就可以先关注一下多吉云的公众号，当它给你颁发后通知你后，你就可以执行djy bind_djy，bind_djy函数会自动绑定时间最长的证书。

但是指不定它哪天就收费了。

刷新

目录

目录刷新

refresh_menu目录刷新，这确保了当你页面更新内容时，你的CDN站点可以即使的更新缓存，但是请注意https://www.xhwv.cn和https://www.xhwv.cn/是不一样的，前者代表只刷新首页，后者代表整站刷新，在代码中我默认写的是前者，平时发表文章时，直接上传执行就可以了，不需要传参，但是如果网站多个页面有较大的变更，可以传参后者，只需要刷新改动的地方的缓存就可以了。

使用示例：

1. djy refresh_menu https://www.xhwv.cn 刷新首页，默认选项，参数可以不传，当你发布文章执行这个就可以了。
2. djy refresh_menu https://www.xhwv.cn/刷新整站，多个页面变动较大可以使用这个
3. djy refresh_menu https://www.xhwv.cn/links/刷新友链页

URL（静态文件）

先刷新，再预热，可以提高访问速度，如果已经被缓存只能使用url刷新，然后再使用url预热。

当你使用URL刷新时，URL刷新结束后会自动调用函数执行URL预热。

URL刷新（节点有缓存时）

适用于节点已经有缓存了，应该使用刷新功能，可以理解为清除节点的缓存。

refresh_urlULR刷新可以立即刷新你修改后的文章，缓存的内容会立马强制过期，当你向CDN站点请求后，CDN会直接回源站获取对应的资源返回给你，并将它缓存，但是URL刷新会降低缓存命中率。

使用示例：

1. djy refresh_url https://www.xhwv.cn/sitemap.xml刷新文件
2. djy refresh_url https://www.xhwv.cn/p/f470ac5b.html刷新文章

URL预热（节点没有缓存时）

适用于当没有缓存的时候推送缓存，如果已经有缓存，则不会更新缓存。可以理解为缓存到节点。

refresh_preURL预热，提交URL预热请求后，源站将会主动将对应的资源缓存到CDN节点，首次请求时，就可以直接从CDN节点缓存中获取到最新的请求资源，无需再回源站获取。预热功能会提高缓存命中率。

使用示例（需要未被节点缓存）:

1. djy refresh_preURLhttps://www.xhwv.cn/sitemap.xml预热文件
2. djy refresh_pre https://www.xhwv.cn/p/f470ac5b.html预热文章

文章刷新

修改文章是很常见的事情，所以我写一个cg函数，可以直接传入abbrlink就可以刷新页面了，但是前提是你得使用了hexo-abbrlink插件才可以，不然只能使用refresh_url函数来传入整个链接，如果你想了解如何使用hexo-abbrlink可以参考：Hexo：hexo利用hexo-abbrlink插件生成永久链接-CSDN博客

cg函数使用示例:

​ djy cg f470ac5b

调用函数后会自动URL刷新和URL预热。

总结

好了，现在我们就可以自己写个xxx.cmd文件里，把上传需要用的功能都写进去，但是其实用到的也不是很多，但是我们可以自己写个写多个cmd文件，例如双击查看流量数据图，请求数图或者下载日志等等，上传的话大概就只需要下面这些就够了

hexo clean
hexo g
hexo d
djy refresh_menu

如果你需要直接打开cmd就能执行这些命令，将根目录配置为环境变量即可哦~

如果你有想法，其实也可以做成交互式数字菜单选择的形式，但是我感觉我自己用起来挺麻烦的，所以我就没搞，如果你不怕折腾其实也可以搞出来哈哈哈哈哈，记得搞出来给我留言哦，我去给你捧场！

看过来

感谢你能看到这里，我没怎么写过博客，如果有什么建议和批评，可以在评论区留言哦~

参考

SDK 概览 - 多吉云文档中心

Hexo：hexo利用hexo-abbrlink插件生成永久链接-CSDN博客