如何方便地在项目初始化时实现所有mapper？

看作者提供的例子都是通过扫描单一文件然后写入结构体的，这样的话意味着我项目初始化的时候需要手动进行结构体的初始化并扫描mapper目录，然后通过判断文件名的形式写入，一旦mapper变多就会让代码看着十分的臃肿，每次添加新的mapper也需要去修改代码。

这是我目前的实现方式，不知道项目是否已经有统一的写入方式，或者更好的解决方案能在每次添加新的mapper时不对这块代码进行维护？

func initMapperImpl() {
    mapperImpl = make(map[string]interface{})
    mapperImpl["doorMapperImpl"] = new(DoorMapperImpl)
    mapperImpl["roomMapperImpl"] = new(RoomMapperImpl)
    mapperImpl["customerMapperImpl"] = new(CustomerMapperImpl)
    mapperImpl["communityMapperImpl"] = new(CommunityMapperImpl)

    var mapperPaths []string

    mapperPaths, _ = util.GetAllFile("/mnt/code/reinhardtv1/mapper", mapperPaths)
    for _, str := range mapperPaths {
        c, _ := ioutil.ReadFile(str)
        name := str[strings.LastIndex(str, "/")+1:len(str)-4] + "Impl"
        fmt.Println(name)
        switch name {
        case "doorMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
        case "roomMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
        case "communityMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
        case "customerMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
        }
    }
}

看作者提供的例子都是通过扫描单一文件然后写入结构体的，这样的话意味着我项目初始化的时候需要手动进行结构体的初始化并扫描mapper目录，然后通过判断文件名的形式写入，一旦mapper变多就会让代码看着十分的臃肿，每次添加新的mapper也需要去修改代码。

这是我目前的实现方式，不知道项目是否已经有统一的写入方式，或者更好的解决方案能在每次添加新的mapper时不对这块代码进行维护？
func initMapperImpl() {
  mapperImpl = make(map[string]interface{})
  mapperImpl["doorMapperImpl"] = new(DoorMapperImpl)
  mapperImpl["roomMapperImpl"] = new(RoomMapperImpl)
  mapperImpl["customerMapperImpl"] = new(CustomerMapperImpl)
  mapperImpl["communityMapperImpl"] = new(CommunityMapperImpl)

  var mapperPaths []string

  mapperPaths, _ = util.GetAllFile("/mnt/code/reinhardtv1/mapper", mapperPaths)
  for _, str := range mapperPaths {
      c, _ := ioutil.ReadFile(str)
      name := str[strings.LastIndex(str, "/")+1:len(str)-4] + "Impl"
      fmt.Println(name)
      switch name {
      case "doorMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
      case "roomMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
      case "communityMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
      case "customerMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
      }
  }
}

Readme.md中文介绍里面有写明的，使用代码扫描你的model层结构体生成xml

功能：XML/Mapper生成器- 根据struct结构体生成*mapper.xml

  //step1 定义你的数据库模型,必须包含 json注解（默认为数据库字段）, gm:""注解指定 值是否为 id,version乐观锁,logic逻辑软删除
  type UserAddress struct {
    Id            string `json:"id" gm:"id"`
    UserId        string `json:"user_id"`
    RealName      string `json:"real_name"`
    Phone         string `json:"phone"`
    AddressDetail string `json:"address_detail"`

    Version    int       `json:"version" gm:"version"`
    CreateTime time.Time `json:"create_time"`
    DeleteFlag int       `json:"delete_flag" gm:"logic"`
}

第二步，在你项目main 目录下建立一个 XmlCreateTool.go 内容如下

func main() {
var bean = UserAddress{} //此处只是举例，应该替换为你自己的数据库模型
GoMybatis.OutPutXml(reflect.TypeOf(bean).Name()+"Mapper.xml", GoMybatis.CreateXml("biz_"+GoMybatis.StructToSnakeString(bean), bean))
}

第三步，执行命令，在当前目录下得到 UserAddressMapper.xml文件
```
go run XmlCreateTool.go
```

