부트캠프 진행 중 SpringBoot email을 알아보던중에 시간이 조금 지나 프로젝트를 진행할 때 회원에게 메일을 발송하는 기능을 구현해보고 싶다는 생각이들었다. 회원가입 시 이메일 인증을 하고, 비밀번호를 분실했을 때 인증을 코드를 발송하는 기능등 다양하게 사용되기 때문에 아직은 미래지만 실제로 회사에서 일하게 된다면 유저에게 직접적으로 도움을 줄 수 있는 기능이기 때문에 관심이 갔다.

이번에 알아 볼것은 Gmail의 SMTP 서버를 활용하여 이메일을 발송하는 방법이다.

SpringBoot Email이란?

Spring Boot는 스프링 프레임워크를 기반으로한 개발을 더욱 쉽게하고 빠르게 만들어주는 도구이며, 이를 사용하여 이메일(Email)을 보내는 기능을 구현할 수 있다. 스프링 부트를 이용하여 이메일을 보내려면 다음과 같은 단계를 따를 수 있습니다.

1. 의존성 설정: 스프링 부트는 자체적으로 이메일을 보내는 데 필요한 의존성을 제공합니다. 이를 위해 spring-boot-starter-mail 의존성을 프로젝트에 추가한다. 이렇게 하면 이메일을 보내기 위한 필수적인 라이브러리와 설정들이 자동으로 추가된다.
2. 이메일 설정: application.properties 또는 application.yml 파일을 사용하여 이메일 관련 설정을 정의합니다. 이 설정에는 이메일 호스트, 포트, 보내는 사람의 정보 등이 포함될 수 있다.

개발 환경

• Spring Boot

• Java 17

• IntelliJ

구글 계정 설정

Gmail의 SMTP 서버를 활용하기 위한 절차가 필요하다.

1. 구글 계정 관리에 들어가서 보안 탭을 클릭한다.

2. 2단계 인증을 설정하지 않았다면 사용하는 것으로 설정을 변경한다.

3. 아래 이미지를 참고하여 앱 비밀번호를 설정한다.

4. 앱 선택 목록에서 메일을 선택

5. 기기 선택 목록에서 기타를 선택한 후 기기 이름을 입력(원하는대로 작성 하시면됩니다).

6. 생성 버튼을 눌러 앱 비밀번호를 생성한다.

7. 16자리의 앱 비밀번호를 확인합니다. 앱 비밀번호는 노출되지 않도록 주의하고, 개인 공간에 복사해둔다.

8. 확인버튼을 눌러 완료!

구글 메일 설정

1. Gmail 설정에 들어가서 전달 및 POP/IMAP 탭으로 들어가기!

2. 모든 메일에 POP를 활성화 하기를 선택!

3. IMAP 사용을 선택!

4. 변경사항을 저장!

의존성 & yml 파일 설정

build.gradle 수정

dependencies {
...
implementation 'org.springframework.boot:spring-boot-starter-mail'

// 아래 2개는 thymeleaf를 사용하는 경우에만 추가
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect'
...
}

• [Spring Boot Starter Mail] (https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-mail): 메일 서버와 연결해서 메일을 발송하는데 필요한 라이브러리

application.yml 수정

spring:
  mail:
    host: smtp.gmail.com # 1
    port: 587 # 2
    username: ${mail.username} # 3
    password: ${mail.password} # 4
    properties:
      mail:
        smtp:
          auth: true # 5
          timeout: 5000 # 6
          starttls:
            enable: true # 7

1. SMTP 서버 호스트

2. SMTP 서버 포트

3. SMTP 서버 로그인 아이디: 발신자 (이메일이 test@gmail.com 이면 test가 해당)

4. SMTP 서버 로그인 패스워드: 앱 비밀번호

5. 사용자 인증 시도 여부 (기본값 : false)

6. Socket Read Timeout 시간(ms) (기본값 : 무한대)

7. StartTLS 활성화 여부 (기본값 : false)

스프링 스케쥴러는 일정 주기마다 특정 작업을 수행하기 위해서 사용된다. 개발자가 하나하나 신경쓰지 않더라도 Scheduler의 기능을 이용하면 원하는 기능을 수행할 수 있게된다.

실행주기를 설정하는 방법

• fixedDelay : 이전 수행이 종료된 지점을 기준으로 일정시간이 경과했을 때 다음을 수행
• fixedRate : 이전 수행이 시작된 지점을 기준으로 일정시간이 경과했을 때 다음을 수행

위의 두가지 방법은 이전에 수행했던 수행시점을 기준으로 일정시간 후에 다음 수행을 시작한다. fixedRate의 경우 작업에 소요되는 수행 시간이 fixedRate에서 지정된 시간보다 길어지면 두수행이 겹쳐서 발생할 가능성이 있기 때문에 fixedRate을 사용하여 스케쥴링을 할 때에는 주의가 필요하다.

Cron 표현식

• 스케쥴링 시간은 정규 표현식을 사용하여 표현하는 규칙
• 초 / 분 / 시 / 일 / 월 /요일 / 년도(생략가능)
• 0 5 * * * * : 매시 5분마다 작업을 수행
• 0 0/10 * * * * 10분에 한번씩 작업을 수행

한 번 알면 어렵지 않은 Cron 표현식을 잘 숙지하시길 바랍니다! 스케줄러 구성할 때 매우 편하게 느껴진다고 하네요 ㅎㅎ 마지막으로 이러한 어려움으로부터 쉽게 해방할 수 있는 사이트를 소개합니다.

Cron Maker: Cron 메이커~~ cron 표현식을 생성해줍니다. 개인 공부용으로 사용하시면 좋을 것 같습니다.

1. 스프링부트(SpringBoot)란?

Spring Framework는 수많은 기능이 있는 만큼 환경설정 또한 매우 복잡합니다. 스프링을 처음 접할 때는 XML을 작성하고, DI등 귀찮고 어려움을 느끼경험이 생길것 입니다.

이에 어려움을 해결하기 위해 나온 것이 스프링 부트 입니다.

스프링 부트는 스프링 프레임워크를 사용하기 위한 수많은 설정 부분을 자동화하여(스프링 부트가 대신해줌) 개발자가 환결설정보다 개발에 좀 더 집중할 수 있게 도와줍니다. 또한 내장 서버를 가지고 있어 귀찮게 따로 톰캣(TomCat)등을 설치할 필요가 없습니다.

[_스프링 부트의 주요 핵심_]

• Spring Boot starter를 통한 dependency 자동화

Spring Boot starter란

특정 목적을 달성하기 위한 의존성(dependency)그룹이라고 쉽게 말할 수 있습니다. starter는 npm혹은 yaml처럼 간편하게 dependency를 제공해주는데, 만약 JPA혹은 Mybatis가 필요하다면 pom.xml(Maven 사용할 때), build.gradle(Gradle 사용할 때)에 "spring-boot-start-data-jpa"만 추가해주면 스프링 부트가 그에 필요한 라이브러리(lib)를 가져오고 버전을 자동으로 관리해줍니다.

💡Tip 추가로 스프링 부트(SpringBoot)는 JSP 사용을 지양하고, HTML방식을 지향합니다. 그래서 만약 스프링 부트에 JSP를 사용하려면 프로젝트 구조가 조금 달라지고, lib를 추가해야 합니다.

2. 그렇다면 스프링 부트와 스프링의 차이점은?

스프링의 철학을 스프링 부트가 대부분 가져가고, 쉽게 말하면 스프링에서 귀찮은 한경 세팅이 사라진 것이 스프링 부트라고 말할 수 있습니다. 결론은 스프링과 스프링 부트는 몇 가지를 제외하면 크게 다른점이 없습니다.

💡SpringBoot와 Spring Framework의 차이점

• SpringBoot는 Embed Server(내장 서버)를 사용해서 스프링 부트 내부에 Tomcat이 포함되어 있습니다. 따라고 Spring과 다르게 따로 Tomcat을 설치하거나 버전 관리를 할 필요가 없습니다.
• Spring Boot starter를 통해 dependency 자동화
• XML 설정을 하지 않아도 됩니다.(^^)
• jar 파일을 이용해 쉽게 배포가 가능합니다. -> Spring은 war파일을 사용해서 배포할 때 따로 톰켓도 세팅하고 귀찮은 점이 많았습니다. SpringBoot는 손쉽게 jar파일만 배포하면 끝!

1-1 DI와 IoC의 개념 소개:

• DI는 Dependency Injection의 약자로, 객체간의 의존성을 외부에서 주입하는 개념이다.

• IoC는 Iversion of Control의 약자로, 개발자가 객체의 생성과 관리를 제어하는 것이 아니라 프레임워크나 컨테이너에 위임하는 개념이다.

• IoC 피자가 있지만, 피자에는 제어권이 없어서 스스로 재료를 결정하지 못한다는 개념

• DI 피자가 스스로 재료를 결정하지 못하니, 피자에 맞는 피자의 재료를 외부에서 주입해주는 방법, (재료를 넣어준다는 행위의 초점) (ex.모짜렐라 치즈(혹은 그냥 치즈)를 넣어준다)

1-2 왜 DI와 IoC가 필요한지:

• DI와 IoC는 코드의 유연성, 재사용성, 테스트 용이성을 높이고, 객체간의 결합도를 낮추기 위해 사용된다.

1-3 DI와 IoC의 장점과 이점:

• 유연한 코드 구조, 테스트 용이성, 결합도 감소, 확장성과 유지 보수성을 높여준다.

2. IoC의 개념과 원리

서브웨이에 간것을 예시로 들어보기 🌯

• 우선, 제어의 역전이 없다면(❌), 우리는 직접 원하는 대로 재료를 선택한다면 알바생들은 이미 레시피(코드)에 지정되어 있는 재료의 샌드위치가 아니여서 당황을 겪게된다. 각 재료들에 대한 제어권 이 객체 내부에 있기 때문이다. 만약 요구를 반영하고자한다면 객체 내에 큰 변경이 생기게 된다.
• But, 제어를 역전시킨다면(⭕️), 각 재료들에 대한 제어권을 우리가 갖게 되어 우리가 직접 조합을 요청하여 자신만의 조합의 샌드위치를 주문할 수 있다. 객체 내부에서 재료의 종류를 제어해 변경이 자유롭지 못하던 코드가 외벵서 제어를 받으면서 변경이 자유롭게 가능해진다. 이를 통해 위에서 제어의 역전이 없을 때 생기는 큰 변경에 대한 문제를 해결할 수 있게 되었다.

2-1 IoC의 정의와 개념 설명:

• IoC를 그대로 해석하면 제어의 역전이다. 무엇인가 제어하는 주체가 바뀐다는 의미인데 어떤 제어가 어떻게 바뀌는 것일까? Spring을 사용해 본 사람이면 알듯이 Service, DAO같은 객체를 사용자가 직접 생성(new) 하지 않는다. @Autowired를 통해 받아 사용하는데 이 @Autowired가 IoC(제어의 역전)이다.

• 제어의 역전이라는 용어는 개발자가 직접 객체를 생성하고 관리하는 것에서 벗어나, 객체의 생성과 관리를 프레임워크 또는 컨테이너가 담당하는것을 의미

  //기존 자바 프로젝트
  

public class order { private Customer customer;

public order() {
    this.customer = new Customer();
}

}

// Spring 프로젝트 public class order {

@Autowired
private Customer customer;

}

#### 2-2 <span style="color: #8A2BE2">IoC 동작 원리: </span>
- 스프링 컨테이너(IoC container)는 프로젝트에서 사용되는 객체들을 Bean으로 관리하고 있고 @Autowired를 통해 객체를 주입해준다.

