Doctrine Cache does the job but by implementing a standard the Symfony Cache seems to have another advantage besides its delievered anyway. So i checked it out.

Documentation is still a bit sparse and the best resource so far is this blogpost:
https://symfony.com/blog/new-in-symfony-3-1-cache-component

I wont go into detail on how you use the Cache but rather how you integrate it with Redis, which is my favourite Cache backend.

You can create a Cache service via the FrameworkBundle in your config.yml and you can also create a default Redis client to use with your Cache service.

framework:
    default_locale: de
    secret: ThisTokenIsNotSoSecretChangeIt
    assets: ~
    templating:
        engines: ['twig']
    cache:
	default_redis_provider: "redis://%cache.redis_host%:%cache.redis_port%/%cache:redis_db%"
        pools:
           sf_cache:
             adapter: cache.adapter.redis
             public: true
             default_lifetime: 1200
             provider: cache.default_redis_provider

When the Redis Extension is present it will use the extension elsewards it will use Predis, which is plain PHP.
You can also pass any other client. F.e. if you have already created a Predis client service in your app then just pass this as provider.

    cache:
        pools:
           sf_cache:
             adapter: cache.adapter.redis
             public: true
             default_lifetime: 1200
             provider: my.predis.client.service.id

I recently discovered SncRedisBundle and i have to say i like it :)
I used to create Predis clients directly because its very easy and thought i wouldnt need a bundle for this.
But with SncRedisBundle you get Logging and WebProfiler support additionally, which is great for development.
Also you get some more easy symfony integrations for other stuff as Doctrine, Mailings or Sessions which i dont use but maybe you do.
So check it out.

So my best move is to use SncRedisBundle to create a Redis client and integrate it with the Cache Component.

snc_redis:
    clients:
        sf_cache:
            type: predis
            alias: sf_cache
            dsn: "redis://%cache.redis_host%:%cache.redis_port%/0"
            logging: "%kernel.debug%"

framework:
    default_locale: de
    secret: ThisTokenIsNotSoSecretChangeIt
    assets: ~
    templating:
        engines: ['twig']
    cache:
        pools:
           sf_cache:
             adapter: cache.adapter.redis
             public: true
             default_lifetime: 1200
             provider: snc_redis.sf_cache

Now you have integrated caching with webprofiler appearance and logging, nice!

UPDATE
You can also add your snc redis client to the standard app cache, provided with symfony:

cache:
    prefix_seed: my-app
    app: cache.adapter.redis
    system: cache.adapter.redis
    default_redis_provider: snc_redis.cache

In some apps however you need to cache data behind the scenes, f.e. responses from API calls or custom objects sets.
Symfony2 itself doesnt have such a functionality on first sight (symfony2 doesnt, but Doctrine, see below) and so I searched for one and first found a bundle which utilize the Zend Cache lib:
https://github.com/KnpLabs/KnpZendCacheBundle

This worked well but as discussed here(https://github.com/KnpLabs/KnpZendCacheBundle/issues/2) this adds dependencies to your Symfony2 project. This is actually not necessary since Doctrine/Commons is almost always part of your Symfony2 distribution and the Doctrine/Commons provides a Cache Layer as well.
A very good one, indeed.

So if you need to cache data use Doctrine/Commons.

This Cache Layer abstracts the caching functionality and provides already various different backends for your caching data.
These are already build-in in the master version:

• APC
• Array
• Filesystem
• Memcache
• PhpFile
• Redis
• WinCache
• Xcache
• ZendData

You could even create your own on top of the CacheProvider class and the Cache interface.

In your Symfony2 project simply register your cache service of choice and your ready to go.
In your config.yml or services.yml add:

cache:
        class: Doctrine\Common\Cache\PhpFileCache
        arguments: [%kernel.cache_dir%]

And in your controller you can call the service and save and load data from the cache.

As you can see you can set a namespace for your cache data, so that you can easy use it for different scenarions in the same app.
Further you can set a time-to-live (TTL) in seconds as third parameter of the save method.

So after all symfony2 has a caching mechanism for data, its just a little hidden in the Doctrine/Commons dependency.

Update from the Update!!
LiipDoctrineCacheBundle is abanndoned, use https://github.com/doctrine/DoctrineCacheBundle
Update!!
————————————————————-

I just was told that there is a Bundle for the Doctrine/Commons cache:
https://github.com/liip/LiipDoctrineCacheBundle

So I recommend to use this.
The benefit of this is, you can configure your caches through yml files and you have one central cache reference. I guess this saves some bytes in case you use different caches with different namepaces.

So with the LiipDoctrineCacheBundle the above example would go like this (given you have already registered the bundle):

config.yml

liip_doctrine_cache:
    namespaces:
        mynamespace:
            namespace: mynamespace.cache
            type: php_file

IndexController.php

$cache = $container->get('liip_doctrine_cache.ns.[mynamespace]');
if (false === ($cached_data = $cache->fetch($cache_key))) {
            $cached_data = $SOMEAPI->getData($params);
            $cache->save($cache_key, $cached_data, 3600);//TTL 1h
}

Anyway: In the footer of my magento shop we might have a summary of the shopping cart,
which i simply put in the footer.phtml template file:

<?php if (Mage::getModel('checkout/cart')->getItemsCount() > 0): ?>
  <div class="footer_cart_widget">
    <a href="/checkout/cart" class="cart">
      <?php echo $this->__('Warenkorb') ?>:<br />
      <span class="cart_meta">
        <?php echo Mage::getModel('checkout/cart')->getItemsCount() ?>
        <?php if (Mage::getModel('checkout/cart')->getItemsCount() == 1): ?>
          Produkt: 
        <?php else: ?>
          Produkte: 
        <?php endif; ?>
        <?php echo $this->helper('checkout')->formatPrice(Mage::getSingleton('checkout/cart')->getQuote()->getGrandTotal()); ?>
      </span>
    </a>
  </div>
<?php endif; ?>

This means we might need to disable the caching for the footer HTML block,
so that my cart summary will stay dynamically generated.

This is how you can do it:

copy

app/code/core/Mage/Page/Block/Html/Footer.php

to

app/code/local/Mage/Page/Block/Html/Footer.php

and just comment out the following lines:

//$this->addData(array(
//    'cache_lifetime'=> false,
//    'cache_tags'    => array(Mage_Core_Model_Store::CACHE_TAG, Mage_Cms_Model_Block::CACHE_TAG)
//));

you could also put the cart values in the getCacheKeyInfo() method, but as this would result in caching a footer for any state of the shopping cart from my understanding, i don’t think it’s necessarily a good idea.