Comment puis-je servir des fichiers statiques intégrés dans un binaire Go ?

Servir des fichiers statiques à partir de binaires dans Go : un système de fichiers personnalisé

Lors du service de fichiers statiques dans Go, le gestionnaire FileServer simplifie le processus. Cependant, dans les cas où seuls quelques fichiers statiques doivent être déployés, une approche alternative peut éliminer le besoin de gérer ces fichiers en externe.

Implémentation InMemoryFS

Le serveur de fichiers nécessite un objet FileSystem, ce qui soulève la question de savoir comment intégrer des fichiers statiques dans un binaire. Une implémentation d'InMemoryFS peut servir des fichiers à partir de la mémoire, éliminant ainsi le besoin d'interagir directement avec le système de fichiers.

package main

import (
    "io"
    "net/http"
    "time"
)

type InMemoryFS map[string]io.ReadCloser

// Implements FileSystem interface
func (fs InMemoryFS) Open(name string) (http.File, error) {
    f, ok := fs[name]
    if !ok {
        return nil, os.ErrNotExist
    }
    return &InMemoryFile{
        ReadCloser: f,
    }, nil
}

type InMemoryFile struct {
    io.ReadCloser
}

// Implements http.File interface
func (f *InMemoryFile) Close() error {
    return nil
}
func (f *InMemoryFile) Stat() (os.FileInfo, error) {
    fi, err := f.ReadCloser.Stat()
    if err != nil {
        return nil, err
    }
    return &InMemoryFileInfo{
        name: f.ReadCloser.(os.FileInfo).Name(),
        size: fi.Size(),
        modTime: fi.ModTime(),
    }, nil
}

type InMemoryFileInfo struct {
    name string
    size int64
    modTime time.Time
}

// Implements os.FileInfo
func (s *InMemoryFileInfo) Name() string       { return s.name }
func (s *InMemoryFileInfo) Size() int64        { return s.size }
func (s *InMemoryFileInfo) Mode() os.FileMode  { return 0644 }
func (s *InMemoryFileInfo) ModTime() time.Time { return s.modTime }
func (s *InMemoryFileInfo) IsDir() bool        { return false }
func (s *InMemoryFileInfo) Sys() interface{}   { return nil }

Exemple d'utilisation

L'implémentation d'InMemoryFS peut être utilisée avec le FileServer comme suit :

func main() {
    FS := make(InMemoryFS)
    // Load static files into memory
    FS["foo.html"] = os.Open("foo.html")
    FS["bar.css"] = os.Open("bar.css")
    http.Handle("/", http.FileServer(FS))
    http.ListenAndServe(":8080", nil)
}

Alternative Considérations

Au lieu de créer un système de fichiers personnalisé, il pourrait être plus simple de réécrire la partie de desserte pour gérer directement un petit nombre de fichiers statiques, évitant ainsi d'avoir à émuler un système de fichiers complet. En fin de compte, la meilleure approche dépend des exigences spécifiques du projet.

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!