테크폭스

Querydsl 일반적인 사용 정리

Tech업 — Mon, 4 Jul 2022 15:56:54 +0900

Querydsl로 프로젝트를 하면서 많은 쿼리문을 작성하는데 필요 시 계속 구글링하면서 하기도 귀잖고 해서 일반적인 사용 방법에 대해 정리하려고 한다.

◆기본적인 사용

//객체 조회
val foos = query.selectFrom(foo).fetch()
//count 조회
val count = query.selectFrom(foo).fetchCount()
//join
val foos = query.selectFrom(foo)
                                            .leftJoin(food).on(foo.id.eq(food.foo.id)
                      .fetch()
//ordering
val foos = query.selectFrom(foo)
                .orderBy(foo.name.asc(), foo.age.desc()).fetch()
//update
query.update(foo).set(foo.name,"joy").where(foo.name.eq("jerrey")).execte()

◆Subqueries

Sub query를 사용하기 위해서는 JPAExpression을 사용해야 한다.

var foos = query
            .selectFrom(foo)
            .where(
                foo.id.`in`(
                    JPAExpressions
                        .select(user.foo.id)
                        .from(user)
                        .where(user.age.isNotNull)
                )
            ).fetch()

◆Paging 사용

Spring에서 제공하는 Paging 객체를 사용하면 order by 문구를 생성 시에 QClass로 생성되는 것을 볼 수 있다. 이 문제는 PathBuilder와 OrderSpecifier를 사용하여 쉽게 해결 할 수 있다.

pageable.sort.forEach {
            val pathBuilder = PathBuilder(foo.type, foo.metadata)
            query = query.orderBy(
                OrderSpecifier(
                    if (it.isAscending) Order.ASC else Order.DESC,
                    pathBuilder.getString(it.property)
                )
            )
        }

query = query.offset(pageable.offset).limit(pageable.pageSize.toLong())

var foos= query.fetch()

return PageImpl<foo>(foos, pageable, query.fetchCount())

마지막에 Page정보를 업데이트하여 return해야만 정확한 Page정보를 전달할 수 있다.

◆LAZY load 문제 해결

Data Entity에서 LAZY로 설정된 칼럼을 방문함에 있어 LazyInitializationException 이 발생할 수 있다. 참고링크, 이를 해결하기 위해 방법은 여러가지가 있지만 QueyDSL를 이용하여 쉽게 해결하는 방법을 소개 하려고 한다. left join후 강제로 join를 fetch 시키는 방법이다.

var query = query
            .selectFrom(user)
            .leftJoin(user.foo)
            .where(user.foo.id.eq(ids))
return query.fetchJoin().fetch()

마지막 실행문에서 fetchJoin를 먼저 해줘야만 LAZY로 설정된 객체를 같이 가져온다.

◆ 2 Depth fetch

종종 업무를 하다보면 2depth object까지 조회해야하는 경우가 있고 그 과정에서 LAZY 에러가 발생하는 경우가 있다. 이경우 아래와 같이 사용하면 된다.

query
            .select(foo)
            .from(foo)
            .innerJoin(foo.user, user).fetchJoin()
            .innerJoin(user.role, rol).fetchJoin()
            .where(
                foo.user.id.eq(id),                
            ).fetch()

Join과 동시에 fetchJoin을 실행하여 구현 가능 하다.

◆ BooleanExpression 사용

조건문이 많은 경우 query를 더 직관적으로 사용할 수 있는 방법이다

fun eqEmail(userEmail: String?): BooleanExpression? {
        userEmail ?: return null

        return user.email.like("$userEmail%")
}

fun predicateUserType(type: String): BooleanExpression? {
        if (type == "admin") {
            return user.role.name.qe("admin");
        }

        return user.role.name.notEqualsIgnoreCase("admin")

}
fun test(){
        var query = query
            .selectFrom(user)
            .leftJoin(user.foo)
            .where(eqEmail("abc@abc.com"),
                                predicateUserType("admin"))
        return query.fetchJoin().fetch()
}

https://vimsky.com/examples/detail/java-class-com.querydsl.jpa.JPAExpressions.html

http://querydsl.com/static/querydsl/latest/reference/html/ch03s02.html

https://ict-nroo.tistory.com/117

https://ksabs.tistory.com/186

https://jsonobject.tistory.com/605

https://hojak99.tistory.com/578

https://velog.io/@sonaky47/querydsl-%EB%91%90%EB%B2%88%EC%A7%B8-%EA%B9%8A%EC%9D%B4%EB%A5%BC-fetch-%ED%95%B4%EB%B3%B4%EC%9E%90

특정 기능 속도 개선 경험담(MySQL)

Tech업 — Thu, 23 Jun 2022 22:42:02 +0900

2개월동안 진행했던 속도 개선 작업에 관하여 간단한 정리를 하려고 한다. 추후 진행할 프로젝트에서 참고될수 있도록 정리해 놓는 목적이 크다. 실질적으로 속도 개선은 소량 데이터(만건이하)에서 약 70%개선, 많은 데이터(5만건 이상)에서 10배 정도 개선이 있지만 만약 제일 처음에 개선한 buik insert 변경은 속도 개선 효과는 결과에 반영하지 않았다. 만약 반영한다면 소량 데이터에서도 5배 속도 개선이 이루어 졌다고 봐도 된다.

개선 작업을 요약하면 아래와 같다.

JPA save를 Buik insert로 수정
native query를 QueryDSL로 변경 및 projection 방식 채택
속도 느린 query 속도 개선
전체 Logic 수정하여 DB 접근을 최소화
데이터 불일치 문제 해결
재 배포 없이 API로만 결과 검증 가능하도록 검증 API 추가
모든 코드를 kotlin로 재 작성

JPA save를 Buik insert로 수정

Buik Insert로 로직 수정. 개선 작업을 진행한 부분은 모든 JPA save를 사용하여 속도가 엄청 느렸다. 자료 조사를 통해 먼저 colloction에 후 saveAll 방식으로 수정 했지만 좀 더 낫은 방법으로 개선 하기 위하여 buik insert 방식을 채용. 기존 save 방식 대비 약 10배 성능 향상이 이루어 짐.

native query를 QueryDSL로 변경 및 projection 방식 채택

기존 로직에서 데이터를 조회하는 부분이 native query로 작성되여 있고 가져온 object를 class 생성자를 만들어서 강제 형 변환을 하여 사용하였다. 이부분의 query 가 복잡하여 해석도 힘들고 유지보수도 힘들것 같아 queryDSL로 작성하였다. queryDSL로 변환하니 모든 relation data를 가져오는 것을 확인 하여 조회 속도가 느려진 것을 확인 하고 필요한 데이터를 projection하는 방식을 택하여 가져와서 속도 개선을 하였다.

속도 느린 query 속도 개선

속도 느린 query 에 대하여 explain 명령어를 사용하여 왜 느린지를 분석하고 index가 없으면 전체 테이블 관계를 파악하여 index를 만들어 넣고 만약 기존에 index가 존재하면 기존 index를 타게끔 조건문과 join 관계를 수정하였다.

전체 로직을 수정하여 DB 접근을 최소화

기존에는 필요시마다 DB에서 데이터를 계속 읽어와서 처리해야 함으로 빈번한 조회가 발생하여 전체 로직의 속도가 느려졌다. 처리 해야 할 데이터 양이 적으면 큰 문제가 되지 않지만 10만 건 이상 데이터를 처리함에 있어 많은 속도 저하가 발생하였다. 이런 문제를 해결하기 위해 처리에 필요한 데이터를 맨 처음에 읽어 온 후 비즈니스 로직으로 처리하도록 변경하였다. 또한 coroutine으로 작성된 로직에서 병렬로 처리함에 있어 DB 조회 속도가 현저히 떨어지는 것을 발견하고 coroutine 시작 시 약간의 delay을 DB을 접근을 동시에 하는 것을 막아 조회 속도를 일정하게 보장 시켰다. ( 추후 DB 성능을 높이니 delay를 주지 않아도 조회 속도에 문제 없는 것을 확인 하고 delay에 대한 코드는 제거 했다.)
경험한 프로젝트에서는 3만건 정도면 약 70% 속도 차이를 보이지만 10만 데이터는 약 10배 속도 향상을 달성 하였다.

데이터 불일치 문제 해결

기존 로직과 새로 작성한 로직 사이 결과가 불일치 문제 해결
모든 작업을 끝내고 최종 테스트를 진행하였는데 소수점 자리수의 마지막 자리가 계속 상이한 점을 발견하고 어디에 문제가 있을지를 고민해 보았다. 많은 케이스에서 문제 없는데 오직 한 케이스만 문제 있었다. 자세히 들여다 보니 double를 소수점 타입을 사용한 것이 문제 였다. 지단로보트의 BigDecimal 사용법 정리를 보고 상이함이 발생하는 부분의 double만 BigDecimal로 수정하니 모든 문제가 해결 되였다. ( 기존 방법은 일정한 단위로 처리 후 DB에 저장 후 다시 필요하면 읽어오는 방식이 여서 저장하지 않는 값과 저장한 값 사이 약간의 차이가 발생 한 것으로 추정 된다.)

재배포없이 API로만 결과 검증 가능하도록 검증 API 추가

기존 로직과 속도 비교를 위하여 서비스 중인 분산캐시를 사용하여 on/off 할 수 있게 하였다. 실시간으로 새로 개선한 로직이 기존 로직과 결과가 일치함과 서비스를 새로 배포하지 않고 바로바로 테스트 가능 하여 속도 개선 작업에서 많이 사용된다.

모든 로직을 kotlin으로 재 작성

기존 로직은 JAVA로 되여 있었다. JAVA로 많은 중복 코드로 인해 코드의 가독성이 떨어져 있었다. 모든 코드를 이해하고 kotlin으로 작성하였다. 변환 과정에서 한번 더 느겼지만 코드가 휠씬 간결해지고 특히 코드 작성에서 null에서 체크를 모두 끝내니 NPE가 발생을 원춴적으로 차단 된것 같다는 느낌이 든다. 또한 다른 JAVA class를 사용함에 있어서도 null에 대한 체크를 엄격히 하니 코드 작성에 좀 더 집중할 수 있는 것 같다. 필자는 JAVA로 작성시 여러번 NPE를 발생 시킨 경험이 있다.

현재 읽고 있는 책들

Tech업 — Thu, 19 May 2022 21:40:02 +0900

아래 내용은 현재 테크업이 읽고 있는 책들이다. 아직은 진행 중인 책들이 대부분이여서 완독할 때까지 이 포스트를 업데이트 할 예정이다. 추천해 주실 책들이 있으시면 댓글로 부탁드립니다.

Kotlin

Kotlin in Action
제일 처음 코틀린으로 입문하면서 본 책이다.
Hands-On Data Structures and Algorithms with Kotlin
데이터 구조와 알고리즘 구현을 코틀린으로 재해석한 책이다. 기존적인 array부터 queue, map 까지 kotlin으로 구현한걸 설명과 함께 다루고 있다.
Functional Kotlin
Functional 프로그래밍관점으로 kotlin에 대하여 설명한 책이다
Kotlin Standard Library Cookbook
코틀린의 표준라이브러리 소개와 사용법을 다룬 책이다. 이 책 내용 일부는 블로그에 글로 정리되여 있다.

JAVA

Java: A Beginner's Guide, Eighth Edition, 8th Edition
자바 언어 입문으로 읽는 책이다. 설명이 간단 명료하고 좋다. 자바 입문으로 추천한다.

Architeture

Microservices with Spring Boot and Spring Cloud - Second Edition
MSA 서비스에 대하여 다루고 있다. spring boot로 MSA를 구성함에 있어 일반적인 문제점과 그것들에 대한 해결책을 제시하고 있다.
Hands-On High Performance with Spring 5
Spring 입문으로 읽는 책이다. Spring에대한 기초적인 지식과 최적의 사용법에 대하여 다루고 고민하게 만든다.
Spring Boot 2 Recipes: A Problem-Solution Approach
Spring boot를 이용하여 웹서비스를 구성함에 있어 시나리오별로 소개하고 있는 책이다. 입문 서적으로써 좋다.

The Design of Web APIs
전반적인 API 설계에 대하여 복습하기 위해 읽는 책이다. 읽으면서 블로그에 정리할 예정이다.
Clean Architecture: A Craftsman’s Guide to Software Structure and Design
좋은 Architecture를 가지는 software를 만드는데 있어서 기본적인 원칙부터 아키텍쳐 설계까지 망라한 책이다.

Algorithm

40 Algorithms Every Programmer Should Know
알고리즘을 복습하기 좋은 책, 평소에 여유 시간되면 읽으면 좋은 책이다.

Clean Code

Clean Code: A Handbook of Agile Software Craftsmanship
개발자라면 항상 고민해야할 문제 clean code 에 대하여 깊게 다룬 책이다. 이 책은 더 설명이 필요 없을것 같다.

Logging

Kotlin Standard Library Cookbook
로깅에 대하여 깊게 다룬 책이다. 기회가 된다면 읽어보길 추천 드린다. 초기 OS레벨의 로깅법부터 어플리케이션 로깅까지 자세히 설명 되여 있다.

DataBase

Learn MongoDB 4.x
MongoDB 입문으로 좋은 책이다. 입문부터 후반 최적화까지 다루고 있다.
MongoDB in Action, Second Edition: Covers MongoDB version 3.0
입문으로 간이 프로젝트 맛보기로 좋은 책이다.

Mastering DynamoDB
Dynamo DB에 대한 전체적 소개와 best practice 내용이 포함되여 입문용으로 AWS 문서와 결합해 보면 좋은 책

ELK

Learning Elastic Stack 7.0 - Second Edition
ELK에 대해 배우고 싶어 시작한 책인데 아직 초반에 머물러 있다.

[python] AWS lambda layer로 필요 라이브러리 추가

Tech업 — Sat, 12 Mar 2022 07:33:38 +0900

lambda 로 간단한 프로그램을 작성하여 사용하는 경우가 많은데 라이브러이들을 layer로 저장하고 사용하면 여러 lambda 함수에서 공동으로 사용할 수 있어 개발 속도를 높이는데 도움이 된다. 이 글은 인터넷 상에 있는 여러가지 방법들 중 제일 간단하고 쉽게 할 수 있는 방법에 대해 소개 한다.

◆ 라이브러리 다운로드

라이브러리는 Linux 환경에서 다운받고 그 라이브러리를 사용하여 layer를 만드는 것을 추천한다.

AWS lambda에서 사용하는 python 버전도 중요하다. 본 글에서는 python 3.8 기준으로 설명할 예정이다.

먼저 라이브러리를 다운받을 폴더를 생성 후 필요한 라이브러리 들을 다운 받는다.

#폴더 생성
cd $HOME 
mkdir -p lib/python 
cd lib/python
#라이브러리 다운
pip install pymysql -t .

다운 받는 목록을 현재 목록으로 지정해 주어야 한다. 지정해 주지 않으면 python설치 목록 중 Lib 폴더에 설치 된다.

#만든 라이브러리 폴더를 zip으로 묶어 준다.
cd .. 
zip ../pymysql.zip .

◆AWS lambda layer 추가

Lambda 서비스로 가서 Layer 탭에 들어가서 아래와 같이 설정해 준다.

Create Layer → 이름, 설명 기입 → upload a .zip file를 선택 후 금방 만든 zip파일을 업로드 (compatible architecture도 선택해 줘야 한다. 여기서는 x86_64를 선택) → runtime에서 python 3.8을 선택에서 layer 구성을 끝마친다.

◆함수에 Layer 추가

함수 편집 화면에서 Layers 항목에서 금방 추가한 layer를 선택하여 추가하면 된다.

명심해야할 점은 Layer에 크기 제한이 있다는 점이다. 왼만한 라이브러리를 모두 추가 가능 하나 deep learning 관련 큰 라이브러리는 따로 서비스를 이용하거나 몇개 layer로 만들어서 배포하는 것을 추천 한다. 아래 layer를 쉽게 만드는 github링크도 공유 했다. 해당 방법을 이용하면 쉽게 layer zip파일을 만들 수 있다.

https://blog.skbali.com/2018/11/aws-lambda-layer-example-in-python/

AWS SES 사용하기

Tech업 — Tue, 1 Mar 2022 16:46:06 +0900

쉽고 편리하게 E-mail를 고객한테 보내려면 Gmail SMTP를 사용하는 방법은 검색하면 많이 나온다. 이번 글은 spring 프로젝트에서 AWS SES를 설정하고 메일을 보내는 방법을 설명 하려고 한다.

AWS에서 서비스를 신청하고 도메인을 등록하고 권한을 부여하는 부분에 대한 내용은 생략하고 Spring에서 설정하고 메일을 보내는 방법에 대해 적으려고 한다.

◆Dependency 추가

<dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-java-sdk-ses</artifactId>
            <version>1.12.167</version>
</dependency>

◆Config Class

import com.amazonaws.auth.AWSStaticCredentialsProvider
import com.amazonaws.auth.BasicAWSCredentials
import com.amazonaws.services.simpleemail.AmazonSimpleEmailService
import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration

class AwsSesConfig(

    @Value("\${aws_accesskey}")
    val accessKey: String,

    @Value("\${aws_secret}")
    val secretKey: String,

    @Value("\${aws_region}")
    val region: String,
) {
    @Bean
    fun amazonSimpleEmailService(): AmazonSimpleEmailService {
        return AmazonSimpleEmailServiceClientBuilder.standard()
            .withRegion(region)
            .withCredentials(
                AWSStaticCredentialsProvider(
                    BasicAWSCredentials(accessKey, secretKey)
                )
            )
            .build()
    }
}

환경변수로 AWS Crtedential 정보를 설정하고 그것을 이용하여 AmazonSimpleEmailService client를 생성하는 Bean을 만들어 준다.

◆ 간단한 메일 보내기

fun sendEmail() {
        val message = Message()
        message.withSubject(Content("this"))
        message.withBody(Body().withHtml(Content("This is test mail")))
        val destination = Destination().withToAddresses("apple@hotmail.com")
        awsSimpleEmailServiceClient.sendEmail(
            SendEmailRequest()
                .withSource("foo@hotmail.com")
                .withDestination(destination)
                .withMessage(message)
        )
    }

내용, 발신자, 수신자를 설정하고 sendEmail 함수를 호출하여 메일을 보낼 수 있다.

추후 sendBulkTemplatedEmail를 사용하여 다수의 수신자에게 메일을 보내는 방법에 대해 업데이트 할 예정이다.

https://gist.github.com/BlackthornYugen/1b3e1ff4426294e7054c9a7190e8f2cd

https://junho85.pe.kr/1449

Hibernate L2 Cache - Region 별 저장 및 통계 정보를 이용하기

Tech업 — Tue, 25 Jan 2022 22:56:17 +0900

Hibernate L2 Cache는 기본적인 설정으로는 default 영역에 모든 데이터가 저장된다. 이렇게 저장되면 정확히 cache가 동작여부를 알 수 없다. 분산 캐시를 구성하면 더더욱 확인하기 어렵다. 이를 정확히 확인 하기 위해서는 cache를 entity별로 Region를 설정하고 각 Region 의 통계 정보를 이용하면 된다.

Region 설정

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "Foo")

