分层迭代开发方案文档（完整版）

# 10亿手机号毫秒级查询：从理论到实战的异构索引架构完整指南

在数据量爆炸式增长的今天，如何高效处理海量数据查询成为每个后端工程师必须面对的挑战。最近我在准备架构师面试时，深入研究了10亿手机号按尾号毫秒级查询的解决方案，不仅完成了理论设计，还进行了完整的实战测试。本文将分享从架构设计到代码实现的完整过程。



## 问题背景：为什么简单索引不够用？

假设我们有一个包含10亿手机号码的用户表，需要支持按手机尾号（后4位）进行快速查询。很多工程师的第一反应是使用LIKE查询或普通索引：

```sql
-- 错误做法：全表扫描
SELECT * FROM users WHERE phone LIKE '%1234';

-- 效果有限：无法利用最左前缀原则
CREATE INDEX idx_phone ON users(phone);
```

但实际测试发现，在百万级数据量下，LIKE查询已经需要秒级响应，10亿数据根本不可行。B+树索引的"最左前缀原则"让后缀查询无法有效利用索引。

## 解决方案：异构索引架构设计

### 架构核心思想

异构索引的核心思路是：**为不同的查询维度建立独立的索引表**，通过数据冗余换取查询性能。具体到手机尾号查询场景：

1. **主表**：按用户ID分片，存储完整用户信息
2. **异构索引表**：按手机尾号分片，只存储`(尾号, 用户ID)`映射关系
3. **精准路由**：利用尾号本身的均匀分布特性，直接取模路由到对应分表

### 系统架构设计


![5f20039e76b72.png](/static/img/d16711a2d733d254f3f80cc79e1299fb.5f20039e76b72.webp)

## 实战代码实现

### 数据表设计

**主表结构**（按user_id分片）：
```sql
CREATE TABLE users_main (
    user_id BIGINT AUTO_INCREMENT PRIMARY KEY,
    phone_number VARCHAR(20) NOT NULL,
    username VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```

**异构索引表**（按尾号取模分表）：
```sql
-- 分表示例
CREATE TABLE phone_index_0 (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    phone_suffix CHAR(4) NOT NULL,
    user_id BIGINT NOT NULL,
    phone_number VARCHAR(20) NOT NULL,
    INDEX idx_suffix (phone_suffix)
);
```

### 完整的数据生成脚本

```python
import mysql.connector
import random
import time
from concurrent.futures import ThreadPoolExecutor

def create_tables_and_data():
    """创建表并生成测试数据"""
    conn = mysql.connector.connect(
        host='localhost', user='root', 
        password='your_password', database='phone_system'
    )
    cursor = conn.cursor()
    
    # 创建主表
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS users_main (
            user_id BIGINT AUTO_INCREMENT PRIMARY KEY,
            phone_number VARCHAR(20) NOT NULL,
            username VARCHAR(100),
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    
    # 创建10个索引分表
    for i in range(10):
        cursor.execute(f"""
            CREATE TABLE IF NOT EXISTS phone_index_{i} (
                id BIGINT AUTO_INCREMENT PRIMARY KEY,
                phone_suffix CHAR(4) NOT NULL,
                user_id BIGINT NOT NULL,
                phone_number VARCHAR(20) NOT NULL,
                INDEX idx_suffix (phone_suffix)
            )
        """)
    
    print("表创建成功")
    
    # 生成100万条测试数据
    print("开始生成 1000000 条测试数据...")
    start_time = time.time()
    
    for batch in range(100):  # 100批，每批10000条
        main_values = []
        index_values = {i: [] for i in range(10)}
        
        for i in range(10000):
            phone = generate_phone_number()
            suffix = phone[-4:]
            table_index = int(suffix) % 10
            
            main_values.append((phone, f"user_{batch * 10000 + i}"))
            index_values[table_index].append((suffix, batch * 10000 + i + 1, phone))
        
        # 批量插入
        cursor.executemany("INSERT INTO users_main (phone_number, username) VALUES (%s, %s)", main_values)
        
        for table_idx, values in index_values.items():
            if values:
                sql = f"INSERT INTO phone_index_{table_idx} (phone_suffix, user_id, phone_number) VALUES (%s, %s, %s)"
                cursor.executemany(sql, values)
        
        conn.commit()
        
        if (batch + 1) % 10 == 0:
            elapsed = time.time() - start_time
            print(f"进度: {(batch + 1) * 10000}/1000000 ({(batch + 1) * 10}%), 耗时: {elapsed:.2f}秒")
    
    total_time = time.time() - start_time
    print(f"数据生成完成! 总耗时: {total_time:.2f}秒")
    
    # 显示统计信息
    cursor.execute("SELECT COUNT(*) FROM users_main")
    print(f"主表总记录数: {cursor.fetchone()[0]}")
    
    for i in range(10):
        cursor.execute(f"SELECT COUNT(*) FROM phone_index_{i}")
        print(f"索引表 {i} 记录数: {cursor.fetchone()[0]}")
    
    conn.close()

def generate_phone_number():
    """生成随机手机号"""
    prefixes = ['130', '131', '132', '133', '134', '135', '136', '137', '138', '139',
               '150', '151', '152', '153', '155', '156', '157', '158', '159',
               '180', '181', '182', '183', '184', '185', '186', '187', '188', '189']
    prefix = random.choice(prefixes)
    return f"{prefix}{random.randint(1000,9999)}{random.randint(1000,9999)}"
```

