Lombok의 @Builder는 객체를 빌더 패턴(Builder Pattern)으로 생성할 수 있도록 도와주는 애노테이션이다. 빌더 패턴은 특히 매개변수가 많거나 선택적으로 제공되는 경우에 유용한 객체 생성 방식으로, 코드의 가독성을 높이고 유지보수를 쉽게 만들어준다. Lombok은 이 패턴을 매우 간단하게 구현할 수 있게 해준다.

주요 특징

1. 유연한 객체 생성: 모든 필드를 한 번에 설정할 필요 없이, 필요한 필드만 선택적으로 설정할 수 있다.
2. 불변성(Immutable): 빌더 패턴을 사용하면 객체를 생성한 후 수정할 수 없도록 만들기 쉽다.
3. 가독성 향상: 매개변수가 많을 때, 코드의 가독성을 높여주고 매개변수의 순서를 기억할 필요가 없어진다.

기본 사용법

Lombok의 @Builder 애노테이션을 클래스 또는 생성자에 붙여 사용한다.

import lombok.Builder;

@Builder
public class User {
    private String name;
    private int age;
    private String email;
}

빌더 사용 예시

위의 클래스에 대해 빌더 패턴을 사용하여 객체를 생성할 수 있다.

public class Main {
    public static void main(String[] args) {
        User user = User.builder()
                        .name("John Doe")
                        .age(30)
                        .email("john.doe@example.com")
                        .build();

        System.out.println(user);
    }
}

@Builder의 장점

• 매개변수의 순서가 중요하지 않음: 빌더를 사용하면 생성자에 넣는 매개변수의 순서를 기억할 필요 없이, 각 필드를 명시적으로 설정할 수 있다.
• 유연한 객체 생성: 모든 필드를 다 채울 필요 없이, 필요한 필드만 선택적으로 설정할 수 있다.
• 읽기 쉬운 코드: 많은 매개변수를 가진 객체를 생성할 때 가독성이 높아진다.

@Builder와 @AllArgsConstructor, @NoArgsConstructor와의 조합

Lombok의 @AllArgsConstructor와 @NoArgsConstructor와 함께 사용하면 더 유연하게 객체 생성 방식을 조합할 수 있다.

import lombok.Builder;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Product {
    private String name;
    private double price;
    private int stock;
}

이와 같이 Lombok의 @Builder는 복잡한 객체 생성 과정을 단순화해주고, 객체 생성 시 유연성을 높이는 데 매우 유용하다.

copyProperties()는 Spring Framework의 BeanUtils 클래스에 있는 메서드로, 하나의 객체에서 다른 객체로 필드 값을 복사할 때 사용된다. 주로 두 객체 간에 같은 필드 이름과 타입을 가진 경우에 유용하게 사용할 수 있다. 이 메서드를 사용하면 객체의 특정 필드들을 일일이 복사하지 않고 한 번에 처리할 수 있어 코드를 간결하게 유지할 수 있다.

기본 사용법

import org.springframework.beans.BeanUtils;

public class Main {
    public static void main(String[] args) {
        SourceObject source = new SourceObject();
        source.setName("John");
        source.setAge(30);

        TargetObject target = new TargetObject();
        BeanUtils.copyProperties(source, target);

        System.out.println(target.getName());  // "John"
        System.out.println(target.getAge());   // 30
    }
}

위 코드에서 BeanUtils.copyProperties(source, target)를 사용하면 source 객체의 name과 age 값이 target 객체로 복사된다.

주요 특징

1. 같은 이름과 타입을 가진 필드만 복사: 소스와 타깃 객체의 필드 이름과 타입이 일치해야 복사된다.
2. null 값도 복사: 소스 객체의 필드 값이 null일 경우, 타깃 객체의 필드 값도 null로 덮어씌워진다.
3. 부분 복사 가능: 소스 객체에 존재하지만 타깃 객체에 없는 필드는 무시된다. 즉, 타깃 객체에 정의되지 않은 필드는 복사되지 않는다.

특정 필드를 제외하고 복사

copyProperties()는 특정 필드를 제외하고 복사할 수도 있다. 예를 들어, 특정 필드는 복사하고 싶지 않을 때 ignoreProperties 매개변수를 사용할 수 있다.

BeanUtils.copyProperties(source, target, "age");

위 코드는 age 필드를 제외하고 나머지 필드를 복사한다.

사용 시 주의사항

1. 필드 타입 일치: 필드의 이름과 타입이 일치하지 않으면 해당 필드는 복사되지 않는다.
2. getter, setter 필요: copyProperties()는 필드에 직접 접근하는 것이 아니라 getter와 setter 메서드를 통해 값을 복사한다. 따라서 필드에 대한 getter/setter가 정의되어 있어야 한다.
3. 복잡한 객체: 깊은 복사(deep copy)가 아니라 얕은 복사(shallow copy)를 수행한다. 즉, 객체 안에 참조된 객체의 필드는 복사되지 않고 동일한 객체 참조를 가리키게 된다.

실사용 예시

copyProperties()는 주로 다음과 같은 상황에서 유용하다.

• DTO(Data Transfer Object)와 Entity 간 데이터 복사: 서비스 레이어에서 DTO와 Entity 간 데이터를 주고받을 때, 두 객체 간에 필드가 유사하다면 일일이 값을 할당하지 않고 copyProperties()로 쉽게 처리할 수 있다.

UserDTO userDTO = new UserDTO();
userDTO.setName("John");
userDTO.setAge(30);

UserEntity userEntity = new UserEntity();
BeanUtils.copyProperties(userDTO, userEntity);

• 기존 객체의 값 업데이트: 기존에 생성된 객체의 일부 필드 값을 다른 객체로부터 업데이트해야 할 때 유용하다.

Spring의 copyProperties()를 사용하면 객체 간의 데이터 전송이 훨씬 간결해지고, 반복되는 코드를 줄일 수 있다.

Stream.of().anyMatch(Objects::isNull)는 Java의 Stream API와 Objects 클래스의 유틸리티 메서드를 조합해 스트림 내에 null 값이 있는지 확인할 때 사용하는 코드이다. 이 구문을 자세히 분석하면 아래와 같은 요소들로 구성된다.

