Fix #106 (comment)

Author: Moln

src/ServiceManager.php

@@ -134,6 +134,13 @@ class ServiceManager implements ServiceLocatorInterface
      */
     protected $configured = false;
 
+    /**
+     * Cached abstract factories from string.
+     *
+     * @var array
+     */
+    private $cachedAbstractFactories = [];
+
     /**
      * Constructor.
      *
@@ -486,12 +493,17 @@ private function resolveAbstractFactories(array $abstractFactories)
     {
         foreach ($abstractFactories as $abstractFactory) {
             if (is_string($abstractFactory) && class_exists($abstractFactory)) {
-                $abstractFactory = new $abstractFactory();
+                //Cached string
+                if (!isset($this->cachedAbstractFactories[$abstractFactory])) {
+                    $this->cachedAbstractFactories[$abstractFactory] = new $abstractFactory();
+                }
+
+                $abstractFactory = $this->cachedAbstractFactories[$abstractFactory];
             }
 
             if ($abstractFactory instanceof AbstractFactoryInterface) {
-                $abstractFactoryClassName = get_class($abstractFactory);
-                $this->abstractFactories[$abstractFactoryClassName] = $abstractFactory;
+                $abstractFactoryObjHash = spl_object_hash($abstractFactory);
+                $this->abstractFactories[$abstractFactoryObjHash] = $abstractFactory;
                 continue;
             }
 

test/CommonServiceLocatorBehaviorsTrait.php

@@ -21,7 +21,7 @@
 use Zend\ServiceManager\Factory\InvokableFactory;
 use Zend\ServiceManager\Initializer\InitializerInterface;
 use Zend\ServiceManager\ServiceLocatorInterface;
-use ZendTest\ServiceManager\TestAsset\CallOnlyOnceAbstractFactory;
+use ZendTest\ServiceManager\TestAsset\CallTimesAbstractFactory;
 use ZendTest\ServiceManager\TestAsset\FailingAbstractFactory;
 use ZendTest\ServiceManager\TestAsset\FailingFactory;
 use ZendTest\ServiceManager\TestAsset\InvokableObject;
@@ -140,20 +140,43 @@ public function testCanCreateServiceWithAbstractFactory()
         $serviceManager->get(DateTime::class);
     }
 
-    public function testCallOnlyOnceWithMultipleIdenticalAbstractFactory()
+    public function testCallTwiceWithDifferentInstanceAbstractFactories()
     {
-        CallOnlyOnceAbstractFactory::setCallTimes(0);
+        CallTimesAbstractFactory::setCallTimes(0);
+
+        $obj1 = new CallTimesAbstractFactory();
+        $obj2 = new CallTimesAbstractFactory();
+
+        $serviceManager = $this->createContainer([
+            'abstract_factories' => [
+                $obj1,
+                $obj2,
+            ]
+        ]);
+        $serviceManager->addAbstractFactory($obj1);
+        $serviceManager->addAbstractFactory($obj2);
+        $serviceManager->has(stdClass::class);
+
+        $this->assertEquals(2, CallTimesAbstractFactory::getCallTimes());
+    }
+
+    /**
+     * A new test with the same instance of `CallTimesAbstractFactory` should be provided.
+     */
+    public function testCallOnlyOnceWithSameInstanceAbstractFactory()
+    {
+        CallTimesAbstractFactory::setCallTimes(0);
 
         $serviceManager = $this->createContainer([
             'abstract_factories' => [
-                new CallOnlyOnceAbstractFactory(),
-                new CallOnlyOnceAbstractFactory(),
+                CallTimesAbstractFactory::class,
+                CallTimesAbstractFactory::class,
             ]
         ]);
-        $serviceManager->addAbstractFactory(CallOnlyOnceAbstractFactory::class);
+        $serviceManager->addAbstractFactory(CallTimesAbstractFactory::class);
         $serviceManager->has(stdClass::class);
 
-        $this->assertEquals(1, CallOnlyOnceAbstractFactory::getCallTimes());
+        $this->assertEquals(1, CallTimesAbstractFactory::getCallTimes());
     }
 
     public function testCanCreateServiceWithAlias()

test/TestAsset/CallOnlyOnceAbstractFactory.php renamed to test/TestAsset/CallTimesAbstractFactory.php

@@ -12,7 +12,7 @@
 use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\Factory\AbstractFactoryInterface;
 
-class CallOnlyOnceAbstractFactory implements AbstractFactoryInterface
+class CallTimesAbstractFactory implements AbstractFactoryInterface
 {
     protected static $callTimes = 0;