[JAVA] J'ai essayé le guide d'introduction de Spring Boot [Accès aux données avec JPA]

Objectif

Pour ceux qui ont fini de travailler sur Spring Quickstart Guide, ceux qui ont commencé à apprendre Spring Boot et ceux qui veulent revoir

Le fonctionnaire est un guide populaire, alors essayez-le! Je partagerai ce que j'ai appris en travaillant réellement sur Accéder aux données avec JPA.

Environnement de développement

Système d'exploitation: macOS Mojave version 10.14.6
Éditeur de texte: Visual Studio Code (ci-après VSCode)
Java: 11.0.2

Cliquez ici pour consulter le guide de démarrage rapide Cliquez ici pour un examen de la création d'un service Web RESTful Cliquez ici pour un examen de la consommation d'un service Web RESTful

1. Démarrez le projet Spring Boot!

Tout d'abord, accédez à spring initial izr.

1. Cliquez sur le bouton AJOUTER DES DEPENDANCES pour ajouter Spring Data JPA et H2 Database.

** Spring Data JPA (Java Persistence API) est une API pour l'enregistrement et la récupération d'objets Java dans la base de données (mappage O / R). ** **

** H2 Database toha est une base de données fournie en standard en Java. En l'ajoutant ici, c'est pratique car il n'est pas nécessaire de configurer un serveur distinct tel que MySQL. ** **

2.Artifact, le nom a été changé en ʻaccessing-data-jpa`. 3. Changez Java en 11.

Cliquez ensuite sur le bouton GENERATE pour télécharger le fichier Zip.

Extrayez le fichier Zip téléchargé et vous êtes prêt à partir.

2. Ajoutez du code!

Ouvrez le dossier précédent avec VS Code. Nous vous recommandons d'installer le Java Extension Pack pour les extensions. Il est dit que vous devez l'installer. (Uniquement pour ceux qui ne l'ont pas installé)

Créons Customer.java!

Créez un fichier Customer.java dans src / main / java / com / example / accessdatajpa /.

Nous ajouterons le code dans le fichier Customer.java.

Customer.java

package com.example.accessingdatajpa;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Customer {

  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  private Long id;
  private String firstName;
  private String lastName;

  protected Customer() {}

  public Customer(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return String.format(
        "Customer[id=%d, firstName='%s', lastName='%s']",
        id, firstName, lastName);
  }

  public Long getId() {
    return id;
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }
}

Nous approfondirons le code que nous avons ajouté au fichier Customer.java.

①@Entity

Customer.java

@Entity
public class Customer {
  //réduction
}

L'annotation @ Entity est une classe associée à une table DB (classe d'entité). Les variables définies dans cette classe d'entité sont associées à des colonnes DB.

② @ Id,@GeneratedValue (strategy = GenerationType.AUTO), constructeur

Customer.java

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
private String firstName;
private String lastName;

protected Customer() {}

public Customer(String firstName, String lastName) {
  this.firstName = firstName;
  this.lastName = lastName;
}

Dans l'annotation «@ Id», la variable affectée devient la clé primaire de la table. De plus, avec l'annotation @GeneratedValue (strategy = GenerationType.AUTO), les identifiants seront automatiquement générés avec des numéros de série.

Dans cette table Customer, la clé primaire est id et les autres colonnes ont firstName et lastName.

En tant qu'exigence de la classe d'entité, un constructeur sans argument est requis, définissez donc un constructeur sans arguments, Un constructeur avec des arguments est défini pour créer une instance à enregistrer dans la base de données.

③ Définition de la méthode toString et de la méthode getter

Customer.java

@Override
public String toString() {
  return String.format(
     "Customer[id=%d, firstName='%s', lastName='%s']",
      id, firstName, lastName);
}

public Long getId() {
  return id;
}

public String getFirstName() {
  return firstName;
}

public String getLastName() {
  return lastName;
}

La méthode toString est une méthode qui renvoie une représentation sous forme de chaîne telle que définie dans la classe java.lang.Object. L'annotation @ Override remplace la méthode toString définie dans la classe ʻObject avec cette classe. C'est une annotation pour spécifier `.

