PHP Configuration::setNamingStrategy方法代码示例

 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     /** @var $options \DoctrineORMModule\Options\Configuration */
     $options = $this->getOptions($serviceLocator);
     $config = new Configuration();
     $config->setAutoGenerateProxyClasses($options->getGenerateProxies());
     $config->setProxyDir($options->getProxyDir());
     $config->setProxyNamespace($options->getProxyNamespace());
     $config->setEntityNamespaces($options->getEntityNamespaces());
     $config->setCustomDatetimeFunctions($options->getDatetimeFunctions());
     $config->setCustomStringFunctions($options->getStringFunctions());
     $config->setCustomNumericFunctions($options->getNumericFunctions());
     $config->setClassMetadataFactoryName($options->getClassMetadataFactoryName());
     foreach ($options->getNamedQueries() as $name => $query) {
         $config->addNamedQuery($name, $query);
     }
     foreach ($options->getNamedNativeQueries() as $name => $query) {
         $config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']());
     }
     foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) {
         $config->addCustomHydrationMode($modeName, $hydrator);
     }
     foreach ($options->getFilters() as $name => $class) {
         $config->addFilter($name, $class);
     }
     $config->setMetadataCacheImpl($serviceLocator->get($options->getMetadataCache()));
     $config->setQueryCacheImpl($serviceLocator->get($options->getQueryCache()));
     $config->setResultCacheImpl($serviceLocator->get($options->getResultCache()));
     $config->setHydrationCacheImpl($serviceLocator->get($options->getHydrationCache()));
     $config->setMetadataDriverImpl($serviceLocator->get($options->getDriver()));
     if ($namingStrategy = $options->getNamingStrategy()) {
         if (is_string($namingStrategy)) {
             if (!$serviceLocator->has($namingStrategy)) {
                 throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy));
             }
             $config->setNamingStrategy($serviceLocator->get($namingStrategy));
         } else {
             $config->setNamingStrategy($namingStrategy);
         }
     }
     if ($repositoryFactory = $options->getRepositoryFactory()) {
         if (is_string($repositoryFactory)) {
             if (!$serviceLocator->has($repositoryFactory)) {
                 throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory));
             }
             $config->setRepositoryFactory($serviceLocator->get($repositoryFactory));
         } else {
             $config->setRepositoryFactory($repositoryFactory);
         }
     }
     if ($entityListenerResolver = $options->getEntityListenerResolver()) {
         if ($entityListenerResolver instanceof EntityListenerResolver) {
             $config->setEntityListenerResolver($entityListenerResolver);
         } else {
             $config->setEntityListenerResolver($serviceLocator->get($entityListenerResolver));
         }
     }
     $this->setupDBALConfiguration($serviceLocator, $config);
     return $config;
 }

 public function testSetGetNamingStrategy()
 {
     $this->assertInstanceOf('Doctrine\\ORM\\Mapping\\NamingStrategy', $this->configuration->getNamingStrategy());
     $namingStrategy = $this->getMock('Doctrine\\ORM\\Mapping\\NamingStrategy');
     $this->configuration->setNamingStrategy($namingStrategy);
     $this->assertSame($namingStrategy, $this->configuration->getNamingStrategy());
 }

 /**
  * Creates a new EntityManager instance based on the provided configuration.
  *
  *     $factory = new Doctrine_EMFactory;
  *     $em = $factory->entity_manager();
  *
  * @param string $db_group the name of the Kohana database config group to get connection information from
  *
  * @return \Doctrine\ORM\EntityManager
  */
 public function entity_manager($db_group = 'default')
 {
     $config = $this->config->load('doctrine');
     // Ensure the composer autoloader is registered
     require_once $config['composer_vendor_path'] . 'autoload.php';
     // Create the Configuration class
     $orm_config = new Configuration();
     // Create the metadata driver
     $driver = $this->create_annotation_driver();
     $orm_config->setMetadataDriverImpl($driver);
     // Configure the proxy directory and namespace
     $orm_config->setProxyDir($config['proxy_dir']);
     $orm_config->setProxyNamespace($config['proxy_namespace']);
     if ($config->get('use_underscore_naming_strategy')) {
         $naming_strategy = new UnderscoreNamingStrategy($config->get('case_underscore_naming_strategy'));
         $orm_config->setNamingStrategy($naming_strategy);
     }
     // Configure environment-specific options
     if ($this->environment === Kohana::DEVELOPMENT) {
         $orm_config->setAutoGenerateProxyClasses(TRUE);
         $cache = new ArrayCache();
     } else {
         $orm_config->setAutoGenerateProxyClasses(FALSE);
         $cache = new ApcCache();
     }
     // Set the cache drivers
     $orm_config->setMetadataCacheImpl($cache);
     $orm_config->setQueryCacheImpl($cache);
     // Create the Entity Manager with the database connection information
     $em = EntityManager::create($this->get_connection_config($db_group), $orm_config);
     $this->register_custom_types($config);
     return $em;
 }

 /**
  * @param  ContainerInterface $container
  * @return EntityManager
  */
 public function __invoke(ContainerInterface $container)
 {
     $config = $container->has('config') ? $container->get('config') : [];
     if (!isset($config['doctrine'])) {
         throw new ServiceNotCreatedException('Missing Doctrine configuration');
     }
     $config = $config['doctrine'];
     $proxyDir = isset($config['proxy_dir']) ? $config['proxy_dir'] : 'data/DoctrineORM/Proxy';
     $proxyNamespace = isset($config['proxy_namespace']) ? $config['proxy_namespace'] : 'DoctrineORM/Proxy';
     $autoGenerateProxyClasses = isset($config['configuration']['auto_generate_proxy_classes']) ? $config['configuration']['auto_generate_proxy_classes'] : false;
     $underscoreNamingStrategy = isset($config['configuration']['underscore_naming_strategy']) ? $config['configuration']['underscore_naming_strategy'] : false;
     // Doctrine ORM
     $doctrine = new Configuration();
     $doctrine->setProxyDir($proxyDir);
     $doctrine->setProxyNamespace($proxyNamespace);
     $doctrine->setAutoGenerateProxyClasses($autoGenerateProxyClasses);
     // Naming Strategy
     if ($underscoreNamingStrategy) {
         $doctrine->setNamingStrategy(new UnderscoreNamingStrategy());
     }
     // ORM mapping by Annotation
     //AnnotationRegistry::registerAutoloadNamespace($config['driver']['annotations']['class']);
     AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
     $driver = new AnnotationDriver(new AnnotationReader(), $config['driver']['annotations']['paths']);
     $doctrine->setMetadataDriverImpl($driver);
     // Cache
     $cache = $container->get(\Doctrine\Common\Cache\Cache::class);
     $doctrine->setQueryCacheImpl($cache);
     $doctrine->setResultCacheImpl($cache);
     $doctrine->setMetadataCacheImpl($cache);
     // EntityManager
     return EntityManager::create($config['connection']['orm_default']['params'], $doctrine);
 }

 /**
  * @param \Doctrine\ORM\Configuration $config
  * @param array $options
  * @throws \InvalidArgumentException
  */
 protected static function setupNamingStrategy(Configuration &$config, array $options = [])
 {
     $namingStrategy = self::getOption($options, 'naming_strategy') ?: new UnderscoreNamingStrategy();
     if (!$namingStrategy instanceof NamingStrategy) {
         throw new \InvalidArgumentException('Naming strategy provided is not valid');
     }
     $config->setNamingStrategy($namingStrategy);
 }

 /**
  * @param ContainerInterface $container
  *
  * @return EntityManagerInterface
  * @throws ORMException
  */
 public function __invoke(ContainerInterface $container)
 {
     $config = $container->has('config') ? $container->get('config') : [];
     $proxyDir = isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy';
     $proxyNamespace = isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy';
     $autoGenerateProxyClasses = isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false;
     $underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false;
     $entityPaths = isset($config['doctrine']['orm']['entity_paths']) ? $config['doctrine']['orm']['entity_paths'] : ['src'];
     // Doctrine ORM
     $doctrine = new Configuration();
     $doctrine->setProxyDir($proxyDir);
     $doctrine->setProxyNamespace($proxyNamespace);
     $doctrine->setAutoGenerateProxyClasses($autoGenerateProxyClasses);
     if ($underscoreNamingStrategy) {
         $doctrine->setNamingStrategy(new UnderscoreNamingStrategy());
     }
     // Cache
     $cache = $container->get(Cache::class);
     $doctrine->setQueryCacheImpl($cache);
     $doctrine->setResultCacheImpl($cache);
     $doctrine->setMetadataCacheImpl($cache);
     // ORM mapping by Annotation
     AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
     if (class_exists(DoctrineExtensions::class)) {
         DoctrineExtensions::registerAnnotations();
     }
     $cachedAnnotationReader = new CachedReader(new AnnotationReader(), $cache);
     $driver = new AnnotationDriver($cachedAnnotationReader, $entityPaths);
     $doctrine->setMetadataDriverImpl($driver);
     $eventManager = new EventManager();
     if (isset($config['doctrine']['orm']['event_subscribers'])) {
         foreach ($config['doctrine']['orm']['event_subscribers'] as $subscriber) {
             $subscriberInstance = $container->get($subscriber);
             if ($subscriberInstance instanceof MappedEventSubscriber) {
                 $subscriberInstance->setAnnotationReader($cachedAnnotationReader);
             }
             $eventManager->addEventSubscriber($subscriberInstance);
         }
     }
     $entityManager = EntityManager::create($config['doctrine']['connection']['orm_default'], $doctrine, $eventManager);
     // Types
     Type::addType('uuid', UuidType::class);
     $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('uuid', 'uuid');
     if (isset($config['doctrine']['orm']['types'])) {
         foreach ($config['doctrine']['orm']['types'] as $type => $class) {
             Type::addType($type, $class);
         }
     }
     return $entityManager;
 }

