Hi all! Again, this article is a purely basic cognitive overview for beginners. There will be nothing complicated here, so those who are hungry for complex articles, please do not throw too many tomatoes)
So, let’s say we want to write a web server with a rest-like API in java, but we don’t know any frameworks, standards, or libraries yet.
The first thing we can do is implement all the logic ourselves completely from scratch on sockets.
Socket is a concept from TCP protocol. This is a kind of socket that can receive / send data packets over the network on a specific port.
We will need to do something like this:
• establishment/termination of TCP connections with clients
• maintaining a pool of connections so that the server can process multiple requests in parallel
• parsing http headers, cookies, urls
• and many other low-level mechanisms involving the study of protocol documentation and complex concurrency
This code can take months to implement and maintain. But even after that, such a server will be significantly inferior to the existing ones in terms of performance and stability.
In addition, the server’s business logic is likely to be drowned in technical code, making maintenance even more difficult.
To solve the problems above, the Servlet API standard was invented.
The most important part of the API method service() interface javax.servlet.Servlet:
public void service(ServletRequest req, ServletResponse res)
We just need to get the necessary parameters / headers / etc from the parameter req and write response/status to res.
In our case, it is much easier to take an abstract implementation of this interface – HttpServlet
And bind this servlet to some path in XML:
Now, if you open http://my-api.com/hello in the browser, we will see the text “Hello from server”
And how does it work?
The “servlet container” does all the magic for us. This is exactly the thing that implements the servlet specification and provides us with Servlet API.
The most common:
And the scheme is something like this:
1. We package our code in a special war format and load it into a container
2. For each request to the server along the specified path, the server creates a new servlet with our code
3. Each request has its own thread
This approach already greatly simplifies the development of a web server, but there are still a couple of important things that the framework could do for us:
• serialization/deserialization of request and response body (eg json <–> pojo)
• more flexible mapping of urls to methods (routing)
• and a bunch of more specific ‘wants’ from security to transactionality
At the heart of the ecosystem, the spring is DI. This is such a thing that allows you to conveniently slip one object into another. The core turned out to be very convenient and a bunch of libraries and frameworks grew around it.
• spring web
• spring jdbc template
• spring security
• spring cloud
• spring data
How does the spring framework work?
1. We write code in the form of simple classes (called beans)
2. We write code that describes which beans need to be injected
3. Launch IoC spring container
4. IoC container reads our code and configuration
5. According to the instructions in the configuration, slips instances of one class into another
6. We get the necessary classes from it and run methods on them
So here spring web is a web framework built on top of Servlet APIto make our lives even easier.
This class is called controller. Its methods correspond to the URLs of our api. When the client requests http://my-api.ru/hello , the method will be executed getHello().
We described all this with the help of annotations. spring web read them and configure the servlet as needed.
It happens like this:
1. Spring parsed our controllers and set up a special class DispatcherServlet
2. Per request is triggered DispatcherServlet
3. It determines which method to call in which controller
4. In our controller method, the business logic is processed
5. The response is serialized (for example, in json)
Now we are happy with everything and can implement our API without thinking about anything other than business logic.
1. It almost never makes sense to implement the logic of a web framework on your own – it’s long and complicated
2. Most web frameworks run on top of the Servlet API
3. It’s always good to understand how your favorite web framework works from the inside out. This helps you get the most out of it and get the most out of it.