Même si le serveur HTTP commence à utiliser Go et protobuf, SQL Server, la requête ne renverra pas le résultat

Contenu de la question

J'essaie de créer des requêtes API en utilisant Go, protobuf et SQL Server comme base de données. Mon serveur HTTP est démarré par requête curl, code retour : 5

Mon main.gocode

package main

import (
    "context"
    "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "net"
    "net/http"

    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    pb "github.com/myorg/nb_nb_nb/proto"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    _ "google.golang.org/grpc/grpclog/glogger"

    _ "github.com/denisenkom/go-mssqldb"
)

type appServer struct {
    pb.UnimplementedMyAppServiceServer
    db *sql.DB
}
//mssql
const (
    dbserver = "windows.net"
    port     = 1433
    user     = "reader"
    password = "mypassword"
    database = "dbnm"
)

const sqlQuery = `
my query
`

func (s *appServer) ExecuteQuery(ctx context.Context, req *pb.QueryRequest) (*pb.QueryResponseList, error) {
    log.Printf("received: Start Date - %v, End Date - %v", req.GetReportStartDate(), req.GetReportEndDate())

    rows, err := s.db.Query(sqlQuery, req.ReportStartDate, req.ReportEndDate)
    if err != nil {
        log.Printf("Error executing query: %v", err)
        return nil, fmt.Errorf("failed to execute query: %v", err)
    }
    defer rows.Close()

    var results []*pb.QueryResponse
    for rows.Next() {
        var result pb.QueryResponse
        err := rows.Scan(
            //fields
        )
        if err != nil {
            log.Printf("Error scanning rows: %v", err)
            return nil, fmt.Errorf("failed to scan rows: %v", err)
        }

        results = append(results, &result)
    }

    return &pb.QueryResponseList{Responses: results}, nil
}

func connectDB() (*sql.DB, error) {
    connectionString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=%s", dbserver, user, password, port, database)
    db, err := sql.Open("mssql", connectionString)
    if err != nil {
        return nil, fmt.Errorf("failed to connect to the database: %v", err)
    }

    if err := db.Ping(); err != nil {
        return nil, fmt.Errorf("database connection failed: %v", err)
    }

    fmt.Println("Database connection successful")
    return db, nil
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            log.Println("Recovered from panic:", r)
        }
    }()

    db, err := connectDB()
    if err != nil {
        log.Fatalf("Failed to connect to the database: %v", err)
    }
    defer db.Close()

    log.Println("Starting gRPC server...")
    lis, err := net.Listen("tcp", ":7777")
    if err != nil {
        log.Fatalf("TCP connection failed: %v", err)
    } else {
        log.Printf("gRPC Server Listening at %v", lis.Addr())
    }

    size := 1024 * 1024 * 50
    s := grpc.NewServer(grpc.MaxRecvMsgSize(size), grpc.MaxSendMsgSize(size))
    pb.RegisterMyAppServiceServer(s, &appServer{db: db})

    mux := runtime.NewServeMux()
    opts := []grpc.DialOption{grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, ""))}
    err = pb.RegisterMyAppServiceHandlerFromEndpoint(context.Background(), mux, ":7777", opts)
    if err != nil {
        log.Fatalf("Failed to register gRPC gateway: %v", err)
    } else {
        log.Printf("Registered gRPC gateway")
    }

    http.HandleFunc("/api/query", func(w http.ResponseWriter, r *http.Request) {
        startDate := r.URL.Query().Get("startDate")
        endDate := r.URL.Query().Get("endDate")

        req := &pb.QueryRequest{
            ReportStartDate: startDate,
            ReportEndDate:   endDate,
        }
        fmt.Print(req)
        resp, err := (&appServer{db: db}).ExecuteQuery(r.Context(), req)
        if err != nil {
            log.Printf("Error executing query: %v", err)
            http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            return
        }

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

    go func() {
        log.Println("Starting HTTP server...")
        err := http.ListenAndServe(":7778", mux)
        if err != nil {
            log.Fatalf("HTTP server failed: %v", err)
        } else {
            log.Printf("HTTP server started.")
        }
    }()

    if err := s.Serve(lis); err != nil {
        log.Fatalf("gRPC server failed: %v", err)
    } else {
        log.Printf("gRPC, HTTP, and API server started.")
    }
}

go运行server/main.goRetour

Database connection successful
2023/12/24 21:48:23 Starting gRPC server...
2023/12/24 21:48:23 gRPC Server Listening at [::]:7777
2023/12/24 21:48:23 Registered gRPC gateway
2023/12/24 21:48:23 Starting HTTP server...

et demande de curl (curl -X GET "http://localhost:7778/api/query?startDate=2023-10-01&endDate=2023-10-02") retour :

{"code":5, "message":"Not Found", "details":[]}

Qu'est-ce qui me manque dans mon code ? Pourquoi ne puis-je renvoyer aucun résultat ? Mon pare-feu est désactivé.

Bonne réponse

Il semble que la route "/api/query" ait été définie sur le ServeMux par défaut, mais le mux ServeMux est utilisé lors de l'écoute sur l'interface.

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!