엑셀 다운로드 기능을 구현하는 상황에 마주하였다.

"다운로드 폴더에 저장하는 기능을 구현해야지"

그 때 나는 막연히, 비동기 통신(ajax)으로 개발하면 어떨까 생각하였다.

그런데 ajax 통신을 송신하여도 Controller로 전송은 잘되지만, 계속 에러가 발생하였다.

답답한 나는 원인이 무엇인지 파고들었다.

기본적으로 파일을 다운로드 하는 기능의 경우 ajax를 사용하지 못한다고 한다.

그렇다고..? 그러면 그러한 이유는?

ajax를 사용할 경우 파일 다운로드 응답을 브라우저에서 처리하지 않고

ajax 내부에서 처리하기 때문에 브라우저에서의 파일 다운로드 사용이 불가능하다.

그러므로 submit, a태그 등의 동기 통신으로 처리해야 한다.

// 다음의 메서드 내 ms > configuration > environment > dataSource > url에 명시되어 있다.

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException

나같은 경우, 로그로 쿼리를 확인하기 위해 log4j를 세팅하는 과정에서 우선순위에 영향을 주었는지, Default로 잡힌 DataSource가 DB Connection되지 않고, 다른 DataSource가 Connection되어서 한 번 내부까지 까보았다. 이 방법을 몰라서 엄한 곳을 뒤지느라 시간 낭비를 하였다.

이렇듯, 데이터베이스 다중 연동을 통해 개발하다, 해당 sql문이 수행되는 DB의 주소를 알고 싶다면 참고하면 좋을 것 같다.

기준 원소를 하나 잡아 기준 원소보다 작은 원소와 큰 원소 그룹으로 나눠, 기준 원소의 좌우로 분할한 다음 각각을 정렬하는 방식이다. 평균적으로 가장 좋은 성능을 가져, 가장 많이 쓰이는 정렬 알고리즘이다.

[31, 8, 48, 73, 11, 3, 20, 29, 65, 15]

1) 기준 원소를 15로 잡는다는 전제하에, 15을 중심으로 이보다 작은 원소들은 15의 왼쪽에, 나머지 원소들은 15의 오른쪽에 재배치한다.

[8, 11, 3, ((15)), 31, 48, 20, 29, 65, 73]

2) 왼쪽과 오른쪽에 위치한 원소들을 독립적으로 정렬한다.

[3, 8, 11, ((15)), 20, 29, 31, 48, 65, 73]

3) 결론적으로 크기가 섞이지 않는 두 배열을 나눠놓고 양쪽 배열을 재귀적으로 정렬하는 특징을 갖는다.

분할의 작동 과정

퀵 정렬의 장점 및 단점

장점

1. 특정 상태가 아닌 이상 평균 시간 복잡도는 NlogN이며, 다른 NlogN 알고리즘에 비해 대체적으로 속도가 매우 빠르다.

2. 추가적인 별도의 메모리를 필요로하지 않으며 재귀 호출 스택프레임에 의한 공간복잡도는 logN으로 메모리를 적게 소비한다.

단점

1. 특정 조건하에 성능이 급격하게 떨어진다.

   • 크기가 1억인 정렬에서 각 원소가 평균 100개씩 중복되면 시간이 1.7배로 늘어나고, 평균 1000개씩 중복되면 시간이 7배로 늘어난다.

   • 이미 정렬되어 있거나, 거의 정렬되어 있는 경우, 역순으로 정렬되어 있는 경우 최악의 경우에 해당된다.

     • 해당 경우에서, 분할 과정에서 pivot을 선택할 때 최소값이나 최대값을 선택하는 경우가 발생할 가능성이 높다. 이 경우, 분할된 두 개의 부분 배열 중 한 쪽이 매우 작아져서 퀵 정렬의 장점을 활용하지 못하고, 다른 한 쪽은 대부분의 원소를 가지고 있어서 분할 과정에서 많은 비교와 교환이 필요된다.

2. 재귀를 사용하기 때문에 재귀를 사용하지 못하는 환경일 경우 그 구현이 매우 복잡해진다.

