상상코딩

1. 아키텍쳐(Architecture)

• 건축 분야에서 유래된 용어이다
• 요구 사항을 만족하는 건축물을 만들기 위한 청사진과 같다
• 컴퓨터 시스템에서의 아키텍처는 어떠한 시스템을 구축하는데 있어 해당 시스템의 비지니스적 요구 사항을 만족하는 전체 시스템 구조를 정의하는 것이다
• 전체 시스템 구조를 상호간에 쉽게 이해할 수 있도록 일반적으로 이미지나 도형 등을 많이 사용한다
• 아케텍쳐는 최대한 심플하고 간결해야 한다

2. 시스템 아키텍쳐(System Architecture)

• 하드웨어와 소프트웨어를 모두 포함하는 어떤 시스템의 전체적인 구성을 큰그림으로 표현한 것이다
• 해당 시스템이 어떤 하드웨어로 구성되고, 어떤 소프트웨어를 사용하는지를 대략적으로 알 수 있도록 한다
• 시스템 구성 요소들 간의 상호작용과 시스템의 동작 원리 등을 시스템 아키텍처 안에 표현하면 이해하기가 쉽다

3. 소프트웨어 아키텍쳐(Software Architecture)

• 하드웨어를 제외한 모든 소프트웨어의 구성을 큰 그림으로 표현한 것이다
• Java 플랫폼 아키텍쳐가 대표적이다
• Java의 기술지원, 기능 등을 그림을 통해 알 수 있다

• Spring Framework 모듈 아키텍쳐를 보면 지원하는 모듈을 확인할 수 있다.
  - 모듈은 여러가지 기능들을 목적에 맞게 그룹화하여 묶어 놓은 것을 말한다
  - Spring에서 모듈은 Java의 패키지 단위로 묶여 있고, 패키지 안에는 클래스들이 포함되어 있다
  - 모듈은 재사용이 가능하도록 라이브러리 형태로 제공된다

4. 계층형 아키텍쳐(N-Tier)

 1) API 계층(API Layer)

• 클라이언트의 요청을 받아들이는 계층이다
• 표현 계층(Presentation Layer)이라고도 하지만 REST API를 제공하는 애플리케이션의 경우 API 계층이라고 표현한다

 2) 서비스 계층(Service Layer)

• API 계층에서 전달 받은 요청을 업무 도메인의 요구 사항에 맞게 비즈니스적으로 처리하는 계층이다
• 애플리케이션의 핵심 로직이 포함되어 있으며, 애플리케이션에 있어 핵심이 되는 계층이다

※ 도메인(Domain)
 - 애플리케이션 개발에서 흔하게 사용하는 도메인이란 용어는 주로 비즈니스적인 어떤 업무 영역과 관련이다
 - 애플리케이션 개발에서 필요한 업무 로직에 대한 지식을 도메인 지식(Domain Knowledge)이라고 한다

 - 도메인 지식이 많을수록 서비스 계층에서 비즈니스 로직으로 구현해야 하는 것들을 퀄리티가 높게 표현할 수 있다

 3) 데이터 엑세스 계층(Data Access Layer)

• 비즈니스 계층에서 처리된 데이터를 데이터베이스 등의 데이터 저장소에 저장하기 위한 계층이다

※ 참조 링크

▶ Spring Framework : https://docs.spring.io/spring-framework/docs/5.0.0.M5/spring-framework-reference/html/overview.html

1. PSA(Portable Service Abstraction)

 1) Pablo Picasso 의 추상화 기법

• 파블로 피카소의 작품 'The Bull is a series of eleven lithographs created' 이다
• 다국적 기업인 Apple의 업무 프로세스에 기본이 되는 그림이기도 하다
• 황소의 특성을 살려 본질만을 남기려 한 작품이다

• 객체지향 프로그램밍에서는 클래스의 본질적인 특성만을 추출해서 일반화하는 작업을 추상화(Abstraction)라고 한다
• Java에서 추상화를 표현할 수 있는 방법에는 추상 클래스와 인터페이스가 있다

 2) 일반화(추상화)의 예

• 어린 아이의 특성을 일반화하여 코드로 작성해 보면 아래와 같다

• 위의 추상 클래스에 구체적인 메서드를 작성해 본다

• Child 클래스를 실행시켜 본다

• 클라이언트(ChildManageApplication 클래스의 main() 메서드)는
• NewBornBaby, Infant, Toddler 를 사용할 때 구체화 클래스의 객체를 자신의 타입에 할당하지 않고, (1) ~ (3)과 같이 Child 클래스 변수에 할당을 해서 접근을 한다
• 클라이언트는 Child라는 추상클래스만 찾아서 하위의 기능 클래스를 사용할 수 있다
• 클라이언트가 추상황 된 상위클래스만을 일관되게 바라보며 하위 클래스의 기능을 사용할 수 있는 것이 일관된 서비스 추상화이며, PSA의 기본 개념이다

