这个依赖注入模式是否具有线程安全性？

小伙伴们有没有觉得学习Golang很有意思？有意思就对了！今天就给大家带来《这个依赖注入模式是否具有线程安全性？》，以下内容将会涉及到，若是在学习中对其中部分知识点有疑问，或许看了本文就能帮到你！

我很难想出一个干净的模式来在 rest 服务器中注入依赖项，从而允许我编写独立的单元测试。下面的结构似乎有效，但我不确定它是否是线程安全的。

商店：

package store

type interfacestore interface {
    connect()
    disconnect()
    user() interfaceuser
}

// wiring up
type store struct {
    db *mongo.database
}

func (s *store) connect() {
    client, err := mongo.connect()
    if err != nil {
        log.fatal(err.error())
    }

    s.db = client.database()
}

func (s *store) disconnect() {
    s.db.client().disconnect(context.todo())
}

func (s *store) user() interfaceuser {
    return &user{s.db}
}


// exposed from the package to create a store instance
func getstore() interfacestore {
    return &store{}
}


// user related
type interfaceuser interface {
    insertone(models.user) (string, error)
}

type user struct {
    db *mongo.database
}

func (u *user) insertone(user models.user) (primitive.objectid, error) {
    collection := u.db.collection(collectionusers)
    // persisting user in db
}

服务器：

package server

type server struct{}

func (s *server) start() {
    storeinstance := store.getstore()
    storeinstance.connect()
    defer storeinstance.disconnect()

    r := gin.default()
    keys := keys.getkeys()

    routes.initroutes(r, storeinstance)

    port := fmt.sprintf(":%s", keys.port)

    r.run(port)
}

func createinstance() *server {
    return &server{}
}

路线：

package routes

func initroutes(router *gin.engine, store store.interfacestore) {
    router.use(middlewares.cors)

    // createsubrouter creates a gin routergroup with the prefix "/user"
    userroutes(createsubrouter("/user", router), store)
}

func userroutes(router *gin.routergroup, store store.interfacestore) {
    controller := controllers.getusercontroller(store)

    router.get("/", controller.get)
}

控制器：

package controllers

type usercontrollers struct {
    userservice services.interfaceuser
}

func (u *usercontrollers) get(c *gin.context) {
    userdetails, _ := u.userservice.fetchallinformation(bson.m{"_id": userdata.(models.user).id})

    utils.respondwithjson(c, userdetails)
}

func getusercontroller(store store.interfacestore) usercontrollers {
    userservice := services.getuserservice(store)

    return usercontrollers{
        userservice: &userservice,
    }
}

服务：

package services

type InterfaceUser interface {
    FetchAllInformation(bson.M) (*models.User, error)
}

type user struct {
    store store.InterfaceStore
}

func (u *user) FetchAllInformation(filter bson.M) (*models.User, error) {
    user, err := u.store.User().FindOne(filter)
    if err != nil {
        return nil, err
    }

    return user, nil
}

func GetUserService(store store.InterfaceStore) user {
    return user{
        store: store,
    }
}

通过使用接口，我可以在为控制器编写测试时模拟整个服务，并且可以模拟整个存储来测试服务组件，而无需访问数据库。

我想知道存储实例是否可以在代码中安全共享，因为接口不是指针。这是否意味着每次我将 store 传递到树上时都会创建一个副本？

解决方案

type 用户结构 {} 定义指出 store 是实现 store.InterfaceStore 接口的任何内容。

如果你仔细观察，你会发现你正在使用指针接收器来实现它。这意味着接收者（指向的实例）将被共享。

如果你的模拟通过值类型实现它们，它将在方法调用时被复制，你会很安全，但这也意味着这个模拟在方法调用后不会保持新状态，我猜是不是你想要的。

底线，这并不是关于如何在结构中通过值或引用定义它，而是这些方法接受什么作为接收者。

本篇关于《这个依赖注入模式是否具有线程安全性？》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！