구현 코드

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {31, 8, 48, 73, 11, 3, 20, 29, 65, 15};
        printArray(arr, arr.length); // 정렬 전 배열 출력
        System.out.println();
        quickSort(arr); // 퀵정렬 수행
        System.out.println();
        printArray(arr, arr.length); // 정렬 후 배열 출력

    }

    // 퀵정렬 함수 호출을 위한 Wrapper 함수
    private static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }

    // 퀵정렬 함수
    private static void quickSort(int[] arr, int start, int end) {
        // pivot을 중심으로 분할한 뒤, 분할된 배열에 대해 퀵정렬 함수를 재귀적으로 호출한다.
        int part2 = partition(arr, start, end);

        if (start < part2 - 1) {
            quickSort(arr, start, part2 - 1);
        }
        if (part2 < end) {
            quickSort(arr, part2, end);
        }
    }

    // pivot을 중심으로 분할하는 함수
    private static int partition(int[] arr, int start, int end) {
        // pivot은 배열의 중간값으로 선택한다.
        int pivot = arr[(start + end) / 2];

        // start와 end를 이용하여 pivot보다 큰 값과 작은 값으로 나눈다.
        while (start <= end) {
            while (arr[start] < pivot) start++;
            while (arr[end] > pivot) end--;
            if (start <= end) {
                // start와 end의 값을 swap해준다.
                swap(arr, start, end);
                start++;
                end--;
            }
        }
        // 분할된 배열 중, 왼쪽 파트의 끝 지점을 리턴한다.
        return start;
    }

    // 배열의 두 요소를 swap해주는 함수
    private static void swap(int[] arr, int start, int end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }

    // 배열을 출력하는 함수
    private static void printArray(int[] arr, int size) {
        for (int cnt = 0; cnt < size; cnt++) {
            System.out.print(arr[cnt] + " ");
        }
        System.out.println();
    }

}

정렬이란?

원소들을 기준에 맞춰 순서대로 위치시키는 것

정렬의 중요성에 대해 생각해본 결과

원하는 데이터를 탐색하는데에 있어서 용이한 정렬은 프로그래밍 및 알고리즘 이해에 도움이 된다는 것이었다. 예를들어 시간복잡도 개념과 for문에 대한 이해도 정도가 되겠다.

알고리즘 복잡도

입력 크기에 따른 단위 연산의 수행 횟수 변화를 함수로 나타낸 것을 의미한다.

알고리즘의 복잡도를 나타낼 땐, 점근적 표기(시간 복잡도 함수를 원소로 표현하는 법)를 사용한다.

점근적 복잡도 : 입력의 크기가 충분히 클 때의 복잡도

입력의 크기가 작으면 복잡한 알고리즘이든 효율적인 알고리즘이든 실제 수행 시간은 별 차이 없다.

점근적 복잡도에 있어서는 최고차항의 차수만 중요하고 나머지는 다 무시된다. 그 이유는 차수의 차이에 비하면 계수의 차이는 미미하기 때문이다. 최고 차항이 아닌 항들도 영향이 미미하기는 마찬가지이다.

결론적으로 복잡도라 함은 어떤 알고리즘이 효율적인지를 판단하는 지표로 이해하면 편하다.

대표적인 점근적 표기법

빅오 표기(O) : 점근적 상한 (최악의 경우의 복잡도) 오메가 표기(Ω) : 점근적 하한 (최적의 경우의 복잡도) 세타 표기(Θ) : 점근적 동일 (평균적인 복잡도)

빅오 표기법(Big-O notation)은 복잡도를 나타내는 점근 표기법 중 가장 많이 사용되는 표기법이다.

빅오 표기법이 가장 많이 사용되는 이유는 알고리즘 효율성을 상한선 기준으로 표기하기 때문이다.

다시 말해 최악의 경우를 고려하는 데 가장 좋은 표기법이다 (알고리즘 효율성은 값이 클수록, 즉 그래프가 위로 향할수록 비효율적임을 의미)

최악의 경우를 고려하는 이유는 알고리즘이 복잡해짐에 따라 평균을 구하기 애매하여, 보통 최악의 경우인 빅오 표기법이 시간복잡도에 많이 사용된다.

선택 정렬

배열에서 가장 큰 원소를 찾아 배열의 맨 끝자리 원소와 자리를 바꾼다.
이처럼 맨 우측부터 자리를 잡아가며 같은 작업을 반복한다.

private static void selectionSort(Integer[] a, int size) {
        // 사이즈가 10인 배열이 존재할 때,
        // [시작] 0번째 인덱스
        // [종료] 8번째 인덱스
        for (int i = 0; i < size - 1; i++) {
            int min_index = i;
            // 사이즈가 10인 배열이 존재할 때,
            // [시작] 바깥 for문 시작 인덱스 + 1
            // [종료] 9번째 인덱스
            for (int j = i + 1; j < size; j++) {
                // 만약 바깥 인덱스+1 데이터가 바깥 인덱스 데이터보다 작다면 [최소 인덱스 변수]값을 바깥인덱스+1값으로 변환한다.
                // a[j] : 내부 for문 내 인덱스 값
                // a[min_index] : 가장 작은 값을 가진 인덱스
                if (a[j] < a[min_index]) {
                    min_index = j;
                }
            }
            // i번째 값과 찾은 최솟값을 서로 교환
            // 바깥 for문의 인덱스값에 가장 최저값을 swap 메서드를 통해 교환
            // 이로써 0번째 인덱스부터 차차 작은 값이 위치하게 된다.
            swap(a, min_index, i);
        }
    }

