beego ORM框架（beego框架怎么样）

beego中内嵌了ORM框架, ORM框架可以将结构体和数据表进行对应起来, 只需要通过结构体和对象就可以对数据表进行操作。

设计类：模型类。

ORM另外一个作用：根据设计的类生成数据库中的表。

安装ORM

go get github.com/astaxie/beego/orm

执行的位置

D:\Go\study\src\class>go get github.com/astaxie/beego/orm

1 创建表

main.go

package main
import (
_ "class/models" /* 加载模型文件 */
_ "class/routers"
"github.com/astaxie/beego"
)
func main() {
beego.Run()
}

models/model.go

package models
import (
"github.com/astaxie/beego/orm"
_ "github.com/go-sql-driver/mysql"
)
type User struct {
Id int
Name string
Pwd string
}
func init() {
// 设置数据库基本信息
orm.RegisterDataBase("default", "mysql", "root:root@tcp(127.0.0.1:3307)/blog?charset=utf8")
/*
参数1 数据库的别名，用来在 ORM 中切换数据库使用
参数2 driverName
参数3 对应的链接字符串
*/
// 映射model数据
orm.RegisterModel(new(User)) //user表名
// 生成表
orm.RunSyncdb("default", false, true)
/*
default: 数据库别名 第二个参数 false:不需要更新表 true 需要更新表 第三个参数: 创建表的过程是否可见
*/
}

执行bee run命令

D:\Go\study\src\class>bee run
______
| ___ \
| |_/ / ___ ___
| ___ \ / _ \ / _ \
| |_/ /| __/| __/
\____/ \___| \___| v1.10.0
2018/12/09 22:40:47 INFO ? 0001 Using 'class' as 'appname'
2018/12/09 22:40:47 INFO ? 0002 Initializing watcher...
class
2018/12/09 22:40:54 SUCCESS ? 0003 Built Successfully!
2018/12/09 22:40:54 INFO ? 0004 Restarting 'class.exe'...
2018/12/09 22:40:54 SUCCESS ? 0005 './class.exe' is running...
create table `user`
-- --------------------------------------------------
-- Table Structure for `class/models.User`
-- --------------------------------------------------
CREATE TABLE IF NOT EXISTS `user` (
`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
`name` varchar(255) NOT NULL DEFAULT '' ,
`pwd` varchar(255) NOT NULL DEFAULT ''
) ENGINE=InnoDB;
2018/12/09 22:40:56.956 [I] [asm_amd64.s:1333] http server Running on http://:8080

2 ORM插入数据

controllers/default.go

package controllers
import (
    "class/models" /* 导入模型 */
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/orm"
)
type MainController struct {
    beego.Controller
}
func (c *MainController) Get() {
    // 1. 有ORM对象
    o := orm.NewOrm()
    // 2. 有一个要插入数据的结构体对象
    user := models.User{}
    // 3. 对结构体赋值
    user.Name = "xuchenkai"
    user.Pwd = "123456"
    // 4. 插入
    _, err := o.Insert(&user)
    if err != nil {
        beego.Info("插入失败", err)
        return
    }
    c.Data["data"] = "今天中午吃饺子"
    c.TplName = "test.html"
}
func (c *MainController) Post() {
    c.Data["data"] = "今天中午吃面条"
    c.TplName = "test.html"
}

3 ORM查询

package controllers
import (
    "class/models"
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/orm"
)
type MainController struct {
    beego.Controller
}
func (c *MainController) Get() {
    // 1. 有ORM对象
    o := orm.NewOrm()
    // 2. 查询对象
    user := models.User{}
    // 3. 指定查询对象字段值(字段值首字母要注意大写)
    //user.Id = 1
    user.Name = "xuchenkai"
    // 4. 查询
    //err := o.Read(&user) //根据id查询
    err := o.Read(&user, "Name") //根据Name查询, 必须传递第二个参数"Name"
    if err != nil {
    beego.Info("查询失败", err)
    }
    beego.Info("查询成功", user)
    c.Data["data"] = "今天中午吃饺子"
    c.TplName = "test.html"
  }
func (c *MainController) Post() {
    c.Data["data"] = "今天中午吃面条"
    c.TplName = "test.html"
}

4 ORM更新

package controllers
import (
"class/models"
"github.com/astaxie/beego"
"github.com/astaxie/beego/orm"
)
type MainController struct {
beego.Controller
}
func (c *MainController) Get() {
// 1. 有ORM对象
o := orm.NewOrm()
// 2. 需要更新的结构体对象
user := models.User{}
//3 查询需要更新的数据
user.Id = 1
err := o.Read(&user)
// 4 给数据赋值
if err == nil {
user.Name = "pengjihan"
user.Pwd = "123456789"
// 更新
_, err = o.Update(&user)
if err != nil {
beego.Info("更新失败", err)
return
}
}
c.Data["data"] = "今天中午吃饺子"
c.TplName = "test.html"
}
func (c *MainController) Post() {
c.Data["data"] = "今天中午吃面条"
c.TplName = "test.html"
}

ORM 删除

package controllers
import (
    "class/models"
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/orm"
)
type MainController struct {
    beego.Controller
}
func (c *MainController) Get() {
    // 1. 有ORM对象
    o := orm.NewOrm()
    // 2. 删除的对象
    user := models.User{}
    // 3. 指定删除哪一条数据
    user.Id = 1
    // 4 删除
    _, err := o.Delete(&user)
    if err != nil {
        beego.Info("删除错误", err)
        return
    }
    c.Data["data"] = "今天中午吃饺子"
     c.TplName = "test.html"
}
func (c *MainController) Post() {
    c.Data["data"] = "今天中午吃面条"
    c.TplName = "test.html"
}
一对多查询
//用户结构体
type User struct {
    Id int
    Name string `orm:"unique"`
    Pwd string
    Articles []*Article `orm:"rel(m2m)"` //与Article建立多对多的关系, 建立中间表user_articles
}
/*
文章结构体 字段命名规则: 不要出现下划线(会出现两个下划线),
除了首字母大写外, 字段中出现第二个大写, 将会新建一个下划线
如: ArticleName => article_name
*/
type Article struct {
    Id int `orm:"pk;auto"`
    ArtiName string `orm:"size(20)"` //文章标题
    Atime time.Time `orm:"auto_now"` //内容
    Acount int `orm:"default(0);null"`
    Acontent string
    Aimg string
    ArticleType *ArticleType `orm:"rel(fk)"` //外键约束 与 ArticleType 建立一对多关系
    Users []*User `orm:"reverse(many)"` //与User立多对多的关系, 建立中间表user_articles
}
type ArticleType struct {
    Id int
    TypeName string `orm:"size(20)"`
    Articles []*Article `orm:"reverse(many)"` //与Article建立多对一的关系
}

一对多关系查询时必须使用RelatedSel(), 不然查不到数据, 参数要指定关联的表, 不然数据不正确

count, err = o.QueryTable("Article").RelatedSel("ArticleType").Count() //两个表建立了外键约束的关系

多对多插入

//多对多插入读者 插入到中间表
//1 获取操作对象
article := models.Article{Id: id}
//2 获取多对多操作对象
m2m := o.QueryM2M(&article, "Users") //article和user表建立了多对多的关系
//3 获取插入对象
userName := c.GetSession("userName") //获取登录的用户
user := models.User{}
user.Name = userName.(string)
o.Read(&user, "Name") //读取用户 写入到user结构体中 Name 查询的条件
//4 多对多插入
_, err = m2m.Add(&user)
if err != nil {
beego.Info("插入失败")
}

多对多查询

o.LoadRelated(&arti, "Users")