현실을 넘어

[블로그 이사] https://velog.io/@qkrtkdwns3410/posts

OverTheHorizon3410 — Fri, 15 Mar 2024 00:37:55 +0900

https://velog.io/@qkrtkdwns3410/posts

ㅇ

OverTheHorizon3410 — Tue, 5 Mar 2024 19:25:12 +0900

# [전자정부프레임워크] 3.5 → 4.0 마이그레이션 및 호환성 인증

OverTheHorizon3410 — Tue, 5 Mar 2024 15:58:20 +0900

[전자정부프레임워크] 3.5 → 4.0 마이그레이션 및 호환성 인증 (velog.io)

[전자정부프레임워크] 3.5 → 4.0 마이그레이션 및 호환성 인증

회사에서 전자정부 프레임워크관련하여 마이그레이션 및 호환성 점검을 받은 내용을 기록한다.Spring MVC 와 Spring Boot 모두 마이그레이션을 수행하였습니다.회사마다 소스 형태가 다르기에, 다르

velog.io

여기 참고!

[코틀린 인 액션] 4.2.2 부 생성자: 상위 클래스를 다른 방식으로 초기화

OverTheHorizon3410 — Mon, 4 Mar 2024 15:18:50 +0900

코틀린 생성자 vs 자바 생성자

코틀린은 자바에 비해 생성자가 여러 개 필요한 경우가 적다.

자바에서 필요한 오버로드 생성자는 코틀린의 기본 생성자와 이름 붙인 인자 문법으로 해결이 가능하다.
- 이름 붙인 인자
  - 함수나 생성자 호출시 파라미터의 이름을 명시적으로 지정하여 값을 전달하는 방식
```
fun formatMessage(name: String, age: Int, location: String) {
    // ...
}
```
  - 을 호출시에
```
formatMessage(location = "Seoul", age = 30, name = "Alice")
 혹은
formatMessage(name = "Alice", age = 30, location = "Seoul")
```
  - 인자가 무엇을 의미하는지 명확하게 전달이 가능하다.

부 생성자가 필요한 경우

프레임 워크 클래스를 확장하는 경우, 다양한 방법으로 인스턴스 초기화할 수 있어야 할때

예: 안드로이드의 View 클래스

예시

View 클래스

open class View {
    constructor (ctx: Context) {
        // 코드
    }
    constructor (ctx: Context, attr: AttributeSet) {
        // 코드
    }
}

MyButton 클래스

class MyButton : View {
    constructor (ctx: Context) : super(ctx) {
        // ...
    }
    constructor (ctx: Context, attr: AttributeSet) : super(ctx, attr) {
        // ...
    }
}

생성자 위임 방식

super() 를 통한 위임

this() 를 사용해 클래스 자신의 다른 생성자를 호출할 수 있음

