Elysia Tools

Durchsuche Tools, Beispiele, visuelle Erklärungen und Themenguides an einem klaren Ort.

Beliebte Kategorien

Themen

Sprache
ZHDERUPTENFRES

Elysia Tools

Mobile Navigation

Go

Web Go Netzwerk-Beispiele

Web Go Netzwerk-Beispiele einschließlich HTTP-Anfragen, HTTP-Server und TCP-Sockets

Beispiele

Einträge in dieser Sammlung

QuellcodegoEinfach

HTTP-Anfragen

GET/POST-Anfragen senden mit Headern, Query-Parametern und Anforderungs/Antwort-Handling

Schwierigkeit

4/10

Geschätzte Zeit

20 min

Schlagwörter

go, web, networking

Voraussetzungen

Basic Go, net/http package

go
// Web Go HTTP Requests Examples
// Sending HTTP GET/POST requests with proper handling

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"time"
)

// 1. Simple GET Request

// SimpleGet performs a simple HTTP GET request
func SimpleGet(url string) (string, error) {
	resp, err := http.Get(url)
	if err != nil {
		return "", fmt.Errorf("GET request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
	}

	return string(body), nil
}

// SimpleGetExample demonstrates simple GET request
func SimpleGetExample() {
	fmt.Println("--- Simple GET Request ---")

	url := "https://jsonplaceholder.typicode.com/posts/1"
	body, err := SimpleGet(url)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// 2. GET Request with Headers

// GetWithHeaders performs GET request with custom headers
func GetWithHeaders(url string, headers map[string]string) (string, error) {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return "", err
	}

	// Add headers
	for key, value := range headers {
		req.Header.Set(key, value)
	}

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	return string(body), nil
}

// GetWithHeadersExample demonstrates GET with headers
func GetWithHeadersExample() {
	fmt.Println("\n--- GET with Headers ---")

	url := "https://jsonplaceholder.typicode.com/posts/1"
	headers := map[string]string{
		"Accept":        "application/json",
		"User-Agent":    "MyGoApp/1.0",
		"Authorization": "Bearer token123",
	}

	body, err := GetWithHeaders(url, headers)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// 3. GET Request with Query Parameters

// GetWithQueryParams performs GET with query parameters
func GetWithQueryParams(baseURL string, params map[string]string) (string, error) {
	// Build URL with query parameters
	u, err := url.Parse(baseURL)
	if err != nil {
		return "", err
	}

	query := u.Query()
	for key, value := range params {
		query.Set(key, value)
	}
	u.RawQuery = query.Encode()

	url = u.String()

	resp, err := http.Get(url)
	if err != nil {
		return "", fmt.Errorf("GET request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	return string(body), nil
}

// GetWithQueryParamsExample demonstrates GET with query parameters
func GetWithQueryParamsExample() {
	fmt.Println("\n--- GET with Query Parameters ---")

	baseURL := "https://jsonplaceholder.typicode.com/posts"
	params := map[string]string{
		"userId": "1",
		"_limit": "5",
	}

	body, err := GetWithQueryParams(baseURL, params)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// 4. POST Request with JSON Body

// PostJSON sends a POST request with JSON body
func PostJSON(url string, data map[string]interface{}) (string, error) {
	jsonData, err := json.Marshal(data)
	if err != nil {
		return "", fmt.Errorf("error marshaling JSON: %v", err)
	}

	resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		return "", fmt.Errorf("POST request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
	}

	return string(body), nil
}

// PostJSONExample demonstrates POST with JSON
func PostJSONExample() {
	fmt.Println("\n--- POST JSON Request ---")

	url := "https://jsonplaceholder.typicode.com/posts"
	data := map[string]interface{}{
		"title":  "Test Post",
		"body":   "This is a test post",
		"userId": 1,
	}

	body, err := PostJSON(url, data)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// 5. POST Request with Form Data

// PostForm sends a POST request with form data
func PostForm(url string, formData map[string]string) (string, error) {
	// Build form data
	values := url.Values{}
	for key, value := range formData {
		values.Set(key, value)
	}

	resp, err := http.PostForm(url, values)
	if err != nil {
		return "", fmt.Errorf("POST form request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	return string(body), nil
}

// PostFormExample demonstrates POST with form data
func PostFormExample() {
	fmt.Println("\n--- POST Form Request ---")

	url := "https://jsonplaceholder.typicode.com/posts"
	formData := map[string]string{
		"title":  "Test Form",
		"body":   "Form data content",
		"userId": "1",
	}

	body, err := PostForm(url, formData)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// 6. PUT Request

// PutJSON sends a PUT request with JSON body
func PutJSON(url string, data map[string]interface{}) (string, error) {
	jsonData, err := json.Marshal(data)
	if err != nil {
		return "", fmt.Errorf("error marshaling JSON: %v", err)
	}

	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return "", err
	}

	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("PUT request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	return string(body), nil
}

// PutJSONExample demonstrates PUT request
func PutJSONExample() {
	fmt.Println("\n--- PUT Request ---")

	url := "https://jsonplaceholder.typicode.com/posts/1"
	data := map[string]interface{}{
		"id":     1,
		"title":  "Updated Post",
		"body":   "Updated content",
		"userId": 1,
	}

	body, err := PutJSON(url, data)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// 7. DELETE Request

// DeleteResource sends a DELETE request
func DeleteResource(url string) (int, error) {
	req, err := http.NewRequest("DELETE", url, nil)
	if err != nil {
		return 0, err
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return 0, fmt.Errorf("DELETE request failed: %v", err)
	}
	defer resp.Body.Close()

	return resp.StatusCode, nil
}

// DeleteRequestExample demonstrates DELETE request
func DeleteRequestExample() {
	fmt.Println("\n--- DELETE Request ---")

	url := "https://jsonplaceholder.typicode.com/posts/1"
	statusCode, err := DeleteResource(url)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Status Code: %d\n", statusCode)
}

// 8. Custom HTTP Client with Timeout

// HTTPClient represents a custom HTTP client
type HTTPClient struct {
	client      *http.Client
	baseURL     string
	defaultHeaders map[string]string
}

// NewHTTPClient creates a new HTTP client
func NewHTTPClient(timeout time.Duration) *HTTPClient {
	return &HTTPClient{
		client: &http.Client{
			Timeout: timeout,
		},
		defaultHeaders: make(map[string]string),
	}
}

// SetBaseURL sets the base URL for requests
func (c *HTTPClient) SetBaseURL(baseURL string) {
	c.baseURL = baseURL
}

// SetDefaultHeader sets a default header for all requests
func (c *HTTPClient) SetDefaultHeader(key, value string) {
	c.defaultHeaders[key] = value
}

// Get performs a GET request
func (c *HTTPClient) Get(path string) (string, error) {
	url := c.baseURL + path
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return "", err
	}

	// Add default headers
	for key, value := range c.defaultHeaders {
		req.Header.Set(key, value)
	}

	resp, err := c.client.Do(req)
	if err != nil {
		return "", fmt.Errorf("GET request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	if resp.StatusCode >= 400 {
		return "", fmt.Errorf("HTTP error: %d", resp.StatusCode)
	}

	return string(body), nil
}

// Post performs a POST request
func (c *HTTPClient) Post(path string, data map[string]interface{}) (string, error) {
	url := c.baseURL + path
	jsonData, err := json.Marshal(data)
	if err != nil {
		return "", err
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return "", err
	}

	req.Header.Set("Content-Type", "application/json")

	// Add default headers
	for key, value := range c.defaultHeaders {
		if key != "Content-Type" {
			req.Header.Set(key, value)
		}
	}

	resp, err := c.client.Do(req)
	if err != nil {
		return "", fmt.Errorf("POST request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	if resp.StatusCode >= 400 {
		return "", fmt.Errorf("HTTP error: %d", resp.StatusCode)
	}

	return string(body), nil
}

// CustomClientExample demonstrates custom HTTP client
func CustomClientExample() {
	fmt.Println("\n--- Custom HTTP Client ---")

	client := NewHTTPClient(10 * time.Second)
	client.SetBaseURL("https://jsonplaceholder.typicode.com")
	client.SetDefaultHeader("User-Agent", "MyGoApp/1.0")

	// GET request
	body, err := client.Get("/posts/1")
	if err != nil {
		fmt.Printf("GET Error: %v\n", err)
		return
	}
	fmt.Printf("GET Response: %s\n", body)

	// POST request
	data := map[string]interface{}{
		"title":  "New Post",
		"body":   "Post content",
		"userId": 1,
	}

	body, err = client.Post("/posts", data)
	if err != nil {
		fmt.Printf("POST Error: %v\n", err)
		return
	}
	fmt.Printf("POST Response: %s\n", body)
}

// 9. Handling Response Headers

// GetWithResponseHeaders performs GET and returns headers
func GetWithResponseHeaders(url string) (string, http.Header, error) {
	resp, err := http.Get(url)
	if err != nil {
		return "", nil, err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", nil, err
	}

	return string(body), resp.Header, nil
}

// ResponseHeadersExample demonstrates reading response headers
func ResponseHeadersExample() {
	fmt.Println("\n--- Response Headers ---")

	url := "https://jsonplaceholder.typicode.com/posts/1"
	body, headers, err := GetWithResponseHeaders(url)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Println("Response Headers:")
	for key, values := range headers {
		for _, value := range values {
			fmt.Printf("  %s: %s\n", key, value)
		}
	}

	fmt.Printf("\nBody: %s\n", body)
}

// 10. Request with Context (Timeout)

// GetWithContext performs GET with context timeout
func GetWithContext(url string, timeout time.Duration) (string, error) {
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return "", err
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("request failed: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response: %v", err)
	}

	return string(body), nil
}

// ContextExample demonstrates context with timeout
func ContextExample() {
	fmt.Println("\n--- Request with Context Timeout ---")

	url := "https://jsonplaceholder.typicode.com/posts/1"

	body, err := GetWithContext(url, 5*time.Second)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Response: %s\n", body)
}

// Main function
func main() {
	fmt.Println("=== Web Go HTTP Requests Examples ===\n")

	SimpleGetExample()
	GetWithHeadersExample()
	GetWithQueryParamsExample()
	PostJSONExample()
	PostFormExample()
	PutJSONExample()
	DeleteRequestExample()
	CustomClientExample()
	ResponseHeadersExample()
	ContextExample()

	fmt.Println("\n=== All HTTP Request Examples Completed ===")
}
QuellcodegoMittel

HTTP-Server

Einfache HTTP-Server mit Routing, Handlern und Middleware erstellen

Schwierigkeit

6/10

Geschätzte Zeit

25 min

Schlagwörter

go, web, networking

Voraussetzungen

Intermediate Go, net/http package

go
// Web Go HTTP Server Examples
// Creating HTTP servers with routing and handlers

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strings"
	"time"
)

// 1. Basic HTTP Server

// BasicHTTPServer demonstrates a simple HTTP server
func BasicHTTPServerExample() {
	fmt.Println("--- Basic HTTP Server ---")

	// Define handler
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Hello, World!\n")
		fmt.Fprintf(w, "Path: %s\n", r.URL.Path)
		fmt.Fprintf(w, "Method: %s\n", r.Method)
	})

	http.HandleFunc("/about", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "About Page\n")
	})

	http.HandleFunc("/contact", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Contact Page\n")
	})

	fmt.Println("Server starting on http://localhost:8080")
	// In real usage: log.Fatal(http.ListenAndServe(":8080", nil))
	fmt.Println("(Server would run here)")
}

// 2. Server with Custom ServeMux

// CustomServeMuxExample demonstrates using custom ServeMux
func CustomServeMuxExample() {
	fmt.Println("\n--- Custom ServeMux ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Home Page\n")
	})

	mux.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "API Endpoint\n")
	})

	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]string{"status": "healthy"})
	})

	server := &http.Server{
		Addr:    ":8080",
		Handler: mux,
	}

	fmt.Println("Server configured on :8080")
	// In real usage: log.Fatal(server.ListenAndServe())
	fmt.Println("(Server would run here)")
}

