아주그냥

RedisTemplate 없이 Jedis로 직접 Redis 연결해보기

p퐝유p — Sun, 31 May 2026 00:40:20 +0900

☆ 기존 Redis 쓰는 방식

@Autowired
private RedisTemplate<String, String> redisTemplate;

redisTemplate.opsForValue().set("key", "value");
redisTemplate.opsForValue().get("key");

application.yml에 host랑 port만 적으면 연결됐다.

spring:
  data:
    redis:
      host: localhost
      port: 6379

여기에 대한 내부 동작을 알아보고 싶어 직접 Redis를 연결해봤다.

☆ Jedis란?

Jedis는 Java에서 Redis에 명령어를 직접 보낼 수 있게 해주는 클라이언트 라이브러리다.

사실 Spring Data Redis도 내부적으로 Jedis(또는 Lettuce)를 쓰고 있다.
우리가 RedisTemplate을 쓸 때 그 아래에서 Jedis가 실제로 Redis 서버에 명령어를 보내고 있었던 거다.

입력한 코드
  → RedisTemplate (Spring Data Redis가 감싸줌)
    → Jedis / Lettuce
      → Redis 서버

오늘은 중간 단계 RedisTemplate 를 건너뛰고 Jedis를 직접 쓴 거다.

☆ Redis 단일 연결해보기

public class UrlRepository {

    private final Jedis jedis;

    public UrlRepository() {
        this.jedis = new Jedis("localhost", 6379);
    }

    public void save(String code, String originalUrl) {
        jedis.set("url:" + code, originalUrl);
    }

    public String findByCode(String code) {
        return jedis.get("url:" + code);
    }
}

jedis.set() = Redis SET 명령어

jedis.get() = Redis GET 명령어

그냥 Redis 명령어가 그대로 보인다. RedisTemplate이 숨겨주던 게 이거였구나 싶었다.

☆ Connection Pool로 연결해보기

요청 1 → Jedis 연결 생성 → 사용 중...
요청 2 → 같은 Jedis 연결 사용 시도 → 충돌!

더 심각한 건 이거다.

동시 요청 1000개
→ 연결 1000개 생성 시도
→ Redis 서버 부하 폭발!!

이를 해결하고자 Connection Pool을 연결해보았다.

Connection Pool은 이렇게 동작한다.

미리 연결 N개 만들어놓고
요청 오면 → 놀고 있는 연결 빌려줌 → 다 쓰면 반납

JedisPool을 적용했다.

public class UrlRepository {

    private final JedisPool jedisPool;

    public UrlRepository() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();

        // 최대 연결 수: 동시에 Redis에 접근할 수 있는 최대 연결 개수
        poolConfig.setMaxTotal(10);

        // 최대 대기 연결 수: Pool에서 놀고 있는 연결 최대 개수
        poolConfig.setMaxIdle(5);

        // 최소 대기 연결 수: 항상 유지할 최소 연결 개수
        poolConfig.setMinIdle(2);

        // 연결 고갈 시 대기 여부
        poolConfig.setBlockWhenExhausted(true);

        this.jedisPool = new JedisPool(poolConfig, "localhost", 6379);
    }

    public void save(String code, String originalUrl) {
        // try-with-resources: 사용 후 자동으로 Pool에 반납
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set("url:" + code, originalUrl);
        }
    }

    public String findByCode(String code) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.get("url:" + code);
        }
    }
}

try-with-resources로 Jedis를 감싼 게 포인트다.
블록이 끝나면 자동으로 Pool에 반납된다.
반납 안 하면 연결이 고갈돼서 새 요청이 무한 대기하게 된다.

☆ Spring Data Redis의 역할

직접 구현하고 나니 RedisTemplate 뒤에 뭐가 있는지 보였다.

직접 구현	Spring Data Redis
`new JedisPool(poolConfig, "localhost", 6379)`	`application.yml`에 host, port만 작성
`jedisPool.getResource()`	자동으로 연결 가져옴
`try-with-resources`로 반납	자동으로 반납
`jedis.set(key, value)`	`redisTemplate.opsForValue().set(key, value)`
`jedis.get(key)`	`redisTemplate.opsForValue().get(key)`

backend-labs 레포: https://github.com/nikeisme/backend-labs

순수 Java로 HTTP 서버 구현해보기

p퐝유p — Thu, 28 May 2026 22:56:22 +0900

순수 소켓으로 HTTP 서버를 구현해보았다.

AI와 함께 같이 살아가면서 깊은 사고를 하지 않는다. 아니 사고조차 하지 않으려한다.

진짜 귀찮으면 AI가 써준 코드를 이유를 알아보려 하지도 않고 화이트박스 형식으로 기능만 구현이 되면 커밋을 때린다.

SpringBooot 없이, JPA 없이, 외부 웹 프레임워크 부재를 느끼면서

계속 사고하는 방식으로 습관을 들이고자 위와 같은 것을 시도해보았다.

앞으로 이렇게 많이 까보는 호두까기가 될 것이다. 그래야 내가 시야가 넓어질 것 같기 때문.

오늘 만든 것

POST /shorten -> 긴 단축 URL을 단축 코드로 변환
GET /{code} -> 단축 코드로 원본 URL에 301 리다이렉트

프로젝트 구조

url-shortener/
├── Main.java
├── server/
│   └── HttpServer.java
├── handler/
│   └── RequestHandler.java
├── service/
│   └── UrlShortenerService.java
├── repository/
│   └── UrlRepository.java
└── util/
    └── Base62.java

핵심 개념 1 - Base62 인코딩

URL 단축의 핵심은 긴 URL을 짧은 코드로 바꾸는 것이다.

숫자를 62진수로 변환하는 방식을 쓴다. 0~9, a~z, A~Z 총 62개 문자를 사용한다.

예를 들어, DB의 ID 값 '12345'를 Base62로 인코딩하면 'dnh' 같은 짧은 문자열이 된다.

public class Base62 {

    private static final String CHARACTERS = 
        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final int BASE = 62;

    public static String encode(long id) {
        StringBuilder sb = new StringBuilder();
        while (id > 0) {
            sb.append(CHARACTERS.charAt((int) (id % BASE)));
            id /= BASE;
        }
        return sb.reverse().toString();
    }

    public static long decode(String code) {
        long result = 0;
        for (char c : code.toCharArray()) {
            result = result * BASE + CHARACTERS.indexOf(c);
        }
        return result;
    }
}

<실행 화면>

- Base62로 인코딩 완료

- Base62로 디코딩 완료

- Base62로 인코딩 → 디코딩 → 인코딩 왕복 완료

핵심 개념 2 - 순수 소켓 HTTP 서버

Tomcat을 사용하면 아래와 같이 수행된다.

클라이언트 → Spring Boot (Tomcat이 다 처리) → 코드

Tomcat 께서 해주셨던 것을 직접 구현하면 이렇게 된다.

클라이언트 → ServerSocket → RequestHandler → 코드

HTTP 요청이 실제로 어떻게 생겼는지 처음 알았는데, 그냥 텍스트다.

POST /shorten HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Content-Length: 37

{"url":"https://www.naver.com"}

이걸 직접 읽고 파싱해서 처리하는 것이다.

public class HttpServer {

    private final int port; // 서버가 열릴 포트 번호 (8080)
    private final UrlShortenerService service; // URL 단축 비즈니스 로직
    private final ExecutorService threadPool; // 동시 요청 처리용 스레드 폴

    public HttpServer(int port) {
        this.port = port;
        this.service = new UrlShortenerService(); 
        // Java 21 - 기존 스레드보다 가볍고 수천 개 동시 처리 기능
        this.threadPool = Executors.newVirtualThreadPerTaskExecutor(); 

    public void start() throws IOException {
        // 지정한 포트를 열고, 클라이언트 연결 대기 시작
        ServerSocket serverSocket = new ServerSocket(port);
        System.out.println("서버 시작! 포트: " + port);

        while (true) {
            // 클라이언트가 연결될 때까지 여기서 블로킹 대기
            Socket clientSocket = serverSocket.accept();

            // 연결된 클라이언트를 RequestHandler에게 위임
            // 스레드 폴이 처리하므로 메인 루프는 바로 다음 연결 대기로 복귀
            threadPool.submit(new RequestHandler(clientSocket, service));
        }
    }
}

여기서 Executors.newVirtualThreadPerTaskExecutor()를 쓴 게 포인트다.

Java 21의 Virtual Thread를 활용했는데, 기존 스레드보다 훨씬 가볍다. 동시 요청이 많아져도 버틸 수 있다.

핵심 개념 3 - RequestHandler

HttpServer가 클라이언트 연결을 받으면 RequestHandler한테 넘긴다.

RequestHandler가 하는 일은 딱 4가지다.

HTTP 요청 읽기
파싱 (메서드,경로 추출)
라우팅
응답전송

@Override
public void run() {
    try (
        // 클라이언트가 보낸 데이터를 읽는 스트림
        BufferedReader in = new BufferedReader(
            new InputStreamReader(clientSocket.getInputStream()));
        // 클라이언트에게 데이터를 보내는 스트림
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream())
    ) {
        // HTTP의 첫번째 줄을 읽기
        // ex) "POST /shorten HTTP/1.1" or "GET /abc123 HTTP/1.1"
        String requestLine = in.readLine(); // 연결은 됐지만 요청이 없는 경우 종료

        if (requestLine == null) return;

        // 공백으로 분리
        // parts[0] → 메서드 (GET, POST)
        // parts[1] → 경로 (/shorten, /abc123)
        // parts[2] → HTTP 버전 (HTTP/1.1)
        String[] parts = requestLine.split(" ");
        String method = parts[0];
        String path = parts[1];

        // 라우팅 - 메서드 + 경로 조합으로 핸들러 결정
        // Spring Boot의 @PostMapping, @GetMapping 이 내부에서 하는 것과 동일
        if (method.equals("POST") && path.equals("/shorten")) {
            handleShorten(in, out);
        } else if (method.equals("GET") && !path.equals("/")) {
            handleRedirect(path, out);
        } else {
            sendResponse(out, "404 Not Found", "text/plain", "Not Found");
        }

    } catch (IOException e) {
        e.printStackTrace();
    }
}

Spring Boot에서 @PostMapping("/shorten"), @GetMapping("/{code}") 이렇게 달았던 게 내부에서 이런 식으로 동작하고 있었던 거다.

Spring Boot와 비교해보기

직접 구현한 코드가 Spring Boot에서는 어떤 어노테이션으로 대체되는지 비교해보면 이렇다.

서버 시작 - ServerSocket

// 우리가 직접 구현한 것
ServerSocket serverSocket = new ServerSocket(8080);

// Spring Boot에서는
@SpringBootApplication  // 내장 Tomcat이 자동으로 포트 열어줌
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

<실행 화면>

라우팅 - method.equals("POST") && path.equals("/shorten")

// 우리가 직접 구현한 것
int contentLength = 0;
while (!(line = in.readLine()).isEmpty()) {
    if (line.startsWith("Content-Length:")) {
        contentLength = Integer.parseInt(line.split(": ")[1].trim());
    }
}
char[] body = new char[contentLength];
in.read(body);

// Spring Boot에서는
@RequestBody Map<String, String> body  // 알아서 파싱해줌

응답 전송 - out.print("HTTP/1.1 200 OK\r\n...")

// 우리가 직접 구현한 것
out.print("HTTP/1.1 200 OK\r\n");
out.print("Content-Type: application/json\r\n");
out.print("Content-Length: " + body.length() + "\r\n");
out.print("\r\n");
out.print(body);
out.flush();

// Spring Boot에서는
return ResponseEntity.ok().body(Map.of("code", code));

301 리다이렉트

// 우리가 직접 구현한 것
out.print("HTTP/1.1 301 Moved Permanently\r\n");
out.print("Location: " + originalUrl + "\r\n");

// Spring Boot에서는
return ResponseEntity.status(HttpStatus.MOVED_PERMANENTLY)
        .location(URI.create(originalUrl))
        .build();

Spring Boot가 편한 건 맞다. 근데 이걸 직접 짜보고 나니 어노테이션 뒤에 뭐가 있는지가 보인다.

실제 동작 확인

# URL 단축 요청
curl -X POST http://localhost:8080/shorten \
  -H "Content-Type: application/json" \
  -d '{"url":"https://www.naver.com"}'

# 응답
{"code":"1"}

# 리다이렉트 확인
curl -v http://localhost:8080/1

# 응답
HTTP/1.1 301 Moved Permanently
Location: https://www.naver.com

<실행 화면>

- URL 단축 요청 → code : 1 로 응답 확인

- 301 리다이렉트 확인 → 응답 확인

아니 그래가지구 결국

HTTP는 결국 텍스트 프로토콜이다.

그동안 Tomcat이 다 해줬기 때문에 HTTP 요청/응답이 어떻게 생겼는지도 몰랐다. 직접 파싱해보니 그냥 줄바꿈으로 구분된 텍스트라는 게 체감됐다.

Tomcat이 하는 일이 보였다.

포트 열고, 연결 받고, 요청 파싱하고, 응답 전송하고. 이걸 Tomcat이 다 해줬던 거다.
이제 spring-boot-starter-web 의존성 추가하면 어떤 일이 일어나는지 머릿속에 그려진다.

AtomicLong의 필요성을 이해했다.

멀티스레드 환경에서 일반 long을 쓰면 동시 요청 시 같은 코드가 두 개 생길 수 있다.
AtomicLong의 getAndIncrement()는 원자적으로 처리되기 때문에 이 문제가 없다.

다음 단계

지금은 In-Memory (HashMap)에 저장하고 있어서 서버 재시작하면 데이터가 날아간다.

다음에는 Redis를 연결해서 영속성을 추가할 예정이다.

계속 업데이트할 예정!

backend-labs 레포: https://github.com/nikeisme/backend-labs

인프라 엔지니어가 매일 실행하는 리눅스 명령어들

p퐝유p — Sun, 17 May 2026 21:43:04 +0900

일 평균 500만 건 로그를 수집하며 원활히 운영 중인 시스템에 문제가 생기면,

제일 먼저 드는 생각이 "원래 아무 문제 없었는데" 이다.

근데 이런 생각을 하는 내가 싫다. 어디선가 잘못되었으니까 생기는 문제이기 때문이다.

어쩌면 회피형 + 불안형에서 비롯된 대사일지도... ㅎㅎ

디버깅을 해보면 서버 환경 문제인 경우가 대다수였다.

인프라 쪽을 의심하려고 해도 증거를 갖고 의심해야 하고, 이제 서버도 항상 모니터링이 필요하다고 생각이 들어

인프라 엔지니어가 매일 실행하는 리눅스 명령어를 눈에 익혀보려고 한다.

★ 서버 상태 확인

uptime  #서버 가동 시간 + 부하 평균 (load average)

top  # 실시간 프로세스 및 CPU/메모리 사용률
htop # top의 컬러 개선판 (별도 설치 필요)

★ 디스크 / 메모리

df -h  # 디스크 파티션별 사용량(human-readable)
free -h # 메모리 및 스왑 사용량

★ 네트워크

ip a # 네트워크 인터페이스 및 IP 주소 목록
ip r # 라우팅 테이블
ss -tlnp # 리스닝 중인 포트 및 해당 프로세스

★ 서비스 관리

systemctl status <서비스명> # 특정 서비스 상태 확인
systemctl --failed # 실패한 서비스 전체 목록
jouranlctl -u <서비스명> -f #실시간 서비스 로그 스트리밍

★ 커널 / 보안

dmesg | tail # 최근 커널 메시지 (하드웨어 오류, 네트워크 이슈 등)
last # 최근 로그인 기록 (누가 언제 접속했는지)

★ 정리

- 서버 응답이 느릴 때 → uptime으로 load average 확인 → top으로 범인 프로세스 찾기

- 디스크 꽉 찼다는 추측이 들 때 → df -h 로 어느 파티션인지 확인

- 서비스 갑자기 안될 때 → systemctl --failed 먼저, 그 다음 journalctil -u <서비스명>

- 외부에서 접속이 안될 때 → ss -tnlp 로 포트 열려있는지 확인

실시간 대용량 처리는 많은 범위의 공부가 필요하다.

앞으로 하나하나씩 익혀가며 성장하자

화이티잉

SELECT 쿼리에 ORDER BY를 꼭 써야 하는 이유 (+ 페이징까지)

p퐝유p — Tue, 12 May 2026 21:22:02 +0900

업무 중에 거래로그를 적재하는 테이블에서

데이터를 감지(폴링)하는 SELECT 쿼리를 짜다가, ORDER BY가 왜 중요한지 제대로 이해하게 되었다.

아~ 실시간으로 폴링을 하니까 더 단단한 순차적 폴링을 위해 ORDER BY 를 하는곤가? 추측했다.

하지만!! 생각보다 훨씬 중요한 이유가 있었다.

☆ ORDER BY가 없으면 무슨 일이 생길까?

-- 이렇게 쓰면 안 된다
SELECT * FROM trade_log LIMIT 10;

얼핏 보면 문제없어 보인다.

그런데 DB는 ORDER BY가 없으면 자기 마음대로 순서를 정한다.

오늘은 PK 순서대로 줄 수 있고, 내부 인덱스 상태나 실행 계획에 따라 내일은 다른 순서를 줄 수도 있다.

같은 쿼리인데 실행할 때마다 결과 순서가 다를 수 있다는 뜻이다.

거래로그처럼 시간 순서나 일련번호 순서가 의미 있고, 수억건이 있는 데이터에서 문제가 일어나면 걷잡을 수 없다.

-- 이렇게 써야 한다
SELECT * FROM trade_log ORDER BY seq LIMIT 10;

근데 ORDER BY만 넣는다고 끝이 아니다.

-- Page 1
SELECT * FROM trade_log ORDER BY seq DESC LIMIT 10 OFFSET 0;

-- Page 2
SELECT * FROM trade_log ORDER BY seq DESC LIMIT 10 OFFSET 10;

ORDER BY도 넣었고, LIMIT/OFFSET도 썼다.

완벽해 보이지만.... 씹던 껌으로 막아놓은 구멍 송송 뚫린 파이프라인이다.

☆ 데이터는 계속 변한다

Page 1을 조회하는 사이에 데이터가 삭제됐다고 해보자.

조회 전: seq 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

Page 1 조회 → 10, 9, 8, 7, 6 반환

이 사이에 seq 10 삭제됨

Page 2 조회 (OFFSET 10) → 4, 3, 2, 1

seq 5번이 어디 갔지? Page 1에도 없고 Page 2에도 없다. 그냥 누락된 거다.

반대로 새 데이터가 추가되면 같은 row가 두 페이지에 중복으로 나오기도 한다.

거래로그에서 특정 건이 조회 안 된다? 운영 중인 서비스에서 이런 일 생기면 꽤 심각하다.

☆ 제대로 된 해법: 커서 기반 페이징

OFFSET 대신 마지막으로 본 데이터의 기준값을 조건으로 넘기는 방식이다.

-- 처음 조회
SELECT * FROM trade_log ORDER BY seq DESC LIMIT 10;

-- 다음 페이지: 마지막으로 받은 seq를 기준으로
SELECT * FROM trade_log WHERE seq < :lastSeq ORDER BY seq DESC LIMIT 10;

이렇게 하면:

중간에 데이터가 삭제돼도 누락 없음
새 데이터가 추가돼도 중복 없음
뒤 페이지로 갈수록 느려지는 문제도 없음 (OFFSET 100000 같은 풀스캔 방지)

PK가 일련번호인 테이블에서 특히 잘 맞는 방식이다.

☆ 정리

문제	원인	해결
매번 순서가 다름	ORDER BY 없음	ORDER BY 추가
페이지 이동 시 누락/중복	OFFSET 기반 페이징	커서 기반으로 교체
뒤 페이지 조회 느림	OFFSET 큰 값	커서 기반으로 교체

ORDER BY는 시작일 뿐이고, 페이징까지 제대로 하려면 커서 기반까지 고려해야 한다.

Claude API로 Git 작업 자동화해봤다 (브랜치명, 커밋, PR까지)

p퐝유p — Wed, 1 Apr 2026 17:49:35 +0900

사이드 프로젝트 하면서 Git 작업이 점점 번거로워졌다.

왜냐하면 점점 낮아지는 나의 작문 실력 때문이었다.

원활한 공유를 위해 팀원들에게 나의 작업을 간결하면서도 가독성이 높게 pr을 진행하고 싶었는데

나의 작문 실력은 날로 증발했다.

그리고 때때로, 브랜치명 지을 때마다 컨벤션 문서 찾아보고,

커밋 메시지는 대충 fix 때려박고, PR 본문은 귀찮아서 비워두는 일이 반복됐다.

기능 구현보다 이런 부수적인 작업에 시간이 더 드는 느낌이랄까.

그래서 요즘 대세이자 가족,친구들보다 내가 더 많이 찾는 Claude의 API를 붙여서 이걸 자동화해봤다.

★ CLAUDE.md 파일이란?

Claude Code(Anthropic에서 만든 터미널용 Claude CLI)를 사용할 때,

프로젝트 루트에 CLAUDE.md 파일을 놓으면 Claude가 자동으로 읽어서 컨텍스트로 활용한다.

프로젝트 루트/
├── CLAUDE.md   ← Claude가 자동으로 읽는 컨텍스트 파일
├── src/
└── ...

매번 "우리 브랜치 컨벤션은 이래, 커밋은 이렇게 써야 해" 설명할 필요 없이,

이 파일 하나로 Claude가 프로젝트 맥락을 이해하고 그에 맞는 결과물을 뽑아준다.

뭔가 인수인계 할 때의 파일처럼 이 파일을 만들어놓으면 이 맥락으로 착착착 결과물이 나온다... 대박...

그래서 CLAUDE.md 파일을 만들어서 Clauder가 우리 프로젝트 맥락을 항상 이해하도록 설계했다.

# 반듯서랍 — Claude Context

## 브랜치 컨벤션
{type}/{kebab-case-description}
- feature: 신규 기능
- fix: 버그 수정
- refactor: 리팩토링
...

## 커밋 컨벤션
{type}: {설명}

## PR 형식
## What / ## Why / ## How

이것만 해놓으면 "내가 그때 말했자나!! " 이런 말을 하지 않을 수 있다.

★ 만든 것들

우선, 아래 두 파일을 만들었다.

scripts/
├── branch.py   ← 작업 내용 → 브랜치명 자동 생성
└── commit.py   ← 파일 선택 → 커밋 → 충돌 체크 → push → PR 생성

1. branch.py 실행

해당 파일은 브랜치 명을 생성해주고, checkout을 해준다.

아래 명령어로 실행된다.

Claude는 컨텍스트를 입력하기 때문에 최대한 ""에 들어가는 내용을 구체적으로 적어주는게 좋다.

