KoreanPaper

객체지향 프로그래밍 기초

KoreanPaper — Fri, 15 May 2026 16:24:39 +0900

1. 객체와 클래스 : 사용자 정의 자료형의 이해

객체지향 프로그래밍의 가장 큰 특징 중 하나는

사용자가 새로운 자료형을 직접 정의해서 사용할 수 있다는 점이다.

우리는 int, string 같은 자료형을 사용해 데이터를 저장한다.

자바는 이처럼 내가 원하는 구조를 가진 새로운 자료형도 만들 수 있다.

예를 들어 '책'이라는 자료형이 필요하다면 '제목/저자/가격' 과 같은 정보로 묶을 수 있다.

객체(Object)

객체는 서로 다른 타입의 데이터를 하나로 묶은 구조이다.(이질적)

즉, 관련된 데이터를 하나의 단위로 관리하기 위한 개념이다.

클래스(Class)

클래스는 객체를 생성하기 위한 설계도이다.

public class Book{
    public String title;
    public String author;
    public int price;
}

'책' 이라는 새로운 자료형을 정의

객체 생성 과정

1. Book 타입의 변수 b 선언

Book b;

2. 메모리에 실제 Book 객체 생성

new Book();

3. 생성된 객체의 주소를 변수 b에 저장

b = new Book();

이를 합치면 다음과 같이 표현된다.

Book b = new Book();

2. 클래스와 배열의 차이 + 객체 배열

클래스 : 서로 다른 타입의 데이터를 묶어 관리한다.

class Person {
    String name;
    int age;
}

배열 : 동일한 타입의 데이터를 묶어 관리한다.

int[] a = new int[5]

* 자바는 배열도 객체로 취급된다.

객체 배열 : 사용자가 만든 자료형을 배열로 생성

Book[] books = new Book[3];

books[0]=new Book();
books[1]=new Book();
books[2]=new Book();

3. Method (메서드)

메서드는 객체의 동작(행위)을 정의하는 기능이다.

public int add(int x, int y){
	int z = x+y;
    return z;
}

메서드 구성요소

1. 접근 제한자 : Public / Private / Protected / default(생략)

* Public으로 선언된 클래스는 반드시 파일이름과 같아야함.

* 같은 파일에 여러 클래스를 작성할 경우, public 제거하고 작성 ( 다른 패키지에 접근 제한됨)

2. 반환 타입 (리턴 타입) : int, String, void 등

* 반환 값이 없는 경우에는 void 사용 (ex. System.out.println)

3. 메서드 이름 (매개 변수=파라미터) : 메서드 실행에 필요한 값을 전달 받는다.

메서드 Overloading

하나의 클래스 안에서 같은 이름의 메서드를 여러 개 정의하는 기법

public int add(int a, int b) {
    return a + b;
}

public double add(double a, double b) {
    return a + b;
}

오버로딩 조건

- 메서드 이름이 같아야 함

- 매개변수의 타입 또는 개수가 달라야함.

오버로딩과 바인딩

오버로딩은 컴파일 시점에 호출할 메서드가 결정된다.

이를 '정적 바인딩'이라고 한다.

4. 클래스 구성 요소

클래스는 크게 두 가지 정보로 구성된다.

- 상태 정보 > 멤버 변수

- 행위 정보 > 멤버 메서드

public class Person{

    public String name;
    public int age;

    public void play(){
        System.out.println("밥을 먹는다");
    }
    
    // 생성자 메서드
    public Person(){
    	// 객체를 생성하는 코드
    }
}

5. 생성자 (Constructor)

생성자는 객체를 생성하고 초기화 하는 특별한 메서드이다.

public class Person {

    public Person() {
		// 객체 초기화 코드
    }
}

특징

- 클래스 이름과 동일

- 반환 타입 없음

- 객체 생성 시 자동 호출

- 객체 초기화 용도로 사용

Person p = new Person();

위 코드에서 new Person()이 생성자를 호출한다.

*실제 메모리 할당은 new가 수행, 생성자는 초기화 담당

5. 클래스 종류 (Model)

1. Main Class

프로그램 실행 시작 지점이 되는 클래스

public static void main(String[] args)

2. DTO / VO

데이터를 저장하고 전달하기 위한 객체 = 계층 간 데이터를 전달하기 위한 객체

class BookDTO {
    private String title;
    private int price;
}

데이터를 하나로 묶어야할 경우 사용 (데이터를 하나로 수집)

DB에 있는 데이터를 가져와 사용해야하는 경우 사용 > 데이터를 하나로 묶어 담을 바구니가 필요

3. DAO

데이터베이스 접근 로직을 담당하는 객체

데이터 저장, 조회, 수정, 삭제 기능 수행 (CRUD)

4. Utility Class

공통 기능을 제공하는 클래스

ex. 날짜 처리, 문자열 처리, 계산 기능 등 > 객체 생성 없이 사용하는 경우가 많다.

6. This 와 Static

This

현재 메서드를 호출한 객체 자기 자신을 의미한다.

public void setName(String name) {
    this.name = name;
}

ex. 같은 클래스로 생성된 객체 p1,p2,p3 중, 어떤 객체가 호출했는지 알아야 데이터 수정 가능

Static

객체 생성 없이, 클래스 이름으로 바로 접근 가능한 멤버이다.

특징

- 기능만 제공하기 때문에 데이터 사용 안함. > DTO,DAO 사용 안함

- This 사용 불가 (현재 객체 자체가 없기 때문)

- Static 메서드의 경우, 호출되는 다른 메서드들도 static 이어야함 !

- Utility, 공통 상수, 상태 없는 기능에서 사용

7. 접근 제한자

객체 간 접근 범위를 제어하기 위한 문법이다.

접근 제한자접근 범위

public	모든 클래스 접근 가능
private	자기 클래스 내부만 접근 가능
protected	상속 관계에서 접근 가능
default	같은 패키지 내부만 접근 가능

8. 정보 은닉

객체 내부 데이터를 외부에서 직접 수정하지 못하도록 숨기는 개념이다.

보통 멤버 변수는 private로 선언한다.

9. Private 변수에 접근하기 위한 방법

1. Getter, Setter 메서드 + toString() 메서드 사용

Setter : private 상태 변수에 정보 삽입

Getter : private 상태 변수의 정보를 읽어옴.

toString() : 객체가 가진 값 전체를 문자열 형태로 읽어옴.(리턴)

public class Person{
    private String name;
    private int age;

    public void setName(String name){
        this.name=name;
    }

    public void setAge(int age){
        this.age=age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
    
    public String toString(){
    	return name+age;
    }
}

* Setter 메서드 사용 보다는, Change변수명의 메서드를 직접 생성하여 사용하는 걸 권장 > 상태 변경에 있어 추적이 중요하기 때문

Person p = new Person();
p.setName("홍길동");
p.setAge(50);

String name = p.getName();
int age = p.getAge();

System.out.println(p.toString());

2. 생성자 메서드를 이용해 객체 초기화

public class Person{
    private String name;
    private int age;

    Public Person(){
        this.name="홍길동";
        this.age=50;
    }
    
    public String toString(){
    	return name+age;
    }
}

Person p = new Person();

System.out.println(p.toString());

객체 생성시 원하는 값으로 초기화를 원할 경우, 생성자 메서드를 오버로딩해서 초기화

public class Person{
    private String name;
    private int age;

    Public Person(String name, int age){
        this.name=name;
        this.age=age;
    }
    
    public String toString(){
    	return name+age;
    }
}

Person p = new Person("홍길동",50);

System.out.println(p.toString());

Kafka를 배워보자(2) _ Docker를 활용한 실습 환경 구성 + 기본 개념 실습

KoreanPaper — Thu, 7 May 2026 14:47:58 +0900

Kafka는 로컬 환경에 직접 설치하려고 하면 설정이 꽤 복잡하다.

따라서, Docker를 사용해 간단한 환경 구성을 통해 실습을 진행하였다. ( Docker 기본 지식 필요 )

먼저 docker -v와 docker compose version을 통해 Docker가 설치되어 있는지 확인이 필요하다.(설치 필요)

나는 지속적인 실습을 위해, OrdStack을 이용해 컨테이너를 종료하지 않고 시작-정지 하는 방식을 사용했다.

실습 환경 구성

1. 실습 디렉토리 생성

터미널 실행 (디렉토리 생성 위치로 이동 cd)

디렉토리 생성

mkdir kafka-practice

디렉토리 이동

cd kafka-practice

현재 위치 확인

pwd

2. 실습 디렉토리 내에 docker-compose.yml 생성

3. docker-compose.yml 작성

version: '3'
services:
    zookeeper:
        image: confluentinc/cp-zookeeper:7.5.0
        environment:
            ZOOKEEPER_CLIENT_PORT: 2181
            
    # zookeeper는 kafka 의 관리자 역할을 수행
    # kafka가 zookeeper에게 접속하는 포트 : 2181 (관리자 서버는 2181에서 대기 중)

    kafka:
        image: confluentinc/cp-kafka:7.5.0
        ports:
            - "9092:9092" # 9092 포트에 kafka 서버 연결
        environment:
            KAFKA_BROKER_ID: 1 # 브로커 아이디(kafka 서버 고유 아이디, 여러개 존재시 구분용)
            KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 # zookeeper 주소(카프카가 주키퍼한테 말함)
            KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092 # 외부에서 접속하는 주소(카프카는 내부 포트로 접속하지만 외부에서는 9092 포트로 접속함)
            KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1 # 토픽 복제 수(단일서버, 브로커 1개)
        depends_on:
            - zookeeper
            # Kafka는 Zookeeper가 먼저 실행된 다음 시작

4. Kafka 실행

터미널에서 실습 디렉토리로 이동 후 실행

docker compose up -d

* 실행 상태 확인 : docker ps

* 종료하기 : docker compose down

5. Kafka 컨테이너 접속

docker exec -it kafka bash

* 나가기 : exit / Ctrl+d

기본 개념 실습

1. Topic

[ 생성 ]

kafka-topics --create \
  --topic test-topic \
  --bootstrap-server localhost:9092 \
  --partitions 1 \
  --replication-factor 1
  
  
  
####
--create --topic 생성할 topic 이름 입력

--bootstrap-server localhost:9092 
어느 카프카 서버에 접속할 것인지 명시 (항상 작성 필요)

--partition 파티션 개수
--replication-factor 복제 개수
####

[ 목록 조회 ]

Kafka-topics —bootstrap-server localhost:9092 —list

[ 상세 조회 ]

Kafka-topics —bootstrap-server localhost:9092 —describe —topic test-topic

[ 삭제 ]

Kafka-topics —bootstrap-server localhost:9092 —delete —topic test-topic

2. Producer 실행 (메시지 보내기)

kafka-console-producer \
  --topic test-topic \
  --bootstrap-server localhost:9092

* 종료 : ctrl+c

3. Consumer 실행(메시지 읽기)

새로운 터미널 실행 필요

kafka-console-consumer \
  --topic test-topic \
  --from-beginning \
  --bootstrap-server localhost:9092

* Earliest : 처음 오프셋 부터 읽음 / Latest : 마지막 오프셋 부터 읽음

* 디폴트는 Latest = 마지막 다음부터 읽음 > —from-beginning : earliest 로 지정 필요

* ctrl+c 로 종료

Kafka를 배워보자(1) _ 기본 개념

KoreanPaper — Thu, 7 May 2026 14:06:45 +0900

Apache Kafka란?

'분산 시스템 기반의 이벤트 스트리밍 플랫폼'

대용량 이벤트 데이터 처리
실시간 데이터 스트리밍
데이터 파이프라인 구축
시스템 간 데이터 전달
분산 환경에서의 안정적인 메시지 저장

메시징 시스템이 필요한 이유

서비스 간 직접 통신을 하게 되면 시스템 간 결합도가 높아진다.

주문 서비스
결제 서비스
알림 서비스
배송 서비스

의 경우들은 서로 직접 연결되면 구조가 복잡해지고 장애 전파 가능성도 커진다.

Kafka 같은 메시징 시스템은 중간에서 데이터를 전달하는 역할을 수행한다.

기본 구조

Producer → Kafka → Consumer

Producer : 메시지를 생성하고 보내는 객체

Kafka : 메시지를 저장하고 전달하는 중간 플랫폼

Consumer : 저장된 메시지를 읽어 처리하는 객체

Kafka 구조

Broker

- Kafaka 서버 1대

- 여러개로 구성 가능, 메시지 분산 저장

- 확장성, 장애대응, 고가용성 확도

- 특정 서버가 다운되더라도 복제된 데이터를 통해 서비스를 지속할 수 있다.

Topic

- 메시지가 저장되는 영역

- 하니의 DB 테이블이라고 생각할 수 있음.

- Key와 Value 기반 구조를 가진다.

- 메시지가 순차적으로 수정 없이 로그가 쌓이는 형태로 삽입 저장됨.

Partition

- 독립적인 로그 파일

- 병렬 처리, 확장성, 고성능 처리 가능

- Offset이 지정 되어 순차 저장

- 같은 Partition 내에서는 순서가 보장됨 ( 다른 Partition에서는 순서 보장 안됨 )

* Kafka는 네트워크를 통해 데이터를 전송하기 때문에 직렬화(Serializer)과정이 필요하다.

* '객체 > 바이트 배열'로 변환 후 전송됨.

메시지 순서 보장 방식

Kafka는 같은 Partition 내에서만 순서를 보장하고, Topic 전체 순서를 보장하지 않는다.

즉, Partition이 여러개라면 Consumer에서 메시지를 읽는 순서가 달라질 수 있다.

1. 동일한 Key값을 가진 메시지는 동일한 Partition으로 전송

2. Key값이 없는 경우, 자동으로 Partion 선택

- Round Robin 방식 : 메시지를 순차적으로 Partition에 분배 (Kafka 2.4 이전)

- Sticky Partitioning 방식 : 하나의 Partition에 배치를 빠르게 채워 전송한 뒤, 다른 Partition으로 이동 (Kafka 2.4 이후)

Leader 과 Follower

여러개의 Broker 중, 하나의 서버가 다운될 경우를 대응 > 각 Broker에 복제 데이터를 저장

- Leader Partition : 실제 서비스를 담당, Producer와 Consumer는 Leader와 통신

- Follower Partiton : Leader 데이터를 복제하는 역할 (읽기,쓰기 불가)

Leader가 있는 Broker가 다운되면, Follower 중 하나를 새로운 Leader로 승격시킴 > 고가용성

( Partiton에는 Leader가 반드시 1개만 존재 )

MSA 구조만 나누면 끝일까? DDD와 TDD가 필요한 이유 : 프로젝트 구조 파악하기

KoreanPaper — Sat, 24 Jan 2026 22:43:54 +0900

최근 백엔드 아키텍처를 논할 때 MSA는 빠지지 않는 주제이다.

하지만 MSA는 단순히 서비스를 쪼개는 것이 아닌 "어떻게 쪼갤 것인가(DDD)"와 "쪼개진 서비스를 어떻게 신뢰할 것인가(TDD)"에 대한 고민이 필요하다..!

한 번 간단히 알아보자..!

1. 설계의 기준 : DDD

MSA를 시작할 때 가장 먼저 "어디를 기준으로 서비스를 나눌 것인가?"에 대해 고민한다.

이때 DDD는 훌륭한 설계 도면이 된다고 한다.

DDD는 도메인 주도 설계 방식으로 유비쿼터스 언어를 사용한다.

도메인 주도 설계 : 핵심 서비스를 기준으로, 여러 기능의 서비스를 도메인으로 나누어 설계하는 것.
유비쿼터스 언어 : 기획자부터 개발자까지 하나의 언어로 소통하여 설계와 코드의 간극을 줄임.
Bounded Context : 비즈니스 로직을 분석해 하위 도메인을 나누고, 그 사이에 명확한 경계를 만든다. 이 경계가 MSA 서비스를 나누는 핵심 기준이 된다.

장점: 복잡한 비즈니스 로직을 명확하게 관리할 수 있고, 기획-개발 간 소통 오류가 줄어듦.

단점: 초기 설계 비용이 크고, 도메인 전문가의 참여가 필수적이라 러닝 커브가 높음.

설계한 도메인을 물리적으로 구현하기 = 멀티모듈
앞서 DDD로 나눈 '논리적인 경계'를 실제 코드상에서 '물리적으로 격리'하기 위해 멀티 모듈 구조를 활용한다.

모듈: 독립적으로 배포될 수 있는 코드의 최소 단위.

멀티 모듈 구조: 하나의 프로젝트를 여러 개의 모듈로 나누어 관리하며, 각 하위 도메인을 별도의 모듈로 작성.

장점: 코드 재사용성이 높아지고 독립적인 빌드가 가능해 유연성 향상.

단점: 설정이 복잡해질 수 있고, 도메인 설계가 잘못될 경우 도메인 간 의존성 때문에 개선이 어려울 수 있음.

2. MSA 란?

DDD라는 도면을 바탕으로 세워진 실제 건물이 바로 MSA !

쪼개진 서비스들이 각자 독립적인 DB를 가지고 배포되는 구조를 가진다.

장점: 특정 서비스에 트래픽이 몰릴 때 해당 부분만 확장하면 되는 엄청난 유연성을 가진다.

단점: 서비스가 늘어날수록 서비스 간 호출 관계가 복잡해져, 코드 수정이 다른 서비스에 어떤 영향을 주는지 파악하기 힘들다.

3. TDD 란?

MSA 환경에서 서비스 간의 복잡한 호출 관계를 일일이 손으로 테스트하는 것은 불가능에 가까우므로,

TDD를 사용해 자동 테스트가 가능하게 한다.

테스트 주도 개발로 Red - Green - Refactor 사이클을 따른다.

안전한 리팩토링 : 기능을 수정해도 기존 테스트 코드가 성공한다면, 안심하고 배포할 수 있다.

문서화 역할 : 테스트 코드는 그 자체로 "이 기능은 이렇게 동작해야 한다"는 가장 정확한 명세서가 된다.

Spring Boot에서는 Junit + Mockito + AssertJ 조합으로 테스트 환경을 잘 구축할 수 있다.(공부 예정)

MSA 환경이라면 서비스 간의 통신을 테스트하는 계약 테스트(contract test)를 알아보려고 한다. (이것 또한 공부 예정)

결론

DDD로 비즈니스 로직을 분석해서 MSA의 경계를 나눈다.
MSA 구조 위에서 서비스 간의 복잡함을 TDD로 검증하며 개발한다.
결과적으로 비즈니스 변화에 빠르고 안정적으로 대응하는 유연한 시스템이 완성된다

+실제 프로젝트에 어떻게 적용되는지 살펴보자!

계층 기준으로 나눈 모듈 구조

DDD + TDD 기반의 프로젝트 구조 (스프링 부트 기준)

+ 위의 내용들을 바탕으로 여러 아카텍처들의 특징을 알아보자!

DDD 단계: Layered이 아닌 Domain-based 기준으로 서비스를 바라보기 시작.

MSA 단계: 쪼개진 도메인을 Multi-module이나 Hexagonal 구조를 활용해 독립적인 서비스로 구축.

TDD 단계: 헥사고날 아키텍처는 입출력이 분리되어 있어, 외부 환경(DB 등)에 상관없이 핵심 로직만 테스트하기에 최적의 환경을 제공.

개인 프로젝트나 간단한 프로젝트들 (보통 내가 진행했던) 은 Layered 구조를 많이 사용했다.

+ 그렇다면 왜 Domain-based로 넘어가는게 좋을까? (코드 중심 > 비지니스 중심)

기존의 Layered Architecture는 기술적 계층(Controller, Service, Repository)을 기준으로 코드를 나눈다.

하지만 프로젝트 규모가 커지고 MSA를 고려하게 되면 다음과 같은 한계에 부딪히게 된다.

1. 무엇을 하는 코드인지 찾기 힘들다 (가독성)

Layered: 새로운 '주문' 기능을 추가하려면 OrderController, OrderService, OrderRepository를 각각의 패키지에서 찾아야 한다. > 기능이 많아질수록 Service 패키지 안에 수십 개의 파일이 쌓여 어떤 코드가 서로 연관되어 있는지 파악하기 어려워진다.
Domain-based: Order라는 도메인 폴더 하나에 관련 컨트롤러, 서비스, 엔티티를 모두 모아둔다. 특정 기능을 수정할 때 해당 폴더 안에서 모든 것을 해결할 수 있어 가독성이 압도적이다.

2. 서비스 간 결합도가 너무 높다 (의존성)

Layered: 모든 서비스가 하나의 거대한 Service 계층에 섞여 있다 보니, '회원' 로직이 '주문' 로직을 직접 참조하거나 복잡하게 얽히는 경우가 빈번하다. 하나를 수정했을 때 어디가 문제될지 무서움이 시작된다..
Domain-based: 각 도메인이 명확한 경계(Bounded Context)를 가진다. 도메인 간의 참조를 엄격히 제한하거나 필요한 경우 인터페이스를 통해 소통하게 함으로써 결합도를 낮출 수 있다.

3. MSA 전환이 불가능에 가깝다 (확장성)

Layered: 특정 기능을 별도의 서비스로 분리하고 싶어도, 기술 계층별로 코드가 흩어져 있고 강하게 결합되어 있어 떼어내기가 매우 어렵다.
Domain-based: 도메인 단위로 이미 응집되어 있기 때문에, 특정 도메인을 그대로 복사해서 새로운 마이크로서비스로 독립시키기가 훨씬 수월하다.

마무리하며.

결국 우리가 MSA 구조로 넘어가기 위해선 정확한 경계와 테스트가 필요하다.

익숙했던 기술 중심으로 나눈 개발은 이제 인사하고.. 도메인 기준으로 나눈 개발과 테스트 코드까지 작성해보려고 한다..! 홧팅!

추가로 내가 많이 헷갈렸던 부분은 'Domain-based와 Multi-module은 같은 구조 아니였나?' 이었는데,

재민이한테 물어보니 '도메인은 무엇을 나눌지 결정하는 전략이고, 멀티모듈은 그것을 어떻게 담아낼지 결정하는 물리적인 그릇'이라고 한다..!

너무 추상적이라..진짜 마지막으로 멀티 모듈의 프로젝트 구조에 대해 알려달라고 했다.(슬슬 과부화가 온다...)

root-project/
├── build.gradle (전체 설정)
├── settings.gradle (모듈 포함 설정: include 'api', 'domain', 'common' ...)
│
├── app-api/                # [실행 모듈] 외부 요청(Controller) 처리
│   ├── build.gradle        # domain, common 모듈을 의존함
│   └── src/main/java/.../controller/
│
├── core-domain/            # [도메인 모듈] 핵심 비즈니스 로직 및 엔티티
│   ├── build.gradle        # 특정 기술에 종속되지 않도록 설정
│   └── src/main/java/.../domain/ (Order, Member 등)
│
├── core-common/            # [공통 모듈] 유틸리티, 공통 예외 처리 등
│   ├── build.gradle
│   └── src/main/java/.../utils/
│
└── infrastructure/         # [인프라 모듈] DB 설정, 외부 API 통신 등
    ├── build.gradle
    └── src/main/java/.../config/

Root Project: 전체 프로젝트의 설정을 관리합니다. 어떤 모듈들이 모여 하나의 시스템을 이루는지 settings.gradle에 정의합니다.
App 모듈 (API): 사용자의 요청을 받는 접점입니다. 여러 도메인 모듈을 조합하여 실제 서비스를 제공합니다. MSA로 전환할 때 이 모듈 단위로 떼어내게 됩니다.
Domain 모듈: DDD에서 설계한 바운디드 컨텍스트가 실제로 구현되는 곳입니다. 비즈니스 규칙과 엔티티(Entity)가 위치하며, 외부 환경(DB 등)이 변해도 이 모듈의 로직은 변하지 않는 것이 이상적입니다.
Common 모듈: 프로젝트 어디서든 공통으로 쓰이는 코드를 모아둡니다. 하지만 이 모듈이 너무 커지면 모듈 간 결합도가 다시 높아질 수 있어 주의가 필요합니다.
의존성 방향(API -> Domain -> DB)

독립적 빌드: '주문' 도메인 관련 코드만 수정했다면 전체를 빌드할 필요 없이 해당 모듈과 연관된 부분만 체크하면 되므로 시간이 단축됩니다.
의존성 제어: 예를 들어, domain 모듈은 api 모듈의 존재를 몰라야 합니다. 이렇게 의존성 방향을 한쪽으로만 흐르게 강제할 수 있어 코드가 꼬이는 것을 방지합니다.
TDD 용이성: 핵심 로직이 담긴 domain 모듈만 따로 떼어내어 가벼운 테스트 환경을 구축할 수 있습니다.

.. 나중에 좀 더 알아보도록 하자

투비컨티뉴~

끄읏.

Mac에서 MariaDB 설치 후, DBeaver 연동 중 발생한 오류들

KoreanPaper — Sat, 24 Jan 2026 20:56:31 +0900

과거에 DB를 연결하면서 발생한 오류들의 해결 방법을 기록해 보자..!..

1. MariaDB 설치 중 발생한 오류

Error: Cannot install mariadb because conflicting formulae are installed. mysql: because mariadb, mysql, and percona install the same binaries

> Mac에 이미 Mysql이 설치되어 있어, MariaDB와 충돌이 발생한 상황

[해결 방법]

1. mysql을 일시적으로 비활성화 시키기

brew unlink mysql
# MairaDB만 완전히 사용할 계획이라면 brew uninstall mysql을 권장

2. MariaDB 재설치

brew install mariadb

3. mysql을 다시 사용할 수 있도록 변경

brew link mysql

2. MariaDB 실행 시, 발생한 오류

ERROR 2002 (HY000): Can't connect to local server through socket '/tmp/mysql.sock'

> MariaDB 서버가 실행 중이지 않거나, 잘못된 소켓을 참조하고 있어 발생

[해결 과정]

1. 재실행

brew services restart mariadb

> 하지만 나는 또 다른 오류 발생 ㅠ..

Bootstrap failed: 5: Input/output error Try re-running the command as root for richer errors. Error: Failure while executing; `/bin/launchctl bootstrap gui/501 /Users/Library/LaunchAgents/homebrew.mxcl.mariadb.plist` exited with 5.

> 마리아를 정상적으로 실행 시키지 못했다고 함..

1. MariaDB를 삭제하고 재설치 -> 위의 2가지 오류 상황을 계속 반복

2. brew services restart mariadb를 실행시키면 정상적으로 실행되었다고 뜨는데, brew services list을 확인해보니 상태가 stopped로 되는것을 알 수 있었음..!

3. Homebrew를 삭제 후, 재설치 > 해결 !

재설치를 통해 homebrew가 사용하는 관련 환경 변수들을 새로 설정하고, 문제가 있었던 패키지나 설정 파일을 복구 시킴.
homebrew, Mariadb, mysql을 모두 삭제 후 재실행 시키니 드디어 Mariadb started 상태로 바뀌었다...ㅎ

> 하지만 Homebrew 재설치는 최후의 수단 느낌이라..재민이 한테 다시 물어보았다..!

Homebrew 재설치라는 강력한 처방을 쓰셨는데, 사실 sudo chown -R $(whoami) /usr/local/var/mysql처럼 권한을 수정하거나 /tmp/mysql.sock.lock 파일을 지우는 가벼운 방법도 있습니다. '최후의 수단으로 Homebrew 재설치를 선택했다'는 뉘앙스를 주면 더 완벽할 것 같습니다.

라고 한다.

3. DBeaver과 연동 시 오류 발생

RSA public key is not available client side (option serverRsaPublicKeyFile not set)

> MariaDB 서버와 인증시, RSA 공개키가 설정되지 않아서 발생

[해결 방법]

1. Connection settings에서 Driver Properties으로 들어가기

2. allowPublicKeyRetrieval=true 로 변경

3. useSSL 라는 속성 추가하고 false로 설정

+ allowPublicKeyRetrieval=true 란?

JDBC 설정 옵션으로, 서버에서 클라이언트로 RSA로 암호화 된 공개키를 동적으로 가져오는 것을 허용한다는 뜻이다.
이를 통해 클라이언트(DBeaver)가 서버에 연결될 수 있다.

+ useSSL=false 란?

DB와의 연결시 SSL을 사용하지 않도록 설정하는 옵션이다.
SSL은 클라이언트와 서버간의 통신을 암호화하여 데이터 유출을 방지하는 보안 프로토콜이다.
기본적으로 SSL이 설정된 경우 클라이언트는 SSL을 통해 서버와 통신을 시도하지만, 로컬 환경 또는 개발 환경에서는 SSL이 필요하지 않을 수 있다.
보안 인증서가 구성되지 않은 MariaDB와 MySQL의 서버와 연결할 때 SSL 인증서를 요청하는 오류가 발생할 수 있는데, 이 설정을 통해 이를 방지할 수 있다.

4. 3번째 오류를 해결하니 다른 오류 발생

Access denied for user 'root'@'localhost' (using password: YES)

> 비밀번호가 잘못 입력되었거나, root 계정에 대한 인증 방법이 올바르게 설정되지 않았을 때 발생

[해결 과정]

1. MariaDB 비밀번호 재설정 > 해결 불가

2. 검색해 보니, 포트의 문제..!

3. 해당 포트 번호를 확인해 보니 mysqld가 실행되고 있었음.

sudo lsof -i:3306

4. stop을 하니, mysql이 실행이 되지 않고 있다함 > ..?

brew services stop mysql

5. 그래서 걍 완전 종료 시켜벌임..!

sudo killall mysqld

6. MariaDB를 재실행 시키고, DBeaver에 연동하니 정상적으로 연결이 되었다..휴우~

brew services restart mariadb

하지만, 뭔가 찝찝해서 원인을 좀 더 찾아보았다..!

재민이는

MariaDB가 설치될 때 내부 엔진 이름이 mysqld인 경우가 많습니다. 즉, 아까 죽인 프로세스는 '삭제된 MySQL'이 아니라 '정상 설치된 MariaDB'였을 가능성이 큽니다.

포트 충돌은 보통 3306을 이미 다른 프로세스(이전 설치본 등)가 점유하고 있어서 새로 띄운 MariaDB가 뜨지 못했던 것입니다. killall로 싹 정리한 것이 신의 한 수였습니다.

라고 하는데..그래서 다시 정리하자면..?

MariaDB와 MySQL의 데이터베이스 서버가 동시에 실행되어,
동일한 기본 포트(3306)을 사용하려고 했기 때문에 충돌이 일어났나..? >1차 의심

근데 분명 mysql을 삭제하였는데 왜 이런 오류가 나지..?? > 2차의심

그래서 터미널로 mysql --version을 입력해 보았더니,
mysql from 11.5.2-MariaDB, client 15.2 for osx10.19 (arm64) using EditLine wrapper 을 볼 수 있었다.

알고보니 MariaDB는 MySQL과 호환되는 데이터베이스 서버이기 때문에, MySQL 명령어를 입력해도 MariaDB가 대신 실행될 수 있다고 한다. (MariaDB를 설치할 때 mysql 명령어도 함께 설치)

MariaDB 클라이언트는 MySQL 명령어와 동일한 인터페이스를 제공하기 때문에 mysql --version 명령어가 동작하는 것이였고, MySQL이 삭제된 상태에서도 MariaDB가 설치되어 있기 때문에 mysql 명령어를 입력하면 MariaDB 클라이언트가 대신 실행되고 있는 것이였다.

따라서..
MariaDB 설치 시 MySQL 클라이언트를 별도로 설치할 필요 없이, MariaDB가 이미 MySQL 명령어와 호환되도록 모든 도구를 제공한다는 것을 알게되었다.

그래서 결국엔 sudo killall mysqld 해당 방법이 맞았던거 같다...!

Mac에서 발생한 Git의 13K+ 알림 지옥 : 터미널 명령어 정리+ git init

KoreanPaper — Sat, 24 Jan 2026 20:09:59 +0900

처음 개발을 시작했던 시절.

맥북으로 VSC에서 개발을 하는 도중, 난 별로 한게 없는데 왜 갈수록 변경 사항이 늘어나는거지? 오류인가? 하며,

대수롭게 여기지 않았던 회피형 인간은 나는 나중에 업보 청산을 하게 되는데..

어느 순간 Git 알림이 13K+를 넘어가고 있었다.

이걸 어떻게 지우지? 하며 모든 변경 사항을 Discard Changes를 해버렸고, 결국 내 모든 파일과 설정이 삭제되어 버렸다.

왜 이런 일이 생겨버린걸까.. 하며 원인을 찾아보았는데..

사용자의 홈 디렉토리?( ~, /Users/이름 )에서 git init 명령어가 실행되어 그랬다고 한다.

git init 을 실행하면 그 폴더와 그 안의 모든 하위 폴더를 Git의 감시가 시작한다고 하니.. 나의 모든 것이 Git에 올라갔던거다..!....

원래는 특정 프로젝트 폴더 안에서 git init를 실행했어야 했는데, 터미널을 켜자마자 바로 입력해서 이런 일이 발생한것 같다.

만약 이런 일이 생긴다면 어떻게 해결해야 할까? > 홈 디렉토리에 잘못 생성된 .git 숨김 폴더를 삭제해야 한다.

해결 방법

1. git이 저장된 상위 디렉터리 찾기
터미널 실행 후, git rev-parse --show-toplevel 입력 > git 경로가 나온다.

2. cd 를 이용해 git의 상위 디렉터리로 이동
cd 상위_디렉터리_경로

3. 이동한 해당 디렉토리에 들어간 파일 목록 확인 해보기 > ls -a

4. git 삭제하기 > rm -rf .git
+ 여기서, rm -rf는 무조건 삭제 명령이니 현재 위치를 꼭꼭 확인하도록 하자.

5. git 파일이 삭제 되었는지 확인 > ls -a

추가로 터미널 명령어에 대해 정리해 보자 !

cd 명령어 모음

1. 기본 이동
cd [폴더명] : 현재 위치에 있는 특정 폴더로 들어간다.
cd .. : 한 단계 위 폴더로 나간다.
cd ../.. : 두 단계 위 폴더로 한꺼번에 나간다.

2. 경로 바로가기
cd ~ : 어느 위치에 있든 내 컴퓨터의 홈 디렉토리(/Users/사용자이름)로 즉시 이동
cd - : 바로 직전에 있었던 폴더로 돌아갑니다. (실수로 폴더를 잘못 나왔을 때 유용)
cd / : 시스템의 최상위 루트(Root) 폴더로 이동합니다.

3. 한 번에 깊이 들어가기 ( Tab 키를 누르면 자동 완성 됨 )
cd src/components/header : 하위 폴더 이름을 슬래시(/)로 연결하면 여러 단계를 한 번에 들어갈 수 있다.

+ 가고 싶은 폴더가 너무 깊은 곳에 있어서 경로를 다 치기 귀찮다면?

> 터미널에 cd 를 입력하고(공백 한 칸 포함), Finder에서 해당 폴더를 마우스로 잡아서 터미널 창에 드래그 앤 드롭 해보기.

+ 공백이 있는 폴더명: 만약 폴더 이름에 공백이 있다면 cd My\ Project라고 치거나 cd "My Project"처럼 따옴표로 감싸줘야 한다.

(폴더명에 공백 대신 하이픈-이나 언더바_를 쓰기)

ls 명령어 모음

1. 기본 보기
ls: 현재 폴더의 파일과 폴더 이름을 간단히 보여준다.
ls -l: 상세 정보(권한, 소유자, 파일 크기, 수정 날짜 등)를 포함하여 리스트 형태로 보여준다.
ls -a: 숨겨진 파일까지 전부 보여준다.

+ .git 폴더나 .gitignore 파일은 이름 앞에 .이 붙은 숨김 파일이라 -a를 붙여야 확인 가능!

2. 조합해서 쓰기
ls -la : 숨김 파일을 포함하여 상세 정보까지 한 번에 보기.

3. 유용한 추가 옵션
ls -lh: 파일 크기를 K, M, G 단위로 읽기 편하게(Human-readable) 보여줍니다. (ls -l은 바이트 단위라 읽기 힘들거든요.)
ls -t: 수정 시간(Time) 순서대로 정렬해서 보여줍니다. (방금 수정한 파일을 찾을 때 좋아요.)

+ pwd : 현재 내 위치 확인

+ clear : 터미널 청소

그렇다면, 새로운 프로젝트를 시작할때 git 설정은 어떻게 해야될까?

1. 새로운 프로젝트를 생성 할 경우

# 0. 원하는 위치로 이동 
cd ~/Desktop

# 1. 새 프로젝트 폴더 만들기
mkdir my-new-project

# 2. 만든 폴더 안으로 들어가기
cd my-new-project

# 3. Git 초기화!
git init

2. .gitignore 설정

모든 파일을 전부 기록할 필요가 없으므로, 필요없는 파일을 지정해 주는 기능을 한다.

프로젝트 최상위 폴더에 .gitignore 파일을 만들고, Git이 무시해야 할 목록을 적는다.( node_modules, .env, .DS_Store 등)

직접 쓰기 어렵다면? > gitignore.io 참고하기 !

3. 첫번째 기록 남기기

첫 번째 커밋을 해야 브랜치가 실체화 된다.

touch README.md                    # 설명 파일 생성
git add README.md                  # 장바구니에 담기
git commit -m "Chore: Initial commit" # 첫 기록 완료!

4. GitHub에 연결하기

미리 만들어둔 GitHub 레포지토리의 링크를 가져와 연결

git remote add origin https://github.com/내아이디/내프로젝트.git

5. 첫 Push

로컬에서 만든 내용을 서버로 처음 보내기.

git push -u origin main	
# 앞으로 git push = git push origin main 이라는 뜻 (다른 브렌치랑 헷갈리지 않게 주의!)

+ GitHub에 있는 코드를 가져올 때 = Clone 하기

이미 GitHub에 올려둔 저장소가 있다면 init을 할 필요가 없다.

# 1. 코드를 저장할 부모 폴더로 이동
cd ~/Documents/projects

# 2. 주소를 복사해서 클론 (이때 폴더가 자동으로 생성됨)
git clone https://github.com/사용자이름/저장소이름.git

# 3. 생성된 폴더로 이동
cd 저장소이름

+ 내가 제대로 한게 맞을까? 의문이 들때 필요한 git 명령어

git status : 현재 작업 상태를 보여줌. (nothing to commit, working tree clean이 나오면 성공)
git log : 커밋한 기록들을 보여줌. ( 나갈 때는 q 누르기)
git remote -v : 현재 내 폴더가 어느 깃허브와 연결되어 있는지 알려줌.

인턴이 TF팀에서 협업하는 법(1) : Git Branch 전략

KoreanPaper — Sat, 24 Jan 2026 17:33:44 +0900

인턴 활동을 하면서, 여러 TF 팀에 들어가 프로젝트를 진행한 경험이 있다.

(TF란 Task Force로, 빠른 과제 해결을 위해 사람을 모아 임시로 만든 팀이라고 한다.)

우리 팀은 인수인계와 팀원 변경이 빈번해, 누구나 한눈에 알 수 있는 구조의 Git 브렌치 전략이 필요했다..!

사용했던 Git 전략들을 기록 해 보고자 한닷.

우리 팀은 빠른 개발이 필요했기 때문에, 재민이가 말해준 두가지 방법 중 GitHub Flow 방식을 택했다.

그래도 두가지 방법에 대해 간단히 알아보자.

1. Git Flow (표준 방식)

Main (Master): 실제 사용자에게 서비스 중인 '최종' 코드.
Develop: 다음 버전을 위해 개발 중인 코드들이 모이는 곳.
Feature: 기능을 개발하는 브랜치. 개발이 끝나면 Develop에 합친다.
Release: 배포를 준비하는 단계. 버그 수정만 진행한다.
Hotfix: 서비스 중인 코드(Main)에 급한 버그가 터졌을 때 즉시 수정하는 용도.

2. GitHub Flow (단순하고 빠름)

Main 브랜치 하나만 중심으로 잡는다.
새로운 기능이 필요하면 브랜치를 만들고, 완료되면 바로 Pull Request (PR)를 보낸다.
동료의 리뷰를 거쳐 Main에 합쳐지자마자 바로 배포하는 구조.

Branch 전략

main : 배포 및 기준 브렌치

1. 기능 개발 브렌치 생성하기 ( 서버와 클라이언트 구분 )

feature/client/기능명 : 프론트엔드 부분에서의 기능 개발 (ex. feature/client/home)
feature/server/기능명 : 백엔드 부분에서의 기능 개발(ex. feature/server/login)

2. 기능 개발이 완료되면 main으로 PR 보내고 병합하기.

Git 명령어 정리

1. 새로운 브렌치 생성

main 브렌치에서 최신 코드를 가져온 후, 기능 브렌치 만들기

# main으로 이동
git checkout main

# main의 최신 상태 가져오기
git pull origin main

# 새로운 작업 브렌치 생성 및 이동 (-b : 생성 및 이동을 동시에 진행 )
git checkout -b feature/client/home

2. 새로운 기능 개발 완료 후, 현재 작업 브랜치에서 실행하기

# 팀원들의 코드와의 충돌을 방지하기 위해 진행
git pull origin main

# 수정된 파일 목록 확인 (초록색이 저장될 파일들)
git status

# 모든 변경 사항을 저장 대기열에 추가
git add .

# 저장 메시지 작성
git commit -m "유형: 작업 내용 요약(무엇을,왜)"

# 서버로 코드 보내기
git push origin [내 브랜치명]

+ 항상 push 하기 전, git pull origin main을 하는 습관 필요!

+ 현재 브렌치 상태 확인 명령어 (push 하기 전, 확인해보면 좋음!)

# 현재 내가 위치한 브렌치 확인
git branch

# 현재 브렌치, 수정 사항, 커밋할 내용 등 전반적인 상태 알려줌
git status

+ 커밋 메시지 유형

feat : 새로운 기능 추가
fix : 버그 수정
design : 디자인 수정
refactor : 기능은 그대로지만, 코드 구조를 개선했을 경우
docs : readme.md와 같은 문서 파일 수정
chore : 빌드 설정 변경, 패키지 설치 등 코드와 상관 없는 작업
comment : 주석을 추가하거나 변경했을 경우

3. PR 진행하기 : GitHub에 접속

상단에 나타난 [Compare & pull request] 노란색 버튼을 클릭.
Base: main ← Compare: feature/client/home 상태인지 확인.
작업 내용을 간단히 적고 Create pull request를 클릭.
Merge pull request 버튼을 눌러 main에 최종 합치기.

마무리하며.

팀원들과 개발을 하다보니, 시작하기 전 main을 업데이트 해주는 습관이 매우 중요하다는 것을 알게 되었다.

Github Desktop 만 편리하게? 사용하다가 직접 명령어를 입력하며 관리하니 이해도가 한층 깊어졌고, 협업에 대한 자신감이 올라갔던 경험이 되었던거 같다..!

비밀번호 어떤 방식으로 지켜내야 할까? : 개발에 필요한 암호화 전략

KoreanPaper — Thu, 22 Jan 2026 17:24:41 +0900

최근 개인 정보 유출 사고가 빈번해지면서, 많은 보안 이슈들이 문제되고 있다.

그래서 문득 개발 하면서 사용자가 작성한 비밀번호는 어떤 방식으로 암호화가 될까? 라는 생각이 들어, 간단히 알아보게 되었다.

재민이한테 물어보니, 크게 3단계를 거쳐 암호화가 된다고 한다.

1. 해시 함수

사용자에게 입력 받은 비밀번호를 완전 다른 문자열(=다이제스트)로 변환 시킨다.
해시는 데이터를 되돌릴 수 없게 변경하는 단방향 함수 이므로 원래 비밀번호를 알아내는 것은 어렵다.

여기서 단방향 함수의 단점은?

1) 레인보우 공격에 당할 수 있음
- 같은 비밀번호를 사용하는 사람은 동일한 다이제스트를 가짐
- 공격자가 다이제스트를 최대한 확보
- 확보한 다이제스트와 탈취한 다이제스트를 비요해 원본 메시지를 찾아냄

