2week

* 대면 수업 내용

DI 의존성 주입 개념 복기

• object Dependncies
  petOwner class 코드 참고 -> 생성자 기준으로 new를 통해서 객체를 생성해야한다. 즉 해당 클래스와 생성자는 밀접한 관계를 맺고 있다. 이를 좀 더 유연하게 하기 위해서 DI를 사용하면 된다.
• DI
  Bean Container를 통해서 cat과 dog를 생성하고 주입해서 관리하며 cat과 dog 모두를 소유 할 수 있다.
  설정 xml config를 통해서 동작을 잘 한다.

---

DI의 디자인 패턴

동적으로 주입을 한다. 컴파일마다가 아니라 onetime마다 이루어진다.

설정 하는 방법

-xml
-java annotations
-java-based configuration

스프링 컨테이너의 종류

-BeanFactory
-ApplicationContext

bean에는 id를 부여할 수 있다.

Spring Container and DI

xml bean으로 java의 컨테이너를 컨드롤 할 수도 있다.

Advantage of DI

장점 4가지가 있다.

☕ 인터페이스 vs 추상클래스 용도 차이점 - 완벽 이해

---

실습

실습을 하기 위해서 프로젝트 파일은 아래와 같다

animals 폴더 안에 class와 interface 스크립트가 있다.

AnimalType의 interface 코드를 먼저 살펴보면 아래와 같다.

* AnimalType.java

package kr.ac.hansung.cse.animals;

public interface AnimalType {
    void sound();
}

package를 살펴보면 kr.ac.hansung.cse이란 package의 aminals package를 지정함으로써 클래스를 특정 패키지에 속하도록 할 수 있으며, 다른 클래스에서 해당 클래스를 import하여 사용할 때 패키지 이름을 함께 명시함으로써 컴파일러가 해당 클래스를 찾을 수 있게 하는 역할이다.

## interface란?

Java에서 인터페이스는 추상 클래스와 유사한 역할을 하며, 클래스가 가져야 하는 메서드들의 명세를 제공한다. 인터페이스는 추상 메서드(메서드 선언만 있고 구현은 없는 메서드)와 상수를 정의할 수 있다.

이제 AnimalType이란 추상 메서드를 활용해서 Cat과 Dog class를 작성해보자.

* Cat.java

package kr.ac.hansung.cse.animals;

public class Cat implements AnimalType{
    String myName;

    public void setMyName(String myName) {
        this.myName = myName;
    }
    @Override
    public void sound() {
        System.out.println("Cat name=" + myName + ":" + "Meow");
    }
}

* Dog.java

package kr.ac.hansung.cse.animals;

public class Dog implements AnimalType{
    String myName;

    public void setMyName(String myName) {
        this.myName = myName;
    }

    @Override
    public void sound() {
        System.out.println("Dog name=" + myName + ":" + "Bow Wow");
    }
}

 

우린 추상메서드를 각 dog과 cat에 상속을 할 것이다. 이로 우리는 추상클래스의 원칙을 따라 sound라는 함수를 각 클래스에 구현해야한다. 이를 annotation 표기법으로 override가 되었다는 것을 표기 한다. (여기서 생성자는 없다.) 이제 우리는 이것들을 각기 연결해주어야 할 스프링을 작성할 것이다. 형식은 xml파일 형식이다.

* animal.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 https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="catId" class="kr.ac.hansung.cse.animals.Cat">
        <qualifier value="qf_cat"/>
        <property name="myName" value="bella"/>
    </bean>

    <bean id="dogId" class="kr.ac.hansung.cse.animals.Cat">
        <qualifier value="qf_dog"/>
        <property name="myName" value="poodle"/>
    </bean>

    <bean id="petOwnerId" class="kr.ac.hansung.cse.animals.PetOwner">
<!--        <constructor-arg ref="dogId"/>-->
    </bean>
<!--    annotation 활성화-->
    <context:annotation-config/>
</beans>

위의 코드를 각 살펴보자. 

* <bean>

<bean> 요소를 사용하여 빈을 정의하고 있다. id 속성을 사용하여 각 빈의 고유 식별자를 지정하고 class 속성을 사용하여 해당 빈이 어떤 클래스로부터 객체를 생성하는지를 지정하고 있다. petOwnerId 빈이 정의되어 있는 빈을 살펴보면 kr.ac.hansung.cse.animals.PetOwner 클래스의 인스턴스를 생성한다.