// 3. RESTful API Server

// Post represents a blog post
type Post struct {
	ID     int    `json:"id"`
	Title  string `json:"title"`
	Body   string `json:"body"`
	UserID int    `json:"userId"`
}

var posts = []Post{
	{ID: 1, Title: "First Post", Body: "Content 1", UserID: 1},
	{ID: 2, Title: "Second Post", Body: "Content 2", UserID: 1},
}

// RestfulAPIServer demonstrates RESTful API server
func RestfulAPIServerExample() {
	fmt.Println("\n--- RESTful API Server ---")

	mux := http.NewServeMux()

	// GET /posts - get all posts
	mux.HandleFunc("/posts", func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodGet {
			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(posts)
		} else {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
	})

	// GET /posts/{id} - get single post
	mux.HandleFunc("/posts/", func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodGet {
			// Extract ID from URL path
			idStr := strings.TrimPrefix(r.URL.Path, "/posts/")
			var id int
			fmt.Sscanf(idStr, "%d", &id)

			for _, post := range posts {
				if post.ID == id {
					w.Header().Set("Content-Type", "application/json")
					json.NewEncoder(w).Encode(post)
					return
				}
			}

			http.Error(w, "Post not found", http.StatusNotFound)
		} else {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
	})

	// POST /posts - create new post
	mux.HandleFunc("/posts/create", func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodPost {
			var newPost Post
			err := json.NewDecoder(r.Body).Decode(&newPost)
			if err != nil {
				http.Error(w, "Invalid request body", http.StatusBadRequest)
				return
			}

			newPost.ID = len(posts) + 1
			posts = append(posts, newPost)

			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			json.NewEncoder(w).Encode(newPost)
		} else {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
	})

	fmt.Println("RESTful API Server configured")
	// In real usage: log.Fatal(http.ListenAndServe(":8080", mux))
	fmt.Println("(Server would run here)")
}

