Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

spring-5-reactive-oauth/src/main/java/com/baeldung/reactive/oauth/SecurityConfig.java

@@ -0,0 +1,19 @@
+package com.baeldung.reactive.oauth;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@EnableWebFluxSecurity
+public class SecurityConfig {
+
+        @Bean
+        public SecurityWebFilterChain configure(ServerHttpSecurity http) throws Exception {
+            return http.authorizeExchange()
+                .pathMatchers("/about").permitAll()
+                .anyExchange().authenticated()
+                .and().oauth2Login()
+                .and().build();
+        }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/reactive/oauth/Spring5ReactiveOauthApplication.java

@@ -0,0 +1,27 @@
+package com.baeldung.reactive.oauth;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.security.oauth2.client.registration.ReactiveClientRegistrationRepository;
+import org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction;
+import org.springframework.security.oauth2.client.web.server.ServerOAuth2AuthorizedClientRepository;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@PropertySource("classpath:default-application.yml")
+@SpringBootApplication
+public class Spring5ReactiveOauthApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Spring5ReactiveOauthApplication.class, args);
+    }
+
+    @Bean
+    public WebClient webClient(ReactiveClientRegistrationRepository clientRegistrationRepo, ServerOAuth2AuthorizedClientRepository authorizedClientRepo) {
+        ServerOAuth2AuthorizedClientExchangeFilterFunction filter = new ServerOAuth2AuthorizedClientExchangeFilterFunction(clientRegistrationRepo, authorizedClientRepo);
+        return WebClient.builder()
+            .filter(filter)
+            .build();
+    }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/reactive/oauth/web/MainController.java

