Dependency Injection through Generics

In this lesson, you will learn how to use Rust generics to swap component implementations at compile time, achieving dependency injection without the performance overhead of dynamic dispatch.

The Problem with Hard-coding

In many applications, your high-level logic (like a DataProcessor) relies on a low-level service (like a Database). If you hard-code the specific database type inside your processor, your code becomes brittle and impossible to test without a live connection. Traditionally, languages use "Dependency Injection" via interfaces and dynamic dispatch (pointers), which adds a small runtime cost. In Rust, we use generics to inject the dependency at compile time.

Injecting via Generics

Instead of the DataProcessor knowing exactly which database it talks to, we define the processor to work with any type T that implements a specific trait.

trait Database {
    fn save(&self, data: &str);
}

// The Processor doesn't care WHAT the database is, 
// as long as it satisfies the Database trait.
struct DataProcessor<T: Database> {
    db: T,
}

impl<T: Database> DataProcessor<T> {
    fn process(&self, data: &str) {
        self.db.save(data);
    }
}

Swapping Components

Because the DataProcessor is generic, you can easily swap the dependency based on your environment. In production, you provide your real database implementation. During testing, you provide a "Mock" struct that implements the same trait.

struct PostgresDB;
impl Database for PostgresDB { fn save(&self, d: &str) { /* Real SQL */ } }

struct MockDB;
impl Database for MockDB { fn save(&self, d: &str) { /* Just print to console */ } }

// Swap easily:
let prod_processor = DataProcessor { db: PostgresDB };
let test_processor = DataProcessor { db: MockDB };

Because this is resolved via generics, the Rust compiler generates specific machine code for each version of DataProcessor. There is no "vtable" lookup at runtime, and the compiler can often inline the method calls entirely, making this a truly zero-cost abstraction. You decouple your logic from your infrastructure while keeping your performance lightning-fast.

Key Takeaway: By using generic trait bounds, you can inject dependencies at compile time, allowing for seamless swapping between production and test components with zero runtime performance penalty.