IT is True

2048

잇트루 — Tue, 6 Jan 2026 09:00:44 +0900

Game Over!

키보드 방향키 또는 화면을 밀어서 플레이하세요.

테트리스 (Tetris)

잇트루 — Mon, 5 Jan 2026 09:00:09 +0900

Hold

Score

Combo

← → 이동 ↑ 회전 ↓ 내리기
Space 하드 드롭 Shift 홀드(저장)

[Java] 레코드 클래스 살펴보기 (Record Class)

잇트루 — Fri, 12 Jul 2024 01:16:22 +0900

Record Class

자바의 레코드 클래스는 Java 14부터 프리뷰 상태로 도입되어 Java 16에서 정식으로 지원하게 된 새로운 클래스다. 레코드는 데이터를 담기 위한 클래스를 더욱 간결하고 안전하게 작성하기 위한 기능을 제공한다. 레코드 클래스를 사용하면 기존 POJO 클래스를 작성할 때 필요한 보일러플레이트 코드를 줄이는 효과를 얻을 수 있다.

레코드의 특징

final 클래스로 상속이 불가능하다.
인터페이스 구현이 가능하다.
모든 필드는 불변(private final)으로 값을 변경할 수 없다.
getter 메서드를 기본으로 제공한다.
모든 필드를 포함한 생성자를 기본으로 제공한다.
toString(), equals(), hashCode() 메서드를 기본으로 제공한다.

클래스와 레코드 비교

아래 두 예제는 동일한 역할을 한다.

클래스

public final class Person {
    private final String name;
    private final int age;
    private final LocalDate birthDate;
    private final String email;

    public Person(String name, int age, LocalDate birthDate, String email) {
        this.name = name;
        this.age = age;
        this.birthDate = birthDate;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public LocalDate getBirthDate() {
        return birthDate;
    }

    public String getEmail() {
        return email;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person that = (Person) o;
        return getAge() == that.getAge() &&
                Objects.equals(getName(), that.getName()) &&
                Objects.equals(getBirthDate(), that.getBirthDate()) &&
                Objects.equals(getEmail(), that.getEmail());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge(), getBirthDate(), getEmail());
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthDate=" + birthDate +
                ", email='" + email + '\'' +
                '}';
    }
}

기존 클래스에서는 모든 필드를 명시적으로 선언하고, 생성자에서 초기화해야 하며, 모든 필드에 대해 getter 메서드를 작성해야 한다. 또한, 기존 클래스에서는 equals와 hashCode, toString 메서드를 직접 구현해야 한다.

레코드

public record Person(
        String name,
        int age,
        LocalDate birthDate,
        String email
) {
}

레코드 클래스에서는 필드를 간단하게 선언하는 것으로 생성자와 getter, equals, hashCode, toString 메서드를 모두 자동으로 생성된다.

기본 사용

레코드 클래스는 기존 클래스와 동일하게 커스텀 메서드, 생성자 검증, 정적 변수 및 메서드 등을 작성하여 활용할 수 있다.

생성자 검증

public record Person(
        String name,
        int age
) {
    public Person {
        if (age < 0) {
            throw new IllegalArgumentException("나이는 0보다 작을 수 없습니다.");
        }
    }

    public static void main(String[] args) {
        Person person = new Person("홍길동", -1); // 에러 발생
        System.out.println("person = " + person);
    }
}

정적 변수와 정적 메서드

public record Person(
        String name,
        int age
) {
    public static final int MIN_AGE = 0;
    public static final String DEFAULT_NAME = "홍길동";

    public static int getMinAge() {
        return MIN_AGE;
    }

    public static String getDefaultName() {
        return DEFAULT_NAME;
    }

    public static void main(String[] args) {
        System.out.println(Person.getMinAge()); // 0
        System.out.println(Person.getDefaultName()); // 홍길동
    }
}

커스텀 메서드

public record Person(
        String name,
        int age
) {
    public static final int ADULT_AGE = 18;

    public boolean isAdult() {
        return this.age >= ADULT_AGE;
    }

    public static void main(String[] args) {
        Person person = new Person("홍길동", 18);
        System.out.println(person.isAdult()); // true
    }
}

기존 클래스의 보일러플레이트 코드를 줄여 더욱 간결하고 가독성 높은 코드를 작성할 수 있다.
불변 객체로 유지보수성이 향상될 수 있다.

활용

레코드 클래스는 DTO 클래스로 활용하기 좋다. 레코드 클래스에 스프링 프레임워크에서 제공하는 Bean Validation을 사용하여 제약조건을 쉽게 검증할 수 있다.

의존성 추가

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

Bean Validation 사용

public record Person(
        @NotBlank
        @Size(min = 2, max = 20, message = "이름은 최소2자 최대20자입니다.")
        String name,

        @NotBlank
        @Max(value = 150, message = "나이는 150세 이하여야 합니다.")
        @Min(value = 0, message = "나이는 0세 이상이어야 합니다.")
        int age,

        @NotNull
        LocalDate birthDate,
        
        @Email(message = "이메일 형식이어야 합니다.")
        String email
) {
}

컨트롤러 작성

@RestController
@Validated
public class PersonController {

    @PostMapping("/person")
    public ResponseEntity<PersonResponse> createPerson(@Valid @RequestBody PersonRequest personRequest) {
        return ResponseEntity.status(HttpStatus.CREATED)
                .body(new PersonResponse("홍길동", 20, LocalDate.now(), "gildong@example.com"));
    }
}

코틀린 Data Class와 자바 레코드 비교

자바의 Record는 코틀린 data class와 같이 데이터 중심의 클래스를 정의하는 데 중점을 둔다. 또한, 공통적으로 간결한 문법과 자동으로 생성되는 메서드를 통해 보일러플레이트를 줄이는 역할을 한다. 하지만, 이 둘에는 약간의 차이점이 존재한다.

자바 레코드

public record Person(
        String name,
        int age,
        LocalDate birthDate,
        String email
) {
    public static final int MINIMUM_AGE = 0;

    public Person {
        if (age < 0) {
            throw new IllegalArgumentException("나이는 0보다 작을 수 없습니다.");
        }
    }

    public static int getMinimumAge() {
        return MINIMUM_AGE;
    }

    public boolean isAdult() {
        return age >= 18;
    }
}

