스프링프레임워크 & 마이바티스 무.료 강의자료 제공 (Spring IoC & DI)_ 구로자바학원/구로오라클학원/구로IT학원

Spring Framework & MyBatis
스프링 프레임워크 & 마이바티스 강의
탑크리에듀 교육센터

1. 스프링 프레임워크 개요
2. Spring IoC & DI
2.5 Spring DI(Dependency Injection)
2.5.1 세터 주입(Setter Injection) – XML 기반
2.5.2 세터 주입(Setter Injection) – 어노테이션 기반
2.5.3 생성자 주입(Constructor Injection) – XML 기반
2.5.4 생성자 주입(Constructor Injection) – 어노테이션 기반
2.5.5 메소드 주입(Method Injection)
2.5.5.1 Method Injection(Method Replace)
2.5.5.2 Method Injection(Getter Injection)
CONTENTS
1. 스프링 프레임워크 개
2.5.6 Simple Value Injection
2.5.7 SpEL을 이용한 Value Injection(XML 방식)
2.5.8 SpEL을 이용한 Value Injection(어노테이션 방식)
2.5.9 ref 태그를 이용한 Value Injection(ref local, ref bean, id, name의 차이)
2.5.10 스프링에서 XML 설정 파일의 분리
2.5.11 ApplicationContext의 분리(부모, 자식)
2.5.12 컬렉션 주입(Collection Injection), XML 방식
2.5.12 컬렉션 주입(Collection Injection), 어노테이션 방식

2. Spring IoC & DI
2-5. Spring DI(Dependency Injection)
2-5-1. 세터 주입(Setter Injection) – XML 기반
 [Emp.java]
package edu.ojc.setter1;
interface Emp {
public abstract void gotoOffice();
public abstract void getoffWork();
}
: 세터주입은 클래스 사이의 의존관계를 연결시키기 위해 setter 메소드를 이용하는 방법이다.
 [Programmer.java]
class Programmer implements Emp {
public void gotoOffice() {
System.out.println("프로그래머 출근 합니다.");
}
public void getoffWork() {
System.out.println("프로그래머 퇴근 합니다.");
}
}

2. Spring IoC & DI
 [Designer.java]
class Designer implements Emp {
System.out.println("디자이너 출근 합니다.");
}
System.out.println("디자이너 퇴근 합니다.");
}
}
 [Develop.java]
public class Develope {
Emp emp;
public void setEmp(Emp emp) {
this.emp = emp;
}
void coding() {
emp.gotoOffice();
System.out.println("개발합니다...");
emp.getoffWork();
}
}

2. Spring IoC & DI
 [Src/main/resources/ojc1.xml]
– p 네임스페이스를 이용한 세터주입
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="programmer" class="edu.ojc.setter1.Programmer" />
<bean id="designer" class="edu.ojc.setter1.Designer" />
<bean id="develope" class="edu.ojc.setter1.Develope" p:emp-ref="programmer" />

</beans>
 [TestMain.java]
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestMain {
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("ojc1.xml");
Develope dev = (Develop)context.getBean("develope");
dev.coding();
}
}

2. Spring IoC & DI
2-5-2. 세터 주입(Setter Injection) – 어노테이션 기반
 [Emp.java]
interface Emp {
}
import org.springframework.stereotype.Service;
@Service
}
}
}
 [Designer.java]
@Service
}
}
}

2. Spring IoC & DI
 [Develop.java]
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
@Service
Emp emp;
@Autowired
@Qualifier("programmer")
public void setEmp(Emp emp) {
this.emp = emp;
}
void coding() {
emp.gotoOffice();
emp.getoffWork();
}
}
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-
4.2.xsd">
<context:component-scan base-
package="edu.ojc.setter2"/>
</beans>

2. Spring IoC & DI
 [TestMain.java]
import org.springframework.context.support.ClassPathXmlApplicationContext;
ApplicationContext context = new ClassPathXmlApplicationContext("ojc1.xml");
dev.coding();
}
}

2. Spring IoC & DI
2-5-3. 생성자 주입(Constructor Injection) – XML 기반
 [Emp.java]
package edu.ojc.constructor1;
interface Emp {
}
}
}
}
 [Designer.java]
}
}
}