※ 서버를 이용하는 클라이언트 외에 코드 내에서 어떤 클래스의 기능을 사용하는 측을 클라이언트라고 부른다

2. 서비스에 적용하는 일관된 서비스 추상화 (PSA)기법

• 서비스 추상화는 추상화의 개념을 애플리케이션에 자용하는 서비스에 적용하는 기법이다

• DbClient에서 어떤 JdbcConnector 구현체를 사용하더라도 Connection을 얻는 방식은 getConnection() 메서드를 사용해야 하기 때문에 동일하다
  - 일관된 방식으로 서비스의 기능을 사용할 수 있다
• 애플리케이션에서 특정 서비스를 이용할 때, 서비스의 기능을 접근하는 방식 자체를 일관되게 유지하면서 기술 자체를 유연하게 사용할 수 있도록 하는 것을 PSA(일관된 서비스 추상화)라고 한다

 1) PSA(일관된 서비스 추상화) 코드 예제

• DbClient 클래스의 (1)에서 SQLiteJdbcConnector 구현체의 객체를 생성해서 JdbcConnector 인터페이스 타입의 변수에 할당(업캐스팅)하고 있다
• DbClient 클래스의 (2)에서 실제로 데이터를 데이터베이스에 저장하는 기능을 하는 DataProcessor 클래스의 생성자로 JdbcConnector 객체를 전달하고 있다(의존성 주입).

• 상기와 같이 작성 후 실행을 시키면 error가 발생한다

• JdbcConnector 메서드에 아래 코드를 삽입시켜 부면 해결된다

import java.sql.Connection;

• 에러없이 실행된다

• 다른 애플리케이션에서 SQLite 데이터베이스를 사용하는 것이 아니라 Oracle 데이터베이스를 사용해야 한다면, JdbcConnector 서비스 모듈을 그대로 가져와서 (1)의 new SQLiteJdbcConnector()를 new OracleJdbcConnector()로 바꿔서 사용하면 된다

3. PSA 필요성

• 어떤 서비스를 이용하기 위한 접근 방식을 일관된 방식으로 유지하여 애플리케이션에서 사용하는 기술의 변경 시 최소 작업을 통해 변경 사항을 반영한다
• PSA를 통해서 애플리케이션의 요구 사항 변경에 유연하게 대처할 수 있다
• PSA는 트랜잭션 서비스, 메일 서비스, Spring Data 서비스 등에 적용된다

1. AOP(Aspect Oriented Programming)

• 관심지향 프로그래밍으로 정의한다
• 애플리케이션 핵심 업무 로직에서 공통 기능 로직을 분리하는 것이다

 1) 핵심 관심 사항 (Core concern)

  - 애플리케이션의 주 목적을 달성하기 위한 핵심 로직에 대한 관심사를 말한다

 2) 공통 관심 사항 (Cross-cutting concern)

  - 애플리케이션 전반에 걸쳐 공통적으로 사용되는 기능을 말한다

  - 로깅, 보안, 트랜젝션 등이 있다

2. AOP가 필요한 이유

• 코드의 간결성을 유지
• 객체 지향 설계 원칙에 적합한 코드 구현
• 코드의 재사용

※ 트랜젝션(Tranjection) : 데이터를 처리하는 하나의 작업 단위를 말한다

• 트랜젝션에는 커밋(commit) 과 롤백(rollback) 기능이 있다
  - 커밋은 모든 작업이 성공적으로 수행되었을 경우 수행한 작업을 데이터베이스에 반영하는 것이다
  - 롤백은 작업 중 하나라도 실패하면 이전에 성공한 작업들을 작업 수행 이전으로 되돌리는 것이다
• 여러 작업을 하나의 트랜젝션으로 묶으면 코드는 간결해지고 재활용성은 높아진다

1. 스프링 컨테이너(Spring Container)

• ApplicationContext 를 스프링 컨테이너라고 한다
• 인터페이스로 구현되어 있고, 다형성이 적용된다
• XML, 애너테이션 기반의 자바 설정 클래스로 만들 수 있다
• 이전까지는 개발자가 xml을 통해 모두 설정하여야 했으나, Spring Boot를 사용하면서 설정하지 않는다
• 빈의 인스턴스화, 구성, 전체 생명 주기 및 제거까지 처리한다
  - 컨테이너는 개발자가 정의한 Bean을 객체로 만들어 관리하며, 개발자가 필요로 할 때 제공한다
• 스프링 컨테이너를 통해 원하는 만큼 객체를 가질 수 있다
• 의존성 주입을 통해 애플리케이션의 컴포넌트를 관리한다
  - 스프링 컨테이너는 서로 다른 빈을 연결해 애플리케이션의 빈을 연결하는 역할을 한다
  - 개발자는 모듈 간에 의존 및 결합으로 인해 발생하는 문제로부터 자유로울 수 있다
  - 메서드가 언제, 어디서 호출되어야 하는지, 메서드를 호출하기 위해 필요한 매개 변수를 준비해서 전달하지 않는다

2. Spring Container 사용 목적

• Spring Framework - IoC / DI - 기초 참조 : https://coding-mid-life.tistory.com/48

• 객체 간의 의존성을 낮추기 위하여 사용한다
• 새로운 정책이 발생할 경우 변경 사항을 수작업으로 해야 한다
• 코드의 양이 방대할 경우 수정 시간이 과도하게 소모된다
• 스프링 컨테이너를 사용할 경우 인터페이스에만 의존하도록 설계할 수 있다

3. Spring Container 생성

• 기존에는 xml방식으로 설정하였다 (ClassPathXmlApplicationContext)

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
        <-- <beans />에 필요한 값들을 설정합니다. -->
        
    <bean id="..." class="...">  
        <!-- id="..." Bean의 정의를 식별하는 문자열을 작성한다 -->
        <!-- class="..." Bean의 유형을 정의하고 클래스 이름은 작성한다 -->
    </bean>
         
    <bean id="..." class="...">         
   		 <!-- 추가적인 Bean을 작성한다 -->
    </bean>    
</beans>

• 최근에는 주로 애너테이션 기반의 자바 설정 클래스로 Spring Container 을 만드는 것을 의미한다

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);


스프링 컨테이너를 만드는 다양한 방법은 ApplicationContext 인터페이스의 구현체이다
 - AppConfig.class 등의 구성 정보를 지정해줘서 스프링 컨테이너를 생성한다
 - AppConfig에 있는 구성 정보를 통해서 스프링 컨테이너는 필요한 객체들을 생성한다
 - 애플리케이션 클래스는 구성 메타데이터와 결합되어 ApplicationContext 생성 및 초기화된 후
   완전히 구성되고 실행 가능한 시스템 또는 애플리케이션을 갖게 된다

• 스프링 컨테이너는 Configuration Metadata를 사용한다
• 스프링 컨테이너는 파라미터로 넘어온 설정 클래스 정보를 사용해서 스프링 빈을 등록한다
• new AnnotationConfigApplicationContext(구성정보.class)로 스프링에 있는 @Bean의 메서드를 등록한다
  ※  주석 기반 컨테이너 구성
     : https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-annotation-config
• 스프링 빈 조회에서 상속관계가 있을 시 부모타입으로 조회하면 자식 타입도 함께 조회된다
  - 모든 자바 객체의 최고 부모인 object타입으로 조회하면 모든 스프링 빈을 조회한다

※ IntelliJ 에서 ApplicationContext 인터페이스를 확인하는 방법

  - ctrl + n >  class >  ApplicationContext 입력 검색

  -  ApplicationContext 인터페이스를 구현하기 위한 하위 클래스를 확인할 수 있다

4. Spring Container 종류

• 파라미터로 넘어온 설정 클래스 정보를 참고해서 빈의 생성, 관계 설정 등의 제어작업을 총괄하는 컨테이너이다

 1) BeanFactory

• 스프링 컨테이너의 최상위 인터페이스이다
• BeanFactory는 bean을 등록, 생성, 조회, 반환 등... 빈을 관리하는 역할을 한다
• getBean() 메소드를 통해 빈을 인스턴스화 할 수 있다
• @Bean이 붙은 메서드의 이름을 스프링 빈의 이름으로 사용해 빈을 등록한다

 2) ApplicationContext

• BeanFactory의 기능을 상속받아 제공한다
• bean을 관리하고 검색하는 기능을 BeanFactory가 제공하고 그 외에 부가기능을 제공한다
• 부가 기능은 아래와 같다
  - MessageSource: 메세지 다국화를 위한 인터페이스
  - EnvironmentCapable: 개발, 운영 등 환경변수 등으로 나눠 처리하고, 애플리케이션 구동 시 필요한 정보들을 관리하기 위한 인터페이스
  - ApplicationEventPublisher: 이벤트 관련 기능을 제공하는 인터페이스
  - ResourceLoader: 파일, 클래스 패스, 외부 등 리소스를 편리하게 조회

5. Container 인스턴스화

• ApplicationContext 생성자에 제공된 위치 경로는 컨테이너가 로컬 파일 시스템, Java CLASSPATH 등과 같은 다양한 외부 리소스로부터 구성 메타데이터를 로드할 수 있도록 하는 리소스 문자열이다

// Annotation
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// XML
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

6. new 와 생성자 주입

• new를 사용하는 대신 생성자를 통해 의존 객체가 주입되고, 느슨한 의존 관계가 이루어진다

• userRepository와 discountInfo의 구현 클래스는 Bean 설정에 따라서 유연하게 변하게 된다
• OrderServiceImpl 클래스는 생성자를 통해 어떤 구현 객체가 주입될지 알 수 없으며, 알 필요도 없다
• 어떤 객체가 주입될지는 외부 AppConfig에서 결정된다
• OrderServiceImpl 클래스는 실행에만 집중하게 된다

7. 빈(Bean)

• 스프링 컨테이너에 의해 관리되는 재사용 소프트웨어 컴포넌트이다
  - 컴포넌트(component) : 여러 개의 객체를 하나로 묶어서 저장한 그룹
• Spring 컨테이너가 관리하는 자바 객체를 의미하며, 하나 이상의 빈을 관리한다
• Bean은 인스턴스화된 객체를 의미한다
• 스프링 컨테이너에 등록된 객체를 Spring Bean 이라고 한다
• @Bean이 적힌 메서드를 모두 호출해서 반환된 객체를 스프링 컨테이너에 등록한다
• Bean은 클래스의 등록 정보와 getter/setter 메서드를 포함한다
• Bean은 컨테이너에 사용되는 설정 메타데이터로 생성된다
• 설정 메타데이터
  - XML, Java annotation, Java code 로 표현한다
  - 컨테이너의 명령, 인스턴스화, 설정, 조립할 객체 를 정의한다

 1) Bean 접근 방법

• ApplicationContext 사용하여 bean 정의를 읽고 액세스할 수 있다

// bean을 생성하고 구성한다
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

// getBean 메서드로 bean 인스턴스를 가져온다
PetStoreService service = context.getBean("cmarket", cmarketService.class);

// bean 인스턴스를 사용한다
List<String> userList = service.getUsernameList();

• 응용 프로그램 코드에서는 getBean() 메서드로 호출하여 사용하면 안된다

 2) Bean의 정의(BeanDefinition)

• 스프링은 다양한 설정 형식을 BeanDefinition이라는 추상화 덕분에 지원할 수 있다
• Bean은 BeanDefinition에 의해 정의되며, BeanDefinition에 따라 활용하는 방법이 달라진다
• BeanDefinition (빈 설정 메타정보)
  - 속성에 따라 컨테이너가 Bean을 어떻게 생성하고 관리할지를 결정한다
  - @Bean or <bean> 당 각 1개씩 메타 정보가 생성된다
  - Spring은 설정 메타정보를 BeanDefinition 인터페이스를 통해 관리하기 때문에 컨테이너 설정을 XML, Java로 할 수 있다
  - 스프링 컨테이너는 설정 형식이 XML인지 Java 코드인지에 상관없이 BeanDefinition만 알면 된다

※ BeanDefinition

 : https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/config/BeanDefinition.html

※ 참조 링크

▶ 컨테이너 : https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-basics

▶ 빈 : https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-definition

▶ XML 스키마 기반 구성 : https://docs.spring.io/spring-framework/docs/4.2.x/spring-framework-reference/html/xsd-configuration.html

▶ config.xml 개요 : https://docs.oracle.com/cd/E13222_01/wls/docs81b/config_xml/overview.html

▶ XML 관련 문서 google 추천 검색어 : "beans xmlns meaning" 또는 "xml configuration"

1. IoC(Inversion of Control) / DI(Dependency Injection)

 1) 반전 제어 (IoC)

• Library는 애플리케이션 흐름의 주도권이 개발자... Framework은 애플리케이션 흐름의 주도권이 Framework
• 애플리케이션 흐름의 주도권이 뒤바뀌는 기술
• Java 콘솔 애플리케이션의 일반적인 제어권을 아래 코드에 따라 순서대로 진행하여 보면...
  - 프로세스의 진행을 위해서 main() 메서드가 있어야 한다
  - main() 메서드가 호출되면 System 클래스를 통해서 static 멤버 변수인 out의 println()을 호출한다
  - 일반적인 애플리케이션 제어 흐름은 개발자가 작성한 코드를 순차적으로 실행하는 것이다

public class Ioc {
    public static void main(String[] args) {
        System.out.println("Hello IoC!");
    }
}

• Java 웹 애플리케이션에서 IoC가 적용되는 경우 (반전 제어)
  - 별도의 main( ) 메서드가 존재하지 않는다
  - main( ) 메서드와 같이 애플리케이션이 시작되는 지점을 엔트리 포인트(Entry point)라고 한다
  - main( ) 메서드 대신 서블릿 컨테이너 내의 서블릿 로직이 서블릿을 직접 실행 시킨다
  - 서블릿 로직은 service( )  메서드이다
  - 웹 애플리케이션은 서블릿 컨테이너가 서블릿을 제어하므로 제어 흐름은 서블릿 컨테이너에 있다

2. DI(Dependency Injection)

• Dependency(의존하는, 종속되는) 와 Injection(주입) 의 합성 의미로 보면 의존성 주입의 의미이다
• IoC 개념을 구체화시킨 내용이다
• 아래 그림에서 A클래스는 B클래스의 기능을 사용하고 있다
  - A클래스는 B클래스에 의존한다
  - A클래스의 프로그래밍 로직의 완성을 위하여 B클래스에게 의지한다

