컴퓨터야, 협조 좀 부탁할게

프로그래머스 / 분수의 덧셈 / JAVA

가보자고@ — Wed, 6 Nov 2024 16:29:01 +0900

문제 :

내가 성공한 풀이 :

public int[] solution(int numer1, int denom1, int numer2, int denom2) {

    int[] answer = new int[2];
    int denomgop = denom1 * denom2;
    int gopamount1 = denomgop / denom1;
    int gopamount2 = denomgop / denom2;

    int resultnumer = (numer1 * gopamount1) + (numer2 * gopamount2);

    for (int i = denomgop; i > 0; i--) {
        if (resultnumer % i == 0 && denomgop % i == 0) {
            resultnumer /= i;
            denomgop /= i;
        }// if

        answer[0] = resultnumer;
        answer[1] = denomgop;
    }//for i

    return answer;
}

-> 첫 시작은 좋았지만 4번 11번만 계속해서 실패해서 생각보다 오래걸렸던 문제다. 처음에는 for i 반복에서 시작을 (denomgop / 2)부터 하도록 했었는데 이렇게 하니까 계속해서 4번 11번 실패가 떨어졌다.

2로 나누었던 이유는 순간적으로 생각했을때 분모가 1인 경우는 배제 했던 것 같다. 4번 11번에 대한 반례도 돌아다니는게 거의 없어서 믿거나 말거나하는 생각으로 등호를 없앴는데 성공했다.

프로그래머스 / OX퀴즈 / JAVA

가보자고@ — Wed, 6 Nov 2024 14:42:44 +0900

문제 :

내가 성공한 풀이 :

public String[] solution(String[] quiz) {
    String[] answer = new String[quiz.length];

    for (int i = 0; i < quiz.length; i++) {
        String prob = quiz[i];
        String[] quest = prob.split(" ");

        if (quest[1].equals("+")) {
            answer[i] = Integer.parseInt(quest[0]) + Integer.parseInt(quest[2]) == Integer.parseInt(quest[4]) ? "O" : "X";
        } else {
            answer[i] = Integer.parseInt(quest[0]) - Integer.parseInt(quest[2]) == Integer.parseInt(quest[4]) ? "O" : "X";
        }
    }
    return answer;
}

-> 공백을 기준으로 split해준 다음 자바의 삼항연산자를 통해서 구현하면 어렵지 않게 답을 도출해낼 수 있다.

프로그래머스 / 최빈값 구하기 / JAVA

가보자고@ — Wed, 6 Nov 2024 14:38:37 +0900

문제 :

내가 성공한 풀이 :

public int solution(int[] array) {
    int[] count = new int[1000];
    
    for (int i = 0; i < array.length; i++) {
        int j = array[i];
        count[j]++;
    }//for i
    int max = 0;
    int maxnum = 0;

    for (int i = 0; i < count.length; i++) {
        if (count[i] > max ) {
            max = count[i];
            maxnum = i;
        } else if (count[i] == max) {
            maxnum = -1;
        }
    } //for i
    return maxnum;
}

-> 우선 주어진 배열을 돌면서 해당 값의 index에 해당하는 값을 1씩 증가시키는 반복문을 돌린다. 그 다음 새로 만들어진 배열을 돌면서 이전 값보다 크면 maxnum을 바꾸고 동일하면 -1로 만들어 주었다.

풀면서도 처음부터 배열의 크기를 1000으로 할당하고 들어가는것이 별로였지만 역시나 Map을 통해서 해결하는 방법이 있었다.

프로그래머스 / 다음에 올 숫자 / JAVA

가보자고@ — Wed, 6 Nov 2024 14:31:25 +0900

문제 :

내가 성공한 풀이 :

public int solution(int[] common) {
    boolean issub = true;

    if ((common[1] - common[0]) == (common[2] - common[1])) {
        issub = true;
    } else {
        issub = false;
    } //else

    int answer = 0;
    if (issub == true) {
        answer = common[common.length - 1] + (common[1] - common[0]);
    } else if (issub == false && common[0] > 0 && common[0] != 1) {
        answer = common[common.length - 1] * common[0];
    } else if (issub == false && common[0] == 1) {
        answer = common[common.length - 1] * common[1];
    } else if (issub == false && common[0] != 0) {
        answer = common[common.length - 1] * common[1] / common[0];
    }
    return answer;
}

