Routing mit Compojure

When you type a URL into your browser, how does a web application know which part of its code to run?

This is where routing comes in! Routing is the process of mapping incoming web requests (like visiting a URL) to specific functions or pieces of code that handle them.

• It directs traffic.
• It organizes your application.
• It makes URLs meaningful.

Compojure is a popular routing library for Clojure web applications. It builds on top of Ring, Clojure's web application specification.

Compojure provides simple macros to define routes, making it easy to connect URLs to your handler functions. It helps keep your web application's structure clean and understandable.

Compojure uses macros like GET, POST, PUT, and DELETE to define routes for different HTTP methods. The simplest is GET for fetching data.

Here's how you define a route that responds to requests at the root path /:

To make our routes active, we need a web server. We'll use http-kit, a simple and fast server. We wrap our app-routes in a function and start the server.

Try running this complete example. Then open your browser to http://localhost:3000!

Often, you need to extract dynamic parts from a URL, like an item ID or a username. Compojure lets you do this using path parameters, denoted by a colon (:) followed by the parameter name.

These parameters are then available within your handler function as arguments.

Web applications don't just fetch data (GET). They also create (POST), update (PUT), and delete (DELETE) resources. Compojure provides specific macros for each.

You can define different behaviors for the same URL path based on the HTTP method used.

As your application grows, you'll have many routes. Compojure's routes macro lets you group them logically. This makes your routing definition more organized and readable.

You can then combine these grouped routes into your main application handler.

For even better organization, especially with API versions or sub-sections, you can nest routes. Compojure allows you to define a common path prefix for a group of routes using context.

This creates a clear hierarchy for your application's endpoints, like /api/v1/users or /admin/dashboard.

Compojure processes routes in the order they are defined. The first route that matches an incoming request's path and HTTP method will be used.

• Define more specific routes BEFORE general ones.
• For example, /users/new should come before /users/:id.

Otherwise, /users/new might be incorrectly matched by /users/:id, with 'new' being treated as an ID.

Consider the following Compojure route definitions:

(defroutes my-app
  (GET "/products/latest" [] "Latest Products")
  (GET "/products/:id" [id] (str "Product ID: " id))
  (GET "/" [] "Homepage"))

Which of the following statements are TRUE about these routes?

In this lesson, you've learned the essentials of web routing and how Compojure simplifies it for Clojure applications:

• Routing maps URLs to handler functions.
• Compojure provides macros (GET, POST, etc.) to define routes.
• You can capture path parameters like :id.
• Routes can be grouped with routes and nested with context.
• Order matters: specific routes must come before general ones.

You're now ready to define clear, organized routes for your Clojure web services!