ThinkPHP8 ORM优化与数据库操作技巧实战指南

ThinkPHP8基于think-orm3.0版本，在ORM性能和功能上都有了显著提升 3。本文将深入探讨ThinkPHP8中ORM的优化技巧、数据库查询性能提升方法以及复杂关联场景的处理方案，帮助开发者构建高性能的数据库应用。

ThinkPHP8 ORM新特性

核心改进

ThinkPHP8的ORM系统基于PHP8.0+重构，主要特性包括 3：

• 依赖think-orm3.0版本：提供更强大的ORM功能
• 升级PSR依赖：更好的标准化支持
• 6.0/6.1无缝升级：平滑的版本迁移
• PHP8.0+优化：充分利用PHP8新特性

模型关联优化

通过模型关联操作把数据表的关联关系对象化，解决了大部分常用的关联场景，封装的关联操作比起常规的数据库联表操作更加智能和高效 2。

查询构建器优化技巧

基础查询优化

<?php
declare(strict_types=1);

namespace app\service;

use think\facade\Db;
use think\facade\Cache;
use think\Model;

/**
 * 数据库查询优化服务
 * 提供各种查询优化技巧和最佳实践
 */
class DatabaseOptimizationService
{
    /**
     * 使用索引优化查询
     * @param array $conditions 查询条件
     * @return array 查询结果
     */
    public function optimizedQuery(array $conditions): array
    {
        // 1. 使用索引字段进行查询
        $query = Db::name('users')
            ->field('id,username,email,status,created_at')
            ->where('status', 1); // status字段应该有索引
        
        // 2. 避免使用函数操作索引字段
        if (!empty($conditions['date_range'])) {
            // 错误示例：WHERE DATE(created_at) = '2024-01-01'
            // 正确示例：使用范围查询
            $query->whereBetween('created_at', [
                $conditions['date_range'][0] . ' 00:00:00',
                $conditions['date_range'][1] . ' 23:59:59'
            ]);
        }
        
        // 3. 使用复合索引优化多条件查询
        if (!empty($conditions['username']) && !empty($conditions['email'])) {
            // 确保(username, email)有复合索引
            $query->where([
                ['username', 'like', $conditions['username'] . '%'],
                ['email', '=', $conditions['email']]
            ]);
        }
        
        // 4. 使用LIMIT限制结果集大小
        $query->limit($conditions['limit'] ?? 20);
        
        return $query->select()->toArray();
    }
    
    /**
     * 分页查询优化
     * @param int $page 页码
     * @param int $limit 每页数量
     * @param array $conditions 查询条件
     * @return array 分页结果
     */
    public function optimizedPagination(int $page, int $limit, array $conditions = []): array
    {
        // 使用游标分页替代OFFSET分页（适用于大数据量）
        $lastId = $conditions['last_id'] ?? 0;
        
        $query = Db::name('articles')
            ->field('id,title,author_id,created_at,view_count')
            ->where('status', 1)
            ->where('id', '>', $lastId) // 使用主键游标
            ->order('id', 'asc')
            ->limit($limit);
        
        // 添加其他查询条件
        if (!empty($conditions['category_id'])) {
            $query->where('category_id', $conditions['category_id']);
        }
        
        if (!empty($conditions['keyword'])) {
            // 使用全文索引搜索（如果支持）
            $query->where('title|content', 'like', '%' . $conditions['keyword'] . '%');
        }
        
        $list = $query->select()->toArray();
        
        return [
            'list' => $list,
            'has_more' => count($list) === $limit,
            'last_id' => $list ? end($list)['id'] : $lastId
        ];
    }
    
    /**
     * 批量操作优化
     * @param array $data 批量数据
     * @return bool 操作结果
     */
    public function batchInsertOptimized(array $data): bool
    {
        // 1. 使用事务确保数据一致性
        Db::startTrans();
        
        try {
            // 2. 分批插入，避免单次插入数据过多
            $batchSize = 1000;
            $chunks = array_chunk($data, $batchSize);
            
            foreach ($chunks as $chunk) {
                // 3. 使用insertAll批量插入
                Db::name('user_logs')->insertAll($chunk);
            }
            
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            throw $e;
        }
    }
    
