환경: Redis 6.0 / Sentinel / 데이터 500GB 이상

1. 현상

Sentinel에서 sentinel failover mymaster 명령어로 수동 failover를 수행하면, 데이터가 거의 없고 backlog 설정이 충분한 환경에서도 partial resync가 아닌 full resync가 발생한다.

발생 로그

Before turning into a replica, using my own master parameters to synthesize a cached master:
I may be able to synchronize with the new master with just a partial transfer
Discarding previously cached master state.
Full resync from master
connection with replica client id lost

환경 정보

• Redis 버전: 6.0
• 데이터 사용량: 500GB 이상 (프로덕션)
• client-output-buffer-limit (slave): 2GB 1GB 60
• repl-timeout: 600초
• repl-backlog-size: 충분히 큰 값으로 설정됨
• master_replid2: 0000000000000000000000000000000000000000 (초기화됨)

2. 원인 분석

2.1 근본 원인: sentinel failover의 구조적 한계

sentinel failover는 내부적으로 선택된 replica에게 SLAVEOF NO ONE을 보내는 비협조적(uncoordinated) 방식이다. master는 자신이 교체될 것을 모르기 때문에 내부 쓰기를 계속하고, 이로 인해 offset 불일치가 발생한다. 이것은 버전과 관계없이 동일하게 발생하는 구조적 문제이다.

2.2 Failover 시 내부 동작 순서

1. Sentinel이 replica를 선택하여 SLAVEOF NO ONE 전송 → 새 master로 승격
2. 새 master는 새로운 replid 생성, 이전 replid를 replid2에 저장, second_repl_offset 기록
3. 이전 master는 아직 master로 동작 중 → 내부 쓰기(expire, Sentinel PING 등)로 offset 계속 증가
4. Sentinel이 이전 master에게 SLAVEOF <new-master> 전송 → replica로 전환
5. 기존 replication 연결 끊김 → connection with replica client id lost 발생
6. 이전 master가 새 master에게 PSYNC 요청 → 자신의 offset이 새 master의 second_repl_offset보다 큼
7. 새 master가 partial resync 거부 → full resync 발생

2.3 핵심 메커니즘: Offset 불일치

이전 master의 offset이 새 master의 second_repl_offset보다 크면, 새 master는 "이 replica가 요청하는 offset은 내가 알고 있는 분기 시점보다 앞서 있다"고 판단하여 partial resync를 거부한다. 데이터가 거의 없는 환경에서도 failover 과정의 시간 차이 동안 Sentinel의 PING/INFO 교환만으로 offset 차이가 발생한다.

2.4 replid2 초기화는 결과이지 원인이 아님

master_replid2가 000...000으로 보이는 것은 full resync가 완료된 후 replica가 새 master의 replid로 갱신되면서 초기화된 결과이다.

2.5 배제된 원인

• backlog 크기 부족 → 설정 충분 + 데이터 거의 없음
• client-output-buffer-limit → 2GB로 충분
• repl-timeout → 600초로 충분
• backlog 덮어쓰기 → 쓰기 거의 없음

3. 500GB 환경에서 Full Resync의 영향

• RDB fork 시 copy-on-write로 메모리 사용량 최대 2배(~1TB) → OOM killer 위험
• RDB 생성 중 수십 분간 CPU/IO 부하
• 500GB RDB 전송 중 네트워크 대역폭 점유
• replica가 sync 완료할 때까지 수 시간 서비스 불안정
• offset 차이만큼 데이터 유실 가능성

4. 대응 방안: CLIENT PAUSE + SENTINEL FAILOVER

버전과 관계없이 Sentinel 환경에서는 CLIENT PAUSE WRITE로 쓰기를 먼저 중단하여 master의 offset 증가를 멈춘 후 SENTINEL FAILOVER를 수행해야 한다. 이렇게 하면 새 master의 second_repl_offset과 이전 master의 offset이 일치하여 partial resync가 가능해진다.

Sentinel이 failover 주체가 되므로 +switch-master 이벤트가 즉시 발행되고, 클라이언트 전환도 정상적으로 이루어진다.

4.1 수동 수행 절차

사전 준비로 터미널 2개를 미리 준비한다.

• 터미널 A: master 접속 (redis-cli -h <master-ip> -p 6379)
• 터미널 B: sentinel 접속 (redis-cli -h <sentinel-ip> -p 26379)

4.2 핵심 포인트

• Step 3과 Step 4 사이 간격을 최대한 짧게 하는 것이 핵심이다.
• PAUSE timeout 30초는 안전장치이다. failover가 실패해도 30초 후 자동으로 쓰기가 재개된다.
• lag이 0과 1을 오가는 것은 정상이다. lag은 replica가 1초마다 ACK를 보내는 타이밍 기반이므로, offset 차이가 수십~수백 이내면 바로 진행해도 된다.
• CLIENT PAUSE를 안 해도 failover 중에는 어차피 쓰기가 안 되므로, CLIENT PAUSE가 추가하는 쓰기 중단 시간은 사실상 없다.

4.3 예상 클라이언트 영향 비교

5. SENTINEL FAILOVER vs CLUSTER FAILOVER

Redis Cluster 환경의 CLUSTER FAILOVER는 이 문제가 발생하지 않는다. replica가 master에게 failover를 요청하면 master가 CLIENT PAUSE WRITE를 실행하고, replica가 offset을 따라잡은 후 Cluster 투표를 통해 전환된다. 협조적(coordinated) 방식이므로 offset 불일치가 없고, Cluster 구성이 자동 전파되어 추가 조치도 불필요하다.

Sentinel 환경의 SENTINEL FAILOVER는 master에게 알리지 않고 replica에 SLAVEOF NO ONE을 보내는 비협조적 방식이므로 offset 불일치가 발생하며, 이를 방지하려면 수동으로 CLIENT PAUSE WRITE를 먼저 수행해야 한다. 이 문제는 Sentinel이 내부적으로 협조적 전환을 지원하지 않는 구조적 한계이며, GitHub issue #13118, #13917에서 개선이 제안된 상태이나 아직 공식 반영되지 않았다.

6. 로그 확인 방법

6.1 Failover 전후 replication 상태 확인

redis-cli -h <노드-ip> INFO replication

확인할 값: master_replid, master_replid2, master_repl_offset, second_repl_offset, repl_backlog_first_byte_offset

6.2 새 master 로그에서 partial resync 거부 사유 확인

grep -iE "psync|partial|full|resync|replid|offset|accept|reject" <new-master-log-path>

다음 중 하나가 출력된다:

• Partial resynchronization not accepted: Replication ID mismatch → replid 불일치
• Partial resynchronization not accepted: Requested offset for second ID was X, but I can reply up to Y → offset 초과

6.3 이전 master(강등된 노드) 로그 확인

grep -iE "psync|partial|full|resync|cached|discard|turning|pause" <old-master-log-path>

6.4 Sentinel 로그에서 failover 진행 확인

grep -iE "failover|switch-master|promoted|selected" <sentinel-log-path>

7. 근거 문서