python3 scripts/branch.py "브랜치를 생성하는 의의" --checkout
--checkout 옵션 붙이면 선택 즉시 git checkout -b까지 해준다.

위의 명령어를 입력하면 아래와 같이 뜬다.

브랜치 명을 3가지 정도 만들어주고 선택하게 만들었다.

2. commit.py 실행

이 녀석이 아주 요긴하다. 한번 실행하면 커밋부터 PR생성까지 다 해준다.

변경된 파일 목록 보여주고 선택해서 add
diff 읽어서 커밋 메시지 3개 추천
main과 충돌 사전 감지
push 자동화
PR 본문 자동 생성 (What/Why/How)
gh CLI로 PR 생성까지

아래의 명령을 실행한다.

python3 scripts/commit.py

실행 후, 아래와 같이 수행이된다.

python3 scripts/commit.py
```

**흐름은 이렇다:**

**1. 변경된 파일 선택 → git add**
```
변경된 파일 목록:
  [1] [수정] AuthService.java
  [2] [수정] JwtService.java

선택: a
```

**2. diff 읽어서 커밋 메시지 3개 추천**
```
  [1] feat: 로그아웃 API 및 토큰 블랙리스트 처리
  [2] feat: JWT 로그아웃 구현
  [3] refactor: AuthService 로그아웃 플로우 추가

번호 선택: 1
✅ 커밋 완료
```

**3. push 전 main과 충돌 사전 감지**

push하기 전에 `origin/main`을 fetch해서 충돌 여부를 미리 확인한다. 충돌이 있으면 push를 막고 해결 방법을 알려준다.
```
  main과 충돌 체크 중...
✅ 충돌 없음
  push 완료
```

**4. push 후 CI 링크 안내**

빌드와 테스트는 GitHub Actions가 알아서 돌려준다. 로컬에서 매번 빌드하면 너무 느리니까, push 후 CI 링크만 띄워주는 방식으로 설계했다.
```
  CI 확인: https://github.com/bandeutseolap/repo/actions
```

**5. PR 본문 자동 생성 → PR 생성**

diff 전체를 Claude에게 넘겨서 What/Why/How 구조로 PR 본문을 뽑아준다. GitHub CLI(`gh`)와 연동해서 터미널에서 PR 생성까지 완료된다.
```
✅ PR 생성 완료!
   https://github.com/bandeutseolap/repo/pull/12

3. pull requests 확인

commit.py 까지 완료되면, pr 이 생성된 내용으로 open 된 것을 확인할 수 있고, 확인은 github에서 진행된다.

★ 마치며

이리저리 돌아다니며 어케 claude로 이런 것 까지 구현하지라는 생각이 많았고, 한편으로는 부러웠다.

우선 깃 브랜치/커밋 자동화로 클로드랑 한번 놀아본 결과, 내가 기획자가 되어야겠다 라는 생각이 되었다.

계속 부족한 것 생각해내고, 사용성을 어케 높일까 생각의 연속이었다.

계속 이 시스템에 대해서 보완점을 생각해서 품질을 높여야겠다.

DFS vs BFS — 지도 탐험으로 이해하기

p퐝유p — Mon, 30 Mar 2026 11:18:06 +0900

☆ 상황 설정

아래와 같은 도시지도

목표: 1번 도시에서 출발해서 모든 도시 방문하기

☆ DFS — 길이 막힐 때까지 직진하는 탐험가

"일단 한 방향으로 끝까지 파고들고, 막히면 돌아와서 다른 길"

1번 출발 → 2 → 3 → 4
(4에서 막힘, 되돌아오기)
→ 5 → 6 → 7
(7에서 막힘, 되돌아오기)
→ 8
(8에서 막힘, 되돌아오기)
→ 9 → 10

방문 순서: 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10

한 우물만 끝까지 파는 스타일

☆ BFS — 주변부터 챙기는 탐험가

"지금 있는 곳 주변 다 돌고, 그 다음 거리 돌고, 또 그 다음..."

1번 출발
→ 1 주변 먼저: 2, 5, 9
→ 2 주변: 3 / 5 주변: 6, 8 / 9 주변: 10
→ 3 주변: 4 / 6 주변: 7

방문 순서: 1 → 2 → 5 → 9 → 3 → 6 → 8 → 10 → 4 → 7

돌 던지면 퍼지는 물결처럼 퍼져나가는 스타일

☆ 차이

	DFS	BFS
방식	끝까지 직진 후 되돌아오기	가까운 것부터 차례로
구현	재귀 or 스택	큐(Queue)
용이성	경로 존재 여부, 미로 탈출	최단 경로 찾기

☆ 비유로 기억하기

DFS = 집에서 리모컨 찾을 때 소파 쿠션 하나 다 뒤지고, 다음 쿠션 뒤지는 스타일
BFS = 일단 눈에 보이는 곳 다 훑고, 그 다음 범위 훑는 스타일

최단거리 문제 나오면 → BFS
갈 수 있나 없나 문제 나오면 → DFS or BFS 둘 다 가능

유형별 자료 구조

	자료구조	이유
DFS	스택	되돌아가야 하니까 → 마지막 것부터
BFS	큐	발견 순서대로 탐색해야 하니까 → 처음 것부터

전국 지도로 이해하는 그래프 표현

p퐝유p — Mon, 30 Mar 2026 10:45:11 +0900

☆ 상황 설정

도시 4개 : 서울(0),인천(1),수원(2),대전(3)

연결된 도시

서울 - 인천 - 수원 - 대전

1. 인접 행렬 = 전국 도로 지도책

모든 도시 조합을 표에 다 박아놓고 O/X 표시

서울  인천  수원  대전
서울  [  X    O    X    X  ]
인천  [  O    X    O    X  ]
수원  [  X    O    X    O  ]
대전  [  X    X    O    X  ]

"서울-수원 도로 있어?" → 지도책에서 바로 찍으면 된다. graph[0][2] → X. O(1)

근데 도시가 1000개면?
실제 도로가 몇 개 없어도 1000×1000 = 100만 칸 지도책을 만들어야 한다.
공간 O(N²)

2. 인접 리스트 = 각 도시 관광안내소 팜플렛

"각 도시에서 갈 수 있는 곳만 적어놓기"

서울 안내소   → 인천만 적혀있음
인천 안내소   → 서울, 수원 적혀있음
수원 안내소   → 인천, 대전 적혀있음
대전 안내소   → 수원만 적혀있음

도로 없는 조합은 아예 안 적으니까 팜플렛이 훨씬 얇아요.
공간 O(N + 간선)

근데 단점이 있다.

"서울-수원 도로 있어?" → 서울 안내소 팜플렛 펼쳐서 수원이 나올 때까지 쭉 읽어야 함. O(N)

☆결론

	지도책 (인접행렬)	팜플렛(인접 리스트)
연결 확인	바로 찍으면 됨 O(1)	팜플렛 읽어야 함 O(N)
공간	100만 칸 O(N²)	있는 것만 O(N+간선)
용이성	도시 적고 확인 많을 때	도시 많고 도로 듬성듬성할 때

시간을 아끼려면 지도책, 공간을 아끼려면 팜플렛

[dev] 로그인 #2 - 인증 아키텍처 설계

p퐝유p — Thu, 26 Mar 2026 14:30:51 +0900

구현하기 전에 나는 "만약에" 함정에 빠진다☺️

물론, 일단 구현하는 것도 좋지만

이제 회사에서 뭣 좀 해봣다고

"만약에 만약에 이런 경우에는 이것도 저것도 고려해야하지 않을까"라는 생각이 꼬리에 꼬리를 문다.

이러한 현상은 내가 알고 있는 지식과 사고를 넘어선 확장이라는 긍정 작용도 발동하지만,

과하게 생각해 말그대로 산으로 가기 때문에 항상 다시 중심으로 돌아와서 본질을 생각하는 습관을 들여야겠다는 다짐을 한다.

☆ 설계 전에 정해야할 것들

코드 짜기 전, 세가지를 먼저 결정해야했다.

1. Access Token 만료 시간

2. Refresh Token 만료 시간

3. Redis에 Refresh Token을 어떤 키로 저장할 것 인가

★ Access Token 만료 시간 — 1시간

- Access Token은 짧을수록 보안에 유리하다. 탈취되더라도 유효시간이 짧으면 피해범위가 줄어들기 때문이다.

어차피 Refresh Token 으로 자동 재발급하니까 사용자는 만료를 체감하지 못한다.

처음엔 2시간으로 잡았다.
하지만 해당 협업 툴 프로젝트는 하루종일 켜두는 서비스라는 것을 고려하면 Access Tokend은 짧게 가져가는 것이 맞다.

보안과 UX를 분리해서 생각하면

보안은 Access Token 짧게, UX는 Refresh Token 길게 — 가 정답이다. 1시간으로 조정했다.

★ Refresh Token 만료 시간 — 14일

Refresh Token은 Access Token이 만료됐을 때 재발급받기 위한 토큰이다.

Redis에서 관리하기 때문에 탈취되더라도 서버에서 즉시 무효화할 수 있다.

제어권이 서버에 있으니 길게 가져가도 부담이 없다.

Slack, Notion, Jira 같은 협업 툴들이 로그아웃을 거의 안 시키는 이유가 있다.

출근해서 켜놓고 하루종일 쓰는 서비스에서 갑자기 재로그인을 요구하면 UX가 크게 나빠진다.

그리고 실 업무에서도 현업이 SSO,SyncUser등을 선호하는 것으로 보아
로그아웃 시간 제한은 최소화로 방향을 잡는게 나을 것 같다.

이로써, 14일로 정했고 2주 이상 접속이 없으면 재로그인을 요구하는 게 자연스럽다고 판단했다.

★ Redis 키 구조 - userId 기반

Redis에 Refresh Token을 저장할 때 키를 어떻게 잡을지가 중요하다. 후보는 세 가지로 추려봤다.

1. userId - 사용자 식별 id 그대로

2. email - 로그인 ID로 사용

3. uuid - 별도 발급

email은 변경 가능성이 있어서 키로 쓰기엔 불안정하다.

uuid를 별도 발급하면 추적이 어렵고 관리 포인트(userId 매핑 등)가 늘어난다.

userId는 불변이고 조회가 단순하다.

최종 키 구조는 아래와 같이 잡았다.

RT:{username}

사내 솔루션으로 컨셉을 잡았고, 특성상 아이디 변경 기능이 없다.

username이 사실상 불변이라 userId 대신 username을 키로 써도 안정적이라고 판단했다. 단순하고 조회도 직관적이다.

☆ 최종 아키텍처 구조 (변경 가능성 매우 많음)

[클라이언트]
    |
    | 로그인 요청 (ID/PW)
    ▼
[서버] 인증 성공
    ├── Access Token 발급 (1시간)
    └── Refresh Token 발급 → Redis 저장 (14일 TTL)
            키: refresh:userId:{userId}
    |
    | Access Token 헤더에 담아 API 요청
    ▼
[서버] 토큰 검증
    ├── 유효 → 요청 처리
    └── 만료 → Refresh Token으로 재발급 요청
            Redis 조회 → 일치하면 Access Token 재발급
            Redis 조회 → 없으면 (만료 or 로그아웃) → 재로그인 요구
    |
    | 로그아웃
    ▼
[서버] Redis에서 해당 userId 키 삭제
       → Refresh Token 즉시 무효화

☆ 이 시점의 고민 사항

설계를 마치고 나서 두 가지 고민이 남았다.

1. Redis 키 구조

- userId를 키로 쓰면 한 계정에 하나의 Refresh Token만 유지된다.

같은 계정으로 여러 기기에서 로그인하면 마지막 로그인이 이전 것을 덮어쓴다.

다중 기기 세션을 지원하려면 키 구조를 refresh:userId:{userId}:{deviceId} 형태로 확장해야한다.

팀원들과 머리를 맞댈 필요가 있다.

2. 추후 Kafka로 인증 이벤트를 집계할 가능성이 있어서 uuid 기반 키 구조를 고민했다.

- uuid를 키로 쓰는 게 의미 있는 경우는 다중 기기 세션 + 보안 강화가 동시에 필요할 때다.

같은 userId로 여러 기기에서 로그인했을 때 각각 독립적으로 관리할 수 있다는 장점이 있다.

사내 솔루션 컨셉이라 다중 기기 세션이 필수는 아니지만, 확장 가능성은 열어둘 필요가 있다고 생각한다.

Kafka 집계 관점에서 필요한 건 키 구조가 아니라 이벤트 설계다.

로그인/로그아웃 이벤트를 Kafka로 흘려보내면 consumer에서 처리하면 되고, Redis 키 구조와는 별개로 움직인다.

uuid를 쓰면 오히려 consumer 쪽에서 uuid → userId 매핑을 따로 해야 해서 복잡도만 늘어난다.

Redis 키는 지금 구조 그대로 가져가되, 다중 기기 세션 지원 여부는 팀원들과 논의해봐야겠다.

[dev] 로그인 #1 - JWT와 Redis를 콤비네이션하기

p퐝유p — Thu, 26 Mar 2026 10:54:29 +0900

☆ 시작하게 된 이유

쿠키 기반 세션 방식이 보안 이슈로 지양되는 추세라는 것을 인지하고 있었다.

CSRF 취약점, 도메인이 달라지면 CORS와 엮이는 문제, 모바일 환경에서의 관리 복잡도. 절대적인 이유는 아니지만,

새로 설계하는 시점에 굳이 이 복잡도를 안고 갈 필요는 없다고 판단했다.

그래서 인증 방식을 처음부터 다시 고민했다.

JWT로 방향을 잡았지만 그것만으로는 부족했다.

Refresh Token 관리에서 다시 막혔고, 결국 Redis와 조합하는 구조로 설계하게 됐다.

JWT 만으로 부족한 이유

JWT를 쓰면 서버에 상태를 두지 않아도 된다. - 이게 장점이자 함정

Access Token 만료 시간을 길게 가져가면 탈취되었을 때 대응이 없다.

짧게 가져가면 UX가 나빠진다. 그래서 Refresh Token을 도입했는데 여기서 문제가 생긴다.

Refresh Token을 클라이언트에만 두면 서버가 제어권을 잃는다.

토큰 탈취 시 강제 무효화 불가
로그아웃해도 토큰 만료 전까지 유효
다중 기기 세션 관리 불가

결국 Refresh Token은 서버 측에 저장해야 했고, 그 순간 "완전한 Stateless"는 포기한 거다. 대신 통제 가능한 구조를 얻었다.

☆ DB 말고 Redis를 선택한 이유

Refresh Token 저장소로 MySQL도 고려했다.

근데 인증은 서비스에서 가장 빈번하게 호출되는 경로다.

매 갱신 요청마다 디스크 I/O가 발생하는 건 불필요한 부하다.

Redis를 선택한 이유는 세 가지다.

첫째, 인메모리라 조회 속도가 압도적으로 빠르다.

둘째, TTL을 걸면 만료 처리를 Redis가 알아서 해준다 — 별도 배치나 스케줄러가 필요 없다.

셋째, 로그아웃은 해당 키를 삭제하면 끝이다. 구현이 단순해진다.

회사 솔루션이 같은 구조를 쓰는 걸 이제는 "당연하다"고 느낀다.

☆정리

	선택	이유
인증 방식	JWT	Stateless, 수평 확장 고려
Access Token	1시간	탈취 피해 범위 최소화
Refresh Token	Redis, 7일 TTL	빠른 조회 + 자동 만료 + 즉시 무효화
로그아웃	Redis 키 삭제	서버 제어권 확보

완전한 Stateless는 아니다. 하지만 Redis 한 곳만 바라보는 구조는 관리 포인트가 명확하고, 이후 MSA 전환 시에도 인증 서버를 분리하기 수월하다. 그게 이 선택의 핵심 이유다.

다음 편은 이 구조를 바탕으로 한 실제 아키텍처 설계 과정을 기록한다.

** 여담 **

이거 기가맥힌 표현이라 기록한다. 나중에 써먹어야지 ㅋㅋㅋㅋㅋㅋ

Stateful → 단골 카페. 사장님이 "이 손님은 아메리카노 즐겨 마심"을 기억하고 있음
Stateless → 처음 가는 카페. 매번 "아메리카노 한 잔 주세요"라고 직접 말해야한다. 카페는 아무것도 기억 안하고 있다.

JWT + Redis로 로그인 구현하기 끄적끄적용

p퐝유p — Tue, 24 Mar 2026 17:54:38 +0900

사이드 프로젝트에서 로그인 기능을 구현하면서 JWT와 Redis를 함께 사용하는 방식을 선택했다.

왜 이 방식을 선택했는지, 어떻게 설계했는지 정리해보자.

☆ JWT

- JWT (Json Web Token)은 사용자 인증 정보를 JSON 형태로 담아 서명한 토큰이다.

서버가 DB를 조회하지 않아도 토큰 자체에서 사용자 정보를 검증할 수 있다.

구조는 Header / Payload / Signature 세 파트로 나뉜다.

Header : 알고리즘 종류 (HS256 등) + 타입
Payload : 실제 데이터 (userId, roles, 만료시간 등)
Signature : Header + Payload를 secret key로 서명한 값

서버의 Secret Key 로 서명되어 위변조를 막을 수 있다.

☆ Redis

- 인메모리 key-value 저장소로, 디스크 DB 대비 수백 배 빠른 읽기와 쓰기가 가능하다.

만료 시간을 key마다 설정할 수 있어서 토큰 관리에 적합하다.

☆ 왜 Redis + JWT 조합인가?

	JWT 단독	JWT + Redis
로그아웃	토큰 만료까지 유효	즉시 무효화 가능
성능	DB 조회 없음	Redis 조회
Refresh Token	관리 어려움	Redis TTL로 자동 만료
구현 복잡도	단순	Redis 인프라 필요

JWT 단독으로는 토큰을 서버에서 강제 무효화할 수 없다.

Redis를 추가하면 로그아웃·보안 이슈 시 즉시 차단이 가능해지고, Refresh Token 관리도 TTL 하나로 해결된다.

☆ Redis TTL 이란?

- TTL은 Time To Live의 약자로, Redis에 저장한 데이터에 "이 키는 N초 후에 자동으로 삭제해" 라고 수명을 정해주는 기능이다.

예를 들어, Refresh Token을 Redis 에 저장했을 때, TTL 없이 그냥 저장하면 로그아웃하지 않는 한 영원히 남아있다.

이는 메모리를 계속 잡아먹고, 보안에도 취약하다.

TTL을 걸어두면 14일 후에 자동으로 키가 사라지니까 별도로 정리하는 로직이 필요하지 않다는 것이 장점이다.

application.yml 에 jwt에 대한 AT(Access Token), RT(Refresh Token) 만료에 대한 설정을 한다.

해당 설정값은 redis에 저장된 순간부터 카운트다운이 시작된다.

위의 설정을 바탕으로
아래와 같이 흐름도를 계획했다.

@Value("${jwt.refresh-expiration}")
private long refreshExpiration;
```
위의처럼 만료일에 대한 변수를 설정하면,
아래의 흐름은 이렇게 된다
```
application.yml
  jwt.refresh-expiration: 1209600000
          ↓
  @Value로 주입
          ↓
  .set("RT:user", token, 1209600000, MILLISECONDS)
          ↓
  Redis에 TTL 14일로 저장

우선 아래는 내가 설계한 Auth 의 흐름대로 도표를 만들어달라고 클로드한테 도움을 요청했다.

너무 좋네 직접 안만들어도 되고 훟후후후ㅜㅎ훗 기특한녀석

오케이 이거 참고해서 구현을 한번 해보겟다!!!

[자료구조] 트리

p퐝유p — Sun, 4 Jan 2026 00:20:18 +0900

★ 트리

▷ 트리는 계층형 비선형 자료 구조

	선형 구조	비선형 구조
구성	데이터가 순차적으로 나열시킨 형태	데이터가 계층적 혹은 망으로 구성
용도	자료를 저장하고 꺼내는 것에 초점	표현에 초점
종류	큐, 스택	트리, 그래프

▷ 트리 구성 요소

구성 요소	의미
Node	트리에 데이터를 저장하는 기본 요소
Root Node	트리 맨 위에 있는 노드
Level	최상위 노드를 Level 0으로 하였을 때, 하위 Branch로 연결된 노드를 깊이 나타냄
Parent Node	어떤 노드의 상위 레벨에 연결된 노드
Child Node	어떤 노드의 하위 레벨에 연결된 노드
Leaf Node (Terminal Node)	Child Node가 하나도 없는 노드
Depth	루트에서 어떤 노드에 도달하기 위해 거쳐야 하는 간선의 수

▷ 트리의 종류

1. 이진트리 (Binary Tree)

- 각 노드가 최대 두 개의 자식을 가진다.

무조건 0,1,2 개만 있어야 한다.

2. 완전 이진트리(Complete Binary Tree)

- 노드를 삽입할 때, 최하단 왼쪽 노드부터 차례대로 삽입해야한다.

▷ 완전 이진 트리를 배열로 표현

- 트리 구조 표현 방법은 직접 클래스를 구현하여 사용 / 배열로 표현하는 방법 2가지가 있음

단, 배열로 표현할 때는 완전 이진 트리일 때만 가능

- 완전 이진 트리는 왼쪽부터 데이터가 쌓이게 됨

<예시>

아래의 트리는 이진 트리이면서 완전 이진트리

      8      Level 0
    6   3    Level 1
   4 2 5     Level 2  # -> 이진 트리 O 완전 이진 트리 O

트리를 구현할 때는 0번째 인덱스는 사용하지 않는다.

그래서 None 값을 배열에 넣고 시작

      8      Level 0 -> [None, 8] 첫번째 레벨의 8을 넣고,
    6   3    Level 1 -> [None, 8, 6, 3] 다음 레벨인 6, 3을 넣고
   4 2 5     Level 2 -> [None, 8, 6, 3, 4, 2, 5] 다음 레벨인 4, 2, 5를 넣는다

▷ 완전이진트리 배열의 인덱스

*현재 인덱스 2**	왼쪽 자식의 인덱스
*현재 인덱스 2 + 1**	오른쪽 자식의 인덱스
현재 인덱스 // 2	부모의 인덱스

▷ 완전이진트리의 높이

- 트리의 높이 : 루트 노드부터 가장 아래 리프 노드까지의 길이 (가장 아래 리프노드 - 루트 노드)

▷ 완전이진트리의 노드 개수

- 레벨을 k라고 한다면, 2^k 개수

▷ 만약 높이가 h인데, 모든 노드가 꽉 차 있는 이진트리라면 모든 노드의 개수는 몇개?

1 + 2^1 + 2^2 + 2^3 + 2^4 ..... 2^h

즉, 이를 수식으로 표현하면 2^(h+1) - 1 이 된다.

출처 :

38군데 합격 비법, 2025 코딩테스트 필수 알고리즘| 딩코딩코 - 인프런 강의

현재 평점 5.0점 수강생 2,371명인 강의를 만나보세요. 초보자도 쉽게 이해하는 단계별 설명으로, 막연했던 코딩 테스트가 명확해집니다. 필요한 것만 배우고 바로 실전에 적용하세요! 알고리즘,

www.inflearn.com

[CI/CD] GitHub Actions Self-Hosted Runner – deploy 단계에서 로딩이 지속 (서버에서 실행하려고 했을 때 생긴 문제) 해결 기록

p퐝유p — Tue, 25 Nov 2025 22:33:28 +0900

GitHub Actions Runner 를 내 서버에 올려서 자동 배포(CI/CD)를 만들려고 했다.
그런데 Runner 를 실행하는 과정에서 여러 오류가 발생했고,
문제 해결 과정을 그대로 정리해 둔다.

나중에 나처럼 Runner 를 처음 설치하거나
systemd/SELinux 때문에 막히는 개발자에게 참고가 되길 바란다.

★ 문제

서버 작업으로 인해 모든 작업들이 다 내려가있었다.

action-runner 또한 내려가있어 gitAction에서 deploy 단계일때,

수행하지 않고 5분 넘게 지속되는 현상이 있었다.

★ 첫번째 시도, svc.sh start 로 실행

처음에 runner 경로에서 다음 명령을 실행했다:

sudo ./svc.sh start

하지만 systemd 서비스가 실행되지 않았다.
로그를 확인하니 이런 오류가 있었다:

status=203/EXEC
Failed to locate executable /home/devuser/actions-runner/runsvc.sh: Permission denied

★ 문제1 - 기존 서비스가 이미 설치되어 있던 상태

처음 설치 시도 시 다음 메시지 발생:

Failed: error: exists /etc/systemd/system/actions.runner.<repo>.service

✔ 원인

이전에 실행된 Runner 설치가 systemd 서비스 파일만 남겨둔 상태여서 새로운 install 이 막힌 것.

✔ 해결

sudo ./svc.sh stop || true          # 이미 실행 중이면 중지, 없으면 오류 무시
sudo ./svc.sh uninstall || true     # 기존 서비스 제거, 없으면 오류 무시
sudo rm /etc/systemd/system/actions.runner.*.service   # 남아 있는 서비스 파일 강제 삭제
sudo systemctl daemon-reload        # systemd 캐시 갱신

★ 문제2 - systemd 가 runsvc.sh 실행 실패 (203/EXEC)

여전히 service start 시 아래 오류가 발생했다:

status=203/EXEC
Permission denied: /home/runner/actions-runner/runsvc.sh

✔ 원인

- SELinux 가 /home 디렉토리에서 systemd 실행을 막고 있었고, systemd 실행 경로가 적절하지 않았다.

✔ 해결

- Runner 를 /opt/actions-runner 로 옮기기로 결정.

sudo mkdir -p /opt/actions-runner   # Runner를 둘 안정적인 시스템 경로 생성
sudo mv /home/runner/actions-runner /opt/actions-runner   # 기존 runner를 /opt로 이동
sudo chown -R root:root /opt/actions-runner   # systemd 실행을 위해 root 소유로 변경

처음에는 Runner를 /home 아래 설치했다.
하지만 systemd가 그 안의 runsvc.sh 를 실행하지 못했다.

SELinux 정책이 home 영역에서의 실행을 막고 있었기 때문이다.

이 경험을 통해 /opt가 다음 이유로 더 적합하다는 걸 배웠다.

시스템 서비스가 실행하기 좋은 영역
SELinux가 기본적으로 허용하는 경로
system 디렉터리와 사용자 디렉터리를 분리할 수 있음

단순한 경로 이동이 아니라
“운영 체제의 동작 방식”을 이해하게 되는 계기였다.

★ 문제3 - config.sh를 root로 실행함 (금지됨)

config.sh 실행 시 다음 오류 발생:

Must not run with sudo

✔ 원인

GitHub Actions Runner 는 설정(config.sh)을 일반 사용자 계정에서 실행해야 한다.
(root 금지)

✔ 해결

su - runner
cd /opt/actions-runner
./config.sh --url https://github.com/<user>/<repo> --token <token>

token 정보는

깃헙의 Settings > Actions > Runners > New self-hosted runner 버튼 클릭 > 해당하는 os 선택 > Configure의 코드 복사

★ 문제4 - config.sh 실행 중 permission denied 다수 발생

✔ 에러 메시지

touch: cannot touch '.env': 허가 거부
.path: 허가 거부
Access denied: /opt/actions-runner/_diag

✔ 원인

Runner 디렉터리가 root 소유 → 일반 사용자(runner) 파일 생성 불가

✔ 해결

sudo chown -R runner:runner /opt/actions-runner   # 디렉터리 소유자를 runner로 변경
sudo restorecon -R /opt/actions-runner            # (선택) SELinux 컨텍스트 복구

이후 다시 실행:

./config.sh --url ... --token ...

★ 최종 성공 — Runner 서비스 정상 실행

config.sh 완료 후:

sudo ./svc.sh install
sudo ./svc.sh start
sudo ./svc.sh status

✔ 성공

1. Runner 설치는 단순 설치작업이 아니라 운영 영역에 가깝다.

처음에는 단순히 공식 문서 따라 config.sh만 실행하면 끝날 줄 알았다.
하지만 실제로는 서버 운영 환경과 강하게 연결되어 있었다.

예를 들어:

systemd가 스크립트를 어디서 실행할 수 있는지
SELinux가 home 디렉토리 실행을 막는지
어떤 계정으로 실행해야 하는지
디렉터리 권한은 어떻게 맞춰야 하는지

이런 부분들을 제대로 이해하지 않으면 Runner가 정상적으로 올라오지 않는다.

설치 과정에서 나는 거의 절반의 시간을
“보안 정책과 권한” 때문에 막혔다.

이 경험을 통해,
CI/CD는 단순히 코드 문제가 아니라 인프라와 운영 전체가 연결된 작업이라는 걸 배웠다.

2. ‘권한’과 ‘경로’가 80%의 문제를 만든다는 사실

Runner 설치 중 가장 많이 본 에러는 이거였다:

status=203/EXEC
Permission denied

원인은 대부분 다음 두 가지였다.

권한(owner)이 맞지 않음
systemd가 실행하는 경로가 보안 정책에 걸림

특히 /home/* 경로 아래 스크립트를 systemd가 실행하는 건
SELinux 때문에 거의 막히는 수준이었다.

이 경험 이후,
“안 되면 권한 → 경로 → SELinux 순으로 체크한다”는 나만의 규칙이 생겼다.

3. config.sh와 svc.sh는 서로 다른 권한으로 실행해야 한다는 점

Runner 설치에서 가장 헷갈렸던 부분은 이거였다:

Runner 설정 → 일반 사용자 계정에서 실행해야 함
Runner 서비스 → root에서 실행해야 함

처음엔 root로 config.sh 를 실행해서 계속 에러가 났다.

Must not run with sudo

Runner가 실행되는 방식 자체가
“업무를 특정 사용자 계정으로 수행해야 하기 때문”이라는 걸 이해하고 나서야
전체 구조가 명확해졌다.

이걸 이해하고 나니 왜
/opt/actions-runner 에서
runner 사용자로 config.sh 를 실행하는 게 표준인지 이해할 수 있었다.

이번 Runner 설치 경험은 단순히 에러 해결을 넘어서
CI/CD와 서버 운영의 본질을 직접 체감한 과정이었다.

세밀하게 파고든 덕분에
지금은 Runner 설치와 운영에 자신이 생겼다.

앞으로 비슷한 환경 구성이나
실무에서 CI/CD 인프라를 맡게 될 때
이번 경험이 확실한 기반이 되어줄 것 같다.

[Spring Boot + JWT 인증 시스템 구축기(2)]

p퐝유p — Sun, 23 Nov 2025 17:37:11 +0900

User 엔티티 설계부터 Spring Security 기본 세팅, 그리고 삽질 기록까지

1편에서는 프로젝트 환경 세팅과 디렉토리 구조 설계까지 정리했다.

이번 2편에서는:

User 엔티티 설계
UserRepository 구현
Spring Security에서 유저 정보를 불러오기 위한 CustomUserDetailsService
JWT 토큰 발급/검증 역할의 JwtTokenProvider
매 요청마다 토큰을 검사하는 JwtAuthenticationFilter

까지 구현한 과정을 정리해본다.
중간에 실제로 겪었던 에러와 해결 과정도 같이 기록해놓았다.

★ 1. User 엔티티 설계

JWT 기반 인증에서 가장 중요한 것은 "누구를 인증할 것인가", 즉 User 엔티티다.

/**
 * User 엔티티
 *
 * - Spring Security + JWT 기반 인증에서 핵심이 되는 사용자 정보 테이블
 * - username(로그인 아이디), password(암호), role(권한) 필드를 가짐
 */
@Entity
@Table(name = "users")
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;   // MariaDB의 AUTO_INCREMENT 방식으로 PK 증가

    @Column(nullable = false, unique = true)
    private String username;    // 로그인 아이디 (이메일도 가능)

    @Column(nullable = false)
    private String password;    // 암호화된 비밀번호 저장 (평문X)

    @Column(nullable = false)
    private String role;        // 권한 (예: "USER", "ADMIN")
}

설계 포인트:

username 은 로그인 아이디로 사용되며 unique = true 적용
password 는 나중에 BCrypt로 암호화해서 저장
role 은 "USER", "ADMIN" 등 권한 구분용 문자열

★ 2. UserRepository – JPA로 사용자 조회

UserRepository는 Spring Data JPA를 사용해 간단하게 구현했다.

/**
 * UserRepository
 *
 * - User 엔티티에 대한 데이터 접근 계층
 * - 기본 CRUD는 JpaRepository가 제공
 * - username으로 유저를 조회하는 메서드만 추가로 정의
 */
 
public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByUsername(String username);
}

Spring Security에서 로그인 시, username 으로 유저를 찾기 위해
findByUsername 메서드를 필수로 넣어두었다.

★ 3. CustomUserDetailsService – Spring Security와 User 엔티티 연결

- Spring Security는 로그인할 때 내부적으로 UserDetailsService를 사용해서
"이 username으로 된 유저가 있는지"를 확인한다.

그래서 UserRepository와 User 엔티티를 Spring Security에 연결해 줄 서비스가 필요하다.

/**
 * CustomUserDetailsService
 *
 * - Spring Security가 인증을 수행할 때 호출되는 서비스
 * - username(로그인 아이디)을 기반으로 DB에서 실제 User를 조회한다.
 * - 조회된 User 엔티티를 Spring Security가 이해할 수 있는 UserDetails 형태로 변환해준다.
 */
@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    /**
     * 로그인 요청 시 실행되는 메서드
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("사용자를 찾을 수 없습니다: " + username));

        // Spring Security에서 사용하는 UserDetails 객체로 변환
        return withUsername(user.getUsername())
                .password(user.getPassword())
                .roles(user.getRole())
                .build();
    }
}

여기까지가 “DB에 저장된 User” → “Spring Security가 이해하는 UserDetails” 변환 과정이다.

★ 4. JwtTokenProvider – 토큰 생성 & 검증

JWT를 사용하려면:

로그인 성공 시 토큰을 발급할 수 있어야 하고
클라이언트가 보낸 토큰이 유효한지 검증할 수 있어야 한다.

이를 담당하는 클래스가 JwtTokenProvider이다.

/**
 * JwtTokenProvider
 *
 * - JWT Access Token을 생성하고 검증하는 역할을 담당하는 클래스.
 * - username과 roles 정보를 넣어 JWT를 생성한다.
 * - 요청이 들어왔을 때 토큰이 유효한지 검사한다.
 */
@Component
public class JwtTokenProvider {

    /**
     * application.yml에서 가져올 secret key
     * jwt.secret: "아주 긴 랜덤 문자열"
     */
    @Value("${jwt.secret}")
    private String secretKey;

    // Access Token 유효 시간: 1시간(3600000ms)
    private final long validityInMs = 1000L * 60 * 60;

    /**
     * secretKey를 기반으로 서명에 사용할 Key 객체 생성
     */
    private Key getSigningKey() {
        return Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * JWT 토큰 생성
     */
    public String createToken(String username, Collection<? extends GrantedAuthority> roles) {
        Claims claims = Jwts.claims().setSubject(username); // sub: username
        claims.put("roles", roles.stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));

        Date now = new Date();
        Date expire = new Date(now.getTime() + validityInMs); // 만료 시간 설정

        return Jwts.builder()
                .setClaims(claims)               // 사용자 정보
                .setIssuedAt(now)               // 발급 시간(iat)
                .setExpiration(expire)          // 만료 시간(exp)
                .signWith(getSigningKey(), SignatureAlgorithm.HS256) // 서명
                .compact();
    }

    /**
     * 토큰에서 username 꺼내기
     */
    public String getUsername(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(getSigningKey()) // 서명 검증
                .build()
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }

    /**
     * 토큰 유효성 검사
     */
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(getSigningKey())
                    .build()
                    .parseClaimsJws(token);

            return true; // 문제 없으면 유효한 토큰
        } catch (JwtException | IllegalArgumentException e) {
            return false; // 서명 오류, 만료 등 문제 발생
        }
    }
}

★ 5. JwtTokenProvider – 토큰 생성 & 검증

이제 토큰을 만들 수 있게 되었으니,
매 요청마다 HTTP 헤더에 담긴 토큰을 검증하는 필터가 필요하다.

/**
 * JwtAuthenticationFilter
 *
 * - API 요청이 들어올 때마다 실행되는 필터.
 * - Authorization 헤더에서 Bearer 토큰을 꺼내 JWT 유효성을 검증한다.
 * - 유효한 토큰이면 로그인 인증 완료된 사용자 상태(SecurityContext)에 저장.
 */
@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider jwtTokenProvider;
    private final UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain)
            throws ServletException, IOException {

        String header = request.getHeader("Authorization");

        // Authorization 헤더 존재 + Bearer 형태인지 확인
        if (header != null && header.startsWith("Bearer ")) {

            String token = header.substring(7); // "Bearer " 뒤의 문자열만 추출

            // JWT 토큰 검증
            if (jwtTokenProvider.validateToken(token)) {
                String username = jwtTokenProvider.getUsername(token);

                // username 기반 유저 정보 조회
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);

                // 인증 객체 생성 (Spring Security 내부 인증 객체)
                UsernamePasswordAuthenticationToken auth =
                        new UsernamePasswordAuthenticationToken(
                                userDetails,
                                null,
                                userDetails.getAuthorities()
                        );

                // SecurityContext에 저장 → 인증 완료 상태
                SecurityContextHolder.getContext().setAuthentication(auth);
            }
        }

        // 다음 필터 실행 (필수)
        filterChain.doFilter(request, response);
    }
}

[Spring Boot + JWT 인증 시스템 구축기(1)]

p퐝유p — Sun, 23 Nov 2025 17:11:54 +0900

이 글은 Spring Boot 3.x + Spring Security 6.x 기반으로

JWT 인증/인가 시스템을 직접 구축한 과정을 정리한 시리즈의 첫 번째 글.

JWT 기반 인증 구조는 실제 기업의 백엔드 서비스에서 매우 널리 사용되기 때문에,
이번 프로젝트를 통해 기본 인증 구조 + 보안 설계 + 실무 환경 구성까지 익히는 것이 목표다.

★ 개발 환경

해당 프로젝트는 아래 환경에서 진행했다.

IntelliJ IDEA Ultimate
Java 17
Spring Boot 3.5.x
Gradle (Kotlin DSL)
MariaDB
Hibernate + Spring Data JPA
Spring Security 6.x
Swagger(Springdoc OpenAPI 2.x)

Spring Boot 3.x 이후로 Security와 Swagger 문법이 많이 달라졌기 때문에
최신 버전에 맞춘 구성을 정리한다.

★ build.gradle.kts 설정

이 프로젝트의 핵심이 되는 의존성은 우선 아래와 같다.

하지만 추후 변경 가능성이 있다.

plugins {
    java
    id("org.springframework.boot") version "3.5.4"
    id("io.spring.dependency-management") version "1.1.7"
}

dependencies {
    // Web
    implementation("org.springframework.boot:spring-boot-starter-web")

    // Database
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.mariadb.jdbc:mariadb-java-client:3.3.3")

    // JWT
    implementation("io.jsonwebtoken:jjwt-api:0.11.5")
    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")
    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")

    // Lombok
    compileOnly("org.projectlombok:lombok")
    annotationProcessor("org.projectlombok:lombok")

    // Swagger(OpenAPI)
    implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.5.0")

    // Test
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

특히 Swagger 의존성은 Spring Boot 3.x 대응을 위해 반드시 2.x 버전을 사용해야 한다.

★ 4. application.yml 구성

외부 환경 변수를 .env 로 관리하고
MariaDB와 JPA 설정을 분리하여 유지보수를 쉽게 했다.

spring:
  application:
    name: 프로젝트

  config:
    import: optional:file:.env[.properties]

  datasource:
    url: ${DATABASE_URL}
    username: ${DATABASE_USERNAME}
    password: ${DATABASE_PASSWORD}
    driver-class-name: org.mariadb.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate.format_sql: true
    database-platform: org.hibernate.dialect.MariaDBDialect

server:
  port: 8080

★ 4. 디렉토리 구조 설계 (DDD Lite 방식)

우선 프로젝트에 대한 디렉토리 구조는 아래와 같다.

 ├── domain
 │    ├── user
 │    ├── board
 │    └── auth
 │
 ├── global
 │    ├── config
 │    ├── error
 │    └── security
 │
 └── mainApplication.java

✔ domain 계층

각 도메인을 user/board/auth 등으로 독립 구성하여
확장성과 유지보수성을 높인다는 장점이 있다.

entity
repository
service
controller

구조를 DDD-lite 패턴으로 자연스럽게 분리했다.

✔ global 계층

프로젝트 전역에서 사용하는 공통 기능을 포함한다.

security : JWT, SecurityConfig, 필터
config : SwaggerConfig, WebConfig
error : GlobalExceptionHandler 예정

이 구조는 실제 기업에서도 가장 많이 쓰는 설계 방식이라는 내용이 많이 보여 사용하기로 했다.

★ User 엔티티 설계

JWT 인증의 핵심은 "사용자 정보를 인증 토큰과 연결"하는 것이다.

@Entity
@Table(name = "users")
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;  // 로그인 아이디

    @Column(nullable = false)
    private String password;  // 암호화 저장

    @Column(nullable = false)
    private String role;      // USER / ADMIN 등 권한
}
\

설계 포인트:

username은 unique 조건
password는 BCrypt로 암호화
role은 문자열 기반(확장 쉬움)

★ 환경 설정 완료 여부 테스트

환경 설정이 정상이라면

./gradlew build
./gradlew bootRun

으로 서버가 정상적으로 실행된다.

[CI/CD 오류] failed to build: process "/bin/sh -c npm run build" did not complete successfully: exit code: 127

p퐝유p — Tue, 18 Nov 2025 22:36:49 +0900

프론트엔드 Dockerfile에서 다음과 같은 에러가 발생했다:

failed to build: process "/bin/sh -c npm run build" did not complete successfully: exit code: 127

이 에러는 보통 "명령어가 없음" 의 상황에서 발생한다

이번 케이스에서 문제의 핵심은 아래 Dockerfile의 내용에 있다.

FROM node:20-alpine AS build
ENV NODE_ENV=production     # ← 여기
WORKDIR /app

COPY package*.json ./
RUN npm ci                  # ← devDependencies 미설치

COPY . .
RUN npm run build           # ← react-scripts / vite / webpack 없음 → 127 에러

☆ 원인 분석

- NODE_ENV=production 때문에 devDependencies가 설치되지 않음

1) NODE_ENV=production란?

- NODE_ENV 는 Node.js에게 지금 어떤 환경인지 알려주는 변수이다.

"development" : 개발중

"production" : 배포용

"test" : 테스트환경

NODE_ENV=production 은 꼭 필요한 것만 설치해라 라고 이해하면된다.

이 변수로 npm은

dependencies 만 설치하고, devDependencies 는 건너뛴다.

devDependencies는 개발할때만 쓰는 도구다.

react-scripts, vite 등 빌드할때 (= npm build) 반드시 필요한 애들이 있어서

즉, devDependencies 가 없으면 빌드 자체가 불가능하다.

나의 Dockerfile에는 build 단계에서 아래와 같이 되어있었다.

ENV NODE_ENV=production
RUN npm ci

그래서

npm이 아~ 프로덕션이구나 하고 devDependencies 를 다 건너띄었다.

그래서 node_modules 안에 react-scripts / vite 같은 빌드 도구가 없었던 것이고,

아래서 npm run build 를 호출하려면 react-scripts 를 실행해야하는데

없어서 exit code 127이 발생했다.

☆ 해결 방법

NODE_ENV = production 을 build단계에서 제거하기

일반적인 Docker 멀티 스테이지 빌드에서는 이렇게 한다.

1) 빌드 단계

- devDependencies 포함 전체 설치

- 빌드 실행

2) Runtime(Ngix) 단계 (결과물을 실제로 서비스하는 단계)

- 빌드 결과물 (dist/build) 만 복사

- NODE_ENV = production 설정

즉, NODE_ENV = production 을 사용하지 않으면 된다.

그래서 아래와 같이 Dockerfile을 수정해줬다.

그냥 이건 내가 한 정리

1) 1단계 Build → 건물을 짓는 과정

- 공사 인력 (개발 도구) 필요함

- 여러 장비( devDependencies ) 필요

- 그러니 난장판

2) 2단계 Runtime → 완성된 건물에서 실제로 운영하는 단계

- 손님 (유저) 에게 보여줄 건물만 있으면 되지

- 공사 장비(node_modules) 따위 필요없어

- 깔끔쓰하고 최적화된 상태여야하니 NODE_ENV = production 로 가즈아~~~~~!!!!

☆ 오늘의 교훈

Runtime(Nginx) 단계에서는 "완성된 dist/build 파일만" 사용해서 실제 서비스를 하는 단계이며,

이때, NODE_ENV = production를 설정해 프로덕션 최적화를 적용한다!!

[CI/CD 오류] Vue + GitHub Actions: buildx failed with /app/build not found

p퐝유p — Tue, 18 Nov 2025 22:01:24 +0900

☆ 에러 메시지

buildx failed with: ERROR: failed to build: failed to solve:
failed to compute cache key: failed to calculate checksum of ref
g6jv2ev09dowgkglksu1rd348s::rwtyh1walc64d4lp2i4omzzb9a: "/app/build": not found

☆ 문제 상황

- Github Actions에서 frontend Dockerfile 빌드 과정에서 실패

- 캐시 계산 (cache key) 단계에서 /app/build 디렉토리를 찾을 수 없다는 에러 발생

