[Spring] 001. Spring Framework 개요

FrameWorkStudy

Spring Framework 개요

■■■ Spring Framework 이해하기 ■■■
//-- 스프링이라는 이름이 붙은 Framework !
○ 개요
   1. Framework
      어플리케이션을 구현하고 관리하는 환경(틀, 약속)
   2. Spring Framework
      전달받은 설정 정보에 의해 어플리케이션을 구성하고, 객체를 생성, 관리하는 주체.
      //-- 문법 자체를, 컨테인너를, 문법이 적용되는 공간을, 관리/처리 방식을 스프링이라고 함
      //-- (마치 서블릿 컨테이너 처럼) 총칭하는 개념이라고 생각하면 됨
================================================================================================================================      
○ 스프링 프레임워크(Spring Framework)의 개념
   스프링은 자바 엔터프라이즈 어플리케이션 개발에 사용되는 어플리케이션 프레임워크.
   //-- 단일 모듈(또는 작은규모)프로젝트같은 경우 프레임워크로 안만드는 것이 효율성이 좋음
   
   어플리케이션 프레임워크는 어플리케이션 개발을 빠르고 효율적으로 할 수 있도록
   어플리케이션의 바탕이되는 틀과 공통 프로그래밍 모델 그리고 API 등을 제공해준다.
   //-- 틀, 프로그래밍 모델, API (프레임워크의 3요소 느낌)
 -------------------------------------------------------------------------------------------------------------------------------   
   - 어플리케이션의 기본 틀 → 스프링 컨테이너
   //-- 컨테이너 : 서블릿 컨테이너와 비슷하나 조금 더 큰 규모로 바뀐 느낌
   //-- 장소나 공간만 한정하는 것이 아니라 안에서 일하는 것 + 안에서 생산된 생산물 + 문법
     스프링은 스프링 컨테이너 또는 어플리케이션 컨텍스트라고 불리는 스프링 런타임 엔진을 제공한다.
     //--                         ---------------------            ----------------- 공단, 공장이 돌아갈 수 있도록 동력 전달
     //-- ex) 맨인블랙 사물함(컨테이너) -> 시계 추앙하는 마을 -> 마을 안에 공장도 공단도 있는것 
     //--     거기서 일하는 일꾼들 있고 -> 스프링컨테이너는 공단에 해당 ??????????
     //-- 유연성이 굉장히 뛰어난 것이 특징이기 때문에 뭐라고 딱 지정하기 힘든것이 스프링 -- 액체 같음!
     스프링 컨테이너는 설정 정보를 참고해서 어플리케이션을 구성하는 오브젝트(객체)를 생성하고 관리한다.
     //                -------- 여태까지는 매번 설계도(인스턴스) 등을 생성, 조립 ... 해 왔는데
     //                         3D 프린터에게 맡기는 것 같은 느낌! - 설계도만 주고 내 손이 거의 닿지 않음
     스프링 컨테이너는 독립적으로 동작할 수도 있지만 보통... 웹 모듈에서 동작하는 서비스나 서블릿으로 등록해서 사용한다.
     
     스프링을 사용하려면 먼저 스프링 컨테이너를 다루는 방법과
     스프링 컨테이너가 어플리케이션 오브젝트를 이용할 수 있도록
     설정정보를 작성하는 방법을 알아야한다.
     
     ==> 설정 정보에 의해 어플리케이션을 구성하고 객체를 생성, 관리하는 주체
 -------------------------------------------------------------------------------------------------------------------------------   
   - 공통 프로그래밍 모델 → IoC/DI, 서비스 추상화, AOP
     //                    --------------------------- 대표적인 모델
     프레임워크라는 어플리케이션을 구성하는 오브젝트(객체)가 생성되고 동작하는 방식에 대한 틀을 제공해줄 뿐 아니라
     어플리케이션 코드가 어떻게 작성되어야 하는지에 대한 기준도 제시한다.
     이런 틀을 보통 프로그래밍 모델이라고 한다.
     스프링은 세 가지 핵심 프로그래밍 모델을 제공한다.
     
     ① IoC/DI
        오브젝트 생명 주기와 의존관계에 대한 프로그래밍 모델이다.
        스프링은 유연하고 확장성이 뛰어난 코드를 만들 수 있게 도와주는 객체지향설계 원칙과
        디자인 패턴의 핵심원리를 담고 있는 IoC/DI 를 프레임워크의 핵심 근간으로 삼고 있다.
        스프링 프레임워크에서 동작하는 코드는 IoC/DI 방식을 따라 작성되어야 스프링이 제공하는 가치를 제대로 누릴 수 있다.
        스프링이 직접 제공하는 모든 기술과 API, 심지어 컨테이너까지도 IoC/DI 방식으로 작성되어(만들어져)있다.
        //-- 유기농 친환경 음식만 제공해드립니다. 음식은 유기농 친환경인데 그릇에서 폴리페놀 검출 ect.. 
        //-- 그럼... 이 곳은 유기농친환경 음식을 제공하는건가..? -> 높
        //-- 즉, 스프링은 안보이는 그릇이나 식재료 옮기는 상자 들도 다 친환경 세팅해둔 거라고 생각하면 됨
        스프링을 바르게 이해하고 효율적으로 사용하는데 기본이 되며 가장 중요한 기술이다.
        ·IoC → - 객체 관리의 주체
               - Inversion of Control : 제어의 역전(역제어)
                 //-- 다른 객체를 인스턴스 생성할거야~ 라고 작성해오는 것 : 제어
                 //-- 
               - 객체 생성과 관리를 직접하는 것이 아니라
                 외부(컨테이너)에서 만들어진 오브젝트(객체)를 제공받는 입장이 되는 것.
               - Bean : 스프링이 관리하는 대상
                 //-- POJO... 객체들
               - Bean Factory : 객체를 관리하는 주체
                                일반적으로 이 기능을 확장한 Application Context 를 사용하게 된다.
                 //-- 공장(단수)
               - Application Context : Bean Factory 의 확장 버전
                 //-- 공단(공장들이 모인 곳) 
               - 설정 정보 : 어떤 객체들이 관리 대상인지 설정한 정보.
                 //-- JSP 를 서블릿에 넘겨서 그린것 역시 설정정보를 넘긴 것... -> 그린건 서블릿!
                             XML, Annotation 등을 이용한다.
                             객체 의존 관계도 표현되어 있다.
               - IoC 컨테이너 : 객체를 등록하고 관리하는 공간. //--(작업자, 문법)
                 //-- IOC 컨테이너가 해주는거야~ 등의 표현 전부 가능! 
        ·DI  → - 객체를 관리하는 방법
                 //-- 방법론적
               - 자바에서 객체를 생성하고 관리하는 방법은 모두 has(is)-a 관계를 통해 처리해 왔기 때문에
                 //-- has-a 관계는 무언가를 포함하고 있는 상태이기 때문에 상속을 할 수 없음
                 이들은 모두 의존관계가 치밀하고 밀접한 상황일 수 밖에 없다.
                 때문에... 이러한 강한 결합 상태는 유연성을 떨어뜨리는 결과를 초래하게 된다.
                 이러한 결합 상태를 풀어주는 과정(방법)이 바로 DI 이다.
                 //-- 
               - Dependency Injection : 의존성 주입(의존관계 주입)
               - 의존관계 주입 : 의존 객체를... 이 객체를 사용하는 객체에... 외부에서 주입하는 액션(상태)
               - 의존관계 : A가 실행되기 위해서는 B를 필요로 하는 상태에서 이들의 관계
               - 의존객체 : A 입장에서의 의존객체는 B(즉, 주입되는 객체)
                 
               ※ 우선... A 객체에 B 객체의 주소를 넘겨줌으로써 B객체를 사용하게 된다면...
                  A 객체는 여전히 B 객체를 사용하는 데는 문제가 없고, B 객체는 A 객체와의 결합 상태가 느슨해진다고 할 수 있다.
                  //-- 오로지 스캐너 1개만 객체를 생성해서 직접 넣으면 스캐너 1개만 얻을 수 있지만
                  //-- 스캐너 1,2,3,4,5... 를 가진 Interface 를 넣으면 스캐너 1,2,3,4,5.... 중에 원하는 것을 넣을 수 있음
                    
                  이 때, 넘겨주는 방법은 생성자 또는 setter() 메소드를 이용하는 방법이 있다.
                  //-- Setter Injection 
                    
                  DI 를 위해 객체는 작은 객체부터 생성해서 큰 객체로 DI 하는 과정을 반복적으로 거치게 된다.
                  
                  이 때, 완성된 오브젝트(객체)가 만들어질 때 까지 객체를 관리할 주체가 필요한데
                  //-- 선풍기 만들 때 나사 만들어두면 나사도 관리해두고, 틀도 관리해두고 할 주체
                  그 역할을 하는 것이 바로 컨테이너 인 것이다.
                  //-- 이를 IoC 컨테이너라고도 부르고, 크게 스프링 컨테이너라고 부르기도 하고, 스프링 이라고 부르기도 한다.
     ② 서비스 추상화
        **스프링을 사용하면 환경이나 서버, 특정 기술에 종속되지 않고 이식성이 뛰어나며 유연한 어플리케이션을 만들 수 있게 되는데**,
        //-- 인터페이스 상속 : 포유류(인터페이스-실체화X,추상적개념) : 구체적인 동물
        이를 가능하게 해주는 것이 바로 서비스 추상화이다.
        구체적인 기술과 환경에 종속되지 않도록 유연한 추상 계층을 두는 방법이다.
     ③ AOP (Aspect Oriented Programming)
        //-- OOP(객체지향프로그래밍) 을 조금 더 객체지향적 프로그래밍으로 만들기 위해 도와주는 프로그래밍이 AOP 이다.
        //-- 1) AOP 와 OOP 는 적대관계가 아님. OOP 중심으로 AOP 가 지원/도와주는 것
        //-- 2) 그림참조
        이 AOP 는 어플리케이션 코드에 산재해서 나타나는 부가적인 기능을 독립적인 상태로 모듈화 하는 프로그래밍 모델이다.
        스프링은 AOP 를 이용해서 다양한 엔터프라이즈 서비스를 적용하고도 깔끔한 코드를 유지할 수 있게 해준다.
 -------------------------------------------------------------------------------------------------------------------------------  
   - 기술 API
     스프링은 엔터프라이즈 어플리케이션 개발의 다양한 영역에 바로 활용될 수 있는 방대한 양의 기술 API 를 제공한다.
     UI 작성은 물론이고, 웹 프리젠테이션 계층, 비즈니스 서비스 계층, 기반서비스 계층, 도메인 계층, 데이터 엑세스 계층 등에서
     필요한 주요 기술을 스프링에서 일관된 방식으로 사용할 수 있도록 지원해주는 전략 클래스를 제공한다.
     스프링이 제공하는 API 와 지원 기술은 모두 스프링 프로그래밍 모델에 따라 작성되었기 때문에
     이를 가져다 쓰는 것 만으로도 스프링 프로그래밍 모델을 코드에 자연스럽게 적용할 수 있다.
     스프링의 모든 기술은 표준 자바 엔터프라이즈 플랫폼(JavaEE)에 기술을 두고 있다.
     표준 기술과 더불어 유명 오픈소스 기술과 주요 상용 기술에 대한 지원 기능도 다양하게 제공된다.