-> 내가 해결한 방법은 등차수열인지에 대한 boolean flag를 세운뒤, true이면 공차만큼을 더해주고 false 이면 공비만큼을 곱해주었다.

테스트 케이스 별로 통과하지 못하는 경우가 꽤 많았기 때문에 반례를 찾아가며 해당 반례도 해결할 수 있도록 풀었다. 저렇게 else if 문을 나눈 이유는 common[0]이 0일 경우를 배제하기 위함이다.

프로그래머스 / 연속된 수의 합 / JAVA

가보자고@ — Wed, 6 Nov 2024 12:57:43 +0900

문제 :

내가 성공한 풀이 :

public int[] solution(int n, int k) {

    int[] answer = new int[n];
    int startnum = k/n - (n-1)/2;

    for (int i = 0; i < n; i++) {
        answer[i] = startnum;
        startnum++;
    }

    return answer;
}

-> -> 이 문제의 key는 값을 도출해내는 규칙을 찾아내는 것에 있다고 생각한다. answer배열의 숫자가 어떻게 구해지는지에 대해서 규칙을 찾아내면 어렵지 않게 해결할 수 있다.

처음 시작은 1부터 시작해서 더한값이 total 보다 큰지 작은지 비교하려고 했지만 반례로 음수부터 시작하는 배열이 문제였다.
결국 찾아낸 규칙은 total / num 의 값이 배열의 중간 즈음 위치한다는 것이다.

프로그래머스 / 안전지대 / JAVA

가보자고@ — Wed, 6 Nov 2024 12:49:44 +0900

문제 :

내가 성공한 풀이 :

public int solution(int[][] board) {
    int answer = board.length * board.length;

    int[][] countArray = new int[board.length][board.length];

    // board 배열 깊은복사
    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board.length; j++) {
            countArray[i][j] = board[i][j];
        } //for j
    } //for i

    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board.length; j++) {
            if (board[i][j] == 1) {
                //함수호출
                countArray = countBomb(i, j, countArray);
            } // if
        } // for j
    } // for i

    for (int i = 0; i < countArray.length; i++) {
        for (int j = 0; j < countArray.length; j++) {
            if (countArray[i][j] == 1) {
                answer--;
            }
        }// for j
    }// for i
    return answer;
} //solution

public static int[][] countBomb(int i, int j, int[][] countArray) {
    int[] numX = {-1, 0, 1, -1, 1, -1, 0, 1};
    int[] numY = {-1, -1, -1, 0, 0, 1, 1, 1};

    int locX = 0, locY = 0;

    for (int k = 0; k < 8; k++) {
        locX = i + numX[k];
        locY = j + numY[k];

        if (locX >= 0 && locX < countArray.length && locY >= 0 && locY < countArray.length && countArray[locX][locY] == 0) {
            countArray[locX][locY] = 1;
        }

    }// for k
    return countArray;
}//countBomb

-> 사실대로 말하면 스스로 성공하지 못하고 힌트를 대량 참조한 문제이다.

자바에 대한 감이 많이 떨어졌다고 판단해서 level0의 정답률 낮은 문제들을 다시 풀고 있는데 와....정말 머리가 멈춘느낌이다. 흑흑

처음 내가 시작한 풀이는 8번의 if 문을 써서 1이 아니면 1로 만들고 count를 1 증가하게하는 아주 무식한 코드였다. 하면서도 무식하고 더러운 코드인줄 알았지만 다른방법이 떠오르지 않아서 일단 질렀다. 하지만 당연히 실패ㅎㅎ

성공한 풀이는 우선 깊은 복사를 통해 동일한 2차원 배열이 두개를 만든다. 기존 board배열은 숫자를 바꾸지 않고 그대로 해당 위치가 1인지만 돌면서 확인하고 1일경우 복사한 배열의 숫자를 1로 바꾸는 방법이다.
하는 도중 계속 ArrayIndexofBoundException이 나서 조금 더 걸렸는데 위치가 board의 길이보다 작아야 하는데 그부분을 놓치고 계속 0보다 큰 것만 체크했다.
주의주의!!!

프로그래머스 / 피보나치 수 / JAVA

가보자고@ — Fri, 23 Feb 2024 12:57:21 +0900

문제 :

내가 성공한 풀이 :

-> 숫자가 너무 커지지 않게 반복문 안에서 나머지를 구해주면 성공!

프로그래머스 / n진수 게임 / JAVA

가보자고@ — Fri, 23 Feb 2024 12:49:14 +0900

