GoLang Tutorial - Modules 2 (Adding Dependencies)

In the previous section (Modules 1 (Creating a new module) ), we created a greetings module. In this section, we'll write code to make calls to the Hello function in the module. We'll write code we can execute as an application, and which calls code in the greetings module.

Create a hello directory for our Go module source code. The hello directory is where we'll write our caller:

$ mkdir hello
$ cd hello    
$ go mod init example/hello
go: creating new go.mod: module example/hello
go: to add module requirements and sums:
        go mod tidy

package main

import (
    "fmt"

    "example/greetings"
)

func main() {
    // Get a greeting message and print it.
    message := greetings.Hello("Bogotobogo")
    fmt.Println(message)
}

The code does the following:

1. Declare a main package:
   In Go, code executed as an application must be in a main package.
2. Import two packages:
   example/greetings and the fmt package. This gives our code access to functions in those packages. Importing example/greetings (the package contained in the module we created earlier) gives us access to the Hello function. We also import fmt, with functions for handling input and output text (such as printing text to the console).
3. Get a greeting by calling the greetings package's Hello function.

Because we haven't published the module yet, we need to adapt the example/hello module so that it can find the example/greetings code on our local file system. To do that, use the go mod edit command to edit the example/hello module to redirect Go tools from its module path (where the module isn't) to the local directory (where it is).

$ go mod edit -replace example/greetings=../greetings    

The command specifies that example/greetings should be replaced with ../greetings for the purpose of locating the dependency. After we run the command, the go.mod file in the hello directory should include a replace directive:

module example/hello

go 1.21.4

replace example/greetings => ../greetings    

Then, from the command prompt in the hello directory, run the go mod tidy command to synchronize the example/hello module's dependencies, adding those required by the code, but not yet tracked in the module:

$ go mod tidy
go: found example/greetings in example/greetings v0.0.0-00010101000000-000000000000    

Now, the example.com/hello module's go.mod file should look like this:

module example/hello

go 1.21.4

replace example/greetings => ../greetings

require example/greetings v0.0.0-00010101000000-000000000000    

Let's run the code:

$ go run .
Hi, Bogotobogo. Welcome!    

Here is our file structures so far:

1. modules:
   

   Modules are how Go manages dependencies.

   Refs: Go Modules Reference

   
   

   A module is a collection of packages and it is identified by a module path, which is declared in a go.mod file, together with information about the module's dependencies.

   A module path is the canonical name for a module, declared with the module directive in the module's go.mod file. A module's path is the prefix for package paths within the module.



2. go mod init:
   
   usage:

   go mod init [module-path]    
   

   
   example:

   go mod init example.com   
   

   
   The go mod init command initializes and writes a new go.mod file in the current directory, in effect creating a new module rooted at the current directory. The go.mod file must not already exist.
   init accepts one optional argument, the module path for the new module.


3. go mod tidy:
   
   usage:

   go mod tidy [-e] [-v] [-go=version] [-compat=version]    
   

   
   

   go mod tidy ensures that the go.mod file matches the source code in the module. It adds any missing module requirements necessary to build the current module's packages and dependencies, and it removes requirements on modules that don't provide any relevant packages. It also adds any missing entries to and removes unnecessary entries.

We can change the module path to github.com from example though it's a good practice to use a valid domain or path that uniquely identifies our module.

The final files look like this:

example/greetings/greetings.go:

package greetings

import "fmt"

func Hello(name string) string {
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message
}    

$ go mod init github.com/greetings
go: creating new go.mod: module github.com/greetings
go: to add module requirements and sums:
        go mod tidy    

example/greetings/go.mod:

module github.com/greetings

go 1.21.4    

example/hello/hello.go:

package main

import (
    "fmt"

    "github.com/greetings"
)

func main() {
    message := greetings.Hello("Bogotobogo")
    fmt.Println(message)
}

$ cd hello

$ go mod init github.com/hello
go: creating new go.mod: module github.com/hello
go: to add module requirements and sums:
        go mod tidy   

example/hello/go.mod:

module github.com/hello

go 1.21.4

$ go mod edit -replace github.com/greetings=../greetings     

module github.com/hello

go 1.21.4

replace github.com/greetings => ../greetings

$ go mod tidy
go: found github.com/greetings in github.com/greetings v0.0.0-00010101000000-000000000000    

module github.com/hello

go 1.21.4

replace github.com/greetings => ../greetings

require github.com/greetings v0.0.0-00010101000000-000000000000

$ go run hello.go
Hi, Bogotobogo. Welcome!    

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)