Spring Boot での依存関係の注入: カーテンの向こう側の魔術師
Spring Boot が、どういうわけかあなたが必要なものを知っていて、それを銀の大皿に乗せて渡してくれる魔法の執事のように感じたことはありませんか?これは基本的に 依存関係の注入 (DI) です。あなたはおそらく、DI を 100 回も使用したことがあるでしょう: 一体、Spring は何をいつ注入するかをどのようにして知るのでしょうか?
そう思われる方は、ぜひご参加ください! Spring Boot の DI がどのようにウィザードリーを実行するのかについて、楽しい舞台裏のツアーに参加します。まず、Bean、@Autowired、および Bean のライフサイクル (生成から破棄まで) を管理する方法から始めます。このブログを終える頃には、新しく見つけた DI の知識をプロのように活用できるようになっているでしょう。
平たく言えば、Dependency Injection は、食料品を自分で買いに行くのではなく、自宅まで配達してもらうようなものです。これは、依存関係 (Bean) を「注入」する責任を Spring に委任することで、オブジェクトを手動で作成したり、そのライフサイクルについて心配したりする必要がなくなるようにすることです。
あなたはシェフで、忙しいキッチン (アプリケーション) を運営していると想像してください。必要なたびに卵、牛乳、砂糖を買いに行く時間はありません。誰か (たとえば、Spring) が魔法のように、必要なものを必要なときに正確に届けてくれたら素晴らしいと思いませんか?
それはまさに Spring DI が行うことです。Spring DI は必要なすべての要素 (Bean) を見つけて、指を動かすことなくそれらをコードに注入します。かなりきれいですね?
さて、ここで魔法が起こります。 SpringApplication.run() を使用して Spring Boot アプリを実行すると、Spring は ApplicationContext をブートストラップします。これは執事の取扱説明書と考えてください。何をいつ取得するかを正確に知っています。
段階的に見てみましょう:
コンテナの初期化: SpringApplication.run() を押すと、Spring コンテナ (別名 ApplicationContext) が動作を開始します。それは、仮想レストランへのドアを開けるようなもので、そこではすべての準備が整っています。
Bean の作成: コンテナーはコードをスキャンして @Component、@Service、@Repository、または @Controller などの注釈を探します。これらはそれぞれ Bean (Spring によって管理されるオブジェクト) になります。小麦粉、砂糖、卵など、キッチンに欠かせない材料と考えてください。
BeanFactory による救済: Spring Boot は、BeanFactory を使用してこれらの Bean を作成および管理します。この工場は、いつ、どのように Bean を作成するかを正確に把握しており、必要なときに確実に利用できるようにします。
依存関係の注入: Bean の準備が完了すると、Spring は @Autowired でマークした場所にそれらを注入します。それは、コーヒーを作るだけでなく、コーヒーを必要な正確なカウンターに届けるバリスタがいるようなものです。考える必要さえありません。すべては現れるだけです。
ああ、古き良き @Autowired アノテーションですね。 Spring がどのようにして依存関係を注入する場所を魔法のように判断するのか不思議に思ったことはありませんか?これは、ユーザーのニーズとレジストリ内の適切な Bean を照合する探偵のようなものです。
その仕組みは次のとおりです:
タイプ マッチング: Spring は @Autowired を認識すると、コンテナ内で同じタイプの Bean を探します。あなたがコーヒー豆 (CoffeeService クラス) を注文したと想像してください。Spring はその Bean リポジトリを調べて、「ああ、それはあるよ!」と言いました。注射しましょう。」
修飾子: しかし、同じタイプの Bean が複数ある場合はどうなるでしょうか?その場合、Spring が異常を起こして「NoUniqueBeanDefinitionException」のような例外をスローする可能性があります。でも心配しないでください。@Qualifier を使用して注入する Bean を指定することで、Spring を落ち着かせることができます。
@Autowired
@Qualifier("espressoBean")
private CoffeeService coffeeService;
public class CoffeeShop {
private final CoffeeService coffeeService;
@Autowired
public CoffeeShop(CoffeeService coffeeService) {
this.coffeeService = coffeeService;
}
}
Spring は自動操縦を開始し、コンストラクターに Bean を注入します。これで準備完了です。
Beans in Spring Boot aren’t just objects. They have full-fledged lives, complete with an origin story, a fulfilling career, and an eventual retirement. Let’s follow the lifecycle of a bean:
Instantiation (Birth): First, Spring creates an instance of the bean. This is like the bean’s birth. Spring goes, "Here you go, little guy!" and passes it into the container.
Dependency Injection: After creating the bean, Spring populates it with dependencies (like ingredients in a cake recipe). This is where @Autowired comes into play. Your bean gets everything it needs to work properly.
Post-Initialization: If you have methods annotated with @PostConstruct, Spring calls those after it injects the dependencies. It’s like giving the bean a fresh coat of paint before it goes to work.
Ready for Action: Now your bean is alive and kicking. It’s ready to take on the world!
Pre-Destruction (Retirement): When the application shuts down, Spring calls @PreDestroy methods to give the bean a graceful exit. This is the bean's retirement party, where it cleans up its resources.
Bean Destruction: Finally, the bean is destroyed. Time to rest in peace.
Here’s how you can track these lifecycle events in code:
@Component
public class CoffeeBean {
@PostConstruct
public void onStart() {
System.out.println("Bean is ready to brew some coffee!");
}
@PreDestroy
public void onEnd() {
System.out.println("Bean is retiring. Goodbye, world!");
}
}
Not all beans have the same life expectancy. Spring Boot allows you to define different scopes for beans—basically how long they live. The two most common ones are:
Singleton (the Default): There’s only one instance of the bean, shared across the entire application. It’s like having one espresso machine for the whole coffee shop.
Prototype: A new instance of the bean is created every time it’s needed. Imagine having a fresh espresso machine for every single order. It’s resource-heavy, but sometimes necessary.
@Component
@Scope("prototype")
public class LatteMachine {
// This bean is made fresh for every use
}
Alright, let’s talk about what happens when you run your Spring Boot app using SpringApplication.run(). This method is the grandmaster that kicks off the whole DI process.
Think of your Spring Boot application as a coffee shop. You’re the owner, and the beans are your ingredients: coffee, milk, sugar, etc. Instead of running around managing these ingredients yourself, you’ve got a barista (the Spring container) who fetches everything and delivers it exactly where it’s needed.
All you have to do is give the orders (set up your @Autowired fields), and the barista handles the rest—perfectly brewing that dependency-filled cup of coffee for your customers (application).
At the end of the day, Dependency Injection is what makes Spring Boot such a powerful framework. It simplifies your life, manages your beans, and ensures your code is easy to maintain and extend.
Now that you’ve peeked behind the curtain, you’ve got a superpower that many developers take for granted. So go ahead—start using DI like the wizard you now are. And the next time you see @Autowired, you’ll know exactly what’s going on under the hood.
I hope this blog gave you a deeper understanding of Spring Boot DI and left you with a smile. Now go inject some beans and show your friends how it's done!
How’s that for a blog that’s fun, informative, and easy to understand? Let me know if you'd like any more tweaks!
以上がSpring Boot での依存関係の注入: カーテンの向こうの魔法使いの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。
![[Web フロントエンド] Node.js クイック スタート](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