• 클래스 다이어그램 작성을 자주 해 보는 것이 도움이 된다

※ 클래스 다이어그램 도구 링크 : https://online.visual-paradigm.com/diagrams/features/

 1) 클래스 간 의존 관계 성립

• 아래 그림을 참조

 2) 의존성 주입

• 클래스 간 의존 관계에서는 new 키워드를 사용하여 객체를 직접 생성했다
• 의존성 주입에서는 외부의 객체를 전달받아 생성자의 파라미터로 주입한다

!!! 클래스의 생성자로 객체를 전달 받는 코드가 있다면

▶ 객체를 외부에서 주입 받고 있으며, 의존성 주입이 이루어 지고 있다!!!

 3) 의존성 주입의 필요성

• 일반적으로 Java에서 new 키워드를 사용해서 객체를 생성한다
• Reflection이라는 기법을 이용해서 Runtime시에 객체를 동적으로 생성할 수 있는 방법도 있다
• Stub과 같은 코드를 작성할 경우 new 키워드로 작성하면 내부에서 연동되어 작동하는 클래스명을 모두 고쳐야 한다
• new 키워드를 사용하여 의존 객체를 생성하면 클래스 간의 결합이 강하다고 한다 (Tight Coupling)
• 강한 결합이 있으면 향후 수정, 보완하기가 어렵다

 4) 의존성 주입의 방향성

• 의존성 주입은 느슨한 결합이 좋다 (Loose Coupling)
• 느슨한 결합의 대표적인 방법은 인터페이스(Interface)를 사용하는 것이다
• A클래스가 B클래스에 의존하고 있을 경우 B클래스의 구현체가 어떻게 생성되었는지는 중요하지 않다
• A클래스는 의존하고 목적의 결과만 확인할 수 있으면 된다

• 아래 그림에서 CafeClient 클래스에는 new 키워드로 MenuServiceStub 객체를 생성하고 있다
  - MenuServiceStub 객체는 MenuService 인터페이스에 할당된다
  - 인터페이스 타입의 변수에 구현 객체를 할당하는 것을 업캐스팅(Upcasting)이라고 한다
• 아래 그림은 업캐스팅에 의한 느슨한 결합을 보여준다

 5) Spring 기반 의존성 주입

• 기존의 new 키워드를 사용하여 객체를 생성하는 코드를 Spring에서 변경하여 보자

※ 참조 링크

▶ 객체지향 설계 : https://ko.wikipedia.org/wiki/SOLID_(%EA%B0%9D%EC%B2%B4_%EC%A7%80%ED%96%A5_%EC%84%A4%EA%B3%84) 

▶ 다이어그램 설계 : https://online.visual-paradigm.com/diagrams/templates/class-diagram/

1. POJO(Plain Old Java Object)

• POJO는 IoC/DI, AOP, PSA를 통해서 달성할 수 있다
• Plain은 사전적 의미로 '있는 그대로'이며, Java로 생성하는 순수한 객체를 의미한다
• 객체지향의 원리에 충실하게 설계된 오브젝트이다

2. POJO 프로그래밍

• POJO를 이용해서 프로그래밍 코드를 작성하는 것을 의미한다
• Spring은 POJO 프로그래밍을 지향하는 Framework이다
• Spring은 최대한 다른 환경이나 기술에 종속적이지 않도록 하기 위한 POJO 프로그래밍 코드 작성을 위해 세가지 기술(IoC/DI , AOP , PSA)을 지원한다
• POJO는 몇 가지 기본 규칙을 가지고 있다

   1) 특정 규약에 종속되지 않는다

     - Java 또는 Java spec에 정의되지 않은 기술이나 규약에 간섭받지 않는다

     - Java 언어 외에 필요하지 않은 API에 종속되지 않는다

     ex) EJB Architecture에서는 특정 클래스를 상속받아야 하는 규약이 있다

           - Java의 단일 상속 제한 원칙으로 인하여 해당 클래스에 더 이상의 상속이 불가능하다

           - 결과적으로 추가적인 객체지향적 설계를 적용할 수 없데 된다

           - 아래 코드에서 특정 클래스인 ActionForm 과 Action을 상속받고 있다

            → 상속 목적은 Status라는 기술을 사용하기 위해서이다

            → 향후 애플리케이션의 목적이나 요구사항이 변경될 경우 Status 기술을 사용하기 위해 상속받은 클래스를 전부

                변경하여야 하는 어려움이 발생한다

