Golang中HTTP路由设计的使用与实现（golannia品牌）这样也行？

目录Golang之HTTP路由设计动手编写自己的路由framework/core.goframework/group.go如何实现动态路由改造一下core.go验证

func registerRouter(core *framework.Core) {
print(111)
// 设置控制器
core.Get(“/foo”, FooController)
core.Get(“/user/login”, UserLoginController)
subjectApi :=core.Group(“/subject”)
{
// restful路由，根据请求类型区分了开，：id为动态路由
subjectApi.Get(“/list/all”, SubjectListController)
subjectApi.Post(“/add”, SubjectListController)
subjectApi.Delete(“/:id”, SubjectListController)
subjectApi.Put(“/:id”, SubjectListController)
subjectApi.Get(“/:id”, SubjectListController)
}
}

package framework
import (
“net/http”
“strings”
)
const (
GET=”GET”
PUT=”PUT”
DELETE=”DELETE”
POST=”POST”
)
//map[string]map[string]ControllerHandler 前面存请求类型后面是路径对应执行方法
type Core struct {
router map[string]map[string]ControllerHandler
}
func (c Core) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
ctx:=NewContext(request, writer)
router:=c.FindRouteByRequest(request)
if router==nil{
ctx.Json(404,”router not found “)
return
}
if err:=router(ctx);err!=nil{
ctx.Json(500,”server Interval”)
return
}
//http.DefaultServeMux.ServeHTTP(writer, request)
}
func NewCore() *Core {
getRouter :=map[string]ControllerHandler{}
postRouter :=map[string]ControllerHandler{}
putRouter :=map[string]ControllerHandler{}
deleteRouter :=map[string]ControllerHandler{}
core :=&Core{
router: make(map[string]map[string]ControllerHandler, 0),
}
// 初始化好四种类型的路由map
core.router[GET]=getRouter
core.router[POST]=postRouter
core.router[PUT]=putRouter
core.router[DELETE]=deleteRouter
return core
}
// 注册Get方法
func (c *Core) Get(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern)
c.router[GET][url]=handler
}
// 注册Post方法
func (c *Core) Post(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern) // 大小写不敏感
c.router[POST][url]=handler
}
// 注册Put方法
func (c *Core) Put(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern)
c.router[PUT][url]=handler
}
// 注册Delete方法
func (c *Core) Delete(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern)
c.router[DELETE][url]=handler
}
// 寻找http+静态路由
func (c *Core) FindRouteByRequest(request *http.Request) ControllerHandler {
uri :=request.URL.Path //请求处理器映射地址
method :=request.Method // 请求类型
upperMethod :=strings.ToUpper(method)
upperURI :=strings.ToUpper(uri)
// 找到类型下的具体地址的映射地址的方法，这里还没有实现动态什么的就固定有1个路径key，但是先别急，后面我们再来动手改造
if data, ok :=c.router[upperMethod]; ok {
if handler, ok1 :=data[upperURI]; ok1 {
return handler
}
}
return nil
}

package framework
//IGroup 代表前缀分组
type IGroup interface {
Get(string, ControllerHandler)
Post(string, ControllerHandler)
Delete(string, ControllerHandler)
Put(string, ControllerHandler)
}
//
type Group struct {
core *Core //
perfix string // 自身前缀
}
func (g Group) Get(s string, handler ControllerHandler) {
url :=g.perfix + s
g.core.Get(url, handler)
}
func (g Group) Post(s string, handler ControllerHandler) {
url :=g.perfix + s
g.core.Post(url, handler)
}
func (g Group) Delete(s string, handler ControllerHandler) {
url :=g.perfix + s
g.core.Delete(url, handler)
}
func (g Group) Put(s string, handler ControllerHandler) {
url :=g.perfix + s
g.core.Put(url, handler)
}
func NewGroup(core *Core, perfix string) *Group {
return &Group{core: core, perfix: perfix}
}
func (c *Core)Group(prefix string)IGroup{
return NewGroup(c,prefix)
}

// 实现动态路由匹配树
type Tree struct {
root *node // 根结点
}
// 代表节点
type node struct {
isLast bool // 代表这个节点是否可以成为最终的路由规则。 该节点是否能成为一
segment string // url 中的字符串，代表这个节点表示的路由中某个段的字符串
handler ControllerHandler // 代表这个节点中包含的控制器，用于最终加载调用
childes []*node // 代表这个节点下的子节点
}

//matchNode 方法的参数是一个 URI，返回值是指向 node 的指针，它的实现思路是使用函数递归
// 判断是否动态路由
func isWildSegment(segment string) bool {
return strings.HasPrefix(segment, “:”)
}

