나무정원

JAR (Java Archive) 파일은 Java 프로젝트의 클래스 파일과 리소스를 압축하여 하나의 파일로 패키징하는 방법입니다. JAR 파일을 생성하는 방법은 다음과 같습니다:

1. Maven을 사용하는 경우:

   - Maven은 프로젝트 빌드 도구로서 JAR 파일을 생성하는 기능을 내장하고 있습니다.
   - Maven 프로젝트의 `pom.xml` 파일에 빌드 구성을 작성합니다.
   - `pom.xml` 파일에 JAR 패키징을 위한 `<packaging>` 요소를 `jar`로 설정합니다.
   - Maven 명령어인 `mvn package`를 실행하여 JAR 파일을 생성합니다.
   - `target` 디렉토리 내에 생성된 JAR 파일을 확인할 수 있습니다.

2. Gradle을 사용하는 경우:

   - Gradle은 빌드 자동화 도구로서 JAR 파일 생성 기능을 제공합니다.
   - Gradle 프로젝트의 `build.gradle` 파일에 빌드 스크립트를 작성합니다.
   - JAR 파일 생성을 위해 `jar` 플러그인을 추가하고, 관련 설정을 작성합니다.
   - Gradle 명령어인 `gradle build`를 실행하여 JAR 파일을 생성합니다.
   - `build/libs` 디렉토리 내에 생성된 JAR 파일을 확인할 수 있습니다.

3. 직접 컴파일하는 경우:

   - 컴파일러 명령어를 사용하여 소스 코드를 컴파일하고, JAR 파일을 생성할 수도 있습니다.
   - 소스 코드를 컴파일하여 클래스 파일을 생성합니다.
   - 클래스 파일과 필요한 리소스 파일을 JAR 파일로 패키징합니다.
   - 컴파일된 클래스 파일과 리소스 파일을 JAR 파일로 압축하고, MANIFEST.MF 파일을 추가합니다.
   - 압축된 JAR 파일을 실행 가능한 JAR 파일로 만들기 위해 실행 클래스를 지정합니다.
   - 컴파일러나 빌드 도구를 사용하지 않는 경우, JDK에 포함된 `jar` 명령어를 사용하여 JAR 파일을 생성할 수 있습니다.

위의 방법은 일반적인 JAR 파일 생성 방법을 설명한 것이며, 프로젝트의 종류와 사용하는 빌드 도구에 따라 조금씩 차이가 있을 수 있습니다. 각 도구 또는 환경의 문서를 참조하여 해당 도구에서 제공하는 JAR 파일 생성 방법을 찾을 수 있습니다.

Maven VS Gradle

Maven과 Gradle은 둘 다 프로젝트 빌드 및 종속성 관리 도구로서 사용되지만, 몇 가지 차이가 있습니다:

1. XML vs. Groovy/Kotlin DSL:
   - Maven은 XML 기반의 설정 파일인 `pom.xml`을 사용합니다. 프로젝트의 구조, 종속성, 빌드 설정 등을 XML 요소로 정의합니다.
   - Gradle은 Groovy 또는 Kotlin 기반의 DSL(Domain Specific Language)을 사용합니다. DSL은 좀 더 간결하고 가독성이 높은 스크립트 형식으로 빌드 스크립트를 작성할 수 있도록 합니다.

2. 선언적 vs. 명령적 접근:
   - Maven은 선언적인 접근 방식을 채택합니다. 프로젝트의 의존성이나 빌드 설정을 선언하고, Maven이 해당 설정을 기반으로 빌드를 수행합니다.
   - Gradle은 명령적인 접근 방식을 사용합니다. 개발자는 빌드 스크립트에서 각 작업에 대한 명령을 직접 작성할 수 있으며, 빌드 동작을 세밀하게 제어할 수 있습니다.

3. 생산성과 확장성:
   - Gradle은 더 유연하고 강력한 기능 세트를 제공하여 개발자가 프로젝트를 더 세밀하게 제어할 수 있도록 합니다. 특히, Groovy 또는 Kotlin을 사용하여 빌드 스크립트를 작성하면 매우 유연하고 표현력이 뛰어난 빌드 스크립트를 구성할 수 있습니다.
   - Maven은 간단하고 직관적인 구조를 가지고 있어 초기 설정이 쉽고, 기본 설정을 사용하는 경우 많은 작업을 자동으로 처리할 수 있습니다.

4. 생태계:
   - Maven은 매우 넓은 커뮤니티와 많은 플러그인, 리소스, 템플릿을 제공합니다. Maven 중앙 저장소는 수많은 오픈 소스 라이브러리와 종속성을 호스팅하고 있으며, 이를 쉽게 사용할 수 있습니다. Maven을 사용하면 다양한 프로젝트에서 사용되는 표준적인 빌드 프로세스를 구축할 수 있습니다.
   - Gradle은 Maven과 비슷한 생태계를 가지고 있지만, 상대적으로 최신 기술과 동향에 더 빠르게 적응하고 있습니다. Gradle은 Groovy 및 Kotlin DSL을 사용하여 빌드 스크립트를 작성할 수 있으며, 이를 통해 매우 유연하고 표현력이 뛰어난 빌드 스크립트를 작성할 수 있습니다. 또한, Gradle은 다양한 플러그인과 확장 기능을 제공하여 다양한 작업을 자동화하고 빌드 프로세스를 더욱 향상시킬 수 있습니다.

개발자의 선호도, 프로젝트의 특성, 조직의 요구사항 등을 고려하여 Maven과 Gradle 중에서 선택할 수 있습니다. Maven은 간단하고 직관적인 구조로 프로젝트를 빠르게 구성할 수 있으며, 이미 Maven을 사용하는 프로젝트에 적합합니다. Gradle은 유연성과 확장성이 중요한 프로젝트에 적합하며, 더 강력한 기능과 DSL을 활용하여 빌드 프로세스를 세밀하게 제어할 수 있습니다.

선언적 접근방식 vs 명령적 접근방식

선언적 접근 방식과 명령적 접근 방식은 프로그래밍 언어나 도구에서 사용되는 두 가지 다른 접근 방식을 의미합니다.

1. 선언적 접근 방식(Declarative Approach):
   - 선언적 접근 방식은 "무엇(What)"을 수행할 것인지를 명시하고, 구체적인 실행 방법은 도구나 프레임워크가 알아서 처리하는 방식입니다.
   - 프로그래머는 목표를 선언하고 원하는 결과를 기술합니다. 그러면 도구나 프레임워크는 이를 해석하고 필요한 작업을 수행합니다.
   - Maven은 선언적 접근 방식을 채택하여 프로젝트의 의존성, 빌드 구성, 배포 설정 등을 XML 기반의 POM(Project Object Model) 파일에 선언합니다. Maven은 POM 파일을 해석하여 필요한 작업을 수행하고, 개발자는 목표를 달성하기 위한 설정과 의존성을 정의합니다.

2. 명령적 접근 방식(Imperative Approach):
   - 명령적 접근 방식은 "어떻게(How)" 수행할 것인지를 세부적으로 명시하는 방식입니다.
   - 프로그래머는 각각의 단계와 명령을 구체적으로 작성하여 원하는 작업을 달성합니다.
   - Gradle은 명령적 접근 방식을 사용합니다. 빌드 스크립트를 작성할 때 Groovy 또는 Kotlin 언어를 사용하여 세부 단계와 작업을 명시적으로 작성합니다. Gradle은 이러한 스크립트를 해석하여 작업을 수행합니다.

선언적 접근 방식은 개발자가 목표를 달성하기 위한 구체적인 단계를 신경 쓰지 않고 목표에 집중할 수 있도록 도와줍니다. 반면, 명령적 접근 방식은 개발자가 세부적인 작업을 직접 제어하고 특정 작업의 순서와 실행 방법을 정확히 지정할 수 있습니다. 어떤 접근 방식을 선택할지는 프로젝트의 특성과 개발자의 선호도에 따라 다를 수 있습니다.

Spring Batch는 대용량의 데이터를 처리하는 일괄 처리(Batch Processing)를 위한 프레임워크입니다. 일괄 처리는 주기적으로 반복되거나 대량의 데이터를 처리해야 하는 작업을 말하며, 주로 데이터베이스 처리, 파일 처리, 웹 서비스 호출 등을 포함합니다.

Spring Batch는 Spring 프레임워크의 일부로 개발되었으며, 개발자가 일괄 처리 작업을 구조화하고 관리할 수 있도록 도와줍니다. 주요한 기능과 특징은 다음과 같습니다:

1. 재시작과 복구: Spring Batch는 작업의 실행 상태를 추적하고, 실패한 작업을 자동으로 재시작하거나 복구할 수 있는 기능을 제공합니다. 이를 통해 안정적인 일괄 처리를 보장할 수 있습니다.

2. 트랜잭션 관리: Spring Batch는 각각의 단일 작업 단위에 대해 트랜잭션 관리를 제공합니다. 작업이 실패하면 트랜잭션 롤백을 수행하여 데이터의 일관성을 유지할 수 있습니다.

3. 청크 지향 처리: Spring Batch는 데이터를 청크(chunk) 단위로 처리합니다. 청크는 한 번에 처리될 데이터의 묶음을 의미하며, 대용량 데이터를 작은 덩어리로 나누어 처리하므로 메모리 사용을 최적화할 수 있습니다.

4. 잡과 스텝: Spring Batch는 작업을 잡(Job)과 스텝(Step)으로 구성합니다. 잡은 일괄 처리 작업 단위를 나타내며, 스텝은 잡 내에서 실제로 처리되는 작업 단위를 의미합니다. 이를 통해 복잡한 일괄 처리 작업을 구성하고 관리할 수 있습니다.

5. 스프링 통합: Spring Batch는 Spring 프레임워크와 긴밀하게 통합되어 있습니다. 따라서 Spring의 다른 기능과 라이브러리를 함께 사용할 수 있으며, Spring의 의존성 주입(Dependency Injection)과 AOP(Aspect-Oriented Programming) 등의 기능을 활용할 수 있습니다.

Spring Batch는 대용량 데이터 처리, 정기적인 일괄 처리 작업, 데이터 마이그레이션, 데이터 가공 등의 다양한 시나리오에서 사용됩니다. Spring Batch를 사용하면 안정적이고 확장 가능한 일괄 처리 솔루션을 구현할 수 있습니다.

Spring Boot vs Spring Project

Spring Boot와 Spring Project는 둘 다 Java 기반의 웹 애플리케이션을 개발하기 위해 사용되는 프레임워크입니다. 하지만 두 프로젝트는 목표와 접근 방식에서 차이가 있습니다.

Spring Project

   - Spring Project는 일반적으로 Spring Framework를 기반으로 하는 전통적인 방식의 웹 애플리케이션 개발을 지칭합니다.
   - Spring Framework는 경량 컨테이너, 의존성 주입(Dependency Injection), AOP(Aspect-Oriented Programming) 등 다양한 기능을 제공하는 대표적인 Java 기반의 프레임워크입니다.
   - Spring Project에서는 개발자가 직접 Spring Framework의 구성 요소를 설정하고, 필요한 라이브러리와 모듈을 선택하여 프로젝트를 구성해야 합니다.
   - XML 또는 Java Configuration 파일을 사용하여 Spring Bean을 정의하고, 서비스, 리포지토리, 컨트롤러 등의 계층을 수동으로 구성합니다.
   - 개발자는 다양한 설정과 구성 작업을 수행해야 하며, 프로젝트의 복잡성이 상대적으로 높을 수 있습니다.

Spring Boot

   - Spring Boot는 Spring Framework를 기반으로 하는 웹 애플리케이션을 빠르고 쉽게 구축하기 위한 프레임워크입니다.
   - Spring Boot는 개발자가 최소한의 설정으로 실행 가능한 독립적인 애플리케이션을 만들 수 있도록 자동 설정과 제약조건을 제공합니다.
   - Spring Boot는 내장형 서버를 포함하여 필요한 의존성, 설정 및 구성 요소를 자동으로 관리합니다.
   - 개발자는 별다른 설정 없이 기본적인 구조를 갖춘 Spring Boot 애플리케이션을 작성할 수 있으며, 스프링 부트 스타터 의존성을 사용하여 필요한 모듈과 라이브러리를 간편하게 추가할 수 있습니다.
   - Spring Boot는 Convention over Configuration 원칙을 따르며, 개발자가 명시적인 설정을 하지 않아도 약속된 규칙을 따라 자동으로 동작합니다.
   - Spring Boot 애플리케이션은 단독 실행 가능한 JAR 파일로 패키징되며, 서버에 별도의 웹 컨테이너를 설치할 필요가 없습니다.

