/main.go
package main
import (
  "net/http"
)
// Как было указано выше, поскольку у нас планируется всего по одному экземпляру
// на эти три сервиса, мы объявим экземпляры-синглтоны,
// и убедимся, что пользуемся ими только для доступа к этим сервисам.
var (
  userDBInstance   userDB
  configDBInstance configDB
  rolePermissions  map[string][]string
)
func main() {
  // Предполагается, что далее наши экземпляры синглтонов будут
  // инициализироваться, и отвечает за их инициализацию
  // инициатор.
  // Главная функция будет проделывать это над конкретной
  // реализацией, а тестовые кейсы, если мы планируем их иметь,
  // могут пользоваться сымитированной реализацией.
  userDBInstance = &someUserDB{}
  configDBInstance = &someConfigDB{}
  initPermissions()
  http.HandleFunc("/", UserPermissionsByID)
  http.ListenAndServe(":8080", nil)
}
// Таким образом права доступа, хранящиеся в памяти, будут оставаться актуальными.
func initPermissions() {
  rolePermissions = configDBInstance.allPermissions()
  go func() {
    for {
      time.Sleep(time.Hour)
      rolePermissions = configDBInstance.allPermissions()
    }
  }()
}
/database.go
package main
// Мы используем интерфейсы в качестве типов экземпляров нашей базы данных,
// чтобы можно было писать тесты и использовать имитационные реализации.
type userDB interface {
  userRoleByID(id string) string
}
// Обратите внимание на именование `someConfigDB`. В конкретных случаях мы
// используем некоторую реализацию БД и соответственно именуем наши структуры
// Например, при использовании MongoDB, мы назовем нашу конкретную структуру
// `mongoConfigDB`. При работе с тестовыми кейсами также может быть объявлена
// имитационная реализация `mockConfigDB`.
type someUserDB struct {}
func (db *someUserDB) userRoleByID(id string) string {
  // Для ясности опускаем детали реализации...
}
type configDB interface {
  allPermissions() map[string][]string // отображается с роли на ее права доступа
}
type someConfigDB struct {}
func (db *someConfigDB) allPermissions() map[string][]string {
  // реализация
}
/handler.go
package main
import (
  "fmt"
  "net/http"
  "strings"
)
func UserPermissionsByID(w http.ResponseWriter, r *http.Request) {
  id := r.URL.Query()["id"][0]
  role := userDBInstance.userRoleByID(id)
  permissions := rolePermissions[role]
  fmt.Fprint(w, strings.Join(permissions, ", "))
}

/main.go
package main
// Обратите внимание: пакет main – единственный, импортирующий
// другие пакеты сверх пакета с определениями.
import (
  "github.com/myproject/config"
  "github.com/myproject/database"
  "github.com/myproject/definition"
  "github.com/myproject/handler"
  "net/http"
)
func main() {
  // В данном подходе также используются экземпляры синглтона, и,
  // опять же, инициатор отвечает за то, чтобы они
  // были инициализированы.
  definition.UserDBInstance = &database.SomeUserDB{}
  definition.ConfigDBInstance = &database.SomeConfigDB{}
  config.InitPermissions()
  http.HandleFunc("/", handler.UserPermissionsByID)
  http.ListenAndServe(":8080", nil)
}
/definition/database.go
package definition
// Обратите внимание, что при данном подходе и экземпляр синглтона,
// и тип его интерфейса объявляются в пакете с определениями.
// Убедитесь, что в этом пакете не содержится никакой логики; в
// противном случае в него, возможно, потребуется импортировать другие пакеты,
// и его нейтральная суть будет нарушена.
var (
  UserDBInstance   UserDB
  ConfigDBInstance ConfigDB
)
type UserDB interface {
  UserRoleByID(id string) string
}
type ConfigDB interface {
  AllPermissions() map[string][]string // отображение с роли на права доступа
}
/definition/config.go
package definition
var RolePermissions map[string][]string
/database/user.go
package database
type SomeUserDB struct{}
func (db *SomeUserDB) UserRoleByID(id string) string {
  // реализация
}
/database/config.go
package database
type SomeConfigDB struct{}
func (db *SomeConfigDB) AllPermissions() map[string][]string {
  // реализация
}
/config/permissions.go
package config
import (
  "github.com/myproject/definition"
  "time"
)
// Поскольку пакет с определениями не должен содержать никакой логики,
// управление конфигурацией реализуется в пакете config.
func InitPermissions() {
  definition.RolePermissions = definition.ConfigDBInstance.AllPermissions()
  go func() {
    for {
      time.Sleep(time.Hour)
      definition.RolePermissions = definition.ConfigDBInstance.AllPermissions()
    }
  }()
}
/handler/user_permissions_by_id.go
package handler
import (
  "fmt"
  "github.com/myproject/definition"
  "net/http"
  "strings"
)
func UserPermissionsByID(w http.ResponseWriter, r *http.Request) {
  id := r.URL.Query()["id"][0]
  role := definition.UserDBInstance.UserRoleByID(id)
  permissions := definition.RolePermissions[role]
  fmt.Fprint(w, strings.Join(permissions, ", "))
}

