Corak Reka Bentuk Singleton

Corak reka bentuk Singleton ialah salah satu yang paling penting dan kerap digunakan dalam pengaturcaraan perisian. Ia memastikan bahawa kelas hanya mempunyai satu contoh semasa masa jalan aplikasi dan menyediakan pusat akses global kepada contoh itu. Dalam artikel ini, kita akan membincangkan kepentingan Singleton, cara melaksanakannya di Golang dan faedah yang dibawanya, terutamanya dalam persekitaran serentak.

Apa itu Singleton?

Singleton ialah corak reka bentuk yang mengehadkan tika kelas kepada satu tika. Ia amat berguna dalam situasi di mana satu titik kawalan atau satu sumber dikongsi diperlukan, seperti:

• Pengurus konfigurasi, di mana tetapan aplikasi perlu dipusatkan.
• Kumpulan sambungan pangkalan data, di mana bilangan sambungan yang terhad mesti diuruskan dengan cekap.
• Pembalak, di mana konsistensi balak adalah penting.

Mengapa menggunakan Singleton?

Saya akan menyenaraikan beberapa perkara tentang pelaksanaan daripada Pattern yang lebih masuk akal dan juga untuk menunjukkan bahawa tidak semuanya cerah, beberapa masalah yang boleh kita hadapi dengannya.

Kelebihan

• Ketekalan Global: Memastikan semua titik aplikasi menggunakan contoh yang sama, memberikan ketekalan data dan gelagat.
• Kawalan Akses: Memusatkan kawalan penciptaan dan akses kepada contoh, memudahkan penyelenggaraan dan pengurusan kitaran hayat objek.
• Kecekapan Sumber: Mengelakkan penciptaan berbilang kejadian yang tidak perlu, menjimatkan memori dan sumber pemprosesan.

Keburukan

• Kesukaran Ujian: Singleton boleh menyukarkan ujian unit penulisan kerana mereka memperkenalkan keadaan global yang perlu diuruskan.
• Gandingan Bertambah: Penggunaan Singleton yang berlebihan boleh menyebabkan gandingan yang lebih ketat antara komponen, menjadikannya sukar untuk menyelenggara dan mengembangkan aplikasi.

Melaksanakan Singleton

Untuk melaksanakan singleton saya akan menggunakan Golang. Dalam bahasa ini kita perlu memberi perhatian khusus kepada konkurensi untuk memastikan bahawa hanya satu tika dibuat, walaupun berbilang goroutine cuba mengakses tika secara serentak.

Untuk mendekatkan contoh kita kepada dunia sebenar, mari buat Logger untuk aplikasi kita. Pembalak ialah alat biasa dalam aplikasi yang perlu unik untuk memastikan konsistensi log.

1 - Mentakrifkan struktur

Pertama, kami mentakrifkan struktur yang kami mahu mempunyai satu contoh.

package logger

import (
    "fmt"
    "sync"
)

type Logger struct {}

var loggerInstance *Logger

2 - Melaksanakan fungsi NewInstance

Fungsi NewInstance bertanggungjawab untuk mengembalikan tika tunggal struktur Singleton. Kami menggunakan mutex untuk memastikan keselamatan dalam persekitaran serentak, melaksanakan penguncian semak dua kali untuk kecekapan.

package logger

import (
    "fmt"
    "sync"
)

type Logger struct{}

var logger *Logger
var mtx = &sync.Mutex{}

func NewInstance() *Logger {
    if logger == nil {
        mtx.Lock()
        defer mtx.Unlock()
        if logger == nil {
            fmt.Println("Creating new Logger")
            logger = &Logger{}
        }
    } else {
        fmt.Println("Logger already created")
    }
    return logger
}

3 - Melaksanakan jenis log

Alat Log sentiasa mempunyai beberapa jenis log, seperti Maklumat untuk hanya menunjukkan maklumat, Ralat untuk menunjukkan ralat dan sebagainya. Ini adalah cara untuk menapis juga jenis maklumat yang ingin kami tunjukkan dalam aplikasi kami.

Jadi mari kita buat kaedah yang akan menunjukkan log kita dengan jenis Maklumat. Untuk melakukan ini, kami akan mencipta fungsi yang akan menerima mesej log kami dan memformatkannya ke format INFO.

package logger

import (
    "fmt"
    "sync"
    "time"
)

const (
    INFO    string = "INFO"
)

type Logger struct{}

var logger *Logger
var mtx = &sync.Mutex{}

func NewInstance() *Logger {
    if logger == nil {
        mtx.Lock()
        defer mtx.Unlock()
        if logger == nil {
            fmt.Println("Creating new logger")
            logger = &Logger{}
        }
    } else {
        fmt.Println("Logger already created")
    }
    return logger
}

func (l *Logger) Info(message string) {
    fmt.Printf("%s - %s: %s\n", time.Now().UTC().Format(time.RFC3339Nano), INFO, message)
}

4 - Menggunakan Logger

Dan untuk menggunakan pembalak baharu kami, kami akan membuat seketika dalam pakej utama kami dan membuat log untuk melihat cara pelaksanaan ini berfungsi.

package main

import (
    "playground-go/pkg/logger"
)

func main() {
    log := logger.NewInstance()
    log.Info("This is an example of log")
}

Inilah hasilnya apabila kami menjalankan program:

Creating new logger
2024-07-03T19:34:57.609599Z - INFO: This is an example of log

Jika kami ingin menguji sama ada NewInstance benar-benar menjamin bahawa kami hanya akan mempunyai satu contoh berjalan, kami boleh melakukan ujian berikut.

package main

import (
    "fmt"
    "playground-go/pkg/logger"
)

func main() {
    log := logger.NewInstance()
    log.Info("This is an example of log")

    log2 := logger.NewInstance()
    log2.Info("This is another example of log")

    if log == log2 {
        fmt.Println("same instance")
    } else {
        fmt.Println("different instance")
    }
}

Log kami telah berubah dan kini kami dapat melihat bahawa kami menyekat penciptaan tika baharu:

Creating new logger
2024-07-03T19:45:19.603783Z - INFO: This is an example of log
Logger already created
2024-07-03T19:45:19.603793Z - INFO: This is another example of log
same instance

Kesimpulan

Corak Singleton ialah alat yang berkuasa untuk memastikan bahawa hanya satu tika kelas tertentu wujud semasa masa jalan aplikasi. Dalam contoh logger, kami melihat cara corak ini boleh digunakan untuk memastikan konsistensi log merentas aplikasi.

Saya harap ini membantu anda memahami Singleton di Golang dengan lebih baik.

Atas ialah kandungan terperinci Corak Reka Bentuk Singleton. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!