overengineering bench

Here is a complete, self-contained Go program that starts an HTTP server with a single endpoint (/hello) and returns a JSON document when it is called.

main.go
```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

// response is the JSON payload returned to the client.
type response struct {
	Message string `json:"message"`
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
	// Only allow GET requests (optional guard).
	if r.Method != http.MethodGet {
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}

	payload := response{Message: "Hello, world!"}

	// Tell the client we're sending JSON.
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)

	// Marshal the struct to JSON and write it out.
	if err := json.NewEncoder(w).Encode(payload); err != nil {
		// If something goes wrong while encoding, return a 500.
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

func main() {
	// Register the handler.
	http.HandleFunc("/hello", helloHandler)

	// Start the server on port 8080.
	log.Println("Listening on http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatalf("server failed: %v", err)
	}
}
```

How to run:

1. Save the code above as `main.go`.
2. In the same directory, run:
   ```
   go run main.go
   ```
3. Open your browser or use `curl`:
   ```
   curl http://localhost:8080/hello
   ```
   You should receive:
   ```
   {"message":"Hello, world!"}
   ```

That’s all you need for a tiny JSON-returning HTTP server in Go.

Of course! Here is a simple and complete Go HTTP server that serves JSON on a single endpoint.

This example uses only the Go standard library, so you don't need any external dependencies.

### The Go Code (`main.go`)

Save this code in a file named `main.go`.

```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

// Message defines the structure of our JSON response.
// The `json:"..."` struct tags are used to specify the JSON key names.
type Message struct {
	Text   string `json:"text"`
	Status string `json:"status"`
}

// dataHandler is the function that handles requests to our endpoint.
func dataHandler(w http.ResponseWriter, r *http.Request) {
	// 1. Create the data structure we want to send.
	responseMessage := Message{
		Text:   "Hello from the Go server!",
		Status: "success",
	}

	// 2. Set the "Content-Type" header to "application/json".
	// This tells the client to expect a JSON response.
	w.Header().Set("Content-Type", "application/json")

	// 3. Set the HTTP status code. http.StatusOK is 200.
	w.WriteHeader(http.StatusOK)

	// 4. Encode our Go struct into JSON and write it to the response.
	// json.NewEncoder(w).Encode(data) is a convenient way to stream
	// JSON to a writer without buffering it in memory first.
	// We also check for errors during the encoding process.
	err := json.NewEncoder(w).Encode(responseMessage)
	if err != nil {
		// If there's an error encoding the JSON, we log it
		// and send a generic server error to the client.
		log.Printf("Error encoding JSON: %v", err)
		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
	}
}

func main() {
	// Define the port the server will listen on.
	port := ":8080"

	// Register our handler function for the "/api/data" endpoint.
	// When a request comes in for this path, dataHandler will be called.
	http.HandleFunc("/api/data", dataHandler)

	// Announce that the server is starting.
	log.Printf("Server starting on http://localhost%s", port)

	// Start the HTTP server.
	// http.ListenAndServe blocks until the server is stopped, and it
	// will log and exit if it encounters a fatal error (like the port being busy).
	if err := http.ListenAndServe(port, nil); err != nil {
		log.Fatalf("Could not start server: %s\n", err)
	}
}
```

---

### Explanation

1.  **`package main`**: Declares that this is an executable program.
2.  **`import`**: We import three standard library packages:
    *   `"encoding/json"`: For converting Go structs to and from JSON.
    *   `"log"`: For printing log messages (e.g., server start/error messages).
    *   `"net/http"`: The core package for building HTTP servers and clients.
3.  **`type Message struct`**: We define a Go `struct` that represents the shape of our JSON data. The `json:"..."` tags are optional but highly recommended. They control how the struct fields are named when converted to JSON, allowing you to follow Go's `PascalCase` convention for exported fields while using `camelCase` or `snake_case` in your JSON output.
4.  **`dataHandler(w http.ResponseWriter, r *http.Request)`**: This is our *handler function*.
    *   `w http.ResponseWriter`: This is the writer to which you send your response. You use it to set headers and write the response body.
    *   `r *http.Request`: This contains all the information about the incoming request, such as the URL, headers, and request body (if any). We don't use it in this simple example, but it's required by the function signature.
