Veröffentlichen Sie regelmäßig Bild-Tweets auf Twitter mit AWS Lambda + Java

Überblick

Schreiben Sie einen Beispielcode, um regelmäßig Tweets mit Bildern in AWS Lambda + Java 8 zu veröffentlichen
Zeichnen Sie das aktuelle Datum und die aktuelle Uhrzeit auf Japanisch auf das vorbereitete Hintergrundbild --Verwenden Sie die Twitter4J-Bibliothek zum Posten auf Twitter --Verwenden Sie Amazon CloudWatch Events für die regelmäßige Ausführung

Verwenden Sie Google Noto-Schriftarten, um Japanisch auf Bildern zu zeichnen

Es gibt keine Schriftart, die Japanisch unter AWS Lambda + Java verwenden kann
Referenz: Überprüfen Sie, ob es in AWS Lambda \ + Java \ -Qiita eine Schriftart gibt, die Japanisch \ (Hiragana, Katakana, Kanji ) verwenden kann --Verwenden Sie die Google Noto-Schriftarten Noto Sans CJK JP Regular, indem Sie sie einbinden.
Die Schriftartdatei NotoSansCJKjp-Regular.otf ist ungefähr 16,4 MB groß
Referenz: Noto CJK - Google Noto-Schriftarten

Quellcode

Dateiliste

--pom.xml: Konfigurationsdatei für Maven erstellen --ImageTweet.java: Java-Klasse, die die Hauptverarbeitung ausführt --NotoSansCJKjp-Regular.otf: Schriftdatei mit japanischen Zeichen --fukidashi.png: Hintergrundbilddatei des Bildes, das auf Twitter veröffentlicht werden soll

├── pom.xml
└── src
    └── main
        ├── java
        │   └── com
        │       └── example
        │           └── ImageTweet.java
        └── resources
            ├── font
            │   └── NotoSansCJKjp-Regular.otf
            └── image
                └── fukidashi.png

ImageTweet.java

package com.example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import twitter4j.Status;
import twitter4j.StatusUpdate;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.conf.ConfigurationBuilder;

import javax.imageio.ImageIO;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontFormatException;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

public class ImageTweet implements RequestHandler<Map<String, Object>, Map<String, Object>> {

  /**
   *Dies ist der Einstiegspunkt, wenn Sie als eigenständige Java-Anwendung ausgeführt werden.
   *
   * @param args erstes Element[0]Ein Array mit einer Zeichenfolge, zu der getwittert werden soll
   */
  public static void main(String[] args) {
    Map<String, Object> output = new ImageTweet().invoke(new HashMap<String, Object>());
    System.out.println(output);
  }

  /**
   *Einstiegspunkt bei der Ausführung der AWS Lambda-Funktion(Handler-Methode)ist.
   *
   * @param input Eingabedaten
   * @param context AWS Lambda Context-Objekt
   * @Ausgabedaten zurückgeben
   */
  @Override
  public Map<String, Object> handleRequest(Map<String, Object> input, Context context) {
    return invoke(input);
  }

  /**
   *Tweet
   *
   * @param input Text zum Twittern
   */
  public Map<String, Object> invoke(Map<String, Object> input) {
    Map output = new HashMap<String, Object>();
    try {
      //Stellen Sie den Text zum Twittern zusammen
      String text = LocalDateTime.now(ZoneId.of("JST", ZoneId.SHORT_IDS))
        .format(DateTimeFormatter.ofPattern("Jahr M Monat d Tag H Stunde m Minute s Sekunde"));

      //Bilddateipfad
      String imagePath = "image/fukidashi.png ";
      //Name der Bilddatei
      String imageFileName = new File(imagePath).getName();
      //Name des Bildformats
      String imageFormatName = "png";
      //Bilddatei laden
      BufferedImage image = getImageFromResource(imagePath);

      //Schriftdatei lesen
      String fontPath = "font/NotoSansCJKjp-Regular.otf";
      Font font = getFont(fontPath);

      //Verarbeiten Sie das Bild(Zeichnen Sie Text)
      Graphics2D g = image.createGraphics();
      g.setColor(Color.BLUE);
      g.setFont(font.deriveFont(30.0f));
      g.drawString(text, image.getWidth() / 4, image.getHeight() / 2);
      g.dispose();
      //Bilddaten abrufen
      InputStream imageBody = createInputStream(image, imageFormatName);

      //Umgebungsvariablen abrufen
      Map<String, String> env = System.getenv();

      //Tweet
      TwitterFactory tf = getTwitterFactory(env);
      Status status = tweet(tf, text, imageFileName, imageBody);

      //Erstellen Sie Ausgabedaten
      output.put("result", status);
    } catch (Exception e) {
      output.put("error", e);
    }

    return output;
  }

  /**
   *Laden Sie die Schriftartdatei.
   *
   * @param path Schriftpfad
   * @Font-Objekt zurückgeben
   * @löst FontFormatException aus Wenn die erforderlichen Schriftdaten nicht vorhanden sind
   * @löst eine IOException aus, wenn ein Fehler auftritt
   */
  private Font getFont(String path) throws FontFormatException, IOException {
    ClassLoader cl = getClass().getClassLoader();
    try (InputStream input = cl.getResourceAsStream(path)) {
      //Die Standardgröße von Java Font-Objekten beträgt 12
      return Font.createFont(Font.TRUETYPE_FONT, input).deriveFont(12.0f);
    }
  }

  /**
   *Laden Sie die Bilddatei.
   *
   * @param path Bilddateipfad
   * @Bildobjekt zurückgeben
   * @löst eine IOException aus, wenn ein Fehler auftritt
   */
  private BufferedImage getImageFromResource(String path) throws IOException {
    ClassLoader cl = getClass().getClassLoader();
    URL url = cl.getResource(path);
    return ImageIO.read(url);
  }

