由于一看到大佬搭的二次元api就走不动道，就想着自己也搭一个，但奈何没有服务器，于是想看看cloudflare+github能不能行，网上搜了一番，结果发现github存储库限制只有1GB的空间，悲痛欲绝之下，看到了Cloudflare R2正在向我招手😄，于是一通折腾，发现全网只有随机图片 API (部署于 Cloudflare)这一篇教程，但部署比较难，于是就有了这篇文章，记录一下

爬取二次元图片#

话说要搭建二次元图片的api首先要先有图片吧，于是我就把魔爪伸向了举个栗子api(逃，，)本来想硬爬的，后来仔细看了看api文档，好像可以把所有图片链接都搞下来看的出来，如果把quantity设置的超过图片的总数量，就会返回所有图片的链接如图所示，当quantity设置的特别大时，这个分类下的所有图片的链接就都返回出来了，这时候只需要把它们都复制下来，然后一一下载下来就可以了，大家可以按照api的分类一一创建txt文本，然后将链接再一一的复制进去，就像这样就像这样，这样也方便后续的分类，然后就是熟悉的上python脚本批量下载了

1
import os
2
import requests
3
import threading
4

5
# 定义一个函数来下载单个链接
6
def download_file(url, save_dir):
7
    try:
8
        response = requests.get(url, stream=True)
9
        response.raise_for_status()  # 检查请求是否成功
10
        file_name = os.path.join(save_dir, url.split('/')[-1])  # 从URL中提取文件名
11
        with open(file_name, 'wb') as file:
12
            for chunk in response.iter_content(chunk_size=8192):
13
                file.write(chunk)
14
        print(f"Downloaded: {file_name}")
15
    except Exception as e:
16
        print(f"Failed to download {url}: {e}")
17

18
# 定义一个函数来处理单个txt文件
19
def process_txt_file(txt_file_path, save_dir, num_threads=5):
20
    # 创建对应的文件夹
21
    if not os.path.exists(save_dir):
22
        os.makedirs(save_dir)
23

24
    # 读取txt文件中的链接
25
    with open(txt_file_path, 'r') as file:
26
        urls = [line.strip() for line in file if line.strip()]
27

28
    # 使用多线程下载链接
29
    threads = []
30
    for url in urls:
31
        thread = threading.Thread(target=download_file, args=(url, save_dir))
32
        threads.append(thread)
33
        thread.start()
34
        if len(threads) >= num_threads:
35
            for t in threads:
36
                t.join()
37
            threads = []
38

39
    # 等待剩余的线程完成
40
    for t in threads:
41
        t.join()
42

43
# 定义一个函数来遍历目录并处理所有txt文件
44
def batch_download_from_directory(directory, num_threads=5):
45
    # 遍历目录下的所有文件
46
    for root, _, files in os.walk(directory):
47
        for file in files:
48
            if file.endswith(".txt"):
49
                txt_file_path = os.path.join(root, file)
50
                # 创建对应的文件夹
51
                folder_name = os.path.splitext(file)[0]  # 去掉扩展名
52
                save_dir = os.path.join(root, folder_name)
53
                # 处理当前txt文件
54
                print(f"Processing {txt_file_path}...")
55
                process_txt_file(txt_file_path, save_dir, num_threads)
56

57
if __name__ == "__main__":
58
    # 设置查询目录
59
    search_directory = "你txt文本的目录"  # 把你所有的txt文本放置同一目录，然后替换为你的目录路径
60

61
    # 设置线程数
62
    num_threads = 5  # 你可以根据需要调整线程数
63

64
    # 开始批量下载
65
    batch_download_from_directory(search_directory, num_threads)

下载完成之后，所有图片就都爬了下来，值得注意的是，举个栗子api中还有一个特殊的api(acg动图)，它是不能json请求的，所以就只能硬爬了

1
import os
2
import hashlib
3
import threading
4
import requests
5
from mimetypes import guess_extension
6

