企业版价格文档更新日志社区知识库
登录
后端

Laravel测试的实践技巧与实战应用

TRAE AI 编程助手

测试是确保代码质量的关键环节。Laravel作为现代PHP框架，提供了强大而优雅的测试工具链，让开发者能够轻松构建可靠的测试体系。

01｜Laravel测试架构概览

Laravel的测试体系建立在PHPUnit基础之上，通过框架封装的测试工具类，为开发者提供了简洁而强大的测试能力。理解Laravel测试的核心架构是编写高质量测试的第一步。

测试环境配置

Laravel在phpunit.xml文件中定义了专门的测试环境配置：

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
         convertErrorsToExceptions="true"
         convertNoticesToExceptions="true"
         convertWarningsToExceptions="true"
         processIsolation="false"
         stopOnFailure="false">
    <testsuites>
        <testsuite name="Unit">
            <directory suffix="Test.php">./tests/Unit</directory>
        </testsuite>
        <testsuite name="Feature">
            <directory suffix="Test.php">./tests/Feature</directory>
        </testsuite>
    </testsuites>
    <coverage processUncoveredFiles="true">
        <include>
            <directory suffix=".php">./app</directory>
        </include>
    </coverage>
    <php>
        <env name="APP_ENV" value="testing"/>
        <env name="BCRYPT_ROUNDS" value="4"/>
        <env name="CACHE_DRIVER" value="array"/>
        <env name="DB_CONNECTION" value="sqlite"/>
        <env name="DB_DATABASE" value=":memory:"/>
        <env name="MAIL_MAILER" value="array"/>
        <env name="QUEUE_CONNECTION" value="sync"/>
        <env name="SESSION_DRIVER" value="array"/>
        <env name="TELESCOPE_ENABLED" value="false"/>
    </php>
</phpunit>

测试基类结构

Laravel提供了两个主要的测试基类：

  • Tests\TestCase：功能测试的基础类，提供完整的Laravel应用环境
  • PHPUnit\Framework\TestCase：单元测试的基础类，轻量级且执行速度快
<?php
 
namespace Tests;
 
use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
 
abstract class TestCase extends BaseTestCase
{
    use CreatesApplication;
    
    protected function setUp(): void
    {
        parent::setUp();
        // 全局测试设置
        $this->withoutVite();
    }
}

02｜单元测试核心技巧

单元测试专注于测试单个类或方法的逻辑，是测试金字塔的基础。Laravel通过模型工厂、数据库迁移等工具，让单元测试变得简单而高效。

模型测试最佳实践

<?php
 
namespace Tests\Unit\Models;
 
use App\Models\User;
use App\Models\Post;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
 
class UserTest extends TestCase
{
    use RefreshDatabase;
 
    /** @test */
    public function it_can_have_many_posts()
    {
        $user = User::factory()->create();
        $post = Post::factory()->create(['user_id' => $user->id]);
 
        $this->assertInstanceOf(Post::class, $user->posts->first());
        $this->assertEquals(1, $user->posts->count());
    }
 
    /** @test */
    public function it_can_check_if_user_is_admin()
    {
        $admin = User::factory()->create(['role' => 'admin']);
        $regularUser = User::factory()->create(['role' => 'user']);
 
        $this->assertTrue($admin->isAdmin());
        $this->assertFalse($regularUser->isAdmin());
    }
}

服务类测试策略

<?php
 
namespace Tests\Unit\Services;
 
use App\Services\PaymentService;
use App\Models\Order;
use Tests\TestCase;
use Mockery;
 
class PaymentServiceTest extends TestCase
{
    /** @test */
    public function it_can_process_payment_successfully()
    {
        $paymentGateway = Mockery::mock('App\Contracts\PaymentGatewayInterface');
        $paymentGateway->shouldReceive('charge')
            ->once()
            ->with(1000, 'usd')
            ->andReturn(['status' => 'success', 'transaction_id' => 'txn_123']);
 
        $service = new PaymentService($paymentGateway);
        $order = Order::factory()->make(['amount' => 1000, 'currency' => 'usd']);
 
        $result = $service->processPayment($order);
 
        $this->assertEquals('success', $result['status']);
        $this->assertEquals('txn_123', $result['transaction_id']);
    }
}

