kimkata's Devlog

한 입 크기로 잘라먹는 Next 강의 이벤트!

김까따 — Mon, 12 Aug 2024 13:33:28 +0900

이전에 한 입 크기로 잘라먹는 리액트 강의 쿠폰을 받아 샀었다가 볼 일이 있겠거니 하고 묻어뒀던 강의 ..

최근에 이직을 하고 프론트까지 개발해야 하다보니 허겁지겁 인프런 강의를 꺼내봤다.

스프링 백엔드 개발자로서 프론트는 완전 처음이라 갈피를 못 잡았었는데 이정환님의 한입크기 강의가 굉장히 도움이 됐었다.

이번에 Next.js 로 프로젝트를 진행해야 하는 상황이 왔는데 마침 정환님께서 또 강의를 출시 예정이라고 한다..!!

https://www.winterlood.com/post/%EC%82%AC%EC%A0%84%20%EB%93%B1%EB%A1%9D%20%EC%9D%B4%EB%B2%A4%ED%8A%B8%20-%20%ED%95%9C%20%EC%9E%85%20%ED%81%AC%EA%B8%B0%EB%A1%9C%20%EC%9E%98%EB%9D%BC%EB%A8%B9%EB%8A%94%20Nextjs

사전등록 이벤트 - 한 입 크기로 잘라먹는 Next.js(15+) - Winterlood

사전등록 이벤트 - 한 입 크기로 잘라먹는 Next.js(15+) - 신청자 전원 50% 할인 쿠폰 증정 “한 입 크기로 잘라먹는 Nextjs” 사전 등록 이벤트

www.winterlood.com

사전등록 이벤트로 50% 할인에 추첨으로 100% 할인 쿠폰까지 준다고하니 많관부..!

https://smore.im/form/gIl1v0ftOn

감사합니다 .. 감사합니다 ..

[BOJ] 백준 [21318] 피아노 체조 JAVA

김까따 — Sat, 22 Jun 2024 23:25:02 +0900

https://www.acmicpc.net/problem/21318

문제

풀이

package programmers;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import static java.util.Arrays.stream;

public class Main {

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    public static void main(String[] args) throws IOException {

        int n = Integer.parseInt(br.readLine());
        int[] arr = stream(("0 "+br.readLine()).split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();
        int[] dp = new int[n+1];
        arr[0] = arr[1];

        for(int i=1;i<=n;i++){

            if(arr[i] < arr[i-1]){ // i-1 번째 곡이 i 곡보다 더 어렵다면 i-1 번째에 실수 +1
                dp[i-1]++;
            }
            dp[i] = dp[i-1]; // i번째 기본값으로 이전 i-1 번째 실수 누적 합으로 넣기
        }
        int queryCount = Integer.parseInt(br.readLine());
        StringBuilder result = new StringBuilder();

        for(int i=0;i<queryCount;i++){

            int[] query = stream(br.readLine().split(" "))
                    .mapToInt(e -> Integer.parseInt(e)-1)
                    .toArray();
            // 전 구간 -1 한 이유
            // 마지막 곡에선 실수를 하지 않기때문에 마지막 곡 그 전 인덱스 까지만 본다.
            // 첫 곡 이전 실수 까지 가져와야하기 때문에 첫 곡 그 전 인덱스 까지만 본다.

            result.append(dp[query[1]] - dp[query[0]]+"\n");
        }
        System.out.println(result);
    }
}

[AWS RDS] mysql: table doesn't exist

김까따 — Tue, 30 Jan 2024 17:04:00 +0900

1. 문제상황

Spring 백단에서 프로퍼티별 개발환경을 나누고 로컬에선 H2db, 개발서버에선 aws rds mysql 8.0 을 사용하도록 datasource를 연결하였다.
그리고 h2db쪽에서는 쿼리가 잘 날라가는 걸 확인.
테스트 완료후 ec2에 배포하고 개발서버에서 실행했는데 table이 없다고 나옴.

2. 시도한 방법들

- JPA Naming Strategy

기본적으로 아무런 설정을 하지 않으면 @Table 의 지정한 name 이 대 소문자를 구분하여 쿼리가 날라간다. 즉 , mysql 에서는 테이블 명이 USERS 였고 JPA entity 의 name 은 users 였기 때문에 테이블을 찾지 못하는것.

그래서 별도의 namingStrategy를 프로퍼티에서 지정해주거나 엔티티에서 Table name을 지정할 때 대문자로하면 된다..
그러나 DB tool 내에서의 쿼리콘솔에서도 대소문자 구분하고 싶지 않은데 ... 일단 근본적인 해결방법은 아닌 것 같다.

- lower_case_table_names

mysql 에서 테이블이름에 대해 대 소문자를 구분하는지에 대한 설정을 할 수 있다.
mysql 이 설치된 경로로 들어가 my.cnf 에서 lower_case_table_names = 1 로 설정하면 되지만 AWS RDS에서는 할 수 없기 때문에 RDS 파라미터 설정에서 바꿔줘야한다.

0 -> 1 로 변경.

뭣 ..

파라미터 그룹이 연결되어있어서 변경이 안된다니깐 default 로 다시 바꾸고 파라미터 수정 재시도.

뭣..

찾아보니 mysql 8.0 부터는 DB를 최초 생성했을 때만 설정할 수 있다고 나온다..
https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MySQL.KnownIssuesAndLimitations.html#MySQL.Concepts.ParameterNotes

Known issues and limitations for Amazon RDS for MySQL - Amazon Relational Database Service

Some existing DB instances have a lower limit. For example, MySQL DB instances created before April 2014 have a file and table size limit of 2 TB. This 2 TB file size limit also applies to DB instances or read replicas created from DB snapshots taken befor

docs.aws.amazon.com

3. 결론

결론적으로 내가 손 댈수 있는건 네이밍 전략밖에 없었다.
application.yml 의 physical-strategy를 CustomNamingStrategy 를 PhysicalNamingStrategy 인터페이스를 구현받아 사용하여 해결하였다.

package com.greenroom.server.api.utils;

import org.hibernate.boot.model.naming.Identifier;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;

public class JpaCustomPhysicalNamingStrategy implements PhysicalNamingStrategy {

    @Override
    public Identifier toPhysicalCatalogName(final Identifier identifier, final JdbcEnvironment jdbcEnv) {
        if(identifier == null){
            return null;
        }
        return convertToSnakeCase(identifier);
    }

    @Override
    public Identifier toPhysicalColumnName(final Identifier identifier, final JdbcEnvironment jdbcEnv) {
        if(identifier == null){
            return null;
        }
        return convertToSnakeCase(identifier);
    }

    @Override
    public Identifier toPhysicalSchemaName(final Identifier identifier, final JdbcEnvironment jdbcEnv) {
        if(identifier == null){
            return null;
        }
        return convertToSnakeCase(identifier);
    }

    @Override
    public Identifier toPhysicalSequenceName(final Identifier identifier, final JdbcEnvironment jdbcEnv) {
        if(identifier == null){
            return null;
        }
        return convertToSnakeCase(identifier);
    }

    @Override
    public Identifier toPhysicalTableName(final Identifier identifier, final JdbcEnvironment jdbcEnv) {
        if(identifier == null){
            return null;
        }
        return convertToSnakeCaseAndUpperCase(identifier);
    }

    private Identifier convertToSnakeCase(final Identifier identifier) {
        final String regex = "([a-z])([A-Z])";
        final String replacement = "$1_$2";
        final String newName = identifier.getText()
                .replaceAll(regex, replacement)
                .toLowerCase();
        return Identifier.toIdentifier(newName);
    }

    private Identifier convertToSnakeCaseAndUpperCase(final Identifier identifier) {
        final String regex = "([a-z])([A-Z])";
        final String replacement = "$1_$2";
        final String newName = identifier.getText()
                .replaceAll(regex, replacement)
                .toUpperCase();
        return Identifier.toIdentifier(newName);
    }
}

적용해보면 from 절의 테이블 지정이 대문자로 바뀌어있는 것을 볼 수 있다.

[Spring] java.lang.NoSuchFieldError: Class com.sun.tools.javac.tree.JCTree$JCImport ...

김까따 — Sun, 29 Oct 2023 16:21:56 +0900

스프링부트를 안 쓰고 간단한 라이브러리를 만드는 도중 다음과 같은 문제 발생.

What went wrong:
Execution failed for task ':compileJava'.
> java.lang.NoSuchFieldError: Class cohttp://m.sun.tools.javac.tree.JCTree$JCImport does not have member field 'cohttp://m.sun.tools.javac.tree.JCTree qualid'

환경변수로 자바 버전이 21 이상인 경우에 gradle build 하니깐 자꾸 실패하길래 관련 글 서칭

https://github.com/projectlombok/lombok/issues/3393

[BUG] lombok 1.8.26 incompatible with JDK21 · Issue #3393 · projectlombok/lombok

Describe the bug Lombok 1.8.26 does not work with JDK21 (EA build 16) To Reproduce import lombok.Data; @Data public class Person { private String name; } $ javac -version javac 21-ea $ javac -cp lo...

github.com

lombok 버전을 1.18.30 으로 올리고 다시 빌드

성공

[프로그래머스] [Level2] 가장큰수 JAVA

김까따 — Tue, 10 Oct 2023 15:17:45 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42746

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제

풀이

가장 큰 수를 만들기 위해서 배열안의 수를 큰 수가 될 수 있는 조건으로 정렬을 해야한다.
만약 [ 3, 30, 34 ] 안의 우위를 정할 때 기준운 문제에 나와 있듯이 각각 수를 이어 붙였을 때 제일 큰 수로 하면 되므로 정렬 조건은 (s1, s2) -> (s2 + s1).compareTo(s1 + s2)

추가로 [0, 0, 0, 0] 일 경우엔 0만 리턴하도록 예외처리.

import java.util.Arrays;
import java.util.List;
class Solution {
    public String solution(int[] numbers) {
        List<String> result = Arrays.stream(numbers)
                .mapToObj(String::valueOf)
                .sorted((s1, s2) -> (s2 + s1).compareTo(s1 + s2))
                .toList();
        return result.get(0).equals("0") ? "0" : String.join("", result);
    }
}

[BOJ] 백준 [15486] 퇴사 2 JAVA

김까따 — Fri, 6 Oct 2023 17:21:08 +0900

https://www.acmicpc.net/problem/15486

15486번: 퇴사 2

첫째 줄에 N (1 ≤ N ≤ 1,500,000)이 주어진다. 둘째 줄부터 N개의 줄에 Ti와 Pi가 공백으로 구분되어서 주어지며, 1일부터 N일까지 순서대로 주어진다. (1 ≤ Ti ≤ 50, 1 ≤ Pi ≤ 1,000)

www.acmicpc.net

문제

풀이

하루씩 순차적으로 진행하면서 특정 일의 상담을 진행하고 나서 받는 총 합 이익을 갱신 시켜주면 된다.
특정일을 i
상담 걸리는 시간을 A(i)
페이를 P(i)
페이 총합을 S(i) 라고 했을 때 점화식은
S(i + A(i)) = max( S(i + A(i)), S(i)+P(i) ) 가 된다.

추가로)
i 의 범위는 i 번째 상담을 끝 났을 때 i+1 일에 정산 받는다는 걸 가정하여 n+1 까지.
해당 점화식은 상향식으로 하고 있기 때문에 기록한 최대 페이를 지나온 곳 까지 기록하기 위해 maxPay 를 계속 갱신.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {


    static int n;
    static int[] dp;
    static Consult[] arr;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());
        dp = new int[n+2];
        arr = new Consult[n+2];
        for(int i=1;i<=n;i++){
            arr[i] = new Consult(br.readLine());
        }
        arr[n+1] = new Consult("0 0");

        int maxPay = Integer.MIN_VALUE;
        for(int i=1;i<=n+1;i++){

            if(maxPay < dp[i]){
                maxPay = dp[i];
            }

            if(arr[i].days+i > n+1)
                continue;

            dp[arr[i].days+i] = Math.max(dp[arr[i].days+i],maxPay+arr[i].pays);
        }

        System.out.println(maxPay);
    }

    static class Consult{
        int days;
        int pays;

        public Consult(String in) {
            int[] input = Arrays.stream(in.split(" "))
                     .mapToInt(Integer::parseInt).toArray();
            this.days = input[0];
            this.pays = input[1];
        }
    }
}

[프로그래머스] [Level2] 과제진행하기 JAVA

김까따 — Sun, 17 Sep 2023 16:54:36 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/176962#

프로그래머스

programmers.co.kr

문제

풀이

과제 진행의 우선순위는 1. 시간 2. 최근에 멈춘 과제 이다.

1. 과제를 시간순으로 먼저 정렬해두고 하나씩 진행

2. 현재 과제를 딜레이 시키지 않고 처리할 수 있는 경우 처리
2-1. 밀린 과제가 있는 경우 밀린 과제 스택에서 하나를 꺼내서 다음 처리 과제 대상에 넣음
2-2. 밀린 과제가 없는 경우 다음 과제를 진행

3. 현재 과제를 딜레이 시켜야 할 경우는 현재 시간과 다음과제 시작시간을 비교해서 시간차이만큼 처리하고 스택에 다시 삽입.

4. 시간순 과제 리스트가 빌 경우 밀린 과제를 하나씩 꺼내서 처리

import java.time.LocalDateTime;
import java.time.Month;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

public class Solution{

    private LinkedList<Plan> list = new LinkedList<>();
    private Stack<Plan> delayPlans = new Stack<>();
    private ArrayList<String> answer = new ArrayList<>();
    public String[] solution(String[][] plans) {

        list = Arrays.stream(plans)
                .map(Plan::new)
                .sorted((o1, o2) -> o1.time.compareTo(o2.time))
                .collect(Collectors.toCollection(LinkedList::new));

        LocalDateTime currentTime = null;
        boolean delayedPlanProcFlag = false;

        while (!list.isEmpty() || !delayPlans.isEmpty()) {

            Plan plan = null;
            
            if(delayedPlanProcFlag){
                plan = delayPlans.pop();
                delayedPlanProcFlag = false;
            }else{
                plan = list.poll();
                currentTime = plan.time;
            }

            if(!list.isEmpty()){
                Plan nextPlan = list.peek();
                LocalDateTime estimatedTime = currentTime.plusMinutes(plan.duration);

                int criteria = estimatedTime.compareTo(nextPlan.time);

                if(criteria > 0){ // 현재 plan 의 duration 을 처리 못할 경우
                    delayPlans.add(plan.processPlanPartial(currentTime,nextPlan.time));
                }else{
                    answer.add(plan.name);

                    if(criteria < 0 && !delayPlans.isEmpty()){
                        delayedPlanProcFlag = true;
                        currentTime = estimatedTime;
                    }
                }
            }else{
                answer.add(plan.name);
                while (!delayPlans.isEmpty()){
                    answer.add(delayPlans.pop().name);
                }
            }

        }
        return answer.toArray(String[]::new);
    }


    static class Plan{
        String name;
        LocalDateTime time;
        int duration;

        public Plan(String[] plan){
            this.name = plan[0];
            String[] splitTime = plan[1].split(":");
            this.time = LocalDateTime.of(0, Month.JANUARY,1,Integer.parseInt(splitTime[0]), Integer.parseInt(splitTime[1]));
            this.duration = Integer.parseInt(plan[2]);
        }
        public Plan processPlanPartial(LocalDateTime currentTime, LocalDateTime nextPlanTime){
            long diff = Math.abs(ChronoUnit.MINUTES.between(nextPlanTime, currentTime));
            this.duration -= diff;
            return this;
        }
    }
}

사람인 기업 필터링 기능 만들기 (with Tampermonkey)

김까따 — Sat, 2 Sep 2023 01:07:43 +0900

Tampermonkey

Tampermonkey는 웹 브라우저 확장 프로그램(chrome extention) 중 하나로, 주로 사용자가 웹 페이지의 동작을 수정하거나 개선하기 위해 스크립트를 실행할 수 있게 해주는 도구이다. Tampermonkey는 대부분의 주요 웹 브라우저에서 사용할 수 있으며, 사용자 지정 스크립트를 실행하여 웹 페이지에 자신만의 기능을 추가하거나 웹 사이트의 동작을 수정할 수 있다.

Tampermonkey를 사용하면 할 수 있는 것들:

1. 사용자 지정 스크립트 실행: Tampermonkey를 통해 웹 페이지에 JavaScript 스크립트를 삽입하고 실행가능. 이를 통해 웹 페이지의 내용을 수정하거나 기능을 확장할 수 있다.

2. 광고 차단: Tampermonkey를 사용하여 광고 차단 스크립트를 실행하면 광고를 숨기거나 제거가능.

3. 웹 페이지 개선: Tampermonkey를 사용하여 웹 페이지의 사용자 경험을 개선하거나 특정 기능을 추가할 수 있음.
ex. 웹 페이지의 테마를 변경

4. 사용자 지정 스크립트 저장 및 관리: Tampermonkey는 사용자가 작성한 스크립트를 저장하고 관리하는 기능을 제공.

Tampermonkey를 사용하려면 먼저 해당 브라우저 확장 프로그램 스토어에서 Tampermonkey 확장을 설치해야함.
그런 다음 원하는 스크립트를 작성하거나 Tampermonkey 스크립트 저장소에서 다른 사용자가 작성한 스크립트를 가져와 사용이 가능.

사람인 기업 필터링 기능 추가해보기

구직 플랫폼 중 하나인 사람인에서 애드블록 처럼 안 보고 싶은 기업의 공고 (악성 기업이나 인력장사 보도방 공고) 는 계속 안보이게 하고싶어서 이 Tampermonkey를 이용하여 필터링 하는 기능을 스크립트를 작성하여 만들어 볼 것이다.

우선 Tampermonkey 를 설치하고

https://chrome.google.com/webstore/detail/tampermonkey/dhdgffkkebhmkfjojejmpbldmpobfkfo?hl=ko

Tampermonkey

Change the web at will with userscripts

chrome.google.com

밑의 openuserJS 링크에 들어가서 유저스크립트를 설치만 하면 된다.

( 계속 업데이트 중)
https://openuserjs.org/scripts/katastrophe/jobBlocking_saramin_ver_0.1

About | jobBlocking_saramin_ver_0.1 | Userscripts | OpenUserJS

Are you sure you want to flag this script for potential inspection by a Moderator?

openuserjs.org

우측 상단의 install 클릭후 설치를 누르면 끝.

구현 과정

( 글 접어 놨습니다. )

새 스크립트 만들기 클릭

// ==UserScript==
// @name         New Userscript
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        http://*/*
// @icon         data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

    // Your code here...
})();

저기 function 안에 작동 시킬 원하는 스크립트를 적으면 된다.

중요한건 위의 Userscript 의 메타블록 작성인데 필수 메타태그는 공식문서를 참조하면 된다.

https://www.tampermonkey.net/documentation.php?locale=en

Documentation | Tampermonkey

Documentation

www.tampermonkey.net

사람인 기업 필터링 스크립트 완성본

// ==UserScript==
// @name         jobBlocking_saramin_ver_0.1
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       katastrophe - nicebyy@naver.com
// @match        https://www.saramin.co.kr/zf_user/jobs/list/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=tampermonkey.net
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_listValues
// @license MIT
// @copyright 2023, katastrophe (https://openuserjs.org/users/katastrophe)
// ==/UserScript==

(function () {

    let buttonMap = new Map();

    const createData = (key, element) => {

        const companyName = element.querySelector('.company_nm > a').innerText.replaceAll(' ', '');
        const jobDescription = element.querySelector('.notification_info > .job_tit > a > span').innerText.replaceAll(' ', '');

        const jobInfo = {
            key: key,
            companyName: companyName,
            jobDescription: jobDescription
        };
        return jobInfo;
    };

    const createButton = (key, element) => {

        let button = document.createElement('button');
        // html
        button.type = 'button';
        button.innerHTML = key;
        button.className = 'btn_del';

        //css
        button.style.marginTop = '2px';
        button.style.marginRight = '8px';

        button.style.display = 'inline-block';
        button.style.marginLeft = '4px';
        button.style.width = '13px';
        button.style.height = '17px';
        button.style.verticalAlign = 'top';
        button.style.fontSize = '0';
        button.style.background = 'url(//www.saraminimage.co.kr/sri/person/search_panel/spr_search_panel.png) no-repeat 2px -186px';

        const divBox = element.querySelector('.company_nm');
        divBox.style.width = '200px';
        const pos = element.querySelector('.company_nm > .interested_corp');

        divBox.insertBefore(button, pos);
        button.addEventListener("click", () => {

            let result = GM_getValue(key, null);

            if (result == null) {
                element.style.display = 'none';
                GM_setValue(key, createData(key, element));
                buttonMap.set(key, false);
                displayAllJobs(false);
            }
        });
    };

    const displayAllJobs = (isInit) => { // Find all job elements

        if(isInit){
            buttonMap = new Map();
        }
        const elements = document.querySelectorAll('[id^="rec-"]');

        elements.forEach(element => {
            const recId = element.getAttribute('id'); // jobKey
            const recValue = GM_getValue(recId, null);

            if (recValue !== null) { 
                element.style.display = 'none';

            } else if (isInit) {
                buttonMap.set(recId, true);
                createButton(recId, element);
            }

        });
    }

    const removeBlockingList = ()=>{
        for(let key of GM_listValues()){
            GM_deleteValue(key);
        }
    };

    const createRemoveButton = ()=>{

        let button = document.createElement('button');
        // html
        button.type = 'button';
        button.className = 'sri_btn_md';

        //css
        button.style.display = 'inline-flex';
        button.style.marginLeft = '-34%';

        let buttonText = document.createElement('span');
        buttonText.innerHTML = 'blocking 초기화';
        buttonText.className = 'sri_btn_immediately';

        button.appendChild(buttonText);

        const divBox = document.querySelector('.list_info');
        const pos = document.querySelector('.list_select');

        divBox.insertBefore(button, pos);
        button.addEventListener("click", () => {

            if (!confirm("Blocking List 를 초기화 합니다..")) {
                alert("취소를 누르셨습니다.");
            } else {
                alert("초기화 완료.");
                removeBlockingList();
                location.reload();
            }
        });
    }

    document.querySelector('#page_count').addEventListener("change", () => {
        setTimeout(function(){
            displayAllJobs(true);
        },1000);
    });
    document.querySelector('#sort').addEventListener("change", () => {
        setTimeout(function(){
            displayAllJobs(true);
        },1000);
    });
    if(document.querySelector('#show_applied_recruit')!=null){
        document.querySelector('#show_applied_recruit').addEventListener("change", () => {
            setTimeout(function(){
                displayAllJobs(true);
            },1000);
        });
    }
    document.querySelector('#filter_ai_head_hunting').addEventListener("change", () => {
        setTimeout(function(){
            displayAllJobs(true);
        },1000);
    });
    document.querySelector('#filter_quick_apply').addEventListener("change", () => {
        setTimeout(function(){
            displayAllJobs(true);
        },1000);
    });
        'use strict';
        createRemoveButton();
        displayAllJobs(true);
    
})();

지우기 전

지역별로 검색을 했을 때 못 보던 X 표시와 blocking 초기화 버튼이 보일 것이다.

맨 상단 공고 하나를 지워보면

지운 후

다음과 같이 없어진다. 만약 다시 보이게 하고 싶으면 blocking 초기화 버튼을 누르면 된다.

데이터 관련 스토리지는 GM 관련 내부 Strorage API 를 사용하였다.

데이터를 확인하고 싶다면 설정에서 모드를 상급자로 변경 뒤

다시 에디터쪽으로 가보면 Storage 탭이 새로 생긴 것을 볼 수 있다.

저장포맷은 Key-value 방식의 Json 을 사용하는 듯 하다.

구현하면서 아쉬운점은 상단에 페이징 옵션이나 필터링 관련 기능쪽인데

페이징 방식을 변경할 때 버튼이 생성되고나서 새로운 페이징결과가 적용되기 때문에 이는 직접제어 할 수 없어서 setTimeout 을 이용하여 1초뒤에 버튼이 보이게 만들었다. 네트워크 환경이 불안정하거나 페이지를 불러오는데 1초이상 걸린다면 적용이 안될 수도 있다.

그럴땐 소스 내부의 setTimeout 시간을 1000( 1000ms = 1초 ) 보다 높은 값으로 설정하면 동작한다.

나중에 내가 차단했던 기업을 골라서 다시 취소할 수 있는 기능을 시간나면 만들어 볼 예정이다.

[Spring] Websocket 과 ReverseProxy

김까따 — Fri, 11 Aug 2023 19:32:01 +0900

Websocket

말 그대로 Web 을 이용한 Socket 통신이다. 즉 , HTTP 통신을 이용한다.
웹 브라우저 <-> WAS 간의 실시간 양방향 통신을 위해 사용한다.
처음 핸드쉐이크를 요청할 때 까진 HTTP 와 통신과정이 같고 그 이후엔 TCP 커넥션을 이용하여 실시간으로 통신한다는 것이 특징이다.

여기서 특별한 헤더가 추가 된다는 것이 특징인데 , Upgrade 헤더이다.
HTTP 요청 헤더에서 Websocket 통신을 위해 Upgrade 헤더를 추가해서 요청을 보내는데 이 요청이 WAS 쪽에서 받아 들여져야 그 이후 ws:// or wss:// 프로토콜을 통해 양방향 통신이 가능한 상태가 된다.

Reverse Proxy

웹 소켓 서버 정보를 클라이언트쪽에서 (js 단에서) 가지고 있는 것은 상당히 위험하다. 즉 , 웹 클라이언트에서는 실제로 내가 접속하고 있는 서버의 정보를 몰라야 한다는 것이 보안측면에서도 안전하다.

