[MUSIC] Spring controllers, are just standard Java objects. There's nothing special about them. So, let me give you an example, let's write a simple spring controller and show, how we would connect it to the dispatcher servlet. So that dispatcher servlet could route requests to that controller, into the appropriate methods within the controller. So in order to create a spring controller, all we need to do is create a simple class. So in this case, let's create a class called, Contacts control and, what you will notice, is that well first of you will notice that we have to add class here. Since we want this to be a java class. This is just a basic java class. There is no special interfaces, or class that we are inheriting from. Now, let's say that we want to have a method that is going to handle requests from clients, in order to view a list of contacts. We could simply say, public, contacts, get contacts. And this is just like any other java method. We just need to do something, to retrieve the contacts. And then, let's say that contacts are stored in some variable C. And then we're going to return the contacts, so we'll return C. So, this is just a basic Java class, we've got a basic Java method. Or, we're going and doing some work. What's really nice is this is, this class is clean. It's, it's standard Java, it's not polluted by any frameworks. But we need a way to connect it, to the dispatcher servlet, so that the dispatcher servlet knows about it, knows which request to route to it, and knows which methods to route those requests to. The way that we do this in spring, is we add an @ RequestMapping annotation. And what this tells the spring framework, is that this is going to be a method, that we want to route request to. And we'll talk about what goes into this in a second. The other thing we have to do is at the top of this class, we have to add an @ controller annotation, so that Spring knows that this class, that we want it to serve as a controller. Now, what we do in this request mapping, is we then specify a path for when we want this thing in vogue. For example, we could say /contacts, that we want you to route any request to /contacts into this particular method. And then, what the dispatcher circuit will do, is whenever it sees a request with a /contacts path, it will automatically route that request into, this particular method. So if we then went and let's say we extended our class, and we have another method, we have public, let's say contacts, and then we just call this friends, for example. Maybe, we would want a list of contacts that we consider to be just our friends. The way that we would tell the dispatcher servlet about this thing is, again, we would just add another RequestMapping annotation, and we would map it to a separate path from the first one. So maybe this one goes to /friends. So these annotations, the request mapping annotations tell the dispatcher sort of what. When you route a request to the contacts control object, and which we are saying is a controller with this act controller annotation. If it goes to, if the request is for slash contacts, it should go in this method. If the request is for slash friends, it should be routed to this method. And these methods on these a, on this object will then handle the logic for processing those requests, and determining what happens with them