- 기존엔 사용자가 생성(new)해 파라미터로 다른 객체로 보내거나, 사용할 일이 없을 경우 객체를 소멸하는 등 객체에 대한 제어를 직접 진행했다.

- 하지만 Spring에서는 위처럼 제어를 사용자가 아닌 Spring Framework가 진행하기 때문에 제어의 역전이라고 표현한다.

#### 2-3 <span style="color: #8A2BE2">제어의 역전이 개발자의 코드 구조에 미치는 영향: </span>
- IoC는 개발자가 직접 객체 생성과 관리에 대한 책임을 가지지 않고, 프레임워크나 컨테이너에 위임하므로 코드의 결합도가 낮아지고 유연성이 증가한다.

- 개발자는 의존성 주입을 통해 객체를 활용하며, 객체 간의 관계를 설정 하는 것에 집중한다.

#### 2-4 <span style="color: #8A2BE2">IoC는 왜 필요할까? </span>
- IoC 프로그램 모델은 곧 **역할과 책임의 분리** 라는 내용과 관련이 있다.

- 역할과 책임을 분리해 응집도를 높이고 결합도를 낮추며, 이에 따라 _**변경에 유연한 코드**_ 를 작성할 수 있는 구조가 될 수 있다.

- 결국 IoC를 사용하면 결과적으로 **객체지향 원칙을 잘 지키는 코드**를 만들 수 있다.

#### 2-5 <span style="color: #8A2BE2">IoC 작동순서</span>

- 1. 객체 생성및 구성: IoC컨테이너나 프레임워크를 사용하여 객체를 생성하고 구성
일반적으로 컨테이너는 XML 또는 Annotation과 같은 설정 메타데이터를 사용하여 객체를 생성하고 구성

- 2. 객체의 생명주기 관리: IoC컨테이너는 객체의 생명주기를 관리
객체의 생성, 초기화, 소멸과 같은 단계를 컨테이너가 관리하며, 필요에 따라 객체를 재사용하거나 새로 생성할 수 있다.

- 3. 의존성 주입: IoC컨테이너는 객체에 필요한 의존성을 자동으로 주입한다.
객체는 직접 의존성을 찾거나 생성하지 않고, 컨테이너로부터 필요한 의존성을 주입받는다.
이를 통해 객체 간의 결합도를 낮출 수 있다.

- 4. 제어의 역전: IoC컨테이너는 객체의 제어흐름을 개발자가 아닌 자체적으로 관리
컨테이너는 필요한 객체를 생성하고 호출하며, 개발자는 컨테이너에 필요한 설정을 제공함으로써 컨테이너에게 제어 흐름을 위임한다.

- - -

## 3. DI의 개념과 원리
- - -


#### 3-1 <span style="color: #8A2BE2">DI의 정의와 의존성의 개념 설명:</span>
- 제 3자가 제어를 관리하는 순간 제어의 역전이고, 스프링이 생기기 전부터 있던 개념이었기에 IoC는 다른 프레임워크와 다른 스프링만의 차별점을 설명하기 부족했다.
그래서 스프링만의 차별점을 설명하기 위해 만들어진 개념이 DI이다.

- DI는 Spring에서 IoC 구조를 만드는 방식이다.
DI를 그대로 해석하면 의존성 주입이다.

- 의존성은 무엇이고 왜 주입할까?
프로그래밍에서 뜻하는 의존성은 객체간의 관계를 먼저 알아야 이해하기 쉽다.
의존성
클래스 간 의존 관계(의존성)가 있다면, 한 클래스가 바뀌면 다른 클래스도 영향을 받는다.
결국 의존은 영향을 받는 관계라는 것을 의미한다.

- DI를 사용하는 이유는 개체간의 의존성을 줄이기 위함이다.
밖에서 객체를 생성해 넣어주기 떄문에 재사용성이 늘어나고 수정에 용이해진다.

```java
//기존 자바 프로젝트
class concept_api implements Post(){}
class concept_Spring implements Post(){}

class Blog_log() {
private Post post; // 블로그 글 클래스

    public Blog_log() {
        this.post = new concept_api();
            this.post = new concept_Spring();
    }
}

// DI
private Post post; // 블로그 글 클래스

    public Blog_log(Post post) {
        this.post  = new post();
    }

• 첫번째 방법은 A객체가 B와 C객체를 New 생성자를 통해서 직접 생성하는 방법이고,

• 두번째 방법은 외부에서 생성 된 객체를 setter()를 통해 사용하는 방법이다.

• 이러한 두번째 방식이 의존성 주입의 예시인데, A 객체에서 B, C객체를 사용(의존)할 때 A 객체에서 직접 생성 하는 것이 아니라 외부(IOC컨테이너)에서 생성된 B, C객체를 조립(주입)시켜 setter 혹은 생성자를 통해 사용하는 방식이다.

  • 만약 기존 프로젝트 처럼 interface를 직접 만든다면 글마다 CRUD 함수가 필요하지만, DI처럼 의존성을 주입해 사용한다면 Blog_log 하나의 클래스 만으로 모든 글을 관리할 수 있다.

3-2 의존성 주입의 원리와 종류:

• 클래스 간 의존 관계(의존성)가 있다면, 한 클래스가 바뀌면 다른 클래스도 영향을 받는다.

• 결국 의존은 영향을 받는 관계라는 것을 의미한다.

• 주로 생성자 주입(Constructor Injection), Setter 주입(Setter Injection), 필드 주입(Field Injection) 등의 방식을 사용

3-3 의존관계 주입이란?

• 의존성 주입 DI(Dependency Inversion) 는 제어의 역전이 일어나는것을 전제 로 스프링 내부의 객체들 간의 관계를 관리할 때 사용한다.

• 애플리케이션 실행 시점(런타임)에 (이전에는 인터페이스) 객체 외부에서 실제 구현 객체를 생성해서 그 참조값을 전달하므로써, 클라이언트와 서버의 실제 의존관계가 연결 되는 것이다.

• 의존관계 주입의 장점은 애플리케이션 코드를 변경하지 않고도 이제 의존관계를 변경할 수 있다는 점이다.

• DI 적용 전

  public class Pizza {
    Bread bread;
    Cheese cheese;
    Sauce sauce;
    public Pizza(){
        this.white = new WhiteBread();
        this.mozzarella = new MozzarellaCheese();
        this.chili = new ChiliSauce();
    }
  }

• DI 적용 후

  public class Pizza {
    Bread bread;
    Cheese cheese;
    Sauce sauce;
    public Sandwitch(Bread bread, Cheese cheese, Sauce sauce){
        this.bread = bread;
        this.cheese = cheese;
        this.sauce = sauce;
    }
  }

3-4 의존성은 어떻게 주입하면 될까?

3가지 방법이 존재한다. 1.생성자 주입 , 2.Setter 주입 , 3.Interface 주입

3-5 DI작동 순서

1. 의존성 정의: 먼저, 각각의 클래스나 컴포넌트에서 필요로하는 의존성을 정의

2. 의존성 제공: DI 컨테이너나 프레임워크를 사용하여 의존성을 제공 DI컨테이너는 의존성을 인스턴스화하고 관리하는 책임을 갖는다.

3. 의존성 주입: 의존성을 주입받는 객체에서 의존성을 전달 일반적으로 주입은 생성자를 통해 이루어진다. DI 컨테이너는 의존성을 자동으로 주입하거나 필요한 경우에 수동으로 주입

4. 객체사용: 의존성이 주입된 객체를 사용하여 원하는 작업을 수행 의존성을 사용하는 객체는 직접 의존성을 인스턴스화하거나 관리하지 않고, DI 컨테이너로부터 주입 받은 의존성을 사용

• ** Spring에서의 DI? ** @Controller, @Service 를 들 수 있다. Controller, Service 는 의존관계를 지니고 있다. Controller 에서 Service 를 호출할때, Service 를 받는 생성자가 어딘가에서 호출되어야하지만 instance를 주입하는 코드를 쓰지 않아도 가능하다.

4. Spring에서 DI를 구현하는 방법

4-1 생성자 주입(Constructor Injection):

• 클래스의 생성자를 통해 의존성을 주입하는 방식

• 주입받을 의존성을 인자로 받는 생성자를 정의하고, 해당 인스턴스 변수에 주입

• Ex)

  public class UserController{
    private UserService userService;
  
    public UserController(UserService userService){
        this.userService = userService;
    }
  }

  4-2 속성 주입(Property Injection):

• 의존성을 클래스의 속성으로 주입하는 방식

• Setter 메서드를 통해 의존성을 설정

• Ex)

  public class UserController {
    private UserService userService;
  
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
  }

4-3 필드 주입(Field Injection):

• 의존성을 필드를 통 주입하는 방식

• 메서드 호출 시 의존성이 주입되는 방식

• Ex)

  public class UserService {
    @Inject
    private UserRepository userRepository;
  
    // UserService의 기능들...
  }
  

public class UserRepository { // UserRepository의 기능들... }

- 위의 예시에서 UserService 클래스는 UserRepository에 의존성을 가지고 있습니다. UserService 클래스의 userRepository 필드에 @Inject 어노테이션을 사용하여 의존성 주입을 표시한다.

#### <span style="color: #8A2BE2">4-4 Spring의 DI 설정:</span>
- XML 설정 파일을 사용하는 방법:

```xml
<bean id = "userService" class= "com.example.UserService">
    <property name = "userRepository" ref= "userRepository" />
</bean>

<bean id = "userRepository" class = "com.example.UserRepository"/>

• Java Config를 사용하는 방법:

  @configuration
  public class AppConfig {
    @Bean
    public UserService userService(UserRepository userRepositoty){
        UserService userService = new UserService();
        userService.setUserRepository(userRepository);
        return userService;
    }
  
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
  }

4-5 @Autowired 어노테이션:

• @Autowired 어노테이션을 사용하여 의존성 주입을 자동화

• Spring은 해당 타입의 빈을 찾아 자동으로 주입

-Ex)

public class UserController{
    @Autowired
    private UserService userService
}

5. Spring에서의 IoC(제어의 역전)

5-1. Spring에서의 IoC 컨테이너

• Spring은 ApplicationContext라는 IoC컨테이너를 제공

• ApplicationContext는 Bean을 생성하고, 의존성을 관리하며, 객체의 생명주기를 관리

5-2. Spring IoC 설정

• XML설정 파일을 사용하는 방법:

  <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="userService" class="com.example.UserService" />
  

• Java Config를 사용하는 방법:

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

• Spring의 DI와 IoC를 통해 객체간의 결합도를 낮출 수 있으며, 유연하고 확장 가능한 애플리케이션을 개발할 수 있다.

• Spring은 많은 개발자들에게 선호되는 프레임워크로, DI와 IoC를 지원하여 개발생산성을 향상시키고 유지보수를 용이하게 한다.

ApplicationContext

ApplicationContext를 스프링 컨테이너라고 한다. ApplicationContext는 BeanFactory인터페이스의 하위 인터페이스이다. 즉,ApplicationContext는 BeanFactory에 부가기능을 추가한것 이다.

는 BeanFactory는 스프링 컨테이너의 최상위 인터페이스이다. 스프링 Bean을 관리하고 조회하는 역할을 한다. ApplicationContext는 BeanFactory + 부가기능(국제화 기능, 환경 변수 관련 처리, 애플리케이션 이벤트, 리소스 조회)을 가진다.

정확히는 스프링 컨테이너를 부를 때, BeanFactory, ApplicationContext를 구분해서 말하지만, BeanFactory를 직접적으로 사용하는 경우는 거의 없다. 왜냐하면 ApplicationContext가 BeanFactory의 모든 기능을 가지고 있기 때문이다.