JavaBasic 에서 언급 된 Framework : 환경 / 틀 / 약속

ex) 요일메뉴
      - 스타벅스 가서 요일메뉴 요청 : ???????????
      - 도원에 가서 요일메뉴 요청 : 요청 됨~

런타임 엔진 ...?

---

Spring Framework 의 주요 기능과 특징

○ 스프링 프레임워크(Spring Framework)의 주요 기능과 특징
1. 경량 컨테이너
   자바 객체를 담고, 이들 자바 객체의 생성과 소멸의 라이프 사이클을 관리
2. DI(Dependency Injection)
   의존성(관계) 주입(삽입)을 지원.
   설정 파일을 통해 객체간의 의존 관계를 정의
3. AOP (Aspect Oriented Programming) 지원
   관점 지향 프로그래밍 지원.
   여러 모듈에 공통적으로 쓰이는 기능을 분리하여 각 모듈에 적용하는 것이 가능.
4. POJO(Plane Old Java Object) 지원.
   가장 기본적인 자바 객체를 지원하여 기존 작성 코드의 유지성을 향상
   → 보통 자바(빈) 객체
      - 상속 (X)
      - 인터페이스 (X)
5. 트랜잭션 처리
   JDBC 나 JTA 를 사용하는 설정파일을 통해 트랜잭션을 관리하여
   동일코드를 여러 환경에서 사용하도록 하는것이 가능.
