dependencies { 
   implementation 'io.jsonwebtoken:jjwt:0.9.1' 
   implementation 'org.mariadb.jdbc:mariadb-java-client' 
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa' 
   implementation 'org.springframework.boot:spring-boot-starter-security' 
   implementation 'org.springframework.boot:spring-boot-starter-thymeleaf' 
   implementation 'org.springframework.boot:spring-boot-starter-web' 
}

@Configuration 
public class WebMvcConfig implements WebMvcConfigurer { 
   private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/static/", "classpath:/public/", "classpath:/"
   , "classpath:/resources/", "classpath:/META-INF/resources/", "classpath:/META-INF/resources/webjars/" }; 
   
   @Override 
   public void addViewControllers(ViewControllerRegistry registry) { 
      // /에 해당하는 url mapping을 /common/test로 forward한다. 
      registry.addViewController( "/" ).setViewName( "forward:/index" ); 
      // 우선순위를 가장 높게 잡는다. 
      registry.setOrder(Ordered.HIGHEST_PRECEDENCE); 
   } 
   
   @Override 
   public void addResourceHandlers(ResourceHandlerRegistry registry) {
      registry.addResourceHandler("/**").addResourceLocations(CLASSPATH_RESOURCE_LOCATIONS); 
   } 
}

@Configuration 
@EnableWebSecurity 
public class WebSecurityConfig extends WebSecurityConfigurerAdapter { 
   // 정적 자원에 대해서는 Security 설정을 적용하지 않음. 
   @Override 
   public void configure(WebSecurity web) {
      web.ignoring().requestMatchers(PathRequest.toStaticResources().atCommonLocations()); 
   } 
   
   @Override 
   protected void configure(HttpSecurity http) throws Exception { 
      http.csrf().disable().authorizeRequests() 
         // 토큰을 활용하는 경우 모든 요청에 대해 접근이 가능하도록 함
         .anyRequest().permitAll() 
         .and() 
         // 토큰을 활용하면 세션이 필요 없으므로 STATELESS로 설정하여 Session을 사용하지 않음
         .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) 
         .and() 
         // form 기반의 로그인에 대해 비활성화
         .formLogin().disable(); 
   } 
      
   @Bean 
   public BCryptPasswordEncoder bCryptPasswordEncoder() { 
      return new BCryptPasswordEncoder(); 
   } 
}

@Log4j2 
public class CustomAuthenticationFilter extends UsernamePasswordAuthenticationFilter { 
   public CustomAuthenticationFilter(final AuthenticationManager authenticationManager) { 
      super.setAuthenticationManager(authenticationManager); 
   } 
   
   @Override 
   public Authentication attemptAuthentication(final HttpServletRequest request, final HttpServletResponse response) throws AuthenticationException{ 
      final UsernamePasswordAuthenticationToken authRequest;
      try {
         final User user = new ObjectMapper().readValue(request.getInputStream(), User.class);
         authRequest = new UsernamePasswordAuthenticationToken(user.getEmail(), user.getPw()); 
      } catch (IOException exception) {
         throw new InputNotFoundException();
      } 
      setDetails(request, authRequest); 
      return this.getAuthenticationManager().authenticate(authRequest);
   } 
}

@Entity 
@Table(name = "USER") 
@Getter 
@Builder 
@AllArgsConstructor 
@NoArgsConstructor(access = AccessLevel.PROTECTED) 
public class User extends Common implements Serializable {
   @Column(nullable = false, unique = true, length = 50) 
   private String email; 
   
   @Setter 
   @Column(nullable = false) 
   private String pw;
   
   @Setter 
   @Column(nullable = false, length = 50) 
   @Enumerated(EnumType.STRING) 
   private UserRole role; 
}

public class InputNotFoundException extends RuntimeException { 
   public InputNotFoundException(){ 
      super(); 
   } 
}

@Log4j2 
public class CustomLoginSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler { 
   @Override 
   public void onAuthenticationSuccess(final HttpServletRequest request, final HttpServletResponse response, final Authentication authentication) { 
      final User user = ((MyUserDetails) authentication.getPrincipal()).getUser(); 
      final String token = TokenUtils.generateJwtToken(user); 
      response.addHeader(AuthConstants.AUTH_HEADER, AuthConstants.TOKEN_TYPE + " " + token);
   } 
}

@NoArgsConstructor(access = AccessLevel.PRIVATE) 
public final class AuthConstants { 
   public static final String AUTH_HEADER = "Authorization"; 
   public static final String TOKEN_TYPE = "BEARER"; 
}

@Configuration 
@EnableWebSecurity 
public class WebSecurityConfig extends WebSecurityConfigurerAdapter { 
   // 정적 자원에 대해서는 Security 설정을 적용하지 않음
   @Override 
   public void configure(WebSecurity web) { 
      web.ignoring().requestMatchers(PathRequest.toStaticResources().atCommonLocations()); 
   } 
   
   @Override 
   protected void configure(HttpSecurity http) throws Exception { 
      http.csrf().disable().authorizeRequests() 
         // 토큰을 활용하는 경우 모든 요청에 대해 접근이 가능하도록 함 
         .anyRequest().permitAll() 
         .and() 
         // 토큰을 활용하면 세션이 필요 없으므로 STATELESS로 설정하여 Session을 사용하지 않음
         .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) 
         .and() 
         // form 기반의 로그인에 대해 비활성화 
         .formLogin().disable() 
      .addFilterBefore(customAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class); 
   } 
   
   @Bean 
   public BCryptPasswordEncoder bCryptPasswordEncoder() {
      return new BCryptPasswordEncoder();
   } 
   
   @Bean 
   public CustomAuthenticationFilter customAuthenticationFilter() throws Exception { 
      CustomAuthenticationFilter customAuthenticationFilter = new CustomAuthenticationFilter(authenticationManager()); 
      customAuthenticationFilter.setFilterProcessesUrl("/user/login"); 
      customAuthenticationFilter.setAuthenticationSuccessHandler(customLoginSuccessHandler()); 
      customAuthenticationFilter.afterPropertiesSet(); 
      return customAuthenticationFilter; 
   } 
   
   @Bean 
   public CustomLoginSuccessHandler customLoginSuccessHandler() {
      return new CustomLoginSuccessHandler(); 
   } 
}

@RequiredArgsConstructor 
@Log4j2 
public class CustomAuthenticationProvider implements AuthenticationProvider { 
   @Override 
   public Authentication authenticate(Authentication authentication) throws AuthenticationException { 
      final UsernamePasswordAuthenticationToken token = (UsernamePasswordAuthenticationToken) authentication; 
      // AuthenticaionFilter에서 생성된 토큰으로부터 아이디와 비밀번호를 조회함 
      final String email = token.getName(); 
   } 
   
   @Override 
   public boolean supports(Class<?> authentication) { 
      return authentication.equals(UsernamePasswordAuthenticationToken.class);
   }
}

@RequiredArgsConstructor 
@Service 
public class UserDetailsServiceImpl implements UserDetailsService { 
   private final UserRepository userRepository; 
   
   @Override 
   public MyUserDetails loadUserByUsername(String email) {

   } 
}

@Repository
public interface UserRepository extends JpaRepository <User, Long> {
   User findByEmailAndPw(String email, String pw); 
   Optional<User> findByEmail(String email); 
}

@RequiredArgsConstructor 
@Getter 
public class MyUserDetails implements UserDetails { 
   @Delegate 
   private final User user; 
   private final Collection<? extends GrantedAuthority> authorities;
   
   @Override 
   public Collection<? extends GrantedAuthority> getAuthorities() { 
      return authorities; 
   } 
   
   @Override public String getPassword() { 
      return user.getPw();
   } 
   
   @Override public String getUsername() { 
      return user.getEmail(); 
   } 
   
   @Override public boolean isAccountNonExpired() { 
      return user.getIsEnable(); 
   } 
   
   @Override public boolean isAccountNonLocked() { 
      return user.getIsEnable();
   } 
   
   @Override public boolean isCredentialsNonExpired() { 
      return user.getIsEnable(); 
   } 
   
   @Override public boolean isEnabled() { 
      return user.getIsEnable(); 
   } 
}

@RequiredArgsConstructor 
@Log4j2 
public class CustomAuthenticationProvider implements AuthenticationProvider { 
   private final UserDetailsService userDetailsService; 
   private final BCryptPasswordEncoder passwordEncoder; 
   
   @Override 
   public Authentication authenticate(final Authentication authentication) throws AuthenticationException { 
      final UsernamePasswordAuthenticationToken token = (UsernamePasswordAuthenticationToken) authentication; 

      // AuthenticaionFilter에서 생성된 토큰으로부터 아이디와 비밀번호를 조회함 
      final String userEmail = token.getName(); 
      final String userPw = (String) token.getCredentials(); 
      
      // UserDetailsService를 통해 DB에서 아이디로 사용자 조회
      final MyUserDetails userDetails = (MyUserDetails) userDetailsService.loadUserByUsername(userEmail);
      
      if (!passwordEncoder.matches(userPw, userDetails.getPassword())) { 
         throw new BadCredentialsException(userDetails.getUsername() + "Invalid password"); 
      } 
      
      return new UsernamePasswordAuthenticationToken(userDetails, userPw, userDetails.getAuthorities());
   } 
   
   @Override 
   public boolean supports(Class<?> authentication) { 
      return authentication.equals(UsernamePasswordAuthenticationToken.class); 
   }
}

@Configuration 
@EnableWebSecurity
@RequiredArgsConstructor 
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   private final UserDetailsService userDetailsService; 
   
   // 정적 자원에 대해서는 Security 설정을 적용하지 않음. 
   @Override 
   public void configure(WebSecurity web) { 
      web.ignoring().requestMatchers(PathRequest.toStaticResources().atCommonLocations()); 
   } 
   
   @Override 
   protected void configure(HttpSecurity http) throws Exception { 
      http.csrf().disable().authorizeRequests() 
         // 토큰을 활용하는 경우 모든 요청에 대해 접근이 가능하도록 함 
         .anyRequest().permitAll() 
         .and() 
         // 토큰을 활용하면 세션이 필요 없으므로 STATELESS로 설정하여 Session을 사용하지 않음
         .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) 
         .and() 
         // form 기반의 로그인에 대해 비활성화
         .formLogin() .disable() 
         .addFilterBefore(customAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
   } 
   
   @Bean 
   public BCryptPasswordEncoder bCryptPasswordEncoder() { 
      return new BCryptPasswordEncoder();
   } 
   
   @Bean 
   public CustomAuthenticationFilter customAuthenticationFilter() throws Exception { 
      CustomAuthenticationFilter customAuthenticationFilter = new CustomAuthenticationFilter(authenticationManager()); 
      customAuthenticationFilter.setFilterProcessesUrl("/user/login"); 
      customAuthenticationFilter.setAuthenticationSuccessHandler(customLoginSuccessHandler()); 
      customAuthenticationFilter.afterPropertiesSet(); 
      return customAuthenticationFilter; 
   } 
   
   @Bean 
   public CustomLoginSuccessHandler customLoginSuccessHandler() { 
      return new CustomLoginSuccessHandler(); 
   } 
   
   @Bean 
   public CustomAuthenticationProvider customAuthenticationProvider() { 
      return new CustomAuthenticationProvider(userDetailsService, bCryptPasswordEncoder());
   } 
   
   @Override 
   public void configure(AuthenticationManagerBuilder authenticationManagerBuilder) { 
      authenticationManagerBuilder.authenticationProvider(customAuthenticationProvider()); 
   } 
}

@Log4j2 
@NoArgsConstructor(access = AccessLevel.PRIVATE) 
public final class TokenUtils { 
   private static final String secretKey = "ThisIsA_SecretKeyForJwtExample"; 
   
   public static String generateJwtToken(User user) { 
      JwtBuilder builder = Jwts.builder() 
         .setSubject(user.getEmail()) 
         .setHeader(createHeader()) 
         .setClaims(createClaims(user)) 
         .setExpiration(createExpireDateForOneYear()) 
         .signWith(SignatureAlgorithm.HS256, createSigningKey()); 
      
      return builder.compact(); 
   } 
   
   public static boolean isValidToken(String token) {
      try { 
         Claims claims = getClaimsFormToken(token); 
         log.info("expireTime :" + claims.getExpiration()); 
         log.info("email :" + claims.get("email")); 
         log.info("role :" + claims.get("role")); 
         return true; 
      } catch (ExpiredJwtException exception) { 
         log.error("Token Expired"); 
         return false; 
      } catch (JwtException exception) { 
         log.error("Token Tampered"); 
         return false; 
      } catch (NullPointerException exception) { 
         log.error("Token is null"); 
         return false; 
      }
   } 
   
   public static String getTokenFromHeader(String header) { 
      return header.split(" ")[1];
   } 
   
   private static Date createExpireDateForOneYear() { 
      // 토큰 만료시간은 30일으로 설정 
      Calendar c = Calendar.getInstance(); 
      c.add(Calendar.DATE, 30); 
      return c.getTime();
   } 
   
   private static Map<String, Object> createHeader() { 
      Map<String, Object> header = new HashMap<>(); 
      header.put("typ", "JWT"); 
      header.put("alg", "HS256"); 
      header.put("regDate", System.currentTimeMillis()); 
      return header;
   } 
   
   private static Map<String, Object> createClaims(User user) { 
      // 공개 클레임에 사용자의 이름과 이메일을 설정하여 정보를 조회할 수 있음
      Map<String, Object> claims = new HashMap<>(); 
      claims.put("email", user.getEmail()); 
      claims.put("role", user.getRole()); 
      return claims;
   } 
   
   private static Key createSigningKey() { 
      byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(secretKey);
      return new SecretKeySpec(apiKeySecretBytes, SignatureAlgorithm.HS256.getJcaName()); 
   } 
   
   private static Claims getClaimsFormToken(String token) { 
      return Jwts.parser().setSigningKey(DatatypeConverter.parseBase64Binary(secretKey)) 
        .parseClaimsJws(token).getBody(); 
   } 
   
   private static String getUserEmailFromToken(String token) { 
      Claims claims = getClaimsFormToken(token); 
      return (String) claims.get("email"); 
   } 
   
   private static UserRole getRoleFromToken(String token) { 
      Claims claims = getClaimsFormToken(token); 
      return (UserRole) claims.get("role");
   } 
}