* <qualifier>

<qualifier> 요소를 사용하여 빈에 대한 추가 정보를 제공하고 있다. <qualifier>를 통해서 <bean> 요소로 catId와 dogId 빈에 각각 qf_cat와 qf_dog라는 한정자(qualifier)를 지정하고 있다. 하지만 petOwnerId 빈에는 <qualifier> 요소가 없기 때문에 해당 빈은 한정자를 가지지 않는다. 이렇게 하면 petOwnerId 빈은 한정자를 사용하여 구분되는 것이 아니라 단순히 클래스 kr.ac.hansung.cse.animals.PetOwner의 인스턴스를 생성하게 된다.

* <constructor-arg>

주석 처리가 되어 있는 <constructor-arg ref="dogId"/> 부분은 <constructor-arg> 요소를 사용하여 생성자 인자를 설정할 수 있다. 하지만 여기서는 ref를 사용해서 단순 참조만 하고 있다. ref는 단순히 스프링 컨테이너에 의해 관리되는 참조 프로퍼티로 petOwnerId 빈이 생성될 때 dogId 빈이 생성자의 인자로 전달되어 의존성 주입(Dependency Injection)이 이루어진다. 컨테이너가 뭔지 아래 더보기를 통해 확인하길 바란다.

##컨테이너란?

스프링 컨테이너는 빈(Bean)이라고 불리는 객체들을 관리한다. 이러한 빈은 스프링 컨테이너가 생성하고, 구성하며, 관리한다. 또한, 컨테이너는 빈들 간의 의존성을 해결하고, 필요한 경우 빈을 초기화하고 소멸시킨다.

스프링 컨테이너는 보통 두 가지 주요 유형이 있다:

BeanFactory: 스프링의 가장 기본적인 컨테이너로, 빈의 생성, 의존성 주입, 생명주기 관리 등을 담당한다. 가장 일반적인 구현체로는 XmlBeanFactory가 있습니다.

ApplicationContext: BeanFactory를 확장한 것으로, 추가적인 기능을 제공한다. 더 많은 기능 중에는 메시지 소스 처리, 이벤트 발행, AOP 지원, 환경 설정, 트랜잭션 관리 등이 있다. 일반적으로 ClassPathXmlApplicationContext, FileSystemXmlApplicationContext, AnnotationConfigApplicationContext 등의 구현체가 있다.

스프링 컨테이너는 일반적으로 XML 파일이나 Java Config와 같은 설정을 통해 빈을 정의하고 관리한다. 컨테이너는 설정을 로드하고, 빈들을 초기화하며, 필요한 경우에는 빈들 간의 의존성을 주입하여 애플리케이션의 실행을 관리한다. 이를 통해 객체지향 설계 원칙을 준수하고, 유연하고 확장 가능한 애플리케이션을 개발할 수 있다.

 

* <property>

마지막으로 각 <bean>에 존재하는 <property> 요소를 사용하여 각 빈의 속성을 설정하고 있다. "myName" 프로퍼티에 각각 "bella"와 "poodle" 값을 설정하고 있다.

* <context:annotation-config>

이 요소는 스프링 애플리케이션 컨텍스트에서 어노테이션을 활성화하는 데 사용된다. 이렇게 함으로써 @Autowired, @Component, @Qualifier 등과 같은 어노테이션을 사용하여 스프링의 의존성 주입을 설정할 수 있게 된다.

다음으로 실질 적으로 PetOwner를 통해서 누구를 소유하고 있는지 정해야한다. 스프링 프레임워크의 의존성 주입(Dependency Injection) 기능을 사용하여 애완동물 객체를 주입받아 사용한다. 이를 통해 객체 간의 결합도를 줄이고 유연성을 높일 수 있다. 아래 코드를 살펴보자.

* PetOwner.java

package kr.ac.hansung.cse.animals;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class PetOwner {
    @Qualifier("qf_cat")
    @Autowired
    AnimalType animal;

//    public PetOwner(AnimalType animal){
//        this.animal = animal;
//    }

    public void play(){
        animal.sound();
    }
}

 

* @Qualifier

