찰나의 개발흔적

[Exadata day5] exadata 총정리

aonee — Fri, 24 Oct 2025 14:57:07 +0900

Exadata 동작 전반흐름

“필요한 데이터만 위로 보내라”Exadata는
스토리지에서 똑똑하게 걸러(=Smart Scan),
압축을 활용해 I/O를 줄이고(=HCC),
플래시로 빠르게 읽는(=Flash Cache) 구조까지 통합해
엔드-투-엔드로 병목을 낮추는 아키텍처

Exadata 동작 흐름

1) 클라이언트 → DB 서버: “SQL 나왔습니다!”

사용자가 SELECT 같은 SQL을 날립니다.
DB 서버(인스턴스)가 받아서 “이건 Smart Scan으로 스토리지에서 처리시키는 게 유리한가?”를 먼저 판단해요.

2) 오프로딩 결정(iDB 명령 전송)

가능하면 DB 서버는 블록을 통째로 읽지 않고, iDB(Exadata 전용 프로토콜)로 “이런 조건으로 스캔해줘” 라는 명령을 스토리지 셀에게 보냅니다.
이게 바로 Smart Storage/Smart Scan 오프로딩의 시작!

3) Exadata Storage Cell: “필요한 것만 골라드림” (Smart Scan)

스토리지 셀이 디스크/플래시의 데이터 블록을 직접 스캔하면서:

Row Filtering: WHERE 조건에 맞는 행만 추립니다.
Column Projection: SELECT에 필요한 컬럼만 뽑습니다.
일부 조인/집계도 셀 수준에서 처리할 수 있어, DB 서버가 할 일이 줄어요.

➡ 결과적으로 “필요한 것만” 추출되니 네트워크로 오가는 데이터가 확 줄어듭니다.

4) Flash Cache: “자주 쓰면 플래시에서 번개같이”

스토리지 셀은 먼저 Flash Cache(플래시 기반 캐시)를 확인합니다.
자주 읽는 데이터나 최근 접근한 부분은 디스크 대신 플래시에서 고속 읽기가 됩니다.
쓰기 패턴이 아주 강한 경우엔(옵션) Write-back 모드로 플래시에 먼저 기록 후 나중에 디스크로 내립니다.
(Redo 로그는 별도로 Smart Flash Log가 커밋 지연을 줄여줌)

5) HCC(하이브리드 컬럼 압축): “공간도 성능도 아낀다”

DW/아카이브성 대용량 테이블은 종종 HCC로 압축되어 저장됩니다.
스토리지 셀이 압축 해제 및 필터링을 같이 해줘서,
압축된 데이터라도 적은 I/O로 많은 로우를 훑고, 필요분만 DB 서버로 보내요.
즉 “압축 + 오프로딩” 조합으로 디스크→네트워크→DB 서버 모든 구간의 부하를 감소시킵니다.

6) DB 서버: “받아서 마무리”

여러 스토리지 셀에서 온 가벼워진 결과셋을 DB 서버가 합치고(병렬 쿼리 결과 병합과 유사)
나머지 연산(정렬/집계 일부 등)을 마무리합니다.

7) 최종 결과 → 클라이언트

DB 서버가 결과를 클라이언트에게 반환.
블록 덩어리를 잔뜩 끌어오던 전통 방식보다 CPU·네트워크·디스크 I/O가 모두 절약됩니다.
그래서 더 빠른 쿼리, 더 많은 동시 처리가 가능해집니다.

핵심 키워드 한 줄 요약

Smart Storage/Smart Scan: 스토리지에서 미리 걸러서 필요한 것만 위로 보냄
iDB: DB ↔ 스토리지 셀 간 오프로딩 지시용 전용 프로토콜
Flash Cache: 자주 쓰는 데이터를 플래시에 캐싱해 읽기 가속
HCC: 고압축 + 스토리지 측 해제/필터링으로 I/O·네트워크 절감
(보너스) Smart Flash Log: Redo 커밋 지연 감소(OLTP에 효과)

언제 특히 효과적?

풀 스캔이 많은 DW/분석 쿼리: 조건/컬럼을 스토리지에서 미리 정리
대용량 테이블: HCC + Smart Scan으로 읽기량 대폭 감소
자주 반복 조회: Flash Cache로 랜덤 읽기 지연 최소화

언제 덜 쓰일 수 있나?

인덱스 소량 조회(OLTP형, PK=값 하나): 버퍼 캐시 히트가 더 유리할 수 있음
Smart Scan 비대상 객체/연산(예: 일부 LOB/가상컬럼/특정 인덱스 스캔 등)

Exadata와 병렬 처리

✅ Smart Scan: PX Slave가 스토리지에서 필요한 데이터만 읽음 → I/O 대폭 감소
✅ Storage Offloading: 서버로 올라오는 데이터 량 줄임
✅ Flash Cache 병렬 읽기: 플래시에서 초고속 읽기
✅ InfiniBand / RoCE 네트워크: 병렬 노드 간 빠른 데이터 전송

Exadata에서는 병렬 처리를 하면 CPU 부하가 덜하고, 속도 향상이 선형적으로 나오는 경우는 경우가 많음

병렬도(Degree of Parallelism, DOP)

DOP: 병렬로 작업할 PX 프로세스 개수
수동 설정 또는 자동 설정 가능

ALTER TABLE emp PARALLEL 8; -- 테이블에 병렬도 8 설정

또는 SQL 힌트로:

SELECT /*+ PARALLEL(emp, 8) */ * FROM emp;

병렬도 = PX Slave 수
너무 높게 잡으면 CPU 과부하 발생하므로 주의 ⚠️

병렬 처리 관련 주요 파라미터

파라미터설명

PARALLEL_MAX_SERVERS	전체 병렬 Slave 프로세스 최대 수
PARALLEL_MIN_SERVERS	최소 프로세스 수
PARALLEL_DEGREE_POLICY	AUTO / MANUAL 병렬 정책
PARALLEL_MIN_TIME_THRESHOLD	병렬 실행으로 전환되는 기준 시간
PARALLEL_FORCE_LOCAL	병렬 실행 시 로컬 노드만 사용 여부

특히 DW 환경에서는 PARALLEL_DEGREE_POLICY = AUTO 를 많이 사용합니다.

Exadata 병렬 SQL

작성법은 “객체 속성/힌트/세션 설정” 3가지를 쓴다.
대상은 큰 스캔/집계/적재(DW/배치).
Exadata에선 병렬 + Smart Scan/Direct Path/HCC가 맞물리며 효율이 기가 막히게 올라간다.

1) 기본 설정(세션/DB)

-- 자동 병렬화 권장 (Exadata에서 특히 효과적) ALTER SESSION SET parallel_degree_policy = AUTO; -- MANUAL이면 힌트/속성만 적용 ALTER SESSION SET parallel_min_time_threshold = 10; -- 10초↑ 추정 작업만 자동 병렬 -- 병렬 DML 사용할 때 ALTER SESSION ENABLE PARALLEL DML;

팁: 전역 기본값은 DBA가 PARALLEL_DEGREE_POLICY=AUTO 로 운영 설계하는 게 보통입니다.

2) 객체/SQL 단위 병렬 지정

(A) 객체(테이블/인덱스)에 병렬 속성 부여

ALTER TABLE sales PARALLEL 8; -- 테이블 기본 병렬도(DOP) 8 ALTER INDEX sales_idx PARALLEL 8; -- 해제: ALTER TABLE sales NOPARALLEL;

(B) SQL 힌트로 병렬 지정(가장 흔함)

-- 대용량 SELECT SELECT /*+ PARALLEL(sales, 8) */ * FROM sales WHERE txn_date >= DATE '2025-01-01'; -- CTAS (Create Table As Select) CREATE TABLE sales_y25 NOLOGGING PARALLEL 16 AS SELECT /*+ PARALLEL(16) */ * FROM sales WHERE txn_date >= DATE '2025-01-01'; -- INSERT APPEND (Direct Path + 병렬 적재) ALTER SESSION ENABLE PARALLEL DML; INSERT /*+ APPEND PARALLEL(sales_y25, 16) */ INTO sales_y25 SELECT /*+ PARALLEL(sales, 16) */ * FROM sales WHERE txn_date >= DATE '2025-01-01'; -- 병렬 UPDATE/DELETE ALTER SESSION ENABLE PARALLEL DML; UPDATE /*+ PARALLEL(orders, 8) */ orders SET status = 'CLOSED' WHERE order_dt < SYSDATE - 90; DELETE /*+ PARALLEL(orders, 8) */ FROM orders WHERE order_dt < SYSDATE - 365;

실무 팁: 대량 로딩은 INSERT /*+ APPEND PARALLEL */ + NOLOGGING(복구정책 확인) 조합을 많이 씁니다.

3) 분배 전략 힌트(PX간 데이터 이동 최적화)

-- 조인 키 기준 해시 분배(많이 씀) SELECT /*+ PARALLEL(orders, 16) PARALLEL(customers, 16) PQ_DISTRIBUTE(orders HASH, customers HASH) */ ... FROM orders JOIN customers USING(customer_id); -- 작은 테이블 브로드캐스트(큰 테이블 스캔 최소화) SELECT /*+ PARALLEL(big_t, 16) PARALLEL(dim_t, 16) PQ_DISTRIBUTE(dim_t BROADCAST, big_t HASH) */ ... FROM big_t JOIN dim_t USING(key);

파티션 테이블이면 Partition-wise Join(자연스럽게 발생)으로 데이터 재분배 최소화 → 성능↑

4) Exadata에서 잘 먹히는 패턴

큰 범위 스캔 + PARALLEL → Smart Scan 오프로딩으로 서버로 올라오는 데이터가 확 줄어듦
Direct Path(APPEND, CTAS) → 버퍼캐시 우회 + 플래시/디스크 순차 읽기 최적
여러 파일/파티션 → PX 슬레이브가 일감을 잘 나눠 가짐
HCC(압축 테이블) → 스토리지에서 압축 해제+필터링, 병렬 스캔 효율 극대화

5) 모니터링/검증

-- 실행계획에 PX 단계 확인 SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY_CURSOR(NULL, NULL, 'ALLSTATS LAST +PARALLEL')); -- PX 통계: 어떤 TQ(전송 큐)로 어떻게 분배됐는지 확인 SELECT * FROM V$PQ_TQSTAT; -- 세션/시스템 병렬 서버 현황 SELECT * FROM V$PX_SESSION; SELECT * FROM V$PX_PROCESS;

계획에서 PX COORDINATOR, PX SEND/RECEIVE, PX PARTITION 등이 보이면 병렬이 제대로 동작 중.

6) 성능/안정성 체크리스트

대상 선정: 수백 GB~TB급 스캔·집계/적재 작업에만 병렬. OLTP 단건 처리는 비권장.
DOP(병렬도): 코어수·I/O·동시 작업 수를 고려. 과도한 DOP는 경합/스케줄 지연 초래.
리소스 관리:
- PARALLEL_MAX_SERVERS(총 PX 한도), PARALLEL_SERVERS_TARGET(소프트 한도)
- 멀티테넌트/PDB라면 리소스 매니저 + IORM로 DB/PDB별 공정성 보장
TEMP/UNDO 여유: 대용량 집계/정렬/조인 시 Temp·Undo 사용량 크게 증가
LOGGING 정책: 대량 적재에서 NOLOGGING은 빠르지만 복구 전략(백업) 필수
통계 최신화: 잘못된 카디널리티로 병렬/분배 전략이 꼬이지 않게 통계 갱신
소테이블 브로드캐스트 주의: 작은 줄 알았던 테이블이 커지면 오히려 병목 → 분배 전략 재점검

7) 자주 쓰는 스니펫 모음

-- ① 테이블 기본 병렬도와 NOLOGGING ALTER TABLE fact_sales PARALLEL 16 NOLOGGING; -- ② CTAS로 분할/정렬까지 한 번에 CREATE TABLE fact_sales_y25 PARALLEL 16 NOLOGGING TABLESPACE data_ts AS SELECT /*+ PARALLEL(16) */ /* 필요한 컬럼만 선택 + 파티션 키 기준 정렬/필요 시 가공 */ * FROM fact_sales WHERE sales_dt >= DATE '2025-01-01'; -- ③ 인덱스 병렬 생성 CREATE INDEX fact_sales_y25_ix1 ON fact_sales_y25(customer_id) PARALLEL 16 NOLOGGING; -- ④ 병렬 MERGE (대량 업서트) ALTER SESSION ENABLE PARALLEL DML; MERGE /*+ PARALLEL(t, 12) PARALLEL(s, 12) */ INTO tgt t USING src s ON (t.key = s.key) WHEN MATCHED THEN UPDATE SET ... WHEN NOT MATCHED THEN INSERT (...); -- ⑤ 큰 조인에서 분배 전략 명시 SELECT /*+ PARALLEL(a, 12) PARALLEL(b, 12) PQ_DISTRIBUTE(a HASH, b HASH) */ ... FROM big_a a JOIN big_b b ON b.k = a.k;

[Exadata day4] 통합운영 아키텍처, 마이그레이션, 대용량 데이터 로딩, 모니터링

aonee — Thu, 23 Oct 2025 16:44:38 +0900

10~12장: 운영 및 데이터 로딩

10장: Consolidation 전략 및 권장 아키텍처
11장: 데이터베이스 마이그레이션 방법(논리/물리적)
12장: 대용량 데이터 로딩(DBFS, ACFS, 외부 파일 시스템)

️ 13~16장: 모니터링

13장: Exadata Database Machine Platform Monitoring :: 엑사데이터머신
14장: Monitoring Exadata System Software Components :: 엑사 시스템 소프트웨어 구성요소
15장: Configuring Enterprise Manager Cloud Control to Monitor Exadata Database Machine ::
16장: Monitoring Exadata Storage Servers

오늘 배운 내용 요약정리

10장: Consolidation 전략 및 권장 아키텍처

=

1. Consolidation(통합)의 목적

비용 절감: 하드웨어, 라이선스, 운영 인력 효율화
자원 효율 극대화: CPU, 메모리, I/O 활용도 향상
관리 표준화: 패치·백업·보안 정책 단일화

2. 권장 아키텍처 유형

방식설명특징

멀티테넌트(CDB/PDB)	한 인스턴스에 여러 PDB 운영	경량·패치 일원화·신속 마이그레이션
스키마 통합	하나의 DB 인스턴스에 여러 스키마	단순하지만 격리성 약함
VM 기반 통합	KVM 가상화 활용	격리성↑, 자원 분리 명확
Bare Metal	전통적 단일 DB 인스턴스 통합	단순하나 유연성↓

Exadata 권장 통합 방식: 멀티테넌트 + Instance Caging + IORM

3. CPU 및 메모리 통합 전략

CPU_COUNT로 Instance Caging 설정 → 자원 분배/보장
오버프로비저닝 vs 파티셔닝
- 오버프로비저닝: 자원 공유(성능 민감도 낮은 DB에 적합)
- 파티셔닝: 자원 보장(핵심 업무 DB에 적합)
메모리는 전체 물리 메모리의 75~85% 이내만 사용 권장

4. I/O Resource Management (IORM)

여러 DB가 공존할 때 디스크 I/O 자원 보장을 위한 핵심 기능
DB별·PDB별 IORM plan 설정 → 특정 DB의 과도한 I/O 점유 방지

program -> process (자원(cpu, memory)할당받은 상태)->thread

프로세스할당상태 : program -> mainmemory (RAM) <- cpu

자원 부족하면 LRU 기반으로 관리. 내보내는 작업 swap(HDD, SDD) swapping 잦으면 성능 down

11장: 데이터베이스 마이그레이션 방법(논리/물리적)

1. 마이그레이션 설계 순서

소스 DB 아키텍처 파악 (CDB or Non-CDB, OS/Endian, 캐릭터셋)
타깃 Exadata 용량 계획
Downtime 허용 여부 판단
마이그레이션 방식 결정
테스트 후 실제 이관

2. 물리적 마이그레이션 (Physical)

특징: 구조 변경 없음, 빠르고 안정적, 다운타임 짧음

방식설명장점제약

RMAN	백업/복구 또는 Duplicate 활용	안정성 높음	OS/Endian 호환 필수
Data Guard	Physical Standby 구성 후 switchover	실시간, 다운타임 최소	라이선스 필요, 구성 복잡
TTS/TTDB	테이블스페이스 단위 또는 전체 DB 이관	가장 빠른 방법	TTDB는 Endian 동일 필요, TTS는 RMAN CONVERT로 엔디언 변환 가능

실무에서 가장 많이 쓰는 조합

TTS로 bulk 이관 + GoldenGate로 동기화 + Cutover

3. 논리적 마이그레이션 (Logical)

특징: 구조 변경 가능, 유연하지만 느림

방식설명장점제약

Data Pump (expdp/impdp)	구조·데이터 논리적 덤프	버전 호환 유연	대용량 시 느림
Insert as Select (DB Link)	네트워크 통해 직접 적재	별도 파일 불필요	다운타임 발생 가능
Logical Standby	SQL apply 기반 실시간 복제	다운타임 최소	제약 많고 구성 복잡
GoldenGate	실시간 복제	다운타임 최소	추가 라이선스 필요

4. 멀티테넌트 환경 이관

Non-CDB → CDB 이관:
- Unplug/Plug + Non-CDB to PDB 변환
CDB → CDB 간:
- Unplug/Plug PDB
- 다운타임 최소, 가장 빠른 방식 중 하나

멀티테넌트 구조에서는 마이그레이션 절차가 단순화되는 것이 큰 장점입니다.

12장: 대용량 데이터 로딩(DBFS, ACFS, 외부 파일 시스템)

1. Exadata에서 대용량 적재 시 고려 사항

병렬성 확보 (Granule 단위 병렬 처리)
압축 파일은 병렬 granule 불가 → 미리 압축 해제 권장
I/O 대역폭 최대로 활용하기 위해 Direct Path Load 적극 활용

2. DBFS / ACFS / 외부 파일 시스템 차이

파일시스템설명특징사용 예

DBFS	DB 테이블에 저장된 파일을 파일처럼 접근	안정성, 백업 용이, 성능은 다소 낮음	소규모 파일, 안정성 중요
ACFS	ASM 기반 범용 파일시스템	Exadata에서 가장 권장되는 파일 시스템	대용량 CSV, 데이터 적재
외부 FS(NFS 등)	외부 스토리지 마운트	간편, 병렬 처리는 가능하지만 네트워크 병목 주의	임시 적재/ETL

실무에서는 ACFS가 대용량 로딩 표준

3. 외부 테이블 & 병렬 Granule

Granule 크기: 기본 10MB
Granule 생성 불가: 압축 파일, 시리얼 디바이스
병렬도는 granule 수 or 파일 개수로 결정됨
여러 파일로 나누는 것이 병렬 처리에 유리

CREATE TABLE ext_data ( id NUMBER, name VARCHAR2(50) ) ORGANIZATION EXTERNAL ( TYPE ORACLE_LOADER DEFAULT DIRECTORY acfs_dir ACCESS PARAMETERS ( RECORDS DELIMITED BY NEWLINE FIELDS TERMINATED BY ',' ) LOCATION ('file1.csv', 'file2.csv', 'file3.csv') ) PARALLEL 8;

4. 로딩 성능 향상 팁

Direct Path Load (INSERT /*+ APPEND PARALLEL */)
ACFS + 여러 파일 + Granule 기반 병렬 적재
로딩 후 NOLOGGING 옵션 사용 시 redo 감소
임시 인덱스 생성 지연 (로딩 후 생성)
압축 사용 지양 (병렬 granule 분할 불가)

최종 핵심 포인트 요약

구분핵심 개념키워드

10장	통합 전략	멀티테넌트, Instance Caging, IORM, 자원 보장
11장	마이그레이션	TTS, RMAN, Data Pump, GoldenGate, 논리 vs 물리
12장	대용량 적재	Granule 10MB, ACFS 권장, 병렬 적재, Direct Path Load

실무 TIP

Consolidation 설계 단계에서 자원(CPU/메모리/I/O) 분배를 확정해두면 나중에 마이그레이션, 로딩 작업이 훨씬 수월합니다.
Exadata의 병렬성과 Smart Scan은 “파일 준비” 단계에서 대부분 성능이 결정됩니다

10장 Consolidation Options and Recommendations

Exadata 운영·통합 핵심 정리

1) 메모리 운영 원칙

전체 서버 기준 여유 메모리: 항상 **최소 5%**는 남겨두기
DB들이 합쳐 쓰는 상한: RAM의 75~85% 이내 (권장 상한 = 85%)
초기 배분 감각: 통합 환경이면 주요 DB 1개당 ~40~45% 수준에서 시작해 점증(다른 작업/OS 여유 고려)

HugePages(=대페이지) 필수

기본 4KB 대신 2MB 페이지로 메모리 할당 → TLB 미스↓, 스왑 방지
DB 파라미터:
- USE_LARGE_PAGES=ONLY (권장; HugePages 없으면 기동 실패해서 설정 누락 방지)
- 주의: HugePages 사용 시 AMM(Automatic Memory Management) 미지원 → ASMM(SGA_TARGET/ PGA_AGG…)으로 운용

메모리 계산(러프 가이드)

OLTP: 총 메모리 ≈ SGA + PGA + (PROCESSES × 4MB 오버헤드)
DW: 병렬·해시/정렬 많아 PGA 3배 가중
- 총 메모리 ≈ SGA + (PGA × 3) + (PROCESSES × 4MB)
PGA 관련
- 목표치: PGA_AGGREGATE_TARGET
- 하드 상한: PGA_AGGREGATE_LIMIT

2) OS 커널 파라미터(리눅스) 요령

공유메모리 식별자 수: kernel.shmmni > DB 개수
최대 공유메모리 세그먼트 크기: kernel.shmmax ≈ RAM의 85%
세마포어 (kernel.sem = SEMMSL SEMMNS SEMOPM SEMMNI)
- SEMMNS(시스템 총 세마포) ≥ 모든 DB의 PROCESSES 합
- SEMMSL(집합당 최대 세마포) ≥ 가장 큰 DB의 PROCESSES
요지는: OS 세마포 한도 ≥ DB 프로세스 수요

3) 프로세스/세션·병렬 관리 베스트프랙티스

PROCESSES(동시 접속 한도; DB 파라미터)

2~10개 DB 통합: 50 + (50 × DB개수)
11개 이상: 450 + (10 × DB개수)

병렬 서버 상한

2소켓 서버: 모든 DB의 PARALLEL_MAX_SERVERS 합 ≤ 240
8소켓 서버: 합 ≤ 1280
Data Guard redo apply 병렬 ≤ 16

활성 세션(프로세스) 밀도

일반 워크로드: Active ≤ 5 × CPU_COUNT
매우 CPU집약: Active ≤ 1 × CPU_COUNT

연결 관리

커넥션 풀(UCP/Hikari 등) 사용
필요 시 Shared Server(공유 서버) 로 프로세스 감소
연결 폭주(rate limit) 방지(미들웨어/리스너/Firewall 레벨)

4) CPU 자원 분배: Instance Caging

DB별 CPU_COUNT로 코어 할당 (DB 리소스 매니지먼트의 핵심)
두 방식
- 파티션(보장): 총합 ≤ 물리 코어 → 항상 보장(미션 크리티컬)
- 오버프로비저닝: 총합이 물리 코어 초과 가능 → 유휴 코어 공유(비크리티컬)
권장
- DB별 CPU_COUNT 최소 2 이상
- 중요 DB의 합계 ≤ 물리 코어
- 덜 중요한 DB는 최대 3배수 내에서 오버프로비저닝 가능
- 하드 캡 필요 시 Resource Manager의 MAX_UTILIZATION_LIMIT로 상한

5) HugePages & 스와핑 이야기 (이해 포인트)

프로세스가 많아지고 메모리가 부족하면 swap-out/swap-in 발생 → 지연↑
HugePages(2MB) 사용 + USE_LARGE_PAGES=ONLY →
- 스왑 사실상 차단, 메모리 파편화↓, 대용량 SGA 안정화

6) 스토리지·보안·역할 분리

DB(oracle) vs ASM(grid) OS 계정/그룹 분리(권한·보안·책임 분리)
백업/FRA 용량 사전 확보, IORM 정책 검토(우선순위)
인덱스 전략 재검토(Exadata Smart Scan과 병행)

7) 가상화(KVM) 통합 포인트

Exadata X8M+는 KVM 권장, SR-IOV로 RoCE 성능 근접
VM 단위로 CPU/메모리 지정, 라이선스도 VM 단위
DB마다 VM 1개씩은 오버헤드↑ → 업무/조직 단위로 적절히 통합

8) 멀티테넌트(PDB) 마이그레이션이 쉬운 이유

Unplug/Plug 으로 PDB 단위 이동 → 속도↑, 다운타임↓
여러 PDB 병렬 이관 가능, 패치/업그레이드 일괄 관리 용이

9) 마이그레이션 옵션 단기 비교표

유형예장점유의점

물리계열	RMAN(Backup/Duplicate), Data Guard Physical, TTS/TTDB	다운타임 최소(특히 DG), TTS 가장 빠름	TTDB는 엔디언 불가, TTS는 RMAN으로 엔디언 변환 필요 시 처리
논리계열	Data Pump, Logical Standby, INSERT…SELECT, GoldenGate	구조 재구성/버전 간 유연	변환/적재 시간, 논리 변환 이슈

실무 상: 초기 대량은 TTS/파일적재(External/SQL*Loader), 변경분 동기화는 GoldenGate로 혼합이 가장 흔함.

10) 파일 적재(External Table) 성능 팁

10MB granule 자동 분할로 병렬 읽기
압축 파일은 granule 불가 → 풀고 적재
여러 파일, 비슷한 크기, External LOCATION은 큰 파일→작은 파일 순
Direct Path / APPEND / 병렬 옵션 적극 활용

13장: Exadata Database Machine Platform Monitoring (플랫폼 모니터링)

1. 모니터링 목적

하드웨어 + 소프트웨어 스택을 엔드 투 엔드(End-to-End) 로 감시
(DB ↔ Storage ↔ Infiniband ↔ Cell ↔ OS ↔ Network)
장애 징후 조기 발견 및 가용성 확보

2. 주요 모니터링 계층

계층대상도구

데이터베이스	인스턴스, PDB, SQL, I/O 대기	AWR, ASH, OEM
스토리지	셀 서버, 디스크, 플래시	CellCLI, OEM
네트워크	InfiniBand, RoCE, 이더넷	ibstat, nm2env, OEM
플랫폼	노드 상태, 하드웨어 센서	ILOM, dcli, ipmitool

3. 표준 모니터링 방법

AWR / ADDM: DB 성능 및 리소스 병목
dcli: 여러 노드에 명령 병렬 실행 (Exadata 표준 툴)
ILOM (Integrated Lights Out Manager): HW 상태 및 장애 알람
OS Watcher: CPU/Memory/Network I/O 추적

모니터링을 계층별로 나눠서 보는 게 핵심입니다. (DB → Storage → Network → HW)

14장: Monitoring Exadata System Software Components

1. 구성요소

구성 요소역할

Cell Server (CELLSRV)	Smart Scan, I/O 요청 처리
Management Server (MS)	모니터링·알림·상태 정보 수집
RS (Restart Server)	프로세스 감시·자동 재시작
ibsw / RoCE	InfiniBand 또는 RoCE 네트워크 계층

2. 주요 모니터링 명령어

cellcli -e "LIST ALERTHISTORY" : 알람 이력 확인
cellcli -e "LIST METRICCURRENT" : 실시간 메트릭
cellcli -e "LIST METRICHISTORY" : 히스토리 메트릭
cellcli -e "LIST THRESHOLD" : 임계치 설정 조회
cellcli -e "ALTER THRESHOLD" : 경보 조건 조정

Storage Cell 단의 메트릭 기반 알람 시스템을 정확히 이해하는 게 중요합니다.

3. 모니터링 포인트

CELLSRV 상태 및 재시작 이력
플래시 캐시 Hit Ratio
디스크 리빌드 상태
네트워크 연결 이상
SMART 알람(디스크 HW 이슈)

Exadata의 고가용성은 RS + MS + Threshold 알람에 크게 의존합니다.

15장: Configuring Oracle Enterprise Manager Cloud Control to Monitor Exadata

1. OEM(Cloud Control) 통합 모니터링 목적

DB + Storage + Network + HW를 한 눈에
알람 통합 관리 (Threshold & Notification)
Capacity Planning 및 성능 분석 지원

2. 구성 요소

구성 요소역할

OEM Server	중앙 관리 서버
OMS Agent	각 노드/스토리지에서 데이터 수집
Plug-in for Exadata	Exadata 전용 메트릭 및 상태 수집
Notification Rules	경보 알림 설정

3. 설정 절차

OMS Agent를 모든 DB Node 및 Storage Cell에 배포
Exadata Plug-in 설치 및 등록
DB, Storage, Network 컴포넌트를 OEM에 등록
경보 정책(Notification Rule) 설정
대시보드 / Capacity Planning 활성화

실무에서는 OEM을 통해 알람 자동화 + 통합 모니터링하는 환경이 표준입니다.

4. OEM에서 주로 보는 지표

DB 성능 (AWR 기반)
Storage Server 메트릭 (IOPS, Flash Cache)
Infiniband 상태
HW 센서(온도/팬/전원)
알람 이벤트

16장: Monitoring Exadata Storage Servers

1. Storage Server 주요 컴포넌트

CELLSRV (I/O 처리)
MS (상태 관리/메트릭)
RS (Restart)
디스크 / 플래시 / IB 인터페이스

2. 주요 모니터링 툴

도구특징

CellCLI	Storage Cell 관리 기본 툴
dcli	다중 노드 명령 병렬 실행
ExaCLI	OEM Agent 없이 로컬 CLI
Metric/Threshold	자동 경보 시스템

# 알람 조회 cellcli -e "LIST ALERTHISTORY" # 현재 메트릭 cellcli -e "LIST METRICCURRENT" # 임계치 cellcli -e "LIST THRESHOLD"

3. Storage Server에서 중요한 지표

I/O 지표
- IOPS / MBPS / Latency
- Flash Cache Hit Ratio
디스크 상태
- Predictive Failures, Rebuild Progress
네트워크 상태
- IB/RoCE 장애 여부
알람 이력
- Threshold, 디스크 SMART 경보

특히 “Flash Cache Hit Ratio”는 Exadata 성능을 좌우하는 대표 지표입니다.

4. 알람 및 장애 대응

임계치(Threshold)는 Cell 수준에서 설정 가능
알람 발생 시 OEM / CLI에서 바로 확인 가능
RS 프로세스가 CELLSRV 자동 재시작 → 가용성 유지
디스크 실패 시 ASM redundancy로 서비스 지속

최종 핵심 포인트 요약

장주제핵심 키워드

13장	플랫폼 모니터링	End-to-End 모니터링, ILOM, dcli, OS Watcher
14장	SW 컴포넌트	CELLSRV / MS / RS / Threshold Alerts
15장	OEM 연동	Plug-in, 알람 자동화, Capacity Dashboard
16장	스토리지 모니터링	CellCLI, dcli, Flash Cache Hit Ratio, IOPS, Threshold

실무 TIP

운영팀은 대부분 ① CLI + ② OEM + ③ 알람 메일 조합으로 운영합니다.
특히 Storage Cell의 Alert/Metric은 장애 사전 방지의 핵심입니다.
Exadata 성능 이슈 대부분은 DB가 아니라 Storage Layer에서 시작됩니다.

11장 Migrating Databases to Exadata Database Machine

Oracle Exadata 도입 시 가장 헷갈리기 쉬운 부분 중 하나가 바로 “기존 스토리지 용량/성능”과 “Exadata 스토리지 용량/성능”의 차이를 제대로 이해하고 용량 계획(capacity planning) 을 세우는 것입니다.

아래는 이 내용을 쉽고 실무적으로 정리한 가이드입니다

1. 왜 용량 계획(capacity planning)이 중요한가?

Exadata는 단순히 디스크 용량만 보고 설계하는 장비가 아닙니다.
✅ I/O 성능(IOPS, MBPS)
✅ Smart Flash Cache / PMEM 등 가속 기능
✅ 장애 상황 시 리던던시(ASM redundancy) 용량까지
→ 모두 고려해야만 안정적인 성능과 가용성을 보장할 수 있어요.

“단순 디스크 크기만 보고 마이그레이션하면 성능이 안 나올 수 있다” 는 게 핵심 경고입니다.

2. 현재 시스템 I/O 특성 파악이 첫 단계

수집해야 할 핵심 지표

지표설명수집 방법

IOPS (I/Os per second)	초당 읽기/쓰기 횟수	AWR에서 physical reads, physical writes
MBPS (MB per second)	초당 처리되는 데이터 양	AWR에서 physical I/O disk bytes
데이터 총량	디스크 실제 사용 용량	OS, DB 또는 스토리지 툴
Peak 시점 I/O 부하	평균이 아닌 피크 구간 기준	AWR Top Activity / peak 시간대 기준

AWR 예시 쿼리

SELECT (physical_read_bytes + physical_write_bytes) / (1024*1024) AS MBPS, (physical_reads + physical_writes) AS IOPS FROM v$sysstat WHERE name IN ('physical reads','physical writes','physical write total bytes','physical read total bytes');

또는 AWR Report → “Instance Activity Stats” 섹션에서도 직접 확인 가능.

⚡ 3. Exadata 스토리지의 특성 이해

항목기존 스토리지Exadata

구조	일반 SAN/NAS	Smart Flash + Disk + PMEM
IOPS/MBPS	디스크 성능에 종속	Flash Cache, PMEM, RoCE로 대폭 향상
데이터 압축	제한적	Hybrid Columnar Compression 지원
장애 허용	보통 RAID	ASM Redundancy + Cell Failover
네트워크	TCP/IP	RoCE (RDMA over Converged Ethernet) 초저지연

Exadata는 같은 물리 디스크 용량이라도 실제로는 더 높은 처리량(Throughput) 을 낼 수 있습니다.
예: 기존 SAN 20TB = Exadata 20TB보다 I/O 성능이 훨씬 낮을 가능성 큼.

4. Exadata 용량 산정 단계별 가이드

Step 1. 현재 시스템 파악

AWR에서 Peak IOPS, MBPS, 총 데이터 사이즈 추출

Step 2. Exadata 모델 스펙 확인

공식 스펙: oracle.com/exadata
노드 수, Flash 용량, 디스크 용량, I/O 처리 성능(I/O bandwidth, IOPS)

Step 3. ✨ 성능 최적화 요소 반영

Smart Flash Cache → 디스크 부하 감소
Hybrid Columnar Compression → 용량 절감 (최대 10배 이상 가능)
PMEM / RoCE → 읽기 지연시간 대폭 감소

예: 현재 100TB 데이터를 압축해 Exadata에서는 30~40TB만 필요할 수도 있음.

Step 4. 장애 상황 고려 (Redundancy)

ASM NORMAL 또는 HIGH Redundancy 적용 시
→ 실사용 가능한 스토리지가 줄어듭니다

ASM 모드사용 가능 용량 비율설명

NORMAL	약 50%	2중 미러
HIGH	약 33%	3중 미러

예: 100TB RAW 용량 → NORMAL redundancy 사용 시 실사용 약 50TB

Step 5. ⚠️ 장애 후 I/O 성능 여유 확보

Cell 1~2대 장애 상황에서도 요구 IOPS/MBPS를 충족해야 함
Peak 기준 I/O에 여유 버퍼(보통 20~30%)를 더해 산정

5. Smart Flash Cache / Compression 고려 예시

항목기존Exadata 적용 후 (예시)

원본 데이터	100TB	100TB
Hybrid Compression 적용	-	40TB
Smart Flash Cache Hit	-	70~80% 디스크 오프로드
필요 디스크 용량	100TB	약 50TB (Redundancy 포함)
Peak MBPS	4GB/s	Flash+RoCE로 더 적은 디스크 부하

같은 데이터를 훨씬 작은 물리 용량과 더 적은 디스크 I/O로 처리 가능하게 됨.

6. 핵심 체크리스트

AWR에서 현재 Peak IOPS / MBPS 확보했는가?
실제 데이터 용량과 성장률을 반영했는가?
Exadata의 Flash / PMEM / Compression 효과를 반영했는가?
Redundancy 적용 후 실사용 용량을 계산했는가?
장애 상황에서도 SLA를 충족할 수 있는 I/O 여유를 뒀는가?

✅ 요약 정리

포인트설명

현황 파악	AWR로 IOPS·MBPS·용량을 정확히 수집
Exadata sizing	성능 + 용량 + 장애 대비까지 고려해야 함
✨ 최적화 기능 반영	Flash Cache, PMEM, HCC 압축으로 실제 요구 용량 줄이기
⚠️ Redundancy 감안	NORMAL/HIGH 모드에 따라 실사용 용량이 줄어듦
여유 확보	장애 후에도 SLA 충족할 여유 성능 확보 필수

정리하자면, Exadata는 단순 디스크 용량 비교가 아니라,
✅ IOPS·MBPS·압축 효과·Flash 활용도·장애 허용력까지 함께 계산해야 올바른 용량 계획이 가능합니다.

TTS (Transportable Tablespace)
한 데이터베이스의 테이블스페이스를 통째로 다른 데이터베이스로 이관하는 기능

개념

테이블스페이스를 익스포트(export) 해서
다른 DB에서 임포트(import) 하는 방식으로 빠른 데이터 마이그레이션이 가능.
데이터 파일 그대로 복사하기 때문에 Data Pump만 쓰는 것보다 훨씬 빠름.

TTS 특징

항목설명

대상	테이블스페이스 단위
방식	메타데이터 Export + 데이터파일 복사
속도	빠름 (파일 직접 이동)
주 용도	마이그레이션 / 클론 / 아카이브
조건	플랫폼 엔디언(Endian) 확인 필요 (다르면 변환 필요)

예: 운영 DB의 특정 테이블스페이스만 다른 DW 서버로 옮길 때 자주 사용합니다.

Exadata Migration Considerations

Oracle Exadata 로 마이그레이션할 때는 단순히 DB만 옮기면 되는 게 아니라, Exadata 전용 성능 최적화 설정 및 호환성 조건을 충족해야 합니다. 아래에 핵심 요구사항과 추천 설정을 이유와 함께 정리해드릴게요

1. 플랫폼 및 아키텍처 기본 사항

항목설명의미

플랫폼	64비트 Intel 기반	32비트 OS나 DB는 Exadata에서 지원되지 않음
엔디언(Endian)	Little Endian	기존 플랫폼이 Big Endian이면 마이그레이션 시 endian 변환 필요

예: 기존이 SPARC(Solaris) Big Endian 환경이라면 RMAN CONVERT나 Data Pump 방식 등 endian 변환 작업이 필요합니다.

2. 소프트웨어 호환성 요구사항

Exadata Storage Server, ASM(Automatic Storage Management), 그리고 DB 소프트웨어 버전은 반드시 서로 호환되는 버전이어야 합니다.
예: Oracle Exadata X8M 의 경우 [Doc ID 2724126.1]에 권장 버전이 명시되어 있음.

✅ 팁: 마이그레이션 전 버전 정합성 점검이 필수입니다.
특히 PDB/CDB 환경을 쓰는 경우 ASM/Storage Server 버전도 꼼꼼히 확인해야 합니다.

⚙️ 3. ASM Disk Group 권장 설정

Exadata에서 ASM Disk Group을 구성할 때는 다음과 같은 설정을 강력 권장합니다

속성권장 값설명

AU_SIZE	4 MB	Smart Scan 최적화 (4MB 단위로 효율적 읽기)
COMPATIBLE.ASM	DB 버전과 동일 이상	Exadata 기능 활성화
COMPATIBLE.RDBMS	DB 버전과 동일 이상	Smart Scan 등 고급 기능 활성화 가능
cell.smart_scan_capable	TRUE	Smart Scan 가능 여부 지정

AU_SIZE를 4MB로 하면 Exadata의 Smart Scan이 대용량 연속 스캔(>=4MB) 을 효율적으로 처리할 수 있어 Flash Cache 및 I/O 성능이 극대화됩니다.

4. DB 초기화 파라미터 설정 (필수)

파라미터권장값설명

COMPATIBLE	11.2.0.1 이상	Exadata 기능 전체 사용을 위해 필수
DB_BLOCK_CHECKSUM	TYPICAL 또는 FULL	Exadata HARD(하드웨어 체크섬) 기능 활용
DB_BLOCK_SIZE	8 KB (기본값)	일반적으로 그대로 사용
DB_CREATE_FILE_DEST	ASM 경로 사용	Exadata 환경 표준

DB_BLOCK_CHECKSUM을 켜두면 블록 손상 여부를 하드웨어 차원에서 빠르게 탐지할 수 있어 안정성이 높아집니다.

5. Extent Size 및 I/O 최적화

Exadata는 최소 4MB 이상의 연속적인 스캔에서 최고의 성능을 냅니다.
따라서:
- ASM AU_SIZE = 4MB
- DB Extent Size는 AU_SIZE의 배수(8MB, 16MB 등)로 설정 권장
- 대용량 테이블스페이스는 Extent 크기를 키워 Smart Scan 효율 증가

예: DW 환경에서 8MB Extent로 설정하면 디스크 I/O 오버헤드를 줄이고 Smart Scan 처리량을 극대화할 수 있습니다.

6. 추가 고려사항

항목설명

버전 호환성	ASM, Storage Server, DB 모두 권장 버전으로 업그레이드
데이터 변환	Big Endian → Little Endian 마이그레이션 시 사전 변환 필수
압축	Hybrid Columnar Compression 활성화 가능 (특히 DW 환경에서 효과 큼)
Redundancy	ASM NORMAL 또는 HIGH 모드 적용 (장애 대비)
Smart Scan	테이블/쿼리 구조가 연속 스캔에 유리해야 최대 성능 발휘

✅ 요약 정리

항목권장 설정 / 요구 사항이유

플랫폼	64bit, Little Endian	호환성 필수
소프트웨어	ASM / Storage Server / DB 버전 일치	Smart Scan 및 Flash 기능 활성화
ASM AU_SIZE	4MB	대용량 스캔 성능 극대화
COMPATIBLE	11.2.0.1 이상	Exadata 기능 활성화
DB_BLOCK_CHECKSUM	TYPICAL 또는 FULL	블록 무결성 검사
Extent Size	4MB의 배수	Smart Scan I/O 효율 증가

정리하자면, Exadata로 마이그레이션할 때는 단순 DB 마이그레이션이 아니라,
✅ 64bit 호환성,
✅ ASM/DB 설정 최적화,
✅ AU/Extent Size 조정,
✅ COMPATIBLE 파라미터 설정,
✅ Smart Scan 환경 구성
이 모두 맞아야 최대 성능을 낼 수 있습니다.

Primary, Standby, Redo Log

Primary, Standby, Redo Log 이 세 가지는 Oracle Data Guard 의 핵심 구조를 이해하는 데 아주 중요합니다.
쉽게 말해서 이 관계는 “Primary DB에서 발생한 변경을 Standby DB로 실시간(or 거의 실시간) 복제하기 위한 메커니즘” 입니다.

아래에 그림 없이 개념을 단계별로 설명해볼게요

1. 기본 개념

용어역할설명

Primary Database	주(主) DB	실제 서비스가 동작하는 운영 DB
Standby Database	대기(備) DB	Primary와 동일한 데이터를 복제해둔 백업 DB (DR용)
Redo Log	변경 기록	Primary에서 발생한 모든 트랜잭션 변경 내용을 기록하는 로그 파일

즉, Primary에서 INSERT / UPDATE / DELETE / COMMIT 같은 변경이 일어나면,
이 내용이 먼저 Redo Log에 기록되고,
이 로그를 Standby로 전달하여 동기화합니다.

2. Redo Log가 하는 일

Primary DB에서 트랜잭션 발생
해당 변경이 Redo Log Buffer에 먼저 기록됨
일정 시점(또는 commit 시) → Online Redo Log 파일에 기록됨
Data Guard가 이 Redo 데이터를 전송 (Redo Transport)
Standby에서 Redo Apply가 이를 읽어 DB에 적용함 (Redo Apply)

결과적으로 Standby DB는 Primary DB와 거의 실시간으로 데이터가 동일해집니다.

3. 동작 흐름 정리 (단계별)

[Primary DB] | ├─ 1. 사용자 변경 발생 ├─ 2. Redo Log에 기록 (Redo Log Buffer → Online Redo Log) ├─ 3. LNS(Log Network Service) 프로세스가 Redo 전송 ▼ [Standby DB] ├─ 4. RFS(Remote File Server)가 Redo 수신 ├─ 5. Standby Redo Log에 기록 ├─ 6. MRP(Media Recovery Process)가 Redo 적용 ▼ [데이터 동기화 완료 ✅]

4. Standby Redo Log의 역할

Standby DB도 Redo를 받기 위한 전용 Redo Log(Standby Redo Log, SRL)를 갖고 있어야 합니다.
Primary에서 전송된 Redo가 SRL에 실시간으로 저장되고,
MRP 프로세스가 이 로그를 적용해 데이터 반영합니다.

Standby Redo Log가 없다면 Archive Log 전송을 기다려야 해서 실시간성이 떨어집니다. (최신 DR 환경에서는 거의 필수로 구성)

⚡ 5. Redo 전송 방식

모드특징설명

SYNC 모드	실시간 전송	Primary의 트랜잭션 COMMIT 시점에 Standby 반영까지 확인
ASYNC 모드	비동기 전송	Primary COMMIT 후 Standby로 전송 (약간의 지연 발생)

금융, 중요 서비스는 SYNC, 일반 서비스나 원거리 DR은 ASYNC를 많이 씁니다.

6. 로그 파일 종류 정리

로그 유형위치역할

Online Redo Log	Primary	변경 내역을 실시간 기록
Archive Log	Primary	Online Redo Log가 다 차면 보관용으로 아카이브
Standby Redo Log	Standby	Primary로부터 전송받은 Redo 데이터를 실시간 저장
Archived Redo (from Primary)	Standby	필요 시 Archive Log를 전송받아 복구에 사용

7. Redo & Failover 시나리오

Primary 장애 발생 시 → Standby가 Redo를 모두 적용 완료 상태라면
즉시 Standby를 Primary로 승격 가능 (Failover / Switchover)
Redo가 잘 동기화돼 있어야 RPO(복구 시점 손실)가 0에 가까워집니다.

✅ 요약 정리

구성 요소역할설명

Primary DB	운영	변경 발생 주체
Redo Log	변경 기록	Primary에서 발생한 모든 트랜잭션 기록
Standby DB	복제 대상	Primary의 변경을 Redo Log 기반으로 실시간 반영
Standby Redo Log	중간 저장소	Primary의 Redo를 받아 Standby에서 적용
SYNC/ASYNC	전송 방식	동기 vs 비동기 Redo 전달

핵심 포인트:

Redo Log는 단순한 로그 파일이 아니라 Standby 동기화의 핵심 매개체입니다.
Standby는 Redo를 기반으로 Primary와 똑같은 상태를 유지합니다.
이 구조 덕분에 장애 시 빠르게 DR로 전환할 수 있습니다.

Physical Standby 와 Logical Standby

Oracle Data Guard 환경에서 Standby Database는 크게 두 가지 유형이 있습니다.

Physical Standby 와 Logical Standby

이 둘은 Primary DB로부터 Redo를 어떻게 적용하느냐 방식이 완전히 다릅니다.
아래에서 쉽게 정리해볼게요

1. 개념 요약

구분Physical StandbyLogical Standby

데이터 복제 방식	Redo 블록 단위 그대로 적용	Redo를 SQL로 변환해서 재실행
데이터 구조	Primary와 완전히 동일	Primary와 논리적으로 동일(구조는 약간 다를 수 있음)
적용 방식	Redo Apply	SQL Apply
활용 목적	고가용성(HA), DR	DR + 리포팅/ETL 등 읽기 부하 분산
변경 허용	읽기 전용(일반적으로)	일부 객체 수정 및 추가 가능
복구 속도	빠름	느림(변환 및 적용 오버헤드)

️ 2. Physical Standby (물리적 스탠바이)

정의

Primary DB의 Redo 데이터를 Block 단위 그대로 Standby에 적용하는 방식.
Primary와 물리적으로 완전히 동일한 복제본을 유지.

⚡ 동작 방식

Primary에서 트랜잭션 발생 → Redo 생성
Redo가 Standby로 전송됨
Standby의 MRP(Media Recovery Process)가 Redo를 그대로 적용 (Redo Apply)
Standby는 Primary와 데이터가 완전히 동일한 상태로 유지됨

Primary ──Redo(블록단위)──▶ Physical Standby

특징

✅ 구조 및 데이터가 Primary와 100% 동일
✅ Redo 적용이 빠르고 안정적
✅ 장애 발생 시 빠른 Failover 가능
⚠️ 읽기 전용 모드(기본) — 단, Active Data Guard 라이선스로 읽기 가능

일반적인 DR(재해 복구) 구성에서 가장 널리 쓰이는 방식입니다.

3. Logical Standby (논리적 스탠바이)

정의

Primary DB의 Redo 데이터를 받아 SQL 문장으로 변환 후 Standby에 재적용하는 방식.
데이터 결과는 동일하지만, 물리적 구조는 조금 달라도 됨.

⚡ 동작 방식

Primary에서 트랜잭션 발생 → Redo 생성
Redo가 Standby로 전송됨
Standby의 LSP(Logical Standby Process)가 Redo → SQL 변환
SQL Apply로 데이터를 재적용

Primary ──Redo→SQL 변환──▶ Logical Standby

특징

✅ Standby에서도 DML, DDL 가능 (일부 테이블 제외)
✅ 리포팅/ETL/분석용으로 병행 활용 가능
⚠️ SQL 변환 오버헤드 → 적용 속도가 느림
⚠️ 모든 데이터 타입이 지원되는 건 아님
⚠️ 특정 기능/객체는 변환 불가 (e.g. SecureFile LOB, 일부 XML 타입 등)

주로 운영 + 분석 분리 목적으로 사용됩니다.

4. Physical vs Logical 비교 정리

항목Physical StandbyLogical Standby

적용 방식	Redo Apply (블록 단위)	SQL Apply (SQL 재실행)
동기화 속도	빠름	상대적으로 느림
데이터 구조	Primary와 완전 동일	논리적으로 동일, 일부 구조 변경 가능
활용	DR, 고가용성	DR + 리포팅/분석
변경 허용	읽기 전용 (Active Data Guard로 읽기 가능)	읽기 + 제한적 쓰기 가능
Failover 속도	빠름	느림 (SQL 변환 및 적용 상태에 따라 다름)
지원 객체	대부분	일부 객체 제외됨
유지 관리	단순	변환/적용 이슈로 복잡할 수 있음

5. 실무에서의 활용 시나리오

시나리오추천 유형

단순 DR(재해 복구), 고가용성	✅ Physical Standby
DR + 리포팅 서버 병행 사용	✅ Logical Standby (또는 Active Physical + 리포팅)
Failover/Switchover 빠른 전환	✅ Physical Standby
DW/ETL/분석 작업 분리	Logical Standby (단, 변환 호환성 확인 필요)

대부분의 기업은 운영 DR은 Physical Standby로 구성하고,
리포팅이 필요한 경우 Logical Standby 또는 Active Data Guard를 추가로 씁니다.

6. 관련 주요 프로세스

프로세스Standby 유형역할

LNS	Primary	Redo 전송
RFS	Standby	Redo 수신
MRP	Physical Standby	Redo Apply
LSP	Logical Standby	Redo → SQL 변환 및 적용

✅ 요약 정리

구분Physical StandbyLogical Standby

Redo 처리	Block 단위	SQL 변환
속도	빠름	느림
구조	동일	논리적 동등
용도	DR/HA	DR + 리포팅
복잡도	단순	복잡
Failover	빠름	느림

대부분의 DR 설계는 Physical Standby를 기본으로 하고,
특수한 분석 용도나 부하 분산이 필요할 때만 Logical Standby를 씁니다.

12장 Bulk Data Loading

extraction traslation staging area loading

star shema

sorce로부터 data불러올 때 file로 끌어온다

exa는 file로 소스 불러오지 않고 asm storage에서 불러옴

File 기반 적재 (Staging Area 활용)

staging area영역을 어디로 구성할거냐?

엑사머신 바깥쪽에 둘건지 external. 별도 스토리지 사용. SAN, NAS

엑사머신 안쪽에 둘건지 internal. DBFS(db관리 파일시스템), ACFS(asm관리 파일시스템)

엑사머신 바깥쪽에 둔다는 것은 별도 서버 사용. SAN, NAS

개념

소스 시스템의 데이터를 파일(CSV, Flat File, Parquet 등)로 떨궈서
Staging Area(중간 저장소)에 옮긴 뒤
Exadata로 로드하는 방식입니다.

Staging Area 구성 옵션

위치설명

ACFS / DBFS (Exadata 내부)	Exadata의 파일 시스템에 staging 가능
NAS / SAN (외부)	별도의 스토리지에 staging 후 Exadata에서 접근
외장 디스크 / 테이프 등	물리적 매체로 전송 후 적재

⚠️ 주의: Exadata 내부 서버 디스크(로컬 HDD)에 staging 파일을 두는 건 권장되지 않습니다.

DBFS?

1. DBFS란 무엇인가?

Oracle Database File System(DBFS)는
데이터베이스를 파일 시스템처럼 사용하는 기능입니다.

내부적으로는 DB 테이블에 데이터를 저장하지만,
외부에서는 일반 POSIX 파일 시스템(리눅스 파일 시스템)처럼 접근할 수 있게 해줍니다.

[Application / Loader] │

▼

[ DBFS Mount (POSIX FS) ] │

▼

[ Oracle Database (SecureFiles LOB) ] │

▼

[ Exadata Storage ]

2. DBFS Staging의 동작 방식

Staging 파일 업로드
- CSV, TXT, Parquet 등 대용량 데이터를 DBFS 마운트 지점에 업로드
DBFS 내부 저장
- 파일은 DB 내부의 SecureFile LOB 컬럼에 저장됨
- 실제 물리적 저장소는 Exadata의 ASM 디스크 그룹
POSIX 파일 인터페이스 제공
- OS에서 ls, cp, rm 같은 명령으로 접근 가능
- SQL*Loader, External Table 등에서 파일 경로로 바로 로딩 가능
DB 기능 활용 가능
- DBFS에 저장된 파일도 RMAN 백업, Flashback, Data Guard 동기화 가능

3. DBFS의 특징 및 장점

항목설명

파일 시스템처럼 사용 가능	OS에서 mount 후 일반 파일처럼 접근
SecureFile LOB에 저장	DB 내부에 안전하게 저장됨
⚡ 트랜잭션 일관성 보장	DB 데이터와 동기적으로 관리됨
고가용성 기능 연계 가능	ASM, RMAN, Flashback, Data Guard 등
보안 및 권한 관리 용이	DB 계정 및 권한 관리 기반
Exadata 최적화	로딩 시 내부 경로 사용 → 빠른 적재 속도

즉, 단순한 “파일 폴더”가 아니라
✅ DB의 고가용성과 보안을 그대로 적용할 수 있는 스테이징 스토리지입니다.

⚡ 4. DBFS를 이용한 스테이징 예시

① DBFS 마운트

# 예: 리눅스에서 DBFS를 마운트 dbfs_client username@TNS_ALIAS /mnt/dbfs

② 파일 업로드

cp /data/bulk/orders_202510.csv /mnt/dbfs/

③ External Table로 로딩

CREATE TABLE ext_orders ( order_id NUMBER, order_date DATE, amount NUMBER )

ORGANIZATION EXTERNAL ( TYPE ORACLE_LOADER DEFAULT DIRECTORY dbfs_dir ACCESS

PARAMETERS ( RECORDS DELIMITED BY NEWLINE FIELDS TERMINATED BY ',' )

LOCATION ('orders_202510.csv') )

REJECT LIMIT UNLIMITED;

DBFS 경로에 올린 파일을 바로 External Table로 읽어 들임.

예시2 ) 실습 예시

5. DBFS vs 외부 NAS/SAN 스테이징 비교

항목DBFSNAS/SAN 등 외부 스토리지

설치 위치	DB 내부 (Exadata)	외부
성능	Exadata 내부 경로 → 빠름	네트워크 I/O 경유
가용성	ASM, RMAN, Data Guard 등 연계	외부 스토리지 별도 관리
권한 관리	DB 권한 체계로 통합	OS/NAS 별도 관리 필요
백업	RMAN 등으로 통합 백업 가능	별도 백업 필요
마운트 편의성	POSIX 파일 인터페이스 제공	일반 파일 공유 방식 사용

Exadata 환경에서는 NAS보다 DBFS가 성능·관리성 면에서 우수한 경우가 많습니다.

⚠️ 6. DBFS 사용 시 주의점

DB 내부에 파일이 저장되므로 DB 저장소 용량 관리가 중요
⚡ 대량 병렬 적재 시 IOPS 부하를 고려해야 함
DB 사용자 권한 체계와 잘 맞춰야 함 (파일 접근 = DB 권한)

✅ 요약 정리

항목내용

DBFS란	DB를 파일 시스템처럼 활용하는 기능
저장 방식	SecureFile LOB으로 DB 내부에 저장
⚡ 장점	고성능, 고가용성, 트랜잭션 일관성
활용	External Table, SQL*Loader 스테이징 경로
관리	ASM, RMAN, Data Guard 등과 연계 가능

즉, DBFS를 사용하면 Exadata 내부에서 파일 적재를 보안성·안정성·속도 모두 확보하면서 처리할 수 있습니다.

[Exadata day3] 자원 및 성능 관리 (IORM & 성능 튜닝 & Smart Scan 실행 조건 및 모니터링)

aonee — Wed, 22 Oct 2025 16:47:35 +0900

7~9장: 자원 및 성능 관리

7장: I/O Resource Management (IORM) 계획 및 모니터링
8장: 성능 튜닝(PMEM/Flash, In-Memory Columnar, Latency Capping)
9장: Smart Scan 실행 조건 및 모니터링 방법

오늘 배운 내용 요약정리

7장: I/O Resource Management (IORM) 계획 및 모니터링

IORM ?
I/O Resource Management
여러 종류의 워크로드(Workload)가 하나의 Exadata 환경을 공유할 때
* 워크로드 (EX) 1. OLTP (온라인 트랜잭션) 2.분석(Reporting) 3.ETL (배치 작업) 4.테스트 및 개발
동시에 I/O를 요청하면 발생하는 경쟁에서,
각 워크로드에 공정하고 예측 가능한 I/O 자원 할당을 보장하는 핵심 기술
즉, 중요한 워크로드에 우선순위를 부여하거나, 비율대로 자원을 나누는 역할을 한다.

예를 들어, 하나의 Exadata에 아래와 같은 워크로드가 있다고 해봅시다
DB1: OLTP / Reporting
DB2: ETL / Batch

IORM Category Plan 예시:
Category Interactive (OLTP, Reporting) → 70%
Category Batch (ETL) → 30%

IORM 동작:
총 I/O 자원 100% 중 Interactive Category → 70% 우선 배정 Batch Category → 30% 배정
OLTP 요청이 몰릴 경우, IORM이 자동으로 Batch의 I/O를 제한하고 OLTP에 우선순위를 줍니다.

IORM 핵심 개념 요소
Workload ?
데이터베이스에서 실행되는 작업 (OLTP, Batch, ETL 등)
Consumer Group ?
특정 워크로드를 묶어 관리하는 그룹 (DB 내부 단위)
Category ?
여러 DB에 걸친 Consumer Group을 묶는 상위 단위 (IORM 단위)
Resource Plan ?
자원 할당 정책 (비율, 우선순위 등) 정의
Objective ?
IORM이 자원을 관리하는 목표 모드 (basic, auto, balanced, low_latency 등)

8장 성능 최적화.

성능 최적화(Performance Optimization) 시 고려해야 할 핵심 영역
PMEM 초저지연 읽기 성능 향상 OLTP 속도 ↑
Flash Cache 핫데이터 캐싱 디스크 I/O 감소
In-memory Cache Column Store DW 분석 속도 ↑
Compression Hybrid Columnar Compression 공간 절감 + I/O 절감
Index 전략적 최소화 불필요한 오버헤드 제거
ASM 설정 AU/Extent 조정 I/O 효율 최적화
시스템 통계 Exadata 전용 지표 모니터링 병목 정확히 파악
Timeout 설정 환경별 튜닝 장애 감지 및 안정성 확보

PMEM Cache Mode 종류
Write-Through
(기본/권장)데이터가 PMEM과 Flash/HDD에 동시에 기록됨안정성 높음, 데이터 유실 위험 없음대부분의 운영 환경
Write-Back
고성능 모드먼저 PMEM에 쓰고 나중에 Flash/HDD로 내림응답속도 향상, 장애 시 데이터 손실 위험 있음성능 테스트나 극단적 저지연이 필요한 경우

9장 스마트 스캔 실행조건 및 모니터링 방법

Smart Scan ?
Exadata의 스토리지 오프로딩(Storage Offload) 기능
스캔 작업을 DB 서버가 아니라 스토리지 셀에서 처리하여
네트워크 트래픽을 줄이고, 쿼리 성능을 획기적으로 높이는 기능

그런데 아래와 같은 상황에서는 Smart Scan이 비활성화되어 전통적인 블록 기반 I/O로 처리되기 때문에 성능 향상을 기대할 수 없다.
1. Clustered Table
스캔 클러스터 테이블은 저장 구조가 일반 테이블과 달라서 스토리지 셀에서 효율적 오프로딩 불가
2. Index-Organized Table(IOT)
데이터가 인덱스에 직접 저장되는 구조라 Smart Scan 대상이 아님
3. 압축 인덱스의 Fast Full Scan
스토리지 셀에서 압축 인덱스를 해제하며 스캔하는 기능 미지원
4. Reverse Key Index Fast Full Scan
Reverse Key는 정렬 순서가 뒤섞여 있어 스토리지에서 순차 스캔 불가능
5. Row-level dependency tracking활성화된 테이블
내부적인 추가 메타데이터 관리로 오프로딩 불가능
6. ROWID 순서로 결과 반환
정렬 순서를 보장하기 위해 블록 단위 전송 필요
7. CREATE INDEX ... NOSORT
인덱스 생성 시 기존 데이터 정렬 유지로 Direct Path Read 미발생
8. LOB / LONG 컬럼이 포함된 쿼리
LOB/LONG은 Smart Scan 대상에서 제외됨 (길이가 크고 처리 방식 다름)
9. Flashback Versions Query 사용 시
Undo 데이터 접근 필요로 스토리지 오프로딩 불가
10. 255개 초과 컬럼 참조
Smart Scan의 최대 컬럼 처리 제한 초과
11. Tablespace가 암호화되어 있고, 셀 기반 복호화가 비활성화된 경우
DB 서버에서 복호화를 해야 하므로 Smart Scan 불가
12. Virtual Column 기반 Predicate 사용
가상 컬럼은 스토리지 셀에서 계산 불가(논리식 평가 필요)

모니터링 스마트 스캔 ?
V$SESSION_EVENT 세션단위로 스마트스캔이 일어났는지 확인 불가
v$system_event 시스템 단위로 스마트스캔 일어났는지 확은 가능함
but, 확인 방법은 처음 실행 후 다시 실행했을 때 스마트 스캔이 일어났는지 확인함
6216 -> 6509 아, 스마트스캔 실행됐구나 확인가능함
아니면 트레이스파일로 마스터프로세스랑 슬래이브프로세스가 실행한 걸 확인하여 알 수도 있음

I/O Resource Management

**I/O Resource Management(IORM)**가 왜 중요한지를 이해하는 핵심 개념입니다.

즉, **스토리지를 여러 데이터베이스와 워크로드가 공유(Shared Storage)**할 때의
✅ 장점과 ⚠️ 단점을 설명하고, 왜 IORM이 필수적인 관리 도구인지 연결되는 주제입니다.

1. Shared Storage란?

여러 데이터베이스(혹은 여러 워크로드)가 동일한 스토리지 시스템을 공유하여 사용하는 구조

Exadata 환경에서는 DB 서버 여러 개가 하나의 스토리지 셀 풀(Pool)을 공유하는 게 일반적입니다

2. Shared Storage의 주요 장점

✅ (1) 스토리지 자원 활용도 향상

하나의 DB만 사용하는 전용 스토리지일 경우 → 최대 피크 용량 기준으로 과다 설계해야 함
하지만 실제 사용량은 들쭉날쭉 → 자원 낭비 발생
공유 스토리지를 사용하면, 여유 자원을 다른 DB가 활용 가능함

예시:

DB1이 오전에만 트래픽이 몰림
DB2는 오후에만 트래픽이 있음
하나의 스토리지 풀에서 DB1, DB2가 자원을 시간대별로 나눠 쓰면 더 효율적입니다.

✅ (2) 운영 및 관리 비용 절감

스토리지 시스템을 DB마다 따로 둘 필요가 없음
유지보수 대상 장비 수가 줄어듦 → 관리 인력 및 비용 절감
자원 풀링(Pooling)으로 향후 확장성도 용이

⚠️ 3. Shared Storage의 단점 및 문제점

공유 환경은 자원 효율성을 높이는 대신, 경쟁이 발생할 수 있습니다.

⚡ (1) 워크로드 간 간섭 (Resource Contention)

한 DB에서 대규모 병렬 쿼리가 실행되면,
다른 DB의 중요한 트랜잭션 성능이 급격히 떨어질 수 있음.

예시:

DB1: 대형 보고서 쿼리 (Full Table Scan)
DB2: 실시간 주문 트랜잭션
→ DB1이 I/O를 독점하면 DB2의 응답 속도가 느려짐.

⚡ (2) 워크로드 간 우선순위 조정 어려움

수작업으로 스케줄링하거나 시간대를 나눠야 하는 경우 발생
특히 관리자가 여러 명일 경우 조율이 쉽지 않음
- “나는 분석 작업 해야 한다”
- “나는 서비스 트랜잭션이 먼저다”

이로 인해 피크 시간대에는 성능 병목(bottleneck)이 빈번히 발생합니다.

⚡ (3) 과잉 프로비저닝(Over-Provisioning)의 유혹

문제를 해결하기 위해 스토리지를 더 크게 구축하는 경우가 많음
하지만 이건 결국 **공유의 장점(비용 절감)**을 무력화시키는 결과가 됩니다.

4. IORM이 필요한 이유 (해결책)

Oracle I/O Resource Manager (IORM)은 바로 위의 문제를 해결하기 위해 설계되었습니다.

문제IORM 해결 방식

특정 워크로드가 I/O 독점	Consumer Group / Category 기반 자원 비율 설정
워크로드 우선순위 충돌	Priority 설정으로 중요한 워크로드에 우선권 부여
피크 시간대 충돌	Category Plan을 통해 자동 자원 분배
관리자 간 충돌	정책 기반으로 자동화, 수동 조율 최소화

예를 들어, OLTP 업무에 높은 우선순위를 부여하고, ETL이나 Batch는 남는 자원만 사용하게 설정 가능.

5. 예시: IORM Category Plan으로 해결

두 개의 DB가 공유 스토리지에서 운영 중이라고 가정

DB워크로드Category비중

DB1	실시간 OLTP	Interactive	70%
DB2	Batch 분석	Batch	30%

IORM 설정 (CellCLI):

cellcli> alter iormplan objective=auto cellcli> add iormcategory name=Interactive, level=1, allocation=70 cellcli> add iormcategory name=Batch, level=2, allocation=30

피크 시간대에 OLTP가 몰려도 DB2는 자원을 뺏기지 않고 설정된 범위 내에서만 사용하게 됩니다.

6. Shared Storage + IORM = 균형 잡힌 구조

항목IORM 적용 전IORM 적용 후

성능	비정상적 워크로드에 의해 흔들림	안정적, 우선순위 보장
자원 사용	비효율적 / 편중됨	공정하게 분배됨
관리 방식	수작업, 시간대 분리	자동 정책 기반 할당
비용	과잉 투자 유도 가능	최소 자원으로 최적 활용 가능

✅ 7. 정리

Shared Storage는 자원 효율성과 관리비 절감이라는 장점이 있지만,
⚡ 워크로드 충돌이라는 구조적 리스크가 존재합니다.
⚙️ IORM은 이러한 충돌을 자동으로 관리하고, 우선순위 기반 자원 분배를 통해 성능을 보장합니다.
실제 운영에서는 Consumer Group + Category + CDB Resource Plan을 조합하여 유연하게 제어합니다.

I/O Resource Management Concepts

I/O Resource Management (IORM)**는
여러 종류의 워크로드(Workload)가 하나의 Exadata 환경을 공유할 때
각 워크로드에 공정하고 예측 가능한 I/O 자원 할당을 보장하는 핵심 기술입니다.

아래에 개념을 아주 쉽게 정리해드릴게요

1. 왜 IORM이 필요한가?

현실의 데이터베이스 환경에는 다양한 워크로드가 공존합니다.

예:

‍ OLTP (온라인 트랜잭션)
분석(Reporting)
ETL (배치 작업)
테스트 및 개발

이런 워크로드가 동시에 I/O를 요청하면 경쟁이 발생합니다.
IORM은 이 경쟁 상황에서 중요한 워크로드에 우선순위를 부여하거나, 비율대로 자원을 나누는 역할을 합니다.

2. IORM 핵심 개념 요소

개념설명

Workload	데이터베이스에서 실행되는 작업 (OLTP, Batch, ETL 등)
Consumer Group	특정 워크로드를 묶어 관리하는 그룹 (DB 내부 단위)
Category	여러 DB에 걸친 Consumer Group을 묶는 상위 단위 (IORM 단위)
Resource Plan	자원 할당 정책 (비율, 우선순위 등) 정의
Objective	IORM이 자원을 관리하는 목표 모드 (basic, auto, balanced, low_latency 등)

3. Consumer Group과 Category

Consumer Group

데이터베이스 내에서 특정 워크로드를 그룹화
예: OLTP_GROUP, REPORT_GROUP, ETL_GROUP

4. Resource Plan의 종류

계획 유형대상설명

Intradatabase Plan	단일 DB 내 Consumer Group 간 자원 배분
Interdatabase Plan	여러 DB 인스턴스 간 자원 배분
Category Plan	여러 DB에 걸친 Category 간 자원 배분
CDB Resource Plan	하나의 CDB 안에서 PDB 간 자원 배분 (멀티테넌트)

이 네 가지 Plan은 IORM 레벨에서 동시에 작동할 수 있으며, 계층적으로 영향을 미칩니다.

⚡ 5. 작동 방식 예시

예를 들어, 하나의 Exadata에 아래와 같은 워크로드가 있다고 해봅시다

DB1: OLTP / Reporting
DB2: ETL / Batch

IORM Category Plan 예시:

Category Interactive (OLTP, Reporting) → 70%
Category Batch (ETL) → 30%

IORM 동작:

총 I/O 자원 100% 중 Interactive Category → 70% 우선 배정 Batch Category → 30% 배정

OLTP 요청이 몰릴 경우, IORM이 자동으로 Batch의 I/O를 제한하고 OLTP에 우선순위를 줍니다.

6. 실무 설정 예시

Category Plan 생성 및 적용 (CellCLI)

cellcli> alter iormplan objective=auto cellcli> alter iormplan catPlan='cat_plan1' cellcli> add iormcategory name=Interactive, level=1, allocation=70 cellcli> add iormcategory name=Batch, level=2, allocation=30

objective=auto는 자동으로 I/O를 분배하면서 OLTP 워크로드를 우선하는 모드입니다.

7. 모니터링 예시

IORM Plan 확인:

cellcli> list iormplan

Category 사용량 모니터링:

cellcli> list metriccurrent where objectType='CATEGORY'

DB Resource Plan 확인:

SELECT * FROM v$rsrc_plan; SELECT * FROM v$rsrc_consumer_group;

8. IORM Objective 설정 모드

모드설명

basic	IORM 비활성 상태 (모든 워크로드가 자원 공유)
auto	자동 우선순위 및 할당 (권장 기본값)
balanced	균형 있게 분배
low_latency	지연 시간 최소화에 집중 (OLTP에 적합)

auto 모드에서 가장 유연하게 Category / Consumer Group / CDB Plan이 작동합니다.

✅ 9. 요약 정리

항목설명

IORM 목적	여러 워크로드가 공존할 때 자원 경쟁을 제어
Consumer Group	DB 내부에서 워크로드 구분
Category	여러 DB에 걸친 워크로드 그룹화
Resource Plan	자원 할당 정책 정의 (Intradatabase, Interdatabase, Category, CDB)
Objective	관리 목표 설정 (auto 권장)
결과	예측 가능한 성능, 중요한 워크로드 우선 보장

한 줄 요약:
IORM = Exadata에서 I/O 자원을 워크로드별로 공정하고 전략적으로 분배하는 엔진입니다.
Consumer Group + Category + Resource Plan을 조합하면 복잡한 환경에서도 성능을 안정적으로 유지할 수 있습니다 ⚡

I/O Resource Management Plans

Oracle Exadata의 I/O Resource Manager (IORM) 가
어떻게 여러 가지 방식으로 I/O 자원 할당을 관리할 수 있는지 설명하는 핵심 개념입니다.

IORM에는 3가지 주요 접근 방식이 있으며,
각각 단독으로도 사용 가능하고,
상황에 따라 조합해서 동시에 운영할 수도 있습니다.

아래에 개념을 체계적으로 정리해드릴게요

1. IORM 접근 방식 개요

접근 방식적용 대상설정 위치목적

① Intradatabase	단일 데이터베이스 내부의 워크로드	DB Resource Manager	워크로드(OLTP, Batch 등) 간 자원 배분
② Interdatabase	여러 데이터베이스 간	IORM Plan (cell level)	DB별 자원 할당
③ Category	여러 DB에 걸친 공통 workload 유형	IORM Plan (cell level)	업무 카테고리(OLTP/Report/ETL 등)별 자원 할당

2. ① Intradatabase Resource Management

하나의 데이터베이스 안에서 여러 workload를 제어할 때 사용

예:

한 DB 안에 OLTP, Reporting, ETL 작업이 동시에 실행
OLTP가 우선이므로 더 많은 I/O 비중을 부여하고, 나머지 작업은 제한

구성:

Consumer Group 생성 (ex. OLTP_GROUP, REPORT_GROUP)
DB Resource Manager로 비중 설정
Plan 활성화

예시:

EXEC DBMS_RESOURCE_MANAGER.CREATE_PLAN('OLTP_PLAN','Plan for OLTP vs Reporting'); EXEC DBMS_RESOURCE_MANAGER.CREATE_CONSUMER_GROUP('OLTP_GROUP','OLTP Workload'); EXEC DBMS_RESOURCE_MANAGER.CREATE_CONSUMER_GROUP('REPORT_GROUP','Reporting Workload'); EXEC DBMS_RESOURCE_MANAGER.CREATE_PLAN_DIRECTIVE('OLTP_PLAN','OLTP_GROUP',cpu_p1=>80); EXEC DBMS_RESOURCE_MANAGER.CREATE_PLAN_DIRECTIVE('OLTP_PLAN','REPORT_GROUP',cpu_p1=>20); ALTER SYSTEM SET RESOURCE_MANAGER_PLAN='OLTP_PLAN';

Intradatabase는 단일 DB 환경에서 가장 기본적으로 쓰이는 방식입니다.

3. ② Interdatabase Resource Management

여러 개의 데이터베이스가 하나의 Exadata 스토리지를 공유할 때, DB별 자원 할당을 제어

예:

Exadata 한 대에 DB1(OLTP)와 DB2(DW)가 함께 올라가 있음
OLTP가 우선이므로 DB1에 70%, DB2에 30% 할당

구성:

IORMPLAN에서 DB별 directive 정의
Interdatabase Plan 생성

예시 (CellCLI):

cellcli> ALTER IORMPLAN OBJECTIVE=auto cellcli> ADD IORMDBPLAN DBNAME=DB1, ALLOCATION=70 cellcli> ADD IORMDBPLAN DBNAME=DB2, ALLOCATION=30

이 방식은 데이터베이스 단위로 자원을 공정하게 나누는 역할을 합니다.

4. ③ Category Resource Management

**워크로드의 성격(카테고리)**에 따라 자원을 나누는 고급 기능

예:

모든 DB에서 OLTP / REPORT / MAINTENANCE 세 가지 workload가 있음
OLTP가 가장 중요 → Category별로 자원 비중 설정

구성:

각 Consumer Group을 Category에 매핑
Category Plan에서 Category별 비중 설정

예시 (CellCLI):

cellcli> ALTER IORMPLAN OBJECTIVE=auto cellcli> ADD IORMCATEGORY NAME=OLTP, LEVEL=1, ALLOCATION=60 cellcli> ADD IORMCATEGORY NAME=REPORT, LEVEL=2, ALLOCATION=30 cellcli> ADD IORMCATEGORY NAME=MAINTENANCE, LEVEL=3, ALLOCATION=10

Category Plan은 DB 간이 아니라 업무 성격 기준으로 자원을 분배할 수 있어 대규모 공유 환경에 유리합니다.

⚡ 5. 3가지 방식의 조합

IORM은 이 세 가지 방식을 계층적으로 조합해서 작동시킬 수 있습니다.

[Category Plan] → 카테고리별 우선순위 ↓ [Interdatabase Plan] → DB 간 자원 분배 ↓ [Intradatabase Plan] → 한 DB 내부 워크로드 분배

예:

Category Plan: OLTP > REPORT
Interdatabase Plan: DB1 70% / DB2 30%
Intradatabase Plan (DB1 내부): OLTP 80% / ETL 20%

이렇게 하면 복잡한 멀티워크로드 환경에서도 정교하게 자원을 통제할 수 있습니다.

6. IORM Plan 확인 및 관리 명령

IORM Plan 상태 확인:

cellcli> list iormplan

현재 설정된 Category/DB별 할당 확인:

cellcli> list iormplan detail

DB 내부 Consumer Group 확인:

SELECT * FROM v$rsrc_plan; SELECT * FROM v$rsrc_consumer_group;

✅ 7. 요약 정리

방식대상설정 위치장점적용 시점

Intradatabase	단일 DB 내부 workload	DB Resource Manager	간단, 유연	소규모 환경
Interdatabase	여러 DB 간	Cell IORM Plan	DB 간 공정 배분	멀티 DB 환경
Category	여러 DB의 공통 workload	Cell IORM Plan	업무 성격 기반 관리	대규모, 복합 workload 환경

1개만 써도 되지만, 실무에서는 Interdatabase + Category + Intradatabase 조합이 많습니다.
특히 금융/통신/공공기관 같이 OLTP + Batch + 분석이 동시에 도는 환경에서 빛을 발합니다

8장
Recommendations for Optimizing
Database Performance

Oracle Exadata 환경에서 성능 최적화(Performance Optimization) 시 고려해야 할 핵심 영역을 정리한 것입니다.
단순히 DB 튜닝만으로는 Exadata의 진가를 다 끌어내기 어렵기 때문에, Exadata 전용 기능과 스토리지 계층까지 함께 최적화하는 것이 중요합니다.

아래에 항목별로 구체적으로 설명드릴게요

1. 기본: ASM & Oracle Database Best Practices

**ASM(Oracle Automatic Storage Management)**는 Exadata의 핵심 스토리지 가상화 계층입니다.
DB 자체의 SQL 튜닝, 인덱스 설계, 통계 수집 등도 반드시 병행되어야 합니다.
Exadata만의 성능 기능(PMEM, Flash, Smart Scan 등)은 “DB가 잘 설계되어 있을 때” 최대 효과를 냅니다.

Exadata 성능 최적화는 “DB 튜닝 + 스토리지 계층 최적화”가 함께 가야 합니다.

⚡ 2. Persistent Memory (PMEM) 활용 최적화

PMEM(지속성 메모리)은 DRAM보다 약간 느리지만 Flash보다 훨씬 빠름.
RDMA(Remote Direct Memory Access) 기반으로 DB 서버에서 스토리지 셀의 PMEM에 초저지연 접근 가능.
자주 읽는 핵심 핫 데이터를 PMEM 캐시에 위치시켜 I/O 레이턴시 감소.
목표: Random I/O와 OLTP 트랜잭션 성능 향상.

PMEM Cache를 잘 활용하면 OLTP 처리속도가 10배 이상 향상되는 경우도 있습니다.

3. Flash Memory (Smart Flash Cache) 활용

Flash Cache는 HDD보다 훨씬 빠른 중간 계층 캐시입니다.
Smart Flash Cache는 자주 접근되는 블록을 자동으로 캐싱.
자주 조회되는 읽기 쿼리를 Flash에 위치시키면 디스크 I/O 감소.
Flash Cache 크기와 정책(Write-back vs Write-through)을 환경에 맞게 조정.

Flash Cache는 Exadata Smart Scan과도 연계되어 성능 최적화의 핵심 축입니다.

4. In-Memory Columnar Cache 활용

Oracle Database In-Memory 기능을 사용하면 메모리에 Column Store를 유지 가능.
Smart Scan과 결합하면 대규모 분석 쿼리의 응답 속도가 급격히 개선.
자주 분석되는 테이블(팩트 테이블 등)에 적합.
Columnar 포맷은 압축 효율도 높아 I/O 절감에 유리.

PMEM/Flash + In-memory Column Cache 조합이 대용량 DW 환경의 핵심 성능 전략입니다.

5. Compression 활용

Exadata는 Hybrid Columnar Compression(HCC) 기능을 통해 압축 효율을 크게 높일 수 있음.
- Warehouse Compression: 쿼리 성능 중심
- Archive Compression: 최대 압축률 중심
압축은 단순히 저장공간 절감뿐 아니라, I/O 전송량 감소로 이어져 성능 향상 효과가 큽니다.
잘못 적용하면 CPU 부담이 증가할 수 있으므로 워크로드 특성에 맞게 선택 필요.

6. Index 사용 전략

Exadata Smart Scan은 인덱스 없이도 대량의 Table Scan을 매우 빠르게 수행할 수 있음.
과도한 인덱스는 불필요한 관리 비용과 오버헤드만 유발할 수 있음.
OLTP 워크로드에는 인덱스 필수, 대규모 분석 워크로드는 인덱스 최소화가 원칙.

인덱스 설계는 Exadata에서 재검토가 필요합니다. 기존 DB 환경 그대로 가져오면 성능을 저해할 수 있습니다.

7. ASM Allocation Unit Size / Extent Size 최적화

ASM Allocation Unit(AU) 크기와 Extent Size는 I/O 효율성에 직접적인 영향을 줍니다.
기본값은 보통 4MB인데, 대규모 DW 환경에서는 더 큰 AU가 유리할 수 있음.
Extent size도 테이블 액세스 패턴에 따라 조정하여 Smart Scan 효율을 높일 수 있음.

큰 I/O는 fewer calls, 더 빠른 처리. 작은 I/O는 OLTP에 유리. 워크로드에 맞춰 설계 필요.

8. Exadata Specific System Statistics

Exadata 전용 시스템 통계(v$cell, v$sysstat, v$cell_iorm_statistics 등)를 모니터링해야 진짜 병목을 찾을 수 있음.
주요 지표 예:
- cell physical IO bytes saved by storage index
- cell physical IO interconnect bytes returned by smart scan
- cell flash cache hits
- IORM statistics

일반 DB 통계만 보면 Exadata의 스토리지 오프로딩 효과를 간과할 수 있습니다.

⏳ 9. I/O Timeout Threshold 설정

기본 I/O 타임아웃이 너무 짧으면 Flash/HDD 딜레이 시 불필요한 에러 발생
반대로 너무 길면 장애 감지가 느려짐
워크로드에 따라 적절한 I/O timeout 설정 필요 (특히 OLTP vs DW 환경 차이)

✅ 정리 요약

영역최적화 포인트효과

PMEM	초저지연 읽기 성능 향상	OLTP 속도 ↑
Flash Cache	핫데이터 캐싱	디스크 I/O 감소
In-memory Cache	Column Store	DW 분석 속도 ↑
Compression	Hybrid Columnar Compression	공간 절감 + I/O 절감
Index	전략적 최소화	불필요한 오버헤드 제거
ASM 설정	AU/Extent 조정	I/O 효율 최적화
시스템 통계	Exadata 전용 지표 모니터링	병목 정확히 파악
Timeout 설정	환경별 튜닝	장애 감지 및 안정성 확보

한 줄로 요약하면,
Exadata 성능 최적화는 “스토리지 계층까지 포함한 전체 아키텍처 튜닝”이 핵심입니다.
단순 SQL 튜닝만으로는 Exadata의 Smart 기능을 100% 활용할 수 없습니다 ⚡

PMEM
Persistent Memory

Persistent Memory(PMEM) 는 최신 세대 Exadata에서 가장 큰 성능 혁신 포인트 중 하나입니다.
특히 초저지연 I/O가 필요한 OLTP 워크로드(예: 주식거래, IoT, 실시간 처리)에 강력한 효과를 줍니다 ⚡

아래에 PMEM의 개념, 구성 요소, 동작 방식, 운영 팁까지 쉽게 정리해드릴게요

1. Persistent Memory란?

PMEM은 DRAM(메모리)과 Flash Storage의 중간 영역에 위치한 새로운 형태의 메모리입니다.
속도는 Flash보다 훨씬 빠르고, DRAM보다는 약간 느립니다.
전원이 꺼져도 데이터가 유지되는 특성이 있어 고속 캐시로 사용하기 적합합니다.
Exadata에서는 PMEM을 Smart PMEM Cache와 Smart PMEM Log로 활용합니다.

항목PMEMFlashDRAM

속도	초고속	중간	최고
휘발성	비휘발성	비휘발성	휘발성
용도	캐시 + 로그 가속	일반 캐시	DB 버퍼

⚡ 2. Smart PMEM Cache (Persistent Memory Data Accelerator)

자주 읽히는 데이터를 PMEM에 캐싱해서 초저지연으로 제공하는 기능입니다.

디스크나 Flash보다 빠른 PMEM에 데이터를 저장해 읽기 속도 향상
RDMA(Remote Direct Memory Access)를 이용해 DB 서버가 PMEM을 직접 접근
OLTP 워크로드나 랜덤 읽기 부하에 효과적
Smart Flash Cache와 유사하지만, PMEM이 더 빠름 (Flash 대비 수 μs 수준의 응답속도 개선)

✅ PMEM Cache 모드

모드설명특징

Write-Through	데이터는 PMEM에 쓰고, 동시에 Flash/HDD에도 반영	안정성 높음, 권장
Write-Back	데이터는 PMEM에 먼저 쓰고 나중에 Flash로 내려감	성능은 높지만 관리 복잡

일반적으로 운영 환경에서는 Write-Through 모드를 권장합니다.

3. Smart PMEM Log (Persistent Memory Commit Accelerator)

PMEM을 Redo Log 쓰기 가속에 활용하는 기능입니다.

기존에는 redo log 기록 시 Flash Log를 사용해 지연을 줄였음
PMEM Log는 Flash Log보다 더 빠른 속도로 redo 기록 지연(latency)을 줄임
트랜잭션 커밋(commit) 속도에 직접적으로 영향을 줌 → OLTP 성능 향상
PMEM Log는 데이터베이스별로 활성화 또는 비활성화 가능함

초저지연 커밋이 중요한 워크로드(금융 거래, IoT 센서 데이터 등)에 특히 효과적입니다.

4. PMEM 사용 대상 워크로드 예시

워크로드 유형적합 이유

금융 트랜잭션	커밋 지연 최소화 필요 (PMEM Log 효과 극대화)
실시간 분석	자주 조회되는 데이터 빠른 응답 필요
IoT 센서 데이터	초저지연 쓰기 처리 필요
대규모 OLTP	랜덤 읽기 부하 최적화

9장 스마트스캔

Smart Scan은 Exadata의 스토리지 오프로딩(Storage Offload) 기능으로,
스캔 작업을 DB 서버가 아니라 스토리지 셀에서 처리하여
네트워크 트래픽을 줄이고, 쿼리 성능을 획기적으로 높이는 기능입니다. ⚡

그런데 아래와 같은 상황에서는 Smart Scan이 비활성화되어 전통적인 블록 기반 I/O로 처리되기 때문에 성능 향상을 기대할 수 없습니다.
아래에 항목별로 왜 Smart Scan이 안 되는지까지 해설해드릴게요

1. Smart Scan이란? (간단 복습)

항목Smart Scan전통적 I/O

처리 위치	스토리지 셀	DB 서버
전송량	필요한 컬럼/로우만 전송	전체 블록 전송
성능	빠름 (오프로딩)	느림
효과	네트워크 부하 감소, CPU 절감	부하 집중

Smart Scan은 Table Full Scan, Direct Path Read를 사용하는 경우에 주로 발생합니다.

⚠️ 2. Smart Scan이 동작하지 않는 상황

상황Smart Scan 비활성화 이유

1. Clustered Table 스캔	클러스터 테이블은 저장 구조가 일반 테이블과 달라서 스토리지 셀에서 효율적 오프로딩 불가
2. Index-Organized Table(IOT)	데이터가 인덱스에 직접 저장되는 구조라 Smart Scan 대상이 아님
3. 압축 인덱스의 Fast Full Scan	스토리지 셀에서 압축 인덱스를 해제하며 스캔하는 기능 미지원
4. Reverse Key Index Fast Full Scan	Reverse Key는 정렬 순서가 뒤섞여 있어 스토리지에서 순차 스캔 불가능
5. Row-level dependency tracking 활성화된 테이블	내부적인 추가 메타데이터 관리로 오프로딩 불가능
6. ROWID 순서로 결과 반환	정렬 순서를 보장하기 위해 블록 단위 전송 필요
7. CREATE INDEX ... NOSORT	인덱스 생성 시 기존 데이터 정렬 유지로 Direct Path Read 미발생
8. LOB / LONG 컬럼이 포함된 쿼리	LOB/LONG은 Smart Scan 대상에서 제외됨 (길이가 크고 처리 방식 다름)
9. Flashback Versions Query 사용 시	Undo 데이터 접근 필요로 스토리지 오프로딩 불가
10. 255개 초과 컬럼 참조	Smart Scan의 최대 컬럼 처리 제한 초과 oracle 1개 테이블 최대 가능 컬럼 1000개. 컬럼 255개 초과하면 스마트스캔 X
11. Tablespace가 암호화되어 있고, 셀 기반 복호화가 비활성화된 경우	DB 서버에서 복호화를 해야 하므로 Smart Scan 불가
12. Virtual Column 기반 Predicate 사용	가상 컬럼은 스토리지 셀에서 계산 불가(논리식 평가 필요) virtual column ? C as substr(a,1,4)

3. Smart Scan 동작 여부 확인 방법

SQL 실행 후 통계 확인

SELECT name, value FROM v$sysstat WHERE name LIKE '%cell%';

중요 지표:

cell physical IO interconnect bytes returned by smart scan Smart Scan 발생 시 증가
physical read total bytes 전체 읽기량
이 두 값을 비교하면 Smart Scan이 얼마나 적용됐는지 파악 가능

실행 계획에서 확인

EXPLAIN PLAN FOR SELECT ...; SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

TABLE ACCESS STORAGE FULL 이 나타나면 Smart Scan 발생 가능성 있음 ✅
TABLE ACCESS FULL 만 있다면 일반 블록 I/O

4. Smart Scan이 안 될 때의 대안

제한 원인우회 / 개선 방법

LOB/LONG 컬럼	필요한 컬럼만 선택하거나 SecureFiles LOB으로 전환
가상 컬럼	실제 컬럼으로 materialize 하거나 함수 기반 인덱스 검토
암호화 TS	Cell-based Decryption 활성화 (TDE + Exadata 기능)
ROWID 정렬 요구	정렬 제거 또는 옵티마이저 힌트 검토
255개 초과 컬럼	필요한 컬럼만 Projection

단순히 Smart Scan이 안 되는 상황을 피하는 것만으로도 성능 향상이 가능합니다.

5. Smart Scan 성능 영향 비교 (예시)

방식전송량네트워크 부하응답 속도

Smart Scan (오프로딩)	500MB 테이블 중 50MB만 전송	낮음	⚡ 빠름
전통 블록 I/O	500MB 전체 전송	높음	⏳ 느림

Smart Scan을 쓰는 것만으로도 쿼리 응답 시간이 수 배~수십 배 빨라질 수 있음.

✅ 6. 정리 요약

구분Smart Scan 가능Smart Scan 불가

일반 Heap Table Full Scan	✅	❌ Clustered Table
Direct Path Read	✅	❌ ROWID 순서 필요
지원 데이터 타입	NUMBER, DATE, VARCHAR2 등	❌ LOB, LONG
조건절	일반 Predicate	❌ Virtual Column Predicate
인덱스	테이블 Full Scan 기반	❌ Reverse Key, 압축 인덱스 Fast Full Scan

Smart Scan을 막는 요소를 제거하거나 회피하면, Exadata의 진짜 성능을 끌어낼 수 있습니다 ⚡

Smart Scan을 사용하는지 확인하려면 SQL 실행 계획과 관련 파라미터 설정을 잘 이해해야 합니다.

이를 위해 사용되는 대표적인 초기화 파라미터가 바로

CELL_OFFLOAD_PROCESSING
CELL_OFFLOAD_PLAN_DISPLAY

아래에 실무 기준으로 정리해드릴게요.

1. CELL_OFFLOAD_PROCESSING 파라미터

역할

Exadata Smart Scan(스토리지 오프로딩)을 활성화 또는 비활성화하는 파라미터입니다.
FALSE로 설정하면 Smart Scan 기능이 꺼지고, 전통적인 블록 I/O 방식으로만 동작합니다.
세션 단위로도 제어할 수 있어 튜닝이나 테스트 환경에서 자주 사용됩니다.

값설명

TRUE ✅	Smart Scan 및 오프로딩 기능 활성화 (기본값)
FALSE ❌	Smart Scan 비활성화 → 모든 스캔이 DB 서버에서 처리됨

설정 방법

✅ 세션 단위

ALTER SESSION SET CELL_OFFLOAD_PROCESSING = TRUE; -- 또는 ALTER SESSION SET CELL_OFFLOAD_PROCESSING = FALSE;

시스템 전체

ALTER SYSTEM SET CELL_OFFLOAD_PROCESSING = TRUE;

쿼리 단위 (힌트 사용)

SELECT /*+ OPT_PARAM('cell_offload_processing' 'false') */ * FROM sales WHERE amount > 1000;

특정 쿼리에서만 Smart Scan을 끄고 성능 차이를 비교할 때 유용합니다.

Smart Scan 사용 여부 테스트 예시

ALTER SESSION SET CELL_OFFLOAD_PROCESSING = TRUE; SELECT COUNT(*) FROM big_table WHERE col1 BETWEEN 100 AND 200;

Smart Scan 활성화 후 v$sysstat 또는 EXPLAIN PLAN으로 확인
(Offload 발생 시 TABLE ACCESS STORAGE FULL 표시)

ALTER SESSION SET CELL_OFFLOAD_PROCESSING = FALSE; SELECT COUNT(*) FROM big_table WHERE col1 BETWEEN 100 AND 200;

Smart Scan 비활성화 후 동일 쿼리 실행 시 TABLE ACCESS FULL로 표시됨.

2. CELL_OFFLOAD_PLAN_DISPLAY 파라미터

역할

실행 계획(EXPLAIN PLAN 또는 DBMS_XPLAN)에 **스토리지 오프로딩 정보(Offloaded Predicate)**를 표시할지 여부를 제어합니다.
Smart Scan이 실제로 어떤 조건(Predicate)을 스토리지에서 평가했는지를 확인할 수 있음 → 튜닝 시 매우 중요⚡

값설명

NEVER	실행 계획에 오프로딩 정보 표시 안 함
AUTO (기본값)	Smart Scan이 발생한 경우만 자동 표시
ALWAYS	Smart Scan 여부와 관계없이 항상 표시

설정 방법

✅ 세션 단위

ALTER SESSION SET CELL_OFFLOAD_PLAN_DISPLAY = ALWAYS;

시스템 전체

ALTER SYSTEM SET CELL_OFFLOAD_PLAN_DISPLAY = AUTO;

실행 계획에서 Smart Scan 정보 확인

EXPLAIN PLAN FOR SELECT * FROM big_table WHERE amount > 1000; SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

CELL_OFFLOAD_PLAN_DISPLAY = ALWAYS로 설정되어 있으면, 아래와 같은 내용이 실행 계획에 나타납니다

--------------------------------------------------------------------------------- | Id | Operation | Name | Offloadable? | Storage | --------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | | | | 1 | TABLE ACCESS STORAGE FULL | BIG_TABLE | YES | SmartScan | --------------------------------------------------------------------------------- Predicate Information (identified by operation id): --------------------------------------------------- 1 - storage("AMOUNT">1000)

storage(...) 또는 offloadable predicate가 보이면 Smart Scan이 동작한 것입니다 ✅

3. 실무 튜닝에서의 활용 시나리오

작업방법목적

Smart Scan 활성화 확인	CELL_OFFLOAD_PROCESSING=TRUE + 실행 계획	성능 활용 여부 파악
Smart Scan 비활성화 후 비교	CELL_OFFLOAD_PROCESSING=FALSE	오프로딩 효과 측정
오프로딩된 조건 확인	CELL_OFFLOAD_PLAN_DISPLAY=ALWAYS	Predicate Pushdown 튜닝
특정 조건 오프로딩 테스트	OPT_PARAM 힌트	쿼리별 영향 분석

4. 자주 함께 쓰는 진단 쿼리

Smart Scan 통계 확인

SELECT name, value FROM v$sysstat WHERE name LIKE '%cell%';

중요 지표:

cell physical IO interconnect bytes returned by smart scan
cell physical IO bytes eligible for predicate offload
cell physical IO bytes saved by storage index

Smart Scan이 제대로 동작할수록 interconnect bytes가 작고 saved by storage index가 증가합니다.

✅ 정리 요약

파라미터역할값설명

CELL_OFFLOAD_PROCESSING	Smart Scan 기능 on/off	TRUE / FALSE	Smart Scan 활성화 여부 제어
CELL_OFFLOAD_PLAN_DISPLAY	실행 계획에 오프로딩 정보 표시	NEVER / AUTO / ALWAYS	Smart Scan 동작 세부정보 확인 가능

Smart Scan 튜닝 시에는 다음 3단계를 활용하는 게 실무 팁입니다

CELL_OFFLOAD_PROCESSING으로 Smart Scan on/off 비교
CELL_OFFLOAD_PLAN_DISPLAY로 실제 Predicate Pushdown 확인
v$sysstat 및 실행 계획을 통해 I/O 절감 효과 측정

**Oracle Exadata**에서 Smart Scan이 실행 계획에 표시된다고 해서 무조건 스토리지 오프로딩이 완벽히 적용되는 건 아닙니다.

실제 운영 환경에서는 Smart Scan이 부분적으로만 동작하거나 비활성화되는 상황도 종종 발생합니다.
이런 경우 원인을 파악하지 않으면 성능이 기대치만큼 나오지 않기 때문에, 실행 계획만 보는 것보다 통계와 Wait Event 분석까지 함께 해야 합니다.

아래에 상황별로 정리해드릴게요

1. “STORAGE”가 보인다고 무조건 Smart Scan이 아님 ⚠️

실행 계획에서

TABLE ACCESS STORAGE FULL

이렇게 보이더라도 다음과 같은 이유로 Smart Scan이 완전히 적용되지 않을 수 있습니다.
즉, 실제로는 Block I/O가 일부 또는 전부 사용될 수도 있다는 뜻입니다.

⚠️ 2. Smart Scan이 부분적으로만 동작하는 주요 상황

상황설명영향

① 블록의 최신 상태를 스토리지가 확신할 수 없는 경우	변경 가능성이 있는 블록은 Smart Scan으로 처리 불가 → 블록을 DB 서버로 전송해 버퍼 캐시에서 확인	Smart Scan 부분 적용
② Chained / Migrated Rows 발생	한 행이 여러 블록에 걸쳐 있을 경우, Smart Scan으로는 완전한 로우 반환 불가 → 추가 블록 I/O 발생	성능 저하
③ Dynamic Sampling 발생	옵티마이저가 실행 전 샘플링을 위해 별도 I/O 수행 → Smart Scan 미사용	성능 예측치와 실제치 차이
④ 스토리지 서버 CPU 과부하	셀 서버의 CPU가 DB 서버보다 많이 사용되고 있으면 일부 처리를 DB로 되돌림	성능 하락
⑤ 데이터가 이미 버퍼 캐시에 존재	Smart Scan이 필요 없어짐 → Buffer Cache Copy 사용	디스크 I/O 자체 미발생
⑥ Storage Server Quarantine 발생	문제가 된 스토리지 셀에서 Smart Scan이 비활성화됨	Smart Scan 완전 차단

3. 각 상황에 대한 조금 더 구체적 설명

(1) Block Current Check

Smart Scan은 기본적으로 **읽기 전용 데이터(consistent read)**에 최적화되어 있음.
블록이 변경되었거나 dirty 상태일 가능성이 있을 때, Exadata는 그 블록을 DB 서버로 전송해 버퍼 캐시에서 검증합니다.
Smart Scan은 적용되지만, 추가 블록 I/O가 발생함.

(2) Chained / Migrated Rows

한 행이 여러 블록에 걸쳐 있으면, 스토리지 셀에서 완전한 레코드를 구성할 수 없음.
Smart Scan으로 일부만 가져오고 나머지는 일반 Block I/O로 처리.
테이블 설계나 PCTFREE 설정, 행 크기 조정 등을 통해 완화할 수 있음.

(3) Dynamic Sampling

옵티마이저가 실행 시점에 통계 샘플링을 위해 디스크에서 데이터를 읽는 경우 Smart Scan이 적용되지 않음.
OPTIMIZER_DYNAMIC_SAMPLING 수준을 적절히 조정하거나 통계를 미리 수집하는 것으로 회피 가능.

(4) Storage CPU 부하

스토리지 셀에서 Smart Scan을 수행할 CPU가 충분하지 않으면, 일부 predicate를 DB 서버에서 처리하게 됨.
스토리지 CPU 모니터링이 필요합니다 (cellcli metric 또는 AWR I/O 보고서 활용).

(5) Buffer Cache Hit

Smart Scan은 디스크 I/O가 발생할 때만 작동합니다.
이미 데이터가 버퍼 캐시에 있으면, DB 서버가 캐시에서 데이터를 바로 반환 → Smart Scan 자체가 동작하지 않음.

(6) Storage Server Quarantine

스토리지 셀에 장애나 오류가 발생하면 Oracle이 자동으로 해당 셀을 격리(quarantine).
이 경우 Smart Scan은 비활성화되고, 일반 블록 I/O 경로로만 처리됨.
셀 상태 복구 후 정상 동작 재개 필요.

4. Smart Scan 실제 동작 여부 확인 방법

단순히 실행 계획만으로는 부족하고 통계와 Wait Event를 같이 봐야 합니다.

① 실행 계획

EXPLAIN PLAN FOR SELECT ...; SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

TABLE ACCESS STORAGE FULL → Smart Scan 가능성 존재
단, 확정은 아님 ❗

② 시스템 통계(v$sysstat)

SELECT name, value FROM v$sysstat WHERE name LIKE '%cell%';

중요 지표:

cell physical IO interconnect bytes returned by smart scan
cell physical IO bytes eligible for predicate offload
cell physical IO bytes saved by storage index

Smart Scan이 제대로 동작하면 interconnect bytes 값이 작고 predicate offload가 커짐.

③ Wait Events

SELECT event, total_waits, time_waited FROM v$system_event WHERE event LIKE 'cell%';

대표적인 Smart Scan 관련 Wait Event:

cell smart table scan
cell smart index scan

이 이벤트가 보이면 실제 Smart Scan이 발생한 것입니다.

5. 성능 분석 시 팁

확인 항목정상 Smart ScanSmart Scan 부분/비활성

실행 계획	STORAGE 표시됨	STORAGE 표시됨
cell 통계	Interconnect bytes ↓	Interconnect bytes ↑ 또는 거의 없음
Wait Event	cell smart table scan	db file sequential/scattered read 증가
스토리지 CPU	여유 있음	과부하 발생 가능
Buffer Cache	적중률 적당	너무 높을 경우 Smart Scan 비활성

✅ 6. 요약 정리

구분Smart Scan 정상 동작Smart Scan 영향 받는 경우

실행 계획	STORAGE FULL	동일 (단서만 제공)
I/O 경로	대부분 스토리지 처리	일부 또는 전체 Block I/O 발생
대표 상황	대용량 Table Scan	변경 블록, 체인 로우, Dynamic Sampling 등
진단 방법	v$sysstat, Wait Event, 실행계획	통계/이벤트/스토리지 상태 함께 확인

핵심 포인트:
실행 계획에 STORAGE가 보인다고 Smart Scan이 100% 적용되는 게 아닙니다.
실제 동작은 통계 + Wait Event + 스토리지 상태까지 함께 봐야 정확히 판단할 수 있어요.

service time = cpu time + wait time

cpu큰데, wait작다 ?

즉, 자원대기는 안하는데 cpu time 크다 ? 작업량 많은 상황 => 해결? sql튜닝

이럴 경우, 통계를 보면 안다.

statics : pysical & reads logical reads

cpu작은데, wait크다?

즉, 메모리 크게 변경 등, instanent 튜닝으로 해결

wait event : buffer busy waits => ASSM

Monitoring Exadata Smart Scan

V$SESSION_EVENT 세션단위로 스마트스캔이 일어났는지 확인 불가

=> v$system_event 시스템 단위로 스마트스캔 일어났는지 확은 가능함

but, 확인 방법은 처음 실행 후 다시 실행했을 때 스마트 스캔이 일어났는지 확인함

6216 -> 6509 아, 스마트스캔 실행됐구나 확인가능함

아니면 트레이스파일로 마스터프로세스랑 슬래이브프로세스가 실행한 걸 확인하여 알 수도 있음

[Exadata day2] Exadata 핵심기능 및 초기 설정

aonee — Wed, 22 Oct 2025 09:49:20 +0900

4~6장: 핵심 기능 및 초기 설정

4장: Smart Scan, Smart Flash Cache, PMEM 등 Exadata 성능 최적화 기술
5장: 설치 전 준비(OEDA 사용), 초기 설치 및 배포 절차
6장: 스토리지 서버(Cell) 구성 — CellCLI, Grid Disks, ASM Disk Group 설정

Classic Database I/O and SQL Processing Model

전통적인 DB(SQL) 처리 방식이란?

예전 방식의 데이터베이스 시스템에서는 “모든 똑똑한 처리”가 데이터베이스 서버 안에서만 이뤄집니다.
즉, 저장소(스토리지)는 단순히 데이터를 보관만 하고, 실제 연산은 모두 서버가 처리하죠.

예시: 테이블에서 데이터 검색(SELECT)할 때의 처리 과정

사용자가 SELECT문 실행
→ 예: “이 조건에 맞는 고객 정보만 보여줘!”
DB가 해당 데이터 위치 확인
→ 어떤 파일·영역(Extent)에 이 테이블이 저장돼 있는지 찾아냅니다.
DB가 스토리지에 읽기 요청
→ 테이블이 저장된 모든 블록(데이터 조각)을 읽어오라고 요청합니다.
모든 블록을 메모리로 가져옴
→ 조건에 맞는 데이터만 필요한데도, 테이블 전체 블록이 메모리로 올라옵니다.
DB 서버에서 조건 필터링 작업
→ 가져온 데이터 중에서 SELECT 조건에 맞는 행만 찾습니다.
필요한 행만 사용자에게 반환
→ 최종적으로 원하는 결과만 보여집니다.

⚠️ 비효율이 생기는 이유

조건에 맞는 데이터만 필요한데도 → 테이블 전체를 읽어야 함
이 과정에서 네트워크로 데이터가 대량 전송되고 메모리를 많이 차지함
즉, 불필요한 데이터 I/O(읽기 작업)가 엄청나게 발생함
결과적으로 속도 저하, 서버 부하 증가, 처리 효율 저하로 이어집니다.

✅ 정리하자면

“조건에 맞는 데이터만 딱 읽는 게 아니라, 테이블 전체를 읽은 뒤에 걸러내는 방식”이라서 비효율적입니다.
특히 큰 테이블일수록 이런 낭비가 커지고, 시스템 성능에 영향을 줍니다.

Exadata Smart Scan Model

⚡ Exadata Smart Scan이란?

Oracle Exadata는 기존 방식과 달리, 단순히 데이터를 저장만 하는 게 아니라 스토리지(저장장치) 자체에서 데이터를 먼저 걸러주는 똑똑한 방식을 사용합니다.
즉, 필요한 데이터만 서버로 보내기 때문에 속도도 빠르고 자원 낭비도 훨씬 줄어듭니다.

Exadata Smart Scan의 처리 과정

사용자가 SELECT문 실행
→ 예: “특정 조건에 맞는 고객 정보만 보여줘!”
DB가 Exadata 저장소에 명령 전달
→ 이 데이터가 Exadata 셀에 있으면, 서버가 iDB라는 특수 명령으로 직접 스토리지에게 작업을 시킵니다.
스토리지에서 먼저 필터링 작업
→ Exadata가 **필요한 행(Row)**과 **필요한 컬럼(Column)**만 미리 골라냅니다.
→ 즉, 조건에 안 맞는 데이터는 아예 서버로 올라오지 않음❌ where절 처리함
필요한 데이터만 서버로 전송
→ 기존처럼 블록 단위가 아니라, 결과만 요약해서 iDB 메시지로 전달합니다.
→ 버퍼 캐시에 블록을 저장할 필요도 없습니다.
DB 서버에서 결과 합치기
→ 여러 Exadata 셀에서 온 결과를 병렬 처리처럼 합쳐 최종 결과를 만듭니다.
사용자에게 결과 전달 ✅

이렇게 하면 좋은 점

불필요한 I/O가 거의 없음 → 테이블 전체를 읽지 않음
CPU 사용량 절감 → 서버는 결과만 합치면 되니까 가벼워짐
⚡ 쿼리 속도 향상 → 큰 테이블도 빠르게 조회 가능
더 많은 요청을 동시에 처리 가능

전통 방식 vs Exadata Smart Scan

구분전통적인 DB 방식Exadata Smart Scan 방식

데이터 필터링 위치	DB 서버에서 처리	스토리지(Exadata)에서 처리
I/O 발생량	테이블 전체 블록 전송	필요한 데이터만 전송
CPU 사용량	서버에서 많은 연산 수행	서버 부담 감소 (스토리지에서 전처리)
속도	느릴 수 있음 (대량 데이터 전송 때문)	빠름 (필요한 결과만 전송)

✅ 정리하자면

Exadata Smart Scan은 “필요한 데이터만 똑똑하게 골라서 보내주는” 기술입니다.
덕분에 쿼리 성능이 대폭 향상되고, 서버 자원도 절약할 수 있습니다.

Smart Scan vs Index Scan ?

1. Index Scan 이란?

Index Scan은 말 그대로 “인덱스”를 이용해서 필요한 데이터 위치만 찾아 읽는 방식입니다.

동작 방식

DB는 인덱스를 검색해서 조건에 맞는 ROWID(데이터의 위치)를 찾습니다.
그 위치로 가서 필요한 데이터 블록만 읽어옵니다.
조건에 맞는 데이터를 추출해서 사용자에게 전달합니다.

장점

필요한 데이터가 적을 때 매우 빠름 ✅
불필요한 블록을 거의 읽지 않음 (정확한 위치 접근)

⚠️ 단점

매우 많은 데이터를 읽을 경우, 인덱스를 통해 건건이 찾아가야 하므로 오히려 느릴 수 있음.
Full Table Scan보다 비효율적일 수도 있음(랜덤 I/O 증가).

⚡ 2. Smart Scan 이란?

Smart Scan은 Exadata에서만 가능한 방식으로, 스토리지에서 먼저 필터링해 불필요한 데이터를 아예 안 올리는 방식입니다.

동작 방식

서버는 SELECT 조건을 Exadata 스토리지에 전달합니다.
Exadata가 스토리지 단에서 조건에 맞는 행과 컬럼만 추출합니다.
필요한 데이터만 서버로 전달합니다.

장점

테이블이 크고, 조건이 있는 Full Table Scan일 때 매우 효율적 ✅
불필요한 I/O 최소화, 네트워크 부하 적음, 속도 빠름

⚠️ 단점

인덱스를 쓰는 상황(소량의 특정 행 검색)에는 Smart Scan이 굳이 필요 없음.
Smart Scan은 주로 대량 데이터 조회에서 성능이 극대화됨.

Index Scan vs Smart Scan

항목Index ScanSmart Scan (Exadata)

처리 위치	DB 서버	스토리지(Exadata 셀)
대상 데이터 양	소량의 특정 데이터에 적합	대량 데이터 + 조건 검색 시 유리
I/O 방식	인덱스를 통해 필요한 블록만 랜덤 접근	스토리지에서 먼저 필터링 후 최소 데이터만 전송
CPU 부하	서버 CPU 사용	스토리지에서 분산 처리 → 서버 부담 적음
사용 시점	WHERE 절로 특정한 데이터만 찾을 때	Full Table Scan 시 성능 극대화 (조건 필터링 있음)
대표 예	“ID = 12345” 한 건 찾기	“매출 100만원 이상 고객 전체 조회” 같이 대량 검색

정리하자면

Index Scan → 소량의 특정 데이터를 찾을 때 유리 (인덱스 활용)
⚡ Smart Scan → 대량 데이터를 조건으로 걸러낼 때 유리 (스토리지에서 필터링)

✅ 팁:

Exadata 환경에서도 소량 데이터라면 Index Scan이 Smart Scan보다 빠를 수 있습니다.
반대로 수십~수백만 건 이상을 조회할 때는 Smart Scan이 압도적으로 빠릅니다.

Exadata Storage Index

1. Storage Index란?

“**스토리지(저장소)**에 있는 데이터의 최솟값/최댓값 정보를 기억해두고,
조건에 안 맞는 영역은 아예 읽지 않게 해주는 기능”

기존에는 모든 블록을 읽은 후에 조건에 맞는 데이터를 걸러냈지만,
Storage Index는 읽기 전에 “이 영역은 볼 필요 없어”라고 미리 판단합니다.

2. 내부 구조 (간단 버전)

Exadata의 디스크는 1MB 단위로 잘게 나뉘어 있는데, 이를 Storage Region이라고 합니다.
각 Region마다 **최솟값(MIN)**과 최댓값(MAX) 정보를 메모리에 저장해둔 것이 Region Index입니다.
여러 Region Index를 모은 것이 바로 Storage Index예요.

예:

RegionB 컬럼 MINB 컬럼 MAX

1MB 1	1	5
1MB 2	3	8

쿼리 시 이 정보를 기준으로 읽을지/건너뛸지 판단합니다.

3. Storage Index의 장점

불필요한 I/O 제거 → 디스크에서 덜 읽으니 빠름
서버 부하 감소 → 읽을 게 줄어드니 CPU/메모리 절약
⚡ 자동으로 관리됨 → DBA가 따로 인덱스를 만들 필요 없음

4. 특징 & 제약사항

항목내용

관리 필요 여부	❌ 없음 — 자동으로 생성/삭제
작동 시점	Smart Scan 시 자동 활용
데이터 유형 제한	숫자(NUMBER), 날짜(DATE), 문자열(VARCHAR2) 등은 가능 단 NLS 의존 타입은 불가
사라지는 시점	메모리에만 존재 → 셀이 재부팅되면 사라짐
복구 방식	재부팅 후 첫 쿼리 시 자동 재생성
가장 효과적인 상황	- 데이터가 정렬되어 있거나 잘 클러스터링된 경우 - WHERE 절에 =, <, > 조건이 있는 경우

5. Cold vs Hot, Smart Scan과의 관계

Storage Index는 Smart Scan과 함께 작동합니다.
Smart Scan이 실제로 데이터를 읽는 동안 Storage Index는
“이 구간은 읽지 말자” 하고 범위를 건너뛰는 역할을 합니다.
따라서 대량의 Full Table Scan + 조건 검색에서 효과가 극대화됩니다.

✅ 한 줄 정리

Storage Index = 읽기 전 필터링 장치
블록을 읽기 전에 조건에 맞는지 미리 확인 → 불필요한 I/O를 스킵 → 쿼리 속도 ↑, 자원 ↓

B-Tree Index vs Storage Index

1. B-Tree Index (일반 인덱스)

“필요한 데이터의 위치를 직접 찾아가는 방식”

⚙️ 동작 방식

사용자가 WHERE 조건이 있는 쿼리를 실행
예:
SELECT * FROM T1 WHERE B = 3;
옵티마이저가 해당 컬럼에 인덱스가 있는지 확인
B-Tree 인덱스를 탐색하여 조건에 맞는 ROWID(실제 데이터 위치) 검색
찾은 ROWID로 테이블 블록에서 해당 데이터만 읽어옴
결과를 사용자에게 반환

즉, 인덱스를 이용해 원하는 데이터를 “정확히 찾아가는” 방식이에요.

특징

데이터 소량 조회에 매우 효율적 (랜덤 I/O)
WHERE 조건이 인덱스 컬럼에 있어야 함
인덱스 생성·관리 필요 (DBA 개입)

⚡ 2. Storage Index (Exadata 전용)

“읽기 전에 불필요한 범위를 미리 건너뛰는 방식”

⚙️ 동작 방식

쿼리가 들어오면, Exadata의 Storage Index에서
각 Region(1MB 단위)의 컬럼 MIN/MAX 값을 확인
조건에 절대 부합하지 않는 구간은 아예 읽지 않음
예: MIN=3, MAX=8 인 영역에 B<2 조건이 있으면 스킵
조건에 맞을 가능성이 있는 영역만 Smart Scan으로 읽음
필터링된 결과만 서버로 전송

즉, “읽고 찾는” 게 아니라 “읽기 전에 걸러내는” 방식이에요.

특징

대량 데이터 + 조건 검색 시 효과적
인덱스 생성 필요 없음 (자동)
정렬(클러스터링)이 잘 된 데이터일수록 효과 극대화
Smart Scan 시에만 작동

3. 동작 방식 비교 요약

항목B-Tree IndexStorage Index (Exadata)

목적	원하는 데이터 정확히 찾아감	불필요한 범위를 미리 걸러냄
접근 방식	인덱스를 탐색해 ROWID로 직접 접근	MIN/MAX 정보로 조건에 안 맞는 블록을 Skip
처리 위치	DB 서버에서 처리	Exadata 스토리지에서 필터링
데이터 양	소량 데이터 조회에 유리	대량 데이터 + 조건 검색 시 유리
관리 필요 여부	인덱스 생성·관리 필요	자동 (사용자 개입 없음)
작동 시점	옵티마이저가 인덱스 선택 시	Smart Scan 시
결과	필요한 데이터만 읽음	필요 없는 영역을 스킵하고 나머지 읽음

핵심 정리

B-Tree Index
→ “목표 지점만 정확히 찾아간다”
→ 소량 조회에 강함 (랜덤 I/O)
Storage Index
→ “볼 필요 없는 구간은 애초에 안 본다”
→ 대량 스캔 시 빠름 (불필요한 I/O 감소)

둘 다 인덱스지만,

B-Tree는 찾는 도구
Storage Index는 걸러내는 필터라고 이해하면 정확합니다 ✅

Hybrid Columnar Compression

1. Hybrid Columnar Compression이란?

행(Row) 단위가 아닌 컬럼(Column) 단위로 압축하는 방식.

기존 압축은 **행 기반(row-based)**으로 압축합니다.
HCC는 같은 컬럼의 값들을 모아 압축하기 때문에 패턴이 잘 맞아 압축률이 훨씬 높습니다.
특히 대량 데이터를 저장하는 데이터 웨어하우스(DW) 환경에서 효과가 큽니다.

2. 적용 위치

HCC는 아래 위치에서 설정할 수 있습니다.

✅ 테이블 단위
✅ 파티션 단위
✅ 테이블스페이스 단위

즉, 필요한 범위에만 적용할 수 있어 유연합니다.

⚙️ 3. 압축 모드 2가지

모드특징목적압축률CPU 부하

Warehouse Compression	쿼리 성능에 최적화	DW(분석) 환경	중간~높음	낮음
Online Archival Compression	압축률 극대화	거의 변하지 않는 데이터	매우 높음	높음(압축/해제 시)

Warehouse 모드 → 분석용 쿼리 속도도 빠르고 압축도 잘됨
Online Archival 모드 → 자주 쓰이지 않는 ‘콜드 데이터’ 보관에 최적

4. 작동 방식 (간단 예시)

기존 방식:

행1: A=100, B=200, C=300 행2: A=101, B=201, C=301 행3: A=102, B=202, C=302

HCC 방식:

컬럼 A: 100, 101, 102 컬럼 B: 200, 201, 202 컬럼 C: 300, 301, 302

컬럼 단위로 묶어서 압축하면 반복되는 값을 효과적으로 줄일 수 있어
저장 공간 절약, 읽기 시 더 적은 블록으로 많은 데이터 처리 가능

5. 실무 활용 포인트

파티셔닝과 병행해서 운영 가능 → 예: 최신 데이터는 OLTP 압축, 과거 데이터는 HCC
DBMS_COMPRESSION 패키지의 Compression Advisor로 예상 압축률 확인 가능
압축된 데이터는 Smart Scan과 함께 작동 → 성능 이점 극대화
자주 수정되는 데이터엔 적합하지 않음 (압축 해제·재압축 비용 발생)

6. HCC vs 기존 압축 비교

항목Basic/OLTP 압축Hybrid Columnar Compression

압축 단위	행 기반	컬럼 기반
압축률	보통	매우 높음
성능 최적화	DML(수정)	SELECT(조회)
사용 시나리오	트랜잭션 처리	DW·아카이브·콜드 데이터
Smart Scan 호환	일부	✅ 완벽 호환

정리하자면

Hybrid Columnar Compression = “컬럼 단위로 묶어 고압축 + 빠른 읽기” 기술
저장공간 절약 + 쿼리 성능 향상 + 아카이브 데이터 관리에 최적.

자주 조회하지만 자주 수정되지 않는 데이터에 적합.
Exadata 환경에서 Smart Scan과 Storage Index와 함께 쓰면 성능 효과가 폭발적입니다

[Exadata day1] Exadata 기초

aonee — Mon, 20 Oct 2025 16:41:45 +0900

1~3장: Exadata 기초

1장: Exadata 개요 및 배경, 배포 모델, 리소스 안내
2장: 하드웨어 구성요소(X8M, 랙 구성, 확장성)
3장: 네트워크 아키텍처(RDMA/RoCE), 스토리지 아키텍처 및 멀티랙 구성

Oracle Exadata
오라클 데이터베이스 전용 초고성능 통합 시스템으로, 단순 서버가 아니라 DB 성능을 극대화하기 위한 HW+SW 일체형 어플라이언스입니다.
특히 대기업, 금융권, 공공기관 등 대용량 트랜잭션·분석 시스템에서 널리 쓰입니다.

1. 엑사(Exadata)가 제공하는 핵심 기능

✅ ① Smart Scan (스마트 스캔) — 불필요한 I/O 제거

일반 서버는 모든 데이터를 읽어서 DB에서 필터링하지만,
Exadata는 스토리지 레벨에서 WHERE 조건 등을 미리 처리합니다.
즉, 필요한 데이터만 네트워크로 올리기 때문에 속도가 수십 배 빨라짐.
대규모 테이블 조회나 DW(데이터 웨어하우스) 쿼리에서 효과가 큽니다.

⚡ ② Storage Offload (스토리지 오프로딩) — CPU 부담 감소

DB 서버 대신 스토리지 서버가 일부 쿼리 연산(필터링, 집계)을 처리합니다.
DB 서버는 결과만 받아서 빠르게 응답.
동일한 하드웨어로도 처리량(Throughput) 대폭 증가.

③ Hybrid Columnar Compression (HCC) — 압축 기능

데이터를 행+열 혼합 방식으로 압축해 저장 공간 절감 (최대 10~50배).
압축된 상태로 바로 읽을 수 있어 I/O 속도도 빠름.
DW·백업 영역에서 특히 효과적.

④ Automatic Storage Management (ASM) — 자동 스토리지 관리

스토리지를 수동으로 설정하지 않고, 자동 스트라이핑·미러링·리밸런싱.
장애 발생 시 자동으로 복구.
스토리지 운영 부담이 크게 줄어듦.
참고: 이때 쓰이는 게 Oracle Automatic Storage Management입니다.
ASM의 핵심 역할
- 물리 디스크를 ASM이 자동으로 묶어서 하나의 논리적 스토리지 그룹(Disk Group)으로 만듭니다.
- 데이터베이스는 개별 디스크가 아니라 이 Disk Group을 바라보며 I/O를 수행합니다.
- 덕분에 성능, 가용성, 관리 편의성이 모두 향상됩니다.
- [Oracle Database]
          │
          ▼
  [ASM Instance]
          │
          ▼
  [Disk Group (ex: DATA, FRA)]
          │
          ▼
  [Physical Disks]
- Database Instance: 실제 애플리케이션 데이터를 처리
- ASM Instance: 디스크 그룹을 관리하는 전용 인스턴스 (DB 인스턴스와 별도)
- Disk Group: 여러 물리 디스크를 묶은 논리 그룹
- Physical Disks: 실제 저장 매체
미러링 (Data Mirroring — ASM 기능)
- Exadata의 스토리지는 Oracle Automatic Storage Management(ASM)으로 관리됩니다.
- 모든 데이터는 디스크에 2~3중 복제(미러링) 되어 저장돼요.
상황결과

디스크 하나 망가짐 미러본으로 서비스 정상 운영

디스크 교체 ASM이 자동으로 데이터 재복제
- 이 기능 덕분에 디스크나 스토리지 장애가 나도 데이터가 안전하게 유지되고 서비스는 중단되지 않습니다.
쉽게 말하면…
“중요한 파일을 자동으로 복사해두는 보험 같은 기능”

️ ⑤ 고가용성(HA) & 자동 복구

노드 장애 시 자동 Failover
데이터 미러링 및 RAC(Real Application Cluster) 구조로 무중단 서비스 가능.
장애 복구 시간 최소화 → 금융·거래 시스템에 필수적 기능.
RAC (Real Application Clusters)

일반 DB RAC 구성

서버 1대 다운 = 서비스 중단 다른 서버가 즉시 이어받음 (무중단)
- 예: Exadata에 DB 서버 4대가 있다고 가정하면
  → 하나가 죽어도 나머지 3대가 자동으로 트래픽을 이어받아 서비스 지속
- 부하가 분산되므로 성능도 안정적임.
- 은행이나 카드사 같은 24시간 서비스에 매우 적합합니다.
쉽게 말하면…
“한 서버가 죽어도 서비스가 멈추지 않는 안전장치”
Oracle Real Application Clusters는
여러 대의 서버(DB 인스턴스)가 하나의 데이터베이스를 동시에 운영하는 기능입니다.

⑥ 초고속 네트워크 (InfiniBand / RoCE)

서버–스토리지 간 40~100Gbps급 초고속 네트워크를 사용.
대용량 데이터를 빠르게 전송하고 지연 시간 최소화.

⑦ 자동화된 운영 및 패치

펌웨어, OS, DB, 스토리지까지 통합 관리 및 자동 패치 제공.
수동 튜닝이나 복잡한 설정을 최소화.
DBA가 성능 조정에 시간을 덜 쓰고, 비즈니스에 집중 가능.

⑧ OLTP + OLAP 통합 처리

기존에는 실시간 거래(OLTP)와 분석(OLAP)을 분리해 운영했지만,
Exadata는 한 시스템에서 둘 다 고성능으로 동시 처리가 가능.
실시간 데이터 분석 환경 구축에 유리.

2. 주요 활용 분야

산업 활용 예시

금융	실시간 거래 처리, 리스크 분석
공공기관	빅데이터 분석, 민원/통계 처리
제조	ERP, MES, 재고 및 공급망 관리
통신	실시간 과금, 고객 데이터 분석
리테일	마케팅 분석, POS 거래 처리

3. Exadata 아키텍처 구성 요약

[DB Server]      ← RAC 구성
      │
[InfiniBand Network]
      │
[Storage Server] ← Smart Scan, Offload, Compression

DB 서버: SQL 처리, 트랜잭션 관리
스토리지 서버: 데이터 저장 + 일부 연산 처리
네트워크: 초고속 InfiniBand (혹은 RoCE)
ASM + Grid Infra로 스토리지 및 클러스터 관리

4. 정리 — Exadata의 핵심 장점

압도적인 성능: Smart Scan, Offload, HCC로 속도 향상
️ 높은 안정성: RAC + 자동 복구 + 미러링
운영 효율성: 통합 관리 및 자동화
유연한 확장성: 노드 추가만으로 성능 선형 확장
OLTP & OLAP 통합 처리

결론:
엑사(Exadata)는 단순히 오라클 DB를 올리는 서버가 아니라,
**“DB 성능을 극대화하고 장애 없이 안정적으로 운영하기 위한 통합 플랫폼”**입니다.

원하신다면 Exadata의 실제 운영 환경(노드 수, 데이터 흐름 구조도)을 시각적으로 설명해드릴 수도 있어요.
그림으로도 볼까요? ️✨

Exadata vs Non-Exadata ?

Exadata 환경과 비교해 보기

항목ExadataNon-Exadata

하드웨어	Oracle 전용 HW + SW 통합	HP, Dell 등 일반 서버 + 외부 스토리지
스토리지	Smart Scan + ASM 자동화	일반 파일 시스템 or ASM 수동 구성
네트워크	InfiniBand 초고속	Ethernet (일반)
성능 최적화	Oracle이 HW/DB에 최적화	관리자가 튜닝 필요
장애 복구	RAC + ASM 자동 복구	수동 장애 조치 비중 큼
패치/운영	일괄 관리 도구 제공	개별 컴포넌트별 관리 필요
비용	고가 (올인원)	상대적으로 저렴, 하지만 관리 복잡

쉽게 비유하면…

️ 엑사데이터 = 오라클이 설계부터 시공까지 한 “초고속 스마트 빌딩”
일반 환경 = 철근, 콘크리트, 배관, 전기 모두 따로 사서 조립하는 “수작업 빌딩”

성능을 비슷하게 내려면 많은 튜닝, 관리자 숙련도, 여분 자원이 필요합니다.

실습 패스워드

Exadata Network Architecture

Exadata의 전체 구조는 크게 DB 서버 측 구성요소와 스토리지(Cell) 측 구성요소로 나눌 수 있습니다.

️ 2. Database Server 측 구성 요소

구성 요소설명

OS	Exadata X8M-2부터 RoCE Fabric 환경에서는 Oracle Linux KVM이 기본 가상화 기술로 도입됨. 8소켓 DB 서버에서는 전통적인 Oracle Linux만 사용 가능.
DB Engine	Oracle Database 11gR2, 12c, 18c, 19c 지원. Exadata Storage Software와의 호환성에 맞는 정확한 patch level 필요. DB 19c를 사용하려면 Oracle Grid Infrastructure 19c가 필수.
Grid Infrastructure	클러스터링 및 ASM 관리 기능 제공. RAC 및 HA(고가용성)의 핵심.
ASM (Automatic Storage Management)	오라클 DB 최적화 볼륨 매니저 + 파일 시스템 역할. 스토리지 계층을 추상화해 DB가 효율적으로 I/O 수행 가능하도록 함.
RAC (Real Application Clusters)	여러 DB 인스턴스를 하나의 DB에 연결해 고가용성과 확장성 보장.

3. Exadata Storage Cell 측 구성 요소

구성 요소설명

Cell Server (CELLSRV)	Smart Scan, Offload 처리, 데이터 읽기 최적화 담당
Management Server (MS)	상태 모니터링, 알람, 스토리지 관리 기능
Restart Server (RS)	장애 시 Cell Server 재시작 관리
Storage Tiering	PMEM → Flash → HDD 계층적 스토리지 구조로 고속 I/O 지원

⚡ 4. 주요 동작 흐름

클라이언트 쿼리 실행 → DB 서버의 Oracle Database가 파싱 및 실행 계획 수립
ASM이 스토리지 접근을 중개
Exadata Cell Server가 Smart Scan 수행 — 필요한 데이터만 반환
PMEM/Flash 계층을 우선 활용해 지연 시간 최소화
결과를 DB 서버로 전송, RAC 인스턴스가 집계 후 응답

5. 소프트웨어 버전 관리

Exadata는 DB, Grid Infra, Storage Server Software 버전 간 호환성이 매우 중요합니다.
공식 호환 버전은 My Oracle Support 문서 888828.1 에서 확인 가능.
업그레이드 시 반드시 GI와 Storage Software의 조합을 맞춰야 함.

정리

구성 영역주요 구성 요소역할

Database Server	Oracle Linux / KVM, DB Engine, GI, ASM, RAC	SQL 처리, 클러스터, 스토리지 가상화
Storage Cell	CELLSRV, MS, RS, PMEM/Flash/HDD	Smart Scan, Offload, 스토리지 최적화
네트워크	RoCE or InfiniBand	초고속 전송, 저지연
관리	MOS, Patch, Fleet Maintenance	버전 호환성 유지 및 관리

한 줄 요약

Exadata는 DB 서버의 ASM + RAC + GI와 Storage Cell의 Smart Scan + 계층형 스토리지가 결합된 아키텍처로, 초고속·고가용성·자동화된 데이터베이스 플랫폼입니다.

디스크 계층 구조
(Physical Disk → LUN → Cell Disk → Grid Disk → ASM Disk Group)

Exadata는 물리 디스크를 바로 ASM에 연결하지 않고,
여러 단계의 논리적 계층으로 감싸서 성능·가용성·관리 편의성을 극대화합니다.

1. Exadata 디스크 계층 구조 개요

[ Physical Disk (12ea per cell) ]
           │
           ▼
[ LUN (Logical Unit Number) ]
           │
           ▼
[ Cell Disk ]
           │
           ▼
[ Grid Disk (1~N) ]
           │
           ▼
[ ASM Disk Group ]

2. Physical Disk (물리 디스크)

각 Exadata High Capacity Storage Server에는 12개의 HDD가 장착됨.
Exadata Cell Software가 자동으로 디스크를 감지하므로, 관리자가 수동으로 추가/삭제할 필요 없음.
이 단계에서는 용량과 모델, 시리얼 번호 등의 제한된 속성만 확인 가능.

예:

Physical Disk 1 ... 12

3. LUN (Logical Unit Number)

각 물리 디스크는 하나의 LUN으로 매핑됨.
LUN은 Cell 관리자에게 디스크 관련 추가 메타데이터 속성을 제공합니다.
LUN은 수동으로 만들거나 삭제할 수 없으며, 시스템이 자동 생성합니다.

예:

LUN0 → Physical Disk 0
LUN1 → Physical Disk 1
...
LUN11 → Physical Disk 11

4. Cell Disk

LUN 위에 생성되는 데이터 저장의 기본 논리 단위입니다.
각 LUN마다 1개의 Cell Disk가 만들어짐.
이 단계에서 디스크 전체를 ASM에 바로 연결하지 않고, 한 번 더 추상화해서 스토리지 자원을 논리적으로 관리합니다.

예:

CellDisk_CD_01 → LUN0
CellDisk_CD_02 → LUN1
...

5. Grid Disk

Cell Disk 위에 생성되는 논리적 단위로, ASM이 직접 접근하는 단위입니다.
하나의 Cell Disk 위에 1개 이상 Grid Disk를 만들 수 있음. (1~N 개 가능)
Hot / Cold 데이터 구분을 위해 Cell Disk를 분할해 서로 다른 Grid Disk로 구성 가능.

예:

GridDisk_hot : 디스크 외곽 트랙 (성능 우수)
GridDisk_cold : 디스크 안쪽 트랙 (성능 낮음)

✅ 이렇게 구분하면 고성능이 필요한 테이블스페이스는 hot 영역, 백업이나 저활성 데이터는 cold 영역에 배치할 수 있음.

⚡ 6. ASM Disk Group

Grid Disk들이 ASM Disk로 인식되고,
이들을 모아 ASM Disk Group(ex. +DATA, +RECO)을 구성합니다.
Oracle DB는 이 ASM Disk Group만 바라보기 때문에 하위 디스크 구조를 신경 쓸 필요가 없습니다.

예:

+DATA : 고성능용 ASM Disk Group (hot)
+RECO : 백업 및 로그용 ASM Disk Group (cold)

7. 초기 구성 시 예시

초기 Exadata 설치 시 대부분의 Cell Disk에는 3개의 Grid Disk가 자동으로 생성됩니다:
- DBFS_DG
- DATA_DG
- RECO_DG
  → 각각 데이터, 복구 영역, 내부 파일 시스템용으로 사용됩니다.

물론 운영 환경에 따라 Grid Disk를 1개 또는 여러 개로 나눌 수 있습니다.

Hot / Cold 분리 예시

구분 위치 목적 설명

Hot Grid Disk	디스크 외곽 (Outer Track)	고성능 영역	자주 접근되는 데이터 저장
Cold Grid Disk	디스크 내측 (Inner Track)	저성능 영역	덜 접근되는 데이터 저장

✅ 디스크의 물리적 구조 특성상 외곽 트랙이 I/O 속도가 더 빠릅니다.

정리

계층 역할 생성 방법 ASM과의 관계

Physical Disk	실제 디스크 (12개/셀)	하드웨어 고정	기본 리소스
LUN	디스크 논리 매핑	자동	메타데이터 제공
Cell Disk	LUN 상위 추상화	자동 생성 가능	Grid Disk의 기반
Grid Disk	ASM이 보는 단위	수동 or 자동 구성	ASM Disk로 인식
ASM Disk Group	DB가 보는 단위	ASM에서 구성	테이블스페이스와 연결됨

한 줄 요약

Exadata에서는 Physical Disk → LUN → Cell Disk → Grid Disk → ASM Disk Group 의 계층을 거쳐 Oracle Database가 스토리지에 접근합니다.
이를 통해 성능 계층화, 자동화, 관리 용이성을 모두 확보합니다.

좋은 질문이에요

지금 말씀하신 내용은 **Oracle Exadata Database Machine**의 스토리지 아키텍처 중
Grid Disk → ASM Disk Group → Redundancy / Failure Group 이라는 실제 운영에서 가장 중요한 핵심 개념입니다.

이 구조를 이해하면 Exadata의 고가용성(HA) 및 무중단 유지보수가 어떻게 가능한지 명확하게 이해할 수 있어요

1. Grid Disk → ASM Disk Group 매핑

Exadata에서 스토리지는 다음 흐름으로 구성됩니다:

Physical Disk
  → LUN
    → Cell Disk
      → Grid Disk (ex. 빨간색, 파란색)
        → ASM Disk Group (ex. DATA_1, FRA_1)

Grid Disk는 ASM Disk의 기본 단위로 쓰입니다.
여러 개의 Grid Disk를 묶어서 하나의 ASM Disk Group을 구성할 수 있습니다.
예를 들어:
- 빨간 Grid Disk 전부 → DATA_1 Disk Group
- 파란 Grid Disk 전부 → FRA_1 Disk Group

ASM의 역할: 데이터를 Disk Group에 넣으면 ASM이 알아서 모든 Grid Disk에 균등하게 데이터를 분산 저장합니다 (striping).

2. ASM Redundancy (중복성 옵션)

Exadata에서는 ASM Disk Group 생성 시 중복성 수준을 지정할 수 있습니다.

옵션 설명 복제본 수 Exadata 지원 여부

EXTERNAL	복제 없음	1	❌ 지원 안 함
NORMAL	2-way Mirroring	2	✅ 권장
HIGH	3-way Mirroring	3	✅ 고가용성 환경 권장

EXTERNAL redundancy는 Exadata에서 지원되지 않습니다.

이유: 저장소 장애 보호 불가
온라인 롤링 패치 및 셀 장애 대비 불가능

실무에서는 NORMAL 또는 HIGH redundancy를 사용합니다.

3. Failure Group 개념 (Exadata의 핵심 포인트)

Failure Group = ASM이 데이터를 복제할 때 서로 다른 물리적 영역(셀)

Exadata에서는 각 Storage Cell이 자동으로 하나의 Failure Group으로 설정됩니다.
예: 3개의 셀이 있다면 → CELL1, CELL2, CELL3 3개의 Failure Group이 자동 생성됨.

+-------------------------------+
| DATA_1 ASM Disk Group         |
|  ├─ FG: CELL1 (Grid Disk들)   |
|  ├─ FG: CELL2 (Grid Disk들)   |
|  └─ FG: CELL3 (Grid Disk들)   |
+-------------------------------+

✅ 이렇게 되면 한 셀이 죽더라도 나머지 셀에 복제본이 남아 있으므로 데이터 손실 없이 운영 가능.

4. 데이터 저장 방식 (Mirroring)

예를 들어 NORMAL redundancy를 사용하는 경우:

데이터 1블록을 CELL1에 저장하면
ASM이 자동으로 복제본을 CELL2 또는 CELL3에 저장합니다.

원본 → CELL1
미러 → CELL2

HIGH redundancy라면 3개의 Failure Group에 모두 복제됩니다:

원본 → CELL1
미러1 → CELL2
미러2 → CELL3

5. Failure Group 네이밍

Failure Group 이름은 기본적으로 Cell 이름을 따릅니다.
예:
- DATA_1 Disk Group → CELL1, CELL2, CELL3
- FRA_1 Disk Group → CELL1, CELL2, CELL3

서로 다른 Disk Group이라도 Failure Group 이름이 동일할 수 있음 (단, 서로 다른 그룹에 소속됨).

⚡ 6. 초기 설정 시 Exadata 기본 Disk Group

Exadata 초기 구성 시 자동으로 3개의 ASM Disk Group이 만들어집니다:

Disk Group 용도

DATA	데이터 저장 (핫 데이터)
RECO	Recovery 영역 (로그, 아카이브)
DBFS_DG	내부 관리용 (DBFS 파일시스템)

각각 NORMAL 또는 HIGH redundancy로 설정됩니다.

정리

구성 요소 설명

Grid Disk	ASM Disk의 최소 단위. Cell Disk 위에 생성됨
ASM Disk Group	Grid Disk를 묶어 구성. 예: DATA_1, FRA_1
ASM Redundancy	NORMAL(2-way), HIGH(3-way). External은 Exadata에서 ❌
Failure Group	Storage Cell 단위로 자동 생성. 셀 장애 시 복제본으로 보호
Striping	ASM이 데이터를 모든 Grid Disk에 균등하게 분산 저장

한 줄 요약

Exadata에서 ASM Disk Group은 여러 Grid Disk 위에 구성되고, Failure Group(셀 단위) 을 활용해 자동으로 데이터 복제와 장애 보호를 제공합니다.
NORMAL 또는 HIGH redundancy가 필수이며, EXTERNAL은 지원되지 않습니다.

원하신다면 이걸 Physical Disk → Grid Disk → ASM Disk Group → Failure Group 관계로 도식화한 PDF나 이미지로 만들어드릴 수도 있어요. 그렇게 할까요? ️ ✨

✅ 정답:
b. MS
d. CELLSRV
e. RS

설명 — Exadata Storage Server의 3대 핵심 서비스

서비스 이름 전체 명칭 역할

CELLSRV	Cell Server	Smart Scan, I/O 오프로딩, 데이터 압축/복제 등 핵심 데이터 I/O 처리 담당
MS	Management Server	Exadata 셀의 상태 모니터링, 알람, 구성 정보 관리
RS	Restart Server	장애 발생 시 CELLSRV와 MS를 자동으로 재시작하는 역할

참고

GMON은 ASM 인스턴스의 백그라운드 프로세스이며 Storage Server 서비스가 아님 ❌
OMS(Oracle Management Server)는 Exadata Storage Server 서비스가 아님 ❌

따라서 정답은 MS, CELLSRV, RS 입니다.

java 교육 5일

aonee — Mon, 26 May 2025 15:50:56 +0900

[교육 1일차]

java 기본 개념 교육 c언어와 비교하며 수업해주셨다.

c언어 실행방법 : gcc test01.c -o a.exe 후 a.exe

주의사항 ) gcc있어야함. gcc 경로를 못 찾아서 path설정을 해줬다. 환경변수 path에 gcc bin 폴더경로 추가 후 cmd창 닫고 다시 cmd 열면 해결됨

java 실행방법 : javac test02.java 후 java test02

test01 .c

#include <studio.h>

int main() {
	int a ; 
	a = 100;
	printf("%d\n", a) ; 
	return 0;
}

test04.java

public class test04 {
	public static void main (String[] args){
		int a;
		a = 10;
		System.out.println(a);
		
		double b = 3.143;
		System.out.println(b);
	}


}

test05 .c

#include <stdio.h>

int main(){
int a ;
int *b, *c; 
a=100;
b= &a;
c= b;
printf("%d %d %d", a, *b, *c);

return 0;
}

/*
포인터는 기억공간을 가리킬 수 있는 변수이다 (이름 아님)- 삼각형 기억공간으로 표현
c=b 포인터의 대입은 오른쪽이 가리키는 대상을 왼쪽이 가리키게 된다
*/

test06 .c

#include <stdio.h>

struct ab {
	int a;
	float b;
	
};


int main(){
	struct ab apple;
	struct ab *t;
	
	apple.a = 100;
	apple.b = 3.14;
	
	t= &apple;
	t->b = 0.066;
	
	printf("%d %f\n", apple.a, apple.b);


	return 0;
}

/*
apple이름으로 변수 선언 - struct ab 형태의 공간을 확보한다
a라는int형 변수와 b라는 float형 변수가 함께 있는 복합공간

구조체는 자료형처럼 이해하고 사용하면 됨.
java 클래스는 알고보면 구조체다. 따라서 클래스는 자료형처럼 이해하면 된다.


*/

test07.c

#include <stdio.h>


/*
구조체는 자료형처럼 쓸 수 있기에 typedef 를 적용할 수 있다
이러면 마치 AB라는 새로운 자료형을 만든 것처럼 사용이 가능하다

메모리 확보 방법
1. 변수선언 - 자료형 or 구조체, 이름(심볼) 필수
int a ; b=&a; 기억공간에 대한 포인터는 존재한다

2. malloc - 자료형 or 구조체, 이름(심볼) 없음. 이름이 없이 포인터로만 접근 가능하다.

*/
typedef struct ab {
	int a;
	float b;
	
}AB;


int main(){
	AB apple;
	AB *t;
	
	apple.a = 100;
	apple.b = 3.14;
	
	t= &apple;
	t->b = 0.066;
	
	printf("%d %f\n", apple.a, apple.b);


	return 0;
}

/*
apple이름으로 변수 선언 - struct ab 형태의 공간을 확보한다
a라는int형 변수와 b라는 float형 변수가 함께 있는 복합공간

구조체는 자료형처럼 이해하고 사용하면 됨.
java 클래스는 알고보면 구조체다. 따라서 클래스는 자료형처럼 이해하면 된다.


*/

test08.c

#include <stdio.h>

typedef struct ab {
	int a;
	float b;
	
}AB;


int main(){
	AB *t;
	t = (AB*)malloc(sizeof(AB)); // AB형태의 메모리를 확보하여 포인터를 리턴한다
	t->a = 9999;
	t->b = 193.23412345;
	printf("%d %f \n", t->a, t->b);
	free(t); //malloc으로 확보된 기억공간은 free로 소거한다
	// t(삼각형)을 날리는 게 아니라 t가 가리키는 대상(박스)가 날아간다
	return 0;
}

test09.java

class AB{
	int a;
	double b;
	
}
public class test09{
	public static void main(String[] args){
		AB t = new AB();
		t.a=100;
		t.b = 3.14;
		System.out.println(t.a + ", "+ t.b);
	}
}

test10.c

typedef struct node {
	int data;
	struct node *next; // 가능
	
}Node;


int main(){
	Node* head;
	head= (Node*)malloc(sizeof(Node));

	head->data = 0;
	head->next = (Node*)malloc(sizeof(Node));
	head->next->data = 100;
	
	printf("%d, %d", head->data, head->next->data);
	
	free(head->next); // head포인터가 가리키는 malloc된 대상 안의 next 포인터가 가리키는 대상을 날려라
	free(head);
	
	return 0;
}

test11.java

class Node{
	int data;
	Node next;
}

public class test11{
	public static void main(String[] args){
		Node head = new Node();
		head.data = 100;
		head.next = new Node();
		head.next.data = 200;
		
		System.out.println(head.data + ", "+ head.next.data);
	}
}

test15.java

class Node{
	int data;
	Node next;
}


// 클래스(구조체), 인스턴스(malloc), 멤버변수, 참조형변수(포인터) 개념
클래스 안에서 생선한 변수 멤버변수.
멤버변수는 인스턴스를 생성할 때 할당받는다
클래스 이름으로 생성된 변수를 참조형변수라고 한다
인스턴스를 가리키기 위한 용도이다.....................
public class test15{
	public static void main(String[] args){
		Node head ; // 클래스 이름으로 선언한 변수는 참조형변수, new로 할당받은 메모리 공간을 가리키는 용도
		head = new Node(); // new는 malloc과 유사
		// 클래스 안에는 변수를 선언할 수 있다. 이 변수는 new할 때 메모리를 할당받는다.
		// new Node(); 형태로 만들어진 할당받은 메모리 공간을 인스턴스 라고 한다.
	
		// 클래스는 구조체다. 여러번 선언 가능하다. 즉, 여러번 인스턴스 생성 가능하다. 
		// 여러번 인스턴스 만들어질 때마다 새로 변수가 생긴다.
		// 클래스 안에서 선언된 변수를 멤버변수라고 한다.
		// 멤버변수는 인스턴스 생성할 때마다 메모리를 할당받는다
		
		System.out.println(head.data + ", "+ head.next.data);
	}
}

/*
java의 class는 알고보면 구조체다 : 변수 선언이 가능 (대입연산금지)
class이름으로 변수를 선언할 수 있다. 
자료형으로 뭘 할 수 있었지? 변수 선언. 포인터 선언. malloc선언. 가능
구조체로 뭘 할 수 있었지? 변수, 포인터, malloc선언
java는 이 중 변수 선언만 안된다. 이 점이 c와 차이점 !

구조체는 마치 자료형처럼 쓰는구나... typedef
클래스는 변수 선언이 빠진 구조체더라..
*/

test16.java

class Node{
	int data;
	Node next;
}

public class test16{
	public static void main(String[] args){
		Node head = new Node();
		Node tail = head;
		
		Node t = new Node();
		t.data = 10;
		t.next = null;
		tail.next = t;
		
		tail = tail.next;
		
		t = new Node();
		t.data = 20;
		t.next = null;
		tail.next = t;
		
		for(t= head.next; t != null ; t = t.next){
			System.out.println(t.data);
		}
			
		
		
	}
}

test16.java -> c로 작성

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
	int data;
	struct node *next ;
}Node;

int main(){

	// Node* head, tail, t;
	Node* head = (Node*)malloc(sizeof(Node));
	Node* tail = head;
	
	Node* t = (Node*)malloc(sizeof(Node));
	t->data = 10;
	t->next = Null;
	tail->next = t;
	
	tail = t->next;
	
	Node* t = (Node*)malloc(sizeof(Node));
	t->data = 20;
	t->next = Null;
	tail->next = t;
	
	for(t= head->next; t != Null ; t = t->next){
			printf("%d\n", t->data);
		}
	
	free(head);
	free(tail);
	free(t);
	
	return 0;
}

test17.c

#include <stdio.h>
int add(int i, int j){
	printf("->%d\n", i);
	printf("->%d\n", j);
	return i+j;
}
int main() {
	int r ; 
	r = add(10,20);
	printf("%d ", r);
	return 0;

}

/*
	add(10,20) 이 호출되면??
	1. int i, int j; 선언 - 메모리할당
	2. i = 10; j = 20 ; 대입
	3. 활용
	4. return 값; 값이 함수를 호출한 add(10,20) 부분을 대신한다고 보면 실수가 없다.

*/

함수포인터

test20.c

구조체 안에 함수 선언 불가능하다

#include <stdio.h>

typedef struct apple {
	int data;
    //int add(int, int); // error 함수선언 불가능
}Apple;

int add(int i, int j){
	return 100;
}

int add_v2(int i, int j){
	return 200;
}


int main() {
	int (*fp)(int, int);
	fp = add;
	printf("%d ", fp(10,20));
	
	fp = add_v2;
	printf("%d ", fp(10,20));
	
	return 0;

}

/*
	int (*fp)(int, int); 함수포인터
	fp는 포인터 변수다. 기억공간이 아닌 함수를 가리킨다. 매개변수가 int int 이고 리턴타입이 int인
	fp = add; 이 코드는 fp포인터가 add라는 함수를 가리키도록 대입한 코드

	결과값 100 return
	fp(10,20) fp포인터가 가리키는 함수를 호출한다 ..라는 이야기다.
	
	add_v2추가하면?
	결과값 100 200 return
	
	유지보수가 유독 많은 함수에 함수포인터를 이용하면 유지보수성이 좋아진다.
    
    *** 구조체 안에 함수 선언 안된다 !!!!!!!!!!!!!
*/

구조체 안에 함수 선언 불가능하지만 !!!!!!!!

함수포인터는 구조체 안에 선언 가능

test21.c

#include <stdio.h>

typedef struct apple {
	int data;
	int (*add)(int, int); // 가능! 함수포인터는 구조체 안에 선언이 가능하다
}Apple;

int Apple_add(int i, int j){
	return 100;
}

int main() {
	Apple* t;
	t = (Apple*)malloc(sizeof(Apple));
	t->data = 0;
	t->add=  Apple_add;
	
	printf("%d %d  \n", t->data, t->add(10,20));
	
	return 0;
}

/*
	t->add(10,20)
	함수 포인터를 이용하면 마치 t가 가리키는 대상 안에 add라는 이름의 함수를 호출하는 것 같은
	모양을 만들 수 있다
	
	java는 class안에 함수 선언이 가능하다. 위와 같은 방법으로 호출할 수 있다.
	t.add(10,20);
*/

한번 만들어진 메모리 재사용할 때
단순 데이터 재사용하는 것과
이 데이터를 operation할 수 있는 것과
함수 재사용하는 것과 뭐가 더 효율적일까? 2일차 수업에서 계속..

[교육 2일차]

클래스
인스턴스
참조형변수
멤버변수
멤버함수
new
this

클래스 안에 올 수 있는 코드? 변수선언가능(멤버변수 / 대입은 불가), 함수선언가능(멤버함수 / 호출은 불가)
=> 클래스는 알고보면 구조체, 함수포인터 이용해서 구조체 안에 함수를 밀어 넣음

클래스로 뭐 할 수 있나? (변수선언 포인터선언 malloc = java에선 변수선언 빠짐)
- 포인터 선언 ( 클래스 이름으로 선언된 변수 - 클래스로 선언된 변수는 100%포인터다. 이를, 참조형변수라 한다.)
- 클래스 이름으로 선언된 변수는 인스턴스를 가리키게 된다

new와 malloc은 유사하다. 선언된 클래스 대로 메모리를 할당받은 실체가 인스턴스

멤버변수는 언제 메모리 할당받나? 인스턴스를 생성할때마다.
멤버변수는 어떻게 호출 ? 인스턴스 생성 + 참조형 변수를 이용 + 이름과 매개변수로 호출, this 사용가능

this는 알고보면 로컬변수이고, 호출 때마다 가리키는 대상이 달라지고, 호출된 함수를 포함하는 인스턴스를 가리키게 된다.

test22.c

#include <stdio.h>

typedef struct ab {
	int a;
	float b;
}AB;


int main(){
	int a;
	int *b;
	
	AB ab;
	AB *p;
	p = (AB*)malloc(sizeof(AB));
	ab.a = 100;
	p->b = 3.14;
	
	b= (int*)malloc(sizeof(int));
	*b = 100; // 변수는 이름 있지만 malloc으로 만든 공간은 이름이 없기에 포인터로 접근해야한다
	a=200;
	a = a + 100;
	
	return 0;
}

/*
변수는 이름 있지만 malloc으로 만든 공간은 이름이 없기에 포인터로 접근해야한다
구조체 : 변수, 포인터, malloc

*/

test23.java

class AB{
	int a;
	double b;
}


public class test23{
	public static void main(String[] args){
		AB p = null
		p = new AB();
	}
}

/*
	클래스: 변수
	모든 포인터에는 null값 대입 가능하다.
	포인터는 인스턴스를 가리킨다
	참조형변수는 클래스 이름으로 선언됐고
*/

test24.java

class Apple{
	int data=  0;
	int add(int i){		
		return 100;
	}
	
}


public class test24{
	public static void main(String[] args){
		Apple t = null;
		t = new Apple();
		
		t.data = 100;
		System.out.println(t.add(10));
	}

}

/*
	클래스 안에 선언된 함수를 호출하려면??
	1. 인스턴스 생성
	2. 참조형 변수로 가리키고
	3. 참조형변수. 함수명(매개변수값); 형태로 호출한다
*/

test25.c

#include <stdio.h>

typedef struct apple{
	int data;
	//int add (int i) {return 10101;} // c언어는 구조체 안에 함수 return 못함 -> 별도 함수로 외부에 작성하고 포인터로 선언해줘야함.
	int (*add)(int);
}Apple;

int Apple_add(int i){
	return 10101;
}

int main(){
	Apple* t; // 포인터 선언
	t = (Apple*)malloc(sizeof(Apple)); // 메모리할당
	
	t->data = 100; //데이터
	t->add = Apple_add;
	
	printf("%d", t->add(100));
	
	
	free(t);
	return 0;
}

test26.java

class Apple{
	int data=  23;
	int add(int i){		
		return (this.data + 10101 );
	}
	
}


public class test26{
	public static void main(String[] args){
		Apple t = null;
		t = new Apple();
		
		t.data = 100;
		System.out.println(t.add(10));
	}

}

/*
	this.data
	this는 변수 아님
	t.data = 100; 과 비교해보면 여기서 this는 Apple형 포인터이어야 한다!!
	
	this.data는 100이면 이 결과가 말이 된다(10201)
	this 포인터는 호출된 함수 포인터를 소유하고 있는 인스턴스를 가리키는 포인터 이어야 한다 !!
	(쉽게 얘기하면 자기 자신에 대한 포인터가 된다)
	
	
	print값이 10124일까 10201일까?
	10201
	t포인터에 data 100으로 값 다시 초기화한 후, add함수 호출한 것이기 때문. this.data는 자기자신의 함수포인터가 되어 Apple클래스를 가리키고 data는 100으로 재호출....
*/

test27.c

#include <stdio.h>

typedef struct apple{
	int a;
	int b;
	int c;
	int (*sum)(int, int, int);
}Apple;

int apple_sum(int a, int b, int c){
	return a+b+c;
}

int main(){
	Apple* t; // 포인터 선언
	t = (Apple*)malloc(sizeof(Apple)); // 메모리할당
	
	t->a = 10;
	t->b = 20;
	t->c = 30;
	t->sum = apple_sum;
	
	printf("%d", t->sum(t->a, t->b, t->c));
	
	free(t);
	return 0;
}

/*
	이렇게 함수를 만들면 굳이 구조체로 묶을 필요도 없고, 변수가 추가되면 다시 짜야한다
*/

test28.c

#include <stdio.h>

typedef struct apple{
	int a;
	int b;
	int c;
	int x;
	int (*sum)(struct apple*);
}Apple;

int apple_sum(Apple* this){
	return this->a + this->b + this->c + this->x;
}

int main(){
	Apple* t; // 포인터 선언
	t = (Apple*)malloc(sizeof(Apple)); // 메모리할당
	
	t->a = 10;
	t->b = 20;
	t->c = 30;
	t->x = 55;
	t->sum = apple_sum;
	
	printf("%d", t->sum(t));
	
	free(t);
	return 0;
}

/*
	c언어로 객체지향 프로그래밍 할 때,
	구조체 안에서 선언된 모든 함수 포인터의 첫번째 매개변수는 같은 타입의 포인터로 선언한다
	
	t->sum(t) 호출할 때, 사용한 포인터를 같이 넘긴다.
	
	Apple* this = t ; 
	this는 t가 가리키는 대상을 가리킨다.
	
	this 포인터는 sum 함수 포인터가 소속된 인스턴스 안의 모든 함수와 변수에 접근이 가능하다
	
	x변수를 추가한다고 생각하면 유지보수성이 좋아지더라
*/

test29.java

class Apple{
	int data=  23;
	void print(){		
		System.out.println(this.data);
	}
	
}
public class test29{
	public static void main(String[] args){
		Apple a= new Apple();
		a.data = 100;
		a.print();
		
		Apple b= new Apple();
		b.data =200 ;
		b.print();
		
	}

}

/*
	
*/

test30.c

#include <stdio.h>

int main(){
	int a[4];
	int i;
	int temp, max;
	
	// 3 1 4 2
	a[0] = 3;
	a[1] = 1;
	a[2] = 4;
	a[3] = 2;
	
	max = 0;
	if (a[max] < a[1]) { // 3<1
		max = 1; //x
	}
	if (a[max] < a[2]) { // 3<4
		max = 2; // max= 2
	}
	if (a[max] < a[3]) { // 4<2
		max = 3;
	}
	// max = 2
	//printf("1) max a[max] : %d %d", max, a[max]); // 2 4
	
	if(max != 0){
		temp = a[0]; // 3
		a[0] = a[max]; // a[0] = 4
		a[max] = temp; // a[2] = 3
	}

	
	for(i = 0; i < 4; i++){
		printf("%d\n", a[i]);
	} // 4 1 3 2
	return 0;

}

test31.c

#include <stdio.h>
void print(int* t){
	int i;
	for (i = 0; i < 3; i++){
		printf("print() :  %d\n", *(t+i));
	}
	//printf("print() :  %d\n", *t);
}


int main(){
	int a[2];
	int i;
	int *p;
	
	p = a ; // 배열형 변수는 사실은 포인터다
	
	a[0] = 10;
	a[1] = 20;
	a[2] = 30;
	
	printf("%d\n", *p); // 배열형 변수가 대입된 포인터는 배열의 첫번째 요소를 가리킨다
	printf("%d\n", *(p)); //
	printf("%d\n", *(p+0)); // a[0]
	printf("%d\n", *(p+1)); // a[1]
	
	for(i = 0; i < 3; i++){
		printf("%d\n", a[i]);
	} //
	
	print(a);
	return 0;

}

test32.c

#include <stdio.h>


void add(int* t){ // ???
	
	
}
void print(int* t){
	printf("print() :  %d\n", *(t+0));
	printf("print() :  %d\n", *(t+1));
	//int i;
	//for (i = 0; i < 3; i++){
	//	printf("print() :  %d\n", *(t+i));
	//}
	//printf("print() :  %d\n", *t);
}
void sort(int* t){
	int t;
	if (*(t+0) < *(t+1)){ // 동일 코드 : data[0] < data[1]
		t = *(t+0);
		*(t+0) = *(t+1);
		*(t+1) = t
	}
}

int main(){
	int a[2];
	
	add(a, 0, 100);
	add(a, 1, 200);
	
	sort(a);
	
	print(a);
	
	return 0;

}

/*
	이 코드에서
	add 없는 print함수는 의미가 없다
	add 없는 sort도 의미가 없다
	배열 없는 add도 의미 없다
	
	배열 + add + sort + print가 한 덩어리로 묶여서 재사용되는 빈도가 훨씬 많더라
	-> 객체지향적으로 이 부분을 해결해보자
*/

test33.java

public class test33{
	public static void main(String[] args){
		int[] data = new int[2];
		int[] t = data;
		
		data[0] = 100;
		t[1] = 200;
		
		System.out.println(data[1]);
		System.out.println(t[0]);
		
		
	}
}
/*
	int[] data = new int[2];
	
	배열은 인스턴스이다 (new)
	data는 배열을 가리키는 참조형 변수가 된다 (포인터)
	

*/

test34.java

/*
java는 변수와 함수가 독립적으로 존재할 수 없다. 클래스 안에서 선언되어야 한다.
멤버함수 안에서는 this를 쓸 수 있고
t.add(0,100) 형태로 호출됐을 때, add함수 안의 this는 t와 같은 대상을 가리키게 된다.

add, sort, print는 data배열과 뗄레야 뗄 수 없는 관계가 성립된다.
자연스럽게 한 묶음이 되고, 재사용성이 늘어나게 된다.
*/
class Banana{
	int[] data = null;
	
	void add(int idx, int val){
		this.data[idx] = val;
		
	}
	void print(){
		System.out.println(this.data[0] + "," + this.data[1]);
	}
	void sort(){
		if (this.data[0] < this.data[1]){
			int temp = this.data[0];
			this.data[0] = this.data[1];
			this.data[1]= temp;
		}
	}
}

public class test34{
	public static void main(String[] args){
		Banana t = new Banana();
		t.data = new int[2];
		t.add(0,100);
		t.add(1,200);
		t.sort();
		t.print();
		
	}
}

test35.c

#include <stdio.h>

typedef struct banana{
	int *data;
	void (*add)(struct banana*, int, int);
	void (*print)(struct banana*);
}Banana;

int banana_add(Banana* this, int idx, int val){
	//this->data[idx] = val;
	*(this->data+idx)= val;
}

/*
void print(Banana* this){
	pirntf(this.data[0] + "," + this.data[1]);
	
}
*/

Banana* new_Banana(){
	Banana* t;
	t= (Banana*)malloc(sizeof(Banana));
	
	t->add = Banana_add;
	t->data = (int*)malloc(sizeof(int)*2);
	
	return t;
	
}

int main(){
	Banana* b; // 포인터 선언
	t = (Banana*)malloc(sizeof(Banana)); // 메모리할당

	t->add(t, 0, 100);

	free(t);
	return 0;
}

/*
	이렇게 함수를 만들면 굳이 구조체로 묶을 필요도 없고, 변수가 추가되면 다시 짜야한다
	
	c언어로 객체지향스럽게 코드를 짠 예
	
	c언오로 구조체와 함수포인터를 사용하여 객체지향 적으로 개발할 수도 있다
	하지만 애초에 객체지향 프로그래밍을 목적으로 만든 언어를 사용하는 것이 더 적합하다
	
	이코드는 객체지향 언어의 주요개념들(클래스 인스턴스 멤버변수 멤버함수 this new 등)을
	이해하기 위한 목적으로 사용하자
*/

test36.java

class Apple{
	int data; // 멤버변수
	Apple(int i ){ // 생성자함수 : 인스턴스 생성시 호출됨
		System.out.println("Apple " + i);
		this.data = i;
	}
}

public class test36{
	public static void main(String[] args){
		Apple t = null;
		Apple x = new Apple(100);
		Apple y = new Apple(200);
		
		System.out.println(x.data + ", " + y.data);
		
		//x.Apple(0); // 에러. 생성자함수는 멤버함수가 아니어서 포인터로 호출될 수 없다.
	}
}

/*
	클래스 이름과 같고, 리턴타입이 없다 -> 생성자함수 (Constructor)이라고 한다.
	호출될 수 있지만 멤버함수가 아니다. -> 인스턴스 생성시에 호출된다(매번)
	
	생성자 함수에는 매개변수를 선언할 수 있고, 생성자 함수에 값을 전달할 수 있고
	-> "주로(대부분) 멤버변수를 초기화하는 용도로 사용된다."
*/

test38.java

class Node{
	int data = 0;
	Node next = null;
	
	/*
	Node(int a){
		this.data=a;
	}*/
	
	Node(int a, Node b){
		this.data=a;
		this.next=b;
	}
}

class LinkedList{
	Node head = null;
	Node tail = null;

	Linkedlist(){
		this.head = new Node(0,null);
		this.tail = this.head;
		
	}
	
	void add(int i){
		this.tail.next = new Node(i, null);
	}
	
	
 

public class test38{
	public static void main(String[] args){
		//Node head = new Node(99);
		//System.out.println(head.data);
		
		//Node head2 = new Node(42, null);
		//System.out.println(head2.data);
		
		LinkedList l = new LinkedList();
		l.add(10);
		l.add(20);
		l.add(30);
		
		
	}
}

/*

*/

test39.c

#include <stdio.h>

int main(){
	int a, *p;
	float b;
	void *vp;
	
	a=10;
	p = &a; // 당연 int* 변수가 int형 공간을 가리킨다
	vp = &a; // void* 형 변수가 int공간을 가리킨다
	
	printf(" %d\n", *p);
	// printf("%d\n", *vp); // 에러. void*형은 반드시 타입 형변환 시킨 후 사용해야함.
	printf(" %d\n", *((int*)vp));
	
	b = 3.14;
	vp = &b; // void*형 변수는 모든 형태의 기억공간을 가리킬 수 있다.
	
	printf("%d\n", *((float*)vp));
	
	printf("%d\n", *((int*)vp));
}

[교육 3일차]

test41.java

class Dog{
	int weight=500;
}

public class test41{
	public static void main(String[] args){
		Dog mary = new Dog();
		mary.weight = mary.weight + 12;
		
		System.out.println(mary.weight);
		
		Dog happy = mary;
		happy.weight = happy.weight + 59;
		System.out.println(happy.weight);
	}
}
/*
	인스턴스가 가진 메모리는
	인스턴스를 가리키는 참조형 변수의 개수가 0이 되는 순간에 회수한다
	(가비지콜렉터 라는 메커니즘이 있고 이것은 자바 실행머신에서 활동한다)
	
	실제로 소거하는 시점은? CPU가 놀 때(할일없음), 메모리가 부족(배고파 죽겠다)
	
	main이 끝나서 mary happy 두 포인터가 자동으로 없어진다 (로컬변수)
	따라서 new Dog()로 생성한 메모리가 밥줄이 끊기고 -> 포획되고 -> 소거된다
	
	없앨 수는 없지만 잡혀가게 할 수는 있다 -> 가리키는 포인터의 개수를 0으로 만들면 된다. 
*/

test42.java

class Node{
	int data = 0;
	Node next = null;
	
	Node(int a, Node b){
		this.data=a;
		this.next=b;
	}
}


public class test42{
	public static void main(String[] args){
		Node head = new Node(0,null);
		Node tail = head;
		
		tail.next = new Node(10,null); 
		tail = tail.next;
		
		tail.next = new Node(20,null); 
		tail = tail.next;
		
		tail.next = new Node(30,null); 
		tail = tail.next;
		
		for(Node t = head.next; t != null ; t = t.next){
			System.out.println(t.data);
		}
		
		Node a = head ; 
		Node b = head.next;
		
		while(a != null){
			a.next = null;
			
			a=b;
			b=b.next;
			
		}
		tail = head;
	}
}
/*
	
*/

test43.c

#include <stdio.h>

typedef struct node {
	int data;
	struct node *next;
}Node;

Node* new_Node(int i, Node* b){
	Node* t;
	t= (Node*)malloc(sizeof(Node));
	
	t->data = i;
	t->next = b;
	
	return t;
	
}

int main(){
	Node *head, *tail, *t;
	Node *a, *b;
	
	head = new_Node(0,Null);
	tail = head;
	
	tail->next = new_Node(10, Null);
	tail = tail->next;
	
	tail->next = new_Node(20, Null);
	tail = tail->next;
	
	tail->next = new_Node(30, Null);
	tail = tail->next;
	
	// 어디에 어떻게 코드를 한 줄 짜면 싹 다 지울 수 있을까?
	a= head;
	b = head->next;
	while (a!=Null){
		a=b;
		b=b->next;
	}
	
	for(t= head->next ; t != Null ; t->next){
		printf("%d\n", t->data);
		
	}
	
	free(head);
	
	return 0;
}

test44.java

class A{
	int data = 100;
	
}
/*
	상속 : 클래스가 가진 멤버변수와 멤버함수를 물려받는 것
*/
class B extends A{
	void print(){
		System.out.println("print");
	}
}

public class test44{
	public static void main(String[] args){
		A a = new A();
		//a.print(); // error
		
		B b = new B();
		System.out.println(b.data);
		b.print();
		
		/*
			조상 클래스형 포인터로 자손 클래스의 인스턴스를 가리킬 수 있다.
			(상속 받은 클래스가 자손, 상속을 준 클래스가 조상)
			
			이때 조상에서 선언된 함수와 변수가 접근 가능하다.
		*/
		A ab = new B();
		// ab.print(); 분명 print 함수 포인터가 있는데도 접근이 안된다
		System.out.println(ab.data);
		
		// B ac = new A(); // error 자손은 조상에게 상속만 받을 수 있음.
		
		
	}
}

test46.c

#include <stdio.h>
#include <stdlib.h>

typedef struct a {
	int data;
}A;

typedef struct b {
	int data; // 상속되어서 물려받은 멤버변수
	void (*print)(void); // 자손에서 추가된 멤버함수
}B;

int main(){
	void* vp;
	A* a;
	B* b;
	
	vp = malloc(sizeof(B));
	a = (A*)vp;
	
	printf("%d\n", a->data);
	//a->print(); // error 조상은 조상까지만 접근가능
	
	b=(B*)vp;
	b->print(); // 자손은 조상+자손 접근가능
	
	return 0;
}

test47.c

#include <stdio.h>
#include <stdlib.h>

typedef struct a {
	int data;
}A;

typedef struct b {
	int data; // 상속되어서 물려받은 멤버변수
	void (*print)(void); // 자손에서 추가된 멤버함수
}B;

void a_print(){
	printf("apple\n");
	
}

void* new_a{
	A* t;
	t = malloc(sizeof(A));
	t->data=100;
	t->print = a.print;
	
	return t;
	
}
int main(){
	A* a;
	a=(A*)new_a();
	printf("%d\n", a->data);
	a->print();
	
	return 0;
}

test48.c

#include <stdio.h>
#include <stdlib.h>

typedef struct a {
	int data;
}A;

// 상속은 골라받을 수 없다. 그대로 순서대로 온 다음 자손에서 추가된 것을 넣어준다.
typedef struct b {
	int data; // 상속되어서 물려받은 멤버변수
	void (*print)(void); // 자손에서 추가된 멤버함수
	void (*print2)(void);
}B;

void a_print(){
	printf("apple\n");
	
}
void b_print(){
	printf("banana\n");
	
}

void* new_a(){
	A* t;
	t = malloc(sizeof(A));
	t->data=100;
	t->print = a.print;
	
	return t;
	
}

void* new_b(){
	B* t;
	t = malloc(sizeof(t));
	t->data=444;
	t->print = a_print;
	t->print = b_print;
	return t;
	
}

int main(){
	A* a;
	B* b;
	
	
	
	a=(A*)new_a();
	printf("\n%d\n", a->data);
	a->print();
	
	printf("\n%d\n", b->data);
	b->print();
	
	b=(B*)new_b();
	printf("\n%d\n", b->data);
	a->print();
	
	return 0;
}

test49.java

class A{
	void print(){
		System.out.println("apple");
	}
	
}

class B extends A{
	void print(){
		System.out.println("banana");
	}
}

public class test49{
	public static void main(String[] args){
		B b = new B();
		b.print(); // banana
	}
}

test50.c

#include <stdio.h>
#include <stdlib.h>

typedef struct a {
	void (*print)(void);
}A;

void a_print(){
	printf("apple\n");
	
}
void b_print(){
	printf("banana\n");
	
}

void* new_a(){
	A* t;
	t= (A*)malloc(sizeof(A));
	t->print = a_print;
	return t;
	
}

typedef struct b {
	void (*print)(void);
}B; // 오버라이딩이 일어난 경우에는 함수포인터를 선언하지 않는다

void* new_b(){
	B* t;
	t= (B*)malloc(sizeof(B));
	t->print = a_print; // 물려받는다
	t->print = b_print; // 오버라이딩의 실체
	// 포인터는 물려받은 거, 가리키는 실체는 자손에서 추가된 것
	return t;
	
}

int main(){
	A* a;
	B* b;

	a=(A*)new_a();
	a->print();
	

	b=(B*)new_b();
	a->print();
	b->print();
	
	return 0;
}

/*
결과
apple
apple
banana
*/

test51.java

class A{
	void print(){
		System.out.println("apple");
	}
	
}

class B extends A{
	void print(){
		System.out.println("banana");
	}
	void print2(){
		System.out.println("orange");
	}
}

public class test51{
	public static void main(String[] args){
	
		A a = new A();
		a.print();
		
		B b = new B();
		b.print(); // banana
		b.print2();
		
		A ab = new B();
		ab.print();
		//ab.print2();//error
	}
}
/*
apple
banana
orange
banana

조상의 포인터로 자손의 인스턴스를 가리킬 수 있다.
조상에서 선언된 멤버변수 멤버함수만 접근 가능하다.
만일 오버라이딩 된 경우에는 오버라이딩 된 함수가 호출된다.
*/

tset52.java

class Node{
	int data = 0;
	Node next = null;
	
	Node(int a, Node b){
		this.data=a;
		this.next=b;
	}
}

class LinkedList{
	Node head = null;
	Node tail = null;
	
	LinkedList(){
		head = new Node(0,null);
		tail=head;
	}
	void add(int a){
		tail.next = new Node(a, null);
		tail = tail.next;
	}
	void print(){
		for (Node t = head.next; t != null; t=t.next){
			System.out.println(t.data);
		}
	}
}

class LinkedList2 extends LinkedList{
	void add(int a){
		head.next = new Node(a, head.next);
	}
}


public class test52{
	public static void main(String[] args){
	
		LinkedList l = new LinkedList();
		l.add(10);
		l.add(20);
		l.add(30);
		l.print();
		
		/*
		10
		20
		30
		*/
		
		LinkedList l2 = new LinkedList2();
		l2.add(10);
		l2.add(20);
		l2.add(30);
		l2.print();
		/*
		30
		20
		10
		*/
	}
}
/*

*/

test53.java

class A{
	A(){
		System.out.println("a");
	}
}

class B extends A{
	B(){
		System.out.println("b");
	}
}

public class test53{
	public static void main(String[] args){
		new B();
	}
}

/*
결과
a
b

생성자함수는 인스턴스를 생성했을 때 (new) 호출된다.
자손의 인스턴스를 생성했다 -> 조상의 생성자 호출되고, 자손의 생성자가 호출된다.

생성자함수: 멤버변수 초기화 용도
-> 조상의 멤버변수는 조상의 생성자에서, 자손의 멤버변수는 자손의 생성자에서 각각 초기화 한다.
*/

test54.java

class A{
	int apple = 1;
	A(int i){
		this.apple = i;
	}
	
}

class B extends A{
	
	int banana = 4;
	B(int i, int j){
		//this.apple = j; // error
		super(j); // 
		this.banana = i;
	}
}

public class test54{
	public static void main(String[] args){
		B b = new B(100,200);
		System.out.println(b.apple);
		System.out.println(b.banana);
	}
}

/*
200
100

조상의 멤버변수는 조상의 생성자에서, 자손의 멤버변수는 자손의 생성자에서 각각 초기화한다.
B는 apple, banana 두개의 멤버변수를 가지고 있다.

자손의 인스턴스를 생성하면 조상의 '디폴트로 매개변수 없는 생성자'가 호출된다
A(){...} 생성자가 선언딘 적이 없다. <- 에러가 났다
*/

조상의 멤버변수는 조상의 생성자에서, 자손의 멤버변수는 자손의 생성자에서 각각 초기화한다.
B는 apple, banana 두개의 멤버변수를 가지고 있다.

자손의 인스턴스를 생성하면 조상의 '디폴트로 매개변수 없는 생성자'가 호출된다
A(){...} 생성자가 선언딘 적이 없다. <- 에러가 났다

조상의 생성자가 먼저 생성됨
즉 자손쪽에서는 먼저 호출되는 조상의 생성자를 선택할 수 있다
선택하게 만드는 것에 super()

test56.c

#include <stdio.h>
#include <stdlib.h>

typedef struct a {
	int apple;
	void (*print)(struct a*);
}A;



void a_print(A* this){
	printf(" a_print(A* this->apple :  %d\n",this->apple);
	
}

void a_constructor(A* this, int val){
	this->apple = val;
}

void* new_a(int val){ 
	A* t;
	t= (A*)malloc(sizeof(A));
	t->print = a_print;
	
	a_constructor(t, val);
	
	return t;
}

typedef struct b {
	int apple;	
	void (*print)(void *);
	
	int banana;
}B; 


void b_print(void* self){
	B *this;
	this = (B*)self;
	
	printf(" b_print(B* this->banana :  %d\n",this->banana);
	
}
void b_constructor(void* self, int val){
	B* this;
	this = (B*)self;
	
	this->banana = val;
}

void* new_b(int i, int j){ 
	B* t;
	t= (B*)malloc(sizeof(B));
	
	t->print = a_print;
	t->print = b_print; 
	
	a_constructor(t,j);
	b_constructor(t,i);
	return t;	
}

int main(){
	
	A *a;
	a=(A*)new_a(200);
	a->print(a);

	
	B *b;
	b=(B*)new_b(100,200);
	b->print(b);
	
	
		
	free(a);
	free(b);
	return 0;
}

test59.java

abstract class A{
	abstract void print();
	void print2(){} //abstarct 하지 않은 함수를 같이 쓰는 건 상관없다
	
}

class B extends A{
	void print(){
		System.out.println("print");
	}
	void sound(){
		
		System.out.println("sound");
	}
}

public class test59{
	public static void main(String[] args){
		B banana = new B();
		banana.print();
		banana.sound();
	}
}
/*
print
sound

void print(); 로 함수 선언을 하려면 반드시 abstract가 앞에 붙어주어야한다
abstract 멤버함수를 하나라도 가지고 있는 클래스는 abstract 해야한다.
abstract class는 인스턴스를 못 만든다

abstarct클래스 :: 추상클래스
인스턴스를 생성할 수 없는 클래스
하나이상의 추상메서드(구현되지 않은 메서드)를 가질 수 있음
자식클래스가 이 클래스를 상속받아 구현을 완성해야함


*/

test60.java

abstract class shoppingmall{
	abstract int db();
	void list(){
		int result = db();
		System.out.println(result);
	}
}

class shoppingmall_mysql extends shoppingmall{
	int db(){
		System.out.println("mysql 연동");
		return 100;
	}
}

class shoppingmall_mariadb extends shoppingmall{
	int db(){
		System.out.println("mariadb 연동");
		return 200;
	}
}

public class test60{
	public static void main(String[] args){
		shoppingmall D1 = new shoppingmall_mysql();
		D1.list();
		shoppingmall D2 = new shoppingmall_mariadb();
		D2.list();
	}
}
/*

*/

현재 상황에서 결정할 수 없거나, 앞으로 변경이 만이 일어날 부분을 abstract로 비워놓고
변경이 적은 부분을 미리 클래스로 만들어놓을 수 있다
쇼핑몰 클래스의 재홀용 빈도가 늘어나게되고 -> 생산성이 향상된다

abstract method의 실체는 구조체 안의 함수포인터에 NULL값이 들어가 있는 꼴이다.
이러한 구조체는 MALLOC하게되면 폭탄이 될 수 있다. -> NULL 값이 들어간
함수포인터는 호출하면 터진다. -> 따라서 이런 구조체는 malloc못하게 해야 한다.
-> 인스턴스를 못 만다는 클래스
mysql 연동
100
mariadb 연동
200

[교육 4일차]

test65.java

abstract class Apple{
	abstract int add(int i, int j);
}

class Apple2 extends Apple{
	int add(int i, int j){
		return i+j;
	}
}


public class test65{
	public static void main(String[] args){
		Apple a = new Apple2();
		System.out.println(a.add(1,2));
	}
}
/*

*/

선언되었지만 정의되지 않은 함수 : abstract method
(함수 포인터에 null 값이 대입된 형태와 유사)

함수 포인터에 null값이 대입된 구조체는 존재해서는 안된다. :: 언제 뻗을지 모른다
- 해서 java에서는 인스턴스를 못 만들게 문법으로 박았다 -> abstract class

abstract method 를 상속받으면서 오버라이딩을 하면 abstract 성격이 빠져나간다

t->add = NULL;

test67.java

abstract class Clac {
	abstract int multicas(int i, int j);
	//Addclc(int a) {seed = a;}
	int execute (int i ) {return i + this.seed;}
}

class Mulcalc extends Clac{
	int banana = 0;
	Mulcalc (int a ) {this.banana=  a;}
	int execute (int i ) {return (banana+10)* i;}
}


public class test67{
	public static void main(String[] args){
		
		/*Clac a = new AddCalc(100);
		System.out.println(a.execute(20));*/
		
		Clac b = new MulCalc(100);
		System.out.println(b.execute(20));
	}
}

test68.java

interface IA {
	//void print(){}; // 에러
	void print();
}

class A implements IA {
	void print(){ // 오버라이딩abstract class Clac {
}

public class test68{
	public static void main(String[] args){
		//new IA(); // 에러
		IA t = null;
		System.out.println();
	}
}

/*
*/

interface
- abstract method만 선언이 가능하다
- 앞에 abstract 안 붙여도 자동으로 붙는다.
- 당연히 인스턴스 못만든다 ( 좀 이상한 클래스다)
- 인터페이스를 상속받아 클래스를 만들때는 implements를 이용한다.
(인터페이스를 상속받아 인터페이스를 만들 때 extends를 사용한다)
- 인터페이스를 상속받아 클래스 선언할 때는 인터페이스의 모든 함수를 오버라이딩 해야한다.

test73.java

class Adam{
	private int redBook = 100;
	public int subHouse = 200;
	protected int map = 300; // 상속자는 접근 가능한데, 포인터로는 접근 불가
	
	void picnic(){
		System.out.println(redBook);
		System.out.println(subHouse);
		}
}

class Brown extends Adam{
	void give(){
		//System.out.println(redBook);//error
		System.out.println(subHouse);
		System.out.println(map);
	}
}

class Jen extends Brown{
	void give2(){
		//System.out.println(redBook);//error
		System.out.println(subHouse);
		System.out.println(map);
	}
}

public class test73{
	public static void main(String[] args){
		Adam a = new Brown();
		//System.out.println(a.redBook); // error // redBook has private access in Adam
		System.out.println(a.subHouse); 
		System.out.println(a.map); 
		//System.out.println(a.give2()); 
		
	}
}
/*


*/

멤버변수와 멤버함수 앞에서
private : 포인터를 통해 접근이 불가능
protected : 다른 패키지에 속한 클래스는 포인터로 접근 불가능.
public
이 붙어서 접근을 제한할 수 있다

아무것도 없는 경우는 friendly라고 하는데
같은 패키지는 public, 다른 패키지에게는 private로 동작한다

test74.java

class A{
	public String toString(){
		return "Hello world";
	}
}

public class test74{
	public static void main(String[] args){
		Object t = new A();
		System.out.println(t.toString());
		
		System.out.println((int)(10/3.0));
	}
}

/*
*/

아무 클래스로부터 상속받지 않으면 extends Object가 생략된다

Object는 내장되어 있는 클래스, '모든클래스의 조상이 된다'

toString()은 Object에서 선언되었고, 또한 물려받았다.
java클래스의 모든 인스턴스는 toString()함수를 가지고 잇다 -> Object는 모든 클래스의 조상

toString함수를 오버라이딩 하면 t.toString()호출 시 오버라이딩 된 함수가 호출된다

[JAVA 자료형]

자료형 이름 = 초기값;

정수형 변수 선언에 쓰는 자료형 4가지 : byte(8bit) short(16bit) int(32bit) long(64bit)
일반적으로 40... 이렇게 값을 쓰면 32bit값인데 40L은 64bit 값이 된다

실수형 변수 선언에 쓰는 건 두가지 : float (32bit) double(64bit)
3.14F 32bit가지는 실수 3.14는 64bit값

boolean으로 선언된 변수

char

UTF-8은 1~4바이트 크기를 가지는 가변 길이 문자 체계이고
이것이 인터넷의 표준 인코딩 방법이 되고 있다

필요한 경우, 8859_1(아스키코드), Unicode, UTF-8을 전환하는 것이 필요할 수 있다

약->강한타입
byte < short < int < long(64bit) < float(32bit) < double(64bit)
long(64bit) < float(32bit) : long이 64인데도 float가 더 쎄다(?) 왜?
약한 타입에서 강한 타입으로는 자동 형변환이 가능하지만
강한 타입에서 약한 타입으로는 강제로만 형 변환이 가능하다 (c언어에서는 없다)

100이 그대로 들어갈까? 아니면 변환시켜 들어갈까? 변환시켜 들어감. double이 강타입으로 자동형변환
변수가 double이고 값이 int면? 변수가 원하는 형태에 맞게 형 변환을 하고 (100.0)으로 바꾸고 대입한다

3.14는 double형이다. double에 int
약->강타입 : 자동변환 o ex) double b = 100 ; // 100.0
강->약타입 : 자동변환 x ex) int a= 3.14; error // int에 double 못 넣어.

test80.java

public class test80{
	public static void main(String[] args){
		String t = "helloworld";
		System.out.println(t);
		System.out.println(t.length());
		System.out.println(t.substring(2,5));
		
	}
}

/*
*/

t는 포인터일까요? String은 자료형 아니라 클래스이고, t는 포인터

"Helloworld"는 랎? 인스턴스? -> 인스턴스여야한다

String은 new를 이용하지 않고 인스턴스를 생성하는 유일한 클래스이다.

length()는 문자열 길이를 리턴하는 String의 멤버함수이다.

[교육 5일차]

test

업무에 바로 쓰는 SQL 튜닝 : 데이터베이스 구조 및 옵티마이저 이해

aonee — Mon, 12 May 2025 14:31:22 +0900

1. 데이터베이스 처리 단계: Parse와 Bind

✅ Parse 단계 (구문 분석 단계)

Parse는 SQL 문을 처음 데이터베이스에 제출했을 때 실행 전에 반드시 거치는 해석 및 검증 단계입니다.

주요 작업

문법 검사: SQL 문이 문법적으로 맞는지 검사
객체 이름 해석: 테이블, 뷰, 컬럼 등이 존재하는지 확인
권한 확인: 사용자가 객체에 접근할 수 있는 권한이 있는지 확인
파싱 트리 생성: SQL 문장을 트리 형태로 분석
Shared Pool 검색: SGA의 Shared Pool에 같은 SQL이 이미 파싱되어 있는지 검사 (Soft Parse를 위해)

✅ Hard Parse vs Soft Parse

Hard Parse: 처음 제출되는 SQL → 모든 파싱 과정, 권한 검사, 실행 계획 생성 포함
Soft Parse: 이전에 파싱된 SQL이 Shared Pool에 존재 → 재사용하여 빠르게 처리

✅ Bind 단계 (값 바인딩 단계)

Bind는 SQL 문에 포함된 변수나 리터럴 값들을 실제 값으로 바꾸는 과정입니다.

예시

SELECT * FROM employees WHERE employee_id = :1;

:1이 바인드 변수입니다.
사용자는 :1에 100 같은 값을 전달하면, 이 시점에 SQL 문이 변수와 함께 실행됩니다.

장점

SQL 재사용 가능 (같은 문장에 다른 값만 바꿔서 실행 가능 → Soft Parse 유도)
성능 최적화: Hard Parse 줄여 Shared Pool 효율성 증가
보안 강화: SQL Injection 위험 감소

2. SGA와 Instance

✅ SGA (System Global Area)

Oracle DB에서 인스턴스 메모리 영역을 의미
서버 프로세스와 백그라운드 프로세스들이 공유
데이터베이스 작동 시 반드시 메모리에 올라오는 구조

주요 구성 요소

구성 요소 설명

Shared Pool	SQL 파싱 결과, 커서, 라이브러리 캐시 등 저장
Database Buffer Cache	디스크에서 읽어온 블록 저장 (읽기/쓰기 캐시)
Redo Log Buffer	변경 사항 기록 (장애 발생 시 복구용)
Large Pool	백업, 복구, 병렬 처리 등에서 사용되는 대용량 메모리
Java Pool	Java 기반 객체 저장

✅ Instance (인스턴스)

SGA + 백그라운드 프로세스의 조합
하나의 DB 인스턴스는 한 번에 하나의 DB만 관리 가능 (단, RAC는 예외)
인스턴스는 DB를 오픈하고 관리하는 역할을 함

주요 백그라운드 프로세스

프로세스 설명

DBWR	Dirty Buffer를 디스크에 기록
LGWR	Redo Log Buffer를 Redo Log File로 기록
SMON	시스템 모니터링, 복구 처리
PMON	프로세스 모니터링, 세션 정리
CKPT	체크포인트 발생 시 관련 정보 기록

3. 전체 흐름 요약: SQL 실행과정

SQL 문장 → Parse → Bind → Execute → Fetch

Parse
- 문법 검사, 객체 존재 검사, 권한 확인
- 실행계획 생성 (Hard Parse)
- Shared Pool 검색 (Soft Parse)
Bind
- SQL 문에 변수값 적용
Execute
- 실제 SQL 실행
Fetch
- 결과 데이터 가져오기 (SELECT 문의 경우)

결론 및 정리

Parse는 SQL 문장을 해석하고 실행 계획을 생성하는 단계
Bind는 변수에 실제 값을 넣어 SQL을 완성하는 단계
SGA는 인스턴스가 사용하는 공유 메모리 공간으로 SQL 처리에 필요한 캐시와 버퍼를 포함
Instance는 SGA와 백그라운드 프로세스의 집합으로 데이터베이스를 운영하는 단위

✅ 1. 옵티마이저란?

옵티마이저(Optimizer)는 SQL 문을 어떻게 실행할지 결정하는 데이터베이스 내부 엔진입니다. Oracle에는 크게 두 가지 옵티마이저가 있습니다:

옵티마이저 유형설명

Rule-Based Optimizer (RBO)	오래된 방식. 정해진 규칙에 따라 실행 계획 결정 (Oracle 10g부터 공식적으로 제거됨)
Cost-Based Optimizer (CBO)	현재 표준 방식. 실행 비용을 계산해서 최적의 계획 선택

✅ 2. Cost-Based Optimizer(CBO)의 핵심 개념

CBO는 다음 요소들을 종합해 각 실행 계획의 비용을 추정하고, 가장 적은 비용을 가지는 계획을 선택합니다.

주요 입력 요소

요소설명

통계 정보 (Statistics)	테이블, 인덱스, 컬럼, 데이터 분포, 카디널리티 등
시스템 리소스 정보	CPU 속도, 디스크 I/O 속도 등
쿼리 구조	조인 조건, WHERE 절, 서브쿼리 등
옵티마이저 파라미터	OPTIMIZER_MODE 등 초기화 파라미터

✅ 3. 실행 계획 선택 과정

CBO는 다음과 같은 절차를 통해 SQL을 최적화합니다:

SQL 문 분석 (Parse 단계에서 수행)
가능한 실행 계획들 생성
- 테이블 Full Scan
- Index Scan
- Nested Loop Join, Hash Join 등 다양한 조인 전략
각 계획의 Cost 계산
- CPU, I/O, 메모리 자원 사용량 예측
가장 낮은 Cost를 가진 계획 선택

✅ 4. 비용(Cost) 계산 방식

Oracle의 비용은 실제 "시간"이 아니라 상대적인 리소스 소비량을 나타내는 추상적 수치입니다.

text

복사편집

Cost = CPU Cost + I/O Cost + Network Cost (예: 병렬 처리 시)

예를 들어, 인덱스 스캔이 50, 테이블 Full Scan이 80이라면, CBO는 인덱스 스캔을 선택합니다. 단, 통계 정보가 정확해야 제대로 판단합니다.

✅ 5. 통계 정보의 중요성

CBO는 정확한 결정을 위해 DB 객체의 통계 정보를 사용합니다. 이 정보는 다음 명령어로 수집합니다:

sql

복사편집

EXEC DBMS_STATS.GATHER_TABLE_STATS('SCOTT', 'EMP');

통계 정보 예시:

테이블의 행 수
컬럼의 최대/최소 값
NULL 비율
데이터 분포 (히스토그램)
인덱스 정보 (Clustering Factor 등)

✅ 6. CBO의 실행 계획 확인 방법

실제 Oracle에서 SQL 문장이 어떤 계획으로 실행될지를 보고 싶다면:

sql

복사편집

EXPLAIN PLAN FOR SELECT * FROM employees WHERE department_id = 10; SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

또는

sql

복사편집

SELECT * FROM V$SQL_PLAN WHERE SQL_ID = 'xyz...';

✅ 7. 옵티마이저 관련 파라미터

파라미터설명

OPTIMIZER_MODE	FIRST_ROWS, ALL_ROWS, CHOOSE 등
OPTIMIZER_FEATURES_ENABLE	Oracle 버전에 따른 최적화 동작 선택
OPTIMIZER_INDEX_COST_ADJ	인덱스 사용 유도 정도 조절

✅ 8. 실전 예시

예:

sql

복사편집

SELECT * FROM employees WHERE last_name = 'Smith';

테이블에 수백만 건의 데이터가 있고
last_name 컬럼에 인덱스가 있을 경우
CBO는 인덱스를 사용할지, Full Scan을 할지 비용을 계산해서 결정합니다

만약 통계 정보가 없다면, CBO는 부정확한 판단을 내릴 수 있습니다.

✅ 요약 정리

항목설명

CBO	비용 기반의 실행 계획 선택 시스템
기반 정보	테이블/인덱스 통계, 시스템 리소스, SQL 구조
목표	최소 비용(Max Performance)의 실행 계획 선택
필수 조건	정확한 통계 수집 (DBMS_STATS)
확인 방법	EXPLAIN PLAN, V$SQL_PLAN, AUTOTRACE 등

[oracle] sqlloader 대량의 데이터 DB에 로드 유틸리티

aonee — Fri, 20 Dec 2024 15:01:54 +0900

SQLLoader ?

대량의 데이터를 Oracle 데이터베이스 테이블에 효율적으로 로드하는 데 사용되는 유틸리티

주로 외부 데이터 파일 (예: CSV, 텍스트 파일 등)에 저장된 데이터를 Oracle 데이터베이스 테이블에 삽입할 때 사용

사용법

sqlldr username/password@dbname control=control_file.log

username/password@dbname: Oracle 데이터베이스에 접속할 사용자 이름과 비밀번호 및 데이터베이스의 접속 정보.
control: 로딩 작업을 정의하는 제어 파일의 경로 (Control file).
log: SQL*Loader가 작업 중 생성한 로그 파일.

Control File (제어 파일)

SQL*Loader의 핵심 파일로, 외부 파일에서 데이터를 어떻게 로드할지에 대한 규칙을 정의합니다. 제어 파일에는 다음과 같은 정보를 포함합니다:

로드할 데이터 파일의 경로.
데이터 파일의 형식 (구분자, 고정 길이 등).
대상 테이블과 매핑될 컬럼.
로드할 데이터의 조건.
예시

LOAD DATA
INFILE 'data.csv'
INTO TABLE employees
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
(
    employee_id, 
    first_name, 
    last_name, 
    email,
    hire_date DATE "YYYY-MM-DD"
)

LOAD DATA: SQL*Loader가 데이터를 로드하도록 지시하는 구문.
INFILE 'data.csv': 로드할 데이터가 저장된 외부 파일 경로.
INTO TABLE employees: 로드할 데이터를 삽입할 대상 테이블.
FIELDS TERMINATED BY ',': 각 필드가 쉼표로 구분된다는 것을 나타냅니다 (CSV 형식).
OPTIONALLY ENCLOSED BY '"': 필드 값이 따옴표로 둘러싸일 수 있음을 지정합니다.
DATE "YYYY-MM-DD": 날짜 형식을 정의하는 예시.

control file 옵션

INFILE: 로드할 데이터 파일의 경로를 지정합니다.
INTO TABLE: 데이터를 삽입할 대상 테이블을 지정합니다.
FIELDS TERMINATED BY: 데이터 필드를 구분하는 구분자를 지정합니다. 예를 들어, 쉼표 , 또는 탭 \t.
OPTIONALLY ENCLOSED BY: 값이 따옴표나 다른 문자로 둘러싸여 있는 경우 해당 문자를 지정합니다.
DATE: 날짜 형식을 지정할 때 사용합니다.
TRAILING NULLCOLS: 데이터 파일에 누락된 컬럼에 대해 NULL 값을 삽입하도록 지정합니다.

SQLLoader 실행 예시

sqlldr username/password@dbname control=control_file.ctl 
log=load_log.log 
bad=bad_file.bad 
discard=discard_file.dsc

bad=bad_file.bad: 잘못된 데이터가 있으면 해당 레코드를 기록할 파일을 지정합니다.
ex) insert 수행 시, 데이터 타입 안맞아서 error난 경우
discard=discard_file.dsc: 조건에 맞지 않는 레코드를 기록할 파일을 지정합니다.
ex) when id < 100 , 해당 조건에 맞지 않는 레코드 기록
direct=true: 데이터를 직접 로드하여 성능을 최적화합니다 (배치 처리 모드).
rows=1000: 한 번에 로드할 데이터의 최대 행 수를 지정합니다.

[oracle] manage undo data

aonee — Thu, 19 Dec 2024 16:47:12 +0900

undo data 란?

트랜잭션 처리의 일관성 유지
트랜잭션이 수행된 변경 내용을 저장하고, 트랜잭션이 롤백될 때 해당 변경 사항을 되돌리는 데 사용됨
롤백 및 복구 작업
시스템 크래시나 장애 발생 시, Oracle은 Undo 데이터를 사용하여 트랜잭션을 복구함
장애 발생 후 시스템을 재시작하면 Oracle은 Undo 데이터를 이용하여 일관성을 회복함
읽기 일관성을 보장
다중 트랜잭션이 동시에 실행될 때, 각 트랜잭션에 대해 일관성 있는 데이터를 제공하기 위해 Undo 데이터를 사용함 이를 통해, 하나의 트랜잭션이 데이터를 수정하는 동안 다른 트랜잭션은 수정 전 데이터를 조회할 수 있음

Undo Tablespace

Undo 데이터는 Undo Tablespace라는 특별한 테이블스페이스에 저장됨

이 테이블스페이스는 데이터베이스의 물리적 공간으로, Oracle이 트랜잭션의 변경을 추적하고 롤백을 수행하는 데 필요한 공간을 제함

Undo Tablespace 생성

CREATE TABLESPACE undotbs DATAFILE '/path_to_file/undotbs01.dbf' SIZE 1G;

Undo Tablespace 변경

ALTER DATABASE DATAFILE '/path_to_file/undotbs01.dbf' RESIZE 2G;

Undo Tablespace 상태 확인

SELECT tablespace_name, file_id, file_name, bytes, blocks

FROM dba_data_files

WHERE tablespace_name = 'UNDOTBS';

Undo 데이터 크기 설정

UNDO_RETENTION 값은 최소한의 Undo 데이터를 보유하는 시간 설정

ex)

ALTER SYSTEM SET undo_retention = 3600; -- 1시간 동안 Undo 데이터 유지

undo_retention = 30sec

600/600sec

1/sec

required_undo_size(900)

등등 설정 가능

Undo 사용과 최적화

자동커밋
자동 커밋(autocommit) 모드에서 트랜잭션이 빠르게 종료되므로 Undo 데이터가 빠르게 회수됨
하지만, 큰 트랜잭션을 처리할 때는 Undo 테이블스페이스가 빠르게 가득 찰 수 있음
큰 트랜잭션이 많이 발생하는 환경에서는 Undo 테이블스페이스의 크기를 적절히 늘려야 함
대용량 데이터 처리
대량의 데이터를 처리할 때 Undo 공간이 부족하면 성능 저하나 트랜잭션 롤백 실패가 발생할 수 있음
이럴 때는 UNDO_RETENTION 값을 늘리거나, 대량 데이터 삽입 작업 중에는 적절한 커밋 주기를 설정하여 Undo 공간을 효율적으로 사용해야 함.

[oracle] Table Compression

aonee — Thu, 19 Dec 2024 15:55:56 +0900

Table Compression

header 블럭 여러번 반복되는 문제 해결
compressed block header로 symbol table 두고 사용하면
공간낭비 줄이고 사용가능

basic : pctfree = 0

select 할 때 압축 풀고 다시 selecting하냐? no 압축해제 안일어남

read only 목적으로 사용.

255 columns 넘어가면 압축테이블 사용하지마 제약 있음 (11g기준)

DBMS_COMPRESSION.GET_COMPRESSION_RATIO 
( 
scratchtbsname => 'USERS', 
ownname => 'HR', 
objname => 'I_TEST', 
subobjname => NULL, 
comptype => dbms_compression.COMP_INDEX_ADVANCED_LOW, 
blkcnt_cmp => blkcnt_cmp, 
blkcnt_uncmp => blkcnt_uncmp, 
row_cmp => row_cmp, 
row_uncmp => row_uncmp, 
cmp_ratio => cmp_ratio, 
   For Instructor Use Only.
  This document should not be distributed.
Copyright © 2022, Oracle and/or its affiliates. 
176 Practices for Lesson 15: Improving Space Usage 
comptype_str => comptype_str, 
subset_numrows => dbms_compression.COMP_RATIO_MINROWS, 
objtype => dbms_compression.OBJTYPE_INDEX 
);

index 압축 종류 2종류

low

high

이럴경우, index압축률이 더 좋은 high 압축 사용하는 것이 더 좋음

Resolving Space Usage Issues

dba_outstanding_alerts 로 tablespace 확인 가능

Shrinking Segments

Oracle 데이터베이스에서 사용되지 않는 공간을 세그먼트 내에서 회수하는 작업

세그먼트 축소는 주로 삭제된 데이터나 업데이트로 인해 공간이 낭비되는 경우, 이를 최적화하여 공간을 회수하는 작업이다.

세그먼트 축소를 통해 세그먼트 내의 불필요한 공간을 재사용 가능하게 만들고, 스토리지 효율성을 높이며, 성능을 개선할 수 있다.

* 세그먼트 축소 방법

1) 테이블 축소

ALTER TABLE <테이블명> SHRINK SPACE;

2) 인덱스 축소

ALTER INDEX <인덱스명> SHRINK SPACE;

* 장점

공간 절약: 사용되지 않는 공간을 회수하여 디스크 공간을 절약할 수 있다
성능 향상: 축소된 세그먼트는 더 적은 디스크 공간을 차지하며, 데이터 액세스 성능을 향상시킬 수 있습니다. 데이터베이스가 더 적은 공간을 검색하므로 I/O 효율성이 높아질 수 있다 .
스토리지 최적화: 저장 공간을 재활용하여, 추가적인 스토리지 비용을 절감할 수 있다

* 단점

자원 소모: 축소 작업은 CPU와 I/O 자원을 많이 소모할 수 있습니다. 특히 큰 테이블이나 인덱스를 축소할 때 시간이 많이 걸릴 수 있다
테이블 락: 테이블을 축소하는 동안 해당 테이블에 대한 락이 발생할 수 있습니다. 이로 인해 다른 세션들이 테이블에 접근할 수 없게 되어, 시스템의 동시성에 영향을 줄 수 있다
불필요한 축소 방지: 자주 데이터를 삭제하고 추가하는 테이블에 대해서는 축소 작업을 자주 수행하는 것이 비효율적일 수 있습니다. 세그먼트 축소는 주기적인 작업으로, 모든 경우에 항상 적합하지 않을 수 있다

* 고려사항

트랜잭션 처리: 세그먼트 축소 작업을 수행할 때, 트랜잭션을 처리하는 데 영향을 줄 수 있으므로, 작업을 비업무 시간에 수행하는 것이 좋다
테이블 및 인덱스 크기: 큰 테이블이나 인덱스의 경우, 축소 작업이 완료될 때까지 시간이 오래 걸리며, 시스템 성능에 부정적인 영향을 미칠 수 있다
자동화된 공간 관리 (ASSM): Oracle에서는 ASSM (Automatic Segment Space Management) 방식이 활성화된 경우, 세그먼트 공간 관리를 자동으로 처리하지만, 여전히 세그먼트 축소는 DBA가 수동으로 수행할 수 있는 작업이다

[oracle] Database Storage, logical DB (Tablespace, Segment, Extent, Data Block )

aonee — Wed, 18 Dec 2024 17:00:02 +0900

logical DB VS pysical DB

논리적 데이터베이스는 데이터 모델링과 데이터 관계를 다루며, 주로 사용자나 애플리케이션의 요구에 맞춰 데이터를 어떻게 다룰지를 정의함
물리적 데이터베이스는 실제 데이터가 어떻게 저장되고 관리되는지에 중점을 두며, 시스템의 성능과 저장 공간 최적화, 백업/복구 전략 등을 고려함

논리적 데이터베이스에 대해 자세히 살펴보려함

논리적 데이터베이스는 다음과 같이 구성됨.

Tablespace는 데이터베이스의 논리적 저장 공간을 관리하며, 여러 테이블이나 인덱스가 저장.
Segment는 데이터를 저장하는 집합적인 단위로, 테이블, 인덱스 등의 객체는 세그먼트 형태로 저장됨
Extent는 세그먼트 내에서 데이터를 연속적인 블록 단위로 할당하는 단위이며, 물리적 저장을 효율적으로 관리함
Data Block은 실제 데이터가 저장되는 가장 작은 물리적 저장 단위로, Oracle 데이터베이스가 데이터를 읽고 쓸 때의 기본 단위

Tablespace, Segment, Extent, Data Block 관계

데이터가 저장되는 구조를 이해하는 데 중요한 역할을 하는데, 이들 간의 관계는 다음과 같다.

Tablespace는 데이터베이스에서 데이터를 논리적으로 관리하는 가장 큰 단위임
Segment는 테이블, 인덱스 등의 데이터를 저장하는 논리적 데이터 집합이며, 각 세그먼트는 하나 이상의 Extent로 구성됨
Extent는 여러 개의 Data Block이 연속적으로 배치된 집합이며, Data Block은 Oracle에서 데이터를 실제로 저장하는 가장 작은 단위임

예시 흐름

테이블을 생성하면 Segment가 생성됨
테이블에 데이터가 추가되면, 필요한 만큼 Extent가 할당됨
각 Extent는 연속된 Data Block으로 이루어져 있음
데이터가 Data Block에 저장되며, Data Block은 물리적 디스크에 실제로 존재함

각 구성요소에 대해 더 자세히 살펴보면 다음과 같다.

1. Tablespace

Tablespace는 Oracle 데이터베이스에서 데이터를 논리적으로 관리하기 위한 가장 큰 저장 단위입니다. 데이터베이스 객체(예: 테이블, 인덱스, 클러스터 등)는 특정 테이블스페이스에 저장됩니다. 테이블스페이스는 논리적 개념이며, 실제 데이터는 테이블스페이스 내의 물리적 파일에 저장됩니다.

특징

논리적 저장 단위: 테이블스페이스는 데이터베이스의 논리적인 저장 영역을 정의하며, 여러 개의 테이블스페이스가 데이터베이스 내에서 서로 독립적으로 존재할 수 있습니다.
물리적 파일에 맵핑: 각 테이블스페이스는 하나 이상의 물리적 파일(데이터 파일)과 연결됩니다. 이 데이터 파일은 실제 데이터가 저장되는 디스크 공간을 나타냅니다.
테이블스페이스의 종류
- SYSTEM 테이블스페이스: 시스템과 관련된 중요한 데이터(예: 데이터 딕셔너리, 시스템 테이블 등)가 저장됩니다.
- USERS 테이블스페이스: 일반적인 사용자 데이터가 저장됩니다.
- TEMP 테이블스페이스: 정렬 작업이나 임시 데이터를 저장하는 데 사용됩니다.
- UNDO 테이블스페이스: 트랜잭션 롤백 및 복구에 필요한 정보를 저장합니다.
- 예비 테이블스페이스 (Undo, Temp): 임시 저장 공간으로 사용되며, 주로 시스템 성능을 최적화하기 위해 사용됩니다.

예시

sql

코드 복사

-- 새로운 테이블스페이스 생성 CREATE TABLESPACE my_tablespace DATAFILE '/u01/app/oracle/oradata/mydb/myfile.dbf' SIZE 100M;

장점

데이터 관리의 유연성 제공 (데이터 파일을 다른 디스크로 옮길 수 있음)
성능 최적화를 위한 데이터 분리 가능 (예: 자주 액세스하는 데이터와 덜 액세스하는 데이터를 별도의 테이블스페이스로 관리)

2. Segment

Segment는 테이블스페이스 내에 저장된 데이터의 집합을 의미합니다. Oracle 데이터베이스에서 모든 데이터 객체(테이블, 인덱스, 클러스터 등)는 세그먼트 형태로 저장됩니다. 예를 들어, 하나의 테이블은 하나의 세그먼트를 차지하며, 하나의 세그먼트는 여러 개의 extent로 구성됩니다.

특징

데이터 저장 단위: 세그먼트는 데이터베이스에서 테이블, 인덱스, 롤백 세그먼트와 같은 저장 구조의 데이터를 포함하는 논리적 저장 단위입니다.
세그먼트 유형: 세그먼트의 종류에 따라 저장되는 데이터 유형이 달라집니다.
- 테이블 세그먼트: 테이블에 저장된 데이터.
- 인덱스 세그먼트: 인덱스에 저장된 데이터.
- 롤백 세그먼트: 트랜잭션 롤백을 위한 데이터.
세그먼트는 물리적으로 extent를 여러 개 가질 수 있으며, 데이터가 추가될 때 세그먼트의 크기는 Extent 단위로 증가합니다.

예시

MY_TABLE이라는 테이블은 테이블 세그먼트를 가지며, 이 테이블에 데이터를 삽입하면 세그먼트 크기가 커질 수 있습니다.

3. Extent

Extent는 세그먼트 내에서 데이터를 저장하는 연속된 블록 집합입니다. 즉, Extent는 하나의 세그먼트에서 할당된 여러 개의 데이터 블록이 모인 집합으로, 세그먼트 내에서 데이터를 효율적으로 관리하기 위한 물리적 저장 단위입니다.

특징

연속된 블록 집합: 하나의 extent는 여러 개의 연속적인 데이터 블록으로 구성됩니다. 이 블록들은 물리적 메모리 공간에서 연속적으로 배치됩니다.
크기: Extent의 크기는 테이블스페이스에서 데이터를 관리하는 방식에 따라 다를 수 있습니다. 일반적으로 기본적으로 5MB나 10MB 정도로 설정될 수 있습니다.
자동 확장: 데이터가 세그먼트에 추가되면, 해당 세그먼트에 새로운 Extent가 할당됩니다. 이는 자동으로 이루어지며, 세그먼트가 확장될 수 있도록 합니다.

예시

만약 한 테이블에 데이터가 추가되어 세그먼트가 부족하게 되면, 새로운 Extent가 할당되어 데이터가 추가됩니다.

4. Data Block

Data Block(또는 데이터 블록)은 Oracle 데이터베이스에서 가장 작은 저장 단위입니다. 데이터 블록은 실제로 디스크에 저장되는 데이터를 포함하는 최소 단위이며, Oracle이 데이터를 읽고 쓰는 기본적인 단위입니다. 데이터베이스는 데이터를 읽고 쓸 때 항상 데이터 블록 단위로 작업합니다.

특징

물리적 저장 단위: 데이터 블록은 데이터베이스의 물리적 저장소에서 실제 데이터를 저장하는 기본 단위입니다. 즉, 테이블에 저장된 데이터, 인덱스, 기타 데이터는 모두 데이터 블록에 저장됩니다.
블록 크기: 데이터 블록의 크기는 데이터베이스의 블록 크기(예: 8KB, 16KB 등)에 의해 결정됩니다. 이 크기는 데이터베이스 생성 시 설정되며, 변경할 수 없습니다.
논리적 및 물리적 연관: 데이터 블록은 논리적으로 데이터를 저장하는 단위일 뿐만 아니라, 물리적으로 데이터를 디스크에 배치하는 단위이기도 합니다.

데이터 블록 구조:

데이터 블록에는 다음과 같은 내용들이 포함됩니다:

헤더(Header): 블록의 메타데이터(예: 블록이 사용 중인지, 비어 있는지 여부 등).
행 데이터(Row Data): 실제 저장된 테이블의 행 데이터.
프리 데이터(Free Space): 현재 사용되지 않는 공간으로, 데이터가 삽입될 때 새로운 데이터가 추가됩니다.
체인(Chain): 여러 블록이 연결되어 있을 수 있으며, 한 블록이 꽉 찼을 때 다음 블록으로 체인처럼 연결될 수 있습니다.

예시

데이터베이스가 데이터를 8KB 블록 크기로 구성하고 있다면, 각 데이터는 8KB 단위로 디스크에 저장됩니다. 예를 들어, users 테이블에 데이터가 저장될 때, 각 레코드는 8KB의 데이터 블록에 기록됩니다.

장점

효율적인 데이터 읽기/쓰기: 데이터베이스는 데이터를 블록 단위로 읽고 쓰기 때문에, 물리적인 디스크 I/O가 효율적입니다.
적은 메모리 사용: 데이터 블록은 작은 단위로 데이터를 저장하고 처리하므로, 메모리 사용의 최적화가 가능합니다.

smallfile TS : 여러 datafile 가질 수 있음 - 4백만개 block

bigfile TS : 매우 큰 datafile 딱 1개만 가질 수 있음 - 1 datafile 40억개 block

32K * 40억개 = 32T

db_block_size = 2 4 8 16 32K

extent allocate

1. create table X

테이블 생성은 extent 생성 안됨

공간이 아직 없어서 segment가 아직 아님

그러면 언제 할당되냐? 첫 row insert시 자동 extent 생성됨

DEFERRED_SEGMENT_CREATION=TRUE 설정해두면 됨.

2. dynamic allocation

3. 직접 할당

alter table test allocate extent;

수행시마다 extent 할당

extent deallocate

1. drop table test 반납함

delete X 반납안함

truncate table test; 반납함. 테이블에 있는 영역 다 지워라

2. alter table test deallocate unused;

high water mark 위쪽 반납

첫번재 extent는 header부분

high water mark 물자국

Creating and Managing Tablespaces

각 테이블스페이스는 특정 용도에 맞게 설계되며, 이에 따라 Permanent, Undo, Temporary 등 세 가지 주요 테이블스페이스 유형이 있음
각각의 테이블스페이스는 Oracle 데이터베이스의 성능과 유지보수에 중요한 역할을 함

1. Permanent Tablespace

Permanent 테이블스페이스는 데이터베이스에서 실제로 사용자 데이터나 시스템 데이터를 저장하는 테이블스페이스

이 테이블스페이스는 영구적인 데이터 저장을 위해 사용되며, 일반적으로 테이블, 인덱스, 뷰 등의 데이터가 저장됨

특징

영구적인 데이터 저장: Permanent 테이블스페이스는 사용자가 생성한 테이블, 인덱스, 뷰 등 영구적인 데이터를 저장하는 데 사용됨
데이터 파일: Permanent 테이블스페이스는 하나 이상의 데이터 파일로 구성되며, 이 데이터 파일은 디스크에 실제 데이터를 저장함
기본 테이블스페이스: USERS 테이블스페이스가 이 범주에 속합니다. Oracle 설치 시 기본적으로 제공되는 테이블스페이스

생성 예시

sql

-- Permanent 테이블스페이스 생성

CREATE TABLESPACE my_permanent_tablespace DATAFILE '/u01/app/oracle/oradata/mydb/my_permanent.dbf' 
SIZE 100M AUTOEXTEND ON NEXT 10M MAXSIZE UNLIMITED;

DATAFILE: 테이블스페이스의 물리적 저장 위치를 지정합니다.
SIZE: 테이블스페이스의 초기 크기를 지정합니다.
AUTOEXTEND: 테이블스페이스의 크기가 자동으로 확장되도록 설정합니다.
MAXSIZE: 데이터 파일의 최대 크기를 설정합니다.

2. Undo Tablespace

Undo 테이블스페이스는 트랜잭션이 롤백되거나 복구되는 동안 사용되는 중간 데이터를 저장하는 테이블스페이스이다.

주로 데이터베이스의 트랜잭션 관리와 복구를 위한 로그 정보를 저장함

특징

트랜잭션 관리: Undo 테이블스페이스는 트랜잭션이 실행되는 동안 발생하는 데이터 변경을 취소(롤백)하거나, 롤백된 데이터 상태를 복원할 때 사용됨
Rollback: 트랜잭션이 완료되기 전에 변경된 데이터를 되돌리기 위해 사용 됨
자동 관리: 데이터베이스는 자동으로 Undo 테이블스페이스를 관리하며, 이를 통해 데이터 무결성을 보장 함
기본 Undo 테이블스페이스: Oracle에서 기본적으로 **UNDO**라는 이름의 테이블스페이스가 제공되며, 이를 통해 트랜잭션 복구 작업을 수행 함

생성 예시

sql

-- Undo 테이블스페이스 생성

CREATE TABLESPACE undotbs1 DATAFILE '/u01/app/oracle/oradata/mydb/undotbs01.dbf' 
SIZE 200M AUTOEXTEND ON NEXT 20M MAXSIZE 2G;

DATAFILE: Undo 테이블스페이스의 물리적 위치를 지정 함
SIZE: 초기 크기를 지정 함
AUTOEXTEND: 데이터 파일 크기가 자동으로 확장될 수 있도록 설정 함
MAXSIZE: Undo 파일의 최대 크기를 제한함

사용 예시

Undo 테이블스페이스는 롤백을 위해 필요하므로 트랜잭션 처리 중에 Undo 정보를 저장하고, 트랜잭션이 완료되면 해당 데이터는 삭제됩니다.

3. Temporary Tablespace

Temporary 테이블스페이스는 임시 데이터를 저장하는 데 사용되는 테이블스페이스입니다. 이 테이블스페이스는 주로 정렬 작업, 해시 조인, 임시 테이블 등의 일시적인 작업에 필요한 공간을 제공함

특징

임시 데이터 저장: Temporary 테이블스페이스는 데이터베이스가 쿼리 실행 중에 필요한 임시 데이터를 저장하는 데 사용됩니다. 예를 들어, 대용량 데이터를 처리할 때 정렬 작업, 임시 테이블, 인덱스 빌드 등의 작업이 발생할 때 사용 됨
자동 관리: Temporary 테이블스페이스는 데이터가 한 번 사용되면 삭제되기 때문에 자동으로 관리 됨 .
복구 불필요: Temporary 테이블스페이스는 임시 데이터만 저장하기 때문에 시스템이 크래시나 오류가 발생하더라도 복구할 필요가 없음

생성 예시

sql

-- Temporary 테이블스페이스 생성

CREATE TEMPORARY TABLESPACE temp_ts TEMPFILE '/u01/app/oracle/oradata/mydb/temp01.dbf' 
SIZE 100M AUTOEXTEND ON NEXT 10M MAXSIZE 1G;

TEMPFILE: Temporary 테이블스페이스는 TEMPFILE을 사용하여 데이터를 저장합니다. TEMPFILE은 데이터 파일과 달리 복구 대상이 아니므로 로그를 기록하지 않음
SIZE: 초기 크기를 지정 함
AUTOEXTEND: 필요할 때 자동 확장을 설정하여 공간이 부족할 경우 자동으로 확장 됨
MAXSIZE: 확장 가능한 최대 크기를 설정 함

사용 예시

복잡한 쿼리에서 정렬 작업, 조인 작업 등을 할 때 임시 테이블스페이스에 임시 데이터가 저장 됨
예를 들어, ORDER BY, DISTINCT 등의 작업이 수행될 때 해당 데이터는 Temporary 테이블스페이스에 저장됨

세 가지 테이블스페이스의 차이점

속성	Permanent Tablespace	Undo Tablespace	Temporary Tablespace
목적	영구적인 사용자 데이터(테이블, 인덱스 등) 저장	트랜잭션 롤백 및 복구를 위한 중간 데이터 저장	임시 데이터(정렬, 해시 조인 등) 저장
주요 사용처	사용자 테이블, 인덱스, 뷰, 클러스터 등 저장	트랜잭션 관리, 롤백, 데이터 복구	쿼리 실행 중의 임시 작업(정렬, 인덱스 빌드 등)
파일 유형	DATAFILE	DATAFILE (Undo 정보 저장)	TEMPFILE (임시 데이터 저장)
자동 확장	설정 가능	설정 가능	설정 가능
복구	데이터 복구 가능	트랜잭션 롤백, 데이터 복구에 필수	데이터 복구 필요 없음 (임시 데이터)
생성 예시	CREATE TABLESPACE permanent_ts DATAFILE '/path/to/file' SIZE 100M;	CREATE TABLESPACE undotbs1 DATAFILE '/path/to/undo.dbf' SIZE 200M;	CREATE TEMPORARY TABLESPACE temp_ts TEMPFILE '/path/to/temp01.dbf' SIZE 100M;

정리리

Permanent Tablespace는 데이터베이스의 주요 데이터를 영구적으로 저장하는 데 사용됨
Undo Tablespace는 트랜잭션 롤백 및 복구에 필요한 중간 데이터를 저장하며, 데이터베이스의 무결성을 유지함
Temporary Tablespace는 임시 데이터 작업을 지원하는 데 사용되며, 일반적으로 쿼리 실행 중 발생하는 임시 작업에 대한 데이터를 저장함

각각의 테이블스페이스는 특정 작업이나 기능을 지원하는데 필수적인 역할을 하며, 성능과 효율적인 데이터 관리를 위해 적절하게 구성하고 관리해야함

Segment Space Management

Manual Segment Space Management (수동 세그먼트 공간 관리)

Oracle 데이터베이스에서 세그먼트(예: 테이블, 인덱스, 클러스터 등)에 대한 공간을 수동으로 관리하는 방법

자동 세그먼트 공간 관리(Automatic Segment Space Management, ASSM)

Oracle은 기본적으로 지원함

사용자가 직접 세그먼트의 공간을 관리할 수 있도록 하는 옵션이 Manual Segment Space Management

Manual Segment Space Management는 테이블이나 인덱스 세그먼트의 공간을 수동으로 관리하는 방식임
Freelist를 사용하여 빈 공간을 추적하고 관리하며, 데이터를 삽입할 때 빈 공간을 수동으로 찾아서 할당함
이 방식은 관리 복잡도가 높고, 공간 효율성이 떨어질 수 있어, 현대적인 Oracle 시스템에서는 대부분Automatic Segment Space Management (ASSM)가 선호됨
ASSM은 자동으로 공간을 효율적으로 관리해주므로, 대부분의 경우 수동 방식보다는 자동 방식이 더 유리함

Manual Segment Space Management와 ASSM의 차이점

특징Manual Segment Space ManagementAutomatic Segment Space Management (ASSM)

공간 관리	Freelist 사용, 수동으로 관리	Oracle이 자동으로 공간을 관리
공간 효율성	빈 공간 관리가 수동으로 이루어져 효율성 떨어질 수 있음	공간 관리가 자동화되어 더 효율적임
관리 복잡도	수동으로 빈 공간을 관리해야 하므로 복잡함	관리가 자동화되어 더 간단함
주요 사용 환경	오래된 시스템이나 특별한 요구 사항이 있는 환경에서 사용	대부분의 새로운 시스템에서 사용
조각화	빈 공간 조각화가 발생할 수 있음	조각화가 자동으로 처리됨

[oralce] Default Listener와 Shared Server

aonee — Wed, 18 Dec 2024 15:57:46 +0900

Default Listener

리스너가 알아야하는 4가지 정보

host

port

protocol

LREG

lreg

백그라운드 서버를 통해 다이나믹하게 알려주고 있다

Dynamic Reg

service_names

Dynamic Service Registration

장점

local_listener = A ( service_name 지정 ex)testorcl )

tnsnames.ora파일에 추가

추가로 리스너를 띄우는 거니 클라이언트 아닌, 서버쪽tnsnames.ora파일에 추가해야한다

1. tsnnames.ora

A = 1(host) 2(1561) 3(tcp)

2. SQL > alter system set local_listener=A;

LREG

1521은 무조건 dynamic하게 알린다

1561도 추가하려면 서버측 tnsnames.ora파일 확인

서버쪽 listener.ora파일이 반드시 필요함

환경변수

TNS_ADMIN = $ORACLE_HOME/network/admin/listener.ora

설정되어있는지 확인

(ex)

listener.ora

LISTENER_SALESPDBS =

(DESCRIPTION_LIST =

(DESCRIPTION =

(ADDRESS = (PROTOCOL = TCP)(HOST = host1.example.com)(PORT = 1561))

))

SID_LIST_LISTENER_SALESPDBS =

(SID_LIST = (SID_DESC = (GLOBAL_DB

NAME = PDB1.example.com) (SID_NAME = ORCL) (ORACLE_HOME = /u01/app/oracle/product/12.2.0/dbhome_1)

)

(SID_DESC =

(GLOBAL_DBNAME = PDB2.example.com) (SID_NAME = ORCL)

(ORACLE_HOME = /u01/app/oracle/product/12.2.0/dbhome_1)

) )

Shared Server

1. 관련 파라메터

SQL> ALTER SYSTEM SET shared_servers = 3;

SQL> ALTER SYSTEM SET max_shared_servers = 10; -- user많아지면 server 최대 10개

SQL> ALTER SYSTEM SET dispatchers=’(pro=tcp)(dis=5)’; -- listener 에 dispatcher 가 등록됨

SQL> ALTER SYSTEM SET max_dispatchers = 10;

2. DB 에 접속

서버 share할건지 dedicate할건지 client tnsnames.ora에 설정필요

@sales

- 디스패처

SERVER=shared : 공유 서버 프로세스 연결 ex) 중요하지 않은 반복 작업

SERVER=dedicated : listener 전용 서버 프로세스 연결 ex) 백업, 배치

$ cat $ORACLE_HOME/network/admin/tnsnames.ora 
… 
sales= 
(DESCRIPTION= 
(ADDRESS=(PROTOCOL=tcp)(HOST=sales-server)(PORT=1521)) 
(CONNECT_DATA= 
(SERVICE_NAME=sales.us.example.com) 
(SERVER=shared))) 
… 
$ sqlplus hr/oracle_4U@sales

[oracle] 멀티테넌트, CDB, PDB, SEED 개념 및 PDB 생성방법 5가지

aonee — Wed, 18 Dec 2024 15:20:24 +0900

Multitenant 관리

Oracle Multitenant Architecture (멀티테넌트 아키텍처)

DB 안에 여러 DB들이 들어가 있는 구조

Oracle 12c에서 도입된 멀티테넌트 아키텍처(Multitenant Architecture)는 데이터베이스 관리의 효율성을 높이고, 여러 데이터베이스를 하나의 물리적 시스템에서 독립적으로 운영할 수 있는 방법을 제공합니다. 이 아키텍처의 핵심은 CDB (Container Database)와 PDB (Pluggable Database)의 개념
DB안의 DB
컨테이너 역할을 수행하는 DB기능을 제공한다.

[ 멀티테넌트 아키텍처의 주요 기능 ]

1. PDB 생성 및 관리
  - PDB는 CDB 내에서 Create, Drop, Rename 등의 관리 작업을 통해 생성, 삭제, 이름 변경 등이 가능합니다.
  - CREATE PLUGGABLE DATABASE 명령어로 새로운 PDB를 생성할 수 있습니다.
2. PDB 이동 및 복사
  - PDB Cloning: 기존 PDB를 복사하여 새로운 PDB를 만들 수 있습니다.
  - PDB Relocation: PDB를 다른 CDB로 이동할 수 있습니다.
3. PDB의 연결 및 분리
  - Plug-in: 기존의 PDB를 CDB에 연결하는 작업.
  - Unplugging: CDB에서 PDB를 분리하여 다른 CDB로 옮길 수 있습니다.
4. 공유 및 독립적인 데이터베이스 운영
  - 각 PDB는 독립적인 데이터베이스 환경을 제공하면서도 공유된 리소스를 사용합니다.
  - PDB $SEED를 기반으로 새로운 PDB를 빠르게 생성할 수 있습니다.
5. 공통 리소스와 독립적 관리
  - 공통 리소스 (CDB$ROOT)는 여러 PDB 간에 공유되지만, 각 PDB는 독립적으로 데이터를 관리하고 보안을 유지합니다.주요 기능

[ 멀티테넌트 아키텍처의 예시 ]

1. 한 기업에서 여러 부서가 독립적인 데이터베이스를 운영할 때

각 부서는 자신의 PDB를 통해 독립적인 애플리케이션과 데이터를 처리합니다.
관리자는 CDB를 통해 여러 PDB를 관리하고, 공통 자원(예: 인프라, 라이선스 등)을 활용하여 비용을 절감할 수 있습니다.

2. 클라우드 서비스 제공 업체

클라우드 환경에서 여러 고객이 하나의 CDB를 공유하면서도 각 고객은 자신의 독립적인 PDB에서 데이터를 처리합니다.
이 방식은 멀티 테넌트 아키텍처의 장점을 살려 클라우드 리소스를 효율적으로 활용할 수 있습니다.

[정리]

멀티테넌트 아키텍처는 하나의 CDB에서 여러 개의 PDB를 실행하여 데이터베이스 관리의 효율성과 자원 관리 최적화를 가능하게 합니다

CDB

[CDB] Container DataBase

하나의 CDB는 여러개의 PDB라고 불리는 독립된 DB를 담을수 있는 기능 제공

CDB는 컨테이너 데이터베이스로, 멀티테넌트 아키텍처의 핵심입니다. 하나의 CDB는 여러 개의 PDB를 포함할 수 있으며, 모든 PDB는 이 CDB 내에서 운영됨

CDB$ROOT: CDB 내에서 루트 컨테이너라고도 불리며, 시스템 전반에 영향을 미치는 공통 데이터와 설정을 포함합니다. 예를 들어, 시스템 테이블과 사용자 계정 등이 이곳에 저장됨.
CDB 내의 파일들: CDB에는 기본적으로 컨테이너에 필요한 시스템 파일이 저장됩니다. 데이터베이스 구조의 일부로서 CDB는 모든 PDB를 관리하고 연결할 수 있는 기능을 제공

PDB

[PDB] Pluggable Database

독자적인 스키마, 스키마 오브젝트, 유저와 같은 집합을 가진다. (실제 물리적 정보 저장)

PDB는 플러그 가능한 데이터베이스로, 독립적인 데이터베이스 인스턴스를 의미

각 PDB는 독립적인 데이터베이스 환경을 제공하며, 개별적으로 사용자의 데이터와 애플리케이션을 저장함

PDB는 데이터베이스의 논리적 단위로, 물리적으로는 CDB 내에서 운영됨.
각 PDB는 고유한 데이터와 설정을 가질 수 있으며, 독립적인 백업, 복구, 업그레이드가 가능함
PDB는 CDB 내에 포함된 여러 개의 PDB들 중 하나일 뿐이며, 동일한 CDB에 여러 개의 PDB를 포함할 수 있음

Seed PDB (PDB$SEED)

Seed PDB는 새로운 PDB를 생성할 때 기본 템플릿 역할을 하는 PDB이다

PDB$SEED는 읽기 전용(Read-only) PDB로, 새로운 PDB를 생성할 때 이를 복사하여 사용하는 방식임

이 템플릿을 사용하면 새로운 PDB를 빠르고 일관되게 생성할 수 있음

CDB와 PDB의 관계

CDB는 여러 PDB를 포함할 수 있으며, CDB$ROOT와 여러 PDB가 포함됨
PDB는 독립적인 데이터베이스로 동작하지만, CDB의 리소스를 공유함
예를 들어, 각 PDB는 공통의 컨테이너 데이터를 사용할 수 있음
CDB$ROOT에는 시스템 레벨의 정보와 설정이 포함되고, PDB는 애플리케이션 및 데이터와 관련된 독립적인 정보를 가짐

그 외

[SYS] -> ROOT

- Oracle DB관리자로 Super user.

- Oracle 시스템의 기반이 되는 Data dictionary 소유자이며 DB생성과 삭제도 가능하다.

- Oracle 시스템의 총 관리자이며, SYSDBA 권한을 갖는다.

- Oracle 시스템을 유지, 관리, 생성하기 위한 모든 권한을 갖는 계정

[SYSTEM]

- SYS와 유사한 건한을 가지고 있지만 DB생성과 삭제는 불가능.

- 운영을 위한 권한을 갖는다. SYSOPER의 권한을 갖는다.

- 생성된 DB를 운영, 관리하기 위한 관리자 계정

[SYSDBA]

- SYSOPER의 권한 뿐 아니라 데이터베이스 생성과 삭제, Oracle 시스템에서 모든 권한을 갖는다.

- SYS계정이 갖는 권한.

[SYSOPER]

- 데이터베이스를 운영 관리하기 위한 권한으로 SYSTEM계정이 가짐.

- 아래 권한 외에 데이터베이스 자체를 생성 삭제하거나, 다른 유저 소유의 데이터에는 접근할 수 없다.

- 인스턴스와 데이터베이스에 대한 startup, mount, open, shutdown, dismount, close권한

데이터베이스 백업, 로그파일을 이용한 복구 등에 대한 database backup, archive log, recover 권한

Creating a New PDB from PDB$SEED

Using the FILE_NAME_CONVERT

SQL>

CREATE PLUGGABLE DATABASE pdb1

ADMIN USER admin1 IDENTIFIED BY p1 ROLES=(CONNECT)

FILE_NAME_CONVERT = ('PDB$SEEDdir','PDB1dir');

* 반드시 local user 하나 만들어야 함

create pluggable

admin1은 local user이다. 기본적으로 pdb_dba+connect role 지정함

seed로 local관리자를 만들면 pdb_dba로 role인데 비어있는 role임.

원래 role에 권한 다 넣어두면 쓸 수 있는데

현재 쓸 수 있는 role은 없는 상태임

현재는 오직 connection role 뿐임

/u01/app/PDB$SEEDdir/system.dbf

/u01/app/PDB$1dir/system.dbf

pdb 생성연습

Creating a New PDB from the PDB Seed

$ sqlplus / as sysdba

tnsnames.ora에 등록

Creating PDBs from Seed (5가지방법)

방법1. Create from Scratch

: pdb seed의 file을 copy

즉, Seed PDB에서 새로운 PDB를 복사하여 생성하는 방식

구성: PDB$SEED는 기본 템플릿 역할을 하며, 이 파일을 바탕으로 새 PDB가 생성됩니다. Seed PDB를 기반으로 새로운 데이터베이스를 복제하는 것입니다.
사용처: 기본적인 PDB가 필요하고, 기본 구조와 설정이 동일해야 할 때 사용됩니다.
과정: 새로운 PDB를 만들기 위해 CREATE PLUGGABLE DATABASE 명령어를 사용합니다. PDB는 Seed PDB를 기반으로 복사되고, 사용자 데이터를 추가하거나 수정할 수 있습니다.
예시 SQL:

sql

CREATE PLUGGABLE DATABASE new_pdb FROM PDB$SEED;
장점: 빠르고 효율적인 PDB 생성 방법.
단점: PDB 생성 후 초기 데이터베이스 구조가 기본값으로 설정되어 있어 추가 구성이 필요할 수 있음.

실습

방법 2. Cloning

: source pdb 또는 non-cdb를 복사해서 생성

즉, Cloning은 기존의 PDB나 Non-CDB를 복제하여 새로운 PDB를 만드는 방식

구성: 이미 존재하는 PDB 또는 Non-CDB 데이터베이스를 복사하여 새로운 PDB를 생성합니다. Non-CDB를 CDB로 변환할 수 있는 경우에도 사용됩니다.
사용처: 기존 데이터베이스의 복제본이 필요한 경우.
과정: CREATE PLUGGABLE DATABASE 명령을 사용하여 소스 PDB의 전체 데이터를 복사하여 새 PDB를 만듭니다. 소스 PDB의 메타데이터와 데이터가 그대로 복사되며, 클러스터 환경에서 유용하게 사용됩니다.
예시 SQL:

sql

CREATE PLUGGABLE DATABASE new_pdb FROM source_pdb;
장점: 기존 데이터베이스의 설정과 데이터를 그대로 복제하여 새로운 PDB를 빠르게 생성.
단점: 복제하는 소스의 크기와 데이터 양에 따라 시간이 오래 걸릴 수 있음.
실습

방법 3. Plugging In

: xml metadata file을 이용

방법 4. Relocation

: pdb를 다른 cdb로 이동 : 관련 file들을 move

방법 5. Referencing as a Proxy PDB

: db link를 이용하여 다른 pdb의 proxy pdb로 생성

[oracle] Oracle Net Services 오라클 네트워크 설정 (tnsnames.ora )

aonee — Tue, 17 Dec 2024 16:58:05 +0900

connection VS session

Connection:Communication between a user process and an instance

Session:Represents the state of a current user login to the database instance

Oracle Net Services

오라클 네트워크 사용하렴련

Oracle Net 설치해서 사용하면 됨

client

리스너 확인 목록

1. host

2. port

3. protocol

4. service name / SID / $ORACLE_HOME

name Resolution

로그인 정보 인증부터는

서버한테 맡기고 리스너는 더이상 신경쓰지 않아

서버는 user name 인증부터 확인해 (패스워드 맞는지 등등1)

리스너는 명령어 수행 시 뭐 해주는 거 없어

최초 request확인하고 user랑 연결해주는 것까지만 해줘

List the components of Oracle Net Services

1. Listeners

listener.ora

2. Naming methods

3. Naming (net service name)

tnsnames.ora (local configuration)

4. Profiles

sqlnet.ora

Configuring Naming Methods

Name Resolution

CONNECT jsmith/jspass@finflowers

finflowers =(DESCRIPTION= (ADDRESS=(PROTOCOL=tcp)(HOST=flowers-server)(PORT=1521)) (CONNECT_DATA= (SERVICE_NAME=finance.us.flowers.com)))

더 쉽게 연결하는 방법은? Easy Connect

SQL> connect hr/hr@db.us.oracle.com
db랑 dba11g가 같을 경우, 이렇게 간추릴 수도 있음

Local Naming

$ORACLE_HOME/network/admin/tnsnames.ora에 설정

Connection Options

1. Connect-time failover : 적힌 순서대로 될 때까지 listener에 접속 시도

(FAILOVER=on)

2. Load balancing : 랜덤하게 한 listener에만 접속 시도

(LOAD_BALANCE=on)

3. Source routing : client에서 server까지의 경로 나열

(SOURCE_ROUTE=on)

$ORACLE_HOME/network/admin/tnsnames.ora에 설정

FAILOVER , LOAD_BALANCE 둘다 작성하면 랜덤하게 될 때까지 시도해라

< 서비스 예시 >

db_name=orclcdb

service_names=edu, sales

정리

tnsnames.ora

클라이언트 측에 두는 파일.

로컬 네이밍 구성의 네트워크에서 사용됨

oracle finflowers 접속시

CONNECT jsmith/jspass@finflowers

tnsname.ora

finflowers =(DESCRIPTION= 
(ADDRESS=(PROTOCOL=tcp)(HOST=flowers-server)(PORT=1521))
 (CONNECT_DATA=
 (SERVICE_NAME=finance.us.flowers.com)))

listener.ora

서버 측에 두는 파일.

리스너는 클라이언트에서 DB 연결 요청을 받는 프로세스이다.

이 파일에서 리스너 설정함.

클라이언트에서의 연결은 모두 리스너가 받고 리스너가 어느 DB로 연결하면 좋을지 판단함.

연결할 DB를 리스터파일에 기술한다.

리스너는 listener.ora 파일 내에서 유일해야하며, 기본 리스너를 사용하면 해당 파일 없어도 됨.

[oracle] ASMM : 자동 공유 메모리 관리

aonee — Tue, 17 Dec 2024 15:51:35 +0900

ASMM : 자동 공유 메모리 관리

AMM란?

Automatic Memory Management의 약자로 자동메모리관리이다.

데이터베이스 서버가 작업 로드에 따라 SGA 및 PGA의 크기를 자동으로 조정할 수 있다.

특징

- 작업 로드 변경에 맞게 자동 조정

- 메모리 활용률 최대화

- 메모리 부족 오류 제거에 유용

SGA_TARGET = 1G (<= SGA_MAX_SIZE)

DB_CACHE_SIZE = 0

LARGE_POOL_SIZE = 0

SHARED_POOL_SIZE = 0

JAVA_POOL_SIZE = 0

STREAMS_POOL_SIZE = 0

[oracle] ADR : Automatic Diagnostic Repository

aonee — Tue, 17 Dec 2024 15:42:04 +0900

pwd 현재경로

/u01/app/oracle/diag/rdbms/orclcdb/orclcdb

sqlplus / as sysdba

Use ADRCI to View the Alert Log

$ cd

$ adrci

show alert

:q! 로 종료

1) alert log

- text file : trace/alert_orclcdb.log, xml

중요한 사건

STARTUP(non-default parameter), SHUTDOWN

recovery

log switch, TS create, alter, drop

- 중대한 에러

2) trace file 종류

종류1) bp 백그라운드 프로세서

trace /*dbwr*.trc

종류2) server 서버

trace / *.trc

sql 문장 튜닝에 필요한 파일 기록 (중대한 에러 기록 안함 )

SQL, Plan, 통계

사용방법 : SQL > alter session set sql_trace=true;

false or session out까지 튜닝에 필요한 정보 기록하도록 함

3) DDL LOG FILE (12c)

alter log <- user ddl X

text file : log/ddl_orclcdb.log

xml file : log/ddl/log.xml

adr 쪽에 계속 정보가 쌓이고 있는데

이거 디바이스 full나는거 아니냐

정기적으로 정리해줘야하는거 안이냐

이걸 oracle이 purge작업해줌

4. fixed table

fixed table은 shared pool 안에 메모리로 기록됨

physical read라는 테이블에 기록

shutdown하면 drop됨.

5. Data Dictionary Table

Oracle's Tables

[oracle] Database instance 관리 및 startup & shut down

aonee — Tue, 17 Dec 2024 12:25:36 +0900

1 .parameter file

2. sys인증

3. Instance Startup / Shupdown

4. PDB open / close

5. files

tables - view

Managing Database Instances

Initialization Parameters

인스턴스 파라미터 초기화 필요

이때, spfile 또는 pfile로 설정가능

Server parameter file (SPFILE)

- binary file

- SQL > alter system set open_cursors=500

scope = sfile;

memory

both (default option)

- $ORACLE_HOME/dbs/spfileorclcdb.ora

- spfile과 pfile 둘다 있으면 oracle은 spfile을 올림.

- Read and Wirte

spfile <-> pfile 변경 가능

SQL > create pfile from spfile;

create spfile from pfile;

Text initialization parameter file (PFILE)

- text file <- editor

- initorclcdb.ora

- $ORACLE_HOME/dbs/initorclcdb.ora

- startup 명령어 내리는 쪽에 위치함

- Read only

open_cursors=300'

SQL > alter system set open_cursors=500;

sql로 변경해도 set 파라미터파일은 변경안됨.

재부팅시에도 반영하고 싶으면 set파라미터파일에 설정 필요

SQL > startup pfile = /u01/app/initorclcdb.ora

지정해두면 pfile찾아갈 수 있음

* 오라클은 파라미터파일 어떻게 찾아가나?

1. SPFILE.ora, where SID is the system ID and identifies the instance name (for example, ORCL)

2. SPFILE.ora

3. init.ora (PFILE)

1->2->3 수행했는데 없으면 에러

파라미터 설정

Initialization parameters (parameters):

–Set database limits–Set database-wide defaults–Specify files and directories–Affect performance

Parameters can be of two types: basic or advanced.–Tune around 30 basic parameters to get reasonable database performance

.–Example of a basic parameter: SGA_TARGET–Example of an advanced parameter: DB_CACHE_SIZE

Derived parameters calculate their values from the values of other parameters.

–Example: SESSIONSis derived from PROCESSES.

Some parameter values or value ranges depend on the host operating system.

–Example: DB_BLOCK_SIZE

파라미터 확인

v$parameter : session parameter (로그인세션)

SQL > select name, value from v$parameter where name like '%control%';

여러개 값을 한줄로 다 보여줌

v$spparameter : spfile parameter

v$system_parameter : system parameter (시스템전체)

DB 인증

SYS는 DB인증으로 접근 불가

외부인증이 필요함

방법1. OS인증

- OSDBA로 지정된 OS user group에 속한 OS user로 로그인 해서 다음과 같이 로그인

SQL > show con_name

CDB&ROOT

시스템 접속

$ sqlplus / as sysdba

$ORACLE_HOME/rdbms/lib/config.c 에서 DB 생성시 지정한 OS user group 확인

- OS로 먼저 로그인이 가능한 환경에서 사용 OS 인증 방지

- $ORACLE_HOME/network/admin/sqlnet.ora 파일에 sqlnet.authentication_services=(none) 을 추가

- Root Container만 os인증 가능함

방법2. Password file 에 의한 인증

- $ORACLE_HOME/dbs/orapw 에 등록된 sys의 password를 이용해 다음과 같이 로그인

$ sqlplus sys/oracle_4U@orcl as sysdba

- orapwd 유틸리티를 이용해서 password file을 생성한다. $ orapwd file=$ORACLE_HOME/dbs/orapw password=oracle_4U

Starting Up and Shutting Down a Database Instance

Starting Up

database instance 옵션 미지정시

startup : shutdown > nomount > mount > open

만약, nomount skip 하려면 옵션 지정해줘야함

SQL > startup

Instance Started : open parameter file

Database Mounted : open control file

Database Opened : open datafiles, logfiles

그렇다면, 각 단계별 어떤 역할을 하는가?

- nomount

instance started : open parameter file

메모리 확보. 백그라운드 프로세스 띄우는 단계

SQL > startup nomount

SQL > alter database mount; alter database open ; /* 단계별 startup해야함. 한번에 open까지 못감*/

pdb X

- mount

control file opened for the instance

SQL > startup mount

SQL > alter database open ;

pdb <- mounted

- open

all files opened as described by the control file for the instance

open되어야지 user들이 접근 가능함.

root(open RW), seed(open RO), pdb(mounted)

✅ open했다해서 user 각 pdb까지 설정된 것은 아님

Root > alter pluggable database orclpdb1 open;

ROOT > alter pluggable database all open (read only); -- 전CDB 작업가능

ORCLPDB1 > alter pluggable database open ;

ORCLPDB1 > startup

startup은 shutdown상태에서만 가능한데, 강제로 시작시키려면?

SQL > startup force /* shutdown abort + startup */

강제로 정전시켰다 재시작시키는 것과 같음

close도 가능

ROOT > shutdown immediate

특정 pdb만 close해야하는경우?

ROOT > alter pluggable database all close (read only); -- 전CDB 작업가능

ORCLPDB1 > alter pluggable database close;

ORCLPDB1 > shutdown

✅ 매번 open close 직접 설정하기 싫으면? Automatically 설정

SQL > ALTER PLUGGABLE DATABASE pdb1 SAVE STATE;

Shutting Down

정상 shutdown 방법 3가지

checkpoint가 있음

방법1.

SQL > shutdown normal

1) wait : exit

2) new session X

3) checkpoint

4) close datafiles, logfiles

close control file

stop instance

방법2.

SQL > shutdown transactional

1) wait : commit, rollback

2) new session X

3) checkpoint

4) close datafiles, logfiles

close control file

stop instance

방법3.

SQL > shutdown immediate /* wait없음 /*

1) rollback

2) new session X

3) checkpoint

4) close datafiles, logfiles

close control file

stop instance

비정상 shutdown

flat & checkpoint없음. 이때 복구작업 필요함

SQL > shutdown abort

1) falt

2) new session X

3) stop instance

[oracle] create database

aonee — Tue, 17 Dec 2024 10:43:46 +0900

Creating a Container Database (CDB)

1. startup instance

2. create database

SQL > create database ...

한번에 생성

$ORACLE_HOME/rdbms/admin/ catcdb.sql

$ORACLE_HOME/rdbms/admin/catalog.sql

$ORACLE_HOME/rdbms/admin/ catproc.sql : 오라클 제공 패키지 생성스크립트

Creating a CDB by Using a SQL Command: Example

1. 인스턴스 시작

1-a) 인스턴스이름 설정

Set ORACLE_SID=CDB1

1-b) 파라미터 설정

– CONTROL_FILES to CDB control file names

– DB_NAME to a CDB name

– ENABLE_PLUGGABLE_DATABASE to TR

2. DB 생성

 SQL> 
 CREATE DATABASE cdb1  
 
USER SYS IDENTIFIED BY p1 USER SYSTEM IDENTIFIED BY p2 /*패스워드 설정 */

 LOGFILE GROUP 1 ('/u01/app/oradata/CDB1/redo1a.log', /* 로그파일 2개 생성 */
 '/u02/app/oradata/CDB1/redo1b.log') SIZE 100M,
 GROUP 2 ('/u01/app/oradata/CDB1/redo2a.log',
 '/u02/app/oradata/CDB1/redo2b.log') SIZE 100M 
 
CHARACTER SET AL32UTF8 NATIONAL CHARACTER SET AL16UTF16  

EXTENT MANAGEMENT LOCAL DATAFILE    /* ORACLE DATAFILE 만들 때 만드시 필요 */
'/u01/app/oradata/CDB1/system01.dbf' SIZE 325M 
SYSAUX DATAFILE  '/u01/app/oradata/CDB1/sysaux01.dbf' SIZE 325M 
DEFAULT TEMPORARY TABLESPACE tempts1 
TEMPFILE '/u01/app/oradata/CDB1/temp01.dbf' SIZE 20M 
UNDO TABLESPACE undotbs 
DATAFILE '/u01/app/oradata/CDB1/undotbs01.dbf' SIZE 200M

 ENABLE PLUGGABLE DATABASE /* CDB아키텍처 만들기 위해 꼭 필요 */
SEED FILE_NAME_CONVERT =('/u01/app/oradata/CDB1','/u01/app/oradata/CDB1/seed');
/* SEED는 SEED경로(/u01/app/oradata/CDB1/seed) 위치 지정
해당 옵션은 선택임. 옵션지정 말고 파라미터 OMF에 지정하면 ORACLE이 알아서 SEED생성 및 삭제 자동 관리해줌*/

3. Execute the $ORACLE_HOME/rdbms/admin/catcdb.sqlSQL script

$ORACLE_HOME/rdbms/admin/ catcdb.sql

[Oracle DB] Multitenant Container Database

aonee — Mon, 16 Dec 2024 16:59:42 +0900

Multitenant Container Database

Non-CDB Architecture

각 Instance로 구성

CDB Architecture

Control files, Redo log Files는 공동사용

DataFile은 각각 사용

장점

1) 비용절감 : S/W, Storage, 관리인원

2) 쉽고 간단한 데이터 이동 : PDB plug in/out

3) 자원관리 : PDB별로 resource 제한 지정

4) PDB 는 논리적으로 독립성을 지님 물리적으로는 모든 PDB들이 하나의 DB임(CDB)

5) 관리자 독립 : CDB, PDB

6) 성능 튜닝이 쉬움 : instance가 하나이므로 통합 모니터링이 가능

7) 쉬운 patch & upgrade : 한번에 CDB 레벨로 가능

Container(= datafiles 그룹)종류

1) Root Container

- CDB$ROOT

- con_id=1
- Oracle 전용의 metadata + Common User 정보
- 모든 PDB들이 공유 : DB 생성시 자동으로 만들어짐

2) Template - Seed Container

-   PDB$SEED
-   con_id=2
-   READ ONLY 모드로 PDB 생성에 사용되는 template
-   DB 생성시 자동으로 만들어짐

3) User data - Pluggable DB

PDB 논리적 독립성.

Sharding

- DB 어느것도 공유하지 않음. 독립적 서버.

- 장애전파되지 않는 점이 장점임

- 최대 1000개까지도 묶어서 사용할 수 있음

- shard catalog : sharded Databse, shard관리함

EM

1. DB Express

- 1개 DB

port 5500 통해서, omr에 저장해두고 사용

OMR : Oracle Management Repository

2) Cloud Control

OMS, OMR설치.

OMR에는 target파일이 쫙 준비됨

orcl DB에 OMA는 dbsnmp계정으로 접근

OMS : Oracle Management service

OMR : Oracle Management Repository

OMA : Oracle Management Agent

oralce에서 사용하는

roc환경에서 db구축해야한다면

공유할 수 있는 storage준비해야함

그렇게 결정된 storage얼마나 확보하느냐?

Database Configuration Assistant
(DBCA)

1. Database Template

2. character Set

character Set & national char set (해외타입에 맞춰 결정해야하는 경우)

unicode체계 권장

NLS_LANG

1) 내 클라이언트에서 사용하는 코드체계

ex) NLS_LANG=AL32UTF8

Server는 Client가 설정한 NLS_LANG=AL32UTF8를 보고 그 코드값에 맞출 수 있도록 준비함

1. super set권장

2. NLS_LANG에 설정

DB삭제 시, DBCA 통해 삭제하는 것이 가장 깔끔함

생성 시,

1. DB이름 지정

db_name=orclcdb

db_domain=us.oracle.com

2. Instance이름 지정

ORACLE_SID=orclcdb

global DB name

orcl.

[인스턴스이름].[도메인]

Create as Container Database

auto container ... 설정

DB 유형

OLTP

...

create a new listener

...

=> 복잡하면 silent mode로 한번에 설정 가능

[Oracle DB] Oracle Database 기본구조

aonee — Mon, 16 Dec 2024 15:27:32 +0900

* Oracle DB Server는 Instance와 Database로 구성된다.

* Instance는 하나의 DB와 연관이 되는데, memory, background processes로 구성된다.

Instance start를 해야 SGA영역이 생성된다

* Database는 3개의 파일로 구성된다.

1) Datafiles : user data(table, index) 저장

2) Logfiles : 복구에 사용되는 Log 저장

3) Controlfiles: dbid, datafiles list, logfiles list, 동기화 정보

SGA (System Global Area)

* 필수 구성요소는 3가지 이다

1) Shared Pool

2) Database Buffer Cache

3) Redo Log Buffer

Instance Start할 때, SGA가 생성된다.

Instance Shut down 시, SGA가 사라진다.

서버프로세스는 로그인, 로그아웃시 시작 종료된다.

인스턴스 시작종료와 무관함.

얘가 명령어 다 처리한다.

또한, 모든 서버가 SGA를 공유하여 사용한다.

각 서버가 사용하는 영역은 PGA임.

Shared Pool

Shared Pool 이란?

shared SQL Area를 사용해서 소프트 파싱이 가능하도록 함.

반복 수행 빠르게 처리 가능.

이것이 바로 shared pool의 목적임

p-code

Exec Plan

SQL

특징

1. 공유 SQL 영역

2. 라이브러리캐시

3. 데이터 딕셔너리 캐시

* 데이터 딕셔너리 캐시

Data Dictionary : 전db의 정보 다 기록한다

user_tables

all_tables

dba_tables

oracle table은 DB buffer cache가 아닌, shared pool의 Dictionary cache영역에 저장된다

row 단위로 cache를 저장한다

4. 서버 결과 캐시

result cache는 결과를 저장해두고 그 결과 그대로 user에게 제공한다.

사용하려면 hint를 주면됨. ex) /* + result-cache */

Database Buffer Cache (DB_CACHE_SIZE)

Database Buffer Cache 란?

Physical Read 감소시키고 여러 서버가 Logical Read로 바로 사용가능하도록. 버퍼 공유하도록 하는 것이 버퍼캐시의 목적임.

일반적으로 쿼리를 수행하면, Data File에서 Physical Read하여 결과를 Database Buffer Cache로 불러옴

이를 서버프로세스(=유저)에게 Logical Read하여 결과값을 보여줌.

Physical Read한 결과를 버퍼캐시에 저장해두었으니, 해당 조회결과를 다시 조회해야할 때, Physical Read를 다시 하지 않고 Logical Read로 바로 읽을 수 있음.

특징

* Buffer 상태

1) Free : Empty

2) Pinned : 수행중인 명령어가 이용하는 중

3) Clean : Buffer와 File의 내용이 동일

4) Dirty : 명령이 수행된 결과 buffer의 내용과 File의 내용이 다름

* LRU List : Buffer Header List 양끝이 MRU, LRU로 관리됨

즉, fifo가 아닌, 최근 안쓴 것 제거 방식.

- Checkpoint Queue : 변경된 순서대로 dirty buffer의 list가 관리됨

Redo Log Buffer (LOG_BUFFER)

특징

변경(DML, DDL)시 바뀌게 될 값을 기록 - 순환적, 순차적으로 Server Process가 기록

Large Pool (LARGE_POOL_SIZE)

특징

Shared Server UGA I/O 서버 프로세스 데이터베이스 백업 및 복원 작업시

In-Memory Area

Memoptimize Pool

Memoptimize Pool이란?

Hash Index + Buffers로 구성됨.

- 버퍼캐시와 동일하지만, aging out이 없음. 메모리에 계속 keeping해둠.

즉, In-memory hash index 를 이용하여 빠른 key lookup을 제공

그렇기때문에 조회 빠름

- 사용방법

MEMOPTIMIZE_POOL_SIZE

테이블 레벨에서 설정이 필요함.

단, 반드시 PK가 반드시 있어야함

PGA(Program Global Area)

PGA란?

서버 각각 각자 사용하는 영역.

user가 session 생성하면서 PGA가 생성됨

명령어 받자마자 cursor stack영역에 private SQL area 생성함. 이를, 해당 영역을 포인트로 잡고 있어서 이를, cursor 라고함.

이후, SGA의 shared SQL area에 해당 정보가 있으면 가져다 써.

aging되지 않도록 shared SQL area에 포인터로 잡아둬. 이를, shared cursor 라고 함.

구성

1. Stack Space : 서버 프로세스 정보

2. Session Memory : 세션정보

3. Cursor Stack : 서버가 활동 안하면, 비어있다가, user명령어 받자마자 parse단계 이전에, private SQL area 생성.

4. SQL Work Area : 해당 영역에서 sorting 작업 이루어짐. 줄세우기!! sorting하려는데 영역 부족하면? 쪼개서 tempfile에 임시중간결과 저장해두며 sorting함.

* UGA

Session + Cursor + SQL work Area로 구성됨

Background Processes

1. Database Writer Process(DBWn)

특징

- server 가 변경한 dirty buffer 를 datafile 에 기록

- db_writer_processes : 100 까지 지정가능(CPU 숫자에 따라)

- Checkpoint : DBWn가 dirty buffer를 datafile에 기록하는 작업

Checkpoint 누가한다고요?

DBWR : 메인

LGWR : 조연

CKPT : 스텝정도..

Checkpoint 발생시기

1) DB정상종료시

shutdown시, DB Buffer Cache에서 dirty버퍼 빨리 DataFile로 내려ㅡㅡ!!

내리기 전에, DBWR가 Log먼저 확인함. LGWR이 Redo Log File에 내린 거 확인 후, DBWR이 Datafile로 내린다.

이후 접속시, 모든 데이터 파일의 SCN을 확인해서 CKPT, DBWR, LGWR 모두 정상적으로 동기화됐구나 확인함.

2) Log Swtich시

Redo Log File은 1개로 사용하면 안됨. 꼭 2개 두고 사용해야함.

첫번째 로그파일 꽉 차서 두번째 로그파일로 넘어갈때

Checkpoint가 발생됨.

Drity Buffer가 미처 못 내려갔는데, 복구해야하면?

Redo Log File이 필요하다.

그런데, Buffer에서 Data File에 안전하게 내려가있는 상태면?

Redo Log File 필요 없어. Dirty버퍼 내리면 됨!

3) 90% of the size of the smallest redo log file

Incremental CheckPoint

900초 분량의 recovery 공간만 남ㄴ겨두고 분량 조절함.

fast_start_io_target

Log Writer Process(LGWR)

혼자 일할 때, 병목현상 잦아짐.

로그파일 꽉 찼는데, DBWR이 너무 느려서 DataFile로 아직 못 내렸어.

근데 계속 작업을 수행하면 log 쌓여야하는데

로그파일 용량이 꽉 찼는데 복구하려면 다 저장해둬야하는데 아직 백업못한 정보들 있으니까 지우지도 못하고 멈춰있는거지..

로그가 제때 안 내려오면 시스템 멈춤 발생함

기록시점

1) commit 명령수행

2) log buffer가 1/3이상 or 1M 채워졌을 때

3) DBWR의 시그널에 의해

4) 3초간격

Checkpoint Process(CKPT)

System Monitor Process(SMON) startup > Instance Stated >

1. Instance Recovery수행함

이때, RedoLogFile이 필요함

Rolling Forward : 가장 오래된 거 부터 순서대로 로그정보 재연.

2. Temporary segment 처리

Process Monitor(PMON)

갑자기 user process 정상 logout 못하고 사라진 상황이 발생하면?

1. Lock 걸림. 배타Lock

2. 리소스문제 발생

명령 내리는 user는 사라졌는데, process와 SGA는 잡고있음.

불필요하게 리소스 잡고 있음.

-> PMON이 해당 문제를 해결함

Transaction rollback해서 Lock 해결

PGA deallocate 뺏고 좀비상태로 만듦. kill해서 죽이면 됨.

Listener Registration Process(LREG)

LREG ?

Listener 에게 DB instance, dispatcher 의 정보를 정기적으로 알려줌

Recover Process(RECO)

- 분산 DB 환경에서 원격DB쪽의 중단된 transaction 작업을 cleanup

즉, 분산 Trasaction의 중단된 작업 Rollback

- A DB에서 B DB로 접근하기 위한 링크

인프런 AWS 입문자를 위한 강의-Lambda, CloudFront, DynamoDB, API Gateway, Code Commit, Code Deploy, Code pipeline (22.06.01)

aonee — Wed, 1 Jun 2022 16:59:50 +0900

# Lambda

- Serverless의 주축을 담당 (sever+less, 클라우드가 직접 자동으로 서버를 생성하고 자원 관리)

- Events를 통하여 Lambda를 실행시킴

- nodejs, python, java, go등 다양한 언어 지원

- Lambda Function (람다에서 짠 코드)

#Lambda비용

- Lambda Function이 실행될 때만 지불

- 매달 1,000,000 함수 호출시 무료 (그 이후는 유료)

#Lambda특징

- 최대 300초(5분) 런타임 시간 허용(대용량데이터 처리시 종종 타임아웃. 람다함수 5분이상 돌라갈 경우임.)

- 최대 512MB의 일시적인 디스크 공간 제공(/tmp)

- 최대 5MB Deployment Package허용. AWS콘솔에서 직접 코딩을 짤 수 있지만, Local에서 다수의 파일을 하나의 압축파일을 업로드하여 Deployment를 통하여 사용할 수 있다.

- 50MB초과시 S3버킷에 저장 후 Lambda에서 파일에 대한

#사용사례

사례1. S3 -> Lambda -> DB

1) S3에 파일 upload하려하면 PutObject 이벤트가 발생됨. 이 이벤트는 람다함수 실행시킴

2) Lambda : 데이터를 읽어보고 데이터 변환. 불필요한 데이터 삭제. 깨끗한 데이터 올림. 다리 역할

3) DB

사례2. IOT -> Lambda -> SNS

1) IOT : ex) 자동차 주행 데이터가 들어오는 경우. 갑자기 과속을 하여 예상치 못한 속도 측정되면 Topic으로 데이터를 보냄. 동시에 Lambda 호출함.

2) Lambda : km를 ㅡ> 미국 주행단위인 mileage로 변경해줄 수 있음.

3) SNS

# Lambda실습

- AWS Lambda 대시보드 : 함수개수, 코드 스토리지, 전체 계정 동시성, 예약되지 않은 계정 동시성(Concurrency)

- AWS Lambda 대시보드>함수생성>테스트 : 실행결과에 대한 상세 Log정보를 알 수 있음.

#Lambda 실습

상황1. S3버킷에 PutObject 발생시, Lambda함수 실행시켜라

1) Temperature.json 데이터 'S3'로 실시간 업로드된다.(PutObject)

2) Lambda함수 실행: 특정 온도 넘으면 그 온도가 언제 측정됐는지 주의하라는 메시지를 출력 반대의 경우 출력X.

#CloudFront

- 특정사용자가 요청하였을 때, Edge Location을 사용하여 정적, 동적, 실시간 웹사이트 컨텐츠를 유저들에게 전달

- 컨텐츠 딜리버리 네트워크 CDN(Content Delivery Network)

- 분산 네트워크 (Distributed Network)

- 웹페이지가 현재 어디에서 불려지는지, 해당 웹 페이지에 접속한 사용자가 어느 지역에 위치하는지 근거하여 Content에 Delivery 해줌.

- 우리가 특정 홈페이지를 방문하면 홈페이지 내용이 불려짐. CDN을 통해 html, js, 이미지파일 등 가져오는 속도 비약적으로 상승시킬 수 있음

- 상세예시

Origin : 한국에서 현재 웹사이트를 호스팅하고 있다.

다른 나라에서 홈페이지 컨텐츠 열리는 속도 latency발생. 웹사이트 호스팅 주소와 멀어질수록 더 느려짐.

중국보다 미국이 훨씬 느림. 지연시간 각각 다름.

전세계 유저들이 접근하려함. 콘텐츠를 한국에서 직접 전달하는 것이 아니라 Edge Location을 통해 콘텐츠를 제공한다. ex) 은행(Origin) 직접 가지 않고 ATM(Edge Location)방문.

- Edge Location은 콘텐츠 정보를 캐시에 저장함. 처음 웹사이트 접속시 캐시에 정보가 없다면, Edge Location과 Origin(웹사이트 호스팅) 대화를 주고 받은 후, 그 정보를 Edge Location 캐시에 넣고 유저들에게 콘텐츠를 뿌림.

즉, 콘텐츠들은 EdgeLocation의 캐시에 들어있기 때문에 Latency 현저히 줄읆. 단, 캐시는 영구적이지 않다.

# CloudFront 용어정리

- Edge Location : 콘텐츠들이 캐시(Cache)에 보관되어지는 장소

- Origin : 원본 콘텐츠들이 들어있는 곳. 웹서버 호스팅이 되어지는 곳. S3, EC2인스턴스가 오리진이 될 수 있음

- Distribution(분산) : CDN에서 사용되어지며 전세계에 있는 Edge Location들을 하나로 묶어 통칭하는 것.

#CloudFront 실습

1. S3버킷 만들기 (모든 퍼블릭 액세스 차단 체크풀기:전세계에서 access가능한 public access를 만들것이기 때문)

2. S3버킷에서 파일 올리기. (퍼블릭 권한관리 : 퍼블릭 읽기 액세스 권한 부여함)

3. CloudFront>create Distribute>web get started>

- origin domain name : 생성한s3버킷 선택

- Restrict Bucket Acess : yes

- Origin Access Identity: create a new Identity

- Grant Read Permisions on Bucket : yes

- Default Cache Behavior Settings : Redirect HTTP to HTTPS / Get, Head/ use a cache policy / Restrict Viewer Access(승인받은 유저만 사용 가능.) : no, Distribution Settings price class (얼마나 많은 Edge Location사용할래?) / Alternate Domain Name(DNS) / SSL Certificate : Default / HTTP versions : HTTP/2, HTTP/1.1, HTTP/1.0 > create

#DynamoDB

- NOSQL (Not Only SQL) 데이터베이스

- 매우 빠른 쿼리 속도

- Auto-Scaling 기능 탑재.(처음 DB만들면 크기가 정해지는데, 어느정도 데이터 추가되면 알아서 크기 늘리고 사용안하면 줄여줌)

- key-value 데이터 모델 지원

- 테이블 생성시 스키마 생성 필요 없음

- 모바일, 웹, IOT데이터 사용시 추천됨

- SSD 스토리지 사용(읽고 쓰는 속도 매우 빠름)

#DynamoDB구성

- 테이블(Table)

- 아이템 (Items) : 행과 개념이 비슷함

- 특징(Attributes)-열(column)과 개념이 비슷함

- key-value (key: age, value:78) ex) json, xml

#DynamoDB PK(Primary Keys)

- PK를 사용하여 데이터 쿼리

- 2가지 PK 유형이 있음

유형1) 파티션키 (Partition Key)

- 파티션키:cust_id -> 해시함수(cust_id의 value) -> 94C -> 94C에 저장됨

- 고유 특징 (Unique Attribute)

- 실제 데이터가 들어가는 위치를 결정해줌

- 파티션키 사용시 동일한 두개의 데이터가 같은 위치에 저장될 수 없음!

유형2) 복합키

- 파티션키 + 정렬키

- 예시) 똑같은 고객이 다른 날짜에 다른 물건을 구매.

- 파티션키 : 고객아이디, 정렬키: 날짜

- 같은 파티션키의 데이터들은 같은 장소에 보간, 그 다음 정렬키에 의해 데이터가 정렬됨.

#DynamoDB데이터 접근관리

- AWS IAM으로 관리할 수 있음

- 테이블 생성과 접근권한 부여가능

- 특정 테이블만, 특정 데이터만 접근 가능케해주는 특별한 IAM역할 존재

# DynamoDB Index

- 특정 컬럼만을 사용하여 쿼리

- 테이블 전체가 아닌 기준점(pivot)을 사용해 쿼리가 이루어짐

- 매우 큰 쿼리 성능 효과

- 2가지 Index 유형

1) Local Secondary Index

2) Global Secondary Index

# Local Secondary Index(LSI)

- 테이블 생성시에만 정의해줄 수 있음

- 테이블 생성 후 변경, 삭제가 불가능

- 똑같은 파티션키 사용, 그러나 다른 정렬키 사용. ex) 테이블 -> 파티션키 동일 뷰(x) 정렬키:2019, 뷰(x) 정렬키: 2020

# Global Secondary Index(GSI)

- 테이블 생성 후에도 추가, 변경, 삭제 가능

- 다른 파티션키, 정렬키 사용

- ex) 테이블 파티션키:고객아이디 -> 뷰(x) 파티션키:카테고리 정렬키:구매날짜 , 뷰(x) 파티션키:브랜드 정렬키:구매날짜

# DynamoDB Query vs Scan

- Query

- Primary Key를 사용하여 데이터 검색

- Query 사용시 모든 데이터(컬럼) 반환

- ProjectionExpression 파라미터 : 원하는 컬럼만 가져올 수 있음

- Scan

- 모든 데이터를 불러옴 (primary key 사용x)

- ProjectionExpression 파라미터

=> Query가 Scan보다 훨씬 효율적.

# DynamoDB DAX

- DAX? DynamoDB Accelerator

- 클러스터 In-memory 캐시 (인메모리? SSD, 하드디스크가 아닌 캐시로 속도 향상)

- 10배 이상의 속도 향상 > 읽기 요청만! (쓰기요청X)

- ex) Black Friday날 쇼핑 웹사이트 운영(수많은 읽기 요청 예상)

- 원리

- DAX 캐싱 시스템 : 테이블에 데이터 삽입 & 업데이트시 DAX에도 반영

- 읽기 요청에 맞는 데이터가 DAX에 들어있을 시, DAX에서 데이터 즉시 반환 (Cache Hit) <-> (Cache Miss)

- 단점

- 쓰기 요청이 많은 애플리케이션에는 부절절함

- 읽기 요청이 많지 않은 애플리케이션에는 부절절함

- 아직 모든 지역에서 제공되는 서비스는 아님.

# DynamoDB Stream

- DynamoDB 테이블에서 일어나는 일들 (삽입, 수정, 삭제 등)이 일어날 시, 시간적 순서에 맞게 Streams 에 기록

- Log는 즉각 암호화가 일어나며 24시간 동안 보관됨

- 주로 이벤트를 기록하고 이벤트 발생을 외부로 알리는 용도(ex) Lambda Function)

- 이벤트 전&후에 대한 상황 보관

- ex) DynamoDB Streams <- Lambda Function -> SNS(Simple Notification Service) -> SQS (Simple Queue Service) <-> application

#API

특정물건 장바구니에 담는 것을 요청. 중간에서 복잡한 일 처리해줌. 요청받고 요청 해결해줌.

#Restful API?

- API 종류들 중 하나

- REpresentational State Transfer : 상태에 변화를 주기 위해 그 정보를 server와 client간에 공유하고 주고 받기 위해 사용하는 것.

- CREATE(post), READ(get), UPDATE(put), DELETE(delete)

- JSON형태로 요청을 받고 해결함.

#관리가 힘든 RESTful API

- Authentication & Authorization : 회원/비회원/등급별 혜택 달리, 보이는 페이지 달리

- API요청을 모니터링 해야함 : 재고가 5개인데 10개를 주문하려는 경우 경고창 제공 등. 모니터링

- 더 나은 성능을 위해 API요청 캐시 시스템 필요. : 사람이 일일이 처리하기 어려움.

#API Gateway

- 뛰어난 확장성 제공 및 API를 만들고 운영하는 모니터링 가능

- 모니터링은 CloudWatch를 통해 확인가능

- 웨이터의 역할.

- Back-end 서비스 (웹 애플리케이션, EC2)에 들어있는 데이터 접근 허용

- Pay As You Go. API를 호출할 때. 얼마나 오래 걸리는지. 얼마나 많은 데이터를 처리하는지에 따라 금액 달라짐.

#API Gateway실습

customers -> api gateway -> lambda function -> DynamoDB

# CI/CD

- CI : Continuous Integration 지속적인 통합

내 개발코드 중앙레파지토리에 올리고 테스트하여 다른 개발자와의 코드 충돌을 막아줌. 나는 내 것에만 최선을 다하면 된다.

- CD : Continuous Deployment 지속적인 배포

개발자는 지속적으로 서비스 수정 및 배포. 사용자가 사용시 전혀 불편함 못 느끼도록 서버다운, 프로그램 일시 중지 막아줌.

# CI/CD의 장점

- 자동화 시스템 (Automation) - 테스트

- Incremental Change

ex) 가격에 대한 정보가 안보일 경우, 이를 수정하기 위해 관련 기능들 먼저 수정하고 최종적으로 가격 보이도록 수정.

내가 작성한 프로그램이 오류날 경우 다시 돌아가고 싶은데 매번 백업 귀찮고, 매번 테스트도 귀찮음.

# CI/CD - 중앙 리포지토리 (Repository)

- Github

#Code Comit

- 다양한 파일들(코드, 사진, 라이브러리, 등등)을 보관하는 저장소 (Repository) - Github와 매우 유사

- 동시에 많은 사람들이 저장 장소 접근 및 업데이트 가능

- 버전 컨트롤 기능 제공 ex) 언제 어떻게 누가 저장 내용을 변경하였는지

# Code Deploy

- Automated Deployment. 자동 배포

- 장점

1) 새로운 기능들의 빠른 배포

2) 소프트웨어 & 서버 다운타임 X

3) Maual 에러 X

- 2가지 배포방법

1) Rolling 배포

현재 production에서 돌아가는 서버. 새기능25% 새로운 서버로

2) Blue/Green 배포

Blue완전히 shut down, Green을 100% 활성화

# Code Pipeline

- 하는 일?

1) 빌드, 테스트, 배포 과정을 관리 : 코드 변경시 Code Pipeline은 이를 감지할 수 있음

2) 소프트웨어 및 애플리케이션 출시 자동화 가능 : 빠르고 쉬운 디버깅을 가능케 해줌. 배포(Deployment) VS 출시(Release)

- 작동방법?

- Workflow 정의 (Code pipeline) -> 코드 저장소에서 코드 변경 (Code Commit) -> 컴파일, 테스트, 패키지 생성(Code Build) -> staging or prodcution 배포 (Code Deploy)

인프런 AWS 입문자를 위한 강의-IAM, EC2, EBS, ELB, Route53, RDS, S3, CloudWatch (22.05.31)

aonee — Tue, 31 May 2022 18:46:41 +0900

#AWS

Amazon Web Service

클라우드 컴퓨팅

서버리스(원격에서 서버를 작동시키고 관리하며 메모리활동 지원 스스로 관리) 기능 지원.

#IAM

Identity and Access Management

유저를 관리하고 접근 레벨 및 권한에 대한 관리

- 회원가입시 root 권한을 얻는다

- 그 외 다른 사용자가 접근할 수 있도록 접근키, 비밀키를 생성할 수 있다.

- 매우 세밀한 접근 권한 부여 기능. ex) 직원의 권한에 맞는 수준으로만 권한 제공

- 비밀번호를 수시로 변경 가능케 해줌

- multi-Factor Authentication(다중인증)기능

-정책은 그룹, 역할에 추가시킬 수 있다. 하나의 그룹 안에 다수의 유저가 존재 가능하다. 1)그룹 2)유저 3)역할 4)정책

- Universal함 (지역 설정 필요 없음)

#IAM정책시뮬레이터

1. 개발환경(Staging or Develop)에서 실제환경(Production)으로 빌드하기 전 IAM정책이 잘 작동되는지 테스트하기 위함

2. IAM과 관련된 문제들을 디버깅하기에 최적화된 툴 (이미 실제로 유저에 부여된 다양한 정책들도 테스트 가능)

ex) 정책시뮬레이터 대시보드> 정책시뮬레이터 dynamodb select action permission run simulation 사용자

dynamodb read only access 사용자 권한 추가 permission

#IAM

실습

사용자 추가

사용자이름

프로그래밍 방식 액세스

AWS Management Console 액세스

액세스키ID, 비밀 엑세스키

#EC2

Elastic Compute Cloud. 유연하게 컴퓨팅클라우드 크기를 조절할 수 있다

#EC2지불방법

1. on-demand

- 시간 단위로 가격이 고정되어 있음

- 오랜시간동안 선불로 내지 않고 최소한의 비용을 지불하여 EC2인스턴스를 사용하고 싶을 때

- 특히, 앱/프로그램 개발시 최초로 EC2인스턴스에 Deploy할 때 유용

2. Reseved

- 한정된 EC2 용량 사용 가능, 1-3년 동안 시간별로 할인 적용 받을 수 있음

- 안정된, 예상 가능한 workload시 권장

- 선불로 인한 컴퓨팅 비용 대폭 감소

3. Spot

- 입찰 가격 적용. 가장 큰 할인율을 적용받으며 특히 인스턴스의 시작과 끝기간이 전혀 중요하지 않을 때 유용

- 단순히 비용 절감 시 유용함. 인스턴스의 시작/끝시점에 구애받지 않을 경우 권장

#EBS

- Elastic Block Storage

- EC2를 사용하기 위해 EBS라는 디스크 볼륨을 요구한다. 일종의 하드디스크.

- 저장공간이 생성되어지며 EC2 인스턴스에 부착된다.

- 디스크 볼륨 위에 File System이 생성된다

- EBS는 특정 Availability Zone에 생성된다.

#Availability Zone(AZ)

- 하나의 Regoin안에 여러개의 AZ가 존재할 수 있다.

- 중심으로부터 복사본이 AZ로 뿌려지며, 한쪽 서버가 망가지면 AZ백업을 통해 서비스 제공을 가능케해준다. 일종의 Disaster Recovery.

#EBS볼륨타입

<<SSD군>>

1) General Purpose SSD (GP2) : 최대 10K IOPS를 지원하며 1GB당 3IOPS속도가 나옴

2) Provisioned IOPS SSD (IO1) : 극도의 I/O률을 요구하는 (ex 매우 큰 DB관리) 환경에서 주로 사용됨. 10K이상의 IOPS를 지원함.

<<Magnetic/HDD군>>

3) Throughput Optimized HDD (ST1) : 빅데이터 Datawarehouse, Log프로세싱시 주로 사용 (boot volume으로 사용x)

4) CDD HDD (SC1) : 파일서버와 같이 드문 volume접슨시 주로 사용, 역시 boot volume으로 사용 불가능하나 비용은 매우 저렴함

5) Magnetic (Standard) : 디스크 1GB당 가장 싼 비용을 자랑함. Boot volume으로 유일하게 가능함

#ELB

- Elastic load Balancers

- 수많은 서버의 흐름을 균형있게 흘려보내는데 중추적인 역할을 함

- 하나의 서버로 traffic이 몰리는 병목현상(bottleneck) 방지

- Traffic의 흐름을 Unhealthy instance -> healthy instance로 바꿔줌

#어떤 ELB타입이 적절하게 사용되어져야하나?

1. Application Load Balancer : OSI Layer7에서 작동됨.

- HTTP, HTTPS와 같은 traffic의 load balancing에 가장 적합함

- 고급 request 라우팅 설정을 통하여 특정 서버((루트변경 가능))로 request를 보낼 수 있음

2. network : OSI layer4에서 작동됨. 매우 빠른 속도를 자랑하며 production환경에서 종종 쓰임

- 극도의 performance가 요구되는 TCP traffic에서 적합함

- 초당 수백만개의 request를 아주 미세한 delay로 처리 가능

3. Classic Laod Balanacer : 현재 Legacy로 간주됨. 따라서 거의 쓰이지 않음. 시험에 가장 많이 등장

- Layer7의 Http/Https 라우팅 기능 지원

- Layer4의 TCP traffic 라우팅 기능 지원

#LoadBalancerError

- 504erorr : 어플리케이션이나 서버가 응답을 받지 못하는 경우 나타는 현상

=> 웹서버layer, 데이터베이스layer에서 문제해결 가능

#x-forwarded-for헤더

152.12.3.225(public IP address) -DNS-> ELB 10.0.0.23(private IP address) -> EC2 10.0.0.23

- EC2는 private IP address 밖에 모른다.

- public IP address를 알려면 x-forwarded-for 헤더를 이용해서 알아낼 수 있다.

#Route53

- AWS에서 제공하는 DNS서비스

- 일상에서 종종 사용하는 서버에 이름 부여. 즉, 도메인 주소 구매하여 3가지(EC2 instance, S3 Bucket, Load Balancer) 백엔드로 연결시켜주는 것

- 호스팅 영역 생성

#EC2실습

-putty : ssh를 사용하여 원격 서버에 접속할 수 있도록 해줌

-실습 순서

1) putty다운로드. putty.exe puttygen.exe(pem파일을ppk파일로 변환해줌) 두개파일 설치

2) EC2인스턴스시작. > AMI선택 > 인스턴스유형선택(t2micro) >인스턴스 구성>스토리지추가>태그추가>보안그룹구성(ssh, https)> 검토, 새 키페어 생성하면 pem파일이 다운됨. > 인스턴스 시작을 누르면 pending에서 start상태가 됨.

3) puttygen에서 pem파일>ppk로 변환

4) hostname(ec2-user@awsIpv4퍼블릭IP), port22 + ssh>auth에서 ppk등록> session 저장

sudu su #슈퍼유저
yum update -y #운영체제 업데이트. 관련 패키지 모두 설치해줌.
yum install httpd -y # 아파치 설치. 아파치를 사용하여 인스턴스를 실제 웹서비스처럼 사용할 수 있게 해줌
service httpd start
chkconfig httpd on
cd /var/www/html
ls
vi index.html
<html>
<body><h1>웹페이지</h1></body>
</html>

#RDS

- Relational DB Service 관계형 데이터베이스 (데이터베이스, 테이블, 데이터, 필드)

#DataWarehousing

- Business Intellignece

- 리포트 작성, 데이터분석시 사용 (Production Database -> Data warehousing)

- 매우 방대한 분량의 데이터 로드시 사용

#OLTP vs OLAP ★

- OLTP : Transaction. INSERT와 같이 종종 사용되어지는, 혹은 규모가 작은 데이터를 불러올때 사용되는 SQL 쿼리가 필요할때 유용

ex) Order # 210에만 해당되는 Customer 이름, 주소, 시간 정보 insert

- OLAP : Analytical. 매우 큰 데이터를 불러올때 사용. 주로 덩치가 큰 select 쿼리가 사용됨

ex) 특정 회사 부서의 Net profit, Products

#RDS-Backup

1. Automated Backups(AB) 자동백업

- Retention Period(1-35일) 안의 어떤 시간으로 돌아가게 할 수 있음

- AB는 그날 생성된 스냅샷과 Transaction logs(TL)을 참고함

- 디폴트로 AB기능이 설정되어 있으며 백업정보는 S3에 저장

- AB동안 약간의 I/O suspension(정지)이 존재할 수 있음 -> Latency 지연시간

#DB Snapshots (데이터베이스 스냅샷)

- 주로 사용자에 의해 실행됨

- 원본 RDS Instance를 삭제해도 스냅샷은 존재함 (vs AB, AB는 인스턴스 삭제시 스냅샷 모두 삭제됨)

#RDS데이터베이스 백업시 원본 일어나는 현상?

새로운 RDS Instance, RDS Endpoint 가 생성됨.

즉, 원본과 백업본은 완전히 다른 객체가 됨.

#RDS-Multi AZ, Read Rplicas

Multi AZ

- 원래 존재하는 RDS DB에 무언가 변화(e.x: write)가 생길 때 다른 Availability Zone에 똑같은 복제본이 만들어짐 = Synchronize

- AWS에 의해서 자동으로 관리가 이루어짐 (No admin intervention)

- 원본 RDS DB에 문제가 생길 시 자동으로 다른 AZ의 복제본이 사용됨

- Disater Recovery Only! 성능개선을 위해 사용되진 않음. (성능개선은 Read Replica) ★

- 3ec2 -> 1개 RDS ap-northeast-2A <-> ap-northeast-2B: ap-northeast-2A에서 재해발생시, 자동으로 ap-northeast-2B으로 fail over함.

Read Replica

- production DB의 읽기 전용 복제본이 생성됨

- 주로 Read-Heavy DB 작업시 효율성의 극대화를 위해 사용됨(Scaling)

- Disaster Recovery용도가 아님★

- 최대 5개 Read Replica DB 허용

- Read Replica의 Read Replica 생성 가능 (단, Latency 발생)

- 각각의 Read Replica는 자기만의 고유 Endpoint존재

- 3ec2 -> RDS연결. ec2인스턴스로부터 쓰기 작업 실행될 시, Read Replica에 의해 똑같은 RDS 복제본이 생성됨.

ex) read traffic? main으로 모두 보는 것이 아니라 하나의 인스턴스를 각각의 Read Replica로 연결시킴. 즉, mainDB의 워크로드를 현저히 낮출 수 있으며 성능 높일 수 있다.

#ElastiCache

- 클라우드 내에서 In-memory캐시를 만들어줌

- 데이터베이스에서 데이터를 읽어오는 것이 아니라 캐시에서 빠른 속도로 데이터를 읽어옴

- Read-Heavy 애플리케이션(SNS, 실시간 top 10)에서 상당한 Latency감소 효과 누림

★Read-Heavy데이터 사용시 어떤 서비스를 사용해야 최고의 효율을 낼 수 있을까요? ElastiCache

# ElastiCache 종류

1) Memcached

- Object캐시 시스템으로 잘 알려져 있음

- ElastiCache는 Memcached의 프로토콜을 디폴트로 따름

- EC2 Auto Scaling 처럼 크리가 커졌다 작아졌다 가능함

- 오픈소스

- 사용목적

i) 가장 단순한 캐싱 모델이 필요한가요?

ii) Object caching이 주된 목적인가요?

iii) 캐시 크기를 마음대로 scaling하기를 원하나요?

2) Redis

- Key-value, Set, List와 같은 형태의 데이터를 In-Memory에 저장 가능함

- 오픈소스

- multi-AZ(재해복구) 지원

- 사용목적

i) List, Set과 같은 데이터셋을 사용하나요?

ii) 리더보드처럼 데이터셋의 랭킹을 정렬하는 용도가 필요한가요?

iii) Multi AZ기능이 사용되어져야 하나요?

#RDS실습

- 데이터베이스 생성>엔진옵션(mysql etc)>템플릿(프리티어)>설정>DB인스턴스크기>스토리지>가용성 및 내구성>연결-추가연결구성 퍼블릭엑세스기능 아니요/vpc보안그룹 새로 생성 가용영역 기본설정없음>데이터베이스 인증> 추가구성>월별추정요금

>고급세부정보

#!/bin/bash
yum install httpd php php-mysql -y
yum update -y
chkconfig httpd on # 아파치서버 켬
service httpd start # 아파치 실행
echo "<?php phpinfo();?>" > /var/www/html/index.php #phpvkdlf todtjd gn wjwkd
cd /var/www/html # todtjdgkf vhfejfh dlehd 
wget https://aws-learner-storage.s3.ap-northeast-2.amazonaws.com/connect.php #파일 다운

> connect.php 파일

<?php 
//username password hostname dbname 등록
$username = "awslearner"; 
$password = "awslearner"; 
$hostname = "yourhostnameaddress";  //RDS endpoint
$dbname = "awslearner";

//connection to the database
$dbhandle = mysql_connect($hostname, $username, $password) or die("MySQL에 연결할 수 없습니다"); 
echo "MySQL 접속 성공! username - $username, password - $password, host - $hostname<br>"; 
$selected = mysql_select_db("$dbname",$dbhandle) or die("MySQL DB 연결 실패... - 다시 시도해보세요!"); 
?>

#S3

- simple storage servicve

- 안전하고 가변적인 Object 저장공간을 사용 (ex: Google Cloud)

- 편리한 UI인터페이스를 통해 어디서나 쉽게 데이터를 저장하고 불러올 수 있음

- 파일 크기는 0kb~5tb까지 지원

- 저장공간 무제한

- Bucket이라는 이름을 사용함 (디렉토리와 유사함)

- Bucket은 보편적인 namespace를 사용함

#S3 Object구성요소

- key: 파일명

- value : 파일내용

- version ID : 버전

- metadata : 어떤 팀의 owner인지 등 데이터의 상세정보

- CORS (Cross Origin Resource Sharing) : 한버킷의 파일을 다른 버킷에서 접근가능하도록 해줌(지역상관 x)

#S3 Data Consistency Model

1. Read after Write Consistency (PUT)

2. Eventual Consistency (UPDATE, DELETE)

# S3스토리지

1. 일반 S3

- 가장 보편적으로 사용되는 스토리지 타입

- 높은 내구성(Durability, 얼마나 손실없이 잘 복원되는지), 가용성(Avaliability, 얼마나 데이터 접근 용이한지)

2. S3-IA (Infrequent Access)

- 자주 접근되지는 않으나 접근시 빠른 접근이 요구되는 파일이 많을 시 유용

- 일반 S3에 비해 비용이 저렴하나 접근시 추가 비용 발생

- 멀티 AZ를 통한 데이터 저장 => 가용성 상당히 높음

3. S3-One Zone IA

- 단일 AZ를 통한 데이터 저장

- 단일 AZ에 의한 데이터 접근 제한 (조금 낮은 가용성)

- 데이터 접근시 S3-IA보다 20% 비용 저렴

4. Glacier

- 거의 접근하지 않을 데이터 저장 시 유용

- 매우 저렴한 비용

- 데이터 접근시 대략 4-5시간 소요

5. Intelligent Tiering

- 데이터 접근 주기가 불규칙할 때 매우 유용

- 2가지 티어 존재

- Frequent Tier

- Infrequent Tier

- 데이터 접근주기에 따라 두가지 티어중 하나로 선택됨

- Frequent Tier가 비용이 약간 더 비쌈

- 최고의 비용 절감 효율을 누릴 수 있음

#S3요금

- GB당 (0.023 per GB 정도)

- PUT, GET, COPY 요청 횟수당

- 데이터 다운로드시 / 다른 리소스로 전송시

- METADATA (object tag)

#S3사용 사례

사례1. 파일 저장소(로그, 다양한 파일들(이미지, 비디오, 압축파일 등))

사례2. 웹사이트 호스팅 : html, css, javascript등 웹사이트 구성에 필요한 파일 S3에 올려두고 Route53으로 DNS를 생성하여 사용가능

사례3. CORS : Cross Origin Resource sharing. 한 버킷이 다른 버킷의 파일로 접근 가능하게 해줌.

#최초S3버킷 생성시 -> 비공개(private)

이를 public or 공유가능하도록 변경하려면?

방법1. 버킷 정책 변경 (Bucket policy)

방법2. 접근 제어 리스트 변경 (Access Control List) : 각 파일마다 접근제어 설정 가능

#S3암호화

상황1. 파일 업로드/다운로드시

- SSL(Secure Socket Layer) / TLS (Transport Layer Security)

상황2. 가만히 있을시

i) SSE-S3 : 자동으로 주기적으로 암호 변경 (AES-256 사용됨)

ii) SSE-KMS : 언제, 누가 암호를 변경했는지 기록해주기 때문에 보안관리에 좋음

iii) SSE-C : 직접 암호 변경 가능.

*SSE : Server Side Encrypt

#S3암호화 과정

- PUT 요청이 생성됨

- host: bucket이름

- x-amz-server-side-encryption-parameter: AES-256 => 우리가 파일을 s3에 업로드할 때 헤더에 이것이 있다면 암호화(AES-256)하라는 의미.

암호화가 걸리지 않은 파일을 버켓에 올리지 못하게 하는 방법 있다. 버켓정챙설정. 저 값이 헤더에 없으면 reject.

#S3실습

버킷만들기:일반구성>퍼블릭액세스차단설정>고급설정

버킷에서 폴더만들어 직접 upload도 가능.

고급설정:다른 AWS계정에 대한 엑세스: ACL(액세스 제어리스트)

버킷레벨에 해당하는 접근 권한이 없기 때문

권한 버킷정책 정책생성기

#CloudWatch

-얼마나 많은 공간? 어떤 이벤트들? 서비스의 상태는? 얼마나 에러 발생?

- AWS 리소스 사용의 실시간 모니터링 기능 지원

- 다양한 이벤트(s3버킷 파일 업로드&삭제, S3 버킷 접근시 접근거부 발생, RDS 데이터베이스에 접속 시도)들을 수집하여 로그파일로 저장

- 이벤트&알람 설정을 통해 SNS, AWS Lambda로 전송 가능

- CloudWatch 사용 가능 서비스들 : EC2, RDS, S3, ELB 등!

#CloudWatch모니터링 종류

종류1. Basic Monitoring : 무료, 5분간격으로 최소의 Metrics 제공

종류2. Detailed Monitoring : 유료, 1분 간격으로 자세한 Metrics 제공

(자세한? cpu사용량, 디스크사용량, 네트워크 I/O 등)

#CloudWatch 사용 사례

CASE1.

- Use Case: 매일 얼마나 많은 사람들이 모바일 앱을 사용하는지 알고 싶음

- Potential Issue: 특정날에 수많은 traffic이 몰릴 수 있어 병목현상이 생길 수 있음

- Solution : 매일 traffic rate과 특정 버튼의 유저 클릭 횟수를 분석하여 더 효율적인 앱개발을 할 수 있는 통찰력을 얻을 수 있음

CASE2.

- Use Case: 특정 시간대에 웹서버 상태를 점검하여 비용 절감 목표

- Potential Issue: 똑같은 비용을 내며 AWS리소스들을 사용하지만 낮시간대와 밤시간대에 필요한 서버의 성능은 달라질 수 있기 때문에 금전적 손실이 생길 수 있음 (주로 밤시간대가 낮시간대보다 서버가 오랫동안 idle)

- Solution : 알람 설정을 통하여 특정 threshold에 도달했을 때 개발자에게 상황을 보고해줌으로서 서버관리 가능

#CloudWatch-Alarm

- 임의로 정해놓은 값에 도달할 시 Alarm이 울림

- Alarm이울릴 시 특정 이벤트들을 작동시킬 수 있음

#Alarm State

- Alarm

- Insufficient불충분

- OK

#Billing Alarm

- 우리가 정해놓은 지출 임계값을 초과할 경우 SNS를 통하여 경고를 함

AWS Cloud Practitioner Essentials - AWS의 핵심 서비스

aonee — Wed, 10 Feb 2021 04:00:55 +0900

EC2 (Amazon Elastic Cloud Compute)

EC2란?

Amazon Elastic Cloud Compute의 약자이다.

Compute : 컴퓨팅 또는 서버 리소스를 나타낸다.

Elastic : 필요에 따라 해당 애플리케이션에 필요한 서버의 양을 자동으로 늘리거나 줄일 수 있다.

서버라는 말 대신, EC2 인스턴스 라고 부른다.

EBS (Amazon Elastic Block Store)

EBS란?

EC2 인스턴스의 스토리지 단위로 사용될 수 있다. 따라서 AWS에서 실행 중인 인스턴스에 디스크 공간이 필요할 때마다 EBS 볼륨을 생각하면 된다. 이러한 볼륨은 하드 디스크 또는 SSD 디바이스가 될 수 있다. 사용한 만큼만 지불하면 되고 볼륨이 더 이상 필요하지 않으면 언제라도 삭제하여 요금을 지불하지 않을 수 있다.

EBS 특징

1) 가용성

EBS 볼륨은 안정성과 가용성을 목표로 설계된다. 따라서 볼륨에 있는 데이터는 가용 영역에서 실행 중인 여러 서버에 자동으로 복제된다. EBS 볼륨과 하드 디스크 또는 SSD 등과 같은 물리적 미디어 디바이스르 비교했지만, EBS볼륨이 블록 수준 복제 덕분에 더욱 안정적이다.

2) 드라이브 유형 선택할 수 있다.

ex) db인스턴스 실행중, db 보조 볼륨으로 db구성. 이는 운영체제에 할당된 볼륨보다 빠른 성능을 발휘할 수 있다. 또는 로그용으로 마그네틱 볼륨을 할당할 수도 있다. 마그네틱이 더 저렴하기 때문.

3) 스냅샷

보다 높은 수준의 데이터 내구성을 제공하기 위해 볼륨의 특정 시점 스냅샷을 생성하는 기능을 제공하며 AWS를 사용하면 언제든지 스냅샷에서 새 볼륨을 다시 생성할 수 있습니다. 개선된 재해 복구 보호를 위해 스냅샷을 공유하거나 다른 AWS 리전으로 스냅샷을 복사한다.

4) 암호화

암호화는 EC2측에서 이루어진다. 따라서 EC2 인스턴스와 AWS 데이터 센터 내부의 EBS 볼륨 간에 이동하는 데이터는 전송 중에 암호화된다. 회사가 성장함에 따라 EBS볼륨에 저장되는 데이터의 양도 늘어날 것이다.

4) 탄력성

EBS 볼륨은 용량을 늘리고 다른 유형으로 변경할 수 있으므로 하드디스크에서 SSD로 변경(ex 50GB -> 16TB)할 수 있다. 인스턴스를 중단할 필요도 없다.

=> EBS가 무엇인지, EBS 볼륨을 생성하여 Linux EC2 인스턴스에 연결하는 방법 데모

S3 (Amazon Simple Storage Service)

S3란?

관리형 클라우드 스토리지 서비스
객체를 사실상 무제한으로 저장
언제든 어디서나 액세스
풍부한 보안 제어 기능 -> IAM를 통해 데이터 엑세스 가능한 사용자 지정 가능

S3 특징

1) 리전에 중복으로 데이터 저장

버킷에 데이터를 저장할 때마다 해당 데이터는 선택한 리전의 여러 AWS 시설에 중복 저장된다. 즉, 어느 한 곳의 데이터가 손실되도 복구할 수 있다.

2) 원활한 확장을 고려한 설계

사용한 양에 대해서만 비용이 청구된다.

3) 어디서나 데이터에 액세스 가능

사용 사례

1) 애플리케이션 자산 저장

2) 정적 웹 호스팅

3) 백업 및 재해 복구

-> 교차 리전 복제를 지원하도록 구성할 수 있다.

4) 빅데이터를 위한 스테이징 영역

-> S3의 확장 가능한 스토리지 및 성능 덕분에 다양한 빅데이터 도구를 사용하여 분석하려는 데이터를 준비하거나 장기간 보관할 수 있다.

ex)

Amazon S3의 DataStage: Amazon Redshift로 로드되어 Amazon EMR에서 처리되거나, Amazon Athena와 같은 도구를 사용하여 쿼리될 수 있다.

또한, Snowblall과 같은 AWS Import/Export 디바이스를 사용하여 대량의 볼륨을 Amazon S3로 가져오거나 내보낼 수 있다.

5) 그 외 다수

AWS 글로벌 인프라

3가지 주제로 나눌 수 있다.

1. AWS 리전

2개 이상의 가용 영역을 호스팅하는 지리적 영역이고, AWS 서비스에 대한 구성 수준이다. 리소스를 배포할 때, 리소스가 위치하는 리전을 선택한다.

이때, 어느 리전이 비용을 최소화하고 규제 요구 사항을 준수하면서도 지연시간을 최적화하는데 도움이 되는지 고려하는 것이 중요하다.

또한, 비즈니스 요구 사항을 더 잘 충족하기 위해 여러 리전으로 리소스를 배포할 수도 있다.

ex) 개발자 리소를 한 리전에 배포해야 하지만 기본 고객 기반이 다른 리전에 있는 경우, 개발 자산을 한 리전에 배포하고 고객용 솔루션은 다른 리전에 배포할 수 있다.

또는 동일한 리소스를 여러 리전에 배포하여 고객의 위치와 상관 없이 전 세계적으로 일관된 경험을 제공할 수 있다.

최소의 비용으로 짧은 시간 내에 지연 시간을 최소화하고 조직의 민첩성을 향상시킬 수 있다.

리전은 서로 완전히 분리된 개체이다. 한 리소스는 달느 리전으로 자동 복제되지 않는다.

2. 가용 영역

특정 리전에 존재하는 데이터 센터들의 모음을 의미. 각 가용 영역은 물리적으로 서로 격리되어 있지만 빠르고 지연 시간이 짧은 네트워크로 서로 연결되어 있다. 각 가용 영역은 물리적으로 구분된 독립적인 인프라이다. 물리적은 물론 논리적으로도 분리되어 있다. 또한, 자체적으로 개별 무정전 전원 공급 장치, 현장 예비 발전기, 냉각 장비 미치 네트워크 및 연결 장치를 보유하고 있다.

독립적인 전력 회사의 망을 통해 전력이 공급되며, 여러 개의 티어 1 전송 서비스 공급업체를 통해 네트워크로 연결된다.

가용영역을 격리시켜 다른 영역의 장애로부터 보호하고 특정 리전에서 고가용성 데이터 중복성이 보장된다. 즉, 하나의 영역이 중단되도 다른 영역에서 요청을 처리할 수 있다.

AWS가 여러 가용 영역에 데이터를 프로비저닝하는 것을 모범사례로 추천하는 이유이다.

3. Edge Location

Amazon CloudFront라고 하는 콘텐츠 전송 네트워크(CDN)를 호스팅한다.

Amazon CloudFront는 고객에게 콘텐츠를 전송하는데 사용된다. 콘텐츠에 대한 요청이 자동으로 가장 가까운 Edge Location으로 라우팅되므로 콘텐츠가 더욱 빨리 최종 사용자에게 전송된다. Edge Location의 글로벌 네트워크를 사용하면 최종 고객이 더욱 빠르게 콘텐츠에 엑세스할 수 있다. 일반적으로 Edge Location은 가용영역의 리전과 마찬가지로 인구 밀도가 높은 지역에 위치하기 때문이다.

VPC (Amazon Virtual Private Cloud)

VPC

AWS 클라우드 종량제 온디맨드 컴퓨팅뿐 아니라 관리형 서비스도 제공하며 모두 웹에서 액세스할 수 있다. 이러한 컴퓨팅 리소스 및 서비스는 익숙한 네트워크 구조로 구현된 정상 IP 프로토콜을 통해 액세스할 수 있어야 한다. 고객은 네트워킹 모범 사례를 준수하면서 규제 및 조직의 요구 사항도 충족해야 한다. VPC는 네트워킹 요구 사항을 충족하는 AWS 네트워킹 서비스이다.

1) AWS 클라우드의 프라이빗 가상 네트워크

온프레미스 네트워킹과 동일한 개념 사용

2) 네트워크 구성을 완벽하게 제어할 수 있도록 허용

VPC 내부의 리소스를 격리 및 노출할 수 있는 기능

3) 여러 계층의 보안 제어 기능을 제공

특정 인터넷 및 내부 트래픽을 허용 및 거부할 수 있는 기능

4) 다른 AWS 서비스를 VPC에 배포

네트워크에 내장된 서비스 고유의 보안

TypeORM 개념 및 설치 및 사용방법

aonee — Sun, 7 Jun 2020 23:58:59 +0900

Typeorm 공식문서

ORM 개요

Object-relational mapping, 객체-관계 매핑

객체와 관계형 데이터베이스의 데이터를 자동으로 매핑(연결)해준다.

객체 지향 프로그래밍은 클래스를 사용하고, 관계형 데이터베이스는 테이블을 사용한다.
객체 모델과 관계형 모델 간에 불일치가 존재한다.
ORM을 통해 객체 간의 관계를 바탕으로 SQL을 자동으로 생성하여 불일치를 해결한다.

TypeORM 개요

express와 관계형 데이터베이스를 조합할 때 자주 사용되는 ORM으로 Sequelize가 있다.

그리고 요즘 Typescript의 인기와 함께 떠오르는 ORM으로 TypeORM 이 있다.

Sequelize와 TypeORM 중 어떤 ORM을 사용할지 고민을 많이 했다.

결국은 TypeORM 을 선택했다. 그 이유는 모델의 정의를 제대로 하면 타입을 정하는 메리트를 최대한으로 얻을 수 있고, 복잡한 모델간의 관계를 형성할 수 있다는 장점이 있기 때문이다. 그리고 TypeORM 을 선호하는 글이 더 많길래 사용해봤다.

TypeORM 이라는 이름으로 인해 타입스크립트 전용의 ORM같이 느껴지지만, 자바스크립트(ES5, ES6, ES7)도 지원한다.

TypeORM을 사용하여 개발을 하면 Python의 SQLAlchemy와 같은 Data Mapper 패턴과 Rails와 같은 Active Record 패턴으로 개발할 수 있다.

Active Record vs Data Mapper

Active Record 패턴

TypeORM에서는 Active Record 패턴과 Data Mapper 패턴 두 종류의 패턴을 사용할 수 있다.

Active Record 패턴은 모델 그 자체에 쿼리 메소드를 정의하고, 모델의 메소드를 사용하여 객체를 저장, 제거, 불러오는 방식이다.

아래는 공식문서의 예제 코드이며 BaseEntity라는 클래스를 사용하여 새로운 클래스에 상속하게 한 후 사용할 수 있다. 이를 통해 BaseEntity가 갖고 있는 메소드와 static으로 만들어 내는 커스텀 메소드를 이용할 수 있다.

import {BaseEntity, Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User extends BaseEntity {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    isActive: boolean;

    static findByName(firstName: string, lastName: string) {
        return this.createQueryBuilder("user")
            .where("user.firstName = :firstName", { firstName })
            .andWhere("user.lastName = :lastName", { lastName })
            .getMany();
    }
}

아래는 공식문서에 있는 Active Record 예제코드이다.
아래와 같이 Acitve Record 패턴은 DB 엔티티에 직접 다룰 수 있도록 new 키워드를 이용하여 새로운 인스턴스를 만들어 사용하는 것이 가능하다.

// example how to save AR entity
const user = new User();
user.firstName = "Timber";
user.lastName = "Saw";
user.isActive = true;
await user.save();

// example how to remove AR entity
await user.remove();

// example how to load AR entities
const users = await User.find({ skip: 2, take: 5 });
const newUsers = await User.find({ isActive: true });
const timber = await User.findOne({ firstName: "Timber", lastName: "Saw" });
const timber = await User.findByName("Timber", "Saw");

Data Mapper 패턴

Data Mapper 패턴은 분리된 클래스에 쿼리 메소드를 정의하는 방식이며, Repository를 이용하여 객체를 저장, 제거, 불러온다.
Active Record 패턴과의 차이점은 모델에 접근하는 방식이 아닌 Repository에서 데이터에 접근한다는 것이다.

아래는 공식문서의 예제 코드이다. 먼저 클래스를 정의한다.

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    isActive: boolean;

}

정의한 클래스를 Generic 타입을 이용하여 상속하게 한다.

import {EntityRepository, Repository} from "typeorm";
import {User} from "../entity/User";

@EntityRepository()
export class UserRepository extends Repository<User> {

    findByName(firstName: string, lastName: string) {
        return this.createQueryBuilder("user")
            .where("user.firstName = :firstName", { firstName })
            .andWhere("user.lastName = :lastName", { lastName })
            .getMany();
    }

}

그리고 getRepository()를 사용하여 만들어진 모델을 사용한다.

const userRepository = connection.getRepository(User);

// example how to save DM entity
const user = new User();
user.firstName = "Timber";
user.lastName = "Saw";
user.isActive = true;
await userRepository.save(user);

// example how to remove DM entity
await userRepository.remove(user);

// example how to load DM entities
const users = await userRepository.find({ skip: 2, take: 5 });
const newUsers = await userRepository.find({ isActive: true });
const timber = await userRepository.findOne({ firstName: "Timber", lastName: "Saw" });

Active Record vs Data Mapper

공식문서에 의하면 두 패턴은 각각의 장점이 있다고 한다. 아래 패턴별 특징을 고민하여 개발에 적용하면 좋을 듯하다.

Active Record: 규모가 작은 애플리케이션에서 적합하고 간단히 사용할 수 있다.
Data Mapper: 규모가 큰 애플리케이션에 적합하고 유지보수하는데 효과적이다.

TypeORM 설치

Installation

npm install typeorm --save

npm install reflect-metadata --save

// global place 의 app.ts에 import 추가하기
import "reflect-metadata";

npm install @types/node --save

// Install a database driver:
npm install mysql --save

Quick start

i. typeorm 설치 및 프로젝트 생성

npm install typeorm -g
typeorm init --name 프로젝트이름 --database mysql

프로젝트 디렉토리 구성

프로젝트이름
├── src              // place of your TypeScript code
│   ├── entity       // place where your entities (database models) are stored
│   │   └── User.ts  // sample entity
│   ├── migration    // place where your migrations are stored
│   └── index.ts     // start point of your application
├── .gitignore       // standard gitignore file
├── ormconfig.json   // ORM and database connection configuration
├── package.json     // node module dependencies
├── README.md        // simple readme file
└── tsconfig.json    // TypeScript compiler options

ii. install new project dependencies

cd 프로젝트이름
npm install

ormconfig.json

{
   "type": "mysql",
   "host": "localhost",
   "port": 3306,
   "username": "test",
   "password": "test",
   "database": "test",
   "synchronize": true,
   "logging": false,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.ts"
   ]
}

host, username, password, database and maybe port options.

iii. 프로젝트 시작

npm start

참고

https://github.com/typeorm/typeorm/blob/master/docs/active-record-data-mapper.md

https://typeorm.io/#/

https://velog.io/@josworks27/typeORM-%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0

[Babel/Webpack] 바벨과 웹팩을 이용한 ES6 환경 구축

aonee — Tue, 26 May 2020 19:42:07 +0900

Webpack (웹팩)

1. 개념

자바스크립트 코드가 많아지면 하나의 파일로 관리하는데 한계가 있다. 그렇다고 여러개의 파일을 로딩할 때의 단점도 존재한다.

단점 1) 여러개의 파일을 브라우저에 로딩하는 만큼 네트워크 비용을 치뤄야 한다.

단점 2) 각 파일은 서로의 범위를 침범하면 안되지만, 잘못 작성할 경우 변수 충돌의 위험성이 있다.

웹팩은 이러한 배경에서 이해할 수 있다.

기본구조에서 Module, Bundle, Entry, Output, Mode, Plugin 에 대해 개념을 자세히 정리하려 한다.

2. 기본구조

Module

Bundle

참조관계에 있는 모듈을 모아 하나의 파일로 묶어준다.

중요한 이유
- 모든 모듈을 로드하기 위해 검색하는 시간이 단축된다
- 사용하지 않는 코드를 제거해준다
- 파일의 크기를 줄여준다

Entry

application이 많은 모듈들로 구성이 되어있고 복잡한 참조를 이룬다.

참조관계를 해석해 의존성 그래프를 만든다.

의존성 그래프를 만들기 위해 어떤 모듈을 시작점으로 해석할지 결정한다.

Output

Entry에서 의존성 그래프 만들고 번들과정을 거치면 Output에 설정된 정보를 기반으로 번들된 파일이 생성된다.

Mode

모드키를 통해 빌드환경을 구분지을 수 있다.

번들과정에서 개발과정인지 프로덕션과정인지에 따라 작업환경이 달라지게 설정할 수 있다.

Loader

웹팩은 모든 파일을 모듈로 관리한다.

즉, javascript 파일 뿐 아니라 이미지, 폰트 등 전부 모듈로 관리한다.

그러나, javascript 밖에 모른다.

따라서, javascript 가 아닌 파일을 웹팩이 이해할 수 있도록 변경해야한다. 이와 같은 역할을 하는 것이 로더이다.

로더는 test와 use키로 구성된 객체로 설정할 수 있다.

test : 로딩할 파일을 지정

use : 적용할 로더를 설정

Plugin

번들링의 전체적인 고자어에 여러가지 일들을 할 수 있다.

3. 설정

i. Webpack 설치

npm install webpack webpack-cli --save-dev

ii. babel-loader

Webpack이 모듈을 번들링할 때 Babel을 사용하여 ES6+ 코드를 ES5 코드로 트랜스파일링하도록 babel-loader를 설치한다.

pm install --save-dev babel-loader

iii. babel-loader

npm script를 변경하여 Babel 대신 Webpack을 실행하도록 수정하자. 아래와 같이 package.json 파일의 scripts를 변경한다.

"scripts": {
    "build": "webpack -w"
  },

iv. webpack.config.js

webpack.config.js은 Webpack이 실행될 때 참조하는 설정 파일이다. 프로젝트 루트에 webpack.config.js 파일을 생성하고 아래와 같이 작성한다.

const path = require('path');

module.exports = {
  // enntry file
  entry: './src/js/main.js',
  // 컴파일 + 번들링된 js 파일이 저장될 경로와 이름 지정
  output: {
    path: path.resolve(__dirname, 'dist/js'),
    filename: 'bundle.js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        include: [
          path.resolve(__dirname, 'src/js')
        ],
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader',
          options: {
            presets: ['@babel/preset-env'],
            plugins: ['@babel/plugin-proposal-class-properties']
          }
        }
      }
    ]
  },
  devtool: 'source-map',
  // https://webpack.js.org/concepts/mode/#mode-development
  mode: 'development'
};

v. webpack 실행

Webpack을 실행하여 트랜스파일링 및 번들링을 실행한다. 트랜스파일링은 Babel이 실행하고 번들링은 Webpack이 실행한다. 만약 이전에 실행시킨 빌드 명령이 실행 중인 상태라면 중지시키고 다시 아래 명령을 실행한다.

npm run build

실행 결과 dist/js 폴더에 bundle.js이 생성되었다. 이 파일은 main.js, lib.js 모듈이 하나로 번들링된 결과물이다.

vi. index.html 수정

index.html을 아래와 같이 수정하고 브라우저에서 실행해 보자.

<!DOCTYPE html>
<html>
<body>
  <script src="./dist/js/bundle.js"></script>
</body>
</html>

4. zero configuration?

특별한 설정서버를 사용하지 않고, 이용가능한 인터넷프로토콜 네트워크를 자동적으로 작성 하는 일종의 기법

웹팩 명령어만 실행해도 자주사용되는 웹팩설정 기본적으로 적용시켜준다.
사용방법 ?
- src
  
  엔트리의 경로를 src안에 index.js 파일 이름으로 준비해야 동작
- dist
  
  번들파일이 위치한 장소도 dist 폴더 안에 있어야 한다.
  또한, main.js 파일 이름으로 준비해야한다.

엔트리와 아웃풋 설정 따로 하지 않아도 번들링된다.

npx webpack --target-node

번들 파일이 잘 만들어졌는지 실행

node ./dist/main.js

Babel

IE와 다른 구형 브라우저 ES6의 화살표 함수와 ES7의 지수 연산자를 지원하지 않을 수 있다.

Babel을 사용하면 위 코드를 아래와 같이 ES5 이하의 버전으로 변환할 수 있다.

i. Babel CLI 설치

npm i @babel/cli @babel/core

ii. babelrc 설정 파일 작성

Babel을 사용하려면 @babel/preset-env을 설치해야 한다.

npm install --save-dev @babel/preset-env

iii. 트랜스파일링

Babel을 사용하여 ES6+ 코드를 ES5 이하의 코드로 트랜스파일링하기위해 package.json 파일에 scripts를 추가한다.

"scripts": {
    "build": "babel src/js -w -d dist/js"
  },

-w

타깃 폴더에 있는 모든 파일들의 변경을 감지하여 자동으로 트랜스파일한다. (--watch 옵션의 축약형)

-d

트랜스파일링된 결과물이 저장될 폴더를 지정한다. (--out-dir 옵션의 축약형)

iv. Babel 플러그인

Babel을 사용하려면 @babel/preset-env을 설치해야 한다.

npm install --save-dev @babel/plugin-proposal-class-properties

package.json 파일의 devDependencies에 설치된 것 확인 가능하다.

설치한 플러그인은 .babelrc 파일에 추가해 주어야 한다.

{
  "presets": ["@babel/preset-env"],
  "plugins": ["@babel/plugin-proposal-class-properties"]
}

터미널에서 아래 명령으로 트랜스파일링을 실행

npm run build

트랜스파일링에 성공하면 프로젝트 루트에 dist/js 폴더가 자동 생성되고 트랜스파일링된 main.js와 lib.js가 저장된다.

트랜스파일링된 main.js를 실행

node dist/js/main

참고

http://jeonghwan-kim.github.io/js/2017/05/15/webpack.html

https://poiemaweb.com/es6-babel-webpack-1

https://poiemaweb.com/es6-babel-webpack-2

[Spring Security] JWT(JSON Web Token) 의 코드 구현

aonee — Sun, 17 May 2020 23:58:35 +0900

깃허브 : 전체 코드 Spring Boot에 Spring Security와 JWT를 사용해 로그인 구현

1. 동작과정

Generating JWT

Client : 로그인 요청 POST (id, pw)
Server : id, pw가 맞는지 확인 후 맞다면 JWT를 SecretKey로 생성
Client : Server에게 받은 JWT를 로컬 or 세션에 저장
Client : 서버에 요청할 때 항상 헤더에 Token을 포함시킴
Server : 요청을 받을 때마다 SecretKey를 이용해 Token이 유효한지 검증
- 서버만이 SecretKey를 가지고 있기 때문에 검증 가능
- Token이 검증되면 따로 username, pw를 검사하지 않아도 사용자 인증 가능
Server : response

2. Token 유효 검증

클라이언트의 요청 (Header : Token)
Spring의 Interceptor에 의해 요청이 Intercept됨
클라이언트에게 제공되었던 Token과 클라이언트의 Header에 담긴 Token 일치 확인
auth0 JWT를 이용해 issuer, expire 검증

Validating JWT

3. Spring Boot Security + JWT 코드

3-1. dependency 추가

pom.xml

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>

spring-boot-starter-security와 jjwt 추가

3-2. Secret Key 설정

Hashing algorithm과 함께 사용할 Secret Key를 설정
Secret Key는 Header, Payload와 결합되어 Hash 생성

application.properties

jwt.secret=aoneeJjangjwt

3. JwtUtil

JWT를 생성하고 검증하는 역할 수행
io.jsonwebtoken.Jwts 라이브러리 사용

@Component
public class JwtUtil {
    @Value("${jwt.secret}")
    private String SECRET_KEY;

    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
    }

    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return createToken(claims, userDetails.getUsername());
    }

    private String createToken(Map<String, Object> claims, String subject) {

        return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY).compact();
    }

    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

createToken

Token 생성
- claim : Token에 담을 정보
- issuer : Token 발급자
- subject : Token 제목
- issuedate : Token 발급 시간
- expiration : Token 만료 시간
  - milliseconds 기준!
signWith (알고리즘, 비밀키)

4. MyUserDetailsService

DB에서 UserDetail를 얻어와 AuthenticationManager에게 제공하는 역할
이번에는 DB 없이 하드코딩된 User List에서 get userDetail

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    	if ("user_id".equals(username)) {
            return new User("aonee","$2a$10$VKu6eW.2pHLJn3yeW0eMxuEUBxXCq/b2Vo3HwSqROGI2mmYRnXqpm",new ArrayList<>());
        } else {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
    }
}

Spring Security 5.0에서는 Password를 BryptEncoder를 통해 Brypt화한다.
- https://www.javainuse.com/onlineBcrypt 에서 user_pw를 Bcrypt화
  - $2a$10$VKu6eW.2pHLJn3yeW0eMxuEUBxXCq/b2Vo3HwSqROGI2mmYRnXqpm
id : user_id, pw: user_pw로 고정해 사용자 확인
사용자 확인 실패시 throw Exception

5. LoginController

사용자가 입력한 id, pw를 body에 넣어서 POST API mapping /authenticate
사용자의 id, pw를 검증
jwtUtil을 호출해 Token을 생성하고 JwtResponse에 Token을 담아 return ResponseEntity

@RestController
@CrossOrigin
public class LoginController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtUtil jwtTokenUtil;

    @Autowired
    private MyUserDetailsService userDetailsService;


    @GetMapping("/main")
    public String main(){
        return "Welcome!! This is main page";
    }

    @GetMapping("/hello")
    public String hello(){
        return "hello";
    }

    @PostMapping("/authenticate")
    public ResponseEntity<?> createAuthenticationToken(@RequestBody AuthenticationRequest authenticationRequest) throws Exception {
        try {
            authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(
                            authenticationRequest.getUsername(),
                            authenticationRequest.getPassword())
            );

        } catch (BadCredentialsException e) {
            throw new Exception("Incorrect username or password", e);
        }

        final UserDetails userDetails = userDetailsService
                .loadUserByUsername(authenticationRequest.getUsername());
        final String jwt = jwtTokenUtil.generateToken(userDetails);
        return ResponseEntity.ok(new AuthenticationResponse(jwt));
    }

}

6. AuthenticationRequest

사용자에게서 받은 id, pw를 저장

@Getter
@Setter
public class AuthenticationRequest {
    private String username;
    private String password;

    public AuthenticationRequest() {
    }

    public AuthenticationRequest(String username, String password) {
        this.username = username;
        this.password = password;
    }
}

7. AuthenticationResponse

사용자에게 반환될 JWT를 담은 Response

@Getter
public class AuthenticationResponse {
    private final String jwt;

    public AuthenticationResponse(String jwt) {
        this.jwt = jwt;
    }
}

8. JwtRequestFilter

Client의 Request를 Intercept해서 Header의 Token가 유효한지 검증
if 유효한 Token
- Spring Security의 Authentication을 Setting, to specify that the current user is authenticated

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private MyUserDetailsService userDetailsService;

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        final String authorizationHeader = request.getHeader("Authorization");

        String username= null;
        String jwt = null;

        if(authorizationHeader != null && authorizationHeader.startsWith("Bearer ")){
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }

        if(username != null && SecurityContextHolder.getContext().getAuthentication() == null){
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            if(jwtUtil.validateToken(jwt, userDetails)){
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request,response);
    }
}

[Spring Security] JWT(JSON Web Token) 의 모든 것

aonee — Sun, 10 May 2020 19:04:37 +0900

1. 정의

#JSON #Claim_based_Token #Self_contained

JSON Web Token의 약자로 클레임 토큰 기반의 방식.

클라이언트의 세션 상태를 저장하는 것이 아닌
필요한 정보를 토큰 body에 저장해 클라이언트에 저장해두고 이를 증명서 처럼 사용한다.

Claim based?

Claim : 사용자에 대한 프로퍼티 / 속성
토큰 자체가 정보
Self-contained : 자체 포함, 즉 토큰 자체가 정보
key / value 로 이루어짐

2. 구성

{Header}.{Payload}.{Verify Signature}
3가지 정보를 '.'로 연결하여 사용한다.

JWT 공식사이트 를 통해 JWT를 생성 및 검증할 수 있다.

Header : JWT 토큰의 유형이나 사용된 해시 알고리즘의 정보가 들어간다.

Payload : 클레임(Claims)을 포함한다. 즉, 클라이언트에 대한 정보가 담겨있다.
또한 여기에는 iss, sub, aud, exp, nbf, iat, jti 와 같은 기본 정보가 들어간다.

1. 등록된 클레임 ( Registered claims )
이미 정의된 클레임들로 무조건 따라야 하는 것은 아니지만 권장한다.
iss (issuer, 토큰 발행자), exp (expiration time, 토큰 만료시간), sub (subject, 토큰 제목), aud(audience, 토큰 대상자) 와 같은 클레임들이 있습니다.
클레임의 이름은 compact를 위해 3글자로 사용한다.

2. 공개된 클레임 ( Public claims )
JWT를 사용하는 사람들에 의해 정의되는 클레임이다.
클레임 충돌을 피하기 위해서 IANA JSON Web Token Registry 에 정의하거나 URI 형식으로 정의해야 한다.

3. 비공개 클레임 ( Private claims )
GUI, 서버, 그 외 모듈간에 협의한 클레임이다.

iss: 토큰 발급자 (issuer)

sub: 토큰 제목 (subject)

aud: 토큰 대상자 (audience)

exp: 토큰의 만료시간 (expiraton), 시간은 NumericDate 형식으로 되어있어야 하며 (예: 1480849147370) 언제나 현재 시간보다 이후로 설정되어있어야합니다.

nbf: Not Before 를 의미하며, 토큰의 활성 날짜와 비슷한 개념입니다. 여기에도 NumericDate 형식으로 날짜를 지정하며, 이 날짜가 지나기 전까지는 토큰이 처리되지 않습니다.

iat: 토큰이 발급된 시간 (issued at), 이 값을 사용하여 토큰의 age 가 얼마나 되었는지 판단 할 수 있습니다.

jti: JWT의 고유 식별자로서, 주로 중복적인 처리를 방지하기 위하여 사용됩니다. 일회용 토큰에 사용하면 유용합니다.

Signature : header에서 지정한 알고리즘과 secret key로 Header와 Payload를 담는다.

서명을 통해 메시지가 중간에 변경되지 않았다는 것을 검증하며,
JWT를 보낸 사람이 신뢰할 수 있는 대상이라는 것도 알 수 있다.

3. 특징

1. 표준 RFC 7519
JSON Web Token은 정보를 안전하게 전송하기 위해 정의된 공개된 표준 (RFC 7519) 이다
2. Self-contained ( 자가 수용적 )
JWT 자체적으로 필요한 모든 정보를 포함한다.
헤더 정보와, 실제 전달할 데이터, 검증할 수 있는 서명 데이터를 모두 포함하고 있다.
3. 신뢰 가능
JWT는 디지털 서명에 의해 검증할 수 있으며 신뢰할 수 있다.
비밀 값을 사용하는 HMAC 알고리즘이나 RDS or ECDSA와 같은 공개키, 개인키 쌍으로 서명될 수 있다.
4. Payload는 공개 데이터

JWT에 정보는 누구나 https://jwt.io/ 페이지에 접속해서 정보를 확인할 수 있다.
따라서 비밀번호와 같은 보안이 필요한 정보는 payload에 저장하면 안된다.
5. JWT의 Secret Key

JWT에서는 정보는 공개가 되어있지만 해시 값을 통해서 정보가 유효한지 확인을 하게 됩니다.
따라서 시크릿 키가 유출이 된다면 JWT에서 보안상에 큰 위협이 된다.

4. 과정

4.1 로그인
- client는 Auth Server에 로그인을 합니다. 이때 Auth Server는 application server 내에 위치할 수도 있으며, facebook, goole과 같은 제 3자가 될 수도 있다.
  
  • Auth Server에서 인증을 완료한 사용자는 JWT Token을 전달받는다.
  
  • client는 application server에 resource를 요청할때 앞서 전달받은 JWT Token을 Authorization Header에 전달한다.
  
  • application server는 전달받은 JWT Token이 유효하면 200 ok와 함께 data를 response 한다.
  
  이때 중요한점은 application server가 더이상 로그인한 사용자의 session을 관리하지 않는다는 것 입니다. 단지 전달받은 JWT가 유효한 Token인지만 확인하면 된다.
  
  cors를 enable 하지 않으면 기본적으로 application server는 외부 domain에 resource 접근을 허용하지 않는다.
- 또한, outside domain인 client가 application server에 resource를 요청하기위해 application server는 cors를 enable 해야한다.

4.2 사용 환경
- 하나의 End Point가 아닌 Mobile/Web 등의 multiple endpoint 환경이라면 통합적인 인증/인가 환경을 제공하기위해선 반드시 JWT를 사용한다.
- 보편적인 예로, React로 client를 구성하고 REST API 서버를 따로 두는 경우에는 JWT를 사용한다.
- 3rd party에게 public 하게 open 한 REST Endpoint가 존재할 경우 해당 3rd party의 인증/인가를 관리하기 위해 JWT를 사용한다.

5. 장점 / 단점 & 도입시 고려사항

장점

다양한 클라이언트(web,ios,android) 커버 가능
보안 이슈
사용자가 자신의 비밀 값으로 서버에 로그인 하게 되면, 서버는 JWT를 리턴합니다. token을 인증 값으로 사용하게 되면 기존 쿠키/세션을 사용하는 방식보다 많은 보안 이슈를 막을 수 있습니다. 서버는 GUI로부터 받은 JWT가 유효할 경우, resouce를 사용하도록 허용합니다. 또한 JWT는 쿠키를 사용하지 않기 때문에, Cross-Origin Resource Sharing (CORS) 이슈가 발생하지 않습니다.
데이터 용량: JWT는 기존의 XML보다 덜 복잡하고 인코딩 된 사이즈가 작습니다. 따라서 HTTP와 HTML 환경에서 사용하기 좋습니다.
사용성: JSON parser는 대부분의 프로그래밍이 지원하기 때문에 XML을 사용하는 SAML 보다 만들기 쉽습니다.
CORS(Cross-origin resource sharing) 문제때문에 주로 쓴다.
session의 한계 극복 가능

세션의 한계
1. 서버 확장시 세션 정보의 동기화 문제
  
  서버가 스케일아웃 돼서 여러 개가 생기면 각 서버마다 세션 정보가 저장로그인시(서버1), 새로고침(서버2) 로 접근하면 서버는 인증이 안됐다고 판단
2. 서버 / 세션 저장소의 부하
3. 웹 / 앱 간의 상이한 쿠키-세션 처리 로직

단점 & 도입시 고려사항

Self-contained
토큰 자체에 정보가 있다는 사실은 양날의 검
토큰 길이
토큰 자체 payload 에 Claim set을 저장하기 때문에 정보가 많아질 수록 토큰의 길이가 늘어나 네트워크에 부하를 줄 수 있음
payload 암호화
payload 자체는 그냥 인코딩된 데이터
중간에 payload를 탈취하면 디코딩을 통해 테이터를 볼 수 있음
payload에 중요 데이터를 넣지 않아야 함
Stateless
토큰은 한번 만들면 서버에서 제어가 불가능

참고

https://velopert.com/2389

https://www.youtube.com/watch?v=x6bzYyMY0GA&list=PLVApX3evDwJ1d0lKKHssPQvzv2Ao3e__Q&index=4

https://medium.com/sjk5766/jwt-json-web-token-%EC%86%8C%EA%B0%9C-49e211c65b45

https://sanghaklee.tistory.com/47

[spring boot] 스프링 부트와 AWS로 혼자 구현하는 웹 서비스-1

aonee — Sun, 3 May 2020 23:54:42 +0900

✔ 프로젝트 개발환경**

프로젝트 개발 환경은 다음과 같습니다.

IDE : IntelliJ IDEA Ultimate
Git Tools : Git Bash
OS : Window
SpringBoot 2.2.6
Java8
Gradle

✔프로젝트 코드 ( 깃허브 )

https://github.com/devAon/SpringBoot-WebService

✔ 프로젝트 코드 및 구현 내용 설명**

build.gradle

plugins {
    id 'org.springframework.boot' version '2.2.6.RELEASE'
    id 'io.spring.dependency-management' version '1.0.9.RELEASE'
    id 'java'
}

group = 'com.devAon'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

//Spring Boot Overriding
ext['hibernate.version'] = '5.2.11.Final'

dependencies {
    implementation 'pl.allegro.tech.boot:handlebars-spring-boot-starter:0.3.0'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }

}

test {
    useJUnitPlatform()
}

중요한 개념 정리

✔ SpringBoot & JPA로 간단 API 만들기

SpringBoot & JPA 사용하면 좋은점?

진짜 집중해야할 비즈니스 로직에만 집중할 수 있다.

Entity의 PK는 Long 타입의 Auto_increment 사용이 좋다.

이렇게 하면 MySQL 기준으로 bigint 타입이다.  
주민등록번호와 같은 비지니스상 유니크키나, 여러키를 조합한 복합키로 PK를 잡을 경우 난감한 상황이 발생할 수 있는데 이를 예방할 수 있다.

Spring Boot 2.0 에선 PK의 Auto_increment 를 위해 strategy = GenerationType.IDENTITY 옵션을 추가해야한다.

@GeneratedValue(strategy = GenerationType.IDENTITY)


Hibernate 5.0부터 MySQL의 AUTO는 IDENTITY가 아닌 **TABLE을 기본 시퀀스 전략**으로 선택된다.

우리의 의도대로 Auto\_increment 동작하도록 하기 위해 `@GeneratedValue`의 전략을 `GenerationType.IDENTITY`로 지정

Entity 클래스를 생성시, 무분별한 setter 메소드 생성하지 말자

무분별하게 getter/setter를 생성할 경우,

해당 클래스의 인스턴스 값들이 언제 어디서 변해야하는지 코드상으로 명확히 구분할수가 없어서

차후 기능변경시 복잡해질 수 있다.

대신, 기본생성자를 @NoArgsConstructor(access = AccessLevel.PROTECTED)로 막아두고

setter 메소드 없이 DB에 insert를 하기 위해

생성자 대신 @Builder를 통해 채워야할 필드가 무엇인지 명확하게 지정해주고

생성시점에 값을 채워주면 된다.

테스트 코드 작성하는 방법

@SpringBootTest
public class PostsRepositoryTest {
    ...

@Test
    public void 게시글저장_불러오기() {
        //given
        postsRepository.save(Posts.builder()
                .title("테스트 게시글")
                .content("테스트 본문")
                .author("jojoldu@gmail.com")
                .build());

        //when
        List<Posts> postsList = postsRepository.findAll();

        //then
        Posts posts = postsList.get(0);
        assertThat(posts.getTitle(), is("테스트 게시글"));
        assertThat(posts.getContent(), is("테스트 본문"));
    }
}

JUnit을 통해 어떤 값을 입력할 경우 어떤 결과가 반환되는지 검증할수 있다.

BDD(Behaviour-Driven Development)

given
- 테스트 기반 환경을 구축하는 단계
- 여기선
- @builder의 사용법도 같이 확인
when
- 테스트 하고자 하는 행위 선언
- 여기선 Posts가 DB에 insert 되는것을 확인하기 위함
then
- 테스트 결과 검증
- 실제로 DB에 insert 되었는지 확인하기 위해 조회후, 입력된 값 확인

`@Autowired` 대신 `@AllArgsConstructor` 사용하기

스프링프레임워크에선 Bean 을 주입받는 방식들이 아래와 같이 있다.

-   `@Autowired`
-   setter
-   생성자

이중 가장 권장하는 방식이 생성자로 주입받는 방식이다.
(@Autowired는 비권장방식이다.)
즉, 생성자로 Bean 객체를 받도록 하면 @Autowired와 동일한 효과를 볼 수 있다.

생성자는 @AllArgsConstructor 에서 해결해준다.
모든 필드를 인자값으로 하는 생성자를 Lombok의 @AllArgsConstructor이 대신 생성해 준 것입니다.

또한, 생성자를 직접 안쓰고 Lombok 어노테이션을 사용한 이유가 있다.
해당 클래스의 의존성 관계가 변경될때마다 생성자 코드를 계속해서 수정하는 번거로움을 해결하기 위해서다.

Entity 클래스와 거의 유사한 형태여도 꼭 DTO 클래스 생성해야한다.

절대로 테이블과 매핑되는 Entity 클래스를 Request/ Response 클래스로 사용해서는 안된다.
Entity 클래스는 가장 Core한 클래스이다.
수많은 서비스 클래스나 비지니스 로직들이 Entity 클래스를 기준으로 동작한다.
Entity 클래스가 변경되면 여러 클래스에 영향을 끼치게 되는 반면 Request와 Response용 DTO는 View를 위한 클래스라 정말 자주 변경이 필요하다.
따라서, View Layer와 DB Layer를 철저하게 역할 분리를 하는게 좋다.
실제로 Controller에서 결과값으로 여러 테이블을 조인해서 줘야할 경우가 빈번하기 때문에 Entity 클래스만으로 표현하기가 어려운 경우가 많다.
그러니 꼭 Entity 클래스와 Controller에서 쓸 DTO는 분리해서 사용해야한다.

Postman + 웹 콘솔로 검증을 위해 H2를 활성화

Local환경에서는 DB로 H2를 사용한다.
그러기 위해 H2를 활성화시켜야한다.

( STEP 1 ) application.properties를 application.yml로 변경 후 아래 코드 작성

spring:
  h2:
    console:
      enabled: true

참고

yml로 변경한 이유는 상대적으로 유연한 구조를 가졌기 때문이다.

yml은 상위 계층에 대한 표현, List 등을 완전하게 표현할 수 있다.

( STEP 2 ) Application.java 를 재실행 후 브라우저에http://localhost:8080/h2-console 입력

여기서 꼭❗❗❗❗ JDBC URL 을 jdbc:h2:mem:testdt 로 바꿔준 후 connect버튼을 눌러 접속

postman를 통해 데이터를 전송 후, h2-console에서 쿼리 실행 후 Run을 눌러 확인해볼 수 있다.

생성시간/수정시간 자동화 - JPA Auditing

보통 Entity에는 해당 데이터의 생성시간과 수정시간을 포함시킨다.
언제 만들어졌는지, 언제 수정되었는지 등은 차후 유지보수에 있어 굉장히 중요한 정보이기 때문이다.

그렇다보니 매번 DB에 insert하기전, update 하기전에 날짜 데이터를 등록/수정 하는 코드가 여기저기 들어가게 된다.

그런데 이런 단순하고 반복적인 코드가 모든 테이블과 서비스 메소드에 포함된다면 어마어마하게 귀찮고 코드가 더러워지겠죠?
그래서 이 문제를 해결하기 위해 JPA Auditing를 사용한다.

LocalDate 사용

여기서부터는 날짜 타입을 사용한다.
Java8 부터 LocalDate와 LocalDateTime이 등장한다.
Java의 기본 날짜 타입인 Date의 문제점을 제대로 고친 타입이기 때문에
Java8일 경우 무조건 사용하는 것을 권장한다.

( STEP 1 )

build.gradle

//Spring Boot Overriding
ext['hibernate.version'] = '5.2.11.Final'

( STEP 2 )

BaseTimeEntity 생성

BaseTimeEntity클래스는 모든 Entity들의 상위 클래스가 되어 Entity들의 createdDate, modifiedDate를 자동으로 관리하는 역할이다.

```
@MappedSuperclass
```
JPA Entity 클래스들이 BaseTimeEntity을 상속할 경우 필드들(createdDate, modifiedDate)도 컬럼으로 인식하도록 한다.
```
@EntityListeners(AuditingEntityListener.class)
```
BaseTimeEntity클래스에 Auditing 기능을 포함시킨다.
```
@CreatedDate
```
Entity가 생성되어 저장될 때 시간이 자동 저장된다.
```
@LastModifiedDate
```
조회한 Entity의 값을 변경할 때 시간이 자동 저장된다.

( STEP 3 )

그리고 Posts클래스가 BaseTimeEntity를 상속받도록 변경한다.

...
public class Posts extends BaseTimeEntity {
    ...
}

( STEP 4 ) (꼭‼)

마지막으로 JPA Auditing 어노테이션들을 모두 활성화 시킬수 있도록
Application 클래스에 활성화 어노테이션 하나를 추가한다.

@EnableJpaAuditing // JPA Auditing 활성화
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

( STEP 5 ) (test)

assertTrue(posts.getCreatedDate().isAfter(LocalDateTime.now()));

[spring boot] 연락처 관리 프로젝트 (+TDD)

aonee — Sun, 26 Apr 2020 21:23:12 +0900

✔ 프로젝트 구조

✔MVC 패턴 (Model–View–Controller)

✔프로젝트 전체 코드 ( 깃허브 )

https://github.com/devAon/SpringBoot-Manage-Contact

✔ 프로젝트 코드 및 구현 내용 설명

build.gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.junit.platform:junit-platform-launcher:1.5.0'
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.0'
    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.5.0'
    testImplementation 'org.mockito:mockito-junit-jupiter'
}

Domain

- 실제 DB의 테이블과 매칭될 클래스

Person

@Entity
@NoArgsConstructor
@AllArgsConstructor
@RequiredArgsConstructor
@Data
@Where(clause = "deleted = false")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NonNull
    @NotEmpty
    @Column(nullable = false)
    private String name;

    private String hobby;

    private String address;

    @Valid
    @Embedded
    private Birthday birthday;

    private String job;

    private String phoneNumber;

    @ColumnDefault("0")
    private boolean deleted;

    public void set(PersonDto personDto) {
        if (!StringUtils.isEmpty(personDto.getHobby())) {
            this.setHobby(personDto.getHobby());
        }

        if (!StringUtils.isEmpty(personDto.getAddress())) {
            this.setAddress(personDto.getAddress());
        }

        if (!StringUtils.isEmpty(personDto.getJob())) {
            this.setJob(personDto.getJob());
        }

        if (!StringUtils.isEmpty(personDto.getPhoneNumber())) {
            this.setPhoneNumber(personDto.getPhoneNumber());
        }

        if (personDto.getBirthday() != null) {
            this.setBirthday(Birthday.of(personDto.getBirthday()));
        }
    }
}

@Entity

DB에 저장하기 위해 유저가 정의한 클래스. Domain

RDBMS에서 Table을 객체화 시킨 것

테이블과 연결될 클래스임을 나타냄
@Id

primary key를 가지는 변수 선언

@GeneratedValue

PK의 생성 규칙을 나타낸다.

기본값은 AUTO로 MySql의 auto_increment와 같이 자동증가하는 정수형 값

스프링부트 2.0 이전에는 자동으로 auto_increment가 됐지만

스프링부트 2.0 이후부터는 @GeneratedValue(strategy = GenerationType.Identity) 옵션을 줘야 auto_increment가 된다.

@Column

@Column에서 지정한 변수명과 DB컬럼명 다르게 주고 싶은 경우

(@Column(name=" ") 사용)

해당 어노테이션을 사용하지 않으면 기본적으로 멤버 변수명과 일치하는 DB컬럼을 매핑한다.

기본값 외 추가로 변경이 필요한 옵션 변경 가능. 예를들어 VARCHAR(255) -> VARCHAR(500) 수정
@NotNull : CharSequence, Collection, Map orArray의 객체가 null일 수 없다. 그러나 empty는 가능하다.
@NotEmpty :CharSequence, Collection, Map orArray의 객체가 null과 empty 값(size > 0)이 될 수 없다
@NotBlank: 'String'이 null일 수 없으며, legnth가 0보다 커야 한다.
@NoArgsConstructor

기본 생성자 자동 추가

옵션으로 access - AccessLevel.PROTECTED를 주면 기본생성자의 접근 권한을 protected로 제한할 수 있다.

Entitiy 클래스를 프로젝트 코드상에서 기본생성자로 생성하는 것은 막되,
JPA에서 Entity 클래스를 생성하는 것은 허용하기 위해 사용

@Getter

클래스 내 모든 필드의 Getter 메소드를 자동생성
@Builder

해당 클래스의 빌더패턴 클래스를 생성

생성자 상단에 선언시 생성자에 포함된 필드만 빌더에 포함

DTO

PersonDto

DTO(Data Transfer Object) 란?

dto package

- 계층간 데이터 교환을 위한 객체(Java Beans)이다.

즉, DB에서 데이터를 얻어 Service나 Controller 등으터 보낼 때 사용하는 객체이다.

- Request와 Response용 DTO는 View를 위한 클래스이다.

** 참고 : VO (Valaue Object ) vs DTO**

      VO : 특정한 비즈니스 값을 담는 객체

    DTO : 계층간 통신 용도로 오고가는 객체

@Data
@NoArgsConstructor
@AllArgsConstructor(staticName = "of")
public class PersonDto {
    @NotBlank(message = "이름은 필수값입니다")
    private String name;
    private String hobby;
    private String address;
    private LocalDate birthday;
    private String job;
    private String phoneNumber;
}

* 참고 : Entity 클리스와 DTO 클래스를 분리하는 이유 *

- View Layer와 DB Layer의 역할을 철저하게 분리하기 위해

- Entity 클래스 : 테이블과 매핑되기 때문에 변경시, 여러 클래스에 영향을 끼치게 된다.

- DTO 클래스 : View와 통신하는 클래스로 Request, Response 는 자주 변경된다.

따라서 분리해야한다.

Repository (=DAO)

DAO(Data Access Object) 란?

Repository package

- 실제 DB에 접근하는 객체로 DB에 data를 CRUD하는 계층인 Persistence Layer이다.

- Service와 DB 연결고리

ORM인 JPA를 사용하여 ( extends JpaRepository<Person, Long> ) 개발했다.

PersonRepository

public interface PersonRepository extends JpaRepository<Person, Long> {
    List<Person> findByName(String name);

    @Query(value = "select person from Person person 
                where person.birthday.monthOfBirthday = :monthOfBirthday")
    List<Person> findByMonthOfBirthday(@Param("monthOfBirthday") int monthOfBirthday);

    @Query(value = "select * from Person person 
                where person.deleted = true", nativeQuery = true)
    List<Person> findPeopleDeleted();
}

PersonRepositoryTest

@Transactional
@SpringBootTest
class PersonRepositoryTest {
    @Autowired
    private PersonRepository personRepository;

    @Test
    void findByName() {
        List<Person> people = personRepository.findByName("tony");
        assertThat(people.size()).isEqualTo(1);

        Person person = people.get(0);
        assertAll(
            () -> assertThat(person.getName()).isEqualTo("tony"),
            () -> assertThat(person.getHobby()).isEqualTo("reading"),
            () -> assertThat(person.getAddress()).isEqualTo("seoul"),
            () -> assertThat(person.getBirthday()).isEqualTo(Birthday.of(LocalDate.of(1991, 7, 10))),
            () -> assertThat(person.getJob()).isEqualTo("officer"),
            () -> assertThat(person.getPhoneNumber()).isEqualTo("010-2222-5555"),
            () -> assertThat(person.isDeleted()).isEqualTo(false)
        );
    }

    @Test
    void findByNameIfDeleted() {
        List<Person> people = personRepository.findByName("andrew");

        assertThat(people.size()).isEqualTo(0);
    }

    @Test
    void findByMonthOfBirthday() {
        List<Person> people = personRepository.findByMonthOfBirthday(7);

        assertThat(people.size()).isEqualTo(2);
        assertAll(
            () -> assertThat(people.get(0).getName()).isEqualTo("david"),
            () -> assertThat(people.get(1).getName()).isEqualTo("tony")
        );
    }

    @Test
    void findPeopleDeleted() {
        List<Person> people = personRepository.findPeopleDeleted();

        assertThat(people.size()).isEqualTo(1);
        assertThat(people.get(0).getName()).isEqualTo("andrew");
    }
}

Controller

PersonController

- 사용자의 요청이 진입하는 지점이다.

- 요청에 따른 처리를 결정한다.

- 사용자에게 view를 응답으로 보내준다.

@RequestMapping(value = "/api/person")
@RestController
public class PersonController {
    @Autowired
    private PersonService personService;

    @GetMapping("/{id}")
    public Person getPerson(@PathVariable Long id) {
        return personService.getPerson(id);
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public void postPerson(@RequestBody @Valid PersonDto personDto) {
        personService.postPerson(personDto);
    }

    @PutMapping("/{id}")
    public void modifyPerson(@PathVariable Long id, @RequestBody PersonDto personDto) {
        personService.modify(id, personDto);
    }

    @PatchMapping("/{id}")
    public void modifyPerson(@PathVariable Long id, String name) {
        personService.modify(id, name);
    }

    @DeleteMapping("/{id}")
    public void deletePerson(@PathVariable Long id){
        personService.delete(id);
    }
}

PersonControllerTest

@SpringBootTest
@Transactional
class PersonControllerTest {
    @Autowired
    private PersonRepository personRepository;
    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @BeforeEach
    void beforeEach() {
        mockMvc = MockMvcBuilders
                .webAppContextSetup(wac)
                .alwaysDo(print())
                .build();
    }

    @Test
    void getPerson() throws Exception {
        mockMvc.perform(
                MockMvcRequestBuilders.get("/api/person/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("aonee"))
                .andExpect(jsonPath("$.hobby").isEmpty())
                .andExpect(jsonPath("$.address").isEmpty())
                .andExpect(jsonPath("$.job").isEmpty())
                .andExpect(jsonPath("$.phoneNumber").isEmpty())
                .andExpect(jsonPath("$.deleted").value(false));
    }

    @Test
    void postPerson() throws Exception {
        PersonDto dto = PersonDto.of("aonee", "programming", "seoul", LocalDate.now(), "programmer", "010-1111-2222");

        mockMvc.perform(
                MockMvcRequestBuilders.post("/api/person")
                        .contentType(MediaType.APPLICATION_JSON_UTF8)
                        .content(toJsonString(dto)))
                .andExpect(status().isCreated());

        Person result = personRepository.findAll(Sort.by(Sort.Direction.DESC, "id")).get(0);

        assertAll(
                () -> assertThat(result.getName()).isEqualTo("aonee"),
                () -> assertThat(result.getHobby()).isEqualTo("programming"),
                () -> assertThat(result.getAddress()).isEqualTo("seoul"),
                () -> assertThat(result.getBirthday()).isEqualTo(Birthday.of(LocalDate.now())),
                () -> assertThat(result.getJob()).isEqualTo("programmer"),
                () -> assertThat(result.getPhoneNumber()).isEqualTo("010-1111-2222")
        );
    }

    @Test
    void modifyPerson() throws Exception {
        PersonDto dto = PersonDto.of("aonee", "programming", "seoul", LocalDate.now(), "programmer", "010-1111-2222");

        mockMvc.perform(
                MockMvcRequestBuilders.put("/api/person/1")
                        .contentType(MediaType.APPLICATION_JSON_UTF8)
                        .content(toJsonString(dto)))
                .andExpect(status().isOk());

        Person result = personRepository.findById(1L).get();

        assertAll(
                () -> assertThat(result.getName()).isEqualTo("aonee"),
                () -> assertThat(result.getHobby()).isEqualTo("programming"),
                () -> assertThat(result.getAddress()).isEqualTo("seoul"),
                () -> assertThat(result.getBirthday()).isEqualTo(Birthday.of(LocalDate.now())),
                () -> assertThat(result.getJob()).isEqualTo("programmer"),
                () ->assertThat(result.getPhoneNumber()).isEqualTo("010-1111-2222")
        );
    }


    @Test
    void deletePerson() throws Exception {
        mockMvc.perform(
                MockMvcRequestBuilders.delete("/api/person/1"))
                .andExpect(status().isOk());

        assertTrue(personRepository.findPeopleDeleted().stream().anyMatch(
                person -> person.getId().equals(1L)));
    }

    private String toJsonString(PersonDto personDto) throws JsonProcessingException {
        return objectMapper.writeValueAsString(personDto);
    }

}

Controller에서

-return 값이 void인 경우(post, modify, delete)에는assertThat, assertAll을 통해 검증을 한다.

뿐만 아니라, Repository값을 가져와DB값을 통해 검증한다.

-return 값이 있는 경우(get) 에는andExpect를 통해 검증한다.

뿐만 아니라, DB값이 아닌,return되는 값을 통해 검증한다.

get에서 return되는 값은json 형식을 가지고 있기 때문에jsonPath를 통해 key, value를 검증한다.

ex ) .andExpect(jsonPath("$.name").value("martin"))은

   **key 인("$.name") : **return된 객체의 name속성

   **value인****.value("martin")) :**  name 속성의 값으로 예측되는 테스트 값

** ex 2) .andExpect(jsonPath("$.hobby").isEmpty())**은

   **.isEmpty() :**value가 비어있다.

@SpringBootTest 란?

@ExtendWith(SpringExtension.class)스프링관련 기능을 사용해서 테스트를 진행한다는 의미이다.

@AutoWired 을 사용해 각 상황의 타입에 맞는 IoC컨테이너 안에 존재하는 Bean을 자동으로 주입한다.

Service

PersonService

- @Autowired Repository를 통해 repository의 method를 이용

- DAO클래스를 통해 DB연동을 처리한다.

- DAO로 DB에 접근하고 DTO로 데이터를 전달받은 다음, 비지니스 로직을 처리해 적절한 데이터를 반환한다.

@Slf4j
@Service
public class PersonService {

    @Autowired
    private PersonRepository personRepository;


    @Transactional(readOnly = true)
    public Person getPerson(Long id) {
        return personRepository.findById(id).orElse(null);
    }


    @Transactional
    public void postPerson(PersonDto personDto) {
        Person person = new Person();
        person.set(personDto);
        person.setName(personDto.getName());

        personRepository.save(person);
    }

    @Transactional
    public void modify(Long id, PersonDto personDto) {
        Person person = personRepository.findById(id).orElseThrow(PersonNotFoundException::new);

        if (!person.getName().equals(personDto.getName())) {
            throw new RenameIsNotPermittedException();
        }

        person.set(personDto);

        personRepository.save(person);
    }

    @Transactional
    public void modify(Long id, String name) {
        Person person = personRepository.findById(id).orElseThrow(PersonNotFoundException::new);

        person.setName(name);

        personRepository.save(person);
    }

    @Transactional
    public void delete(Long id) {
        Person person = personRepository.findById(id).orElseThrow(PersonNotFoundException::new);

        person.setDeleted(true);

        personRepository.save(person);
    }
}

PersonServiceTest

@ExtendWith(MockitoExtension.class)
class PersonServiceTest {
    @InjectMocks
    private PersonService personService;

    @Mock
    private PersonRepository personRepository;


    @Test
    void getPerson(){
        when(personRepository.findById(1L))
                .thenReturn(Optional.of(new Person("martin")));

        Person person = personService.getPerson(1L);

        assertThat(person.getName()).isEqualTo("martin");
    }

    @Test
    void postPerson(){
        personService.postPerson(mockPersonDto());

        verify(personRepository, times(1)).save(argThat(new IsPersonWillBeInserted()));
    }

    @Test
    void modify() {
        when(personRepository.findById(1L))
                .thenReturn(Optional.of(new Person("aonee")));

        personService.modify(1L, mockPersonDto());

        verify(personRepository, times(1)).save(argThat(new IsPersonWillBeUpdated()));
    }


    @Test
    void modifyByNameIfPersonNotFound() {
        when(personRepository.findById(1L))
                .thenReturn(Optional.empty());

        assertThrows(PersonNotFoundException.class, () -> personService.modify(1L, "daniel"));
    }

    @Test
    void modifyByName(){
        when(personRepository.findById(1L))
                .thenReturn(Optional.of(new Person("martin")));

        personService.modify(1L, "daniel");

        verify(personRepository, times(1)).save(argThat(new IsNameWillBeUpdated()));
    }

    @Test
    void delete(){
        when(personRepository.findById(1L))
                .thenReturn(Optional.of(new Person("martin")));

        personService.delete(1L);

        verify(personRepository, times(1)).save(argThat(new IsPersonWillBeDeleted()));
    }

    private PersonDto mockPersonDto() {
        return PersonDto.of("aonee", "programming", "seoul", LocalDate.now(), "programmer", "010-1111-2222");
    }
}

build.gradle 에 해당 코드 추가

testImplementation 'org.mockito:mockito-junit-jupiter'

- Mock 테스트 개념 정리

@ExtendWith(MockitoExtension.class))

Spring이 아닌 Mockito관련 기능을 사용해서 테스트를 진행한다는 의미이다.

그리고 이제는MockitoExtension)을 사용하고 더이상 스프링 컨텍스트는 사용하지 않기 때문에

@AutoWired는 아무런 동작을 하지 않는다.

대신,@InjectMocks는 테스트의 대상이 되는 클래스에 붙여주면 된다.

@Mock는 테스트의 대상이 되는 클래스에서@AutoWired 하고 있는 클래스에 붙여주면 된다.

그러면@Mock 이 붙은 클래스를 Mock으로 만들어서@InjectMocks 클래스에 주입해준다.

기존에 Spring context를 사용할 때는 data.sql을 통해 DB에 들어있는 값을 조회했던 것과 달리

@Mock 에는 빈껍데기로 아무런 동작을 하지 않는다. 따라서, 테스트를 위해서는 직접 지정해줘야 한다.

(EX)

when(personRepository.findByName("martin"))
.thenReturn(Lists.newArrayList(new Person("martin")));

when ?

if와 같은 의미. 만약(personRepository.findByName("martin"))호출되면 (실제 호출이 아닌 가정이다.)

thenReturn ?

Lists.newArrayList(new Person("martin") 리턴한다

@SpringBootTest로 만들었다면 각 테스트케이스에 맞는 DB 데이터로 만들었어야한다.

그러나 Mock Test를 통해 보다 간단하게 구현할 수 있었다.

분기문이 많이 나오는 로직일 수록@SpringBootTest 적용하기 더 힘들다.

- Mock 테스트에서 정확하게 검증하는 방법

1.

verify는 post와 같이 return값이 void인 경우에 사용한다.

verify를 사용하지 않을 경우, 올바르게 테스트되었는지 검증할 수 없다.

verify(personRepository, times(1)).save(argThat(new IsPersonWillBeInserted()));

2. PersonService에서

@Transactional
public voidmodify(Long id,String name) {
Person person =personRepository.findById(id).orElseThrow(PersonNotFoundException::new);

person.setName(name)**;**

personRepository.save(person);
}

person.setName(name)**;**해당 코드는 없어서는 안될 핵심 역할을 하는 코드이다.

그런데, 주석처리를 해도 test가 통과한다. 이러한 문제를 해결하기 위해

PersonServiceTest에IsPersonWillBeUpdated 생성

private static class IsPersonWillBeUpdated implements ArgumentMatcher {
@Override
public boolean matches(Person person) {
return equals(person.getName(), "martin")
&& equals(person.getHobby(), "programming")
&& equals(person.getAddress(), "판교")
&& equals(person.getBirthday(), Birthday.of(LocalDate.now())))
&& equals(person.getJob(), "programmer")
&& equals(person.getPhoneNumber(), "010-1111-2222");
}

    private boolean **equals**(Object actual, Object expected) {  
        return [expected.equals(actual);](expected.equals(actual);)  
    }  
}

PersonServiceTest의 modify 테스트에

verify(personRepository,times(1)).save(argThat(newIsPersonWillBeUpdated()));

이처럼 검증을 해주면 된다.

service - argumentmatcher

IsNameWillBeUpdated

public class IsNameWillBeUpdated implements ArgumentMatcher<Person> {
    @Override
    public boolean matches(Person person) {
        return person.getName().equals("daniel");
    }
}

IsPersonWillBeDeleted

public class IsPersonWillBeDeleted implements ArgumentMatcher<Person> {
    @Override
    public boolean matches(Person person) {
        return person.isDeleted();
    }
}

IsPersonWillBeInserted

public class IsPersonWillBeInserted implements ArgumentMatcher<Person> {
    @Override
    public boolean matches(Person person) {
        return equals(person.getName(), "aonee")
                && equals(person.getHobby(), "programming")
                && equals(person.getAddress(), "seoul")
                && equals(person.getBirthday(), Birthday.of(LocalDate.now()))
                && equals(person.getJob(), "programmer")
                && equals(person.getPhoneNumber(), "010-1111-2222");
    }

    private boolean equals(Object actual, Object expected) {
        return expected.equals(actual);
    }
}

IsPersonWillBeUpdated

public class IsPersonWillBeUpdated implements ArgumentMatcher<Person> {
    @Override
    public boolean matches(Person person) {
        return equals(person.getName(), "aonee")
                && equals(person.getHobby(), "programming")
                && equals(person.getAddress(), "seoul")
                && equals(person.getBirthday(), Birthday.of(LocalDate.now()))
                && equals(person.getJob(), "programmer")
                && equals(person.getPhoneNumber(), "010-1111-2222");
    }

    private boolean equals(Object actual, Object expected) {
        return expected.equals(actual);
    }
}

application.yml

spring:
jpa:
show-sql: true

application.properties를 application.yml로 변경
why? 상대적으로 유연한 구조를 가졌기 때문
yml은 상위 계층에 대한 표현, List 등을 완전하게 표현할수가 있다. 또한, 최근의 많은 도구들이 yml 설정을 지원한다

test - resources - data.sql

@SpringBootTest 를 위해

insert into person(`id`, `name`, `year_of_birthday`, `month_of_birthday`, `day_of_birthday`) values (1, 'aonee', 1991, 8, 15);
insert into person(`id`, `name`, `year_of_birthday`, `month_of_birthday`, `day_of_birthday`) values (2, 'david', 1992, 7, 21);
insert into person(`id`, `name`, `year_of_birthday`, `month_of_birthday`, `day_of_birthday`) values (3, 'dennis', 1993, 10, 15);
insert into person(`id`, `name`, `year_of_birthday`, `month_of_birthday`, `day_of_birthday`) values (4, 'sophia', 1994, 8, 31);
insert into person(`id`, `name`, `year_of_birthday`, `month_of_birthday`, `day_of_birthday`) values (5, 'benny', 1995, 12, 23);
insert into person(`id`, `name`, `year_of_birthday`, `month_of_birthday`, `day_of_birthday`, `job`, `hobby`, `phone_number`, `address`)
    values (6, 'tony', 1991, 7, 10, 'officer', 'reading', '010-2222-5555', 'seoul');
insert into person(`id`, `name`, `deleted`) values (7, 'andrew', true);

Exception

- dto

ErrorResponse

@Data
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class ErrorResponse {
    private int code;
    private String message;

    public static ErrorResponse of(HttpStatus httpStatus, String message) {
        return new ErrorResponse(httpStatus.value(), message);
    }

    public static ErrorResponse of(HttpStatus httpStatus, FieldError fieldError) {
        if (fieldError == null) {
            return new ErrorResponse(httpStatus.value(), "invalid params");
        } else {
            return new ErrorResponse(httpStatus.value(), fieldError.getDefaultMessage());
        }
    }
}

PersonNotFoundException

@Slf4j
public class PersonNotFoundException extends RuntimeException {
    private static final String MESSAGE = "Person Entity가 존재하지 않습니다";

    public PersonNotFoundException() {
        super(MESSAGE);
        log.error(MESSAGE);
    }
}

RenameIsNotPermittedException

@Slf4j
public class RenameIsNotPermittedException extends RuntimeException {
    private static final String MESSAGE = "이름 변경이 허용되지 않습니다";

    public RenameIsNotPermittedException() {
        super(MESSAGE);
        log.error(MESSAGE);
    }
}

✔TEST 결과 확인 ( 모두 통과 ! 예 ! 에--! ‍♀️ )

TDD (Test Driven Development 테스트 주도 개발 : 테스트가 개발을 이끌어 나간다 )

테스트 주도 개발을 함께 하려다 보니 신경 쓸 부분이 많아져 개발하는데 시간이 배로 걸렸다.
무엇보다 JPA 와 TDD를 처음 공부하다 보니 더욱 그랬던 것 같다.
직접 TDD를 해보니 개발을 하다 중요한 로직에서 취약한 실수가 있었다.

자칫 모르고 넘어갈 수 있었던 문제였는데 테스트를 통해 바로잡을 수 있었다.

이를 통해, TDD의 중요성을 크게 느꼈다.
사실 처음에는 그저 내가 작성한 테스트가 통과되면 좋겠다는 생각으로 간략하게 작성했다.
그러나 나중에 보니 핵심로직에 제대로 된 검증을 하지 않고 있었다.
무용지물 한 테스트 코드를 작성하고 있었던 것이었다. (~~이럴거면 테스트 왜 해 ‍♀️~~)
이후로는 올바른 검증을 하는 테스트 코드를 작성하기 위해 노력했다.
올바르게 작동하는 깔끔한 코드를 만들기 위해 ! ! ! !
자연스럽게 TEST 코드를 작성하는 날이 올 때까지 꾸준히 공부해야겠다.

[spring] TDD (테스트 주도 개발) 방법

aonee — Sun, 19 Apr 2020 18:14:32 +0900

TDD ? ( Test Driven Development )

선 테스트코드 작성 후 실제 코드 개발

구현 -> 테스트 -> 리펙토링

Development

-목표주도개발
-사용자 중심 개발
-인터페이스 중심 개발

목표?

-올바르게 작동 -test
-깔끔한 코드 - 이때 refactoring

TDD 3가지 cycle

Red - 실패
Green - 성공
Refactoring test 코드 리팩터링.

TDD 만드는 방법

test파일 만들고싶은 파일에서-goto-test

예시

Controller TDD

HelloWorldController.java

@RestController
public class HelloWorldController {
    @GetMapping("/api/helloworld")
    public String helloWord(){
        return "HelloWorld";
    }
}

ctrl+shitft + R 로 테스트 클래스 생성

HelloWorldControllerTest.java

package com.devaon.managecontact.controller;

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;


@SpringBootTest
class HelloWorldControllerTest {

    @Autowired
    private HelloWorldController helloWorldController;

    //모의 http request, response 만들어 테스트 진행하도록 해줌
    private MockMvc mockMvc;

    //단지 메소드 호출 테스트
    @Test
    public void helloWorld() {
        System.out.println(helloWorldController.helloWord());

        assertThat(helloWorldController.helloWord()).isEqualTo("HelloWorld");
    }

    //실제 http 테스트
    @Test
    public void mockMvcHelloWorld() throws Exception {

        //MockMvc setting
        mockMvc = MockMvcBuilders.standaloneSetup(helloWorldController).build();

        //실제 동작하도록 요청
        mockMvc.perform(
                //get 메소드로 요청
                MockMvcRequestBuilders.get("/api/helloworld")
        ).andDo(MockMvcResultHandlers.print())
         .andExpect(MockMvcResultMatchers.status().isOk())
         .andExpect(MockMvcResultMatchers.content().string("HelloWorld"));
    }
}

*MockMvc *

http request, response 만들어 테스트 진행하도록 해준다

MockMvc 세팅

mockMvc = MockMvcBuilders.standaloneSetup(helloWorldController).build();

실제 동작하도록 요청

mockMvc.perform

get/post/put/patch/delete 메소드로 요청

MockMvcRequestBuilders.get("api/helloworld")

Request와 Response에 대해 구체적인 정보를 노출

.andDo(MockMvcResultHandler.print)

자동화된 결과 체크

andExpect(MockMvcResultMatchers )

status가 200 성공했는지 확인

.andExpect(MockMvcResultMatchers.status().isOk())

response의 body 값이 HelloWorld인지 확인

.andExpect(MockMvcResultMatchers.content().string("HelloWorld"))

TDD 예시 프로젝트

[spring boot] 연락처 관리 프로젝트 (+TDD)

https://aonee.tistory.com/64?category=369754

[spring boot] 연락처 관리 프로젝트 (+TDD)

✔ 프로젝트 구조 ✔ MVC 패턴 (Model–View–Controller) ✔ 프로젝트 전체 코드 ( 깃허브 ) https://github.com/devAon/SpringBoot-Manage-Contact ✔ 프로젝트 코드 및 구현 내용 설명 buil..

aonee.tistory.com

✔ 프로젝트 전체 코드 ( 깃허브 )

https://github.com/devAon/SpringBoot-Manage-Contact

[Spring] jpa, Hibernate, mybatis 란? 그리고 SQL Mapper와 ORM

aonee — Sun, 19 Apr 2020 18:12:40 +0900

1. 계층 - 영속성(Persistence)

계층 참고

프레젠테이션 계층 (Presentation layer) - UI 계층 (UI layer) 이라고도 함
애플리케이션 계층 (Application layer) - 서비스 계층 (Service layer) 이라고도 함
비즈니스 논리 계층 (Business logic layer) - 도메인 계층 (Domain layer) 이라고도 함
데이터 접근 계층 (Data access layer) - 영속 계층 (Persistence layer) 이라고도 함

Persistence Framework
JDBC 프로그래밍의 복잡함이나 번거로움 없이 간단한 작업만으로 데이터베이스와 연동되는 시스템을 빠르게 개발할 수 있으며 안정적인 구동을 보장한다.
Persistence Framework는 SQL Mapper와 ORM으로 나눌 수 있다.
아래 참고
Ex) JPA, Hibernate, Mybatis 등

2. SQL Mapper와 ORM

Persistence Framework는 SQL Mapper와 ORM으로 나눌 수 있다.

ORM은 데이터베이스 객체를 자바 객체로 매핑함으로써 객체 간의 관계를 바탕으로 SQL을 자동으로 생성해주지만 SQL Mapper는 SQL을 명시해줘야 한다.
ORM은 관계형 데이터베이스의 ‘관계’를 Object에 반영하자는 것이 목적이라면, SQL Mapper는 단순히 필드를 매핑시키는 것이 목적이라는 점에서 지향점의 차이가 있다.

SQL Mapper
SQL <—매핑—> Object 필드
SQL Mapper는 SQL 문장으로 직접 데이터베이스 데이터를 다룬다.
즉, SQL Mapper는 SQL을 명시해줘야 한다.
Ex) Mybatis, JdbcTempletes 등
ORM(Object-Relational Mapping), 객체-관계 매핑
데이터베이스 데이터 <—매핑—> Object 필드
객체를 통해 간접적으로 데이터베이스 데이터를 다룬다.
객체와 관계형 데이터베이스의 데이터를 자동으로 매핑(연결)해주는 것을 말한다.
ORM을 이용하면 SQL Query가 아닌 직관적인 코드(메서드)로 데이터를 조작할 수 있다.
객체 간의 관계를 바탕으로 SQL을 자동으로 생성한다.
Persistant API라고도 할 수 있다.
Ex) JPA, Hibernate 등
ORM의 장단점 참고

3. JDBC(Java Database Connectivity)

JDBC는 DB에 접근할 수 있도록 Java에서 제공하는 API이다.
모든 Java의 Data Access 기술의 근간
즉, 모든 Persistence Framework는 내부적으로 JDBC API를 이용한다.
JDBC는 데이터베이스에서 자료를 쿼리하거나 업데이트하는 방법을 제공한다.
Plain JDBC vs Spring JDBC 참고

4. JPA (Java Persistence API)

자바 ORM 기술에 대한 API 표준 명세로, Java에서 제공하는 API이다.
- 자바 플랫폼 SE와 자바 플랫폼 EE를 사용하는 응용프로그램에서 관계형 데이터베이스의 관리를 표현하는 자바 API이다.
- 즉, JPA는 ORM을 사용하기 위한 표준 인터페이스를 모아둔 것이다.
- 기존에 EJB에서 제공되던 엔터티 빈(Entity Bean)을 대체하는 기술이다.
자바 어플리케이션에서 관계형 DB를 사용하는 방식을 정의한 인터페이스. 라이브러리가 아니다.
JPA 구성 요소 (세 가지)
- 1) javax.persistance 패키지로 정의된 API 그 자체
- 2) JPQL(Java Persistence Query Language)
- 3) 객체/관계 메타데이터
사용자가 원하는 JPA 구현체를 선택해서 사용할 수 있다.
- JPA의 대표적인 구현체로는 Hibernate, EclipseLink, DataNucleus, OpenJPA, TopLink Essentials 등이 있다.
- 이 구현체들을 ORM Framework라고 부른다.
JPA 처리를 담당하는 Repository는 기본적으로 4가지가 있다.

(T : @Entity의 타입클래스/ ID : P.K 값의 Type )

Repository<T, ID>
CrudRepository<T, ID>
PagingAndSortingRepository<T, ID>
JpaRepository<T, ID>

JPA 사용법
- @Entity
  
  DB에 저장하기 위해 유저가 정의한 클래스. Domain
  
  RDBMS에서 Table을 객체화 시킨 것
- @Id
  
  primary key를 가지는 변수 선언
  
  @GeneratedValue 는 해당 ID값을 어떻게 자동으로 생성할지 전략을 선택할 수 있는데 기본값은 'AUTO' 이다.
- @Column
  
  @Column에서 지정한 변수명과 DB컬럼명 다르게 주고 싶은 경우
  
  (@Column(name=" ") 사용)
  
  해당 어노테이션을 사용하지 않으면 기본적으로 멤버 변수명과 일치하는 DB컬럼을 매핑한다.
- *@NotNull *: CharSequence, Collection, Map orArray의 객체가 null일 수 없다. 그러나 empty는 가능하다.
- @NotEmpty :CharSequence, Collection, Map orArray의 객체가 null과 empty 값(size > 0)이 될 수 없다
- @NotBlank: 'String'이 null일 수 없으며, legnth가 0보다 커야 한다.
JPA는 메소드의 이름만으로 원하는 쿼리(Select)를 실행하는 방법을 제공

Query 메소드를 추가하여 스프링에게 알릴 수 있다.

그러기위해서는 규칙에 맞는 메서드를 작성해야 하는데, 그 규칙은 다음과 같다
- find...By...
- read...By...
- query...By...
- get...By...
- count...By...

Query 메소드에 포함할 수 있는 키워드는 다음과 같다.

Pageable 변수를 추가하면 Page타입을 반환형으로 사용할 수 있다.

Pageable 객체를 통해 페이징과 정렬을 위한 파라미터를 전달한다.

Page<Member> getMembers(Pageable pageable){

위와 같이 작성된 Pageable에서는 다음과 같은 파라미터를 자동 수집한다.

의존성 추가

<dependencies>
  <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
  </dependency>
<dependencies>

5. Hibernate

JPA의 구현체

Hibernate는 JPA의 구현체 중 하나이다.
Hibernate가 SQL을 직접 사용하지 않는다고 해서 JDBC API를 사용하지 않는다는 것은 아니다.
- Hibernate가 지원하는 메서드 내부에서는 JDBC API가 동작하고 있으며, 단지 개발자가 직접 SQL을 직접 작성하지 않을 뿐이다.
HQL(Hibernate Query Language)이라 불리는 매우 강력한 쿼리 언어를 포함하고 있다.
- HQL은 SQL과 매우 비슷하며 추가적인 컨벤션을 정의할 수도 있다.
- HQL은 완전히 객체 지향적이며 이로써 상속, 다형성, 관계등의 객체지향의 강점을 누릴 수 있다.
- HQL쿼리는 자바 클래스와 프로퍼티의 이름을 제외하고는 대소문자를 구분한다.
- HQL은 쿼리 결과로 객체를 반환하며 프로그래머에 의해 생성되고 직접적으로 접근할 수 있다.
- HQL은 SQL에서는 지원하지 않는 페이지네이션이나 동적 프로파일링과 같은 향상된 기능을 제공한다.
- HQL은 여러 테이블을 작업할 때 명시적인 join을 요구하지 않는다.
장점
- 객체지향적으로 데이터를 관리할 수 있기 때문에 비즈니스 로직에 집중 할 수 있으며, 객체지향 개발이 가능하다.
- 테이블 생성, 변경, 관리가 쉽다. (JPA를 잘 이해하고 있는 경우)
- 로직을 쿼리에 집중하기 보다는 객체자체에 집중 할 수 있다.
- 빠른 개발이 가능하다.
단점
- 어렵다. (많은 내용이 감싸져 있기 때문에 알아야 할 것이 많다.)
- 잘 이해하고 사용하지 않으면 데이터 손실이 있을 수 있다. (persistence context)
- 성능상 문제가 있을 수 있다. (이 문제 또한 잘 이해해야 해결이 가능하다.)

6. Mybatis

개발자가 지정한 SQL, 저장 프로시저 그리고 몇 가지 고급 매핑을 지원하는 SQL Mapper이다.
JDBC로 처리하는 상당 부분의 코드와 파라미터 설정 및 결과 매핑을 대신해준다.
기존에 JDBC를 사용할 때는 DB와 관련된 여러 복잡한 설정(Connection)들을 다루어야 했지만 SQL Mapper는 자바 객체를 실제 SQL문에 연결함으로써, 빠른 개발과 편리한 테스트 환경을 제공한다.
데이터베이스 record에 원시 타입과 Map 인터페이스 그리고 자바 POJO를 설정해서 매핑하기 위해 xml과 Annotation을 사용할 수 있다.
MyBatis는 원래 Apache Foundation의 iBatis였으나, 생산성, 개발 프로세스, 커뮤니티 등의 이유로 Google Code로 이전되면서 이름이 바뀌었다.
iBatis와 바뀐 차이점은 아래와 같다.
JDK 1.5, Annotation
Dynatic SQL, XML Element
장점
SQL에 대한 모든 컨트롤을 하고자 할때 매우 적합하다.
SQL쿼리들이 매우 잘 최적화되어 있을 때에 유용하다.
단점
애플리케이션과 데이터베이스 간의 설계에 대한 모든 조작을 하고자 할 때는 적합하지 않다.
애플리케이션과 데이터베이스 간에 서로 잘 구조화되도록 많은 설정이 바뀌어야 하기 때문이다.

참고

https://gmlwjd9405.github.io/2018/12/25/difference-jdbc-jpa-mybatis.html https://gmlwjd9405.github.io/2018/12/25/difference-jdbc-jpa-mybatis.html)

[Spring] 설정 및 구현 - 생명주기, MVC

aonee — Sun, 12 Apr 2020 23:47:59 +0900

1. 빈(Bean) 객체의 생명주기(Life Cycle)

2. 어노테이션을 이용한 스프링 설정

3. 웹 프로그래밍 설계 모델

4. 스프링 MVC 웹서비스

5. STS를 이용하지 않은 웹 프로젝트

6. Service & Dao 객체 구현

7. Controller 객체 구현

1. 빈(Bean) 객체의 생명주기(Life Cycle)

스프링 컨테이너 생성시점과 빈객체의 생성시점은 동일하다.

2. 어노테이션을 이용한 스프링 설정

3. 웹 프로그래밍 설계 모델

13-1 웹프로그래밍을 구축하기 위한설계모델

13-2 스프링MVC플레임워크 설계 구조

13-3 DispatcherServlet 설정

13-4 Controller 객체 -@Controller

13-5 Controller 객체 -@RequestMapping

13-6 Controller 객체 –Model 타입의 파라미터

13-7 View 객체

13-8 전체적인 웹프로그래밍 구조

동작

1. Client -> DispatcherServlet 으로 요청 (Request )

2. DispatcherServlet -> HandlerMapping 가장 적합한 Controller를 찾음

3. HandlerAdapter -> Controller 요청처리 -> DispatcherServlet 찾아준 Controller 안에 가장 적합한 메소드 찾음

4. DispatcherServlet -> ViewResolver 처리결과에 해당하는 View(JSP)가 어떤 것인지 찾아줌

5. DispatcherServlet -> View 응답 생성

6. View -> Client 화면에 응답

4. 스프링 MVC 웹서비스

STS를이용한 웹프로젝트 생성

15-1 프로젝트 전체구조

15-2 web.xml

15-3 DispatcherServlet

15-4 servlet-context.xml

15-5 Controller(컨트롤러)

15-6 View(뷰)

web.xml

DispatcherServlet 설정

<!-- Processes application requests -->
	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
		
	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

서버에 한글깨지지 않도록 설정

<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>
			org.springframework.web.filter.CharacterEncodingFilter     
		</filter-class>
		<init-param>
			<param-name>encoding</param-name>   
			<param-value>UTF-8</param-value>
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>  
			<param-value>true</param-value>
		</init-param>
	</filter>    

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

web.xml

서블릿으로 등록 될 때contextConfigLocation이름으로초기화 파라미 터를 servlet-context.xml로 지정하고 있는데 이때 지정된 servlet-context.xml파일이 스프링 설정의 역할을 하는 파일이다.

<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
		</init-param>

servlet-context.xml

프로젝트에 필요한 객체(빈:bean) 를생성하고 조립한다.

<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

7. Controller 객체 구현

18-1 웹어플리케이션 준비

18-2 @RequestMapping을이용한 URL맵핑

18-3 요청파라미터

19-1 @ModelAttribute

19-2 커맨드객체 프로퍼티 데이터타입

19-3 Model & ModelAndViewspring

Controller -> Service -> Dao

MemberController.java

@Controller
@RequestMapping("/member")
public class MemberController {

	@Autowired
	MemberService service;
    
    @RequestMapping(value = "/memJoin", method = RequestMethod.POST)
	public String memJoin(Member member) {
		
		service.memberRegister(member);
		
		return "memJoinOk";
	}
}

MemberService.java

public interface MemberService{
	void memberRegister( Member member );
}

MemberServiceImpl.java

@Service
public class MemberServiceImpl implements MemberService{
	@AutoWired
    MemberDao dao;
    
    @Override
    public void memberRegister (Member member)
    {
    	printMembers(dao.memberInsert(member));
    }
}

MemberDao.java

public interface MemberDao{
	Map<String, Member> memberInsert (Member member);
}

MemberDaoImpl.java

@Repository
public class MemberDaoImpl implements MemberDao{
	private HashMap<String, Member> dbMap;
    
    public MemberDaoImpl(){
    	dbMap = new HashMap<String, Member>
    }
    
    @Override
    public Map<String, Member> memberInsert (Member member){
    	dbMap.put(member.getMemId(), member);
        return dbMap;
    }
}

[Android] MVVM 패턴 적용해보며 배우기(2) - RxJava2

aonee — Wed, 8 Apr 2020 19:10:50 +0900

RxJava 란?

Reactive Extensions
비동기 이벤트 기반 프로그래밍 라이브러리
매 이벤트마다 그에 대응하는 동작을 정의하는 기존의 이벤트 처리 방식인 콜백 방식과 달리

*발생하는 이벤트를 이벤트 스트림에 전달하고, *

이벤트 스트림을 관찰하다가 원하는 이벤트를 감지하면 이에 따른 동작을 수행하는 방식

RxJava 장점

비동기 이벤트를 매우 쉽게 처리 가능
이벤트나 데이터를 쉽게 가공 및 분배 가능

Observable과 Observer

옵서버블(Observable) ?
- _이벤트를 만들어내는(emit) 주체_로, 이벤트 스트림을 통해 만든 이벤트를 내보낸다.
옵서버(Observer) ?

옵서버블에서 만들어진 _이벤트에 반응(react)_하며, 이벤트를 받았을 때 수행할 작업을 정의한다.

이때, 옵서버가 옵서버블에서 만들어진 이벤트에 반응하려면

옵서버블에서 발생하는 이벤트를 옵서버가 관찰해야하는데,

이를 '옵서버가 옵서버블을 구독(subscribe)한다'라고 표현한다.

Scheduler

작업을 수행할 스레드(thread)를 지정한다.
스케쥴러는 observerOn() 메소드를 사용하여 지정하며,

이 메소드를 호출한 직후에 오는 연산자나 옵서버에서 수행되는 작업이

앞의 observerOn() 메소드에서 지정한 스레드에서 실행된다.

Disposable

옵서버가 옵서버블을 구독할 때 생성되는 객체로,

옵서버블에서 만드는 이벤트 스트림과 이에 필요한 리소스를 관리한다.
옵서버블로부터 더 이상 이벤트를 받지 않으려면 디스포저블을 통해 구독 해제(unsubscribe)를 할 수 있다.

옵서버블은 이를 감지해 자신을 구독하고 있는 옵서버가 더 이상 없는 경우 이벤트를 만들기 위해 유지하고 있던 리소스(ex: 뷰에 대한 참조 등)을 해제한다.

실습 - RxJava2 적용

Retrofit을 통해 받는 HTTP 응답을 Observable 형태로 받도록 수정

1) build.gradle (Module.app) 에 아래 코드를 추가

implementation "com.squareup.retrofit2:adapter-rxjava2:2.5.0"
    // RxAndroid와 RxJava 라이브러리를 추가
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
    implementation 'io.reactivex.rxjava2:rxjava:2.1.3'

2) 데이터 처리부 수정

AndBuddyService.kt

Call -> Observable 로 수정

interface AndBuddyService {
    @POST("/users/signup")
    fun postSignupUser(
        @Body() body: JsonObject
    ): Observable<PostSignupData>
}

AndBuddyServiceImpl.kt

.addCallAdapterFactory(RxJava2CallAdapterFactory.createAsync()) 추가

object AndBuddyServiceImpl {
    private const val BASE_URL = "http://15.164.70.24:3456/"

    private val okHttpClient: OkHttpClient =
        OkHttpClient.Builder().addInterceptor(CookiesIntercepter())
            .addNetworkInterceptor(CookiesIntercepter()).build()

    private val retrofit: Retrofit =
        Retrofit.Builder().baseUrl(BASE_URL).client(
            okHttpClient
        )
            .addCallAdapterFactory(RxJava2CallAdapterFactory.createAsync())
            .addConverterFactory(GsonConverterFactory.create())
            .build()

    val service: AndBuddyService = retrofit.create(
        AndBuddyService::class.java)
}

3) 통신하는 부분 수정

옵서버블을 사용하여 API 호출 결과를 받을 것이기 때문에 Call 객체를 디스포저블 객체로 수정해야한다.

data 부분

RemoteDataSource.kt

interface RemoteDataSource { 
    fun signUp(jsonObject: JsonObject) : Observable<PostSignupData>
}

RetmoteDataSourceImpl.kt

class RemoteDataSourceImpl : RemoteDataSource { 
   val api = AndBuddyServiceImpl.service

   override fun signUp(body: JsonObject) = api.postSignupUser(body).map{it}
}

SignupRepository.kt

class SignupRepository{
    val signupRemoteDataSource: RemoteDataSource = RemoteDataSourceImpl() //인스턴스 생성

    fun signUp( body: JsonObject ) : Observable<PostSignupData> =
        signupRemoteDataSource.signUp(body)
}

UI 부분

SignupViewModel.kt

class SignupViewModel : ViewModel() {
    val signupRepository = SignupRepository()

    internal val disposables = CompositeDisposable()

    val isSuccessNetwork = MutableLiveData<Boolean>()
    val wifiDisconnect = MutableLiveData<Unit>()

    fun viewCommunicate(body: JsonObject) {
        disposables.add(signupRepository.signUp(body)
            .observeOn(AndroidSchedulers.mainThread())
            // 구독할 때 수행할 작업을 구현
            .doOnSubscribe {}
            // 스트림이 종료될 때 수행할 작업을 구현
            .doOnTerminate {}
            // 옵서버블을 구독
            .subscribe({
                // API를 통해 액세스 토큰을 정상적으로 받았을 때 처리할 작업을 구현
                // 작업 중 오류가 발생하면 이 블록은 호출되지 x

                // onResponse

                //if (it.isSuccessful){
                    isSuccessNetwork.value = true

                /*}else{ //아이디 중복
                    isSuccessNetwork.value = false

                    Log.d("test",  "아이디중복: " + it.message())
                }*/

            }) {
                // 에러 블록
                // 네트워크 오류나 데이터 처리 오류 등
                // 작업이 정상적으로 완료되지 않았을 때 호출


                // onFailure
                Log.d("test",  "통신 실패 error : " + it.toString())
                wifiDisconnect.value = Unit
            })
    }

    override fun onCleared() {
        disposables.clear()
        super.onCleared()
    }
}

[Android] MVVM 패턴 적용해보며 배우기(1) - ACC, MVC와 MVVM비교, MVVM 장점

aonee — Tue, 7 Apr 2020 01:25:31 +0900

안드로이드 아키텍쳐 컴포넌트

안드로이드 아키텍쳐 컴포넌트(Android Architecture Components, AAC)
라이브러리 모음
- 앱 구조를 더 튼튼하도록
- 테스트에 용이하도록
- 유지 보수성이 뛰어나도록
모듈화된 코딩을 돕기 위해 Databinding, LiveData, ViewModel 등의 유용한 라이브러리를 제공

이러한 라이브러리의 모음은 MVVM 패턴의 구조의 설계에 최적화되어 있다.

View - 뷰

UI Controller를 담당하는 Activity, Fragment이다.
화면에 무엇을 그릴지 결정하고, 사용자와 상호작용한다.
데이터의 변화를 감지하기 위한 옵저버를 가지고 있다.

ViewModel - 뷰모델

뷰모델은 UI를 위한 데이터를 가지고 있다.
구성(configuration)이 변경되어도 살아남는다. (예를 들어 화면 회전이라던가, 언어 변경 등)
AsyncTask는 액티비티나 프래그먼트의 생명 주기에서 자유로울 수 없지만,

뷰모델은 뷰와 분리되어 있기 때문에 액티비티가 Destroy 되었다가 다시 Create 되어도 종료되지 않고 데이터를 여전히 가지고 있다.

LiveData - 라이브데이터

관찰이 가능한(Observable) 데이터 홀더 클래스이다.
뷰에서 뷰모델의 라이브데이터를 관찰하게 되면 데이터가 변경될 때 내부적으로 자동으로 알려주게 된다.
액티비티나 프래그먼트의 생명 주기를 인지한다. 즉, 액티비티가 화면 위에 활성화되어 있을 때에만 UI변경 등의 기능을 동작하게 되고, Destroy 된 상태에서는 동작하기 않기 때문에 메모리 릭의 발생을 줄여준다.

Repository - 리포지토리

뷰모델과 상호작용하기 위해 잘 정리된(Clean) 데이터 API를 들고 있는 클래스이다.
앱에 필요한 데이터 (내장DB or 외부DB) 를 가져온다.

뷰모델은 DB나 서버에 직접 접근하지 않고, 리포지토리에 접근하는 것으로 앱의 데이터를 관리한다.

Room - 룸

SQLite 데이터베이스를 편하게 사용하게 해주는 라이브러리이다.
SQLite의 코드를 직접 작성하는 경우, 직접 테이블을 Create 하거나 쿼리문을 일일이 변수를 통해 작성해주어야 했지만, Room을 쓰면 조금 더 직관적이고 편리하게 DB를 사용할 수 있다.

아키텍처 적용 전의 문제점

액티비티에 기능을 붙이다보면 액티비티가 무거워지거나 혹은 종속성이 너무 강해

테스트가 힘들고 유지보수가 어려워진다.

MVVM 패턴

View - ViewModel - Model 을 이용해 각각의 역할을 분리하여

가독성과 재사용성을 높인 디자인 패턴으로 종속성 및 유지보수의 어려움을 해소해준다.

MVC와 MVVM 차이점

MVC (Model - View - Controller)
- Controller
  
  Activity 부분에서 View에게는 화면 업데이트, Model에게는 데이터 갱신을 알리며
  
  View와 Mdel을 연결해주며 비즈니스 로직을 처리하기 위해 많은 일을 해야한다.
- View
  
  activity_main.xml 화면 부분으로 UI 역할 담당한다.
- Model
  Model class로 비즈니스 로직에서의 알고리즘, 데이터 드의 기능 처리한다.

MVVM (View - ViewModel - Model)
- View
  
  Activity 역할을 담당하고 UI를 갱신하는 역할에만 충실히 한다.
  뷰모델을 관찰(Observe) 한다.
  따라서, 데이터의 변화를 알아차리고 자동으로 화면을 갱신할 수 있다.
- ViewModel
  
  Model에게 데이터 갱신 처리를 요청하고 잘 정리된 데이터를 참조한다.
- Model
  
  Repository, DataBase 부분으로 데이터 처리 역할을 한다.

MVVM 장점

1. 뷰가 데이터를 실시간으로 관찰한다

LiveData (=Observable 패턴) 을 이용해 DB를 관찰하고 자동으로 UI를 갱신한다.

직접 뷰를 바꾸어주는 번거로움을 없애고 데이터와 불일치할 확률이 줄인다.

2. 생명주기로부터 안전하여 메모리 릭을 방지할 수 있다

뷰모델을 통해 데이터를 참조하기 때문에 액티비티/프래그먼트의 생명주기를 따르지 않는다.

=> 화면전환과 같이 액티비티가 파괴된 후 재구성 되어도 뷰모델이 데이터를 홀드하고 있기 때문에

영향을 받지 않는다.

뷰가 활성화되어있을 경우에만 작동하기 때문에 불필요한 메모리 사용을 줄일 수 있다.

*3. 기능별로 모듈화되어 있어 역할 분리를 할 수 있고 유닛 테스트에 한결 용이해진다. *

내장 DB를 통째로 바꾸고 싶다고 할 때, 뷰나 다른 코드에 깊게 종속돼있지 않아 DB 교체가 쉽다.

뷰모델과 뷰가 1:n 연결이 가능하다.

따라서, 뷰모델에 하나의 메소드를 구현해 놓으면

A 액티비티든 B 액티비티든 여러 뷰에서 호출해 재사용하기 편리하다.

실습 - MVVM 패턴, Repository, DataBinding 적용

얼리버디 프로젝트에 MVVM 아키텍처를 적용해 공부한 내용을 익혀보려 한다.

SignupActivity.kt

var vm: SignupViewModel = SignupViewModel()

lateinit var binding : ActivitySignupBinding

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //setContentView(R.layout.activity_signup)

        binding = DataBindingUtil.setContentView(this, R.layout.activity_signup)
        makeController()

        binding.signupActivity = this

        addObserverableData()
    }

...

fun communication(id: String, pw: String) {
        var jsonObject = JSONObject()
        jsonObject.put("userId", id)
        jsonObject.put("userPw", pw)


        val body = JsonParser().parse(jsonObject.toString()) as JsonObject
        vm.viewCommunicate(body)
    }

     fun click() {
         communication(id, pw)
    }

    private fun View.showOrInvisible(show: Boolean) {
        visibility = if (show) {
            View.VISIBLE
        } else {
            View.INVISIBLE
        }
    }



    private fun idDuplicate(){
        act_signup_tv_id_ment.showOrInvisible(true)

    }

    private fun addObserverableData(){
        vm.isSuccessNetwork.observe(
            this, Observer {
                if(it){
                    val intent = Intent(this@SignupActivity, SignupSuccessActivity::class.java)
                    startActivity(intent)
                }else{
                    idDuplicate()
                }
                }
        )

        vm.wifiDisconnect.observe(
            this, Observer {
                val intent = Intent(this@SignupActivity, SignupFailActivity::class.java)
                startActivity(intent)
            }
        )
    }

}

SignupViewModel.kt

class SignupViewModel : ViewModel() {
    val signupRepository = SignupRepository()

    internal val disposables = CompositeDisposable()

    val isSuccessNetwork = MutableLiveData<Boolean>()
    val wifiDisconnect = MutableLiveData<Unit>()

    fun viewCommunicate(jsonObject: JsonObject) {

        val body = JsonParser().parse(jsonObject.toString()) as JsonObject
        Log.d("test", "postUserData body : " + body)

        signupRepository.signUp(body = body,
            onResponse = {
                //고차함수로 구현, it으로 response에 바로 접근 가능
                if (it.isSuccessful) {
                    val intent = Intent(this, SignupSuccessActivity::class.java)
                    startActivity(intent)
                    isSuccessNetwork.value = true

                } else { //아이디 중복
                    isSuccessNetwork.value = false

                    Log.d("test", "아이디중복: " + it.message())
                }

            }, onFailure = {
                //고차함수로 구현, it으로 t에 바로 접근 가능
                Log.d("test", "통신 실패 error : " + it.toString())
                wifiDisconnect.value = Unit
                val intent = Intent(this@SignupActivity, SignupFailActivity::class.java)
                startActivity(intent)
            }
        )
    }
}

SignupRepository.kt

class SignupRepository{
    val retrofitRemoteDataSource: RemoteDataSource = RemoteDataSourceImpl() //인스턴스 생성
    fun signUp(
        jsonObject: JsonObject,
        onResponse: (Response<PostSignupData>) -> Unit,
        onFailure: (Throwable) -> Unit
    ){
        //생성한 인스턴스로 RempteDataSourceImpl에 구현해놓은 함수 실행
        retrofitRemoteDataSource.signUp(jsonObject, onResponse, onFailure)
    }
}

PostSignupData.kt

data class PostSignupData (
    @SerializedName("status")
    val status: Int,
    @SerializedName("data")
    val idx: Int,
    @SerializedName("message")
    val message: String
)

AndBuddyService.kt

interface AndBuddyService {
    @POST("/users/signup")
    fun postSignupUser(
        @Body() body: JsonObject
    ): Call<PostSignupData>
}

AndBuddyServiceImpl.kt

object AndBuddyServiceImpl {
    private const val BASE_URL = "http://서버주소:3456/"

    private val okHttpClient: OkHttpClient =
        OkHttpClient.Builder().addInterceptor(CookiesIntercepter())
            .addNetworkInterceptor(CookiesIntercepter()).build()

    private val retrofit: Retrofit =
        Retrofit.Builder().baseUrl(BASE_URL).client(
            okHttpClient
        )
            .addConverterFactory(GsonConverterFactory.create())
            .build()

    val service: AndBuddyService = retrofit.create(
        AndBuddyService::class.java)
}

RemoteDataSource.kt

interface RemoteDataSource { //필요한 함수들을 모아서 정의하는 인터페이스
    fun signUp(jsonObject: JsonObject, //post에 필요한 값을 보낼 body
               onResponse: (Response<PostSignupData>) -> Unit, //통신 성공시 수행할 함수
               onFailure: (Throwable) -> Unit) //통신 실패시 수행할 함수
}

RetmoteDataSourceImpl.kt

class RemoteDataSourceImpl : RemoteDataSource { //RemoteDataSource를 상속받는 클래스
    override fun signUp(
        jsonObject: JsonObject,
        onResponse: (Response<PostSignupData>) -> Unit,
        onFailure: (Throwable) -> Unit
    ) {
        AndBuddyServiceImpl.service.postSignupUser(jsonObject).enqueue(object : //enqueue 함수 실행
            Callback<PostSignupData> {
            override fun onFailure(call: Call<PostSignupData>, t: Throwable) { //통신 실패시 실행되는 함수 구현
                onFailure(t)
            }

            override fun onResponse( //통신 성공시 실행되는 함수 구현
                call: Call<PostSignupData>,
                response: Response<PostSignupData>
            ) {
                onResponse(response)
            }
        })
    }
}

build.gradle (Module: app)

android {

    ...

    dataBinding {
        enabled = true
    }

}

dependencies {

    ...

    //Retrofit 라이브러리 : https://github.com/square/retrofit
    implementation 'com.squareup.retrofit2:retrofit:2.6.2'
    //Retrofit 라이브러리 응답으로 가짜 객체를 만들기 위해
    implementation 'com.squareup.retrofit2:retrofit-mock:2.6.2'

    //객체 시리얼라이즈를 위한 Gson 라이브러리 : https://github.com/google/gson
    implementation 'com.google.code.gson:gson:2.8.6'
    //Retrofit 에서 Gson 을 사용하기 위한 라이브러리
    implementation 'com.squareup.retrofit2:converter-gson:2.6.2'

    //okHttp
    implementation 'com.squareup.okhttp3:logging-interceptor:3.8.1'
    implementation 'com.squareup.okhttp3:okhttp:3.8.1'

    //리사이클러뷰 라이브러리
    implementation 'androidx.recyclerview:recyclerview:1.1.0-alpha06'
  }

통신을 위한 퍼미션을 주기 위해 2가지를 추가해줘야한다.

1) AndroidManifest.xml

해당 코드를 추가해줘야 한다.

 <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 <uses-permission android:name="android.permission.INTERNET" />

2) CookiesIntercepter.kt

class CookiesIntercepter : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val request =
            chain.request().newBuilder().header("Content-Type", "application/json")
                .build()
        return chain.proceed(request)
    }
}

참고 [Android] MVVM Part.2

해당 블로그에 설명이 매우 잘 되어있어서 공부 후 정리하는데 많은 도움이 되었다.

[Spring] 스프링 프레임워크란? DI 의존주입이란? 의존주입방법

aonee — Wed, 1 Apr 2020 19:31:12 +0900

1. 스프링 프레임워크란?

스프링 프레임워크

주요기능

DI, AOP, MVC, JDBC 등을 제공

- DI : 주입기능,

- AOP : 관점지향 프로그래밍

- IOC : Inversion of Control

스프링에서 객체를 생성하고 조립하는 컨테이너로, 컨테이너를 통해 생성된 객체를 빈이라고 부른다.

- 컨테이너 : 스프링에서 객체를 생성 및 조립

- 빈 : 컨테이너를 통해 생성된 객체

1) 객체생성 및 속성 데이터 작성 (xml 문서)

2) 스프링 컨테이너에서 객체 생성 및 조립 (스프링 컨테이너, 빈 생성 및 조립)

3) 애플리케이션 구현 (java 문서)

- maven : build tool

스프링 프레임워크 : 개발자들이 개발을 하기 위한 업무를 추상적으로 정의해놓은 틀

틀이 있어 본연의 업무에 집중할 수 있어 작업의 효율을 높일 수 있다.

제공하는 모듈 (=틀, 라이브러리)

제공하는 모듈	기능
spring-core	스프링의 핵심인 DI & Ioc 제공
spring-aop	AOP 구현 기능 제공
spring-jdbc	DB 쉽게(=적은 양의 코드) 다룰 수 있는 기능 제공
spring-tx	스프링에서 제공하는 트랜젝션 관련 기능 제공
spring-webmvc	스프링에서 제공하는 컨트롤러와 뷰를 이용한 스프링 MVC 구현 기능 제공

이용방법 : 모듈에 대한 의존설정을 개발 프로젝트에 XML 파일 등을 이용해 개발자가 직접

전체 프로젝트 구조

2. DI (Dependency Injection)

- 1) DI 를 이용한 프로그래밍 방법

의존주입 방법론이다. (spirng만의 방법은 아님)

구현방법은 @Autowired와@Resource 어노테이션을 이용해서 쉽게구현할수있다.

ex)

배터리 일체형

배터리 분리형

공통점 : 둘다 배터리에 의존한다. 배터리 의존을 주입.

차이점 : 분리형이 일체형보다 유연하다.

2. 스프링 DI 설정 방법

생성할 때 주입

모든 service에 dao를 넣어주고 있음

StudentDao.java

StudentDao studentDao = new StudentDao( );

Service service= new Service(StudentDao);

=같다

applicationContext.xml

<construct-arg ref="studentDao" />

</bean>

construct-arg태그를 통해 생성자 생성

- 2) 의존객체를 주입하는 다양한 방법

① 생성자를 이용한 의존 객체 주입

② setter를 이용한 의존 객체 주입

③ List 타입 의존 객체 주입

④ Map 타입 의존 객체 주입

- 3) 스프링설정파일분리

원인 : 하나의 xml 파일에 너무 많은 파일이 담기면 가독성 및 관리 떨어짐

목적 : 가독성 up, 유지 보수 up

1. 스프링 설정 파일 분리

2. 빈(Bean)의 범위

- 4) 의존객체를 자동으로 주입하는 방법

① 의존객체 자동 주입이란?

스프링 설정 파일에서 의존 객체를 주입할 때

<constructor-org> 또는 <property> 태그로 의존 대상 객체를 명시하지 않아도

스프링 컨테이너가 자동으로 필요한 의존 대상 객체를 찾아서

의존 대상 객체가 필요한 객체에 주입해 주는 기능이다.

구현 방법은

@Autowired 와 @Resource 어노테이션을 이용해서 쉽게 구현할 수 있다.

② @Autowired

appCtxUseAutoWired.xml에

<constructor-org> 또는 <property> 태그 없이

<context:annotation-config /> 와

xsi:schemaLocation=""에 spring-beans.xsd, context, context/spring-context.xsd 추가

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
 		http://www.springframework.org/schema/beans/spring-beans.xsd 
 		http://www.springframework.org/schema/context 
 		http://www.springframework.org/schema/context/spring-context.xsd">

	<context:annotation-config />

	<bean id="wordDao" class="com.word.dao.WordDao" />
    
	<bean id="registerService" class="com.word.service.WordRegisterServiceUseAutowired" />
	
	<bean id="searchService" class="com.word.service.WordSearchServiceUseAutowired" />
	
</beans>

생성자 생성에 사용시

@AutoWired
public WordSearchService (WordDao wordDao){
  this.wordDao = wordDao;
}

프로퍼티 또는 메서드에도 넣어줄 수 있다.

@AutoWired
private WordDao wordDao;

public WordRegisterServiceUseAutowired() {
		// TODO Auto-generated constructor stub
	}

@AutoWired
public void setWordDao( WordDao wordDao){

    this.wordDao = wordDao;

}

단, 프로퍼티 또는 메서드에서 사용시에는

반드시 default 생성자를 명시해줘야한다.

why? 객체가 생성돼야지 프로퍼티에서 WordDao를 끌어올 수 있고

this.wordDao = wordDao; 에 WordDao를 넣어줄 수 있기 때문이다.

③ @Resource

- 5) 다수의 빈(Bean)객체 중 의존 객체의 대상이 되는 객체를 선택하는 방법

① 의존객체 선택

-3), 4) , 5) 비교

3) 에서는 개발자가 직접 주입했음.

<construct-arg ref="studentDao" />

</bean>

4) 에서는

<context:annotation-config />
com.word.dao.WordDao" />
com.word.service.WordRegisterServiceUseAutowired" />

@AutoWired
public WordSearchService (WordDao wordDao){
this.wordDao = wordDao;
}

빈객체의 이름을 이용해서 주입했음

5) 여기에서는

다수의 빈을 사용할 경우

@AutoWired 가 많을 경우

어떤 빈을 사용할지 선택해줌

Exception 왜?

자동 주입 대상 객체를 판단하지 못해

해결방법?

<qualifier value = "" /> 태그를 사용해서 명시

②의존객체 자동 주입 체크

자동 의존 객체가 존재하지 않으면 Exception발생한다.

그러나, Exception 발생하기 않도록 하고 싶다면? @Autowird (required = false)

=> 해당 방법은 잘 쓰이지 않는다. 사용하지 마세요.

③ @Inject

@Autowird와 유사. (required = false)는 사용 불가.

@Autowird VS @Inject

@Autowird가 더 많이 쓰인다.

@Autowird

@Qualifier("qualifier value 명")

@Inject

@Named(value="사용하려는 빈객체의 id명")

Bouncy Castle의 ECDSA를 이용한 신원 인증 시스템 개발

aonee — Mon, 30 Mar 2020 02:09:01 +0900

개인키와 공개키가 파일 형태로 컴퓨터에 남아있어서 저장하거나 불러오는 작업 수행 가능하도록 한다.
Bouncy Castle: Java에서 타원 곡선 암호화 기술을 쉽게 이용 가능하도록 해주는 라이브러리
- 타원 곡선 암호화 기술에 필요한 라이브러리 : bcprov-jdk15on-159.jar와 bcpkix-jdkon-159.jar
- https://www.bouncycastle.org/latest_releases.html
  1. 두 파일을 다운로드 후 프로젝트에 Drag and Drop
  2. 두 파일 우클릭 후 'Add to Build Path'
인증서: 컴퓨터에 저장된 개인키/공개키 파일
- 일반적으로 인증서 정보는 byte 형태로 저장되어있어 읽거나 처리가 어려우므로 키 데이터를 Base64 알고리즘을 이용해 사용하기 쉬운 형태로 인코딩 해서 관리함
- PEM(Privacy Enhanced Mail) : 인코딩된 파일 .pem 확장자

코드 설명

임의의 타원 곡선 암호 키 생성
.pem 확장자로 내보내서 개인키/공개키를 컴퓨터 내에 저장

Pem.java : 특정한 개인키 혹은 공개키 정보를 읽어서 저장한 뒤에 파일로 내보내는 역할
EC.java : 타원 곡선 암호화 기술을 이용해 개인키 및 공개키를 생성해 저장 (sect163k1 알고리즘 사용)
BlockchainStarter.java : 실행

Pem.java

// 특정한 개인키, 공개키 정보를 읽어 저장한 뒤에 파일로 내보내는 역할을 수행
package util;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.security.*;

import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemWriter;

public class Pem {
	
	private PemObject pemObject;
	
	// Key data, description PEM 객체에 저장
	public Pem (Key key, String description) {
		this.pemObject = new PemObject(description, key.getEncoded());
	}
	
	// 특정한 파일 이름으로 PEM 파일 저장
	public void write(String filename) throws FileNotFoundException, IOException {
		PemWriter pemWriter = new PemWriter(new OutputStreamWriter(new FileOutputStream(filename)));
		try {
			pemWriter.writeObject(this.pemObject);
		} finally {
			pemWriter.close();
		}
	}

}

EC.java

package util;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.spec.ECGenParameterSpec;

public class EC {
	// 세부 알고리즘 sect163k1
	private final String ALGORITHM = "sect163k1";
	
	public void generate(String privateKeyName, String publicKeyName) throws Exception {
		// ECDSA(bouncy castle의 타원 곡선 표준 알고리즘) 사용
		KeyPairGenerator generator = KeyPairGenerator.getInstance("ECDSA", "BC");
		
		// 세부 알고리즘 sect163k1
		ECGenParameterSpec ecsp;
		ecsp = new ECGenParameterSpec(ALGORITHM);
		generator.initialize(ecsp, new SecureRandom());
		
		// 해당 알고리즘으로 랜덤의 키 한 쌍 생성
		KeyPair keyPair = generator.generateKeyPair();
		System.out.println("타원곡선 암호키 한 쌍을 생성했습니다.");
		
		// 생성한 키 한쌍에서 개인키와 공개키를 추출
		PrivateKey priv = keyPair.getPrivate();
		PublicKey pub = keyPair.getPublic();
		
		// 개인키와 공개키를 특정한 파일 이름으로 저장
		writePemFile(priv, "EC PRIVATE KEY", privateKeyName);
		writePemFile(priv, "EC PUBLIC KEY", publicKeyName);
		
	}

	// PEM 클래스로 생성된 암호키를 파일로 저장하는 함수
	private void writePemFile(Key key, String description, String filename) 
				throws FileNotFoundException, IOException {
		Pem pemFile = new Pem(key, description);
		pemFile.write(filename);
		
		System.out.println(String.format("EC 암호키 %s를 %s 파일로 내보냈습니다.", 
				description, filename));
	}

}

BlockchainStarter.java

package core;
import java.security.Security;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import util.EC;

public class BlockChainStarter {
	public static void main(String[] args) throws Exception {
		
		// 바운시 캐슬의 암호화 라이브러리 사용
		Security.addProvider(new BouncyCastleProvider());
		
		// 타원 곡선 객체 생성 개인키과 공개키를 각각 private.pem public.pem으로 저장
		EC ec = new EC();
		ec.generate("private.pem", "public.pem");
	}

}

실행 하면 `private.pem`, `public.pem` 두 파일 생성된 것을 확인 가능하다.
작성된 파일은 랜덤으로 생성해서 저장하기에 매번 키 값이 변경된다.

private.pem

public.pem

출처 : http://www.bitweb.co.kr/m/view.php?idx=886

[crawling] Selenium, BeautifulSoup을 이용한 크롤링 - 인터파크 여행지 크롤링

aonee — Sun, 22 Mar 2020 23:55:43 +0900

전체 코드는 깃허브에 있습니다! https://github.com/devAon/Web-Scraping

1. 크롤링

크롤링이란?

웹 페이지를 그대로 가져와서 거기서 데이터를 추출해 내는 행위

머신러닝 영역 안에 빅데이터 처리 분석의 데이터 수집

selenium 과 Beautifulsoup을 이용해서 데이터 수집

- 크롤러

크롤링 소프트웨어

파이참 Pycharm

파이썬 라이브러리 설치방법

Settings - Project Interpreter - +버튼 클릭 - 원하는 라이브러리 검색 후 설치

2. 개발 환경 구축

언어

- python.exe. 설치 (3.x)

모듈

- selenium 설치

$ pip install selenium

- bs4 설치

Selenium VS BeautifulSoup 차이

Selenium

BeautifulSoup은 사용자 행동을 특정해서 데이터를 가져올 수 없다.

사용자의 행동을 동적으로 추가하기 위해 Selenium이 필요하다.

공식문서 : https://selenium-python.readthedocs.io/

Selenium with Python — Selenium Python Bindings 2 documentation

Note This is not an official documentation. If you would like to contribute to this documentation, you can fork this project in Github and send pull requests. You can also send your feedback to my email: baiju.m.mail AT gmail DOT com. So far 40+ community

selenium-python.readthedocs.io

BeautifulSoup

HTML과 XML을 파싱하는데 사용되는 파이썬 라이브러리이다.

공식문서 : https://www.crummy.com/software/BeautifulSoup/bs4/doc/

Beautiful Soup Documentation — Beautiful Soup 4.4.0 documentation

Non-pretty printing If you just want a string, with no fancy formatting, you can call unicode() or str() on a BeautifulSoup object, or a Tag within it: str(soup) # ' I linked to example.com ' unicode(soup.a) # u' I linked to example.com ' The str() functio

www.crummy.com

웹 드라이버

- Chrome 드라이버 설치

https://chromedriver.chromium.org/downloads

Downloads - ChromeDriver - WebDriver for Chrome

WebDriver for Chrome

chromedriver.chromium.org

- Phantom 드라이버 설치

https://github.com/detro/ghostdriver

detro/ghostdriver

Ghost Driver is an implementation of the Remote WebDriver Wire protocol, using PhantomJS as back-end - detro/ghostdriver

github.com

에디터

- vs code 설치

- plugin 설치

vs code에서 ctrl + Shift + X - 아래 4가지 설치

3, 웹드라이버란?

- 자동화 설계

- 시나리오에 따른 움직임

4. Selenium 이란?

- 웹드라이버 띠우기

- 에이전트 조작

- 프록시 조작

Selenium Getting Started

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

driver = webdriver.Firefox()
driver.get("http://www.python.org")
assert "Python" in driver.title
elem = driver.find_element_by_name("q")
elem.clear()
elem.send_keys("pycon")
elem.send_keys(Keys.RETURN)
assert "No results found." not in driver.page_source
driver.close()

(참고) https://selenium-python.readthedocs.io/getting-started.html

2. Getting Started — Selenium Python Bindings 2 documentation

2.2. Example Explained The selenium.webdriver module provides all the WebDriver implementations. Currently supported WebDriver implementations are Firefox, Chrome, IE and Remote. The Keys class provide keys in the keyboard like RETURN, F1, ALT etc. from se

selenium-python.readthedocs.io

잠시대기

명시적 대기 => 특정 요소가 발견될 때까지 대기

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

try:
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "myDynamicElement"))
    )
finally:
    driver.quit()

암묵적 대기 -> DOM이 다 로드 될 때까지 대기하고 먼저 로드되면 바로 진행

절대적 대기 -> time.sleep(10) -> 클라우드 페어 (디도스 방어 솔루션)

https://selenium-python.readthedocs.io/waits.html

5. Waits — Selenium Python Bindings 2 documentation

5. Waits These days most of the web apps are using AJAX techniques. When a page is loaded by the browser, the elements within that page may load at different time intervals. This makes locating elements difficult: if an element is not yet present in the DO

selenium-python.readthedocs.io

5. 웹 드라이버를 이용한 Selenium의 주요 API 습득

- 페이지 접속

- 우회 접속

- 로그인및 검색 등 폼처리

- 찾기

- 추출하기

6. 크롤링 타겟 사이트 분석및 데이터 접근 실습
- search

- result

- rotation

- selenium의 최대치

7. Beautiful Soup의 이해 및 API 습득

- when?

- DOM 접근

- 콘텐츠 획득

8. 수집 데이터의 전처리 및 DB 처리

- 디비 접속 처리

- sql 처리

- 크롤링 데이터 삽입

인터파크 해외여행지 정보 크롤링

Interpark_travel_scraping.py

-Selenium

-BueatifulSoup

# 인터파크 투어 사이트에서 여행지를 입력후 검색 -> 잠시후 -> 결과
# 로그인시 PC 웹 사이트에서 처리가 어려울 경우  -> 모바일 로그인 진입
# 모듈 가져오기
# pip install selenium
# pip install bs4
# pip install pymysql
from selenium import webdriver as wd
from bs4 import BeautifulSoup as bs
from selenium.webdriver.common.by import By
# 명시적 대기를 위해 
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from DbMgr import DBHelper as Db
import time
from Tour import TourInfo

# 사전에 필요한 정보를 로드 => 디비혹스 쉘, 베치 파일에서 인자로 받아서 세팅
db       = Db()
main_url = 'http://tour.interpark.com/' 
keyword  = '로마'
# 상품 정보를 담는 리스트 (TourInfo 리스트)
tour_list = []

# 드라이버 로드
# 맥용
# driver = wd.Chrome(executable_path='./chromedriver')
# 윈도우용
driver = wd.Chrome(executable_path='chromedriver.exe')
# 고스트용
# driver   = wd.PhantomJS(executable_path='./phantomjs')
# 차후 -> 옵션 부여하여 (프록시, 에이전트 조작, 이미지를 배제)
# 크롤링을 오래돌리면 => 임시파일들이 쌓인다!! -> 템프 파일 삭제

# 사이트 접속 (get)
driver.get(main_url)
# 검색창을 찾아서 검색어 입력
# id : SearchGNBText
driver.find_element_by_id('SearchGNBText').send_keys(keyword)
# 수정할경우 => 뒤에 내용이 붙어버림 => .clear() -> send_keys('내용')
# 검색 버튼 클릭
driver.find_element_by_css_selector('button.search-btn').click()

# 잠시 대기 => 페이가 로드되고 나서 즉각적으로 데이터를 획득 하는 행위는 
# 명시적 대기 => 특정 요소가 로케이트(발결된때까지) 대기
try:
    element = WebDriverWait(driver, 10).until(
        # 지정한 한개 요소가 올라면 웨이트 종료
        EC.presence_of_element_located( (By.CLASS_NAME, 'oTravelBox') )
    )
except Exception as e:
    print( '오류 발생', e)
# 암묵적 대기 => DOM이 다 로드 될때까지 대기 하고 먼저 로드되면 바로 진행
# 요소를 찾을 특정 시간 동안 DOM 풀링을 지시 예를 들어 10 초이내 라로 
# 발견 되면 진행
driver.implicitly_wait( 10 )
# 절대기 대기 => time.sleep(10) -> 클라우드 페어(디도스 방어  솔류션)
# 더보기 눌러서 => 게시판 진입 
driver.find_element_by_css_selector('.oTravelBox>.boxList>.moreBtnWrap>.moreBtn').click()

# 게시판에서 데이터를 가져올때 
# 데이터가 많으면 세션(혹시 로그인을 해서 접근되는 사이트일 경우) 관리 
# 특정 단위별로 로그아웃 로그인 계속 시도
# 특정 게시물리 사라질 경우 => 팝업 발생 (없는 ...) => 팝업 처리 검토
# 게시판 스캔시 => 임계점을 모름!!
# 게시판 스캔 => 메타 정보 획득 => loop 를 돌려서 일괄적으로 방문 접근 처리

# searchModule.SetCategoryList(1, '') 스크립트 실행
# 16은 임시값, 게시물을 넘어갔을때 현상을 확인차
for page in range(1, 2):#16):
    try:
        # 자바스크립트 구동하기
        driver.execute_script("searchModule.SetCategoryList(%s, '')" % page)
        time.sleep(2)
        print("%s 페이지 이동" % page)
        #############################################################
        # 여러 사이트에서 정보를 수집할 경우 공통 정보 정의 단계 필요
        # 상품명, 코멘트, 기간1, 기간2, 가격, 평점, 썸네일, 링크(상품상세정보)
        boxItems = driver.find_elements_by_css_selector('.oTravelBox>.boxList>li')
        # 상품 하나 하나 접근
        for li in boxItems:
            # 이미지를 링크값을 사용할것인가? 
            # 직접 다운로드 해서 우리 서버에 업로드(ftp) 할것인가?
            print( '썸네임', li.find_element_by_css_selector('img').get_attribute('src') )
            print( '링크', li.find_element_by_css_selector('a').get_attribute('onclick') )
            print( '상품명', li.find_element_by_css_selector('h5.proTit').text )
            print( '코멘트', li.find_element_by_css_selector('.proSub').text )
            print( '가격',   li.find_element_by_css_selector('.proPrice').text )
            area = ''
            for info in li.find_elements_by_css_selector('.info-row .proInfo'):
                print(  info.text )
            print('='*100)
            # 데이터 모음
            # li.find_elements_by_css_selector('.info-row .proInfo')[1].text
            # 데이터가 부족하거나 없을수도 있으므로 직접 인덱스로 표현은 위험성이 있음
            obj = TourInfo(  
                li.find_element_by_css_selector('h5.proTit').text,
                li.find_element_by_css_selector('.proPrice').text,
                li.find_elements_by_css_selector('.info-row .proInfo')[1].text,
                li.find_element_by_css_selector('a').get_attribute('onclick'),
                li.find_element_by_css_selector('img').get_attribute('src')
            )
            tour_list.append( obj )
    except Exception as e1:
        print( '오류', e1 )

print( tour_list, len(tour_list) )
# 수집한 정보 개수를 루프 => 페이지 방문 => 콘텐츠 획득(상품상세정보) => 디비
for tour in tour_list:
    # tour => TourInfo
    print( type(tour) )
    # 링크 데이터에서 실데이터 획득
    # 분해
    arr = tour.link.split(',')
    if arr:
        # 대체
        link = arr[0].replace('searchModule.OnClickDetail(','')
        # 슬라이싱 => 앞에 ', 뒤에 ' 제거
        detail_url = link[1:-1]
        # 상세 페이지 이동 : URL 값이 완성된 형태인지 확인 (http~)
        driver.get( detail_url )
        time.sleep(2)
        # pip install bs4
        # 혖재 페이지를 beautifulsoup 의 DOM으로 구성
        soup = bs( driver.page_source, 'html.parser')
        # 현제 상세 정보 페이지에서 스케줄 정보 획득
        data = soup.select('.tip-cover')
        #print( type(data), len(data), type(data[0].contents)  )
        # 디비 입력 => pip install pymysql
        # 데이터 sum
        content_final = ''
        for c in data[0].contents:
            content_final += str(c)
        
        # html 콘첸츠 데이터 전처리 (디비에 입력 가능토록)
        import re
        content_final   = re.sub("'", '"', content_final)
        content_final   = re.sub(re.compile(r'\r\n|\r|\n|\n\r+'), '', content_final)

        print( content_final )
        # 콘텐츠 내용에 따라 전처리 => data[0].contents
        db.db_insertCrawlingData(
            tour.title,
            tour.price[:-1],
            tour.area.replace('출발 가능 기간 : ',''),
            content_final,
            keyword
        )

# 종료
driver.close()
driver.quit()
import sys
sys.exit()

TourInfo.py

class TourInfo:
    title = ''
    price = ''
    area  = ''
    link  = ''
    img   = ''
    contents = ''

    def __init__(self, title, price, area, link, img, contents=None ):
        self.title = title
        self.price = price
        self.area  = area
        self.link  = link
        self.img   = img
        self.contents = contents

DBMgr.py

# 디비 처리, 연결, 해제, 검색어 가져오기, 데이터 삽입
import pymysql as my

class DBHelper:
    '''
    맴버변수 : 커넥션 
    '''
    conn = None
    '''
    생성자 
    '''
    def __init__(self):
        self.db_init()
    '''
    맴버 함수
    '''
    def db_init(self):
        self.conn = my.connect(
                        host='localhost',
                        user='root',
                        password='1234',
                        db='pythonDB',
                        charset='utf8',
                        cursorclass=my.cursors.DictCursor )
    
    def db_free(self):
        if self.conn:
            self.conn.close()

    # 검색 키워드 가져오기 => 웹에서 검색
    def db_selectKeyword(self):
        # 커서 오픈
        # with => 닫기를 처리를 자동으로 처리해준다 => I/O 많이 사용
        rows = None
        with self.conn.cursor() as cursor:
            sql  = "select * from tbl_keyword;"
            cursor.execute(sql)
            rows = cursor.fetchall()
            print(rows)
        return rows
        
    def db_insertCrawlingData(self, title, price, area, contents, keyword ):
        with self.conn.cursor() as cursor:
            sql = '''
            insert into `tbl_crawlingdata` 
            (title, price, area, contents, keyword) 
            values( %s,%s,%s,%s,%s )
            '''
            cursor.execute(sql, (title, price, area, contents, keyword) )
        self.conn.commit()
        
# 단독으로 수행시에만 작동 => 테스트코드를 삽입해서 사용        
if __name__=='__main__':
    db = DBHelper()
    print( db.db_selectKeyword() )
    print( db.db_insertCrawlingData('1','2','3','4','5') )
    db.db_free()

필요한 데이터 수집을 위해 XML 분석

[Spring] Intellij tomcat war 배포 - window에서 filezilla를 이용해 sftp 서버배포

aonee — Fri, 20 Mar 2020 18:30:43 +0900

Tomcat에 WAR 배포하는데 삽질을 정말 많이 했다.

WAR 와르와르와르 하니까 전혀 관련 없지만 콜드의 와르르♥ 가 계속 생각났다.

서버 배포에 성공하면 신나는 마음으로 듣기 위해 와르르를 흥얼거리며 해결했다.

결국 행복하게 와르르~~~~~~~~~~~~~~~~~~~~~~듣게 되었다.

와르르 들으면서 하는 포스팅!

1. WAR 파일 생성

1) war 파일 배포하기 위해 Main 클래스에 SpringBootServletInitializer 상속 받기

문제 발생 : Tomcat에 war 배포시 404 에러가 발생했다.

발생 원인 : Main 클래스에 SpringBootServletInitializer를 상속받지 않았기 때문이다.

package kr.ac.korea.sans.cs;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CsApplication {

    public static void main(String[] args) {
        SpringApplication.run(CsApplication.class, args);
    }

}

해결

package kr.ac.korea.sans.cs;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class CsApplication extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(CsApplication.class, args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(CsApplication.class);
    }
}

왜 ?

일반적인 Spring Framework에서는 Web.xml에 DispatcherServlet을 등록하는 작업이 필요하다.

Servlet 3.0에서는 web.xml이 없이도 배포가 가능해졌는데 Apache Tomcat 7부터 지원한다.

web.xml의 역할을 WebApplicationinitializer 인터페이스를 구현하여 프로그래밍으로 ServletContext를 구현할 수 있도록 바뀐것이다.

SpringBootServletInitializer는 WebApplicationinitializer의 구현체이다.

SpringBootServletInitializer를 이용하여 WebApplicationContext를 생성하여 Servlet Context에 추가한다.

프로젝트에 web.xml도 없었고, WebApplicationinitializer를 구현한 SpringBootServletInitializer도 없었기 때문에 Tomcat에서 URL의 요청을 받아드릴수가 없었던 것이다.

SpringBootServletInitializer를 상속 한다는건 결국 Tomcat과 같은 Servlet Container 환경에서 Spring Boot Application을 동작 가능 하도록 Web Application Context를 구성한다는 의미이다.

2) pom.xml finalName 태그 추가

build 태그에 finalName태그 추가하면 된다.

<finalName>cs</finalName>

build태그 전체 코드

<build>
        <finalName>cs</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

이렇게 하면 war파일 생성시 finalName 에 지정한 이름으로 war파일이 생성된다.

3) tomcat 서버에 배포할 war파일 만들기

Run - Edit Configurations..

command line 에 compile war:war 입력 - OK

Run (Shift+F10) 해주면

target 디렉토리에서

finalName에 입력한 cs 이름으로 war파일이 생성된 것을 확인할 수 있다.

2. tomcat 서버에 생성한 WAR 파일 배포

방법 1) localhost에 배포 -> Local tomcat 서버에 배포

방법 2) 원하는 서버에 배포 -> 윈도우의 경우 fileZilla를 이용해 서버에 배포

방법 1) localhost에 배포

① tomcat 설치한 폴더 open

(필자의 경우 : C:\Program Files (x86)\Apache Software Foundation\Tomcat 9.0 - remote 8080\webapps 여기에 위치)

Tomcat 9.0 - remote 8080은 Tomcat 9.0을 복사해서 생성한 파일

② tomcat - webapps 디렉토리에 생성한 war파일 복사&붙여넣기

③ cmd 관리자 권한으로 실행

$ cd C:\Program Files (x86)\Apache Software Foundation\Tomcat 9.0 - remote 8080\bin

$ startup.bat (윈도우의 경우)

맥의 경우 startup.sh

④ startup.bat을 입력하면 tomcat 서버가 구동된다.

spring 문자가 뜨면 서버에 잘 올라간 것이다! 예에~~

작성해둔 테스트 코드를 실행하면 다음과 같이 잘 구동된다!

테스트를 위한 spring /hello 테스트 코드 (Controller 클래스를 만들어 작성하면 된다.)

@RestController
public class CsAppController {
    @RequestMapping(value="/hello", method= RequestMethod.GET)
    public String test (HttpServletRequest request) throws Exception {
        return "Hello";
    }
}

방법2) 원하는 서버에 배포

윈도우 사용자의 경우 FileZilla를 이용하면 편하게 SFPT 서버 배포가 가능하다.

내 사이트 - New site

프로토콜 : SFTP

호스트 : 원하는 서버 주소

포트 : 22

사용자 : 사용자 ID

비밀번호 : 사용자 비밀번호

꼭!!!!!! 포트를 22 로 지정해야한다!!

8080 Nope!

21 Nope!

22 YEAH! YES!

Tomcat 한글 깨짐현상 해결방법

HOXY.... tomcat 한글깨짐 문제가 발생한다 ??!

해결하면 되지~~~

해결방법

실행창(WIN+R)을 누르고 regedit을 입력하여 레지스트리 편집기
컴퓨터 > HKEY_CURRNET_USER > Console 위치에 새로운 키 값을 생성해준다.

해당 키 값의 이름은 Tomcat으로 입력해주고 해당 키 값 안에 DWORD(32비트) 값을 하나 추가해준다.

해당 값의 이름은 CodePage로 변경

편 - 안 -

[Spring] 이클립스로 스프링 프로젝트 생성하기

aonee — Sun, 15 Mar 2020 13:18:27 +0900

eclipse

java -> project -> Maven project -> 두개 체크 -> Group id & Artifactd id작성

Group id : spring4 전체 큰 프로젝트

Artifactd id : testPjt 현재 만드는

>src

>main

>java : java 언어 사용해 기능 구현한 project. java파일 관리

>resource : 보조적인 역할을 하는 자원파일 관리

pom.xml 파일이란?

모듈 가져오는 파일

필용한 라이브러리만 다운로드 해서 사용.

메이븐 설정파일이다. 메이븐은 라이브러리를 연결해주고 빌드를 위한 플랫폼이다.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>spring4</groupId>
  <artifactId>testPjt</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
       		<version>4.1.0.RELEASE</version>
        </dependency>
  </dependencies>
  
  	<build>
  		<plugins>
  			<plugin>
  				<artifactId>maven-compiler-plugin</artifactId>
  				<version>3.1</version>
  				<configuration>
  					<source>1.8</source>
  					<target>1.8</target>
  					<encoding>utf-8</encoding>
  				</configuration>
  			</plugin>
  		</plugins>
  	</build>
  
</project>

=> 에러가 뜨면 버전이 맞지 않아서 이기 때문. 우클릭 - Maven - update project

dependencies, build 추가

dependencies ?

내가 필요한 모듈 명시. main repositories로 부터 local로 라이브버리가 자동으로 다운로드 할 수 있다.

build ?

실제 내가 만든 프로젝트가 빌드될 때 필요한 빌드 명령들.

spring framework ?

java + 수많은 모듈

applicationContext.xml 이란?

빈 (=spring 컨테이너의 객체)을 만들어주는 녀석

spring framework에서는 객체를 생성하는데 new 키워드를 사용하기 보다는

resources / applicationContext.xml에 컨테이너 역할을 해주는 파일을 만들어놓고

main class 에서

STEP 1) GenericXmlApplicationContext 클래스를 이용해 컨테이너 생성

STEP 2) 컨테이너 안에 있는 빈이라는 객체를 가져다 쓰기만 한다. 생성은 컨테이너가 알아서 한다.

STEP 3) 사용을 끝낸 컨테이너 자원은 반환한다.

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	   		http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="tWalk" class="testPjt.TransportationWalk"/>

</beans>

<bean id="" calss="패키지명.클래스명" />

이렇게 명시해주면

내가 이 클래스루부터 객체를 사용하기 위해 new로 객체생성하지 않아도 된다.

객체가 생성됐다는 것?은 메모리가 로드됐다는 것을 의미

객체들을 담고 있다. container

main class에서 사용하면 된다.

기존 - new를 이용해서 사용했다.

public static void main(String[] args) {
		TransportationWalk transportationWalk = new TransportationWalk();
		transportationWalk.move();
	}

수정 - 이제는 bean에 등록을 했으니 위의 코드를 지우고

public static void main(String[] args) {
//	객체생성 및 생성자 호출 & 메서드 호출
//	TransportationWalk transportationWalk = new TransportationWalk();
//	transportationWalk.move();
		
//	spring
	//container생성
	GenericXmlApplicationContext ctx = 
               new GenericXmlApplicationContext("classpath:applicationContext.xml");
		
	//tWalk id의 bean을 통해 transportationWalk 객체생성.
	TransportationWalk transportationWalk = ctx.getBean("tWalk" , TransportationWalk.class);
	transportationWalk.move();
		
	//container 자원 반환
	ctx.close();
}

코틀린 퀴즈 -3 확장함수,제네릭, 고차함수, 람다

aonee — Thu, 12 Mar 2020 03:26:43 +0900

Problem 1

함수를 만드시오. a가 true이면 success를 실행하고 a가 false일 때 fail을 실행한다. - 찬영

success와 fail 함수의 반환값은 없다.

success 실행시 1을 출력하고 fail 실행 시 "실패입니다" 출력

Problem 2

val clientDevelop = Developer()로 시작하며 객체의 생성과 초기화를 한번에 해야 한다. - 시연

단, 아무 범위 지정자나 사용하면 안됨

범위 지정 함수 (ex apply, run, with, also, let)

Problem 3

함수를 만드시오. - 찬영

hint : 확장함수 + 제네릭 + 고차함수 + 람다

Problem 4

AutoCompeleteTextView 확장함수를 작성하시오. - 시연

AutoCompeleteTextView는 EditText같은 위젯이고, TextWatcher는 이미 존재하는 인터페이스이다.

search는 따로 만들지 않아도 된다.

Problem 5

jin, won, chan, sion 을 항목으로 가진 리스트를 만들고,

map 함수를 이용하여 다음과 같이 출력하세요 -예진

친구의 이름 -> JIN
친구의 이름 -> WON
친구의 이름 -> CHAN
친구의 이름 -> SION

답

Solution 1

Solution 2

val clientDevelop = Developer().run{
            langauge = "Kotlin"
            team = "Early Buddy"
        }

Solution 3

Solution 4

fun AutoCompeleteTextView.onChange() {
            this.addTextChangedListener(object : TextWatcher {
                override fun afterTextChanged(s: Editable?) {
                }

                override fun beforeTextChanged(s: CharSequence?) {

                }

                override fun onTextChanged(s: CharSequence?) {
                    //통신
                    search(s)
                }
            })
        }

Solution 5

val friends = listOf("jin, won, chan, sion")
        friends.map{
                 friend -> friend.toUpperCase()
        }.forEach{ println(it) }

코틀린 퀴즈 -2 제네릭, 주생성자, 확장함수, 익명함수, 엘비스 연산자

aonee — Thu, 12 Mar 2020 03:24:56 +0900

Problem 1

프로퍼티 1) dest 변수. 타입은 변경가능한 리스트. write 만 가능하다.

프로퍼티 2) src 변수. 타입은 변경 불가능한 리스트. read만 가능하다.

src로 받은 목록을 dest에 추가하는 append 제네릭 함수를 작성하라

open class Car { ... }
class sedan : Car() { ... }
class truck : Car() { ... }

val sedans : List<sedan> = ...
val trucks : List<truck> = ...
val cars : MutableList<Car> = ...

append(cars, sedans)
append(cars, trucks)

Problem 2

여기서 에러가 나는 코드는? (총 4줄)

val name : String
val address : String  = null

val nullableString : String?
val nonNullableString : String = "Foo"


fun Address (a : String, b : String?, c : String) : String {...}
fun Code (a : String) : PostalCode ? { ... }

Address (null, null, "hello")
val postal :PostalCode = Code("adsf adf f f f  f")

Problem 3

Happy 타입이며 한 번 할당되면 값을 변경하지 못하는 smile 변수가 있다.

해당 변수에 findHappy("Let's have a laugh") findHappy함수 결과를 대입하려한다.

그런데 findHappy함수가 널 값을 반환하는 경우 Happy.None값을대입하는코드를 작성하라

Problem 4

Employee 라는 주생성자를 만든다.

프로퍼티가 두개가 있는데 하나는 String 타입이고 이름은 name, 하나는 널값이 될 수 있는 Employee 타입이고 이름은 manager 이다.
managerName 의 함수를 만드는데 이 함수는 Employee를 파라미터 값으로 갖고 반환값은

해당 Employee의 manager의 name 이다. ( 확장함수 이용 ) -찬영

Problem 5

시연

Problem 6

EditText의 값을 Float 형태로 만들 때는 EditText.text.toString().toFloat()이라는 긴 코드를 통해 만들 수 있다.
하지만, 여러개의 EditText를 모두 Float 형태로 만들 때 쟤네들을 일일히 다 호출해주는 것은 불편하다.
이를 해결하여라. -시연

Problem 7

시연

답

Solution 1

fun <T> append (dest : MutableList<in T>, src : List<out T>){
	dest.addAll(src)
}

Solution 2

1, 2 , 7, 8 줄 ERROR Code

val name : String

=> nonNullable. 즉, 초기화 해줘야 한다. val address : String = null

=> nonNullable. null을 대입할 수 없고 값을 대입해야한다.

Address (null, null, "hello")

=> 첫 번째 인자는 null 허용을 안했는데 null을 대입해서 오류 val postal : PostalCode = Code("adsf adf f f f f")

=> Code함수의 return 값이 nullable이다. 즉, null일 수 있다. 그렇다면 postal변수의 값도 nullable이여야 한다.

그러나 nonNuallable이기 때문에 불가능하다.

Solution 3

val smile : Happy = findHappy("Let's have a laugh") ?: Happy.None

Solution 4

Solution 5

Solution 6

fun EditText.convertFloat() {  
	this.text.toString().toFloat() 
}

Solution 7

코틀린 퀴즈 -1 컬렉션, 생성자, 추상클래스, 인터페이스

aonee — Thu, 12 Mar 2020 03:01:39 +0900

Problem 1

코틀린에서는 컬렉션에 자료 수정 가능여부를 제한할 수 있다.

1-1. List 자료구조를 사용하여 aList를 생성하라. String 타입이다. 리스트에 값3개를 초기화한다.

1-2. 초기화 후 리스트에 "data" 값을 추가하려한다. aList.add("data") 가능할까?

1-3. 가능하다면 이유가 무엇인가? 불가능하다면 리스트를 어떻게 수정해야할까?

Problem 2

생성자의 인자를 통해 바로 클래스 내부의 프로퍼티에 값을 할당하는 코드를 작성하시오. -시연

class의 이름은 Foo이며 두개의 프로퍼티를 갖는다.

첫번째 프로퍼티의 타입은 Int, 이름은 a 이고 한번 할당되면 값을 바꿀 수 없다.

두번째 프로퍼티의 타입은 String, 이름은 b 이고 할당 된 후에도 값 수정이 가능하다.

Problem 3

Shape 인터페이스를 작성하는데 한 개의 프로퍼티와 두개의 함수를 가지고 있다. -찬영

프로퍼티의 타입은 Int이고 이름은 width 이고, 수정이 가능한 값이다.
첫번째 함수의 타입은 Double 이고 이름은 getWidth 이다. 이 함수에는 구현부를 만들지마라.
두번째 함수의 타입은 Unit 이고 이름은 islarge 이다. 이 함수에는 구현부를 만드는데 아무것도 넣지마라.

Problem 4

해당 추상 클래스와 인터페이스의 인스턴스를 생성하시오 -시연

(단, 인스턴스의 이름은 foo 이며 한번 할당 되면 수정이 불가능하다.)

4-1)

추상 클래스는 다음과 같이 선언되어 있다.
abstract class Foo {
abstract fun bar()
}

4-2)

인터페이스는 다음과 같이 선언되어 있다.
interface Bar {
fun baz()
}

답

Solution 1

1-1

aList.add("dd");  val aList : List = listOf("aa", "bb", "cc");

1-2
불가능하다. 그 이유는 List 인터페이스는 불가변이기 때문이다. 즉, 값을 수정할 수 없다.

1-3

val bList : MutableList = arrayListOf("aa", "vv", "cc"); 
bList.add("data");   // MutableList이기 때문에 추가 가! 능!

Solution 2

class Foo (val a : Int, var b : String)

Solution 3

interface Shape{    
	var width : Int    
	fun getWidth() : Double    
	fun isLarge() {}
}

구현부 {}가 존재하지 않으면 반드시 구현해야한다. 즉, width와 getWidth()는 반드시 구현해야한다.

구현부{} 가 존자하는 isLarge()는 구현이 되어있기 때문에 반드시 구현할 필요가 없다.

Solution 4

4-1

val foo = object : Foo(){    
	override fun bar() 
}

주의

추상클래스는 클래스이기 때문에 반드시 인스턴스 생성 시 Foo() 맞음. Foo 아님. 생성자를 사용한다.

4-2

val foo  = object : Bar {    
	override fun baz() 
}

주의

인터페이스는 인터페이스 이름 형태로 인스턴스 생성. Bar() 아님. 그냥 Bar

[Kotlin] 커니의 코틀린-(8) 코틀린 안드로이드 익스텐션

aonee — Wed, 11 Mar 2020 22:04:38 +0900

차세대 안드로이드 개발자를 위한 커니의 코틀린

ch8 코틀린 안드로이드 익스텐션

1. 코틀린 안드로이드 익스텐션 소개

특정 값의 일치 여부 확인 : check, require

[ 사용목적 ]

✔ findVIewById() 메서드 없이

findVIewById() 메서드는 액티비티나 프래그먼트 등 레이아웃 파일에 선언된 여러개의 뷰로 구성된 화면에서 특정 뷰의 인스턴스를 얻기 위해 사용한다.

-> 반환한 뷰 객체를 잘못된 타입의 뷰로 캐스팅하거나 다른 레이아웃에 선언된 ID를 잘못 사용하면 널 값을 반환한다.

값 확인 OR 조건 일치하지 않았을 경우 수행할 작업 지정가능.

check() - IllegalStateException 발생시킴
require() - IllegalArgumentException 발생시킴
checkNotNull() 함수와 requireNotNull() 함수로 특정 값의 null 여부를 확인하고 nul이 아닌 값을 반환 받을 수 있다.

명시적으로 실행 중단하기 : error, TODO

[ 사용목적 ]✔ 호출될 가능성이 없는 영역에 진입하게 되는 경우 임의로 예외를 발생시켜 프로그램의 실행을 막기 위해

정상적으로 프로그램이 실행될 경우 호출될 가능성이 없는 영역 존재.

이 경우, 부작용 예측이 어렵다.

따라서, 예외를 발생시켜 프로그램의 실행을 막을 수 있다.

fun error(message: String) : Nothing - 인자로 받은 message와 함께 IllegalStateException을 발생시킴
fun TODO(): Nothing - NotImplementedError 예외를 발생시켜 이 부분이 완성되지 않았음을 알려줌
fun TODO(reason: String): Nothing - 에러 메시지에 표시될 상세 내용을 reason 매개변수를 통해 전달

2. 컬렉션 생성 함수

배열

fun <T> arrayOf(vararg elements: T): Array<T> - 함수의 인자로 받은 값으로 구성된 배열 반환
fun <T> emptyArray(): Array<T> - 특정 타입을 갖는 빈 배열 반환
fun <T> arrayOfNulls(size: Int): Array<T?> - 배열 내 각 값들이 모두 null 값으로 초기화

리스트

fun <T> listOf(vararg elements: T): List<T> - 수정할 수 없는 리스트
fun <T : Any> listOfNotNull(vararg elements: T?): List<T>
fun <T> mutableListOf(vararg elements: T): MutableList<T>
fun <T> arrayListOf(vararg elements: T): ArrayList<T>

맵

포함하는 요소를 읽을 수만 있고 수정할 수 없는 맵은 다음과 같이 생성할 수 있다.

fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

포함하고 있는 요소를 수정할 수 있는 맵은 mutableMapOf() 함수를 사용하여 생성할 수 있다.

fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

보다 명시적인 타입의 맵을 생성해야 하는 경우 hashMapOf(), linkedMapOf(), sortedMapOf() 함수를 사용할 수 있다.

fun hashMapOf(vararg pairs: Pair<K, V>) : HashMap<K, V>
fun linkeMapOf(vararg pairs : Pair<K, V>) : LinkedHashMap<K, V>
fun sortedMapOf(vararg pairs : Pair<K, V>) : SortedMap<K, V>

집합

집합(set)은 중복되지 않는 요소들로 구성된 자료구조

포함하는 요소를 읽을 수만 있고 수정할 수 없는 집합은 다음과 같이 생성한다.

fun <T> setOf(vararg elements: T): Set<T>

집합에 포함된 요소를 수정할 수 있는 집합은 mutableSetOf() 함수를 사용하여 생성한다.

fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

보다 명시적인 타입의 집합을 생성해야 하는 경우 hashSetOf(), linkedSetOf(), sortedSetOf() 함수를 사용할 수 있다.

fun <T> hashSetOf(vararg elements: T) : HashSet<T>
fun <T> linkedSetOf(vararg elements: T) : LinkedHashSet<T>
fun <T> sortedSetOf(vararg elements: T) : TreeSet<T>

3. 스트림 함수

변환

map(): 컬렉션 내 인자를 다른 값 혹은 타입으로 변환할 때 사용한다.
mapIndexed(): 사용하면 컬렉션 내 포함된 인자의 인덱스 값을 변환 함수 내에서 사용할 수 있다.
mapNotNull(): 컬렉션 내 각 인자를 변환함과 동시에, 변환한 결과가 null 값인 경우 이를 무시한다.
flayMap(): map()과 달리 변환 함수의 반환형이 Interable. 따라서 하나의 인자에서 여러 개의 인자로 매핑이 필요한 경우 사용한다.
groupBy(): 컬렉션 내 인자들을 지정한 기준에 따라 분류하며, 각 인자들의 리스트를 포함하는 맵 형태로 결과를 반환한다.

 @Test
    fun MapTest(){

        // map ()
        val cities = listOf("Seoul, Tokyo, Moutain View")
        cities.map{
            city -> city.toUpperCase()
        }.forEach{ println(it) }

        //mapIndexed()
        val numbers = 0..10
        numbers.mapIndexed{
            idx, number -> idx * number
        }.forEach { print("$it ")}


        //mapNotNull() : 값이 Null이면 무시
        cities.mapNotNull{
                city -> if (city.length <= 5) city else null
        }.forEach{ println(it) }


        //groupBy()
        cities.groupBy { city -> if(city.length <= 5) "A" else "B"}
            .forEach { key, cities -> println("key = $key cities = $cities") }
    }

필터

filter() 함수는 컬렉션 내 인자들 중 주어진 조건과 일치하는 인자만 걸러주는 역할을 한다.

take() 함수는 컬렉션 내 인자들 중 앞에서 take() 함수의 인자로 받은 개수만큼만을 인자로 갖는 리스트를 반환한다.

drop() 함수는 take()함수의 반대 역할. 조건을 만족하는 항목ㅇ르 컬렉션에서 제외한 결과를 반환한다.

first() 함수는 컬렉션 내 첫번재 인자를 반환한다.

last() 함수는 first() 함수와 반대 역할. 컬렉션 내 마지막 인자를 반환한다.

distinct() 함수는 컬렉션 내에 포함된 항목 중 중복된 항목을 걸러낸 결과를 반환한다.

조합 및 합계

zip() 함수는 두 컬렉션 내의 자료들을 조합하여 새로운 자료를 만들 때 사용한다.

count() 함수는 컬렉션 내 포함된 자료의 개수 반환한다.

reduce() 함수는 컬렉션 내 자료들을 모두 합쳐 하나의 값으로 만들어주는 역할을 한다.

fold() 함수는 reduce()와 유사하지만 초깃값 지정 가능하다.

기타

any() 함수는 컬렉션 내 단 하나의 자료라도 존재하면 true를, 그렇지 않으면 false를 반환한다.

none() 함수는 any()함수의 반대.

max() : 최댓값

min() : 최솟값

average() : 평균

4. 범위 지정 함수

특정 객체에 있는 함수를 연속해서 사용 OR 다른 함수의 인자로 전달하기 위해 변수를 선언하고 다른 곳에서 사용하지 않는 등의 경우가 있다.

이때 유용하게 사용할 수 있는 함수를 표준 라이브러리를 통해 제공한다.

let() 함수

해당 함수를 호출한 객체를 이어지는 함수 블록의 인자로 전달한다

[ 사용목적 ]

✔ 불필요한 변수 선언을 방지

✔ null 값이 아닌 경우를 체크한 후 특정 작업을 수행하는 코드에 사용

fun <T, R> T.let ( block : (T) -> R ) : R

fun doSomething(message : String?){
            message?.let{
                println("message : $message")
            }
        }
        doSomething("let함수 예제입니당")

apply() 함수

해당 함수를 호출한 객체를, 이어지는 함수 블록의 리시버(receiver)로 전달한다.

[ 사용목적 ]

✔ 객체 이름 없이 직접 해당 객체 내부에 속성에 접근 가능

fun <T> T.apply ( block : T.() -> Unit ) : T

with() 함수

인자로 받은 객체를 이어지는 함수 블록의 리시버로 전달한다.

[ 사용목적 ]

✔ 함수의 인자로 전달 받은 객체 내부에 속성에 접근 가능

fun <T, R> with (receiver : T, block : T.() -> R ) : R

fun doSomething(messageView : TextView){
            with(messageView){
                text = "Hello, world" 
                gravity = Gravity.CENTER_HORIZONTAL 
            }
        }

run() 함수

인자가 없는 익명 함수처럼 사용하는 형태와, 객체에서 호출하는 형태를 제공

[ 사용목적 ]

✔ 인자가 없는 익명 함수처럼 사용하는 경우, 복잡한 계산을 위해 여러 임시 변수가 필요할 때 유용하게 사용

run() 함수 내부에서 선언되는 변수들은 블록 외부에 노출되지 않으므로 변수 선언 영역을 확실히 분리

✔ 객체에서 run() 함수를 호출하는 경우 with() 함수와 유사한 목적으로 사용.

✔ run() 함수는 안전한 호출을 사용할 수 있으므로 null 값일 수 있는 객체의 속성이나 함수에 연속적으로 접근해야 할 때 유용

fun <R> run ( block : () -> R) : R
fun <T, R> run ( block : T.() -> R ) : R

참고

[Kotlin] 커니의 코틀린-(4) 코틀린 표준 라이브러리

aonee — Wed, 11 Mar 2020 18:23:42 +0900

차세대 안드로이드 개발자를 위한 커니의 코틀린

ch4 코틀린 표준 라이브러리

1. 조건 확인 함수

특정 값의 일치 여부 확인 : check, require

[ 사용목적 ]

✔ 함수 OR 생성자의 인자로 전달받은 값 사용하기 전, 그 값의 유효성 검사

✔ 버그 방지하기 위해 명시적으로 에러 발생 사실 알리고 프로그램 종료

값 확인 OR 조건 일치하지 않았을 경우 수행할 작업 지정가능.

check() - IllegalStateException 발생시킴
require() - IllegalArgumentException 발생시킴
checkNotNull() 함수와 requireNotNull() 함수로 특정 값의 null 여부를 확인하고 nul이 아닌 값을 반환 받을 수 있다.

명시적으로 실행 중단하기 : error, TODO

[ 사용목적 ]

✔ 호출될 가능성이 없는 영역에 진입하게 되는 경우 임의로 예외를 발생시켜 프로그램의 실행을 막기 위해

정상적으로 프로그램이 실행될 경우 호출될 가능성이 없는 영역 존재.

이 경우, 부작용 예측이 어렵다.

따라서, 예외를 발생시켜 프로그램의 실행을 막을 수 있다.

fun error(message: String) : Nothing - 인자로 받은 message와 함께 IllegalStateException을 발생시킴
fun TODO(): Nothing - NotImplementedError 예외를 발생시켜 이 부분이 완성되지 않았음을 알려줌
fun TODO(reason: String): Nothing - 에러 메시지에 표시될 상세 내용을 reason 매개변수를 통해 전달

2. 컬렉션 생성 함수

배열

fun <T> arrayOf(vararg elements: T): Array<T> - 함수의 인자로 받은 값으로 구성된 배열 반환
fun <T> emptyArray(): Array<T> - 특정 타입을 갖는 빈 배열 반환
fun <T> arrayOfNulls(size: Int): Array<T?> - 배열 내 각 값들이 모두 null 값으로 초기화

리스트

fun <T> listOf(vararg elements: T): List<T> - 수정할 수 없는 리스트
fun <T : Any> listOfNotNull(vararg elements: T?): List<T>
fun <T> mutableListOf(vararg elements: T): MutableList<T>
fun <T> arrayListOf(vararg elements: T): ArrayList<T>

맵

포함하는 요소를 읽을 수만 있고 수정할 수 없는 맵은 다음과 같이 생성할 수 있다.

fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

포함하고 있는 요소를 수정할 수 있는 맵은 mutableMapOf() 함수를 사용하여 생성할 수 있다.

fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

보다 명시적인 타입의 맵을 생성해야 하는 경우 hashMapOf(), linkedMapOf(), sortedMapOf() 함수를 사용할 수 있다.

fun hashMapOf(vararg pairs: Pair<K, V>) : HashMap<K, V>
fun linkeMapOf(vararg pairs : Pair<K, V>) : LinkedHashMap<K, V>
fun sortedMapOf(vararg pairs : Pair<K, V>) : SortedMap<K, V>

집합

집합(set)은 중복되지 않는 요소들로 구성된 자료구조

포함하는 요소를 읽을 수만 있고 수정할 수 없는 집합은 다음과 같이 생성한다.

fun <T> setOf(vararg elements: T): Set<T>

집합에 포함된 요소를 수정할 수 있는 집합은 mutableSetOf() 함수를 사용하여 생성한다.

fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

보다 명시적인 타입의 집합을 생성해야 하는 경우 hashSetOf(), linkedSetOf(), sortedSetOf() 함수를 사용할 수 있다.

fun <T> hashSetOf(vararg elements: T) : HashSet<T>
fun <T> linkedSetOf(vararg elements: T) : LinkedHashSet<T>
fun <T> sortedSetOf(vararg elements: T) : TreeSet<T>

3. 스트림 함수

변환

map(): 컬렉션 내 인자를 다른 값 혹은 타입으로 변환할 때 사용한다.
mapIndexed(): 사용하면 컬렉션 내 포함된 인자의 인덱스 값을 변환 함수 내에서 사용할 수 있다.
mapNotNull(): 컬렉션 내 각 인자를 변환함과 동시에, 변환한 결과가 null 값인 경우 이를 무시한다.
flayMap(): map()과 달리 변환 함수의 반환형이 Interable. 따라서 하나의 인자에서 여러 개의 인자로 매핑이 필요한 경우 사용한다.
groupBy(): 컬렉션 내 인자들을 지정한 기준에 따라 분류하며, 각 인자들의 리스트를 포함하는 맵 형태로 결과를 반환한다.

 @Test
    fun MapTest(){

        // map ()
        val cities = listOf("Seoul, Tokyo, Moutain View")
        cities.map{
            city -> city.toUpperCase()
        }.forEach{ println(it) }

        //mapIndexed()
        val numbers = 0..10
        numbers.mapIndexed{
            idx, number -> idx * number
        }.forEach { print("$it ")}


        //mapNotNull() : 값이 Null이면 무시
        cities.mapNotNull{
                city -> if (city.length <= 5) city else null
        }.forEach{ println(it) }


        //groupBy()
        cities.groupBy { city -> if(city.length <= 5) "A" else "B"}
            .forEach { key, cities -> println("key = $key cities = $cities") }
    }

필터

filter() 함수는 컬렉션 내 인자들 중 주어진 조건과 일치하는 인자만 걸러주는 역할을 한다.

take() 함수는 컬렉션 내 인자들 중 앞에서 take() 함수의 인자로 받은 개수만큼만을 인자로 갖는 리스트를 반환한다.

drop() 함수는 take()함수의 반대 역할. 조건을 만족하는 항목ㅇ르 컬렉션에서 제외한 결과를 반환한다.

first() 함수는 컬렉션 내 첫번재 인자를 반환한다.

last() 함수는 first() 함수와 반대 역할. 컬렉션 내 마지막 인자를 반환한다.

distinct() 함수는 컬렉션 내에 포함된 항목 중 중복된 항목을 걸러낸 결과를 반환한다.

조합 및 합계

zip() 함수는 두 컬렉션 내의 자료들을 조합하여 새로운 자료를 만들 때 사용한다.

count() 함수는 컬렉션 내 포함된 자료의 개수 반환한다.

reduce() 함수는 컬렉션 내 자료들을 모두 합쳐 하나의 값으로 만들어주는 역할을 한다.

fold() 함수는 reduce()와 유사하지만 초깃값 지정 가능하다.

기타

any() 함수는 컬렉션 내 단 하나의 자료라도 존재하면 true를, 그렇지 않으면 false를 반환한다.

none() 함수는 any()함수의 반대.

max() : 최댓값

min() : 최솟값

average() : 평균

4. 범위 지정 함수

특정 객체에 있는 함수를 연속해서 사용 OR 다른 함수의 인자로 전달하기 위해 변수를 선언하고 다른 곳에서 사용하지 않는 등의 경우가 있다.

이때 유용하게 사용할 수 있는 함수를 표준 라이브러리를 통해 제공한다.

let() 함수

해당 함수를 호출한 객체를 이어지는 함수 블록의 인자로 전달한다

[ 사용목적 ]

✔ 불필요한 변수 선언을 방지

✔ null 값이 아닌 경우를 체크한 후 특정 작업을 수행하는 코드에 사용

fun <T, R> T.let ( block : (T) -> R ) : R

fun doSomething(message : String?){
            message?.let{
                println("message : $message")
            }
        }
        doSomething("let함수 예제입니당")

apply() 함수

해당 함수를 호출한 객체를, 이어지는 함수 블록의 리시버(receiver)로 전달한다.

[ 사용목적 ]

✔ 객체 이름 없이 직접 해당 객체 내부에 속성에 접근 가능

fun <T> T.apply ( block : T.() -> Unit ) : T

with() 함수

인자로 받은 객체를 이어지는 함수 블록의 리시버로 전달한다.

[ 사용목적 ]

✔ 함수의 인자로 전달 받은 객체 내부에 속성에 접근 가능

fun <T, R> with (receiver : T, block : T.() -> R ) : R

fun doSomething(messageView : TextView){
            with(messageView){
                text = "Hello, world" 
                gravity = Gravity.CENTER_HORIZONTAL 
            }
        }

run() 함수

인자가 없는 익명 함수처럼 사용하는 형태와, 객체에서 호출하는 형태를 제공

[ 사용목적 ]

✔ 인자가 없는 익명 함수처럼 사용하는 경우, 복잡한 계산을 위해 여러 임시 변수가 필요할 때 유용하게 사용

run() 함수 내부에서 선언되는 변수들은 블록 외부에 노출되지 않으므로 변수 선언 영역을 확실히 분리

✔ 객체에서 run() 함수를 호출하는 경우 with() 함수와 유사한 목적으로 사용.

✔ run() 함수는 안전한 호출을 사용할 수 있으므로 null 값일 수 있는 객체의 속성이나 함수에 연속적으로 접근해야 할 때 유용

fun <R> run ( block : () -> R) : R
fun <T, R> run ( block : T.() -> R ) : R

참고

https://medium.com/@fatihcoskun/kotlin-scoping-functions-apply-vs-with-let-also-run-816e4efb75f5

Kotlin Scoping Functions apply vs. with, let, also, and run

Functional-style programming is highly advocated and supported by Kotlin’s syntax as well as a range of functions in Kotlin’s standard…

medium.com

[Nodejs] express 구조, 라우팅 방법, package-lock.json 사용이유

aonee — Sat, 7 Mar 2020 22:14:29 +0900

Express

node를 위한 빠르고 간결한 웹 프레임워크로 기존 메소드 + 편리한 메소드 추가해서 기능 보완했다.

(프레임워크란 ? 설계의 기반이 되는 부분을 기술한 확장 가능한 기반 코드 + 필요한 라이브러리 통합되어 제공하는 형태)

HTTP요청에 대해 라우팅 및 미들웨어 기능 제공

라우팅 : 서버경로제어, 통신 데이터를 보낼 경로 선택

미들웨어 : 부가적인 기능이나 처리를 제공하는 목적

express-generator

Nodejs + Express 구조의 뼈대를 만들 수 있다

설치 : npm install -g express-generator

프로젝트 생성 : express 생성할프로젝트이름

서버 시작 : npm start

모듈 설치 : npm install

프로젝트 구조

./package-lock.json 파일이란?

npm을 사용해 node_modules 트리 OR package.json파일을 수정하면 자동으로 생성되는파일
이 파일은 파일이 생성되는 시점의 의존성 트리에 대한 정확한 정보를 가지고 있다.

필요한 이유?

1. 의존성 트리에 대한 정보를 모두 가지고 있다.

2. github 저장소에 꼭 같이 커밋을 해야한다. 특히, node_modules 없이 배포하는 경우 반드시 필요하다!!

예시) node_modules 폴더를 제외하고 저장된 저장소의 파일을 pull 받았을 때

./package-lock.json 없으면 ? => 의존성 트리의 일부 버전이 다르게 설치됨

있으면 ? => 동일한 버전으로 잘 설치됨

/routes 파일 기본 구조

var express = require('express');

var router = express.Router();



router.get('/', function(req, response, next){



});



module.exports = router;

request처리

req.query : url query문자열

url?str=hello console.log(req.query.str) //결과 : hello

req.params : url에서 변수로 넘어온 것

url/idx url/1004 console.log(req.params.str) //결과 : 1004

req.body : body로 넘어온 값

req.file : 파일을 전송받았을 떄

response처리

res.status() : 정수 값으로 status code 작성

res. send() : JSON형식으로 response body작성

라우팅 - 파일 접근 방법

	>config
		dbconfig.js
	>errors
		DatabaseError.js
		DuplicatedEntryError.js
		index.js
		NoReferenceRowError.js
		NotMatchedError.js
		ParameterError.js
	>models
		Comment.js
		Todo.js
	
	>modules
		>db
		  pool.js
		>utils
		  index.js
		  responseMessage.js
		  statusCode.js
		  util.js
	
	>routes
		>todos
			>todos.js
			>index.js
			router.use('/:todoId/comments', require('./comments'));
			router.use('/', require('./todos'));		
			
			>comments
				>comments.js
				>index.js
				router.use('/', require('./comments'));	
		>index.js
		router.use('/todos', require('./todos'));
	
	>app.js
    	const indexRouter = require('./routes/index');
    	app.use('/', indexRouter);
	>index.js

1. app.js : 라우팅의 시작점. require('./routes/index')를 통해 routes/index 폴더 호출.

2. routes/index

3. routes/todo/index

4. routes/todo/comments/index

[Git ppt 자료 4] 이클립스에서 Git Flow전략을 적용한 협업방법 (master-develop-feature)

aonee — Wed, 4 Mar 2020 01:31:53 +0900

[Git ppt 자료 Link]

[Git ppt 자료 1] Git 필요성, Github 저장소 생성 방법, git 기초 명령어
[Git ppt 자료 2] Branch란? Git Flow란?

[Git ppt 자료 3] 이클립스에서 Git 연동, 사용법, 팀장과 팀원의 협업방법까지 총정리

6.1 협업방식 적용 이유

6.2 협업방식 적용 장점

6.협업(공통) 1. Issue

6.협업(공통) 2. Branch 생성 및 작업

6.협업(공통) 3. Commit & Push

6.협업(공통) 4.Pull Request (= PR)

6.협업(공통) 5. 코드리뷰 (선택사항)

6.협업(공통) 6. Merge (코드병합)

6.협업(공통) 7. Chekcout branch develop

checkout 이란? branch를 이동할 때 사용하는 명령어이다.

6.협업(공통)

6.협업(공통) 9. delete feature branch

feature branch 삭제

6.협업(공통) 10.정리

또 다른 기능을 구현하기 위해서는 다시 6-1번~9번을 수행하면 된다!

[Git ppt 자료 2] Branch란? Git Flow란?

aonee — Wed, 4 Mar 2020 00:55:24 +0900

[Git ppt 자료 Link]

[Git ppt 자료 1] Git 필요성, Github 저장소 생성 방법, git 기초 명령어

[Git ppt 자료 3] 이클립스에서 Git 연동, 사용법, 팀장과 팀원의 협업방법까지 총정리
[Git ppt 자료 4] 이클립스에서 Git Flow전략을 적용한 협업방법 (master-develop-feature)

04. Git Flow

4.1 branch란

4.2 gitflow란

Eclipse - NoClassDefFoundError: org/bouncycastle/jce/provider/BouncyCastleProvider

aonee — Tue, 3 Mar 2020 19:12:02 +0900

jar 파일 적용이 안돼서 발생하는 문제

NoClassDefFoundError : 컴파일타임때 요구되는 클래스가 존재하지만 실행환경에서 참조가 안된 경우 발생하는 에러

해결

1. widow - preferences - Java - Build Path - User Libraries

여기서

New - library명 내가 원하는대로 적고 ok - apply and close

project 우클릭 - build path - add libraries - User Library - 내가 만든 라이브러리 선택 - Finish

[Nodejs] 자바스크립트 기초

aonee — Sun, 1 Mar 2020 23:41:38 +0900

기본자료형

Boolean, Number, String, Null, Undefined, Symbol

객체

Function, Array, Object
관련된 데이터와 함수(property와 method)의 집합
{} 키워드
memberName: memberValue형태
모든 객체는 JSON으로 표기가 가능하다.
JSON 표기법으로 객체를 만들 수 있다.

var arr = {};
var person = {
	name : "최예원",
        address : "seoul"
};

배열

자바스크립트에서 배열은 객체다. 즉 다양한 메소드를 지원한다.
자바스크립트에서 배열에는 어떤 값도 들어 갈 수 있다.
[] 키워드를 이용해서 표현

var array1 = [];  // var array1 = new Array();
var array2 = [1, 2, 3, 4, 5]; 
var array3 = [“최예원”, 3, 4.5, false, {name: “yewon”, address: ”seoul”}];

함수

자바스크립트에서 함수는 객체다
함수를 생성하는 방법에는 함수 선언식과 함수 표현식이 있다.
호이스팅에 영향을 받는 함수 선언식
function add(x, y){ return x + y; }
호이스팅에 영향을 받지 않는 함수 선언식
var add = function(x, y) { return x + y; }
var add = (x, y) => { return x + y; }

일급 객체

변수 or 데이터 구조에 담을 수 있다.
다른 함수의 파라미터로 전달할 수 있다.
반환 값으로 사용할 수 있다.
런타임 시 생성될 수 있다.

var, let, const

var	let	const
재 선언 가능	재 선언 불가능	재 선언 불가능
재 할당 가능	재 할당 가능	재 할당 불가능

재 선언 가능 : 같은 이름의 변수를 다시 선언할 수 있다.
var a = 24;
var a = 25;
재 할당 가능 : 변수가 새로운 값을 가질 수 있다.
var a = 24; a = 25;

JSON?

JavaScript Object Notation. js에서 객체 만들 때 사용하는 표현식

경량의 데이터 교환 가능

특정언어에 종속되지 않음

클라이언트와 데이터교환시 사용 : aplication/json

var jsonEx = {

"nickname" : "애오니",

"hobby" : "Programming"

}

객체요소 접근 2가지 방법

방법1)

console.log(jsonEx["nickname"]);

console.log(jsonEx["hobby"]);

방법2)

console.log(jsonEx.nickname);

console.log(jsonEx.hobby);

json 객체 값 접근

for(key in jsonEx){

console.log(key + ", " + jsonEx[key]);

}

커니의 코틀린-(2) 자바와 비교해보는 코틀린 컬렉션, 클래스, 인터페이스, 싱글톤, 제네릭, 널 안전성

aonee — Fri, 28 Feb 2020 17:08:14 +0900

차세대 안드로이드 개발자를 위한 커니의 코틀린

ch2 자바와 비교해보는 코틀린

2.2 컬렉션

java : 자료 수정 가능여부 제한 불가능. 가변만 존재

Kotlin : 자료 수정 가능여부 제한 가능. 가변, 불가변 모두 존재

2.3 클래스 및 인터페이스

프로퍼티

Java : 클래스 내에 자료를 저장하고 접근하기 위해 필드와 메서드를 사용한다.

자료에 접근하기 위해서는 Getter/Setter 메서드를 추가해야해서 불필요하게 코드가 길어진다

Kotlin : 이러한 불편함을 개선하기 위해 프로퍼티를 사용한다.

생성자

Java : 필드 정의, 생성자 초기화 코드를 직접 작성해야 한다.

Kotlin : 한 줄의 코드로 인자로 받은 값을 사용하여 내부의 필드 및 프로퍼티에 값을 할당할 수 있다.

클래스와 인터페이스의 선언 및 인스턴스 생성

추상클래스

Java : 클래스의 인스턴스를 생성하기 위해 new 키워드를 사용

Kotlin : object : [생성자] 형태로 선언 ex) object : Foo()

인터페이스

Java : 클래스의 인스턴스를 생성하기 위해 new 키워드를 사용

Kotlin : object : [인터페이스 이름] 형태로 선언 ex) object : Bar

추상클래스와 인터페이스의 공통점과 차이점에 대해 알고 싶다면? Click

공통점과 목적 및 특징의 차이점에 대해 적어놨습니다

싱글톤

java와 달리 kotlin은 object를 붙여 코드 한 줄로 쉽게 싱글톤을 생성할 수 있다.

object singleton{

	val test1 = "test다!"
    
    fun testValue() {}
}

//object singleton의 test1참조
val refTest1 = singleton.test1

//object singleton의 testValue 함수참조
singleton.testValue()

2.6 제네릭

인자로 사용하는 타입에 따라 구체화되는 클래스나 인터페이스

1. 클래스 인터페이스 정의

class Car(){ ... }

interface Container<T>{    //타입을 Car 클래스에 한정하고 싶은 경우, Container<T : Car>
	fun put(item : T)
    fun take() : T
}

class Garage : Container<Car>{
	override fun put(item : Car){ ...  }
    override fun take() : Car { ... }
}

2. 제네릭을 인자로 받는 함수

Java : ? super T, ? extends T

Kotlin : in T, out T

T : 별도의 Wildcard 정의가 없이 read/write 모두 가능

in T : Java의 ? super T와 같음. input의 약자이며 write 만 가능

out T : Java의 ? extends T와 같음. output의 약자이며 read 만 가능

2.8 널 안전성

프로그램을 개발하며 가장 빈번하게 발생하는 오류는 널 포인터 예외이다.

Java : @Nullable @NonNull 어노테이션을 사용하여 객체의 널 허용여부를 표시

Kotlin : ?를 붙이면 Nullable

1. 널 허용 여부 표기

2. 엘비스 ( ?: ) 연산자. 널 값을 대신하는 방법

널 값을 허용하지 않는 값 or 변수에 널 값을 반환할 수 있는 함수의 결과를 대입해야하는 경우에 사용한다

조건문과 유사하다.

//foo가 널이면 bar반환
foo ?: bar

//Code함수가 널이면 Code.NONE 대입
val postal : PostalCode = Code("1600 pppp cd") ?: Code.NONE

fun MapImage (address : String){
	//Code함수가 널이면 함수 실행을 종료하고 결과로 null 반환
	val postal = Code("1600 pppp cd") ?: return null
    
    //지도 이미지 생성
    ...
}

3. 안전한 호출 ( ?. ) 연산자. 널 값 확인과 처리 한번에

java : null 값 여부 확인을 위해 주로 if문 사용

Kotlin

//bar가 null이 아닐 경우만 foo에 값 대입. null인 경우는 null 대입
val foo = bar?.baz

//foo가 null 아닐 경우에 bar() 호출
foo?.bar()

4. as? 연산자. 안전한 자료형 변환

지원되지 않는 자료형 변환을 시도하는 경우 예외 발생시키는 대신 널 값 반환해준다.

5. !! 비 널값 보증 연산자. 널 값 아님 명시

보증하려는 항목 뒤에 !!을 붙여 사용.

그러나, null인 경우 예외가 발생하니 주의

6. lateinit 키워드. 나중에 초기화 되는 변수를 위해

Kotlin : 널 값 허용하지 않는 경우 초기화 or 생성자를 통해 초기화 강제함.

그러나, 초기화 없이 변수만 선언할 수 있다. 바로 lateinit 키워드를 사용하여!

디스크 하나 망가짐	미러본으로 서비스 정상 운영
디스크 교체	ASM이 자동으로 데이터 재복제

일반 DB	RAC 구성
서버 1대 다운 = 서비스 중단	다른 서버가 즉시 이어받음 (무중단)