그래서 사용된 방식이 ReverseProxy 방식인데 엔드 유저들은 실제 웹 소켓서버로 요청을 보낼 때 예를 들어 Backend Server 1 의 ip 와 port 로 직접적으로 요청이 하는 방식이 아닌 우선 웹 서버 80 포트로 요청을 보내면 아파치 서버의 conf 설정을 통해 실제 Was 로 포워딩 되는 방식으로 요청이 가게 하는 방식이다. 이를 리버스 프록싱 방식이라고 한다.

Apache 설정

<Virtualhost *:80>
	ProxyPreserveHost On
	ProxyRequests Off

	RewriteEngine On
    RewriteCond ${HTTP:Upgrade} websocket [NC]
  	RewriteCond ${HTTP:Connection} upgrade [NC]
    
	RewriteRule /(.*\/websocket) ws://localhost:8090/$1 [P,L]
	RewriteRule /(.*) http://localhost:8090/$1 [P,L]
    
	ProxyPass / http://localhost:8090/
	ProxyPassReverse / http://localhost:8090/
</VirtualHost>

실제 우리 서버 아파치 설정을 보여주긴 보안상 좀 그러니 예시중 일부를 가져왔다.
HTTP 요청으로 엔드포인트가 /websocket 으로 끝난다면 ws://localhost:8090 으로 요청을 돌려버린다는 설정이다.

즉 , 메인도메인으로 요청할 때 엔드포인트에 따라서 프록시을 적용할 지 말지를 결정할 수 있다는 것이다.
그러나 이것을 적용할 때 문제점이 있었다.

/websock 처럼 엔드포인트로 프록시 조건이 들어갈 때 HTTP 요청도 받을 수 있게 해야한다는 것.
다시말해, 웹 소켓 통신만 한다고 해서 ws:// 로 무조건 보내면 처음 HTTP 핸드쉐이크를 실패한다는 것이다.

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/websock").setAllowedOrigins("*").setHandshakeHandler(new WSHandShakeHandler()).withSockJS();
    }
}

웹 소켓 서버의 Configuration 쪽에서 endPoint 를 /websock 으로 받게 했기 때문에 apache conf 파일의 내용을 다음과 같이 순서를 변경한다.
이렇게 하지 않으면 만약 SockJs를 쓰는 경우엔 웹 클라이언트단에서 콘솔 오류로 info?t=~~~ 404 not Found 를 뱉을 것이다.

<Virtualhost *:80>
	ProxyPreserveHost On
	ProxyRequests Off

	RewriteEngine On
    RewriteCond ${HTTP:Upgrade} websocket [NC]
  	RewriteCond ${HTTP:Connection} upgrade [NC]
    
    RewriteRule /(.*) http://localhost:8090/$1 [P,L]
	RewriteRule /(.*\/websocket) ws://localhost:8090/$1 [P,L]
    
	ProxyPass / http://localhost:8090/
	ProxyPassReverse / http://localhost:8090/
</VirtualHost>

[Spring] Redisson Remote Service 분해해보기

김까따 — Sun, 25 Jun 2023 21:51:15 +0900

Redisson

Reddison 은 Redis 의 클라이언트중 하나로 Jedis, Lecttuce 와 같은 ‘분산’ 서비스 또는 락을 중점으로 이용할 때 사용된다. 이번 포스팅은 락 관련은 넘어가고 Remote Service 에 대해 포스팅하고자 한다.

Redisson Remote Service

기존의 다른 Redis 클라이언트로는 할 수 없었던 Redisson 의 분산 서비스의 특징이다.
RemoteService 는 크게 서버 인스턴스와 클라이언트 인스턴스로 두 종류로 구성되어있다.

위 그림과 같이 아래 클라이언트 인스턴스가 호출하고자 하는 서비스 인터페이스를 가지고 호출을하면 서버측 인스턴스에서 요청을 받아들이는 방식으로 작동한다.

프로젝트 생성

실행 환경 : springboot 3.1.0, Gradle, intellij, window10, Redis, Docker

Redis 설치하기

docker-compose 를 통해 간단하게 테스트용 로컬 레디스를 설치

window의 wsl2 를 이용하여 docker 를 구동하였음.

(mac 을 사용한다면 brew 와 같은 패키지 관리자를 설치후 docker를 설치하면 됨)

docker-compose.yml

version : '3.8'
services :
  redis-remoteService :
    container_name : redis-remoteService
    image : redis:latest
    restart: always
    ports: 
      - 6379:6379

프로젝트 최상단위치에 docker-compose 파일을 넣어두고 백그라운드로 실행.

6379 포트로 잘 돌아가는 것을 확인. (Docker Desktop)

- P3x Redis UI 툴로 확인해보기 (혹은 Redis insight 를 추천)

커넥션 설정

SpringBoot 프로젝트 구성

스프링 프로젝트를 다음과 같이 Gradle 멀티모듈 프로젝트로 구성하였다. (이유는 나중에 설명)

1. 가장 바깥쪽 껍데기 Root 프로젝트인 remoteService 프로젝트
2. 요청을 받아 처리하는 서버 모듈인 redissonServer
3. 요청을 보내는 클라이언트 모듈인 redissonClient
4. Server 와 Client 가 공통적으로 사용하는 코드가 담인 공통묘듈 redissonCommon

remoteService - build.gradle
루트 프로젝트에서 하위 서브모듈들의 공통적인 dependency 들을 정의해준다.

buildscript {
	ext{
		springBootVersion = '3.1.0'
	}
	repositories {
		mavenCentral();
	}
	dependencies {
		classpath "org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}"
		classpath "io.spring.gradle:dependency-management-plugin:1.0.11.RELEASE"
	}
}

// 하위 모든 프로젝트 공통 세팅
subprojects {
	repositories {
		mavenCentral()
	}
	apply plugin: 'java'
	apply plugin: 'idea'
	apply plugin: 'org.springframework.boot'
	apply plugin: 'io.spring.dependency-management'

	group 'com.example'
	version '1.0-SNAPSHOT'

	sourceCompatibility = '17'

	dependencies {
		compileOnly 'org.projectlombok:lombok'
		implementation 'org.springframework.boot:spring-boot-starter-data-redis'
		annotationProcessor 'org.projectlombok:lombok'
		annotationProcessor "org.springframework.boot:spring-boot-configuration-processor"
		testImplementation 'org.springframework.boot:spring-boot-starter-test'
	}

	tasks.named('test') {
		useJUnitPlatform()
	}
	tasks.register("prepareKotlinBuildScriptModel"){}
}

redissonServer - build.gradle

bootJar {
    archiveFileName = 'redisson-client'
}

dependencies {
    implementation project(path: ":redissonCommon", configuration: 'default')
    implementation('org.springframework.boot:spring-boot-starter-web')
}

redissonCommon - build.gradle
공통모듈은 독립으로 존재 하지않고 server 나 client 에 항상 종속적이므로 bootJar = false 로 함

bootJar{enabled = false}
jar{enabled = true}

dependencies {
}

공통모듈 로드 확인하기

redissonCommon 프로젝트에 간단하게 ApplicationReadyEvent로 Member Entity 하나를 만들어서 redissonServer 모듈 실행 시 정상적으로 불러와지는지 확인해본다.

Redisson Common Module 작업하기

아까 추가한 Member 엔티티를 인자로 받아 이름을 바꿔주는 서비스인 RemoteMemberService의 인터페이스를 하나 만들겠다.

RemoteMemberServiceInterface.java

package com.example.redissoncommon.remote;


import com.example.redissoncommon.entity.Member;

public interface RemoteMemberServiceInterface {

    public void renameMember(Member member, String newName);
}

Redisson Remote Service 를 이용하기 위해선 Server 와 Client 가 같이 사용할 수 있는 인터페이스가 필요한데 Client쪽에서는 이 RemoteMemberServiceInterface 를 호출하는 방식으로 사용할 것이고 , Server 쪽에서는 RedissonRemoteService 에 이 인터페이스와 인터페이스를 구현한 서비스 클래스를 등록할 것이다.

Reddisson Server Module 작업하기

application.yml (redissonServer)

server:
  port: 7071
spring:
  data:
    redis:
      port: 6379
      host: redis://localhost

RemoteMemberService.java

package com.example.redissonserver.service;

import com.example.redissoncommon.entity.Member;
import com.example.redissoncommon.remote.RemoteMemberServiceInterface;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class RemoteMemberService implements RemoteMemberServiceInterface {
    @Override
    public Member renameMember(Member member,String newName){
        log.info("before rename => {} ",member);
        member.setName(newName);
        log.info("after rename => {}",member);
        return member;
    }
}

아까 공통모듈 패키지에서 만들어놓은 RemoteMemberServiceInterface 를 구현하는 클래스를 서버쪽 모듈에 추가한다.

RedissonConfiguration.java

package com.example.redissonserver.config;

import com.example.redissoncommon.remote.RemoteMemberServiceInterface;
import com.example.redissonserver.service.RemoteMemberService;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import org.redisson.Redisson;
import org.redisson.api.RRemoteService;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.EventListener;

@Configuration
@EnableCaching
@RequiredArgsConstructor
public class RedissonConfiguration {

    @Value("${spring.data.redis.host}")
    private String REDIS_HOST;

    @Value("${spring.data.redis.port}")
    private String REDIS_PORT;

    private final RemoteMemberService remoteMemberService;

    @Bean
    public RedissonClient redissonClient() {
        Config redisConfig = new Config();
        redisConfig.useSingleServer()
                .setAddress(REDIS_HOST + ":" + REDIS_PORT);
        return Redisson.create(redisConfig);
    }

    @EventListener(ApplicationReadyEvent.class)
    public void registerRemoteService(){
        RRemoteService remoteService = redissonClient().getRemoteService();
        remoteService.register(RemoteMemberServiceInterface.class,remoteMemberService);
    }
}

여기선 간단하게 RedisClient 에 필요한 설정들과 등록할 RemoteService 메서드를 WAS 가 실행될 때 등록되게 해놓았다.

설정부분에서 두 가지 특이사항이 있는데 첫 번째로 Config 부분이다. Config 부분에서 싱글서버로 등록할 때 여러 서버 형태를 체크해서 이미 존재하는지 확인한다.

보다시피 서버형태는 총 4개이다.

1.클러스터 모드 : 말 그대로 여러개의 Redis로 구성되어있는 레디스 클러스터를 사용하는 경우이다.

2.센티넬 모드 : 다운되었을 때 고가용성을위한 센티넬 모드로 사용할 경우이다.

3.마스터 슬레이브 모드 : 마스터-슬레이브 노드로 구성된 레디스 구성일 경우이다.

4.싱글 서버 모드 : 레디스 한 대로 모든 요청을 받는 용도로 사용할 경우 이다. 본 예제에서 사용할 모드이다.

그 외 프록시모드 , 멀티 클러스터 모드 등등 있는데 자세한건 공식 깃헙에 들어가면 나와있으니 참고.

두 번째 특이사항은 RRemoteService 에다가 등록할 RemoteService 를 등록하는 과정인데 기본 값은 요청이 들어올 때 하나의 스레드로만 처리하게 하는 옵션을 가지고 있다.

만약 멀티스레드로 동시에 여러개 처리를 원할 경우

사용할 workerAmount 수를 지정해 주면 된다.

혹은 별도의 ExcutorService 를 등록하고 싶을 경우

이런식으로 등록해 주면 된다.

클라이언트 모듈 작업하기

클라이언트쪽에서는 간단하게 Member 객체를 생성하는 부분과 이름을 바꾸는 부분이 있는 Service 클래스와 요청을 받는 Controller 로 구성하였다.

application.yml (redissonClient)

server:
  port: 7070
spring:
  data:
    redis:
      port: 6379
      host: redis://localhost

RedissonConfiguration.java

package com.example.redissonclient.config;

import com.example.redissoncommon.remote.RemoteMemberServiceInterface;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.api.RemoteInvocationOptions;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class RedissonConfiguration {

    @Value("${spring.data.redis.host}")
    private String REDIS_HOST;

    @Value("${spring.data.redis.port}")
    private String REDIS_PORT;

    @Bean
    public RedissonClient redissonClient() {
        Config redisConfig = new Config();
        redisConfig.useSingleServer()
                .setAddress(REDIS_HOST + ":" + REDIS_PORT);
        return Redisson.create(redisConfig);
    }

    @Bean
    public RemoteMemberServiceInterface remoteMemberService(){
        // 호출할 RemoteMemberService 를 RedisClient 로 부터 호출 하는 부분
        return redissonClient()
                .getRemoteService()
                .get(RemoteMemberServiceInterface.class, RemoteInvocationOptions.defaults()
//                        .noAck().noResult() // 변환 결과가 없을 경우 추가할 수 있는 옵션. blocking 이 걸리지 않는다.
                );
    }
}

RemoteMemberService 를 Common 모듈의 인터페이스를 이용하여 Bean 으로 설정과 동시에 컨테이너에 올리도록 하였다. 사용하는 부분에서 저 인터페이스 빈을 사용하면 된다.

RemoteService 를 호출할 때 기본 값은 결과 값을 반환한다는 가정에 있다. 만약 반환 값이 있다면 추가로 설정해 줘야 하는것이 시간 관련된 부분이다.

없다면 noAck() , noResult() 로 설정해 주면 된다.

MemberService.java

package com.example.redissonclient.service;

import com.example.redissoncommon.entity.Member;
import com.example.redissoncommon.remote.RemoteMemberServiceInterface;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@Service
@RequiredArgsConstructor
@Slf4j
public class MemberService {

    private final AtomicLong memberIdSequence = new AtomicLong(0L);
    private final ConcurrentHashMap<Long,Member> memberDB = new ConcurrentHashMap<Long,Member>();

    private final RemoteMemberServiceInterface remoteMemberServiceInterface;

    public Member callRemoteRenameService(Member member,String name){

        if(member==null)
            throw new IllegalArgumentException("couldn't find member");
        return remoteMemberServiceInterface.renameMember(member,name);
    }

    public Member findMemberById(Long id){
        return Optional.ofNullable(memberDB.get(id))
                .orElse(null);
    }

    public Member createMember(String name){
        Member member = new Member(incrementSequence(), name);
        memberDB.put(member.getId(),member);
        return member;
    }

    private Long incrementSequence(){
        return memberIdSequence.incrementAndGet();
    }
}

여기서 중요한부분은 RemoteMemberServiceInterface 인터페이스의 메서드를 호출한다는 것이다.

MemberController.java

package com.example.redissonclient.controller;

import com.example.redissonclient.service.MemberService;
import com.example.redissoncommon.entity.Member;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@RequiredArgsConstructor
@RestController
@Slf4j
@RequestMapping("/member")
public class MemberController {

    private final MemberService memberService;

    @PostMapping("/create")
    public Member createMember(@RequestParam String name){
        Member member = memberService.createMember(name);
        log.info("created member => {}",member);
        return member;
    }

    @PostMapping("/rename")
    public Member renameMember(@RequestParam Long id,@RequestParam String name){
        Member findMember = memberService.findMemberById(id);
        return memberService.callRemoteRenameService(findMember,name);
    }
}

Postman 으로 요청 테스트

파라미터로 간단하게 hello 를 전달하여 새로운 Memer 객체를 생성한 후 newHello 로 이름을 바꾸는 테스트이다.

정상적으로 동작하는 것을 확인하였다. 그렇다면 어떻게 인터페이스의 메서드를 호출했는데 동작하는것인가?

RemoteService 동작 살펴보기

빈으로 올라와있는 인터페이스를 찍어보면 당연히 jdk 동적 프록시를 사용하고 있다.

보통 빈 컨테이너로 올릴 때 인터페이스를 이용하면 jdk 동적 프록시를 사용하고 class 그대로 이용하면 aop 가 동작해 CGLIB 로 올라간다.

인터페이스 메서드를 사용하는 부분에 debug 를 찍어보면

InvocationalHandler 가 동작하여 remoteInterface 의 getName()을 찾아 맞는 메서드를 호출한다.

그리고 getRequestQueueName 을 호출하는데

바로 이부분. ConcurrentCacheMap 으로 만들어진 요청큐 안에 특별한 키 값으로 요청을 넣는 것을 확인할 수 있다.

확인해 보니 {redisson_rs : ~~~ } 형태로 들어간다. 직접 확인해보기 위해 RemoteServer를 잠시 꺼보자. 그리고 Redis UI tool 에서 확인해보면

요런 모양으로 들어와 있는데 잘 보면 Key 값이 아까 본 모양이랑 똑같이 나와있다.

즉, 내부적으로 Key 를 생성할 때 결정자 중 하나가 “패키지 경로” 라는 것.

실제로 value 로 나와있는 저 값들도 다시 디코딩을 해보면 호출하는 메서드의 패키지 위치라던지 필요한 파라미터 또한 패키지경로 까지 포함한 값으로 들어오게 되어있다.

그래서 처음에 구조 설계를 할때 Common 공통 모듈을 생성한 것이다.

Server 와 Client 가 공통적으로 사용해야하는 RemoteMemberServiceInterface 가 Common 모듈 안에 있어야 RemoteServer 가 요청을 받은 후 에도 해당 패키지로 찾아가서 해당 메서드를 Call 할 수 있기 때문. 즉 , 공통 모듈 구조가 강제화 된다는 뜻이다.

이게 가장 큰 단점이라 만약 사용한다면 저 Common 모듈을 원격 전용 모듈로서 따로 분리하고 파라미터로 받는 Member 객체도 엔티티 그대로 사용하지 말고 별도의 Remote 전용 MemberDto 로 따로 컨버팅하고 사용하야 구조에 지나치게 의존적인 관계가 그나마 덜 해지는 것 같다.

참고로, Redisson Config을 설정할 때 내부적으로 Serialier 를 Kyro 를 사용하고있다.

저 Codec을 JsonJacksonCodec 으로 변경해서 데이터를 확인해보자.

보다시피 파라미터로 받는 Member 엔티티의 클래스 경로까지 모두 포함한다는 것이 보인다. 즉 , 도메인 주도 설계를 한 경우엔 쓰기 쉽지 않아 보이는 강제된 설계구조란 뜻이다.

내부적으로 Serializer 를 재 정의 하거나, 혹은 한다 하더라도 어떤 예상치 못한 문제가 발생할 지 알 수 없으므로 도입하기 애매한 기술인 것 같다.

결론적으로 만약 사용한다면 중요 트랜잭션로직의 속도를 중시한다면 인 메모리 기반 RemoteService 이므로 사용해도 괜찮겠지만 그게 아니라면 별도의 MessageQueue 를 이용하는 것이 좋아보인다.

https://github.com/nicebyy/RedissonRemoteService

GitHub - nicebyy/RedissonRemoteService

Contribute to nicebyy/RedissonRemoteService development by creating an account on GitHub.

github.com

[Spring] 동시성 관리와 락 병행제어 (Redisson, Mysql 네임드락)

김까따 — Fri, 7 Apr 2023 01:56:00 +0900

정말 오랜만에 블로그를 쓰는 것 같다. 쓰고 싶은 것들이 한 트럭인데 생각만하다가 흘러간 세월이 벌써 이렇게된듯..

틈틈이 이제 써 봐야겠다.

1. 병행제어

실무에서 동시성관리는 매우 중요하다. 특히나 내가 속한 팀인 거래소팀에서는 더욱 중요한 이슈이다.
이번에 하나의 Redis 서버에서 과부하가 자주 일어나서 개선하는 방향으로 작업을 하다보니 거래소 차트그리는 쪽을 손보게 되었다. 밑의 그림은 대형 거래소 차트 예시이다.

우리거래소는 코인 페어별로 (USDT, ETH, BTC) 등 차트를 그리는데 아무튼 각설하고 , 대충 차트를 그리는 서버가 여러개란 뜻이다. 각 서버는 1분 간격 스케쥴러로 동작하며, 차트를 그린다.

차트그리기 전용 데이터를 다루는 DB가 별도로 존재하며, 차트를 그리기위해 DB값을 업데이트하고 웹소켓을 이용하여 프론트단으로 데이터를 보내 실시간으로 시세가 변하는 것을 보여주기 위함이고, 여러개의 서버가 차트를 중복해서 그리거나 데이터를 보내면 안되므로 병행제어가 필요했다.

동시성관리를 위한 방법들은 여러개 있는데, JAVA 의 syncronized 메서드 블록을 이용한다던가 Atomic 타입을 사용해서 해결 할 수 있다.

하지만 이 방법은 같은 프로세스 내 에서 다른 스레드끼리 경쟁할때만 유효하고 애초에 서버가 다르면 결국 똑같은 문제를 발생시킨다.

그래서 병행제어를 위한 분산락이 필요한데 두 가지 방법을 소개하려한다.

2. 분산락

분산락은 대표적으로 Redis 나 주키퍼 , Mysql의 NamedLock 등이 있는데 기존엔 Redisson 클라이언트를 이용한 Lock 제어를 하였다.

[1] Redisson

Redis 클라이언트는 분산락을 이용하기위해 Redisson을 이용한 상태이다.

내가 원하는 key 값으로 락을걸면 정한 시간이나 동작이 완료될 때 까지 Redis 안에 key 값으로 락이 걸리게 되고

다른 서버들은 Redis에 접근할 때 이미 락이 걸려있기 때문에 중복작업을 하지 않게 된다.

Redis 내부 예시

하지만 아까 말했듯이 ( Redis를 이용한 원격 함수호출요청이 몇십만, 백만 까지 넘쳐나는 등 .. )

Redis 과부하를 줄이기 위한것이 목적이었기 때문에, 그리고 또 다른 문제점이 발견되어 Redisson 락을 버리기로 하였다.

1. Redis의 락은 Redis Transaction 행위 중 하나이고, 이는 connection을 계속 점유한다.

2. 다른 작업의 connection 때문에 락을 획득하기위한 connection을 실패하게 되어 락 획득 자체가 실패한다.

위 코드와 같이 한정된 connectionPoolSize 에 비해 차트를 그리는서버는 총 4개.. 즉 , 락을 잡고 처리하는데 병목이 발생한다.

우선 기본적으로 Redis는 싱글스레드 기반이라 별 상관없다고 생각할 수 있겠지만 유일하게 Connection에 영향을 끼치는게 Redis Transaction이다. ( Redis Transaction 참고 : https://sabarada.tistory.com/177)

락을 거는 행위는 Redis 의 WATCH 명령에 속하고 커넥션을 점유하게 되어 병목을 유발 시키거나 , Redis 의 다른 작업이 처리되느라 락 획득에 실패하는 경우가 발생하여서 다른 분산락을 이용하기로 하였다.

[2] MySQL NamedLock

마침 DB도 mysql 5.7 이상 버전을 사용하고 있었고, Redis 와 같은 인프라 관련 유지보수 비용도 만만치 않은 상태인데다가 우형 기술블로그가 도움이 많이 되어서 NamedLock을 이용하기로 하였다.

( 참고 : https://techblog.woowahan.com/2631/)

mysql NamedLock 으로 변경 후 코드

(중간 트랜잭션 과정은 대충 생략 ... )

중요한 곳은 NamedLock과 관련된 chartLockRepository 이다.

우선, JPA에서는 공식적으로 NamedLock 을 제공하지 않기때문에 native query를 이용해야 했다.

(관련 공식 레퍼런스 : https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html)

MySql 의 네임드 락 관련 함수는 총 세 가지를 사용했는데 ,

1. 락이 있는지 확인하는 쿼리 : select is_used_lock(key)

2. 락을 획득하는 쿼리 : select get_lock(key, time)

3. 락을 반환하는 쿼리 : select release_lock(key)

1 -> 2 -> 3 순서대로 락 관련 제어를 하였다.

1 : 락이 있는지 먼저 물어보고

2 : 락을 획득하여 트랜잭션을 처리 후

3 : 마지막에 락을 다시 반환

이렇게 방식을 바꾸고 나니, 락을 획득하는데 실패하는 경우가 이젠 더이상 나오지 않은데다가 Redis 의존을 떼어내어 부하를 조금 줄이게 되었다. 중간에 @Transactional 에 전파옵션을 Required_new 로 지정해 논 곳이 있는데 , 배치 작업을 하다 중간에 실패해도 해당 코인 외 나머지 차트그리는 작업까지 롤백이 되면 안되므로 전파옵션도 바꾸게 되었다.

아래는 GPT 한테 도움받은 몇가지 질문들

반박시 님말 맞음....!!

~~아 .. 팀장님좀 뽑아줬으면.. 잘 하고 있는건지 모르겠다..~~

그런데, 분명 1분동안 락을 점유하도록 했는데 처리시간이 1분이상 걸린건 뭔지 모르겠다.. 아시는 분 댓글부탁드려요..ㅠ

[Spring] Spring Redirect 가 동작하지 않는 이유

김까따 — Mon, 7 Nov 2022 12:41:59 +0900

문제상황

/product URL로 상품 등록이라는 동작을 한 뒤에 내가 등록한 상품 리스트로 redirect 명령을 내리려고한다.

보통, 이런 리다이렉션 같은 경우는 상품을 등록 후 새로고침을 수행하였을때

재 등록을 방지하기 위해서 사용하는데 소위 PRG (Post, Redirect, Get 이라고 부른다.)

상품 등록 코드

    @PostMapping("/new")
    @ResponseStatus(HttpStatus.CREATED)
    public String addProduct(
            @ModelAttribute ProductDto.CreateProduct createProduct,
            @AuthenticationPrincipal CustomUserDetails user,
            @RequestParam List<MultipartFile> productImages
    ) throws IOException {
        User currentUser = userService.findByUserId(user.getUserId());
        productService.registerProduct(currentUser,createProduct,productImages);

        return "redirect:/product";
    }

상품 등록을 모두 수행한 후, 상품 리스트를 보여주는 Url (/product) 로 Get요청을 하는 상황.

상품이 성공적으로 등록되었으면 201 상태코드를 반환을 동시에 수행

여기서 등록하기를 누르면 예상과 달리 리다이렉트를 수행하지 않는 문제의 상황이 발생한다.

곰곰히 생각해보니 Redirect 동작은 서버 => 브라우저 에게 내리는 명령이므로 결국 수행은 브라우저가 한다.

그 기준은 Post 수행후 반환된 상태코드를 기준으로 판별한다는 것.

따라서 다음과 같이 변경한다. (HttpStatus.CREATED => HttpStatus.FOUND)

    @PostMapping("/new")
    @ResponseStatus(HttpStatus.FOUND)
    public String addProduct(
            @ModelAttribute ProductDto.CreateProduct createProduct,
            @AuthenticationPrincipal CustomUserDetails user,
            @RequestParam List<MultipartFile> productImages
    ) throws IOException {

        User currentUser = userService.findByUserId(user.getUserId());
        productService.registerProduct(currentUser,createProduct,productImages);

        return "redirect:/product";
    }

다시 상품등록을 똑같이 요청하면 , 수행 후 정상적으로 redirect가 된 것을 확인할 수 있다.

[Spring] WebFlux 도입에 관한 이야기

김까따 — Thu, 3 Nov 2022 19:01:58 +0900

WebFlux 란 웹에서 Reactor의 스트리밍 처리를 담당하기 위해 Spring 5.0 부터 도입이 되었고
non-blocking 에 기반한 reactive streams 를 back pressure 와 함께 처리하여 동시에 많은 요청을 처리하기 위한 목적으로 나왔다.

이전의 Reactive streams는 low 레벨이기 때문에 API 에 있어서 유용하지 못했지만 Webflux에서 풍부한 라이브러리와 연산자들을 통해 서버사이드에 좀 더 집중할 수 있게 되었다.

WebFlux vs SpringMVC

기본적으로 SpringMVC는 멀티스레드에 기반한 명령형 프로그래밍 방식이다.
즉, 나타내고자 하는 기능을 분명하게 나눌 수 있고 디버깅이 쉬우며 유지보수가 편리하다.

그에 반해 WebFlux는 여러 Streams 복잡한 조합과 비동기적인 함수형 프로그래밍 방식을 채택하여 파이프라인을 구성하는 것이기 때문에 변경 추적이 쉽지 않을 뿐더러 변경 추적이 어렵다.

basketFlux.concatMap(basket -> {
    final Mono<List<String>> distinctFruits = Flux.fromIterable(basket).distinct().collectList();
    final Mono<Map<String, Long>> countFruitsMono = Flux.fromIterable(basket)
            .groupBy(fruit -> fruit)
            .concatMap(groupedFlux -> groupedFlux.count()
                .map(count -> {
                    final Map<String, Long> fruitCount = new LinkedHashMap<>();
                    fruitCount.put(groupedFlux.key(), count);
                    return fruitCount;
                }) 
            ) 
            .reduce((accumulatedMap, currentMap) -> new LinkedHashMap<String, Long>() { {
                putAll(accumulatedMap);
                putAll(currentMap);
            }})
    return Flux.zip(distinctFruits, countFruitsMono, (distinct, count) -> new FruitInfo(distinct, count));
}).subscribe(System.out::println);

(Webflux 예시코드)

그럼에도 WebFlux를 쓰는이유

그렇다면 왜 굳이 SpringMVC대신 Webflux 를 쓰려고할까.
단순히 많은 요청을 더 잘 처리하기 위해서 혹은 반전이 일어날만한 성능 기대를 위해 도입을 해야하나?

실제로 초당 500개 정도의 요청을 받는다면 사용을 고려할 만하다고 하지만 여러 글들을 찾아 본 결과 다음과 같은 환경이면 도입할만 하다고 판단하는 것 같다.

데이터를 스트리밍으로 지속적으로 보내줘야 하는 경우
대부분 비즈니스 로직이 다른 업스트림 호출이 반환되기를 기다리는 경우 (ex. 오케스트레이션, API 게이트 웨이)
여러 API를 호출하는 로직 그리고 이를 위합하여 전달하는 시스템일 경우
빈번한 컨텍스트 스위칭으로 인해 늘어난 IO 수행시간으로 인해 CPU와 메모리에 부하가 심한경우 (무거운 스레드)

WebFlux에 맞게 쓰려면

webflux는 기본적으로 비동기이기 때문에 그에 맞는 환경이 갖춰진 상태에서 도입을 해야 적절하게 잘 썼다 라고 얘기할 수 있을 것 같다.

예를들어 Tmax 사의 Tibero DB와 Rxjava, Webflux를 이용하여 교통정보를 실시간 스트림으로 보내주는 작업을 하는 친구가 있는데 DB가 계속 죽는다고 얘기를 했었다.
그 원인이 기본적으로 RDB는 블로킹을 동반한 동기성 DB 이기 때문이다.
아무리 서버로직에서 비동기로 처리하더라도 DB가 비동기가 아니면 결국 병목은 똑같이 걸리기 때문.
따라서 Webflux 를 사용하려면 이와 관련된 DB는 Redis 나 R2DBC와 같은 Nosql 기반 DB를 선택하는 것도 방법이 되겠다.
이러한 이유로 우리회사 같은경우 단순 호출을 기반으로 진행된 챗봇 프로젝트에선 webflux와 redis를 이용하여 개발을 했었다. (현재는 보류)

https://www.youtube.com/watch?v=I0zMm6wIbRI
어느 머기업에서 Webflux를 도입했다가 오히려 느렸던 이유에 대해 설명해논 영상이있다. 블록킹코드가 하나라도 있으면 Webflux 도입하는 의미가 퇴색된다는 것이다. 즉 모든 코드들은 가능한 비동기 Non-blocking으로 개발해야 한다.

[Spring] Redis

김까따 — Sat, 17 Sep 2022 17:01:26 +0900

Redis

Remote Dictionary Server 의 약자로 In-Memory 기반 Key-Value 형식의 Cache Store 이다.

Cach

자주 사용하는 데이터나 값을 미리 복사해 놓는 임시 저장소이며 read-write 가 빈번하게 일어날 때 사용하며 저장공간이 적다는 것이 특징

MemCache vs Redis

세션은 Memory 기반으로 동작해서 데이터를 저장하는 저장소인데 굳이 Redis를 사용해야 하는이유와 Spring 에서 공식적으로 Session 클러스터링을 Redis 방식을 선택하는 이유가 있다.

두 가지 공통점과 차이점을 비교하면 다음과 같다.

가장 큰 특징은

다양한 자료구조를 지원
데이터 저장할 때 Disk에도 저장이 가능할 수 있게 해 주기 때문에 복구에 용이
Memory Cache는 LRU 방식으로 동작하지만 Redis는 다양한 정책을 선택이 가능

Redis 적용 예시

Redis 를 사용하는 기준은 다르겠지만, 단순 캐싱용으로 사용하는 용도를 넘어서는 경우에 사용한다.
예를들어 서버가 여러개일경우 사용자 로그인 정보를 서버끼리 서로 공유할 수 있는 형태로 있어야 하는데 이를 세션 클러스터링이라고 한다.

만약 Server1에서 뭔가 요청을 처리하고 있고 , Server2 와 Server3도 다 같은 세션정보를 알고 있어야 한다고 가정을 하자. (ex. 로그인 된 사용자 정보)
그럼 Server1는 Server2와 Server3에게 정보를 보내주면 Memory내에 사용자 정보를 읽어들여 세션을 유지해야하는데 이는 서버에게 부담을 초래 하게 된다.

Redis Session 클러스터링

따라서 다음과 같이 세션 전용 서버를 따로두면 Server2와 Server3은 별도의 세션 서버로부터 정보를 읽어 들일 수 있기 때문에 로그인이 유지된 채 사용자는 여전히 서비스를 이용가능하다.

혹은 만약 어떤 쇼핑몰 시스템이 있고 도메인서버가 분리되어있을 경우 같은 사용자 정보를 이용해야 할 때 세션 클러스터링을 통해 사용자정보를 받아올 수 있다.

아래 Redis UI 예시를 보면 현재 로그인 된 사용자 세션을 확인할 수 있다.

Spring 에서 Redis 이용해보기

공식문서

Redis Download : https://redis.io/download/

Redis UI : https://www.electronjs.org/apps/p3x-redis-ui

Spring Redis Doc : https://spring.io/projects/spring-data-redis/

본 예제에서는 Jedis를 사용한다.

의존성추가 (build.gradle)

"org.springframework.boot:spring-boot-starter-data-redis"

Redis 서버 설정 (appliction.properties)

### Redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=1234
spring.redis.pool.max-idle=10
spring.redis.pool.min-idle=5
spring.redis.pool.max-active=10
spring.redis.pool.max-wait=-10

@Configuration
public class RedisConfig {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String password;
    @Bean
    public RedisConnectionFactory connectionFactory() {
        JedisConnectionFactory jcf = new JedisConnectionFactory();
        jcf.setHostName(host);
        jcf.setPort(port);
        jcf.setPassword(password);
        return jcf;
    }
    @Bean
    public RedisTemplate<?, ?> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<byte[], byte[]> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

StringReedisSerializer를 넘겨줘서 Sring 타입의 Key Value 템플릿을 사용한다.

이렇게 하고 Redis UI를 통해서 보면 SpringSecurity에서의 세션관리가 Redis를 통해 되고있다는 것을 확인할 수 있다.

[Spring] Springboot 개발 환경 분리 및 Datasource 암호화 하기

김까따 — Wed, 6 Jul 2022 02:12:42 +0900

개발 환경 분리하기

다른사람과 같이 진행하는 토이프로젝트에서 테스트용 환경과 개발 환경의 DB를 다르게 설정해 놨기 때문에 환경의 분리가 필요했다. 이 때 환경을 application.proerties 나 .yml 을 이용하여 분리를 한다.

기존 application.yml

spring:
  datasource:
    url: jdbc:h2:tcp://localhost/~/gubun
    username: sa
    password:
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        format_sql: true
logging.level:
  org.hibernate.SQL: debug
#  org.hibernate.type: trace

AWS RDS 를 개발 db로 사용하기로 해서 기존 H2 DB를 쓰던 환경을 테스트로 두고, 새로 추가한 Postgres DB를 개발 환경으로(test,dev) 분리하기로 하였다.

(SpringBoot 2.4 버전 이후로 on-profile 을 이용해야 한다. 기존의 방식은 deprecated 됨)

application.yml

spring:
  profiles:
    active: dev

logging.level:
  org.hibernate.SQL: debug
#  org.hibernate.type: trace

application-test.yml

server:
  port: 8080

spring:
  config:
    activate:
      on-profile: test
  datasource:
    url: jdbc:h2:tcp://localhost/~/gubun
    username: sa
    password:
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        format_sql: true

application-dev.yml

server:
  port: 9090

spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: ##DB위치
    username: ##이름
    password: ##패스워드
    driver-class-name: org.postgresql.Driver
  jpa:
    hibernate:
      ddl-auto: none
    properties:
      hibernate:
        format_sql: true

DataSource 암호화 하기

그런데 여기서 한 가지 문제는 이 프로젝트가 Git으로 관리 되고 있다는 것이다.
만약 저 DataSource 그대로 Git에 올려버리면 보안문제는 물론이고 AWS에서 막아버린다.
.yml 을 gitignore을 통해 안 올리는 방법도 있겠지만 여기선 암호화해서 올리려고 한다.

Jasypt

Jasypt는 민감정보를 암호화 해주는 모듈로, 여기선 민감정보를 암호화 한 뒤에 환경변수로 복호화키를 설정하여 접속할 수 있게 할 것이다.

https://www.devglan.com/online-tools/jasypt-online-encryption-decryption

Programming Blog Article Feeds as per your Interest | DevGlan

Best programming article feeds as per your Interest on different technologies. Subscribe to any technology and explore the best articles from around the web.

www.devglan.com

이 곳에 들어가면 직접 암/복호화를 수행할 수 있다.

key를 이용하여 복호화를 수행하려면 Two Way Encryption이라는 옵션을 선택해야 한다.
단방향 암호화가 아니기 때문에 복호화 키를 이용하면 바로 원문이 나온다.
참고로, 저 EncryptedString은 Encrypt를 수행할 때 마다 매번 다른 EncryptedString이 나온다.

이제 Spring에서 이를 이용해보자.

의존성추가하기 (ulisesbocchio-jasypt)

dependencies {

	// 암호화 모듈
	implementation 'com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4'
}

참고) 3.0.3 부터 방식이 달라져서 이전 버전을 이용하면 동작 되지 않을 수도 있음

https://github.com/ulisesbocchio/jasypt-spring-boot

GitHub - ulisesbocchio/jasypt-spring-boot: Jasypt integration for Spring boot

Jasypt integration for Spring boot. Contribute to ulisesbocchio/jasypt-spring-boot development by creating an account on GitHub.

github.com

Configuration 추가하기

import lombok.extern.slf4j.Slf4j;
import org.jasypt.encryption.StringEncryptor;
import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 서버 정보 암호화 하기위한 ConfigClass
 * 아래의 URL에서 encrypt decrypt 가능
 * https://www.devglan.com/online-tools/jasypt-online-encryption-decryption
 *
 * application-dev.yml 안에 있는 암호화된 DB 정보를 decrypt 하기 위해선 환경변수에서 값을 직접 입력받아야 합니다.
 */
@Configuration
@Slf4j
public class JasyptConfig {

    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {

        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword(System.getenv("JASYPT_PASSWORD"));
        config.setAlgorithm("PBEWithMD5AndDES");
        config.setKeyObtentionIterations("1000");
        config.setPoolSize("1");
        config.setProviderName("SunJCE");
        config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        config.setIvGeneratorClassName("org.jasypt.iv.NoIvGenerator");
        config.setStringOutputType("base64");
        encryptor.setConfig(config);
        return encryptor;
    }
}

config.setPassword(System.getenv("JASYPT_PASSWORD")); 이 부분이 환경변수로 부터 키 값을 받아와서 설정해 주는 부분이다. 환경변수를 시스템변수에 추가해서 사용할 수 있는데, 필자는 null 이 반환이 되어서 직접 runConfigurations에 추가해서 진행 하였다.

그리고 다시 돌아와서 application-dev.yml 부분의 DB정보를 암호화 하여 나온 값들로 채워주면 되는데 ENC()로 감싸주면 끝

spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: ENC(Akn44dXsH2btWIRNfqmNJc60LKUOWP2c+PVQ15+xSoZf4ddzGl1JcI13hbWZ9LUVeXo6kwdlBIuw+YKPaSUkK8h0sQWonoADl1lGUFwdS4NAaeQugwBBNJIu6kwxMBJ1)
    username: ENC(EmRRq+Xam8r36WFSPZas2UjrcY/DfwSv)
    password: ENC(daX0fX/g9fgOzXIz8TroQj50f1XwHf4z6qHiPA0Vv3g=)
    driver-class-name: org.postgresql.Driver
  jpa:
    hibernate:
      ddl-auto: none
    properties:
      hibernate:
        format_sql: true

[Spring] 스프링 RestTemplate

김까따 — Sun, 26 Jun 2022 04:06:53 +0900

RestTemplate

RestTemplate 은 스프링3.0 이상 부터 지원하는 HTTP 통신, 그 중 RestAPI 를 기준으로 요청을 쉽게 할 수 있게 도와주는 동기방식의 Rest 클라이언트.
Hateoas 의 하이퍼 미디어 링크를 삽입할 수 있게 도와주는 Traverson과 함께 사용된다.

Spring 5.0 부터는 비동기 방식도 지원하는 WebClient를 사용한다.

(서비스 ⇒ other 서비스) 로 필요한 데이터를 받아올 때 사용 하며 예를들어,
받아온 JSON 타입의 데이터를 Jackson2 MessageConverter을 통해 객체에 바인딩을 하여 우리가 쓸 수 있는 Object 형태로 받아 온다.

RestTemplate 동작원리

RestTemplate ⇒ HttpMessageConverter ⇒ RequestEntity ⇒ HttpMessageConverter ⇒ ResponseEntity ⇒ Object

참고)

RestTemplate 생성자 (여러가지 messageConverter들이 등록 되어 있음)

public RestTemplate() {
        this.messageConverters.add(new ByteArrayHttpMessageConverter());
        this.messageConverters.add(new StringHttpMessageConverter());
.............
.............
.............

if (jackson2Present) {
            this.messageConverters.add(new MappingJackson2HttpMessageConverter());
        }
        else if (gsonPresent) {
            this.messageConverters.add(new GsonHttpMessageConverter());
        }
        else if (jsonbPresent) {
            this.messageConverters.add(new JsonbHttpMessageConverter());
        }
        else if (kotlinSerializationJsonPresent) {
            this.messageConverters.add(new KotlinSerializationJsonHttpMessageConverter());
        }

        if (jackson2SmilePresent) {
            this.messageConverters.add(new MappingJackson2SmileHttpMessageConverter());
        }
        if (jackson2CborPresent) {
            this.messageConverters.add(new MappingJackson2CborHttpMessageConverter());
        }
.............
}

RestTemplate 메서드 (Callback 처리 되는 것을 볼 수 있음 )

..............
..............
@Override
    @Nullable
    public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
        RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
        HttpMessageConverterExtractor<T> responseExtractor =
                new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
        return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
    }

    @Override
    @Nullable
    public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
        RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
        HttpMessageConverterExtractor<T> responseExtractor =
                new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
        return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
    }

    @Override
    @Nullable
    public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
        RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
        HttpMessageConverterExtractor<T> responseExtractor =
                new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
        return execute(url, HttpMethod.GET, requestCallback, responseExtractor);
    }
..............
..............

RestTemplate 으로 요청을 보내면 필요한 처리들을 백그라운드에서 Callback 메서드들을 호출하여 처리 후 데이터를 받아오는 방식으로 동작.

RestTemplate으로 REST 엔드포인트 사용하기

RestTemplate 클라이언트는 다른 API에 요청을 하기 위한 12개의 메서드들이 있다.
파라미터들이 다른 오버로딩 된 메서드들을 합치면 총 41개의 메서드들이 있다.

Method	Description	HTTP Method	ResponseType
delete(…)	HTTP Delete 요청 수행	Delete	void
exchange(…)	HTTP 요청을 수행한 후 ResponseEntity를 반환	ALL	ResponseEntity
excute(…)	HTTP 요청을 수행한 후 Object를 반환	ALL	Object
getFor[Entity/Object] (…)	HTTP Get 요청을 수행한 후 [ResponseEntity / Object] 를 반환	GET	ResponseEntity / T
headForHeaders(…)	HTTP Head 요청을 전송하며 헤더 정보를 반환	HEAD	HttpHeaders
optionsForAllow(…)	HTTP Option 요청을 전송하며 Allow 헤더를 반환 ( HTTP 헤더 정보)	OPTIONS	Set
patchForObject(…)	HTTP Patch 요청을 전송하며 결과 객체를 반환	PATCH	T
postFor[Entity/Object] (…)	HTTP Post 를 요청을 수행하며 [ResponseEntity / Object] 를 반환	Post	ResponseEntity / T
PostForLocation(…)	HTTP Post 를 수행한 후 생성되는 URI을 반환	Post	URI
Put(…)	HTTP Put 을 수행	PUT	void

기본적으로 HTTP Method 에 맞는 method 들이 하나씩 있으며 , exchange 와 excute 는 더 넓은 범위의 모든 요청을 수행할 수 있는 low 레벨 메서드이다.

RestTemplate Bean 을 주입받아 사용할 수도 있다.

GET 예시

@Service
@Slf4j
@RequiredArgsConstructor
public class TacoCloudClient {

    private final RestTemplate rest;
    private final Traverson traverson;

    //
    // GET examples
    //

    public Ingredient getIngredientById(String ingredientId) {
        return rest.getForObject("http://localhost:8080/ingredients/{id}",
                Ingredient.class, ingredientId);
    }

    // 모든 요청을 수행할 수 있는 메서드 이므로 요청 method 도 같이 파라미터에 지정
    public List<Ingredient> getAllIngredients() {
        return rest.exchange("http://localhost:8080/ingredients",
                        HttpMethod.GET, null, new ParameterizedTypeReference<List<Ingredient>>() {})
                .getBody();
    }

    // Map 으로 키 지정
    public Ingredient getIngredientById(String ingredientId) {
        Map<String, String> urlVariables = new HashMap<>();
        urlVariables.put("id", ingredientId);
        return rest.getForObject("http://localhost:8080/ingredients/{id}",
                Ingredient.class, urlVariables);
    }

    // URI 객체를 생성하여 전송
    public Ingredient getIngredientById(String ingredientId) {
        Map<String, String> urlVariables = new HashMap<>();
        urlVariables.put("id", ingredientId);
        URI url = UriComponentsBuilder
                .fromHttpUrl("http://localhost:8080/ingredients/{id}")
                .build(urlVariables);
        return rest.getForObject(url, Ingredient.class);
    }

    // header 와 body 정보가 필요할 때 요청 후 ResponseEntity 로 반환
    public Ingredient getIngredientById(String ingredientId) {
        ResponseEntity<Ingredient> responseEntity =
                rest.getForEntity("http://localhost:8080/ingredients/{id}",
                        Ingredient.class, ingredientId);
        log.info("Fetched time: " + responseEntity.getHeaders().getDate());
        return responseEntity.getBody();
    }
}

Post 예시

@Service
@Slf4j
@RequiredArgsConstructor
public class TacoCloudClient {

    private final RestTemplate rest;
    private final Traverson traverson;

    //
    // POST examples
    //
    public Ingredient createIngredient(Ingredient ingredient) {
        return rest.postForObject("http://localhost:8080/ingredients",
                ingredient, Ingredient.class);
    }

    // 생성된 URI 반환
    public URI createIngredient(Ingredient ingredient) {
        return rest.postForLocation("http://localhost:8080/ingredients",
                ingredient, Ingredient.class);
    }

    public Ingredient createIngredient(Ingredient ingredient) {
        ResponseEntity<Ingredient> responseEntity =
                rest.postForEntity("http://localhost:8080/ingredients",
                        ingredient,
                        Ingredient.class);
        log.info("New resource created at " + responseEntity.getHeaders().getLocation());
        return responseEntity.getBody();
    }
}

Put 예시

@Service
@Slf4j
@RequiredArgsConstructor
public class TacoCloudClient {

  private final RestTemplate rest;
  private final Traverson traverson;

  //
  // PUT examples
  //
  public void updateIngredient(Ingredient ingredient) {
    rest.put("http://localhost:8080/ingredients/{id}",
          ingredient, ingredient.getId());
  }
}

Delete 예시

@Service
@Slf4j
@RequiredArgsConstructor
public class TacoCloudClient {

  private final RestTemplate rest;
  private final Traverson traverson;

  //
  // DELETE examples
  //

  public void deleteIngredient(Ingredient ingredient) {
    rest.delete("http://localhost:8080/ingredients/{id}",
        ingredient.getId());
  }
}

RestTemplate의 한계?

스프링 5.0 부터는 WebClient를 지원하고, 이를 사용하도록 권고하고 있다. 그 동안 비동기 방식은 AsyncRestTemplate이 지원해 주었는데 deprecated되 었다.
이어서 RestTemplate을 deprecated 될 가능성이 있다고 한다. 그 이유는..?

참고) 동기 vs 비동기 , blocking vs non-blocking

RestTemplate	WebClient
Blocking	Non-Blocking
Sync	Async
MultiThread	SingleThread

RestTemplate 과 WebClient의 Blocking 이나 Non-Blocking 이냐 에 따라 성능차이가 동시 사용자가 많아 질수록 급격하게 차이가 난다고 한다.

Boot 1은 WebClient , Boot 2 는 SpringMVC의 RestTemplate 이다.

기존 (SpringMVC) Sync-Blocking 방식은 쓰레드 풀이 수용할 수 있는 요청만 동시적으로 처리하고 그 이상은 큐잉되어 대기하게 되는데 이 max-size 를 지속적으로 초과하게 된다면 전체 대기시간이 점점 늘어나게 된다. ( Thread poll hell 현상)

그래서 I/O 작업에 있어서 효율을 낼 수 있는 async & non-blocking 과 event-driven 방식을 통해 처리할 수 있는 Webclient를 쓰도록 권장하는 것이다.

참고 ) Spring Webflux 는 어떻게 적은 리소스로 많은 트래픽을 감당할까?

[Spring] RestAPI와 Hateoas로 링크 삽입하기

김까따 — Sun, 19 Jun 2022 05:05:29 +0900

Hateoas

기존의 API 응답 방법에서 만약 특정 URL에 대한 요청을 했는데, 해당 URL이 바뀌었다면 404 NotFound를 반환하기 때문에 이를 동적으로 Hypermedia 링크를 삽입된 응답을 반환하기 위한 메커니즘이 Hateoas 이다.

Hateoas(Hypermedia As The Engine Of Application State)는 Hypermedia를 Application의 상태를 관리하기 위해 도입된 개념. 즉 , 클라이언트는 서버와 동적으로 상호작용이 가능하도록 해야함. ⇒ 요청에 필요한 URI를 응답에 포함시켜 반환

RestAPI 구현레벨

RestAPI에도 구현 레벨이 있는데 Hateoas 는 마지막 Level3 의 단계이다. [참고링크]

의존성 추가하기

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

참고) 스프링부트 2.2 이상 부터는 기존 Resource 에서 EntityModel로 바뀌었음

이전버전	2.2이후
ResourceSupport	RepresentationalModel
Resource	EntityModel
Resource	CollectionModel
PagedResources	PagedModel
ResourceAssembler	RepresentationalModelAssembler
ControllerLinkBuilder	WebMvcLinkBuilder

리소스에 하이퍼링크 추가하기

반환타입이 List 타입이므로 CollectionModel.of() 메서드를 이용해서 반환한다.

linkTo 메서드 안에 특정 Controller를 지정함으로써 해당 Controller의 요청에 대한 삽입할 Link를 생성할 수 있다. ⇒ URI 가 변경되어도 변경된 URI에 대한 링크가 반환이 된다.

linkTo 안에 methodOn을 이용해서 특정 메서드를 지정할 수도 있음

DesignTacoApiController.class

import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn;

@RestController
@RequestMapping(path = "/api/design",produces = "application/json")
@RequiredArgsConstructor
@CrossOrigin(origins = "*")
public class DesignTacoApiController {

    private final TacoRepository tacoRepository;

    @GetMapping("/recent")
    public CollectionModel<Taco> recentTacos(){
        PageRequest pageRequest = PageRequest.of(0, 12, Sort.by("createdAt").descending());

        List<Taco> tacos = tacoRepository.findAll(pageRequest).getContent();
        CollectionModel<Taco> recentResources = CollectionModel.of(tacos);

        Link link = linkTo(methodOn(DesignTacoApiController.class).recentTacos())
                .withRel("recents");
        recentResources.add(link);

        return recentResources;
    }
}

{
    "_embedded": {
        "tacoList": [
            {
                "id": 2,
                "createdAt": "2022-06-18T19:07:13.816+00:00",
                "name": "taco123",
                "ingredients": [
                    {
                        "id": "FLTO",
                        "name": "Flour Tortilla",
                        "type": "WRAP"
                    },
                    {
                        "id": "GRBF",
                        "name": "Ground Beef",
                        "type": "PROTEIN"
                    },
                    {
                        "id": "JACK",
                        "name": "Monterrey Jack",
                        "type": "CHEESE"
                    },
                    {
                        "id": "LETC",
                        "name": "Lettuce",
                        "type": "VEGGIES"
                    },
                    {
                        "id": "SLSA",
                        "name": "Salsa",
                        "type": "SAUCE"
                    }
                ]
            }
        ]
    },
    "_links": {
        "recents": {
            "href": "http://localhost:8080/api/design/recent"
        }
    }
}

리소스 어셈블러

taco가 만약 여러개라면 반복문을 통해 여러개의 Link 객체를 만들어 삽입해야 하므로 RepresentationalModelAssembler를 구현한 Assembler를 만들어서 해결한다.

게다가 TacoList를 보면 id값이 노출되어 있는데, 클라이언트 입장에서는 id값을 알 필요가 없기 때문에 별도의 RepresentationalModel을 상속받은 유틸리티 class를 생성하여 _self 링크가 이를 대체하게 한다.

TacoResources.class

@Relation(value = "taco",collectionRelation = "tacos")
public class TacoResources extends RepresentationModel<TacoResources> {

    @Getter
    private final String name;

    @Getter
    private final Date createAt;

    @Getter
    private final List<Ingredients> ingredients;

    public TacoResources(Taco taco) {
        this.name=taco.getName();
        this.createAt=taco.getCreatedAt();
        this.ingredients=taco.getIngredients();
    }
}

참고로, @Relation 으로 이름을 지정해주면 json안에 임의로 생성된 tacoList 변수명을 다른 변수명으로 지정해 줄 수 있음

어셈블러 TacoResourceAssembler.class

@Component
public class TacoResourceAssembler implements RepresentationModelAssembler<Taco, EntityModel<TacoResources>> {

    @Override
    public EntityModel<TacoResources> toModel(Taco taco) {

        return EntityModel.of(new TacoResources(taco),
                linkTo(methodOn(DesignTacoApiController.class).findTacoById(taco.getId())).withSelfRel()
        );
    }

    @Override
    public CollectionModel<EntityModel<TacoResources>> toCollectionModel(Iterable<? extends Taco> tacos) {
        return RepresentationModelAssembler.super.toCollectionModel(tacos).add(
                        linkTo(DesignTacoApiController.class).withSelfRel(),
                linkTo(methodOn(DesignTacoApiController.class).recentTacos()).withRel("recents")
        );
    }

}

단일 객체를 반환하는 toModel 에서는 taco ⇒ tacoResources로 변환하고 EntityModel에 링크를 삽입하여 반환한다.

컬렉션을 반환하는 toCollectionModel 에서는 tacos ⇒ CollectionModel로 변환하는데, 컬렉션으로 반환될 수 있는 모든 경우를 지정하여 각각에 맞는 Link가 삽입될 수 있도록 한다.

컨트롤러 DesignTacoApiController.class

@RestController
@RequestMapping(path = "/api/design",produces = "application/json")
@RequiredArgsConstructor
@CrossOrigin(origins = "*")
public class DesignTacoApiController {

    private final TacoRepository tacoRepository;
    private final TacoResourceAssembler assembler;

    @GetMapping("/recent")
    public CollectionModel<EntityModel<TacoResources>> recentTacos(){
        PageRequest pageRequest = PageRequest.of(0, 12, Sort.by("createdAt").descending());

        List<Taco> tacos = tacoRepository.findAll(pageRequest).getContent();

        return assembler.toCollectionModel(tacos);
    }

    @GetMapping
    public List<Taco> findAll(){
        return tacoRepository.findAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Taco> findTacoById(@PathVariable Long id){
        Optional<Taco> findTaco = tacoRepository.findById(id);

        return findTaco.map(taco -> new ResponseEntity<>(taco, HttpStatus.OK))
                .orElseGet(() -> new ResponseEntity<>(null, HttpStatus.NOT_FOUND));
    }
}

컨트롤러에서는 어셈블러를 컴포넌트로 주입받아 사용하면 된다.

{
    "_embedded": {
        "tacos": [
            {
                "name": "taco1",
                "createAt": "2022-06-18T19:31:40.148+00:00",
                "ingredients": [
                    {
                        "id": "FLTO",
                        "name": "Flour Tortilla",
                        "type": "WRAP"
                    },
                    {
                        "id": "GRBF",
                        "name": "Ground Beef",
                        "type": "PROTEIN"
                    },
                    {
                        "id": "CHED",
                        "name": "Cheddar",
                        "type": "CHEESE"
                    },
                    {
                        "id": "TMTO",
                        "name": "Diced Tomatoes",
                        "type": "VEGGIES"
                    },
                    {
                        "id": "SLSA",
                        "name": "Salsa",
                        "type": "SAUCE"
                    }
                ],
                "_links": {
                    "self": {
                        "href": "http://localhost:8080/api/design/2"
                    }
                }
            }
        ]
    },
    "_links": {
        "self": {
            "href": "http://localhost:8080/api/design"
        },
        "recents": {
            "href": "http://localhost:8080/api/design/recent"
        }
    }
}

객체안의 객체에 링크를 삽입하기

Taco 안에 Ingredients 객체에 대한 링크도 나타낼 수 있는데 기존 TacoResources라는 유틸리티 클래스에 Ingrerdients의 어셈블러를 넣어줘서 추가적인 링크를 삽입할 수 있다.

@Getter
@Setter
@Relation(value = "ingredient",collectionRelation = "ingredients")
public class IngredientResources extends RepresentationModel<IngredientResources> {

    private String name;
    private Type type;

    public IngredientResources(Ingredient ingredient) {
        this.name = ingredient.getName();
        this.type = ingredient.getType();
    }
}

@Relation(value = "taco",collectionRelation = "tacos")
public class TacoResources extends RepresentationModel<TacoResources> {

    private static final IngredientResourceAssembler ingredientResourceAssembler = new IngredientResourceAssembler();

    @Getter
    private final String name;

    @Getter
    private final Date createAt;

    @Getter
    private final CollectionModel<EntityModel<IngredientResources>> ingredients;

    public TacoResources(Taco taco) {
        this.name=taco.getName();
        this.createAt=taco.getCreatedAt();
        this.ingredients=ingredientResourceAssembler.toCollectionModel(taco.getIngredients());
    }
}

List 타입의 컬렉션 필드 대신에 CollectionModel을 필드로 대체한다.

컨트롤러 IngredientController.class

@RestController
@RequestMapping(path="/ingredients", produces="application/json")
@CrossOrigin(origins="*")
@RequiredArgsConstructor
public class IngredientController {

    private IngredientRepository ingredientRepository;

    @GetMapping
    public Iterable<Ingredient> findAllIngredients() {
        return ingredientRepository.findAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Ingredient> findIngredientById(@PathVariable String id){
        Optional<Ingredient> findIngredient = ingredientRepository.findById(id);

        return findIngredient.map(ingredient -> new ResponseEntity<>(ingredient, HttpStatus.OK))
                .orElseGet(() -> new ResponseEntity<>(null, HttpStatus.NOT_FOUND));
    }

}

어셈블러 IngredientResourceAssembler.class

public class IngredientResourceAssembler implements RepresentationModelAssembler<Ingredient, EntityModel<IngredientResources>> {

    @Override
    public EntityModel<IngredientResources> toModel(Ingredient ingredient) {
        return EntityModel.of(new IngredientResources(ingredient),
                linkTo(methodOn(IngredientController.class).findIngredientById(ingredient.getId())).withSelfRel()
        );
    }

    @Override
    public CollectionModel<EntityModel<IngredientResources>> toCollectionModel(Iterable<? extends Ingredient> ingredients) {

        return RepresentationModelAssembler.super.toCollectionModel(ingredients).add(
                linkTo(IngredientController.class).withSelfRel()
        );
    }
}

{
    "_embedded": {
        "tacos": [
            {
                "name": "taco2",
                "createAt": "2022-06-18T19:49:45.909+00:00",
                "ingredients": {
                    "_embedded": {
                        "ingredients": [
                            {
                                "name": "Corn Tortilla",
                                "type": "WRAP",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/COTO"
                                    }
                                }
                            },
                            {
                                "name": "Ground Beef",
                                "type": "PROTEIN",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/GRBF"
                                    }
                                }
                            },
                            {
                                "name": "Monterrey Jack",
                                "type": "CHEESE",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/JACK"
                                    }
                                }
                            },
                            {
                                "name": "Diced Tomatoes",
                                "type": "VEGGIES",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/TMTO"
                                    }
                                }
                            },
                            {
                                "name": "Lettuce",
                                "type": "VEGGIES",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/LETC"
                                    }
                                }
                            },
                            {
                                "name": "Salsa",
                                "type": "SAUCE",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/SLSA"
                                    }
                                }
                            },
                            {
                                "name": "Sour Cream",
                                "type": "SAUCE",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/SRCR"
                                    }
                                }
                            }
                        ]
                    },
                    "_links": {
                        "self": {
                            "href": "http://localhost:8080/ingredients"
                        }
                    }
                },
                "_links": {
                    "self": {
                        "href": "http://localhost:8080/api/design/4"
                    }
                }
            },
            {
                "name": "taco1",
                "createAt": "2022-06-18T19:49:33.849+00:00",
                "ingredients": {
                    "_embedded": {
                        "ingredients": [
                            {
                                "name": "Flour Tortilla",
                                "type": "WRAP",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/FLTO"
                                    }
                                }
                            },
                            {
                                "name": "Ground Beef",
                                "type": "PROTEIN",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/GRBF"
                                    }
                                }
                            },
                            {
                                "name": "Carnitas",
                                "type": "PROTEIN",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/CARN"
                                    }
                                }
                            },
                            {
                                "name": "Cheddar",
                                "type": "CHEESE",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/CHED"
                                    }
                                }
                            },
                            {
                                "name": "Diced Tomatoes",
                                "type": "VEGGIES",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/TMTO"
                                    }
                                }
                            },
                            {
                                "name": "Lettuce",
                                "type": "VEGGIES",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/LETC"
                                    }
                                }
                            },
                            {
                                "name": "Salsa",
                                "type": "SAUCE",
                                "_links": {
                                    "self": {
                                        "href": "http://localhost:8080/ingredients/SLSA"
                                    }
                                }
                            }
                        ]
                    },
                    "_links": {
                        "self": {
                            "href": "http://localhost:8080/ingredients"
                        }
                    }
                },
                "_links": {
                    "self": {
                        "href": "http://localhost:8080/api/design/2"
                    }
                }
            }
        ]
    },
    "_links": {
        "self": {
            "href": "http://localhost:8080/api/design"
        },
        "recents": {
            "href": "http://localhost:8080/api/design/recent"
        }
    }
}

참고) [스프링 Hateoas 공식문서]
출처: 스프링 인 액션

[Spring] Http 통신과 관련된 Annotations 간단 정리

김까따 — Thu, 16 Jun 2022 21:37:19 +0900

HTTP 통신과 관련된 Annotation들

@RequestMapping (요청을 받을 때)

특정 URL에 요청을 보내면 Controller에서 이를 처리하는데, URL과 HTTP Method에 따라 맞는 요청을 받아 처리한다.

@Controller
@Slf4j
@SessionAttributes("order")
@RequiredArgsConstructor
@RequestMapping("/orders")
public class OrderController {

    @GetMapping("/current") // @RequestMapping(value = "/current",method = RequestMethod.GET)
    public String orderForm(@AuthenticationPrincipal User user,Order order){
    ...

    }
}

Class 레벨에 @RequestMapping을 걸어두고 Method레벨에 @GetMapping 같이 특정 HTTP Method를 알 수 있는 애노테이션을 붙이는 방식이 선호되는 방식

HTTP Method 종류와 애노테이션

`@GetMapping`

HTTP Get 방식의 Method를 처리
Get Method 요청을 처리하는데 추가로 전달할 요청 관련 정보는 쿼리파라미터로 같이 전달
HTTP Form 에 입력한 값은 쿼리 파라미터로 전달해서 view를 리턴하거나 정보를 리턴함
@RequestParam 이나 @ModelAttribute를 통해 전달 받은 요청 파라미터를 처리

// RequestParam : String, Integer 과 같은 primitive 타입
    @GetMapping
    public String ordersForUser(@AuthenticationPrincipal User user,Model model
    , @RequestParam int limit,@RequestParam int offset){

      PageRequest pageable = PageRequest.of(offset,limit);
      model.addAttribute("orders",orderRepository.findByUserOrderByPlacedAtDesc(user,pageable));

      return "orderList";
    }

// ModelAttribute : object 타입

    @GetMapping("/current")
    public String orderForm(@AuthenticationPrincipal User user,@ModelAttribute Order order){
        if (order.getDeliveryName() == null) {
            order.setDeliveryName(user.getFullname());
        }
        if (order.getDeliveryStreet() == null) {
            order.setDeliveryStreet(user.getStreet());
        }
        if (order.getDeliveryCity() == null) {
            order.setDeliveryCity(user.getCity());
        }
        if (order.getDeliveryState() == null) {
            order.setDeliveryState(user.getState());
        }
        if (order.getDeliveryZip() == null) {
            order.setDeliveryZip(user.getZip());
        }
        return "orderForm";
    }

`@PostMapping`

HTTP Post 방식의 Method를 처리
요청을 처리하는데 추가로 전달할 요청 관련 정보는 HTTP body에도 담아 전달
HTTP Form 에 입력한 값은 Get방식과 마찬가지로 쿼리스트링 방식으로 전달해서 로직을 수행
@RequestBody 나 @ModelAttribute를 통해 전달 받은 요청 파라미터를 처리
전달 받은 데이터는 MessageConverter와 자바 reflection을 통해 객체 바인딩이 가능

    @PostMapping // ModelAttribute 사용 (파라미터 형태로 보내질 때)
    public String processOrder(@Valid Order order, Errors errors, SessionStatus sessionStatus, @AuthenticationPrincipal User user){

        if(errors.hasErrors()){
            return "orderForm";
        }

        log.info("order submitted : {}",order);
        order.setUser(user);
        orderRepository.save(order);
        sessionStatus.setComplete();
        return "redirect:/";
    }

    @PostMapping // RequestBody 사용 (Body에 데이터를 담아 보내질 때)
    public String processOrder(@Valid @RequestBody Order order, Errors errors, SessionStatus sessionStatus, @AuthenticationPrincipal User user){

        if(errors.hasErrors()){
            return "orderForm";
        }
        order.setUser(user);
        orderRepository.save(order);
        sessionStatus.setComplete();
        return "redirect:/";
    }

`@PutMapping`, `@PatchMapping`, `@DeleteMapping`

Html Form은 Get과 Post만 동작하지만, PostMapping 처럼 동작하는 HTTP Method들이 있음
PutMapping 과 PatchMapping은 수정관련 요청 Method인데 차이점은 부분수정vs전체수정
DeleteMapping은 말 그대로 데이터를 삭제할 때 요청하는 Method

`@RequestParam`

요청 파라미터를 받는 방식 중 하나로 primitive 타입만 받는다.
보낼때 파마미터 변수와 메소드의 파라미터 변수와 같으면 생략이 가능함

`@ResponseBody` (데이터를 보낼 때)

ViewResolver를 통해 서버에서 view 를 렌더링해서 보여주는 응답을 할 수 있지만

API서버로서 데이터를 보낼 때는 String 형식이나 Json 형식으로 body데이터를 보낼 수 있음

    @GetMapping("/list")
    @ResponseBody
    @ResponseStatus(HttpStatus.OK)
    public ArrayList<List<Taco>> getTacos(@AuthenticationPrincipal User user){

        Pageable pageable = PageRequest.of(0, orderProps.getPageSize());
        List<Order> orders = orderRepository.findByUserOrderByPlacedAtDesc(user, pageable);

        return orders.stream()
                .map(Order::getTacos)
                .collect(Collectors.toCollection(ArrayList::new));
    }

헤더 설정이 필요한 경우 HttpEnity 형태로 return 도 가능함

`@PathVariable`

경로 변수라고도 하며 URL에 쿼리스트링 형식으로 데이터를 보내는 것과 다르게 URL 경로중 일부로 작용함.
ex) www.tacocloud.com/taco/1

    private final TacoRepository tacoRepository;
    @GetMapping("/{tacoNum}")
    @ResponseBody
    public Taco getTaco(@PathVariable Long tacoNum){

        return tacoRepository.findById(tacoNum).get();
    }

위와 같이 쿼리 스트링 형식이 아닌 경로에 포함된 변수로서 사용이 가능

`RedirectAttributes`

요청한 데이터와 관련되거나 포함된 URL을 다시 redirect해서 보여줄때 사용한다. 예를들어 PRG (post redirect get ) 방식으로 다시 Get을 요청 하게 만들 때 사용함

    private final TacoRepository tacoRepository;

    @PostMapping
    public String processDesign(@Valid Taco design, Errors errors,RedirectAttributes redirectAttributes) {
        if (errors.hasErrors()) {
            return "design";
        }

        Taco savedTaco = tacoRepository.save(design);
        redirectAttributes.addAttribute("tacoNum",savedTaco.getId());

        return "redirect:/taco/{tacoNum}";
    }

`@ModelAttribute`

ModeAttribute는 object 와 String 을 서로 변환, 역변환을 도와주는 타입 컨버터가 적용되어 있다. RequestBody와 차이점은 ModelAttribute는 요청 파라미터에만 적용이 된다. 그래서 Order를 쓸 때도 애노테이션을 생략해도 동작이 가능했음. (RequestBody는 불가능)

Jackson2HttpMessageConverter 로 인해 컨버전이 동작하는데 reflection 기반이기 때문에 객체에 getter만 선언해도 동작이 됨

메소드레벨에서 `@ModelAttribute` 사용

    @ModelAttribute("orders")
    public List<Order> orders(@AuthenticationPrincipal User user){

        Pageable pageable = PageRequest.of(0, orderProps.getPageSize());
        List<Order> orders = orderRepository.findByUserOrderByPlacedAtDesc(user, pageable);
        return orders;

    }

@ModelAttribute를 만약 메소드레벨에서 사용하면 지정한 변수명은 모든 요청에대해 자동으로 model.setAttribute() 가 동작해서 model에 담기게 됨

[Spring] YML 한번 알고 가기

김까따 — Tue, 7 Jun 2022 01:21:27 +0900

YML

YML 은 ‘사람이 쉽게 읽을 수 있는’ 데이터 직렬화 양식이고 원래 Yet Another Markup Language 였는데 핵심은 마크업이 아닌 데이터임을 보여주기 위해 YAML Ain't Markup Language 라는 재귀적요소를 더한 이름으로 바꾸었음.

YML의 장점

가독성
자료형과의 결합
주석 사용가능

1. 가독성

xml의 경우엔 태그기반 markup으로 속성을 표시해 주는데 조금만 복잡해도 사람이 읽기가 힘들다. json 의 경우도 마찬가지로 어디까지가 Object이고 Array 인지 보기가 힘듬.
그에 반해 yml은 계층구조로 표현하여 가독성이 좋으며 .properties 에 비해 불필요한 중복제거도 가능.

2. 자료형과의 결합

YML의 기본 자료형

스칼라 : number, String
배열

Youtube:
 channel:
  - penbird
  - kyleschool
  - habithackers

Youtube:
 channel:
  - name : penbird
    type : ["keyboard and hand writings","keyboard and hand writings2"]
  - name : kyleschool
    type : ["data science and engineering", "data science and engineering2"]
  - name : habithackers
    type : ["opct training", "opct training2"]

3. 주석사용가능

#기호 하나로 간단하게 주석을 추가할 수 있음

Youtube: # 유튜브
 channel: # 채널
  - name : penbird #이름
    type : ["keyboard and hand writings","keyboard and hand writings2"]
  - name : kyleschool
    type : ["data science and engineering", "data science and engineering2"]
  - name : habithackers
    type : ["opct training", "opct training2"]

Springboot에서의 YML

Springboot 에서 구성속성들을 bean에 필요하면 추가로 매핑도 할 수 있음

@Component
@ConfigurationProperties(prefix = "taco-orders")
@Data
@Validated
public class OrderProps {

    @Range(min=5,max=25,message = "must be in 5~25")
    private int pageSize = 20;

}

taco:
  orders:
    pageSize: 10

Spring-configuration-metadata.json 처럼 json 포맷형식에 매핑되어 있거나

{
    .....
    {
      "name": "spring.profiles.active",
      "type": "java.util.List<java.lang.String>",
      "description": "Comma-separated list of active profiles. Can be overridden by a command line switch.",
      "sourceType": "org.springframework.boot.context.config.ConfigFileApplicationListener"
    },
    {
      "name": "logging.level.values",
      "values": [
        {
          "value": "trace"
        },
        {
          "value": "debug"
        },
        {
          "value": "info"
        },
        {
          "value": "warn"
        },
        {
          "value": "error"
        },
        {
          "value": "fatal"
        },
        {
          "value": "off"
        }
      ],
      "providers": [
        {
          "name": "any"
        }
      ]
    },
  .....
}

@ConfigurationProperties 를 이용할 수도 있음

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {

    private ClassLoader classLoader;

    /**
     * Whether to generate a random datasource name.
     */
    private boolean generateUniqueName = true;

    /**
     * Datasource name to use if "generate-unique-name" is false. Defaults to "testdb"
     * when using an embedded database, otherwise null.
     */
    private String name;

    /**
     * Fully qualified name of the connection pool implementation to use. By default, it
     * is auto-detected from the classpath.
     */
    private Class<? extends DataSource> type;

    /**
     * Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
     */
    private String driverClassName;

    /**
     * JDBC URL of the database.
     */
    private String url;

    /**
     * Login username of the database.
     */
    private String username;

    /**
     * Login password of the database.
     */
    private String password;

.......

profile 분리

개발환경, 운영환경, 테스트환경 에 맞는 속성들을 줘서 따로 관리를 할 수 있음

application.yml

spring:
  datasource:
      url: jdbc:mariadb://localhost:3306/shop?serverTimezone=Asia/Seoul
      username: root
      password: 1234
      driver-class-name: org.mariadb.jdbc.Driver

application-prod.yml

spring:
  datasource:
      url: jdbc:mariadb://localhost:3306/shop?serverTimezone=Asia/Seoul
      username: root
      password: 1234
      driver-class-name: org.mariadb.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: none

application-test.yml

spring:
  datasource:
      url: jdbc:h2:tcp://localhost/D:/db/h2/taco
      username: sa
      password:
      driver-class-name: org.h2.Driver

properties vs yml

분명 불 필요한 반복도 줄고 보기도 쉬운데 yml만 쓰면 좋아보인다. 하지만 단점도 있다.

spring.datasource.driverClassName=net.sf.log4jdbc.sql.jdbcapi.DriverSpy
spring.datasource.url=jdbc:log4jdbc:mariadb://localhost:3306/test?characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.hikari.username=root
spring.datasource.hikari.password=qlalfqjsgh
spring.datasource.hikari.maximum-pool-size=10

spring:
  datasource:
    driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
    url: jdbc:log4jdbc:mariadb://localhost:3306/test?characterEncoding=UTF-8&serverTimezone=UTC
    hikari:
      username: root
      password: qlalfqjsgh
      maximum-pool-size: 10

프로퍼티 값을 불러 올 수 없음

.properties 에서의 값은 @PropertySource로 불러올 수 있지만 기본적으로 .yml에서는 불가능.

@Configuration 
@PropertySource("classpath:/com/taco/application.properties")
public class AppConfig{

    @Autowired 
    Environment env;

    @Bean
    public TestBean testBean(){
            TestBean testBean = new TestBean();
        testBean.setName(env.getProperty("testbean.name"));
        return testBean;
    }
}

testbean.name = test

그 외 메세지 국제화 기능이나 예외 공통처리 등 .properties에서만 가능한 것들이 있음

참고로, yml ⇒ properties 로 변환하는 방법이 있음. (공식문서)

참고) 프로퍼티 우선순위