• Redis Replication 공식 문서 (replid2, second_repl_offset 동작 원리): https://redis.io/docs/latest/operate/oss_and_stack/management/replication/
• Redis Sentinel 공식 문서 (failover 시 REPLICAOF NO ONE 방식): https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/
• CLUSTER FAILOVER 공식 문서 (협조적 전환 방식): https://redis.io/docs/latest/commands/cluster-failover/
• GitHub issue #4819 — sentinel failover 후 offset 불일치로 full resync 발생 보고: https://github.com/redis/redis/issues/4819
• GitHub issue #13483 — Redis 7.2.4에서도 동일 현상 발생 확인: https://github.com/redis/redis/issues/13483
• GitHub issue #13118 — Sentinel에 협조적 failover 도입 제안 (미반영): https://github.com/redis/redis/issues/13118
• GitHub issue #13917 — 동일 문제 개선 제안 (미반영): https://github.com/redis/redis/issues/13917

/* ===== 00_insert_verify_data.js ===== */
/* 목적: 업그레이드 전후 검증용 더미데이터 생성 (verify_* 네임스페이스) */

const DB_NAME = "prd-sre-test-jti-create-test002";
const PREFIX = "verify_";

const dbx = db.getSiblingDB(DB_NAME);
const colUsers = dbx.getCollection(PREFIX + "users");
const colProducts = dbx.getCollection(PREFIX + "products");
const colOrders = dbx.getCollection(PREFIX + "orders");

const COUNTS = { users: 2000, products: 500, orders: 7000 };
const BATCH_SIZE = 500;

function randInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }
function pick(arr) { return arr[Math.floor(Math.random() * arr.length)]; }
function randomString(len) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let s = ""; for (let i = 0; i < len; i++) s += chars.charAt(Math.floor(Math.random()*chars.length));
  return s;
}
function randomTags() {
  const tags = ["mochi","fruit","gift","dessert","coffee","kids","premium"];
  const n = randInt(1,3);
  return Array.from({length:n}, () => pick(tags));
}

// 인덱스
colUsers.createIndex({ email: 1 }, { unique: true });
colProducts.createIndex({ sku: 1 }, { unique: true });
colOrders.createIndex({ userId: 1, createdAt: -1 });

// Users
print("== inserting users ==");
let users = [];
for (let i = 0; i < COUNTS.users; i++) {
  users.push({
    _id: new ObjectId(),
    email: `user${i}@test.com`,
    name: `User ${i}`,
    age: randInt(18,60),
    joinedAt: new Date(Date.now() - randInt(0,1000)*86400000),
    city: pick(["Seoul","Suwon","Busan","Incheon"]),
    tier: pick(["basic","silver","gold","vip"])
  });
  if (users.length >= BATCH_SIZE) { colUsers.insertMany(users, { ordered:false }); users=[]; }
}
if (users.length) colUsers.insertMany(users, { ordered:false });

// Products
print("== inserting products ==");
let products = [];
for (let i = 0; i < COUNTS.products; i++) {
  products.push({
    _id: new ObjectId(),
    sku: `SKU-${String(i).padStart(5,"0")}`,
    name: `Product ${i} ${randomString(randInt(3,12))}`,
    price: Math.round((Math.random()*50000 + 5000))/100,
    tags: randomTags(),
    createdAt: new Date(Date.now() - randInt(0,365)*86400000)
  });
  if (products.length >= BATCH_SIZE) { colProducts.insertMany(products, { ordered:false }); products=[]; }
}
if (products.length) colProducts.insertMany(products, { ordered:false });

// Orders
print("== inserting orders ==");
const userIds = colUsers.find({}, { _id:1 }).toArray().map(d=>d._id);
const skus = colProducts.find({}, { sku:1 }).toArray().map(d=>d.sku);

let orders = [];
for (let i = 0; i < COUNTS.orders; i++) {
  const items = Array.from({length: randInt(1,3)}).map(()=>({
    sku: pick(skus),
    qty: randInt(1,5),
    price: Math.round((Math.random()*10000 + 500))/100
  }));
  orders.push({
    _id: new ObjectId(),
    userId: pick(userIds),
    items,
    total: items.reduce((a,b)=>a + b.qty*b.price, 0),
    status: pick(["new","paid","shipped","cancelled"]),
    createdAt: new Date(Date.now() - randInt(0,120)*86400000)
  });
  if (orders.length >= BATCH_SIZE) { colOrders.insertMany(orders, { ordered:false }); orders=[]; }
}
if (orders.length) colOrders.insertMany(orders, { ordered:false });

print("✅ verify data inserted");
print("counts:", {
  users: colUsers.estimatedDocumentCount(),
  products: colProducts.estimatedDocumentCount(),
  orders: colOrders.estimatedDocumentCount()
});

1. 업그레이드 “전” 스냅샷 (같은 DB 내 저장)

/* ===== 01_pre_snapshot_fixed.js ===== */

/* ===== 01_pre_snapshot_fixed.js ===== */

const DB_NAME = "prd-sre-test-jti-create-test002";
const SNAP_COLL = "__verify_snapshots";
const EXCLUDE_PREFIX = "__verify_";
const ALLOWLIST = []; // 필요 시 ["verify_users", ...] 처럼 제한

const dbx = db.getSiblingDB(DB_NAME);
const snaps = dbx.getCollection(SNAP_COLL);

function listCollections() {
  return dbx.runCommand({ listCollections: 1, nameOnly: false }).cursor.firstBatch;
}
function isIncluded(name) {
  if (name.startsWith(EXCLUDE_PREFIX)) return false;
  if (ALLOWLIST.length === 0) return true;
  return ALLOWLIST.includes(name);
}
function helloSafe() {
  try { return db.adminCommand({ hello: 1 }); }
  catch (e) { try { return db.isMaster(); } catch (e2) { return {}; } }
}
function isMongos(hello) {
  // mongos일 때 hello.msg === "isdbgrid" 가 통상적으로 존재
  return hello && (hello.msg === "isdbgrid");
}
function fcwSafe() { // FCV 안전 폴백
  try {
    const r = db.adminCommand({ getParameter: 1, featureCompatibilityVersion: 1 });
    if (r && r.featureCompatibilityVersion) return { source: "getParameter", value: r.featureCompatibilityVersion };
  } catch (_) {}
  try {
    const doc = db.getSiblingDB("admin").system.version.findOne({ _id: "featureCompatibilityVersion" });
    if (doc) return { source: "system.version", value: { version: doc.version, targetVersion: doc.targetVersion ?? null } };
  } catch (_) {}
  try { return { source: "fallback", value: { serverVersion: db.version() } }; } catch (_) { return { source: "fallback", value: null }; }
}
function collStatsSafe(n) { try { return dbx.runCommand({ collStats: n, scale: 1 }); } catch (e) { return { ok:0, errmsg: e.message }; } }
function indexesSafe(n) { try { return dbx.getCollection(n).getIndexes(); } catch (e) { return [{ _error: e.message }]; } }

// dbHash 가능 시 사용
function dbHashSafe(names) {
  try { return dbx.runCommand({ dbHash: 1, collections: names, full: true }); }
  catch (e) { return { ok: 0, errmsg: e.message }; }
}

