Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de Java para conectarse a una instancia de base de datos de Neptune
<a name="access-graph-sparql-java"></a>

En esta sección, se indica cómo ejecutar un ejemplo de Java completo que se conecta a una instancia de base de datos de Amazon Neptune y realiza una consulta SPARQL.

Siga estas instrucciones desde una instancia de Amazon EC2 que esté en la misma nube privada virtual (VPC) que su instancia de base de datos de Neptune.

**Para conectarse a Neptune mediante Java**

1. Instale Apache Maven en la instancia EC2. Si utiliza Amazon Linux 2023 (preferido), utilice:

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

   Si utiliza Amazon Linux 2, descargue el archivo binario más reciente desde [https://maven.apache.org/download.cgi:](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. Este ejemplo solo se ha probado con Java 8. Escriba lo siguiente para instalar Java 8 en la instancia EC2:

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

1. Escriba lo siguiente para establecer Java 8 como tiempo de ejecución predeterminado en la instancia EC2:

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

   Cuando se le solicite, escriba el número para Java 8.

1. Escriba lo siguiente para establecer Java 8 como compilador predeterminado en la instancia EC2: 

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

   Cuando se le solicite, escriba el número para Java 8.

1. En un directorio nuevo, cree un archivo `pom.xml` y, a continuación, ábralo en un editor de texto.

1. Copie lo siguiente en el archivo `pom.xml` y guárdelo (normalmente puede ajustar los números de versión a la última versión estable):

   ```
   <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**  
Si está modificando un proyecto de Maven ya existente, la dependencia requerida aparece resaltada en el código anterior.

1. Escriba lo siguiente en la línea de comandos a fin de crear subdirectorios para el código fuente de ejemplo (`src/main/java/com/amazonaws/`):

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

1. En el directorio `src/main/java/com/amazonaws/`, cree un archivo llamado `App.java` y, a continuación, ábralo en un editor de texto.

1. Copie lo siguiente en el archivo `App.java`. *your-neptune-endpoint*Sustitúyala por la dirección de la instancia de base de datos de Neptune.
**nota**  
Para obtener información acerca de cómo encontrar el nombre de host de la instancia de base de datos de Neptune, consulte la sección [Conexión a los puntos de conexión de Amazon Neptune](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. Use el siguiente comando Maven para compilar y ejecutar el ejemplo:

   ```
   mvn compile exec:java
   ```

El ejemplo anterior devuelve hasta 10 de los triples (subject-predicate-object) del gráfico utilizando la `?s ?p ?o` consulta con un límite de 10. Para otras consultas, sustitúyala por otra consulta SPARQL.

La iteración de los resultados en el ejemplo imprime el valor de cada variable devuelta. El objeto `Value` se convierte en `String` y después se imprime. Si cambia la parte `SELECT` de la consulta, debe modificar el código.