Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erweiterte Amazon SNS SNS-Clientbibliothek für Java
<a name="extended-client-library-java"></a>

## Voraussetzungen
<a name="prereqs-sns-extended-client-library"></a>

Im Folgenden sind die Voraussetzungen für die Verwendung der [Amazon SNS Extended Client Library für Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib) aufgeführt:
+ Ein AWS SDK. Das Beispiel auf dieser Seite verwendet das AWS Java-SDK. Informationen zur Installation und Einrichtung des SDK finden Sie unter [Setup the AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-install.html) im *AWS SDK für Java Developer Guide*.
+ Und AWS-Konto mit den richtigen Anmeldeinformationen. Um ein Konto zu erstellen AWS-Konto, navigieren Sie zur [AWS Startseite](https://aws.amazon.com/) und wählen Sie dann ** AWS Konto erstellen**. Folgen Sie den Anweisungen.

  Informationen zu Anmeldeinformationen finden Sie im *AWS SDK für Java Entwicklerhandbuch* unter „[AWS Anmeldeinformationen und Region für die Entwicklung einrichten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html)“.
+ Java 8 oder höher. 
+ Die erweiterte Amazon SNS Extended Client Library für Java (ist auch verfügbar von [Maven](https://maven.apache.org/)) enthalten. 

## Konfigurieren der Nachrichtenspeicherung
<a name="large-message-configure-storage"></a>

Die Amazon SNS Extended Client-Bibliothek verwendet die Payload Offloading Java Common Library AWS zum Speichern und Abrufen von Nachrichten. Sie können die folgenden Amazon S3 [Optionen für die Nachrichtenspeicherung](https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/SNSExtendedClientConfiguration.java):
+ **Schwellenwert für benutzerdefinierte Nachrichtengrößen** — Nachrichten mit Nutzlasten und Attributen, die diese Größe überschreiten, werden automatisch in Amazon S3 gespeichert.
+ **`alwaysThroughS3`flag** — Setzen Sie diesen Wert auf, um `true` zu erzwingen, dass alle Nachrichten-Payloads in Amazon S3 gespeichert werden. Beispiel:

  ```
  SNSExtendedClientConfiguration snsExtendedClientConfiguration = new
  SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME).withAlwaysThroughS3(true);
  ```
+ **Benutzerdefinierter KMS-Schlüssel** — Der Schlüssel, der für die serverseitige Verschlüsselung in Ihrem Amazon S3 S3-Bucket verwendet werden soll.
+ **Bucket-Name** — Der Name des Amazon S3 S3-Buckets zum Speichern von Nachrichtennutzlasten. 

## Beispiel: Veröffentlichen von Nachrichten in Amazon SNS mit Payload, die in Amazon S3 gespeichert ist
<a name="example-s3-large-payloads"></a>

Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen Sie ein Beispielthema und eine Queue.
+ Die abonnierte Queue kann nun Nachrichten vom Thema empfangen.
+ Veröffentlichen Sie eine Testnachricht.

Die Nachrichtennutzlast wird in Amazon S3 gespeichert und der Verweis darauf wird veröffentlicht. Der Amazon SQS Extended Client wird zum Empfangen der Nachricht verwendet.

**SDK für Java 1.x**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/java/example_code/sns#code-examples) einrichten und ausführen. 
Um eine große Nachricht zu veröffentlichen, verwenden Sie die Amazon SNS Extended Client Library für Java. Die Nachricht, die Sie senden, verweist auf ein Amazon S3-Objekt, das den tatsächlichen Nachrichteninhalt enthält.  

```
import com.amazon.sqs.javamessaging.AmazonSQSExtendedClient;
import com.amazon.sqs.javamessaging.ExtendedClientConfiguration;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.sns.AmazonSNS;
import com.amazonaws.services.sns.AmazonSNSClientBuilder;
import com.amazonaws.services.sns.model.CreateTopicRequest;
import com.amazonaws.services.sns.model.PublishRequest;
import com.amazonaws.services.sns.model.SetSubscriptionAttributesRequest;
import com.amazonaws.services.sns.util.Topics;
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
import com.amazonaws.services.sqs.model.ReceiveMessageResult;
import software.amazon.sns.AmazonSNSExtendedClient;
import software.amazon.sns.SNSExtendedClientConfiguration;

public class Example {

        public static void main(String[] args) {
                final String BUCKET_NAME = "extended-client-bucket";
                final String TOPIC_NAME = "extended-client-topic";
                final String QUEUE_NAME = "extended-client-queue";
                final Regions region = Regions.DEFAULT_REGION;

                // Message threshold controls the maximum message size that will be allowed to
                // be published
                // through SNS using the extended client. Payload of messages exceeding this
                // value will be stored in
                // S3. The default value of this parameter is 256 KB which is the maximum
                // message size in SNS (and SQS).
                final int EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD = 32;

                // Initialize SNS, SQS and S3 clients
                final AmazonSNS snsClient = AmazonSNSClientBuilder.standard().withRegion(region).build();
                final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard().withRegion(region).build();
                final AmazonS3 s3Client = AmazonS3ClientBuilder.standard().withRegion(region).build();

                // Create bucket, topic, queue and subscription
                s3Client.createBucket(BUCKET_NAME);
                final String topicArn = snsClient.createTopic(
                                new CreateTopicRequest().withName(TOPIC_NAME)).getTopicArn();
                final String queueUrl = sqsClient.createQueue(
                                new CreateQueueRequest().withQueueName(QUEUE_NAME)).getQueueUrl();
                final String subscriptionArn = Topics.subscribeQueue(
                                snsClient, sqsClient, topicArn, queueUrl);

                // To read message content stored in S3 transparently through SQS extended
                // client,
                // set the RawMessageDelivery subscription attribute to TRUE
                final SetSubscriptionAttributesRequest subscriptionAttributesRequest = new SetSubscriptionAttributesRequest();
                subscriptionAttributesRequest.setSubscriptionArn(subscriptionArn);
                subscriptionAttributesRequest.setAttributeName("RawMessageDelivery");
                subscriptionAttributesRequest.setAttributeValue("TRUE");
                snsClient.setSubscriptionAttributes(subscriptionAttributesRequest);

                // Initialize SNS extended client
                // PayloadSizeThreshold triggers message content storage in S3 when the
                // threshold is exceeded
                // To store all messages content in S3, use AlwaysThroughS3 flag
                final SNSExtendedClientConfiguration snsExtendedClientConfiguration = new SNSExtendedClientConfiguration()
                                .withPayloadSupportEnabled(s3Client, BUCKET_NAME)
                                .withPayloadSizeThreshold(EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD);
                final AmazonSNSExtendedClient snsExtendedClient = new AmazonSNSExtendedClient(snsClient,
                                snsExtendedClientConfiguration);

                // Publish message via SNS with storage in S3
                final String message = "This message is stored in S3 as it exceeds the threshold of 32 bytes set above.";
                snsExtendedClient.publish(topicArn, message);

                // Initialize SQS extended client
                final ExtendedClientConfiguration sqsExtendedClientConfiguration = new ExtendedClientConfiguration()
                                .withPayloadSupportEnabled(s3Client, BUCKET_NAME);
                final AmazonSQSExtendedClient sqsExtendedClient = new AmazonSQSExtendedClient(sqsClient,
                                sqsExtendedClientConfiguration);

                // Read the message from the queue
                final ReceiveMessageResult result = sqsExtendedClient.receiveMessage(queueUrl);
                System.out.println("Received message is " + result.getMessages().get(0).getBody());
        }
}
```

## Andere Endpunktprotokolle
<a name="large-payloads-other-protocols"></a>

Sowohl die Amazon SNS - als auch die Amazon SQS Bibliotheken verwenden die [Payload-Offloading Java Common Library für AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws), um Nachrichten-Payloads mit Amazon S3 zu speichern und abzurufen. Jeder Java-aktivierte Endpunkt (z. B. ein HTTPS-Endpunkt, der in Java implementiert ist) kann dieselbe Bibliothek verwenden, um den Nachrichteninhalt aufzuheben.

Endpunkte, für die die Payload Offloading Java Common Library nicht verwendet werden kann, AWS können trotzdem Nachrichten mit in Amazon S3 gespeicherten Payloads veröffentlichen. Im Folgenden wird ein Beispiel für eine Amazon S3-Referenz gezeigt, die im obigen Codebeispiel veröffentlicht wird:

```
[
  "software.amazon.payloadoffloading.PayloadS3Pointer",
  {
    "s3BucketName": "extended-client-bucket",
    "s3Key": "xxxx-xxxxx-xxxxx-xxxxxx"
  }
]
```