Creando el Servidor

Si tienes problemas en Windows para ejecutar:

go run *

reemplazalo por:

go run .

Si despues de esto tienes el siguiente detalle:
go: cannot find main module; see ‘go help modules’

ejecuta el siguiente comando:

go env -w GO111MODULE=off

Para los que sientan que el manejo de rutas es muy rustico, aca les dejo un ejemplo con Gorilla Mux:

<code>
package main

import (
	"fmt"
	"net/http"

	"github.com/gorilla/mux"
)

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

	router := mux.NewRouter()

	router.HandleFunc("/", login)

	server.Listen(router)
}

func login(w http.ResponseWriter, r *http.Request) {
	fmt.Println("New user are connected")
}

En sv.go lo unico que tenemos que cambiar principalmente es declarar a router como Handler en el ListenAndServe, lo hacemos de la siguiente manera:

<code>
package main

import (
	"net/http"
)

//Server is a struct of the server
type Server struct {
	port string
}

//NewServer is the function to create the server
func NewServer(port string) *Server {
	return &Server{
		port: port,
	}
}

//Listen is a function to start the http ListenAndServe
func (s *Server) Listen(r http.Handler) error {
	err := http.ListenAndServe(s.port, r)

	if err != nil {
		return err
	}
	return nil
}

Para poder utilizar gorilla mux solo tenemos que usar:

<code>
go get -u github.com/gorilla/mux

Si usas windows y tienes problemas con el comando go run * usa en su lugar go run .

Codigo creado con fasthttp, es un modulo que hace mas rapido el servidor

server.go

package main

import (
	"github.com/valyala/fasthttp"
)
type Server struct{
	port string

}

func NewServer(port string) *Server{
	return &Server{
		port:port,
	}
}

func(s *Server) Listen() error{
	err:=fasthttp.ListenAndServe(s.port,nil)
	//err:=http.ListenAndServe(":8080",nil)
	if err != nil{
		return err
	}
	return nil
}

.\main.go:4:12: undefined: NewServer

/:

Cuando pongo “go run *” en la consola me dice: :
cannot find package "" in any of:
c:\go\src* (from $GOROOT)
C:\Users\Administrador\go\src* (from $GOPATH)
¿Cuál puede ser el problema?

Deberían actualizar este curso, hay muchas instrucciones o comandos que están obsoletos.

El Profesor habla de handlers cuando crea la función para escuchar el puerto del servidor creado. Habla de “Handlers” y pensé o que no había prestado atención o que era un concepto que faltaba. Consultando encuentro que un Handler es un caso particular de interfaz que ha sido explicada adecuadamente en sesiones previas del curso. Encontré este artículo, donde se especifica qué es un Handler, Handle y HandleFunc, conceptos basados en interfaces.

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

// Puerto del servidor
type Server struct {
	port string
}


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

func (s *Server) Listen() error {
	// Seguno parametro es un handler
	err := http.ListenAndServe(s.port, nil)
	
	return err
}

esas funciones http de Go deben ser robustas para que no tengan problemas con levantar un servidor web de forma tan sencilla.

es muy facil de crear nuestro server web con golang con http

El tener todos los archivos separados pero dentro del mismo package permite que las estructuras y funciones puedan interactuar entre ellos, pero teniéndolas de una forma más ordenada.

// regresa un apuntador, es decir una dirección de memoria
func NewServer(port string) *Server {
	// & obtiene la dirección de memoria de la struct que se genera
	return &Server{
		port: port,
	}
}

func (s *Server) Listen) error {
	// este método recibe el puerto y un handler para las rutas
	err := http.ListenAndServe(s.port, nil)
	if err != nil {
		return err
	}
	//todo sale correctamente
	return nil
}

La ventaja de regresar un apuntador nos permite no estar pasando toda un copia de la estructura a través de las funciones.

El crean un servidor e iniciarlo se pueden hacer en el main, en este ejemplo se crean wrappers para abstraer dicha lógica.

Comúnmente se pasa nil como handler, usándose por defecto DefaultServeMux. En otro caso, podríamos pasar un middleware para encargarse.

excelente 😃

Tengo una pregunta, por qué aquí se retorna nil en vez de err? si en el if se evaluó que sea distinto de nil, eso quiere decir que err es nil no?

func (s *Server) listen() error {
	err := http.ListenAndServe(s.port, nil)

	if err != nil {
		return err
	}

	return nil
}