//过滤下一层满足 segment 规则的子节点
func (n *node) filterChildNodes(segment string) []*node {
if len(n.childes)==0 {
return nil
}
// 如果是动态路由则子节点直接满足条件
if isWildSegment(segment) {
return n.childes
}
// 不是的话就从子节点里面找2
nodes :=make([]*node, 0, len(n.childes))
for _, node :=range n.childes {
// 判断所有子节点里面是否有动态路由或者唯一匹配的路由
if isWildSegment(node.segment) || node.segment==segment {
nodes=append(nodes, node)
}
}
return nodes
}
// 匹配路由
func (n *node) matchNode(url string) *node {
// 正序拆分路由第一个/
segments :=strings.SplitN(url, “/”, 2)
segment :=segments[0] // 第一个路由节点
//判断如果不是动态路由，那么都统一大写
if !isWildSegment(segment) {
segment=strings.ToUpper(segment)
}
// 找到下一层路由节点
nodes :=n.filterChildNodes(segment)
// 错误返回
if nodes==nil || len(nodes) <=0 {
return nil
}
//如果只有一个子节点了，是最后的话就返回最后的一个路由节点
if len(segments)==1 {
for _, node :=range nodes {
if node.isLast {
return node
}
}
return nil
}
// 否则持续循环去判断各个节点集合中的递归下一层
for _, v :=range nodes {
toMatch :=v.matchNode(segments[1])
if toMatch !=nil {
return toMatch
}
return nil
}
return nil
}

// 增加路由
func (tree *Tree) AddRoute(url string, handler ControllerHandler) error {
n :=tree.root
// 确认路由是否已存在
if n.matchNode(url) !=nil {
return errors.New(fmt.Sprintf(“add router %v error”, url))
}
segments :=strings.Split(url, “/”)
// 对每个segment
for index, segment :=range segments {
// 不是动态路由的静态节点 需要转变大写
if !isWildSegment(segment) {
segment=strings.ToUpper(segment)
}
isLast :=index==len(segments)-1 // 判断是否为最后一个节点
var objNode *node
childNodes :=n.filterChildNodes(segment)
if len(childNodes) > 0 {
// 如果有segment相同的子节点，则选择这个子节点
for _, node :=range childNodes {
if node.segment==segment {
objNode=node
break
}
}
}
// 如果没有找到相同的子节点，那么就自己构造一个添加进tree里面
if objNode==nil {
objNode=&node{
isLast: isLast,
segment: segment,
handler: nil,
childes: make([]*node, 0),
}
if isLast {
objNode.handler=handler
}
n.childes=append(n.childes, objNode)
}
n=objNode
}
return nil
}
// 寻找对应的映射控制器处理方法
func (tree *Tree) FindHandler(url string) ControllerHandler {
// 直接复用
matchNode :=tree.root.matchNode(url)
if matchNode==nil {
return nil
}
return matchNode.handler
}

package framework
import (
“log”
“net/http”
“strings”
)
const (
GET=”GET”
PUT=”PUT”
DELETE=”DELETE”
POST=”POST”
)
type Core struct {
router map[string]*Tree
}
func (c Core) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
ctx :=NewContext(request, writer)
router :=c.FindRouteByRequest(request)
if router==nil {
ctx.Json(404, “router not found “)
return
}
if err :=router(ctx); err !=nil {
ctx.Json(500, “server Interval”)
return
}
//http.DefaultServeMux.ServeHTTP(writer, request)
}
func NewCore() *Core {
getRouter :=NewTree()
postRouter :=NewTree()
putRouter :=NewTree()
deleteRouter :=NewTree()
core :=&Core{
router: make(map[string]*Tree, 0),
}
core.router[GET]=getRouter
core.router[POST]=postRouter
core.router[PUT]=putRouter
core.router[DELETE]=deleteRouter
return core
}
// 注册Get方法
func (c *Core) Get(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern)
if err :=c.router[GET].AddRoute(url, handler); err !=nil {
log.Fatal(“add router error:”, err)
}
}
// 注册Post方法
func (c *Core) Post(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern) // 大小写不敏感
if err :=c.router[POST].AddRoute(url, handler); err !=nil {
log.Fatal(“add router error:”, err)
}
}
func (c *Core) Put(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern)
if err :=c.router[PUT].AddRoute(url, handler); err !=nil {
log.Fatal(“add router error:”, err)
}
}
func (c *Core) Delete(pattern string, handler ControllerHandler) {
url :=strings.ToUpper(pattern)
if err :=c.router[DELETE].AddRoute(url, handler); err !=nil {
log.Fatal(“add router error:”, err)
}
}
// 寻找http+静态路由
func (c *Core) FindRouteByRequest(request *http.Request) ControllerHandler {
uri :=request.URL.Path
method :=request.Method
upperMethod :=strings.ToUpper(method)
// upperURI :=strings.ToUpper(uri) 内部路由会去判断非动态会转大写
if data, ok :=c.router[upperMethod]; ok {
return data.FindHandler(uri)
}
return nil
}

func UserLoginController(ctx *framework.Context) error {
ctx.Json(200, “ok,UserLoginController”)
return nil
}
func SubjectListController(ctx *framework.Context) error {
ctx.Json(200, “ok,SubjectListController”)
return nil
}

您可能感兴趣的文章:Golang?HTTP服务超时控制实现原理分析Golang搭建HTTP服务器Golang中基于HTTP协议的网络服务Golang实现简单http服务器的示例详解Golang?HTTP编程的源码解析详解Golang实现HTTP编程请求和响应Golang Http请求返回结果处理Golang中HTTP服务的分析与设计详解