ApplicationContext의 구현체가 여러가지 있는데, 구현체에 따라 스프링 컨테이너를 XML을 기반으로 만들 수도 있고, 자바클래스로 만들 수도 있다. 이게 가능한 이유는 빈 등록을 BeanDefination으로 추상화해서 생성 하기 때문이다. XML로 하든, 자바로 하든 BeanDefinition이 생성된다.

스프링 컨테이너 내부에는 빈 저장소가 존재한다. 빈 저장소는 key로 빈 이름을 가지고 있으며, value로 실제 빈 객체를 가지고 있다.

스프링 컨테이너는 기본적으로 빈을 싱글톤으로 관리해준다. 따라서 싱글톤 컨테이너라고 불리기도한다. 스프링 컨테이너가 빈을 싱글톤으로 관리해주면서 기존 싱글턴 패턴의 문제점(싱글톤 패턴 구현을 위한 코드가 추가되어야함, 구체 클래스에 의존, 유연성이 떨어짐 etc)은 없어지고, 싱글톤의 장점(매번 인스턴스를 생성할 필요없이 단 하나만 생성해서 비용을 줄일 수 있다.)만 가져갈 수 있다.

자바 설정 클래스로 스프링 컨테이너 생성하기

아래는 어노테이션 기반의 자바 클래스로 스프링 컨테이너를 만든 예시이다.

@configuration
public class Appconfig {
    @Bean
    public StationService stationService(){
        return new StationServiceImpl(stationRepository());
    }

    @Bean
    public StationRepository stationRepository() {
        return new MemoryStationRepository();
    }

    @Bean
    //...
}

new AnnotationConfigApplicationContext()를 통해 자바 기반 스프링 컨테이너를 만들어 준다. 그럼 비어있는 빈 저장소가 생긴다. 이때 만들어 둔 자바 설정 클래스를 파라미터로 넘겨줘서 생성한다. 그럼 자바 설정 클래스 내부의 @Bean 어노테이션이 붙은 메서드들을 실행하면서 빈 저장소에 실제 빈을 등록한다.

ApplicationContext ac = 
new AnnotationConfigApplicationContext(AppConfig.class);

사용할 땐, 빈 등록 메서드 이름을 통해 객체를 가져올 수 있다.

