Heim > Artikel > Backend-Entwicklung > Golang RESTful API mit Gin, Gorm, PostgreSQL
Umfassendes Beispiel eines Golang RESTful API-Dienstes, der Gin für das Routing, Gorm für ORM und PostgreSQL als Datenbank verwendet. Dieses Beispiel umfasst die folgenden PostgreSQL-Funktionen: Datenbank- und Tabellenerstellung, Dateneinfügung und -abfrage, Indizierung, Funktionen und gespeicherte Prozeduren, Trigger, Ansichten, CTEs, Transaktionen, Einschränkungen und JSON-Verarbeitung.
Angenommen, Sie haben PostgreSQL, Golang und Go-Mod eingerichtet, initialisieren Sie das Projekt:
mkdir library-api cd library-api go mod init library-api
Projektstruktur
/library-api |-- db.sql |-- main.go |-- go.mod
Installieren Sie die erforderlichen Pakete:
go get github.com/gin-gonic/gin go get gorm.io/gorm go get gorm.io/driver/postgres
Hier ist ein SQL-Skript zum Erstellen des Datenbankschemas:
-- Create the library database. CREATE DATABASE library; -- Connect to the library database. \c library; -- Create tables. CREATE TABLE authors ( id SERIAL PRIMARY KEY, name VARCHAR(100) NOT NULL UNIQUE, bio TEXT ); CREATE TABLE books ( id SERIAL PRIMARY KEY, title VARCHAR(200) NOT NULL, -- This creates a foreign key constraint: -- It establishes a relationship between author_id in the books table and the id column in the authors table, ensuring that each author_id corresponds to an existing id in the authors table. -- ON DELETE CASCADE: This means that if an author is deleted from the authors table, all related records in the books table (i.e., books written by that author) will automatically be deleted as well. author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE, published_date DATE NOT NULL, description TEXT, details JSONB ); CREATE TABLE users ( id SERIAL PRIMARY KEY, name VARCHAR(100) NOT NULL, email VARCHAR(100) UNIQUE NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- CREATE TABLE borrow_logs ( -- id SERIAL PRIMARY KEY, -- user_id INTEGER REFERENCES users(id), -- book_id INTEGER REFERENCES books(id), -- borrowed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- returned_at TIMESTAMP -- ); -- Create a partitioned table for borrow logs based on year. -- The borrow_logs table is partitioned by year using PARTITION BY RANGE (borrowed_at). CREATE TABLE borrow_logs ( id SERIAL PRIMARY KEY, user_id INTEGER REFERENCES users(id), book_id INTEGER REFERENCES books(id), borrowed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, returned_at TIMESTAMP ) PARTITION BY RANGE (borrowed_at); -- Create partitions for each year. -- Automatic Routing: PostgreSQL automatically directs INSERT operations to the appropriate partition (borrow_logs_2023 or borrow_logs_2024) based on the borrowed_at date. CREATE TABLE borrow_logs_2023 PARTITION OF borrow_logs FOR VALUES FROM ('2023-01-01') TO ('2024-01-01'); CREATE TABLE borrow_logs_2024 PARTITION OF borrow_logs FOR VALUES FROM ('2024-01-01') TO ('2025-01-01'); -- Benefit: This helps in improving query performance and managing large datasets by ensuring that data for each year is stored separately. -- Indexes for faster searching. CREATE INDEX idx_books_published_date ON books (published_date); CREATE INDEX idx_books_details ON books USING GIN (details); -- GIN Index (Generalized Inverted Index). It is particularly useful for indexing columns with complex data types like arrays, JSONB, or text search fields -- Add a full-text index to the title and description of books CREATE INDEX book_text_idx ON books USING GIN (to_tsvector('english', title || ' ' || description)); -- to_tsvector('english', ...) converts the concatenated title and description fields into a Text Search Vector (tsv) suitable for full-text searching. -- The || operator concatenates the title and description fields, so both fields are indexed together for searching. -- 'english' specifies the language dictionary, which helps with stemming and stop-word filtering. -- Create a simple view for books with author information. CREATE VIEW book_author_view AS SELECT books.id AS book_id, books.title, authors.name AS author_name FROM books JOIN authors ON books.author_id = authors.id; -- Create a view to get user borrow history CREATE VIEW user_borrow_history AS SELECT u.id AS user_id, u.name AS user_name, b.title AS book_title, bl.borrowed_at, bl.returned_at FROM users u JOIN borrow_logs bl ON u.id = bl.user_id JOIN books b ON bl.book_id = b.id; -- Use a CTE to get all active borrow logs (not yet returned) WITH active_borrows AS ( SELECT * FROM borrow_logs WHERE returned_at IS NULL ) SELECT * FROM active_borrows; -- Function to calculate the number of books borrowed by a user. -- Creates a function that takes an INT parameter user_id and returns an INT value. If the function already exists, it will replace it. CREATE OR REPLACE FUNCTION get_borrow_count(user_id INT) RETURNS INT AS $$ -- is a placeholder for the first input. When the function is executed, PostgreSQL replaces with the actual user_id value that is passed in by the caller. SELECT COUNT(*) FROM borrow_logs WHERE user_id = ; $$ LANGUAGE SQL; -- AS $$ ... $$: This defines the body of the function between the dollar signs ($$). -- LANGUAGE SQL: Specifies that the function is written in SQL. -- Trigger to log activities. CREATE TABLE activity_logs ( id SERIAL PRIMARY KEY, description TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE OR REPLACE FUNCTION log_activity() RETURNS TRIGGER AS $$ BEGIN INSERT INTO activity_logs (description) -- NEW refers to the new row being inserted or modified by the triggering event. VALUES ('A borrow_log entry has been added with ID ' || NEW.id); -- The function returns NEW, which means that the new data will be used as it is after the trigger action. RETURN NEW; END; $$ LANGUAGE plpgsql; -- It uses plpgsql, which is a procedural language in PostgreSQL CREATE TRIGGER log_borrow_activity AFTER INSERT ON borrow_logs FOR EACH ROW EXECUTE FUNCTION log_activity(); -- Add a JSONB column to store metadata ALTER TABLE books ADD COLUMN metadata JSONB; -- Example metadata: {"tags": ["fiction", "bestseller"], "page_count": 320}
Hier ist ein vollständiges Beispiel einer RESTful-API mit Gin und GORM:
package main import ( "net/http" "time" "github.com/gin-gonic/gin" "gorm.io/driver/postgres" "gorm.io/gorm" ) type Author struct { ID uint `gorm:"primaryKey"` Name string `gorm:"not null;unique"` Bio string } type Book struct { ID uint `gorm:"primaryKey"` Title string `gorm:"not null"` AuthorID uint `gorm:"not null"` PublishedDate time.Time `gorm:"not null"` Details map[string]interface{} `gorm:"type:jsonb"` } type User struct { ID uint `gorm:"primaryKey"` Name string `gorm:"not null"` Email string `gorm:"not null;unique"` CreatedAt time.Time } type BorrowLog struct { ID uint `gorm:"primaryKey"` UserID uint `gorm:"not null"` BookID uint `gorm:"not null"` BorrowedAt time.Time `gorm:"default:CURRENT_TIMESTAMP"` ReturnedAt *time.Time } var db *gorm.DB func initDB() { dsn := "host=localhost user=postgres password=yourpassword dbname=library port=5432 sslmode=disable" var err error db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{}) if err != nil { panic("failed to connect to database") } // Auto-migrate models. db.AutoMigrate(&Author{}, &Book{}, &User{}, &BorrowLog{}) } func main() { initDB() r := gin.Default() r.POST("/authors", createAuthor) r.POST("/books", createBook) r.POST("/users", createUser) r.POST("/borrow", borrowBook) r.GET("/borrow/:id", getBorrowCount) r.GET("/books", listBooks) r.Run(":8080") } func createAuthor(c *gin.Context) { var author Author if err := c.ShouldBindJSON(&author); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } if err := db.Create(&author).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, author) } func createBook(c *gin.Context) { var book Book if err := c.ShouldBindJSON(&book); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } if err := db.Create(&book).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, book) } func createUser(c *gin.Context) { var user User if err := c.ShouldBindJSON(&user); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } if err := db.Create(&user).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, user) } // The Golang code does not need changes specifically to use the partitioned tables; the partitioning is handled by PostgreSQL // you simply insert into the borrow_logs table, and PostgreSQL will automatically route the data to the correct partition. func borrowBook(c *gin.Context) { var log BorrowLog if err := c.ShouldBindJSON(&log); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } tx := db.Begin() if err := tx.Create(&log).Error; err != nil { tx.Rollback() c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } tx.Commit() c.JSON(http.StatusOK, log) } func getBorrowCount(c *gin.Context) { userID := c.Param("id") var count int if err := db.Raw("SELECT get_borrow_count(?)", userID).Scan(&count).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, gin.H{"borrow_count": count}) } // When querying a partitioned table in PostgreSQL using Golang, no changes are needed in the query logic or code. // You interact with the parent table (borrow_logs in this case) as you would with any normal table, and PostgreSQL automatically manages retrieving the data from the appropriate partitions. // Performance: PostgreSQL optimizes the query by scanning only the relevant partitions, which can significantly speed up queries when dealing with large datasets. // Here’s how you might query the borrow_logs table using GORM, even though it’s partitioned: func getBorrowLogs(c *gin.Context) { var logs []BorrowLog if err := db.Where("user_id = ?", c.Param("user_id")).Find(&logs).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, logs) } func listBooks(c *gin.Context) { var books []Book db.Preload("Author").Find(&books) c.JSON(http.StatusOK, books) }
Starten Sie den Golang-Server mit
go run main.go
Jetzt verfügen Sie über eine umfassende Golang RESTful API, die verschiedene PostgreSQL-Funktionen abdeckt und es zu einem robusten Beispiel für Schulungen oder Interviews macht.
Lassen Sie uns das Golang RESTful API-Beispiel mit zusätzlichen PostgreSQL-Funktionen erweitern, indem wir Ansichten, CTEs (Common Table Expressions) und Volltextindizierung integrieren und JSON-Verarbeitung. Jede dieser Funktionen wird mit relevanten PostgreSQL-Tabellendefinitionen und Golang-Code zur Interaktion mit ihnen demonstriert.
Das Datenschema für diesen Teil ist bereits aus dem letzten Abschnitt vorbereitet, daher müssen wir nur noch mehr Golang-Code hinzufügen.
mkdir library-api cd library-api go mod init library-api
JSON-Verarbeitung:
Durch die Verwendung von db.Raw und db.Exec für Roh-SQL mit GORM können Sie die leistungsstarken Funktionen von PostgreSQL nutzen und gleichzeitig die ORM-Funktionen von GORM für andere Teile Ihrer Anwendung beibehalten. Dies macht die Lösung sowohl flexibel als auch funktionsreich.
In diesem erweiterten Beispiel zeige ich, wie die folgenden Funktionen mithilfe von Golang und PostgreSQL integriert werden:
VACUUM wird normalerweise als Wartungsaufgabe verwendet, nicht direkt aus dem Anwendungscode. Sie können es jedoch zu Verwaltungszwecken mit GORMs Exec ausführen:
/library-api |-- db.sql |-- main.go |-- go.mod
PostgreSQLs MVCC ermöglicht gleichzeitige Transaktionen durch die Beibehaltung verschiedener Zeilenversionen. Hier ist ein Beispiel, wie man das MVCC-Verhalten in Golang mithilfe von Transaktionen demonstriert:
go get github.com/gin-gonic/gin go get gorm.io/gorm go get gorm.io/driver/postgres
Fensterfunktionen werden verwendet, um Berechnungen für eine Reihe von Tabellenzeilen durchzuführen, die sich auf die aktuelle Zeile beziehen. Hier ist ein Beispiel für die Verwendung einer Fensterfunktion zur Berechnung der laufenden Summe der ausgeliehenen Bücher für jeden Autor:
mkdir library-api cd library-api go mod init library-api
Das obige ist der detaillierte Inhalt vonGolang RESTful API mit Gin, Gorm, PostgreSQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!