Clojure Functional Programming & JVM Backend Development · Lesson

Handling Requests & Responses

Master how to parse incoming request data and construct appropriate HTTP responses, including JSON and HTML.

Handling Requests & Responses is a free Clojure Functional Programming & JVM Backend Development lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Clojure Functional Programming & JVM Backend Development learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Handling Requests & Responses

In web development, your application constantly handles incoming requests from clients and sends back appropriate responses. This lesson teaches you how to read data from a client's request and construct different types of responses, like HTML and JSON, using Clojure's Ring.

Understanding the Ring Request Map

When a request hits your Clojure application, Ring transforms it into a standard Clojure map, often called the request map. This map contains all details about the incoming request, such as:

:uri: The path of the request (e.g., "/users")
:request-method: The HTTP method (e.g., :get, :post)
:headers: A map of all HTTP headers
:query-params: A map of URL query parameters
:body: The request body, if any

Accessing Query & Form Parameters

Clients often send data via URL query parameters (e.g., /search?q=clojure) or HTML form parameters. Ring provides these parsed in the :query-params and :form-params keys of the request map, respectively. You can access them like any other map entry.

Code: Query Parameter Demo

Try running this example to see how to extract a query parameter. We'll simulate a request map for a handler function.

(ns coddykit.core
  (:require [ring.util.response :refer [response]]))

(defn greet-handler [request]
  (let [name (get-in request [:query-params "name"] "Guest")]
    (response (str "Hello, " name "!"))))

(defn -main []
  (let [mock-request {:query-params {"name" "Coddy"}}]
    (println "Simulating request with name 'Coddy':")
    (let [res (greet-handler mock-request)]
      (println "Status:" (:status res))
      (println "Body:" (:body res))))
  (let [mock-request-no-name {:query-params {}}]
    (println "\nSimulating request with no name:")
    (let [res (greet-handler mock-request-no-name)]
      (println "Status:" (:status res))
      (println "Body:" (:body res))))

Reading the Request Body

When clients send data in the request body (e.g., for POST or PUT requests), this data is available in the :body key of the request map. For common formats like JSON, you'll typically use a Ring middleware to parse the raw body into a Clojure map automatically. Without middleware, :body contains an InputStream.

Building Your Response Map

After processing a request, your handler function must return a response map. This map tells Ring how to construct the HTTP response sent back to the client. A minimal response map needs:

:status: The HTTP status code (e.g., 200 for OK, 404 for Not Found)
:headers: A map of HTTP headers (e.g., {"Content-Type" "text/html"})
:body: The actual content to send back (e.g., HTML string, JSON string)

Responding with HTML

To send an HTML page, your response map's :body should be an HTML string, and the "Content-Type" header must be set to "text/html". Ring's response helper function is a great starting point, and header helps add headers.

Code: HTML Response Demo

Here's how to create a simple handler that responds with an HTML page. Note the use of header to set the correct content type.

(ns coddykit.core
  (:require [ring.util.response :refer [response header]])) 

(defn html-page-handler [request]
  (-> (response "<h1>Welcome to CoddyKit!</h1><p>This is an HTML page.</p>")
      (header "Content-Type" "text/html")))

(defn -main []
  (let [mock-request {}]
    (println "Simulating request for HTML page:")
    (let [res (html-page-handler mock-request)]
      (println "Status:" (:status res))
      (println "Headers:" (:headers res))
      (println "Body:" (:body res)))))

Responding with JSON

For API endpoints, you'll often send data back as JSON. This requires setting the "Content-Type" header to "application/json" and ensuring your :body contains a valid JSON string. You'll typically use a library like clojure.data.json or cheshire to convert Clojure data structures into JSON strings.

Code: JSON Response Demo

This example shows how to send a JSON response. We use clojure.data.json to convert a Clojure map to a JSON string.

(ns coddykit.core
  (:require [ring.util.response :refer [response header]]
            [clojure.data.json :as json]))

(defn json-data-handler [request]
  (let [data {:status "success" :message "Data received!"}]
    (-> (response (json/write-str data))
        (header "Content-Type" "application/json"))))

(defn -main []
  (let [mock-request {}]
    (println "Simulating request for JSON data:")
    (let [res (json-data-handler mock-request)]
      (println "Status:" (:status res))
      (println "Headers:" (:headers res))
      (println "Body:" (:body res)))))

Quick Check: Response Structure

You're building an API and need to send a successful response with a JSON object {"message": "Item created"}. Which of the following correctly represents the Ring response map?

Recap: Requests & Responses

You've learned how to handle the core of web interactions in Clojure! We covered:

The structure of the Ring request map and how to access its data.
Extracting query and form parameters from requests.
Understanding how request bodies (like JSON) are handled.
Constructing Ring response maps with :status, :headers, and :body.
Sending back both HTML and JSON content by setting the appropriate Content-Type header.

These are fundamental skills for building any web application with Ring and Compojure!

Frequently asked questions

Is the “Handling Requests & Responses” lesson free?

Yes — the full text of “Handling Requests & Responses” is free to read here on the web, and the Clojure Functional Programming & JVM Backend Development course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Clojure Functional Programming & JVM Backend Development course, upgrade to CoddyKit PRO.

What will I learn in “Handling Requests & Responses”?

Master how to parse incoming request data and construct appropriate HTTP responses, including JSON and HTML. You practise Clojure Functional Programming & JVM Backend Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Clojure Functional Programming & JVM Backend Development?

No prior experience is required. Clojure Functional Programming & JVM Backend Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Handling Requests & Responses” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Clojure Functional Programming & JVM Backend Development lesson?

Yes. Every Clojure Functional Programming & JVM Backend Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Clojure Functional Programming & JVM Backend Development