Spring Social Twitter-Setup

Spring Social Twitter Setup

Der erste Teil der Serie befasst sich mit der anfänglichen Arbeit vonconsuming the StackExchange REST API, um die wichtigsten Fragen abzurufen. Diesesecond part konzentrieren sich auf die Einrichtung der Unterstützung, die für die Interaktion mit den Twitter-REST-APIs mithilfe des Spring Social Twitter-Projekts erforderlich ist. Das Endziel ist es, diese Fragen zu twittern, zwei pro Tag, und zwar auf mehreren Konten, die sich jeweils auf ein einzelnes Thema konzentrieren.

1. Verwenden von Spring Social Twitter

Die für die Verwendung des Spring Social Twitter-Projekts erforderlichen Abhängigkeiten sind unkompliziert. Zuerst definieren wirspring-social-twitter selbst:


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

Dann müssen wir einige seiner Abhängigkeiten mit aktuelleren Versionen überschreiben:


   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

Sowohlspring-core als auchspring-web werden als Abhängigkeiten vonspring-social-twitter definiert, jedoch mitolder versions -3.0.7.RELEASE bzw.3.1.0.RELEASE. Das Überschreiben dieser in unserem eigenen pom stellt sicher, dass das Projekt die von uns definierten aktuellen Versionen anstelle dieser älteren geerbten Versionen verwendet.

2. Erstellen einer Twitter-Anwendung

Dieser Anwendungsfall - Tweeten aufpersonal account und nicht im Namen anderer Benutzer in ihren Konten - ist einfach. Die Tatsache, dass es einfach ist, ermöglicht es uns, auf die meistenOAuth orchestrationzu verzichten, die erforderlich sind, wenn die Anwendung für mehrere Benutzer auf jedem ihrer Twitter-Konten twittern müsste.

Für unseren Anwendungsfall werden wircreate the TwitterTemplate directly verwenden, da wir alles, was wir dazu benötigen, manuell einrichten können.

Als erstes benötigen wirdev application - nach dem Anmelden kann mancreated here sein. Nach dem Erstellen der Anwendung haben wirConsumer Key undConsumer Secret - diese werden auf der Seite der Anwendung abgerufen - auf der RegisterkarteDetails unterOAuth settings.

Damit die Anwendung auf dem Konto twittern kann, müssenRead and Write Access festgelegt werden, um die Standardberechtigungen vonRead zu ersetzen.

3. Bereitstellung vonTwitterTemplate

Als nächstes müssen fürTwitterTemplateAccess Token undAccess Token Secret bereitgestellt werden. Diese können auch auf der Anwendungsseite unter der RegisterkarteDetails -Create my access token generiert werden. Sowohl das Zugriffstoken als auch das Geheimnis können dann unter der RegisterkarteOAuth tool abgerufen werden.

Neue können jederzeit auf der RegisterkarteDetailsüber die AktionRecreate my access tokenneu generiert werden.

Zu diesem Zeitpunkt haben wir alles, was wir brauchen - den Verbraucherschlüssel und das Verbrauchergeheimnis sowie das Zugriffstoken und das Zugriffstokengeheimnis - was bedeutet, dass wir unsereTwitterTemplatefür diese Anwendung erstellen können:

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

4. Eine Vorlage pro Konto

Nachdem wir nun gesehen haben, wie ein einzelnesTwitterTemplate füra single account erstellt wird, können wir noch einmal auf unseren Anwendungsfall zurückblicken - wir müssen auf mehreren Konten twittern - was bedeutet, dass wir mehrereTwitterTemplate-Instanzen benötigen .

Diese können auf Anfrage mit einem einfachen Mechanismus erstellt werden:

@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;
   }
}

Die vier Sicherheitsartefakte sind natürlichexternalized in a properties file; Zum Beispiel fürSpringAtSO account:

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

Dies ermöglicht eine gute Mischung aus Flexibilität und Sicherheit - die Sicherheitsanmeldeinformationen sind nicht Teil der Codebasis (welcheis opensource), sondern leben unabhängig vom Dateisystem und werden von Spring erfasst und sind über eine einfache Konfiguration in der Spring-Umgebung verfügbar ::

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

Properties in Spring sind ein Thema, das bereits besprochen wurde, daher werden wir hier nicht näher auf dieses Thema eingehen.

Schließlich überprüft eintest, ob ein Konto über die erforderlichen Sicherheitsinformationen verfügt, die in der Frühlingsumgebung verfügbar sind. Wenn die Eigenschaften nicht vorhanden sind, sollte die Logik vongetTwitterTemplateden Test mitNullPointerException nicht bestehen:

@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. Tweeten

Wenden wir uns mit den erstelltenTwitterTemplate der tatsächlichen Aktion vontweeting zu. Zu diesem Zweck verwenden wir einen sehr einfachen Dienst, akzeptierenTwitterTemplate und verwenden die zugrunde liegende API, um einen Tweet zu erstellen:

@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. Testen derTwitterTemplate

Und schließlich können wir einen Integrationstest schreiben, um den gesamten Prozess der Bereitstellung vonTwitterTemplate für ein Konto und des Twitterns für dieses Konto durchzuführen:

@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. Fazit

Zu diesem Zeitpunkt ist die von uns erstellte Twitter-API völlig unabhängig von der StackExchange-API und kann unabhängig von diesem speziellen Verwendungszweck zum Twittern verwendet werden.

Der nächste logische Schritt beim Twittern von Fragen aus Stack Exchange-Konten besteht darin, eine Komponente zu erstellen, die mitboth the Twitter and StackExchange APIs interagiert, die wir bisher vorgestellt haben. Dies wird der Schwerpunkt des nächsten Artikels in dieser Reihe sein.

TOC

Spring Social Twitter-Setup