Ch01. Spring

/*Spring 기본 의존문법*/

package pack;
class Baduk{
	AI ag;
	Baduk(AI ag){  //생성자 - 의존객체에서 외부에서 주입받음. 
		this.ag = ag;
		System.out.println("대국을 시작합니다.");
	}
	void play() {ag.play();}   // 주입받은 ai에서의 play 실행
	void stop() {ag.stop();}
}  
//의존성 주입(DI): Baduk이 직접 AlphaGo나 BetaGo를 생성하지 않고, 외부(main)에서 생성된 객체를 전달받아 사용.
interface AI{
	abstract void play();
	abstract void stop();
}
class AlphaGo implements AI{
	public void play() {System.out.println("인공지능은 알파고입니다.");}
	public void stop() {System.out.println("알파고가 게임을 중단.");}
}
class BetaGo implements AI{
	public void play() {System.out.println("인공지능은 베타고입니다.");}
	public void stop() {System.out.println("베타고 게임을 중단.");}
} // 같은 Interface지만 행동은 다른 "다형성 실현"
public class Sample {
	public static void main(String[] args) {
		Baduk b1 = new Baduk(new AlphaGo()); // 의존성 Alphago 주입
		Baduk b2 = new Baduk(new BetaGo());	// 의존성 Betago 주입
		b1.play(); b1.stop(); // 실행코드
		b2.play(); b2.stop();
	}
}
/*
class A{}
interface IA{}
interface IB{}
interface IC{}
class B extends A implements IA, IB, IC{}
 */

📌 실행 흐름 & 결과
Baduk b1 = new Baduk(new AlphaGo());
Baduk 생성자 실행 → "대국을 시작합니다." 출력.
내부적으로 ag = new AlphaGo() 저장.
b1.play();
AlphaGo.play() 실행 → "인공지능은 알파고입니다." 출력.
b1.stop();
AlphaGo.stop() 실행 → "알파고가 게임을 중단." 출력.
Baduk b2 = new Baduk(new BetaGo());
"대국을 시작합니다." 출력.
내부적으로 ag = new BetaGo() 저장.
b2.play();
"인공지능은 베타고입니다." 출력.
b2.stop();
"베타고 게임을 중단." 출력.

Springboot3의 구조

스프링부트 - 스프링 프레임워크를 더 쉽고 빠르게 이용할 수있도록 만든 도구. 빠르게 스프링 프로젝트를 설정. 의존성 세트라고 불리는 스타터를 이용해 의존성을 쉽게 사용하고 관리가능.
1. 스프링부트는 스프링코어와 스프링 MVC의 모든 기능을 자동으로 로드하므로 수동으로 개발환경 구성할 필요 X
2. 스프링 애플리케이션은 톰캣과 같은 WAS에서 배포
3. 자바코드는 클래스 A에서 B 객체를 쓰고싶은 경우 직접 생성. 스프링의 경우 직접생성이 아닌 스프링 컨테이너에서 객체를 주입받아 사용. -> Ioc/DI 개념 (중요함!!)

직접 생성 (new) vs. 스프링 컨테이너에 맡겨서 주입받기 (DI)

// B라는 클래스
class B {
    public void doSomething() {
        System.out.println("B가 일을 합니다!");
    }
}

// A라는 클래스
class A {
    private B b;

    public A() {
        // A 안에서 B를 직접 생성함
        this.b = new B();
    }

    public void action() {
        b.doSomething();
    }
}

// 실행
public class Main {
    public static void main(String[] args) {
        A a = new A(); // A를 만들면 A 내부에서 B도 생성됨
        a.action();
    }
}

A가 B를 직접 new해서 생성. A는 항상 B만 써야함

Spring에서 IoC/DI 사용하는 경우

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component // 스프링이 관리하는 Bean
class B {
    public void doSomething() {
        System.out.println("B가 일을 합니다!");
    }
}

@Component // 스프링이 관리하는 Bean
class A {
    private final B b;

    // 생성자 주입 (권장 방식)
    @Autowired
    public A(B b) {
        this.b = b; // 스프링 컨테이너가 B 객체를 대신 넣어줌
    }

    public void action() {
        b.doSomething();
    }
}
-----------------------
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public CommandLineRunner run(A a) { // 스프링이 A를 주입
        return args -> {
            a.action(); // "B가 일을 합니다!"
        };
    }
}

new를 사용하지않고 @Component로 등록해두면 스프링 컨테이너가 객체를 생성하여 관리
A는 B를 직접 만들지않고 외부에서 받아서 DI 사용.
B대신 C라는 클래스를 쓰고싶으면 스프링 설정만 바꾸고 A의 코드는 그대로 유지가 가능하다.
IoC - Inversion of Control 제어의 역전.
DI - Dependency Injection 의존성 주입

@Component // 클래스 MyBean 빈으로 등록
// 스프링 컨테이너에서 이 클래스를 관리
public class MyBean {
}

관점지향 프로그래밍 AOP

AOP - Aspect Oriented Programming
관점지향 프로그래밍 - 프로그래밍에 대한 관심을 핵심관점, 부가관점으로 나누어서 관심기준으로 모듈화하는것을 의미한다. 솔직히 뭔말인지 안와닿음...
쉬운 예로 계좌이체, 고객관리하는 프로그램이 있을 때 각 프로그램에는 로깅 조직, 지금까지 벌어진일을 관리하기위한 데이터베이스 연결로직 포함. 이때 핵심관점은 계좌이체, 고객 관리 로직이고 부가 관점은 로깅, 데이터베이스 연결로직이다.
따라서 프로그래머는 핵심 관점 코드에만 집중하고 프로그램의 변경과 확장에 유연하게 대응이 가능.

이식 가능한 서비스 추상화 PSA

Portable Service Attraction - 스프링에서 제공하는 다양한 기술들을 추상화 해서 개발자가 쉽게 사용하는 인터페이스

한줄정리
IoC - 객체의 생성과 관리를 개발자가 하는것이 아니라 프레임워크가 대신하는것
DI - 외부에서 객체를 주입받아 사용하는것
AOP - 프로그래밍 할 때 핵심 관점과 부가 관점을 나누어 개발하는것
PSA - 어느 기술을 사용하던 일관된 방식으로 처리하도록 하는것