Study Web Development

2월 23일

이전으로

Spring

1. 스프링 기초

1-1 스프링 프레임워크란?

JSP/Servlet은 소규모 컨테이너로, 트래픽이 많은 경우 서비스가 불안정한 문제가 있어 중량급 컨테이너 J2EE EJB가 개발됨
EJB는 트래픽이 많아도 서비스가 안정적인 대신, 일반 사용자가 체감할 만큼 속도가 전반적으로 느리다는 문제가 있으며, 배포하려면 전용 서버에 전용 형식 압축 파일을 만들어야 하는 등 개발 과정이 복잡함(JSP/Servlet은 파일만 만들면 톰캣으로 바로 구동되고 수정을 바로 바로 확인할 수 있는 것과 대조적)
Spring 프레임워크는 무겁고 복잡한 EJB의 단점을 극복한 경량 컨테이너
- 고유의 뼈대 혹은 기반 구조를 가지고 있으므로, 문법이 강요됨
- JSP/Servlet은 web.xml과 *.properties 외에 설정 정보가 없지만, Spring은 설정 정보가 많은 편
- 가벼운 편이라고는 해도, 홍보용 웹 사이트처럼 단순한 사이트를 만들 때는 JSP/Servlet이 더 적절하고 규모 있는 사이트를 만들 때 Spring

소프트웨어 프레임워크

소프트웨어 시스템에 대한 라이브러리 또는 클래스의 재사용 세트
개발 용이성
- 공통 기능은 프레임워크가 제공하여 패턴 기반 개발과 비즈니스 로직에만 집중한 개발 가능
운영 용이성
- 비즈니스 로직/아키텍처 파악이 용이하여 변경이 용이함
시스템 복잡도의 감소
- 복잡한 기술은 프레임워크에 의해 숨겨지며, 미리 잘 정의된 기술 세트가 적용됨
개발 코드의 최소화
- 공통 컴포넌트와 서비스를 활용하여 반복 개발 제거
이식성
- 플랫폼과의 연동을 프레임워크가 제공하므로 플랫폼 비의존적인 개발 가능
변경 용이성
- 잘 구조화된 아키텍처가 적용되어 플랫폼에 비의존적
품질 보증
- 검증된 개발 기술과 패턴에 따른 개발
설계와 코드의 재사용성
- 프레임워크의 서비스 및 패턴, 사전에 개발된 컴포넌트가 재사용됨

1-2 스프링 프레임워크 특징

경량
- Spring은 여러 개의 모듈로 구성되어 있고, 각 모듈은 하나 이상의 JAR 파일로 구성되어 있음
- JAR 파일들만 있으면 개발과 실행이 모두 가능하며 JAR 파일들의 크기도 작아 Spring을 이용해서 만든 애플리케이션의 배포는 매우 빠르고 쉬움
Inversion of Control(IoC) 컨테이너
- IoC 컨테이너는 자바 객체의 생성, 소멸과 같은 라이프 사이클을 관리하며, Spring 컨테이너로부터 필요한 객체를 가져와 사용
  - IoC가 적용되기 전에는 애플리케이션 수행에 필요한 객체의 생성이나 객체 간 의존 관계를 개발자가 직접 처리해야 했지만, IoC가 적용되면 컨테이너가 대신 처리함
  - Spring의 기능을 사용하려면 Spring 컨테이너에 객체를 저장해야 하며, Spring 문법을 따르지 않고 생성한 일반적인 객체는 IoC 컨테이너에 의해 관리되지 않음
