自定义回调处理是最常见的接口开发实现，开发中只需要对接口中的部分方法进行替换与修改，在驱动默认实现逻辑中注入自定义逻辑。所有的SQL语句执行必定会通过DoQuery或者DoExec或者 DoFilter接口，根据需求在自定义的驱动中实现并覆盖相关接口方法实现所需功能即可。

    我们来看一个自定义回调处理的示例，现需要将所有执行的SQL语句记录到monitor表中，以方便于进行SQL审计。为简化示例编写，以下代码实现了一个自定义的MySQL驱动，该驱动继承于drivers下mysql模块内已经实现的DriverMysql。

    自2.1.0版本之后,ORM驱动模块独立，需要开发者手动引入至项目内。

    以mysql为例，需引入 github.com/gogf/gf/contrib/drivers/mysql/v2 至go.mod，并导入到项目中使用。

    其它驱动详细请至 https://github.com/gogf/gf/tree/master/contrib/drivers 查看。

    1. package driver
    3. import (
    4.     "context"
    5.     "database/sql"
    6.     "github.com/gogf/gf/contrib/drivers/mysql/v2"
    7.     "github.com/gogf/gf/v2/database/gdb"
    8.     "github.com/gogf/gf/v2/os/gtime"
    9.     "github.com/gogf/gf/v2/text/gstr"
    10.     "github.com/gogf/gf/v2/util/gconv"
    11.     "strconv"
    12. )
    14. // MyDriver is a custom database driver, which is used for testing only.
    15. // For simplifying the unit testing case purpose, MyDriver struct inherits the mysql driver
    16. // gdb.DriverMysql and overwrites its functions DoQuery and DoExec.
    17. // So if there's any sql execution, it goes through MyDriver.DoQuery/MyDriver.DoExec firstly
    18. // and then gdb.DriverMysql.DoQuery/gdb.DriverMysql.DoExec.
    19. // You can call it sql "HOOK" or "HiJack" as your will.
    20. type MyDriver struct {
    21.     *mysql.DriverMysql
    22. }
    24. var (
    25.     // customDriverName is my driver name, which is used for registering.
    26.     customDriverName = "MyDriver"
    27. )
    29. func init() {
    30.     // It here registers my custom driver in package initialization function "init".
    31.     // You can later use this type in the database configuration.
    32.     if err := gdb.Register(customDriverName, &MyDriver{}); err != nil {
    33.         panic(err)
    34.     }
    35. }
    37. // New creates and returns a database object for mysql.
    38. // It implements the interface of gdb.Driver for extra database driver installation.
    39. func (d *MyDriver) New(core *gdb.Core, node *gdb.ConfigNode) (gdb.DB, error) {
    40.     return &MyDriver{
    41.         &mysql.DriverMysql{
    42.             Core: core,
    43.         },
    44.     }, nil
    45. }
    47. // DoQuery commits the sql string and its arguments to underlying driver
    48. // through given link object and returns the execution result.
    49. func (d *MyDriver) DoQuery(ctx context.Context, link gdb.Link, sql string, args ...interface{}) (rows gdb.Result, err error) {
    50.     tsMilli := gtime.TimestampMilli()
    51.     rows, err = d.DriverMysql.DoQuery(ctx, link, sql, args...)
    52.     _, _ = link.ExecContext(ctx,
    53.         "INSERT INTO `monitor`(`sql`,`cost`,`time`,`error`) VALUES(?,?,?,?)",
    54.         gdb.FormatSqlWithArgs(sql, args),
    55.         gtime.TimestampMilli()-tsMilli,
    56.         gtime.Now(),
    57.         err,
    58.     )
    59.     return
    60. }
    62. // DoExec commits the query string and its arguments to underlying driver
    63. // through given link object and returns the execution result.
    64. func (d *MyDriver) DoExec(ctx context.Context, link gdb.Link, sql string, args ...interface{}) (result sql.Result, err error) {
    65.     tsMilli := gtime.TimestampMilli()
    66.     result, err = d.DriverMysql.DoExec(ctx, link, sql, args...)
    67.     _, _ = link.ExecContext(ctx,
    68.         "INSERT INTO `monitor`(`sql`,`cost`,`time`,`error`) VALUES(?,?,?,?)",
    69.         gdb.FormatSqlWithArgs(sql, args),
    70.         gtime.TimestampMilli()-tsMilli,
    71.         gtime.Now(),
    72.         err,
    73.     )
    74.     return
    75. }
    77. // DoFilter is a hook function, which filters the sql and its arguments before it's committed to underlying driver.
    78. // The parameter `link` specifies the current database connection operation object. You can modify the sql
    79. // string `sql` and its arguments `args` as you wish before they're committed to driver.
    80. func (d *MyDriver) DoFilter(ctx context.Context, link gdb.Link, sql string, args []interface{}) (newSql string, newArgs []interface{}, err error) {
    81.     //Filter sql Step1
    82.     sql_new := gstr.Replace(sql, "\n", "")
    84.     //Filter sql Step2
    85.     sql_new = gstr.Replace(sql_new, "\t", "")
    86.     //... Filter what you want ...
    88.     //Filter args Step1
    89.     for _, v := range args {
    90.         switch v.(type) {
    91.         case gdb.Map:
    92.             //Do it what you wan
    93.         case string:
    94.             //Do it what you wan
    95.         }
    96.     }
    97.     return sql_new, args, nil
    98. }
    100. // ConvertDataForRecord is a very important function, which does converting for any data that
    101. // will be inserted into table/collection as a record.
    102. //
    103. // The parameter `value` should be type of *map/map/*struct/struct.
    104. // It supports embedded struct definition for struct.
    105. func (d *MyDriver) ConvertDataForRecord(ctx context.Context, data interface{}) (map[string]interface{}, error) {
    106.     //this hook is convert data to map[string]interface{}
    107.     result := make(map[string]interface{}, 0)
    109.     //like this
    110.     switch data.(type) {
    111.     case gdb.Map:
    112.         result = gconv.Map(data)
    113.     case gdb.List:
    114.         for k, v := range data.(gdb.List) {
    115.             result[strconv.Itoa(k)] = gconv.Map(v)
    116.         }
    117.         //case other type,do it what you want
    118.     }
    119.     return result, nil
    120. }

    我们看到，这里在包初始化方法init中使用了gdb.Register("MyDriver", &MyDriver{})来注册了了一个自定义名称的驱动。我们也可以通过gdb.Register("mysql", &MyDriver{})来覆盖已有的框架mysql驱动为自己的驱动。

    驱动名称mysql为框架默认的DriverMysql驱动的名称。

    由于这里我们使用了一个新的驱动名称MyDriver，因此在gdb配置中的type数据库类型时，需要填写该驱动名称。以下是一个使用配置的示例：

    1. database:
    2.   default:
    3.   - link: "MyDriver:root:12345678@tcp(127.0.0.1:3306)/user"