- frontend 이미지가 실패하자 backend 이미지 빌드도 중단됨

☆ 원인 분석

이 에러는 Dockerfile이 /app/build 디렉토리를 COPY 하려하는데

빌드 단계에서 그 디렉토리가 아예 생성되지 않아 발생함

즉,

RUN npm ci
RUN npm run build

이 단계에서 build 폴더가 생성되지 않았음.

왜 안만들어졌을까?

☆ 원인 분석

1.프론트가 React 기준 Dockerfile이었는데 실제 프로젝트는 Vue였음

- 기존에는 React 를 사용하기로 했으나 Vue로 변경이 되었다.

하지만 나는 라이브러리 변경 후, 로컬에서 오 잘되는구나 하고 이 GitActions 를 신경쓰지 못하고

왜 안되지 만 바보같이 반복하고 있었다.

2. Vue의 기본 결과물은 /dist 로 생성이 된다. (React는 /build)

그래서 Dockerfile에서 이렇게 되어 있었다면:

COPY --from=build /app/build/ /usr/share/nginx/html/

Vue에는 /build 폴더 자체가 생기니 당연히 에러가 발생할 수 밖에...

☆ 해결 방법

Dockerfile을 Vue 기준으로 수정해야 함.

프론트엔드 Dockerfile 수정 전 (문제 버전)

COPY --from=build /app/build/ /usr/share/nginx/html/

프론트엔드 Dockerfile 수정 후 (문제 버전)

COPY --from=build /app/dist/ /usr/share/nginx/html/

Vue + Vite 프로젝트는 항상 /dist 폴더가 최종 산출물임.

☆ 결론

- React 용 Dockerfile을 Vue 프로젝트에 사용해서 생긴 문제
- Vue의 빌드 산출물은 /dist
- Dockerfile COPY 경로 수정으로 해결됨

추가 오류: Backend Docker 빌드 실패 (gradlew bootJar exit code 1)

프론트엔드 문제를 해결하자 이번에는 백엔드 이미지 빌드 단계에서 실패하는 문제가 발생했다.

GitHub Actions 로그 메시지는 다음과 같다:

buildx failed with: ERROR: failed to build: failed to solve:
process "/bin/sh -c ./gradlew bootJar --no-daemon --stacktrace"
did not complete successfully: exit code: 1

☆ 오류 추적 방법

1) Annotations에는 단순히 “exit code: 1”만 보여서 정보가 부족

→ 그래서 실제 빌드 로그 전체를 스크롤하여 원인을 찾아야 했다.

2) buildx 로그 중 What went wrong: 부분까지 내려감

- Gradle이 어떤 Task를 실행하는 중 구성(Configuration) 오류가 발생했을 때 출력되는 표준 오류 섹션

Gradle이 Task를 실행하기전

'필요한 파일,디렉토리가 존재하는지', 'Task 속성이 올바르게 설정되었는지' 등을 검사하는 단계에서

문제를 발견했을 때 나타나는 에러

거기서 다음 메시지를 발견:

What went wrong:
Some problems were found with the configuration of task ':npmBuild'
In plugin 'com.github.node-gradle.node' type 'NpmTask' property '$1' specifies directory '/frontend/src' which doesn’t exist.
…
Specifies file '/frontend/package.json' which doesn't exist.
Specifies file '/frontend/package-lock.json' which doesn't exist.

즉, 백엔드 빌드 중인데 프론트엔드 관련 파일을 찾으려 하면서 실패하고 있었음.

☆ 원인 분석

원인 1) backend/build.gradle 안에 프론트 자동 빌드를 위한 NpmTask가 들어있었음

내 backend 빌드 파일에는 아래처럼 설정이 존재했다.

inputs.dir("${project.rootDir}/../frontend/src")
inputs.file("${project.rootDir}/../frontend/package.json")
inputs.file("${project.rootDir}/../frontend/package-lock.json")

이 작업이 실행되면 backend Dockerfile에서 다음이 실행됨

./gradlew bootJar

그러면 Gradle은 backend 의 모든 task 를 포함하여

npmBuild task 도 함께 실행하려고 시도한다.

하지만,

현재 컨테이너는 backend, frontend 분리하여 총 2개로 운영하기때문에 다음 경로를 찾지 못한다.

/frontend/src

/frontend/package.json

/fronted/package-lock.json

결과적으로 npmBuild task 가 실패 → bootJar 전체 실패 → Docker 빌드 실패

☆ 해결 방법

- backend에서 npmBuild task 제거

backend/build.gradle.kts에서 다음 블록을 아예 삭제:

val npmBuild by tasks.registering(…){
    …
}
val copyFrontend by tasks.registering(Copy::class) {
    dependsOn(npmBuild)
    …
}
tasks.processResources {
    dependsOn(copyFrontend)
}

이렇게 되면 backend는 온전히 SpringBoot만 빌드가 되고 frontend는 GitHubActions에서 별도로 빌드하여 충돌하지 않는다.

GitHub Actions CI/CD 환경에서 DB 연결 오류 해결기

p퐝유p — Wed, 8 Oct 2025 00:02:50 +0900

Spring Boot를 깃으로 형상관리할 때,

DB, 토큰 등 중요 정보 관리 방법 중 하나는 .env 파일에 환경 변수로 관리하는 방법이다.

.env 파일은

.gitignore 파일에 커밋이 되지 않도록 설정이 되면 로컬에서만 실행이 되는 것이다.

.env 자체가 git 에 올라가지 않는데

gitAction으로 Docker 에 배포가 되어 DB 접속 정보는 어떻게 불러오느냐가 문제였다.

우선 .env 파일을 올리지 않고 백엔드 도커를 배포했더니 DB 커넥션이 되지 않은 상태에서 방법을 찾아봤다.

문제 상황

- GitHub Actions로 CI/CD를 돌리는데, 애플리케이션에서 DB 접속 정보를 필요로 함

- 중요한 정보(DB URL, 계정, 비밀번호)는 코드에 직접 쓰면 안 됨 → secrets 활용

해결 방법

- secrets 값을 .env 파일로 생성해서 docker-compose가 읽도록 함

- GitHub Actions에서 job step으로 .backend.env 파일을 만듦

docker-compose.yml 파일에 env_file 경로 추가하기

루트 최상단 파일에 .backed.env 파일 명을 읽어
docker-compose가 실행되어 DB 접속 정보를 읽어 DB 접속이 될 수 있도록 해당 로직을 추가한다.

GitHub Actions에서 job step으로 .backend.env 파일 생성 로직 추가

- name: Create .backend.env next to compose
  run: |
    set -euo pipefail
    cd "$GITHUB_WORKSPACE"
    cat > .backend.env <<'EOF'
    DATABASE_URL=${{ secrets.DATABASE_URL }}
    DATABASE_USERNAME=${{ secrets.DATABASE_USERNAME }}
    DATABASE_PASSWORD=${{ secrets.DATABASE_PASSWORD }}
    SPRING_JACKSON_TIME_ZONE=Asia/Seoul
    EOF
    ls -al .backend.env docker-compose.yml

1. set -euo pipefail : 스크립트에서 실수를 최대한 빨리 잡고, 조용히 실패하지 않게 하는 안전장치

set -e : 스크립트 실행 중 **에러(exit code 0이 아닌 경우)**가 발생하면 즉시 종료.
set -u : 정의되지 않은 변수를 참조하려 하면 에러 발생시키고 종료.
set -o pipefail
파이프(|)로 연결된 명령어 실행 시, 마지막 명령어가 아니라 첫 번째 실패한 명령어의 exit code를 반환.
없으면 마지막 명령어만 성공하면 전체 성공으로 간주됨 → 중간 실패를 놓칠 수 있음.

2. cd "$GITHUB_WORKSPACE"

GitHub Actions 러너 환경에서 작업 디렉토리를 이동
$GITHUB_WORKSPACE

- GitHub Actions가 실행될 때 자동으로 설정되는 환경 변수.

- 의미: 현재 리포지토리 코드가 체크아웃(clone)된 경로.

- 위치 : /home/devuser/actions-runner/_work/<리포지토리명>/<리포지토리명>

3. cat > .backend.env <<'EOF' ... EOF

GitHub Secrets 값들을 환경파일로 저장

4. ls -al .backend.env docker-compose.yml

디버깅용(파일이 제대로 생성됐는지 확인)

GitHub Actions에서 Actions secrets and variables 생성하기

아래의 화면 경로로 들어가
화면 경로 : 깃헙 repository > settings > security > Secrets and variables > actions

CI-CD.yml파일에서 입력한 변수명으로 DB 정보를 저장한다.

GitHub Actions 실행하기

DB 연결 실패 1 - Host 허용 문제

- Error: 1130-HY000: Host '172.18.0.3' is not allowed to connect to this MySQL server

원인

DB가 도커 브리지 대역(172.18.0.*) 에서의 접속을 허용하지 않음.

해결 방법
DB의 계정을 지정하여 도커 브리지 대역에 접속을 허용하도록 권한을 부여하는 쿼리를 실행한다.

GRANT ALL PRIVILEGES ON [DB명].* TO '[계정명]'@'172.18.0.%' IDENTIFIED BY '[패스워드]';

DB 연결 실패 2 - RSA 공개키/인증 방식

- RSA public key is not available client side

원인

서버 인증 플러그인과 JDBC가 충돌.

해결 방법

JDBC URL에 ?allowPublicKeyRetrieval=true&useSSL=false 추가

최종검증

아래의 명령어로 컨테이너 네트워크에서 직접 연결을 한다.

임시로 연결하는 것이라 네트워크 명은 testnet 이런식으로 명명해도 된다.

docker run --rm -it --network [네트워크명] mariadb:10.6 \
  mysql -h 192.168.0.201 -u <정확한계정> -p [데이터베이스명] -e "SELECT 1"

SELECT 1 이 확인되면 연결완료!

브릿지 서버도 올라가는 순간 찍어놓았던 아래 데이터베이스 연결여부에 대한 디버깅용 코드도 확인이 되었다.

이로써 데이터베이스 연결 성공

헷갈리는 배열 정리해보기

p퐝유p — Sat, 28 Jun 2025 20:39:42 +0900

★ LinkedList와 List 차이점 – 언제 뭘 써야 할까?

Java를 공부하다 보면 List, ArrayList, LinkedList 같은 자료구조를 자주 만나게 된다. 이름은 비슷한데, 정확히 무슨 차이가 있는지 헷갈리는 경우가 많다. 이번 글에서는 각각이 어떤 역할을 하는지, 그리고 어떤 상황에서 어떤 걸 쓰는 게 좋은지 정리해보려고 한다.

☆ List는 인터페이스

먼저 List는 클래스가 아니라 인터페이스다. 쉽게 말하면, 어떤 기능을 제공할지 약속만 해놓은 틀 같은 거다. 실제로 데이터를 저장하거나 조작하는 일은 ArrayList, LinkedList 같은 구현 클래스가 담당한다.

★ ArrayList와 LinkedList는 구현 방식이 다르다

둘 다 List 인터페이스를 구현하고 있고, 데이터를 순서대로 저장할 수 있다. 하지만 내부 구조와 동작 방식에는 큰 차이가 있다.

✅ ArrayList – 배열 기반

내부적으로 배열을 사용해서 데이터를 저장한다.
인덱스를 이용한 접근이 빠르다. (get(index) 속도가 빠름)
중간에 삽입하거나 삭제할 때는 느리다. (요소들을 옮겨야 해서 시간이 걸림)

✅ LinkedList – 노드 기반

노드들이 서로 연결되어 있는 구조다. (이중 연결 리스트)
중간에 데이터를 삽입하거나 삭제할 때 빠르다. (노드 연결만 바꾸면 됨)
인덱스를 통한 접근은 느리다. (앞에서부터 순차적으로 찾아야 하기 때문)

★ 언제 어떤 걸 써야 할까?

상황추천 자료구조

인덱스로 자주 접근할 경우	ArrayList
중간 삽입/삭제가 자주 일어나는 경우	LinkedList
데이터 크기가 자주 바뀌지 않는 경우	ArrayList
큐(Queue)처럼 앞뒤로 데이터를 넣고 빼야 할 경우	LinkedList

예시 – 큐처럼 사용하기

Queue<String> queue = new LinkedList<>(); queue.offer("apple"); queue.poll(); // 가장 앞의 요소 제거

대부분의 경우에는 ArrayList를 사용하는 게 더 효율적이다.
삽입과 삭제가 빈번한 경우에는 LinkedList를 고려해볼 만하다.
항상 List로 선언해두고, 상황에 따라 구현체만 바꾸는 방식이 가장 유연하다.

★ Java에서 ArrayList<String> vs String[] 차이점 정리

1. 기본 개념부터 다름

자료구조	배열 (Array)	컬렉션 클래스
크기	고정됨 (한 번 정하면 변경 불가)	동적으로 크기 조절 가능
선언	String[] arr = new String[3];	ArrayList<String> list = new ArrayList<>();
기능	단순 저장 및 인덱스로 접근	추가, 삭제, 검색 등 다양한 메서드 제공
속도	조금 더 빠름 (가볍고 단순함)	상대적으로 느릴 수 있음 (기능 많음)

2. 크기 유연성

String[]은 크기를 한 번 정하면 변경이 안 된다.
String[] arr = new String[3]; arr[0] = "A"; arr[1] = "B"; arr[2] = "C"; // arr[3] = "D"; // 에러 발생
ArrayList는 계속 add()로 요소를 추가할 수 있다.
ArrayList<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C"); list.add("D"); // 문제 없음

3. 사용 가능한 메서드 차이

배열은 거의 기능이 없다. 그냥 인덱스로 접근하고, 길이 구하는 정도 (arr.length)
ArrayList는 여러 기능이 포함돼 있다.
list.add("apple"); list.remove("apple"); list.contains("banana"); list.size(); list.get(2);

4. 제네릭 지원 (<>)

ArrayList<String>처럼 제네릭 타입을 쓸 수 있어서 타입 안정성이 좋다.
배열은 타입을 정하긴 하지만, 복잡한 구조에서는 제네릭처럼 쓸 수 없다.

5. 사용 예와 추천 상황

상황추천 자료구조

크기가 고정된 단순한 데이터	String[]
데이터 추가/삭제가 자주 필요할 때	ArrayList<String>
반복문에서 빠르게 처리해야 할 경우	String[] (조금 더 빠름)
기능이 다양한 조작이 필요한 경우	ArrayList<String>

배열(String[])은 가볍고 빠르지만, 기능이 제한적이고 크기가 고정되어 있다.
ArrayList<String>는 유연하고 메서드가 많지만, 상대적으로 성능은 조금 떨어질 수 있다.
단순하고 고정된 데이터 구조가 필요하다면 배열을 쓰면 된다.
하지만 대부분의 실무에서는 데이터가 계속 추가되고, 삭제되기도 하고, 검색이나 정렬 같은 작업도 해야 하기 때문에 ArrayList를 더 자주 쓰게 된다.

이때까지 회피해왔던 시간 복잡도 알아보기

p퐝유p — Sat, 14 Jun 2025 22:45:58 +0900

나는 알고리즘 문제를 풀거나, 답을 구하기 위해 다른 천재분들이 풀어왔던 알고리즘 관련 글을 볼때

시간 복잡도와 공간 복잡도를 애써 무시, 회피해왔다.

하지만 회피도 이제 한계가 왔다.

코드를 짜거나 진짜 뭔가 개발자 흉내를 내기 위해서라도 이러면 속도가 빠를거야, 효율적인 코드야 이런 근거 없는 생각보다

"시간 복잡도" / "공간 복잡도" 등을 고려하며 근거 있는 코드를 짜기 위해 이친구들과 친해지기로 마음을 먹어 글을 써본다.

★ 시간 복잡도

- 시간 복잡도란 "입력값에 비해 얼마나 일을 수행해야 하는가?" 를 의미한다.

입력값과 문제를 해결하는데 걸리는 시간과의 상관관계를 말한다.

만약, 입력 값이 2배로 늘어났을 때,

문제를 해결하는데 시간은 몇배로 늘어나는지를 보는 것을 말한다.

시간 복잡도를 고려한 알고리즘은 입력 값이 늘어나도 걸리는 시간이 덜 늘어나는 알고리즘이 좋은 것이라 할 수 있다.

☆ 최댓값 찾기 알고리즘의 시간 복잡도 판단해보기

첫번째 방법

def find_max_num(array):
    for number in array: # array 의 길이만큼 아래 연산이 실행
        is_max_num = True # 최댓값 변수 (flag)
        for compare_number in array: # array 의 길이만큼 아래 연산이 실행
            if number < compare_number: # 비교 연산 1번 실행
                is_max_num = False # 대입 연산 1번 실행
        if is_max_num:# 비교 연산 1번 실행
            return number

print("정답 = 6 / 현재 풀이 값 = ", find_max_num([3, 5, 6, 1, 2, 4]))
print("정답 = 6 / 현재 풀이 값 = ", find_max_num([6, 6, 6]))
print("정답 = 1888 / 현재 풀이 값 = ", find_max_num([6, 9, 2, 7, 1888]))

이 해결 방법은 각 숫자마다 모든 다른 숫자와 비교해서 최대값인지 확인하는 코드이다.

만약 다른 모든 값보다 크다면 반복문을 중단한다.

바로, 각 줄이 실행되는 걸 1번의 연산이 된다고 생각하고

아래와 같이 계산하여 위의 함수는 2* N^2 + N 만큼의 시간이 걸린 것이라고 알 수 있다.

1. array의 길이 x array의 길이 x ( 비교 연산 1번 + 대입 연산 1번) → N x N x 2

(여기서 array(입력값)의 길이는 보통 N이라고 표현한다.)

2. array의 길이 x 비교 연산 1번 → N

두번째 방법

def find_max_num(array):
    max_num = array[0] # 연산 1번 실행
    for number in array:  # array의 길이 만큼 아래 연산이 실행
        if number > max_num: # 비교 연산 1번 실행
            max_num = number # 대입 연산 1번 실행

    return max_num


print("정답 = 6 / 현재 풀이 값 = ", find_max_num([3, 5, 6, 1, 2, 4]))
print("정답 = 6 / 현재 풀이 값 = ", find_max_num([6, 6, 6]))
print("정답 = 1888 / 현재 풀이 값 = ", find_max_num([6, 9, 2, 7, 1888]))

아래와 같이 계산하여 1 + 2 x N 만큼의 시간이 걸린 것이라고 할 수 있다.

max_num 대입 연산 1번
array의 길이 x (비교 연산 1번 + 대입 연산 1번)

★ 비교하기

두 함수를 비교해보면 두번째 함수의 1 + 2 x N 가 더 효율적이라고 볼 수 있다.

☆ 2N^2 + N vs 2N+1

N의 길이	∑ 2N^2 + N	∑ 2N+1
1	3	3
10	210	21
100	20100	201
1000	2001000	2001
10000	200010000	20001

- 위의 표를 보면,

2N^2 + N 의 연산량이 나온 첫번째 풀이 방법은 N^2 만큼의 연산량이 필요하고,

2N+1 의 연산량이 나온 두번째 풀이 방법은 N 만큼의 연산량이 필요하다.

이렇게 알아봄으로써

아, 시간복잡도를 고려했을때 좀 코드를 고쳐야겠는데??

시간 복잡도를 고려하지 않고 코드를 짰네 바보같아

이렇게 말할 수 있도록 더욱 성장하는 사람이 되고 싶다.

[DFS]백준 11724번 - 연결 요소의 개수_Java

p퐝유p — Sun, 25 May 2025 22:28:26 +0900

연결된 요소의 개수를 구하는 문제는 "연결" 이라는 키워드로 봐서 DFS 혹은 BFS 유형의 문제이다.

서로 연결되었다는 정보를 2차원 배열 boolean 형태로 표현하였다.

이미 방문한 지점을 다시 방문하지 않으려면 1차원 배열 boolean 형태로 표현하였다.

연결된 지점을 찾는 것 이기 때문에 정점의 개수만큼 DFS를 반복했다.

package java_dfs.test;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.StringTokenizer;

class ConnetcedComponent {

final static int MAX = 1000 + 10 ; // 최댓값은 여유있게 10정도 늘려주자

static boolean graph[][]; // 2차원 배열의 그래프 생성

static boolean visited[]; // 방문여부 배열

static int N,M; // N : 정점의 개수 , M: 간선의 개수

static int answer; // 연결요소 개수

static void dfs(int index){

visited[index] = true ; // 방문여부 true로 변경

for(int i=1; i<=M; i++){ // 간선 개수 만큼 반복

if(visited[i] == false && graph[index][i]){ // 다음 방문 예정인 요소가 fasle상태이고, idx번/i번째 요소가 연결되어있어야함

dfs(i);

}

public static void main(String[] args) throws IOException{

//0.입력 초기화

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

StringTokenizer st = new StringTokenizer(br.readLine());

N = Integer.parseInt(st.nextToken()); //N : 정점의 개수

M = Integer.parseInt(st.nextToken()); //N: 노드의 개수

// 1. 그래프의 연결정보 채우기

graph = new boolean[MAX][MAX]; // 그래프 연결 정보 채우기

visited = new boolean[MAX]; // 방문여부 배열 채우기

for (int i=0; i<M; i++){ // 정점의 개수

st = new StringTokenizer(br.readLine());

int u = Integer.parseInt(st.nextToken()); // 양끝점 중 하나

int v = Integer.parseInt(st.nextToken()); // 양끝점 중 하나

// 재방문을 막기 위해 양끝점 둘다 true로 채워줘야함

graph[u][v] = true;

graph[v][u] = true;

}

//2. 재귀 함수 호출

for (int i =1; i<=M; i++){ // 간선의 개수 만큼

if (!visited[i]){ // 방문을 하지 않았다면

dfs(i); // 재귀함수 호출

answer ++; // 연결요소 개수 카운트 증가

}

// 3. 출력

bw.write(String.valueOf(answer));

bw.close();

br.close();

}

★ 결과

[알고리즘] DFS 재귀함수 - 타겟넘버문제 풀이

p퐝유p — Sat, 17 May 2025 21:20:18 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/43165

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

DFS (깊이 우선 탐색, Depth-First Search)

DFS는 그래프나 트리에서 노드를 깊이 우선으로 ㅊ방문하는 탐색 알고리즘입니다. 즉, 가장 깊은 노드까지 탐색한 후, 더 이상 깊이 갈 수 없으면 다시 이전 노드로 돌아와 다른 경로를 탐색하는 방식입니다.

DFS의 특징

완전탐색 (Brute Force) 가능
- 모든 가능한 경로를 탐색하여 최적의 해를 찾는 데 유용합니다.
재귀적 구조
- 일반적으로 재귀나 스택을 이용하여 구현합니다.
메모리 효율성
- BFS보다 메모리를 적게 사용하는 경우가 많습니다.
백트래킹과의 결합
- 특정 조건에서 탐색을 중단하고 이전 상태로 돌아가는 백트래킹과 함께 자주 사용됩니다.

DFS의 기본 동작 원리

시작 노드에서 출발
깊이 있는 노드로 최대한 이동
더 이상 갈 곳이 없으면 이전 노드로 돌아옴 (백트래킹)
모든 노드를 방문할 때까지 반복

class Solution {
    int answer;  // 최종 정답을 저장할 변수

    public int solution(int[] numbers, int target) {
        answer = 0;  // 초기화 (각 테스트 케이스마다 초기화 필요)
        dfs(0, 0, numbers, target);  // DFS 탐색 시작 (시작 인덱스 0, 초기 합 0)
        return answer;  // 최종 정답 반환
    }

    void dfs(int n, int sum, int[] numbers, int target) {
        // 모든 숫자를 다 사용한 경우 (트리의 리프 노드에 도달)
        if (n == numbers.length) {
            // 목표 값과 현재 합이 일치하는지 확인
            if (sum == target) 
                answer++;  // 목표 값 달성 시 정답 카운트 증가
            return;  // 종료 (리프 노드 도달 시 리턴)
        }

        // 현재 숫자를 더한 경우
        dfs(n + 1, sum + numbers[n], numbers, target);
        
        // 현재 숫자를 뺀 경우
        dfs(n + 1, sum - numbers[n], numbers, target);
    }
}

[Docker] 3. 도커 기본 명령어 익히기

p퐝유p — Mon, 5 May 2025 02:36:42 +0900

★ 이미지 다운로드

- 이미지명만 입력해도 최신버전(latest)으로 다운된다.

# docker pull 이미지명
$ docker pull nginx # docker pull nginx:latest와 동일하게 작동

이미지를 다운로드 할 때 Dockerhub이라는 곳에서 이미지를 다운 받는다.

Dockerhub도 마찬가지로 사람들이 올려놓은 이미지들이 저장되어 있어서 pull을 통해 다운받아서 사용할 수 있다.

Dockerhub은 Github처럼 이미지를 저장 및 다운받을 수 있는 저장소 역할을 하고 있다.

[특정 버전 이미지 다운로드]

# docker pull 이미지명:태그명
$ docker pull nginx:stable-perl

특정 버전을 나타내는 이름을 태그명이라고 한다. 태그명은 dockerhub에서 확인할 수 있다.

★ 이미지 조회

- 다운받은 모든 이미지 조회

docker image ls

항목 명 의미

REPOSITORY	이미지의 이름
TAG	이미지의 버전 또는 라벨. 기본값은 latest이며, 직접 태그를 만들 수도 있다.
IMAGE ID	해당 이미지의 고유 식별자입니 컨테이너를 만들거나 삭제할 때 사용 가능
CREATED	이미지가 만들어진 시점. docker hub 에 만들어진 시점을 의미
SIZE	이미지의 용량 . 디스크에서 이 이미지가 차지하는 공간을 나타냄.

★ 이미지 삭제

특정 이미지 삭제할 때,

$ docker image rm [이미지 ID 또는 이미지명]

rm : remove의 약자
이미지 ID를 입력할 때 전체 ID를 다 입력하지 않고 ID의 일부만 입력해도 된다. (단, ID의 일부만 입력했을 때, 입력한 ID의 일부를 가진 이미지가 단 1개여야 한다.)
컨테이너에서 사용하고 있지 않은 이미지만 삭제가 가능하다.

중지된 컨테이너에서 사용하고 있는 이미지 강제 삭제할 때,

$ docker image rm -f [이미지 ID 또는 이미지명]

실행 중인 컨테이너에서 사용하고 있는 이미지는 강제로 삭제할 수 없다.

전체 이미지 삭제할 때,

# 컨테이너에서 사용하고 있지 않은 이미지만 전체 삭제
$ docker image rm $(docker images -q)

# 컨테이너에서 사용하고 있는 이미지를 포함해서 전체 이미지 삭제
$ docker image rm -f $(docker images -q)

docker images -q : 시스템에 있는 모든 이미지의 ID를 반환한다.

여기서 -q 옵션은 quite를 의미하며, 상세 정보 대신에 각 이미지의 고유한 ID만 표시하도록 지시한다.

★ 컨테이너 생성

이미지를 바탕으로 컨테이너를 생성한다. 이 때, 컨테이너를 실행시키지는 않는다.

(컨테이너를 실행하지 않고 생성만 하는 경우가 잘 없어서, 이 명령어는 잘 사용하지 않는다.)

→ 로컬 환경에 다운받은 이미지가 없다면 Dockerhub으로부터 이미지를 다운(docker pull)받아서 컨테이너를 생성한다.

# docker create 이미지명[:태그명]
$ docker create nginx

$ docker ps -a # 모든 컨테이너 조회

★ 컨테이너 실행

정지되어 있는 컨테이너를 실행시킨다.

# docker start 컨테이너명[또는 컨테이너 ID]
$ docker start 컨테이너명[또는 컨테이너 ID]

$ docker ps # 실행중인 컨테이너 조회

# Nginx 컨테이너 중단 후 삭제하기
$ docker ps # 실행 중인 컨테이너 조회
$ docker stop {nginx를 실행시킨 Contnainer ID} # 컨테이너 중단
$ docker rm {nginx를 실행시킨 Contnainer ID} # 컨테이너 삭제
$ docker image rm nginx # Nginx 이미지 삭제

★ 컨테이너 생성 + 실행

이미지를 바탕으로 컨테이너를 생성한 뒤, 컨테이너를 실행까지 시킨다.

(처음에 이미지를 바탕으로 컨테이너를 실행시키고 싶을 때, 이 명령어를 자주 사용한다고 한다.)

▶ 로컬 환경에 다운받은 이미지가 없다면 Dockerhub으로부터 이미지를 다운(docker pull)받아서 실행시킨다.

▶ Dockerhub으로부터 새롭게 갱신된 이미지를 다운 받고 싶다면 docker pull 명령어를 활용해야 한다.

# docker run 이미지명[:태그명]
$ docker run nginx # 포그라운드에서 실행 (추가적인 명령어 조작을 할 수가 없음)

# Ctrl + C로 종료할 수 있음

※ 포그라운드 (foreground) vs 백그라운드 (background) 차이

포그라운드 : 내가 실행시킨 프로그램의 내용이 화면에서 실행되고 출력되는 상태를 뜻한다.

그러다보니 포그라운드 상태에서는 다른 프로그램을 조작 불가.

백그라운드 : 내가 실행시킨 프로그램이 컴퓨터 내부적으로 실행되는 상태를 의미.

그래서 프로그램이 어떻게 실행되고 있는 지에 대한 정보를 화면에서 확인 불가.

이런 특성 때문에 다른 명령어를 추가로 입력할 수도 있고, 새로운 프로그램을 조작할 수도 있다.

☆ 컨테이너에 이름 붙여서 생성 및 실행하기

# docker run -d --name [컨테이너 이름] 이미지명[:태그명]
$ docker run -d --name my-web-server nginx

# Nginx 컨테이너 중단 후 삭제하기
$ docker ps # 실행 중인 컨테이너 조회
$ docker stop {nginx를 실행시킨 Contnainer ID} # 컨테이너 중단
$ docker rm {nginx를 실행시킨 Contnainer ID} # 컨테이너 삭제
$ docker image rm nginx # Nginx 이미지 삭제

☆ 호스트의 포트와 컨테이너의 포트를 연결하기

# docker run -d -p [호스트 포트]:[컨테이너 포트] 이미지명[:태그명]
$ docker run -d -p 4000:80 nginx

연결 확인 완료!

docker run -p 4000:80 라고 명령어를 입력하게 되면,

도커를 실행하는 호스트의 4000번 포트를 컨테이너의 80번 포트로 연결하도록 설정한다.

★ 컨테이너 조회

☆ 실행 중인 컨테이너들만 조회

$ docker ps

ps : process status의 약자

☆ 모든 컨테이너 조회 (작동 중인 컨테이너 + 작동을 멈춘 컨테이너)

 docker ps -a

-a : all의 약자

★ 컨테이너 중지

$ docker stop 컨테이너명[또는 컨테이너 ID]
$ docker kill 컨테이너명[또는 컨테이너 ID]

집에 있는 컴퓨터로 비유하자면 stop은 시스템 종료 버튼을 통해 정상적으로 컴퓨터를 종료하는 걸 의미

kill은 본체 버튼을 눌러 무식하게 종료하는 걸 의미

★ 컨테이너 삭제

// 중지되어 있는 특정 컨테이너 삭제
$ docker rm 컨테이너명[또는 컨테이너 ID] 

//실행되고 있는 특정 컨테이너 삭제
 docker rm -f 컨테이너명[또는 컨테이너 ID]
 
 //중지되어 있는 모든 컨테이너 삭제
 $ docker rm $(docker ps -qa)
 
 //실행되고 있는 모든 컨테이너 삭제
 $ docker rm -f $(docker ps -qa)

★ 컨테이너 로그 조회

컨테이너를 실행시키고나서 실행시킨 컨테이너가 잘 실행되고 있는지,

에러가 발생한 건 아닌 지 로그를 확인할 수 있어야 한다.

디버깅할 때 필수로 확인해야 하는 게 로그다.

# 특정 컨테이너의 모든 로그 조회
$ docker run -d nginx
$ docker logs [nginx가 실행되고 있는 컨테이너 ID]

# 최근 로그 10줄만 조회
# dokcer logs --tail [로그 끝부터 표시할 줄 수] [컨테이너 ID 또는 컨테이너명]
$ dokcer logs --tail 10 [컨테이너 ID 또는 컨테이너명]

#기존 로그 조회 + 생성되는 로그를 실시간으로 보고 싶은 경우
# Nginx의 컨테이너에 실시간으로 쌓이는 로그 확인하기
$ docker run -d -p 80:80 nginx
$ docker logs -f

#기존 로그는 조회하지 않기 + 생성되는 로그를 실시간으로 보고 싶은 경우
docker logs --tail 0 -f [컨테이너 ID 또는 컨테이너명]

★ 실행중인 컨테이너 내부에 접속하기 (exec -it)

☆ 실행 중인 컨테이너 내부에 접속하기

# docker exec -it 컨테이너명[또는 컨테이너 ID] bash

$ docker run -d nginx
$ docker exec -it [Nginx가 실행되고 있는 컨테이너 ID] bash
$ ls # 컨테이너 내부 파일 조회
$ cd /etc/nginx 
$ cat nginx.conf

→ 컨테이너 내부에서 나오려면 Ctrl + D 또는 exit을 입력하면 된다

→ bash : 쉘(Shell)의 일

→ -it : -it옵션을 사용해야 명령어를 입력하고 결과를 확인할 수 있다. -it옵션을 적지 않으면 명령어를 1번만 실행시키고 종료되어 버린다. 즉, -it 옵션을 적어야 계속해서 명령어를 입력할 수 있다.

★ Docker 로 Redis 실행시켜보기

☆ Redis 이미지를 바탕으로 컨테이너 실행시키기

● 로컬 환경에 redis 이미지가 없으면 Dockerhub으로부터 Redis 이미지를 자동으로 다운받는다.

$ docker run -d -p 6379:6379 redis

☆ 다운로드 된 이미지 확인하기

$ docker image ls

☆ 컨테이너가 잘 실행되고 있는 지 체크

$ docker ps

☆ 컨테이너 실행시킬 때 에러 없이 잘 실행됐는 지 로그 체크

$ docker logs [컨테이너 ID 또는 컨테이너명]

☆ Redis 컨테이너에 접속

$ docker exec -it [컨테이너 ID 또는 컨테이너명] bash

☆ 컨테이너에서 redis 사용해보기

$ redis-cli

127.0.0.1:6379> set 1 jscode
127.0.0.1:6379> get 1

※ 참고 강의

비전공자도 이해할 수 있는 Docker 입문/실전 강의 | JSCODE 박재성 - 인프런

JSCODE 박재성 | , 에라이, 못 해먹겠네!비전공자로 개발을 시작해 여러 회사에서 CTO로 활동하다가, 현재는 교육자로 활동하고 있는 박재성이라고 합니다. 저도 비전공자로 개발을 시작해 서버

www.inflearn.com

[Docker]3.Docker / 컨테이너(Container)/ 이미지(Image) 개념 복습하기

p퐝유p — Mon, 5 May 2025 01:20:50 +0900

★ Docker 란?

컨테이너를 사용하여 각각의 프로그램을 분리된 환경에서 실행 및 관리할 수 있는 툴

★ 컨테이너란?

- 하나의 컴퓨터 환경 내에서 독립적인 컴퓨터 환경을 구성하여 , 각 환경에 프로그램을 별도로 설치할 수 있는 개념이다.

윈도우에서도 하나의 컴퓨터에 여러 사용자로 나뉘어서 사용할 수 있다. 각 사용자들에게 각각 다른 환경들을 독립적으로 구성할 수 있고,필요한 프로그램을 따로따로 설치가 가능하다. 즉,하나의 컴퓨터 환경 내에서 여러개의 미니 컴퓨터 환경 을 구성할 수 있는 형태이다. 여기서 얘기하는 미니 컴퓨터를 보고 Docker에서는 컨테이너(Container)라고 부른다.

아래의 그림을 보면

여기서 ‘컨테이너’와 ‘컨테이너를 포함하고 있는 컴퓨터’를 구분하기 위해

컨테이너를 포함하고 있는 컴퓨터를 ‘호스트(host) 컴퓨터’라고 부른다.

- 컨테이너의 독립성

▶ 디스크 (저장공간) : 각 컨테이너마다 서로 각자의 저장 공간을 가지고 있다.

A컨테이너 내부에서 B컨테이너 내부에 있는 파일은 접근 불가하다.

▶ 네트워크 (IP, Port) : 각 컨테이너마다 고유의 네트워크를 가지고 있다. 컨테이너는 각자의 IP 주소를 가지고 있다.

★ 이미지(Image) 란?

- 이미지는 프로그램을 실행하는 데 필요한 설치 과정, 설정, 버전 정보 등을 포함하고 있다.

즉, 프로그램을 실행하는 데 필요한 모든 것을 포함하고 있다.

예를 들어, MySQL 서버를 이미지로 만들었다면, 이 이미지를 Docker로 실행시키는 순간 MySQL 서버가 컨테이너

(Container) 환경에서 실행된다. MySQL을 일일이 설치할 필요없이 MySQL 데이터베이스를 사용할 수 있게 된다.

참고하고 있는 강의에서는 닌텐도 게임칩을 예를 들어 설명해주셨다. 이보다 적절한 비유는 없는 것 같다.

닌텐도의 여러가지 칩을 꽂아 다양한 게임을 즐길 수 있듯이 이미지는 프로그램을 실행하는데 필요한 모든 것을 포함하고

있다고 보면 된다.

※ 참고 강의

https://www.inflearn.com/course/%EB%B9%84%EC%A0%84%EA%B3%B5%EC%9E%90-docker-%EC%9E%85%EB%AC%B8-%EC%8B%A4%EC%A0%84/dashboard

비전공자도 이해할 수 있는 Docker 입문/실전 강의 | JSCODE 박재성 - 인프런

www.inflearn.com

[Docker] 2. 윈도우에 도커 데스크 탑 설치해보기

p퐝유p — Mon, 5 May 2025 00:55:29 +0900

Docker Desktop on Windows는 Windows 운영체제에서 Docker를 쉽게 사용할 수 있도록 만든 공식 GUI 및 도구 모음이다.

Linux에서 동작하는 Docker 엔진을 Windows에서도 간편하게 쓸 수 있도록 가상화 기술을 활용해서 실행해주는 역할을 한다.

내가 Docker Desktop on Windows 을 사용하는 이유는 우선 나의 pc 가 window 환경이기도 하고,

아래의 이유와 같다.

리눅스 기반 Docker 환경을 쉽게 실행
- Docker는 원래 Linux 전용이라, Windows에서는 가상화(WSL2 or Hyper-V)를 통해 리눅스를 구동해야 함.
복잡한 설정 없이 GUI로 컨테이너 관리
- GUI에서 클릭으로 컨테이너 실행/중지/삭제 가능.
WSL2 통합 지원
- WSL2를 통해 Windows와 Linux 간 파일 공유, 경로 접근이 매끄럽게 이루어짐.
개발환경 통합
- Visual Studio Code, Git, 터미널 등과 연동이 잘 됨.

01. 설치 파일 다운로드

https://docs.docker.com/desktop/install/windows-install/ 페이지에서 설치 파일을 다운로드

02. 설치 완료 후, 로그인 화면이 뜨는데 로그인은 하지 않아도 된다.

3. wsl 커널 업데이트

- 윈도우용 도커 데스크탑은 WSL2 또는 Hyper-V 기반으로 설치할 수 있다.

설치 파일 다운로드 하는 화면 하단에 WSL2 기반으로 설치를 진행하므로 최소 시스템 요구 사항을 확인해야한다.

04 . WSL 커널 업데이트

WSL 커널 업데이트 안내 창을 확인하고 https://learn.microsoft.com/ko-kr/windows/wsl/wsl2-kernel 사이트로 이동하여

해당 업데이트 패키지를 다운로드한다.

05. PowerShell를 실행하고 WSL2를 기본 버전으로 설정

wsl --set-default-version2

06. Docker Desktop 재실행

바탕화면 또는 시작 메뉴에 Docker Desktop 아이콘을 클릭하여 아래의 화면에 접속한다.

화면 왼쪽 하단에 아이콘이 초록색으로 바뀌고 마우스를 올리면 "Engine running" 메시지가 출력되는 것을 확인할 수 있다.

07. 명령 프롬프트에서 도커 CLI 실행 여부 확인

명령 프롬프트를 실행하고, 도커 CLI 실행에 문제 없는지 도커 버전을 확인하는 명령어를 입력한다.

docker version

08. 도커 명령어 확인

docker --help 명령어로 도커 명령어 사용법과 구성을 확인해본다.

09. 최신버전의 우분투 컨테이너에서 HelloWorld 메세지 출력해보기

최신 버전의 우분투 컨테이너를 실행하고, 해당 컨테이너 쉘에서 Hello World 메시지를 출력한다.

아래에 Heollo World 라고 오타를 냈는데 오타를 똑같이 맨하단에 출력한 것을 보니 잘 실행되는 것 같다. ㅎㅎㅎ...

※ 참고 강의

윈도우에 도커 데스크탑 설치

Install Docker Desktop on Windows Docker Desktop은 컨테이너화된 애플리케이션 및 마이크로서비스를 구축하고 공유할 수 있는 Mac, Linux, Windows 환경용 원클릭 설치 애플리케이션으로, 설치된 머신에서 컨테

myanjini.tistory.com

비전공자도 이해할 수 있는 Docker 입문/실전 강의 | JSCODE 박재성 - 인프런

www.inflearn.com

[Docker]1. 도커는 왜 알아야 할까?

p퐝유p — Mon, 5 May 2025 00:28:43 +0900

★ 도커를 많이 쓰는 이유 ?

- 도커의 핵심 특징은 이식성이다.

회사에서도 도커를 사용하고 있다. 도커를 사용하여 redis,kafka,nginx 등을 컨테이너로 띄워 관리하고 있다.

회사 제품 패키지를 어느 환경에서든 쉽게 설치할 수 있다는 것에 경이로움이 있었다.

라이브러리 버전 관리도 쉽고, 일일이 설치해야한다는 번거로움을 덜고 있어 더 도커에 대해 구체적으로 파보고 싶었다.

도커를 도시락 통에 비유하자면

마치 도시락통에 밥, 반찬, 숟가락까지 먹는 데 필요한 모든 것을 한 번에 담아놓는 것처럼

어디서든 열기만 하면 바로 먹을 수 있는 도시락처럼

도커는 어디서든 실행 가능한 앱 패키지를 만드는 기술이라고 생각하면 된다.

도시락 통에는 밥,반찬 다 있는 것 처럼 도커는 앱이 실행되기 위한 모든 환경을 포함하고 있다.

도시락통은 어디서든 다 먹을 수 있는 것 처럼 도커는 어떤 컴퓨터든 컨테이너를 실행하면 항상 똑같이 동작한다.

다른 도시락이랑 섞일 수 없는 것처럼 도커에서 컨테이너끼리는 독립적이며 서로 간섭하지 않은다는 것이 특징이다.

★도커와 가상머신의 차이점

가상화 방식	OS 수준 가상화 (컨테이너)	하드웨어 수준 가상화
호스트 OS 공유	예 (컨테이너는 호스트 OS 커널 공유)	아니요 (각 VM은 자체 OS 실행)
부팅 속도	매우 빠름 (초 단위)	느림 (분 단위, OS 부팅 필요)
자원 사용량	가볍고 효율적	상대적으로 무거움
격리 수준	낮음 (커널 공유로 보안 이슈 가능)	높음 (완전한 격리)
이미지 크기	작음 (수십~수백 MB)	큼 (수 GB 이상)
운영 체제 의존성	호스트 OS와 컨테이너 OS가 같은 커널 필요	다양한 OS 설치 가능 (리눅스, 윈도우 등)
사용 사례	마이크로서비스, CI/CD, 클라우드 앱 배포 등	복잡한 앱, 다양한 OS 테스트, 레거시 앱 등

- 도커는 빠르고 가벼운 환경에서 애플리케이션을 배포하고 실행하는 데 적합하며, 개발 및 배포 자동화에 강점을 가진다.

- 가상머신은 완전히 독립된 시스템 환경이 필요할 때 유리하며, 보안과 OS 다양성이 중요한 경우 사용된다.

※참고 강의

비전공자도 이해할 수 있는 Docker 입문/실전 강의 | JSCODE 박재성 - 인프런

www.inflearn.com

[코딩테스트] 역전 홈런으로 경기 이겨서 도파민 돌아서 푸는 코테 문제 - 프로그래머스 / 숫자 문자열과 영단어 / 크레인 인형 뽑기 게임

p퐝유p — Sun, 6 Apr 2025 23:26:01 +0900

해냈다 해냈어 두산이 해냈어

스벅에서 과제랑 이것저것 하면서 무려 4시간 반동안 경기 봤는데 다이슨에 기가 다 빨린 것 같은 너낌이다....

하지만 이겨서 너어어어무 조으다 다 괜찮아진다 ㅎㅎㅎ헤헤헤헤헿

악바리로 경기하는 선수들 모습에 자극받아 다시 놑북을 핀건 아니지만,,,

그래도 수수수수퍼 도파민이 돌아서 코테 문제 2개나 풀었다.

역시나, 이번 코테 문제를 풀면서 부족함을 메웠다. 다시 한번 리마인딩하자.

[문제1]

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이

import java.util.*;

class Solution {
    public int solution(String s) {
        int answer = 0;

        // 영단어 숫자를 숫자 문자열로 매핑하기 위한 해시맵 생성
        Map<String, String> map = new HashMap<>();
        map.put("zero", "0");
        map.put("one", "1");
        map.put("two", "2");
        map.put("three", "3");
        map.put("four", "4");
        map.put("five", "5");
        map.put("six", "6");
        map.put("seven", "7");
        map.put("eight", "8");
        map.put("nine", "9");

        // 입력 문자열 s에 대해 영단어 숫자를 대응하는 숫자 문자열로 변환
        for (String key : map.keySet()) {
            // 예: "one4seveneight" → "14seveneight" → "1478"
            s = s.replaceAll(key, map.get(key));
        }

        // 최종적으로 변환된 숫자 문자열을 정수형으로 변환
        answer = Integer.parseInt(s);

        // 결과 반환
        return answer;
    }
}

[인텔리전스 하신 분들의 풀이]

class Solution {
    public int solution(String s) {
        String[] strArr = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
        for(int i = 0; i < strArr.length; i++) {
            s = s.replaceAll(strArr[i], Integer.toString(i));
        }
        return Integer.parseInt(s);
    }
}

굳이 HashMap 으로 안해도 된다. 내가 너무 복잡하게 생각했나보다.

그래도 HashMap의 개념 정립을 하게된 계기가 되었다.

[문제 2]

크레인 인형 뽑기 게임

크레인 ff형뽑기 게zz크레인 인형뽑기

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

import java.util.*;

class Solution {
    public int solution(int[][] board, int[] moves) {
        int answer = 0; // 터뜨려서 사라진 인형 개수 누적

        Stack<Integer> stack = new Stack<>(); // 뽑은 인형을 담을 바구니(스택)

        // moves 배열을 순회하며 하나씩 처리
        for (int move : moves) {
            int col = move - 1; // 배열 인덱스는 0부터 시작하므로 1을 빼줌 (열 번호)

            // 해당 열(column)을 위에서부터 아래로 훑음
            for (int row = 0; row < board.length; row++) {
                // 인형이 있는 경우 (0이 아니면 인형이 존재)
                if (board[row][col] != 0) {
                    int doll = board[row][col]; // 뽑은 인형
                    board[row][col] = 0; // 뽑았으므로 빈 칸(0)으로 설정

                    // 바구니(stack)에 동일한 인형이 연속으로 있으면 제거
                    if (!stack.isEmpty() && stack.peek() == doll) {
                        stack.pop(); // 인형 터뜨리기
                        answer += 2; // 두 개가 사라지므로 +2
                    } else {
                        stack.push(doll); // 바구니에 인형 넣기
                    }

                    break; // 해당 열에서 인형을 하나 뽑았으면 더 이상 아래는 탐색하지 않음
                }
            }
        }

        return answer; // 터진 인형의 총 개수 반환
    }
}

[인텔리하신 분들의 풀이]

뭔가 내가 푼거랑 비스무리해서 위로를 삼는다.

import java.util.Stack;

class Solution {
    public int solution(int[][] board, int[] moves) {
        int answer = 0;
        Stack<Integer> stack = new Stack<>();
        for (int move : moves) {
            for (int j = 0; j < board.length; j++) {
                if (board[j][move - 1] != 0) {
                    if (stack.isEmpty()) {
                        stack.push(board[j][move - 1]);
                        board[j][move - 1] = 0;
                        break;
                    }
                    if (board[j][move - 1] == stack.peek()) {
                        stack.pop();
                        answer += 2;
                    } else
                        stack.push(board[j][move - 1]);
                    board[j][move - 1] = 0;
                    break;
                }
            }
        }
        return answer;
    }
}

스택에 관한 문제 하나 더 풀자.

이번주 한주도 존버하자 언젠간 또 금욜 오겠지????

끝.

나의 험난한 가상머신(VM)설치 여정

p퐝유p — Sun, 30 Mar 2025 23:43:17 +0900

⭐ CentOS 설치 시작을 위한 설치 파일 다운로드

1. Oracle VirtualBox : VirtualBox-7.1.6-167084-Win.exe 다운로드
나는 window10Home 을 사용하고 있다. 이 버전은 hyper-v 를 제공하지 않는다는 절망적인 정보를 얻었다.
하지만 나중에 설치를 할 수 있다는 글을 보았다. 좀 더 알아볼걸,,,,, 아냐 이제라도 알아서 다행이야 럭키비키자나
(해당 글 - https://blog.naver.com/toruin84/221936206258)
그래서 VirtualBox-7.1.6-167084-Win.exe를 설치하여 Oracle virtualBox를 설치하여 가상화 머신을 만들어보도 록 하겠다.
2. centOS-Stream-9-latest-x86_64-dvd1.iso 다운로드
현재 centOS 사이트에서는 9와 10버전을 다운로드 받을 수 있다. 안정성을 위해 9버전을 다운로드 받았다.
3. putty.exe 다운로드
원래는 형형색깔이 있는 친근한 mobaXterm 을 선호한다. 하지만 putty 를 많이 사용하는 것 같아 선택했다.
나의 취향보다 현실을 택했다.

⭐ VM (가상화 머신) 만들기
1. 새로 만들기를 선택하여 가상화 머신을 만든다.

(모두 같은 D: 경로로 설정해야 정상적으로 만들어졌다.)

2. 가상 머신에 CentOS9 설치하기

3. SSH 사용하여 서버 접속하기
ip를 입력하여 서버 접속을 한다.

그런데, 연결이 안된다.....

ip a 명령어로 ip 먼저 확인하자. ip 는 문제 없었다.

rpm -q openssh-server 로 ssh 패키지 설치 되었나 확인. 설치는 되어있었다.

ss -tln | grep :22 로 22번 포트 열려있는지 확인. 역시 포트가 닫혀있었다. 아무것도 안나왔다.

아래와 같이 실행하면 22번 포트가 열리고, putty 로 접속이 잘된다.

sudo firewall-cmd --permanent --add-service=ssh : 입력해서 SSH 연결을 허용

sudo firewall-cmd --reload : 방화벽 설정을 다시 로드
sudo systemctl status sshd: ssh 켜져있는지 확인 (active 면 성공!)

ip를 입력하여 서버 접속을 한다. 계정을 입력하라고 한다. 된다 된다 기쁘다. 쾌감이 꽤 있다.

SSH 를 root 계정으로 접속하기
그런데 온전히 나만 사용하는 건데도 root 로 접속이 안된다. 다시 centOS 로 돌아간다 흑흑흑흑흑

기본적으로 CentOS는 root 계정의 SSH 원격 접속을 차단하도록 설정되어 있다고 한다. root 계정에게 권한을 주자.

sudo passwd root : 입력하여 비밀번호 설정

sudo vi /etc/ssh/sshd_config
열어서 아래 속성을 추가
PermitRootLogin yes <-- 추가 또는 수정
PasswordAuthentication yes <-- 필요하면 yes로 변경

다시 방화벽 재부팅!
sudo firewall-cmd --reload : 방화벽 설정을 다시 로드
sudo systemctl status sshd: ssh 켜져있는지 확인 (active 면 성공!)

너무 잘된다. (positive)

[ 정보 처리 기사 필기 ] 화면 설계

p퐝유p — Wed, 25 Jan 2023 10:45:20 +0900

표준 및 지침에 따라 UI를 제작하기 위해서 설계도가 필요하다.

★ 설계도는 결과물에 대해 미리보기 기능을 한다.

☆ 와이어프레임 : 뼈대 ( 레이아웃 ) 배치, 화면 단위

☆ 목업 : 실제 화면과 유사, 기능 구현 아님

☆ 스토리보드 : 와이어 프레임 + 콘텐츠 설명 ( Description ), 이동경로

작업 지침서 활용 ( Description은 세부적 작성 필요 )

☆ 프로토타입 : 또 나왔네, 인터렉션 적용 ( 동적인 형태 )

☆ 유스케이스 : 사용자 요구사항 ( 기능적 ) 을 다이어그램 형식으로 문서화

각각의 유스케이스에 대한 명세서 작성

★ UI 요구사항 확인

☆ 기능 : 무엇을 실행하는지, 동사형으로 정리

☆ 품질 : 품질, 서비스, 감성적인 부분

☆ 제약 : 비용과 데드라인, 규제 등

★ 정황 시나리오 작성

- 6하원칙, 이야기 형식, 완성된 서비스를 상상

★ 요구사항 작성

- 정황 시나리오를 토대로 작성

★ 요약

- 개인적 인터뷰를 통해 가능한 많은 사람들과 인터뷰를 진행한다.

- 인터뷰를 통해 사업적, 기술적 요구사항을 명확히 한다.

- 인터뷰 후, 리서치를 진행해야 효율적이다.

- 활동 사항을 정의할 때는서로 협의를 통해 진행한다.

- 요구사항의 작성은 사용자 중심으로 하여 개발에 편리하도록 한다.

- UI 요구사항 중 순서는 중요하지 않다.

- 정확 시나리오는 완성된 서비스를 상상하며 6하원칙과 이야기 형식으로 작성한다.

- 요구사항은 정황 시나리오를 토대로 작성한다.

★ 품질 요구사항

☆ 기능

- 적정한 기능이 정확하게 + 호환, 보안

- 적절성, 정확, 상호운용, 보안, 호환

☆ 사용

- 얼마나 쉽고 편한지

- 이해, 학습, 운용, 친밀

☆ 신뢰

- 고장이 나도 문제 없어!

- 성숙성, 고장 허용성, 회복성

☆ 유지보수

- 개선 및 확장

- 분석, 변경, 시험, 안정

☆ 이식

- 다른 환경에서 적응

- 적용, 설치, 대체, 공존

☆ 효율

- 한정된 시간, 자원으로 많은 일 처리

- 시간, 자원

★ UI 프로토타입 제작 및 검토

★ UI 프로토타입

- 동적인 형태 ( 실제 동작하는 것처럼)의 테스트 모델

- 필수 기능을 포함, 간단하게, 실 사용자 테스트로 기능 검증

장점 : 이해와 오류발견이 쉽다.

단점 : 자원 소모, 생략 가능성

☆ 종류

- 페이퍼 ( 손으로 ) : 저렴, 즉시, 간단

- 디지털 (SW 로) : 결과와 비슷, 테스트 및 수정, 어려움

☆ 고려사항

- 계획 : 목적 -> 환경 -> 핵심UI -> 인원 -> 검증 -> 해결 -> 가이드

- 작성 : 범위확인 - 목표확인 - 자원확인

☆ 제작단계

요구사항 분석 - 요구사항 작성 ( 프로토타입)

사용자 테스트 및 수정 - 사용자 피드백 및 승인 ( 반복 )

★ UI 설계서

☆ 표지 : 프로젝트 ( 시스템 ) 명

☆ 개정 이력 : 초안작성 이후 변경할 때마다 버전 0 .1 증가

☆ 요구사항 정의서 : 요구사항 별 적용여부 기록

☆ 시스템 구조 : 전체 시스템 ( 사용자, 관리자 등 ) 의 설계 구조

☆ 사이트 맵 : 전체 콘텐츠 메뉴별 구성 + 표 형태로 작성

☆ 프로세스 정의서 : 사용자 입장에서 작업이 진행되는 순서도

☆ 화면 설계 : 각 화면별로 표지 + 스토리 보드

★ 유용성평가, 상세설계 , 감성공학

☆ 유용성 평가

뜻 : 사용자 입장에서 얼마나 유용한지

실행 ( 기능 ) : 불필요, 중복, 불편, 어려운

결과 ( 평가 ) : 즉각적이지 않은 피드백, 결과 이해, 파악이 어려움

☆ 상세설계

시나리오 : 순서도나 계층구조로 작성

일반규칙 : 기능, 구조, 인터렉션, 예외처리 ( 이후 세부기능 정의)

기대효과 : 긍정적인 문장과 단어 ( 완전, 일관, 이해 )

☆ 감성공학

HCI : 편리하고 안전한 시스템 개발 ( 최적의 UX가 목표)

UX : 시스템 이용 경험. 주관적임 ( 객관적인 UI 편리성)

감성공학 : 감성적, 인간친화적 개발

[정보 처리 기사 필기 ] UI 표준 및 지침

p퐝유p — Wed, 25 Jan 2023 10:31:18 +0900

※ 표준 - 공통적인 것

※ 지침 - 꼭 지켜야하는 것

★ 웹 표준

- 웹 접근성 : 장애가 있는 사람들도 동등하게 이용 가능

- 크로스 브라우징 : 어느 환경 ( 브라우저, 플랫폼)에서도 이용 가능

☆ 웹 접근성을 지키기 위한 지침

- 인식 (대체)

대상을 판단할 수 있어야 한다.

EX ) 시각 장애인을 위한 음성 안내

- 운용 (포인팅 )

서비스를 이용할 때, 편안해야한다.

EX ) 마우스 대신 키보드나 음성

- 이해 ( 논리적 )

결과적으로 납득이 가야한다.

EX ) 로그인 하는데 로그인에 대한 메시지가 생성되어 확인이 되도록 함.

- 견고함

EX ) 제작에 필요한 문법들을 준수하며 개발해야한다.

정부 시스템 - 누구나 평등하게 정보 습득

☆ 문법 준수 : 보편적, 보통 표현

☆ 비표준 지양 : 불가피할 경우, 대체 정보 제공

☆ 호환성 : 결제, 인증 기능 등

[정보 처리 기사 필기] 사용자 인터페이스

p퐝유p — Wed, 25 Jan 2023 09:42:34 +0900

★ UI (User Interface ) 란?

- 각 사용자와 시스템간의 매게체 역할을 하는 모든 것

★ 사용자 인터페이스 3가지 분야 : 제어 / 구성 / 기능

★ 사용자 인터페이스 특징

- 만족도에 큰 영향을 끼치기 때문에, 가장 많이 변경됨

- 편리성과 가독성, 이해도를 높인다.

- 최소한의 노력으로 결과를 얻을 수 있도록 한다.

- 소프트웨어 아키텍처를 숙지해야 한다.

★ 사용자 인터페이스의 구분

1. CLI ( Command Line Interface ) - ex. 텍스트

2. GUI ( Graphic User Interface ) - ex. 마우스

3. NUI ( Natural User Interface ) - ex. 말, 행동

★ 사용자 인터페이스 기본 원칙 : 직관 / 유효 / 학습 / 유연

★ 사용자 인터페이스의 설계 지침 ( 긍정적 )

- 사용자 중심, 일관성, 단순성, 결과예측 가능, 표준화, 접근성

- 명확성, 가시성, 오류발생 해결

※ 참고 영상

20230112 정보 처리 기사 필기 - 1과목 ( 소프트웨어 설계)

p퐝유p — Thu, 12 Jan 2023 17:14:09 +0900

1장. 요구사항 확인

소프트웨어 생명 주기 : 소프트웨어 개발 과정을 단계별로 나눈 것

1. 폭포수 모델

- 각 단계를 한번씩만 거침 (되돌릴 수 없음).

- 단계별 철저한 검증 필요 / 매뉴얼 작성 필요

2. 프로토타입 모델

- 기능적 인터페이스 중심으로 견본 개발 후 최종 개발

- 추후 발견 될 오류 방지

3. 나선형 모델

- 계획 -> 분석(검증) -> 개발 -> 평가(오류방지) 단계 반복

- 폭포수와 프로토타입의 장점 흡수하여 점진적 개발

- 대규모 소프트웨어 개발에 용이

4. 애자일 모델

- 요구사항 반영 및 고객과의 의사소통 빈도를 높이는 것 목표

- 여러 개발 방법을 아우르는 모델

★ 1장. 요구사항 확인 - 06. 요구사항 정의 분석 확인

☆ 요구사항 : 서비스에 대한 설명 및 제약 조건

- 기능 : 기능 자체

- 비기능 : 기능의 품질, 제약 사항

- 사용자 : 쉬운 표현 사용

- 시스템 : 개발자 입장, 전문 용어

☆요구사항 개발 프로세스

☆ 도출 ( 의사소통 ) -> 분석 -> 명세(문서화) -> 확인

☆ 분석 : 타당성 조사, 특정 기준으로 분류

개념 모델링 : 단순화, 개념적 표현, 객체간 관계와 종속성분석

협상 : ( 기능과 비기능, 필요자원, 서로 ) 의 요구사항이 충돌하는 경우

정형분석 : 마지막 단계, 구문과 의미를 갖는 언어 사용, 수학적 기호로 표현

☆ 확인 : 검증

검토 : 일반적, 고객대표 포함

모델 검증 : 정적 ( 논리적) 검증, 실행 안함

프로토타이핑 : 지속적인 프로토타입 작성, 사전 피드백

(단점 : 프로토타입에만 집중, 비용 부담, 과대평가)

인수테스트 : 사용자 입장에서 요구사항 체크 (계획 필요)

★ 1장. 요구사항 확인 - 07. UML ( Unified Modeling Language )

☆ UML ( Unified Modeling Language )

- 원활한 의사소통을 위해 표준화된 모델링 언어

※ 클객컴배복패 / 유시커상활타

구조적 다이어그램		행위 다이어그램
종류	키워드	종류	키워드
클래스	구조	유스케이스	모델링
객체	관계	시퀀스	메시지
컴포넌트	구현, 인터페이스	커뮤니케이션	메시지 + 연관관계
배치	구현, 위치	상태	상태 변화
복합체 구조	내부구조	활동	로직 흐름
패키지	그룹	타이밍	시간 제약

☆ UML 구성 요소 : 사물 / 관계 / 다이어그램

※ 사관다

사물 : 특정 대상

- 구조 : 요소 / 행동 : 행위 / 그룹 : 묶음 / 주해 : 설명

관계 : 연관, 의존, 일반화, 실체화, 집합, 포함

◎ 물리적인 자원의 위치를 표시하는 것으로 구현 단계에서 사용되는 것은?

- 배치

◎ 사물의 종류 중, ( 구조, 행동, 주해 ) 를 제외한 나머지 하나는 ?

- 그룹

◎( 시퀀스, 상태, 배치, 활동 ) 중, 동적인 행위를 표현하기 위한 것이 아닌 것은?

- 배치

◎ UML 다이어그램 중, 구현 단계에서 사용하기 적절한 것은?

- 컴포넌트 , 배치

◎ 의존, 실체화 관계에서 처럼, 일시적인 관계를 표현할 때 사용되는 선은?

- 점선 화살표

◎ 다중도 표현에서 ( '다수', '또는' ) 에 해당하는 기호는?

- * / ....

◎ 자동차와 열쇠의 관계를 표현하기 가장 적절한 관계는?

- 포함

[Java] JVM의 메모리 구조

p퐝유p — Thu, 29 Dec 2022 00:24:36 +0900

★ JVM이란?

- JVM 은 Java virtual Machine의 약자로 '자바를 실행하기 위한 가상 기계'라고 할 수 있다.

자바를 실행하기 위한 가상 컴퓨터라고 할 수 있다.

자바가 속도가 느리다는 단점이 있는데 Java 애플리케이션은 JVM을 한 번 더 거치고, 하드웨어에 맞게 완전히 컴파일 된 상태가 아니고 실행 시에 해석 되기 때문이다.

★ JVM 메모리 구조

3가지 주요 영역

1. 메서드 영역 (method area)

- 프로그램 실행 중 어떤 클래스가 사용되면, JVM은 해당 클래스의 클래스파일을 읽어서 분석 후,

클래스에 대한 정보를 이곳에 저장한다. 이 때, 클래스의 클래스 변수(calss variable)도 이 영역에 함께 생성된다.

2. 힙 (heap)

- 인스턴스가 생성되는 공간. 프로그램 실행 중 생성되는 인스턴스는 모두 이곳에 생성된다.

즉, 인스턴스 변수들이 생성되는 공간이다.

3. 호출 스택 (call statck 또는 execution stack)

- 호출 스택은 메서드의 작업에 필요한 메모리 공간을 제공한다.

메서드가 호출되면, 호출 스택에 호출된 메서드를 위한 메모리가 할당 된다.

이 메모리는 메서드가 작업을 수행하는 동안 지역변수(매개 변수)들과 연산의 중간결과 등을 저장하는데 사용된다.

그리고 메서드가 작업을 마치면 할당되었던 메모리 공간은 반환되어 비워진다.

[Java] 변수와 메서드

p퐝유p — Tue, 27 Dec 2022 23:27:58 +0900

★ 선언 위치에 따른 변수의 종류

변수의 종류

1. 클래스 변수

2. 인스턴스 변수

3. 지역 변수

변수의 종류를 결정 짓는 기준은 ' 변수의 선언된 위치'

멤버 변수를 제외한 나머지 변수들은 모두 지역변수멤버 변수 중 static이 붙은 것이 클래스 변수, 붙지 않은 것이 인스턴스 변수

class Variables 
{
	int iv; // 인스턴스 변수
    static int cv; // 클래스 변수(static 변수, 공유변수)
    