유저 홈 디렉토리에 있는 spring-boot-dev-tools.properties
테스트에 있는 @TestPropertySource
@SpringBootTest 애노테이션의 properties 애트리뷰트
커맨드 라인 아규먼트
SPRING_APPLICATION_JSON (환경 변수 또는 시스템 프로티) 에 들어있는 프로퍼티
ServletConfig 파라미터
ServletContext 파라미터
java:comp/env JNDI 애트리뷰트
System.getProperties() 자바 시스템 프로퍼티
OS 환경 변수
RandomValuePropertySource
JAR 밖에 있는 특정 프로파일용 application properties
JAR 안에 있는 특정 프로파일용 application properties
JAR 밖에 있는 application properties
JAR 안에 있는 application properties
@PropertySource
기본 프로퍼티 (SpringApplication.setDefaultProperties)

[SpringSecurity] 스프링 시큐리티 구성하기

김까따 — Tue, 7 Jun 2022 01:18:21 +0900

Spring Secutiry 구성하기

WebSecurityConfigurerAdapter

SpringSecutiry 의존성을 추가하게 되면 기본적으로 WebSecurityConfigurerAdapter 클래스가 실행.
WebSecurityConfigurerAdapter 는 SpringSecutiry 의 웹(http) 보안 기능 초기화 및 설정들을 당담하는 내용이 담겨있고 인증/인가 관련 설정을 제공.

configure() 메서드를 Override 하여 설정정보를 구성할 수 있다.

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final UserDetailsService userDetailsService;
    @Bean
    public PasswordEncoder encoder(){
        return new BCryptPasswordEncoder();
    }

    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/design", "/orders")
                .access("hasRole('ROLE_USER')")
                .antMatchers("/", "/**").access("permitAll")
                .and()
                .formLogin()
                .loginPage("/login")
                .and()
                .logout()
                .logoutSuccessUrl("/")
                .and()
                .csrf();
    }
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .userDetailsService(userDetailsService)
                .passwordEncoder(encoder());
    }

}

참고 (구성 메소드)

메소드	하는 일
access(String)	인자로 전달된 SpEL 표현식이 true면 접근을 허용한다.
anonymous()	익명의 사용자에게 접근을 허용한다.
authenticated()	익명이 아닌 사용자로 인증된 경우 접근을 허용한다.
denyAll()	무조건 접근을 거부한다.
fullyAuthenticated()	익명이 아니거나 또는 remember-me가 아닌 사용자로 인증되면 접근을 허용한다.
hasAnyAuthority(String...)	지정된 권한 중 어떤 것이라도 사용자가 갖고 있으면 접근을 허용한다.
hasAnyRole(String...)	지정된 역할 중 어느 하나라도 사용자가 갖고 있으면 접근을 허용한다.
hasAuthority(String)	지정된 권한을 사용자가 갖고 있으면 접근을 허용한다.
hasIpAddress(String)	지정된 IP 주소로부터 요청이 오면 접근을 하용한다.
hasRole(String)	지정된 역할을 사용자가 갖고 있으면 접근을 허용한다.
not()	다른 접근 메소드들의 효력을 무효화한다.
permitAll()	무조건 접근을 허용한다.
rememberMe()	remember-me(이전 로그인 정보를 쿠키나 데이터베이스로 저장한 후 일정 기간 내에 다시 접근 시 저장된 정보로 자동 로그인됨)를 통해 인증된 사용자의 접근을 허용한다.

authentication	해당 사용자의 인증 객체
denyAll	항상 false를 산출한다.
hasAnyRole(역할 내역)	지정된 역할 중 어느 하나라도 해당 사용자가 갖고 있으면 true
hasRole(역할)	지정된 역할을 해당 사용자가 갖고 있으면 true
hasIpAddress(IP 주소)	지정된 IP 주소로부터 해당 요청이 온 것이면 true
isAnonymous()	해당 사용자가 익명 사용자이면 true
isAuthenticated()	해당 사용자가 익명이 아닌 사용자로 인증되었으면 true
isFullyAuthenticated()	해당 사용자가 익명이 아니거나 또는 remember-me가 아닌 사용자로 인증 되었으면 true
isRememberMe()	해당 사용자가 remember-me 기능으로 인증되었으면 true
permitAll	항상 true를 산출한다.
principal	해당 사용자의 principal 객체

사용자 스토어 구성

In-Memory 기반
JDBC 기반
LDAP 기반
커스텀 사용자 명세 서비스

In-Memory 기반

사용자 정보를 유지/관리 할 수 있는 곳 중 하나가 메모리
변경이 필요없는 사용자를 정해놓는 용도로 사용 ⇒ 테스트 목적

@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .inMemoryAuthentication()
                .withUser("admin")
                .password("{noop}1234")
                .authorities("ADMIN")
                .and()
                .withUser("testuser")
                .password("{noop}1234")
                .authorities("USER");
    }

JDBC 기반

사용자 정보를 RDBMS로 유지/관리 하려는 목적으로 사용.
기본으로 제공하는 Query를 커스터마이징 가능

기본적으로 제공되는 쿼리로 가져오는 값 (username으로 검색)

사용자 검색 : username, password, enabled
권한 검색 : username, authority
그룹 검색 : groupid, groupname, groupautority

@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.jdbcAuthentication()
                .dataSource(dataSource)
                .usersByUsernameQuery("""
                        select username, password, enabled 
                        from users 
                        where username=?
                        """)
                .authoritiesByUsernameQuery("""
                        select username, authority 
                        from authorities 
                        where username=?
                        """)
                .passwordEncoder(new NoEncodingPasswordEncoder());
    }
     */

LDAP 기반

Lightweight Directory Access Protocol : 네트워크 상의 디렉토리 서비스 표준인 X.500의 DAP를 기반으로한 경량화(Lightweight) 된 DAP 버전으로 TCP/IP 계층과 관련되어있음.

주로 사용자, 시스템, 네트워크, 서비스, 애플리케이션 등의 정보를 트리 구조로 저장하여 조회하거나 관리하는 용도나 특정 영역에서 이용자명과 패스워드를 확인하여 인증하는 용도.

관련 기술블로그 : https://www.blocko.io/developer/ldap-인증/

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {

        auth.ldapAuthentication()
                .userSearchBase("ou=people") // 사용자를 찾기위한 기준점 쿼리
                .userSearchFilter("(uid={0})") // 사용자를 찾기위한 필터
                .groupSearchBase("ou=groups") // 그룹을 찾기위한 기준점 쿼리
                .groupSearchFilter("member={0}") // 그룹을 찾기위한 필터
                .contextSource()
                .root("dc=taco,dc=com") // ldap 서버 루트 경로 지정
                .ldif("classpath:users.ldif") // ldif 파일을 지정
                .and()
                .passwordCompare()
                .passwordEncoder(new BCryptPasswordEncoder())
                .passwordAttribute("userPasscode");

    }

커스텀 사용자 명세 서비스

스프링에 내장된 사용자 스토어 외 사용자 명세 서비스를 커스터마이징해서 사용이 가능
UserDetails 를 구현받는 엔티티를 생성해야함.


import java.io.Serial;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import lombok.*;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;

@Entity
@Data
@NoArgsConstructor(access=AccessLevel.PUBLIC, force=true)
@RequiredArgsConstructor
public class User implements UserDetails {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;

    private final String username;
    private final String password;
    private final String fullname;
    private final String street;
    private final String city;
    private final String state;
    private final String zip;
    private final String phoneNumber;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Arrays.asList(new SimpleGrantedAuthority("ROLE_USER"));
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

참고: UserDetails

메소드명	리턴타입	설명
getAuthorities()	Collection<? extends GrantedAuthority>	계정이 갖고있는 권한 목록을 리턴한다.
getPassword()	String	계정의 비밀번호를 리턴한다.
getUsername()	String	계정의 이름을 리턴한다.
isAccountNonExpired()	boolean	계정이 만료되지 않았는 지 리턴한다. (true: 만료안됨)
isAccountNonLocked()	boolean	계정이 잠겨있지 않았는 지 리턴한다. (true: 잠기지 않음)
isCredentialNonExpired()	boolean	비밀번호가 만료되지 않았는 지 리턴한다. (true: 만료안됨)
isEnabled()	boolean	계정이 활성화(사용가능)인 지 리턴한다. (true: 활성화)

@Service
@RequiredArgsConstructor
public class UserRepositoryUserDetailsService implements UserDetailsService {
    private final UserRepository userRepo;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User user = userRepo.findByUsername(username);
        if (user != null) {
            return user;
        }
        throw new UsernameNotFoundException("User '" + username + "' not found");
    }
}

@Repository
public interface UserRepository extends JpaRepository<User,Long> {

    User findByUsername(String username);
}

        @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/design", "/orders")
                .access("hasRole('ROLE_USER')")
                .antMatchers("/", "/**").access("permitAll")
                .and()
                .formLogin()
                .loginPage("/login")
                .and()
                .logout()
                .logoutSuccessUrl("/")
                .and()
                .csrf();
    }
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .userDetailsService(userDetailsService)
                .passwordEncoder(encoder());
    }

@Data
public class RegistrationForm {

    private String username;
    private String password;
    private String fullname;
    private String street;
    private String city;
    private String state;
    private String zip;
    private String phone;

    public User toUser(PasswordEncoder passwordEncoder) {
        return new User(username,passwordEncoder.encode(password),fullname, street, city, state, zip, phone);
    }
}

@Controller
@RequestMapping("/register")
@RequiredArgsConstructor
public class RegistrationController {
    private final UserRepository userRepo;
    private final PasswordEncoder passwordEncoder;

    @GetMapping
    public String registerForm() {
        return "registration";
    }

    @PostMapping
    public String processRegistration(RegistrationForm form) {
        userRepo.save(form.toUser(passwordEncoder));
        return "redirect:/login";
    }
}

password 암호화

SpringSecurity5부터 의무적으로 PasswordEncoder를 이용하여 암호화를 하지 않으면 오류가 발생함. 암호화를 하면 DB에 저장될 때 암호화된 password가 저장이 됨.

암호화된 사용자정보

ID	CITY	FULLNAME	PASSWORD	PHONE_NUMBER	STATE	STREET	USERNAME	ZIP
1	aaa	user	$2a$10$GtCiKop4o9Vlm7CoKryHCuXVehCyNYB5krnMJBbfOylkVInzinc7K	aaa	aaa	aaa	user	aaa

SpringSecutiry 암호화 모듈

BCryptPasswordEncoder : bcrypt 해싱
NoOpPasswordEncoder : 암호화 x
Pbkdf2PasswordEncoder : PBKDF2 암호화
SCryptPasswordEncoder : scrypt 해싱
StandardPasswordEncoder : SHA-256

public class NoEncodingPasswordEncoder implements PasswordEncoder {

    @Override
    public String encode(CharSequence rawPwd) {
        return rawPwd.toString();
    }

    @Override
    public boolean matches(CharSequence rawPwd, String encodedPwd) {
        return rawPwd.toString().equals(encodedPwd);
    }
}

PasswordEncoder 의 encode 와 matches 메서드를 이용하여 암호화/비교를 수행함.

[SpringSecurity] 권한 설정 hasRole 오류와 prefix

김까따 — Thu, 2 Jun 2022 01:35:33 +0900

스프링시큐리티를 공부하던 도중 책에서 이런 코드가 있었다.

SecutiryConfig 구성 클래스 안에서 configure를 orverride 하는 코드이다.

.hasRole() 을 호출할 때 ROLE_USER 로 설정하는것.

그리고 이는 밑의 코드와 동일하게 돌아간다고

하지만 막상 돌려보면 ?

??????

오류를 찾아봤더니 친절하게 설명을 해준다.

ROLE_ 은 자동생성해주니깐 prefix의 ROLE_ 을 쓰지말라고 ..

hasRole()의 내부는 이렇게 생겨먹었다.

저 rolePrefix는 자동으로 ROLE_ 이라는 prefix를 붙여주기 때문에 ROLE_ 이라는 prefix를 제외한 권한을 적으라는 것이다.

여기서 ROLE_ 이라는 prefix를 자동으로 붙여준다. 별도의 설정을 하지 않는 이상

따라서 다음과 같이 바꿔준다.

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                    .antMatchers("/design", "/orders")
                    .hasRole("USER")
                    .antMatchers("/", "/**").permitAll()
                .and()
                    .formLogin()
                    .loginPage("/login")
//                    .defaultSuccessUrl("/design",true)
                .and()
                    .logout()
                    .logoutSuccessUrl("/")
                .and()
                    .csrf().disable();
    }

그런데 만약 내가 prefix를 따로 설정 해놨다면 ?

getAuthorities에서 설정한 prefix를 따온다.

@Entity
@Data
@NoArgsConstructor(access=AccessLevel.PUBLIC, force=true)
@RequiredArgsConstructor
public class User implements UserDetails {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;

    private final String username;
    private final String password;
    private final String fullname;
    private final String street;
    private final String city;
    private final String state;
    private final String zip;
    private final String phoneNumber;


    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Arrays.asList(new SimpleGrantedAuthority("ROLE_USER"));
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

[BOJ] 백준 [1062] 가르침 JAVA

김까따 — Wed, 1 Jun 2022 02:01:38 +0900

https://www.acmicpc.net/problem/1062

1062번: 가르침

첫째 줄에 단어의 개수 N과 K가 주어진다. N은 50보다 작거나 같은 자연수이고, K는 26보다 작거나 같은 자연수 또는 0이다. 둘째 줄부터 N개의 줄에 남극 언어의 단어가 주어진다. 단어는 영어 소문

www.acmicpc.net

문제

풀이

단순히 문자열 완전탐색으로 풀 수 있었다.
우선, anta tica 부터 5개의 알파벳을 차지하고 시작하므로 k>5 인경우에만 진행해야 한다.

pattern matching 함수를 사용하여 만약, 해당 패턴의 단어가 있으면 anta tica를 제외한 부분만
문자열 리스트에 추가한다.

알파벳 방문 체크 배열 visit 을 하나씩 체크하다가 k 개의 갯수가 되었다면 문자열 리스트를 순회하여 모두 읽을 수 있는지 체크

import java.util.*;
import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.*;

import static java.util.Arrays.stream;

public class Main {


    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static int n,k;
    static int ans=0;
    static String[] words;
    static boolean[] visit = new boolean[26];
    public static void main(String[] args) throws IOException {
        String[] input = br.readLine().split(" ");
        n = Integer.parseInt(input[0]);
        k = Integer.parseInt(input[1]);

        visit['a'-'a']=true;
        visit['n'-'a']=true;
        visit['t'-'a']=true;
        visit['i'-'a']=true;
        visit['c'-'a']=true;

        if(k<5){
            System.out.println(ans);
            return;
        }
        words = new String[n];
        k = k-5;
        Pattern pattern = Pattern.compile("anta(.*)tica");
        for(int i=0;i<n;i++){
            Matcher matcher = pattern.matcher(br.readLine());
            if(matcher.find())
                words[i] = matcher.group(1);
        }

        dfs(0,0);
        System.out.println(ans);
    }

    static void dfs(int cur,int len){

        if(len == k){
            int cnt = 0;

            for(int i=0;i<n;i++){
                boolean read = true;

                for(int j = 0; j< words[i].length(); j++){

                    if (!visit[words[i].charAt(j) - 'a']) {
                        read = false;
                        break;
                    }
                }
                if(read)
                    cnt++;
            }

            ans = Math.max(ans,cnt);
            return;
        }

        for(int i=cur;i<26;i++){
            if(!visit[i]){
                visit[i]=true;
                dfs(i,len+1);
                visit[i]=false;
            }
        }
    }
}

[BOJ] 백준 [2573] 빙산 JAVA

김까따 — Mon, 30 May 2022 00:45:00 +0900

https://www.acmicpc.net/problem/2573

2573번: 빙산

첫 줄에는 이차원 배열의 행의 개수와 열의 개수를 나타내는 두 정수 N과 M이 한 개의 빈칸을 사이에 두고 주어진다. N과 M은 3 이상 300 이하이다. 그 다음 N개의 줄에는 각 줄마다 배열의 각 행을

www.acmicpc.net

문제

풀이

탐색문제인데 , 탐색할 때 마다 다른 노드에 영향을 끼치는 유형이며 큐를 이용해야 하는 문제이다.

isSeprated() 함수로 분리가 되었는지에 대한 검사를 계속 시행하면서
만약 분리가 되지 않은 경우 전 좌표를 살피면서 동서남북으로 바다가 있는지 검사한다.
검사한 결과가 0보다 클 경우 큐에 삽입.

if 큐가 비어있을 경우 => 분리 불가능. break

import java.io.*;
import java.util.*;
import java.util.stream.IntStream;

import static java.util.Arrays.stream;


public class Main {

    static int[] dx={0,0,1,-1},dy={1,-1,0,0};
    static int w,h;
    static int[][] map;
    static boolean[][] visit;

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    public static void main(String[] args) throws IOException {
        StringTokenizer st = new StringTokenizer(br.readLine()," ");

        h = Integer.parseInt(st.nextToken());
        w = Integer.parseInt(st.nextToken());
        map = new int[h][w];
        for(int i=0;i<h;i++){
            map[i] = stream(br.readLine().split(" "))
                                .mapToInt(Integer::parseInt)
                                .toArray();

        } // end input

        int answer=0;

        while (!isSeparate()){

            LinkedList<int[]> q = new LinkedList<>();

            for(int i=0;i<h;i++){
                for(int j=0;j<w;j++){
                    if(map[i][j]>0){
                        q.add(new int[]{j,i, countNearBy(j, i)}); // x,y,count
                    }
                }
            }

            if (q.isEmpty()) {
                answer = 0;
                break;
            }

            while (!q.isEmpty()){
                int[] cur = q.poll();
                int x = cur[0];
                int y = cur[1];
                int cnt = cur[2];
                map[y][x] = map[y][x] > cnt? map[y][x]-cnt : 0;
            }
            answer++;
        }

        System.out.println(answer);

    }

    static boolean isRange(int x,int y){

        return x>=0&&y>=0&&x<w&&y<h;
    }
    static int countNearBy(int x,int y){

        return (int) IntStream.range(0, 4)
                .filter(i -> isRange(x, y))
                .filter(i->map[y + dy[i]][x + dx[i]] == 0)
                .count();
    }
    static boolean isSeparate(){

        visit = new boolean[h][w];
        int cnt=0;
        for(int i=0;i<h;i++){
            for(int j=0;j<w;j++){
                if(!visit[i][j] && map[i][j]!=0) {
                    dfs(j, i, visit);
                    cnt++;
                }
            }
        }
        return cnt>1;
    }

    static void dfs(int x,int y,boolean[][] visit){

        visit[y][x]=true;

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

            int nextX = x+dx[i];
            int nextY = y+dy[i];

            if(isRange(nextX,nextY) && map[nextY][nextX]!=0 && !visit[nextY][nextX])
                dfs(nextX,nextY,visit);
        }
    }
}

[BOJ] 백준 [13458] 시험감독 JAVA

김까따 — Mon, 30 May 2022 00:37:50 +0900

https://www.acmicpc.net/problem/13458

13458번: 시험 감독

첫째 줄에 시험장의 개수 N(1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄에는 각 시험장에 있는 응시자의 수 Ai (1 ≤ Ai ≤ 1,000,000)가 주어진다. 셋째 줄에는 B와 C가 주어진다. (1 ≤ B, C ≤ 1,000,000)

www.acmicpc.net

문제

풀이

1. 각 시험장 마다 총 감독원이 꼭 있어야 함
2. 시험장 인원을 부감독 수로 나눔

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import static java.util.Arrays.stream;


public class Main {



    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        int[] arr = stream(br.readLine().split(" "))
                            .mapToInt(Integer::parseInt).sorted()
                            .toArray();


        int[] input = stream(br.readLine().split(" "))
                            .mapToInt(Integer::parseInt)
                            .toArray();
        int b = input[0];
        int c = input[1];

        long answer = 0;
        for(int i=0;i<n;i++){

            arr[i] -= b;
            answer++;

            if(arr[i]<0)
                continue;

            answer+=arr[i]/c;

            if(arr[i]%c>0)
                answer++;
        }

        System.out.println(answer);
    }
}

[BOJ] 백준 [17136] 색종이붙이기 JAVA

김까따 — Wed, 25 May 2022 01:53:31 +0900

https://www.acmicpc.net/problem/17136

17136번: 색종이 붙이기

<그림 1>과 같이 정사각형 모양을 한 다섯 종류의 색종이가 있다. 색종이의 크기는 1×1, 2×2, 3×3, 4×4, 5×5로 총 다섯 종류가 있으며, 각 종류의 색종이는 5개씩 가지고 있다. <그림 1> 색종이를 크

www.acmicpc.net

문제

풀이

이 문제의 핵심은 그리디하게 접근해서는 풀 수 없는 문제이다.

반례)
0 0 0 0 0 0 0 0 0 0
0 0 1 1 1 1 1 1 0 0
0 0 1 1 1 1 1 1 0 0
0 0 1 1 1 1 1 1 0 0
0 0 1 1 1 1 1 1 0 0
0 0 1 1 1 1 1 1 0 0
0 0 1 1 1 1 1 1 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

답은 4인데, 큰 것 부터 차례대로 붙이면 4보다 많은 갯수가 나온다.
따라서 완전탐색을 진행해야한다.

1. 주어진 좌표에서 1 찾기
2. 해당 좌표(top-left) 기준으로 사이즈마다 모두 가능한지 검사하기
3. 2번이 가능하다면 해당 좌표를 -1로 두고 1번을 반복(dfs)
4. 3번의 과정이 끝이나면 백트래킹

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import static java.util.Arrays.stream;


public class Main {

    static int[][] map = new int[10][10];
    static int[] arr = new int[6];
    static int min = 26;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        for(int i=0;i<10;i++){
            map[i] = stream(br.readLine().split(" "))
                                .mapToInt(Integer::parseInt)
                                .toArray();
        }
        Arrays.fill(arr,5);
        arr[0]=0;

        dfs();

        System.out.println(min>25?-1:min);
    }

    private static void dfs() {

        int[] point = find();

        if(point[0] == -1 && point[1]==-1){ // 최소값 갱신 or 종결조건:탐색 끝좌표
            int cnt = 25 - stream(arr).sum();
            min = Math.min(min, cnt);
            return;
        }

        int x = point[0];
        int y = point[1];


        for (int size = 5; size >= 1; size--) {
            if (arr[size] > 0 && canAttach(x, y, size)) {
                attach(x, y, size); //붙이기
                dfs();
                attach(x, y, size); //떼기
            }
        }

    }

    private static int[] find() { // 좌표찾기

        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++){
                if(map[i][j]==1)
                    return new int[]{j,i};
            }
        }
        return new int[]{-1,-1};
    }

    private static void attach(int x, int y, int size) {
        for (int i = y; i < y + size; i++) {
            for (int j = x; j < x + size; j++) {
                map[i][j]*=-1;
            }
        }

        arr[size] += map[y][x];
    }

    private static boolean canAttach(int x, int y, int size) {
        for(int i=y;i<y+size;i++){
            for(int j=x;j<x+size;j++){
                if(!isRange(j,i) || map[i][j]!=1) // 0: 못붙이는자리 -1: 이미 붙여진 자리
                    return false;
            }
        }
        return true;
    }

    private static boolean isRange(int x, int y) {
        return x>=0&&y>=0&&x<10&&y<10;
    }
}

[JPA] JPA 개요 및 영속성 컨텍스트

김까따 — Tue, 24 May 2022 02:40:56 +0900

ORM 개요

OOP 시대에 객체를 RDBMS에 관리하다 보니 SQL 중심적인 개발을 하게 됨으로써 나타나는 문제점들을 해결하기 위해 도입.

객체는 ↔ RDBMS 사이를 매끄럽게 연결하여 SQL 의존성을 덜어내고 OOP 중점적으로 개발을 하는 것이 목표.

JPA (Java Persistense Api)

현재 Java 진형의 ORM 표준으로 인터페이스이고 구현체는 Hibernate, EclipseLink, DataNucleus 등

그 중 Hibernate 가 우리가 흔히 쓰는 구현체이다.

SpringDataJPA

JPA를 한 단계 더 추상화 시켜 개발을 편하게 해주는 Spring에서 제공하는 인터페이스

JPA 구동방식

persistence.xml에 jdbc 관련 정보 ( driver, username, password, url ) 등을 읽어와서
EntityManagerFactory에 저장하고 EntityManager 를 통해 작업을 한다.

EntityManagerFactory 는 하나만 생성해서 어플리케이션 전체에 공유되고
Threadsafe 한 EntityManager를 생성**하고 내부엔 영속성 컨텍스트가 있음.
한번 사용한 EntityManager 는 사용 후 버려지는데 사용 단위는 Transaction 범위

영속성 컨텍스트

엔티티를 영구적으로 저장하는 공간이며 내부에 1차캐시가 있다.

DB에서 데이터를 조회할 땐 무조건 1차캐시를 먼저 확인하고 없으면 1차캐시로 데이터를 영속화를 한 후에 값을 반환한다.

Entity의 생명주기

Entity의 상태는 비영속, 영속, 준영속, 삭제총 4가지로 나타낼 수 있음.

비영속 (new)

단순히 엔티티를 새로 생성한 상태

Member member = new Member("kim");

영속 (Managed)

새로 생성한 엔티티가 영속성 컨텍스트에 의해 관리되는 상태
저장 or 조회를 실행하면 영속성컨텍스트가 먼저 엔티티를 관리한다.

EntityManager.persist(member); // 저장
EntityManager.find(id); //조회

준영속 (detach)