6. 다양한 프레임워크와의 조합
   mybatis(ibatis), Hivernate, Struts, Struts2, JPA, JDO, Quartz 등
   다른 프레임워크 뿐 아니라 사용자가 만든 프레임워크와의 연동성을 제공한다.
   
※ 스프링 프레임워크(Spring Framework)에서 가장 중요한 개념
   //-- 하나의 클래스에서 필요한 기능이 있다면 다른 클래스의 인스턴스를 직접 생성했었지만
   //-- 이제 직접 생성하는 것 대신에, 외부 스프링객체를 통해서 (내가 직접하는것 X) 대신 처리해주는 것
   //-- 그렇기에 스프링객체가 원활하게 일 할 수 있도록 환경(여건)을 세팅해주는 것
 - DI(Dependency Injection, 의존성 주입, 의존관계 주입)
   : 객체를 생성하고 관리하는 의존성에 대해서 어떻게 처리하는가에 대한 개념
 - IoC(Inversion of control, 제어의 역전)
   : 인스턴스의 생성부터 소멸까지의 인스턴스 생명주기 관리를 컨테이너가 대신하는 개념

---

Spring Framework 환경 설정

■■■ Spring Framework 환경설정 ■■■
※ 스프링 프레임워크 관련 홈페이지
   http://www.spring.io
   → 환경 구성을 위해 스프링 프레임워크 관련 파일을 다운로드 받아야하는데
      해당 파일들을 직접적으로 다운로드 받을 수 있는 서비스는 더이상 제공되고 있지 않은 상태이다.
      (STS 연동 (Maven 활용)만 가능한 형태...)
   
○ 적용 및 테스트가 원활한 버적으로 실습환경 구성(비 STS)
→ 자체 공유 서버를 통해 배포
   ① spring-framework-3.0.2-with-docs.zip
      기본적인 스프링 프레임워크 구성에 필수적인 jar 파일과
      스프링 프레임워크 설명문서(pdf 버전, html 버전)가 포함된 항목.
      스프링 원래의 jar 파일들
   ② spring-framework-3.0.2-dependencies.zip
      스프링 프레임워크 구성에 의존성을 가진 jar 파일들이 포함된 항목.
      어떤 기능을 수행하느냐에따라 추가적으로 필요한 항목.
      스프링이 참조하는 의존 jar 파일들
※ 주의)
   다운로드 받은 두 개의 압축 파일은 C:\ 또는 D:\ 처럼
   드라이브 루트에 폴더를 생성하여 압축을 풀어놓는다.
   그 안에 들어있는 jar 파일들을 필요한 기능에 따라 선택적으로 복사하여 사용할 예정이기 때문에
   쉬운 경로에 압축을 풀어놓는다는 의미도 있지만, 압축을 해제하는 과정에서 이름(경로포함)이 길어서
   제대로 압축을 해제하지 못하고 오류가 발생하기 때문에 간단한 경로에서 압축을 해제할 수 있도록 한다.

---

IoC/DI

■■■ IoC DI ■■■
Dependency 는 의존객체를 말한다.
Injection 은 주입을 의미한다.

객체 A 가 사용되기 위해 B 객체가 반드시 필요하다고 가정하면,
A 객체 입장에서 B 객체는 의존 객체가 된다

클래스 A 가 다음과 같은 상황이고,
public class A
{
	private B b;	//-- B 타입이라는 b 변수 (다른 곳에 설계되어있는 B)
	
	public A(B b)
	{
		b = new B();	//-- A 내부에서 B 인스턴스 생성
	}
}
어떤 곳에서 『A a = new A();』 라는 구문을 통해 A 객체 생성을 하는 과정이 있다면,
//----- 메인메소드를 포함하고 있는 다른 외부의 클래스에서 A 인스턴스 구문 작성 시
의존 객체인 B 객체 생성 과정은 여기(어떤 곳)에 없는 상황이된다.
//-- 그 곳엔 B를 생성하는 인스턴스는 없음
A 객체 내부 생성자에 의존 객체인 B를 생성하는 과정이 포함되어 있는 것이다.

