golang利用beego框架orm操作mysql

GO引入orm框架操作mysql

在beego框架中引入orm操作mysql需要进行的步骤：

第一步：导入orm框架依赖，导入mysql数据库的驱动依赖

import (
	"github.com/astaxie/beego/orm"     //导入orm框架
	_ "github.com/go-sql-driver/mysql" //导入数据库驱动
)

第二步:进行模型结构定义

//例如定义user表模型结构
type TestUser struct {
    Id   int `orm:"pk;auto;column(user_id)"` //表示设置为主键并且自增，列名为user_id
    Name string `orm:"size(100)"column(user_name)`
    Sex  int `orm:"size(2);column(gender)"`
    CreateDate time.Time `orm:"type(date);column(create_date)"`
    Age int `orm:size(10);column(age)`
}
//注意：以上的字段名必须大写，否则无法识别

在进行模型结构定义需要注意的是（模型结构定义也就是表字段定义，beego中的orm框架会自动给你生成模型定义对应的表）：

关于表名：默认是生成以结构名小写并且加上s结尾的表名，也可以自行设置表名

func (u *模型结构名) TableName() string {
    return "你设置的表名"
}

关于索引定义:可以为单个字段或多个字段添加索引

// 多字段索引
func (u *模型结构名) TableIndex() [][]string {
    return [][]string{
        []string{"字段1", "字段2"},
    }
}

// 多字段唯一键
func (u *模型结构名) TableUnique() [][]string {
    return [][]string{
        []string{"字段1", "字段2"},
    }
}
写法都是固定了，只要按照这样的方式写就可以了

关于自定义引擎：对mysql可以支持自定义引擎

// 设置引擎为 INNODB
func (u *模型结构名) TableEngine() string {
    return "INNODB"
}

关于字段属性的设置：例如字段大小，字段的为空不为空等设置

多个设置间使用 ; 分隔，设置的值如果是多个，使用 , 分隔。

在设置属性时都是以orm:"你的设置"开头

设置int类型通常为id字段自增并且为主键:orm:"pk;auto"

为空设置：数据库表默认为 NOT NULL，设置 null 代表 ALLOW NULL

Name string orm:"null" 表示name字段可以为空