영속성 컨텍스트가 엔티티를 관리하지 않는 상태
Query가 commit을 호출해도 영속성을 거치지 않는 상태이기 때문에 동작하지 않음
1차캐시에 남아있지 않으므로 당연히 DirtyChecking 기능도 동작하지 않음
영속성컨텍스트의 모든 기능을 이용할 수 없는 상태이다.

EntityManager.detach(member); // 준영속으로 만들기
EntityManager.clear() // 영속성 컨텍스트 초기화

삭제 (removed)

엔티티를 삭제한 상태

EntityManager.remove(member); // 삭제 명령

영속성 컨텍스트 Flush

엔티티의 생명주기는 위와 같으며, Transaction.commit() 과 같이 커밋이 호출되어야 DB에 반영이 된다. 이를 Flush 라고 한다.
그 전까진 영속성컨텍스트가 붙잡고 있는 상태이다. ( Flush가 되어도 영속성 컨텍스트가 사라지는건 x )

그럼 커밋이 호출되는 시점, 즉 DB에 반영되는 시점 기준은 언제일까

EntityManager.flush() 를 직접호출
Transaction commit (자동호출)
JPQL 쿼리를 직접 날림 (자동호출)

위 3가지 조건일 때 DB에 작업한 내용이 반영이 된다. ( 반영이 되어도 영속성 컨텍스트엔 내용이 남아 있음)

영속성 컨텍스트의 이점

위와 같은 내용을 바탕으로 영속성컨텍스트에 의해 관리를 받을때 얻을 수 있는 이점이 있다.

1. Entity 동일성 (==) 보장

데이터 값이 같은 두 객체는 참조하는 주소 값이 다르다.

하지만 EntityManager에 의해 관리되는 상태이면 두 객체는 같은 참조를 지닌다.

@Slf4j
@SpringBootTest
@Transactional
class UserTest {

    @Autowired
    EntityManager entityManager;

    @DisplayName("userA id 값으로 조회")
    @Test
    void same(){
        User userA = new User("userA");
        entityManager.persist(userA);

        User findUser = entityManager.find(User.class, userA.getId());

        log.info("user A = {}", userA);
        log.info("findUser = {}",findUser);

        Assertions.assertSame(userA,findUser);
    }
}

2. 쓰기지연

모든 데이터 변경 Query를 쓰기지연 저장소에 보관해 놨다가 commit을 수행할 때 한번에 날린다.

@Slf4j
@SpringBootTest
@Transactional
@Rollback(false)
class UserTest {

    @Autowired
    EntityManager entityManager;

    @Test
    void lazy(){

        log.info("===== persist 효출 전 =====");
        User userA = new User("userA");
        entityManager.persist(userA);
        log.info("===== persist 효출 후 =====");

    }
}

persist 를 호출해도 바로 insert query가 발생하지 않고 commit시점에 호출이 된다.

3. DirtyChecking

@Slf4j
@SpringBootTest
@Transactional
@Rollback(false)
class UserTest {

    @Autowired
    EntityManager entityManager;

    @Test
    void dirtyChecking(){

        User userA = new User("userA");
        entityManager.persist(userA);

        userA.setName("userB");

        entityManager.flush();
        entityManager.clear();

        User userB = entityManager.find(User.class, userA.getId());
        log.info("변경 후 = {}",userB);
    }
}

모든 Entity는 영속성 컨텍스트에서 관리되며 데이터의 CRUD를 추적.

변경이 일어나면 영속성 컨텍스트에서 DirtyChecking을 통해 1차캐시에서 먼저 조회를 한 후 스냅샷과 값이 다르면 commit 시점에 이를 반영한다.

4. 지연로딩

만약 연관관계에 있는 두 Entity 중(ex. user, team) 하나(user)를 호출 하였을때
그 와 연관된 다른 엔티티는 실제로 호출되기 전 까진 호출되지 않는다.

User만 호출 했을 경우 (user에 대한 select query 한번만 나감)

@Slf4j
@SpringBootTest
@Rollback(value = false)
@Transactional
class UserTest {

    @Autowired
    EntityManager entityManager;

    Long userId;

    @BeforeEach
    void save(){

        User userA = new User("userA");
        Team team = new Team("team");

        team.users.add(userA);

        userA.setTeam(team);

        entityManager.persist(team);
        userId = userA.getId();

        // 영속성 컨텍스트 초기화
        entityManager.flush();
        entityManager.clear();
    }

    @Test
    @DisplayName("team is null")
    void test(){

        User user = entityManager.find(User.class, userId);
        Team team = user.getTeam();

        Assertions.assertNull(team.name);
    }
}

User의 Team 까지 호출 하였을 경우 (프록시 강제초기화)

@Test
    @DisplayName("team is not null")
    void test(){

        User user = entityManager.find(User.class, userId);
        String teamName = user.getTeam().getName();

        Assertions.assertNotNull(teamName);
    }

team 의 getName() 을 호출해야만 team에 대한 select query가 한번 더 나간다.
즉, 실제로 사용하기 전 까진 query가 발생하지 않아 리소스 절감에 도움이 된다.

이 옵션을 사용하기 위해선 연관관계를 지정할때 FetchType=Lazy로 설정해야 동작함.
(Default 옵션으로 Eager 이 설정되어 있어 query가 user만 호출해도 2번 발생함)
보통 @X To One 관계일때 Lazy로 걸어둔다. ( 최적화 관련 옵션 )

연관관계

DB의 한쪽 엔티티가 다른 엔티티와의 연관된 데이터를 이용하기 위해선 한쪽에서 외래키를 가지고 있어야 한다.

JPA에서는 필드에 외래키로 관리하는 대신 엔티티를 필드에 추가하고 연관관계의 주인을 지정해준다. ( FK 를 가지고 있는 쪽이 연관관계의 주인이다.)

@Entity
@Setter @Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class User {

    @Id
    @GeneratedValue
    Long id;
    String name;

    @JoinColumn(name = "team_id")
    @ManyToOne(fetch = FetchType.LAZY)
    Team team;

    public User(String name) {
        this.name = name;
    }

}

@Entity
@Setter @Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Team {

    @Id @GeneratedValue
    Long id;
    String name;

    @OneToMany(mappedBy = "team",cascade = CascadeType.ALL) 
    List<User> users = new ArrayList<>();

    public Team(String name) {
        this.name = name;
    }
}

연관관계의 종류

N:M (@ManyToMany) ⇒ 필드추가가 불가능하므로 일대다 다대일로 풀어쓴다.
1:N (@OneToMany) ⇒ mappedby 옵션으로 연관관계의 주인을 지정
N:1 (@ManyToOne) ⇒ 외래키 지정
1:1 (@OneToOne) ⇒ 외래키 지정

출처 : 자바 ORM 표준 JPA 프로그래밍

[Spring] 폼 유효성(validation) 검사하기

김까따 — Tue, 24 May 2022 02:35:17 +0900

폼 입력 유효성 검사하기

Validation 개요

사용자가 만약 특정 로직을 수행 했는데 잘못된 입력으로 인해 어플리케이션이 오작동을 하면 안된다. 그러므로 검증을 통해 처리해 줘야 함.

Validation 사용

검증을 수행하기 위해선 다음과 같은 의존성 모듈이 필요

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

검증을 위한 라이브러리는 두 가지가 있다.

javax 표준 스펙(jsr-303) Bean Validator : 공식문서
hibernate validator : 공식문서

@Valid 는 annotation 이 javax 표준 검증기이고 컨트롤러 메소드 유효성 검사만 가능.
@Validated 는 Spring 에서 지원해주는 검증기이고 다른 계증에서도 사용이 가능. (AOP기반)

LocalValidatorFactoryBean 이 annotation을 보고 검증을 수행.
실무에선 대부분 hibernate 의 validator를 사용한다고 한다.

검사 규칙 선언하기 예시

package springinaction.tacos.entity;

import lombok.Data;
import org.hibernate.validator.constraints.CreditCardNumber;

import javax.validation.constraints.Digits;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;

@Data
public class Order {

    @NotBlank(message = "Name is required")
    private String deliveryName;

    @NotBlank(message = "Street is required")
    private String deliveryStreet;

    @NotBlank(message = "City is required")
    private String deliveryCity;

    @NotBlank(message = "State is required")
    private String deliveryState;

    @NotBlank(message = "Zip code is required")
    private String deliveryZip;

    @CreditCardNumber(message = "Not a valid credit card number")
    private String ccNumber;

    @Pattern(regexp = "^(0[1-9]|1[0-2])([\\/])([1-9][0-9])$",
            message = "Must be formatted MM/YY")
    private String ccExpiration;

    @Digits(integer = 3, fraction = 0, message = "Invalid CVV")
    private String ccCVV;
}

package springinaction.tacos.entity;

import lombok.Data;
import net.bytebuddy.implementation.bind.annotation.Empty;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import java.util.List;

@Data
public class Taco {

    @NotBlank
    @Size(min=5,message = "최소 5글자 필요")
    private String name;

    @Size(min=1, message = "최소 하나이상의 재료필요")
    private List<String> ingredients;
}

@CreditCardNumber 와 같은 검증은 hibernate 의 validator가 수행한다는 것을 알 수 있다.

폼과 바인딩 그리고 검증

사용자가 입력한 form 을 통해 서버로 넘어왔다고 가정하면 @Valid annotation 이 붙어 있는 필드를 검증하게 된다. 그리고 검증이 실패할 시 Errors 에 담긴다.

@PostMapping
    public String processDesign(@Valid Taco design, Errors errors) {
        if (errors.hasErrors()) {
            List<FieldError> list = errors.getFieldErrors();
            list.forEach(e->log.error(e.getDefaultMessage()));

            return "design";
        }

        log.info("Processing design: " + design);
        return "redirect:/orders/current";
    }

참고) 검증 결과를 담은 BindingResult와 fieldError grobalError 등이 있다.

fieldError는 messageConverter 작동이 성공해서 정상적으로 바인딩을 하고 나서 필드 유효성을 검증한 뒤에 실패하면 BingdingResult에 담겨지고
grobalError는 비즈니스로직 관련해서 발생한 오류를 BingdingResult에 담는다.
( BindingResult는 Errors를 상속받은 인터페이스임 )

만약 바인딩 자체에 실패한다면 ..? 컨트롤러가 호출되지 않음 .. !

만약 검증에 실패시 bindingResult.hasErrors() 를 수행해서 예외 처리를 하는 방식으로 한다.
추후 뒷장에 더 상세하게 나와있으니 pass

에러 메세지 출력해보기

2022-05-15 02:27:10.705  INFO 11824 --- [nio-8080-exec-7] s.t.web.controller.DesignTacoController  : Processing design: Taco(name=12345, ingredients=[FLTO, GRBF, CHED, TMTO, SLSA])
2022-05-15 02:27:18.455 ERROR 11824 --- [nio-8080-exec-1] s.tacos.web.controller.OrderController   : Must be formatted MM/YY
2022-05-15 02:27:18.456 ERROR 11824 --- [nio-8080-exec-1] s.tacos.web.controller.OrderController   : Not a valid credit card number

만약 검증에 실패한다면

사용자가 입력한 form 검증이 실패하면 다시 입력할 수 있도록 입력폼을 불러와야 하는데 이전의 입력한 값들을 유지하고 싶다면 Thymeleaf 에서 다음과 같이 수행할 수 있다.

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="EUC-KR">
    <title>Taco Cloud</title>
    <link rel="stylesheet" th:href="@{/css/styles.css}"/>
</head>
<body>

<form method="POST" th:action="@{/orders}" th:object="${order}">
    <h1>Order your taco creations!</h1>

    <img th:src="@{/images/TacoCloud.png}"/> <a th:href="@{/design}" id="another">Design another taco</a><br/>

    <div th:if="${#fields.hasErrors()}">
            <span class="validationError"> Please correct the problems below and resubmit. </span>
    </div>

    <h3>Deliver my taco masterpieces to...</h3>

    <label for="deliveryName">Name: </label>
    <input type="text" id="deliveryName" th:field="*{deliveryName}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('deliveryName')}"
          th:errors="*{deliveryName}">Name Error</span>
    <br/>

    <label for="deliveryStreet">Street address: </label>
    <input type="text" id="deliveryStreet" th:field="*{deliveryStreet}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('deliveryStreet')}"
          th:errors="*{deliveryStreet}">Street Error</span>
    <br/>

    <label for="deliveryCity">City: </label>
    <input type="text" id="deliveryCity" th:field="*{deliveryCity}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('deliveryCity')}"
          th:errors="*{deliveryCity}">City Error</span>
    <br/>

    <label for="deliveryState">State: </label>
    <input type="text" id ="deliveryState" th:field="*{deliveryState}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('deliveryState')}"
          th:errors="*{deliveryState}">State Error</span>
    <br/>

    <label for="deliveryZip">Zip code: </label>
    <input type="text" id ="deliveryZip" th:field="*{deliveryZip}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('deliveryZip')}"
          th:errors="*{deliveryZip}">Zip Error</span>
    <br/>

    <h3>Here's how I'll pay...</h3>
    <label for="ccNumber">Credit Card #: </label>
    <input type="text" id ="ccNumber" th:field="*{ccNumber}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('ccNumber')}"
          th:errors="*{ccNumber}">CC Num Error</span>
    <br/>

    <label for="ccExpiration">Expiration: </label>
    <input type="text" id ="ccExpiration" th:field="*{ccExpiration}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('ccExpiration')}"
          th:errors="*{ccExpiration}">CC Num Error</span>
    <br/>

    <label for="ccCVV">CVV: </label>
    <input type="text" id ="ccCVV" th:field="*{ccCVV}"/>
    <span class="validationError"
          th:if="${#fields.hasErrors('ccCVV')}"
          th:errors="*{ccCVV}">CC Num Error</span>
    <br/>

    <input type="submit" value="Submit order"/>
</form>
</body>
</html>

tip) input 태그에 id 값을 추가로 넣어주면 해당 input 태그의 id 식별이 가능해서 추적이 용이함.

th:field = *{필드명} 을 통해 field 를 식별하고
th:if="${#fields.hasErrors('필드명')}” 을 통해 만약 그 field 에서 오류가 발생하면
th:errors="*{필드명}" 과 같이 에러가 발생한 필드를 재 출력한다.

이 외 만약 에러가 발생했을 경우 별도로 css class를 적용할 수 있는
th : errorclass 를 타임리프가 지원해준다.

출처 : 스프링 인 액션

[BOJ] 백준 [15787] 기차가 어둠을 헤치고 은하수를 JAVA

김까따 — Thu, 19 May 2022 00:17:39 +0900

https://www.acmicpc.net/problem/15787

15787번: 기차가 어둠을 헤치고 은하수를

입력의 첫째 줄에 기차의 수 N(1 ≤ N ≤ 100000)과 명령의 수 M(1 ≤ M ≤ 100000)가 주어진다. 이후 두 번째 줄부터 M+1번째 줄까지 각 줄에 명령이 주어진다.

www.acmicpc.net

문제

풀이

주어진 수의 범위가 커서 비트 마스킹으로 풀어야 하는 문제이다.

0000...00000 으로 총 21개의 0으로 기차의 상태를 체크한다. ( << 연산을 적용하면 10 부터 시작하기 때문)
명령의 경우

case 1 => 해당 위치에 << 연산을 적용시킨 결과와 or 연산 적용
case 2 => 1번에 not 을 적용시킨 결과와 and 연산 적용
case 3 => << 연산으로 한칸 밀어내고 21개의 1 과 and 연산으로 사이즈 조절
case 4 => >> 연산으로 한칸 밀어내고 not 연산을 적용시킨 ( 11111110) 과 and 연산

나올 수 있는 모든 경우를 카운트한다.

참고) 비트마스크 연산

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.Arrays.stream;


public class Main {

    static int n, m;
    static int[] trains;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();
        n = input[0];
        m = input[1];
        trains = new int[n + 1];

        for (int i = 0; i < m; i++) { // command

            input = stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .toArray();

            int command = input[0];
            int index = input[1];
            int seat = input.length == 2 ? 0 : input[2];

            switch (command) {
                case 1 -> trains[index] |= (1 << seat);
                case 2 -> trains[index] &= ~(1 << seat);
                case 3 -> {
                    trains[index] <<= 1;
                    trains[index] &= ((1 << 21) - 1);
                }
                case 4 -> {
                    trains[index] >>= 1;
                    trains[index] &= ~1;
                }
            }
        }

        int ans = (int) stream(trains, 1, n + 1)
                .distinct()
                .count();

        System.out.println(ans);
    }
}

[BOJ] 백준 [1052] 물병JAVA

김까따 — Wed, 18 May 2022 23:08:00 +0900

https://www.acmicpc.net/problem/1052

1052번: 물병

지민이는 N개의 물병을 가지고 있다. 각 물병에는 물을 무한대로 부을 수 있다. 처음에 모든 물병에는 물이 1리터씩 들어있다. 지민이는 이 물병을 또 다른 장소로 옮기려고 한다. 지민이는 한 번

www.acmicpc.net

문제

풀이

경우의 수 를 하나씩 따져보면 -1 을 출력할 일은 없다.

우선 물통을 안사고 최대한 합친다고 해보자
주어진 n 이 다음과 같을 때 하나씩 보자.

case 1 : 0
case 2 : 1
case 3 : 2 1
case 4 : 4
case 5 : 4 1
case 6 : 4 2
...
남는 물병이 점점 늘어난다. => 병이 모자랄 일은 x
그리고 2^n 의 갯수이면 물병을 사지 않아도 된다.

ex) n=13 k=2 이면
안사고 최대한 합칠 수 있는 경우는 [8 4 1] 이다. k 보다 크다.
하지만 3병을 더 사면 [16] . 즉, 한 병에 모두 담아갈 수 있다.

이제 k개의 물병에 나눠 가져간다고 해보자.

1. 주어진 물 n 이 k 보다 이하 라면 ? => 그냥 다 들고 가면 됨
2. 주어진 물 n 이 k 보다 작다면 ?? => 물병들을 일부 합쳐서 가져가야 됨

2번의 과정은 2^n 형태로 만드는 과정이다. 1번의 조건이 만족할 때 까지.
2^n 형태로 만들기 위해 필요한 추가 물병의 갯수를 구하면 된다.

n=13 : 물병의 갯수가 홀수이면 하나가 계속 남기때문에 1개를 추가구매한다. 그리고 2로 나눈다. => 7
n=7 : 물병의 개수가 홀수이므로 1개를 추가 구매하고 2로 나눈다. => 3
n=3 : 2
즉 , 3개를 더 사면 n=13 k=2를 만족한다.

if( n%2 == 1) :
n = n/2
cnt++
n++

이런식으로 진행하지만 비트마스킹을 이용해 풀 수 있다.

n을 2진수로 변환했을 때 1의 갯수가 k 보다 클 동안 반복 :
1이 처음으로 나타나면 합칠 때 홀수가 발생하는 숫자이므로 그 위치의 수 만큼 cnt를 늘려준다.

cnt += n&(-n)
n+=n&(-n)

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.Arrays.stream;


public class Main {

    static int n, k;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();
        n = input[0];
        k = input[1];
        
        int ans = 0;

        while (Integer.bitCount(n) > k) {
            ans += n & (-n);
            n += n & (-n);
        }
        System.out.println(ans);
    }
}

[BOJ] 백준 [17124] 두개의배열 JAVA

김까따 — Sat, 14 May 2022 01:14:27 +0900

https://www.acmicpc.net/problem/17124

17124번: 두 개의 배열

정수 배열 A 와 B가 있다. A는 총 n개의 서로 다른 양의 정수를 포함하고 B는 총 m개의 서로 다른 양의 정수를 포함한다. A, B를 이용해서 길이가 n인 새로운 배열 C를 만들어보자. C[i] 는 배열 B에 있

www.acmicpc.net

문제

풀이

이분탐색 or 이진탐색 문제이다.

해당 위치를 기준으로 앞 뒤를 파악해야 하므로 lower higher 메서드를 제공해주는
TreeSet을 이용한다.

B 배열이 기준이므로 B배열을 TreeSet으로 만든다음
A 배열 원소만큼 반복문을 돌린다.

찾은 결과 원소를 result 라고 하면
1. bSet 이 원소 e 를 가지고 있을 경우 => result = e
2. 가지고 있지 않을 경우
2-1. bSet 에 e 를 추가해서 lower higher 를 호출
2-2. lower = null => 추가한 원소가 맨 앞 자리이므로 result = higher
higher = null => 추가한 원소가 맨 뒷 자리이므로 result = lower
그 외 => e-lower 과 e-higher 를 비교해서 가장 차이가 적은 것이 result

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.Arrays.stream;


public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int tc = Integer.parseInt(br.readLine());
        while (tc-->0){ br.readLine();

            long sum = 0L;

            ArrayList<Integer> listA = stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .boxed()
                    .collect(Collectors.toCollection(ArrayList::new));

            TreeSet<Integer> setB = stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .boxed()
                    .collect(Collectors.toCollection(TreeSet::new)); // 기준 Set

            for (Integer e : listA) {

                int result=e; // 기준 Set 에 이미 있는 요소이면 바로 출력

                if(!setB.contains(e)){ // 없는 요소이면 위치 찾기

                    // 추가한 요소의 앞 뒤 확인
                    setB.add(e);
                    Integer lower = setB.lower(e);
                    Integer higher = setB.higher(e);

                    if(lower == null) // 맨 앞자리일 경우
                        result = higher;
                    else if(higher==null)  // 맨 뒷자리일 경우
                        result = lower;
                    else result = Math.abs(e - lower) <= Math.abs(e - higher) ?
                                lower : higher; // lower-e-higher >> 이 형태로 있으므로 앞 뒤 차이 계산해서 결정

                    setB.remove(e); // 다시 제거
                }
                sum+=(long)result;
            }
            System.out.println(sum);
        }
    }
}

/**

 *
 */

[BOJ] 백준 [19236] 청소년 상어JAVA

김까따 — Wed, 11 May 2022 21:51:18 +0900

https://www.acmicpc.net/problem/19236

19236번: 청소년 상어

첫째 줄부터 4개의 줄에 각 칸의 들어있는 물고기의 정보가 1번 행부터 순서대로 주어진다. 물고기의 정보는 두 정수 ai, bi로 이루어져 있고, ai는 물고기의 번호, bi는 방향을 의미한다. 방향 bi는

www.acmicpc.net

문제

풀이

DFS 완전 탐색 문제이다.
중요한건 배열을 미리 clone 시켜놓고 탐색을 진행하고나서 다시 백트래킹 할 때 복제해둔 배열로 원복하는 것.

물고기가 움직일 때 : moveFish
1. 해당위치에 물고기가 없는 경우 => 단순 물고기만 이동
2. 해당위치에 상어가 있는 경우 => 이동 x
3. 그 외 => 두 물고기위 위치를 swap

상어를 기준으로 dfs 를 호출할 때 마다 moveFish 를 호출해주고
상어가 움직이면서 먹을 수 있는 물고기의 최대 max 값을 갱신시키면 된다.

import java.util.*;

import static java.util.Arrays.stream;


public class Main {
    
    static Fish[] fish = new Fish[17];
    static int[][] map = new int[4][4];
    static int max = 0;
    static int[] dx = {0, -1, -1, 0, 1, 1, 1, 0, -1};
    static int[] dy = {0, 0, -1, -1, -1, 0, 1, 1, 1};
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                int fishNum = sc.nextInt();
                int fishDir = sc.nextInt();
                map[i][j] = fishNum;
                fish[fishNum] = new Fish(i, j, fishDir, true);
            }
        }
        //첫번째 위치 먹고 start
        int fishNum = map[0][0];
        fish[fishNum].alive = false;
        map[0][0] = -1;
        dfs(0, 0, fish[fishNum].dir, fishNum);
        System.out.println(max);
    }

    //상어 위치 (x, y)
    public static void moveFish(int x, int y) {
        for (int i = 1; i <= 16; i++) {
            Fish moveFish = fish[i];
            
            //이미 먹은 물고기인 경우
            if (!moveFish.alive) 
                continue;

            //8방향 이동여부 확인
            for (int j = 0; j < 8; j++) {
                int nextDir = (moveFish.dir + j) >= 9 ? (moveFish.dir + j) % 8 : (moveFish.dir + j);
                int nextX = moveFish.x + dx[nextDir];
                int nextY = moveFish.y + dy[nextDir];

                if (!isRange(nextX,nextY)|| (nextX == x && nextY == y)) // 해당위치에 상어가 있으면 continue
                    continue;

                if (map[nextX][nextY] != -1) { // 물고기가 살아있어 위치를 바꿀때
                    Fish otherFish = fish[map[nextX][nextY]];
                    map[moveFish.x][moveFish.y] = map[nextX][nextY];
                    map[nextX][nextY] = i;
                    otherFish.x = moveFish.x;
                    otherFish.y = moveFish.y;

                } else { // 이미 죽은 물고기라서 단순 위치만 이동시킬 때
                    map[moveFish.x][moveFish.y] = -1;
                    map[nextX][nextY] = i;
                }
                moveFish.x = nextX;
                moveFish.y = nextY;
                moveFish.dir = nextDir;
                break;
            }

        }
    }

    public static void dfs(int x, int y, int d, int sum) {
        //결과값 갱신
        if (max < sum) max = sum;

        //fish, map 상태 저장해둠
        Fish[] cloneFish = new Fish[17];
        for (int i = 1; i < 17; i++)
            cloneFish[i] = new Fish(fish[i].x, fish[i].y, fish[i].dir, fish[i].alive);
        int[][] cloneMap = new int[4][4];
        for (int i = 0; i < 4; i++) {
            cloneMap[i] = map[i].clone();
        }
        moveFish(x, y); // 물고기 이동,회전

        for (int i = 1; i < 4; i++) { // 상어 이동
            int nextX = x + dx[d] * i;
            int nextY = y + dy[d] * i;

            if (!isRange(nextX,nextY))
                continue;

            int fishNum = map[nextX][nextY];
            if (fishNum != -1) {
                //살아있는 물고기가 있는 경우
                fish[fishNum].alive = false;
                map[nextX][nextY] = -1;
                dfs(nextX, nextY, fish[fishNum].dir, sum + fishNum); // 탐색

                // 백트래킹
                fish[fishNum].alive = true;
                map[nextX][nextY] = fishNum;
            }
        }

        //fish, map 상태 복구
        fish = cloneFish.clone();
        for (int i = 0; i < 4; i++)
            map[i] = cloneMap[i].clone();
    }

    static boolean isRange(int x,int y){
        return x>=0&&y>=0&&x<4&&y<4;
    }

    public static class Fish {
        int x, y, dir;
        boolean alive;

        public Fish(int x, int y, int dir, boolean alive) {
            this.x = x;
            this.y = y;
            this.dir = dir;
            this.alive = alive;
        }
    }
}

