Laminas ServiceManager and MVC ControllerManager: Proxy Lifecycle Coordination

Direct answer

The ControllerManager::get() call returns a LazyServiceFactory proxy without initializing the controller. The real controller is instantiated when the proxy is first invoked, which occurs during the MVC dispatch lifecycle after the controller has been looked up but before the controller's onDispatch() method (or action) runs. Therefore, proxy resolution happens after the lookup and before your controller's onDispatch body.

Confirmed facts

• ControllerManager is a plugin manager that delegates to the parent ServiceManager for services it does not define locally.
• A shared service in a single ServiceManager returns the same instance on every get() call.
• The LazyServiceFactory creates a value‑holder proxy; initialization occurs on the first method call on that proxy.

Likely explanation for proxy chains

When a lazy controller depends on other lazy services, each dependency gets its own proxy. Building the controller proxy does not trigger its dependencies; each proxy initializes independently on first use. Consequently, memory usage and initialization order follow actual access patterns, not the EVENT_DISPATCH trigger itself.

Shared instance state across containers

If you request the same service name from the primary ServiceManager and from ControllerManager, you receive two separate proxies unless the plugin manager is wired to delegate to the primary container. To keep a single shared instance:

1. Ensure the ControllerManager is constructed with the application ServiceManager as its parent (or creation context).
2. Define the shared service once in the primary container as shared.
3. Let the ControllerManager resolve it via parent delegation; avoid registering a duplicate definition in the plugin manager.

If the plugin manager lacks this parent link, each container will produce its own proxy and thus two distinct real objects.

Steps for this case

1. Verify that the controller class is non‑final and proxyable (lazy proxies cannot wrap final classes).
2. Confirm that ControllerManager::get() returns a proxy and that the controller’s constructor has not run yet (e.g., static counter is 0).
3. During a request, check that the constructor runs exactly once before the first controller method (e.g., onDispatch) executes.
4. For any dependency that must be shared, define it once in the primary ServiceManager as shared and rely on parent delegation from the ControllerManager.

One detail that changes the recommendation

If the ControllerManager was instantiated without the application ServiceManager as its parent, the delegation step above will not work. Verify the parent container wiring before adjusting service definitions.

Verification snippet

// After fetching from ControllerManager, before dispatch:
$proxy = $controllerManager->get(MyController::class);
// assert real constructor has not run yet

// During dispatch, after first method call:
// assert real constructor has run exactly once

// Shared identity check:
$fromPrimary = $primarySm->get(SharedDep::class);
$fromCM = $controllerManager->get(SharedDep::class);
// compare spl_object_id($fromPrimary) === spl_object_id($fromCM)