// 4. Server with Middleware

// LoggerMiddleware logs all requests
func LoggerMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		fmt.Printf("[%s] %s %s\n", start.Format("2006-01-02 15:04:05"), r.Method, r.URL.Path)

		// Call next handler
		next.ServeHTTP(w, r)

		fmt.Printf("Completed in %v\n", time.Since(start))
	})
}

// CORSMiddleware adds CORS headers
func CORSMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

		if r.Method == "OPTIONS" {
			w.WriteHeader(http.StatusOK)
			return
		}

		next.ServeHTTP(w, r)
	})
}

// AuthMiddleware validates authentication
func AuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		token := r.Header.Get("Authorization")

		if token == "" {
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}

		if token != "Bearer valid-token" {
			http.Error(w, "Forbidden", http.StatusForbidden)
			return
		}

		next.ServeHTTP(w, r)
	})
}

// MiddlewareServerExample demonstrates server with middleware
func MiddlewareServerExample() {
	fmt.Println("\n--- Server with Middleware ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Public endpoint\n")
	})

	mux.HandleFunc("/protected", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Protected endpoint\n")
	})

	// Wrap middleware
	handler := CORSMiddleware(LoggerMiddleware(mux))

	server := &http.Server{
		Addr:    ":8080",
		Handler: handler,
	}

	fmt.Println("Server with middleware configured")
	// In real usage: log.Fatal(server.ListenAndServe())
	fmt.Println("(Server would run here)")
}