[BOJ] 백준 [10844] 쉬운계단수JAVA

김까따 — Wed, 11 May 2022 02:31:41 +0900

https://www.acmicpc.net/problem/10844

10844번: 쉬운 계단 수

첫째 줄에 정답을 1,000,000,000으로 나눈 나머지를 출력한다.

www.acmicpc.net

문제

풀이

DP 를 활용한 문제이다.
우선 1~9 까지는 한자리 수 니깐 1 이다.

여기서 2번째 자리수는 다음과 같은 상황이 나온다.
0 + ?
1 + ?
2 + ?
3 + ?
4 + ?
...
9 + ?
여기서 ? 에 올 숫자는 이전 숫자보다 +1 또는 -1 이다.

그런데, 예외가 있다.
만약 9 가 나왔다면 다음은 무조건 8만 나와야 한다. ( 98 )
그리고 0 이라면 이전은 다음건 1만 나와야 한다. 예를들어 10 ? 이 경우엔 다음수는 1만 가능 => 101
그럼 끝자리 경우 자체가 결정자가 될수 있다는 말이고 , 주어진 n 에 대해서도 결정자가 되어야 하니
점화식은 dp[자리수][0~9] 로 식을 세울 수 있다.
=> dp[i][j] = dp[i-1][j-1] + dp[i-1][j+1]

0과 9일때 예외를 제외하고 bottom-up 방식 점화식

import java.io.*;
import java.util.*;
import static java.util.Arrays.stream;

public class Main {

    static int limit = 1000000000;
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        long[][] dp = new long[n+1][10];

        Arrays.fill(dp[1],1);
        dp[1][0]=0;

        for(int i=2; i<=n; i++){
            for(int j=0; j<10; j++){

                long next = switch (j){ // 숫자 + j
                    case 0->dp[i-1][1]; // 0 일경우 다음은 1만 와야됨
                    case 9->dp[i-1][8]; // 9 일경우 다음은 8만 와야됨
                    default -> dp[i-1][j-1]+dp[i-1][j+1] % limit;
                };
                dp[i][j] = next;
            }
        }
        long result = stream(dp[n])
                .reduce((sum, e) -> (sum + e) % limit)
                .getAsLong();
        System.out.println(result);

    }
}

Spring 구조와 Component

김까따 — Sat, 7 May 2022 02:26:57 +0900

스프링 구조

어플리케이션은 기본적으로 Components 간의 상호작용으로 동작하는데
Component 또는 Bean 형태로 스프링 컨테이너인 ApplicationContext 라는 DI 컨테이너에 올려두고 관리 되는 구조.

ApplicationContext 와 Bean 등록

빈을 등록하는 방법은 위와 같이 annotation 기반으로 등록하거나 xml 파일로 등록할 수 있다.
위와 같이 스프링 컨테이너에 빈을 등록하면 실제 어플리케이션이 동작할 때
의존성 주입 (DI) 을 기반으로 해서 스프링이 관리하는 빈으로 변경되어 수행된다.

@Configuration // Coonfiguration 또한 Component 이다.
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService(memberRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }

}

빈 이름	빈 객체
userService	UserService@x01
userRepository	UserRepository@x02

등록한 bean 출력해보기

ApplicationContext ac = new
AnnotationConfigApplicationContext(AppConfig.class);

AppConfig bean = ac.getBean(AppConfig.class);
System.out.println("bean = " + bean.getClass());
//출력: bean = AppConfig$$EnhancerBySpringCGLIB$$bd479d70

실제로 annotation 으로 등록한 bean 을 출력해보면 EnhancerBySpringCGLIB 라는 것이 출력이 된다. 즉, 스프링이 관리하는 bean 형태로 변환이 되어서 DI 컨테이너에 관리되고 있다는 것.

@Autowired 를 필드, 메서드, 생성자에 붙여줌으로 써 필요한 Component 를 주입받을 수 있다.

빈을 등록하는 예시

설정 정보 : @Configuration
빈 : @Bean
컴포넌트 : @Component ( @Service @Repository @Controller 등 )

위와 같이 보통 bean을 등록할 때 적절한 annotation을 붙여서 등록을 한다.
@Bean 형태로 등록하는 것은 수동 bean 을 등록하는 방법이고
그 외는 자동 bean을 등록하는 방법이다.

수동 bean 을 등록하는 기준

어플리케이션은 크게 업무 로직과 기술 지원 로직으로 나눌 수 있다.

업무로직은 Service Repository Controller 등 비즈니스 로직을 말한다. 만약 문제가 발생하면 어디서 발생했는지 명확히 파악하기가 쉽다.

기술지원 로직은 기술적인 문제나 AOP를 처리할 때 주로 사용된다. (log, DBconnetion 등 )
횡단 관심사 처리를 목적으로 어플리케이션 전반적으로 영향을 끼치기 때문에 만약 문제가 발생하면 어디서 발생했는지 명확하게 드러나지 않는다.

따라서 이러한 기술지원 로직들은 수동빈 등록으로 설정정보에 바로 나타나게 하는 것이 유지보수에 유리하다.

출처 : 인프런 스프링 백엔드 핵심기본, 스프링 인 액션

[BOJ] 백준 [3085] 사탕게임 JAVA

김까따 — Fri, 6 May 2022 01:28:43 +0900

https://www.acmicpc.net/problem/3085

3085번: 사탕 게임

예제 3의 경우 4번 행의 Y와 C를 바꾸면 사탕 네 개를 먹을 수 있다.

www.acmicpc.net

문제

풀이

탐색 위치를 p1 이라고 하면 x 방향으로 1 또는 y 방향으로 1 다음인 p2 와 자리값을 바꾸고
주어진 2차원 배열을 모두 탐색해서 연속되는 문자의 최대 값을 갱신시키면 된다.

N<=50 이기 때문에 충분히 시간내에 탐색할 수 있다. => lis 알고리즘 사용 x

import java.io.*;
import java.util.*;

public class Main {

    static int max = 1;
    static int n;
    static char[][] map;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());
        map = new char[n][n];

        for(int i=0;i<n;i++){
            map[i] = br.readLine().toCharArray();
        } // end input

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){

                if(isRange(j+1,i)) {
                    swap(new Point(j,i),new Point(j+1,i));
                }

                if(isRange(j,i+1)) {
                    swap(new Point(j,i),new Point(j,i+1));
                }
            }
        }

        System.out.println(max);
    }

    private static void swap(Point p1,Point p2) {  // 0:x 1:y
        char cur = map[p1.y][p1.x];
        char next = map[p2.y][p2.x];
        // swap
        map[p1.y][p1.x] = next;
        map[p2.y][p2.x] = cur;
        search(); // 연속 되는 사탕 찾기
        // restore
        map[p1.y][p1.x] = cur;
        map[p2.y][p2.x] = next;

    }

    private static void search() {

        int cnt = 1;

        for(int i=0;i<n;i++){ // x 방향 진행
            for(int j=0;j<n;j++){

                if(isRange(j+1,i) && map[i][j]==map[i][j+1]){ // 연속으로 같으면 cnt 수 증가
                    cnt++;
                    max = Math.max(max,cnt);
                }else{
                    cnt=1;
                }
            }
        }

        for(int i=0;i<n;i++){ // y 방향 진행
            for(int j=0;j<n;j++){

                if(isRange(i,j+1) && map[j][i]==map[j+1][i]){
                    cnt++;
                    max = Math.max(max,cnt);
                }else{
                    cnt=1;
                }
            }
        }
    }

    static boolean isRange(int x,int y){
        return x>=0&&y>=0&&x<n&&y<n;
    }
    static class Point{
        int x,y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

[BOJ] 백준 [1935] 후위표기식2 JAVA

김까따 — Thu, 5 May 2022 18:38:29 +0900

https://www.acmicpc.net/problem/1935

1935번: 후위 표기식2

첫째 줄에 피연산자의 개수(1 ≤ N ≤ 26) 가 주어진다. 그리고 둘째 줄에는 후위 표기식이 주어진다. (여기서 피연산자는 A~Z의 영대문자이며, A부터 순서대로 N개의 영대문자만이 사용되며, 길이

www.acmicpc.net

문제

풀이

후위 표기식 문제는 항상 stack을 이용한다.

1. 연산자 => stack 에서 2개 꺼낸 피 연산자를 연산 후 stack에 결과 값을 push
2. 피연산자 => stack 에 push

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int operandCount = Integer.parseInt(br.readLine());
        HashMap<Character, Double> operands = new HashMap<>();
        Stack<Double> stack = new Stack<>();

        char[] equations = br.readLine().toCharArray();

        for(int i=0;i<operandCount;i++){
            double value = Double.parseDouble(br.readLine());
            operands.put((char) ('A'+i),value);
        } // end input

        for (char ch : equations) {

            if(!isOperator(ch)){ // 연산자인경우
                stack.push(operands.get(ch));
            }else { // 피 연산자인 경우

                Double op1 = stack.pop();
                Double op2 = stack.pop();

                Double result = switch (ch) {
                    case '+' -> op2 + op1;
                    case '-' -> op2 - op1;
                    case '/' -> op2 / op1;
                    case '*' -> op2 * op1;
                    default -> 0.00;
                };
                stack.push(result);
            }
        }
        System.out.printf("%.2f",stack.pop());
    }

    static boolean isOperator(char ch){
        return ch<'A'||ch>'Z';
    }
}

[BOJ] 백준 [17413] 단어뒤집기2 JAVA

김까따 — Thu, 5 May 2022 17:55:15 +0900

https://www.acmicpc.net/problem/17413

17413번: 단어 뒤집기 2

문자열 S가 주어졌을 때, 이 문자열에서 단어만 뒤집으려고 한다. 먼저, 문자열 S는 아래와과 같은 규칙을 지킨다. 알파벳 소문자('a'-'z'), 숫자('0'-'9'), 공백(' '), 특수 문자('<', '>')로만 이루어져

www.acmicpc.net

문제

풀이

태그 안에 있는 문자열들을 제외한 나머지들을 뒤집어 출력하는 문제이다.

기본적으로 단어들을 모아서 출력하기 때문에

1. 태그 시작점 "<" 또는 공백 " " 일 경우 => 모아논 문자열을 뒤집어서 Builder에 넣는다.
1.1 "<" 일 경우 태그 문자열을 정방향 출력이기 때문에 그대로 출력 하라는 flag 설정
1.2 " " 일 경우 뒤집은 문자열을 삽입

2. 태그가 끝날경우 => flag 초기화

3. flag = true 인 경우 => 태그 안 문자열이므로 Builder에 삽입

4. 일반 문자열일 경우 => 문자하나씩 모아서 문자열에 이어붙임

1~4 번이 다 끝나면 Builder에 남아 있는 문자열이 있을 수 있기 때문에 1.2 과정을 한번 더 진행

import static java.util.Arrays.*;

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String[] input = br.readLine().split("");

        boolean stream = false;
        StringBuilder sb = new StringBuilder();
        StringBuilder reverseStr = new StringBuilder();
        for (String s : input) {

            if (s.equals("<")) {
                sb.append(reverseStr.reverse()); // reverse 한 값을 추가
                sb.append(s); //공백은 정방향으로 추가
                reverseStr = new StringBuilder(); // revereString 추가
                stream = true; // 태그 stream 시작
            } else if (s.equals(">")) { // 태그 끝
                sb.append(s);
                stream = false; // 태그 stream 종료
            } else if (stream) { // 태그 안 문자열이면 그대로 추가
                sb.append(s);
            } else if (s.equals(" ")) { // 공백을 만날 경우 reverseString 추가
                sb.append(reverseStr.reverse());
                sb.append(s);
                reverseStr = new StringBuilder();
            } else { // 일반 문자열인 경우
                reverseStr.append(s);
            }
        }
        sb.append(reverseStr.reverse()); // reverseString 에 남은 문자열 추가
        System.out.println(sb.toString());
    }
}

[BOJ] 백준 [12100] 2048(Easy) JAVA

김까따 — Thu, 28 Apr 2022 01:35:12 +0900

https://www.acmicpc.net/problem/12100

12100번: 2048 (Easy)

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2

www.acmicpc.net

문제

풀이

완전탐색으로 풀어내면 되는데 2차원 이상 배열은 복사를
1차원 배열 단위로 고쳐서 .clone() 메서드를 사용해야 한다.

dfs탐색하기 전에 기존 배열을 어디에 저장해놓고 dfs 탐색이 끝나면 저장된 배열을 원복하면서 탐색한다.

연쇄적으로 합쳐질 수 없기 때문에 큐를 하나 선언해서 하나씩 poll 하면서 병합을 진행한다.

1. 끝이 0 이면 큐에서 하나 빼서 할당
2. 할당된 자리랑 큐에서 하나 뺀 값이 같으면 병합 후 index 증가
3. 그 외인 경우 ( 할당된 값이랑 큐에서 꺼낸 값이 다를 때 ) index 증가시키고 큐에서 하나 뺀 값을 할당

package baekjoon;

import static java.util.Arrays.*;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Stack;
import java.util.stream.Collectors;

public class Main {

    static int n;
    static int[][] map;
    static int ans = 0;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        map = new int[n][n];
        for (int i = 0; i < n; i++) {
            map[i] = stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt).toArray();
        } // end input

        rotate(0);
        System.out.println(ans);
    }

    private static void rotate(int count) { // dfs

        if(count==5){ // 5번 움직였을 때 종결
            for(int i=0;i<n;i++)
                for(int j=0;j<n;j++)
                    ans = Math.max(ans,map[i][j]); // max 값 갱신
            return;
        }

        int[][] nextMap = new int[n][n]; // 이전 상태로 되돌리기 위한 배열 복사
        for(int k=0;k<n;k++)
            nextMap[k] = map[k].clone();

        for(int i=0;i<4;i++){ // 우,좌,하,상
            move(i);
            rotate(count+1);
            for(int k=0;k<n;k++)
                map[k] = nextMap[k].clone(); // 원복
        }
    }

    static void move(int dir) { // 해당 방향에서 움직이는 함수

        LinkedList<Integer> q = new LinkedList<>(); // 한번 움직임에 두 번 이상 합쳐짐을 방지하기 위한 큐

        if (dir == 0) { // 우
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (map[i][j] != 0)
                        q.add(map[i][j]); // 큐에 삽입
                    map[i][j] = 0;
                }

                int index = 0; // 0부터 시작
                while (!q.isEmpty()) {
                    Integer cur = q.poll();

                    if (map[i][index] == 0) { // 0 이면
                        map[i][index] = cur;
                    } else if (map[i][index] == cur) { // 병합하기
                        map[i][index] = cur * 2;
                        index++;
                    } else { // 합쳐질 수 없는 경우 그대로 이동만
                        index++;
                        map[i][index] = cur;
                    }
                }
            }
        } else if (dir == 1) { // 좌
            for (int i = 0; i < n; i++) {
                for (int j = n - 1; j >= 0; j--) {
                    if (map[i][j] != 0)
                        q.add(map[i][j]);
                    map[i][j] = 0;
                }

                int index = n - 1;
                while (!q.isEmpty()) {
                    Integer cur = q.poll();

                    if (map[i][index] == 0) {
                        map[i][index] = cur;
                    } else if (map[i][index] == cur) {
                        map[i][index] = cur * 2;
                        index--;
                    } else {
                        index--;
                        map[i][index] = cur;
                    }
                }
            }
        } else if (dir == 2) { // 하
            for (int i = 0; i < n; i++) {
                for (int j = n - 1; j >= 0; j--) {
                    if (map[j][i] != 0)
                        q.add(map[j][i]);
                    map[j][i] = 0;
                }

                int index = n - 1;
                while (!q.isEmpty()) {
                    Integer cur = q.poll();

                    if (map[index][i] == 0) {
                        map[index][i] = cur;
                    } else if (map[index][i] == cur) {
                        map[index][i] = cur * 2;
                        index--;
                    } else {
                        index--;
                        map[index][i] = cur;
                    }
                }
            }
        } else if (dir == 3) { // 상
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (map[j][i] != 0)
                        q.add(map[j][i]);
                    map[j][i] = 0;
                }

                int index = 0;
                while (!q.isEmpty()) {
                    Integer cur = q.poll();

                    if (map[index][i] == 0) {
                        map[index][i] = cur;
                    } else if (map[index][i] == cur) {
                        map[index][i] = cur * 2;
                        index++;
                    } else {
                        index++;
                        map[index][i] = cur;
                    }
                }
            }
        }
    }
}

[BOJ] 백준 [16198] 에너지 모으기JAVA

김까따 — Wed, 27 Apr 2022 01:03:12 +0900

https://www.acmicpc.net/problem/16198

16198번: 에너지 모으기

N개의 에너지 구슬이 일렬로 놓여져 있고, 에너지 구슬을 이용해서 에너지를 모으려고 한다. i번째 에너지 구슬의 무게는 Wi이고, 에너지를 모으는 방법은 다음과 같으며, 반복해서 사용할 수 있

www.acmicpc.net

문제

풀이

DFS 완전 탐색 문제이다.

1 2 3 4 가 주어질 때
(3) 번을 고를 경우 => energy += 2*4 가 되고 1 2 4 가 남는다.
1 4 는 고를 수 없기 때문에 남은 2번을 고르면 energy += 1*4 를 하면 최종적으로 12가 나온다.

List 하나 선언해서 DFS를 돌리고 해당 위치 x 를 remove 한 뒤
백트래킹을해서 다시 x 를 넣어 주는 식으로 하는 것이 일반적인 풀이다.

다른풀이)
union-find 가 생각이나서 next[] 라는 배열 하나 더 선언 한 뒤에 자기 자신 위치를 초기로 가지고 있다가
left 나 right 값이 방문 되어 있을 경우 그 다음 left나 right 를 찾을 수 있는 메서드를 이용하였다.

백트래킹 할 때는 해당위치가 x라고 하면 next[x]=x 이런 식으로 인덱스를 복구도 같이 진행.

package baekjoon;

import static java.util.Arrays.*;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Stack;
import java.util.stream.Collectors;

public class Main {

    static int maxEnergy = Integer.MIN_VALUE;
    static int n;
    static int[] energy;
    static boolean[] visit;
    static int[] next;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());
        energy = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        visit = new boolean[n];
        next = new int[n];
        for (int i = 0; i < n; i++)
            next[i] = i; // 현재 위치는 자기 자신

        getEnergy(0, 0);
        System.out.println(maxEnergy);
    }

    public static void getEnergy(int depth, int totalEnergy) {

        if (depth == n - 2) { // 최대값 갱신
            maxEnergy = Math.max(totalEnergy, maxEnergy);
        }

        for (int i = 1; i < n - 1; i++) {

            if (!visit[i]) { // 만약 방문 안한 곳이면
                visit[i] = true;
                getEnergy(depth + 1, totalEnergy +
                        energy[findRight(i)] * energy[findLeft(i)]); // 좌우로 방문된 곳 제외하고 새로 찾은 값
                visit[i] = false;
                next[i] = i;
            }
        }
    }

    public static int findRight(int x) {

        if (!visit[x]) // 현재 위치가 방문안한 곳이면 해당 인덱스 return
            return x;
        return next[x] = findRight(x + 1); // 다음 위치 return
    }

    public static int findLeft(int x) {

        if (!visit[x])
            return x;
        return next[x] = findLeft(x - 1);
    }
}

[BOJ] 백준 [1406] 에디터 JAVA

김까따 — Tue, 26 Apr 2022 23:51:42 +0900

https://www.acmicpc.net/problem/1406

1406번: 에디터

첫째 줄에는 초기에 편집기에 입력되어 있는 문자열이 주어진다. 이 문자열은 길이가 N이고, 영어 소문자로만 이루어져 있으며, 길이는 100,000을 넘지 않는다. 둘째 줄에는 입력할 명령어의 개수

www.acmicpc.net

문제

풀이

시간제한을 보면 매우 빡빡한 것을 알 수 있다.

실패한 원인은 처음에 LinkedList 를 썼으나 결국엔 조건을 만족하기 위해서 index를 타야 했기 때문
입력이 매우 길기 때문에 index를 탈 생각을 하면 안된다 ( StringBuilder.insert 연산도 마찬가지)

따라서 2개의 스택만으로 모든 걸 해결해야 하는 문제이다

package baekjoon;

import static java.util.Arrays.*;

import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        Stack<String> left = stream(br.readLine().split(""))
                .collect(Collectors.toCollection(Stack::new));
        Stack<String> right = new Stack<>();
        int queryCount = Integer.parseInt(br.readLine());

        for(int i=0;i<queryCount;i++){
            String[] input = br.readLine().split(" ");
            String query = input[0];

            if(query.equals("L") && !left.isEmpty()){
                right.add(left.pop());
            }else if(query.equals("D") && !right.isEmpty()){
                left.add(right.pop());
            }else if(query.equals("B") && !left.isEmpty()){
                left.pop();
            }else if(query.equals("P") ){
                left.add(input[1]);
            }
        }
        
        StringBuffer ans = new StringBuffer();
        left.forEach(ans::append);
        while (!right.isEmpty())
            ans.append(right.pop());
        System.out.println(ans);
    }
}

[BOJ] 백준 [2504] 괄호의 값JAVA

김까따 — Thu, 21 Apr 2022 00:30:09 +0900

https://www.acmicpc.net/problem/2504

2504번: 괄호의 값

4개의 기호 ‘(’, ‘)’, ‘[’, ‘]’를 이용해서 만들어지는 괄호열 중에서 올바른 괄호열이란 다음과 같이 정의된다. 한 쌍의 괄호로만 이루어진 ‘()’와 ‘[]’는 올바른 괄호열이다. 만일

www.acmicpc.net

문제

풀이

괄호 짝이 맞는 지 검사하는 작업에 더해서 괄호에 따른 연산을 추가로 하는 문제이다.

1. 열린 괄호인 경우 :
- stack 에 push 한 뒤 임시 변수에 곱 연산을 한다.

2. 닫힌 괄호인 경우 :
2.1 이전 괄호가 짝이 맞는 열린 괄호인 경우
- 더 이상 곱 연산이 적용 되지 않는 원소이므로 최종 결과 값에 더해준다
2.2 stack의 맨 위 원소와 짝이 맞지 않거나 stack 이 비어 있는 경우
- 잘못된 괄호이므로 break
- stack 에서 pop 한 뒤 괄호에 맞는 값을 임시 변수에 나누기 연산을 한다.

- 루프를 다 돌 동안에 stack 이 비어 있지 않으면 짝이 맞지 않으므로 break


import static java.util.Arrays.*;

import java.io.*;
import java.util.ArrayList;
import java.util.Stack;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        ArrayList<String> words = stream(br.readLine().split(""))
                .collect(Collectors.toCollection(ArrayList::new));

        int answer = 0;
        Stack<String> stack = new Stack<>();
        String prev = "";
        int cur = 1; // 1에서 부터 시작

        loop:
        for (String word : words) {

            switch (word) {
                case "(" -> {   // 열리는 괄호 일때
                    cur *= 2;
                    stack.push(word);
                }
                case "[" -> {
                    cur *= 3;
                    stack.push(word);
                }
                case ")" -> {  // 닫히는 괄호 일때

                    if (stack.isEmpty() || !stack.peek().equals("(")) { // 잘못 된 괄호이면 break
                        answer = 0;
                        break loop;
                    } else if (prev.equals("(")) // 중간 정산
                        answer += cur;
                    stack.pop();
                    cur /= 2;
                }
                case "]" -> {
                    if (stack.isEmpty() || !stack.peek().equals("[")) {
                        answer = 0;
                        break loop;
                    } else if (prev.equals("["))
                        answer += cur;
                    stack.pop();
                    cur /= 3;
                }
            }
            prev = word; // 중간 정산을 위한 이전 값 기록
        }

        if(!stack.isEmpty()) // 괄호짝이 남는 경우 => 잘못된 괄호
            answer = 0;
        System.out.println(answer);
    }
}

[BOJ] 백준 [18111] 마인크래프트 JAVA

김까따 — Wed, 20 Apr 2022 17:36:36 +0900

https://www.acmicpc.net/problem/18111

18111번: 마인크래프트

팀 레드시프트는 대회 준비를 하다가 지루해져서 샌드박스 게임인 ‘마인크래프트’를 켰다. 마인크래프트는 1 × 1 × 1(세로, 가로, 높이) 크기의 블록들로 이루어진 3차원 세계에서 자유롭게

www.acmicpc.net

문제

풀이

단순 완전 탐색 + 구현 문제이다

주어진 map 좌표에서 높이의 범위를 받은다음
범위 내 높이를 기준 h 에서 평평해지는 조건을 전부 찾아
time과 inventory 조건을 만족할 때 마다 갱신을 시켜주면 된다.

import static java.util.Arrays.*;

import java.io.*;

public class Main {

