Java vs. Go: A Weather Service Implementation Comparison

After discussions with friends, I became interested in comparing Java and Go, especially since I have experience with Java but not much with Go. This repository serves as a practical comparison, featuring two identical weather service implementations: one in Java and one in Go. Both services interact with The National Weather Service (NWS) API to fetch forecast data.

Running the Java Project in VS Code

To run the Java weather service:

1. Navigate to the project directory:

   cd java-weather-service

2. Build the project using Maven:

   ./mvnw clean install

3. Run the Spring Boot application:

   ./mvnw spring-boot:run

   The application will start on http://localhost:8080.

Running the Go Project in VS Code

To run the Go weather service:

1. Navigate to the project directory:

   cd go-weather-service

2. Build the executable:

   go build -o weather-service ./cmd/weather-service

3. Run the compiled application:

   ./weather-service

   The application will start on http://localhost:8080.

Key API Call Implementations

Java API Call

In the Java project, the WeatherService.java file handles the API calls to the NWS. It uses RestTemplate to make HTTP requests.

// java-weather-service/src/main/java/com/example/weatherservice/service/WeatherService.java
// ...
public Optional<WeatherResponse> getWeatherForCity(String city) {
    // ...
    try {
        // 2. Call NWS /points/{latitude},{longitude} endpoint
        String pointsUrl = UriComponentsBuilder.fromHttpUrl("https://api.weather.gov/points/" + coordinates)
                .build().toUriString();
        System.out.println("Calling NWS Points API: " + pointsUrl);

        NwsPointResponse pointResponse = restTemplate.getForObject(pointsUrl, NwsPointResponse.class);

        // ...

        String forecastUrl = pointResponse.getProperties().getForecast();
        System.out.println("Calling NWS Forecast API: " + forecastUrl);

        // 3. Call the forecast URL obtained from the /points endpoint
        NwsForecastResponse forecastResponse = restTemplate.getForObject(forecastUrl, NwsForecastResponse.class);

        // ...
    } catch (HttpClientErrorException e) {
        // ...
    } catch (RestClientException | InvalidUrlException e) {
        // ...
    }
}

Go API Call

In the Go project, the main.go file sets up the HTTP server, and the actual API call logic is likely within a handler function. Based on the main.go file, the handlers.WeatherHandler is responsible for handling the /weather endpoint. I will assume the API call logic is within a file like go-weather-service/pkg/handlers/weather.go or similar, as it’s a common Go project structure.

// go-weather-service/cmd/weather-service/main.go
package main

import (
	"log"
	"net/http"

	"go-weather-service/pkg/handlers" // Import our custom handlers package
)

func main() {
	http.HandleFunc("/weather", handlers.WeatherHandler)
	log.Println("Registered /weather handler")

	port := ":8080"
	log.Printf("Server starting on port %s", port)
	err := http.ListenAndServe(port, nil)
	if err != nil {
		log.Fatalf("Server failed to start: %v", err)
	}
}

(Note: The exact Go API call implementation details are not directly visible from the provided main.go and go.mod files. A more detailed analysis of the go-weather-service directory would be needed to pinpoint the exact file and code snippet for the API call.)

Initial Impressions

Java, with its extensive ecosystem and mature frameworks like Spring Boot, offers a robust and feature-rich environment for building applications. However, setting up and running a Go project in VS Code felt remarkably straightforward and lightweight. Go’s built-in tooling and simple dependency management (via go.mod) contribute to a very smooth developer experience.

Furthermore, Go’s approach to concurrency, particularly with goroutines and channels, is a significant highlight. It provides powerful and intuitive primitives for handling concurrent operations, which can lead to highly efficient and scalable services. This feature alone makes Go a compelling choice for modern backend development where performance and concurrency are paramount.

• Sample Code: https://github.com/jansenzjh/WeatherJavaVsGo