이는 의존성이 강한 결합에 속하기 때문에
사용자가 B 객체를 바꾸고 싶어도 A 클래스의 내부 소스 코드를 바꾸지 않고서는 다른 객체로 바꿀 수 없는 상황이 된다.
//-- class A에서 private C c 로 바꾸면 되지 않나?
//-- -> 컴파일 되어 class 파일이 배포되어지기 때문에 변경할 수도 없는 상황이다.
게임기에 빗대어 예를 들자면, 게임 칩이 내장된 게임기 모델과 같다고 할 수 있다.
//-- 스스로 배터리 교체가 불가능한 현재의 휴대폰

이를 다음과 같이 수정한다면,
//-- 메인메소드를 포함하고 있는 다른 외부의 클래스에서
B b = new B();
A a = new A(b);
//-- 이렇게 건네준다면 결국은 B타입만 건네줄 수 밖에 없는 구조임
//-- 이래서 추상화를 통해 인터페이스 구조를 만드는 것
의존 객체인 B 객체에 대한 생성 권한이 사용자에게 주어진다.
B 객체를 독립적으로 생성하고 A 객체에 이를 전달해주는 것이다.

필요한 경우 B 객체 대신 다른 객체로 변경하여 전달하는 것도 가능하다.
이 때, B 객체를 의존 객체(Dependency) 라고 하고
A 객체에 전달해주는 과정을 주입(Injection) 이라고 한다.

게임기로 말하자면 게임팩 교체가 가능한 모델과 같다고 할 수 있다.
//-- 스스로 배터리를 교체 가능했던 옛날의 휴대폰
스프링은 환경 설정 파일인 XML 파일을 통해서(또는 Annotation 을 통해서)
스프링 코드 변경 없이 객체 생성과 객체간의 의존 관계(DI)를 설정, 조정, 변경 할 수 있다.
//-- XML 등장 전에는 결국 class 파일 build 하여 배포하게 되면 수정이 불가능한 것은 동일

※ DI 설정은 ① 생성자를 이용하는 방법 과, ② setter 를 이용하는 방법 크게 두 가지가 있다.
   일반적으로 setter 메소드를 이용한 DI 방법을 사용하게 된다.
   스프링에서는 XML 환경 설정 파일에서 객체 생성 및 DI 설정을 한다.
   cf) Annotation 을 활용하는 방법
   
※ IoC(Inversion of Control)
   DI 패턴을 적용하게 되면,
   객체 생성 과정 및 의존성 주입은 일반적인 객체 생성과는 다른 방식으로 진행된다.
   작은 부품 객체인 C 를 만들고,
   그 부품 객체인 C 를 중간 부품 객체인 B 에 주입(Injection) 하고, 
   중간 부품 객체인 B(C가 탑재된 B)를 이용해서
   최종 완제품인 A 객체에 주입(Injection) 하게 되면 객체 조립이 완성되는구조 
   이 과정 또는 여기에 대한 관리... 이 모두를 종합하여 IoC 라고 표현한다.
   이 행위를 하는 주체 즉, IoC Container 를 대상으로 IoC 라고 표현하기도 하고, 
   이 행위가 일어나는 장소를 IoC 라고 표현하기도 하며, 
   큰 범주에서 이를 Spring 이라 표현하기도 한다.

---

■■■ IoC/DI 실습 01 ■■■
※ 스프링 프레임워크 없이 IoC/DI 개념 실습
○ 실습 성격 및 주요사항
   1.콘솔 프로젝트
   2.성적처리
     국어, 영어, 수학 점수를 입력받아 총점, 평균을 출력하는 프로그램

○ 물리적 파일 구성
   1. Record.java            → 인터페이스
   2. RecordView.java        → 인터페이스
   3. RecordImpl1.java       → Record 인터페이스를 구현하는 클래스
   4. RecordImpl2.java       → Record 인터페이스를 구현하는 클래스
   5. RecordViewImpl.java    → RecordView 인터페이스를 구현하는 클래스
   6. Main.java              → 클래스.main() 메소드를 포함하는 외부의 테스트 클래스

IoC/DI 실습 01
SpringPrj01

/*================
   Record.java
   - 인터페이스
================= */

package com.test.spr;

public interface Record
{
	// ※ 인터페이스이기 때문에 메소드는 선언만 가능
	
	// 국어 점수 getter/setter 선언
	public void setKor(int kor);
	public int getKor();
	
	
	// 영어 점수 getter/setter 선언
	public void setEng(int eng);
	public int getEng();
	
	
	// 수학 점수 getter/setter 선언
	public void setMat(int mat);
	public int getMat();
	
	// 총점 얻어내는 메소드 선언
	public int getTotal();
	
	// 평균 얻어내는 메소드 선언
	public double getAvg();
}

---

/*===================
   RecordView.java
   - 인터페이스
 ================== */

package com.test.spr;

public interface RecordView
{
	// ※ 인터페이스이기 때문에 메소드는 선언만 가능
	
	// setter 메소드 선언
	public void setRecord(Record record);
	
	// 입력 액션 전용 메소드 선언
	public void input();
	
	// 출력 액션 전용 메소드 선언
	public void output();
}

---

/*========================================
   RecordImpl1.java
   - 클래스
   - Record 인터페이스를 구현하는 클래스
========================================= */

package com.test.spr;

public class RecordImpl1 implements Record
{
	// 추상 클래스 → 일반클래스 (오버라이딩)
	
	// 주요 속성 구성
	private int kor, eng, mat;

	@Override
	public void setKor(int kor)
	{
		this.kor = kor;
	}

	@Override
	public int getKor()
	{
		return kor;
	}

	@Override
	public void setEng(int eng)
	{
		this.eng = eng;
		
	}

	@Override
	public int getEng()
	{
		return eng;
	}

	@Override
	public void setMat(int mat)
	{
		this.mat = mat;
	}

	@Override
	public int getMat()
	{
		return mat;
	}

	@Override
	public int getTotal()
	{
		int result = 0;
		
		result = this.getKor() + this.getEng() + this.getMat();
		
		return result;
	}

	@Override
	public double getAvg()
	{
		double result = 0;
		
		result = this.getTotal() / 3.0;
		
		return result;
	}
	
}

---

/*========================================
   RecordImpl2.java
   - 클래스
   - Record 인터페이스를 구현하는 클래스
   - RecordImpl1 의 적용 업무와 차별화
========================================= */

package com.test.spr;

public class RecordImpl2 implements Record
{
	// 추상 클래스 → 일반클래스 (오버라이딩)
	
	// 주요 속성 구성
	private int kor, eng, mat;

	@Override
	public void setKor(int kor)
	{
		this.kor = kor;
	}

	@Override
	public int getKor()
	{
		return kor;
	}

	@Override
	public void setEng(int eng)
	{
		this.eng = eng;
		
	}

	@Override
	public int getEng()
	{
		return eng;
	}

	@Override
	public void setMat(int mat)
	{
		this.mat = mat;
	}

	@Override
	public int getMat()
	{
		return mat;
	}

	@Override
	public int getTotal()
	{
		int result = 0;
		
		// 총점 산출과정에서 -> 기본 점수(100점) 추가
		result = 100 + this.getKor() + this.getEng() + this.getMat();
		
		return result;
	}

	@Override
	public double getAvg()
	{
		double result = 0;
		
		// 평균 점수 산출 과정에서 -> 기본점수가 포함된 상태에서의 평균처리
		result = this.getTotal() / 4.0;
		
		return result;
	}
	
}

---

/*=================================================
   Main.java
   - main() 메소드를 포함하고 있는 테스트 클래스
================================================== */

package com.test.spr;

public class Main
{
	public static void main(String[] args)
	{
		// [스프링이 처리하고 관리하게 될 영역] → 스프링 컨테이너 안에서 벌어지게 될 상황
		//---------------------------------------------------------------------------------------
		
		// Record rec1 = new Record(); 
		//-- 인터페이스 이기 때문에 불가능~
		
		// 해당 인터페이스를 가진 클래스(추상X)
		// ① Record(→ RecordImpl1) 객체 생성 과정
		Record rec1 = new RecordImpl1();                //-- dependency (의존객체)
		
		// ② Record(→ RecordImpl2) 객체 생성 과정
		Record rec2 = new RecordImpl2();                //-- dependency (의존객체)
		
		// RecordView(→ RecordViewImpl) 객체 생성 과정
		RecordView view = new RecordViewImpl();
		//-- Record 객체 필요로 하고 있는 상황
		
		// check
		// 의존 객체 주입
		view.setRecord(rec1);                           //-- setter injection
		//view.setRecord(rec2);                           //-- setter injection
		//-- 의존 객체 주입 방법을 사용하게되면
	    //   느슨한 결합을 구성할 수 있게 되고(결합력 약화)
		//   한 쪽의 변동 상황이 다른 쪽에 영향을 덜 줄 수 있게 된다.
		
		/*
		RecordImpl을 각각 다른 타입의 Record 를 만들기 위해서 구성 + 
		사실 RecordImpl1, 2 를 구성할 필요는 없이 RecordViewImpl 에서 구성하면 되지만
		결합력을 약화시키기 위해서 따로 구성한 것
		*/
		//---------------------------------------------------------------------------------------
		
		view.input();
		view.output();
		
	}// end main()
}