1. Stream.of()

Stream.of()는 Java 8에서 추가된 Stream API의 메서드로, 지정된 요소들로 스트림(Stream)을 생성한다. 스트림은 데이터를 처리하는데 있어 선언적이고 함수형 스타일을 사용할 수 있도록 도와주는 클래스이다. Stream.of()는 가변인자(varargs)를 받기 때문에 여러 개의 요소를 전달할 수 있다.

예시:

Stream<String> stream = Stream.of("A", "B", "C");

여기서 "A", "B", "C"는 스트림에 포함된 요소들이다.

2. Objects::isNull

Objects::isNull은 Java의 Objects 유틸리티 클래스에 있는 정적 메서드로, 입력된 객체가 null인지 확인하는 메서드이다. 이는 object == null과 동일한 역할을 한다.

boolean result = Objects.isNull(someObject);  // true if someObject is null

3. anyMatch()

anyMatch()는 Stream API에서 제공하는 메서드로, 스트림의 요소 중 하나라도 주어진 조건(predicate)을 만족하면 true를 반환한다. 모든 요소를 확인하지 않고, 조건에 맞는 첫 번째 요소를 찾으면 탐색을 중단하고 true를 반환한다.

예시:

boolean hasEven = Stream.of(1, 2, 3).anyMatch(n -> n % 2 == 0);  // true

위 코드에서 스트림에 있는 숫자 중 하나라도 짝수면 true를 반환한다.

4. 결합: Stream.of().anyMatch(Objects::isNull)

이제 이 코드의 전체 의미를 보면, Stream.of()로 생성된 스트림 내에 null이 있는지 확인하는 과정이다. Objects::isNull은 요소가 null인지 판단하는 기준이 되고, anyMatch()는 해당 조건을 만족하는 요소가 하나라도 있으면 true를 반환한다.

예시:

boolean hasNull = Stream.of("A", null, "C").anyMatch(Objects::isNull);
System.out.println(hasNull);  // true

이 코드는 "A", null, "C"로 구성된 스트림에서 하나라도 null인 값이 있는지를 확인하는 것이다. null 값이 존재하기 때문에 hasNull은 true가 된다.

동작 과정 요약:

1. Stream.of("A", null, "C"): 스트림에 "A", null, "C" 세 가지 값을 넣는다.
2. anyMatch(Objects::isNull): 각 요소가 null인지 검사하는데, null이 발견되면 true를 반환하고 스트림 탐색을 종료한다.

5. 실제 사용 예시

이 코드는 다양한 곳에서 유용하게 사용할 수 있다. 예를 들어, 메서드에 전달된 여러 매개변수나 리스트에 null 값이 있는지 빠르게 확인할 수 있다.

예시 1: 메서드 매개변수 확인

public void processData(String a, String b, String c) {
    if (Stream.of(a, b, c).anyMatch(Objects::isNull)) {
        throw new IllegalArgumentException("One or more arguments are null");
    }
    // 처리 로직
}

여기서는 메서드로 전달된 a, b, c 중 하나라도 null이면 예외를 던진다.

예시 2: 리스트에 null 값이 있는지 확인

List<String> list = Arrays.asList("apple", null, "banana");
boolean containsNull = list.stream().anyMatch(Objects::isNull);

System.out.println(containsNull);  // true

리스트에서 null 값을 찾을 때도 anyMatch와 Objects::isNull을 사용할 수 있다.

결론

Stream.of().anyMatch(Objects::isNull)는 스트림에서 null 값을 빠르게 찾는 데 유용한 구문이다. Stream.of()로 스트림을 만들고, anyMatch()를 사용해 Objects::isNull을 기준으로 null 여부를 검사한다. 이 방식은 코드의 간결성과 가독성을 높이며, 특히 데이터 유효성 검사나 필드 검증에서 자주 사용될 수 있다.

YML 파일에 다국어 값을 저장하는 이유?!

1. 구조화된 설정 관리:

• YML 파일은 기본적으로 설정 파일로 사용되기 때문에, 다국어와 관련된 설정 값을 하나의 파일에서 구조화된 형태로 관리할 수 있다.
• 다국어뿐만 아니라 서버 설정, 외부 API 설정 등을 함께 관리할 수 있기 때문에 설정 통합 관리가 가능하다. 예를 들어, batchmonitor.server-type처럼 특정 모듈의 서버 유형을 YML 파일에 저장함으로써 코드 변경 없이 설정만 업데이트할 수 있다.

2. 배포 시 수정이 쉬움:

• YML 파일은 애플리케이션의 설정 파일이기 때문에, 코드를 수정하지 않고 설정을 변경하거나 추가할 수 있다.
• 예를 들어, 새로운 언어가 추가되거나 기존 서버 유형의 명칭이 바뀌는 경우에도 애플리케이션 재시작 또는 핫스왑만으로 쉽게 변경사항을 적용할 수 있다. DB나 message code 방식보다 빠르게 대응할 수 있음.

3. 경량화 및 속도:

• YML 파일은 애플리케이션 구동 시 메모리에 로드 되어 빠르게 참조할 수 있다. DB에서 값을 불러오는 것보다 조회 속도가 빠르고, 코드 내에서 간단히 접근할 수 있어. 메시지 코드 방식보다는 비교적 가볍고 단순하다.

4. 환경별 설정 가능:

• Spring에서 프로파일 기능을 이용해 YML 파일을 환경별로 다르게 설정할 수 있다. 즉, 개발 환경, 테스트 환경, 운영 환경에서 각기 다른 다국어 설정을 사용할 수 있음.
• DB 방식으로 다국어를 관리할 경우 환경마다 데이터베이스에 추가 설정을 해야 하거나 복잡한 동기화가 필요할 수 있지만, YML 파일은 환경에 맞게 쉽게 분리할 수 있음.

5. 단순성과 유지보수 용이성:

• YML 파일에 다국어 설정을 관리하면 복잡한 로직 없이 간단히 값을 가져와 사용할 수 있다. message code 방식은 messages.properties에 다국어 값을 정의하고 코드에서 MessageSource를 통해 불러오는 방식인데, 이는 좀 더 복잡한 구조를 요구한다.
• 반면 YML 파일을 사용하는 방식은 직관적이고 추가/수정이 용이해. 예를 들어, 새로운 서버 유형이 추가되거나 언어가 추가될 때 YML 파일에 직접 추가하면 되니까 유지보수가 간편함.

다른 방식과 비교

1. DB에 저장:

• 장점: 다국어 데이터를 동적으로 관리할 수 있고, 데이터베이스 쿼리를 통해 검색 및 통계를 낼 수 있다. 다국어 데이터를 중앙에서 통합 관리할 수 있고, 다국어 텍스트가 많을 때 유리함.
• 단점: 조회 속도가 느릴 수 있고, 변경 사항을 반영하려면 DB 업데이트 및 쿼리 수정이 필요하다. 애플리케이션 레이어에서 DB 연결 없이 간단한 다국어 처리를 할 수 없기 때문에, YML 파일처럼 가볍지 않음.

2. Spring Message Code (messages.properties):

• 장점: 메시지 코드 방식은 Spring이 기본 제공하는 기능이므로 통합성이 높고, 다국어 메시지를 일관되게 관리할 수 있다. 기본적인 메시지 포맷팅, 다국어 지원, 그리고 재사용성이 높음.
• 단점: 추가/수정 시 properties 파일을 수정해야 하고, 코드 내에서 MessageSource와의 연결이 필요해 복잡도가 약간 올라감. 특히 다국어와 상관없는 설정 값을 관리할 때는 적합하지 않다.

YML에 다국어 설정을 저장하는 단점:

1. 대규모 데이터 관리에 불리함:

• YML 파일은 설정 파일로써 소규모의 간단한 데이터를 관리하기에 적합해. 하지만 다국어 항목이 많아지고 데이터가 복잡해지면 파일 자체의 크기가 커지고, 관리가 어려워질 수 있다.
• 특히 수백, 수천 개의 다국어 메시지를 처리해야 하는 경우, YML 파일로 관리하는 것은 비효율적이다. 이런 경우 DB처럼 대량의 데이터를 효율적으로 저장하고 조회할 수 있는 방식이 필요함.

2. 동적 변경의 어려움:

• YML 파일은 정적 설정 파일이기 때문에, 애플리케이션이 실행된 후에는 내용을 변경하기 어렵다. 변경 사항이 있을 경우 애플리케이션을 재시작해야 적용되기 때문에, 실시간으로 다국어 설정을 업데이트하거나 동적으로 적용할 수 없다는 단점이 있다.
• 반면 DB나 properties 파일을 사용하면, 다국어 메시지를 실시간으로 변경하고, 즉시 반영할 수 있다. 예를 들어, 관리자가 다국어 텍스트를 변경할 수 있는 관리 화면을 제공하려면 DB 방식이 유리하다.

3. 버전 관리의 복잡성:

• YML 파일은 코드와 함께 버전 관리되기 때문에, 다국어 텍스트의 변경 이력을 따로 관리하려면 번거로울 수 있다. 특히 여러 개발자가 동시에 작업할 경우, 충돌이 발생할 수 있고 이를 해결하기 위해 불필요한 작업이 추가될 수 있다.
• DB를 사용하면 다국어 메시지에 대한 변경 이력을 자동으로 추적할 수 있고, 메시지의 추가/수정/삭제도 별도 관리가 가능하다.

4. 파일 크기 증가:

• YML 파일의 크기가 커지면 애플리케이션 구동 속도에 영향을 줄 수 있다. 모든 다국어 데이터를 로드해야 하므로 메모리 사용량도 증가할 수 있다. 반면, DB는 필요한 데이터만 필터링해서 조회하기 때문에 메모리 부담이 적고, 확장성도 높다.

5. 환경에 따른 설정 분리의 어려움:

• YML 파일을 환경별로 나누기는 쉬우나, 다국어 설정이 각 환경마다 크게 달라지면 파일 관리가 복잡해질 수 있다. DB는 환경에 상관없이 동일한 데이터베이스를 사용할 수 있으므로, 환경에 독립적인 다국어 데이터 관리에 적합하다.

왜 DB나 properties 파일과 섞어서 사용하는가?

YML 파일과 DB 또는 properties 파일을 섞어서 사용하는 이유는, 각각의 장점과 단점을 잘 조합하여 효율적인 다국어 관리를 하기 위함이다.

적용 방법:

1. YML은 기본 설정:

• 고정된 소규모의 다국어 값(예: 서버 유형, 고정된 시스템 메시지)은 YML 파일에 저장해서 사용한다. 이런 값들은 자주 변경되지 않으므로 YML 파일로 관리하면 편리함.

2. DB는 대규모 데이터 및 동적 변경:

• 동적으로 추가되거나 자주 수정되는 다국어 메시지는 DB에서 관리한다. 예를 들어, 사용자 정의 메시지나 관리자가 자주 수정하는 내용을 실시간으로 반영하려면 DB에 저장하는 게 훨씬 유리하다.
• DB 방식은 다국어 메시지를 동적으로 불러올 수 있고, 애플리케이션을 재시작하지 않아도 되기 때문에 실시간 반영이 가능하다.

3. properties는 메시지 코드 관리:

• Spring의 message code(.properties 파일)는 주로 에러 메시지나 폼 필드 검증 메시지처럼 특정 로직에서 반복적으로 사용되는 메시지를 관리할 때 유리하다. properties 파일은 다국어 메시지를 중앙에서 관리하고, 필요할 때마다 손쉽게 가져올 수 있음.
• properties 방식은 다양한 언어의 에러 메시지를 코드로 정의해두고, 쉽게 유지보수할 수 있는 장점이 있다.

.properties에 기록된 데이터들이 외계어처럼 깨져 보일 때?! charset을 설정해서 해결하자! 😎