@Cache 이노테이션에 region 값을 넣으면 “Foo” region이 생성된다.

설정된 Region에 저장

@QueryHints(value ={@QueryHint(name = HINT_CACHEABLE, value = "true"),
@QueryHint(name = HINT_CACHE_REGION , value = "Foo")})
fun existsFooByName(name: String): Boolean;

@QueryHint의 HINT_CACHE_REGION 값을 위에서 설정한 값으로 설정하면 Foo Region으로 데이터가 저장된다.

통계정보를 이용

Hibernate의 statistics 정보를 이용하여 Hit, Miss, Put count를 Region 별로 얻을 수 있다.

class HibernateHelper(
private val sessionFactory: SessionFactory
){
    fun getHibernateHitMiss(){
            val cacheRegionNames = sessionFactory.statistics.secondLevelCacheRegionNames
        cacheRegionNames.foreach{
            val cachaStatistics = sessionFactory.statistics.getCacheRegionStatistics(it)
            println(cachaStatistics.regionName)
            println(cachaStatistics.hitCount)
            println(cachaStatistics.missCount)
            println(cachaStatistics.putCount)
        }
    }
}

통계정보는 SessionFactory부터 얻을 수 있다. 이미 hibernate에서는 Bean으로 설정되여 있기때문에 가져다 쓰면 된다.

