Symfony: Your Next Microframework (SymfonyCon 2015)

Symfony:
Your Next Microframework
by your friend:
Ryan Weaver
@weaverryan
by your friend:
Ryan Weaver
@weaverryan

KnpUniversity.com

github.com/weaverryan
Who is this guy?
> Lead for the Symfony documentation 
> KnpLabs US - Symfony Consulting,

training & general Kumbaya

> Writer for KnpUniversity.com Tutorials
> Husband of the much more

talented @leannapelham

Thinking about 2
Problems
@weaverryan

Problem 1:

Symfony Sucks
@weaverryan

Symfony

is too hard
@weaverryan

The Symfony Framework

is too hard
@weaverryan
The components are not usually the
problem

Route

Controller

Response
@weaverryan
WTF?
Useful Objects

1) Common tasks require 
too much code
@weaverryan

2) Symfony is too big
@weaverryan

Too many ﬁles

==

A Perceived Complexity
@weaverryan

@weaverryan
~ 25 ﬁles
~ 10 directories
for Hello World

Problem 2:

Is my project

macro or micro?
@weaverryan

Macro => Use Symfony
@weaverryan

Micro => Use Silex
@weaverryan

The fact we have this
option is incredible

but…
@weaverryan

Silex has a slightly
diﬀerent tech stack
@weaverryan

Silex doesn’t have bundles
@weaverryan

Silex can’t evolve to a full
stack Symfony App
@weaverryan

What if we just made
Symfony smaller?
@weaverryan

Symfony: Your Next Microframework (SymfonyCon 2015)

<?php 
 
use SymfonyComponentHttpKernelKernel; 
use SymfonyComponentConfigLoaderLoaderInterface; 
 
class AppKernel extends Kernel 
{ 
public function registerBundles() 
{ 
return array( 
new SymfonyBundleFrameworkBundleFrameworkBundle(), 
new SymfonyBundleTwigBundleTwigBundle(), 
); 
} 
 
public function registerContainerConfiguration($loader) 
{ 
$loader->load( 
__DIR__.'/config/config_'.$this->getEnvironment().'.yml' 
); 
} 
}

How small can we go?
@weaverryan

What is a Symfony
Application?
@weaverryan

What is a Symfony App?
@weaverryan
1.A set of bundles
2.A container of services
3.Routes

Let’s create a new

Symfony project

from nothing
@weaverryan

{ 
"require": { 
"symfony/symfony": "^2.8" 
} 
}
@weaverryan
composer.json

<?php 
 
use SymfonyComponentConfigLoaderLoaderInterface; 
use SymfonyComponentHttpKernelKernel; 
 
require __DIR__.'/vendor/autoload.php'; 
 
{ 
{ 
} 
 
{ 
} 
} 
index.php

<?php 
 
use SymfonyBundleFrameworkBundleKernelMicroKernelTrait; 
use SymfonyComponentDependencyInjectionContainerBuilder; 
use SymfonyComponentRoutingRouteCollectionBuilder;
// ... 
 
{ 
use MicroKernelTrait; 
 
{ 
} 
 
protected function configureRoutes(RouteCollectionBuilder $routes) 
{ 
} 
 
protected function configureContainer(ContainerBuilder $c, $loader) 
{ 
} 
} 
index.php
1) A set of bundles
2) Routes
3) A container of services

{ 
return array( 
new SymfonyBundleFrameworkBundleFrameworkBundle() 
); 
}
AppKernel

{ 
$c->loadFromExtension('framework', array( 
'secret' => 'S0ME_SECRET', 
)); 
}
AppKernel
// config.yml
framework: 
secret: S0ME_SECRET

{ 
$routes->add('/random/{limit}', 'kernel:randomAction'); 
}
AppKernel
New in 2.8!
service:methodName
(Symfony’s controller as a service syntax)

public function randomAction($limit) 
{ 
return new JsonResponse(array( 
'number' => rand(0, $limit) 
)); 
}
AppKernel

<?php 
 
// ... 
 
