Go es un lenguaje de programación de código abierto desarrollado en Google y diseñado para ayudar a construir sistemas de software simples y confiables. El punto fuerte de Go es sus mecanismos de concurrencia que hacen que sea más sencillo escribir software, explotar arquitecturas de múltiples núcleos..

Es un lenguaje compilado, tipificado estáticamente, concurrente y recolectado de basura..

Es un lenguaje moderno muy interesante debido a algunas de las elecciones que se han hecho durante su diseño. Por ejemplo, el Sistema de tipos, aunque Go tiene métodos y también un estilo de programación OO, no existe una jerarquía de tipos. La única forma de conseguirlo es a través de interfaces..

Cómo difiere de los demás

Se debe leer la especificación del idioma para comprender mejor los elementos de diseño del lenguaje. Es realmente conciso y ayuda a resaltar algunos detalles realmente interesantes. La forma en que Go difiere de otros lenguajes de programación típicos, es que tiene características a diferencia de otros lenguajes OO:

• Sin herencia de tipo
• Sin sobrecarga de métodos y operadores.
• Construido en primitivas de concurrencia, que realmente lo hacen destacar entre la multitud. Comparte la memoria comunicándose y no al revés..
• Una cadena de herramientas que utiliza un modelo tradicional de compilación y enlace para generar binarios sin dependencias externas.
• Los mapas estan construidos en.

Organización del código

El código Go se mantiene bajo los espacios de trabajo. Es solo una jerarquía de directorios, como sigue:

• src - contiene archivos fuente de Go como paquetes
• pkg - contiene objetos de paquete
• compartimiento - contiene ejecutables

La herramienta Ir crea los paquetes de origen e instala los binarios resultantes en compartimiento y pkg directorios.

Una aplicación web simple utilizando Go

Construyamos un sitio estático y luego continuemos para mejorarlo de modo que se comporte de forma mucho más dinámica, en función de la entrada del usuario..

El sitio estático

La estructura de código para el sitio estático se ve así:

Por lo tanto, básicamente querrá crear una estructura similar a la imagen anterior o como se muestra en el repositorio. Esta estructura de repositorio residiría bajo el espacio de trabajo . Lea sobre la estructura del código Go para más información.

Ahora lo que queremos hacer es servir un archivo HTML que reside en el directorio público.

los index.html Los contenidos son los siguientes:

       
Desarrollar un sitio web usando Go
 
Soy una página estática, siendo servida con la ayuda de Go lang..
   

Y aquí está el programa Go para servir archivos estáticamente desde la carpeta pública:

paquete main import ("net / http") func main () fs: = http.FileServer (http.Dir ("public")) http.ListenAndServe (": 8080", fs)

Permítame explicarle:

• net / http - este paquete proporciona implementaciones de servidor y cliente HTTP.
• FileServer: esta función devuelve un controlador que sirve solicitudes HTTP con el contenido del sistema de archivos..

Eso es. Realmente simple y al punto. Puede ejecutar el código utilizando lo siguiente: ve corre gostatic.go.

Una mejor solucion

Sin embargo, esta solución no separa claramente las preocupaciones de enrutamiento y servicio y, por lo tanto, una mejor solución sería la siguiente:

paquete main import ("net / http" "log") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle ("/", fs) log.Println ("Listening ... ") err: = http.ListenAndServe (": 8080 ", nil) if err! = Nil log.Fatal (" ListenAndServe: ", err) 

Escuchar y guardar inicia un servidor HTTP en la dirección TCP dada y luego llama a Servir con un controlador. Este controlador suele ser nulo, por lo que el enrutador predeterminado (en el caso de Go, el DefaultServerMux puede hacerse cargo de).

Ahora en lo que respecta a DefaultServeMux - Tomemos un breve desvío para comprender cómo Go realiza el procesamiento HTTP. Lo hace con la ayuda de dos cosas primarias..

• ServerMuxes - (Enrutador) Es un multiplexor, esencialmente un enrutador HTTP, que compara las solicitudes entrantes con la lista definida y luego llama al controlador asociado..
• Manipuladores - Estos son responsables de "manejar" la solicitud, como responder con los encabezados apropiados, cuerpo, etc. Cualquier objeto que obedezca la interfaz del Controlador puede actuar como uno.

Continúe y ejecute la aplicación web de muestra como se hizo anteriormente y debería ver el resultado!

Sitios dinámicos - Agregar una marca de tiempo en cada actualización

A continuación, escribamos la aplicación para que imprima la hora actual, lo que implica que en cada actualización obtendrá un resultado diferente. El código Go se vería así:

paquete main import ("fmt" "net / http" "time") func main () http.HandleFunc ("/", handler) log.Println ("listening ...") err: = http.ListenAndServe (": 8080 ", nil) if err! = nil panic (err) func handler (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Hola. El tiempo es: "+ time.Now ( ) .Formato (tiempo.RFC850)) 

Aquí hemos importado. fmt Para trabajar con algunas funciones de impresión. El fmt implementa funciones de E / S formateadas a lo largo de las líneas de C stdio biblioteca.

También hemos hecho uso de HandleFunc que registra la ruta URL con la función de controlador en el DefaultServeMux. El controlador de funciones es del tipo http.HandlerFunc. Se necesita un http.ResponseWriter y http.Request como sus argumentos. Las personas familiarizadas con los servlets de Java recordarán haber hecho esto.!

Para imprimir el tiempo, importamos el "tiempo" del paquete estándar y lo usamos para responder al objeto del escritor de respuestas. Escribiendo a http.ResponseWriter Objeto podemos enviar la respuesta al cliente..

http.Request Es la estructura que representa la solicitud HTTP y, por lo tanto, tiene todos los datos de la solicitud. Para acceder a la ruta URL hacemos r.URL.path.

Cuando ejecutas esto y luego accede localhost: 8080 Debería ver la hora actual en cada actualización.

Aceptar entrada de usuario

Ahora vamos a escribir una aplicación que acepta una nombre de usuario en la página de índice y luego, cuando se envía el formulario, saluda al usuario en la página siguiente.

Aquí está nuestra estructura de código Go:

Primero creamos un archivo HTML que contiene el formulario dentro del directorio público.

       
Go Greeter
 
   
   

Este formulario, al enviar, se redireccionará a /saludar. Escribamos también los contenidos de la greet.html archivo dentro del directorio público, que presentaríamos cuando la solicitud llega a /saludar.

       
Hola .
   

El código Go es el siguiente:

paquete main import ("log" "net / http" "html / template") func main () http.HandleFunc ("/", root) http.HandleFunc ("/ greet", greeter) log.Println ("Listening ... ") err: = http.ListenAndServe (": 8080 ", nil) if err! = Nil log.Fatal (" ListenAndServe: ", err) func root (w http.ResponseWriter, r * http.Request) t, _: = template.ParseFiles ("public / index.html") t.Execute (w, nil) func greeter (w http.ResponseWriter, r * http.Request) username: = r.FormValue (" username ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.Execute (w, username) si err! = nil http.Error (w, err.Error (), http .StatusInternalServerError) 

Hemos utilizado html / plantilla para mantener el código HTML en las plantillas y luego usarlas para renderizar, a petición.

Hay una mirada curiosa. . en el greeter.html expediente. los html / plantilla el paquete asume que el texto plano siempre se produce. Agrega escapes donde sea necesario para incrustar de forma segura esa cadena simple en el contexto correcto. Cuando un valor de datos no es texto sin formato, podemos asegurarnos de que no se escape especificando su tipo. Tan esencialmente, Oye, .! puede ser invocado usando tmpl.Execute (out, HTML ('Nishant')) para producir Oye, Nishant!. Adelante, inténtalo!

Como la aplicación básica ahora está funcionando, finalmente podemos implementarla en Heroku.

Desplegando a Heroku

Una vez que tengas la heroku-toolbelt correctamente configurados y el repositorio administrado a través de Git, podemos implementarlo en estas líneas.

El único cambio que deberíamos hacer en el código para implementarlo en Heroku es cambiar la línea en la que escucha en un puerto específico.

Cambio:

 http.ListenAndServe (": 8080", ...) 

a:

http.ListenAndServe (":" + os.Getenv ("PORT"), ... .

Heroku Setup

Para poder implementarlo en Heroku, necesitará una cuenta de usuario de Heroku. También necesitarás un cliente de línea de comandos de Heroku. Consíguelo instalando el Heroku Toolbelt si no está ya.

Una vez instalado, inicie sesión usando la cuenta Heroku diciendo inicio de sesión de heroku, y luego subir su clave SSH. Con estas cosas en su lugar, debería estar listo para desplegarse en Heroku.

Despliegue de la aplicación

Para poder implementarlo en Heroku, necesitamos que la aplicación se almacene en Git..

git init. git añadir -A. git commit -m 'primera aplicación heroku go' 

También necesitaremos un Procfile para decirle a Heroku que el comando que necesita para ejecutar el proceso web es nuestra aplicación..

echo 'web: gogreeter'> Procfile

Las dependencias del paquete Go se gestionan en Heroku con la ayuda de Godep paquetes.

Instala Godep y guarda tus dependencias usando lo siguiente:

ve y obtén github.com/kr/godep godep save 

Agrega estos nuevos archivos a Git:

git añadir -A. git commit -m 'godep' 

Finalmente, crea la aplicación Heroku. Se puede hacer así:

heroku create -b https://github.com/kr/heroku-buildpack-go.git 

Esto debería crear un control remoto Git en su repositorio con el nombre de Heroku. ¡Ya está listo para desplegar! Ejecuta lo siguiente:

git push heroku master

Una vez que se complete el comando anterior, su aplicación debería estar en funcionamiento!

Ve a visitar la URL diciendo Heroku abierto o visitando directamente la URL de la aplicación que ves en la consola.

Eso es. Ahora tienes una aplicación Go en funcionamiento en Heroku!

Resumen

En este tutorial aprendimos lo fácil que es desarrollar una aplicación web Go y también implementarla en Heroku. En estos días, el desarrollo web depende en gran medida de los marcos que uno utiliza. Para explorar algunas de estas opciones, definitivamente debería revisar algunos de estos proyectos.

• Hugo
• martini
• Jaranear
• Kit de herramientas web de gorila
• Hastie - Generador de sitio estático en Go