I'm currently learning Go and would appreciate people's insights on how best to reduce the amount of duplicate code.
The folder structure of the relevant parts is as follows:
. ├── http │ ├── handlers │ └── routes ├── models │ └── dto ├── specifications └── store └── postgres
In my specations
folder I have 2 "storage" interfaces:
type TaskStore interface { CreateTask(ctx context.Context, input dto.TaskCreate) error UpdateTask(ctx context.Context, id int, input dto.TaskUpdate) error GetTask(ctx context.Context, id int) (dto.TaskResult, error) ListTasks(ctx context.Context) ([]dto.TaskResult, error) DeleteTask(ctx context.Context, id int) error } type TagStore interface { CreateTag(ctx context.Context, input dto.TagCreate) error RenameTag(ctx context.Context, id int, input dto.TagUpdate) error ListTags(ctx context.Context) ([]dto.TagResult, error) GetTag(ctx context.Context, id int) (dto.TagResult, error) DeleteTag(ctx context.Context, id int) error }
store/postgres
folder contains the implementation of tasks and tags (repository mode).
Questions I saw:
In my handlers
folder I have a struct that accepts input from one of the storage interfaces:
type TaskHandler struct { store specifications.TaskStore } func NewTaskHandler(store specifications.TaskStore) TaskHandler { return TaskHandler{ store: store, } }
type TagHandler struct { store specifications.TagStore } func NewTagHandler(store specifications.TagStore) TagHandler { return TagHandler{ store: store, } }
These handlers contain methods that will be mapped to api paths:
func (h TaskHandler) List() http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { tasks, err := h.store.ListTasks(r.Context()) if err != nil { log.Err(err).Msg("failed to retrieve tasks") w.WriteHeader(http.StatusInternalServerError) return } render.JSON(w, r, tasks) } }
func (h TagHandler) List() http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { tags, err := h.store.ListTags(r.Context()) if err != nil { log.Err(err).Msg("failed to retrieve tags") w.WriteHeader(http.StatusInternalServerError) return } render.JSON(w, r, tags) } }
You'll notice that the List
methods on each handler are basically the same, except for the interface used by each store.
How can I change this setting to reduce duplicate code?
I initially thought I could use generics to solve this problem, for example:
type EntityStore[CreateDto any, UpdateDto any, ResultDto any] interface { Create(ctx context.Context, input CreateDto) error Update(ctx context.Context, id int, input UpdateDto) error List(ctx context.Context) ([]ResultDto, error) Get(ctx context.Context, id int) (ResultDto, error) Delete(ctx context.Context, id int) error }
But this means mapping each type into a handler, which I don't think is a practical solution.
Any suggestions on how to better map my DTOs and interfaces?
You can have a helper function
func ListHandler[T any](name string, lister func(ctx context.Context) ([]T, error)) func(w http.ResponseWriter, r *http.Request) { return func(w http.ResponseWriter, r *http.Request) { list, err := lister(r.Context()) if err != nil { log.Err(err).Msg("failed to retrieve " + name) w.WriteHeader(http.StatusInternalServerError) return } render.JSON(w, r, list) } }
Then you will have
func (h TaskHandler) List() http.HandlerFunc { return ListHandler("tasks", h.store.ListTasks) } func (h TagHandler) List() http.HandlerFunc { return ListHandler("tags", h.store.ListTags) }
The above is the detailed content of Reduce the amount of duplicate code when mapping DTOs in Go. For more information, please follow other related articles on the PHP Chinese website!