자바 프로젝트 심화과정

// execution( 반환타입  패키지.클래스.메서드(파라미터) )
"execution(* com.example.board.service.*.*(..))"

// 분석:
// *                         → 반환타입 무관 (void, String, List 전부)
// com.example.board.service → 이 패키지 안에 있는
// *                         → 모든 클래스 (BoardService, UserService, AdminService)
// .*                        → 모든 메서드 (write, update, delete, getList ...)
// (..)                      → 파라미터 무관 (0개든 100개든)

// 결과: service 패키지의 모든 메서드에 자동 적용!

// 다른 예시들
"execution(* com.example.board.service.BoardService.*(..))"  // BoardService만
"execution(* com.example.board.service.*.get*(..))"          // get으로 시작하는 메서드만
"execution(public * com.example.board.service.*.*(..))"       // public 메서드만

@Around("serviceLayer()")
public Object logExecutionTime(ProceedingJoinPoint jp) throws Throwable {

    // ① 실제 메서드 실행 전 코드
    log.info("메서드 시작");
    long start = System.currentTimeMillis();

    // ② jp.proceed() = 실제 메서드 실행 (필수!)
    //    BoardService.write() 같은 실제 비즈니스 로직이 여기서 실행됨
    Object result = jp.proceed();

    // ③ 실제 메서드 실행 후 코드
    long end = System.currentTimeMillis();
    log.info("메서드 완료: {}ms", end - start);

    // ④ 반드시 result 반환 (메서드의 실제 반환값)
    return result;
}

// 실행 흐름: 클라이언트가 boardService.write() 호출
// → AOP가 가로챔 → ① 실행 전 코드 → ② jp.proceed() → ③ 실행 후 코드 → ④ 결과 반환

// ProceedingJoinPoint jp 에서 꺼낼 수 있는 정보들

jp.getTarget().getClass().getSimpleName()
// → "BoardService" (어떤 클래스의 메서드인지)

jp.getSignature().getName()
// → "write" (메서드 이름)

jp.getArgs()
// → [BoardDto(title=테스트), User(id=1)] (파라미터들)

Arrays.toString(jp.getArgs())
// → "[BoardDto(title=테스트, content=내용), User(id=1)]" (문자열 변환)

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-data-jpa"
    implementation "org.springframework.boot:spring-boot-starter-webmvc"
    implementation "org.springframework.boot:spring-boot-starter-security"
    // ↓ 추가!
    implementation "org.springframework.boot:spring-boot-starter-aop"
    implementation "io.jsonwebtoken:jjwt-api:0.12.3"
    runtimeOnly "io.jsonwebtoken:jjwt-impl:0.12.3"
    runtimeOnly "io.jsonwebtoken:jjwt-jackson:0.12.3"
    compileOnly "org.projectlombok:lombok"
    runtimeOnly "org.mariadb.jdbc:mariadb-java-client"
    annotationProcessor "org.projectlombok:lombok"
    testImplementation "org.springframework.boot:spring-boot-starter-test"
}

@Slf4j           // log.info() 자동 생성 (Lombok)
@Aspect          // 이 클래스가 AOP 클래스임을 선언
@Component       // Spring Bean으로 등록
public class LogAspect {

    // service 패키지의 모든 클래스, 모든 메서드에 적용
    @Pointcut("execution(* com.example.board.service.*.*(..))")
    public void serviceLayer() {}

    // ① 실행 전후 처리 — 실행시간 측정
    @Around("serviceLayer()")
    public Object logExecutionTime(ProceedingJoinPoint jp) throws Throwable {
        String className = jp.getTarget().getClass().getSimpleName();
        String methodName = jp.getSignature().getName();

        log.info("[START] {}.{}() - 파라미터: {}",
            className, methodName, Arrays.toString(jp.getArgs()));

        long start = System.currentTimeMillis();
        Object result = jp.proceed();   // 실제 메서드 실행 (필수!)
        long time = System.currentTimeMillis() - start;

        log.info("[END] {}.{}() - 실행시간: {}ms", className, methodName, time);
        return result;
    }