// 5. Server with Query Parameters

// QueryParamsServer demonstrates handling query parameters
func QueryParamsServerExample() {
	fmt.Println("\n--- Server with Query Parameters ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/search", func(w http.ResponseWriter, r *http.Request) {
		query := r.URL.Query()
		keyword := query.Get("q")
		page := query.Get("page")
		limit := query.Get("limit")

		result := map[string]interface{}{
			"keyword": keyword,
			"page":    page,
			"limit":   limit,
			"results": []string{"Result 1", "Result 2", "Result 3"},
		}

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(result)
	})

	fmt.Println("Server with query parameters configured")
}

// 6. Static File Server

// StaticFileServerExample demonstrates serving static files
func StaticFileServerExample() {
	fmt.Println("\n--- Static File Server ---")

	mux := http.NewServeMux()

	// Serve static files from ./static directory
	fs := http.FileServer(http.Dir("./static"))
	mux.Handle("/static/", http.StripPrefix("/static/", fs))

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Welcome! Static files at /static/\n")
	})

	fmt.Println("Static file server configured")
	// In real usage: log.Fatal(http.ListenAndServe(":8080", mux))
}

// 7. Server with Graceful Shutdown

// GracefulShutdownExample demonstrates graceful shutdown
func GracefulShutdownExample() {
	fmt.Println("\n--- Graceful Shutdown ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Server running\n")
	})

	server := &http.Server{
		Addr:    ":8080",
		Handler: mux,
	}

	// Start server in goroutine
	go func() {
		fmt.Println("Server starting...")
		// In real usage: if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		// 	log.Fatal(err)
		// }
	}()

	// Simulate graceful shutdown
	time.Sleep(1 * time.Second)

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	fmt.Println("Shutting down server...")
	// In real usage: if err := server.Shutdown(ctx); err != nil {
	// 	log.Printf("Server shutdown error: %v", err)
	// }

	fmt.Println("Server gracefully stopped")
}

// 8. JSON Request/Response Handler

// User represents a user
type User struct {
	Name  string `json:"name"`
	Email string `json:"email"`
}

// JSONHandlerExample demonstrates JSON handling
func JSONHandlerExample() {
	fmt.Println("\n--- JSON Request/Response Handler ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/api/user", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodPost:
			var user User
			err := json.NewDecoder(r.Body).Decode(&user)
			if err != nil {
				http.Error(w, "Invalid JSON", http.StatusBadRequest)
				return
			}

			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			json.NewEncoder(w).Encode(map[string]interface{}{
				"message": "User created",
				"user":    user,
			})

		default:
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
	})

	fmt.Println("JSON handler configured")
}

// 9. File Upload Handler

// FileUploadExample demonstrates file upload handling
func FileUploadExample() {
	fmt.Println("\n--- File Upload Handler ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/upload", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
			return
		}

		// Parse multipart form (max 10MB)
		err := r.ParseMultipartForm(10 << 20)
		if err != nil {
			http.Error(w, "Unable to parse form", http.StatusBadRequest)
			return
		}

		// Get file from form
		file, handler, err := r.FormFile("file")
		if err != nil {
			http.Error(w, "Error retrieving file", http.StatusBadRequest)
			return
		}
		defer file.Close()

		fmt.Printf("Uploaded file: %s (%d bytes)\n", handler.Filename, handler.Size)

		// Read file content
		fileBytes, err := ioutil.ReadAll(file)
		if err != nil {
			http.Error(w, "Error reading file", http.StatusInternalServerError)
			return
		}

		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, "File uploaded successfully: %s (%d bytes)\n", handler.Filename, len(fileBytes))
	})

	fmt.Println("File upload handler configured")
}

