๋ฒ์จ ์ถ์์ด ๋ค๊ฐ์ค๊ณ , ์กธ์ ํ ์ง ๋ ๋ฌ์ด ๋ค ๋์ด๊ฐ๋ค. ๋ฉด์ ์ ์กฐ๊ธ์ฉ ๋ค๋ ๋ณด๋ฉด์ ์ฌ๋ฌ ํ์ฌ์ ์ฌ๋ฌด์ค์ ๋ค์ด๊ฐ๋ณด๋, ๊ทธ๊ณณ์์ ์ค์ ๋ก ์ผํ๊ณ ์ถ์ ์ด๋ง์ด ์ ์ ๋ ์ปค์ง๋ค. ๋์์ ํผ์ณ์ง ํ์ค์ ์ง์ ๋ง์ฃผํ ์๋ก, ๋ด๊ฐ ๋ฐฐ์ฐ๊ณ ์ฑ์ฅํด์ผ ํ ๊ฒ๋ค์ด ์ผ๋ง๋ ๋ง์์ง๋ ๋๋๋ค.
ํ์ง๋ง ํฌ๊ธฐํ์ง ์๊ณ ํ ๊ฑธ์์ฉ ๋์๊ฐ๋ค๋ฉด, ์ธ์ ๊ฐ ๋ด๊ฐ ์์ํ ๋ด์ผ์ ๋๋ฌํ ์ ์์ ๊ฒ์ด๋ผ ๋ฏฟ๋๋ค.
์๋ฐ์์๋ ์์ธ๋ฅผ ํฌ๊ฒ 3๊ฐ์ง๋ก ๋๋๋ค.

