Routing, Controller und Plugs

Welcome to routing in Phoenix! Think of routing as your application's traffic controller. When a user visits a URL, the router determines which part of your code should handle that request.

It's how Phoenix connects an incoming web address (like /users) to a specific function in your application.

In Phoenix, all your routes are defined in the lib/my_app_web/router.ex file. This file uses special macros to declare how different HTTP methods (GET, POST, PUT, DELETE) map to your application's logic.

You'll often see routes grouped into scopes and processed by pipelines, which apply common behaviors.

Let's look at how a basic route is defined. Here, a GET request to the root path / is mapped to the index function within PageController.

Notice the pipe_through :browser which applies a set of common behaviors to browser requests.

Once the router directs a request, a controller takes over. Controllers are Elixir modules that contain actions (functions) responsible for handling specific requests.

Their main job is to:

• Receive request parameters.
• Perform necessary business logic (e.g., fetch data).
• Prepare a response, often by rendering a template.

Controller actions are just functions that accept two arguments: conn (the connection struct) and params (request parameters).

Here's a simple PageController with an index action that renders an index.html template.

Instead of hardcoding URLs in your templates or code, Phoenix provides path helpers. These are functions that generate URLs based on your defined routes.

Using path helpers makes your links robust. If you change a route's path, you only update it in router.ex, and all generated links will automatically update.

For example, ~p"/" generates the root path.

Plugs are composable functions or modules that process the Plug.Conn (connection) struct. They act like middleware, allowing you to intercept and modify requests before they reach a controller, or modify responses after they leave.

Think of them as a series of steps a request goes through. Each plug can transform the request (or halt it) and pass it to the next plug in the pipeline.

Plugs are simple Elixir modules implementing the init/1 and call/2 functions. init/1 is for configuration, and call/2 does the actual work.

Here's a plug that logs the request path and adds a custom header to the response:

To use your custom plug, you add it to a pipeline in your router.ex file. All requests passing through that pipeline will then be processed by your plug.

For example, adding plug MyPhoenixAppWeb.Plugs.MyLogger to the :browser pipeline means every browser request will trigger this plug.

• Plug.Parsers: Parses request bodies (JSON, forms).
• Plug.Logger: Logs request details.
• Plug.Static: Serves static assets like CSS/JS.

In this lesson, you've learned the core components that handle web requests in Phoenix:

• Routes (in router.ex) map incoming URLs to controller actions.
• Controllers contain actions (functions) that execute business logic and prepare responses.
• Plugs are reusable components that process the request connection (Plug.Conn) in a pipeline, before or after the controller.

Together, these form a powerful and flexible system for building web applications.