https://www.baeldung.com/hibernate-second-level-cache

[kotlin] Serialization을 이용하여 JSON를 다루어 보자

Tech업 — Thu, 20 Jan 2022 22:03:40 +0900

Kolin에서 Json를 보통 Gson 라이브러리를 사용하여 다룬다. Gson를 사용해도 원만한 처리는 가능하다. Serialization은 Gson에서 지원이 미흡한 NEP문제에 대해 강력하게 제한함으로써 kotlin의 가치관를 그대로 반영한 라이브러리이다. 이글은 kotlin의 serialization에 대하여 설정부터 간단한 사용법을 정리할 예정이다.

◆ Maven 설정

<properties>
    <kotlin.version>1.6.10</kotlin.version>
    <serialization.version>1.3.2</serialization.version>
</properties>

버전 정보를 속성에 명시한다.

<build>
    <plugins>
        <plugin>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-maven-plugin</artifactId>
            <version>${kotlin.version}</version>
            <executions>
                <execution>
                    <id>compile</id>
                    <phase>compile</phase>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <compilerPlugins>
                    <plugin>kotlinx-serialization</plugin>
                </compilerPlugins>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.jetbrains.kotlin</groupId>
                    <artifactId>kotlin-maven-serialization</artifactId>
                    <version>${kotlin.version}</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

