The Clean Architecture in php

Switching to Laravel
218
This layout file is largely the same as our layout in ZF2. We’re using Blade to render the area
named content, which was defined in our
dashboard.blade.php
template file, at a specific spot.
Each of our templates going forward will define this
content
section.
We’re also using Laravel’s
Session
facade to grab data from the session, namely our flash
message for when we need to alert the user to something awesome happening (we’ll get to that
in a bit when we start working on the other controllers).
The last thing we need to update is our route for the dashboard. Laravel routes are stored in
the
app/Http/routes.php
file. Currently, the only route defined is still pointing at the defunct
WelcomeController
. Let’s fix that:
Route
::
get
(
'/'
,
'DashboardController@indexAction'
);
Now we’re instructing Laravel to render the
DashboardController::indexAction()
when a
GET request is made to
/
.
Try it out in your browser. You should see our lovely dashboard, back in action!
This would make a good place to commit your code to source control.
If you’re just reading, but want to see the code in action, you can checkout the tag
15-laravel-dashboard:
git clone https://github.com/mrkrstphr/cleanphp-example.git
git checkout 15-laravel-dashboard
Customer Management
Now let’s move on to managing customers. We’ll start this time by defining the routes we need
for the
CustomersController
:
// app/Http/routes.php
// ...
Route
::
get
(
'/customers'
,
'CustomersController@indexAction'
);
Route
::
match
(
[
'get'
,
'post'
],
'/customers/new'
,
'CustomersController@newOrEditAction'
);
Route
::
match
(
[
'get'
,
'post'
],

Switching to Laravel
219
'/customers/edit/{id}'
,
'CustomersController@newOrEditAction'
);
These new routes are set up to the actions we laid out in Zend Framework 2. So let’s copy over
our
CustomersController
with the necessary changes to make it work for Laravel.
We’ll start by defining our basic controller:
// app/Http/Controllers/CustomersController.php
namespace
App\Http\Controllers;
use
CleanPhp\Invoicer\Domain\Repository\CustomerRepositoryInterface;
class
CustomersController
extends
Controller {
private
$customerRepository
;
public function
__construct
(
CustomerRepositoryInterface
$customerRepository
) {
$this
->
customerRepository
=
$customerRepository
;
}
// ...
}
This basic controller looks almost exactly like it did in ZF2, although missing some dependencies
(for now), and has been moved to a new namespace
App\Http\Controllers
.
Laravel ships with a very powerful
Service Container⁶⁵
that handles dependency injection very
well. When
CustomersController
is instantiated, it will automatically search the container for
CustomerRepositoryInterface
and load it if found. If not found, it will try to instantiate the
object, although in our case, it will not try to instantiate an interface.
So the next thing we need to do is get an entry for
CustomerRepositoryInterface
into the
service container. We’ll do so in the
app/Providers/AppServiceProvider.php
file:
⁶⁵
http://laravel.com/docs/container