```java StationService stationService = applicationContext.getBean("stationService",StationService.class);

좋았던점

이번 프로젝트는 조장을 중심으로 각자 부를 나눠 분업화가 잘되서 누구 한명이 막히면 안굴러가는게 아니라 다 각자 했기에 일이 잘 진행됐던것같다. 그리고 무엇보다 프로젝트를 마쳤을 때 고생했지만 뿌듯함과 행복감이 들어 좋았습니다.

아쉬웠던점

처음에 구상을 하고 진행하는데 너무 머리로 할려고 했던것같다. 나중에 가니 머리가 복잡해지고 이건 왜 쓴거지? 이건 필요없는데 왜 한거야.. 등등 내 생각 처럼 진행이 안됐던 것 같다. 이번 프젝을 계기로 조금더 치밀하고 확실하게 정리 후 작업을 진행하고 싶다.

다음주 계획

이번에 프젝을 하면서 확실히 조금는 것 같다. 직접하나의 프로젝트를 경험하니 이해 안되던 부분도 이해가 갔다. 이 기세를 이어가서 혼자서 작은 프로그램도 짜보고, 알고리즘 문제도 하루에 하나정도는 풀어볼 생각이다!

4주차는 JavaWeb에 대해 배우고 IntelliJ와는 다른 IDEA인 VScode를 통해 Html과 Css에 대해 맛을 보고 java로 넘어와 , Tomcat - MYSQL - JAVA를 연동 시키는 작업을 했다.

여긴 어디? 나는 어디?

지금 까지 배운 것들을 활용하여 연동 시키다 보니 어지러운 마음이 먼저 들었지만 그래도 나름 조금씩 개념이 잡혀가고 있다. 익숙함 주변의 개발자 분들이 몇분이 있는데 만나면 하는 말이 항상 익숙해져야 한다. 너자신이 스스로 쳐봐야 한다. 남이 쓴거 따라써봐야 아무 소용 없다. 이런말들을 자주 들었었는데 이제 어언 한달동안 강사님의 코드를 따라치고 공부하고 하였지만 막상 야 너 저거 쳐봐! 하면 눈앞이 깜깜했다.. 그래서 이번주는 프로그래머스 문제도 풀어보고 내가 직접 써보는 시간을 조금이지만 가졌던 것 같다.

그러다 보니 익숙함이란 말이 정말 크게 다가왔다. 하지만 절망보단 희망이 보였다. 나도 꾸준히 계속 코드를 치고 깨달음을 얻고 하다보면 나도 발전하겠구나 라는 생각이 많이 드는 한주였다.

아쉬운점

절대적인 공부량이 적다. 나는 정말 6개월 부트캠프에 들어온 사람이고 노베이스였다 .. html, css, js, ts, react를 공부했었지만 내머리에 남은 지식이 없었다.. 내가 정말 살아남을려면 절대적인 공부량을 늘려야하고 최소한 내 기준은 지켜야한다. 피곤하다고 안하고 남들이 집간다고 안하고 하면 난 살아남을 수 없을 것 같다 아니 그건 100프로 다. 간절함을 가질 시간!

좋았던점

부트캠프에 오기전 힘든시간을 보냈다. 사람은 움직여야 변하고 무라도 벨수 있다. 지금 나는 그런 과정을 겪고있어 긍정적이다. 조금은 밝게 변하고 사람들과 대화하고 웃고 문제에대해 토론하고 이런 과정이 솔직히 나에게는 너무 좋은것 같다.

다음주 계획

복습이 가장 중요하다. 하루에 배우는 양이 많다보니 모든 부분을 복습하진 못하더라도 어느정도는 가져가야 한다. 복습에 집중할 생각이다.

어느새 한달이....! 행복하다 단순히 시간뿐만 아니라 내 눈에 살짝이지만 보이고있다. 규칙적인 생활을 하면서 건강도 좋아지고 많지는 않지만 내손으로 코드를 치고 조금씩 익숙해지고 있다는 사실이 나를 행복하게 한다~

그래서 한달동안 뭐했는데!!

일단 가장중요한 것은 규칙적인 생활을 통해 내 패턴들이 바뀌고 있다. 누군가와 비교하고싶지는 않다 한동안 심리적으로 힘든시간을 보냈는데 그런 시간을 이기고 지금 조금은 바뀐 나의 모습이 좋다.

한달동안 JAVA를 배우고 눈 깜짝할새에 MYSQL -> JAVA Web -> HTML -> css 이제 이것들을 이용해 팀을 짜서 미니 프로젝트를 하는 중이다.

앞으로 뭐할건데 !!

이제 정말 중요한 Spring을 배운다. 한국은 자바공화국이라 불릴정도로 정말 많은 회사들이 이용하고 있는데 대부분의 회사는 Spring을 써서 확실히 개념을 익히고 잘쓸 수 있도록 노력 할 것이다 ! 잘해보자 Spring

근데 왜이렇게 아쉽지...

인간이 잘못인가 내가 잘못인가... 살짝만 쉬자고 했잖아... 요즘들어 피곤함을 많이 느꼈는데 너무쉰것같다... 바짝해도 모자란데 겨우 한달 해놓고 안일 해지는 것 같아서 조금 싫어질라하네요

주말 잘쉬었으니 다시 달려봅시다!

마무리

동기부여가 약해지는 순간은 언제나 온다고 한다. 그래서 계속 계속 계속 계속 자극을 받아야 사람은 움직인다. 나의 자극을 잘찾아 자극 받는 삶 살자 !

1. Spring FramWork 란?

JAVA 기반의 기업용 애플리케이션 개발을 위한 오픈 소스 애플리케이션 프레임워크이다. 동적인 웹 사이트를 개발하기 위한 여러 가지 서비스를 제공하고 있다. 대한민국 공공기관의 웹 서비스 기발 시 사용을 권장하고 있는 전자정부 표준프레임워크의 기반 기술로서 쓰이고 있다.

Spring Framework

• 핵심기술: 스프링 DI 컨테이너, AOP, 이벤트...

• 웹 기술: 스프링 MVC..
• 데이터 접근 기술: 트랜잭션, JDBC, ORM 지원..
• 기술 통합: 캐시, 스케줄링..
• 테스트: 스프링 기반 테스트 지원

스프링을 사용하는 핵심적인 이유는?

스프링 자바(java)언어 기반의 프레임워크이다. 자바 언어의 가장 큰 특징은 객체 지향 언어 인데, 스프링은 이러한 객체지향 언어가 가진 특징을 살려서 좋은 객체 지향 애플리케이션을 개발할 수 있게 도와주는 프레임워크이다. (물론, 위에 언급한듯이 웹 애플리케이션을 만들고, 전자 정부 프레임워크이기 때문에 등의 이유도 있다)

💡'좋은 객체 지향 애플리케이션을 개발하는데 어떻게 도움을 주는가?'에 대해서 알아보자면, 객체 지향의 핵심은 다형성 이다. 하지만 다형성 만으로는 클라이언트 코드 변경을 하게 되어, OCP, DIP를 지키기가 어렵다. 그래서 이때, 스프링은 다형성 을 극대화해서 편리하게 이용할 수 있게 지원해주는 기능이다. 그중에서 제어의 역전(IoC), 의존관계 주입(DI)는 다형성을 활용해서 역할과 구현을 편리하게 다룰 수 있도록 지원한다. 이를 통해서 우리는 역할에 따른 구현을 레고 블럭 조립하듯이 맘대로 편리하게 변경 할 수 있다. (이때 역할이 가장 중요하므로 잘 설계되어있어야 문제가 안생긴다!)

📕라이브러리

라이브러리는 개발에 필요한 기능이 있을 때 직접 가져와 사용할 수 있도록 자주 사용되는 기능들을 모아 미리 구현해 둔 것 이다.

예를 들어 JAVA에서는 문자열을 사용할 때 String name = "최웅진"; 이렇게 사용한다. String은 java.lang.String에 미리 만들어져있는 기능이고 우리는 java.lang.String 이라는 라이브러리에서 기능을 가져와 사용하는것이다.

📕프레임워크

프레임워크도 개발에 필요한 기능이 미리 구현되어 있는 것이다. 하지만 프레임워크에는 라이브러리와 달리 기본 틀이 정해져있다. 때문에 제약없이 사용할 수 있는 라이브러리와 달리 프레임워크는 정해진 틀 안에서 미리 구현 된 기능을 사용해야한다.

스프링 프레임워크에서는 MVC라는 정해진 구조 안에서 개발자가 프로그램을 개발한다.

📕프레임워크 vs 라이브러리 차이

프레임워크, 라이브러리의 가장 큰 차이는 "흐름을 누가 결정하는가"이다. 라이브러리는 개발자가 직접 프로그램의 흐름을 결정하지만 프레임워크는 정해진 흐름에 맞게 개발자가 프로그램을 개발한다.

📕스프링은 아래 그림과 같이 구성되어있는 프레임워크이다. (출처)

2. Spring MVC 구조란?

스프링 프레임워크는 MVC 구조로 이루어져 있다.

📕MVC 구조란? Model - View - Controller 의 줄임말

Spring의 MVC 구조를 살펴보면 아래와 같다.

• View - Controller - Service - Serviceimpl - DAO - DAOimpl - DTO 각 구조에 대해 보면 크게 View, COntoller, Service, DAO, DTO로 이루어져 있다. 이외에도 DispatcherServlet, servlet-context가 있지만 우선 위 구조만 살펴보자.

• View 말 그대로 사용자에게 보여지는 화면을 View라고 한다. Spring에서는 JSP를 통해 화면을 구성하고 Controller를 통해 백엔드 서버와 연결한다.

• Controller View와 Service 사이를 연결한다. 클라이언트에서 입력한 URL에 맞는 View를 보여주고, View에서 처리하는 데이터를 Service로 전달해준다.

@RequestMapping(value = "/")
    public String home() {
    service.method();
        return "index";
    } // localhost:port/로 접속한 클라이언트에게 index.jsp를 반환한다.

• Service 실제 로직을 처리하는 곳으로 모든 기능은 Service에서 만들어진다. Controller를 통해 화면과 연결되고, DAO를 통해 데이터베이스와 연결된다.

• DAO Data Access Object의 줄일말인 DAO는 프로젝트와 데이터베이스를 연결한다. Mapper에 SQL을 명시한뒤 Mapper와 함께 데이터베이스와 데이터를 주고받는다.

• DTO Data Transfer Object의 줄임말이고 VO(Value Object)라고도 불리는 DTO는 MVC구조 사이사이에서 데이터 교환을 위한 오브젝트이다. 특이하게 getter/setter 두가지 함수만 가지고 있으며 주로 데이터베이스 테이블과 매칭된다. 👉DTO와 VO가 완벽하게 같은 말은 아니지만 크게 차이를 두진 않는다.

public class temp { //데이터 베이스 테이블 컬럼과 GET,SET만 가지고있다.

    private int id;
    private String name;

    public int getId() {return id;}
    public void setId(int id) {this.id = id;}

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
}

👉Service -Serviceimpl / DAO - DAOimpl은 무엇일까? impl은 implement의 줄임말로 Serviceimpl은 Service라는 인터페이스를 implemets, Daoimpl은 DAO라는 인터페이스를 implements한 것이다.

interface와 impl을 나누어 설계하는 이유는 다음번에 알아보려고한다.

3. Ioc, DI

3-1. Ioc (Inversion of Control)**

IoC를 그대로 해석하면 제어의 역전이다. 무엇인가 제어하는 주체가 바뀐다는 의미인데 어떤 제어가 어떻게 바뀌는 것일까?

Spring을 사용해 본 사람이면 알듯이 Service, DAO같은 객체를 사용자가 직접 생성(new) 하지 않는다. @Autowired를 통해 받아 사용하는데 이 @Autowired가 IoC(제어의 역전)이다.

//기존 자바 프로젝트

public class order {
    private Customer customer;

    public order() {
        this.customer = new Customer();
    }
}

// Spring 프로젝트
public class order {

    @Autowired
    private Customer customer;
}

스프링 컨테이너(IoC container)는 프로젝트에서 사용되는 객체들을 Bean으로 관리하고 있고 @Autowired를 통해 객체를 주입해준다.

기존엔 사용자가 생성(new)해 파라미터로 다른 객체로 보내거나, 사용할 일이 없을 경우 객체를 소멸하는 등 객체에 대한 제어를 직접 진행했다. 하지만 Spring에서는 위처럼 제어를 사용자가 아닌 Spring Framework가 진행하기 때문에 제어의 역전이라고 표현한다.

Spring Bean

Spring에서 Bean은 스프링 프레임워크에 의해서 관리되는 자바 객체이다.

👉Spring Bean은 Java Bean과 다른 의미이다.

IoC는 왜 필요할까?

IoC 프로그램 모델은 곧 역할과 책임의 분리 라는 내용과 관련이 있다. 역할과 책임을 분리해 응집도를 높이고 결합도를 낮추며, 이에 따라 변경에 유연한 코드 를 작성할 수 있는 구조가 될 수 있다. 결국 IoC를 사용하면 결과적으로 객체지향 원칙을 잘 지키는 코드를 만들 수 있다.

서브웨이에 간것을 예시로 들어보자. 🌯

• 우선, 제어의 역전이 없다면(❌), 우리는 직접 원하는 대로 재료를 선택한다면 알바생들은 이미 레시피(코드)에 지정되어 있는 재료의 샌드위치가 아니여서 당황을 겪게된다. 각 재료들에 대한 제어권 이 객체 내부에 있기 때문이다. 만약 요구를 반영하고자한다면 객체 내에 큰 변경이 생기게 된다.
• But, 제어를 역전시킨다면(⭕️), 각 재료들에 대한 제어권을 우리가 갖게 되어 우리가 직접 조합을 요청하여 자신만의 조합의 샌드위치를 주문할 수 있다. 객체 내부에서 재료의 종류를 제어해 변경이 자유롭지 못하던 코드가 외벵서 제어를 받으면서 변경이 자유롭게 가능해진다. 이를 통해 위에서 제어의 역전이 없을 때 생기는 큰 변경에 대한 문제를 해결할 수 있게 되었다.

할리우드 법칙 (Hollywood Principle)

Don't call us, we'll call you

우리가 어떤 것을 주도하여 호출하는 것이 아니라, 주도권은 빼앗기고 호출 당하기를 기다리는 모습과 유사하다.

3-2. DI (Dependency Injection)

제 3자가 제어를 관리하는 순간 제어의 역전이고, 스프링이 생기기 전부터 있던 개념이었기에 IoC는 다른 프레임워크와 다른 스프링만의 차별점을 설명하기 부족했다. 그래서 스프링만의 차별점을 설명하기 위해 만들어진 개념이 DI이다.

DI는 Spring에서 IoC 구조를 만드는 방식이다. DI를 그대로 해석하면 의존성 주입이다. 의존성은 무엇이고 왜 주입할까? 프로그래밍에서 뜻하는 의존성은 객체간의 관계를 먼저 알아야 이해하기 쉽다.

DI를 사용하는 이유는 개체간의 의존성을 줄이기 위함이다. 밖에서 객체를 생성해 넣어주기 떄문에 재사용성이 늘어나고 수정에 용이해진다.

//기존 자바 프로젝트
class concept_api implements Post(){}
class concept_Spring implements Post(){}

class Blog_log() {
private Post post; // 블로그 글 클래스

    public Blog_log() {
        this.post = new concept_api();
            this.post = new concept_Spring();
    }
}

// DI
private Post post; // 블로그 글 클래스

    public Blog_log(Post post) {
        this.post  = new post();
    }

만약 기존 프로젝트 처럼 interface를 직접 만든다면 글마다 CRUD 함수가 필요하지만, DI처럼 의존성을 주입해 사용한다면 Blog_log 하나의 클래스 만으로 모든 글을 관리할 수 있다.

의존관계 주입에서 의존관계 와 주입 은 무엇일까?

• 의존성 클래스 간 의존 관계(의존성)가 있다면, 한 클래스가 바뀌면 다른 클래스도 영향을 받는다. 결국 의존은 영향을 받는 관계라는 것을 의미한다.

• 주입 의존성을 다른 곳으로부터 주입해주는 것이다.

의존성은 어떻게 주입하면 될까?

3가지 방법이 존재한다. 1.생성자 주입 , 2.Setter 주입 , 3.Interface 주입

Spring 에서의 DI

Spring Framework에서 DI는 어떻게 이루어질까?

예시로 @Controller, @Service를 들 수 있다. Controller, Service는 의존관계를 지니고 있다. Controller에서 Service를 호출할때, Service를 받는 생성자가 어딘가에서 호출되어야 하지만 instance를 주입하는 코드를 쓰지 않아도 가능하다.

의존관계 자동 주입

스프링에서 객체 생성을 자동으로 생성해주는 역할 스프링 빈으로 등록되면 스프링이 자동으로 인스턴스를 생성하며 이때 필요한 의존성도 주입해준다.

Spring의 의존관계를 자동으로 주입하는 방법은 Autowored 를 사용하면 된다. @Autowired는 스프링 컨테이너가 주입하려 하는 객체의 타입이 일치하는 객체를(등록된 스프링 빈을) 찾아서 자동으로 주입 한다. Autowired 방법에도 필드, 생성자, setter 주입이 있다. (이때 생성자 주입은 완전한 생성자일 경우 NullPointerException을 방지할 수 있다.)

1. 전반적인 느낀 점

1) 이번주는 평일 2일을 쉬고 심지어 하루는 체력관리를 못해서 몸살가기를 앓아서 하루를 쉬어서 총 3일을 쉬고 2일만 나가게되었다.

2) 팀 프로젝트가 있었는데 조장님이 잘 이끌고 나가줘서 다행이라고 생각하였다.

2. 좋았던 점

1) MySql을 배우게 되었는데 JAVA보다는 쉽게 이해가 가서 기분좋게 수업을 들을 수 있었다.

3. 아쉬웠던 점

1) 체력관리를 못해서 쉬는날이 많았음에도 불구하고 자기관리를 못했던게 아쉽다. 너무 풀어진거같아서 다시 재정비해야겠다.

2) 팀프로젝트에 열정적으로 참여하지 못한것같아서 아쉬웠다. 이해도가 부족해서 서포트하는 느낌으로 참여할 생각을 했단게 생각해보면 말도안되는 생각이었던것 같다. 그래도 다행이 뜯어고칠 부분이 많이 있어 분업화를 새로할 계획이라 좀더 적극적으로 참여할 생각이다.

4. 개선할 점

1) 3주차가 됐는데 아직 루틴을 확실하게 못잡았다. 6개월은 조금더 욕구적인 측면에서 절제하면서 몸관리를 잘하면서 루틴을 완성 시켜야 할 것 같다.

2) 메모 하는 습관도 부족하여서 아쉬운점과 이해못한부분 확실한 메모가 필요하다!

3) 복습을 너무 안하고 있다... 다시 정신 잡아야한다 화이팅..!

5. 다음주 계획

1) 주에 Velog 3개 이상 쓰기

2) 이해 안되는 부분 복습 또 복습

3) 문제를 푸는데 최대한 답을 안보고 해결하기( 코드를 내힘으로 작성 ) 하루에 2문제 이상풀기 (간단한 문제라도)

4) 조별 미니 프로젝트 적극적으로 참여

... 어려워! 어리광 피우고 싶은 기분이 많이 든다.. 빠르게 이해하고 넘어가시는 분들을 보면 내머리가 나쁜가??? 하는 생각이 들기도하지만 할 수 있는건 복습이다...! 어렵다고 피하지 말자 ! ! 이렇게 다짐을 계속 하지만 하루 하루지나면서 무너지는 내모습이 아쉬운 기분이 드는건 어쩔 수 없는것 같다.. 그래서 이 기분을 돌파 하려면 수업중 들으면서 여쭤봐도 이해 안되는 부분을 메모 해놓고 돌아와 따로 찾아보면서 velog에 올릴 생각 이다 ! 결국 남는건 사진 기록이다 !!

목표

• 일주일에 10개 이상 velog 올리기 (짧더라도)
• 코딩테스트 문제 하루에 3개이상
• 모르는 용어 메모하기
• 코드랑 친해지기

String substring(int index)

substring 함수는 두가지가 있으며, 그중 첫번째로 인자값을 하나만 받는 함수 입니다. 인자값은 int 형으로 substring 하고자 하는 문자열의 앞에서 부터 몇번째 위치인가를 지정하는 값입니다. 입력받은 인자값을 index 로 해당 위치를 포함하여 이후의 모든 문자열을 리턴 시키는 함수 입니다.

이때 이 index 값은 0부터 시작 합니다.

String str = "0123456789";

위와 같은 문자열이 있을때 0~4 까지를 제외한 56789 를 가져오고 싶을 경우 아래와 같이 호출 하면 됩니다.

str.substring(5)

index 값이 5인 위치 이후 값을 가져오라고 했으므로 56789를 리턴하게 됩니다.

String substring(int beginIndex, int endIndex)

이번에 알아볼 substring 함수는 입력 인자값이 두개 입니다.

첫번째 입력 받는 인자 값은 인자값이 한개인 substring 과 같이 가져올 문자열의 시작 부분을 지정합니다. 두번째 입력 받는 인자 값은 가져올 문자열의 끝 부분을 지정 하는 것으로 substring(in index) 가 시작부분만 지정하고 나머지 모든 문자열을 리턴하는것과 차이가 있습니다.

beginIndex 위치에서 시작하여 endIndex 전 위치까지의 값을 리턴합니다.

다음 문자열중 356512 값만 가져오는 것을 연습해 보겠습니다.

String str = "0000003565120";
System.out.println(str.substring(6,12);

시작 인덱스 값을 6으로 끝나는 인덱스 값을 12로 설정하여 원하는 356512 라는 값을 리턴 받을 수 있습니다. substring(6,12) ==> index 6 위치에서 index 12 -1 위치 (11자리) 까지의 값을 리턴 합니다.

변수란 프로그램에 의해 이름을 할당받은 데이터를 저장 할 수 있는 메모리 공간 을 의미합니다. ex) 사람의 나이, 학생의 학년, 사원의 수

변수 선언

변수 선언 방법은 변수에 맞는 자료형과 변수 이름으로 선언합니다.

변수를 선언하는 두가지 방법

1. 변수의 선언만 하는 방법 변수를 선언하여 메모리 공간만을 할당받고, 나중에 변수를 초기화하는 방법

public class VariableEx {
    public static voic main(String[] args) {
        int age;

        age = 11;

        System.out.println(age);
    }

}
// 결과 : 11

2. 변수 선언과 동시에 초기화하는 방법 변수 선언하여 메모리 공간을 할당받음과 동시에 변수를 초기화 하는 방법

public class VariableEx {
public static voic main(String[] args) {
        int age = 11;

        System.out.println(age);
     }
}
//결과 : 11

변수 명명 규칙

변수의 이름은 영문자(대소문자), 숫자를 사용함(단 숫자로 시작할 수 없다.) ex) 1level = X 변수의 이름은 특수문자 중에 '_' 와 '$' 만 사용가능 함 변수의 이름 사이에는 공백을 포함할 수 없음 변수의 이름으로 java에서 미리 정의 한 키워드 즉 예약어(reserved word)는 사용 할 수 없음 변수의 이름은 그 쓰임에 맞는 이름으로 명명하는 것이 가독성에 좋음

변수와 메모리

변수를 선언하는 것은 해당 자료형의 크기 만큼의 메모리를 사용하겠다는 것이다. 변수는 기본적으로 메모리의 주소를 기억하는 역할을 합니다. 여기서 메모리 주소란 물리적인 메모리 공간을 서로 구분하기 위해 사용되는 일종의 식별자입니다. 즉 메모리 주소란 메모리 공간에서의 정확한 위치를 식별하기 위한 고유 주소를 의미합니다.

변수를 참조할 때는 메모리의 주소를 참조하는 것이 아닌 해당 주소에 저장된 데이터를 참조하게 됩니다. 따라서 변수는 데이터가 저장된 메모리의 주소뿐만 아니라 저장된 데이터의 길이와 형태에 관한 정보도 같이 기억해야 합니다. 아래의 그림은 메모리상에 변수가 어떤 식으로 저장되는지를 보여줍니다.

위의 그림처럼 하나의 메모리 공간에는 8개의 비트로 이루어진 1바이트의 데이터가 저장됩니다. 따라서 메모리의 주소 또한 1바이트씩 증가되며, 낮은 주소부터 차례대로 데이터가 저장됩니다. 위의 그림에서 변수의 길이가 총 4개의 메모리 공간을 포함하므로 해당 변수에는 4바이트의 데이터가 저장되어 있습니다. 이때 변수의 이름은 첫번째 메모리 주소인 0x10만을 가리키게 됩니다. 따라서 변수의 길이가 4입니다.

<문제>

<풀이>

해당 문제에서는 자바의 반복문 for문 에 대해 알 수 있습니다.

String[] numbers = {"one", "two", "three")};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

• for문 구조

for(초기치; 조건식; 증감식) { 조건식이 참일 동안만 반복; }

<채점결과>

<정답코드>

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        int n = sc.nextInt();

        for(int i = 0; i < n; i++){
            System.out.print(str);
        }

    }
}

<문제 출처>

https://school.programmers.co.kr/learn/courses/30/lessons/181950

<문제>

해당 문제에서는 자바의 출력문 println 에 대해 알 수 있습니다.

println()

 System.out.println("문자열");
 System.out.println(변수명);
 System.out.println("문자열" + 변수명);

<채점결과>

<정답 코드>

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();

        System.out.print("a = " + a );
        System.out.println();
        System.out.print("b = " + b );
        System.out.println();
    }
}

<문제 출처>

https://school.programmers.co.kr/learn/courses/30/lessons/181951

<문제>

해당 문제에서는 자바의 출력문 에 대해 알 수 있습니다.

System.out.print("Hello World!");

<채점결과>

<정답 코드>

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.next();
        System.out.println(a);
    }
}

<문제 출처>

https://school.programmers.co.kr/learn/courses/30/lessons/181952

클래스(Class)

• 클래스는 객체를 만들기 위한 설계도 입니다.
• 흔히 클래스를 붕어빵 틀, 객체를 붕어빵이라고 비유합니다.

예를들어, 건물이 있습니다. 이 건물을 표현하는 속성에는 건물명, 주소, 층수등이 있습니다. 그리고 이 건물이 수행하는 행동에는 엘리베이터 운행등이 있습니다.

위와 같이 속성과 행동을 설계하는 것이 클래스 입니다. 그리고 이 클래스라는 설계도를 통해 여러 건물이라는 객체를 만들어낼 수 있습니다.

다른 비유를 들어본다면

영화 예매 사이트에는 회원이 존재합니다. 회원을 클래스로 만든다고 하면 필요한 속성과 행동은 무엇일까요?

• 속성 : 이름, 전화번호, ID, PW, 마일리지, ....
• 행동 : 영화 예매하기, 이벤트 참가하기, ....

이와 같이 클래스를 설계할 수 있고, 이 클래스를 통해 객체를 만들 수 있습니다.

클래스 작성 방법

public class <클래스명> {
    Data_Type <변수명>;

    public <클래스명>(파라미터1, 파라미터2, ....) {
        // 생성자 내부 구현
    }

    public Return_Type <메소드명>(파라미터1, 파라미터2, ...) {
        // 생성자 내부 구현
    }
}

메소드: Return Type

일을 수행한 결과값을 일을 시킨 곳에 알려주는 역할을 합니다.

• 되돌려줄 값이 있다면 그 값에 해당하는 데이터 타입(int, double, String, ...)을 입력합니다.

public int withdraw() {
    return 10000;
}

• 되돌려줄 값이 없다면 void를 입력합니다.

public void sparkle() {

}

메소드 : 파라미터

메소드를 호출한 쪽에서 실제 기능을 수행할 메소드에게 알려주어야 하는 부가 정보가 있는 경우에 사용합니다.

아래의 코드에서 int money를 파라미터라고 합니다.

public void deposit(int money) {
    balance += money;
}

public void calculateSum(double num1, double num2) {
    result = num1 + num2;
}

예제 : 계좌 클래스 작성

public class Account {
    // 필드 작성
    String accountHolder; // 예금주
    String accountNumber; // 계좌번호
    int balance;           // 잔액

    // 생성자

    // 메소드
    public void deposit(int money) {      //입금
        System.out.println(money + "원을 입금합니다.");
        balance += money;
    }

    public void withraaw(int money) {    //출금
        System.out.println(money + "원을 출금합니다.");
        balance -= money;
    }

    public void showBalance() {          //잔액조회
        System.out.println("잔액 : " + balance + "원");
          return balance;
    }
}

객체 생성 및 메소드 호출

• 객체란 현실 세계에 실제로 존재하는 것을 의미합니다.
• 클래스 설계대로 작성한 클래스의 속성에 특정한 값들을 대입하여 의미를 가지게 하는것 입니다.

객체 생성 및 메소드 호출 방법

• 키워드 new를 사용하여 객체를 생성할 수 있습니다.

<클래스명> <변수명> = new <클래스명>();

Student student = new Student();
Book book = new Book();

<변수명>.<필드명>;
student.name = "홍길동";

<변수명>.<메소드명>(파라미터1, ...);
student.calculateAverage();
book.searchBooks("Java");

계좌 클래스를 이용한 객체 생성 및 메소드 호출 (예제)

앞서 생성한 계좌 클래스를 이용해 객체를 생성하고 메소드를 호출해보겠습니다.

public class AccountTest {

    public static void main(String[]args){
        // 계좌 클래스를 이용해 account라는 Account 클래스 타입 객체 생성
        Account account = new Account();

        //속성 정의
        account.accountHolder = "홍길동";
        account.accountNumber = "123-456789";
        account.balance = 10000;

        //메소드 호출
           System.out.println("계좌" + account.accountNumber + " ( 예금주 : " 
        + account.account.showBalance();

    }
}

*결과값은 아래와 같습니다. *

계좌 123-456789 (예금주 : 홍길동) 잔액 : 10000원 20000원을 입금합니다. 잔액 : 30000원 45000원을 출금합니다. 잔액 : -1500원

메소드의 여러 가지 형태

만약 클래스 내에서 메소드를 아래와 같이 정의했다면,

  public String formatTime(int hour, int minute) {}

아래와 같이 변수를 선언하며 호출할 수도 있습니다.

  String timeInfo = colock.formatTime(5, 2);

메소드 오버로딩(Overloading)

한 클래스 내에 비슷한 기능의 메소드를 같은 이름으로 여러 개 정의하는 것을 의미합니다.

메소드 오버로딩의 조건

• 메소드 이름이 같아야 합니다.
• 메소드 파라미터의 개수, 데이터 타입, 순서가 달라야 합니다.
• 메소드 리턴 타입이 다르면 다른 메소드로 인식합니다.

Overloading 클래스

  public class Overloading {
      public void addition( int num1, int num2 ) {
        System.out.println( num1 + num2);
    }
    public void addition ( double num1, double num2) {
        System.out.println( num1 + num2);
    }
    public void addition ( String str1, String str2) {
        Systme.out.println( str1 + str2);
    }
  }

Overloading 메소드 호출

  public class OverloadingTest
      public static void main ( String[] args) {
        Overloading overloading = new Overloading();

        overloading.addition( 1000, 365);
        overloading.addition( 4.3, 1.8);
        overloading.addition( "ANT", "AND");
    }
}

생성자

생성자는 클래스를 이용하여 객체를 만들어주는 작업자입니다. 클래스라는 설계도에 따라 여러 객체를 만들 때 생성자를 통하게 됩니다.

모든 클래스는 객체를 생성할 수 있도록 최소한 하나의 생성자를 갖습니다. 클래스에 생성자가 하나도 없다면, 자동으로 기본 생성자가 추가됩니다. 기본 생성자란, 매개 변수가 없고 내용이 없는 생성자입니다.

만약 생성자가 하나라도 생성되어 있다면 기본 생성자를 생성하는 방식으로는 객체를 생성할 수 없습니다.

생성자 작성 방법

public <클래스명> ( 파라미터 변수, ...) {
// 필드 초기화
}

public Student() {...}
public Student(String name) {...}
public Student(String name, String id) {...}

생성자를 통해 객체를 생성하는 방법

//기본 생성자로 객체 생성
Student student = new Student();

//생성자를 생성한 후 생성자를 통해 객체 생성
public Book(String title, int price) {
    tihs.title = title;
    this.price = price;
}

Book book = new Book("해리포터", 8000);

this 자신의 클래스에 있는 필드나 멤버 메소드에 접근하고 싶을 때 사용하는 키워드 입니다.

생성자 오버로딩

• 초기값을 세팅해야 하는 데이터가 각각 다르다면, 생성자를 오버로딩 합니다.
• 생성자에서 정의하지 않은 필드는 자동으로 초기값을 가지게 됩니다.

public class Book {
    String title;
    String author;
    int price;

    public Book( String author ) {
        this.author = author;
    }

    public Book ( String title, String author) {
        this.title = title;
        this.author = author;
    }

    public Book ( String title, String author, int price ) {
        this.title = title;
        this.author = author;
        this.price = price;
    }
}

오버로딩된 생성자를 this를 통해 참조하도록 할 수 있습니다. 이때, 주의할 것은 this를 생성자의 첫 번째 라인에 둬야 한다는 것입니다.

public class Book {
    String title;
    String author;
    int price;

    public Book( String author ) {
      this.author = author;
    }

    public Book( String title, String author ) {
      this(author);
      this.author = author;
    }

    public Book( String title, String author, int price ) {
      this(author, title);
      this.price = price;
    }
}

자료 구조란 현실 세계 및 추상적 세계에서의 Data들의 모임 또는 이러한 Data들의 관계 등 Data들의 집합을 의미 합니다.

신중히 선택한 자료구조 혹은 설계된 자료구조는 더 효율적인 알고리즘을 사용할 수 있게 하며 실행시간 및 메모리 용량과 같은 자원을 최소한으로 사용하면서 연산을 수행하도록 해줍니다.

자료구조는 원하는 형식으로 만들 수도 있으며, 지금부터 기존에 널리 알려진 자료구조 및 알고리즘을 풀면서 필요했던 다양한 자료구조에 대해 정리해 보겠습니다.

ST2. 단순구조

기본적으로 제공하는 자료형 및 추가로 정리한 자료형(BigDecimal)

정수

• byte, short, long, int

실수

• float, double
• BigDecimal

BigDemcimal

실수형 소수점 사칙연산의 한계를 극복하며 큰 수를 다루기 위해 사용됩니다. 단점은 느립니다!

BigDecimal number1 = new BigDecimal("0.001"); BigDecimal number2 = new BigDecimal("0.0007");

더하기

number1 + number2 = number1.add(number2)

빼기

number1 - number2 = number1.subtract(number2)

곱하기

number1 * number2 = number1.multiply(number2)

나누기

number1.divide(number2, 3, RoundingMode.UP) // 올림
number1.divide(number2, 3, RoundingMode.HALF_UP) // 반올림
number1.divide(number2, 3, RoundingMode.DOWN) // 버림

나머지

number1.remainder(number2)

절댓값

number1.abs()

최소값

number1.min(number2)

최대값

number1.max(number2)

논리적 비교

if( number1.compareTo(number2) == 1) {
    System.out.println("number1 > number2");
}else if (number1.compareTo(number2) == 0 ) {
    System.out.println("number1 == number2");
}else {
    System.out.println("number1 < number2");
}

문자

• char

문자열

• String

ST3. 선형구조

리스트 (List)

일반적으로 List형 자료구조는 배열과 같이 일자로 나열되어 서로 연결된 자료구조를 말합니다. 배열과의 차이점은 빈틈없이 자료를 적재하는 것이 목적인 자료구조입니다. 자료 중간의 삭제가 일어난다면 중간의 자료를 제거하고 앞뒤 연결이 필요합니다.

순차리스트

배열을 기반으로 구현된 리스트입니다. 장점 : indeex로 바로 데이터를 가지고 올 수 있어 검색이 빠릅니다. 단점 : 중간 데이터의 삭제가 일어난다면 삭제 후 다시 정리하는 과정이 필요하다는 것이 단점이기에 중간 데이터의 빈번한 수정이 일어난다면 추천하지 않습니다.

List<Integer> numberList = new ArrayList();

연결 리스트

데이터가 서로 연결된 형태의 자료형입니다. 장점 : 데이터의 추가 삭제는 위치정보 수정만으로 가능하여 정보의 추가 삭제가 일어 날 때 유용합니다. 단점 : 검색을 위해서 자료를 순차적으로 확인해야 하기 때문에 검색에는 비효율 적입니다.

단순 연결 리스트 (simple linked list)

가장 단순한 형태로 현재의 노드들은 다음 노드를 가리키는 하나의 참조 만을 가지고 있기에 한쪽 방향의 노드의 접근만 가능합니다.

이중 연결 리스트( double linked list)

끝점과 시작점이 연결된 구조입니다.

원형 연결 리스트( Circular linked list)

단순 연결 리스트 자료구조에서 마지막 노드를 첫 노드와 연결한 구조입니다.

위와 같은 개념적인 형상을 기반으로 원하는 형식으로 자료구조를 만들면 됩니다. 가볍게 이중 연결 리스트 자료구조를 만드는 방법을 보여드리겠습니다. java에서 제공하는 LikedList 같은 경우 데이터를 저장하는 각 노드가 이전 노드와 다음 노드의 상태만 알고 있는 자료구조 입니다. 이제 제일 복잡해 보이는 double linked list를 구현해 보겠습니다. 그리고 해당 자료구조를 만드는 데 필요한 add, remove 메서드, 그리고 특정 index 위치의 데이터를 추출하기 위한 get 메서드 전체를 순회하는 toString 메서드를 구현해보겠습니다.

public class  DoubleLinkedList<E> {
    private Node<E> head;
    private Node<E> tail;
    private int size = 0;

    public void add( E item ) {
        Node<E> temp = new Node<>( item );
        if( tail == null ) {
            head = temp;
            tail = temp;
        } else {
            Node<E> lastNode = getNode(size-1);
            lastNode.next = temp;
            temp.before = lastNode;
            temp.next = head;
            head.before = temp;
            tail = temp;
        }
        System.out.println(temp.item +"이 삽입되었습니다.");
        size++;

    }

    private void checkingValidataion( int index ) {
        if( size < index + 1 ) {
            throw new IndexOutOfBoundsException("size를 확인하세요");
        }

    }
    public void remove( int index ) {
        Node<E> temp = getNode(index);
        Node<E> nextNode = temp.next;
        Node<E> beforeNode = temp.before;
        beforeNode.next = nextNode;
        nextNode.before = beforeNode;
        System.out.println(temp.item +"이 지워졌습니다.");
        if( index == 0 ) {
            head = nextNode;
        }
        if( size == 1 ) {
            head = null;
            tail = null;
        } else if( index == size-1 ) {
            tail = beforeNode;
        }
        size--;
    }

    public E get( int index ) {
        Node<E> temp = getNode(index);

        return temp.item;
    }

    private Node<E> getNode( int index ) {
        checkingValidataion(index);
        Node<E> temp;
        // 효율적 탐색을 위한 설계
        if ( index < size / 2 ) {
            // 앞에서 부터 찾기 
            temp = head;
            for (int inner = 0; inner < index; inner++) {
                temp = head.next;
            }
        } else {
            //뒤에서 부터 찾기
          temp = tail;
            for (int inner = size - 1; inner > index; inner--) {
                temp = temp.before;
            }
        }
        return temp;
    }

    @Override
    public String toString() {
        if( size == 0 ) {
            return "노드가 비었습니다.";
        }
        StringBuilder result = new StringBuilder();
        Node<E> temp = head;
        for( int index = 0; index < size; index++ ) {
            result.append("노드 순회 index : ").append(index).append(" ").append(temp.item).append("\n");
            temp = temp.next;
        }
        return result.toString();
    }
    // DoubleLinkedList에서 사용할 중첩클래스
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> before;

        public Node(E item ) {
            this.item = item;
            this.next = null;
            this.before = null;
        }

    }
}

DoubleLinkedList<Integer> doubleLinked = new DoubleLinkedList<>();
doubleLinked.add(1);
doubleLinked.add(2);
doubleLinked.add(3);
doubleLinked.add(4);

System.out.println(doubleLinked.toString());

doubleLinked.remove(2);

System.out.println(doubleLinked.toString());

1     1이 삽입되었습니다.
2    2이 삽입되었습니다.
3    3이 삽입되었습니다
4    4이 삽입되었습니다.
5    노드 순회 index : 0 1
6    노드 순회 index : 1 2
7    노드 순회 index : 2 3
8    노드 순회 index : 3 4
9
10    3이 지워졌습니다.
11    노드 순회 index : 0 1
12    노드 순회 index : 1 2
13    노드 순회 index : 2 4

스택 (Stack)

Stack이란 마지막에 들어온 데이터를 먼저 내보내는 후입선출(LIFO)을 표현하기 위한 자료구조 입니다. 예를 들어 웹이서 History는 마지막 접근했던 페이지로 돌아가야 할 경우 이런 경우를 위해 사용하는 자료구조입니다. 위에서 작성했던 코드를 응용해서 push( 집어넣는 메서드 ), pop( 가져오는 메서드 ) 정도만 새로 작성한다면 기본적으로 사용할 수 있습니다. (물론 push,pop 두 가지만으로 는 불 충분 합니다.) Java에서 제공하는 java.util.Stack 라이브러리 stack 을 사용하는 방법이 있습니다.

• push() : 마지막 위치에 데이터 삽입
• pop() : 마지막 데이터 제거 후 제거된 데이터 return
• peek() : 마지막에 들어온 데이터를 return 합니다.
• isEmpty() : stack이 비었는지 확인합니다.

Stack<String> stack = new Stack<>();
stack.push("first");
System.out.println("삽입 : " + stack.peek() );
stack.push("second");
System.out.println("삽입 : " + stack.peek() );
stack.push("third");
System.out.println("삽입 : " + stack.peek() );
stack.push("forth");
System.out.println("삽입: " + stack.peek() );

for( String item : stack ) {
    System.out.println("순회 : " + item);
}
while( !stack.isEmpty() ) {
    System.out.println("제거 : " + stack.pop() ); 
}

System.out.println("Stack이 비었습니까 : " + stack.isEmpty());

큐 ( Queue )

Queue란 먼저 들어온 데이터를 먼저 내보내는 선입선출(FIFO)을 표현하기 위한 자료구조입니다. 예를 들어 프린트나 테이블 예약 같은 경우 먼저 예약한 사람이 우선일 때 필요한 자료구조입니다. Java에서 que를 사용하기 위해서는 java.util.Queue를 구현한 클래스를 사용하면 됩니다. 내부 연결 구조를 배열로 만들었느냐, 연결 리스트 구조로 만들었느냐에 따라 내부 로직과 위 리스트에서 언급한 장단점이 생기게 되지만 사용법은 같습니다.

• add() : que자료구조에 데이터 삽입.
• peek() : 제일 먼저 들어와 상단에 위치한 데이터를 말합니다.
• poll() : 상단에 위치한 데이터를 추출하고 que에서 제거 합니다. 추출한 데이터를 return 합니다.
• isEmpty() : stack이 비었는지 확인합니다.

Queue<String> queData = new ArrayDeque<String>();
// Queue<String> queData = new LinkedList<String>();

queData.add ("first");
queData.add ("second");
queData.add ("third");
queData.add ("forth");

for( String item : queData){
    System.out.println("순회 : " + item);
}

while( ! queData.isEmpty() ) {
    System.out.println("제거 : " + queData.poll());
}

System.out.println("queData가 비었습니까 : " queData.isEmpty());

우선순위 큐 (Priority Queue )

선입 선출 구조의 Que와 다른 점은, 우선순위에 따라 우선순위가 높은 객체가 먼저 나오는 자료구조 입니다. 우선순위 Que를 구현하는 방법은 배열 기반으로, 연결리스트를 기반으로, Heap을 이용하여 구현하는 방법이 존재합니다. 배열로 우선순위큐를 구현했을 경우 데이터 삽입, 삭제과정에서 데이터를 밀고 당기는 연산을 해야 하는 단점과 연결리스트로 우선순위 que를 구현하였을 경우 삽입의 위치를 찾기 위해 첫 번째 노드부터 마지막에 저장된 노드까지 순회해야 하는 기본적인 문제가 있어 더 좋은 성능을 발휘하는 Heap 기반으로 구현하는 것이 일반적입니다.

Heap은 tree구조로 데이터를 정제하여 넣습니다. java.util.PriorityQueue을 사용한다는 것은 결국 heap을 구성하는 것 이라고 봐도 무방합니다. 우선 Heap을 알기 전에 최종 목표인 Priority Queue의 사용법을 알아보겠습니다.

원론적으로 우선순위큐를 사용한다는 것은 Priority Queue에 들어갈 객체는 우선순위를 나타내기 위해 Comparable 인터페이스의 compareTo메서드를 구현하거나, 들어갈 객체를 변경할 수 없어 Comparable 인터페이스를 구현하지 못하는 경우 Pririty Queue생성 시 생성자로 Comparator 인터페이스를 구현한 객체를 넘기면 됩니다.

두 방법 다 사용법을 확인해보겠습니다. 우선순위 큐에 넣을 객체는 Student로 시험 점수가 높은 사람을 top으로 위치하도록 우선순위 큐를 세팅하는 것ㅇ입니다. 추가적인 욕심으로 동점자의 경우 사전식으로 정렬되도록 세팅 하겠습니다. 아직 배우지 않았지만 java.util.PriorityQueue의 경우 기본 Heap구성은 minHeap으로 구성되기 때문에 상단에 위치한 데이터는 우선순위가 작은 값부터 위치한다고 보면됩니다.

당장 필요한 것은 우선순위가 높은 것이 위쪽에 위치하는것이기 때문에 Comparator.reverseOrder()를 사용했다 정도만 이해하면 되겠습니다. 그리고 우선순위가 높다는 것은 Comparator 혹은 compareTo 비교를 통해 +1 이 나오도록 하면 우선순위가 높다고 이해하면 됩니다.

// Comparable 구현 
public class Student implements Comparable<Student> {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public int compareTo(Student input) {
        int result = Integer.compare(score, input.score);
        if( result == 0 ) {
            result = input.name.compareTo(name);
        }
        return result;
    }

    @Override
    public String toString() {
        return "이름 : " + name + " 점수 : " + score;
    }
}

PriorityQueue<Student> priorityQueue = new PriorityQueue<>(Comparator.reverseOrder());
priorityQueue.add(new Student("김석진", 100));
priorityQueue.add(new Student("박석진", 90));
priorityQueue.add(new Student("진석진", 95));
priorityQueue.add(new Student("구석진", 88));
priorityQueue.add(new Student("다석진", 100));
priorityQueue.add(new Student("사석진", 100));
priorityQueue.add(new Student("나석진", 100));

1    // 출력 
2    이름 : 김석진 점수 : 100
3    이름 : 나석진 점수 : 100
4    이름 : 다석진 점수 : 100
5    이름 : 사석진 점수 : 100
6    이름 : 진석진 점수 : 95
7    이름 : 박석진 점수 : 90
8    이름 : 구석진 점수 : 88

// comparator 이용 
public class Student {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "이름 : " + name + " 점수 : " + score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

}

PriorityQueue<Student> priorityQueue = new PriorityQueue<>( ( first, second )-> {
    int result = Integer.compare(second.getScore(), first.getScore());
    if( result == 0 ) {
        result = first.getName().compareTo(second.getName());
    }
    return result;
}) ;
priorityQueue.add(new Student("김석진", 100));
priorityQueue.add(new Student("박석진", 90));
priorityQueue.add(new Student("진석진", 95));
priorityQueue.add(new Student("구석진", 88));
priorityQueue.add(new Student("다석진", 100));
priorityQueue.add(new Student("사석진", 100));
priorityQueue.add(new Student("나석진", 100));

while( !priorityQueue.isEmpty() ) {
    Student student = priorityQueue.poll();
    System.out.println(student.toString());

}

1    // 출력 
2    이름 : 김석진 점수 : 100
3    이름 : 나석진 점수 : 100
4    이름 : 다석진 점수 : 100
5    이름 : 사석진 점수 : 100
6    이름 : 진석진 점수 : 95
7    이름 : 박석진 점수 : 90
8    이름 : 구석진 점수 : 88

Heap

Heap이란 우선순위를 둔 우선순위 큐를 위해 필요한 자료구조로 부모의 노드는 항상 자식의 노드보다 클 경우를 Max Heap, 작을 경우를 Min Heap라고 합니다. 그럼 Max Heap, Min Heap 자료구조를 구성하기 위해 직관적으로 필요한 데이터를 넣는 add, 맨 위 데이터를 뽑은 pop 메서드를 구현해보겠습니다. 또한, 위와 같은 tree구조를 표현하기 위해 Node가 아닌 배열을 통해 완전 이진트리를 구성하겠습니다.

배열을 통해 Tree이진 트리 구성 관련은 아래에서 더 자세하게 다루고 MaxHeap 구현 방법입니다.

• add() : Max Heap의 경우 마지막 노드에 값을 넣은 후 부모 노드와 비교 후 들어온 값이 크면 부모 노드와 교체한다. 최상위 꼭대기까지 같은 로직을 반복한다.

• pop() : Max Heap의 경우 꼭대기 값을 반환 후, 마지막 노드를 root 노드와 교체후 자식 노드들과 크기 비교를 통해 자식이 클 경우 swap하는 로직을 통해 tree를 재구성 한다.

• isEmpty() : Heap이 비었는지 확인한다.

  public class MaxHeap <T extends Comparable<T> > {
    private int maxSize;
    private int pointer; // 마지막 노드의 위치를 저장하기 위해 필요
    private Object[] heap;
  
  

public MaxHeap( int arrSize ){
    arrSize++;
    maxSize = 1;
    pointer = 0;
    while( maxSize <= arrSize ) {
        maxSize <<= 1;
    }

    this.heap = new Object[arrSize];
}

public void add( T item ) {
    if(isFull()) {
        throw new ArrayIndexOutOfBoundsException();
    }

    int tempIndex   = ++pointer;
    heap[pointer] = item;

    while( tempIndex > 0 && tempIndex != 1) {
        @SuppressWarnings("unchecked")
        T parentValue = (T) heap[tempIndex/2];

        if( parentValue.compareTo( item ) < 0) {
            T swapData = parentValue;
            heap[tempIndex/2] = item;
            heap[tempIndex] = swapData;
        } else {
            break;
        }
        tempIndex /= 2;
    }
}

@SuppressWarnings("unchecked")
public T pop() {
    if(isEmpty()) {
        throw new ArrayIndexOutOfBoundsException();
    }
    T result      = (T)heap[1];
    T lastChild   = (T)heap[pointer];
    heap[1]         = lastChild;
    heap[pointer--] = 0;

    int tempIndex   = 1;
    while( tempIndex*2 <= pointer ) {
        Boolean hasRightChild = tempIndex*2+1 <= pointer;
        T leftChild  = (T)heap[tempIndex*2];
        T rightChild = (T)heap[tempIndex*2+1];
        T parent     = (T)heap[tempIndex];
        T changeValue = null;
        int changeIndex;

        if( !hasRightChild ) {

            if( parent.compareTo(leftChild)  > 0 ) break;
            changeIndex = tempIndex*2;
            changeValue = leftChild;
        } else {
            if( parent.compareTo(leftChild)  > 0 && parent.compareTo(rightChild)  > 0 ) break;

            changeValue = leftChild.compareTo(rightChild) < 0? rightChild : leftChild;
            changeIndex = leftChild.compareTo(rightChild) < 0? tempIndex*2+1 : tempIndex*2;

        }

        //교체
        heap[tempIndex]    = changeValue;
        heap[changeIndex]  = parent;
        tempIndex = changeIndex;
    }

    return result;
}

public boolean isEmpty() {
    return pointer == 0;
}

private boolean isFull() {
    return pointer >= maxSize;
}

}

- - -

```java
MaxHeap<Student> maxHeap = new MaxHeap<>(7);
maxHeap.add(new Student("김석진", 100));
maxHeap.add(new Student("박석진", 90));
maxHeap.add(new Student("진석진", 95));
maxHeap.add(new Student("구석진", 88));
maxHeap.add(new Student("다석진", 100));
maxHeap.add(new Student("사석진", 100));
maxHeap.add(new Student("나석진", 100));