## 实战测试结果分析

### 数据生成性能

运行数据生成脚本的实际结果：
```
开始生成 1000000 条测试数据...
进度: 100000/1000000 (10.0%), 耗时: 32.92秒
进度: 200000/1000000 (20.0%), 耗时: 47.69秒
...
进度: 1000000/1000000 (100.0%), 耗时: 392.31秒
数据生成完成! 总耗时: 392.31秒

主表总记录数: 1000000
索引表 0 记录数: 99823
索引表 1 记录数: 100117
索引表 2 记录数: 99999
索引表 3 记录数: 100378
索引表 4 记录数: 100168
索引表 5 记录数: 99684
索引表 6 记录数: 99820
索引表 7 记录数: 100412
索引表 8 记录数: 99590
索引表 9 记录数: 100009
```

**关键发现**：数据分布非常均匀，验证了手机尾号的自然均匀分布特性。

### 查询性能测试脚本

```python
import mysql.connector
import time
import random
from concurrent.futures import ThreadPoolExecutor, as_completed

def query_performance_test():
    """查询性能测试"""
    conn = mysql.connector.connect(
        host='localhost', user='root',
        password='your_password', database='phone_system'
    )
    cursor = conn.cursor(dictionary=True)
    
    # 单次查询测试
    print("=== 单个查询测试 ===")
    start_time = time.time()
    cursor.execute("""
        SELECT ui.phone_suffix, ui.phone_number, um.username
        FROM phone_index_4 ui
        JOIN users_main um ON ui.user_id = um.user_id
        WHERE ui.phone_suffix = '1234'
        ORDER BY ui.id DESC
        LIMIT 20
    """)
    results = cursor.fetchall()
    query_time = (time.time() - start_time) * 1000
    
    print(f"查询成功: 找到{len(results)}条记录, 耗时{query_time:.2f}毫秒")
    for i, row in enumerate(results[:3]):
        print(f"  {i+1}. {row['phone_number']} - {row['username']}")
    
    # 并发查询测试
    print("\n开始并发查询测试:")
    concurrent_users = 10
    queries_per_user = 5
    
    def worker(user_id):
        results = []
        for _ in range(queries_per_user):
            suffix = f"{random.randint(0,9999):04d}"
            table_index = int(suffix) % 10
            
            start_time = time.time()
            cursor.execute(f"""
                SELECT COUNT(*) as cnt 
                FROM phone_index_{table_index} 
                WHERE phone_suffix = %s
            """, (suffix,))
            count = cursor.fetchone()['cnt']
            query_time = (time.time() - start_time) * 1000
            
            results.append({
                'suffix': suffix,
                'table_index': table_index,
                'query_time': query_time,
                'count': count
            })
        return results
    
    start_time = time.time()
    with ThreadPoolExecutor(max_workers=concurrent_users) as executor:
        futures = [executor.submit(worker, i) for i in range(concurrent_users)]
        all_results = []
        for future in as_completed(futures):
            all_results.extend(future.result())
    
    total_time = time.time() - start_time
    query_times = [r['query_time'] for r in all_results]
    
    print(f"总查询数: {len(all_results)}")
    print(f"总耗时: {total_time:.2f}秒")
    print(f"平均QPS: {len(all_results)/total_time:.2f}")
    print(f"平均查询时间: {sum(query_times)/len(query_times):.2f}毫秒")
    print(f"最快查询: {min(query_times):.2f}毫秒")
    print(f"最慢查询: {max(query_times):.2f}毫秒")
    
    conn.close()

# 性能对比测试
def compare_methods():
    """对比异构索引和LIKE查询性能"""
    print("开始性能对比测试...")
    
    # 测试异构索引
    print("\n异构索引方案:")
    test_heterogeneous()
    
    # 测试LIKE查询
    print("\nLIKE查询方案:")
    test_like_query()

def test_heterogeneous():
    """测试异构索引性能"""
    conn = mysql.connector.connect(...)
    cursor = conn.cursor(dictionary=True)
    
    start_time = time.time()
    query_count = 15
    
    for _ in range(query_count):
        suffix = f"{random.randint(0,9999):04d}"
        table_index = int(suffix) % 10
        cursor.execute(f"""
            SELECT 1 FROM phone_index_{table_index} 
            WHERE phone_suffix = %s LIMIT 1
        """, (suffix,))
    
    total_time = time.time() - start_time
    print(f"平均查询时间: {total_time*1000/query_count:.2f}毫秒")
    print(f"QPS: {query_count/total_time:.2f}")
    
    conn.close()
```

### 实际测试结果分析