2. Spring IoC & DI
 [Develop.java]
Emp emp;
public Develope(Emp emp) {
this.emp = emp;
}
void coding() {
emp.gotoOffice();
emp.getoffWork();
}
}
– C 네임스페이스를 이용한 세터주입
xmlns:c="http://www.springframework.org/schema/c"
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="programmer" class="edu.ojc.constructor1.Programmer" />
<bean id="designer" class="edu.ojc.constructor1.Designer" />
<bean id="develope" class="edu.ojc.constructor1.Develope" c:emp-
ref="programmer" />

</beans>

2. Spring IoC & DI
 [TestMain.java]
ApplicationContext context = new ClassPathXmlApplicationContext("ojc3.xml");
Develope dev = (Develope)context.getBean("develope");
dev.coding();
}
}

2. Spring IoC & DI
2-5-4. 생성자 주입(Constructor Injection) – 어노테이션 기반
 [Emp.java]
interface Emp {
}
@Service
}
}
}
 [Designer.java]
@Service
}
}
}

2. Spring IoC & DI
 [Develop.java]
import org.springframework.beans.factory.annotation.Qualifier;
@Service
Emp emp;
@Autowired
public Develope(@Qualifier(value="programmer") Emp emp) {
this.emp = emp;
}
void coding() {
emp.gotoOffice();
emp.getoffWork();
}
}

2. Spring IoC & DI
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<context:component-scan base-
package="edu.ojc.constructor2"/>
</beans>

2. Spring IoC & DI
 [TestMain.java]
ClassPathXmlApplicationContext("ojc4.xml");
dev.coding();
}
}

2. Spring IoC & DI
2-5-5. 메소드 주입(Method Injection)
: Method 정의 전체에 Bean을 주입하는 것으로 Method Replace와 Getter Injection으로 구별할 수 있다.
 Method Replace(메소드 대체) : 기존 메소드를 런타임 중에 새로운 구현으로 대체
 Getter Injection(게터 주입) : 기존 메소드를 런 타임 중에 spring Context로 부터 특정한 빈을 반환하
는 새로운 구현으로 대체. Method 주입의 특별한 경우로 Method가 특정 타입의 빈을 반환하도록 선언
해 두고(보통 abstract) 런타임 중 실제 반환되는 빈은 Spring Context에서 오도록 하는 방법
2-5-5-1. Method Injection(Method Replace)
 [Emp.java]
package ojc1;
public interface Emp {
public String work();
}
package ojc1;
public class Programmer implements Emp {
public String work() {
return
"Programmer Working...";
}
}

2. Spring IoC & DI
 [Designer.java]
package ojc1;
import java.lang.reflect.Method;
import
org.springframework.beans.factory.support.MethodReplacer;
public class Designer implements MethodReplacer {
public Object reimplement(Object target,
Method method, Object[] args) throws Throwable {
return "Designer Working...";
}
}
 [MethodReplaceTest.java]
package ojc1;
public class MethodReplaceTest {
Emp programmer;
public void setProgrammer(Programmer programmer) {
this.programmer = programmer;
}
ClassPathXmlApplicationContext("lookup.xml");
MethodReplaceTest test = (MethodReplaceTest)
context.getBean("methodReplaceTest");
//Programmer의 work()가 아닌 대체자인 Designer의 work()가 실행됨
System.out.println(test.programmer.work());
}
}

2. Spring IoC & DI
 [/src/main/resources/lookup.xml]
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
<bean id="programmer" class="ojc1.Programmer">
<replaced-method name="work" replacer="designer" />
</bean>
<bean id="designer" class="ojc1.Designer" />
<bean id="methodReplaceTest" class="ojc1.MethodReplaceTest">
<property name="programmer" ref="programmer"/>
</bean>
</beans>

2. Spring IoC & DI
2-5-5-2. Method Injection(Getter Injection)
 [/src/main/resources/lookup.xml]
<bean id="programmer" class="ojc1.Programmer">
<replaced-method name="work" replacer="designer" />
</bean>
<bean id="designer" class="ojc1.Designer" />
<bean id="methodReplaceTest" class="ojc1.MethodReplaceTest">
<property name="programmer" ref="programmer"/>
</bean>
</beans>

2. Spring IoC & DI
2-5-5-2. Method Injection(Getter Injection)
 [EmpTest.java]
package ojc2;
public class EmpTest {
public static void main(String[] args) throws Exception{
ApplicationContext ctx = new ClassPathXmlApplicationContext("emp.xml");
Emp emp = (Emp) ctx.getBean("emp");
emp.work();
}
}

2. Spring IoC & DI
2-5-6. Simple Value Injection
 [XML]
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd">
<bean name="sample" class="onj.value.injection.ValueInjectionExam">
<property name="name">
<value>onj</value>
</property>
<property name="age">
<value>6</value>
</property>
</bean>
</beans>
 빈 정의 XML 파일에서 property 태그의 value 태그로 값을 지정하며 String으로 값을 읽는다.
 property의 value를 주입 받는 빈에서는 setter를 만들어야 한다.
 [자바 코드]
private String name;
private String age;
//빈 정의 XML에서 name이라는 Property의 value 값을 주입 받음
public void setName(String name) { this.name = name; }
//빈 정의 XML에서 age라는 Property의 value 값을 주입 받음
public void setAge(String age) { this.age = age; }

2. Spring IoC & DI
2-5-7. SpEL을 이용한 Value Injection(XML 방식)
 Spring 3.X에서 추가된 기능으로 SpEL을 이용하면 동적으로 표현 식을 해석하고 그 결과를 Spring의 Application
Context에서 사용할 수 있다. 결국 동적으로 생성된 값을 다른 자바 빈에 주입할 수 있다.
 [app-context2.xml]
<bean name="onj" class="onj.spel.injection.Onj"/>
<bean name="sample" class="onj.spel.injection.SpelInjectionExam">
<property name="name">
<value>#{onj.name}</value>

</property>
<property name="age">
<value>#{onj.age}</value>
</property>
</beans>

2. Spring IoC & DI
 [Onj.java]
package onj.spel.injection;
public class Onj {
private String name="OnJ";
private String age = "10";
/*
app-context2.xml에서 SpelInjectionExam 에 값을 주입하기 위해 getter만 만듬
#{onj.name} 구문에 의해 getter가 호출되고 그 값이 SpelInjectionExam에 주입된다.
*/
public String getName() {
return name;
}
public String getAge() {
return age;
}
}

2. Spring IoC & DI
 [SpelInjectionExam.java]
import org.springframework.context.support.GenericXmlApplicationContext;
public class SpelInjectionExam {
private String age;
// 빈 정의 XML에서 name이라는 Property의 value 값을 주입 받음
public void setName(String name) {
this.name = name;
}
// 빈 정의 XML에서 age라는 Property의 value 값을 주입 받음
public void setAge(String age) {
this.age = age;
}
// 빈 정의 XML에서 age라는 Property의 value 값을 주입 받음
this.age = age;
}
public String toString() {
return "This is spel injection example... " +
"Your name is " + name + " age is " + age;
}
GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.load("classpath:app-context2.xml");
ctx.refresh();
SpelInjectionExam sample = (SpelInjectionExam) ctx.getBean("sample");
System.out.println(sample);
}
}
[결과]
This is spel injection example... Your name is OnJ age is 10

2. Spring IoC & DI
2-5-8. SpEL을 이용한 Value Injection(어노테이션 방식)
<context:annotation-config/>
<context:component-scan base-package="onj.spel.annotation" />
</beans>

2. Spring IoC & DI
 [Onj.java]
public class Onj {
/*
app-context2.xml에서 SpelInjectionExam 에 값을 주입하기 위해 getter만 만듬
#{onj.name} 구문에 의해 getter가 호출되고 그 값이 SpelInjectionExam에 주입된다.
*/
return name;
}
return age;
}
}

2. Spring IoC & DI
 [SpelInjectionExam.java]