`class MyButton : View {
    constructor (ctx: Context) : this(ctx,MY_STYLE) {
        // ...
    }
    constructor (ctx: Context, attr: AttributeSet) : super(ctx, attr) {
        // ...
    }
}

모든 부 생성자는 상위 클래스를 초기화하거나 다른 생성자에게 생성을 위임하는 역할을 해야합니다!

Uploaded by N2T

[코틀린 인 액션] 4.2.3 인터페이스에 선언된 프로퍼티 구현

OverTheHorizon3410 — Mon, 4 Mar 2024 15:18:39 +0900

코틀린에서 인터페이스의 경우 추상 프로퍼티를 포함할 수 있다.

인터페이스를 구현하는 클래스가 해당 프로퍼티에 대한 구현을 제공해야 한다.

추상 프로퍼티 선언 예시

interface User {
    val nickname: String
}

//주 생성자에서 프로퍼티를 직접 선언한다.
class PrivateUser(override val nickname: String) : User {
    /*User 의 추상 프로퍼티를 override 키워드로 구현*/
}


// 커스텀 게터를 사용한다.
class SubscribingUser(val email: String) : User {
    /*이메일 주소에서 별명을 계산하여 반환하는 커스텀 게터 사용*/
    override val nickname: String
        get() = email.substringBefore('@')
}

// 초기화 식을 사용한다.
class FacebookUser(val accountId: Int) : User {
    //객체 초기화시 계산한 데이터를 저장하고, 이를 nickname 의 프로퍼티 값으로 사용
    override val nickname = getFacebookName(accountId)
}

인터페이스에서 게터와 세터가 있는 프로퍼티 선언

interface User {
    val email: String
    val nickname: String
        get() = email.substringBefore('@')
}

email은 추상 프로퍼티로 하위 클래스에서 반드시 구현해야 합니다.

nickname은 커스텀 게터를 사용하여 구현되며, 하위 클래스에서 오버라이드하지 않고 상속할 수 있습니다.

클래스에서 구현된 프로퍼티와 접근자

클래스에서 구현된 프로퍼티는 뒷받침하는 필드를 원하는 대로 사용 가능.

Uploaded by N2T

[코틀린] 11727 2×n 타일링 2

OverTheHorizon3410 — Mon, 4 Mar 2024 15:18:36 +0900

마지막에 2×1 타일을 놓는 경우

마지막에 1×2 타일 두 개를 세로로 놓는 경우

마지막에 2×2 타일을 놓는 경우

를 모두 고려한다면, 점화식을 도출이 가능하다.

dp[n] = dp[n-1] + 2 dp[n-2]

package 알고리즘.백준.NX2타일링2

import java.io.BufferedReader
import java.io.InputStreamReader

/**
 *packageName    : 알고리즘.백준.NX2타일링2
 * fileName       : Main
 * author         : ipeac
 * date           : 2024-03-04
 * description    :
 * ===========================================================
 * DATE              AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2024-03-04        ipeac       최초 생성
 */
fun main() {
    BufferedReader(InputStreamReader(System.`in`)).use { r ->
        val n = r.readLine()!!.toInt()
        
        val dp = IntArray(1001) //왠지 모르겠는데 n+1 크기로 잡으니까 ArrayindexOutOfBounds 에러가 발생함.
        
        dp[1] = 1
        dp[2] = 3
        
        if (n <= 2) {
            println(dp[n])
            return
        }
        
        for (i in 3..n) {
            dp[i] = (dp[i - 1] + dp[i - 2] * 2) % 10007
        }
        
        println(dp[n])
    }
}

Uploaded by N2T

[코틀린] 10866번 덱

OverTheHorizon3410 — Sat, 2 Mar 2024 21:53:23 +0900

package 알고리즘.백준.덱

import java.io.BufferedReader
import java.io.InputStreamReader

/**
 *packageName    : 알고리즘.백준.덱
 * fileName       : Main
 * author         : ipeac
 * date           : 2024-03-02
 * description    :
 * ===========================================================
 * DATE              AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2024-03-02        ipeac       최초 생성
 */
fun main() {
    BufferedReader(InputStreamReader(System.`in`)).use { br ->
        val n = br.readLine().toInt()
        val deque = ArrayDeque<Int>()
        val answer = StringBuilder()
        
        repeat(n) {
            when (val command = br.readLine()) {
                "pop_front" -> answer.appendLine(deque.removeFirstOrNull() ?: -1)
                "pop_back" -> answer.appendLine(deque.removeLastOrNull() ?: -1)
                "size" -> answer.appendLine(deque.size)
                "empty" -> answer.appendLine(if (deque.isEmpty()) 1 else 0)
                "front" -> answer.appendLine(deque.firstOrNull() ?: -1)
                "back" -> answer.appendLine(deque.lastOrNull() ?: -1)
                
                else -> {
                    val (p, x) = command.split(" ")
                    when (p) {
                        "push_front" -> deque.addFirst(x.toInt())
                        "push_back" -> deque.addLast(x.toInt())
                    }
                }
            }
        }
        
        println(answer)
    }
}

덱(Deck) 관련 문제이다
- 덱까지 구현해서 문제를 풀어보면 좋을 것 같긴하다..

일단 ArrayDeck 을 사용하였다.
ArrayDeck
- 등장 이유
  - 효율적인 양방향 큐(deque) 의 구현을 위해서 등장
- 장점
  - 기존의 LinkedList 기반 큐의 경우 추가, 제거시에 O(1) 의 성능을 보인다.
    - ArrayDeck 도 그 면에서는 동일하게 좋다.
  - 메모리 사용량의 최적화
    - LinkedList 같은 연결리스트의 경우 각 노드가 데이터와 함께 다음 노드를 가리키는 포인터를 포함함.
    - 결국 포인트를 가지고 있음으로서, 그 만큼의 메모리의 추가적인 공간이 필요하게 된다.
    - 하지만, ArrayDeck 의 경우 이러한 포인터가 없기에, 단순한 배열 인덱스를 사용하여 요소에 접근한다.
  - 랜덤 엑세스 최적화
    - 배열구조이다.
    - LinkedList 같은 경우 연속한 메모리에 위치한 것이 아니기에, 결국 최악 O(n) 의 조회 성능을 기대할 수 있다.
    - 하지만 ArrayDeck 의 경우 배열 구조이기에 인덱스 를 통한 접근으로 O(1) 시간에 조회가 가능하다.

잡설하고, 일단 문제 자체는 너무 쉬웠는데,

단순히 프린트 스트림으로 출력하는 경우 IO 가 반복시마다 발생해서 오버헤드가 있다.

StringBuilder() 에 담아서 해당 값을 한번의 IO 로 출력하도록하면 통과한다.

Uploaded by N2T

[JPA] .setHint(QueryHints.READ_ONLY, true)

OverTheHorizon3410 — Sat, 2 Mar 2024 00:05:50 +0900

개요

JPA 에서 쿼리를 최적화하는 방법 중 하나는 읽기 전용 쿼리를 사용하는 것이다.

데이터를 변경하지 않는 조회 작업에서 성능의 향상이 가능하다.

방법

서비스 트랜잭션 안에서 전역적으로 설정
- @Transactional(readOnly = true)
  - 메서드, 클래스 레벨안에서 모든 DB 작업이 읽기 전용으로 변경됨.
  - JPA 하이버네이트 프로바이더가 내부적으로 DB 에 대한 변경 사항을 추적하지 않도록 성능 최적화 수행

쿼리자체에서 설정
- .setHint(QueryHints.READ_ONLY, true)
```
List<OrderEntity> orders = qf.selectFrom(orderEntity)
    .where(...)
    .setHint(QueryHints.READ_ONLY, true)
    .fetch();
