Comment Golang implémente l'architecture MVC

MVC (Model View Controller) est un modèle d'architecture logicielle couramment utilisé qui divise une application en trois parties principales : le modèle, la vue et le contrôleur. Cette séparation peut améliorer la maintenabilité, l'évolutivité et la réutilisation de l'application. Dans Golang, nous pouvons facilement implémenter l'architecture MVC.

1. Introduction à MVC

Modèle 1.1

La couche Modèle est la partie centrale de l'application. Elle est principalement responsable du traitement des opérations liées aux données. La couche Modèle peut contenir le contenu suivant :

1.1.1 Connexion à la base de données

La tâche principale de la couche Modèle est d'interagir avec la base de données. Dans Golang, nous pouvons utiliser la bibliothèque base de données/sql officiellement fournie pour nous connecter à une base de données relationnelle. Par exemple :

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

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(host:port)/dbname")
    // ...
}

1.1.2 Opérations sur la base de données

Grâce à la bibliothèque base de données/sql, nous pouvons effectuer diverses opérations sur la base de données. Par exemple, interrogez une table dans la base de données :

rows, err := db.Query("SELECT * FROM users")
defer rows.Close()
for rows.Next() {
    var id int
    var username string
    var password string
    err := rows.Scan(&id, &username, &password)
    // ...
}

1.2 View

La couche View est chargée d'afficher les données, généralement une page HTML. Dans Golang, nous pouvons utiliser le moteur de modèle HTML pour créer la couche View. Par exemple :

import (
    "html/template"
)

type User struct {
    Username string
    Password string
}

func main() {
    tpl := template.Must(template.ParseFiles("template.html"))
    user := User{
        Username: "user",
        Password: "password",
    }
    tpl.Execute(w, user)
}

1.3 Contrôleur

La couche Contrôleur est responsable du traitement des demandes des utilisateurs et de la transmission des demandes à la couche Modèle et à la couche Vue. Dans Golang, le routeur HTTP peut être utilisé pour implémenter les fonctions de la couche Contrôleur. Par exemple :

import (
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    // 处理用户请求
    // ...
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

2. Golang implémente MVC

2.1 Couche modèle

Dans Golang, nous pouvons utiliser struct pour définir la structure des données de la couche Modèle, par exemple :

type User struct {
    ID       int
    Username string
    Password string
}

Nous pouvons également définir les méthodes du Modèle couche via l'interface, Par exemple :

type UserRepository interface {
    FindByID(id int) (*User, error)
    FindAll() ([]*User, error)
    Store(user *User) error
    Delete(id int) error
}

Ensuite, nous pouvons implémenter la méthode Model layer spécifiquement en implémentant l'interface UserRepository. Par exemple :

type UserRepositoryImpl struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepositoryImpl {
    return &UserRepositoryImpl{
        db: db,
    }
}

func (r *UserRepositoryImpl) FindByID(id int) (*User, error) {
    var user *User
    err := r.db.QueryRow("SELECT * FROM users WHERE id = ?", id).
        Scan(&user.ID, &user.Username, &user.Password)
    if err != nil {
        return nil, err
    }
    return user, nil
}

func (r *UserRepositoryImpl) FindAll() ([]*User, error) {
    var users []*User
    rows, err := r.db.Query("SELECT * FROM users")
    if err != nil {
        return nil, err
    }
    for rows.Next() {
        var user User
        err := rows.Scan(&user.ID, &user.Username, &user.Password)
        if err != nil {
            return nil, err
        }
        users = append(users, &user)
    }
    return users, nil
}

func (r *UserRepositoryImpl) Store(user *User) error {
    stmt, err := r.db.Prepare("INSERT INTO users (username, password) VALUES (?, ?)")
    if err != nil {
        return err
    }
    _, err = stmt.Exec(user.Username, user.Password)
    if err != nil {
        return err
    }
    return nil
}

func (r *UserRepositoryImpl) Delete(id int) error {
    stmt, err := r.db.Prepare("DELETE FROM users WHERE id = ?")
    if err != nil {
        return err
    }
    _, err = stmt.Exec(id)
    if err != nil {
        return err
    }
    return nil
}

2.2 Couche de vue

Dans Golang, nous pouvons utiliser le moteur de modèle HTML pour restituer la couche de vue, par exemple :

var tpl = `
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>{{.Title}}</title>
</head>
<body>
    <table>
        <thead>
            <tr>
                <th>ID</th>
                <th>Username</th>
                <th>Password</th>
            </tr>
        </thead>
        <tbody>
            {{range $index, $user := .Users}}
            <tr>
                <td>{{$user.ID}}</td>
                <td>{{$user.Username}}</td>
                <td>{{$user.Password}}</td>
            </tr>
            {{end}}
        </tbody>
    </table>
</body>
</html>
`

type PageData struct {
    Title string
    Users []*User
}

func handler(w http.ResponseWriter, r *http.Request) {
    userRepository := NewUserRepository(db)
    users, err := userRepository.FindAll()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    data := PageData{
        Title: "Users",
        Users: users,
    }
    tpl := template.Must(template.New("index").Parse(tpl))
    err = tpl.Execute(w, data)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

2.3 Couche de contrôleur

Dans Golang, nous pouvons utiliser un routeur HTTP pour gérer les demandes des utilisateurs, telles que as :

func handler(w http.ResponseWriter, r *http.Request) {
    // 处理用户请求
    // ...
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Nous pouvons également utiliser la bibliothèque gorilla/mux pour implémenter des fonctions de routage avancées. Par exemple :

func handler(w http.ResponseWriter, r *http.Request) {
    // 处理用户请求
    // ...
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", handler)
    r.HandleFunc("/users/{id}", getUser).Methods(http.MethodGet)
    http.ListenAndServe(":8080", r)
}

func getUser(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, _ := strconv.Atoi(vars["id"])
    userRepository := NewUserRepository(db)
    user, err := userRepository.FindByID(id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    json.NewEncoder(w).Encode(user)
}

3. Conclusion

En implémentant l'architecture MVC dans Golang, nous pouvons bien séparer les différentes parties de l'application, améliorant ainsi la maintenabilité, l'évolutivité et la réutilisabilité. Dans l'implémentation, nous pouvons utiliser la bibliothèque de base de données/sql officiellement fournie pour faire fonctionner la base de données, utiliser le moteur de modèle HTML pour afficher la page et utiliser le routeur HTTP pour traiter les demandes des utilisateurs. Dans le même temps, nous pouvons également utiliser des bibliothèques tierces pour implémenter des fonctions avancées, telles que la bibliothèque gorilla/mux pour implémenter des fonctions de routage avancées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!