Publiez régulièrement des images de tweets sur Twitter avec AWS Lambda + Java

Aperçu

Rédigez un exemple de code pour publier régulièrement des tweets avec des images dans AWS Lambda + Java 8
Dessinez la date et l'heure actuelles en japonais sur l'image d'arrière-plan préparée --Utilisez la bibliothèque Twitter4J pour publier sur Twitter --Utilisez Amazon CloudWatch Events pour une exécution régulière

Utilisez les polices Google Noto pour dessiner le japonais sur les images

Aucune police ne peut utiliser le japonais sur AWS Lambda + Java --Référence: Vérifiez s'il existe une police qui peut utiliser le japonais \ (Hiragana / Katakana / Kanji ) dans AWS Lambda \ + Java \ -Qiita
Utilisez la police Google Noto Fonts Noto Sans CJK JP Regular en l'incorporant.
Le fichier de police NotoSansCJKjp-Regular.otf a une taille d'environ 16,4 Mo --Référence: Noto CJK - Google Noto Fonts

Code source

Liste des fichiers

--pom.xml: Construire le fichier de configuration pour Maven --ImageTweet.java: classe Java qui effectue le traitement principal --NotoSansCJKjp-Regular.otf: fichier de police contenant des caractères japonais --fukidashi.png: Fichier image de fond de l'image à publier sur Twitter

├── 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>> {

  /**
   *Il s'agit du point d'entrée lors de l'exécution en tant qu'application Java autonome.
   *
   * @param args premier élément[0]Un tableau avec une chaîne à tweeter
   */
  public static void main(String[] args) {
    Map<String, Object> output = new ImageTweet().invoke(new HashMap<String, Object>());
    System.out.println(output);
  }

  /**
   *Point d'entrée lors de l'exécution de la fonction AWS Lambda(Méthode du gestionnaire)est.
   *
   * @param input Données d'entrée
   * @param context Objet de contexte AWS Lambda
   * @renvoyer les données de sortie
   */
  @Override
  public Map<String, Object> handleRequest(Map<String, Object> input, Context context) {
    return invoke(input);
  }

  /**
   *Tweet
   *
   * @Param input Texte à tweeter
   */
  public Map<String, Object> invoke(Map<String, Object> input) {
    Map output = new HashMap<String, Object>();
    try {
      //Assemblez le texte pour tweeter
      String text = LocalDateTime.now(ZoneId.of("JST", ZoneId.SHORT_IDS))
        .format(DateTimeFormatter.ofPattern("année M mois d jour H heure m minute s seconde"));

      //Chemin du fichier image
      String imagePath = "image/fukidashi.png ";
      //Nom du fichier image
      String imageFileName = new File(imagePath).getName();
      //Nom du format d'image
      String imageFormatName = "png";
      //Charger le fichier image
      BufferedImage image = getImageFromResource(imagePath);

      //Lire le fichier de police
      String fontPath = "font/NotoSansCJKjp-Regular.otf";
      Font font = getFont(fontPath);

      //Traiter l'image(Dessiner du texte)
      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();
      //Obtenir des données d'image
      InputStream imageBody = createInputStream(image, imageFormatName);

      //Obtenir des variables d'environnement
      Map<String, String> env = System.getenv();

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

      //Créer des données de sortie
      output.put("result", status);
    } catch (Exception e) {
      output.put("error", e);
    }

    return output;
  }

  /**
   *Chargez le fichier de police.
   *
   * @param path Chemin du fichier de police
   * @objet de police de retour
   * @jette FontFormatException s'il n'y a pas de données de police requises
   * @lève IOException si une erreur se produit
   */
  private Font getFont(String path) throws FontFormatException, IOException {
    ClassLoader cl = getClass().getClassLoader();
    try (InputStream input = cl.getResourceAsStream(path)) {
      //La taille par défaut des objets Java Font est 12
      return Font.createFont(Font.TRUETYPE_FONT, input).deriveFont(12.0f);
    }
  }

  /**
   *Chargez le fichier image.
   *
   * @param path Chemin du fichier image
   * @objet image de retour
   * @lève IOException si une erreur se produit
   */
  private BufferedImage getImageFromResource(String path) throws IOException {
    ClassLoader cl = getClass().getClassLoader();
    URL url = cl.getResource(path);
    return ImageIO.read(url);
  }

  /**
   *Obtient la chaîne d'octets des données d'image.
   *
   * @objet image image param
   * @param formatName Nom du format d'image
   * @return Chaîne d'octets de données d'image
   * @lève IOException si une erreur se produit
   */
  private InputStream createInputStream(BufferedImage image, String formatName) throws IOException {
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    ImageIO.write(image, formatName, output);
    return new ByteArrayInputStream(output.toByteArray());
  }

  /**
   *Obtient l'objet TwitterFactory.
   *
   * @variable d'environnement param env
   * @renvoyer l'objet TwitterFactory
   */
  private TwitterFactory getTwitterFactory(Map<String, String> env) {
    ConfigurationBuilder cb = new ConfigurationBuilder();
    //Obtenir les informations d'identification Twitter à partir des variables d'environnement
    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());
  }

  /**
   *Publiez un tweet avec une image.
   *
   * @param text Texte à tweeter
   * @param imageFileName Nom du fichier de l'image à inclure dans le tweet
   * @param imageBody Données d'image à inclure dans les tweets
   * @renvoyer l'objet Status à la suite d'un tweet
   * @lance TwitterException si une erreur se produit
   */
  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

Fichier de configuration pour la construction avec Maven.

--Match Java version 1.8 pris en charge par AWS Lambda --Introduisez la bibliothèque aws-lambda-java-core pour AWS Lambda --Introduisez maven-shadow-plugin pour générer des fichiers JAR, y compris des bibliothèques

<?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>

image de fond

Dans ce programme, une image fukidashi est préparée comme arrière-plan de l'image à tweeter.

Génération de fichiers JAR

Construisez avec Maven pour générer un fichier JAR.

$ mvn package

Un fichier JAR appelé image-tweet-1.0.jar est généré dans le répertoire cible.

Création de fonctions AWS Lambda

Créez une fonction Lambda à partir de la console de gestion Lambda (https://console.aws.amazon.com/lambda/).

Entrez "informations de base". Nom de la fonction: n'importe quel nom Exécution: Java 8 Rôle d'exécution: créer un nouveau rôle avec des autorisations Lambda de base

Entrez le "code de fonction". Type d'entrée de code: télécharger un fichier .zip ou jar Exécution: Java 8 Gestionnaire: com.example.ImageTweet :: handleRequest

Cliquez sur "Télécharger" pour télécharger le fichier JAR généré image-tweet-1.0.jar.

Définissez les variables d'environnement. Dans ce programme, les informations d'identification pour appeler l'API Twitter sont obtenues à partir de la variable d'environnement.

Cliquez sur Test en haut à droite de la page pour créer un nouvel événement de test. Modèle d'événement: Hello World Nom de l'événement: n'importe quel nom Modifiez (ou laissez la valeur par défaut) le JSON qui est les données d'entrée.

Vous pouvez lancer le test en cliquant sur "Test" en haut à droite de la page. Le résultat s'affiche.

Ceci complète la fonction de publication de tweets avec des images sur Twitter.

Utiliser Amazon CloudWatch Events

Cliquez sur Ajouter un déclencheur sur le côté gauche du concepteur de fonctions Lambda.

Sélectionnez CloudWatch Events.

Définissez le contenu du déclencheur pour qu'il s'exécute toutes les minutes. Règle: créer une nouvelle règle Nom de la règle: n'importe quel nom Description de la règle: description arbitraire Type de règle: expression planifiée Expression planifiée: cron (* * * *? *)

Ceci termine les réglages qui sont exécutés périodiquement.

Résultat d'exécution

Vous pourrez publier régulièrement des tweets avec des images sur Twitter.