03｜功能测试实战应用

功能测试验证应用的整体功能，模拟真实用户的操作行为。Laravel提供了丰富的HTTP测试工具，让功能测试编写变得直观而强大。

HTTP请求测试

<?php
 
namespace Tests\Feature;
 
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
 
class AuthenticationTest extends TestCase
{
    use RefreshDatabase;
 
    /** @test */
    public function user_can_login_with_valid_credentials()
    {
        $user = User::factory()->create([
            'email' => 'test@example.com',
            'password' => bcrypt('password123')
        ]);
 
        $response = $this->post('/login', [
            'email' => 'test@example.com',
            'password' => 'password123'
        ]);
 
        $response->assertRedirect('/dashboard');
        $this->assertAuthenticatedAs($user);
    }
 
    /** @test */
    public function user_cannot_login_with_invalid_credentials()
    {
        $response = $this->post('/login', [
            'email' => 'invalid@example.com',
            'password' => 'wrongpassword'
        ]);
 
        $response->assertSessionHasErrors('email');
        $this->assertGuest();
    }
}

API端点测试

<?php
 
namespace Tests\Feature\API;
 
use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
 
class ProductApiTest extends TestCase
{
    use RefreshDatabase;
 
    /** @test */
    public function it_can_list_all_products()
    {
        Product::factory()->count(5)->create();
 
        $response = $this->getJson('/api/products');
 
        $response->assertStatus(200)
            ->assertJsonCount(5, 'data')
            ->assertJsonStructure([
                'data' => [
                    '*' => ['id', 'name', 'price', 'description']
                ]
            ]);
    }
 
    /** @test */
    public function it_can_create_a_product()
    {
        $productData = [
            'name' => 'Test Product',
            'price' => 99.99,
            'description' => 'A test product'
        ];
 
        $response = $this->postJson('/api/products', $productData);
 
        $response->assertStatus(201)
            ->assertJsonFragment($productData);
 
        $this->assertDatabaseHas('products', $productData);
    }
}

04｜测试数据管理与工厂模式

有效的测试数据管理是编写可靠测试的关键。Laravel的模型工厂和数据库迁移系统为测试数据管理提供了强大支持。

高级工厂定义

<?php
 
namespace Database\Factories;
 
use App\Models\User;
use App\Models\Post;
use Illuminate\Database\Eloquent\Factories\Factory;
 
class PostFactory extends Factory
{
    protected $model = Post::class;
 
    public function definition()
    {
        return [
            'user_id' => User::factory(),
            'title' => $this->faker->sentence(),
            'content' => $this->faker->paragraphs(3, true),
            'status' => $this->faker->randomElement(['draft', 'published', 'archived']),
            'published_at' => $this->faker->optional()->dateTime(),
        ];
    }
 
    public function published()
    {
        return $this->state(function (array $attributes) {
            return [
                'status' => 'published',
                'published_at' => now(),
            ];
        });
    }
 
    public function draft()
    {
        return $this->state(function (array $attributes) {
            return [
                'status' => 'draft',
                'published_at' => null,
            ];
        });
    }
}

测试数据场景构建

<?php
 
namespace Tests\Feature;
 
use App\Models\User;
use App\Models\Post;
use App\Models\Comment;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
 
class BlogFunctionalityTest extends TestCase
{
    use RefreshDatabase;
 