Plugin 정보를 추가한다.

<dependency>
    <groupId>org.jetbrains.kotlinx</groupId>
    <artifactId>kotlinx-serialization-json</artifactId>
    <version>${serialization.version}</version>
</dependency>

마지막으로 dependency를 추가한다. gradle보다 설정이 좀 복잡하다. dependency 뿐만아니라 plugin를 추가해야만 사용 가능 하다. gradle 설정 참고

◆ JSON object class 작성

@Serializable
data class Foo(
    @SerializedName("id")
    val id: Int? = null,
    @SerializedName("name")
    val name: String? =null,
    @SerializedName("age")
    val age: Int? = null,
)

@Serializable 어노테이션을 사용하면 해당 class는 Serialization라이브러리를 사용할 수 있는 객체로 된다. @SerializedName은 json에 매핑되는 key 값을 의미한다. Serialization을 사용하면 null 값에 대한 설정 부분이 약간 민감하다. Gson를 사용하면 class에서 null값 허용을 설정해 주지 않아도 알아서 무시한다. Serialization에서는 초기값을 null로 설정해 주지않으면 null 값을 Parsing하지 않고 exception을 발생 시킨다.

◆사용

//DeSerialize
val fooStr = """{"id":1,"name":"foo","age":20}""""
val fooObj = Json.decodeFromString<Foo>(fooStr)
//Serialize
val jsonList = Json.encodeToString(fooObj )

