Pagsisimula sa Alamo Apoy

Upang simulan ang pag - uugnay ng Alamofire sa iyong proyektong iOS, maaari mong idagdag ang aklatan na ginagamit ang Swift Appy Mander, CocoaPods, o Carthage. Swift Appy Maler sa iyong proyektong ito habang ito ay itinatayo sa Xcode. Idagdag ang paketeng Alamofire sa pamamagitan ng paglalakbay patungo Ang File [[FL]] [[FLL]] [[2] Eblusyon[FL] at pagpasok sa UT][T] [[T] [[T] [[T] [[T] [[T] [[T] [[T] [[T] [[T] [[T] [[T]] [[T] [[T] [[T]] [[T] [[T]:] [[T] [[T] [[T]] [[T] [[T]] [[T]] [[T] [[T]]] [[T]] [[T] [[T] [[

import Alamofire

Ang Alamofireificers ay nagbibigay ng maginhawang entidad para sa lahat ng karaniwang operasyon ng HTTP. Sa ilalim ng hood, gumagamit ito ng Apple EXTers ngunit mahirap unawain ang boilerplate tulad ng queue management, parame administration, at tugon fectation. Ito ay nagbibigay-daan sa iyong pagtuon sa lohikang pangnegosyo sa halip na networking tuberoping. Para sa higit pang detalye sa ilalim ng networking layer, tumutukoy sa [[LT:0T:0T] apple EXSPERS.[LES][S.[T][T][T][T][T][T][TLES][TLES][T.

Pagganap sa mga Kahilingan sa Pag - upo

Ang pag - aalis ng impormasyon mula sa isang RESTful endpoint ang pinakakaraniwang operasyon.

AF.request("https://api.example.com/users")
 .validate()
 .responseDecodable(of: [User].self) { response in
 switch response.result {
 case .success(let users):
 print("Fetched \(users.count) users")
 case .failure(let error):
 print("Request failed with error: \(error)")
 }
 }

Pansinin ang paggamit ng , na nag - aalis ng Swiftifts protocol upang awtomatikong i-parse ang JON sa mga bagay na modelo. hurifine a struct na umaayon sa (o ). Ang pamamaraang ito ay nag - aalis ng manu - manong J serialization at na nagpapabuti sa kaligtasan ng tipo.

Pagdaragdag ng mga Parametro at Tagapangulo ng Query

Maraming REST API ang nangangailangan ng mga query parameter o kaugalian na HTTP headers. Tinatanggap ng Alamofire ang mga parameter bilang isang diksyunaryo at mga hawakang awtomatiko para sa mga unch request (parameters ay inihahabla sa URL).Ang mga header ay idinaragdag sa pamamagitan ng parameter:

let parameters: Parameters = ["page": 1, "limit": 20]
let headers: HTTPHeaders = [
 "Authorization": "Bearer YOUR_TOKEN",
 "Accept": "application/json"
]

AF.request("https://api.example.com/users",
 parameters: parameters,
 headers: headers)
 .validate()
 .responseDecodable(of: [User].self) { response in
 // handle response
 }

Alabofire awtomatikong URL-encodes the parameters at ikinakabit ang mga ito sa kahilingan na URL. Para sa pag-aayos ng kaugalian, maaari mong tiyakin ang isang maliwanag .

Pagsagot Nang May Kagantihan

Ang paraang ay awtomatikong sumusuri sa mga kodigo ng katayuan ng HTTP sa 200–299 na saklaw at tumatanggi sa mga tugon na may hindi-kanais-nais na nilalamang uri. Maaari ka ring magdagdag ng mga batayang pang-administratibo ng kaugalian. Halimbawa, upang tanggapin lamang ang 200 at 201 kodigo ng katayuan:

.validate(statusCode: [200, 201])

Ang mga kabiguan sa pagbibigay ng tawad ay iniulat na mga pagkakamali sa humahawak ng tugon, na nagpapahintulot sa iyo na ipatupad ang di - nagbabagong pagkakamali na humahawak sa lahat ng iyong pagkakapit.

Pagpadala ng POST Data

Ang paglikha o pag-apruba ng mga mapagkukunan ay karaniwang nangangailangan ng POST na may request na katawan.Si Alamofire ay sumusuporta sa mga maramihang estratehiyang pang-edukasyon, na ang ay ang pinaka-karaniwan para sa REST API. Ang sumusunod na halimbawa ay nagpapadala ng bagong user na bagay sa server:

let newUser: [String: Any] = [
 "name": "Jane Doe",
 "email": "[email protected]"
]

AF.request("https://api.example.com/users",
 method: .post,
 parameters: newUser,
 encoding: JSONEncoding.default)
 .validate()
 .responseDecodable(of: User.self) { response in
 switch response.result {
 case .success(let createdUser):
 print("User created: \(createdUser)")
 case .failure(let error):
 print("Error creating user: \(error)")
 }
 }

Kung inaasahan ng API ang URL ⁇ encoded form data (e.g., para sa OAuth token exchange), gamitin sa halip. Para sa mga file uploads o mixed data, ang Alamofire ay nagbibigay na gumagawa ng isang multipart request. Halimbawa:

AF.upload(multipartFormData: { multipartFormData in
 multipartFormData.append(Data("Jane Doe".utf8), withName: "name")
 multipartFormData.append(imageData, withName: "avatar", fileName: "avatar.jpg", mimeType: "image/jpeg")
}, to: "https://api.example.com/users")
 .validate()
 .responseDecodable(of: User.self) { response in
 // handle response
 }

Paggawa na May Iba Pang Pamamaraan ng HTTP

Ang mga operasyong RESTful API ay kadalasang nangangailangan ng PUT (full update), PATCH (partial update), at DELETE (removal). alabofire pinangangasiwaan ang mga ito sa pamamagitan ng parehong paraan ; baguhin lamang ang parameter.

PUT at PATCH

Upang i-update ang isang umiiral na mapagkukunan, gamitin o . Ang request body ay naglalaman ng mga na-aprubang field:

let updatedFields: [String: Any] = ["name": "Jane Smith"]
AF.request("https://api.example.com/users/123",
 method: .patch,
 parameters: updatedFields,
 encoding: JSONEncoding.default)
 .validate()
 .responseDecodable(of: User.self) { response in
 // handle updated user
 }

PUTULO

Ang pag - aalis ng yaman ay karaniwan nang hindi nangangailangan ng tulong, o ng isang mensahe:

AF.request("https://api.example.com/users/123",
 method: .delete)
 .validate()
 .response { response in
 if let error = response.error {
 print("Delete failed: \(error)")
 } else {
 print("User deleted successfully")
 }
 }

Laging suriin ang API dokumentasyon para sa inaasahang status code (e.g., 204 Walang Content).

Patiunang Pagkakamali sa Pag - aasikaso at Pag - i - monitor ng Network

Ang mga pagkakamaling ginagampanan ni Robust error handing ay mahalaga para sa isang karanasang walang kinalaman sa paggamit ng Internet. iniulat ni Alamofire ang mga pagkakamali sa pamamagitan ng uring , na nagpapakita ng pagkakaiba sa pagitan ng mga pagkakamali sa network (timeout, walang koneksiyon), mga pagkakamali sa server (masamang kodigo ng katayuan), at mga kabiguan sa serialization (invalid JON).

switch response.result {
case .success(let value):
 // handle success
case .failure(let error):
 if let afError = error.asAFError {
 switch afError {
 case .sessionTaskFailed(let sessionError):
 print("Network issue: \(sessionError.localizedDescription)")
 case .responseValidationFailed(let reason):
 print("Validation failed: \(reason)")
 default:
 print("Other Alamofire error: \(afError.localizedDescription)")
 }
 }
}

Maaabot ang Network

Bago gumawa ng mga kahilingan, baka gusto mong suriin ang makukuhang network.

let reachabilityManager = NetworkReachabilityManager()
reachabilityManager?.startListening { status in
 switch status {
 case .notReachable:
 print("Network is not reachable")
 case .reachable(.cellular):
 print("Connected via cellular")
 case .reachable(.ethernetOrWiFi):
 print("Connected via WiFi")
 case .unknown:
 print("Unknown status")
 }
}

Gamitin ito upang ipaalam sa gumagamit o ipagpaliban ang mga kahilingan. Para sa mas makabagong mga disenyo, isaalang-alang ang pagsasama ng matrikula sa isang mekanismong pang-estratehiya, tulad ng muling pag-eensayo ng mga bigong kahilingan kapag ibinalik ang connectivity.

Pinakamahusay na Gawain Para sa Produksiyon-Pagbasa Networking

Ang pagsunod sa tatag na mga huwaran ay mag - iingat sa iyong networking layer na mapanatili, mapanatiling matatag, at maging aktibo.

1. Magsagawa ng mga Modelong Masusunod

Laging bigyan ng kahulugan ang mga uring Swift na naaayon sa (o ) bilang tugon parcing.Ito ay nag-aalis ng manufacturing na JSON at nagbabawas ng mga bug. Gamitin o ang mas mababang glossiyong ⁇ FLT:36] kung kailangan mo ng dynamic contenture. Apple ⁇ s [FLT:]] covered keysicure na may cusplain ang mga susi.

2. Mas Ligtas na Pag - iral at Pangangasiwa ng mga Token

Huwag hardcode API keys o tokens. I-imbak ang mga sensitibong halaga sa Keychain at idikit ang mga ito sa mga kahilingan sa pamamagitan ng header. Para sa OAuth streets, ipatupad ang isang bahagyang respirator. Alamofireifics Ang protocol ay nagpapahintulot sa iyo na awtomatikong baguhin ang mga kahilingan pagkatapos makakuha ng bagong single.

class AuthInterceptor: RequestInterceptor {
 func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
 var request = urlRequest
 request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
 completion(.success(request))
 }

 func retry(_ request: Request, for session: Session, dueTo error: Error, completion: @escaping (RetryResult) -> Void) {
 // Check if error is 401, refresh token, then retry
 completion(.retryWithDelay(1.0))
 }
}

3. Kumbinasyon sa async/await

Ang Alamofire 5 ay lubusang sumusuporta sa Swiftimenciers consentence model. Gamitin ang mga bersyon ng mga paraan ng paghiling upang isulat ang mas malinis, linear code:

do {
 let users = try await AF.request("https://api.example.com/users")
 .serializingDecodable([User].self)
 .value
 print("Users: \(users)")
} catch {
 print("Error: \(error)")
}

Ihalo ito sa organisadong pagsang - ayon (mga grupo ng mga tusk, mga artista) upang pangasiwaan ang maraming kahilingan at iwasan ang tinatawag na back series.

4. Pag - aalis ng Tatak

Upang mabawasan ang mga tawag sa network at mapabuti ang suporta sa offline, isaayos ang mga patakaran sa pag-aalsa.Ignogorya Ang alabo ay may paggalang sa (e.g., ). Maaari ka ring gumamit ng isang kaugalian na may angkop na kapasidad na disk:

let cache = URLCache(memoryCapacity: 10 * 1024 * 1024,
 diskCapacity: 50 * 1024 * 1024,
 diskPath: "networking_cache")
let session = Session(configuration: URLSessionConfiguration.default)
session.sessionConfiguration.urlCache = cache

5. Subukin ang Iyong Tagala ng Network

Isulat ang mga unit test para sa mga kliyenteng API gamit ang pakunwaring datos.[Cofire ⁇ s Maaaring i-iniksiyunan ng isang pakunwaring protocol na nagbabalik ng mga prefinciflusion. Isaalang-alang ang paggamit ng mga aklatan tulad ng o ang itinayong calcanin porsporation.Ture ang iyong pagkakamali sa paghawak at pag-a-reporfleflection ay tama nang hindi na tumatama sa tunay na mga intition.

6. Gumamit ng Centralized Networking Managing

Gumawa ng isang klase na nagsasaayos ng isa halimbawa na may base URL, headers, interceptions, at isang kabahaging cache. Ito ay pumipigil sa duplication at ginagawa itong madaling palitan ng mga patakaran o kutyain ang buong layer.

class APIClient {
 static let shared = APIClient()
 private let session: Session

 private init() {
 let config = URLSessionConfiguration.default
 config.timeoutIntervalForRequest = 30
 config.urlCache = URLCache.shared
 session = Session(configuration: config, interceptor: AuthInterceptor())
 }

 func fetchUsers() async throws -> [User] {
 return try await session.request("\(baseURL)/users")
 .serializingDecodable([User].self)
 .value
 }
}

Para sa isang komprehensibong pagkaunawa sa mga padrong networking, tumutukoy ang [Alamofire Advanced Usage document. Ang [[FLT API tutorial sa quitapi.net ay nagbibigay ng mahahalagang mga kabatiran sa pagdidisenyo ng rove API.

Sa pagsunod sa mga panuntunang ito at sa pag - aalis ng mga Alamofireić na nagpapahayag ng API, maaari kang magtayo ng isang network layer na kapuwa malakas at madaling panatilihin.