문제 :

내가 성공한 풀이 :

-> n진법으로 변환하여 arr에 저장을 해주고 arr를 돌면서 arr의 i번째에 저장된 값의 길이가 1이 아니면(즉, 10 처럼 두개의 숫자를 합친 것이라면) 하나씩 나눠서 arr2 에 저장한다. 결국 arr2가 돌아가면서 말할 숫자가 되는 것이다.

그 다음 result에 튜브가 말해야 하는 숫자들을 담아준다.

list를 3개 만들어서 성공했기 때문에 조금 아쉽긴 하다... 훌쩍.. 다른 분들 풀이를 보고 공부 해야겟다!

8. 백엔드 / 스프링

가보자고@ — Fri, 23 Feb 2024 12:43:57 +0900

https://dev-coco.tistory.com/163 와 https://mangkyu.tistory.com/95

<WAS(Web Application Server)와 WS(Web Server)의 차이>

1. WAS

동적인 데이터를 제공하기 위한 서버 / 웹서버에서 처리할 수 없는 동적인 정보를 처리하여 웹서버에 정적인 정보를 제공 / 비즈니스 로직을 넣을 수 있음(그 자체로 객체로서의 값을 갖는다는 말로 추정) / Tomcat, PHP 등
일반적으로 웹서버의 기능을 내제하고 있어 웹 서버 없이도 서비스가 가능

2. WS

정적인파일(html,js,이미지 파일 등)을 제공하기 위한 서버 / 비즈니스 로직을 넣을 수 없음 / Apache등
정적인 파일로만 처리 가능한 것은 WAS로 요청을 넘기지않고 바로 요청 처리

<스프링 프레임워크>

-> 자바 개발을 편하게 해주는 오픈소스 프레임워크

경량 컨테이너로서 자바 객체를 직접 관리(빈 동그라미들은 패스?)

제어의 역전(IoC)을 통해 어플리케이션의 느슨한 결합을 도모

의존성 주입(DI, Dependency Injection)을 지원

관점 지향 프로그래밍(AOP, Aspect-Oriented Programming)을 지원

트랜잭션이나 로깅, 보안과 같이 여러 모듈에서 공통적으로 사용하는 기능의 경우 해당 기능을 분리하여 관리할 수 있다.

<@RequestBody, @RequestParam, @ModelAttribute의 차이>

RequestBody : 클라이언트가 전송하는 JSON 형태의 HTTP Body 내용을 MessageConverter를 통해 Java Object로 변환시켜주는 역할 / 변수들의 생성자, Getter,Setter가 없어도 정상적으로 작동
RequestParam : 1개의 HTTP 요청 파라미터를 받기 위해 사용 / 반드시 해당 파라미터가 전송돼야함 / 디폴트로 필요하기 때문에 필요하지 않으면 required=false 해줘야함
ModelAttribute : 클라이언트가 전송하는 폼 형태의 HTTP Body 내용과 파라미터의 값들을 생성자,Getter,Setter를 통해 주입하기 위해 사용 / 변수들의 생성자, 게터세터 꼭 필요

<스프링 부트 vs 스프링 프레임워크>

-> 스프링은 초기에 개발자가 해줘야하는 설정들이 많지만 기본적인 설정들이 돼있고 저동화 된 것이 부트임 / 내장된 톰캣을 사용해 서버를 바로 실행할 수 있음

<Spring MVC>

-> Model, View, Controller 의 약자 / 각 층간의 기능을 구분하는 디자인패턴

Model : 데이터 관리 및 비즈니스 로직을 처리하는 부분 / 다오, 디티오, 서비스 등
View : 비즈니스 로직의 처리 결과를 통해 유저 인터페이스가 표현되는 구간 / html, jsp, json응답 등
Controller : 사용자의 요청을 처리하고 Model과 View를 중개하는 역할

<MVC의 요청 흐름>

DispatcherServlet : 클라이언트에게 요청을 받아 응답까지의 MVC 처리과정을 통제한다.
HandlerMapping : 클라이언트의 요청 URL을 어떤 Controller가 처리할지 결정한다.
HandlerAdapter : HandlerMapping에서 결정된 핸들러 정보로 해당 메소드를 직접 호출해주는 역할을 한다.
ViewResolver : Controller의 처리 결과(데이터)를 생성할 view를 결정한다.

1. 클라이언트는 URL을 통해 얻고자 하는 내용이 무엇인지 전송한다.

