브라우저에서 https://blog.example.com/posts/1을 열 때:

1. DNS 조회 → blog.example.com의 IP 획득
2. TCP 3-way handshake (SYN → SYN-ACK → ACK) + TLS handshake
3. GET /posts/1 HTTP/1.1 전송
4. 서버: 라우팅 → 인증/인가 → 비즈니스 로직 → DB 조회
5. 200 OK + {"id":1,"title":"..."}
6. 연결 유지(keep-alive) 또는 종료

정적 파일은 Nginx가 직접 응답하고, /api는 WAS 두 대로 나눠 보내는 설정:

upstream app {
    server 10.0.0.11:8080;   # Spring Boot #1
    server 10.0.0.12:8080;   # Spring Boot #2
}
server {
    listen 443 ssl;                     # TLS 종료
    location /static/ { root /var/www; }  # 정적: Nginx가 끝냄
    location /api/    { proxy_pass http://app; }  # 동적: WAS로 전달
}

// 한 JVM 프로세스 안에서 두 스레드가 같은 Heap 객체(list)를 공유
List<String> list = Collections.synchronizedList(new ArrayList<>());
Thread a = new Thread(() -> list.add("A"));
Thread b = new Thread(() -> list.add("B"));
a.start(); b.start();
a.join();  b.join();
System.out.println(list);   // [A, B] 또는 [B, A]

count++는 읽기 → 더하기 → 쓰기 3단계입니다. 두 스레드가 동시에 100을 읽으면 둘 다 101을 써서 결과는 102가 아니라 101이 됩니다.

// ❌ 경쟁 상태
private int count = 0;
public void increase() { count++; }

// ✅ 방법 1: 락
public synchronized void increase() { count++; }

// ✅ 방법 2: CAS 기반 원자 연산 (락 없이)
private final AtomicInteger count = new AtomicInteger();
public void increase() { count.incrementAndGet(); }

// 비동기 + 논블로킹: 두 외부 호출을 동시에 보내고, 둘 다 끝나면 합침
CompletableFuture<User>  user  = CompletableFuture.supplyAsync(() -> userApi.get(id));
CompletableFuture<Point> point = CompletableFuture.supplyAsync(() -> pointApi.get(id));

user.thenCombine(point, MyPage::new)
    .thenAccept(page -> log.info("done: {}", page));   // 완료 시 콜백

// 비동기 + 블로킹 (안티패턴): 맡겨 놓고 바로 기다림
User u = user.get();

$ javac Main.java        # Main.class (바이트코드) 생성
$ java Main              # JVM이 Main.class 실행
$ javap -c Main          # 바이트코드 확인: aload_0, invokevirtual ...

같은 Main.class를 macOS, Linux, Windows의 JVM에서 그대로 실행할 수 있습니다.

Member m = new Member();   // Eden에 생성, 스택 변수 m이 참조 → 도달 가능
m = null;                  // 참조 끊김 → 도달 불가 → 다음 Minor GC에서 회수

static List<Member> cache = new ArrayList<>();
cache.add(new Member());   // static이 계속 참조 → 회수 안 됨 → 쌓이면 메모리 누수

// 고정 크기 스레드 풀: 스레드 10개가 작업 100개를 나눠 처리
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
    int n = i;
    pool.submit(() -> handle(n));
}
pool.shutdown();

// Java 21 가상 스레드: 작업마다 스레드 하나, 수만 개도 가능
try (var ex = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        int n = i;
        ex.submit(() -> handle(n));
    }
}

// 절차지향: 데이터(balance)를 여러 함수가 직접 수정
int balance = 10000;
balance = withdraw(balance, 3000);

// 객체지향: 데이터와 규칙을 객체가 함께 가짐
Account account = new Account(10000);
account.withdraw(3000);

public class Account {
    private long balance;

    public void withdraw(long amount) {
        if (amount <= 0) throw new IllegalArgumentException("금액은 0보다 커야 합니다");
        if (balance < amount) throw new IllegalStateException("잔액이 부족합니다");
        balance -= amount;
    }
}
// ❌ account.setBalance(account.getBalance() - 1000);  규칙이 호출부로 새어 나감
// ✅ account.withdraw(1000);                           규칙은 Account 안에

class Member {
    protected String name;
    public void login() { ... }
}
class AdminMember extends Member {       // 관리자는 회원이다 (is-a) → 상속 OK
    public void banUser(Member target) { ... }
}

// 합성: 재사용만 필요하면 필드로 가짐
class OrderService {
    private final DiscountPolicy discountPolicy;   // has-a
}

interface Payment { void pay(int amount); }
class CardPayment  implements Payment { public void pay(int a) { /* 카드 */ } }
class KakaoPayment implements Payment { public void pay(int a) { /* 카카오 */ } }

class OrderService {
    private final Payment payment;               // 구체 타입을 모름
    OrderService(Payment payment) { this.payment = payment; }
    void order(int amount) { payment.pay(amount); }   // 실제 객체의 pay가 실행
}

abstract class Animal {
    protected final String name;              // 공통 상태
    protected Animal(String name) { this.name = name; }
    abstract void sound();                    // 자식마다 다름
    void sleep() { System.out.println(name + " 잠을 잔다"); }   // 공통 구현
}
class Dog extends Animal {
    Dog(String name) { super(name); }
    @Override void sound() { System.out.println("멍멍"); }
}

// SRP: 가입·메일·로그를 각각 분리
class UserService { void register(User u) { ... } }
class EmailSender { void sendWelcome(User u) { ... } }

// OCP: if-else 대신 구현체 추가
// if ("CARD".equals(type)) ... else if ("KAKAO".equals(type)) ...   ❌
class TossPayment implements Payment { ... }                          // ✅

// LSP 위반: 계약(send)을 지키지 못하는 구현체
class KakaoNotification implements Notification {
    public void send(String msg) { throw new UnsupportedOperationException(); }
}

// ISP: 거대한 Worker 대신 역할별 분리
interface Workable   { void work(); }
interface Approvable { void approve(); }

// DIP: 인터페이스에 의존 + 생성자 주입
class OrderService {
    private final OrderRepository repository;
    OrderService(OrderRepository repository) { this.repository = repository; }
}

요청 → DispatcherServlet → HandlerMapping → Controller → Model 생성 → ViewResolver → View(Thymeleaf) 렌더링 → 응답

@Controller
public class PostController {
    @GetMapping("/posts/{id}")
    public String detail(@PathVariable Long id, Model model) {
        model.addAttribute("post", postService.find(id));
        return "post/detail";      // templates/post/detail.html
    }
}

com.example.board
├── controller/  PostController.java    @RestController
├── service/     PostService.java       @Service, @Transactional
├── repository/  PostRepository.java    extends JpaRepository<Post, Long>
├── domain/      Post.java              @Entity
└── dto/         PostCreateRequest.java, PostResponse.java

com.example.board
├── domain/                        Post.java (순수 Java, JPA 어노테이션 없음)
├── application/
│   ├── port/in/   CreatePostUseCase.java      ← 인바운드 포트
│   ├── port/out/  SavePostPort.java           ← 아웃바운드 포트
│   └── service/   CreatePostService.java      implements CreatePostUseCase
└── adapter/
    ├── in/web/            PostController.java       → CreatePostUseCase 호출
    └── out/persistence/   PostJpaAdapter.java       implements SavePostPort

MySQL을 MongoDB로 바꿔도 PostMongoAdapter만 새로 만들면 되고 domain, application은 그대로입니다.

public class Post {
    private String title;
    private String content;

    public Post(String title, String content) {
        validate(title, content);
        this.title = title;
        this.content = content;
    }

    public void update(String title, String content) {
        validate(title, content);
        this.title = title;
        this.content = content;
    }

    public String getTitle()   { return title; }
    public String getContent() { return content; }

    private void validate(String title, String content) {
        if (title == null || title.isBlank())   throw new IllegalArgumentException("제목을 입력해 주세요.");
        if (content == null || content.isBlank()) throw new IllegalArgumentException("내용을 입력해 주세요.");
    }
}

// PostView.java
public class PostView {
    private final Scanner scanner = new Scanner(System.in);

    public int readMenu() {
        System.out.println("\n=== 게시판 ===");
        System.out.println("1. 작성  2. 목록  3. 조회  4. 수정  5. 삭제  6. 종료");
        System.out.print("선택: ");
        return Integer.parseInt(scanner.nextLine());
    }
    public String read(String label) { System.out.print(label + ": "); return scanner.nextLine(); }
    public int readNumber(String label) { return Integer.parseInt(read(label)) - 1; }

    public void printList(List<Post> posts) {
        if (posts.isEmpty()) { printMessage("게시글이 없습니다."); return; }
        for (int i = 0; i < posts.size(); i++) System.out.println((i + 1) + ". " + posts.get(i).getTitle());
    }
    public void printPost(Post post) {
        System.out.println("제목: " + post.getTitle());
        System.out.println("내용: " + post.getContent());
    }
    public void printMessage(String message) { System.out.println(message); }
}

// PostController.java
public class PostController {
    private final PostView view;
    private final List<Post> posts = new ArrayList<>();

    public PostController(PostView view) { this.view = view; }

    public void run() {
        while (true) {
            try {
                switch (view.readMenu()) {
                    case 1 -> create();
                    case 2 -> view.printList(posts);
                    case 3 -> view.printPost(find(view.readNumber("조회할 번호")));
                    case 4 -> update();
                    case 5 -> { posts.remove(index(view.readNumber("삭제할 번호"))); view.printMessage("삭제되었습니다."); }
                    case 6 -> { view.printMessage("프로그램을 종료합니다."); return; }
                    default -> view.printMessage("잘못된 입력입니다.");
                }
            } catch (IllegalArgumentException e) {   // NumberFormatException 포함
                view.printMessage(e.getMessage());
            }
        }
    }

    private void create() {
        posts.add(new Post(view.read("제목"), view.read("내용")));
        view.printMessage("게시글이 작성되었습니다.");
    }
    private void update() {
        Post post = find(view.readNumber("수정할 번호"));
        post.update(view.read("새로운 제목"), view.read("새로운 내용"));
        view.printMessage("게시글이 수정되었습니다.");
    }
    private Post find(int i) { return posts.get(index(i)); }
    private int index(int i) {
        if (i < 0 || i >= posts.size()) throw new IllegalArgumentException("존재하지 않는 게시글입니다.");
        return i;
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        new PostController(new PostView()).run();
    }
}