따라서, Spring Project는 전통적인 Spring Framework를 기반으로 하는 웹 애플리케이션 개개발 방식과 접근 방식에서 Spring Boot와 Spring Project의 차이를 보다 구체적으로 설명해 드리겠습니다.

1. 개발 방식:
   - Spring Project: Spring Framework를 사용하는 전통적인 개발 방식으로, 개발자가 모든 구성 요소를 수동으로 설정하고 구현해야 합니다. XML 또는 Java Configuration 파일을 사용하여 빈(Bean) 정의와 의존성 주입(Dependency Injection)을 설정해야 합니다.
   - Spring Boot: Spring Boot는 개발자에게 자동 설정과 기본적인 구조를 제공하여 개발자가 별도의 설정 없이 빠르게 개발에 집중할 수 있도록 합니다. 개발자는 주요 의존성과 구성 요소를 간편하게 추가하기 위해 스프링 부트 스타터 의존성을 사용할 수 있습니다.

2. 컨벤션과 설정:
   - Spring Project: 개발자는 명시적인 설정과 구성을 수행해야 합니다. Spring Framework의 다양한 설정 파일 및 구성 옵션을 이용하여 애플리케이션을 세밀하게 제어할 수 있습니다.
   - Spring Boot: Spring Boot는 "의약품(Docs as Code)" 원칙에 따라 약속된 컨벤션을 따르며, 개발자가 최소한의 설정으로 애플리케이션을 실행할 수 있도록 합니다. 개발자는 자동 설정 기능과 컨벤션을 준수하여 애플리케이션을 구축하며, 필요에 따라 커스터마이징할 수 있습니다.

3. 서버 실행 환경:
   - Spring Project: 일반적으로 Spring Project는 별도의 서버에 배포되어 실행됩니다. Apache Tomcat, Jetty, JBoss 등 다양한 웹 컨테이너를 사용하여 Spring 애플리케이션을 호스팅합니다.
   - Spring Boot: Spring Boot는 내장형 서버(Tomcat, Jetty, Undertow)를 포함하여 단독 실행 가능한 JAR 파일 형태로 애플리케이션을 패키징합니다. 별도의 웹 서버 설치 없이도 개발 및 실행이 가능합니다.

4. 편의성과 생산성:
   - Spring Project: Spring Framework를 자세히 이해하고 설정하는 데 시간과 노력이 필요합니다. 모든 구성 요소와 설정을 수동으로 작성해야 하므로 초기 설정 작업이 번거로울 수 있습니다.
   - Spring Boot: Spring Boot는 기본 설정과 자동 구성 기능을 제공하여 개발자가 빠르게 애플리케이션을 개발하고 실행할 수 있습니다.

5. 의존성 관리:
   - Spring Project: 개발자는 필요한 의존성을 수동으로 관리해야 합니다. Maven 또는 Gradle과 같은 빌드 도구를 사용하여 의존성을 명시적으로 선언하고 관리해야 합니다.
   - Spring Boot: Spring Boot는 스프링 부트 스타터 의존성을 통해 의존성 관리를 간편하게 처리합니다. 스타터 의존성은 일련의 관련된 의존성을 묶어 제공하며, 개발자는 필요한 스타터 의존성을 추가함으로써 의존성 관리를 자동화할 수 있습니다.

6. 설정과 프로파일:
   - Spring Project: 개발자는 XML 또는 Java Configuration 파일을 사용하여 애플리케이션의 설정을 작성해야 합니다. 프로파일(Profile)을 통해 다양한 환경에 대한 설정을 분리하고 관리할 수 있습니다.
   - Spring Boot: Spring Boot는 자동 설정 기능을 제공하여 개발자가 별도의 설정 파일을 작성하지 않아도 됩니다. application.properties 또는 application.yml 파일을 사용하여 간단한 설정을 제공하며, 다양한 프로파일을 지원하여 환경별 설정을 관리할 수 있습니다.

7. 실행 및 배포:
   - Spring Project: Spring Project는 전통적인 웹 애플리케이션 서버(WAS)에 배포하여 실행됩니다. 개발자는 WAR 파일을 생성하고 서버에 배포하는 과정을 거쳐야 합니다.
   - Spring Boot: Spring Boot는 내장형 서버를 사용하여 애플리케이션을 실행할 수 있습니다. 단독 실행 가능한 JAR 파일로 패키징되며, 개발자는 명령어를 통해 애플리케이션을 실행할 수 있습니다. 또한, 클라우드 환경이나 컨테이너 환경에서도 쉽게 배포할 수 있습니다.

결론적으로, Spring Boot는 Spring Project에 비해 개발의 편의성과 생산성을 높여줍니다. 자동 설정과 스타터 의존성을 통해 초기 설정 작업을 최소화하고, 내장형 서버와 단독 실행 가능한 JAR 파일을 제공하여 배포 및 실행을 간단하게 처리할 수 있습니다. 또한, 컨벤션 over 설정 원칙을 따라 일관된 구조와 규칙을 제약할 수 있습니다.

8. 모니터링과 관리:
   - Spring Project: Spring Project에서는 애플리케이션의 모니터링과 관리를 위한 별도의 모듈이나 도구를 사용해야 합니다. 예를 들어, Spring Actuator를 추가하여 애플리케이션의 메트릭스, 헬스 체크, 엔드포인트 등을 노출시킬 수 있습니다.
   - Spring Boot: Spring Boot는 Actuator 모듈을 기본으로 제공하여 애플리케이션의 모니터링과 관리를 쉽게 할 수 있습니다. Actuator를 사용하면 HTTP 엔드포인트를 통해 애플리케이션의 정보를 조회하고, 메트릭스를 수집하고, 로그 레벨을 동적으로 변경하는 등의 작업을 수행할 수 있습니다.

