go iris简易mvc模型

package datamodels

type User struct {
	UserId    int64  `json:"user_id" xorm:"not null pk autoincr BIGINT(20)"`
	Name      string `json:"name" xorm:"unique VARCHAR(255)"`
	Balance   int64  `json:"balance" xorm:"BIGINT(20)"`
	Time      int64  `json:"time" xorm:"BIGINT(20)"`
	CreatTime int64  `json:"creat_time" xorm:"BIGINT(20)"`
}

package repositories

import (
	"test/datamodels"
	"github.com/go-xorm/xorm"
)

// Userdao 将xorm引擎封装为struct
type Userdao struct {
	engine *xorm.Engine
}

// NewUserDao 会被外部引用，首字母大写。
// 初始化struct，传入*xorm.Engine，返回封装xorm引擎的struct指针
func NewUserDao(xormEngine *xorm.Engine) *Userdao {
	// 等同于 return &Userdao{engine: xorm_engine,}
	engineUser := &Userdao{engine: xormEngine,}	// 初始化结构体
	return engineUser
}

// engine = xorm.NewEngine("mysql", "root:123@/test?charset=utf8")
// GetAll 获取User表中所有数据
func (d *Userdao) GetAll() []datamodels.User {
	// 先初始化一个slice，cap为0，类型为struce，用来接收数据
	dataList := make([]datamodels.User, 0)
	// orm语句，执行结果回传给datalist的指针变量
	err := d.engine.Find(&dataList)
	if err != nil {
		return dataList	// 如果出错则return空切片
	}
	return dataList
}

package services

import (
	"test/datamodels"
	"test/repositories"
	_ "github.com/go-sql-driver/mysql"
	"github.com/go-xorm/xorm"
)
/**
 *	1.初始化struct
 *  2.声明interface
 *  3.将struct赋值给interface
 *  4.interface使用struct的func
 */

 /**
 *	将dao的struct包含于service的struct中，
 *	这样调用struct(service)的func就相当于调用struct(dao)的func
 *  初始化struct(service)的时候顺便初始化了struct(dao)
 *  将初始化的struct(service)赋值给interface
 *  这样interface可以调用func(service)了 - 也就是func(dao)
 *  service是表层，dao是底层
 */


// UserService 初始化接口
type UserService interface {
	GetAll() []datamodels.User
}

// userSer 将dao中
type userService struct {
	dao *repositories.Userdao // 包含dao的struct
}

// NewUserService 实例化struct,再将struct赋值给interface
func NewUserService() UserService {
	engine, err := xorm.NewEngine("mysql", "root:root@/xorm?charset=utf8")
	if err != nil {
		// 错误处理
		panic("here")
	}
	a := &userService{dao: repositories.NewUserDao(engine)}	// 顺便把dao给new了
	return a
}

func (s *userService) GetAll() []datamodels.User {
	return s.dao.GetAll()
}

package controllers

import (
	"fmt"
	"test/services"
	"github.com/kataras/iris/v12"
)

type IndexController struct {
	Ctx iris.Context
	Sb  services.UserService　　// Sb此处一定要首字母大写
}

func (c *IndexController) Get() {
	c.Ctx.HTML("/ | ")
	c.Ctx.Next()
}

func (c *IndexController) GetUsers() {

	dataList := c.Sb.GetAll()

	fmt.Println(dataList)
	c.Ctx.Next()
}

package main

import (
	"test/services"
	"test/web/controllers"

	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/mvc"
)