1    // 출력 
2    이름 : 김석진 점수 : 100
3    이름 : 나석진 점수 : 100
4    이름 : 다석진 점수 : 100
5    이름 : 사석진 점수 : 100
6    이름 : 진석진 점수 : 95
7    이름 : 박석진 점수 : 90
8    이름 : 구석진 점수 : 88

덱 ( Deque )

Deque 란 Stack과 queue 양쪽으로 엘리먼트의 삽입과 삭제를 수행할 수 있는 자료구조입니다.

• add() : 데이터를 que형식으로 삽입합니다.

• addFirst() : 데이터를 위에서 삽입합니다.(Stack 형식)

• addLast() : 데이터를 아래에서 삽입합니다.(Que 형식 == add() )

• poll() : que의 poll과 같은 기능을 합니다.

• pollFirst() : que의 poll과 같은 기능을 합니다.

• pollLast() : deque의 하단에 tail 쪽의 데이터를 제거하고 return합니다.

//Deque<String> deque = new LinkedList<>();
Deque<String> deque = new ArrayDeque<String>();

deque.addLast("first");
deque.addLast("second");
deque.addLast("third");
deque.addLast("forth");

for( String item : deque  ){
    System.out.println("순회 : " + item);
}

while( !deque.isEmpty() ) {
    System.out.println("제거 : " + deque.pollLast() ); 
}

System.out.println("Stack이 비었습니까 : " + deque.isEmpty());

참고자료

– 윤성우의 열혈 자료구조 ( C언어 ) – 위키백과

Java의 역사는 1991년 6월 Sun Microsystems에 다니던 제임스 고슬링 이 만들었습니다.

왜 새로운 언어를 만들었을까?

자바는 초기에 토스터, 전자레인지, 리모콘 등의 가전제품에 사용되는 임베디드 소프트웨어 를 위해 만들어졌습니다. 이미 C, C++ 등 하드웨어에서 쓰이는 언어가 있었는데 왜 새롭게 언어 까지 만들었을까요?

당시 대부분의 컴퓨터 언어는 특정 플랫폼(또는 OS)이나 하드웨어에 맞게 컴파일 되도록 설계되었는데 플랫폼마다 그리고 각 플랫폼에서 쓰이는 CPU 마다 해당 환경에 맞는 컴파일러가 필요했기 때문에 개발 비용이 비싸고 오래 걸렸다고 합니다.

예를 들어 C++ 프로그램의 경우 모든 종류의 CPU에 맞게 컴파일될 수 있지만 플랫폼과 CPU에 따라 다른 C++ 컴파일러가 필요했습니다.

따라서 제임스 고슬링과 동료들은 OS에 상관없이, CPU에 상관없이 다양한 환경에서 실행 되는, 이식성이 뛰어난 Cross Platform 언어의 개발에 착수했고, 이러한 배경을 바탕으로 Write Once, Run Anywher(WORA)의 철학을 가진 자바의 탄생으로 이어졌습니다.

