Build Your Own PHP Framework

Sign in Get started

This episode is for members only

Sign up to access "Build Your Own PHP Framework" right now.

Already a member? Sign in to continue

Playing

14. Adding routing

Episodes

0%

Your progress

Total: 4h 45m
Played: 0m
Remaining: 4h 45m

Join or sign in to track your progress

01. Setting up

01. Introduction

02. Composer and PSR-4 Autoloading

03. Bootstrapping and structure

04. Error reporting with Ignition

02. Container

05. Using a container

06. Adding service providers

07. Autowiring with reflection

08. Refactoring to a singleton

03. Application config

09. Building the Config class

10. Reading and merging config files

11. Registering service providers through config

12. Using env files

04. Routing and controllers

13. Everything starts with requests

14. Adding routing

15. Responding in routes

16. Cleaning up responding

17. Defining routes in a separate file

18. Creating a controller

19. Using services inside controllers

05. Views

20. Installing Twig

21. Rendering a view

22. Debugging in Twig

23. Creating a base layout

24. Page titles in Twig

25. Creating a Twig config helper

06. Database

26. Setting up and querying the database

27. Working with models

28. Creating an example user profile page

07. Authentication

29. Setting up Sentinel

30. Creating the registration flow

31. Registering and authenticating a user

32. Showing authenticated state

34. Logging out

08. CSRF Protection

35. Protecting routes with CSRF

36. Adding tokens to forms

09. Flashing messages

37. Basic session flashing

38. Creating a Twig helper and flashing globally

10. Validation

39. Validating the login form

40. Manually adding validation errors

41. Validating the registration form

42. Custom validation rules

11. Middleware

43. How middleware works

44. Adding auth middleware and grouping routes

45. Persisting old form data

12. Exception handling

46. Creating an exception handler

47. Custom 404 (and other error) views

48. Rendering views for CSRF errors

13. Pagination

49. Paginating with Eloquent

50. Building a pagination view with Twig

14. Global helpers

51. Registering functions with PSR-4

52. Container resolution helper

53. View and config helpers

54. Route generator helper

Transcript

00:00

Now that we have our request, the next step is to start to create routes. Now we're going to do this really roughly inside of bootstrap and app,

00:07

and then I'm going to show you how we can split this up into files for much better organization. Okay, let's get rid of what we've are dumping out here, and let's go and create a new service provider that will hold our router. So once again, let's go and grab any of these service providers that we've already got,

00:24

and let's create out a route service provider, which will hold this for us. Okay, let's paste this in, we'll get rid of what we don't need in boot, and let's change this over to route service provider. Once again, not forgetting to register this over in our config,

00:42

so route service provider, and we're done. We now have a new service provider specifically for our routes. Once again, we want to figure out what package we want to pull in to handle routing for us. We're not going to be building our own router,

00:55

because that is a huge job and would be a course in itself. So we're going to use fast route, but we're not directly going to use this. Fast route is an incredibly popular router, it's used by frameworks like slim. We are instead going to use league route, which uses fast route behind the scenes,

01:14

but it adds some additional functionality, like the ability to register controllers, apply middleware to our routes, which is really important, and a bunch of other things as well. So keep in mind that we are using fast route behind the scenes,

01:29

but we're using this route package to make our lives a lot easier. Okay, let's head over to the current version here, and let's go over to the installation and get started with this. So again, of course, we're going to use composer to pull this in.

01:43

So let's pull this into our project, and let's just start to use this. So we might just need to allow any dependencies to be upgraded. So we'll use the W flag for that, and now it's installed. Okay, let's add our router to our container,

01:58

and then we'll look at registering some routes. So we're going to grab our container once again, add in a item to our container, and this is going to be router from league and route. So let's name that with the class for that.

02:12

And then in here, let's make sure we set this to shared, like we're going to do with the majority of our services, and let's create a new router. So new router, and we'll return that router from here.

02:26

And we're going to do a couple of other things here in between. Now, one thing that we need to do with our router is set a strategy. You can find all of this in the documentation for league router, but we just want the standard application strategy.

02:40

We have other strategies like JSON strategies, which will decorate your responses with JSON if you're building an API. But for us, we just want this to be the standard application strategy. So in here, we're going to use our router and we're going to set a strategy.

02:55

This comes with a couple of strategies and you can also build your own, but we are going to set this to a new application strategy from this package. And then from this, we're going to set our container. So this is aware of our container and we are already in a service provider.

03:12

So we can just either pass in get container or container directly into here. Okay, that is our router now set up. It's easy as that to just do a couple of things to get this working. Let's try now over in bootstrap an app to register a few routes.

03:28

And like I said, we'll do this in here and then move this over a little bit later. So let's do this within the point where we initialize our app and then run it. Run will respond to any of the routes that we have created. So I'm going to create out a temporary router variable here

03:45

so I can access from our container, the router. So from league route like this, and then this is where we just register any routes. So let's say router and we'll say get, and this will just be our homepage. So let's set this to a forward slash.

04:00

That's obviously the route that we want this to respond to. And let's create out a closure in here and var dump home. And then we'll just kill the page inside of there. So at this point, now that we've got our router on here,

04:16

what we should be able to do is head over to our application and see some sort of response from this. Now we're getting an error here and we might see this quite commonly. What's happening here is the router or the route collector

04:30

expects the route parser to be passed in, but we've given a resolvable argument. The reason for this, if we head over to our route service provider is that we didn't register this as a service. So basically our container is not returning the router to us.

04:45

So let's go ahead and add in our router directly into here. And that should now resolve the router out correctly and pass this in for us. Okay. So if we give this a refresh, we're seeing run app.

04:56

So nothing is actually happening at the moment, but we are responding to that route or we actually accessing that route. So over in our app, let's just get rid of run app because we need to do something in here to actually respond to this.

05:10

Let's give this a refresh. And of course we see nothing in here at the moment, but we now know that we are potentially responding to this route that we've just created. Let's take a look in the next episode at how we actually respond to this router request.

Episode summary

In this episode, we dive into adding routing to our application. We start by discussing what routing is and why it's important, and then we make some quick changes in our bootstrap/app just to get things working. But rather than leaving it messy, we move toward a more organized setup by creating a new RouteServiceProvider.

We set up the RouteServiceProvider and register it in our config, so all our routing logic stays nicely separated. Next up, instead of building a routing system from scratch (which would be a massive job), we pull in a popular package: league/route. This package sits on top of fast-route and gives us cool extras like controller registration and middleware support.

Once it’s installed with Composer, we add the router to our service container and configure it with the correct strategy, choosing the standard ApplicationStrategy for this project. After the setup, we walk through how to register a basic route and make sure everything is wired together.

We hit a small configuration hiccup, fix it, and test things out—at the end, we're able to see our new route is being recognized, even though we aren’t returning a visible response just yet. In the next video, we’ll focus on actually responding to incoming requests using the router. Stay tuned!

Episode discussion

No comments, yet. Be the first!