No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Manejando rutas en backend

30/42
Recursos

Aportes 23

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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!")
}

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

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")
}```

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

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 鈥渃lase鈥

Tengo problema con el comando 鈥済o run *鈥

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

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

que onda con los videos estan muy mal editados

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

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.

Si presentan este error al ejecutar su c贸digo en Windows:

go: go.mod file not found in current directory or any parent directory; see 'go help modules'

Solo deben ejecutar en consola:

go env -w GO111MODULE=auto

o

go env -w GO111MODULE=auto

Y ya con esto estar铆a corriendo su servidor.

Los que tengan problemas con el archivo router.go en la parte de la cracion del struct, dejenlo as铆:

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

Por mi parte para ejecutar los archivos parte del package main, me funciono 鈥済o 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
}

驴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

Se me presento un error en router.go 鈥淓l 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!")
}
>