2) 해시 함수가 너무 빨라, 해커가 초당 수억 번의 대입 공격 (Brute-force)이 가능

+ 그렇다면, 단방향 함수를 어떻게 보완하는가? > 아래 2단계를 추가 진행한다.

2. 솔팅(Salting)

원본 메시지에 문자열을 추가하여 다이제스트를 생성한다.
salt : 다이제시트를 생성할 때 추가되는 바이트 단위의 임의 문자열.

3. 키 스트레칭

해싱 과정을 수만 번 반복하여 연산 속도를 의도적으로 늦추는 기법
생성된 다이제스트를 다시 입력하여 새로운 다이제스트를 다시 생성 > 반복
입력한 패스워드를 동일한 횟수만큼 해시해야만, 입력한 패스워드의 일치 여부를 확인할 수 있음

해싱 알고리즘 종류

SHA-1, SHA-256, MD-5, Argon2, scrypt, bcrypt, PBKDF2 등
암호 보안을 위해 Argon2, bcrypt, scrypt가 권장

Adaptive Key Derivation Functions

솔팅과 키 스트레칭을 반복하는 함수
연산 난이도를 조절하고, 더 복잡한 암호 키를 만들어 낸다
일반 적인 해시 함수(MD5, SHA-256 등)는 데이터를 최대한 빨리 처리 > 이 과정을 복잡하고 무겁게 만든 함수
PBKDF2 : 솔트를 적용한 후 해시 함수의 반복 횟수를 임의로 선택
Bcrypt, Argon2 등의 알고리즘이 존재

