如何处理未知变量或如何处理多个数据库

huangapple
go评论116阅读模式
英文:

How to deal with unknown variables or How to deal with multiple databases

问题

我正在处理一个使用多个数据库的Go RESTful API应用程序。在启动服务器时，用户会指定他们想要使用的数据库。

在应用程序中，我有三个函数，其中一个处理连接：selectedDb.Get()、selectedDb.Add()、selectedDb.Connect()。

如果有人选择了MySQL，它会处理MySQL相关的事情；如果有人选择了MongoDB，它会处理MongoDB相关的事情，依此类推。

以下是我尝试实现这一目标的方式：

DbInterface.go

  1. package dbinit
  3. type Object struct {
  4.     Uuid    string
  5.     Object  string
  6.     Deleted bool
  7. }
  9. // 所有连接器都应该具备的接口
  10. type Intfc interface {
  11.     Connect() HERE_LIES_MY_PROBLEM
  12.     Add(string, string, string) string
  13.     Get(string) (Object, bool)
  14. }

MySQL.go

  1. package mysqlConnector
  3. import (
  4.     ...
  5. )
  7. type Mysql struct{}
  9. // 连接到MySQL
  10. func (f Mysql) Connect() HERE_LIES_MY_PROBLEM {
  12.     client, err = sql.Open("mysql", "yourusername:yourpassword@/yourdatabase")
  13.     if err != nil {
  14.         panic(err.Error())
  15.     }
  17.     return client
  18. }
  20. // 向数据库添加项目
  21. func (f Mysql) Add(owner string, refType string, object string) string {
  22.     // 处理与该数据库相关的事务
  24.     return // 一个字符串
  25. }
  27. func (f Mysql) Get(Uuid string) (dbinit.Object, bool) {
  28.     // 处理与该数据库相关的事务
  30.     return // 一个对象和一个布尔值
  31. }

Mongo.go

  1. package mongoConnector
  3. import (
  4.     ...
  5. )
  7. type Mongo struct{}
  9. // 连接到MongoDB
  10. func (f Mongo) Connect() HERE_LIES_MY_PROBLEM {
  12.     info := &mgo.DialInfo{
  13.         Addrs:    []string{hosts},
  14.         Timeout:  60 * time.Second,
  15.         Database: database,
  16.         Username: username,
  17.         Password: password,
  18.     }
  20.     client, err := mgo.DialWithInfo(info)
  21.     if err != nil {
  22.         panic(err)
  23.     }
  25.     return client
  26. }
  28. // 向数据库添加项目
  29. func (f Mongo) Add(owner string, refType string, object string) string {
  30.     // 处理与该数据库相关的事务
  32.     return // 一个字符串
  33. }
  35. func (f Mongo) Get(Uuid string) (dbinit.Object, bool) {
  36.     // 处理与该数据库相关的事务
  38.     return // 一个对象和一个布尔值
  39. }

main.go

  1. ...
  3. var selectedDb dbinit.Intfc
  5. commandLineInput := "mysql" // 仅作为示例
  7. if commandLineInput == "mysql" {
  8.     selectedDb = mysqlConnector.Mysql{}
  9. } else if commandLineInput == "mongo" {
  10.     selectedDb = mongoConnector.Mongo{}
  11. }
  13. client := selectedDb.Connect()
  15. // 每次调用API时都会运行这里
  16. api.HandlerFoobar = foobar.handlerFunction(func(params foobar.Params) middleware.Responder {
  18.     // 在这里，我想向selectedDb添加一些内容
  19.     selectedDb.Get(client, addStringA, addStringB, addStringC)
  21.     return // API响应
  23. })
  25. ...

问题陈述

当我返回MySQL的client时，它对于MongoDB不起作用，反之亦然。

我希望只在启动服务器时连接到数据库，并将client存储在client变量中。然而，问题在于MongoDB返回的client与MySQL返回的client不同。

  1. 在代码中的HERE_LIES_MY_PROBLEM位置应该填写什么？
  2. 或者，我是否对处理这些事情的Go范式有误解？
