Tutorial de GoLang – Aplicación Web Parte 1

GCP-ICON.png

Marcar y Compartir
búsqueda del sitio bogotobogo.com:

Introducción

En este post, aprenderemos a hacer una aplicación sencilla. Esta tendrá varias partes y está basada en https://golang.org/doc/articles/wiki/.

Esto será un buen complemento a nuestros tutoriales básicos rápidos que hemos practicado hasta ahora.

Comenzando

Crearemos un nuevo directorio llamado gowiki en algún lugar bajo $GOTPAH:

$ echo $GOPATH~/go$ mkdir -p $GOPATH/src/github.com/einsteinish/go_tutorial/gowiki

Crea un archivo wiki.go como este:

initial_import.png

Estamos importando los paquetes fmt e ioutil de la biblioteca estándar de Go. Más adelante, a medida que implementemos funcionalidades adicionales, añadiremos más paquetes a esta declaración de importación.

Definiendo las estructuras de datos

Un wiki consiste en una serie de páginas, cada una de las cuales tiene un título y un cuerpo (el contenido de la página). Aquí, definimos Page como una estructura con dos campos que representan el título y el cuerpo.

type Page struct { Title string Body byte}

El tipo byte significa una porción de byte.

El elemento Body es un byte en lugar de una cadena porque ese es el tipo esperado por las bibliotecas io que utilizaremos.

La estructura Page describe cómo se almacenarán los datos de la página en la memoria. Pero, ¿qué pasa con el almacenamiento persistente? Podemos abordar eso creando un método save() en Page:

func (p *Page) save() error { filename := p.Title + ".txt" return ioutil.WriteFile(filename, p.Body, 0600)}

El método save() dice «Este es un método llamado save que toma como receptor p, un puntero a Page. No toma parámetros, y devuelve un valor de tipo error»

Note que el (p *Page) toma la siguiente sintaxis:

receiver_syntax.png

Este método guardará el cuerpo de la página en un archivo de texto. Para simplificar, usaremos el Título como nombre del archivo.

El método save devuelve un valor de error porque ese es el tipo de retorno de WriteFile (una función de la biblioteca estándar que escribe una porción de bytes en un archivo). El método save devuelve el valor de error, para permitir que la aplicación lo maneje en caso de que algo vaya mal mientras se escribe el archivo. Si todo va bien, Page.save() devolverá nil (el valor cero para punteros, interfaces y algunos otros tipos).

El entero octal literal 0600, pasado como tercer parámetro a WriteFile, indica que el archivo debe crearse con permisos de lectura y escritura sólo para el usuario actual.

Además de guardar páginas, también querremos cargar páginas:

func loadPage(title string) *Page { filename := title + ".txt" body, _ := ioutil.ReadFile(filename) return &Page{Title: title, Body: body}}

La función loadPage construye el nombre del archivo a partir del parámetro title, lee el contenido del archivo en una nueva variable body, y devuelve un puntero a un literal Page construido con los valores title y body adecuados.

Las funciones pueden devolver múltiples valores. La función de la biblioteca estándar io.ReadFile devuelve byte y error. En loadPage, el error no se maneja todavía; el «identificador en blanco» representado por el símbolo del guión bajo (_) se utiliza para tirar el valor de retorno del error (en esencia, asignando el valor a nada).

¿Pero qué pasa si ReadFile encuentra un error? Por ejemplo, el archivo podría no existir. No debemos ignorar estos errores. Modifiquemos la función para que devuelva *Page y error.

func loadPage(title string) (*Page, error) { filename := title + ".txt" body, err := ioutil.ReadFile(filename) if err != nil { return nil, err } return &Page{Title: title, Body: body}, nil}

Los que llamen a esta función pueden ahora comprobar el segundo parámetro; si es nil, entonces se ha cargado con éxito una Page. Si no, será un error que puede ser manejado por el llamador.

En este punto tenemos una estructura de datos simple y la capacidad de guardar y cargar desde un archivo. Escribamos una función principal para probar lo que hemos escrito:

func main() { p1 := &Page{Title: "TestPage", Body: byte("This is a sample Page.")} p1.save() p2, _ := loadPage("TestPage") fmt.Println(string(p2.Body))}

wiki-go-1.png

Después de compilar y ejecutar este código, se ha creado un archivo llamado TestPage.txt, que contiene el contenido de p1. El fichero se leerá en la estructura p2, y su elemento Body se imprimirá en la pantalla.

TestPage-text.png

paquete net/http

Comencemos con un servidor web sencillo, similar al que hicimos antes (Web):

Simple_Web_Code.png

La función principal comienza con una llamada a http.HandleFunc, que le dice al paquete http que maneje todas las peticiones a la raíz de la web («/») con handler.

Luego llama a http.ListenAndServe, especificando que debe escuchar en el puerto 8080 en cualquier interfaz («:8080»). (No te preocupes por su segundo parámetro, nil, por ahora.) Esta función se bloqueará hasta que el programa se termine.

ListenAndServe() siempre devuelve un error, ya que sólo vuelve cuando se produce un error inesperado. Para registrar ese error envolvemos la llamada a la función con log.Fatal. La función Fatal llama a os.Exit(1) después de escribir el mensaje de registro.

El manejador de la función es del tipo http.HandlerFunc. Toma un http.ResponseWriter y un http.Request como argumentos.

Un valor http.ResponseWriter ensambla la respuesta del servidor HTTP; al escribir en él, enviamos datos al cliente HTTP.

Un http.Request es una estructura de datos que representa la solicitud HTTP del cliente. r.URL.Path es el componente de ruta de la URL de la solicitud. El trailing significa «crear una subcorrida de Path desde el primer carácter hasta el final». Esto elimina la «/» inicial del nombre de la ruta.

Ejecuta este programa y accede a la URL:

HiThereIlove.png

Continúa con la Aplicación Web Parte 2 (Usando net/http).

  1. Tutorial de GoLang – HelloWorld
  2. Espacios de trabajo
  3. Código de Visual Studio
  4. Tipos de datos y variables
  5. byte y runa
  6. Paquetes
  7. Funciones
  8. . Arrays y rebanadas
  9. Una función que toma y devuelve una rebanada
  10. Condicionales
  11. Bucles
  12. Mapas
  13. Rango
  14. Punteros
  15. Cierres y funciones anónimas
  16. Estructuras y métodos receptores
  17. Receptores de valores o punteros
  18. Interfaces
  19. Aplicación Web Parte 0 (Introducción)
  20. Aplicación Web Parte 1 (Básica)
  21. Aplicación Web Parte 2 (Usando net/http)
  22. Aplicación Web Parte 3 (Añadiendo capacidad de «edición»)
  23. Aplicación Web Parte 4 (Manejando páginas noexistentes y guardando páginas)
  24. Aplicación Web Parte 5 (Manejo de errores y caché de plantillas)
  25. Aplicación Web Parte 6 (Validando el título con una expresión regular)
  26. Aplicación Web Parte 7 (Literales de función y cierres)
  27. Construyendo la imagen Docker y desplegando la aplicación Go a un clúster Kubernetes (minikube)
  28. Marco sin servidor (Modelo de aplicación sin servidor-SAM)
  29. API web sin servidor con AWS Lambda
  30. Arrays vs Slices con un ejemplo de rotación de arrays a la izquierda
  31. Funciones variadas
  32. Goroutines
  33. Canales (»
  34. Canales (»
  35. Canales (»
  36. Diferir
  37. Pánico y recuperación de GoLang
  38. Cadenas Formateo
  39. JSON
  40. SQLite
  41. Módulos 1 (Crear un nuevo módulo)
  42. Módulos 2 (Añadir dependencias)
  43. AWS SDK para Go (Listado S3)
  44. Lista enlazada
  45. Árbol de búsqueda binario (BST) Parte 1 (Estructuras de árbol/nodo con funciones de inserción e impresión)

Deja una respuesta

Tu dirección de correo electrónico no será publicada.