public class MessageForm extends ActionForm{ 
	String message;
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
}
public class MessageAction extends Action{ 
	public ActionForward execute(ActionMapping mapping, ActionForm form,
		HttpServletRequest request, HttpServletResponse response)
        throws Exception {
		MessageForm messageForm = (MessageForm) form;
		messageForm .setMessage("Hello World");
		return mapping.findForward("success");
	}
}

 2) 특정 환경에 종속되지 않는다
  - 특정한 프레임워크에서만 동작하면 안된다

  - 웹 기반의 환경정보나 웹 기술을 담고있는 클래스, 인터페이스를 사용하면 안된다
   → 웹 컨트롤러와 연결되어 사용할 경우라도 웹을 직접적으로 사용환경으로 제한하면 안된다

   → ex) HTTPServletRequest, HTTPServletResponse 등... 

 3) 객체지향 원리를 따라야 한다

  - Java로 구현되었어도 객체지향적 설계가 적용되었다고 볼 수 없는 경우가 있다

  - 책임과 역활이 분명하게 구분되어야 한다 (단일책임의 원칙)

   → 하나의 클래스는 하나의 책임 또는 역활만 존재해야 한다

   → 상속, 다형성을 활용해서 설계할 수 있다

   → 조건문만을 활용하여 설계된 오브젝트는 POJO라고 할 수 없다

※ 참조 링크

▶ 객체지향 설계

https://ko.wikipedia.org/wiki/SOLID_(%EA%B0%9D%EC%B2%B4_%EC%A7%80%ED%96%A5_%EC%84%A4%EA%B3%84) 

1. Framework

• Frame의 대표적인 의미는 ‘뼈대, ‘틀’, ‘구조’ 이다
• 일상 생활에서 그림이나 액자. 자동차의 뼈대 등을 프레임이라고 부른다
• Frame은 어던 대상의 큰 틀이나 외형적인 구조를 의미한다
• 프로그래밍 분야에서의  Frame도 비슷한 의미를 가지고 있다

 2. 프로그램 종류별 Frame

 1) Web의 초기에는 HTML 문서를 구성하는 태그 중에서 frame이라는 태그가 존재했다

• 아래 예를 보면 frameset과 frame 태그를 이용해서 HTML 문서의 틀만 구성하고 있는 것을 볼 수 있다

<frameset cols="33%,*,33%">
    <frame name="left" src="/left_menu"/>
    <frame name="center" src="/context"/>
    <frame name="right" src="/right_menu"/>
</frameset>

 2) Java에서 Frame과 유사한 의미를 가지는 Framework 가 있다

• Java에서는 Collection Framework 가 있다
• Java에서 자주 사용하는 Map이나 Set, List 등의 Collection들은 데이터를 저장하기 위해 널리 알려져 있는 자료구조를 바탕으로 비슷한 유형의 데이터들을 가공 및 처리하기 쉽도록 표준화 된 방법을 제공하는 클래스의 집합이다
• Java 클래스 유형 중에서 기본적인 뼈대로만 구성되어 있는 것은 추상 메서드만 정의되어 있는 Interface 이다
• Collection은 Map, Set, List 같은 인터페이스와 그 인터페이스들을 구현한 구현체들의 집합이다

3. 프로그램에서의 Framework 역활

• 기본적으로 프로그래밍을 하기 위한 틀이나 구조를 제공하므로 생산성이 향상된다
• 정해진 규약에 따라 작성하므로 애플리케이션을 체계적으로 관리가 가능하다
• 코드의 재사용성이 높고, 확장성이 좋다
• 서로 다른 애플리케이션 간의 통신, 데이터 저장소에 데이터를 저장 등... 다양한 기능들을 라이브러리 형태로 제공한다
• 개발자에게 애플리케이션의 핵심 로직의 개발에 집중할 수 있도록 편의를 제공한다

4. Framework 와 Library

• Framework 와 Library는 애플리케이션 구현을 위해 필요한 여러가지 기능들을 제공하는 의미에서는 유사하다
• 애플리케이션에 대한 제어권에 따라 구분할 수 있다

Spring Frame 예) 

@SpringHelloApplication
@RestController
@RequestMapping(path = "/v1/message")
public class SampleApplication {
    @GetMapping
    public String getMessage() {  // (2)
        String message = "hello world";
        return StringUtils.upperCase(message);       
    }

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

• Library
  - StringUtils 클래스는 Apache Commons Lang3 라이브러리의 유틸리티 클래스 중 하나이다
  - StringUtils 클래스의 upperCase() 메서드는 파라미터로 전달된 문자열(message 변수)을 대문자로 변환한다
  - 개발자가 작성한 코드 안에서 필요한 기능을 해당 라이브러리를 호출해서 사용하는 것이 Library 이다
  - 필요한 부분에 개발자가 직접 해당하는 라이브러리를 사용한다
  - Library는 애플리케이션의 주도권이 개발자에게 있다
• Framework
  - 위의 예) 에서 사용한 애너테이션이나 main() 메서드 내의 SpringApplication.run() 메서드는 Spring Framework에서 지원하는 기능들이며, 라이브러리와는 다르게 코드 상에는 보이지 않는 상당히 많은 일을 한다
  - getMessage() 메서드 내부의 코드처럼 개발자가 메서드 내에 코드를 작성해 두면, Spring Framework에서 개발자가 작성한 코드를 사용해서 애플리케이션의 흐름을 만들어낸다
  - Framework 자체 규약이 있으며, 규약에 맞춰 코드를 작성해야 한다
  -  Framework는 애플리케이션의 주도권이 개발자에게 있다