require __DIR__.'/vendor/autoload.php'; 
 
 
{ 
// ... 
} 
 
$kernel = new AppKernel('dev', true); 
$request = Request::createFromGlobals(); 
$response = $kernel->handle($request); 
$response->send(); 
$kernel->terminate($request, $response); 
index.php

How many ﬁles?
@weaverryan
How many lines of code?

This is a full stack
framework
@weaverryan

@weaverryan
1. Service Container
2. Routing
3. Events
4. ESI & Sub-Requests
5. Compatible with 3rd party bundles

The goal is not to create
single-ﬁle apps
@weaverryan

Building a
Realistic App
@weaverryan
github.com/weaverryan/docs-micro_kernel

Requirements:
@weaverryan
1. Add some organization
2. Load annotation routes
3. Web Debug Toolbar + Proﬁler
4. Twig

Reorganize
{ 
} 
// web/index.php 
$kernel = new AppKernel('dev', true); 
$response->send();

{ 
$bundles = array( 
new FrameworkBundle(), 
new TwigBundle(), 
new SensioFrameworkExtraBundle() 
); 
 
if ($this->getEnvironment() == 'dev') { 
$bundles[] = new WebProfilerBundle(); 
} 
 
return $bundles; 
}
app/AppKernel.php

{ 
$loader->load(__DIR__.'/config/config.yml'); 
 
if (isset($this->bundles['WebProfilerBundle'])) { 
$c->loadFromExtension('web_profiler', array( 
'toolbar' => true, 
'intercept_redirects' => false, 
)); 
} 
}
app/AppKernel.php
@weaverryan

app/conﬁg/conﬁg.yml
framework: 
secret: S0ME_SECRET 
templating: 
engines: ['twig'] 
profiler: { only_exceptions: false }
@weaverryan

{ 
 
$c->loadFromExtension('web_profiler', array( 
'toolbar' => true, 
'intercept_redirects' => false, 
)); 
} 
}
app/AppKernel.php
@weaverryan
Goodbye conﬁg_dev.yml

{ 
$routes->import( 
'@WebProfilerBundle/Resources/config/routing/wdt.xml', 
'_wdt' 
); 
$routes->import( 
'@WebProfilerBundle/Resources/config/routing/profiler.xml', 
'/_profiler' 
); 
} 
 
$routes->import(__DIR__.'/../src/App/Controller/', '/', 'annotation') 
}
app/AppKernel.php
Goodbye routing_dev.yml

@weaverryan
{ 
$loader->load(__DIR__ . '/config/config.yml'); 
 
$c->setParameter('secret', getenv('SECRET')); 
$c->loadFromExtension('doctrine', [ 
'dbal' => [ 
'driver' => 'pdo_mysql', 
'host' => getenv('DATABASE_HOST'), 
'user' => getenv('DATABASE_USER'), 
'password' => getenv('DATABASE_PASS'), 
] 
]); 
// ... 
}
Environment Variables

@weaverryan
{ 
 
if (in_array($this->getEnvironment(), ['dev', 'test'])) { 
 
$c->loadFromExtension('framework', [ 
'profiler' => ['only_exceptions' => false] 
]); 
 
} 
 
// ... 
}
Environment Control

@weaverryan
Build Services
{ 
// ... 
 
$c->register('santa.controller', SantaController::class) 
->setAutowired(true); 
 
}

@weaverryan
Build Routes
{ 
// ... 
$routes->add('/santa', 'AppBundle:Santa:northPole'); 
 
$routes->add(‘/naughty-list/{page}’, 'AppBundle:Santa:list') 
->setRequirement('list', 'd+') 
->setDefault('page', 1); 
}

@weaverryan
Bundless
Applications?

@weaverryan
Wait, what does a
bundle even give me?

A bundle gives you:
@weaverryan
1. Services
2. A resource root (e.g. path to load templates)
3. Magic functionality (e.g. commands)
4. Shortcuts
(_controller, AppBundle:User)

@weaverryan
1) Services
{ 
// ... 
 
$c->register('santa.controller', SantaController::class) 
->setAutowired(true); 
 
}