업무 중, 다국어를 설정해 둔 .properties 파일의 내용이 깨져 보이는 이슈가 있었다. 구글링을 통해 해결 방법을 찾았고, 답은 간단했다. 아래와 같이 file Encodings 설정을 해주면 해결 완료!

Default encoding for properties files: UTF-8

File > Setting > Editor >  Inspections

경고 표시를 제거하기 위해서는 SQL 메뉴에서 아래 3개 항목을 체크 해제 해야한다.

1. No data sources configured
2. SQL dialect detection
3. Unresolved reference**

회사에서 노트북으로 모바일 웹을 띄우려고 시도했다가, 위와 같은 화면을 만났다! 당황하지 말고 아래 방법으로 해결하자. 방법은 간단하다! 화면 아무 곳이나 클릭한 뒤 thisisunsafe 를 타이핑 하기만 하면 놀랍게도 화면이 정상적으로 표시된다. 이유가 뭘까 ㅎㅎ 궁금궁금 🤷‍♀️

해결방법 👉🏻 브라우저 내 아무곳이나 클릭 → thisisunsafe 입력

비싼 마우스 제대로 활용해보자!! 😎✨

방법은 간단하다. 로지텍 옵션 프로그램을 실행 후, 자주쓰는 인텔리제이 단축키를 이 버튼 저 버튼에 등록해주면 끝! 나는 브레이크 포인트를 보여주는 디버깅 창과 콘솔을 깔끔하게 지워주는 단축키, 그리고 북마크를 스크롤키 옵션에 넣어 바로 띄울 수 있게 설정해뒀다. 각자 자주쓰는 키를 단축키로 설정해두고 인텔리제이를 좀 더 편하게 사용하자 :)

2023년 혹은 2022년의 어느 날, 프로그래머스 컨퍼런스를 참여해서 강연을 듣고 정리한 내용들의 회고록

1. 연사 소개

2. 일반적인 커리어 성장

2-1. 커리어는 정글짐

• vs 사다리
• 꼭 위로 가지 않아도 된다
• 여러 가지 역할을 시도해 보는 것이 커리어에 좋다.
• 안 해 봤던 일을 해 보는 것도 좋다.
• 어떤 역할이 나한테 맞는지 체험 해보자.
• 요즘 전문성 & 안정성이란?
  • 변화를 두려워하지 않고, 나에게 필요한 지식이나 기술을 필요한 만큼 배울 수 있는 학습력 → 전문성을 쌓을 수 있다.

2-2. 결과를 내는 데 집중하기

• 성취하는 경험하기 → 자신감
• working backwards
  • 문제 정의의 중요성: 소통을 통해 맞는 결과부터 정의
    • 성공 실패는 어떻게 정의되나? 우선 순위는?
    • 의사 소통 능력의 중요성
  • 질문 많이 하고 잘 하기 (자기 검열 안 하기)
• Done is better than perfect
  • 완벽주의 보다는 완료주의
  • 가능하면 literation 기반으로 일 하기

2-3. 나의 성장을 저해하는 요소

• 나이 혹은 남과의 비교
• 나에 대한 고정 관념 (vs. growth mindset)
• 과거의 상처
  • 나이와 현명함의 관계
  • 나를 돌아보고 상처가 있다면 치유하자.

2-4. 인격적인 성숙

• Hire Character, Tran Skill - Peter Schutz
  • 기술은 가르칠 수 있으나, 성품은 가르칠 수 없다.
• 긍정적인 태도
  • 팀웍 vs Brilliant Jerk
• 주기적으로 회고하는 자세
• 실수를 인정하고, 모르는 것을 모른다고 하는 여유

2-5. 시작과 꾸준함의 중요성 - 복리가 있는 일 하기

• 아무 일도 안 하면 아무런 일도 발생하지 않음
  • 시작이 반
• Practice Makes Perfact
  • 꾸준히 매일 하다 보면 발전하는 게 조금 더 오랜 시간을 두고 보임
• 복리가 있는 일들
  • 운동
  • 배움/학습 (호기심)
  • 네트워킹 (사람 만나기)
  • 책 읽기/글쓰기

2-6. 네트워크의 중요성

• 사람들을 만날 때 호기심 갖기
  • 첫 인상에 사로잡히지 않기
  • 질문의 중요성
• 좋은 사람들과 일하는 환경의 중요성
• 좋은 평판 유지하기
  • 팀플레이어, 공정한 사람, 긍정적인 사람 등
• 도움 요청하고 도움 받기

2-7. 커뮤니티의 힘

• 심플스텝스 (WE GROW TOGETHER)

  • 2017년 설립된 미국 이주 한인 여성 재취업 목적 비영리 단체

  • 다수의 재취업 성공 케이스들을 만들어 냄

    • 서포트 네트워크와 롤 모델의 중요성

      

- 실리콘 밸리에서 날아온 데이터 엔지니어링
    - 총 10기 370명

2-8. 자신의 강점과 약점을 이해하기

• 내 강점을 최대화하는 일을 찾기
• 단 내 강점이 약점이 되는 순간이 있는데 그걸 잘 인지하기
  • Peter’s principle: 사람들은 일반적으로 무능할 때까지 승진함 (혹은 성장함)
  • Comfort zone에서 나오기
    • 완벽한 사람
    • 실행을 아주 잘 하는 사람?
• 인지는 꼭 해야하지만 꼭 변화할 필요가 있을까?

2-9. 사기 증후군 극복하기

3. 개발자의 커리어 성장

3.1 기본기 확실히 하기

높은 성능과 안정성을 갖춘 현재 가장 많이 사용되고 있는 웹서버. Apache 같은 웹 서버와 비교하면 빠르고, 대규모 어플리케이션 처리에 적합하다는 장점이 있음.

Ngnix를 이해하기 위해 필요한 용어 4가지

1. 클라이언트

   • 클라이언트란 서비스를 이용하기 위해 네트워크를 통해 요청을 보내는 주체를 말함.
   • 예를 들어, 인터넷에서 웹페이지를 보기 위해 웹 브라우저를 실행하면 웹 브라우저가 클라이언트가 된다.
   • 웹 개발 영역에서 보통 클라이언트라 하면 크롬, 사파리, 익스플로러 등 웹 브라우저를 의미한다고 보면 됨.
     