9. 마이크로서비스 아키텍처:
   - Spring Project: Spring Framework를 기반으로 하는 전통적인 방식의 개발에서는 마이크로서비스 아키텍처를 구현하기 위해 추가적인 설정과 관리 작업이 필요합니다. 서비스 디스커버리, 로드 밸런싱, 서킷 브레이커 등의 기능을 수동으로 구현해야 합니다.
   - Spring Boot: Spring Boot는 기본적으로 마이크로서비스 아키텍처를 지원하기 위한 기능과 통합을 제공합니다. Netflix OSS, Spring Cloud 등의 프레임워크와의 통합을 통해 서비스 디스커버리(Eureka), 로드 밸런싱(Ribbon), 서킷 브레이커(Hystrix) 등의 기능을 자동으로 제공합니다.

10. 커뮤니티와 생태계:
   - Spring Project: Spring Framework는 오랜 역사와 넓은 커뮤니티를 가지고 있어 다양한 리소스, 문서, 튜토리얼, 예제 등을 찾아볼 수 있습니다. 또한, Spring 생태계는 다양한 모듈과 라이브러리로 구성되어 있어 개발자가 유연하게 선택하여 사용할 수 있습니다.
   - Spring Boot: Spring Boot는 Spring Framework의 생태계와 커뮤니티를 기반으로 하고 있어, 다양한 지원과 확장성을 제공합니다. Spring Boot 스타터와 Spring Boot Actuator를 비롯한 다양한 모듈과 도구들이 활발하게 개발되고 유지보수되고 있습니다.

요약하면, Spring Project는 다양한 리소스와 유연한 모듈 선택을 통해 개발자에게 큰 자유도를 제공하는 반면, Spring Boot는 Spring Framework를 기반으로 한 빠른 애플리케이션 개발과 편리한 확장성을 제공합니다. 두 프로젝트는 각자의 장점과 목적에 따라 선택되며, 프로젝트의 규모와 요구사항에 맞게 고려하여 사용하면 됩니다.

• Interceptor는 웹 애플리케이션에서 요청과 응답 처리 과정을 가로채고 수정 또는 보완할 수 있는 기능을 제공하는 컴포넌트

• 일반적으로 Interceptor는 프레임워크나 미들웨어에서 제공되며, 요청을 처리하기 전과 후에 실행되는 코드 블록으로 구성

Interceptor의 주요 목적

• 인증과 권한 부여: Interceptor를 사용하여 사용자 인증 또는 권한 부여를 수행. 예를 들어, 로그인이 필요한 페이지에 접근할 때 Interceptor를 사용하여 사용자가 로그인되어 있는지 확인하고, 필요한 권한을 가지고 있는지 확인

• 로깅: Interceptor를 사용하여 요청과 응답에 대한 로그를 작성. 이를 통해 애플리케이션의 동작을 추적하고 디버깅에 도움

• 예외 처리: Interceptor를 사용하여 예외를 처리하고 오류 페이지 보여줌. 예를 들어, 예외가 발생하면 Interceptor에서 예외를 캐치하고, 사용자에게 오류 메시지를 보여주는 대체 페이지로 리다이렉션
• 캐싱: Interceptor를 사용하여 응답을 캐싱하고 이전에 요청한 동일한 요청에 대해 캐시된 응답을 반환. 이를 통해 서버의 부하를 줄이고 응답 시간을 개선.
• 트랜잭션 관리: Interceptor를 사용하여 트랜잭션을 시작하거나 종료. 이를 통해 데이터베이스 작업과 같은 트랜잭션 범위에서 요청을 처리

   - Spring에서 Interceptor는 HandlerInterceptor 인터페이스를 구현하여 만들 수 있습니다.
   - Interceptor는 preHandle, postHandle, afterCompletion 등의 메서드를 오버라이드하여 요청 전, 요청 후, 응답 완료 후에 실행할 로직을 구현할 수 있습니다.
   - preHandle 메서드는 요청을 처리하기 전에 실행되고, 요청을 가로채고 처리 여부를 결정할 수 있습니다.
   - postHandle 메서드는 요청 처리 후에 실행되고, 컨트롤러의 처리 결과에 대한 로직을 추가할 수 있습니다.
   - afterCompletion 메서드는 응답이 완료된 후에 실행되고, 리소스 정리 등의 작업을 수행할 수 있습니다.

어노테이션

어노테이션 설정 추가시, <bean>에 Context관련 namespace와 schema 문서위치 등록필요

 - namespace에서 context 체크박스 체크

자동 주소 추가됨

컴포넌트 스캔(component-scan) 설정

 - 사용할 객체들 <bean>에 등록하지 않고, 자동으로 생성할때 필요

 - <context:component-scan.>엘리먼트 정의

 - 설정 추가시, 스프링 컨테이너가 classpath에 있는 클래스 스캔해서, @Component가 설정된 클래스들 자동객체 생성함

src/main/resources/applicationContext.xml 

<beans>
	<!-- 해당 경로 클래스 스캔해서, @Component설정된 클래스 자동 객체 생성 -->
	<context:component-scan base-package="polymorphsim"></context:component-scan>
    
    <bean id="tv" class="polymorphsim.LgTV"></bean>
    
 </beans>

@Component

- 위에 applicationContext에 컴포넌트 스캔 설정했으면, 설정파일에 클래스들을 일일이 <bean>엘리먼트로 등록안해도됨

 - 컴포넌트 어노테이션은 클래스 위에 선언 ("변수")

package polymorphsim;

import org.springframework.stereotype.Component;

@Component("tv")
public class LgTV implements TV{
	public LgTV() {
		System.out.println("===> LgTV 객체 생성");
	}
	public void powerOn() {
		System.out.println("LgTV --전원 켠다.");
	}
	public void powerOff() {
		System.out.println("LgTV --전원 끈다.");
	}
	public void volumeUp() {
		System.out.println("LgTV --소리 올린다.");
	}
	public void volumeDown() {
		System.out.println("LgTV --소리 내린다");
	}
}

의존성 주입 어노테이션

스프링에서 의존성 주입을 지원하는 어노테이션 

@Autowired 

