Learning Objectives

• Understand what the App struct pattern is and why it's useful
• Learn how to define a struct to hold application dependencies
• See how structs can organize application state and configuration
• Understand the foundation for dependency management in Go applications

Introduction

In this one, you're gonna introduce an App struct to your application. This struct will hold your application's dependencies and state, making it easier to manage and pass around shared resources like database connections. This is the first step toward a more organized application structure that scales as your project grows.

Theory/Concept

What is the App struct pattern?

As your Go application grows, you'll need to share resources like database connections, configuration, and other dependencies across multiple handlers. Instead of passing these around as individual parameters or using global variables, you can group them together in a struct.

The App struct acts as a container for all your application's dependencies and state. Think of it as your application's central hub - everything your app needs lives here.

Defining the App struct:

type App struct {
	DB *sql.DB
}

This simple struct has one field: a database connection. Right now, it's just a definition - you're not using it yet. But this is the foundation. As your application grows, you'll add more fields to this struct: configuration, loggers, stores, and other dependencies.

Why use a struct instead of global variables?

Global variables work, but they make testing harder and can lead to hidden dependencies. With an App struct:

• Dependencies are explicit and visible
• You can create multiple App instances for testing
• It's clear what each handler needs
• You can pass the App to handlers as a parameter

What comes next:

In this lesson, you're just defining the struct. In future lessons, you'll:

• Create an instance of App in your main function
• Pass it to your handlers
• Use it to access shared resources

For now, you're setting up the structure that will make your code more maintainable as it grows.

Key Takeaways

• The App struct pattern groups application dependencies and state together
• Structs make dependencies explicit and easier to manage than global variables
• Start simple with just the dependencies you need (like DB)
• The App struct will grow as your application adds more features
• This pattern makes testing easier by allowing multiple App instances

Related Go Bytes

• Go Structs Basics - Video | GitHub Repo
• Go Application Structure - Video | GitHub Repo