2. 웹 서버

   • 웹 서버는 클라이언트의 요청에 따라 HTML, CSS, JS, 이미지 파일과 같은 정적 파일을 응답하여 제공하는 소프트웨어를 말함.
   • 웹 서버는 HTTP 프로토콜을 사용하여 클라이언트와 통신한다.
   • 대표적인 웹서버로는 Ngnix, Apache 등이 있음.
   • 이 외에도 Microsoft IIS, LIGHTTPD 등 다양한 웹서버가 존재함.
     

3. WAS (Web Application Server)

   • WAS는 클라이언트의 요청에 대해 동적인 처리를 담당하는 영역.
   • 웹 서버와 달리 어플리케이션 로직을 실행할 수 있도록 구성되어 있다.
   • 예를 들어 회원가입이나 로그인 등의 로직을 처리하는 영역이 WAS.
   • 또한 데이터베이스 연동, 트랜젝션 관리, 보안, 로깅 등의 기능도 제공한다.
   • 이를 통해 웹 어플리케이션의 안정성과 성능을 향상시키며, 개발자들은 어플리케이션 개발에 집중할 수 있다.
   • 대표적인 WAS로는 Tomcat, JBoss, WebLogic 등이 있음.
   • 웹 서버와 WAS는 역할의 차이가 있지만, 현업에서는 웹 서버로 퉁(?)쳐서 얘기하곤 한다.
   • Node.js는 웹 서버 또는 WAS로도 사용할 수 있다.
     

4. DB

   • DB는 조직이나 개인이 필요한 정보를 체계적으로 저장, 관리하고 검색할 수 있는 시스템이다.
   • DB는 일반적으로 다수의 사용자가 공유할 수 있으므로, 대규모 데이터의 저장과 검색을 처리할 수 있다.
   • 가장 많이 사용되는 DB 유형으로는 관계형(RDBMS), NoSQL 등이 있다.
     

일반적인 요청과 응답의 순서

-> 보통의 웹 서비스는 클라이언트 > 웹서버 > WAS > DB 순으로 요청 되고, DB > WAS > 웹 서버 > 클라이언트 순으로 응답이 된다.

웹 서버를 사용해야 하는 이유 ⁉️

1. WAS의 부담을 줄여주기 위함

   • WAS는 로그인, 회원가입, 개인정보 수정 등 동적 작업을 처리하는 것만으로도 작업량이 많음. 이에 HTML, CSS, JS, 이미지 등 정적인 파일을 클라이언트에게 전달하는 역할을 웹 서버에게 위임함으로써 WAS의 작업 부담을 줄일 수 있다.
     
     

2. 보안 기능 제공

   • 웹 서버는 보안 기능을 제공하여 웹 페이지에 대한 접근을 제어할 수 있다.
   • 예를 들어, 웹 서버는 SSL/TLS 프로토콜을 사용하여 데이터를 암호화하고, 엑세스 제어, 웹 방화벽 보안 기능을 제공하여 웹 사이트를 보호할 수 있음
     
     

3. 높은 성능 제공

   • 웹 서버는 대부분 비동기 처리 방식을 사용하여 높은 성능을 제공함.
   • 예를 들어 Ngnix, Apache 등의 웹 서버는 이벤트 기반, 멀티 프로세싱, 스레드 풀 등의 기술을 사용하여 수천대의 클라이언트 요청을 동시에 처리할 수 있다.
     
     

Ngnix를 사용하는 이유 ‼️

1. 높은 성능과 적은 메모리 사용

   • Ngnix는 비동기 I/O 처리 방식을 사용하여 높은 성능을 제공한다. 이를 통해 대규모 웹 사이트에서도 빠른 응답 시간을 보장할 수 있다.
   • 또한 Ngnix는 적은 메모리 사용량으로도 높은 성능을 제공한다. 이를 통해 운용 비용을 절감할 수 있다.
     
     

2. 리버스 프록시(Reverse Proxy) 사용이 가능함

   • 프록시(Proxy)의 사전 정의는 "대리"이다. 인터넷 접속을 할 때 보안상의 문제로 직접 통신을 주고 받을 수 없을 때, 그 사이의 중계기로서 대리로 통신을 수행하는 기능을 프록시라고 말한다. 이렇게 중계를 기능하게 하는 것을 프록시 서버 라고 부른다.

   • 프록시는 크게 포워드 프록시와 리버스 프록시로 구분한다.
     
     

     

   • 포워드 프록시

     • 클라이언트와 인터넷 그 사이에 있는 영역을 말한다.
     • 클라이언트가 어떠한 정보를 요청하면 포워드 프록시가 이를 대신 받아서 서버에게 전달한다. 이후 서버의 응답 또한 포워드 프록시가 대신 받아서 클라이언트에게 전달한다.
     • 포워드 프록시를 사용하면 클라이언트의 IP 주소가 웹 서버에 노출되지 않는다. 따라서, 클라이언트의 위치나 신원을 식별하는 것이 어려워지므로 보안이 강화된다.
     • 또한 접근 제어를 수행할 수 있다. 포워드 프록시를 사용하여 특정 IP 주소, 도메인 또는 URL에 대한 접근을 제한할 수 있다.
     • 미디어 스트리밍을 지원할 수 있다. 미디어 파일은 일반적으로 큰 용량을 가지고 있기 때문에, 웹 서버에서 직접 전송하는 것은 효율적이지 않다. 포워드 프록시를 사용하여 미디어 파일을 캐시하고, 클라이언트에게 빠르게 제공할 수 있다.
       
       