- 생성자, 메소드, 멤버변수 위에 모두 사용가능 (대부분은 멤버변수위에 선언)|
- 변수의 타입을 기준으로 객체를 검색하여 의존성 주입을 처리

- 스프링 컨테이너가 멤버변수 위에있는 어노테이션 확인하는 순간 변수타입 체크
  > 그 타입의 객체가 메모리 존재여부 확인 > 객체를 변수에 주입

- @Autowired가 붙은 객체가 메모리에 없으면, 컨테이너는 NoSuchBeanDefinitionException 발생시킴

  (=해당 어노테이션 대상 객체가 메모리에 존재하지 않음)

 ** 의존성 관계에 있는경우, 관련있는 객체가 메모리에 없는경우 에러가 발생함 (위 이미지처럼)

   관련있는 객체를 메모리에 생성하려면, applicationContext.xml에 아래 두가지 방법중 하나 

(1) <bean id="~" class="~"></bean> 의존관계 클래스를 bean을 명시하거나

(2) 의존관계 있는 클래스에 @Component("sony")처럼  어노테이션 설정해주기 
 > 단 <context:component-scan/>에 해당 패키지명이 명시되어있어야함

(예제는 컨테이너가 SonySpeaker객체를 speaker 변수에 자동 할당해준다고 )

@Qualifier

의존성 주입될 객체의 아이디나 이름을 지정할 수 있음.  

NoUniqueBeanDefinitionException ㅣ 의존성 주입대상 되는 Speaker타입 객체가 두개이상일때 문제  발생

SonySpeaker과, AppleSpeaker 객체가 모두 메모리에 생성되어있는 상태라면, 컨테이너는 어떤 객체를 할당할지 스스로 판별할수 없어서 에러발생 

이런경우, @Autowired되는 대상이 Speaker타입 객체가 AppleSpeaker, SonySpeaker 두개이고, 둘다 메모리에 생성된경우 발생함

해결하기 위해 @Qulifier어노테이션 사용, @AutoWired밑에 명시

src/main/java/polymorphsim/LgTV 

package polymorphsim;

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

@Component("tv")
public class LgTV implements TV{
	@Autowired
	@Qualifier("apple")
	private Speaker speaker;
	public LgTV() {
		System.out.println("===> LgTV 객체 생성");
	}
	public void powerOn() {
		System.out.println("LgTV --전원 켠다.");
	}
	public void powerOff() {
		System.out.println("LgTV --전원 끈다.");
	}
	public void volumeUp() {
		speaker.volumeUp();
		//System.out.println("LgTV --소리 올린다.");
	}
	public void volumeDown() {
		speaker.volumeDown();
		//System.out.println("LgTV --소리 내린다");
	}
}

실행결과

@Resource

- 객체의 이름을 이용하여 의존성 주입을 처리
 - name 속성을 사용, 스프링 컨테이너가 해당 이름으로 객체 검색해서 의존성 주입 처리

- Resource와 같은 기능의 어노테이션 @Inject 둘다 이름기반 의존성 주입

src/main/java/polymorphsim/LgTV 

package polymorphsim;

import org.springframework.stereotype.Component;
import javax.annotation.Resource;

@Component("tv")
public class LgTV implements TV{
	
	@Resource(name="apple")
	private Speaker speaker;
	
	public LgTV() {
		System.out.println("===> LgTV 객체 생성");
	}
	public void powerOn() {
		System.out.println("LgTV --전원 켠다.");
	}
	public void powerOff() {
		System.out.println("LgTV --전원 끈다.");
	}
	public void volumeUp() {
		speaker.volumeUp();
		//System.out.println("LgTV --소리 올린다.");
	}
	public void volumeDown() {
		speaker.volumeDown();
		//System.out.println("LgTV --소리 내린다");
	}
}

 >> apple 이름으로 메모리에 생성된 AppleSpeaker객체를 speaker변수에 할당

Spring 의존성 주입

** 결론 : 두개를 적절히 섞어서 쓰기

 변경되지 않는 객체는 어노테이션으로 설정하여 사용
 변경될 가능성이 있는 객체는 XML설정으로 사용

IoC(제어의 역행)

스프링 객체의 생성, 의존관계를 스프링에서 자동으로 관리

의존성(Dependency)는 객체와 객체와의 관계를 의미

Dependency Lookup : 컨테이너가 객체를 생성, 클라이언트는 생성한 객체를 검색해서 사용 (실 개발과정 미사용)

Denepdency Injection (Setter/Constructor Inection) : 컨테이너가 직접 객체들 사이에 의존관계를 처리

 - Setter과 Constructor의 공통점 : 멤버변수를 원하는 값으로 설정하는것 목적
 - 결과는 같으므로 어떤방법 쓰던지 상관없음
    단, 코딩컨벤션 따라 한가지로 통일. 대부분은 Setter사용 / Setter메소드 제공되지 않는 클래스만 생성자인젝션

생성자 인젝션(Constructor Injection)

 - xml에서 클래스 찾아서 객체생성시, 매개변수 없는 기본생성자를 호출

 - 기본생성자 외에 매개변수를 가지는 다른 생성자 호출하도록 생성할 수 있음

 - 생성자 인젝션을 사용해서, 생성자의 매개변수(예시:sony)로 의존관계에 있는 객체주소 정보 전달가능

 - 예시 : <constructor-arg index="0" ref="apple"></constructor-arg> <constructor-arg index="1" value="2000000"></constructor-arg>

이클립스 자동 생성자 추가

생성하려는 클래스 열고 > alt + shift + s > Generate Constructor using Fields> 초기화할 멤버변수 선택후 OK

src/main/java/polymorphsim/SonySpeaker.java

package polymorphsim;

public class SonySpeaker {
	public SonySpeaker() {
		System.out.println("===> SonySpeaker 객체 생성");
	}
	public void volumeUp() {
		System.out.println("SonySpeaker---소리 울린다.");
	}
	public void volumeDown() {
		System.out.println("SonySpeaker---소리 내린다.");
	}
}

src/main/java/polymorphsim/SamsungTV.java

package polymorphsim;

public class SamsungTV implements TV{
	private SonySpeaker speaker;
	private int price;

