Clojure Functional Programming & JVM Backend Development · Lektion

Ring-Middleware im Detail

Lernen Sie, wie Ring-Middleware Handler umschließt und so übergreifendes Verhalten wie Logging, Parameterparsing und Sitzungsverwaltung in Compojure-Web-Apps ergänzt.

Ring-Middleware im Detail ist eine kostenlose Clojure Functional Programming & JVM Backend Development-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Clojure Functional Programming & JVM Backend Development-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Clojure Functional Programming & JVM Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What Is Middleware?

In Ring, a handler is a function that takes a request map and returns a response map. Middleware is a higher-order function that takes a handler and returns a new handler.

This lets you wrap behavior around your core logic without modifying it.

(defn wrap-example [handler]
  (fn [request]
    (handler request)))

The Wrapping Pattern

Every middleware follows the same shape: receive a handler, return a function that takes a request. You can act before or after calling the inner handler.

Before: inspect or modify the request
After: inspect or modify the response

(defn wrap-logging [handler]
  (fn [request]
    (println "Incoming:" (:uri request))
    (let [response (handler request)]
      (println "Status:" (:status response))
      response)))

Applying Middleware

You apply middleware by calling it on your handler. The result is a new handler that you pass to the server.

(def app
  (-> handler
      wrap-logging))

The Threading Macro

The -> threading macro is the idiomatic way to stack middleware. Each layer wraps the one before it.

Order matters: the last middleware listed is the outermost layer that sees the request first.

(def app
  (-> routes
      wrap-params
      wrap-session
      wrap-logging))

Built-in Middleware

The ring-defaults library bundles common middleware so you do not write it by hand.

wrap-params parses query and form params
wrap-session manages sessions
wrap-keyword-params turns string keys into keywords

(require '[ring.middleware.defaults :refer [wrap-defaults site-defaults]])

(def app
  (wrap-defaults routes site-defaults))

Modifying the Request

To add data for downstream handlers, assoc a key onto the request before calling the inner handler.

(defn wrap-user [handler]
  (fn [request]
    (let [user (lookup-user (:session request))]
      (handler (assoc request :current-user user)))))

Modifying the Response

To set headers or transform output, work on the response after calling the inner handler.

(defn wrap-content-type [handler]
  (fn [request]
    (let [response (handler request)]
      (assoc-in response [:headers "Content-Type"] "text/html"))))

Conditional Middleware

Sometimes you only want middleware on certain routes. You can apply it selectively rather than globally.

(defroutes app
  (GET "/public" [] public-handler)
  (-> (GET "/admin" [] admin-handler)
      wrap-authentication))

Exception Handling Middleware

A common pattern is wrapping all handlers in a try/catch to return a clean 500 response instead of leaking stack traces.

(defn wrap-errors [handler]
  (fn [request]
    (try
      (handler request)
      (catch Exception e
        {:status 500 :body "Internal Server Error"}))))

Order of Execution

Think of middleware as an onion. The request travels inward through each layer to the handler, then the response travels outward back through them.

Outermost middleware runs first on request, last on response
Innermost runs last on request, first on response

; request:  wrap-logging -> wrap-session -> wrap-params -> handler
; response: handler -> wrap-params -> wrap-session -> wrap-logging

Composing Reusable Middleware

Because middleware are just functions, you can group them into a single composed function and reuse it across multiple apps.

(defn wrap-common [handler]
  (-> handler
      wrap-logging
      wrap-errors
      wrap-params))

Quick Check

Test your understanding of middleware ordering.

Recap

You learned that middleware are higher-order functions wrapping handlers to add cross-cutting behavior.

They can modify the request before, or the response after
The -> macro stacks them like an onion
Libraries like ring-defaults bundle common ones

Next you can combine custom middleware with Compojure routes for full-featured apps.

Häufig gestellte Fragen

Ist die Lektion „Ring-Middleware im Detail“ kostenlos?

Ja — der vollständige Text von „Ring-Middleware im Detail“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Clojure Functional Programming & JVM Backend Development-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Clojure Functional Programming & JVM Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Ring-Middleware im Detail“?

Lernen Sie, wie Ring-Middleware Handler umschließt und so übergreifendes Verhalten wie Logging, Parameterparsing und Sitzungsverwaltung in Compojure-Web-Apps ergänzt. Du übst Clojure Functional Programming & JVM Backend Development mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Clojure Functional Programming & JVM Backend Development zu starten?

Keine Vorkenntnisse erforderlich. Clojure Functional Programming & JVM Backend Development auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Ring-Middleware im Detail“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Clojure Functional Programming & JVM Backend Development-Lektion Code schreiben und ausführen?

Ja. Jede Clojure Functional Programming & JVM Backend Development-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Clojure Functional Programming & JVM Backend Development