英文:

I'm working on a Go RESTful API application with multiple databases. When starting the server, the user supplies which database they would like to use.

In the application, I have three functions of which one handles the connection: selectedDb.Get(), selectedDb.Add(), selectedDb.Connect().

If somebody selects, Mysql, it handles things for Mysql, if someone selects MongoDB it handles things for Mongo and so on.

This is how I try to accomplish this:

DbInterface.go

  1. package dbinit
  3. type Object struct {
  4. 	Uuid         string
  5. 	Object       string
  6. 	Deleted      bool
  7. }
  9. // The interface that all connectors should have
  10. type Intfc interface {
  11. 	Connect() HERE_LIES_MY_PROBLEM
  12. 	Add(string, string, string) string
  13. 	Get(string) (Object, bool)
  14. }

MySQL.go

  1. package mysqlConnector
  2.     
  3. import (
  4.     ...
  5. )
  7. type Mysql struct{}
  9. // Connect to mysql
  10. func (f Mysql) Connect() HERE_LIES_MY_PROBLEM {
  12.     client, err = sql.Open("mysql", "yourusername:yourpassword@/yourdatabase")
  13.     if err != nil {
  14.         panic(err.Error())    
  15.     }
  16.     
  17.     return client
  18. }
  20. // Add item to DB
  21. func (f Mysql) Add(owner string, refType string, object string) string {
  22.     // do stuff related to this DB
  24.     return // a string
  25. }
  27. func (f Mysql) Get(Uuid string) (dbinit.Object, bool) {
  28.     // do stuff related to this DB
  30.     return // an object and a bool
  31. }

Mongo.go

  1. package mongoConnector
  2.     
  3. import (
  4.     ...
  5. )
  7. type Mongo struct{}
  9. // Connect to mongo
  10. func (f Mongo) Connect() HERE_LIES_MY_PROBLEM {
  12.     info := &mgo.DialInfo{
  13.         Addrs:    []string{hosts},
  14.         Timeout:  60 * time.Second,
  15.         Database: database,
  16.         Username: username,
  17.         Password: password,
  18.     }
  20.     client, err := mgo.DialWithInfo(info)
  21.     if err != nil {
  22.         panic(err)
  23.     }
  25.     return client
  26. }
  28. // Add item to DB
  29. func (f Mongo) Add(owner string, refType string, object string) string {
  30.     // do stuff related to this DB
  32.     return // a string
  33. }
  35. func (f Mongo) Get(Uuid string) (dbinit.Object, bool) {
  36.     // do stuff related to this DB
  38.     return // an object and a bool
  39. }

main.go

  1. ...
  3. var selectedDb dbinit.Intfc
  5. commandLineInput := "mysql" // just for the example
  7. if commandLineInput == "mysql" {
  8.     selectedDb = mysqlConnector.Mysql{}
  9. } else if commandLineInput == "mongo" {
  10.     selectedDb = mongoConnector.Mongo{}
  11. }
  13. client := selectedDb.Connect()
  15. // this runs everytime the API is called
  16. api.HandlerFoobar = foobar.handlerFunction(func(params foobar.Params) middleware.Responder {
  18.     // Here I want to add something to the selected dbinit
  19.     selectedDb.Get(client, addStringA, addStringB, addStringC)
  21.     return // the API response
  22.     
  23. })
  25. ...

Problem statement

When I return the client for Mysql, it doesn't work for Mongo and visa versa.

I want to connect to the database ONLY when starting the server and store the client inside the client variable. The problem, however, is that Mongo returns another client than Mysql does and so forth.

  1. What should be in the places where I have HERE_LIES_MY_PROBLEM in the code?
  2. Or do I get the Go paradigm wrong for dealing with these things?

答案1

得分: 5

如果你想保留这些方法与接口的关联，你需要稍微修改接口的定义：

接口：

  1. // 所有连接器都应该具有的接口
  2. type Intfc interface {
  3.     // 连接到数据库，如果连接时发生错误，返回错误
  4.     Connect() error
  5.     // 添加数据，返回一个字符串，如果发生错误，返回错误
  6.     Add(string, string, string) (string, error)
  7.     // 根据参数获取数据，返回一个对象和一个布尔值
  8.     Get(string) (Object, bool)
  9. }

MySQL：

  1. type Mysql struct{
  2.     conn *sql.DB // 数据库连接
  3. }
  5. // 连接到 MySQL
  6. func (f *Mysql) Connect() error {
  7.     conn, err := sql.Open("mysql", "yourusername:yourpassword@/yourdatabase")
  8.     if err != nil {
  9.         return err
  10.     }
  11.     f.conn = conn
  12.     return nil
  13. }
  15. // 向数据库添加数据
  16. func (f *Mysql) Add(owner string, refType string, object string) (string, error) {
  17.     // 做一些操作
  18.     return // 返回一个字符串和错误
  19. }
  21. func (f *Mysql) Get(Uuid string) (dbinit.Object, bool) {
  22.     // 做一些操作
  23.     return // 返回一个对象和一个布尔值
  24. }

Mongo：

  1. type Mongo struct{
  2.     session *mgo.Session
  3. }
  5. // 连接到 MongoDB
  6. func (f *Mongo) Connect() error {
  7.     info := &mgo.DialInfo{
  8.         // 一些数据
  9.     }
  11.     session, err := mgo.DialWithInfo(info)
  12.     if err != nil {
  13.         return err
  14.     }
  15.     f.session = session
  16.     return nil
  17. }
  19. // 向数据库添加数据
  20. func (f *Mongo) Add(owner string, refType string, object string) (string, error) {
  21.     // 做一些操作
  22.     return // 返回一个字符串和错误（成功时可能为 nil）
  23. }
  25. func (f *Mongo) Get(Uuid string) (dbinit.Object, bool) {
  26.     // 做一些操作
  27.     return // 返回一个对象和一个布尔值
  28. }

主程序：

  1. var selectedDb dbinit.Intfc
  3. commandLineInput := "mysql"
  5. if commandLineInput == "mysql" {
  6.     selectedDb = &mysqlConnector.Mysql{}
  7. } else if commandLineInput == "mongo" {
  8.     selectedDb = &mongoConnector.Mongo{}
  9. }
  11. err := selectedDb.Connect()
  12. if err != nil {
  13.     panic(err)
  14. }
  16. // 每次调用 API 时都会运行这段代码
  17. api.HandlerFoobar = foobar.handlerFunction(func(params foobar.Params) middleware.Responder {
  18.     data, err := selectedDb.Add(addStringA, addStringB, addStringC)
  19.     if err != nil {
  20.         // 做一些操作
  21.     }
  23.     return // API 响应
  24. })

但你也可以从 Intfc 接口中移除 Connect() error 方法，只使用 Add 和 Get 方法，但你需要更新包中的代码：

MySQL：

  1. // 连接到 MySQL，可以使用任何函数名
  2. func Connect() (*Mysql, error) {
  3.     connection, err := sql.Open("mysql", "yourusername:yourpassword@/yourdatabase")
  4.     if err != nil {
  5.         return nil, err
  6.     }
  7.     return &Mysql{conn: connection}, nil
  8. }

Mongo：

  1. // 连接到 MongoDB，可以使用任何函数名
  2. func Connect() (*Mongo, error) {
  3.     info := &mgo.DialInfo{
  4.         // 一些数据
  5.     }
  7.     s, err := mgo.DialWithInfo(info)
  8.     if err != nil {
  9.         return nil, err
  10.     }
  11.     return &Mongo{session: s}, nil
  12. }