2. 디스패처 서블릿은 핸들러 매핑에게 해당 요청이 어느 컨트롤러에게 전달돼야 하는 것인지 알려달라 하면 핸들러 매핑이 찾아서 디스패처 서블릿에게 응답을 줌

3. 디스패처 서블릿은 어떤 컨트롤러인지에 대한 내용을 핸들러 어댑터에게 주면 핸들러 어댑터가 해당 컨트롤러에게 요청을 처리하라고 의 전달한다.

4. 컨트롤러는 자기가 해야하는 비즈니스 로직을 처리한 후에 어느 뷰로 반환할지에 대한 정보를 핸들러 어댑터에게 반환한다.

5. 디스패처 서블릿은 뷰 리졸버에게 반환할 뷰에 대한 정보를 찾으라고 하고 뷰리졸버가 뷰단으로 컨트롤러가 완성한 내용을 전달한다.

6. 디스패처 서블릿은 컨트롤러에서 뷰에 전달할 데이터를 추가한다.

7. 뷰 리졸버가 준 내용이랑 디스패처 서블릿에서 데이터가 추가된 뷰를 반환한다.

<제어의 역전(IoC)>

->Inversion of Control / 의존성 주입의 상위개념 / 스프링 컨테이너가 필요에 따라 개발자 대신 Bean들을 관리(제어)해주는 행위 / 모든 객체에 대한 제어권을 개발자가 아닌 IoC 컨테이너에게 넘긴 것을 말함 / 원래는 개발자가 new 등을 통해 객체를 생성하고 직접 의존성을 주입해주고 그랬는데 스프링에서는 스프링 컨테이너에 빈 등록을 하기만 하면 걔가 알아서 다해줌 / 객체에 대한 제어권이 컨테이너로 역전되기 때문에

<스프링 빈 등록방법>

1. 우선 가장 쉬운 방법으로 @Component 어노테이션을 사용하는 것입니다.

@Controller, @Service, @Repository는 모두 @Component를 포함하고 있습니다.

2. 설정 클래스를 따로 만들어 @Configuration 어노테이션을 붙이고(xml??), 해당 클래스 안에서 빈으로 등록할 메소드를 만들어 @Bean 어노테이션을 붙여주면 자동으로 해당 타입의 빈 객체가 생성됩니다.

<의존성 주입(Dependency Injection)>

-> 필요한 객체를 직접 생성하는 것이 아닌 외부로부터 객체를 받아서 사용하는 것 / 어떤 객체에 스프링 컨테이너가 또 다른 객체와 의존성을 맺어주는 행위 / 객체간의 결합도를 줄이고 코드의 재사용성을 높일 수 있음 / DI를 하는 이유 : 테스트용이, 코드의 재사용성 높, 객체간의 의존성 줄이고 결합도는 낮춤

의존성 주입은 생성자 주입(생성자가 하나이고, 그 생성자로 주입받을 객체가 빈으로 등록되어 있다면 @Autowired를 생략 할 수 있습니다), 필드 주입(필드에 @Autowired 어노테이션만 붙여주면 자동으로 의존성 주입), 세터 주입(Setter 메소드에 @Autowired 어노테이션을 붙이는 방법)이 있는데 Spring에서는 생성자를 통한 주입을 권장함(이유 : 1. 순환 참조를 방지 2. 불변성을 가짐 3. 테스트에 용이하기 때문)임

클래스 내부에 객체를 생성하면 의존성 주입이 아니라 의존성을 스스로 만든것이고, 의존성 주입을 하면 Gun.java파일을 따로 생성하고 Soldier.java파일에서 @Autowired등(어노테이션)을 이용해서 등록해주면 됨

<스프링 빈의 라이프사이클>

-> 스프링 IoC 컨테이너 생성 → 스프링 빈 생성 → 의존관계 주입 → 초기화 콜백(코드가 호출되는데 코드를 넘겨준 곳의 뒤에서 실행되는 것) 메소드 호출 → 사용 → 소멸 전 콜백 메소드 호출 → 스프링 종료

스프링 빈 생명주기 콜백 관리법

1. 인터페이스( InitializingBean, DisposableBean )

2. 설정 정보에 초기화 메소드, 종료 메소드 지정

3. @PostConstruct, @PreDestroy 어노테이션 지원

<스프링 필터와 인터셉터>