코틀린 데이터 클래스

data class Person(
    var name: String,
    var age: Int,
    val birthDate: LocalDate,
    val email: String
) {
    init {
        require(age >= 0) { "나이는 0보다 작을 수 없습니다." }
    }

    companion object {
        const val MINIMUM_AGE = 0

        fun getMinimumAge() = MINIMUM_AGE
    }

    fun isAdult() = age >= 18
}

차이점

자바의 레코드 필드는 기본적으로 final이므로 불변성을 보장하지만, 코틀린의 데이터 클래스는 val 키워드를 통해 불변성을 보장한다. var 키워드를 사용하면 가변 필드가 된다.
레코드와 데이터 클래스 둘 다 toString(), equals(), hashCode()를 기본으로 자동 생성하지만, 코틀린의 데이터 클래스는 추가적으로 copy(), componentN() 메서드를 생성해 준다.
자바 레코드는 정적 메서드와 필드를 직접 추가할 수 있지만, 코틀린 데이터 클래스는 companion object를 통해 정적 멤버를 정의할 수 있다.

[Algorithm] 배열의 구간 합 알고리즘 (Prefix Sum) - Java

잇트루 — Sun, 2 Jun 2024 23:44:54 +0900

구간 합

구간 합(Prefix Sum)은 주어진 배열의 특정 구간, 즉 배열의 연속된 요소들의 합을 의미하다. 예를 들어, 배열이 [1, 2, 3, 4, 5]라 할 때 2번째 요소부터 4번째 요수까지의 구간 합은 2 + 3 + 4로 9가 된다.

자바에서 구간 합을 구하기 위해 일반적으로 다음과 같이 반복문을 사용한다.

int[] arr = {1, 2, 3, 4, 5};
int sum = 0;
for (int i = 1; i <= 3; i++) {
    sum += arr[i];
}
System.out.println("sum: " + sum); // 9

다음과 같이 2차원 배열의 경우에는 2중 반복문을 통해 구한다.

1 2 3
4 5 6
7 8 9

int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int sum = 0;
for (int i = 0; i <= 1; i++) {
    for (int j = 0; j <= 1; j++) {
        sum += matrix[i][j];
    }
}
System.out.println("sum: " + sum); // 12

구간 합 알고리즘

구간 합 알고리즘은 주어진 배열의 특정 구간의 합을 빠르게 계산하는 알고리즘이다. 전체 배열의 누적 합을 미리 계산하여 배열을 만든 뒤, 임의의 구간 합을 O(1)의 시간 복잡도로 빠르게 계산하는 데 사용한다.

누적합과 구간합을 구하는 방법은 다음과 같다.

누적합

sum[i] = arr[0] + arr[1] + ... + arr[i]

누적합의 i번째 요소가 배열의 0번째 요소부터 i번째 합인 것을 활용하여 다음과 같이 쉽게 구할 수 있다.

int[] arr = {1, 2, 3, 4, 5};
int[] sum = new int[arr.length + 1];

for (int i = 1; i <= arr.length; i++) {
    sum[i] = sum[i - 1] + arr[i - 1];
}

System.out.println("sum = " + Arrays.toString(sum)); // [0, 1, 3, 6, 10, 15]

구간합

배열의 i부터 j까지의 구간합은 j번째 누적합에서 i 직전의 누적합을 빼면 된다.

s(i, j) = sum[j] - sum[i - 1]

int[] arr = {1, 2, 3, 4, 5};
int[] sum = new int[arr.length + 1];

for (int i = 1; i <= arr.length; i++) {
    sum[i] = sum[i - 1] + arr[i - 1];
}

int i = 2; // 2번쨰 부터
int j = 5; // 5번째 까지의 합
int result = sum[j] - sum[i - 1];

System.out.println("result = " + result); // 14

2차원 배열의 구간합

2차원 배열에서의 누적합과 구간합을 구하는 방법은 1차원 배열의 구간합 알고리즘을 응용하여 구할 수 있다.

다음과 같이 1부터 9까지 3x3 배열의 크기인 2차원 배열이 존재할 때 누적합과 구간합은 다음과 같이 구할 수 있다.

1 2 3
4 5 6
7 8 9

누적합

2차원 배열의 누적합은 각 위치를 기준으로 (0, 0)부터 현재 위치까지의 모든 요소의 합이다. 조금 복잡할 수 있으나, i, j 번째의 누적합의 공식은 다음과 같다.

sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + arr[i - 1][j - 1];

위 공식에서 sum[i][j]는 배열 arr의 0, 0부터 (i - 1, j - 1)까지의 모든 요소의 합을 나타낸다.
sum[i][j - 1]은 왼쪽 요소까지의 누적 합이고, sum[i - 1][j]는 바로 위 요소까지의 누적합이다.
이를 더하면 왼쪽 위 요소(sum[i - 1][j - 1])까지의 누적합이 2번 포함되므로 sum[i - 1][j - 1]을 한 번 빼준다.
이후 현재 위치의 값을 더하면 현재 위치까지의 누적합을 구할 수 있다.

위 공식을 토대로 다음과 같이 코드를 작성할 수 있게 된다.

int[][] arr = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
};
int[][] sum = new int[arr.length + 1][arr[0].length + 1];

for (int i = 1; i <= arr.length; i++) {
    for (int j = 1; j <= arr[0].length; j++) {
        sum[i][j] = sum[i][j-1] + sum[i-1][j] - sum[i-1][j-1] + arr[i-1][j-1];
    }
}

코드의 결과는 다음과 같다.

구간합

위에서 구한 2차원 배열의 누적합을 토대로 구간합을 구하는 공식은 다음과 같다.

result = sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1]

1부터 9까지 3x3 크기의 2차원 배열을 기준으로 보면, 2, 2 위치의 누적합인 12(1 + 2 + 4 + 5)를 구한다고 가정해 보자.

(1, 1)부터 (1, 2)까지의 누적합 3과 (1, 1)부터 (2, 1)까지의 누적합 5를 더하면 8이 된다.
이는 (1, 1)이 2번 더해진 결과이기 때문에 (1, 1)을 한 번 뺀다.
마지막으로 (2, 2)에 해당하는 5를 더한다.