버블 정렬

한 번 돌 때마다 마지막 요소가 정렬되는 것이 거품이 올라오는 것처럼 보여 버블 정렬이라고 한다.
정렬할 배열이 주어지면, 왼쪽부터 시작한다.
이후 이웃한 쌍을 2개씩 비교해나아간다.
순서대로 되어있지 않다면 자리를 바꾼다.
위 작업을 반복하며 나아가다, 맨 오른쪽 수의 경우 대상에서 제외한다.
마지막에는 0,1번째 인덱스를 비교하며 정렬이 완료된다.

    private static void bubbleSort(Integer[] a, int size) {
        // 사이즈가 10인 배열이 존재할 때,
        // [시작] 1번째 인덱스
        // [종료] 9번째 인덱스
        for (int i = 1; i < size; i++) {
            // 사이즈가 10인 배열이 존재할 때,
            // [시작] 0번째 인덱스
            // [종료] 배열의 크기 - 바깥 for문의 초기식 변수
            for (int j = 0; j < size - i; j++) {
                // 처음 for문이 도는 경우
                // 만약 0번째 인덱스값이 1번째 인덱스값보다 클 경우
                // 1번째 인덱스가 0번째 인덱스값으로 교환
                // 이로써 큰 수가 뒤에 위치하게 된다.
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                }
            }
        }
    }

삽입 정렬

이미 정렬된 배열에서 자기 자신의 자리를 찾아서 삽입된다고 하여 삽입 정렬이라고 한다.
매 순서마다 해당 요소를 앞의 정렬된 배열에서 삽입할 수 있는 위치를 찾아 해당 위치에 넣는다.
해당 위치에 있던 요소부터 뒤의 요소들은 한 칸씩 밀린다.

    private static void insertionSort(Integer[] a, int size) {
        // 사이즈가 10인 배열이 존재할 때,
        // [시작] 1번째 인덱스
        // [종료] 9번째 인덱스
        for (int i = 1; i < size; i++) {
            // 처음 수행 시 1번째 인덱스 원소를 target 변수에 초기화
            int target = a[i];
            // 변수 j는 바깥 for문 초기식 변수보다 1이 작다.
            // 처음 수행 시 0번째 인덱스을 의미한다.
            int j = i - 1;
            // 변수 j의 값이 0 이상이고,
            // 바깥 for문 초기식 변수 인덱스의 값이, 1값을 뺀 인덱스 값보다 작을 경우
            // 이전 원소값들을 한 칸씩 뒤로 미룬다.
            // 그 후 j의 값을 하나 감소시킨다.
            while (j >= 0 && target < a[j]) {
                a[j + 1] = a[j];
                j--;
            }
            // 위 while문을 빠져나오는 경우는 앞의 원소가 타겟(바깥 for문 초기식 변수 원소)보다 작다는 뜻으로,
            // 타겟 원소는 j번째 원소 뒤에 와야한다.
            a[j + 1] = target;
        }
    }

삽입 정렬의 경우 코드만으로 이해가 어려울 수 있어 아래의 간단한 로그를 출력해보았다.

정렬 작업 전
1 5 7 8 6 4 2 3 9 
================= 바깥 for문 시작, i : 1 =================
target : 5, a[i] : 5
a[j+1] : 5
================= 바깥 for문 시작, i : 2 =================
target : 7, a[i] : 7
a[j+1] : 7
================= 바깥 for문 시작, i : 3 =================
target : 8, a[i] : 8
a[j+1] : 8
================= 바깥 for문 시작, i : 4 =================
target : 6, a[i] : 6
j : 3, target : 6, a[j] : 8
j : 2, target : 6, a[j] : 7
a[j+1] : 6
================= 바깥 for문 시작, i : 5 =================
target : 4, a[i] : 4
j : 4, target : 4, a[j] : 8
j : 3, target : 4, a[j] : 7
j : 2, target : 4, a[j] : 6
j : 1, target : 4, a[j] : 5
a[j+1] : 4
================= 바깥 for문 시작, i : 6 =================
target : 2, a[i] : 2
j : 5, target : 2, a[j] : 8
j : 4, target : 2, a[j] : 7
j : 3, target : 2, a[j] : 6
j : 2, target : 2, a[j] : 5
j : 1, target : 2, a[j] : 4
a[j+1] : 2
================= 바깥 for문 시작, i : 7 =================
target : 3, a[i] : 3
j : 6, target : 3, a[j] : 8
j : 5, target : 3, a[j] : 7
j : 4, target : 3, a[j] : 6
j : 3, target : 3, a[j] : 5
j : 2, target : 3, a[j] : 4
a[j+1] : 3
================= 바깥 for문 시작, i : 8 =================
target : 9, a[i] : 9
a[j+1] : 9

