import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectConfig {
  // DB 에 저장된 암호를 해싱하는 암호 인코더 정의
  @Bean
  public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
  }

  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        .csrf(c -> c.disable()) // POST 를 포함한 모든 엔드포인트를 호출할 수 있게 csrf 비활성화
        .authorizeHttpRequests(authz -> authz.anyRequest().permitAll());  // 인증없이 모든 호출 허용

    return http.build();
  }
}

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Lob;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@ToString
@Getter
@Setter
@Entity
public class User {

  @Id
  private String username;

  @Lob
  private String password;
}

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@ToString
@Getter
@Setter
@Entity
public class Otp {

  @Id
  private String username;

  private String code;
}

import com.assu.study.chap1101.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, String> {
  Optional<User> findByUsername(String username);
}

import com.assu.study.chap1101.entity.Otp;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface OtpRepository extends JpaRepository<Otp, String> {
  Optional<Otp> findByUsername(String username);
}

import com.assu.study.chap1101.entity.User;
import com.assu.study.chap1101.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@RequiredArgsConstructor
@Transactional
@Service
public class UserService {

  private final PasswordEncoder passwordEncoder;
  private final UserRepository userRepository;

  // 사용자 추가
  public void addUser(User user) {
    user.setPassword(passwordEncoder.encode(user.getPassword()));
    userRepository.save(user);
  }
}

import lombok.NoArgsConstructor;

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

@NoArgsConstructor
public final class GenerateCodeUtil {
  
  public static String generateCode() {
    String code;

    try {
      // 임의의 int 값을 생성하는 SecureRandom 인스턴스 생성
      SecureRandom random = SecureRandom.getInstanceStrong();
      
      // 0~8,999 사이의 값을 생성하고 1,000을 더해서 1,000~9,999 (4자리 코드) 사이의 값 얻음
      int c = random.nextInt(9000) + 1000;
      
      // int 를 String 응로 변환하여 반환
      code = String.valueOf(c);
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException("Error when generating the random code.");
    }

    return code;
  }
}

import com.assu.study.chap1101.entity.Otp;
import com.assu.study.chap1101.entity.User;
import com.assu.study.chap1101.repository.OtpRepository;
import com.assu.study.chap1101.repository.UserRepository;
import com.assu.study.chap1101.util.GenerateCodeUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

@RequiredArgsConstructor
@Transactional
@Service
public class UserService {

  private final PasswordEncoder passwordEncoder;
  private final UserRepository userRepository;
  private final OtpRepository otpRepository;

  // ...

  // 사용자 인증 후 OTP 생성하여 SMS 를 통해 발송
  public void auth(User user) {
    Optional<User> oUser = userRepository.findByUsername(user.getUsername());

    // 사용자가 있으면 암호를 확인 후 새로운 OTP 생성
    // 사용자가 없거나 암호가 틀리면 예외 발생
    if (oUser.isPresent()) {
      User u = oUser.get();
      if (passwordEncoder.matches(user.getPassword(), u.getPassword())) {
        renewOtp(u);
      } else {
        throw new BadCredentialsException("Bad Credentials");
      }
    } else {
      throw new BadCredentialsException("Bad Credentials");
    }
  }

  private void renewOtp(User user) {
    String code = GenerateCodeUtil.generateCode();

    Optional<Otp> userOtp = otpRepository.findByUsername(user.getUsername());

    // 이 사용자에 대한 otp 가 있으면 otp 값 업데이트
    Otp otp;
    if (userOtp.isPresent()) {
      otp = userOtp.get();
    } else {
      otp = new Otp();
      // 이 사용자에 대한 opt 가 없으면 새로 생성된 값으로 레코드 생성
      otp.setUsername(user.getUsername());
    }
    otp.setCode(code);

    otpRepository.save(otp);
  }
}

import com.assu.study.chap1101.entity.Otp;
import com.assu.study.chap1101.repository.OtpRepository;
import com.assu.study.chap1101.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

@RequiredArgsConstructor
@Transactional
@Service
public class UserService {