7
# 配置参数
8
URL = "https://t.alcy.cc/acg"
9
THREAD_NUM = 5                  # 线程数量
10
SAVE_DIR = "acg"             # 图片保存目录
11
RECORD_FILE = "downloaded.txt"  # 记录文件
12
HEADERS = {
13
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
14
}
15

16
# 初始化环境
17
if not os.path.exists(SAVE_DIR):
18
    os.makedirs(SAVE_DIR)
19

20
# 初始化记录集合和锁
21
downloaded = set()
22
file_lock = threading.Lock()
23
record_lock = threading.Lock()
24

25
# 加载已有记录
26
if os.path.exists(RECORD_FILE):
27
    with open(RECORD_FILE, 'r') as f:
28
        downloaded.update(line.strip() for line in f)
29

30
def get_extension(content_type):
31
    """根据Content-Type获取文件扩展名"""
32
    ext = guess_extension(content_type)
33
    return ext if ext else '.bin'
34

35
def download_image():
36
    while True:
37
        try:
38
            # 获取图片数据
39
            response = requests.get(URL, headers=HEADERS)
40
            if response.status_code != 200:
41
                continue
42

43
            content = response.content
44
            content_type = response.headers.get('Content-Type', '')
45

46
            # 计算哈希值
47
            file_hash = hashlib.md5(content).hexdigest()
48

49
            # 检查是否重复
50
            with file_lock:
51
                if file_hash in downloaded:
52
                    continue
53

54
            # 生成文件名
55
            extension = get_extension(content_type)
56
            filename = f"{file_hash}{extension}"
57
            filepath = os.path.join(SAVE_DIR, filename)
58

59
            # 保存图片
60
            with open(filepath, 'wb') as f:
61
                f.write(content)
62

63
            # 更新记录
64
            with record_lock:
65
                downloaded.add(file_hash)
66
                with open(RECORD_FILE, 'a') as f:
67
                    f.write(file_hash + '\n')
68

69
            print(f"下载成功：{filename}")
70

71
        except Exception as e:
72
            print(f"发生错误：{str(e)}")
73

74
if __name__ == "__main__":
75
    # 创建并启动线程
76
    threads = []
77
    for _ in range(THREAD_NUM):
78
        t = threading.Thread(target=download_image, daemon=True)
79
        t.start()
80
        threads.append(t)
81

82
    # 保持主线程运行
83
    try:
84
        while True:
85
            pass
86
    except KeyboardInterrupt:
87
        print("\n程序已终止")

至此，准备工作就以及完成了，如果有小伙伴不想爬虫的话，其实也是有现成的二次元图集的Github，Github这两个都是，可以直接上手（逃）

上传图片#

进入Cloudflare R2创建一个存储桶，位置选亚太地区，然后把你爬到的所有图片都上传上去，由于R2上传有限制，不能批量上传，需要自己搭文件管理器这里已经有很详细的教程了，就不多说了，自己感受去吧☺️Cloudflare R2 的完美搭档：R2 Uploader 使用指南如果觉得太麻烦的，听说alist好像也可以对接R2，没有具体测试，你们自己看着办吧图片上传完成之后应该是这样子的

搭建api#

我们进去Cloudflare，创建一个D1 SQL数据库，名字随意，然后电脑桌面创建一个index.html文件

1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
6
    <title>SQL Generator</title>
7
    <style>
8
        body {
9
            font-family: Arial, sans-serif;
10
            margin: 20px;
11
        }
12
        .container {
13
            max-width: 600px;
14
            margin: auto;
15
        }
16
        .input-group {
17
            margin-bottom: 15px;
18
        }
19
        .input-group label {
20
            display: block;
21
            margin-bottom: 5px;
22
        }
23
        .input-group input, .input-group textarea {
24
            width: 100%;
25
            padding: 8px;
26
            box-sizing: border-box;
27
        }
28
        .drop-area {
29
            border: 2px dashed #ccc;
30
            padding: 20px;
31
            text-align: center;
32
            margin-bottom: 15px;
33
        }
34
        .drop-area.dragover {
35
            border-color: #000;
36
        }
37
        .file-list {
38
            margin-bottom: 15px;
39
        }