---

IoC/DI 실습 02
SpringPrj02

■■■ IoC/DI 실습 02 ■■■
※ 스프링 프레임워크 적용 IoC/DI 개념 실습
○ 실습 환경 구성
   → 스프링 자원을 활용할 수 있는 환경 구성
      1. 프로젝트 생성(SpringPrj02)
      2. 프로젝트명 마우스 우클릭
      3. Build Path > Configure Build Path... 메뉴 선택
      4. Libraries 탭 선택 > 우측 메뉴 중 Add Externam Jars... 버튼 클릭
      5. 필요한 jar 파일을 해당 프로젝트에 외부 라이브러리로 등록
         - 경로1 : C:\s-f-3.0.2-with-docs\dist
            (파일 5개)
           ·org.springframework.asm-3.0.2.RELEASE.jar
           ·org.springframework.beans-3.0.2.RELEASE.jar
           ·org.springframework.context-3.0.2.RELEASE.jar
           ·org.springframework.core-3.0.2.RELEASE.jar
           ·org.springframework.expression-3.0.2.RELEASE.jar
         - 경로2 : C:\s-f-3.0.2-dependencies\org.apache.commons\com.springsource.org.apache.commons.logging\1.1.1
            (파일 1개)
           ·com.springsource.org.apache.commons.logging-1.1.1.jar
      6. 스프링 프레임워크의 환경 설정 파일을 XML 형식으로 생성
         생성위치는... 현재 콘솔 프로젝트를 진행중이기 때문에
         프로젝트명 하위의 src 디렉터리
         현재 실습 환경에서의 파일 이름은 사용자가 임으로 부여하여 생성하는 것이 가능한 상황.
         → 『applicationContext.xml』
      7. 생성한 applicationContext.xml 파일에
         스프링이 참조하게 될 객체에 대한 정보와 DI 설정을 추가하게 되며
         이와 같은 문서의 기본적인 구성을 위해
         스프링에서 제공하는 문서의 가이드라인 참조
         - 참조 경로 : file:///C:/s-f-3.0.2-with-docs/docs/spring-framework-reference/htmlsingle
           · 참조 파일 : spring-framework-reference.html
           · 참조 위치 : III. Core Technologies ...
                          3.2.1. Configuration metadata
         → 해당 위치의 xml 샘플 파일의 내용을 복사하여
            applicationContext.xml 의 내용에 덮어쓰기 (전체 선택 후 붙여넣기)

○ 실습 성격 및 주요사항
   1.콘솔 프로젝트
   2.성적처리
     국어, 영어, 수학 점수를 입력받아 총점, 평균을 출력하는 프로그램

○ 물리적 파일 구성
   1. Record.java            → 인터페이스
      → SpringPrj01 프로젝트의 기존 소스코드 활용
   2. RecordView.java        → 인터페이스
      → SpringPrj01 프로젝트의 기존 소스코드 활용
   3. RecordImpl1.java       → Record 인터페이스를 구현하는 클래스
      → SpringPrj01 프로젝트의 기존 소스코드 활용
   4. RecordImpl2.java       → Record 인터페이스를 구현하는 클래스
      → SpringPrj01 프로젝트의 기존 소스코드 활용
   5. RecordViewImpl.java    → RecordView 인터페이스를 구현하는 클래스
      → SpringPrj01 프로젝트의 기존 소스코드 활용
   6. Main.java              → 클래스.main() 메소드를 포함하는 외부의 테스트 클래스
      → 수정(check) ★ 
   7. applicationContext.xml → 프로젝트 > src 폴더 하위에 생성
                                (현재 파일의 이름은 임의로 지정 가능)

---

