Utilizzo di Java per connettersi a un'istanza database Neptune

Per connettersi a Neptune tramite Java

1. Installa Apache Maven sulla tua istanza. EC2 Per aggiungere un archivio con un pacchetto Maven, immettere prima quanto segue:

   sudo wget https://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo

   Per impostare il numero di versione per i pacchetti, immettere quanto segue.

   sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo

   Potrai quindi utilizzare yum per installare Maven:

   sudo yum install -y apache-maven

2. Questo esempio è stato testato solo con Java 8. Inserisci quanto segue per installare Java 8 sulla tua istanza: EC2

   sudo yum install java-1.8.0-devel

3. Immettete quanto segue per impostare Java 8 come runtime predefinito sull'EC2istanza:

   sudo /usr/sbin/alternatives --config java

   Quando richiesto, immetti il numero per Java 8.

4. Immettete quanto segue per impostare Java 8 come compilatore predefinito sulla vostra EC2 istanza:

   sudo /usr/sbin/alternatives --config javac

   Quando richiesto, immetti il numero per Java 8.

5. In una nuova directory , creare un file pom.xml, quindi aprirlo in un editor di testo.

6. Copia quanto segue nel file pom.xml e salvalo (di solito puoi modificare i numeri di versione in base all'ultima versione stabile):

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

   Nota

   Se stai modificando un progetto Maven esistente, la dipendenza necessaria è evidenziata nel codice precedente.

7. Per creare sottodirectory per il codice sorgente di esempio (src/main/java/com/amazonaws/), immettere quanto segue nella riga di comando:

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

8. Nella directory src/main/java/com/amazonaws/, creare un file denominato App.java, quindi aprirlo in un editor di testo.

9. Copiare quanto segue nel file App.java. Replace (Sostituisci) your-neptune-endpoint con l'indirizzo della tua istanza DB di Neptune.

   Nota

   Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta la sezione Connessione agli endpoint Amazon Neptune.

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

10. Per compilare ed eseguire l'esempio, usare il comando Maven seguente:

    mvn compile exec:java