정렬 작업 후
1 2 3 4 5 6 7 8 9 
Process finished with exit code 0

정렬 알고리즘의 장, 단점

선택 정렬
장점 : 구현이 간단하고, 비교하는 과정에 비해 실제 교환 횟수는 적어서 많은 교환 횟수를 요하는 자료 상태에서 효율적이다.
단점 : 데이터의 개수가 많아질 시 성능이 떨어진다.

버블 정렬
장점 : 구현이 간단하다.
단점 : 데이터의 개수가 많아질 시 성능이 떨어진다.

삽입 정렬
장점 : 구현이 간단하고 데이터가 이미 정렬되어 있을 경우 성능이 좋다
단점 : 입력 데이터가 역순으로 정렬되어 있을 때 성능이 좋지 않다.

Date, Calendar 클래스의 경우 자바 1버전에서 출시된 것으로 나온지 아주 오래된 놈이다. 그렇기에 여러 문제점을 갖고 있다.

대표적인 문제점을 집어보겠다.

Date의 클래스 문제점

• Date 클래스는 내부적으로 mutable한 상태를 가지고 있기 때문에 set메서드를 통해 값이 바뀌어, mutable한 상태가 변경되어서 값이 변경되게 된다. 이러한 경우에는 다른 곳에서도 같은 인스턴스를 참조하고 있을 경우에도 값이 변경되어 예기치 않은 결과가 발생할 수 있다.

Calander 클래스의 문제점

• Calendar 클래스는 복잡하고 잘못 사용하면 버그가 발생할 수 있는 상황이 많다. 그 중에서도 가장 대표적인 예시는 월(month) 정보를 다루는데 있다. Calendar 클래스에서 월 정보를 다루는 메서드들은 0부터 시작하며, 0은 1월을 의미하고, 11은 12월을 의미한다. 이러한 특징 때문에 다음과 같은 코드를 작성할 경우 버그가 발생할 수 있습니다.

그렇기에 우린 자바 8버전에서 출시된 java.time 패키지를 사용하자

• 자바 8부터는 java.time 패키지를 도입하여 새로운 API를 제공하는데, 이 API는 날짜와 시간 정보를 다루는 작업이 쉽고 간편하며, 불변 객체로 구현되어 있기 때문에 안전하게 사용할 수 있다.

다음의 코드를 통해 현재 날짜 및 이전의 날짜의 정보를 가져올 수 있다.

        ZoneId seoulZoneId = ZoneId.of("Asia/Seoul");
        LocalDateTime now = LocalDateTime.now(seoulZoneId);
        Instant threeDaysAgo = now.minusDays(3).with(LocalTime.MIN).atZone(seoulZoneId).toInstant();
        Instant nowInstant = now.atZone(seoulZoneId).toInstant();

with 메서드의 인자로 LocalTime.MIN, LocalTime.MAX를 넣어 활용하면 해당 날짜의 00:00:00, 23:59:59의 유닉스 타임을 가져올 수 있는데, 아주 유용하다

• now.with(LocalTime.MIN).atZone(seoulZoneId).toInstant();
• now.with(LocalTime.MAX).atZone(seoulZoneId).toInstant();

그것은 바로 SELECT을 하는 쿼리의 id값을 매핑된 상태에 포함하지 못하여 발생한 에러이다.

문제의 원인을 파악하지 못해 긴 시간을 허비하였으나, 끝내 문제를 해결하였다.

해결법은 다음과 같다.

마이바티스 세팅을 위해 dataSource 프로퍼티의 mapperLocations의 항목을 추가해주지 않아서이다.

사용하려는 마이바티스 쿼리 xml 파일을 프로퍼티에 추가시켜주어, 문제를 해결하였다.

결론은 새로 생성한 쿼리 작성 파일을 못읽어서 해당 value를 못찾는 에러였던 것이다.

하지만 이 에러의 경우 해당 경우 이외에 쿼리문을 잘못작성하는 등의 이유로도 발생한다고 하니, 다른 블로그 게시글을 참고하여야 할 수도 있다.

- 예시

        <set>
            <if test="actionType != null">actionType = #{actionType},</if>
            <if test="contents != null">contents = #{contents},</if>
        </set>

#{}

• 사용 시 PreparedStatement 생성한다.

• PreparedStatement가 제공하는 set 계열의 메서드를 사용하여 물음표를 대체할 값을 지정한다.

• 들어오는 데이터를 문자열(String)로 인식하여, 자동 따옴표가 붙는다.

• SQL Injection을 예방할 수 있어 보안 측면에서 유리함.