	public SamsungTV() {
		System.out.println("===> SamsungTV(1) 객체생성");
	}
	public SamsungTV(SonySpeaker speaker) {
		System.out.println("===> SamsungTV(2) 객체생성");
		this.speaker=speaker;
	}
	
	public SamsungTV(SonySpeaker speaker, int price) {
		System.out.println("===> SamsungTV(3) 객체생성");
		this.speaker = speaker;
		this.price = price;
	}
	public void powerOn() {
		System.out.println("SamsungTv --전원 켠다. (가격: "+price+")");
	}
	public void powerOff() {
		System.out.println("SamsungTv --전원 끈다.");
	}
	public void volumeUp() {
		speaker.volumeUp();
	}
	public void volumeDown() {
		speaker.volumeDown();
	}
}

src/main/resources/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.xsd">

	<bean id ="tv" class="polymorphsim.SamsungTV">
		<constructor-arg index="0" ref="sony"></constructor-arg>
		<constructor-arg index="1" value="2000000"></constructor-arg>
	</bean>
	<bean id = "sony" class="polymorphsim.SonySpeaker"></bean>
    
</beans>

실행결과

• 객체 생성할때, 기본생성자가 아닌, 세번째 SaumsungTV(Speaker speakr, int price) 생성자가 사용됨.
• bean등록 순서대로 객체를 처리하는데, 생성자 인젝션으로 의존성 주입될 SonySpeaker가 먼저 객체생성SonySpeaker 객체를 매개변수로 받아들이는 생성자를 호출하여 객체 생성
• <constructor-arg>엘리먼트의 인자로 전달될 데이터가 <bean>인 다른 객체인경우 ref속성, 고정 문자열/정수인경우는 value
• 생성자 여러개 오버로딩 된 경우, index속성 통해 어떤값이 몇번째 매개변수로 매핑되는지 지정가능. 0부터시작

이클립스 자동 인터페이스 생성

생성할 인터페이스의 자식 열고 > alt + shift + T > Extract Interface> 생성할 인터페이스 이름/메소드 선택후 OK

 * 체크박스 전체해제

src/main/resources/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.xsd">

	<bean id ="tv" class="polymorphsim.SamsungTV">
		<constructor-arg index="0" ref="apple"></constructor-arg>
		<constructor-arg index="1" value="2000000"></constructor-arg>
	</bean>
	<bean id = "sony" class="polymorphsim.SonySpeaker"></bean>
	<bean id = "apple" class="polymorphsim.AppleSpeaker"></bean>
    
</beans>

자바코드 수정없이, <constructor-arg 의 ref를 "sony"대신 "apple"로 변경하여 AppleSpeaker호출가능

<추가 생성/수정한 파일>

(interface) Speaker.java

(class) SonySpeaker.java

(class) AppleSpeaker.java

(class) SamsungTV.java >> 매개변수/멤버변수를 SonySpeaker대신, Speaker로 변경

Setter Injection

- Setter메소드 호출해서 의존성 주입을 처리

- 대부분 생성자 주입 보다 setter 주입 사용

- Setter메소드는 스프링 컨테이너가 자동으로 호출, 호출시점은 <bean> 객체 생성 직후
  Setter인젝션 동작하려면, Setter메소드 뿐만 아니라, 기본 생성자도 반드시 필요

- 예시 : <constructor-arg index="0" ref="apple"></constructor-arg> <constructor-arg index="1" value="2000000"></constructor-arg>

이클립스 자동 생성자 추가

생성하려는 클래스 열고 > alt + shift + s > Generate Getter and Setters > 초기화할 멤버변수 선택후 OK

src/main/resources/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.xsd">

	<bean id ="tv" class="polymorphsim.SamsungTV">
		 <!-- Setter 주입 -->
		 <property name="speaker" ref="apple"></property>
		 <property name="price" value="2000000"></property>
	</bean>
    
	<bean id = "sony" class="polymorphsim.SonySpeaker"></bean>
	<bean id = "apple" class="polymorphsim.AppleSpeaker"></bean>
</beans>

• <property> 엘리먼트사용 필요, name속성값이 호출하려는 메소드이름
  - Setter 메소드 이름 : setSpeaker()
  - name 속성값 : name ="speaker"  (첫문자 대문자로 바꾸고 set붙인 차이..)
• 생성자주입처럼, Setter 메소드 호출하면서 다른 <bean>객체를 인자로 넘기려면 ref속성, 기본형데이터는 value속성

실행결과

p 네임스페이스 사용

applicationContext.xml에 추가

xmlns:p="http://www.springframework.org/schema/p"

(p네임스페이스 적용전)

<bean id ="tv" class="polymorphsim.SamsungTV" >
   <property name="speaker" ref="apple"></property>
   <property name="price" value="2000000"></property>
</bean>

(p 네임스페이스 적용후)

</bean id="tv" class="polymorphsim.samsungtv" p:speaker-ref="sony" p:price="2000000">

 sts기능으로 p네임스페이스 추가방법

컬렉션 객체 설정

스프링에서 컬렉션 매핑과 관련된 엘리먼트들을 지원. 

List

src/main/java/com/springbook/ioc/injection/CollectionBean.java

package com.springbook.ioc.injection;

import java.util.List;
import java.util.Set;

public class CollectionBean {
	private List<String> addressList;
	public void setAddressList(List<String> addressList) {
		this.addressList = addressList;
	}
	
}

src/main/resources/applicationContext.xml

	<bean id ="collectionBean" class="com.springbook.ioc.injection.CollectionBean">
		<property name="addressList">
			<list>
				<value>경기도</value>
				<value>서울</value>
			</list>
		</property>
	</bean>

--> applicationContext에도 <list>엘리먼트 사용

Set (중복미허용)

src/main/java/com/springbook/ioc/injection/CollectionBean.java

package com.springbook.ioc.injection;

import java.util.List;
import java.util.Set;

public class CollectionBean {
	private Set<String> addressList;
	public void setAddressList(Set<String> addressList) {
		this.addressList = addressList;
	}
	
}