以下是自动生成的xml文件内容

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "https://raw.githubusercontent.com/zhuxiujia/GoMybatis/master/mybatis-3-mapper.dtd">
<mapper>
<!--logic_enable 逻辑删除字段-->
<!--logic_deleted 逻辑删除已删除字段-->
<!--logic_undelete 逻辑删除 未删除字段-->
<!--version_enable 乐观锁版本字段,支持int,int8,int16,int32,int64-->
<resultMap id="BaseResultMap" tables="biz_user_address">
<id column="id" property="id"/>
<result column="id" property="id" langType="string"   />
<result column="user_id" property="user_id" langType="string"   />
<result column="real_name" property="real_name" langType="string"   />
<result column="phone" property="phone" langType="string"   />
<result column="address_detail" property="address_detail" langType="string"   />
<result column="version" property="version" langType="int" version_enable="true"  />
<result column="create_time" property="create_time" langType="Time"   />
<result column="delete_flag" property="delete_flag" langType="int"  logic_enable="true" logic_undelete="1" logic_deleted="0" />
</resultMap>
</mapper>

看作者提供的例子都是通过扫描单一文件然后写入结构体的，这样的话意味着我项目初始化的时候需要手动进行结构体的初始化并扫描mapper目录，然后通过判断文件名的形式写入，一旦mapper变多就会让代码看着十分的臃肿，每次添加新的mapper也需要去修改代码。这是我目前的实现方式，不知道项目是否已经有统一的写入方式，或者更好的解决方案能在每次添加新的mapper时不对这块代码进行维护？
func initMapperImpl() {
    mapperImpl = make(map[string]interface{})
    mapperImpl["doorMapperImpl"] = new(DoorMapperImpl)
    mapperImpl["roomMapperImpl"] = new(RoomMapperImpl)
    mapperImpl["customerMapperImpl"] = new(CustomerMapperImpl)
    mapperImpl["communityMapperImpl"] = new(CommunityMapperImpl)

    var mapperPaths []string

    mapperPaths, _ = util.GetAllFile("/mnt/code/reinhardtv1/mapper", mapperPaths)
    for _, str := range mapperPaths {
        c, _ := ioutil.ReadFile(str)
        name := str[strings.LastIndex(str, "/")+1:len(str)-4] + "Impl"
        fmt.Println(name)
        switch name {
        case "doorMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
        case "roomMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
        case "communityMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
        case "customerMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
        }
    }
}

Readme.md中文介绍里面有写明的，使用代码扫描你的model层结构体生成xml

功能：XML/Mapper生成器- 根据struct结构体生成*mapper.xml

  //step1 定义你的数据库模型,必须包含 json注解（默认为数据库字段）, gm:""注解指定 值是否为 id,version乐观锁,logic逻辑软删除
  type UserAddress struct {
  Id            string `json:"id" gm:"id"`
  UserId        string `json:"user_id"`
  RealName      string `json:"real_name"`
  Phone         string `json:"phone"`
  AddressDetail string `json:"address_detail"`

  Version    int       `json:"version" gm:"version"`
  CreateTime time.Time `json:"create_time"`
  DeleteFlag int       `json:"delete_flag" gm:"logic"`
}

第二步，在你项目main 目录下建立一个 XmlCreateTool.go 内容如下

func main() {
  var bean = UserAddress{} //此处只是举例，应该替换为你自己的数据库模型
  GoMybatis.OutPutXml(reflect.TypeOf(bean).Name()+"Mapper.xml", GoMybatis.CreateXml("biz_"+GoMybatis.StructToSnakeString(bean), bean))
}

第三步，执行命令，在当前目录下得到 UserAddressMapper.xml文件

go run XmlCreateTool.go

以下是自动生成的xml文件内容

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://raw.githubusercontent.com/zhuxiujia/GoMybatis/master/mybatis-3-mapper.dtd">
<mapper>
    <!--logic_enable 逻辑删除字段-->
    <!--logic_deleted 逻辑删除已删除字段-->
    <!--logic_undelete 逻辑删除 未删除字段-->
    <!--version_enable 乐观锁版本字段,支持int,int8,int16,int32,int64-->
    <resultMap id="BaseResultMap" tables="biz_user_address">
    <id column="id" property="id"/>
  <result column="id" property="id" langType="string"   />
  <result column="user_id" property="user_id" langType="string"   />
  <result column="real_name" property="real_name" langType="string"   />
  <result column="phone" property="phone" langType="string"   />
  <result column="address_detail" property="address_detail" langType="string"   />
  <result column="version" property="version" langType="int" version_enable="true"  />
  <result column="create_time" property="create_time" langType="Time"   />
  <result column="delete_flag" property="delete_flag" langType="int"  logic_enable="true" logic_undelete="1" logic_deleted="0" />
    </resultMap>
</mapper>

emmm，我不是这个意思，就是mapper是已经生成完的，但是使用的时候是需要执行WriteMapperPtr()这个方法将mapper和结构体绑定，而在这个绑定的过程中需要自己去手动new结构体，并对每一个结构体执行WriteMapperPtr()。之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用，这样就不需要使用者每次新增模版文件的时候手动去绑定一次。我想知道gomybatis是否有做类似的功能，还是每个mapper在使用的时候都需要手动WriteMapperPtr()一次，就像我这段代码：

case "doorMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
case "roomMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
case "communityMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
case "customerMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)

看作者提供的例子都是通过扫描单一文件然后写入结构体的，这样的话意味着我项目初始化的时候需要手动进行结构体的初始化并扫描mapper目录，然后通过判断文件名的形式写入，一旦mapper变多就会让代码看着十分的臃肿，每次添加新的mapper也需要去修改代码。这是我目前的实现方式，不知道项目是否已经有统一的写入方式，或者更好的解决方案能在每次添加新的mapper时不对这块代码进行维护？
func initMapperImpl() {
  mapperImpl = make(map[string]interface{})
  mapperImpl["doorMapperImpl"] = new(DoorMapperImpl)
  mapperImpl["roomMapperImpl"] = new(RoomMapperImpl)
  mapperImpl["customerMapperImpl"] = new(CustomerMapperImpl)
  mapperImpl["communityMapperImpl"] = new(CommunityMapperImpl)

  var mapperPaths []string

  mapperPaths, _ = util.GetAllFile("/mnt/code/reinhardtv1/mapper", mapperPaths)
  for _, str := range mapperPaths {
      c, _ := ioutil.ReadFile(str)
      name := str[strings.LastIndex(str, "/")+1:len(str)-4] + "Impl"
      fmt.Println(name)
      switch name {
      case "doorMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
      case "roomMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
      case "communityMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
      case "customerMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
      }
  }
}
Readme.md中文介绍里面有写明的，使用代码扫描你的model层结构体生成xml

功能：XML/Mapper生成器- 根据struct结构体生成*mapper.xml
  //step1 定义你的数据库模型,必须包含 json注解（默认为数据库字段）, gm:""注解指定 值是否为 id,version乐观锁,logic逻辑软删除
  type UserAddress struct {
    Id            string `json:"id" gm:"id"`
    UserId        string `json:"user_id"`
    RealName      string `json:"real_name"`
    Phone         string `json:"phone"`
    AddressDetail string `json:"address_detail"`

    Version    int       `json:"version" gm:"version"`
    CreateTime time.Time `json:"create_time"`
    DeleteFlag int       `json:"delete_flag" gm:"logic"`
}
第二步，在你项目main 目录下建立一个 XmlCreateTool.go 内容如下
func main() {
    var bean = UserAddress{} //此处只是举例，应该替换为你自己的数据库模型
    GoMybatis.OutPutXml(reflect.TypeOf(bean).Name()+"Mapper.xml", GoMybatis.CreateXml("biz_"+GoMybatis.StructToSnakeString(bean), bean))
}
第三步，执行命令，在当前目录下得到 UserAddressMapper.xml文件
go run XmlCreateTool.go
以下是自动生成的xml文件内容
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://raw.githubusercontent.com/zhuxiujia/GoMybatis/master/mybatis-3-mapper.dtd">
<mapper>
    
    
    
    
    <resultMap id="BaseResultMap" tables="biz_user_address">
    <id column="id" property="id"/>
    <result column="id" property="id" langType="string"   />
    <result column="user_id" property="user_id" langType="string"   />
    <result column="real_name" property="real_name" langType="string"   />
    <result column="phone" property="phone" langType="string"   />
    <result column="address_detail" property="address_detail" langType="string"   />
    <result column="version" property="version" langType="int" version_enable="true"  />
    <result column="create_time" property="create_time" langType="Time"   />
    <result column="delete_flag" property="delete_flag" langType="int"  logic_enable="true" logic_undelete="1" logic_deleted="0" />
    </resultMap>
</mapper>
emmm，我不是这个意思，就是mapper是已经生成完的，但是使用的时候是需要执行WriteMapperPtr()这个方法将mapper和结构体绑定，而在这个绑定的过程中需要自己去手动new结构体，并对每一个结构体执行WriteMapperPtr()。之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用，这样就不需要使用者每次新增模版文件的时候手动去绑定一次。我想知道gomybatis是否有做类似的功能，还是每个mapper在使用的时候都需要手动WriteMapperPtr()一次，就像我这段代码：
case "doorMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
case "roomMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
case "communityMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
case "customerMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)

"之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用" 我不清楚你们的程序具体打包方式，是直接上传mapper文件到服务器目录？还是吧mapper使用类似statikFS的文件系统框架转成string写入到程序里的？还是吧mapper 定义成字符串写在某个go文件里面的？甚至可能mapper文件只是一个动态字符串，从其他服务传送过来的数据呢？因为这些不确定性，不可以强制使用者绑定某个框架，因为只给出公共的 WriteMapperPtr方法提供给你们写入。

你所描述的应该是存储容器的问题和范畴，这个问题不属于gomybatis 的orm框架的定位。

看作者提供的例子都是通过扫描单一文件然后写入结构体的，这样的话意味着我项目初始化的时候需要手动进行结构体的初始化并扫描mapper目录，然后通过判断文件名的形式写入，一旦mapper变多就会让代码看着十分的臃肿，每次添加新的mapper也需要去修改代码。这是我目前的实现方式，不知道项目是否已经有统一的写入方式，或者更好的解决方案能在每次添加新的mapper时不对这块代码进行维护？
func initMapperImpl() {
    mapperImpl = make(map[string]interface{})
    mapperImpl["doorMapperImpl"] = new(DoorMapperImpl)
    mapperImpl["roomMapperImpl"] = new(RoomMapperImpl)
    mapperImpl["customerMapperImpl"] = new(CustomerMapperImpl)
    mapperImpl["communityMapperImpl"] = new(CommunityMapperImpl)

    var mapperPaths []string

    mapperPaths, _ = util.GetAllFile("/mnt/code/reinhardtv1/mapper", mapperPaths)
    for _, str := range mapperPaths {
        c, _ := ioutil.ReadFile(str)
        name := str[strings.LastIndex(str, "/")+1:len(str)-4] + "Impl"
        fmt.Println(name)
        switch name {
        case "doorMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
        case "roomMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
        case "communityMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
        case "customerMapperImpl":
            mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
        }
    }
}
Readme.md中文介绍里面有写明的，使用代码扫描你的model层结构体生成xml

