What is Middleware?

You may have heard people use the term "middleware" in a variety of contexts and wondered what they are talking about. Explore the vast and rich set of technologies and processes they cover!

Middleware has many meanings

Middleware is a flexible term that people use to refer to different things. In the broadest possible sense, you can think of it as "programs that run among other programs". In other words, any software depends on separate code to provide input and process output.

Some middleware exists as a comprehensive application that transforms data from one state to another, with clearly defined protocols and data formats for other code to use. But middleware can also be as granular as a single function, hooked into a series of other functions that the framework runs.

Like much software, middleware takes advantage of the concept of modularity: Breaking down a complex process into smaller, more manageable parts.

How does Middleware work?

Middleware is often as powerful as its publicly defined protocols and behaviors. Strict communication protocols allow programmers to write standards-compliant software to function correctly.

The web application server acts as middleware to connect the website's user interface experience with the data model and logic that the back-end application and database provide. Since it is not tightly coupled to the systems that communicate with it, you could, in theory at least, swap out the application server for a compatible one without having to rewrite the application code or Restructure your database.

Middleware components often use technologies such as JSON, REST, XML, and SOAP. It's all mature, popular, and text-based, making exchanging or rearranging components much easier. The text-based format and various toolkits also allow for easier and more reliable debugging.

Different types of Middleware

Because the term is so broad, there are many different examples and uses for middleware. Some of the most popular include:

1. Message broker, which adds structure to communication between processes.
2. Web application server and web framework.
3. Game engines provide default behavior that you can use, extend, or replace.
4. Event streaming platforms like Apache Kafka.

Using Middleware in software development

One of the most visible uses of middleware is through web frameworks. Most frameworks provide a core environment that you can customize and extend according to your own requirements. This model typically involves passing HTTP requests through a series of built-in and custom functions, in a specified order, and returning an HTTP response at the end.

The Express.js framework uses this model to support customization. Take this example of a middleware function written in JavaScript:

app.use('/user/:id', (req, res, next) => { console.log('Request Type:', req.method) next() })

This function is extremely simple:

1. It handles specific URLs starting with "/user/", followed by an id.
2. It records the type of request method which can be GET, POST, etc.
3. It calls a provided function, next, to continue processing the chain of middleware functions.

That last next call is an important step in the middleware process and shows how flexible this approach can be. As long as each middleware function operates independently, you can swap them in and out, as well as rearrange the behavior of the entire chain easily.

The PHP framework, Laravel, has an almost identical middleware setup. Notice how the namespace explicitly defines this class as "middleware".

namespace AppHttpMiddleware; use Closure; use IlluminateHttpRequest; use SymfonyComponentHttpFoundationResponse; class EnsureTokenIsValid { /** * Handle an incoming request. */ public function handle(Request $request, Closure $next): Response { if ($request->input('token') !== 'my-secret-token') { return redirect('home'); } return $next($request); } }

Again, the role of this class is very specific: All it does is check the request to see if it contains a token. In this case, the middleware function can break the chain, refuse to call the next function and instead send a redirect. The redirect function will return an appropriate Response object that the middleware function will return as part of its signature contract.

This last example shows how Django, a web framework based on Python, handles middleware. Django uses the term "plugin" to describe its middleware architecture, similar to other related terms you may hear like "hook" or "callback". In essence, this is simply another case of setting up middleware that provides flexibility throughout a structured process.

def simple_middleware(get_response): # One-time configuration and initialization. def middleware(request): # Code to be executed for each request before # the view (and later middleware) are called. response = get_response(request) # Code to be executed for each request/response after # the view is called. return response return middleware

You can then control which middleware runs and in what order with a simple array:

MIDDLEWARE = ​​[ "django.middleware.security.SecurityMiddleware", "django.contrib.sessions.middleware.SessionMiddleware", "django.middleware.common.CommonMiddleware", "django.middleware.csrf.CsrfViewMiddleware", "django.contrib. auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware", "django.middleware.clickjacking.XFrameOptionsMiddleware", ]

Django provides default behavior like the CommonMiddleware class that most applications will benefit from; it prohibits access to certain "bad" user agents and handles URL canonicalization. It's quite common for security-focused, task-critical middleware to run early in the process, but this flexibility allows you to customize the order depending on your application's needs.

Why is Middleware useful?

Middleware makes it easier to connect applications that are not designed for connection. It provides functionality to integrate them, along with powerful, structured protocols so they can communicate.

Therefore, middleware has a number of important benefits, including:

1. Streamline application development and reduce time to market.
2. Connect effectively.
3. Faster transition of changes.
4. Work tools are easily accessible.

Ultimately, middleware is a form of modularity, a concept that is beneficial when applied to all forms of programming, from the highest level to the lowest level.

Micah Soto

Update 23 January 2024