pour utiliser DynamoDBLocal vous devez suivre ces étapes.

1. Direct DynamoDBLocal Dépendance
2. Obtenir Natif SQLite4Java dépendances
3. Set sqlite4java.library.path pour afficher les bibliothèques natives

1. Obtenez La Dépendance Dynamodblocale Directe

C'est le plus facile. Vous avez besoin de ce dépôt comme expliqué dans forums AWS.

<!--Dependency:-->
<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>DynamoDBLocal</artifactId>
        <version>1.11.0.1</version>
        <scope></scope>
    </dependency>
</dependencies>
<!--Custom repository:-->
<repositories>
    <repository>
        <id>dynamodb-local</id>
        <name>DynamoDB Local Release Repository</name>
        <url>https://s3-us-west-2.amazonaws.com/dynamodb-local/release</url>
    </repository>
</repositories>

2. Obtenir Natif Sqlite4java dependencies

Si vous n'ajoutez pas ces dépendances, vos tests échoue avec 500 erreur interne.

tout d'Abord, ajoutez ces dépendances:

<dependency>
    <groupId>com.almworks.sqlite4java</groupId>
    <artifactId>sqlite4java</artifactId>
    <version>1.0.392</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.almworks.sqlite4java</groupId>
    <artifactId>sqlite4java-win32-x86</artifactId>
    <version>1.0.392</version>
    <type>dll</type>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.almworks.sqlite4java</groupId>
    <artifactId>sqlite4java-win32-x64</artifactId>
    <version>1.0.392</version>
    <type>dll</type>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.almworks.sqlite4java</groupId>
    <artifactId>libsqlite4java-osx</artifactId>
    <version>1.0.392</version>
    <type>dylib</type>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.almworks.sqlite4java</groupId>
    <artifactId>libsqlite4java-linux-i386</artifactId>
    <version>1.0.392</version>
    <type>so</type>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.almworks.sqlite4java</groupId>
    <artifactId>libsqlite4java-linux-amd64</artifactId>
    <version>1.0.392</version>
    <type>so</type>
    <scope>test</scope>
</dependency>

puis, ajoutez ce plugin pour obtenir des dépendances natives à un dossier spécifique:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.10</version>
            <executions>
                <execution>
                    <id>copy</id>
                    <phase>test-compile</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <includeScope>test</includeScope>
                        <includeTypes>so,dll,dylib</includeTypes>
                        <outputDirectory>${project.basedir}/native-libs</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

3. Set sqlite4java.library.path pour afficher les bibliothèques natives

comme dernière étape, vous devez définir sqlite4java.library.path propriété du système dans le répertoire natif-libs. C'est OK pour le faire avant de créer votre serveur local.

System.setProperty("sqlite4java.library.path", "native-libs");

après ces étapes, vous pouvez utiliser DynamoDBLocal comme bon vous semble. Voici une règle de Junit qui crée un serveur local pour cela.

import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.local.main.ServerRunner;
import com.amazonaws.services.dynamodbv2.local.server.DynamoDBProxyServer;
import org.junit.rules.ExternalResource;

import java.io.IOException;
import java.net.ServerSocket;

/**
 * Creates a local DynamoDB instance for testing.
 */
public class LocalDynamoDBCreationRule extends ExternalResource {

    private DynamoDBProxyServer server;
    private AmazonDynamoDB amazonDynamoDB;

    public LocalDynamoDBCreationRule() {
        // This one should be copied during test-compile time. If project's basedir does not contains a folder
        // named 'native-libs' please try '$ mvn clean install' from command line first
        System.setProperty("sqlite4java.library.path", "native-libs");
    }