◆프로젝트에서의 사용

타 사이트와 연동하거나 타 서비스와 데이터를 주고 받음에 있어 요즘은 json포맷이 보편화 되였다.

프로젝트에서 쉽게 json class을 생성하는 방법을 공유하려고 한다. IntelliJ에서 Json To kotlin class라는 plugin를 설치하고 class 파일을 만든 후 클릭 메뉴에서 generate ...를 선택하고 kotlin data from json를 선택하고 json 을 붙여 넣으면 자동으로 kotlin class를 생성해 준다. Advanced를 클릭하여 어노테이션, null 값에 대한 처리 대한 옵션을 선택할 수 있다. 자동으로 생성해준 class는 완벽할 수 없으므로 한번 검토해 보고 사용하는 것이 좋다.

TiP:

Gson vs serialization

1. not null 변수에 null이 들어 갈 수 있음, kotlin 언어의 null safe 장점이 사라진다

2. default value 적용 불가

Ref:

https://kotlinlang.org/docs/serialization.html#example-json-serialization

https://github.com/Kotlin/kotlinx.serialization

[JobRunr] Pro 버전에서 Server Tag 설정 방법 및 실전 노하우

Tech업 — Fri, 14 Jan 2022 18:50:02 +0900

이글에서 JobRunr에 대하여 간단한 사용법에 대하여 알아 보았다. 이번 글은 JobRunr Pro 버전에서 Service node에 대하여 각기 다른 tag를 설정하는 방법 및 Recurring Job를 설정 시 ProgressBar를 이용하는 방법에 대해 정리한 곳이 없어 정리하려고 한다.

