1. IoC (Inversion of Control)
Inversion of Control์ ๋ป์ "์ ์ด์ ์ญ์ "์ด๋ค. ์ฌ๊ธฐ์ ๋งํ๋ ์ ์ด๋, ๊ฐ์ฒด๋ฅผ ์ง์ ์์ฑํ๊ฑฐ๋ ์ฐพ๋ ๋ฐฉ์์์ ๋ฒ์ด๋ Spring Framework์ IoC ์ปจํ ์ด๋ ์๊ฒ ์ ์ด์ ๊ถํ์ ๋๊น์ผ๋ก์จ, IoC ์ปจํ ์ด๋๊ฐ ํ์ํ ๋ ์์์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ ํ์ํ ์์กด์ฑ์ ์์์ ์ฃผ์ ์ ํด์ฃผ๋ ๋ฐฉ์์ ์๋ฏธํ๋ค.
- ๊ฐ์ฒด์ ์ ์ด๋ฅผ ์ธ๋ถ์์ ๋ด๋นํ๊ฒ ํ๋ค๋ ํญ ๋์ ๊ฐ๋
- IoC Container์๊ฒ ์ ์ด ๊ถํ์ ๋๊ธด๋ค๋ ๊ฐ๋
* IoC Container : Spring Framework๊ฐ ์์กด์ฑ ์ฃผ์ ์ ์๋์ ํด์ฃผ๊ธฐ ์ํ "Bean"๋ค์ ์งํฉ๊ณผ "Bean"๋ค์ ๊ด๋ฆฌํด์ฃผ๋ ๊ณต๊ฐ์ด๋ค.
* Bean : Spring Framework๊ฐ ๊ด๋ฆฌํ๋ ๊ฐ์ฒด๋ค์ "Bean"์ด๋ผ๊ณ ํ๋ค. ( ์์ธํ ์ค๋ช ์ ์ถํ์ ๋ค๋ฃจ๊ฒ ๋ค. )
2. DI (Dependency Injection)
Dependency Injecton์ ๋ป์ "์์กด์ฑ ์ฃผ์ "์ด๋ค. ์ฌ๊ธฐ์ ๋งํ๋ "์์กด"์ด๋, ๊ฐ์ฒด A๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด B๋ฅผ ์์ฑํ๊ฑฐ๋ ์ฐธ์กฐํ ๋, A๋ B์ "์์กด"ํ๋ค๊ณ ๋งํ ์ ์๋ค. ์ด๊ฒ์ "์์กด ๊ด๊ณ" ๋ผ๊ณ ๋งํ ์ ์๋ค.
public class A {
private B b;
public A() {
this.b = new B(); // ์์ฑ์ ํตํ ์์กด๊ด๊ณ
// A๋ B๋ฅผ ์์กด ํ๊ณ ์์. ๋์ ์์กด ๊ด๊ณ์ด๋ค.
}
}
"์์กด"์ด๋๊ฑธ ์ดํด๋ฅผ ํ๋ค๋ฉด, ์ด์ "์์กด์ฑ ์ฃผ์ (DI)"์ ๋ํด ์์๋ณด์.
"์์กด์ฑ ์ฃผ์ "์ ๋ง๊ทธ๋๋ก "์ฐธ์กฐ๋ฅผ ํตํด ์ธ๋ถ์์ ๊ฐ์ฒด๋ฅผ ์ฃผ์ ํด์ฃผ๋ ๋ฐฉ์"์ด๋ค.
public class A {
private B b;
public A(B b) {
this.b = b; // ์ฐธ์กฐ๋ฅผ ํตํ ์์กด ๊ด๊ณ
}
}
3. DI (Dependency Injection) ์ฅ์
1. ๊ฒฐํฉ๋ ๊ฐ์
A ๊ฐ์ฒด์ B ๊ฐ์ฒด ๊ฐ์ ๊ฒฐํฉ๋๊ฐ ๋ฎ์์ง๋ค. A ๊ฐ์ฒด๊ฐ B ๊ฐ์ฒด๋ฅผ ์ง์ ์์ฑํ์ง ์๊ธฐ ๋๋ฌธ์, B ๊ฐ์ฒด๊ฐ ๋ง์ฝ ์ธํฐํ์ด์ค๋ ์ถ์ํด๋์ค์ผ ๊ฒฝ์ฐ ๊ตฌํ์ฒด๊ฐ ๋ฐ๋๋๋ผ๋ A ๊ฐ์ฒด์ ์ฝ๋์ ๋ณ๊ฒฝ์ด ์์ด์ง๋ค๋ ์ฅ์ ์ด ์๋ค. ( ์ ์ง ๋ณด์์ฑ ํฅ์ )
2. ์ ์ฐ์ฑ๊ณผ ํ์ฅ์ฑ
์ธ๋ถ์์ ์ฃผ์ ๋ฐ๋ ์์กด์ฑ์ ํ์์ ๋ฐ๋ผ ์ฝ๊ฒ ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํ๋ค. ๊ตฌํ์ฒด๋ฅผ ๋ฐ๊ฟ์ผ๋ก์จ, ๊ธฐ์กด ์ฝ๋์ ๋ณ๊ฒฝ ์์ด ์๋ก์ด ๊ธฐ๋ฅ์ด๋ ์๊ตฌ ์ฌํญ์ ๋์ํ ์ ์๋ค๋ "์ ์ฐ์ฑ"๊ณผ "ํ์ฅ์ฑ"์ ๊ฐ์ง๊ฒ ๋๋ค.
3. ์ฝ๋ ์ฌ์ฌ์ฉ์ฑ ์ฆ๊ฐ
์ฌ๋ฌ ํด๋์ค๊ฐ ๋์ผํ ์์กด์ฑ์ ํ์๋ก ํ๋ฉด, ์์กด์ฑ ์ฃผ์ ์ ํตํด ๋์ผํ ๊ฐ์ฒด๋ฅผ ์ฌ๋ฌ ํด๋์ค์์ ์ฌ์ฌ์ฉ์ ํ ์ ์๋ค. ์ด๋ฅผ ํตํด ์ฝ๋์ ์ค๋ณต์ ์ค์ผ ์ ์๊ณ , ์ ์ง๋ณด์์ฑ์ ๋์ผ ์ ์๋ค.
๊ฒฐ๋ก
IoC๋ ์ธ๋ถ์ ๊ฐ์ฒด ์์ฑ๊ณผ ์ฃผ์ ์ ๋ํ ์ ์ด๋ฅผ ๋งก๊ธด๋ค๋ ์๋ฏธ์ด๊ณ , DI๋ IoC์ ๊ฐ์ฒด ์ฃผ์ ์ ์ค์ ๋ก ๊ตฌํํ ๊ฐ๋ ์ด๋ค.
์ฐธ์กฐ ( Spring ๊ณต์ ๋ฌธ์ )
https://docs.spring.io/spring-framework/reference/core/beans/introduction.html
Introduction to the Spring IoC Container and Beans :: Spring Framework
This chapter covers the Spring Framework implementation of the Inversion of Control (IoC) principle. Dependency injection (DI) is a specialized form of IoC, whereby objects define their dependencies (that is, the other objects they work with) only through
docs.spring.io
'๐ณSpring > ๐ฑSpring Framework' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Spring Framework] IoC ์ปจํ ์ด๋ ๋์ ์๋ฆฌ (0) | 2024.11.14 |
---|---|
[Spring Framework] IoC ์ปจํ ์ด๋ & Bean ๊ฐ๋ ์ดํด ํ๊ธฐ (1) | 2024.10.21 |
[Spring Framework] Spring & Spring Framework ์ฐจ์ด (0) | 2024.10.19 |