필터 : 요청과 응답을 거른뒤 정제하는 역할 / Dispatcher Servlet에 요청이 전달되기 전, 후에 url 패턴에 맞는 모든 요청에 대해 부가 작업을 처리할 수 있는 기능을 제공 / 스프링 컨테이너가 아닌 톰캣과 같은 웹 컨테이너에 의해 관리 됨 / 사례 : 보안 및 인증/인가 관련 작업, 모든 요청에 대한 로깅 또는 검사, 이미지/데이터 압축 및 문자열 인코딩

인터셉터 : 요청에 대한 작업 전, 후로 가로채는 것 / Dispatcher Servlet이 Controller를 호출하기 전 / 후에 인터셉터가 끼어들어 요청과 응답을 참조하거나 가공할 수 있는 기능을 제공 / 인터셉터는 스프링 컨텍스트에서 동작 / 사례 : 세부적인 보안 및 인증/인가 공통 작업, Controller로 넘겨주는 정보(데이터)의 가공

<관점지향 프로그래밍(AOP)>

-> Aspect Oriented Programming / 핵심 비즈니스 로직에 있는 공통 관심사항을 분리하여 각각을 모듈화 하는 것을 의미 / 인증, 로깅, 트랜잭션 처리에 용이 / AOP의 가장 큰 특징이자 장점은 중복 코드 제거, 재활용성의 극대화, 변화수용의 용이성이 좋다는 점

<롬복>

-> 어노테이션 기반으로 코드를 자동완성 해주는 라이브러리이다. Lombok을 이용하면 Getter나 Setter, 생성자 등을 자동완성 시킬 수 있어서 개발자의 생산성을 높여줌 / 롬복을 설치해야 @게터, @세터 등을 이용해서 하나하나 게터세터 안쓰더라도 다 자동으로 돼있다고 볼수 있음 / 메소드를 컴파일 하는 과정에 개입해서 추가적인 코드를 만들어냄(어노테이션 프로세싱 / 자바 컴파일러가 컴파일 단계에서 어노테이션을 분석하고 처리하는 기법)

<서블릿>

-> 자바를 사용하여 웹페이지를 동적으로 생성하는 서버 / 클라이언트의 요청을 처리하고, 그 결과를 반환하는 Servlet 클래스의 구현 규칙을 지킨 자바 웹 프로그래밍 기술 / Spring MVC에서 Controller로 이용되며, 사용자의 요청을 받아 처리한 후에 결과를 반환 / 추가 - JSP와 비슷하지만 JSP는 HTML 문서 안에 Java코드를 포함하는 반면, 서블릿은 자바코드안에 HTML을 포함하고 있다는 점에서 차이

-> 순서

1. 사용자가 URL을 입력하면 요청(Request)가 Servlet Container로 전송됩니다.

2. Servlet Container에서 HttpServletRequest, HttpServletResponse 객체를 생성합니다.

3. web.xml(웹 어플리케이션의 설정파일 / 매핑, 뷰리졸버 등)을 기반으로 사용자가 요청한 URL이 어느 서블릿에 대한 요청인지 찾습니다.

4. 해당 서블릿에서 service메소드를 호출한 후 GET, POST여부에 따라 페이지를 호출합니다.

5. doGet() or doPost() 메소드는 동적 페이지를 생성한 후 HttpServletResponse객체에 응답을 보냅니다.

6. 응답이 끝나면 HttpServletRequest, HttpServletResponse 두 객체를 소멸시킵니다.

<VO, BO, DAO, DTO>

DAO(Data Access Object) : DB의 데이터에 접근을 위한 객체(레포지토리 또는 매퍼)
DTO(Data Transfer Object) : 각 계층간의 데이터 교환을 위한 객체 / 로직을 갖지 않는 데이터객체(변수와 게터, 세터만 가진 클래스)(Controller, View, Business Layer, Persistent Layer) -> 유저가 브라우저에 넣은 데이터를 DTO에 넣어서 전송 / DTO를 받은 서버가 DAO를 이용하여 DB에 저장
VO(Value Object) : 실제 데이터만을 저장하는 객체 / 사용하는 도중에는 변경 불가능하고 읽기만 가능(그래서 세터는 없고 게터기능만 있음)(DTO는 데이터의 전송만을 위한 객체이고 VO는 객체 자체로 어떤 값을 가짐)
BO(Business Object) : 여러 DAO를 활용해 비즈니스 로직을 처리하는 객체(서비스단)

