[Kotlin] 코틀린 사용하면서 활용한 코드 정리 + WebFlux + MongoDB

사용되는 코드를 정리해봅니당

그저 잊지 않기 위한 기록용이고...📝 + WebFlux와 MongoDB도 조금 정리

수시로 업데이트 예정 .. 🤓

 

 

Document (MongoDB)

• data class
  • 데이터를 담는 목적의 클래스 선언
  • 데이터 저장, 관리하는 데 필요한 기본적인 메서드 자동 생성 
  • equals(), hashCode(), toString(), componentN(), copy() 등 생성 👉 필요에 따라 직접 구현 가능
  • 데이터 클래스의 주 생성자에 선언된 프로퍼티 👉 val로 선언

data class User(val name: String, val age: Int)

fun main() {
    val user1 = User("Alice", 30)
    val user2 = User("Bob", 25)

    println(user1.toString())  // 출력: User(name=Alice, age=30)
    println(user1.hashCode())  // 출력: 해시 코드 값
    println(user1 == user2)    // 출력: false, 각 필드를 비교하여 결과를 반환합니다.

    val olderUser = user1.copy(age = 35)
    println(olderUser)         // 출력: User(name=Alice, age=35)
}

---

• companion object
  • 클래스 안에 정의되는 특별한 객체
  • 클래스의 인스턴스 없이도 클래스와 연관된 정적 멤버나 메서드 선언 가능
  • 자바의 static와 유사한 역할
  • 각 클래스는 단 하나의 companion object만 가질 수 있음
  • 기본 이름 생략 가능 👉 companion

class User(val name: String, val age: Int) {
    companion object {
        fun create(name: String): User {
            return User(name, 0)
        }
    }
}

fun main() {
    val user = User.create("Alice")
    println("User: ${user.name}, Age: ${user.age}")  // "User: Alice, Age: 0" 출력
}

👉 인스턴스 생성하지 않고도 companion object 멤버 접근 가능 

---

• operator fun invoke
  • operator fun은 연산자 오버로딩 허용하는 특별한 함수 선언 방식
  • 연산자 오버로딩 👉 클래스나 데이터 타입에 대해 특정 연산자의 동작을 정의하거나 재정의
  • invoke 연산자 👉 객체를 함수처럼 호출 가능

class Greeter(val greeting: String) {
    operator fun invoke(name: String) {
        println("$greeting, $name!")
    }
}

fun main() {
    val greeter = Greeter("Hello")
    greeter("World")  // 출력: Hello, World!
}

greeter 객체를 함수처럼 호출
greeter("World")와 greeter.invoke("World")는 동일

---

• with(객체) 👉 with관련 정리
  • 결과 반환 없이 내부에서 수신객체를 이용해 다른 함수 호출
  • 주어진 객체에 대해 블록을 실행하고 블록 내에서 해당 객체의 멤버에 직접 접근

@Document("cat")
data class CatDocument(
	
    @Id
    val catId: String? = null,
    
    val color: String?,
    
    val catType: List<String>?, 
){
	companion object{
        operator fun invoke(cat: Cat) = with(cat){
            CatDocument(
                catId = catId, // catId = this.catId -> this 생략
                color = color,
                catType = catType,
            ) // CatDocument 생성자 호출하여 새로운 CatDocument 객체 생성
        }
	}
}

👉 Cat 객체를 CatDocument 객체로 변환하는 기능

👉 cat은 with 블록 안에서 Cat 객체의 필드에 접근해서 cat을 기반으로 CatDocument 객체 생성

👉 with 블록 내의 this는 cat을 가리킴 !

 

 

 

Repository (MongoDB)

• ReactiveMongoRepository
  • 스프링 데이터 MongoDB에서 제공하는 인터페이스
  • 비동기적으로 MongoDB 조작 기능 제공 👉 Webflux
  • CRUD 메서드 제공 
  • @Document 어노테이션 사용하여 MongoDB의 컬렉션에 매핑됨
• @EnableReactiveMongoRepository
  • Spring Data MongoDB의 reactive repository를 활성화하는 데 사용
  • basePackages : 리포지토리 인터페이스를 검색할 패키지 지정
  • reactiveMongoTemplateRef : 특정 ReactiveMongoTemplate 빈 사용 지정

@SpringBootApplication
@EnableReactiveMongoRepositories(
    basePackages = ["com.example.repositories"],
    reactiveMongoTemplateRef = "reactiveMongoTemplate"
)

 

• MongoDB에서 객체를 쿼리하여 특정 조건에 맞는 결과 페이징 처리

dbConfiguration.MongoTemplate().find(query, Document::class.java)
	.skip(skipOffset)
    .take(size)

 

🔹 query는 MongoDB에서 검색할 조건 정의
🔹 Document::class.java는 검색할 문서의 클래스 타입 지정 및 반환할 객체 
🔹.skip(skipOffset) 는 결과 집합에서 지정된 수의 문서 건너뛰도록 지시
🔹.take(size) 는 반환할 최대 문서 수 = 한 페이지에 표시할 문서 수 

 

• Criteria
  • 쿼리 작성 시 조건 정의하는 데 사용되는 객체 👉 필터링
  • addCriteria() 👉 Query 객체에 새로운 검색 조건 추가 역할