Switching to Laravel
220
// app/Providers/AppServiceProvider.php
namespace
App\Providers;
use
CleanPhp\Invoicer\Domain\Repository\CustomerRepositoryInterface;
use
CleanPhp\Invoicer\Persistence\Doctrine\Repository\CustomerRepository;
use
Illuminate\Support\ServiceProvider;
class
AppServiceProvider
extends
ServiceProvider {
public function
register
() {
$this
->
app
->
bind
(
CustomerRepositoryInterface
::
class
,
function
(
$app
) {
return new
CustomerRepository(
$app
[
'Doctrine\ORM\EntityManagerInterface'
]
);
}
);
}
}
We bind an entry into the service manager with the fully qualified namespace name of
CustomerRepositoryInterface
, using the
::class
keyword off that object (if we refactor this
class and rename it, we won’t have to worry about missing some string-based references). When
invoked, this entry will return an instantiated
CustomerRepository
, passing along an instance
of Doctrine’s
EntityManager
, which comes from the Doctrine provider we setup earlier.
This is all we need to do to take care of the instantiate of the controller. Laravel takes care of the
rest!
Let’s move on to creating the Customer listing.
Customer Listing
We’ll start with the listing of customers (the
/customers
route, which translates to
indexAction()
Let’s add our
indexAction()
to
CustomersController
:
public function
indexAction
() {
$customers
=
$this
->
customerRepository
->
getAll
();
return
view(
'customers/index'
, [
'customers'
=>
$customers
]);
}
Just like in ZF2, we’re pulling all the customers out of the
CustomersRepository
, and passing
them along to the view. We’re using Laravel’s
view()
helper to define the template to render and
the data to provide to it.
Let’s create our view
resources/views/customers/index.blade.php
:

Switching to Laravel
221
@
extends
(
'layouts.layout'
)
@
section(
'content'
)
<
div class
=
"page-header clearfix"
>
<
h2 class
=
"pull-left"
>
Customers
h2
>
<
a href
=
"/customers/new"
class
=
"btn btn-success pull-right"
>
Create Customer
a
>
div
>
<
table class
=
"table"
>
<
thead
>
<
tr
>
<
th
>
#
<
th
>
Name
th
>
<
th
>
Email
th
>
tr
>
thead
>
php
foreach
(
$customers
as
$customer
)
:
?>

Switching to Laravel
222
ZF2 is organized as a collection of components. Namely, we’ll need the Zend InputFilter and Zend
StdLib (which houses the hydration classes) components. Unfortunately, ZF2 isn’t as modular as
it sets itself up to be. These two libraries actually depend on the Zend ServiceManager and Zend
I18N libraries, but they don’t state it in their
composer.json
file’s
require
block.
This is quite a bit of hogwash. We’ll need to require all these libs:
composer require zendframework/zend-inputfilter
\
zendframework/zend-servicemanager
\
zendframework/zend-i18n
\
zendframework/zend-stdlib
Once we have our Laravel application up and running, we’ll probably want to refactor away
these components to use their Laravel counterparts.
Another benefit at this point is that our Peridot tests should pass now with these dependencies
in place:
./vendor/bin/peridot specs
Now that we have these dependencies, we can inject them into the
CustomersController
constructor:
// app/Http/Controllers/CustomersController.php
namespace
App\Http\Controllers;
use
CleanPhp\Invoicer\Domain\Repository\CustomerRepositoryInterface;
use
CleanPhp\Invoicer\Service\InputFilter\CustomerInputFilter;
use
Zend\Stdlib\Hydrator\HydratorInterface;
class
CustomersController
extends
Controller {
protected
$customerRepository
;
protected
$inputFilter
;
protected
$hydrator
;
public function
__construct
(
CustomerRepositoryInterface
$customerRepository
,
CustomerInputFilter
$inputFilter
,
HydratorInterface
$hydrator
) {
$this
->
customerRepository
=
$customerRepository
;
$this
->
inputFilter
=
$inputFilter
;
$this
->
hydrator
=
$hydrator
;
}
// ...
}

Switching to Laravel
223
Laravel knows to simply instantiate the
CustomerInputFilter
, but it can’t instantiate an
interface, so we need to tell it what to do with
HydratorInterface
. Let’s instruct it to instantiate
Zend’s
ClassMethods
hydrator to meet this dependency:
use
Zend\Stdlib\Hydrator\ClassMethods;
use
Zend\Stdlib\Hydrator\HydratorInterface;
class
AppServiceProvider
extends
ServiceProvider {
public function
register
() {
$this
->
app
->
bind
(HydratorInterface
::
class
,
function
(
$app
) {
return new
ClassMethods();
});
// ...
}
}
Now when faced with a request for a
HydratorInterface
, Laravel will simply instantiate
ClassMethods
.
Let’s implement the
newOrEditAction()
:
// app/Http/Controllers/CustomersController.php
public function
newOrEditAction
(Request
$request
,
$id
=
''
) {
$viewModel
=
[];
$customer
=
$id
?
$this
->
customerRepository
->
getById
(
$id
)
:
new
Customer();
if
(
$request
->
getMethod
()
==
'POST'
) {
$this
->
inputFilter
->
setData
(
$request
->
request
->
all
());
if
(
$this
->
inputFilter
->
isValid
()) {
$this
->
hydrator
->
hydrate
(
$this
->
inputFilter
->
getValues
(),
$customer
);
$this
->
customerRepository
->
begin
()
->
persist
(
$customer
)
->
commit
();
Session
::
flash
(
'success'
,
'Customer Saved'
);
return new
RedirectResponse(

Switching to Laravel
224
'/customers/edit/'
.
$customer
->
getId
()
);
}
else
{
$this
->
hydrator
->
hydrate
(
$request
->
request
->
all
(),
$customer
);
$viewModel
[
'error'
]
=
$this
->
inputFilter
->
getMessages
();
}
}
$viewModel
[
'customer'
]
=
$customer
;
return
view(
'customers/new-or-edit'
,
$viewModel
);
}
So there’s a lot going on here, however it’s nearly identical to our ZF2 code for the same action.
Let’s step through it:
1. As we have a variable
{id}
in our route, Laravel is kind enough to pass that along as an
argument to the action. We’re also asking for an instance of
Illuminate\Http\Request
,
and Laravel is happy to oblige.
2. We setup an empty “ViewModel” array variable and use that throughout the method to
collect data to pass along to the view, which we do at the very end using Laravel’s
view()
helper.
3. If we have an ID, we utilize the
CustomerRepository
to retrieve that Customer from the
database, otherwise we instantiate an empty
Customer
object.
4. If the request is a
GET
request, we simply add the
$customer
to the
$viewModel
and carry
on.
5. If the request is a
POST
, we populate the
CustomerInputFilter
with the posted data, and
then check to see if the input filter is valid.
6. If the input is valid, we hydrate the
$customer
object with the posted values, persist it to
the repository, setup a flash success message using Laravel’s
Session
facade, and redirect
to the edit page for the Customer.
7. If the input is not valid, we hydrate the customer with the raw posted data, store the
validation error messages in the
$viewModel
, and carry on.
For this to work, we’ll need to add a couple more
use
statements to the top of the controller (I
recommend alphabetizing them):

Switching to Laravel
225
use
CleanPhp\Invoicer\Domain\Entity\Customer;
use
Illuminate\Http\Request;
use
Illuminate\Support\Facades\Session;
use
Symfony\Component\HttpFoundation\RedirectResponse;
Now, of course, we need to setup the template file
customers/new-or-edit
that’s referenced in
the action:
resources
/
views
/
customers
/
new
-
or
-
edit
.
blade
.
php
-->
@
extends
(
'layouts.layout'
)
@
section(
'content'
)
<
div class
=
"page-header clearfix"
>
<
h2
>
empty
(
$customer
->
getId
())
?
'Edit'
:
'New'
?>
Customer