[JAVA] Data Nucleus commençant par Gradle

introduction

Ceci est l'article du 11ème jour du Java Advent Calendar 2016.

Tout a commencé lorsque j'étais skieur Gradle et que je voulais utiliser Google Cloud SQL avec Google Container Engine sur Gradle. Après cela, j'ai heurté des murs, alors j'ai décidé d'en écrire un peu, y compris la signification d'un mémorandum.

Google Cloud SQL est une fonction de Google Cloud Platfrom et est une base de données compatible MySQL. Google Container Engine est également une fonctionnalité de Google Cloud Platform, simplement un hôte Docker. Il y a de nombreux malentendus, veuillez donc vous référer à des spécialistes, des livres spécialisés et des pages spécialisées dans ce domaine.

Qu'est-ce que JDO et Data Nucleus?

Pour expliquer brièvement JDO, il s'agit d'un mécanisme qui permet aux classes Java d'être stockées dans la base de données telles quelles. Il semble que le maintien de l'état d'une classe s'exprime comme persistance en utilisant JDO. Dans cet article, je vais laisser la structure de côté et la rendre disponible en premier.

DataNucleus est une implémentation JPA et JDO et est également couramment utilisé dans Google App Engine. Par conséquent, si vous recherchez DataNucleus sur le Web, vous trouverez de nombreux articles sur AppEngine, ce qui peut être un peu déroutant. La page officielle est ici. http://www.datanucleus.org/

Dans cet article, j'aimerais vous présenter Data Nucleus 5.0.3, qui a une longueur d'avance sur la dernière.

Projet Gradle

Maintenant, je voudrais créer un projet Gradle. Je ne suis pas doué pour expliquer, alors j'aimerais parler en code.

build.gradle

buildscript {
  repositories {
    jcenter()
  }
}

apply plugin: 'java'
apply plugin: 'application'

mainClassName = 'net.leak4mk0.test.datanucleus.Main'

[compileJava, compileTestJava]*.options*.encoding = 'UTF-8'

repositories {
    jcenter()
}

dependencies {
  // JDO
  compile 'org.datanucleus:datanucleus-core:5.0.3'
  compile 'org.datanucleus:datanucleus-api-jdo:5.0.3'
  compile 'org.datanucleus:datanucleus-rdbms:5.0.3'
  compile 'org.datanucleus:javax.jdo:3.2.0-m5'

  // DB
  compile 'com.h2database:h2:1.4.193'
}

Notez qu'au lieu de nous fier à javax.jdo: jdo-api: * comme interface JDO, nous utilisons ʻorg.datanucleus: javax.jdo: * `fourni par DataNucleus. .. Il ne semble y avoir aucun problème avec les versions antérieures de DataNucleus, mais il semble préférable d'utiliser l'interface DataNucleus pour la série 5.x.x.

De plus, bien sûr, vous avez besoin d'un connecteur DB. Cette fois, nous adopterons H2 pour la base de données, alors ajoutez le pilote H2 à la dépendance. Si vous voulez juste utiliser le pilote, vous pouvez utiliser runtime, mais cette fois je veux utiliser la console Web, donc je spécifie compile.

Importez le fichier Gradle créé avec Intellij IDEA. Si vous utilisez Eclipse ou n'avez pas besoin d'un IDE, veuillez procéder de manière appropriée. (Sensation de lancer) En passant, Gradle est déjà v3.1 ... J'ai remarqué en regardant en bas à droite d'IDEA.

Modèle JDO

