如何在代码中实现代码包与用户代码的分离，并实现相互访问

珍惜时间，勤奋学习！今天给大家带来《如何在代码中实现代码包与用户代码的分离，并实现相互访问》，正文内容主要涉及到等等，如果你正在学习Golang，或者是对Golang有疑问，欢迎大家关注我！后面我会持续更新相关内容的，希望都能帮到正在学习的大家！

我是 golang 新手，所以我从 udemy 购买了一些课程来帮助我熟悉这门语言。当我用该语言开展一个项目时，我发现其中之一对于总体理解非常有帮助。

在我上的课中，所有与sql相关的函数都在sqlc文件夹中，结构较少：

sqlc
        generatedcode
        store

其中一个文件是由 sqlc 生成的查询器，其中包含具有所生成的所有方法的接口。这是目前的总体思路：https://github.com/techschool/simplebank/tree/master/db/sqlc

package db

import (
    "context"

    "github.com/google/uuid"
)

type querier interface {
    addaccountbalance(ctx context.context, arg addaccountbalanceparams) (account, error)
    createaccount(ctx context.context, arg createaccountparams) (account, error)
    ...
}

var _ querier = (*queries)(nil)

是否可以将 sqlc 生成的内容和开发人员创建的任何查询（动态查询）包装到单个查询器中？我还试图让 sqlc 生成的代码位于它自己的文件夹中。我的目标结构是：

sql
        sqlc
            generatedcode
        store - (wraps it all together)
        dynamicsqlfiles

这应该清楚我所说的商店的含义：https://github.com/techschool/simplebank/blob/master/db/sqlc/store.go

package db

import (
    "context"
    "database/sql"
    "fmt"
)

// store defines all functions to execute db queries and transactions
type store interface {
    querier
    transfertx(ctx context.context, arg transfertxparams) (transfertxresult, error)
}

// sqlstore provides all functions to execute sql queries and transactions
type sqlstore struct {
    db *sql.db
    *queries
}

// newstore creates a new store
func newstore(db *sql.db) store {
    return &sqlstore{
        db:      db,
        queries: new(db),
    }
}

我正在尝试通过该存储运行所有内容（包括生成的函数和我的函数），因此我可以进行类似于此文件（server.store）中的 createuser 函数的调用。：https://github.com/ techschool/simplebank/blob/master/api/user.go

arg := db.createuserparams{
        username:       req.username,
        hashedpassword: hashedpassword,
        fullname:       req.fullname,
        email:          req.email,
    }

    user, err := server.store.createuser(ctx, arg)
    if err != nil {
        if pqerr, ok := err.(*pq.error); ok {
            switch pqerr.code.name() {
            case "unique_violation":
                ctx.json(http.statusforbidden, errorresponse(err))
                return
            }
        }
        ctx.json(http.statusinternalservererror, errorresponse(err))
        return
    }

我尝试创建一个包含另一个查询器接口的东西，该查询器接口嵌入生成的查询器接口，然后创建我自己的 db.go，它使用生成的 dbtx 接口，但有自己的查询结构和新函数。它总是给我一个错误，即我创建的查询结构没有实现我所做的功能，尽管它是在我制作的自定义方法之一中实现的。

我删除了该分支，并一直在单击上面链接的 simplebank 项目，看看是否可以找到另一种方法来完成此操作，或者是否错过了某些内容。如果做不到，也没关系。我只是利用这个机会来进一步了解该语言，并在可能的情况下将一些代码分开。

更新： 我只需要更改几部分，但我修改了 store.go 使其看起来更像：

// sdb is imported, but points to the generated Querier
// Store provides all functions to execute db queries and transactions
type Store interface {
    sdb.Querier
    DynamicQuerier
}

// SQLStore provides all functions to execute SQL queries and transactions
type SQLStore struct {
    db *sql.DB
    *sdb.Queries
    *dynamicQueries
}

// NewStore creates a new Store
func NewStore(db *sql.DB) Store {
    return &SQLStore{
        db:             db,
        Queries:        sdb.New(db),
        dynamicQueries: New(db),
    }
}

然后为我要创建的方法创建一个新的查询器和结构。给他们自己的新功能，并在上面将其捆绑在一起。之前，我试图找到一种方法来尽可能多地重用生成的代码，我认为这就是问题所在。

为什么我想要这个界面： 我想要一个结构，将我将要处理的文件与我永远不会接触（生成）的文件分开。这是新的结构：

我喜欢生成的代码如何将所有内容放入 querier 接口中，然后检查实现它的任何内容是否满足所有功能要求。所以我想为我自己创建的动态部分复制它。

这可能会让事情变得比“需要”的复杂一些，但它也提供了一组额外的错误检查，这是很好的。在这种情况下，即使可能没有必要，它最终也是可行的。

正确答案

是否可以将 sqlc 生成的内容和开发人员创建的任何查询（动态查询）包装到单个查询器中？

如果我正确理解您的问题，我认为您正在寻找类似以下内容的内容 (playground)：

package main

import (
    "context"
    "database/sql"
)

// sample sql c code
type dbtx interface {
    execcontext(context.context, string, ...interface{}) (sql.result, error)
    preparecontext(context.context, string) (*sql.stmt, error)
    querycontext(context.context, string, ...interface{}) (*sql.rows, error)
    queryrowcontext(context.context, string, ...interface{}) *sql.row
}

type queries struct {
    db dbtx
}

func (q *queries) deleteaccount(ctx context.context, id int64) error {
    // _, err := q.db.execcontext(ctx, deleteaccount, id)
    // return err
    return nil // pretend that this always works
}

type querier interface {
    deleteaccount(ctx context.context, id int64) error
}

//
// your custom "dynamic" queries
//

type mydynamicqueries struct {
    db dbtx
}

func (m *mydynamicqueries) getdynamicresult(ctx context.context) error {
    // _, err := q.db.execcontext(ctx, deleteaccount, id)
    // return err
    return nil // pretend that this always works
}

type mydynamicquerier interface {
    getdynamicresult(ctx context.context) error
}

// combine things

type alldatabase struct {
    *queries  // note: you could embed this directly into mydynamicqueries instead of having a seperate struct if that is your preference
    *mydynamicqueries
}

type databasefunctions interface {
    querier
    mydynamicquerier
}

func main() {
        // basic example
    var db databasefunctions
    db = getdatabase()
    db.deleteaccount(context.background(), 0)
    db.getdynamicresult(context.background())

}

// getdatabase - perform whatever is needed to connect to database...
func getdatabase() alldatabase {
    sqlc := &queries{db: nil}           // in reality you would use new() to do this!
    mydyn := &mydynamicqueries{db: nil} // again it's often cleaner to use a function
    return alldatabase{queries: sqlc, mydynamicqueries: mydyn}
}

为了简单起见，以上内容都在一个文件中，但可以轻松地从多个包中提取，例如

type alldatabase struct {
    *generatedcode.queries
    *store.mydynamicqueries
}

如果这不能回答您的问题，请显示您失败的尝试之一（以便我们可以看到您哪里出了问题）。

一个一般性评论 - 您真的需要该界面吗？ common recommendation 是“接受接口，返回结构”。虽然这可能并不总是适用，但我怀疑您可能会在并不真正需要的地方引入接口，这可能会增加不必要的复杂性。

我认为容纳两个查询者的商店将它们捆绑在一起。您能用上面的例子（在问题帖子中）解释一下为什么没有必要吗？ sqlstore 如何访问所有 querier 接口函数？

struct sqlstore 就是“将它们捆绑在一起”。根据 Go spec：

给定一个结构体类型 s 和一个命名类型 t，提升的方法将包含在该结构体的方法集中，如下所示：

• 如果 s 包含嵌入字段 t，则 s 和 *s 的方法集都包含接收者为 t 的提升方法。*s 的方法集还包含接收者为 *t 的提升方法。
• 如果 s 包含嵌入字段 *t，则 s 和 *s 的方法集都包含接收者为 t 或 *t 的提升方法。

所以 sqlstore 类型的对象：

type SQLStore struct {
    db *sql.DB
    *sdb.Queries
    *dynamicQueries
}

var foo SQLStore // Assume that we are actually providing values for all fields

将实现 sdb.queries 以及 dynamicqueries 中的所有方法（您还可以通过 sql.db 成员通过 foo.db.xxx 访问）。这意味着您可以调用 foo.addaccountbalance() 和 foo.mygenericquery() （假设在 dynamicqueries 中！）等。

spec 表示“接口以最基本的形式指定了一个（可能为空）方法列表”。因此，您可以将接口视为必须由您分配给接口的任何实现（例如 struct）来实现的函数列表（接口本身不直接实现任何内容）。

This example可能会帮助您理解。

希望这能有所帮助（因为我不确定您不理解哪一方面，我也不确定要关注什么）。

本篇关于《如何在代码中实现代码包与用户代码的分离，并实现相互访问》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！