DI, (Dependency Injection)
DI (Dependency Injection, ์์กด์ฑ ์ฃผ์
)
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์์ ์์กด์ฑ ๊ด๋ฆฌ๋ฅผ ์ํ ๋์์ธ ํจํด
๊ฐ์ฒด๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด์ ์์กดํ์ง ์๋๋ก ์ธ๋ถ์์ ์ฃผ์ ๋ฐ๋ ํํ๋ก ์ฌ์ฉํ๋ ๊ฒ
์์กด์ฑ ์ฃผ์ ์ด๋ ์ธ๋ถ์์ ์์กด ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ๋๊ฒจ์ฃผ๋ ๊ฒ์ ์๋ฏธ
์์กด์ฑ์ ์ธ๋ถ์์ ์ฃผ์ ๋ฐ์ ์์กด์ฑ์ ์์ ๊ณ ๊ฐ์ฒด๊ฐ ๊ฒฐํฉ๋๋ฅผ ๋ฎ์ถ๋ค.
์์กด์ฑ์ ์ฃผ์
ํ๋ ์ธ๊ฐ์ง ์ ํ
Constructor Injection โ ํด๋์ค ์์ฑ์๋ฅผ ํตํด ์์กด์ฑ ์ฃผ์
Method(Setter) Injection -> ๊ฐ์ฒด(ํด๋์ค) ์์ฑ ํ ๋ฉ์๋๋ฅผ ํตํด ์์กด์ฑ์ ์ฃผ์
Interface Injection -> ์ข ์์ฑ์ ์ฃผ์ ํ ๋ฉ์๋๋ฅผ ๊ฐ๋ ์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํ์ฌ ์์กด์ฑ์ ๋ฐ์ ํด๋์ค(๊ฐ์ฒด๊ฐ) ๊ตฌํํ๋๋ก ์ฃผ์ ํ๋ ๋ฐฉ์
DI ์ฅ์
์์กด ๊ฐ์ฒด๋ฅผ ๊ฐ์ ๋ผ์ธ ์ ์์ด ์ฌ์ฌ์ฉ์ฑ๊ณผ ํ์ฅ์ฑ ๋์์ง๋ค.
์ธ๋ถ์ ์์กด ๊ฐ์ฒด๋ฅผ Mock ์ผ๋ก ๋์ฒดํ์ฌ ๋จ์ ํ ์คํธ ์์ฑ์ด ์ฌ์์ง๋ค.
๋ค๋ฅธ ๊ฐ์ฒด์ ์์กดํ์ง ์์์ ์ฝ๋๊ฐ ๋ณ๊ฒฝ์ด ๋์ด๋ ๋ค๋ฅธ ๊ฐ์ฒด์ ์ํฅ์ ๋ ์ฃผ๋ฏ๋ก ์ ์ฐํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
์ ์ฐํ ์ฝ๋๋?
๋ณ๊ฒฝ์ด๋ ํ์ฅ์ ๋ํด์ ์ ์ฐํ๊ฒ ๋์ฒํ ์ ์๋ ์ฝ๋๋ฅผ ์๋ฏธํ๋ค.
์ ์ง๋ณด์์ฑ ๐, ํ์ฅ์ฑ ๐
์ ์ฐํ ์ฝ๋๋ฅผ ์์ฑํ๋ ค๋ฉด ์ฝ๋ ๊ฐ ๊ฒฐํฉ๋๊ฐ ๋ฎ์์ผ ํ๋ค.
DI Container
DI๋ฅผ ๊ตฌํํ๊ธฐ ์ํด ๊ฐ์ฒด ์์ฑ, ์์กด์ฑ ์ฃผ์ ๋ฑ์ ์๋์ผ๋ก ์ฒ๋ฆฌํด์ฃผ๋ ์ธ๋ถ ์ญํ
DI Container๋ฅผ ์ผ๋ฐ์ ์ผ๋ก Context, ๋๋ Container๋ผ๊ณ ๋ถ๋ฅธ๋ค.
๊ฐ์ฅ ๋ํ์ ์ธ DI Container๋ Spring Framework
IoC (Inversion of Control, ์ ์ด์ ์ญ์ )
์์กด์ฑ์ ์ ๊ฑฐํ๊ธฐ ์ํ ๊ฐ์ฒด์งํฅ ์ค๊ณ ์์น DI Pattern์ IoC๋ฅผ ๊ตฌํํ๋ ๋ํ์ ์ธ ๋ฐฉ๋ฒ
์ ์ด์ ์ญ์ ์ ๊ฐ๋จํ ์ค๋ช ํ์๋ฉด ํ๋ก๊ทธ๋จ์ ์คํ ํ๋ฆ์ ์ ์ด๊ถ์ ์ธ๋ถ(ํ๋ ์์ํฌ)์๊ฒ ์์ํ๋ ๊ฒ!
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ค๊ณ์ ๊ธฐ๋ณธ ์์นSOLID ์ ๋ค์ฏ ๋ฒ์งธ ์์น Dependency Inversion "๋ฎ์ ์์ค์ ๊ตฌํ์ ์์กดํ์ง ๋ง๊ณ ๋์ ์์ค์ ์ถ์ํ์ ์์กดํด์ผ ํ๋ค๋ ๋ป"
Why do we call it Dependency โInversionโ?
Well, it appears that in traditional software development, the best practice was to build software in a layered architecture, which enabled the construction of increasingly complex systems.
In this architecture, higher-level components depended directly upon lower-level components in order to achieve a complex task.
Last updated