**首次测试结果：**
```
=== 单个查询测试 ===
查询成功: 找到20条记录, 耗时61.40毫秒
前3条结果:
  1. 13434421234 - user_982255
  2. 13820691234 - user_951705
  3. 18397591234 - user_951226

开始并发查询测试:
总查询数: 50
成功查询: 50
失败查询: 0
总耗时: 0.52秒
平均QPS: 96.32
平均查询时间: 86.47毫秒
最快查询: 1.00毫秒
最慢查询: 444.52毫秒
```

**第二次测试（缓存预热后）：**
```
=== 单个查询测试 ===
查询成功: 找到20条记录, 耗时1.03毫秒
开始并发查询测试:
总查询数: 50
成功查询: 50
总耗时: 0.83秒
平均QPS: 60.26
平均查询时间: 137.94毫秒
最快查询: 1.00毫秒
```

**性能对比测试结果：**
```
异构索引方案:
平均查询时间: 13.40毫秒
QPS: 189.12

LIKE查询方案:  
平均查询时间: 224.54毫秒
QPS: 20.47
```


![4dfe34cc70ee38.png](/static/img/672ac2a5cf5bdfcdbd81715a6a77bf59.4dfe34cc70ee38.webp)


## 架构优势深度解析

### 1. 避免广播查询
传统分库分表按user_id分片，按尾号查询需要扫描所有分片。异构索引通过独立的尾号分片，实现**精准路由**，查询只会命中单个分表。


![65b80ef1ee166.png](/static/img/e76eab09ea28f34e1edb3152cc327632.65b80ef1ee166.webp)


### 2. 线性扩展能力
当数据量继续增长时，只需增加异构索引表的分片数量即可。路由算法`尾号 % 分片数`保证数据均匀分布。

### 3. 实际性能提升
基于测试数据，异构索引方案相比LIKE查询：
- **查询速度提升约17倍**（13.4ms vs 224.5ms）
- **QPS提升约9倍**（189 vs 20）

## 生产环境实战经验

### 数据一致性保障
```python
def insert_user_transactional(phone, username):
    """使用事务保证数据一致性"""
    conn = mysql.connector.connect(...)
    try:
        conn.start_transaction()
        
        # 插入主表
        cursor.execute("INSERT INTO users_main (phone_number, username) VALUES (%s, %s)", 
                      (phone, username))
        user_id = cursor.lastrowid
        
        # 插入索引表
        suffix = phone[-4:]
        table_index = int(suffix) % 10
        cursor.execute(f"""
            INSERT INTO phone_index_{table_index} 
            (phone_suffix, user_id, phone_number) VALUES (%s, %s, %s)
        """, (suffix, user_id, phone))
        
        conn.commit()
    except Exception as e:
        conn.rollback()
        raise e
    finally:
        conn.close()
```

### 遇到的实战问题及解决方案

**问题1：首次查询性能波动**
- **现象**：首次查询60ms，后续查询1ms
- **原因**：数据库缓存未命中
- **解决**：生产环境通过预热缓存解决

**问题2：偶发性慢查询**  
- **现象**：95%查询很快，偶有400ms+慢查询
- **解决**：设置超时时间和重试机制

**问题3：数据分布验证**
- **验证**：实际测试证实尾号分布均匀，各分表数据量基本一致
- **意义**：为架构设计提供了数据支撑

## 总结与展望

通过这次从理论到实战的完整探索，我深刻体会到异构索引架构在海量数据查询中的价值。关键收获包括：

1. **理论验证**：手机尾号的天然均匀分布是架构设计的"金钥匙"
2. **实战检验**：精准路由避免了分布式系统最头疼的广播查询
3. **性能证实**：简单的取模分表在实际中表现惊人地好

**生产环境建议：**
- 实际使用1000个分表（测试用了10个）
- 添加连接池和缓存机制
- 设置完善的监控告警系统

这个方案不仅适用于手机尾号查询，还可以推广到各种需要按特定维度快速查询海量数据的场景。架构的本质是权衡艺术，异构索引用适度的复杂度换来了巨大的性能提升。

感谢：https://mp.weixin.qq.com/s/QraLp40GFEnSVwJ1lFEIRg 

*（完整代码和测试数据已在实际环境中验证，可直接用于生产环境参考）*

10亿手机号毫秒级查询：从理论到实战的异构索引架构完整指南

# Nginx 动态代理访问子节点网页完整流程

## 一、环境准备
1. **服务器要求**：
   - A 服务器（需安装 Nginx，且能访问 A1/A2/A3 子节点）
   - B 服务器（需能访问 A 服务器的 8080 端口）
   - 确保子节点（如 A1）的网页服务已启动（如 HTTP 80 端口）



2. **软件安装**：
   - 在 A 服务器安装 Nginx：
     ```bash
     # Ubuntu/Debian
     sudo apt update && sudo apt install nginx
     
     # CentOS
     sudo yum install epel-release && sudo yum install nginx
     ```

3. **防火墙设置**：
   - 放行 A 服务器的 8080 端口：
     ```bash
     # Ubuntu/Debian（UFW）
     sudo ufw allow 8080/tcp
     
     # CentOS（Firewalld）
     sudo firewall-cmd --add-port=8080/tcp --permanent
     sudo firewall-cmd --reload
     ```