Dependency Injection(DI) 지원
- 설정 파일이나 어노테이션을 통해 객체 간의 의존 관계를 설정(=주입)
Aspect Oriented Programming(AOP) 지원
- 공통으로 사용하는 기능들을 외부의 독립된 클래스로 분리하고, 해당 기능을 프로그램 코드에 직접 명시하지 않고 선언적으로 처리하여 적용
- 트랜잭션, 로깅, 보안 등 여러 모듈에서 공통으로 필요하지만 실제 모듈의 핵심은 아닌 기능들을 분리
Plain Old Java Object(POJO) 지원
트랜잭션 처리를 위한 일관된 방법 제공
JDBC, MyBatis(iBatis), 하이버네트, JPA 등 데이터베이스 처리를 위한 라이브러리 연동;
JMS, 메일, 스케줄링 등 엔터프라이즈 어플리케이션을 개발하는 데 필요한 다양한 API 연동
Spring MVC
- Model, View, Container 사이의 의존 관계를 컨테이너에서 관리

1-3 스프링 프레임워크 설치

eGovFrame 사용

Open Perspective-Spring 선택
Package Explorer에서 New-Spring Legacy Project 선택하고, 프로젝트명에 ch01DI 입력 후 Spring MVC Project를 선택 후 Next
프로젝트 최상위 패키지명을 kr.spring.di로 입력 후 Finish
src/main/resources에 설정 파일을 보관하며, src/main/webapp/resources는 CSS나 이미지 등을 보관
pom.xml 열고 편집 가능하도록 하단에서 pom.xml 탭을 선택하여 <properties> 태그 사이의 내용을 다음처럼 수정

		<java-version>1.8</java-version>
		<org.springframework-version>5.0.20.RELEASE</org.springframework-version>

프로젝트의 Properties에서 Java Build Path의 JRE System Library와 Project Facets의 Java 버전을 1.8로 변경
kr.spring.di 패키지 삭제

Maven

https://mvnrepository.com/

소프트웨어 개발시 반복되는 작업을 자동화하는 빌드 도구
표준 프로젝트를 일관된 방식과 구조로 관리, 배포, 운영 가능
필요한 라이브러리는 lib 폴더에 넣는 것이 아니라, pom.xml에 groupId, artifactId, version을 지정하면 메이븐이 전용 서버에서 다운로드받아 통합적으로 관리
- 프로젝트 디펜던시들은 C:\Users\J\.m2\repository에 저장됨
라이브러리 버전에 따라 호환성 문제가 발생할 수 있으므로 신경써야 함

2. 스프링 DI와 객체 관리

2-1 DI란

어떤 객체의 속성에 그 객체가 사용할 다른 객체를 설정(=주입)하는 것

2-2 Bean 객체 설정 및 컨테이너를 통한 Bean 객체 사용

src/main/java를 오른쪽 클릭하고 새 패키지 kr.spring.ch01 생성 후 새 클래스 MessageBean 생성

package kr.spring.ch01;

public class MessageBean {
	public void sayHello(String name) {
		System.out.println("Hello, " + name);
	}
}

src/main/resources를 오른쪽 클릭하고 New-Spring Bean Configuration File 선택 후 이름에 applicationContext.xml 입력하고 Next
XSD namespace에서 aop, beans, context를 선택하고 각각 가장 위에 있는 XSD를 선택, XSD namespace에서 p를 추가로 선택하여 Next-Finish
applicationContext.xml 파일이 열리면 하단의 Source 탭 선택하고 <beans> 태그 내에 다음의 내용을 추가

	<!-- 객체 생성을 위한 설정(Spring Container) -->
	<!-- 
	name : 컨테이너에 보관되는 bean 객체를 식별할 때 사용할 이름; 생성자를 이용하여 객체 주소를 직접 얻을 수 없기 때문에 식별자가 필요하며, 식별자는 유일해야 함
	class : bean 객체를 생성할 때 사용할 클래스명
	 -->
	<bean name="messageBean" class="kr.spring.ch01.MessageBean"/>

새 클래스 SpringMain 생성

package kr.spring.ch01;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		// applicationContext.xml 설정 파일을 읽어들여 Spring Container 생성
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 식별자를 이용해 객체를 컨테이너로부터 읽어옴
		MessageBean messageBean = (MessageBean)context.getBean("messageBean");
		messageBean.sayHello("초코");
		
		// 어플리케이션 종료시 컨테이너에 존재하는 모든 bean을 종료
		context.close();
	}
}

새 패키지 kr.spring.ch02 생성하고 새 클래스 StudentBean 생성

package kr.spring.ch02;

public class StudentBean {
	public void study(String course) {
		System.out.println(course + "을 공부합니다.");
	}
}

applicationContext.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<bean name="studentBean" class="kr.spring.ch02.StudentBean"/>

kr.spring.ch02 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch02;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		// applicationContext.xml 설정 파일을 읽어들여 Spring Container를 생성
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 객체를 컨테이너로부터 읽어옴
		StudentBean studentBean = (StudentBean)context.getBean("studentBean");
		studentBean.study("개발");
		
		// 어플리케이션 종료시 컨테이너에 존재하는 모든 bean을 종료
		context.close();
	}
}

새 패키지 kr.spring.ch03 생성하고 새 클래스 OperatorBean 생성

package kr.spring.ch03;

public class OperatorBean {
	public int add(int a, int b) {
		return a + b;
	}
}

applicationContext.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<bean name="operatorBean" class="kr.spring.ch03.OperatorBean"/>

kr.spring.c03 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch03;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		// applicationContext.xml 설정 파일을 읽어들여 Spring Container를 생성
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 객체를 컨테이너로부터 읽어옴
		OperatorBean bean = (OperatorBean)context.getBean("operatorBean");
		int result = bean.add(10, 20);
		
		System.out.println("결과 : " + result);
		
		// 어플리케이션 종료시 컨테이너에 존재하는 모든 bean을 종료
		context.close();
	}
}

2-3 의존 관계 설정

2-3-1 생성자 방식

새 패키지 kr.spring.ch04 생성하고 새 클래스 WriteArticleDAO 생성

package kr.spring.ch04;

public class WriteArticleDAO {
	public void insert() {
		System.out.println("WriteArticleDAO의 insert() 메서드 실행");
	}
}

새 클래스 WriteArticleService 생성

package kr.spring.ch04;

public class WriteArticleService {
	private WriteArticleDAO writeArticleDAO;
	
	public WriteArticleService(WriteArticleDAO writeArticleDAO) {
		this.writeArticleDAO = writeArticleDAO;
	}
	
	public void write() {
		System.out.println("WriteArticleService의 write() 메서드 실행");
		
		writeArticleDAO.insert();
	}
}

applicationContext.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- 의존 관계 주입 : 생성자 방식 -->
	<bean name="writeArticleService" class="kr.spring.ch04.WriteArticleService">
		<constructor-arg>
			<!-- ref : 주입할 의존 객체에 해당하는 bean 객체의 식별값 -->
			<ref bean="writeArticleDAO"/>
		</constructor-arg>	
	</bean>
	<bean name="writeArticleDAO" class="kr.spring.ch04.WriteArticleDAO"/>

kr.spring.ch04 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch04;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		// applicationContext.xml 설정 파일을 읽어들여 스프링 컨테이너를 생성
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 컨테이너에 DI 생성자 설정 방식으로 생성된 객체를 읽어옴
		WriteArticleService articleService = (WriteArticleService)context.getBean("writeArticleService");
		articleService.write();
		
		// 어플리케이션 종료시 컨테이너에 존재하는 모든 bean을 종료
		context.close();
	}
}

kr.spring.ch05 생성 후 새 클래스 MemberDAO 생성

package kr.spring.ch05;

public class MemberDAO {
	public void register() {
		System.out.println("MemberDAO의 register() 메서드 실행");
	}
}

새 클래스 MemberService 생성

package kr.spring.ch05;

public class MemberService {
	private MemberDAO memberDAO;
	
	public MemberService(MemberDAO memberDAO) {
		this.memberDAO = memberDAO;
	}
	
	public void send() {
		System.out.println("MemberService의 send() 메서드 실행");
		memberDAO.register();
	}
}

applicationContext.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- 의존 관계 주입 : 생성자 방식 -->
	<bean name="memberService" class="kr.spring.ch05.MemberService">
		<constructor-arg>
			<!-- ref : 주입할 의존 객체에 해당하는 bean 객체의 식별값 -->
			<ref bean="memberDAO"/>
		</constructor-arg>
	</bean>
	<bean name="memberDAO" class="kr.spring.ch05.MemberDAO"/>

kr.spring.ch05 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch05;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		// applicationContext.xml 설정 파일을 읽어 들여 Spring Container를 생성
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 컨테이너에 DI 생성자 설정 방식으로 생성된 객체를 읽어옴
		MemberService memberService =  (MemberService)context.getBean("memberService");
		memberService.send();
		
		// 어플리케이션이 종료시 컨테이너에 존재하는 모든 bean을 종료
		context.close();
	}
}

새 패키지 kr.spring.ch06 생성 후 새 클래스 SmsSender 생성하고 오른쪽 클릭하여 Source-Generate toString()... 선택

package kr.spring.ch06;

public class SmsSender {
	@Override
	public String toString() {
		return "SmsSender 호출";
	}
}

새 클래스 SystemMonitor 생성하고 멤버 변수 선언 후 오른쪽 클릭한 다음 Source-Generate Constructor using Fields... 선택

package kr.spring.ch06;

public class SystemMonitor {
	private long periodTime;
	private SmsSender sender;
	
	public SystemMonitor(long periodTime, SmsSender sender) { // super()는 생략해도 암묵적으로 포함됨
		this.periodTime = periodTime;
		this.sender = sender;
	}

	@Override
	public String toString() {
		return "SystemMonitor [periodTime=" + periodTime + ", sender=" + sender + "]";
	}
}

applicationContext.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- DI 생성자 설정 방식 : 여러 개의 인자 사용 -->
	<bean name="monitor" class="kr.spring.ch06.SystemMonitor">
		<!-- (주의) 인자의 순서대로 기재 -->
		<!-- 
		<constructor-arg>
			<value>10</value>
		</constructor-arg>
		<constructor-arg>
			<ref bean="smsSender"/>
		</constructor-arg>
		 -->
		
		<!-- 속성으로 값 또는 객체 설정 -->
		<!-- 
		<constructor-arg value="20"/>
		<constructor-arg ref="smsSender"/>
		 -->
		
		<!-- 순서를 무시할 때는 index를 함께 명시 -->
		<!-- 
		<constructor-arg index="1" ref="smsSender"/>
		<constructor-arg index="0" value="30"/>
		 -->
		
		<!-- 생성자의 인자명 기재 -->
		<constructor-arg name="periodTime" value="40"/>
		<constructor-arg name="sender" ref="smsSender"/>
	</bean>
	<bean name="smsSender" class="kr.spring.ch06.SmsSender"/>

새 클래스 SpringMain 호출

package kr.spring.ch06;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		// applicationContext.xml 설정 파일을 읽어들여 Spring Container를 생성
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// DI 생성자 설정 방식
		SystemMonitor monitor = (SystemMonitor)context.getBean("monitor");
		System.out.println(monitor);
		
		context.close();
	}
}

2-3-2 프로퍼티 설정 방식

새 패키지 kr.spring.ch07 생성 후 새 클래스 RegisterDAO 생성

package kr.spring.ch07;

public class RegisterDAO {
	public void insert() {
		System.out.println("RegisterDAO의 insert() 메서드 실행");
	}
}

새 클래스 RegisterService 생성

package kr.spring.ch07;

public class registerService {
	private RegisterDAO registerDAO;
	
	// 의존 관계 설정 방식 : 프로퍼티
	public void setRegisterDAO(RegisterDAO registerDAO) { // 생성자는 기본 생성자를 사용하고, setter 메서드를 통해 객체의 주소를 전달; 표준적인 setter 메서드 명명 방식을 준수하지 않으면 에러
		this.registerDAO = registerDAO; 
	}
	
