golang melaksanakan pemalam

Apabila perniagaan kami terus berkembang, aplikasi kami cenderung menjadi lebih besar dan lebih kompleks Pada masa ini, banyak model pembangunan perisian tradisional mungkin menjadi tidak mencukupi. Model gandingan kod tradisional sukar untuk memenuhi keperluan pembangunan kami yang pelbagai, manakala kaedah pembangunan plug-in menyediakan konsep reka bentuk yang lebih fleksibel dan berskala, yang boleh mencapai penyahgandingan kod secara berkesan dan membolehkan aplikasi beroperasi tanpa menukar Fungsi baharu boleh ditambah pada mana-mana masa sambil mengekalkan logik kod asal.

Dalam proses melaksanakan pembangunan pemalam, Golang, sebagai bahasa pengaturcaraan yang cekap, boleh dipercayai dan sangat maju, sememangnya merupakan pilihan yang sangat baik. Hari ini, kita akan mengetahui cara melaksanakan aplikasi pemalam di Golang.

Pengenalan kepada pembangunan pemalam

Sebelum meneruskan operasi sebenar, mari kita perkenalkan secara ringkas apa itu pembangunan pemalam. Pembangunan plug-in ialah kaedah pembangunan yang membahagikan aplikasi kepada berbilang komponen bebas Setiap komponen boleh dibangunkan, diuji, digunakan dan diselenggara secara bebas, dan komponen ini boleh ditambah atau dipadamkan pada bila-bila masa semasa aplikasi sedang berjalan. Melakukannya mempunyai beberapa kelebihan:

1. Kebolehgunaan semula kod yang dipertingkat: Setiap komponen ialah modul bebas, yang membolehkannya digunakan semula dalam aplikasi yang berbeza.
2. Mencapai penyahgandingan kod: hanya antara muka perlu ditakrifkan antara komponen, tanpa mengetahui butiran pelaksanaan dalaman komponen lain. Dengan cara ini, komponen yang berbeza boleh dibangunkan, diuji dan digunakan secara bebas.
3. Tingkatkan kebolehskalaan kod: Apabila aplikasi memerlukan fungsi baharu, hanya komponen baharu perlu ditambah, sekali gus mengelakkan pengubahsuaian kod asal dan membenarkan aplikasi dikembangkan dengan lebih cekap.

Gunakan Go untuk melaksanakan pemalam

Seterusnya, kami akan menggunakan bahasa Go untuk melaksanakan aplikasi pemalam. Kami akan menggunakan pakej pemalam Go untuk memuatkan dan melaksanakan pemalam Setiap pemalam mesti melaksanakan antara muka tertentu untuk dipanggil dalam aplikasi. Di sini, kami akan membangunkan aplikasi kalkulator mudah, terutamanya untuk menunjukkan cara menggunakan Go untuk mencapai pembangunan pemalam.

Aplikasi kalkulator boleh menyokong penambahan, penolakan, pendaraban, pembahagian dan fungsi lain, dan setiap fungsi sepadan dengan pemalam. Kami akan menulis program utama dan empat pemalam untuk melaksanakan empat logik pengiraan berbeza bagi penambahan, penolakan, pendaraban dan pembahagian.

Pertama, mari kita lihat kod program utama:

package main

import (
    "fmt"
    "os"
    "plugin"
)

type Operation interface {
    Calculate(a, b int) int
}

type Plugin struct {
    Name      string
    Operation Operation
}

