Spring Securityでログイン機能の実装中に起きた循環参照エラーについて (DIやDIコンテナについて解説あり)

|目次|
|---|
|[初めに](#初めに)|
|[循環参照エラーについて](#循環参照エラーについて)|
|[DIやDIコンテナについて](#diやdiコンテナについて)|

<h1>初めに</h1>
これは、<strong>Spring Security</strong>を使用したログイン機能の実装を勉強していた時に発生しました。以下のサイトを見ると似たようなところで躓いている人が多いようです<strong>(私もその一人(〃ﾉωﾉ))</strong>。今回は実際に自分が起こした循環参照のエラーを例にその対処法について解説したいと思います。


https://shiron-program.hatenablog.com/entry/2022/08/13/003608

https://qiita.com/TaikiTkwkbysh/questions/3d6e8f28174c3dfcb755

https://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q11277744801



<h1>循環参照エラーについて</h1>

<strong><font color="Red">循環参照</font></strong>は特定のオブジェクトやクラスが相互に依存する状態を指し、この状態が発生するとアプリケーションの動作に問題(アプリの起動に失敗など)が生じることが多いです。具体的には、AクラスがBクラスに依存し、BクラスがAクラスに依存しているような状態のことを指します。循環参照エラーの原因をちゃんと理解するには、<font color="blue"><strong>[DIやDIコンテナについて](#diやdiコンテナについて)</strong></font>ちゃんと理解する必要がございます。<font color="blue"><strong>[DIやDIコンテナについて](#diやdiコンテナについて)</strong></font>の解説も記載したの参考にしてください。

|目次|
|---|
|[循環参照の概要](#循環参照の概要)|
|[循環参照エラーの実例](#循環参照エラーの実例)|
|[今回の循環参照エラーの原因](#今回の循環参照エラーの原因)|
|[循環参照エラーの対処方法](#循環参照エラーの対処方法)|



<h2>循環参照の概要</h2>
循環参照は、オブジェクトの相互依存関係が複雑に絡み合い、互いに参照することで無限ループ状態や予期せぬエラーを引き起こす状態を指します。これは特にDIコンテナを使用したフレームワークやアプリケーションで問題となることが多いです。循環参照の問題点としては、アプリケーションの起動時にDIコンテナがオブジェクトの依存関係を解決しようとした際に、循環参照を検出してエラーをスローすることが挙げられます。これにより、アプリケーションの起動が阻害されることがあります。

<h2>循環参照エラーの実例</h2>
循環参照エラーの実例について紹介します。最初にも紹介したように、多くの開発者がSpring Securityを使用したログイン機能の実装時に循環参照エラーに遭遇しています。私自身も、Spring Securityを使用してログイン機能を実装した際にこのエラーに直面しました。具体的には、「<strong>データベースからパスワードを取得し、それを比較する機能</strong>」を実装し、動作確認を行ったところ、循環参照エラーが発生しました。このようなエラーの背後には、特定のサービスやコンポーネントが互いに依存する構造が潜んでいることが多いです。Spring Securityのような複雑なフレームワークを使用する際には、特に注意が必要です。

この状態で起動すると以下のようなエラーログがコンソール出力されます。
```:循環参照エラーのコンソールログ
Error starting ApplicationContext. To display the condition evaluation report re-run your application with 'debug' enabled.    
2023-09-21T18:32:20.597+09:00 ERROR 8408 --- [  restartedMain] o.s.b.d.LoggingFailureAnalysisReporter   : 

***************************
APPLICATION FAILED TO START
***************************

Description:

The dependencies of some of the beans in the application context form a cycle:

┌─────┐
|  customAuthenticationProvider (field private org.springframework.security.crypto.password.PasswordEncoder com.app.login.configurations.CustomAuthenticationProvider.passwordEncoder)
↑     ↓
|  securityConfig (field private com.app.login.configurations.CustomAuthenticationProvider com.app.login.configurations.SecurityConfig.customAuthenticationProvider)
└─────┘


Action:

Relying upon circular references is discouraged and they are prohibited by default. Update your application to remove the dependency cycle between beans. As a last resort, it may be possible to break the cycle automatically by setting spring.main.allow-circular-references to true.
```

<h2>今回の循環参照エラーの原因</h2>
循環参照エラーが発生した原因は、以下の2つの設定に起因しています。

1. **SecurityConfig**: このクラスでは`CustomAuthenticationProvider`（カスタマイズした認証クラス）をDI（依存性注入）しており、このプロバイダはユーザーの認証処理を実施しています。
2. **PasswordEncoderのBean登録**:`SecurityConfig`内で、`PasswordEncoder`をBeanとして登録しています。これにより、パスワードのハッシュ化および比較のエンコーダーを提供しています。

以下は問題となったソースコードの詳細です。

こちらは、`SecurityConfig`になります。
```java:SecurityConfig
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private CustomAuthenticationProvider customAuthenticationProvider;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
        // カスタム認証プロバイダを設定
        .authenticationProvider(customAuthenticationProvider)
        // CORSの設定を適用
        .cors(customizer -> customizer.configurationSource(corsConfigurationSource()))
        // CSRFの保護を無効にする
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(authorizeRequests ->
            authorizeRequests
                // loginのパスへのリクエストはすべて許可
                .requestMatchers("/login").permitAll()
                 // その他のリクエストは認証が必要
                .anyRequest().authenticated()
        )
        .formLogin(formLogin -> 
            formLogin
            // ログイン処理のURLを指定(フロントがログインボタン実行時にPOSTする場所)
            .loginProcessingUrl("/login")
            // カスタムログインページのURLを指定(Spring Securityデフォルトの画面を置き換える)
            .loginPage("http://127.0.0.1:5500/view/login.html")
            // ログイン成功時のリダイレクト先URLを指定
            .defaultSuccessUrl("http://127.0.0.1:5500/view/index.html")
            // 認証失敗時のリダイレクト先URLを指定
            .failureUrl("http://127.0.0.1:5500/view/error.html")
        );

    return http.build();
    }

    @Bean
    public UrlBasedCorsConfigurationSource corsConfigurationSource() {
        // CORSの設定を行うためのオブジェクトを生成
        CorsConfiguration configuration = new CorsConfiguration();
        
        // クレデンシャル（資格情報（CookieやHTTP認証情報））を含むリクエストを許可する
        configuration.setAllowCredentials(true);
        
        // 許可するオリジン（この場合は"http://127.0.0.1:5500"のみ）を設定
        configuration.addAllowedOrigin("http://127.0.0.1:5500");
        
        // 任意のヘッダーを許可
        configuration.addAllowedHeader("*");
        
        // 任意のHTTPメソッド（GET, POSTなど）を許可
        configuration.addAllowedMethod("*");
        
        // CORS設定をURLベースで行うためのオブジェクトを生成
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        
        // 全てのURLパスにこのCORS設定を適用
        source.registerCorsConfiguration("/**", configuration);
        
        return source;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
```
こちらは、`CustomAuthenticationProvider`になります。
```java:CustomAuthenticationProvider
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

import com.app.login.service.CustomUserDetailsService;

@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private CustomUserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

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

        UserDetails userDetails = userDetailsService.loadUserByUsername(username);

        if (passwordEncoder.matches(providedPassword, userDetails.getPassword())) {
            return new UsernamePasswordAuthenticationToken(username, userDetails.getPassword(), userDetails.getAuthorities());
        } else {
            throw new BadCredentialsException("Authentication failed");
        }
    }

    @Override
    public boolean supports(Class<?> authentication) {
        // authentication(認証方式)がUsernamePasswordAuthenticationToken.class(ユーザー名とパスワード認証)か判定
        return authentication.equals(UsernamePasswordAuthenticationToken.class);
    }
}
```

上記のソースコードを確認すると以下の内容が原因で循環参照エラー発生しています。

1. `SecurityConfig`では、`CustomAuthenticationProvider`をDIしています。
2. `CustomAuthenticationProvider`では、`PasswordEncoder`をDIしています。
3. この`PasswordEncoder`は`SecurityConfig`でDIコンテナにBean登録しています。

この状態が、`SecurityConfig`と`CustomAuthenticationProvider`の間で循環の依存関係を作り出しています。具体的には、`SecurityConfig`が`CustomAuthenticationProvider`を参照し、その`CustomAuthenticationProvider`が再び`SecurityConfig`で登録された`PasswordEncoder`を参照しているため、この循環がエラーの原因となっています。

## 循環参照エラーの対処方法
今回の場合の循環参照エラーの対処方法は3つあります。

1. **遅延ローディング**：<font color="Red"><strong>@Lazyアノテーション</strong></font>を使用して、SpringにBeanの初期化を遅らせるように指示します。
   
:::note warn
この方法は実装が簡単ですが、Beanの初期化順序を遅らせるだけであり、Bean登録が増えるほど制御が困難になる可能性があります。クラス間の依存性が強い場合、この方法を推奨するのは難しいです。
:::

2. **コンストラクタ・メソッドインジェクション**：コンストラクタやメソッドの引数にBean登録したクラスを追加することで、明示的な依存関係の注入を行います。

:::note warn
コンストラクタインジェクションを使用すると、Beanの初期化の際に必要なすべての依存関係が解決されるまでインスタンス化が遅延されます。循環参照が存在する場合、Springはこの問題を初期化時に検出します。この方法は、循環参照を明確に検出する点で有効ですが、クラス間の依存性が高い場合、その設計自体を見直すべきかもしれません。
:::

3. **Bean登録の分割**：新しいクラスを作成し、依存関係を再構築することで循環参照を防ぎます。

:::note warn
この方法は他の2つに比べて実装が複雑になるかもしれませんが、依存関係の削減が期待できます。
:::


### 遅延ローディングを利用した修正方法
遅延ローディングを利用する修正方法として、`SecurityConfig`で`CustomAuthenticationProvider`をDIする部分に<font color="Red"><strong>@Lazyアノテーション</strong></font>を追加します。具体的な変更箇所は以下の通りです。

```diff:遅延ローディングでの修正箇所
    // CustomAuthenticationProvider Beanをこのクラスに注入する
    @Autowired
+   @Lazy
    private CustomAuthenticationProvider customAuthenticationProvider;
```

ソースコード全体は以下のようになります。
```java:遅延ローディングで修正したソースコード全体
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    // CustomAuthenticationProvider Beanをこのクラスに注入する
    @Autowired
    @Lazy
    private CustomAuthenticationProvider customAuthenticationProvider;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
        // カスタム認証プロバイダを設定
        .authenticationProvider(customAuthenticationProvider)
        // CORSの設定を適用
        .cors(customizer -> customizer.configurationSource(corsConfigurationSource()))
        // CSRFの保護を無効にする
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(authorizeRequests ->
            authorizeRequests
                // loginのパスへのリクエストはすべて許可
                .requestMatchers("/login").permitAll()
                 // その他のリクエストは認証が必要
                .anyRequest().authenticated()
        )
        .formLogin(formLogin -> 
            formLogin
            // ログイン処理のURLを指定(フロントがログインボタン実行時にPOSTする場所)
            .loginProcessingUrl("/login")
            // カスタムログインページのURLを指定(Spring Securityデフォルトの画面を置き換える)
            .loginPage("http://127.0.0.1:5500/view/login.html")
            // ログイン成功時のリダイレクト先URLを指定
            .defaultSuccessUrl("http://127.0.0.1:5500/view/index.html")
            // 認証失敗時のリダイレクト先URLを指定
            .failureUrl("http://127.0.0.1:5500/view/error.html")
        );

    return http.build();
    }

    // @Beanをつけることで、このメソッドがSpringのコンテナにBeanとして登録される
    @Bean
    public UrlBasedCorsConfigurationSource corsConfigurationSource() {
        // CORSの設定を行うためのオブジェクトを生成
        CorsConfiguration configuration = new CorsConfiguration();
        
        // クレデンシャル（資格情報（CookieやHTTP認証情報））を含むリクエストを許可する
        configuration.setAllowCredentials(true);
        
        // 許可するオリジン（この場合は"http://127.0.0.1:5500"のみ）を設定
        configuration.addAllowedOrigin("http://127.0.0.1:5500");
        
        // 任意のヘッダーを許可
        configuration.addAllowedHeader("*");
        
        // 任意のHTTPメソッド（GET, POSTなど）を許可
        configuration.addAllowedMethod("*");
        
        // CORS設定をURLベースで行うためのオブジェクトを生成
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        
        // 全てのURLパスにこのCORS設定を適用
        source.registerCorsConfiguration("/**", configuration);
        
        return source;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
```

### コンストラクタ・メソッドインジェクションを利用した修正方法
コンストラクタ・メソッドインジェクションを利用する修正方法は以下の通りです。
1. `SecurityConfig`で`CustomAuthenticationProvider`をフィールドインジェクションしていた個所を削除します。
2. 次に<strong>`securityFilterChain`</strong>メソッドの引数に、`CustomAuthenticationProvider`を追加します。

具体的な変更箇所は以下の通りです。

```diff:メソッドインジェクションでの修正箇所
// 以下を削除
-   @Autowired
-   @Lazy
-   private CustomAuthenticationProvider customAuthenticationProvider;

    @Bean
+   public SecurityFilterChain securityFilterChain(HttpSecurity http, CustomAuthenticationProvider customAuthenticationProvider) throws Exception {
```

ソースコード全体は以下のようになります。
```java:メソッドインジェクションで修正したソースコード全体
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.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http, CustomAuthenticationProvider customAuthenticationProvider) throws Exception {
        http
        // カスタム認証プロバイダを設定
        .authenticationProvider(customAuthenticationProvider)
        // CORSの設定を適用
        .cors(customizer -> customizer.configurationSource(corsConfigurationSource()))
        // CSRFの保護を無効にする
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(authorizeRequests ->
            authorizeRequests
                // loginのパスへのリクエストはすべて許可
                .requestMatchers("/login").permitAll()
                 // その他のリクエストは認証が必要
                .anyRequest().authenticated()
        )
        .formLogin(formLogin -> 
            formLogin
            // ログイン処理のURLを指定(フロントがログインボタン実行時にPOSTする場所)
            .loginProcessingUrl("/login")
            // カスタムログインページのURLを指定(Spring Securityデフォルトの画面を置き換える)
            .loginPage("http://127.0.0.1:5500/view/login.html")
            // ログイン成功時のリダイレクト先URLを指定
            .defaultSuccessUrl("http://127.0.0.1:5500/view/index.html")
            // 認証失敗時のリダイレクト先URLを指定
            .failureUrl("http://127.0.0.1:5500/view/error.html")
        );

    return http.build();
    }

    // @Beanをつけることで、このメソッドがSpringのコンテナにBeanとして登録される
    @Bean
    public UrlBasedCorsConfigurationSource corsConfigurationSource() {
        // CORSの設定を行うためのオブジェクトを生成
        CorsConfiguration configuration = new CorsConfiguration();
        
        // クレデンシャル（資格情報（CookieやHTTP認証情報））を含むリクエストを許可する
        configuration.setAllowCredentials(true);
        
        // 許可するオリジン（この場合は"http://127.0.0.1:5500"のみ）を設定
        configuration.addAllowedOrigin("http://127.0.0.1:5500");
        
        // 任意のヘッダーを許可
        configuration.addAllowedHeader("*");
        
        // 任意のHTTPメソッド（GET, POSTなど）を許可
        configuration.addAllowedMethod("*");
        
        // CORS設定をURLベースで行うためのオブジェクトを生成
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        
        // 全てのURLパスにこのCORS設定を適用
        source.registerCorsConfiguration("/**", configuration);
        
        return source;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
```

### Bean登録の分割を利用した修正方法
Bean登録の分割を利用する修正方法は以下の通りです。

1. `SecurityConfig`で`CustomAuthenticationProvider`をフィールドインジェクションしていた個所をコンストラクタインジェクションに変更します。
:::note warn
フィールドインジェクションとは、クラスのフィールド（変数）に直接、必要なオブジェクトやコンポーネントを注入することを指します。しかし、<font color="Red"><strong>フィールドインジェクションの利用することは非推奨</strong></font>とされています。
:::

2. `SecurityConfig`で実装していた`PasswordEncoder`のBean登録処理を削除します。

3. 新しく`PasswordEncoderConfig`クラスを作成し、2で削除した`PasswordEncoder`のBean登録処理を実装します。

4. `CustomAuthenticationProvider`のフィールドインジェクションしていた個所をコンストラクタインジェクションに変更します。

具体的な修正箇所は以下の通りです。

```diff:Bean登録の分割での修正箇所(SecurityConfig)
-   @Autowired
-   private CustomAuthenticationProvider customAuthenticationProvider;

+   private final CustomAuthenticationProvider customAuthenticationProvider;

+   public SecurityConfig(CustomAuthenticationProvider customAuthenticationProvider) {
+       this.customAuthenticationProvider = customAuthenticationProvider;
+   }

// securityFilterChainとcorsConfigurationSourceメソッド内容は省略

-   @Bean
-   public PasswordEncoder passwordEncoder() {
-       return new BCryptPasswordEncoder();
-   }
```

```diff:Bean登録の分割での修正箇所(CustomAuthenticationProvider)
-   @Autowired
-   private CustomUserDetailsService userDetailsService;

-   @Autowired
-   private PasswordEncoder passwordEncoder;

+   private final CustomUserDetailsService userDetailsService;
    
+   private final PasswordEncoder passwordEncoder;

+   public CustomAuthenticationProvider(
+       CustomUserDetailsService userDetailsService,
+       PasswordEncoder passwordEncoder
+   ) {
+       this.userDetailsService = userDetailsService;
+       this.passwordEncoder = passwordEncoder;
+   }
```

PasswordEncoderをBean登録する新規クラス`PasswordEncoderConfig`の内容です。
```java:Bean登録の分割で追加したPasswordEncoderConfig
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class PasswordEncoderConfig   {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
```

ソースコード全体は以下のようになります。
```java:Bean登録の分割で修正したソースコード全体(SecurityConfig )
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.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final CustomAuthenticationProvider customAuthenticationProvider;

    public SecurityConfig(CustomAuthenticationProvider customAuthenticationProvider) {
        this.customAuthenticationProvider = customAuthenticationProvider;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
        // カスタム認証プロバイダを設定
        .authenticationProvider(customAuthenticationProvider)
        // CORSの設定を適用
        .cors(customizer -> customizer.configurationSource(corsConfigurationSource()))
        // CSRFの保護を無効にする
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(authorizeRequests ->
            authorizeRequests
                // loginのパスへのリクエストはすべて許可
                .requestMatchers("/login").permitAll()
                 // その他のリクエストは認証が必要
                .anyRequest().authenticated()
        )
        .formLogin(formLogin -> 
            formLogin
            // ログイン処理のURLを指定(フロントがログインボタン実行時にPOSTする場所)
            .loginProcessingUrl("/login")
            // カスタムログインページのURLを指定(Spring Securityデフォルトの画面を置き換える)
            .loginPage("http://127.0.0.1:5500/view/login.html")
            // ログイン成功時のリダイレクト先URLを指定
            .defaultSuccessUrl("http://127.0.0.1:5500/view/index.html")
            // 認証失敗時のリダイレクト先URLを指定
            .failureUrl("http://127.0.0.1:5500/view/error.html")
        );

    return http.build();
    }

    // @Beanをつけることで、このメソッドがSpringのコンテナにBeanとして登録される
    @Bean
    public UrlBasedCorsConfigurationSource corsConfigurationSource() {
        // CORSの設定を行うためのオブジェクトを生成
        CorsConfiguration configuration = new CorsConfiguration();
        
        // クレデンシャル（資格情報（CookieやHTTP認証情報））を含むリクエストを許可する
        configuration.setAllowCredentials(true);
        
        // 許可するオリジン（この場合は"http://127.0.0.1:5500"のみ）を設定
        configuration.addAllowedOrigin("http://127.0.0.1:5500");
        
        // 任意のヘッダーを許可
        configuration.addAllowedHeader("*");
        
        // 任意のHTTPメソッド（GET, POSTなど）を許可
        configuration.addAllowedMethod("*");
        
        // CORS設定をURLベースで行うためのオブジェクトを生成
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        
        // 全てのURLパスにこのCORS設定を適用
        source.registerCorsConfiguration("/**", configuration);
        
        return source;
    }

}

```
```java:Bean登録の分割で修正したソースコード全体(PasswordEncoderConfig)
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class PasswordEncoderConfig   {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

```

```java:Bean登録の分割で修正したソースコード全体(CustomAuthenticationProvider)
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import com.app.login.service.CustomUserDetailsService;

@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {

    private final CustomUserDetailsService userDetailsService;
    
    private final PasswordEncoder passwordEncoder;

    public CustomAuthenticationProvider(
        CustomUserDetailsService userDetailsService,
        PasswordEncoder passwordEncoder
    ) {
        this.userDetailsService = userDetailsService;
        this.passwordEncoder = passwordEncoder;
    }

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

        UserDetails userDetails = userDetailsService.loadUserByUsername(username);

        if (passwordEncoder.matches(providedPassword, userDetails.getPassword())) {
            return new UsernamePasswordAuthenticationToken(username, userDetails.getPassword(), userDetails.getAuthorities());
        } else {
            throw new BadCredentialsException("Authentication failed");
        }
    }
    
    @Override
    public boolean supports(Class<?> authentication) {
        // authentication(認証方式)がUsernamePasswordAuthenticationToken.class(ユーザー名とパスワード認証)か判定
        return authentication.equals(UsernamePasswordAuthenticationToken.class);
    }
}

```

ここで、Spring Securityでログイン機能の実装中に起きた循環参照エラーについての対象方法についての説明は終わりです。以下は、DIやDIコンテナについての解説です。

#

<h1>DIやDIコンテナについて</h1>

<font color="Red"><strong>循環参照エラー</strong></font>の解消には<font color="Red"><strong>diやdiコンテナ</strong></font>の仕組みをちゃんと理解する必要があります。今まで、なんとなくで実装していた方はまずはここを見て復習してみてください。（私もその一人(〃ﾉωﾉ)）


<h2>DIとは何か</h2>
Springを勉強すればあらゆる本やネット記事、動画で以下の説明を見聞きすることでしょう。

- <font color="Red"><strong>DI(Dependency Injection)：依存性の注入</strong></font>

そして「<strong>(｡･ω･｡)?」</strong>となり、なんとなく
「<strong>依存性の注入を心掛けた実装をしないといけないのか、へー興味ない(－‸ლ)</strong>」となることでしょう(笑)。

しかしこの意味を理解しないとSpring DIを理解するのは難しいです。なのでこの言葉をもう少し意味のわかる言葉に変換したいと思います。

- <font color="Red"><strong>依存性の注入：外部からオブジェクトを注入することでクラス同士の依存性を弱める</strong></font>

:::note info
しかし、個人的な感想としては、<strong>依存性の注入</strong>という言葉だけでは、実際には依存性が増加しているようなイメージを持つかもしれません。この点を鑑みると、<strong>DEI(Dependency External Injection)</strong>という名前のほうが、もう少し直感的に捉えやすくするかもしれません。日本語で直訳すると「<strong>依存性の外部注入</strong>」となり、<strong>外部からの依存関係の注入</strong>という意味がもう少し明確になるでしょう。この点についてはあくまで私の個人的な考えですが、DIの本質とメリットを理解する上での視点として参考にしていただければと思います。
:::

とはいえ言葉だけでは難しいと思うので実際のソースコードでもを確認しましょう。

以下のHelloメッセージを表示する機能を<strong>依存性の注入のなし</strong>の場合と<strong>依存性の注入のあり</strong>の場合で呼び出すクラスを作成します。
```java:Helloメッセージを表示するクラス
public class HelloPrint {
    void helloPrint(String str) {
        System.out.println("Hello "+ str +" DI!");
    }
}
```

まずは、<strong>依存性の注入なし</strong>のソースコードです。
```java:依存性の注入なしのソースコード
public class HelloNoDI {
    private HelloPrint helloPrint;

    HelloNoDI(){
        this.helloPrint = new HelloPrint();
    }

    void run() {
        String str = "No";
        this.helloPrint.helloPrint(str);
    }

    public static void main(String args[]){
        HelloNoDI helloNoDI = new HelloNoDI();
        helloNoDI.run();
    }
}
```
見てもこれだけじゃよくわからないですよね。
次のコードが、<strong>依存性の注入あり</strong>のソースコードです。

```java:依存性の注入ありのソースコード
public class HelloDI {
    private HelloPrint helloPrint;

    HelloDI(HelloPrint helloPrint){
        this.helloPrint = helloPrint;
    }

    void run() {
        String str = "Yes";
        this.helloPrint.helloPrint(str);
    }

    public static void main(String args[]){
        HelloPrint helloPrint = new HelloPrint();
        HelloDI helloDI = new HelloDI(helloPrint);
        helloDI.run();
    }
}
```

まず一つ目の違いは、<font color="Red"><strong>コンストラクタの引数の有無</strong></font>です。<strong>依存性の注入なし</strong>の場合は引数がなくて、<strong>依存性の注入あり</strong>の場合は、引数があります。また、<strong>依存性のなし</strong>の場合は<font color="Red"><strong>`HelloPrint`のインスタンスの生成をコンストラクタ内</strong></font>で行っていますが<strong>依存性のあり</strong>の場合は、<font color="Red"><strong>コンストラクタの引数を代入</strong></font>しています。
```diff
// 依存性の注入なし
-    HelloNoDI(){
-       this.helloPrint = new HelloPrint();
-    }

// 依存性の注入あり
+    HelloDI(HelloPrint helloPrint){
+       this.helloPrint = helloPrint;
+    }

```

二つ目の違いは、コンストラクタ呼び出し前の<font color="Red"><strong>`HelloPrint`のインスタンスの生成の有無</strong></font>です。<strong>依存性のなし</strong>の場合は何もせず、<strong>依存性のあり</strong>の場合は、<font color="Red"><strong>`HelloPrint`のインスタンスの生成</strong></font>を行って、それを<font color="Red"><strong>コンストラクタの引数に追加</strong></font>して呼び出しています。
```diff
// 依存性の注入なし
-    public static void main(String args[]){
-        HelloNoDI helloNoDI = new HelloNoDI();
-        helloNoDI.run();
-    }


// 依存性の注入あり
+   public static void main(String args[]){
+       HelloPrint helloPrint = new HelloPrint();
+       HelloDI helloDI = new HelloDI(helloPrint);
+       helloDI.run();
+   }
```

これを見ると<strong>依存性の注入あり</strong>の場合は<strong>mainメソッド(今回の外部にあたるもの)</strong>から<strong>オブジェクト(`HelloPrint`のインスタンス)</strong>を<strong>グローバル変数のhelloPrint に注入(コンストラクタの引数を介して代入)</strong>しています。

一方で、<strong>依存性の注入なし</strong>の場合は、コンストラクタ内で<strong>オブジェクト(`HelloPrint`のインスタンス)を注入(代入)</strong>しているので、<strong>クラス同士(`HelloNoDI`と`HelloPrint`)の依存性(結びつき)が強い</strong>と言えます。

以上がDIの説明です。コードがシンプルなのであまり違いがわからないと思いますが、<strong>依存性の注入あり</strong>で実装すると<font color="Red"><strong>ソースコードの再利用性や拡張性が向上</strong></font>します。また、外部からのオブジェクトの注入が可能になるため、<font color="Red"><strong>テスト時にモックオブジェクトなどを用いることも容易</strong></font>になります。

<h2>DIコンテナとは何か</h2>
DIコンテナには以下のような役割があります。

- <strong>Beanの登録</strong>：アノテーションや設定ファイルを通じて、オブジェクトをDIコンテナに登録することができます。これにより、アプリケーション内でそのオブジェクトが必要な場面で自動的に提供されるようになります。
:::note info
使用するアノテーション例：<strong>@Component</strong>, <strong>@Bean</strong>, <strong>@Configuration</strong>, <strong>@Service</strong>, <strong>@Repository</strong>, <strong>@Controller</strong>
:::

- <strong>依存性の注入の自動化</strong>：開発者は、インスタンスを手動で生成やクラスに代入するといった処理を書く必要がなくなります。アノテーションを付与したり、メソッドの引数に型を指定するだけで、DIコンテナが適切なオブジェクトを自動で注入してくれます。
:::note info
使用するアノテーション例：<strong>@Autowired</strong>, <strong>@Inject</strong>
:::
  
- <strong>Beanのライフサイクルの管理</strong>：DIコンテナは、Beanの生成、初期化、破棄などのBeanのライフサイクルを管理します。例えば、アプリケーションの開始時に特定の動作を行うための初期化メソッドや、アプリケーションの終了時にリソースを解放するための終了メソッドを指定することができます。
:::note info
使用するアノテーション例：<strong>@PostConstruct</strong>, <strong>@PreDestroy </strong>
:::

- <strong>設定ファイルの一元管理</strong>：アプリケーションの設定情報やBeanの定義などを一元的に管理することができます。これにより、設定変更や機能追加を行う際の変更範囲を最小限に抑えることができます。


### Beanの登録
Springでは、アプリケーションの<strong>コンポーネント（部品や機能）</strong>を<strong>Beanとして管理</strong>します。Beanとは、Springの中で管理されるオブジェクトやクラスのことを指します。これらのBeanは、<strong>対象のクラスやメソッドに特定のアノテーションを付与</strong>したり、<strong>XMLの設定ファイルに記述すること（古いバージョン）</strong>でSpringの<strong>DIコンテナ（保管庫）</strong>に登録され、アプリケーションがそれを必要とする時に提供されます。

図にすると以下のような感じです。

```plantuml

@startuml
<style>
root {
  Padding 0
  Margin 0
}
title {
  FontStyle bold
  FontColor red
  FontSize 60
}
</style>
title

<img:https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2663952/28c7ac4e-240b-6307-e0bc-4afee0eb41c7.png>

Bean登録のイメージ図

end title

@enduml
```


以下は`HelloPrint`をDIコンテナに登録するサンプルコードです。
```java:HelloPrintをDIコンテナに登録するサンプルコード
import org.springframework.stereotype.Component;

@Component
public class HelloPrint {
    void helloPrint(String str) {
        System.out.println("Hello "+ str +" DI!");
    }
}
```
古いバージョンのSpringだとXMLで記述するかもしれません。
```xml:HelloPrintをDIコンテナに登録するサンプルコード(XML)
<beans>
    <bean id="helloPrint" class="com.example.HelloPrint"/>
</beans>
```

### 依存性の注入の自動化

<strong>依存性の注入の自動化</strong>は先ほどの図の「<strong>DI(依存性の注入)</strong>」の部分に当たります。
```plantuml

@startuml
<style>
root {
  Padding 0
  Margin 0
}
title {
  FontStyle bold
  FontColor red
  FontSize 60
}
</style>
title

<img:https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2663952/28c7ac4e-240b-6307-e0bc-4afee0eb41c7.png>

Bean登録のイメージ図

end title

@enduml
```

以下は`HelloPrint`の依存性の注入を自動化したサンプルコードです。このコードでは`HelloService`クラスのhelloPrintフィールドに`HelloPrint`のインスタンスを生成るコードが不要で「**this.helloPrint**」にオブジェクトが自動的に注入されることを確認できます。
```java:HelloPrintの依存性の注入を自動化したサンプルコード

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class HelloService {

    private final HelloPrint helloPrint;

    @Autowired
    public HelloService(HelloPrint helloPrint) {
        this.helloPrint = helloPrint;
    }

    public void greet(String str) {
        helloPrint.helloPrint(str);
    }
}
```
:::note info
このサンプルコードでは、コンストラクタが1つだけの場合、<strong>@Autowired</strong>アノテーションは省略可能です。
:::
:::note warn
依存性の注入を自動化するためには、対象クラスもBeanとして登録されている必要があります。今回の例では、<strong>@Service</strong>アノテーションによってBeanとして登録されています。
:::

### Beanのライフサイクルの管理
SpringのBeanのライフサイクルは、SpringのコンテナがBeanを管理する際のライフサイクルを意味します。ライフサイクルとは、Beanのインスタンス化、依存性の注入、初期化、使用、破棄などがあげられます。

以下はライフサイクルを示すサンプルコードです。
<font color="Red"><strong>@PostConstruct</strong></font>は<font color="Red"><strong>Beanの初期化時(アプリ起動時)</strong></font>、<font color="Red"><strong>@PreDestroy</strong></font>は<font color="Red"><strong>Beanの破棄時(アプリ終了時)</strong></font>に呼ばれるメソッドを指定するためのアノテーションです。

```java:ライフサイクルの設定サンプルコード
import org.springframework.stereotype.Component;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

@Component
public class LifecycleBean {

    @PostConstruct
    public void init() {
        System.out.println("LifecycleBean is initialized.");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("LifecycleBean is about to be destroyed.");
    }
}
```

以下は、起動時のコンソール出力の結果です。この出力は、`LifecycleBean`が初期化されたことを示しています。
以下のメッセージが出力がされていると思います。
**LifecycleBean is initialized.**

```diff:起動時のコンソール出力
  .   ____          _            __ _ _ 
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.3)

2023-09-21T15:23:17.831+09:00  INFO 4940 --- [  restartedMain] com.app.login.LoginApplication
: Starting LoginApplication using Java 17.0.4.1 with PID 4940 (C:\Java\workspace\Login\login\bin\main started by takeru in C:\Java\workspace\Login)
2023-09-21T15:23:17.835+09:00  INFO 4940 --- [  restartedMain] com.app.login.LoginApplication
: No active profile set, falling back to 1 default profile: "default"
2023-09-21T15:23:17.941+09:00  INFO 4940 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor 
: Devtools property defaults active! Set 'spring.devtools.add-properties' to 'false' to disable
2023-09-21T15:23:17.943+09:00  INFO 4940 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor 
: For additional web related logging consider setting the 'logging.level.web' property to 'DEBUG'       
2023-09-21T15:23:20.916+09:00  INFO 4940 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  
: Tomcat initialized with port(s): 8080 (http)
2023-09-21T15:23:20.937+09:00  INFO 4940 --- [  restartedMain] o.apache.catalina.core.StandardService   
: Starting service [Tomcat]
2023-09-21T15:23:20.939+09:00  INFO 4940 --- [  restartedMain] o.apache.catalina.core.StandardEngine    
: Starting Servlet engine: [Apache Tomcat/10.1.12]
2023-09-21T15:23:21.082+09:00  INFO 4940 --- [  restartedMain] o.a.c.c.C.[Tomcat].[localhost].[/]       
: Initializing Spring embedded WebApplicationContext
2023-09-21T15:23:21.086+09:00  INFO 4940 --- [  restartedMain] w.s.c.ServletWebServerApplicationContext 
: Root WebApplicationContext: initialization completed in 3139 ms
+ LifecycleBean is initialized.
2023-09-21T15:23:22.129+09:00  INFO 4940 --- [  restartedMain] o.s.s.web.DefaultSecurityFilterChain     
: Will secure any request with [org.springframework.security.web.session.DisableEncodeUrlFilter@32a7c477, org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@7e650ece, org.springframework.security.web.context.SecurityContextHolderFilter@6c35240a, org.springframework.security.web.header.HeaderWriterFilter@56095e54, org.springframework.web.filter.CorsFilter@4eb72c9e, org.springframework.security.web.authentication.logout.LogoutFilter@51d1b33c, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@443deafc, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@2f863f1, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@7fb314c1, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5ef1aaff, org.springframework.security.web.access.ExceptionTranslationFilter@3fe379d3, org.springframework.security.web.access.intercept.AuthorizationFilter@1d1b5b7c]
2023-09-21T15:23:22.513+09:00  INFO 4940 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is 
running on port 35729
2023-09-21T15:23:22.586+09:00  INFO 4940 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-09-21T15:23:22.604+09:00  INFO 4940 --- [  restartedMain] com.app.login.LoginApplication           : Started LoginApplication in 5.521 seconds (process running for 6.32)
```

以下は、終了時のコンソール出力の結果です。この出力は、`LifecycleBean`が破棄される直前のことを示しています。 最後の行に以下のメッセージが出力がされていると思います。
最後の行に以下のメッセージが出力がされていると思います。
**LifecycleBean is about to be destroyed.**
```diff:終了時のコンソール出力
    .   ____          _            __ _ _ 
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.3)

2023-09-21T15:23:17.831+09:00  INFO 4940 --- [  restartedMain] com.app.login.LoginApplication
: Starting LoginApplication using Java 17.0.4.1 with PID 4940 (C:\Java\workspace\Login\login\bin\main started by takeru in C:\Java\workspace\Login)
2023-09-21T15:23:17.835+09:00  INFO 4940 --- [  restartedMain] com.app.login.LoginApplication
: No active profile set, falling back to 1 default profile: "default"
2023-09-21T15:23:17.941+09:00  INFO 4940 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor 
: Devtools property defaults active! Set 'spring.devtools.add-properties' to 'false' to disable
2023-09-21T15:23:17.943+09:00  INFO 4940 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor 
: For additional web related logging consider setting the 'logging.level.web' property to 'DEBUG'       
2023-09-21T15:23:20.916+09:00  INFO 4940 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  
: Tomcat initialized with port(s): 8080 (http)
2023-09-21T15:23:20.937+09:00  INFO 4940 --- [  restartedMain] o.apache.catalina.core.StandardService   
: Starting service [Tomcat]
2023-09-21T15:23:20.939+09:00  INFO 4940 --- [  restartedMain] o.apache.catalina.core.StandardEngine    
: Starting Servlet engine: [Apache Tomcat/10.1.12]
2023-09-21T15:23:21.082+09:00  INFO 4940 --- [  restartedMain] o.a.c.c.C.[Tomcat].[localhost].[/]       
: Initializing Spring embedded WebApplicationContext
2023-09-21T15:23:21.086+09:00  INFO 4940 --- [  restartedMain] w.s.c.ServletWebServerApplicationContext 
: Root WebApplicationContext: initialization completed in 3139 ms
LifecycleBean is initialized.
2023-09-21T15:23:22.129+09:00  INFO 4940 --- [  restartedMain] o.s.s.web.DefaultSecurityFilterChain     
: Will secure any request with [org.springframework.security.web.session.DisableEncodeUrlFilter@32a7c477, org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@7e650ece, org.springframework.security.web.context.SecurityContextHolderFilter@6c35240a, org.springframework.security.web.header.HeaderWriterFilter@56095e54, org.springframework.web.filter.CorsFilter@4eb72c9e, org.springframework.security.web.authentication.logout.LogoutFilter@51d1b33c, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@443deafc, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@2f863f1, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@7fb314c1, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5ef1aaff, org.springframework.security.web.access.ExceptionTranslationFilter@3fe379d3, org.springframework.security.web.access.intercept.AuthorizationFilter@1d1b5b7c]
2023-09-21T15:23:22.513+09:00  INFO 4940 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is 
running on port 35729
2023-09-21T15:23:22.586+09:00  INFO 4940 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-09-21T15:23:22.604+09:00  INFO 4940 --- [  restartedMain] com.app.login.LoginApplication           : Started LoginApplication in 5.521 seconds (process running for 6.32)
+ LifecycleBean is about to be destroyed.
```

### 設定ファイルの一元管理
設定ファイルを一元管理することで、システムの設定やメッセージなどの情報を一箇所にまとめることができます。このアプローチにより、変更が必要な場合や設定値を参照する際に、該当の情報を簡単に探し出しやすくなります。


以下は、`LifecycleBean`の初期化時と破棄時メッセージを<font color="Red"><strong>application.properties</strong></font>に外部化しました。
```properties:application.properties
app.init.message=LifecycleBean is initialized.
app.destroy.message=LifecycleBean is about to be destroyed.
```

以下は<font color="Red"><strong>application.properties</strong></font>に設定したメッセージを取得するサンプルコードです。「<font color="Red"><strong>@Valueアノテーション</strong></font>」を使用することで設定ファイルの値をJavaで取得できるようになります。
```java:プロパティファイルから取得するメッセージ取得のサンプルコード
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConfigurationSampleBean {

    @Value("${app.init.message}")
    private String initMessage;

    @Value("${app.destroy.message}")
    private String destroyMessage;

    public String getInitMessage() {
        return this.initMessage;
    }

    public String getDestroyMessage() {
        return this.destroyMessage;
    }
}
```
`LifecycleBean`で設定していたメッセージを`ConfigurationSampleBean`から取得するように修正しています。
```java:修正後のLifecycleBean
package com.app.login.configurations;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

@Component
public class LifecycleBean {

    private ConfigurationSampleBean configurationSampleBean;

    LifecycleBean(ConfigurationSampleBean configurationSampleBean){
        this.configurationSampleBean = configurationSampleBean;
    }

    @PostConstruct
    public void init() {
        System.out.println(this.configurationSampleBean.getInitMessage());
    }

    @PreDestroy
    public void destroy() {
        System.out.println(this.configurationSampleBean.getDestroyMessage());
    }
}
```

以下は、起動時のコンソール出力の結果です。この出力は、`LifecycleBean`が初期化されたことを示しています。
以下のメッセージが出力がされていると思います。
**LifecycleBean is initialized.**
```diff: 起動時のコンソール出力
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.3)

2023-09-21T16:16:19.197+09:00  INFO 6448 --- [  restartedMain] com.app.login.LoginApplication           : Starting LoginApplication using Java 17.0.4.1 with PID 6448 (C:\Java\workspace\Login\login\bin\main started by takeru in C:\Java\workspace\Login)   
2023-09-21T16:16:19.201+09:00  INFO 6448 --- [  restartedMain] com.app.login.LoginApplication           : No active profile set, falling back to 1 default profile: "default"
2023-09-21T16:16:19.312+09:00  INFO 6448 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : Devtools property defaults active! Set 'spring.devtools.add-properties' to 'false' to disable
2023-09-21T16:16:19.313+09:00  INFO 6448 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : For additional web related logging consider setting the 'logging.level.web' property to 'DEBUG'
2023-09-21T16:16:22.075+09:00  INFO 6448 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2023-09-21T16:16:22.118+09:00  INFO 6448 --- [  restartedMain] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-09-21T16:16:22.123+09:00  INFO 6448 --- [  restartedMain] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.12]
2023-09-21T16:16:22.312+09:00  INFO 6448 --- [  restartedMain] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2023-09-21T16:16:22.318+09:00  INFO 6448 --- [  restartedMain] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3000 ms
+ LifecycleBean is initialized.
2023-09-21T16:16:23.425+09:00  INFO 6448 --- [  restartedMain] o.s.s.web.DefaultSecurityFilterChain     : Will secure any request with [org.springframework.security.web.session.DisableEncodeUrlFilter@37a46c54, org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@e52b243, org.springframework.security.web.context.SecurityContextHolderFilter@4bc2ec5, org.springframework.security.web.header.HeaderWriterFilter@4eb72c9e, org.springframework.web.filter.CorsFilter@e2e6051, org.springframework.security.web.authentication.logout.LogoutFilter@6455a2a4, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@4429b5d4, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@206dcbce, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@213502ab, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@73abefcc, org.springframework.security.web.access.ExceptionTranslationFilter@32a7c477, org.springframework.security.web.access.intercept.AuthorizationFilter@1ad34c99]
2023-09-21T16:16:23.811+09:00  INFO 6448 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is 
running on port 35729
2023-09-21T16:16:23.909+09:00  INFO 6448 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-09-21T16:16:23.927+09:00  INFO 6448 --- [  restartedMain] com.app.login.LoginApplication           : Started LoginApplication in 5.425 seconds (process running for 6.112)
```

以下は、終了時のコンソール出力の結果です。この出力は、`LifecycleBean`が破棄される直前のことを示しています。 
最後の行に以下のメッセージが出力がされていると思います。
**LifecycleBean is about to be destroyed.**
```diff:終了時のコンソール出力
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.3)

2023-09-21T16:16:19.197+09:00  INFO 6448 --- [  restartedMain] com.app.login.LoginApplication           : Starting LoginApplication using Java 17.0.4.1 with PID 6448 (C:\Java\workspace\Login\login\bin\main started by takeru in C:\Java\workspace\Login)   
2023-09-21T16:16:19.201+09:00  INFO 6448 --- [  restartedMain] com.app.login.LoginApplication           : No active profile set, falling back to 1 default profile: "default"
2023-09-21T16:16:19.312+09:00  INFO 6448 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : Devtools property defaults active! Set 'spring.devtools.add-properties' to 'false' to disable
2023-09-21T16:16:19.313+09:00  INFO 6448 --- [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : For additional web related logging consider setting the 'logging.level.web' property to 'DEBUG'
2023-09-21T16:16:22.075+09:00  INFO 6448 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2023-09-21T16:16:22.118+09:00  INFO 6448 --- [  restartedMain] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-09-21T16:16:22.123+09:00  INFO 6448 --- [  restartedMain] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.12]
2023-09-21T16:16:22.312+09:00  INFO 6448 --- [  restartedMain] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2023-09-21T16:16:22.318+09:00  INFO 6448 --- [  restartedMain] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3000 ms
LifecycleBean is initialized.
2023-09-21T16:16:23.425+09:00  INFO 6448 --- [  restartedMain] o.s.s.web.DefaultSecurityFilterChain     : Will secure any request with [org.springframework.security.web.session.DisableEncodeUrlFilter@37a46c54, org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@e52b243, org.springframework.security.web.context.SecurityContextHolderFilter@4bc2ec5, org.springframework.security.web.header.HeaderWriterFilter@4eb72c9e, org.springframework.web.filter.CorsFilter@e2e6051, org.springframework.security.web.authentication.logout.LogoutFilter@6455a2a4, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@4429b5d4, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@206dcbce, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@213502ab, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@73abefcc, org.springframework.security.web.access.ExceptionTranslationFilter@32a7c477, org.springframework.security.web.access.intercept.AuthorizationFilter@1ad34c99]
2023-09-21T16:16:23.811+09:00  INFO 6448 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is 
running on port 35729
2023-09-21T16:16:23.909+09:00  INFO 6448 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-09-21T16:16:23.927+09:00  INFO 6448 --- [  restartedMain] com.app.login.LoginApplication           : Started LoginApplication in 5.425 seconds (process running for 6.112)
+ LifecycleBean is about to be destroyed.
```