2) Resource Root
{ 
// ... 
 
$c->loadFromExtension('twig', [ 
'paths' => [__DIR__.'/Resources/views' => 'north_pole'] 
]); 
}
public function randomAction($limit) 
{ 
$number = rand(0, $limit); 
 
return $this->render(‘@north_pole/micro/random.html.twig’, [ 
'number' => $number 
]); 
}

@weaverryan
3) Magic Functionality
1. Register commands as services
2. Conﬁgure Doctrine mappings to load your
Entity directory

@weaverryan
4) Shortcuts
santa: 
controller: AppBundle:Santa:xmas 
controller: AppBundleControllerSantaController::xmasAction
$em->getRepository('AppBundle:App'); 
$em->getRepository('AppBundleEntityApp');

@weaverryan
One New Trick
{ 
$routes->import(__DIR__.’@AppBundle/Controller/‘, '/', 'annotation') 
}
{ 
$routes->import(__DIR__.'/../src/App/Controller/', '/', 'annotation') 
}

Multiple kernels, why?
@weaverryan
1. micro service architecture in monolithic
repository
2. performance (less routes, services &
listeners)

Multiple kernels was
always possible
@weaverryan

Now they’re obvious
@weaverryan

// app/ApiKernel.php
class ApiKernel extends Kernel 
{ 
use MicroKernelTrait; 
 
{ 
$bundles = array( 
new FrameworkBundle(), 
new SensioFrameworkExtraBundle() 
); 
 
return $bundles; 
} 
}
No TwigBundle

{ 
// ... 
 
protected function configureContainer($c, $loader) 
{ 
$loader->load(__DIR__.'/config/api.yml'); 
} 
}
Use PHP logic to load share
conﬁg, and custom conﬁg

{ 
// ... 
 
protected function configureRoutes($routes) 
{ 
$routes->import( 
__DIR__.'/../src/Api/Controller/', 
'/api', 
'annotation' 
); 
} 
 
public function getCacheDir() 
{ 
return __DIR__.’/../var/cache/api/'
.$this->getEnvironment(); 
} 
}
Load diﬀerent routes
cacheDir ~= the cache key

Boot the correct kernel
however you want
@weaverryan

// web/index.php
use SymfonyComponentHttpFoundationRequest; 
 
require __DIR__.'/../app/autoload.php'; 
 
 
if (strpos($request->getPathInfo(), '/api') === 0) { 
require __DIR__.'/../app/ApiKernel.php'; 
$kernel = new ApiKernel('dev', true); 
} else { 
require __DIR__.'/../app/WebKernel.php'; 
$kernel = new WebKernel('dev', true); 
} 
 
$response->send();

But how does it work?
@weaverryan

There is one person

who *hates* the name

MicroKernelTrait
@weaverryan

trait MicroKernelTrait 
{ 
abstract protected function configureRoutes(RouteCollectionBuilder $routes); 
abstract protected function configureContainer(ContainerBuilder $c, $loader); 
 
{ 
$loader->load(function ($container) use ($loader) { 
$container->loadFromExtension('framework', array( 
'router' => array( 
'resource' => 'kernel:loadRoutes', 
'type' => 'service', 
), 
)); 
 
$this->configureContainer($container, $loader); 
}); 
} 
 
public function loadRoutes(LoaderInterface $loader) 
{ 
$routes = new RouteCollectionBuilder($loader); 
$this->configureRoutes($routes); 
 
return $routes->build(); 
} 
}
Closure Loader
New service route loader

I have a big project…
@weaverryan
Use it for clarity

I’m teaching
@weaverryan
Show it for simplicity

I have a small app
@weaverryan
Show it for power

@weaverryan
PHP & Symfony Video Tutorials
KnpUniversity.com
Thank You!

Symfony: Your Next Microframework (SymfonyCon 2015)

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Symfony: Your Next Microframework (SymfonyCon 2015) (20)

More from Ryan Weaver (14)

Recently uploaded (20)

Symfony: Your Next Microframework (SymfonyCon 2015)