์์คํ ์์ ๋ณต๊ตฌ๊ฐ ๋ถ๊ฐ๋ฅํ ์ฌ๊ฐํ ๋ฌธ์ ๋ฐ์ ์ ๋ํ๋๋ ์ํ
์ฃผ๋ก ํ๋์จ์ด๋ JVM ์์ฒด์ ๋ฌธ์ ์ ๊ด๋ จ๋๋ฉฐ, ํ๋ก๊ทธ๋จ์ด ์ ์์ ์ผ๋ก ๊ณ์ ์คํ๋๊ธฐ ์ด๋ ต๋ค.
์๋ฌ๋ ๊ฐ๋ฐ์๊ฐ ์ง์ ์ฒ๋ฆฌํ ์ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ผ๋ฉฐ, ๋๋ถ๋ถ ์ ํ๋ฆฌ์ผ์ด์ ๋ ๋ฒจ์์ ์ฒ๋ฆฌํ์ง ์๊ณ ์์คํ ์ฐจ์์์ ์ค๋จ๋๋ค.
ํ๋ก๊ทธ๋จ ์คํ ์ค ๋ฐ์ํ ์ ์๋ ์๊ธฐ์น ์์ ์ํฉ์ผ๋ก, ๊ฐ๋ฐ์๊ฐ ์ ์ ํ ์ฒ๋ฆฌํ๋ฉด ํ๋ก๊ทธ๋จ์ด ๊ณ์ ์คํ๋ ์ ์๋ค.
์์ธ๋ ์ฝ๋ ๋ก์ง์ด๋ ์ธ๋ถ ์
๋ ฅ, ํ๊ฒฝ์ ์ํด ๋ฐ์ํ๋ฉฐ, try-catch ๋ธ๋ก ๋ฑ์ ํตํด ์ฒ๋ฆฌ ๊ฐ๋ฅํ๋ค.
null ์ฐธ์กฐ ๋ณ์ ์ ๊ทผ(NullPointerException) ์์ธ๋ ํฌ๊ฒ ์ฒดํฌ ์์ธ(Checked Exception)์ ์ธ์ฒดํฌ ์์ธ(Unchecked Exception)๋ก ๋๋๋ค.
์ฒดํฌ ์์ธ๋ ์ปดํ์ผ ์ ์ฒ๋ฆฌ ์ฌ๋ถ๋ฅผ ๊ฐ์ ํ๋ฉฐ, ์ธ์ฒดํฌ ์์ธ๋ ๋ฐํ์ ์ ๋ฐ์ํฉ๋๋ค.
๐ค ์ปดํ์ผ ์? ๋ฐํ์ ์?
๐งฉ ์ปดํ์ผ(Compile)
- ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ , ์ฆ ํ๋ก๊ทธ๋จ์ ๋น๋(์ปดํ์ผ) ํ๋ ์๊ฐ
- ์ด๋๋ ๋ฌธ๋ฒ ์ค๋ฅ๋ ํ์ ์ค๋ฅ ๊ฐ์ ๊ฑธ ๋ฏธ๋ฆฌ ๊ฒ์ฌ ๊ฐ๋ฅ
- ์๋ฅผ ๋ค์ด, ์กด์ฌํ์ง ์๋ ๋ฉ์๋๋ฅผ ํธ์ถํ๊ฑฐ๋, ์๋ฃํ์ด ๋ง์ง ์์ผ๋ฉด ์ปดํ์ผ ์์ ์ ์๋ฌ๊ฐ ๋ฐ์
๐ ์ฆ, โ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ ์ ์๊ธฐ๋ ๋ฌธ์ โ
โ๏ธ ๋ฐํ์ ์ (Runtime)- ํ๋ก๊ทธ๋จ์ด ์ค์ ๋ก ์คํ๋๊ณ ์๋ ๋์์ ์๋ฏธ
- ์คํ ์ค์ ์ฌ์ฉ์์ ์ ๋ ฅ, ๋คํธ์ํฌ, ํ์ผ ๋ฑ ์์์น ๋ชปํ ์ํฉ์ผ๋ก ์ค๋ฅ๊ฐ ๋ฐ์ ๊ฐ๋ฅ
- ์๋ฅผ ๋ค์ด, 0์ผ๋ก ๋๋๊ฑฐ๋(null ์ฐธ์กฐ, ํ์ผ ์์ ๋ฑ) ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ฐํ์ ์์ ์ ๋ฌธ์
๐ ์ฆ, โ์ฝ๋๋ฅผ ์คํํ๋ ๋์ค์ ์๊ธฐ๋ ๋ฌธ์ โ
RuntimeException ์ ํ์ ํด๋์ค๊ฐ ์๋๋ฉด์ Exception ํด๋์ค์ ํ์ ํด๋์ค
์ฒดํฌ ์์ธ๋ ๋ฐ๋์ ์๋ฌ ์ฒ๋ฆฌ(try-catch, throw) ํด์ผํ๋ค.
RuntimeException์ ํ์ ํด๋์ค
์๋ฌ ์ฒ๋ฆฌ๋ฅผ ๊ฐ์ ํ์ง ์๋๋ค.
๋ฐํ์์์ ๋ฐ์ํ ์ ์๋ ์์ธ
์ธ์ฒดํฌ ์์ธ๋ ๋๋ถ๋ถ ๊ฐ๋ฐ์์ ๋ก์ง ์ค๋ฅ๋ก ์ธํด ๋ฐ์ํ๋ค.
String s = null;
System.out.println(s.length()); //NullPointerException ๋ฐ์
์ด ๋ฌธ์ ๋ ์ธ๋ถ ์์ธ์ด ์๋ ์ฝ๋ ์์ฑ ์์ ์ ์ถฉ๋ถํ ๋ฐฉ์งํ ์ ์๋ ๋ฌธ์ ์ด๋ฏ๋ก,
์ปดํ์ผ๋ฌ๊ฐ try-catch๋ก ์์ธ ์ฒ๋ฆฌ๋ฅผ ๊ฐ์ ํ์ง ์๋๋ค.
๋ง์ฝ ์ธ์ฒดํฌ ์์ธ๊น์ง ๋ชจ๋ ์ฒ๋ฆฌํ๋๋ก ๊ฐ์ ํ๋ค๋ฉด,
์ฝ๋๊ฐ ๋ถํ์ํ๊ฒ ๊ธธ์ด์ง๊ณ ๊ฐ๋
์ฑ์ด ๋จ์ด์ง๋ค.
try {
String s = null;
System.out.println(s.length());
} catch (NullPointerException e) {
e.printStackTrace();
}
์ด๋ฐ ์์ผ๋ก ๋งค๋ฒ ๊ฐ์ธ๋ ๊ฑด ๋นํจ์จ์ ์ด๊ธฐ ๋๋ฌธ์,
์๋ฐ๋ ๊ฐ๋ฐ์๊ฐ ์ค์ค๋ก ๋ฐฉ์งํ ์ ์๋ ์์ธ์ ๋ํด์๋ ์์จ์ ์ธ ์ฒ๋ฆฌ๋ฅผ ํ์ฉํ๋ค.
| ๊ตฌ๋ถ | ์์ | ๊ธฐ๋ณธ ๋กค๋ฐฑ ์ฌ๋ถ | ์ค๋ช | ์ฒ๋ฆฌ ๋ฐฉ๋ฒ |
|---|---|---|---|---|
| ์ฒดํฌ ์์ธ (Checked Exception) | IOException, SQLException | โ ๋กค๋ฐฑ๋์ง ์์ | ์ปดํ์ผ ์์ ์ ์์ธ ์ฒ๋ฆฌ๊ฐ ๊ฐ์ ๋จ. ์ฃผ๋ก ์ธ๋ถ ์์ธ(ํ์ผ, ๋คํธ์ํฌ ๋ฑ)์ผ๋ก ๋ฐ์ํ๋ฉฐ ๋ณต๊ตฌ ๊ฐ๋ฅ์ฑ์ด ์์. | ๋ช
์์ ์ผ๋ก rollbackFor ์์ฑ ์ง์ ํ์ โ @Transactional(rollbackFor = Exception.class) |
| ์ธ์ฒดํฌ ์์ธ (Unchecked Exception) | NullPointerException, IllegalArgumentException | โ ์๋ ๋กค๋ฐฑ๋จ | ๋ฐํ์ ์์ ์ ๋ฐ์ํ๋ฉฐ, ์ฃผ๋ก ๊ฐ๋ฐ์์ ๋ ผ๋ฆฌ์ ์ค์๋ก ๋ฐ์. ๋ณต๊ตฌ๊ฐ ์ด๋ ต๊ณ ํ๋ก๊ทธ๋จ ์ค๋ฅ๋ก ๊ฐ์ฃผ๋จ. | @Transactional ๊ธฐ๋ณธ ์ค์ ์ผ๋ก ์๋ ๋กค๋ฐฑ ์ฒ๋ฆฌ |
@Transactional์ ๊ธฐ๋ณธ์ ์ผ๋ก RuntimeException(์ธ์ฒดํฌ ์์ธ)์ด๋ Error๊ฐ ๋ฐ์ํ๋ฉด ์๋์ผ๋ก ๋กค๋ฐฑ@Transactional
public void process() throws IOException {
// Checked Exception ๋ฐ์ โ ๊ธฐ๋ณธ์ ์ผ๋ก ๋กค๋ฐฑ๋์ง ์์
throw new IOException("ํ์ผ ์ฝ๊ธฐ ์คํจ");
}
@Transactional
public void execute() {
// Unchecked Exception ๋ฐ์ โ ์๋ ๋กค๋ฐฑ๋จ
throw new NullPointerException("๋ ์ฐธ์กฐ ์ค๋ฅ");
}
@Transactional(rollbackFor = Exception.class)
public void forceRollback() throws IOException {
// Checked Exception์ด์ง๋ง ๋ช
์์ ์ผ๋ก ๋กค๋ฐฑ ์ค์
throw new IOException("๊ฐ์ ๋กค๋ฐฑ");
}
์ฐธ๊ณ
์๊ธฐ์ผ ํ๋โก ํ์ดํ ์์์์!!!