Asignando Rutas HTTP

Clase 33 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Daniel Alejandro Salazar Martinez

student•

Aqui el codigo actualizado

main.go

package main

func main()  {
	server := NewServer(":3000")

	//uso de la funcion handle con el path "/" y el handler
	server.Handle("/", HandleRoot)
	server.Handle("/api", HandleHome)
	server.Listen()
}

server.go

//el archivo main va a poder leer todo lo que este en el archivo server
package main

import (
	"net/http"
)

type Server struct{
	//puerto del servidor para escuchar las conexiones
	port string

	//se agrega el atributo router que es un apuntador al struct Router de router.go
	router *Router
}

//Funcion tipo global para ser leida en otros archivos
//Sirve para instanciar el servidor y que sea capaz de escuchar las conexiones
//recive el puerto que tiene que estar escuchando y devuelve el servidor como tal
func NewServer(port string) *Server {
	return &Server{
		port: port,

		//router instanciado
		router: NewRouter(),
		//con esto el servidor ya es capaz de instanciar el router y de tenerlo como propiedad
	}
}

//Handle es el nombre de la ruta por ejemplo "/api" asignado a un handler especifico
func (s *Server) Handle(path string, handler http.HandlerFunc){
	//Asociacion del handler con la ruta, es decir, el mapa con la llave path asignado al handler
	s.router.rules[path] = handler
	//asi el servidor es capaz de agregar la ruta especifica a un handler especifico
}


//Funcion tipo receiver, del struct Server, devuelve un error en caso de que haya problemas al conectar
func (s *Server) Listen() error{
	//el router va a ser el encargado de tomar las urls y procesarlas como se debe, crea el entry-point
	// los parametros son: el slash que es el punto de entrada, y el handler es el router recien creado
	http.Handle("/", s.router)
	
	//con la funcion listenanserve() del paquete http nos ayuda a escuchar todas las peticiones
	//colocas el puerto como primer parametro, el segundo es un handler 
	//pero nosotros haremos nuestros handlers por eso se coloca nil
	err := http.ListenAndServe(s.port, nil)

	if err != nil {
		return err
	}
	//si la ejecucion salio bien, retorna un valor nil
	return nil
	 
}

router.go

package main

import(
	
	"net/http"
)

//Struct router para hacer request en el servidor
type Router struct{
	//Reglas para definir de que rutas pasan a que handler, mapa que pasa de strings a handler
	//mapa que tenga como llaves strings y que mapee a HandlerFunc
	rules map[string]http.HandlerFunc

}

//forma de instanciar el router, similar al NewServer() del archivo servidor.go
func NewRouter() *Router {
	return &Router{
		//a diferencia del servidor, aqui el router debe empezar en un estado vacio, creamos un mapa vacio
		rules: make(map[string]http.HandlerFunc),
	}
}

//funcion que recibe el path que es un mapa y que devuelve dos valores:
//valor que devuelve y el valor booleano para saber si existe o no la llave dentro del mapa
func (r *Router) FindHandler(path string) (http.HandlerFunc, bool){
	//asignacion de el valor en el mapa de reglas a las variables handler y exist
	handler, exist := r.rules[path]
	return handler, exist
}



//Metodo ServeHTTP de router para poder implementar en el handler el atributo s.router en server.go
//parametros: el primero es el escritor, el segundo es el request en donde viene la informacion
//no olvidar colocar ServeHTTP con letras mayusculas
func (r *Router) ServeHTTP(w http.ResponseWriter, request *http.Request) {

	//manejo del mensaje de manera dinamica
	//r es la referencia al router y usar la funcion FindHandler
	//el FindHandler compara el request con el mapa de reglas para saber si existe o no.
	//los valores son asignados a las variables 'handler' y 'exist'
	handler, exist := r.FindHandler(request.URL.Path)

	//Evaluacion del booleano del handler para saber si existe o no, error 404
	if !exist{
		//WriteHeader es para indicar el status del request
		w.WriteHeader(http.StatusNotFound)
		//el return nos ayuda a romper la funcion si esto no existe el handler
		return 
	}
	//handler para enviar objeto w y request
	handler(w, request)


}

handlers.go

package main

import (
	"net/http"
	"fmt"
)


// Handler para manejar la ruta principal
//Parametros: escritor w del tipo http.ResponseWriter y objeto request
func HandleRoot(w http.ResponseWriter, r *http.Request)  {
	//Impresion en el navegador
	//parametros: escritor-objeto encargado de responder al cliente 
	//y mensaje escrito a travez del escritor
	fmt.Fprintf(w, "Hello World from handlers")
}

func HandleHome(w http.ResponseWriter, r *http.Request)  {
	fmt.Fprintf(w, "This is the API Endpoint")
}

Jhon Mauricio Garcia Galvis

student•

que hiciste que me funciono??

Pedro Andrés Chaparro Quintero

student•

Gracias por compartir! Había comentado el http.Handle("/", s.router) en el server.go y no me funcionaban las rutas.

William Rodriguez

student•

Esta fue mi implementación luego de entender como funciona HandleFunc hace lo mismo pero me parecio mas sencilla

Main:

func main() {
	RoutesLayout()
	log.Println(http.ListenAndServe(&quot;:5000&quot;, nil))
}

Routes:

func RoutesLayout() {
	http.HandleFunc(&quot;/&quot;, Index)
	http.HandleFunc(&quot;/home&quot;, Home)
}

Handlers:

func Index(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != &quot;/&quot; {
		page404(w, r)
		return
	}
	fmt.Fprint(w, &quot;Welcome to Index&quot;)
}

func Home(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, &quot;Welcome to Home&quot;)
}

func page404(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(404)
	fmt.Fprint(w, &quot;Web site not Found 404&quot;)
}