◆Server Tag 기능

보통 production 환경에는 여러개의 node가 존재하고 특정 업무를 수행하는 node도 존재하기 마련이다. Tag 기능은 특정 Job를 특정 node에서만 수행 하도록 하는 기능이다. 이 기능은 pro버전에만 제공한다. JobRunr 설정에 아래 내용을 추가 해야 Tag 기능을 사용 가능하다.

@Configuration
class JobRunrConfig(
    private val mongoClient: MongoClient
) {
    @Bean
    fun storageProvider(jobMapper: JobMapper): StorageProvider {

        val storageProvider = MongoDBStorageProvider(mongoClient)
        storageProvider.setJobMapper(jobMapper)
        return storageProvider
    }

    @Bean
    fun backgroundJobServer(
        storageProvider: StorageProvider,
        @Qualifier("jobRunrJsonMapper") jsonMapper: JsonMapper,
        jobActivator: JobActivator
    ): BackgroundJobServer {

        val backgroundJobServer = BackgroundJobServer(
            storageProvider, jsonMapper, jobActivator,
            BackgroundJobServerConfiguration
                .usingStandardBackgroundJobServerConfiguration()
                .andTags("Windows"),
            JobNotFoundConfiguration.usingStandardJobNotFoundConfiguration()
        )
        backgroundJobServer.start()

        return backgroundJobServer
    }
}