앞에서 구한 누적합을 통해 (1, 1)부터 (3, 3)까지의 구간합을 구한다면 다음과 같이 구할 수 있다.

(1, 1)부터 (3, 3)까지의 누적합에서 바로 위까지의 누적합과 바로 왼쪽의 누적합을 뺀다.
이는 왼쪽 위 위치까지의 누적 합이 2번 빠지게 되므로 한 번 더한다.

int x1 = 1;
int y1 = 1;
int x2 = 3;
int y2 = 3;
int result = sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1]; // 45

[Spring] 스프링 부트 3.2 RestClient 살펴보기

잇트루 — Thu, 30 May 2024 00:05:37 +0900

RestClient

RestClient는 Spring framework 6.1(Spring boot 3.2)에 새로 추가된 동기식 HTTP Client로 Spring 애플리케이션에서 REST API 호출을 위한 HTTP 요청을 보낼 수 있다.

RestClient의 등장으로 같은 동기식 HTTP Client인 RestTemplate을 대체하여 사용할 수 있으며, fluent API를 제공하여 현대적인 방식으로 코드를 작성할 수 있게 되었다.

RestClient의 등장 이유

기존의 RestTemplate는 2009년 Spring 3.0에 추가된 상당히 오래된 동기식 HTTP Client이다. 그로 인해 몇 가지 단점들이 존재한다.

RestTemplate는 수많은 메서드가 오버로딩되어 제공하기 때문에 기능을 사용하는데 혼란을 줄 수 있다.
고전적인 방식인 Template method 패턴을 활용한 클래스로 현대적인 방식과는 거리가 멀다.
Non-Blocking 환경에서는 적절하지 않다.

이후 등장한 WebClient는 동기식 처리와 비동기식 처리 모두 지원하며, fluent API를 제공한다. 하지만 Spring MVC 환경에서 사용하기 위해 WebFlux를 추가로 의존해야 한다는 단점이 있다.

따라서, Spring MVC 환경에서 현대적인 방식으로 HTTP Client 사용하기 위해 등장했다.

RestClienet 사용하기

RestClient 생성

RestTemplate와는 달리 static 메서드를 통해 new 생성자를 사용하지 않고 객체를 생성할 수 있다. create() 메서드를 통해 생성하거나 builder를 통해 여러 default 설정을 할 수 있다.

// create()
RestClient restClient1 = RestClient.create();

// builder()
RestClient restClient2 = RestClient.builder()
        .baseUrl("http://localhost:8080")
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
        .build();

GET 요청

http://localhost:8080/{key1}/{key2}와 같이 path variable 경로에 요청을 보낸다고 가정하면 다음과 같이 요청을 보낼 수 있다.

String key1 = "key1";
Long key2 = 1L;
ResponseEntity<Map> response = restClient.get()
        .uri("http://localhost:8080/{key1}/{key2}", key1, key2)
        .retrieve()
        .toEntity(Map.class);

query parameter에 값을 담아 요청할 경우에는 uriBuilder를 사용하여 쉽게 작성할 수 있다.

String name = "홍길동";
int age = 20;
ResponseEntity<Map> response = restClient.get()
        .uri(uriBuilder -> uriBuilder.path("/example")
                .queryParam("name", str)
                .queryParam("age", age)
                .build())
        .retrieve()
        .toEntity(Map.class);

path variable과 query parameter를 동시에 사용하면 다음과 같이 작성하여 요청할 수 있다.

Long id = 1L;
String name = "홍길동";
int age = 20;
ResponseEntity<Map> response = restClient.get()
        .uri(uriBuilder -> uriBuilder.path("/example/{id}")
                .queryParam("name", str)
                .queryParam("age", age)
                .build(id))
        .retrieve()
        .toEntity(Map.class);

ResponseEntity 형태로 받고 싶지 않을 경우에는 body를 통해 객체 형태로 응답받을 수 있다.

Long id = 1L;
String name = "홍길동";
int age = 20;
Map response = restClient.get()
        .uri(uriBuilder -> uriBuilder.path("/example/{id}")
                .queryParam("name", str)
                .queryParam("age", age)
                .build(id))
        .retrieve()
        .body(Map.class);

POST 요청

이름과 나이를 가진 객체를 body에 담아 post 요청을 한다고 가정하면 다음과 같이 작성할 수 있다.

Person person = new Person("홍길동", 20);
Map response = restClient.post()
        .uri("http://localhost:8080/example")
        .contentType(MediaType.APPLICATION_JSON)
        .body(person)
        .retrieve()
        .body(Map.class);

post 요청도 마찬가지로 ResponseEntity 형태로 응답받기 위해서는 다음과 같이 작성할 수 있다.

Person person = new Person("홍길동", 20);
ResponseEntity<Map> response = restClient.post()
        .uri("http://localhost:8080/example")
        .contentType(MediaType.APPLICATION_JSON)
        .body(person)
        .retrieve()
        .toEntity(Map.class);

System.out.println("body = " + response.getBody());
System.out.println("StatusCode = " + response.getStatusCode());
System.out.println("Headers = " + response.getHeaders());

PUT

PUT 요청은 다음과 같이 작성할 수 있다.

Long id = 1L;
Person person = new Person("홍길동", 20);
Map response = restClient.put()
        .uri("http://localhost:8080/example/{id}", id)
        .contentType(MediaType.APPLICATION_JSON)
        .body(person)
        .retrieve()
        .body(Map.class);

DELETE

DELETE 요청 다음과 같이 작성할 수 있다.

Long id = 1L;
ResponseEntity<Void> bodilessEntity = restClient.delete()
        .uri("http://localhost:8080/example/{id}", id)
        .retrieve()
        .toBodilessEntity();

toBodilessEntity()는 responseBody는 없으나, Http StatusCode와 Headers를 가진 ResponseEntity다.

예외처리

RestClient의 예외처리 방법은 크게 2가지다.

builder()를 통해 RestClient를 생성할 때 defaultStatusHandler()를 통한 예외처리
요청 후 onStatus()를 통해 응답의 상태코드에 따른 예외처리

RestClient restClient = RestClient.builder()
        .baseUrl("http://localhost:8080")
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
        .defaultStatusHandler(HttpStatusCode::is4xxClientError, (req, res) -> {
            throw new RestClientException("Client error: " + res.getStatusCode());
        })
        .build();

ResponseEntity<Map> response = restClient.get()
        .uri(uriBuilder -> uriBuilder.path("/example/{id}")
                .queryParam("str", str)
                .build(id))
        .retrieve()
        .onStatus(HttpStatusCode::is5xxServerError, (req, res) -> {
            throw new RestClientException("Server error: " + res.getStatusCode());
        })
        .toEntity(Map.class);

[Algorithm] 10진수를 n진수로, n진수를 10진수로 변환하기 (진법 변환) - Java

잇트루 — Tue, 16 Jan 2024 01:30:51 +0900

자바의 진법 변환

진법 변환은 알고리즘 문제에서 자주 활용된다. 자바에서는 이를 쉽게 활용할 수 있도록 함수를 제공하고 있다.

자바에서 제공하는 함수를 통해 진법을 변환하는 방법과 직접 구현하여 변환하는 방법을 알아보고자 한다.

10진수를 N진수로 변환하기

자바 내장 함수 사용

10진수의 숫자를 N진수로 변환하기 위해 java.lang 패키지에서 Integer와 Long 클래스의 toString() 메서드를 제공한다.
첫 번째 인자에는 변환할 수, 두 번째 인자에는 변환할 진법을 넣어 쉽게 변환할 수 있다.
이 외에도 java.math 패키지의 BigInteger 클래스의 toString() 메서드를 통해 진법 변환을 할 수도 있다.

public class Main {
    public static void main(String[] args) {
        int decimal = 1234;

        String binary = Integer.toString(decimal, 2);
        String base4 = Integer.toString(decimal, 4);
        String octal = Integer.toString(decimal, 8);
        String hexa = Integer.toString(decimal, 16);
        String base32 = Integer.toString(decimal, 32);

        System.out.println(binary);
        System.out.println(base4);
        System.out.println(octal);
        System.out.println(hexa);
        System.out.println(base32);
    }
}

// 출력
10011010010
103102
2322
4d2
16i

직접 구현

직접 구현하는 방법에는 다음과 같이 수행할 수 있다.

10진수 숫자를 변환할 진법으로 나눈 나머지를 구한다.
나머지를 해당 진수의 자릿수로 사용한다.
10진수 이상인 경우 나머지가 10 이상인 경우 'a'부터 대응되는 문자로 변환한 후 지수의 자릿수로 사용한다.
위 과정을 10진수 숫자가 0이 될 때까지 반복한다.
완성된 수를 역순으로 뒤집는다.

public class Main {
    public static void main(String[] args) {
        int decimal = 1234;

        String binary = convertDecimalToBase(decimal, 2);
        String base4 = convertDecimalToBase(decimal, 4);
        String octal = convertDecimalToBase(decimal, 8);
        String hexa = convertDecimalToBase(decimal, 16);
        String base32 = convertDecimalToBase(decimal, 32);

        System.out.println(binary);
        System.out.println(base4);
        System.out.println(octal);
        System.out.println(hexa);
        System.out.println(base32);
    }

    private static String convertDecimalToBase(int decimal, int base) {
        StringBuilder sb = new StringBuilder();

        // 10진수 정수가 0이 될 때까지 반복
        while (decimal > 0) {
            // 10진수 정수를 base로 나눈 나머지(n진법으로 변환된 수)
            int temp = decimal % base;

            if (temp >= 10) { // 나머지 값이 10 이상이면, 'a'부터 시작하는 문자로 변환
                sb.append((char) (temp - 10 + 'a'));
            } else { // 나머지 값이 10 미만이면 그대로 사용
                sb.append(temp);
            }

            // 다음 숫자를 구하기 위한 나눗셈
            decimal = decimal / base;
        }

        // 문자열 뒤집기
        return sb.reverse().toString();
    }
}

// 출력
10011010010
103102
2322
4d2
16i

N진수를 10진수로 변환하기

자바 내장 함수 사용

N진수의 숫자를 10진수로 변환하는 방법은 java.lang 패키지에서 Integer와 Long 클래스의 parseInt() 메서드를 사용한다.
첫 번째 인자에는 변환할 문자열, 두 번째 인자에는 변환할 문자열의 진법을 넣어 10진수로 변환할 수 있다.
이 외에도 java.math 패키지의 BigInteger 클래스의 생성자를 통해 진법 변환을 할 수도 있다.

public class Main {
    public static void main(String[] args) {
        int binaryToDecimal = Integer.parseInt("1010110101", 2);
        int base4ToDecimal = Integer.parseInt("2101201101", 4);
        int octalToDecimal = Integer.parseInt("54210", 6);
        int hexaToDecimal = Integer.parseInt("12132", 8);
        int base32ToDecimal = Integer.parseInt("abcde", 16);

        System.out.println(binaryToDecimal);
        System.out.println(base4ToDecimal);
        System.out.println(octalToDecimal);
        System.out.println(hexaToDecimal);
        System.out.println(base32ToDecimal);
    }
}

직접 구현

직접 구현하는 방법에는 다음과 같이 수행할 수 있다.

거듭제곱을 위한 수와 결과를 담을 변수를 준비한다.
변환할 문자열의 각 자릿수를 역순으로 순회한다
각 자릿수가 '0'과 '9' 사이에 포함되면 해당 숫자로 변환하고, 그보다 크면 대응하는 알파벳으로 변환한다.
거듭제곱 수와 변환한 수를 곱하여 결과에 더한다.
거듭제곱 수를 문자열의 진법과 곱하여 업데이트한다.

public class Main {
    public static void main(String[] args) {
        int binaryToDecimal = convertBaseToDecimal("1010110101", 2);
        int base4ToDecimal = convertBaseToDecimal("2101201101", 4);
        int octalToDecimal = convertBaseToDecimal("54210", 6);
        int hexaToDecimal = convertBaseToDecimal("12132", 8);
        int base32ToDecimal = convertBaseToDecimal("abcde", 16);

        System.out.println(binaryToDecimal);
        System.out.println(base4ToDecimal);
        System.out.println(octalToDecimal);
        System.out.println(hexaToDecimal);
        System.out.println(base32ToDecimal);
    }