package onj.spel.annotation;
import org.springframework.beans.factory.annotation.Value;
@Service("sample")
public class SpelInjectionExam {
private String age;
/* Onj객체의 getName을 호출해 값을 세팅 */
@Value("#{onj.name}")
public void setName(String name) {
this.name = name;
}
/* Onj객체의 getAge를 호출해 값을 세팅 */
@Value("#{onj.age}")
this.age = age;
}
return "This is spel injection example... " + "Your name is " + name + ", age is " + age;
}
ctx.refresh();
SpelInjectionExam sample = (SpelInjectionExam) ctx.getBean("sample");
}
}
[결과]
This is spel injection example... Your name is OnJ age is 10

2. Spring IoC & DI
2-5-9. ref 태그를 이용한 Value Injection(ref local, ref bean, id, name의 차이)
 하나의 빈을 다른 빈에 주입하기 위해 두 개의 빈 설정이 필요한데 하나의 빈은 주입될 빈이고, 다른 빈은 타깃이 되는 빈에
대한 설정이다. 주입될 빈과 타깃에서 setter로 정의한 빈은 서로 호환이 되기만 하면 된다. (타깃에서 정의한 빈이 인터페이
스이면 주입될 빈은 인터페이스를 구현한 클래스면 된다.)
 빈 정의는 같은 XML 파일 내에 있어야 하는데 만약 다른 이름의 빈을 주입하거나 다른 설정파일에서 빈을 찾으려면 <ref>
태그의 bean 속성을 사용해야 한다.
 ref태그를 사용하여 주입하며 ref태그는 항상 property 나 constructor-arg 다음에 나와야 한다.
<bean id="onj" name="onjName" class="onj.ref.injection.Onj"/>
<bean id="sample" name="sampleName" class="onj.ref.injection.RefInjectionExam">
<property name="onj">
<ref bean="onj"/> 
</property>
</bean>
</beans>

2. Spring IoC & DI
 [Onj.java]
package onj.ref.injection;
public class Onj {
return name;
}
return age;
}
}
 [RefInjectionExam.java]
package onj.ref.injection;
import
org.springframework.context.support.GenericXmlApplicationContext;
public class RefInjectionExam {
private Onj onj;
public void setOnj(Onj onj) { this.onj = onj;}
return "This is ref injection example... " +
"Your name is " + onj.getName() + ", age is " +onj.getAge();
}
ctx.refresh();
RefInjectionExam sample = (RefInjectionExam) ctx.getBean("sample");
}
}

2. Spring IoC & DI
 bean vs local
1. <ref bean=“onjBean”/>
가장 일반적인 형태,
동일한/상위 Bean Factory or
Application Context 내에서 자
바 빈을 검색, 물론 동일한 XML
설정 파일 내부가 아니더라도
관계 없다. 찾고자 하는 onj
Bean은 id, name 어느 것이나
정의되어 있으면 된다.
2. <ref local= “onjBean” />
동일한 XML 설정 파일내에서
onjBean을 검색하며 onjBean은
bean정의의 id, name 어느 것
이나 정의되어 있으면 된다.
Spring4에서 local을 더 이상 사
용하지 않는다. 스프링4 이상이
라면 <ref bean=“”/>을 사용하
자.
 빈 정의시 id 와 name의 차이
 id or bean은 하나의 XML 파일에서는 하나만 정의가능(유일)
 id는 오로지 하나, name은 여러 개 정의 가능하다.
<bean id="foo" name = "foo1, foo2" class="ojc.Foo"/>
Foo f1 = (Foo) context.getBean("foo");
Foo f2 = (Foo) context.getBean("foo1");
Foo f3 = (Foo) context.getBean("foo2");
 다른 설정파일에 name이 같은 빈을 정의할 수 있다. id는 불가.
1. [bean1.xml]
<bean id="foo" name = "king,
queen" class="ojc.Foo"/>
2. [bean2.xml]
<bean id="bar" name = "king" class="ojc.Bar"/>
FileSystemXmlApplicationContext context =
new FileSystemXmlApplicationContext(new String[] { "beans2.xml", "beans1.xml" });
Foo f = (Foo) context.getBean("king");
bean1.xml 파일이 나중에 로딩되므로 bean1.xml의 king이 로드된다.

2. Spring IoC & DI
2-5-10. 스프링에서 XML 설정 파일의 분리
: XML 설정파일을 여러 개로 분리할 수 있으며 이 경우 ref bean 태그를 사용하여 자바 빈을 로딩 하면 된다.
Application Context를 생성할 때 여러 XML 파일명을 문자열 배열로 넣어주면 된다.
 [Dog.java]