40
        .file-list p {
41
            margin: 0;
42
        }
43
        .switch {
44
            display: flex;
45
            align-items: center;
46
            margin-bottom: 15px;
47
        }
48
        .switch input {
49
            margin-right: 10px;
50
        }
51
        button {
52
            padding: 10px 20px;
53
            background-color: #007bff;
54
            color: #fff;
55
            border: none;
56
            cursor: pointer;
57
        }
58
        button:hover {
59
            background-color: #0056b3;
60
        }
61
    </style>
62
</head>
63
<body>
64
    <div class="container">
65
        <h1>SQL Generator</h1>
66
        <div class="input-group">
67
            <label for="tableName">Table Name</label>
68
            <input type="text" id="tableName" placeholder="Enter table name">
69
        </div>
70
        <div class="input-group">
71
            <label for="baseUrl">Base URL</label>
72
            <input type="text" id="baseUrl" placeholder="Enter base URL">
73
        </div>
74
        <div class="drop-area" id="dropArea">
75
            Drag & Drop Files Here
76
        </div>
77
        <div class="file-list" id="fileList">
78
            <p>No files added</p>
79
        </div>
80
        <div class="switch">
81
            <input type="checkbox" id="recreateTable">
82
            <label for="recreateTable">Delete and Recreate Table</label>
83
        </div>
84
        <button id="generateSql">Generate SQL</button>
85
    </div>
86

87
    <script>
88
        const dropArea = document.getElementById('dropArea');
89
        const fileList = document.getElementById('fileList');
90
        const generateSqlButton = document.getElementById('generateSql');
91
        let files = [];
92

93
        dropArea.addEventListener('dragover', (event) => {
94
            event.preventDefault();
95
            dropArea.classList.add('dragover');
96
        });
97

98
        dropArea.addEventListener('dragleave', () => {
99
            dropArea.classList.remove('dragover');
100
        });
101

102
        dropArea.addEventListener('drop', (event) => {
103
            event.preventDefault();
104
            dropArea.classList.remove('dragover');
105
            files = Array.from(event.dataTransfer.files);
106
            updateFileList();
107
        });
108

109
        function updateFileList() {
110
            fileList.innerHTML = '';
111
            if (files.length === 0) {
112
                fileList.innerHTML = '<p>No files added</p>';
113
            } else {
114
                fileList.innerHTML = `<p>${files.length} files added</p>`;
115
            }
116
        }
117

118
        generateSqlButton.addEventListener('click', () => {
119
            const tableName = document.getElementById('tableName').value;
120
            const baseUrl = document.getElementById('baseUrl').value;
121
            const recreateTable = document.getElementById('recreateTable').checked;
122

123
            if (!tableName || !baseUrl || files.length === 0) {
124
                alert('Please fill in all fields and add at least one file.');
125
                return;
126
            }
127

128
            let sql = '';
129
            if (recreateTable) {
130
                sql += `DROP TABLE IF EXISTS ${tableName};\n`;
131
                sql += `CREATE TABLE ${tableName} (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    name TEXT,\n    url TEXT\n);\n\n`;
132
            }
133

134
            files.forEach(file => {
135
                const fileName = file.name;
136
                const fileUrl = `${baseUrl}/${fileName}`;
137
                sql += `INSERT INTO ${tableName} (name, url) VALUES ('${fileName}', '${fileUrl}');\n`;
138
            });
139

140
            downloadSql(sql);
141
        });
142

143
        function downloadSql(sql) {
144
            const blob = new Blob([sql], { type: 'text/plain' });
145
            const url = URL.createObjectURL(blob);
146
            const a = document.createElement('a');
147
            a.href = url;
148
            a.download = 'generated_sql.txt';
149
            document.body.appendChild(a);
150
            a.click();
151
            document.body.removeChild(a);
152
            URL.revokeObjectURL(url);
153
        }
154
    </script>
155
</body>
156
</html>

