Elixir og Phoenix: Skalerbar backend-udvikling · Lektion

Implementering af API-endpoints og serialisering

Byg API-endpoints, håndtér request- og response-bodyer, og serialisér data effektivt til klienter.

Lektion 2 af 411 trin

Implementering af API-endpoints og serialisering er en gratis Elixir og Phoenix: Skalerbar backend-udvikling-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Elixir og Phoenix: Skalerbar backend-udvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

API-endepunkter: Det grundlæggende

Velkommen! I denne lektion bygger vi API-endepunkter i Phoenix. Et API-endepunkt er en bestemt URL, som en API-klient kan tilgå for at udføre en handling eller hente data.

Tænk på det som en digital adresse til en bestemt ressource, f.eks. /api/products eller /api/users/123. Hvert endepunkt svarer normalt til en handling (f.eks. hent alle produkter eller opret en ny bruger).

Oprettelse af et API til en ressource

Phoenix har en praktisk generator, som hurtigt kan sætte en RESTful API-ressource op. Vi bruger mix phx.gen.json til at oprette en Product-ressource.

Denne kommando genererer:

En router-post
En controller (f.eks. ProductController)
Et Ecto-skema (f.eks. Product)
En visning (f.eks. ProductView) til JSON-serialisering

mix phx.gen.json Products Product products name:string description:text price:decimal

API-controlleren: Liste og visning

Efter genereringen kan vi se på en grundlæggende API-controller. Handlingen index håndterer GET /products for at vise alle produkter på en liste. Handlingen show håndterer GET /products/:id for at vise ét produkt.

Phoenix-controllere bruger conn (forbindelsen) til at håndtere forespørgsler og svar. Vi henter data og bruger derefter render til at gengive dem som JSON.

defmodule MyAppWeb.ProductController do
  use MyAppWeb, :controller
  alias MyApp.Products
  alias MyApp.Products.Product

  action_fallback MyAppWeb.FallbackController

  def index(conn, _params) do
    products = Products.list_products()
    render(conn, :index, products: products)
  end

  def show(conn, %{"id" => id}) do
    product = Products.get_product!(id)
    render(conn, :show, product: product)
  end
end

Håndtering af forespørgselsbrødtekster: Oprettelse

Når en klient sender data for at oprette en ny ressource (f.eks. POST /products), ligger dataene i forespørgslens brødtekst. Phoenix gør disse data tilgængelige i conn.body_params.

Vi sender typisk dataene til et Ecto Changeset til validering og indsætter dem derefter i databasen. Hvis det lykkes, svarer vi med den nyoprettede ressource; ellers sender vi en fejl.

Kode: Handlingen `create`

Her er en forenklet handling med create. Bemærk, hvordan vi bruger conn.body_params og derefter gengiver resultatet med render. (I en rigtig app ville create_product involvere Changesets og kald til Ecto Repo).

Prøv at forstå, hvordan det nye produkt gengives tilbage til klienten.

