class AliasManager
Same name in other branches
- 9 core/modules/path_alias/src/AliasManager.php \Drupal\path_alias\AliasManager
- 8.9.x core/modules/path_alias/src/AliasManager.php \Drupal\path_alias\AliasManager
- 8.9.x core/lib/Drupal/Core/Path/AliasManager.php \Drupal\Core\Path\AliasManager
- 10 core/modules/path_alias/src/AliasManager.php \Drupal\path_alias\AliasManager
The default alias manager implementation.
Hierarchy
- class \Drupal\path_alias\AliasManager implements \Drupal\path_alias\AliasManagerInterface
Expanded class hierarchy of AliasManager
3 files declare their use of AliasManager
- AliasManagerTest.php in core/
modules/ path_alias/ tests/ src/ Unit/ AliasManagerTest.php - AliasTest.php in core/
modules/ path_alias/ tests/ src/ Kernel/ AliasTest.php - PathProcessorTest.php in core/
tests/ Drupal/ Tests/ Core/ PathProcessor/ PathProcessorTest.php
1 string reference to 'AliasManager'
- path_alias.services.yml in core/
modules/ path_alias/ path_alias.services.yml - core/modules/path_alias/path_alias.services.yml
1 service uses AliasManager
- path_alias.manager in core/
modules/ path_alias/ path_alias.services.yml - Drupal\path_alias\AliasManager
File
-
core/
modules/ path_alias/ src/ AliasManager.php, line 13
Namespace
Drupal\path_aliasView source
class AliasManager implements AliasManagerInterface {
/**
* The cache key to use when caching paths.
*
* @var string
*/
protected $cacheKey;
/**
* Whether the cache needs to be written.
*
* @var bool
*/
protected $cacheNeedsWriting = FALSE;
/**
* Holds the map of path lookups per language.
*
* @var array
*/
protected $lookupMap = [];
/**
* Holds an array of aliases for which no path was found.
*
* @var array
*/
protected $noPath = [];
/**
* Holds an array of paths that have no alias.
*
* @var array
*/
protected $noAlias = [];
/**
* Whether preloaded path lookups has already been loaded.
*
* @var array
*/
protected $langcodePreloaded = [];
/**
* Holds an array of previously looked up paths for the current request path.
*
* This will only get populated if a cache key has been set, which for example
* happens if the alias manager is used in the context of a request.
*
* @var array
*/
protected $preloadedPathLookups = FALSE;
public function __construct(AliasRepositoryInterface $pathAliasRepository, AliasPrefixListInterface $pathPrefixes, LanguageManagerInterface $languageManager, CacheBackendInterface $cache, TimeInterface $time) {
}
/**
* {@inheritdoc}
*/
public function setCacheKey($key) {
// Prefix the cache key to avoid clashes with other caches.
$this->cacheKey = 'preload-paths:' . $key;
}
/**
* {@inheritdoc}
*
* Cache an array of the paths available on each page. We assume that aliases
* will be needed for the majority of these paths during subsequent requests,
* and load them in a single query during path alias lookup.
*/
public function writeCache() {
// Check if the paths for this page were loaded from cache in this request
// to avoid writing to cache on every request.
if ($this->cacheNeedsWriting && !empty($this->cacheKey)) {
// Start with the preloaded path lookups, so that cached entries for other
// languages will not be lost.
$path_lookups = $this->preloadedPathLookups ?: [];
foreach ($this->lookupMap as $langcode => $lookups) {
$path_lookups[$langcode] = array_keys($lookups);
if (!empty($this->noAlias[$langcode])) {
$path_lookups[$langcode] = array_merge($path_lookups[$langcode], array_keys($this->noAlias[$langcode]));
}
}
$twenty_four_hours = 60 * 60 * 24;
$this->cache
->set($this->cacheKey, $path_lookups, $this->time
->getRequestTime() + $twenty_four_hours);
}
}
/**
* {@inheritdoc}
*/
public function getPathByAlias($alias, $langcode = NULL) {
// If no language is explicitly specified we default to the current URL
// language. If we used a language different from the one conveyed by the
// requested URL, we might end up being unable to check if there is a path
// alias matching the URL path.
$langcode = $langcode ?: $this->languageManager
->getCurrentLanguage(LanguageInterface::TYPE_URL)
->getId();
// If we already know that there are no paths for this alias simply return.
if (empty($alias) || !empty($this->noPath[$langcode][$alias])) {
return $alias;
}
// Look for the alias within the cached map.
if (isset($this->lookupMap[$langcode]) && ($path = array_search($alias, $this->lookupMap[$langcode]))) {
return $path;
}
// Look for path in storage.
if ($path_alias = $this->pathAliasRepository
->lookupByAlias($alias, $langcode)) {
$this->lookupMap[$langcode][$path_alias['path']] = $alias;
return $path_alias['path'];
}
// We can't record anything into $this->lookupMap because we didn't find any
// paths for this alias. Thus cache to $this->noPath.
$this->noPath[$langcode][$alias] = TRUE;
return $alias;
}
/**
* {@inheritdoc}
*/
public function getAliasByPath($path, $langcode = NULL) {
if (!str_starts_with($path, '/')) {
throw new \InvalidArgumentException(sprintf('Source path %s has to start with a slash.', $path));
}
// If no language is explicitly specified we default to the current URL
// language. If we used a language different from the one conveyed by the
// requested URL, we might end up being unable to check if there is a path
// alias matching the URL path.
$langcode = $langcode ?: $this->languageManager
->getCurrentLanguage(LanguageInterface::TYPE_URL)
->getId();
// Check the path prefix, if the top-level part before the first / is not in
// the list, then there is no need to do anything further, it is not in the
// database.
if ($path === '/' || !$this->pathPrefixes
->get(strtok(trim($path, '/'), '/'))) {
return $path;
}
// During the first call to this method per language, load the expected
// paths for the page from cache.
if (empty($this->langcodePreloaded[$langcode])) {
$this->langcodePreloaded[$langcode] = TRUE;
$this->lookupMap[$langcode] = [];
// Load the cached paths that should be used for preloading. This only
// happens if a cache key has been set.
if ($this->preloadedPathLookups === FALSE) {
$this->preloadedPathLookups = [];
if ($this->cacheKey) {
if ($cached = $this->cache
->get($this->cacheKey)) {
$this->preloadedPathLookups = $cached->data;
}
else {
$this->cacheNeedsWriting = TRUE;
}
}
}
// Load paths from cache.
if (!empty($this->preloadedPathLookups[$langcode])) {
$this->lookupMap[$langcode] = $this->pathAliasRepository
->preloadPathAlias($this->preloadedPathLookups[$langcode], $langcode);
// Keep a record of paths with no alias to avoid querying twice.
$this->noAlias[$langcode] = array_flip(array_diff($this->preloadedPathLookups[$langcode], array_keys($this->lookupMap[$langcode])));
}
}
// If we already know that there are no aliases for this path simply return.
if (!empty($this->noAlias[$langcode][$path])) {
return $path;
}
// If the alias has already been loaded, return it from static cache.
if (isset($this->lookupMap[$langcode][$path])) {
return $this->lookupMap[$langcode][$path];
}
// Try to load alias from storage.
if ($path_alias = $this->pathAliasRepository
->lookupBySystemPath($path, $langcode)) {
$this->lookupMap[$langcode][$path] = $path_alias['alias'];
return $path_alias['alias'];
}
// We can't record anything into $this->lookupMap because we didn't find any
// aliases for this path. Thus cache to $this->noAlias.
$this->noAlias[$langcode][$path] = TRUE;
return $path;
}
/**
* {@inheritdoc}
*/
public function cacheClear($source = NULL) {
// Note this method does not flush the preloaded path lookup cache. This is
// because if a path is missing from this cache, it still results in the
// alias being loaded correctly, only less efficiently.
if ($source) {
foreach (array_keys($this->lookupMap) as $lang) {
unset($this->lookupMap[$lang][$source]);
}
}
else {
$this->lookupMap = [];
}
$this->noPath = [];
$this->noAlias = [];
$this->langcodePreloaded = [];
$this->preloadedPathLookups = [];
$this->pathAliasPrefixListRebuild($source);
}
/**
* Rebuild the path alias prefix list.
*
* @param string $path
* An optional path for which an alias is being inserted.
*/
protected function pathAliasPrefixListRebuild($path = NULL) {
// When paths are inserted, only rebuild the prefix list if the path has a top
// level component which is not already in the prefix list.
if (!empty($path)) {
if ($this->pathPrefixes
->get(strtok($path, '/'))) {
return;
}
}
$this->pathPrefixes
->clear();
}
/**
* Rebuild the path alias prefix list.
*
* @param string $path
* An optional path for which an alias is being inserted.
*
* @deprecated in drupal:11.1.0 and is removed from drupal:12.0.0.
* Use \Drupal\path_alias\AliasManager::pathAliasPrefixListRebuild instead.
*
* @see https://www.drupal.org/node/3467559
*/
protected function pathAliasWhitelistRebuild($path = NULL) {
@trigger_error(__METHOD__ . '() is deprecated in drupal:11.1.0 and is removed from drupal:12.0.0. Use \\Drupal\\path_alias\\AliasManager::pathAliasPrefixListRebuild() instead. See https://www.drupal.org/node/3467559', E_USER_DEPRECATED);
$this->pathAliasPrefixListRebuild($path);
}
}
Members
Title Sort descending | Deprecated | Modifiers | Object type | Summary |
---|---|---|---|---|
AliasManager::$cacheKey | protected | property | The cache key to use when caching paths. | |
AliasManager::$cacheNeedsWriting | protected | property | Whether the cache needs to be written. | |
AliasManager::$langcodePreloaded | protected | property | Whether preloaded path lookups has already been loaded. | |
AliasManager::$lookupMap | protected | property | Holds the map of path lookups per language. | |
AliasManager::$noAlias | protected | property | Holds an array of paths that have no alias. | |
AliasManager::$noPath | protected | property | Holds an array of aliases for which no path was found. | |
AliasManager::$preloadedPathLookups | protected | property | Holds an array of previously looked up paths for the current request path. | |
AliasManager::cacheClear | public | function | ||
AliasManager::getAliasByPath | public | function | ||
AliasManager::getPathByAlias | public | function | ||
AliasManager::pathAliasPrefixListRebuild | protected | function | Rebuild the path alias prefix list. | |
AliasManager::pathAliasWhitelistRebuild | Deprecated | protected | function | Rebuild the path alias prefix list. |
AliasManager::setCacheKey | public | function | ||
AliasManager::writeCache | public | function | Cache an array of the paths available on each page. We assume that aliases will be needed for the majority of these paths during subsequent requests, and load them in a single query during path alias lookup. |
|
AliasManager::__construct | public | function |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.