在Angular应用中践行依赖倒置原则是否合理？该实现是否有价值？

Great question—this is a super common dilemma when trying to apply the Dependency Inversion Principle (DIP) in Angular, especially since TypeScript interfaces don’t exist at runtime, forcing us to work around the lack of "interface-based injection" natively. Let’s break down when this approach adds real value, and when it’s just unnecessary complexity.

When This Approach Does Add Value #

• Cross-module/library abstraction: If your service contract needs to be shared across independent modules or external libraries, an InjectionToken acts as a runtime-safe stand-in for an interface. For example, if you’re building a UI toolkit that expects a data-fetching service, using a token lets consumers of your library provide their own implementation without coupling to your concrete class.
• Simpler testing: This pattern makes unit testing way easier. Instead of messing with override providers for concrete classes, you can just swap out the useClass (or use useValue for mocks) in your test module’s providers. Your component code stays untouched—no need for conditional logic or refactoring to accommodate tests.
• Dynamic runtime switching: If you need to swap service implementations based on environment, user roles, or runtime conditions, InjectionToken pairs beautifully with useFactory. For instance, you could use a mock service in development and a real API service in production, all without changing how components inject the service.
• Compile-time type safety: Even though interfaces disappear at runtime, using a generic InjectionToken<CustomType> lets TypeScript enforce that any provided implementation matches the expected contract. This is way safer than injecting a concrete class directly if you want to enforce a specific set of methods/properties.

When It’s Unnecessary Complexity #

• Small, single-module apps: If your app is tiny, the service is only used within one module, and you have zero plans to swap out its implementation, this pattern is overkill. Injecting the concrete class directly is simpler, more readable, and has less cognitive overhead for new developers.
• Module-specific services with no reuse: You mentioned module-level services have inherent specificity—and that’s exactly right. If a service is purpose-built for a single module and will never be used elsewhere, adding an InjectionToken just adds an extra layer of abstraction that no one needs to maintain.

Quick Checklist to Decide #

Ask yourself these questions to determine if the pattern is worth it:

1. Will this service be reused across multiple modules or external libraries?
2. Do I anticipate needing to swap the service’s implementation in the future?
3. Will I need to mock this service frequently for unit testing?
4. Do I need to dynamically switch implementations at runtime?

If any of these are "yes," go for the InjectionToken approach—it’ll pay off in flexibility and maintainability. If all are "no," stick with injecting the concrete class to keep things simple.

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