public class VerificationService {

    public void createAndSendCode(String email, VerificationType type) {
        // 1. 인증 코드 생성 및 Redis 저장 (0.1초)
        String code = generateRandomCode();
        redisService.saveCode(email, code, type);

        // 2. 이메일 발송 - SMTP 서버 응답 대기
        emailService.sendVerificationCode(email, code, type);
    }
}

public class VerificationCodeCreatedEvent extends ApplicationEvent {
    private final String email;
    private final String code;
    private final VerificationType type;

    public VerificationCodeCreatedEvent(
        Object source,
        String email,
        String code,
        VerificationType type
    ) {
        super(source);
        this.email = email;
        this.code = code;
        this.type = type;
    }

    // getters
}

@Service
@RequiredArgsConstructor
public class VerificationService {
    private final ApplicationEventPublisher eventPublisher;
    private final RedisService redisService;

    public void createAndSendCode(String email, VerificationType type) {
        // 1. Redis에 인증 코드 저장 (동기)
        String code = generateRandomCode();
        redisService.saveCode(email, code, type);

        // 2. 이벤트 발행 (비동기)
        eventPublisher.publishEvent(
            new VerificationCodeCreatedEvent(this, email, code, type)
        );
    }
}

@Component
public class VerificationCodeEventListener {
    private final EmailService emailService;

    @Async("emailTaskExecutor")  // 별도 스레드 풀에서 실행
    @EventListener
    public void handleVerificationCodeCreated(
        VerificationCodeCreatedEvent event
    ) {
        try {
            emailService.sendVerificationCode(
                event.getEmail(),
                event.getCode(),
                event.getType()
            );
        } catch (Exception e) {
            // 실패 시 재시도 로직 또는 알림 처리
        }
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean(name = "emailTaskExecutor")
    public Executor emailTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);        // 기본 스레드 수
        executor.setMaxPoolSize(5);         // 최대 스레드 수
        executor.setQueueCapacity(100);     // 대기 큐 크기
        executor.setThreadNamePrefix("email-async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  // 큐가 꽉 찼을 때: 호출한 스레드가 직접 실행
        executor.initialize();
        return executor;
    }
}

@Transactional
public void createAndSendCode(String email, VerificationType type) {
    String code = generateRandomCode();
    redisService.saveCode(email, code, type);  // 1) DB 저장

    eventPublisher.publishEvent(
        new VerificationCodeCreatedEvent(this, email, code, type)
    );
}

@Component
public class VerificationCodeEventListener {
    private final EmailService emailService;

    @Async("emailTaskExecutor")  // 별도 스레드 풀에서 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleVerificationCodeCreated(
        VerificationCodeCreatedEvent event
    ) {
        try {
            emailService.sendVerificationCode(
                event.getEmail(),
                event.getCode(),
                event.getType()
            );
        } catch (Exception e) {
            // 실패 시 재시도 로직 또는 알림 처리
        }
    }
}

GET count
+1
SET count

        Long currentAttempts = redisTemplate.opsForHash().increment(key, "attemptCount", 1);

// 인증 코드 저장 + 10분 TTL 설정
redisTemplate.opsForValue()
    .set("email:code:" + email, code, 10, TimeUnit.MINUTES);

@Service
@RequiredArgsConstructor
public class EmailVerificationService {

    private static final String KEY_PREFIX = "email:verification:"; // 키 구조
    private static final int MAX_ATTEMPTS = 5; // 최대 횟수
    private static final int CODE_EXPIRY_MINUTES = 10; // 만료 시간

    private final RedisTemplate redisTemplate;

    // 1) 인증 코드 생성 및 저장(hash)
    public String generateCode(String email) {
        String code = generateRandomCode();
        String key = KEY_PREFIX + email;

        Map data = new HashMap<>();
        data.put("code", code);
        data.put("attempts", 0);
        data.put("created_at", LocalDateTime.now().toString());

        redisTemplate.opsForHash().putAll(key, data);
        redisTemplate.expire(key, CODE_EXPIRY_MINUTES, TimeUnit.MINUTES);

        return code;
    }

    // 2) 인증 코드 검증(Redis 자체)
    public boolean verify(String email, String inputCode) {
        String key = KEY_PREFIX + email;

        // 1. 키 존재 여부 확인
        if (!Boolean.TRUE.equals(redisTemplate.hasKey(key))) {
            throw new CodeExpiredException("인증 코드가 만료되었거나 존재하지 않습니다.");
        }

        // 2. 시도 횟수 증가
        Long attempts = redisTemplate.opsForHash()
            .increment(key, "attempts", 1);

        // 3. 최대 시도 횟수 체크
        if (attempts > MAX_ATTEMPTS) {
            throw new TooManyAttemptsException(
                "인증 시도 횟수가 초과되었습니다."
            );
        }

        // 4. 코드 일치 확인
        String storedCode = (String) redisTemplate.opsForHash()
            .get(key, "code");

        if (storedCode == null) {
            throw new CodeExpiredException("인증 코드가 만료되었습니다.");
        }

        boolean isValid = storedCode.equals(inputCode);

        // 5. 인증 성공 시 즉시 삭제
        if (isValid) {
            redisTemplate.delete(key);
        }

        return isValid;
    }

    // 3) 재발급 시, 이전 코드 무효화
    public String regenerateCode(String email) {
        String key = KEY_PREFIX + email;
        redisTemplate.delete(key);
        return generateCode(email);
    }

    // 4) IP당 1분에 2번 요청 가능
    public void checkRateLimit(String ip) {
        String key = "rate:limit:" + ip;
        Long requests = redisTemplate.opsForValue().increment(key);

        if (requests == 1) { // 첫 요청 시 TTL 설정
        redisTemplate.expire(key, 1, TimeUnit.MINUTES);
        }

        if (requests > 2) {
            throw new RateLimitExceededException("너무 많은 요청입니다. 1분 후 다시 시도하세요.");
         }
    }

    // 5) 인증코드 생성
    private String generateRandomCode() {
        return RandomStringUtils.randomAlphanumeric(6).toUpperCase();
    }
}

Long attempts = redisTemplate.opsForHash()
    .increment(key, "attempts", 1);

// 키 존재 여부 먼저 체크
if (!Boolean.TRUE.equals(redisTemplate.hasKey(key))) {
    throw new CodeExpiredException("인증 코드가 만료되었습니다.");
}

// 이후 increment 실행

public interface UserRepository extends JpaRepository {
    Page findByClientCompanyNameContaining(String companyName, Pageable pageable);
    Page findByLastLoginAtBetween(LocalDateTime start, LocalDateTime end, Pageable pageable);
}

// Specification 사용을 위해 상속만 추가
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {}

public class UserSpecification {
    public static Specification<User> filterClients(
            LocalDate startDate,
            LocalDate endDate,
            String range,
            String keyword) {

        return (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();
	        ...
        }
    }
}

@PostMapping("/login")
public ResponseEntity login(@RequestBody LoginDto req) {
    // Controller에서 직접 처리
}

if (user.isLocked()) {
    throw new AccountLockedException("계정이 잠겼습니다.");
}

if (user.isFirstLogin()) {
    return new FirstLoginResponse("비밀번호를 변경하세요.");
}

if (!passwordEncoder.matches(req.getPassword(), user.getPassword())) {
    user.incrementFailCount();
    if (user.getFailCount() >= 5) {
        user.lock();
    }
    userRepository.save(user);
    throw new BadCredentialsException("아이디 또는 비밀번호 틀렸습니다.");
}

// AuthenticationManager를 수동으로 호출
UsernamePasswordAuthenticationToken authToken =
    new UsernamePasswordAuthenticationToken(
        req.getEmail(),
        req.getPassword(),
        user.getAuthorities()
    );
Authentication authentication = authenticationManager.authenticate(authToken);

// SessionAuthenticationStrategy 수동 호출
sessionAuthenticationStrategy.onAuthentication(authentication, request, response);

SecurityContext context = securityContextHolderStrategy.createEmptyContext();
context.setAuthentication(authentication);
SecurityContextHolder.setContext(context);
securityContextRepository.saveContext(context, request, response);

@Entity
@Table(name = "users")
@EqualsAndHashCode(of = "email", callSuper = false)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class User implements UserDetails {
    //...
}

    @Transactional
    public LoginResponse login(LoginDto req, HttpServletRequest request,
                                HttpServletResponse response) {

        // 1. 사용자 조회
        User user = userRepository.findByEmail(req.getEmail())
            .orElseThrow(() -> new UsernameNotFoundException("사용자를 찾을 수 없습니다."));

        // 2. 계정 잠김 체크
        if (user.isLocked()) {
            throw new AccountLockedException("계정이 잠겼습니다. 관리자에게 문의하세요.");
        }

        // 3. 계정 활성화 체크
        if (!user.isEnabled()) {
            throw new DisabledException("비활성화된 계정입니다.");
        }

        // 4. 비밀번호 검증
        if (!passwordEncoder.matches(req.getPassword(), user.getPassword())) {
            user.incrementFailCount();
            userRepository.save(user);

            if (user.isLocked()) {
                throw new AccountLockedException(
                    "5회 실패로 계정이 잠겼습니다. 관리자에게 문의하세요."
                );
            }

            throw new BadCredentialsException(
                String.format("아이디 또는 비밀번호가 틀렸습니다. (남은 시도: %d회)",
                              5 - user.getFailCount())
            );
        }

        // 5. 첫 로그인 체크
        if (user.isFirstLogin()) {
            return LoginResponse.firstLogin("비밀번호를 변경해야 합니다.");
        }

        // 6. Spring Security 인증 실행
        performSecurityAuthentication(req, user, request, response);

        // 7. 로그인 성공 처리
        user.resetFailCount();
        userRepository.save(user);

        return LoginResponse.success(user);
    }

    private void performSecurityAuthentication(LoginDto req, User user,
                                                HttpServletRequest request,
                                                HttpServletResponse response) {

        // 1. AuthenticationManager를 통한 인증
        UsernamePasswordAuthenticationToken authToken =
            new UsernamePasswordAuthenticationToken(
                req.getEmail(),
                req.getPassword(),
                user.getAuthorities()
            );

        Authentication authentication = authenticationManager.authenticate(authToken);

        // 2. SessionAuthenticationStrategy 호출 (세션 정책 적용) → SessionRegistry 등록
        sessionAuthenticationStrategy.onAuthentication(authentication, request, response);

        // 3. SecurityContext 생성 및 설정
        SecurityContext context = securityContextHolderStrategy.createEmptyContext();
        context.setAuthentication(authentication);
        SecurityContextHolder.setContext(context);

        // 4. SecurityContextRepository에 저장 (HttpSession에 저장됨)
        securityContextRepository.saveContext(context, request, response);
    }

    public HttpSessionEventPublisher httpSessionEventPublisher() {
        return new HttpSessionEventPublisher() {
            @Override
            public void sessionCreated(HttpSessionEvent event) {
                super.sessionCreated(event);
            }

            @Override
            public void sessionDestroyed(HttpSessionEvent event) {
                super.sessionDestroyed(event);
            }
        };
    }

    public ServletListenerRegistrationBean
            httpSessionEventPublisherRegistration() {
        return new ServletListenerRegistrationBean<>(httpSessionEventPublisher());
    }

    public SessionRegistry sessionRegistry() {
        return new SessionRegistryImpl() {
            @Override
            public void registerNewSession(String sessionId, Object principal) {
                super.registerNewSession(sessionId, principal);
            }

            @Override
            public void removeSessionInformation(String sessionId) {
                SessionInformation info = getSessionInformation(sessionId);
                super.removeSessionInformation(sessionId);
            }

            private String extractPrincipalName(Object principal) {
                if (principal instanceof User) {
                    return ((User) principal).getEmail();
                }
                return principal.toString();
            }
        };
    }

    public SessionAuthenticationStrategy sessionAuthenticationStrategy(
            SessionRegistry sessionRegistry) {

        // 3-1) 동시 로그인 개수 제한
        ConcurrentSessionControlAuthenticationStrategy concurrentControl =
            new ConcurrentSessionControlAuthenticationStrategy(sessionRegistry);
        concurrentControl.setMaximumSessions(1);  // 동일 계정 1명만
        concurrentControl.setExceptionIfMaximumExceeded(false);  // 기존 세션 만료

        // 3-2) 세션 고정 공격 방지 (세션 ID 재발급)
        SessionFixationProtectionStrategy sessionFixation =
            new SessionFixationProtectionStrategy();
        sessionFixation.setMigrateSessionAttributes(true);

        // 3-3) SessionRegistry에 세션 등록
        RegisterSessionAuthenticationStrategy registerSession =
            new RegisterSessionAuthenticationStrategy(sessionRegistry);

        // 3가지 전략을 Composite로 통합
        return new CompositeSessionAuthenticationStrategy(Arrays.asList(
            concurrentControl,
            sessionFixation,
            registerSession
        ));
    }

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        .csrf(csrf -> csrf.disable())  // REST API는 CSRF 불필요

        // SecurityContext 저장 방식 설정
        .securityContext(context -> context
            .securityContextRepository(securityContextRepository())
            .requireExplicitSave(true)  // 명시적 저장 (Controller에서 수동 저장)
        )

        // 세션 관리 설정
        .sessionManagement(session -> session
            .sessionFixation().changeSessionId()  // 세션 고정 공격 방지
            .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
            .maximumSessions(1)  // 동일 계정 1명만
            .maxSessionsPreventsLogin(false)  // 기존 세션 만료 방식
            .sessionRegistry(sessionRegistry())
            .expiredSessionStrategy(customSessionExpiredStrategy())  // 만료 시 처리
        )

        // 예외 처리
        .exceptionHandling(ex -> ex
            .authenticationEntryPoint(authenticationDeniedHandler())  // 401
            .accessDeniedHandler(authorizationDeniedHandler())  // 403
        )

        // 커스텀 필터 추가
        .addFilterBefore(sessionExpiredFilter(), SecurityContextPersistenceFilter.class)
        .addFilterBefore(improvedLogoutFilter(), LogoutFilter.class);

    return http.build();
}