@Qualifier 어노테이션은 주입될 빈을 세부적으로 지정할 때 사용된다. 여러 개의 동일한 타입의 빈이 존재할 때, 어떤 빈을 주입할지 세밀하게 지정할 수 있다. 여기서 @Qualifier("qf_cat")는 AnimalType 타입의 빈(animal.xml) 중에서 <qualifier> value값이 "qf_cat"인 빈을 찾아 주입받도록 지정한다.

* @Autowired

@Autowired 어노테이션은 스프링 프레임워크에서 사용되는 자동 의존성 주입을 나타낸다. 이 어노테이션이 적용된 필드나 메서드의 매개변수에 해당하는 빈을 스프링 컨테이너가 자동으로 주입된다. 여기서 @Autowired 어노테이션은 AnimalType 타입의 빈을 주입받도록 지정되어 있다.

* AnimalType animal;

@Autowired 어노테이션이 적용된 필드로, AnimalType 타입의 빈이 자동으로 주입된다. 여기서 의문은 각 애완동물들을 AnimalType들을 implements를 통해 상속을 받고 있는데 왜 @Autowired 어노테이션을 사용해야하는지 말이다. ' @Autowired 어노테이션이 적용된 필드로, AnimalType 타입의 빈이 자동으로 주입된다.' 라는 것은 스프링 프레임워크가 해당 타입의 빈을 찾아서 주입한다는 의미한다. 즉, 각 애완동물(Cat,Dog)들의 타입은 상속을 받은 AnimalType으로 구분이 되어 있는 것이다. 결론적으로 @Autowired 어노테이션이 사용된 필드에 해당하는 빈을 주입받기 위해서는 해당 타입에 맞는 빈이 스프링 컨테이너에 등록되어 있어야 하는 검증을 하는 역할을 하는 것이다. 

## @Autowired를 사용하지 않는 다면..

    public PetOwner(AnimalType animal){
        this.animal = animal;
    }

위 코드는 PetOwner 클래스의 생성자를 나타낸다. 이 생성자는 AnimalType 타입의 매개변수를 받아들이고 이를 animal 필드에 할당하는 역할을 한다. 여기서 생성자는 AnimalType 인터페이스를 매개변수로 받아들이기 때문에 PetOwner 객체를 생성할 때 이 생성자에 전달된 AnimalType 타입의 빈을 주입해야 한다. 즉, main에 객체를 생성할 때 PetOwner에 매개변수를 AnimalType인 빈(Cat, Dog)을 항상 의식하고 기입을 해야한다는 것이다. @Autorwired를 사용하지 않고 생성자를 사용했을 때의 예상되는 mian 코드는 아래와 같아

public class Main {
    public static void main(String[] args) {
        // AnimalType을 구현한 클래스의 객체 생성
        AnimalType animal = new Cat(); // 예시로 Cat 클래스를 사용

        // PetOwner 생성자 호출하여 PetOwner 객체 생성
        PetOwner person = new PetOwner(animal);

        // PetOwner 객체를 사용하여 작업 수행
        person.play();
    }
}

결론적으로 의존성 주입을 사용하지 않으면 불필요하게 코드가 늘어난다는 것을 알 수 있다.

* person.play();

animal 객체의 sound() 메서드를 호출하여 애완동물의 sound를 재생한다. 이러한 구성을 통해 스프링은 PetOwner 클래스를 컨테이너로 관리하고 AnimalType 타입의 빈을 주입하여 객체를 초기화하고 사용할 수 있다.

이제 우리는 스프링 프레임워크로 xml을 통한 컨테이너들과 클래스들을 살펴보았다. 스프링 프레임워크에서 XML 설정 파일을 사용하여 빈을 관리하고 의존성 주입을 수행 main 코드들을 살펴보자.

* main.java

package kr.ac.hansung.cse;

import kr.ac.hansung.cse.animals.PetOwner;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("conf/animal.xml");

        PetOwner person = (PetOwner) context.getBean("petOwnerId");
        person.play();

        context.close();
    }
}

코드를 보면 kr.ac.hansung.cse 패키지에 Main 클래스가 정의되어 있고 PetOwner 클래스와 ClassPathXmlApplicationContext 클래스를 import 하고 있다.

* ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("conf/animal.xml");

ClassPathXmlApplicationContext를 사용하여 xml 설정 파일을 로드하고 스프링 컨테이너 객체를 생성한다. 여기서 xml 설정 파일은 conf/animal.xml이다. animal.xml에 관한 스프링 컨테이너는 앞서 우리가 살펴봤다.

*  PetOwner person = (PetOwner) context.getBean("petOwnerId");

context.getBean("petOwnerId")를 통해 스프링 컨테이너에서 petOwnerId 빈을 검색한다. 이때 반환되는 객체의 타입이 Object이기 때문에 (PetOwner)를 통해 해당 객체를 PetOwner 타입으로 캐스팅해야 한다.

*  person.play();

PetOwner 인터페이스나 클래스에 정의된 play() 메서드를 호출하여 애완동물 소유주의 플레이 메서드를 실행한다.

* context.close();

스프링 컨테이너를 종료하고 리소스를 정리한다.

이렇게 스프링의 빈과 컨테이너의 개념을 살펴보았다. 아직은 익숙하지 않아 중간중간 낯설게 느껴진다. 이에 우리는 빈과 컨테이너 개념을 계속해서 살펴보며 강의를 이어나가면 된다. 다음에는 MVC패턴에 관해서 공부를 하게 될 것이다. 중요한 개념이니 잘 듣고 잘 정리해보면 좋을 듯하다.

---

## 스스로 실습하기

여기서 끝내기 아쉬워서 스스로 실습을 해보려고 한다. 현재 우리는 sound에 관련된 인터페이스를 가지고 스프링 컨테이너를 오고가며 의존성 주입 수업을 통해 학습 해보았다. 따라서 스스로 학습을 해볼 때 AnimalType 인터페이스에 맞는 새로운 함수를 하나 만들어보고 새로운 인터페이스를 하나 더 추가해서 나만의 코드를 한번 구현해보면 좋을 듯하다.

---

## 중간고사를 위한 이론 정리

빈(Bean)이란?

POJO를 가지고 빈이라고 한다. 하나의 객체이다.
빈을 직접 생성하지 않고 스프링 커네이너를 통해서 관리를 한다.
Configuration Metadata를 앞으로 만들어야한다.

* XML 파일: 예를 들어, Spring Framework에서는 XML 파일을 사용하여 Bean 정의, 의존성 주입 및 다양한 설정을 정의합니다.
* 어노테이션: 많은 프레임워크와 라이브러리에서는 어노테이션을 사용하여 구성 정보를 제공합니다. 예를 들어, Spring Framework에서는 @Bean, @Autowired, @ComponentScan 등의 어노테이션을 사용하여 애플리케이션의 구성을 정의합니다.

XML

메타데이터(configuration metadata)를 XML로 표현을 한다.

Spring Bean Definition

Spring Bean Definition은 Spring Framework에서 빈(Bean)을 정의하고 구성하기 위한 메타데이터이다. Spring에서 빈(Bean)의 생성 및 관리 방법을 결정하는 설정입니다. 

scope : 객체가 하나인경우 싱글톤 여러개면 프로토타입 스프링에서는 싱글톤을 많이 사용한다. 본래에는 싱글톤을 직접구현 하지만 scope을 설정하면 싱글톤을 구현할 필요없이 알아서 스프링에서 만들어준다.

<bean id="myBean" class="com.example.MyBean" scope="singleton">
    <!-- 빈 설정 -->
</bean>
<bean id="myBean" class="com.example.MyBean" scope="prototype">
    <!-- 빈 설정 -->
</bean>

Singleton(싱글톤) 스코프
싱글톤 빈은 Spring 컨테이너에서 한 번 생성됩니다.
이 싱글톤 빈은 참조될 때마다 동일한 인스턴스가 반환됩니다.
컨테이너가 종료될 때 이 싱글톤 빈은 가비지 컬렉션됩니다.
Prototype(프로토타입) 스코프
프로토타입 빈은 매 요청마다 새로운 객체를 생성합니다.
이 프로토타입 빈은 보통의 방식으로 가비지 컬렉션됩니다. 즉, 해당 객체에 대한 참조가 없어질 때 가비지 컬렉션됩니다.
기본 스코프
명시적으로 지정하지 않은 경우, 모든 빈은 기본적으로 싱글톤입니다.