    private static int convertBaseToDecimal(String num, int base) {
        int decimal = 0;
        int power = 1; // 거듭제곱을 위한 변수

        // 문자열을 역순으로 순회
        for (int i = num.length() - 1; i >= 0; i--) {
            int digit; // 현재 자릿수의 숫자
            char curr = num.charAt(i); // 현재 자리의 문자

            if (curr >= '0' && curr <= '9') { // 현재 문자가 숫자라면 해당 숫자로 변환
                digit = curr - '0';
            } else { // 알파벳 문자(A ~ F)이면 10 ~ 15의 값으로 변환
                digit = curr + 10 - 'A';
            }

            // 현재 자릿수의 숫자 거듭제곱수를 곱하여 10진수에 더함
            decimal += digit * power;
            // 거듭제곱수를 업데이트
            power *= base;
        }

        return decimal;
    }
}

[Algorithm] 파스칼의 삼각형 알고리즘 구현하기 (Pascal's triangle) - Java

잇트루 — Wed, 3 Jan 2024 23:25:12 +0900

파스칼 삼각형

파스칼의 삼각형은 블레즈 파스칼에 의해 제안된 삼각형으로 구성된 배열이다.

파스칼의 삼각형은 다음과 같은 규칙이 있다.

각 행의 첫 번째와 마지막의 숫자는 1이다.
각 행의 중간에 위치한 숫자는 이전 행의 왼쪽 위치에 있는 숫자와 바로 위에 있는 숫자의 합이다.

구현

위 두 규칙을 통해 파스칼의 삼각형을 2차원 배열로 구현해 보자.

public class Main {
    public static void main(String[] args) {
        int n = 7;

        // 파스칼의 삼각형 만들기
        int[][] pascal = new int[n][];
        for (int i = 0; i < n; i++) {
            pascal[i] = new int[i + 1];

            // 규칙 1. 각 행의 첫 번쨰와 마지막 숫자는 1
            pascal[i][0] = 1;
            pascal[i][i] = 1;

            // 규칙 2. 중간에 위치한 숫자는 이전 행의 왼쪽에 있는 숫자와 바로 위에 있는 숫자의 합
            for (int j = 1; j < i; j++) {
                pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
            }
        }

        // 파스칼의 삼각형 출력
        for (int i = 0; i < pascal.length; i++) {
            for (int j = 0; j < pascal[i].length; j++) {
                System.out.print(pascal[i][j] + " ");
            }
            System.out.println();
        }
    }
}

// 출력
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1

[Java] 병합 정렬 (Merge Sort) - 정렬 알고리즘 (Sorting Algorithm)

잇트루 — Mon, 1 Jan 2024 01:13:14 +0900

병합 정렬 (Merge Sort)

병합 정렬(Merge Sort)은 효율적이고 안정적인 정렬 알고리즘 중 하나로, 분할 정복(Divide and Conquer) 알고리즘을 따른다. 병합 정렬의 기본 개념은 다음과 같다.

분할(Divide) : 입력받은 배열을 절반으로 분할하고, 길이가 1이 될 때까지 분할을 반복한다.
정복(Conquer) : 각 분할된 배열에 대해 재귀적으로 정렬을 수행한다.
병합(Merge) : 분할한 배열을 병합하면서 정렬한다. 두 개의 정렬된 배열을 하나의 정렬된 배열로 합치는 과정으로 병합 과정에서 실제 정렬이 이루어진다.

병합 정렬의 시간 복잡도는 O(n log n)으로 길이가 긴 배열을 안정적으로 정렬할 때 적합한 알고리즘이다.

병합 정렬의 장단점

장점

O(n log n)의 시간 복잡도를 가지고 있어 다른 정렬 알고리즘에 비해 효율적이다.
동일하 값의 원소가 입력에 따라 순서를 보장하는 안정 정렬(Stable Sort) 알고리즘이다.
최선과 최악의 경우에도 항상 동일한 시간 복잡도를 가진다.

단점

원본 배열을 분할하여 새로운 배열을 추가적으로 만들기 때문에 추가적인 메모리가 필요하다.
다른 정렬 알고리즘에 비해 구현하기가 복잡하다.
배열의 크기가 작은 경우 퀵 정렬과 같은 알고리즘이 더 빠르다.

병합 정렬은 여러 상황에 따라 적절하게 사용되어야 하는데, 제한된 메모리를 가진 환경에서는 다소 적합하지 않을 수 있다.

병합 정렬의 과정

구현

public class MergeSort {
    public void sort(int[] arr, int left, int right) {
        if (left == right) {
            return;
        }

        // 중간 인덱스
        int mid = (left + right) / 2;

        // 왼쪽 정렬
        sort(arr, left, mid);
        // 오른쪽 정렬
        sort(arr, mid + 1, right);

        // 배열 합치기
        merge(arr, left, mid, right);
    }

    public void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1; // 왼쪽 배열의 길이
        int n2 = right - mid; // 오른쪽 배열의 길이

        // 왼쪽 배열 오른쪽 배열
        int[] leftTemp = new int[n1];
        int[] rightTemp = new int[n2];

        // 왼쪽 배열 담기
        for (int i = 0; i < n1; i++) {
            leftTemp[i] = arr[left + i];
        }
        // 오른쪽 배열 담기
        for (int i = 0; i < n2; i++) {
            rightTemp[i] = arr[mid + 1 + i];
        }

        // 왼쪽 배열과 오른쪽 배열의 인덱스
        int i = 0, j = 0;
        // 원본 배열 arr의 시작 인덱스
        int k = left;

        // 원본 배열에 정렬
        while (i < n1 && j < n2) {
            if (leftTemp[i] <= rightTemp[j]) {
                arr[k] = leftTemp[i];
                i++;
            } else {
                arr[k] = rightTemp[j];
                j++;
            }
            k++;
        }

        // 남아 있는 요소 담기
        while (i < n1) {
            arr[k] = leftTemp[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = rightTemp[j];
            j++;
            k++;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[] array = {38, 27, 43, 3, 9, 82, 10};
        MergeSort mergeSort = new MergeSort();
        
        mergeSort.sort(array, 0, array.length - 1);

        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

// 출력
3 9 10 27 38 43 82

[Java] 싱글톤 패턴(Singleton Pattern) - 개념 및 예제

잇트루 — Sun, 3 Dec 2023 06:20:36 +0900

싱글톤 패턴(Singleton Pattern)

싱글톤 패턴은 객체 지향 프로그래밍에서 특정 클래스가 단 하나만의 인스턴스를 생성하여 사용하기 위한 패턴이다. 생성자를 여러 번 호출하더라도 인스턴스가 하나만 존재하도록 보장하여 애플리케이션에서 동일한 객체 인스턴스에 접근할 수 있도록 한다.

싱글톤 패턴을 사용하는 이유

커넥션 풀, 스레드 풀, 디바이스 설정 객체 등과 같은 경우 인스턴스를 여러 개 만들게 되면 불필요한 자원을 사용하게 되고, 프로그램이 예상치 못한 결과를 낳을 수 있다. 따라서 객체를 필요할 때마다 생성하는 것이 아닌 단 한 번만 생성하여 전역에서 이를 공유하고 사용할 수 있게 하기 위해 싱글톤 패턴을 사용한다.

싱글톤 패턴의 장단점

장점

유일한 인스턴스 : 싱글톤 패턴이 적용된 클래스의 인스턴스는 애플리케이션 전역에서 단 하나만 존재하도록 보장한다. 이는 객체의 일관된 상태를 유지하고 전역에서 접근 가능하도록 한다.
메모리 절약 : 인스턴스가 단 하나뿐이므로 메모리를 절약할 수 있다. 생성자를 여러 번 호출하더라도 새로운 인스턴스를 생성하지 않아 메모리 점유 및 해제에 대한 오버헤드를 줄인다.
지연 초기화 : 인스턴스가 실제로 사용되는 시점에 생성하여 초기 비용을 줄일 수 있다.

단점

결합도 증가 : 싱글톤 패턴은 전역에서 접근을 허용하기 때문에 해당 인스턴스에 의존하는 경우 결합도가 증가할 수 있다.
테스트 복잡성 : 싱글톤 패턴은 단 하나의 인스턴스만을 생성하고 자원을 공유하기 때문에 싱글톤 클래스를 의존하는 클래스는 결합도 증가로 인해 테스트가 어려울 수 있다.
상태 관리의 어려움 : 만약, 싱글톤 클래스가 상태를 가지고 있는 경우 전역에서 사용되어 변경될 수 있다. 이로 인해 예상치 못한 동작이 발생할 수 있다.
전역에서 접근 가능 : 애플리케이션 내 어디서든 접근이 가능한 경우, 무분별한 사용을 막기 힘들다. 이로 인해 변경에 대한 복잡성이 증가할 수 있다.

싱글톤 패턴을 사용할 때에는 장단점을 고려하여 상황에 맞게 적절히 사용해야 한다. 단 하나의 인스턴스를 생성하여 메모리 효율성을 높일 수 있지만, 그로 인해 따를 수 있는 문제점들이 있기 때문이다.

싱글톤 패턴의 기본 구현

싱글톤 패턴을 적용할 경우 두 개 이상의 객체는 존재할 수 없다. 이를 구현하기 위해서는 객체 생성을 위한 new 생성자에 제약을 걸어야 하고, 만들어진 단일 객체를 반환할 수 있는 메서드가 필요하다. 따라서 다음 세 가지 조건이 반드시 충족되어야 한다.

new 키워드를 사용할 수 없도록 생성자에 private 접근 제어자를 지정해야 한다.
유일한 단일 객체를 반환할 수 있는 정적 메서드가 필요하다.
유일한 단일 객체를 참조할 정적 참조 변수가 필요하다.

아래 이미지는 싱글톤 패턴의 구조다.

클라이언트는 getInstance() 메서드를 통해 싱글톤 인스턴스를 얻을 수 있다.
getInstance() 메서드 내부에는 instance가 null이면 생성하고, null이 아니면 instance를 반환한다.
이로써 단 하나만의 객체를 생성하여 사용할 수 있도록 한다.

구현 코드

public class Singleton {
    // 정적 참조 변수(싱글톤 객체를 담을 변수)
    private static Singleton singletonObject;

    // private 생성자
    private Singleton() {
    }
    
    // getInstance()
    public static Singleton getInstance() {
        if (singletonObject == null) {
            singletonObject = new Singleton();
        }
        
        return singletonObject;
    }
}

singletonObject는 단일 객체를 저장하기 위한 정적 참조 변수다.
외부에서는 해당 객체를 생성할 수 없도록 생성자를 private로 지정한다.
getInstance() 메서드를 통해 인스턴스를 얻을 수 있다.
getInstance()를 최초로 실행할 때에만 초기화한다. (지연 초기화)

싱글톤 패턴 사용

public class Client {
    public static void main(String[] args) {
        // private 생성자(에러 발생)
        // Singleton singleton = new Singleton();

        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        Singleton instance3 = Singleton.getInstance();

        System.out.println(instance1);
        System.out.println(instance2);
        System.out.println(instance3);

        System.out.println(instance1 == instance2);
        System.out.println(instance1 == instance3);
    }
}

// 출력
com.book.objects.designpattern.singleton.Singleton@24d46ca6
com.book.objects.designpattern.singleton.Singleton@24d46ca6
com.book.objects.designpattern.singleton.Singleton@24d46ca6
true
true

싱글톤 객체를 getInstance()를 통해 여러 변수에서 호출하더라도 같은 인스턴스를 참조한다.

싱글톤 패턴의 주의사항

싱글톤 패턴은 단일 객체이기 때문에 공유 객체로 사용된다. 따라서 상태 값을 가지지 않는 것이 좋다. 단일 객체가 상태 값을 가지는 경우 특정 참조 변수가 상태를 변경했을 때 다른 참조 변수에도 영향을 미치기 때문이다. 상태 값이 아닌 읽기 전용 속성을 가지거나 또 다른 단일 객체를 참조하는 속성을 가지는 경우에는 문제가 되지 않는다.

위 코드의 경우 멀티 스레드 환경에서 Thread Safe하지 않는 문제점이 있다. Thread Safe는 여러 스레드가 동시에 접근하는 경우 해당 애플리케이션에 어떠한 문제도 발생하지 않는 것을 의미한다. 즉, 싱글톤 패턴은 여러 스레드가 동시에 접근하는 경우 문제가 발생한다는 것을 의미한다.

두 스레드 A와 B가 존재한다고 가정할 때, 스레드 A가 getInstance() 메서드의 if 검사에 통과하여 싱글톤 객체를 생성하려고 할 때, 스레드 B도 if 검사를 통과할 수 있는 문제가 있다.

public static Singleton getInstance() {
    if (singletonObject == null) {  // (2) 스레드 B 진입 가능
        singletonObject = new Singleton();  // (1) 스레드 A 진입 (객체 생성 X)
    }
    
    return singletonObject;
}

실행 테스트

public class Client {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            Singleton singleton = Singleton.getInstance();
            System.out.println(singleton);
        });

        Thread thread2 = new Thread(() -> {
            Singleton singleton = Singleton.getInstance();
            System.out.println(singleton);
        });

        Thread thread3 = new Thread(() -> {
            Singleton singleton = Singleton.getInstance();
            System.out.println(singleton);
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

com.book.objects.designpattern.singleton.Singleton@2e58d931
com.book.objects.designpattern.singleton.Singleton@12985f41
com.book.objects.designpattern.singleton.Singleton@12985f41

thread1과 thread2가 동시에 실행되면서 싱글톤 객체가 2번 초기화되어 서로 다른 주소를 참조하고 있다.

Thread Safe한 싱글톤 패턴 구현

Thread Safe한 싱글톤 패턴을 구현하는 방법에는 여러 가지가 있다. 가장 쉬운 방법부터 시작해서 싱글톤 패턴 구현의 권장하는 방법까지 차례대로 알아보자.

sychronized 키워드 사용

가장 단순한 방법으로 sychronized 키워드를 통해 getInstance() 메서드에 하나의 스레드만 접근 가능하도록 하는 방법이다.

public class Singleton {
    private static Singleton singletonObject;

    private Singleton() {
    }
    
    public static synchronized Singleton getInstance() {
        if (singletonObject == null) {
            singletonObject = new Singleton();
        }
        
        return singletonObject;
    }
}

단, 여러 스레드가 getInstance() 메서드를 동시에 접근하려 할 때 동기화 작업(Lock) 때문에 성능 저하가 발생할 수 있다.

이른 초기화(eager initialization) 사용

만약 싱글톤 객체를 생성하는 비용이 크지 않은 경우 이른 초기화 방법을 적용할 수 있다.

public class Singleton {
    private static final Singleton SINGLETON_OBJECT = new Singleton();

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        return SINGLETON_OBJECT;
    }
}

변수 선언과 동시에 초기화하여 Thread Safe한 싱글톤 패턴을 구현할 수 있다.
부가적으로 final 키워드를 붙여 상수로써 사용하면 전역에서 공유하면서 변하지 않는 속성으로 사용한다.
다만, 미리 생성하는 것 자체가 단점으로 작용할 수 있다.
애플리케이션 실행과 동시에 Singleton 객체가 인스턴스화하여 메모리를 점유하게 된다.
만약, 해당 리소스를 사용하지 않는다면 자원 낭비일 뿐이다.

Double checked locking

getInstance() 메서드를 사용할 때마다 동기화 작업을 하는 것이 아닌 초기화 할 때만 동기화 작업을 수행하는 방법으로 volatile 키워드와 더블 체크를 통한 synchronized 키워드를 활용하는 방법이다.

public class Singleton {
    // volatile 키워드 사용
    private static volatile Singleton singletonObject;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singletonObject == null) {
            // if 문 진입 시에만 Singleton 클래스에 대한 동기화 작업 수행
            synchronized (Singleton.class) {
                if (singletonObject == null) {
                    singletonObject = new Singleton();
                }
            }
        }

        return singletonObject;
    }
}

이 방법은 최초 getInstance() 메서드를 호출할 때 두 스레드가 if 문에 진입하더라도, 이후에 진행되는 synchronized 키워드로 인해 두 번째 if 문에서는 lock이 걸려 Thread Safe한 싱글톤 패턴의 구현 방법이다.
매번 getInstance() 메서드를 호출할 때마다 동기화 작업이 걸리는 것이 아닌 최초에 초기화할 때에만 동기화 작업을 수행한다.
다만, 이 방법은 volatile 키워드를 사용하기 위해 JVM 버전이 1.5 이상이어야만 한다.
따라서 JVM에 따라 Thread Safe하지 않을 수 있는 문제점이 있다.

Bill Pugh Solution 사용 (권장)

private static inner class를 사용하여 Thread Safe한 싱글톤 패턴을 구현하는 방법이다. JVM의 ClassLoader에 의해서 로드될 때 내부적으로 실행되는 synchronized 키워드를 이용하는 방법이다.

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton SINGLETON_OBJECT = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.SINGLETON_OBJECT;
    }
}