    /**
     * 聚合查询优化
     * @param array $conditions 查询条件
     * @return array 统计结果
     */
    public function aggregateQueryOptimized(array $conditions): array
    {
        // 使用缓存减少重复计算
        $cacheKey = 'stats_' . md5(serialize($conditions));
        
        return Cache::remember($cacheKey, function() use ($conditions) {
            $query = Db::name('orders')
                ->field([
                    'COUNT(*) as total_orders',
                    'SUM(amount) as total_amount',
                    'AVG(amount) as avg_amount',
                    'DATE(created_at) as order_date'
                ])
                ->where('status', 'completed');
            
            // 添加时间范围条件
            if (!empty($conditions['start_date'])) {
                $query->where('created_at', '>=', $conditions['start_date']);
            }
            
            if (!empty($conditions['end_date'])) {
                $query->where('created_at', '<=', $conditions['end_date']);
            }
            
            return $query->group('DATE(created_at)')
                ->order('order_date', 'desc')
                ->select()
                ->toArray();
        }, 300); // 缓存5分钟
    }
}

模型关联优化

解决复杂关联场景问题

在ThinkPHP8中，复杂的关联场景下可能会遇到查询语句表名生成异常的问题 1。以下是优化方案：

<?php
declare(strict_types=1);

namespace app\model;

use think\Model;
use think\model\relation\HasMany;
use think\model\relation\BelongsTo;
use think\model\relation\HasOne;

/**
 * 订单模型
 * 演示复杂关联场景的优化处理
 */
class Order extends Model
{
    protected $name = 'orders';
    
    protected $type = [
        'created_at' => 'datetime',
        'updated_at' => 'datetime',
        'amount' => 'decimal:2'
    ];
    
    /**
     * 订单详情关联
     * @return HasMany 一对多关联
     */
    public function details(): HasMany
    {
        return $this->hasMany(OrderDetails::class, 'order_number', 'order_number');
    }
    
    /**
     * 用户关联
     * @return BelongsTo 多对一关联
     */
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class, 'user_id', 'id');
    }
    
    /**
     * 优化的关联查询方法
     * 解决复杂关联场景下的表名生成问题
     * @param array $conditions 查询条件
     * @return array 查询结果
     */
    public static function getOrdersWithDetails(array $conditions = []): array
    {
        // 方案1：使用明确的表别名
        $query = self::alias('o')
            ->field('o.id,o.order_number,o.amount,o.status,o.created_at')
            ->with([
                'details' => function($query) {
                    $query->field('order_number,product_name,quantity,price');
                },
                'user' => function($query) {
                    $query->field('id,username,email');
                }
            ]);
        
        // 添加查询条件时使用表别名
        if (!empty($conditions['status'])) {
            $query->where('o.status', $conditions['status']);
        }
        
        if (!empty($conditions['user_id'])) {
            $query->where('o.user_id', $conditions['user_id']);
        }
        
        // 使用hasWhere时指定表别名
        if (!empty($conditions['min_quantity'])) {
            $query->hasWhere('details', function($query) use ($conditions) {
                $query->where('orderdetails.quantity', '>', $conditions['min_quantity']);
            });
        }
        
        return $query->select()->toArray();
    }
    
    /**
     * 使用withSum优化统计查询
     * @param array $conditions 查询条件
     * @return array 查询结果
     */
    public static function getOrdersWithSum(array $conditions = []): array
    {
        $query = self::alias('o')
            ->field('o.id,o.order_number,o.status,o.created_at')
            ->withSum(['details' => 'details_sum'], 'price')
            ->withCount(['details' => 'details_count']);
        
        // 解决withSum中表名问题的方法
        if (!empty($conditions['min_amount'])) {
            $query->hasWhere('details', function($query) use ($conditions) {
                // 明确指定表名避免歧义
                $query->where('orderdetails.price', '>', $conditions['min_amount']);
            });
        }
        
        if (!empty($conditions['order_number_prefix'])) {
            $query->where('o.order_number', 'like', $conditions['order_number_prefix'] . '%');
        }
        
        return $query->where('o.order_number', '<', 10120)
            ->select()
            ->toArray();
    }
    
    /**
     * 预加载优化
     * 避免N+1查询问题
     * @param array $orderIds 订单ID数组
     * @return array 查询结果
     */
    public static function getOrdersWithPreload(array $orderIds): array
    {
        return self::with([
            'details' => function($query) {
                $query->field('order_number,product_name,quantity,price,product_id')
                    ->with(['product' => function($q) {
                        $q->field('id,name,category_id');
                    }]);
            },
            'user' => function($query) {
                $query->field('id,username,email,phone');
            }
        ])
        ->whereIn('id', $orderIds)
        ->select()
        ->toArray();
    }
}

