hello jiniworld

[MySQL] Window Function를 활용한 별도 계산 출력

jiniya22 — Wed, 6 Aug 2025 14:10:59 +0900

1. Window Function?

쿼리의 각 행에 대해 해당 행과 관련된 행을 사용하여 계산을 수행하는 비집계 함수 함수입니다.
각 행에 대해 누적값, 순위, 평균 등을 계산하는데에 활용하는데 집계함수와 달리 결과를 묶지 않고 계산 결과를 유지합니다.
(행을 그대로 유지하면서 계산한다는 차이점이 있습니다.)

일반 집계 함수: group by
- 그룹별로 하나의 결과만 반환
window 함수: over()
- 행을 그대로 유지하면서 별도의 결과를 반환

2. 예제

아래와 같은 데이터가 들어있는 user_contract 테이블에서

user_contract_id,user_id,contract_id
1,sherry,C00437
2,jini,C00437
3,lily,C00542
4,jane,C01113
5,jini,C00001
6,lily,C00100
7,lily,C00005

아래 두 예제를 window함수와 일반 집계함수를 활용하여 출력해봅니다.

기존 row를 그대로 출력하면서 user_id별로 user_contract_id 가 가장 큰것을 조회하기
user_id 로 그룹핑하여 user_contract_id가 가장 큰 것을 조회하기

OVER (PARTITION BY ...) 는 window function 를 활용하면 기존 row를 유지하면서 user_id별 max(user_contract_id)를 함께 출력할 수 있습니다.

select user_contract_id, user_id, contract_id, 
    max(user_contract_id) over (partition by user_id) max_user_contract_id
from user_contract
where user_id in ('jini', 'sherry', 'lily', 'jane')
order by user_id;

partition by user_id: 결과값을 user_id 별로 그룹핑하여
max(user_contract_id) over: 위에서 그룹화된 그룹들 내에서 max(track_contract_id)를 계산합니다.

조회결과는 아래와 같습니다.
원본의 row를 그대로 유지하면서, 최대값을 계산하여 컬럼에 보여줍니다.

user_contract_id,user_id,contract_id,max_user_contract_id
4,jane,C01113,4
5,jini,C00001,5
2,jini,C00437,5
7,lily,C00005,7
6,lily,C00100,7
3,lily,C00542,7
1,sherry,C00437,1

만일 user_id별로 가장큰 user_contract_id를 조회하고 싶음거라면 group by 한 후, max 함수를 적용하면 됩니다.

select user_id, max(user_contract_id) max_user_contract_id
from user_contract
where user_id in ('jini', 'sherry', 'lily', 'jane')
group by user_id;

user_id,max_user_contract_id
jane,4
jini,5
lily,7
sherry,1

[Spring Security] @PreAuthorize에서 활용하고 있는 인증 객체 warning 해소

jiniya22 — Thu, 3 Jul 2025 09:50:30 +0900

인증과 관련된 객체를 커스텀한 AuthUser 객체가 있고,

public record AuthUser(
    Long userId,
    String name,
    Long userGroupId,
    UserType userType)
    implements Serializable {
  
  AuthUser(User user) {
    this(
        user.getUserId(),
        user.getName(),
        user.getRoleGroup() == null ? null : user.getRoleGroup().getRoleGroupId(),
        user.getUserType()
        user.getUsername());
  }

  public boolean isAdmin() {
    return UserType.ADMIN == userType;
  }

  public boolean isBasic() {
    return UserType.BASIC == userType;
  }
}

일반적으로는 이 커스텀 인증 객체를 이용하여 요청을 보낸 authUser에 관한 정보를 읽어들여 서비스 클래스의 메서드에서 활용하고 있습니다.

@PreAuthorize("@cardSecurityService.allowAccess(#authUser)")
@Secured(Roles.Card.READ)
@PutMapping("/{cardId}")
public void updateCard(
        @PathVariable String cardId, @Auth AuthUser authUser) {
    cardService.update(cardId, CardRequestMapper.INSTANCE.toCommand(reques, authUser.userId()));
}

@Service
class cardSecurityService {

  public boolean allowAccess(AuthUser user) {
    return user.isAdmin();
  }

}

위와 같이 코드 블럭 내에서 authUser를 사용하고 있는 경우에는 문제가 없겠지만

만일 아래와 같이 @PreAuthorized에서만 해당 객체를 사용하고, 코드 블럭 내에서는 사용하지 않는다면 IntelliJ에서 Parameter 'authUser' is never used 라는 문구와 함께 회색 글자로 표기됩니다.

@PreAuthorize 에서 해당 객체를 활용하지만, 메서드 내에서는 사용되지 않은 상황이라 IntelliJ는 해당 파라미터가 사용되지 않았다고 판단하고 있습니다.

1. IntelliJ의 warning 억제

아주 단순하게 컨트롤러 메서드에 @SuppressWarnings("unused") 설정하여 IntelliJ에 안쓰는 파라미터에 대한 경고를 표시하지 않도록 하여 이 문제를 해소할 수 있습니다.

@SuppressWarnings("unused")
@PreAuthorize("@cardSecurityService.allowAccess(#authUser)")
@Secured(Roles.Card.READ)
@GetMapping("/{cardId}")
public void updateCard(@PathVariable String cardId, @Auth AuthUser authUser) {
  cardService.select(cardId);
}

그러면 아래와 같이 authUser 파라미터가 회색으로 표기되던 것이 해소된 것을 확인할 수 있습니다.

2. 블럭 내부에서 authUser 사용하기

메서드 블럭안에서 어떤식으로든 authUser를 활용하는 방식으로도 warning을 해소할 수도 있습니다.

@PreAuthorize("@cardSecurityService.allowAccess(#authUser)")
@Secured(Roles.Card.READ)
@GetMapping("/{cardId}")
public void updateCard(@PathVariable String cardId, @Auth AuthUser authUser) {
  if(authUser == null) return;
  cardService.select(cardId);
}

3. @PreAuthorize에서 authentication 활용하기

@PreAuthorize 에서는 Spring Security에서 제공하는 Authentication 객체를 바로 사용할 수 있습니다.

@PreAuthorize("@cardSecurityService.allowAccess(authentication)")
@Secured(Roles.Card.READ)
@GetMapping("/{cardId}")
public void updateCard(@PathVariable String cardId) {
  cardService.select(cardId);
}

Authentication으로 대체하고, allowAccess 메서드에서 authentication 객체로부터 AuthUser를 꺼내서 사용할 수 있습니다.

위에서 소개했던 나머지 2가지 방식보다 더 깔끔한 구조이기에 전체 구조를 깔끔하게 설정하고 싶다면 이와 같은 방식을 권장합니다.

@Service
class CardSecurityService {
  
  public boolean allowAccess(Authentication authentication) {
    if (authentication.getPrincipal() != null
        && authentication.getPrincipal() instanceof AuthUser authUser) {
      return authUser.isAdmin();
    }
    return false;
  }

}

[Spring Data Commons] 2.1. Spring Data Repository

jiniya22 — Tue, 17 Dec 2024 11:10:08 +0900

핵심 개념
1. 확장 인터페이스
2. 기타 파생 쿼리
메서드 질의하기
Repository Interface 정의하기

1. 핵심 개념

Spring Data Repository 추상화의 목표는 다양한 퍼시스턴스 저장소의 데이터 접근 계층을 구현하는데에 필요한 보엘러플레이트 코드를 줄이는 것입니다.

Spring Data Repository 추상화의 중심 인터페이스는 Repository 입니다.
이것은 도메인 클래스를 관리하면서 도메인클래스의 식별자를 유형인수로써 사용합니다.

Spring Data에서는 도메인 타입을 Entity 라고 부릅니다. (= 또는 Aggregate 라고도 부릅니다.)

각 도메인 객체는 식별자(ID) 가 있고, 데이터를 액세스할때에 이 값을 활용합니다.

Spring Data Commons에서 제공하는 Repository의 확장 인터페이스로는 CrudRepository, ListCrudRepository, PagingAndSortingRepository, ListPagingAndSortingRepository 가 있습니다.

이 확장 인터페이스를 실질적으로 사용하고자하는 저장소 모듈(JPA, mongoDB 등...)에서 지원되는지 사전에 확인한 후, 지원되면 사용하면 됩니다.

1.1. 확장 인터페이스

CrudRepository와 ListCrudRepository는 Repository인터페이스의 상속 인터페이스로, 엔티티 클래스에 대한 정교한 CURD 기능을 제공해줍니다.
ListCrudRepository는 CrudRepository에서 Iterable 객체로 반환하는 값을 List형태로 반환하는 것만 차이가 있습니다.

@NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {
    <S extends T> S save(S entity);

    <S extends T> Iterable<S> saveAll(Iterable<S> entities);

    Optional<T> findById(ID id);

    boolean existsById(ID id);

    Iterable<T> findAll();

    Iterable<T> findAllById(Iterable<ID> ids);

    long count();

    void deleteById(ID id);

    void delete(T entity);

    void deleteAllById(Iterable<? extends ID> ids);

    void deleteAll(Iterable<? extends T> entities);

    void deleteAll();
}

@NoRepositoryBean
public interface ListCrudRepository<T, ID> extends CrudRepository<T, ID> {
    <S extends T> List<S> saveAll(Iterable<S> entities);

    List<T> findAll();

    List<T> findAllById(Iterable<ID> ids);
}

Repository는 기본적으로 프로퍼티명을 기반한 Query Methods 를 제공하지만, PK의 경우 PK로 지정한 프로퍼티명과 무관하게 Id라는 명칭으로 쿼리메서드를 제공합니다. (ex. findById)

Reseved Methods Names 참고

프로퍼티명에 기반한 Query Methods 를 사용하는 것 외에 직접 쿼리를 사용하고 싶다면 @Query 애너테이션을 사용하여 사용자 지정 쿼리를 사용할 수 있습니다.

엔티티에 대한 페이징된 액세스를 편리하게 해주는 메서드를 포함한 PagingAndSortingRepository 도 있습니다.

목록을 Iterable 객체가 아닌 List객체로 반환하는 ListPagingAndSortingRepository 확장 인터페이스가 있습니다.

@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends Repository<T, ID> {
    Iterable<T> findAll(Sort sort);

    Page<T> findAll(Pageable pageable);
}

1.2. 기타 파생 쿼리

엔티티를 조회하는 것 외에도 count나 존재여부를 조회하는 파생쿼리도 사용할 수 있고,

interface UserRepository extends CrudRepository<User, Long> {

  long countByLastname(String lastname);
  boolean existsByLastname(String lastname);
}

삭제 쿼리도 아래와 같이 사용할 수 있습니다.

interface UserRepository extends CrudRepository<User, Long> {

  long deleteByLastname(String lastname);

  List<User> removeByLastname(String lastname);
}

2. 메서드 질의하기

Spring Data를 사용하여 애플리케이션에서 사용하고자하는 저장소에 대한 쿼리를 선언하고 사용하는 방법은 4가지 단계를 거칩니다.

Repository 또는 Repository 의 하위 인터페이스를 상속한 인터페이스를 선언하고 대상이되는 도메인클래스와 그 도메인 클래스의 PK타입을 설정
그 인터페이스 내에 사용하고자하는 쿼리 메서드를 선언
JavaConfig (또는 XML config)에 Repository 가 위치한 패키지를 지정
서비스 클래스에서 해당 Repository를 주입하여 사용

2.1. Repository 인터페이스 정의

Repository 또는 Repository의 하위 인터페이스를 상속하는 인터페이스를 정의합니다.

PK 타입이 Long인 User 라는 엔티티 도메인이 있다고 할 때,
이 도메인 엔티티를 처리할 Repository 인터페이스를 정의해봅시다.

@Getter
@ToString
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = jakarta.persistence.GenerationType.IDENTITY)
    private final Long id;
    private String username;
    private String email;

    protected User() {
        this.id = null;
    }

    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    User withId(Long id) {
        return new User(id, this.username, this.email);
    }
}

CrudRepository에 처리하고자하는 도메인 엔티티 타입과 그 도메인의 PK인 Long 타입을 설정합니다.

package me.jiniworld.sdc.store.jpa.user;

interface UserRepository extends CrudRepository<User, Long> {
}

2.2. 쿼리 메서드 선언

생성한 Repository 인터페이스 내에 쿼리 메서드를 선언합니다.

아래 코드는 Spring Data Commons에서 기본적으로 제공해주는 CrudRepository를 사용한 예제 코드입니다.

사용하고자하는 저장소와 프레임워크에 따라 ReactiveCrudRepository, CoroutineCrudRepository 등 다양한 Repository를 활용할 수 있습니다.

package me.jiniworld.sdc.store.jpa.user;

import org.springframework.data.repository.CrudRepository;

interface UserRepository extends CrudRepository<User, Long> {
    boolean existsByEmail(String email);
}

2.3. Java 구성파일 설정

사용하고자하는 Spring Data store 타입이 단 하나일 경우에는 구성파일 설정을 생략해도 기능이 동작하지만,
JPA, MongoDB 등 여러개의 Spring Data 프로젝트를 하나의 애플리케이션 내에 정의하는 경우에는 반드시 config 설정을 추가해야 합니다.

아래 예시는 JPA를 사용하고 있는 코드에 대한 예제입니다.
JPA를 활용한 Repository 가 위치할 패키지를 정의하여, 설정한 패키지 내에 위치한 인터페이스에 대해서 Proxy 객체를 생성하도록 합니다.

@EnableJpaRepositories(basePackages = {"me.jiniworld.sdc.store.jpa"})
@Configuration
public class JpaConfig {
}

2.4. Repository 주입

위에서 작성했던 Repository 의 객체를 주입합니다.

UserRepository에 @Component 나 @Repository 와 같은 애너테이션을 설정하지 않아도 @EnableJpaRepositories로 인터페이스를 모두 등록했기에 객체를 주입할 수 있습니다.

@Transactional(readOnly = true)
@RequiredArgsConstructor
@Service
class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

    @Override
    public User findById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new RuntimeException("User not found"));
    }

    @Override
    @Transactional
    public User save(User user) {
        return userRepository.save(user);
    }
}

3. Repository Interface 정의하기

CrudRepository나 JpaRepository 코드를 살펴보면 @NoRepositoryBean 라는 애너테이션이 붙은 것을 확인할 수 있습니다.

@NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {
  ...
}

Repository 를 확장한 다른 인터페이스에도 @NoRepositoryBean 애너테이션이 설정된것을 확인할 수 있는데, 이 애너테이션은 특정 도메인 엔티티와 연결된 것이 아닌 공통 쿼리메서드를 정의할 인터페이스를 선언하는 애너테이션 입니다.

참고로 @NoRepositoryBean 애너테이션을 설정할 경우, Spring Data가 런타임 중에 해당 인스턴스를 생성하지 않게 해줍니다.

만약 여러 도메인 엔티티에서 공통적으로 활용될 쿼리 메서드들이 있다면 커스텀 베이스 Repoistory를 선언하는 것도 좋습니다.

@NoRepositoryBean
interface MyBaseRepository<T, ID> extends Repository<T, ID> {

  Optional<T> findById(ID id);

  <S extends T> S save(S entity);
}

interface UserRepository extends MyBaseRepository<User, Long> {
  User findByEmail(String email);
}

++

Working with Spring Data Repositories
Defining Repository Interfaces

[Spring Data Commons] 1. 개요

jiniya22 — Mon, 16 Dec 2024 14:48:07 +0900

Spring Data Commons 프로젝트는 다양한 관계형 & 비관계형 데이터 저장소에 사용되는 솔루션 개발의 핵심 Spring 개념을 제공합니다.

1. Dependencies

각각의 Spring Data 모듈들의 시작일이 모두 다르기 때문에 대부분 major, minor 버전이 다릅니다.

호환되는 버전을 찾는 가장 쉬운 방법은 Spring Data Release Train을 사용하는 것입니다.

Spring Data Release Train내에는 각 모듈이 통합적으로 호환되기 위한 버전이 정의되어있습니다.

1.1. Spring Data release train BOM

릴리즈 트레인 버전은 calver 패턴 양식인 YYYY.MINOR.MICRO 을 따르며, 현재 날짜 기준으로 2024.1.0 입니다.

※ spring-data-commons의 Release Notes 참고

GA 릴리즈, 서비스 릴리즈는 ${calver} 포맷으로 버전이 정의되고
그 외의 릴리즈들의 경우 suffix로 아래와 같은 modifier를 붙여 ${calver}-${modifier} 포맷을 사용합니다.

SNAPSHOT: 현재스냅샷
M1, M2, ...: 마일스톤
RC1, RC2, ...: 릴리즈 후보

Spring Data examples repository에서 예제코드를 찾아볼 수 있습니다.

현 문서에서 설명하고 있는 Spring Data Common 모듈의 버전은 Spring Framework 6.2.0 이상을 요구합니다.

1.1.1. maven

<properties>
  <spring-data-bom.version>2024.1.0</spring-data-bom.version>
</properties>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-bom</artifactId>
      <version>${spring-data-bom.version}</version>
      <scope>import</scope>
      <type>pom</type>
    </dependency>
  </dependencies>
</dependencyManagement>

1.1.2. gradle

ext {
	springDataBomVersion = '2024.1.0'
}

dependencyManagement {
	imports {
		mavenBom "org.springframework.data:spring-data-bom:${springDataBomVersion}"
	}
}

1.2. Spring Boot 종속성 관리

Spring Boot는 최신버전의 Spring Data 모듈을 선택해 줍니다.
만약 새버전으로 업그레이드 하기를 원한다면, spring-data-bom.version 버전을 최신화하면 됩니다.

Spring Docs의 Version Properties 문서를 보면, Spring Boot에 의해 관리되고 있는 라이브러리들의 버전을 override하기위한 버전과 관련된 프로퍼티명을 제공하고 있습니다.
관련 사항이이 궁금하다면 해당 문서를 참고하면 됩니다.

2. Spring Data 업그레이드

Spring Data 버전을 업그레이드하기 위한 방법은 프로젝트의 Wiki 페이지를 참고하면 됩니다.

Wiki의 릴리즈 노트에는 각 버전별로 업그레이드를 위한 지침을 포함하고 있습니다.
만일 릴리즈 노트 업데이트가 여러개가 있다면 과거 릴리즈 노트도 검토한 후 업그레이드 하는 것이 좋습니다.

3. Object Mapping

Spring Data 객체 매핑/생성 과 각 필드 및 프로퍼티에 접근하는 것, 그리고 가변성/불변성에 대한 기본사항을 알아봅시다.

이 포스팅에서는 JPA와 같은 데이터 저장소의 객체 매핑을 사용하지 않는 Spring Data 모듈에 대해 설명합니다.

Spring Data 객체 매핑의 핵심 책임은 도메인 객체의 인스턴스를 생성하고, store-native 데이터 구조를 그 인스턴스에 매핑하는 것으로, 아래 2가지 기본 단계를 필요로 합니다.

노출 되어있는 생성자를 이용한 객체 생성
노출된 모든 프로퍼티를 구체화하기 위한 객체 요소

3.1. 객체 생성

Spring Data는 해당 타입의 객체를 구체화하기 위해 사용할 퍼시스턴스 엔티티의 생성자를 감지하기 위해 시도하며, 아래와 같은 조건에 의해 객체를 생성합니다.

만일 @PersistenceCreator 애너테이션이 설정된 단일 정적 팩토리 메서드가 존재할 경우, 그것을 사용함
생성자가 단 하나일 경우, 그것을 사용함
여러개의 생성자가 있으나 @PersistenceCreator 애너테이션이 설정된 생성자가 단 하나일 경우, 그것을 사용함
record class 타입일 경우, 그것을 사용함
NoArgsConstructor(인수 없는 생성자)가 존재할 경우, (다른 생성자는 모두 무시하고) 그것을 사용함

값은 기본적으로 엔티티의 프로퍼티명과 생성자(또는 팩토리 메서드) 인수 이름이 동일하다고 가정하여 해당 속성들을 채워져서 표현됩니다.

생성자(또는 팩토리 메서드)에 설정된 인수값과 엔티티의 프로퍼티명을 달리하면서 값을 표현하고 싶다면 @ConstructorProperties 에 설정하면 되고,
@Value 애너테이션으로 SpEL 표현식을 사용하여 사용자 정의 방식으로 값을 표현할 수도 있습니다.

객체 생성 시 최적화

Spring Data 객체 생성은 reflection 오버헤드를 방지하기 위해 기본적으로 런타임시 생성된 팩토리 클래스를 사용하여 객체 생성을 최적화 합니다.

팩토리 클래스는 도메인 클래스 생성자를 직접 호출합니다.

예를들어, 아래와 같은 클래스가 있다고 할때

class Person {
  Person(String firstname, String lastname) { … }
}

런타임 중에 아래와 같은 팩토리 클래스를 생성하여 사용합니다.

class PersonObjectInstantiator implements ObjectInstantiator {

  Object newInstance(Object... args) {
    return new Person((String) args[0], (String) args[1]);
  }
}

팩토리 생성자를 런타임시 생성하여 활용하는 경우, reflection을 이용하는 것보다 10%의 성능 향상이 제공됩니다.

단, 아래의 조건을 충족하는 경우에만 내부적으로 팩토리 메서드를 생성하니, 관련 제약조건에 유의해야 합니다.
(만일, 아래의 제약조건을 만족하지 않을 경우에는 reflection을 이용하여 엔티티를 객체화 합니다.)

private class 가 아니어야 합니다.
non-static inner class 가 아니여야 합니다.
CGLib 프록시 class가 아니어야 합니다.
Spring Data에서 사용할 생성자는 private이면 안됩니다.

3.2. 프로퍼티(속성) 채우기

엔티티 객체가 생성될 때, Spring Data는 클래스의 나머지 모든 영구(persistent) 속성들을 채웁니다.
만일 엔티티의 생성자에 의해 채워지지 않는 경우에는 식별자 속성은 순환 객체 참조를 해결할 수 있도록 먼저 채워집니다.
그 다음 비일시적(non-transient) 속성들이 엔티티 객체에 설정됩니다.

속성을 채우는 과정은 아래의 단계를 따릅니다.

immutable property(변경할수 없는 속성)이면서 공개되어있는 with... 메서드가 있는 경우, with... 메서드를 사용하여 새 속성값을 새 엔티티 인스턴스를 만듭니다.
setter를 이용한 속성 접근이 정의되어있는 경우 setter를 호출합니다.
변경가능한 속성일 경우 직접 설정
속성의 변경이 불가한 경우, 영속적 연산에 사용되는 생성자를 사용하여 객체의 복제본을 생성합니다. (3.1. 객체 생성 참고)
기본적으로 값은 직접 설정 합니다.

내부

객체 생성 최적화와 유사하게, 속성 체우기에서도 Spring Data 런타임시 생성된 접근자 클래스를 사용하여 엔티티 객체와 상호작용을 합니다.

class Person {

  private final Long id;
  private String firstname;
  private @AccessType(Type.PROPERTY) String lastname;

  Person() {
    this.id = null;
  }

  Person(Long id, String firstname, String lastname) {
    // Field assignments
  }

  Person withId(Long id) {
    return new Person(id, this.firstname, this.lastame);
  }

  void setLastname(String lastname) {
    this.lastname = lastname;
  }
}

class PersonPropertyAccessor implements PersistentPropertyAccessor {

  private static final MethodHandle firstname;              

  private Person person;                                    

  public void setProperty(PersistentProperty property, Object value) {

    String name = property.getName();

    if ("firstname".equals(name)) {
      firstname.invoke(person, (String) value);             
    } else if ("id".equals(name)) {
      this.person = person.withId((Long) value);            
    } else if ("lastname".equals(name)) {
      this.person.setLastname((String) value);              
    }
  }
}

PropertyAccessor는 (객체의 변경할 수 없는 속성의 변형을 가능하게 하기 위해) 객체의 변경가능한 인스턴스를 보유합니다.

기본적으로 FieldAccess 방식으로 프로퍼티 값을 읽고 쓰며, (= 리플렉션 활용)
명시적으로 @AccessType(Type.PROPETY) 와 같이 접근방식을 설정할 경우 PropertyAccess방식으로 메서드를 호출할 수 있습니다.(= setter)

setter나 with... 메서드를 이용한 방식은 리플렉션을 이용한 프로퍼티 설정보다 25% 의 성능향상이 있습니다.

~~++ 작동되는 예제 추후 보강될 예정...~~

~~3.3. 예시~~

person:
  id: 123
  first-name: jini
  last-name: yoo

@Getter
@ToString
@ConfigurationProperties(prefix = "person")
public class Person {
    private final Long id;
    private final String firstName;
    private final String lastName;

    public Person(Long id, String firstName, String lastName) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
    }

}

[Spring Boot Core] 2.2. Externalized Configuration

jiniya22 — Mon, 9 Dec 2024 16:48:18 +0900

spring.config.name
spring.config.location
optional location
wildcard location
profile별 구성 파일
1. 특정 프로파일 활성화
2. Last wins 전략
추가 데이터 import
1. Profipe-specific varinants 가져오기
2. 확장자 없는 파일 가져오기
configtree
property placeholders
다중 문서 파일 작업
활성화 프로퍼티

Spring Boot 는 애플리케이션이 시작될 때, application.properties 와 application.yml 파일을 아래의 경로로부터 자동으로 찾아서 로드합니다.

classpath로 부터 찾기
1. classpath의 root
2. classpath 하위의 /config 패키지
현재 디렉토리에서 찾기
1. 현재 디렉토리
2. 현재 디렉토리의 ./config/ 디렉토리
3. ./config 디렉토리의 직계 하위 디렉토리

1. `spring.config.name`

기본적으로 application이라는 config 파일명을 로드하지만 (예: application.yml)
만일 config 파일명을 변경하고 싶다면, spring.config.name 환경 프로퍼티로 관련 설정을 추가할 수 있습니다.

예를들어 demo.jar 애플리케이션을 싫행하는데, demo.yml 또는 demo.properties 구성파일을 읽고 싶다면, 아래와 같이 애플리케이션을 실행하면 됩니다.

java -jar demo.jar --spring.config.name=demo

2. `spring.config.location`

하나 이상의 구성 파일을 로드하고 싶다면, spring.config.location 속성을 사용하면됩니다.
쉼표를 통해 여러개를 참조할 수도 있으며, 파일명 또는 디렉토리 위치를 직접적으로 설정하는 방법입니다.

나중에 읽어들인 구성파일은 이전에 불려진 구성파일을 override 합니다.

나중에 읽어들인 구성파일을 우선한다

java -jar demo.jar --spring.config.location=\
  optional:classpath:/default.yml,\
  optional:classpath:/override.yml

spring.config.name, spring.config.location, spring.config.additional-location 구성설정은 어떤 구성 파일을 읽을 건지를 판단하는 설정으로 애플리케이션 구동 중에 매우 일찍 읽어들이는 속성으로,
환경변수(OS 환경변수, 시스템 속성, command line 인수)로 정의해야 정상적으로 작동됩니다.

디렉토리와 파일의 위치값은 profile 별로 체크하여 확장할 수 있습니다.
spring.config.location=classpath:demo.yml 로 설정되어있을 때, profile 설정에 따라 특정 구성설정을 읽어들일 수 있습니다. (classpath:demo-.yml)

예를들어, profile이 dev 인 경우라면 classpath:demo-dev.yml 을 찾아서 읽는 것입니다.

spring.config.location에 아래와 같이 위치를 설정할 경우, 아래와 같은 순서로 구성파일을 읽어들입니다.

optional:classpath:/custom-config/
optional:file:./custom-config/

--spring.config.location=optional:classpath:/custom-config/,optional:file:./custom-config/

additional-location 에 설정할 경우, 기본 설정값을 읽어들인 후 추가적인 구성파일 설정을 override 하여 구성파일을 읽어들입니다.

optional:classpath:/;optional:classpath:/config/
optional:classpath:file:./;optional:classpath:file:./config/;optional:classpath:file:./config/*/;
optional:classpath:/custom-config/
optional:file:./custom-config/

--spring.config.additional-location=optional:classpath:/custom-config/,optional:file:./custom-config/

3. optional location

3.1. `optional:`

기본적으로 설정한 위치에 구성파일이 없을 경우 ConfigDataLocationNotFoundException를 발생시키면서 애플리케이션이 시작되지 않습니다.
만일, 특정 구성파일을 읽어들이는 것이 필수가 아니라면 optional: 을 붙여주면 됩니다.

위에서 예시에서 봤던것 처럼 spring.config.location 설정에도 사용할 수 있고, (ex. --spring.config.location=optional:classpath:/demo.yml)
spring.config.import 에도 설정할 수 있습니다.

3.2. on-not-found

만일 애플리케이션 시작중 config 파일 위치 찾기에 대한 오류(ConfigDataLocationNotFoundExceptions)를 모두 무시하고, 구성 파일가 없더라도 무조건 애플리케이션을 실행시키고 싶다면 시스템/환경 변수로 spring.config.on-not-found 프로퍼티 값을 ignore 로 설정하면 됩니다.

@SpringBootApplication
public class SpringBootApp {

	public static void main(String[] args) {
		SpringApplication app = new SpringApplication(SpringBootApp.class);
		app.setDefaultProperties(Map.of("spring.config.on-not-found", "ignore"));
		app.run(args);
	}

}

4. wildcard location

config/*/ 와 같이 location 끝에 *를 포함할 경우, 구성이 로드 될때 하위 디렉터리 까지 확장하여 검색합니다.
(구성 속성이 여러개인 k8s 환경에 유용합니다.)

예를들어 redis와 mysql 구성이 있는 경우, 구성을 그대로 유지하면서 각각 별도 파일로 구성하고 싶다면 config/*/ 로 설정해두면 아래와 같은 위치에 존재하는 구성 파일들을 모두 찾아 로드할 수 있습니다.

/config/redis/application.yml
/config/mysql/application.yml

config/*/ 는 Spring Boot에서 포함하고 있는 기본 검색 위치이기 때문여, 기본적으로 내 jar 프로젝트의 외부 config 디렉토리의 하위 디렉토리를 모두 검색합니다.

물론 탐색하고 싶은 위치를 변경하고 싶다면 spring.config.location 이나 spring.config.additional-location
에 * 를 포함하여 변경할 수 있습니다.

Note

wildcare location은 *를 단하나만 포함시켜야 하고, 와일드카드를 포함하여 찾고자하는 디렉토리 위치를 설정하고자한다면 */로 끝내야 하고, 와일드카드 디렉토리 하위의 특정 파일명을 지정하고 싶다면 */<filename> 같은 형식으로 정의해야 합니다.
와일드카드가 있는 위치 파일 이름은 알파벳 오름차순 순으로 정렬되어 로드됩니다.

wildcard location은 외부 디렉토리에서만 작동 합니다. classpath: 위치에는 와일드카드를 사용할 수 없습니다.

5. profile별 구성 파일

5.1. 특정 프로파일 활성화

-Dspring.profiles.active=dev 와 같은 방식으로 활성화할 프로파일을 정의하면, 1순위로 application.yml 파일을 로드하고 그 후에 application-dev.yml 구성파일을 로드합니다.

나중에 로드된 application-dev.yml 구성파일이 이전에 읽은 구성 값을 override 합니다.

구성파일

spring:
  application:
    name: spring-boot

custom:
  name: jini
  group: jiniworld

application.yml

spring:
  application:
    name: spring-boot-dev

custom:
  name: jini-dev

application-dev.yml

애플리케이션 실행

활성화할 프로파일을 지정하여 애플리케이션 실행합니다.

java -jar demo.jar -Dspring.profiles.active=dev

결과

나중에 불려지는 application-dev.yml 에 설정한 값이 최종적으로 덮어써지기 때문에, spring.application.name 값은 spring-boot-dev가 됩니다.
(이는, 애플리케이션 실행시 로그 내에서 확인할 수 있습니다.)

2024-11-15T16:44:43.572+09:00 DEBUG 14254 --- [spring-boot-dev] [  restartedMain] o.s.boot.SpringApplication               : Loading source class me.jiniworld.springboot.SpringBootApp

spring.application.name 과 마찬가지로 custom.name 값은 application-dev.yml 에서 override 된 "jini-dev"가 설정되고, dev profile에는 정의하지 않은 custom.group 값은 기본 application.yml 에 정의한 jiniworld 가 출력되는 것을 확인할 수 있습니다.

5.2. Last wins 전략

만일, spring.profiles.active 값에 "prod,live" 와 같이 여러개를 설정할 경우
동일한 프로퍼티 값에 대해 가장 나중에 호출된 application-live.yml 파일에 설정한 값으로 override 합니다.

여러개의 profile이 지정된 경우, 마지막에 설정한 전략이 override 되는 Last wins 전략이 적용됩니다.

Last wins 전략은 위치 그룹 수준에서 적용되는데,

spring.config.active=prod,live 인 상황에서 아래와 같은 구조로 구성파일이 있다고 할때,

/cfg
  application-live.yml
/ext
  application-live.yml
  application-prod.yml

spring.config.location=classpath:/cfg/,classpath:/ext/ 와
spring.config.location=classpath:/cfg/;classpath:/ext/ 는 override 규칙이 다릅니다.

5.2.1. classpath:/cfg/,classpath:/ext/

location을 쉼표로 구분하는 것은 (활성화할 profile 순서를 정의한것 처럼) 각 location 디렉토리별로 순서를 지정하는 것과 같습니다.

따라서, cfg 디렉토리 하위에 있는 파일들이 가장 우선순위가 높고 그다음에 ext 디렉토리 하위의 파일을 로드합니다.

/cfg/application-live.yml
/ext/application-prod.yml
/ext/application-live.yml

5.2.1. classpath:/cfg/;classpath:/ext/

location을 세미콜론로 구분하는 것은 각 location 디렉토리를 동일한 수준으로 간주하는 것과 같습니다.
다만, 만일 두 디렉토리 내에 동일한 프로파일이 존재한다면 먼저 위치한 디렉토리를 먼저 로드합니다.

/ext/application-prod.yml
/cfg/application-live.yml
/ext/application-live.yml

Note

만일 활성화할 프로파일을 명시적으로 지정해주지 않는다면 기본적으로 default 프로파일을 설정합니다.
즉, 프로파일 미지정시에는 application-default 구성파일 내에 정의된 프로파일들을 로드합니다.

아래는 활성화할 프로파일 미지정시 출력되는 로그화면의 일부입니다.

2024-12-04T14:05:35.451+09:00  INFO 32545 --- [spring-boot] [  restartedMain] me.jiniworld.springboot.SpringBootApp    : No active profile set, falling back to 1 default profile: "default"

6. 추가 데이터 import

애플리케이션 프로퍼티는 spring.config.import 프로퍼티를 이용하여 다른 위치로부터 config data를 가져올 수 있습니다.

아래와 같이 classpath 하위에 있는 파일을 추가로 가져올 수도 있고,

spring:
  config:
    import: optional:classpath:/demo.yml

프로퍼티 파일이 위치한 동일한 디렉토리에 있는 파일을 가져오는 것도 가능합니다.

spring:
  config:
    import: optional:./demo.yml

spring.config.import를 이용하여 가져온 값들을 가장 우선하며, 구성파일 내에서의 spring.config.import 프로퍼티의 위치와는 무관합니다.
(= import를 정의한 구성 파일의 맨 마지막에 작성하든 맨 위에 작성하든 프로퍼티 위치와는 무관하게 무조건 import한 파일을 맨 마지막으로 override 한다.)

즉, 아래 두 구성파일은 모두 동일하게 작동되며, demo.yml 에 작성된 것으로 덮어써집니다.

spring:
  config:
    import: "demo.yml"

custom:
  name: hello

custom:
  name: hello

spring:
  config:
    import: "demo.yml"

spring.config.import 에는 여러개의 위치를 포함시킬 수 있으며, 마찬가지로 맨 마지막에 정의한 위치를 우선합니다.
spring.config.import 프로퍼티 설정은 구성파일 내에 단 한번만 import 합니다. (여러개 선언하더라도)

6.1. Profipe-specific varinants 가져오기

또, application*.yml 이외에 변형된 profile 도 가져오는게 가능합니다.

예를들어, 아래와 같이 demo 라는 이름의 구성파일을 가져온다고 설정이 되어있으면서, qa 프로파일이 활성화 되어있을 경우에는 (= -Dspring.profiles.active=qa)

spring:
  config:
    import:
      - demo.yml

application.yml → application-qa.yml → demo.yml → demo-qa.yml 순으로 덮어써집니다. (demo-qa.yml 구성파일이 가장 높은 우선순위)

6.2. 확장자 없는 파일 가져오기

Spring Boot에는 다양한 위치주소를 지원하는 플러그형 API를 포함하고 있기 때문에, 기본적으로 java 클래스를 이용한 프로퍼티 속성과 YAML, 구성 트리를 통한 import가 가능합니다.
(Consul, Apache Zookeeper, Netflix Archaius 등과 같은 외부 저장소로부터 구성 데이터 로드)

일부 클라우드 플랫폼은 볼륨 마운트된 파일에 파일 확장자를 추가할 수 없습니다.
이러한 경우에 대한 구성파일 로드를 가능하게 하기 위해 Spring Boot는 확장자 hint를 제공합니다.

확장자 hint는 대괄호를 묶어서 실행하는데, 아래와 같이 작성하면 파일명에 확장자가 없어도 로드가 가능합니다.

spring:
  config:
    import:
      - "file:/etc/config/demo[.yml]"

7. configtree

Kubernetes 와 같은 클라우드 플랫폼에서 애플리케이션을 실행할 때, 플랫폼에서 제공하는 구성값을 읽어야하는 경우가 있습니다.
플랫폼에서 제공하는 구성값을 읽기 위하여 환경변수를 사용하는 것은 드문일은 아니지만, 값을 비밀로 해야하는 경우에는 보안상 취약하다는 단점이 있습니다.

그러한 이유로, 환경변수 대안으로 많은 클라우드 플랫폼에서 마운트된 데이터 볼륨에 구성을 매핑할 수 있습니다.

Kubernetes를 예로 들자면 ConfigMaps 와 Secrets 둘다 볼륨 마운트 할 수 있습니다.

일반적인 볼륨 마운트 패턴

단일파일에는 전체 프로퍼티 세트를 포함하고 있다.
여러개의 파일은 파일이름은 'key'가 되고 내용은 'value'가 되어 디렉토리 트리에 기록됩니다.

K8s 가 아래와 같은 볼륨을 마운트했다고 해봅시다.
이 중, username은 config 값이고, password 값은 비밀입니다.

etc/
  config/
    myapp/
      username
      password

이 값을 읽기 위해서, 프로퍼티에 아래와 같이 설정할 수 있습니다.

spring:
  config:
    import: "optional:configtree:/etc/config/"

구성트리의 값은 예상되는 컨텐츠 내용에 따라 String 과 byte[] 유형 모두에 바인딩될 수 있습니다.

여러 구성트리 가져오기

아래와 같은 볼륨이 주어졌을 때에는,

etc/
  config/
    db/
      username
      password
    db/
      username
      password

아래와 같이 * 를 사용하면 여러개의 구성 트리를 가져올 수 있습니다.

spring:
  config:
    import: "optional:configtree:/etc/config/*/"

Note

다만, 여러구성트리를 import 할 경우, 알파벳 순으로 정렬하여 로드합니다.
만약 로드 순서를 직접 정의하고 싶다면 각 위치별로 별도로 import하여 가져와야합니다.

8. property placeholders

구성파일 내에서 "${}" 내에 property-placeholder 문법을 이용하면 기존에 정의한 프로퍼티나 시스템 속성, 환경변수를 참조할 수 있습니다.

${속성키:기본값} 과 같이 속성키가 없을 경우 할당할 기본값도 정의할 수 있습니다.

이때, 참조할 값은 소문자로 구성된 Kebab case 로 사용하는 표준 형식을 따라야 합니다.
이를 따를 때, Spring Boot는 기존 Relaxed Binding @ConfigurationProperties 를 사용할 때와 동일한 로직을 사용할 수 있습니다.

참고: [Spring Boot Core] Spring Boot Relaxed Binding using yaml

활용 방안: property placeholders를 활용한 명령어 인자 간소화

만일, 특정 애플리케이션을 실행할 때, 아래와 같이 포트를 지정한다고 할때,

java -jar demo.jar -Dserver.port=18080

property placeholders 를 활용하여 아래와 같이 정의해두면,

server:
  port: "${port:8080}"

아래와 같이 매우 간단하게 command line 인자를 사용할 수 있습니다.

java -jar demo.jar --port=18080

9. 다중 문서 파일 작업

하나로 구성된 구성파일을 여러 논리적 문서로 분할할 수 있습니다.

YAML 구성파일의 경우, 각 논리적 문서 구분을 --- 로 합니다.

.properties 파일의 경우에는 #--- 또는 !--- 로 합니다.

예를들어 아래와 같이 구성된 구성파일이 있다고 할때,

맨 위의 논리적 문서는 공통 속성이고,
활성화된 프로파일에 따라 특정 속성값을 재정의할 수 있습니다.

상세한 섦명은 활성화 프로퍼티 를 참고해주세요.

spring:
  datasource:
    hikari:
      connection-test-query: SELECT 1
      maximum-pool-size: 30
      auto-commit: false

management:
  endpoint:
    env:
      show-values: always
  endpoints:
    web:
      exposure:
        include: env

logging:
  level:
    root: info
    web: debug
    org.springframework:
      boot.autoconfigure: info
      web: debug

---

spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://상용서버:3306/jiniworld
    hikari:
      pool-name: pool-prod
      username: jini
      password: jiniProd

---

spring:
  config:
    activate:
      on-profile: local
  datasource:
    url: jdbc:mysql://localhost:3306/jiniworld
    hikari:
      pool-name: pool-local
      username: jini
      password: jiniLocal

Note

구성 파일 구분 기호 --- 앞에는 공백이 없어야합니다.

10. 활성화 프로퍼티

spring.config.activate 속성을 이용하여 조건부로 특정 프로퍼티 파일을 확성할 수 있습니다.

java -jar demo.jar -Dspring.config.activate=prod

위에서 소개했듯, 맨 첫번째 문단은 맨 처음으로 구성되는 공통 설정이고,
spring.config.activate.on-profile은 활성화되기 위해 일치해야할 profile 표현식을 정의합니다.

spring.config.activate.on-cloud-profile 라는 속성도 있는데, 이는 활성화되기 위해 탐지되어야하는 CloudPlatform을 정의합니다.
ex. spring.config.activate.on-cloud-profile=kubernetes

myprop:
  "always-set"
---
spring:
  config:
    activate:
      on-cloud-platform: "kubernetes"
      on-profile: "prod | staging"
myotherprop: "sometimes-set"

++

외부 애플리케이션 프로퍼티
~~file:./application-demo.yml 적용 안됨. 추후 알아볼 것.~~
configtree에 대해서도 직접적인 사용예제로 테스트해볼 것

[Spring Boot Core] 2.1. Externalized Configuration 개요와 JSON Application Properties 설정하기

jiniya22 — Sun, 3 Nov 2024 17:11:57 +0900

구성설정 외부화 개요
1. 예제
command line 프로퍼티 액세스
JSON Application properties

1. 구성설정 외부화 개요

Spring Boot 를 이용하면, configuration을 외부화하여 여러 환경에서 동일한 코드를 활용하여 애플리케이션을 실행시킬 수 있습니다.

Java Config 파일, YAML 파일, 환경변수 및 명령어 인수 등을 통해 다양한 외부 구성 소스를 활용할 수 있습니다.

Spring 에서는 아래 3가지 방식으로 값을 주입합니다.

@Value 애너테이션을 이용하여 Bean에 직접 주입
Spring 의 환경 추상화를 통한 접근
@ConfigurationProperties 로 객체에 바인딩하여 활용

Spring Boot는 값을 합리적으로 재정의할 수 있도록 설계되어있는 PropertySource 순서를 사용합니다.
Spring Boot에서는 여러방식으로 환경변수를 주입할 수 있는데, 이 후에 불려진 소스는 환경변수를 오버라이딩합니다.

프로퍼티는 다음과 같은 순서로 읽습니다.

기본 프로퍼티
- SpringApplication.setDefaultProperties 메서드로 프로퍼티를 변경할 수 있습니다.
@Configuration 클래스에 설정하는 @PropertySource 애너테이션
- 이 프로퍼티 소스는 애플리케이션 컨텍스트를 새로 고칠 때 환경에 추가되는 값입니다.
- 따라서, logging.* 이나 spring.main.* 같은 속성은 여기에 설정하면 동작되지 않습니다.
구성 데이터
- application.yml 나 application.properties 와 같은 파일
RandomValuePropertySource
- random.* 프로퍼티 값만을 가지고 있는 프로퍼티 소스입니다.
OS 환경 변수
Java 시스템 프로퍼티
- System.getProperties() 로 조회할 수 있습니다.
JNDI 속성
- java:comp/env
- 애플리케이션이 서블릿 컨테이너나 애플리케이션 서버에서 실행되는 경우 사용할 수 있습니다.
ServletContext 초기화 파라미터
ServletConfig 초기화 파라미터
SPRING_APPLICATION_JSON 프로퍼티
- 환경변수나 시스템 속성에 포함된 인라인 JSON
command line 인수
테스트에 사용되는 properties 속성
- @SpringBootTest 나 애플리케이션의 특정 부분 테스트에 활용합니다
테스트에서 사용되는 @DynamicPropertySource
테스트에서 사용되는 @TestPropertySource
DevTools 전역 프로퍼티
- devtools가 활성화 되어있는 상태에만 활성화 됨
- $HOME/.config/spring-boot 디렉토리 하위에 있는 전역 프로퍼티

config 데이터 파일은 다음 순서에 따라 고려 됩니다.

참고로, .properties, YAML 파일 모두 동일하게 지원되며, 아래에서는 application.yml 파일 하나로 설명하도록 하겠습니다.

패키징된 jar 내에 있는 애플리케이션 프로퍼티
- application.yml
패키징된 jar 내에 있는 프로필별 애플리케이션 프로퍼티
- application-{profile}.yml
패키징된 jar 밖에 있는 애플리케이션 프로퍼티
- application.yml
패키징된 jar 밖에 있는 프로필별 애플리케이션 프로퍼티
- application-{profile}.yml

Note

구성파일은 .yml(그 외의 YAML 변형파일 모두) 나 .properties 모두 지원하지만,
하나의 프로젝트 내에 동일한 형식을 구성하는 것이 관리면에서 권장합니다.

만일 같은 위치에 두가지 형식이 모두 있을 경우에는 .properties 파일을 더 우선합니다.

Note

환경변수를 사용할때, OS 에서 마침표로 구분된 환경변수명을 허용하지 않는 경우가 많습니다.
이 경우에는 마침표를 _로 대체하여 사용하 ㄹ수 있습니다.
예를들어, spring.config.name 프로퍼티를 환경변수로 설정하고 싶다면 SPRING_CONFIG_NAME 이라는 이름으로 사용 가능합니다.

참고: Binding From Environment Variables

1.1. 예제

불려지는 순서에 따라 프로퍼티값이 override 되는 것을 확인하기 위해 아래 예제를 살펴봅시다.

1.1.1. 예제 1

yml 데이터 파일에 아래와 같이 구성 설정을 할 경우,

name: jini

아래 api를 호출해보면, 프로퍼티 파일에 설정한 구성 값이 잘 출력되는 것을 확인할 수 있을 것입니다.

@RequiredArgsConstructor
@RequestMapping("/test")
@RestController
class TestController {

    private final AppConfig appConfig;

    @GetMapping
    public String hello() {
        return "name: " + appConfig.getName();
    }
}

http :8080/test

HTTP/1.1 200
Connection: keep-alive
Content-Length: 10
Content-Type: text/plain;charset=UTF-8
Date: Fri, 01 Nov 2024 10:25:50 GMT
Keep-Alive: timeout=60

name: jini

1.1.2. 예제 2

command line 인자로 값을 설정해주면, 기존에 패키징된 jar 내의 application.yml 파일 설정을 override 할 수 있습니다.
아래와 같이 command line 인자로 name 값을 정의해주면 해당 값이 덮어써지는 것을 확인할 수 있습니다.

java -jar spring-boot-0.0.1.jar --name="lily"

http :8080/ttt

HTTP/1.1 200
Connection: keep-alive
Content-Length: 10
Content-Type: text/plain;charset=UTF-8
Date: Fri, 01 Nov 2024 10:26:45 GMT
Keep-Alive: timeout=60

name: lily

Tip

env 와 configprops 엔드포인트를 활용하면 프로퍼티에 특정 값이 들어있는 이유를 확인하는데에 유용합니다.
프로덕션 준비를 하기 전에 이부분을 검토하여 예상치 못한 속성 값을 진단하는 것이 좋습니다.
참고: [Spring Boot Core] Actuator를 이용한 환경 변수 모아보기

2. command line 프로퍼티 액세스

기본적으로 SpringApplication 은 -- 으로 시작되는 command line 인자값을 프로퍼티로 변환해주고, 이 프로퍼티들을 Spring Environment에 추가합니다.

예시: java -jar demo.jar --server.port=18080

만약 command line 인자값들을 Spring Environment에 추가하고 싶지 않다면,
SpringApplication.setAddCommandLineProperties(false) 설정으로 비활성화 시킬 수 있습니다.

3. JSON Application properties

환경변수와 시스템 프로퍼티들을 사용할 때, 종종 이름 설정의 제한을 마주할 때가 있습니다.

Spring에서는 단일 JSON 구조로 프로퍼티 블록을 인코딩하여 사용하는 것을 허용합니다.

3.1. 예제 소스코드

my 라는 prefix 에 name 과 age 프로퍼티를 설정한다고 하고, 그 프로퍼티를 읽어들일 코드를 작성해봅시다.

@Data
@ToString
@ConfigurationProperties(prefix = "my")
@Component
public class MyProperties {
    private String name;
    private Integer age;
}

@RequiredArgsConstructor
@RequestMapping("/properties")
@RestController
class PropertiesController {

    private final MyProperties myProperties;

    @GetMapping("/my")
    public String my() {
        return myProperties.toString();
    }
}

3.2. JSON Application Properties 설정하기

JSON Application Properties를 설정하는 방법은 다양합니다.
아래 3가지 방법중 편한 방법대로 설정하면 됩니다.

3.2.1. command line 인자로 설정

java -jar spring-boot.jar \
 --spring.application.json="{\"my\":{\"name\":\"coco\", \"age\":22}}"

3.2.2. 시스템 프로퍼티로 설정

java -Dspring.application.json="{\"my\":{\"name\":\"coco\", \"age\":22}}" -jar spring-boot.jar

3.2.3. 환경변수로 설정

사용하고 있는 터미널의 환경변수 설정파일에 들어가서

vim ~/.zshrc

하단에 SPRING_APPLICATION_JSON 환경 export를 추가해줍니다.

export SPRING_APPLICATION_JSON="{\"my\":{\"name\":\"coco\", \"age\":22}}"

수정사항을 반영해주고

source ~/.zshrc

echo명령어로 환경변수가 잘 설정되어있는지 확인해줍니다.

echo $SPRING_APPLICATION_JSON

{"my":{"name":"coco2", "age":22}}

설정한 환경변수가 잘 조회된다면 애플리케이션을 실행해봅니다.

java -jar spring-boot.jar

3.3. 테스트

3.3.1. api 테스트

HTTPie 로 실행한 결과입니다.
사용하고 있는 http client 를 이용하여 api를 조회해봅시다.

http :8080/properties/my

HTTP/1.1 200
Connection: keep-alive
Content-Length: 31
Content-Type: text/plain;charset=UTF-8
Date: Sun, 03 Nov 2024 07:50:05 GMT
Keep-Alive: timeout=60

MyProperties(name=coco, age=22)

GET http://localhost:8080/actuator/env

...
{
  "name": "spring.application.json",
  "properties": {
    "my.name": {
      "value": "coco",
      "origin": "\"spring.application.json\" from property source \"commandLineArgs\""
    },
    "my.age": {
      "value": 22,
      "origin": "\"spring.application.json\" from property source \"commandLineArgs\""
    }
  }
},

3.3.2. env 테스트

env 테스트에 대한 상세한 설명은 아래 게시물을 참고해주세요.

[Spring Boot Core] Actuator를 이용한 환경 변수 모아보기

3.3.2.1. command line 인자 설정 결과

command line 인자로 설정한 후 Actuator env를 REST Client로 조회한 결과입니다.

GET http://localhost:8080/actuator/env

{
  "propertySources": [
    {
      "name": "commandLineArgs",
      "properties": {
        "spring.application.json": {
          "value": "{\"my\":{\"name\":\"coco\", \"age\":22}}"
        }
      }
    },
    {
      "name": "spring.application.json",
      "properties": {
        "my.name": {
          "value": "coco",
          "origin": "\"spring.application.json\" from property source \"commandLineArgs\""
        },
        "my.age": {
          "value": 22,
          "origin": "\"spring.application.json\" from property source \"commandLineArgs\""
        }
      }
    },
    ...
  ]
}

3.3.2.2. 환경변수 설정 결과

SPRING_APPLICATION_JSON 환경변수로 설정한 후 Actuator env를 REST Client로 조회한 결과입니다.

GET http://localhost:8080/actuator/env

{
  "propertySources": [
    {
      "name": "spring.application.json",
      "properties": {
        "my.name": {
          "value": "jini",
          "origin": "System Environment Property \"SPRING_APPLICATION_JSON\""
        },
        "my.age": {
          "value": 28,
          "origin": "System Environment Property \"SPRING_APPLICATION_JSON\""
        }
      }
    },
    {
      "name": "systemProperties",
      "properties": {
        ...
        "SPRING_APPLICATION_JSON": {
          "value": "{\"my\":{\"name\":\"jini\",\"age\":28}}",
          "origin": "System Environment Property \"SPRING_APPLICATION_JSON\""
        },
        ...
      }
    }
  ]
}

++

Externalized Configuration

[Spring Boot Core] 1. SpringApplication

jiniya22 — Tue, 22 Oct 2024 16:33:01 +0900

Spring Appplication

startup 실패
지연 초기화
커스텀 배너
SpringApplication 커스텀
애플리케이션 가용성
웹 환경
application arguments 접근
Application 또는 CommandLineRunner
애플리케이션 종료
관리자 기능
애플리케이션 시작 추적
1. 시작 시간 분석
1. 특정 startup event만 필터링하여 분석
1. jq json processor 를 이용한 빈 초기화 기간 조회

SpringApplication 클래스는 main()메서드를 이용하여 편리하게 Spring 애플리케이션 부팅을 제공합니다.

SpringApplication.run 정적 메서드에게 위임하여 애플리케이션을 실행합니다.

@SpringBootApplication
public class SpringBootApp {

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

}

최초로 프로젝트를 생성한 후, 실행했을 때 아래와 같이 로그가 출력됩니다.

.   ____          _            __ _ _
/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
'  |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/

:: Spring Boot ::                (v3.3.3)

2024-09-30T14:25:01.031+09:00  INFO 38382 --- [spring-boot] [  restartedMain] me.jiniworld.springboot.SpringBootApp    : Starting SpringBootApp using Java 22.0.2 with PID 38382 (/User/jini/jini_box/jinispaces/java/spring-playground/spring-boot/build/classes/java/main started by jini in /User/jini/jini_box/jinispaces/java/spring-playground)
2024-09-30T14:25:01.033+09:00  INFO 38382 --- [spring-boot] [  restartedMain] me.jiniworld.springboot.SpringBootApp    : The following 1 profile is active: "local"
2024-09-30T14:25:01.052+09:00  INFO 38382 --- [spring-boot] [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : Devtools property defaults active! Set 'spring.devtools.add-properties' to 'false' to disable
2024-09-30T14:25:01.052+09:00  INFO 38382 --- [spring-boot] [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : For additional web related logging consider setting the 'logging.level.web' property to 'DEBUG'
2024-09-30T14:25:01.411+09:00  INFO 38382 --- [spring-boot] [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
2024-09-30T14:25:01.418+09:00  INFO 38382 --- [spring-boot] [  restartedMain] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2024-09-30T14:25:01.418+09:00  INFO 38382 --- [spring-boot] [  restartedMain] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.28]
2024-09-30T14:25:01.435+09:00  INFO 38382 --- [spring-boot] [  restartedMain] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2024-09-30T14:25:01.435+09:00  INFO 38382 --- [spring-boot] [  restartedMain] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 383 ms
2024-09-30T14:25:04.900+09:00  INFO 38382 --- [spring-boot] [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2024-09-30T14:25:04.914+09:00  INFO 38382 --- [spring-boot] [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2024-09-30T14:25:04.919+09:00  INFO 38382 --- [spring-boot] [  restartedMain] me.jiniworld.springboot.SpringBootApp    : Started SpringBootApp in 4.048 seconds (process running for 9.333)

기본적으로 INFO 로깅메시지가 출력됩니다.

만일 로깅 설정을 직접 설정하고 싶다면, Logging 페이지를 참조하여 알맞게 커스텀 하면 됩니다.

로깅 정보의 맨 첫번째로는 spring 기본 배너와 함께, Spring Boot 의 메인 버전(spring-boot.formatted-version)이 출력되고,

그 다음에 애플리케이션 실행시 시작 정보 로깅을 출력합니다.
시작 정보 로깅에는 애플리케이션을 시작한 사용자에 대한 세부 정보 등이 포함되어있는데, 이 정보를 끄고 싶다면

spring.main.log-startup-info 값을 false 로 설정하면 됩니다.

spring:
  main:
    log-startup-info: false

1. startup 실패

애플리케이션 시작에 실패했을 때, 등록된 FailureAnalyzers는 오류 메시지와 함께 문제 해결을 위한 조치 방안을 제공해줍니다.

아래는 8080포트를 이용하여 애플리케이션을 시작했으나, 다른 곳에서 이미 해당 포트를 사용하고 있을 경우에 대한 에러 로그입니다.

***************************
APPLICATION FAILED TO START
***************************

Description:

Web server failed to start. Port 8080 was already in use.

Action:

Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.

Disconnected from the target VM, address: '127.0.0.1:51544', transport: 'socket'

Process finished with exit code 0

Spring Boot에서는 다양한 FailureAnalyzers 구현체를 제공하고 있으며, 직접 커스텀한 FailureAnalyzers 구현체를 이용할 수 도 있습니다. 참고

2. 지연 초기화

Spring Application은 지연 초기화(Lazy Initialization)를 허용합니다.

지연 초기화가 활성화 되어있을 경우, bean은 애플리케이션 시작시가 아닌, 필요시에 생성됩니다.
빈 생성이 애플리케이션 실행시에 생성되는 것이 아니기 떄문에, 애플리케이션 시작에 걸리는 시간을 줄일 수 있습니다.

웹 애플리케이션에서 지연 초기화를 활성화할 경우, http 요청을 받기 전까지 웹 관련 bean이 초기화 되지 않습니다.

지연 초기화를 활성화시킬 경우, 문제가 있는 빈이 사용되는 시점에 초기화 되기 때문에 애플리케이션의 문제점 발견이 늦어질 수 있다는 단점이 있습니다.

또, 시작시 초기화되는 빈 뿐안아니라 이후에 초기화될 모든 빈들을 수용할만큼 JVM 메모리가 충분한지 체크하기가 어려운 점이 있어 기본적으로 지연 초기화를 활성화 하지 않습니다.
지연 초기화 기능을 활성화할거라면 사전에 JVM 힙 크기를 미세 조정하는 것이 좋습니다.

지연 초기화를 활성화하고 싶다면 spring.main.lazy-initialization 값을 true 로 설정하면 됩니다. (기본값: false)

spring:
  main:
    lazy-initialization: true

기본적으로 지연초기화를 활성화한 상태에서, 특정 빈은 지연초기화를 비활성화하고 싶다면, 해당 빈에 @Lazy(false) 설정을 추가해주면 됩니다.

3. 커스텀 배너

[Spring Boot] Custom Banners 참고

4. SpringApplication 커스텀

기본 SpringApplication에서 커스텀을 하고 싶다면, SpringApplication 인스턴스를 직접 생성하여 커스텀하여 실행시킬 수 있습니다.

@SpringBootApplication
public class SpringBootApp {

	public static void main(String[] args) {
		SpringApplication app = new SpringApplication(SpringBootApp.class);
		app.setBannerMode(Banner.Mode.OFF);
		app.run(args);
	}

}

SpringApplicationBuilder를 이용하여 빌더 패턴으로 SpringApplication 커스텀이 가능하고,

@SpringBootApplication
public class SpringBootApp {

	public static void main(String[] args) {
		new SpringApplicationBuilder().sources(SpringBootApp.class)
			.bannerMode(Banner.Mode.OFF)
			.run(args);
	}

}

.child() 메서드로 parent-child 계층 구조 설정도 가능합니다.

5. 애플리케이션 가용성

Spring 애플리케이션은 플랫폼에 배포할때 인프라를 사용한 플랫폼 가용성에 대한 정보를 알려줍니다. (쿠버네티스의 Probes와 같은)

Spring Boot에는 Liveness, readiness 가용성 상태에 대한 기본적인 지원이 포함되어있습니다.
만약 Spring Boot의 actuator를 사용하는 경우, 이러한 상태는 health endpoint group으로 노출됩니다.
또, ApplicationAvailability 인터페이스를 통해 당신의 빈에 주입하여 가용성 상태를 얻을 수 있습니다.

5.1. Liveness status

애플리케이션의 Liveness(활성) 상태는 내부상태가 올바르게 작동될 수 있거나 실패중인 상태에서 스스로 복구할 수 있는지에 대해 알려줍니다.

Liveness 상태가 문제가 있다면, 애플리케이션이 복구할 수 없는 상태에 있다는 뜻으로, 인프라가 애플리케이션을 새로 시작해야 한다는 의미입니다.

memo

일반적으로, Liveness 상태를 외부 검사 기반으로 하는 것을 권장하지 않습니다.
만일, 외부 검사 기반으로 설정한다면, 외부 시스템(DB, 외부 web api, 외장 캐시)의 실패로 인해 대규모 재시작이나 플랫폼 전반에 걸친 연쇄 실패를 유발할 수 있습니다.

Spring Boot의 내부상태는 대부분 ApplicationContext 로 표현됩니다.
만약 애플리케이션 컨텍스트가 성공적으로 시작된다면, Spring Boot는 애플리케이션을 유효한 상태로 가정하고, 컨텍스트가 새로 고쳐질 때 애플리케이션은 활성 상태로 간주합니다.

5.2. Readiness status

애플리케이션의 Readiness(준비) 상태는 애플리케이션이 트래픽을 처리할 준비가 되었는지 여부를 알려줍니다.

실패한 readiness status는 플랫폼에게 현재 애플리케이션으로 트래픽을 라우팅해서는 안된다는 것을 알려줍니다.

이것을 일반적으로 시작 중에 발생됩니다.
CommandLineRunner 및 ApplicationRunner 컴포넌트가 처리되는 동안 또는 애플리케이션이 너무 바빠서 추가 트래픽을 처리할 수 없다고 판단되는 경우에 언제든지 발생합니다.

애플리케이션은 CommandLineRunner가 실행되자마자 준비된 것으로 간주합니다.

note

시작중에 실행되어야하는 작업들은 @PostContruct 와같은 Spring component lifecycle callback 대신 CommandLineRunner 및 ApplicationRunner 컴포넌트에서 실행해야 합니다.

5.3. 애플리케이션 가용성 상태 관 리

애플리케이션 구성 요소는 언제든지 ApplicationAvailability 인터페이스를 통해 현재 가용성 상태를 검색할 수 있습니다.

애플리케이션은 상태 업데이트를 수신하거나 애플리케이션 상태를 업데이트하고자할 때가 많습니다.

쿠버네티스의 exec Probe가 아래의 파일을 볼 수 있도록 애플리케이션의 Readiness 상태를 내보낼 수 있습니다.

6. 웹 환경

SpringApplication 은 알맞는 ApplicationContext 타입을 생성하려고 시도합니다.

만일 Spring MVC 를 사용하는 경우에는 AnnotationConfigServletWebServerApplicationContext 가 사용되고
Spring MVC 는 없고 Spring WebFlux 가 있다면 AnnotationConfigReactiveWebServerApplicationContext 가 사용됩며
그 외의 경우에는 AnnotationConfigApplicationContext 가 사용됩니다.

즉, Spring MCP 와 Spring WebFlux의 WebClient 를 사용하고 있다면, 기본적으로 Spring MVC가 사용됩니다.

만일, 애플리케이션 타입을 변경하고 싶다면 setWebApplicationType(웹애플리케이션타입) 으로 override 하면 됩니다.

또는 setApplicationContextFactory() 로도 설정 가능합니다.

tip

JUnit 테스트 내에서 SpringApplication 을 사용하는 경우에는, setWebApplicationType(WebApplicationType.NONE) 을 호출하는 것을 권장합니다.

7. application arguments 접근

만약 _SpringApplication.run(...)` 으로 전달된 application arguments 에 접근해야한다면, org.springframework.boot.ApplicationArguments 빈을 통해 해당 값을 주입할 수 있습니다.

@RequiredArgsConstructor
@RequestMapping("/spring-application")
@RestController
class SpringApplicationController {

    private final ApplicationArguments applicationArguments;

    @GetMapping
    public Data applicationArguments() {
        Map<String, Object> options = new HashMap<>();
        applicationArguments.getOptionNames().forEach(optionName -> options.put(optionName, applicationArguments.getOptionValues(optionName)));

        return new Data(List.of(applicationArguments.getSourceArgs()), options, applicationArguments.getNonOptionArgs());
    }

    record Data(List<String> sourceArgs, Map<String, Object> options, List<String> nonOptionArgs) {
    }
}

java -jar spring-boot/build/libs/spring-boot-0.0.1.jar --debug --tag=test local

{
  "sourceArgs": [
    "--debug",
    "--name=jini",
    "local"
  ],
  "options": {
    "debug": [],
    "name": [
      "jini"
    ]
  },
  "nonOptionArgs": [
    "local"
  ]
}

8. Application 또는 CommandLineRunner 사용

SpringApplication 이 시작된 이후 특정 코드를 실행하고 싶다면, ApplicationRunner 또는 CommandLineRunner 인터페이스를 구현해야합니다.

두 인터페이스 모두 동일한 방식으로 동작되며, 하나의 run 메서더드를 제공하고 있으며, 이는 SpringApplication.run() 이 완료되기 직전에 호출됩니다.
이러한 작업은 보통 애플리케이션이 시작된 후 실질적인 트래픽을 받기 전에 실행되어야하는 작업에 적합합니다.

@Slf4j
@SpringBootApplication
public class SpringBootApp {

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

	@Bean
	CommandLineRunner commandLineRunner() {
		return args -> log.info("commandLineRunner - args : {}", Arrays.toString(args));
	}

}

웹서버가 실행 된후, 위의 commandLineRunner() 빈 실행에 의해 로그에 commandLineRunner - args : [--debug, --tag=test, local] 가 찍혔습니다.

2024-10-07T13:44:09.486+09:00  INFO 82127 --- [spring-boot] [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2024-10-07T13:44:09.488+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] inMXBeanRegistrar$SpringApplicationAdmin : Application Admin MBean registered with name 'org.springframework.boot:type=Admin,name=SpringApplication'
2024-10-07T13:44:09.489+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] o.s.b.d.livereload.LiveReloadServer      : Starting live reload server on port 35729
2024-10-07T13:44:09.490+09:00  INFO 82127 --- [spring-boot] [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2024-10-07T13:44:09.551+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] o.s.b.a.ApplicationAvailabilityBean      : Application availability state LivenessState changed to CORRECT
2024-10-07T13:44:09.552+09:00  INFO 82127 --- [spring-boot] [  restartedMain] me.jiniworld.springboot.SpringBootApp    : commandLineRunner - args : [--debug, --tag=test, local]
2024-10-07T13:44:09.553+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] o.s.boot.devtools.restart.Restarter      : Creating new Restarter for thread Thread[#1,main,5,main]
2024-10-07T13:44:09.553+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] o.s.boot.devtools.restart.Restarter      : Immediately restarting application
2024-10-07T13:44:09.553+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] o.s.boot.devtools.restart.Restarter      : Starting application me.jiniworld.springboot.SpringBootApp with URLs []
2024-10-07T13:44:09.553+09:00 DEBUG 82127 --- [spring-boot] [  restartedMain] o.s.b.a.ApplicationAvailabilityBean      : Application availability state ReadinessState changed to ACCEPTING_TRAFFIC

8.1. CommandLineRunner 빈의 실행 순서 설정하기

ApplicationRunner, CommandLinerRunner 빈을 여러개 정의하고, Ordered 인터페이스의 구현이나 @Order 애너테이션을 이용하여 실행 순서를 설정할 수 있습니다.

@Slf4j
@SpringBootApplication
public class SpringBootApp {

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

	@Order(1)
	@Bean
	CommandLineRunner commandLineRunner() {
		return args -> log.info("commandLineRunner bean : {}", Arrays.toString(args));
	}

}

@Slf4j
@Component
public class MyCommandLineRunner implements CommandLineRunner, Ordered {

    @Override
    public void run(String... args) {
        log.info("MyCommandLineRunner: {}", Arrays.toString(args));
    }

    @Override
    public int getOrder() {
        return 2;
    }
}

2024-10-07T14:47:32.154+09:00  INFO 90766 --- [spring-boot] [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2024-10-07T14:47:32.156+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] inMXBeanRegistrar$SpringApplicationAdmin : Application Admin MBean registered with name 'org.springframework.boot:type=Admin,name=SpringApplication'
2024-10-07T14:47:32.158+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] o.s.b.d.livereload.LiveReloadServer      : Starting live reload server on port 35729
2024-10-07T14:47:32.158+09:00  INFO 90766 --- [spring-boot] [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2024-10-07T14:47:32.215+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] o.s.b.a.ApplicationAvailabilityBean      : Application availability state LivenessState changed to CORRECT
2024-10-07T14:47:32.217+09:00  INFO 90766 --- [spring-boot] [  restartedMain] me.jiniworld.springboot.SpringBootApp    : commandLineRunner bean : [--debug, --tag=test, local]
2024-10-07T14:47:32.217+09:00  INFO 90766 --- [spring-boot] [  restartedMain] m.j.springboot.MyCommandLineRunner       : MyCommandLineRunner: [--debug, --tag=test, local]
2024-10-07T14:47:32.217+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] o.s.boot.devtools.restart.Restarter      : Creating new Restarter for thread Thread[#1,main,5,main]
2024-10-07T14:47:32.217+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] o.s.boot.devtools.restart.Restarter      : Immediately restarting application
2024-10-07T14:47:32.217+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] o.s.boot.devtools.restart.Restarter      : Starting application me.jiniworld.springboot.SpringBootApp with URLs []
2024-10-07T14:47:32.217+09:00 DEBUG 90766 --- [spring-boot] [  restartedMain] o.s.b.a.ApplicationAvailabilityBean      : Application availability state ReadinessState changed to ACCEPTING_TRAFFIC

9. 애플리케이션 종료

각 SpringApplication 은 종료 시 ApplicationContext 가 종료시 graceful 하게 꺼지도록 JVM에 shutdown hook를 등록합니다.
DisposableBean 인터페이스나 @PreDestory 애너테이션과 같은 표준 Spring lifecycle 콜백을 사용할 수 있습니다.

만약 SpringApplication.exit()가 호출될 때 특별한 exit code를 반환하기를 원한다면 org.springframework.boot.ExitCodeGenerator 인터페이스를 구현한 빈을 활용하면 됩니다.

ExitCodeGenerator 가 2개 이상인 경우, 0이 아닌 exit code가 사용되며,

@SpringBootApplication
public class SpringBootApp {

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

	@Bean
	public ExitCodeGenerator exitCodeGenerator() {
		return () -> 42;
	}

}

ExitCodeEvent 에 대한 EventListener를 만듭니다.

@Slf4j
@Component
public class ExitCodeEventListener {

    @EventListener
    public void handleExitCodeEvent(ExitCodeEvent event) {
        log.info("ExitCodeEvent >>> Exit code: {}", event.getExitCode());
    }

}

data 값이 q 일 경우, 종료시키는 api를 추가하였습니다.

public record SimpleData<T> (T data) { }

@RequiredArgsConstructor
@RequestMapping("/exit-code")
@RestController
class ExitCodeController {

    private final ApplicationContext applicationContext;
    private final ExitCodeGenerator exitCodeGenerator;

    @PostMapping
    public String exitCode(@RequestBody SimpleData<String> req) {
        if ("q".equals(req.data())) {
            SpringApplication.exit(applicationContext, exitCodeGenerator);
        }
        return req.data();
    }

}

HTTPie로 api 테스트를 한 결과입니다.

http POST :8080/exit-code data=q

http: error: ConnectionError: ('Connection aborted.', RemoteDisconnected('Remote end closed connection without response')) while doing a POST request to URL: http://localhost:8080/exit-code

10. 관리자 기능

spring.application.admin.enabled 프로퍼티 속성을 활성화하여 관리자 기능을 활성화 시킬 수 있습니다.

spring:
  application:
    admin:
      enabled: true

javac 명령어가 설치된 디렉토리에 들어가보면 jconsole 명령어가 있다. 이 명령어를 실행하면 Java Monitoring & Management Console 을 실행할 수 있습니다.

which javac
/opt/homebrew/opt/openjdk/bin/javac

ls /opt/homebrew/opt/openjdk/bin/
jar         java        javadoc     jcmd        jdb         jdeps       jhsdb       jinfo       jmap        jpackage    jrunscript  jstack      jstatd      keytool     serialver
jarsigner   javac       javap       jconsole    jdeprscan   jfr         jimage      jlink       jmod        jps         jshell      jstat       jwebserver  rmiregistry

./jconsole

힙 메모리 사용량, CPU 사용량, 로딩된 클래스 수 등 실행중인 애플리케이션에 대한 다양한 정보를 확인할 수 있습니다.

11. 애플리케이션 시작 추적

애플리케이션을 시작하는 동안 SpringApplication 과 ApplicationContext 는 애플리케이션 생애주기동안 bean lifecycle 이나 애플리케이션 이벤트 처리 와 관련된 다양한 작업을 수행합니다.
_ApplicationStartup_을 사용하면 스프링프레임워크를 사용하여 StartupStep 객체로 애플리케이션 시작 시퀀스를 추적할 수 있습니다.

일반적으로, 기본으로 설정되어있는 DefaultApplicationStartup 를 사용하지만, (별도의 옵션이 설정되어있지 않음)

@SpringBootApplication
public class SpringBootApp {

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

}

SpringApplication 인스턴스를 설정할 때, setApplicationStartup 로 ApplicationStartup 구현을 설정할 수 있습니다.

ApplicationStartup 구현체로는 BufferingApplicationStartup 와 FlightRecorderApplicationStartup 가 있고, 이 구현체들을 사용할 경우, Spring 애플리케이션이 시작되는 동안, 각 단계별로 걸린 시간들을 상세히 파악할 수 있습니다.

11.1. 시작 시간 분석

@SpringBootApplication
public class SpringBootApp {

	public static void main(String[] args) {
		SpringApplication application = new SpringApplication(SpringBootApp.class);
		application.setApplicationStartup(new BufferingApplicationStartup(2048));
		application.run(args);
	}

}

api 를 실행해봅니다. (아래는 curl로 조회한 결과입니다.)

curl http://localhost:8080/actuator/startup | json_pp

{
  "springBootVersion": "3.3.3",
  "timeline": {
    "startTime": "2024-10-22T05:00:48.922274Z",
    "events": [
      {
        "endTime": "2024-10-22T05:00:48.933747Z",
        "duration": "PT0.011367S",
        "startTime": "2024-10-22T05:00:48.922380Z",
        "startupStep": {
          "name": "spring.boot.application.starting",
          "id": 0,
          "tags": [
            {
              "key": "mainApplicationClass",
              "value": "me.jiniworld.springboot.SpringBootApp"
            }
          ]
        }
      },
      ...
      {
        "endTime": "2024-10-22T05:00:50.013900Z",
        "duration": "PT0.003504S",
        "startTime": "2024-10-22T05:00:50.010396Z",
        "startupStep": {
          "name": "spring.boot.application.started",
          "id": 260,
          "tags": []
        }
      },
      {
        "endTime": "2024-10-22T05:00:50.014133Z",
        "duration": "PT0.000103S",
        "startTime": "2024-10-22T05:00:50.014030Z",
        "startupStep": {
          "name": "spring.beans.instantiate",
          "id": 265,
          "tags": [
            {
              "key": "beanName",
              "value": "myCommandLineRunner"
            },
            {
              "key": "beanType",
              "value": "interface org.springframework.boot.Runner"
            }
          ]
        }
      },
      {
        "endTime": "2024-10-22T05:00:50.014428Z",
        "duration": "PT0.000279S",
        "startTime": "2024-10-22T05:00:50.014149Z",
        "startupStep": {
          "name": "spring.beans.instantiate",
          "id": 267,
          "tags": [
            {
              "key": "beanName",
              "value": "springBootApp"
            }
          ],
          "parentId": 266
        }
      },
      ...
      {
        "endTime": "2024-10-22T05:01:07.532088Z",
        "duration": "PT0.001044S",
        "startTime": "2024-10-22T05:01:07.531044Z",
        "startupStep": {
          "name": "spring.beans.instantiate",
          "id": 293,
          "tags": [
            {
              "key": "beanName",
              "value": "flashMapManager"
            },
            {
              "key": "beanType",
              "value": "interface org.springframework.web.servlet.FlashMapManager"
            }
          ]
        }
      }
    ]
  }
}

11.2. 특정 startup event만 필터링하여 분석

startupStemp의 특정 name만 필터링해서 보여주도록 하고 싶다면 ApplicationStartup 구현체에 startupStep에 아래와 같은 match를 설정해주면 됩니다.

@SpringBootApplication
public class SpringBootApp {

	public static void main(String[] args) {
		SpringApplication application = new SpringApplication(SpringBootApp.class);
		var applicationStartup = new BufferingApplicationStartup(2048);
		applicationStartup.addFilter(startupStep -> startupStep.getName().matches("spring.beans.instantiate"));
		application.setApplicationStartup(applicationStartup);
		application.run(args);
	}

}

api 를 실행해봅니다. (아래는 HTTPie로 조회한 결과입니다.)

http :8080/actuator/startup

HTTP/1.1 200
Connection: keep-alive
Content-Type: application/vnd.spring-boot.actuator.v3+json
Date: Tue, 22 Oct 2024 05:15:39 GMT
Keep-Alive: timeout=60
Transfer-Encoding: chunked

{
  "springBootVersion": "3.3.3",
  "timeline": {
    "startTime": "2024-10-22T05:12:04.400145Z",
    "events": [
      {
        "endTime": "2024-10-22T05:12:04.578045Z",
        "duration": "PT0.000673S",
        "startTime": "2024-10-22T05:12:04.577372Z",
        "startupStep": {
          "name": "spring.beans.instantiate",
          "id": 7,
          "tags": [
            {
              "key": "beanName",
              "value": "org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory"
            }
          ],
          "parentId": 6
        }
      },
      ...
      {
        "endTime": "2024-10-22T05:12:05.718332Z",
        "duration": "PT0.020823S",
        "startTime": "2024-10-22T05:12:05.697509Z",
        "startupStep": {
          "name": "spring.beans.instantiate",
          "id": 284,
          "tags": [
            {
              "key": "beanName",
              "value": "viewResolver"
            }
          ]
        }
      },
      {
        "endTime": "2024-10-22T05:12:05.719134Z",
        "duration": "PT0.000787S",
        "startTime": "2024-10-22T05:12:05.718347Z",
        "startupStep": {
          "name": "spring.beans.instantiate",
          "id": 293,
          "tags": [
            {
              "key": "beanName",
              "value": "flashMapManager"
            },
            {
              "key": "beanType",
              "value": "interface org.springframework.web.servlet.FlashMapManager"
            }
          ]
        }
      }
    ]
  }
}

11.3. jq json processor 를 이용한 빈 초기화 기간 조회

사전에 jq를 다운받습니다.
mac OS의 경우, brew로 설치가 가능합니다.

brew install jq

다른 OS에서 설치해야한다면. Download jq를 참고해주세요.

jq를 이용하여 startupStep.name 이 spring.beans.instantiate 인 항목들에 대해서 startupStep - tags[0] - value 와 duration 값만 duration 내림차순으로 조회합니다.

아래의 결과에는 가장 오래걸린 빈 초기화가 0.05초이지만, 만약 빈의 초기화가 오래걸리는 항목이 조회된다면, 애플리케이션의 개선점을 찾는데에 도움이 될 수 있습니다.

curl 'http://localhost:8080/actuator/startup' -X POST \
| jq '[.timeline.events
 | sort_by(.duration) | reverse[]
 | select(.startupStep.name | match("spring.beans.instantiate"))
 | {beanName: .startupStep.tags[0].value, duration: .duration}]'

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 77332    0 77332    0     0   600k      0 --:--:-- --:--:-- --:--:--  604k
[
  {
    "beanName": "tomcatServletWebServerFactory",
    "duration": "PT0.051436S"
  },
  {
    "beanName": "jmxMBeanExporter",
    "duration": "PT0.045843S"
  },
  {
    "beanName": "webMvcObservationFilter",
    "duration": "PT0.028073S"
  },
  {
    "beanName": "requestMappingHandlerMapping",
    "duration": "PT0.025103S"
  },
  ...
  {
    "beanName": "org.springframework.boot.actuate.autoconfigure.web.mappings.MappingsEndpointAutoConfiguration$ServletWebConfiguration",
    "duration": "PT0.000052S"
  },
  {
    "beanName": "org.springframework.boot.actuate.autoconfigure.startup.StartupEndpointAutoConfiguration",
    "duration": "PT0.000051S"
  }
]

ApplicationStartup을 활용하여 Spring Boot 애플리케이션의 startup메트릭에 대해 확인할 수 있었습니다.

다만, ApplicationStartup은 애플리케이션의 startup 하는 동안에만 사용할 수 있는 부분으로, 애플리케이션 계측을 위한 Java 프로파일러 및 메트릭 수집 프레임워크를 대체하지는 않습니다.

12. Virtual Thread

Java 21 이상 버전을 사용하는 경우, spring.threads.virtual.enabled 속성을 이용하여 가상 스레드를 활성화할 수 있습니다.

이 옵션을 사용하기 전에, official Java virtual threads Docs를 읽어보는것을 권장합니다.

어떤 경우, "고정된 가상 스레드"로 인하여 애플리케이션의 처리량이 낮아질 수 있습니다.
위의 공식문서에서는 JDK Flight Recorder 또는 jcmd CLI로 이러한 경우를 감지하는 방법도 설명합니다.

note

virtual thread는 전용 스레드 풀이 아닌 JVM 전체 플랫폼 스레드 풀에서 예약됩니다.
따라서, virtual thread 가 활성화되면 thread pool을 구성하는 속성은 더이상 효과가 없어 집니다.

Warning

가상 스레드는 데몬 스레드입니다.
모든 스레드가 데몬 스레드일 경우, JVM이 종료됩니다.
이러한 성질을 유의하지 않으면 애플리케이션 운영 중 문제점을 만날 수 있습니다.

예를 들어, 애플리케이션을 유지하기 위해 @Scheduled Bean에 의존하는 경우 이러한 동작이 문제가 될 수 있습니다.
가상 스레드가 활성화된 상태에서는, 스케줄러 스레드가 데몬 스레드가 되기 때문에 JVM을 활성 상태로 유지하지 않습니다.
이는 스케줄링에 영향을 미칠 뿐만 아니라 다른 기술에도 영향을 미칠 수 있습니다.

모든 경우에 JVM을 계속 실행하기 위해서는 spring.main.keep-alive 속성을 true로 설정하면 됩니다. 이렇게 설정하면 모든 스레드가 가상 스레드인 경우에도 JVM이 활성상태로 유지됩니다.

++

Spring Boot Docs 3.3.4
Core Features - SpringApplication

[Spring Boot Core] Actuator를 이용한 환경 변수 모아보기

jiniya22 — Tue, 15 Oct 2024 18:21:06 +0900

dependency 추가
actuator endpoints 설정
환경변수 보이게 설정

Spring Application을 이용하여 개발을 하는 중에, OS에 설정되어있는 환경 변수나, 프로퍼티를 통해 설정된 프로파일 값들이 어떻게 적용되어있는지 한눈에 확인해보고 싶은 경우가 종종 있습니다.

Spring Actuator 에서는 이러한 환경정보를 모아서 json형태로 내려주는 기능을 제공합니다.

1. dependency 추가

사용중인 dependency 관리툴에 따른 dependency를 추가해줍니다.

implementation("org.springframework.boot:spring-boot-starter-actuator:3.3.4")

build.gradle.kts (Gradle - Kotlin)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
    <version>3.3.4</version>
</dependency>

pom.xml (Maven)

2. actuator endpoints 설정

보안 이슈 때문에 실질적인 상용환경에서는 적용하면 안되겠지만, 개발중인 로컬 환경에서는 옵션을 이용하면 현재 환경에서 어떠한 환경변수가 설정되어있는지 한눈에 확인할 수 있어 필요시 활용하기 좋습니다.

actuator 의존성을 추가했다면, application.yml 에 actuator 관련 설정을 추가할 수 있습니다.
actuator 환경설정을 읽기위해서는 management.endpoints.web.exposure.include 값에 env를 추가해주면 됩니다.

management:
  endpoints:
    web:
      exposure:
        include: env

2.1. GET `/actuator/env`

사용하고 있는 http client로 /actuator/env api를 실행합니다.

HTTPie로 실행한 결과입니다.

환경변수의 values 값을 보여주지 않고 마스킹 처리된 결과를 보여주는 것이 기본 값이기 때문에 아래와 같이 "******"로 출력되는 것을 확인할 수 있습니다.

http :8080/actuator/env

HTTP/1.1 200
Connection: keep-alive
Content-Type: application/vnd.spring-boot.actuator.v3+json
Date: Tue, 15 Oct 2024 09:03:10 GMT
Keep-Alive: timeout=60
Transfer-Encoding: chunked

{
  "activeProfiles": [
    "local"
  ],
  "defaultProfiles": [
    "default"
  ],
  "propertySources": [
    {
      "name": "server.ports",
      "properties": {
        "local.server.port": {
          "value": "******"
        }
      }
    },
    {
      "name": "devtools-local: [file:/Users/jini/.config/spring-boot/spring-boot-devtools.yml]",
      "properties": {
        "spring.devtools.restart.enabled": {
          "value": "******",
          "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 4:16"
        },
        "spring.devtools.restart.log-condition-evaluation-delta": {
          "value": "******",
          "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 5:39"
        },
        "spring.devtools.restart.additional-exclude": {
          "value": "******",
          "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 6:27"
        },
        "spring.devtools.livereload.enabled": {
          "value": "******",
          "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 8:16"
        }
      }
    },
    {
      "name": "commandLineArgs",
      "properties": {
        "debug": {
          "value": "******"
        },
        "tag": {
          "value": "******"
        }
      }
    },
    {
      "name": "servletContextInitParams",
      "properties": {}
    },
    {
      "name": "systemProperties",
      "properties": {
        "spring.devtools.restart.trigger-file": {
          "value": "******"
        },
        "java.specification.version": {
          "value": "******"
        },
        "sun.jnu.encoding": {
          "value": "******"
        },
        "java.class.path": {
          "value": "******"
        },
        "java.vm.vendor": {
          "value": "******"
        },
        ...
        "java.class.version": {
          "value": "******"
        },
        "LOGGED_APPLICATION_NAME": {
          "value": "******"
        }
      }
    },
    {
      "name": "systemEnvironment",
      "properties": {
        "HOMEBREW_PREFIX": {
          "value": "******",
          "origin": "System Environment Property \"HOMEBREW_PREFIX\""
        },
        "RABBIT_MQ_HOME": {
          "value": "******",
          "origin": "System Environment Property \"RABBIT_MQ_HOME\""
        },
        "SDKMAN_CANDIDATES_API": {
          "value": "******",
          "origin": "System Environment Property \"SDKMAN_CANDIDATES_API\""
        },
        ...
        "NVM_BIN": {
          "value": "******",
          "origin": "System Environment Property \"NVM_BIN\""
        }
      }
    },
    {
      "name": "Config resource 'class path resource [application.yml]' via location 'optional:classpath:/'",
      "properties": {
        "spring.application.admin.enabled": {
          "value": "******",
          "origin": "class path resource [application.yml] - 4:16"
        },
        "spring.application.name": {
          "value": "******",
          "origin": "class path resource [application.yml] - 5:11"
        },
        "spring.profiles.active": {
          "value": "******",
          "origin": "class path resource [application.yml] - 7:13"
        },
        ...
        "logging.level.root": {
          "value": "******",
          "origin": "class path resource [application.yml] - 53:11"
        },
        "logging.level.web": {
          "value": "******",
          "origin": "class path resource [application.yml] - 54:10"
        }
      }
    },
    {
      "name": "devtools",
      "properties": {
        "spring.groovy.template.cache": {
          "value": "******"
        },
        "spring.mvc.log-resolved-exception": {
          "value": "******"
        },
        "spring.web.resources.chain.cache": {
          "value": "******"
        },
        "spring.thymeleaf.cache": {
          "value": "******"
        },
        ...
        "spring.web.resources.cache.period": {
          "value": "******"
        }
      }
    }
  ]
}

2.1. GET `/actuator/env/{환경변수명}`

사용하고 있는 http client로 /actuator/env/{환경변수명} api를 실행합니다.
특정 환경변수명에 대하여 세부정보를 조회할 수 있습니다.

http :8080/actuator/env/RABBIT_MQ_HOME

HTTP/1.1 200
Connection: keep-alive
Content-Type: application/vnd.spring-boot.actuator.v3+json
Date: Tue, 15 Oct 2024 09:06:57 GMT
Keep-Alive: timeout=60
Transfer-Encoding: chunked

{
    "activeProfiles": [
        "local"
    ],
    "defaultProfiles": [
        "default"
    ],
    "property": {
        "source": "systemEnvironment",
        "value": "******"
    },
    "propertySources": [
        {
            "name": "server.ports"
        },
        {
            "name": "devtools-local: [file:/Users/jini/.config/spring-boot/spring-boot-devtools.yml]"
        },
        {
            "name": "commandLineArgs"
        },
        {
            "name": "servletConfigInitParams"
        },
        {
            "name": "servletContextInitParams"
        },
        {
            "name": "systemProperties"
        },
        {
            "name": "systemEnvironment",
            "property": {
                "origin": "System Environment Property \"RABBIT_MQ_HOME\"",
                "value": "******"
            }
        },
        {
            "name": "random"
        },
        {
            "name": "Config resource 'class path resource [application.yml]' via location 'optional:classpath:/'"
        },
        {
            "name": "devtools"
        },
        {
            "name": "Management Server"
        }
    ]
}

3. 환경변수 보이게 설정

환경변수는 보안이 매우 중요한 요소로, 로컬환경에서만 사용하기 권장합니다.
local에서 테스트 중, 프로젝트에서 사용하고 있는 환경변수값을 확인하고 싶을 때 사용하면 좋습니다.

management.endpoint.env.show-values 값을 always 로 설정하여 확인하면 됩니다.

management:
  endpoint:
    env:
      show-values: always
  endpoints:
    web:
      exposure:
        include: env

3.1. GET `/actuator/env`

http :8080/actuator/env
HTTP/1.1 200
Connection: keep-alive
Content-Type: application/vnd.spring-boot.actuator.v3+json
Date: Tue, 15 Oct 2024 09:11:02 GMT
Keep-Alive: timeout=60
Transfer-Encoding: chunked

{
    "activeProfiles": [
        "local"
    ],
    "defaultProfiles": [
        "default"
    ],
    "propertySources": [
        {
            "name": "server.ports",
            "properties": {
                "local.server.port": {
                    "value": 8080
                }
            }
        },
        {
            "name": "devtools-local: [file:/Users/jini/.config/spring-boot/spring-boot-devtools.yml]",
            "properties": {
                "spring.devtools.livereload.enabled": {
                    "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 8:16",
                    "value": true
                },
                "spring.devtools.restart.additional-exclude": {
                    "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 6:27",
                    "value": "ttt/**,**/Ttt*.class"
                },
                "spring.devtools.restart.enabled": {
                    "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 4:16",
                    "value": true
                },
                "spring.devtools.restart.log-condition-evaluation-delta": {
                    "origin": "file [/Users/jini/.config/spring-boot/spring-boot-devtools.yml] - 5:39",
                    "value": false
                }
            }
        },
        {
            "name": "commandLineArgs",
            "properties": {
                "debug": {
                    "value": ""
                },
                "tag": {
                    "value": "test"
                }
            }
        },
        {
            "name": "servletContextInitParams",
            "properties": {}
        },
        {
            "name": "systemProperties",
            "properties": {
                "CONSOLE_LOG_CHARSET": {
                    "value": "UTF-8"
                },
                "FILE_LOG_CHARSET": {
                    "value": "UTF-8"
                },
                ...
                "user.dir": {
                    "value": "/Users/jini/jini_box/jinispaces/java/spring-playground"
                },
                "user.home": {
                    "value": "/Users/jini"
                },
                "user.language": {
                    "value": "ko"
                },
                "user.name": {
                    "value": "sherry_01"
                },
                "user.timezone": {
                    "value": "Asia/Seoul"
                }
            }
        },
        {
            "name": "systemEnvironment",
            "properties": {
                "HOME": {
                    "origin": "System Environment Property \"HOME\"",
                    "value": "/Users/jini"
                },

                "JAVA_HOME": {
                    "origin": "System Environment Property \"JAVA_HOME\"",
                    "value": "/Users/jini/.sdkman/candidates/java/current"
                },
                "JAVA_OPTS": {
                    "origin": "System Environment Property \"JAVA_OPTS\"",
                    "value": "-Xmx1024m"
                },
                "RABBIT_MQ_HOME": {
                    "origin": "System Environment Property \"RABBIT_MQ_HOME\"",
                    "value": "/opt/homebrew/opt/rabbitmq/sbin"
                },
                ,,,
            }
        },
        {
            "name": "Config resource 'class path resource [application.yml]' via location 'optional:classpath:/'",
            "properties": {
                ...
                "spring.mvc.log-resolved-exception": {
                    "origin": "class path resource [application.yml] - 25:29",
                    "value": true
                },
                "spring.mvc.static-path-pattern": {
                    "origin": "class path resource [application.yml] - 26:26",
                    "value": "/static/**"
                },
                "spring.profiles.active": {
                    "origin": "class path resource [application.yml] - 7:13",
                    "value": "local"
                }
            }
        },
        {
            "name": "devtools",
            "properties": {
                "server.error.include-binding-errors": {
                    "value": "always"
                },
                "server.error.include-message": {
                    "value": "always"
                },
                ...
                "spring.web.resources.cache.period": {
                    "value": "0"
                },
                "spring.web.resources.chain.cache": {
                    "value": "false"
                }
            }
        }
    ]
}

3.2. GET `/actuator/env/{환경변수명}`

특정 환경변수 상세보기를 실행해보면 아래와 같이 마스킹되지 않고 value가 노출된 것을 확인할 수 있습니다.

http :8080/actuator/env/JAVA_HOME

HTTP/1.1 200
Connection: keep-alive
Content-Type: application/vnd.spring-boot.actuator.v3+json
Date: Tue, 15 Oct 2024 09:13:50 GMT
Keep-Alive: timeout=60
Transfer-Encoding: chunked

{
    "activeProfiles": [
        "local"
    ],
    "defaultProfiles": [
        "default"
    ],
    "property": {
        "source": "systemEnvironment",
        "value": "/Users/jini/.sdkman/candidates/java/current"
    },
    "propertySources": [
        {
            "name": "server.ports"
        },
        {
            "name": "devtools-local: [file:/Users/jini/.config/spring-boot/spring-boot-devtools.yml]"
        },
        {
            "name": "commandLineArgs"
        },
        {
            "name": "servletConfigInitParams"
        },
        {
            "name": "servletContextInitParams"
        },
        {
            "name": "systemProperties"
        },
        {
            "name": "systemEnvironment",
            "property": {
                "origin": "System Environment Property \"JAVA_HOME\"",
                "value": "/Users/jini/.sdkman/candidates/java/current"
            }
        },
        {
            "name": "random"
        },
        {
            "name": "Config resource 'class path resource [application.yml]' via location 'optional:classpath:/'"
        },
        {
            "name": "devtools"
        },
        {
            "name": "Management Server"
        }
    ]
}

++

Spring Boot 환경변수 조회하기

[Spring Docs] DevTools

jiniya22 — Fri, 4 Oct 2024 16:45:17 +0900

Developer Tools
Developer Tools 프로퍼티 기본값
log-request-details 프로퍼티를 이용한 헤더 로깅
Hot swapping
자동 restart
애플리케이션의 프로덕션 배포를 위한 패키징

1. Developer Tools?

devTools 는 개발의 편의성을 위한 여러 기능들을 포함하고 있습니다.

gradle 환경에서는 아래와 같은 의존성을 추가해주면 되고,

dependencies {
	developmentOnly("org.springframework.boot:spring-boot-devtools")
}

Maven 을 사용하고 있다면 아래와 같은 의존성을 추가하면 됩니다.

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-devtools</artifactId>
		<optional>true</optional>
	</dependency>
</dependencies>

위와 같이 의존성을 추가했을 경우, 멀티모듈 프로젝트 상에서 다른 모듈에 DevTools가 전이 적용되는 것을 방지할 수 있습니다.

devTools 는 개발의 편의를 위해 제공되는 기능들로, 보안적인 이유로 production 환경에서는 사용하는 것을 권장하지 않습니다.
참고로 java -jar로 실행된 애플리케이션이나 특별한 클래스 로더를 통해 시작된 로 패키징된 애플리케이션의 경우, production application 으로 간주되어 자동으로 비활성화 됩니다.

만일 강제로 devTools를 활성화시키고 싶다면 -Dspring.devtools.restart.enabled=true 옵션을 설정하여 애플리케이션을 실행하면 되지만, 보안에 취약하기 때문에 권장하지 않습니다.

2. Developer Tools 프로퍼티 기본값

Spring Boot에서 지원하는 다양한 라이브러리들에서는 성능 개선을 위해 캐시를 사용합니다.

예시 1. 예를들면 템플릿 엔진에서 캐시를 사용하여 화면으로 보여줄 템플릿을 캐시합니다. 템플릿 파일을 캐시할 경우, 코드가 수정될 때마다 매번 코드를 분석하지 않습니다.
예시 2. Spring MVC에서 정적 리소스를 제공할 때에 response에 HTTP 캐싱 헤더를 추가

캐싱 기능은 production 환경에서는 성능 개선에 매우 좋지만, 개발 중에는 수정사항을 바로 반영하지 않기 때문에 개발에 역효과를 줍니다.

이러한 이유로 devTools에서는 기본적으로 캐싱 옵션을 비활성화합니다.

아래의 값들은 devTools 를 사용할 경우 적용될 프로퍼티 기본값들입니다.
만일, 아래의 기본값을 사용하고 싶지 않다면 spring.devtools.add-properties 하위에 프로퍼티를 재설정 해주면 됩니다.

server.error.include-binding-errors
- always
server.error.include-message
- always
server.error.include-stacktrace
- always
server.servlet.jsp.init-parameters.development
- TRUE
server.servlet.session.persistent
- TRUE
spring.docker.compose.readiness.wait
- only-if-started
spring.freemarker.cache
- FALSE
spring.graphql.graphiql.enabled
- TRUE
spring.groovy.template.cache
- FALSE
spring.h2.console.enabled
- TRUE
spring.mustache.servlet.cache
- FALSE
spring.mvc.log-resolved-exception
- TRUE
spring.reactor.netty.shutdown-quiet-period
- 0s
spring.template.provider.cache
- FALSE
spring.thymeleaf.cache
- FALSE
spring.web.resources.cache.period
- 0
spring.web.resources.chain.cache
- FALSE

Spring MVC/WebFlux 애플리케이션 개발하는 동안에는 web 그룹에 대한 logging 레벨을 DEBUG로 활성화하는 것을 권장합니다.
web 그룹에 대한 로깅레벨을 DEBUG로 설정할 경우, request, request를 처리하는 핸들러, response 및 세부 정보에 대한 상세 정보를 확인할 수 있습니다.
단, request 세부정보에는 민감 정보가 들어있을 수 있기 때문에,

3. log-request-details 프로퍼티를 이용한 헤더 로깅

org.springframework.web 패키지의 로깅레벨을 trace 로 설정하면 웹 요청과 처리하는 핸들러, 응답 결과 및 세부 정보를 출력할 수 있습니다.

기본적으로 DispatcherServlet 에서 request에 대한 parameters, headers와 response의 headers 정보는 마스킹되어 출력되지 않습니다.
만일, 개발 중에 세부정보를 확인하고 싶다면 spring.mvc.log-request-details 프로퍼티 값을 true로 설정해주면 관련 정보를 로그로 출력할 수 있습니다.
(단, payload 값은 노출되지 않습니다.)

application.yml 을 아래와 같이 설정한 후 로깅 출력값을 확인해봅시다.

spring:
  application:
    name: spring-boot

  mvc:
    log-request-details: true

logging:
  level:
    root: info
    web: debug
    org.springframework.web: trace

3.1. `spring.mvc.log-request-details: true`

2024-09-26T10:05:24.404+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : POST "/hello?version=2", parameters={version:[2]}, headers={user-agent:[vscode-restclient], content-type:[application/json], accept-encoding:[gzip, deflate], content-length:[64], cookie:[SESSION=MjczMGI1YTUtZWU0YS00MDNjLWFiM2MtYTljMDQ4ODI5ZTQ2], host:[localhost:8080], connection:[keep-alive]} in DispatcherServlet 'dispatcherServlet'
2024-09-26T10:05:24.410+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped to me.jiniworld.springboot.TttController#hello(User)
2024-09-26T10:05:24.447+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] m.m.a.RequestResponseBodyMethodProcessor : Read "application/json;charset=UTF-8" to [User(2): jini]
2024-09-26T10:05:24.450+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] o.s.web.method.HandlerMethod             : Arguments: [User(2): jini]
2024-09-26T10:05:24.453+09:00 DEBUG 75476 --- [spring-boot] [nio-8080-exec-1] m.m.a.RequestResponseBodyMethodProcessor : Using 'text/plain', given [*/*] and supported [text/plain, */*, application/json, application/*+json]
2024-09-26T10:05:24.453+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] m.m.a.RequestResponseBodyMethodProcessor : Writing ["jini, jiniworld.me"]
2024-09-26T10:05:24.455+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] s.w.s.m.m.a.RequestMappingHandlerAdapter : Applying default cacheSeconds=-1
2024-09-26T10:05:24.455+09:00 TRACE 75476 --- [spring-boot] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : No view rendering, null ModelAndView returned.
2024-09-26T10:05:24.456+09:00 DEBUG 75476 --- [spring-boot] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed 200 OK, headers={Content-Type:[text/plain;charset=UTF-8], Content-Length:[18], Date:[Thu, 26 Sep 2024 01:05:24 GMT], Keep-Alive:[timeout=60], Connection:[keep-alive]}

3.2. `spring.mvc.log-request-details: false`

2024-09-26T10:13:15.843+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : POST "/hello?version=2", parameters={masked}, headers={masked} in DispatcherServlet 'dispatcherServlet'
2024-09-26T10:13:15.847+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped to me.jiniworld.springboot.TttController#hello(User)
2024-09-26T10:13:15.884+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] m.m.a.RequestResponseBodyMethodProcessor : Read "application/json;charset=UTF-8" to [User(2): jini]
2024-09-26T10:13:15.887+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] o.s.web.method.HandlerMethod             : Arguments: [User(2): jini]
2024-09-26T10:13:15.890+09:00 DEBUG 75731 --- [spring-boot] [nio-8080-exec-1] m.m.a.RequestResponseBodyMethodProcessor : Using 'text/plain', given [*/*] and supported [text/plain, */*, application/json, application/*+json]
2024-09-26T10:13:15.890+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] m.m.a.RequestResponseBodyMethodProcessor : Writing ["jini, jiniworld.me"]
2024-09-26T10:13:15.892+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] s.w.s.m.m.a.RequestMappingHandlerAdapter : Applying default cacheSeconds=-1
2024-09-26T10:13:15.892+09:00 TRACE 75731 --- [spring-boot] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : No view rendering, null ModelAndView returned.
2024-09-26T10:13:15.893+09:00 DEBUG 75731 --- [spring-boot] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed 200 OK, headers={masked}

4. Hot swapping

Spring Boot는 JVM의 hot swap기능을 지원합니다.
hot swap은 코드 변경사항이 감지되면 애플리케이션을 자동으로 로드하는 기능으로, 클래스파일의 변동사항을 핫스왑하거나 정적 리소스 파일을 리로드 하는 기능을 제공합니다.

IntelliJ 와같은 IDE를 이용하여 개발하는 중에 활용하여 개발 능률 향상 목적으로 사용합니다.

IntelliJ 를 사용하는 경우, 앱 실행에 대한 구성설정에서 관련 설정을 할 수 있습니다.

On 'Update' action, On frame deactivation 옵션 설정을 변경하여 핫스왑 관련 기능을 사용할 수 있는데
설정값에 따라 컨테이너의 재시작 없이 정적 리소스와 클래스의 리로드 하여 개발의 편의성을 올려 줍니다.

4.1. 정적 리소스 리로드

spring boot에서는 hot reload를 위한 몇가지 옵션을 제공합니다.
그 중 가장 추천하는 방식은, spring-boot-devtools 를 활용하여 빠른 애플리케이션 재시작을 이용하여 개발 능률을 향상시키는 것입니다.

devtools 는 classpath에서 변경사항을 모니터링하여 변경사항이 있을 시 작동합니다.

정적 리소스 변경사항의 적용을 위해서는, 프로젝트의 build 과정이 필수이지만, default restart exclusions에 의해 정적 리소스는 변경사항이 생겨도 재시작을 하지 않습니다. (다만 livereload는 작동됩니다.)

spring:
  devtools:
    restart:
      enabled: true
      additional-exclude: ttt/**,**/Ttt*.class

spring.devtools.restart.exclude, spring.devtools.restart.additional-exclude 프로퍼티 설정으로 default restart exclusions를 수정할 수 있습니다.

4.2. 컨테이너 재시작 없이 템플릿 뷰 로드

Spring Boot 에서 지원하고 있는 템플릿의 캐싱 비활성화 옵션을 제공하여, 템플릿 뷰의 수정사항 발생시, 컨테이너 재시작 없이 갱신된 사항을 로드할 수 있게 해줍니다.

예를들어, Thymeleaf 템플릿을 이용하는 경우, spring.thymeleaf.cache 를 false로 설정할 경우, 서버 재시작 없이 템플릿의 변경사항을 로드할 수 있습니다.

spring:
  thymeleaf:
    cache: false

FreeMarker 템플릿을 사용한다면 spring.freemarker.cache, Groovy 템플릿을 사용한다면 spring.groovy.template.cache 에 설정하면 됩니다.

4.3. 빠른 애플리케이션 재시작

devtools에는 자동 애플리케이션을 재시작을 지원합니다.

devtools를 이용한 restart에서는 2개의 클래스 로더를 이용하여 재시작을 하며,
외부 라이브러리의 경우에는 기존에 채워져있는 것을 그대로 사용하고(기본 클래스로더에 로드되어있음) 개발자가 직접 작성한 클래스들만 재시작 클래스로더에 재로드하여 재시작합니다.

JRebel과 같은 기술만큼 빠르지는 않지만, 일반적으로 "cold start" 보다는 빠릅니다.
(cold start는 일반적으로 애플리케이션을 종료하고 새로 시작하는 것을 의미합니다.)

4.4. 컨테이너 재시작 없이 java 클래스 리로드

IntelliJ IDEA, Eclipse 등 최신 IDE에서는 bytecode의 핫 스와핑을 지원하고 있습니다.

class나 method의 시그니처에 영향을 미치지 않는 수준의 변경이 일어난 경우에는 컨테이너의 재시작없이 리로드하여 수정사항을 즉각 반영해줍니다.

class나 method의 시그니처에 영향을 미친 경우에는 재시작없이 리로드 사항이 반영되지 않습니다.

새로운 메서드가 추가 또는 삭제 되는 경우 아래와 같은 팝업 노출과 함께 핫스왑이 실패됩니다.

api url의 변경과 같은 시그니처 변경시에는 별도의 실패 팝업은 뜨지 않지만 리로드는 되어도 api 변경이 반영되지 않습니다.

5. 자동 restart

spring-boot-devtools 를 사용하는 애플리케이션은 classpath 파일이 변경될때마다 재시작합니다. (재시작 할 때, 수정된 파일에 대해 다시 컴파일 한 후 재시작 됩니다.)

이는, IntelliJ와 같은 IDE로 개발을 할 때에, 변경사항을 빠르게 반영해주기 때문에 편리합니다.

단, AspectJ weaving 을 사용할 때엔 자동 재시작을 지원하지 않습니다.

5.1. Restart vs Reload

spring boot에서 제공하는 재시작은 2개의 클래스로더에 의해 작동합니다.
dependency를 통해 이용하고 있는 타사 jar 클래스들은 변경되지 않는 클래스로, 기본 클래스로더(base classloader)에 로드됩니다.
그리고, 개발중인 클래스들은 재시작 클래스로더(restart classloader)에 로드됩니다.

애플리케이션이 재시작될 때, 재시작 클래스로더는 사라지고 새로운 클래스 로더가 생성됩니다.
기본 클래스로더는 기존에 채워져있는 것을 그대로 사용하기 때문에, 애플리케이션 restart는 일반적으로 "cold starts" 보다 훨씬 빠릅니다.

애플리케이션의 재시작이 너무 느리거나, 클래스로딩에 문제가 있다면 JRebel 같은 재로딩 기술을 고려해보는 것도 좋습니다.

5.2. condition evalutaion에서 변경사항 로깅

기본적으로 애플리케이션이 재시작할 때, 조건 평가 델타를 보여주는 보고서가 기록됩니다.
이 보고서에는 빈의 추가나 제거, 구성설정의 변경 등에 대한 변경 사항이 들어있습니다.

컨테이너 restart시 보고서 로깅을 비활성화하고 싶다면 spring.devtools.restart.log-condition-evaluation-delta 값을 false로 설정하면 됩니다.

아래는 condition evalutaion delta의 예시입니다.

2024-09-30T13:42:56.365+09:00 DEBUG 35798 --- [spring-boot] [  restartedMain] .s.b.a.l.ConditionEvaluationReportLogger :


============================
CONDITIONS EVALUATION REPORT
============================


Positive matches:
-----------------

   AopAutoConfiguration matched:
      - @ConditionalOnProperty (spring.aop.auto=true) matched (OnPropertyCondition)

   AopAutoConfiguration.ClassProxyingConfiguration matched:
      - @ConditionalOnMissingClass did not find unwanted class 'org.aspectj.weaver.Advice' (OnClassCondition)
      - @ConditionalOnProperty (spring.aop.proxy-target-class=true) matched (OnPropertyCondition)

   ApplicationAvailabilityAutoConfiguration#applicationAvailability matched:
      - @ConditionalOnMissingBean (types: org.springframework.boot.availability.ApplicationAvailability; SearchStrategy: all) did not find any beans (OnBeanCondition)

      ...

Negative matches:
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'jakarta.jms.ConnectionFactory' (OnClassCondition)

...         

Exclusions:
-----------

   None


Unconditional classes:
----------------------

   org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration

   org.springframework.boot.autoconfigure.ssl.SslAutoConfiguration

   org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration

   org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration

   org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration

   org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration

5.3. 리소스 제외

특정 리소스의 경우, 수정사항이 발생되었다 하더라도 반드시 재시작이 될 필요가 없습니다. (ex. thymeleaf 템플릿)

기본적으로, /META-INF/maven, /META-INF/resources, /resources, /static, /public, /templates 디렉토리 내의 리소스들은 변경사항이 있어도 재시작이 되지 않습니다. (하지만, live reload의 경우, 해당 디렉토리 내의 리소스 변경이 있을 시 재시작됩니다.)

String DEFAULT_RESTART_EXCLUDES = "META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**,**/*Test.class,**/*Tests.class,git.properties,META-INF/build-info.properties";

만일, 이 리소스 디렉토리들을 변경하고 싶다면, spring.devtools.restart.exclude 에 설정해주면 되고, 기본값을 유지하면서 리소스 제외값을 추가하고 싶다면 spring.devtools.restart.additional-exclude 프로퍼티 값을 추가해주면 됩니다.

spring:
  application:
    name: spring-boot

  devtools:
    restart:
      log-condition-evaluation-delta: false
      additional-exclude: /ttt/**,**/*Test.class

5.4. restart 비활성화

재시작 기능을 비활성화 하고 싶다면, spring.devtools.restart.enabled 값을 false 로 설정하면 됩니다.

프로퍼티값을 통해 restart 비활성화 시킬 경우, 재시작 클래스로더가 초기화된 후, 파일 변경 사항을 감시하지 않아 컨테이너 재시작이 되지 않습니다.

만일, 완전한 restart 비활성화를 설정하고 싶다면, 코드상에 시스템 설정값을 통해 spring.devtools.restart.enabled 값을 false로 설정하면 됩니다.

@SpringBootApplication
public class MyApplication {

	public static void main(String[] args) {
		System.setProperty("spring.devtools.restart.enabled", "false");
		SpringApplication.run(MyApplication.class, args);
	}

}

5.5. 알려져있는 제한사항

restart 기능은 표준 ObjectInputStream 을 이용한 역직렬화된 객체에서 잘 작동되지 않습니다.

만약 데이터 역직렬화가 필요한 경우라면, Spring 의 ConfigurableObjectInputStream를 Thread.currentThread().getContextClassLoader() 와 함께 사용해야할 수 있습니다.

몇몇 3rd party 라이브러리들에서 context classloader를 고려하지 않고 역직렬화하는 경우가 있어, 이 부분을 유의해야합니다.

6. 애플리케이션의 프로덕션 배포를 위한 패키징

애플리케이션을 프로덕션 환경에 배포하기 위해서는 패키징을 해야합니다.
스프링 부트에서는 애플리케이션 패키징을 최적화하기 위한 다양한 옵션을 제공합니다.

프로덕션 환경에 health check, REST 메트릭, JMX end-point, spring actuator 등을 추가하는 것을 고려해보세요.

++

Hot Swap failed. SpringBootApp: add method not implemented
Hot Swap failed. SpringBootApp: delete method not implemented

Amazon ElastiCache & Memory DB

jiniya22 — Wed, 22 May 2024 18:03:22 +0900

실시간 애플리케이션을 위한 실시간 성능.

※ 2024년 4월 16일 AWS Database Introductory Training - Amazon ElastiCache 교육의 내용을 정리한 포스팅입니다.

ElasticCache
Amazon Memory DB for Redis
Amazon ElasticCache Common In-Memory Use Cases

1. Amazon ElastiCache

현대화가 진행될 수록 총 비용(TCO, total cost of ownership)을 절감할 수 있고,
이에 의해 시간도 절감할 수 있습니다.

실시간 서비스를 위해서는 microseconds로 데이터에 접근할 수 있어야 합니다.

microseconds로 데이터에 접근하기 위해서는 캐시를 활용해야 합니다.

다음과 같은 경우에는 캐시를 사용하는 것을 고려해보는것이 좋습니다.

동일한 쿼리가 빈번히 발생되는 경우
읽기 지연시간이 높은 경우
높은 I/O 나 과도한 읽기로 인한 비용을 절감하고 싶은 경우

캐시를 쓰게 되면 다음과 같은 주요 이점들이 있습니다.

규모에 따른 예측가능한 비용을 보장하여, 총 비용을 절감할 수 있다
별도의 I/O 수수료가 없습니다 (인스턴스당 수수료만 지불하면 됩니다.)
DB 부하를 줄여 애플리케이션 응답 시간을 향상시킵니다
읽기 처리량을 확장시킬 수 있습니다.

이러한 이점들을 고려하여, FE가 BE에 접근하지 않고 캐시를 이용하게 되면 BE 부담도 줄이면서 빠르게 데이터 접근이 가능하게 됩니다.

redis나 memcached를 직접 설치하는 경우, 유지보수나 scale out에 어려움이 크고 장애 대응이 까다로운 반면 ElastiCache를 사용하게 되면 아래와 같은 측면에서 장점이 큽니다.

성능 및 확장성
고가용성 및 엔터프라이즈 보안
총비용 감소
Fully-managed
- 레디스 Api를 완전 지원하기 때문에 유연하게 접근이 가능합니다.
오픈소스 호환을 지원
- EKS, lambda 등과 연동하여 사용 가능

또, 오랫동안 접속하지 않은 데이터들은 하드에 저장하여 비용을 절감시켜주는 data tiering 기능도 제공하고 있습니다.

ElastiCache는 적용할 수 있는 사용 예시로는 아래와 같은 서비스들이 있습니다.

microseconds로 데이터에 접근되어야하는 서비스
실시간 데이터 분석 서비스
실시간으로 지리적 정보를 계산하여 거리감 등을 계산하는 Geospatial
미디어 스트리밍
실시간 랭킹 조회

Amazon ElastiCache Serverless

기존 ElastiCache와의 차이점은
설정을 해두고, 요청이 오면 요청 오는만큼 처리되는 것으로, 인프라 관리 없이 매우 빠르게 고가용성 캐시 생성이 가능하여 애플리케이션 액세스 패턴에 따라 즉각적인 확장이 가능합니다.

매우 빠르게 생성할 수 있으나, 기본 엘라스틱캐시보다 비용이 조금 더 비쌉니다.
요청하는 만큼 비용이 듭니다.

2. Amazon MemoryDB for Redis

Amazon Memory DB for Redis는 아래와 같은 주요 특징을 가지고 있습니다.

성능 및 확장성
뛰어난 내구성(durability) 및 고가용성
엔터프라이즈 보안
Fully-managed
오픈소스 호환을 지원

ElastiCache와 특징이 거의 유사하지만, 내구성에 대한 차이점이 있습니다.
Amazone MemoryDB for Redis는 트랜잭션 로그에 커밋해두기 때문에 다운되어도 복구가 가능합니다.(데이터가 휘발되지 않습니다)

때문에, 내구성이 필요하지 않고 일시적으로 저장되는 데이터는 ElastiCache를 활용해야하고, 빠른 access 속도가 필요하지만 내구성도 필요하다면 Amazon MemoryDB for Redis를 사용하는 것이 좋습니다.

AWS에서 제공하고 있는 In-Memory DB들은 아래와 같은 차이점을 가지고 있습니다.

Elastic for Memcached는 failover 지원도 안하고, 데이터타입도 string만 지원하지만, 멀티스레드를 지원합니다.

다만, 멀티스레드도 결국 cpu자원을 이용하는 것이기 때문에 때에 따라 더 느려질 수 있기 때문에 무조건 장점이라고 생각할 수 없습니다.

ElastiCache for Redis는 스냅샷을 이용하여 복구를 지원하기 때문에 memcached 보다는 내구성이 좋지만, 전원이 나갈 경우 데이터가 휘발되는 정보로 영속성은 없습니다.

MemoryDB for Redis는 트랜젝션 로그를 활용하여 영속성을 지원하여 내구성이 좋습니다.

3. Amazon ElasticCache Common In-Memory Use Cases

3.1. caching

디스크 기반의 데이터베이스와 애플리케이션에서 데이터를 검색하는 것은 속도가 느립니다.

microseconds 의 지연시간과 높은 처리량을 위해서는 자주 사용하는 데이터를 In-Memory DB인 레디스에 저장하는것을 권장합니다.

주로 캐싱하는 종류로는 쿼리캐싱이나 전체 웹페이지 캐싱이 있습니다.

• 쿼리 캐싱(관계형, 비관계형, 객체, JSON, XML, 검색, 그래프, API)
• 전체 웹 페이지 캐싱(대부분의 앱 서버와 간단한 통합 모듈)

캐싱에서 소개되는 TTL과 evctions 에 대해 알아보자면

TTL은 지정한 시간이 지날 경우 바로 만료처리가 되는 것이 아니라 지정한 시간동안 데이터가 유지되는것을 보장하는 설정입니다.

TTL은 각 키를 생성 또는 수정할 때 명시적으로 할당하는 값으로, 글로벌 속성이 아닙니다.
또, 일부 키에는 TTL 설정이 필요하지 않을 수 있습니다.

또, 메모리가 꽉찼을 경우, 자동으로 제거하기 위한 Evictions 정책이 있습니다.
어떤 기준에 따라 키를 제거할 것인지 정책을 지정할 수 있습니다.

redis의 key는 해시함수를 이용하여 저장하기 때문에 키이름을 일부러 어렵게 설정할 필요 없습니다.

3.2. Leaderboards

리더보드는 변화하는 점수와 순위를 실시간으로 업데이트해야합니다.
따라서, 낮은 지연시간과 짧고 동시성이 높은 데이터 저장소인 레디스를 사용하는 것이 좋습니다.

게임 랭킹 시스템이나, 많이팔린 상품 등이 관련된 서비스라고 볼 수 있습니다.

sorted set 데이터 구조를 이에 활용하면 좋습니다.
아래와 같이 리더보드에 사용자의 활동점수를 합산하면 아주 간단하게 리더보드 구현이 가능합니다.

점수를 합산하거나 특정 구매기록을 쌓는 등의 기록을 쌇는 저장소로 no sql을 사용하여
히스토리가 쌓일 경우 이벤트로 score를 redis에 업데이트하도록 하면

별도의 연산없이 바로 읽어서 서비스를 할 수 있게 해줍니다.

이는, 화면의 UI와 서비스 특성에 따라 달라질 수 있는데

만약, 반드시 페이지 이동이 되어야하는 서비스라면, 위와 같은 구조로 서비스하는 것이 불가능합니다.
페이징 처리가 된다는 것은 결국 총 count를 알아야하기 때문에 이 경우에는 RDB를 쓰는 것이 더 합리적입니다.
(대표적으로 admin페이지)

리더보드나, 페이스북/인스타그램 피드, 구글 검색 결과 등과 같이 페이징 형태가 아닌 load more 형태로 다음 데이터를 불러오는 형태의 UI로 구성하는 데이터 부담이 줍니다.

Geospatial

배달업체. 특정 반경 안에 있는 가게를 알려줘
택시
- 주기적으로 택시들에 대한 실시간 위치를 트래킹 해야합니다.
- 500m 반경에 있는 택시 조회
내 위치에서 가까이에 있는 편의점
- dynamoDB에 기존 위치정보를 저장

실시간으로 변경되는 택시나 배달업체 위치 정보 등은 쓰기 트래픽이 빈번하고 많을 때에는, rdb 로는 구성이 어렵습니다. 이 경우에는 no sql를 활용해야 합니다.

Chat & Message 비권장

redis의 pub/sub
브로드캐스팅 방식
노드가 여러개일 경우, 여러개의 노드에게 메시지를 전달해야하는 부분때문에 성능이 떨어질 수 있습니다.
(노드가 많아질수록 성능이 떨어질수 있다)

shadded pub/sub 하나의 샤드에서만 pub/sub을
클러스터 n개의 샤드를

Message Queue
failover가 발생되었을 때 데이터 유실이 발생됩니다 -> 유실되면 안된다면 sqs를 사용하는것을 권장

Machine Learning

dynamodb에 매일 전 유저의 정적 추천목록을 갱신하여,
접속시 그 추천목록을 바로 서빙합니다.
사용하면서 클릭한 정보를 기반으로 추천정보를 위한 데이터를 수집합니다.(동적)

sorted set을 이용하여, 저장되어있는 추천목록을 서빙

[Effective Java] Item57~67. 일반적인 프로그래밍 원칙

jiniya22 — Sun, 19 May 2024 21:28:25 +0900

Item 57. 지역변수의 범위를 최소화 하라

지역변수를 사용하기 직전에, 지역변수를 선언하는 것이 좋으며
가능한 선언과 동시에 초기화하는 것이 좋습니다.

while문 같이, 변수를 외부에 선언하는 문법보다는
for문을 이용하여, for문 블럭 내에서 지역변수를 선언하고, 그 블럭 내에서만 해당 지역변수를 사용하게 만드는 것이 bug를 유발하지 않기에 더 좋은 코드입니다.

메서드는 작게 유지하고, 각 메서드당 하나의 기능에 집중하게 만들자

Item 58. 전통적인 for문 보다는 for-each문을 사용하라

전통적으로 for문을 사용하는 아래와 같은 방식이 있습니다.

for (Iterator<Element> i = c.iterator(); i.hasNext(); ) {
  Element e = i.next();
  ...
}

for (int i = 0; i < a.length; i++) {
  ...
}

이러한 for문은 while문보다는 낫지만, for문 내에서 정의한 지역변수 요소들을 사용해야할 것이 아니라면 아래와 같은 이유의 단점들이 존재합니다.

for 선언에 쓰이는 요소들이 많아지는 만큼, 그에 의한 오류가 발생시킬 수 있는 가능성도 높아집니다.
for를 적용할 대상이 달라짐에 따라 작성법이 달라지는 불편함이 존재합니다. (컬렉션, 배열)

인덱스나 반복자를 사용하지 않아도 된다면, 향상된 for문을 사용하는 것이 가독성 측면에서도 좋고,
for 적용대상이 컬렉션이든 배열이든 관계없이 동일한 문법 구조로 작성하는 것이 가능합니다.

또, 전통적인 for문과 비교했을 때 성능적인 차이점도 없습니다.

for(Element e: elements) {
  ...
}

다만, 아래의 상황에서는 향상된 for문을 사용할 수 없기 때문에 전통적인 for문을 사용해야 합니다.

컬렉션을 순회하면서 선택된 원소를 제거해야하는 경우.
- Java8 이상부터 지원하는 Colleciton 클래스의 removeIf 메서드로 컬렉션을 명시적으로 순회하는 것을 피할 수 있습니다.
리스트나 배열을 순회하면서 그 원소의 값의 일부나 전체를 교체해야하는 경우
- 이 경우에는 리스트의 반복자나 배열의 인덱스를 사용해야합니다.
여러 컬렉션을 병렬로 순회해야하는 경우

Item 60. 정확한 답이 필요하다면 float와 double은 피하라

float와 double은 과학/공학 계산용으로 설계된 것으로, 이진 부동소수점 연산에 사용됩니다.
넓은 범위의 수를 빠르고 정밀한 근사치로 계산하기 때문에, 정확한 계산 결과가 필요할 때 사용하면 안됩니다.

특히, 금융 관련 계산에서는 사용하지 않아야 합니다.

float/double은 0.1 이나 음의 거듭제곱( $10^{-1}$ , $10^{-2}$ )을 표현할 수 없습니다.

예를들어, 1.01 - 0.33 = 0.68 이 나와야하지만
java에서는 0.6799999999999999를 출력합니다.

System.out.println(1.01 - 0.33);

0.6799999999999999

아래의 계산 결과도 0.2가 아닌 근사치가 출력됩니다

System.out.println(1.00 - 8 * 0.10);

0.19999999999999996

double 자료형을 정확한 계산이 필요한 금융 계산에 적용할 경우, 잘못된 결과가 발생될 수 있습니다.

double funds = 1.00;
int itemsBought = 0;
for (double price = 0.10; funds >= price; price += 0.10) {
    funds -= price;
    itemsBought++;
}
System.out.println(itemsBought + " items bought.");
System.out.println("Change: $" + funds);

3 items bought.
Change: $0.3999999999999999

이 경우, BigDecimal로 교체할 경우 정확한 결과를 도출할 수 있습니다.
다만, BigDecimal은 기본 타입에 비해 속도가 느리고 사용 방법이 직관적이지 않다는 단점이 있습니다

final BigDecimal TEN_CENTS = new BigDecimal(".10");
int itemsBought = 0;
BigDecimal funds = new BigDecimal("1.00");
for (BigDecimal price = TEN_CENTS; funds.compareTo(price) >= 0; price = price.add(TEN_CENTS)) {
    funds = funds.subtract(price);
    itemsBought++;
}
System.out.println(itemsBought + " items bought.");
System.out.println("Change: $" + funds);

4 items bought.
Change: $0.00

만약 계산법을 십진수로 표현이 가능하면서, 계산에 필요한 수가 너무 크지 않다면 int 나 long 타입으로 변경하여 계산하는 것도 방법입니다.
숫자를 9자리 십진수로 표현할 수 있다면 int 자료형을, 18자리 십진수로 표현할 수 있다면 long 타입을 사용하면 됩니다.

만일 18자리수롤 넘어간다면 BigDecimal을 사용해야 합니다.

위의 예제 코드에서는 달러 체계에서 센트 단위로 변경한 후, 자료형을 int로 변경하여 계산을 할 수 있습니다.

int funds = 100;
int itemsBought = 0;
for (int price = 10; funds >= price; price += 10) {
    funds -= price;
    itemsBought++;
}
System.out.println(itemsBought + " items bought.");
System.out.println("Change: " + funds + " cents");

4 items bought.
Change: 0 cents

61. 박싱된 타입 보다는 primitive 타입을 사용하라

java에서 데이터 타입은 primitive(기본) 타입 (int, long, float, double) 과 reference 타입(String, Map, List, Double, Integer) 이 있습니다.

primitive 타입을 List 나 Map에서 활용하기 위해 사용되는 것이 boxing 된 기본타입들이 있는데, Integer, Long, Float, Double이 이에 해당됩니다.

java에서는 auto boxing, auto unboxing을 제공하고 있어 기본타입과 박싱된 기본 타입을 구분하지 않고 혼용해서 사용할 수 있지만, 두 타입에는 차이점이 있습니다.
따라서, 두 타입의 차이점을 명확히 알고 타입을 적절하게 사용하는 것이 좋습니다.

61.1. 차이점

기본 타입은 값만 가지고 있으나, 박싱된 기본타입은 값과 식별성(identity) 속성을 가지고 있습니다
- 식별성은 값이 동일하더라도 서로 다른 값임을 판단하는 속성입니다. 박싱된 기본타입도 reference 타입의 일종이므로 값으로 동일성을 판단하는 것이 아니라 주소값으로 동일값임으로 판단합니다.
기본타입은 유효한 값만을 담을 수 있지만, 박싱된 기본타입의 기본값은 유효하지 않은 값도 담을 수 있습니다.
- 박싱된 기본값은 null 도 담을 수 있습니다.
기본타입이 시간과 메모리 사용면에서 더 효율적입니다.

61.2. 박싱된 기본타입 사용시 주의점

기본타입과 박싱된 기본타입을 혼용해서 사용할 경우, 자동으로 unboxing 되기 때문에, null이 들어올 수 있는 상황에 대한 예외처리를 해야합니다.

예를 들어 아래와 같은 코드가 있다고 할때,
i는 초기화가 되어있지 않기 때문에 null이 들어있는 상태입니다.
null값은 10과 같지 않기 때문에 출력문이 출력될 것이라고 생각할 수 있으나

이 값을 기본타입 10과 비교하려 할때, 자동 unboxing 되면서 null값을 기본타입으로 변환하려 시도하게 되고
이 때, NullPointerException이 발생되게 됩니다.

static Integer i;

public static void main(String[] args) {
	if(i != 10)
		System.out.println("이게 출력될까요?");
}

비슷한 이유로, 아래의 코드도 오류가 발생될 수 있습니다.

정수형 수를 오름차순으로 정렬하고자 아래의 크드를 만들었으나
얼핏보기에는 코드상으로 이상이 없어보이지만, 만일 비교대상이 null이 들어왔을 경우에 대한 예외처리가 빠져있어, 적용 대상에 null이 들어있을 경우 NullPointerException을 발생시킵니다.

Comparator<Integer> naturalOrder = (i, j) -> i < j ? -1 : (i == j ? 0 : 1);

또, 박싱된 기본타입을 사용하는 것은 객체를 생성하는 것이기에 이에의한 연산적 측면에서의 오류를 범할 수 있습니다.

참고로, Java9 버전부터는 박싱된 기본타입을 생성자를 통해 생성하는 것을 막고 있기 때문에
동일한 수를 담고 있는 두 숫자 객체의 비교에 대한 예상치 못한 부작용은 해소되었습니다.

@Deprecated(since="9", forRemoval = true)
public Integer(int value) {
	this.value = value;
}

63. 문자열 합성이 빈번할 경우 StringBuilder를 사용하자

여러개의 문자열을 합치는 것은 + 연산자를 사용하는 것으로도 손쉽게 가능합니다.

String s1 = "apple"
String s2 = "tree"
String result = s1 + s2;

다만, 문자열을 + 연산자로 잇는 행위는 성능이 좋지 않습니다.
n개의 문자열을 + 연산자로 연결하는데에 드는 시간복잡도는 $O(n^2)$ 입니다.

문자열은 불변객체 일종이기 때문에 잇는 연산이 발생할 때마다 매번 새로운 객체에 복사하는 행위를 하기 때문입니다.

그렇기 때문에, 이어야하는 항목이 많을 경우라면 StringBuilder 를 사용하는 것이 좋습니다.

static String ex01(List<String> list) {
	StringBuilder builder = new StringBuilder();
	for (String s : list) {
		builder.append(s);
	}
	return builder.toString();
}

67. 최적화는 신중히 하라

성능때문에 견고한 구조를 희생해서는 안됩니다.
빠른 프로그램보다는 좋은 프로그램을 작성하는 것이 더 좋습니다.

좋은 프로그램이지만 원하는 성능이 나오지 않는다면, 아키텍처 자체가 최적화할 수 있는 길을 안내해줄 것입니다.

좋은 프로그램은 정보 은닉 원칙을 따르고, 그렇기 떄문에 개별 구성요소를 각각 독립적으로 설계할 수 있게 됩니다.
따라서 시스템의 나머지에 영향을 주지 않고도 각 요소를 다시 설계할 수 있게 합니다.

속도적 최적화 문제는 추후 얼마든지 해결할 수 있는 문제이지만
아키텍쳐적 결함은 시스템 전체를 재작성하지 않고서는 해결하기 어려운 상황이 많습니다.
성능을 제한하는 설계는 피해야합니다.

외부 시스템과 소통하는 방식은 추후 변경하기가 어렵습니다.
따라서 초반에 설계하는 단계에서 이 부분을 유의하여 설계해야합니다.

[Effective Java] Item18. 상속보다는 컴포지션을 사용하라

jiniya22 — Sun, 17 Mar 2024 15:35:08 +0900

(구체 클래스를 확장하는) 상속은 캡슐화를 깨뜨리는 특성입니다.

상위 클래스의 새로운 릴리즈로 내부 구현의 변경이 생겼을 때,
- 그를 구현한 커스텀 구현 클래스에서 예기치 못하는 오동작을 만날 수 있습니다.
상위 클래스에서 새로운 메서드를 추가했을 때,
- 기존에 특정 validation 조건을 만족해야만 값을 추가할 수 있는 구현 클래스가 있었다고 할 때, 상위 클래스의 새로운 릴리즈 버전에서 추가된 메서드가 validation 체크 없이 데이터를 넣을 수 있는 우려도 발생될 수 있습니다.
- 기존에 이용하고 있던 커스텀 구현 클래스에서 그 메서드와 똑같은 시그니쳐를 가진 메서드를 보유하고 있을 경우 기존에 잘 되던 동작도 되지 않을 수 있고, 디버깅도 까다롭습니다

1. 상속의 문제점

상속의 문제점에 대해 알아 볼 수 있는 예제를 확인해봅시다.

아래 코드는
HashSet의 add, addAll 함수를 통해 추가된 요소의 수를 구하고자 addCount 라는 필드값의 추가하여 기능을 수행하는 코드 예제 입니다.

@Getter
public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;

    public InstrumentedHashSet() {
    }
    public InstrumentedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
    }

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }
}

add나 addAll함수를 호출한 횟수를 출력하고자합니다.
아래의 실행코드에서 우리가 원하는 결과값은 4이지만 놀랍게도 7이 출력되는것을 확인할 수 있습니다.

static void ex1() {
    InstrumentedHashSet<Integer> s = new InstrumentedHashSet<>();
    s.add(3);
    s.addAll(List.of(5, 6, 8));
    System.out.println(s.getAddCount());
}

이는, HashSet에서 사용하고 있는 addAll함수 내에서 add함수를 호출하기 때문에 발생된 문제입니다.
그 때문에,

public boolean addAll(Collection<? extends E> c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

우리가 새로 추가한 addCount라는 필드값은 기존에 Set, HashSet 컬렉션에서 요구하는 구조와 벗어났기 때문에 발생된 문제입니다.

기존에 제공되고 있는 라이브러리를 활용하면서, 기능을 확장하고 싶다면
상속을 통한 기능 확장보다는, 기존 클래스의 구성요소를 새로운 클래스의 구성요소로 사용되는 Composition(구성) 방식을 사용하는 것이 좋습니다.

2. 컴포지션을 사용한 예제

Set을 필드로 갖고, Set으 기능을 그대로 사용하는 전달용 클래스를 하나 만듭니다.
내부에 갖고 있는 모든 메서드는 Set에 정의된 함수를 그대로 사용합니다.

package me.jiniworld.effectivejava.item18;

import java.util.Collection;
import java.util.Iterator;
import java.util.Set;

public class ForwardingSet<E> {
    private final Set<E> s;

    public ForwardingSet(Set<E> s) {
        this.s = s;
    }

    public void clear() {
        s.clear();
    }

    public boolean contains(Object o) {
        return s.contains(o);
    }

    public boolean isEmpty() {
        return s.isEmpty();
    }

    public int size() {
        return s.size();
    }

    public Iterator<E> iterator() {
        return s.iterator();
    }

    public boolean add(E e) {
        return s.add(e);
    }

    public boolean remove(Object o) {
        return s.remove(o);
    }

    public boolean containsAll(Collection<?> c) {
        return s.containsAll(c);
    }

    public boolean addAll(Collection<? extends E> c) {
        return s.addAll(c);
    }

    public boolean removeAll(Collection<?> c) {
        return s.removeAll(c);
    }

    public boolean retainAll(Collection<?> c) {
        return s.retainAll(c);
    }

    public Object[] toArray() {
        return s.toArray();
    }

    public <T> T[] toArray(T[] a) {
        return s.toArray(a);
    }

    @Override
    public boolean equals(Object o) {
        return s.equals(o);
    }

    @Override
    public int hashCode() {
        return s.hashCode();
    }

    @Override
    public String toString() {
        return s.toString();
    }
}

그리고 위에서 생성한 포워딩클래스를 필드로 갖는 컴포지션 클래스를 생성합니다.

여기에서, addAll함수는 ForwardingSet에 정의해둔 addAll 함수를 사용하기 때문에, InstrumentedSet에서 정의한 add를 호출하지 않습니다.

@EqualsAndHashCode(callSuper = false)
@Getter
public class InstrumentedSet<E> extends ForwardingSet<E> {
    private int addCount = 0;
    public InstrumentedSet(Set<E> s) {
        super(s);
    }

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }
}

따라서, 아래의 실행결과는 우리가 원하는 대로 4가 출력되는 것을 확인할 수 있습니다.

static void ex2() {
    InstrumentedSet<Integer> s = new InstrumentedSet<>(new HashSet<>());
    s.add(3);
    s.addAll(List.of(5, 6, 8));
    System.out.println(s.getAddCount());
}

기능을 확장하고 싶다면 상속보다 컴포지션 방식을 사용하는 것을 권장합니다.

상속을 사용하기 전에 아래 2가지를 먼저 체크해야합니다.

확장하고자 하는 기능을 has-a 방식(컴포지션)으로 구현할 수 있는지 체크해야 하고
확장하고자 하는 클래스에 들어있있는 기능들이 결함이 없는지 반드시 체크해야 합니다.
- 상속을 하게 되면, 상위 클래스의 결함도 그대로 전파됩니다.

[Effective Java] Item17. 불변클래스를 이용하여 변경가능성을 최소화 하라

jiniya22 — Sat, 16 Mar 2024 21:43:28 +0900

불변 클래스는 단순합니다.

그렇기 때문에 가변클래스보다 설계/구현/사용이 쉽습니다.

불변 객체는 생성시점부터 사용을 마치는 시점까지 값을 그대로 유지하기 때문에, 예상치 못한 오류를 방지할 수 있어서 안전합니다.
ThreadSafe하고, 여러 스레드가 동시에 사용하더라도 훼손되지 않으며, 재활용이 편리합니다.

클래스를 불변으로 만들기 위해서는 아래의 규칙을 따라야 합니다.

setter 를 제공하지 않는다
- 객체 내의 필드값을 수정할 수 없도록 합니다.
클래스를 final 설정하여 클래스를 확장할 수 없도록 합니다
- 하위 클래스를 통한 확장 중, 의도치 않게 객체 내의 필드값을 수정하는 상황이 발생할 수 있습니다.
모든 필드를 final로 선언합니다.
- ThreadSafe 하기 때문에 새로 생성된 인스턴스를 동기화 없이 다른 스레드로 건넬수 있게 합니다.
모든 필드를 private 선언합니다.
- 객체 내의 필드를 클라이언트 측에서 직접 수정할 수 없게 해줍니다.
클래스 내의 가변 요소는 본인(해당 클래스)만 접근할 수 있도록 합니다

Java 14 에서는 불변 클래스를 record 키워드로 생성할 수 있으니, record 클래스로 불변 클래스를 생성하면 됩니다.

불변객체는 자유롭게 공유가 가능하기 때문에, clone 하지 않고, 그자체를 여러곳에서 활용할 수 있습니다.

때문에, 불변객체를 복제하는 것은 무의미하고(그 자체를 활용하면 되기 때문에)
클래스를 복사하는 clone같은 메서드는 제공하지 않는것을 권장합니다.

다만, 내부 값이 조금이라도 다를 경우, 객체를 하나더 만들어야합니다.
때문에, 만약 만들어야하는 불변객체가 많다면 그에 따른 비용이 발생된다는 단점이 있습니다.

불변 객체를 만드는 또다른 방법

위에서 제시하는 방법을 제외하고, 설계적인 방법으로 불변 객체를 만드는 방법이 있습니다.

바로, 모든 생성자를 private 또는 package-private으로 설정하고, 정적 팩터리 메서드를 이용하여 객체를 생성하는 방법입니다.
public/protected 생성자가 없기 떄문에 클래스 확장도 불가능하기 떄문에 논리적으로 final 합니다.

@Getter
public class Complex {
    private double re;
    private double im;

    private Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    public static Complex valueOf(double re, double im) {
        return new Complex(re, im);
    }
}

단순하면서, 예상치 못한 오류를 방지할 수 있도록 불변 클래스/객체를 사용하는 것을 권장하지만
만일 불변 클래스로 정의할 수 없다면 최대한 변경할 수 있는 요소를 최소한으로 하는 것을 권장합니다.

객체를 재활용할 목적으로 내부 필드값을 다시 초기화해서는 안되며, 정적 팩터리 메서드를 통해 객체를 생성한 후, 값이 변경되지 않도록 클래스를 정의하는 것을 권장합니다.

++

Item 17. 변경가능성을 최소화 하라.

[Effective Java] Item 15. 상수로 사용하고자하는 필드값이 불변객체인지 고려해야한다

jiniya22 — Sat, 16 Mar 2024 20:37:08 +0900

프로그램의 요소를 접근할 수 있는 권한은 최대한 최소화하는 것이 좋습니다.
반드시 공개되어야하는 요소들만 public으로 설정하는 것이, 유지보수 면에서도 좋습니다.

public 클래스 내의 가변 필드값들은 모두 private 으로 설정 하는 것을 권장하고
상수필드의 경우 필요에 따라 public으로 설정합니다

상수로 이용하고자하는 필드값에는 public static final 를 설정하는데,

이때 주의해야할 점이, reference 타입 중 몇몇 타입은 private static final을 설정하여도 내용을 수정할 수 있다는 점입니다.

변경가능한 레퍼런스 타입 필드값 (array, modifiable 컬렉션들) 의 경우 내용 private static final을 설정해도 변경이 가능하다.

예시 1

아래 예제코드에서 private static final을 설정하였으나, 값을 변경할 수 있는 것을 확인할 수 있습니다.

static final String[] arr = {"apple"};
public static void main(String[] args) {
    System.out.println(Arrays.toString(arr));
    arr[0] = "banana";
    System.out.println(Arrays.toString(arr));
}

[apple]
[banana]

예시 2

unmodifiable 리스트가 아닌 경우, private static final 설정을 하여도 내용을 수정할 수 있습니다.

private static final List<String> list = Lists.newArrayList("RED", "BLUE");
static void ex02() {
    System.out.println(list);
    list.set(0, "AAA");
    System.out.println(list);
}

[RED, BLUE]
[AAA, BLUE]

이러한 부분을 고려하지 않는다면, 변경되지 않아야하는 데이터가 어느시점에 변경되어 서비스에 영향을 줄 수 있습니다.

이런 부분을 방지하기 위해서는, 아래 2가지 방법을 사용할 수 있습니다.

불변 객체로 변환하여 사용하기
변경이 가능한 필드값은 private로 설정하고 해당 값을 복제한 값을 반환하는 메서드를 제공하기

1. 불변객체로 변환하여 사용하기

List.of를 이용하여 불변객체로 만든 후, 그 객체를 사용하면 외부에서 원치 않게 수정되는 일을 방지할 수 있고

변경하려 할때, .UnsupportedOperationException 익셉션이 발생합니다.

private static final String[] P_VALUES = {"apple", "melon", "peach"};
public static final List<String> VALUES = List.of(P_VALUES);

public static void main(String[] args) {
    System.out.println(VALUES);
    VALUES.set(0, "AAA"); // Exception 발생
}

2. 변경이 가능한 필드값은 private로 설정하고 해당 값을 복제한 값을 반환하는 메서드를 제공하기

아래와 같이, 변경이 가능한 필드값은 private으로 설정해두고,
해당값의 clone한 값을 리턴하는 public 메서드를 추가해줍니다.

fruits() 메서드의 리턴값인 fruits를 수정하더라도 원본에는 영향을 주지 않습니다.

private static final String[] P_VALUES = {"apple", "melon", "peach"};

public static final String[] fruits() {
    return P_VALUES.clone();
}
public static void main(String[] args) {
    String[] fruits = fruits();
    System.out.println(Arrays.toString(fruits));
    fruits[0] = "AAA";
    System.out.println(Arrays.toString(fruits));
    System.out.println(Arrays.toString(fruits()));
}

[apple, melon, peach]
[AAA, melon, peach]
[apple, melon, peach]

++

Item 15. 클래스와 멤버의 접근 권한을 최소화하라

[Go] 19. 테스트와 벤치마크

jiniya22 — Wed, 13 Mar 2024 18:08:51 +0900

1. 테스트

Golang 에서는 테스트를 지원하고 있습니다.

go test 명령을 이용하여 테스트 코드를 실행할 수 있으며,
아래와 같은 표준 규약을 가지고 있습니다.

파일명이 _test.go 로 끝납니다
테스트 코드는 func TestXxxxx(t *testing.T) 형태의 함수로 작성합니다
- testing 패키지 import
- 테스트 함수의 매개변수는 t *testing.T 하나여야 합니다

1.1. 테스트 실행

1.1.1. 테스트 전체 실행

ex28.1.go 라는 이름으로 아래와 같은 간단한 예제코드를 작성하였습니다.

package main

import "fmt"

func power(num int) int {
	return num * num
}

func main() {
	n := 5
	result := power(5)
	fmt.Printf("%d의 거듭제곱은 %d\n", n, result)
}

이제 테스트 코드를 작성해봅시다.
Go 표준 규약에 맞춰 ex28_1_test.go 라는 이름으로 아래와 같은 코드를 작성하였습니다.

t.Errorf 를 이용하여, 테스트중 에러 발생시에 대한 출력문도 정의할 수 있습니다.

package main

import "testing"

func TestPower(t *testing.T) {
	result := power(5)
	if result != 25 {
		t.Errorf("power(5)의 결과는 25입니다. 하지만 결과가 %d가 나왔습니다.", result)
	}
}

go test 명령을 사용하기 위해서는, 기존 코드가 모듈로 정의되어있어야 하므로
모듈을 생성한 후,

go mod init goplayground/ex28.1

테스트 코드를 실행합니다.
테스트가 모두 통과되었기 때문에 아래와 같이 PASS 가 출력되었습니다.

go test

PASS
ok      goplayground/ex28.1     0.496s

테스트 코드 실행 중, 오류가 발생되면 아래와 같이 에러 코드와 함께 FAIL이 출력됩니다.

--- FAIL: TestPower (0.00s)
    ex28_1_test.go:8: power(5)의 결과는 25입니다. 하지만 결과가 50가 나왔습니다.
FAIL
exit status 1
FAIL    goplayground/ex28.1     0.599s

1.1.2. 특정 테스트 함수만 실행

테스트 실행 중, -run 테스트명 옵션을 이용하면 특정 테스트만 실행시킬 수 있습니다.

go test -run TestPower

PASS
ok      goplayground/ex28.1     0.463s

1.2. assert

testify 외부 패키지의 assert

먼저, go get 명령어를 이용하여 외부 패키지를 설치합니다.

go get github.com/stretchr/testify

그 후, testify 패지키 내의 assert 패키지를 import하여 assert 패키지를 활용하여 테스트 코드를 작성합니다.

기본적으로 assert 패키지 내의 함수들은 첫번째 인자로 TestT(= *testing.T) 객체를 받지만,

func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool

assert.New(t) 로 생성한 객체를 활용하면, 맨 첫번째 인자에 TestingT를 입력하는 것을 생략할 수 있습니다.

package main

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func TestPower2(t *testing.T) {
	assert := assert.New(t)
	assert.Equal(25, power(5), "power(5)의 결과는 25입니다")
}

assert 패키지 내에는 아래와 같은 함수를 제공하고 있습니다.
조건에 만족하지 않을시 테스트 FAIL과 함께 msgAndArgs를 출력합니다.

func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool
- 인자로 입력받는 두 값(expected, actual)을 비교하여 같을 경우 테스트 성공
func Greater(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool
- expected > actual 일 경우 테스트 성공
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool
- object의 개수가 length과 같을 경우 테스트 성공
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool
- object가 nil이 아닐경우 테스트 성공
func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
- expected != actual 일 경우 테스트 성공

2. 벤치마크

Go에서는 코드 성능을 검사하는 벤치마크 기능을 지원합니다.

벤치마크는 아래와 같은 표준 규약을 가지고 있습니다.

파일명이 _test.go 로 끝납니다
테스트 코드는 func BenchmarkXxxxx(b *testing.B) 형태의 함수로 작성합니다
- testing 패키지 import
- 테스트 함수의 매개변수는 `b *testing. B 하나여야 합니다

먼저 벤치마크 기능을 이용하여 성능 테스트를 하기 위한 코드를 작성하였습니다.

package main

import "fmt"

func fibonacci1(n int) int {
	if n < 0 {
		return 0
	} else if n < 2 {
		return n
	}
	return fibonacci1(n-2) + fibonacci1(n-1)
}

func fibonacci2(n int) int {
	if n < 0 {
		return 0
	} else if n < 2 {
		return n
	}
	first := 0
	second := 1
	result := 0

	for i := 2; i <= n; i++ {
		result = first + second
		first = second
		second = result
	}
	return second
}

func main() {
	fmt.Println(fibonacci1(10))
	fmt.Println(fibonacci2(10))
}

벤치마크를 돌리기 전에, fibonnaci1, fibonnaci2 함수가 원하는대로 작 돌아가는지 테스트 코드로 확인합니다.

package main

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func TestFibonnacci1(t *testing.T) {
	assert := assert.New(t)
	assert.Equal(0, fibonacci1(-1), "fibonacci1(-1) 결과는 0이어야 합니다")
	assert.Equal(0, fibonacci1(0), "fibonacci1(0) 결과는 0이어야 합니다")
	assert.Equal(1, fibonacci1(1), "fibonacci1(1) 결과는 1이어야 합니다")
	assert.Equal(21, fibonacci1(8), "fibonacci1(8) 결과는 21이어야 합니다")
	assert.Equal(55, fibonacci1(10), "fibonacci1(10) 결과는 55이어야 합니다")
}

func TestFibonnacci2(t *testing.T) {
	assert := assert.New(t)
	assert.Equal(0, fibonacci2(-1), "fibonacci2(-1) 결과는 0이어야 합니다")
	assert.Equal(0, fibonacci2(0), "fibonacci2(0) 결과는 0이어야 합니다")
	assert.Equal(1, fibonacci2(1), "fibonacci2(1) 결과는 1이어야 합니다")
	assert.Equal(21, fibonacci2(8), "fibonacci2(8) 결과는 21이어야 합니다")
	assert.Equal(55, fibonacci2(10), "fibonacci2(10) 결과는 55이어야 합니다")
}

PASS
ok      goplayground/ex28.2     0.658s

각 벤치마크 함수에서 b.N 만큼 반복문을 실행합니다.
Go에서는 N값을 적절히 증가시키면서 충분히 테스트를 하여 함수 성능을 측정해줍니다.

package main

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func BenchmarkFibonacci1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		fibonacci1(20)
	}
}

func BenchmarkFibonacci2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		fibonacci2(20)
	}
}

-bench . 옵션을 이용하여 현재 모듈에 있는 벤치마크를 테스트를 실행합니다.

go test -bench .

goos: darwin
goarch: arm64
pkg: goplayground/ex28.2
BenchmarkFibonacci1-10             48760             24825 ns/op
BenchmarkFibonacci2-10          167900041                7.157 ns/op
PASS
ok      goplayground/ex28.2     3.546s

fibonacci1 함수는 24825 ns 가 걸렸고, fibonnaci2 함수는 7.157ns 가 걸렸습니다.
fibonacci1 함수가 재귀함수를 사용하고 있기 때문에 성능이 현저히 떨어지는 것을 확인할 수 있었습니다.

[Go] 18. 채널

jiniya22 — Tue, 12 Mar 2024 18:07:31 +0900

channel은 고루틴간에 메시지를 전달하는 메시지 큐입니다.

1. 기본 문법

채널 인스턴스는 make() 내장함수로 만들 수 있습니다.

var 변수명 chan 채널타입 = make(chan 채널타입)

채널에 데이터를 넣기 위해서는 <- 연산자를 사용하고,
채널로부터 데이터를 뺄 때에도 <- 연산자를 사용합니다.

아래는 messages 라는 이름의 채널에 데이터를 넣고, 빼는 예제입니다.

var messages chan string = make(chan string)
messages <- "apple"

데이터를 빼려고 시도할 때, 만약 messages 에 데이터가 들어있지 않을 경우, 데이터가 들어올 때까지 대기합니다.

var message string = <- messages

채널은 프로그래밍적으로 안전하게 코딩하기 위해
잘못 작성된 상황을 방지하기 위한 용도로 아래와 같이 작성할 수 있습니다.
수신/송신만 하는 채널

func sendChan(ch chan <- string)
func receiveChan(ch <-chan string)

1.1. 간단한 예제

채널 인스턴스 ch를 만들고, 그 채널 인스턴스를 활용하는 고루틴을 생성하는 예제입니다.
go power(&wg, ch) 코드에서 아직 ch 인스턴스에 데이터가 들어있지 않아, 대기상태로 기다리다가
데이터가 들어오면 고루틴을 실행합니다

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup
	ch := make(chan int)
	wg.Add(1)
	go power(&wg, ch)
	fmt.Println("data insert before")
	ch <- 5
	fmt.Println("data insert after")
	wg.Wait()
}

func power(wg *sync.WaitGroup, ch chan int) {
	fmt.Println("power function start")
	num := <-ch
	time.Sleep(time.Second)
	fmt.Printf("%d의 거듭제곱은 %d\n", num, num*num)
	fmt.Println("power function end")
	wg.Done()
}

data insert before
power function start
data insert after
5의 거듭제곱은 25
power function end

채널 인스턴스에 데이터가 들어올 때까지, power 함수 내의 fmt.Println 가 출력되지 않고 대기하고 있습니다.

2. 채널 크기

ch := make(chan string)

채널 생성시 위와 같이 make 함수내에 인자를 하나만 설정할 경우, 크기가 0인 채널이 만들어집니다.
크기가 0인 채널은 들어온 데이터를 담아두지 않고 수신자가 소비할 때까지 대기합니다.

채널 크기가 0인 채널 인스턴스에 데이터를 담아두고 소비하지 않을 경우, deadlock이 걸리면서 프로그램이 멈춥니다.

위의 예제코드에서, 채널에 넣은 데이터를 소비하지 않도록 코드를 아래와 같이 변경할 경우, 데드락 발생 후 프로그램이 강제종료 되는 것을 확인할 수 잇습니다.

이 때, 채널 인스턴스에 데이터를 할당하는 코드 아후의 로직은 동작되지 않습니다.
아래 예제에서도 data insert after 는 출력되지 않은 것을 확인할 수 있습니다.

func main() {
	var wg sync.WaitGroup
	ch := make(chan int)
	wg.Add(1)
	go power(&wg, ch)
	fmt.Println("data insert before")
	ch <- 5
	fmt.Println("data insert after")
	wg.Wait()
}

func power(wg *sync.WaitGroup, ch chan int) {
	fmt.Println("power function start")
	time.Sleep(time.Second)
	fmt.Println("power function end")
	wg.Done()
}

data insert before
power function start
power function end
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
        /Users/sherry/jini_box/jinispaces/go/goplayground/ch25/ex25.1/ex25.1.go:15 +0xe8

3. 버퍼를 가진 채널

버퍼는 내부에 데이터를 보관할수 있는 메모리 영역을 말합니다.
버퍼를 가진 채널을 생성하고 싶다면, make 함수로 채널 인스턴스를 생성할 때, 두번째 인자값에 버퍼 크기를 설정하면 됩니다.

ch := make(chan string, 2)

버퍼 크기가 있는 채널의 경우, 버퍼 크기만큼 데이터를 담아둘 수 있습니다.
버퍼에 담기지 않은 데이터가 있지 않는다면 버퍼에 들어있는 데이터를 수신할 때까지 무한정 대기하지 않습니다.

버퍼를 초과하는 경우에는 버퍼가 없는 채널과 동일하게 데이터 소비를 무한정 기다립니다. (제때 소비되지 않으면 deadlock이 발생됩니다)

4. 채널 닫기

채널 인스턴스에 들어있는 값들을 처리하는 코드를 작성할 때에는 주의해야할 점이 있습니다.

아래 예제를 보며 설명을 이어가겠습니다.

package main

import (
	"fmt"
	"sync"
	"time"
)

func power(wg *sync.WaitGroup, ch chan int) {
	for num := range ch {
		fmt.Printf("%d의 거듭제곱은 %d\n", num, num*num)
		time.Sleep(200 * time.Millisecond)
	}
	wg.Done()
}

func main() {
	var wg sync.WaitGroup
	ch := make(chan int)

	wg.Add(1)
	go power(&wg, ch)
	for i := 0; i < 10; i++ {
		ch <- i
	}
	wg.Wait()
}

0의 거듭제곱은 0
1의 거듭제곱은 1
2의 거듭제곱은 4
3의 거듭제곱은 9
4의 거듭제곱은 16
5의 거듭제곱은 25
6의 거듭제곱은 36
7의 거듭제곱은 49
8의 거듭제곱은 64
9의 거듭제곱은 81
fatal error: all goroutines are asleep - deadlock!

위의 코드는 문제없이 종료될것 같지만, 위와 같이 데드락이 발생되었습니다.

ch 인스턴스에 10개의 데이터를 넣엏고, power 고루틴에서 10개에 대해서 처리할것을 예상하겠지만

power 고루틴에서는 정확하게 ch인스턴스의 데이터가 몇개일지 예측할 수 없기 때문에, 10개의 입력을 모두 마친 후에도 여전히 데이터의 입력을 무한 대기하는 상태가 되어, 데드락이 발생됩니다.

채널을 제때에 닫아주지 않아 고루틴에서 데이터를 무한 대기하는 상태에 대해 좀비 루틴 또는 고루틴 leak 이라고 부릅니다.

여러개의 데이터를 입력받고, 입력받은 데이터들에 대한 처리를 하고자 할 때에는, 해당 채널의 입력을 마치기 위해 채널을 닫아줘야 합니다

for 루프에서 데이터를 입력을 모두 마친 후, close(ch) 로 채널을 닫아주면 데드락 이슈를 해결할 수 있습니다.

func main() {
	var wg sync.WaitGroup
	ch := make(chan int)

	wg.Add(1)
	go power(&wg, ch)
	for i := 0; i < 10; i++ {
		ch <- i
	}
	close(ch)
	wg.Wait()
}

5. select ... case

select 문을 이용하여 여러 채널을 대기하며, 각 채널에 데이터가 들어왔을시에 대한 처리를 한번에 할 수 있습니다.

package main

import (
	"fmt"
	"sync"
	"time"
)

func power(wg *sync.WaitGroup, nums chan int, quit chan bool) {
	for {
		select {
		case num := <-nums:
			fmt.Printf("%d의 거듭제곱은 %d\n", num, num*num)
			time.Sleep(time.Second)
		case <-quit:
			wg.Done()
			return
		}
	}
}

func main() {
	var wg sync.WaitGroup
	nums := make(chan int)
	quit := make(chan bool)
	wg.Add(1)
	go power(&wg, nums, quit)
	for i := 1; i <= 5; i++ {
		nums <- i
	}
	quit <- true
	wg.Wait()
}

1의 거듭제곱은 1
2의 거듭제곱은 4
3의 거듭제곱은 9
4의 거듭제곱은 16
5의 거듭제곱은 25

6. context

컨텍스트는 context 패키지에서 제공하는 기능으로,
작업을 지시할 때 작업 가능시간, 작업 취소 등의 조건을 지시할 수 있는 작업 명세서 역할을 하며, 작업 설정에 대한 데이터를 전달할 수 있습니다.

새로운 고루틴으로 작업을 시작할 때, 일정 시간동안만 작업을 지시할 때
외부에서 작업을 취소하고자할 때

6.1. 작업 취소가 가능한 context

작업이 취소될 때까지 1초마다 메시지를 출력하는 고루틴

package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	wg.Add(1)
	ctx, cancel := context.WithCancel(context.Background())
	go printTickEverySecond(ctx)

	time.Sleep(5 * time.Second)
	cancel()
	wg.Wait()
}

func printTickEverySecond(ctx context.Context) {
	tick := time.Tick(time.Second)
	for {
		select {
		case <-ctx.Done():
			wg.Done()
			return
		case <-tick:
			fmt.Println("Tick!")
		}
	}
}

Tick!
Tick!
Tick!
Tick!
Tick!

context.WithCancel() 는 취소가능한 컨텍스트를 생성합니다.
상위 컨텍스트가 있다면 인자로 상위컨텍스트를 설정하면 됩니다. 예제코드에서는 상위 컨텍스트가 없기 때문에 기본 컨텍스트인 **context.Background()**를 인자로 설정하였습니다.

context.WithCancel() 가 반환하는 cancel 함수를 호출할 경우, 컨텍스트가 종료됩니다.

5초 대기후, cacel() 함수가 호출되도록 설정하였고,
고루틴에서 1초간격으로 Tick! 메시지가 출력되도록 설정하였습니다.
그리고 만약 작업취소 가 실행될 경우(ctx.Done()) 작업그룹이 종료되도록 하였습니다.

6.2. 작업 시간을 설정한 context

context.WithTimeout 의 두번째 인자에 작업시간을 설정할 수 있습니다.
이 경우, 컨텍스트 생성 후, 작업시간이 지난 후, Done() 채널에 시그널을 보냅니다.

아래 코드는, 5초가 지난 후 컨텍스트를 종료시키는 예제코드입니다.

package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	wg.Add(1)
	ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
	go printTickEverySecond(ctx)
	wg.Wait()
}

func printTickEverySecond(ctx context.Context) {
	tick := time.Tick(time.Second)
	for {
		select {
		case <-ctx.Done():
			wg.Done()
			return
		case <-tick:
			fmt.Println("Tick!")
		}
	}
}

Tick!
Tick!
Tick!
Tick!
Tick!

6.3. 특정 값을 설정한 context

context.WithValue 함수를 이용하여 컨텍스트에 특정 키를 설정할 수 있습니다. (반환값은 context.Context)

컨텍스트에 설정한 값은 Value(키)를 이용하여 조회할 수 있습니다. 존재하지 않는 키를 조회시도할 경우 nil을 반환합니다.

package main

import (
	"context"
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func main() {
	wg.Add(1)
	ctx := context.WithValue(context.Background(), "num", 5)
	go power(ctx)
	wg.Wait()
}

func power(ctx context.Context) {
	if v := ctx.Value("num"); v != nil {
		num := v.(int)
		fmt.Printf("%d의 거듭제곱은 %d\n", num, num*num)
	}
	wg.Done()
}

[Go] 17. 고루틴

jiniya22 — Mon, 11 Mar 2024 18:06:12 +0900

고루틴은 경량 스레드로, 함수 or 명령을 동시에 실행할 때 사용합니다.

main() 함수는 고루틴에 의해 실행되는 함수로, Go 프로그램은 최소 1개 이상의 고루틴으로 구성되어있습니다.

원래의 CPU코어는 한번에 하나의 명령을 수행하지만, 컨텍스트 스위칭을 이용하여 여러개의 스레드를 전환하며 실행할 수 있습니다.
다만, 컨텍스트 스위칭은 스레드 전환 이전에 instruction pointer(명령 포인터), 스택 메모리 등의 정보를 저장하여 작업중인 스레드를 기록하는 과정을 거치고, 복원하는 일을 거치는데 이러한 부분에 의해 컨텍스트 스위칭 비용 이 발생되게 됩니다.

CPU코어 수에 비해 스레드 수가 너무 많을시(CPU코어수의 2배이상으로 스레드를 설정), 컨텍스트 스위칭 비용에 의한 성능저하가 발생될 수 있습니다.

Golang 에서는 CPU코어마다 OS스레드를 하나만 할당 하기 때문에, 컨텍스트 스위칭 비용이 발생되지 않습니다.

고루틴은 함수 앞에 go 라는 키워드를 붙여 생성합니다.
고루틴 내에서 go 키워드로 고루틴을 생성하면 새로운 고루틴이 생성되어 새로운 고루틴에서 명령을 수행합니다.

Golang에서는 고루틴을 이용하여 OS스레드를 활용한 동시성 프로그래밍을 합니다.

1. 간단한 예제

각각 200ms, 300ms 씩 간격을 갖고 영문자와 숫자 한자씩 출력하는 함수를 고루틴으로 출력하는 예제입니다.

package main

import (
	"fmt"
	"time"
)

func printAlphabets() {
	alphabets := []rune{'A', 'B', 'C', 'D', 'E', 'F'}
	for _, alphabet := range alphabets {
		time.Sleep(200 * time.Millisecond)
		fmt.Printf("%c ", alphabet)
	}
}

func printNumbers() {
	for i := 0; i < 7; i++ {
		time.Sleep(300 * time.Millisecond)
		fmt.Printf("%d ", i)
	}
}

func main() {
	go printAlphabets()
	go printNumbers()

	fmt.Println("main 1")
	time.Sleep(3 * time.Second)
	fmt.Println("main 2")
}

main 1
A 0 B C 1 D 2 E 3 F 4 5 6 main 2

go루틴으로 각각 호출했기 때문에 동시에 실행되며,
두 고루틴함수 내에는 문자 출력 이전에 time.sleep 을 갖고 있기 때문에 main 1 이 가장 먼저 출력된것을 확인할 수 있습니다.

여기에서, main함수내에 있는 time.Sleep 부분을 아래와 같이 600 밀리초로 수정할 경우,
printAlphabets()와 printNumbers() 고루틴을 마치기 전에 종료되는 것을 확인할 수 있습니다.

이는 메인 함수가 종료될 경우, 서브 고루틴(메인 내에서 호출한 모든 고루틴)이 즉시 종료 되기 때문입니다.

func main() {
	go printAlphabets()
	go printNumbers()

	fmt.Println("main 1")
	time.Sleep(600 * time.Millisecond)
	fmt.Println("main 2")
}

main 1
A 0 B main 2
1

2. 서브 고루틴 종료시 까지 기다리기

메인함수에서 서브고루틴이 모두 종료될때까지 기다리기 위해, time.Sleep 하는 방법도 있겠지만, 언제 종료될지 모르는 경우도 많기 때문에 우리는 보다 확실한 방법을 사용할 필요가 있습니다.

Golang에서는 고루틴이 종료될 때까지 대기하기 위한 sync패키기의 WaitGroup 객체를 지원합니다.

아래와 같이 sync.WaintGroup 객체를 생성한 후,

var wg sync.WaitGroup

총 이용할 서브 고루틴 개수를 Add 하고,

wg.Add(2)

서브고루틴의 동작을 모두 마친 후 Done 함수를 호출하면 작업 하나가 완료처리됩니다.

wg.Done()

서브 고루틴이 호출되는 상위 고루틴에서는, 작업그룹이 모두 완료될 때까지 대기하기 위해 Wait() 함수를 호출합니다.

wg.Wait()

2.1. sync.WaitGroup 적용

위에서 만들었었던 알파벳과 숫자를 출력하는 예제코드에 sync.WaitGroup 을 적용해봅시다.

package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func printAlphabets() {
	alphabets := []rune{'A', 'B', 'C', 'D', 'E', 'F'}
	for _, alphabet := range alphabets {
		time.Sleep(200 * time.Millisecond)
		fmt.Printf("%c ", alphabet)
	}
	wg.Done()
}

func printNumbers() {
	for i := 0; i < 7; i++ {
		time.Sleep(300 * time.Millisecond)
		fmt.Printf("%d ", i)
	}
	wg.Done()
}

func main() {
	wg.Add(2)
	go printAlphabets()
	go printNumbers()
	wg.Wait()
	fmt.Println("main 2")
}

A 0 B 1 C D 2 E 3 F 4 5 6 main 2

실행하고자하는 고루틴함수가 2개이기 때문에, wg.Add(2) 설정하여 실행해보니
메인함수에 time.Sleep 를 설정하지 않아도 서브고루틴이 모두 종료될때까지 대기하는 것을 확인할 수 있었습니다.

2.2. 두번째 예제

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func sumAtoB(i, a, b int) {
	sum := 0
	for i := a; i <= b; i++ {
		sum += i
	}
	fmt.Printf("%d) %d 부터 %d 까지의 총 합 = %d\n", i, a, b, sum)
	wg.Done()
}
func main() {
	cnt := 10
	wg.Add(cnt)
	for i := 0; i < cnt; i++ {
		go sumAtoB(i, 1, 1000000)
	}
	wg.Wait()
}

0) 1 부터 1000000 까지의 총 합 = 500000500000
3) 1 부터 1000000 까지의 총 합 = 500000500000
9) 1 부터 1000000 까지의 총 합 = 500000500000
6) 1 부터 1000000 까지의 총 합 = 500000500000
7) 1 부터 1000000 까지의 총 합 = 500000500000
1) 1 부터 1000000 까지의 총 합 = 500000500000
4) 1 부터 1000000 까지의 총 합 = 500000500000
5) 1 부터 1000000 까지의 총 합 = 500000500000
8) 1 부터 1000000 까지의 총 합 = 500000500000
2) 1 부터 1000000 까지의 총 합 = 500000500000

3. 고루틴 사용시 주의 사항

고루틴을 활용한 동시성 프로그래밍을 이용할 때에는 공유자원 관련 이슈를 반드시 유의해야 합니다.
동시에 실행되는 작업에서 동일한 자원을 이용하게 될 경우, 작업이 실행도중 공유자원 값이 변경되어 원하는 동작과 다르게 결과가 나와 예상하지 못한 결과를 만날 수 있습니다.

이러한 이유로, 공유자원(객체 또는 DB자원 등) 을 이용할 경우에는 다른 고루틴이 자원을 변경하지 않도록 고려하여 코드를 작성해야합니다.

3.1. mutex

동시성 프로그래밍에서 공유자원 사용시 원치 않은 오류가 발생되지 않도록 하는 가장 단순한 방법으로는 mutex를 이용하는 방법입니다.

sync 내장 패키지의 Mutex를 이용하면 mutex를 간단히 활용할 수 있습니다.

공유자원을 사용하는 함수 내에 mutex.Lock() 을 이용하여, 다른 고루틴에서 공유자원을 사용하지 못하고 대기상태를 갖도록 합니다.

defer mutex.Unlock() 함수로 고루틴 종료시, mutex를 반환하게 하면 함수 종료시 대기중인 다른 고루틴에서 뮤텍스를 획득할 수 있도록 할 수 있습니다.

뮤텍스를 이용하는 함수에서는 반드시, Unlock()을 호출하여 뮤텍스를 반환해줘야 합니다!

var mutex sync.Mutex

func testFunc(account *Account) {
	mutex.Lock()
	defer mutex.Unlock()
	...
}

deadlock

하지만, 동시성 프로그래밍을 위해 고루틴을 작성한 코드에서 뮤텍스를 이용하는것은

동시성 프로그래밍으로써의 성능 이점의 장점을 놓치는 면과
뮤텍스를 잘못 사용할 경우, deadlock이 발생될 수 있는 문제점
과 같은 문제사항이 있습니다.

아래의 예제를 보면서 데드락 이슈에 대해 생각해봅시다.

package main  

import (  
  "fmt"  
  "math/rand"  "sync"  "time")  

var wg sync.WaitGroup  

func dining(name string, first, second *sync.Mutex, firstName, secondName string) {  
  for i := 0; i < 10; i++ {  
   fmt.Printf("%s가 밥을 먹으려합니다.\n", name)  
   first.Lock()  
   fmt.Printf("%s가 %s를 획득했습니다.\n", name, firstName)  
   second.Lock()  
   fmt.Printf("%s가 %s를 획득했습니다.\n", name, secondName)  

   fmt.Printf("%s가 밥을 먹습니다.\n", name)  
   time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)  

   second.Unlock()  
   first.Unlock()  
  }  
  wg.Done()  
}  

func main() {  
  rand.New(rand.NewSource(time.Now().UnixNano()))  

  wg.Add(2)  
  fork := &sync.Mutex{}  
  spoon := &sync.Mutex{}  

  go dining("A", fork, spoon, "fork", "spoon")  
  go dining("B", spoon, fork, "spoon", "fork")  

  wg.Wait()  
}

B가 밥을 먹으려합니다.
B가 spoon를 획득했습니다.
B가 fork를 획득했습니다.
B가 밥을 먹습니다.
A가 밥을 먹으려합니다.
B가 밥을 먹으려합니다.
B가 spoon를 획득했습니다.
A가 fork를 획득했습니다.
fatal error: all goroutines are asleep - deadlock!

뮤텍스 이름을 fork, spoon 로 정의하고, 각 뮤텍스를 점유한 경우에 fork나 spoon을 획득한 경우로 생각해봅시다.
포크랑 스푼이 모두 있는 경우에 식사를 할 수 있으며, 식사를 마친 후 뮤텍스를 반환합니다.

실행 결과를 보면, 처음에 B가 먼저 뮤텍스를 점유하며 식사를 마쳤지만,
뮤텍스 반환 후 다음 loop를 실행하려고 할 때, A가 fork 뮤텍스를 획득해버리는 바람에 양쪽 모두 나머지 뮤텍스를 획득하지 못하여 무한정 대기하는 상태인 데드락에 빠지는 현상이 발생하였습니다.

이처럼 동시성 프로그래밍에서 뮤텍스를 사용하는 경우에는 성능 저하 이슈 뿐만 아니라, 예상하지 못한 데드락 을 마주할 수 있기 때문에 유의해야 합니다.

3.2. 자원 이슈 해결하는 방법 또다른 방법

뮤텍스를 사용하는 이유는 공유자원 접근에 의한 side effect를 방지하기 위함입니다.
하지만 뮤텍스를 이용하면, 성능저하나 데드락 등의 문제가 발생할 수 있습니다.

그렇다면, 뮤텍스를 이용하지 않고 자원 이슈를 해결할 수 있는 방법은 어떤게 있을까요?

공유 자원을 동시에 접근하지 않도록 코드를 작성하면 문제는 해결됩니다.

각 고루틴마다 서로 다른 영역을 작업하도록 하거나
각자 다른 역할을 수행하여 작업간의 간섭이 없도록 하면 됩니다.

package main  

import (  
  "fmt"  
  "sync"  "time")  

type Job interface {  
  Do()  
}  

type PowerJob struct {  
  num int  
}  

func (pj *PowerJob) Do() {  
  fmt.Printf("%d 거듭제곱 job start\n", pj.num)  
  time.Sleep(500 * time.Millisecond)  
  fmt.Printf("%d 거듭제곱 job end! 결과는 %d\n", pj.num, pj.num*pj.num)  
}  

func main() {  
  var jobs [10]Job  
  size := 10  

  for i := 0; i < size; i++ {  
   jobs[i] = &PowerJob{i}  
  }  

  var wg sync.WaitGroup  
  wg.Add(size)  

  for i := 0; i < len(jobs); i++ {  
   job := jobs[i]  
   go func() {  
    job.Do()  
    wg.Done()  
   }()  
  }  
  wg.Wait()  

}

2 거듭제곱 job start
7 거듭제곱 job start
9 거듭제곱 job start
6 거듭제곱 job start
8 거듭제곱 job start
4 거듭제곱 job start
5 거듭제곱 job start
0 거듭제곱 job start
1 거듭제곱 job start
3 거듭제곱 job start
2 거듭제곱 job end! 결과는 4
4 거듭제곱 job end! 결과는 16
6 거듭제곱 job end! 결과는 36
8 거듭제곱 job end! 결과는 64
0 거듭제곱 job end! 결과는 0
5 거듭제곱 job end! 결과는 25
3 거듭제곱 job end! 결과는 9
9 거듭제곱 job end! 결과는 81
7 거듭제곱 job end! 결과는 49
1 거듭제곱 job end! 결과는 1

위의 예제에서, 각 고루틴은 배열 중 각기 다른 인덱스를 접근하기 때문에 공유자원을 사용하지 않아 공유자원 관련 이슈를 방지할 수 있습니다.

이렇게 코드를 작성하면 뮤텍스를 사용하지 않고도 동시성 프로그래밍 사용시 발생할 수 있는 문제를 해결할 수 있습니다.

[Effective Java] Item 14. Comparable을 구현할지 고려하라

jiniya22 — Sun, 10 Mar 2024 17:59:47 +0900

Comparable 인터페이스 내에 선언된 유일한 메서드인 compareTo는 동치성 비교에 더해 순서 비교까지 가지고 있습니다.
Comparable을 구현한 클래스를 담은 배열은 Arrays.sort()를 이용하여 정렬할 수 있습니다.

compareTo 메서드 일반 규약입니다.

현재객체가 주어진 객체보다 작으면 -1, 같으면 0, 크면 1를 반환합니다. (현재객체와 비교할 수 없는 타입이 주어지는 경우에는 ClassCastException을 반환합니다.)
x.compareTo(y) == -y.compareTo(x)
x.compareTo(y) > 0 && y.compareTo(z) 일 경우, x.compareTo(z) > 0 를 만족해야 합니다.
x.compareTo(y) == 0 일 경우, x.compareTo(z) == y.compareTo(z) 를 만족해야 합니다.
x.compareTo(y) == 0 일 경우, x.equals(y)여야 합니다.

compareTo 규약을 지킬 경우, 비교를 활용한 클래스인 TreeSet, TreeMap, 정렬 등을 활용할 수 있습니다.

정렬된 컬렉션의 경우, 동치성 비교에 equals가 아닌 compareTo 를 사용합니다.

compareTo의 일반 규약중 맨 마지막에 쓰여진, x.compareTo(y) == 0 인 경우, x.equals(y) == true를 만족하도록 정의하자에 대해서 살펴봅시다.

BigDecimal에서 "1.0"과 "1.00" 입력에 대한 compareTo 비교값은 0을 반환하지만, equals 결과는 false를 반환하고 있습니다.

BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("1.00");
System.out.println(b1.equals(b2));      // false
System.out.println(b1.compareTo(b2));   // 0

이러한 이유로, HashSet에 넣은 결과와

Set<BigDecimal> hashSet = new HashSet<>();
hashSet.add(b1);
hashSet.add(b2);
System.out.println(hashSet);    // [1.0, 1.00]

TreeSet에 넣은 결과가 달라지게 됩니다.

Set<BigDecimal> treeSet = new TreeSet<>();
treeSet.add(b1);
treeSet.add(b2);
System.out.println(treeSet);    // [1.0]

이 부분에 대해 유의하고, compareTo를 규약에 맞춰 정의하는 필요성에 대해 고려해보는 것이 좋습니다.

정수나 실수 primitive 타입에 대한 비교연산은 < 나 > 같은 관계 연산자를 쓰지 않아야 합니다.
(보이게도 거추장 스럽고 오류를 발생시키기도 합니다.)

compareTo 메서드에서 필드값을 비교할 때에는

박싱된 기본 타입 클래스의 정적 메서드(Float.compare등..)를 이용하거나
Comparator 인터페이스가 제공하는 비교자 생성 메서드를 사용합시다.

Comparable 사용 예제

public record Member(
    String name, int age
) implements Comparable<Member> {

    @Override
    public int compareTo(@NotNull Member m) {
        int result = Integer.compare(age, m.age);
        if(result == 0) {
            return name.compareTo(m.name);
        }
        return result;
    }
}

public class ComparableExample {

    public static void main(String[] args) {
        List<Member> members = Lists.newArrayList(new Member("jini", 33),
            new Member("lily", 28), new Member("sol", 39), new Member("coco", 28));
        Collections.sort(members);
        System.out.println(members);
    }
}

[Member[name=coco, age=28], Member[name=lily, age=28], Member[name=jini, age=33], Member[name=sol, age=39]]

Comparator 사용 예

public record Student(
    String name, int age
) {
}

public class ComparatorExample {

    public static void main(String[] args) {
        List<Student> students = Lists.newArrayList(new Student("jini", 33),
            new Student("lily", 28), new Student("sol", 39), new Student("coco", 28));
        Collections.sort(students, COMPARATOR);
        System.out.println(students);
    }

    static final Comparator<Student> COMPARATOR = Comparator
        .comparingInt((Student s) -> s.age())
        .thenComparing(s -> s.name());

}

[Student[name=coco, age=28], Student[name=lily, age=28], Student[name=jini, age=33], Student[name=sol, age=39]]

[Go] 16. 에러 핸들링

jiniya22 — Sun, 10 Mar 2024 17:04:54 +0900

1. 에러 반환

에러가 발생할 수 있는 함수의 경우, 함수 내에서 에러를 처리하지 말고, 다중 리턴 성징을 활용하여 에러를 함께 반환하는 것을 추천합니다.

해당 메서드에서 에러가 발생했을 경우, 어떤 에러가 발생된 것인지 알림과 함께 종료 또는 재개를 하도록 코드를 작성하면 좋습니다.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func ReadFile(filename string) (string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return "", err
	}
	defer file.Close()
	rd := bufio.NewReader(file)
	line, _ := rd.ReadString('\n')
	return line, nil
}

func WriteFile(filename string, line string) error {
	file, err := os.Create(filename)
	if err != nil {
		return err
	}
	defer file.Close()
	_, err = fmt.Fprintf(file, line)
	return err
}

func main() {
	filename := "data.txt"
	line, err := ReadFile(filename)
	if err != nil {
		err = WriteFile(filename, "파일이 존재하지 않아서 WriteFile 함수로 새로 생성했습니다.")
		if err != nil {
			fmt.Println("파일 생성중 에러 발생", err)
			return
		}
		line, err = ReadFile(filename)
		if err != nil {
			fmt.Println("파일 읽기 2번째 실패", err)
			return
		}
	}
	fmt.Println("파일에 쓰여진 값은", line)

}

1.1. 사용자 정의 에러 반환

fmt.Errorf() 함수를 이용하여 사용자 정의 에러를 반환할 수 있습니다.

package main

import (
	"fmt"
	"math"
)

func Sqrt(f float64) (float64, error) {
	if f < 0 {
		return 0, fmt.Errorf("제곱근은 양수여야 합니다. 입력값: %f\n", f)
	}
	return math.Sqrt(f), nil
}

func f1(num float64) {
	result, err := Sqrt(num)
	if err != nil {
		fmt.Printf("Error! %v\n", num)
		return
	}
	fmt.Printf("Sqrt(%f) = %v\n", num, result)
}

func main() {
	f1(2.2)
	f1(-2.2)
}

Sqrt(2.200000) = 1.4832396974191326
Error! -2.2

errors 패키지의 New를 이용하려 error 타입을 생성할수도 있습니다.

import "errors"
errors.New("제곱근은 양수여야 합니다")

2. 에러 타입

error 타입은 인터페이스로, string을 리턴하는 Error() 메서드의 선언만 가지고 있습니다.
즉, Error() 함수를 가지고 있다면, 에러로 사용할 수 있습니다.

type error interface {
	Error() string
}

package main

import "fmt"

type PasswordError struct {
	Len         int
	RequiredLen int
}

func (err PasswordError) Error() string {
	return "암호길이가 짧습니다."
}

type Account struct {
	Id       string
	Password string
}

func RegisterAccount(id, password string) (*Account, error) {
	const minimumLength = 8
	if len(password) < minimumLength {
		return nil, PasswordError{len(password), minimumLength}
	}
	return &Account{id, password}, nil
}

func main() {
	if account, err := RegisterAccount("jini", "jini123"); err != nil {
		if errInfo, ok := err.(PasswordError); ok {
			fmt.Printf("최소 길이: %d, 입력 길이: %d\n", errInfo.RequiredLen, errInfo.Len)
		}
	} else {
		fmt.Println("회원가입 성공! ", account)
	}
}

최소 길이: 8, 입력 길이: 7

PasswordError는 Error() 메서드를 구현하고 있기 때문에, err를 타입변환할 수 있습니다.

err.(PasswordError)

3. 에러 랩핑

4. panic

panic은 프로그램을 정상 진행시키기 어려운 상황을 만났을 때, 프로그램 흐름을 중지시키는 기능입니다.

Go에서는 내장함수 panic()으로 패닉 기능을 제공합니다.

func panic(v any)

panic() 내장함수는 인자값으로 모든 타입을 받을 수 있습니다.

위에서 설명했었던 error 인터페이스를 활용한 예제들은, 호출자에게 에러가 발생된 이유를 직접적으로 알려주는 것이었다면,
패닉은 프로그램 수행시 예기치 못한 에러를 만났을 때 사용하는 기능입니다.

버그 발생으로 인해 잘못된 메모리에 접근하거나
메모리가 부족할 때

아래와 같이 특정 조건에 panic을 발생시킬 수 있습니다.
panic() 함수를 호출하면, 에러 메시지를 출력하고 call stack을 표시하는데, 이것을 통해 에러가 발생된 경로를 알 수 있습니다.

package main

import "fmt"

func divide(a, b int) {
	if b == 0 {
		panic("분모 b는 0일 수 없습니다")
	}
	fmt.Printf("%d / %d = %d\n", a, b, a/b)
}

func main() {
	divide(3, 0)
}

panic: 분모 b는 0일 수 없습니다

goroutine 1 [running]:
main.divide(0x3?, 0x2?)
        /Users/sherry/jini_box/jinispaces/go/goplayground/ch23/ex23.5/ex23.5.go:7 +0xc8
main.main()
        /Users/sherry/jini_box/jinispaces/go/goplayground/ch23/ex23.5/ex23.5.go:14 +0x30

5. 패닉 복구

recover() 함수를 이용하면, 패닉 복구를 할 수 있습니다.

func recover() any

recover() 함수를 실행했을 때, 패닉 전파중일 경우에는 panic객체를 반환하고, 아닐 경우에는 nil을 반환합니다.
아래의 분기문은, 패닉전파시에만 실행되는 구문입니다.

if r := recover(); r != nil {
	fmt.Println("panic 복구 - ", r)
}

recover 함수를 이용하여, 패닉 전파를 복구해봅시다.
아래와 같이, defer 지연 실행을 활용하면, f() 함수 실행 종료 직전에 특정 구문을 실행되도록 할 수 있습니다.

package main

import "fmt"

func f() {
	fmt.Println("f() start")
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("panic 복구 - ", r)
		}
	}()
	g()
	fmt.Println("f() finish")
}

func g() {
	fmt.Printf("3 / 2 = %d\n", divide(3, 2))
	//fmt.Printf("3 / 0 = %d\n", divide(3, 0))
}

func divide(a, b int) int {
	if b == 0 {
		panic("분모 b는 0일 수 없습니다")
	}
	return a / b
}

func main() {
	f()
	fmt.Println("main 끝부분")
}

panic을 발생시키는 코드를 담고 있는 예제코드입니다.
만일, 위의 코드에서 패닉을 유발시키지 않는다면 f() 함수도 정상적으로 종료한 후, main 끝부분 출력까지 마무리됩니다.

f() start
3 / 2 = 1
f() finish
main 끝부분

여기에서, g() 함수 내의 주석부분을 해제하면, g() 함수를 종료하기 전에 panic이 발생되게 됩니다.
이 경우, 패닉 복구가 실행되어, panic 복구 - 분모 b는 0일 수 없습니다이 출력되게 됩니다.
g() 함수 도중에 패닉이 발생되었기 때문에, f() 함수는 정상적으로 종료되지 않기 때문에, f() finish는 출력되지 않습니다.
이렇게 패닉 복구를 잘 활용하면 서비스가 도중에 종료되지 않습니다!

f() start
3 / 2 = 1
panic 복구 -  분모 b는 0일 수 없습니다
main 끝부분

panic함수의 인자로 any타입을 넣을 수 있었던 것 처럼, recover함수의 결과도 any타입입니다.
특정 타입의 패닉일 경우에만 어떤 행위를 동작하게 하고 싶다면 아래와 같이 작성할 수도 있습니다.

if r, ok := recover().(net.Error); ok {
	fmt.Println("net.Error 타입의 패닉에 대한 복구")
}

[Effective Java] Item 10~11. equals는 일반 규약을 지켜서 재정의하라

jiniya22 — Sun, 10 Mar 2024 17:03:43 +0900

1. equals 규약을 지키면서 값을 추가하기

equals를 override할 때에는 반드시 아래의 일반 규약을 만족해야 합니다.
(아래 규약은 모두 null이 아닌 참조값 x에 대한 규약입니다)

x.equals(x) 는 반드시 true 여야 하고
x.equals(y) == true 라면, y.equals(x) == true 여야 합니다.
x.equals(y) == true 이고, y.equals(z) == true 라면, x.equals(z) == true 여야 합니다.
x.equals(y) 결과는 여러번 호출하더라도 늘 같은 값을 반환해야 합니다.
x.equals(null) 은 반드시 false 여야 합니다.

위의 특징을 고려했을 때, 어떤 구현클래스의 상속클래스는 이 규칙을 만족하지 못하게 됩니다.

예를 들어, 아래와 같은 Point 객체가 있고,

@RequiredArgsConstructor
@Getter
public class Point {
    private final int x;
    private final int y;

    @Override
    public boolean equals(Object o) {
        if(o instanceof Point p) {
            return this.x == p.x && this.y == p.y;
        }
        return false;
    }
}

이를 상속한 NamePoint 클래스가 있다고 할 때,

@Getter
public class NamePoint extends Point {
    private final String name;

    public NamePoint(int x, int y, String name) {
        super(x, y);
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if(o instanceof NamePoint p) {
            return super.equals(p) && this.name.equals(p.name);
        }
        return false;
    }
}

여기서 정의된 eqauls 메서드는 일반 규약을 만족하지 않습니다.
point를 namePoint와 비교한 경우에는 결과값이 true지만, 순서를 바꿀 경우 equals 결과가 달라지 기 때문입니다.

Point point = new Point(2, 3);
NamePoint namePoint = new NamePoint(2, 3, "coco");
System.out.println(point.equals(namePoint));  // true
System.out.println(namePoint.equals(point));  // false

객체 지향적 추상화의 이점을 이용하면서, 구체 클래스를 확장해 새로운 값을 추가하면서 equals 규약을 만족시킬 수 있는 방법은 없습니다

equals 규약을 지키면서 값을 추가하고 싶다면

구체 클래스의 하위 클래스에 값을 추가하는 것(상속)이 아닌, 컴포지션을 사용 하거나
최상위에 추상클래스를 정의하고, 하위클래스에서 값을 추가하면 됩니다.

composition 사용 예제

구체 클래스의 하위 클래스에 값을 추가하는 것(상속)이 아닌, 컴포지션을 사용 하면 equals 규약을 지키면서 값을 추가할 수 있습니다.

@Getter
@RequiredArgsConstructor
public class Point {
    private final int x;
    private final int y;

    @Override
    public boolean equals(Object o) {
        if(o instanceof Point p) {
            return this.x == p.x && this.y == p.y;
        }
        return false;
    }
}

@Getter
@RequiredArgsConstructor
public class ColorPoint {
    private final Color color;
    private final Point point;

    public Point asPoint() {
        return point;
    }

    @Override
    public boolean equals(Object o) {
        if (o instanceof ColorPoint cp) {
            return this.point.equals(cp.point) && this.color.equals(cp.color);
        }
        return false;
    }
}

또는, 최상위에 아무런 필드값을 갖지 않은 추상클래스로 정의하여 상위 클래스를 직접 인스턴스로 만드는게 불가능하다면 상속 개념을 이용하면서 equals 규약을 만족시킬 수 있습니다.

2. 기타 고려 사항

2.1. float, double 비교

부동소수 값을 다루는 float, double 타입의 비교는 정적메서드 Float.compare(f1, f2), Double.compare(d1, d2) 로 비교하여 equals 체크합니다.

Float.equals, Double.equals는 primitive 타입일 경우 auto boxing이 일어나기 때문에 성능이 더 떨어집니다.

2.2. null도 값으로 취급하는 참조타입 비교

null도 정상값으로 취급하는 참조타입이라면, Object.equals(o1, o2) 로 비교하여 NullPointerException 발생을 방지합니다.

또, 성능을 높이고 싶다면 가장 다를 가능성이 큰 필드부터 비교하도록 하면 좋습니다.

2.3. Object 이외의 타입을 매개변수로 받는 equals는 사용하지 말자

매개변수를 Object가 아닌 다른 값으로 넣는 것은, 기본 equals 매서드를 재정의하는 것이 아닌 동일한 메서드명으로 메서드를 overload 한 것입니다.

public boolean equals(Point p) { ... }

오버라이딩 할 메서드를 정의할 때, @Override 애너테이션을 붙여준다면, 애초에 컴파일시 에러가 발생되기 때문에 오류를 방지할 수 있습니다.

그러니, @Override 애너테이션을 붙여 실수를 예방합시다.

@Override
public boolean equals(Object o) {
	if(o instanceof Point p) {
		return this.x == p.x && this.y == p.y;
	}
	return false;
}

3. equals 재정의 후 hashCode도 재정의하라

equals를 재정의 한 후, hashCode를 재정의하지 않으면, HashMap같은 컬렉션에 요소를 넣을 때 문제가 발생됩니다.

두 객체의 equals 결과가 true라면 hashCode 결과도 같아야 합니다.

클래스가 불변 클래스면서 해시코드 계산 비용이 큰 경우라면, 지연 초기화 전략으로 hashCode를 읽어들이는 것도 좋은 방법입니다.

private int hashCode;

@Override
public int hashCode() {
	int result = hashCode;
	if(result == 0) {
		// 연산식
	}
	return result;
}

어느정도 성능도 고려하면서, 동일 객체 여부를 잘 판단하는 hashCode를 작성하는 것이 중요한데,
Lombok 을 이용하면 이런 부분을 매우 간편하게 해결할 수 있습니다.

@EqualsAndHashCode
@RequiredArgsConstructor
@Getter
public class Point {
    private final int x;
    private final int y;
}

지연 초기화 캐시전략도 지원합니다.
@EqualsAndHashCode(cacheStrategy = EqualsAndHashCode.CacheStrategy.LAZY)

++

아이템 10. equals는 일반 규약을 지켜 재정의하라
아이템 11. equals를 재정의하려거든 hashCode도 재정의하라

[Go] 15. 자료구조 - list, ring, map

jiniya22 — Mon, 5 Feb 2024 17:00:37 +0900

Go에서 map은 기본 내장타입으로 제공하고 있으며,
list와 ring은 container 기본 내장 패키지에서 제공하고 있습니다.

1. 리스트

list는 container 내장패키지에서 제공하고 있는 LinkedList 자료구조입니다.

type List struct {
	root Element
	len  int
}

type Element struct {
	next, prev *Element
	list *List
	Value any
}

배열이 연속된 메모리에 데이터를 저장했었다면, 리스트는 불연속된 메모리공간에 데이터를 저장한다는 차이점이 있습니다.

배열은 연속된 메모리 공간에 데이터를 저장하기 때문에 인덱스를 이용한 데이터 접근이 빈번하다면 배열 또는 슬라이스를 이용하는 것이 더 효율적이고
데이터의 삽입과 삭제가 더 빈번하다면 리스트를 이용하는 것이 더 효율적입니다.

다만, 데이터 지역성(= 데이터가 밀집한 정도) 는 데이터를 연산 속도에 많은 영향을 주는데,
리스트에 비해 배열의 데이터 지역성이 월등히 좋기 때문에 요소수가 적을 경우에는 데이터의 삽입/삭제가 빈번하더라도 리스트보다는 배열의 효율이 더 효율적입니다.
이 부분을 유의하여 적절한 타입을 활용하는 것이 좋습니다.

List는 길이와 Element를 가지고 있는 타입으로,
각 Element는 이전 요소와 다음요소를 가리키는 포인터변수와
현재 값과 현재 값이 들어있는 리스트의 포인터변수 등을 가지고 있습니다.

Value값은 {}interface 타입으로 어떤 타입이든 들어갈 수 있습니다. (any는 {}interface의 별칭)

포인터변수가 이전과 다음에 모두 있기 때문에, 리스트 앞과 뒤에 요소 추가가 가능합니다.

list.New() 함수로 리스트 인스턴스를 생성할 수 있으며,
PushFront(), PushBack() 메서드로 리스트의 앞 또는 뒤에 요소를 추가할 수 있습니다.

PushFront와 PushFront 메서드는 요소를 추가한 후, 추가한 요소의 포인터를 반환하며,

func (l *List) PushBack(v any) *Element {
	l.lazyInit()
	return l.insertValue(v, l.root.prev)
}

그 포인터 변수를 활용하여 특정 요소 앞 또는 뒤에 값을 삽입할 수도 있습니다.

func (l *List) InsertBefore(v any, mark *Element) *Element {
	if mark.list != l {
		return nil
	}
	// see comment in List.Remove about initialization of l
	return l.insertValue(v, mark.prev)
}

아래는 리스트를 사용하는 간단한 예제입니다.

package main

import (
	"container/list"
	"fmt"
)

func main() {
	a := list.New()
	e1 := a.PushBack(1)
	e2 := a.PushFront(2)

	a.InsertBefore(10, e1)
	a.InsertAfter(20, e2)

	for e := a.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value, ", ")
	}

	fmt.Println("\n----------")
	for e := a.Back(); e != nil; e = e.Prev() {
		fmt.Print(e.Value, ", ")
	}
}

2, 20, 10, 1,
----------
1, 10, 20, 2,

Front() 메서드로 리스트의 맨 앞에 위치한 요소의 포인터를 가져올 수 있으며,
_Next(), Prev() 메서드로 특정 요소 포인터 변수의 이전 또는 다음 요소를 읽어들일 수 있습니다.

1.1. list로 Queue 구현

package main

import (
	"container/list"
	"fmt"
)

type Queue struct {
	v *list.List
}

func (q *Queue) Push(val any) {
	q.v.PushBack(val)
}

func (q *Queue) Pop() any {
	ele := q.v.Front()
	if ele != nil {
		return q.v.Remove(ele)
	}
	return nil
}

func NewQueue() *Queue {
	return &Queue{list.New()}
}

func main() {
	queue := NewQueue()
	for i := 0; i < 5; i++ {
		queue.Push(i)
	}
	for ele := queue.Pop(); ele != nil; ele = queue.Pop() {
		fmt.Print(ele, ", ")
	}
}

0, 1, 2, 3, 4,

1.2. list로 Stack 구현

package main

import (
	"container/list"
	"fmt"
)

type Stack struct {
	v *list.List
}

func (s *Stack) Push(value any) {
	s.v.PushBack(value)
}

func (s *Stack) Pop() any {
	ele := s.v.Back()
	if ele != nil {
		return s.v.Remove(ele)
	}
	return nil
}

func NewStack() *Stack {
	return &Stack{list.New()}
}

func main() {
	stack := NewStack()
	for i := 0; i < 5; i++ {
		stack.Push(i)
	}

	for ele := stack.Pop(); ele != nil; ele = stack.Pop() {
		fmt.Print(ele, ", ")
	}
}

2. 링

링은 Go의 container 내장패키지에서 제공하고 있는 circular linked list 로, list에서 맨 뒤 요소와 맨 앞 요소가 연결된 자료구조입니다.

type Ring struct {
	next, prev *Ring
	Value      any
}

ring에서도 New() 함수를 제공하고 있는데,
인자로 element 개수를 설정할 수 있으며, 선언하면 링이 위치한 포인터 변수를 반환합니다.

func New(n int) *Ring {
	if n <= 0 {
		return nil
	}
	r := new(Ring)
	p := r
	for i := 1; i < n; i++ {
		p.next = &Ring{prev: p}
		p = p.next
	}
	p.next = r
	r.prev = p
	return r
}

링은 마지막이라는 개념이 없기 떄문에 아래와 같은 예제 코드가 가능합니다.

package main

import (
	"container/ring"
	"fmt"
)

func main() {
	r := ring.New(5)
	n := r.Len()

	for i := 0; i < n; i++ {
		r.Value = i
		r = r.Next()
	}

	for i := 0; i < n; i++ {
		fmt.Print(r.Value, ", ")
		r = r.Next()
	}
	fmt.Println("\n--------------")
	for i := 0; i < n; i++ {
		fmt.Print(r.Value, ", ")
		r = r.Prev()
	}
}

0, 1, 2, 3, 4,
--------------
0, 4, 3, 2, 1,

length가 5인 링을 생성한 후, 0부터 4까지 값을 할당하고, Next()를 이용하여 순회하면 0, 1, 2, 3, 4, 가 출력됩니다.
이 순회를 마친 후, r은 0값이 있는 곳을 가리키고 있기 때문에 그 다음 for 루프에서는 0에서 시작되며, Prev() 함수를 이용하여 순회하기 때문에 그 이후부터는 4, 3, 2, 1, 이 출력됩니다.

링은 저장할 요소의 개수가 고정되어있으면서, 오래된 요소를 지워도 되는 경우에 사용하면 좋습니다.

실행취소/재개
고정크기 버퍼
리플레이

3. 맵

map은 key와 value형태로 데이터를 저장하는 데이터 구조로, 순서를 보장하지 않습니다.

Go에서는 map이라는 이름으로 기본 내장 타입으로 제공하고 있습니다.

Java에서는 HashMap, Hashtable, python에서는 dictionary 라고 부릅니다

추가/삭제/읽기 모두 $O(1)$ 시간복잡도가 발생하기 때문에 매우 빠르지만, 입력한 순서를 보장하지 않고, 이 떄문에 인덱스를 사용하여 접근하는 것이 불가능합니다.
또, 배열과 리스트에 비해 상대적으로 메모리를 많이 차지합니다.

map[키타입]값타입

make함수를 이용하여 map을 만들 수 있습니다.
map은 for range를 이용하여 요소를 순회할 수 있고, key, value 형태로 읽어들일 수 있습니다.

package main

import "fmt"

func main() {
	m := make(map[string]int)
	m["jini"] = 100
	m["coco"] = 92
	m["sol"] = 84

	for key, value := range m {
		fmt.Printf("key: %s, value: %d\n", key, value)
	}
	fmt.Println(m["jini"])
}

map은 순서를 보장하지 않습니다.
그렇기 때문에, 아래 예제코드에서 for 루프의 출력문이 입력순서대로 출력되지 않습니다.

package main

import "fmt"

type User struct {
	Name string
	Age  int
}

func main() {
	users := make(map[int]User)

	users[99] = User{"coco", 25}
	users[11] = User{"jin", 37}
	users[28] = User{"lily", 28}
	users[19] = User{"rora", 21}
	users[192] = User{"kate", 34}

	for key, value := range users {
		fmt.Println(key, value)
	}

}

192 {kate 34}
99 {coco 25}
11 {jin 37}
28 {lily 28}
19 {rora 21}

map의 요소를 삭제하고 싶다면, delete(맵변수, 삭제할키) 함수를 사용하면 됩니다.
delete함수는 존재하지 않는 키를 삭제 시도하더라도 에러를 발생시키지 않습니다

또, 존재하지 않는 요소값을 출력하려 해도 오류가 발생되지 않고, 해당 맵 value의 데이터타입 기본값을 출력합니다.

package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["apple"] = 3
	m["banana"] = 12
	m["melon"] = 22

	delete(m, "banana")
	delete(m, "tomato")  // 에러 발생 x
	fmt.Println("있는 요소를 조회할 경우: ", m["apple"])
	fmt.Println("없는 요소를 조회할 경우: ", m["banana"])  // 에러 발생 x
}

key를 이용하여 요소를 조회하는 행위는 value 하나만 리턴받을 수도 있지만, value와 key존재유무를 함께 리턴받을 수 있습니다.

value := m["키값"]
value, ok := m["키값"]

이러한 특성을 잘 이용하여 아래와 같이 코드를 작성할 수 있습니다.

if value, ok := m["grape"]; ok {
  fmt.Println("저장된 값은", value)
} else {
  fmt.Println("해당 값이 존재하지 않습니다.")
}

[Go] 14. 함수 고급편

jiniya22 — Sun, 4 Feb 2024 16:57:23 +0900

1. 가변 인수 함수

함수의 인수 개수를 고정하지 않는 함수를 가변 인수 함수라고 합니다.

fmt 패키지의 Println은 아래와 같이 사용 가능합니다.

fmt.Println("Hi")
fmt.Println(23, "apple")
fmt.Println(3.14, "ABC", 10)

Println 함수를 살펴보면, 아래와 같이 ...interface{} 타입을 인수값으로 가지고 있습니다.

type any = interface{}

func Println(a ...any) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}

... 키워드를 이용하면 가변 인수를 처리할 수 있습니다.

func sum(nums ...int) int {
	result := 0
	for _, num := range nums {
		result += num
	}
	return result
}

func main() {
	fmt.Println(sum(2))
	fmt.Println(sum(5, 6, 10))
	fmt.Println(sum(22, 99))
}

...키워드로 설정한 가변 인수는 함수 내부에서 슬라이스타입으로 처리됩니다.

sum 함수에 설정한 nums 인수의 경우, []int 로 처리됩니다.

만일, 모든 타입을 받을 수 있는 가변인수를 함수에 이용하고 싶다면,
Println 함수와 같이 ...interface{} 타입을 받으면 됩니다

2. defer 지연 실행

함수가 종료되기 직전에 반드시 실행되어야하는 코드가 있다면,
defer 지연 실행을 이용하면, 종료되기 직전에 해당 명령을 실행할 수 있습니다.

defer 명령문

지연실행이 필요한 대표적인 예로는 파일이나 소켓과 같은 OS 내부 자원을 사용하는 함수가 있습니다.
파일을 생성하거나 읽는 행위는 OS 내부자원을 이용하는 것이기 때문에, 코드상에서 해당 기능을 이용할 때, 자원을 빌려씁니다.
때문에, 사용한 후에는 OS에게 핸들을 반환해줘야 내부자원이 고갈되지 않습니다.

defer 지연실행은 역순으로 실행됩니다.
즉, 가장 먼저 선언된 defer 함수가 가장 나중에 실행됩니다.

아래의 예제코드를 보면 맨 나중에 선언한 defer 지연실행이 가장 먼저 실행된 것을 확인할 수 있습니다.

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Create("data.txt")
	if err != nil {
		fmt.Println("파일 생성 중 오류 발생")
		return
	}
	defer fmt.Println("defer 지연실행은 맨먼저 선언한것이 맨 나중에 실행됩니다.")
	defer file.Close()
	defer fmt.Println("맨 마지막에 사용한 defer 지연실행이지만 가장 먼저 실행됩니다.")

	fmt.Println("파일에 Hello jiniworld!를 썼습니다.")
	fmt.Fprintln(file, "Hello jiniworld!")
}

파일에 Hello jiniworld!를 썼습니다.
맨 마지막에 사용한 defer 지연실행이지만 가장 먼저 실행됩니다.
defer 지연실행은 맨먼저 선언한것이 맨 나중에 실행됩니다.

3. 함수 타입 변수, 함수 리터럴

Go에서의 함수는, javascript와 같이 함수를 리턴타입으로 사용할 수 있습니다.

아래 예제를 살펴봅시다.

func add(a, b int) int {
	return a + b
}

func multiply(a, b int) int {
	return a * b
}

func getOperator(op string) func(int, int) int {
	if op == "+" {
		return add
	} else if op == "-" {
		return func(a int, b int) int {
			return a - b
		}
	} else if op == "*" {
		return multiply
	}
	return nil
}

getOperator 함수와 같이 함수를 리턴할 수 있습니다.
이미 선언된 함수명을 리턴할수도 있고,
else if op == "-" 에서 정의했던 것 처럼, 익명함수 형태를 리턴할 수도 있습니다.

Go에서는 익명함수를 함수 리터럴 이라고 부릅니다.

함수명을 적지 않고 함수타입 변수값에 대입되는 함수값을 함수리터럴이라고 부릅니다. Java에서는 람다라고 부릅니다.

3.1. 별칭을 이용하여 가독성 높이기

함수를 리턴타입으로 사용하는 것은 가독성이 떨어지기 때문에, 아래와 같이 별칭을 정의하여 사용할 수도 있습니다.

type opFunc func(int, int) int

func getOperator(op string) opFunc {
	if op == "+" {
		return add
	} else if op == "-" {
		return func(a int, b int) int {
			return a - b
		}
	} else if op == "*" {
		return multiply
	}
	return nil
}

4. 함수 리터럴

외부에 정의된 외부변수를 함수 리터럴 내에서도 사용할 수 있습니다.

func main() {
	num := 1
	f := func(a int) {
		num *= a
	}
	num += 100
	f(2)
	fmt.Println(num)
}

함수리터럴을 선언할 때가 아닌, 그 함수리터럴을 사용할 때, 함수 내부가 실행됩니다.
따라서, 위의 코드의 실행결과는 202가됩니다. (1 -> 101 -> 202)

4.1. 캡처

외부변수를 함수 리터럴 내에서 사용할 때, 주의해야할 점이 있습니다.
함수리터럴은 호출되는 시점에 실행된다는 점입니다.

[]func() 를 이용하여 만약, 0, 1, 2를 출력하고자 할때 아래와 같은 방식으로 함수를 정의하면 예상과 달리 3, 3, 3이 출력됩니다.

func CaptureLoop() {
	f := make([]func(), 3)
	fmt.Println("ValueLoop")
	for i := 0; i < 3; i++ {
		f[i] = func() {
			fmt.Println(i)
		}
	}
	for i := 0; i < len(f); i++ {
		f[i]()
	}
}

함수 리터럴 내에서 외부변수는 값을 복사하는 것이 아니라, 변수값의 참조(주소값) 를 이용하여 캡쳐됩니다.
그런데 함수 리터럴 내의 함수는 호출시점에 실행되기 때문에, 변수값은 for루프를 모두 마친 후, 3이된 시점의 참조값을 읽어들이기 때문에 모두 3으로 출력되는 것입니다.

우리가 원래 의도했었던 것 처럼 0, 1, 2를 출력하게 하고 싶다면,
함수리터럴 내에서 외부 변수 i를 그대로 사용하는 것이 아니라, 새로운 변수에 값을 복사한 후, 그 값을 활용하면 됩니다.

func CaptureLoop2() {
	f := make([]func(), 3)
	fmt.Println("ValueLoop")
	for i := 0; i < 3; i++ {
		v := i
		f[i] = func() {
			fmt.Println(v)
		}
	}
	for i := 0; i < len(f); i++ {
		f[i]()
	}
}

4.2. 파일 핸들을 함수 리터럴 내에서 사용하기

함수타입을 인자로 받는 함수를 이용하고자 할때, 함수리터럴을 이용하면, 외부변수값을 함수 리터럴 내에서 사용할 수 있다고 했습니다.

여기에서 더 나아가, 파일 핸들과 같은 값도 함수 리터럴 내의 내부상태로 가질 수 있습니다.

package main

import (
	"fmt"
	"os"
)

type Writer func(string)

func writeHello(writer Writer) {
	writer("Hello")
}

func main() {
	file, err := os.Create("data.txt")
	if err != nil {
		fmt.Println("파일 생성 실패")
		return
	}
	defer file.Close()
	writeHello(func(msg string) {
		fmt.Fprintln(file, msg)
	})
}

이러한 성질을 잘 이용하면, writeHello 함수에서 다양한 로직을 실행할 수 있습니다. (의존성 주입)

[Go] 13. 인터페이스

jiniya22 — Sun, 21 Jan 2024 13:39:03 +0900

1. 인터페이스

인터페이스는 메서드 선언을 가지고 있는 타입으로, 아래와 같은 성질을 가지고 있습니다.

메서드명은 필수 요소입니다
동일한 메서드명은 설정할 수 없습니다. (overloading x)
메서드 선언만 들어있습니다. (메서드 구현은 포함x)

type 키워드 뒤에 인터페이스명을 쓰고, interface 키워드를 쓴 후 중괄호를 쓰며
중괄호 안에 인터페이스에 포함된 메서드들을 씁니다

type InterfaceName interface {
  Introduce()
  calculate(a, b int) int
}

아래는 인터페이스를 사용한 예제코드입니다.

package main  

import "fmt"  

type Member interface {  
  Introduce() string  
}  

type VipMember struct {  
  Name string  
  Age  int  
}  

func (u VipMember) Introduce() string {  
  return fmt.Sprintf("이름: %s, 나이: %d", u.Name, u.Age)  
}  

func main() {  
  var member Member = VipMember{"coco", 25}  
  fmt.Println(member.Introduce())  
}

이름: coco, 나이: 25

인터페이스에 정의한 메서드를 로컬타입의 메서드로 선언해두면
인터페이스 타입인 member에 VipMember를 담을 수 있고,

Member인터페이스에는 Introduce 메서드에 대한 구현이 작성되어있지 않지만, 담겨져있는 타입이 VipMember이기 때문에
Introduce() 메서드를 호출할 경우, VipMember에 정의한 Introduce 메서드가 호출되는 것입니다.

이러한 성질을 잘 활용하면, 구현 객체의 교체만으로 코드를 수정할 수 있게 되기 때문에 코드수정이 편리해집니다.

2. 인터페이스 사용 예제

2.1. fedex 모듈 생성

먼저, fedex 모듈을 생성해봅시다.

ch20디렉토리 하위에 fedex디렉토리를 만든 후, 그 안에 fedex.go 파일을 생성하여

cd ch20
mkdir fedex
vim fedex.go

아래와 같이 Send메서드를 정의해봅니다.

package fedex

import "fmt"

type FedexSender struct {
}

func (f *FedexSender) Send(parcel string) {
	fmt.Printf("Fedex sends %s parcel\n", parcel)
}

그 후, 모듈을 github 외부 레파지토리로 설정하여 모듈을 생성합니다.

go mod init github.com/jiniya22/goplayground/ch20/fedex

그러면 아래와 같이 go.mod 파일이 생성됩니다.

module github.com/jiniya22/goplayground/ch20/fedex

go 1.21.5

2.2. 메인모듈 생성

ch20 디렉토리로 이동한 후, fedex모듈을 활용할 ex20.2 모듈을 생성해봅니다.

mkdir ex20.2
vim ex20.2.go

package main

func main() {
}

ex.20.2.go 파일의 껍데기를 만든 후, ex20.2 를 모듈로 만듭니다.

go mod init goplayground/ex20.2

그후, 위에서 생성했었던 fedex 모듈을 활용하여 FedexSender를 사용하는 함수를 생성하고 사용해봅니다.

package main

import (
	"github.com/jiniya22/goplayground/ch20/fedex"
)

func SendBook(name string, sender *fedex.FedexSender) {
	sender.Send(name)
}
func main() {
	sender := &fedex.FedexSender{}
	SendBook("ABC 신나는 영어", sender)
	SendBook("너에게 보내는 편지", sender)
}

외부 저장소에 들어있는 모듈을 다운로드받습니다.

go mod tidy

go: finding module for package github.com/jiniya22/goplayground/ch20/fedex
go: downloading github.com/jiniya22/goplayground v0.0.0-20240114082621-0a685760f1d2
go: downloading github.com/jiniya22/goplayground/ch20/fedex v0.0.0-20240114082621-0a685760f1d2
go: found github.com/jiniya22/goplayground/ch20/fedex in github.com/jiniya22/goplayground/ch20/fedex v0.0.0-20240114082621-0a685760f1d2

모듈을 다운받은 후, go.sum 파일이 생성됩니다.

위의 모듈을 빌드한 후 실행시켜보면 아래와 같이 출력됩니다.

Fedex sends ABC 신나는 영어 parcel
Fedex sends 너에게 보내는 편지 parcel

2.3. koreapost 모듈 추가

fedex 모듈과 동일한 방식으로 koreapost(우체국) 모듈을 생성합니다.

package koreapost

import "fmt"

type PostSender struct {
}

func (f *PostSender) Send(parcel string) {
	fmt.Printf("우체국에서 택배 %s 를 보냅니다\n", parcel)
}

go mod init github.com/jiniya22/goplayground/ch20/koreapost

2.4. 인터페이스 활용

아래의 함수를, 인터페이스를 활용하여 FedexSender, PostSender가 모두 사용할 수 있는 함수로 변경해보자.

func SendBook(name string, sender *fedex.FedexSender) {
	sender.Send(name)
}

package main

import (
	"github.com/jiniya22/goplayground/ch20/fedex"
	"github.com/jiniya22/goplayground/ch20/koreapost"
)

type Sender interface {
	Send(parcel string)
}

func SendBook(name string, sender Sender) {
	sender.Send(name)
}
func main() {
	fedexSender := &fedex.FedexSender{}
	postSender := &koreapost.PostSender{}
	SendBook("ABC 신나는 영어", fedexSender)
	SendBook("너에게 보내는 편지", postSender)
}

Fedex sends ABC 신나는 영어 parcel
우체국에서 택배 너에게 보내는 편지 를 보냅니다

3. 덕타이핑

Go의 인터페이스는 덕타이핑(duck typing) 방식을 사용합니다.
덕타이핑 방식이란, 인터페이스의 구현 여부를 명시적으로 나타낼 필요없이, 인터페이스에 선언된 메서드를 구현하는 것 만으로도 그 인터페이스의 구현하는 타입으로 간주하는 것을 의미합니다.

Java에서는, 인터페이스에 선언되어있는 메서드들을 가지고 있는 클래스더라도, implements 키워드로 그 인터페이스를 구현했다고 명시적으로 설정해야만 구현클래스로 간주했지만 Go는 이런 명시가 필요하지 않습니다.

인터페이스를 사용하는 시점에, 해당 타입이 인터페이스에 정의된 메서드를 포함하고 있는지를 판단하며, 이러한 성질로 인해 개발에 편의성이 높습니다.

4. 인터페이스를 포함하는 인터페이스

인터페이스는 인터페이스를 포함할 수 있습니다.

또, 포함하고 있는 인터페이스에서 이름이 겹치는 경우에는 하나만 포함됩니다

type Reader interface {
	Read() (n int, err error)
	Close() error
}

type Writer interface {
	Write() (n int, err error)
	Close() error
}

type ReadWriter interface {
	Reader
	Writer
}

ReadWriter 인터페이스는 Read() (n int, err error), Close() error, Write() (n int, err error) 를 모두 포함한 타입의 경우에만 사용가능합니다.

5. 빈 인터페이스

빈 인터페이스(interface{}) 는 어떠한 메서드도 포함하고 있지 않기 때문에 모든 타입을 담을 수 있습니다.

빈 인터페이스는 int, float64, string, int8 등 다양한 타입들을 담을 수 있기 때문에 아래와 같이 활용할 수 있습니다.

package main

import "fmt"

func PrintValue(v interface{}) {
	switch t := v.(type) {
	case int:
		fmt.Printf("%d는 int 타입", t)
	case float64:
		fmt.Printf("%f는 float64 타입", t)
	case string:
		fmt.Printf("%s는 string 타입", t)
	default:
		fmt.Printf("%v는 int, float64, string 외의 타입", t)
	}
	fmt.Println()
}

func main() {
	PrintValue(32)
	PrintValue(3.14)
	PrintValue("지니")
	var a int8 = 9
	PrintValue(a)
}

32는 int 타입
3.140000는 float64 타입
지니는 string 타입
9는 int, float64, string 외의 타입

6. 인터페이스 기본값

인터페이스의 기본값은 nil 입니다

인터페이스에 선언된 메서드를 포함하고 있는 타입으로 초기화하지 않고 사용할 경우에는 panic: runtime error: invalid memory address or nil pointer dereference 메시지와 함께 런타임 에러가 발생되기 때문에 이 부분에 대해 유의해야 합니다.

인터페이스 변수가 초기화 되어있는지에 대해서는 컴파일시 확인되지 않기 때문에
인터페이스의 메서드를 사용하기 전에, 인터페이스가 nil이 아닌지를 반드시 체크해야 합니다.

package main

type Member interface {
	Introduce()
}

func main() {
	var member Member
	member.Introduce()
}

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x2 addr=0x0 pc=0x102e3a7fc]

goroutine 1 [running]:
main.main()
        /Users/sherry/jini_box/jinispaces/go/goplayground/ch20/ex20.4/ex20.4.go:9 +0x1c

7. 인터페이스 변환

7.1. 인터페이스를 구체화타입으로 변환

VipMember 타입으로 생성한 포인터변수를 Member 인터페이스에 담을 수 있고,
이 member에 Introduce()를 실행하면 VipMember에 정의한 메서드가 실행됩니다.

인터페이스를 다시 *VipMember 타입으로 변환하고 싶다면 member.(*VipMember) 와 같은 방식으로 변환할 수 있습니다.

package main

import "fmt"

type Member interface {
	Introduce() string
}

type VipMember struct {
	Name string
	Age  int
}

func (v *VipMember) Introduce() string {
	return fmt.Sprintf("%s는 Vip회원이며 나이는 %d 입니다.", v.Name, v.Age)
}

func main() {
	var member Member = &VipMember{"sol", 26}
	fmt.Println(member.Introduce())
	fmt.Printf("member의 타입은 %T\n\n", member)

	vipMember := member.(*VipMember)
	fmt.Println(vipMember.Introduce())
	fmt.Printf("vipMember의 타입은 %T\n\n", vipMember)
}

sol는 Vip회원이며 나이는 26 입니다.
member의 타입은 *main.VipMember

sol는 Vip회원이며 나이는 26 입니다.
vipMember의 타입은 *main.VipMember

VipMember 타입 외에 BasicMember 타입을 만들고, 이 타입도 Member 인터페이스에 선언된 메서드를 구현한 후 아래 코드를 실행하면,

*VipMember 타입으로 선언한 member 변수가 *VipMember 로는 다시 변환하는게 가능하지만
*BasicMember 타입으로는 변환이 되지 않는 것을 알 수 있습니다.

package main

import "fmt"

type Member interface {
	Introduce() string
}

type BasicMember struct {
	Name string
	Age  int
}

func (v *BasicMember) Introduce() string {
	return fmt.Sprintf("%s는 기본회원이며 나이는 %d 입니다.", v.Name, v.Age)
}

type VipMember struct {
	Name string
	Age  int
}

func (v *VipMember) Introduce() string {
	return fmt.Sprintf("%s는 Vip회원이며 나이는 %d 입니다.", v.Name, v.Age)
}

func main() {
	var member Member = &VipMember{"sol", 26}
	fmt.Println(member.Introduce())
	fmt.Printf("member의 타입은 %T\n\n", member)

	vipMember := member.(*VipMember)
	fmt.Println(vipMember.Introduce())
	fmt.Printf("vipMember의 타입은 %T\n\n", vipMember)

	basicMember := member.(*BasicMember) // Runtime Exception 발생!
	fmt.Println(basicMember.Introduce())
	fmt.Printf("normalMember의 타입은 %T", basicMember)
}

basicMember := member.(*BasicMember) 실행 중에 panic: interface conversion: main.Member is *main.VipMember, not *main.BasicMember 에러가 발생됩니다.

다른 인터페이스 타입으로 변환하고 싶다면 위와 같은 방법으로는 불가합니다.

7.2. 인터페이스 타입 변환

인터페이스 타입 변환을 이용하여 다른 구체화타입/인터페이스로 변경할 수 있습니다.

인터페이스 타입을 변환한 후, 그 인터페이스에 선언된 메서드를 실행하는 부분에서 변환하는 인터페이스에 선언된 메서드가 포함되어있는지 유무를 컴파일시점에 판단하지 않기 때문에, 이에 대한 방어코드를 반드시 작성해야합니다

Shape 인터페이스와, 그 인터페이스를 구현한 Circle 타입이 있고,

type Shape interface {
	Introduce() string
}

type Circle struct {
	Name   string
	Radius int
}

func (v *Circle) Introduce() string {
	return fmt.Sprintf("%s는 원. 반지름은 %d 입니다.", v.Name, v.Radius)
}

Shape 인터페이스를 포함하고 있는 Polygon 인터페이스와
그 인터페이스를 구현한 Square 타입이 있다고 할 때,

type Polygon interface {
	Shape
	GetLines() int
}

type Square struct {
	Name  string
	Width int
}

func (v *Square) Introduce() string {
	return fmt.Sprintf("%s는 정사각형. 변의 길이는 %d 입니다.", v.Name, v.Width)
}

func (v *Square) GetLines() int {
	return 4
}

Shape 인터페이스를 Polygon 인터페이스로 변환하려 할때,
변환중 오류가 발생하지 않았을 때에만 특정 기능을 수행하도록 아래와 같이 작성할 수 있습니다.

func PrintIntroduce(s Shape) {
	p, ok := s.(Polygon)
	if ok {
		fmt.Printf("변의 수는 %d\n", p.GetLines())
	}
	fmt.Println(s.Introduce())
}

변환 중 오류가 발생하지 않았을 때에 특정 기능이 수행하도록 하는 코드는 아래와 같이 더 축약해서 작성할 수 있습니다.

if p, ok := s.(Polygon); ok {
	fmt.Printf("변의 수는 %d\n", p.GetLines())
}

func main() {
	var s1 Shape = &Circle{"원1", 2}
	fmt.Println(s1.Introduce())
	fmt.Printf("s1의 타입은 %T\n", s1)

	var s2 Shape = &Square{"사각형1", 5}
	fmt.Println(s2.Introduce())
	fmt.Printf("s2의 타입은 %T\n", s2)

	fmt.Println("-------")
	PrintIntroduce(s1)
	PrintIntroduce(s2)
}

원1는 원. 반지름은 2 입니다.
s1의 타입은 *main.Circle
사각형1는 정사각형. 변의 길이는 5 입니다.
s2의 타입은 *main.Square
-------
원1는 원. 반지름은 2 입니다.
변의 수는 4
사각형1는 정사각형. 변의 길이는 5 입니다.

위의 예제의 full code는 jiniya22 Github ex20.6.go에 있습니다.

[Go] 12. 메서드

jiniya22 — Sun, 21 Jan 2024 13:35:42 +0900

메서드는 함수와 달리 func 오른쪽에 소괄호로 리시버를 받습니다.
리시버는 type키워드로 선언된 모든 로컬 타입들을 입력받을 수 있습니다. (= type으로 선언된 별칭들이나 구조체)

메서드를 잘 활용하면 데이터와 관련 기능을 묶어 응집도를 높일 수 있습니다.

func (r Receiver) methodName() int {
	return r.width * r.height
}

아래 예제를 확인해보면, 기존의 함수와 메서드의 차이점을 알 수 있습니다.

package main  

import "fmt"  

type account struct {  
  balance int  
}  

func withdrawFunc(a *account, amount int) {  
  a.balance -= amount  
}  

func (a *account) withdrawMethod(amount int) {  
  a.balance -= amount  
}  

func main() {  
  a := &account{1000}  
  withdrawFunc(a, 30)  
  fmt.Printf("잔액: %d\n", a.balance)  

  a.withdrawMethod(50)  
  fmt.Printf("잔액: %d\n", a.balance)  
}

잔액: 970
잔액: 920

포인터 함수로 선언된 a를 함수를 이용하는 방법과 메서드를 이용하는 방법에 대해 알아보았습니다.

메서드는 리시버타입인 *account에 속해있고, 그렇게 때문에 a.withdrawMethod(50) 같은 방식으로 사용할 수 있습니다.

모든 로컬 타입들은 리시버가 될 수 있습니다.
만약, int와 같은 타입에도 메서드를 활용하고 싶다면 별칭타입을 선언해두고 메서드를 선언하면 됩니다.

int 타입에 별칭을 정의한 후 아래와 같이 메서드를 설정할 수 있습니다.

type myInt int  

func (a myInt) add(b int) int {  
  return int(a) + b  
}

func main() {  
  var a myInt = 10  
  fmt.Println(a.add(5))  
  var b = 10  
  fmt.Println(myInt(b).add(5))  
}

포인터 메서드, 값타입 메서드

리시버로 이용하는 타입을 포인터를 이용하여 메서드 수행결과를 전달할 수도 있고,
또는 값으로 넘겨주되 리턴타입으로 반환하는 방법이 있습니다.

package main  

import "fmt"  

type account struct {  
  balance int  
}  

func (a *account) withdrawPointer(amount int) {  
  a.balance -= amount  
}  

func (a account) withdrawRetureValue(amount int) account {  
  a.balance -= amount  
  return a  
}  

func main() {  
  a := account{1000}  

  (&a).withdrawPointer(50)  
  fmt.Printf("a 잔액: %d\n", a.balance)  

  fmt.Println("------------")  

  a2 := a.withdrawRetureValue(30)  
  fmt.Printf("a 잔액: %d\n", a.balance)  
  fmt.Printf("a2 잔액: %d\n", a2.balance)  
}

a 잔액: 950
------------
a 잔액: 950
a2 잔액: 920

리시버를 포인터로 설정하는 withdrawPointer 메서드는 수행한 후, 원본인 a의 값에 영향을 줍니다

그러나, 값으로 리시버를 받으면서 리턴하는 withdrawRetureValue 메서드는, 리시버값을 새로 메모리에 복사한 후 메서드 수행결과를 리턴하기 때문에, a2에는 우리가 원하는대로 920이 출력되지만, 기존 원본값인 a에는 영향을 주지 않습니다.

이러한 성질을 잘 유의하여 상황에 맞게 메서드를 선언해야합니다.

[Go] 10. 패키지

jiniya22 — Sat, 20 Jan 2024 19:04:25 +0900

package는 Go에서 코드를 묶는 가장 큰 단위입니다

구조체로 데이터를 묶고, 함수로 코드를 묶었다면
패키지는 함수와 구조체 그리고 그외의 코드를 묶습니다.

main패키지는 프로그램의 시작점인 main()함수를 포함한 패키지 입니다. (프로그램의 시작점이기 때문에 필수 요소입니다)

하나의 프로그램은 main패키지 하나와 0개 이상의 외부 패키지로 구성됩니다.

패키지명은 아래와 같은 규칙으로 만드는 것을 권장합니다.

최대한 간소하게
소문자만을 이용하여 만들기

GoLang Standard library 에서 유용한 패키지를 학습하고, 표준 패키지에서 제공하고 있는 기능이라면 활용하여 서비스를 구현하는 것이 좋습니다.

Awesome Go 에서도 많이 사용되는 패키지를 참고할 수 있습니다.

1. 패키지 import

Go에서 import된 패키지를 찾는 방법은 아래와 같습니다.

Go설치 경로로부터 Go 기본제공 패키지(fmt 등...)를 찾고
외부 repository(GitHub 등...)에 저장된 패키지의 경우, 다운받아서 GOPATH/pkg 에 설치합니다.
1. go env GOPATH 명령어로 GOPATH를 조회할 수 있습니다.
현재 모듈 하위에 위치한 패키지를 조회합니다.

import할 패키지가 하나라면 큰따옴표로 패키지명을 감싸서 아래와 같이 작성하면 되고

import "fmt"

여러개면 아래와 같이 소괄호로 감싸서 import합니다
경로가 있을 경우에는 경로를 그대로 작성하고, 맨마지막 디렉토리명을 이용하여 메서드를 이용합니다.

아래는 math/rand 패키지를 이용하여 0이상 10미만의 랜덤수 10개를 출력하는 코드입니다.

package main  

import (  
  "fmt"  
  "math/rand"
)  

func main() {  
  for i := 0; i < 10; i++ {  
   fmt.Print(rand.Intn(10), " ")  
  }  
}

만약, 패키지 명이 동일한 패키지를 import해야한다면, 패키지명 앞에 별명을 붙여주면 됩니다.

import (
	"text/template"
	htemplate "html/template"
)

사용하지 않는 패키지명을 import할 경우, 에러가 납니다.
사용하지는 않지만 부가효과를 이용하기 위해 import가 필요한 경우에는 패키지명 앞에 _를 붙여주면 됩니다.

부가효과란 패키지가 초기화되면서 실행되는 코드에 따른 효과를 의미합니다.

import (
	_ "github.com/mattn/go-sqlite3"
)

2. Go모듈

Go 1.16 이상의 버전에서는 모든 Go코드는 Go모듈 아래에 있어야 합니다.

이전 버전의 경우, Go모듈을 만들지 않은 Go코드는 GOPATH/src 아래에 위치시켜야 했습니다

go build 하기 위해서는 Go모듈 루트 폴더에 go.mod 파일이 반드시 있어야 합니다.

go.mod 파일은 Go 버전, 필요한 외부 패키지 등이 명시된 파일입니다

Go모듈을 만드는 방법은 아래의 명령을 통해 go.mod 파일을 생성하는 것입니다.

go mod init 패키지명

go.mod 파일이 생성되면 go build 명령으로 빌드가 가능해지고, 빌드를 하면 Go 실행파일이 생성됩니다.

2.1. 모듈 활용 실습

goproject 프로젝트 내에서 usepkg 디렉토리를 만든 후, 그 디렉토리로 이동하여

mkdir usepkg
cd usepkg

아래의 명령어를 이용하여 usepkg디렉토리가 모듈 작동되도록 합니다.

go mod init goproject/usepkg

그러면 아래와 같은 내용을 담고 있는 go.mod파일이 생성됩니다.

module goproject/usepkg

go 1.21.5

2.1.1. 모듈 내 패키지 만들기

usepkg 내에 custompkg디렉토리를 만들고, custompkg.go를 만듭니다.

mkdir custompkg
cd custompkg
vim custompkg.go

package custompkg  

import "fmt"  

func PrintLine() {  
  fmt.Println("-----------")  
}

2.1.2. 모듈 내 패키지 및 외부 repository 패키지 활용

다시 상위 디렉토리인 usepkg로 이동하여, usepkg.go를 생성하고 모듈내에 있는 패키지를 활용해봅니다.

cd ..
touch usepkg.go

조금 전에 생성한 모듈과 ("goproject/usepkg/custompkg")
github에 있는 외부 repository 패키지를 import하여 함수를 사용해보았습니다.

package main  

import (  
  "fmt"  
  "github.com/guptarohit/asciigraph"  
  "goproject/usepkg/custompkg"
)  

func main() {  
  custompkg.PrintLine()  
  data := []float64{3, 4, 5, 8, 10, 5, 2}  
  graph := asciigraph.Plot(data)  
  fmt.Println(graph)  
}

go mod tidy 명령어를 이용하여 필요한 외부 패키지를 다운받습니다.

go mod tidy

그러면 외부 패키지가 다운로드 받아지고, go.mod 파일에 맨 아래줄이 추가된 것을 확인할 수 있으며, go.sum 파일이 생성됩니다.

module goproject/usepkg  

go 1.21.5  

require github.com/guptarohit/asciigraph v0.5.6

go.sum 파일에도 패키지의 버전정보가 기입되어있는데, 패키지의 위조 여부를 검사하기 위한 checksum 결과를 답고 있습니다.

github.com/guptarohit/asciigraph v0.5.6 h1:0tra3HEhfdj1sP/9IedrCpfSiXYTtHdCgBhBL09Yx6E=  
github.com/guptarohit/asciigraph v0.5.6/go.mod h1:dYl5wwK4gNsnFf9Zp+l06rFiDZ5YtXM6x7SRWZ3KGag=

필요한 패키지를 모두 다운받았으니, 이제 빌드 후 프로그램을 실행할 수 있습니다.

go build
./usepkg

-----------
 10.00 ┤   ╭╮
  9.00 ┤   ││
  8.00 ┤  ╭╯│
  7.00 ┤  │ │
  6.00 ┤  │ │
  5.00 ┤ ╭╯ ╰╮
  4.00 ┤╭╯   │
  3.00 ┼╯    │
  2.00 ┤     ╰

다운받은 외부 패키지 모듈은 GOPATH/pkg/mod 에 설치됩니다.

MacOS의 경우 ~/go 하위에 설치됩니다.

이미 다운받은 패키지를 다른 모듈에서 활용할 때에는, 다운로드하지 않고 기존에 다운받았던 모듈을 사용합니다.

3. 패키지 외부 공개

ch16디렉토리 하위에 모듈로 이용할 ex16.2 디렉토리를 생성한 후, 그 디렉토리로 이동한 후, go mod init 명령어를 실행합니다.

cd ch16
mkdir ex16.2
cd ex16.2
go mod init ch16/ex16.2

mkdir publicpkg
cd publicpkg
vim publicpkg.go

publicpkg.go 파일에 변수와 상수, 구조체, 함수 등을 공개형과 비공개형을 정의해봅니다.

맨 첫번째 문자를 대문자로 설정할 경우 공개형태가 되고, 소문자로 설정할 경우 비공개형태가 됩니다.

package publicpkg  

import "fmt"  

const (  
  PI = 3.1415  
  pi = 3.14  
)  

var ScreenSize = 1080  
var screenHeight int  

func PublicFunc() {  
  const MyConst = 100  
  fmt.Println("PublicFunc 는 공개함수입니다!", MyConst)  
}  

func privateFunc() {  
  fmt.Println("privateFunc 는 비공개함수입니다!")  
}  

type MyInt int  
type myString string  

type MyStruct struct {  
  Age  int  
  Name string  
}  

func (m MyStruct) PublicMethod() {  
  fmt.Println("MyStruct 에 들어있는 공개 메서드")  
}  

func (m MyStruct) privateMethod() {  
  fmt.Println("MyStruct 에 들어있는 비공개 메서드")  
}  

type myPrivateStruct struct {  
  Age  int  
  Name string  
}  

func (m myPrivateStruct) PrivateMethod() {  
  fmt.Println("myPrivateStruct 에 들어있는 비공개 메서드")  
}

상위 디렉토리로 이동한 후, ex16.2.go 파일을 생성하고, 조금 전에 정의한 공개변수/구조체/함수를 사용해봅시다.

package main  

import (  
  "ch16/ex16.2/publicpkg"  
  "fmt")  

func main() {  
  fmt.Printf("PI: %v, ScreenSize: %v\n", publicpkg.PI, publicpkg.ScreenSize)  
  publicpkg.PublicFunc()  

  var myInt publicpkg.MyInt = 10  
  fmt.Println("myInt:", myInt)  

  myStruct := publicpkg.MyStruct{Name: "jini"}  
  fmt.Println(myStruct)  
  myStruct.PublicMethod()  
}

PI:  3.1415
PublicFunc 는 공개함수입니다! 100
myInt: 10
{0 jini}
MyStruct 에 들어있는 공개 메서드

publicpkg 모듈내에서 공개형만 접근가능합니다!

4. 패키지 초기화

패키지를 import 했을 때, 아래의 동작 과정을 거칩니다.

컴파일러가 패키지 내의 전역변수를 초기화
패키지에 init()함수가 있을 경우, init()함수를 호출하여 패키지를 초기화함
1. init() 함수는 반드시 입력 매개변수와 반환값이 없는 함수여야 합니다.

go에서 어떤 패키지를 사용하지는 않지만, 패키지에 정의된 패키지 초기함수인 init()함수의 기능을 원한다면, 아래와 같이 _ 을 이용하여 임포트하면 됩니다.

Go에서 import하였으나, 사용하지 않을 경우 에러가 발생되기 때문에

import (
	_ "github.com/mattn/go-sqlite3"
)

ex16.3 모듈을 만든 후,

mkdir ex16.3
cd ex16.3
go mod init ch16/ex16.3

mkdir exinit
vim exinit.go

패키지 초기화에 대해 알아보기 위한 예제를 작성해봅니다.

package exinit  

import "fmt"  

var (  
  a = c + b  
  b = f()  
  c = f()  
  d = 3  
)  

func init() {  
  d++  
  fmt.Println("init 함수 실행! d: ", d)  
}  

func f() int {  
  d++  
  fmt.Println("f() 함수 실행! d: ", d)  
  return d  
}  

func PrintD() {  
  fmt.Println("d: ", d)  
}

import 함수에서 exinit 패키지를 import할 때,
exinit 패키지 내에 정의된 변수의 초기화와 init()함수가 실행됩니다.
그 후에, main함수가 실행을 시작합니다.

package main  

import (  
  "ch16/ex16.3/exinit"  
  "fmt")  

func main() {  
  fmt.Println("------")  
  exinit.PrintD()  
}

f() 함수 실행! d:  4
f() 함수 실행! d:  5
init 함수 실행! d:  6
------
d:  6

[Go] 09. 문자열

jiniya22 — Thu, 18 Jan 2024 17:00:35 +0900

문자 집합으로 타입명은 string입니다.
쌍따옴표(") 또는 backtick(`)으로 감싸서 정의합니다.

backtick으로 감쌀 경우, 문자열 안에 들어있는 특수문자(\t, \n 등)를 문자자체로 인식합니다.

utf-8을 표준 문자코드로 사용한다
- ansi에 있는 문자들은 1byte로 표현(영문자, 숫자, 일부특수문자)
  - ansi = ascii코드(7bit)의 확장판
- 그외의 문자들은 2~3byte로 표현
- ansi문자에 해당하는 문자는 1byte로 표현하면서 다국어문자를 표현가능하기 때문에 합리적입니다
문자열 일치여부는 ==, != 로 비교합니다
>, >=, <, <=로 문자열 비교할 수 있고, 문자열 비교는 맨 앞글자부터 한 글자씩 비교합니다.
문자열 대입시 문자열 자체의 복사가 아니라 같은 메모리를 가리키도록 하기 때문에, 문자열 대입은 성능에 영향을 주지 않습니다.
- 문자열의 주소값까지 함께 복사됩니다.
문자열은 불변 입니다

쌍따옴표로 감싼 문자열은 특수문자 처리가 되지만

s1 := "apple\tbanana\nmelon"  
fmt.Println(s1)

apple   banana
melon

backtick으로 감싼 문자열은 문자로 인식합니다.

s2 := `red\tblue\norange`  
fmt.Println(s2)

red\tblue\norange

1. rune

이전에 변수에 대한 포스팅에서 잠깐 소개했었던 rune 데이터 타입은 int32 데이터 타입의 alias입니다.
utf-8문자를 표현하기 위해서는 최소 1byte ~ 3byte가 필요합니다.

그러나, 3byte에 해당하는 정수타입은 없기 때문에 4byte 정수타입인 int32타입을 문자 하나를 표현하는데에 사용합니다.

문자하나를 표현되는 int32타입을 편의상 rune 이라는 타입을 이용하여 정의합니다.

java 에서 char값을 숫자와 문자로 표현할 수 있었던 것 처럼, go에서도 rune타입의 값을 문자나 숫자로 표현할 수 있습니다

var ch rune  
ch = '가'  
fmt.Printf("%%c : %c, %%d: %d, 데이터 타입: %T", ch, ch, ch)

%c : 가, %d: 44032, 데이터 타입: int32

2. 문자열 메모리크기

len() 내장함수를 문자열에 사용하면, 그 문자열의 메모리 크기를 구할 수 있습니다. (문자열 길이가 아닙니다)

ansi문자에 해당하는 영문자, 숫자는 각 문자당 1byte의 메모리 크기를 차지하기 때문에 4가 출력되지만

s1 := "abC4"  
fmt.Println(len(s1))

한글은 한문자당 3byte의 메모리 크기를 차지하기 때문에 3 * 3 = 9 가 출력됩니다.

s2 := "가나다"   
fmt.Println(len(s2))

3. 문자열 길이

문자열에 포함된 글자수(= 길이)를 알아내고 싶다면, 문자열을 []rune 타입으로 변환한 후 len() 내장함수로 길이를 구하면 됩니다.

[]rune 은 가변길이 배열인 slice 타입입니다.

s1 := "abC4"  
s2 := "가나다"  

r1 := []rune(s1)  
r2 := []rune(s2)  

fmt.Println(len(r1))  
fmt.Println(len(r2))

4
3

[]rune 타입으로 변경한 후에는 문자열 길이를 구할 수 있습니다.

4. 문자열 순회

4.1. 잘못 작성한 문자열 순회

문자열에 len() 함수를 적용할 경우, 문자열 메모리 크기를 반환합니다.

그렇기 때문에 java에서 자주 이용하는 방식대로 for i 반복문을 이용할 경우,
문자하나씩 출력되는 것이 아니라, 1byte씩 읽어들이기 때문에
ANSI문자에 해당하는 A, B, 1, 2는 잘 출력되지만 가, 나 는 각각 3개씩 쪼개져서 이상한 문자로 출력되게 됩니다.

또, 이 문자들의 데이터타입은 uint8로 출력되는데
uint8은 alias로 byte와 같은 타입입니다.
문자열에 len을 바로 적용할 경우 byte단위로 읽어집니다.

s := "AB12가나"  
for i := 0; i < len(s); i++ {  
  fmt.Printf("%%d: %d, %%c: %c (%T)\n", s[i], s[i], s[i])  
}

%d: 65, %c: A (uint8)
%d: 66, %c: B (uint8)
%d: 49, %c: 1 (uint8)
%d: 50, %c: 2 (uint8)
%d: 234, %c: ê (uint8)
%d: 176, %c: ° (uint8)
%d: 128, %c: � (uint8)
%d: 235, %c: ë (uint8)
%d: 130, %c: � (uint8)
%d: 152, %c: � (uint8)

4.2. []rune 변환후 순회

문자열을 []rune 타입으로 변환하는 것은 문자로 이뤄진 가변배열로 변환하는 것이기 때문에,
배열의 각 요소를 출력하면 문자를 순회하는 것이 가능합니다.

s := "AB12가나"
arr := []rune(s)  
for i := 0; i < len(arr); i++ {  
  fmt.Printf("%%d: %d, %%c: %c (%T)\n", arr[i], arr[i], arr[i])  
}

%d: 65, %c: A (int32)
%d: 66, %c: B (int32)
%d: 49, %c: 1 (int32)
%d: 50, %c: 2 (int32)
%d: 44032, %c: 가 (int32)
%d: 45208, %c: 나 (int32)

4.3. range 키워드로 순회 추천**

더 간편한 방식으로, for range를 string에 적용하면, 문자열을 순회할 수 있습니다.
[]rune 타입으로 변환하는 방법에서는, 데이터타입 변환을 위한 작업(메모리 할당 등...)을 행해야하지만, for range로 문자열을 순회하는 방법은 그러한 작업이 없기 때문에 메모리 낭비

s := "AB12가나"
for _, v := range s {  
  fmt.Printf("%%d: %d, %%c: %c (%T)\n", v, v, v)  
}

%d: 65, %c: A (int32)
%d: 66, %c: B (int32)
%d: 49, %c: 1 (int32)
%d: 50, %c: 2 (int32)
%d: 44032, %c: 가 (int32)
%d: 45208, %c: 나 (int32)

5. 문자열 합치기

+ 연산자를 이용하여 문자열을 합칠 수 있으며,
+= 를 이용하여 기존 문자열에 문자열을 합칠 수도 있습니다.

s1 := "hi"  
s2 := "wow"  
s3 := s1 + " " + s2  
s1 += " " + s2  

fmt.Println(s3)  
fmt.Println(s1)

hi wow
hi wow

6. 문자열 대입

문자열을 대입할 때에는, 다른 변수들과 달리 주소값도 함께 복사됩니다.
따라서, 새로 복사되는 것이 아니라 같은 메모리를 바라보게 되기 때문에 성능을 떨어뜨리지 않습니다.

문자열은 내부에 포인터와 길이 필드로 구성되어있습니다. 아래 예제를 통해 실제 문자열이 가리키고 있는 메모리의 주소와 길이 등을 확인해볼 수 있습니다.

package main  

import (  
  "fmt"  
  "reflect"  "unsafe")  

func main() {  
  s1 := "apple"  
  s2 := s1  
  fmt.Printf("s1의 주소: %p, %d\n", unsafe.StringData(s1), unsafe.StringData(s1))  
  fmt.Printf("s2의 주소: %p, %d\n", unsafe.StringData(s2), unsafe.StringData(s2))  

  fmt.Println((*reflect.StringHeader)(unsafe.Pointer(&s1)))  
  fmt.Println((*reflect.StringHeader)(unsafe.Pointer(&s2)))  
}

s1의 주소: 0x100f4ca75, 4311009909
s2의 주소: 0x100f4ca75, 4311009909
&{4311009909 5}
&{4311009909 5}

StringHeader 구조체는 주소와 문자열길이를 담고 있습니다.

7. 문자열은 불변

문자열은 불변타입입니다.

이러한 성질로 인하여 문자열 내의 특정 문자를 변경하는 것은 불가하며
문자열 합성시에는 새로운 메모리공간에 두 문자열을 합치는 행위를 합니다.

아래의 예제코드에서 문자열 합산 이후 s1의 주소가 변경된 것을 확인할 수 있습니다.

package main  

import (  
  "fmt"  
  "unsafe")  

func main() {  
  s1 := "test"  
  fmt.Printf("최초의 s1의 주소: %p\n", unsafe.StringData(s1))  

  s1 += "123"  
  fmt.Printf("문자열 합산 후 s1의 주소: %p\n", unsafe.StringData(s1))  
}

최초의 s1의 주소: 0x102428650
문자열 합산 후 s1의 주소: 0x140000a4012

8. 문자열 합산이 빈번하다면 strings.Builder로

문자열 합신이 빈번하다면, strings 패키지의 Builder를 이용하면 메모리 낭비를 줄일 수 있습니다.

strings.Builder는 내부에 []byte 를 가지고 있기 떄문에 문자 추가시 매번 메모리를 새로 생성하지 않기 때문에 공간 낭비가 적습니다.

package main  

import (  
  "fmt"  
  "strings")  

func main() {  
  fmt.Println(ToUpper("Hello World!"))  
}  

func ToUpper(s string) string {  
  var builder strings.Builder  
  for _, ch := range s {  
   if ch >= 'a' && ch <= 'z' {  
    builder.WriteRune('A' + (ch - 'a'))  
   } else {  
    builder.WriteRune(ch)  
   }  

  }  
  return builder.String()  
}

[Go] 08. 포인터

jiniya22 — Thu, 18 Jan 2024 01:25:27 +0900

1. 포인터?

포인터는 변수가 위치한 주소를 값으로 갖는 타입입니다.
데이터타입 왼쪽에 *를 붙여서 선언합니다.

*int, *float64 등...

데이터가 들어있는 변수왼쪽에 &를 붙이면 그 데이터의 주소를 얻을 수 있고,
포인터변수 왼쪽에 * 를 붙이면 포인터변수가 가리키고 있는 메모리(인스턴스)에 들어있는 실제 값을 얻을 수 있습니다.

기본값은 nil
함수 종료로 인해 사용을 마친 인스턴스는 가비지컬렉터에 의해 메모리 해제 됩니다.

데이터타입이 int인 변수 a의 주소를 값으로 갖고 있는 포인터 변수 p에 대한 예제를 확인해봅시다.

var a = 10  
var p *int  
p = &a  
fmt.Printf("a의 값: %d\n", a)  
fmt.Printf("p의 값: %p\n", p)  
fmt.Printf("p가 가리키고있는 메모리에 들어있는 값: %d\n", *p)  

fmt.Println("---------")  
*p = 100  
fmt.Printf("p가 가리키고있는 메모리에 들어있는 값: %d\n", *p)  
fmt.Printf("a의 값: %d", a)

a의 값: 10
p의 값: 0x14000112008
p가 가리키고있는 메모리에 들어있는 값: 10
---------
p가 가리키고있는 메모리에 들어있는 값: 100
a의 값: 100

포인터변수 p에 들어있는 값을 변경하자 a의 값도 변경된 것을 확인할 수 있습니다.

*p를 변경하는 것은 a를 변경하는 것과 같습니다.

2. 포인터를 쓰는 이유

변수 대입이나 함수인자를 전달하는 행위는 값을 복사합니다.
값을 복사하는 행위는 메모리 공간을 사용하기 때문에, 메모리 복사시 발생되는 성능적 이슈가 있습니다.

또, 복사된 값이기 때문에 복사된 값의 변경사항이 실제값에 반영되지 않는 점이 있습니다.

메모리 공간을 효율적으로 사용하고 싶거나 변경사항을 원문에도 반영하고 싶다면 포인터를 사용하는 것이 좋습니다.

go에서 함수 파라미터 값으로 구조체변수를 넘겨주는 행위는 구조체 변수값을 복사하는 행위입니다.

따라서, 아래의 예제에서, data변수는 ChangeData함수내로 복사가 되기 때문에, main함수 내의 data 와 ChangeData 함수내의 data의 주소는 각각 다르고,
ChangeData 함수내에서 값을 변경하여도, main 함수내의 data 변수는 변경되지 않습니다.

package main  

import "fmt"  

type Data struct {  
  value string  
  score [4]int  
}  

func main() {  
  var data Data  
  fmt.Printf("data.value의 주소값: %p\n", &data.value)  
  ChangeData(data)  
  fmt.Printf("data의 value: %s, score[3]: %d\n", data.value, data.score[3])  
}  

func ChangeData(data Data) {  
  fmt.Printf("ChangeData 내의 data.value의 주소값: %p\n", &data.value)  
  data.value = "temp"  
  data.score[3] = 100  
}

data.value의 주소값: 0x1400010e0c0
ChangeData 내의 data.value의 주소값: 0x1400010e0f0
data의 value: , score[3]: 0

위의 코드에서, data의 주소값을 넘겨주는 방식으로 변경합니다.

package main  

import "fmt"  

type Data struct {  
  value string  
  score [4]int  
}  

func main() {  
  var data Data  
  fmt.Printf("data.value의 주소값: %p\n", &data.value)  
  ChangeData(&data)  
  fmt.Printf("data의 value: %s, score[3]: %d\n", data.value, data.score[3])  
}  

func ChangeData(data *Data) {  
  fmt.Printf("ChangeData 내의 data.value의 주소값: %p\n", &data.value)  
  data.value = "temp"  
  data.score[3] = 100  
}

data.value의 주소값: 0x1400006a0c0
ChangeData 내의 data.value의 주소값: 0x1400006a0c0
data의 value: temp, score[3]: 100

ChangeData 함수내에서, data는 포인터변수이기 때문에 원래는 (*data).value = "temp" 와 같이 작성해야하지만, Go언어에서는 data.value = "temp" 로 설정할 수 있도록 편의를 제공하고 있습니다.

java 에서는 method에 객체의 인스턴스를 넘겨줄 때, 인스턴스명을 넘겨주는 것으로 가능했다면,
go에서는 구조체 포인터를 넘겨줘야하합니다.

한번 더 정리하자면, 아래에 있는 d1, d2, d3 인스턴스는 모두 각기 다른 인스턴스입니다. (d2, d3는 d1을 복사한 값이기 때문에)

var d1 Data
var d2 = d1
var d3 = d1

아래에 있는 a1, a2, a3 포인터 변수는 하나의 인스턴스를 가리키고 있습니다.

var a1 = &Data{}  
var a2 = a1  
var a3 = a2

3. 구조체 변수에 대한 포인터변수 초기화

구조체 변수에 & 을 붙여 포인터변수에 담을 수 있지만

type User struct {  
  Name string  
  Age  int  
}

func main() {  
  var u User  
  var p1 = &u  
  fmt.Println(*p1)
}

&User{} 와 같은 방식으로 한번에 초기값을 대입할 수도 있고, (p2의 데이터타입은 *User)

var p2 = &User{}  
fmt.Println(*p2)

new() 내장함수를 이용하여 초기화 할 수도 있습니다.

var p3 = new(User)  
fmt.Println(*p3)

4. stack, heap

보통 함수 내에서만 이용하는 값은 stack 메모리 영역을 사용하고,
함수 외부에 공개되어있는 값은 heap 메모리 영역을 사용합니다.

기본적으로, 함수 내부에서 정의한 변수의 경우, 함수를 종료한 후 가비지 컬렉터에 의해 메모리 해제되지만,
함수 내에서 생성한 변수의 주소값을 반환한다면, 이는 함수가 종료되더라도 메모리 해제가 되지 않습니다.
즉, 이 경우에는 heap 메모리 영역에 할당됩니다.

package main  

import "fmt"  

type User struct {  
  Name string  
  Age  int  
}  

func main() {  
  pUser := NewUser("jini", 32)  
  fmt.Println(*pUser)  
}  

func NewUser(name string, age int) *User {  
  return &User{Name: name, Age: age}  
}

{jini 32}

[Go] 07. 배열, 구조체

jiniya22 — Wed, 17 Jan 2024 17:00:51 +0900

1. 배열

같은 타입의 데이터들로 이루어져 있습니다.

배열을 이루는 각 값을 elemenet(요소), 위치값은 index라고 합니다.

var 변수명 [요소 개수]타입

배열 요소수는 상수 값만 설정할 수 있습니다.
배열의 길이는 len(배열명) 으로 구할 수 있습니다.
range를 이용하면 for순회하면서 인덱스와 값을 함께 조회할 수 있습니다.
배열의 길이는 설정하였으나 값을 설정하지 않거나 구조체 변수의 각 필드값을 초기화 하지 않을 경우, 각 데이터 타입의 기본값으로 초기화 됩니다.
배열이나 구조체와 같이 중괄호를 이용하여 초기값을 설정하는 변수들은 }가 새로운 줄에 위치하지 않을 경우 반드시 , 를 작성해줘야합니다.

1.1. 배열 초기화

arr := [5]float32{3.14, 5.9, 9.0, 7, 12.3}  

for i := 0; i < len(arr); i++ {  
  fmt.Println(arr[i])  
}

실수의 경우, format을 지정하지 않으면 최소 소수점 까지 표시하기 때문에 9.0, 7은 모두 9, 7로 출력됩니다.

배열을 선언하고 초기화를 하지 않는다면, 각 데이터 타입에 따른 기본값으로 초기화됩니다. (정수 데이터의 경우에는 0)

var arr [3]int  
fmt.Println(arr)

[0 0 0]

아래와 같이, 배열의 길이에 비해 초기화에 이용되는 요소수가 적을 경우에는, 맨 앞 인덱스부터 할당되고 나머지는 데이터타입에 맞는 기본값이 설정됩니다.

arr := [5]int{5, 2}  
fmt.Println(arr)

[5 2 0 0 0]

아래와 같이 `인덱스:값` 방식으로 배열을 초기화하면 특정 인덱스에만 요소를 초기화할 수도 있습니다.

arr := [5]int{2: 11, 4: 98}  
fmt.Println(arr)

[0 0 11 0 98]

배열 요소 개수를 생략하고 싶다면 [...] 를 사용하면 됩니다.

arr := [...]string{"red", "blue", "green"}  
fmt.Println(arr, len(arr))

[red blue green] 3

1.2. range

for range 를 이용하면 배열을 순회하면서 인덱스, 값 을 조회할 수 있습니다.

range는 array외에도 slice, string, map, channel에도 사용할 수 있습니다.

arr := [...]string{"red", "blue", "green"}  
for i, v := range arr {  
  fmt.Println(i, v)  
}

0 red
1 blue
2 green

만약, 인덱스가 필요없다면, 아래와 같이 작성하면 됩니다.
for _, v := range { }

1.3. 배열 주소

arr := [...]int16{11, 12, 13}  
for i := 0; i < len(arr); i++ {  
  fmt.Printf("인덱스: %d, 값: %d, 주소값: %d\n", i, arr[i], &arr[i])  
}

인덱스: 0, 값: 11, 주소값: 1374390206482
인덱스: 1, 값: 12, 주소값: 1374390206484
인덱스: 2, 값: 13, 주소값: 1374390206486

배열은 연속된 메모리공간에 저장되기 때문에, 각 요소의 주소는 요소의 데이터타입 크기에 따라 달라집니다.
배열 주소는 1바이트(= 8bit)당 1차이가 납니다.

즉, int8타입의 경우, 각 배열요소의 주소차이가 1이고
int16타입은 2, int64는 8씩 차이가 납니다.

1.4. 배열 복사

데이터타입과 배열 크기가 같은 경우,
아래와 같이 배열간의 대입 방식(a = b )으로 b에 들어있는 값을 a 배열의 각 메모리 공간에 복사할 수 있습니다.

복사 시, 각 배열의 주소값은 변하지 않습니다.

a := [3]int{10, 20, 30}  
b := [3]int{1, 2, 3}  
fmt.Println(a)  
fmt.Println(b)  

fmt.Println("-----------")

a = b  
fmt.Println(a)  
fmt.Println(b)

[10 20 30] 0x140000a8018
[1 2 3] 0x140000a8030
-----------
[1 2 3] 0x140000a8018
[1 2 3] 0x140000a8030

1.5. 다중 배열

데이터타입이 int이면서, 요소가 5개인 배열이 2개인 이중배열은 표현하는 방법은 아래와 같습니다.

var arr [2][5]int

배열을 닫는 } 를 배열 항목과 같은 줄에 작성할 때에는 , 를 생략해도 되지만

a := [2][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}

다른 줄에 있을 때에는 반드시 , 를 작성해야 합니다.

배열 외에도 구조체 등과 같이 괄호를 이용하여 값을 초기화할 수 있는 데이터타입들은 이와 같은 특징을 가지고 있습니다.

a := [2][5]int{  
  {1, 2, 3, 4, 5},  
  {6, 7, 8, 9, 10},  
}

기본 배열에서 아래와 같이 작성할 경우에는 ,를 찍어줘야 합니다.

b := [...]int{1, 2, 3, 4, 5,
}

간단하게, 위의 배열을 이용한 예제를 확인해봅시다.

a := [2][5]int{  
  {1, 2, 3, 4, 5},  
  {6, 7, 8, 9, 10},  
}  

fmt.Println(a)  
fmt.Println(a[0])  
fmt.Println(a[1])

[[1 2 3 4 5] [6 7 8 9 10]]
[1 2 3 4 5]
[6 7 8 9 10]

a[0]에 해당하는 값이 바로 {1, 2, 3, 4, 5} 입니다.

2. 구조체

구조체의 크기는 구조체 내에 정의된 필드들의 데이터크기를 모두 합산한 값입니다.
- int타입 필드 1개와 float64타입 필드 1개로 구성되어있다면 8byte + 8byte = 16byte
(배열과 같이) 대입연산으로 구조체 값 복사가 가능합니다.
- m1 = m2

2.1. 구조체 선언

(타입이 같거나 다른) 여러개의 변수를 하나로 묶은 타입을 구조체(structure)라고 합니다.

구조체는 사용자가 직접 타입을 만들기 때문에 type키워드를 사용하여 선언해야 합니다.

이전 시간에, const 목록을 이용한 enum 정의 부분에서, 아래와 같이 타입을 정의했던 것처럼

type ColorType int

const (
	Red ColorType = iota
	Blue
	Yellow
	Black
)

아래와 같은 형태로 구조체를 정의합니다.

type 구조체타입명 struct {
	필드명 데이터타입
}

구조체명과 필드명의 맨 첫번째 글자를 대문자로 정의할 경우, 패키지 외부로 공개(public)되는 타입입니다.

2.2. 기본 사용법

선언과 동시에 모든 필드값을 초기화시키고자할 때, 기본적으로 아래와 같이 필드명: 값 형태로 초기화 하며, 이렇게 필드명을 직접 설정할 때에는 일부 변수만 초기화 할 수 있습니다.

package main  

import "fmt"  

type Member struct {  
  Name string  
  Age  int  
}  

func main() {  
  m1 := Member{Name: "jay", Age: 38}  
  fmt.Println(m2)

  m2 := Member{Name: "jane"}  
  fmt.Println(m2)  
}

{jay 38}
{janae 0}

모든 필드를 초기화할 경우에는 필드명을 생략할 수 있고

m1 := Member{"jini", 32}  
fmt.Println(m1)

초기화시, 맨 마지막 }를 선언필드와 별도의 줄로 작성할 때에는 반드시 , 를 작성해야 합니다.

m3 := Member{  
  "rora",  
  29,  
}

타입을 먼저 선언하고 나중에 값을 설정할 수도 있습니다.

var m2 Member  
m2.name = "coco"  
m2.age = 22

2.3. 메모리 정렬

데이터에 효과적으로 접근하기 위해 메모리를 일정 크기 간격으로 정렬 하는 것

레지스터의 크기와 데이터의 크기가 같게 정렬되어있을 경우에 데이터를 효율적으로 읽어들일 수 있습니다.

레지스터는 실제 연산에 사용되는 데이터가 저장되는 곳으로, 레지스터 크기가 8byte인 컴퓨터를 64bit 컴퓨터라고 부릅니다.

package main  

import (  
  "fmt"  
  "unsafe")  

type Student struct {  
  Age   int32  
  Score float64  
}

func main() {  

  u1 := Student{Age: 32, Score: 9.5}  
  fmt.Println(unsafe.Sizeof(u1), &u1.Age, &u1.Score)
}

16 0x14000112010 0x14000112018

64bit 컴퓨터의 경우에는 각 데이터를 8의 배수에 담는 것이 효율적이기 때문에, 데이터 시작 주소는 8의 주소 배수에 위치합니다.

그리고, 구조체 내의 변수는 각 타입에 따라 타입의 byte수의 배수에 위치해 있습니다.
int32 타입은 4의 배수위치에, float64타입은 8의 배수 위치에 있습니다.

int8은 1의 배수, int16은 2의 배수

따라서, u1 데이터의 크기(unsafe.Sizeof) 결과가 16이 나옵니다.
이것을 그림으로 나타내면 아래와 같습니다.

이러한 성질을 토대로

int8타입의 필드 A, C, E와 int타입의 필드 B, D 로 구성된 User구조체가 있다고 할 때,
이 구조체의 필드 배치를 그대로 두는 것이 아니라
최적의 메모리 배치를 고려하여 패딩을 최소화하는 것이 좋습니다.

이렇게 생긴 구조체를

type User struct {  
  A int8  
  B int  
  C int8  
  D int  
  E int8  
}

이렇게 변경하면

type User struct {  
  A int8
  C int8
  E int8
  B int  
  D int
}

아래와 같이 메모리 낭비를 줄일 수 있습니다. (40 -> 24)

[Go] 06. if문, switch문, for문

jiniya22 — Tue, 16 Jan 2024 17:00:48 +0900

go에서는 java for문에서 초기값을 선언할 수 있는 것과 같이 if문과 switch문에서도 초기값을 선언할 수 있습니다.

1. if문

1.1. if 초기문; 조건문

go에서는 if문 내에서만 사용가능한 초기문을 선언할 수 있습니다.
단, 그 선언문문은 if-else 블럭 밖에서는 사용할 수 없습니다.

package main

import "fmt"

func main() {
	if age, ok := getAge(); ok && age < 20 {
		fmt.Println("You are young", age)
	} else if ok && age < 30 {
		fmt.Println("Nice age", age)
	} else if ok {
		fmt.Println("You are beautiful", age)
	} else {
		fmt.Println("Error")
	}
	// age, ok 사용 불가능
}

func getAge() (int, bool) {
	return 24, true
}

2. switch

go에서는 switch문의 case에서 break를 작성하지 않아도, 기본적으로 case하나 실행 후 switch문을 빠져나갑니다.

fallthrough 키워드를 이용할 경우, case 실행 후 그 다음 case도 실행하지만, 이 키워드는 코드 혼동을 주기 때문에 사용하지 않는 것을 권장합니다.

2.1. 여러값을 한번에 비교

switch문에서 하나의 case에 여러개의 값을 쉼표로 구문하여 비교할 수 있습니다.

package main

import "fmt"

func main() {
	day := "friday"

	switch day {
	case "friday":
		fmt.Println("금요일은 불금!")
	case "saturday", "sunday":
		fmt.Println("주말 너무 좋아요")
	default:
		fmt.Println("월화수목 월화수목")
	}
}

2.2. 조건문 비교

스위치의 비교값에 true를 넣어, if문과 같이 조건문 비교를 case에 설정할 수 있습니다.

이때, switch true {} 는 switch {}로 줄여쓸 수 있습니다.

switch true {

}

비교값이 true인 경우에는 case에 비교구문을 작성할 수 있습니다.

or 조건을 case에 작성하고 싶다면 , 또는 || 로 구분지어 조건을 나열하면 되고
and 조건은 && 를 사용하면 됩니다

switch {
case temp < 10, temp > 30:
  fmt.Println("놀러가기 좋지 않은 날씨입니다")
case temp > 15 && temp < 20:
  fmt.Println("적당한 겉옷을 입고 나가면 좋을 날씨입니다")
default:
  fmt.Println("기타")
}

2.3. switch문에서 초기문 사용

switch문에서도 초기문을 설정할 수 있으며, 초기문에 설정한 변수는 switch블럭 내에서만 사용 가능합니다.

package main

import "fmt"

func getAge() int {
	return 30
}
func main() {
	switch age := getAge(); age {
	case 18:
		fmt.Println("18살!")
	case 30:
		fmt.Println("30!!!")
	default:
		fmt.Println("내 나이는", age)
	}

	// switch 블록 밖에서는 age 변수 사용 불가
}

초기문 사용과 함께 조건문을 사용하고 싶다면 아래와 같이 비교값을 생략하면 됩니다.

switch age:= getAge(); {
}

2.4. switch문에 const 열거값 활용

const 열거값을 파라미터로 받아, 열거타입에 따른 switch case 실행하는 것도 자주 이용되는 방식입니다.

package main

import "fmt"

type ColorType int

const (
	Red ColorType = iota
	Blue
	Yellow
	Black
)

func colorToString(color ColorType) string {
	switch color {
	case Red:
		return "red"
	case Blue:
		return "blue"
	default:
		return "etc"
	}
}

func getMyColor() ColorType {
	return Blue
}

func main() {
	fmt.Println("내가 가장 좋아하는 색은", colorToString(getMyColor()))
}

3. for문

for문은 for 초기문; 조건문; 후처리 {}로 구성되며,
if문과 switch문과 마찬가지로 초기문에 선언된 변수는 for코드블럭 안에서만 사용가능합니다.

for i := 0; i < 10; i++ {
	fmt.Print(i, ", ")
}

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

초기문, 후처리는 생략 가능하고, 생략할 때에는 기본적으로 쉼표는 표시해야하나,

for i := 0; i < 10; {
	fmt.Print(i, ", ")
	i++
}

i := 0
for ; i < 10; i++ {
	fmt.Print(i, ", ")
}

조건문만 있는 경우에는 쉼표 생략이 가능합니다.

java에서 while문을 대신하는 기능입니다.

i = 0
for i < 10 {
	fmt.Print(i, ", ")
	i += 2
}

3.1. 무한루프

if문에서도 그랬던것 처럼 조건문에 true를 설정할 수 있습니다.
이를 이용하여 무한루프를 나타낼 수 있습니다.

for true {

}

조건문 true는 생략 가능하여 아래와 같이 간단한 형태도 가능합니다.

for {

}

3.2. continue, break

java에서 제공하는 continue, break도 지원합니다.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	stdin := bufio.NewReader(os.Stdin)
	for {
		fmt.Print("숫자를 입력하세요(종료: 0): ")
		var num int
		_, err := fmt.Scanln(&num)
		if err != nil {
			fmt.Println("Error! 숫자 값을 입력해야합니다")
			_, _ = stdin.ReadString('\n')
			continue
		}
		fmt.Printf("입력한 숫자는 %d 입니다\n", num)
		if num == 0 {
			break
		}
	}
	fmt.Println("End")
}

숫자를 입력하세요(종료: 0): 29
입력한 숫자는 29 입니다
숫자를 입력하세요(종료: 0): hi
Error! 숫자 값을 입력해야합니다
숫자를 입력하세요(종료: 0): 2
입력한 숫자는 2 입니다
숫자를 입력하세요(종료: 0): 0
입력한 숫자는 0 입니다
End

public void test() {
	hi
}

3.3. label

레이블을 설정하여, 중첩 for문에서 특정 for문을 종료시킬 수도 있습니다.

package main

import "fmt"

func main() {

	a := 1
	b := 1

OuterFor:
	for ; a <= 9; a++ {
		for b = 1; b <= 9; b++ {
			if a*b == 30 {
				break OuterFor
			}
		}
	}
	fmt.Printf("%d * %d = %d\n", a, b, a*b)
}

5 * 6 = 30

다만, label 을 이용한 반복문 종료는 사용자 혼란을 주는 면이 있기 때문에 사용하지 않는 것을 권장합니다.

또, 중첩 반복문은 최대한 제거하는 방향으로 코드를 작성하여, 플래그 변수나 레이블 사용 없이 코드를 작성하는 것을 권장합니다.

package main  

import "fmt"  

func main() {  
  a := 1  
  b := 1  

  for ; a <= 9; a++ {  
   var found bool  
   if b, found = find30(a); found {  
    break  
   }  
  }  
  fmt.Printf("%d * %d = %d\n", a, b, a*b)  
}  

func find30(a int) (int, bool) {  
  for b := 1; b <= 9; b++ {  
   if a*b == 30 {  
    return b, true  
   }  
  }  
  return 0, false  
}

[Go] 05. 함수, 상수

jiniya22 — Mon, 15 Jan 2024 17:00:51 +0900

1. 함수

func Func1(a int, b int) int {
    return a + b
}

함수명의 첫글자가 대문자일 경우 public 함수
함수명 옆 소괄호에 매개변수(parameter)를 설정합니다.
- 만일 매개변수가 없다면 비워둡니다.
매개변수 소괄호 오른쪽에 반환타입을 설정합니다.
- 반환타입이 없다면 비워둡니다.
중괄호 안에 함수 수행코드와, 반환타입이 존재할 경우, 마지막 줄에 반환값을 return 합니다.
- 함수 코드의 시작인 중괄호 { 는 반드시 함수 정의하는 func와 동일한 라인에 작성해야 합니다.
  - 아래와 같이 코드 블록을 작성할 수 없습니다.
```
func Func1(a int, b int) int
{ // Error
  return a + b
}
```

반환값은 여러개 설정할 수 있으며, 여러개일 경우에는 소괄호로 감싸줍니다.

func Divide(a, b int) (int, bool) {
  if b == 0 {
    return 0, false
  }
  return a / b, true
}

func main() {
  result, success := Divide(5, 3)
  fmt.Println(result, success) // 1 true
  result2, success := Divide(5, 0)
  fmt.Println(result2, success) // 0 false
}

2. 상수

2.1. 상수

최초로 선언된 후 변하지 않는 값을 정의하거나 코드값을 정의할 때 사용합니다.

정수, 실수, 문자열 등과 같은 primitive(기본 타입값) 만이 상수로 선언될 수 있으며,
구조체, 배열과 같은 타입은 상수로 사용할 수 없습니다.

그 밖의 primitive 타입으로는 bool, rune, complex가 있습니다.

상수는 var키워드 대신 const 키워드를 이용하여 선언합니다.

const ConstValue int = 5

2.2. iota

상수 목록을 iota 키워드를 사용하여 열거형 처럼 정의할 수 있습니다.
iota를 이용하면 증가하는 상수를 편리하게 선언할 수 있습니다.

아래와 같이 작성할 경우, 0부터 시작하여 각각 0, 1, 2로 초기화됩니다.

const (
	APPLE = iota
	BANANA
	GREEN
)

const 내의 상수 목록에서 최초로 iota를 사용할 때, 0으로 설정되는데

코드값을 다르게 적용하고 싶다면 아래와 같이 설정할 수 있고, 아래의 경우 각각 11, 12, 13으로 초기화 됩니다.

const (
	APPLE = iota + 11
	BANANA
	GREEN
)

쉬프트 연산자를 활용하여 10, 20, 40, 80 값을 열거형을 이용하여 초기화할 수도 있습니다.

const (
	C1 = 10 << iota
	C2
	C3
	C4
)

2.3. 타입 없는 상수

Go에서는 타입이 없는 상수를 정의할 수 있습니다.

아래와 같이, 타입없이 상수를 정의하면 타입 상관없이 연산이 가능합니다.

예를들어, 정수값이 들어있는 상수의 경우, 정수값들(int, int8, int32, int64)과 실수(float32, float64, complex32, complex64) 들과 연산이 가능합니다.

const LIMIT = 10

func main() {
	var a int8 = LIMIT * 4
	var a2 int32 = LIMIT * 8
	var a3 float32 = LIMIT * 8
	var a4 complex64 = LIMIT * 8
	var a5 = LIMIT * 2.38

	fmt.Printf("%v, %T\n", a, a)
	fmt.Printf("%v, %T\n", a2, a2)
	fmt.Printf("%v, %T\n", a3, a3)
	fmt.Printf("%v, %T\n", a4, a4)
	fmt.Printf("%v, %T\n", a5, a5)
}

40, int8
80, int32
80, float32
(80+0i), complex64
23.8, float64

실수타입의 상수의 경우,
정수타입에 담을수는 없지만, 변수에 선언된 값이 아닌 이상 정수/실수와 사칙연산은 문제없이 잘 되며
변수로 정의된 정수와는 연산되지 않습니다.

또, float32 타입과 float64 타입 모두와 연산이 가능하고, 그에 따라 리턴값을 받을 수 있습니다.

const PI = 3.14

func main() {
	var b float32 = PI * 2
	var b2 = PI * 1.2
	var b3 = PI + 8

	var c float32 = 8.12
	var b4 = PI * c

	var d = 9.87
	var b5 = PI * d

	//var a = 8
	//var b5 = PI * a		// Error

	fmt.Printf("%v, %T\n", b, b)
	fmt.Printf("%v, %T\n", b2, b2)
	fmt.Printf("%v, %T\n", b3, b3)
	fmt.Printf("%v, %T\n", b4, b4)
	fmt.Printf("%v, %T\n", b5, b5)
}

6.28, float32
3.768, float64
11.14, float64
25.496801, float32
30.991799999999998, float64

2.4. 리터럴

리터럴은 값 자체로 쓰여진 문구입니다.

Go에서는 컴파일될때 상수값이 리터럴로 변환됩니다.
이러한 성질로 인하여 상수 표현식을 활용한 계산은 컴파일시 리터럴로 변환되기 때문에 CPU 자원을 사용하지 않습니다.

예를들어 아래와 같이 작성된 코드에서, 변수 x는

const PI = 3.14
var x = 3.14 * 1000

컴파일 타임에 아래와 같이 변환됩니다

var x = 3140

상수는 컴파일시점에 리터럴로 변환됩니다.
그렇기 때문에 상수의 메모리 주소값에 접근할 수 없습니다
이 특징에 대해서 잘 명심하여, 개발시 유의해야합니다.

[Go] 03. fmt - 2. 표준입력

jiniya22 — Sun, 14 Jan 2024 23:10:11 +0900

1. 표준 입력

표준 입력장치(ex. 키보드)로부터 데이터를 입력받는 함수

Scan
- 표준 입력으로부터 값을 입력받습니다.
Scanln
- 표준 입력으로부터 한줄을 읽어서 값을 입력받습니다.
Scanf
- 표준 입력으로부터 서식형태로 값을 입력받습니다.

func Scan(a ...interface{}) (n int, err error)
func Scanln(a ...interface{}) (n int, err error)
func Scanf(format string, a ...interface{}) (n int, err error)

Scan함수는 입력받을 데이터가 들어있는 주소를 인자로 받아서,
입력 성공시 총 입력된 값의 개수를, 실패시에는 error를 반환합니다.

package main

import "fmt"

func main() {
	var a int
	var b int

	n, err := fmt.Scan(&a, &b)
	if err != nil {
		fmt.Println(n, err)
	} else {
		fmt.Println(n, a, b)
	}
}

입력받은 값을 공백으로 구분하여, a, b에 저장하며
입력 중 에러가 발생되지 않는다면, 입력된 데이터의 개수와 각 값을 출력하는 코드입니다.

예를들어, 10 20를 입력할 경우, 아래와 같이 출력되고,

2 10 20

2 hi와 같이 잘못된 데이터타입이 들어와서 에러가 발생했을시, 아래와 같이 에러문구를 함께 출력합니다.

1 expected integer

참고로, 첫번째 입력부터 오류가 발생했을시에는, 정상적으로 입력된 값이 없기 때문에 n이 0이 되기 때문에 0 expected integer를 출력합니다.

package main

import "fmt"

func main() {
	var a string
	var b string

	n, err := fmt.Scanf("%3s%2s", &a, &b)
	if err != nil {
		fmt.Println(n, err)
	} else {
		fmt.Println(n, a, b)
	}
}

abcde입력을, 서식에 맞춰 "abc", "de"로 입력받는것이 가능합니다

2 abc de

2. Scan 함수 동작 원리

사용자가 표준입력장치(ex. 키보드)로 입력하면, 입력데이터는 standard input stream(표준 입력 스트림, 컴퓨터 내부 메모리 공간)에 저장됩니다.

Scan함수는 표준입력 스트림으로부터 값을 읽어서 입력값을 처리합니다.

stream이라는 말에서 알 수 있듯, 데이터 흐름을 의미하며, 이 값은 한번 읽어들이면 다시 읽을수 없는 값입니다.

이때, 중요한 것은 Scan 함수 실행중, 오류가 발생했다고 하여 입력스트림 값이 비워지는 것이 아니라는 점입니다.

예를들어, 입력스트림에 "apple 3" 이라는 값이 들어있는데, Scan으로 받는 데이터 타입이 정수값일 경우, 맨첫번째 문자 "a"를 읽으면서 바로 오류가 발생되게 됩니다

그러나, 그 이후에 들어있는 "pple 3"은 아직 입력 스트림에 여전히 들어있는 상태입니다.

아래 예제를 통해 자세히 알아봅시다.

package main

import "fmt"

func main() {
	var a, b int

	n, err := fmt.Scan(&a, &b)
	if err != nil {
		fmt.Println(n, err)
	} else {
		fmt.Println(n, a, b)
	}

	var c, d string
	n, err = fmt.Scan(&c, &d)
	if err != nil {
		fmt.Println(n, err)
	} else {
		fmt.Println(n, c, d)
	}
}

apple 3를 입력했을 때, 오류가 발생되지만, 여전히 입력 스트림에는 "pple 3"가 남아있고, 이 값이 c와 d에 들어가게 됩니다.

0 expected integer
2 pple 3

3. 표준 입출력 스트림 비우기

bufio 패키지의 NewReader 객체는 줄바꿈(\n)이 나올 때까지 입력을 받기 때문에,
에러가 발생했을시, stdin.ReadString('\n')를 호출하면 표준 입출력 스트림을 비워지기 때문에 새로 표준 입출력을 입력받을 수 있습니다.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	stdin := bufio.NewReader(os.Stdin)
	var a, b int

	n, err := fmt.Scan(&a, &b)
	if err != nil {
		fmt.Println(n, err)
		stdin.ReadString('\n')
	} else {
		fmt.Println(n, a, b)
	}

	n, err = fmt.Scan(&a, &b)
	if err != nil {
		fmt.Println(n, err)
		stdin.ReadString('\n')
	} else {
		fmt.Println(n, a, b)
	}
}

[Go] 03. fmt - 1. 출력

jiniya22 — Sun, 14 Jan 2024 22:37:53 +0900

fmt 패키지는 OS가 제공하는 표준입출력(standard input/output)을 사용하여 프로그램 내부에서 입력/출력을 간편하게 처리하게 합니다.

Go언어의 기본 패키지입니다.

1. 출력용 함수

Print
- 함수 입력값을 출력
Println()
- 함수 입력값을 출력한 후 개행(new line)
Printf(서식문자열, 인수1, 인수2, ...)
- 입력값에 정의한 서식문자열에 맞춰 인수를 출력합니다

package main

import "fmt"

func main() {
	var n = 12345.6789
	fmt.Print("1)")
	fmt.Println("2) n: ", n)
	fmt.Printf("3) n: %f => %.2f\n", n, n)
	fmt.Println("finish!!")
}

1)2) n:  12345.6789
3) n: 12345.678900 => 12345.68
finish!!

실수타입을 서식없이 출력하면, 기본형태로 출력됩니다.(12345.6789)
실수타입을 "%f"로 출력하면, 설정된 데이터타입에 맞춘 실수값이 출력되며, 소수점을 지정해주면 설정한 소수점만큼 반올림하여 출력됩니다.

Println 함수는 쉼표로 구분지어 나열한 값을 공백 한칸을 두고 출력하고
Print 함수는 쉼표로 구분지어 나열한 값을 공백없이 출력합니다.

fmt.Println("apple", "banana")
fmt.Println("-------")
fmt.Print("apple", "banana")

apple banana
-------
applebanana

2. 서식문자

%v는 데이터 타입에 맞춰서 기본형태로 출력하고,
%T는 데이터 타입을 출력합니다.

자주 이용되는 서식문자열은 %d, %f, %s지만, 예제를 통해 그 외의 서식문자열에 대해 알아보도록 합시다.

2.1. 정수 서식

정수를 나타내는 서식문자열로는 아래와 같이 다양한 타입들이 존재하는데,
그 중 %d, %o(%O), %c는 정수 타입에만 적용할 수 있는 서식입니다.

var n1 = 43
fmt.Printf("%%v(기본): %v\n", n1)
fmt.Printf("%%T(데이터타입): %T\n", n1)
fmt.Printf("%%d(10진수 정수): %d\n", n1)
fmt.Printf("%%b(2진수 정수): %b\n", n1)
fmt.Printf("%%o(8진수 정수): %o\n", n1)
fmt.Printf("%%O(8진수 정수, prefix로 0o 붙임): %O\n", n1)
fmt.Printf("%%x(16진수 정수): %x\n", n1)
fmt.Printf("%%X(16진수 정수): %X\n", n1)
fmt.Printf("%%c(유니코드 문자): %b\n", n1)

fmt.Print()

fmt.Printf("%v = %c(유니코드), %v = %c(유니코드)\n", 65, 65, 97, 97)

%v(기본): 43
%T(데이터타입): int
%d(10진수 정수): 43
%b(2진수 정수): 101011
%o(8진수 정수): 53
%O(8진수 정수, prefix로 0o 붙임): 0o53
%x(16진수 정수): 2b
%X(16진수 정수): 2B
%c(유니코드 문자): 101011

65 = A(유니코드), 97 = a(유니코드)

적용할 수 없는 타입의 경우, %!d(float64=1.2) 같은 형태로 출력됩니다.

var n2 = 1.2
fmt.Printf("%d, %o, %c, %s, %t\n", n2, n2, n2, n2, n2)
fmt.Printf("%x, %b\n", n2, n2)

%!d(float64=1.2), %!o(float64=1.2), %!c(float64=1.2), %!s(float64=1.2), %!t(float64=1.2)
0x1.3333333333333p+00, 5404319552844595p-52

2.2. 실수 서식(format)

실수타입을 출력하는 서식문자로, %f(%F), %e(%E), %g(%G)가 있습니다.
이 서식문자들은 실수타입에만 적용가능합니다.

%f는 실수를 타입에 맞게 기본 출력하며, %e는 지수표기법으로 출력합니다.

%g는 값이 큰 실수값은 지수형태(%e)로, 값이 작은 실수값은 기본(%f) 출력합니다.

var n1 = 1234.56789

fmt.Printf("%%v(기본): %v\n", n1)
fmt.Printf("%%T(데이터타입): %T\n", n1)
fmt.Printf("%%f(실수): %f\n", n1)
fmt.Printf("%%e(지수표기법): %e\n", n1)
fmt.Printf("%%E(지수표기법): %E\n", n1)
fmt.Printf("%%f(실수 소수점 3자리까지): %.3f\n", n1)

%v(기본): 1234.56789
%T(데이터타입): float64
%f(실수): 1234.567890
%e(지수표기법): 1.234568e+03
%E(지수표기법): 1.234568E+03
%f(실수 소수점 3자리까지): 1234.568

실수의 경우, 서식을 설정하지 않을 경우 최소 소수점 자리수 로 표시됩니다.

var a float32 = 7.0  
fmt.Println(a)

2.3. bool 타입

var v1 = true
fmt.Printf("%%T(데이터타입): %T\n", v1)
fmt.Printf("%%t(boolean): %t\n", v1)

%T(데이터타입): bool
%t(boolean): true

2.4. string 타입

문자열을 출력하는 서식문자열은 2가지가 있습니다.
\t(탭), \n(개행)과같은 특수문자의 동작을 행하며 출력하는 %s와, 동작을 무시하고 그대로 출력하는 %q 가 있습니다.

var v2 = "hello\njiniworld\t!"
fmt.Printf("%%s(문자열): %s\n", v2)
fmt.Printf("%%q(문자열, 특수문자 기능 동작 무시): %q\n", v2)

%s(문자열): hello
jiniworld       !
%q(문자열, 특수문자 기능 동작 무시): "hello\njiniworld\t!"

2.5. 메모리 주소

var v3 = 123  
fmt.Printf("%%p(메모리 주소값) %p", &v3)

%p(메모리 주소값) 0x14000110020

[Kubernetes 시작하기] 11. 데몬셋

jiniya22 — Fri, 29 Dec 2023 16:30:48 +0900

데몬셋
1. 데몬셋
2. 데몬셋 스케쥴러
데몬셋 생성
1. 모든 노드에 데몬셋 생성하기
2. 특정 노드에만 데몬셋 생성
데몬셋 업데이트
데몬셋 삭제

파드 집합을 복제하는 이유는 크게 두가지 이유가 있습니다.

중복성을 위해
- 중복성: 여러개의 복제본 설정으로, 장애 발생되더라도 그에 대한 대비가 가능하게 하는 성질
- 관련 쿠버네티스 객체: 레플리카셋, 디플로이먼트
각 노드에 에이전트나 데몬을 실행하기 위해
- 클러스터 내의 모든 노드에 단일 파드를 스케쥴링하기 위해
- 관련 쿠버네티스 객체: 데몬셋

이번 포스팅에서는, 위에서 소개한 파드 집합 복제 이유의 2번째에 해당하는, 데몬 실행을 위한 데몬셋에 대해 알아볼 것입니다.

1. 데몬셋

1.1. 데몬셋

파드의 복사본이 쿠버네티스 클러스터 노드 집합에서 실행되게 합니다.
일반적으로 (클러스터 스토리지나 로그 수집기나 노드 모니터링 에이전트와 같이) 모든 노드에서 실행되어야하는 시스템 데몬을 배포하는데에 사용합니다.

데몬셋을 사용하면 클라우드 기반 클러스터 노드에 소프트웨어를 쉽게 설치할 수 있습니다.

클러스터 확장시, 특정 소프트웨어를 새로 추가한 노드에 설치하는 것도 데몬셋을 이용하여 설치하면 됩니다.

장시간 실행되는 서비스를 실행하는 파드를 생성하고, 클러스터의 원하는 상태와 현재(관찰된) 상태를 동일하게 만든다는 점에서 레플리카셋과 유사점이 있습니다.

사용목적에 따라 레플리카셋과 데몬셋 중 선택해야합니다.

레플리카셋
- 애플리케이션을 노드에서 완전히 분리할 때 사용
데몬셋
- 모든 노드(또는 특정 노드집합)에서 단일 파드 복사본이 실행되어야하는 경우에 사용
  - 데몬셋 설정에서 label을 설정하면, 특정 노드 집합에서만 데몬셋을 실행할 수 있습니다.

1.2. 데몬셋 스케쥴러

별도의 설정을 하지 않을 경우, 기본적으로 모든 노드에 파드의 복제본을 설치합니다.

데몬셋을 일부 노드에만 설치하고 싶다면 node selector을 설정하면 됩니다.
node selector는 설정한 라벨 목록으로 노드를 필터링하여 파드를 복제해줍니다.

조정 루프에 의해 관리되며, 측정된 정보를 바탕으로 데몬셋 컨트롤러는 일치하는 파드가 없는 각노드에 파드를 생성합니다.
이에 의해, 클러스터에 새로운 노드가 추가되었을 경우에도 데몬셋 컨트롤러가 해당 노드에 파드를 추가해줍니다.

조정 루프: 조정 루프는 지속적으로 파드의 상태를 관찰하고, 현재(관찰된) 상태가 원하는 상태와 일치할 수 있도록 동작합니다.

레플리카셋이 자신이 관리하는 파드를 소유하고 있었다면,(파드가 레플리카셋의 하위 리소스)
데몬셋의 경우, 데몬셋에 의해 관리되는 각 파드들이 데몬셋을 소유하고 있습니다. (파드가 데몬셋의 상위 리소스)

2. 데몬셋 생성

2.1. 모든 노드에 데몬셋 생성하기

별도의 필터링 없이, 모든 노드에 데몬셋 파드를 생성해봅니다.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  labels:
    app: fluentd
spec:
  selector:
    matchLabels:
      app: fluentd
  template:
    metadata:
      labels:
        app: fluentd
    spec:
      containers:
      - name: fluentd
        image: fluent/fluentd:v0.14.10
        resources:
          limits:
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 200Mi
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers

정의해둔 데몬셋 구성파일을 이용하여 데몬셋을 생성해봅니다.

kubectl apply -f fluentd.yml

daemonset.apps/fluentd created

데몬셋 목록 조회

kubectl get ds

NAME      DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
fluentd   3         3         3       3            3           <none>          64s

파드 목록 조회

데몬셋은 특정 조건에 맞는 노드에 설치되는 파드이기 때문에 파드 목록 조회를 이용하여 조회할 수 있습니다.
파드 전체 목록을 조회해보면 데몬셋이 조회되는 것을 확인할 수 있습니다.

kubectl get pods -o wide

NAME            READY   STATUS    RESTARTS   AGE   IP           NODE           NOMINATED NODE   READINESS GATES
fluentd-dn4sc   1/1     Running   0          98s   10.244.5.2   kind-worker    <none>           <none>
fluentd-wwf8k   1/1     Running   0          98s   10.244.3.2   kind-worker3   <none>           <none>
fluentd-xh69t   1/1     Running   0          98s   10.244.4.2   kind-worker2   <none>           <none>
kuard-fk5dg     1/1     Running   0          5s    10.244.3.3   kind-worker3   <none>           <none>
kuard-w7qxr     1/1     Running   0          5s    10.244.5.3   kind-worker    <none>           <none>

라벨을 이용하여 app이 fluentd인 파드만 조회하면 아래와 같이 fluentd 파드만 조회할 수 있습니다.

kubectl get pods -o wide -l app=fluentd

NAME            READY   STATUS    RESTARTS   AGE     IP           NODE           NOMINATED NODE   READINESS GATES
fluentd-dn4sc   1/1     Running   0          2m12s   10.244.5.2   kind-worker    <none>           <none>
fluentd-wwf8k   1/1     Running   0          2m12s   10.244.3.2   kind-worker3   <none>           <none>
fluentd-xh69t   1/1     Running   0          2m12s   10.244.4.2   kind-worker2   <none>           <none>

fluentd 데몬셋에 대한 현재상태 조회

kubectl describe daemonset fluentd

Name:           fluentd
Selector:       app=fluentd
Node-Selector:  <none>
Labels:         app=fluentd
Annotations:    deprecated.daemonset.template.generation: 1
Desired Number of Nodes Scheduled: 3
Current Number of Nodes Scheduled: 3
Number of Nodes Scheduled with Up-to-date Pods: 3
Number of Nodes Scheduled with Available Pods: 3
Number of Nodes Misscheduled: 0
Pods Status:  3 Running / 0 Waiting / 0 Succeeded / 0 Failed
Pod Template:
  Labels:  app=fluentd
  Containers:
   fluentd:
    Image:      fluent/fluentd:v0.14.10
    Port:       <none>
    Host Port:  <none>
    Limits:
      memory:  200Mi
    Requests:
      cpu:        100m
      memory:     200Mi
    Environment:  <none>
    Mounts:
      /var/lib/docker/containers from varlibdockercontainers (ro)
      /var/log from varlog (rw)
  Volumes:
   varlog:
    Type:          HostPath (bare host directory volume)
    Path:          /var/log
    HostPathType:
   varlibdockercontainers:
    Type:          HostPath (bare host directory volume)
    Path:          /var/lib/docker/containers
    HostPathType:
Events:
  Type    Reason            Age    From                  Message
  ----    ------            ----   ----                  -------
  Normal  SuccessfulCreate  2m28s  daemonset-controller  Created pod: fluentd-wwf8k
  Normal  SuccessfulCreate  2m28s  daemonset-controller  Created pod: fluentd-xh69t
  Normal  SuccessfulCreate  2m28s  daemonset-controller  Created pod: fluentd-dn4sc

데몬셋 삭제

kubectl delete -f fluentd.yml

daemonset.apps "fluentd" deleted

2.2. 특정 노드에만 데몬셋 생성

특정 노드에만 데몬셋을 실행하고 싶다면, 라벨을 활용하면 됩니다.
데몬셋을 실행하고자하는 노드에 라벨을 설정한 후, 특정 라벨이 있는 노드에게만 데몬셋이 생성되도록 제한할 수 있습니다.

기존에 생성했던 kind 클러스터 노드에는 아래와 같이 2개의 worker노드에 tier: backend 라벨이 설정되어있었습니다.

-l, --selector: 특정 라벨 필터링을 위한 옵션

kubectl get nodes -l tier=backend
NAME           STATUS   ROLES    AGE     VERSION
kind-worker    Ready    <none>   5m45s   v1.27.3
kind-worker2   Ready    <none>   5m45s   v1.27.3

이전에 생성했던 데몬셋을 삭제한 후, 필터링에 활용할 label을 nodeSelector에 설정해봅니다.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  labels:
    app: fluentd
    tier: backend
spec:
  selector:
    matchLabels:
      app: fluentd
      tier: backend
  template:
    metadata:
      labels:
        app: fluentd
        tier: backend
    spec:
      nodeSelector:
        tier: backend
      containers:
      - name: fluentd
        image: fluent/fluentd:v0.14.10
        resources:
          limits:
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 200Mi
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers

fluentd-2.yml

그리고, 위의 데몬셋 구성파일을 이용하여 데몬셋을 생성해봅니다.

kubectl apply -f fluentd.yml

그러면, 2개의 worker노드에만 fluentd 파드가 설치된 것을 확인할 수 있습니다.

kubectl get pods -o wide -l app=fluentd
NAME            READY   STATUS    RESTARTS   AGE   IP           NODE           NOMINATED NODE   READINESS GATES
fluentd-5nzhm   1/1     Running   0          20s   10.244.3.6   kind-worker    <none>           <none>
fluentd-sfgdz   1/1     Running   0          20s   10.244.4.5   kind-worker2   <none>           <none>

3. 데몬셋 업데이트

데몬셋은 전체 클러스터에 서비스를 배포하고자할 때 유용합니다.

쿠버네티스 1.6 버전 이전에는, 데몬셋을 업데이트하고자 할때, 데몬셋이 관리하는 각 파드들을 수동으로 삭제한 후, 수정한 데몬셋 구성파일을 이용하여 새로 파드를 생성하는 것이 유일한 방법이었습니다.

쿠버네티스 1.6 이후 버전부터는, 클러스터 내에서 레플리카셋 롤아웃 관리를 하는 디플로이먼트 객체와 동일한 기능이 생겼습니다.

롤링 업데이트 전략을 사용하면 데몬셋에 대한 롤아웃을 수행할 수 있습니다

데몬셋의 롤아웃 정책은 spec 하위에 정의합니다.

minReadySeconds
- 롤링업데이트가 다음 파드의 업그레이드 전에 파드를 준비상태로 두는 시간
updateStrategy.rollingUpdate.maxUnavailable
- 동시에 롤링업데이트할 수 있는 최대 파드 수
- 속도는 느리겠지만, 안전한 서비스 배포를 위해서는 1로 설정하는 것이 좋습니다.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  labels:
    app: fluentd
    tier: backend
spec:
  selector:
    matchLabels:
      app: fluentd
      tier: backend
  minReadySeconds: 10
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  template:
    metadata:
      labels:
        app: fluentd
        tier: backend
    spec:
      nodeSelector:
        tier: backend
      containers:
      - name: fluent
        image: fluent/fluentd:v0.14.10
        resources:
          limits:
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 200Mi
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers

fluentd-3.yml

이전에 생성했던 데몬셋은 롤아웃 정책이 적용되어있지 않기 때문에 제거후 진행해야합니다.
새로, 데몬셋을 실행 한후,

kubectl apply -f fluentd-3.yml
daemonset.apps/fluentd created

현재 설치되어있는 fluentd 버전을 확인해봅니다.

kubectl get pods -o jsonpath="{.items[*].spec.containers[*].image}" -l app=fluentd

fluent/fluentd:v0.14.10 fluent/fluentd:v0.14.10%

fluentd 이미지를 fluent/fluentd:v0.14.10 -> fluent/fluentd:v0.14.14로 업데이트한 후, 새로 적용해봅니다.

kubectl apply -f fluentd-3.yml

daemonset.apps/fluentd configured

그리고, 데몬셋의 롤아웃 상태를 확인해봅니다.

Waiting for daemon set "fluentd" rollout to finish: 0 out of 2 new pods have been updated...
Waiting for daemon set "fluentd" rollout to finish: 0 out of 2 new pods have been updated...
Waiting for daemon set "fluentd" rollout to finish: 1 out of 2 new pods have been updated...
Waiting for daemon set "fluentd" rollout to finish: 1 out of 2 new pods have been updated...
Waiting for daemon set "fluentd" rollout to finish: 1 out of 2 new pods have been updated...
Waiting for daemon set "fluentd" rollout to finish: 1 out of 2 new pods have been updated...
Waiting for daemon set "fluentd" rollout to finish: 1 of 2 updated pods are available...
Waiting for daemon set "fluentd" rollout to finish: 1 of 2 updated pods are available...
daemon set "fluentd" successfully rolled out

다시 이미지 버전을 조회해보면 아래와 같이 버전이 업데이트 된 것을 확인할 수 있습니다.

kubectl get pods -o jsonpath="{.items[*].spec.containers[*].image}" -l app=fluentd

fluent/fluentd:v0.14.14 fluent/fluentd:v0.14.14%

4. 데몬셋 삭제

기본적으로, 데몬셋과 그 데몬셋이 관리하고 있던 파드를 함께 삭제하지만,
--cascade=false 설정을 하면, 파드는 그대로 남기고 데몬셋만 삭제됩니다.

4.1. 데몬셋 구성파일을 이용한 삭제

kubectl delete -f fluentd.yml

daemonset.apps "fluentd" deleted

4.2. 데몬셋 이름을 이용한 삭제

kubectl delete ds fluentd

daemonset.apps "fluentd" deleted

[Kubernetes 시작하기] 05. 파드

jiniya22 — Fri, 29 Dec 2023 16:25:10 +0900

파드
1. 파드?
2. 파드 매니페스트
파드
1. 명령어를 이용한 파드 생성/삭제
2. 파드 매니페스트 적용을 통한 파드 실행
파드에 접근
1. 파드 로그 출력
2. 컨테이너에서 명령 실행하기
Probe

1. 파드

1.1. 파드?

컨테이너화 된 애플리케이션을 배포하고자 할때,
여러 애플리케이션을 한 머신 위에 단일 원자 단위(atimic unit)로 배포하고자 할 것입니다

쿠버네티스에서는, 이 단일 원자 단위를 Pod(파드)라고 부릅니다.

어떤 애플리케이션을 서비스하기 위해 웹서버 와 Git 동기화 서버 가 필요하고, 그 두 서버는 _공통 파일 리소스_를 이용하고 있다고 할때

웹서버와 Git동기화 서버는 각각 별도의 컨테이너에 담는다
위의 두 컨테이너는 Volume(공통 파일 리소스 서버)에 접근할 수 있다
두 서버는 하나의 기능을 위한 서버이자, 공유 파일시스템을 이용하며, 서로 공생관계이다.

이런 두 컨테이너를 Pod라는 하나의 단위로 그룹화 합니다.

파드는 동일한 실행환경에서 동작하는 애플리케이션 컨테이너와 볼륨의 집합 이고, 쿠버네티스 클러스터에서 배포할 수 있는 가장 작은 아티팩트 입니다.

동일한 파드 내에 실행되는 애플리케이션은

같은 머신에 존재합니다.
동일한 ip, port, network namespace를 공유하고, 동일한 호스트명(uts 네임스페이스)을 갖습니다.
시스템 V IPC나 POSIX 메시지 큐 위의 프로세스 간 통신 채널을 통해 통신할 수 있습니다.

서로 다른 파드에 있는 애플리케이션은 서로 격리되어있고, 서로 다른 ip주소와 호스트 주소를 갖습니다.

어떤 애플리케이션을 하나에 다 두었을때와 각자 별도로 분리했을 때를 생각했을때
각기 다른 머신에 두어도 잘 동작이 되는 애플리케이션이라면 각기 다른 파드에 구성하는 것이 옳습니다.

또 필요에따라 서버의 scale out을 시행할 텐데,
파드로 묶어둘 경우 파드 내에 들어있는 모든 애플리케이션의 확장이 일어난다는 점도 염두해야 합니다.

1.2. 파드 매니페스트

파드는 파드 매니페스트(Pod manifest)에 기술됩니다.

파드 매니페스트는 쿠버네티스 API객체를 yaml 텍스트 파일 형태로 표현한 것으로, 파드 매니페스트 파일에 작성된 내용은 선언형 컨피규레이션 성질에 의해 쿠버네티스 서버에 적용됩니다.

아래 코드는 파드 매니페스트 예시입니다.

apiVersion: v1
kind: Pod
metadata:
  name: kuard
spec:
  containers:
    - image: gcr.io/kuar-demo/kuard-arm64:blue
      name: kuard
      ports:
        - containerPort: 8080
          name: http
          protocol: TCP

2. 파드 생성

2.1. 명령어를 이용한 파드 생성/삭제

파드 생성

kubectl run kuard --image=gcr.io/kuar-demo/kuard-arm64:blue

pod/kuard created

pod 상태 및 목록 조회

kubectl get pods

NAME    READY   STATUS    RESTARTS   AGE
kuard   1/1     Running   0          65s

파드를 생성한 후 바로 위의 명령어를 실행하면, Pending으로 조회되다가 Running으로 바뀝니다.
위의 명령어는 파드 목록 뿐만아니라, 준비된 컨테이너 수, 파드의 상태, 파드의 수명, 파드가 재시작된 수를 확인할 수 있습니다.

파드 삭제

파드 삭제 명령어 실행 후, 30s의 종료 유예시간 후 삭제됩니다.
유예 시간동안은 Terminating 상태로 출력되며, 이 상태에서는 더이 상 새로운 요청을 받지 않지만, 현재 처리중인 요청이 끝낼수 있도록 하기 때문에 신뢰성 측면에서 강점이 있습니다.

kubectl delete pod/kuard

파드가 삭제할 때에는 파드 내에 들어있는 컨테이너 및 데이터가 함께 삭제됩니다.
만약, 파드 삭제시 제거되면 안되는 데이터가 있다면, 그 데이터들은 Persistent Volume 에 설정해둬야 합니다.

2.2. 파드 매니페스트 적용을 통한 파드 실행

kuard-pod.yml 파일에 파드에 관한 설정을 정의해두고, apply를 통해 파드를 생성할 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: kuard
spec:
  containers:
    - image: gcr.io/kuar-demo/kuard-arm64:blue
      name: kuard
      ports:
        - containerPort: 8080
          name: http
          protocol: TCP

파드 실행

kubectl apply -f kuard-pod.yml

pod/kuard created

kubectl get pods 명령어를 실행하면 kuard 파드가 조회됩니다.

위와같이 파일을 통해 파드에 대한 정의를 하게된다면 장기적인 관점에서 편리하게 관리할 수 있습니다.

파드 세부사항 조회

파드에 대한 상세한 정보를 확인하고 싶다면 kubectl describe pods 파드명 을 사용하면 됩니다.

kubectl describe pods kuard

Name:             kuard
Namespace:        default
Priority:         0
Service Account:  default
Node:             minikube/192.168.49.2
Start Time:       Mon, 27 Nov 2023 00:02:09 +0900
Labels:           <none>
Annotations:      <none>
Status:           Running
IP:               10.244.0.6
IPs:
  IP:  10.244.0.6

파드 내에서 실행중인 컨테이너에 대한 정보

Containers:
  kuard:
    Container ID:   docker://364fd550f63c6e92805e41533ac72777c9af0a8b27ce630176f0bb9d41658120
    Image:          gcr.io/kuar-demo/kuard-arm64:blue
    Image ID:       docker-pullable://gcr.io/kuar-demo/kuard-arm64@sha256:4f500bd9af3813076b7672450fd060a51a5c98d6fea1772d48ae0447da66a26a
    Port:           8080/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Mon, 27 Nov 2023 00:02:09 +0900
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-sghjc (ro)
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True
Volumes:
  kube-api-access-sghjc:
    Type:                    Projected (a volume that contains injected data from multiple sources)
    TokenExpirationSeconds:  3607
    ConfigMapName:           kube-root-ca.crt
    ConfigMapOptional:       <nil>
    DownwardAPI:             true
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s

스케줄링된 시간과 이미지를 가져온 시간, 상태검사 실패로인한 재시작 여부, 시간 등에 대한 이벤트 정보

Events:
  Type    Reason     Age    From               Message
  ----    ------     ----   ----               -------
  Normal  Scheduled  4m48s  default-scheduler  Successfully assigned default/kuard to minikube
  Normal  Pulled     4m48s  kubelet            Container image "gcr.io/kuar-demo/kuard-arm64:blue" already present on machine
  Normal  Created    4m48s  kubelet            Created container kuard
  Normal  Started    4m48s  kubelet            Started container kuard

3. 파드에 접근

파드 내부에서 실행되고 있는 코드 및 데이터와 상호작용하는 방법을 알아봅니다.

3.1. 파드 로그 출력

kubectl logs 파드명 명령어를 이용하면, 실행중인 파드로부터 현재 로그를 다운받을 수 있습니다.

-f
- 연속 로그 스트림으로 실시간 로그를 확인
--previous
- 컨테이너의 이전 인스턴스로 부터 로그를 가져옵니다
- 컨테이너가 문제가 있어 계속해서 컨테이너 재시작하고 있는 경우에 활용하면 좋습니다

kubectl logs kuard

2023/11/26 15:02:09 Starting kuard version: v0.10.0-blue
2023/11/26 15:02:09 **********************************************************************
2023/11/26 15:02:09 * WARNING: This server may expose sensitive
2023/11/26 15:02:09 * and secret information. Be careful.
2023/11/26 15:02:09 **********************************************************************
2023/11/26 15:02:09 Config:
{
  "address": ":8080",
  "debug": false,
  "debug-sitedata-dir": "./sitedata",
  "keygen": {
    "enable": false,
    "exit-code": 0,
    "exit-on-complete": false,
    "memq-queue": "",
    "memq-server": "",
    "num-to-gen": 0,
    "time-to-run": 0
  },
  "liveness": {
    "fail-next": 0
  },
  "readiness": {
    "fail-next": 0
  },
  "tls-address": ":8443",
  "tls-dir": "/tls"
}
2023/11/26 15:02:09 Could not find certificates to serve TLS
2023/11/26 15:02:09 Serving on HTTP on :8080

3.2. 컨테이너에서 명령 실행하기

kubectl exec 명령어를 사용하여, 컨테이너 내부에서 명령을 실행할 수 있습니다.

kubectl exec kuard -- date

Sun Nov 26 15:27:00 UTC 2023

여기에 -it 옵션을 추가하면, 대화형으로 명령을 계속해서 실행할 수 있습니다.

kubectl exec -it kuard -- sh

~ $ls

bin    dev    etc    home   kuard  lib    media  mnt    opt    proc   root   run    sbin   srv    sys    tmp    usr    var

4. Probe(프로브)

쿠버네티스에서는 프로세스 health check를 통해 컨테이너가 살아있는지 체크하며, 문제가 있을시 쿠버네티스가 애플리케이션을 재시작 해줍니다.

하지만, 애플리케이션의 health check는 문제가 없지만, 프로세스 deadlock에 걸린 상태라 요청을 처리할 수 없는 상태라면 어떻게 해야할까

쿠버네티스에서는 이러한 문제를 해결하고자 liveness(활성) 상태 검사를 도입했습니다.
단순히 애플리케이션이 동작되고 있는 것 뿐만 아니라, 정상 기능 수행 여부를 검사하는 기능입니다.

이는, 애플리케이션마다 정의가 달라질 수 있는 부분이기 때문에 파드 매니페스트에 정의합니다.

쿠버네티스에서는 다양한 프로브 옵션을 제공하며, 별도로 지정하지 않을 경우 기본값으로 설정됩니다.
관련 링크: Configure Probes

제공하고 있는 고급 프로브 옵션에는 아래와 설정들이 있습니다.

파드 구동 후 프로브를 시작하고자 대기하는 시간

실패로 간주할 총 실패 수

실패수를 재설정하는데에 필요한 성공 횟수

4.1. 활성 프로브 (liveness probe)

컨테이너 단위로 정의되며, 파드의 각 컨테이너별로 상태검사를 수행합니다.

kubectl apply -f kuard-pod-health.yml

pod/kuard created

포트포워딩 설정을 통해 호스트와 파드 내의 이미를 연결할 수 있습니다.

kubectl port-forward kuard 8080:8080
Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080
Handling connection for 8080

포트포워딩 설정을 마쳤으면, kuard 웹 페이지에 접근이 가능합니다.
Liveness Probe 탭에 들어가면, 프로브 실행 결과를 확인할 수 있는데

Fail 링크를 클릭하여 임의로 상태 검사 실패를 시켜봅니다.
그러면, 아래와 같이 500 status가 노출되다가 재시작을 행하게 됩니다.

활성 상태 검사 실패에 대한 default 반응은 파드를 재시작하는 것입니다.
이 값은 restartPolicy(파드 재시작 정책) 설정으로 변경할 수 있습니다.

restartPolicy
- Always
  - 기본값
  - 활성 검사 실패시 재시작
- OnFailure
  - 활성 검사 실패 또는 0이 아닌 프로세스 정지 코드시 재시작
- Never
  - 재시작하지 않는다

kubectl describe pods kuard 명령어를 이용하여 Event 섹션에서 재시작에 관련된 세부 정보를 확인할 수 있습니다.

Events:
  Type     Reason     Age                 From               Message
  ----     ------     ----                ----               -------
  Normal   Scheduled  5m1s                default-scheduler  Successfully assigned default/kuard to minikube
  Normal   Pulled     31s (x2 over 5m1s)  kubelet            Container image "gcr.io/kuar-demo/kuard-arm64:blue" already present on machine
  Normal   Created    31s (x2 over 5m1s)  kubelet            Created container kuard
  Normal   Started    31s (x2 over 5m1s)  kubelet            Started container kuard
  Warning  Unhealthy  31s (x3 over 51s)   kubelet            Liveness probe failed: HTTP probe failed with statuscode: 500
  Normal   Killing    31s                 kubelet            Container kuard failed liveness probe, will be restarted

4.2. 준비 프로브 (readiness probe)

준비 프로브는 상태 검사를 하는 프로프 중 하나 입니다.

liveness probe는 애플리케이션의 정상 동작 여부를 검사하고, 활성검사 실패시 컨테이너를 재시작한다면,

readiness probe는 컨테이너가 사용자 요청 처리에 대한 준비 유무를 검사합니다.
준비 상태 검사 실패시, 컨테이너는 서비스 로드밸런서에서 제거됩니다

준비프로브와 활성 프로브를 함께 사용하면 클러스터 내에서 정상 상태의 컨테이너만 실행되게 할 수 있습니다.

4.3. 시작 프로브 (startup probe)

느리게 구동되는 컨테이너(slow-starting container)를 관리하기 위한 대안으로 도입되었습니다.
느리게 구동되는 컨테이너에 대해 느리게 폴링하고, 그 컨테이너가 초기화된 후 응답 활성 검사를 가능하게 합니다.

파드 구동시, 파드의 다른 프로브가 구동되기 전에 시작 프로브가 실행됩니다.

시작프로브는 시간이 초과되거나 성공할때까지 진행됩니다.

시간이 초과되면 파드를 다시 시작하고
성공하면 활성 프로브로 인계됩니다.

4.3. 상태 검사의 기타 타입

상태검사는 HTTP 검사 외에도

apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: liveness-http
spec:
  containers:
  - name: liveness
    image: registry.k8s.io/liveness
    args:
    - /server
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
        httpHeaders:
        - name: Custom-Header
          value: Awesome
      initialDelaySeconds: 3
      periodSeconds: 3

TCP 소켓을 이용한 상태 검사도 지원하고

apiVersion: v1
kind: Pod
metadata:
  name: goproxy
  labels:
    app: goproxy
spec:
  containers:
  - name: goproxy
    image: registry.k8s.io/goproxy:0.1
    ports:
    - containerPort: 8080
    readinessProbe:
      tcpSocket:
        port: 8080
      initialDelaySeconds: 15
      periodSeconds: 10
    livenessProbe:
      tcpSocket:
        port: 8080
      initialDelaySeconds: 15
      periodSeconds: 10

exec 프로브도 지원합니다.
exec 프로브는 컨테이너 내부에서 스크립트나 프로그램을 실행합니다.
스크립트가 종료코드 0을 반환할 경우 해당 프로브를 성공으로, 그 외의 경우 실패로 간주합니다.
HTTP 호출에 적합하지 않은 사용자 정의 애플리케이션의 검증 로직에 이용하면 좋습니다.

apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: liveness-exec
spec:
  containers:
  - name: liveness
    image: registry.k8s.io/busybox
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy; sleep 30; rm -f /tmp/healthy; sleep 600
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5

그밖에 gRPC 프로브도 지원하니, 필요하다면 Define a gRPC liveness probe를 참고하시면 됩니다.

5. 리소스 관리

TODO ++

애플리케이션이 필요로하는 리소스의 양을 정의

쿠버네티스에서 사용자가 설정할 수 있는 리소스에 관련된 2가지 매트릭

resource 요청(requests)
- 애플리케이션 실행을 위해 필요한 최소 resource 양 설정
resource 제한(limits)
- 애플리케이션이 사용할 수 있는 최대 resource 양 설정

6. 볼륨을 통한 데이터 보존

쿠버네티스에서 제공하는 persistent storage 로, 파드가 삭제되거나 컨테이너가 재시작되어도 데이터가 삭제되지 않습니다.

spec.volumes 섹션에 컨테이너 목록에서 접근해야할 볼륨 목록을 추가하고,
볼륨을 이용할 컨테이너들은 volumeMounts 설정을 추가해줍니다.

apiVersion: v1
kind: Pod
metadata:
  name: kuard
spec:
  volumes:
    - name: kuard-data
      hostPath:
        path: /var/lib/kuard
  containers:
    - image: gcr.io/kuar-demo/kuard-arm64:blue
      name: kuard
      volumeMounts:
        - mountPath: /data
          name: kuard-data
      ports:
        - containerPort: 8080
          name: http
          protocol: TCP

노드

파드는 언제나 노드 위에서 동작합니다.
노드는 쿠버네티스에서 워커머신을 의미하고, 클러스터에 따라 가상머신일 수도 있고 물리머신일 수도 있습니다.

각 노드는 컨트롤 플레인에 의해 관리됩니다.
컨트롤 플레인은 클러스터 내의 노드를 통해 파드에 대한 스케쥴링을 자동으로 처리합니다.

[Go] 01. Go 시작하기

jiniya22 — Thu, 28 Dec 2023 18:32:14 +0900

Go
1. Go?
2. go 설치
3. build
Hello world!! 출력 실습

1. Go

1.1. Go?

Go는 2009년에 발표된 오픈소스 프로그래밍 언어입니다.

Go는 쉽고 예외 상황이 적은 문법을 가지고 있는 언어로, 빠른 성능과 일관되고 쉬운 문법이 특징입니다.

시스템 프로그래밍, 백엔드 프로그래밍으로 많이 사용됩니다.

아래와 같은 주요 특징을 가지고 있습니다.

클래스 대신 (메서드를 가지고 있는) 구조체를 지원
상속 지원 x
인터페이스는 있다
함수 리터럴(익명함수) 제공
고성능 가비지 컬렉터 제공
메모리 주소를 가리키는 포인터가 있다
제네릭 지원 x
네임스페이스 제공 x. 모든 코드는 패키지 단위로 분리됩니다
정적 컴파일 언어
강타입 언어

Go는 가비지 컬렉터를 제공하지만, 가비지 컬렉터가 있는 언어중 상위 성능을 가지고 있다.

가비지 컬렉터는 메모리에서 불필요한 영역을 치워줍니다.

가비지 컬렉터가 없는 언어

프로그래머가 직접 메모리 할당과 해제를 책임져야 합니다.

할당한 메모리를 해제하지 않아서 메모리 누수 현상이 발생되거나

이미 해제한 영역을 다시 해제하여 버그가 발생할 수 있습니다.

비교적 더 빠른 성능

가비지 컬렉터가 있는 언어

메모리 해제를 자동으로 해주기 때문에 메모리 관련 문제가 줄어든다

메모리 청소에 CPU 성능을 사용한다는 단점이 있다

정적 컴파일 언어로, 컴파일 과정을 거쳐 실행 파일을 미리 만들어야 하지만 대시 실행 속도가 빠르다.

강타입 언어로, 타입에 의한 문제가 발생되지 않는다.

정적 컴파일 언어?
컴파일한 결과물인 실행파일을 사전에 만들어두고 사용하는 방식의 언어

1.2. go 설치

Go 공식페이지 에 들어가서 OS에 맞는 파일을 다운로드 받고

터미널에서 go version명령어 실행시, 버전정보가 출력되면 go 설치가 완료된 것입니다.

go version

go version go1.21.5 darwin/arm64

1.3. build

Go언어의 모든 코드는 패키지 단위로 작성합니다. (1.16 이후 버전)

내가 위치되어있는 가장 가까이 있는 디렉토리를 패키지로 간주합니다.

예를들어

goplayground/content/notice 구조에서,

content 하위에있는 go 파일의 모듈명은 goplayground/content 이고,
notice 하위에있는 go 파일의 모듈명은 goplayground/content/notice 입니다.

모든 Go코드는 빌드하기 전에 모듈을 생성해야 합니다.
아래와 같은 형식으로, 모듈을 생성한 후, build하면 되는데

go mod init goplayground/content

모듈 생성 명령어를 실행하고나면, 모듈내에 go.mod라는 파일이 생성됩니다.
파일 내에는 모듈명과 Go버전, 필요한 패키지 목록 정보가 담겨져 있습니다.

go build 명령어를 실행하면, 현재 시스템에 맞는 실행파일을 생성해줍니다.
만약, 특정 시스템의 실행파일을 만들고 싶다면, 아래와 같이 GOOS, GOARCH 옵션을 직접 지정하여 build하면 됩니다.

GOOS=linux GOARCH=amd64 go build

빌드에 설정할 수 있는 GOOS, GOARCH 목록은 아래 명령어를 통해 확인할 수 있습니다.

go tool dist list

aix/ppc64
android/386
android/amd64
android/arm
android/arm64
darwin/amd64
darwin/arm64
dragonfly/amd64
freebsd/386
freebsd/amd64
freebsd/arm
freebsd/arm64
freebsd/riscv64
illumos/amd64
ios/amd64
ios/arm64
js/wasm
linux/386
linux/amd64
linux/arm
linux/arm64
linux/loong64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/riscv64
linux/s390x
netbsd/386
netbsd/amd64
netbsd/arm
netbsd/arm64
openbsd/386
openbsd/amd64
openbsd/arm
openbsd/arm64
plan9/386
plan9/amd64
plan9/arm
solaris/amd64
wasip1/wasm
windows/386
windows/amd64
windows/arm
windows/arm64

2. Hello jiniworld!! 출력 실습

2.1. Hello jiniworld!! 실습

먼저, 프로젝트를 생성합니다.
프로젝트 이름은 goplayground로 생성하였습니다.

프로젝트 안에 hello 디렉토리를 만들고, 그 안에 hello.go 파일을 생성하여, 아래의 코드를 작성합니다.

package main

import "fmt"

func main() {
	fmt.Println("Hello jiniworld!!")
}

Go 1.16 버전부터 Go 모듈을 사용하는 것이 기본형태로 되었습니다.

Go 1.16 이전 버전에서는 Go모듈을 사용하지 않는 코드는 $GOPATH/src 아래에 위치시키면 되었지만, 이제는 무조건 모든 코드들을 Go모듈 아래에 위치시켜야합니다.

hello.go 코드의 경우, hello 모듈 아래에 위치되어있습니다.

hello 모듈로 이동하고나서, 모듈을 초기세팉 해줍니다.

cd hello

go mod init goplayground/hello

go: creating new go.mod: module goplayground/hello
go: to add module requirements and sums:
        go mod tidy

모듈 초기화를 마쳤다면, 빌드를 할 수 있습니다.
Go 모듈을 초기화 하면 실행파일이 생성됩니다.

go build

실행파일을 실행해보면, Hello jiniworld!!가 출력됩니다.

./hello

Hello jiniworld!!

go run 명령어를 이용하면 빌드하지 않고 파일을 바로 실행할 수 있습니다.

go run hello.go

Hello jiniworld!!

2.2. 코드 설명

package main

import "fmt"

func main() {
	fmt.Println("Hello jiniworld!!")
}

Go언어의 모든 코드는 패키지 선언으로 시작합니다.

이 코드가 main패키지에 속해있는 코드임을 Go컴파일러에게 알려줍니다. (ln 1)
main 패키지는 프로그램의 시작점을 포함하는 특별한 패키지로, main 패키지를 선언했을 경우 반드시 main함수를 작성해야합니다.

다른 패키지에서 제공하고 있는 기능을 사용하고 싶을 때에는 import를 사용하면 됩니다.
fmt는 표준 입출력을 내장하고 있는 내장 패키지입니다.(ln 3)

main함수는 프로그램의 진입점 함수입니다. Go로 만든 프로그램은 main함수에서 시작되고, main함수가 종료되면 프로그램이 종료됩니다.(ln 5-7)

Println은 fmt 패키지에서 포함하고 있는 표준 출력 함수 일종으로, 문자열을 터미널에 출력합니다.(ln 6)

[Docker] 01. 도커 시작하기

jiniya22 — Tue, 5 Dec 2023 01:20:50 +0900

Docker
docker CLI

1. Docker

1.1. 도커 등장 배경

전통적인 방법에서는, 어떤 웹 애플리케이션 서비스를 구축하고자 할 때, 서버에 웹서버, DB서버, Redis 등을 직접 설치하고, 구성파일 설정을 한 후 각 애플리케이션간에 연동을 해야 했습니다.

이러한 방식으로 철치하는 것은 구조를 세팅하는데에 인력자원도 많이 들 뿐만 아니라
서로 다른 시스템에서 테스트를 하고자 할 때에도 어려움이 많았습니다.

또, 개발환경을 설정하면서 패키지 버전이나 OS의 차이에 따른 부분으로 인해 개인 PC에서 개발환경을 세팅하는 것만으로도 많은 시간이 소요되었습니다.

도커를 이용하여 서비스 환경을 구축하면, 다양한 환경에서도 손쉽게 서비스를 다운받고, 배포나 실행을 편리하게 할 수 있도록 도와줍니다.

1.2. Docker?

도커는 컨테이너 기반의 오픈소스 가상화 플랫폼으로 (컨테이너를 사용하여) 응용프로그램의 배포나 실행을 보다 간편하게 할 수 있도록 설계된 도구 입니다.

다양한 프로그램과 실행환경을 컨테이너로 추상화 합니다.
추상화된 컨테이너를 활용하여 프로그램의 배포나 관리를 하나의 방식으로 처히라여 단순합니다.

여러가지 클라우드 환경에서 실행가능하게 해줍니다.

컨테이터는 코드를 포함한 모든 종속성을 패키지화하여 응용 프로그램이 여러 컴퓨터 환경에서 빠르고 안정적으로 실행될 수 있도록 하는 소프트웨어 표준 단위입니다.

컨테이너(도커) 이미지는 애플리케이션을 실행하는데에 필요한 모든 요소(코드, 런타임, 시스템 도구, 시스템 라이브러리 및 설정)들을 포함하는 가볍고 독립적인 실행 가능한 소프트웨어 패키지를 의미합니다.

컨테이너화된 소프트웨어는 소프트웨어를 환경으로부터 격리시켜주며, 개발환경의 차이와 상관없이 균일하게 작동되도록 보장합니다. 이에 의해 OS와 상관없이 항상 동일하게 실행됩니다.

도커 이미지는 프로그램을 실행하는데에 필요한 모든 설정과 종속성들이 들어있습니다.
도커 이미지를 인스턴스화한 것이 도커 컨테이너입니다.

도커 컨테이너를 실행하는 것이 바로 프로그램을 실행하는 것입니다.

1.3. Docker 설치

Docker 웹페이지에 들어가 docker를 다운받고, Docker ID를 생성합니다.

도커 설치를 완료했다면, docker CLI를 이용하여 도커 명령어를 실행할 수 있습니다.

관련 명령어는 docker --help 를 실행하면 도커 명령어에 대해 상세한 설명을 확인해볼 수 있습니다.

docker [OPTIONS] COMMAND

```txt Common Commands: run Create and run a new container from an image exec Execute a command in a running container ps List containers build Build an image from a Dockerfile pull Download an image from a registry push Upload an image to a registry images List images login Log in to a registry logout Log out from a registry search Search Docker Hub for images version Show the Docker version information info Display system-wide information ``` ```sh Management Commands: builder Manage builds buildx* Docker Buildx (Docker Inc., v0.11.2) compose* Docker Compose (Docker Inc., v2.22.0) container Manage containers context Manage contexts image Manage images manifest Manage Docker image manifests and manifest lists network Manage networks plugin Manage plugins system Manage Docker trust Manage trust on Docker images volume Manage volumes ``` ```txt Commands: attach Attach local standard input, output, and error streams to a running container commit Create a new image from a container´s changes cp Copy files/folders between a container and the local filesystem create Create a new container diff Inspect changes to files or directories on a container's filesystem events Get real time events from the server export Export a container's filesystem as a tar archive history Show the history of an image import Import the contents from a tarball to create a filesystem image inspect Return low-level information on Docker objects kill Kill one or more running containers load Load an image from a tar archive or STDIN logs Fetch the logs of a container pause Pause all processes within one or more containers port List port mappings or a specific mapping for the container rename Rename a container restart Restart one or more containers rm Remove one or more containers rmi Remove one or more images save Save one or more images to a tar archive (streamed to STDOUT by default) start Start one or more stopped containers stats Display a live stream of container(s) resource usage statistics stop Stop one or more running containers tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE top Display the running processes of a container unpause Unpause all processes within one or more containers update Update configuration of one or more containers wait Block until one or more containers stop, then print their exit codes ``` ```sh Global Options: --config string Location of client config files (default "/Users/sherry/.docker") -c, --context string Name of the context to use to connect to the daemon (overrides DOCKER_HOST env var and default context set with "docker context use") -D, --debug Enable debug mode -H, --host list Daemon socket to connect to -l, --log-level string Set the logging level ("debug", "info", "warn", "error", "fatal") (default "info") --tls Use TLS; implied by --tlsverify --tlscacert string Trust certs signed only by this CA (default "/Users/sherry/.docker/ca.pem") --tlscert string Path to TLS certificate file (default "/Users/sherry/.docker/cert.pem") --tlskey string Path to TLS key file (default "/Users/sherry/.docker/key.pem") --tlsverify Use TLS and verify the remote -v, --version Print version information and quit ```

2. docker CLI

2.1. docker version

docker version 명령어로 도커 버전을 조회해봅니다.

docker version

Client:
 Cloud integration: v1.0.35
 Version:           24.0.2
 API version:       1.43
 Go version:        go1.20.4
 Git commit:        cb74dfc
 Built:             Thu May 25 21:51:16 2023
 OS/Arch:           darwin/arm64
 Context:           desktop-linux

Server: Docker Desktop 4.21.1 (114176)
 Engine:
  Version:          24.0.2
  API version:      1.43 (minimum version 1.12)
  Go version:       go1.20.4
  Git commit:       659604f
  Built:            Thu May 25 21:50:59 2023
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.6.21
  GitCommit:        3dce8eb055cbb6872793272b4f20ed16117344f8
 runc:
  Version:          1.1.7
  GitCommit:        v1.1.7-0-g860f061
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

2.2. docker run

docker 명령어는 docker CLI로, 클라이언트 명령어입니다.

docker run --help 명령어를 실행하면, docker run 명령어를 실행하는 것에 대한 상세한 정보를 확인할 수 있습니다.

거기에는, run에 대한 간략한 설명으로, Create and run a new container from an image 라고 쓰여있습니다.
docker run 은 도커 이미지를 이용하여 새로운 컨테이너를 생성 또는 실행하는 명령어입니다.

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

명령어를 실행했을 때, 만일 로컬(현재서버의 이미지 캐시 보관 장소)에 그 이미지가 없을 경우 Docker Hub로부터 이미지를 다운받은 후 그 이미지를 이용하여 도커 컨테이너를 실행합니다.

기본적으로, 도커 이미지 안에 정의된 시작 커맨드를 실행하며
COMMAND를 설정할 경우, 시작 커맨드 대신 다른 명령어를 실행할 수 있습니다.

※ COMMAND는 도커 이미지 안에 정의되어있는 명령어만 실행 가능합니다.

Docker 이미지 실행 예제 1

Hello from Docker!라는 메시지를 출력하는 예제용 도커 이미지를 이용하여 컨테이너를 실행해봅시다.

docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
70f5ac315c5a: Pull complete
Digest: sha256:c79d06dfdfd3d3eb04cafd0dc2bacab0992ebc243e083cabe208bac4dd7759e0
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

만일 로컬에 해당 이미지가 있을 경우, line 2-5의 이미지를 다운받는 로그는 출력되지 않습니다.

Docker 이미지 실행 예제 2

alpine은 경량 리눅스 이미지입니다.

-i, --interactive
- 표준입출력을 활성화시킵니다.
-t, --tty
- pseudo-TTY(유사 터미널) 할당
- 유사 터미널을 이용하여 컨테이너에 접속할 수 있게 합니다.

아래는 alpine 이미지로 생성한 컨테이너를 ls 커맨드를 이용해서 실행한 결과입니다.

-it 옵션과 sh 명령어를 이용하여 alpine 컨테이너 내에 접근합니다.

/bin 하위를 ls 명령어로 조회하여 어떤 COMMAND 가 들어있는지 확인할 수 있습니다.

sh, ls 등의 명령어가 여기에 포함되어있기 때문에, COMMAND에 sh나 ls 명령어가 사용 가능한 것입니다.

docker run -it alpine sh

/ # ls /bin
arch           chattr         dd             ed             fsync          ionice         linux32        lzop           mount          pidof          pwd            sed            stty           umount
ash            chgrp          df             egrep          getopt         iostat         linux64        makemime       mountpoint     ping           reformime      setpriv        su             uname
base64         chmod          dmesg          false          grep           ipcalc         ln             mkdir          mpstat         ping6          rev            setserial      sync           usleep
bbconfig       chown          dnsdomainname  fatattr        gunzip         kbd_mode       login          mknod          mv             pipe_progress  rm             sh             tar            watch
busybox        cp             dumpkmap       fdflush        gzip           kill           ls             mktemp         netstat        printenv       rmdir          sleep          touch          zcat
cat            date           echo           fgrep          hostname       link           lsattr         more           nice           ps             run-parts      stat           true

Docker 이미지 실행 예제 3

COMMAND에 _ls_를 설정하여 명령어를 실행한 결과입니다.
alpine 이미지로 실행한 도커 컨테이너 내의 디렉토리의 파일 리스트를 출력한 결과입니다.

docker run alpine ls

bin
dev
etc
home
lib
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

2.3. docker ps

proccess status
도커 컨테이너 목록 조회

docker ps

Options:
  -a, --all             Show all containers (default shows just running)
  -f, --filter filter   Filter output based on conditions provided
      --format string   Format output using a custom template:
                        'table':            Print output in table format with column headers (default)
                        'table TEMPLATE':   Print output in table format using the given Go template
                        'json':             Print in JSON format
                        'TEMPLATE':         Print output using the given Go template.
                        Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates
  -n, --last int        Show n last created containers (includes all states) (default -1)
  -l, --latest          Show the latest created container (includes all states)
      --no-trunc        Don't truncate output
  -q, --quiet           Only display container IDs
  -s, --size            Display total file sizes

기본적으로 현재 실행중인 컨테이너 목록만 조회되며, -a (= --all) 옵션을 추가하면 모든 컨테이너 목록을 조회할 수 있습니다.

현재 실행중인 컨테이너를 조회하기 위해,
알파인 이미지를 올린 컨테이너에 ping명령어를 실행시켜둔 후

docker run alpine ping localhost

PING localhost (127.0.0.1): 56 data bytes
64 bytes from 127.0.0.1: seq=0 ttl=64 time=0.022 ms
64 bytes from 127.0.0.1: seq=1 ttl=64 time=0.107 ms
64 bytes from 127.0.0.1: seq=2 ttl=64 time=0.130 ms
64 bytes from 127.0.0.1: seq=3 ttl=64 time=0.127 ms
64 bytes from 127.0.0.1: seq=4 ttl=64 time=0.125 ms
...

터미널을 하나 더 켜서 docker ps를 실행하면 아래와 같이 실행중인 컨테이너 프로세스가 출력됩니다.

docker ps

CONTAINER ID   IMAGE     COMMAND            CREATED         STATUS         PORTS     NAMES
0806dde711bb   alpine    "ping localhost"   6 seconds ago   Up 6 seconds             charming_hertz

CONTAINER ID
- 컨테이너의 고유한 아이디(해시값의 일부)
IMAGE
- 컨테이너 생성시 사용한 도커 이미지
COMMAND
- 컨테이너 시작시 실행한 커맨드
CREATED
- 컨테이너 실행시간
STATUS
- 컨테이너 상태
  - 실행중(Up), 종료(Exited), 일시정지(Pause)
PORTS
- 컨테이너가 개방한 포트와 호스트에 연결한 포트
NAMES
- 컨테이너 고유 이름
- 컨테이너 생성시 --name 옵션을 설정하지 않을 경우 도커 엔진이 임의로 생성합니다.(형용사_명사로 지어짐)
- 이름은 중복할 수 없고, docker rename 명령어로 이름을 변경할 수 있습니다.
  - docker rename 기존컨테이너명 변경할컨테이너명

컨테이너 목록 중, 원하는 항목만 조회하기

--format 옵션을 사용하면 원하는 항목만 설정한 포맷대로 조회할 수 있습니다.

docker ps --format 'table(포맷)'

포맷은 {{.테이블명}}형태로 작성합니다.
테이블명은 맨 앞글자만 대문자로 표시합니다.

image명, 커맨드, 컨테이너만 조회하는 명령은 아래와 같습니다.

docker ps --format 'table{{.ID}}\t{{.Image}}\t{{.Command}}\t{{.Names}}'

CONTAINER ID   IMAGE                                COMMAND                  NAMES
5094b62ff780   alpine                               "ping localhost"         mystifying_dijkstra

관련된 상세한 format 설정을 알고 싶다면 Docker docs - FOrmat command and log output을 참고하시면 됩니다.

모든 컨테이너 조회하기

-a 옵션을 사용하면, 종료한 컨테이너를 포함하여 모두 출력합니다.

docker ps -a

CONTAINER ID   IMAGE         COMMAND            CREATED          STATUS                      PORTS     NAMES
51386027ccda   alpine        "ping localhost"   3 minutes ago    Exited (0) 30 seconds ago             ecstatic_bartik
0806dde711bb   alpine        "ping localhost"   16 minutes ago   Exited (0) 15 minutes ago             charming_hertz
a02ec8137e2c   alpine        "ls"               31 minutes ago   Exited (0) 31 minutes ago             nervous_diffie
8df60db66036   hello-world   "ls"               32 minutes ago   Created                               brave_ptolemy
ac64dca944dd   hello-world   "/hello"           2 hours ago      Exited (0) 2 hours ago                nostalgic_thompson

[Kubernetes 시작하기] 02. 컨테이너 생성과 실행

jiniya22 — Mon, 20 Nov 2023 02:01:53 +0900

컨테이너 이미지
Docker를 활용한 애플리케이션 이미지 빌드
다단계 이미지 빌드
원격 레지스트리에 이미지 저장
컨테이너 런타임 인터페이스
1. docker로 컨테이너 실행하기
2. 리소스 사용량 제한
정리

k8s는 분산 애플리케이션을 생성/배포/관리하기 위한 플랫폼입니다.

k8s 기반으로 시스템을 구축하기 위해서는 우리들이 실행하고자하는 프로그램이 포함되어있는 애플리케이션 컨테이너 이미지를 빌드하는 것과 분산 시스템을 구성하는 방법을 알아야합니다

애플리케이션 프로그램은 (애플리케이션을 구성하고 있는) 프로그래밍 언어의 런타임, 라이브러리, 소스코드로 구성되어 있습니다.

대부분의 애플리케이션은 외부 라이브러리에 의존성을 가지고 있는 경우가 많습니다.
외부 라이브러리는 일반적으로 특정 머신에 설치한 OS의 공유 컴포넌트 형태로 제공됩니다.

공유 라이브러리에 의존적일 경우 다른 OS로 애플리케이션을 이관했을 때, 애플리케이션 내부에 포함된 공유라이브러리가 OS에 맞지않아 동작되지 않는 등의 문제가 발생할 수 잇습니다.

k8s가 등장하기 이전의 전통적인 운영방식에서는 모든 프로그램이 시스템상에서 동일한 버전의 공유 라이브러리를 공유하는 것으로 이 문제를 해결하였습니다.
다만, 이 경우에는 공유 라이브러리에 대한 의존도에 의해 불필요한 결합도가 높아지고, 복잡성이 증가된다는 단점이 있습니다.

애플리케이션을 개발할 때, 다른 사람과 개발환경을 쉽게 공유할 수 있도록 구성하는 것은 매우 중요합니다.
Docker를 이용하면 실행파일을 패키징 하여, 다른 팀원들이 손쉽게 다운로드하고 이를 registry(= 컨테이너 이미지 저장소)에 푸시할 수 있습니다.

컨테이너 레지스트리는 대부분의 public cloud에서 사용가능하고, 클라우드 환경에서 이미지를 빌드하는 서비스도 사용 가능합니다.

레지스트리를 이용하여 애플리케이션을 private 이미지에 올리고, 이를 이용하여 관리 및 배포를 하며, 이미지 builder 서비스를 이용하여 CI/CD를 편리하게 행합니다.

1. 컨테이너 이미지

컨테이너 이미지는 OS 컨테이너 내부에서 프로그램을 실행하는데에 필요한 모든 파일들을 캡슐화한 바이너리 패키지로, 파일 시스템 계층으로 구성되어있습니다.

컨테이너 이미지를 실행하여 OS 컨테이너 내부에서 실행되는 애플리케이션을 생성할 수 있습니다.

Docker는 가장 유명하고 널리 사용되고 있는 컨테이너 이미지 포맷으로, 사실상 거의 표준처럼 이용되고 있습니다.
우리는 docker 명령어를 이용하여 컨테이너를 패키징/배포/실행 할 수 있습니다.

도커 이미지는 단일 파일이 아닌 다른 파일을 가리키는 Manifest 파일의 명세입니다.
간접적으로 참조하고 있는 특성을 통해 효율적으로 저장하고 전송하는 것이 가능합니다.

컨테이너 이미지는 컨테이너 환경 설정 및 애플리케이션 구성파일 등을 포함합니다.

컨테이너는 크게 2가지 범주로 구분합니다.

시스템 컨테이너
애플리케이션 컨테이너

시스템 컨테이너는 가상머신처럼 동작하고, 전체 부팅 프로세스를 실행합니다.
ssh, cron과 같이 VM에서 일반적으로 자주 쓰이는 커멘드들을 포함하고 있습니다.
초창기에는 시스템 컨테이너 유형이 일반적으로 쓰였으나, 최근에는 애플리케이션 컨테이너가 실용성이 높아 더 각광받고 있습니다.

애플리케이션 컨테이너는 일반적으로 단일 프로그램을 실행합니다.
하나의 컨테이너가 하나의 프로그램을 실행한다는 것은 확장성면에서 큰 장점입니다.

이런 특성으로 인하여, 일반적으로 k8s같은 컨테이너 오케스트레이션은 애플리케이션 컨테이너로 구성된 분산 시스템을 구축/배포합니다.

2. Docker를 활용한 애플리케이션 이미지 빌드

2.1. Dockerfile

Dockerfile을 이용하여 애플리케이션을 도커 이미지로 패키징 할 수 있고, 이를 이용하여
도커 컨테이너 이미지 생성을 자동화할 수 있습니다.

리액트 기본 애플리케이션을 이용하여 도커 이미지를 패키징하는 예제 코드를 실습해봅시다.

※ 리액트 애플리케이션을 다운받기 위해서는 선행적으로 node가 설치되어있어야 합니다.

2.1.1. 애플리케이션 생성 및 Dockerfile 생성

먼저 디렉토리를 생성 한 후,

mkdir docker-react-app
cd docker-react-app

npx를 이용하여 create-react-app을 현재 디렉토리에 설치합니다.

npx create-react-app .

이미지 복사시, 제외시킬 파일들을 .dockerignore 에 작성합니다.

node_modules

도커 컨테이너 이미지를 패키징하는 명세에 해당하는 Dockerfile을 생성합니다.

FROM node:alpine

WORKDIR /usr/src/app

COPY package.json .

RUN npm install

COPY . .

CMD [ "npm", "run", "start" ]

도커 이미지 생성

docker build -t jiniworld/docker-react-app .

[+] Building 105.9s (10/10) FINISHED                                                                                                         docker:desktop-linux
 => [internal] load build definition from Dockerfile                                                                                                         0.0s
 => => transferring dockerfile: 158B                                                                                                                         0.0s
 => [internal] load .dockerignore                                                                                                                            0.0s
 => => transferring context: 2B                                                                                                                              0.0s
 => [internal] load metadata for docker.io/library/node:alpine                                                                                               2.9s
 => [1/5] FROM docker.io/library/node:alpine@sha256:4a512d1538b1a8281b58cab0b366a5c62436566bb63e7dcd4a6769c98edb3b5f                                         5.3s
 => => resolve docker.io/library/node:alpine@sha256:4a512d1538b1a8281b58cab0b366a5c62436566bb63e7dcd4a6769c98edb3b5f                                         0.0s
 => => sha256:7ab0a8aeffef38c226acdcd921d3877f2a0887e66254c96704e8faa54729ffd6 2.37MB / 2.37MB                                                               0.9s
 => => sha256:2d5d499b0ef9279f09adbe89093cb1188a646d5bcae72c23c82b7cba981be8fa 448B / 448B                                                                   0.3s
 => => sha256:4a512d1538b1a8281b58cab0b366a5c62436566bb63e7dcd4a6769c98edb3b5f 1.43kB / 1.43kB                                                               0.0s
 => => sha256:fe8982961121d058349f1d6f22115582a665a54fa2b8e585551070723bf66aa7 1.16kB / 1.16kB                                                               0.0s
 => => sha256:ece0d10eb54d6fd5d3ef2f329f3f264fa500bd8e7b725e8b327bea18d02adaa8 7.15kB / 7.15kB                                                               0.0s
 => => sha256:915db32f2887698a56b738a38cbdbc8ffcdd6bf738a1e5e762de36950b514347 43.51MB / 43.51MB                                                             4.2s
 => => extracting sha256:915db32f2887698a56b738a38cbdbc8ffcdd6bf738a1e5e762de36950b514347                                                                    1.0s
 => => extracting sha256:7ab0a8aeffef38c226acdcd921d3877f2a0887e66254c96704e8faa54729ffd6                                                                    0.0s
 => => extracting sha256:2d5d499b0ef9279f09adbe89093cb1188a646d5bcae72c23c82b7cba981be8fa                                                                    0.0s
 => [internal] load build context                                                                                                                            0.1s
 => => transferring context: 1.55MB                                                                                                                          0.0s
 => [2/5] WORKDIR /usr/src/app                                                                                                                               0.1s
 => [3/5] COPY package.json .                                                                                                                                0.0s
 => [4/5] RUN npm install                                                                                                                                   95.1s
 => [5/5] COPY . .                                                                                                                                           0.0s
 => exporting to image                                                                                                                                       2.2s
 => => exporting layers                                                                                                                                      2.2s
 => => writing image sha256:31901e7478d86557e45b0563553b302ad2fa9604bd581705dacc628430da0b5b                                                                 0.0s
 => => naming to docker.io/jiniworld/docker-react-app                                                                                                        0.0s

What's Next?
  View a summary of image vulnerabilities and recommendations → docker scout quickview

도커 이미지 실행

docker run -d --name docker-react-app -p 8080:8080 jiniworld/docker-react-app

2.2. 이미지 크기 최적화

도커 컨테이너 이미지는 계층화된 파일 시스템으로 구성되어있습니다.
때문에, 도커파일을 구성할 때 이미지 크기를 최적화하기 위해 알맞게 계층 구조 설정을 해야합니다.

아래와 같이 2가지 구성이 있다고 할 때
두 구성 중, 2번째 구성이 이미지 크기를 최적화한 구성이라고 할 수 있습니다.

구성 1

A계층: 기본 OS 컨테이너
- B계층: 소스코드 server.js 추가
  - C계층: node 패키지 설치

구성 2

A계층: 기본 OS 컨테이너
- B계층: node 패키지 설치
  - C계층: 소스코드 server.js 추가

1번째 구성의 경우, node계층이 server.js에 종속되어있기 떄문에
server.js 파일이 변경되는 경우 그 하위 계층의 다운로드 및 업로드가 일어나게 됩니다.

이미지 크기를 최적화하기 위해서는 변경 가능성이 적은것을 위에 배치하고, 변경이 빈번한 것을 아래에 구성하는 것이 중요합니다.

아래는 노드기반의 도커 컨테이너 이미지의 Dockerfile 예시입니다.
먼저, package*.json 을 먼저 복사한 후, npm install 로 앱 실행에 필요한 패키지를 설치한 후,
나머지 소스코드를 복사한 후, 실행합니다.

일반적으로 소스코드가 의존성 패키지보다 빈번하게 수정되기 때문에 이와 같은 순서로 배치하였습니다.

FROM node:16

WORKDIR /usr/src/app

COPY package*.json .

RUN npm install

COPY . .

CMD [ "npm", "start" ]

2.3. 이미지 보안

보안이 유지되어야하는 정보와 이미지가 혼재되어서는 안됩니다.

이미지에 설정되어있는 라이브러리가 많을 수록, 그 애플리케이션에 대한 취약점이 늘어날 수 있습니다.
따라서 컨테이너 이미지 내의 파일은 최소화하여 되도록 작은 크기의 이미지를 구성하는 것을 추천합니다.

3. 다단계 이미지 빌드

이미지 크기를 크게 만드는 대표적인 실수 중 하나는
애플리케이션 컨테이너 이미지 구성 중 프로그램의 컴파일을 포함시키는 것 입니다.

도커 파일 내에 컴파일을 포함시키는 것은 컨테이너 이미지 빌드를 매우 손쉽게 할 수 있게 합니다.

하지만, 컴파일 수행이 도커파일 내에 쓰여져 있으면 운영환경에는 필요하지 않은 개발도구들이 컨테이너 이미지 내에 포함되게 됩니다.
불필요한 파일들이 많아지면 용량이 커지게 되고, 이는 컨테이너 배포 속도에도 영향을 주게됩니다.

코드 컴파일을 이미지 내에 포함시키는 것이 아닌 다단계 빌드(multistage build) 방식으로 구성하는 것을 권장합니다.

다단계 빌드를 통해 도커 이미지를 단일 이미지가 아닌 여러 이미지로 생성합니다.
각 이미지는 stage로 간주하며, 아티팩트는 이전 단계에서 현재 단계로 복사할 수 있습니다.

예를 들어, build stage와 deploy stage로 구성된 이미지가 있다고 할 때,
build stage에서는 컴파일러와 프로그램을 실행하기 위해 필요한 툴, 그리고 소스코드만 포함되어있으며 build stage 결과물이 deploy stage로 넘어갑니다.
deploy stage에서는 그 파일들을 배포하는 이미지입니다

다단계 빌드 방식은 컴파일결과물이 이미지 내에 포함되어있지 않기 때문에 컨테이너 이미지 크기를 매우 작게 구성할 수 있고,
이에 의해 배포 시간을 단축할 수 있습니다.

4. 원격 레지스트리에 이미지 저장

컨테이너 이미지를 여러 서버에서 일일히 내려받고 업로드하는 것은 인적 자원도 많이 들 뿐만 아니라 예기치 못한 실수를 범할 수 있습니다.

이런 이유로 도커 이미지를 원격 registry를 저장하여 다운받는 형태로 많이 사용합니다.

registry는 GitHub과 같이 public과 private을 제공하는데,
외부에 공개하지 않고 특정 팀원들끼리만 공유하고자한다면 private registry를 사용하는 것이 좋고.
만일 공개되어도 무방하다면 public registry를 사용해도 됩니다.

registry는 일종의 저장소입니다.
이 곳에 이미지를 올리기 위해서는 먼저 docker login 명령어로 로그인을 선행해야합니다.

5. 컨테이너 런타임 인터페이스

docker run 커멘드로 컨테이너 이미지를 실행시킬 수 있습니다.

5.1. docker로 컨테이너 실행하기

5.1.1. kuard

gcr.io/kuar-demo/kuard-arm64:green 이미지를 사용하여 kuard 라는 이름의 컨테이너를 배포해봅니다.

docker run -d --name kuard -p 8080:8080 gcr.io/kuar-demo/kuard-arm64:green

-d, --detach
- 도커 이미지 컨테이너를 백그라운드(daemon)로 실행시키며 컨테이너 ID를 출력합니다.
--name 컨테이너명
- 컨테이너명을 지정합니다.
- 만일 이름을 지정하지 않을 경우 gracious_banzai와 같은 형태로 랜덤으로 생성됩니다
-p, --publish 호스트포트:컨테이너포트
- host와 컨테이너의 port를 forward 연결합니다.

5.1.2. 직접 생성한 도커 이미지 실행

아래는 직접 생성한 jiniworld/docker-react-app 이미지를 실행시킨 예제코드입니다.

docker run -d --name docker-react-app -p 8080:8080 jiniworld/docker-react-app

27e517ed82e390b0fbdaa899715e0a89b0d8f741595a3a4f0e2ea745c62900fa

docker ps 명령어를 사용하면 도커 컨테이너 목록을 조회할 수 있습니다.

docker ps

CONTAINER ID   IMAGE                        COMMAND                  CREATED         STATUS         PORTS                    NAMES
27e517ed82e3   jiniworld/docker-react-app   "docker-entrypoint.s…"   4 seconds ago   Up 3 seconds   0.0.0.0:8080->3000/tcp   docker-react-app

5.2. 리소스 사용량 제한

도커는 리눅스 커널이 기본적으로 제공하는 cgroup 기술을 이용하여 애플리케이션이 좀 더 적은 리소스를 사용하도록 설정할 수 있습니다.
k8s에서도 이것을 활용하여 각 파드에서 사용하는 리소스 양을 제한합니다.

docker run -d --name kuard -p 8080:8080 \
  -m 200m --memory-swap 1G \
  -c 1024 \
  gcr.io/kuar-demo/kuard-arm64:green

-m, --memory 바이트
- 메모리 제한을 설정
--memory-swap 바이트
- swap 메모리 제한을 설정
-c, --cpu-shares 정수
- CPU 작업시 자원을 프로세스에 얼마나 할당할지에 대한 리소스 제한
- 1024가 기본 할당 비율이며, 기본보다 CPU를 두배로 사용하고 싶다면 2048로 설정하면 됩니다. (0.5배로 설정하고 싶다면 512)

6. 정리

이미지 빌드를 마친 후, 필요없는 이미지는 docker rmi 이미지명(또는 이미지 ID) 제거합니다.
이미지를 제거하지 않으면 시스템 상에 영구적으로 존재하니 이부분을 유의해야 합니다.

기존에 빌드했던 이미지를 제거하지 않고 동일한 이름으로 이미지를 빌드할 경우 이전에 생성했던 이미지는 그대로 있는채로 새 이미지 빌드됩니다.

현재 머신에 존재하는 이미지 목록을 조회하고 싶으면 docker images 명령을 이용하면 됩니다.

docker images

REPOSITORY                     TAG       IMAGE ID       CREATED          SIZE
jiniworld/docker-react-app     latest    31901e7478d8   48 minutes ago   549MB
gcr.io/kuar-demo/kuard-arm64   green     ca8c55a31e7a   4 years ago      22.1MB

docker system prune 를 이용하면 빌드 프로세스에 의해 캐시된 미사용 이미지 계층과 중지된 상태의 컨테이너들을 한번에 제거할 수 있습니다.
이 명령어를 cron으로 설정해두면 일정 주기로 불필요한 이미지를 제거할 수 있습니다.

docker system prune

WARNING! This will remove:
  - all stopped containers
  - all networks not used by at least one container
  - all dangling images
  - all dangling build cache

Are you sure you want to continue? [y/N]

++

Kubernetes Up & Running Third Edition

[Kubernetes 시작하기] 01. 쿠버네티스 소개

jiniya22 — Sun, 19 Nov 2023 15:14:00 +0900

이 포스팅은 쿠버네티스 시작하기 3/e 책을 정리한 내용입니다.

Kubernetes? (= k8s)
개발 속도 향상
확장
인프라 추상화
클라우드 네이티브 에코시스템

1. Kubernetes? (= k8s)

쿠버네티스는 컨테이너화된 애플리케이션을 배포하기 위한 오픈소스 오케스트레이터입니다.

orchestrator
레지스트리 저장소로부터 컨테이너 이미지를 가져오거나 배치하고 실행중인 컨테이너를 관리할 수 있게하는 도구

k로 시작되서 s로 끝나는 쿠버네티스는 k와 s 사이의 8글자를 줄여서 k8s라고 줄여서 부르곤 합니다.

대부분의 Public cloud 에서 지원하고 있으며, Cloud native application 구축을 위한 표준 API로 자리하고 있습니다.

신뢰성과 확장성 갖춘 분산 시스템 인프라 요소입니다.

신뢰성은 시스템의 일부분이 고장나더라도 전체 시스템이 동작하지 않아서는 안되는 성질로,
rollout되는 동안에도 해당 시스템의 가용성을 그대로 보장하는 것을 예시로 들 수 있습니다.

rollout: 배포에 대한 변경사항. rollout을 이용하여 배포를 시작/일시정지/재개/롤백할 수 있습니다.

확장성은 상황에 따라 애플리케이션 용량이나 수를 늘리거나 줄이는 것을 의미합니다.

쿠버네티스와 컨테이너 API를 사용하는 것에는 아래와 같은 장점이 있습니다.

개발 속도 향상
확장성
인프라 추상화
효율성 증대
클라우드 네이티브 에코시스템

2. 개발 속도 향상

속도는 가용성을 갖는 서비스를 유지하면서 제공할 수 있는 서비스의 수로 측정합니다.
이 값이 높을 수록, 새로운 소프트웨어를 안정적으로 배포할 수 있고, 이는 개발 속도 향상에도 큰 영향을 줍니다.

쿠버네티스에서는 속도 개선을 위해 아래과 같은 특징을 지니고 있습니다.

불변성
선언형 configuration
온라인 자가 치유 시스템
재사용 가능한 공유 라이브러리 및 도구

2.1. 불변성

Immutable infrastructure

불변형 인프라.
서버가 한번 배포된 이후 절대 변경되지 않습니다. 따라서, 시스템에서 생성된 artifact(실행파일)는 사용자의 수정에 의해 변경될 수 없습니다.

예전의 방식에서는,
yum update 과 같은 패키지 관리 도구를 통해 기존 인프라 시스템을 업그레이드 했습니다.

더 쉽게 예시를 들자면, Apache와 같은 서버의 업데이트가 필요한 경우, 직접 인프라 구성팀이 Apache 웹서버를 업그레이드 시키기도 했고
httpd.conf 구성파일의 업그레이드가 필요했을 경우, 기존 파일을 덮어쓰는 형태였습니다.

이와 같은 구버전의 방식의 경우, 시스템을 업그레이드 하게되면, 시스템도 업그레이드 되고 구성파일도 변경되기 때문에
다시 예전의 버전으로 되돌리고 싶은 경우 많은 작업이 필요하였습니다.
물론, 기존 구성에 대해 백업을 두는 것도 방법이겠지만 이에 대한 공수도 많이 들어간다는 문제점이 있었습니다.

불변형 인프라는 이에 대한 해결 방안입니다.
사용하는 인프라 서비스(Apache WebServer, DB 등) 버전은 한번 설정하고 개발자에 의해 직접적으로 수정되지 않습니다.
그리고, 그 서비스를 이용하기 위한 구성파일(httpd.conf, my.cnf) 역시 직접적으로 수정되지 않습니다.

인프라 서비스의 버전과 구성파일에 대한 세팅을 쿠버네티스 설정파일에 정의되고
이미지를 빌드한 후, 실행중인 컨테이너를 직접적으로 수정하는 일이 없으며

만일, 서비스버전을 변경하고 싶거나, 설정파일 수정이 필요하다면 새로운 버전의 이미지를 구성하여 이미지 교체를 통해 변경이 이뤄집니다.

불변형 인프라는, 예전버전의 시스템 및 구성파일로 롤백하는 것이 매우 간편합니다.
단순하게, 예전에 사용했던 이미지로 교체하여 빌드하면 끝이기 때문입니다.

2.2. 선언형 configuration

상태를 선언하는 방법으로,
리소스 존재 유무를 따지는 것보다는 원하는 상태로 업데이트하는 것에 초점을 맞추고 있습니다.
원하는 목적에 달성하기 위한 구체적인 명령 제시가 아닌, 목적에 대한 선언만 있으며
시스템이 스스로 판단하여 목적을 달성합니다.
이는, 시스템 운영에 필요한 판단과 운영에 대해 사람의 개입을 최소화 시킵니다

직접적으로 명령어를 나열하는 것이 아니기 때문에
선언한 명세대로 수행되지 않았을시, 일정시간 동안의 대기 후 다시 재생성 등의 기능을 자동으로 구성하는 것도 손쉽게 가능합니다.

2.3. 자가 치유 시스템

또, 불변형 인프라 시스템에서, 사람이 직접 구성을 변경했을시
선언형 configuration 명세와 현재 구성설정이 다름을 감지하여 최초로 선언된 상태로 복구하는 것도 가능합니다.이는, 의도치않은 수정이 일어나도 자동으로 감지되어 작동되기 때문에 전체 시스템을 더 견고하게 만들어 신뢰성을 높입니다.

전통적인 방식에서는 이러한 변화에 대해 사람이 직접 장애를 분석하고 복구해야했다면, k8s에서는 선언형 configuration을 이용한 자가 치유가 가능합니다.

이는, 신뢰성 있는 시스템 구축에도 도움이 되며, 시스템 운영에 대한 유지보수 비용도 줄여주어 개발자의 개발 속도 향상에 큰 영향을 줍니다.

3. 확장

마이크로서비스로 애플리케이션 서비스를 구성하면, 필요에 따라 각 서비스를 확장하는 것도 용이해집니다.

이벤트로 인해 일시적으로 트래픽이 몰리는 API 서버를 증설하는 등의 행위를 예로 들 수 있습니다.

k8s에서는 이러한 서비스 확장을 선언형 컨피규레이션으로 간단히 정의할 수 있고
새로운 선언상태를 감지하면, 쿠버네티스에서 알아서 서비스를 확장합니다.

쿠버네티스는 아래와 같은 추상화 및 API를 제공하여 마이크로서비스 아키텍처 구축에 편의를 제공합니다.

파드, Pod
디스커버리, Discovery
네임스페이스, Namespace
인그레스, Ingress

4. 인프라 추상화

k8s는 특정 클라우드시스템에 국한된 서비스가 아닌, 다양한 클라우드 시스템에 손쉽게 이식할 수 있습니다.

특정 클라우드에서 제공하고 있는 클라우드 관리형 서비스가 아닌 오픈소스 스토리지 솔루션을 이용한다면 선언형 configuration을 이용하여 새로운 클라우드로 환경 구축을 손쉽게 할 수 있습니다.

이는 k8s가 API 지향 인프라 추상화 특징에 의한 특징입니다.

5. 클라우드 네이티브 에코시스템

k8s는 처음부터 확장 가능한 환경을 염두하여 설계되었습니다.
이러한 설계목표는 쿠버네티스 도구 및 서비스에 대한 활발한 커뮤니티가 형성되어, 쿠버네티스 기반의 에코시스템(비즈니스 생태계)로 이어졌습니다.

이러한 풍부한 클라우드 네이티브 에코시스템은 개발자를 비즈니스 로직 및 서비스 개발에만 집중할 수 있게 해줍니다.

++

Kubernetes Up & Running Third Edition

[MacOS M1] Apple Silicon Mac에 VM을 이용하여 Ubuntu 설치하기

jiniya22 — Sat, 18 Nov 2023 01:58:14 +0900

M1 MacOS에 가상머신을 이용하여 Linux 설치하기

UTM은 Apple Silicon Mac 환경에서 x86/x64 운영체제를 가상화할 수 있게 합니다.
이 Hypervisor를 이용하면 VM환경에서 Linux나 Windows를 설치하여 사용할 수 있습니다.

Ubuntu Server를 다운받은 후, UTM을 실행시킵니다.

본인 컴퓨터에 맞는 타입으로 iso파일을 다운받으면 됩니다.
저의 경우 MacOS M1 Appli silicon으로 arm 타입으로 다운받았습니다.

새 가상머신 만들기 버튼을 누르고

Virtualize(가상화) 를 누른 후 운영체제 Linux로 가상머신을 생성합니다.

탐색으로 통해 Boot ISO Image 를 불러오고

장치 설정은 각자 컴퓨터 사양에 맞춰 설정해주면 됩니다.
저의 경우 기본적으로 세팅되어있는 대로 진행하였습니다.

메모리는 4G, CPU Cores는 기본값, Storage는 64GB

서버를 구분지을 이름을 설정한 후, 저장을 누르면 기본 세팅은 끝납니다.

가상환경을 켜고, Try or Install Ubuntu Server 를 클릭해서 우분투 서버 설치를 시작합니다.

언어설정은 English로 선택하고

Ubuntu 설정, Network connections, Proxy Server, Mirror address, 스토리지 등 설정에 대해서 기본값으로 설정하고 넘어갑니다.

Ubuntu 서버명과 계정명(username)과 비밀번호를 설정해줍니다.

OpenSSH Server 도 함께 설치합니다.

X 표가 바로 체크 표시입니다.

필요한 Snap server 가 있다면 체크하여 함께 설치해도됩니다.

Installing system이 Install complete! 로 바뀔때까지 기다립니다.

아래와 같이 제목이 바뀌면, 맨 아래에 있는 Reboot Now 버튼이 아닌, 팝업창의 우상단에서 이미지를 꺼냅니다.

우측 상단에서 이미지를 꺼낸후, 왼쪽 상단의 restart (◁) 버튼을 눌러서 서버를 재시작합니다.

그러면 아래와 같이 Ubuntu 서버가 잘 설치된 것을 확인할 수 있습니다.

++

How to install Ubuntu Linux on Apple Silicon MacOS

[가상 면접 사례로 배우는 대규모 시스템 설계 기초] 11. 뉴스 피드 시스템 설계

jiniya22 — Sat, 26 Aug 2023 06:23:48 +0900

요구사항
개략적 설계
1. 피드 발행
2. 뉴스 피드 조회
상세 설계
마무리

뉴스피드 시스템은 인스타그램이나 트위터와 같이 홈페이지 중앙에서 지속적으로 업데이트되는 포스팅 시스템을 말합니다.

뉴스피드 시스템을 설계하는데에서 고민해야하는 부분은 아래와 같습니다.

내가 작성한 포스팅을 나를 팔로워한 사용자들에게 발행하는 것
팔로잉하고 있는 사용자의 피드를 나의 뉴스피드에서 읽는 것

간단하게 표현하자면, 데이터를 쓰는 파트 그리고 데이터를 읽는 파트에 대해 설계하면 됩니다.

1. 요구사항

뉴스피드 시스템을 설계하기 위해 필요한 요구사항들을 생각해봅니다.

모바일, 웹 모두 지원
뉴스 피드
- 내가 직접 포스팅을 올릴수도 있고
- 팔로잉하고 있는 사용자가 올린 포스팅을 뉴스피드에서 볼 수 있어야 한다.
스토리 정렬 방식?
- 생성일시 내림차순으로
한명의 사용자가 가질 수 있는 최대 친구수는?
트래픽 규모는?
피드에 올릴 수 있는 데이터
- 단순 문자열 뿐만 아니라 이미지나 미디어파일(비디오)도 올릴 수 있다.

2. 개략적 설계

요구사항을 파악했으니, 앞서 이야기 했던 2가지 기능에 대해 개략적으로 설계 해봅니다.

피드 발행 API
- 내가 포스트를 발행하면
  - 발행한 포스트 내용이 캐시와 데이터베이스에 기록되고
  - 친구들의 뉴스피드에도 전송된다.
- POST /v1/me/feed
- ```
POST {{server}}/v1/me/feed
Authorization: Bearer {{accessToken}}

{
  "message": "안녕하세요. 반가워요"
}
```
뉴스 피드 조회 API
- 내가 팔로잉한 사용자들의 포스팅을 시간 역순으로 모아서 뉴스피드를 조회합니다
- GET /v1/me/feed
- ```
GET {{server}}/v1/me/feed
Authorization: Bearer {{accessToken}}
```

2.1. 피드 발행

피드 발행 API를 이용하여 사용자는 모바일 앱이나 웹 브라우저에서 포스팅을 발행합니다.
웹서버는 로드밸런서를 통해 트래픽을 분산합니다.

포스팅은 DB와 캐시에 저장되고,
저장 후에는 fanout service(포스팅 전송 서비스)를 통해 새 포스팅을 친구의 뉴스피드에 push합니다.

그 후, 알림서비스로 푸시 알림을 보냅니다.

2.2. 뉴스 피드 조회

사용자(client)가 뉴스 피드 조회 API를 요청하면
마찬가지로 로드밸런서를 통해 웹서버를 분산처리하고, 웹서버에서는 뉴스피드 서비스를 호출합니다.
뉴스피드 서비스는 뉴스피드 캐시로부터 피드 정보를 읽어들입니다.
읽어들인 정보를 사용자에게 반환합니다.

3. 상세 설계

3.1. 피드 발행 상세 설계

위에서 설명했었던 피드 발행 부분에서 웹서버와 fanout service(포스팅 전송 서비스)를 더 상세하게 설계해봅니다.

3.1.1. 웹서버

클라이언트와 통신하는 웹서버에 인증과 처리율 제한 설정을 하여 보안을 높입니다.

피드 발행과 뉴스 피드 조회시 유효한 인증 토큰을 확인합니다.
- Authorization 헤더가 유효할 경우에만 API를 호출할 수 있도록 인증처리를 합니다.
특정기간동안 한 사용자가 올릴수 있는 포스팅의 수를 제한합니다.
- 스팸이나 유해 컨텐츠가 자주 올라오는것을 방지할 수 있습니다.

3.1.2. 팬아웃(포스팅 전송) 서비스

사용자 A가 새 포스팅을 올렸을 때, A의 팔로워들에게 포스팅을 전달하는 서비스로, 아래와 같이 2가지 방식으로 구성할 수 있습니다.

쓰기 시점에 포스팅 전송 (= push 모델)
읽기 시점에 포스팅 전송 (= pull 모델)

push 모델

포스팅을 올릴 때, 관계된 사용자들에게 바로 새 포스팅을 보냅니다.

뉴스피드가 실시간으로 갱신되기 때문에, 뉴스피드를 읽는데 드는 시간이 짧다는 장점이 있습니다.

다만, 유명인사의 경우, 팔로워들의 모든 뉴스피드를 갱신하는데에 많은 시간이 소요될 수 있다는 문제점이 있습니다.(= hotkey)
서비스를 잘 이용하지 않는 사용자의 경우, 실시간으로 피드 갱신을 하기위한 컴퓨팅 자원 낭비가 비효율적입니다.

pull 모델

로그인을 하지 않을 경우에는 컴퓨터 자원을 소모하지 않기 때문에
서비스에 거의 로그인하지 않는 사용자의 경우, 서비스를 이용할 때에만 피드를 가져오는 pull 모델이 더 효율적입니다.
데이터를 필요할 때 가져오기 때문에, 유명인사가 많은 팔로워들에게 포스트를 push하지 않아도 되기 때문에 hot key문제도 생기지 않습니다.

다만, 서비스를 시작하는 시점에 뉴스피드를 읽어오기 때문에 뉴스피드를 읽는데에 많은 시간이 소요될 수 있다는 단점이 있습니다.

push pull 결합 모델

push모델과 pull모델의 장점을 결합합니다.

뉴스피드를 빠르게 읽어들이기 위해 일반 사용자에 대해서는 push 모델을 사용하고
유명인사 같이 팔로워가 많은 사람의 경우, pull모델 방식으로 포스팅을 가져오도록 합니다

이렇게 설정할 경우, hotkey문제도 해결하고, 뉴스피드도 빠르게 읽어들일 수 있습니다.

(그래프) DB에서 친구 id 목록을 가져오고
친구 id 목록을 이용하여 캐시에서 친구 정보를 읽어들여셔, 피드 전송 대상 필터링
- mute설정한 친구 제외나, 친한친구에게만 보내기 등의 기능도 가능합니다.
MQ에 새 포스팅 id와 친구목록id를 넣습니다
포스팅 전송 서버가 MQ에서 데이터를 꺼내어 뉴스피드 캐시에 데이터를 넣습니다.

Graph DB
수백만/수십억개의 관계를 효과적으로 다루기 위한 데이터베이스
각 노드는 하나 이상의 레이블을 가질 수 있다는 점에서 RDB와 차이가 있고, 이러한 특성에 의해 빅데이터를 다루는 분야에서 효과적으로 활용할 수 있습니다.
Node는 RDB의 row, Label은 RDB의 table에 해당됩니다.

3.2. 뉴스피드 조회 상세 설계

사용자가 뉴스 피드 읽기 요청을 보내면
로드밸런서에 연결된 웹서버중 하나로 요청이 보내지고
웹서버에서는 뉴스피드 서비스를 호출합니다.
뉴스피드 서비스에서는 뉴스 피드 캐시로부터 사용자 id, 포스팅 id 목록을 가져오고
사용자 캐시와 포스트 캐시로부터 데이터를 각각 읽어와서 뉴스피드를 만듭니다.
뉴스피드는 json형태로 client에게 전송합니다.

이미지나 미디어 컨텐츠는 cdn에 저장하여 빨리 읽을 수 있도록 합니다.

3.3. 캐시 구조

캐시 구조를 아래와같이 제안합니다.

뉴스 피드
- post_id, user_id 쌍이 저장됨
컨텐츠
- 포스팅 데이터를 보관하는 캐시로, 인기 컨텐츠는 별도의 캐시에 보관합니다
소셜 그래프
- 사용자간의 관계를 보관합니다.
행위
- 포스팅에서 행해지는 사용자 행위(좋아요, 답글 등)에 대한 정보를 보관합니다
카운터
- 좋아요, 답글, 팔로워, 팔로잉 등의 count 정보를 보관합니다.

4. 마무리

뉴스피드 시스템 설계도 다른 시스템 설계와 마찬가지로 정답이라는 것은 없고
요구사항이나 제약조건 따라 시스템을 설계하며, 기술의 장단점을 잘 인지하며 타협을 보는 것이 중요한 부분입니다.

뉴스피드 시스템에서도 다른 시스템 설계와 마찬가지로 아래와 같은 부분들을 설계시 고려해볼 수 있습니다.

데이터베이스 규모 확장
많은 데이터를 캐시할 수 있는 방법
여러 데이터 센터를 지원하는 방법
컴포넌트 간의 결합도를 낮추기 위한 Message Queue 활용

[가상 면접 사례로 배우는 대규모 시스템 설계 기초] 01. 사용자 수에 따른 규모 확장성

jiniya22 — Fri, 19 May 2023 02:16:02 +0900

※ 이 포스팅은 가상 면접 사례로 배우는 대규모 시스템 설계 기초의 1장. 사용자 수에 따른 규모 확장성 부분을 정리한 것입니다.

개요
웹계층 Scale Out
데이터 계층 Scale Out
로드밸런서 && 데이터베이스 다중화
데이터베이스 규모 확장
1. 샤딩
2. 데이터베이스 종류에 대한 고민
응답시간 개선
데이터 센터

1. 개요

1.1. 단일서버?

모든 컴포넌트(웹앱, DB, 캐시서버 등)가 단 한대의 서버에서 실행되는 시스템입니다.

웹서비스를 이용하고자하는 사용자가 웹서버에 바로 접근하는 구조로 웹서버가 다운될 경우 웹사이트 접속이 불가능합니다.
또, 데이터베이스가 하나이기 때문에 장애가 발생했을 시, 장애 자동복구나 다중화를 지원하지 못합니다.

이러한 이유로 수백만 사용자를 지원하는 시스템을 설계하기 위해서는 여러대의 서버를 사용하는 것은 필수적입니다.

1.2. 서버 확장

서버를 확장하고자 할 때, 크게 2가지 계층에서 확장을 고려할 수 있습니다.

첫번째는 웹과 모바일의 트래픽을 처리하기 위한 웹계층 확장이 있고,
나머지 하나는 데이터 처리와 장애 복구를 위한 데이터 계층 확장이 있습니다.
이 두가지는 각각 독립적으로 확장할 수 있습니다.

1.3. Scale Up vs Scale Out

웹 계층과 데이터 계층을 확장하고자 할 때, 각 계층을 확장하는 방법에는 크게 2가지 방식이 있습니다.

흔히들 많이 들어봤을 Scale Up과 Scale Out이 이에 해당됩니다.

Scale Up
- 수직적 규모 확장 프로세스
- 고사양 자원(더 좋은 CPU, 더 많은 RAM)을 추가하여 성능을 개선합니다.
Scale Out
- 수평적 규모 확장 프로세스
- 더 많은 서버를 추가하여 성능을 개선합니다.

Scale Up은 서버의 스펙을 높이는 것을 말하는 것이고, Scale Out은 여러 서버를 묶어서 하나의 서비스를 처리하도록 하는 것입니다.

Scale Up 방식으로 규모를 확장하는 것은 비용도 비싼데다 확장하는데에 한계가 있습니다.
또, 서버에 장애가 발생했을시 모든 서비스가 다운되게 되는 SPOF 위험성이 있습니다.(Single Point Of Failure)

따라서, 서버 확장을 위해서는 Scale out 방식은 필수적입니다.

서버 장애 발생에 대한 대책 방안으로는 자동복구(failover), 다중화(redundancy) 가 있습니다.

그러면 이제, 웹서버를 Scale Out하는 방법과 데이터베이스를 Scale Out하는 방법을 알아봅시다.

2. 웹 계층 Scale Out

단일 서버에서는 웹 서비스를 위한 서버가 단 한대이며, 사용자가 직접적으로 서버에 접근합니다.
따라서, 그 서버에서 장애가 발생했을 때 웹사이트에 접속하지 못하는 문제점이 있습니다.

단순하게 웹서버가 다운되었거나
응답속도가 느려지는 경우 경우 (너무 많은 사용자가 접속하여 웹서버가 한계에 도달)

그렇기 때문에 수백만 사용자가 이용하는 시스템을 설계하는데에서 웹 계층에서의 부하 분산은 필수적입니다.

2.1. 로드밸런서

웹 계층을 Scale Out하기 위한 방법입니다.

로드밸런서는 웹서버들의 트래픽 부하를 분산하는 역할을 합니다.
웹 계층에서 발생되는 장애를 해결하기 위한 방법입니다.

사용자가 웹사이트에 접속하고자 할때, 웹서버로 직접 접속하지 않고 로드밸런서로 접속합니다.

로드밸런서에 여러 서버를 연결하여 웹/모바일 트래픽을 분산하여 처리하기 때문에, 서버 하나가 죽더라도 다른 서버들이 트래픽을 받아 사이트가 다운되는 일을 방지할 수 있습니다.(가용성 증가)

서버에 유입되는 트래픽이 일시적으로 높아지는 기간이 있다면 로드밸런서에 서버를 더 추가하여 장애를 줄일 수 있습니다.

또, 로드밸런서에 연결된 서버들을 같은 네트워크에 구성하여, private ip로 설정하면 외부에서 server로 직접 접속하지 못하게 설정할 수 있고
이를 통해 보안을 높일 수 있습니다.

3.2. stateless

웹 계층을 Scale Out 하기 위해서는, 하나의 요청이 어느 서버에서 실행되든 동일하게 동작되어야 합니다.

이전에 세션을 이용하여 사용자 정보를 서버에 저장하던 부분에서, 사용자 정보는 client가 가지고 있는 방식으로 변경이 되어야 하며
각 요청들은 무상태(stateless) 로 만들어야 합니다.

request에 session과 같은 상태정보가 있을 경우, 서버 하나에 의존적인 구조가 됩니다.
로드밸런서를 구성했을 때 세션정보를 활용하기 위해 고정세션 기능을 활용할수도 있으나, 이럴 경우 로드밸런서의 부담도 커지며, 서버 장애 발생시 다른 서버에서 요청을 처리할 수 없게 됩니다.

따라서, 웹 계층을 수평적으로 확장하기 위해서는 stateless 아키텍처로 구성하는 것은 필수적입니다.

웹서버를 stateless 아키텍처로 구성하면, 사용자가 로드밸런서에 설정된 서버 중 특정 서버와만 데이터를 송수신하지 않아도 됩니다.
http request는 로드밸런서 내의 어느 서버로든 전송되어도 되고, 만일 상태정보가 필요할 경우에는 웹서버가 아닌 shared storage(공유저장소) 로부터 가져옵니다.

즉, 상태정보는 웹서버로부터 물리적으로 분리된 상태입니다.

사용자 상태정보는 database, cache(memcached, redis) 등에 저장할 수 있습니다.

2.3. 메시지 큐

메시지 큐는 메시지의 무손실(durability)을 보장하는 비동기 통신 컴포넌트입니다.

생산자(Producer) 입력 서비스가 메시지를 만들어 메시지 큐에 발행합니다(publish)
메시지큐는 연결되어있는 소비자(Consumer) 서비스에게 메시지에 들어있는 동작을 수행합니다.

서비스(또는 서버) 간 결합이 느슨해져서(loosely coupled) 규모를 확장하는데에 도움이 됩니다.
생산자와 소비자는 각각 독립적이기 때문에 둘중 하나가 다운된 상태여도 각 기능에 영향을 주지 않습니다.
1. 소비자가 다운되어도 생산자의 메시지 발행은 정상적으로 이뤄집니다.
2. 생산자가 다운되어도 소비자는 메시지를 수신할 수 있습니다.

만약 어떤 작업이 완료되기 까지 오래 걸리지만, 다음 작업을 진행하는 데에 있어서 그 작업의 결과를 당장 받지 않아도 된다면, 메시지 큐를 사용해보는 것을 추천합니다.

관련 내용은 아래의 그림을 보면 이해하기가 쉬울 것입니다.

첫 번째 그림은 우리가 흔히 많이 이용하는 동기방식으로 API를 호출하는 A, B, C 서비스에서 API를 요청하고 응답받는 예시 입니다.
C에서 요청을 처리하던 중 에러가 발생될 경우, B와 A에도 에러가 전파된다는 단점이 있기 때문에 이 부분에 대해 고려하면서 개발을 진행해야 합니다.

두번 째 그림에서는 D, E, F 사이에 메시지 큐를 두고 있고,
D에서 E로 직접적으로 요청을 보내는 것이 아니라, 중간에 위치한 메시지 큐에 이벤트를 주는 방식으로 기능을 처리합니다.
D는 이벤트 큐에 어떤 행위를 적재하고, E는 이벤트 큐로부터 consume으로 이벤트를 받아서 처리합니다.

이렇게 처리할 경우, 만일 D가 문제가 발생하여 서버가 정상적으로 동작하지 않게 되더라도 E가 이벤트큐로부터 이벤트를 소비하는 것에 영향을 주지 않습니다.(반대의 경우도 마찬가지로 영향을 주지 않습니다.)

2.4. 로그, 메트릭, 자동화

웹 서버가 많아진 만큼, 장애가 발생된 서버를 모니터링 하는 기능이 필수적입니다.
또, 하나의 서비스를 여러 서버에 배포하는 CI/CD 부분도 반드시 고려해야할 사항입니다.

로그
- 에러 로그를 모니터링
- 시스템 오류를 쉽게 찾을 수 있습니다.
- 로그를 단일 서비스로 모아주는 도구를 활용하여 로그를 간편히 조회합니다
메트릭
- 호스트 단위 메트릭
  - CPU, Memory, 디스크 I/O
- 종합 메트릭
  - 데이터베이스 계층의 성능, 캐시 계층의 성틍
- 핵심 비즈니스 메트릭
  - daily active user, revenue(수익), retention(재방문)
자동화 도구
- 생산성을 높이기 위해 필수적으로 필요합니다.
- CI(Continuous Integration, 지속적 통합)
  - 개발자가 만든 코드를 자동으로 어떤 검증 절차를 거치게 하여 문제점을 빠르게 감지하게 합니다.
- 빌드, 테스트, 배포 절차를 자동화하여 개발 생산성을 향상합니다.

3. 데이터 계층 Scale Out - 데이터베이스 다중화

데이터베이스 다중화는 데이터베이스 서버를 Scale Out하는 방법입니다.

master-slave 관계를 설정하여 데이터 원본은 master 서버에, 복제본은 slave 서버에 저장하는 방식
데이터 계층에서 발생되는 장애를 해결하기 위한 방법입니다.

데이터 원본은 master 서버에 저장되고 사본을 slave에 저장하는 방식입니다.

읽기 연산 외의 기능(데이터를 변경하는 기능)은 master에서만 일어나고, slave 서버에서는 read 연산만 일어납니다.

데이터 변동을 일으키는 연산은 master로 전달됩니다.

애플리케이션 연산의 대부분은 읽기 연산(read)으로, 쓰기 연산(insert/update/delete)에 비해 부하가 더 큽니다.

이에 따라, slave 데이터베이스 수를 master 데이터 수보다 많이 설정하는 것이 데이터베이스 성능을 높이기에 유리합니다.

성능을 높일 수 있습니다.
- slave 서버를 여러개 두게 되면 읽기 연산을 분산 처리하게되고, 이에 따라 병렬적으로 처리되는 쿼리 수가 늘어나 성능이 높아집니다.
안정성(reliability)
- 데이터베이스 서버를 여러지역에 다중화할 경우, 재해발생으로 데이터가 손상되어도 데이터는 안전하게 보존할 수 있습니다.
가용성(availability)
- 데이터베이스를 여러 곳에 복제해둘 경우, 하나의 데이터베이스 서버가 장애가 발생되어도 다른 서버에 있는 데이터를 가져와 서비스를 지속할 수 있습니다.

IF 1

만일 slave 데이터베이스 서버에 장애가 발생되었는데 slave 서버가 한대 뿐일 경우에는 일시적으로 모든 데이터베이스 연산은 master가 수행하게 됩니다.

IF 2

만일, master 데이터베이스 서버에 장애가 발생될 경우, slave 데이터베이스중 하나를 master 데이터베이스 서버로 대체하여 연산합니다.
그 때, 만일 slave 데이터베이스 서버가 한대 뿐이었다면 새로운 slave 서버를 즉시 추가하는게 좋습니다.

production 환경에서라면, slave 데이터베이스 서버에 있는 데이터가 최신 데이터가 아닐 경우가 있기 때문에 별도의 처리를 고려해야 합니다.

이 경우에는, slave 데이터베이스를 master 데이터베이스로 교체하기 전에 없는 데이터를 복구하기 위한 복구 스크립트(recovery script)를 실행해야합니다.

※ 만일 multi-master, circular replication 등을 도입하여 master 데이터베이스를 1개 이상으로 설정할 경우 master 데이터베이스에 장애가 발생되더라도 장애복구가 더 유리할 수 있겠지만, 이 부분은 구성이 매우 복잡해서 시스템 설계에 난이도가 높습니다.

4. 로드밸런서 && 데이터베이스 다중화

읽기나 쓰기를 실행하는 과정은 아래와 같습니다.

사용자가 DNS 서버로부터 public ip를 전달받는다(public ip는 로드밸런서 주소)
public ip를 이용하여 로드밸런서에 접속합니다.
로드밸런서는 Web Server들 중 하나에게 HTTP request를 전달합니다.
웹서버에서 비즈니스 로직을 실행합니다.
1. 데이터베이스 쓰기연산의 경우 master DB를 사용하고
2. 데이터베이스 읽기연산의 경우 slave DB를 사용합니다.

5. 데이터베이스 규모 확장

위에서 데이터베이스 서버를 Scale Out 방식으로 확장하는 것을 알아봤습니다.

그런데 만약 하나의 데이터베이스 서버 내에 데이터 규모가 너무 커진다면 어떻게 해야할까요?

단순하게 데이터베이스 서버의 용량을 증설하는 Scale Up 방식은 쉬워보이지만, 이는 위에서 말했었던 고비용, SPOF, 증설 용량 한계등의 문제가 있습니다.

이럴 때에는, 데이터베이스를 수평적으로 증설하는 것을 고려해봐야합니다.

5.1. 샤딩(sharding)

데이터베이스를 수평적으로 확장하는 것을 샤딩이라고 합니다.

샤드들은 모두 같은 스키마를 쓰지만 각 샤드에 들어있는 데이터는 중복되지 않습니다.
즉, 하나의 데이터베이스 서버를 여러대로 쪼갠 형태라고 볼 수 있습니다.

샤딩 전략을 구현할 때 고려할 중요한 것은 샤딩 키(= 파티션 키) 인데, 이 것은 데이터 분산에 활용된 하나 이상의 키입니다.

샤딩을 구성했을 경우 고려해야할 몇가지 사항이 있습니다.

재샤딩
- 데이터가 너무 많아 샤드가 더 필요할 때
- 샤드간 데이터 분포가 균등하지 않을 경우
유명인사 문제(= 핫스팟 조회)
- 빈번히 조회되는 레코드가 하나의 샤드에 몰려있을 경우, 하나의 샤드에만 트래픽이 몰릴 수 있습니다.
- 이 경우, 유명인사들을 여러 샤드에 분산하여 할당해야합니다.
조인, 비정규화
- 샤딩 후 데이터 조인이 힘들어지는 문제가 발생합니다
- 이를 해결하기 위해 데이터베이스를 비정규화하여 하나의 테이블에서 쿼리가 수행될 수 있도록 할 수 있습니다.

5.2. 데이터베이스 종류에 대한 고민

하나의 데이터베이스를 쪼개서 여러개의 서버에 저장하는 것이 샤딩입니다. 이러한 특징 때문에 고려해야할 점이 있습니다.

RDBMS는 데이터무결성과 일관성이 중요하기 때문에 샤딩이 매우 까다롭습니다.

RDBMS의 가장 중요한 특징인 관계형이 바로 그에 대한 이유입니다.
만일, 특정 데이터베이스의 FK값을 이용하여 다른 테이블과 join을 하고자할 때, 그 연관테이블이 다른 DB서버에 저장되어있다면 어떻게 될까?
파티션 조각간의 join은 되지 않기 때문에 이 경우에는 RDBMS의 장점이 무색해집니다.

바로 이러한 점이 기존의 RDBMS에서 샤딩에 대한 어려운 점으로 남습니다.

때문에, 샤딩을 활용하고자 한다면, NoSQL을 사용해볼 것을 고려해보는 것도 좋습니다.

NoSQL은 그 밖에도 아래와 같은 상황에도 고려해보는 것을 권장합니다.

응답 지연시간(latency)이 낮아야할 경우
다루는 데이터가 비정형일 경우(=관계형 데이터가 아닐경우)
데이터를 직렬화/역직렬화 하기만 하면 되는 경우
아주 많은 데이터를 저장해야하는 경우
트래픽 양에 따른 규모 확장을 빠르고 손쉽게 하고 싶은 경우

6. 응답시간 개선

응답시간(latency)을 개선하기 위한 방법을 알아봅시다.
캐시를 붙여서 정적 컨텐트를 CDN으로 옮기면 개선할 수 있습니다.

6.1. 캐시

값비싼 연산결과나 자주 참조되는 데이터를 메모리 안에 둬서 후에 이어지는 request를 보다 빨리 처리될 수 있도록 하는 저장소입니다.

request 하나를 처리할 때 최소 1번 이상의 Database 호출이 발생됩니다.
애플리케이션 성능 향상을 위해서는 DB 호출을 최소화하는 것이 중요합니다.

캐시 계층은 데이터가 잠시 보관되는 곳으로, DB보다 빠릅니다
별도의 캐시 계층을 두는 것은 성능개선과 DB 부하를 줄이는 장점이 있습니다.

캐시를 사용할때 몇가지 고려해야할 점이 있습니다.

캐시를 적용하기 적절한 경우는?
- 데이터 갱신이 잘 일어나지 않을 경우에는 캐시를 적용하기 적절합니다.
- 데이터 갱신이 빈번한 경우에는 적절하지 않습니다.
캐시에는 어떤 데이터를 둬야할까?
- 캐시는 휘발성 메모리에 둡니다.
- 서버 재시작시 모두 휘발되기 때문에 영속적으로 저장해야할 데이터는 반드시 database에 저장해야합니다.
보관된 데이터의 만료기간은?
- 캐시 만료기간에 대한 정책을 설정하여, 만료된 데이터는 캐시에서 삭제되도록 해야합니다.
  - 만료시간이 너무 짧을시, DB 호출을 빈번하게 하고
  - 만료시간이 너무 길 경우, 원본과 캐시에 저장된 값이 다를 경우가 있습니다.
일관성(consistency) 유지 방법은?
- 데이터를 저장하는 연산과 캐시를 갱신하는 연산은 하나의 Transaction 내에서 처리해야만 일관성을 유지할 수 있습니다.
장애 대책
- 캐시서버를 분산시켜야 합니다. (= 여러대 둬야 합니다.)
  - 캐시서버가 하나뿐이라면, 캐시서버에 장애가 발생했을시 데이터 조회 관련된 모든 서비스가 중단될 수 있습니다. (SPOF, Single Point Of Failure)
데이터 방출(eviction) 정책
- 캐시가 꽉찼을 때 기존 데이터 중 어떤 데이터를 방출할것인지에 대한 정책
- LRU, Least Recently Used
  - 마지막으로 사용된 시점이 가장 오래된 것을 내보냄
- LFU, Least Frequently Used
  - 사용 빈도가 가작 적은 것을 내보냄
- FIFO, First In First Out
  - 가장 먼저 들어온 것을 가장 먼저 내보냄(= 선입선출)
캐시 메모리
- 너무 작을 경우, 저장된 데이터가 자주 밀려나가 캐시 성능이 떨어집니다.

6.2. CDN

Content Delivery Network
정적 컨텐츠를 전송할 때 쓰이는 지리적으로 분산된 서버의 네트워크로 이미지, 비디오, css, javascript 파일 등을 캐시할 수 있습니다.

request path + query string + request header + cookie 등의 정보를 이용하여 HTTP 페이지를 캐시합니다.

CDN 서버가 여러대일 경우, 사용자가 http request를 요청할 시, 가장 가까운 CDN 서버로부터 정적 컨텐츠를 전달받을 수 있습니다.
만일, CDN 서버에 캐시되지 않은 정적 컨텐츠를 요청했을 경우, 원본 서버로부터 요청하여 컨텐츠를 요청하여 적재한 후 반환합니다.

이때, 응답 헤더에는 TTL 값이 들어있고, TTL에 명시된 시간이 끝날때까지만 캐시합니다.
컨텐츠의 최신성 유지와 원본 서버에 요청보내는 수의 간의 중간점을 찾기 위해 적절한 TTL을 설정해야 합니다.

CDN 서버를 사용할 때 고려해두면 좋을 사항이 몇가지 있습니다.

만일 CDN 서버에 장애가 발생했을 경우에 대한 대책 방안
- 원본서버로부터 직접 컨텐츠를 가져오도록 처리
TTL이 만료되지 않은 컨텐츠를 무효화하는 방안
- CDN 서비스 사업자가 제공하는 무효화 API
- 정적 컨텐츠에 버전 관련 인자 설정
  - ex. like.png?v=2

6.3. Cache && CDN 적용 결과

정적 컨텐츠(images, js, css)는 웹서버가 아닌 CDN을 통해 제공하기 때문에 웹서버 성능을 향상시킵니다.
캐시가 database 서버의 부하를 줄입니다.

7. 데이터 센터(IDC)

지리적 라우팅(geoDNS-routing, geo-routing)을 이용하면 사용자의 위치에서 가장 가까운 데이터 센터로 ip를 변환할 수 있습니다.

예를들면 서울 IDC, 대전 IDC 같이 지역을 달리 구성하는 것

여러개의 데이터 센터를 지리적으로 다른 위치에 위치시키는 것이 큰 재난에 대한 대응을 할 수 있습니다.

다중 데이터 센터 아키텍처에서 데이터 센터 하나가 장애가 발생했을시, 관련 트래픽은 나머지 데이터 센터에서 대신하여 처리합니다.

다중 데이터 센터 아키텍처를 구성할 때엔 아래와 같은 사항을 고려해야 합니다.

트래픽 우회
- GeoDNS가 가장 가까운 데이터센터로 트래픽을 보내도록 해야합니다.
데이터 동기화
- 데이터 센터마다 별도의 데이터베이스를 가지고 있을 경우, 각 데이터 센터 내에 있는 데이터베이스를 다중화해야 합니다.
테스트 및 배포
- 자동화된 배포도구를 이용하여 각 데이터 센터에서 웹사이트/애플리케이션 구동이 잘되는지 테스트해야 합니다.

++

가상 면접 사례로 배우는 대규모 시스템 설계 기초
이미지 출처
- https://www.flaticon.com/authors/iconbaandar

[Hexagonal Architecture] 3. Adapter 구현하기

jiniya22 — Fri, 31 Mar 2023 03:42:29 +0900

Web Adapter 구현하기
Persistence Adapter 구현하기
참고

1. Web Adapter 구현하기

웹 어댑터는 incoming adapter 중 하나로, 외부로부터 http를 통해 request를 받아 애플리케이션 코어를 호출하는 주도하는 어댑터입니다.

우리가 controller 클래스로 정의하는 부분이 이에 해당되며, http와 관련된 기능을 담당합니다.

웹 어댑터는 application - port - in에 위치한 input port를 호출합니다.

input port는 외부 어댑터와 애플리케이션 코어가 통신하는 명세로 인터페이스로 되어있어 DIP(의존성 역전 원칙)이 작용됩니다.

이전시간에 설명했던 UseCase 인터페이스, 읽기전용 UseCase인 Query 인터페이스가 여기에 해당됩니다.

웹 어댑터는 아래와 같은 단계로 작업을 수행합니다.

http request를 Java 객체로 매핑
권한 검사
입력 유효성 검증
입력 값을 Use Case용 입력모델로 매핑
유스케이스 호출
유스케이스 결과를 http로 매핑
http response 반환

http와 관련된 기능은 철저하게 웹 어댑터에서 처리하고,
애플리케이션 코어나 다른 어댑터는 http와 관련된 모든 기능을 관여하지 않습니다.

애플리케이션 코어에서 http에 대한 기능을 관여하지 않는 성질에 의해 다른 어댑터로 쉽게 교체할 수 있습니다.

웹 어댑터도 유스케이스와 같이 작게 쪼개어 가독성을 높이고 코드의 재활용을 높입니다.
(또한 협업에도 효율적입니다.)

공지사항 조회용 웹 어댑터

@Validated
@WebAdapter
@Tag(name = "setting-system", description = "설정-시스템(공지사항, FAQ, 이용약관, 메타정보 등)")
@RestController
@RequestMapping("/v1/notices")
internal class GetNoticeController(
    private val getNoticeQuery: GetNoticeQuery,
) {

    @Operation(summary = "공지사항 목록")
    @GetMapping("")
    fun getNotices(
        @RequestParam(value = "page", required = false, defaultValue = "0") page: Int,
        @RequestParam(value = "size", required = false, defaultValue = "10") size: Int,
    ) = getNoticeQuery.getNoticeSummaries(GetNoticesCommand(page = page, size = size))

    @Operation(summary = "공지사항 상세조회")
    @GetMapping("/{notice_id}")
    suspend fun getNotice(@PathVariable("notice_id") noticeId: String,
    ) = getNoticeQuery.getNoticeDetail(noticeId)
        ?: throw NotFoundException("조회되는 공지사항이 없습니다.")

}

공지사항 등록용 웹 어댑터

@WebAdapter
@Tag(name = "setting-system", description = "설정-시스템(공지사항, FAQ, 이용약관, 메타정보 등)")
@RestController
@RequestMapping("/v1/notices")
internal class RegisterNoticeController(
    private val registerNoticeUseCase: RegisterNoticeUseCase,
) {

    @Operation(summary = "공지사항 등록")
    @PostMapping("")
    suspend fun getNotices(
        @Valid @RequestBody command: RegisterNoticeCommand,
    ) = registerNoticeUseCase.registerNotice(command)

}

2. Persistence Adapter 구현하기

기존의 계층형 아키텍처의 문제점은 데이터베이스(영속성 계층)에 의존적인 구조라는 점이었습니다.

헥사고날 아키텍처는 데이터베이스가 아닌 도메인 주도 설계입니다.
도메인을 기준으로 설계하기 위해서는 DIP(의존성 역전)이 적용되어야 합니다.

서비스에서 영속성 작업을 수행하기 위해 output port 를 호출합니다.

persistence adapter는 output port 인터페이스를 구현하고
output port는 명세만 작성되어있기 때문에 영속성 계층에 대한 의존성이 없습니다.

web adapter와 마찬가지로 다른 어댑터로 쉽게 교체할 수 있고, 영속성 어댑터의 변경은 애플리케이션 코어에 영향을 주지 않습니다.

영속성 어댑터는 아래와 같은 단계로 작업을 수행합니다.

입력값을 받고
입력값을 데이터베이스용 형식으로 매핑한 후 데이터 베이스로 보낸 다음
- JPA를 사용하는 경우 JPA 엔티티 도메인 형식으로 매핑
- MongoDB를 사용하는 경우 MongoDB 도큐먼트 형식으로 매핑
데이터베이스 출력값을 애플리케이션 형식으로 매핑하여
출력값을 반환합니다.

2.1. Output Port

Output port에 JpaRepository 인터페이스가 있을 경우, 영속성 어댑터가 output port에 의존성을 갖게되는 문제점이 있습니다.

output port에서도 input port와 마찬가지로, 어뎁터에서 작동될 기능에 대한 명세가 기록된 인터페이스만 정의하고
JpaRepository 인터페이스는 adapter - out - persistence에 위치시키는 것이 구조적으로 좋습니다

ISP(인터페이스 분리 원칙)

interface LoadNoticePort {
    fun loadNotices(pageable: Pageable): Flow<Notice>
    suspend fun loadNotice(id: String): Notice?
}

interface SaveNoticePort {
    suspend fun saveNotice(notice: Notice)
}

2.2. ORM Entity

만일, 연결할 퍼시스턴스 어댑터가 MongoDB 기반이라면,
MongoDB document 정의가 필수적으로 필요합니다.

이때, 도메인 레이어에서 영속성 레이어로의 결합을 낮추기 위해, 도메인 객체로 변환하는 매퍼를 별도로 정의하기를 권장합니다.

2.2.1. ORM Entity

@Document(value = "notice")
internal class NoticeDocument(var title: String, var content: String) {
    @Id
    var id: String? = null

    @CreatedDate
    var createdAt: LocalDateTime = LocalDateTime.now()

    @LastModifiedDate
    var updatedAt: LocalDateTime? = null

}

2.2.2. ORM Repository

JpaRepository, MongoRepository, CoroutineCrudRepository 등 이용하고자하는 Spring Data 프로젝트를 활용하여 DB 레코드를 조회합니다.

@Repository
internal interface NoticeRepository: CoroutineCrudRepository<NoticeDocument, String> {
    fun findAllBy(pageable: Pageable): Flow<NoticeDocument>
}

2.3. Mapper 클래스

영속성 어댑터에서 조회한 ORM Entity를 도메인으로 변환하고,
웹어댑터에서 요청하는 도메인 정보를 영속성 어댑터에서 활용하기 위해 ORM Entity로 변환하는 과정이 필요합니다.

도메인 → ORM Entity, ORM Entity → 도메인으로 변환하는 Mapper 클래스를 만들어줍니다.

internal object NoticeMapper {

    fun mapToNotice(doc: NoticeDocument) =
        Notice(summary = Notice.Summary(id = doc.id, title = doc.title,
            createdAt = DateTimeUtils.toString(doc.createdAt)), content = doc.content)

    fun mapToDocument(notice: Notice) =
        NoticeDocument(title = notice.summary.title, content = notice.content)

}

3. 참고

3.1. application domain

참고로, application core에 위치한 도메인은 아래와 같이 정의했습니다.

간단하게, 간략정보를 담고 있는 Summary와, detail 메서드로 상세정보를 조회할 수 있도록 했습니다.

data class Notice(
    val summary: Summary,
    val content: String,
) {
    data class Summary(
        val id: String? = null,
        val title: String,
        val createdAt: String? = null,
    )

    data class Detail(
        val id: String? = null,
        val title: String,
        val content: String,
        val createdAt: String? = null,
    )

    fun detail(): Detail {
        return Detail(id = summary.id, title = summary.title, content = content, createdAt = summary.createdAt)
    }
}

3.2. Transaction 위치

영속성 어댑터에서 ORM 엔티티에 접근하는 과정이 있으나, 트랜잭션은 하나의 기능을 모두 마쳤을 때 commit 또는 rollback이 되어야하는 기능입니다.

따라서, 영속성 어댑터가 아닌 서비스(= UseCase 구현체)에서 트랙젝션을 설정하는 것이 좋습니다.

@Transactional(readOnly = true)
@UseCase
internal class GetNoticeService(
    private val loadNoticePort: LoadNoticePort,
) : GetNoticeQuery {

    override fun getNoticeSummaries(command: GetNoticesCommand) =
        loadNoticePort.loadNotices(PageRequest.of(command.page, command.size, Sort.by(
            Sort.Order.desc("id")))).map { it.summary }

    override suspend fun getNoticeDetail(id: String): Notice.Detail? =
        loadNoticePort.loadNotice(id)?.detail()
}

@Transactional(readOnly = true)
@UseCase
internal class RegisterNoticeService(
    private val saveNoticePort: SaveNoticePort,
): RegisterNoticeUseCase {

    @Transactional
    override suspend fun registerNotice(command: RegisterNoticeCommand) {
        saveNoticePort.saveNotice(Notice(Notice.Summary(title = command.title), content = command.content))
    }

}

트랜젝션은 서비스 내의 메서드에 직접 설정하거나, AOP를 이용하여 service 메서드 종료 후 동작되도록 정의할 수 있습니다

※ 해당 코드는 GitHub에서 demo-hexagonal 프로젝트에서 확인할 수 있습니다.

[Java - String] 1. 중복 문자 제거하기

jiniya22 — Wed, 8 Mar 2023 20:36:14 +0900

주어진 문자열에서, 중복된 문자는 제거하는 코드를 작성하라

apple -> aple
banana -> ban

풀이
성능

1. 풀이

1.1. indexOf 활용

문자열 s의 각 문자를 순회하며
StringBuilder sb에 아직 입력되지 않은 문자를 추가한다.

문자가 sb에 포함되어있지 않다면 추가
포함되어있다면 추가하지 않으면 된다.

static String removeDuplicates1(String s) {
    if (s == null || s.isBlank()) {
        return s;
    }
    StringBuilder sb = new StringBuilder();
    for (char c : s.toCharArray()) {
        if (sb.indexOf(String.valueOf(c)) == -1) {
            sb.append(c);
        }
    }
    return sb.toString();
}

1.2. HashSet 활용

문자열 s에 들어있는 문자를 순회하면서
문자를 HashSet에 추가하는데

HashSet에 포함되어있지 않을 경우 sb에 추가하고
포함되어있을 경우 sb에 추가하지 않습니다.

Set의 add함수는 만일 기존에 값이 들어있을 경우 false, 없을 경우 true를 리턴합니다.

static String removeDuplicates2(String s) {
    if (s == null || s.isBlank()) {
        return s;
    }
    StringBuilder sb = new StringBuilder();
    Set<Character> set = new HashSet<>();
    for (char c : s.toCharArray()) {
        if (set.add(c)) {
            sb.append(c);
        }
    }
    return sb.toString();
}

1.3. stream의 distinct 활용

stream()의 distinct()를 이용하여 중복 문자를 제거하고,
제거한 후 collect(Collectors.joining())으로 리스트를 합치는 방법을 이용할 수 도 있습니다.

static String removeDuplicates3(String s) {
    if (s == null || s.isBlank()) {
        return s;
    }
    return Arrays.asList(s.split("")).stream()
            .distinct()
            .collect(Collectors.joining());
}

2. 성능

다만, 위의 3가지의 방법은 속도 차이가 있습니다.

String s = "aB 8 b tT ! k 2 098!";

라는 문자열에 대해서 아래와 같은 퍼포먼스를 보여줍니다.

실행시간: 80251 ns (0 ms)
aB 8btT!k209

실행시간: 75711 ns (0 ms)
aB 8btT!k209

실행시간: 5073320 ns (5 ms)
aB 8btT!k209

Set을 활용하는 방법이 가장 성능이 빠르고,
거의 비등한 방식으로 indexOf 방식으로 빠르지만
stream()을 활용한 방식은 현저히 느립니다.

이 부분에 대해 고려를 하고 코드를 작성하는 것이 좋을것으로 보입니다.

++

RemoveDuplicateCharacters

[Java] override, overload

jiniya22 — Sun, 5 Feb 2023 16:57:02 +0900

1. method override

상속하는 클래스에서 상위 클래스(또는 인터페이스)의 메서드를 재정의하는 것

메서드를 재정의 하는 것이기 때문에 final, static 메서드는 오버라이드 할 수 없습니다.

protected 이상의 접근 제한자에서 지원됩니다.

private 접근제한자는 오버라이드 할 수 없습니다.

서브 클래스의 오버라이드 메서드에서 슈퍼 클래스의 메서드를 호출하고 싶다면 super키워드를 사용하면 됩니다.

오버라이딩은 런타임 시 실질적으로 작동될 메서드가 결정되는 동적 바인딩 방식입니다.

1.1. 예제 1

Java에서 서브 클래스 타입은 슈퍼 클래스 타입으로 받을 수 있습니다.
아래 예제에서는 Animal 타입으로 Cat, Dog 클래스를 받을 수 있습니다.

interface Animal {
    void bark();
}

class Cat implements Animal {
    @Override
    public void bark() {
        System.out.println("야옹");
    }
}

class Dog implements Animal {
    @Override
    public void bark() {
        System.out.println("멍멍");
    }
}

public class OverrideTest {

    public static void main(String[] args) {
        List<Animal> animals = List.of(new Dog(), new Cat());
        for (Animal animal : animals) {
            animal.bark();
        }
    }
}

멍멍
야옹

Animal을 구현한 Cat, Dog 클래스는 bark() 메서드를 오버라이드 했어서
위와 같이 같은 이름의 메서드를 호출할 수 있습니다.

animal.bark() 구문은 런타임시 실제 메서드를 결정합니다.

1.2. 예제 2. override시 공변 리턴 타입 허용

오버라이드 시 covariant(공변) 리턴 타입을 허용한다는 것은
오버라이드 시 반환 값을 Sub Class로 설정할 수 있는 성질을 뜻합니다.

즉, 오버라이드 할 때 반환 값을 하위 클래스로 변경할 수 있는 성질입니다.

Shape 인터페이스에서 area 메서드의 반환타입은 Number 입니다.

Shape를 구현하는 클래스인 Square, Circle에서는 area메서드의 리턴타입은 Integer, Double로 변경이 가능합니다.

interface Shape {
    Number area();
}

class Square implements Shape {
    private int width;

    public Square(int width) {
        this.width = width;
    }

    @Override
    public Integer area() {
        return width * width;
    }
}

class Circle implements Shape {
    private int radius;

    public Circle(int radius) {
        this.radius = radius;
    }

    @Override
    public Double area() {
        return Math.PI * Math.pow(radius, 2.0);
    }
}

2. method overload

같은 이름의 메서드이지만 서로 다른 입력값을 갖는 메서드를 작성하는 것을 의미합니다.

서로 다른 입력값에는 인수의 갯수, 인수 타입, 인수 위치가 해당됩니다.

특정 메서드에 throws문이 있다고 할 때, 오버로드 메서드에 throws문이 있지 않아도 되고 다른 Exception을 throw 해도 됩니다.

인수 값에 따라 실행될 메서드가 실행되는, 컴파일 시 실행될 메서드가 결정되는 정적 바인딩 방식입니다.

메서드는 static 또는 static이 아닌 메서드로 작성하고
리턴값은 각각 달라도 됩니다.

static int plus(int a, int b) {
    return a + b;
}

static int plus(int a, int b, int c) {
    return a + b + c;
}

static double plus(double a, double b) {
    return a + b;
}

3. interface 내의 default, static 메서드

interface 함수 내의 메서드는 기본적으로 public abstract 이고 해당 키워드는 생략하여 표기합니다.

Java 8 부터는 interface에서 static 메서드, default 메서드를 이용할 수 있습니다.

default 키워드는 인터페이스 메서드에 기본 구현을 작성할 수 있도록 합니다. (default 메서드는 override가 필수가 아닙니다.)

static 메서드는 하위 클래스로 상속되지는 않지만, 인터페이스 내의 static method나 default 메서드에서 접근은 가능합니다.

interface Vehicle {
    String getName();

    static String code() {
        return "200";
    }

    default void introduce() {
        System.out.printf("이름: %s, 코드: %s%n", getName(), code());
    }
}

class Car implements Vehicle {
    private String name;

    public Car(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }
}

default 메서드가 있는 interface는 abstract class와 기능상으로는 동일해 보입니다.

interface에 default 메서드를 이용하는 것은
기존의 비즈니스 로직에는 영향을 주지 않으면서 추가 기능을 추가하고자할 때 활용할 수 있습니다.

기본적으로 abstract class와 interface의 차이점은
abstract class에서는 abstract가 아닌 메서드도 가질 수 있고, 필드값을 가질 수 있다는 점입니다.

이 특성을 이용하여 Java에서는 기존의 인터페이스에 새로은 기능을 추가하고자 할때, 그 인터페이스의 구현체에 영향을 주지않으면서 기능을 추가하는 것이 가능해졌습니다.

4. static method 숨기기

만일, Super Class와 Sub Class에서 동일한 이름의 static method를 갖고 있다면,
클래스 작성된 static 메서드를 호출하고 나머지는 숨겨집니다.

class Fruit {
    public static void introduce() {
        System.out.println("나는 과일 입니다");
    }
}

class Apple extends Fruit {
    public static void introduce() {
        System.out.println("나는 사과 입니다");
    }
}

public class MethodHidingTest {
    public static void main(String[] args) {
        Fruit.introduce();
        Apple.introduce();
    }
}

나는 과일 입니다
나는 사과 입니다

[Codility - Java] 5. Prefix Sums - 4. MinAvgTwoSlice

jiniya22 — Wed, 1 Feb 2023 01:21:01 +0900

MinAvgTwoSlice

A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P < Q < N, is called a slice of array A (notice that the slice contains at least two elements). The average of a slice (P, Q) is the sum of A[P] + A[P + 1] + ... + A[Q] divided by the length of the slice. To be precise, the average equals (A[P] + A[P + 1] + ... + A[Q]) / (Q − P + 1).

For example, array A such that:

A[0] = 4
A[1] = 2
A[2] = 2
A[3] = 5
A[4] = 1
A[5] = 5
A[6] = 8

contains the following example slices:

slice (1, 2), whose average is (2 + 2) / 2 = 2;
slice (3, 4), whose average is (5 + 1) / 2 = 3;
slice (1, 4), whose average is (2 + 2 + 5 + 1) / 4 = 2.5.

The goal is to find the starting position of a slice whose average is minimal.

Write a function:

class Solution { public int solution(int[] A); }

that, given a non-empty array A consisting of N integers, returns the starting position of the slice with the minimal average. If there is more than one slice with a minimal average, you should return the smallest starting position of such a slice.

For example, given array A such that:

A[0] = 4
A[1] = 2
A[2] = 2
A[3] = 5
A[4] = 1
A[5] = 5
A[6] = 8

the function should return 1, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [2..100,000];
each element of array A is an integer within the range [−10,000..10,000].

N개의 정수로 이뤄진 비어있지 않은 배열 A

정수로 이뤄진 pair인 (P, Q)는 0 <= P < Q < N을 만족합니다.
pair (P, Q)는 배열 A의 요소를 slice한 것이고, 그 것의 평균은 (A[P] + A[P + 1] + ... + A[Q]) / (Q - P + 1) 입니다.
가장 평균이 작은 pair의 P값을 리턴하면 됩니다.

가장 작은 평균을 나타내는 시작점 P를 구하는 문제.

4개 이상의 수의 평균은, 어떻게 하더라도 2개나 3개로 구성한 평균보다 큽니다.

4 2 1 1 의 평균보다, 1 1 의 평균이 더 작은 것을 생각하면 됩니다.

방법 1. 누적 합을 이용하여 풀기.

누적합을 이용하여 countingArr를 계산하고,
누적합의 2요소간의 차, 3요소간의 차를 조회하여 가장 작은 평균값을 나타내는 시작점 P를 구하면 됩니다.

countingArr의 맨 첫번째는 0,
그 이후부터는 A의 요소를 합산한 값이 들어있습니다.

$A = [4, 2, 2, 5, 1, 5, 8]$
$countingArr = [0, 4, 6, 8, 13, 14, 19, 27]$

(0, 1) = (4 + 2)/2
(1, 2) = (2 + 2)/2
(1, 3) = (2 + 2 + 5)/3

countingArr에서 구하는 방법은
(0, 1) = (countingArr[2] - countingArr[0])/2
(1, 2) = (countingArr[3] - countingArr[1])/2
(1, 3) = (countingArr[4] - countingArr[1])/3

코드로 나타내면 아래와 같습니다.

static int minAvgTwoSlice(int[] A) {
    int[] countingArr = new int[A.length + 1];
    for (int i = 0; i < A.length; i++) {
        countingArr[i + 1] = countingArr[i] + A[i];
    }
    double minAvg = (countingArr[2] - countingArr[0])/2.0;
    int startingPosition = 0;
    for (int i = 2; i < A.length; i++) {
        double temp = (countingArr[i + 1] - countingArr[i - 1])/2.0;
        if(minAvg > temp) {
            minAvg = temp;
            startingPosition = i - 1;
        }
        temp = (countingArr[i + 1] - countingArr[i - 2])/3.0;
        if(minAvg > temp) {
            minAvg = temp;
            startingPosition = i - 2;
        }
    }
    return startingPosition;
}

방법 2.

누적합을 활용하지 않고, 배열 A의 각요소를 더해서 평균을 구해도 무관합니다.

static int minAvgTwoSlice(int[] A) {
    int minSlice = 0;
    double minAvg = (A[0] + A[1])/2.0;

    for (int i = 2; i < A.length; i++) {
        double temp = (A[i] + A[i - 1]) / 2.0;
        if(temp < minAvg) {
            minAvg = temp;
            minSlice = i - 1;
        }
        temp = (A[i] + A[i - 1] + A[i - 2]) / 3.0;
        if (temp < minAvg) {
            minAvg = temp;
            minSlice = i - 2;
        }
    }
    return minSlice;
}

[Codility - Java] 4. Counting Elements - 1. FrogRiverOne

jiniya22 — Tue, 31 Jan 2023 15:34:32 +0900

FrogRiverOne

Find the earliest time when a frog can jump to the other side of a river.

A small frog wants to get to the other side of a river. The frog is initially located on one bank of the river (position 0) and wants to get to the opposite bank (position X+1). Leaves fall from a tree onto the surface of the river.

You are given an array A consisting of N integers representing the falling leaves. A[K] represents the position where one leaf falls at time K, measured in seconds.

The goal is to find the earliest time when the frog can jump to the other side of the river. The frog can cross only when leaves appear at every position across the river from 1 to X (that is, we want to find the earliest moment when all the positions from 1 to X are covered by leaves). You may assume that the speed of the current in the river is negligibly small, i.e. the leaves do not change their positions once they fall in the river.

For example, you are given integer X = 5 and array A such that:

A[0] = 1
A[1] = 3
A[2] = 1
A[3] = 4
A[4] = 2
A[5] = 3
A[6] = 5
A[7] = 4

In second 6, a leaf falls into position 5. This is the earliest time when leaves appear in every position across the river.

Write a function:

class Solution { public int solution(int X, int[] A); }

that, given a non-empty array A consisting of N integers and integer X, returns the earliest time when the frog can jump to the other side of the river.

If the frog is never able to jump to the other side of the river, the function should return −1.

For example, given X = 5 and array A such that:

A[0] = 1
A[1] = 3
A[2] = 1
A[3] = 4
A[4] = 2
A[5] = 3
A[6] = 5
A[7] = 4

the function should return 6, as explained above.

Write an efficient algorithm for the following assumptions:

N and X are integers within the range [1..100,000];
each element of array A is an integer within the range [1..X].

개구리는 0 위치에 있고, X + 1로 가고 싶어한다.

강 표면에는 나뭇잎이 떠있습니다.

N개의 정수로 구성된 배열 A (배열 A는 비어있지 않습니다.)
A[K] 에는 K 초에 측정된 나뭇잎 위치가 들어있습니다.

A[0]은 0초에 떨어진 나뭇잎, A[1]은 1초에 떨어진 나뭇잎

개구리는 위치 1부터 위치 X까지 모든 낙엽이 띄워져 있어야 반대편으로 갈 수 있습니다.

개구리가 몇 초가 지나야 강 반대편으로 넘어갈 수 있는지 구하면 됩니다.
만일, 넘어갈 수 없다면 -1을 리턴하세요.

1 <= N, X <= 100,000

배열 A를 순회하면서 set에 요소를 넣고,
set 크기가 X 가 같아지면 반복문을 종료하면 됩니다.
반복문을 모두 돈 후에도 X와 set 크기가 같은 경우가 없다면 -1을 리턴하면 됩니다.

static int frogRiverOne(int[] A, int X) {
    int result = -1;
    Set<Integer> s = new HashSet<>();
    for (int i = 0; i < A.length; i++) {
        s.add(A[i]);
        if (X == s.size()) {
            result = i;
            break;
        }
    }
    return result;
}

$O(N)$

[Codility - Java] 3. Time Complexity - 2. PermMissingElem

jiniya22 — Tue, 31 Jan 2023 15:09:54 +0900

PermMissingElem

Find the missing element in a given permutation.

An array A consisting of N different integers is given. The array contains integers in the range [1..(N + 1)], which means that exactly one element is missing.

Your goal is to find that missing element.

Write a function:

class Solution { public int solution(int[] A); }

that, given an array A, returns the value of the missing element.

For example, given array A such that:

A[0] = 2
A[1] = 3
A[2] = 1
A[3] = 5

the function should return 4, as it is the missing element.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [0..100,000];
the elements of A are all distinct;
each element of array A is an integer within the range [1..(N + 1)].

N 개의 서로다른 정수로 구성된 배열 A
배열의 각 요소는 $1 <= A[i] <= N + 1$ 범위 중 하나고,
단 하나의 정수만 없다.

배열 안에서 빠져있는 정수를 리턴하는 코드를 작성하면 됩니다.

배열 A를 순회하며 arr에 넣은 후,
arr를 다시 순회하면서 값이 들어있지 않은 경우 그 값을 리턴하면 됩니다.

int result = 0;
int[] arr = new int[A.length + 2];
for (int a : A) {
    arr[a] = 1;
}
for (int i = 1; i < arr.length; i++) {
    if (arr[i] == 0) {
       result = i;
       break;
    }
}
return result;

$O(N)$ or $O(N * log(N))$

[Codility - Java] 3. Time Complexity - 1. FrogJmp

jiniya22 — Tue, 31 Jan 2023 14:49:12 +0900

FrogJmp

Count minimal number of jumps from position X to Y.

A small frog wants to get to the other side of the road.
The frog is currently located at position X and wants to get to a position greater than or equal to Y.
The small frog always jumps a fixed distance, D.

Count the minimal number of jumps that the small frog must perform to reach its target.

Write a function:

class Solution { public int solution(int X, int Y, int D); }

that, given three integers X, Y and D, returns the minimal number of jumps from position X to a position equal to or greater than Y.

For example, given:

X = 10
Y = 85
D = 30

the function should return 3, because the frog will be positioned as follows:

after the first jump, at position 10 + 30 = 40
after the second jump, at position 10 + 30 + 30 = 70
after the third jump, at position 10 + 30 + 30 + 30 = 100

Write an efficient algorithm for the following assumptions:

X, Y and D are integers within the range [1..1,000,000,000];
X ≤ Y.

개구리가 도로 반대편으로 가고 싶어한다.
현재 X 위치에 있다고 할 때, Y 위치로 가려고 한다. (이때, Y 위치를 넘어서도 된다.)
개구리는 항상 고정된 거리인 D만큼 점프한다.

몇번을 뛰어야 D에 도달하게 되는지 리턴하면 된다.

X <= Y
1 <= X, Y, D <= 1,000,000,000,000

static int flogJmp(int X, int Y, int D) {
    if(X == Y) return 0;
    if(X + D >= Y) return 1;
    return (int)Math.ceil((double)(Y - X) / D);
}

$O(1)$

X와 Y가 같은 경우에는 0
X + D가 Y보다 클 경우에는 1
그 외의 경우에는 연산을 하면 되는데

거리 3을 2로 몇번이면 도달할 수 있느냐라고 할 때, 2번을 해야합니다.
즉, 소수의 올림을 활용하면 됩니다.

Math.ceil 함수는 double 자료형을 받는 함수이기 때문에 정확한 연산을 위해 분자 또는 분모 둘 중 하나를 double로 치환한 후 실행해야합니다.

그 후에는 int로 자료형을 변경해주면 끝

[Codility - Java] 2. Array - 2. OddOccurrencesInArray

jiniya22 — Tue, 31 Jan 2023 13:30:52 +0900

OddOccurrencesInArray

Find value that occurs in odd number of elements.

A non-empty array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired.

For example, in array A such that:

A[0] = 9  A[1] = 3  A[2] = 9
A[3] = 3  A[4] = 9  A[5] = 7
A[6] = 9

the elements at indexes 0 and 2 have value 9,
the elements at indexes 1 and 3 have value 3,
the elements at indexes 4 and 6 have value 9,
the element at index 5 has value 7 and is unpaired.

Write a function:

class Solution { public int solution(int[] A); }

that, given an array A consisting of N integers fulfilling the above conditions, returns the value of the unpaired element.

For example, given array A such that:

A[0] = 9  A[1] = 3  A[2] = 9
A[3] = 3  A[4] = 9  A[5] = 7
A[6] = 9

the function should return 7, as explained in the example above.

Write an efficient algorithm for the following assumptions:

N is an odd integer within the range [1..1,000,000];
each element of array A is an integer within the range [1..1,000,000,000];
all but one of the values in A occur an even number of times.

정수 N개로 이뤄진 배열 A
1 <= N < 1,000,000 이며
홀수개로 있는 숫자가 1개와, 나머지는 짝수개 있다.
홀수개가 있는 숫자를 반환하는 코드를 작성하면 된다.

간단하게, map을 이용하면 된다.
map에 key가 존재하면 remove하고,
없으면 put한다.

A 순회를 모두 마친 뒤 map에 남아있는 값이 바로 홀수개로 있는 정수다.

static int oddOccurrencesInArray(int[] A) {
    Map<Integer, Integer> map = new HashMap<>();
    for(int i : A) {
        if(map.containsKey(i)) {
            map.remove(i);
        } else {
            map.put(i, 1);
        }
    }
    return map.keySet().stream().findFirst().orElse(0);
}

$O(N)$ or $O(N*log(N))$

[Codility - Java] 2. Array - 1. CyclicRotation

jiniya22 — Tue, 31 Jan 2023 13:16:21 +0900

CyclicRotation

Rotate an array to the right by a given number of steps.

An array A consisting of N integers is given. Rotation of the array means that each element is shifted right by one index, and the last element of the array is moved to the first place. For example, the rotation of array A = [3, 8, 9, 7, 6] is [6, 3, 8, 9, 7] (elements are shifted right by one index and 6 is moved to the first place).

The goal is to rotate array A K times; that is, each element of A will be shifted to the right K times.

Write a function:

class Solution { public int[] solution(int[] A, int K); }

that, given an array A consisting of N integers and an integer K, returns the array A rotated K times.

For example, given

A = [3, 8, 9, 7, 6]
K = 3

the function should return [9, 7, 6, 3, 8]. Three rotations were made:

[3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7]
[6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9]
[7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]

For another example, given

A = [0, 0, 0]
K = 1

the function should return [0, 0, 0]

Given

A = [1, 2, 3, 4]
K = 4

the function should return [1, 2, 3, 4]

Assume that:

N and K are integers within the range [0..100];
each element of array A is an integer within the range [−1,000..1,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

N개의 정수로 구성된 배열 A
K 만큼 오른쪽으로 rotate한 배열을 리턴하는 코드를 구하면 됩니다.

0 <= N, K <= 100 을 만족하기 때문에, 빈 문자열이 들어왔을 때에 대한 처리도 해야합니다.

static int[] cyclicRotation(int[] A, int K) {
    if(A == null || A.length < 1 || K == 0) {
        return A;
    }

    int[] result = new int[A.length];
    K %= A.length;
    for (int i = 0; i < A.length; i++) {
        if (i + K < A.length) {
            result[i + K] = A[i];
        } else {
            result[i + K - A.length] = A[i];
        }
    }
    return result;
}

hello jiniworld

[MySQL] Window Function를 활용한 별도 계산 출력

1. Window Function?

2. 예제

[Spring Security] @PreAuthorize에서 활용하고 있는 인증 객체 warning 해소

1. IntelliJ의 warning 억제

2. 블럭 내부에서 authUser 사용하기

3. @PreAuthorize에서 authentication 활용하기

[Spring Data Commons] 2.1. Spring Data Repository

1. 핵심 개념

1.1. 확장 인터페이스

1.2. 기타 파생 쿼리

2. 메서드 질의하기

2.1. Repository 인터페이스 정의

2.2. 쿼리 메서드 선언

2.3. Java 구성파일 설정

2.4. Repository 주입

3. Repository Interface 정의하기

++

[Spring Data Commons] 1. 개요

1. Dependencies

1.1. Spring Data release train BOM

1.2. Spring Boot 종속성 관리

2. Spring Data 업그레이드

3. Object Mapping

3.1. 객체 생성

3.2. 프로퍼티(속성) 채우기

[Spring Boot Core] 2.2. Externalized Configuration

1. spring.config.name

2. spring.config.location

3. optional location

3.1. optional:

3.2. on-not-found

4. wildcard location

5. profile별 구성 파일

5.1. 특정 프로파일 활성화

5.2. Last wins 전략

6. 추가 데이터 import

6.1. Profipe-specific varinants 가져오기

6.2. 확장자 없는 파일 가져오기

7. configtree

8. property placeholders

9. 다중 문서 파일 작업

10. 활성화 프로퍼티

++

[Spring Boot Core] 2.1. Externalized Configuration 개요와 JSON Application Properties 설정하기

1. 구성설정 외부화 개요

1.1. 예제

2. command line 프로퍼티 액세스

3. JSON Application properties

3.1. 예제 소스코드

3.2. JSON Application Properties 설정하기

3.3. 테스트

3.3.1. api 테스트

3.3.2. env 테스트

++

[Spring Boot Core] 1. SpringApplication

Spring Appplication

1. startup 실패

2. 지연 초기화

3. 커스텀 배너

4. SpringApplication 커스텀

5. 애플리케이션 가용성

5.1. Liveness status

5.2. Readiness status

5.3. 애플리케이션 가용성 상태 관 리

6. 웹 환경

7. application arguments 접근

8. Application 또는 CommandLineRunner 사용

9. 애플리케이션 종료

10. 관리자 기능

11. 애플리케이션 시작 추적

11.1. 시작 시간 분석

11.2. 특정 startup event만 필터링하여 분석

11.3. jq json processor 를 이용한 빈 초기화 기간 조회

12. Virtual Thread

++

[Spring Boot Core] Actuator를 이용한 환경 변수 모아보기

1. dependency 추가

2. actuator endpoints 설정

1. `spring.config.name`

2. `spring.config.location`

3.1. `optional:`

2.1. GET `/actuator/env`

2.1. GET `/actuator/env/{환경변수명}`

3.1. GET `/actuator/env`

3.2. GET `/actuator/env/{환경변수명}`

3.1. `spring.mvc.log-request-details: true`

3.2. `spring.mvc.log-request-details: false`