Home » Java » Enterprise Java » Spring Social Twitter Setup

About Eugen Paraschiv

Eugen Paraschiv

Spring Social Twitter Setup

In the first part of this series, we looked at how we could consume the StackExchange REST API in order to retrieve its top questions. This second part will focus on setting up the support necessary to interact with the Twitter REST APIs using the Spring Social Twitter project. The end goal is to be able to tweet these questions, two per day, on several accounts, each focused on a single topic.

1. Using Spring Social Twitter

The required dependencies necessary to use the Spring Social Twitter project are straightforward. First, we define spring-social-twitter itself:


Then, we need to override some of it’s dependencies with more up-to-date versions:


Both spring-core and spring-web are defined as dependencies by spring-social-twitter but with older versions – 3.0.7.RELEASE and 3.1.0.RELEASE respectivelly. Overriding these in our own pom ensures that the project is using the up-to-date versions that we have defined instead of these older inherited versions.

2. Creating a Twitter Application

This usecase – tweeting on a personal account and not on behalf of other users on their accounts, is a simple one. The fact that it is simple allows us to dispense with most of the OAuth orchestration necessary if the application would need to tweet for multiple users, on each of their twitter accounts. So, for our usecase, we will create the TwitterTemplate directly, as we can manually set up everything we need to do so. First thing we need is a dev application – one can be created here, after logging in. After creating the application, we will have a Consumer Key and Consumer Secret – these are obtained from the page of the Application – on the Details tab, under OAuth settings. Also, in order to allow the Application to tweet on the account, Read and Write Access must be set to replace the default Read only privileges.

3. Provisioning a TwitterTemplate

Next, the TwitterTemplate requires an Access Token and an Access Token Secret to be provisioned. These can also be generated from the Application page – under the Details tab – Create my access token. Both the Access Token and the Secret can then be retrieved from under the OAuth tool tab. New ones can always be regenerated on the Details tab, via Recreate my access token action. At this point we have everything we need – the Consumer Key and Consumer Secret, as well as the Access Token and Access Token Secret – which means we can go ahead and create our TwitterTemplate for that application:

new TwitterTemplate(consumerKey, consumerSecret, accessToken, accessTokenSecret);

4. One Template per Account

Now that we have seen how to create a single TwitterTemplate for a single account, we can look back at our usecase again – we need to tweet on several accounts – which means we need several TwitterTemplate instances. These can be easily created on request, with a simple mechanism:

public class TwitterTemplateCreator {
   private Environment env;
   public Twitter getTwitterTemplate(String accountName) {
      String consumerKey = env.getProperty(accountName + ".consumerKey");
      String consumerSecret = env.getProperty(accountName + ".consumerSecret");
      String accessToken = env.getProperty(accountName + ".accessToken");
      String accessTokenSecret = env.getProperty(accountName + ".accessTokenSecret");
      TwitterTemplate twitterTemplate =
         new TwitterTemplate(consumerKey, consumerSecret, accessToken, accessTokenSecret);
      return twitterTemplate;

The four security artifacts are of course externalized in a properties file, by account; for example, for the SpringAtSO account:


This allows for a good mix of flexibility and safety – the security credentials are not part of the codebase (which is opensource) but live independently on the filesystem and are picked up by Spring and available in the Spring Enviroment via a simple configuration:

@PropertySource({ "file:///opt/stack/twitter.properties" })
public class TwitterConfig {

Properties in Spring are a subject that has been discussed before, so we won’t go into further details on this subject here. Finally, a test will verify that an account has the necessary security information readily available in the Spring Environment; if the properties are not present, the getTwitterTemplate logic should fail the test with a NullPointerException:

@ContextConfiguration(classes = { TwitterConfig.class })
public class TwitterTemplateCreatorIntegrationTest {
   private TwitterTemplateCreator twitterTemplateCreator;
   public void givenValidAccountSpringAtSO_whenRetrievingTwitterClient_thenNoException() {

5. Tweeting

With the TwitterTemplate created, let’s turn to the actual action of tweeting. For this, we’ll use a very simple service, accepting a TwitterTemplate and using its underlying API to create a tweet:

public class TwitterService {
   private Logger logger = LoggerFactory.getLogger(getClass());
   public void tweet(Twitter twitter, String tweetText) {
      try {
      } catch (RuntimeException ex) {
         logger.error("Unable to tweet" + tweetText, ex);

6. Testing the TwitterTemplate

And finally, we can write an integration test to perform the entire process of provisioning a TwitterTemplate for an account and tweeting on that account:

@ContextConfiguration(classes = { TwitterConfig.class })
public class TweetServiceLiveTest {
   private TwitterService twitterService;
   private TwitterTemplateCreator twitterCreator;
   // tests
   public void whenTweeting_thenNoExceptions() {
      Twitter twitterTemplate = twitterCreator.getTwitterTemplate("SpringAtSO");
      twitterService.tweet(twitterTemplate, "First Tweet");

7. Conclusion

At this point, the Twitter API we have created is completely separate from the StackExchange API and can be used independent of that particular usecase, to tweet anything. The next logical step in the process of tweeting questions from Stack Exchange accounts is to create a component – interacting with both the Twitter and StackExchange APIs that we have presented so far – this will be the focus of the next article in this series.

Reference: Spring Social Twitter Setup from our JCG partner Eugen Paraschiv at the baeldung blog.
(0 rating, 0 votes)
You need to be a registered member to rate this.
Start the discussion Views Tweet it!
Do you want to know how to develop your skillset to become a Java Rockstar?
Subscribe to our newsletter to start Rocking right now!
To get you started we give you our best selling eBooks for FREE!
1. JPA Mini Book
2. JVM Troubleshooting Guide
3. JUnit Tutorial for Unit Testing
4. Java Annotations Tutorial
5. Java Interview Questions
6. Spring Interview Questions
7. Android UI Design
and many more ....
I agree to the Terms and Privacy Policy
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments