huangzj
267 lines
8.4 KiB
Go
267 lines
8.4 KiB
Go
package reverse
|
|
|
|
import (
|
|
"ReverseEngine/entity"
|
|
"ReverseEngine/imp"
|
|
"ReverseEngine/static"
|
|
"ReverseEngine/support"
|
|
"ReverseEngine/util"
|
|
"bufio"
|
|
"database/sql"
|
|
"fmt"
|
|
_ "github.com/go-sql-driver/mysql"
|
|
"gopkg.in/ini.v1"
|
|
"log"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
//数据库到实体映射 可在config.ini中配置
|
|
tm = make(map[string]string)
|
|
|
|
//通用配置 可在config.ini中配置
|
|
def = "string" //默认的映射类型
|
|
tagKey = "xorm" //tag的key
|
|
suffix = ".go" //文件后缀
|
|
cover = true //存在文件是否进行覆盖，只有配置为false的时候不会覆盖，其他默认为true
|
|
|
|
//数据库配置 可在config.ini中配置 格式是：”用户名:密码@tcp(IP:端口)/数据库?charset=utf8”
|
|
username = "你的mysql连接账号"
|
|
password = "你的连接密码"
|
|
tcp = "@tcp"
|
|
ip = "你的地址"
|
|
port = "3306"
|
|
database = "你的数据库" //这个是我的数据库
|
|
charset = "utf8mb4&parseTime=True&loc=Local"
|
|
connMaxLifeTime = 100
|
|
maxIdleConns = 10
|
|
|
|
//校验、数据库连接实现类
|
|
cg imp.ContentGenerate
|
|
dbc imp.DbConnection
|
|
rc imp.ReverseCheck
|
|
)
|
|
|
|
//---------------------------------------初始化,策略配置,规则校验-----------------------------------------
|
|
|
|
type DataReverseEngine struct {
|
|
}
|
|
|
|
func NewEngine() *DataReverseEngine {
|
|
return &DataReverseEngine{}
|
|
}
|
|
|
|
//创建初始化 --加载配置信息等
|
|
func init() {
|
|
cfg := loadIniCfg() //获取ini配置文件的对象
|
|
if nil == cfg {
|
|
panic("配置文件 config.ini配置错误，请检查")
|
|
return
|
|
}
|
|
loadCommonConfig(cfg) //加载通用配置
|
|
loadDataBaseConfig(cfg) //加载数据库配置
|
|
loadTypeMappingConfig(cfg) //加载类型映射配置
|
|
rc = &support.CheckSupport{} //校验支持
|
|
dbc = &support.DbSupport{} //数据库支持
|
|
cg = &support.FileContentSupport{} //文本拼接支持
|
|
|
|
}
|
|
|
|
/*
|
|
重写自己的文件类型定义实现
|
|
*/
|
|
func (*DataReverseEngine) SetContentGenerate(face imp.ContentGenerate) {
|
|
cg = face
|
|
}
|
|
|
|
/*
|
|
重写自己的数据库连接工具
|
|
*/
|
|
func (*DataReverseEngine) SetDbConnection(face imp.DbConnection) {
|
|
dbc = face
|
|
}
|
|
|
|
/*
|
|
重写自己的校验规则
|
|
*/
|
|
func (*DataReverseEngine) SetReverseCheck(face imp.ReverseCheck) {
|
|
rc = face
|
|
}
|
|
|
|
func checkError(err error, s string) {
|
|
if err != nil {
|
|
panic(s + err.Error())
|
|
}
|
|
}
|
|
|
|
//----------------------------------逆向工程---------------------------------
|
|
|
|
/*
|
|
数据库逆向工程
|
|
tableName:表名
|
|
path:创建目录的相对路径(右键选中文件夹，点击relative path得到的路径)
|
|
*/
|
|
func (r *DataReverseEngine) SimpleEngineer(tableName string, path string) {
|
|
r.Engineer(database, tableName, path, cover)
|
|
}
|
|
|
|
/*
|
|
数据库逆向工程
|
|
tableName:表名
|
|
path:创建目录的相对路径(右键选中文件夹，点击relative path得到的路径)
|
|
cover:如果已经存在改文件是否进行覆盖
|
|
*/
|
|
func (r *DataReverseEngine) SimEngineer(tableName string, path string, cover bool) {
|
|
r.Engineer(database, tableName, path, cover)
|
|
}
|
|
|
|
/*
|
|
数据库逆向工程
|
|
dbName：数据库名称
|
|
tableName:表名
|
|
path:创建目录的相对路径(右键选中文件夹，点击relative path得到的路径)
|
|
cover:如果已经存在改文件是否进行覆盖
|
|
*/
|
|
func (*DataReverseEngine) Engineer(dbName string, tableName string, path string, cover bool) {
|
|
//tableName = strings.Title(tableName) //tableName进行首字母大写
|
|
if !rc.CheckFileDir(path, tableName, cover) { //进行通用校验
|
|
return
|
|
}
|
|
dbPath := strings.Join([]string{username, ":", password, tcp, "(", ip, ":", port, ")/", database, "?", "charset=", charset}, "")
|
|
db := dbc.CreateDbConnection(dbPath, maxIdleConns, connMaxLifeTime) //连接数据库--可配置连接不同的数据库
|
|
if db == nil {
|
|
log.Println("数据库连接失败，程序终止")
|
|
return
|
|
}
|
|
//校验对应的数据库表是否存在
|
|
if rc.CheckTableExist(dbName, tableName, db) {
|
|
dbReverse(path, tableName, dbName, db)
|
|
return
|
|
}
|
|
log.Println("数据库表不存在:", tableName) //不存在的话打印日志返回
|
|
}
|
|
|
|
func dbReverse(path string, tableName string, dbName string, db *sql.DB) {
|
|
file, result := util.CreateNeedOpenFile(util.GenerateFilePath(path, tableName, static.Splice, suffix))
|
|
if !result {
|
|
return
|
|
}
|
|
cms := util.FindColumnMessage(dbName, tableName, db) //查询数据库表字段信息
|
|
tableComment := util.FindTableComment(dbName, tableName, db) //查询数据库表字段信息
|
|
dErr := db.Close() //关闭数据库连接
|
|
checkError(dErr, "数据库关闭失败：")
|
|
if nil == cms {
|
|
log.Println("没有查到数据库字段信息略过")
|
|
}
|
|
fms, hasTime := buildFieldMessage(cms) //创建字段名和类型的映射
|
|
w := bufio.NewWriter(file) //进行文件的操作
|
|
content := cg.GenerateFileContent(path, tableName, fms, hasTime, tagKey, tableComment) //拼go文件
|
|
_, err := w.WriteString(content)
|
|
checkError(err, "写入出错了：")
|
|
fErr, cErr := w.Flush(), file.Close()
|
|
|
|
checkError(fErr, "文件写入出错了,flush错误:")
|
|
checkError(cErr, "文件写入出错了,close错误:")
|
|
}
|
|
|
|
func buildFieldMessage(cms []entity.ColumnMessage) ([]entity.FieldMessage, bool) {
|
|
var fms []entity.FieldMessage
|
|
hasTime := false
|
|
|
|
for _, cm := range cms {
|
|
fm := &entity.FieldMessage{
|
|
FiledName: cm.Field, //字段名称
|
|
FieldType: typeMapping(cm.Type, &hasTime), //字段类型,进行映射
|
|
OriginType: cm.Type, //数据库原始类型
|
|
IsKey: cm.IsKey(), //是否主键
|
|
TagKey: tagKey, //tag的key值，这边先写死，正常应该是可配
|
|
Comment: cm.GetComment(), //注释信息
|
|
Default: cm.GetDefault(), //默认值信息
|
|
CanNull: cm.CanNull(), //是否可以为空
|
|
}
|
|
|
|
fms = append(fms, *fm)
|
|
}
|
|
|
|
return fms, hasTime
|
|
}
|
|
|
|
func typeMapping(t string, has *bool) string {
|
|
rt := strings.Split(t, "(")[0] //需要把类型后面的([长度])去掉
|
|
value, ok := tm[rt]
|
|
if ok {
|
|
if value == static.TimeT {
|
|
*has = true
|
|
}
|
|
return value
|
|
}
|
|
|
|
return def
|
|
}
|
|
|
|
//-----------------------------------读取和属性设置-----------------------------
|
|
func loadIniCfg() *ini.File {
|
|
cfg, err := ini.Load(static.IniAddress)
|
|
if err != nil {
|
|
log.Println("读取失败使用原始配置", err)
|
|
os.Exit(1)
|
|
return nil
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
func loadDataBaseConfig(cfg *ini.File) {
|
|
if len(cfg.Section(static.DataBase).Keys()) == 0 {
|
|
log.Println("配置区间为空，采用数据库配置通用配置")
|
|
return
|
|
}
|
|
util.GenerateConfig("username", username, cfg.Section(static.DataBase))
|
|
util.GenerateConfig("password", password, cfg.Section(static.DataBase))
|
|
util.GenerateConfig("tcp", tcp, cfg.Section(static.DataBase))
|
|
util.GenerateConfig("ip", ip, cfg.Section(static.DataBase))
|
|
util.GenerateConfig("port", port, cfg.Section(static.DataBase))
|
|
util.GenerateConfig("database", database, cfg.Section(static.DataBase))
|
|
util.GenerateConfig("charset", charset, cfg.Section(static.DataBase))
|
|
util.GenerateConfigInt("connMaxLifeTime", connMaxLifeTime, cfg.Section(static.DataBase))
|
|
util.GenerateConfigInt("maxIdleConns", maxIdleConns, cfg.Section(static.DataBase))
|
|
|
|
}
|
|
|
|
func loadCommonConfig(cfg *ini.File) {
|
|
if len(cfg.Section(static.Common).Keys()) == 0 {
|
|
log.Println("配置区间为空，采用通用配置")
|
|
return
|
|
}
|
|
util.GenerateConfig("def", def, cfg.Section(static.Common)) //默认的映射类型
|
|
util.GenerateConfig("tagKey", tagKey, cfg.Section(static.Common)) //tag的key
|
|
util.GenerateConfig("suffix", suffix, cfg.Section(static.Common)) //文件后缀
|
|
util.GenerateConfigBool("cover", &cover, cfg.Section(static.Common)) //存在文件是否进行覆盖，只有配置为false的时候不会覆盖，其他默认为true
|
|
}
|
|
|
|
func defaultTypeMappingConfig() {
|
|
tm["double"] = "float64"
|
|
tm["float"] = "float64"
|
|
tm["int"] = "int"
|
|
tm["tinyint"] = "int"
|
|
tm["bigint"] = "int"
|
|
tm["time"] = "time.Time"
|
|
tm["timestamp"] = "time.Time"
|
|
tm["date"] = "time.Time"
|
|
tm["dateTime"] = "time.Time"
|
|
}
|
|
|
|
func loadTypeMappingConfig(cfg *ini.File) {
|
|
if len(cfg.Section(static.MapType).Keys()) == 0 {
|
|
defaultTypeMappingConfig()
|
|
log.Println("配置区间为空，采用类型映射通用配置")
|
|
return
|
|
}
|
|
|
|
for _, k := range cfg.Section(static.MapType).Keys() {
|
|
if k.Name() != "" {
|
|
tm[k.Name()] = k.Value()
|
|
}
|
|
}
|
|
}
|