然后打开，Table Name填api的分类名，Base URL填你R2存储桶的链接(什么，你不会连一个域名都没有吧，那可以关闭电脑去睡觉了），如果不知道的话，可以进去R2存储桶的管理界面，添加一个访问域名，记住，如果你想创建哪个分类的数据表，链接要对应R2存储桶的目录，比如ysmp，那你的链接就是https://example.com/ysmp，其实就是对应你R2存储桶图片的目录名然后再将对应那个分类里的所有图片都拖进去，勾选Delete and Recreate Table，然后点击创建就可以了，然后它会生成一个txt文件，你打开，将内容复制进D1的控制台去点击执行，显示成功就可以了，以此类推，api中的每个图片分类都要重复一遍这个操作，直到D1表中有所有图片的分类然后进去Workers，创建一个Worker，worker.js为

1
export default {
2
    async fetch(request, env, ctx) {
3
        // 检查是否是预检请求（OPTIONS请求），如果是则返回CORS头部
4
        if (request.method === 'OPTIONS') {
5
            return new Response(null, {
6
                headers: {
7
                    'Access-Control-Allow-Origin': '*',
8
                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
9
                    'Access-Control-Allow-Headers': '*',
10
                },
11
            });
12
        }
13

14
        const url = new URL(request.url);
15

16
        // 检查URL中是否包含 "favicon.ico"
17
        if (url.pathname.includes("favicon.ico")) {
18
            return new Response('Not Found', { status: 404 });
19
        }
20

21
        // 获取路径中的表名
22
        const pathParts = url.pathname.split('/');
23
        const tableName = pathParts[1];
24

25
        // 检查是否包含 'json' 参数
26
        const searchParams = new URLSearchParams(url.search);
27
        const isJson = searchParams.has('json');
28
        const quantityParam = searchParams.get('quantity');
29
        const quantity = quantityParam ? parseInt(quantityParam, 10) : 1; // 默认为1
30

31
        // 构建SQL查询
32
        const sql = `SELECT url FROM \`${tableName}\``;
33

34
        try {
35
            const rows = await env.PIC_DB.prepare(sql).all();
36

37
            if (rows.results.length > 0) {
38
                let urls = [];
39

40
                if (isJson && searchParams.get('json') && !isNaN(parseInt(searchParams.get('json')))) {
41
                    const index = parseInt(searchParams.get('json'), 10);
42
                    if (index >= 0 && index < rows.results.length) {
43
                        urls.push(rows.results[index].url);
44
                    }
45
                } else if (isJson) {
46
                    for (let i = 0; i < quantity && i < rows.results.length; i++) {
47
                        const randomIndex = Math.floor(Math.random() * rows.results.length);
48
                        urls.push(rows.results[randomIndex].url);
49
                    }
50
                } else {
51
                    const randomIndex = Math.floor(Math.random() * rows.results.length);
52
                    const randomImageUrl = rows.results[randomIndex].url;
53

54
                    return new Response(null, {
55
                        status: 302,
56
                        headers: {
57
                            'Access-Control-Allow-Origin': '*',
58
                            'Location': randomImageUrl,
59
                        },
60
                    });
61
                }
62

63
                // 将链接数组转为一行一个链接的文本格式
64
                const responseText = urls.join('\n');
65

66
                return new Response(responseText, {
67
                    status: 200,
68
                    headers: {
69
                        'Content-Type': 'text/plain',
70
                        'Access-Control-Allow-Origin': '*',
71
                    },
72
                });
73
            } else {
74
                return new Response('No matching images found', {
75
                    status: 404,
76
                    headers: {
77
                        'Content-Type': 'text/plain',
78
                    },
79
                });
80
            }
81
        } catch (error) {
82
            return new Response('Internal Server Error: ' + error.message, {
83
                status: 500,
84
                headers: {
85
                    'Content-Type': 'text/plain; charset=utf-8',
86
                },
87
            });
88
        }
89
    },
90
};

部署完后进去设置，添加你api的域名，然后绑定D1数据库，名称为PIC_DB 支持api就搭建完成了，api文档适配举个栗子的api文档，请求方式也相同，属于高仿😀 拜拜👋