Luis Vides

student•

Creo que no estás respetando la arquitectura de la aplicación, cada archivo debe contener funciones definidas. en tu caso el archivo Handlers está verificando si una ruta existe o no y esa no tiene que ser su responsabilidad. En el archivo handler sólo deberían definirse funciones handlers. Lo mismo en main, estás levantando el servidor cuando eso debería ser responsabilidad del archivo server. Ahora te puede parecer más sencillo la implementación que planteaste, pero el software siempre crece y evoluciona, una "arquitectura" como la que estás presentando terminaría siendo un espagueti de código sin pies ni cabeza. Recordá que aquí también se enseñan buenas prácticas de programación y la creación de tantos archivos forma parte de esas buenas prácticas.

William Rodriguez

student•

En el handler (manejador la funcion es administrar las rutas) esta funcion esta bien ubicada acorde a la funcion de administrar las rutas.

ifr.URL.Path != "/" { page404(w, r) return }

Esta validacion remplaza medio proyecto al struct que valida las rutas si ya existen o no y todo el codigo que el profe elaboro cuando el paquete de http ya lo realiza.

El codigo que relacione es didactico hablar de arquitectura en este caso es como aplicar arquitectura de software al hola mundo.

pude separarlo en services y otras capas pero si copio y pero todos esos archivos en la caja de comentarios se ve horrible y no se entiende esto es didactico.

Pero si comparto contigo las buenas practicas y arquitecturas. Me hubiera gustado que en el curso usaran una arquitectura mas real y no tan didactica.

esta sola linea remplaza medio proyecto que creo el profe ...

Ademas se parece mas estructuras de frameworks como Gin y gorila Mux.

Paolo Donato Torregrosa Navarro

student•

Hola, se que algunos se pueden estar preguntando si existe una forma mas rápida de hacer todo esto y simplemente sentarse a escribir las rutas del server, y la respuesta es si :3 el paquete de go que se encarga de todo esto se instala de esta forma go get -u github.com/gorilla/mux

Avelino Sánchez

student•

También se puede lograr sencillamente con la librería estándar sin todo esto. Solo que aquí hace el ejemplo de como funciona todo y usar wrappers para ordenar el código.

http.HandleFunc(&quot;/index&quot;, handleIndex())

Incluso con mux podríamos varios de estos wrappers porque también solo sería el router. La ventaja está en que mux ya tiene implementadas funcionalidades para manejar las URLs más fácilmente que la stdlib.

Kevin Picon

student•

Hola, podrias explicarme un poco mas como funciona el gorilla mux? ya que trate de usarlo y no pude

Henrry Bourgeot

student•

Néstor, me encantó esta forma de manejar los endpoints en Go, yo tenía otro modo de realizarlos, pero siendo honesto esta forma en que lo implementaste está muy bien estructurada, la usaré ahora en mis proyectos de Go

Avelino Sánchez

student•

http.HandlerFunc es diferente de http.HandleFunc.

http.HandlerFunc es un type func significa que es una definición de una función. La diferencia radica en que es una signature específica y asociada a un tipo de función: las que reciben un (writer, request) y no tiene una implementación.

http.HandleFunc() puede definir un path directamente a una función, con mayor facilidad. Sin embargo, la forma completa de hacerlo y utilizar ServeHTTP, sirve para agregar procesos intermedios, middleware o nuestro propio router (como es el ejemplo).

Mikel Aranda

student•

Cómo puedo asignar paths anidadas con su propio router? Por ejemplo que todas las paths con /api/ sean manejadas por un router y /web/ sea manejado por otro?

Victor Inojosa

student•

Tengo este error y no se como solucionarlo. Me ayudan?

cannot use HandleRoot (type func(http.ResponseWriter, http.Request)) as type http.HandlerFunc in argument to server.Handle

Andres Camilo Bobadilla Parra

student•

Seguramente le falto agregarle al segundo parametro el asterisco. deeberia quedar así la función:

func HandleRoot(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello World") }

Victor Inojosa

student•

Tengo este error y no se como solucionarlo. Me ayudan?

cannot use HandleRoot (type func(http.ResponseWriter, http.Request)) as type http.HandlerFunc in argument to server.Handle

victor rodriguez

student•

si se explicaran las cosas dentro del codigo todo quedaria realmente claro. OK

Daniel G Perico Sánchez

student•

Cuando intento ingresar a una dirección que no está mapeada dentro de las direcciones posibles no pasa nada. Tengo entendido que el w.WriteHeader(http.StatusNotFound) debería encargarse de mostrar algo pero parece que este no es el caso. ¿es normal?

Tony Barquera

student•

Me paso lo mismo usando Firefox, pero si revisamos la consola al momento de ingresar una dirección no valida, podemos ver que ahí si aparece que se dio el 404 Not Found por lo que si se esta recibiendo el resultado, solo que el navegador no muestra una pantalla en la que indica que algo esta mal, lo probé de igual manera con Google Chrome y en este si aparece en pantalla el 404, así que puede ser cuestión simplemente del navegador como se visualiza.

Carlos Nassif Trejo Garcia

student•

package main

import (
	"net/http"
)

type Router struct {
	rules map[string]http.HandlerFunc
}

func NewRouter() *Router {
	return &Router{
		rules: make(map[string]http.HandlerFunc),
	}
}

func (r *Router) FindHandler(path string) (http.HandlerFunc, bool) {
	handler, exist := r.rules[path]
	return handler, exist
}

func (r *Router) ServeHTTP(w http.ResponseWriter, request *http.Request) {
	handler, exists := r.FindHandler(request.URL.Path)

	if !exists {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	handler(w, request)
}

Asignando Rutas HTTP

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos