Laravel 5.5 withChain队列链中作业间对象状态传递问题求助

Absolutely, this is a super common pain point when working with Laravel job chains—you’d think the framework would have built-in support for sharing state between parent and child jobs in a chain, but it doesn’t come out of the box. I’ve run into this exact issue multiple times, and here are a few practical approaches that work well:

1. Use a Shared Storage (Cache/Database) #

This is the most straightforward method I recommend for most cases. You store the state you need to share in a temporary or persistent storage layer, then retrieve it in each child job. The key is to use a unique identifier tied to the job chain so you don’t mix up data between different chains.

Example with Cache: #

In your parent job (Test):

public function handle()
{
    // Run your parent job logic and generate the state to share
    $sharedState = [
        'user_id' => $this->user->id,
        'processed_data' => $this->processUser($this->user),
        'timestamp' => now()->toIso8601String()
    ];

    // Use the root job ID to create a unique cache key (works for chains)
    $cacheKey = "job_chain_{$this->job->getRootJobId()}";
    
    // Store the state with an expiration to avoid leftover data
    Cache::put($cacheKey, $sharedState, now()->addHour());
}

In your child jobs (Test1/Test2):

public function handle()
{
    $cacheKey = "job_chain_{$this->job->getRootJobId()}";
    $sharedState = Cache::get($cacheKey);

    if (!$sharedState) {
        // Handle missing state (maybe log and fail/retry)
        throw new \Exception("Shared state not found for job chain");
    }

    // Use the shared state in your child job logic
    $processedData = $sharedState['processed_data'];
    // ... rest of your code

    // Optional: Delete the cache once the last child job runs to clean up
    if ($this->job->isLastInChain()) {
        Cache::forget($cacheKey);
    }
}

If you need persistent storage (for longer-running chains or audit purposes), create a simple job_chain_states table with columns like root_job_id, data (JSON), and expires_at, then use Eloquent to store/retrieve the state instead of cache.

2. Dispatch Child Jobs Manually from the Parent #

If you don’t want to rely on external storage, you can adjust your workflow to have the parent job dispatch the child chain after it completes its processing. This way, you can pass the generated state directly as constructor arguments to the child jobs.

Example: #

First, dispatch only the parent job initially:

// Instead of using withChain, just dispatch the parent
App\Jobs\Test::dispatch($user);

Then in the parent job’s handle method:

public function handle()
{
    // Run parent job logic and generate state
    $sharedState = $this->processUser($this->user);

    // Now dispatch the child chain with the state included
    Test1::withChain([
        new Test2($this->user, $sharedState)
    ])->dispatch($this->user, $sharedState);
}

Update your child job constructors to accept the state:

class Test1 implements ShouldQueue
{
    protected $user;
    protected $sharedState;

    public function __construct(User $user, array $sharedState)
    {
        $this->user = $user;
        $this->sharedState = $sharedState;
    }

    public function handle()
    {
        // Use $this->sharedState directly
        // ...
    }
}

This method avoids external storage but requires restructuring your initial dispatch logic. It’s great if your parent job’s processing is fast and you don’t need to resume the chain if the parent fails (since the child jobs only dispatch after the parent succeeds).

3. Custom Chain Context with Redis #

For more complex chains where you need to share multiple pieces of state across jobs, you can create a custom context class that uses Redis to store shared data tied to the chain’s root job ID. This is similar to the cache method but gives you more control over how state is managed.

Example Context Class: #

class ChainContext
{
    public static function set(string $rootJobId, string $key, mixed $value): void
    {
        Redis::hSet("job_chain:$rootJobId", $key, serialize($value));
    }

    public static function get(string $rootJobId, string $key): mixed
    {
        $data = Redis::hGet("job_chain:$rootJobId", $key);
        return $data ? unserialize($data) : null;
    }

    public static function delete(string $rootJobId): void
    {
        Redis::del("job_chain:$rootJobId");
    }
}

In the parent job:

public function handle()
{
    $rootJobId = $this->job->getRootJobId();
    ChainContext::set($rootJobId, 'user_processed', true);
    ChainContext::set($rootJobId, 'processed_data', $this->processUser($this->user));
}

In a child job:

public function handle()
{
    $rootJobId = $this->job->getRootJobId();
    $isProcessed = ChainContext::get($rootJobId, 'user_processed');
    $processedData = ChainContext::get($rootJobId, 'processed_data');

    // Clean up when the last job runs
    if ($this->job->isLastInChain()) {
        ChainContext::delete($rootJobId);
    }
}

This approach is scalable for larger chains and lets you add/remove state keys dynamically as jobs run.

内容的提问来源于stack exchange，提问作者Frost