![](https://velog.velcdn.com/images/cher_blair/post/a940b0b2-ef68-4e4a-8a55-982b904275a3/image.png)

- 리버스 프록시
    - 인터넷과 백엔드 그 사이에 있는 서버 영역을 말한다.
    - 로드 밸런싱이 가능하다.
    - 캐싱 서버로도 이용이 가능하다. 예를 들어 클라이언트가 이미지를 요청했을 때 처음에는 서버에서 가져오지만 이후에는 동일한 요청이 있을 때 캐시 서버에서 가져와 클라이언트에게 전달해 준다. 이를 통해 사이트 접속 속도를 빠르게 유지할 수 있다.
    - 보안 효과가 있다. WAS가 데이터를 응답할 때는 기기의 명칭이나 주소 등 실제로는 민감한 정보들이 담겨져 있다. 이러한 정보들을 중간에서 숨겨 줌으로써 보안을 높일 수 있게 된다. <br><br>

3. SSL 지원
   • SSL(Secure Sockets Layer)은 웹 사이트와 사용자 간의 통신을 암호화하고 보안을 유지하는 데 사용되는 프로토콜이다. SSL은 HTTPS (HTTP Secure)로 알려진 보안 HTTP 프로토콜의 기반 기술이다.
   • HTTPS는 HTTP 프로토콜의 암호화 된 버전이다. SSL 프로토콜을 사용하여 웹 서버와 클라이언트 간 보안 연결을 설정하고, SSL 인증서를 사용하여 서버의 신원을 인증한다. 이를 통해 중간자 공격과 같은 보안 위협을 방지하고, 사용자의 개인 정보와 웹 사이트의 기밀 정보를 보호할 수 있다.
   • Ngnix는 HTTPS 인증서를 제공해 줄 수 있다.
     
     

4. 데이터 압축

   • 클라이언트가 보내는 요청이 Text일 경우 gzip을 사용하여 해당 데이터를 압축 시킬 수 있다.

5. 비동기 처리

   • Ngnix는 이벤트 루프 방식을 사용하여 높은 성능을 제공한다. 이를 통해 동시에 여러 요청이 들어왔을 때도 많은 트래픽을 동시에 처리할 수 있어 빠른 응답 시간을 보장한다.
     
     
     
     

     (이미지 출처: https://www.cloudflare.com/ko-kr/learning/cdn/glossary/reverse-proxy/)

Option ?

$("#tree").dynatree({
    title: "Dynatree", // Tree's name (only used for debug outpu)
    minExpandLevel: 1, // 1: root node is not collapsible
    imagePath: null, // Path to a folder containing icons. Defaults to 'skin/' subdirectory.
    children: null, // Init tree structure from this object array.
    initId: null, // Init tree structure from a <ul> element with this ID.
    initAjax: null, // Ajax options used to initialize the tree strucuture.
    autoFocus: true, // Set focus to first child, when expanding or lazy-loading.
    keyboard: true, // Support keyboard navigation.
    persist: false, // Persist expand-status to a cookie
    autoCollapse: false, // Automatically collapse all siblings, when a node is expanded.
    clickFolderMode: 3, // 1:activate, 2:expand, 3:activate and expand
    activeVisible: true, // Make sure, active nodes are visible (expanded).
    checkbox: false, // Show checkboxes.
    selectMode: 2, // 1:single, 2:multi, 3:multi-hier
    fx: null, // Animations, e.g. null or { height: "toggle", duration: 200 }
    noLink: false, // Use <span> instead of <a> tags for all nodes
    // Low level event handlers: onEvent(dtnode, event): return false, to stop default processing
    onClick: null, // null: generate focus, expand, activate, select events.
    onDblClick: null, // (No default actions.)
    onKeydown: null, // null: generate keyboard navigation (focus, expand, activate).
    onKeypress: null, // (No default actions.)
    onFocus: null, // null: set focus to node.
    onBlur: null, // null: remove focus from node.

    // Pre-event handlers onQueryEvent(flag, dtnode): return false, to stop processing
    onQueryActivate: null, // Callback(flag, dtnode) before a node is (de)activated.
    onQuerySelect: null, // Callback(flag, dtnode) before a node is (de)selected.
    onQueryExpand: null, // Callback(flag, dtnode) before a node is expanded/collpsed.

    // High level event handlers
    onPostInit: null, // Callback(isReloading, isError) when tree was (re)loaded.
    onActivate: null, // Callback(dtnode) when a node is activated.
    onDeactivate: null, // Callback(dtnode) when a node is deactivated.
    onSelect: null, // Callback(flag, dtnode) when a node is (de)selected.
    onExpand: null, // Callback(flag, dtnode) when a node is expanded/collapsed.
    onLazyRead: null, // Callback(dtnode) when a lazy node is expanded for the first time.
    onCustomRender: null, // Callback(dtnode) before a node is rendered. Return a HTML string to override.
    onCreate: null, // Callback(dtnode, nodeSpan) after a node was rendered for the first time.
    onRender: null, // Callback(dtnode, nodeSpan) after a node was rendered.
    postProcess: null, // Callback(data, dataType) before an Ajax result is passed to dynatree.

    // Drag'n'drop support
    dnd: {
        // Make tree nodes draggable:
        onDragStart: null, // Callback(sourceNode), return true, to enable dnd
        onDragStop: null, // Callback(sourceNode)
        // Make tree nodes accept draggables
        autoExpandMS: 1000, // Expand nodes after n milliseconds of hovering.
        preventVoidMoves: true, // Prevent dropping nodes 'before self', etc.
        revert: false, // true: slide helper back to source if drop is rejected
        onDragEnter: null, // Callback(targetNode, sourceNode, ui, draggable)
        onDragOver: null, // Callback(targetNode, sourceNode, hitMode)
        onDrop: null, // Callback(targetNode, sourceNode, hitMode, ui, draggable)
        onDragLeave: null // Callback(targetNode, sourceNode)
    },
    ajaxDefaults: { // Used by initAjax option
        cache: false, // false: Append random '_' argument to the request url to prevent caching.
        timeout: 0, // >0: Make sure we get an ajax error for invalid URLs
        dataType: "json" // Expect json format and pass json object to callbacks.
    },
    strings: {
        loading: "Loading…",
        loadError: "Load error!"
    },
    generateIds: false, // Generate id attributes like <span id='dynatree-id-KEY'>
    idPrefix: "dynatree-id-", // Used to generate node id's like <span id="dynatree-id-<key>">.
    keyPathSeparator: "/", // Used by node.getKeyPath() and tree.loadKeyPath().
    cookieId: "dynatree", // Choose a more unique name, to allow multiple trees.
    cookie: {
        expires: null // Days or Date; null: session cookie
    },
    // Class names used, when rendering the HTML markup.
    // Note:
    // These settings only apply on initialisation.
    // If only single entries are passed for options.classNames, all other
    // values are still set to default.
    classNames: {
        container: "dynatree-container",
        node: "dynatree-node",
        folder: "dynatree-folder",

        empty: "dynatree-empty",
        vline: "dynatree-vline",
        expander: "dynatree-expander",
        connector: "dynatree-connector",
        checkbox: "dynatree-checkbox",
        nodeIcon: "dynatree-icon",
        title: "dynatree-title",
        noConnector: "dynatree-no-connector",

        nodeError: "dynatree-statusnode-error",
        nodeWait: "dynatree-statusnode-wait",
        hidden: "dynatree-hidden",
        combinedExpanderPrefix: "dynatree-exp-",
        combinedIconPrefix: "dynatree-ico-",
        hasChildren: "dynatree-has-children",
        active: "dynatree-active",
        selected: "dynatree-selected",
        expanded: "dynatree-expanded",
        lazy: "dynatree-lazy",
        focused: "dynatree-focused",
        partsel: "dynatree-partsel",
        lastsib: "dynatree-lastsib"
    },
    debugLevel: 1 // 0:quiet, 1:normal, 2:debug
});

SiteMesh vs jsp include ?

SiteMesh 동작 방식

1. 위 그림에서 데코레이터에 전달되는 HTML 페이지는 <html>, <head>, <body> 등을 포함한 완전한 HTML 페이지이다. 이때 데코레이터에 전달되는 HTML 페이지는 레이아웃과 관련된 내용은 포함되지 않는다.
2. 데코레이터는 레이아웃 정보를 담고 있는 JSP 페이지로서, 앞서 생성한 HTML 페이지에 저장된 (<title> 등의) 메타 정보와 <body> 태그에 포함된 내용을 추출한 뒤, 레이아웃의 알맞은 위치에 추출한 내용을 삽입하여 최종 결과를 생성하게 된다.

PageFilter(servelet filter) ?

 <filter-mapping>
         <filter-name>sitemesh</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>

• 위 예시는 / 로 들어오는 모든 요청에 대해서 PageFilter를 적용한다고 설정 한 것
• PageFilter는 요청 URL과 매칭되는 데코레이터를 검색한 뒤, 데코레이터가 발견될 경우 결과 HTML에 매칭되는 데코레이터를 적용한다.
• 따라서, 데코레이터가 적용되어야 하는 URL의 경우 반드시 PageFilter에 매핑시켜주어야 함.

Decoratror ?

[run] -> [edit configurations...]

Dfile.encoding=UTF-8 추가

Project Structure 창에서 해당하는 웹 프로젝트(모듈)의 Web framework를 선택하고 [Add Application Server specific descriptor...]를 클릭

위와 같이 지정해준다. Version은 5.0만 있지만 상관 없다. [OK]를 클릭한다.

위와 같이 Tomcat Context Descriptor가 추가된 것을 볼 수 있다. [OK]를 클릭한다.

META-INF/context.xml 파일이 생성되었다. 여기에 DataSource 등의 필요한 설정을 추가해주면 된다.

👉🏻 백준 2751 문제 바로가기

❓ 병합 정렬?!

병합 정렬: 분할 정복 방식을 사용해 데이터를 분할하고, 분할한 집합을 정렬하며 합치는 알고리즘
평균적인 시간 복잡도는 O(nlogn).

❗️pseudo code

❗️pesudo code

count (정렬할 수 개수)
sortedArray (정렬할 배열)
tempArray (정렬 시 잠시 사용 할 임시 배열)

for (count 만큼 반복) {
    sortedArray 선언
}
병합 정렬 함수 수행
결괏값 출력

// 병합 정렬 수행
병합 정렬 (start, end) {
    start(시작점), end(종료점), middle(중간점)

    // 재귀 함수 형태로 구현
    병합 정렬 (start, middle)
    병합 정렬 (middle + 1, end)
    for (start ~ end) {
        tempArray 저장
    }

    // 두 그룹 병합 로직
    index1 (앞쪽 그룹 시작점)
    index2 (뒤쪽 그룹 시작점)
    while (index1 <= 중간점 && index2 <= 종료점) {
        양쪽 그룹 index가 가르키는 값을 비교한 후 더 작은 수를 선택해 배열에 저장하고,
        선택된 데이터의 index 값을 오른쪽으로 한 칸 이동하기
        반복문이 끝난 후 남아 있는 데이터 정리
    }
}

✨ solve

import java.io.*;

public class Main {
    public static int[] sortedArray, tempArray;
    public static long result;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int count = Integer.parseInt(br.readLine());
        sortedArray = new int[count + 1];
        tempArray = new int[count + 1];
        for (int i = 1; i <= count; i++) {
            sortedArray[i] = Integer.parseInt(br.readLine());
        }

        // 병합 정렬 수행
        mergeSort(1, count);
        for (int i = 1; i <= count; i++) {
            bw.write(sortedArray[i] + "\n");
        }
        bw.flush();
        bw.close();
    }

    private static void mergeSort(int start, int end) {
        if (end - start < 1) {
            return;
        }
        int middle = start + (end - start) / 2;

        // 재귀 함수 형태로 구현
        mergeSort(start, middle);
        mergeSort(middle + 1, end);
        for (int i = start; i <= end; i++) {
            tempArray[i] = sortedArray[i];
        }
        int k = start;
        int index1 = start;
        int index2 = middle + 1;

        // 두 그룹 병합
        while (index1 <= middle && index2 <= end) {
            if (tempArray[index1] > tempArray[index2]) {
                sortedArray[k] = tempArray[index2];
                k++;
                index2++;
            } else {
                sortedArray[k] = tempArray[index1];
                k++;
                index1++;
            }
        }
        while (index1 <= middle) {
            sortedArray[k] = tempArray[index1];
            k++;
            index1++;
        }
        while (index2 <= end) {
            sortedArray[k] = tempArray[index2];
            k++;
            index2++;
        }
    }
}

👉🏻 백준 11004 문제 바로가기

❓ 퀵 정렬?!

퀵 정렬: 기준값(pivot)을 선정해 해당 값보다 작은 데이터와 큰 데이터로 분류하는 것을 반복해 정렬하는 알고리즘.
기준값이 어떻게 선정되는지가 시간 복잡도에 많은 영향을 미치고, 평균적인 시간 복잡도는 O(nlogn).

• 퀵 정렬의 핵심 이론

    pivot을 중심으로 계속 데이터를 2개의 집합으로 나누면서 정렬하는 것이 퀵 정렬의 핵심이다.

• 퀵 정렬의 과정

  1. 데이터를 분할하는 pivot을 설정한다.
  2. pivot을 기준으로 아래의 과정을 거쳐 데이터를 2개의 집합으로 분리한다.
      1) start가 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 start를 오른쪽으로 1칸 이동한다.
      2) end가 가리키는 데이터가 pivot이 가리키는 데이터보다 크면 end를 왼쪽으로 1칸 이동한다.
      3) start가 가리키는 데이터가 pivot이 가리키는 데이터보다 크고, end가 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면,
         start, end가 가리키는 데이터는 swap하고 start는 오른쪽, end는 왼쪽으로 1칸씩 이동한다.
      4) start와 end가 만날때까지 1) ~ 3)을 반복한다.
      5) start와 end가 만나면 만난 지점에서 가리키는 데이터와 pivot이 가리키는 데이터를 비교하여 pivot이 가리키는 데이터가 크면
         만난 지점의 오른쪽에, 작으면 만난 지점의 왼쪽에 pivot이 가리키는 데이터를 삽입한다.
  3. 분리 집합에서 각각 다시 pivot을 선정한다.
  4. 분리 집합이 1개 이하가 될 때까지 과정 1 ~ 3을 반복한다.

