spring-boot
Spring boot + Spring Data JPA

Introducción

Observaciones

Ejemplo básico de integración de Spring Boot y Spring Data JPA

Vamos a construir una aplicación que almacene POJOs en una base de datos. La aplicación utiliza Spring Data JPA para almacenar y recuperar datos en una base de datos relacional. Su característica más atractiva es la capacidad de crear implementaciones de repositorio automáticamente, en tiempo de ejecución, desde una interfaz de repositorio.

Clase principal

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);
    }
}

El método main() utiliza el método SpringApplication.run() Spring Boot para iniciar una aplicación. Tenga en cuenta que no hay una sola línea de XML. Ningún archivo web.xml tampoco. Esta aplicación web es 100% pura de Java y no tiene que lidiar con la configuración de tuberías o infraestructura.

Clase de entidad

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. */
}

Aquí tienes una clase de Greeting con dos atributos, el id y el text . También tienes dos constructores. El constructor predeterminado solo existe por el bien de JPA. No lo usarás directamente, por lo que puede ser designado como protected . El otro constructor es el que usarás para crear instancias de Greeting que se guardarán en la base de datos.

La clase de Greeting está anotada con @Entity , lo que indica que es una entidad JPA. Por falta de una anotación de @Table , se supone que esta entidad se asignará a una tabla llamada "Saludo".

La propiedad id del saludo se anota con @Id para que JPA la reconozca como el ID del objeto. La propiedad id también se anota con @GeneratedValue para indicar que la ID debe generarse automáticamente.

La otra propiedad, el text se deja sin anotar. Se supone que se asignará a una columna que comparte el mismo nombre que la propiedad en sí.

Propiedades transitorias

En una clase de entidad similar a la anterior, podemos tener propiedades que no queremos que se conserven en la base de datos o se creen como columnas en nuestra base de datos, tal vez porque solo queremos establecerlas en el tiempo de ejecución y usarlas en nuestra aplicación. por lo tanto, podemos tener esa propiedad anotada con la anotación @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. */
}

Aquí tiene la misma clase de saludo que ahora tiene una propiedad transitoria textInSomeLanguage que puede inicializarse y usarse en tiempo de ejecución y no se conservará en la base de datos.

Clase 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 extiende la interfaz de CrudRepository . El tipo de entidad y la ID con la que trabaja, Greeting y Long , se especifican en los parámetros genéricos en CrudRepository . Al extender CrudRepository , GreetingRepository hereda varios métodos para trabajar con la persistencia del Greeting , incluidos los métodos para guardar, eliminar y encontrar entidades de Greeting .
Consulte esta discusión para comparar CrudRepository , PagingAndSortingRepository , JpaRepository .

Spring Data JPA también le permite definir otros métodos de consulta simplemente declarando su firma de método. En el caso de GreetingRepository , esto se muestra con un método findByText() .

En una aplicación Java típica, esperarías escribir una clase que implemente GreetingRepository . Pero eso es lo que hace que Spring Data JPA sea tan poderoso: no tiene que escribir una implementación de la interfaz del repositorio. Spring Data JPA crea una implementación sobre la marcha cuando ejecuta la aplicación.

Clase de servicio

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);

}

Servicio de frijol

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);
    }

}

Clase de controlador

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);
    }

}

Archivo de propiedades de la aplicación para la base de datos 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

Archivo SQL

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

archivo 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>

Construyendo un JAR ejecutable

Puede ejecutar la aplicación desde la línea de comandos con Maven. O puede crear un solo archivo JAR ejecutable que contenga todas las dependencias, clases y recursos necesarios y ejecutarlo. Esto facilita el envío, la versión y la implementación del servicio como una aplicación a lo largo del ciclo de vida del desarrollo, en diferentes entornos, etc.

Ejecute la aplicación utilizando ./mvnw spring-boot:run . O puede construir el archivo JAR con ./mvnw clean package . Luego puedes ejecutar el archivo JAR:

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