<많은(대용량) 트래픽(장애) 대처>

스케일 업(Scale Up): 서버에 CPU나 RAM 등을 추가하여 서버의 하드웨어 스펙을 향상시키는 방법
스케일 아웃(Scale Out): 서버를 추가하여 시스템을 증가시키는 방법

<CORS>

- 한 출처에 있는 자원에서 다른 출처에 있는 자원에 접근하도록 하는 개념 / 도메인이 다른 2개의 사이트가 데이터를 주고 받을 때 발생하는 문제 / 추가 HTTP 헤더를 사용하여 한 출처에서 실행 중인 웹 애플리케이션이 다른 출처의 선택한 자원에 접근할 수 있는 권한을 부여하도록 브라우저에 알려주는 체제 / 도메인을 *으로 설정하면 모든 도메인에 대해 요청을 허락할 수 있음 /

Access-Control-Allow-Origin : 요청을 보내는 페이지의 출처 [ *, 도메인 ]
Access-Control-Allow-Methods : 요청을 허용하는 메소드. Default : GET, POST
Access-Control-Max-Age : 클라이언트에서 preflight 요청 (서버의 응답 가능여부에 대한 확인) 결과를 저장할 시간
Access-Control-Allow-Headers : 요청을 허용하는 헤더

<아파치, 톰캣>

- 아파치 : 웹 서버용 소프트웨어 / HTTP 웹서버

- 톰캣 : 아파치 재단의 웹 어플리케이션 서버 / jsp코드가 포함되어 있는 웹 페이지를 만들어줌 / 톰캣은 웹서버에서 넘어온 동적인 페이지를 읽어 들여 프로그램을 실행하고 그 결과를 다시 html로 재구성하여 아파치에게 되돌려 줌

<멀티프로세스인지 멀티쓰레드인지>

- 아파치 : 멀티프로세스가 기본 / 멀티쓰레드와 함께 운용 가능

- 톰캣 : 요청을 처리하기 위한 쓰레드 풀을 관리하고 있다. 그리고 요청이 오면 해당 쓰레드 풀에서 쓰레드를 꺼내 요청을 처리하도록 함

<디자인패턴>

- 디자인패턴 : 개발하면서 발생하는 반복적인 문제들을 어떻게 해결할 것인지에 대한 해결 방안의 모범사례

- DatabaseController=> SingletonPattern을 사용하여 데이터베이스를 제어하는 하나의 인스턴스만을 생성

- DatabasePool => ObjectPool Pattern을 사용하여 데이터베이스 객체를 미리 생성하여 Performance 향상

- UnitFactory => FactoryPattern을 사용하여 객체 생성을 최적화 + Singleton Pattern을 사용하여 하나의 공장을 사용

- BaseFrame => ObserverPattern을 사용하여 사용자의 정보가 생신되면 View의 값들도 갱신되게 함

- PlayerInfo => StrategyPattern을 사용하여 상황에 따라 다른 스킬을 사용

생성패턴

구조패턴

-> 클래스나 객체를 조합하여 더 큰 구조를 만드는 패턴 / 서로 다른 인터페이스를 갖는 두개의 객체를 하나로 묶어 하나의 인터페이스를 제공하거나 객체들을 서로 묶어 새로운 기능을 제공하기 위함 /

어댑터 패턴: 호환되지 않는 두 클래스를 연결하여 사용하기 위한 디자인 패턴 / 코드의 수정 없이 사용가능하기 때문에 기존 것을 재사용하거나 라이브러리를 수정할 수 없을 때 사용함

프록시 패턴: 실제 기능을 수행하는 객체 대신 가상의 객체(프록시 / 대리자)를 만들어 사용하는 패턴 / 어떤 객체에 접근 제어를 위해 대리인을 사용하는 디자인 패턴

데코레이터 패턴: 객체에 동적으로 새로운 기능을 추가하여 객체를 확장할 수 있는 패턴 / 어떤 객체에 새로운 기능 추가를 위해 대리인을 사용하는 디자인 패턴

퍼사드(외관) 패턴: 서브시스템을 더 쉽게 사용할 수 있도록 단순한 인터페이스를 제공하는 패턴 / 어떤 복합적인 기능에 대해 간략화된 인터페이스를 제공하는 디자인 패턴

