스프링 전에 다지는 자바 문법

자바를 한 번 배웠더라도, 스프링 코드에는 비교적 최신 자바 문법이 가득하다. 람다·스트림·record·애노테이션을 모르면 이후 챕터의 예제가 "마법"처럼 보인다. 이 장은 스프링 학습에 꼭 필요한 자바 문법만 골라 "기존 방식 → 새 문법" 으로 빠르게 짚는다.

#1. 애노테이션 (Annotation)

애노테이션은 코드에 붙이는 "메타데이터(부가 정보)" 다. @로 시작하며, 그 자체로는 아무 동작도 하지 않는다. 대신 컴파일러나 프레임워크가 읽어서 무언가를 해 준다.

가장 익숙한 예가 @Override다.

class Cat extends Animal {
    @Override                 // "이 메서드는 부모를 재정의한다"고 컴파일러에 알림
    public String sound() {   // 메서드 이름을 오타 내면 컴파일 에러로 즉시 발견
        return "야옹";
    }
}

@Override는 실행 동작을 바꾸지 않는다. 단지 컴파일러에게 정보를 줄 뿐이다. 스프링도 똑같은 원리로, 애노테이션을 보고 일을 한다.

@Component         // 스프링: "이 클래스를 빈으로 등록해"
public class MemberService { ... }

@Autowired         // 스프링: "여기에 의존성을 주입해"
private MemberRepository repository;

#2. var — 지역변수 타입 추론

우변만 봐도 타입이 분명하면, 좌변 타입을 var로 줄일 수 있다. (Java 10+)

// 기존 — 타입을 양쪽에 길게 반복
Map<String, List<Member>> groups = new HashMap<>();

// var — 컴파일러가 우변을 보고 타입을 추론
var groups = new HashMap<String, List<Member>>();
var name = "kim";        // String
var count = 10;          // int

#3. 제네릭 (Generics)

제네릭은 "어떤 타입을 다루는지"를 <> 안에 적어 알려 주는 문법이다. 컴파일 시점에 타입을 검사해 주고, 꺼낼 때 형변환(캐스팅)을 없애 준다.

// 기존 — Object로 담으면 타입 안전성이 없다
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);   // 직접 캐스팅, 실수하면 런타임 오류

// 제네릭 — 담을 타입을 명시
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);            // 캐스팅 불필요, 컴파일러가 타입 보장
list.add(123);                     // 💥 컴파일 에러 — String만 허용

<T>의 T는 "여기 들어올 타입"을 가리키는 타입 매개변수다. 스프링·자바 API는 제네릭으로 가득하다.

List<Member> members;                       // Member를 담는 리스트
Optional<Member> found;                     // Member가 있을 수도 없을 수도
ResponseEntity<MemberDto> response;          // 응답 바디 타입이 MemberDto
public interface MemberRepository
        extends JpaRepository<Member, Long> {}   // 엔티티=Member, ID=Long

#4. 람다식과 함수형 인터페이스

함수형 인터페이스는 추상 메서드가 딱 하나뿐인 인터페이스다. 그 구현을 통째로 클래스로 만드는 대신, 람다식으로 "메서드 본문만" 짧게 전달할 수 있다.

// 기존 — 익명 클래스로 Runnable 구현 (군더더기가 많다)
Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("실행");
    }
};

// 람다 — 매개변수와 본문만 남긴다
Runnable task = () -> System.out.println("실행");

// 정렬 기준(Comparator)도 람다로
list.sort((a, b) -> a.getAge() - b.getAge());   // 나이 오름차순

자주 쓰는 함수형 인터페이스는 정해져 있다.

http.authorizeHttpRequests(auth -> auth.anyRequest().authenticated());

http
    .authorizeHttpRequests(auth -> auth          // ── 인가 설정 묶음
        .requestMatchers("/login").permitAll()
        .anyRequest().authenticated()
    )
    .formLogin(form -> form.loginPage("/login")); // ── 로그인 설정 묶음

#5. 메서드 참조 (Method Reference)

람다가 하는 일이 "이미 있는 메서드 하나를 호출" 하는 게 전부라면, 클래스::메서드 형태로 더 짧게 줄일 수 있다.

// 람다
stream.map(member -> member.getName());

// 메서드 참조 — 같은 의미
stream.map(Member::getName);

#6. 스트림 (Stream)

스트림은 컬렉션을 "선언적으로" 처리하는 문법이다. for 문으로 "어떻게" 도는지 일일이 쓰는 대신, filter·map 같은 연산을 체인으로 연결해 "무엇을" 할지 표현한다.

// 기존 for문 — 성인 회원의 이름만 모으기
List<String> names = new ArrayList<>();
for (Member m : members) {
    if (m.getAge() >= 20) {
        names.add(m.getName());
    }
}

// 스트림 — 흐름이 그대로 읽힌다
List<String> names = members.stream()
        .filter(m -> m.getAge() >= 20)   // 성인만 거르고
        .map(Member::getName)            // 이름으로 바꿔서
        .toList();                       // 리스트로 모은다

flowchart LR
    A[회원 목록] -->|stream| B["filter<br/>(성인만)"] --> C["map<br/>(이름만)"] --> D["toList<br/>(모으기)"]

연산은 두 종류다. 중간 연산은 스트림을 반환해 계속 이어 붙이고, 최종 연산에서 결과가 나온다.

#자주 쓰는 패턴 예제

아래 예제는 모두 List<Member> members(필드: id, name, age, city)를 다룬다고 하자.

// ① 조건에 맞는 개수 세기 — 성인 회원 수
long adultCount = members.stream()
        .filter(m -> m.getAge() >= 20)
        .count();

// ② 통계 — 나이 합계·평균 (mapToInt로 숫자 전용 스트림(IntStream)으로 전환)
int totalAge   = members.stream().mapToInt(Member::getAge).sum();
double avgAge  = members.stream().mapToInt(Member::getAge).average().orElse(0);

// ③ 정렬 후 상위 N개 — 나이 많은 순 3명
List<Member> top3 = members.stream()
        .sorted(Comparator.comparingInt(Member::getAge).reversed())  // 내림차순
        .limit(3)
        .toList();

// ④ 문자열로 잇기 — 이름을 ", "로 연결 → "kim, lee, park"
String names = members.stream()
        .map(Member::getName)
        .collect(Collectors.joining(", "));

// ⑤ 그룹으로 묶기 — 도시별 회원 목록 (Map<String, List<Member>>)
Map<String, List<Member>> byCity = members.stream()
        .collect(Collectors.groupingBy(Member::getCity));

// ⑥ Map으로 모으기 — id를 키로 (Map<Long, Member>)
Map<Long, Member> byId = members.stream()
        .collect(Collectors.toMap(Member::getId, m -> m));

// ⑦ 조건 검사 — 미성년자가 한 명이라도 있는가?
boolean hasMinor = members.stream().anyMatch(m -> m.getAge() < 20);

// ⑧ 첫 요소 찾기 — 서울에 사는 첫 회원(없을 수 있으므로 Optional)
Optional<Member> firstSeoul = members.stream()
        .filter(m -> m.getCity().equals("서울"))
        .findFirst();

"하고 싶은 것 → 연산"으로 외우면 빠르다.

#주의할 점

Stream<Member> s = members.stream();
s.count();
s.forEach(...);   // 💥 IllegalStateException — 스트림은 한 번 소비하면 재사용 불가

• 일회용: 최종 연산을 한 번 실행하면 그 스트림은 끝이다. 다시 쓰려면 members.stream()으로 새로 만든다.

• 원본 불변: 스트림은 원본 컬렉션을 바꾸지 않고 새 결과를 반환한다. (filter해도 members는 그대로)

• 지연 평가: 중간 연산(filter·map)은 쌓아 두기만 하고, 최종 연산이 호출돼야 실제로 실행된다. 그래서 최종 연산이 없으면 아무 일도 일어나지 않는다.

public List<MemberDto> findMembers() {
    return memberRepository.findAll().stream()   // List<Member>
            .map(MemberDto::from)                // 각 엔티티를 DTO로
            .toList();                           // List<MemberDto>
}

#7. Optional

null을 그냥 반환하면, 받는 쪽에서 null 검사를 깜빡해 NullPointerException(NPE) 이 터지기 쉽다. Optional은 "값이 있을 수도, 없을 수도"를 명시적으로 감싸는 상자다.

// 기존 — null을 반환하면 호출부가 방심한다
Member m = repository.findById(1L);
System.out.println(m.getName());     // m이 null이면 💥 NPE

// Optional — "없을 수 있음"이 타입에 드러난다
Optional<Member> found = repository.findById(1L);
Member m = found.orElseThrow(() -> new IllegalArgumentException("회원 없음"));

자주 쓰는 처리 메서드:

#8. record

DTO나 값 객체는 보통 "데이터를 담기만" 한다. 그런데 그걸 일반 클래스로 만들면 필드·생성자·getter·equals·hashCode·toString까지 수십 줄을 써야 한다. record는 이 모든 걸 한 줄로 만들어 준다. (Java 16+)

// 기존 — 데이터 하나 담으려고 장황한 코드
public class MemberDto {
    private final String name;
    private final int age;
    public MemberDto(String name, int age) { this.name = name; this.age = age; }
    public String getName() { return name; }
    public int getAge() { return age; }
    // equals, hashCode, toString ... 까지 추가로
}

// record — 위 전체와 거의 같은 일을 한 줄로
public record MemberDto(String name, int age) {}

MemberDto dto = new MemberDto("kim", 20);
dto.name();   // 접근자는 getName()이 아니라 name() — 필드명 그대로
dto.age();    // 20

• 값이 불변(final) 이라 한 번 만들면 바뀌지 않는다.

• 생성자·접근자·equals/hashCode/toString이 자동 생성된다.

#9. 향상된 switch와 텍스트 블록

#switch 식 (Java 14+)

기존 switch는 break를 빠뜨리면 다음 case로 흘러가는(fall-through) 함정이 있었다. 화살표(->) switch는 그 위험이 없고, 값을 바로 반환할 수 있다.

// 기존 — break 누락 위험, 값 대입이 번거로움
String label;
switch (grade) {
    case 1: label = "브론즈"; break;
    case 2: label = "실버"; break;
    default: label = "기타";
}

// switch 식 — 화살표로 간결하게, 결과를 바로 반환
String label = switch (grade) {
    case 1 -> "브론즈";
    case 2 -> "실버";
    default -> "기타";
};

#텍스트 블록 (Java 15+)

여러 줄 문자열을 """ 로 감싸면 줄바꿈·따옴표를 그대로 쓸 수 있다.

// 기존 — \n과 + 로 지저분
String json = "{\n  \"name\": \"kim\",\n  \"age\": 20\n}";

// 텍스트 블록 — 보이는 그대로
String json = """
        {
          "name": "kim",
          "age": 20
        }
        """;