Dagger中@Singleton注解用于方法的作用及相关疑问

Great question—this is a super common confusion when you’re getting used to how Dagger handles scoping! Let’s break this down clearly:

First: What @Singleton on a @Provides method actually does #

You’re totally right that methods themselves don’t have "instances" the way classes do. The @Singleton annotation here isn’t about the method—it’s about the object that the method provides.

When you mark a @Provides method with @Singleton, you’re telling Dagger: "For the entire lifecycle of the component that includes this module, only create one instance of the object returned by this method. Reuse that single instance for every client that needs it."

How this differs from @Singleton on a class #

Putting @Singleton directly on a class (like @Singleton class ElectricHeater) works too—but only if Dagger can instantiate that class directly. That means the class needs an @Inject-annotated constructor (or a no-arg constructor, though using @Inject is better practice).

But there are cases where you can’t or don’t want to annotate the class itself:

• Maybe the class is from a third-party library, so you can’t modify its code to add @Singleton.
• Maybe you need to configure the instance before returning it (e.g., return new ElectricHeater(true); with a specific parameter), so you need a @Provides method to handle that setup.
• Maybe you’re returning an interface type (like Heater) instead of the concrete class, so Dagger needs guidance on how to scope the concrete instance being provided.

In all these cases, putting @Singleton on the @Provides method is how you tell Dagger to treat the provided instance as a singleton within the component’s scope.

Does every call to the method return the same instance? #

Short answer: Not if you call the method manually—but you shouldn’t be calling these @Provides methods yourself!

Dagger is the one that calls these methods as part of building its dependency graph. The first time a client needs the Heater instance, Dagger will invoke provideHeater() to create the ElectricHeater. After that, every other client that requests a Heater will get that exact same instance—Dagger won’t call the provideHeater() method again for the lifetime of the component.

So the documentation’s line about "the graph will use a single instance for all clients" means exactly that: every part of your code that gets a Heater via Dagger’s injection will receive the same ElectricHeater object.

For example, if you have two classes:

class CoffeeMaker {
  @Inject Heater heater;
}

class TeaMaker {
  @Inject Heater heater;
}

Dagger will inject the same ElectricHeater instance into both CoffeeMaker and TeaMaker when they’re created through the component.

内容的提问来源于stack exchange，提问作者Johann