Printemps Social Twitter Setup

La première partie de la série porte sur le travail initial deconsuming the StackExchange REST API afin de récupérer ses principales questions. Cesecond part se concentrera sur la mise en place du support nécessaire pour interagir avec les API REST Twitter à l'aide du projet Spring Social Twitter. L'objectif final est de pouvoir tweeter ces questions, deux par jour, sur plusieurs comptes, chacun axé sur un seul sujet.

1. Utiliser Spring Social Twitter

Les dépendances requises pour utiliser le projet Spring Social Twitter sont simples. Tout d'abord, nous définissonsspring-social-twitter lui-même:


   org.springframework.social
   spring-social-twitter
   1.1.0.RELEASE

Ensuite, nous devons remplacer certaines de ses dépendances par des versions plus à jour:


   org.springframework
   spring-core
   4.1.0.RELEASE


   org.springframework
   spring-web
   4.1.0.RELEASE


   org.codehaus.jackson
   jackson-mapper-asl
   1.9.13

Les deuxspring-core etspring-web sont définis comme dépendances parspring-social-twitter mais avecolder versions -3.0.7.RELEASE et3.1.0.RELEASE respectivement. Remplacer ces éléments dans notre propre pom garantit que le projet utilise les versions mises à jour que nous avons définies à la place de ces versions héritées plus anciennes.

2. Création d'une application Twitter

Ce cas d'utilisation - tweeter sur unpersonal account et non au nom d'autres utilisateurs sur leurs comptes, est simple. Le fait qu'il soit simple permet de se passer de la plupart desOAuth orchestration nécessaires si l'application avait besoin de tweeter pour plusieurs utilisateurs, sur chacun de leurs comptes Twitter.

Donc, pour notre cas d'utilisation, nous allonscreate the TwitterTemplate directly, car nous pouvons configurer manuellement tout ce dont nous avons besoin pour le faire.

La première chose dont nous avons besoin est undev application - on peut êtrecreated here, après la connexion. Après avoir créé l'application, nous aurons unConsumer Key et unConsumer Secret - ceux-ci sont obtenus à partir de la page de l'application - sur l'ongletDetails, sousOAuth settings.

De plus, pour permettre à l'application de tweeter sur le compte,Read and Write Access doit être défini pour remplacer les privilèges par défaut deRead uniquement.

3. Provisionnement d'unTwitterTemplate

Ensuite, leTwitterTemplate nécessite le provisionnement d'unAccess Token et d'unAccess Token Secret. Ceux-ci peuvent également être générés à partir de la page Application - sous l'ongletDetails -Create my access token. Le jeton d'accès et le secret peuvent ensuite être récupérés sous l'ongletOAuth tool.

Les nouveaux peuvent toujours être régénérés sur l'ongletDetails, via l'actionRecreate my access token.

À ce stade, nous avons tout ce dont nous avons besoin - la clé du consommateur et le secret du consommateur, ainsi que le jeton d'accès et le secret du jeton d'accès - ce qui signifie que nous pouvons continuer et créer nosTwitterTemplate pour cette application:

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

4. Un modèle par compte

Maintenant que nous avons vu comment créer un seulTwitterTemplate poura single account, nous pouvons revenir sur notre cas d'utilisation - nous devons tweeter sur plusieurs comptes - ce qui signifie que nous avons besoin de plusieurs instances deTwitterTemplate .

Ceux-ci peuvent être facilement créés sur demande, avec un mécanisme simple:

@Component
public class TwitterTemplateCreator {
   @Autowired
   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");
      Preconditions.checkNotNull(consumerKey);
      Preconditions.checkNotNull(consumerSecret);
      Preconditions.checkNotNull(accessToken);
      Preconditions.checkNotNull(accessTokenSecret);

      TwitterTemplate twitterTemplate =
         new TwitterTemplate(consumerKey, consumerSecret, accessToken, accessTokenSecret);
      return twitterTemplate;
   }
}

Les quatre artefacts de sécurité sont bien entenduexternalized in a properties file, par compte; par exemple, pour lesSpringAtSO account:

SpringAtSO.consumerKey=nqYezCjxkHabaX6cdte12g
SpringAtSO.consumerSecret=7REmgFW4SnVWpD4EV5Zy9wB2ZEMM9WKxTaZwrgX3i4A
SpringAtSO.accessToken=1197830142-t44T7vwgmOnue8EoAxI1cDyDAEBAvple80s1SQ3
SpringAtSO.accessTokenSecret=ZIpghEJgFGNGQZzDFBT5TgsyeqDKY2zQmYsounPafE

Cela permet un bon mélange de flexibilité et de sécurité - les informations d'identification de sécurité ne font pas partie de la base de code (quiis opensource) mais vivent indépendamment sur le système de fichiers et sont récupérées par Spring et disponibles dans Spring Enviroment via une configuration simple :

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

Properties in Spring est un sujet qui a déjà été abordé, nous n'entrerons donc pas dans plus de détails sur ce sujet ici.

Enfin, untest vérifiera qu'un compte dispose des informations de sécurité nécessaires facilement disponibles dans l'environnement Spring; si les propriétés ne sont pas présentes, la logiquegetTwitterTemplate doit échouer le test avec unNullPointerException:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TwitterConfig.class })
public class TwitterTemplateCreatorIntegrationTest {
   @Autowired
   private TwitterTemplateCreator twitterTemplateCreator;
   //
   @Test
   public void givenValidAccountSpringAtSO_whenRetrievingTwitterClient_thenNoException() {
      twitterTemplateCreator.getTwitterTemplate(SimpleTwitterAccount.SpringAtSO.name());
   }
}

5. Tweet

Une fois lesTwitterTemplate créés, passons à l'action réelle detweeting. Pour cela, nous utiliserons un service très simple, acceptant unTwitterTemplate et utilisant son API sous-jacente pour créer un tweet:

@Service
public class TwitterService {
   private Logger logger = LoggerFactory.getLogger(getClass());

   public void tweet(Twitter twitter, String tweetText) {
      try {
         twitter.timelineOperations().updateStatus(tweetText);
      } catch (RuntimeException ex) {
         logger.error("Unable to tweet" + tweetText, ex);
      }
   }
}

6. Test desTwitterTemplate

Et enfin, nous pouvons écrire un test d'intégration pour effectuer l'ensemble du processus de provisionnement d'unTwitterTemplate pour un compte et de tweeter sur ce compte:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TwitterConfig.class })
public class TweetServiceLiveTest {
   @Autowired
   private TwitterService twitterService;
   @Autowired
   private TwitterTemplateCreator twitterCreator;

   @Test
   public void whenTweeting_thenNoExceptions() {
      Twitter twitterTemplate = twitterCreator.getTwitterTemplate("SpringAtSO");
      twitterService.tweet(twitterTemplate, "First Tweet");
   }
}

7. Conclusion

À ce stade, l'API Twitter que nous avons créée est complètement distincte de l'API StackExchange et peut être utilisée indépendamment de cette cas d'utilisation particulière, pour tout tweet.

La prochaine étape logique du processus de tweeter des questions à partir des comptes Stack Exchange consiste à créer un composant - interagissant avecboth the Twitter and StackExchange APIs que nous avons présenté jusqu'à présent - ce sera l'objet du prochain article de cette série.

TOC

Printemps Social Twitter Setup