src/main/resources/applicationContext.xml

	 <bean id ="collectionBean" class="com.springbook.ioc.injection.CollectionBean">
		<property name="addressList">
			<set value-type="java.lang.String">
				<value>서울시 강남구</value>
				<value>서울시 강서구</value>
				<value>서울시 강서구</value>
			</set>
		</property>
	</bean>

--> applicationContext에도 <set value-type="java.lang.String" > 엘리먼트 사용

set이 중복 제거해주므로, 출력결과는 서울시 강남구, 서울시 강서구 2건만 나옴

main

package com.springbook.ioc.injection;

import java.util.List;
import java.util.Set;
import java.util.Map;
import java.util.Properties;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import com.springbook.ioc.injection.CollectionBean;

public class CollectionBeanClient {
	public static void main(String[] args) {
		
		AbstractApplicationContext factory = new GenericXmlApplicationContext("applicationContext.xml");
		CollectionBean bean = (CollectionBean) factory.getBean("collectionBean");
        // List, Set, Map, Properties에 맞게 변경
		Set<String> addressList = bean.getAddressList();
		
		for(String address : addressList) {
			System.out.println(address.toString());
		}
		factory.close();
	}
}

스프링 컨테이너 종류 

- BeanFactory와 이를 상속한 ApplicationContext두가지 유형 컨테이너 제공

 BeanFactory

 - 스프링 설정파일에 등록된 <bean>객체를 생성하고 관리하는 가장 기본적인 컨테이너 기능만 제공

 - 컨테이너 구동될때 <bean>객체를 생성하는것이 아니라, 클라이언트 요청(Lookup)에 의해서만 <bean>객체가 생성되는 지연 로딩(Lazy Loading)방식을 사용. 일반적인 스프링 프로젝트에 BeanFactory를 사용할 일은 전혀 없음

ApplicationContext

 - BeanFactory가 제공하는 <bean>객체 관리 기능 외에, 트랜잭션 관리나 메시지 기반의 다국어 처리 등, 다양한 기능을 제공. 컨테이너가 구동되는 시점에 <bean>에 등록된 클래스들을 객체 생성하는 즉시 로딩(pre-loading) 방식으로 동작

- 웹 애플리케이션 개발도 지원하므로 대부분 스프링 프로젝트는 ApplicationContext 유형의 컨테이너를 이용

구현클래스

GenericXmlApplicationContext : 파일시스템이나 클래스 경로에 있는 XML설정 파일을 로딩하여 구동하는 컨테이너

XmlWebApplicationContext : 웹 기반의 스프링 애프리케이션을 개발할 때 사용하는  컨테이너

src/main/java/polymorphsim/TvUser.java

package polymorphsim;

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

public class TvUser {
	public static void main(String[] args) {
		/*
		BeanFactory factory = new BeanFactory();
		TV tv = (TV)factory.getBean(args[0]);
		*/
		
		//1. Spring 컨테이너를 구동
		AbstractApplicationContext factory = new GenericXmlApplicationContext("applicationContext.xml");
		
		//2. Spring 컨테이너로 부터 필요한 객체를 요청(Lookup)
		TV tv = (TV)factory.getBean("tv");
		tv.powerOn();
		tv.volumeUp();
		tv.volumeDown();
		tv.powerOff();
		
		// 3. Spring컨테이너를 종료
		factory.close();
	}
}

실행결과

src/main/resources/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.xsd">

	<bean id ="tv" class="polymorphsim.SamsungTV"/>
</beans>

<bean>, <description>, <alias>, <import>등 네개 엘리먼트를 자식 엘리먼트로 사용가능
<bean>과 <import>정도가 실제 프로젝트에서 사용

<import> 엘리먼트

 - 스프링 설정파일 하나에 모든 클래스를 <bean>으로 등록/관리 할 수 있지만, bean이외에도 트랜잭션관리,예외처리, 다국어 처리등 다양한 설정 필요. 모든파일을 하나로 관리하지 않고 xml파일로 나눠서 사용하는게 효과적

<beans>
	<import resource="context-datasource.xml"/>
    <import resource="context-trransaction.xml"/>
</beans>

<bean> 엘리먼트

 - id와 class속성을 사용. id는 생략가능, class속성은 필수

 - id속성 : 자바 식별자 작성 규칙, CamelCase사용, id는 유일해야함

 - class속성 :  클래스 등록할 때는 정확한 경로와 클래스 이름 지정 필수

 - name속성 : id와 같은기능. 자바 식별자 규칙 따르지 않아도 됨. 특수문자 허용 

src/main/resources/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.xsd">

	<bean id ="tv" class="polymorphsim.SamsungTV" init-method="initMethod" destroy-method="destroyMethod" lazy-init="true" scope="singleton"/>
</beans>

프레임워크 장점

1. 빠른 구현시간

 - 아키텍처 골격코드는 프레임워크에서 제공, 개발자는 비즈니스 로직만 구현하면 됨

2. 쉬운 관리

 - 같은 프레임워크에 적용된 애플리케이션은 아키텍쳐가 같으므로 관리하기 쉬움

3. 개발자들 역량 획일화

4. 검증된 아키텍쳐 재사용과 일관성 유지

EJB(Enterpirse Java Beans)

POJO(Plain Old Java Object)

 - 평범한 옛날 자바 객체

  <-> Not POJO : Servlet클래스 // 우리마음대로 만들수 없음, 반드시 Servlet에서 요구하는 규칙에 맞게 클래스 만들어야 실행할 수 있음)

Servlet 클래스 작성 규칙

 - java.servlet, javax.servlet.http 패키지 import

- public 클래스로 선언

- Servlet, GenericServlet, HttpServlet중 하나를 상속

- 기본 생성자가 있어야 함

- 생명주기에 해당하는 메소드 재정의(Overriding)

스프링 프레임워크 특징

 - IoC와  AOP를 지원하는 경량의 컨테이너 프레임워크

1) 경량(Lightweight)

 - 크기측면에서 가벼움, 여러개의 모듈, 각모듈은 하나이상의 jar파일로 구성

 - 프레임워크가 POJO형태의 객체를 관리. 기존의 EJB객체 관리하는것 보다 훨씬 가볍고 빠름

