Clojure Functional Programming & JVM Backend Development · Pelajaran

Middleware Ring Secara Mendalam

Pelajari cara middleware Ring membungkus handler untuk menambahkan perilaku lintas fungsi seperti logging, penguraian parameter, dan penanganan sesi dalam aplikasi web Compojure.

Middleware Ring Secara Mendalam adalah pelajaran Clojure Functional Programming & JVM Backend Development gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Clojure Functional Programming & JVM Backend Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Clojure Functional Programming & JVM Backend Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Middleware Ring Secara Mendalam” gratis?

Ya — teks lengkap “Middleware Ring Secara Mendalam” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Clojure Functional Programming & JVM Backend Development, upgrade ke CoddyKit PRO. Kursus Clojure Functional Programming & JVM Backend Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Middleware Ring Secara Mendalam”?

Pelajari cara middleware Ring membungkus handler untuk menambahkan perilaku lintas fungsi seperti logging, penguraian parameter, dan penanganan sesi dalam aplikasi web Compojure. Kamu berlatih Clojure Functional Programming & JVM Backend Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Clojure Functional Programming & JVM Backend Development?

Tidak diperlukan pengalaman sebelumnya. Clojure Functional Programming & JVM Backend Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Middleware Ring Secara Mendalam” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Clojure Functional Programming & JVM Backend Development ini?

Ya. Setiap pelajaran Clojure Functional Programming & JVM Backend Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Clojure Functional Programming & JVM Backend Development