    /** @test */
    public function it_can_display_published_posts_with_comments()
    {
        // 创建测试场景
        $user = User::factory()->create();
        $publishedPost = Post::factory()
            ->published()
            ->create(['user_id' => $user->id]);
        
        $comment = Comment::factory()->create([
            'post_id' => $publishedPost->id,
            'user_id' => $user->id
        ]);
 
        $draftPost = Post::factory()
            ->draft()
            ->create(['user_id' => $user->id]);
 
        $response = $this->get('/blog');
 
        $response->assertStatus(200)
            ->assertSee($publishedPost->title)
            ->assertSee($comment->content)
            ->assertDontSee($draftPost->title);
    }
}

05｜高级测试技巧与最佳实践

掌握高级测试技巧能够显著提升测试的质量和可维护性。以下是一些经过实战验证的最佳实践。

测试替身与依赖注入

<?php
 
namespace Tests\Feature;
 
use App\Contracts\PaymentGatewayInterface;
use App\Models\Order;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
use Mockery;
 
class OrderProcessingTest extends TestCase
{
    use RefreshDatabase;
 
    /** @test */
    public function it_can_process_order_with_payment_gateway()
    {
        $gateway = Mockery::mock(PaymentGatewayInterface::class);
        $gateway->shouldReceive('charge')
            ->once()
            ->andReturn(['status' => 'success', 'transaction_id' => 'txn_123']);
 
        $this->app->instance(PaymentGatewayInterface::class, $gateway);
 
        $order = Order::factory()->create(['amount' => 1000]);
 
        $response = $this->post("/orders/{$order->id}/process");
 
        $response->assertRedirect()
            ->assertSessionHas('success', 'Order processed successfully');
 
        $this->assertEquals('completed', $order->fresh()->status);
    }
}

并发测试与队列测试

<?php
 
namespace Tests\Feature;
 
use App\Jobs\ProcessOrderJob;
use App\Models\Order;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Queue;
use Tests\TestCase;
 
class QueueProcessingTest extends TestCase
{
    use RefreshDatabase;
 
    /** @test */
    public function it_queues_order_processing_job()
    {
        Queue::fake();
 
        $order = Order::factory()->create();
 
        $this->post("/orders/{$order->id}/process-async");
 
        Queue::assertPushed(ProcessOrderJob::class, function ($job) use ($order) {
            return $job->order->id === $order->id;
        });
    }
 
    /** @test */
    public function it_processes_order_job_successfully()
    {
        $order = Order::factory()->create(['status' => 'pending']);
 
        $job = new ProcessOrderJob($order);
        $job->handle();
 
        $this->assertEquals('processed', $order->fresh()->status);
    }
}

浏览器测试与Dusk集成

<?php
 
namespace Tests\Browser;
 
use App\Models\User;
use Laravel\Dusk\Browser;
use Tests\DuskTestCase;
 
class UserRegistrationTest extends DuskTestCase
{
    /** @test */
    public function it_can_register_new_user()
    {
        $this->browse(function (Browser $browser) {
            $browser->visit('/register')
                ->type('name', 'John Doe')
                ->type('email', 'john@example.com')
                ->type('password', 'password123')
                ->type('password_confirmation', 'password123')
                ->press('Register')
                ->assertPathIs('/dashboard')
                ->assertSee('Welcome, John Doe');
        });
    }
 
    /** @test */
    public function it_shows_validation_errors()
    {
        $this->browse(function (Browser $browser) {
            $browser->visit('/register')
                ->press('Register')
                ->assertPathIs('/register')
                ->assertSee('The name field is required.')
                ->assertSee('The email field is required.');
        });
    }
}

06｜测试优化与性能调优

高效的测试套件不仅需要功能完备，更需要执行速度快、维护成本低。以下是一些测试优化的关键策略。

数据库事务优化

<?php
 
namespace Tests;
 
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Foundation\Testing\RefreshDatabase;
 
trait OptimizedDatabaseTesting
{
    protected function setUp(): void
    {
        parent::setUp();
        
        // 根据测试类型选择合适的数据库策略
        if ($this->usesUnitTesting()) {
            // 单元测试使用内存数据库
            $this->app['config']->set('database.default', 'sqlite');
            $this->app['config']->set('database.connections.sqlite.database', ':memory:');
        } elseif ($this->usesHeavyDatabaseOperations()) {
            // 重型数据库操作使用数据库事务
            $this->setUpDatabaseTransactions();
        }
    }
 