    void method()
    {
    	int lv = 0; // 지역 변수
    }
}

변수의 종류	선언 위치	생성 시기
클래스 변수	클래스 영역	클래스가 메모리에 올라갈 때
인스턴스 변수	클래스 영역	인스턴스가 생성되었을 때
지역 변수	클래스 이외의 영역 (메서드, 생성자, 초기화 블럭 내부)	변수 선언문이 수행되었을 때

★ 인스턴스 변수

- 클래스 영역에 선언되며, 인스턴스를 생성할 때 만들어진다.

인스턴스는 독립적인 저장공간을 가지므로 서로 다른 값을 가질 수 있다.

인스턴스 마다 고유한 상태를 유지해야하는 속성의 경우, 인스턴스 변수로 선언한다.

★ 클래스 변수

- 선언하는 방법은 static을 붙이기만 하면 된다.

클래스 변수는 모든 인스턴스가 공통된 저장공간(변수)을 공유햐게 된다.

인스턴스를 생성하지 않고도 언제라도 바로 사용할 수 있다.

( 형태 : 클래스 이름. 클래스 변수)

★ 지역 변수

메서드 내에 선언되어 메서드 내에서만 사용 가능

for 문 또는 while문의 블럭 내에 선언된 지역변수는 블럭 { } 내에서만 사용 가능

[Java] 객체지향프로그래밍 / 클래스와 객체

p퐝유p — Thu, 22 Dec 2022 19:47:52 +0900

★ 객체 지향 이론

- 기본 개념은 ' 실제 세계는 사물(객체)로 이루어져 있으며, 발생하는 모든 사건들은 사물간의 상호작용이다."

실제 세계를 컴퓨터 속에 옮겨 놓은 것과 같은 가상세계를 구현하고, 이 가상세계에서 모의실험을 함으로써 많은 시간과 비용을 절약할 수 있었다.

★ 객체지향언어 특징

1. 코드의 재사용성이 높다.

2. 코드의 관리가 용이하다.

3.신뢰성이 높은 프로그래밍을 가능하게 한다.

★ 클래스란?

- 클래스란 ' 객체를 정의해 놓은 것' 또는 ' 객체의 설계도 또는 틀' 이다.

클래스의 정의 : 클래스란 객체를 정해놓은 것

클래스의 용도 : 클래스는 객체를 생성하는데 사용

★ 객체란?

- 객체란 ' 실제로 존재하는 것' 이다. 객체지향이론에서는 사물과 같은 유형적인 것 뿐 아니라. 개념이나 논리같은 무형적인 것도 포함된다.

객체의 정의 : 실제로 존재하는 것. 사물 또는 개념

객체의 용도 : 객체가 가지고 있는 기능과 속성에 따라 다름

유형의 객체 : 책상,의자, 자동차, Tv 와 같은 사물

무형의 객체 : 수학공식, 프로그렘 에러와 같은 논리와 개념

★ 객체와 인스턴스

인스턴스(instance) : 어떤 클래스로부터 만들어진 객체

인스턴스화 : 클래스로부터 객체를 만드는 과정

★ 객체의 구성 요소 - 속성과 기능

속성(property) : 멤버변수(member variable), 특성(attribute), 필드(field), 상태(state)

기능 (function) : 메서드(method) , 함수(function), 행위(behavior)

ex ) Tv의 속성과 기능