Double checked locking보다 단순하면서 JVM 버전에 제약 없이 지연 초기화와 Thread Safe한 싱글톤 패턴을 구현할 수 있다.
싱글톤 패턴 구현의 권장되는 방법이지만, 이 방법 또한 문제점이 없지 않다.
자바 리플렉션과 직렬화를 통해 싱글톤이 파괴될 수 있다.

Enum 사용 (권장)

Enum 클래스는 생성자를 private으로 갖게 만들고, 상수만 갖는 클래스이기 때문에 싱글톤의 성질을 가진다. 이를 이용하여 다음과 같이 싱글톤 객체를 구현할 수 있다.

public enum Singleton {
    SINGLETON_OBJECT
}

지금까지의 노력이 헛수고처럼 느껴질 수 있게 만드는 코드다.
단순한 코드로 싱글톤 패턴을 구현할 수 있다.
다만, Enum 외의 클래스는 상속 불가능한 문제점이 있다.

정리

싱글톤 패턴은 객체의 인스턴스가 단 하나만을 생성하도록 만드는 디자인 패턴이다.
private 생성자를 가져야 하는 특징이 있다.
단일 객체 참조 변수는 static 이어야 하고 getInstance() 메서드를 참조한다.
변경 여지가 있는 상태 값을 가지지 않는 것이 좋다.
멀티 스레드 환경의 경우 Thread Safe한 구현 방법을 고려해야 한다.
Thread Safe한 싱글톤 패턴은 Bill Pugh Solution 방법과 Enum 사용을 권장하고 있다.