功能：XML/Mapper生成器- 根据struct结构体生成*mapper.xml
  //step1 定义你的数据库模型,必须包含 json注解（默认为数据库字段）, gm:""注解指定 值是否为 id,version乐观锁,logic逻辑软删除
  type UserAddress struct {
  Id            string `json:"id" gm:"id"`
  UserId        string `json:"user_id"`
  RealName      string `json:"real_name"`
  Phone         string `json:"phone"`
  AddressDetail string `json:"address_detail"`

  Version    int       `json:"version" gm:"version"`
  CreateTime time.Time `json:"create_time"`
  DeleteFlag int       `json:"delete_flag" gm:"logic"`
}
第二步，在你项目main 目录下建立一个 XmlCreateTool.go 内容如下
func main() {
  var bean = UserAddress{} //此处只是举例，应该替换为你自己的数据库模型
  GoMybatis.OutPutXml(reflect.TypeOf(bean).Name()+"Mapper.xml", GoMybatis.CreateXml("biz_"+GoMybatis.StructToSnakeString(bean), bean))
}
第三步，执行命令，在当前目录下得到 UserAddressMapper.xml文件
go run XmlCreateTool.go
以下是自动生成的xml文件内容
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://raw.githubusercontent.com/zhuxiujia/GoMybatis/master/mybatis-3-mapper.dtd">
<mapper>
    
    
    
    
    <resultMap id="BaseResultMap" tables="biz_user_address">
    <id column="id" property="id"/>
  <result column="id" property="id" langType="string"   />
  <result column="user_id" property="user_id" langType="string"   />
  <result column="real_name" property="real_name" langType="string"   />
  <result column="phone" property="phone" langType="string"   />
  <result column="address_detail" property="address_detail" langType="string"   />
  <result column="version" property="version" langType="int" version_enable="true"  />
  <result column="create_time" property="create_time" langType="Time"   />
  <result column="delete_flag" property="delete_flag" langType="int"  logic_enable="true" logic_undelete="1" logic_deleted="0" />
    </resultMap>
</mapper>
emmm，我不是这个意思，就是mapper是已经生成完的，但是使用的时候是需要执行WriteMapperPtr()这个方法将mapper和结构体绑定，而在这个绑定的过程中需要自己去手动new结构体，并对每一个结构体执行WriteMapperPtr()。之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用，这样就不需要使用者每次新增模版文件的时候手动去绑定一次。我想知道gomybatis是否有做类似的功能，还是每个mapper在使用的时候都需要手动WriteMapperPtr()一次，就像我这段代码：
case "doorMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
case "roomMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
case "communityMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
case "customerMapperImpl":
    mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
"之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用" 我不清楚你们的程序具体打包方式，是直接上传mapper文件到服务器目录？还是吧mapper使用类似statikFS的文件系统框架转成string写入到程序里的？还是吧mapper 定义成字符串写在某个go文件里面的？因为这些不确定性，不可以强制使用者绑定某个框架，因为只给出公共的 WriteMapperPtr方法提供给你们写入。

你所描述的应该是存储容器的问题和范畴，这个问题不属于gomybatis 的orm框架的定位。

感谢，我大概明白你的意思了。

看作者提供的例子都是通过扫描单一文件然后写入结构体的，这样的话意味着我项目初始化的时候需要手动进行结构体的初始化并扫描mapper目录，然后通过判断文件名的形式写入，一旦mapper变多就会让代码看着十分的臃肿，每次添加新的mapper也需要去修改代码。这是我目前的实现方式，不知道项目是否已经有统一的写入方式，或者更好的解决方案能在每次添加新的mapper时不对这块代码进行维护？
func initMapperImpl() {
  mapperImpl = make(map[string]interface{})
  mapperImpl["doorMapperImpl"] = new(DoorMapperImpl)
  mapperImpl["roomMapperImpl"] = new(RoomMapperImpl)
  mapperImpl["customerMapperImpl"] = new(CustomerMapperImpl)
  mapperImpl["communityMapperImpl"] = new(CommunityMapperImpl)

  var mapperPaths []string

  mapperPaths, _ = util.GetAllFile("/mnt/code/reinhardtv1/mapper", mapperPaths)
  for _, str := range mapperPaths {
      c, _ := ioutil.ReadFile(str)
      name := str[strings.LastIndex(str, "/")+1:len(str)-4] + "Impl"
      fmt.Println(name)
      switch name {
      case "doorMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
      case "roomMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
      case "communityMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
      case "customerMapperImpl":
          mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
      }
  }
}
Readme.md中文介绍里面有写明的，使用代码扫描你的model层结构体生成xml