// 10. Server with TLS/HTTPS

// HTTPSServerExample demonstrates HTTPS server
func HTTPSServerExample() {
	fmt.Println("\n--- HTTPS Server ---")

	mux := http.NewServeMux()

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Secure connection!\n")
	})

	// Server configuration
	server := &http.Server{
		Addr:    ":8443",
		Handler: mux,
	}

	fmt.Println("HTTPS server configured on :8443")
	// In real usage:
	// log.Fatal(server.ListenAndServeTLS("server.crt", "server.key"))
	fmt.Println("(HTTPS server would run here)")
}

// Main function
func main() {
	fmt.Println("=== Web Go HTTP Server Examples ===\n")

	BasicHTTPServerExample()
	CustomServeMuxExample()
	RestfulAPIServerExample()
	MiddlewareServerExample()
	QueryParamsServerExample()
	StaticFileServerExample()
	GracefulShutdownExample()
	JSONHandlerExample()
	FileUploadExample()
	HTTPSServerExample()

	fmt.Println("\n=== All HTTP Server Examples Completed ===")
}
QuellcodegoMittel

TCP-Sockets

TCP-Verbindungen herstellen, Daten senden/empfangen und socket-basierte Kommunikation aufbauen

Schwierigkeit

6/10

Geschätzte Zeit

25 min

Schlagwörter

go, web, networking

Voraussetzungen

Intermediate Go, net package

go
// Web Go TCP Sockets Examples
// TCP socket programming for network communication

package main

import (
	"bufio"
	"encoding/binary"
	"fmt"
	"io"
	"net"
	"strings"
	"time"
)

// 1. TCP Client

// TCPClient connects to a TCP server
func TCPClient(host string, port int) (net.Conn, error) {
	address := fmt.Sprintf("%s:%d", host, port)
	conn, err := net.Dial("tcp", address)
	if err != nil {
		return nil, fmt.Errorf("failed to connect: %v", err)
	}

	fmt.Printf("Connected to %s\n", address)
	return conn, nil
}

// TCPClientExample demonstrates TCP client
func TCPClientExample() {
	fmt.Println("--- TCP Client ---")

	// Note: This example requires a running TCP server
	conn, err := TCPClient("localhost", 8080)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		fmt.Println("(Note: This requires a running TCP server)")
		return
	}
	defer conn.Close()

	// Send data
	message := "Hello, TCP Server!\n"
	_, err = conn.Write([]byte(message))
	if err != nil {
		fmt.Printf("Error writing: %v\n", err)
		return
	}

	fmt.Printf("Sent: %s", message)

	// Read response
	buffer := make([]byte, 1024)
	n, err := conn.Read(buffer)
	if err != nil {
		fmt.Printf("Error reading: %v\n", err)
		return
	}

	fmt.Printf("Received: %s\n", string(buffer[:n]))
}

// 2. TCP Server

// TCPServer starts a simple TCP server
func TCPServer(port int) error {
	address := fmt.Sprintf(":%d", port)
	listener, err := net.Listen("tcp", address)
	if err != nil {
		return fmt.Errorf("failed to listen: %v", err)
	}
	defer listener.Close()

	fmt.Printf("TCP Server listening on %s\n", address)

	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Printf("Error accepting connection: %v\n", err)
			continue
		}

		fmt.Printf("New connection from %s\n", conn.RemoteAddr())

		// Handle connection in goroutine
		go handleConnection(conn)
	}
}

// handleConnection handles a client connection
func handleConnection(conn net.Conn) {
	defer conn.Close()

	remoteAddr := conn.RemoteAddr().String()
	fmt.Printf("Handling connection from %s\n", remoteAddr)

	// Read data
	buffer := make([]byte, 1024)
	n, err := conn.Read(buffer)
	if err != nil {
		fmt.Printf("Error reading from %s: %v\n", remoteAddr, err)
		return
	}

	fmt.Printf("Received from %s: %s\n", remoteAddr, string(buffer[:n]))

	// Send response
	response := fmt.Sprintf("Echo: %s", string(buffer[:n]))
	_, err = conn.Write([]byte(response))
	if err != nil {
		fmt.Printf("Error writing to %s: %v\n", remoteAddr, err)
		return
	}

	fmt.Printf("Response sent to %s\n", remoteAddr)
}

// TCPServerExample demonstrates TCP server
func TCPServerExample() {
	fmt.Println("\n--- TCP Server ---")

	fmt.Println("Starting TCP server on :8080")
	fmt.Println("(In production, server.ListenAndServe() would block here)")

	// In real usage:
	// err := TCPServer(8080)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	// For demonstration, just show the concept
	conn, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("Server would accept connections here")
}