package ojc.spring.twoxml;
public interface Dog {
public void jitda();
}
 [Jindo.java]
import
org.springframework.stereotype.Component;
public class Jindo implements Dog{
public void jitda() {
System.out.println("진도진도~");
}
}
 [Pudle.java]
import
org.springframework.stereotype.Component;
public class Pudle implements Dog {
public void jitda() {
System.out.println("푸들푸들~");
}
}

2. Spring IoC & DI
 [DogManager.java]
import
org.springframework.beans.factory.annotation.Autowired;
public class DogManager {
private Pudle pudle;
private Jindo jindo;
public void setPudle(Pudle pudle) {
this.pudle = pudle;
}
public void setJindo(Jindo jindo) {
this.jindo = jindo;
}
public void walwal() {
this.jindo.jitda();
this.pudle.jitda();
}
}
 [DogApp.java]
import
org.springframework.context.support.ClassPathXmlApplicationContext;
public class DogApp {
ApplicationContext context =
new ClassPathXmlApplicationContext(new String[]
{"applicationContext.xml", "dog.xml"});
DogManager dManager = (DogManager)
context.getBean("dogManager");
dManager.walwal();
}
}

2. Spring IoC & DI
 [DogManager.java]
[src/main/resources/applicationContext.xml]
xsi:schemaLocation="http://www.springframework.org/schem
a/beans http://www.springframework.org/schema/beans/spring-beans-
4.2.xsd">
<bean id="dogManager" class="ojc.spring.twoxml.DogManager">
<property name="pudle">
<ref bean="pudle"></ref>
</property>
<property name="jindo">
<ref bean="jindo"></ref>
</property>
</bean>
</beans>
 [src/main/resources/dog.xml]
<bean id="pudle" class="ojc.spring.twoxml.Pudle"/>
<bean id="jindo" class="ojc.spring.twoxml.Jindo"/>
</beans>
[결과]
진도진도~
푸들푸들~

2. Spring IoC & DI
2-5-11. Application Context의 분리(부모, 자식)
: 한 컨텍스는 다른 컨텍스트의 부모가 될 수 있다. 자식 컨텍스에 있는 빈이 부모 컨텍스트에 있는 빈 참조 가능한데
스프링은 ApplicationContext 중첩 기능을 제공 함으로서 설정을 여러 파일로 나눌 수 있게 해준다. 자식 컨텍스트에
서 부모 컨텍스트의 빈을 참조하는 방식은 동일하다. 단 이름이 같은 것이 있다면 ref 태그에서 parent 속성을 사용하
면 된다.
 [parent.xml]
<bean id="parent1" class="java.lang.String">
<constructor-arg>
<value>parent bean 1</value>
</constructor-arg>
</bean>
<constructor-arg>
<value>parent bean 2</value>
</constructor-arg>
</bean>
</beans>

2. Spring IoC & DI
 [child.xml]
<bean id="target1" class="onj.context.overlap.Onj">
<property name="val1">
<ref bean="parent1"/>
</property>
</bean>
<bean id="target2" class="onj.context.overlap.Onj">
<property name="val2">
<ref parent="parent2"/> <!– 부모 context에서 parent2라는 id,name을 검색 
</property>
</bean>
<constructor-arg>
<value>child bean 2</value>
</constructor-arg>
</bean>
</beans>
 [Onj.java]
package onj.context.overlap;
public class Onj {
private String val1;
private String val2;
public String getVal1() {
return val1;
}
public void setVal1(String val1) {
this.val1 = val1;
}
public String getVal2() {
return val2;
}
public void setVal2(String val2) {
this.val2 = val2;
}
}

2. Spring IoC & DI
 [ContextOverlapExam.java]
package onj.context.overlap;
public class ContextOverlapExam {
GenericXmlApplicationContext parent = new GenericXmlApplicationContext();
parent.load("classpath:parent.xml");
parent.refresh();
GenericXmlApplicationContext child = new GenericXmlApplicationContext();
child.load("classpath:child.xml");
child.setParent(parent);
child.refresh();
Onj target1 = (Onj) child.getBean("target1");
Onj target2 = (Onj) child.getBean("target2");
String target3 = (String) child.getBean("parent2");
System.out.println(target1.getVal1());
System.out.println(target2.getVal2());
System.out.println(target3);
}
}

