โ๏ธ Java Design-Pattern โ ค - Factory Method
โ๏ธ Java Design-Pattern โ
ค - Factory Method
๐
ใJAVA ์ธ์ด๋ก ๋ฐฐ์ฐ๋ ๋์์ธ ํจํด : ์ฝ๊ฒ ๋ฐฐ์ฐ๋ GoF์ 23๊ฐ์ง ๋์์ธ ํจํดใ
๋ฅผ ์ฝ๊ณ ์ ๋ฆฌํ ๊ธ์ ๋๋ค.
Factory Method
ํจํด์ด๋?
- ์ธ์คํด์ค ์์ฑ ๋ฐฉ๋ฒ์ ์์ ํด๋์ค์์ ๊ฒฐ์ ํ๋, ์ค์ ์ธ์คํด์ค๋ ํ์ ํด๋์ค์์ ์์ฑํ๋ค.
- ์ฆ ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ ๊ณต์ฅ์ย
Template Method
ย ํจํด์ผ๋ก ๊ตฌ์ฑํ ๊ฒ์ด๋ค.
์์ ํ๋ก๊ทธ๋จ
framework
ย ํจํค์ง์ ํฌํจ๋ยProduct
,ยFactory
ย ํด๋์ค๋ ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ ๋ผ๋ ์ญํ ์ ํ๋ค.idcard
ย ํจํค์ง์ ํฌํจ๋ยIDCard
,ยIDCardFactory
ย ํด๋์ค๋ ๊ตฌ์ฒด์ ์ธ ๋ด์ฉ์ ๊ตฌํํ๋ ์ญํ ์ ํ๋ค.Main
ย ํด๋์ค๋ ๋์ ํ ์คํธ๋ฅผ ์ํ ํด๋์ค์ด๋ค.
Product
ย ํด๋์ค
1
2
3
4
5
package framework;
public abstract class Product {
public abstract void use();
}
- ์ด ํ๋ ์์ํฌ์์๋ ๋ฌด์์ด๋ ย
use
ํ ์ ์๋ ๊ฒ์ ์ ํ์ผ๋ก ๊ท์ ํ๋ค.
Factory
ย ํด๋์ค
1
2
3
4
5
6
7
8
9
10
11
12
package framework;
public abstract class Factory {
public final Product create(String owner) {
Product p = createProduct(owner);
registerProduct(p);
return p;
}
protected abstract Product createProduct(String owner);
protected abstract void registerProduct(String product);
}
Template Method
ย ํจํด์ ์ฌ์ฉํ์ฌยcreate
ย ๋ฉ์๋๋ฅผ ํตํดยProduct
ย ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ค.ยcreate
ย ๋ฉ์๋ ๋ดยcreateProduct
,ยregisterProduct
ย ๋ฉ์๋๋ ์ถ์ ๋ฉ์๋๋ก ์ ์ธ๋์ด ์๋ค.- ์ด์ฒ๋ผย
Factory Method
ย ํจํด์ ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋ยTemplate Method
ย ํจํด์ ์ฌ์ฉํ๋ค.
IDCard
ย ํด๋์ค
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package idcard;
import framework.Product;
public class IDCard extends Product {
private String owner;
IDCard(String owner) {
System.out.println(owner + "์ ์นด๋๋ฅผ ๋ง๋ญ๋๋ค.");
this.owner = owner;
}
@Override
public void use() {
System.out.println(this + "์ ์ฌ์ฉํฉ๋๋ค.");
}
@Override
public String toString() {
return "[IDCard:" + owner + "]"
}
public String getOwner() {
return owner;
}
}
Product
ย ํด๋์ค์ ํ์ ํด๋์ค๋ก์ ์ ์๋ ํด๋์ค์ด๋ค.
IDCardFactory
ย ํด๋์ค
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package idcard;
import framework.Factory;
import framework.Product;
import java.util.ArrayList;
import java.util.List;
public class IDCardFactory extends Factory {
private List<String> owners = new ArrayList<>();
@Override
protected Product createProduct(String owner) {
return new IDCard(owner);
}
@Override
protected void registerProduct(Product product) {
if (product instanceof IDCard) {
IDCard card = (IDCard) product;
owners.add(card.getOwner());
}
}
public List<String> getOwners() {
return owners;
}
}
Main
ย ํด๋์ค
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import framework.Factory;
import framework.Product;
import idcard.IDCardFactory;
public class Main {
public static void main(String args[]) {
Factory factory = new IDCardFactory();
Product card1 = factory.create("๊น์๋ฌด๊ฐ");
Product card2 = factory.create("๋ฐ์๋ฌด๊ฐ");
Product card3 = factory.create("์ต์๋ฌด๊ฐ");
card1.use();
card2.use();
card3.use();
}
}
- ์ค์ ๋กย
IDCardFactory
ย ์ธ์คํด์ค๋ฅผ ๋ง๋ค์ด ์ฌ์ฉํ๋ ๋์ ํ ์คํธ๋ฅผ ์ํ ํด๋์ค์ด๋ค.
Factory Method
ย ํจํด์ ๋ฑ์ฅ์ธ๋ฌผ
Product
ย ํด๋์ค
- ํ๋ ์์ํฌ์ ํด๋น๋๋ฉฐ, ์ ํ์ญํ ๋ก, ์ด ํจํด์ผ๋ก ์์ฑ๋๋ ์ธ์คํด์ค๊ฐ ๊ฐ์ ธ์ผ ํ ์ธํฐํ์ด์คย
API
๋ฅผ ๊ฒฐ์ ํ๋ ์ถ์ ํด๋์ค์ด๋ค.
Factory
ย ํด๋์ค
- ํ๋ ์์ํฌ์ ํด๋น๋๋ฉฐ, ์ ํ ์ญํ ์ ์์ฑํ๋ ์์ฑ์ย
Creator
ย ์ญํ ์ ํ๋ค. - ์ค์ ๋ก ์์ฑํ ย
ConcreteProduct
ย ์ญํ ์๋ ์๋ ๋ฐ๊ฐ ์๋ค. - ์์ ํ๋ก๊ทธ๋จ์์๋ย
new
ย ๋์ ยcreateProduct
ย ๋ฉ์๋๋ฅผ ํตํด ์ธ์คํด์ค๋ฅผ ์์ฑํ๋๋ฐ, ์ด๋ฅผ ํตํด ๊ตฌ์ฒด์ ์ธ ํด๋์ค ๋ช ์ ์์กดํ์ง ์์ ์ ์๊ฒ ๋๋ค.
IDCard
ย ํด๋์ค
- ๊ตฌ์ฒด์ ์ธ ์ ํย
ConcreteProduct
ย ์ญํ ์ ๋งก์ ์ ํ ์ญํ ์ ๊ตฌ์ฒด์ ์ธ ๊ตฌํ์ ์ํํ๋ค.
IDCardFactory
ย ํด๋์ค
- ๊ตฌ์ฒด์ ์ธ ์์ฑ์ย
ConcreteCreator
ย ์ญํ ์ ๋งก์ ์์ฑ์ ์ญํ ์ ๊ตฌ์ฒด์ ์ธ ๊ตฌํ์ ์ํํ๋ค.
์ฑ ์์ ์ ์ํ๋ ํํธ
ํ๋ ์์ํฌ์ ๊ตฌ์ฒด์ ์ธ ๋ด์ฉ
- ์ฌ๊ธฐ์ ๊ฐ์ ํ๋ ์ ์ํฌ๋ฅผ ์ฌ์ฉํ์ฌย
IDCard
๊ฐ ์๋ยTV
๋ฅผ ๋ง๋ ๋ค๊ณ ๊ฐ์ ํด๋ณด์. - ์ด ๊ฒฝ์ฐย
framework
ย ํจํค์ง๋ฅผยimport
ํ๋ ๋ณ๊ฐ์ยtelevision
ย ํจํค์ง๋ฅผ ๋ง๋ค๊ฒ ๋๋ค. - ๊ทธ๋ฐ๋ฐ,ย
framework
ย ํจํค์ง ๋ด ํด๋์ค๋ค์ ์์ ํ ํ์๊ฐ ์๋ค. - ์๋ํ๋ฉดย
framework
ย ํจํค์ง ๋ด์์๋ยidcard
ย ํจํค์ง๋ฅผยimport
ย ํ ์ ์ด ์๋ค. - ์ฆ ํด๋น ํจํด์์ ํ๋ ์์ํฌ๋ ๊ตฌ์ฒด์ ์ธ ๋ด์ฉ์ ์์กดํ์ง ์๋๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
์ธ์คํด์ค ์์ฑ: ๋ฉ์๋ ๊ตฌํ ๋ฐฉ๋ฒ
- ์ธ์คํด์ค ์์ฑ ๋ฉ์๋๋ฅผ ๊ธฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ค์ ๋ ๊ฐ์ง๋ก ์๊ฐํ ์ ์๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
/* 1. ์ถ์ ๋ฉ์๋๋ก ๊ธฐ์ */
abstract class Factory {
public abstract Product createProduct(String name);
// ...
}
/* 2. ๋ํดํธ ๊ตฌํ์ ์ค๋น */
class Factory {
public Product createProduct(String name) {
return new Product(name);
}
}
- ์ถ์ ๋ฉ์๋๋ก ๊ธฐ์ ํ๋ ๊ฒฝ์ฐ ์์ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ ๋ฐฉ๋ฒ์ผ๋ก, ์ถ์ ๋ฉ์๋๋ก ๊ธฐ์ ํ ๊ฒฝ์ฐ ๊ตฌํ๋์ด ์์ง ์๋๋ผ๋ ์ปดํ์ผํ ๋ ๊ฒ์ถ๋๋ค๋ ์ฅ์ ์ด ์๋ค.
- ๋ํดํธ ๊ตฌํ์ ์ค๋นํ๋ ๊ฒฝ์ฐ ํ์ ํด๋์ค์์ ๊ตฌํํ์ง ์๋๋ผ๋ ๋ํดํธ ๊ตฌํ์ด ์ฌ์ฉ๋๋ค๋ ์ฅ์ ์ด ์๋ค.
- ๋ค๋ง,ย
Product
ย ํด๋์ค์ ๋ํด ์ง์ ยnew
๋ฅผ ์คํํ์ฌ ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ฏ๋กยProduct
ย ํด๋์ค๋ฅผ ์ถ์ ํด๋์ค๋ก ๋ ์ ์๋ค.
ํจํด ์ด์ฉ๊ณผ ๊ฐ๋ฐ์ ๊ฐ์ ์์ฌ์ํต
- ํ๋์ ํด๋์ค๋ง ์ฝ์ด์๋ ๋์์ ์ ์ดํดํ ์ ์๋ค.
- ์์ ํด๋์ค์์ ๋์์ ๋ผ๋๋ฅผ ์ดํดํ ํ ๊ฑฐ๊ธฐ์์ ์ฌ์ฉ๋๋ ์ถ์ ๋ฉ์๋๊ฐ ๋ฌด์์ธ์ง ํ์ธํ๊ณ , ๋ค์ ๊ทธ ์ถ์ ๋ฉ์๋๋ฅผ ์ค์ ๋ก ๊ตฌํํ๋ ํด๋์ค์ ์์ค ์ฝ๋๋ฅผ ์ดํด๋ณด์์ผ ํ๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ๋์์ธ ํจํด์ ์ฌ์ฉํด ์ด๋ค ํด๋์ค ๊ตฐ์ ์ค๊ณํ ๊ฒฝ์ฐ, ์ค๊ณ์๊ฐ ๋ณด์์์๊ฒ ์๋ํ ๋์์ธ ํจํด์ด ๋ฌด์์ธ์ง ์ ์ ๋ฌํ ํ์๊ฐ ์๋ค.
- ๊ทธ๋ ์ง ์์ผ๋ฉด ์ค๊ณ์์ ์๋์์ ๋ฒ์ด๋ ์์ ์ด ๊ฐํด์ง ์ ์๋ค.
- ์ฃผ์์ด๋ ๊ฐ๋ฐ ๋ฌธ์์ ์ค์ ๋ก ์ฌ์ฉ๋๋ ๋์์ธ ํจํด์ ๋ช ์นญ๊ณผ ์๋๋ฅผ ๊ธฐ์ ํ์ฌ ๋๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด๋ค.
static Factory Method
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* 1. java.security.SecureRandom */
SecureRandom random = SecureRandom.getInstance("NativePRNG");
/* 2. java.util.List */
List<String> list = List.of("Alice", "Bob");
/* 3. java.util.Arrays */
String[] arr = {"Alice", "Bob"};
List<String> list = Arrays.asList(arr);
/* 4. java.lang.String */
String string = String.valueOf('A');
/* 5. java.time.Instant */
Instant instant = Instant.now();
- ์ธ์คํด์ค ์์ฑ์ ์ํย
static
ย ๋ฉ์๋ ์ ๋ฐ์ยFactory Method
๋ผ๊ณ ๋ถ๋ฅด๋ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. - ์ด๊ฒ์ย
GoF
์ยFactory Method
ย ํจํด๊ณผ๋ ๋ค๋ฅด์ง๋งยJava
์์ ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋ ์์ฃผ ์ฌ์ฉ๋๋ ๊ธฐ๋ฒ์ด๋ค. Java API
ย ๋ํผ๋ฐ์ค์์๋ ์ธ์คํด์ค ์์ฑ์ ์ํ ํด๋์ค ๋ฉ์๋๋ฅผยstatic Factory Method
๋ก ํํํ๊ธฐ๋ ํ๋ฏ๋กยJava API
ย ๋ ํผ๋ฐ์ค๋ฅผ ์ฝ์ ๋๋ ์ฐธ์กฐํ๋ ํด๋์ค์ยstatic Factory Method
๊ฐ ์ ๊ณต๋๋์ง ์ฃผ๋ชฉํด์ผ ํ๋ค.create
,ยnewInstance
,ยgetInstance
ย ๋ฑ์ ์ด๋ฆ์ด ์์ฃผ ์ฌ์ฉ๋์ง๋ง, ๊ทธ ๋ฐ์ ์ด๋ฆ์ด ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ๋ ์๋ค.
This post is licensed under CC BY 4.0 by the author.