func main() {
	// 1.创建实例
	app := iris.New()

	// 2.设置错误等级
	//app.Logger().SetLevel("debug")

	// 3.注册模板
	htmlEngine := iris.HTML("./web/views", ".html") // 从./web/views目录下加载所有以.html为后缀文件，并解析他们
	htmlEngine.Layout("shared/layout.html")         // 相当于组成页面的框架html，其他模板填充进该layout
	htmlEngine.Reload(true)                         // 每次重新加载模板
	app.RegisterView(htmlEngine)                    // 注册该模板

	// 4.设置静态文件目录
	app.HandleDir("/public", "./public/") // 外网访问/public文件就是访问web.exe同级目录下public文件

	// 5.设置异常页面
	app.OnAnyErrorCode(func(ctx iris.Context) { // 自定义错误，错误码在100~511自动触发
		ctx.ViewData("message", ctx.Values().GetStringDefault("message", "访问页面出错")) // 绑定数据
		ctx.ViewLayout("shared/layout.html")
		ctx.View("shared/error.html")
	})

	// 6.注册控制器
	// app.Use(bigbefore)	// 全局before
	// app.Done(bigafter)	// 全局after
	// app.UseGlobal(global)
	// users := app.Party("/user", middleHandlerUser)   // user组,访问该组下路由都会触发middleHandlerUser方法
	// users.Use(b)                                     // user组的前置函数，在middleHandlerUser之后执行
	// users.Done(a)                                // user组的后置函数
	// users.Get("", routeUser)                         // http://127.0.0.1:8080/user
	// users.Get("/test", before, routeUserTest, after) // http://127.0.0.1:8080/user/test 依次执行 before, routeUserTest, after 方法
	// users.Get("/user/test", routeUserUserTest)       // http://127.0.0.1:8080/user/user/test

	// test := app.Party("/test") // 不使用middleHandlerUser
	// test.Get("", routeTest)    // http://127.0.0.1:8080/test

	app.Use(bigbefore)                    // 全局Use
	app.Done(bigafter)                    // 全局Done
	app.UseGlobal(useGlobal)              // 全局UseGlobal
	mvc.Configure(app.Party("/"), config) // 路由分组

	// 7.启动服务
	app.Run(iris.Addr(":8080"))
}

func config(app *mvc.Application) {
	//添加基本身份验证（admin：password）中间件
	//用于基于/电影的请求。
	app.Router.Use(groupBefore) // 小组前置
	app.Router.Done(groupAfter) // 小组后置
	// 使用数据源中的一些（内存）数据创建我们的电影资源库。
	//repo := repositories.NewMovieRepository(datasource.Movies)
	// 创建我们的电影服务，我们将它绑定到电影应用程序的依赖项。
	//movieService := services.NewMovieService(repo)
	//app.Register(movieService)
	//为我们的电影控制器服务
	//请注意，您可以为多个控制器提供服务
	//你也可以使用`movies.Party（relativePath）`或`movies.Clone（app.Party（...））创建子mvc应用程序
	userService123 := services.NewUserService()	// 传入的是一个Interface类型的接口
	app.Register(userService123)
	app.Handle(new(controllers.IndexController))
}

func groupBefore(ctx iris.Context) {
	ctx.HTML("小组Use | ")
	ctx.Next()
}

func groupAfter(ctx iris.Context) {
	ctx.HTML("小组Done | ")
	ctx.Next()
}

func useGlobal(ctx iris.Context) {
	ctx.HTML("全局UseGlobal | ")
	ctx.Next()
}

func b(ctx iris.Context) {
	ctx.HTML("user组before | ")
	ctx.Next()
}

func a(ctx iris.Context) {
	ctx.HTML("user组after | ")
	ctx.Next()
}

func middleHandlerUser(ctx iris.Context) {
	ctx.HTML("user组middleHandler | ")
	ctx.Next()
}

func routeUserUserTest(ctx iris.Context) {
	ctx.WriteString("/user/user/test | ")
	ctx.Next()
}

func routeUser(ctx iris.Context) {
	ctx.WriteString("/user | ")
	ctx.Next()
}

func routeUserTest(ctx iris.Context) {
	ctx.WriteString("/user/test | ")
	ctx.Next()
}

func before(ctx iris.Context) {
	ctx.WriteString("我是/user/test的before方法 | ")
	ctx.Next()
}

func after(ctx iris.Context) {
	ctx.WriteString("我是/user/test的after方法 | ")
	ctx.Next()
}

func routeTest(ctx iris.Context) {
	ctx.WriteString("/test | ")
	ctx.Next()
}

func bigbefore(ctx iris.Context) {
	ctx.WriteString("全局Use | ")
	ctx.Next()
}

func bigafter(ctx iris.Context) {
	ctx.WriteString("全局Done | ")
	ctx.Next()
}