5. Spring Boot

 1) Spring Boot 사용 목적

• XML 기반의 복잡한 설계 방식을 지양한다
  - 기존에 사용하던 Spring의 복잡한 설정에서 탈피할 수 있다
• 의존 라이브러리를 자동으로 관리한다
  - Spring Boot의 starter 모듈 자동구성 기능으로 라이브러리의 수동 설정의 불편함을 제거하였다

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    implementation 'com.h2database:h2'
}

• 애플리케이션 설정을 자동으로 구성한다
   - Spring Boot은 스타터(Starter) 모듈을 통해 설치되는 의존 라이브러리를 기반으로 애플리케이션의 설정을 자동으로 구성한다

implementation 'org.springframework.boot:spring-boot-starter-web'

       - 위와 같은 starter를 작성하면 Spring Boot은 애플리케이션이 웹 애플리케이션이라고 인식하고 웹 애플리케이션을 띄울 서블릿 컨테이너(디폴트: Tomcat) 설정을 자동으로 구성한다

implementation 'org.springframework.boot:spring-boot-starter-jdbc’

       - 위와 같은 starter를 작성하면 Spring Boot은 애플리케이션에 데이터베이스 연결이 필요하다고 인식하고 JDBC 설정을 자동으로 구성한다
       - Spring Boot에서 지원하는 자동 구성으로 인해 애플리케이션에 대한 설정을 직접해야하는 번거로움을 최소화할 수 있다
       - 자동 구성을 활성화 하기 위해서 아래와 같은 애너테이션을 코드에 추가해면 된다

@SpringBootApplication  // Spring Boot에서 자동 구성 설정을 활성화해 준다
public class SampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SampleApplication.class, args);
    }
}

• 프로덕션급 애플리케이션의 빌드를 쉽게 할 수 있다
  - Spring Boot을 사용하면 개발한 애플리케이션 구현 코드를 손쉽게 빌드할 수 있다
  - build > bootJar(더블 클릭) 하면 libs > 파일명.jar 와 같이 애플리케이션 실행 파일이 생성된다
  - 직접 빌드 결과물을 War 파일 형태로 WAS(Web Application Server)에 올릴 필요가 없다

※ WAS(Web Application Server)

 - Java 기반의 웹 애플리케이션을 배포하는 일반적인 방식은 개발자가 구현한 애플리케이션 코드를 WAR(Web application ARchive) 파일 형태로 빌드한 후에 WAS(Java에서는 서블릿 컨테이너라고도 한다)라는 서버에 배포해서 해당 애플리케이션을 실행하는 것이다

 - Java에서 사용되는 대표적인 WAS에는 Tomcat이 있다

 - WAS는 구현된 코드를 빌드해서 나온 결과물을 실제 웹 애플리케이션으로 실행되게 해주는 서버이다

• 내장된 WAS를 통해 배포를 쉽게 할 수 있다
   - Spring Boot은 Apache Tomcat이라는 WAS를 내장하고 있기때문에 별도의 WAS를 구축할 필요가 없다
   - Spring Boot을 통해 빌드된 jar 파일을 이용해서 아래와 같은 명령어를 cmd에서 입력 해주면 서비스 가능한 웹 애플리케이션을 실행 할 수 있다

java -jar sample-app.jar

※ 참조 링크

▶ 자바 서블릿 :https://ko.wikipedia.org/wiki/%EC%9E%90%EB%B0%94_%EC%84%9C%EB%B8%94%EB%A6%BF

▶ 서블릿 컨테이너 : https://ko.wikipedia.org/wiki/%EC%9B%B9_%EC%BB%A8%ED%85%8C%EC%9D%B4%EB%84%88

▶ 아파치 톰캣 : https://ko.wikipedia.org/wiki/%EC%95%84%ED%8C%8C%EC%B9%98_%ED%86%B0%EC%BA%A3

https://tomcat.apache.org/

1. Spring Framework 실습환경 구성

• JDK-11 설치되어 있어야 한다
• JAVA_HOME 설정되어 있어야 한다
• IntelliJ Community Edition이 설치되어 있어야 한다

2. Spring Boot 기반 샘플 프로젝트 생성

• Spring Initializr 기능을 이용하여 IntelliJ Community Editiond에서 프로젝트 생성한다
• https://start.spring.io/ 스프링 부트 기반의 프로젝트를 만들어 주는 사이트로 이동한다

