Das Dokument gibt eine Einführung in die Programmiersprache Go für Java-Entwickler und behandelt grundlegende Konzepte wie Variablen, Slices, Schleifen, Strukturen und Fehlerbehandlung. Es werden auch fortgeschrittene Themen wie Goroutinen, Channels und das Konzept der Einbettung anstelle von Vererbung erklärt. Zudem wird auf die Verwendung von Go in modernen Anwendungen wie Microservices und Serverless-Architekturen eingegangen.

1. JAVA TO GO
GOOGLE GO FÜR JAVA
ENTWICKLER

3. 467.882 ZEILEN CODE
2.130 CONTRIBUTORS

5. 3 GRÜNDE FÜR GO
1 Einfach
2 Mächtig
3 Langweilig

7. HELLO GOPHER
package main
import "fmt"
func main() {
fmt.Println("Hello Gopher!")
}
Ausführen
go build hellogopher.go // 1. Code kompilieren
./hellogopher // 2. Binary ausführen
go run hellogopher.go // Code kompilieren und ausführen

8. ENTWICKLUNG
JetBrains
GoLand
Visual
Studio Code
Vim Go

9. 5 FAKTEN ZU GO
1 statisches Typsystem
2 Garbage Collection
3 keine Vererbung
4 Concurrency eingebaut
5 native Ausführung
Linux, Win, z/OS, 386, amd64, ARM, wasm, ...

10. VARIABLEN, SLICES, SCHLEIFEN
// Variable
var frank string = "Frank"
claire := "Claire"
1
2
3
4
// Array (fixe Länge)
5
namesArray := [3]string{frank, claire, "Zoe"}
6
7
// Slice (variable Länge)
8
namesSlice := make([]string, 2)
9
namesSlice[0] = frank
10
11
// Schleife
12
for i, name := range namesSlice {
13
fmt.Println("Hello " + name + "!")
14
}
15
// Array (fixe Länge)
namesArray := [3]string{frank, claire, "Zoe"}
// Variable
1
var frank string = "Frank"
2
claire := "Claire"
3
4
5
6
7
// Slice (variable Länge)
8
namesSlice := make([]string, 2)
9
namesSlice[0] = frank
10
11
// Schleife
12
for i, name := range namesSlice {
13
fmt.Println("Hello " + name + "!")
14
}
15
// Slice (variable Länge)
namesSlice := make([]string, 2)
namesSlice[0] = frank
// Variable
1
var frank string = "Frank"
2
claire := "Claire"
3
4
// Array (fixe Länge)
5
namesArray := [3]string{frank, claire, "Zoe"}
6
7
8
9
10
11
// Schleife
12
for i, name := range namesSlice {
13
fmt.Println("Hello " + name + "!")
14
}
15
// Schleife
for i, name := range namesSlice {
fmt.Println("Hello " + name + "!")
}
// Variable
1
var frank string = "Frank"
2
claire := "Claire"
3
4
// Array (fixe Länge)
5
namesArray := [3]string{frank, claire, "Zoe"}
6
7
// Slice (variable Länge)
8
namesSlice := make([]string, 2)
9
namesSlice[0] = frank
10
11
12
13
14
15

11. STRUCT STATT KLASSE
type Congressman struct {
Name string
}
1
2
3
4
func main() {
5
c := Congressman{Name: "Peter Russo"}
6
fmt.Println("Hello " + c.Name + "!")
7
}
8
c := Congressman{Name: "Peter Russo"}
fmt.Println("Hello " + c.Name + "!")
type Congressman struct {
1
Name string
2
}
3
4
func main() {
5
6
7
}
8
type Congressman struct {
Name string
}
func main() {
c := Congressman{Name: "Peter Russo"}
fmt.Println("Hello " + c.Name + "!")
}
1
2
3
4
5
6
7
8

12. FUNCTION RECEIVER STATT INSTANZMETHODE
func (c Congressman) swearOathOfOffice() {
fmt.Printf("I, %v, swear to serve the USA.", c.Name)
}
type Congressman struct {
1
Name string
2
}
3
4
5
6
7
8
func main() {
9
c := Congressman{Name: "Peter Russo"}
10
c.swearOathOfOffice();
11
}
12
func (c Congressman) swearOathOfOffice() {
fmt.Printf("I, %v, swear to serve the USA.", c.Name)
}
c := Congressman{Name: "Peter Russo"}
c.swearOathOfOffice();
type Congressman struct {
1
Name string
2
}
3
4
5
6
7
8
func main() {
9
10
11
}
12