왜 이름이 Java 인가요?

초기에는 언어이름이 자바가 아니라 오크(Oak)였습니다. 당시 썬 마이크로시스템즈 Green Team 에 소속된 제임스는 처음에는 본인의 팀명을 따서 이름을 그린톡(Greentalk)으로 지었다가, 사무실 바깥의 오크나무를 보고 오크(Oak)로 바꾸었습니다.

하지만 후에 Oak라는 이름이 Oak Technologies에서 이미 사용 중이라는 사실을 알고, 동료들과의 회의를 거쳐서 "dynamic", "revolutionary", "Silk", "jolt", "DNA” 등의 이름 후보 중 최종적으로 인도네시아 자바섬에서 재배되는 커피원두에서 차용된 자바(Java) 라는 이름으로 결정되었습니다. (그래서 자바 로고에 커피가 있다는...)

결론적으로 1991년에 오크(Oak)라는 이름으로 시작하여, 1996년에 발표된 1.0.2 버전부터 자바(Java)라는 이름을 사용하게 되었습니다.

자바의 특징

자바의 개발자들은 유닉스(Unix) 기반의 배경을 가지고 있었기 때문에 문법적인 특성은 파스칼이 아닌 C++의 조상인 C언어와 비슷합니다. 그리고 C 에 객체 지향적 기능을 추가하여 만든 C++과는 달리, 처음부터 객체 지향 언어로 개발된 프로그래밍 언어 입니다.