## 二、A 服务器 Nginx 配置

### 1. 打开配置文件
```bash
sudo nano /etc/nginx/nginx.conf
```

### 2. 添加代理配置
在 `http` 块中添加以下内容：
```nginx
http {
    # 其他原有配置...

    server {
        listen 8080;  # 监听端口，B 服务器将访问此端口
        server_name _;  # 允许所有域名访问

        location /proxy {
            # 从 URL 参数获取子节点 IP 和端口
            set $target_ip $arg_ip;
            set $target_port $arg_port;

            # 验证参数是否存在
            if ($target_ip = "") {
                return 400 "Error: Please provide 'ip' parameter";
            }

            if ($target_port = "") {
                set $target_port 80;  # 默认端口为 80
            }

            # 反向代理到目标子节点
            proxy_pass http://$target_ip:$target_port;

            # 保留原始请求头
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}
```

### 3. 保存并重启 Nginx
```bash
sudo systemctl restart nginx
```


## 三、B 服务器访问方法

### 1. 直接通过浏览器访问
在 B 服务器的浏览器中输入：
```
http://A服务器IP:8080/proxy?ip=子节点IP&port=子节点端口
```
- 示例：访问 A1 的 80 端口网页：
  ```
  http://192.168.1.100:8080/proxy?ip=192.168.1.101&port=80
  ```

### 2. 使用 curl 命令验证
```bash
curl "http://A服务器IP:8080/proxy?ip=192.168.1.101&port=80"
```


## 四、动态 IP 处理方案

### 1. 使用动态 DNS（DDNS）
如果子节点（如 A1）的 IP 经常变化，建议搭配 DDNS 服务：
1. 为子节点申请一个固定域名（如 `a1.mydomain.com`）
2. 在子节点安装 DDNS 客户端，自动更新 IP 到域名
3. 修改 Nginx 配置中的 `$target_ip` 为域名：
   ```nginx
   proxy_pass http://$arg_ip:$target_port;  # 直接使用 URL 中的域名参数
   ```

### 2. 动态参数传递
每次访问时直接传递最新 IP：
```
http://A服务器IP:8080/proxy?ip=192.168.1.102&port=80  # 假设 A1 的新 IP 是 192.168.1.102
```


## 五、注意事项

1. **HTTPS 支持**：
   - 如果子节点使用 HTTPS（443 端口），修改 Nginx 配置为：
     ```nginx
     proxy_pass https://$target_ip:$target_port;
     ```
   - 需在 A 服务器安装 SSL 证书（如 Let's Encrypt）

2. **端口冲突**：
   - 确保 A 服务器的 8080 端口未被其他服务占用

3. **安全加固**：
   - 限制仅允许 B 服务器访问 A 的 8080 端口：
     ```nginx
     allow 192.168.1.200;  # B 服务器的 IP
     deny all;
     ```


## 六、常见问题处理

1. **404 错误**：
   - 检查 Nginx 配置是否正确，特别是 `location /proxy` 的路径

2. **502 Bad Gateway**：
   - 确认子节点 IP 和端口是否可达
   - 检查子节点的网页服务是否正常运行

3. **跨域问题**：
   - 在 Nginx 配置中添加跨域头：
     ```nginx
     add_header Access-Control-Allow-Origin *;
     ```


如果需要 B 服务器代理 B1/B2/B3，只需在 B 服务器重复上述配置，A 服务器通过 B 的 8080 端口访问即可。

Nginx 动态代理访问子节点网页完整流程

# 📱 使用 Kivy 将 Python 应用打包成 Android APK 完整指南

## 1 环境准备与安装

### 1.1 系统要求

- **推荐操作系统**：Ubuntu 20.04 或更高版本（在 Linux 环境下最为稳定）
- **Windows 用户**：建议使用 WSL（Windows Subsystem for Linux）或虚拟机
- **Python 版本**：Python 3.8 或更高版本



### 1.2 安装必要依赖

在 Ubuntu/Debian 系统上，打开终端并运行以下命令安装所有必需的依赖：

```bash
# 更新系统包管理器
sudo apt update
sudo apt upgrade -y

# 安装编译工具和依赖
sudo apt install -y python3-pip python3-setuptools python3-virtualenv git zip unzip
sudo apt install -y build-essential libffi-dev zlib1g-dev libncursesw5-dev
sudo apt install -y libgdbm-dev libc6-dev zlib1g-dev libsqlite3-dev tk-dev
sudo apt install -y libssl-dev openssl cython libxml2-dev libxslt1-dev

# 安装图形和 OpenGL 相关依赖
sudo apt install -y libgl1-mesa-dev libgles2-mesa-dev

# 安装 Java 开发工具包
sudo apt install -y openjdk-11-jdk
```

### 1.3 安装 Kivy 和 Buildozer

```bash
# 安装 Kivy
pip3 install kivy

# 安装 Buildozer
pip3 install buildozer
```

## 2 创建 Kivy 应用