@@ -0,0 +1,46 @@
+package com.baeldung.reactive.oauth.web;
+
+import static org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction.oauth2AuthorizedClient;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.annotation.RegisteredOAuth2AuthorizedClient;
+import org.springframework.security.oauth2.core.user.OAuth2User;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import reactor.core.publisher.Mono;
+
+import com.baeldung.reactive.oauth.web.dto.Foo;
+
+@RestController
+public class MainController {
+    
+    @Autowired
+    private WebClient webClient;
+    
+    @GetMapping("/")
+    public Mono<String> index(@AuthenticationPrincipal Mono<OAuth2User> oauth2User) {
+       return oauth2User
+        .map(OAuth2User::getName)
+        .map(name -> String.format("Hi, %s", name));
+    }
+    
+    @GetMapping("/foos/{id}")
+    public Mono<Foo> getFooResource(@RegisteredOAuth2AuthorizedClient("custom") OAuth2AuthorizedClient client, @PathVariable final long id){
+        return webClient
+            .get()
+            .uri("http://localhost:8088/spring-security-oauth-resource/foos/{id}", id)
+            .attributes(oauth2AuthorizedClient(client))
+            .retrieve()
+        .bodyToMono(Foo.class); 
+    }
+   
+    @GetMapping("/about")
+    public String getAboutPage() {
+       return "WebFlux OAuth example";
+    }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/reactive/oauth/web/dto/Foo.java

@@ -0,0 +1,35 @@
+package com.baeldung.reactive.oauth.web.dto;
+
+public class Foo {
+    private long id;
+    private String name;
+
+    public Foo() {
+        super();
+    }
+
+    public Foo(final long id, final String name) {
+        super();
+
+        this.id = id;
+        this.name = name;
+    }
+
+    //
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodeclient/OauthClientApplication.java

@@ -0,0 +1,24 @@
+package com.baeldung.webclient.authorizationcodeclient;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.PropertySource;
+
+/**
+ * 
+ * Note: This app is configured to use the authorization service and the resource service located in Baeldung/spring-security-oauth repo
+ * 
+ * As we usually do with other well-known auth providers (github/facebook/...) we have to log-in using user credentials (john/123) and client configurations handled by the auth server
+ * 
+ * @author rozagerardo
+ *
+ */
+@PropertySource("classpath:webclient-auth-code-client-application.properties")
+@SpringBootApplication
+public class OauthClientApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(OauthClientApplication.class, args);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodeclient/configuration/WebClientConfig.java

@@ -0,0 +1,20 @@
+package com.baeldung.webclient.authorizationcodeclient.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.oauth2.client.registration.ReactiveClientRegistrationRepository;
+import org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction;
+import org.springframework.security.oauth2.client.web.server.ServerOAuth2AuthorizedClientRepository;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    WebClient webClientForAuthorized(ReactiveClientRegistrationRepository clientRegistrations, ServerOAuth2AuthorizedClientRepository authorizedClients) {
+        ServerOAuth2AuthorizedClientExchangeFilterFunction oauth = new ServerOAuth2AuthorizedClientExchangeFilterFunction(clientRegistrations, authorizedClients);
+        return WebClient.builder()
+            .filter(oauth)
+            .build();
+    }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodeclient/configuration/WebSecurityConfig.java

@@ -0,0 +1,22 @@
+package com.baeldung.webclient.authorizationcodeclient.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@Configuration
+public class WebSecurityConfig {
+    @Bean
+    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .authenticated()
+            .and()
+            .oauth2Client()
+            .and()
+            .formLogin();
+        return http.build();
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodeclient/web/ClientRestController.java

@@ -0,0 +1,53 @@
+package com.baeldung.webclient.authorizationcodeclient.web;
+
+import static org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction.clientRegistrationId;
+import static org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction.oauth2AuthorizedClient;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.annotation.RegisteredOAuth2AuthorizedClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import reactor.core.publisher.Mono;
+
+@RestController
+public class ClientRestController {
+
+    private static final String RESOURCE_URI = "http://localhost:8082/spring-security-oauth-resource/foos/1";
+
+    @Autowired
+    WebClient webClient;
+
+    @GetMapping("/auth-code")
+    Mono<String> useOauthWithAuthCode() {
+        Mono<String> retrievedResource = webClient.get()
+            .uri(RESOURCE_URI)
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string);
+    }
+
+    @GetMapping("/auth-code-annotated")
+    Mono<String> useOauthWithAuthCodeAndAnnotation(@RegisteredOAuth2AuthorizedClient("bael") OAuth2AuthorizedClient authorizedClient) {
+        Mono<String> retrievedResource = webClient.get()
+            .uri(RESOURCE_URI)
+            .attributes(oauth2AuthorizedClient(authorizedClient))
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string + ". Principal associated: " + authorizedClient.getPrincipalName() + ". Token will expire at: " + authorizedClient.getAccessToken()
+            .getExpiresAt());
+    }
+
+    @GetMapping("/auth-code-explicit-client")
+    Mono<String> useOauthWithExpicitClient() {
+        Mono<String> retrievedResource = webClient.get()
+            .uri(RESOURCE_URI)
+            .attributes(clientRegistrationId("bael"))
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodelogin/OauthClientLoginApplication.java

@@ -0,0 +1,24 @@
+package com.baeldung.webclient.authorizationcodelogin;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.PropertySource;
+
+/**
+ * 
+ * Note: This app is configured to use the authorization service and the resource service located in Baeldung/spring-security-oauth repo
+ * 
+ * As we usually do with other well-known auth providers (github/facebook/...) we have to log-in using user credentials (john/123) and client configurations handled by the auth server
+ * 
+ * @author rozagerardo
+ *
+ */
+@PropertySource("classpath:webclient-auth-code-login-application.properties")
+@SpringBootApplication
+public class OauthClientLoginApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(OauthClientLoginApplication.class, args);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodelogin/configuration/WebClientConfig.java

@@ -0,0 +1,31 @@
+package com.baeldung.webclient.authorizationcodelogin.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.security.oauth2.client.registration.ReactiveClientRegistrationRepository;
+import org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction;
+import org.springframework.security.oauth2.client.web.server.ServerOAuth2AuthorizedClientRepository;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    @Primary
+    WebClient webClientForAuthorized(ReactiveClientRegistrationRepository clientRegistrations, ServerOAuth2AuthorizedClientRepository authorizedClients) {
+        ServerOAuth2AuthorizedClientExchangeFilterFunction oauth = new ServerOAuth2AuthorizedClientExchangeFilterFunction(clientRegistrations, authorizedClients);
+        oauth.setDefaultOAuth2AuthorizedClient(true);
+        return WebClient.builder()
+            .filter(oauth)
+            .build();
+    }
+
+    @Bean
+    WebClient otherWebClient(ReactiveClientRegistrationRepository clientRegistrations, ServerOAuth2AuthorizedClientRepository authorizedClients) {
+        ServerOAuth2AuthorizedClientExchangeFilterFunction oauth = new ServerOAuth2AuthorizedClientExchangeFilterFunction(clientRegistrations, authorizedClients);
+        return WebClient.builder()
+            .filter(oauth)
+            .build();
+    }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodelogin/configuration/WebSecurityConfig.java

@@ -0,0 +1,20 @@
+package com.baeldung.webclient.authorizationcodelogin.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@Configuration
+public class WebSecurityConfig {
+    @Bean
+    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .authenticated()
+            .and()
+            .oauth2Login();
+        return http.build();
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/authorizationcodelogin/web/ClientRestController.java

@@ -0,0 +1,68 @@
+package com.baeldung.webclient.authorizationcodelogin.web;
+
+import static org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction.clientRegistrationId;
+import static org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction.oauth2AuthorizedClient;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.annotation.RegisteredOAuth2AuthorizedClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import reactor.core.publisher.Mono;
+
+@RestController
+public class ClientRestController {
+
+    private static final String RESOURCE_URI = "http://localhost:8082/spring-security-oauth-resource/foos/1";
+
+    @Autowired
+    WebClient webClient;
+
+    @Autowired
+    @Qualifier("otherWebClient")
+    WebClient otherWebClient;
+
+    @GetMapping("/auth-code")
+    Mono<String> useOauthWithAuthCode() {
+        Mono<String> retrievedResource = webClient.get()
+            .uri(RESOURCE_URI)
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string);
+    }
+
+    @GetMapping("/auth-code-no-client")
+    Mono<String> useOauthWithNoClient() {
+        // This call will fail, since we don't have the client properly set for this webClient
+        Mono<String> retrievedResource = otherWebClient.get()
+            .uri(RESOURCE_URI)
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string);
+    }
+
+    @GetMapping("/auth-code-annotated")
+    Mono<String> useOauthWithAuthCodeAndAnnotation(@RegisteredOAuth2AuthorizedClient("bael") OAuth2AuthorizedClient authorizedClient) {
+        Mono<String> retrievedResource = otherWebClient.get()
+            .uri(RESOURCE_URI)
+            .attributes(oauth2AuthorizedClient(authorizedClient))
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string + ". Principal associated: " + authorizedClient.getPrincipalName() + ". Token will expire at: " + authorizedClient.getAccessToken()
+            .getExpiresAt());
+    }
+
+    @GetMapping("/auth-code-explicit-client")
+    Mono<String> useOauthWithExpicitClient() {
+        Mono<String> retrievedResource = otherWebClient.get()
+            .uri(RESOURCE_URI)
+            .attributes(clientRegistrationId("bael"))
+            .retrieve()
+            .bodyToMono(String.class);
+        return retrievedResource.map(string -> "We retrieved the following resource using Oauth: " + string);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/clientcredentials/ClientCredentialsOauthApplication.java

@@ -0,0 +1,24 @@
+package com.baeldung.webclient.clientcredentials;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+/**
+ * 
+ * Note: This app is configured to use the authorization service and the resource service located in Baeldung/spring-security-oauth repo
+ * 
+ * @author rozagerardo
+ *
+ */
+@PropertySource("classpath:webclient-client-credentials-oauth-application.properties")
+@EnableScheduling
+@SpringBootApplication
+public class ClientCredentialsOauthApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ClientCredentialsOauthApplication.class, args);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/clientcredentials/configuration/WebClientConfig.java

@@ -0,0 +1,22 @@
+package com.baeldung.webclient.clientcredentials.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.oauth2.client.registration.ReactiveClientRegistrationRepository;
+import org.springframework.security.oauth2.client.web.reactive.function.client.ServerOAuth2AuthorizedClientExchangeFilterFunction;
+import org.springframework.security.oauth2.client.web.server.UnAuthenticatedServerOAuth2AuthorizedClientRepository;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    WebClient webClient(ReactiveClientRegistrationRepository clientRegistrations) {
+        ServerOAuth2AuthorizedClientExchangeFilterFunction oauth = new ServerOAuth2AuthorizedClientExchangeFilterFunction(clientRegistrations, new UnAuthenticatedServerOAuth2AuthorizedClientRepository());
+        oauth.setDefaultClientRegistrationId("bael");
+        return WebClient.builder()
+            .filter(oauth)
+            .build();
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/clientcredentials/service/WebClientChonJob.java

@@ -0,0 +1,31 @@
+package com.baeldung.webclient.clientcredentials.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Component
+public class WebClientChonJob {
+
+    Logger logger = LoggerFactory.getLogger(WebClientChonJob.class);
+
+    private static final String RESOURCE_URI = "localhost:8082/spring-security-oauth-resource/foos/1";
+
+    @Autowired
+    private WebClient webClient;
+
+    @Scheduled(fixedRate = 5000)
+    public void logResourceServiceResponse() {
+
+        webClient.get()
+            .uri(RESOURCE_URI)
+            .retrieve()
+            .bodyToMono(String.class)
+            .map(string -> "We retrieved the following resource using Client Credentials Grant Type: " + string)
+            .subscribe(logger::info);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/manualrequest/ManualRequestApplication.java

@@ -0,0 +1,22 @@
+package com.baeldung.webclient.manualrequest;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.PropertySource;
+
+/**
+ * 
+ * Note: This app is configured to use the authorization service and the resource service located in Baeldung/spring-security-oauth repo
+ * 
+ * @author rozagerardo
+ *
+ */
+@PropertySource("classpath:webclient-manual-request-oauth-application.properties")
+@SpringBootApplication
+public class ManualRequestApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ManualRequestApplication.class, args);
+    }
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/manualrequest/configure/WebClientConfig.java

@@ -0,0 +1,16 @@
+package com.baeldung.webclient.manualrequest.configure;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    public WebClient configureWebClient() {
+        return WebClient.builder()
+            .build();
+    };
+
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/manualrequest/configure/WebSecurityConfig.java

@@ -0,0 +1,17 @@
+package com.baeldung.webclient.manualrequest.configure;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@Configuration
+public class WebSecurityConfig {
+    @Bean
+    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .permitAll();
+        return http.build();
+    }
+}

spring-5-reactive-oauth/src/main/java/com/baeldung/webclient/manualrequest/web/ManualOauthRequestController.java

@@ -0,0 +1,63 @@
+package com.baeldung.webclient.manualrequest.web;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpHeaders;
+import org.springframework.security.oauth2.core.endpoint.OAuth2ParameterNames;
+import org.springframework.util.Base64Utils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.reactive.function.BodyInserters;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.nimbusds.oauth2.sdk.GrantType;
+
+import reactor.core.publisher.Mono;
+
+@RestController
+public class ManualOauthRequestController {
+
+    private static Logger logger = LoggerFactory.getLogger(ManualOauthRequestController.class);
+
+    private static final String RESOURCE_ENDPOINT = "localhost:8082/spring-security-oauth-resource/foos/1";
+    
+    @Value("${the.authorization.client-id}")
+    private String clientId;
+    
+    @Value("${the.authorization.client-secret}")
+    private String clientSecret;
+    
+    @Value("${the.authorization.token-uri}")
+    private String tokenUri;
+    
+    @Autowired
+    WebClient client;
+
+    @GetMapping("/manual-request-oauth")
+    public Mono<String> obtainSecuredResource() {
+        logger.info("Creating web client...");
+        Mono<String> resource = client.post()
+            .uri(tokenUri)
+            .header(HttpHeaders.AUTHORIZATION, "Basic " + Base64Utils.encodeToString((clientId + ":" + clientSecret).getBytes()))
+            .body(BodyInserters.fromFormData(OAuth2ParameterNames.GRANT_TYPE, GrantType.CLIENT_CREDENTIALS.getValue()))
+            .retrieve()
+            .bodyToMono(JsonNode.class)
+            .flatMap(tokenResponse -> {
+                String accessTokenValue = tokenResponse.get("access_token")
+                    .textValue();
+                logger.info("Retrieved the following access token: {}", accessTokenValue);
+                return client.get()
+                    .uri(RESOURCE_ENDPOINT)
+                    .headers(h -> h.setBearerAuth(accessTokenValue))
+                    .retrieve()
+                    .bodyToMono(String.class);
+            });
+        logger.info("non-blocking Oauth calls registered...");
+        return resource.map(res -> "Retrieved the resource using a manual approach: " + res);
+
+    }
+
+}