/**
 * 订单详情模型
 */
class OrderDetails extends Model
{
    protected $name = 'orderdetails';
    
    protected $type = [
        'price' => 'decimal:2',
        'quantity' => 'integer'
    ];
    
    /**
     * 商品关联
     * @return BelongsTo 多对一关联
     */
    public function product(): BelongsTo
    {
        return $this->belongsTo(Product::class, 'product_id', 'id');
    }
    
    /**
     * 订单关联
     * @return BelongsTo 多对一关联
     */
    public function order(): BelongsTo
    {
        return $this->belongsTo(Order::class, 'order_number', 'order_number');
    }
}

/**
 * 商品模型
 */
class Product extends Model
{
    protected $name = 'products';
    
    /**
     * 分类关联
     * @return BelongsTo 多对一关联
     */
    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class, 'category_id', 'id');
    }
}

关联查询性能优化

<?php
declare(strict_types=1);

namespace app\service;

use app\model\Order;
use app\model\User;
use think\facade\Cache;
use think\facade\Db;

/**
 * 关联查询优化服务
 * 提供高性能的关联查询解决方案
 */
class RelationQueryService
{
    /**
     * 优化的用户订单查询
     * @param int $userId 用户ID
     * @param array $options 查询选项
     * @return array 查询结果
     */
    public function getUserOrdersOptimized(int $userId, array $options = []): array
    {
        $cacheKey = "user_orders_{$userId}_" . md5(serialize($options));
        
        return Cache::remember($cacheKey, function() use ($userId, $options) {
            // 1. 使用预加载避免N+1问题
            $query = Order::with([
                'details' => function($query) {
                    $query->field('order_number,product_name,quantity,price')
                        ->limit(5); // 限制关联数据数量
                },
                'user' => function($query) {
                    $query->field('id,username,avatar');
                }
            ])
            ->field('id,order_number,user_id,amount,status,created_at')
            ->where('user_id', $userId);
            
            // 2. 添加状态过滤
            if (!empty($options['status'])) {
                $query->where('status', $options['status']);
            }
            
            // 3. 时间范围查询
            if (!empty($options['date_range'])) {
                $query->whereBetween('created_at', $options['date_range']);
            }
            
            // 4. 排序和分页
            $query->order('created_at', 'desc')
                ->limit($options['limit'] ?? 10);
            
            return $query->select()->toArray();
        }, 300);
    }
    
    /**
     * 复杂统计查询优化
     * @param array $conditions 查询条件
     * @return array 统计结果
     */
    public function getComplexStatistics(array $conditions = []): array
    {
        // 使用原生SQL优化复杂统计
        $sql = "
            SELECT 
                u.id,
                u.username,
                COUNT(o.id) as order_count,
                COALESCE(SUM(o.amount), 0) as total_amount,
                COALESCE(AVG(o.amount), 0) as avg_amount,
                MAX(o.created_at) as last_order_time
            FROM users u
            LEFT JOIN orders o ON u.id = o.user_id AND o.status = 'completed'
            WHERE u.status = 1
        ";
        
        $params = [];
        
        // 添加时间条件
        if (!empty($conditions['start_date'])) {
            $sql .= " AND o.created_at >= ?";
            $params[] = $conditions['start_date'];
        }
        
        if (!empty($conditions['end_date'])) {
            $sql .= " AND o.created_at <= ?";
            $params[] = $conditions['end_date'];
        }
        
        $sql .= "
            GROUP BY u.id, u.username
            HAVING order_count > 0
            ORDER BY total_amount DESC
            LIMIT 100
        ";
        
        return Db::query($sql, $params);
    }
    
