Build Your Own PHP Framework
This episode is for members only

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

Get started
Already a member? Sign in to continue
Playing
13. Everything starts with requests

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
2m 23s
0%
02. Composer and PSR-4 Autoloading
6m 17s
0%
03. Bootstrapping and structure
3m 18s
0%
04. Error reporting with Ignition
3m 49s
0%
02. Container
05. Using a container
3m 21s
0%
06. Adding service providers
5m 23s
0%
07. Autowiring with reflection
5m 5s
0%
08. Refactoring to a singleton
4m 17s
0%
03. Application config
09. Building the Config class
6m 19s
0%
10. Reading and merging config files
6m 21s
0%
11. Registering service providers through config
2m 13s
0%
12. Using env files
6m 26s
0%
04. Routing and controllers
13. Everything starts with requests
6m 52s
0%
14. Adding routing
5m 27s
0%
15. Responding in routes
4m 13s
0%
16. Cleaning up responding
7m 12s
0%
17. Defining routes in a separate file
3m 10s
0%
18. Creating a controller
5m 17s
0%
19. Using services inside controllers
2m 3s
0%
05. Views
20. Installing Twig
6m 22s
0%
21. Rendering a view
3m 36s
0%
22. Debugging in Twig
4m 45s
0%
23. Creating a base layout
3m 38s
0%
24. Page titles in Twig
4m 31s
0%
25. Creating a Twig config helper
8m 57s
0%
06. Database
26. Setting up and querying the database
13m 29s
0%
27. Working with models
4m 32s
0%
28. Creating an example user profile page
5m 49s
0%
07. Authentication
29. Setting up Sentinel
8m 36s
0%
30. Creating the registration flow
5m 44s
0%
31. Registering and authenticating a user
5m
0%
32. Showing authenticated state
5m 40s
0%
33. Logging in
3m 59s
0%
34. Logging out
3m 2s
0%
08. CSRF Protection
35. Protecting routes with CSRF
7m 51s
0%
36. Adding tokens to forms
6m 5s
0%
09. Flashing messages
37. Basic session flashing
5m 46s
0%
38. Creating a Twig helper and flashing globally
1m 39s
0%
10. Validation
39. Validating the login form
6m 40s
0%
40. Manually adding validation errors
1m 24s
0%
41. Validating the registration form
4m 5s
0%
42. Custom validation rules
9m 39s
0%
11. Middleware
43. How middleware works
5m 41s
0%
44. Adding auth middleware and grouping routes
7m 37s
0%
45. Persisting old form data
6m 53s
0%
12. Exception handling
46. Creating an exception handler
3m 38s
0%
47. Custom 404 (and other error) views
7m 27s
0%
48. Rendering views for CSRF errors
5m 18s
0%
13. Pagination
49. Paginating with Eloquent
7m 48s
0%
50. Building a pagination view with Twig
7m 38s
0%
14. Global helpers
51. Registering functions with PSR-4
1m 50s
0%
52. Container resolution helper
2m 24s
0%
53. View and config helpers
4m 12s
0%
54. Route generator helper
4m 34s
0%

Transcript