Argon2

CPU 및 메모리의 사용량 조정 가능

시간 및 메모리 요구 사항을 조정하여, 알고리즘 복잡성 설정 가능

솔트 사용

최신 암호화 함수로 가장 강력한 보안성과 유연성 지원

실행 속도가 느리고 구현이 복잡

bcrypt

느린 해시 함수를 사용하여, brute-force 공격에 강함

보안적으로 검증된 함수이므로, 가장 널리 사용

솔트 사용, 상대적으로 빠른 실행 속도, 단순한 구현

강력한 패스워드 다이제스트를 생성하는 시스템을 쉽게 구현하고 싶다면 사용

GPU를 사용한 공격이 취약

scrypt

대량의 메모리를 요구하여 공격을 어렵게함

솔트 사용, 느린 해시 함수
(다이제스트를 생성할 때 메모리 오버헤드를 갖도록 설계되어, brute-force 공격을 시도할 때 병렬화 처리가 매우 어려움)

긴 비밀번호도 저장 가능

메모리 및 시간 사용량 조정 가능

실행속도가 느리고 구현이 복잡

무차별 대입 공격에 대해 최대로 강하지만, Argon2만큼 메모리나 시간을 많이 소모하지는 않음

구현하려는 시스템이 매우 민감한 정보를 다루고, 보안 시스템을 구현하는 데 많은 비용을 투자할 수 있다면 사용

백엔드 개발 부분에서의 회원가입 / 로그인 로직 흐름

회원가입 : 사용자 비밀번호 > Salt 생성 > Bcrypt 해싱 > DB 저장 (Hash+Salt)
로그인 : 입력 비밀번호 > DB의 Salt와 결합 후 해싱 > DB의 해시값과 비교

+ 검증된 라이브러리 사용 : Spring Security > BCryptPasswordEncoder 사용, Node.js > bcrypt 사용

클라이언트와 서버 사이에서의 암호화

1. 사용자가 클라이언트에서 비번 입력

2. 비번을 서버로 전송하기 전, HTTPS 암호화 필수 진행 (전송 중 패킷을 가로채는 'MITM' 차단)

3. 전달받은 비번을 해싱 알고리즘을 이용해 솔팅 및 DB에 저장/비교

DB가 해킹 당하더라도, 솔팅을 시켰기 때문에 원본 비번 유추가 어렵다.

하지만, 솔트와 저장된 암호화 키를 둘다 알게 된다면 해킹이 가능해 진다.

보안을 한 층 더 강화할 순 없을까?

재민이한테 또 한번 물어보자.

보안 강화법

페퍼(Pepper) 사용 : DB 밖의 비밀 키

Salt가 사용자마다 다른 '공개된 양념'이라면, Pepper는 모든 비밀번호에 공통적으로 적용되는 '비밀 양념'이다.

방법: 암호화할 때 Password + Salt + Pepper 조합으로 해싱
핵심: Salt는 DB에 저장하지만, Pepper는 애플리케이션의 환경 변수나 별도의 보안 서버에 보관
효과: 해커가 DB를 탈취해도 Pepper를 모르면 암호를 풀 수 없음 > 물리적으로 저장소를 분리하는 전략입니다.

하드웨어 보안 모듈 (HSM) 및 KMS 활용

코드나 서버 설정 파일에 암호화 키를 두는 것도 불안하다면, 아예 키 관리 전용 서비스를 이용한다.

AWS KMS / Google Cloud KMS : 암호화 키를 클라우드 제공업체의 인프라 내부에 저장하고, 키 자체는 절대 밖으로 노출되지 않게 관리한다.
장점: 키에 접근하는 로그가 모두 남고, 특정 IP나 권한이 있는 서버에서만 암호화/복호화 요청을 보낼 수 있어 관리 효율성과 보안성이 극대화 된다.

2단계 인증 (2FA / MFA) 도입

암호화 알고리즘이 아무리 강력해도, 사용자의 비밀번호 자체가 너무 단순하거나 피싱에 당하면 무용지물이다.

방법: 비밀번호 인증 성공 후, 이메일/SMS 인증번호나 Google Authenticator(OTP) 등을 추가로 요구한다.
효과: 암호화 키가 유출되어 비밀번호가 뚫리더라도, 물리적인 인증 수단이 없는 해커는 로그인을 할 수 없다. 최근 테크 기업들이 가장 강조하는 '제로 트러스트(Zero Trust)' 모델의 핵심이다.

마무리하며

이렇게 암호화 과정을 알아보니 보안 강도는 '해커를 얼마나 귀찮고 힘들게 만드는가'에 달려 있다는 생각을 하게 되었다.

아무 생각없이 보안 라이브러리에 의존하기보단 직접 과정과 방식을 알아보니 전체적인 보안 로직을 이해하는데 도움이 되었고,

직접 페퍼나 2단계 인증 단계를 도입한 프로젝트를 후기로 가져와야겠다는 목표를 세웠다.

+ 최근 발생한 개인정보 유출 사고의 원인에 대해 간단히 물어보았다.

크리덴셜 스터핑 (Credential Stuffing) : 다른 곳에서 유출된 아이디/비번을 대입해 로그인을 시도하는 방식.
접근 제어 미흡 : 권한이 없는 사용자가 타인의 API 주소를 유추해 정보를 빼가는 것.
로그 관리 및 모니터링 부족 : 해커가 들어와서 며칠 동안 데이터를 긁어가는데도 시스템이 이를 감지하지 못한 상태.

그 외, 흔히 발생하는 보안 이슈들

클라우드 설정 오류 : 저장소 권한 설정을 'public'으로 두어 외부 누구나 접근 가능하게 방치
Access Key 유출 : 깃허브 등에 DB 접속 키나 인증키를 포함해 올려둠
API 취약점 공격 : 허점이 있는 API를 찾아내, 타인의 정보를 조회하여 무한으로 확보
공급망 공격 : 협력업체나 외부 솔루션의 취약점을 통해 내부망으로 침투
내부 직원이 고의로 데이터를 공유
피싱 : 관리자의 PC를 해킹하여 내부망 접속

앞으로 더욱 주의하며 개발해야겠슨

진짜로 끄읏.

기본 문법(4)

KoreanPaper — Wed, 21 Jan 2026 15:05:52 +0900

1. 객체 (Object)
- 객체란, 서로 다른 구성 요소들로 이루어진 하나의 구조이다.
- 하나의 바구니라 생각을 하면 이해하기 쉽다.
- 데이터의 이동이 쉽고, 이질적인 구조를 가진다.

2. 새로운 자료형 만들기
- 기본 자료형 외 새로운 자료형이 필요할 경우, 개발자가 직접 자료형을 만들어서 사용한다.
= 객체 지향 프로그래밍의 특징 = 새로운 자료형 = 사용자 정의 자료형

- Class란, '새로운 자료형을 만들어주는 도구' 라고 생각하면 된다.

- Person 이라는 새로운 자료형 생성

public class Person{
String name;
    int age;
    int phone;
    }

- 새로 선언 된 name, age, phone는 '속성 = 멤버변수 = 프로퍼티 = 상태 변수' 라고 한다.

3. 새로운 자료형 사용하기
1. 새로운 자료형을 가지고 변수 선언 -> Person p;
2. 객체 생성하기 = 인스턴스 생성 -> new Person();
3. 변수 p와 생성된 객체 연결 -> p = new Person();

=> Person p = new Person();

public static void main(String[] args) {
> 
Person p1 = new Person();
p1.name="홍길동";
p1.age=24;
p1.phone=12345;
> 
Person p2 = new Person();
p2.name="최길동";
p2.age=25;
p2.phone=13335;
}

4. 메서드 (Method)
- 객체가 가지고 있는 동작 = 메서드 = 함수
- '접근제한자 리턴타입 메소드명 (인수1, 인수2){수행코드, return 반환값 ;}' 으로 구성

public void test (int a, int b) {
System.out.println(a);
}

- 리턴 타입 = 수행된 후 반환하는 결과의 자료형
- 리턴 타입이 void일 경우, 아무 결과도 반환하지 않는 것이다. (return이 없음)
- 인수 = 매개변수

5. 오버로딩 (Overloading)
- 서로 비슷한 동작(메서드)들을 같은 이름으로 사용하는 것. = 중복 정의
- 객체 지향 프로그래밍의 한 특징이다.
- 오버로딩을 하기 위해서는 매개 변수의 개수와 타입이 서로 달라야 한다.

정적 바인딩 이란?
- 컴파일 시점에서 사용될 메서드가 결정 되는 것.

- println의 메소드 오버로딩 사용 예시

System.out.println(12);
System.out.println(12.23);
System.out.println("afd");

- int, float, srting 등 자료형 구분 없이 오버로딩을 사용하여 편리하게 사용

기본 문법(3)

KoreanPaper — Wed, 21 Jan 2026 14:57:06 +0900

1. 비교 연산자

public static void main(String[] args) {
boolean Kor=false;
boolean Adult=true;

System.out.println(Kor && Adult);  // ANd -> &&는 둘다 T일 때만, T
System.out.println(Kor || Adult);  // OR -> ||는 하나라도 T이면, T


System.out.println(1==0 && 1/0==0);  // &&는 앞에 있는 피연산자가 F이면 뒤를 평가하지 않음(단축평가)
System.out.println(1!=0 || 1/0==0);  // ||은 앞에 있는 피연산자가 T이면 뒤를 평가하지 않음

String str1 = new String("java"); 
String str2 = new String("java");
System.out.println(str1==str2);  // String 안에 텍스트가 저장 되어 있는게 아니라 텍스트 데이터가 있는 주소가 저장되어있음

Scanner sc = new Scanner(System.in);
String t1 =sc.nextLine();
String t2 =sc.nextLine();
System.out.println(t1==t2);  // 다르다고 인식, scanner가 각기 다른 별개의 텍스트로 메모리에 저장, 즉 주소비교
System.out.println(t1.equals(t2));  // 텍스트가 같은지 비교 (내용이 같은지)

char c ='A'; // 원시타입 -> 메모리에 직접저장
System.out.println('A'=='A'); //한글자씩 직접적으로 메모리 저장되는 char는 비교가 보장된다.



}

2. 증감 연산자(전위, 후위)

int b =10;
System.out.println(b); //10
System.out.println(b++); //10
System.out.println(b); //11

int c = b++;
System.out.println(b +""+c); // 12 11

int d = ++b;
System.out.println(b+""+d); // 13 13

- 파이썬은 증감 연산자가 없음

3. if문(조건)

public class Solution03 {
public static void main(String[] args) {

int c = 100;
if (c < 40) {
System.out.println("c가 40보다 작다");
} else if (c<90) {
System.out.println("c가 90보다 작다");
} else {
System.out.println("아무 조건도 해당하지 않는다.");
}

}

4. switch문(조건)

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
int day = sc.nextInt();

switch (day%7) {

case 0:
System.out.println("sun");
break;

case 1:
System.out.println("mon");
break;

case 2:
System.out.println("tue");
break;

case 3:
System.out.println("wen");
break;

default:
System.out.println("해당 없음");
break;
}

}

5. for문(반복)

public static void main(String[] args) {

for(int i =0; i<5; i+=2) {
System.out.println(i);
}
        
-------------------------------------------------------
        
for (int a=5; a>=0; a--) {
System.out.println(a); // '5-a' 으로도 표현 가능
}

}

6. while문(반복)

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
String name ="";

while(name.equals("")) {
Systehttp://m.out.print("name: ");
name=sc.nextLine();

if(name.equals("")) {
System.out.println("nothing");
} else {
System.out.println("hi "+name);
}
}

----------------------------------------------------------------
        
int i=0;
while(i<5) {
System.out.println(i);
i++;
}

----------------------------------------------------------------
        
int j =0;
do {
System.out.println(j);
j++;
} while (j<5);

}

7. 여러가지 조건에 의해 끝나는 경우 Or 조건문으로 표현하기 매애한 경우

public static void main(String[] args) {

Scanner sc= new Scanner(System.in);
while(true) {
System.out.println("name: ");
String input = sc.nextLine();

if(input.equals("")) {
System.out.println("nothing");
continue;
}
System.out.println("hi "+input);
break;
}
}

8. 배열

public static void main(String[] args) {

int[] numbers; //배열 선언
numbers = new int[5]; // 초기화
numbers[0]=10; // 0번째 자리에 10을 삽입
System.out.println(numbers[0]);

String[] names = new String[10]; // 빈 배열을 선언하고 초기화

int[] ages = {10,20,30};
String[] titles = {"dd","ff","gg"};
System.out.println(titles); // 주소 출력
System.out.println(Arrays.toString(titles)); //데이터 출력

int[][] matrix = new int[5][3]; // 2차원 배열, 4주치의 3일치
int [][] matrix2 = {
{1,2,3},
{0,6,4},
}; //행렬
System.out.println(matrix2[1][2]);
System.out.println(Arrays.toString(matrix2)); //주소 출력
System.out.println(Arrays.deepToString(matrix2)); //데이터 출력

}
    ---------------------------------------------------------------------------
          int[] numbers= {1,2,3,4,5};

              for(int i=0; i<numbers.length; i++) {
                  System.out.println(numbers[i]);
              }

              //향상된 for문
              for(int number : numbers) {
                  System.out.println(number); // 1 2 3 4 5 형태로 출력
}