  private final PasswordEncoder passwordEncoder;
  private final UserRepository userRepository;
  private final OtpRepository otpRepository;

  // ...
  
  // 사용자의 OTP 검증
  public boolean check(Otp otp) {
    // 사용자 이름으로 OTP 검색
    Optional<Otp> userOtp = otpRepository.findByUsername(otp.getUsername());

    if (userOtp.isPresent()) {
      Otp o = userOtp.get();
      // DB 에 OTP 가 있고, 비즈니스 논리 서버에서 받은 OTP 와 일차하면 true 반환
      return otp.getCode().equals(o.getCode());
    }
    return false;
  }
}

import com.assu.study.chap1101.entity.Otp;
import com.assu.study.chap1101.entity.User;
import com.assu.study.chap1101.service.UserService;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RequiredArgsConstructor
@RestController
public class AuthController {

  private final UserService userService;

  // 사용자 추가
  @PostMapping("/user/add")
  public void addUser(@RequestBody User user) {
    userService.addUser(user);
  }

  // 사용자 인증 후 OTP 생성하여 SMS 를 통해 발송
  @PostMapping("/user/auth")
  public void auth(@RequestBody User user) {
    userService.auth(user);
  }

  // 사용자의 OTP 검증
  @PostMapping("/otp/check")
  public void check(@RequestBody Otp otp, HttpServletResponse response) {
    if (userService.check(otp)) {
      response.setStatus(HttpServletResponse.SC_OK);
    } else {
      response.setStatus(HttpServletResponse.SC_FORBIDDEN); // 403
    }
  }
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
  @GetMapping("/hello")
  public String hello() {
    return "hello";
  }
}

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;

import java.util.Collection;

/**
 * 사용자 이름/암호를 이용한 인증을 구현하는 클래스
 * Authentication 는 간접적으로 확장됨
 */
public class UsernamePasswordAuthentication extends UsernamePasswordAuthenticationToken {

  /**
   * 인증 인스턴스가 인증되지 않은 상태로 유지됨
   * 
   * Authentication 객체가 인증 상태로 설정되지 않고, 프로세스 중 예외로 발생하지 않았다면 
   * AuthenticationManager 는 요청을 인증할 AuthenticationProvider 객체를 찾음
   */
  public UsernamePasswordAuthentication(Object principal, Object credentials) {
    super(principal, credentials);
  }

  /**
   * Authentication 객체가 인증됨 (= 인증 프로세스가 완료됨)
   * 
   * AuthenticationProvider 객체가 요청을 인증할 때는 이 생성자를 호출하여 Authentication 인스턴스를 만들고, 
   * 이 때는 인증된 객체가 됨
   * 
   * @param authorities 허가된 권한의 컬렉션이며, 완료된 인증 프로세스에서는 필수임
   */
  public UsernamePasswordAuthentication(Object principal, Object credentials, Collection<? extends GrantedAuthority> authorities) {
    super(principal, credentials, authorities);
  }
}

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

/**
 * 사용자 이름/OTP를 이용한 인증을 구현하는 클래스
 * Authentication 는 간접적으로 확장됨
 */
public class OtpAuthentication extends UsernamePasswordAuthenticationToken {
  public OtpAuthentication(Object principal, Object credentials) {
    super(principal, credentials);
  }

//  public OtpAuthentication(Object principal, Object credentials, Collection<? extends GrantedAuthority> authorities) {
//    super(principal, credentials, authorities);
//  }
}

import lombok.Getter;
import lombok.Setter;

/**
 * 인증 서버가 노출하는 REST API 를 호출할 때 사용할 모델 클래스
 */
@Getter
@Setter
public class User {
  private String username;
  private String password;
  private String code;
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * 인증 서버가 노출하는 REST API 를 호출하는데 이용할 RestTemplate 형식의 빈 선언
 */
@Configuration
public class ProjectConfig {
  @Bean
  public RestTemplate restTemplate() {
    return new RestTemplate();
  }
}

import com.assu.study.chap1102.authtication.model.User;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

@RequiredArgsConstructor
@Component  // 이 형식의 인스턴스를 컨텍스트에 포함시킴
public class AuthenticationServerProxy {

  private final RestTemplate restTemplate;

  @Value("${auth.server.base.url}")
  private String baseUrl;

  /**
   * 사용자 이름/암호 인증을 수행
   */
  public void sendAuth(String username, String password) {
    String url = baseUrl + "/user/auth";

    User body = new User();
    body.setUsername(username);
    body.setPassword(password);

    HttpEntity request = new HttpEntity<>(body);

    restTemplate.postForEntity(url, request, Void.class);
  }

  /**
   * 사용자 이름/OTP 인증을 수행
   */
  public boolean sendOtp(String username, String code) {
    String url = baseUrl + "/otp/check";

    User body = new User();
    body.setUsername(username);
    body.setCode(code);

    HttpEntity request = new HttpEntity<>(body);

    ResponseEntity response = restTemplate.postForEntity(url, request, Void.class);

    return response.getStatusCode().equals(HttpStatus.OK);
  }
}

import com.assu.study.chap1102.authtication.UsernamePasswordAuthentication;
import com.assu.study.chap1102.authtication.proxy.AuthenticationServerProxy;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.stereotype.Component;

/**
 * 사용자 이름/암호의 인증 논리 구현 클래스
 */
@RequiredArgsConstructor
@Component  // 이 형식의 인스턴스를 컨텍스트에 포함시킴
public class UsernamePasswordAuthenticationProvider implements AuthenticationProvider {

  private final AuthenticationServerProxy authenticationServerProxy;

  @Override
  public Authentication authenticate(Authentication authentication) throws AuthenticationException {
    String username = authentication.getName();
    String password = String.valueOf(authentication.getCredentials());

    // 프록시를 통해 인증 서버로 사용자 이름/암호 인증 요청
    // 인증이 되면 인증 서버는 SMS 로 클라이언트에게 OTP 전송
    authenticationServerProxy.sendAuth(username, password);

    return new UsernamePasswordAuthenticationToken(username, password);
  }

  /**
   * AuthenticationProvider 가 어떤 종류의 Authentication 인터페이스를 지원할 지 결정
   * 이는 authenticate() 메서드의 매개 변수로 어떤 형식이 제공될지에 따라서 달라짐
   * <p>
   * AuthenticationFilter 수준에서 아무것도 맞춤 구성하지 않으면 UsernamePasswordAuthenticationToken 클래스가 형식을 정의함
   */
  @Override
  public boolean supports(Class<?> authentication) {
    return UsernamePasswordAuthentication.class.isAssignableFrom(authentication);
  }
}

import com.assu.study.chap1102.authtication.OtpAuthentication;
import com.assu.study.chap1102.authtication.proxy.AuthenticationServerProxy;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.stereotype.Component;

/**
 * 사용자 이름/OTP의 인증 논리 구현 클래스
 */
@RequiredArgsConstructor
@Component  // 이 형식의 인스턴스를 컨텍스트에 포함시킴
public class OtpAuthenticationProvider implements AuthenticationProvider {

  private final AuthenticationServerProxy authenticationServerProxy;

  @Override
  public Authentication authenticate(Authentication authentication) throws AuthenticationException {
    String username = authentication.getName();
    String code = String.valueOf(authentication.getCredentials());

    boolean result = authenticationServerProxy.sendOtp(username, code);

    // OTP 가 맞으면 Authentication 인스턴스를 반환하고, 필터가 HTTP 응답에 토큰을 보냄
    if (result) {
      // 아직 `Authentication` 객체가 인증된 상태가 아니므로
      // 매개 변수가 2개인
      // `OtpAuthentication(Object principal, Object credentials)` 생성자를 이용하여
      // `Authentication` 객체 생성
      return new OtpAuthentication(username, code);
    } else {
      // OTP 가 틀리면 예외 발생
      throw new BadCredentialsException("bad credentials");
    }
  }

  /**
   * AuthenticationProvider 가 어떤 종류의 Authentication 인터페이스를 지원할 지 결정
   * 이는 authenticate() 메서드의 매개 변수로 어떤 형식이 제공될지에 따라서 달라짐
   * <p>
   * AuthenticationFilter 수준에서 아무것도 맞춤 구성하지 않으면 UsernamePasswordAuthenticationToken 클래스가 형식을 정의함
   */
  @Override
  public boolean supports(Class<?> authentication) {
    return OtpAuthentication.class.isAssignableFrom(authentication);
  }
}

import com.assu.study.chap1102.authtication.OtpAuthentication;
import com.assu.study.chap1102.authtication.UsernamePasswordAuthentication;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.crypto.SecretKey;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;

@RequiredArgsConstructor
@Component
public class InitialAuthenticationFilter extends OncePerRequestFilter {

  // 인증 관리자, 인증 책임을 위임
  private final AuthenticationManager authenticationManager;

  @Value("${jwt.signing.key}")
  private String SIGNING_KEY;

  /**
   * 요청이 필터 체인에서 이 필터에 도달할 때 호출됨
   * <p>
   * OTP 를 얻기 위해 사용자 이름/암호를 보내는 인증 논리 구현
   */
  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    // HTTP 요청 헤더를 통해 자격 인증 정보가 넘어옴
    String username = request.getHeader("username");
    String password = request.getHeader("password");
    String code = request.getHeader("code");

    // 헤더에 OTP 가 없으면 사용자 이름/암호 인증으로 가정
    if (code == null) {
      Authentication authentication = new UsernamePasswordAuthentication(username, password);

      // 따라서 OTP 가 없으면 UsernamePasswordAuthentication 인스턴스를 만든 후 책임을 AuthenticationManager 에게 전달하여 첫 번째 인증단계 호출
      // AuthenticationManager 는 해당하는 AuthenticationProvider 를 찾음
      // UsernamePasswordAuthenticationProvider.supports() 가 UsernamePasswordAuthentication 형식을 받는다고
      // 선언하였으므로 UsernamePasswordAuthenticationProvider 로 인증 책임을 위임함
      authenticationManager.authenticate(authentication);
    } else {
      // 헤더에 OTP 가 있으면 사용자 이름/OTP 인증 단계라고 가정
      // OtpAuthentication 형식의 인스턴스를 만든 후 책임을 AuthenticationManager 에게 전달하여 두 번째 인증단계 호출
      Authentication authentication = new OtpAuthentication(username, code);
      authenticationManager.authenticate(authentication);

      // OtpAuthenticationProvider 에 OTP 가 틀리면 인증이 실패하면서 예외가 발생하므로
      // OTP 가 유효할 때만 JWT 토큰이 생성되고, HTTP 응답 헤더에 포함됨

      // 대칭키로 서명 생성
      SecretKey key = Keys.hmacShaKeyFor(SIGNING_KEY.getBytes(StandardCharsets.UTF_8));

      // TODO: deprecated
      // JWT 생성 후 인증된 사용자의 이름을 클레임 중 하나로 저장함
      // 토큰을 서명하는데 키를 이용함
      String jwt = Jwts.builder()
              .setClaims(Map.of("username", username))  // 본문에 값 추가
              .signWith(key)  // 비대칭키로 토큰에 서명 첨부
              .compact();

      // 토큰을 HTTP 응답의 권한 부여 헤더에 추가
      response.setHeader("Authorization", jwt);
    }
  }

  /**
   * /login 경로가 아니면 이 필터를 실행하지 않음
   */
  @Override
  protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
    return !request.getServletPath().equals("/login");
  }
}

// 대칭키로 서명 생성
SecretKey key = Keys.hmacShaKeyFor(SIGNING_KEY.getBytes(StandardCharsets.UTF_8));

// JWT 생성 후 인증된 사용자의 이름을 클레임 중 하나로 저장함
// 토큰을 서명하는데 키를 이용함
String jwt = Jwts.builder()
        .setClaims(Map.of("username", username))  // 본문에 값 추가
        .signWith(key)  // 비대칭키로 토큰에 서명 첨부
        .compact();

import com.assu.study.chap1102.authtication.UsernamePasswordAuthentication;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.crypto.SecretKey;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;