backgroundJobServer에 대한 설정을 해 줘야 된다. 여기서는 모든 parameter 값은 기본 값을 사용했고 tag만 별도로 설정해 주었다.

◆ Tag 사용

JobRunr 함수 정의 시 Tag 정보도 같이 적어 준다.

@Recurring(id = "Myjob-window", cron = "8 8 12 * * *")
@Job(name = "MyJob", runOnServerWithTag = "Windows", retries = 2)
public void myJob() throws Exception {
     log.info("My job start.");
}

◆ Recurring Job에서 Progress Bar 사용

Progress Bar 기능은 JobRunr에서 기본적으로 제공하는 DashBoard 기능 중 하나이다. Progress Bar를 사용하려면 JobContext를 인자로 받아야 사용가능하다. 그런데 Recurring Job를 정의하면 인자로 아무것도 받지 못한다. 이를 해결 하기 위해서 Recrring Job 정의서의 Background Job를 enqueue하는 방식으로 우회하여 해결이 가능 하다.

@Recurring(id = "Myjob-window", cron = "8 8 12 * * *")
@Job(name = "MyJob", runOnServerWithTag = "Windows", retries = 2)
public void myJob() throws Exception {
     log.info("My job start.");
}

@Job(name = "MyJob-enqueue", runOnServerWithTag = "Windows", retries = 2)
public Boolean MyRealJob(JobContext jobContext) throws Exception {
        JobDashboardProgressBar progressBar = jobContext.progressBar(1000);
        for(int i = 0; i < 1000; i++) {
            progressBar.increaseByOne();
     }
}

