R Academy · Pelajaran

Membuat Permintaan HTTP dengan httr2

Hantar permintaan GET dan POST, kendalikan pengepala serta proses respons.

Pelajaran 2 daripada 413 langkah

Membuat Permintaan HTTP dengan httr2 ialah pelajaran R Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran R Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Pengenalan kepada httr2

httr2 ialah pakej R moden untuk permintaan HTTP dan menggantikan httr. Pakej ini menggunakan corak pembina berasaskan paip: mulakan dengan request(url), tambah pengubah, kemudian laksanakan dengan req_perform().

library(httr2)

# Basic GET request pattern:
# request(url)     -> create request object
# |> req_*()       -> modify request
# |> req_perform() -> send request
# |> resp_*()      -> extract from response

# Minimal example (requires internet):
# resp <- request('https://httpbin.org/get') |>
#   req_perform()
# resp_status(resp)     # 200
# resp_body_json(resp)  # parsed JSON body

cat('httr2 follows: build -> perform -> extract')

request() dan req_perform()

request(url) mencipta objek permintaan. req_perform() melaksanakannya dan mengembalikan objek respons. Respons itu kemudiannya boleh diperiksa dengan fungsi resp_*.

library(httr2)

# Build and send a GET request
# resp <- request('https://httpbin.org/get') |>
#   req_perform()

# Inspect response
# resp_status(resp)          # 200
# resp_status_desc(resp)     # 'OK'
# resp_headers(resp)         # list of headers
# resp_header(resp, 'content-type')  # single header
# resp_body_string(resp)     # raw body as string
# resp_body_json(resp)       # parsed JSON
# resp_body_raw(resp)        # raw bytes

cat('Response hierarchy:')
cat('status -> headers -> body')

req_headers(): Pengepala Tersuai

req_headers() menambah atau menggantikan pengepala HTTP. Ia digunakan untuk token pengesahan, penetapan jenis kandungan, pengepala versi API dan metadata permintaan tersuai.

library(httr2)

# Add custom headers
# resp <- request('https://api.example.com/data') |>
#   req_headers(
#     'Authorization' = 'Bearer my_token',
#     'X-API-Version' = '2',
#     'Accept'        = 'application/json'
#   ) |>
#   req_perform()

# Common headers:
# 'Content-Type' = 'application/json' for POST with JSON body
# 'Accept'       = 'application/json' to request JSON response
# 'User-Agent'   = 'MyApp/1.0' for polite identification
# 'X-API-Key'    = key  for key-based auth

cat('req_headers() sets HTTP request headers')

req_url_query(): Parameter Pertanyaan

req_url_query() menambah parameter pertanyaan kepada URL dengan selamat, termasuk mengekod aksara khas. Cara ini lebih kemas daripada menggabungkan rentetan secara manual dengan paste0().

library(httr2)

# Add query parameters
# resp <- request('https://api.example.com/search') |>
#   req_url_query(
#     q      = 'R programming',
#     page   = 1,
#     size   = 20,
#     sort   = 'relevance'
#   ) |>
#   req_perform()
# Resulting URL:
# https://api.example.com/search?q=R+programming&page=1&size=20&sort=relevance

# Inspect the URL without performing:
req <- request('https://api.example.com/search') |>
  req_url_query(q = 'hello world', page = 2)
req$url
# 'https://api.example.com/search?q=hello+world&page=2'

Permintaan POST dengan req_body_json()

Hantar data JSON dalam permintaan POST dengan req_body_json(). Fungsi ini menetapkan pengepala Content-Type: application/json secara automatik dan mengekodkan senarai R kepada JSON.

library(httr2)

# POST request with JSON body
# resp <- request('https://api.example.com/users') |>
#   req_method('POST') |>
#   req_body_json(list(
#     name  = 'Alice',
#     email = 'alice@example.com',
#     role  = 'admin'
#   )) |>
#   req_perform()

# resp_status(resp)     # 201 Created (if success)
# resp_body_json(resp)  # returned user object

# Other body methods:
# req_body_form(...)  -> application/x-www-form-urlencoded
# req_body_raw(bytes) -> raw bytes
# req_body_file(path) -> file upload
cat('req_body_json() handles Content-Type automatically')

resp_body_json(): Menghuraikan Respons

resp_body_json() menghuraikan badan respons sebagai JSON kepada senarai R. Gunakan simplifyVector=TRUE (nilai lalai) untuk menukar susunan JSON kepada vektor R dan objek kepada senarai bernama secara automatik.

library(httr2)
library(jsonlite)

# Simulated API response handling
# resp <- request('https://api.github.com/users/hadley') |>
#   req_perform()
# user <- resp_body_json(resp)
# user$name    # 'Hadley Wickham'
# user$public_repos  # number of repos
# user$followers     # follower count

# For arrays (simplifyVector=TRUE converts to data frame):
# resp <- request('https://api.github.com/users/hadley/repos') |>
#   req_perform()
# repos <- resp_body_json(resp, simplifyVector = TRUE)
# repos$name  # vector of repo names

cat('resp_body_json() with simplifyVector=TRUE -> data frame')

resp_status() dan Pengendalian Ralat

resp_check_status() menjana ralat secara automatik untuk respons 4xx/5xx. Tanpanya, httr2 tidak menjana ralat bagi kod status yang buruk — anda mesti memeriksanya secara jelas atau memanggil resp_check_status().

library(httr2)

# Pattern: check status after perform
# resp <- request('https://api.example.com/data') |>
#   req_perform() |>
#   resp_check_status()  # errors on 4xx/5xx

# Manual status checks:
# status <- resp_status(resp)
# if (status == 200) { ... }
# if (status == 404) { stop('Not found') }
# if (status == 401) { stop('Unauthorized') }
# if (status == 429) { Sys.sleep(60); retry() }

