golang7_ TCP programming

Basic introduction of network programming

There are two kinds of network programming :
1)TCP socket Programming , Is the mainstream of network programming . The name Tcp socket Programming , Because the bottom layer is based on Tcp/ip Association Arguable . such as : QQ Chat
2)b/s Structural http Programming , When we use the browser to access the server , What you use is http agreement , and http Bottom layer Old is used tcp socket Realized . such as : Jingdong Mall

tcp socket Programming

Write a server program , stay 8888 Port listening You can create links with multiple clients
After the link is successful , The client can send data , Server side accepts data , And displayed on the terminal .
First use telnet To test , Then write a client program to test

server

func process(conn net.Conn) {
    
	// Here we receive the data sent by the client circularly 
	defer conn.Close() // close conn
	for {
    
		// Create a new slice 
		buf := make([]byte, 1024)
		//conn.Read(buf)
		//1.  Wait for the client to pass conn Send a message 
		//2.  If the client does not wrtie[ send out ], So the coroutine is stuck here 
		//fmt.Printf(" The server is waiting for the client %s  Send a message \n", conn.RemoteAddr().String())
		n , err := conn.Read(buf) // from conn Read 
		if err != nil {
    
			
			fmt.Printf(" Client exit  err=%v", err)
			return //!!!
		}
		//3.  Display the content sent by the client to the terminal of the server 
		fmt.Print(string(buf[:n])) 
	}
}

func main() {
    

	fmt.Println(" The server starts listening ....")
	//net.Listen("tcp", "0.0.0.0:8888")
	//1. tcp  Indicates that the use of network protocol is tcp
	//2. 0.0.0.0:8888  Means listening locally  8888 port 
	listen, err := net.Listen("tcp", "0.0.0.0:8888")
	if err != nil {
    
		fmt.Println("listen err=", err)
		return 
	}
	defer listen.Close() // Delay off listen
	// Loop waiting for the client to link me 
	for {
    
		// Waiting for client link 
		fmt.Println(" Wait for the client to link ....")
		conn, err := listen.Accept()
		if err != nil {
    
			fmt.Println("Accept() err=", err)
			
		} else {
    
			fmt.Printf("Accept() suc con=%v  client ip=%v\n", conn, conn.RemoteAddr().String())
		}
		// Here is a collaborative process , Serving clients 
		go process(conn)
	}
	//fmt.Printf("listen suc=%v\n", listen)
}

client

func main() {
    
	conn, err := net.Dial("tcp", "192.168.20.253:8888")
	if err != nil {
    
		fmt.Println("client dial err=", err)
		return 
	}
	// Function one ： The client can send a single line of data , And then quit 
	reader := bufio.NewReader(os.Stdin) //os.Stdin  For standard input [ terminal ]

	for {
    
		// Read a line of user input from the terminal , And ready to send it to the server 
		line, err := reader.ReadString('\n')
		if err != nil {
    
			fmt.Println("readString err=", err)
		}
		// If the user enters  exit Quit 
		line = strings.Trim(line, " \r\n")
		if line == "exit" {
    
			fmt.Println(" Client exit ..")
			break
		}
		// then line  Send to   The server 
		_, err = conn.Write([]byte(line + "\n"))
		if err != nil {
    
			fmt.Println("conn.Write err=", err)	
		}
	}
}