// 3. TCP Client with Timeout

// TCPClientWithTimeout connects with timeout
func TCPClientWithTimeout(host string, port int, timeout time.Duration) (net.Conn, error) {
	address := fmt.Sprintf("%s:%d", host, port)

	conn, err := net.DialTimeout("tcp", address, timeout)
	if err != nil {
		return nil, fmt.Errorf("connection timeout: %v", err)
	}

	fmt.Printf("Connected to %s (with timeout)\n", address)
	return conn, nil
}

// TimeoutClientExample demonstrates client with timeout
func TimeoutClientExample() {
	fmt.Println("\n--- TCP Client with Timeout ---")

	conn, err := TCPClientWithTimeout("localhost", 8080, 5*time.Second)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		fmt.Println("(Note: This requires a running TCP server)")
		return
	}
	defer conn.Close()

	fmt.Println("Connection established with timeout")
}

// 4. Bidirectional Communication

// ChatClient demonstrates bidirectional chat
func ChatClient(host string, port int) error {
	address := fmt.Sprintf("%s:%d", host, port)
	conn, err := net.Dial("tcp", address)
	if err != nil {
		return err
	}
	defer conn.Close()

	fmt.Printf("Connected to chat server %s\n", address)

	// Start goroutine to read messages
	go func() {
		scanner := bufio.NewScanner(conn)
		for scanner.Scan() {
			fmt.Printf("Server: %s\n", scanner.Text())
		}
	}()

	// Read from stdin and send to server
	scanner := bufio.NewScanner(conn)
	for scanner.Scan() {
		text := scanner.Text()
		if strings.ToLower(text) == "quit" {
			break
		}

		_, err := conn.Write([]byte(text + "\n"))
		if err != nil {
			return err
		}
	}

	return nil
}

// BidirectionalExample demonstrates bidirectional communication
func BidirectionalExample() {
	fmt.Println("\n--- Bidirectional Communication ---")

	fmt.Println("Chat client (requires running chat server)")
	fmt.Println("(In production, would run ChatClient here)")
}

// 5. UDP Client/Server

// UDPServer starts a UDP server
func UDPServer(port int) error {
	address := fmt.Sprintf(":%d", port)
	conn, err := net.ListenPacket("udp", address)
	if err != nil {
		return fmt.Errorf("failed to listen: %v", err)
	}
	defer conn.Close()

	fmt.Printf("UDP Server listening on %s\n", address)

	buffer := make([]byte, 1024)
	for {
		n, addr, err := conn.ReadFrom(buffer)
		if err != nil {
			fmt.Printf("Error reading: %v\n", err)
			continue
		}

		fmt.Printf("Received from %s: %s\n", addr, string(buffer[:n]))

		// Send response
		response := []byte("UDP Acknowledgment")
		_, err = conn.WriteTo(response, addr)
		if err != nil {
			fmt.Printf("Error writing: %v\n", err)
		}
	}
}

// UDPClient sends data to UDP server
func UDPClient(host string, port int, message string) error {
	address := fmt.Sprintf("%s:%d", host, port)
	conn, err := net.Dial("udp", address)
	if err != nil {
		return fmt.Errorf("failed to connect: %v", err)
	}
	defer conn.Close()

	fmt.Printf("Sending to %s: %s\n", address, message)

	_, err = conn.Write([]byte(message))
	if err != nil {
		return fmt.Errorf("error sending: %v", err)
	}

	// Read response
	buffer := make([]byte, 1024)
	n, err := conn.Read(buffer)
	if err != nil {
		return fmt.Errorf("error reading: %v", err)
	}

	fmt.Printf("Received: %s\n", string(buffer[:n]))
	return nil
}

// UDPExample demonstrates UDP communication
func UDPExample() {
	fmt.Println("\n--- UDP Client/Server ---")

	fmt.Println("UDP Server starting on :8081")
	fmt.Println("(In production, UDPServer would run here)")

	// Client example
	fmt.Println("\nUDP Client (requires running UDP server)")
	err := UDPClient("localhost", 8081, "Hello UDP!")
	if err != nil {
		fmt.Printf("Error: %v\n", err)
	}
}

// 6. Protocol Buffers over TCP

// SendBinaryMessage sends binary data with length prefix
func SendBinaryMessage(conn net.Conn, data []byte) error {
	// Send message length first (4 bytes)
	length := uint32(len(data))
	err := binary.Write(conn, binary.BigEndian, length)
	if err != nil {
		return fmt.Errorf("error writing length: %v", err)
	}

	// Send data
	_, err = conn.Write(data)
	if err != nil {
		return fmt.Errorf("error writing data: %v", err)
	}

	return nil
}