```
- 해당 쿼리가 데이터를 변경하지 않고 오직 읽기만 수행할 것임을 JPA 프로바이더에게 알려준다.

착안

Spring Data Jpa 도 조회쿼리 자체를 읽기전용으로 들고오진 않는다.
- 앞으로 Data Jpa 같은 경우도 읽기전용 쿼리로 만들어야겠다.

서비스 레벨에서의 트랜잭션이 읽기전용이 아니더라도 조회 쿼리자체에 읽기 전용으로 설정한다면 조금이라도 성능의 이점을 가져올 수 있지 않을까?

뒤늦게 생각된 문제점

쿼리힌트가 조회로 설정된 경우, 쿼리힌트가 조회인지 아닌지 여부를 고려해서 개발을 해야하는 불필요한 행동이 필요할 것 같다.

그냥 쿼리힌트를 다는것말고, 서비스단에서 트랜잭션으로 관리하는게 나을 것 같기도하다..

읽기전용이 아닌 경우에 대량의 조회가 필요한 경우에만 별도의 메서드를 만드는게 어떨까도 싶다.

Uploaded by N2T

[코틀린 ] 5525 IOIOI [문자열]

OverTheHorizon3410 — Sat, 2 Mar 2024 00:05:41 +0900

package 알고리즘.백준.IOIOI

import java.io.BufferedReader

/**
 *packageName    : 알고리즘.백준.IOIOI
 * fileName       : Main
 * author         : ipeac
 * date           : 2024-03-01
 * description    :
 * ===========================================================
 * DATE              AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2024-03-01        ipeac       최초 생성
 */
fun main() {
    BufferedReader(System.`in`.reader()).use { br ->
        val n = br.readLine().toInt()
        val m = br.readLine().toInt()
        val s = br.readLine()
        
        var answer = 0
        var patternCount = 0
        var index = 0
        
        while (index < m - 1) {
            if (s[index] == 'I' && s[index + 1] == 'O' && index + 2 < m && s[index + 2] == 'I') {
                patternCount++
                
                if (patternCount == n) {
                    answer++
                    //패턴이 겹칠 가능성이 있기에, 카운트를 하나 줄인다. ( 이전 카운트를 기억할 수 있음 (효율))
                    patternCount--
                }
                
                index += 2
            } else {
                patternCount = 0
                index++
                
                // I 를 만날때까지 index를 증가시킨다.
                while (index < m && s[index] != 'I') {
                    index++
                }
            }
        }
        
        println(answer);
    }
}

Uploaded by N2T

[코틀린] 21736 헌내기는 친구가 필요해

OverTheHorizon3410 — Fri, 1 Mar 2024 01:07:29 +0900

package 알고리즘.백준.헌내기는친구가필요해

import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.util.*

val dx = intArrayOf(-1, 1, 0, 0)
val dy = intArrayOf(0, 0, -1, 1)

data class Position(val x: Int, val y: Int)

fun main() {
    val reader = BufferedReader(InputStreamReader(System.`in`))
    val writer = BufferedWriter(OutputStreamWriter(System.out))

    reader.use { r ->
        writer.use { w ->
            val (n, m) = r.readLine().split(" ").map { it.toInt() }
            val graph = Array(n) { CharArray(m) }
            val visited = Array(n) { BooleanArray(m) { false } }

            var doyeon = Position(0, 0)

            for (i in 0 until n) {
                val line = r.readLine()
                for (j in 0 until m) {
                    val value: Char = line[j]

                    if (value == Tile.DOYEON.value) {
                        doyeon = Position(i, j)
                    }

                    graph[i][j] = value
                }
            }

            bfs(graph, visited, doyeon, n, m).let { if (it > 0) println(it) else println("TT") }
        }
    }
}

fun bfs(campus: Array<CharArray>, visited: Array<BooleanArray>, doyeon: Position, n: Int, m: Int): Int {
    val queue: LinkedList<Position> = LinkedList()
    queue.add(doyeon)
    visited[doyeon.x][doyeon.y] = true

    var count = 0

    while (queue.isNotEmpty()) {
        val (x, y) = queue.poll()

        for (i in 0 until 4) {
            val nx = x + dx[i]
            val ny = y + dy[i]

            if (nx in 0 until n && ny in 0 until m && !visited[nx][ny]) {
                when (campus[nx][ny]) {
                    Tile.EMPTY.value -> {
                        visited[nx][ny] = true
                        queue.add(Position(nx, ny))
                    }

                    Tile.PERSON.value -> {
                        count++
                        visited[nx][ny] = true
                        queue.add(Position(nx, ny))
                    }
                }
            }
        }
    }

    return count
}

enum class Tile(val value: Char) {
    EMPTY('O'),
    WALL('X'),
    DOYEON('I'),
    PERSON('P')
}

현실을 넘어

[블로그 이사] https://velog.io/@qkrtkdwns3410/posts

ㅇ

# [전자정부프레임워크] 3.5 → 4.0 마이그레이션 및 호환성 인증

[코틀린 인 액션] 4.2.2 __부 생성자: 상위 클래스를 다른 방식으로 초기화__

코틀린 생성자 vs 자바 생성자

부 생성자가 필요한 경우

예시

생성자 위임 방식

모든 부 생성자는 상위 클래스를 초기화하거나 다른 생성자에게 생성을 위임하는 역할을 해야합니다!

[코틀린 인 액션] 4.2.3 인터페이스에 선언된 프로퍼티 구현

추상 프로퍼티 선언 예시

인터페이스에서 게터와 세터가 있는 프로퍼티 선언

클래스에서 구현된 프로퍼티와 접근자

[코틀린] 11727 __2×n 타일링 2__

[코틀린] 10866번 덱

ArrayDeck

[JPA] .setHint(QueryHints.READ_ONLY, true)

개요

방법

착안

뒤늦게 생각된 문제점

[코틀린 ] 5525 IOIOI [문자열]

[코틀린] 21736 헌내기는 친구가 필요해

[코틀린 인 액션] 4.2.2 부 생성자: 상위 클래스를 다른 방식으로 초기화

[코틀린] 11727 2×n 타일링 2