golang start dan stop service

Golang ialah salah satu bahasa pengaturcaraan yang paling popular pada masa ini dan boleh digunakan untuk membangunkan pelbagai aplikasi, termasuk aplikasi pelayan. Artikel ini akan memperkenalkan cara menggunakan golang untuk menulis kod untuk memulakan dan menghentikan perkhidmatan.

1. Mulakan perkhidmatan

1. Tentukan perkhidmatan

Pertama, kita perlu mentakrifkan struktur perkhidmatan. Berikut ialah contoh mudah:

type MyService struct {
    httpServer *http.Server
}

func NewMyService(port string) *MyService {
    return &MyService{
        httpServer: &http.Server{
            Addr: fmt.Sprintf(":%s", port),
        },
    }
}

func (svc *MyService) Run() error {
    return svc.httpServer.ListenAndServe()
}

Dalam contoh ini, kami mentakrifkan struktur bernama MyService yang mengandungi tika http.Server. Kami juga mentakrifkan fungsi NewMyService, yang mencipta contoh struktur MyService. Fungsi ini perlu menghantar nombor port dan menggunakannya untuk mengkonfigurasi atribut Addr http.Server. Akhir sekali, kami juga mentakrifkan kaedah Run, yang memulakan http.Server dan mula mendengar permintaan masuk.

2. Mulakan perkhidmatan

Untuk memulakan perkhidmatan, kita hanya perlu menggunakan fungsi NewMyService untuk mencipta contoh perkhidmatan dan kemudian memanggil kaedah Run :

svc := NewMyService("8080")
err := svc.Run()
if err != nil {
    fmt.Printf("Failed to start service: %s", err)
    return
}

Kod ini mencipta contoh perkhidmatan baharu bernama svc dan mengkonfigurasinya untuk mendengar pada port 8080. Kemudian, kami memanggil kaedah Run untuk memulakan perkhidmatan. Jika permulaan gagal, kami akan mencetak mesej ralat ke konsol.

2. Menghentikan perkhidmatan

Menghentikan perkhidmatan adalah lebih rumit sedikit daripada memulakan perkhidmatan, kerana kita perlu mengendalikan proses penutupan yang anggun. Penutupan anggun memastikan pelayan menyelesaikan sebarang permintaan yang sedang berjalan sebelum ditutup. Berikut ialah cara untuk mencapai penutupan yang anggun:

1. Ubah suai definisi perkhidmatan

Pertama, kita perlu menambah saluran penutupan pada struktur MyService:

type MyService struct {
    httpServer *http.Server
    stopChan   chan os.Signal
}

Saluran penutupan ini akan digunakan untuk memberitahu pelayan bila hendak berhenti. Kami juga perlu mengubah suai fungsi NewMyService supaya saluran tertutup ditambahkan pada contoh perkhidmatan:

func NewMyService(port string) *MyService {
    stopChan := make(chan os.Signal, 1)
    signal.Notify(stopChan, os.Interrupt, syscall.SIGTERM)

    return &MyService{
        httpServer: &http.Server{
            Addr: fmt.Sprintf(":%s", port),
        },
        stopChan: stopChan,
    }
}

Di sini kami mentakrifkan paip bernama stopChan dan menggunakan fungsi signal.Notify untuk menambah sistem pengendalian Isyarat penamatan (cth. ctrl-c) ditambahkan pada saluran. Kami kemudian menambah saluran paip pada contoh perkhidmatan.

2. Ubah suai kaedah Run

Seterusnya, kita perlu mengubah suai kaedah Run. Kami akan menggunakan goroutine dalam kaedah ini untuk mendengar untuk menutup saluran dan jika saluran menerima isyarat, hentikan http.Server dan tutup fungsi:

func (svc *MyService) Run() error {
    go func() {
        <-svc.stopChan
        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
        defer cancel()
        svc.httpServer.Shutdown(ctx)
    }()

    return svc.httpServer.ListenAndServe()
}

Di sini kami telah menentukan dengan menggunakan kaedah context.WithTimeout Konteks Timeout untuk memastikan bahawa http.Server mempunyai masa yang mencukupi untuk menyelesaikan permintaan yang sedang diproses. Kami kemudian memanggil kaedah Shutdown http.Server untuk menghentikan pelayan yang sedang berjalan. Akhir sekali, kami mendengar paip dalam goroutine, menunggu pemberitahuan penutupan, dan menggunakan pemberitahuan itu untuk melakukan penutupan yang anggun.

3. Hentikan perkhidmatan

Sekarang kita hanya perlu mencipta contoh perkhidmatan baharu dalam kod klien, panggil kaedah Runnya dan tunggu ctrl-c atau penamatan lain isyarat Itu sahaja:

svc := NewMyService("8080")
err := svc.Run()
if err != nil {
    fmt.Printf("Failed to start service: %s", err)
    return
}

// wait for shutdown signal

Di sini kami mencipta contoh perkhidmatan dan memanggil kaedah Runnya. Kemudian kita hanya perlu menunggu ctrl-c atau isyarat penamatan lain.

Ringkasan

Dalam artikel ini, kami mempelajari cara menulis kod untuk memulakan dan menghentikan perkhidmatan menggunakan golang untuk memberikan pengalaman penutupan yang stabil dan anggun untuk aplikasi anda. Sama ada anda menulis perkhidmatan web, API RESTful atau apa-apa jenis perkhidmatan lain, teknologi ini akan memberi kesan positif terhadap kebolehpercayaan dan kestabilan aplikasi anda.

Atas ialah kandungan terperinci golang start dan stop service. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!