Routing and Controllers in Phoenix Elixir

What You’ll Learn 📚

By the end of this tutorial, you’ll understand:

• The basics of routing in Phoenix Elixir
• How controllers work and their role in a Phoenix application
• Common patterns and best practices
• Troubleshooting tips for common issues

Introduction to Routing and Controllers

In Phoenix, routing is the process of directing incoming web requests to the appropriate part of your application. Think of it as a traffic director for your app! 🚦

Controllers are like the conductors of your application. They handle requests, perform actions, and send responses back to the client. Imagine them as the bridge between your app’s logic and the outside world.

Key Terminology

• Route: A mapping between a URL and a controller action.
• Controller: A module that handles requests and returns responses.
• Action: A function within a controller that processes a request.

Getting Started: The Simplest Example

Let’s start with a simple example to see routing and controllers in action. First, ensure you have Phoenix installed. If not, you can set it up with:

mix archive.install hex phx_new

Now, create a new Phoenix project:

mix phx.new hello_world

Navigate into your project directory:

cd hello_world

Start the Phoenix server:

mix phx.server

Open lib/hello_world_web/router.ex and add a simple route:

scope "/", HelloWorldWeb do
  pipe_through :browser

  get "/hello", PageController, :hello
end

Next, create the PageController:

defmodule HelloWorldWeb.PageController do
  use HelloWorldWeb, :controller

  def hello(conn, _params) do
    text(conn, "Hello, World!")
  end
end

Progressively Complex Examples

Example 1: Adding Parameters

Let’s modify our route to accept a name parameter:

get "/hello/:name", PageController, :hello

Update the controller to greet the user by name:

def hello(conn, %{"name" => name}) do
  text(conn, "Hello, #{name}!")
end

Example 2: JSON Responses

Let’s return a JSON response:

def hello(conn, %{"name" => name}) do
  json(conn, %{message: "Hello, #{name}!"})
end

Example 3: Handling Errors

Let’s handle a case where the name is missing:

def hello(conn, params) do
  case Map.fetch(params, "name") do
    {:ok, name} -> json(conn, %{message: "Hello, #{name}!"})
    :error -> json(conn, %{error: "Name not provided"})
  end
end

Common Questions and Answers

1. What is the purpose of a controller in Phoenix?

   Controllers handle incoming requests, execute business logic, and return responses. They act as intermediaries between the router and the views/templates.

2. How do I define a route in Phoenix?

   Routes are defined in the router.ex file using the get, post, put, and delete macros, mapping URLs to controller actions.

3. Can I have multiple routes pointing to the same controller action?

   Yes, you can define multiple routes that direct to the same action. This is useful for handling different URL patterns with the same logic.

4. How do I pass parameters to a controller action?

   Parameters can be passed via the URL and accessed in the controller through the params map.

5. What is the conn parameter?

   The conn parameter represents the connection and holds request and response data. It’s passed to every controller action.

6. How do I return JSON from a controller?

   Use the json function to send JSON responses from a controller action.

7. How can I handle errors in a controller?

   Use pattern matching or case statements to handle different scenarios and return appropriate responses.

8. What is the pipe_through macro?

   The pipe_through macro specifies a pipeline of plugs (middleware) that requests should pass through, such as authentication or logging.

9. How do I test my routes and controllers?

   Use Phoenix’s built-in testing framework to write tests for your routes and controllers, ensuring they behave as expected.

10. Can I use Phoenix with other databases besides PostgreSQL?

    Yes, Phoenix supports various databases, including MySQL and SQLite, through Ecto adapters.

11. What is the difference between get and post routes?

    get routes are used for retrieving data, while post routes are used for creating or updating data.

12. How do I redirect from one action to another?

    Use the redirect function to send a client-side redirect to another action or URL.

13. Can I use Phoenix for real-time features?

    Yes, Phoenix has built-in support for real-time features using channels and WebSockets.

14. How do I secure my routes?

    Use authentication and authorization plugs in your pipelines to secure routes and restrict access.

15. What is a plug in Phoenix?

    A plug is a function that processes a connection. It’s used for tasks like authentication, logging, and more.

16. How do I handle file uploads in Phoenix?

    Use the Plug.Upload module to handle file uploads in your controllers.

17. Can I use Phoenix with a front-end framework?

    Yes, Phoenix can be integrated with front-end frameworks like React, Vue, or Angular for building modern web applications.

18. How do I deploy a Phoenix application?

    Deploying a Phoenix app involves building a release and deploying it to a server. You can use tools like Distillery or Mix releases.

19. What are some common errors in routing and controllers?

    Common errors include undefined routes, incorrect parameter handling, and missing controller actions. Always check your logs for detailed error messages.

20. How do I structure a large Phoenix application?

    Organize your application into contexts, which group related functionality together, making your codebase more maintainable.

Troubleshooting Common Issues

If you encounter a “Route not found” error, double-check your route definitions and ensure your server is running.

Remember to restart your server after making changes to the router or controllers to see the updates in action.

For more detailed error messages, check the server logs in your terminal.

Practice Exercises

• Create a new route that takes a user’s age and returns a message indicating if they are a minor or an adult.
• Modify the JSON response to include a timestamp of when the request was processed.
• Implement error handling for a missing age parameter in your new route.

Keep experimenting and building! Remember, every mistake is a step closer to mastering Phoenix Elixir. You’ve got this! 🚀

For more information, check out the official Phoenix routing documentation.