func main() {

    if len(os.Args) < 3 {
        fmt.Println("Usage: pluginCalculator OPERATION VALUE")
        os.Exit(-1)
    }

    op := os.Args[1]
    value := os.Args[2]

    plugins := []Plugin{
        Plugin{"Add", nil},
        Plugin{"Subtract", nil},
        Plugin{"Multiply", nil},
        Plugin{"Divide", nil},
    }

    for i, plugin := range plugins {
        p, err := pluginOpen("./plugins/" + plugin.Name + ".so")
        if err != nil {
            fmt.Println("Error opening plugin:", plugin.Name)
            continue
        }
        var op Operation
        op, err = p.Lookup("Operation")
        if err != nil {
            fmt.Println("Error looking up operation:", plugin.Name)
            continue
        }
        plugins[i].Operation = op
    }

    for _, plugin := range plugins {
        if plugin.Operation == nil {
            continue
        }
        if plugin.Name == op {
            valueInt := 0
            fmt.Sscanf(value, "%d", &valueInt)
            result := plugin.Operation.Calculate(100, valueInt)
            fmt.Printf("Result of %s(%d, %d): %d
", op, 100, valueInt, result)
            return
        }
    }

    fmt.Println("Unsupported operation:", op)
}

func pluginOpen(path string) (*plugin.Plugin, error) {
    p, err := plugin.Open(path)
    return p, err
}

Dalam program ini, kami menggunakan pakej pemalam Go untuk memuatkan pemalam dan melaksanakan operasinya. Pertama, kami mentakrifkan antara muka kalkulator Operasi Setiap pemalam mesti melaksanakan antara muka ini untuk dipanggil dalam aplikasi. Kemudian, kami menentukan struktur Pemalam untuk mewakili maklumat pemalam, termasuk nama pemalam dan tika Operasi.

Seterusnya, kami mentakrifkan tatasusunan pemalam untuk menyimpan semua maklumat pemalam. Kami menggunakan gelung for untuk mengulangi semua pemalam dan memuatkan fail pemalam melalui fungsi pemalam.Buka. Jika pemuatan gagal, log ralat dan teruskan melintasi pemalam seterusnya. Jika pemuatan berjaya, gunakan fungsi p.Lookup untuk mencari antara muka Operasi yang dilaksanakan dalam pemalam dan tetapkan ia kepada tatasusunan pemalam. Akhir sekali, kami menanyakan operasi yang dimasukkan oleh pengguna, dan jika pemalam yang sepadan ditemui, kami menggunakan fungsi Kira pemalam untuk mengira keputusan dan mengeluarkan maklumat hasil pada konsol.

Seterusnya, mari kita lihat pelaksanaan kod pemalam. Di sini, kami akan menulis empat pemalam untuk melaksanakan empat logik pengiraan berbeza bagi penambahan, penolakan, pendaraban dan pembahagian. Pemalam ini semuanya akan melaksanakan antara muka Operasi yang kami takrifkan sebelum ini.

Pertama, mari kita lihat kod Add plug-in yang melaksanakan penambahan:

package main

type Add struct{}

func (*Add) Calculate(a, b int) int {
    return a + b
}

var Operation = Add{}

Dalam program ini, kami mentakrifkan struktur Tambah yang melaksanakan kaedah Kira antara muka Operasi kami takrifkan Kaedah ini melaksanakan operasi penambahan dan mengeksportnya sebagai pembolehubah Operasi untuk memudahkan pemuatan program utama.

Begitu juga, berikut ialah pelaksanaan kod bagi empat pemalam untuk penolakan, pendaraban dan pembahagian:

Tolak pemalam:

package main

type Subtract struct{}

func (*Subtract) Calculate(a, b int) int {
    return a - b
}

var Operation = Subtract{}

Darab pemalam:

package main

type Multiply struct{}

func (*Multiply) Calculate(a, b int) int {
    return a * b
}

var Operation = Multiply{}

Pemalam Bahagi:

package main

type Divide struct{}

func (*Divide) Calculate(a, b int) int {
    return a / b
}

var Operation = Divide{}

Pelaksanaan pemalam adalah sangat mudah dan jelas Kesemuanya hanya melaksanakan kaedah Kira dalam antara muka Operasi, tetapi anda perlu menggunakan -. buildmode=plugin flag untuk menjana fail .so semasa membina, contohnya:

go build -buildmode=plugin Add.go

Ringkasan

Dalam artikel ini, kami memperkenalkan konsep asas pembangunan pemalam dan menunjukkan cara membangun dan menggunakan pemalam melalui aplikasi kalkulator yang menggunakan Golang untuk melaksanakan pemalam. Kaedah pembangunan pemalam ini boleh meningkatkan kecekapan dan kualiti pembangunan perisian kami dengan sangat baik, di samping mencapai penyahgandingan kod dan pengembangan aplikasi yang fleksibel dengan berkesan. Perlu diingatkan bahawa dalam pembangunan sebenar, adalah perlu untuk menilai dengan teliti keperluan aplikasi dan memilih penyelesaian pembangunan plug-in yang sesuai berdasarkan situasi sebenar untuk mencapai kesan pembangunan yang optimum.

Atas ialah kandungan terperinci golang melaksanakan pemalam. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!