5.  **`w.Header().Set("Content-Type", "application/json")`**: This is crucial. It sets the `Content-Type` HTTP header, informing the client (like a web browser or `curl`) that the body of the response is JSON-formatted data.
6.  **`w.WriteHeader(http.StatusOK)`**: This explicitly sets the HTTP status code to `200 OK`. While this is the default, it's good practice to be explicit.
7.  **`json.NewEncoder(w).Encode(responseMessage)`**: This is the idiomatic way to send a JSON response. It creates a new JSON encoder that writes directly to the `http.ResponseWriter` (`w`) and then encodes our `responseMessage` struct into JSON. It's more efficient than marshaling to a byte slice and then writing the slice.
8.  **`main()`**: The entry point of our program.
    *   `http.HandleFunc("/api/data", dataHandler)`: This line registers our `dataHandler` to handle all incoming requests for the path `/api/data`.
    *   `http.ListenAndServe(":8080", nil)`: This starts the HTTP server. It listens for TCP connections on port `8080`. The `nil` argument tells it to use the `DefaultServeMux`, which is the default request router that `http.HandleFunc` registers handlers with. This function will block forever unless it returns an error.

---

### How to Run

1.  Open your terminal or command prompt.
2.  Navigate to the directory where you saved `main.go`.
3.  Run the server using the following command:

    ```bash
    go run main.go
    ```

4.  You will see the output in your terminal:

    ```
    2023/10/27 10:30:00 Server starting on http://localhost:8080
    ```

The server is now running and listening for requests on port `8080`.

### How to Test

You can test the endpoint using `curl` in your terminal or by visiting the URL in your web browser.

#### Using `curl` (Recommended)

Open a **new** terminal window and run:

```bash
curl http://localhost:8080/api/data
```

**Expected Output:**

The server will respond with the JSON content, which `curl` will print to your terminal. It might be formatted on a single line.

```json
{"text":"Hello from the Go server!","status":"success"}
```

You can use a tool like `jq` to pretty-print the output:

```bash
curl -s http://localhost:8080/api/data | jq
```

**Pretty-Printed Output:**
```json
{
  "text": "Hello from the Go server!",
  "status": "success"
}
```

#### Using a Web Browser

Open your web browser and navigate to `http://localhost:8080/api/data`. The browser will display the raw JSON text. If you have a browser extension for viewing JSON, it will be nicely formatted.

Certainly! Here is a simple Go server with one HTTP endpoint (`/`) that returns a JSON response:

```go
package main

import (
    "encoding/json"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        response := map[string]string{"message": "Hello, World!"}
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(response)
    })

    http.ListenAndServe(":8080", nil)
}
```

## How it works:

- The server listens on port `8080`.
- The `/` endpoint responds with a JSON object: `{"message": "Hello, World!"}`.

## How to run:

1. Save the code to a file, e.g., `main.go`.
2. Run:  
   ```bash
   go run main.go
   ```
3. Visit [http://localhost:8080](http://localhost:8080) in your browser or `curl http://localhost:8080` in your terminal.

---

Let me know if you want the endpoint or JSON data customized!

```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type response struct {
	Message string `json:"message"`
}

func main() {
	// Register the single endpoint.
	http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(response{Message: "pong"})
	})

	// Start the server on port 8080.
	log.Println("Server listening on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}
```

Here’s a minimal Go HTTP server with one endpoint that returns JSON.

main.go:
```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
	"time"
)

type response struct {
	Message string `json:"message"`
	Time    string `json:"time"`
}

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			w.Header().Set("Allow", http.MethodGet)
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		resp := response{
			Message: "Hello, world!",
			Time:    time.Now().UTC().Format(time.RFC3339),
		}
		_ = json.NewEncoder(w).Encode(resp)
	})

	addr := ":8080"
	log.Printf("listening on %s", addr)
	log.Fatal(http.ListenAndServe(addr, mux))
}
```

Run:
- go run main.go
- curl http://localhost:8080/hello

Example response:
{"message":"Hello, world!","time":"2025-11-06T12:34:56Z"}

Here’s a minimal Go HTTP server with one endpoint that returns JSON.

main.go:
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type HelloResponse struct {
	Message string `json:"message"`
}

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			w.Header().Set("Allow", http.MethodGet)
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
		w.WriteHeader(http.StatusOK)
		_ = json.NewEncoder(w).Encode(HelloResponse{Message: "hello"})
	})

	addr := ":8080"
	log.Printf("listening on %s", addr)
	if err := http.ListenAndServe(addr, mux); err != nil {
		log.Fatal(err)
	}
}