◆DashBoard에서 log 보기

기본적으로 제공하는 Dashboard에서는 log 정보도 담을 수 있다. 설정은 아래와 같이 하고 사용하면 된다.

//정의
private Logger log =new JobRunrDashboardLogger(LoggerFactory.getLogger(MyService.class))

//사용
log.info("My Job");

[Kotlin] foreach 와 map 알고 쓰자

Tech업 — Wed, 12 Jan 2022 22:48:21 +0900

Kotlin으로 구현하다보면 foreach와 map은 실제로 같은 기능을 하는 것 같지만 깊게 이해하고 사용하면 상황에 따라 유용하여 사용할 수 있다. 이글에서는 두 문법에 관하여 정리해 보려고 한다.

◆foreach

이 문법은 단순히 모든 Collection 원소에 대하여 한번 순회하면서 처리하는 문법이다. 중간에 중단도 가능하고 결과 값을 만들어 내기도 하고 아닐 수도 있다. 즉 모든 처리가 가능 하다.

val list = listOf(
     Data("John", "Ali"), 
     Data("Naidu", "Tan"), 
     Data("Evgenii", "Dmitry"))
list.foreach{
    if(it.firstName=="Naidu"){
        println("This is Naidu")
        break
    }
}

◆map

map은 모든 원소을 순회하면서 결과값을 반환한다. 즉 모든 원소를 순환하는 목적이 다른 무언가를 하기 위함이다. 원래 Collection이 아닌 다른 Collection으를 만든다. 이 떄문에 map을 보통 두 Collection를 transform 하기위해 사용한다.

val list = listOf(
        Data("John", "Ali",30),
        Data("Naidu", "Tan",32),
        Data("Evgenii", "Dmitry",32))
val newList =list.map{ it.age +=1}

◆결론

단순히 모든 원소에 대하여 어떤 처리를 하거나 특정 조건에서 loop를 중단하고 결과 값이 필요 없으면 foreach를 선택, loop의 결과를 다른 Collection으로 반환 받고 싶으면 map을 선택하는 것이 좋다.

https://stackoverflow.com/questions/354909/is-there-a-difference-between-foreach-and-map

[Spring] 코드에서 Active Profile 가져오기

Tech업 — Sun, 9 Jan 2022 12:15:29 +0900

실행프로파일 별로 다르게 실행해야할 업무 로직을 구현이 필요할 경우 아래와 같이 진행하면 쉽게 구현 할 수 있다.

◆Enviroment 빈 설정

Spring 환경 변수는 Enviroment class로부터 가져 올 수 있다. 아래 코드로 bean을 주입한다.

@Autowired
private final Environment environment;

◆사용

if(Arrays.stream(environment.getActiveProfiles()).anyMatch(
                env -> (env.equalsIgnoreCase("dev") ))){
	//비즈니스 로직 구현
}