(좌)싱글톤 : accountDao참조 - 동일 (우)프로토타입 : accountDao참조 - 참조 할 때 마다 새로 생성

싱글톤이기에 같은 것을 참조한다.결과적으로 같은 결과를 출력한다. 변경을 주려면 setUserName을 주어야한다. 따라서 싱글톤은 의존성 주입을 하게 된다. 만약 프로토타입으로 하게된다면 각기 다르게 값이 나오지만 setUserName을 주지 않은 객체는 Null을 반환하게 된다.

* 의존성 주입 메서드 종류

생성자 기반 의존성 주입(Constructor-based Injection) - constructor-arg
생성자를 통해 의존성을 주입합니다.
객체를 생성할 때 필요한 의존성을 생성자 매개변수로 전달하여 의존성을 주입합니다.

세터 기반 의존성 주입(Setter-based Injection) - property
프로퍼티 세터(Property Setter)를 통해 의존성을 주입합니다.
객체를 생성한 후, 필요한 의존성을 설정하는 Setter 메서드를 호출하여 의존성을 주입합니다.

constructor-arg : 생성자를 인자로 넘겨줄 수 있다.(빈을 생성할 때 생성자를 통해 필요한 인자값을 전달할 때 사용한다. XML 구성 파일에서 사용되며 생성자 인자의 순서에 따라 값을 전달한다.)

<bean id="myBean" class="com.example.MyBean">
    <constructor-arg value="value1"/>
    <constructor-arg value="value2"/>
</bean>

property : setter에 넘겨줄 인자를 설정할 때 사용한다.(빈을 생성한 후에 Setter 메서드를 사용하여 필드 값을 주입할 때 사용한다. XML 구성 파일에서 사용되며, 프로퍼티 이름과 값을 지정하여 주입한다.)

<bean id="myBean" class="com.example.MyBean">
    <property name="propertyName1" value="value1"/>
    <property name="propertyName2" value="value2"/>
</bean>

init, destory : (빈의 초기화와 소멸 시 실행할 메서드를 지정합니다.)

<bean id="myBean" class="com.example.MyBean" init-method="init" destroy-method="destroy">
    <!-- 빈 설정 -->
</bean>

---

singleton: scope에 명시를 하지 않으면 default로 설정 된다.
prototype:
request:
session:
global-session:
<싱글톤 동작 이미지 참조 about 10:00>
<14:00 sigletone과 prototype의 차이 설명>

---

Spring Annotation Based Configuration

Old wine in new bottle -> xml을 사용하지 않고 Annotation을 사용해서 (무엇을?)설정한다. Annotation은 클래스에 직접 설정을 한다. xml은 설정해야할 양이 너무 많다는 단점을 보완하기 위해서 Annotation을 사용, Annotation의 동작은 XML을 오버라이딩해서 적용된다.

Enabled Spring Annotation(Annotation 설정 하는 방법)

xmlns:context="...", etc, need config
context:annotaion-config

Kind Of Annotation

@Required : 해당 클래스의 메타데이터의 정보를 기본적으로 설정해주고 점검하는 역할, Boy라는 클래스를 XML로 부터 메타데이터로 name과 value가 있으면 해당 @Required가 설정 되어 있는 클래스에서는 name과 value가 존재해야한다. 하지만 만약 age와 같이 @Required에 설정되지 않은 정보가 존재하거나 @Required로 부터 정의된 테이터 타입에 맞지 않는 값이 들어간다면 에러를 표출한다.

아래는 잘못된 것

@Autorwired : 자동으로 객체와 객체를 연결한다. 즉, 자동으로 의존성을 주입한다.라고 이해하면 된다. scope이 설정되지 않은 singletone이 default로 설정된 객체를 자동으로 주입시킨다.

@Autowired를 사용하지 않고 생성하면 property를 설정해야함 하지만  @Autowired를 사용하면 따로 property를 사용하지 않고 객체를 주입할 수 있다. 따라서 College의 property는 더 이상 setter기반으로 의존하지 않을 수 있다.

@Qulifier(value="tony") : XML에서 scope이 설정되지 않은 2개의 같은 class가 존재한다는 가정에서 value가 "tony"인 객체를 주입하겠다는 방식으로 사용되는 Annotation

@Resource : Autowired가 되는 방식과 같지만 name 속성을 통해서 bean의 id를 찾게된다.