-
Notifications
You must be signed in to change notification settings - Fork 0
ElasticSearch ‐ Analysis and Mapping
woojin edited this page Aug 1, 2026
·
5 revisions
- 텍스트 데이터를 효율적으로 검색할 수 있는 형태로 변환하는 과정을 가리킨다.
- 이 과정은 토큰화(tokenization), 필터링(filtering), 정규화(normalization) 등 여러 단계로 이루어진다.
- 목표는 텍스트를 색인하고 질의할 수 있는 term(토큰)으로 분해하는 것이다.
| 구성요소 | 역할 | 예시 |
|---|---|---|
| Character Filters | 토큰화 이전에 입력 텍스트를 전처리한다. 문자나 문자열을 제거하거나 치환한다 | HTML Stripping, Mapping, Pattern Replacement |
| Tokenizers | 텍스트를 개별 term으로 쪼갠다. 공백·구두점 등 어떤 기준으로 나눌지 정의한다 | Standard, Whitespace, Keyword Tokenizer |
| Token Filters | 토큰을 수정한다. 주로 정규화하거나(소문자 변환, 불용어 제거) 추가 변환을 적용한다 | Lowercase, Stop, Stemmer Token Filter |
- 순서가 정해져 있다 — Character Filters → Tokenizer → Token Filters.
- Character Filter는 문자 단위로 원문을 손보고, Tokenizer는 문자열을 토큰 배열로 바꾸며, Token Filter는 토큰 단위로 다듬는다. 다루는 대상이 단계마다 달라진다.
-
Character Filter 단계에서
<p>태그가 제거된다. 아직 하나의 문자열이다. - Tokenizer 단계에서 공백 기준으로 잘려 배열이 된다.
-
Token Filter 단계에서 각 토큰이 소문자로 바뀐다.
Elasticsearch→elasticsearch.
- 역색인은 Elasticsearch를 포함한 검색 엔진에서 빠르고 효율적인 전문 검색을 가능하게 하는 기본 자료구조다.
- term(단어 또는 토큰)을 문서 집합 내의 위치에 매핑하여, 특정 term을 포함한 문서를 빠르게 찾을 수 있게 한다.
- Terms — 색인되는 개별 단어나 토큰이다.
- Posting List — 각 term에 대해, 그 term이 등장하는 문서들의 목록이다(문서 내 위치 정보 포함).
- Documents — 색인되고 검색되는 텍스트 데이터의 집합이다.
- Document Parsing — 문서를 파싱해 개별 term으로 분해한다. 이때 analyzer(character filter, tokenizer, token filter)를 사용한다.
- Term Extraction — 문서에서 term을 추출하고, 각 term을 문서 식별자와 연결한다.
- Index Creation — 각 term마다 역색인에 항목을 만든다. 이 항목은 term과 posting list로 구성되며, posting list는 그 term을 포함한 모든 문서에 대한 참조를 담는다.
원본 문서
Document 1: "Elasticsearch is a search engine"
Document 2: "Search engines are powerful"
분석 후 토큰
Document 1: ["elasticsearch", "is", "a", "search", "engine"]
Document 2: ["search", "engines", "are", "powerful"]
- 방향이 뒤집혀 있다. 원래 데이터는
문서 → 단어들이지만, 역색인은단어 → 문서들이다. 그래서 "역"색인이다. -
search는 두 문서 모두에 나오므로 posting list가1, 2다.
- 효율성(Efficiency) — term과 그에 연결된 문서를 빠르게 조회할 수 있어 검색이 매우 빠르다.
- 확장성(Scalability) — 대량의 텍스트 데이터를 효율적으로 다룰 수 있다.
- 연관성(Relevance) — Boolean 질의, 구문(phrase) 질의, 근접(proximity) 검색 같은 고급 질의를 지원한다.
- Elasticsearch에서 mapping은 인덱스 안의 문서에 대한 스키마 정의다.
- 문서와 그 필드들이 어떻게 저장되고 색인되는지를 정의한다. 데이터 타입, analyzer, 그 밖에 데이터가 처리되고 질의되는 방식에 영향을 주는 설정들이 포함된다.
- 관계형 데이터베이스의 스키마에 해당하는 개념이다.
| 구성요소 | 의미 |
|---|---|
| Index | 유사한 특성을 가진 문서들의 모음 |
| Document | 인덱스에 저장되는 JSON 객체 |
| Field | 문서 안의 각 key-value 쌍 |
| Data Type | 필드가 담는 데이터의 종류를 지정 (text, keyword, date, integer 등) |
PUT /my_index
{
"mappings": {
"properties": {
"title": {
"type": "text",
"analyzer": "standard"
},
"tags": {
"type": "keyword"
},
"views": {
"type": "integer"
},
"published_at": {
"type": "date"
}
}
}
}-
"analyzer": "standard"— 해당 텍스트를 standard analyzer로 처리한다. -
"type": "keyword"— 이 필드는 정확한 값을 담는다. 분석 없이 필터링, 정렬, 집계에 적합하다. -
"type": "integer"— 정수 값이다. -
"type": "date"— Elasticsearch는 다양한 날짜 형식을 처리할 수 있다.
1. Core Data Type
- Text — 분석되는 텍스트다. 전문 검색에 적합하며, analyzer를 거쳐 term으로 만들어져 색인된다.
- Keyword — 하나의 term으로 통째로 다뤄야 할 정형 데이터에 쓴다.
-
Numeric — 숫자를 위한 여러 타입이다.
long,integer,short,byte등. - Date — 날짜와 시간에 쓴다.
- Boolean — true/false 값에 쓴다.
- Range — 숫자, 날짜, IP의 범위에 쓴다.
2. Complex Data Type
- Object — 문서 안의 중첩 객체에 쓴다.
{
"type": "object",
"properties": {
"name": { "type": "text" },
"age": { "type": "integer" }
}
}
- Nested — object의 특별한 형태로, 중첩된 객체들을 별개의 문서처럼 질의할 수 있게 한다.
{
"type": "nested",
"properties": {
"comments": {
"type": "nested",
"properties": {
"user": { "type": "keyword" },
"message": { "type": "text" },
"date": { "type": "date" }
}
}
}
}
3. Special Data Type
- Geo-Data — 지리 데이터에 쓴다.
- IP — IP 주소 저장에 쓴다.
- Completion — 자동완성이나 추천 기능에 쓴다.
- Token Count — 텍스트의 토큰 개수를 세는 데 쓴다.
- Percolator — 문서에 대해 실행할 쿼리를 저장하는 데 쓴다.
4. Binary Data Type
- Binary — Base64로 인코딩된 바이너리 데이터 저장에 쓴다.
- 문서를 색인할 때, 값이 내장 date 형식 중 하나를 따르면 Elasticsearch가 date 필드를 자동으로 감지한다.
- 다만 모호함을 피하려면 mapping에 date 형식을 명시적으로 정의하는 편이 낫다.
- Elasticsearch는 여러 date 형식을 지원한다.
- 기본 형식은
strict_date_optional_time||epoch_millis다.- 먼저
strict_date_optional_time형식으로 파싱을 시도한다. - 실패하면 epoch 기준 밀리초로 파싱을 시도한다.
- 먼저
- 인덱스의 mapping을 정의할 때
format파라미터로 date 필드의 형식을 지정할 수 있다. - 이렇게 하면 색인할 때와 질의할 때 Elasticsearch가 날짜를 올바르게 파싱한다.
POST /date_playground/_doc/1
{
"date_default": "2024-06-07T12:00:00Z",
"date_custom_format": "2024-06-07 12:00:00",
"date_iso8601": "2024-06-07T12:00:00.000Z",
"date_millis": 1717761600000
}- 네 필드의 표기법은 전부 다르지만, 가리키는 시각은 같다.
- Elasticsearch는 이들을 파싱해 내부적으로 epoch 밀리초(long) 하나로 저장한다.
- 그래서 형식이 달라도 범위 검색, 정렬, 집계가 동일하게 동작한다.
필드의 타입 외에, 그 필드를 어떻게 다룰지 지정하는 옵션들이다.
| 파라미터 | 역할 | 비고 |
|---|---|---|
| index | 필드를 검색 가능하게 할지 결정한다 | 끄면 공간 절약과 처리량 개선. 예: 시계열 데이터 |
| format | date 필드에서 허용할 날짜 형식을 지정한다 | |
| coerce | true면 입력 데이터를 필드 타입에 맞게 변환하려 시도한다 | 예: "100" → 100
|
| doc_values | 효율적인 정렬·집계·접근 패턴을 지원한다 | 끄면 공간 절약. 예: price, release_date
|
| norms | 스코어링에 사용된다 | 끄면 공간 절약. 예: tags
|
| null_value | null 값을 대체할 값을 지정한다 | 예: unknown
|
| copy_to | 지정한 필드들을 추가 필드에 함께 색인한다 | 예: first_name, last_name → full_name으로 검색 |
-
index— 이 필드로 검색할 일이 없다면 끈다. 역색인을 만들지 않으므로 저장 공간이 줄고 색인 처리량이 오른다. 시계열 데이터처럼 저장은 하되 검색 조건으로는 쓰지 않는 필드가 대상이다. -
format— date 필드에서 받아들일 날짜 형식을 지정한다. -
coerce— 타입이 어긋나는 입력을 자동 변환한다. 문자열"100"이 integer 필드로 들어오면 숫자100으로 바꿔 저장한다. -
doc_values— 정렬과 집계를 위한 구조다. 검색은 역색인(단어 → 문서)을 쓰지만, 정렬·집계는 반대 방향(문서 → 값)이 필요해 별도로 만든다.price,release_date처럼 정렬·집계에 쓰는 필드에 필요하고, 쓰지 않는 필드는 꺼서 공간을 아낀다. -
norms— 스코어링에 쓰이는 정보다.tags처럼 연관도 점수가 의미 없는 필드는 꺼도 된다. -
null_value— 값이 null일 때 대신 색인할 값을 지정한다. null은 원래 색인되지 않아 검색으로 찾을 수 없는데,unknown같은 대체값을 두면 "값 없음"도 검색 대상이 된다. -
copy_to— 여러 필드의 값을 하나의 추가 필드에 모아 색인한다. 데이터를 따로 저장하는 것이 아니라, 여러 필드를 하나인 것처럼 검색할 수 있게 해준다.first_name과last_name을full_name으로 모으면 이름 전체로 한 번에 검색된다.
- Elasticsearch에서는 인덱스에 매핑이 한번 만들어지면, 그 매핑의 특정 부분은 변경할 수 없다.
- 이 불변성(immutability) 은 주로 Elasticsearch가 데이터를 저장하고 색인하는 방식 때문에 생긴다.
- Lucene Index Structure — Lucene 세그먼트를 다시 써야 한다.
- Data Integrity and Consistency — 필드 타입을 string에서 integer로 바꾸는 것과 같은 문제다.
- Performance Considerations — 매핑 변경을 반영하려고 대량의 데이터를 재색인하는 일은 자원과 시간을 많이 소모한다.
- Field Type Incompatibility — 저장된 데이터를 다시 해석하는 것은 전체 데이터셋을 재색인하지 않고는 불가능하다. (예: integer → date)
- Index Structure Optimization — Elasticsearch는 최초 매핑을 기준으로 인덱스 구조를 최적화해 둔다.
-
새 인덱스를 만든다 — 원하는 매핑으로 새 인덱스를 정의하고, Reindex API로 기존 인덱스의 데이터를 새 인덱스로 옮긴다.
- 원하는 매핑으로 새 인덱스를 생성한다.
- Reindex API로 기존 데이터 이전한다.
- 애플리케이션이 새 인덱스를 바라보게 전환한다.
- Elasticsearch의 multi-fields mapping은 문서의 하나의 필드를 여러 방식으로 색인할 수 있게 해준다. 그래서 같은 데이터에 대해 서로 다른 종류의 검색을 수행할 수 있다.
- 같은 텍스트를 여러 방식으로 분석하고 싶을 때 유용하다. 예를 들어 하나의 필드를 text(전문 검색용)와 keyword(정확히 일치 검색용)로 동시에 색인하는 경우다.
- Versatility — 같은 데이터를 서로 다른 종류의 질의에 사용할 수 있다.
- Efficiency — 질의 목적별로 인덱스에 데이터를 중복 저장할 필요를 줄인다.
- Flexibility — 같은 필드에 서로 다른 analyzer를 적용할 수 있어, 검색 요구사항별로 최적화가 가능하다.
PUT /my_index
{
"mappings": {
"properties": {
"title": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword"
}
}
}
}
}
}-
title— analyzer를 거쳐 토큰으로 쪼개진다. 전문 검색용이다. -
title.keyword— 통째로 하나의 term이 된다. 정확히 일치하는 값 찾기, 정렬, 집계용이다.
- Elasticsearch의 index template은 새 인덱스가 생성될 때 자동으로 적용될 settings, mappings, aliases를 미리 정의해 두는 설정이다.
- 비슷한 구조를 따르는 인덱스들을 관리할 때 특히 유용하다. 로깅이나 메트릭 용도의 시계열 인덱스가 대표적이다.
-
Index Patterns — index template은 특정 패턴에 일치하는 인덱스에 적용된다. 예를 들어
log-*패턴은 이름이log-로 시작하는 모든 인덱스에 적용된다. - Priority — 템플릿은 우선순위 값을 가질 수 있고, 이 값이 여러 템플릿이 적용되는 순서를 결정한다. 우선순위가 높은 템플릿이 낮은 템플릿의 설정을 덮어쓴다.
- Settings — 샤드 개수, 레플리카 개수 등 인덱스 수준의 설정이다.
- Mappings — 인덱스 안 필드들의 데이터 타입과 설정을 정의한다.
- Aliases — 인덱스의 대체 이름이다. 질의와 인덱스 관리를 단순하게 해준다.
- Elasticsearch에는 내장 index template이 있고, 각각 우선순위 100을 가진다. 대상 패턴은 다음과 같다.
logs-*-*
metrics-*-*
synthetics-*-*
profiling-*
PUT _index_template/my_log_template
{
"index_patterns": ["log-*"],
"priority": 200,
"template": {
"settings": {
"number_of_shards": 1,
"number_of_replicas": 1
},
"mappings": {
"properties": {
"timestamp": { "type": "date" },
"level": { "type": "keyword" },
"message": { "type": "text" }
}
},
"aliases": {
"logs-all": {}
}
}
}log-2026-08-01 ─┐
log-2026-08-02 ─┼─ 이름이 log-* 이므로 생성 시 템플릿이 자동 적용
log-2026-08-03 ─┘ (settings + mappings + aliases)
- Elasticsearch의 dynamic mapping은 새 문서가 색인될 때 인덱스의 필드 매핑을 자동으로 만들고 갱신해 주는 기능이다.
- 덕분에 매핑을 미리 명시하지 않아도 새 필드를 즉석에서 처리할 수 있다. 들어올 데이터의 구조를 미리 알 수 없는 상황에서 특히 유용하다.
-
편리함의 대가가 있다. dynamic mapping은 첫 문서를 보고 타입을 결정하는데, 그 판단이 늘 옳지는 않다. 우편번호
"01234"가 숫자로 잡혀 앞의 0이 사라지거나, 버전 문자열"1.0"이 float으로 잡히는 식이다. 그리고 매핑 변경 문서에서 본 대로 한번 굳은 타입은 재색인 없이 바꿀 수 없다. - 그래서 운영 인덱스는 매핑을 명시하는 편이 낫다. 구조를 아는 데이터라면 직접 정의하고, 매일 새 인덱스가 생기는 시계열이라면 index template으로 매핑을 미리 걸어 둔다. dynamic mapping은 데이터 구조를 아직 모르는 탐색 단계나 로그 수집처럼 필드가 계속 늘어나는 경우에 쓴다.
-
Strings — 값이 텍스트로 보이면
text타입에keyword하위 필드를 함께 붙여 매핑한다. -
Numbers — 감지된 형식에 따라
long,double등으로 매핑한다. -
Floating point —
float으로 매핑한다. -
Dates — 날짜처럼 보이는 문자열은
date로 매핑한다. -
Booleans — true/false처럼 보이는 값은
boolean으로 매핑한다. -
Object —
object로 매핑한다.
- Elasticsearch에서 매핑의
dynamic파라미터는 매핑에 명시적으로 정의되지 않은 필드를 어떻게 처리할지 정한다.
-
true— (기본값) 새 필드를 만나면 자동으로 매핑에 추가한다. -
false— 매핑에 명시되지 않은 새 필드를 무시한다. 이 필드들은 색인되지도, 저장되지도 않는다. -
strict— 매핑에 정의되지 않은 필드가 담긴 문서를 거부하고 에러를 반환한다.
- Elasticsearch의 dynamic template은 동적으로 추가되는 필드에 대해 직접 규칙을 정의할 수 있게 해준다.
-
dynamic_templates는 필드의 이름, 타입, 그 밖의 속성을 기준으로 특정 필드에 대해 더 세밀한 규칙을 정의하게 해준다. - Flexibility — 필드가 동적으로 추가될 때 어떻게 색인되고 분석될지를 타입별로 지정할 수 있다.
- Control — 필드명이나 데이터 타입 같은 패턴·조건에 따라 특정 매핑을 적용할 수 있다.
- Efficiency — 모든 필드를 미리 정의하지 않고도 analyzer나 색인 옵션 같은 설정을 자동으로 적용할 수 있다.
PUT /my_index
{
"mappings": {
"dynamic_templates": [
{
"template_name": {
"match": "pattern",
"match_mapping_type": "type",
"mapping": {
"type": "desired_type",
"other_options": "..."
}
}
}
]
}
}| 항목 | 역할 |
|---|---|
template_name |
템플릿 이름 |
match |
필드명 패턴으로 대상을 고른다 |
match_mapping_type |
동적으로 감지된 타입으로 대상을 고른다 |
mapping |
조건에 맞은 필드에 적용할 매핑 |
-
dynamic_templates는 배열이다. 여러 규칙을 순서대로 나열하고, 먼저 일치하는 규칙이 적용된다.
- stemming은 자연어 처리(NLP)와 정보 검색에서 단어를 어간(base or root) 형태로 줄이는 과정이다.
- 목적은 한 단어의 여러 형태를 하나로 묶어 단일 항목으로 분석하는 것이다.
Original Words : "running", "runner", "ran", "runs"
Stemmed Form : "run"
Stemming Algorithms
- Porter Stemmer — 가장 널리 쓰이는 stemming 알고리즘 중 하나다. 일련의 규칙을 적용해 단어를 어근 형태로 변환한다.
- Snowball Stemmer — Porter Stemmer의 더 발전되고 설정 가능한 버전이다.
- stop words는 검색 엔진이나 NLP 작업에서 처리 전에 제거되는 흔한 단어들이다.
- 이 단어들은 대개 매우 흔하고 고유한 의미를 거의 담지 않으므로, 제외하면 인덱스 크기를 줄이고 검색 성능을 높일 수 있다.
Sentence : "The quick brown fox jumps over the lazy dog."
After Removing Stop Words : "quick brown fox jumps over lazy dog"
-
standard — Unicode 텍스트 분할 규칙에 따라 텍스트를 단어로 쪼갠다.
- Tokenizer:
standard - Token Filters:
lowercase, stop 지원
- Tokenizer:
-
simple — 글자가 아닌 문자를 기준으로 나누고 토큰을 소문자로 만든다.
- Tokenizer:
lowercase
- Tokenizer:
-
whitespace — 공백(스페이스, 탭 등)을 기준으로 텍스트를 토큰으로 나눈다.
- Tokenizer:
whitespace
- Tokenizer:
-
stop — simple analyzer와 비슷하되 stopword 필터링이 추가된다.
- Tokenizer:
whitespace
- Tokenizer:
-
keyword — 텍스트를 토큰화하지 않는다. 입력 전체를 하나의 토큰으로 다룬다. 정확히 일치하는 검색에 주로 쓴다.
- Tokenizer:
keyword
- Tokenizer:
-
pattern — 정규식 패턴을 기준으로 텍스트를 나눈다.
- Tokenizer:
pattern
- Tokenizer:
- 더 많은 정보: https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-analyzers.html
- Java - Class
- Java - Java Memory
- Java ‐ Solving Concurrency Issues with Synchronized
- Java - synchronized
- Java ‐ Instance Variable & Local Variable vs final
- Java ‐ Object
- Java ‐ Immutable Object
- Java ‐ String
- Java ‐ Wrapper Class
- Java ‐ ENUM
- Java ‐ Nested Class & Inner Class & Local Class & Anonymous Class
- Java ‐ Generic
- Java ‐ ArrayList
- Java ‐ LinkedList
- Java ‐ List
- Java ‐ Set
- Java ‐ Hash
- Java ‐ HashSet
- Java ‐ Map & Stack & Queue
- Java ‐ Iterate & Sort
- Java - Process & Thread
- Java - Thread Creation & Execution
- Java - Thread Control & LifeCycle
- Java - Memory Visibility
- Java - Advanced Synchronization
- Java - Producer/Consumer Problem
- Java - Synchronization & Atomic Operation
- Java - Concurrent Collection
- Java - Thread Pool & Executor Framework
- Java - Character Encoding
- Java - I/O
- Java - File & Files
- Java - Reflection
- Java - Annotation
- Java - Lambda
- Java - Functional Interface
- Java - Lambda vs Anonymous Class
- Java - Method Reference
- Java - Stream API
- Java - Optional
- Java - Default Method
- Java - Parallel Stream
- Java - Functional Programming
- Java - JVM & GC & SOLID
- Java - Data Storage and Memory Allocation: Primitive vs. Reference
- Java ‐ Static Keyword: Efficient Resource Management at the Class Level
- Java ‐ OOP
- Java ‐ Collection Framework Selection Standard
- Java ‐ Multi Threading & Concurrent Programming
- Java ‐ Exception Handling & Advanced Java
- Java ‐ Java 8+
- Java ‐ Java Application Performance Tuning
- Java - CAS
- Java - Virtual Thread
- Java - Benchmark
- Kotlin - Variables, Types, and Operators in Kotlin
- Kotlin - Control Flow in Kotlin
- Kotlin - Object-Oriented Programming in Kotlin
- Kotlin - Functional Programming in Kotlin
- Kotlin - Key Features of Kotlin
- Kotlin - Generics in Kotlin
- Kotlin - Lazy Initialization and Delegation in Kotlin
- Kotlin - Advanced Functional Programming in Kotlin
- Kotlin - Operator Overloading and Kotlin DSL
- Kotlin - Annotations and Reflection in Kotlin
- Kotlin - Miscellaneous Topics in Kotlin
- Coroutine - Limitations of Thread-Based Work & the Emergence of Coroutines
- Coroutine - runBlocking
- Coroutine - CoroutineDispatcher
- Coroutine - Controlling Coroutines with Job
- Coroutine - Receiving Results from Coroutines
- Coroutine - Coroutine Context
- Coroutine - Structured Concurrency
- Coroutine - Exception Handling
- Coroutine - Suspended Functions
- Coroutine - Understanding Coroutines
- Coroutine - Advanced Coroutines
- Coroutine - Coroutine Testing
- Spring - OOP & Spring
- Spring - Spring Container & Spring Bean
- Spring - Singleton Container
- Spring - Dependency Injection
- Spring - Bean LifeCycle Callback
- Spring - Bean Scope
- Spring ‐ Web Server, Web Application server
- Spring ‐ Servlet
- Spring ‐ Servlet & JSP & MVC
- Spring ‐ MVC Framework
- Spring ‐ Spring MVC
- Spring - Thymeleaf
- Spring - Message & Internationalization
- Spring - Validation
- Spring - Bean Validation
- Spring - Cookie & Session
- Spring - Filter & Interceptor
- Spring - API Exception Handling
- Spring - Spring Type Converter
- Spring - File Upload
- Spring - Connection Pool & DataSource
- Spring - Transaction
- Spring ‐ Spring Exception Abstraction
- Spring - Database Access
- Spring ‐ Spring Transaction
- Spring ‐ Spring Transaction Propagation
- Spring ‐ Thread Local
- Spring ‐ Template Method Pattern & Callback Pattern
- Spring ‐ Dynamic Proxy
- Spring ‐ Spring Proxy
- Spring ‐ Bean Processor
- Spring ‐ @Aspect AOP
- Spring ‐ Spring AOP
- Spring ‐ Spring AOP Application
- Spring - MyBatis
- Spring ‐ URL Encoding
- Spring - Cache Annotation
- Spring - Retry
- Spring Security - Initialization
- Spring Security - Authentication Process
- Spring Security - Authentication Architecture
- Spring Security - Authentication Status Persistence Processing Mechanism
- Spring Security - Session Management
- Spring Security - Exception Handling
- Spring Security - Mechanisms for responding to Malicious Attacks
- Spring Security - Authorization Process
- Spring Security - Authorization Architecture
- Spring Security - Multiple Security Settings
- Spring Security - Redis Redundancy Settings
- Spring Security - Event
- Spring Security - Integration
- Spring Security - OAuth 2.0
- Spring Security - OAuth 2.0 Authorization Type
- Spring Security - Open ID Connect
- Spring Security - OAuth 2.0 Client
- Spring Security - OAuth 2.0 Client Fundamentals
- Spring Security - OAuth 2.0 oauth2Login
- Spring Security - OAuth 2.0 oauth2Client
- Spring Security - OAuth 2.0 Resource Server
- Spring Security - OAuth 2.0 Resource Server API
- Spring Security - OAuth 2.0 Verification
- [🔖Spring Security - OAuth 2.0 MAC & RSA Token Verification]
- Spring Security - OAuth 2.0 Resource Server Permission Implementation
- Spring Security - OAuth 2.0 opaque()
- Spring Security - Integrating OAuth 2.0 Client and Resource Server
- Spring Security - Authorization Server
- Spring Security - Authorization Server Main Domain Class
- Spring Security - Authorization Server Endpoint Protocol
- Spring Batch - Scheduler vs Batch
- Spring Batch - Batch Concept
- Spring Batch - Batch Domain
- Spring Batch - Job
- Spring Batch - Step
- Spring Batch - Flow
- Spring Batch - Chunk Process
- Spring Batch - ItemReader
- Spring Batch - ItemWriter
- Spring Batch - ItemProcessor
- Spring Batch - Retry & Error Handling
- Spring Batch - Multi Threads Processing
- [Spring Batch - Batch Event Listener]
- [Spring Batch - Batch Test]
- [Spring Batch - File Processing]
- [Spring Batch - Read and Write Operations in Relational Databases and NoSQL]
- [Spring Batch - FaultTolerant & ItemStream]
- [Spring Batch - Partitioning]
- Spring Batch ‐ Tasklet vs Chunk
- [Spring Batch - Class 2]
- [Spring Batch - Class 3]
- [Spring Batch - Class 4]
- [Spring Batch - Class 5]
- [Spring Batch - Class 6]
- [Spring Batch - Class 7]
- Database - Database Introduction
- Database - Search & Sort
- Database - Data Processing
- Database - Aggregation & Grouping
- Database - Inner Join
- Database - Outer Join & Etc Join
- Database - Sub Query
- Database - UNION
- Database - CASE
- Database - Index
- Database - Data Integrity
- Database - Transaction
- Database - Why Database Design Matters
- Database - Concept Modeling
- Database - Logical Data Modeling
- Database - Identifying Relationship & Non-Identifying Relationship
- Database - Normalization
- Database - Physical Data Modeling
- Database - Common Code Design
- Database - Hierarchical Structure Design
- Database - Data Change History Design
- Database - SOFT DELETE
- Database - Statistics Table Design
- Database - Inheritance Relationship Design
- Database - Entity-Attribute-Value (EAV) Model
- Database - JSON Schema Design
- Database - Database Performance and MySQL Architecture
- Database - Execution Plans 1 - Mastering EXPLAIN
- Database - Execution Plans 2 - Mastering ANALYZE
- Database - Diagnosing Full Table Scans and Composite Index Basics
- Database ‐ Index Internal Structures 1 ‐ B-Tree & B+Tree
- Database - Index Internal Structures 2 - Clustered and Secondary Indexes
- Database - Diagnosing Using filesort and Early Termination
- Database - ICP, Covering, and Skip Scans
- Database - Merge, MRR, New Features, Hints, and Operations
- 🔖Database - The Optimizer and Histograms
- Database - Join Optimization
- Database - Optimizing Sort, Pagination, and Grouping
- Database - Streaming Aggregation and Pre-aggregated Tables
- MySQL ‐ Solving Concurrency Problems using Database-Level Locking
- MySQL - Multi Column Index
- MySQL - Covering Index & RDB vs ElasticSearch Diff
- MySQL - ORDER BY
- MySQL - INSERT
- MySQL - AUTO_INCREMENT_LOCK
- MySQL - Index Dive Using In Query
- MySQL - Why don't use prefix index in default
- MySQL - MySQL LockType
- MySQL - DeadLock Case
- MySQL - NoOffset For Query Tuning
- MySQL ‐ Skip Locked for Session
- MySQL - Checking DB Metrics with SQL Queries
- MySQL - Data Modeling for Practical Service Development
- MySQL - Basic CRUD in MySQL
- MySQL ‐ MySQL Internal Architecture and Storage Engines
- MySQL - MySQL Horizontal Scaling
- MySQL ‐ Operational‐Level System Design
- MySQL - MySQL Fundamentals
- MySQL - Why You Should Use MySQL: JOIN
- MySQL - Must-Know SQL Anti-Patterns
- MySQL - Learning Data Modeling Through Practical Examples
- MySQL - Foreign Key & Strategic Patterns
- MySQL - Advanced Topics in MySQL
- Redis ‐ Redis
- Redis ‐ Redis Manual
- Redis ‐ Redis Cache Strategy
- Redis ‐ Redis Master-Slave
- Redis - Redis Cluster Mode
- Redis - Redis Cluster Example
- Redis - Redis Data Structure
- Redis - Redis Server
- Redis - Reduce DB write load using Redis
- Redis - Solving Concurrency Issues (1)
- Redis ‐ Solving Concurrency Issues (2)
- Redis - Solving Concurrency Issues (3)
- Redis - Implementing Popular Searches
- Redis - API Rate Limiting
- Redis - Geospatial
- Redis - DAU Counting Application
- Redis - Session Management Application
- Redis - Redis Transaction ACID
- Redis - Redis Data Persistence
- Redis - Redis Keys Management
- Redis - Decoupling microservices with Redis Pub/Sub
- Redis - Redis Pipelining & RTT(Round Trip Time)
- Redis - Redis Streams
- Redis - Hash Slot Rebalancing
- JPA - Java Persistence API
- JPA - Entity Mapping & PK Strategy
- JPA ‐ JPA Association Mapping
- JPA - Proxy Association
- JPA - Value Type
- JPA - Dirty Checking vs. Merge: Understanding the Difference in JPA
- JPA - Cascading and Orphan Removal in JPA
- JPA - Introduction to Object-Oriented Query Languages in JPA
- JPA - Spring Data JPA
- JPA ‐ Solving Concurrency Issues with Pessimistic Locking
- JPA ‐ Solving Concurrency Issues with Optimistic Locking
- JPA - Lazy Loading and Performance Optimization in JPA
- JPA - ManyToOne Important Things
- JPA - OneToMany Important Things
- JPA - OSIV
- MicroService Architecture - Service Communications Patterns(RESTful API)
- MicroService Architecture - Service Communications Patterns(GraphQL)
- MicroService Architecture - Service Communications Patterns(gRPC)
- MicroService Architecture - API Gateway Patterns
- MicroService Architecture - Asynchronous Communications Patterns
- MicroService Architecture - Data Management Patterns
- MicroService Architecture - CQRS Patterns
- MicroService Architecture - Distributed Transactions
- [MicroService Architecture - Event-Driven Architecture]
- [MicroService Architecture - Resilience & Observability and Monitoring]
- [MicroService Architecture - Security Patterns]
- [MicroService Architecture - Testing Strategies]
- [MicroService Architecture - Scalability & Caching Patterns]
- [MicroService Architecture - Deployment Patterns]
- [MicroService Architecture - Serverless Architecture]
- [MicroService Architecture - GraphQL]
- [MicroService Architecture - Evolution of Distributed Systems and Their Drawbacks]
- [MicroService Architecture - Protocol Buffers]
- [MicroService Architecture - gRPC Communication Patterns]
- [MicroService Architecture - gRPC Optimization Strategies and Implementation]
- MicroService Architecture - 2PC
- MicroService Architecture - TCC
- MicroService Architecture - SAGA
- Apache Kafka - Kafka Introduction
- Apache Kafka - Kafka CLI
- Apache Kafka - Kafka Producer Application
- Apache Kafka - Kafka Consumer Application
- Apache Kafka - Idempotent Producer & Transactional Producer & Transactional Consumer
- Apache Kafka - Kafka Streams
- Apache Kafka - Kafka Connect
- Apache Kafka - Kafka Topic/Producer/Consumer
- Apache Kafka - Producer Mechanism
- Apache Kafka - Consumer Mechanism
- Apache Kafka - Multi Node Kafka Cluster
- Apache Kafka - Producer & Consumer Serialization/DeSerialization
- Apache Kafka - Topic Segment Management
- Apache Kafka - KSQLDB Stream
- Apache Kafka - KSQLDB Table
- Apache Kafka - KSQLDB Application
- Apache Kafka - Group by & Mview
- [Apache Kafka - Join]
- [Apache Kafka - Time & Windows]
- [Apache Kafka - Connecting KSQLDB to Kafka Connect]
- [Apache Kafka - Kafka Connect]
- [Apache Kafka - JDBC Source Connector]
- [Apache Kafka - JDBC Sink Connector]
- [Apache Kafka - Debezium MySQL CDC Source Connector]
- [Apache Kafka - Schema Registry]
- Apache Kafka - Differences Between RocksDB and In-Memory KeyValueStore in GlobalKTable
- Apache Kafka - Kafka Streams
- [Apache Kafka - Kafka Connect]
- [Apache Kafka - Idempotent Producers and Transactional Producers & Consumers]
- [Apache Kafka - CDC(Change Data Capture)]
- [Apache Flink - Apache Flink Architecture]
- [Apache Flink - Stream Processing]
- [Apache Flink - Data Stream API & Window]
- [Apache Flink - State Management]
- HTTP - Internet Network
- HTTP - URI & Browser Request Flow
- HTTP - HTTP Basic
- HTTP - HTTP Method
- HTTP - HTTP Method Application
- HTTP - HTTP Status Code
- HTTP ‐ HTTP Default Header
- HTTP - HTTP Cache & Condition Request
- AWS - AWS CDK(Cloud Development Kit)
- AWS - Signed URL
- AWS - PreSigned URL
- AWS - Cognito
- AWS - Signed URL Logic
- Docker - Docker
- Docker ‐ Docker CLI
- Docker ‐ Docker Volume
- Docker - Dockerfile Image
- Docker ‐ Docker Compose Container Management
- Docker ‐ Deploy(feat. AWS ECR)
- Docker - Cloud Native Technology
- Docker - Docker Essentials(1)
- Docker - Docker Essentials(2)
- Docker - Docker Network and Storage
- Docker - Building and Managing Containerized Application
- Docker - Container Orchestration
- Docker - Docker Security
- Docker - Logging and Monitoring
- Docker - Advanced Docker Usage
- Docker - Container-to-Container Communication
- [Docker - Docker Image Layer를 활용한 Cache 패턴과 Dangling Image]
- [Docker - Dockerfile 최적화를 위한 빌드 캐싱 및 멀티 스테이지 빌드 패턴]
- [Docker - GitHub Container Registry(GHCR)]
- [Docker - Docker Network 3가지]
- Kubernetes - Probe
- Kubernetes - ConfigMap & Secret
- Kubernetes - PV/PVC & Deployment & Service & HPA
- Kubernetes - Helm & Kustomize
- Kubernetes - Pod 1
- [Kubernetes - Pod 2]
- Kubernetes - Controller 1
- [Kubernetes - Controller 2]
- [Kubernetes - Object]
- [Kubernetes - Ingress & Nginx Application]
- [Kubernetes - Node Scheduling]
- [Kubernetes - Monitoring]
- [Kubernetes - Logging]
- Kubernetes - Deployment using Amazon EKS
- Jenkins - Jenkins Fundamentals & Environment Setup
- Jenkins - Jenkins Jobs: Freestyle & Pipeline
- Jenkins - Jenkins Pipeline Project
- Jenkins - Implementing Continuous Integration(CI) with Jenkins
- Nginx ‐ Nginx Introduction
- Nginx ‐ Nginx Supplementary Summary
- Nginx ‐ Deploying Domain with Nginx
- Nginx ‐ Implementing HTTPS with Nginx
- Nginx ‐ Backend Deployment via Nginx Reverse Proxy
- Nginx ‐ Load Balancing with Nginx
- Nginx - Core Concept
- [Nginx - Advanced Concept]
- [Nginx - Advanced Reverse Proxy]
- Monitoring - Log Level & Filter
- Monitoring - Log Collection with ELK Stack
- Monitoring - Log Monitoring with Kibana
- Monitoring - Server Monitoring with Prometheus and Grafana with Discord Alerts
- Test - Load Testing Fundamentals
- Test - Identifying Bottlenecks with Load Testing
- [Test - Resolving Bottlenecks and Improving Performance]
- Test - JUnit5
- Test - Mockito
- Test - TestContainers
- Test - JMeter
- Test - Chaos Monkey
- Test - ArchUnit
- Test - Appendix: Tips for Better Testing
- [gRPC - Writing .proto Files with Protocol Buffers]
- [gRPC - Various Communication Patterns in gRPC]
- [gRPC - gRPC Optimization Techniques and Advanced Features]
- TDD - Introduction to TDD
- TDD - Iterating with TDD
- TDD - Managing System Data
- TDD - Handling Unexpected Test Failures
- TDD - Abstraction & Reusability
- TDD - Building a Testing DSL
- TDD - Managing Test Context
- TDD - Driving Input Code with Output Tests
- TDD - Pagination Test
- [PostgreSQL - Docker만을 사용하는 경량화된 환경 구성 방법]
- [PostgreSQL - PostgreSQL에서 제공하는 데이터 타입]
- [PostgreSQL - PostgreSQI의 JSONB, 역인덱싱과 활용 방법]
- [PostgreSQL - 데이터베이스 성능을 위한 최적화 패턴 및 전략]
- [PostgreSQL - 트랜잭션과 ACID, Isolation 수준별 차이]
- [PostgreSQL - Database Lock 교착상태와 읽기/쓰기 성능을 보장하는 MVCC 모델]
- [PostgreSQL - pgvector와 벡터 저장, 유사도 검색 패턴 개념]
- [PostgreSQL - 벡터 인덱스 최적화와 벡터 검색과 전문 검색 결합 패턴]
- [PostgreSQL - PostgreSQL 플러그인]
- [PostgreSQL - PostGIS - 공간 쿼리와 GIST 인덱스, 지리 타입과 공간 쿼리를 위한 타입과 기본 함수]
- [PostgreSQL - pg_search - 검색 엔진 없이 텍스트 검색 구현과 주의사항]
- [PostgreSQL - 단일 인스턴스 한계를 극복하는 분산 패턴과 스케줄링, 분산 환경 구축 방법]
- [PostgreSQL - Citus - 분산 테이블과 분산 쿼리를 위한 Extension과 데이터 분산 처리]
- [PostgreSQL - pg_cron - PostgreSQL로 구성하는 CronJob]
- [PostgreSQL - 스케줄러 + 분산 처리를 동시에 도입하는 주기적 집계 쿼리 패턴]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Kafka + Debezium을 활용한 CDC 패턴 설계]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Temporal을 활용한 워크플로우 패턴]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Docker와 경량 이미지를 활용한 환경 구축 방법]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Kafka에서의 메시지 Delivery Guarantee]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - 실시간 동기화의 핵심 CDC]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - MySQL Binary Log 기반의 CDC]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Binary Log 기반의 CDC 구현 플랫폼 Debezium이란?]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Debezium Architecture]
- [Workflow-Driven Techniques for Large-Scale Traffic Processing - Debezium Architecture Best Practice와 주의사항]
- Reactive Programming - Everything About Reactive Programming & Core Concepts of Reactive Programming
- Reactive Programming - Mastering Reactor Operators in WebFlux & A Deep Dive into WebFlux Operators
- Reactive Programming - Best Practices and Optional Patterns in WebFlux & Key Practical Patterns for WebFlux Development
- Reactive Programming - Practical WebFlux Patterns with Spring Boot & Building Applications with Spring Boot and WebFlux
- ElasticSearch - Elasticsearch Core Concepts
- ElasticSearch - Basic Search Features & Architecture
- ElasticSearch - Korean Optimized Search
- ElasticSearch - Defining Data Types: Understanding Mappings
- ElasticSearch - Commonly Used Search APIs
- ElasticSearch - Managing Documents (1)
- ElasticSearch - Managing Documents (2)
- ElasticSearch - Analysis and Mapping
- ElasticSearch - All About Search
- ElasticSearch - Query Joins
- ElasticSearch - Processing Query Results
- ElasticSearch - Aggregations
- ElasticSearch - Tips for Improving Search Results
- [ElasticSearch - Elasticsearch Overview]
- [ElasticSearch - Elasticsearch Internals]
- [ElasticSearch - Monitoring]
- [ElasticSearch - Troubleshooting]
- Design Pattern - Strategy
- Design Pattern - Factory Method
- Design Pattern - Abstract Factory
- Design Pattern - Singleton
- Design Pattern - Observer
- Design Pattern - Publisher - Subscriber
- Design Pattern - Decorator
- Design Pattern - Adapter
- Design Pattern - Builder
- Design Pattern - Template Method
- Design Pattern - Facade
- Design Pattern - Proxy
- Design Pattern - Command
- Design Pattern - Chain of Responsibility
- Design Pattern - State
- Design Pattern - Composite
- [Clean Spring - Domain-Driven Development]
- [Clean Spring - Domain-Driven Development with Design Patterns]
- [Clean Spring - Developing Membership Application with Hexagonal Architecture]
- [Clean Spring - JPA and Domain Model Patterns]
- [Clean Spring - Designing a Consistent Domain Model with Aggregates]
- [Clean Spring - Web API Adapter]
- [Clean Spring - Hexagonal Architecture: Ports]
- [Clean Spring - Hexagonal Architecture: Application Components]
- [Clean Spring - Test Improvement & Architecture Validation]
- [Clean Spring - Developing Application Components]
- (Effective Java Item 1) Java ‐ 생성자 대신 정적 팩토리 메서드를 고려하라
- (Effective Java Item 2) Java - 생성자에 매개변수가 많다면 빌더를 고려하라
- (Effective Java Item 3) Java - private 생성자나 열거 타입으로 싱글턴임을 보증하라
- (Effective Java Item 4) Java - 인스턴스화를 막으려거든 private 생성자를 사용하라
- (Effective Java Item 5) Java - 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
- (Effective Java Item 6) Java ‐ 불필요한 객체 생성을 피하라
- (Effective Java Item 7) Java - 다 쓴 객체 참조를 해제하라
- (Effective Java Item 8) Java - finalizer와 cleaner 사용을 피하라
- (Effective Java Item 9) Java - try‐finally보다는 try‐with‐resources를 사용하라
- (Effective Java Item 10) Java ‐ equals는 일반 규약을 지켜 재정의하라
- (Effective Java Item 11) Java ‐ equals를 재정의하려거든 hashCode도 재정의하라
- (Effective Java Item 12) Java - toString을 항상 재정의하라
- (Effective Java Item 13) Java ‐ clone 재정의는 주의해서 진행하라
- (Effective Java Item 14) Java ‐ Comparable을 구현할지 고려하라
- (Effective Java Item 15) Java ‐ 클래스와 멤버의 접근 권한을 최소화하라
- (Effective Java Item 16) Java ‐ public 클래스에서는 public 필드가 아닌 접근자 메서드를 사용하라
- (Effective Java Item 17) Java ‐ 변경 가능성을 최소화하라
- (Effective Java Item 18) Java ‐ 상속보다는 컴포지션을 사용하라
- (Effective Java Item 19) Java ‐ 상속을 고려해 설계하고 문서화하라. 그러지 않았다면 상속을 금지하라
- (Effective Java Item 20) Java ‐ 추상 클래스보다는 인터페이스를 우선하라
- (Effective Java Item 21) Java ‐ 인터페이스는 구현하는 쪽을 생각해 설계하라
- (Effective Java Item 22) Java ‐ 인터페이스는 타입을 정의하는 용도로만 사용하라
- (Effective Java Item 23) Java ‐ 태그 달린 클래스보다는 클래스 계층구조를 활용하라
- (Effective Java Item 24) Java ‐ 멤버 클래스는 되도록 static으로 만들라
- (Effective Java Item 25) Java ‐ 톱레벨 클래스는 한 파일에 하나만 담으라
- (Effective Java Item 26) Java ‐ 로 타입은 사용하지 말라
- (Effective Java Item 27) Java ‐ 비검사 경고를 제거하라
- (Effective Java Item 28) Java ‐ 배열보다는 리스트를 사용하라
- (Effective Java Item 29) Java ‐ 이왕이면 제네릭 타입으로 만들라
- (Effective Java Item 30) Java ‐ 이왕이면 제네릭 메서드로 만들라
- (Effective Java Item 31) Java - 한정적 와일드카드를 사용해 API 유연성을 높이라
- (Effective Java Item 32) Java - 제네릭과 가변인수를 함께 쓸 때는 신중하라
- (Effective Java Item 33) Java ‐ 타입 안전 이종 컨테이너를 고려하라
- (Effective Java Item 34) Java - int 상수 대신 열거 타입을 사용하라
- (Effective Java Item 35) Java - ordinal 메서드 대신 인스턴스 필드를 사용하라
- (Effective Java Item 36) Java ‐ 비트 필드 대신 EnumSet을 사용하라
- (Effective Java Item 37) Java ‐ ordinal 인덱싱 대신 EnumMap을 사용하라
- (Effective Java Item 38) Java ‐ 확장할 수 있는 열거 타입이 필요하면 인터페이스를 사용하라
- (Effective Java Item 39) Java ‐ 명명 패턴보다 애너테이션을 사용하라[Effective Java Item 39]
- (Effective Java Item 40) Java ‐ @Override 어노테이션을 일괄되게 사용하라
- (Effective Java Item 41) Java ‐ 정의하려는 것이 타입이라면 마커 인터페이스를 사용하라
- (Effective Java Item 42) Java ‐ 익명 클래스보다는 람다를 사용하라
- (Effective Java Item 43) Java ‐ 람다보다는 메서드 참조를 사용하라
- (Effective Java Item 44) Java - 표준 함수형 인터페이스를 사용하라
- (Effective Java Item 45) Java - 스트림은 주의해서 사용하라
- (Effective Java Item 46) Java - 스트림에서는 부작용 없는 함수를 사용하라
- (Effective Java Item 47) Java - 반환 타입으로는 스트림보다 컬렉션이 낫다
- (Effective Java Item 48) Java ‐ 스트림 병렬화는 주의해서 사용하라
- (Effective Java Item 49) Java ‐ 매개변수가 유효한지 검사하라
- (Effective Java Item 50) Java ‐ 적시에 방어적 복사본을 만들라
- (Effective Java Item 51) Java ‐ 메서드 시그니처를 신중히 설계하라
- (Effective Java Item 52) Java ‐ 다중정의는 신중히 사용하라
- (Effective Java Item 53) Java ‐ 가변인수는 신중히 사용하라
- (Effective Java Item 54) Java - null이 아닌, 빈 컬렉션이나 배열을 반환하라
- (Effective Java Item 55) Java ‐ 옵셔널 반환은 신중히 하라
- (Effective Java Item 56) Java ‐ 공개된 API 요소에는 항상 문서화 주석을 사용하라
- (Effective Java Item 57) Java ‐ 지역변수의 범위를 최소화하라
- (Effective Java Item 58) Java ‐ 전통적인 for문보다는 for‐each문을 사용하라
- (Effective Java Item 59) Java ‐ 라이브러리를 익히고 사용하라
- (Effective Java Item 60) Java ‐ 정확한 답이 필요하다면 float와 double은 피하라
- (Effective Java Item 61) Java ‐ 박싱된 기본 타입보다는 기본 타입을 사용하라
- (Effective Java Item 62) Java ‐ 다른 타입이 적절하다면 문자열 사용을 피하라
- (Effective Java Item 63) Java ‐ 문자열 연결은 느리니 주의하라
- (Effective Java Item 64) Java ‐ 객체는 인터페이스를 사용해 참조하라
- (Effective Java Item 65) Java ‐ 리플렉션보다는 인터페이스를 사용하라
- (Effective Java Item 66) Java ‐ 네이티브 메서드는 신중히 사용하라
- (Effective Java Item 67) Java ‐ 최적화는 신중히 하라
- (Effective Java Item 68) Java ‐ 일반적으로 통용되는 명명 규칙을 따르라
- (Effective Java Item 69) Java ‐ 예외는 진짜 예외 상황에만 사용하라
- (Effective Java Item 70) Java ‐ 복구할 수 있는 상황에는 검사 예외를, 프로그래밍 오류에는 런타임 예외를 사용하라
- (Effective Java Item 71) Java ‐ 필요 없는 검사 예외 사용은 피하라
- (Effective Java Item 72) Java ‐ 표준 예외를 사용하라
- (Effective Java Item 73) Java ‐ 추상화 수준에 맞는 예외를 던지라
- (Effective Java Item 74) Java ‐ 메서드가 던지는 모든 예외를 문서화하라
- (Effective Java Item 75) Java ‐ 예외의 상세 메시지에 실패 관련 정보를 담으라
- (Effective Java Item 76) Java ‐ 가능한 한 실패 원자적으로 만들라
- (Effective Java Item 77) Java ‐ 예외를 무시하지 말라
- (Effective Java Item 78) Java - 공유 중인 가변 데이터는 동기화해 사용하라
- (Effective Java Item 79) Java - 과도한 동기화는 피하라
- (Effective Java Item 80) Java - 쓰레드보다는 실행자, 태스크, 스트림을 애용하라
- (Effective Java Item 81) Java - wait와 notify는 동시성 유틸리티를 애용하라
- (Effective Java Item 82) Java - 쓰레드 안전성 수준을 문서화하라
- (Effective Java Item 83) Java - 지연 초기화는 신중히 사용하라
- (Effective Java Item 84) Java - 프로그램의 동작을 쓰레드 스케줄러에 기대지 말라
- (Effective Java Item 85) Java - 자바 직렬화의 대안을 찾으라
- (Effective Java Item 86) Java - Serializable을 구현할지는 신중히 결정하라
- (Effective Java Item 87) Java - 커스텀 직렬화 형태를 고려해보라
- (Effective Java Item 88) Java - readObject 메서드는 방어적으로 작성하라
- (Effective Java Item 89) Java - 인스턴스 수를 통제해야 한다면 readResolve보다는 열거 타입을 사용하라
- [🔖(Effective Java Item 90) Java - 직렬화된 인스턴스 대신 직렬화 프록시 사용을 검토하라]
- (Effective Kotlin Item 1) Kotlin - 가변성을 제한하라
- (Effective Kotlin Item 2) Kotlin - 임계 영역을 제거하라
- (Effective Kotlin Item 3) Kotlin - 가능한 한 빨리 플랫폼 타입을 제거하라
- (Effective Kotlin Item 4) Kotlin - 변수의 스코프를 최소화하라
- (Effective Kotlin Item 5) Kotlin - 인수와 상태에 대한 기대치를 명시하라
- (Effective Kotlin Item 6) Kotlin - 사용자 정의 오류보다 표준 오류를 선호하라
- (Effective Kotlin Item 7) Kotlin - 결과가 없을 가능성이 있는 경우 널 가능 또는 Result 반환 타입을 선호하라
- (Effective Kotlin Item 8) Kotlin - use를 사용하여 리소스를 닫아라
- (Effective Kotlin Item 9) Kotlin - 단위 테스트를 작성하라
- (Effective Kotlin Item 10) Kotlin - 가독성을 목표로 설계하라
- (Effective Kotlin Item 11) Kotlin - 연산자의 의미는 함수의 이름과 일치해야 한다
- (Effective Kotlin Item 12) Kotlin - 가독성을 높이려면 연산자를 사용하라
- (Effective Kotlin Item 13) Kotlin - 타입 명시를 고려하라
- (Effective Kotlin Item 14) Kotlin - 리시버를 명시적으로 참조하라
- (Effective Kotlin Item 15) Kotlin - 프로퍼티는 동작이 아닌 상태를 나타내야 한다
- (Effective Kotlin Item 16) Kotlin - Unit?을 반환이나 연산에 사용하지 말라
- (Effective Kotlin Item 17) Kotlin - 이름 있는 인수 사용을 고려하라
- (Effective Kotlin Item 18) Kotlin - 코딩 컨벤션을 준수하라
- (Effective Kotlin Item 19) Kotlin - knowledge를 반복하지 말라
- (Effective Kotlin Item 20) Kotlin - 일반적인 알고리즘을 반복하지 말라
- (Effective Kotlin Item 21) Kotlin - 일반적인 알고리즘을 구현할 때 제네릭을 사용하라
- (Effective Kotlin Item 22) Kotlin - 타입 매개변수의 섀도잉을 피하라
- (Effective Kotlin Item 23) Kotlin - 제네릭 타입에 변성 한정자 사용을 고려하라
- (Effective Kotlin Item 24) Kotlin - 공통 모듈을 추출해서 여러 플랫폼에서 재사용하라
- (Effective Kotlin Item 25) Kotlin - 각각의 함수는 하나의 추상화 수준으로 작성하라
- (Effective Kotlin Item 26) Kotlin - 변경으로부터 코드를 보호하려면 추상화를 사용하라
- (Effective Kotlin Item 27) Kotlin - API 안정성을 명시하라
- (Effective Kotlin Item 28) Kotlin - 외부 API를 래핑하는 것을 고려하라
- (Effective Kotlin Item 29) Kotlin - 가시성을 최소화하라
- (Effective Kotlin Item 30) Kotlin - 문서로 규약을 정의하라
- (Effective Kotlin Item 31) Kotlin - 추상화 규약을 준수하라
- (Effective Kotlin Item 32) Kotlin - 보조 생성자 대신 팩토리 함수를 고려하라
- (Effective Kotlin Item 33) Kotlin - 이름 있는 선택적 인수를 갖는 기본 생성자 사용을 고려하라
- (Effective Kotlin Item 34) Kotlin - 복잡한 객체 생성을 위해 DSL 정의를 고려하라
- (Effective Kotlin Item 35) Kotlin - 의존성 주입을 고려하라
- (Effective Kotlin Item 36) Kotlin - 상속보다 합성을 선호하라
- (Effective Kotlin Item 37) Kotlin - 데이터 묶음을 표현할 때 data 한정자를 사용하라
- (Effective Kotlin Item 38) Kotlin - 연산과 행동을 전달하려면 함수 타입이나 함수형 인터페이스를 사용하라
- (Effective Kotlin Item 39) Kotlin - 제한된 계층구조를 표현하기 위해 sealed 클래스와 sealed 인터페이스를 사용하라
- [(Effective Kotlin Item 40) Kotlin - 태그 클래스 대신 클래스 계층구조를 선호하라]
- [(Effective Kotlin Item 41) Kotlin - 열거형 클래스를 사용해서 값 목록을 나타내라]
- [(Effective Kotlin Item 42) Kotlin - equals의 규약을 준수하라]
- [(Effective Kotlin Item 43) Kotlin - hashCode의 규약을 준수하라]
- [(Effective Kotlin Item 44) Kotlin - compareTo의 규약을 준수하라]
- [(Effective Kotlin Item 45) Kotlin - API의 필수적이지 않은 부분을 확장으로 추출하는 것을 고려하라]
- [(Effective Kotlin Item 46) Kotlin - 멤버 확장 함수를 피하라]
- (Effective Kotlin Item 3) Kotlin - variable
- (Effective Kotlin Item 4) Kotlin - primitive types, literals, and operations
- (Effective Kotlin Item 5) Kotlin - control Flow: if, when, try, and while
- (Effective Kotlin Item 6) Kotlin - function
- (Effective Kotlin Item 7) Kotlin - for
- (Effective Kotlin Item 8) Kotlin - Null Safety and Nullable Types
- (Effective Kotlin Item 9) Kotlin - Class
- (Effective Kotlin Item 10) Kotlin - Extend
- (Effective Kotlin Item 11) Kotlin - Data Class
- (Effective Kotlin Item 12) Kotlin - Object
- (Effective Kotlin Item 13) Kotlin ‐ Exception
- (Effective Kotlin Item 14) Kotlin - Enum Classes
- (Effective Kotlin Item 15) Kotlin - Sealed Classes and Interfaces
- (Effective Kotlin Item 16) Kotlin - Annotation Classes
- (Effective Kotlin Item 17) Kotlin - Extensions
- (Effective Kotlin Item 18) Kotlin - Collections
- (Effective Kotlin Item 19) Kotlin - Operator Overloading
- (Effective Kotlin Item 20) Kotlin - The Beauty of the Type System
- (Effective Kotlin Item 21) Kotlin - Generic
- Reactive Programming - Reactive Streams
- Reactive Programming - Blocking I/O & Non-Blocking I/O
- Reactive Programming - Reactor Outline
- Reactive Programming - Marble Diagram
- Reactive Programming - Cold Sequence & Hot Sequence
- [Reactive Programming - Backpressure]
- [Reactive Programming - Sinks]
- [Reactive Programming - Scheduler]
- [Reactive Programming - Context]
- [Reactive Programming - Debugging]
- [Reactive Programming - Testing]
- [Reactive Programming - Operators]
- [Reactive Programming - Spring Webflux]
- [Reactive Programming - Annotation Based Controller]
- [Reactive Programming - Functional Endpoint]
- [Reactive Programming - Spring Data R2DBC]
- [Reactive Programming - Exception Handling]
- [Reactive Programming - WebClient]
- [Reactive Programming - Reactive Streaming Data Processing]
- 가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 사용자 수에 따른 규모 확장성
- 가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 개략적인 규모 추정
- 가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 처리율 제한 장치의 설계
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 안정 해시 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 키-값 저장소 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 분산 시스템을 위한 유일 ID 생성기 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - URL 단축기 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 웹 크롤러 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 알림 시스템 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 뉴스 피드 시스템 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 채팅 시스템 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 검색어 자동완성 시스템 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 유튜브 설계]
- [가상 면접 사례로 배우는 대규모 시스템 설계 기초 1 - 구글 드라이브 설계]
- (Clean Code 2) Clean Code - 의미 있는 이름
- (Clean Code 3) Clean Code - 함수
- (Clean Code 4) Clean Code - 주석
- (Clean Code 5) Clean Code - 형식 맞추기
- (Clean Code 6) Clean Code - 객체와 자료구조
- (Clean Code 7) Clean Code - 오류 처리
- (Clean Code 8) Clean Code - 경계
- (Clean Code 9) Clean Code - 단위 테스트
- (Clean Code 10) Clean Code - 클래스
📖 리팩토링 2판⭐
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 - 느려진 서비스, 어디부터 봐야 할까
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 - 성능을 좌우하는 DB 설계와 쿼리
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 외부 연동이 문제일 때 살펴봐야 할 것들
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 비동기 연동, 언제 어떻게 써야 할까
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 동시성, 데이터가 꼬이기 전에 잡아야 한다
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ IO 병목, 어떻게 해결하지
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 실무에서 꼭 필요한 보안 지식
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 모르면 답답해지는 네트워크 기초
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 자주 쓰는 서버 구조와 설계 패턴
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ 처음 해보는 성능 테스트를 위한 기본 정리
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ NoSQL 이해하기
- 주니어 백엔드 개발자가 반드시 알아야 할 실무 지식 ‐ DB로 분산 잠금 구현하기
- 개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴 - 객체 지향
- 개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴 - 다형성과 추상 타입
- 개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴 - 재사용: 상속보단 조립
- 개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴 - 설계 원칙: SOLID
- 개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴 - DI(Dependency Injection)와 서비스 로케이터
- 개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴 - 주요 디자인 패턴
- [Real MySQL 8.0 - 인덱스]
- [Real MySQL 8.0 - 실행 계획]
- [Real MySQL 8.0 - 아키텍처]
- [Real MySQL 8.0 - 트랜잭션과 잠금]
- 객체지향의 사실과 오해(역할, 책임, 협력 관점에서 본 객체지향) - 협력하는 객체들의 공동체
- 객체지향의 사실과 오해(역할, 책임, 협력 관점에서 본 객체지향) - 이상한 나라의 객체
- [객체지향의 사실과 오해(역할, 책임, 협력 관점에서 본 객체지향) - 타입과 추상화]
- [객체지향의 사실과 오해(역할, 책임, 협력 관점에서 본 객체지향) - 역할, 책임, 협력]
- [객체지향의 사실과 오해(역할, 책임, 협력 관점에서 본 객체지향) - 책임과 메시지]
- [객체지향의 사실과 오해(역할, 책임, 협력 관점에서 본 객체지향) - 객체 지도]