/main.go
package main
// Обратите внимание: главный пакет – единственный, импортирующий
// другие локальные пакеты.
import (
  "github.com/myproject/config"
  "github.com/myproject/database"
  "github.com/myproject/handler"
  "net/http"
)
func main() {
  userDB := &database.SomeUserDB{}
  configDB := &database.SomeConfigDB{}
  permissionStorage := config.NewPermissionStorage(configDB)
  h := &handler.UserPermissionsByID{UserDB: userDB, PermissionsStorage: permissionStorage}
  http.Handle("/", h)
  http.ListenAndServe(":8080", nil)
}
/database/user.go
package database
type SomeUserDB struct{}
func (db *SomeUserDB) UserRoleByID(id string) string {
  // реализация
}
/database/config.go
package database
type SomeConfigDB struct{}
func (db *SomeConfigDB) AllPermissions() map[string][]string {
  // реализация
}
/config/permissions.go
package config
import (
  "time"
)
// Здесь мы определяем интерфейс, представляющий наши локальные потребности,
// предъявляемые к конфигурационной БД, а именно,
// метод `AllPermissions`.
type PermissionDB interface {
  AllPermissions() map[string][]string // отображение роли на права доступа
}
// Затем мы импортируем сервис, который будет предоставлять
// права доступа из памяти, и, чтобы использовать этот сервис, другому
// пакету потребуется объявить локальный интерфейс
type PermissionStorage struct {
  permissions map[string][]string
}
func NewPermissionStorage(db PermissionDB) *PermissionStorage {
  s := &PermissionStorage{}
  s.permissions = db.AllPermissions()
  go func() {
    for {
      time.Sleep(time.Hour)
      s.permissions = db.AllPermissions()
    }
  }()
  return s
}
func (s *PermissionStorage) RolePermissions(role string) []string {
  return s.permissions[role]
}
/handler/user_permissions_by_id.go
package handler
import (
  "fmt"
  "net/http"
  "strings"
)
// объявление наших локальных потребностей из пользовательского экземпляра бд
type UserDB interface {
  UserRoleByID(id string) string
}
// ... и наших локальных потребностей из долговременного хранилища данных в памяти.
type PermissionStorage interface {
  RolePermissions(role string) []string
}
// Наконец наш обработчик не может быть полностью функциональным,
// поскольку требует ссылок на экземпляры, не являющиеся синглтонами.
type UserPermissionsByID struct {
  UserDB             UserDB
  PermissionsStorage PermissionStorage
}
func (u *UserPermissionsByID) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  id := r.URL.Query()["id"][0]
  role := u.UserDB.UserRoleByID(id)
  permissions := u.PermissionsStorage.RolePermissions(role)
  fmt.Fprint(w, strings.Join(permissions, ", "))
}