• 사용 이유

  • PreparedStatement란 친구는 수행 시 물음표값에 Parameter가 바인딩되어 수행된다.
  • 이는 Parameter 값이 바뀌어도 같은 쿼리로 인식한다는 의미로, 이렇게 파싱된 쿼리는 재활용되기에(캐싱) 성능 상 이점을 갖는다.

• 결론

  • #{} 값에 자동으로 따옴표가 붙고 성능이 좋다.

${}

• 사용 시 Statement를 생성한다.

• Statement란 친구는 Parameter 값을 그대로 전달하기에 문자열에 따옴표가 붙지 않는다.

• 항상 쿼리문에 대한 파싱이 진행되어 처리 속도가 저하될 수 있다는 단점이 존재한다.

• SQL Injection을 예방할 수 없어, 보안 상 불리하다는 단점이 존재한다.

  • SQL Injection : 악의적인 사용자가 보안상의 취약점을 이용하여, 임의의 SQL 문을 주입하고 실행되게 하여 데이터베이스가 비정상적인 동작을 하도록 조작하는 행위

• 사용 이유

  • 테이블, 컬럼명을 전달하고자 할 때 사용되곤 한다.

• 결론

  • ORDER BY하고 싶은 컬럼이 있을 때 파라미터를 통해 ASC, DESC를 설정하고 싶은 경우 #{}를 사용할 경우 따옴표가 붙어 'ASC','DESC'같이 변환되어, 원하는대로 동작되지 않기에 이 경우가 아니라면 굳이 ${}를 써야하나 싶다.

atime (access time, 접근 시간)

• 파일에 접근한 시간을 나타낸다.
  

• 파일을 open할 때마다 갱신되며 vi, cat 명령어로 파일 확인 시 atime값은 변한다.

  
  
  

  mtime (modification time, 접근 시간)
  

• 파일의 내용이 수정될 때 mtime값은 변한다.

  
  
  

  ctime (change time, 접근 시간)
  

• inode의 값 (파일 속성, 권한, 크기 등)이 변경되면 ctime값은 변한다.

오해와 진실

• ctime의 경우 잘못 생각하면 creation time으로 이해할 수 있고 초기에는 이런 의미로 썼으나, 나중엔 의미가 변경되어 현재는 incode changed time 용도로 사용된다.

• inode 변경이 발생하는 행동

  • chmod(file permissions 변경)
  • chown(file 소유자 변경)
  • ln(하드 링크 생성)
  • rm(삭제)

• %x, %y, %z 지정자를 사용하여 사람이 읽기 좋게 파일의 atime, mtime, ctime을 표시해줄 수 있다.

• 관련 링크

  • https://www.lesstif.com/lpt/atime-mtime-ctime-105644095.html

• 다음의 리눅스 명령어 사용 시 Argument list too long이 발생!

• 이 에러는 find 명령어 수행 시 한 번에 리스팅(리스팅:작업 중에 있는 디렉토리에 있는 내용의 리스트)할 수 있는 파일의 개수를 초과했을 경우 나오는 메시지이다.

• 결론적으로 해당 디렉토리에 파일, 디렉토리 개수가 너무 많아 발생한 것이다.

해결

• 그래서 찾은 후 수행할 작업 명령어를 추가해주었다.

• exec 명령어 {} ; : 찾은 파일들에 대해서 쉘 명령어를 사용해서 특정명령실행

  • {} : find로 찾은 파일리스트

  • ; : -exec와 -ok는 반드시 escape 된 세미클론(;)으로 종료해야 하며 이는 옵션의 끝을 의미한다.

find /sec/1/nonverbal/*/*/ -name "*.wav" -mtime +30 -exec rm -rf {} \;

• 참고로 삭제하는 대상의 기준이 파일이 아닌 디렉토리일 경우 -name 옵션을 빼준 뒤 다음과 같이 수정해주는 방법도 있다.

  find /sec/*/nonverbal/*/* -type d -mtime +30 -exec rm -rf {} \;

• 관련 링크

- https://linuxism.ustd.ip.or.kr/365
- https://tyson.tistory.com/233
- https://yjshin.tistory.com/entry/Linux-%EB%A6%AC%EB%88%85%EC%8A%A4-%EC%98%A4%EB%9E%98%EB%90%9C-%ED%8C%8C%EC%9D%BC-%EC%82%AD%EC%A0%9C%ED%95%98%EA%B8%B0

• IntSummaryStatistics
• LongSummaryStatistics
• DoubleSummaryStatistics

사용 예제

    private double getSensingDataAvg(List<Double> sensingDataList) {
        // mapToDouble : 스트림의 요소를 기본 타입형 스트림으로 반환하여 작업 효율을 높이기 위해 사용
        DoubleSummaryStatistics SummaryStatistics = sensingDataList.stream().mapToDouble(Double::doubleValue).summaryStatistics();
        return SummaryStatistics.getAverage();
    }

