自定义回调处理是最常见的接口开发实现，我们往往只需要对接口中的部分实现进行替换修改，以在原有的实现逻辑中注入自定义的逻辑实现。我们来看一个自定义回调处理的示例，我们需要将所有执行的SQL语句记录到monitor表中，以方便于进行SQL审计。

    为简化示例编写，我们这里实现了一个自定义的MySQL驱动，该驱动继承于gdb模块中已经实现的DriverMysql，并按照需要修改覆盖相应的接口方法。由于所有的SQL语句执行必定会通过DoQuery或者DoExec接口，因此我们在自定义的驱动中实现并覆盖这两个接口方法即可。

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

    我们看到，这里在包初始化方法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"