Help me met het opzetten van een REST API in Go
description
Met deze prompt krijg je duidelijke en praktische hulp bij het bouwen van een REST API in Go, wat je veel tijd bespaart en je helpt een solide basis te leggen voor je backend. Het behandelt niet alleen code, maar ook architectuur en best practices, waardoor je kwalitatief betere en onderhoudbare API's ontwikkelt.
prompt
Help me met het ontwerpen en implementeren van een REST API in Go. Beschrijf de structuur, benodigde ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een overzicht van hoe je een REST API in Go kunt ontwerpen en implementeren voor het beheren van persoonlijke taken en deadlines.
**1. Structuur van het project**
Een overzichtelijke structuur zou er als volgt uit kunnen zien:
```
task-api/
│
├── main.go // Startpunt van de applicatie
├── handlers/ // Bevat HTTP handlers
│ └── handlers.go
├── models/ // Data modellen
│ └── task.go
├── repository/ // Data opslag en toegang
│ └── repository.go
└── utils/ // Hulpfuncties (optioneel)
└── utils.go
```
**2. Benodigde packages**
- `net/http` voor HTTP-server en routing
- `github.com/gorilla/mux` voor eenvoudige routing
- `encoding/json` voor JSON verwerking
- (optioneel) `sync` voor gelijktijdigheid en data-beveiliging
- (optioneel) `log` voor logging
**3. Voorbeeld van een eenvoudige endpoint**
Hier is een basisvoorbeeld van het opzetten van een API met een endpoint om taken op te halen en toe te voegen.
**main.go**
```go
package main
import (
"log"
"net/http"
"github.com/gorilla/mux"
"task-api/handlers"
)
func main() {
r := mux.NewRouter()
// Endpoints
r.HandleFunc("/tasks", handlers.GetTasks).Methods("GET")
r.HandleFunc("/tasks", handlers.CreateTask).Methods("POST")
// Server starten
log.Println("Server gestart op :8080")
if err := http.ListenAndServe(":8080", r); err != nil {
log.Fatal(err)
}
}
```
**models/task.go**
```go
package models
import "time"
type Task struct {
ID string `json:"id"`
Titel string `json:"titel"`
Beschrijving string `json:"beschrijving"`
Deadline time.Time `json:"deadline"`
Voltooid bool `json:"voltooid"`
}
```
**handlers/handlers.go**
```go
package handlers
import (
"encoding/json"
"net/http"
"github.com/gorilla/mux"
"task-api/models"
"sync"
"time"
)
// In-memory opslag (voor demo)
var (
tasks = make([]models.Task, 0)
mu sync.Mutex
)
func GetTasks(w http.ResponseWriter, r *http.Request) {
mu.Lock()
defer mu.Unlock()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(tasks)
}
func CreateTask(w http.ResponseWriter, r *http.Request) {
var task models.Task
if err := json.NewDecoder(r.Body).Decode(&task); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
task.ID = generateID()
mu.Lock()
tasks = append(tasks, task)
mu.Unlock()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(task)
}
func generateID() string {
return time.Now().Format("20060102150405")
}
```
**4. Samenvatting**
- Gebruik `gorilla/mux` voor routing.
- Beheer taken in een slice met een mutex voor gelijktijdigheid.
- Eindpunten: `/tasks` GET voor ophalen en POST voor toevoegen.
- Data model: `Task` met velden zoals ID, titel, beschrijving, deadline en voltooid.
**5. Uitbreidingen**
- Verbinden met een database (bijv. SQLite, PostgreSQL)
- Authentication en autorisatie
- Validatie van input
- Geavanceerde routing en filtering
Als je verdere hulp nodig hebt bij bijvoorbeeld database integratie of meer endpoints, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Zeker! Ik help je met het ontwerpen en implementeren van een REST API in Go voor een takenbeheer applicatie.
## Projectstructuur
```
task-manager-api/
├── cmd/
│ └── main.go
├── internal/
│ ├── handlers/
│ │ └── task_handler.go
│ ├── models/
│ │ └── task.go
│ ├── storage/
│ │ └── memory_storage.go
│ └── middleware/
│ └── logging.go
├── pkg/
│ └── utils/
│ └── response.go
├── go.mod
└── go.sum
```
## Benodigde Packages
```bash
go mod init task-manager-api
go get github.com/gorilla/mux
go get github.com/rs/cors
```
## Code Implementatie
### 1. Model Definitie (`internal/models/task.go`)
```go
package models
import (
"time"
)
type Task struct {
ID string `json:"id"`
Title string `json:"title" validate:"required"`
Description string `json:"description"`
Completed bool `json:"completed"`
Deadline time.Time `json:"deadline"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type TaskRequest struct {
Title string `json:"title" validate:"required"`
Description string `json:"description"`
Deadline time.Time `json:"deadline"`
}
```
### 2. Storage Interface (`internal/storage/memory_storage.go`)
```go
package storage
import (
"sync"
"task-manager-api/internal/models"
"time"
)
type TaskStorage interface {
Create(task *models.Task) error
GetByID(id string) (*models.Task, error)
GetAll() ([]*models.Task, error)
Update(id string, task *models.Task) error
Delete(id string) error
}
type MemoryStorage struct {
tasks map[string]*models.Task
mutex sync.RWMutex
}
func NewMemoryStorage() *MemoryStorage {
return &MemoryStorage{
tasks: make(map[string]*models.Task),
}
}
func (s *MemoryStorage) Create(task *models.Task) error {
s.mutex.Lock()
defer s.mutex.Unlock()
task.ID = generateID()
task.CreatedAt = time.Now()
task.UpdatedAt = time.Now()
s.tasks[task.ID] = task
return nil
}
func (s *MemoryStorage) GetByID(id string) (*models.Task, error) {
s.mutex.RLock()
defer s.mutex.RUnlock()
task, exists := s.tasks[id]
if !exists {
return nil, ErrTaskNotFound
}
return task, nil
}
// Andere methoden implementeren...
```
### 3. Handler Implementatie (`internal/handlers/task_handler.go`)
```go
package handlers
import (
"encoding/json"
"net/http"
"task-manager-api/internal/models"
"task-manager-api/internal/storage"
"github.com/gorilla/mux"
)
type TaskHandler struct {
storage storage.TaskStorage
}
func NewTaskHandler(storage storage.TaskStorage) *TaskHandler {
return &TaskHandler{storage: storage}
}
// GET /api/tasks/{id}
func (h *TaskHandler) GetTask(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id := vars["id"]
task, err := h.storage.GetByID(id)
if err != nil {
http.Error(w, "Taak niet gevonden", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(task)
}
// POST /api/tasks
func (h *TaskHandler) CreateTask(w http.ResponseWriter, r *http.Request) {
var taskReq models.TaskRequest
if err := json.NewDecoder(r.Body).Decode(&taskReq); err != nil {
http.Error(w, "Ongeldige JSON", http.StatusBadRequest)
return
}
task := &models.Task{
Title: taskReq.Title,
Description: taskReq.Description,
Deadline: taskReq.Deadline,
Completed: false,
}
if err := h.storage.Create(task); err != nil {
http.Error(w, "Kon taak niet aanmaken", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(task)
}
// Andere endpoints: GetAllTasks, UpdateTask, DeleteTask
```
### 4. Main Application (`cmd/main.go`)
```go
package main
import (
"log"
"net/http"
"task-manager-api/internal/handlers"
"task-manager-api/internal/storage"
"github.com/gorilla/mux"
"github.com/rs/cors"
)
func main() {
// Initialize storage
taskStorage := storage.NewMemoryStorage()
// Initialize handlers
taskHandler := handlers.NewTaskHandler(taskStorage)
// Setup router
router := mux.NewRouter()
// API routes
api := router.PathPrefix("/api").Subrouter()
// Task routes
api.HandleFunc("/tasks", taskHandler.CreateTask).Methods("POST")
api.HandleFunc("/tasks", taskHandler.GetAllTasks).Methods("GET")
api.HandleFunc("/tasks/{id}", taskHandler.GetTask).Methods("GET")
api.HandleFunc("/tasks/{id}", taskHandler.UpdateTask).Methods("PUT")
api.HandleFunc("/tasks/{id}", taskHandler.DeleteTask).Methods("DELETE")
// CORS setup
c := cors.New(cors.Options{
AllowedOrigins: []string{"http://localhost:3000"},
AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowedHeaders: []string{"*"},
})
handler := c.Handler(router)
// Start server
log.Println("Server gestart op http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", handler))
}
```
## Voorbeeld Endpoint Gebruik
### GET /api/tasks/123
```bash
curl -X GET http://localhost:8080/api/tasks/123
```
Response:
```json
{
"id": "123",
"title": "Project afronden",
"description": "Laatste bugs fixen",
"completed": false,
"deadline": "2024-12-31T23:59:59Z",
"created_at": "2024-01-15T10:30:00Z",
"updated_at": "2024-01-15T10:30:00Z"
}
```
### POST /api/tasks
```bash
curl -X POST http://localhost:8080/api/tasks \
-H "Content-Type: application/json" \
-d '{
"title": "Nieuwe taak",
"description": "Dit is een beschrijving",
"deadline": "2024-12-31T23:59:59Z"
}'
```
## Volgende Stappen
1. Database integratie (bijv. PostgreSQL met pgx)
2. Validatie middleware toevoegen
3. Authenticatie implementeren
4. Testing toevoegen
5. Docker containerization
Deze structuur biedt een solide basis voor je takenbeheer API met propere scheiding van concerns en uitbreidingsmogelijkheden.