• 관련 자료

  • https://www.techiedelight.com/ko/calculate-average-of-all-items-list-java/
  • https://codechacha.com/ko/java8-summarystatistics/

그에 대한 원인은 해당 설정 파일에 오타가 포함되어 태그 매칭에 에러가 발생하여 그렇다.

<entry key="influxdb.username">testyang</entry>ㅡ

다음과 같이 바꿔주어 해결한다.

<entry key="influxdb.username">testyang</entry>

• 참조 링크 : http://blog.idmware.com/2012/01/im-trying-to-make-my-java-xml.html

- 실제 값을 저장 장소로 갖는 자료형이다.
- 산술 연산이 가능하다.
- null값으로 초기화가 불가능하며, 0으로 초기화된다.

Integer (Wrapper 클래스, 객체)

- 실제 값이 아닌 객체의 주소를 저장하고 있는 객체형 변수로 참조형이다.
- Unboxing하지 않으면 산술 연산이 불가능하나, null값은 처리할 수 있다.
- null값 처리가 용이하여 SQL과 연동 시 처리가 효율적이다.

public static void main(String[] args) {
        Integer iA = new Integer(123);
        Integer iB = new Integer(123);

        int ia = (int) iA;              // 언박싱 (참조형 => 기본형)
        int ib = iB;                    // 오토 언박싱

        Integer iC = (Integer) 456;     // 박싱 (기본형 => 참조형)
        Integer iD = ia;                // 오토 박싱
    }

equals 메서드

비교하고자 하는 대상의 내용 자체를 비교한다.

==

비교하고자 하는 대상의 주소값을 비교한다.

    public static void main(String[] args) {
        String a = "aaa";
        String b = a;
        String c = new String("aaa");

        System.out.println(a.equals(b));        // 내용 비교    -> TRUE
        System.out.println(a == b);             // 주소값 비교  -> TRUE
        System.out.println(a == c);             // 주소값 비교  -> FALSE
        System.out.println(a.equals(c));        // 내용 비교    -> TRUE


        System.out.println(a);                  // aaa
        System.out.println(b);                  // aaa
        System.out.println(c);                  // aaa
    }

의사 코드

운전자가 자동차를 생산한다.
자동차는 내부적으로 타이어를 생산한다.

자바 코드

new Car();
Car 객체 생성자에서 new Tire();

설명

의존성은 new로, new를 실행하는 Car가 Tire에 의존한다.

1. 스프링없이 의존성 주입하기 1 - 생성자를 통해 의존성을 주입

의사 코드

운전자가 타이어를 생산한다.
운전자가 자동차를 생산하면서 타이어를 장착한다.

자바 코드 - 생성자 인자 이용

Tire tire = new koreaTire();
Car car = new Car(tire);

➜ 전략 패턴 사용 (전략 패턴의 3요소 : 클라이언트, 전략, 컨텍스트) 1. 전략 : Tire를 구현한 koreaTire, americaTire (전략 메서드를 가진 전략 객체) 2. 컨텍스트 : Car의 getTireBrand() 메서드 (전략 객체를 사용하는 컨텍스트) 3. 클라이언트 : Driver의 main() 메서드 (전략 객체를 생성해 컨텍스트에 주입하는 제3자)

2. 스프링없이 의존성 주입하기 2 - 속성을 통해 의존성을 주입

의사 코드

운전자가 타이어를 생산한다.
운전자가 자동차를 생산한다.
운전자가 자동차에 타이어를 장착한다.

자바 코드 - 생성자 인자 이용

Tire tire = new koreaTire();
Car car = new Car();
car.setTire(tire);

3. 스프링을 통한 의존성 주입 - XML 파일 사용

의사 코드

운전자가 종합 쇼핑몰에서 타이어를 구매한다.
운전자가 종합 쇼핑몰에서 자동차를 구매한다.
운전자가 자동차에 타이어를 장착한다.

자바 코드 - 생성자 인자 이용

ApplicationContext context = new ClassPathXmlApplicationContext("main/java/expert002_01/expert002.xml");

// 종합 쇼핑몰에서 상품에 해당하는 Car, Tire 구매하는 코드
Car car = context.getBean("car", Car.class);
Tire tire = context.getBean("tire", Tire.class);
car.setTire(tire);

    <bean id="tire" class="main.java.expert002.koreaTire"/>

    <bean id="americaTire" class="main.java.expert002.AmericaTire"/>

    <bean id="car" class="main.java.expert002.Car"/>

4. 스프링을 통한 의존성 주입 - 스프링 설정 파일(XML)에서 속성 주입

의사 코드