	public void write() {
		System.out.println("RegisterService의 write() 메서드 실행");
		registerDAO.insert();
	}
}

applicationContext.xml을 복사 붙여넣기하여 applicationContext2.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DI 프로퍼티 설정 방식 -->
	<!-- bean 태그의 식별자는 name으로 부여해도 되고 id로 부여해도 됨 -->
	<bean id="registerService" class="kr.spring.ch07.RegisterService">
		<property name="registerDAO">
			<!-- ref : 주입할 의존 객체에 해당하는 bean 객체의 식별값 -->
			<ref bean="registerDAO"/>
		</property>
	</bean>
	<bean id="registerDAO" class="kr.spring.ch07.RegisterDAO"/>
</beans>

kr.spring.ch07 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch07;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
		
		// DI 프로퍼티 설정 방식
		RegisterService service = (RegisterService)context.getBean("registerService");
		service.write();
		
		context.close();
	}
}

새 패키지 kr.spring.ch08에 새 클래스 EmailSender 생성

package kr.spring.ch08;

public class EmailSender {
	@Override
	public String toString() {
		return "EmailSender 호출";
	}	
}

새 패키지 WorkController 생성

package kr.spring.ch08;

public class WorkController {
	private long periodTime;
	private EmailSender email;
	
	public void setPeriodTime(long periodTime) {
		this.periodTime = periodTime;
	}
	public void setEmail(EmailSender email) {
		this.email = email;
	}
	
	@Override
	public String toString() {
		return "WorkController [periodTime=" + periodTime + ", email=" + email + "]";
	}
}

applicationContext2.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- DI 프로퍼티 설정 방식 : 여러 개의 프로퍼티 -->
	<bean id="work" class="kr.spring.ch08.WorkController">
		<!-- property 태그의 경우 항상 프로퍼티명을 명시하므로 순서 무관 -->
		<property name="periodTime">
			<value>10</value>
		</property>
		<property name="email"> <!-- WorkController의 프로퍼티명 -->
			<ref bean="email"/> <!-- bean 식별자 -->
		</property>
	</bean>
	<bean id="email" class="kr.spring.ch08.EmailSender"/>

kr.spring.ch08 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch08;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
		
		// DI 프로퍼티 설정 방식 : 여러 개의 프로퍼티 사용
		WorkController work = (WorkController)context.getBean("work");
		System.out.println(work);
		
		context.close();
	}
}

2-3-3 XML 네임스페이스를 이용한 프로퍼티 설정

새 패키지 kr.spring.ch09 생성하고 새 클래스 ImageSender 생성

package kr.spring.ch09;

public class ImageSender {
	@Override
	public String toString() {
		return "ImageSender 호출";
	}
}

새 클래스 UploadController 생성

package kr.spring.ch09;

public class UploadController {
	private long timeout;
	private ImageSender image;
	
	public void setTimeout(long timeout) {
		this.timeout = timeout;
	}
	public void setImage(ImageSender image) {
		this.image = image;
	}
	
	@Override
	public String toString() {
		return "UploadController [timeout=" + timeout + ", image=" + image + "]";
	}
}

applicationContext2.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- XML 네임스페이스를 이용한 프로퍼티 설정 -->
	<bean id="upload" class="kr.spring.ch09.UploadController" p:timeout="50" p:image-ref="image"/>
	<bean id="image" class="kr.spring.ch09.ImageSender"/>

kr.spring.ch09 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch09;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
		
		// XML 네임스페이스를 이용한 프로퍼티 설정
		UploadController upload = (UploadController)context.getBean("upload");
		System.out.println(upload);
		
		context.close();		
	}
}

2-3-6 콜렉션 타입 프로퍼티 설정

List 타입과 배열

kr.spring.ch10 패키지에 새 클래스 PerformanceMonitor 생성

