• 3.4 Zinx-V0.3代码实现

    3.4 Zinx-V0.3代码实现

    zinx/znet/server.go

    1. package znet
    2. import (
    3. "fmt"
    4. "net"
    5. "time"
    6. "zinx/ziface"
    7. )
    8. //iServer 接口实现,定义一个Server服务类
    9. type Server struct {
    10. //服务器的名称
    11. Name string
    12. //tcp4 or other
    13. IPVersion string
    14. //服务绑定的IP地址
    15. IP string
    16. //服务绑定的端口
    17. Port int
    18. //当前Server由用户绑定的回调router,也就是Server注册的链接对应的处理业务
    19. Router ziface.IRouter
    20. }
    21. /*
    22. 创建一个服务器句柄
    23. */
    24. func NewServer (name string) ziface.IServer {
    25. s:= &Server {
    26. Name :name,
    27. IPVersion:"tcp4",
    28. IP:"0.0.0.0",
    29. Port:7777,
    30. Router: nil,
    31. }
    32. return s
    33. }
    34. //============== 实现 ziface.IServer 里的全部接口方法 ========
    35. //开启网络服务
    36. func (s *Server) Start() {
    37. fmt.Printf("[START] Server listenner at IP: %s, Port %d, is starting\n", s.IP, s.Port)
    38. //开启一个go去做服务端Linster业务
    39. go func() {
    40. //1 获取一个TCP的Addr
    41. addr, err := net.ResolveTCPAddr(s.IPVersion, fmt.Sprintf("%s:%d", s.IP, s.Port))
    42. if err != nil {
    43. fmt.Println("resolve tcp addr err: ", err)
    44. return
    45. }
    46. //2 监听服务器地址
    47. listenner, err:= net.ListenTCP(s.IPVersion, addr)
    48. if err != nil {
    49. fmt.Println("listen", s.IPVersion, "err", err)
    50. return
    51. }
    52. //已经监听成功
    53. fmt.Println("start Zinx server ", s.Name, " succ, now listenning...")
    54. //TODO server.go 应该有一个自动生成ID的方法
    55. var cid uint32
    56. cid = 0
    57. //3 启动server网络连接业务
    58. for {
    59. //3.1 阻塞等待客户端建立连接请求
    60. conn, err := listenner.AcceptTCP()
    61. if err != nil {
    62. fmt.Println("Accept err ", err)
    63. continue
    64. }
    65. //3.2 TODO Server.Start() 设置服务器最大连接控制,如果超过最大连接,那么则关闭此新的连接
    66. //3.3 处理该新连接请求的 业务 方法, 此时应该有 handler 和 conn是绑定的
    67. dealConn := NewConntion(conn, cid, s.Router)
    68. cid ++
    69. //3.4 启动当前链接的处理业务
    70. go dealConn.Start()
    71. }
    72. }()
    73. }
    74. func (s *Server) Stop() {
    75. fmt.Println("[STOP] Zinx server , name " , s.Name)
    76. //TODO Server.Stop() 将其他需要清理的连接信息或者其他信息 也要一并停止或者清理
    77. }
    78. func (s *Server) Serve() {
    79. s.Start()
    80. //TODO Server.Serve() 是否在启动服务的时候 还要处理其他的事情呢 可以在这里添加
    81. //阻塞,否则主Go退出, listenner的go将会退出
    82. for {
    83. time.Sleep(10*time.Second)
    84. }
    85. }
    86. //路由功能:给当前服务注册一个路由业务方法,供客户端链接处理使用
    87. func (s *Server)AddRouter(router ziface.IRouter) {
    88. s.Router = router
    89. fmt.Println("Add Router succ! " )
    90. }

    zinx/znet/conneciont.go

    1. package znet
    2. import (
    3. "fmt"
    4. "net"
    5. "zinx/ziface"
    6. )
    7. type Connection struct {
    8. //当前连接的socket TCP套接字
    9. Conn *net.TCPConn
    10. //当前连接的ID 也可以称作为SessionID,ID全局唯一
    11. ConnID uint32
    12. //当前连接的关闭状态
    13. isClosed bool
    14. //该连接的处理方法router
    15. Router ziface.IRouter
    16. //告知该链接已经退出/停止的channel
    17. ExitBuffChan chan bool
    18. }
    19. //创建连接的方法
    20. func NewConntion(conn *net.TCPConn, connID uint32, router ziface.IRouter) *Connection{
    21. c := &Connection{
    22. Conn: conn,
    23. ConnID: connID,
    24. isClosed: false,
    25. Router: router,
    26. ExitBuffChan: make(chan bool, 1),
    27. }
    28. return c
    29. }
    30. func (c *Connection) StartReader() {
    31. fmt.Println("Reader Goroutine is running")
    32. defer fmt.Println(c.RemoteAddr().String(), " conn reader exit!")
    33. defer c.Stop()
    34. for {
    35. //读取我们最大的数据到buf中
    36. buf := make([]byte, 512)
    37. _, err := c.Conn.Read(buf)
    38. if err != nil {
    39. fmt.Println("recv buf err ", err)
    40. c.ExitBuffChan <- true
    41. continue
    42. }
    43. //得到当前客户端请求的Request数据
    44. req := Request{
    45. conn:c,
    46. data:buf,
    47. }
    48. //从路由Routers 中找到注册绑定Conn的对应Handle
    49. go func (request ziface.IRequest) {
    50. //执行注册的路由方法
    51. c.Router.PreHandle(request)
    52. c.Router.Handle(request)
    53. c.Router.PostHandle(request)
    54. }(&req)
    55. }
    56. }
    57. //启动连接,让当前连接开始工作
    58. func (c *Connection) Start() {
    59. //开启处理该链接读取到客户端数据之后的请求业务
    60. go c.StartReader()
    61. for {
    62. select {
    63. case <- c.ExitBuffChan:
    64. //得到退出消息,不再阻塞
    65. return
    66. }
    67. }
    68. }
    69. //停止连接,结束当前连接状态M
    70. func (c *Connection) Stop() {
    71. //1. 如果当前链接已经关闭
    72. if c.isClosed == true {
    73. return
    74. }
    75. c.isClosed = true
    76. //TODO Connection Stop() 如果用户注册了该链接的关闭回调业务,那么在此刻应该显示调用
    77. // 关闭socket链接
    78. c.Conn.Close()
    79. //通知从缓冲队列读数据的业务,该链接已经关闭
    80. c.ExitBuffChan <- true
    81. //关闭该链接全部管道
    82. close(c.ExitBuffChan)
    83. }
    84. //从当前连接获取原始的socket TCPConn
    85. func (c *Connection) GetTCPConnection() *net.TCPConn {
    86. return c.Conn
    87. }
    88. //获取当前连接ID
    89. func (c *Connection) GetConnID() uint32{
    90. return c.ConnID
    91. }
    92. //获取远程客户端地址信息
    93. func (c *Connection) RemoteAddr() net.Addr {
    94. return c.Conn.RemoteAddr()
    95. }