    /**
     * 分层查询优化
     * 适用于深层关联查询
     * @param array $categoryIds 分类ID数组
     * @return array 查询结果
     */
    public function getProductsByCategoriesOptimized(array $categoryIds): array
    {
        // 第一层：获取分类信息
        $categories = Db::name('categories')
            ->field('id,name,parent_id')
            ->whereIn('id', $categoryIds)
            ->select()
            ->toArray();
        
        if (empty($categories)) {
            return [];
        }
        
        // 第二层：获取商品信息
        $products = Db::name('products')
            ->field('id,name,category_id,price,stock')
            ->whereIn('category_id', array_column($categories, 'id'))
            ->where('status', 1)
            ->order('sort desc, id desc')
            ->select()
            ->toArray();
        
        // 第三层：获取商品图片（如果需要）
        if (!empty($products)) {
            $productIds = array_column($products, 'id');
            $images = Db::name('product_images')
                ->field('product_id,image_url,sort')
                ->whereIn('product_id', $productIds)
                ->where('is_main', 1)
                ->select()
                ->toArray();
            
            // 组装数据
            $imageMap = array_column($images, 'image_url', 'product_id');
            foreach ($products as &$product) {
                $product['image'] = $imageMap[$product['id']] ?? '';
            }
        }
        
        // 组装最终结果
        $categoryMap = array_column($categories, null, 'id');
        $result = [];
        
        foreach ($products as $product) {
            $categoryId = $product['category_id'];
            if (!isset($result[$categoryId])) {
                $result[$categoryId] = [
                    'category' => $categoryMap[$categoryId],
                    'products' => []
                ];
            }
            $result[$categoryId]['products'][] = $product;
        }
        
        return array_values($result);
    }
}

数据库连接优化

连接池配置

<?php
// config/database.php
return [
    // 默认数据连接标识
    'default' => env('database.driver', 'mysql'),
    
    // 数据库连接配置信息
    'connections' => [
        'mysql' => [
            // 数据库类型
            'type' => env('database.type', 'mysql'),
            // 服务器地址
            'hostname' => env('database.hostname', '127.0.0.1'),
            // 数据库名
            'database' => env('database.database', ''),
            // 用户名
            'username' => env('database.username', 'root'),
            // 密码
            'password' => env('database.password', ''),
            // 端口
            'hostport' => env('database.hostport', '3306'),
            // 数据库连接参数
            'params' => [],
            // 数据库编码默认采用utf8
            'charset' => env('database.charset', 'utf8mb4'),
            // 数据库表前缀
            'prefix' => env('database.prefix', ''),
            
            // 连接池配置
            'pool' => [
                // 最小连接数
                'min_connections' => 1,
                // 最大连接数
                'max_connections' => 10,
                // 连接超时时间
                'connect_timeout' => 10.0,
                // 等待超时时间
                'wait_timeout' => 3.0,
                // 心跳间隔
                'heartbeat' => -1,
                // 最大空闲时间
                'max_idle_time' => 60,
            ],
            
            // 数据库部署方式:0 集中式(单一服务器),1 分布式(主从服务器)
            'deploy' => 0,
            // 数据库读写是否分离 主从式有效
            'rw_separate' => false,
            // 读写分离后 主服务器数量
            'master_num' => 1,
            // 指定从服务器序号
            'slave_no' => '',
            
            // 是否严格检查字段是否存在
            'fields_strict' => true,
            // 是否需要断线重连
            'break_reconnect' => false,
            // 监听SQL
            'trigger_sql' => env('app_debug', true),
            // 开启字段缓存
            'fields_cache' => false,
        ],
        
        // 读库配置
        'mysql_read' => [
            'type' => 'mysql',
            'hostname' => env('database.read_hostname', '127.0.0.1'),
            'database' => env('database.database', ''),
            'username' => env('database.read_username', 'root'),
            'password' => env('database.read_password', ''),
            'hostport' => env('database.read_hostport', '3306'),
            'charset' => 'utf8mb4',
            'prefix' => env('database.prefix', ''),
            // 只读连接
            'read_only' => true,
        ],
    ],
];