    @Override
    protected void before() throws Throwable {

        try {
            final String port = getAvailablePort();
            this.server = ServerRunner.createServerFromCommandLineArgs(new String[]{"-inMemory", "-port", port});
            server.start();
            amazonDynamoDB = new AmazonDynamoDBClient(new BasicAWSCredentials("access", "secret"));
            amazonDynamoDB.setEndpoint("http://localhost:" + port);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected void after() {

        if (server == null) {
            return;
        }

        try {
            server.stop();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public AmazonDynamoDB getAmazonDynamoDB() {
        return amazonDynamoDB;
    }

    private String getAvailablePort() {
        try (final ServerSocket serverSocket = new ServerSocket(0)) {
            return String.valueOf(serverSocket.getLocalPort());
        } catch (IOException e) {
            throw new RuntimeException("Available port was not found", e);
        }
    }
}

Vous pouvez utiliser cette règle comme ceci

@RunWith(JUnit4.class)
public class UserDAOImplTest {

    @ClassRule
    public static final LocalDynamoDBCreationRule dynamoDB = new LocalDynamoDBCreationRule();
}

vous pouvez utiliser DynamoDB Local comme une dépendance de test Maven dans votre code de test, comme indiqué dans ce annonce. Vous pouvez exécuter sur HTTP:

import com.amazonaws.services.dynamodbv2.local.main.ServerRunner;
import com.amazonaws.services.dynamodbv2.local.server.DynamoDBProxyServer;

final String[] localArgs = { "-inMemory" };
DynamoDBProxyServer server = ServerRunner.createServerFromCommandLineArgs(localArgs);
server.start();
AmazonDynamoDB dynamodb = new AmazonDynamoDBClient();
dynamodb.setEndpoint("http://localhost:8000");
dynamodb.listTables();
server.stop();

vous pouvez également exécuter en mode embedded:

import com.amazonaws.services.dynamodbv2.local.embedded.DynamoDBEmbedded;

AmazonDynamoDB dynamodb = DynamoDBEmbedded.create();
dynamodb.listTables();

il s'agit d'une reformulation de la réponse de bhdrkn pour les utilisateurs de Gradle (la sienne est basée sur Maven). C'est toujours les mêmes trois étapes:

1. Direct DynamoDBLocal Dépendance
2. Obtenir Natif SQLite4Java dépendances
3. Définir sqlite4java.bibliothèque.chemin de montrer bibliothèques natives

1. Obtenez La Dépendance Dynamodblocale Directe

ajouter à la section dépendances de votre build.gradle fichier...

dependencies {
    testCompile "com.amazonaws:DynamoDBLocal:1.+"
}

2. Obtenir Natif SQLite4Java dépendances

les bibliothèques sqlite4java seront déjà téléchargées en tant que dépendance de DynamoDBLocal, mais les fichiers de la bibliothèque doivent être copiés au bon endroit. Ajouter à votre construction.dossier gradle...

task copyNativeDeps(type: Copy) {
    from(configurations.compile + configurations.testCompile) {
        include '*.dll'
        include '*.dylib'
        include '*.so'
    }
    into 'build/libs'
}

3. Set sqlite4java.bibliothèque.chemin de montrer bibliothèques natives

nous devons dire à Gradle de courir copyNativeDeps pour tester et dire à sqlite4java où trouver les fichiers. Ajouter à votre construire.dossier gradle...

test {
    dependsOn copyNativeDeps
    systemProperty "java.library.path", 'build/libs'
}

j'ai enveloppé les réponses ci-dessus en deux JUnit rules cela ne nécessite pas de modifications au script de compilation car les règles traitent les éléments de bibliothèque natifs. J'ai fait cela car j'ai trouvé que L'idée n'aimait pas les solutions de Gradle/Maven comme il vient de se déclencher et a fait sa propre chose anyhoos.

cela signifie que les étapes sont:

• Get the Assortimentofjunitrules version 1.5.32 or above dependency
• Get the Direct DynamoDBLocal dépendance
• ajouter le LocalDynamoDbRule ou HttpDynamoDbRule à votre test JUnit.

Maven:

<!--Dependency:-->
<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>DynamoDBLocal</artifactId>
        <version>1.11.0.1</version>
        <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.github.mlk</groupId>
      <artifactId>assortmentofjunitrules</artifactId>
      <version>1.5.36</version>
      <scope>test</scope>
    </dependency>
</dependencies>
<!--Custom repository:-->
<repositories>
    <repository>
        <id>dynamodb-local</id>
        <name>DynamoDB Local Release Repository</name>
        <url>https://s3-us-west-2.amazonaws.com/dynamodb-local/release</url>
    </repository>
</repositories>

Gradle:

repositories {
  mavenCentral()

   maven {
    url = "https://s3-us-west-2.amazonaws.com/dynamodb-local/release"
  }
}

dependencies {
    testCompile "com.github.mlk:assortmentofjunitrules:1.5.36"
    testCompile "com.amazonaws:DynamoDBLocal:1.+"
}

Code:

public class LocalDynamoDbRuleTest {
  @Rule
  public LocalDynamoDbRule ddb = new LocalDynamoDbRule();

  @Test
  public void test() {
    doDynamoStuff(ddb.getClient());
  }
}

pour les tests unitaires au travail, J'utilise Mockito, puis je me moque de L'AmazonDynamoDBClient. ensuite simulé les retours à l'aide lorsque. comme suit:

when(mockAmazonDynamoDBClient.getItem(isA(GetItemRequest.class))).thenAnswer(new Answer<GetItemResult>() {
        @Override
        public GetItemResult answer(InvocationOnMock invocation) throws Throwable {
            GetItemResult result = new GetItemResult();
            result.setItem( testResultItem );
            return result;
        }
    });

pas sûr si c'est ce que vous cherchez, mais c'est comment nous le faisons.

Il y a le couple de nœud.js wrappers pour DynamoDB Local. Ceux-ci permettent d'exécuter facilement des essais unitaires en combinaison avec des coureurs de tâches comme gulp ou grunt. Essayez dynamodb-localhost, dynamodb-local

dans Hadoop nous utilisons aussi DynamoDBLocal pour tester et déboguer le travail. S'il vous plaît voir comment il est utilisé comme exemple à: https://github.com/apache/hadoop/blob/HADOOP-13345/hadoop-tools/hadoop-aws/src/test/java/org/apache/hadoop/fs/s3a/s3guard/TestDynamoDBMetadataStore.java#L113

j'ai trouvé que l'amazone pensions qu'aucun fichier d'index, de sorte que ne semble pas fonctionner d'une manière qui vous permet de mettre en comme ceci:

maven {
   url = "https://s3-us-west-2.amazonaws.com/dynamodb-local/release"
}

la seule façon d'obtenir les dépendances à charger est de télécharger DynamoDbLocal comme un jar et de l'introduire dans mon script de construction comme ceci:

dependencies {
    ...
    runtime files('libs/DynamoDBLocal.jar')
    ...
}

bien sûr, cela signifie que toutes les dépendances de SQLite et de Jetty doivent être apportées à la main - je suis toujours en train d'essayer d'obtenir ce droit. Si quelqu'un connaît un fiable pensions pour DynamoDbLocal, j'aimerais vraiment savoir.