// mongos 폴백: 결정적 샘플 체크섬
function sampleChecksum(collName, opts = { limitPerSide: 1000, stride: 100 }) {
  const { limitPerSide, stride } = opts;
  const col = dbx.getCollection(collName);

  function rollingHashOfCursor(cur) {
    let h = 0; let i = 0;
    cur.forEach(doc => {
      if ((i++ % stride) !== 0) return; // stride 간격 샘플링(결정적)
      const s = JSON.stringify(doc); // 기본은 전체 문서 직렬화(필요시 프로젝션으로 조정)
      for (let k = 0; k < s.length; k++) h = ((h << 5) - h + s.charCodeAt(k)) | 0;
    });
    return h|0;
  }

  // 앞쪽 일부(_id 오름차순) + 뒤쪽 일부(_id 내림차순)를 합쳐서 결정적 샘플
  const fwd = col.find({}).sort({ _id: 1 }).limit(limitPerSide);
  const rev = col.find({}).sort({ _id: -1 }).limit(limitPerSide);

  const hf = rollingHashOfCursor(fwd);
  const hr = rollingHashOfCursor(rev);
  const combined = (((hf & 0xffff) << 16) ^ (hr & 0xffff)) | 0;

  return { hash32: combined, forwardSample: limitPerSide, backwardSample: limitPerSide, stride };
}

const snapshotId = new ObjectId();
print(`[PRE] start for ${DB_NAME}, snapshotId=${snapshotId}`);

const hello = helloSafe();
const atMongos = isMongos(hello);
const fcv = fcwSafe();

const colMetaAll = listCollections().map(c => ({
  name: c.name,
  type: c.type,
  options: {
    validator: c.options?.validator ?? null,
    timeseries: c.options?.timeseries ?? null,
    clusteredIndex: c.options?.clusteredIndex ?? null
  }
}));

const targetCols = colMetaAll.filter(c => c.type === "collection" && isIncluded(c.name)).map(c => c.name);

// 공통 수집
const stats = {}, indexes = {};
targetCols.forEach(n => { stats[n] = collStatsSafe(n); indexes[n] = indexesSafe(n); });

// 해시 수집(분기)
let hashMode = "";
let hashPayload = {};
if (!atMongos) {
  const dh = dbHashSafe(targetCols);
  if (dh && dh.ok === 1) {
    hashMode = "dbHash";
    hashPayload = dh; // { collections: {name:{md5:..}}, md5:.. }
  } else {
    hashMode = "sample32";
    // mongod인데도 실패하면 폴백
    const samples = {};
    targetCols.forEach(n => { samples[n] = sampleChecksum(n); });
    hashPayload = { samples };
  }
} else {
  hashMode = "sample32"; // mongos → dbHash 불가
  const samples = {};
  targetCols.forEach(n => { samples[n] = sampleChecksum(n); });
  hashPayload = { samples };
}

snaps.insertOne({
  _id: snapshotId,
  role: "pre",
  db: DB_NAME,
  createdAt: new Date(),
  hello,
  fcv,
  hashMode,         // "dbHash" | "sample32"
  hashPayload,      // dbHash 결과 or 샘플 해시 맵
  collections: colMetaAll,
  targetCols,
  stats,
  indexes
}, { writeConcern: { w: "majority" } });

print(`[PRE] saved (mode=${hashMode}).`);

2.업그레이드 “후” 비교 (같은 DB 내 저장)

/* ===== 02_post_compare_compass_fixed.js ===== */