[Kopring] JPA Auditing - 생성/수정 시각 설정 및 테스트

잇트루 — Tue, 21 Nov 2023 00:19:39 +0900

JPA Auditing

프로젝트 작성 시 트래킹을 목적으로 엔티티의 생성 시간과 수정 시간 등을 테이블에 저장하여 관리해야 한다. 이를 쉽게 구현하기 위해 Spring Data JPA는 Auditing이라는 엔티티의 변경 내역을 추적하고 기록하는 기능을 제공한다. 이를 통해 엔티티의 생성일자, 수정일자 등을 쉽게 관리할 수 있다.

다음은 JPA Auditing 기능을 사용하지 않고 수동으로 관리하는 경우의 User 엔티티다.

@Entity
class User(
    ...
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null

    ...

    @Column(nullable = false, updatable = false)
    var createdAt: LocalDateTime = LocalDateTime.MIN
        protected set
    
    @Column(nullable = false)
    var lastModifiedAt: LocalDateTime = LocalDateTime.MIN
        protected set

    @PrePersist
    fun prePersist() {
        createdAt = LocalDateTime.now()
        lastModifiedAt = LocalDateTime.now()
    }

    @PreUpdate
    fun preUpdate() {
        lastModifiedAt = LocalDateTime.now()
    }

    ...

}