/*
 * Copyright 2015 Jack Sleight <http://jacksleight.com/>
 * This source file is subject to the MIT license that is bundled with this package in the file LICENCE.md. 
 */
use Doctrine\ORM\Configuration;
use Doctrine\Common\EventManager;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Proxy\Autoloader;
use Chalk\Doctrine\ORM\EntityManager as ChalkEntityManager;
use Chalk\Doctrine\NamingStrategy;
use Chalk\Listener;
\Coast\Doctrine\register_dbal_types();
if (!isset($app->config->database)) {
    throw new \Chalk\Exception('Database connection details are required');
}
$config = new Configuration();
$config->setNamingStrategy(new NamingStrategy());
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$config->setProxyDir($app->config->dataDir->dir('proxy'));
$config->setProxyNamespace('Chalk\\Proxy');
$config->setAutoGenerateProxyClasses(false);
$config->setQueryCacheImpl($app->cache->value());
$config->setResultCacheImpl($app->cache->value());
$config->setMetadataCacheImpl($app->cache->value());
Autoloader::register($app->config->dataDir->dir('proxy'), 'Chalk\\Proxy');
$evm = new EventManager();
$evm->addEventSubscriber(new Listener());
$em = new ChalkEntityManager(EntityManager::create($app->config->database + ['driver' => 'pdo_mysql', 'charset' => 'utf8'], $config, $evm));
$em->getConnection()->exec("SET NAMES utf8");
Toast\Wrapper::$em = $em;
return $em;

 /**
  * @param array         $settings
  * @param Configuration $configuration
  */
 protected function setNamingStrategy(array $settings = [], Configuration $configuration)
 {
     $strategy = array_get($settings, 'naming_strategy', LaravelNamingStrategy::class);
     $configuration->setNamingStrategy($this->container->make($strategy));
 }

 /**
  * Setup naming strategy.
  *
  * @param \Doctrine\ORM\Configuration $config
  * @param array                       $options
  *
  * @throws \InvalidArgumentException
  */
 protected static function setupNamingStrategy(Configuration &$config, array $options)
 {
     $namingStrategy = $options['naming_strategy'] ?: new UnderscoreNamingStrategy(CASE_LOWER);
     if (!$namingStrategy instanceof NamingStrategy) {
         throw new \InvalidArgumentException('Naming strategy provided is not valid');
     }
     $config->setNamingStrategy($namingStrategy);
 }

 /**
  * {@inheritDoc}
  *
  * @return Configuration
  */
 public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
 {
     /** @var $options \DoctrineORMModule\Options\Configuration */
     $options = $this->getOptions($container);
     $config = new Configuration();
     $config->setAutoGenerateProxyClasses($options->getGenerateProxies());
     $config->setProxyDir($options->getProxyDir());
     $config->setProxyNamespace($options->getProxyNamespace());
     $config->setEntityNamespaces($options->getEntityNamespaces());
     $config->setCustomDatetimeFunctions($options->getDatetimeFunctions());
     $config->setCustomStringFunctions($options->getStringFunctions());
     $config->setCustomNumericFunctions($options->getNumericFunctions());
     $config->setClassMetadataFactoryName($options->getClassMetadataFactoryName());
     foreach ($options->getNamedQueries() as $name => $query) {
         $config->addNamedQuery($name, $query);
     }
     foreach ($options->getNamedNativeQueries() as $name => $query) {
         $config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']());
     }
     foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) {
         $config->addCustomHydrationMode($modeName, $hydrator);
     }
     foreach ($options->getFilters() as $name => $class) {
         $config->addFilter($name, $class);
     }
     $config->setMetadataCacheImpl($container->get($options->getMetadataCache()));
     $config->setQueryCacheImpl($container->get($options->getQueryCache()));
     $config->setResultCacheImpl($container->get($options->getResultCache()));
     $config->setHydrationCacheImpl($container->get($options->getHydrationCache()));
     $config->setMetadataDriverImpl($container->get($options->getDriver()));
     if ($namingStrategy = $options->getNamingStrategy()) {
         if (is_string($namingStrategy)) {
             if (!$container->has($namingStrategy)) {
                 throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy));
             }
             $config->setNamingStrategy($container->get($namingStrategy));
         } else {
             $config->setNamingStrategy($namingStrategy);
         }
     }
     if ($quoteStrategy = $options->getQuoteStrategy()) {
         if (is_string($quoteStrategy)) {
             if (!$container->has($quoteStrategy)) {
                 throw new InvalidArgumentException(sprintf('Quote strategy "%s" not found', $quoteStrategy));
             }
             $config->setQuoteStrategy($container->get($quoteStrategy));
         } else {
             $config->setQuoteStrategy($quoteStrategy);
         }
     }
     if ($repositoryFactory = $options->getRepositoryFactory()) {
         if (is_string($repositoryFactory)) {
             if (!$container->has($repositoryFactory)) {
                 throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory));
             }
             $config->setRepositoryFactory($container->get($repositoryFactory));
         } else {
             $config->setRepositoryFactory($repositoryFactory);
         }
     }
     if ($entityListenerResolver = $options->getEntityListenerResolver()) {
         if ($entityListenerResolver instanceof EntityListenerResolver) {
             $config->setEntityListenerResolver($entityListenerResolver);
         } else {
             $config->setEntityListenerResolver($container->get($entityListenerResolver));
         }
     }
     $secondLevelCache = $options->getSecondLevelCache();
     if ($secondLevelCache->isEnabled()) {
         $regionsConfig = new RegionsConfiguration($secondLevelCache->getDefaultLifetime(), $secondLevelCache->getDefaultLockLifetime());
         foreach ($secondLevelCache->getRegions() as $regionName => $regionConfig) {
             if (isset($regionConfig['lifetime'])) {
                 $regionsConfig->setLifetime($regionName, $regionConfig['lifetime']);
             }
             if (isset($regionConfig['lock_lifetime'])) {
                 $regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']);
             }
         }
         // As Second Level Cache caches queries results, we reuse the result cache impl
         $cacheFactory = new DefaultCacheFactory($regionsConfig, $config->getResultCacheImpl());
         $cacheFactory->setFileLockRegionDirectory($secondLevelCache->getFileLockRegionDirectory());
         $cacheConfiguration = new CacheConfiguration();
         $cacheConfiguration->setCacheFactory($cacheFactory);
         $cacheConfiguration->setRegionsConfiguration($regionsConfig);
         $config->setSecondLevelCacheEnabled();
         $config->setSecondLevelCacheConfiguration($cacheConfiguration);
     }
     if ($className = $options->getDefaultRepositoryClassName()) {
         $config->setDefaultRepositoryClassName($className);
     }
     $this->setupDBALConfiguration($container, $config);
     return $config;
 }

 /**
  * Configures the metadata configuration instance.
  *
  * @param Configuration $configuration
  * @param array                       $doctrineConfig
  *
  * @throws ORMException
  */
 protected function configureMetadataConfiguration(Configuration $configuration, array $doctrineConfig)
 {
     if (isset($doctrineConfig['filters'])) {
         foreach ($doctrineConfig['filters'] as $name => $filter) {
             $configuration->addFilter($name, $filter['class']);
         }
     }
     if (isset($doctrineConfig['logger'])) {
         $configuration->setSQLLogger($doctrineConfig['logger']);
     }
     if (isset($doctrineConfig['proxy']) && isset($doctrineConfig['proxy']['auto_generate'])) {
         $configuration->setAutoGenerateProxyClasses($doctrineConfig['proxy']['auto_generate']);
     }
     if (isset($doctrineConfig['proxy']) && isset($doctrineConfig['proxy']['namespace'])) {
         $configuration->setProxyNamespace($doctrineConfig['proxy']['namespace']);
     }
     if (isset($doctrineConfig['repository'])) {
         $configuration->setDefaultRepositoryClassName($doctrineConfig['repository']);
     }
     $namingStrategy = array_get($doctrineConfig, 'naming_strategy', 'Nord\\Lumen\\Doctrine\\ORM\\NamingStrategy');
     $configuration->setNamingStrategy(new $namingStrategy());
 }

 /**
  * @inheritdoc
  */
 public function start()
 {
     parent::start();
     $connectionConfig = $this->config('connection');
     if (!empty($connectionConfig) && is_array($connectionConfig)) {
         // Setup Doctrine. Largely borrowed from
         // https://github.com/l3pp4rd/DoctrineExtensions/blob/master/doc/annotations.md#em-setup
         // Register Doctrine default annotations.
         AnnotationRegistry::registerFile($this->getEngine()->getSiteInfo()->getSiteRoot() . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
         // Setup annotation metadata cache
         if ($this->getEngine()->getEnvironmentInfo()->isDevMode() || !$this->getEngine()->config('memcache.enabled')) {
             $cache = new ArrayCache();
         } else {
             $cache = new MemcacheCache();
             $cache->setMemcache($this->getEngine()->getMemcache());
         }
         // Setup annotation metadata reader and driver
         /** @var AnnotationReader $cachedAnnotationReader (for all intents and purposes...) */
         $cachedAnnotationReader = new CachedReader(new AnnotationReader(), $cache);
         $this->driverChain = new MappingDriverChain();
         $this->annotationDriver = new AnnotationDriver($cachedAnnotationReader, array($this->getEngine()->getApplicationInfo()->getSitegearRoot()));
         // Setup Gedmo extension annotations
         \Gedmo\DoctrineExtensions::registerAnnotations();
         $this->driverChain->addDriver($this->annotationDriver, 'Gedmo');
         // Setup Sitegear extension annotations
         // TODO Make model-providing modules declare their own namespaces
         $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\Customer\\Model');
         $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\News\\Model');
         $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\Locations\\Model');
         $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\Products\\Model');
         // Create the entity manager configuration, with proxy generation, cached metadata and lowercase-underscore
         // database naming convention.
         $entityManagerConfig = new Configuration();
         // TODO Make this a temp directory set in the engine config
         $entityManagerConfig->setProxyDir(sys_get_temp_dir());
         // TODO Configurable namespace and naming strategy
         $entityManagerConfig->setProxyNamespace('Proxy');
         $entityManagerConfig->setAutoGenerateProxyClasses($this->getEngine()->getEnvironmentInfo()->isDevMode());
         $entityManagerConfig->setMetadataDriverImpl($this->driverChain);
         $entityManagerConfig->setMetadataCacheImpl($cache);
         $entityManagerConfig->setQueryCacheImpl($cache);
         $entityManagerConfig->setNamingStrategy(new UnderscoreNamingStrategy(CASE_LOWER));
         // Setup event subscribers.
         $eventManager = new EventManager();
         foreach ($this->config('orm.subscribers') as $subscriberConfig) {
             /** @var \Doctrine\Common\EventSubscriber $subscriber */
             $subscriber = TypeUtilities::buildTypeCheckedObject($subscriberConfig['class'], 'event subscriber', null, array('\\Doctrine\\Common\\EventSubscriber'), isset($subscriberConfig['arguments']) ? $subscriberConfig['arguments'] : array());
             if ($subscriber instanceof MappedEventSubscriber) {
                 /** @var MappedEventSubscriber $subscriber */
                 $subscriber->setAnnotationReader($cachedAnnotationReader);
             }
             $eventManager->addEventSubscriber($subscriber);
         }
         // Create the entity manager using the configured connection parameters.
         $this->entityManager = EntityManager::create($this->config('connection'), $entityManagerConfig, $eventManager);
         // Register the JSON custom data type.  This has to be done last, when the entity manager has a connection.
         foreach ($this->config('dbal.types') as $key => $className) {
             Type::addType($key, $className);
             $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping(preg_replace('/^.*\\\\(.*?)$/', '$1', $className), $key);
         }
     } else {
         throw new \DomainException('<h1>Incorrect or Missing Configuration</h1><p>You have attempted to use the Doctrine module in your site, but you have not provided all the required connection parameters in your configuration file.</p><p>Please rectify this by providing connection parameters ("driver", "dbname", plus normally "username" and "password") or disabling the Doctrine module.</p>');
     }
 }

 /**
  * {@inheritdoc}
  */
 protected function createWithConfig(ContainerInterface $container, $configKey)
 {
     $config = $this->retrieveConfig($container, $configKey, 'configuration');
     $configuration = new Configuration();
     $configuration->setProxyDir($config['proxy_dir']);
     $configuration->setProxyNamespace($config['proxy_namespace']);
     $configuration->setAutoGenerateProxyClasses($config['auto_generate_proxy_classes']);
     $configuration->setEntityNamespaces($config['entity_namespaces']);
     $configuration->setCustomDatetimeFunctions($config['datetime_functions']);
     $configuration->setCustomStringFunctions($config['string_functions']);
     $configuration->setCustomNumericFunctions($config['numeric_functions']);
     $configuration->setCustomHydrationModes($config['custom_hydration_modes']);
     $configuration->setClassMetadataFactoryName($config['class_metadata_factory_name']);
     foreach ($config['named_queries'] as $name => $dql) {
         $configuration->addNamedQuery($name, $dql);
     }
     foreach ($config['named_native_queries'] as $name => $query) {
         $configuration->addNamedNativeQuery($name, $query['sql'], $query['rsm']);
     }
     foreach ($config['filters'] as $name => $className) {
         $configuration->addFilter($name, $className);
     }
     $configuration->setMetadataCacheImpl($this->retrieveDependency($container, $config['metadata_cache'], 'cache', CacheFactory::class));
     $configuration->setQueryCacheImpl($this->retrieveDependency($container, $config['query_cache'], 'cache', CacheFactory::class));
     $configuration->setResultCacheImpl($this->retrieveDependency($container, $config['result_cache'], 'cache', CacheFactory::class));
     $configuration->setHydrationCacheImpl($this->retrieveDependency($container, $config['hydration_cache'], 'cache', CacheFactory::class));
     $configuration->setMetadataDriverImpl($this->retrieveDependency($container, $config['driver'], 'driver', DriverFactory::class));
     if (is_string($config['naming_strategy'])) {
         $configuration->setNamingStrategy($container->get($config['naming_strategy']));
     } elseif (null !== $config['naming_strategy']) {
         $configuration->setNamingStrategy($config['naming_strategy']);
     }
     if (is_string($config['repository_factory'])) {
         $configuration->setRepositoryFactory($container->get($config['repository_factory']));
     } elseif (null !== $config['repository_factory']) {
         $configuration->setRepositoryFactory($config['repository_factory']);
     }
     if (is_string($config['entity_listener_resolver'])) {
         $configuration->setEntityListenerResolver($container->get($config['entity_listener_resolver']));
     } elseif (null !== $config['entity_listener_resolver']) {
         $configuration->setEntityListenerResolver($config['entity_listener_resolver']);
     }
     if (null !== $config['default_repository_class_name']) {
         $configuration->setDefaultRepositoryClassName($config['default_repository_class_name']);
     }
     if ($config['second_level_cache']['enabled']) {
         $regionsConfig = new RegionsConfiguration($config['second_level_cache']['default_lifetime'], $config['second_level_cache']['default_lock_lifetime']);
         foreach ($config['second_level_cache']['regions'] as $regionName => $regionConfig) {
             if (array_key_exists('lifetime', $regionConfig)) {
                 $regionsConfig->setLifetime($regionName, $regionConfig['lifetime']);
             }
             if (array_key_exists('lock_lifetime', $regionConfig)) {
                 $regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']);
             }
         }
         $cacheFactory = new DefaultCacheFactory($regionsConfig, $configuration->getResultCacheImpl());
         $cacheFactory->setFileLockRegionDirectory($config['second_level_cache']['file_lock_region_directory']);
         $cacheConfiguration = new CacheConfiguration();
         $cacheConfiguration->setCacheFactory($cacheFactory);
         $cacheConfiguration->setRegionsConfiguration($regionsConfig);
         $configuration->setSecondLevelCacheEnabled(true);
         $configuration->setSecondLevelCacheConfiguration($cacheConfiguration);
     }
     if (is_string($config['sql_logger'])) {
         $configuration->setSQLLogger($container->get($config['sql_logger']));
     } elseif (null !== $config['sql_logger']) {
         $configuration->setSQLLogger($config['sql_logger']);
     }
     return $configuration;
 }

 public function register(Container $c)
 {
     parent::register($c);
     $c['orm.options'] = array();
     $c['orm.types'] = array();
     $c['orm.proxies_dir'] = sys_get_temp_dir();
     $c['orm.proxies_namespace'] = 'DoctrineProxy';
     $c['orm.auto_generate_proxies'] = $c->factory(function ($c) {
         return $c['debug'];
     });
     $c['orm.custom.functions.string'] = array();
     $c['orm.custom.functions.numeric'] = array();
     $c['orm.custom.functions.datetime'] = array();
     $c['orm.custom.hydration_modes'] = array();
     $c['orm.class_metadata_factory_name'] = 'Doctrine\\ORM\\Mapping\\ClassMetadataFactory';
     $c['orm.default_repository_class'] = 'Doctrine\\ORM\\EntityRepository';
     $c['orm.initialize'] = $c->protect(function () use($c) {
         static $initialized = false;
         if ($initialized) {
             return;
         }
         $initialized = true;
         if (!isset($c['orm.options'])) {
             $c['orm.options'] = array('default' => array());
         } elseif (!is_array(reset($c['orm.options']))) {
             // Se o primeiro elemento do array de opções não for um array,
             // muito provavelmente o usuário está colocando as options de
             // uma única conexão, então usar como default
             $c['orm.options'] = array('default' => $c['orm.options']);
         }
         $tmp = $c['orm.options'];
         foreach ($tmp as $name => &$options) {
             if (!isset($options['connection'])) {
                 throw new \LogicException("Missing 'connection' param in Doctrine ORM in {$name}.");
             }
             if (is_string($options['connection'])) {
                 $options['connection'] = $c['dbal.options'][$options['connection']];
             } elseif (!is_array($options['connection']) && !$options['connection'] instanceof Connection) {
                 throw new \LogicException("Param 'connection' in {$name} must be a string, array or a Connection instance.");
             }
         }
         $c['orm.options'] = $tmp;
         $c['orm.defaultName'] = key($c['orm.options']);
     });
     $c['orm.ems'] = function ($c) {
         $c['orm.initialize']();
         $ems = new Container();
         foreach ($c['orm.options'] as $name => $options) {
             $config = $c['orm.configs'][$name];
             $connection = $options['connection'];
             $ems[$name] = function ($ems) use($connection, $config) {
                 return EntityManager::create($connection, $config);
             };
         }
         return $ems;
     };
     $c['orm.configs'] = function ($c) {
         $c['orm.initialize']();
         $configs = new Container();
         foreach ($c['orm.options'] as $name => $options) {
             $configs[$name] = $config = new Configuration();
             $config->setProxyDir($c['orm.proxies_dir']);
             $config->setProxyNamespace($c['orm.proxies_namespace']);
             $config->setAutoGenerateProxyClasses($c['orm.auto_generate_proxies']);
             $config->setCustomStringFunctions($c['orm.custom.functions.string']);
             $config->setCustomNumericFunctions($c['orm.custom.functions.numeric']);
             $config->setCustomDatetimeFunctions($c['orm.custom.functions.datetime']);
             $config->setCustomHydrationModes($c['orm.custom.hydration_modes']);
             $config->setClassMetadataFactoryName($c['orm.class_metadata_factory_name']);
             $config->setDefaultRepositoryClassName($c['orm.default_repository_class']);
             $config->setEntityListenerResolver($c['orm.entity_listener_resolver']);
             $config->setRepositoryFactory($c['orm.repository_factory']);
             $config->setNamingStrategy($c['orm.strategy.naming']);
             $config->setQuoteStrategy($c['orm.strategy.quote']);
             $chain = new MappingDriverChain();
             $config->setMetadataDriverImpl($chain);
             foreach ((array) $options['mappings'] as $entity) {
                 if (!is_array($entity)) {
                     throw new \InvalidArgumentException("The 'orm.options' option 'mappings' should be an array of arrays.");
                 }
                 if (isset($entity['alias'])) {
                     $config->addEntityNamespace($entity['alias'], $entity['namespace']);
                 }
                 switch ($entity['type']) {
                     case 'annotation':
                         if (isset($c['annotation.reader'])) {
                             $driver = new AnnotationDriver($c['annotation.reader'], (array) $entity['path']);
                         } else {
                             $simple = isset($entity['use_simple_annotation_reader']) ? $entity['use_simple_annotation_reader'] : true;
                             $driver = $config->newDefaultAnnotationDriver((array) $entity['path'], $simple);
                         }
                         break;
                     case 'yml':
                         $driver = new YamlDriver($entity['path']);
                         break;
                     case 'simple_yml':
                         $driver = new SimplifiedYamlDriver(array($entity['path'] => $entity['namespace']));
                         break;
                     case 'xml':
                         $driver = new XmlDriver($entity['path']);
//.........这里部分代码省略.........

 protected function setupNamingStrategy(Configuration $config, $spec)
 {
     $strategyClass = $spec['naming_strategy'];
     if (isset($strategyClass)) {
         $strategy = new $strategyClass();
         $config->setNamingStrategy($strategy);
         if (isset($spec['table_prefixes']) && method_exists($strategy, 'setTablePrefixes')) {
             $strategy->setTablePrefixes($spec['table_prefixes']);
         }
     }
 }