Composer and PSR-4 Autoloading: Build Your Own PHP Framework

Build Your Own PHP Framework

Sign in Get started

Playing

02. Composer and PSR-4 Autoloading

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

We are truly starting from scratch here. So we are going to go ahead and make out a folder.

00:04

We're going to open up, up in our editor, and we're going to talk about composer and PSR for auto loading. Okay. Let's start with the folder.

00:12

I'm going to go ahead and make out a directory called no framework, and I'm going to CD into this, and I'm going to open this up with my editor once that's open, of course, we've got a completely empty project here. There is absolutely nothing in here.

00:27

So we need to start to think about the app structure. So to start with, why don't we go ahead and create out a new directory in here that's going to house all of our core framework stuff. So I'm just going to call that app.

00:39

That's just going to be our directory here, where we store all of our service providers, our middleware, all that good stuff that's going to work now to be able to access this, of course, we're going to need some sort of public directory that we can point to.

00:53

So I'm going to create out a directory in here called public. And inside of here, we can just create out a standard PHP file called index dot PHP that our web server will go ahead and hit. So if we just test this out by echoing out framework, we should be able to head

01:09

over to the browser, regardless of how you are set up on your local machine. And we should see this. So I'm using Laravel herd to host this. So I get a nice no framework dot test domain, but however you are, you are

01:23

getting this to work, it doesn't really matter. You should be able to open this up in your browser. And see that index dot PHP directory. Once you have everything configured.

01:31

Okay. So now that we've got this, we need to think about PSR for auto-loading inside of this file and inside of the bootstrap files that we're going to create. We need to access any of the classes inside of the app directory.

01:45

So let's go ahead and just start to create out a core directory in here. That's going to house our app file. So let's create out a PHP class in here called app and go ahead and create that out. So we've got just a standard class in here, which we should be able to new

02:01

up from inside of here and get working. Now at the moment, that's not going to work. Let's show this as an example. So I'm going to go ahead and say new app.

02:10

And why don't we just go ahead and VAR dump app out inside of here. And if we hop over to the browser and give that a refresh yet, sure enough, we don't have our app class available. So that's where composer comes in.

02:23

We want to auto-load everything inside of this app directory. So wherever we're trying to access it, it can always be found. So to do this, we're going to go and create out a file in the root of our projects called composer.json.

02:37

And once we've done this, we're going to go ahead and make sure we have composer installed, which is our dependency manager for PHP. We're going to need this to put in any of the dependencies that our framework is going to use.

02:48

So this is absolutely crucial. So once you do have composer installed, you should just be able to run composer on the command line. And we see an error here because the contents of our composer.json file

02:58

is invalid at the moment, but at least we know that it is installed. So to make this valid, we need a JSON object in here, and we're going to start to auto-load in everything from that app directory so we can access it once we require composer in.

03:13

So let's go ahead and start to do this. To do this, we use an auto-load object and PSR 4. And inside of here, we want to give the root name for everything that contains app. Now this can be anything you want.

03:26

So it doesn't have to be app. It can be the name of your company. For example, we could have code course or whatever you're building. It makes sense just to include this as app.

03:36

That's a pretty standard thing. So from this, where do we want to load from? Well, we want to load from the app directory. Now, just by doing this, once we dump our composer auto-load file and require it

03:49

into index, we'll have access to any of the classes inside of app. So let's go ahead and do that now. So if you notice, we can run composer and that should work now. We're going to run composer dump auto-load and optionally we can provide

04:04

in the optimize flag as well. It doesn't really matter. Okay. So now that we've run this, you'll notice a couple of things.

04:10

We've got this vendor folder created out in here, and that contains a composer directory with all of our class map namespaces. We don't really need to worry about that, but this auto-load.php file just needs to be included anywhere that we bootstrap our application up.

04:25

We just need to do this once and then we will have access to any of these classes. So let's go ahead and require this in. So from here, we're going to require and go back into vendor. We're going to require in auto-load.php, and that is all we need to do.

04:41

So now we need to think about the namespace of this app that we have created this app class that we've created, because when we are working with our app default namespace or our root namespace, just here, this needs to be under that default namespace and then any sub directories that we have under here.

05:01

So we're going to define the namespace out in here as app core, and we should be done. We don't need two slashes just there. So this app class lives under app, which is where we registered this over in compose.json and core is this directory just here.

05:17

Okay. Now that we've done that, let's go over to the browser and let's take a look at what happens. Okay.

05:23

Yeah. So the reason that this isn't working is because over in here, we are not referencing the namespace for this. If you're very new to PHP, we can do this in a couple of ways.

05:32

You can do this inline, or you can do this with a use statement at the top. The first way that this looks like is app core and app. So we can use that up there. So it knows where this lives.

05:44

If we head over, give that a refresh. There we go. We've now got access to this instantiated class, or you can do this inline directly. When you instantiate something, which we're not going to do throughout the

05:56

course, I always just prefer to import it. And if your editor allows this, you can just go ahead and import this at the top, whenever you reference a class. And we'll be doing that throughout the course as well.

06:07

Okay. So there is our basic app structure. Now, anything that we need to create goes inside of app, and then we can have a bunch of other folders in here that use this out as well.

Episode summary

In this episode, we start completely from scratch by setting up a new project folder and getting things ready for our own mini-framework. We create some basic directories, like app for our core code and public for the entry point to the application, with a simple index.php file to make sure everything's wired up in the browser.

The main focus this time is to introduce Composer and how PSR-4 autoloading works. Composer is PHP's dependency manager, but it's also essential for automagically loading classes you define in your application. We walk through creating a composer.json file, configuring it for PSR-4 so that everything inside the app directory can be autoloaded just by requiring Composer's generated autoload.php.

Then we create our first PHP class inside app/core/App.php, and deal with namespacing so Composer knows how to find the class. We learn how to use namespaces with either an inline approach or by importing at the top of the file, and settle on using the more maintainable use statement style for consistency going forward.

By the end, we've set up a very minimal but robust structure where we can add code to our app directory, and it will always be easily available to us thanks to Composer and PSR-4 autoloading. This sets the stage for building the rest of our application in a clean and manageable way.

Episode discussion

No comments, yet. Be the first!