    // ② 예외 발생 시에만 실행
    @AfterThrowing(pointcut = "serviceLayer()", throwing = "ex")
    public void logException(JoinPoint jp, Exception ex) {
        log.error("[EXCEPTION] {}.{}() - {} : {}",
            jp.getTarget().getClass().getSimpleName(),
            jp.getSignature().getName(),
            ex.getClass().getSimpleName(),
            ex.getMessage());
    }
}

@Getter
public class CustomException extends RuntimeException {
    // RuntimeException 상속 = @Transactional 자동 롤백!
    private final HttpStatus status;
    private final String message;

    // 자주 쓰는 예외 — 정적 팩토리 메서드
    public static CustomException notFound(String msg) {
        return new CustomException(HttpStatus.NOT_FOUND, msg);
    }
    public static CustomException badRequest(String msg) {
        return new CustomException(HttpStatus.BAD_REQUEST, msg);
    }
    public static CustomException unauthorized(String msg) {
        return new CustomException(HttpStatus.UNAUTHORIZED, msg);
    }
}

@RestControllerAdvice  // 모든 Controller 예외를 여기서 처리
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomException.class)
    public ResponseEntity<?> handleCustom(CustomException e) {
        return ResponseEntity.status(e.getStatus())
            .body(Map.of("status", e.getStatus().value(),
                         "message", e.getMessage()));
    }

    @ExceptionHandler(IllegalArgumentException.class)  // 기존 코드 호환성 유지
    public ResponseEntity<?> handleIllegal(IllegalArgumentException e) {
        return ResponseEntity.badRequest()
            .body(Map.of("status", 400,
                         "message", e.getMessage()));
    }

    @ExceptionHandler(Exception.class)  // 안전망
    public ResponseEntity<?> handleAll(Exception e) {
        return ResponseEntity.internalServerError()
            .body(Map.of("status", 500,
                         "message", "서버 오류가 발생했습니다."));
    }
}

// 없는 게시글 조회 시 (404)
{ "status": 404, "message": "없는 게시글입니다." }

// 잘못된 비밀번호 (400)
{ "status": 400, "message": "아이디 또는 비밀번호가 틀렸습니다." }

// 수정 권한 없음 (403)
{ "status": 403, "message": "수정 권한이 없습니다." }

// 서버 오류 (500)
{ "status": 500, "message": "서버 오류가 발생했습니다." }

@Getter @Builder @NoArgsConstructor @AllArgsConstructor
public class BoardDto {
    private Long id;
    private String title;
    private String content;
    private String nickname;
}

// BoardService - Entity → DTO 변환
private BoardDto toDto(Board board) {
    return BoardDto.builder()
        .id(board.getId())
        .title(board.getTitle())
        .content(board.getContent())
        .nickname(board.getUser().getNickname())
        .build();
}

// Lombok이 자동으로 만들어주는 것 — 직접 작성 불필요
public static BoardDtoBuilder builder() { return new BoardDtoBuilder(); }

public static class BoardDtoBuilder {
    private Long id;
    private String title;
    private String content;
    private String nickname;

    public BoardDtoBuilder id(Long id)       { this.id = id;           return this; }
    public BoardDtoBuilder title(String t)    { this.title = t;         return this; }
    public BoardDtoBuilder content(String c)  { this.content = c;       return this; }
    public BoardDtoBuilder nickname(String n) { this.nickname = n;      return this; }
    public BoardDto        build()            { return new BoardDto(id, title, content, nickname); }
}

@Getter @Setter
@Builder            // ← 추가!
@NoArgsConstructor
@AllArgsConstructor  // ← 추가! (@Builder 필수)
public class UserDto {
    private Long id;
    private String username;
    private String password;
    private String nickname;
    private String role;
    private String adminCode;
}

// AdminService.getAllUsers() — Builder 사용 예시
public List<UserDto> getAllUsers() {
    return userRepository.findAll().stream()
        .map(user -> UserDto.builder()
            .id(user.getId())
            .username(user.getUsername())
            .nickname(user.getNickname())
            .role(user.getRole())
            .build())    // Setter 방식보다 훨씬 명확!
        .collect(Collectors.toList());
}