### 2.1 简单的示例应用

创建一个项目目录，并在其中创建 `main.py` 文件：

```python
from kivy.app import App
from kivy.uix.button import Button

class MyApp(App):
    def build(self):
        return Button(text='Hello, Kivy!')

if __name__ == '__main__':
    MyApp().run()
```

### 2.2 测试应用

在继续之前，先测试你的应用是否能正常运行：

```bash
python3 main.py
```

如果一切正常，你应该能看到一个显示 "Hello, Kivy!" 按钮的窗口。

## 3 配置 Buildozer

### 3.1 初始化 Buildozer

在项目目录中运行以下命令：

```bash
buildozer init
```

这会在当前目录生成一个 `buildozer.spec` 文件，其中包含了所有的构建配置。

### 3.2 关键配置说明

以下表格列出了 `buildozer.spec` 文件中需要关注和可能修改的重要配置项：

| 配置项 | 描述 | 示例值 |
|--------|------|--------|
| `title` | 应用名称 | `My Kivy App` |
| `package.name` | 应用包名（全部小写） | `myapp` |
| `package.domain` | 应用域名（组织反域名） | `org.example` |
| `source.dir` | 源代码目录 | `.` |
| `source.include_exts` | 包含的文件类型 | `py,png,jpg,kv,atlas,txt` |
| `version` | 应用版本号 | `0.1` |
| `requirements` | Python 依赖 | `python3,kivy,cython` |
| `android.permissions` | Android 权限 | `INTERNET, WRITE_EXTERNAL_STORAGE` |
| `presplash.filename` | 启动画面图片 | `%(source.dir)s/data/presplash.png` |
| `icon.filename` | 应用图标 | `%(source.dir)s/data/icon.png` |

### 3.3 常用配置修改

根据你的需求修改 `buildozer.spec` 文件：

```ini
[app]
title = My Kivy App
package.name = myapp
package.domain = org.example
source.dir = .
source.include_exts = py,png,jpg,kv,atlas,txt
version = 0.1
requirements = python3,kivy,cython

[buildozer]
log_level = 2

[app::android]
permissions = INTERNET

[app::android:meta_data]
```

如果你需要访问网络、存储等功能，记得在 `android.permissions` 中添加相应权限。

## 4 打包 APK

### 4.1 首次构建

在项目目录中运行以下命令开始构建：

```bash
buildozer -v android debug
```

**注意**：
- 第一次构建需要下载 Android SDK、NDK 和其他依赖，可能需要 **30-60 分钟**，具体取决于你的网络速度
- 确保网络连接稳定，因为需要从 GitHub 和其他源下载大量文件

### 4.2 网络问题解决方案

如果在国内或遇到网络问题，可以尝试以下方法：

```bash
# 设置 HTTP/HTTPS 代理（根据你的实际情况修改）
export http_proxy=http://127.0.0.1:38457
export https_proxy=http://127.0.0.1:38457

# 或者使用 FastGithub 等加速工具
```

### 4.3 构建类型

- **调试版本**：`buildozer -v android debug` - 包含调试信息，未签名
- **发布版本**：`buildozer -v android release` - 需要签名，用于上架应用商店

## 5 定位和获取 APK 文件

构建成功后，APK 文件会生成在 `bin` 目录中：

- **调试 APK**：`bin/MyApp-0.1-debug.apk`
- **发布 APK**：`bin/MyApp-0.1-release.apk`

## 6 安装和测试

### 6.1 安装到安卓设备

**方法一：使用 ADB 安装**
```bash
adb install bin/MyApp-0.1-debug.apk
```

**方法二：手动安装**
1. 将 APK 文件传输到安卓手机
2. 在手机上启用"未知来源"安装权限
3. 使用文件管理器找到 APK 文件并安装

### 6.2 查看日志

如果应用运行异常，可以通过以下命令查看日志：
```bash
adb logcat | grep python
```

## 7 常见问题与解决方案

以下表格汇总了打包过程中可能遇到的常见问题及解决方法：

| 问题现象 | 可能原因 | 解决方案 |
|---------|----------|----------|
| SSL/SSH 错误 | Ubuntu 版本过旧 | 使用 Ubuntu 18.04 或更高版本 |
| 下载过程中失败 | 网络不稳定 | 设置代理或使用加速器 |
| 文件已存在错误 | 上次下载不完整 | 删除 `.buildozer` 文件夹重新下载 |
| 提取压缩包失败 | 下载文件损坏 | 手动下载并替换对应文件 |
| 应用启动崩溃 | 缺少依赖库 | 检查 `requirements` 是否包含所有依赖 |
| 预加载画面卡住 | 资源文件问题 | 检查图标和启动画面文件格式 |

### 7.1 清理构建缓存

如果遇到构建问题，可以尝试清理缓存：

```bash
# 清理构建文件
buildozer android clean

# 完全清理（包括下载的依赖）
buildozer distclean
```

### 7.2 添加缺失的依赖

如果应用使用了其他 Python 库，确保在 `buildozer.spec` 的 `requirements` 中添加它们：