    protected function usesUnitTesting(): bool
    {
        return strpos(get_class($this), 'Tests\\Unit') === 0;
    }
 
    protected function usesHeavyDatabaseOperations(): bool
    {
        return method_exists($this, 'heavyDatabaseOperations') && 
               $this->heavyDatabaseOperations();
    }
}

并行测试配置

<?php
 
// phpunit.xml 配置并行测试
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
         executionOrder="depends,defects"
         beStrictAboutOutputDuringTests="true"
         beStrictAboutTodoAnnotatedTests="true"
         failOnRisky="true"
         failOnWarning="true"
         cacheDirectory=".phpunit.cache"
         requireCoverageMetadata="false"
         beStrictAboutCoverageMetadata="false">
    
    <!-- 并行测试配置 -->
    <extensions>
        <extension class="ParaTest\Runners\PHPUnit\WorkerTestCase"/>
    </extensions>
    
    <php>
        <env name="PARATEST" value="true"/>
        <env name="APP_ENV" value="testing"/>
        <env name="DB_CONNECTION" value="sqlite"/>
        <env name="DB_DATABASE" value=":memory:"/>
    </php>
</phpunit>

测试覆盖率优化

<?php
 
namespace Tests;
 
use PHPUnit\Framework\TestCase as BaseTestCase;
 
abstract class CoverageTestCase extends BaseTestCase
{
    protected function setUp(): void
    {
        parent::setUp();
        
        if ($this->shouldCollectCoverage()) {
            $this->startCoverageCollection();
        }
    }
 
    protected function tearDown(): void
    {
        if ($this->shouldCollectCoverage()) {
            $this->stopCoverageCollection();
        }
        
        parent::tearDown();
    }
 
    protected function shouldCollectCoverage(): bool
    {
        return env('COVERAGE', false) && $this->isCriticalTest();
    }
 
    protected function isCriticalTest(): bool
    {
        $criticalNamespaces = ['App\\Services', 'App\\Models', 'App\\Http\\Controllers'];
        $testClass = get_class($this);
        
        foreach ($criticalNamespaces as $namespace) {
            if (strpos($testClass, str_replace('App\\', 'Tests\\Unit\\', $namespace)) === 0) {
                return true;
            }
        }
        
        return false;
    }
}

07｜持续集成与自动化测试

将测试集成到持续集成流程中，确保每次代码变更都能通过自动化测试验证。

GitHub Actions 配置

name: Laravel Tests
 
on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
 
jobs:
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        php-version: [8.1, 8.2, 8.3]
        
    services:
      mysql:
        image: mysql:8.0
        env:
          MYSQL_ROOT_PASSWORD: password
          MYSQL_DATABASE: testing
        ports:
          - 3306:3306
        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
 
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: ${{ matrix.php-version }}
        extensions: mbstring, xml, ctype, iconv, intl, pdo, pdo_mysql
        coverage: xdebug
        
    - name: Copy .env
      run: php -r "file_exists('.env') || copy('.env.example', '.env');"
      
    - name: Install Dependencies
      run: composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist
      
    - name: Generate key
      run: php artisan key:generate
      
    - name: Directory Permissions
      run: chmod -R 777 storage bootstrap/cache
      
    - name: Run Migrations
      env:
        DB_CONNECTION: mysql
        DB_HOST: 127.0.0.1
        DB_PORT: 3306
        DB_DATABASE: testing
        DB_USERNAME: root
        DB_PASSWORD: password
      run: php artisan migrate
      
    - name: Execute tests (Unit and Feature tests) via PHPUnit
      env:
        DB_CONNECTION: mysql
        DB_HOST: 127.0.0.1
        DB_PORT: 3306
        DB_DATABASE: testing
        DB_USERNAME: root
        DB_PASSWORD: password
      run: vendor/bin/phpunit --coverage-text --coverage-clover=coverage.xml
      
    - name: Upload coverage reports to Codecov
      uses: codecov/codecov-action@v3
      with:
        file: ./coverage.xml
        flags: unittests
        name: codecov-umbrella