운전자가 종합 쇼핑몰에서 자동차를 구매 요청한다.
종합 쇼핑몰은 자동차를 생산한다.
종합 쇼핑몰은 타이어를 생산한다.
종합 쇼핑몰은 자동차에 타이어를 장착한다.
종합 쇼핑몰은 운전자에게 자동차를 전달한다.

자바 코드 - 생성자 인자 이용

ApplicationContext context = new ClassPathXmlApplicationContext("expert003/expert003.xml");
Car car = context.getBean("car", Car.class);

    <bean id="koreaTire" class="main.java.expert003.koreaTire"/>

    <bean id="americaTire" class="main.java.expert003.AmericaTire"/>

    <bean id="car" class="main.java.expert003.Car">
        <property name="tire" ref="koreaTire"/>
    </bean>

5. 스프링을 통한 의존성 주입 - @Autowired를 통한 속성 주입

의사 코드

운전자가 종합 쇼핑몰에서 자동차를 구매 요청한다.
종합 쇼핑몰은 자동차를 생산한다.
종합 쇼핑몰은 타이어를 생산한다.
종합 쇼핑몰은 자동차에 타이어를 장착한다.
종합 쇼핑몰은 운전자에게 자동차를 전달한다.

자바 코드 - 생성자 인자 이용

ApplicationContext context = new ClassPathXmlApplicationContext("main/java/expert004/expert004.xml");

Car car = context.getBean("car", Car.class);

     <context:annotation-config />

    <bean id="tire" class="main.java.expert004.koreaTire"/>

    <bean id="americaTire" class="main.java.expert004.AmericaTire"/>

    <bean id="car" class="main.java.expert004.Car" />


public class Car {
    @Autowired
    Tire tire;

    public String getTireBrand() {
        return "장착된 타이어 : " + tire.getBrand();
    }

}

@Autowired를 통한 속성 매칭 규칙(feat.@Resource)

1. 타입(인터페이스)을 구현한 Bean이 존재하고, 빈이 한 개 인가 (예 => 유일한 빈 객체 할당, 아니오 => No Matching bean 에러)

2. 아니오 => id가 일치하는 하나의 빈이 있는가 (예 => 유일한 빈 객체 할당, 아니오 => No Unique 에러)

스프링의 @Autowired는 id 매칭보다 type 매칭이 우선이기에 스프링 설정 파일 내 id가 존재하지 않더라도 클라이언트 측에서 클래스로 호출하여 의존성 주입 시 정상적으로 구동된다.

@Resource : 자바 표준 어노테이션 -> type과 id 가운데, 매칭 순위는 id가 더 높다. 고로 id로 매칭한 빈을 못찾을 경우 type으로 매칭할 빈을 찾게 된다.

@Autowired : 스프링 어노테이션 -> type과 id 가운데, 매칭 순위는 type이 더 높다.

스프링을 사용하지 않는다면 @Resource만을 사용해야 한다.

• MyBatis를 통해 RDB에 값을 넣는 과정에서 0인 Double 타입의 데이터가 null로 적재됨

원인

• null을 판별하는 다음의 코드에서 파라미터가 0인 경우 공백으로 판단한다.

        <if test="currentValue != null and currentValue != ''">, #{currentValue}</if>

해결

• 유효성 검사는 자바 부분에서 처리하여 진행

• MyBatis 쿼리문 내 0이 들어갈 수 있는 파라미터에 조건문을 없애고 '#{currentValue}'와 같이 작성

의존성 주입

<!-- 모델매퍼 테스트 -->
    <dependency>
        <groupId>org.modelmapper</groupId>
        <artifactId>modelmapper</artifactId>
        <version>2.3.8</version>
    </dependency>

Spring Bean 등록

다음과 같이 어노테이션으로 하던지, 아니면 xml 설정파일에 bean 등록하여 사용할 것

@Configuration
public class AppConfig {

    @Bean
    public ModelMapper modelMapper(){
        return new ModelMapper();
    }

}

만들어지는 대상은 Getter, 만드는 대상은 Setter가 필요하다.

전달할 데이터 - DTO

@AllArgsConstructor
@Getter
public class TestDTO {
    private String id;
    private String name;
}

전달받을 데이터 - VO

@Setter
public class TestVO {
    private String id;
    private String name;
}

의존성 주입

        // service단에서 다음의 로직을 수행

        // 생성자를 통해 값 세팅
        TestDTO testDTO = new TestDTO("1","임꺽정");

        // 해당 메서드로 값 전달 진행
        TestVO testVO = modelMapper.map(testDTO,TestVO.class); 

