El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Implementació

Següent ►
►

En aquesta secció, ens centrarem en la implementació del projecte final. Aquest és el moment en què posarem en pràctica tots els conceptes apresos al llarg del curs. La implementació es dividirà en diverses etapes per assegurar-nos que cada part del projecte es desenvolupi de manera organitzada i eficient.

  1. Estructura del Projecte

Abans de començar a escriure codi, és important definir l'estructura del projecte. Una bona organització facilita el manteniment i l'escalabilitat del codi.

Exemple d'Estructura de Projecte

/project
    /cmd
        /app
            main.go
    /pkg
        /handlers
            handlers.go
        /models
            models.go
        /db
            db.go
    /internal
        /config
            config.go
    /web
        /static
        /templates
    go.mod
    go.sum

Explicació de l'Estructura

  • /cmd/app: Conté el punt d'entrada de l'aplicació.
  • /pkg: Conté el codi reutilitzable, com ara els controladors, models i la configuració de la base de dades.
  • /internal: Conté el codi que no hauria de ser accessible des de fora del projecte.
  • /web: Conté els fitxers estàtics i les plantilles HTML.
  • go.mod i go.sum: Fitxers de gestió de dependències.

  1. Configuració Inicial

Fitxer main.go

El fitxer main.go és el punt d'entrada de l'aplicació. Aquí és on inicialitzarem la configuració, la connexió a la base de dades i els rutes del servidor web.

package main

import (
    "log"
    "net/http"
    "project/internal/config"
    "project/pkg/handlers"
)

func main() {
    // Carregar la configuració
    cfg, err := config.LoadConfig()
    if err != nil {
        log.Fatalf("Error carregant la configuració: %v", err)
    }

    // Inicialitzar el servidor
    mux := http.NewServeMux()
    mux.HandleFunc("/", handlers.Home)
    mux.HandleFunc("/about", handlers.About)

    // Iniciar el servidor
    log.Printf("Servidor escoltant a %s", cfg.ServerAddress)
    err = http.ListenAndServe(cfg.ServerAddress, mux)
    if err != nil {
        log.Fatalf("Error iniciant el servidor: %v", err)
    }
}

Fitxer config.go

El fitxer config.go conté la configuració de l'aplicació, com ara l'adreça del servidor i les credencials de la base de dades.

package config

import (
    "encoding/json"
    "os"
)

type Config struct {
    ServerAddress string `json:"server_address"`
    DBUser        string `json:"db_user"`
    DBPassword    string `json:"db_password"`
    DBName        string `json:"db_name"`
}

func LoadConfig() (*Config, error) {
    file, err := os.Open("config.json")
    if err != nil {
        return nil, err
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    config := &Config{}
    err = decoder.Decode(config)
    if err != nil {
        return nil, err
    }

    return config, nil
}

Fitxer config.json

Aquest fitxer conté la configuració en format JSON.

{
    "server_address": ":8080",
    "db_user": "root",
    "db_password": "password",
    "db_name": "project_db"
}

  1. Implementació de Funcionalitats

Controladors (Handlers)

Els controladors gestionen les sol·licituds HTTP i responen amb les dades adequades.

package handlers

import (
    "net/http"
    "html/template"
)

func Home(w http.ResponseWriter, r *http.Request) {
    tmpl, _ := template.ParseFiles("web/templates/home.html")
    tmpl.Execute(w, nil)
}

func About(w http.ResponseWriter, r *http.Request) {
    tmpl, _ := template.ParseFiles("web/templates/about.html")
    tmpl.Execute(w, nil)
}

Models

Els models representen les estructures de dades de l'aplicació.

package models

type User struct {
    ID       int
    Username string
    Email    string
}

Base de Dades

La configuració de la base de dades inclou la connexió i les operacions CRUD.

package db

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "project/internal/config"
)

func Connect(cfg *config.Config) (*sql.DB, error) {
    dsn := cfg.DBUser + ":" + cfg.DBPassword + "@/" + cfg.DBName
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        return nil, err
    }
    return db, nil
}

  1. Proves

És important provar cada part del codi per assegurar-nos que funciona correctament.

Exemple de Prova

package handlers

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestHome(t *testing.T) {
    req, err := http.NewRequest("GET", "/", nil)
    if err != nil {
        t.Fatal(err)
    }

    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(Home)

    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
    }
}

  1. Desplegament

Un cop implementades i provades totes les funcionalitats, és hora de desplegar l'aplicació.

Construcció de l'Aplicació

go build -o project cmd/app/main.go

Desplegament

El desplegament pot variar segons l'entorn. Aquí teniu un exemple de desplegament en un servidor Linux.

scp project user@server:/path/to/deploy
ssh user@server
cd /path/to/deploy
./project

Conclusió

En aquesta secció, hem cobert la implementació del projecte final, des de la configuració inicial fins al desplegament. Hem après a estructurar el projecte, configurar el servidor, implementar controladors i models, connectar-nos a la base de dades, provar el codi i desplegar l'aplicació. Amb aquests coneixements, estàs preparat per desenvolupar aplicacions completes en Go.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats