Spring Boot에서 파일을 스트리밍(Stream) 방식으로 write할 때, 메모리에 올릴지 여부는 사용 방식에 따라 달라집니다. 하지만 일반적인 경우 스트리밍은 메모리 사용을 최소화하기 위한 기법으로, 전체 데이터를 메모리에 올리지 않고 일정 크기의 버퍼를 통해 점진적으로 처리합니다.

✅ 메모리에 올리지 않는 경우 (Streaming 방식)

Java에서 InputStream → OutputStream 형태로 데이터를 전달할 때 보통 다음처럼 사용합니다:

try (InputStream in = ...;
     OutputStream out = new FileOutputStream("output.txt")) {

    byte[] buffer = new byte[8192]; // 8KB 버퍼
    int bytesRead;
    while ((bytesRead = in.read(buffer)) != -1) {
        out.write(buffer, bytesRead, 0);
    }
}

이 방식은:

Servlet이란?

Servlet은 Java를 기반으로 작성된 서버 측 프로그램으로, 클라이언트(주로 웹 브라우저)의 요청을 처리하고, 응답을 생성하는 역할을 합니다. 주로 HTTP 요청과 응답을 처리하기 위해 사용되며, Java EE (이후 Jakarta EE로 이름 변경) 스펙의 일부입니다.

Servlet은 기본적으로 웹 애플리케이션 서버(Tomcat, Jetty 등) 위에서 동작하며, 웹 서버와 클라이언트 간의 중간 처리자로 기능합니다.

Servlet의 주요 특징

• Java 언어 기반: 플랫폼 독립적이며 객체 지향 프로그래밍의 장점을 가집니다.
• 요청-응답 처리: HTTP 요청(GET, POST, PUT, DELETE 등)을 받아서 필요한 비즈니스 로직을 수행하고, 결과를 다시 클라이언트에 전송합니다.
• 확장성: 추가 설정과 라이프사이클 관리가 가능해 복잡한 웹 애플리케이션 개발이 가능합니다.
• 스레드 기반: 하나의 Servlet 인스턴스가 다수의 요청을 처리하기 위해 여러 스레드와 함께 동작합니다.
• 라이프사이클 관리: init(), service(), destroy() 메서드를 통해 생명주기를 관리합니다.

Servlet의 동작 방식

1. 클라이언트 요청: 사용자가 브라우저를 통해 서버로 요청을 보냅니다.
2. 웹 서버 전달: 요청은 웹 서버(Tomcat 등)에 의해 해당 Servlet에 전달됩니다.
3. Servlet 요청 처리:
   • service() 메서드가 호출되어 요청을 처리합니다.
   • 요청 방식에 따라 doGet(), doPost() 등의 메서드가 실행됩니다.
4. 응답 생성: 처리 결과를 HttpServletResponse 객체를 통해 클라이언트로 반환합니다.
5. 라이프사이클 종료: 서버가 내려가거나 특정 상황에서 destroy()가 호출되어 정리 작업을 합니다.

Servlet의 기본 구조 (예제)

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.getWriter().write("<h1>Hello, Servlet!</h1>");
    }
}

이 코드는 /hello 경로로 요청이 오면 “Hello, Servlet!” 이라는 HTML을 클라이언트에 반환합니다.

Java에서 abstract class와 interface는 둘 다 **추상화(abstraction)**를 위한 수단이지만, 설계 목적과 사용 방식에 중요한 차이가 있습니다. 아래에 그 차이점을 정리해 드릴게요.

✅ 공통점

• 둘 다 인스턴스화할 수 없음
• 둘 다 메서드 시그니처만 선언하고, 구현은 하위 클래스(또는 구현 클래스)에서 담당
• 둘 다 **다형성(polymorphism)**을 위한 수단

🔍 주요 차이점

✨ Java 8+ 이후 달라진 점

• Java 8부터 인터페이스에 default 메서드와 static 메서드 추가 가능

  interface Vehicle {
      default void start() {
          System.out.println("Starting...");
      }
  }
  

• Java 9부터는 private 메서드도 인터페이스 내부에서 선언 가능

✅ 언제 어떤 걸 써야 할까?

• abstract class가 적합한 경우:

모의 테스트

두개 뽑아서 더하기

public static int[] solution_03(int[] numbers) {
    TreeSet<Integer> result = new TreeSet<>();

    for (int i = 0; i < numbers.length - 1; i++) {
        for (int j = i + 1; j < numbers.length; j++) {
            result.add(numbers[i] + numbers[j]);
        }
    }

    return result.stream().sorted().mapToInt(Integer::intValue).toArray();
}

• stream 사용법

모의고사 (수포자)

public static int[] solution_04(int[] answers) {
    int[] pattern1 = {1, 2, 3, 4, 5};
    int[] pattern2 = {2, 1, 2, 3, 2, 4, 2, 5};
    int[] pattern3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

    int[] scores = new int[3];

    for (int i = 0; i < answers.length; i++) {
        scores[0] += answers[i] == pattern1[i % pattern1.length % pattern1.length] ? 1 : 0;
        scores[1] += answers[i] == pattern2[i % pattern2.length % pattern2.length] ? 1 : 0;
        scores[2] += answers[i] == pattern3[i % pattern3.length % pattern3.length] ? 1 : 0;
    }

    int maxScore = Arrays.stream(scores).max().getAsInt();

    ArrayList<Integer> answer = new ArrayList<>();
    for (int i = 0; i < scores.length; i++) {
        if (scores[i] == maxScore) {
            answer.add(i + 1);
        }
    }
    return answer.stream().mapToInt(Integer::intValue).toArray();
}

