REST API 완전 정복

// 사용자 정보: { name: "라희", email: "[email protected]", age: 30 }

// PUT → 전체를 새 데이터로 통째로 교체
PUT /users/1
{ name: "라희2", email: "[email protected]", age: 30 }  // 전부 보내야 함

// PATCH → 일부만 수정
PATCH /users/1
{ name: "라희2" }  // name만 바꾸고 나머지는 그대로

User 객체       →  {"id":1,"name":"라희"}
List<User>      →  [{"id":1},{"id":2}]
Map<String,Object> →  {"key":"value"}

@RestController
@RequestMapping("/users")  // 기본 경로 — 아래 모든 메서드 URL 앞에 자동으로 붙음
public class UserController {

  @GetMapping("/{id}")   // 실제 URL → /users/{id}
  public User 조회() { }

  @PostMapping           // 실제 URL → /users
  public User 생성() { }
}

@GetMapping("/{id}")     // GET    /users/1   조회
@PostMapping              // POST   /users     생성
@PutMapping("/{id}")     // PUT    /users/1   전체 수정
@PatchMapping("/{id}")   // PATCH  /users/1   부분 수정
@DeleteMapping("/{id}") // DELETE /users/1   삭제

// 이것들은 전부 @RequestMapping의 단축 버전
// 아래 두 개는 완전히 같음
@GetMapping("/users")
@RequestMapping(value="/users", method=RequestMethod.GET)

// GET /users/1
@GetMapping("/{id}")
public User 조회(@PathVariable int id) {
    // id = 1
}

// GET /users/1/orders/5 — 여러 개도 가능
@GetMapping("/{userId}/orders/{orderId}")
public Order 주문조회(@PathVariable int userId,
                     @PathVariable int orderId) {
    // userId = 1, orderId = 5
    // 변수명이 {} 안과 같아야 자동 매핑됨
}

// GET /users?name=라희&age=30
@GetMapping
public List<User> 검색(
    @RequestParam String name,    // name = "라희"
    @RequestParam int age) {      // age = 30
}

// 필수가 아닌 경우 (없어도 됨)
@RequestParam(required = false) String name

// 기본값 지정
@RequestParam(defaultValue = "1") int page

// POST /users
// Body: {"name":"라희","email":"[email protected]"}
@PostMapping
public User 생성(@RequestBody User user) {
    // user.getName() = "라희"
    // user.getEmail() = "[email protected]"
    // Jackson이 자동으로 JSON → 자바 객체로 변환
    // @ResponseBody의 반대 방향
    return userService.save(user);
}

@GetMapping("/users")
public User 조회(@RequestHeader("Authorization") String token) {
    // token = "Bearer eyJhbGci..."
    // 로그인 토큰을 헤더에서 꺼낼 때 주로 사용
}

// HTTP 요청 구조:
// Header → 부가 정보 (토큰, 콘텐츠 타입 등)
// Body   → 실제 데이터

// 단순히 객체만 리턴 → 상태코드 200이 자동으로 붙음
@GetMapping("/{id}")
public User 조회(@PathVariable int id) {
    return userService.findById(id);
}

// ResponseEntity로 상태코드까지 직접 제어 (권장)
@GetMapping("/{id}")
public ResponseEntity<User> 조회(@PathVariable int id) {
    User user = userService.findById(id);
    if (user == null) {
        return ResponseEntity.notFound().build();    // 404
    }
    return ResponseEntity.ok(user);                // 200 + JSON
}

@PostMapping
public ResponseEntity<User> 생성(@RequestBody User user) {
    User saved = userService.save(user);
    return ResponseEntity.status(201).body(saved);  // 201 + JSON
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> 삭제(@PathVariable int id) {
    userService.delete(id);
    return ResponseEntity.noContent().build();     // 204
}

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;

    // GET /users/1 → 1번 사용자 조회
    @GetMapping("/{id}")
    public ResponseEntity<UserResponse> 조회(@PathVariable int id) {
        return ResponseEntity.ok(userService.사용자조회(id));
    }

    // GET /users?name=라희&page=0 → 검색 + 페이징
    @GetMapping
    public ResponseEntity<List<UserResponse>> 목록(
            @RequestParam(required = false) String name,
            @RequestParam(defaultValue = "0") int page) {
        return ResponseEntity.ok(userService.목록조회(name, page));
    }

    // POST /users → 회원가입
    @PostMapping
    public ResponseEntity<UserResponse> 회원가입(
            @Valid @RequestBody UserCreateRequest request) {
        return ResponseEntity.status(201)
            .body(userService.회원가입(request));
    }

    // PUT /users/1 → 전체 수정
    @PutMapping("/{id}")
    public ResponseEntity<UserResponse> 수정(
            @PathVariable int id,
            @Valid @RequestBody UserUpdateRequest request) {
        return ResponseEntity.ok(userService.수정(id, request));
    }

    // DELETE /users/1 → 삭제
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> 삭제(@PathVariable int id) {
        userService.삭제(id);
        return ResponseEntity.noContent().build();
    }
}

