[spring] spring framework
<1. ์คํ๋ง ํ๋ ์ ์ํฌ ๊ฐ์>
๐ ์๋ฐ์ ๊ฐ์ฒด ์์ฑ, ๋ฉ๋ชจ๋ฆฌ ๋ก๋ฉ
๋์ ๋ก๋ฉ = ํ๋ก๊ทธ๋จ ์ ์ฐ์ฑ๊ณผ ํ์ฅ์ฑ ๋์.
๋์ ํ๋ก๊ทธ๋๋ฐ = ์๋ฐ์์ ๋์ ์ผ๋ก ํด๋์ค ๋ก๋ํ๊ณ ๋งํฌ.
๋์ ์ผ๋ก ๊ฐ์ฒด ์์ฑ+๋ฉ๋ชจ๋ฆฌ ๋ก๋ฉ ๋ฐ๋ณต์
- ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ฆ๊ฐ = ๊ฐ์ฒด ๋ฐ๋ณต์ ์ผ๋ก ์์ฑ๋๊ณ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ฉ ๋ ๋๋ง๋ค ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ฆ๊ฐ
- ๊ฐ๋น์ง ์ปฌ๋ ์ ๋ถํ = ๋ถํ์ํ ๊ฐ์ฒด ๋ง์์ ธ ๊ฐ๋น์ง ์ปฌ๋ ์ ๋ถํ ์ฆ๊ฐ
- ํ๋ก๊ทธ๋จ ์คํ ์๋ ์ ํ = ์์คํ ์์ ์๋น ↑
- ๋ฉ๋ชจ๋ฆฌ ๋จํธํ = ๋ฐ๋ณต์ ์ผ๋ก ๊ฐ์ฒด ์์ฑ๋๊ณ ์๋ฉธํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋จํธํ ๋ฐ์
๋ฉ๋ชจ๋ฆฌ ์ผ๋ถ ์์ญ์ด ์์ ์กฐ๊ฐ์ผ๋ก ๋๋์ด์ ธ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ ํ๋ฝ
๐ ์คํ๋ง ํ๋ ์์ํฌ์ ํ์๊ณผ ๋ฐ์
์คํ๋ง=EJB(Enterprise Java Beans)์ ๋ณต์ก์ฑ, ๋ถํธํจ ๊ฐ์ ํ๊ธฐ ์ํด ๋ง๋ค์ด์ก๋ค.
ํน์ง
1. IoC์ปจํ ์ด๋ ์ ๊ณต=Bean์๋ช ์ฃผ๊ธฐ ๊ด๋ฆฌ๋ฅผ ์ฝ๊ฒ ํ๋ค.
2. XML์ด๋ Annotation์ ์ฌ์ฉํ ์ ์ธ์ ํธ๋์ญ์ ๊ด๋ฆฌ ๋ฑ์ ์ ๊ณต
3. POJO=์ฝ๋ ์์ ์์ด๋ enterprise์๋น์ค ์ ์ฉ ๊ฐ๋ฅ
4. MVCํ๋ ์์ํฌ ์ ๊ณต=์น ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐ์ ์ํ ๊ธฐ๋ฅ ์ ๊ณต
5. AOP=์ ์ธ์ ํธ๋์ญ์ ๊ด๋ฆฌ, ๋ฐ์ดํฐ ๊ด๋ฆฌ ๋ฑ ์ง์
6. DI ์์กด์ฑ ์ฃผ์ ์ง์=๊ฐ ๊ณ์ธต์ด๋ ์๋น์ค๋ค ์ฌ์ด ๋๋ ๊ฐ์ฒด ์ฌ์ด ์์กด์ฑ ์กด์ฌ์ ์คํ๋ง ํ๋ ์ ์ํฌ๊ฐ ์๋ก ์ฐ๊ฒฐ.
7. ํ์ฅ์ฑ ๋๋ค=๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๋ถ๋ฆฌํด๋จ๊ธฐ ๋๋ฌธ์ ํ์ํ๊ฒ๋ง ์ฌ์ฉ ๊ฐ๋ฅ
๐ IoC์ปจํ ์ด๋
=๊ฐ์ฒด ์์ฑ, ๊ด๋ฆฌ, ์์กด์ฑ ์ฃผ์ ๋ด๋นํ๋ ์์
์ ํ๋ฆฌ์ผ์ด์ ์ ์ด ํ๋ฆ์ ํ๋ ์์ํฌ๊ฐ ๋ด๋นํ๋๋ก ํจ
๊ธฐ๋ฅ=Bean๊ด๋ฆฌ, ์์กด์ฑ ์ฃผ์ , ๋ผ์ดํ์ฌ์ดํด ๊ด๋ฆฌ
IoC ์ปจํ ์ด๋ ๊ตฌํ์ฒด=BeanFactory, ApplicationContext
IoC ์ด์ = ๊ฒฐํฉ๋ ๊ฐ์, ํ ์คํธ ์ฉ์ด์ฑ, ์ฌ์ฌ์ฉ์ฑ๊ณผ ํ์ฅ์ฑ
๐ ์คํ๋ง ์ปจํ ์ด๋์ ๋น ๊ด๋ฆฌ
=๋น ์์ฑ-์๋ฉธ๊น์ง ๊ฐ์ฒด ์๋ช ์ฃผ๊ธฐ ๊ด๋ฆฌ.
1. ๋น ์ ์(Bean Definition)
– ์ ์๋ฐฉ์: XML ์ค์ ํ์ผ, ์๋ฐ์ค์ ํด๋์ค, ๋๋์ด๋ ธํ ์ด์ (@Component, @Service, @Repository ๋ฑ).
– ๋ฉํ๋ฐ์ดํฐ: ๋น์ํด๋์ค, ์์ฑ๋ฐฉ๋ฒ, ์์กด์ฑ, ์ด๊ธฐํ/์๋ฉธ ๋ฉ์๋๋ฑํฌํจ.
2. ๋น ์์ฑ(Bean Instantiation)
– ์ฑ๊ธํค๊ด๋ฆฌ: ๊ธฐ๋ณธ์ ์ผ๋กํ๋์์ธ์คํด์ค๋ง์์ฑ๋ฐ๊ด๋ฆฌ.
– ๋ค๋ฅธ์ค์ฝํ์ง์: ํ๋กํ ํ์ , ์์ฒญ(Request) ๋ฑ ๋ค์ํ์ค์ฝํ๊ฐ๋ฅ.– ์์ฑ์ํธ์ถ: ์์ฑ์ํ์ํ์์กด์ฑ์์ฃผ์ .
3. ์์กด์ฑ์ฃผ์ (Dependency Injection)
– ์์กด์ฑํด๊ฒฐ: ์์ฑ์์ฃผ์ , ์ธํฐ์ฃผ์ , ํ๋์ฃผ์ ๋ฐฉ์์ผ๋ก์๋์ฃผ์ .
– ์๋์ฃผ์ : @Autowired์๊ฐ์์ด๋ ธํ ์ด์ ์ผ๋ก๊ฐ๋จํ๊ฒ์์กด์ฑํด๊ฒฐ๊ฐ๋ฅ.
4. ๋น ์ด๊ธฐํ(Bean Initialization)
– ์ด๊ธฐํ๋ฉ์๋: @PostConstruct ์ด๋ ธํ ์ด์ ์ด๋ InitializingBean ์ธํฐํ์ด์ค ์ฌ์ฉ.
– ์ปค์คํฐ๋ง์ด์ง: ์ด๊ธฐํ๋ฉ์๋์ง์ ๊ฐ๋ฅ.
5. ๋น ์ฌ์ฉ(Bean Usage)
– ์ ํ๋ฆฌ์ผ์ด์ ์ฌ์ฉ: ๋น์์ฃผ์ ๋ฐ์์ ํ๋ฆฌ์ผ์ด์ ์์์ฌ์ฉ.
– ์ฑ๊ธํค์ฌ์ฌ์ฉ: ์ฑ๊ธํค์ค์ฝํ๋๋์ผํ์ธ์คํด์ค๋ฅผ์ฌ์ฌ์ฉ, ํ๋กํ ํ์ ์์๋ก์ด์ธ์คํด์ค๋ฅผ์์ฑ.
6. ๋น ์๋ฉธ(Bean Destruction)
– ์๋ฉธ๋ฉ์๋: @PreDestroy ์ด๋ ธํ ์ด์ ์ด๋ DisposableBean ์ธํฐํ์ด์ค ์ฌ์ฉ.
– ์์ํด์ : ํ์ผ๋ซ๊ธฐ, ๋คํธ์ํฌ์ฐ๊ฒฐ์ข ๋ฃ๋ฑํ์ํ์์ํด์ ์ํ.
๐์คํ๋ง ํ๋ ์์ํฌ ์ฅ๋จ์
์ฅ์ =์์ฐ์ฑ, ํ์ง๋ณด์ฆ, ์ ์ง ๋ณด์
๋จ์ =ํ์ต๊ณก์ (๊ณต๋ถํ ์ ๋ง์), ์ค๋ช ์ ๋ณต์ก์ฑ, ์ถ์ํ์ ํ๊ณ
๐ ์คํ๋ง ํ๋ ์์ํฌ ์ฃผ์ ๊ตฌ์ฑ์์
Spring Core Container
= ์คํ๋ง์ ํต์ฌ ์ด๋ฃจ๋ ์ปจํ ์ด๋. BeanFactory๋ฅผ ํฌํจํ์ฌ ์์กด์ฑ ์ฃผ์ ๊ธฐ๋ฅ์ ์ ๊ณต.
๊ฐ์ฒด ์์ฑ๊ณผ ๊ฐ์ฒด ๊ฐ ๊ด๊ณ ์ค์ ์ด ์ฌ์์ง๋ค
SpringAOP
=ํธ๋์ญ์ ๊ด๋ฆฌ, ๋ก๊น , ๋ณด์ ๋ฑ ์๋น์ค๋ฅผ ์ ํ๋ฆฌ์ผ์ด์ ํต์ฌ ๋ก์์์ ๋ถ๋ฆฌํ์ฌ ๊ด๋ฆฌ
Spring MVC
= ์น ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐํ๊ธฐ ์ํ model view controller ๊ตฌ์กฐ ์ ๊ณต.
๊ฐ๋ฐ์๊ฐ ๊ฐ ๋ถ๋ถ์ ๋ถ๋ฆฌํ์ฌ ๊ฐ๋ฐ ๊ฐ๋ฅ
Spring Data Access/Integration
= ๋ฐ์ดํฐ ์ก์ธ์ค ๊ธฐ์ ์ ์ถ์ํํ์ฌ ์ ๊ณต
๋ ํจ์จ์ ์ธ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์์ ์งํ ๊ฐ๋ฅ
Spring Web Flow
= ์น ์ ํ๋ฆฌ์ผ์ด์ ํ๋ฆ ์ ์ํ๊ณ ๊ด๋ฆฌํ ์ ์๋ ํ๋ ์์ํฌ.
Spring Security
= ์ธ์ฆ๊ณผ ๊ถํ ๋ถ์ฌ๋ฅผ ์ํ ๋ณด์ ํ๋ ์์ํฌ
Spring Boot
= ์คํ๋ง ํ๋ ์์ํฌ ๊ธฐ๋ฐ์ผ๋ก
๋ณต์กํ ์ด๊ธฐ ์ค์ ์ ์ต์ํํ๊ณ
๋น ๋ฅด๊ฒ ํ๋ก๋์ ์ค๋น๊ฐ ๋ ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐํ ์ ์๊ฒ ๋๋ ํ๋ ์์ํฌ
๐์คํ๋ง ํ๋ ์์ํฌ ๋ชจ๋
๋ชจ๋ | ์ค๋ช |
spring-beans | ์คํ๋ง ์ปจํ ์ด๋ ์ด์ฉํด์ ๊ฐ์ฒด ์์ฑํ๋ ๊ธฐ๋ณธ ๊ธฐ๋ฅ ์ ๊ณต |
spring-context | ๊ฐ์ฒด ์์ฑ, ๋ผ์ดํ ์ฌ์ดํด ๊ด๋ฆฌ, ์คํค๋ง ํ์ฅ |
spring-aop | ํ๋ก์ ๊ธฐ๋ฐ AOP๊ธฐ๋ฅ ์ ๊ณต |
spring-web | RESTํด๋ผ์ด์ธํธ, ๋ฐ์ดํฐ ๋ณํ ์ฒ๋ฆฌ, ์๋ธ๋ฆฟ ํํฐ, ํ์ผ ์ ๋ก๋ ๋ฑ ๊ธฐ๋ฅ ์ ๊ณต |
spring-webmvc | ์คํ๋ง ๊ธฐ๋ฐ ์น MVC ํ๋ ์์ํฌ, controller, view๊ตฌํ ์ ๊ณต |
spring-websocket | MVC์์ ์ฌ์ฉํ ์น์์ผ ๊ธฐ๋ฅ ์ง์ |
spring-oxm | XML๊ณผ ์๋ฐ ๊ฐ์ฒด๊ฐ ๋งคํ ์ฒ๋ฆฌ API |
spring-tx | ํธ๋์ญ์ ์ฒ๋ฆฌ ์ํ ์ถ์ ๋ ์ด์ด |
spring-jdbc | jdbcํ๋ก๊ทธ๋๋ฐ ์ฝ๊ฒ ํ ์ ์๋ ํ ํ๋ฆฟ ์ ๊ณต |
spring-orm | ํ์ด๋ฒ๋ค์ดํธ, JPA, MyBatis๋ฑ๊ณผ ์ฐ๋ |
spring-jms | JMS์๋ฒ์ ๋ฉ์์ง ์ฝ๊ฒ ์ฃผ๊ณ ๋ฐ์ ์ ์๋๋ก ํ ํ๋ฆฟ๊ณผ ์ด๋ ธํ ์ด์ ๋ฑ ์ ๊ณต |
spring-context-support | ์ค์ผ์ค๋ง, ๋ฉ์ผ ๋ฐ์ก, ์บ์ ์ฐ๋, ๋ฒจ๋ก์ํฐ ๋ฑ ๊ธฐ๋ฅ |
<2. ์์กด์ฑ ์ฃผ์ ๊ฐ์>
์์กด์ฑ ์ฃผ์ (DI) =๋น์ด ํ์ํ ๊ณณ์ ์ 3์๊ฐ ๋น์ ๋ง๋ค์ด ์ ๋ฌํด ์ฃผ๋๋ก ํ๋ ๊ฒ. โญโญโญโญโญ
Hello ๊ตฌ์กฐ
1๏ธโฃ DI ์ฌ์ฉํ์ง ์๋ ์ฝ๋
=(bad case!) HelloControllerํด๋์ค์ HelloServiceํด๋์ค๊ฐ ๊ฐํ ์์กด๊ด๊ณ๊ฐ ๋๊ฒ ๋๋ค.
2๏ธโฃ Constructor based DI
์์ฑ์๋ฅผ ์ด์ฉํ ์์กด์ฑ ์ฃผ์ = ์์ฑ์๋ฅผ ์ด์ฉํด ๊ฐ์ฒด๋ฅผ inject(์ ๋ฌ)ํ๋ ๊ฒ
HelloMain.java
package com.example.myapp.di;
public vlass HelloMain{
public static void main(String[] args){
IHelloService helloService=new HelloService(); //Service ๊ฐ์ฒด ์์ฑ ํ
HelloController controller=new HelloController(helloService);//Controller์ ์ ๋ฌ
controller.hello("hoho");
}
}
HelloController.java
package com.example.myapp.di;
public class HelloController{
IHelloService helloService;
public HelloController(IHelloService helloService)
{this.helloService=helloService;}
public void hello(String name)
{ System.out.println("HelloController:"+helloService.sayHello(name)); }
}
HelloMainํด๋์ค์์ HelloService๊ฐ์ฒด ์์ฑํ
HelloControllerํด๋์ค ์์ฑ์ ์ธ์๋ก ์ ๋ฌํ์ฌ HelloController๊ฐ์ฒด๋ฅผ ์์ฑ.
์ด๋ฌ๋ฉด HelloController์๊ฒ HelloService๊ฐ์ฒด๋ฅผ ์ ๋ฌ ๊ฐ๋ฅ.
์ด์ฒ๋ผ ์์ฑ์๋ฅผ ์ด์ฉํด ๊ฐ์ฒด๋ฅผ inject(์ ๋ฌ)ํ๋ ๊ฒ์ด ์์ฑ์๋ฅผ ์ด์ฉํ ์์กด์ฑ ์ฃผ์ ์ด๋ค.
3๏ธโฃ Setter based DI
setter based DI = setter๋ฉ์๋ ์ด์ฉํ์ฌ ๊ฐ์ฒด inject(์ ๋ฌ)ํ๋ ๋ฐฉ๋ฒ
์์ฑ์๋ฅผ ๊ตฌํํ ๋ ์ ๋ฌํด์ผํ ๊ฐ์ฒด๊ฐ ๋ง์ผ๋ฉด
ํ๋์ฉ ๋ค ์์ฑ์ ๊ตฌํํ๊ธฐ ํ๋ค๋ค.
์ด ๋ setter๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฅผ ํธํ๊ฒ ํ ์ ์๋ค.
HelloMain.java
package.com.example.myapp.di;
public class HelloMain{
public static void main(String[]args){
IHelloService helloService=new HelloService();
HelloController controller=new HelloController();
controller.setHelloService(helloService); //set methodํธ์ถํ์ฌ ๊ฐ์ฒด ์ ๋ฌ
controller.hello("hongildong");
}
}
HelloController.java
package com.example.myapp.di;
public class HelloController{
IHelloService helloService;
public void setHelloService(IHelloService helloService){
this.helloService=helloService;
}
public void hello(String name){
System.out.println("HelloController:"+helloService.sayHello(name));
}
}
์์ฑ์ vs setter
์์ฑ์๋ฅผ ์ด์ฉํ ์์กด์ฑ ์ฃผ์ =์์ฑ์์ ์ธ์๋ก, ์์กด ๊ฐ์ฒด ์ ๋ฌ
setter๋ฉ์๋ ์ด์ฉํ ์์กด์ฑ ์ฃผ์ =setter๋ฉ์๋ ์ด์ฉํ์ฌ ์์กด ๊ฐ์ฒด ์ ๋ฌ
+) ์ฑ ์ 60ํ์ด์ง ์ฉ์ด+์ค๋ช ์ธ์์ผํ๋ค
+) AOP ์ฉ์ด๋ง ์ธ์ฐ๋ฉด ๋๋ค.
+) italic์ฒด๋ก ์ฐ์ฌ์์ผ๋ฉด ๋์ฑ๋ ์ ์๊ฑฐ๋ ์ค์ํ ๊ฒ์ด๋ค
<3.์คํ๋ง์ ์์กด์ฑ ์ฃผ์ >
์คํ๋ง ์์กด์ฑ ์ฃผ์
1. xml์ด์ฉํ ๋ฐฉ๋ฒ
2. annotation์ด์ฉํ ๋ฐฉ๋ฒ
3. configํ์ผ (์๋ฐ ํด๋์ค)์ด์ฉ
๐1. XML ์ด์ฉํ DI
1๏ธโฃXML ์ด์ฉํ ์์กด์ฑ ์ฃผ์
1. ์คํ๋ง ํ๋ ์์ํฌ ํ๋ก์ ํธ ๋ง๋ค๊ธฐ
โ workspace-spring.zip
workspace-spring.zipํ์ผ ๋ด๋ ค๋ฐ์ ์์ถ ํ๊ณ
์ดํด๋ฆฝ์ค์ workspace-springํด๋๋ฅผ ํด๋น ์ํฌ์คํ์ด์ค ํด๋๋ก ์ค์
โก Spring Leagcy Project ์์ฑ
2. pom.xml์ ๋ฒ์ ์ค์
3. application-config.xml ํ์ผ ์์ฑ
+) ๋ง์ฝ Spring Bean Configuration File์ด ์๋จ๋ฉด ์ฐ์ธก์๋จ์ ์ด ๋ฒํผ ๋๋ฌ๋ผ
next, finish๋ฅผ ๋๋ฅด๋ฉด xmlํ์ผ ์์ฑ๋๋ค
์ด์ ์ด ํ์ผ์ bean๋ค์ ์ ์ํ๊ณ ์์กด์ฑ์ ์ค์ ํ๋ฉด ๋๋ค.
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- bean ์์ฑ ํ ์์กด์ฑ ์ฃผ์
์ค์ -->
<bean id="helloService" class="com.example.myapp.di.HelloService"/>
</beans>
<bean> tag
์์ฑ | ์ค๋ช |
name ๋๋ id | bean๊ณ ์ ์๋ณ์ ์ง์ . |
class | ํ์. ๋น ์์ฑํ๋๋ฐ ์ฌ์ฉํ ํด๋์ค ์ง์ |
scope | ํน์ ๋น ์ ์์์ ์์ฑ๋ ๊ฐ์ฒด์ ๋ฒ์ ์ง์ . |
lazy-init | ๋น์ด ์ฌ์ฉ๋๋ ์์ ์ ์ธ์คํด์ค ์์ฑ. ์์ฑ๊ฐ์ true or false |
init-method | ์ธ์คํด์ค ์์ฑ ํ init method์์ฑ์ ์ ์ฅํ ๋ฉ์๋ ์คํ |
destroy-method | ๋น ๊ฐ์ฒด ์ญ์ ์ destroy method์์ฑ์ ์ง์ ํ ๋งค์๋ ์คํ |
spring context ์์๋
spring context class = ๊ฐ์ฒด ์์ฑํ๊ณ ๊ด๋ฆฌํ๋ ์ปจํ ์ด๋ ๊ธฐ๋ฅ.
์ปจํ ์ด๋๋ก ๋ถํฐ ๋น์ ์ฐพ๊ธฐ ์ํด์๋ ์ปจํ ์คํธ๊ฐ ์์ด์ผ ํ๋ค.
์คํ๋ง์ ์ปจํ ์คํธ
=BeaFactory ์ธํฐํ์ด์ค ๊ตฌํํ ํด๋์ค๋ค + ์ด๋ฅผ ์์ํ ApplicationContext ์ธํฐํ์ด์ค ๊ตฌํํ ํด๋์ค๋ค
ClassPathXmlAplicationContext๋ฑ..์ bean factory(bean์ ๋ง๋๋ ๊ณต์ฅ)
์์
HelloMain.java
run - run as - java application
package com.example.myapp.di;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class HelloMain {
public static void main(String[] args) {
AbstractApplicationContext context=
new GenericXmlApplicationContext("application-config.xml");//context์์ฑ
context.close();
}
}
๊ฒฐ๊ณผ
์ปจํ ์คํธ ์์ฑํ๋ฉด ํด๋์คํจ์ค ๊ฒฝ๋ก์ application-config.xmlํ์ผ์ด ๋ก๋๋์ด
helloService๋น์ ์ฑ๊ธํค์ผ๋ก ์ธ์คํด์คํ ํ๋ ๊ฒ์ ํ์ธ ๊ฐ๋ฅ
context.close()๋ฉ์๋ ํธ์ถ๋ก ์ธํด helloService๋น์ด ์๋ฉธ๋๋ ๋ก๊ทธ๋ ์์
2๏ธโฃ ์์ฑ์๋ฅผ ์ด์ฉํ ์์กด์ฑ ์ฃผ์
=controller class์ ์๋น์ค ํด๋์ค ์ธ์คํด์ค ์ ๋ฌํ๊ธฐ ์ํด controller class์์ฑ์ ์ถ๊ฐ.
HelloController.java
package com.example.myapp.di;
public class HelloController{
IHelloService helloService;
public HelloController(IHelloService helloService){
this.helloService=helloService;}
public void hello(String name)
{ System.out.println("HelloController:"+helloService.sayHello(name));}
}
spring์ค์ ํ์ผ์ HelloControllerํด๋์ค ๋น ์ ์์ <constructor-args> tag๋ก ์์กด์ฑ ์ฃผ์ ๊ฐ๋ฅ
<constructor-args> tag์ ref ์์ฑ์ ์์กด์ฑ ์ฃผ์ ํ ๋ค๋ฅธ ๋น ์์ด๋ ์ง์ ํ๋ค.
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- bean ์์ฑ ํ ์์กด์ฑ ์ฃผ์
์ค์ -->
<bean id="helloService" class="com.example.myapp.di.HelloService"/>
<bean id="helloService" class="com.example.myapp.di.HelloController">
<constructor-arg ref="helloService"/>
</bean>
</beans>
HelloMain.java
package com.example.myapp.di;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class HelloMain2 {
public static void main(String[] args) {
AbstractApplicationContext context
=new GenericXmlApplicationContext("application-config.xml");
HelloController controller=context.getBean(HelloController.class);
controller.hello("hoho");
context.close();
}
}
HelloService.java
package com.example.myapp.di;
import org.springframework.stereotype.Controller;
@Controller
public class HelloService implements IHelloService{
@Override
public String sayHello(String name)
{
System.out.println("HelloService.salyHello() method");
String message="HEllO!"+name;
return message;
}
}
IHelloService.java
package com.example.myapp.di;
public interface IHelloService {
String sayHello(String name);
}
๊ฒฐ๊ณผ
HelloService.sayHello() ๋ฉ์๋ ์คํ
HelloController: HELLO!hoho
+)
HelloMain์์ controller bean์ ์ฐพ๊ธฐ ์ํด getBean๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค.
getBean(Class<T> requiredType) T๋ฉ์๋ ์ด์ฉํ๋ฉด ํด๋น ์ธ์ ์ ํ์ ๊ฐ์ฒด๊ฐ ๋ฐํ๋๋ค.
๋ง์ผ ๊ฐ์ ํ์ ์ ๋น์ด 2๊ฐ ์ด์์ด๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๋น ์ด๋ฆ ์ง์ ์ง์ ๊ฐ๋ฅ
HelloController controller=context.getBeean("helloController",helloController.class);
์์ฑ์์ ์ ๋ฌํ๋ ์ธ์ ํ์ ์ด String์ด๊ฑฐ๋ ๊ธฐ๋ณธ ๋ฐ์ดํฐํ์ ์ด๋ฉด value์์ฑ ์ด์ฉ
public class BasicDataSource implements DataSource{
private String driverClassName;
private String url;
public DataSource(String driverClassName,String url)
{ this.driverClassName=driverClassName; this.url=url;
.... ์๋ต
<bean id="dataSource" class="com.example.myapp.database.BasicDataSource">
<constructor-arg value="jdbc:oracle:thin:@localhost:1521:xe"/>
<constructor-arg value="oracle.jdbc.OracleDriver"/>
</bean>
+) index๋ ์ง์ ๊ฐ๋ฅ --> ์์ฑ์์๊ฒ ์ ๋ฌํ ์ธ์ ์์ ๋ช ํํ ํ๊ธฐ ๊ฐ๋ฅ
<bean id="dataSource" class="com.example.myapp.database.BasicDataSource">
<constructor-arg index="1" value="jdbc:oracle:thin:@localhost:1521:xe"/>
<constructor-arg index="2" value="oracle.jdbc.OracleDriver"/>
</bean>
+) null์ผ ๊ฒฝ์ฐ
<constructor-arg><null/></constructor-arg>
3๏ธโฃ setter ๋ฉ์๋ ์ด์ฉํ ์์กด์ฑ ์ฃผ์
=DIํ ๊ฐ์ฒด ๋ง์์ ํด๋์ค์ ์์ฑ์ ์ค๋ณต ์ ์ํ๋ ๊ฒ์ ๊ท์ฐฎ๋ค.
set๋ฉ์๋ ์ ์ธํ๊ณ <property>ํ๊ทธ๋ฅผ ์ด์ฉํ์ฌ DI๊ฐ๋ฅ
+) ๋จ set ๋ฉ์๋ ์ฌ์ฉ์ ๊ธฐ๋ณธ์์ฑ์ ์ธ์ ๋ค๋ฅธ ์์ฑ์ ์ ์ํ๋ฉด ์๋จ. ๊ธฐ๋ณธ์์ฑ์๋ ๋ฐ๋์ ์กด์ฌํด์ผํจ
HelloController.java
package com.example.myapp.di;
public class HelloController {
IHelloService helloService;
public void setHElloService(IHelloService helloService) {this.helloService=helloService;}
public void hello(String name)
{
System.out.println("HelloController:"+helloService.sayHello(name));
}
}
์์ controller๋ ์๋น์ค ๊ฐ์ฒด๊ฐ ํ์ํ๋ค
set ๋ฉ์๋ ์ด์ฉํ DI๋ฅผ ์ํ ์คํ๋ง ์ค์ ํ์ผ ํ๊ทธ๋ <property>ํ๊ทธ์ด๋ค.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- bean ์์ฑ ํ ์์กด์ฑ ์ฃผ์
์ค์ -->
<bean id="helloService" class="com.example.myapp.di.HelloService"/>
<bean id="helloController" class="com.example.myapp.di.HelloController">
<property name="helloService" ref="helloService"/>
</bean>
</beans>
๊ฒฐ๊ณผ
HelloService.sayHello() ๋ฉ์๋ ์คํ
HelloController:HELLO!hoho
+) DI๊ฐ์ด ๊ธฐ๋ณธ ์๋ฃํ์ด๊ฑฐ๋ String์ด๋ฉด <property>tag์ value์์ฑ ์ด์ฉํ์ฌ ๊ฐ ์ง์
+) ๋น ์ด๋ฆ์ set์ ๋นผ๊ณ ๋ค์ ๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ฐ๊พผ ๊ฒ
๐2. annotation์ ์ด์ฉํ DI
1๏ธโฃAnnotation ์ด์ฉํ ์์กด์ฑ ์ฃผ์
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- ์ค์บํ ํจํค์ง ๊ฒฝ๋ก ์ค์ -->
<context:component-scan base-package="com.example.myapp"/>
</beans>
์์ ํจํค์ง๋ฅผ ์ง์ ํ๋ฉด ํ์ ํจํค์ง๊น์ง bean์ผ๋ก ๋ฑ๋ก๋ ํด๋์ค๋ฅผ ์ฐพ๋๋ค.
annotation์ถ๊ฐ, bean์์ฑ
HelloService.java
package com.example.myapp.di;
import org.springframework.stereotype.Service;
@Service
public class HelloService implements IHelloService{
@Override
public String sayHello(String name)
{
System.out.println("HelloService.salyHello() method");
String message="HEllO!"+name;
return message;
}
}
HelloController.java
package com.example.myapp.di;
import org.springframework.stereotype.Controller;
@Controller
public class HelloController{
IHElloService helloService;
public void hello(String name){
System.out.println("HelloController:"+helloService.sayHello(name));
}
}
ํ๋ก์ ํธ ํ์ผ ์์ด์ฝ์ด ์ด๋ ๊ฒ ๋ณํ๋ฉด ์คํ๋ง ๋น์ผ๋ก ๋ฑ๋ก๋์์์ ์๋ฏธ
๐bean ์์ฑ์ฉ annotation
<bean>ํ๊ทธ์ ๊ฐ์ ์ญํ .
์ด๋ ํ annotation์ ๋ฃ์ด๋ ์๋์ ํ์ง๋ง. ๋ชฉ์ ์ ๋ง๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
๋น์ ์์ด๋๋ ํด๋์ค ์ด๋ฆ ์ฒซ๋ฌธ์๋ง ์๋ฌธ์๋ก ๋ฐ๊พผ๊ฒ์ผ๋ก ์ค์ ๋๋ค.
annotation | explanation |
@Component | ์ผ๋ฐ์ ์ธ component๋ก ๋ฑ๋กํ๊ธฐ ์ํ ํด๋์ค์ ์ด์ฉ ๋น์ด๋ฆ ์ง์ ์ง์ ํ๊ณ ์ถ์ ์ @Component(value="homeController") |
@Controller | controller class |
@Service | service class |
@Repository | DAO class or repository class |
๐์์กด์ฑ ์ฃผ์ ์ค์
์์กด์ฑ ์ฃผ์ ์ค์ annotation
annotation | explanation |
@Autowired | ํ์
๊ธฐ์ค ์์กด์ฑ ์ฃผ์
๊ฐ์ ํ์ ๋น์ด ๋๊ฐ ์ด์ ์์ผ๋ฉด ๋ณ์ ์ด๋ฆ์ผ๋ก ๋น ์ฐพ์ @Autowired IHelloService helloService; |
@Qualifier | ๋น ์ด๋ฆ์ผ๋ก ์์กด์ฑ ์ฃผ์
. @Autowired์ ๊ฐ์ด ์ฌ์ฉ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๊ฐ ์ถ๊ฐ๋๋ฉด ๊ฐ์ ํ์ ๋น์ด 2๊ฐ ๋ง๋ค์ด์ง๋ค. ์ด ๋ ๋น ์ด๋ฆ ์ง์ ํด์ค ์ ์๋ค. @Autowired @Qualifier("niceService") IHelloService helloService; |
@Resource | name์ ์์ฑ์ ์ด์ฉํ์ฌ ๋น ์ด๋ฆ ์ง์ name ์์ฑ ์๋ตํ๋ฉด ๋ณ์ ์ด๋ฆ๊ณผ ๊ฐ์ ๋น ์ฐพ๋๋ค. @Resource(name="niceService") IHelloService helloService; |
@Inject | @Autowired์ ๋์ผ @Inject IHelloService helloService; |
๐๋น ์์ฑ, ์์กด์ฑ ์ฃผ์ ๋ฌธ์ ํด๊ฒฐ
@Inject, @Autowired๋ฅผ ์ฌ์ฉํ ๋ ๊ฐ์ ํ์ ๋น์ด 2๊ฐ ์ด์ ์์ผ๋ฉด ๋ณ์ ์ด๋ฆ ๊ธฐ์ค์ผ๋ก ๋น์ ์ฐพ๋๋ค
์ด๋ ๋ณ์ ์ด๋ฆ๊ณผ ๊ฐ์ ์ด๋ฆ์ ๊ฐ๋ ๋น์ด ์กด์ฌํ์ง ์์ผ๋ฉด ์๋์ ๊ฐ์ ์๋ฌ๊ฐ ๋๋ค
No unique bean of type[com.exmaple.myall.di.IHelloService] is defiend: expected single matching bean but found 2:[name1, name2]
๐์ค๋ฅ ๋ฐ์ ์ ์์ธ ์ฐพ๊ธฐ ๊ฐ์ด๋๋ผ์ธ
1) ์คํ๋ง ์ค์ ํ์ผ(ex: application-config.xml) ์ด๋ฆ, ๊ฒฝ๋ก ์ฌ๋ฐ๋ฅธ์ง ํ์ธ.
main()๋ฉ์๋ ํ์ผ ์ด๋ฆ๊ณผ ์ค์ ์ค์ ํ์ผ ๊ฒฝ๋ก ํ์ธ
2) XML์ด์ฉํ ์์กด์ฑ ์ฃผ์ -- ๋น ์์ฑ, ์์กด์ฑ ์ฃผ์ ์ด ์ฌ๋ฐ๋ฅธ์ง ํ์ธ.
setter ๋ฉ์๋ ๊ธฐ๋ฐ DIํ๋ ค๋ฉด ๊ธฐ๋ณธ์์ฑ์ ์๋์ง ํ์ธ
3) annotation DI = <context:component-scan> tag์ฌ๋ฐ๋ฅธ์ง ํ์ธ
4) class์ @Controller, @Service๋ฑ ๋น ์์ฑ์ ์ํ DI์ค์ ๋์ด ์๋์ง ํ์ธ
5) DI์ ํ์ํ ๋ฉค๋ฒ๋ณ์์์ @Autowired annotation๋ฑ์ ์ํด ์์กด์ฑ์ฃผ์ ์ค์ ๋์ด์๋์ง ํ์ธ
6) ์ดํด๋ฆฝ์ค ์ข ๋ฃํ C:/Users/{์ฌ์ฉ์๋ช } ์๋์ .m2 ๋๋ ํ ๋ฆฌ ์ญ์ ํ ์ดํด๋ฆฝ์ค ์คํ
๐ 3. ์๋ฐ ์ค์ ํ์ผ ์ด์ฉํ ์์กด์ฑ ์ฃผ์
(java config file)
= XML๋ฌธ์๋ annotation์์ด๋ ์๋ฐ ํด๋์ค๋ก ๋น ์์ฑ, ์์กด์ฑ ์ฃผ์ ์ด ๊ฐ๋ฅํ๋ค
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
HelloController.java
package com.example.myapp.di;
public class HelloController {
IHelloService helloService;
public void setHelloService(IHelloService helloService){
this.helloService=helloService;
}
public void hello(String name){
System.out.println("HelloController:"+helloService.sayHello(name));
}
}
HelloMain.java
package com.example.myapp.di;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import com.example.myapp.config.AppConfig;
public class HelloMain {
public static void main(String[] args) {
AbstractApplicationContext context=
new AnnotationConfigApplicationContext(AppConfig.class);
HelloController controller=context.getBean(HelloController.class);
controller.hello("HoHo");
context.close();
}
}
HelloService.java
package com.example.myapp.di;
public class HelloService implements IHelloService{
@Override
public String sayHello(String name)
{
System.out.println("HelloService.salyHello() method = ");
String message="HEllO!"+name;
return message;
}
}
IHelloService.java
package com.example.myapp.di;
public interface IHelloService {
String sayHello(String name);
}
AppConfig.java
package com.example.myapp.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import com.example.myapp.di.HelloController;
import com.example.myapp.di.HelloService;
import com.example.myapp.di.IHelloService;
@Configuration
@ComponentScan(basePackages= {"com.example.myapp"})
@ImportResource(value= {"classpath:application-config.xml"})
public class AppConfig {
@Bean
IHelloService helloService() {return new HelloService();}
@Bean //์์กด์ฑ ์ฃผ์
!!
HelloController helloController()
{
HelloController controller=new HelloController();
controller.setHelloService(helloService());
return controller;
}
}
@Configuration
=์๋ฐํด๋์ค๊ฐ ์ค์ ํ์ผ๋ก ์ฌ์ฉ๋๊ฒ ํ๋ค
ํด๋์ค ์ ์ธ๋ถ์ ์์น
@ComponentScan
=XML๋ฌธ์์ <context:component-scan/>๊ณผ ๊ฐ์ ์ญํ ํจํค์ง ์ฌ๋ฌ๊ฐ ์ค์ ์ {}์ฌ์ฉ
@ImportResource
=๊ธฐ์กด์ ์๋ XML๋ฌด๋ ๋ถ๋ฌ์ค๋ ์ญํ
@Bean
=@Bean ์ด๋ ธํ ์ด์ ์ ์ ์ํ ๋ฉ์๋๋ก ๊ฐ์ฒด ์์ฑ.
ํด๋น ๋ฉ์๋์ ์ด๋ฆ์ด ๋น์ ์ด๋ฆ์ด ๋๋ค.
๐๋น์์ฑ๊ณผ ์์กด์ฑ ์ฃผ์ ๋น๊ต
XML vs Annotation
4. Bean ์ค์ ํ์ผ
+) sts-4.27.0์์ ์คํ
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- ์ค์บํ ํจํค์ง ๊ฒฝ๋ก ์ค์ -->
<context:component-scan base-package="com.example.myapp"/>
</beans>
โ ๏ธํ๋ก์ ํธ๋ค ! ํ์ ์์ ๊ฒฝ์ฐ
์๋ฌด ํ๋ก์ ํธ ์ ํํด์ ์ค๋ฅธ์ชฝ ๋ง์ฐ์ค - Maven - Update Project
SelectAll ํ OK
์คํ๋ง ์ค์ ํ์ผ ๋๋๊ธฐ
๊ธฐ๋ฅ๋ณ๋ก XMlํ์ผ์ ๋๋์ด ์ค์ ์ด ๊ฐ๋ฅํ๋ค
<import>ํ๊ทธ๋ก ๋ค๋ฅธ ๋น ์ค์ ํ์ผ ํฌํจ ๊ฐ๋ฅ
<import resource="context-aspect.xml"/>
์ฌ๋ฌ๊ฐ ์ค์ ํ์ผ ์ง์
AbstractApplicationContext context =new GenericXmlApplicationContext("context-*.xml");
์์
package com.example.myapp.di;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class HelloMain {
public static void main(String[] args) {
AbstractApplicationContext context
=new GenericXmlApplicationContext("context-*.xml");
HelloController controller=context.getBean(HelloController.class);
controller.hello("hoho");
context.close();
}
}
prototpye๊ณผ singleton
์คํ๋ง ์ปจํ ์ด๋๋ ๋น ์์ฑํ ๋ (singletonํจํด ์์ด๋) ์ปจํ ์ด๋ ํด๋์ค๋น ํ ๊ฐ์ ์ธ์คํด์ค๋ง ์์ฑํ๋ค.
์คํ๋ง์ ์ฑ๊ธํค ํจํด์ด ์๋ ์ฑ๊ธํค ๋ ์ง์คํธ๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ์ผ๋ฐ ํด๋์ค๋ ์ฑ๊ธํค์ฒ๋ผ ๊ด๋ฆฌํด์ค๋ค.
binํ๊ทธ์ scope (์๋ช ์ฃผ๊ธฐ) ์์ฑ ์ด์ฉํด์ bean์ด ์ฑ๊ธํค์ผ๋ก ์์ฑ๋๊ฒ ํ ์ง ์ค์ ํ ์ ์๋ค
<bean>ํ๊ทธ์ scope ์์ฑ
scope์์ฑ ๊ฐ | ์ค๋ช |
singleton | ํ๊ฐ์ ์ธ์คํด์ค๋ง ์์ฑ (๊ธฐ๋ณธ๊ฐ) |
prototype | ๋น ์ฉ์ฒญํ ๋ ๋ง๋ค ์ธ์คํด์ค ์์ฑ |
thread | ์ค๋ ๋๋ณ๋ก ์์ฑ. ์คํ์ค์ธ ์ค๋ ๋์ ์ข ์๋๋ค. |
request | HTTP์์ฒญ๋ง๋ค ๋น ๊ฐ์ฒด ์์ฑ |
session | HTTP ์ธ์ ๋ง๋ค ๋น ๊ฐ์ฒด ์์ฑ |
application | singleton ์ค์ฝํ์ ์ ์ฌ. |
globalSession | ๊ธ๋ก๋ฒ HTTP์ธ์
์ ๋ํ ๋น ๊ฐ์ฒด ์์ฑ Portlet ์ง์ํ๋ ์ปจํ ์คํธ์๋ง ์ ์ฉ ๊ฐ๋ฅ ๊ธ๋ก๋ฒ ์ธ์ ์ด ์์ผ๋ฉด ์ธ์ ์ค์ฝํ์ ๊ธฐ๋ฅ์ด ๊ฐ๋ค |
+) singleton, prototype ์ฐจ์ด ์๊ธฐ ์ํด ๋ ๊ฐ์ฒด getBean()๋ฉ์๋๋ก ์ ๋ฌ๋ฐ์ ==์ฐ์ฐ์๋ก ๋น๊ตํ๋ฉด ๊ฐ์์ง ์ ์ ์๋ค.
์์
XML์ด์ฉํ์ฌ ๋น ์์ฑํ ๋ bbean scope์ง์
<bean id="HelloService" class="com.example.myapp.di.HelloService" scope="prototype"/>
Annotation์ผ๋ก ์์กด์ฑ ์ค์ ์ bean scope์ง์
@Controller
@Scope("prototype")
public class HelloService implements IHelloService { }
์๋ฐ ํด๋์ค ์ด์ฉํ์ฌ ๋น ์์ฑ+์์กด์ฑ ์ฃผ์
@Configuration
@ComponentScan(basePackages={"com.example.myapp"})
@ImportResource(value={"classpath:application-config.xml"})
public class AppConfig {
@Bean
@Scope("prototype")
IHelloService helloService() {
return new HelloService();
}
Main ํด๋์ค์์ bean 2๊ฐ ๋น๊ตํด ๋ณด๊ธฐ
package com.example.myapp.di;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class HelloMain {
public static void main(String[] args) {
AbstractApplicationContext context = ... ์๋ต ...;
HelloService s1 = context.getBean(HelloService.class);
HelloService s2 = context.getBean(HelloService.class);
System.out.println(s1==s2);
...
}
์ปฌ๋ ์ ํ์ ์์กด์ฑ ์ค์
์์กด์ฑ ์ฃผ์ ํด์ผ ํ ๋ฉค๋ฒ ๋ณ์ ํ์ ์ด ๋ฐฐ์ด, ์ปฌ๋ ์ ํ์ ๋ฑ์ผ ๋
์คํ๋ง ์ค์ ํ์ผ๋ก ์์กด์ฑ ์ฃผ์ ๊ฐ๋ฅ
pom.xml
lombok ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์กด์ฑ ์ถ๊ฐ
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.28</version>
</dependency>
Customer.java
package com.example.myapp.di;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import lombok.Getter;
import lombok.Setter;
@Getter @Setter
public class Customer {
private List<String> nameList;
private Set<String> emailList;
private Map<Integer, String> departmentInfo;
private Properties jobInfo;
}
์คํ๋ง ์ค์ ํ์ผ์ ์์กด์ฑ ์ฃผ์ ํ ๋ ํ๊ทธ
ํ๊ทธ | ํ์ |
<list> | java.util.List ๋๋ ๋ฐฐ์ด |
<set> | java.util.Set |
<map> | java.util.Map |
<props> | java.util.Properties |
<list>
=๋ฐฐ์ด, List ํ์ ์์ฑ ์ฌ์ฉ
<value> ๋ฐ์ดํฐํ์ด๋น String์ด๊ฑฐ๋ ๊ธฐ๋ณธ ์๋ฃํ์ผ ๋ ์ฌ์ฉ
<ref> List๊ฐ ์ด๋ฏธ ์ ์๋์ด ์๋ ๋ค๋ฅธ ๋น ๊ฐ์ง ๋ ์ฌ์ฉ
<bean> ๋ฏธ๋ฆฌ ์ ์๋์ด ์๋ ๋น์ด ์๋ ์๋ก์ด ๋น ์ง์ ์ ์ํ์ฌ ์ฌ์ฉ
<set>
<value> ๋ฐ์ดํฐํ์ด๋น String์ด๊ฑฐ๋ ๊ธฐ๋ณธ ์๋ฃํ์ผ ๋ ์ฌ์ฉ
<ref> List๊ฐ ์ด๋ฏธ ์ ์๋์ด ์๋ ๋ค๋ฅธ ๋น ๊ฐ์ง ๋ ์ฌ์ฉ
<bean> ๋ฏธ๋ฆฌ ์ ์๋์ด ์๋ ๋น์ด ์๋ ์๋ก์ด ๋น ์ง์ ์ ์ํ์ฌ ์ฌ์ฉ
<map>
<entry> key๊ฐ value ์ง์
<props>
<prop>ํ๊ทธ๋ฅผ ์์ ํ๊ทธ๋ก ๊ฐ์ง๋ค.
<prop key="key๊ฐ">ํ๋กํผํฐ ๊ฐ</prop>
์์ ) ๋น ์ค์ ํ์ผ
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="customer" class="com.example.myapp.di.Customer">
<property name="nameList">
<list>
<value>JinKyoung</value>
<value>JSook</value>
<value>HyunJeong</value>
<value>HyunJun</value>
<value>HyunSu</value>
</list>
</property>
<property name="emailList">
<set>
<value>HEOJK</value>
<value>JSOOK</value>
<value>JEONG</value>
<value>JUNE</value>
<value>SU</value>
</set>
</property>
<property name="departmentInfo">
<map>
<entry key="10" value="Administration"/>
<entry key="20" value="Marketing"/>
<entry key="30" value="Purchasing"/>
<entry key="60" value="IT"/>
</map>
</property>
<property name="jobInfo">
<props>
<prop key="SA_MAN">Sales Manager</prop>
<prop key="IT_PROG">IT Programmer</prop>
<prop key="AC_MAN">Accounting Manager</prop>
<prop key="ST_MAN">Stock Manager</prop>
</props>
</property>
</bean>
</beans>
CustomerMain.java
package com.example.myapp.di;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class CustomerMain {
public static void main(String[] args) {
AbstractApplicationContext context =
new GenericXmlApplicationContext("application-config.xml");
Customer cust = context.getBean(Customer.class);
List<String> nameList = cust.getNameList();
System.out.println(nameList);
System.out.println();
Set<String> emailList = cust.getEmailList();
System.out.println(emailList);
System.out.println();
Map<Integer, String> departmentInfo = cust.getDepartmentInfo();
System.out.println(departmentInfo);
System.out.println();
Properties jobInfo = cust.getJobInfo();
System.out.println(jobInfo);
context.close();
}
}
๊ฒฐ๊ณผ
์คํ๋ง ํ๋ก์ ํธ ๋ง๋ค๊ธฐ ์ค์ต
โ ๏ธegov 3.9 ๋๋ 3.10์์ spring legacy project ์์ฑ ๊ฐ๋ฅ
๐ณ๋ฌธ์ 1
๋ต
MemberMain.java
package com.sample.myapp.member;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class MemberMain{
public static void main(String[] args) {
AbstractApplicationContext context
=new GenericXmlApplicationContext("application-config.xml");
MemberController controller=context.getBean(MemberController.class);
controller.printInfo();
context.close();
}
}
MemberController.java
package com.sample.myapp.member;
import org.springframework.stereotype.Controller;
@Controller
public class MemberController {
IMemberService memberService;
public void setMemberService(IMemberService memberService)
{
this.memberService=memberService;
}
public void printInfo()
{
System.out.println("MemberController="+memberService.getMemberInfo());
}
}
IMemberService.java
package com.sample.myapp.member;
public interface IMemberService {
public Member getMemberInfo();
}
MemberService.java
package com.sample.myapp.member;
import org.springframework.stereotype.Controller;
@Controller
public class MemberService implements IMemberService{
@Override
public Member getMemberInfo()
{
Member member=new Member();
member.setMemberId("1234");
member.setName("hong");
member.setAge(10);
member.setEmail("h@naver.com");
return member;
}
}
Member.java
package com.sample.myapp.member;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Member {
private String memberId;
private String name;
private int age;
private String email;
}
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<bean id="memberService" class="com.sample.myapp.member.MemberService"/>
<bean id="memberController" class="com.sample.myapp.member.MemberController">
<property name="memberService" ref="memberService"/>
</bean>
</beans>
๊ฒฐ๊ณผ
๐ณ๋ฌธ์ 2
๋ต
EmpMain.java
package com.example.myapp.hr;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class EmpMain {
public static void main(String[] args) {
AbstractApplicationContext context =
new GenericXmlApplicationContext("application-config.xml");
EmpController controller = context.getBean(EmpController.class);
controller.printInfo();
context.close();
}
}
EmpController.java
package com.example.myapp.hr;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class EmpController {
private final IEmpService empService;
@Autowired
public EmpController(IEmpService empService) {
this.empService = empService;
}
public void printInfo() {
int count = empService.getEmpCount(50);
System.out.println("์ฌ์์ ์: " + count);
}
}
IEmpService.java
package com.example.myapp.hr;
public interface IEmpService {
int getEmpCount(int deptid);
}
EmpService.java
package com.example.myapp.hr;
import org.springframework.stereotype.Controller;
@Controller
public class EmpService implements IEmpService {
@Override
public int getEmpCount(int deptid)
{
if(deptid==50)
{
return 5;
}
else {
return 0;
}
}
}
Employee.java
package com.example.myapp.hr;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Employee {
private int employeeId;
private String firstName;
private String lastName;
private String email;
private String phoneNumber;
private java.sql.Date hireDate;
private String jobId;
private double salary;
private double commissionPct;
private int managerId;
private int departmentId;
}
application-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.example.myapp.hr" />
</beans>
๊ฒฐ๊ณผ