Course – LSS – NPI (cat=Spring Security)
announcement - icon

If you're working on a Spring Security (and especially an OAuth) implementation, definitely have a look at the Learn Spring Security course:

Course – LS (cat=HTTP Client-Side)

Get started with Spring and Spring Boot, through the Learn Spring course:


1. Overview

In this tutorial, we’ll use Spring Security OAuth to authenticate with the Reddit API.

2. Maven Configuration

First, in order to use Spring Security OAuth – we need to add the following dependency to our pom.xml (of course along any other Spring dependency you might use):


3. Configure OAuth2 Client

Next – let’s configure our OAuth2 client – the OAuth2RestTemplate – and a file for all the authentication related properties:

protected static class ResourceConfiguration {

    private String accessTokenUri;

    private String userAuthorizationUri;

    private String clientID;

    private String clientSecret;

    public OAuth2ProtectedResourceDetails reddit() {
        AuthorizationCodeResourceDetails details = new AuthorizationCodeResourceDetails();
        return details;

    public OAuth2RestTemplate redditRestTemplate(OAuth2ClientContext clientContext) {
        OAuth2RestTemplate template = new OAuth2RestTemplate(reddit(), clientContext);
        AccessTokenProvider accessTokenProvider = new AccessTokenProviderChain(
          Arrays.<AccessTokenProvider> asList(
            new MyAuthorizationCodeAccessTokenProvider(), 
            new ImplicitAccessTokenProvider(), 
            new ResourceOwnerPasswordAccessTokenProvider(),
            new ClientCredentialsAccessTokenProvider())
        return template;


And ““:


You can get your own secret code by creating a Reddit app from

We’re going to use the OAuth2RestTemplate to:

  1. Acquire the access token needed to access the remote resource.
  2. Access the remote resource after getting the access token.

Also note how we added the scope “identity” to Reddit OAuth2ProtectedResourceDetails so that we can retrieve the users account information later.

4. Custom AuthorizationCodeAccessTokenProvider

The Reddit OAuth2 implementation is a little different from the standard. And so – instead of elegantly extending the AuthorizationCodeAccessTokenProvider – we need to actually override some portions of it.

There are github issues tracking improvements that will make this not necessary, but these issues are not yet done.

One of the non-standard things that Reddit does is – when we redirect the user and prompt him to authenticate with Reddit, we need to have some custom parameters in the redirect URL. More specifically – if we’re asking for a permanent access token from Reddit – we need to add a parameter “duration” with the value “permanent“.

So, after extending AuthorizationCodeAccessTokenProvider – we have added this parameter in the getRedirectForAuthorization() method:

    requestParameters.put("duration", "permanent");

You can check the full source code from here.

5. The ServerInitializer

Next – let’s create our custom ServerInitializer.

We need to add a filter bean with id oauth2ClientContextFilter, so that we can use it to store the current context:

public class ServletInitializer extends AbstractDispatcherServletInitializer {

    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext context = 
          new AnnotationConfigWebApplicationContext();
        context.register(WebConfig.class, SecurityConfig.class);
        return context;

    protected String[] getServletMappings() {
        return new String[] { "/" };

    protected WebApplicationContext createRootApplicationContext() {
        return null;

    public void onStartup(ServletContext servletContext) throws ServletException {
        registerProxyFilter(servletContext, "oauth2ClientContextFilter");
        registerProxyFilter(servletContext, "springSecurityFilterChain");

    private void registerProxyFilter(ServletContext servletContext, String name) {
        DelegatingFilterProxy filter = new DelegatingFilterProxy(name);
        servletContext.addFilter(name, filter).addMappingForUrlPatterns(null, false, "/*");

6. MVC Configuration

Now – let’s take a look at our MVC configuration of our simple web-app:

@ComponentScan(basePackages = { "org.baeldung.web" })
public class WebConfig implements WebMvcConfigurer {

    public static PropertySourcesPlaceholderConfigurer 
      propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();

    public ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        return viewResolver;

    public void configureDefaultServletHandling(
      DefaultServletHandlerConfigurer configurer) {

    public void addResourceHandlers(ResourceHandlerRegistry registry) {

    public void addViewControllers(ViewControllerRegistry registry) {

7. Security Configuration

Next – let’s take a look at the main Spring Security configuration:

public class SecurityConfig extends WebSecurityConfigurerAdapter {

    protected void configure(AuthenticationManagerBuilder auth) 
      throws Exception {

    protected void configure(HttpSecurity http) throws Exception {

    private LoginUrlAuthenticationEntryPoint oauth2AuthenticationEntryPoint() {
        return new LoginUrlAuthenticationEntryPoint("/login");

Note: We added a simple security configuration that redirect to “/login” which get the user information and load authentication from it – as explained in the following section.

8. RedditController

Now – let’s take a look at our controller RedditController.

We use method redditLogin() to get the user information from his Reddit account and load an authentication from it – as in the following example:

public class RedditController {

    private OAuth2RestTemplate redditRestTemplate;

    public String redditLogin() {
        JsonNode node = redditRestTemplate.getForObject(
          "", JsonNode.class);
        UsernamePasswordAuthenticationToken auth = 
          new UsernamePasswordAuthenticationToken(node.get("name").asText(), 
          Arrays.asList(new SimpleGrantedAuthority("ROLE_USER")));
        return "redirect:home.html";


An interesting detail of this deceptively simple method – the reddit template checks if the access token is available before executing any request; it acquires a token if one is not available.

Next – we present the information to our very simplistic front end.

9. home.jsp

Finally – let’s take a look at home.jsp – to display the information retrieved form user’s Reddit account:

<%@ taglib prefix="c" uri=""%>
<%@ taglib prefix="sec" uri=""%>
    <h1>Welcome, <small><sec:authentication property="principal.username" /></small></h1>

10. Conclusion

In this introductory article, we explored authenticating with the Reddit OAuth2 API and displaying some very basic information in a simple front end.

Now that we’re authenticated, we’re going to explore doing more interesting things with the Reddit API in the next article of this new series.

The full implementation of this tutorial can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.

Course – LSS (cat=Security/Spring Security)

I just announced the new Learn Spring Security course, including the full material focused on the new OAuth2 stack in Spring Security:

Course – LS (cat=HTTP Client-Side)

Get started with Spring and Spring Boot, through the Learn Spring course:

res – Security (video) (cat=Security/Spring Security)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.