Tv의 속성 : 크기, 길이, 높이, 색상, 볼륨, 채널

Tv의 기능 : 켜기,끄기, 볼륨 높이기, 볼륨 낮추기, 채널 변경하기 등

★ 프로그래밍 관점에서 클래스의 정의와 의미

1. 클래스 - 데이터와 함수의 결합

* 변수 : 하나의 데이터를 저장할 수 있는 공간

* 배열 : 같은 종류의 여러 데이터를 하나의 집합으로 저장할 수 있는 공간

* 구조체 : 서로 관련된 여러 데이터를 종류에 관계없이 하나의 집합으로 저장할 수 있는 공간

* 클래스: 데이터와 함수의 결합 ( 구조체 + 함수 )

2. 클래스 - 사용자정의 타입(user-defined type)

* 프로그래머가 서로 관련된 변수들을 묶어서 하나의 타입으로 새로 추가하는 것을 사용자 정의 타입이라고 한다.

[Java] 형식화된 출력 - printf( )

p퐝유p — Thu, 22 Dec 2022 17:21:26 +0900

★ printf ( ) 란?

- '지시자(specifier)'를 통해 변수의 값을 여러 가지 형식으로 변환하여 출력하는 기능을 가지고 있다.

'지시자'는 값을 어떻게 출력할 것인지를 지정해주는 역할을 한다.

정수형 변수에 저장된 값을 10진 정수로 출력할 때는 지시자 '%d'를 사용하며,

변수의 값을 지정된 형식으로 변환해서 지시자 대신 넣는다.

예 ) int 타입의 변수 age의 값이 14일 때,

printf ( ) 는 지시자 '%d' 대신 14를 넣어서 출력한다.

★ println( ) 과 printf ( ) 차이는 ?

- 평소 화면에 출력할 때, println( )을 써왔는데 단점은 변수의 값을 그대로 출력하므로 값을 변환하지 않으면 다른 형식으로 출력할 수 없다. 같은 값이라도 다른 형식으로 출력하고 싶을 때, printf( ) 를 사용한다.

println( )과 달리 printf ( ) 는 출력 후 줄바꿈을 하지 않는다.

줄바꿈을 하고 싶다면 지시자 ' %n '을 따로 넣어줘야한다.

예 ) 소수점 둘째자리까지만 출력하고 싶을 때, 정수를 16진수나 8진수를 출력하고 싶을 때

 System.out.printf("age:%d", age); 
 System.out.printf("age:%d", 14);
 System.out.printf("age:14"); // "age : 14 " 가 화면에 출력된다.

만약 출력하는 값이 2개라면, 지시자도 2개를 사용해야하고, 출력될 값과 지시자의 순서는 일치해야한다.

3개 이상의 값도 지시자를 지정해서 출력할 수 있으며 개수 제한은 없다.

System.out.printf("age:%d year:%d", age, year);
System.out.printf("age:%d year:%d", age, year,14,2017); 
// "age:14 year:2017" 이 화면에 출력된다.

지시자	설명
%b	불리언(boolean) 형식으로 출력
%d	10진 (demical) 정수의 형식으로 출력
%o	8진 (octal) 정수의 형식으로 출력
%x, %X	16진(hexa - demical) 정수의 형식으로 출력
%f	부동 소수점(floating - point) 표현식의 형식으로 출력
%e,%E	지수 ( exponent) 표현식의 형식으로 출력
%c	문자 (character)로 출력
%s	문자열 (string) 로 출력

[기타] 자바 관련 문제 - 시험 복습

p퐝유p — Tue, 13 Dec 2022 15:13:01 +0900

사전 질문 복습

얻는 게 많은 시험이었다. 기본을 정말 붕어빵 끝 부분처럼 빠싹하게 알고싶다.

1번 문제

1. public class Score implements Comparable<Score> {
2.     private int point;
3.     public Score(int point) { this.point = point; }
4. // insert code here
5. }

Which method will complete this class?

A. public int compareTo(Object o){/*more code here*/}

B. public int compareTo(Score other){/*more code here*/}

C. public int compare(Score s1,Score s2){/*more code here*/}

D. public int compare(Object o1,Object o2){/*more code here*/}

답 : B

★ Comparable

- 객체의 정렬 기준을 정의하는 방법 중 하나가 정렬 대상 클래스를 자바에서 기본적으로 제공하고 있는 Comparable 인터페이스를 구현하도록 하도록 변경하는 것이다.

Comparable 인터페이스의 comparableTo( ) 메서드를 통해 인자로 넘어온 같은 타입의 다른 객체와 대소 비교가 가능하다.

출력하는 값Case 1. 메서드를 호출한 객체 < 인자로 넘어온 객체 : 음수Case 2. 메서드를 호출한 객체 = 인자로 넘어온 객체 : 0Case 3. 메서드를 호출한 객체 > 인자로 넘어온 객체 : 양수

★ Comparator

- 정렬 대상 클래스의 코드를 직접 수정할 수 없는 경우거나 다른 정렬 기준으로 정렬하고 싶을 때 사용한다.Comparator인터페이스의 구현체를 Arrays.sort( )나 Collections.sort( ) 와 같은 정렬 메서드의 추가 인자로 넘기면 정렬 기준을 누락된 클래스의 객체나 기존 정렬을 무시하고, 새로운 정렬 기준으로 넘길 수 있다.

2번 문제

 class Atom {
      Atom() { System.out.print("atom "); }
 }

   class Rock extends Atom {
       Rock(String type) { System.out.print(type); }
     }

 public class Mountain extends Rock {
     Mountain() {
         super("granite ");
         new Rock("granite ");
     }
     public static void main(String[] a) { new Mountain(); }
 }

What is the result?

A. Compilation fails.

B. atom granite

C. granite granite

D. atom granite granite

E. An exception is thrown at runtime.

F. atom granite atom granite

답 : F

★ Super의 역할

- 상속받은 부모 클래스의 변수명이나 클래스 변수를 참조

- 부모 클래스 생성자를 호출한다.

3번 문제

class Line {
     public class Point { public int x,y;}
     public Point getPoint() { return new Point(); }
}

class Triangle {
    public Triangle() {
       // insert code here
   }
 }

Which code, inserted at line 16, correctly retrieves a local instance of a Point object?

A. Point p = Line.getPoint();

B. Line.Point p = Line.getPoint();

C. Point p = (new Line()).getPoint();

D. Line.Point p = (new Line()).getPoint();

★ 내부 클래스

- 외부 클래스명.내부 클래스명 객체명 = new 외부클래스명.내부 클래스명();

내부 클래스를 이용하는 이유는 '캡슐화' 때문.

예를 들어, A라는 클래스가 있는데 이 클래스에는 b라는 작업이 많이 사용된다.

이럴 때, B라는 클래스를 만들어 놓으면 간단하게 사용할 수 있다.

그런데 A 이외에 다른 클래스에 B라는 작업이 필요 없다면 B 클래스를 노출 시키고 싶지 않을 것이다.

즉, 내부 구현을 감추고 싶을 때 내부 클래스를 사용하면 될 것이다.

4번 문제

StringBuilder sb1 = new StringBuilder("123");
String s1 = "123";
// insert code here
System.out.println(sb1 + " " + s1);

Which code fragment, inserted at line 24, outputs "123abc 123abc"?

A. sb1.append("abc"); s1.append("abc");

B. sb1.append("abc"); s1.concat("abc");

C. sb1.concat("abc"); s1.append("abc");

D. sb1.concat("abc"); s1.concat("abc");

E. sb1.append("abc"); s1 = s1.concat("abc");

F. sb1.concat("abc"); s1 = s1.concat("abc");

G. sb1.append("abc"); s1 = s1 + s1.concat("abc");

H. sb1.concat("abc"); s1 = s1 + s1.concat("abc");

★ StringBuilder란?

StringBuilder는 문자열을 버퍼에 담아 그 안에서 추가,수정, 삭제 작업을 할 수 있도록 도와주는 클래스이다.

기존 String 변수에 새로운 값을 넣어서 수정할 수 도 있지만, 새로운 문자열로 변경될 경우,새로운 스트링 객체로 리턴된다. 그래서 StringBuilder를 이용하면 새로운 객체를 만들지 않고도 자유롭게 문자 변경 작업을 할 수 있는 것이 장점이다.

답이 E인 이유는 StringBuilder에는 concat이 없고, String에는 append가 없다.

Concat함수는 연결을 해주는 함수고 Append는 문자열 끝에 문자열을 추가하는 함수이다.

칼럼이 같은 여러 개 데이터 프레임을 세로로 결합할 때, Concat과 Append를 많이 쓴다.append는 세로로만 결합할 수 있지만, concat은 가로,세로 모두 결합할 수 있다.concat함수가 더 빠르다.

5번 문제

interface Animal { void makeNoise(); }

class Horse implements Animal {
     Long weight = 1200L;
     public void makeNoise() { System.out.println("whinny"); }
 }

   public class Icelandic extends Horse {
       public void makeNoise() { System.out.println("vinny"); }
	   public static void main(String[] args) {
       Icelandic i1 = new Icelandic();
       Icelandic i2 = new Icelandic();
       Icelandic i3 = new Icelandic();
       i3 = i1; i1 = i2; i2 = null; i3 = i1;
     }
        }

When line 15 is reached, how many objects are eligible for the garbage collector?

A. 0

B. 1

C. 2

D. 3

E. 4

F. 6

★ garbage collector란?

- 프로그램을 개발할 때 유효하지 않은 메모리인 garbage가 발생하게 된다. Java는 개발자가 메모리를 직접 해지해 주는 일이 없다. 그 이유는 garbage collector 가 메모리를 알아서 정리해주기 때문이다.

i1=A, i2=B and i3=C;

After i3 = i1

i1=A, i2=B and i3=A

After i1 = i2

i1=B, i2=B and i3=A;

After i2 = null:

i1=B, i2=null and i3=A;

After i3 = i1

i1=B, i2=null and i3=B

총 4개

5번 문제

public class Pass {
     public static void main(String [] args) {
        	int x = 5;
        	Pass p = new Pass();
         p.doStuff(x);
         System.out.print(" main x = " + x);
     }

     void doStuff(int x) {
         System.out.print(" doStuff x = " + x++);
     }
 }

What is the result?

A. Compilation fails.

B. An exception is thrown at runtime.

C. doStuff x = 6 main x = 6

D. doStuff x = 5 main x = 5

E. doStuff x = 5 main x = 6

F. doStuff x = 6 main x = 5

★ 인스턴스 변수 / 지역 변수

인스턴스 변수 : 클래스 내에서 선언된 것

메소드 내에서 선언한 것은 인스턴스 변수에 포함되지 않는다. 인스턴스 변수는 그 변수가 속한 객체 안에서 존재.

지역 변수 : 메소드 내에서 선언된 것

메소드 매개변수도 지역변수에 포함, 지역 변수는 임시 메소드가 스택에 들어 있는 동안만 살아 있다.

'인스턴스 변수'는 클래스 내에서 선언되고, '지역 변수' 는 메소드 내에서 선언

지역변수는 사용하기 전, 반드시 초기화해야한다.

기본 값이 없어서 초기화 하기 전, 사용하려고 하면 반드시 컴파일 과정에서 오류가 난다.

6번 문제

Which Man class properly represents the relationship “Man has a best friend who is a Dog”?

A. class Man extends Dog { }
B. class Man implements Dog { }
C. class Man { private BestFriend dog; }
D. class Man { private Dog bestFriend; }
E. class Man { private Dog<bestFriend> }
F. class Man { private BestFriend<dog> }

★인터페이스 정의와 구현

public interface Pet {...} // 정의
public class Dog extends Canine implements Pet {...} // 구현

7번 문제

 class Animal { public String noise() { return "peep"; } }

12. class Dog extends Animal {
13.     public String noise() { return "bark"; }
14. }

15. class Cat extends Animal {
16.     public String noise() { return "meow"; }
17. } ...

30. Animal animal = new Dog();
31. Cat cat = (Cat)animal;
32. System.out.println(cat.noise());

What is the result?

A. peep

B. bark

C. meow

D. Compilation fails

E. An exception is thrown at runtime.

Cat 자료형이 메모리에 올라간 적이 없다.

형변환 에러는 런타임시에 발생

8번 문제

 public class KungFu {
2.       public static void main(String[] args) {
3.           Integer x = 400;
4.           Integer y = x;
5.           x++;
6.           StringBuilder sb1 = new StringBuilder("123");
7.           StringBuilder sb2 = sb1;
8.           sb1.append("5");
9.           System.out.println((x==y) + " " + (sb1==sb2));
10.     }
11. }

A. true true

B. false true

C. true false

D. false false

E. Compilation fails.

F. An exception is thrown at runtime.

9번 문제

1.   public class GC {
2.       private Object o;
3.       private void doSomethingElse(Object obj) { o = obj; }
4.       public void doSomething() {
5.           Object o = new Object();
6.           doSomethingElse(o);
7.           o = new Object();
8.           doSomethingElse(null);
9.           o = null;
10.     }
11. }

When the doSomething method is called, after which line does the Object created in line 5 become available for garbage collection?

A. Line 5

B. Line 6

C. Line 7

D. Line 8

E. Line 9

F. Line 10

dosomethingElse(null);메소드를 호출하면서 null을 파라미터로 넘긴다.

그러면서 오브젝트 o가 null 값을 가지게 된다.

10번 문제

 public class HeapObject implements Serializable , Cloneable {
       private final String name;
       public HeapObject(String name) {
           this. name = name;
       }

       @Override
       protected HeapObject clone() throws CloneNotSupportedException {
           return (HeapObject)super.clone();
       }

     public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
         HeapObject t1 = new HeapObject("test");
         HeapObject t2 = t1.clone();
         HeapObject t3 = serializeAndDeserialize(t1);
         HeapObject t4 = t1;
     }

     private static HeapObject serializeAndDeserialize(HeapObject t1) throws IOException, ClassNotFoundException {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(baos);
         oos.writeObject(t1);
         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
         return (HeapObject)ois.readObject();
     }
}

line 15에서 heap에 존재하는 HeapObject의 instance 수는?

A. 1

B. 2

C. 3

D. 4

★ clone 메서드

Java의 최상위 클래스인 Object에는 객체를 복제하는 clone 메서드가 존재한다.

이 메서드의 역할은 기존 객체의 데이터를 보존하기 위해서이다.

Java의 모든 클래스에는 Object에서 파생되기 때문에 모든 클래스의 인스턴스는 clone( )을 사용할 수 있다.

clone 메서드를 호출하려면 해당 객체의 클래스가 Cloneable 인터페이스를 구현해야한다.

11번 문제

public class MonitorCount {
	public static synchronized void foo1() {};
    public synchronized void foo2() {}
      public void foo3() {
         synchronized (this) {
         }
     }
           synchronized (getClass()) {
          }
     }
     public void foo5() {
         synchronized (new Object()) {
         }
     }
     public void foo6() {
         synchronized (new Object()) {
         }
     }
 }

[Java] 알고리즘 대소문자 변환

p퐝유p — Sun, 11 Dec 2022 00:09:49 +0900

★ StuDY 에서 sTUdy 로 변경해보자.

class Main {
    public String solution(String str){
        String answer="";

        for(char x : str.toCharArray()){
            if(x == Character.isLowerCase()) answer +=Character.toUpperCase(x);

            else answer += Character.toLowerCase(x);
        }
        return answer;
    }

    public static void main(String[] args){
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str=kb.next();
        System.out.println(T.solution(str));
    }
}

★ Str.toCharArray( )

- 문자열을 한글자씩 분리해서 char타입의 배열에 넣어주는 메소드

- char형 배열을 합쳐서 하나의 String(문자열)로 만들 수 있다.

String s2 = new String (charArr);

[JAVA] 프로그래머스 - 문자열 반복 출력

p퐝유p — Tue, 22 Nov 2022 21:40:39 +0900

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

[JAVA] 프로그래머스 가위바위보

p퐝유p — Tue, 22 Nov 2022 21:24:40 +0900

프로그래머스

programmers.co.kr

charAt(i) 함수란?

String 타입의 데이터(문자열) 타입인 문자 ▶ char 타입으로 변환할 때 사용하는 함수

[JAVA] 프로그래머스 삼각형의 완성조건(1)

p퐝유p — Tue, 22 Nov 2022 20:58:27 +0900

프로그래머스

programmers.co.kr

[Java] 신고 결과 받기 _ 프로그래머스 코딩 테스트 문제_문자열,해시

p퐝유p — Thu, 10 Nov 2022 23:19:36 +0900

프로그래머스

programmers.co.kr

전체 코드

import java.util.*;

class KaKaoReport {
    public int[] solution(String[] id_list, String[] report, int k) {

        int[] answer = new int[id_list.length];

        // 1. 중복제거
        HashSet<String> reportSet = new HashSet<String>();
        for (String rep : report) reportSet.add(rep);

        // 2. report에서 각 사람이 신고 당한 횟수를 counthash로 정의하기
        HashMap<String,ArrayList<String>> notifyListHash = new HashMap<>();

        for(String rep :reportSet) {
            int blankIdx = rep.indexOf(" ");
            String reporter = rep.substring(0,blankIdx);
            String reportee = rep.substring(blankIdx+1);

            ArrayList<String> reporterList = notifyListHash.getOrDefault(reportee,null);
            if(reporterList==null) reporterList = new ArrayList<>();

            reporterList.add(reporter);
            notifyListHash.put(reportee,reporterList);
        }

        // 3.notifyListHash를 기반으로 reportHash 만들기
        HashMap<String,Integer> reporterHash = new HashMap<>();

        for (ArrayList<String>notifyList : notifyListHash.values())
            if(notifyList.size()>=k)
                for(String reporter : notifyList)
                    reporterHash.put(reporter,reporterHash.getOrDefault(reporter,0)+1);

        // 4. reporterHash 정보를 answer에 옮겨담기
        for (int i=0; i<id_list.length; i++)
            answer[i] = reporterHash.getOrDefault(id_list[i],0);

        return answer;
    }

    public static void main(String[] args){
        KaKaoReport sol = new KaKaoReport();
        String[] id_list = {"muzi", "frodo", "apeach", "neo"};
        String[] report = {"muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"};
        int k = 2;
        // String[] id_list = {"con", "ryan"};
        // String[] report = {"ryan con", "ryan con", "ryan con", "ryan con"};
        // int k = 3;
        sol.solution(id_list, report, k);
    }


}

// 1. ["muzi", "frodo", "apeach", "neo"] 4명의 사용자 정보가 주어짐

// 2. 중복을 제거해야한다.

// Why? 무지가 프로도를 여러번 신고 가능하나 딱 한번만 인정된다. 앞단에서 전처리로 끝내버리면 훨씬 수월하다.
// HashSet으로 옮기는 순간 중복 제거된다.

// 3. 신고자 목록을 관리
// - NotifyListHash key : 신고 당한 사람(String) / value : 신고 한사람 (ArrayList)
// 이것이 몇번 신고 당했는지 횟수를 알 수 있음. k 이상이면 ArrayList에 있는 사람에게 신고 결과를 알려주면 됨

// 4. 신고 결과를 알려주기 위한 reporterHash
// 신고를 한 사람이 결과를 몇 번 받았느냐 알려줄 수 있음. (  k이상일 때만 신고 결과 알려줄 수 있음)

1. report를 hashSet을 이용하여 중복 제거한다.

테스트 케이스 2 결과가

이렇게 하나로 나온다.

2. report에서 각 사람이 신고 당한 횟수를 countHash로 정한다.

신고한 사람을 reporter / 신고 당한 사람을 reportee로 구분하였다.

reporter만 출력

reportee만 출력

3. notiftListHash를 기반으로 reportHash 만들기

신고한 사람이 몇번 신고 했는지 나온다.

4. reporterHash 정보를 answer에 옮겨담는다.

그럼 이렇게 담겨져 테스트에 통과하게 된다.

★ 알게된 것

getOrDefault(Object key, V DefaultValue)

key : 값을 가져와야 하는 요소의 키
defaultValue : 지정된 키로 매핑된 값이 없는 경우 반환되어야 하는 기본값

★ 참고 자료

[Java] 신규 아이디 추천 - 프로그래머스 코딩테스트 문제_정규식 표현

p퐝유p — Thu, 10 Nov 2022 00:35:57 +0900

[문제]

신규 유저가 입력한 아이디를 나타내는 new_id가 매개변수로 주어질 때, "네오"가 설계한 7단계의 처리 과정을 거친 후의 추천 아이디를 return 하도록 solution 함수를 완성해 주세요.

[제한사항]

new_id는 길이 1 이상 1,000 이하인 문자열입니다.
new_id는 알파벳 대문자, 알파벳 소문자, 숫자, 특수문자로 구성되어 있습니다.
new_id에 나타날 수 있는 특수문자는 -_.~!@#$%^&*()=+[{]}:?,<>/ 로 한정됩니다.

[입출력 예]

no	new_id	result
예1	*"...!@BaT#..y.abcdefghijklm"**	"bat.y.abcdefghi"
예2	"z-+.^."	"z-+.^."
예3	"=.="	"aaa"
예4	"123_.def"	"123_.def"
예5	"abcdefghijklmn.p"	"abcdefghijklmn"

★ 주요 정규식 표현

- 정규표현식의 기본형태 : String.replaceAll('From', 'To')

