sdk list java

// 클래스, 상속, 캡슐화, 다형성
public class Animal {
    private String name;
    
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 상태 변경과 제어 흐름을 명시적으로 작성
public static int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;  // 상태 변경
    }
    return result;
}

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class FunctionalExample {
    public static void main(String[] args) {
        // 1. 람다 표현식과 고차 함수
        Function<Integer, Integer> square = x -> x * x;
        Function<Integer, Integer> addOne = x -> x + 1;
        
        // 함수 합성
        Function<Integer, Integer> squareThenAdd = square.andThen(addOne);
        System.out.println(squareThenAdd.apply(3)); // 10
        
        // 2. 불변성과 순수 함수
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> doubled = numbers.stream()
            .map(n -> n * 2)  // 원본을 변경하지 않음
            .collect(Collectors.toList());
        
        // 3. 함수를 파라미터로 전달
        calculate(10, 5, (a, b) -> a + b); // 15
        calculate(10, 5, (a, b) -> a * b); // 50
    }
    
    static void calculate(int x, int y, BinaryOperator<Integer> operation) {
        System.out.println(operation.apply(x, y));
    }
}

// 타입 파라미터를 사용한 일반화
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 제네릭 메서드
public static <T extends Comparable<T>> T findMax(List<T> list) {
    return list.stream()
        .max(Comparable::compareTo)
        .orElse(null);
}

import java.util.concurrent.*;

public class ConcurrentExample {
    public static void main(String[] args) throws Exception {
        // CompletableFuture를 사용한 비동기 프로그래밍
        CompletableFuture<String> future1 = CompletableFuture
            .supplyAsync(() -> fetchDataFromAPI1());
            
        CompletableFuture<String> future2 = CompletableFuture
            .supplyAsync(() -> fetchDataFromAPI2());
            
        // 두 작업을 결합
        CompletableFuture<String> combined = future1
            .thenCombine(future2, (result1, result2) -> result1 + " " + result2);
            
        System.out.println(combined.get());
    }
}

// RxJava 또는 Project Reactor 사용 예제
Flux.just(1, 2, 3, 4, 5)
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .subscribe(System.out::println);

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

// OOP: 클래스와 인터페이스 정의
interface DataProcessor<T> {
    CompletableFuture<List<T>> process(List<T> data);
}

public class HybridExample implements DataProcessor<Integer> {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    
    @Override
    public CompletableFuture<List<Integer>> process(List<Integer> data) {
        // 함수형 + 동시성 프로그래밍
        return CompletableFuture.supplyAsync(() -> 
            data.parallelStream()           // 병렬 처리
                .filter(n -> n > 0)         // 함수형: 필터링
                .map(this::complexCalculation)  // 메서드 참조
                .sorted()                    // 정렬
                .collect(Collectors.toList()),
            executor
        );
    }
    
    // 명령형 스타일의 복잡한 계산
    private Integer complexCalculation(Integer n) {
        int result = n;
        for (int i = 0; i < 3; i++) {
            result = result * 2 + 1;
        }
        return result;
    }
    
    public static void main(String[] args) throws Exception {
        HybridExample processor = new HybridExample();
        List<Integer> data = Arrays.asList(1, -2, 3, 4, -5, 6);
        
        // 비동기 처리 시작
        CompletableFuture<List<Integer>> future = processor.process(data);
        
        // 콜백 체인 (함수형)
        future.thenApply(result -> {
            System.out.println("처리 결과: " + result);
            return result;
        })
        .thenAccept(result -> {
            // 결과 활용
            int sum = result.stream().mapToInt(Integer::intValue).sum();
            System.out.println("합계: " + sum);
        })
        .get(); // 완료 대기
        
        processor.executor.shutdown();
    }
}

// ✅ 권장: Authorization 헤더 사용
fetch('/api/data', {
  headers: {
    'Authorization': 'Bearer ' + accessToken,
    'Content-Type': 'application/json'
  }
});

// ❌ 비권장: 바디에 토큰 포함
fetch('/api/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    accessToken: accessToken,
    otherData: data
  })
});

// src/main/java/com/example/user/event/UserSignedUpEvent.java
package com.example.user.event;

import java.time.Instant;

public record UserSignedUpEvent(Long userId, String email, Instant occurredAt) {}

// src/main/java/com/example/user/service/SignUpService.java
package com.example.user.service;

import com.example.user.event.UserSignedUpEvent;
import com.example.user.model.User;
import com.example.user.repo.UserRepository;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.Instant;

@Service
public class SignUpService {

    private final UserRepository userRepository;
    private final ApplicationEventPublisher publisher;

    public SignUpService(UserRepository userRepository, ApplicationEventPublisher publisher) {
        this.userRepository = userRepository;
        this.publisher = publisher;
    }

    @Transactional
    public Long signUp(String email, String name) {
        User user = userRepository.save(new User(email, name));  // JPA 엔티티 저장 가정
        // 이벤트 발행 (트랜잭션 안에서)
        publisher.publishEvent(new UserSignedUpEvent(user.getId(), user.getEmail(), Instant.now()));
        return user.getId();
    }
}

// src/main/java/com/example/user/listener/AuditLogListener.java
package com.example.user.listener;

import com.example.user.event.UserSignedUpEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
public class AuditLogListener {
    private static final Logger log = LoggerFactory.getLogger(AuditLogListener.class);

    @Order(0) // 여러 리스너가 있을 때 순서 제어 가능 (낮을수록 먼저)
    @EventListener
    public void onUserSignedUp(UserSignedUpEvent event) {
        log.info("AUDIT: userId={}, email={}, at={}", event.userId(), event.email(), event.occurredAt());
    }
}