생성일자와 수정일자를 엔티티 필드에 작성하여 관리한다.
생성일자는 @PrePersist 어노테이션을 통해 엔티티가 생성될 때 생성시각을 주입한다.
수정일자는 @PrePersist, @PreUpdate 어노테이션을 통해 엔티티가 생성/수정될 때 현재시각을 주입한다.

JPA Auditing 기능을 사용하지 않고도 생성/수정 시각을 관리할 수 있지만, 모든 엔티티에 중복 코드를 작성해야 한다. 이를 해결하기 위해 생성/수정 시각을 자동으로 관리하기 위한 코드를 작성해 보자.

JPA Auditing 적용하기

BaseTimeEntity.kt

다음은 엔티티의 생성/수정 시각을 추적하고 기록하기 위한 추상 클래스다.

@MappedSuperclass
@EntityListeners(AuditingEntityListener::class)
abstract class BaseTimeEntity {

    @CreatedDate
    @Column(nullable = false, updatable = false)
    var createdAt: LocalDateTime = LocalDateTime.MIN
        protected set
    
    @LastModifiedDate
    @Column(nullable = false)
    var modifiedAt: LocalDateTime = LocalDateTime.MIN
        protected set
}

@MappedSuperclass : 엔티티에 공통 매핑 정보를 공유하기 위해 사용하는 어노테이션으로 부모 클래스에 선언하고, 엔티티가 이를 상속하여 필드들을 사용할 수 있도록 한다.
@EntityListeners : 엔티티의 상태 변화 이벤트를 처리하는 리스너를 지정하는 어노테이션이다. AuditingEntityListener를 통해 Auditing 이벤트를 처리한다.
@CreatedDate, @LastModifiedDate : Spring Data JPA에서 제공하는 Auditing 어노테이션으로 각각 엔티티의 생성일자와 수정일자를 추적한다.

MainApplication.kt

JPA Auditing 기능을 활성화하기 위해 메인 애플리케이션에 @EnableJpaAuditing 어노테이션을 추가한다.

@EnableJpaAuditing
@SpringBootApplication
class MainApplication

fun main(args: Array<String>) {
    runApplication<MainApplication>(*args)
}

User.kt

BaseTimeEntity를 상속받는 것만으로도 처음에 작성한 수동으로 관리하는 User 엔티티와 같은 기능을 하게 된다.

@Entity
class User(
    email: String,
    name: String,
    gender: Gender
) : BaseTimeEntity() {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null

    @Column(nullable = false, unique = true, updatable = false)
    var email = email
        protected set

    @Column(nullable = false)
    var name = name
        protected set

    @Column(nullable = false)
    @Enumerated(EnumType.STRING)
    var gender = gender
        protected set
}

Article.kt

이로써 생성일자와 수정일자가 필요한 모든 엔티티에 BaseTimeEntity를 상속하여 적용할 수 있다.

@Entity
class Article(
    title: String,
    content: String
) : BaseTimeEntity() {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null

    @Column
    var title = title
        protected set

    @Column
    var content = content
        protected set
}

테이블 생성 결과

애플리케이션을 실행한 후 생성된 테이블을 살펴보면 user 테이블과 article 테이블에 created_at, last_modified_at이 생성된다.

테스트 코드 작성

이제 엔티티를 생성 또는 수정할 때 정상적으로 createdAt과 lastModifiedAt이 의도한 대로 동작하는지 확인해 보자. 다음 코드는 kotest로 작성된 코드다.

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class BaseTimeEntityTest(
    @Autowired
    private val userRepository: UserRepository
) : FunSpec({

    test("User 생성 시 createdAt과 lastModifiedAt이 생성된 시각으로 저장되어야 한다.") {
        val user = User(
            email = "test@test.com",
            name = "홍길동",
            gender = Gender.MAN
        )

        val savedUser = userRepository.save(user)

        savedUser.createdAt shouldBe savedUser.lastModifiedAt
    }

    test("User를 수정하면 lastModifiedAt이 변경된 시각으로 수정되어야 한다.") {
        val user = User(
            email = "test2@test.com",
            name = "홍길동",
            gender = Gender.MAN
        )
        val savedUser = userRepository.save(user)

        Thread.sleep(1000)
        savedUser.update("임꺽정", Gender.MAN)
        val updatedUser = userRepository.save(savedUser)

        updatedUser.createdAt shouldNotBe updatedUser.lastModifiedAt
    }
})

User 엔티티를 생성하면 createdAt과 lastModifiedAt이 생성된 시점으로 설정되어 서로 같은 값을 가지게 된다.
User 엔티티를 생성한 후 값을 수정하여 다시 저장하면, lastModifiedAt이 수정된 시점으로 변경되어 createdAt과 다른 값을 가지게 된다.