[TOC]
# 简介
支持3种形式的路由
1. 函数注册级别的restful路由
2. control级别的注册自动化的映射
3. 更自由化的handle注册,只要实现了ServeHTTP(response, request)函数的都可以
前面是包名,后面是方法,第三个参数是你指定方法
`/:?id`表示传递参数
~~~
func init() {
beego.Router("/", &controllers.MainController{})
beego.Router("/user", &controllers.UserController{})
beego.Router("/user/info/?:id", &controllers.UserController{}, "get:GetInfo")
}
~~~
对应controllers包下面的我创建个文件user.go就这样写
~~~
import (
"github.com/astaxie/beego"
)
type UserController struct {
beego.Controller
}
func (c *UserController) GetInfo() {
c.Ctx.WriteString("hello world---111-----\n")
id := c.Ctx.Input.Param(":id")
c.Ctx.WriteString("getInfo data, id = "+id)
}
~~~
如果想要post的话就这样指定
~~~
beego.Router("/user/info", &controllers.UserController{}, "get:GetInfo;post:PostInfo")
~~~
# 重定向
把/index.html实际指向到/static/html/+
~~~
func main() {
ignoreStaticPath()
beego.Run()
}
//重定向
func ignoreStaticPath() {
//没有匹配到的
beego.InsertFilter("/", beego.BeforeRouter, TransparentStatic)
//匹配所有的
beego.InsertFilter("/*", beego.BeforeRouter, TransparentStatic)
}
func TransparentStatic(ctx *context.Context) {
//"github.com/astaxie/beego/context" 导入这个包
orpath := ctx.Request.URL.Path
beego.Debug("request url: ", orpath)
//如果请求url还有api字段,说明指令应该取消静态资源路径重定向
if (strings.Index(orpath, "api") >= 0) {
return
}
//"net/http"
//重定向到 /static/html/+ 这个路径
http.ServeFile(ctx.ResponseWriter, ctx.Request, "static/html/"+ctx.Request.URL.Path)
}
~~~
# 正则路由
~~~
/**
41 * 正则路由实践
42 */
43
44 /**
45 * 正则路由实践
46 * 注意事项：1. 第二个参数需要传递一个控制器：Controller
47 * 2. 【?:id】 中的id也可以换成其他字符，如：【?:abc】
48 * 测试用例：能 匹 配：/api ; /api/123 ; /api/abc ; /api/abc.html ; /api/abc/
49 不能匹配：/api/123/456 ：即/api/之后只能再接一个参数
50 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
51 */
52 beego.Router("/api/?:id", &controllers.MainController{})
53
54 /**
55 * 正则路由实践
56 * 注意事项：【:id】前面没有了 ?
57 * 测试用例：能 匹 配：/api/123 ; /api/abc ; /api/abc.html ; /api/abc/
58 不能匹配：/api ; /api/123/456 ：即/api/之后只能再接一个参数
59 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
60 */
61 beego.Router("/api/:id", &controllers.MainController{})
62
63 /**
64 * 正则路由实践
65 * 注意事项：【:id】前面没有了 ?
66 * 测试用例：能 匹 配：/api/123 ; /api/0
67 不能匹配：/api ; /api/123/456 ; /api/abc ; /api/123.html
68 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
69 */
70 beego.Router("/api/:id:int", &controllers.MainController{})
71
72 /**
73 * 正则路由实践
74 * 注意事项：:id([0-9]+) 之中有个 + 号。有+号时表示可以是多位数字，无+号表示就只能匹配一位数字
75 * 测试用例：能 匹 配：/api/123 ; /api/0
76 不能匹配：/api ; /api/abc ; /api/123/456 ：即/api/之后只能再接一个参数
77 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
78 */
79 beego.Router("/api/:id([0-9]+)", &controllers.MainController{})
80
81 /**
82 * 正则路由实践
83 * 注意事项：:[\\w] 之中的w不能替换为别的字符
84 * 测试用例：能 匹 配：/api/123 ; /api/hezhixiong
85 不能匹配：/api ; /api/abc.html
86 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
87 */
88 beego.Router("/api/:username([\\w]+)", &controllers.MainController{})
89
90 /**
91 * 正则路由实践
92 * 注意事项：: :username:string表示 username为string型
93 * 测试用例：能 匹 配：/api/123 ; /api/hezhixiong
94 不能匹配：/api ; /api/abc.html
95 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
96 */
97 beego.Router("/api/:username:string", &controllers.MainController{})
98
99 /**
100 * 正则路由实践
101 * 注意事项：:无
102 * 测试用例：能 匹 配：/api/123 ; /api/hezhixiong ; /api/abc.html ; /api/abc/123/efg/ddd
103 不能匹配：/api
104 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
105 */
106 beego.Router("/api/*.*", &controllers.MainController{})
107
108 /**
109 * 正则路由实践
110 * 注意事项：:无
111 * 测试用例：能 匹 配：/api/123 ; /api/hezhixiong ; /api/abc.html ; /api/abc/123/efg/ddd
112 不能匹配：/api
113 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
114 */
115 beego.Router("/api/*", &controllers.MainController{})
116
117 /**
118 * 正则路由实践
119 * 注意事项：:无
120 * 测试用例：能 匹 配：/api/bei_123.html ; /api/bei_0.html
121 不能匹配：/api/bei_.html ; /api/bei_123 ; /api/bei_12a.html
122 * 输出结果：具体输出结果需要看第二个参数的Get()方法所指定的模板和数据。
123 */
124 beego.Router("/api/bei_:id([0-9]+).html", &controllers.MainController{})
~~~
# 函数级别的注册
~~~
beego.Get(router, beego.FilterFunc)
beego.Post(router, beego.FilterFunc)
//任何方式
beego.Any(router, beego.FilterFunc)
~~~
~~~
beego.Get("/", func(c *context.Context) {
c.Output.Body([]byte("---------------"))
})
~~~
参数路由适用于函数和control设置,解析后的数据可以在`ctx.Input.Param()`获取
# 映射路由
~~~
beego.Router("/user/info", &Restcontrollers{}, "*:GetInfo")
beego.Router("/user/info", &Restcontrollers{}, "get,post:GetInfo")
beego.Router("/user/info", &Restcontrollers{}, "get:GetInfo;post:GetInfo")
~~~
# 自动化路由
~~~
beego.AutoRouter(&controllers.ObjectController{})
~~~
请求映射如下:
~~~
/object/login 调用ObjectController中的Login方法
~~~
除了前缀两个`/:controller/:method`的匹配外,剩下的url,beego会帮你解析为参数,保存在`this.Ctx.Input.Param`当中:
~~~
/object/blog/2013/03/5 调用ObjectController中的Blog方法,参数如下:map[0:2013, 1:03, 2:5]
~~~
~~~
/object/LOGIN 也是解析到Login方法
~~~
自动化路由之API解析
现在可以自动化解析下面的url,把请求分发给controller下面的simple方法
~~~
/controller/simple
/controller/simple.json
/controller/simple.html
/controller/simple.rss
~~~
可以通过`this.Ctx.Input.Param(":ext")`获取后缀名
# 注解路由
beego 自动会进行源码分析，注意只会在 dev 模式下进行生成，生成的路由放在 `/routers/`
用户无需在 router 中注册路由，只需要 Include 相应地 controller，然后在 controller 的 method 方法上面写上 router 注释（// @router）就可以了，详细的使用请看下面的例子：
~~~
// CMS API
type CMSController struct {
beego.Controller
}
func (c *CMSController) URLMapping() {
c.Mapping("StaticBlock", c.StaticBlock)
c.Mapping("AllBlock", c.AllBlock)
}
// @router /staticblock/:key [get]
func (this *CMSController) StaticBlock() {
}
// @router /all/:key [get]
func (this *CMSController) AllBlock() {
}
~~~
可以在`router.go`中通过如下方式注册路由：
~~~
beego.Include(&CMSController{})
~~~
beego 自动会进行源码分析，注意只会在 dev 模式下进行生成，生成的路由放在 “/routers/commentsRouter.go” 文件中。
这样上面的路由就支持了如下的路由：
* GET /staticblock/:key
* GET /all/:key
其实效果和自己通过 Router 函数注册是一样的：
~~~
beego.Router("/staticblock/:key", &CMSController{}, "get:StaticBlock")
beego.Router("/all/:key", &CMSController{}, "get:AllBlock")
~~~
对应控制器
~~~
// CMS API
type CMSController struct {
beego.Controller
}
func (c *CMSController) URLMapping() {
c.Mapping("StaticBlock", c.StaticBlock)
c.Mapping("AllBlock", c.AllBlock)
}
// @router /staticblock/:key1 [get]
func (this *CMSController) StaticBlock() {
this.Ctx.WriteString("hello world---112211-----\n")
key1 := this.Ctx.Input.Param(":key1")
this.Ctx.WriteString("getInfo data, key = "+key1)
}
// @router /all/:key1 [get]
func (this *CMSController) AllBlock() {
}
~~~
# 命名空间
**cond**
~~~
Cond(cond namespaceCond)
~~~
看域名是不是这个api.beego.me不是就给404
~~~
ns:=NewNamespace("/v1")
ns.Cond(func(ctx *context.Context) bool {
//判断域名
if ctx.Input.Domain() == "api.beego.me" {
return true
}
return false
})
~~~
# 多模块
多模块使用namespace,然后引用的地方注册
~~~
beego.AddNamespace(ns)
~~~
~~~
//shop model
shop := NewNamespace("/shop")
//order model
order := NewNamespace("/order")
min.go
beego.AddNamespace(shop, order)
~~~
~~~
/**
184 * namespace路由实践
185 * 注意事项：必须要把NewNamespace的对象注册到AddNamespace中去，否则无效
186 * 测试用例：仅仅匹配：/aaa/go
187 * 输出结果：get请求的情况下，执行指定函数Login；其他HTTP method则按照RESTful规则
188 */
189 ns_1 := beego.NewNamespace("aaa", beego.NSRouter("/go", &controllers.MainController{}, "get:Login"))
190 // beego.AddNamespace(ns_1)
191
192 /**
193 * 域名如果不是：127.0.0.1，则不可以匹配 /bbb/go
194 * 仅仅匹配：/bbb/go
195 */
196 ns_2 := beego.NewNamespace("bbb",
197 beego.NSCond(func(ctx *context.Context) bool {
198 if ctx.Input.Domain() == "127.0.0.1" {
199 return true
200 }
201 return false
202 }),
203 beego.NSRouter("/go", &controllers.MainController{}, "get:Login"),
204 )
205
206 ns_3 := beego.NewNamespace("ccc",
207 beego.NSRouter("/go", &controllers.MainController{}, "get:Login"),
208 // 条件判断，如果为真，则可以匹配上下文的路由，如果为假，则上下文的路由都不能匹配
209 beego.NSCond(func(ctx *context.Context) bool {
210 if ctx.Input.Domain() == "127.0.0.1" {
211 return true
212 }
213 return false
214 }),
215 beego.NSRouter("php", &controllers.MainController{}),
216 beego.NSGet("java", func(ctx *context.Context) {
217 ctx.Output.Body([]byte("显示Get追加的内容"))
218 }),
219
220 // nasespace嵌套示例
221 beego.NSNamespace("room",
222 beego.NSCond(func(ctx *context.Context) bool {
223 // 如果子namespace的判断条件为假，那么仅仅是子namespace的url不能匹配，不影响夫namespace的匹配结果
224 if ctx.Input.Request.Method != "GET" {
225 return true
226 }
227 return false
228 }),
229 beego.NSRouter("/shanghai", &controllers.MainController{}), // 匹配地址：/ccc/room/shanghai
230 ),
231 )
232
233 beego.AddNamespace(ns_1, ns_2, ns_3)
234 }
~~~
# 定义的 handler
有些时候我们已经实现了一些 rpc 的应用,但是想要集成到 beego 中,或者其他的 httpserver 应用,集成到 beego 中来.现在可以很方便的集成:
~~~
s := rpc.NewServer()
s.RegisterCodec(json.NewCodec(), "application/json")
s.RegisterService(new(HelloService), "")
beego.Handler("/rpc", s)
~~~
`beego.Handler(router, http.Handler)`这个函数是关键,第一个参数表示路由 URI, 第二个就是你自己实现的`http.Handler`, 注册之后就会把所有 rpc 作为前缀的请求分发到`http.Handler`中进行处理.
这个函数其实还有第三个参数就是是否是前缀匹配,默认是 false, 如果设置了 true, 那么就会在路由匹配的时候前缀匹配,即`/rpc/user`这样的也会匹配去运行
~~~
beego.Handler("/rpc", s, true)
~~~
# 跨域
~~~
beego.InsertFilter("*", beego.BeforeRouter, cors.Allow(&cors.Options{
AllowOrigins: []string{"*"},
AllowMethods: []string{"GET", "PUT", "PATCH", "POST"},
AllowHeaders: []string{"Origin", "Authorization", "Access-Control-Allow-Origin", "Access-Control-Allow-Headers", "Content-Type", "token"},
ExposeHeaders: []string{"Content-Length"},
AllowCredentials: true}))
~~~
- 基础
- 简介
- 主要特征
- 变量和常量
- 编码转换
- 数组
- byte与rune
- big
- sort接口
- 和mysql类型对应
- 函数
- 闭包
- 工作区
- 复合类型
- 指针
- 切片
- map
- 结构体
- sync.Map
- 随机数
- 面向对象
- 匿名组合
- 方法
- 接口
- 权限
- 类型查询
- 异常处理
- error
- panic
- recover
- 自定义错误
- 字符串处理
- 正则表达式
- json
- 文件操作
- os
- 文件读写
- 目录
- bufio
- ioutil
- gob
- 栈帧的内存布局
- shell
- 时间处理
- time详情
- time使用
- new和make的区别
- container
- list
- heap
- ring
- 测试
- 单元测试
- Mock依赖
- delve
- 命令
- TestMain
- path和filepath包
- log日志
- 反射
- 详解
- plugin包
- 信号
- goto
- 协程
- 简介
- 创建
- 协程退出
- runtime
- channel
- select
- 死锁
- 互斥锁
- 读写锁
- 条件变量
- 嵌套
- 计算单个协程占用内存
- 执行规则
- 原子操作
- WaitGroup
- 定时器
- 对象池
- sync.once
- 网络编程
- 分层模型
- socket
- tcp
- udp
- 服务端
- 客户端
- 并发服务器
- Http
- 简介
- http服务器
- http客户端
- 爬虫
- 平滑重启
- context
- httptest
- 优雅中止
- web服务平滑重启
- beego
- 安装
- 路由器
- orm
- 单表增删改查
- 多级表
- orm使用
- 高级查询
- 关系查询
- SQL查询
- 元数据二次定义
- 控制器
- 参数解析
- 过滤器
- 数据输出
- 表单数据验证
- 错误处理
- 日志
- 模块
- cache
- task
- 调试模块
- config
- 部署
- 一些包
- gjson
- goredis
- collection
- sjson
- redigo
- aliyunoss
- 密码
- 对称加密
- 非对称加密
- 单向散列函数
- 消息认证
- 数字签名
- mysql优化
- 常见错误
- go run的错误
- 新手常见错误
- 中级错误
- 高级错误
- 常用工具
- 协程-泄露
- go env
- gometalinter代码检查
- go build
- go clean
- go test
- 包管理器
- go mod
- gopm
- go fmt
- pprof
- 提高编译
- go get
- 代理
- 其他的知识
- go内存对齐
- 细节总结
- nginx路由匹配
- 一些博客
- redis为什么快
- cpu高速缓存
- 常用命令
- Go 永久阻塞的方法
- 常用技巧
- 密码加密解密
- for 循环迭代变量
- 备注
- 垃圾回收
- 协程和纤程
- tar-gz
- 红包算法
- 解决golang.org/x 下载失败
- 逃逸分析
- docker
- 镜像
- 容器
- 数据卷
- 网络管理
- 网络模式
- dockerfile
- docker-composer
- 微服务
- protoBuf
- GRPC
- tls
- consul
- micro
- crontab
- shell调用
- gorhill/cronexpr
- raft
- go操作etcd
- mongodb