@Service
public class UserService { }

// @Component의 특수 버전. 기능은 @Component와 같음 → 스프링 빈으로 등록
// @Service를 쓰는 이유 → "이 클래스는 비즈니스 로직을 담당한다"는 의도를 명확하게 표현

@Service
public class UserService {

    private final UserRepository userRepository;
    private final EmailService emailService;

    // 생성자 주입
    public UserService(UserRepository userRepository,
                       EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

// Lombok @RequiredArgsConstructor 쓰면 생성자 코드 자동 생성
@Service
@RequiredArgsConstructor  // ← 이 한 줄로 위 생성자 코드 대체
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
}

@Service
public class AccountService {

    @Transactional  // 이 메서드 전체가 하나의 트랜잭션
    public void 송금(int 출금계좌, int 입금계좌, int 금액) {
        accountRepository.출금(출금계좌, 금액);  // ①
        accountRepository.입금(입금계좌, 금액);  // ②에서 에러나면 ①도 rollback
    }
}

// 읽기 전용 (조회할 때 권장) — 성능 최적화 + 실수로 수정하는 것 방지
@Transactional(readOnly = true)
public User 조회(int id) { }

// 에러 발생해도 rollback 안 하고 싶을 때
@Transactional(noRollbackFor = 특정Exception.class)
public void 처리() { }

// 트랜잭션 전파 옵션
@Transactional(propagation = Propagation.REQUIRES_NEW)
// 항상 새 트랜잭션 시작 (기존 트랜잭션과 분리)

@Service
public class OrderService {
    @Transactional
    public void 주문하기() {
        orderRepository.save(주문);
        userService.포인트차감();  // ← UserService 호출
    }
}

@Service
public class UserService {
    @Transactional  // ← 이미 트랜잭션이 있는데 어떻게 되나?
    public void 포인트차감() { }
}

@Service
public class UserService {

    @Transactional
    public User 회원가입(User user) {
        if (userRepository.existsByEmail(user.getEmail())) {
            throw new DuplicateEmailException("이미 있는 이메일");
        }
        return userRepository.save(user);
    }
}

// 커스텀 예외 — RuntimeException 상속해야 자동 rollback!
public class DuplicateEmailException extends RuntimeException {
    public DuplicateEmailException(String message) {
        super(message);
    }
}

// 인터페이스
public interface UserService {
    User 사용자조회(int id);
    User 회원가입(User user);
}

// 실제 구현체
@Service
public class UserServiceImpl implements UserService {

    @Override
    public User 사용자조회(int id) { ... }

    @Override
    public User 회원가입(User user) { ... }
}

// 언제 이렇게 나누냐?
// ① 나중에 구현체를 바꿔도 Controller는 그대로 (인터페이스만 보니까)
// ② 테스트할 때 가짜 구현체(Mock)로 교체하기 쉬움
// ③ 구현체가 하나뿐이면 굳이 나눌 필요 없음 (요즘 추세)

// 우리가 쓰는 코드
@Transactional
public User 회원가입(User user) {
    return userRepository.save(user);
}

// 스프링이 내부적으로 하는 일 (AOP @Around와 완전히 동일)
public User 회원가입(User user) {
    트랜잭션시작();          // Before
    try {
        Object r = 진짜회원가입(user); // jp.proceed()
        트랜잭션커밋();         // 성공시
        return (User) r;
    } catch (Exception e) {
        트랜잭션롤백();         // 실패시
        throw e;
    }
}
// @Transactional 붙이면 스프링이 Proxy를 만들어서
// 트랜잭션 시작/커밋/롤백을 자동으로 앞뒤에 끼워줌
// AOP 배울 때 나온 Proxy, @Around 개념이 여기서 쓰이는 것!

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;
    private final EmailService emailService;
    private final PasswordEncoder passwordEncoder;

    // 조회 — readOnly = true 로 성능 최적화
    @Transactional(readOnly = true)
    public User 사용자조회(int id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("없는 사용자"));
    }

    // 회원가입
    @Transactional
    public User 회원가입(User user) {
        if (userRepository.existsByEmail(user.getEmail())) {
            throw new DuplicateEmailException("이미 있는 이메일");
        }
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        User saved = userRepository.save(user);
        emailService.send(saved.getEmail(), "환영합니다!");
        return saved;
    }

    // 수정 — 변경 감지(Dirty Checking)로 자동 UPDATE
    @Transactional
    public User 수정(int id, User 수정데이터) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("없는 사용자"));
        user.setName(수정데이터.getName());
        // save() 안 해도 트랜잭션 끝날 때 자동 UPDATE
        return user;
    }

    // 삭제
    @Transactional
    public void 삭제(int id) {
        if (!userRepository.existsById(id)) {
            throw new UserNotFoundException("없는 사용자");
        }
        userRepository.deleteById(id);
    }
}