测试报告与监控

<?php
 
namespace App\Console\Commands;
 
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Artisan;
 
class RunTestsWithReport extends Command
{
    protected $signature = 'test:report {--coverage : Generate coverage report}';
    protected $description = 'Run tests with detailed reporting';
 
    public function handle()
    {
        $this->info('Starting test execution...');
        
        $startTime = microtime(true);
        
        $options = ['--colors' => 'always'];
        
        if ($this->option('coverage')) {
            $options['--coverage-html'] = 'coverage-report';
        }
        
        $exitCode = Artisan::call('test', $options);
        
        $executionTime = round(microtime(true) - $startTime, 2);
        
        if ($exitCode === 0) {
            $this->info("✅ All tests passed successfully!");
            $this->info("Execution time: {$executionTime} seconds");
            
            if ($this->option('coverage')) {
                $this->info("Coverage report generated in: coverage-report/");
            }
        } else {
            $this->error("❌ Some tests failed!");
            $this->error("Execution time: {$executionTime} seconds");
        }
        
        return $exitCode;
    }
}

08｜常见问题与解决方案

在实际测试过程中，开发者经常会遇到各种挑战。以下是一些常见问题的解决方案。

时间相关测试

<?php
 
namespace Tests\Unit;
 
use Carbon\Carbon;
use Tests\TestCase;
 
class TimeSensitiveTest extends TestCase
{
    /** @test */
    public function it_handles_time_based_logic_correctly()
    {
        // 固定当前时间
        Carbon::setTestNow('2024-01-15 10:00:00');
        
        $service = new TimeBasedService();
        $result = $service->isBusinessHours();
        
        $this->assertTrue($result);
        
        // 清理测试时间
        Carbon::setTestNow();
    }
}

外部服务测试

<?php
 
namespace Tests\Feature;
 
use Illuminate\Support\Facades\Http;
use Tests\TestCase;
 
class ExternalServiceTest extends TestCase
{
    /** @test */
    public function it_can_handle_external_api_responses()
    {
        Http::fake([
            'api.external-service.com/*' => Http::response([
                'status' => 'success',
                'data' => ['id' => 123, 'name' => 'Test']
            ], 200)
        ]);
        
        $response = $this->post('/sync-external-data');
        
        $response->assertStatus(200)
            ->assertJson(['message' => 'Data synchronized successfully']);
            
        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.external-service.com/data';
        });
    }
}

文件上传测试

<?php
 
namespace Tests\Feature;
 
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;
 
class FileUploadTest extends TestCase
{
    /** @test */
    public function it_can_upload_and_process_files()
    {
        Storage::fake('uploads');
        
        $file = UploadedFile::fake()->image('avatar.jpg')->size(100);
        
        $response = $this->post('/upload-avatar', [
            'avatar' => $file
        ]);
        
        $response->assertStatus(200);
        
        Storage::disk('uploads')->assertExists('avatars/' . $file->hashName());
        
        // 验证文件处理逻辑
        $this->assertDatabaseHas('users', [
            'avatar' => 'avatars/' . $file->hashName()
        ]);
    }
}

09｜测试驱动开发实践

测试驱动开发（TDD）是一种强大的开发方法论，通过先写测试再实现功能的方式，确保代码质量和可维护性。

TDD 循环实践

<?php
 
// 第一步：编写失败的测试
namespace Tests\Unit\Services;
 
use App\Services\CalculatorService;
use Tests\TestCase;
 
class CalculatorServiceTest extends TestCase
{
    /** @test */
    public function it_can_add_two_numbers()
    {
        $calculator = new CalculatorService();
        
        $result = $calculator->add(2, 3);
        
        $this->assertEquals(5, $result);
    }
    