查询缓存优化

<?php
declare(strict_types=1);

namespace app\service;

use think\facade\Cache;
use think\facade\Db;
use think\Model;

/**
 * 查询缓存优化服务
 * 提供智能的查询缓存策略
 */
class QueryCacheService
{
    /**
     * 多级缓存查询
     * @param string $table 表名
     * @param array $conditions 查询条件
     * @param int $ttl 缓存时间
     * @return array 查询结果
     */
    public function multiLevelCache(string $table, array $conditions, int $ttl = 300): array
    {
        $cacheKey = $this->generateCacheKey($table, $conditions);
        
        // L1缓存：内存缓存（Redis）
        $data = Cache::store('redis')->get($cacheKey);
        if ($data !== null) {
            return $data;
        }
        
        // L2缓存：文件缓存
        $data = Cache::store('file')->get($cacheKey);
        if ($data !== null) {
            // 回写到L1缓存
            Cache::store('redis')->set($cacheKey, $data, $ttl);
            return $data;
        }
        
        // 从数据库查询
        $data = $this->queryFromDatabase($table, $conditions);
        
        // 写入多级缓存
        Cache::store('redis')->set($cacheKey, $data, $ttl);
        Cache::store('file')->set($cacheKey, $data, $ttl * 2);
        
        return $data;
    }
    
    /**
     * 智能缓存失效
     * @param string $table 表名
     * @param array $affectedData 受影响的数据
     * @return void
     */
    public function invalidateCache(string $table, array $affectedData): void
    {
        // 生成相关的缓存键模式
        $patterns = $this->generateCachePatterns($table, $affectedData);
        
        foreach ($patterns as $pattern) {
            // 删除匹配的缓存
            $this->deleteCacheByPattern($pattern);
        }
    }
    
    /**
     * 预热缓存
     * @param array $preloadQueries 预加载查询配置
     * @return void
     */
    public function warmupCache(array $preloadQueries): void
    {
        foreach ($preloadQueries as $query) {
            $this->multiLevelCache(
                $query['table'],
                $query['conditions'],
                $query['ttl'] ?? 300
            );
        }
    }
    
    /**
     * 生成缓存键
     * @param string $table 表名
     * @param array $conditions 查询条件
     * @return string 缓存键
     */
    private function generateCacheKey(string $table, array $conditions): string
    {
        ksort($conditions); // 确保条件顺序一致
        return 'query_' . $table . '_' . md5(serialize($conditions));
    }
    
    /**
     * 从数据库查询
     * @param string $table 表名
     * @param array $conditions 查询条件
     * @return array 查询结果
     */
    private function queryFromDatabase(string $table, array $conditions): array
    {
        $query = Db::name($table);
        
        foreach ($conditions as $field => $value) {
            if (is_array($value)) {
                $query->whereIn($field, $value);
            } else {
                $query->where($field, $value);
            }
        }
        
        return $query->select()->toArray();
    }
    
    /**
     * 生成缓存模式
     * @param string $table 表名
     * @param array $affectedData 受影响的数据
     * @return array 缓存模式数组
     */
    private function generateCachePatterns(string $table, array $affectedData): array
    {
        $patterns = [];
        
        // 基础表缓存模式
        $patterns[] = 'query_' . $table . '_*';
        
        // 根据受影响的数据生成更精确的模式
        if (!empty($affectedData['id'])) {
            $patterns[] = 'query_' . $table . '_*id*' . $affectedData['id'] . '*';
        }
        
        return $patterns;
    }
    