• 아래와 같이 설정한다
  - Project 항목은 최근에 Gradle 을 많이 사용한다
  메이븐(Maven)과 그래들(Gradle)의 개념 및 비교 — 슬기로운 개발생활😃 (tistory.com)
  - Spring Boot 항목은 자동 설정된 상태 그대로 사용한다
  - SNAPSHOT는 만들고 있는 버젼을 의미한다
  - 3.0.0(M3)는 기능 개발은 되었지만 출시 소프트웨어가 결정되지 않았음을 의미한다
  - Project Metadata 항목은 사용자에 맞게 변경해 준다
    → Group : 기업이나 도메인 명을 주로 작성한다
    → Artifact : 결과물의 이름을 작성한다(프로젝트명)
    → Name : Artifact 명으로 자동 작성된다
    → Description
    → Package name : Group + Artifact 결합으로 자동생성
    → Packaging
       : 일반적으로 Spring Boot 애플리케이션은 WAS를 내장하고
         있는 Jar 파일 형태로 배포해서 실행한다
       : 개발한 코드들을 빌드해서 하나의 빌드 결과물로 만들어
         낸다는 의미이다        
    → Java : 컴퓨터에 설치된 버젼을 선택한다

•  우측의 ADD DEPRNDENCIES를 클릭하여 아래의 모듈을 선택한다
  - 어떤 스프링 기반의 라이브러리를 사용할 것인지를 결정한다
  - Lombok
   : @Getter, @Setter 등의 애노테이션을 통해 자주 사용하는 Java 코드를 자동으로 구성해주는 라이브러리이다
  - Spring Web
• 하단의 GENERATE를 클릭하여 샘플 프로젝트를 다운한다

• 별도의 project 폴더를 만들고 다운받은 파일을 압축해제 한다

3. 탬플릿 프로젝트 열기

• IntelliJ를 열고 다운로드 한 폴더를 open 한다

• 신뢰할 수 있는 파일인지 묻는다면 ok하고 진행한다
• 템플릿 프로젝트를 오픈하면 Gradle 빌드 툴이 자동으로 빌드 작업을 한다

• 빌드가 진행됨에 따라 External Libraries 하위에 의존 라이브러리들이 생성된다

• External Libraries 하위에 의존 라이브러리들이 보이지 않을 경우 아래와 같이 진행하여 라이브러리를 생성한다
  - 우측의 메뉴에서 Gradle 탭을 눌러서 오픈한다

- 프로젝트 이름에서 마우스 오른쪽 버튼을 눌러 컨텍스트 메뉴를 오픈한다
- Reload Gradle Project를 클릭한다
- External Libraries 하위에 의존 라이브러리가 있는지 확인한다
- 그래도 나타나지 않으면 IntelliJ를 종료 후 다시 진행해 본다

4. Lombok 설정

• IntelliJ 상단의 File 메뉴에서 Setting 을 오픈한다

• [Build, Execution, Deployment] > [Compiler] > [Annotation Processors] 메뉴를 선택한다
• [Enable annotation processing] 체크 박스에 체크한 후, [Apply] > [OK] 버튼을 차례로 클릭한다

• [Enable annotation processing] 체크 박스에 체크를 해야 Lombok을 정상적으로 사용할 수 있다

5. Spring Boot Application 동작 확인

• IntelliJ에서 Section2Week3Application.java 파일을 더블 클릭해서 오픈한다

• 파일을 실행시킨다
• 실행 라인에 .Section2Week3Application  : Started Section2Week3Application in 2.013 seconds (JVM running for 2.383) 문구가 출력되면 정상 실행된 것이다 

• 죄측의 실행아이콘이 계속 돌고 있는 것은 애플리케이션 자체가 내장 WAS에서 실행이 되고 있음을 의미하는 지극히 정상적인 동작이다
• 위 화면의 아래에서 4번째 줄에 출력된 port 번호를 확인한 후 Crome 창을 열고 localhost:8080 을 입력한다
  - 아래와 같이 에러가 뜨면 성공이다
  - 현재 아무것도 작성한 내용이 없으므로 에러가 뜨는 것이 정상이다

• IntelliJ 에서 실행을 중단한 후 다시  localhost:8080 화면을 새로고침 한다
  - 아래와 같이 출력되면 정상이다
  - 스프링부트 파일을 실행 중단하였으므로 8080 port에 연결할 수 없는 것이다

• 간단히 출력화면을 보고 싶다면 다음과 같이 작성 후 실행해 본다
  - [src] > [main] > [resources] > [static] > 마우스 우클릭 > 새로만들기 > HTML > 이름을 hello 로 입력 후 Enter
  - 아래와 같이 HTML 화면이 나오면 body에 아래와 같이 작성한다

<body>
    <h1>Hello SpringBoot World!!!</h1>
</body>

• main > java 파일을 재실행 한 후 새로 작성한 HTML파일이 실행되도록 Crome에서 localhost:8080/hello.html 을 입력한다