2) 제어의 역행 (IoC : Inversion of Control)

 - 애플리케이션 구성하는 객체간 느슨한 결합, 낮은 결합도 유지

 - IoC가 적용되면 객체생성을 자바 코드로 직접생성하는것이 아니라, 컨테이너가 대신 처리

   객체와 객체 사이의 의존관계도 컨테이너가 처리
 - 소스에 의존관계가 명시되지 않으므로, 결합도가 떨어져서 유지보수 편리

3) 관점지향 프로그래밍(AOP : Aspect Oriented Programming)

 - 비즈니스 메소드 개발할때, 핵심 비즈니스 로직과 각 비즈니스 메소드마다 반복해서 등장하는 공통로직 분리함으로써 응집도가 높게 개발할 수 있도록 지원

 - 관점 지향 프로그래밍의 개념 : 공통으로 사용하는 기능들을 외부의 독립된 클래스로 분리하고, 해당 기능을 프로그램 코드에 직접 명시하지 않고 선언적으로 처리하여 적용하는것

- 응집도 높은 비즈니스 컴포넌트 만들수 있음 + 유지보수 혁신적 향상

4) 컨테이너(Container)

 - 특정 객체의 생성관리 담당, 객체 운용에 필요한 다양한 기능 제공

 - 대표 컨테이너 : Servlet컨테이너(톰캣 서버에 포함) , EJB컨테이너

- AP운용에 필요한 객체 생성, 객체간 의존관계 관리하는점에서 스프링도 일종의 컨테이너

JAVA (11.0.12)

1. oracle에서 jdk 다운로드 

2. 시스템 > 시스템속성 > 고급 > 환경변수에 JAVA_HOME추가

 새로만들기 >>  JAVA설치파일의 bin경로로 

ㅇ 변수이름 : JAVA_HOME

ㅇ 변수값 : C:\Program Files\Java\jdk1.8.0_301\bin
              C:\Program Files\Java\jdk-11.0.12\bin
3. 기존 환경변수 Path 에 JAVA_HOME 추가

C:\Program Files\Common Files\Oracle\Java\javapath;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\Program Files (x86)\Intel\iCLS Client\;C:\Program Files\Intel\iCLS Client\;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\;C:\Program Files\Intel\Intel(R) Management Engine Components\DAL;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\DAL;C:\Program Files\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files\Samsung\SamsungLink\AllShare Framework DMS\bin\;%JAVA_HOME%

4. 윈도우 cmd창열고, java -version 설치확인

(8버전 삭제후 11로 재설치)

Eclipse (넘어가도됨... mars버전)

1. eclipse.org 사이트에서 다운로드

 - 다운로드 받은버전 : mars

2. 개발 폴더에 압축해제  

  - 경로 : C:\DEV\eclipse

3. 이클립스 실행 :: eclipse.exe

 >> 아래와 같이 오류발생

4. eclipse.ini 파일내에 jdk가 가진 javaw.exe 파일 위치 명시

-vm
C:\Program Files\Java\jdk1.8.0_301\bin\javaw.exe

5. 파일 저장후 닫기, 이클립스 실행 :: 성공

 (Tomcat) eclipse 서버 설정

 (Eclipse에서 설정안하고, 맨아래 sts에서 참고해서 설정하면됨)

1. tomcat.apache.org 에서 톰캣 다운로드
 - https://archive.apache.org/dist/tomcat/tomcat-8/v8.0.32/bin/

 - 다운로드 버전 : 8.0.32

2. 개발 경로에 압축해제

 - 나의 경로 : C:\DEV\apache-tomcat-8.0.32

3. 이클립스 실행후 Server 추가

 - Servers > ~Click this link~ > Apache Tomcat v8.0 > Next
 - Browse해서 설치된 tomcat링크 선택후 Finish

4. Server 구동

 - Server 옆 초록버튼(실행)  > Console창 확인

DB (MySQL) 8.0.26 

1. mysql사이트에서 다운로드

 - 다운로드 버전 : 8.0.26

 - https://dev.mysql.com/downloads/mysql/

2. 설치 과정 (생략)

 - 포트는 기본으로 설정함

 - root 계정 pass설정

 ** 주의 : 설치할때 컴퓨터이름이 한글로 되어있으면 오류남..

3. 환경변수설정

 > C:\Program Files\MySQL\MySQL Server 8.0\bin
 - cmd에서 mysql --version으로 확인

4. service.msc 실행

  - window + R키

 - MySQL80이 실행되어있는지 확인
    >>설치하다가 재설치해서 81로됨

4. mysql workbench 실행

5. db 확인

6. Schema생성 후 table생성, insert

- schema명 : board 

STS(Spring Tool Stuie) 설치 4.13.0

1. STS설치
ㅇ Help > Eclipse Marketplace

 --> Marketplace에서 3.7.3 버전이 보이지 않아서 

      수동설치 하려고했는데.. url이 유효하지 않음 http://dist.springsource.com/snapshot/TOOLS/nightly/e3.7

      sts 설치 https://spring.io/tools 

 -- 설치한 버전 : 4.13.0

(이클립스 설치 괜히함......)

2. 서버설정 (eclipse와 동일)
 - Servers > Tomcat 설정후 실행 

 - Console에서 Server startup 확인

3. Legacy 프로젝트 생성을 위한 추가 download

  3-1 오른쪽마우스 클릭 > New > Project... >  Spring Legacy 프로젝트가 없음

  3-2 Help > Eclipse Marketplace > sts 검색

       두번째 Spring Tools 3 Add-On Spring Tools 4 ~~를 install
       Confirm후 sts 자동 재시작

  3-3 Spring Legacy Project 생성가능

STS 프로젝트 생성 및 설정

1. Legacy 프로젝트 생성
  File > New > Spring Legacy Project

  - Project Name : BoardWeb

  - Templates : Spring MVC Project

** 생성시 오류발생 : 조치  https://gardentree.tistory.com/148

2. 패키지명 설정 후 저장

   정상생성!

3. 프로젝트 설정 변경

  - 생성한 프로젝트 선택 후 우클릭 > Properties > Project Facets

  - Java는 Version 설치한 버전에 맞게 변경 (11)
  - Runtimes에 Apache Tomcat 선택
  - Apply > Apply And Close

  - Java Build Path > Libraries에 정상변경 확인