    /**
     * 按模式删除缓存
     * @param string $pattern 缓存模式
     * @return void
     */
    private function deleteCacheByPattern(string $pattern): void
    {
        // Redis实现
        $redis = Cache::store('redis')->handler();
        $keys = $redis->keys($pattern);
        
        if (!empty($keys)) {
            $redis->del($keys);
        }
        
        // 文件缓存实现（简化版）
        Cache::store('file')->clear();
    }
}

性能监控与调试

SQL性能监控

<?php
declare(strict_types=1);

namespace app\service;

use think\facade\Log;
use think\facade\Db;
use think\facade\Cache;

/**
 * SQL性能监控服务
 * 监控和分析SQL查询性能
 */
class SqlPerformanceMonitor
{
    /**
     * 慢查询阈值（毫秒）
     */
    private int $slowQueryThreshold = 1000;
    
    /**
     * 监控SQL执行
     * @param callable $callback 执行回调
     * @param string $operation 操作描述
     * @return mixed 执行结果
     */
    public function monitor(callable $callback, string $operation = '')
    {
        $startTime = microtime(true);
        $startMemory = memory_get_usage();
        
        // 开启SQL监听
        Db::listen(function($sql, $time, $explain) use ($operation) {
            $this->logSqlExecution($sql, $time, $explain, $operation);
        });
        
        try {
            $result = $callback();
            
            $endTime = microtime(true);
            $endMemory = memory_get_usage();
            
            $this->logPerformanceMetrics([
                'operation' => $operation,
                'execution_time' => ($endTime - $startTime) * 1000,
                'memory_usage' => $endMemory - $startMemory,
                'peak_memory' => memory_get_peak_usage()
            ]);
            
            return $result;
        } catch (\Exception $e) {
            $this->logError($operation, $e);
            throw $e;
        }
    }
    
    /**
     * 记录SQL执行信息
     * @param string $sql SQL语句
     * @param float $time 执行时间
     * @param array $explain 执行计划
     * @param string $operation 操作描述
     * @return void
     */
    private function logSqlExecution(string $sql, float $time, array $explain, string $operation): void
    {
        $timeMs = $time * 1000;
        
        // 记录慢查询
        if ($timeMs > $this->slowQueryThreshold) {
            Log::warning('慢查询检测', [
                'operation' => $operation,
                'sql' => $sql,
                'time' => $timeMs . 'ms',
                'explain' => $explain
            ]);
            
            // 发送告警（可选）
            $this->sendSlowQueryAlert($sql, $timeMs, $operation);
        }
        
        // 统计查询信息
        $this->collectQueryStatistics($sql, $timeMs, $operation);
    }
    
    /**
     * 记录性能指标
     * @param array $metrics 性能指标
     * @return void
     */
    private function logPerformanceMetrics(array $metrics): void
    {
        Log::info('性能监控', $metrics);
        
        // 存储到性能监控系统
        $this->storeMetrics($metrics);
    }
    
    /**
     * 收集查询统计信息
     * @param string $sql SQL语句
     * @param float $time 执行时间
     * @param string $operation 操作描述
     * @return void
     */
    private function collectQueryStatistics(string $sql, float $time, string $operation): void
    {
        $date = date('Y-m-d');
        $hour = date('H');
        
        // 按小时统计查询次数和平均时间
        $statsKey = "sql_stats_{$date}_{$hour}";
        $stats = Cache::get($statsKey, [
            'total_queries' => 0,
            'total_time' => 0,
            'slow_queries' => 0,
            'operations' => []
        ]);
        
        $stats['total_queries']++;
        $stats['total_time'] += $time;
        
        if ($time > $this->slowQueryThreshold) {
            $stats['slow_queries']++;
        }
        
        if (!isset($stats['operations'][$operation])) {
            $stats['operations'][$operation] = [
                'count' => 0,
                'total_time' => 0
            ];
        }
        
        $stats['operations'][$operation]['count']++;
        $stats['operations'][$operation]['total_time'] += $time;
        
        Cache::set($statsKey, $stats, 3600); // 缓存1小时
    }
    