(() => {
  const DB_NAME = "prd-sre-test-jti-create-test002";
  const SNAP_COLL = "__verify_snapshots";
  const EXCLUDE_PREFIX = "__verify_";
  const ALLOWLIST = [];

  const dbx = db.getSiblingDB(DB_NAME);
  const snaps = dbx.getCollection(SNAP_COLL);

  function latestPre() { return snaps.find({ db: DB_NAME, role: "pre" }).sort({ createdAt: -1 }).limit(1).toArray()[0] || null; }
  function listCollections() { return dbx.runCommand({ listCollections: 1, nameOnly: false }).cursor.firstBatch; }
  function isIncluded(name) { if (name.startsWith(EXCLUDE_PREFIX)) return false; if (ALLOWLIST.length===0) return true; return ALLOWLIST.includes(name); }
  function collStatsSafe(n){ try { return dbx.runCommand({ collStats: n, scale: 1 }); } catch(e){ return { ok:0, errmsg: e.message }; } }
  function indexesSafe(n){ try { return dbx.getCollection(n).getIndexes(); } catch(e){ return [{ _error: e.message }]; } }
  function normalizeIndex(ix){
    const keep={}; ["name","key","unique","partialFilterExpression","sparse","expireAfterSeconds","weights","default_language","language_override","textIndexVersion","wildcardProjection","collation"]
      .forEach(k=>{ if (ix[k] !== undefined) keep[k]=ix[k]; });
    return keep;
  }
  function helloSafe(){ try { return db.adminCommand({ hello: 1 }); } catch(e){ try{ return db.isMaster(); } catch(e2){ return {}; } } }
  function isMongos(hello){ return hello && (hello.msg === "isdbgrid"); }
  function dbHashSafe(names){ try { return dbx.runCommand({ dbHash: 1, collections: names, full: true }); } catch(e){ return { ok:0, errmsg:e.message }; } }

  // 샘플 체크섬 (PRE와 동일 방식 유지해야 비교 가능)
  function sampleChecksum(collName, opts = { limitPerSide: 1000, stride: 100 }) {
    const { limitPerSide, stride } = opts;
    const col = dbx.getCollection(collName);
    function rollingHashOfCursor(cur){
      let h=0, i=0; cur.forEach(doc=>{
        if ((i++ % stride) !== 0) return;
        const s = JSON.stringify(doc);
        for (let k=0;k<s.length;k++) h = ((h<<5) - h + s.charCodeAt(k)) | 0;
      }); return h|0;
    }
    const fwd = col.find({}).sort({ _id: 1 }).limit(limitPerSide);
    const rev = col.find({}).sort({ _id: -1 }).limit(limitPerSide);
    const hf = rollingHashOfCursor(fwd);
    const hr = rollingHashOfCursor(rev);
    const combined = (((hf & 0xffff) << 16) ^ (hr & 0xffff)) | 0;
    return { hash32: combined, forwardSample: limitPerSide, backwardSample: limitPerSide, stride };
  }

  const pre = latestPre();
  if (!pre) {
    print("ERROR: No PRE snapshot found. 먼저 01_pre_snapshot_fixed.js를 실행해 주세요.");
    return; // Compass 안전
  }

  print(`[POST] comparing with PRE ${pre._id} @ ${pre.createdAt}, mode=${pre.hashMode}`);

  const hello = helloSafe();
  const atMongos = isMongos(hello);

  const colMetaNowAll = listCollections().map(c => ({
    name: c.name, type: c.type,
    options: {
      validator: c.options?.validator ?? null,
      timeseries: c.options?.timeseries ?? null,
      clusteredIndex: c.options?.clusteredIndex ?? null
    }
  }));
  const targetColsNow = colMetaNowAll.filter(c => c.type==="collection" && isIncluded(c.name)).map(c => c.name);

  const statsNow = {}, indexesNow = {};
  targetColsNow.forEach(n => { statsNow[n] = collStatsSafe(n); indexesNow[n] = indexesSafe(n).map(normalizeIndex); });

  // === 비교 섹션 ===
  function diffCounts(preStats, nowStats){
    const out=[]; const names = new Set([...Object.keys(preStats||{}), ...Object.keys(nowStats||{})]);
    names.forEach(n=>{
      if (!isIncluded(n)) return;
      const a = preStats?.[n], b = nowStats?.[n];
      const ac = a?.count, bc = b?.count;
      if (ac !== bc) out.push({ collection:n, count: `${ac} → ${bc}` });
    }); return out;
  }
  function diffIndexes(preIx, nowIx){
    const out=[]; const names = new Set([...Object.keys(preIx||{}), ...Object.keys(nowIx||{})]);
    const sig = x => JSON.stringify(x);
    names.forEach(n=>{
      if (!isIncluded(n)) return;
      const A = (preIx?.[n]||[]).map(normalizeIndex);
      const B = (nowIx?.[n]||[]).map(normalizeIndex);
      const SA = new Set(A.map(sig)), SB = new Set(B.map(sig));
      const missing = A.filter(x=>!SB.has(sig(x)));
      const added = B.filter(x=>!SA.has(sig(x)));
      if (missing.length || added.length) out.push({ collection:n, missingFromPost:missing, addedInPost:added });
    }); return out;
  }
  function diffOptions(preColsAll, nowColsAll){
    const out=[]; const preMap=Object.fromEntries((preColsAll||[]).map(x=>[x.name,x])); const nowMap=Object.fromEntries((nowColsAll||[]).map(x=>[x.name,x]));
    const names=new Set([...Object.keys(preMap), ...Object.keys(nowMap)]);
    names.forEach(n=>{
      if (!isIncluded(n)) return;
      const a = preMap[n], b = nowMap[n];
      if (!a && b) out.push({ collection:n, change:"new collection" });
      else if (a && !b) out.push({ collection:n, change:"collection removed" });
      else if (a && b) {
        const diffs=[]; ["validator","timeseries","clusteredIndex"].forEach(k=>{
          if (JSON.stringify(a.options?.[k]) !== JSON.stringify(b.options?.[k])) diffs.push({ field:k, pre:a.options?.[k], post:b.options?.[k] });
        });
        if (diffs.length) out.push({ collection:n, diffs });
      }
    }); return out;
  }

  // 해시 비교 (모드에 따라)
  let hashDiff = [];
  if (pre.hashMode === "dbHash") {
    // 가능하면 dbHash 재사용(현재 mongod에서 실행일 때만)
    const dh = dbHashSafe(targetColsNow);
    if (dh && dh.ok === 1) {
      const preMap = pre.hashPayload?.collections || {};
      const nowMap = dh.collections || {};
      const names = new Set([...Object.keys(preMap), ...Object.keys(nowMap)]);
      names.forEach(n=>{
        if (!isIncluded(n)) return;
        const a = preMap[n], b = nowMap[n];
        if (!a && b) hashDiff.push({ collection:n, change:"added(no PRE hash)" });
        else if (a && !b) hashDiff.push({ collection:n, change:"removed(no POST hash)" });
        else if (a.md5 !== b.md5) hashDiff.push({ collection:n, change:`hash changed ${a.md5} → ${b.md5}` });
      });
    } else {
      // PRE는 dbHash였지만 지금은 mongos이거나 실패 → sample32 폴백으로 재검증
      const samplesNow = {};
      targetColsNow.forEach(n => { samplesNow[n] = sampleChecksum(n); });
      hashDiff.push({ note: "dbHash unavailable at POST; used sample32 fallback", samplesNow });
    }
  } else {
    // PRE가 sample32였음 → 같은 방식으로 비교
    const preSamples = pre.hashPayload?.samples || {};
    const diff = [];
    targetColsNow.forEach(n=>{
      if (!isIncluded(n)) return;
      const nowS = sampleChecksum(n);
      const preS = preSamples[n];
      if (!preS) diff.push({ collection:n, change:"no PRE sample" });
      else if (preS.hash32 !== nowS.hash32) diff.push({ collection:n, change:`sample hash ${preS.hash32} → ${nowS.hash32}`, pre:preS, post:nowS });
    });
    // 새로 생긴/사라진 컬렉션도 기록
    const preNames = new Set(Object.keys(preSamples));
    const nowNames = new Set(targetColsNow);
    [...nowNames].forEach(n=>{ if (!preNames.has(n)) diff.push({ collection:n, change:"added in POST" }); });
    [...preNames].forEach(n=>{ if (!nowNames.has(n)) diff.push({ collection:n, change:"removed in POST" }); });
    hashDiff = diff;
  }

  const statsDiff = diffCounts(pre.stats, statsNow);
  const idxDiff = diffIndexes(pre.indexes, indexesNow);
  const optDiff = diffOptions(pre.collections, colMetaNowAll);

  print("\n=== HASH DIFF ==="); printjson(hashDiff);
  print("\n=== COUNT/STATS DIFF ==="); printjson(statsDiff);
  print("\n=== INDEX DIFF ==="); printjson(idxDiff);
  print("\n=== COLLECTION OPTION DIFF ==="); printjson(optDiff);

  snaps.insertOne({
    role: "post",
    db: DB_NAME,
    createdAt: new Date(),
    compareWith: pre._id,
    postHello: hello,
    hashModePre: pre.hashMode,
    result: { hashDiff, statsDiff, idxDiff, optDiff },
    statsNow, indexesNow, colMetaNowAll
  }, { writeConcern: { w: "majority" } });

  print("\n[POST] saved & compare finished (mongos/mongod auto).");
})();

apiVersion: v1
kind: Pod
metadata:
  name: redis-shake
  namespace: redis-shake
  labels:
    app: redis-shake
spec:
  containers:
  - name: redis-shake
    image: rmhewedy/redis-shake:latest # 최신 버전을 사용하거나 특정 태그를 지정하세요.
    command: ["/url/local/bin/redis-shake"]
    args:
      - "/etc/redis-shake/shake.toml"
    volumeMounts:
    - name: redis-shake-config
      mountPath: /etc/redis-shake
  volumes:
  - name: redis-shake-config
    configMap:
      name: redis-shake-configmap
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: redis-shake-configmap
  namespace: redis-shake
data:
  shake.toml: |

    [sync_reader] 
    cluster = false # 클러스터 여부
    address = "IP:PORT" # 원본 Redis IP:PORT
    username = ""
    password = "패스워드"
    tls = false
    sync_rdb = true
    sync_aof = true
    prefer_replica = true

    [redis_writer]
    cluster = false # 클러스터 여부
    address = "IP:PORT" # 대상 Redis IP:PORT
    username = ""
    password = "패스워드"
    tls = false
    sync_rdb = true
    sync_aof = true
    prefer_replica = true