主程序：

  1. var selectedDb dbinit.Intfc
  2. var err error
  3. commandLineInput := "mysql"
  5. if commandLineInput == "mysql" {
  6.     selectedDb, err = mysqlConnector.Connect()
  7. } else if commandLineInput == "mongo" {
  8.     selectedDb, err = mongoConnector.Connect()
  9. }
  11. if err != nil {
  12.     panic(err)
  13. }
英文:

If you want to preserve the interface with those methods, you should change a little your interface as:

Interface:

<!-- language: go -->

  1. // The interface that all connectors should have
  2. type Intfc interface {
  3.     // Connect to the database, if an error occur at the moment
  4.     // of connection, return the error
  5.     Connect() error
  6.     // Add returns a string, it returns an error if something occurs
  7.     Add(string, string, string) (string, error)
  8.     Get(string) (Object, bool)
  9. }

MySQL:

<!-- language: go -->

  1. type Mysql struct{
  2.     conn *sql.DB // contains the connection to the DB
  3. }
  5. // Connect to mysql
  6. func (f *Mysql) Connect() error {
  7.     conn, err := sql.Open(&quot;mysql&quot;, &quot;yourusername:yourpassword@/yourdatabase&quot;)
  8.     if err != nil {
  9.         return error
  10.     }
  11.     f.conn = conn
  12.     return nil
  13. }
  15. // Add item to DB
  16. func (f *Mysql) Add(owner string, refType string, object string) (string, error) {
  17.     // do something
  18.     return // a string and error
  19. }
  21. func (f *Mysql) Get(Uuid string) (dbinit.Object, bool) {
  22.     // do something
  23.     return // an object and a bool
  24. }

Mongo:

<!--language: go -->

  1. type Mongo struct{
  2.     session *mgo.Session
  3. }
  5. // Connect to mongo
  6. func (f *Mongo) Connect() error {
  7.     info := &amp;mgo.DialInfo{
  8.         // some data
  9.     }
  11.     session, err := mgo.DialWithInfo(info)
  12.     if err != nil {
  13.         return error
  14.     }
  15.     f.session = session
  16.     return nil
  17. }
  19. // Add item to DB
  20. func (f *Mongo) Add(owner string, refType string, object string) (string, error) {
  21.     // do something
  22.     return // a string and error (it could be nil at success)
  23. }
  25. func (f *Mongo) Get(Uuid string) (dbinit.Object, bool) {
  26.     // do something
  27.     return // an object and a bool
  28. }

Main:

<!-- language: go -->

  1. var selectedDb dbinit.Intfc
  3. commandLineInput := &quot;mysql&quot;
  5. if commandLineInput == &quot;mysql&quot; {
  6.     selectedDb = &amp;mysqlConnector.Mysql{}
  7. } else if commandLineInput == &quot;mongo&quot; {
  8.     selectedDb = &amp;mongoConnector.Mongo{}
  9. }
  11. err := selectedDb.Connect()
  12. if err != nil {
  13.     panic(err)
  14. }
  16. // this runs everytime the API is called
  17. api.HandlerFoobar = foobar.handlerFunction(func(params foobar.Params) middleware.Responder {
  18.     data, err := selectedDb.Add(addStringA, addStringB, addStringC)
  19.     if err != nil {
  20.         // do something
  21.     }
  23.     return // the API response
  24. })

But you also can remove the Connect() error method from Intfc and just use Add and Get, but you should update the packages like:

Mysql

<!-- language: go -->

  1. // Connect to mysql, it could be any function name
  2. func Connect() (*Mysql, error) {
  3.     connection, err := sql.Open(&quot;mysql&quot;, &quot;yourusername:yourpassword@/yourdatabase&quot;)
  4.     if err != nil {
  5.         return nil, error
  6.     }
  7.     return &amp;Mysql{conn: connection}
  8. }

Mongo

<!-- language: go -->

  1. // Connect to mongo, it could be any function name
  2. func Connect() (*Mongo, error) {
  3.     info := &amp;mgo.DialInfo{
  4.         // some data
  5.     }
  7.     s, err := mgo.DialWithInfo(info)
  8.     if err != nil {
  9.         return nil, error
  10.     }
  11.     return &amp;Mongo{session: s}
  12. }

Main

<!-- language: go -->

  1. var selectedDb dbinit.Intfc
  2. var err error
  3. commandLineInput := &quot;mysql&quot;
  5. if commandLineInput == &quot;mysql&quot; {
  6.     selectedDb, err = mysqlConnector.Connect()
  7. } else if commandLineInput == &quot;mongo&quot; {
  8.     selectedDb, err = mongoConnector.Connect()
  9. }
  11. if err != nil {
  12.     panic(err)
  13. }

答案2

得分: 1

详细说明一下我的评论，而不是

  1. type Intfc interface {
  2.     Connect() HERE_LIES_MY_PROBLEM
  3.     Add(string, string, string) string
  4.     Get(string) (Object, bool)
  5. }

你可以使用

  1. type Intfc interface {
  2.     Connect() DBClient
  3. }

和

  1. type DBClient interface {
  2.     Add(string, string, string) string
  3.     Get(string) (Object, bool)
  4. }
  6. type MySQLClient sql.DB
  7. type MongoClient mgo.Session
  9. func (f Mysql) Connect() DBCLient {
  11.     client, err = sql.Open("mysql", "yourusername:yourpassword@/yourdatabase")
  12.     if err != nil {
  13.         panic(err.Error())    
  14.     }
  16.     return MySQLClient(client)
  17. }
  19. func (f Mongo) Connect() DBClient {
  21.     info := &mgo.DialInfo{
  22.         Addrs:    []string{hosts},
  23.         Timeout:  60 * time.Second,
  24.         Database: database,
  25.         Username: username,
  26.         Password: password,
  27.     }
  29.     client, err := mgo.DialWithInfo(info)
  30.     if err != nil {
  31.         panic(err)
  32.     }
  34.     return MongoClient(client)
  35. }
  37. func (s *MySQLClient) Add(...) {
  38.     // ...
  39. }
  41. func (s *MongoClient) Add(...) {
  42.     // ...
  43. }
英文:

Elaborating on my comment, instead of

  1. type Intfc interface {
  2.     Connect() HERE_LIES_MY_PROBLEM
  3.     Add(string, string, string) string
  4.     Get(string) (Object, bool)
  5. }

you can use

  1. type Intfc interface {
  2.     Connect() DBClient
  3. }

and

  1. type DBClient interface {
  2.     Add(string, string, string) string
  3.     Get(string) (Object, bool)
  4. }
  6. type MySQLClient sql.DB
  7. type MongoClient mgo.Session
  9. func (f Mysql) Connect() DBCLient {
  11.     client, err = sql.Open(&quot;mysql&quot;, &quot;yourusername:yourpassword@/yourdatabase&quot;)
  12.     if err != nil {
  13.         panic(err.Error())    
  14.     }
  16.     return MySQLClient(client)
  17. }
  19. func (f Mongo) Connect() DBClient {
  21.     info := &amp;mgo.DialInfo{
  22.         Addrs:    []string{hosts},
  23.         Timeout:  60 * time.Second,
  24.         Database: database,
  25.         Username: username,
  26.         Password: password,
  27.     }
  29.     client, err := mgo.DialWithInfo(info)
  30.     if err != nil {
  31.         panic(err)
  32.     }
  34.     return MongoClient(client)
  35. }
  37. func (s *MySQLClient) Add(...) {
  38.     // ...
  39. }
  41. func (s *MongoClient) Add(...) {
  42.     // ...
  43. }

答案3

得分: 1

我认为，接口Intfc（或更好的名称DbIntfc）应该只有Get和Add两个方法。

而且应该存在另一个函数 - 但不是DbIntfc的一部分，它返回连接到MySql或MongoDb的DbIntfc。让我们看一下：

  1. type MySqlDbIntfc struct{
  2.    db *Sql.DB
  3. }
  5. // 连接到mysql
  6. func NewMySqlDbIntfc() (DbIntfc,error) {
  7.     // 请不要在这样的抽象方法中使用panic
  8.     client, err := sql.Open("mysql", "yourusername:yourpassword@/yourdatabase")
  9.     if err != nil {
  10.         return nil, err
  11.     }
  12.     return &MySqlDbIntfc{client}, nil
  13. }
  15. func (mySqlDb *MySqlDbIntfc) Get(Uuid string) (dbinit.Object, error) {
  16.   var obj dbinit.Object
  17.   err := mySqlDb.db.QueryRow("SELECT uuid, object, deleted FROM myTable WHERE uuid=?", Uuid).Scan(&obj.Uuid, &obj.Object, &obj.Deleted)
  18.   if err != nil {
  19.     return dbinit.Object{}, err
  20.   }
  21.   return obj, nil
  22. }

实现NewMgoDbIntfc应该很简单，包括NewMgoDbIntfc.Add/Get方法。

而且决定是使用NewMySqlDbIntfc还是NewMgoDbIntfc也应该很容易。

英文:

I think, that interface Intfc (or better name DbIntfc) should have only methods Get and Add.

And it should exist another function - but not a part of DbIntfc, that returns DbIntfc - that connects to MySql or MongoDb. Let's look:

  1.     type MySqlDbIntfc struct{
  2.        db *Sql.DB
  3.     }
  4.     
  5.     // Connect to mysql
  6.     func NewMySqlDbIntfc() (DbIntfc,error) {
  7.         // Please do not prefer panic in such abstract methods
  8.         client, err := sql.Open(&quot;mysql&quot;, &quot;yourusername:yourpassword@/yourdatabase&quot;)
  9.         if err != nil {
  10.             return nil, err
  11.         }
  12.         return &amp;MySqlDbIntfc{client}, nil
  13.     }
  15.     func (mySqlDb *MySqlDbIntfc) Get(Uuid string) (dbinit.Object, error) {
  16.       var obj dbinit.Object
  17.       err := mySqlDb.db.QueryRow(&quot;SELECT uuid, object, deleted FROM myTable WHERE uuid=?&quot;, Uuid).Scan(&amp;obj.Uuid, &amp;obj.Object, &amp;obj.Deleted)
  18.       if err != nil {
  19.         return dbinit.Object{}, err
  20.       }
  21.       return obj, nil
  22.     }

And implemention NewMgoDbIntfc should be easy, including methods NewMgoDbIntfc.Add/Get.

And decision whether use NewMySqlDbIntfc or NewMgoDbIntfc should also be easy.

答案4

得分: 0

> 1. 在代码中的HERE_LIES_MY_PROBLEM的位置应该填写什么？

根据源代码，DialWithInfo()函数返回error和*Session，它们都是来自mgo包的结构体。所以你可以将HERE_LIES_MY_PROBLEM替换为*mgo.Session。

> 2. 我对处理这些事情的Go范式理解错了吗？

关于连接多个数据库的惯用方法，我认为有很多不同的观点。以下是我对连接Mongo和Redis的一些想法：

  1. var logger *log.Logger
  3. func init() {
  4. 	logger = log.New(os.Stderr,
  5. 		"Database :: ",
  6. 		log.Ldate|log.Ltime|log.Lshortfile)
  7. }
  9. // 在这里创建不同类型的数据库连接。
  10. func SystemConnection() map[string]interface{} {
  11. 	listConnection := make(map[string]interface{})
  12. 	var err error
  13. 	// 创建Redis连接
  14. 	redisConn := RedisHost{
  15. 		Address:  "localhost:6379",
  16. 		Password: "",
  17. 		DB:       0,
  18. 	}
  20. 	redisConnection, err := redisConn.Connect()
  21. 	if err != nil {
  22. 		panic(err)
  23. 	}
  25. 	// 创建MongoDB连接
  26. 	mongo := MongoHost{
  27. 		Host: "localhost",
  28. 		Port: "27017",
  29. 	}
  30. 	mongoConnection := mongo.Connect()
  32. 	listConnection["redis"] = redisConnection
  33. 	listConnection["mongodb"] = mongoConnection
  34. 	return listConnection
  35. }
  37. func GetMongo() *mgo.Session {
  38. 	// 创建MongoDB连接
  39. 	mongo := MongoHost{
  40. 		Host: "localhost",
  41. 		Port: "27017",
  42. 	}
  43. 	mongoConnection := mongo.Connect()
  45. 	return mongoConnection
  46. }

你可以从这里查看源代码。

要使用上述代码，在你的主程序的init()函数中调用SystemConnection()，像这样：

  1. func init(){
  2. 	listConnection := database.SystemConnection()
  4. 	// 获取Redis连接，将其转换为*redis.Client类型。
  5. 	redisConn := listConnection["redis"].(*redis.Client)
  7. 	// 获取MongoDB连接。
  8. 	mongoConn := listConnection["mongodb"].(*mgo.Session)
  9. }

再次说明，这种方法是我个人的观点，可能还有其他适合你的方法。

英文:

> 1. What should be in the places where I have HERE_LIES_MY_PROBLEM in the code?

As you can see from the source that the DialWithInfo() return error and *Session from mgo package and that is a struct. so you can replace your HERE_LIES_MY_PROBLEM with *mgo.Session

> 2. do I get the Go paradigm wrong for dealing with these things?

As far as the idiomatic to connect with multiple databases there are many opinion I think. And here is some of my thought to connect with mongo and redis :

  1. var logger *log.Logger
  3. func init() {
  4. 	logger = log.New(os.Stderr,
  5. 		&quot;Database :: &quot;,
  6. 		log.Ldate|log.Ltime|log.Lshortfile)
  7. }
  9. //we create different types of databse connection here.
  10. func SystemConnection() map[string]interface{} {
  11. 	listConnection := make(map[string]interface{})
  12. 	var err error
  13. 	// create redis connection
  14. 	redisConn := RedisHost{
  15. 		Address:  &quot;localhost:6379&quot;,
  16. 		Password: &quot;&quot;,
  17. 		DB:       0,
  18. 	}
  20. 	redisConnection, err := redisConn.Connect()
  21. 	if err != nil {
  22. 		panic(err)
  23. 	}
  25. 	//create mongodb connection
  26. 	mongo := MongoHost{
  27. 		Host: &quot;localhost&quot;,
  28. 		Port: &quot;27017&quot;,
  29. 	}
  30. 	mongoConnection := mongo.Connect()
  32. 	listConnection[&quot;redis&quot;] = redisConnection
  33. 	listConnection[&quot;mongodb&quot;] = mongoConnection
  34. 	return listConnection
  35. }
  37. func GetMongo() *mgo.Session {
  38. 	//create mongodb connection
  39. 	mongo := MongoHost{
  40. 		Host: &quot;localhost&quot;,
  41. 		Port: &quot;27017&quot;,
  42. 	}
  43. 	mongoConnection := mongo.Connect()
  45. 	return mongoConnection
  46. }

you can see the source from here

To use above code you can call the SystemConnection() on your init() in your main program. like this :

  1. func init(){
  2. 	listConnection := database.SystemConnection()
  4. 	//getting redis connection convert it from interface to *redisClient.
  5. 	redisConn := listConnection[&quot;redis&quot;].(*redis.Client)
  7. 	// get postgre connection.
  8. 	mongoConn := listConnection[&quot;mongodb&quot;].(*mgo.Session)
  10. }

Again this approach is my opinion there are others that might be suit with yours.

huangapple
  • 本文由 发表于 2017年5月3日 17:17:31
  • 转载请务必保留本文链接：https://go.coder-hub.com/43755892.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定