Ensuite, je voudrais créer une classe de modèle à utiliser dans JDO. Voici un exemple, mais je pense qu'il est utile de consulter d'autres pages sur JDO (en particulier la documentation officielle d'AppEngine). Les classes communes «Auteur» et «Livre».

java/net/leak4mk0/test/datanucleus/Author.java

package net.leak4mk0.test.datanucleus;

import java.util.Set;
import javax.jdo.annotations.Element;
import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;

@PersistenceCapable //Classe à persister
public class Author {
  @PrimaryKey //Clé primaire
  @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY) //Générer automatiquement une clé unique
  private Long id;

  @Persistent //Champs à persister
  private String name;

  @Persistent(mappedBy = "author")
  @Element(dependent = "true")
  private Set<Book> books;

  public Author(String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

java/net/leak4mk0/test/datanucleus/Book.java

package net.leak4mk0.test.datanucleus;

import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;

@PersistenceCapable
public class Book {
  @PrimaryKey
  @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
  private Long id;

  @Persistent
  private Author author;

  @Persistent
  private String title;

  public Book(Author author, String title) {
    this.author = author;
    this.title = title;
  }

  public Author getAuthor() {
    return this.author;
  }

  public void setAuthor(Author author) {
    this.author = author;
  }

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }
}

Nous utiliserons des annotations pour spécifier comment persister.

Fichier de configuration JDO

Certains paramètres sont nécessaires pour que JDO puisse accéder à la base de données. Nous définirons ce qu'il faut utiliser pour l'implémentation JDO, la destination de la connexion DB, le pilote, l'utilisateur, etc. Pour plus de détails, reportez-vous à la page suivante. http://www.datanucleus.org/products/datanucleus/jdo/pmf.html

resources/META-INF/jdoconfig.xml

<?xml version="1.0" encoding="utf-8"?>
<jdoconfig xmlns="http://xmlns.jcp.org/xml/ns/jdo/jdoconfig">
  <persistence-manager-factory name="memory-h2">
    <property name="javax.jdo.PersistenceManagerFactoryClass"
        value="org.datanucleus.api.jdo.JDOPersistenceManagerFactory"/>
    <property name="javax.jdo.option.ConnectionURL" value="jdbc:h2:mem:test"/>
    <property name="javax.jdo.option.ConnectionDriverName" value="org.h2.Driver"/>
    <property name="javax.jdo.option.ConnectionUserName" value="sa"/>
    <property name="javax.jdo.option.ConnectionPassword" value=""/>
    <property name="datanucleus.schema.autoCreateTable" value="true"/>
  </persistence-manager-factory>
</jdoconfig>

Il est également possible de décrire plusieurs paramètres, tels que la modification de la base de données utilisée pendant le développement et l'exploitation. Cela peut être fait en écrivant plusieurs éléments persistence-manager-factory avec des attributs name différents.

Code principal

Et le code principal. Vous n'utiliserez probablement pas de noms de variables multi-octets dans votre code réel, mais cela peut être utile lors de l'écriture d'un exemple de code. La complétion de code est difficile à travailler, mais ...

java/net/leak4mk0/test/datanucleus/Main.java

package net.leak4mk0.test.datanucleus;

import java.sql.SQLException;
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import org.h2.tools.Server;

public class Main {
  public static void main(String[] args) throws SQLException {
    final PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory("memory-h2");
    final PersistenceManager pm = pmf.getPersistenceManager();

Auteur final Ryunosuke Akutagawa= new Author("Ryunosuke Akutagawa");
Auteur final Satoshi Fukuzawa= new Author("Satoshi Fukuzawa");
Auteur final Osamu Osamu= new Author("Osamu Dazai");
    pm.makePersistentAll(Satoshi Fukuzawa,Osamu Dazai); //Persistance

livre final Rashomon= new Book(Ryunosuke Akutagawa, "Rashomon");
    pm.makePersistentAll(Rashomon); //Persistance

livre final Affaires occidentales= new Book(Satoshi Fukuzawa, "Affaires occidentales");
Recommandations académiques finales du livre= new Book(Satoshi Fukuzawa, "Recommandations académiques");
    pm.makePersistentAll(Affaires occidentales,Recommandations académiques); //Persistance

dernier livre 100 vues de Tomitake= new Book(Osamu Dazai, "Tomitake Hyakukei");
Final Book Run Meros= new Book(Osamu Dazai, "Exécuter meros");
livre final Tsugaru= new Book(Osamu Dazai, "Tsugaru");
    pm.makePersistentAll(Tomitake Hyakukei,Exécuter meros,Tsugaru); //Persistance

    pm.deletePersistentAll(Rashomon); //Effacer

Recommandations académiques.author =Osamu Dazai; //Changement

    Server.main(); //Lancez la console
  }
}

Fondamentalement, makePersistent pour conserver les données et deletePersistent pour les supprimer. De plus, si vous souhaitez modifier les données une fois persistantes, modifiez simplement le champ. Je ne l'ai pas posté cette fois, mais lors de la recherche, j'utiliserai les méthodes newQuery et ʻexecuteList`.

Encore une étape, améliorer

Enfin, il reste un emploi. Comme vous pouvez le voir, l'utilisation de JDO pour conserver un modèle nécessite un code très simple, car DataNucleus ajoute le code dont vous avez vraiment besoin à chaque classe. L'ajout de code en se référant aux informations d'annotation est appelé Enhance, et afin de rendre la classe de modèle persistante, Enhancer doit améliorer la classe de modèle après la compilation. Les détails sur l'utilisation de Enhancer sont décrits à la page suivante. http://www.datanucleus.org/products/datanucleus/jdo/enhancer.html

Écrire ceci dans Gradle est le point principal de cet article. (C'était long…) Je vais l'écrire rapidement en référence à la méthode de description dans Ant.

build.gradle

//Omission...
task enhance {
  description = 'DataNucleus enhancement'
  dependsOn compileJava

  doLast {
    ant.taskdef(
            name: 'datanucleusenhancer',
            classpath: sourceSets.main.runtimeClasspath.asPath,
            classname: 'org.datanucleus.enhancer.EnhancerTask'
    )

    ant.datanucleusenhancer(
            classpath: sourceSets.main.runtimeClasspath.asPath,
            failonerror: true,
            verbose: true,
            api: 'JDO') {
      fileset(dir: sourceSets.main.output.classesDir)
    }
  }
}
classes.dependsOn enhance

Puisqu'il utilise un fichier de classe, il doit être exécuté après la tâche compileJava, et dependOn spécifie qu'il dépend de compileJava. Cela rend également la tâche classes dépendante de la tâche ʻenhance` pour s'assurer qu'elle est améliorée avant l'exécution.

Résultat d'exécution

Après cela, gradlew run devrait démarrer le navigateur et vérifier le contenu de la base de données. Assurez-vous de spécifier jdbc: h2: mem: test dans l'URL JDBC.

Vous pouvez voir que tout le traitement de persistance effectué dans le code principal a été appliqué.

à la fin

Cette fois, le plus important était de savoir comment améliorer Data Nucleus avec Gradle. Lors du fonctionnement réel sur GCP, lors de l'ajout de dépendances à Gradle, il y avait un autre point d'adaptation en raison de conflits de bibliothèque, etc. S'il y a des erreurs de codage évidentes mais des exceptions, vous voudrez peut-être regarder une fois l'arbre de dépendances de Gradle.

Jusqu'à la fin Merci d'avoir lu. N'hésitez pas à utiliser le code présenté dans cet article. Cependant, veuillez noter que nous ne pouvons prendre aucune responsabilité.