❗️문제 분석하기

  - 퀵 정렬을 구현해 주어진 수를 오름차순으로 정렬한 뒤, k번째 수 출력
  - 퀵 정렬 알고리즘에서 K번쨰 수를 좀 더 빨리 구하기 위한 아이디어 고민
  - 퀵 정렬 알고리즘을 구현하려면 먼저 pivot을 지정해야 함
  - 어떤 값을 pivot으로 정하면 k번째 수를 더 빨리 구할 수 있을까?! 고민
  - pivot 정하는 방법
      ㄴ pivot == K: K번째 수를 찾은 것이므로 알고리즘을 종료한다.
      ㄴ pivot > K: pivot의 왼쪽 부분에 K가 있으므로 왼쪽(S ~ pivot -1)만 정렬을 수행한다.
      ㄴ pivot < K: pivot의 오른쪽 부분에 K가 있으므로 오른쪽(pivot + 1 ~ E)만 정렬을 수행한다.
  - 데이터가 대부분 정렬되어 있는 경우 앞쪽에 있는 수를 pivot으로 선택하면 불필요한 연산이 많아짐
  - 이 문제의 경우 배열의 중간 위치를 pivot으로 설정하고 접근

❗️pseudo code

  count (숫자의 개수)
  numK (K번째의 수)
  savedArray (숫자 데이터 저장 배열)
  for (count 만큼 반복( {
      savedArray 배열 저장하기
  }
  퀵 소트 실행
  K번째 데이터 출력

  * 별도 함수 구현
  퀵 소트 함수 (시작, 종료, K) {
      피벗 구하기 함수 (시작, 종료)
      if (피벗 == K) {
          종료
      } else if (K < 피벗) {
          퀵 소트 수행하기 (시작, 피벗 -1, K)
      } else {
          퀵 소트 수행하기 (피벗 + 1, 종료, K)
      }
  }
  피벗 구하기 함수 (시작, 종료) {
      데이터가 2개인 경우는 바로 비교하여 정렬
      middle (중앙 값)
      중앙 값을 시작 위치와 swap
      피벗을 시작 위치 값 savedArray[S]로 저장
      i (시작점), j (종료점)
      while (i <= j) {
          피벗보다 큰 수가 나올 때까지 i++
          피벗보다 작은 수가 나올 때까지 j--
          찾은 i와 j 데이터를 swap
      }
      피벗 데이터를 나눠진 두 그룹의 경계 index에 저장하기
      경계 index 리턴
  }

✨ solve

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int count = Integer.parseInt(st.nextToken());
        int numK = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(in.readLine());

        int[] savedArray = new int[count];
        for (int i = 0; i < count; i++) {
            savedArray[i] = Integer.parseInt(st.nextToken());
        }
        quickSort(savedArray, 0, count - 1, numK - 1);
        System.out.println(savedArray[numK - 1]);
    }

    private static void quickSort(int[] A, int S, int E, int K) {
        if (S < E) {
            int pivot = partition(A, S, E);
            if (pivot == K) {
                return;
            } else if (K < pivot) {
                quickSort(A, S, pivot - 1, K);
            } else {
                quickSort(A, pivot + 1, E, K);
            }
        }
    }

    private static int partition(int[] A, int S, int E) {
        if (S + 1 == E) {
            if (A[S] > A[E]) {
                swap(A, S, E);
                return E;
            }
        }
        int M = (S + E) / 2;
        swap(A, S, M); // 중앙 값을 1번째 요소로 이동
        int pivot = A[S];
        int i = S + 1, j = E;
        while (i <= j) {
            while (j > S + 1 && pivot < A[j]) {
                j--;
            }
            while (i <= E && pivot > A[i]) {
                i++;
            }
            if (i <= j) {
                swap(A, i++, j--);
            }
        }
        // 피벗 데이터를 나눠진 두 그룹의 경계 index에 저장하기
        A[S] = A[j];
        A[j] = pivot;
        return j;
    }

    private static void swap(int[] A, int i, int j) {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
}