브릿지 패턴 : 클래스들의 집합을 두 개의 개별 계층구조(추상화 및 구현)로 나눈 후 각각 독립적으로 개발할 수 있도록 하는 구조 디자인 패턴 / 구현 뿐 아니라 추상화 부분까지 변경시켜야 하는 경우 사용 / 구현부분에서 추상층을 분리하여 각자 독립적으로 변형이 가능 / 추상화된 클래스를 바꿔도 다른 부분에 영향을 주지 않음

컴포지트(합성) 패턴 : 복합 객체를 구성하는 개별적인 객체들을 모두 동일한 인터페이스(방법)로 다룰 수 있게 하는 패턴 / 개별 객체와 복합 객체를 동일하게 다루기 때문에 트리 구조의 객체를 구성하기에 좋은 패턴

플라이웨이트 패턴 : 공통으로 사용하는 클래스(Flyweight)를 생성하는 팩토리 클래스(FlyweightFactory)를 만들어, 인스턴스를 최초 1개만 생성하고 공유하여 재사용할 수 있도록 하는 구조 패턴 / 공유 가능한 객체를 통해 메모리 사용을 최적화하는 패턴 /

행위패턴

Observer(옵저버 패턴) : 객체 간의 일대다 종속 관계를 정의하여 한 객체의 상태 변경이 다른 객체들에게 알려지도록 한다.
Strategy(전략 패턴) : 알고리즘을 정의하고, 실행 중에 선택할 수 있게 한다.
Command(커맨드 패턴) : 요청을 객체로 캡슐화하여 요청을 매개변수화 하고, 요청을 큐에 저장하거나 로깅하고 실행을 지연시킨다.
State(상태 패턴) : 객체의 상태를 캡슐화하고, 상태 전환을 관리한다.
Chain of Responsibility(책임 연쇄 패턴) : 요청을 보내는 객체와 이를 처리하는 객체를 분리하여, 다양한 처리자 중 하나가 요청을 처리한다.
Visitor(방문자 패턴) : 객체 구조를 순회하면서 다양한 연산을 수행할 수 있게 한다.
Interpreter(인터프리터 패턴) : 언어나 문법에 대한 해석기를 제공하여, 주어진 언어로 표현된 문제를 해결하는 패턴이다.
Memento(메멘토 패턴) : 객체의 내부 상태를 저장하고 복원할 수 있는 기능을 제공하는 패턴이다.
Mediator(중재자 패턴) : 객체 간의 상호 작용을 캡슐화하여, 객체 간의 직접적인 통신을 방지하는 패턴이다.
Template Method(템플릿 메서드 패턴) : 알고리즘의 구조를 정의하면서 하위 클래스에서 각 단계의 구현을 제공하는 디자인 패턴이다.
Iterator(이터레이터 패턴) : 컬렉션 내의 요소들에 접근하는 방법을 표준화하여 컬렉션의 내부 구조에 독립적으로 접근할 수 있는 패턴이다.

<스프링에서의 싱글톤패턴>

* 싱글톤패턴 : 단 하나의 인스턴스(객체)를 생성해 사용하는 디자인 패턴

- 자바 싱글톤패턴의 단점 : 상속이 불가능 / 테스트하기 힘들다 등

이 단점을 해결하기 위해서 스프링에서는 컨테이너를 통해 직접 싱글톤 객체를 생성하고 관리하고 / 이미 만들어진 객체를 공유하기 때문에 효율적임 / static 메소드나 private 생성자 등을 사용하지 않아 객체지향적 개발을 할 수 있음

<@Bean, @Configuration, @Component>

@Bean: 개발자가 직접 제어가 불가능한 라이브러리 또는 설정을 위한 클래스를 직접 빈 등록 / configuration 어노테이션이 선언돼있는 클래스 안에 써야함
@Configuration: 1개 이상의 @Bean 메소드를 갖는 클래스의 경우에 반드시 명시해 주어야 함
@Component: 개발자가 직접 개발한 클래스를 자동으로 빈 등록할 때 사용

<@SpringBootApplication>

SpringBootConfiguraion : @Configuration을 포함하고 있고, 테스트 등을 위한 자동 설정을 위한 하기 위해 찾아짐
@EnableAutoConfiguration : 필요한 설정들을 자동으로 해주는 자동 설정 기능을 활성화함
@ComponentScan : 빈을 찾아서 등록하기 위한 위치를 지정함

<스프링의 스코프 프로토타입 빈>