[ ]	or : 대괄호의 모든 문자
[^]	not : 대괄호 안의 문자 외의 모든 문자
^[ ]	대괄호 안의 문자로 시작하는 문자열
[ ]$	대괄호 안의 문자로 끝나는 문자열
+	1개 이상의 문자

- 단계별 정규 표현식 적용

1단계	소문자로 치환	toLowerCase()
2단계	소문자,숫자,빼기(-),밑줄(_),마침표(.)	[^a-z0-9\-_.]
3단계	마침표(.)가 2번 이상	\.+
4단계	마침표(.)가 처음이나 끝에 위치하면 제거	^[.]\|[.]$
5단계	빈 문자열이라면, new_id에 "a" 대입	isEmpty
6-1단계	길이가 16자 이상	substring
6-2단계	마침표(.)가 new_id의 끝에 위치한다면	[.]$
7단계	길이가 2자 이하	while

public class IdRecommend2 {

    public String solution(String new_id) {
        // 1
        String answer = new_id.toLowerCase();
        // 2
        answer = answer.replaceAll("[^-_.a-z0-9]", "");
        // 3
        answer = answer.replaceAll("\\.+", ".");
        // 4
        answer = answer.replaceAll("^[.]|[.]$", "");
        // 5
        if (answer.equals(""))
            answer = "a";
        // 6
        if (answer.length() > 15) {
            answer = answer.substring(0, 15);
            answer = answer.replaceAll("[.]$", "");
        }
        // 7
        while (answer.length() < 3)
            answer += answer.charAt(answer.length() - 1);

        return answer;
    }


    public static void main(String[] args) {
        IdRecommend sol = new IdRecommend();
        System.out.print(sol.solution("...!@BaT#*..y.abcdefghijklm"));
    }


}

[Java] 신규 아이디 추천 - 프로그래머스 코딩테스트 문제(1)

p퐝유p — Wed, 9 Nov 2022 23:58:18 +0900

프로그래머스

programmers.co.kr

[문제]

[제한사항]

[입출력 예]

no	new_id	result
예1	*"...!@BaT#..y.abcdefghijklm"**	"bat.y.abcdefghi"
예2	"z-+.^."	"z-+.^."
예3	"=.="	"aaa"
예4	"123_.def"	"123_.def"
예5	"abcdefghijklmn.p"	"abcdefghijklmn"

public class IdRecommend {

    public String solution(String new_id) {

        // 1.모든 대문자를 대응되는 소문자로 치환
        String answer = "";
        new_id = new_id.toLowerCase();

        // 2.알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거
        for (int i = 0; i < new_id.length(); i++) {
            char ch = new_id.charAt(i);
            if (Character.isAlphabetic(ch) ||
                    Character.isDigit(ch) ||
                    ch == '-' || ch == '_' || ch == '.')
                answer += ch;
        }

        // 3.마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환
        while (answer.indexOf("..") != -1)
            answer = answer.replace("..", ".");


        // 4.마침표(.)가 처음이나 끝에 위치한다면 제거
        if (!answer.isEmpty() && answer.charAt(0) == '.')
            answer = answer.substring(1);
        if (!answer.isEmpty() && answer.charAt(answer.length() - 1) == '.')
            answer = answer.substring(0, answer.length() - 1);


        // 5.빈 문자열이라면, new_id에 "a"를 대입
        if (answer.isEmpty())
            answer = "a";

        // 6.길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거
        //  만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거
        if (answer.length() > 15) {
            answer = answer.substring(0, 15);
            if (answer.charAt(answer.length() - 1) == '.')
                answer = answer.substring(0, answer.length() - 1);
        }

        // 7. 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.
        while (answer.length() < 3)
            answer += answer.charAt(answer.length() - 1);

        return answer;
    }

    public static void main(String[] args) {
        IdRecommend sol = new IdRecommend();
        System.out.print(sol.solution("...!@BaT#*..y.abcdefghijklm"));
    }


}

toLowerCase

- 대상 문자열을 소문자로 변환

toUpperCase

- 대상 문자열을 대문자로 변환

charAt

- String으로 저장된 문자열을 한 글자만 선택해서 char타입으로 변환

Character.isAlphabetic

- 명시된 char 값이 문자인지 여부를 판단하여 true/false 반환

Character.isDigit

- 명시된 char 값이 숫자인지 여부를 판단하여 true/false 반환

indexOf

- 특정 문자나 문자열이 앞에서부터 처음 발견되는 인덱스 반환

- 찾지 못했을 경우 "-1" 반환

substring

- 문자열의 특정 부분을 잘라내는데 사용

[JAVA] 엔티티 매핑 (6) - 필드와 컬럼 매핑 어노테이션 레퍼런스

p퐝유p — Mon, 25 Jul 2022 14:40:43 +0900

@Entity
@Table(name="MEMBER", uniqueConstraints = {@UniqueConstraint( //추가
		name = "NAME_AGE_UNIQUE",
		columnNames = {"NAME","AGE"})})
public class Member {

	@Id
	@Column(name="ID")
	private String id;
	
	@Column(name= "NAME", nullable = false, length=10 ) // 추가
	private String username;
	
	private Integer age;
	
	//==추가==
	@Enumerated(EnumType.STRING)
	private RoleType roleType;
	
	@Temporal(TemporalType.TIMESTAMP)
	private Date createDate;
	
	@Temporal(TemporalType.TIMESTAMP)
	private Date lastModifiedDate;
	
	@Lob
	private String description;
	
	
	//Getter,Setter
    .....
	
}

분류	매핑 어노테이션	설명
필드와 컬럼 매핑	@Column	컬럼을 매핑한다.
	@Enumerated	자바의 enum 타입을 매핑한다.
	@Temporal	날짜 타입을 매핑한다.
	@Lob	BLOB,CLOB타입을 매핑한다.
	@Transient	특정 필드를 데이터베이스에 매핑하지 않는다.
기타	@ Access	JPA가 엔티티에 접근하는 방식을 지정한다.

[JAVA] 엔티티 매핑 (4) - 기본 키 매핑

p퐝유p — Sat, 23 Jul 2022 21:15:15 +0900

기본 키를 애플리케이션에서 직접 할당하는 대신,

데이터베이스가 생성해주는 값을 사용하려면 어떻게 매핑해야할까?

★ 기본 키 매핑

- JPA가 제공하는 데이터베이스 기본 키 생성 전략

1. IDENTITY : 기본 키 생성을 데이터베이스에 위임한다.

2. SEQUENCE : 데이터베이스 시퀀스를 사용해 기본키를 할당한다.

3. TABLE : 키 생성 테이블을 사용한다.

하지만 데이터베이스 벤더마다 지원하는 방식이 다르다.

오라클은 시퀀스 제공하지만 My SQL은 시퀀스를 제공하지 않는 것 처럼 다 다르다.

- 기본 키를 직접 할당하려면 @Id만 사용하면 되고,

자동 생성 전략 사용 시, @Id 에 @GenerateValue를 추가하고 원하는 키 생성 전략을 선택하면 된다,

☆ 기본 키 직접 할당 전략

기본 키 직접 할당 전략은 em.persist( ) 로 엔티티를 저장하기 전에 애플리케이션에서 기본 키를 직접 할당하는 방법이다.

@Id
@Column(name = "id")
private String id;

@Id 적용 기능 자바 타입은

1. 자바 기본형

2. 자바 래펴(Wrapper)형

3. String

4. java.util.Date

5. java.sql.Date

6. java.math.BigDecimal

7. java.math.BigInteger

이다.

Board board = new Board();
board.setId("id1") // 기본키 직접 할당
em.persist(board);

☆ IDENTITY 전략

- 데이터베이스에 엔티티를 저장해서 식별자 값 획득 후 영속성 컨텍스트에 저장한다.

테이블에 데이터를 저장해야 식별자 값을 획득할 수 있다.

☆ TABLE 전략

- 데이터베이스 시퀀스 생성용 테이블에서 식별자 값을 획득 후 영속성 컨텍스에 저장한다.

☆ SEQUENCE

- 데이터베이스 시퀀스에서 식별자 값을 획득 후 영속성 컨텍스에 저장한다.

http://www.kyobobook.co.kr/product/detailViewKor.laf?ejkGb=KOR&mallGb=KOR&barcode=9788960777330&orderClick=LAG&Kc=

자바 ORM 표준 JPA 프로그래밍 - 교보문고

스프링 데이터 예제 프로젝트로 배우는 전자정부 표준 데이터베이스 프레임 | ★ 이 책에서 다루는 내용 ★■ JPA 기초 이론과 핵심 원리■ JPA로 도메인 모델을 설계하는 과정을 예제 중심으로

www.kyobobook.co.kr

[JAVA] 엔티티 매핑 (3) - DDL 생성 기능

p퐝유p — Sat, 23 Jul 2022 20:47:12 +0900

★ DDL 생성 기능

- 회원 이름은 필수로 입력되어야 하고, 10자를 초과하면 안 된다는 제약조건이 추가되었다.

스키마 자동 생성하기를 통해 만들어지는 DDL에 이 제약조건을 추가해보자.

@Entity
@Table(name="MEMBER", uniqueConstraints = {@UniqueConstraint( //추가
		name = "NAME_AGE_UNIQUE",
		columnNames = {"NAME","AGE"})})
public class Member {

	@Id
	@Column(name="ID")
	private String id;
	
	@Column(name= "NAME", nullable = false, length=10 ) // 추가
	private String username;
	
	private Integer age;
    
    ....
    
    }

@Column(name= "NAME", nullable = false, length=10 ) // 추가
	private String username;

- 위의 해석은

@Column 매핑 정보의

nullable 속성 값을 falase로 지정 : not null 제약조건 추가

length = 10 : 글자 수 10자로 제한

- 하지만 이런 기능들은 단지 DDL을 자동 생성할 때만 사용되고 JPA의 실행 로직에는 영향을 주지 않는다.

따라서 스키마 자동 생성 기능을 사용하지 않고, 직접 ddl을 만든다면 사용할 이유가 없다.

http://www.kyobobook.co.kr/product/detailViewKor.laf?ejkGb=KOR&mallGb=KOR&barcode=9788960777330&orderClick=LAG&Kc=

자바 ORM 표준 JPA 프로그래밍 - 교보문고

www.kyobobook.co.kr

[JAVA] 엔티티 매핑 (2) - 데이터베이스 스키마 자동 생성

p퐝유p — Sat, 23 Jul 2022 19:16:01 +0900

테이블을 먼저 생성하고, 그 다음 엔티티를 생성했다.

하지만 데이터베이스 스키마 자동생성을 통해 엔티티만 만들고 테이블은 자동 생성 할 수 있다.

★ 데이터베이스 스키마 자동 생성

- JPA는 이 매핑 정보와 데이터베이스 방언을 사용해서 데이터베이스 스키마를 생성한다.

※ 데이터베이스 방언이란?

- SQL 표준을 지키지 않거나 특정 데이터베이스만의 고유한 기능을 '방언'이라고 한다.

JPA는 특정베이스에 종속적이지 않은 기술. 따라서 다른 데이터베이스로 교체 가능하다.

만약 종속적이면 데이터베이스 교체하기 어렵다.

따라서, 하이버네이트 등의 JPA 구현체들은 다양한 데이터베이스 방언 클래스를 제공한다.

☆ 스키마 자동 생성하는 법

persistence.xml 에 다음 속성을 추가한다.

 <property name="hibernate.hbm2ddl.auto" value="create" />

결과는 애플리케이션 실행 시점에 데이터베이스 테이블을 자동으로 생성한다.

☆ 콘솔에 실행되는 테이블 생성 DDL을 출력하는 법

테이블이 자동으로 잘 생성되었는지 확인하기 위해 콘솔에 나타나는 법은

<property name="hibernate.show_sql" value="true" />

이 속성을 true로 설정해주면 된다.

실행된 결과를 보자. 기존 테이블을 삭제하고 다시 생성한 것을 볼 수 있다.

- 스키마 자동 생성 기능의 장점은 개발자가 테이블을 직접 생성하는 수고를 덜 수 있다는 것이다.

하지만 자동 생성 기능이 만든 DDL은 운영 황경에서 사용할 만큼 완벽하지 않으므로

개발 환경에서 사용하거나 매핑을 어떻게 해야 하는지 참고하는 정도로만 사용하는 것이 좋다고 한다.

☆ hibernate.hbm2ddl.auto 속성 정리

옵션	속성
create	기존 테이블 삭제 후 새로 생성. DROP + CREATE
create-drop	create 속성에 더하여 애플리케이션 종료 시 생성한 DDL 을 제거한다. DROP + CREATE+DROP
update	데이터베이스 테이블과 엔티티 매핑정보를 비교하여 변경 사항만 수정한다.
validate	데이터베이스 테이블과 엔티티 매핑정보를 비교하여 차이가 있을 시 경고를 남기고 애플리케이션을 실행하지 않는다. 이 설정은 DDL을 수정하지 않는다.
none	자동 생성 기능을 사용하지 않으려면 hibernate.hbm2ddl.auto 속성 자체를 삭제하거나 유효하지 않은 옵션 값을 주면 된다.

[Java] 엔티티 매핑 (1) - @Entity / @Table / 그 외 다양한 매핑

p퐝유p — Sat, 23 Jul 2022 18:06:37 +0900

★ @Entity란?

- JPA를 사용해서 테이블과 매핑할 클래스는 @Entity를 꼭 붙여야 한다.

☆ @Entity 속성

1. name : JPA에서 사용할 엔티티 이름을 지정해야한다.

설정하지 않으면 클래스 이름 그대로 사용하는 걸로 인식한다.

☆ @Entity 주의사항

1. 기본 생성자는 필수 (파라미터가 없는 public 또는 protected 생성자)

public member () // 기본 생성자

//임의의 생성자
public Member(String name){
	this.name = name
}

2. final, enum,interface,inner 클래스에는 사용 불가

3. 저장할 필드에 final 사용불가

★ @Table란?

- @Table은 엔티티와 매핑할 테이블을 지정한다. 이를 생략하면 매핑한 엔티티 이름을 테이블 이름으로 사용한다.

☆ @Entity 속성

속성	기능	기본값
name	매핑할 테이블 이름	엔티티 이름을 사용한다.
catalog	catalog 기능이 있는 데이터베이스에서 catalog를 매핑한다.
schema	schema 기능이 있는 데이터베이스에서 schema를 매핑한다. DDL 생성 시에 유니크 제약조건을 만든다. 2개 이상의 복합 유니크 제약조건도 가능하다. 스키마 자동 생성 기능을 사용해서 DDL을 만들 때만 사용된다.

※ DDL(Data Definition Language] - 데이터 정의어

데이터 베이스를 정의하는 언어 / 데이터 생성,수정,삭제 등 전체 골격을 만드는 역할

ex ) CREATE, ALTER,DROP,TRUNCATE

출처 : https://cbw1030.tistory.com/71

★ 그 외 다양한 매핑

- 회원 관리 프로그램에서 다음과 같은 요구사항이 추가해야 한다.

1. 회원은 일반회원 / 관리자 로 구분

2. 회원 가입일과 수정일 생성

3. 회원을 설명할 수 있는 필드 생성. 이 필드는 길이 제한 없음

package jpabook.start;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.UniqueConstraint;



@Entity
@Table(name="MEMBER", uniqueConstraints = {@UniqueConstraint( //추가
		name = "NAME_AGE_UNIQUE",
		columnNames = {"NAME","AGE"})})
public class Member {

	@Id
	@Column(name="ID")
	private String id;
	
	@Column(name= "NAME", nullable = false, length=10 ) // 추가
	private String username;
	
	private Integer age;
	
	//==추가==
	@Enumerated(EnumType.STRING)
	private RoleType roleType;
	
	@Temporal(TemporalType.TIMESTAMP)
	private Date createDate;
	
	@Temporal(TemporalType.TIMESTAMP)
	private Date lastModifiedDate;
	
	@Lob
	private String description;
	
	
	//Getter,Setter
	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public Integer getAge() {
		return age;
	}

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

	public RoleType getRoleType() {
		return roleType;
	}

	public void setRoleType(RoleType roleType) {
		this.roleType = roleType;
	}

	public Date getCreateDate() {
		return createDate;
	}

	public void setCreateDate(Date createDate) {
		this.createDate = createDate;
	}

	public Date getLastModifiedDate() {
		return lastModifiedDate;
	}

	public void setLastModifiedDate(Date lastModifiedDate) {
		this.lastModifiedDate = lastModifiedDate;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}
	
}

1. roleType

- 자바의 enum을 사용해서 회원 타입을 구분한다. 이때 쓰이는 어노테이션은 @Enumerated이다.

일반 회원은 USER, 관리자는 ADMIN

2. createdDate,lastModifiedDate

- 자바의 날짜 타입은 @Temporal을 사용해서 매핑한다.

3. description

- 회원을 설명하는 필드는 길이 제한이 없다. 그래서 VARCHAR타입 대신에 CLOB타입으로 저장해야한다.

@Lob을 사용하면 CLOB,BLOB 타입을 매핑할 수 있다.

- 이 책을 바탕으로 학습했습니다.

http://www.kyobobook.co.kr/product/detailViewKor.laf?ejkGb=KOR&mallGb=KOR&barcode=9788960777330&orderClick=LAG&Kc=

자바 ORM 표준 JPA 프로그래밍 - 교보문고

www.kyobobook.co.kr

[Java] 영속성 관리 - (5) 준영속

p퐝유p — Sun, 17 Jul 2022 17:07:08 +0900

★ 준영속이란?

- 준영속 상태는 영속성 컨텍스트가 관리하는 영속 상태의 엔티티가 영속성 컨텍스트에서 분리된 상태를 말한다.

☆ 영속 상태의 엔티티를 준영속 상태로 만드는 방법

1. em.detach(entity) : 특정 엔티티만 준영속 상태로 전환한다.

2. em.clear( ) : 영속성 컨텍스트를 완전히 초기화한다.

3. em.close( ) : 영속성 컨텍스트를 종료한다.

☆ 준영속 상태의 특징

1. 거의 비영속 상태에 가깝다.

- 영속 컨텍스트가 관리하지 않는다.

그래서 1차 캐시, 쓰기 지연 등등 영속성 컨텍스트가 제공하는 어떠한 기능도 동작하지 않는다.

2. 식별자 값을 가지고 있다.

- 준영속 상태는 이미 한 번 영속 상태였으므로 반드시 식별자 값을 가지고 있다.

3. 지연 로딩을 할 수 없다.

- 준영속 상태는 영속성 컨텍스가 더는 관리하지 않으므로 지연 로딩시 문제가 발생한다.

☆ 병합: merge( )

- 준영속 상태의 엔티티를 다시 영속 상태로 변경하려면 병합을 사용하면 된다.

merge( ) 메소드는 준영속 상태의 엔티티를 받아서 그 정보로 새로운 영속 상태의 엔티티를 반환한다.

public class ExamMergeMain {

	EntityManagerFactory emf = 
			Persistence.createEntityManagerFactory(("jpabook");

	public static void main(String[] args) {

		Member member = createMember("memberA", "회원1");

		member.setUsername("회원명변경");

		mergeMember(member);
	}

	static Member createMember(String id, String username) {
		// == 영속성 컨텍스트1 시작 ==//

		EntityManager em1 = emf.createEntityManager();

		EntityTransaction tx1 = em1.getTransaction();

		tx1.begin();

		Member member = new Member();
		member.setId(id);
		member.setUsername(username);

		em1.persist(member);
		tx1.commit();

		em1.close(); // 영속성 컨텍스트1 종료,
						// member 엔티티는 준영속 상태가 된다.
		// == 영속성 컨텍스트1 종료 ==//

		return member;
	}

	static void mergeMember(Member member) {
		// == 영속성 컨텍스트2 시작 ==//

		EntityManager em2 = emf.createEntityManager();

		EntityTransaction tx2 = em2.getTransaction();

		tx2.begin();
		Member mergeMember = em2.merge(member);
		tx2.commit();

		// 준영속 상태
		System.out.println("member = " + member.getUsername());

		// 영속 상태
		System.out.println("mergeMember = " + mergeMember.getUsername());

		System.out.println("em2 contains member = " + em2.contains(member));

		System.out.println("em2 contains mergeMember = " + em2.contains(mergeMember));
		em2.close(); // 영속성 컨텍스트2 종료,

		// == 영속성 컨텍스트2 종료 ==//

	}

}

http://www.kyobobook.co.kr/product/detailViewKor.laf?ejkGb=KOR&mallGb=KOR&barcode=9788960777330&orderClick=LAG&Kc=

자바 ORM 표준 JPA 프로그래밍 - 교보문고

www.kyobobook.co.kr

[JAVA] JPA 영속성 관리 (4) - 플러시 (flush)

p퐝유p — Sun, 17 Jul 2022 16:39:46 +0900

★ 플러시(flush)란?

- 플러시는 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영한다.

☆ 플러시 실행 후, 결과

1. 변경 감지가 동작해서 영속성 컨텍스트 내의 모든 엔티티를 스냅샷과 비교 후, 엔티티를 찾는다.

수정된 엔티티는 수정 쿼리를 만들어 쓰기 지연 SQL 저장소에 등록한다.

2. 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송한다.

☆ 영속성 컨텍스트를 플러시하는 방법

1. em.flush()를 직접 호출한다.

- 직접 호출은 영속성 컨텍스트를 강제로 플러시한다.

테스트나 다른 프레임워크와 JPA를 함께 사용할 때를 제외하고 거의 사용하지 않는다.

2. 트랜잭션 커밋 시 플러시가 자동 호출된다.

- 트랜잭션만 커밋하면 어떤 데이터도 데이터베이스에 반영되지 않는다.

그래서 트랜잭션 커밋 전에 꼭 플러시를 호출해서 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영해야한다.

이런 문제를 방지하기 위해 JPA는 플러시를 자동 호출해야한다.

3. JPQL 쿼리 실행 시 플러시가 자동 호출된다.

- JPQL이나 Crieterial 같은 객체자향 쿼리를 호출할 때도 플러시가 실행된다.

☆ 플러시 모드 옵션

- 엔티티 매니저에 플러시 모드를 직접 지정하려면

javax.persistence.FlushModeType을 사용하면 된다.

1. FlushModeType.AUTO : 커밋이나 쿼리를 실행할 때 프러시(기본값)

- 플러시 모드를 별도로 설정하지 않으면 AUTO로 동작

따라서, 트랜잭션 커밋이나 쿼리 실행 시에 플러시를 자동으로 호출한다.

2. FlushModeType.COMMIT: 커밋할 때만 플러시

- 성능 최적화를 위해 사용할 수 있다.

http://www.kyobobook.co.kr/product/detailViewKor.laf?ejkGb=KOR&mallGb=KOR&barcode=9788960777330&orderClick=LAG&Kc=

자바 ORM 표준 JPA 프로그래밍 - 교보문고