์์กด์ฑ์ด ์๊ธฐ๋ ๊ฒฝ์ฐ
ํ ํด๋์ค์์ ๋ค๋ฅธ ํด๋์ค์ ์ ๊ทผํ ๋ ์๋์ ๊ฐ์ ์ฝ๋๋ก ์ ๊ทผ์ ํฉ๋๋ค. ์ด๋ ํด๋์คB๋ ํด๋์คA์ ์์กดํ๊ฒ ๋ฉ๋๋ค.
์์กด์ฑ์ ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด ์ฌ์ด์ ์์กด ๊ด๊ณ๊ฐ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
class A {
var name: String = "A"
}
class B {
// ํด๋์คB๋ ํด๋์คA์ ์์กดํ๋ค. (์์กด์ฑ์ด ์๊ธด๋ค.)
var a: A = A()
func printName() {
print(a.name)
}
}
let b: B = B()
b.printName() // "A"
์์กด์ฑ ์ฃผ์
์ด๋ ๊ฒ ์์กด์ฑ์ด ์๊ธฐ๋ ์ฝ๋๋ค์ ์ข์ง ์์ต๋๋ค. ์์กดํ๊ณ ์๋ ํด๋์ค ๋ด์ ์ฝ๋๊ฐ ๋ฐ๋๋ฉด ํด๋น ํด๋์ค๋ฅผ ์์กดํ๊ณ ์๋ ๋ค๋ฅธ ํด๋์ค๋ค๋ ์์ ํด ์ฃผ์ด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ณ ๊ฐ์ ํ๊ธฐ ์ํด ํ์ฅ์ฑ ์๋ ์ฝ๋๋ก ๋ฐ๊พธ๋ ๊ฒ์ด ์์กด์ฑ ์ฃผ์ ์ ๋๋ค.
์์กด์ฑ ์ฃผ์ ์ ๊ธฐ์กด์ ์์กด์ฑ์ ๊ฐ์ ํ์ฌ ์์กด์ฑ์ ์ธ๋ถ์์ ์ฃผ์ ํ ์ ์๋ ๋ฐฉ์์ผ๋ก ๋ฐ๊พธ๋ ๊ฐ๋ ์ ๋๋ค.
๋ค์ ๋งํด, ํ๋กํ ์ฝ(Protocol)์ ์ฌ์ฉํด์ ์์กด์ฑ์ ๋ถ๋ฆฌ์ํด์ผ๋ก์ ์์กด ๊ด๊ณ๋ฅผ ์ญ์ (Inversion of Control)์ํจ ๋ค์, ๊ทธ ํ๋กํ ์ฝ์ ํตํด์ ์ธ๋ถ์์ ๊ฐ์ฒด๋ ๋ฐ์ดํฐ๋ฅผ ์ฃผ์ ํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
protocol Module {
var name: String { get set }
}
class A: Module {
var name: String = "A"
}
class B: Module {
var name: String = "B"
}
class C {
// ํด๋์คA๋ฅผ ์ง์ ์ ์ธํ๋ ๊ฒ์ด ์๋ ํ๋กํ ์ฝ ํ์
์ผ๋ก ์ ์ธํ๊ฒ ๋๋ฉด,
// ํด๋น ํ๋กํ ์ฝ์ ์ฑํํ๊ณ ์๋ ๋ชจ๋ ํ์
๋ค์ ์ฃผ์
๊ฐ๋ฅํ๊ฒ ๋ง๋ ๋ค.
var a: Module
init(a: Module) {
self.a = a
}
func printName() {
print(a.name)
}
}
// ๊ฐ์ ๋ ์์กด์ฑ ์ฃผ์
์ ํตํด ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ
let moduledA = C(a: A())
moduledA.printName() // "A"
์ฃผ์ (Injection)
์์ฑ์์ ํตํด์ ์ ์ฅ ์์ฑ์ ์ธ๋ถ์์ ์ฃผ์ ํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
class A {
var name: String
init(name: String) {
self.name = name
}
}
// ์ธ๋ถ์์ ๊ฐ์ ์ฃผ์
(ํ ๋น, ์ด๊ธฐํ)ํด์ ์ธ์คํด์ค ์์ฑ
let a = A(name: "ํ๊ธธ๋")
์์กด์ฑ ์ฃผ์ ์ ์ฅ์
1. ์ฌํ์ฉ์ฑ/ํ์ฅ์ฑ
์์กด์ฑ ์ฃผ์ ์ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด ๊ฐ์ ์์กด์ฑ์ ์ค์ฌ์ฃผ๋ ์์ ์ ํ๊ธฐ ๋๋ฌธ์ ์ฝ๋์ ์ฌํ์ฉ์ฑ๊ณผ ํ์ฅ์ฑ์ด ๋์์ง๋๋ค.
์๋ฅผ ๋ค์ด, Delegate ํจํด๊ฐ์ ๊ฒ๋ ํต์ฌ์ด ํ๋กํ ์ฝ์ด๊ธฐ ๋๋ฌธ์ ํ๋กํ ์ฝ์ ๊ฐ์ง๊ณ ๋ง๋ฆ์ ํตํด์ ํ์ฅ์ฑ์ด ๋์์ง๋๋ค.
2. ์ ์ฐํ ์ฝ๋/ํ๋ก๊ทธ๋จ ์์ฑ ๊ฐ๋ฅ
๋ํ ๊ฐ์ฒด ๊ฐ์ ๊ฒฐํฉ๋๋ ๋ฎ์์ง๊ธฐ ๋๋ฌธ์ ์ ์ฐํ ์ฝ๋/ํ๋ก๊ทธ๋จ์ ์์ฑํ ์๊ฐ ์์ต๋๋ค.
3. ์ฌ์ด ์ ์ง ๋ณด์
์์ ์ฅ์ ๋ค์ ํตํด ์ ์ง ๋ณด์๋ ์ํํ๊ฒ ํ ์ ์๊ฒ ๋ฉ๋๋ค.
4. ํ ์คํธ ๊ฐ๋ฅ
ํ ์คํธ ๊ฐ๋ฅํ ์ฝ๋๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. (Unit Test)
5. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ(OOP)์ 5๋ ์์น(SOLID)์ ๋ฐ๋ฆ
SOLID ์ค ํ๋์ธ ์์กด ๊ด๊ณ ์ญ์ ์์น(DIP: Dependency Inversion Principle)์ ๋ฐ๋ฅผ ์ ์๊ฒ ๋ฉ๋๋ค.