No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Manejando rutas en backend

30/42
Recursos

Aportes 22

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

esta clase está mal editada… minuto 5:00 y minuto 5:40 basicamente repiten el video…

Este es el código, agregue algunas anotaciones, espero les sirvan

archivo main.go

package main

func main()  {
	server := NewServer(":3000")
	server.Listen()
}

archivo 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
	}
}

//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 parametro 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	 
}

archivo router.go

package main

import(
	"fmt"
	"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),
	}
}

//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) {

	//impresion de mensaje respuesta que el servidor da a la ruta
	//Fprintf es un escritor, que recive w que es el escritor asignado, y el mensaje que queremos mostrar 
	fmt.Fprintf(w, "Hello world!")
}

Si alguien tiene problemas en el Router.go, le comparto mi solución

package main

import (
	"fmt"
	"net/http"
)

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

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

func (r *Router) ServeHTTP(w http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(w, " Hello world")
}```

En el struct del router hay un error al declararlo

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

los elementos del struct no se utiliza : al declarar el tipo de dato, lo correcto es

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

elimine los : para que no errores de ejecución

Creo que debimos primero crear una http.HandlerFunc y luego modularizarla con router en un archivo diferente.

en un comienzo no entendí hasta que implemente una http.HandlerFunc sólita y hay si entendí.

http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(writer, "Hola Mundo web desde Gol")
})

lo que se hizo fue agruparlas en un slice

Tengo problema con el comando “go run *”

package : cannot find package "" in any of:
c:\go\src* (from $GOROOT)

Se podría hacer el análisis como si fuera POO donde el struct Server es una clase que tiene los atributos port y router y la función NewServer seria el constructor con la cual creamos una instancia de Server y la función Listen es un método de de dicha “clase”

Hola me sale el siguiente error cuando ejecuto go run * en la carpeta webServer
`ATHADL27895:webServer pilar.mass$ go run *

<h1>command-line-arguments</h1>

./router.go:9:8: http.HandleFunc is not a type`
a alguien mas le pasó ?

el router.go tiene que implementar todos los métodos que pide la interfaz que necesita handler.
Se entiende la idea pero se ve confuso.

Por mi parte para ejecutar los archivos parte del package main, me funciono “go run .”

Lastimosamente llegue hasta este punto, pero no puedo avanzar mas dado que no puedo ejecutar el comando go run * o go run . porque la ejecución se corta al instante

package main // Conoce todo lo de este paquete
import "net/http"

// Puerto del servidor
type Server struct {
	port string
	router *Router
}


// Instanciar servidor y escuchar conexciones
func NewServer(port string) *Server {
	return &Server{
		port: port,
		router: NewRouter(),
	}
}

func (s *Server) Listen() error {
	// Punto de entrada de la aplicacion
	http.Handle("/", s.router)


	// Seguno parametro es un handler
	err := http.ListenAndServe(s.port, nil)
	
	return err
}

Aquí es donde se me dificulta un poco, seguí al pie de la letra la clase, corrí el programa y todo funciona pero no entiendo muy bien lo que se hace, supongo lo comprenderé mejor cuando lo aplique a proyectos propios y leyendo documentación. Sigo adelante

¿Cuál es el objetivo de Router? No me queda claro.

Gracias de antemano.

nuestra ruta inical es “/” con http.Handle("/", s.router)

Hay que implementar todo aquello que esta en la interfases

el router cuando intersecta este mensaje lo va a escribir con l funcion fmt.Fprintf

con router es facil implemetar las rutas y con alto nivel de programacion ya que usamos struct y interfases

No entiendo porque me lo sigue marcando como erroneo, porque coma y quita la coma pero aun me dice que tengo un error de syntax,

package main

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

rules dentro de Router hacer referencia a las reglas de los endpoints que va a ser capaz de manejar.

http.Handle recibe 2 argumentos: un pattern string de la ruta a manejar; y una interfaz Handler.

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

type Router struct {}

http.Handle("/count", Router)

Para que el Router pueda considerarse Handler debe implementar el método ServeHTTP.

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	fmt.Fprintf(w, "Hello world")
}

fmt.Fprintf trabaja con un escritor, como es el caso de http.ResponseWriter.

Otra alternativa para hacer esto tenemos a http.Handlefunc() que recibe una función específica para manejar rutas.

func main() {
	h1 := func(w http.ResponseWriter, _ *http.Request) {
		io.WriteString(w, "Hello from a HandleFunc!\n")
	}

	http.HandleFunc("/", h1)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

Se me presento un error en router.go “El tipo de agente exportado debe tener un comentario o no ser exportado”

lo solucione poniendo un comentario en la parte superior siguiendo este formato, ejemplo: ** //Router …**
por si les pása.

<package main

import (
	"fmt"
	"net/http"
)

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

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

func (r *Router) ServeHTTP(w http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(w, "Hello Word!")
}
>

que onda con los videos estan muy mal editados