위에서 자바를 만든 이유에서 설명했듯 자바의 가장 큰 특징은 컴파일된 코드가 플랫폼(또는 OS), CPU에 독립적이라는 점 입니다.

자바 언어는 다섯 가지의 특징이 있으며, 다음과 같습니다.

It should be "simple, object-oriented and familiar"
It should be "robust and secure"
It should be "architecture-neutral and poratble"
It should execute with "high performance"
It should be "interpreted, threaded, and dynamic"

이를 번역해보면 다음과 같다.

1. 자바는 "단순하고, 객체지향이며, 친숙"해야 한다.

2. 자바는 "견고하며, 보안상 안전"하다.

3. 자바는 "아키텍처에 중립적이어야 하며 포터블"해야 한다.

4. 자바는 "높은 성능"을 제공해야 한다.

5. 자바는 "인터프리터 언어이며, 쓰레드를 제공하고, 동적인 언어"이다.

1) 자바는 "단순하고, 객체지향이며, 친숙"해야 한다. 자바는 처음 만들 때부터 객체지향으로 디자인되어 있다. 그리고, 다형성, 캡슐화 등 객체 지향 언어의 특징들을 지원할 수 있는 구조로 되어 있다. 그리고, 자바로 개발할 때에는 처음부터 모든 것을 만들 필요가 없다. 개발하면서 필요한 여러 기능들은 이미 API를 통해서 제공하고 있다. 파일을 읽고 쓰거나 네트워크로 데이터를 주고 받는 I/O, 그래프 UI 등을 개발하기 위한 여러 라이브러리를 통해서 보다 쉽게 개발할 수 있는 환경을 제공하고 있다. 파일을 읽고 쓰거나 네트워크로 데이터를 주고 받는 I/O, 그래픽 UI 등을 개발하기 위한 여러 라이브러리를 통해서 보다 쉽게 개발할 수 있는 환경을 제공한다.

2) 자바는 "견고하며, 보안상 안전"하다. 자바는 컴파일할 때와 실행할 때 문법적 오류에 대한 체크를 한다. 메모리 관리 모델이 매우 단순하고, C를 배우고 사용하는 개발자들의 머리를 아프게 하는 포인터의 개념이 없다. 이 특징들은 자바를 매우 믿을 수 있고(reliable) 견고한 소프트웨어가 될 수 있도록 도와준다.

자바는 기본적으로 분산 환경에서 사용하기 위하여 디자인되었다. 분산 환경에서 보안은 중요한 부분 중 하나다. 자바 기술은 외부에서 침입이 불가능한 애플리케이션을 만들 수 있도록 해준다.

3) 자바는 "아키텍처에 중립적이어야하며 포터블"해야 한다. 자바로 작성한 프로그램은 매우 다양한 하드웨어 아키텍처에서 수행할 수 있도록 되어 있다. 따라서 자바는 아키텍처에 중립적인 바이트 코드를 제공한다. 따라서, 자바의 버전만 동일하다면, 동일한 프로그램은 어떤 플랫폼에서도 실행할 수 있다. 이러한 호환성과 포터블한 환경을 제공하는 것은 JVM 덕분이다.

4) 자바는 "높은 성능"을 제공해야 한다. 자바는 실행 환경에서 최대한의 성능을 낼 수 있도록 되어 있다. 게다가 자동화된 가비지 컬렉터는 낮은 우선 순위의 쓰레드로 동작하기 때문에 보다 높은 성능을 낼 수 있다. 그리고, 보다 빠른 성능을 위해서 네이티브 언어로 작성한 부분을 자바에서 사용할 수 있도록 되어 있다.

5) 자바는 "인터프리터 언어이며, 쓰레드를 제공하고, 동적인 언어"이다. 자바 인터프리터는 자바 바이트 코드를 어떤 장비에서도 수행할 수 있게 해준다. 따라서, 시존에 사용하던 무거운 컴파일과 링크와 테스트 사이클을 거쳐야 하는 개발 환경보다 빠른 환경을 구축할 수 있다.(하지만 지금의 자바 개발 환경은 각종 라이브러리들로 인해 그렇게 단순하지만은 않다.)

자바는 멀티 쓰레드 환경을 제공하기 때문에, 동시에 여러 작업을 수행할 수 있다. 따라서 사용자에게 매우 빠른 사용 환경을 제공한다.

자바 컴파일러는 컴파일시 매우 엄격한 정적인 점검을 수행한다. 그리고, 실행시에 동적으로 필요한 프로그램들을 링크시킨다. 게다가 새로운 코드는 다양한 소스에서 요청에 의해서 연결될 수 있다.

JDK, JRE

• JDK : Java Development Kit
• JRE : Java Runtime Environment

가장 좌측을 보면 JDK와 JRE로 나뉘어져 있는 것을 볼 수 있다. 즉, JRE는 자바를 실행하기위한 환경의 집합이라고 보면된다. 그리고, JRE에 있는 여러 가지 레고 블럭처럼 칸칸이 쌓여 있는 것들은 자바에서 제공하는 라이브러리들 이라고 보면 된다.

JVM과 GC

일반적으로 자바를 실행할 때 많이 사용되는 용어들은 다음과 같은 것들이 있다.

• JVM : Java Virtual Machine(자바 가상 머신)
• GC : Garbage Collector(가비지 컬렉터)

먼저 JVM에 대해서 간단히 알아보자. JVM은 작성한 자바 프로그램이 수행되는 프로세스를 의미한다. 다시 말해서, Java라는 명령어를 통해서 애플리케이션이 수행되면, JVM 위에서 애플리케이션이 동작한다. 이 JVM에서 작성한 프로그램을 찾고 수행하는 일련의 작업이 진행된다.

자바의 메모리 관리는 개발자가 하지 않아도 된다. 메모리 관리를 JVM이 알아서 하기 때문이다. 이때 JVM 내에서 메모리 관리를 해주는 것을 바로 "가비지 컬렉터"라고 부른다. Garbage는 우리나라말로 "쓰레기"라는 의미이며, 사용하고 남아 있는 전혀 필요 없는 객체들이 여기에 속한다. 아무리 가비지 컬렉터가 쓰레기를 알아서 청소한다고 하더라도, 메모리를 효율적으로 사용하도록 개발하는 것은 매우 중요하다. 예를 들어, 쓰레기를 청소하는 작업이 수행되면 "가비지 컬렉션이 수행되었다"라고 표현한다. 아니면 짧게 "GC가 발생했다"라고 이야기 한다.

어떤 객체를 생성하더라도 그 객체는 언젠가는 쓰레기가 되어 메모리에서 지워져야만 한다. 예를 들어 "abc"라는 문자열이 있는데, 더 이상 사용할 일이 없다면 메모리에서 삭제 되어야만 한다. 만약 지워지지 않으면, 자바 프로그램은 엄청난 메모리가 필요할 것이다. 그래서 C를 사용하여 개발할 때에는 메모리를 해제하는 작업을 꼭 해줘야만 한다. 하지만, 자바는 그런 작업을 해 줄 필요가 없다. 가비지 컬렉터라는 것이 알아서 쓰레기들을 치워주기 때문이다.

Java7부터 공식적으로 사용할 수 있는 G1(Garbage First)라는 가비지 컬렉터를 제외한 나머지 JVM은 다음과 같이 영역을 나누어 힙(Heap)이라는 공간에 객체들을 관리한다.

가장 왼쪽에 있는 Young 영역에는 말 그대로 젊은 객체들이 존재하며, Old 영역에는 늙은 객체들이 자리잡게 된다. 그리고, Perm이라는 영역에는 클래스나 메소드에 대한 정보가 쌓인다.

Young 영역에는 Eden과 두 개의 Survivor 영역으로 나뉘는데, 이 중에서 객체를 생성하자마자 저장되는 장소는 Eden이다. 일반적으로 자바에서 메모리가 살아가는 과정은 다음과 같다.

1. Eden 영역에서 객체가 생성된다.
2. Eden 영역이 꽉 차면 살아있는 객체만 Survivor 영역으로 복사되고, 다시 Eden 영역을 채우게 된다.
3. Survivor 영역이 꽉 차게 되면 다른 Survivor 영역으로 객체가 복사된다. 이 때, Eden 영역에 있는 객체들 중 살아있는 객체들도 다른 Survivor 영역으로 간다. 즉, Survivor 영역의 둘 중 하나는 반드시 비어 있어야만 한다.

지금까지 과정을 마이너(minor) GC 혹은 영(Young) GC라고 부른다. 여기서 GC는 가비지 컬렉터가 아니라 가비지 컬렉션을 말한다.

그러다가, 오래 살아있는 객체들은 Old 영역으로 이동한다. 지속적으로 이동하다가 Old 영역이 꽉 차면 GC가 발생하는데 이것을 메이저(major) GC, 풀(Full) GC라고 부른다.

그렇다면 영 GC와 풀 GC 중 어떤 것이 더 빠를까?

영 GC가 풀 GC보다 빠르다. 왜냐하면 일반적으로 더 작은 공간이 할당되고, 객체들을 처리하는 방식도 다르기 때문이다. 그렇다고, 전체의 힙 영역을 영 영역으로 만들면 장애로 이어질 확률이 매우 높아진다.

오라클 JDK에서 제공하는 GC의 방식은 크게 4가지가 있으며, Java7부터 추가된 G1(Garbage First)를 포함하여 총 5가지의 가비지 컬렉터가 존재한다. 정리하자면 다음과 같다.

• Serial GC
• Parallel Young Generation Collector
• Parallel Old Generation Collector
• Concurrent Mark & Sweep Collector(줄여서 CMS)
• G1(Garbage First)

이중에서 WAS로 사용하는 JVM에서 사용하면 안되는 것은 Serial GC다. 이 GC 방식은 -client 옵션을 지정했을 때 사용된다. 즉, 클라이언트용 장비에 최적화된 GC이기 때문에 만약 WAS에서 이 방식을 사용하면 GC 속도가 매우 느려 웹 애플리케이션이 엄청 느려진다.

참고

• 자바의 신