Server REST Simplu pentru Gestionarea Notițelor Text în Go

Server REST simplu în Go pentru gestionarea notițelor text cu operații CRUD, folosind net/http și stocare în memorie, ideal pentru prototipuri rapide.

Introducere scurtă

Server REST Simplu pentru Gestionarea Notițelor Text în Go (go)
DESCRIERE:
Un server RESTful scris în Go care permite crearea, citirea, actualizarea și ștergerea notițelor text. Utilizează pachetul standard net/http și o structură de date în memorie pentru gestionarea notițelor.

NOTE SUPLIMENTARE:
Serverul păstrează notițele doar în memorie, deci datele se pierd la repornire. Pentru utilizare reală ar trebui integrată o bază de date. Codul este gata de utilizare și ușor extensibil.

EXPLICAȚII:
- Structura Note reprezintă o singură notiță cu ID, Titlu și Conținut.
- Harta notes stochează toate notițele în memorie, indexate după ID.
- Handler-ele HTTP gestionează cererile REST și răspund în JSON.
- Middleware-ul loggingHandler afișează în consolă fiecare cerere primită.
- Funcția main configurează router-ul, middleware-ul și pornește serverul pe portul configurat.

Cod Exemplu: go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"sync"
)

// Note reprezintă o singură notiță text
// cu ID unic, Titlu și Conținut.
type Note struct {
	ID      int    `json:"id"`
	Titolo  string `json:"titolo"`
	Contenuto string `json:"contenuto"`
}

// notes stochează toate notițele în memorie
// protejat de mutex pentru acces concurent.
var (
	notes = make(map[int]Note)
	mu    sync.Mutex
	idSeq = 1 // secvență pentru generarea ID-urilor unice
)

// loggingHandler este un middleware care loghează fiecare cerere HTTP.
func loggingHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s %s", r.RemoteAddr, r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

// getNotesHandler returnează lista tuturor notițelor în JSON.
func getNotesHandler(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	defer mu.Unlock()

	var lista []Note
	for _, note := range notes {
		lista = append(lista, note)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(lista)
}

// getNoteHandler returnează o singură notiță după ID.
func getNoteHandler(w http.ResponseWriter, r *http.Request) {
	id, err := estraiID(r.URL.Path)
	if err != nil {
		http.Error(w, "ID invalid", http.StatusBadRequest)
		return
	}

	mu.Lock()
	note, ok := notes[id]
	mu.Unlock()

	if !ok {
		http.Error(w, "Notiță negăsită", http.StatusNotFound)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(note)
}

// createNoteHandler creează o notiță nouă din JSON trimis în corp.
func createNoteHandler(w http.ResponseWriter, r *http.Request) {
	var n Note
	err := json.NewDecoder(r.Body).Decode(&n)
	if err != nil {
		http.Error(w, "JSON invalid", http.StatusBadRequest)
		return
	}

	mu.Lock()
	n.ID = idSeq
	idSeq++
	notes[n.ID] = n
	mu.Unlock()

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(n)
}

// updateNoteHandler actualizează o notiță existentă după ID.
func updateNoteHandler(w http.ResponseWriter, r *http.Request) {
	id, err := estraiID(r.URL.Path)
	if err != nil {
		http.Error(w, "ID invalid", http.StatusBadRequest)
		return
	}

	var n Note
	err = json.NewDecoder(r.Body).Decode(&n)
	if err != nil {
		http.Error(w, "JSON invalid", http.StatusBadRequest)
		return
	}

	mu.Lock()
	_, ok := notes[id]
	if !ok {
		mu.Unlock()
		http.Error(w, "Notiță negăsită", http.StatusNotFound)
		return
	}

	n.ID = id
	notes[id] = n
	mu.Unlock()

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(n)
}

// deleteNoteHandler șterge o notiță după ID.
func deleteNoteHandler(w http.ResponseWriter, r *http.Request) {
	id, err := estraiID(r.URL.Path)
	if err != nil {
		http.Error(w, "ID invalid", http.StatusBadRequest)
		return
	}

	mu.Lock()
	_, ok := notes[id]
	if !ok {
		mu.Unlock()
		http.Error(w, "Notiță negăsită", http.StatusNotFound)
		return
	}
	delete(notes, id)
	mu.Unlock()

	w.WriteHeader(http.StatusNoContent) // 204 No Content
}

// estraiID extrage ID-ul numeric din URL, așteptând /notes/{id}
func estraiID(path string) (int, error) {
	parti := strings.Split(strings.Trim(path, "/"), "/")
	if len(parti) < 2 {
		return 0, fmt.Errorf("cale invalidă")
	}
	return strconv.Atoi(parti[1])
}

func main() {
	mux := http.NewServeMux()

	// Rute REST pentru notițe
	mux.HandleFunc("/notes", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			getNotesHandler(w, r)
		case http.MethodPost:
			createNoteHandler(w, r)
		default:
			http.Error(w, "Metodă nesuportată", http.StatusMethodNotAllowed)
		}
	})

	mux.HandleFunc("/notes/", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			getNoteHandler(w, r)
		case http.MethodPut:
			updateNoteHandler(w, r)
		case http.MethodDelete:
			deleteNoteHandler(w, r)
		default:
			http.Error(w, "Metodă nesuportată", http.StatusMethodNotAllowed)
		}
	})

	// Pornire server cu middleware de logging
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("Server pornit pe portul %s", port)
	err := http.ListenAndServe(":"+port, loggingHandler(mux))
	if err != nil {
		log.Fatalf("Eroare la pornirea serverului: %v", err)
	}
}
×
×
×
Vrei să regenerezi răspunsul?
×
Exportă chatul
Alege formatul de export
Generazione PDF in corso…
Allegati
×
Ești pe cale să închizi chatul și să treci la generatorul de imagini. Dacă nu ești autentificat, vei pierde chatul nostru. Confirmi?
Vizualizezi un chat distribuit în mod temporar. Nu va fi salvat.
×
Prompturi salvate
×
Notă privată
×
Etichetă
×
Caută în toate chaturile
×
Insight-urile tale
Se analizează…
×
Preferințe AI
Numele asistentului 30
Lungimea răspunsurilor
Model IA
Răspunsuri structurate
Include exemple
Folosește emoji
Ghidează-mă, nu rezolva Indicii și întrebări în loc de soluția gata făcută
Mai multe setări →
×
Distribuie acest chat
Cine deschide acest link va putea vedea chatul sau îl va putea adăuga în profilul său ca chat propriu.
Atenție: vor fi partajate și atașamentele chatului. Cine îl adaugă va primi o copie a fișierelor în propriul folder.
Chat distribuit
Cineva a distribuit un chat cu tine. Vrei doar să îl vezi sau să îl adaugi la chaturile tale?
Atenție: vor fi partajate și atașamentele chatului. Cine îl adaugă va primi o copie a fișierelor în propriul folder.
×

Mesaje salvate

Se încarcă...

×

Istoricul Chatului

programe-exemplu · ISTORIC CHAT

Se încarcă...

Preferințe AI

×
  • BasicRăspunsuri rapide și esențiale pentru studiu
  • MediuCalitate superioară pentru studiu și programare
  • AvansatRaționament complex și analize detaliate
Explică Pașii

Ce este necesar?

Go 1.18+ instalat

Pachetul standard net/http pentru serverul HTTP

Pachetul encoding/json pentru serializarea JSON

Structură de date în memorie (map) pentru stocarea notițelor

Endpoint-uri REST: GET /notes, GET /notes/{id}, POST /notes, PUT /notes/{id}, DELETE /notes/{id}

Middleware simplu pentru logarea cererilor

Configurare: portul serverului configurabil prin variabila de mediu PORT (implicit 8080)

Fără dependențe externe, doar biblioteca standard Go

Nu este necesar Arduino sau hardware extern pentru acest exemplu

Subiecte similare

Generator Simplu de Parole în Go (lungime fixă)
Generator simplu de parole în Go care creează parole aleatorii de lungime fixă folosind litere mici, mari și cifre pentru securitate rapidă și eficientă.
Validator Simplu de Email din Terminal în Go
Validator simplu de email în Go care verifică sintaxa adresei din terminal folosind expresii regulate pentru validare rapidă și sigură a email-urilor.
Downloader Simplu de Fișiere HTTP în Go
Program simplu în Go pentru descărcarea fișierelor HTTP cu gestionare erori și salvare locală. Ideal pentru învățarea cererilor HTTP și manipularea fișierelor.
CLI pentru Lansarea Comenzilor Simple de Sistem în Go
Program CLI simplu în Go pentru executarea comenzilor de sistem cu argumente opționale, afișând ieșirea și gestionând erorile eficient în terminal.
CLI pentru Redenumirea în Bloc a Fișierelor dintr-un Folder cu Go
CLI în Go pentru redenumirea în bloc a fișierelor dintr-un folder, cu prefix, sufix și index, gestionând erori și fără interfață grafică.
Instrument CLI pentru Compararea a Două Fișiere Text (diff simplificat) în Go
Instrument CLI simplu în Go pentru compararea a două fișiere text linie cu linie, afișând diferențele cu prefixe clare și gestionare robustă a erorilor.
Server HTTP Static pentru Servirea unui Folder Local în Go
Server HTTP static în Go pentru servirea fișierelor dintr-un folder local, ideal pentru dezvoltare și testare conținut static pe portul 88.
CLI pentru Gestionarea unei Liste de Cumpărături Salvate în Fișier în Go
Aplicație CLI în Go pentru gestionarea listei de cumpărături salvate în fișier JSON, cu comenzi simple pentru adăugare, eliminare, vizualizare și ștergere.