SpringFramework๋?
- Spring Framework ๋ ์๋ฐ๋ก Enterprise Application ์ ๋ง๋ค ๋ ํฌ๊ด์ ์ผ๋ก ์ฌ์ฉํ๋ Programming ๋ฐ Configuration Model ์ ์ ๊ณตํด ์ฃผ๋ Framework ๋ก Application ์์ค์ ์ธํ๋ผ ์คํธ๋ญ์ณ๋ฅผ ์ ๊ณต.
- ์ฆ ๊ฐ๋ฐ์๊ฐ ๋ณต์กํ๊ณ ์ค์ํ๊ธฐ ์ฌ์ด Low Level ( ์ฝ๊ฒ ๋งํ๋ฉด setting )์ ์ ๊ฒฝ์ฐ์ง ์๊ณ Business Logic๊ฐ๋ฐ์ ์ ๋ ํ ์ ์๋๋ก ํด์ค๋ค
Spring Container
- ์คํ๋ง ์ปจํ ์ด๋๋ ์คํ๋ง์์ ์๋ฐ ๊ฐ์ฒด๋ค์ ๊ด๋ฆฌํ๋ ๊ณต๊ฐ์ ๋งํจ.
- ์๋ฐ ๊ฐ์ฒด๋ฅผ ์คํ๋ง์์ ๋น(Bean)์ด๋ผ๊ณ ํ๋๋ฐ, ์คํ๋ง ์ปจํ ์ด๋์์๋ ์ด ๋น(Bean)์ ์์ฑ๋ถํฐ ์๋ฉธ๊น์ง๋ฅผ ๊ฐ๋ฐ์ ๋์ ๊ด๋ฆฌํด์ฃผ๋ ๊ณณ์ด๋ผ๊ณ ํ ์ ์์
Spring ์ผ๊ฐํ
Enterprise Application ๊ฐ๋ฐ ์ ๋ณต์กํจ์ ํด๊ฒฐํ๋ Spring์ ํต์ฌ.
Enterprise Application์ด๋?
๊ฐ์ธ ์ฌ์ฉ์๊ฐ ์๋ ์กฐ์ง์ ์๊ตฌ ์ฌํญ์ ์ถฉ์กฑํ๋๋ก ์ค๊ณ๋ ๋๊ท๋ชจ ์ํํธ์จ์ด ์๋ฃจ์ (chatgpt)
Java SE(standard edition) : ๋ก์ปฌ์์ ๋์๊ฐ๋ ์ดํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค ๋ ์ฌ์ฉ
Java EE : ์๋ฒ๋ฅผ ์ฌ์ฉํ๋ ์ดํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค ๋ ์ฌ์ฉ (๊ท๋ชจ๊ฐ ์ปค์ง๊ฑฐ๋ผ๊ณ ์ฝ๊ฒ ์๊ฐํ๋ฉด ๋จ)
1. POJO (Plain Old Java Object)
- ํน์ ํ๊ฒฝ์ด๋ ๊ธฐ์ ์ ์ข ์์ ์ด์ง ์์ ๊ฐ์ฒด์งํฅ ์๋ฆฌ์ ์ถฉ์คํ ์๋ฐ๊ฐ์ฒด
- ํ ์คํธํ๊ธฐ ์ฉ์ดํ๋ฉฐ, ๊ฐ์ฒด์งํฅ ์ค๊ณ๋ฅผ ์์ ๋กญ๊ฒ ์ ์ฉํ ์ ์๋ค.
2. PSA(Portable Service Abstraction)
- ํ๊ฒฝ๊ณผ ์ธ๋ถ๊ธฐ์ ์ ๋ณ๊ฒฝ๊ณผ ๊ด๊ณ์์ด ์ผ๊ด๋ ๋ฐฉ์์ผ๋ก ๊ธฐ์ ์ ์ ๊ทผํ ์ ์๊ฒ ํด์ฃผ๋ ์ค๊ณ ์์น
- ํธ๋์ญ์ ์ถ์ํ, OXM์ถ์ํ, ๋ฐ์ดํฐ ์ก์ธ์ค์ Exception ๋ณํ๊ธฐ๋ฅ..๋ฑ ๊ธฐ์ ์ ์ธ ๋ณต์กํจ์ ์ถ์ํ๋ฅผ ํตํด Low Level์ ๊ธฐ์ ๊ตฌํ ๋ถ๋ถ๊ณผ ๊ธฐ์ ์ ์ฌ์ฉํ๋ ์ธํฐํ์ด์ค๋ก ๋ถ๋ฆฌ.
- ์๋ฅผ ๋ค์ด ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ด๊ณ์์ด ๋์ผํ๊ฒ ์ ์ฉํ ์ ์๋ ํธ๋์ญ์ ์ฒ๋ฆฌ๋ฐฉ์.
3. IoC/DI (Dependency Injection)
- DI๋ ์ ์ฐํ๊ฒ ํ์ฅ ๊ฐ๋ฅํ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ๋๊ณ ๊ฐ์ฒด ๊ฐ์ ์์กด๊ด๊ณ๋ ์ธ๋ถ์์ ๋ค์ด๋๋ฏนํ๊ฒ ์ค์ .
- ํ์ํ ๋๋ง๋ค ๋ง๋๋๊ฒ ์๋๋ผ, ๋ค ๋ง๋ค์ด ๋๊ณ DIํ๋ ๊ฒ
4. AOP(Aspect Oriented Programming)
- ๊ด์ฌ์ฌ์ ๋ถ๋ฆฌ๋ฅผ ํตํด์ ์ํํธ์จ์ด์ ๋ชจ๋์ฑ์ ํฅ์
- ๊ณตํต ๋ชจ๋์ ์ฌ๋ฌ ์ฝ๋์ ์ฝ๊ฒ ์ ์ฉ๊ฐ๋ฅ.
SpringFramework์ ํน์ง
- ๊ฒฝ๋์ปจํ
์ด๋
- ์คํ๋ง์ ์๋ฐ๊ฐ์ฒด๋ฅผ ๋ด๊ณ ์๋ ์ปจํ ์ด๋์ด๋ค.
- ์คํ๋ง ์ปจํ ์ด๋๋ ์๋ฐ ๊ฐ์ฒด์ ์์ฑ๊ณผ ์๋ฉธ๊ณผ ๊ฐ์ ๋ผ์ดํ์ฌ์ดํด์ ๊ด๋ฆฌ
- ์ธ์ ๋ ์คํ๋ง ์ปจํ ์ด๋๋ก ๋ถํฐ ํ์ํ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ ์ฌ์ฉํ ์ ์๋ค.
- DI(Dependency Injection)
- ์คํ๋ง์ ์ค์ ํ์ผ์ด๋, ์ด๋ ธํ ์ด์ ์ ํตํด์ ๊ฐ์ฒด๊ฐ์ ์์กด ๊ด๊ณ๋ฅผ ์ค์ ํ ์ ์๋ค
- ๊ธฐ์กด์๋ Singleton ํจํด์ผ๋ก ํ์ํ ๋ ๋ง๋ค์ด์ ์ฌ์ฉ
- DI๋ฅผ ์ด์ฉํด์ ์ฒ์๋ถํฐ ํ์ํ ๊ฒ๋ค์ ์ฃผ์
- DI์ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ : Setter Injection, Constructor Injection, Method Injection
- POJO(Plain Old Java Object)
- ์คํ๋ง ์ปจํ ์ด๋์ ์ ์ฅ๋๋ ์๋ฐ๊ฐ์ฒด๋ ํน์ ํ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ฑฐ๋, ์์ ์์ด๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
- ์ผ๋ฐ์ ์ธ ์๋ฐ ๊ฐ์ฒด๋ฅผ ์นญํ๊ธฐ ์ํ ๋ณ์นญ ๊ฐ๋
- IoC(Inversion Of Control - ์ ์ด์ ์ญ์ )
- ๊ฐ์ฒด์งํฅ ์ธ์ด์์ Object๊ฐ์ ์ฐ๊ฒฐ ๊ด๊ณ๋ฅผ ๋ฐํ์์ ๊ฒฐ์
- ๊ฐ์ฒด ๊ฐ์ ๊ด๊ณ๊ฐ ๋์จํ๊ฒ ์ฐ๊ฒฐ๋จ
- ์ ์ด์ ์ญ์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ : DL (Dependency Lookup)๊ณผ DI(Dependency Injection)
DI์ IoC Container์ ๋ํด์ ์ข ๋ ์์ธํ
DI(Dependency Injection) (=๋ถํ์กฐ๋ฆฝ)
ํ๋ก๊ทธ๋จ์ ๊ฐ์ฒด์งํฅ์ผ๋ก ๋ง๋ค๊ฒ ๋ ๊ฒฝ์ฐ, ๊ฐ์ฒด๋ค์ ์กฐ๋ฆฝ๊ด๊ณ๋ก ๋ง๋ค์ด์ง๊ฒ ๋๋ค.
A๋ผ๋ ํด๋์ค๊ฐ B๋ผ๋ ํด๋์ค๋ฅผ ๊ฐ์ฒดํ ํด์ ์ฌ์ฉํ๊ณ ์๋ค๊ณ ํ ๋ ๋๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
1. ์ผ์ฒดํ
class A{
private B b;
public A(){
b = new B(); //A๊ฐ B๋ฅผ ์ง์ ์์ฑ
}
}
A๊ฐ ์์ฑ๋ ๋ B์ ๊ฐ์ฒด๋ฅผ ์์ฑํด์ ๊ฐ์ง๋ค.
์ด ๊ฒฝ์ฐ A๊ฐ B๋ฅผ ์ผ์ฒดํ์ผ๋ก ๊ฐ์ก๋ค๊ณ ํด์ Composition(์ผ์ฒดํ) has a ๊ด๊ณ๋ผ๊ณ ํ๋ค
์ด๋ B๋ฅผ A์ ๋ถํ์ด๋ผ๊ณ ํ ์ ์๋๋ฐ, ์ด B๋ฅผ Dependency(๋ถํ)๋ผ๊ณ ํ๋ค.
2. ์กฐ๋ฆฝํ
class A{
private B b;
public A(){
// b = new B();
}
public void setB(B b){
this.b = b;
}
}
A๊ฐ B๋ฅผ ์ง์ ์์ฑํ์ง ์๋๋ค.
์ธ๋ถ์์ ์์ฑํด์ ๊ทธ ์์ฑ์ setB๋ก settingํ์ฌ ์ฌ์ฉํ๋ค.
์ด ๊ฒฝ์ฐ ์กฐ๋ฆฝํ ๊ด๊ณ๋ผ๊ณ ํ๋ค.
์ผ์ฒดํ ๋ณด๋ค ์กฐ๋ฆฝํ์ด ๊ฒฐํฉ๋ ฅ์ด ํจ์ฌ ๋ ๋ฎ๊ณ ๋ค๋ฅธ ๋ถํ์ผ๋ก ๋ฐ๊ฟ ๋ผ์ธ ์ ์๋ค.
- 1๋ฒ ์ผ์ฒดํ์ ๊ฒฝ์ฐ
A a = new A();
์ฌ์ฉ์ ์ ์ฅ์์ A์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค๋ฉด ๊ทธ ์์ ๋ถํ์ด ๋ญ๊ฐ ์๋์ง ์ ๋ชจ๋ฅด๊ฒ ๋๊ณ ๋ถํ์ ๋ฐ๊ฟ ๋ผ์ธ ์ ์๋ค.
- 2๋ฒ ์กฐ๋ฆฝํ์ ๊ฒฝ์ฐ
B b = new B();
A a = new A();
a.setB(b);
A์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ณ A๊ฐ ๊ฐ์ง๊ณ ์๋ ๋ถํ B(Dependency)๋ฅผ ๋ง๋ค์ด์ ๊ฝ์์ค๋ค.(Injection)(=Dependency Injection)
์ฅ์ : ๋ถํ์ ๋ฐ๊ฟ ๋ผ์ธ ์ ์๋ค.
๋จ์ : ๋ถํ์ ์กฐ๋ฆฝํด์ผ ํ๋ ๋ถํธํจ์ด ์๋ค
Injection์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ
- Setter Injection
B b = new B();
A a = new A();
a.setB(b);
- Construction Injection
B b = new B();
A a = new A(b);
IoC Container
์ฌ๋ฌ๊ฐ์ง ๋ถํ๋ค์ ์ฃผ๋ฌธ์์ ์์ฑํด์ Spring์๊ฒ ์ ๊ณตํ๋ฉด ๋ถํ์ ์์ฑํ๊ณ ์กฐ๋ฆฝํด ์ค๋ค.
์ฃผ๋ฌธ์ ์์ฑ ๋ฐฉ๋ฒ ๋ ๊ฐ์ง
1. xmlํ์ผ
2. Annotation
๊ฐ์ฒด๋ฅผ ์์ฑํด์ ๊ทธ๊ฒ๋ค์ ๋ด์ ์ ์๋ ๊ทธ๋ฆ์ด ํ์ํ๋ฐ ์ด๋ฅผ Spring์์ Container ๋ผ๊ณ ํ๋ค.
IoC Container๋ผ๊ณ ํ๋ ์ด์
์ ์ฌ์ง๊ณผ ๊ฐ์ด ์ผ์ฒดํ์ผ๋ก ์ ํ์ ๋ง๋ค๊ฒ ๋๋ฉด Aํด๋์ค๊ฐ Bํด๋์ค๋ฅผ ๋ง๋ค๊ณ , Bํด๋์ค๊ฐ Cํด๋์ค๋ฅผ, Cํด๋์ค๊ฐ Dํด๋์ค๋ฅผ ๋ง๋ค๊ฒ ๋๋ค.
์ฆ ์์ฐจ์ ์ผ๋ก ๊ฐ์ฒด๊ฐ ๋ง๋ค์ด์ง๋ค.
๋ฐ๋ฉด ์ ์ฌ์ง๊ณผ ๊ฐ์ด ์กฐ๋ฆฝํ์ Dํด๋์ค, Cํด๋์ค, Bํด๋์ค, Aํด๋์ค ์์ผ๋ก ๋ง๋ค์ด ์ง๋ค.
์ฆ ์ญ์(Inversion)์ผ๋ก ๋ง๋ค์ด์ง๋ค.
์์ ๊ฐ์ ์ด์ ๋ก IoC(Inversion of Control) Container๋ผ๊ณ ํ๋ค.
๋จ์ํ ๋ถํ๋ง ๋ด๊ณ ์๋ค๋ฉด Dependency Container๋ผ๊ณ ํ ํ ๋ฐ IoC Container ๋ผ๊ณ ํ๋ ์ด์ ๋ ๊ฒฐํฉ๊น์ง ๋์ ๋ด๊ฒจ์ง๋ค๋ ์๋ฏธ๋ฅผ ์ข ๋ ๊ฐํ๊ฒ ๋ํ๋ด๊ธฐ ์ํด์ ์ด๋ค.
Spring DI ์ฉ์ด
- ๋น(Bean)
- ์คํ๋ง์ด IoC ๋ฐฉ์์ผ๋ก ๊ด๋ฆฌํ๋ ์ค๋ธ์ ํธ๋ฅผ ๋งํจ
- ์คํ๋ง์ด ์ง์ ๊ทธ ์์ฑ๊ณผ ์ ์ด๋ฅผ ๋ด๋นํ๋ ์ค๋ธ์ ํธ๋ง์ Bean์ด๋ผ๊ณ ๋ถ๋ฆ
- ๋น ํฉํ ๋ฆฌ(Bean Factory)
- ์คํ๋ง์ IoC๋ฅผ ๋ด๋นํ๋ ํต์ฌ ์ปจํ ์ด๋
- Bean์ ๋ฑ๋ก, ์์ฑ, ์กฐํ, ๋ฐํํ๋ ๊ธฐ๋ฅ์ ๋ด๋น
- ์ผ๋ฐ์ ์ผ๋ก Bean Factory๋ฅผ ๋ฐ๋ก ์ฌ์ฉํ์ง ์๊ณ ์ด๋ฅผ ํ์ฅํ ApplicationContext๋ฅผ ์ด์ฉํ๋ค.
- ์ ํ๋ฆฌ์ผ์ด์
์ปจํ
์คํธ(Application Context)
- Bean Factory๋ฅผ ํ์ฅํ IoC ์ปจํ ์ด๋
- Bean์ ๋ฑ๋กํ๊ณ ๊ด๋ฆฌํ๋ ๊ธฐ๋ณธ์ ์ธ ๊ธฐ๋ฅ์ Bean Factory์ ๋์ผ
- ์คํ๋ง์ด ์ ๊ณตํ๋ ๊ฐ์ข ๋ถ๊ฐ ์๋น์ค๋ฅผ ์ถ๊ฐ๋ก ์ ๊ณต
- Bean Factory๋ผ๊ณ ๋ถ๋ฅผ ๋๋ ์ฃผ๋ก ๋น์ ์์ฑ๊ณผ ์ ์ด์ ๊ด์ ์์ ์ด์ผ๊ธฐ ํ๋๊ฒ์ด๊ณ , ์ ํ๋ฆฌ์ผ์ด์ ์ปจํ ์คํธ๋ผ๊ณ ํ ๋๋ ์คํ๋ง์ด ์ ๊ณตํ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ง์ ๊ธฐ๋ฅ์ ๋ชจ๋ ํฌํจํด์ ์ด์ผ๊ธฐํ๋ ๊ฒ์ด๋ผ๊ณ ๋ณด๋ฉด ๋จ.
- ์ค์ ์ ๋ณด/์ค์ ๋ฉํ์ ๋ณด
- ์คํ๋ง์ ์ค์ ์ ๋ณด๋ Application Context ๋๋ Bean Factory๊ฐ IoC๋ฅผ ์ ์ฉํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ฉํ์ ๋ณด๋ฅผ ๋งํ๋ค.
- ์ค์ ์ ๋ณด๋ IoC ์ปจํ ์ด๋์ ์ํด ๊ด๋ฆฌ๋๋ Bean๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ ๊ตฌ์ฑํ ๋ ์ฌ์ฉ๋จ.
- ์คํ๋ง ํ๋ ์์ํฌ
- ์คํ๋ง ํ๋ ์์ํฌ๋ IoC ์ปจํ ์ด๋, Application Context๋ฅผ ํฌํจํด์ ์คํ๋ง์ด ์ ๊ณตํ๋ ๋ชจ๋ ๊ธฐ๋ฅ์ ํตํ์ด ๋งํ ๋ ์ฃผ๋ก ์ฌ์ฉ.
SpringContainer
๋น ์์ฑ๋ฒ์
- ์ฑ๊ธํค ๋น(Singleton Bean)
- ์คํ๋ง ๋น์ ๊ธฐ๋ณธ์ ์ผ๋ก '์ฑ๊ธํค'์ผ๋ก ๋ง๋ค์ด์ง.
- ๊ทธ๋ฌ๋ฏ๋ก, ์ปจํ ์ด๋๊ฐ ์ ๊ณตํ๋ ๋ชจ๋ ๋น์ ์ธ์คํด์ค๋ ํญ์ ๋์ผํจ
- ์ปจํ ์ด๋๊ฐ ํญ์ ์๋ก์ด ์ธ์คํด์ค๋ฅผ ๋ฐํํ๊ฒ ๋ง๋ค๊ณ ์ถ์ ๊ฒฝ์ฐ scope๋ฅผ prototype์ผ๋ก ์ค์ ํด์ผ ํจ.
'๐๋ฐฑ์๋ : BackEnd' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Spring Web MVC (0) | 2024.01.02 |
---|---|
Spring AOP (1) | 2024.01.02 |
MVC Pattern, Session, Cookie (1) | 2024.01.01 |
[JSP] (0) | 2023.12.28 |
[Servlet] (0) | 2023.12.27 |