Run:
- go run . (from the directory containing main.go)

Test:
- curl http://localhost:8080/hello
- Response: {"message":"hello"}

Below is a complete, minimal example of a Go (Golang) HTTP server that listens on port 8080 and exposes a single endpoint (`/hello`). When you make a GET request to this endpoint (e.g., via `curl http://localhost:8080/hello`), it returns a simple JSON response like `{"message": "Hello, World!"}`.

### Prerequisites
- Make sure you have Go installed (download from [golang.org](https://golang.org)).
- Create a new directory for this project, navigate to it, and run `go mod init example` to initialize a module.

### Code (main.go)
```go
package main

import (
	"encoding/json" // For JSON encoding
	"fmt"           // For error printing (optional)
	"net/http"      // For HTTP server
)

// Handler function for the /hello endpoint
func helloHandler(w http.ResponseWriter, r *http.Request) {
	// Define the data to return as JSON
	data := map[string]string{
		"message": "Hello, World!",
	}

	// Marshal the data to JSON
	jsonData, err := json.Marshal(data)
	if err != nil {
		http.Error(w, "Failed to marshal JSON", http.StatusInternalServerError)
		return
	}

	// Set the Content-Type header to application/json
	w.Header().Set("Content-Type", "application/json")
	// Write the JSON response
	w.Write(jsonData)
}

func main() {
	// Register the handler for the /hello endpoint
	http.HandleFunc("/hello", helloHandler)

	// Start the server on port 8080
	fmt.Println("Server listening on http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		fmt.Printf("Server failed: %v\n", err)
	}
}
```

### How to Run
1. Save the code above in a file named `main.go`.
2. In your terminal, run `go run main.go`.
3. The server will start and print "Server listening on http://localhost:8080".
4. Test it with a tool like curl: `curl http://localhost:8080/hello`.
   - Expected output: `{"message":"Hello, World!"}`

### Notes
- This is a basic example using Go's standard library (`net/http`). For production use, consider adding error handling, logging, or using a framework like Gin or Echo.
- The server runs on localhost:8080 by default. You can change the port in `http.ListenAndServe(":8080", nil)`.
- If you access a different path (e.g., `/`), it will return a 404 error since only `/hello` is handled.
- To stop the server, press Ctrl+C in the terminal.

If you need modifications (e.g., more endpoints, custom JSON, or authentication), let me know!

# Golang HTTP Server with JSON Endpoint

Here's a simple HTTP server in Go that exposes one endpoint returning JSON data:

```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Response struct {
	Message string `json:"message"`
	Status  int    `json:"status"`
	Data    Data   `json:"data"`
}

type Data struct {
	Id      int    `json:"id"`
	Content string `json:"content"`
}

func handler(w http.ResponseWriter, r *http.Request) {
	// Set response content type
	w.Header().Set("Content-Type", "application/json")

	// Create response data
	response := Response{
		Message: "Success",
		Status:  http.StatusOK,
		Data: Data{
			Id:      1,
			Content: "This is a sample JSON response from the server",
		},
	}

	// Encode the response as JSON
	err := json.NewEncoder(w).Encode(response)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func main() {
	// Register the handler function for the endpoint
	http.HandleFunc("/api/data", handler)

	// Start the server on port 8080
	log.Println("Server starting on :8080...")
	log.Fatal(http.ListenAndServe(":8080", nil))
}
```

## How to Use:

1. Save this code to a file (e.g., `main.go`)
2. Run the server with: `go run main.go`
3. Access the endpoint at: `http://localhost:8080/api/data`

## Response Example:
When you access the endpoint, you'll receive JSON like:
```json
{
  "message": "Success",
  "status": 200,
  "data": {
    "id": 1,
    "content": "This is a sample JSON response from the server"
  }
}
```

## Features:
- Proper Content-Type header set to `application/json`
- Error handling for JSON encoding
- Structured response with multiple fields
- Simple, clean code following Go conventions
- Runs on port 8080 by default

You can customize the port, response structure, and endpoint path as needed.

Here’s a minimal Go HTTP server with a single endpoint (`/hello`) that responds with JSON:

```go
package main

import (
    "encoding/json"
    "log"
    "net/http"
)

// response is the JSON structure we’ll send back.
type response struct {
    Message string `json:"message"`
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    // Only allow GET
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    // Prepare our response
    resp := response{
        Message: "Hello, world!",
    }

    // Set the Content-Type header so client knows it's JSON
    w.Header().Set("Content-Type", "application/json")
    // Encode resp as JSON to the ResponseWriter
    if err := json.NewEncoder(w).Encode(resp); err != nil {
        // If encoding fails, send an internal server error
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}

func main() {
    // Register the handler for the /hello endpoint
    http.HandleFunc("/hello", helloHandler)

    // Start the server on port 8080
    log.Println("Starting server on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}
```

How to run:

1. Save the above code to a file, e.g. `main.go`.
2. In the same directory, run:
   
   ```
   go mod init example.com/hello
   go run main.go
   ```

3. In another terminal, test it with:

   ```
   curl http://localhost:8080/hello
   ```

   You should see:

   ```
   {"message":"Hello, world!"}
   ```

### Golang HTTP Server with JSON Endpoint
#### Overview

Below is an example of a simple Golang HTTP server that exposes one endpoint, `/hello`, which returns a JSON response.

#### Code
```go
package main

import (
    "encoding/json"
    "log"
    "net/http"
)

// HelloResponse represents the JSON response structure
type HelloResponse struct {
    Message string `json:"message"`
}

// helloHandler handles the /hello endpoint
func helloHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Invalid request method", http.StatusBadRequest)
        return
    }

    response := HelloResponse{
        Message: "Hello, World!",
    }

    w.Header().Set("Content-Type", "application/json")
    err := json.NewEncoder(w).Encode(response)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}

func main() {
    http.HandleFunc("/hello", helloHandler)

    log.Println("Server is listening on port 8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}
```

#### Explanation

1. We define a `HelloResponse` struct to represent the JSON response.
2. The `helloHandler` function handles the `/hello` endpoint. It checks if the request method is `GET`, and if not, returns a `400 Bad Request` error.
3. We create a `HelloResponse` instance and set its `Message` field to "Hello, World!".
4. We set the `Content-Type` header to `application/json` and encode the response using `json.NewEncoder`.
5. In the `main` function, we register the `helloHandler` function with the `/hello` endpoint using `http.HandleFunc`.
6. We start the server using `http.ListenAndServe` on port `8080`.

#### Running the Server

To run the server, save the above code in a file named `main.go` and execute the following commands in your terminal:

```bash
go build main.go
./main
```

Alternatively, you can use `go run main.go` to run the server directly.

#### Testing the Endpoint

To test the `/hello` endpoint, you can use a tool like `curl` or a web browser:

```bash
curl http://localhost:8080/hello
```

This should return the following JSON response:

```json
{"message":"Hello, World!"}
```

Here's a Go HTTP server with one endpoint that returns a JSON response:

```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Greeting struct {
	Message string `json:"message"`
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
	// Set content type to JSON
	w.Header().Set("Content-Type", "application/json")

	// Create response struct
	greeting := Greeting{
		Message: "Hello, World!",
	}

	// Encode and send JSON response
	if err := json.NewEncoder(w).Encode(greeting); err != nil {
		http.Error(w, "Error encoding response", http.StatusInternalServerError)
	}
}

func main() {
	// Register endpoint handler
	http.HandleFunc("/hello", helloHandler)

	// Start server
	log.Println("Server starting on port 8080...")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatalf("Server failed to start: %v", err)
	}
}
```

Key features:
- Single endpoint at `/hello`
- Returns JSON response: `{"message":"Hello, World!"}`
- Proper content type header (`application/json`)
- Error handling for JSON encoding
- Server listens on port 8080

To use:
1. Save as `main.go`
2. Run: `go run main.go`
3. Access: `http://localhost:8080/hello`

Example response:
```json
{
  "message": "Hello, World!"
}
```

This implementation:
1. Uses proper HTTP headers for JSON content
2. Handles errors during JSON encoding
3. Logs server start and error information
4. Follows standard Go conventions for web servers
5. Contains complete error checking

To test with curl:
```bash
curl -i http://localhost:8080/hello
```

Expected output:
```
HTTP/1.1 200 OK
Content-Type: application/json
Date: ... 
Content-Length: 27

{"message":"Hello, World!"}
```

Here's a simple Go HTTP server with one endpoint that returns JSON:

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

// Response structure for JSON output
type Response struct {
	Message string `json:"message"`
	Status  string `json:"status"`
	Data    Data   `json:"data"`
}

type Data struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

// Handler function for the endpoint
func helloHandler(w http.ResponseWriter, r *http.Request) {
	// Set the content type to JSON
	w.Header().Set("Content-Type", "application/json")
	
	// Create response data
	response := Response{
		Message: "Hello from Go HTTP Server!",
		Status:  "success",
		Data: Data{
			ID:   1,
			Name: "Sample Data",
		},
	}
	
	// Convert struct to JSON
	jsonData, err := json.Marshal(response)
	if err != nil {
		http.Error(w, "Error creating JSON response", http.StatusInternalServerError)
		return
	}
	
	// Write JSON response
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

func main() {
	// Register the handler for the endpoint
	http.HandleFunc("/api/hello", helloHandler)
	
	// Start the server
	port := ":8080"
	fmt.Printf("Server starting on port %s\n", port)
	fmt.Println("Try: http://localhost:8080/api/hello")
	
	// Start listening
	log.Fatal(http.ListenAndServe(port, nil))
}
```

## How to run:

1. Save the code to a file (e.g., `server.go`)
2. Run the server:
```bash
go run server.go
```

3. Test the endpoint:
```bash
curl http://localhost:8080/api/hello
```

## Expected JSON response:
```json
{
  "message": "Hello from Go HTTP Server!",
  "status": "success",
  "data": {
    "id": 1,
    "name": "Sample Data"
  }
}
```

## Alternative simpler version:

If you want something even more minimal:

```go
package main

import (
	"encoding/json"
	"log"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	
	response := map[string]interface{}{
		"message": "Hello World!",
		"success": true,
	}
	
	json.NewEncoder(w).Encode(response)
}

func main() {
	http.HandleFunc("/", handler)
	log.Println("Server running on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}
```

Both versions will create a working HTTP server that returns JSON responses. The first version is more structured and includes proper error handling, while the second is more concise.

# Golang HTTP Server with JSON Endpoint

Here's a simple Golang HTTP server with a single endpoint that returns JSON data:

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"
)

// Response is the structure of our JSON response
type Response struct {
	Message   string    `json:"message"`
	Status    string    `json:"status"`
	Timestamp time.Time `json:"timestamp"`
}

// handleRequest handles the API endpoint request
func handleRequest(w http.ResponseWriter, r *http.Request) {
	// Create response data
	response := Response{
		Message:   "Hello, World!",
		Status:    "success",
		Timestamp: time.Now(),
	}

	// Set content type header
	w.Header().Set("Content-Type", "application/json")
	
	// Encode response to JSON and send it
	err := json.NewEncoder(w).Encode(response)
	if err != nil {
		// If encoding fails, return an error
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func main() {
	// Define the endpoint
	http.HandleFunc("/api/data", handleRequest)

	// Set up the server
	port := 8080
	fmt.Printf("Server starting on port %d...\n", port)
	
	// Start the server
	err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil)
	if err != nil {
		log.Fatalf("Failed to start server: %v", err)
	}
}
```

## How to run

1. Save the code to a file named `server.go`
2. Run the server with: `go run server.go`
3. The server will start on port 8080
4. Access the endpoint at: http://localhost:8080/api/data

## Testing the endpoint

You can test the endpoint using curl:

```bash
curl http://localhost:8080/api/data
```

This should return a JSON response like:

```json
{
  "message": "Hello, World!",
  "status": "success",
  "timestamp": "2023-06-14T12:34:56.789012345Z"
}
```

## Notes

- The server runs on port 8080 by default
- The single endpoint is at `/api/data`
- The response includes a message, status, and the current timestamp
- The `Content-Type` header is set to `application/json`
- Basic error handling is included

You can extend this example by adding more fields to the Response struct or creating additional endpoints as needed.

Here's a minimal Go HTTP server with one endpoint that returns JSON.

Code (save as main.go):

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Response struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

func dataHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	resp := Response{
		Status:  "ok",
		Message: "Hello from Go HTTP server!",
	}

	if err := json.NewEncoder(w).Encode(resp); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

func main() {
	http.HandleFunc("/data", dataHandler)

	port := "8080"
	log.Printf("Server listening on :%s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

How to run and test:
- go run main.go
- curl http://localhost:8080/data
- You should see: { "status": "ok", "message": "Hello from Go HTTP server!" }