    /** @test */
    public function it_can_subtract_two_numbers()
    {
        $calculator = new CalculatorService();
        
        $result = $calculator->subtract(5, 3);
        
        $this->assertEquals(2, $result);
    }
}
 
// 第二步：实现功能使测试通过
<?php
 
namespace App\Services;
 
class CalculatorService
{
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }
    
    public function subtract(int $a, int $b): int
    {
        return $a - $b;
    }
}
 
// 第三步：重构优化
<?php
 
namespace App\Services;
 
class CalculatorService
{
    public function add(int $a, int $b): int
    {
        return $this->calculate($a, $b, '+');
    }
    
    public function subtract(int $a, int $b): int
    {
        return $this->calculate($a, $b, '-');
    }
    
    private function calculate(int $a, int $b, string $operation): int
    {
        return match($operation) {
            '+' => $a + $b,
            '-' => $a - $b,
            default => throw new \InvalidArgumentException("Unsupported operation: {$operation}")
        };
    }
}

行为驱动开发（BDD）风格

<?php
 
namespace Tests\Feature;
 
use App\Models\User;
use App\Models\Product;
use Tests\TestCase;
 
class ShoppingCartFeatureTest extends TestCase
{
    /** @test */
    public function customer_can_add_product_to_cart()
    {
        $this->given_a_customer()
            ->and_a_product_exists()
            ->when_they_add_product_to_cart()
            ->then_the_product_should_be_in_their_cart();
    }
    
    private function given_a_customer()
    {
        $this->customer = User::factory()->create();
        $this->actingAs($this->customer);
        return $this;
    }
    
    private function and_a_product_exists()
    {
        $this->product = Product::factory()->create([
            'name' => 'Laravel T-shirt',
            'price' => 29.99
        ]);
        return $this;
    }
    
    private function when_they_add_product_to_cart()
    {
        $this->response = $this->post('/cart/add', [
            'product_id' => $this->product->id,
            'quantity' => 1
        ]);
        return $this;
    }
    
    private function then_the_product_should_be_in_their_cart()
    {
        $this->response->assertStatus(200);
        $this->assertDatabaseHas('cart_items', [
            'user_id' => $this->customer->id,
            'product_id' => $this->product->id,
            'quantity' => 1
        ]);
    }
}

总结与最佳实践清单

通过深入探讨Laravel测试的各个方面，我们构建了一套完整的测试实践体系。以下是关键要点的总结：

✅ 测试类型选择

  • 单元测试：专注于单个类或方法，执行速度快，适合测试业务逻辑
  • 功能测试：验证完整的用户场景，确保系统功能正确性
  • 集成测试：测试多个组件之间的交互，确保系统整体协调性

✅ 测试数据管理

  • 使用模型工厂创建一致的测试数据
  • 利用数据库迁移确保数据结构一致性
  • 采用事务回滚或内存数据库提高测试效率

✅ 测试质量保障

  • 保持测试的独立性和可重复性
  • 使用描述性的测试方法名称
  • 遵循AAA模式（Arrange, Act, Assert）
  • 避免测试之间的依赖关系

✅ 性能优化策略

  • 合理使用测试替身（Mock）减少外部依赖
  • 配置并行测试加速执行
  • 优化数据库操作，使用内存数据库或事务回滚
  • 定期清理和重构测试代码

✅ 持续集成实践

  • 将测试集成到CI/CD流程中
  • 配置测试覆盖率报告
  • 设置测试失败的通知机制
  • 定期审查和更新测试用例

通过遵循这些实践技巧，开发者可以构建出高质量、可维护的Laravel测试套件，为应用的稳定性和可靠性提供坚实保障。记住，好的测试不仅是质量的保证，更是开发效率的倍增器。

思考题：在你的Laravel项目中，哪些业务逻辑最适合采用TDD方式开发？如何设计测试用例来确保核心业务规则的正确性？

（此内容由 AI 辅助生成，仅供参考）