+ SpringPrj01 파일 에 Main.java(수정) 과 applicationContext.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-3.0.xsd">

		<!--
			※ 스프링이 제공하는 환경 설정 XML 파일 샘플
			   → 스프링이 생성하고 관리해야 할 객체들에 대한 정보 전달 
		-->
		<!-- 위치는 <beans></beans> 사이에서 구성 -->
		
		<!-- Record (→ RecordImpl1) 객체에 대한 정보 전달 (+ 사용해도 된다는 허가) -->
		<bean id="record1" class="com.test.spr.RecordImpl1"></bean>	<!-- 설계도 넘김 -->
		<!-- id 는 이름 class 는 해당 객체 정보가 있는 위치 -->
		
		<!-- Record (→ RecordImpl2) 객체에 대한 정보 전달 -->
		<bean id="record2" class="com.test.spr.RecordImpl2"></bean>
		
		<!-- Record (→ RecordViewImpl) 객체에 대한 정보 전달 -->
		<bean id="recordView" class="com.test.spr.RecordViewImpl">
			<!--
			      RecordView 객체의 record 속성에 필요한(주입해야하는)
			      의존 객체에 대한 DI 설정 정보 전달 과정
			      //-( 설계도 안에 필요한 속성값을 넘겨주는 행위 )
			      
			      『property』엘리먼트는 setter 메소드에 대한 정의
			      즉, 『setXxx()』 메소드인 경우 『property name="xxx"』라고 설정하게 된다. 
			-->
			<property name="record">
				<!-- 『ref』 엘리먼트에 의해 DI 객체에 대한 참조 지정 -->
				<ref bean="record1"/>
			</property>
			
			<!--
				※ 위 구문은 (line 30 ~ 32)
				『<property name="record" ref="record1"></property>』
				의 형태로 작성해도 된다.
			-->
			
		</bean>

</beans>

---

/*=================================================
   Main.java
   - main() 메소드를 포함하고 있는 테스트 클래스
================================================== */

package com.test.spr;

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

public class Main
{
	public static void main(String[] args)
	{
		// [스프링이 처리하고 관리하게 될 영역] → 스프링 컨테이너 안에서 벌어지게 될 상황
		//---------------------------------------------------------------------------------------
		/*
		
		// Record rec1 = new Record(); 
		//-- 인터페이스 이기 때문에 불가능~
		
		// 해당 인터페이스를 가진 클래스(추상X)
		// ① Record(→ RecordImpl1) 객체 생성 과정
		Record rec1 = new RecordImpl1();                //-- dependency (의존객체)
		
		// ② Record(→ RecordImpl2) 객체 생성 과정
		Record rec2 = new RecordImpl2();                //-- dependency (의존객체)
		
		// RecordView(→ RecordViewImpl) 객체 생성 과정
		RecordView view = new RecordViewImpl();
		//-- Record 객체 필요로 하고 있는 상황
		
		// check
		// 의존 객체 주입
		view.setRecord(rec1);                           //-- setter injection
		//view.setRecord(rec2);                           //-- setter injection
		//-- 의존 객체 주입 방법을 사용하게되면
	    //   느슨한 결합을 구성할 수 있게 되고(결합력 약화)
		//   한 쪽의 변동 상황이 다른 쪽에 영향을 덜 줄 수 있게 된다.
		*/
		//---------------------------------------------------------------------------------------
		
		// ※ 스프링 프레임워크에서는
		//    객체 생성 과정 및 DI(의존 객체 주입)에 대한 설정은
		//    스프링 환경 설정 파일로 대체된다.(→ applicationContext.xml)
		
		// 스프링 프레임워크에서 『applicationContext.xml』 파일을 읽어서
		// 생성 및 관리할 객체에 대한 정보를 얻을 수 있도록 해야 한다.
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//-- applicationContext 로 이동하여 작업 -> bean 3개 구성
		
		// 『getBean()』 메소드를 이용하여 사용자가 원하는 객체를 얻어낸다.
		
		//RecordView view = (RecordViewImpl)context.getBean("view");	//-- 다운캐스팅
		
		// 스프링 3.0 이후 버전부터 사용가능한 코드
		RecordView view = context.getBean("view", RecordViewImpl.class);
		//-- 오브젝트 형식으로 읽어올 때 설계도 줄테니까 설계도 대로 캐스팅해서 해당 데이터를 넘겨줘
		//-- 55번 형식 또는 58 번 형식 둘 다 사용 가능
		
		view.input();
		view.output();
		
	}// end main()
}