• 파라미터가 String 형태로 들어와 ""로 감싸진다.
• 쿼리문 작성 시 #{}의 경우에는 PreparedStatement를 생성하게 되는데 파라미터에 ?가 바인딩되어 수행된다.
• 예시로 #{user_id}의 user_id의 값이 abc일 경우 쿼리에는 'abc'의 형태가 된다
• 파싱된 쿼리문은 재활용(캐싱)되기 때문에 효율적이다.
• 쿼리 주입을 예방할 수 있어 보안 측면에서 유리하다.

${}

• 파라미터가 String 형태로 들어와 ""로 감싸지지 않아, 테이블이나 컬럼명을 파라미터로 전달하고 싶을 때 사용한다.

    <select id="select" resultType="String" parameterType="Map">
        SELECT
            name AS name
        FROM
            user_#{tableId} // 컬럼명에 ""가 안붙어 bad sql Exception 발생 X
        WHERE
            id = #{id}
    </select>

• 해당 컬럼의 자료형에 맞춰 파라미터의 자료형이 변경되기에 항상 쿼리문 파싱을 진행하여 성능상에 단점이 존재한다.

• 쿼리 주입을 예방할 수 없어 보안 측면에서 불리하다.

서브쿼리 내에서 ORDER BY를 설정해도 효과가 없는 이유

| 참고 자료 => https://mariadb.com/kb/en/why-is-order-by-in-a-from-subquery-ignored/

해결 방법

1. 서브쿼리 내 order by 뒤에 limit를 걸어라

2. ORDER BY절을 최상위 절로 옮겨라 (위 참고자료에서 추천하는 방식)

@NotNull : null은 허용하지 않으나, "", " "은 허용한다.

@NotEmpty : null, ""은 허용하지 않으나, " "은 허용한다.

@NotBlank : null, "", " " 모두 허용하지 않는다.

- 참고로 위 어노테이션을 사용하기 위해 컨트롤러의 DTO 파라미터에

@Valid 어노테이션을 추가해줘야 제 기능을 수행한다.

• String 타입에서 @NotBlank 사용

• Integer 타입 등 숫자 관련 타입은 @NotNull 사용

타입에 어노테이션을 제대로 사용하지 않을 경우 다음의 에러가 발생할 수 있다.

{ "result": "error", "message": "HV000030: No validator could be found for type: java.lang.Integer.", "code": 500 }

프로그램이 메모리 사용 방식

• 코드 실행 영역
• 데이터 저장 영역

객체 지향 프로그램의 메모리 사용 방식

• 코드 실행 영역

• 데이터 저장 영역

  • static 영역
  • stack 영역
  • heap 영역

함수를 쓰면 좋은 이유

• 중복 코드를 한 곳에 모아서 관리할 수 있다.
• 논리를 함수 단위로 분리해서 이해하기 쉬운 코드를 작성할 수 있다.

멀티 프로세스 : 다수의 데이터 저장 영역, 즉 다수의 T 메모리를 갖는 구조이다.

멀티 스레드 : T 메모리 내 스택 영역을 스레드 개수만큼 분할하여 사용하는 것을 의미한다.

객체지향의 4대 특성

객체지향 설계 5원칙

디자인 패턴

객체지향의 4대 특성

• 추상화 (모델링) ➜ 객체들의 공통적인 특성(기능)을 뽑아 이름을 붙이는 것
• 다형성 (사용편의성) ➜ 오버라이딩(메서드 재정의), 오버로딩(메서드 중복 정의)을 통해 다형성을 제공하고 이는 개발자에게 사용 편의성을 제공한다.
• 캡슐화 (은닉화) ➜ 특정 객체가 독립적으로 역할을 수행하기 위해 필요한 기능을 묶은 것으로 정보에 대한 접근에 제한을 두는 것을 의미한다.
• 상속 (재사용성, 확장) ➜ 상위 개념을 하위 개념이 물려받음을 의미한다.

상위 클래스와 인터페이스

➜ 상위 클래스는 물려줄 특성이 많을수록 이상적이다. (because of LSP) ➜ 인터페이스는 구현을 강제할 메서드가 적을수록 이상적이다. (because of ISP)

다중 상속

➜ 자바는 부모 클래스를 하나 이상 가질 수 없다. 허나 인터페이스는 추상클래스보다 더욱 추상적이기에 여러 인터페이스 상속을 받을 수 있기는 하다.

추상 클래스

사용하는 이유 1 : 객체 타입 강제를 위해 ➜ 단적인 예로 누가 실수로 "동물" 객체를 만들면 안되기 때문이다. 사용하는 이유 2 : 메서드 내용 구현 자율화를 위해➜ 행위를 어떻게 구현할까(구체화)에 대한 자율성 부여

final 키워드 출몰 지역

1. 클래스 -> 상속 금지
2. 변수 -> 데이터 변경 불가 (상수)
3. 메서드 -> 오버라이딩 금지

객체지향 설계 5원칙