• 패턴 파악, maxScore 구하는 방법 .max().getAsInt()

행렬의 곱셉

public static int[][] solution_05(int[][] arr1, int[][] arr2) {
    int[][] answer = new int[arr1.length][arr2[0].length];

    for (int i = 0; i < arr1.length; i++) {
        for (int j = 0; j < arr2[0].length; j++) {
            for (int k = 0; k < arr1[0].length; k++) {
                answer[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }
    return answer;
}

• O(N^3) 의 index 유의

실패율

public static int[] solution_06(int N, int[] stages) {

    int[] challenger = new int[N+2];
    Arrays.stream(stages).forEach(stage -> challenger[stage]++);

    HashMap<Integer, Double> fails = new HashMap<>();
    double totalPlayer = stages.length;

    for( int i = 1; i <= N; i++) {
        if(challenger[i] == 0) {
            fails.put(i, 0.0);
        }else {
            fails.put(i, (double)challenger[i]/totalPlayer);
            totalPlayer -= challenger[i];
        }
    }

    return fails.entrySet().stream()
        .sorted((o1, o2) -> Double.compare(o2.getValue(), o1.getValue()))
        .mapToInt(HashMap.Entry::getKey).toArray();
}

• challenger 을 [N+2] 개로 잡는 이유
• for문에서 totalPlayer -= challenger[i];
• HashMap의 entrySet 사용 요령 기억하기

방문 길이

import java.util.HashMap;
import java.util.HashSet;

class Solution {

    private static HashMap<Character, int[]> location = new HashMap<>();

    private static void initLocation() {
        location.put('U', new int[]{0, 1});
        location.put('D', new int[]{0, -1});
        location.put('L', new int[]{-1, 0});
        location.put('R', new int[]{1, 0});
    }

    public int solution(String dirs) {
        initLocation();
        int x = 5, y = 5;

        HashSet<String> answer = new HashSet<>();

        for (int i = 0; i < dirs.length(); i++) {
            int[] move = location.get(dirs.charAt(i));
            int nx = x + move[0];
            int ny = y + move[1];

            if (!isValidMove(nx, ny)) {
                continue;
            }
            answer.add(x + " " + y + " " + nx + " " + ny);
            answer.add(nx + " " + ny + " " + x + " " + y);

            x = nx;
            y = ny;
        }

        return answer.size() / 2;
    }

    private static boolean isValidMove(int nx, int ny) {
        return nx < 11 && nx >= 0 && ny < 11 && ny >= 0;
    }
}

• A->B, B->A 도 하나의 이동경로로 파악되는 점 유의 answer.size() / 2 (문제에는 상세 설명이 없음)

Virtual Thread는 Java 19부터 도입되고 Java 21에서 정식으로 안정화된 Project Loom의 핵심 기능 중 하나로, 기존의 Java 플랫폼에서 사용되던 platform thread(또는 OS thread)와는 다른 개념입니다. Virtual thread는 **경량 스레드(lightweight thread)**로서, 수십만 개의 스레드를 동시에 실행할 수 있도록 설계되었습니다.

1. Virtual Thread의 핵심 개념

기존 Platform Thread vs Virtual Thread

2. 주요 특징

경량 스레드

• Virtual thread는 메모리 사용량이 훨씬 적고 생성 속도도 빠릅니다.
• 1:1 매핑이 아닌 M:N 구조로, 여러 virtual thread가 하나의 OS thread를 공유합니다.

차단 I/O와의 통합

• 기존에는 Thread.sleep()이나 InputStream.read() 같은 blocking I/O 호출이 OS thread를 점유하여 비효율적이었음.
• Virtual thread에서는 이러한 호출이 발생하면 JVM이 해당 virtual thread를 parking하고, 다른 작업을 실행시켜 병목을 피함.

코드 스타일 유지

• 기존의 CompletableFuture, Reactive API 없이도 전통적인 동기 코드 스타일을 유지하면서도 고성능 비동기 처리가 가능.

3. 사용 예시

Runnable task = () -> {
    System.out.println("Hello from " + Thread.currentThread());
};

Thread thread = Thread.ofVirtual().start(task);

혹은 Executors를 통해 수많은 스레드 처리도 가능:

대용량 처리를 위한 **비동기 Event Driven Architecture (EDA)**는 시스템이 이벤트(event)를 중심으로 작동하며, 확장성, 유연성, 성능을 확보하는 데에 효과적인 아키텍처입니다. 아래에 개념과 구성 요소, 장점 및 적용 사례에 대해 자세히 설명드릴게요.

✅ 1. 기본 개념

**Event Driven Architecture (EDA)**는 시스템 내에서 이벤트가 발생하면, 이를 감지하고 처리하는 구조로 구성됩니다. 이벤트는 어떤 상태의 변화를 의미하고, 이를 **프로듀서(생산자)**가 발생시키고, **컨슈머(소비자)**가 이를 처리합니다.

비동기 방식에서는 이 이벤트가 즉시 처리되지 않고, 큐나 버퍼를 통해 일시 저장되며, 컨슈머가 가능한 시점에 이벤트를 처리합니다. 이 구조는 시스템이 처리해야 할 데이터나 요청이 많을 때 부하를 완화하고 확장성을 제공합니다.