El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Redes en Swift

Siguiente ►
►

En este módulo, aprenderás cómo manejar la comunicación en red dentro de tus aplicaciones Swift. Este es un aspecto crucial del desarrollo de aplicaciones modernas, ya que la mayoría de las aplicaciones necesitan interactuar con servicios web para obtener datos o enviar información.

Contenido

  1. Introducción a las Redes en Swift
  2. Realizando Solicitudes HTTP
  3. Manejo de Respuestas HTTP
  4. Parseo de JSON
  5. Ejemplo Práctico: Consumir una API REST
  6. Errores Comunes y Soluciones
  7. Ejercicios Prácticos

Introducción a las Redes en Swift

Swift proporciona varias formas de manejar la comunicación en red. La más común y recomendada es usar URLSession, una API poderosa y flexible que permite realizar solicitudes HTTP y manejar respuestas de manera eficiente.

Conceptos Clave

  • URLSession: Una clase que proporciona una API para realizar solicitudes HTTP.
  • Data Task: Una tarea que se utiliza para enviar y recibir datos mediante HTTP.
  • JSON: Un formato común para intercambiar datos entre un cliente y un servidor.

Realizando Solicitudes HTTP

Para realizar una solicitud HTTP en Swift, utilizamos URLSession. Aquí hay un ejemplo básico de cómo hacer una solicitud GET:

import Foundation

// 1. Crear la URL
guard let url = URL(string: "https://api.example.com/data") else {
    print("URL inválida")
    return
}

// 2. Crear la solicitud
let request = URLRequest(url: url)

// 3. Crear la sesión
let session = URLSession.shared

// 4. Crear la tarea
let task = session.dataTask(with: request) { data, response, error in
    // 5. Manejar la respuesta
    if let error = error {
        print("Error: \(error.localizedDescription)")
        return
    }
    
    guard let data = data else {
        print("No se recibió datos")
        return
    }
    
    // Aquí puedes manejar los datos recibidos
    print("Datos recibidos: \(data)")
}

// 6. Iniciar la tarea
task.resume()

Explicación del Código

  1. Crear la URL: Asegúrate de que la URL sea válida.
  2. Crear la solicitud: Utilizamos URLRequest para crear una solicitud HTTP.
  3. Crear la sesión: URLSession.shared proporciona una sesión compartida que podemos usar para realizar solicitudes.
  4. Crear la tarea: dataTask(with:) crea una tarea que se ejecutará para enviar la solicitud y recibir la respuesta.
  5. Manejar la respuesta: En el closure, manejamos cualquier error y los datos recibidos.
  6. Iniciar la tarea: task.resume() inicia la tarea.

Manejo de Respuestas HTTP

Es importante manejar adecuadamente las respuestas HTTP para asegurarse de que la solicitud fue exitosa y los datos recibidos son válidos.

let task = session.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Respuesta inválida")
        return
    }
    
    guard let data = data else {
        print("No se recibió datos")
        return
    }
    
    // Aquí puedes manejar los datos recibidos
    print("Datos recibidos: \(data)")
}

Explicación del Código

  • Verificar el error: Primero, verificamos si hubo un error en la solicitud.
  • Verificar la respuesta HTTP: Nos aseguramos de que la respuesta sea un HTTPURLResponse y que el código de estado esté en el rango 200-299, lo que indica éxito.
  • Verificar los datos: Nos aseguramos de que los datos no sean nulos antes de proceder.

Parseo de JSON

La mayoría de las veces, los datos recibidos estarán en formato JSON. Swift proporciona el tipo Codable para facilitar el parseo de JSON.

Ejemplo de Parseo de JSON

Supongamos que recibimos el siguiente JSON:

{
    "name": "John Doe",
    "age": 30
}

Podemos definir una estructura para representarlo y usar JSONDecoder para parsearlo:

import Foundation

struct Person: Codable {
    let name: String
    let age: Int
}

let task = session.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Respuesta inválida")
        return
    }
    
    guard let data = data else {
        print("No se recibió datos")
        return
    }
    
    do {
        let person = try JSONDecoder().decode(Person.self, from: data)
        print("Nombre: \(person.name), Edad: \(person.age)")
    } catch {
        print("Error al parsear JSON: \(error.localizedDescription)")
    }
}

task.resume()

Explicación del Código

  • Definir la estructura: Person es una estructura que conforma el protocolo Codable.
  • Parsear los datos: Usamos JSONDecoder para convertir los datos JSON en una instancia de Person.

Ejemplo Práctico: Consumir una API REST

Vamos a crear una aplicación que consuma una API REST pública para obtener una lista de usuarios.

Paso 1: Definir la Estructura de Datos

struct User: Codable {
    let id: Int
    let name: String
    let username: String
    let email: String
}

Paso 2: Realizar la Solicitud

import Foundation

guard let url = URL(string: "https://jsonplaceholder.typicode.com/users") else {
    print("URL inválida")
    return
}

let request = URLRequest(url: url)
let session = URLSession.shared

let task = session.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Respuesta inválida")
        return
    }
    
    guard let data = data else {
        print("No se recibió datos")
        return
    }
    
    do {
        let users = try JSONDecoder().decode([User].self, from: data)
        for user in users {
            print("Nombre: \(user.name), Usuario: \(user.username), Email: \(user.email)")
        }
    } catch {
        print("Error al parsear JSON: \(error.localizedDescription)")
    }
}

task.resume()

Explicación del Código

  • Definir la estructura User: Representa a un usuario con propiedades que coinciden con el JSON.
  • Realizar la solicitud: Similar a los ejemplos anteriores, pero esta vez decodificamos una lista de usuarios.

Errores Comunes y Soluciones

Error: URL inválida

  • Solución: Asegúrate de que la URL esté correctamente formateada y sea válida.

Error: No se recibió datos

  • Solución: Verifica que el servidor esté respondiendo correctamente y que la URL sea correcta.

Error al parsear JSON

  • Solución: Asegúrate de que la estructura de datos en Swift coincida con el formato del JSON recibido.

Ejercicios Prácticos

Ejercicio 1: Realizar una Solicitud POST

Crea una función que realice una solicitud POST a una API y envíe datos en formato JSON.

Ejercicio 2: Manejar Errores de Red

Modifica el ejemplo práctico para manejar diferentes tipos de errores de red, como la falta de conexión a Internet.

Ejercicio 3: Parsear JSON Anidado

Crea una estructura Swift para parsear un JSON anidado y escribe una función que realice la solicitud y maneje la respuesta.

Conclusión

En esta sección, has aprendido cómo manejar la comunicación en red en Swift utilizando URLSession. Has visto cómo realizar solicitudes HTTP, manejar respuestas, y parsear JSON. Estos son conceptos fundamentales que te permitirán crear aplicaciones que interactúan con servicios web de manera eficiente. En el próximo módulo, profundizaremos en el uso de Core Data para el almacenamiento persistente de datos en tus aplicaciones.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados