ํ ํ๋ฆฟ ๋ฉ์๋๊ฐ ๋ฌด์์ธ์ง ์์๋ณด๊ธฐ ์ ์ ํ ํ๋ฆฟ ๋ฉ์๋๊ฐ ํ์ํ ์ํฉ์ ๋จผ์ ์์๋ณด์.
๋ ํด๋์ค TestA
์ TestB
๊ฐ ์๋ค.
๋ ํด๋์ค๋ ํ ๊ฐ ๋ฉ์๋(logic
)๋ฅผ ๊ฐ๊ณ ํด๋น ๋ฉ์๋๋ 0.5์ด๊ฐ ์์๋๋ ์ด๋ค ์์
์ ์ํํ๋ค.
logic
๋ฉ์๋์ ์คํ์๊ฐ์ ์ธก์ ํด์ผ ํ๋ ์๊ตฌ์ฌํญ์ด ์์ด์ ์๋์ ๊ฐ์ด ๊ตฌํํ๋ค.
@Slf4j
public class WithoutTemplateMethodTest {
public class TestA {
public void logic() throws InterruptedException {
log.info("start");
// ์คํ์๊ฐ ์ธก์ ์์
long start = System.currentTimeMillis();
// ๋น์ฆ๋์ค ๋ก์ง
log.info("TestA logic1 processing ...");
Thread.sleep(500);
// ์คํ์๊ฐ ๋ก๊ทธ์ถ๋ ฅ
long end = System.currentTimeMillis();
long spendTime = end - start;
log.info("end, time = {}", spendTime);
}
}
public class TestB {
public void logic() throws InterruptedException {
// ์คํ์๊ฐ ์ธก์ ์์
log.info("start");
long start = System.currentTimeMillis();
// ๋น์ฆ๋์ค ๋ก์ง
log.info("TestB logic processing ...");
Thread.sleep(500);
// ์คํ์๊ฐ ๋ก๊ทธ์ถ๋ ฅ
long end = System.currentTimeMillis();
long spendTime = end - start;
log.info("end, time = {}", spendTime);
}
}
}
๋ ํด๋์ค์ logic
๋ฉ์๋์์ ๋น์ฆ๋์ค ๋ก์ง์ ์ํํ๋ ์ฝ๋๋ ๋จ ๋ ์ค์ด๋ค.
๋น์ฆ๋์ค ๋ก์ง๊ณผ๋ ๊ด๊ณ์๋ ์คํ์๊ฐ์ ์ธก์ ํ๋ ์ฝ๋์ ์์ด ํจ์ฌ ๋ง๋ค. ๋ํ ์คํ์๊ฐ ์ธก์ ๋ถ๋ถ์ ์๋ฒฝํ๊ฒ ์ค๋ณต๋๋ค. ์ด๋ ๊ฒ ๋น์ฆ๋์ค ๋ก์ง๊ณผ ๊ด๋ จ์๋ ๊ณตํต์ ๋ถ๊ฐ๊ธฐ๋ฅ ๋๋ฌธ์ ์ฝ๋๊ฐ ๊ธธ์ด์ง๊ณ ์ค๋ณต๋๋ค.
์ด๋ ๊ฒ ๋น์ฆ๋์ค ๋ก์ง๊ณผ ๊ด๊ณ์๋ ๋ถ๊ฐ๊ธฐ๋ฅ (๋ก๊น , ์คํ์๊ฐ ์ธก์ ๋ฑ ..) ์ ๋ถ๋ฆฌํด๋ด๋ ์๋ฃจ์ ์ผ๋ก ํ ํ๋ฆฟ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
ํ
ํ๋ฆฟ ๋ฉ์๋๋ ์ด๋ฆ ๊ทธ๋๋ก ์ด๋ค ํ
ํ๋ฆฟ์ ์ ๊ณตํ๋ ๊ฒ์ด๋ค.
์ฌ๊ธฐ์ ํ
ํ๋ฆฟ์๋ ๋ณํ์ง ์๋ ๋ถ๊ฐ๊ธฐ๋ฅ์ด ๋ด๊ฒจ์ ธ ์๊ณ ํ
ํ๋ฆฟ ์ฝ๋์ ์ํ๋ ๊ณณ์์ ๋น์ฆ๋์ค ๋ก์ง์ ์ํํ๋ ๋ฉ์๋๋ฅผ ํธ์ถ์ํค๋ฉด ๋๋ค.
์์์ ์ด์ฉํด์ ํ
ํ๋ฆฟ ๋ฉ์๋ ํจํด์ ์ ์ฉํ ๊ฒ์ด๋ค.
ํ
ํ๋ฆฟ ์ญํ ์ ํ๋ ์ถ์ํด๋์ค ํ๋๋ฅผ ์ ์ํ๊ณ ์์ ํด๋์ค์์ ๋น์ฆ๋์ค ๋ก์ง์ ์ํด ์ค๋ฒ๋ผ์ด๋ฉ ๋ ์ถ์๋ฉ์๋ ํ๋๋ฅผ ์ ๊ณตํ๋ค.
๊ณตํต์ ๋ถ๊ฐ๊ธฐ๋ฅ์ ํด๋นํ๋ execute
๋ถ๋ถ์์ ์์ํด๋์ค์์ ์ค๋ฒ๋ผ์ด๋ฉ ํ ๋น์ฆ๋์ค ๋ก์ง์ ๋ด๋นํ๋ call
๋ฉ์๋๋ฅผ ํธ์ถํ๋๋ก ๊ตฌํํ๋ค.
@Slf4j
public abstract class AbstractTemplate {
public void execute() {
log.info("start");
long start = System.currentTimeMillis();
call();
long end = System.currentTimeMillis();
long spendTime = end - start;
log.info("end, time = {}", spendTime);
}
protected abstract void call();
}
์ด์ ์คํ์๊ฐ์ ์ธก์ ํ๊ณ ์ ํ๋ ๋ฉ์๋๋ฅผ ๊ฐ์ง ํด๋์ค๋ AbstractTemplate
๋ฅผ ์์ํ๊ณ call
๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํ๋ฉด ๋๋ค.
@Slf4j
public class SubClass1 extends AbstractTemplate {
@Override
protected void call() {
log.info("logic1 processing ...");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Slf4j
public class SubClass2 extends AbstractTemplate{
@Override
protected void call() {
log.info("logic2 processing ...");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
์ ์ํ ๋ ํด๋์ค์ ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ณ ํ ์คํธ๋ฅผ ์ํํ๋ค.
public class TemplateMethodTest {
@Test
void test() {
AbstractTemplate subClass1 = new SubClass1();
subClass1.execute();
SubClass2 subClass2 = new SubClass2();
subClass2.execute();
}
}
๋ถ๋ชจํ์ ์ผ๋ก ์ธ์คํด์ค๋ฅผ ์์ฑ(์ ์ผ์คํ )ํ๊ณ ์ค๋ฒ๋ผ์ด๋ฉ ๋ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด ์ค๋ฒ๋ผ์ด๋ฉ ๋ ์์ ํด๋์ค์ ๋ฉ์๋๊ฐ ์ํ๋๋ค.
ํ
์คํธ ๊ฒฐ๊ณผ ํ
ํ๋ฆฟ ๋ฉ์๋๋ฅผ ์ ์ฉํ์ง ์์์ ๋์ ์๋ฒฝํ๊ฒ ๊ฐ์ ๊ฒ์ ํ์ธํ ์ ์๋ค.
์ธํ๋ฐ - ์คํ๋ง ํต์ฌ ์๋ฆฌ ๊ณ ๊ธํธ (๊น์ํ ๋)