GAE Go, init() - call it multiple times?

I'm writing a Google App Engine Go application. In it, I want to handle some calls separately in different .go files. Should I call "init()" function separately in each of those files, or just declare it in one file and call some other functions for initialisation of each .go file?

For example, if I'd have two files, user.go:

package User

import(
	"http"
	"fmt"
)

func init() {
    http.HandleFunc("/", hello)
}

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, user!")
}

And admin.go:

package Admin

import(
	"http"
	"fmt"
)

func init() {
    http.HandleFunc("/admin/", hello)
}

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, admin!")
}

Is such an initialisation correct, or is it advised against something like this?

According to Go language specification:

• all initialization code is run in a single goroutine, and

• init() functions within a single package execute in unspecified order

In your case, the packages User and Admin are independent (User does not import Admin, nor Admin imports User). This means that:

• the two init() functions in User and Admin execute in unspecified order

Joining the bodies of the two init() functions in a single init() function would look like this:

func init() {
    http.HandleFunc("/", User.Hello)
    http.HandleFunc("/admin/", Admin.Hello)
}

Notice that it is irrelevant whether the program first registers <code>"/"</code> or <code>"/admin/"</code>. So, the following code is also valid :

func init() {
    http.HandleFunc("/admin/", Admin.Hello)
    http.HandleFunc("/", User.Hello)
}

From the above two snippets of code, we can see that it is OK for <code>http.HandleFunc("/", ...)</code> and <code>http.HandleFunc("/admin/", ...)</code> to be called in unspecified order.

Because <code>"/"</code> and <code>"/admin/"</code> can be registered in any order, and all init() functions run in a single goroutine, the answer to your question is: Yes, such an initialisation correct.

I think your question is really one of package design. I can't quite tell by your question, but you may also be confusing packages and source files. To clarify: a package is made up of one or more source files in one directory, defines a logical unit of functionality including public APIs and private internal representations of data.

If you are interested in the specifics of init(), here are the relevant portions of the spec

> A package with no imports is initialized by assigning initial values
> to all its package-level variables and then calling any package-level
> function with the name and signature of
>
> func init()
>
> defined in its source.

You have two packages defined in your code above, so the following also applies:

> If a package has imports, the imported packages are initialized before
> initializing the package itself.

Which suggests if there is a dependence of Admin on User (or vice versa) that will determine the order in which the two init() calls are executed. No such dependence will result in the execution of the init() calls in unspecified order.

However, given the code that you have, you don't really care in which order they execute. So really it comes down to whether you really need two packages or whether you could do with a single package (possibly with two separate source files).

Some questions you might ask yourself:

• Are there two separate (business) functions to be represented?
• Do you need to provide separate public APIs?
• Any organizational reasons to separate different packages (different coders)?
• Do you plan to reuse the code in one or more packages independent of the other?