Elixir og Phoenix: Skalerbar backendutvikling · leksjon

Implementering av API-endepunkter og serialisering

Bygg API-endepunkter, håndter forespørsels- og svarinnhold, og serialiser data effektivt for klienter.

Leksjon 2 av 411 trinn

Implementering av API-endepunkter og serialisering er en gratis leksjon i Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Elixir og Phoenix: Skalerbar backendutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

API-endepunkter: Grunnleggende begreper

Velkommen! I denne leksjonen skal vi bygge API-endepunkter i Phoenix. Et API-endepunkt er en bestemt URL som en API-klient kan få tilgang til for å utføre en handling eller hente data.

Tenk på det som en digital adresse til en bestemt ressurs, for eksempel /api/products eller /api/users/123. Hvert endepunkt tilsvarer vanligvis en handling (for eksempel å hente alle produkter eller opprette en ny bruker).

Opprette et API for en ressurs

Phoenix tilbyr en praktisk generator for raskt å sette opp en RESTful API-ressurs. Vi bruker mix phx.gen.json til å opprette ressursen Product.

Denne kommandoen genererer:

En oppføring i ruteren
En kontroller (for eksempel ProductController)
Et Ecto-skjema (for eksempel Product)
En visning (for eksempel ProductView) for JSON-serialisering

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

API-kontrolleren: Liste og visning

Etter genereringen kan vi se på en enkel API-kontroller. Handlingen index håndterer GET /products for å liste opp alle produkter. Handlingen show håndterer GET /products/:id for å vise ett enkelt produkt.

Phoenix-kontrollere bruker conn (tilkoblingen) til å håndtere forespørsler og svar. Vi henter data og bruker deretter render til å gjengi 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 av forespørselsinnhold: Opprettelse

Når en klient sender data for å opprette en ny ressurs (for eksempel POST /products), ligger dataene i forespørselsinnholdet. Phoenix gjør disse dataene tilgjengelige i conn.body_params.

Vanligvis sender vi disse dataene til et Ecto Changeset for validering og setter dem deretter inn i databasen. Hvis det lykkes, svarer vi med den nyopprettede ressursen; ellers sender vi en feilmelding.

Kode: `create`-handlingen

Her er en forenklet create-handling. Legg merke til hvordan vi bruker conn.body_params og deretter render resultatet. (I en virkelig applikasjon ville create_product involvere Changesets og kall til Ecto Repo.)

Prøv å forstå hvordan det nye produktet gjengis tilbake 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 av forespørselsinnhold: Oppdatering

Handlingen update håndterer PUT- eller PATCH-forespørsler for å endre en eksisterende ressurs (for eksempel PUT /products/:id). Den ligner på create, men først henter du den eksisterende ressursen.

De oppdaterte dataene finnes også i conn.body_params. Etter at ressursen er validert og oppdatert, svarer du vanligvis med den oppdaterte ressursen eller en feilmelding.

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

Hva er serialisering?

Serialisering er prosessen med å konvertere datastrukturer i Elixir (som structs eller kart) til et format som enkelt kan overføres over et nettverk eller lagres. For API-er betyr dette vanligvis å konvertere Elixir-data til JSON (JavaScript Object Notation).

Hvorfor er dette viktig? Det gjør at ulike systemer (Elixir-backend-en din og en mobilapp eller webfrontend) kan forstå og utveksle data på en konsistent måte.

Grunnleggende JSON-serialisering med `render`

Phoenix bruker visninger til å håndtere serialisering. Når du kaller render(conn, :show, product: product) i en kontroller, leter Phoenix etter en tilsvarende visningsmodul (for eksempel ProductView) og en funksjon (for eksempel render("show.json", %{product: product})).

Denne funksjonen definerer deretter hvordan Elixir-strukturen product skal omdannes til et JSON-kart.

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

Tilpasse JSON-resultatet

Funksjonen product/1 i ProductView er stedet der du definerer den nøyaktige strukturen til JSON-svaret. Du kan:

Velge bestemte felt som skal inkluderes eller utelates.
Gi felter nye navn som er enklere for klienten å bruke.
Nøste relaterte data (for eksempel inkludere kategorien til et produkt).

Dette gir deg detaljert kontroll over hvilke data API-et eksponerer, og hvordan de struktureres.

Hurtigsjekk: Forespørselsinnhold

Se for Dem et Phoenix API-endepunkt som er laget for å opprette en ny bruker. En klient sender en POST-forespørsel til /api/users med en JSON-kropp:

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

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

Besvar den i den interaktive leksjonen

Oppsummering: Endepunkter og serialisering

Godt jobbet! De har lært hvordan man bygger og forstår Phoenix API-endepunkter:

API-endepunkter: Spesifikke URL-er for handlinger på ressurser.
Forespørselskropper: Data som sendes av klienter (for eksempel med POST/PUT), ligger i conn.body_params.
Serialisering: Konvertering av Elixir-data til JSON for API-svar, hovedsakelig håndtert av Phoenix-visninger.
Tilpasning: Visninger lar Dem styre den nøyaktige JSON-strukturen.

Disse konseptene er grunnleggende for å bygge robuste og klientvennlige RESTful-API-er med Phoenix!

Gratis å komme i gang

Lær deg Elixir med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Implementering av API-endepunkter og serialisering» gratis?

Ja – hele teksten i «Implementering av API-endepunkter og serialisering» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Elixir og Phoenix: Skalerbar backendutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Implementering av API-endepunkter og serialisering»?

Bygg API-endepunkter, håndter forespørsels- og svarinnhold, og serialiser data effektivt for klienter. Du øver på Elixir og Phoenix: Skalerbar backendutvikling med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Elixir og Phoenix: Skalerbar backendutvikling?

Ingen tidligere erfaring er nødvendig. Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Implementering av API-endepunkter og serialisering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Elixir og Phoenix: Skalerbar backendutvikling-leksjonen?

Ja. Alle Elixir og Phoenix: Skalerbar backendutvikling-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Prinsipper og beste praksis for API-design
Implementering av API-endepunkter og serialisering
Strategier for autentisering og autorisering
Paginering, filtrering og API-versjonering

← Tilbake til Elixir og Phoenix: Skalerbar backendutvikling