    static int[][] map;
    static int h,w,b;
    static int fromHeight=Integer.MAX_VALUE, toHeight=0;
    static int minTime=Integer.MAX_VALUE,maxHeight;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        h = input[0];w=input[1];b=input[2];
        map = new int[h][w];
        for(int y=0;y<h;y++){
            map[y] = stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt).toArray();
            fromHeight = Math.min(stream(map[y]).min().getAsInt(), fromHeight);
            toHeight = Math.max(stream(map[y]).max().getAsInt(), toHeight); // 시간 초과 방지를 위해 블록 높이 range 설정
        } // end input

        for(int height = fromHeight; height<= toHeight; height++){

            int time=0;
            int inventory = b;

            for(int y=0;y<h;y++){
                for(int x=0;x<w;x++){ // 전체 좌표 탐색

                    if(time>minTime) // 최소 시간보다 높으면 continue
                        continue;

                    int diff = map[y][x]-height; // 블럭 높이 차이
                    if(diff>0){
                        time+=diff*2;
                        inventory += diff;
                    }else if(diff<0){
                        time-=diff;
                        inventory +=diff;
                    }
                }
            }
            if(inventory<0) // 채울 블럭이 없으면 pass
                continue;

            if(time<=minTime){ // 높이가 커지는 순으로 탐색하므로 time 이 같다면 갱신가능
                maxHeight = height;
                minTime = time;
            }
        }

        System.out.println(minTime+" "+maxHeight);

    }
}

[BOJ] 백준 [1107] 리모컨 JAVA

김까따 — Fri, 15 Apr 2022 01:37:08 +0900

https://www.acmicpc.net/problem/1107

1107번: 리모컨

첫째 줄에 수빈이가 이동하려고 하는 채널 N (0 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 고장난 버튼의 개수 M (0 ≤ M ≤ 10)이 주어진다. 고장난 버튼이 있는 경우에는 셋째 줄에는 고장난 버튼

www.acmicpc.net

문제

풀이

완전탐색 문제이다

목표채널 target 까지 0~999999 사이까지 모두 탐색해서 만약 고장난 버튼이 없이 갈 수 있다면
그 채널에서 target 차이와 자릿수를 합한 결과를 반환하면 된다

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    static int n,target;
    static boolean[] isBroken = new boolean[10];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        target = Integer.parseInt(br.readLine());
        n = Integer.parseInt(br.readLine());
        if(n!=0){
            stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .forEach(e->isBroken[e]=true);
        }
        //end input

        int ans = Math.abs(100-target);

        for(int i=0;i<=999999;i++){

            String cur = Integer.toString(i);
            boolean check=false;

            for(int j=0;j<cur.length();j++){
                if(isBroken[cur.charAt(j) - '0']){
                    check=true; // 고장난 버튼이면 break
                    break;
                }
            }
            if(!check) // 고장안났으면 target 까지 거리 계산해서 갱신
                ans = Math.min(ans,cur.length()+Math.abs(i-target));
        }
        System.out.println(ans);
    }
}

처음에 입력 0 인 경우 입력 받기에서 런타임 에러나는 것 때매 한참 헤맸다..

[BOJ] 백준 [14500] 테트로미노 JAVA

김까따 — Thu, 14 Apr 2022 16:20:48 +0900

https://www.acmicpc.net/problem/14500

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

문제

풀이

테트리스 블록을 암거나 하나 놓았을 때 그 블록이 위치한 격자 점수 합의 최대값을 구하는 문제이다.

어느 한 점 x,y 에서 시작해서 깊이 우선탐색 DFS를 돌리면 블록 모양이 나온다.
그런데 T 블록은 DFS로 구할 수 없으니 , 그 구간만 BFS로 구해야한다.

BFS를 진행할 때 만약 4방향 모두 진행 할 수 있다면
중심좌표 x,y 의 값 + (4방향 좌표의 합) = sum 이라고 하면
sum - ( 4방향 각 좌표) 가 T 블록 점수 다른모양 4개가 나온다.

만약 4방향 모두 진행 못하고 3방향으로만 가능하면 블록은 1개이다.

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    static int w, h,max=0;
    static int[][] map;
    static boolean[][] visit;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        h = input[0]; w = input[1];
        map = new int[h][w];
        visit = new boolean[h][w];
        for(int i=0;i<h;i++){
             map[i] = stream(br.readLine().split(" "))
                      .mapToInt(Integer::parseInt).toArray();
        } // end input

        for(int y=0;y<h;y++){
            for(int x=0;x<w;x++){
                visit[y][x] = true;
                dfs(x,y,1,map[y][x]); // 블록들 탐색
                bfs(x,y); // t 블록 탐색
                visit[y][x] = false;
            }
        }

        System.out.println(max);
    }

    static int[] dx={0,0,1,-1},dy={1,-1,0,0};
    private static void dfs(int x, int y, int depth, int sum) {

        if(depth==4){
            max = Math.max(max,sum);
            return;
        }

        for(int dir=0;dir<dx.length;dir++){
            int nextX = dx[dir]+x;
            int nextY = dy[dir]+y;

            if(!isRange(nextX,nextY) || visit[nextY][nextX])
                continue;

            visit[nextY][nextX]=true;
            dfs(nextX,nextY,depth+1,sum+map[nextY][nextX]);
            visit[nextY][nextX]=false;
        }

    }

    private static void bfs(int x, int y) {

        int sum = map[y][x];
        LinkedList<Integer> tBlocks = new LinkedList<>();

        for(int dir=0;dir<dx.length;dir++){
            int nextX = dx[dir]+x;
            int nextY = dy[dir]+y;

            if(!isRange(nextX,nextY))
                continue;

            tBlocks.add(map[nextY][nextX]);
            sum+=map[nextY][nextX];
        }

        if(tBlocks.size()==4){ // 4방향 모두 가능 한 경우
            for (Integer t : tBlocks)
                max = Math.max(max,sum-t);
        }else if(tBlocks.size()==3){ // 하나만 있는 경우
            max = Math.max(max,sum);
        }

    }

    private static boolean isRange(int x,int y){
        return x>=0&&y>=0&&x<w&&y<h;
    }
}

[BOJ] 백준 [1800] 인터넷 설치 JAVA

김까따 — Wed, 13 Apr 2022 16:06:44 +0900

https://www.acmicpc.net/problem/1800

1800번: 인터넷 설치

첫 번째 줄에 N(1 ≤ N ≤ 1,000), 케이블선의 개수 P(1 ≤ P ≤ 10,000), 공짜로 제공하는 케이블선의 개수 K(0 ≤ K < N)이 주어진다. 다음 P개의 줄에는 케이블이 연결하는 두 컴퓨터 번호와 그 가격이 차

www.acmicpc.net

문제

풀이

처음 풀어보는 유형의 문제다. 아이디어를 못 떠올려서 도움을 받았다..

만약 1-3-2-5 이런식으로 연결 된다고 치면 각각 edge들에 대하여 가중치들은 4, 3, 9 원이다.
여기서 k=1, 회선 하나는 공짜로 준다고 했으니 제일 비싼 9원을 빼면 남은건 4, 3 인데
이들 중 제일 비싼 회선 값만 return 하므로 ans=4 이 답이다

일단 출발점(1) 에서 부터 출발해서 탐색을 진행하는데 도착지(n) 까지
제일 싼 간선을 생각하면서 가야하므로 다익스트라 알고리즘을 사용한다

그런데 회선 몇개 까지 공짜로 봐주는지 체크를 해 가며 가야하므로 경우의 수가 너무 많다
그래서 특정 목표 추정치 Estimate 를 기준으로 도달 가능한지에 대한 여부로 범위를 좁혀가야 한다.

거기다가 가중치의 합 이라는 개념이 필요가 없다
그러므로 거리배열 Dist[] 의 정의를 공짜 회선으로 전환한 갯수로 하였다

그래서 최종적으로 Dist[n] 의 값이 K 안에 있으면 도달 가능한지에 대한 여부를 반환하면서
이분탐색으로 도달가능하면 mid값 낮추고 도달 불가능하면 mid 값 높히는 식으로 답을 도출해야 한다.

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    static int n,e,k;
    static int minEstimate=0,maxEstimate;
    static ArrayList<ArrayList<Node>> graph = new ArrayList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         int[] input = stream(br.readLine().split(" "))
                  .mapToInt(Integer::parseInt).toArray();
         n = input[0]; e = input[1]; k = input[2];

         for(int i=0;i<=n;i++)
             graph.add(new ArrayList<>());
         for(int i=0;i<e;i++){
             input = stream(br.readLine().split(" "))
                     .mapToInt(Integer::parseInt).toArray();
             graph.get(input[0]).add(new Node(input[1],input[2]));
             graph.get(input[1]).add(new Node(input[0],input[2]));
             maxEstimate = Math.max(maxEstimate,input[2]);
         }//end input

        int ans=-1;

        while (minEstimate<=maxEstimate){ //이분 탐색
            int midEstimate = (minEstimate+maxEstimate)/2;

            if(isArrive(midEstimate)) { //도달 가능하면 ans 갱신
                ans = midEstimate;
                maxEstimate = midEstimate - 1; // max 추정치 범위를 좁힘
            }
            else
                minEstimate = midEstimate + 1; // min 추정치 범위를 좁힘
        }
        System.out.println(ans); // 도달 불가능이면 -1
    }
    static boolean isArrive(int estimate){ // 추정치로 탐색 가능한지 탐색

        int[] dist = new int[n+1];
        Arrays.fill(dist,Integer.MAX_VALUE);
        dist[1]=0;

        PriorityQueue<Node> pq = new PriorityQueue<Node>((o1, o2) -> o1.weight-o2.weight);
        pq.add(new Node(1,0));

        while (!pq.isEmpty()){
            Node cur = pq.poll();

            if(dist[cur.node] < cur.weight)
                continue;

            for (Node next : graph.get(cur.node)) {

                int nextCount=cur.weight; // 공짜회선 개수

                if(estimate < next.weight) // 더 비싼 회선가격이 나오면
                    nextCount++; // 공짜 회선으로 전환

                if(dist[next.node] > nextCount){
                    dist[next.node]=nextCount;
                    pq.add(new Node(next.node,nextCount));
                }
            }
        }

        return dist[n]<=k; // 공짜회선 k개 보다 적은 개수이면 탐색 가능
    }
    static class Node {
        int node,weight;

        public Node(int node, int weight) {
            this.node = node;
            this.weight = weight;
        }
    }
}

[BOJ] 백준 [1032] 명령 프롬프트 JAVA

김까따 — Tue, 12 Apr 2022 17:08:24 +0900

https://www.acmicpc.net/problem/1032

1032번: 명령 프롬프트

첫째 줄에 파일 이름의 개수 N이 주어진다. 둘째 줄부터 N개의 줄에는 파일 이름이 주어진다. N은 50보다 작거나 같은 자연수이고 파일 이름의 길이는 모두 같고 길이는 최대 50이다. 파일이름은

www.acmicpc.net

문제

풀이

명령어 길이는 같으니 맨 위의 명령어를 대표로 잡고 세로로 비교
만약 다른 문자가 있으면 '?' 으로 치환, 그렇지 않으면 그 문자 그대로 쓰기

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {


    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        char[][] arr = new char[n][];

        for(int i=0;i<n;i++)
            arr[i] = br.readLine().toCharArray();
        // end input

        StringBuilder ans = new StringBuilder();

        for(int i=0;i<arr[0].length;i++){
            char peek = arr[0][i]; // 암거나 하나 대표문자로 선언

            for(int j=0;j<n;j++){
                if(peek!=arr[j][i]){ // 세로로 비교했을 때 다르면
                    peek = '?'; // peek 을 '?' 으로 치환
                    break;
                }
            }
            ans.append(peek);
        }
        System.out.println(ans.toString());
    }
}

[JPA] org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name

김까따 — Sun, 10 Apr 2022 12:53:34 +0900

JPA로 작성되었던 기존 CustomRepository Interface를 상속받은 RepositoryImpl을
QueryDsl 로 복잡한 쿼리를 해결하고 V2로 넘어가는 과정에서 문제가 발생하였다.

기존 OrderRepositoryImpl를 남기고 싶어서 v1,v2 따로 나누기위해 Class 이름 뒤에 v1을 남기고
QueryDsl로 작성한 Repository의 뒤에 v2로 작성하여 돌렸더니 ..

두 시간 삽질을 했다 .. 쿼리가 잘 못 됬는지 확인해보고, 애노테이션도 확인해보고 삽질이란 삽질은 다 했다가
Repository 자체가 문제란걸 깨닫고 CustomRepository 규칙을 다시 보았다.

기본 Impl으로 설정되어있는 접미사가 있어야 있어야 Bean을 만드는 규칙이 있었다.
그리고 리플렉션 api 같은 걸 써서 bean을 등록하고 돌아가기 때문.

결론 : Impl 꼭 붙일것.. Custom에 목 매이지 말고 그냥 별도의 Repository 로 따로 빼서 빈으로 만드는 게 더 나을수도

[BOJ] 백준 [1445] 일요일 아침의 데이트 JAVA

김까따 — Fri, 8 Apr 2022 16:55:28 +0900

https://www.acmicpc.net/problem/1445

1445번: 일요일 아침의 데이트

첫째 줄에 숲의 세로 크기 N과 가로 크기 M이 주어진다. N과 M은 3보다 크거나 같고, 50보다 작거나 같은 자연수이다. 둘째 줄부터 숲의 지도가 주어진다. 숲의 지도는 S, F, g, . 만으로 이루어져 있

www.acmicpc.net

문제

풀이

우선순위큐를 이용한 bfs 하는 문제이다. 우선시 되어야 하는 기준은
1. 쓰레기를 지나지 않는 것
2. 쓰레기 근처도 지나지 않는 것

그런데 2 번 조건을 처리하기 위해 처음 입력때 받은 g 를 list 안에 넣고
list를 순회하면서 map의 값이 '.' => 'm' 으로 바꾸고
bfs를 수행할 Queue 의 Comparator를 정해 주었다.

출발지를 push 한 다음 탐색하면 끝

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;

public class Main {

    static int[] dx = {0,0,1,-1},dy={1,-1,0,0};
    static char[][] map;
    static Point start;
    static int w,h;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        h = input[0];w=input[1];
        map = new char[h][w];

        LinkedList<Point> gList = new LinkedList<>();
        for(int i=0;i<h;i++){
            map[i] = br.readLine().toCharArray();

            for(int j=0;j<w;j++){
                if(map[i][j]=='S') start = new Point(j, i,0,0);
                else if(map[i][j]=='g') gList.add(new Point(j,i));
            }
        } //end input

        setNearby(gList);
        Point result = bfs(start);
        System.out.println(result.gCnt+" "+result.mCnt);
    }
    static void setNearby(LinkedList<Point> gList){

        for (Point point : gList) {
            for(int i=0;i<dx.length;i++){
                int nextX = point.x+dx[i];
                int nextY = point.y+dy[i];

                if(isRange(nextX,nextY) && map[nextY][nextX]=='.')
                    map[nextY][nextX]='m';
            }
        }
    }
    static Point bfs(Point start){
        Queue<Point> q = new PriorityQueue<>((o1, o2) ->
                o1.gCnt==o2.gCnt?o1.mCnt-o2.mCnt:o1.gCnt-o2.gCnt);
        boolean[][] visit = new boolean[h][w];

        q.add(start);
        visit[start.y][start.x]=true;
        while (!q.isEmpty()){

            Point cur = q.poll();

            if(map[cur.y][cur.x]=='F')
                return cur;

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

                int nextX = cur.x+dx[i];
                int nextY = cur.y+dy[i];

                if(!isRange(nextX,nextY) || visit[nextY][nextX])
                    continue;

                switch (map[nextY][nextX]){
                    case 'g'->q.add(new Point(nextX, nextY, cur.gCnt + 1, cur.mCnt));
                    case 'm'->q.add(new Point(nextX, nextY, cur.gCnt, cur.mCnt + 1));
                    default -> q.add(new Point(nextX, nextY, cur.gCnt, cur.mCnt));
                }
                visit[nextY][nextX]=true;
            }
        }
        return null;
    }
    static boolean isRange(int x,int y){
        return x>=0&&y>=0&&y<h&&x<w;
    }
    static class Point{
        int x, y;
        int gCnt,mCnt;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
        public Point(int x, int y, int gCnt, int mCnt) {
            this.x = x;
            this.y = y;
            this.gCnt = gCnt;
            this.mCnt = mCnt;
        }
    }
}

[BOJ] 백준 [2980] 도로와 신호등 JAVA

김까따 — Fri, 8 Apr 2022 01:00:57 +0900

https://www.acmicpc.net/problem/2980

2980번: 도로와 신호등

상근이는 트럭을 가지고 긴 일직선 도로를 운전하고 있다. 도로에는 신호등이 설치되어 있다. 상근이는 각 신호등에 대해서 빨간 불이 지속되는 시간과 초록 불이 지속되는 시간을 미리 구해왔

www.acmicpc.net

문제

풀이

총 시간을 (빨간불+파란불) 로 % 연산을 하여 현재 신호등이 빨간불인지 파란불인지 구간을 파악해야한다

구간을 section 이라고 했을 때 빨간불 지속시간 보다 작으면 => 빨간불 구간
or => 파란불 구간

기다리는 시간을 더해주고 다음위치로 이동할 때 이동거리 만큼 총 시간에 더해주는 식으로 하면 된다

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        int n = input[0], len = input[1], curPos = 0, time = 0;
        
        for (int i = 0; i < n; i++) {
            int[] arr = stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt).toArray();
            // arr = { 위치, 빨간불, 파란불}
            time += arr[0] - curPos; // 다음 위치 까지 가는데 걸리는 시간
            curPos = arr[0]; // 위치 이동
            
            int section = time % (arr[1] + arr[2]); // 신호등 사이클 확인
            if (section < arr[1]) // 빨간불 구간
                time += arr[1] - section;
        }
        // 남은 신호등 거리 계산 포함
        System.out.println(time + len - curPos);
    }
}

[BOJ] 백준 [8979] 올림픽 JAVA

김까따 — Thu, 7 Apr 2022 21:26:50 +0900

https://www.acmicpc.net/problem/8979

8979번: 올림픽

입력의 첫 줄은 국가의 수 N(1 ≤ N ≤ 1,000)과 등수를 알고 싶은 국가 K(1 ≤ K ≤ N)가 빈칸을 사이에 두고 주어진다. 각 국가는 1부터 N 사이의 정수로 표현된다. 이후 N개의 각 줄에는 차례대로 각

www.acmicpc.net

문제

풀이

주어진 메달의 갯수로 어떤 나라가 몇등 했는지 구하는 문제이다

Medal 클래스를 만들고 비교연산을 위해 Comparable 인터페이스를 implements 한다.
비교순위를 보장해주는 TreeMap <메달,나라들> 컬렉션을 사용하여 똑같은 점수가 있을 경우
해당 점수의 value 를 List 안에 추가하는 방식으로 입력을 받는다

그런 다음 TreeMap을 순회하면서 구할 나라의 등수를 계산

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;

public class Main {


    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         int[] input = stream(br.readLine().split(" "))
                  .mapToInt(Integer::parseInt).toArray();

         int n = input[0]; // 나라 크기
         int query = input[1]; // 등수를 구할 나라

        // 정렬 기준 : 점수 내림차순 (key)
        TreeMap<Medal, ArrayList<Integer>> ranking = new TreeMap<>();

        for(int i=0;i<n;i++){
             int[] info = stream(br.readLine().split(" "))
                      .mapToInt(Integer::parseInt).toArray();
            Medal score = new Medal(info[1],info[2],info[3]);

            if(ranking.containsKey(score)){  // 해당 금,은,동 점수의 국가가 또 존재할 경우 추가
                ranking.get(score).add(info[0]);
            }else{
                ArrayList<Integer> nations = new ArrayList<>(); // 특정 금,은,동 스코어가 처음 나오면 Map에 추가
                nations.add(info[0]);
                ranking.put(score,nations);
            }
        }

        int ans=0; // 등수

        for (var entry : ranking.entrySet()) {
            ArrayList<Integer> nations = entry.getValue();

            if(nations.contains(query)){ // entry 를 탐색하던 도중 구하고 싶은 나라가 포함되어 있으면 등수 +1 하고 출력
                System.out.println(ans+1);
                break;
            }else ans+=nations.size(); // 나라들이 포함되어 있는 리스트 사이즈 만큼 등수 추가
        }
    }
    static class Medal implements Comparable<Medal>{
        int gold,silver,bronze;

        public Medal(int gold, int silver, int bronze) {
            this.gold = gold;
            this.silver = silver;
            this.bronze = bronze;
        }

        @Override
        public int compareTo(Medal o) {

            if(o.gold == this.gold){
                if(o.silver==this.silver)
                    return o.bronze-this.bronze;
                return o.silver-this.silver;
            }
            return o.gold-this.gold;
        }
    }
}

[BOJ] 백준 [13460] 구슬탈출2 JAVA

김까따 — Thu, 7 Apr 2022 13:58:30 +0900

https://www.acmicpc.net/problem/13460

13460번: 구슬 탈출 2

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B'

www.acmicpc.net

문제

풀이

구슬을 이동시키다가 빨간색 구슬만 구멍에 빠지는 최소 move 카운트를 return 하는 문제이다
우선 최소 횟수는 좌표 BFS 특성상 먼저 끝내는 것이 최소 횟수 이므로 종결조건을 만족하기만 하면 return

1. 총 4방향 {아래, 위, 오른, 왼} 으로 움직이는데 벽인 '#' 기호를 만날 때 까지 움직인다

2. 파란색 구슬의 좌표 nextB(X,Y) 가 구멍에 빠지면 continue
2-1. 빨간색구슬 nextR(X,Y) 가 빠지면 move 카운트 return

3. 두 개의 구슬 좌표가 겹칠 경우 => 움직인 방향에 따라서 원래 구슬위치 기준으로 1 만큼 조정

4. 조정 된 위치가 처음 방문하는 좌표이면 큐에 Push

import static java.util.Arrays.*;
import static java.util.stream.Collectors.*;

import java.util.*;
import java.io.*;


public class Main {

    static char[][] map;
    static int[] dx = {0, 0, 1, -1}, dy = {1, -1, 0, 0}; // 아래, 위, 오른, 왼
    static int w, h;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        h = input[0];
        w = input[1];

        map = new char[h][w];
        Board board = new Board();

        for (int i = 0; i < h; i++) {
            map[i] = br.readLine().toCharArray();
            for (int j = 0; j < w; j++) {

                switch (map[i][j]) {
                    case 'R' -> board.red = (new Point(j, i));
                    case 'B' -> board.blue = (new Point(j, i));
                    case 'O' -> Board.hole = (new Point(j, i));
                }
            }
        }//end input

        int bfs = bfs(board);
        System.out.println(bfs);
    }

    static int bfs(Board board) {

        boolean[][][][] visit = new boolean[h][w][h][w];

        LinkedList<Board> q = new LinkedList<>();
        q.add(board);
        visit[board.red.y][board.red.x][board.blue.y][board.blue.x] = true;

        while (!q.isEmpty()) {

            Board curBoard = q.poll();

            if (curBoard.move > 9) break; // 종결조건

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

                int nextRX = curBoard.red.x;
                int nextRY = curBoard.red.y;
                int nextBX = curBoard.blue.x;
                int nextBY = curBoard.blue.y;

                while (isRange(nextRX + dx[i], nextRY + dy[i])) { // 빨간색 구슬 이동
                    nextRX += dx[i];
                    nextRY += dy[i];

                    if (nextRX == Board.hole.x && nextRY == Board.hole.y)
                        break;
                }

                while (isRange(nextBX + dx[i], nextBY + dy[i])) { // 파란색 구슬 이동
                    nextBX += dx[i];
                    nextBY += dy[i];

                    if (nextBX == Board.hole.x && nextBY == Board.hole.y)
                        break;
                }

                if (Board.hole.x == nextBX && Board.hole.y == nextBY)
                    continue;
                if (Board.hole.x == nextRX && Board.hole.y == nextRY) // 빨간색만 빠진경우 종료
                    return curBoard.move + 1;

                //dx = {0, 0, 1, -1}, dy = {1, -1, 0, 0};
                if (nextRX == nextBX && nextRY == nextBY) { // 위치가 겹칠 경우 조정

                    switch (i) {
                        case 0 -> {
                            if (curBoard.red.y > curBoard.blue.y) nextBY -= 1;
                            else nextRY -= 1;
                        }
                        case 1 -> {
                            if (curBoard.red.y < curBoard.blue.y) nextBY += 1;
                            else nextRY += 1;
                        }
                        case 2 -> {
                            if (curBoard.red.x > curBoard.blue.x) nextBX -= 1;
                            else nextRX -= 1;
                        }
                        case 3 -> {
                            if (curBoard.red.x < curBoard.blue.x) nextBX += 1;
                            else nextRX += 1;
                        }
                    }
                }

                if (!visit[nextRY][nextRX][nextBY][nextBX]) { // 각 구슬의 위치가 처음 기록되는 경우만 push
                    visit[nextRY][nextRX][nextBY][nextBX] = true;
                    q.add(new Board(new Point(nextBX, nextBY), new Point(nextRX, nextRY), curBoard.move + 1));
                }
            }
        }
        return -1;
    }

    static boolean isRange(int x, int y) {
        return x >= 0 && y >= 0 && x < w && y < h && map[y][x] != '#';
    }
    static class Point {
        int x, y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    static class Board {

        Point blue, red;
        static Point hole;
        int move;

        public Board() {
            move = 0;
        }

        public Board(Point blue, Point red, int move) {
            this.blue = blue;
            this.red = red;
            this.move = move;
        }
    }
}