How to use reflection type for gorm to generalize an api function

When implementing ORM (Object-Relational Mapping) with the GORM library in Go, you can enhance the generality of API functions through reflection. This approach reduces code duplication and improves maintainability and extensibility.

How to Use GORM's Reflection Types to Genericize API Functions

1. Define a generic interface

   First, define a generic interface that includes all methods every model must implement. For example, each model should be able to save and delete itself.

   go
   type ModelInterface interface {
       Save() error
       Delete() error
   }

2. Implement this interface for each model

   Then, implement these methods for each database model. This ensures all models adhere to the same specification and can be processed by generic API functions.

   go
   type User struct {
       gorm.Model
       Name string
   }
   
   func (u *User) Save() error {
       return DB.Save(u).Error
   }
   
   func (u *User) Delete() error {
       return DB.Delete(u).Error
   }

3. Create generic API functions

   Use reflection to create generic API functions. Reflection enables dynamic method invocation at runtime without specifying method calls at compile time.

   go
   func GenericSave(entity ModelInterface) error {
       return entity.Save()
   }
   
   func GenericDelete(entity ModelInterface) error {
       return entity.Delete()
   }

4. Use generic API functions

   Finally, use these generic API functions in your code. Since all models implement ModelInterface, you can pass any model instance to these functions.

   go
   user := &User{Name: "John Doe"}
   err := GenericSave(user)
   if err != nil {
       log.Fatalf("Failed to save user: %s", err)
   }
   
   err = GenericDelete(user)
   if err != nil {
       log.Fatalf("Failed to delete user: %s", err)
   }

Example Explanation

In the above example, we define a ModelInterface interface containing Save() and Delete() methods. Each model (e.g., User model) implements this interface. This allows creating generic GenericSave and GenericDelete functions that accept ModelInterface-typed parameters, achieving true function genericity.

By this approach, adding new models is straightforward as long as they implement the ModelInterface interface. This enables reusing existing generic functions, significantly enhancing code maintainability and extensibility.