Tutoriel Spring et la persistance avec JPA

Par : LELA Malik, TERBAH Aghiles, FABLET Yann, DEVASSINE Alexandre

Décembre 2019

Création de projet SpringBoot et diverses configurations 2 Installer Spring Tool Suite dans Eclipse 2 1- Créer un projet Spring Boot 5 2- Configurer build.gradle 6 3- Configurer la connexion à une base de données 7

Mise en route 11

Architecture typique pour une application Web 15

Notion de composants 15

Comment tester les composants ? 16

Internationalisation 17

Création de projet SpringBoot et diverses configurations

Installer Spring Tool Suite dans Eclipse Rendez-vous sur le Marketplace d’Eclipse

Saisissez STS dans la barre de recherche. Installez Spring Tool Suite pour Eclipse Puis suivez les instructions sur les captures d’écran

Après l'installation est terminée, Eclipse vous demandera de redémarrer IDE. Cliquez sur Restart Now pour redémarrer IDE.

1- Créer un projet Spring Boot Allez sur le site : https://start.spring.io/ pour générer un projet automatiquement. Ou, sur Eclipse, créez un projet Spring Boot :

Sélectionnez les technologies utilisées dans ce projet, y compris JPA et une base de données que vous connaissez bien (ex : Derby DataBase).

2- Configurer build.gradle build.gradle est l’équivalent du pom.xml de Maven, c’est dans ce fichier que vous allez ajouter les dépendances nécessaires à votre projet. Note : Si vous souhaitez utiliser une BDD embarquée Derby (derby embedded), vérifiez qu’une fois le projet créé sous Eclipse, il y a bien la ligne : “runtimeOnly 'org.apache.derby:derby'” dans les dépendances du fichier build.gradle (dans le dossier src/resources). Voici le contenu du fichier build.gradle par défaut :

Vous pouvez observer dans dependencies un certains nombres d’alias importants. mavenCentral() : L’alias mavenCentral permet d’aller rechercher toutes les dépendances sur le site http://repo1.maven.org/maven2/ runtime : L’alias runTime contient les dépendances nécessaires seulement au lancement de l’application implementation : équivalent de compile, contient les dépendances nécessaires lors de la compilation du projet

3- Configurer la connexion à une base de données Afin que Spring Boot puisse se connecter à la base de données, vous devez le configurer dans le fichier applications.properties. Vous pouvez utiliser n'importe quelle base de données que vous bien connaissez, ci-dessous sont 4 configurations (MySQL, Oracle, SQL Server et Derby).

Si vous souhaitez utiliser une base de données de type Derby (non embarquée), voici la démarche à suivre :

1) Lancer la base de données associée à glassfish : a) se placer dans le dossier bin de glassfish5 b) ouvrir un terminal et lancer : ./asadmin start-database --dbhome ../javadb

2) Créer un serveur glassfish sous eclipse 3) Lancez ce serveur glassfish 4) Allez sur : http://localhost:8080/, puis allez dans la console d’administration de

glassfish 5) Une fois sur la console d'administration, allez dans la section “JDBC”, pui “JDBC

Connection Pools”, puis cliquez sur l’onglet “Additional Properties”. 6) Puis, récupérez les informations (PortNumber, Password, User). 7) Allez dans JDBC/JDBCRessources et récupérez le nom de la base par défaut

(“jdbc/__default”) 8) Modifiez la ligne de dépendance à derby de la manière suivante, dans le fichier

build.gradle : “runtimeOnly 'org.apache.derby:derbyclient:10.14.2.0'” 9) Allez dans le fichier application.properties et insérez les lignes suivantes :

spring.jpa.hibernate.ddl-auto=create spring.datasource.driver-class-name=org.apache.derby.jdbc.ClientDriver spring.datasource.url=jdbc:derby://localhost:1527/jdbc/__default;create=true spring.datasource.username=APP spring.datasource.password=APP

10) Voilà, vous avez configurez votre projet pour qu’il fonctionne avec une base de données Derby.

Si vous souhaitez visualiser le contenu de votre base de données sous Derby créée précédemment, voici la démarche à suivre :

1) Sous Eclipse, allez dans Database / New Database Connection 2) Choisissez donc un serveur de type Derby (Et non pas Derby Embedded) 3) Dans Database/Schema indiquez le nom de votre base (Dans l’exemple :

“jdbc/__default”) 4) Puis, renseignez les informations UserName et Password (Dans notre exemple :

“APP” pour les deux) 5) Puis, si les Driver ‘Derby Server’ ne sont pas présents, cliquez sur “Edit Driver

Settings”, puis cliquez sur “Download/Update” 6) Ensuite choisissez les versions “10.14.2.0” pour les deux premiers choix (sur 3), voir

capture d’écran ci-dessous :

7) Cliquez sur télécharger et faites suivant. 8) Avant de valider votre configuration, testez votre connexion. 9) Ensuite affichez la vue “DataBase Navigator” (Windows/ShowView/DataBase

Navigator) 10) Ainsi, vous pourrez voir le contenu de votre base de données en cliquant sur APP

(après avoir exécuter votre projet spring qui stocke des information dans votre base, bien évidemment).

Mise en route

Pour bien comprendre le fonctionnement de Spring Boot et JPA Persistence, nous allons suivre un petit tutoriel créé par Spring. Commencez par créer un projet de type Gradle. Nous allons créer des clients pour cette exemple : Créez une JPA Entity appelée : Customer.java 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;

}

}

Il s’agit là d’une entité JPA classique comme nous avons l’habitude d’en créer. Elle possède 3 attributs : name, firstname et id. La classe possède aussi 2 constructeurs, un constructeur par défaut qui existe juste pour le bien de JPA. On ne l’utilise jamais de façon direct, c’est pour cela qu’il est protected. L’autre constructeur est utilisé pour créer les instances de Customer qu’on sauvegardera dans la base de données. Customer est annotée @Entity, indiquant qu’il s’agit d’une entité JPA. Maintenant, nous allons créer de simples queries et pouvoir observer la puissance de la persistance JPA. Créez une interface CustomerRepository de cette façon : 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);

}

CustomerRepository hérite de l’interface CrudRepository. Les types avec lesquels on travaille est précisé, ici dans les paramètres génériques: <Customer, Long>

De cette façon, CustomerRepository hérite de méthodes permettant de sauvegarder, supprimer et récupérer des entités Customer. Il est également possible de spécifier nous même les requêtes que nous voulons faire en déclarant les méthodes nécessaires. Ce qui fait que Spring Data JPA est si puissant, c’est que vous n’avez pas besoin d’écrire d’implémentation de l'interface repository. Spring Data JPA crée une implémentation lui même lorsque vous lancez l’application.

Testons notre application ! Créez une classe AccessingDataJpaApplication de ce type : import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.boot.CommandLineRunner;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.context.annotation.Bean;

@SpringBootApplication

public class AccessingDataJpaApplication {

private static final Logger log =

LoggerFactory.getLogger(AccessingDataJpaApplication.class);

public static void main(String[] args) {

SpringApplication.run(AccessingDataJpaApplication.class);

}

@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("");

};

}

}

La classe inclut une méthode main qui permet de tester notre CustomerRepository. D’abord, nous récupérons le CustomerRepository du contexte de l’application Spring. Ensuite nous les sauvegardons des objets Customer en utilisant la méthode save(). On utilise ensuite les méthodes findAll() pour récupérer tous les objets Customer de la base de données. Puis findOne() pour un seul objet Customer grâce à son id. Enfin on démontre l’utilisation de la méthode findByLastName() pour trouver tous les utilisateurs ayant pour nom de famille “Bauer”. source : https://spring.io/guides/gs/accessing-data-jpa/

Architecture typique pour une application Web - Les classes de domaine (@Entity) - Les DAO (@Repository) - Les controllers (@Controller) - Les controllers interagissent avec la couche UI (thymeleaf)

Notion de composants

@Component : Cette annotation est utilisée sur les classes pour indiquer un composant Spring. L'annotation @Component marque la classe Java en tant que bean ou composant afin que le mécanisme d'analyse des composants de Spring puisse l'ajouter au contexte de l'application.

Note : @Service et @Repository sont des cas particuliers de @Component. Ils sont techniquement les mêmes mais nous les utilisons à des fins différentes. Le travail de @Repository consiste à intercepter les exceptions spécifiques à la persistance et à les redéfinir en tant qu’une des exceptions unifiées non contrôlées de Spring. Nous marquons les beans avec @Service pour indiquer qu'il contient la logique métier. Il n’y a donc pas d’autre spécialité que de l’utiliser dans la couche service.

Comment tester les composants ? La première question à se poser pour tester les composants, c’est : Que faut-il tester ? Nous pouvons tester les Spring Data Repository responsables pour les entités. Spring Boot fournit l'annotation @DataJpaTest, pour l’utiliser, il faut juste l’ajouter à notre unité de test et il sera automatiquement mis en place pour le contexte de l’application Spring. Exemple : @ExtendWith(SpringExtension.class)

@DataJpaTest

class UserEntityRepositoryTest {

@Autowired private DataSource dataSource;

@Autowired private JdbcTemplate jdbcTemplate;

@Autowired private EntityManager entityManager;

@Autowired private UserRepository userRepository;

@Test

void injectedComponentsAreNotNull(){

assertThat(dataSource).isNotNull();

assertThat(jdbcTemplate).isNotNull();

assertThat(entityManager).isNotNull();

assertThat(userRepository).isNotNull();

}

}

Internationalisation L’internationalisation en utilisant Spring Data JPA passe par l’utilisation des fichiers message_properties. Spring fournit une aide d'étendre au niveau d'internationalisation (Internationalization) (i18n) grâce à l'utilisation de Spring Interceptor, Locale Resolvers et Resource Bundles pour différents sites régionaux. L'information locale ( Locale) se trouve sur le paramètre de l'URL. Les informations locales seront stockées dans Cookie et l'utilisateur n’a pas besoin de sélectionner de nouveau la langue dans les pages suivantes.

Ici, on crée trois fichiers properties pour les langues,dont l'anglais,le français et le vietnamien. Ces fichiers seront chargés et gérés par messageResource Bean.