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.

# Herstellen von Verbindungen mit einer Neptune-DB-Instance über Java
<a name="access-graph-sparql-java"></a>

Dieser Abschnitt führt Sie durch die Ausführung eines vollständigen Java-Beispiels, in dem eine Verbindung mit einer Amazon-Neptune-DB-Instance hergestellt wird und eine SPARQL-Abfrage ausgeführt wird.

Befolgen Sie diese Anweisungen für eine Amazon-EC2-Instance befolgen, die sich in derselben Virtual Private Cloud (VPC) wie Ihre Neptune-DB-Instance befindet.

**Herstellen einer Verbindung mit Neptune über Java**

1. Installieren Sie Apache Maven auf Ihrer EC2-Instance. Wenn Sie Amazon Linux 2023 (bevorzugt) verwenden, verwenden Sie:

   ```
   sudo dnf update -y
   sudo dnf install maven -y
   ```

   Wenn Sie Amazon Linux 2 verwenden, laden Sie die neueste Binärdatei von [https://maven.apache.org/download.cgi herunter:](https://maven.apache.org/download.cgi:)

   ```
   sudo yum remove maven -y
   wget https://dlcdn.apache.org/maven/maven-3/ <version>/binaries/apache-maven-<version>-bin.tar.gz
   sudo tar -xzf apache-maven-<version>-bin.tar.gz -C /opt/
   sudo ln -sf /opt/apache-maven-<version> /opt/maven
   echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc
   echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc
   source ~/.bashrc
   ```

1. Dieses Beispiel wurde lediglich mit Java 8 getestet. Geben Sie Folgendes ein, um Java 8 auf Ihrer EC2-Instance zu installieren:

   ```
   sudo yum install java-1.8.0-devel
   ```

1. Geben Sie Folgendes ein, um Java 8 als Standard-Laufzeit Ihrer EC2-Instance festzulegen:

   ```
   sudo /usr/sbin/alternatives --config java
   ```

   Wenn Sie dazu aufgefordert werden, geben Sie die Nummer für Java 8 ein.

1. Geben Sie Folgendes ein, um Java 8 als Standard-Compiler Ihrer EC2-Instance festzulegen: 

   ```
   sudo /usr/sbin/alternatives --config javac
   ```

   Wenn Sie dazu aufgefordert werden, geben Sie die Nummer für Java 8 ein.

1. Erstellen Sie in einem neuen Verzeichnis eine `pom.xml`-Datei und öffnen Sie diese in einem Text-Editor.

1. Kopieren Sie Folgendes in die Datei `pom.xml` und speichern Sie diese. (Sie können die Versionsnummern in der Regel in die neueste stabile Version ändern):

   ```
   <project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.amazonaws</groupId>
     <artifactId>RDFExample</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>RDFExample</name>
     <url>https://maven.apache.org</url>
     <dependencies>
       <dependency>
         <groupId>org.eclipse.rdf4j</groupId>
         <artifactId>rdf4j-runtime</artifactId>
         <version>3.6</version>
       </dependency>
     </dependencies>
     <build>
       <plugins>
         <plugin>
             <groupId>org.codehaus.mojo</groupId>
             <artifactId>exec-maven-plugin</artifactId>
             <version>1.2.1</version>
             <configuration>
               <mainClass>com.amazonaws.App</mainClass>
             </configuration>
         </plugin>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <configuration>
             <source>1.8</source>
             <target>1.8</target>
           </configuration>
         </plugin>
       </plugins>
     </build>
   </project>
   ```
**Anmerkung**  
Wenn Sie ein vorhandenes Maven-Projekt ändern, ist die erforderliche Abhängigkeit im vorhergehenden Code hervorgehoben.

1. Zum Erstellen von Unterverzeichnissen für den Beispielquellcode (`src/main/java/com/amazonaws/`), geben Sie Folgendes in die Befehlszeile ein:

   ```
   mkdir -p src/main/java/com/amazonaws/
   ```

1. Erstellen Sie im Verzeichnis `src/main/java/com/amazonaws/` eine Datei namens `App.java` und öffnen Sie diese dann in einem Text-Editor.

1. Kopieren Sie Folgendes in die `App.java`-Datei. *your-neptune-endpoint*Ersetzen Sie durch die Adresse Ihrer Neptune-DB-Instance.
**Anmerkung**  
Informationen zum Ermitteln des Hostnamens Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md). 

   ```
   package com.amazonaws;
   
   import org.eclipse.rdf4j.repository.Repository;
   import org.eclipse.rdf4j.repository.http.HTTPRepository;
   import org.eclipse.rdf4j.repository.sparql.SPARQLRepository;
   
   import java.util.List;
   import org.eclipse.rdf4j.RDF4JException;
   import org.eclipse.rdf4j.repository.RepositoryConnection;
   import org.eclipse.rdf4j.query.TupleQuery;
   import org.eclipse.rdf4j.query.TupleQueryResult;
   import org.eclipse.rdf4j.query.BindingSet;
   import org.eclipse.rdf4j.query.QueryLanguage;
   import org.eclipse.rdf4j.model.Value;
   
   public class App
   {
       public static void main( String[] args )
       {
           String sparqlEndpoint = "https://your-neptune-endpoint:port/sparql";
           Repository repo = new SPARQLRepository(sparqlEndpoint);
           repo.initialize();
   
           try (RepositoryConnection conn = repo.getConnection()) {
              String queryString = "SELECT ?s ?p ?o WHERE { ?s ?p ?o } limit 10";
   
              TupleQuery tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString);
   
              try (TupleQueryResult result = tupleQuery.evaluate()) {
                 while (result.hasNext()) {  // iterate over the result
                      BindingSet bindingSet = result.next();
   
                      Value s = bindingSet.getValue("s");
                      Value p = bindingSet.getValue("p");
                      Value o = bindingSet.getValue("o");
   
                      System.out.print(s);
                      System.out.print("\t");
                      System.out.print(p);
                      System.out.print("\t");
                      System.out.println(o);
                 }
              }
           }
       }
   }
   ```

1. Kompilieren und führen Sie das Beispiel mit folgendem Maven-Befehl aus:

   ```
   mvn compile exec:java
   ```

Das vorherige Beispiel gibt bis zu 10 der Triples (subject-predicate-object) im Diagramm zurück, wenn die `?s ?p ?o` Abfrage mit einem Limit von 10 verwendet wird. Um etwas anderes abzufragen, ersetzen Sie die Abfrage durch eine andere SPARQL-Abfrage.

Die Iteration der Ergebnisse des Beispiels gibt die Werte alle zurückgegebenen Variablen aus. Das `Value`-Objekt wird in einen `String` konvertiert und ausgegeben. Wenn Sie den `SELECT`-Teil der Abfrage ändern, müssen Sie den Code ändern.