2. Spring IoC & DI
2-5-12. 컬렉션 주입(Collection Injection), XML 방식
<bean id="onj" name="onjName" class="onj.injection.collection.Onj"/>
<bean id="sample" class="onj.injection.collection.CollectionExam">
<property name="map">
<map>
<entry key="someValue">
<value>hello map...</value>
</entry>
<entry key="someBean">
<ref bean="onj"/>
</entry>
</map>
: 한 컨텍스는 다른 컨텍스트의 부모가 될 수 있다. 자식 컨텍스에 있는 빈이 부모 컨텍스트에 있는 빈 참조 가능한데
스프링은 ApplicationContext 중첩 기능을 제공 함으로서 설정을 여러 파일로 나눌 수 있게 해준다. 자식 컨텍스트에
서 부모 컨텍스트의 빈을 참조하는 방식은 동일하다. 단 이름이 같은 것이 있다면 ref 태그에서 parent 속성을 사용하
면 된다.
</property>
<property name="set">
<set>
<value>hello list...</value>
<ref bean="onj"/>
</set>
</property>
<property name="props">
<props>
<prop key="firstName">Jong Cheol</prop>
<prop key="lastName">Lee</prop>
</props>
</property>
</bean>
</beans>

2. Spring IoC & DI
2-5-12. 컬렉션 주입(Collection Injection), XML 방식
 [CollectionExam.java]
public void display() {
for(Map.Entry<String, Object> entry:map.entrySet()) {
System.out.println("Key: " + entry.getKey() + "-" + entry.getValue());
}
for(Map.Entry<Object, Object> entry : props.entrySet()) {
System.out.println("key : " + entry.getKey() + "-" + entry.getValue() );
}
for(Object obj : set) {
System.out.println("value : " + obj);
}
}
ctx.refresh();
CollectionExam col = (CollectionExam)ctx.getBean("sample“)
col.display();
}

2. Spring IoC & DI
2-5-12. 컬렉션 주입(Collection Injection), 어노테이션 방식
xmlns:util="http://www.springframework.org/schema/util"
http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.2.xsd">
<context:annotation-config/>
<context:component-scan base-package="onj.collection.annotation" />
<bean id="onj" name="onjName" class="onj.collection.annotation.Onj"/>
<util:map id="map" map-class="java.util.HashMap">
</entry>
<entry key="someBean">
<ref ben="onj"/>
</entry>
</util:map>
<util:properties id="props">
<prop key="firstName">Jong Cheol</prop>
<prop key="lastName">Lee</prop>
</util:properties>
<util:set id="set">
<value>hello.... set</value>
<ref bean="onj"/>
</util:set>
</beans>

2. Spring IoC & DI
2-5-12. 컬렉션 주입(Collection Injection), 어노테이션 방식
 [Onj.java]
package onj.collection.annotation;
@Service("onj")
public class Onj {
return "my name is OnJ";
}
}
 [CollectionAnnotationExam.java]
…
…
@Service("sample")
public class CollectionAnnotationExam {
@Resource(name="map")
private Map<String, Object> map ;
@Resource(name="props")
private Properties props;
@Resource(name="set")
private Set<Object> set;
…
…
…

Any Questions ?
THANK YOU
FOR YOUR ATTENTION
무료국비지원교육 / 구로자바학원 _ 탑크리에듀 교육센터
http://www.topcredu.co.kr

스프링프레임워크 & 마이바티스 무.료 강의자료 제공 (Spring IoC & DI)_ 구로자바학원/구로오라클학원/구로IT학원

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to 스프링프레임워크 & 마이바티스 무.료 강의자료 제공 (Spring IoC & DI)_ 구로자바학원/구로오라클학원/구로IT학원 (20)

More from 탑크리에듀(구로디지털단지역3번출구 2분거리) (20)

스프링프레임워크 & 마이바티스 무.료 강의자료 제공 (Spring IoC & DI)_ 구로자바학원/구로오라클학원/구로IT학원