// ReceiveBinaryMessage receives binary data with length prefix
func ReceiveBinaryMessage(conn net.Conn) ([]byte, error) {
	// Read message length
	var length uint32
	err := binary.Read(conn, binary.BigEndian, &length)
	if err != nil {
		return nil, fmt.Errorf("error reading length: %v", err)
	}

	// Read data
	data := make([]byte, length)
	_, err = io.ReadFull(conn, data)
	if err != nil {
		return nil, fmt.Errorf("error reading data: %v", err)
	}

	return data, nil
}

// BinaryProtocolExample demonstrates binary protocol
func BinaryProtocolExample() {
	fmt.Println("\n--- Binary Protocol over TCP ---")

	fmt.Println("Binary protocol demonstration")
	fmt.Println("(Would use SendBinaryMessage and ReceiveBinaryMessage)")
}

// 7. Connection Pool

// ConnPool represents a connection pool
type ConnPool struct {
	conns chan net.Conn
	factory func() (net.Conn, error)
}

// NewConnPool creates a new connection pool
func NewConnPool(size int, factory func() (net.Conn, error)) (*ConnPool, error) {
	pool := &ConnPool{
		conns:   make(chan net.Conn, size),
		factory: factory,
	}

	// Initialize connections
	for i := 0; i < size; i++ {
		conn, err := factory()
		if err != nil {
			return nil, err
		}
		pool.conns <- conn
	}

	return pool, nil
}

// Get gets a connection from the pool
func (p *ConnPool) Get() (net.Conn, error) {
	select {
	case conn := <-p.conns:
		return conn, nil
	default:
		// Pool exhausted, create new connection
		return p.factory()
	}
}

// Put returns a connection to the pool
func (p *ConnPool) Put(conn net.Conn) {
	select {
	case p.conns <- conn:
		// Connection returned to pool
	default:
		// Pool full, close connection
		conn.Close()
	}
}

// Close closes all connections in the pool
func (p *ConnPool) Close() {
	close(p.conns)
	for conn := range p.conns {
		conn.Close()
	}
}

// ConnectionPoolExample demonstrates connection pooling
func ConnectionPoolExample() {
	fmt.Println("\n--- Connection Pool ---")

	// Create pool
	pool, err := NewConnPool(3, func() (net.Conn, error) {
		return net.Dial("tcp", "localhost:8080")
	})

	if err != nil {
		fmt.Printf("Error creating pool: %v\n", err)
		fmt.Println("(Note: This requires a running TCP server)")
		return
	}

	defer pool.Close()

	// Get connection
	conn, err := pool.Get()
	if err != nil {
		fmt.Printf("Error getting connection: %v\n", err)
		return
	}

	fmt.Printf("Got connection from pool: %v\n", conn.RemoteAddr())

	// Return connection
	pool.Put(conn)

	fmt.Println("Connection returned to pool")
}

// 8. Socket Options

// SetSocketOptions configures socket options
func SetSocketOptions(conn net.Conn) error {
	tcpConn, ok := conn.(*net.TCPConn)
	if !ok {
		return fmt.Errorf("not a TCP connection")
	}

	// Set keep-alive
	err := tcpConn.SetKeepAlive(true)
	if err != nil {
		return fmt.Errorf("error setting keep-alive: %v", err)
	}

	// Set keep-alive period
	err = tcpConn.SetKeepAlivePeriod(30 * time.Second)
	if err != nil {
		return fmt.Errorf("error setting keep-alive period: %v", err)
	}

	// Set no delay
	err = tcpConn.SetNoDelay(true)
	if err != nil {
		return fmt.Errorf("error setting no delay: %v", err)
	}

	return nil
}

// SocketOptionsExample demonstrates socket options
func SocketOptionsExample() {
	fmt.Println("\n--- Socket Options ---")

	fmt.Println("Socket options configured (keep-alive, no delay)")
	fmt.Println("(Would use SetSocketOptions on TCP connections)")
}

// Main function
func main() {
	fmt.Println("=== Web Go TCP Sockets Examples ===\n")

	TCPClientExample()
	TCPServerExample()
	TimeoutClientExample()
	BidirectionalExample()
	UDPExample()
	BinaryProtocolExample()
	ConnectionPoolExample()
	SocketOptionsExample()

	fmt.Println("\n=== All TCP Sockets Examples Completed ===")
}

Werkzeuge

Tools, die oft mit diesem Beispiel genutzt werden

Verwandt

Verwandte Beispielsammlungen

Verwandt

Verwandte Themen

Thema

Netzwerk-Triage, Paketinspektion und Endpoint-Debugging

Untersuche Captures, replaye Webhooks, validiere Adressen und CIDR, pruefe DNS, WHOIS, hosts, TLS und User Agents, und dokumentiere die Diagnose.

Thema

JSON Schema aus Beispielen und Tabellen ableiten