    /**
     * 发送慢查询告警
     * @param string $sql SQL语句
     * @param float $time 执行时间
     * @param string $operation 操作描述
     * @return void
     */
    private function sendSlowQueryAlert(string $sql, float $time, string $operation): void
    {
        // 实现告警逻辑，如发送邮件、短信、钉钉等
        // 这里简化为日志记录
        Log::error('慢查询告警', [
            'sql' => $sql,
            'time' => $time . 'ms',
            'operation' => $operation,
            'timestamp' => date('Y-m-d H:i:s')
        ]);
    }
    
    /**
     * 存储性能指标
     * @param array $metrics 性能指标
     * @return void
     */
    private function storeMetrics(array $metrics): void
    {
        // 可以存储到时序数据库如InfluxDB、Prometheus等
        // 这里简化为缓存存储
        $key = 'performance_metrics_' . date('Y-m-d_H');
        $data = Cache::get($key, []);
        $data[] = array_merge($metrics, ['timestamp' => time()]);
        Cache::set($key, $data, 3600);
    }
    
    /**
     * 记录错误信息
     * @param string $operation 操作描述
     * @param \Exception $exception 异常对象
     * @return void
     */
    private function logError(string $operation, \Exception $exception): void
    {
        Log::error('数据库操作异常', [
            'operation' => $operation,
            'error' => $exception->getMessage(),
            'file' => $exception->getFile(),
            'line' => $exception->getLine(),
            'trace' => $exception->getTraceAsString()
        ]);
    }
    
    /**
     * 获取性能统计报告
     * @param string $date 日期
     * @return array 统计报告
     */
    public function getPerformanceReport(string $date = ''): array
    {
        if (empty($date)) {
            $date = date('Y-m-d');
        }
        
        $report = [
            'date' => $date,
            'hourly_stats' => [],
            'summary' => [
                'total_queries' => 0,
                'total_time' => 0,
                'slow_queries' => 0,
                'avg_time' => 0
            ]
        ];
        
        for ($hour = 0; $hour < 24; $hour++) {
            $statsKey = "sql_stats_{$date}_" . sprintf('%02d', $hour);
            $stats = Cache::get($statsKey, []);
            
            if (!empty($stats)) {
                $report['hourly_stats'][$hour] = $stats;
                $report['summary']['total_queries'] += $stats['total_queries'];
                $report['summary']['total_time'] += $stats['total_time'];
                $report['summary']['slow_queries'] += $stats['slow_queries'];
            }
        }
        
        if ($report['summary']['total_queries'] > 0) {
            $report['summary']['avg_time'] = $report['summary']['total_time'] / $report['summary']['total_queries'];
        }
        
        return $report;
    }
}

最佳实践总结

1. 查询优化原则

• 使用索引：确保查询条件字段有适当的索引
• **避免SELECT ***：只查询需要的字段
• 合理使用LIMIT：限制结果集大小
• 优化JOIN查询：使用适当的关联方式
• 避免N+1问题：使用预加载(with)查询

2. 缓存策略

• 多级缓存：结合内存缓存和文件缓存
• 智能失效：数据变更时及时清理相关缓存
• 预热机制：提前加载热点数据
• 缓存穿透防护：避免大量无效查询

3. 性能监控

• 慢查询监控：设置合理的慢查询阈值
• 性能指标收集：监控查询时间、内存使用等
• 告警机制：及时发现性能问题
• 定期分析：生成性能报告并优化

4. 代码规范

• 使用模型关联：避免手写复杂JOIN查询
• 事务管理：确保数据一致性
• 错误处理：完善的异常处理机制
• 代码复用：抽取通用的查询逻辑

总结

ThinkPHP8的ORM系统在性能和功能上都有了显著提升，通过合理使用查询优化技巧、模型关联、缓存策略和性能监控，可以构建高性能的数据库应用。在实际开发中，需要根据具体业务场景选择合适的优化策略，持续监控和改进系统性能，确保应用的稳定性和可扩展性。

关键是要理解ThinkPHP8 ORM的工作原理，掌握各种优化技巧，并在项目中持续实践和改进。通过本文介绍的方法，可以有效提升ThinkPHP8应用的数据库操作性能。