为单个字段添加索引或者唯一索引：Name strig orm:"index" 或者`Name string orm:"unique"

为字段设置对应的列名: Name string orm:"column(user_name)"

设置字段的大写设置 size 以后，db type 将使用 varchar(size): Name string orm:"size(10)"

为字段设置浮点数精度：Money float64 orm:"digits(12);decimals(4)" 结果显示9999.9999

时间类型的设置

设置为 date 时，time.Time 字段的对应 db 类型使用 date

Created time.Time `orm:"auto_now_add;type(date)"`

设置为 datetime 时，time.Time 字段的对应 db 类型使用 datetime

Created time.Time `orm:"auto_now_add;type(datetime)"`

设置为字段添加注释:注释中禁止包含引号

Status int orm:"default(1)" description:"这是状态字段"

第三步：进行初始化操作，主要进行建立数据库连接，以及注册模型结构，建表等操作。

func init() {
    //注册数据库，一共有五个参数，后面连个用于连接池操作
	_ = orm.RegisterDataBase("default", "mysql",
		"root:123456@tcp(172.16.163.128:3307)/goodsinfo?charset=utf8")
    //进行注册模型结构，可以有多个，用逗号分隔
	orm.RegisterModel(new(Stu))
    //创建表，默认为default，只建立一次，后面再执行这个会忽略
	_ = orm.RunSyncdb("default", false, true)
}

注：以上没有引入关联关系操作

第四步:编写sql语句进行操作mysql数据库

//查询所有学生信息
func SelectAll() []orm.Params  {
	o := orm.NewOrm()
	var maps []orm.Params
	_, _ = o.Raw("select * from stu_stu").Values(&maps)
	return maps
}

//根据id查询学生信息
func SelectById(id int) Stu  {
	o:=orm.NewOrm()
	_ = o.Raw("select * from stu_stu where id=?", id).QueryRow(&stu)
	return stu
}

//根据id删除用户
func Deletebyid(id int) {
	o := orm.NewOrm()
	_ = o.Raw("delete from stu_stu where id = ?", id).QueryRow(&stu)
}

//根据id更新信息
func Updatebyid(id int,name string) {
	o:=orm.NewOrm()
	_ = o.Raw("update stu_stu set name=? where id=?", name, id).QueryRow(&stu)
}

//插入数据
func InsertData(id int,name string)  {
	o:=orm.NewOrm()
	_ = o.Raw("insert into stu_stu values(?,?)", id, name).QueryRow(&stu)
}

//根据name进行模糊查询
func SelectUnClear(name string) []orm.Params  {
	o := orm.NewOrm()
	var maps []orm.Params
	_, _ = o.Raw("select * from stu_stu where name like ?","%"+name+"%").Values(&maps)
	return maps
}

控制器编写并且返回json数据

package controllers

import (
	"github.com/astaxie/beego"
	"github.com/astaxie/beego/orm"
	"goorm/models"
)

type SelectAll struct {
	beego.Controller
}
//全局变量
var stu models.Stu
//查询所有信息
func (c *SelectAll) Get() {
	var maps []orm.Params
	maps = models.SelectAll()
	c.Data["json"]=maps
	c.ServeJSON()
}

type SelectbyId struct {
	beego.Controller
}

//根据id查询用户
func (c *SelectbyId) Get() {
	id, _ := c.GetInt(":id")
	stu = models.SelectById(id)
	c.Data["json"]=stu
	c.ServeJSON()
}

//根据id删除用户
type DeletebyId struct {
	beego.Controller
}

func (c *DeletebyId) Get() {
	id, _ := c.GetInt(":id")
	models.Deletebyid(id)
	str:=models.SelectAll()
	c.Data["json"]=str
	c.ServeJSON()
}
//根据id更新信息
type Updatebyid struct {
	beego.Controller
}

func (c *Updatebyid) Get()  {
	id,_:=c.GetInt(":id")
	name:=c.GetString(":name")
	models.Updatebyid(id,name)
	str:=models.SelectAll()
	c.Data["json"]=str
	c.ServeJSON()
}

//插入数据
type InsertData struct {
	beego.Controller
}

func (c *InsertData) Get()  {
	id, _ :=c.GetInt(":id")
	name:=c.GetString(":name")
	models.InsertData(id,name)
	str:=models.SelectAll()
	c.Data["json"]=str
	c.ServeJSON()
}

//模糊查询
type SelectUnClear struct {
	beego.Controller
}

func (c *SelectUnClear) Get()  {
	name:=c.GetString(":name")
	var maps []orm.Params
	maps = models.SelectUnClear(name)
	c.Data["json"]=maps
	c.ServeJSON()
}

以上就是beego引入orm框架操作mysql数据库的简单练习

数据多模式输出 ---json，xml，jsonp

beego 当初设计的时候就考虑了 API 功能的设计，而我们在设计 API 的时候经常是输出 JSON 或者 XML 数据，那么 beego 提供了这样的方式直接输出：

注意 struct 属性应该 为 exported Identifier 也就是首字母应该大写

• JSON 数据直接输出：

  func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["json"] = &mystruct
      this.ServeJSON()
  }
  

  调用 ServeJSON 之后，会设置 content-type 为 application/json，然后同时把数据进行 JSON 序列化输出。

• XML 数据直接输出：

  func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["xml"]=&mystruct
      this.ServeXML()
  }
  

  调用 ServeXML 之后，会设置 content-type 为 application/xml，同时数据会进行 XML 序列化输出。

• jsonp 调用

  func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["jsonp"] = &mystruct
      this.ServeJSONP()
  }
  

  调用 ServeJSONP 之后，会设置 content-type 为 application/javascript，然后同时把数据进行 JSON 序列化，然后根据请求的 callback 参数设置 jsonp 输出。

开发模式下序列化后输出的是格式化易阅读的 JSON 或 XML 字符串；在生产模式下序列化后输出的是压缩的字符串。

---

golang页面模板tpl从列表中循环取值

{{range .mydata}}

<option value="{{.id}},{{.name}}">[ {{.id}},{{.name}} ]</option>

{{end}}

如果是返回的是对象列表：例如：[{...}{....}{....}]，现在我想取里面的第一个{}内容，使用{{index .Keys 1}}即可。

如果是想取结构体里面某一个字段的值则使用:{{(index .Keys 1).propert_name}}