功能：XML/Mapper生成器- 根据struct结构体生成*mapper.xml
  //step1 定义你的数据库模型,必须包含 json注解（默认为数据库字段）, gm:""注解指定 值是否为 id,version乐观锁,logic逻辑软删除
  type UserAddress struct {
    Id            string `json:"id" gm:"id"`
    UserId        string `json:"user_id"`
    RealName      string `json:"real_name"`
    Phone         string `json:"phone"`
    AddressDetail string `json:"address_detail"`

    Version    int       `json:"version" gm:"version"`
    CreateTime time.Time `json:"create_time"`
    DeleteFlag int       `json:"delete_flag" gm:"logic"`
}
第二步，在你项目main 目录下建立一个 XmlCreateTool.go 内容如下
func main() {
    var bean = UserAddress{} //此处只是举例，应该替换为你自己的数据库模型
    GoMybatis.OutPutXml(reflect.TypeOf(bean).Name()+"Mapper.xml", GoMybatis.CreateXml("biz_"+GoMybatis.StructToSnakeString(bean), bean))
}
第三步，执行命令，在当前目录下得到 UserAddressMapper.xml文件
go run XmlCreateTool.go
以下是自动生成的xml文件内容
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://raw.githubusercontent.com/zhuxiujia/GoMybatis/master/mybatis-3-mapper.dtd">
<mapper>
    
    
    
    
    <resultMap id="BaseResultMap" tables="biz_user_address">
    <id column="id" property="id"/>
    <result column="id" property="id" langType="string"   />
    <result column="user_id" property="user_id" langType="string"   />
    <result column="real_name" property="real_name" langType="string"   />
    <result column="phone" property="phone" langType="string"   />
    <result column="address_detail" property="address_detail" langType="string"   />
    <result column="version" property="version" langType="int" version_enable="true"  />
    <result column="create_time" property="create_time" langType="Time"   />
    <result column="delete_flag" property="delete_flag" langType="int"  logic_enable="true" logic_undelete="1" logic_deleted="0" />
    </resultMap>
</mapper>
emmm，我不是这个意思，就是mapper是已经生成完的，但是使用的时候是需要执行WriteMapperPtr()这个方法将mapper和结构体绑定，而在这个绑定的过程中需要自己去手动new结构体，并对每一个结构体执行WriteMapperPtr()。之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用，这样就不需要使用者每次新增模版文件的时候手动去绑定一次。我想知道gomybatis是否有做类似的功能，还是每个mapper在使用的时候都需要手动WriteMapperPtr()一次，就像我这段代码：
case "doorMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*DoorMapperImpl), c)
case "roomMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*RoomMapperImpl), c)
case "communityMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CommunityMapperImpl), c)
case "customerMapperImpl":
  mysql.GoMybatisEngine.WriteMapperPtr(mapperImpl[name].(*CustomerMapperImpl), c)
"之前接触过别的一些go的sql模版，基本都是扫描模版的目录，通过统一的方法，输入方法名直接调用" 我不清楚你们的程序具体打包方式，是直接上传mapper文件到服务器目录？还是吧mapper使用类似statikFS的文件系统框架转成string写入到程序里的？还是吧mapper 定义成字符串写在某个go文件里面的？因为这些不确定性，不可以强制使用者绑定某个框架，因为只给出公共的 WriteMapperPtr方法提供给你们写入。你所描述的应该是存储容器的问题和范畴，这个问题不属于gomybatis 的orm框架的定位。
感谢，我大概明白你的意思了。

推荐使用 statikFS 类似框架，吧mapper写入到程序里。这样使用自动化发布到生产环境的话，可以省去上传一堆mapper文件的繁琐步骤。另外附上项目中使用的 statikFS加载工具代码片段


import (
    "github.com/rakyll/statik/fs"
    "io/ioutil"
    "log"
    "reflect"
)

func LoadMapper(it interface{}) {
    var v = reflect.ValueOf(it)
    if v.Kind() != reflect.Ptr {
        panic("load " + v.String() + " must use ptr!")
    }
    for {
        if v.Kind()==reflect.Ptr{
            v=v.Elem()
        }else{
            break
        }
    }

    statikFS, err := fs.New()
    if err != nil {
        log.Fatal(err)
    }
    var name = "/" + v.Type().Name() + ".xml"
    log.Println("load xml:", name)
    var f, e = statikFS.Open(name)
    if e != nil {
        panic(e)
    }
    b, e := ioutil.ReadAll(f)
    core_context.Engine.WriteMapperPtr(it, b)
}

zhuxiujia / GoMybatis