  /**
   *Ruft die Byte-Zeichenfolge der Bilddaten ab.
   *
   * @param image image object
   * @param formatName Name des Bildformats
   * @Bilddaten-Byte-Zeichenfolge zurückgeben
   * @löst eine IOException aus, wenn ein Fehler auftritt
   */
  private InputStream createInputStream(BufferedImage image, String formatName) throws IOException {
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    ImageIO.write(image, formatName, output);
    return new ByteArrayInputStream(output.toByteArray());
  }

  /**
   *Ruft das TwitterFactory-Objekt ab.
   *
   * @param env Umgebungsvariable
   * @TwitterFactory-Objekt zurückgeben
   */
  private TwitterFactory getTwitterFactory(Map<String, String> env) {
    ConfigurationBuilder cb = new ConfigurationBuilder();
    //Holen Sie sich Twitter-Anmeldeinformationen von Umgebungsvariablen
    cb.setDebugEnabled(true)
      .setOAuthConsumerKey(env.get("TWITTER_CONSUMER_KEY"))
      .setOAuthConsumerSecret(env.get("TWITTER_CONSUMER_SECRET"))
      .setOAuthAccessToken(env.get("TWITTER_ACCESS_TOKEN"))
      .setOAuthAccessTokenSecret(env.get("TWITTER_ACCESS_TOKEN_SECRET"));
    return new TwitterFactory(cb.build());
  }

  /**
   *Poste einen Tweet mit einem Bild.
   *
   * @param text Text zum Twittern
   * @param imageFileName Dateiname des Bildes, das in den Tweet aufgenommen werden soll
   * @param imageBody Bilddaten, die in Tweets enthalten sein sollen
   * @Rückgabe des Statusobjekts durch Tweeten
   * @löst eine TwitterException aus Wenn ein Fehler auftritt
   */
  private Status tweet(TwitterFactory tf, String text, String imageFileName, InputStream imageBody) throws TwitterException {
    Twitter twitter = tf.getInstance();
    StatusUpdate status = new StatusUpdate(text);
    status.setMedia(imageFileName, imageBody);
    return twitter.updateStatus(status);
  }
}

pom.xml

Konfigurationsdatei zum Erstellen mit Maven.

--Match Java Version 1.8 wird von AWS Lambda unterstützt

Einführung der Bibliothek aws-lambda-java-core für AWS Lambda
Einführung des Maven-Shade-Plugins zum Generieren von JAR-Dateien einschließlich Bibliotheken

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>image-tweet</artifactId>
  <packaging>jar</packaging>
  <version>1.0</version>
  <name>image-tweet</name>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-core -->
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-lambda-java-core</artifactId>
      <version>1.2.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.twitter4j/twitter4j-core -->
    <dependency>
      <groupId>org.twitter4j</groupId>
      <artifactId>twitter4j-core</artifactId>
      <version>4.0.7</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!-- https://maven.apache.org/plugins/maven-shade-plugin/ -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.2.1</version>
        <configuration>
          <createDependencyReducedPom>false</createDependencyReducedPom>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

</project>

Hintergrundbild

In diesem Programm wird ein Fukidashi-Bild als Hintergrund für das zu twitternde Bild vorbereitet.

Generierung von JAR-Dateien

Erstellen Sie mit Maven, um eine JAR-Datei zu generieren.

$ mvn package

Im Zielverzeichnis wird eine JAR-Datei mit dem Namen image-tweet-1.0.jar generiert.

Erstellen von AWS Lambda-Funktionen

Erstellen Sie eine Lambda-Funktion über die Lambda-Verwaltungskonsole (https://console.aws.amazon.com/lambda/).

Geben Sie "Basisinformationen" ein. Funktionsname: Beliebiger Name Laufzeit: Java 8 Ausführungsrolle: Erstellen Sie eine neue Rolle mit grundlegenden Lambda-Berechtigungen

Geben Sie den "Funktionscode" ein. Codeeintragstyp: ZIP- oder JAR-Datei hochladen Laufzeit: Java 8 Handler: com.example.ImageTweet :: handleRequest

Klicken Sie auf "Hochladen", um die generierte JAR-Datei image-tweet-1.0.jar hochzuladen.

Umgebungsvariablen festlegen. In diesem Programm werden die Anmeldeinformationen zum Aufrufen der Twitter-API von der Umgebungsvariablen abgerufen.

Klicken Sie oben rechts auf der Seite auf Test, um ein neues Testereignis zu erstellen. Ereignisvorlage: Hallo Welt Ereignisname: Beliebiger Name Ändern (oder belassen Sie die Standardeinstellung) den JSON, der die Eingabedaten darstellt.

Sie können den Test ausführen, indem Sie oben rechts auf der Seite auf "Test" klicken. Das Ergebnis wird angezeigt.

Damit ist die Funktion zum Posten von Tweets mit Bildern auf Twitter abgeschlossen.

Verwenden Sie Amazon CloudWatch-Ereignisse

Klicken Sie links im Lambda-Funktions-Designer auf Trigger hinzufügen.

Wählen Sie CloudWatch-Ereignisse.

Stellen Sie den Inhalt des Triggers so ein, dass er jede Minute ausgeführt wird. Regel: Erstellen Sie eine neue Regel Regelname: Beliebiger Name Regelbeschreibung: Beliebige Beschreibung Regeltyp: Geplanter Ausdruck Geplanter Ausdruck: cron (* * * *? *)

Damit sind die Einstellungen abgeschlossen, die regelmäßig ausgeführt werden.

Ausführungsergebnis

Sie können regelmäßig Tweets mit Bildern auf Twitter veröffentlichen.