S'il n'est pas remplacé correctement, une erreur se produira. Par conséquent, si vous faites une faute de frappe comme toStrign (), vous obtiendrez une erreur lors de la compilation et cela vous le dira.

Cette fois, je remplace une méthode qui renvoie une chaîne pour afficher l'id, le prénom et le nom.

Lorsque vous utilisez la méthode appelée String.format, vous devez spécifier le format spécifié comme premier argument, donc % s spécifie une chaîne et% d spécifie un entier décimal et un format.

Après cela, nous définissons une méthode getter pour obtenir chaque variable.

Créons CustomerRepository.java!

Créez un fichier CustomerRepository.java dans src / main / java / com / example / accessdatajpa /.

Nous ajouterons du code dans le fichier CustomerRepository.java.

CustomerRepository.java

package com.example.accessingdatajpa;

import java.util.List;

import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository<Customer, Long> {

  List<Customer> findByLastName(String lastName);

  Customer findById(long id);

}

Nous approfondirons le code que nous avons ajouté au fichier CustomerRepository.java.

① Créer une interface de référentiel

CustomerRepository.java

public interface CustomerRepository extends CrudRepository<Customer, Long> {
  //réduction
}

Je crée une interface appelée CustomerRepository. À ce moment-là, il hérite d'une interface appelée Crud Repository. L'interface `CrudRepository spécifie le type d'entité Customer et le type d'ID Long comme paramètres génériques. ''

L'interface CrudRepository est une interface qui vous permet d'effectuer des opérations telles que Créer, Lire, Mettre à jour et Supprimer (CRUD). Par conséquent, l'interface du référentiel client peut également effectuer les opérations ci-dessus.

② Mise en œuvre de la méthode

CustomerRepository.java

List<Customer> findByLastName(String lastName);

Customer findById(long id);

Dans Spring Data JPA, findBy 〇〇 et une méthode qui satisfait une règle de dénomination spécifique sont définis comme des ** méthodes de requête basées sur leur contenu. ** **

Cette fois, «findByLastName (String lastName)» est applicable. C'est une méthode qui peut obtenir toutes les données correspondant au lastName reçu en argument. findById (long id) est une méthode qui peut obtenir les données qui correspondent à un identifiant spécifique.

Modifions AccessingDataJpaApplication.java!

Je pense que l'état par défaut est le suivant.

AccessingDataJpaApplication.java

package com.example.accessingdatajpa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AccessingDataJpaApplication {
    
    public static void main(String[] args) {
      SpringApplication.run(AccessingDataJpaApplication.class, args);
    }

}

Ajoutez le code en vous référant à la formule.

AccessingDataJpaApplication.java

package com.example.accessingdatajpa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//Code ajouté
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class AccessingDataJpaApplication {

  //Code ajouté
  private static final Logger log = LoggerFactory.getLogger(AccessingDataJpaApplication.class);

  public static void main(String[] args) {
    SpringApplication.run(AccessingDataJpaApplication.class);
  }

  //Code ajouté
  @Bean
  public CommandLineRunner demo(CustomerRepository repository) {
    return (args) -> {
      // save a few customers
      repository.save(new Customer("Jack", "Bauer"));
      repository.save(new Customer("Chloe", "O'Brian"));
      repository.save(new Customer("Kim", "Bauer"));
      repository.save(new Customer("David", "Palmer"));
      repository.save(new Customer("Michelle", "Dessler"));

      // fetch all customers
      log.info("Customers found with findAll():");
      log.info("-------------------------------");
      for (Customer customer : repository.findAll()) {
        log.info(customer.toString());
      }
      log.info("");

      // fetch an individual customer by ID
      Customer customer = repository.findById(1L);
      log.info("Customer found with findById(1L):");
      log.info("--------------------------------");
      log.info(customer.toString());
      log.info("");

      // fetch customers by last name
      log.info("Customer found with findByLastName('Bauer'):");
      log.info("--------------------------------------------");
      repository.findByLastName("Bauer").forEach(bauer -> {
        log.info(bauer.toString());
      });
      // for (Customer bauer : repository.findByLastName("Bauer")) {
      //  log.info(bauer.toString());
      // }
      log.info("");
    };
  }

}

Nous approfondirons le code que nous avons ajouté au fichier AccessingDataJpaApplication.java.

① journal pour la sortie du journal

AccessingDataJpaApplication.java

//Code ajouté
private static final Logger log = LoggerFactory.getLogger(AccessingDataJpaApplication.class);

Logger et LoggerFactory sont utilisés pour afficher le journal dans le terminal. Vous pouvez obtenir le journal en spécifiant la classe dans l'argument de LoggerFactory.getLogger ().

② Enregistrement et acquisition des données

AccessingDataJpaApplication.java

//Code ajouté
@Bean
public CommandLineRunner demo(CustomerRepository repository) {
  return (args) -> {
    // save a few customers
    repository.save(new Customer("Jack", "Bauer"));
    repository.save(new Customer("Chloe", "O'Brian"));
    repository.save(new Customer("Kim", "Bauer"));
    repository.save(new Customer("David", "Palmer"));
    repository.save(new Customer("Michelle", "Dessler"));

    // fetch all customers
    log.info("Customers found with findAll():");
    log.info("-------------------------------");
    for (Customer customer : repository.findAll()) {
      log.info(customer.toString());
    }
    log.info("");

    // fetch an individual customer by ID
    Customer customer = repository.findById(1L);
    log.info("Customer found with findById(1L):");
    log.info("--------------------------------");
    log.info(customer.toString());
    log.info("");

    // fetch customers by last name
    log.info("Customer found with findByLastName('Bauer'):");
    log.info("--------------------------------------------");
    repository.findByLastName("Bauer").forEach(bauer -> {
      log.info(bauer.toString());
    });
    // for (Customer bauer : repository.findByLastName("Bauer")) {
    //  log.info(bauer.toString());
    // }
    log.info("");
  };
}

Enregistrement et acquisition de données La méthode Démo CommandLineRunner (référentiel CustomerRepository) est appelée par Spring Boot après l'exécution de l'application.

Tout d'abord, nous enregistrons des données. Lors de l'instanciation d'un client, nous transmettons une chaîne (firstName, lastName) comme argument au constructeur. Ensuite, l'objet Java généré est enregistré dans la table Customer par la méthode de sauvegarde du référentiel.

python

repository.save(new Customer("Jack", "Bauer"));

Ensuite, j'obtiens toutes les données avec findAll () ''. L'instruction for étendue tourne la boucle, reçoit plusieurs données acquises avec l'argument client et les sort une par une. J'utilise le remplacement toString () '' lors de la sortie.

python

for (Customer customer : repository.findAll()) {
  log.info(customer.toString());
}

Ensuite, les données avec l'ID 1 sont acquises par `` findById (1L) ''. Comme cela ne peut acquérir qu'une seule donnée spécifique, elle est sortie sans boucle.

python

// fetch an individual customer by ID
Customer customer = repository.findById(1L);
log.info(customer.toString());

Enfin, avec findByLastName ("Bauer"), nous obtenons les données avec la valeur de lastName Bauer. Il peut y avoir plusieurs de ces données, elles ont donc été définies pour être reçues en tant que type de liste.

Les données multiples acquises sont bouclées par l'instruction forEach, reçues par l'argument bauer et sorties une par une. Je pense que la déclaration étendue pour qui est commentée peut être écrite de cette manière.

python

// fetch customers by last name
repository.findByLastName("Bauer").forEach(bauer -> {
    log.info(bauer.toString());
});
// for (Customer bauer : repository.findByLastName("Bauer")) {
  //  log.info(bauer.toString());
// }

3. Lançons-le!

Maintenant que l'application est prête à fonctionner, vérifions.

Entrez la commande suivante dans le terminal et appuyez sur Entrée.

Terminal

$ ./mvnw spring-boot:run

Après un certain temps, les caractères suivants apparaîtront dans le terminal.

Terminal

Customers found with findAll():
-------------------------------
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']

Customer found with findById(1L):
--------------------------------
Customer[id=1, firstName='Jack', lastName='Bauer']

Customer found with findByLastName('Bauer'):
--------------------------------------------
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']

Site de référence

** En tant que base des annotations relatives à JPA - Partie 1- ** ** Exigences de classe d'entité ** CrudRepository ** [Spring Data JPA] Règles de dénomination pour les méthodes implémentées automatiquement **