13. INTERFACE
type Greeter interface {
greet()
}
1
2
3
4
func passBy(c1 Greeter, c2 Greeter)
5
c1.greet()
6
c2.greet()
7
}
8
9
func main() {
10
c := Congressman{Name: "Frank U."
11
e := Enemy{}
12
passBy(c, e)
13
}
14
func passBy(c1 Greeter, c2 Greeter)
c1.greet()
c2.greet()
}
type Greeter interface {
1
greet()
2
}
3
4
5
6
7
8
9
func main() {
10
c := Congressman{Name: "Frank U."
11
e := Enemy{}
12
passBy(c, e)
13
}
14
func main() {
c := Congressman{Name: "Frank U."
e := Enemy{}
passBy(c, e)
}
type Greeter interface {
1
greet()
2
}
3
4
func passBy(c1 Greeter, c2 Greeter)
5
c1.greet()
6
c2.greet()
7
}
8
9
10
11
12
13
14
type Greeter interface {
greet()
}
1
2
3
4
func passBy(c1 Greeter, c2 Greeter)
5
c1.greet()
6
c2.greet()
7
}
8
9
func main() {
10
c := Congressman{Name: "Frank U."
11
e := Enemy{}
12
passBy(c, e)
13
}
14
type Congressman struct {
Name string
}
func (c Congressman) greet() {
fmt.Println("Hello", c.Name)
}
type Enemy struct{}
func (e Enemy) greet() {
fmt.Println("Go to hell!")
}

14. ZU EINFACH?

15. STRUCT EMBEDDING STATT VERERBUNG
type Congressman struct {
Name string
}
1
2
3
4
type President struct {
5
Congressman // Embedded
6
7
NuclearWeaponCode string
8
}
9
10
func main() {
11
p := President{NuclearWeaponCode: "123"}
12
p.Name = "Frank Underwood"
13
p.swearOathOfOffice();
14
}
15
type President struct {
Congressman // Embedded
NuclearWeaponCode string
}
type Congressman struct {
1
Name string
2
}
3
4
5
6
7
8
9
10
func main() {
11
p := President{NuclearWeaponCode: "123"}
12
p.Name = "Frank Underwood"
13
p.swearOathOfOffice();
14
}
15
p := President{NuclearWeaponCode: "123"}
p.Name = "Frank Underwood"
p.swearOathOfOffice();
type Congressman struct {
1
Name string
2
}
3
4
type President struct {
5
Congressman // Embedded
6
7
NuclearWeaponCode string
8
}
9
10
func main() {
11
12
13
14
}
15

16. FEHLER
// Fehler als Rückgabewert
func (c Congressman) bribe(amount float64) error {
if c.Name != "Peter Russo" {
return errors.New("Not corrupt!")
}
c.AccountBalance += amount
return nil
}
1
2
3
4
5
6
7
8
9
func main() {
10
c := Congressman{Name: "Jackie Sharp", AccountBalance: -10.0}
11
12
// Fehler behandeln
13
err := c.bribe(5000.0)
14
if err != nil {
15
fmt.Printf("%v is not bribable.", c.Name)
16
}
17
}
18
// Fehler behandeln
err := c.bribe(5000.0)
if err != nil {
fmt.Printf("%v is not bribable.", c.Name)
}
// Fehler als Rückgabewert
1
func (c Congressman) bribe(amount float64) error {
2
if c.Name != "Peter Russo" {
3
return errors.New("Not corrupt!")
4
}
5
c.AccountBalance += amount
6
return nil
7
}
8
9
func main() {
10
c := Congressman{Name: "Jackie Sharp", AccountBalance: -10.0}
11
12
13
14
15
16
17
}
18

17. GENERICS
func printSliceOfInts(numbers []int) {
for _, num := range numbers {
fmt.Print(num, " ")
}
}
func printSliceOfStrings(strings []string) {
for _, num := range strings {
fmt.Print(num, " ")
}
}
Kommen in Go 1.18 im Februar 2022!

18. MÄCHTIG

19. CONCURRENCY
GOROUTINE
leichtgewichtiger Thread
CHANNEL
Kanal für Nachrichten, dient der
Kommunkation
Synchronisation
von Goroutinen

20. GOROUTINE
func main() {
go HelloCongressman("Russo")
}
func HelloCongressman(name string) {
1
fmt.Println("Hello Congressman", name)
2
}
3
4
5
6
7

21. CHANNEL
// Deklarieren und Initialisieren
c := make(chan int)
1
2
3
// Nachricht über Channel senden
4
c <- 1
5
6
// Nachricht von Channel empfangen,
7
// "Pfeil" gibt Richtung des Datenfluss an
8
value = <-c
9
// Nachricht über Channel senden
c <- 1
// Deklarieren und Initialisieren
1
c := make(chan int)
2
3
4
5
6
// Nachricht von Channel empfangen,
7
// "Pfeil" gibt Richtung des Datenfluss an
8
value = <-c
9
// Nachricht von Channel empfangen,
// "Pfeil" gibt Richtung des Datenfluss an
value = <-c
// Deklarieren und Initialisieren
1
c := make(chan int)
2
3
// Nachricht über Channel senden
4
c <- 1
5
6
7
8
9

22. DEBATTE MIT GOROUTINEN UND CHANNELS
debate := make(chan int) // Channel deklarieren und initialisieren
func speaker(name string, debate chan int) {
1
for {
2
microphone := <-debate // Auf Mikro warten (Nachricht empfangen)
3
4
fmt.Printf("Turn %v: %v says '%v'n", microphone, name, randomAnswer())
5
time.Sleep(400 * time.Millisecond)
6
7
microphone++
8
debate <- microphone // Mikro zurückgeben (Nachricht senden)
9
}
10
}
11
12
func main() {
13
14
15
go speaker("Jackie", debate)
16
go speaker("Frank", debate)
17
18
microphone := 1
19
debate <- microphone // Mikro geben und Diskussion starten
20
time.Sleep(2 * time.Second) // Dauer der Diskussion
21
<-debate // Mikro nehmen und Diskussion beenden
22
}
23
debate := make(chan int) // Channel deklarieren und initialisieren
go speaker("Jackie", debate)
go speaker("Frank", debate)
func speaker(name string, debate chan int) {
1
for {
2
microphone := <-debate // Auf Mikro warten (Nachricht empfangen)
3
4
fmt.Printf("Turn %v: %v says '%v'n", microphone, name, randomAnswer())
5
time.Sleep(400 * time.Millisecond)
6
7
microphone++
8
debate <- microphone // Mikro zurückgeben (Nachricht senden)
9
}
10
}
11
12
func main() {
13
14
15
16
17
18
microphone := 1
19
debate <- microphone // Mikro geben und Diskussion starten
20
time.Sleep(2 * time.Second) // Dauer der Diskussion
21
<-debate // Mikro nehmen und Diskussion beenden
22
}
23
debate := make(chan int) // Channel deklarieren und initialisieren
go speaker("Jackie", debate)
go speaker("Frank", debate)
microphone := 1
debate <- microphone // Mikro geben und Diskussion starten
time.Sleep(2 * time.Second) // Dauer der Diskussion
<-debate // Mikro nehmen und Diskussion beenden
func speaker(name string, debate chan int) {
1
for {
2
microphone := <-debate // Auf Mikro warten (Nachricht empfangen)
3
4
fmt.Printf("Turn %v: %v says '%v'n", microphone, name, randomAnswer())
5
time.Sleep(400 * time.Millisecond)
6
7
microphone++
8
debate <- microphone // Mikro zurückgeben (Nachricht senden)
9
}
10
}
11
12
func main() {
13
14
15
16
17
18
19
20
21
22
}
23
func speaker(name string, debate chan int) {
for {
microphone := <-debate // Auf Mikro warten (Nachricht empfangen)
fmt.Printf("Turn %v: %v says '%v'n", microphone, name, randomAnswer())
time.Sleep(400 * time.Millisecond)
microphone++
debate <- microphone // Mikro zurückgeben (Nachricht senden)
}
}
debate := make(chan int) // Channel deklarieren und initialisieren
go speaker("Jackie", debate)
go speaker("Frank", debate)
microphone := 1
debate <- microphone // Mikro geben und Diskussion starten
time.Sleep(2 * time.Second) // Dauer der Diskussion
<-debate // Mikro nehmen und Diskussion beenden
1
2
3
4
5
6
7
8
9
10
11
12
func main() {
13
14
15
16
17
18
19
20
21
22
}
23

23. DEBATTE MIT GOROUTINEN UND CHANNELS
>_ go run debate.go
Turn 1: Frank says 'You liar.'
Turn 2: Jackie says 'Back off.'
Turn 3: Frank says 'Back off.'
Turn 4: Jackie says 'My point.'
Turn 5: Frank says 'You liar.'
Turn 6: Jackie says 'You're wrong.'

24. STANDARDBIBLIOTHEK
Tests
#
HTTP(2) Server und Router
#
JSON
#
Logging
#

25. EINFACH
LANGWEILIG
Variablen,
Slices,
Schleifen
Struct
#
#
ZU EINFACH?
Struct
Embedding
Fehler
Generics
#
#
#
MÄCHTIG
Interface
Goroutine
Channel
Standardbibliothe
#
#
#
#

26. DEMO

27. GO LIEBT
Microservices Serverless Functions
Kommandozeilen-Tools DevOps und Cloud

29. JAN STAMER
Solution Architect
jan.stamer@comdirect.de