【Spring Boot】Spring Security × JWT認証で作成した7つのクラスの役割を整理してみた

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyMSJ9.xyzSignature
       ↑                      ↑                    ↑
   Header（アルゴリズム）  Payload（中身）       Signature（署名）

src/main/
├── java/com/example/training_tracker_api/
│   │
│   ├── auth/
│   │   ├── controller/
│   │   │   └── AuthController.java              ③ ログインAPI
│   │   └── dto/
│   │       ├── LoginRequest.java                ログインリクエスト
│   │       └── LoginResponse.java               ログインレスポンス（JWT返却）
│   │
│   └── common/
│       └── security/
│           ├── JwtProperties.java               ① JWT設定値
│           ├── JwtService.java                  ② JWT生成・検証
│           ├── CustomUserDetailsService.java    ④ ユーザー情報の取得
│           ├── SecurityConfig.java              ⑤ Spring Security設定
│           ├── JwtAuthenticationFilter.java     ⑥ リクエストごとのJWT認証
│           └── CurrentUserProvider.java         ⑦ ログインユーザー取得
│
└── resources/
    └── application.properties                   （jwt.secret / jwt.expiration-ms）

// jwt.* の設定値をまとめて受け取るクラス
@ConfigurationProperties(prefix = "jwt")
public class JwtProperties {

    private String secret;      // 署名に使う秘密鍵（文字列）

    private long expirationMs;  // トークンの有効期限（ミリ秒）

    // getter / setter は省略

    // アプリ起動直後に設定値の妥当性を検証する
    @PostConstruct
    void validate() {
        if (secret == null) {
            throw new IllegalStateException("jwt.secret is required");
        }

        // 秘密鍵が32バイト未満だとHMAC-SHA256の要件を満たさないためエラー
        int byteLength = secret.getBytes(StandardCharsets.UTF_8).length;
        if (byteLength < 32) {
            throw new IllegalStateException(
                "jwt.secret must be at least 32 bytes (current: " + byteLength + " bytes)"
            );
        }

        if (expirationMs <= 0) {
            throw new IllegalStateException("jwt.expiration-ms must be positive");
        }
    }
}

jwt.secret=your-256-bit-secret-key-here-minimum-32-bytes
jwt.expiration-ms=3600000

@Service
public class JwtService {

    private final SecretKey signingKey; // 署名・検証に使う秘密鍵

    private final long expirationMs;    // 有効期限（ミリ秒）

    public JwtService(JwtProperties props) {
        // 文字列の秘密鍵をHMAC-SHA用のSecretKeyオブジェクトに変換
        this.signingKey = Keys.hmacShaKeyFor(
            props.getSecret().getBytes(StandardCharsets.UTF_8)
        );
        this.expirationMs = props.getExpirationMs();
    }

    // トークンを生成する（ログイン成功時に呼ばれる）
    public String generateToken(String username) {
        Date now = new Date();
        Date expiry = new Date(now.getTime() + expirationMs); // 現在時刻 + 有効期限

        return Jwts.builder()
            .subject(username)  // Payload に username を格納
            .issuedAt(now)      // 発行日時
            .expiration(expiry) // 有効期限
            .signWith(signingKey) // 秘密鍵で署名
            .compact();           // 文字列に変換して返す
    }

    // トークンを検証してユーザー名を取り出す（リクエストごとに呼ばれる）
    public String parseAndValidate(String token) {
        return Jwts.parser()
            .verifyWith(signingKey) // 署名の検証（改ざん検知）
            .build()
            .parseSignedClaims(token) // 有効期限の検証も内部で行われる
            .getPayload()
            .getSubject(); // Payload から username を取り出す
    }
}

        return Jwts.builder()
            .subject(username)  // Payload に username を格納
            .issuedAt(now)      // 発行日時
            .expiration(expiry) // 有効期限
            .signWith(signingKey) // 秘密鍵で署名
            .compact();           // 文字列に変換して返す

      return Jwts.parser()
            .verifyWith(signingKey) // 署名の検証（改ざん検知）
            .build()
            .parseSignedClaims(token) // 有効期限切れの場合も、この解析処理の中で例外が発生する
            .getPayload()
            .getSubject(); // 問題がなければ、payloadからsubject（ユーザー名）を取り出す

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    private final AuthenticationManager authenticationManager;
    private final JwtService jwtService;

    public AuthController(AuthenticationManager authenticationManager, JwtService jwtService) {
        this.authenticationManager = authenticationManager;
        this.jwtService = jwtService;
    }

    @PostMapping("/login")
    public ResponseEntity<LoginResponse> login(@Valid @RequestBody LoginRequest request) {
        try {
            // Spring Security に認証を委譲する
            authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                    request.getUsername(),
                    request.getPassword()
                )
            );
        } catch (BadCredentialsException e) {
            // 認証に失敗した場合は401を返す
            return ResponseEntity.status(401).build();
        }

        // 認証成功 → トークンを生成してレスポンスに含める
        String token = jwtService.generateToken(request.getUsername());
        return ResponseEntity.ok(new LoginResponse(token));
    }
}

// リクエストDTO
public class LoginRequest {
    @NotBlank(message = "username is required")
    private String username;

    @NotBlank(message = "password is required")
    private String password;

    // getter / setter 省略
}

// レスポンスDTO（recordで1行）
public record LoginResponse(String token) {}

         // Spring Security に認証を委譲（パスワードのハッシュ照合もここで行われる）
            authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                    request.getUsername(),
                    request.getPassword()
                )
            );

@Service
public class CustomUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // Spring Securityからusernameを受け取り、DBからユーザー情報を返す
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // DB にユーザーがいなければ UsernameNotFoundException を投げる
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username));

        // ロールを"ROLE_USER"などの形式に変換
        List<SimpleGrantedAuthority> roles = user.getRoles().stream()
            .map(role -> new SimpleGrantedAuthority("ROLE_" + role.name()))
            .toList();

        // Spring Securityが扱えるUserDetailsオブジェクトに変換して返す
        return User.builder()
            .username(user.getUsername())
            .password(user.getPassword()) // ハッシュ化済みパスワード
            .authorities(roles)
            .build();
    }
}

@Configuration
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtAuthenticationFilter;

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

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            // AuthorizationヘッダーのJWTで認証するため、CSRFを無効化する
            .csrf(csrf -> csrf.disable())

            // セッションを使わない（JWTはステートレスなのでサーバー側にセッションを持たない）
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )

            // 認証エラー時は401を返す
            .exceptionHandling(ex -> ex
                .authenticationEntryPoint((req, res, e) ->
                    res.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"))
            )

            // 認可設定（どのエンドポイントを認証不要にするか）
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/h2-console/**").permitAll() // 開発用 DB コンソールは認証不要
                .requestMatchers("/api/auth/login").permitAll() // ログインは認証不要（当然）
                .anyRequest().authenticated()                   // それ以外はすべて認証必須
            )

            // h2-consoleはiframeで動くためsameOriginを許可
            .headers(h -> h
                .frameOptions(HeadersConfigurer.FrameOptionsConfig::sameOrigin)
            )

            // JWTフィルタをSpring Securityのフィルタチェーンに組み込む
            // UsernamePasswordAuthenticationFilter の前に実行されるように指定
            .addFilterBefore(
                jwtAuthenticationFilter,
                UsernamePasswordAuthenticationFilter.class
            )
            .build();
    }

    // パスワードのハッシュ化にBCryptを使う
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // AuthControllerから認証処理を呼び出すために必要
    @Bean
    public AuthenticationManager authenticationManager(
        AuthenticationConfiguration authenticationConfiguration
    ) throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }
}

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private static final String AUTHORIZATION_HEADER = "Authorization";
    private static final String BEARER_PREFIX = "Bearer ";

    private final JwtService jwtService;

    public JwtAuthenticationFilter(JwtService jwtService) {
        this.jwtService = jwtService;
    }

    @Override
    protected void doFilterInternal(
        HttpServletRequest request,
        HttpServletResponse response,
        FilterChain filterChain
    ) throws ServletException, IOException {

        // リクエストヘッダーから "Bearer <token>" を取り出す
        String token = resolveToken(request);

        if (token != null) {
            try {
                // トークンを検証し、Payloadのsubjectからユーザー名を取り出す
                String username = jwtService.parseAndValidate(token);

                // 認証情報オブジェクトを作成（パスワードは不要なので null）
                UsernamePasswordAuthenticationToken authentication =
                    new UsernamePasswordAuthenticationToken(
                        username,
                        null,
                        List.of(new SimpleGrantedAuthority("ROLE_USER"))
                    );

                // SecurityContext に認証情報をセット（これで「認証済み」とみなされる）
                SecurityContextHolder.getContext().setAuthentication(authentication);

            } catch (Exception e) {
                // トークンが不正・期限切れの場合は 401 を返して処理を止める
                SecurityContextHolder.clearContext();
                response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid token");
                return;
            }
        }

        // 次のフィルタへ処理を渡す
        filterChain.doFilter(request, response);
    }

    // "Authorization: Bearer <token>"ヘッダーからトークン文字列だけ取り出す
    private String resolveToken(HttpServletRequest request) {
        String header = request.getHeader(AUTHORIZATION_HEADER);
        if (header != null && header.startsWith(BEARER_PREFIX)) {
            return header.substring(BEARER_PREFIX.length()); // "Bearer "の7文字を除いた部分
        }
        return null; // ヘッダーがなければnull（認証不要なエンドポイントはこのまま通過する）
    }
}

@Component
public class CurrentUserProvider {

    // SecurityContext に格納された認証情報からユーザー名を取り出す
    public String getUsername() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();

        if (auth == null || !auth.isAuthenticated()) {
            throw new IllegalStateException("Authentication is not available");
        }

        return auth.getName(); // JwtAuthenticationFilter でセットした username が返る
    }
}

@Service
public class PostService {

    private final CurrentUserProvider currentUserProvider;

    // 「自分の投稿だけ取得する」ような処理で使う
    public List<Post> findMyPosts() {
        String username = currentUserProvider.getUsername();

        // username を使って DB から自分の投稿を取得…
    }
}