max by (namespace, statefulset) (
  label_replace(
    max_over_time(container_memory_usage_bytes{container="backup-agent"}[7d]),
    "statefulset", "$1", "pod", "^(.*)-[0-9]+$"
  )
)

7일간 최대 cpu 사용률

max by (namespace, statefulset) (
  label_replace(
    max_over_time(
      rate(container_cpu_usage_seconds_total{container="backup-agent"}[5m])[7d:]
    ) * 1000,
    "statefulset", "$1", "pod", "^(.*)-[0-9]+$"
  )
)

MEMORY SUM

{ "size": 0, "query": { "bool": { "must": [ { "range": { "@timestamp": { "gte": "now-1h", "lte": "now" } } }, { "prefix": { "service.address": "10.156.133.121" } } ] } }, "aggs": { "max_memory_used_rss": { "max": { "field": "redis.info.memory.used.rss" } }, "total_max_memory_used_rss": { "sum": { "field": "redis.info.memory.used.rss" } } } }

memory 사용률 40% 미만

GET your_index/_search
{
  "_source": [
    "rscId",
    "service.address"
  ],
  "script_fields": {
    "used_memory_percent": {
      "script": {
        "source": "doc['redis.info.memory.used.value'].value * 100 / doc['redis.info.memory.max.value'].value",
        "lang": "painless"
      }
    }
  },
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "redis.info.memory.max.value": {
              "gte": 4294967296
            }
          }
        },
        {
          "script": {
            "script": {
              "source": "doc['redis.info.memory.used.value'].value < doc['redis.info.memory.max.value'].value * 0.4",
              "lang": "painless"
            }
          }
        }
      ]
    }
  }
}

rscId로 group

GET your_index/_search
{
  "size": 0,
  "aggs": {
    "group_by_rscId": {
      "terms": {
        "field": "rscId.keyword",
        "size": 10000
      },
      "aggs": {
        "group_by_service_address": {
          "terms": {
            "field": "service.address.keyword",
            "size": 10000
          },
          "aggs": {
            "top_hits": {
              "top_hits": {
                "_source": ["rscId", "service.address", "redis.info.memory.max.value"],
                "size": 1
              }
            },
            "avg_used_memory_percent": {
              "bucket_script": {
                "buckets_path": {
                  "used": "avg_used_memory",
                  "max": "avg_max_memory"
                },
                "script": "params.used * 100 / params.max"
              }
            },
            "avg_used_memory": {
              "avg": {
                "field": "redis.info.memory.used.value"
              }
            },
            "avg_max_memory": {
              "avg": {
                "field": "redis.info.memory.max.value"
              }
            }
          }
        }
      }
    }
  },
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "redis.info.memory.max.value": {
              "gte": 4294967296
            }
          }
        },
        {
          "script": {
            "script": {
              "source": "doc['redis.info.memory.used.value'].value < doc['redis.info.memory.max.value'].value * 0.4",
              "lang": "painless"
            }
          }
        }
      ]
    }
  }
}

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Elasticsearch 결과 변환</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        textarea { width: 100%; height: 200px; margin-top: 10px; }
        button { margin: 10px 0; padding: 10px; cursor: pointer; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f4f4f4; }
    </style>
</head>
<body>

    <h2>Elasticsearch 결과 변환</h2>

    <label for="jsonInput">Elasticsearch JSON 응답 입력:</label>
    <textarea id="jsonInput" placeholder="여기에 Elasticsearch JSON 데이터를 입력하세요..."></textarea>
    <button onclick="processInput()">변환하기</button>

    <table id="resultTable">
        <thead>
            <tr>
                <th>rscId</th>
                <th>Service Address</th>
                <th>Max Memory</th>
                <th>Max Used Memory Percent</th>
            </tr>
        </thead>
        <tbody>
            <!-- 결과가 여기에 추가됨 -->
        </tbody>
    </table>

    <script>
        function formatElasticsearchData(response) {
            const result = [];

            try {
                response.aggregations.group_by_rscId.buckets.forEach(rscBucket => {
                    const rscId = rscBucket.key;

                    rscBucket.group_by_service_address.buckets.forEach(serviceBucket => {
                        const serviceAddress = serviceBucket.key;
                        const maxMemory = serviceBucket.top_hits.hits.hits[0]._source["redis.info.memory.max.value"];
                        const maxUsedMemoryPercent = serviceBucket.avg_used_memory_percent.value.toFixed(2); // 소수점 2자리

                        result.push({ rscId, serviceAddress, maxMemory, maxUsedMemoryPercent });
                    });
                });
            } catch (error) {
                alert("잘못된 JSON 형식입니다. 올바른 데이터를 입력하세요.");
                console.error("Parsing error:", error);
                return [];
            }

            return result;
        }

        function processInput() {
            const inputText = document.getElementById("jsonInput").value.trim();
            if (!inputText) {
                alert("JSON 데이터를 입력하세요.");
                return;
            }

            try {
                const jsonData = JSON.parse(inputText);
                const results = formatElasticsearchData(jsonData);
                displayResults(results);
            } catch (error) {
                alert("JSON 파싱에 실패했습니다. 올바른 JSON을 입력하세요.");
                console.error("JSON Parse Error:", error);
            }
        }

        function displayResults(results) {
            const tableBody = document.querySelector("#resultTable tbody");
            tableBody.innerHTML = ""; // 기존 내용 초기화

            if (results.length === 0) {
                tableBody.innerHTML = "<tr><td colspan='4' style='text-align:center;'>데이터가 없습니다.</td></tr>";
                return;
            }

            results.forEach(item => {
                const row = `<tr>
                    <td>${item.rscId}</td>
                    <td>${item.serviceAddress}</td>
                    <td>${item.maxMemory.toLocaleString()} Bytes</td>
                    <td>${item.maxUsedMemoryPercent} %</td>
                </tr>`;
                tableBody.innerHTML += row;
            });
        }
    </script>

</body>
</html>

{
  "query": {
    "bool": {
      "must": {
        "script": {
          "script": {
            "source": """
              if (!doc.containsKey('redis.info.memory.used.rss') || !doc.containsKey('redis.info.memory.max.value')) {
                return false;
              }
              if (doc['redis.info.memory.used.rss'].size() == 0 || doc['redis.info.memory.max.value'].size() == 0) {
                return false;
              }
              return doc['redis.info.memory.used.rss'].value > doc['redis.info.memory.max.value'].value;
            """,
            "lang": "painless"
          }
        }
      },
      "must_not": {
        "prefix": {
          "rscId": "cube"
        }
      }
    }
  }
}

모든 collection compact

mongo your_database_name -u your_user -p your_pass --authenticationDatabase admin --quiet --eval 'db.getCollectionNames().forEach(function(c){ print("Compacting: " + c); printjson(db.runCommand({compact: c})); })'

아래 코드는 pattern을 설명하기 위한 예시이므로 로직상에 어색함이 있을 수 있다.

Abstract class

@RequiredArgsConstructor
abstract class OrderService {
    private final UserDao userDao;

    abstract ProductType getProductType;
    abstract int getPoint(String productCode);
    abstract int getProductName(String productCode);

    public void order(Order order) {
        orderDao.insertOrderTemp(order);

        int point = getPoint(order.getProductCode());
        String productName = getProductName(order.getProductCode());

        order.setPorint(point);
        order.setProductName(productName);

        requestOrder(order);
    }

    private void validOrder(Order order) throws OrderException {
        // 주문 정보 유효성 체크
    }

    private void requestOrder(Order order) {
        // 주문 실행
    }
}

옷 주문 Service

@Service
public ClothesOrderService extends OrderService {
    private final ClothesProductDao clothesProductDao;
    public ClothesOrderService(UserDao userDao, ClothesProductDao clothesProductDao) {
        super(userDao);
        this.clothesProductDao = clothesProductDao;
    }

    @Override
    ProductType getProductType() {
        return ProductType.Clothes;
    }

    @Override
    int getPoint(String productCode) {
        // 포인트 계산 로직

        return 포인트;
    }

    @Override
    int getProductName(String productCode) {
        // 상품명 조합 로직

        return 상품명;
    }
}

식품 주문 Service

@Service
public FoodOrderService extends OrderService {
    private final FoodProductDao foodProductDao;
    public ClothesOrderService(UserDao userDao, FoodProductDao foodProductDao) {
        super(userDao);
        this.foodProductDao = foodProductDao;
    }

    @Override
    ProductType getProductType() {
        return ProductType.Food;
    }


    @Override
    int getPoint(String productCode) {
        // 포인트 계산 로직

        return 포인트;
    }

    @Override
    int getProductName(String productCode) {
        // 상품명 조합 로직

        return 상품명;
    }
}

주문 Service Factory

@Component
public class OrderServiceFactory {
    private final Map<ProductType, OrderService> orderServiceMap = new HashMap<>();

    public OrderServiceFactory(List<OrderService> orderServices) {
        orderServices.forEach(s -> orderServiceMap.put(s.getOrderType(), s);
    }

    public OrderService getOrderService(ProductType productType) {
        return orderServiceMap.get(productType);
    }   
}

주문 Service Factory 사용

@RequiredArgsConstructor
@RestController
public class OrderController {
    private final ModelMapper modelMapper;
    private final OrderServiceFactory orderServiceFactory;

    @PostMapping("/order")
    public ResponseEntity order(@RequestBody OrderDto.Request requestDto) {
        Order order = modelMapper.map(requestDto, Order.class);
        orderServiceFactory.getOrderService(requestDto.getProductType()).order(order);

        return ResponseEntity.ok();
    }
}

Enum을 활용한 코드 관리시에 반복적으로 사용되는 부분을 공통 유틸로 생성

나는 평소에 Enum을 활용하여 코드를 관리하는 것을 선호한다. Enum으로 관리시에 자주 사용되는 부분을 공통 유틸로 분리하는 패턴을 적용하여 기록한다. 아래 패턴은 조금 더 좋은 아이디어가 있을 때마다 리팩토링하여 업데이트 할 예정이다

일반적으로 사용되는 Enum 반복 사용 패턴 1

@AllArgsConstructor
@Getter
public enum Friut {
    APPLE("AP"),
    BANANA("BN"),
    STRAWBERRY("ST"),
    MANGO("MG"),
    PINEAPPLE("PA");

    private String code;

    public static Friut findBycode(String code) {
        return Arrays.stream(Fruit.values())
            .filter(f -> f.getCode().equals(value))
            .findAny()
            .orElse(Fruit.APPLE);
    }
}

Interface를 활용하여 findByCode 부분 유틸화

• 코드값 관련 인터페이스

  public interface EnumCode {
    String getCode();
  }

• EnumValue 인터페이스 구현 Enum

  @AllArgsConstructor
  @Getter
  public enum Friut implements EnumCode {
    APPLE("AP"),
    BANANA("BN"),
    STRAWBERRY("ST"),
    MANGO("MG"),
    PINEAPPLE("PA");
  
    private String code;
  }

• Enum code find util

  public class EnumFindUtil{
    public static <E extends Enum<E> & EnumCode> Optional<E> findByValue(Class<E> clazz, String value) {
        return Arrays.stream(clazz.getEnumConstants())
            .filter(e -> e.getCode().equals(value)
            .findAny();
    }
  }

• 활용

  Fruit favoriteFruit = EnumFindUtil.findByCode(Fruit.class, "MG").orElse(Fruit.APPLE);

일반적으로 사용되는 Enum 반복 사용 패턴 2

@AllArgsConstructor
@Getter
public enum FruitTypeByColor implements EnumCode, EnumValueList<Fruit> {
    RED_FRUIT("RD", Arrays.asList(FRUIT.APPLE, FRUIT.STRAWBERRY)),
    YELLOW_FRUIT("YL", Arrays.asList(FRUIT.BANANA, FRUIT.MANGO, FRUIT.PINEAPPLE));

    private String code;
    private List<Fruit> valueList;

    public static FruitTypeByColor findByCode(String code) {
        return Arrays.stream(FruitTypeByColor.values())
            .filter(f -> f.getCode().equals(value))
            .findAny()
            .orElseThrow();
    }

    public FruitTypeByColor findByValue(Fruit value){
        return Arrays.stream(FruitTypeByColor.values())
            .filter(e -> hasByValue(e.getValueList(), value))
            .findAny()
            .orElseThrow();
    }

    private boolean hasByValue(List<Fruit> values, Fruit value) {
        return values.stream()
            .anyMatch(e -> e == value);
    }
}

Interface를 활용하여 getValueList 부분 유틸화

• 코드리스트 관련 인터페이스

  public interface EnumValueList<T> {
    List<T> getValueList();
  }

• EnumCodeList 인터페이스 구현 Enum

  @AllArgsConstructor
  @Getter
  public enum FruitTypeByColor implements EnumCode, EnumValueList<Fruit> {
    RED_FRUIT("RD", Arrays.asList(FRUIT.APPLE, FRUIT.STRAWBERRY)),
    YELLOW_FRUIT("YL", Arrays.asList(FRUIT.BANANA, FRUIT.MANGO, FRUIT.PINEAPPLE));
  
    private String code;
    private List<Fruit> valueList;
  }

• Enum code find util

  public class EnumFindUtil{
    public static <E extends Enum<E> & EnumCode> Optional<E> findByCode(Class<E> clazz, String value) {
        return Arrays.stream(clazz.getEnumConstants())
            .filter(e -> e.getCode().equals(value)
            .findAny();
    }
  
    public static <E extends Enum<E> & EnumValueList<C>, C extends Enum<C>> Optional<E> findByValue(Class<E> clazz, C value){
        return Arrays.stream(clazz.getEnumConstants())
            .filter(e -> hasByValue(e.getValueList(), code))
            .findAny();
    }
  
    private static <E extends Enum<E>, C extends Enum<C>> boolean hasByValue(List<E> values, C value) {
        return values.stream()
            .anyMatch(e -> e == value);
    }
  }

• 활용

  FruitTypeByColor favoriteFruit = EnumFindUtil.findByCode(Fruit.class, "RD").orElseThrow();
  FruitTypeByColor fruitType = EnumFindUtil.findByValue(FruitTypeByValue.class, Fruit.APPLE).orElseThrow();

  위 패턴을 활용하여 다양한 적용이 가능할 것으로 보인다

Date d = Date.from(instant);

Set<Rank> faceCards = EnumSet.of(JACK, QUEEN, KING)

BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);

StackWalker luke = StackWalker.getInstance(options);

Object newArray = Array.newInstance(classObject, arrayLen);

FileStore fs = Files.getFileStore(path);

BufferedReader br = Files.newBufferdReader(path);

List<Complaint> litany = Collections.list(legacyLitany);

출처: Effective JAVA

K8S kubeadm 토큰의 유효기간은 24시간까지이다. 토큰 생성시점이 24시간이 지날 경우 유효기간이 지나기에 토큰의 재생성이 필요하다

Master node 접속

$ kubeadm token create --print-join-command
kubeadm join 172.0.0.0:6443 --token rirkqc.j4ir52qccxnyxxlx --discovery-token-ca-cert-hash sha256:09377352f6c32357e21278fc23c3e4c78cbfbdddd4e6d15df7d91b5501c

Worker node 접속

$ kubeadm join 172.0.0.0:6443 --token rirkqc.j4ir52qccxnyxxlx --discovery-token-ca-cert-hash sha256:09377352f6c32357e21278fc23c3e4c78cbfbdddd4e6d15df7d91b5501c

IP는 172.0.0.0으로 표기함. 실제 사용되는 IP와 SUBNET을 적용바람.

🛠 K8S 설치 (각 노드에 모두 동일하게 설치)

k8s 저장소 추가

$ curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
$ sudo chmod -R 777 /etc/apt
$ cat <<EOF> /etc/apt/sources.list.d/kubernetes.list
> deb http://apt.kubernetes.io/ kubernetes-xenial main
> EOF

docker 설치

$ wget -qO- get.docker.com | sh

k8s package 설치

$ sudo apt-get update
$ sudo apt-get install -y kubelet kubeadm kubectl kubernetes-cni

docker 환경설정 변경

ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock구문 뒤에 --exec-opt native.cgroupdriver=systemd를 추가

$ sudo vi /lib/systemd/system/docker.service
[Service]
Type=notify                                                                    
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker                                                
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --exec-opt native.cgroupdriver=systemd
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

$ sudo systemctl daemon-reload
$ sudo systemctl restart docker

🗒 MASTER NODE 설정

cluster 초기화

$ sudo kubeadm init --apiserver-advertise-address 0.0.0.0 --pod-network-cidr=172.0.0.0/16 --ignore-preflight-errors=ALL

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 172.0.0.0:6443 --token gs5zbb.lwpwcaghege7a6cs \
        --discovery-token-ca-cert-hash sha256:0885f23cdbf64b621c53c0c230bd938adf0da057e8039331ae4b6490343bb0ca

• mkdir 시작되는 구문부터 3줄 복사하여 터미널에 입력
• `kubeadm join 172.0.0.0:6443 --token gs5zbb.lwpwcaghege7a6cs \

    --discovery-token-ca-cert-hash sha256:0885f23cdbf64b621c53c0c230bd938adf0da057e8039331ae4b6490343bb0ca`은 worker node에서 master node에 연결하기 위한 명령어

  설치확인