@Service
class PersonService @Autowired constructor(private val mongoTemplate: MongoTemplate) {

    fun findByLastNameAndAge(lastName: String, age: Int): List<Person> {
        val criteria = Criteria().andOperator(
            Criteria("lastName").`is`(lastName),
            Criteria("age").gte(age)
        )
        val query = Query(criteria)
        return mongoTemplate.find(query, Person::class.java)
    }
}

@Service
public class UserService {

    @Autowired
    private MongoTemplate mongoTemplate;

    public List<User> findByAgeGreaterThan(int age) {
        Query query = new Query();
        query.addCriteria(Criteria.where("age").gt(age));
        return mongoTemplate.find(query, User.class);
    }
}

 

• query.with()
  • 다양한 옵션 적용 👉 페이징, 정렬, 특정 옵션 등 설정

import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;

Query query = new Query();
Query query2 = new Query();

query.with(Sort.by(Sort.Direction.ASC, "fieldName"));
query2.with(PageRequest.of(pageNumber, pageSize));

 

 

 

 

 

Service

•  flatMap
  • 비동기적으로 데이터 스트림 처리하고 연결
• let
  • null이 아닌 경우 사용될 로직 작성하고 새로운 결과 반환
• Mono.just()
  • 비동기적으로 단일 값 생성
• doOnSuccess
  • Mono 또는 Flux에서 비동기 작업이 성공적으로 완료된 후 부가적인 동작 수행

override fun update(taskId: String, task: Task): Mono<Task> {
    log.info { "[update] taskId: $taskId, task: $task" }

    return repository.findById(taskId)
        .flatMap { document ->
            repository.save(TaskDocument(taskId, document, task))
                .flatMap { taskDocument ->
                    task.taskSchedules?.let {
                        taskScheduleService.updateByTaskId(taskId, it, Task(taskDocument))
                            .collectList()
                            .map { scheduleList -> Task(taskDocument, scheduleList) }
                    } ?: Mono.just(Task(taskDocument))
                }
                .doOnSuccess { log.info { "[update] taskId: $taskId" } }
        }
}

 

💥 보통 Spring + JPA를 사용해서 UPDATE 로직을 구현할 때 엔티티 계층에서 수정 관련 비즈니스 로직을 추가해서 처리했기 때문에 repository.save()를 사용할 필요가 없었다 👉 EntityManager가 트랜잭션 내에서 엔티티의 변경사항을 자동으로 추적하기 때문(dirty Checking)

✨ 하지만 리액티브 프로그래밍 모델에서는 모든 작업이 non-blocking 및 비동기적으로 수행되므로 엔티티를 영속성 컨텍스트에서 관리하지 않아 dirty checking이 존재하지 않게 된다. 그렇기 때문에 엔티티에 대한 모든 수정 사항을 명시적으로 DB에 저장되게끔 해야하므로 repository.save()를 호출해 변경사항을 저장 !

 

 

• thenEmpty()

Reactor 라이브러리에서 제공하는 메서드로, 특별히 반환할 값이 없을 때 사용
👉 단순히 비동기적인 작업이 완료되었음을 처리하는 용도

public final Mono<Void> thenEmpty(Publisher<Void> other) {
        return this.then(fromDirect(other));
}

 

• .when()

Reactor 라이브러리에서 제공하는 메서드로, 여러 개의 Mono를 병렬로 실행하고 모든 Mono가 완료될 때까지 기다린 후 결과를 처리할 수 있는 기능 제공 
Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have completed.

import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

public class MonoWhenExample {
    public static void main(String[] args) {
        // 두 개의 비동기 작업 정의
        Mono<String> task1 = Mono.fromCallable(() -> {
            Thread.sleep(1000); // 1초 동안 대기
            return "Task 1 completed";
        }).subscribeOn(Schedulers.boundedElastic());

        Mono<String> task2 = Mono.fromCallable(() -> {
            Thread.sleep(2000); // 2초 동안 대기
            return "Task 2 completed";
        }).subscribeOn(Schedulers.boundedElastic());

        // Mono.when()을 사용하여 두 작업을 병렬로 실행하고, 모든 작업이 완료될 때까지 기다림
        Mono.when(task1, task2)
            .doOnTerminate(() -> System.out.println("All tasks completed"))
            .block(); // 블로킹 호출로 결과 대기 (예제용, 실제 사용 시 비동기적으로 처리)

        System.out.println("Program finished");
    }
}

 

✨ 실제 코드에서는 .thenEmpty(Mono.`when`( ~~~) ) 
이렇게 when 메서드에 백틱을 추가했다. 그 이유는 코틀린에서 when이 키워드이기 때문이다.
충돌을 피하고 코드의 가독성을 유지하기 위해 백틱을 사용한다 !

 

• filterNot

컬렉션의 요소를 조건에 따라 필터링하여 특정 조건에 부합하지 않는 요소들로 새로운 컬렉션 반환

 

 

 

참고자료 

https://mangkyu.tistory.com/358

https://www.geeksforgeeks.org/spring-webflux-reactive-crud-rest-api-example/

https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html

https://www.baeldung.com/kotlin/backticks