title: Bean of type 'org.springframework.security.oauth2.client.registration.ClientRegistrationRepository' that could not be found. - Spring Security
body: <p>I am developing a spring application with spring-security and login with google but I get this error when executing the application:</p>
  
  <pre><code>***************************
  APPLICATION FAILED TO START
  ***************************
  
  Description:
  
  Method springSecurityFilterChain in org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration required a bean of type 'org.springframework.security.oauth2.client.registration.ClientRegistrationRepository' that could not be found.
  
  The following candidates were found but could not be injected:
      - Bean method 'clientRegistrationRepository' in 'OAuth2ClientRegistrationRepositoryConfiguration' not loaded because OAuth2 Clients Configured Condition registered clients is not available
  
  
  Action:
  
  Consider revisiting the entries above or defining a bean of type 'org.springframework.security.oauth2.client.registration.ClientRegistrationRepository' in your configuration.
  </code></pre>
  
  <p>My application.yml:</p>
  
  <pre><code>spring:
      datasource:
          url: jdbc:mysql://localhost:3306/manager
          username: application_spring
          password: application_spring
  
      jpa:
          show-sql: true
          hibernate:
              ddl-auto: update
  security:
        oauth2:
          client:
            registration:
              google:
                client-id: {client id}
                client-secret: {client-secret}
                redirectUri: "{baseUrl}/oauth2/callback/{registrationId}"
                scope:
                  - email
                  - profile
  app:
    auth:
      tokenSecret: 926D96C90030DD58429D2751AC1BDBBC
      tokenExpirationMsec: 864000000
    oauth2:
      # After successfully authenticating with the OAuth2 Provider,
      # we'll be generating an auth token for the user and sending the token to the
      # redirectUri mentioned by the frontend client in the /oauth2/authorize request.
      # We're not using cookies because they won't work well in mobile clients.
      authorizedRedirectUris:
        - http://localhost:3000/oauth2/redirect
        - myandroidapp://oauth2/redirect
        - myiosapp://oauth2/redirect
  </code></pre>
  
  <p>And my SecurityConfig class: </p>
  
  <pre><code>package com.manager.manager.config;
  
  import org.springframework.context.annotation.Configuration;
  import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Bean;
  import org.springframework.security.authentication.AuthenticationManager;
  import org.springframework.security.config.BeanIds;
  import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  import org.springframework.security.config.http.SessionCreationPolicy;
  import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  import org.springframework.security.crypto.password.PasswordEncoder;
  import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
  import org.springframework.security.oauth2.client.web.AuthorizationRequestRepository;
  import org.springframework.security.oauth2.core.endpoint.OAuth2AuthorizationRequest;
  import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  
  import com.manager.manager.security.oatuh2.CustomOAuth2UserService;
  import com.manager.manager.security.oatuh2.HttpCookieOAuth2AuthorizationRequestRepository;
  import com.manager.manager.security.oatuh2.OAuth2AuthenticationFailureHandler;
  import com.manager.manager.security.oatuh2.OAuth2AuthenticationSuccessHandler;
  import com.manager.manager.security.utils.RestAuthenticationEntryPoint;
  import com.manager.manager.security.utils.TokenAuthenticationFilter;
  import com.manager.manager.service.impl.CustomUserDetailsService;
  
  @Configuration
  @EnableWebSecurity
  @EnableGlobalMethodSecurity(
          securedEnabled = true,
          jsr250Enabled = true,
          prePostEnabled = true
  )
  public class SecurityConfig extends WebSecurityConfigurerAdapter {
      @Autowired
      private CustomUserDetailsService customUserDetailsService;
  
      @Autowired
      private CustomOAuth2UserService customOAuth2UserService;
  
      @Autowired
      private OAuth2AuthenticationSuccessHandler oAuth2AuthenticationSuccessHandler;
  
      @Autowired
      private OAuth2AuthenticationFailureHandler oAuth2AuthenticationFailureHandler;
  
      @Autowired
      private HttpCookieOAuth2AuthorizationRequestRepository httpCookieOAuth2AuthorizationRequestRepository;
  
      @Bean
      public TokenAuthenticationFilter tokenAuthenticationFilter() {
          return new TokenAuthenticationFilter();
      }
  
      /*
        By default, Spring OAuth2 uses HttpSessionOAuth2AuthorizationRequestRepository to save
        the authorization request. But, since our service is stateless, we can't save it in
        the session. We'll save the request in a Base64 encoded cookie instead.
      */
      @Bean
      public HttpCookieOAuth2AuthorizationRequestRepository cookieAuthorizationRequestRepository() {
          return new HttpCookieOAuth2AuthorizationRequestRepository();
      }
  
      @Override
      public void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
          authenticationManagerBuilder
                  .userDetailsService(customUserDetailsService)
                  .passwordEncoder(passwordEncoder());
      }
  
      @Bean
      public PasswordEncoder passwordEncoder() {
          return new BCryptPasswordEncoder();
      }
  
      @Bean(BeanIds.AUTHENTICATION_MANAGER)
      @Override
      public AuthenticationManager authenticationManagerBean() throws Exception {
          return super.authenticationManagerBean();
      }
  
      @Override
      protected void configure(HttpSecurity http) throws Exception {
          http
                  .cors()
                      .and()
                  .sessionManagement()
                      .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                      .and()
                  .csrf()
                      .disable()
                  .formLogin()
                      .disable()
                  .httpBasic()
                      .disable()
                  .exceptionHandling()
                      .authenticationEntryPoint(new RestAuthenticationEntryPoint())
                      .and()
                  .authorizeRequests()
                      .antMatchers("/",
                          "/error",
                          "/favicon.ico",
                          "/**/*.png",
                          "/**/*.gif",
                          "/**/*.svg",
                          "/**/*.jpg",
                          "/**/*.html",
                          "/**/*.css",
                          "/**/*.js")
                          .permitAll()
                      .antMatchers("/auth/**", "/oauth2/**")
                          .permitAll()
                      .anyRequest()
                          .authenticated()
                      .and()
                  .oauth2Login()
                      .authorizationEndpoint()
                          .baseUri("/oauth2/authorize")
                          .authorizationRequestRepository(cookieAuthorizationRequestRepository())
                          .and()
                      .redirectionEndpoint()
                          .baseUri("/oauth2/callback/*")
                          .and()
                      .userInfoEndpoint()
                          .userService(customOAuth2UserService)
                          .and()
                      .successHandler(oAuth2AuthenticationSuccessHandler)
                      .failureHandler(oAuth2AuthenticationFailureHandler);
  
          // Add our custom Token based authentication filter
          http.addFilterBefore(tokenAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
      }
  
  
  
  }
  </code></pre>
  
  <p>To do this app I was following this tutorial : 
  <a href="https://www.callicoder.com/spring-boot-security-oauth2-social-login-part-2/" rel="noreferrer">https://www.callicoder.com/spring-boot-security-oauth2-social-login-part-2/</a></p>
  
  <p>Anybody knows what could be the problem? 
  Thanks</p>