defmodule MyAppWeb.ProductController do
  use MyAppWeb, :controller
  alias MyApp.Products
  alias MyApp.Products.Product

  # ... other actions ...

  def create(conn, %{"product" => product_params}) do
    case Products.create_product(product_params) do
      {:ok, product} ->
        conn
        |> put_status(:created)
        |> render(:show, product: product)
      {:error, %Ecto.Changeset{} = changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render(MyAppWeb.ChangesetView, "error.json", changeset: changeset)
    end
  end

  # Dummy function for runnable code
  defp create_product(params) do
    # In a real app, this would save to DB with Ecto.Changeset
    # For demo, just return a dummy product
    product = %Product{id: 1, name: params["name"], price: params["price"], description: params["description"]}
    {:ok, product}
  end

  # For runnable context
  defmodule Product do
    defstruct [:id, :name, :price, :description]
  end
end

Håndtering af forespørgselsbrødtekster: Opdatering

Handlingen update håndterer PUT- eller PATCH-forespørgsler for at ændre en eksisterende ressource (f.eks. PUT /products/:id). Den minder om create, men først henter du den eksisterende ressource.

De opdaterede data findes også i conn.body_params. Efter validering og opdatering af ressourcen svarer du typisk med den opdaterede ressource eller en fejl.

defmodule MyAppWeb.ProductController do
  use MyAppWeb, :controller
  alias MyApp.Products
  alias MyApp.Products.Product

  # ... other actions ...

  def update(conn, %{"id" => id, "product" => product_params}) do
    product = Products.get_product!(id)

    case Products.update_product(product, product_params) do
      {:ok, product} ->
        render(conn, :show, product: product)
      {:error, %Ecto.Changeset{} = changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render(MyAppWeb.ChangesetView, "error.json", changeset: changeset)
    end
  end

  # Dummy functions for runnable context
  defp get_product!(id), do: %Product{id: String.to_integer(id), name: "Old Name", price: "10.0", description: "Old Description"}
  defp update_product(product, params) do
    updated_product = %{product | name: Map.get(params, "name", product.name), price: Map.get(params, "price", product.price)}
    {:ok, updated_product}
  end

  defmodule Product do
    defstruct [:id, :name, :price, :description]
  end
end

Hvad er serialisering?

Serialisering er processen, hvor Elixir-datastrukturer (som structs eller maps) konverteres til et format, der nemt kan overføres via et netværk eller gemmes. For API'er betyder det normalt, at Elixir-data konverteres til JSON (JavaScript Object Notation).

Hvorfor er det vigtigt? Det gør det muligt for forskellige systemer (din Elixir-backend og en mobilapp eller webfrontend) at forstå og udveksle data på en ensartet måde.

Grundlæggende JSON-serialisering med `render`

Phoenix bruger visninger til at håndtere serialisering. Når du kalder render(conn, :show, product: product) i en controller, leder Phoenix efter et tilsvarende visningsmodul (f.eks. ProductView) og en funktion (f.eks. render("show.json", %{product: product})).

Denne funktion definerer derefter, hvordan Elixir-structen product skal omdannes til et JSON-map.

defmodule MyAppWeb.ProductView do
  use MyAppWeb, :view

  def render("index.json", %{products: products}) do
    %{data: render_many(products, __MODULE__, :product)}
  end

  def render("show.json", %{product: product}) do
    %{data: render_one(product, __MODULE__, :product)}
  end

  def product(product) do
    %{id: product.id,
      name: product.name,
      description: product.description,
      price: product.price}
  end
end

Tilpasning af JSON-output

Funktionen product/1 i ProductView er det sted, hvor du definerer den nøjagtige struktur af dit JSON-svar. Du kan:

Vælge bestemte felter, der skal medtages eller udelades.
Omdøbe felter, så de er nemmere for klienter at bruge.
Indlejre relaterede data (f.eks. medtage et produkts kategori).

Det giver dig detaljeret kontrol over, hvilke data dit API stiller til rådighed, og hvordan de struktureres.

Hurtigt tjek: Forespørgselsbrødtekster

Forestil dig et Phoenix API-endpoint, der er designet til at oprette en ny bruger. En klient sender en POST-anmodning til /api/users med en JSON-body:

{"user": {"name": "Alice", "email": "alice@example.com"}}

Hvilken del af conn-strukturen indeholder dataene {"name": "Alice", "email": "alice@example.com"}?

Besvar den i den interaktive lektion

Opsummering: Endpoints og serialisering

Godt klaret! Du har lært, hvordan du opbygger og forstår Phoenix API-endpoints:

API-endpoints: Specifikke URL'er til handlinger på ressourcer.
Anmodningsbodyer: Data, som klienter sender (f.eks. med POST/PUT), findes i conn.body_params.
Serialisering: Konvertering af Elixir-data til JSON til API-svar, primært håndteret af Phoenix-visninger.
Tilpasning: Visninger giver dig mulighed for at styre den præcise JSON-struktur.

Disse begreber er grundlæggende, når du bygger robuste og klientvenlige RESTful API'er med Phoenix!

Gratis at komme i gang

Lær Elixir med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Implementering af API-endpoints og serialisering” gratis?

Ja — hele teksten til “Implementering af API-endpoints og serialisering” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Elixir og Phoenix: Skalerbar backend-udvikling-kurset, skal du opgradere til CoddyKit PRO. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Implementering af API-endpoints og serialisering”?

Byg API-endpoints, håndtér request- og response-bodyer, og serialisér data effektivt til klienter. Du øver dig i Elixir og Phoenix: Skalerbar backend-udvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Elixir og Phoenix: Skalerbar backend-udvikling?

Der kræves ingen tidligere erfaring. Elixir og Phoenix: Skalerbar backend-udvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Implementering af API-endpoints og serialisering”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Elixir og Phoenix: Skalerbar backend-udvikling-lektion?

Ja. Alle Elixir og Phoenix: Skalerbar backend-udvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Principper og bedste praksis for API-design
Implementering af API-endpoints og serialisering
Strategier for godkendelse og autorisation
Sideinddeling, filtrering og API-versionering

← Tilbage til Elixir og Phoenix: Skalerbar backend-udvikling