# HTTP status codes:
# 200 OK, 201 Created, 204 No Content
# 400 Bad Request, 401 Unauthorized, 403 Forbidden
# 404 Not Found, 429 Rate Limited
# 500 Server Error, 503 Service Unavailable
cat('Always check response status codes')

req_retry(): Percubaan Semula Automatik

req_retry() mencuba semula permintaan yang gagal secara automatik. Tentukan max_tries dan, secara pilihan, is_transient, iaitu fungsi yang mengenal pasti ralat yang boleh dicuba semula seperti 429 atau 503. Ini penting untuk klien API yang teguh.

library(httr2)

# Automatic retry with exponential backoff
# resp <- request('https://api.example.com/data') |>
#   req_retry(
#     max_tries = 3,
#     is_transient = function(resp) {
#       resp_status(resp) %in% c(429, 500, 503)
#     },
#     backoff = ~ 2^.x  # exponential: 2, 4, 8 seconds
#   ) |>
#   req_perform()

# Default retry behavior:
# - Retries on 429 Too Many Requests automatically
# - Uses Retry-After header if present
# - max_tries = 1 by default (no retry)

# Simple retry:
# req_retry(max_tries = 3)  # retry up to 3 times total
cat('req_retry() adds resilience to API calls')

req_throttle(): Mengehadkan Kadar

req_throttle(rate) memastikan anda tidak melebihi kadar permintaan maksimum. Hantar rate = n/period, contohnya 10 permintaan seminit. httr2 akan berhenti seketika antara permintaan mengikut keperluan.

library(httr2)

# Throttle to at most 10 requests per minute
# urls <- paste0('https://api.example.com/items/', 1:50)
# resps <- lapply(urls, function(url) {
#   request(url) |>
#     req_throttle(rate = 10 / 60) |>  # 10/min
#     req_perform()
# })

# Alternative: use req_perform_parallel() for parallel
# with throttle built in:
# reqs <- lapply(urls, \(u) request(u))
# resps <- req_perform_parallel(
#   reqs,
#   on_error = 'continue',  # skip failures
#   progress = TRUE
# )

cat('req_throttle(rate = 10/60) = 10 req/min')

Pembantu Pengesahan

httr2 menyediakan pembantu pengesahan terbina dalam: req_auth_basic(user, pass) untuk pengesahan Asas, req_auth_bearer_token(token) untuk token Bearer dan req_oauth_*() untuk aliran OAuth.

library(httr2)

# Bearer token (most common for modern APIs)
# resp <- request('https://api.example.com/data') |>
#   req_auth_bearer_token('my_api_token_here') |>
#   req_perform()

# Basic authentication
# resp <- request('https://api.example.com/data') |>
#   req_auth_basic('username', 'password') |>
#   req_perform()

# Store tokens securely in environment variables
# token <- Sys.getenv('MY_API_TOKEN')
# resp <- request('https://api.example.com') |>
#   req_auth_bearer_token(token) |>
#   req_perform()

cat('Never hardcode tokens in scripts!')
cat('Use Sys.getenv() or the keyring package')

Larian Uji dengan req_dry_run()

req_dry_run() memaparkan dengan tepat perkara yang akan dihantar dalam permintaan, iaitu kaedah, URL, pengepala dan badan, tanpa menghantarnya. Ini penting untuk menyahpepijat permintaan kompleks sebelum menghubungi API sebenar.

library(httr2)

# Inspect the request without sending it
req <- request('https://api.example.com/users') |>
  req_method('POST') |>
  req_headers(
    'X-API-Version' = '2',
    'Accept'        = 'application/json'
  ) |>
  req_auth_bearer_token('my_token') |>
  req_body_json(list(name = 'Alice', role = 'admin')) |>
  req_url_query(notify = 'true')

# Show request details without sending
req_dry_run(req)
# POST /users?notify=true HTTP/1.1
# Host: api.example.com
# Authorization: Bearer my_token
# Content-Type: application/json
# ...

Semakan Pantas

Uji pemahaman anda tentang corak pembinaan permintaan httr2.

Jawab dalam pelajaran interaktif

Imbas Kembali: Permintaan HTTP dengan httr2

Perkara utama: httr2 menggunakan pembina berasaskan paip: request(url) |> req_*() |> req_perform(). Tambah pengepala dengan req_headers(), parameter pertanyaan dengan req_url_query() dan badan JSON dengan req_body_json(). Lakukan pengesahan dengan req_auth_bearer_token(). Sentiasa semak status dengan resp_check_status(). Tambah ketahanan dengan req_retry() dan hadkan kadar dengan req_throttle(). Nyahpepijat dengan req_dry_run().

library(httr2)

# Complete httr2 request pattern:
# resp <- request('https://api.example.com/endpoint') |>
#   req_headers('Accept' = 'application/json') |>
#   req_url_query(param1 = 'value', page = 1) |>
#   req_auth_bearer_token(Sys.getenv('API_TOKEN')) |>
#   req_retry(max_tries = 3) |>
#   req_throttle(rate = 10/60) |>
#   req_perform() |>
#   resp_check_status()

# Extract data:
# data <- resp_body_json(resp, simplifyVector = TRUE)

cat('build -> authenticate -> perform -> check -> extract')

Percuma untuk bermula

Pelajari R dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 43
Pelajaran: 159

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membuat Permintaan HTTP dengan httr2” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran R Academy, termasuk “Membuat Permintaan HTTP dengan httr2”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membuat Permintaan HTTP dengan httr2”?

Hantar permintaan GET dan POST, kendalikan pengepala serta proses respons. Anda berlatih R Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan R Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran R Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Membuat Permintaan HTTP dengan httr2” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke R Academy