- 싱글톤과는 달리 컨테이너에게 빈을 요청할 때마다 매번 새로운 객체를 생성하여 반환함 / (((이렇게 빈의 scope(빈이 존재할 수 있는 범위)를 간단하게 관리해줄 수 있는 것이 spring의 장점입니다.))))

빈의 scope 설정은 @Scope 어노테이션으로 설정하며, 프로토타입 scope로 설정하려면 @Scope(”prototype”)와 같이 문자열로 지정

<@Transactional의 동작 원리>

- 프록시 패턴 중 하나임

- 트랜잭셔널 어노테이션을 해주면 트랜잭션(하나의 행동(송금, 결제)를 하기위한 일련의 과정) 실행 도중 오류가 발생하면 트랜잭션은 실패로 끝나게 됨 / 호출시점에 Proxy Bean을 생성하고 Proxy 객체의 메소드를 호출하면 트랜잭션 처리를 수행

<@Transactional를 스프링 Bean의 메소드 A에 적용하였고, 해당 Bean의 메소드 B가 호출되었을 때, B 메소드 내부에서 A 메소드를 호출하면 어떤 요청 흐름이 발생하는지>

- A 메소드는 프록시로 감싸진 메소드가 아니므로 트랜잭션이 적용되지 않은 일반 코드가 수행됩니다 / 프록시는 클라이언트가 타겟 객체를 호출하는 과정에만 동작하며, 타겟 객체의 메소드가 자기 자신의 다른 메소드를 호출할 때는 프록시가 동작하지 않기때문

- 만약 기본 옵션인 Required를 가져간다면 로컬 트랜잭션 3개가 모두 부모 트랜잭션인 A에 합류하여 수행됩니다. 그래서 부모 트랜잭션이나 로컬 트랜잭션 3개나 모두 같은 트랜잭션이므로 어느 하나의 로직에서 문제가 발생하면 전부 롤백이 됨

<@Transactional에 readOnly 속성을 사용하는 이유>

- 보통의 트랜잭션은 영속성 컨텍스트에서 데이터 조회 결과 엔티티가 관리되는데 readonly를 붙여주면 조회만 할 뿐 수정, 삭제는 하지 않는다는 것을 말해주는 것이다 / 조회만 하기 때문에 메모리 사용량을 줄일 수 있고 가독성이 높아진다.

- N + 1문제 : 1번의 쿼리를 날렸을 때 의도하지 않은 N번의 쿼리가 추가적으로 실행되는 것 / JPA를 이용해 1:N 또는 N:1 관계를 가진 엔티티를 조회할 때 발생 / 한쪽 테이블만 조회하고 연결된 다른 테이블은 따로 조회하기 때문에 발생

- 해결방안

Fetch Join(패치조인) : 미리 두 테이블을 JOIN 하여 한 번에 모든 데이터를 가져올 수 있게하여 N+1문제 자체가 발생하지 않게함
@Entity Graph : @EntityGraph 의 attributePaths는 같이 조회할 연관 엔티티명을 적으면 됨 / ex) @EntityGraph(attributePaths = {"pets"})

<ORM 사용으로 인해 쿼리가 복잡해졌을 때의 해결방안>

- ORM(Object-Relational Mapping) : 객체와 관계형 DB의 데이터를 자동으로 매핑해주는 프레임워크 / 객체지향 프로그래밍은 클래스를 사용하기 때문에 관계형 DB의 형식과 차이가 있음 그래서 ORM을 통해 형식을 맞춰줌

일단 JPA 자체는 정적인 상황에서 사용하는걸 권장하기 때문에 복잡한 쿼리와 동적인 쿼리에 대한 문제가 발생하게 되는데, 그럴때는 JPQL과 Querydsl을 사용할 것을 권장하고 있음

프로그래머스 / 모음사전 / JAVA

가보자고@ — Fri, 23 Feb 2024 12:40:16 +0900

문제 :

내가 성공한 풀이 :

-> 완전탐색은 어려워....ㅠㅠ

DFS로 해결했는데 재귀호출함수를 만드는 건 왜 항상 어려운걸까....

막상 풀고 보면 이해하기 어려운 코드는 아닌데 혼자 만드는것이 어렵다ㅠ 이 문제에서 중요한 부분은 AAAAA다음에 AAAAE로 넘어가는 부분이라고 생각한다. 길이가 5를 넘어가면 return을 해주고 이 때 return을 만나면 dfs(AAAA,4)로 돌아가고 거기서 for 반복을 돌기 때문에 AAAAE가 저장된다.