  $ kubectl get nodes
  

NAME STATUS ROLES AGE VERSION ip-172-0-0-0 NotReady control-plane,master 7m13s v1.23.4

## 🗒 WORKER NODE 설정
#### 초기화
```bash
$ sudo kubeadm reset

master node join (master node cluster 초기화시에 생성된 토큰으로)

$ sudo kubeadm join 172.0.0.0:6443 --token p46o53.yf40pnp8mbsd4efe \
        --discovery-token-ca-cert-hash sha256:8464611730f9c9ad87d814993643085146acfbbddddd6bdf28a2ed63a59897eb --ignore-preflight-errors=ALL

master node에서 cluster 구성 확인 (STATUS NotReady)

$ kubectl get nodes
NAME               STATUS     ROLES                  AGE     VERSION
ip-172-0-0-1       NotReady   <none>                 6m34s   v1.23.4
ip-172-0-0-0       NotReady   control-plane,master   28m     v1.23.4
ip-172-0-0-2       NotReady   <none>                 12m     v1.23.4

🗒 MASTER NODE 컨테이너 네트워크 애드온 설정

IP 대역 변경

$ wget https://docs.projectcalico.org/v3.22/manifests/calico.yaml
$ sed -i -e 's?192.168.0.0/16?172.0.0.0/16?g' calico.yaml
$ kubectl apply -f calico.yaml

node 확인 (STATUS Ready 확인)

$ kubectl get nodes
NAME               STATUS     ROLES                  AGE    VERSION
ip-172-0-0-1       Ready      <none>                 33m    v1.23.4
ip-172-0-0-0       Ready      control-plane,master   115m   v1.23.4
ip-172-0-0-2       Ready      <none>                 99m    v1.23.4

1. build.gradle에 내용 추가

bootRun {
   jvmArgs '-Xdebug', '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005'
}

dependencies {
   implementation 'org.springframework.boot:spring-boot-devtools'
}

2. Gradle BootRun 실행

3. Eclipse에서 아래 순서대로 실행

• Debug Configuration
• Remote Java Application
• Connect tab에서 Project 설정 및 port (5005번) 설정

4. Debug 실행

Eclipse

경로: 이클립스경로.Eclipse.ini

-Djavax.net.ssl.trustStore=NUL
-Djavax.net.ssl.trustStoreType=Windows-ROOT 

IntelliJ

경로: IntelliJ경로\idea.properties

java.net.useSystemProxies=true

NPM

경로: C:\Users\사용자계정.npmrc

set=proxy
http://ID:PW@IP:PORT=
proxy=http://ID:PW@IP:PORT/
https-proxy=http://ID:PW@IP:PORT/
strict-ssl=false
registry=http://registry.npmjs.org/

Java8부터 지원한 NPE 방지 wrapper class

// 기존 방식
String name = userRepository.getName();

if (name != null) {
   logic(name);
}

// Optional 사용
Optional.ofNullable(userRepository.getName())
   .ifPresent((n) -> {
      logic(n);
   });

Optional 제대로 활용하기

isPresent()-get() 대신 orElse()/orElseGet() 등 사용

// not good
Optional<String> name = Optional.ofNullable(userRepository.getName());
if (name.isPresent()) {
   return name.get();
} else {
   return null;
}

// good
return Optional.ofNullable(userRepository.getName())
   .orElse(null);

null 대신 isEmpty() 사용

// not good
Optional<String> name = null;

// good
Optional<String> name = Optional.empty();

Optional<Integer> 대신 OptionalInt 사용(int, long, double)

// not good
Optional<Integer> age = Optional.of(userRepository.getAge());

// good
OptionalInt age = OptionalInt.of(userRepository.getAge());

연산이 필요하거나 객체생성이 수행되는 orElse는 orElseGet 사용

// not bad
int userCnt = Optional.ofNullable(userRepository.getUserList())
   .map(List::size)
   .orElse(0);

// not good
Optional<User> user = Optional.ofNullable(userRepository.getUser())
   .orElse(new User());

// good
Optional<User> user = Optional.ofNullable(userRepository.getUser())
   .orElseGet(User::new);

null이 예상되는 경우 of() 대신 ofNullable() 사용

// not good
Optional<User> user = Optional.of(userRepository.getUser()); // null이 반환될 수 있음. NPE 발생.

// good
Optional<User> user = Optional.ofNullable(userRepository.getUser());

필자는 요즘 Clean code에 대해 관심이 많아 위 같은 경우에 대해 어떤 식으로 구현을 하면 좋을지 고민한 끝에 여러 가지 자료를 참조한 끝에 아래와 같이 구현한 정보를 기록하려 한다.

Spring framework 개발환경에서 if문으로 장황스럽게 구현된 코드를 Factory pattern을 활용하여 관리가 용이하도록 변경해보려한다.

아래 코드를 예로 들어보자. 구매한 상품 타입에 따라 포인트 계산식이 달라지는 로직이다.

의류포인트계산 Service

@Service
public class ClothesPointCalculateService {
    public int calculatePoint(PointCalculate pointCalculate) {
        return (int) Math.ceil(pointCalculate.getPrice() * 0.05);
    }
}

식품포인트계산 Service

@Service
public class FoodPointCalculateService {
    public int calculatePoint(PointCalculate pointCalculate) {
        return (int) Math.ceil(pointCalculate.getPrice() * 0.03);
    }
}

전자제품포인트계산 Service

@Service
public class ElectronicsPointCalculateService {
    public int calculatePoint(PointCalculate pointCalculate) {
        return (int) Math.ceil(pointCalculate.getPrice() * 0.10);
    }
}

포인트계산 Test case

@SpringBootTest
class PointCalculateTest {

    private final int PRICE = 10000;

    @Autowired
    private ClothesPointCalculateService clothesPointCalculateService;

    @Autowired
    private FoodPointCalculateService foodPointCalculateService;

    @Autowired
    private ElectronicsPointCalculateService electronicsPointCalculateService;

    @Test
    public void clothesPointCalculate_if_success() {
        assert(calculatePoint(ProductType.CLOTHES) == 500);
    }

    @Test
    public void foodPointCalculate_if_success() {
        assert(calculatePoint(ProductType.FOOD) == 300);
    }

    @Test
    public void electronicsPointCalculate_if_success() {
        assert(calculatePoint(ProductType.ELECTRONICS) == 1000);
    }

    private int calculatePoint(ProductType productType) {
        PointCalculate pointCalculate = PointCalculate.builder()
                .productType(productType)
                .price(PRICE)
                .build();

        if (productType == ProductType.CLOTHES) {
            return clothesPointCalculateService.calculatePoint(pointCalculate);
        } else if (productType == ProductType.FOOD) {
            return foodPointCalculateService.calculatePoint(pointCalculate);
        } else if (productType == ProductType.ELECTRONICS) {
            return electronicsPointCalculateService.calculatePoint(pointCalculate);
        }

        return 0;
    }
}

포인트계산을 사용하는 곳이 당장은 한 군데 밖에 없어 크게 문제될 것이 없다하더라도, 추후 주문/정산/상품상세 등 다양한 곳에서 사용하게 될 수 있고 상품타입도 추가될 수 있다. 상품타입이 추가되면 아래 if문을 사용하는 곳을 모두 찾아 수정하여야한다.

if (productType == ProductType.CLOTHES) {
    return clothesPointCalculateService.calculatePoint(pointCalculate);
} else if (productType == ProductType.FOOD) {
    return foodPointCalculateService.calculatePoint(pointCalculate);
} else if (productType == ProductType.ELECTRONICS) {
    return electronicsPointCalculateService.calculatePoint(pointCalculate);
}

시스템을 운영하는 데 굉장히 비효율적이므로 위에 예시를 든 코드를 Factory Pattern을 활용하여 개선해보자

우선 포인트계산 Service를 인터페이스로 분리하자. (기존에 생성해둔 Service와의 이름이 중복되어 class명 앞에 Factory를 붙였다)

public interface PointCalculateService {
    int calculatePoint(PointCalculate pointCalculate);
    ProductType getProductType();
}

@Service
public class FactoryClothesPointCalculateService implements PointCalculateService {

    @Override
    public int calculatePoint(PointCalculate pointCalculate) {
        return (int) Math.ceil(pointCalculate.getPrice() * 0.05);
    }

    @Override
    public ProductType getProductType() {
        return ProductType.CLOTHES;
    }
}

@Service
public class FactoryElectronicsPointCalculateService implements PointCalculateService {

    @Override
    public int calculatePoint(PointCalculate pointCalculate) {
        return (int) Math.ceil(pointCalculate.getPrice() * 0.10);
    }

    @Override
    public ProductType getProductType() {
        return ProductType.ELECTRONICS;
    }
}

@Service
public class FactoryFoodPointCalculateService implements PointCalculateService {

    @Override
    public int calculatePoint(PointCalculate pointCalculate) {
        return (int) Math.ceil(pointCalculate.getPrice() * 0.03);
    }

    @Override
    public ProductType getProductType() {
        return ProductType.FOOD;
    }
}

이제 포인트계산 Service를 담아사용할 Factory component를 생성하자

포인트계산 Service Factory class

@Component
public class PointCalculateServiceFactory {

    private final Map<ProductType, PointCalculateService> pointCalculateServiceMap = new HashMap<>();

    /**
     * 생성자주입
     * @param pointCalculateServices
     */
    public PointCalculateServiceFactory(List<PointCalculateService> pointCalculateServices) {
        pointCalculateServices.forEach(s -> pointCalculateServiceMap.put(s.getProductType(), s));
    }

    public PointCalculateService getPointCalculateService(ProductType productType) {
        return pointCalculateServiceMap.get(productType);
    }
}

포인트계산 Test cass

@SpringBootTest
class PointCalculateTest {

    private final int PRICE = 10000;

    @Autowired
    private PointCalculateServiceFactory pointCalculateServiceFactory;

    @Test
    public void clothesPointCalculate_if_success() {
        assert(calculatePoint(ProductType.CLOTHES) == 500);
    }

    @Test
    public void foodPointCalculate_if_success() {
        assert(calculatePoint(ProductType.FOOD) == 300);
    }

    @Test
    public void electronicsPointCalculate_if_success() {
        assert(calculatePoint(ProductType.ELECTRONICS) == 1000);
    }

    private int calculatePoint(ProductType productType) {
        PointCalculate pointCalculate = PointCalculate.builder()
                .price(PRICE)
                .productType(productType)
                .build();
        return pointCalculateServiceFactory.getPointCalculateService(productType).calculatePoint(pointCalculate);
    }
}

장황스러운 if문이 아래와 같이 이해하기도 쉽고 유지보수도 용이하도록 변경되었다.

pointCalculateServiceFactory.getPointCalculateService(productType).calculatePoint(pointCalculate);

앞으로는 새로운 포인트계산서비스가 필요할 경우 CalculateService interface를 상속받는 Service bean만 생성해주면 된다.

위 코드는 github에서 확인 할 수 있다.