/**
 * JWT 기반 인증 관련 필터
 * <p>
 * 요청의 권한 부여 HTTP 헤더에 JWT 가 있다고 가정하고, 서명을 확인하여 JWT 검증 후
 * 인증된 Authentication 객체를 만들어 SecurityContext 에 추가함
 */
@RequiredArgsConstructor
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

  @Value("${jwt.signing.key}")
  private String SIGNING_KEY;

  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    String jwt = request.getHeader("Authorization");

    SecretKey key = Keys.hmacShaKeyFor(SIGNING_KEY.getBytes(StandardCharsets.UTF_8));

    // TODO: deprecated
    // 토큰을 구문 분석하여 클레임을 얻고, 서명을 검증함
    // 서명이 유효하지 않으면 예외가 발생함
    Claims claims = Jwts.parser()
        .setSigningKey(key)
        .build()
        .parseClaimsJws(jwt)
        .getBody();

    String username = String.valueOf(claims.get("username"));

    // SecurityContext 에 추가할 Authentication 인스턴스 생성
    GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("user");

    // 인증이 되었으므로 매개변수가 3개인 생성자로 Authentication 인스턴스 생성
    UsernamePasswordAuthentication auth = new UsernamePasswordAuthentication(username, null, List.of(grantedAuthority));

    // SecurityContext 에 Authentication 객체 추가
    SecurityContextHolder.getContext().setAuthentication(auth);

    // 필터 체인의 다음 필터 호출
    filterChain.doFilter(request, response);
  }

  /**
   * /login 경로이면 이 필터를 실행하지 않음
   * 즉, /login 외의 다른 모든 경로에 대한 요청 처리
   */
  @Override
  protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
    return request.getServletPath().equals("/login");
  }
}

import com.assu.study.chap1102.authtication.filter.InitialAuthenticationFilter;
import com.assu.study.chap1102.authtication.filter.JwtAuthenticationFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

@Configuration
public class SecurityConfig {
  // filter 주입
  private final InitialAuthenticationFilter initialAuthenticationFilter;
  private final JwtAuthenticationFilter jwtAuthenticationFilter;

  public SecurityConfig(InitialAuthenticationFilter initialAuthenticationFilter, JwtAuthenticationFilter jwtAuthenticationFilter) {
    this.initialAuthenticationFilter = initialAuthenticationFilter;
    this.jwtAuthenticationFilter = jwtAuthenticationFilter;
  }

  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        .csrf(c -> c.disable()) // POST 를 포함한 모든 엔드포인트를 호출할 수 있게 csrf 비활성화
        .addFilterAt(initialAuthenticationFilter, BasicAuthenticationFilter.class)  // 필터 체인에 필터 추가
        .addFilterAfter(jwtAuthenticationFilter, BasicAuthenticationFilter.class)
        .authorizeHttpRequests(authz -> authz.anyRequest().authenticated());  // 모든 요청이 인증되게 함

    return http.build();
  }
}

import com.assu.study.chap1102.authtication.provider.OtpAuthenticationProvider;
import com.assu.study.chap1102.authtication.provider.UsernamePasswordAuthenticationProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;

import java.util.Arrays;

@Configuration
public class ProviderConfig {

  // AuthenticationProvider 주입
  private final UsernamePasswordAuthenticationProvider usernamePasswordAuthenticationProvider;
  private final OtpAuthenticationProvider otpAuthenticationProvider;

  public ProviderConfig(UsernamePasswordAuthenticationProvider usernamePasswordAuthenticationProvider, OtpAuthenticationProvider otpAuthenticationProvider) {
    this.usernamePasswordAuthenticationProvider = usernamePasswordAuthenticationProvider;
    this.otpAuthenticationProvider = otpAuthenticationProvider;
  }

  /**
   * 맞춤 구성한 AuthenticationProviderService 구현 연결
   */
  @Bean
  public AuthenticationManager authenticationManager() throws Exception {
    return new ProviderManager(Arrays.asList(this.usernamePasswordAuthenticationProvider, this.otpAuthenticationProvider));
  }
}