00:00
Everything in our app starts out with a request, which we will then use to resolve which route we want to display. We'll either use a controller or a closure for our routes, which
00:13
we'll get to a little bit later. And then when we run our app, we will put forward a response back to the browser. So we'll render out a response, whether that's just text or HTML. We'll get to responses a little bit later, but the first thing we want
00:27
to focus on is our request, and then we will see how this fits into the rest of the life cycle of our app. Okay. So to achieve this, we're going to go ahead and use a package, which will
00:38
allow us to have a PSR HTTP implementation of a request, which we'll again, come to a little bit later. This just means that it's a standard. This is going to work with our router really nicely.
00:52
And then we'll have the same thing for our responses as well. We want everything to work nicely together. Let's go ahead and just pull this package in and then let's see what it looks like. So let's go down to the section just here.
01:03
You can see the PHP package containing implementations of PSR 7 HTTP messaging interfaces and message factory interfaces. The factory part is what we want. Okay.
01:15
So we're going to go ahead and pull this in. So let's go over to the documentation and let's grab the composer command to go ahead and install this and we'll see what this looks like, and I'll show you a couple of examples as well.
01:26
Okay. So now that we've got this in here, we can either create this manually directly within our app, or we could register this within a service provider. I'm going to go ahead and register this in a service provider, because
01:37
we might need to manually access this somewhere else in our app a little bit later on, so again, let's grab one of our service providers and we'll create out a new service provider in here. So let's create out a request service provider and let's paste this in.
01:56
Let's go ahead and get rid of the content in boot because we're not going to need that. And of course, let's change the name over here to request service provider. Now we set up our config earlier.
02:07
So it's incredibly easy to just go ahead and go over to config and app and pull this service provider directly into here. So we'll pull in our request service provider and that's already registered for us. Okay.
02:22
So over in our request service provider, we want to bind this to the container. So let's say get container. Let's add in to the container using this request object, which comes from this package just here.
02:36
So let's go ahead and register that as the name, create out the closure in here, and we'll do this in just a second. We're not going to forget to go over to provides and pull in request class. So our container knows what we're resolving.
02:50
Okay. So this is really easy. We're going to use a factory to create a request instance. So we're going to pull in the server request factory again, from that package.
03:01
And we're going to create this from globals. There are a bunch of ways that we can create a request, but we're going to do this from PHP globals. So into here, we want to pass in the server globals from PHP, the
03:13
get and the post globals from PHP. We also might need a little bit later cookies. So let's pull in our cookie, super global array, and also our files, super global array, if we ever need them.
03:29
So now when we resolve this out, it's going to go ahead and create a request for us. Now, something else we didn't look at a little bit earlier was using shared. So setting this as shared means that every time we access this, we're going to get the same instance every single time.
03:45
We can even do that to our config service provider as well. So where we registered this, we can set this as shared. It just means that if we access this more than once, it's not going to keep resolving this and it's kind of acting like a singleton.
03:59
Okay. So we've got our request class inside of here. Let's go ahead and grab this out of our container and just see what this looks like. So up here again, let's kill the page and let's go ahead and access
04:09
this directly from our container. So we'll say get request from this package and let's just var dump on this and see what this gives us. Okay.
04:19
Let's go to the browser and we'll give that a refresh. And there we go. So we've now got a server request. Now, just a little bit of background.
04:27
If we open up our server request class or the server request class from this package, you can see that this implements, if we come down here, this server request interface. And this server request interface is from the PSR package. So it implements this interface.
04:45
And what this means is that when we use something like our router, which we're going to pull in later, this already expects this to be this PSR 7 request. So it will have all of the methods inside of here. If we just take a look and these are all named the same, this is just a standard.
05:02
It means that we can use any package that implements this kind of request and it always will contain exactly the same methods. So for example, we're going to be using get parsed body quite a lot, which will give us all of the data from the body.
05:17
When we post a form, we've also got something like get query params, which will give us all of the pretty obviously query parameters that we have in our application. So if we close this off, what we can do with this is grab out them query params.
05:34
So let's say get query params, and let's see what this gives us. Give that a refresh. And of course, at the moment, we've just got an empty array now, because over in our request service provider, we passed in all the details about our server and
05:52
the current request, what we can do is just add on to the end of here, some sort of example, for example, we're going to be implementing pagination later. So we'll need to know within the query string, what page we're currently on. Let's go ahead and hit enter on here.
06:06
And as you can see that request knows about the request that we've just put forward through PHP, and it contains the page that we're currently on. The same thing is going to happen when we eventually submit a form and we're not using a query string.
06:19
Instead, we're going to be sending a post request through to our server. The get parsed body method will contain all of the data about what's being sent through in that form. So don't worry if this doesn't make too much sense at the moment.
06:35
Once we get into our routing and our controllers, we'll see that we'll get this request through to each of our controllers automatically. And from that within our controllers, we can read out any data we need that's been posted through that's in the query string or any files that have been uploaded.

Episode summary

In this episode, we're diving into the very beginning of how our app handles incoming web requests. Everything your app does starts with a request coming in, and we need a way to represent that request in our code. We'll talk about how our app uses either controllers or closures to handle routes—though that's something we'll see in more detail later on.

To work with requests in a standardized way, we're pulling in a PHP package that follows the PSR-7 standard for HTTP messages. This package helps us create request objects from PHP's global variables (like $_SERVER, $_GET, $_POST, etc.), which makes things super consistent and easier to manage.

We go through installing the package, setting up a custom Request Service Provider so we can easily get a request object from our container anywhere in the app, and making sure it's shared (kind of like a singleton—there's only ever one instance per request).

After we've got the request in our hands, we do a little bit of experimentation—like outputting it to see what it looks like and accessing query parameters from the URL. You'll see that this makes extracting data from the request (whether it's query params, POST data, or even file uploads) really straightforward. Later on, as we build out routing and controllers, this request handling will plug right in, making it effortless to access any data sent to our app.

Episode discussion

No comments, yet. Be the first!