```ini
requirements = python3,kivy,cython,requests,pillow
```

## 8 高级配置

### 8.1 应用签名（发布版本）

要对发布版 APK 进行签名，首先创建密钥库：

```bash
keytool -genkey -v -keystore my-release-key.keystore -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias
```

然后在 `buildozer.spec` 中配置：

```ini
[app]
# 发布构建配置
buildozer.release_keystore = /path/to/my-release-key.keystore
buildozer.release_keystore_password = YOUR_PASSWORD
buildozer.release_key_alias = my-alias
buildozer.release_key_password = YOUR_PASSWORD
```

### 8.2 优化 APK 大小

```ini
[app]
# 只指定需要的架构
android.arch = armeabi-v7a

# 排除不必要的文件
source.exclude_exts = .pyc,.git,.gitignore
```

## 总结

通过以上步骤，应该能够成功将 Kivy 应用打包为 Android APK。关键要点：

1. **环境准备**：使用推荐的 Ubuntu 版本可以避免多数问题
2. **网络稳定**：首次构建需要下载大量依赖，稳定的网络至关重要
3. **耐心调试**：如果遇到问题，查看终端输出日志，通常会有详细的错误信息

如果在具体步骤中遇到问题，可以查阅 [Buildozer 官方文档](https://buildozer.readthedocs.io/) 或 Kivy 社区获取更多帮助。

使用 Kivy 将 Python 应用打包成 Android APK 完整指南

## 1. 布局基础属性

### 1.1 `direction` - 布局方向
**作用**：定义子元素的排列方向



**可选值**：
- `ROW`：水平排列（默认）
- `COLUMN`：垂直排列

```python
import toga
from toga.style import Pack
from toga.style.pack import ROW, COLUMN

def build(app):
    # 水平排列的容器
    horizontal_box = toga.Box(style=Pack(direction=ROW, padding=10))
    btn1 = toga.Button("按钮1", style=Pack(padding=5))
    btn2 = toga.Button("按钮2", style=Pack(padding=5))
    horizontal_box.add(btn1)
    horizontal_box.add(btn2)
    
    # 垂直排列的容器  
    vertical_box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    btn3 = toga.Button("按钮3", style=Pack(padding=5))
    btn4 = toga.Button("按钮4", style=Pack(padding=5))
    vertical_box.add(btn3)
    vertical_box.add(btn4)
    
    # 主容器
    main_box = toga.Box(style=Pack(direction=COLUMN))
    main_box.add(horizontal_box)
    main_box.add(vertical_box)
    
    return main_box
```

### 1.2 `display` - 显示方式
**作用**：控制元素是否显示

**可选值**：
- `PACK`：正常显示（默认）
- `NONE`：隐藏元素（不占空间）

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    visible_btn = toga.Button("可见按钮", style=Pack(padding=5))
    hidden_btn = toga.Button("隐藏按钮", style=Pack(display=None, padding=5))
    
    box.add(visible_btn)
    box.add(hidden_btn)  # 这个按钮不会显示
    
    return box
```

### 1.3 `visibility` - 可见性
**作用**：控制元素可见性

**可选值**：
- `VISIBLE`：可见（默认）
- `HIDDEN`：隐藏（但仍占空间）

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    visible_btn = toga.Button("可见按钮", style=Pack(padding=5))
    # 隐藏但仍占空间的按钮
    hidden_btn = toga.Button("隐藏但占位", style=Pack(visibility='hidden', padding=5))
    another_btn = toga.Button("另一个按钮", style=Pack(padding=5))
    
    box.add(visible_btn)
    box.add(hidden_btn)  # 看不到但会占位置
    box.add(another_btn)
    
    return box
```

## 2. 对齐与分布属性

### 2.1 `align_items` - 交叉轴对齐
**作用**：在交叉轴上对齐子元素

**可选值**：
- `START`：起始对齐
- `CENTER`：居中对齐  
- `END`：末端对齐

```python
from toga.style.pack import START, CENTER, END

def build(app):
    main_box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 起始对齐（顶部/左侧）
    start_box = toga.Box(
        style=Pack(direction=ROW, align_items=START, height=100, background_color='lightgray', padding=5)
    )
    start_box.add(toga.Button("Start", style=Pack(width=80, height=30)))
    
    # 居中对齐
    center_box = toga.Box(
        style=Pack(direction=ROW, align_items=CENTER, height=100, background_color='lightblue', padding=5)
    )
    center_box.add(toga.Button("Center", style=Pack(width=80, height=30)))
    
    # 末端对齐（底部/右侧）
    end_box = toga.Box(
        style=Pack(direction=ROW, align_items=END, height=100, background_color='lightgreen', padding=5)
    )
    end_box.add(toga.Button("End", style=Pack(width=80, height=30)))
    
    main_box.add(toga.Label("align_items 示例:", style=Pack(padding_bottom=5)))
    main_box.add(start_box)
    main_box.add(center_box)
    main_box.add(end_box)
    
    return main_box
```

### 2.2 `justify_content` - 主轴分布
**作用**：在主轴上分布子元素

**可选值**：
- `START`：起始分布（默认）
- `CENTER`：居中分布
- `END`：末端分布

```python
def build(app):
    main_box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 起始分布
    start_box = toga.Box(
        style=Pack(direction=ROW, justify_content=START, width=300, background_color='lightgray', padding=5)
    )
    for i in range(3):
        start_box.add(toga.Button(f"Btn{i}", style=Pack(width=60, margin=2)))
    
    # 居中分布
    center_box = toga.Box(
        style=Pack(direction=ROW, justify_content=CENTER, width=300, background_color='lightblue', padding=5)
    )
    for i in range(3):
        center_box.add(toga.Button(f"Btn{i}", style=Pack(width=60, margin=2)))
    
    # 末端分布
    end_box = toga.Box(
        style=Pack(direction=ROW, justify_content=END, width=300, background_color='lightgreen', padding=5)
    )
    for i in range(3):
        end_box.add(toga.Button(f"Btn{i}", style=Pack(width=60, margin=2)))
    
    main_box.add(toga.Label("justify_content 示例:", style=Pack(padding_bottom=5)))
    main_box.add(start_box)
    main_box.add(center_box)
    main_box.add(end_box)
    
    return main_box
```

## 3. 尺寸与弹性属性

### 3.1 `width` / `height` - 固定尺寸
**作用**：设置元素的固定宽度和高度

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 固定宽度的按钮
    fixed_btn = toga.Button(
        "固定宽度200", 
        style=Pack(width=200, height=40, background_color='lightblue', padding=5)
    )
    
    # 固定高度的按钮
    tall_btn = toga.Button(
        "固定高度80", 
        style=Pack(width=120, height=80, background_color='lightgreen', padding=5)
    )
    
    box.add(fixed_btn)
    box.add(tall_btn)
    
    return box
```

### 3.2 `flex` - 弹性布局
**作用**：在可用空间中按比例分配空间

**注意**：只在未设置明确宽高时生效

```python
def build(app):
    box = toga.Box(style=Pack(direction=ROW, height=60, padding=10, background_color='gray'))
    
    # flex=1 的元素
    flex1_btn = toga.Button(
        "flex=1", 
        style=Pack(flex=1, margin=2, background_color='lightblue')
    )
    
    # flex=2 的元素（占用两倍空间）
    flex2_btn = toga.Button(
        "flex=2", 
        style=Pack(flex=2, margin=2, background_color='lightgreen')
    )
    
    # flex=1 的元素
    flex1_btn2 = toga.Button(
        "flex=1", 
        style=Pack(flex=1, margin=2, background_color='lightcoral')
    )
    
    box.add(flex1_btn)
    box.add(flex2_btn)
    box.add(flex1_btn2)
    
    return box
```

## 4. 间距属性

### 4.1 `margin` 系列 - 外边距
**作用**：设置元素的外边距

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=20, background_color='lightgray'))
    
    # 不同的外边距设置
    margins = [
        ("四周10px", {"margin": 10}),
        ("上下10px, 左右20px", {"margin": (10, 20)}),
        ("上10px, 右20px, 下30px, 左40px", {"margin": (10, 20, 30, 40)}),
        ("仅右边距50px", {"margin_right": 50}),
    ]
    
    for text, margin_style in margins:
        btn = toga.Button(
            text, 
            style=Pack(
                background_color='white', 
                padding=5,
                **margin_style
            )
        )
        box.add(btn)
    
    return box
```

## 5. 外观属性

### 5.1 `color` - 文字颜色
**作用**：设置文字颜色

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    colors = [
        ("红色文字", "red"),
        ("蓝色文字", "blue"),
        ("绿色文字", "green"),
        ("十六进制颜色", "#FF00FF"),
    ]
    
    for text, color in colors:
        label = toga.Label(
            text, 
            style=Pack(color=color, padding=5, font_size=14)
        )
        box.add(label)
    
    return box
```

### 5.2 `background_color` - 背景颜色
**作用**：设置背景颜色

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    backgrounds = [
        ("浅蓝背景", "lightblue"),
        ("浅绿背景", "lightgreen"),
        ("浅珊瑚色", "lightcoral"),
        ("黄色背景", "yellow"),
    ]
    
    for text, bg_color in backgrounds:
        btn = toga.Button(
            text, 
            style=Pack(
                background_color=bg_color, 
                padding=10, 
                margin=5,
                color='black'  # 确保文字可读
            )
        )
        box.add(btn)
    
    return box
```

## 6. 文本属性

### 6.1 `text_align` - 文本对齐
**作用**：设置文本水平对齐方式

```python
from toga.style.pack import LEFT, RIGHT, CENTER, JUSTIFY

def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10, width=300))
    
    alignments = [
        ("左对齐文本", LEFT),
        ("居中对齐文本", CENTER),
        ("右对齐文本", RIGHT),
        ("两端对齐文本", JUSTIFY),
    ]
    
    for text, alignment in alignments:
        label = toga.Label(
            text, 
            style=Pack(
                text_align=alignment,
                padding=10,
                background_color='lightgray',
                width=280,
                margin=2
            )
        )
        box.add(label)
    
    return box
```

### 6.2 `text_direction` - 文本方向
**作用**：设置文本阅读方向

```python
from toga.style.pack import LTR, RTL

def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 从左到右（默认）
    ltr_label = toga.Label(
        "从左到右文本 (LTR)", 
        style=Pack(text_direction=LTR, padding=10, background_color='lightblue')
    )
    
    # 从右到左
    rtl_label = toga.Label(
        "从右到左文本 (RTL)", 
        style=Pack(text_direction=RTL, padding=10, background_color='lightgreen')
    )
    
    box.add(ltr_label)
    box.add(rtl_label)
    
    return box
```

## 7. 字体属性

### 7.1 字体相关属性
**作用**：设置字体系列、样式、大小等

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 字体系列
    font_family_label = toga.Label(
        "自定义字体: Arial", 
        style=Pack(font_family='Arial', font_size=14, padding=5)
    )
    
    # 字体大小
    font_size_label = toga.Label(
        "大号字体: 20pt", 
        style=Pack(font_size=20, padding=5)
    )
    
    # 字体粗细
    font_weight_label = toga.Label(
        "粗体文字", 
        style=Pack(font_weight='bold', padding=5)
    )
    
    # 字体样式
    font_style_label = toga.Label(
        "斜体文字", 
        style=Pack(font_style='italic', padding=5)
    )
    
    # 组合使用
    combined_label = toga.Label(
        "组合样式: 粗体+斜体+大号", 
        style=Pack(
            font_weight='bold', 
            font_style='italic', 
            font_size=16,
            padding=10,
            background_color='lightyellow'
        )
    )
    
    box.add(font_family_label)
    box.add(font_size_label)
    box.add(font_weight_label)
    box.add(font_style_label)
    box.add(combined_label)
    
    return box
```

## 8. 综合示例

下面是一个结合多种属性的完整示例：

```python
import toga
from toga.style import Pack
from toga.style.pack import COLUMN, ROW, CENTER, START, END

def build(app):
    # 主容器 - 垂直布局
    main_box = toga.Box(style=Pack(direction=COLUMN, padding=20))
    
    # 标题
    title = toga.Label(
        "用户信息表单",
        style=Pack(
            text_align=CENTER,
            font_size=20,
            font_weight='bold',
            padding_bottom=20,
            color='navy'
        )
    )
    
    # 姓名行 - 水平布局
    name_box = toga.Box(style=Pack(direction=ROW, padding=10))
    name_label = toga.Label(
        "姓名:",
        style=Pack(width=80, padding_right=10, font_weight='bold')
    )
    name_input = toga.TextInput(
        style=Pack(flex=1, padding=8)
    )
    name_box.add(name_label)
    name_box.add(name_input)
    
    # 邮箱行 - 水平布局  
    email_box = toga.Box(style=Pack(direction=ROW, padding=10))
    email_label = toga.Label(
        "邮箱:",
        style=Pack(width=80, padding_right=10, font_weight='bold')
    )
    email_input = toga.TextInput(
        style=Pack(flex=1, padding=8)
    )
    email_box.add(email_label)
    email_box.add(email_input)
    
    # 按钮容器 - 水平布局，右对齐
    button_box = toga.Box(
        style=Pack(
            direction=ROW, 
            justify_content=END,
            padding_top=20
        )
    )
    
    cancel_btn = toga.Button(
        "取消",
        style=Pack(
            padding=15,
            margin_left=10,
            background_color='#e74c3c',
            color='white',
            width=100
        )
    )
    
    submit_btn = toga.Button(
        "提交",
        style=Pack(
            padding=15,
            margin_left=10,
            background_color='#3498db',
            color='white',
            width=100
        )
    )
    
    button_box.add(cancel_btn)
    button_box.add(submit_btn)
    
    # 将所有元素添加到主容器
    main_box.add(title)
    main_box.add(name_box)
    main_box.add(email_box)
    main_box.add(button_box)
    
    return main_box

def main():
    app = toga.App('综合示例', 'org.example.comprehensive', startup=build)
    return app

if __name__ == '__main__':
    main().main_loop()
```

## 重要注意事项

1. **版本兼容性**：确保使用的 Toga 版本与文档匹配
2. **属性优先级**：某些属性会相互影响，如 `flex` 只在未设置明确宽高时生效
3. **布局嵌套**：通过组合 `ROW` 和 `COLUMN` 方向可以创建复杂布局
4. **调试技巧**：给容器设置背景色可以直观看到布局边界

每个属性都可以单独使用或组合使用，通过不断实践可以掌握 Pack 布局系统的强大功能。

10亿手机号毫秒级查询：从理论到实战的异构索引架构完整指南

Nginx 动态代理访问子节点网页完整流程

一、环境准备

📱 使用 Kivy 将 Python 应用打包成 Android APK 完整指南

1 环境准备与安装

1.1 系统要求

1. 布局基础属性

1.1 direction - 布局方向

1.1 `direction` - 布局方向