Magento makes extensive use of caching. The System | Tools | Cache Management section enables us to Enable | Disable | Refresh the cache from the comfort of the graphical interface. During development, the use of the console is more convenient and faster.

The following cache-related commands are supported:

cache
  cache:clean Cleans cache type(s)
  cache:disable Disables cache type(s)
  cache:enable Enables cache type(s)
  cache:flush Flushes cache storage used by cache type(s)
  cache:status Checks cache status

Out of the box, Magento Open Source comes with 14 different cache types. We can easily get the status of each cache type by running the php bin/magento cache:status command, which gives the following output:

Current status:
                config: 0
                layout: 0
            block_html: 0
           collections: 0
            reflection: 0
                db_ddl: 0
                   eav: 0
 customer_notification: 0
      the_custom_cache: 1
    config_integration: 0
config_integration_api: 0
             full_page: 0
             translate: 0
     config_webservice: 0

We can use the enable | disable | clean cache commands to impact one or more cache types at once.

If built-in cache types are not enough, we can always create our own.

Creating a new cache type in Magento is as easy as doing the following:

Create the <MAGELICIOUS_DIR>/Core/etc/cache.xml file with the following content:

<config>
    <type name="the_custom_cache" translate="label,description" instance="MageliciousCoreModelCacheTheCustomCache">
        <label>The Custom Cache</label>
        <description>Our custom cache type</description>
    </type>
</config>

Create the <MAGELICIOUS_DIR>/Core/Model/Cache/TheCustomCache.php file with the following content:

class TheCustomCache extends MagentoFrameworkCacheFrontendDecoratorTagScope {
    const TYPE_IDENTIFIER = 'the_custom_cache';
    const CACHE_TAG = 'THE_CUSTOM_CACHE';

    public function __construct(MagentoFrameworkAppCacheTypeFrontendPool $cacheFrontendPool) {
        parent::__construct($cacheFrontendPool->get(self::TYPE_IDENTIFIER), self::CACHE_TAG);
    }
}

The TYPE_IDENTIFIER is used internally as a cache type code that is unique among all cache types. The CACHE_TAG is a cache tag that's used to distinguish the cache type from all other caches. Running cache:status should now show our custom cache type on the list.

We can use the instance of MagentoFrameworkAppCacheTypeListInterface to invalidate the cache, as follows:

$this->typeList->invalidate(MageliciousCoreModelCacheTheCustomCache::TYPE_IDENTIFIER);

We can use the instance of MagentoFrameworkAppCacheManager $cacheManager to programmatically execute the same enable | disable | clean operations as per the following example:

$cacheManager->setEnabled(
    [MageliciousCoreModelCacheTheCustomCache::TYPE_IDENTIFIER], 
    true
);

$cacheManager->clean([MageliciousCoreModelCacheTheCustomCache::TYPE_IDENTIFIER]);

$cacheManager->flush([MageliciousCoreModelCacheTheCustomCache::TYPE_IDENTIFIER]);

Saving data to cache requires serialization, as per the following example:

// MagentoFrameworkConfigCacheInterface $cache
// MagentoFrameworkSerializeSerializerInterface $serializer
// MagentoFrameworkAppCacheStateInterface $cacheState

$isCacheEnabled = $cacheState->isEnabled(MageliciousCoreModelCacheTheCustomCache::TYPE_IDENTIFIER);

$cacheId = 'some-unique-identifier';

if ($isCacheEnabled) {
    $cache->save(
        $serializer->serialize('some-data'),
        $cacheId,
        [
            MageliciousCoreModelCacheTheCustomCache::CACHE_TAG
        ]
    );
}

Reading data from the cache is as easy as per the following example:

if ($cacheData = $this->cache->load($cacheId);) {
    $someData = $this->getSerializer()->unserialize($cacheData);
} else {
    $someData = $this->fetchSomeData();
}