package kr.spring.ch10;

import java.util.List;

public class PerformanceMonitor {
	private List<Double> deviations;

	public void setDeviations(List<Double> deviations) {
		this.deviations = deviations;
	}

	@Override
	public String toString() {
		return "PerformanceMonitor [deviations=" + deviations + "]";
	}
}

applicationContext2.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- List 타입 프로퍼티 설정 -->
	<bean id="performanceMonitor" class="kr.spring.ch10.PerformanceMonitor">
		<property name="deviations">
			<list> <!-- 컨테이너가 List 타입 객체를 생성하여 deviations에 전달 -->
				<value>0.2</value>
				<value>0.3</value>
				<!-- 문자열일 경우 <value>String</value> -->
				<!-- 객체일 경우 <ref bean="SomeDemo"/> -->
			</list>
		</property>
	</bean>

kr.spring.ch10 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch10;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
		
		// List 타입 프로퍼티 설정
		PerformanceMonitor monitor = (PerformanceMonitor)context.getBean("performanceMonitor");
		System.out.println(monitor);
		
		context.close();
	}
}

Map 타입

새 패키지 kr.spring.ch11 생성 후 새 클래스 RestHandler, SoapHandler, ProtocolHandlerFactory 생성

package kr.spring.ch11;

import java.util.Map;

public class ProtocolHandlerFactory {
	private Map<String, Object> map;

	public void setMap(Map<String, Object> map) {
		this.map = map;
	}

	@Override
	public String toString() {
		return "ProtocolHandlerFactory [map=" + map + "]";
	}
}

applicationContext2.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- Map 타입 프로퍼티 설정 -->
	<bean id="protocolHandlerFactory" class="kr.spring.ch11.ProtocolHandlerFactory">
		<property name="map">
			<map>
				<entry>
					<key><value>soap</value></key> <!-- 프로퍼티 map은 key 자료형이 String이므로 <value>로 key에 넣을 문자열 전달 -->
					<ref bean="soapHandler"/> <!-- 프로퍼티 map은 value 자료형이 Object이므로 <ref bean>으로 value에 넣을 객체 전달 -->
				</entry>
				<entry>
					<key><value>rest</value></key>
					<ref bean="restHandler"/>
				</entry>
			</map>
		</property>
	</bean>
	<bean id="soapHandler" class="kr.spring.ch11.SoapHandler"/>
	<bean id="restHandler" class="kr.spring.ch11.RestHandler"/>

kr.spring.ch11 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch11;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
		
		// Map 타입 프로퍼티 설정
		ProtocolHandlerFactory protocol = (ProtocolHandlerFactory)context.getBean("protocolHandlerFactory");
		System.out.println(protocol);
		
		context.close();
	}
}

Set 타입

새 패키지 kr.spring.ch12 생성하고 새 클래스 VideoClient 생성

package kr.spring.ch12;

import java.util.Set;

public class VideoClient {
	private Set<Integer> subSet;

	public void setSubSet(Set<Integer> subSet) {
		this.subSet = subSet;
	}

	@Override
	public String toString() {
		return "VideoClient [subSet=" + subSet + "]";
	}
}

applicationContext2.xml의 <beans> 태그 사이에 다음의 내용을 추가

	<!-- Set 타입 프로퍼티 설정 -->
	<bean id="videoClient" class="kr.spring.ch12.VideoClient">
		<property name="subSet">
			<set> <!-- 컨테이너에서 Set 타입 객체를 생성하여 subSet에 전달 -->
				<value>10</value>
				<value>20</value>
			</set>
		</property>
	</bean>

kr.spring.ch12 패키지에 새 클래스 SpringMain 생성

package kr.spring.ch12;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMain {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
		
		// Set 타입 프로퍼티 설정
		VideoClient video = (VideoClient)context.getBean("videoClient");
		System.out.println(video);
		
		context.close();		
	}
}

다음으로