Leiten Sie aus repräsentativen JSON-Beispielen oder XLSX-Zeilen einen prüfbaren JSON-Schema-Entwurf ab und kontrollieren Sie Typen, Pflichtfelder, Nullwerte und Ausreißer, bevor er als Vertrag dient.

Thema

Autorisierte Webhook-Erfassung und Vertrauensprüfung des Endpoints

Kontrollierte Webhook-Requests erfassen und wiederholen, Zustellnachweise prüfen und das HTTPS-Zertifikat des Empfängers untersuchen, ohne ein gültiges Zertifikat mit fachlichem Vertrauen gleichzusetzen.

Thema

Observability-Debugging mit Logs, Traces, Webhooks und JSON-Payloads

Parsen Sie Logs, decodieren Sie Traces, pruefen Sie Webhook/API-Belege, erkunden Sie JSON-Payloads und extrahieren Sie Muster vor der Incident-Notiz.

Start
Werkzeuge3212
Beispiele593
Visualisierungen471
Dateibetrachter103
Themen239
Schlagwörter333
Bilder, Audio & Video657

Werkzeuge für Bild-, Audio- und Videobearbeitung, Konvertierung und Optimierung

Mathe, Datum & Finanzen647

Rechner, Zahlenwerkzeuge, Datumslogik, Statistik und Finanztools

Design & Farbe298

Werkzeuge für Farben, Layouts, Grafiken, visuelle Gestaltung und Designhilfen

Text & Schreiben209

Werkzeuge für Schreiben, Bereinigung, Formatierung, Extraktion und Textanalyse

Entwicklung & Web193

Entwicklerwerkzeuge, Netzwerk-Utilities, Web-Debugging und Automatisierungshelfer

Konvertierung & Kodierung175

Werkzeuge für Format-, Datei-, Archiv-, Einheiten- und Kodierungskonvertierung

Lead-Quiz veröffentlichen und Kontakte sicher übergeben
Gedenktexte: Familienprüfung und Übergabe zum Druck
Private Gewohnheiten: Sicherung, Wiederherstellung und Freigabeprüfung
Vom Artikel zu X- und LinkedIn-Entwürfen: Faktenprüfung und Übergabe
Interaktive Markdown-Lektion prüfen und offline übergeben

© 2026 Elysia Tools. Alle Rechte vorbehalten.

DokumentationTarifeÜber unsNutzungsbedingungenDatenschutzerklärungCookiesKontakt

Web & Internet

Websuche (SearXNG-JSON)

Durchsucht das Web über die SearXNG-Instanz s.stdlang.com und liefert JSON für Automatisierung und Folgetools.

Development

API-Request-Code-Snippet-Generator

Erzeugt cURL- und gaengige Sprach-Snippets aus URL, Methode, Headern, Query-Parametern und Body

Development

API Mock Server

Erzeugt einen temporaeren Redis-basierten Mock-Server mit dynamischen Antworten

Networking

BGP-AS_PATH-Policy- und Schleifen-Sandbox

Simuliert AS_PATH-Schleifenerkennung, Policy-Filter, Attributänderungen und eine deterministische Best-Path-Auswahl.

Development

JSON zu Go Struct

Konvertiert JSON-Daten in Go-Struct-Definitionen mit json-Tags, exportierten PascalCase-Feldern und verschachtelter Typ-Inferenz

Security

JWT-Decoder

JWT-Tokens dekodieren

Security

JWT-Generator

JWT-Tokens mit benutzerdefinierten Claims und Algorithmen generieren

Format Conversion

SSH Konfigurations Parser

Analysiert und konvertiert SSH Konfigurationsdateien in JSON Format

C++

Windows Netzwerkprogrammierung - C++ Beispiele

Umfassende C++ Netzwerkprogrammierbeispiele für Windows-Plattform einschließlich HTTP-Anfragen, TCP-Sockets und HTTP-Server-Implementierung

C#

Windows Netzwerkprogrammierung - C# Beispiele

Umfassende C# Netzwerkprogrammierbeispiele für Windows-Plattform einschließlich HTTP-Anfragen, TCP-Sockets, UDP-Kommunikation und Webserver-Implementierung

Go

Web Go Datenserialisierung Beispiele

Web Go Datenserialisierungsbeispiele einschließlich JSON-Kodierung/Dekodierung und XML-Parsing

Dokumente

PDF-Beispiele

Generierte PDF-Beispiele von Tools zwischen 2026-02-01 und 2026-02-10

Objective-C

macOS Objective-C Netzwerk-Beispiele

macOS Objective-C Netzwerk-Beispiele einschließlich URLSession, HTTP-Anfragen, WebSocket und Netzwerkerreichbarkeit

Observability

Distributed Tracing Beispiele

Umfassende Beispiele für verteiltes Tracing mit Jaeger, OpenTelemetry und modernen Observability Tools