spring-boot
Botte de printemps + Spring Data JPA

Introduction

Remarques

Exemple de base de l'intégration Spring Spring et Spring Data JPA

Nous allons créer une application qui stocke les POJO dans une base de données. L'application utilise Spring Data JPA pour stocker et récupérer des données dans une base de données relationnelle. Sa fonction la plus convaincante est la possibilité de créer automatiquement des implémentations de référentiel, à l'exécution, à partir d'une interface de référentiel.

Classe principale

package org.springboot;

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

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

La méthode main() utilise la méthode SpringApplication.run() Spring Boot pour lancer une application. Veuillez noter qu'il n'y a pas une seule ligne de XML. Pas de fichier web.xml non plus. Cette application Web est 100% Java pur et vous n'avez pas à gérer la configuration de la plomberie ou de l'infrastructure.

Classe d'entité

package org.springboot.model;

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

@Entity
public class Greeting {

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

    public Greeting() {
        super();
    }

    public Greeting(String text) {
        super();
        this.text = text;
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

Ici vous avez une classe Greeting avec deux attributs, l' id et le text . Vous avez également deux constructeurs. Le constructeur par défaut n'existe que pour JPA. Vous ne l’utiliserez pas directement, il peut donc être désigné comme protected . L'autre constructeur est celui que vous utiliserez pour créer des instances de Greeting d' Greeting à enregistrer dans la base de données.

La classe de @Entity Greeting est annotée avec @Entity , indiquant qu'il s'agit d'une entité JPA. En l'absence d'une annotation @Table , il est supposé que cette entité sera mappée sur une table nommée 'Greeting'.

La propriété id @Id d' @Id est annotée avec @Id afin que JPA le reconnaisse comme identifiant de l'objet. La propriété id est également annotée avec @GeneratedValue pour indiquer que l'ID doit être généré automatiquement.

L'autre propriété, text est laissée non annotée. Il est supposé qu'il sera mappé à une colonne qui partage le même nom que la propriété elle-même.

Propriétés transitoires

Dans une classe d'entité similaire à celle ci-dessus, nous pouvons avoir des propriétés que nous ne voulons pas conserver dans la base de données ou des colonnes dans notre base de données, peut-être parce que nous voulons simplement les définir à l'exécution et les utiliser dans notre application. nous pouvons donc avoir cette propriété annotée avec l'annotation @Transient.

package org.springboot.model;

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

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;
    @Transient
    private String textInSomeLanguage;
    
    public Greeting() {
        super();
    }
 
    public Greeting(String text) {
        super();
        this.text = text;
        this.textInSomeLanguage = getTextTranslationInSpecifiedLanguage(text);
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

Vous avez ici la même classe de textInSomeLanguage accueil qui a maintenant une propriété transitoire textInSomeLanguage qui peut être initialisée et utilisée à l'exécution et ne sera pas conservée dans la base de données.

Classe DAO

package org.springboot.repository;

import org.springboot.model.Greeting;
import org.springframework.data.repository.CrudRepository;

public interface GreetingRepository extends CrudRepository<Greeting, Long> {

    List<Greeting> findByText(String text);
}

GreetingRepository étend l'interface CrudRepository . Le type d'entité et l'ID avec lesquels il fonctionne, Greeting et Long , sont spécifiés dans les paramètres génériques de CrudRepository . En étendant CrudRepository , GreetingRepository hérite de plusieurs méthodes pour utiliser la persistance Greeting , y compris des méthodes pour enregistrer, supprimer et rechercher des entités de CrudRepository Greeting .
Voir cette discussion pour la comparaison de CrudRepository , PagingAndSortingRepository , JpaRepository .

Spring Data JPA permet également de définir d'autres méthodes de requête en déclarant simplement leur signature de méthode. Dans le cas de GreetingRepository , cela est montré avec une méthode findByText() .

Dans une application Java typique, vous vous attendez à écrire une classe qui implémente GreetingRepository . Mais c'est ce qui fait la puissance de Spring Data JPA: vous n'avez pas besoin d'écrire une implémentation de l'interface du référentiel. Spring Data JPA crée une implémentation à la volée lorsque vous exécutez l'application.

Classe de service

package org.springboot.service;

import java.util.Collection
import org.springboot.model.Greeting;

public interface GreetingService {

    Collection<Greeting> findAll();
    Greeting findOne(Long id);
    Greeting create(Greeting greeting);
    Greeting update(Greeting greeting);
    void delete(Long id);

}

Service Bean

package org.springboot.service;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.repository.GreetingRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class GreetingServiceBean implements GreetingService {

    @Autowired
    private GreetingRepository greetingRepository;

    @Override
    public Collection<Greeting> findAll() {
        Collection<Greeting> greetings = greetingRepository.findAll();
        return greetings;
    }

    @Override
    public Greeting findOne(Long id) {
        Greeting greeting = greetingRepository.findOne(id);
        return greeting;
    }

    @Override
    public Greeting create(Greeting greeting) {
        if (greeting.getId() != null) {
            //cannot create Greeting with specified Id value
            return null;
        }
        Greeting savedGreeting = greetingRepository.save(greeting);
        return savedGreeting;
    }

    @Override
    public Greeting update(Greeting greeting) {
        Greeting greetingPersisted = findOne(greeting.getId());
        if (greetingPersisted == null) {
            //cannot find Greeting with specified Id value
            return null;
        }
        Greeting updatedGreeting = greetingRepository.save(greeting);
        return updatedGreeting;
    }

    @Override
    public void delete(Long id) {
         greetingRepository.delete(id);
    }

}

Classe de contrôleur

package org.springboot.web.api;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/api")
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    // GET [method = RequestMethod.GET] is a default method for any request. 
    // So we do not need to mention explicitly

    @RequestMapping(value = "/greetings", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Collection<Greeting>> getGreetings() {
        Collection<Greeting> greetings = greetingService.findAll();        
        return new ResponseEntity<Collection<Greeting>>(greetings, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> getGreeting(@PathVariable("id") Long id) {
        Greeting greeting = greetingService.findOne(id);
        if(greeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Greeting>(greeting, HttpStatus.OK);
    }
    
    @RequestMapping(value = "/greetings", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> createGreeting(@RequestBody Greeting greeting) {
        Greeting savedGreeting = greetingService.create(greeting);
        return new ResponseEntity<Greeting>(savedGreeting, HttpStatus.CREATED);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> updateGreeting(@PathVariable("id") Long id, @RequestBody Greeting greeting) {
        Greeting updatedGreeting = null;
        if (greeting != null && id == greeting.getId()) {
            updatedGreeting = greetingService.update(greeting); 
        }
        if(updatedGreeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity<Greeting>(updatedGreeting, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<Greeting> deleteGreeting(@PathVariable("id") Long id) {
        greetingService.delete(id);
        return new ResponseEntity<Greeting>(HttpStatus.NO_CONTENT);
    }

}

Fichier de propriétés d'application pour la base de données MySQL

#mysql config
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=Welcome@123
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto = update

spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.DefaultNamingStrategy

#initialization
spring.datasource.schema=classpath:/data/schema.sql

Fichier SQL

drop table if exists greeting;
create table greeting (
    id bigint not null auto_increment, 
    text varchar(100) not null, 
    primary key(id)
);

fichier pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>org</groupId>
<artifactId>springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.1.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Construire un fichier JAR exécutable

Vous pouvez exécuter l'application à partir de la ligne de commande avec Maven. Vous pouvez également créer un seul fichier JAR exécutable contenant toutes les dépendances, classes et ressources nécessaires et l'exécuter. Cela facilite l'envoi, la version et le déploiement du service en tant qu'application tout au long du cycle de développement, dans différents environnements, etc.

Exécutez l'application en utilisant ./mvnw spring-boot:run . Ou vous pouvez créer le fichier JAR avec le ./mvnw clean package . Ensuite, vous pouvez exécuter le fichier JAR:

java -jar target/springboot-0.0.1-SNAPSHOT.jar