JPA con Spring Boot

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package org.ieselcaminas.jpa;

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

@SpringBootApplication
public class JpaApplication implements CommandLineRunner {

	public static void main(String[] args) {
		SpringApplication.run(JpaApplication.class, args);
	}
	//En este método definimos nuestro propio código
	@Override
	public void run(String... args) {
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package org.ieselcaminas.jpa.entity;

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

@Entity
public class Customer {

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

  protected Customer() {}
  public Customer(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  public Long getId() {
    return id;
  }
  public String getFirstName() {
    return firstName;
  }
  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }
  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  @Override	
  public String toString() {
      return id + " - " + firstName + " - " + lastName;
  }

}

1
2
3
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  private Long id;

1
2
3
4
5
6
7
8
package org.ieselcaminas.jpa.repository;

import org.ieselcaminas.jpa.entity.Customer;
import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository<Customer, Long> {

}

1
2
3
4
private final CustomerRepository customerRepository;
public JpaApplication(CustomerRepository customerRepository){
    this.customerRepository = customerRepository;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Override
public void run(String... args) {
    Customer c = new Customer("Pepe", "García");
    //El repositorio es donde están todos los métodos que tratan con la base de datos.
    //En este caso está haciendo un INSERT ya que el objecto es nuevo
    this.customerRepository.save(c);
    
    //Pero también puedeo modificar un registro
    c.setFirstName("Juan");
	this.customerRepository.save(c);
    
    //Vamos a seleccionar el Customer con id 1
    //Se escribe 1L porque es un dato escrito a mano de tipo long
    Optional<Customer> clienteOp = this.customerRepository.findById(1L);
    clienteOp.ifPresent(System.out::println);
    
    //Si queremos acceder al objeto Customer
    if (clienteOp.isPresent()){
        c = clienteOp.get();
        System.out.println(c);
    }

    //El método findAll devuelve todos los registros de la entidad asociada
    this.customerRepository.findAll().forEach(System.out::println);

    //En este código estamos guardando los datos en un Iterable que es lo que devuelven los métodos findAll
    Iterable<Customer> l = this.customerRepository.findAll();
    for (Customer customer : l) {
        System.out.println(customer);
    }
    
    //Cuidado que si no existe el registro con ID 5, saltará una excepción
    c = this.customerRepository.findById(5L).get();
	this.customerRepository.delete(c);
}

1
2
public List<Customer> findCustomersByFirstName(String firstName);
public Customer findCustomerByFirstNameAndLastName(String firstName, String lastName)

1
2
@Query("SELECT COUNT(c) FROM Customer c")
public int countAllRecords();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package org.ieselcaminas.jpa;

import jakarta.persistence.*;

@Entity
public class Note {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String text;
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name="id_customer")
    private Customer customer;

    protected Note() {}
    
    public Note(String text, Customer customer) {
        this.text = text;
        this.customer = customer;
    }
    
    public Long getId() {
        return id;
    }
    public String getText() {
        return text;
    }

    public Customer getCustomer() {
        return customer;
    }

    @Override
    public String toString() {
        return text;
    }

}

1
2
3
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name="customer_id")
private Customer customer;

1
2
@OneToMany(mappedBy = "customer",  fetch=FetchType.EAGER)
private List<Note> notes = new ArrayList<>;

1
2
3
4
5
6
7
public List<Note> getNotes(){
    return this.notes;
}

public void addNote(Note note){
    this.notes.add(note);
}

1
2
3
4
5
6
7
8
9
10
11
package org.ieselcaminas.jpa.repository;

import org.ieselcaminas.jpa.entity.Note;
import org.springframework.data.repository.CrudRepository;

import java.util.List;

public interface NoteRepository extends CrudRepository<Note, Long> {


}

1
2
3
4
5
private final NoteRepository noteRepository;
public JpaApplication(CustomerRepository customerRepository, NoteRepository noteRepository){
	this.customerRepository = customerRepository;
	this.noteRepository = noteRepository;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Override
public void run(String... args) {
    //Creamos una nota
    // 1º el cliente
    Customer c = customerRepository.findById(1L).get();
    //Y ahora la nota
    Note n = new Note("Primera nota", c);
    noteRepository.save(n);

    Customer c2 = customerRepository.findById(2L).get();
    n = new Note("Primera nota María", c2);
    noteRepository.save(n);

    customerRepository.findCustomersByFirstName("Pepe").forEach(System.out::println);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package org.ieselcaminas.jpa.controller;

import org.ieselcaminas.jpa.entity.Customer;
import org.ieselcaminas.jpa.repository.CustomerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Scanner;

@Component
public class CustomerController {

    private final CustomerRepository customerRepository;
    public CustomerController(CustomerRepository customerRepository){
        this.customerRepository = customerRepository;

    }
    public Customer createCustomer(){
        String firstName, lastName;
        Customer c;
        Scanner sc = new Scanner(System.in);

        System.out.println("Enter customer's first name:");
        firstName = sc.nextLine();
        System.out.println("Enter customer's last name:");
        lastName = sc.nextLine();
        c =  new Customer(firstName, lastName);
        customerRepository.save(c);

        return c;

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
......
private final CustomerController customerController;
public JpaApplication(CustomerRepository customerRepository,
                      NoteRepository noteRepository, CustomerController customerController){
    this.customerRepository = customerRepository;
    this.noteRepository = noteRepository;
    this.customerController = customerController;
}
.....
@Override
public void run(String... args) {
    this.customerController.createCustomer();
    this.customerRepository.findAll().forEach(System.out::println);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package jpa;

import jakarta.persistence.*;

@Entity
// Se le puede indicar que el nombre de la tabla no es "cliente", nombre por defecto que es // igual al nombre la entidad (Cliente), sino "clientes"
@Table(name = "clientes")
public class Cliente {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String nombre;

    // Siempre un constructor por defecto
    public Cliente() {
    }
    public Cliente(String nombre) {
        this.nombre = nombre;
    }

    // Getters y Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    @Override
    public String toString(){
        return this.nombre;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package jpa;

import jakarta.persistence.*;
import jpa.Cliente;

@Entity
// Se le puede indicar que el nombre de la tabla no es "cuenta_corriente", nombre por 
// defecto que es igual al nombre la entidad (CuentaCorriente), sino "cuentas_corrientes"
@Table(name = "cuentas_corrientes")
public class CuentaCorriente {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String nombre;

    @Column(nullable = false)
    private double cantidad;

    //Siempre debe tener un constructor vacío
    public CuentaCorriente() {
    }

    //Se pueden hacer tantos constructores como deseemos
    public CuentaCorriente(String nombre) {
        this.nombre = nombre;
    }

    // Getters y Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public double getCantidad() {
        return cantidad;
    }

    public void setCantidad(double cantidad) {
        this.cantidad = cantidad;
    }

    // Otros setters
    public void ingresar(double cantidad){
        if (cantidad > 0 )
            this.cantidad += cantidad;
    }

    public void retirar(double cantidad){
        if (cantidad > 0 )
            this.cantidad -= cantidad;
    }

    @Override
    public String toString(){
        return this.nombre + " - " + this.cantidad;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
    /**
     * IMPORTANTE fetch = FetchType.EAGER. En caso contrario es FetchType.LAZY y da 
     * error porque no se inicializa la lista de cuentas
     */
    @ManyToMany(fetch = FetchType.EAGER)
    /*
       En este caso le decimos:
       - que la tabla se llama cliente_cuenta
       - que mi columna id se llama en esa tabla cliente_id
       - que la columna de la cuenta se llama cuenta_id en dicha tabla
     */
    @JoinTable(
            name = "cliente_cuenta",
            joinColumns = @JoinColumn(name = "cliente_id"),
            inverseJoinColumns = @JoinColumn(name = "cuenta_id")

    )
    // Inicializar siempre el Set
    private Set<CuentaCorriente> cuentas = new HashSet<>();

	// Demás código ....

    public Set<CuentaCorriente> getCuentas() {
        return this.cuentas;
    }

    public void setCuentas(Set<CuentaCorriente> cuentas) {
        this.cuentas = cuentas;
    }

    // Se puede crear un método para añadir la entidad relacionada a la lista.
    // En otro caso, habría que usar cliente.getCuentas().add(cuenta)
    public void addCuenta(CuentaCorriente cuenta) {
        this.cuentas.add(cuenta);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    //Le decimos que, en la entidad Cliente, las cuentas se almacenan en el atributo con nombre cuentas
    @ManyToMany(mappedBy = "cuentas", fetch = FetchType.EAGER)
    //Hay que inicializar la lista siempre
    private Set<Cliente> clientes = new HashSet<>();

	// Demás código ....

    public Set<Cliente> getClientes() {
        return this.clientes;
    }

    public void setClientes(Set<Cliente> clientes) {
        this.clientes = clientes;
    }

    // Se puede crear un método para añadir la entidad relacionada a la lista.
    // En otro caso, habría que usar cuenta.getClientes().add(cliente)
    public void addCliente(Cliente cliente){
        this.clientes.add(cliente);
    }

1
2
3
4
5
package jpa;

import org.springframework.data.jpa.repository.JpaRepository;

interface ClienteRepository extends JpaRepository<Cliente, Long> {}

1
2
3
4
5
package jpa;

import org.springframework.data.jpa.repository.JpaRepository;

interface CuentaCorrienteRepository extends JpaRepository<CuentaCorriente, Long> {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package jpa;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Se pueden hacer tantos servicios como deseemos, pero siempre hemos de crear métodos relacionados
 * en ellos.
 */
@Service
class ClienteService {
    /*
    La anotación @Autowired indica a Spring que nos "auto inyecte" esta clase, en este caso ClienteRepository y
    CuentaCorrienteRepository.
    De esta forma ya no es necesario inyectarlas en el constructor
     */
    @Autowired
    private ClienteRepository clienteRepository;
    
    @Autowired
    private CuentaCorrienteRepository cuentaCorrienteRepository;

    public void crearClienteConCuenta(String nombreCliente, String nombreCuenta) {
        Cliente cliente = new Cliente(nombreCliente);
        CuentaCorriente cuenta = new CuentaCorriente();
        cuenta.setNombre(nombreCuenta);
        
        cliente.getCuentas().add(cuenta);
        cuenta.getClientes().add(cliente);
        
        cuentaCorrienteRepository.save(cuenta);
        clienteRepository.save(cliente);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package jpa;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class JpaApplication implements CommandLineRunner {
    private final ClienteService clienteService;
    public JpaApplication(ClienteService clienteService) {
        this.clienteService = clienteService;
    }

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

    //En este método definimos nuestro propio código
    @Override
    public void run(String... args) {
        this.clienteService.crearClienteConCuenta("Mengano", "Cmengano");        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void crearCuentaConClientes(String nombreCuenta) {
    CuentaCorriente cuenta = new CuentaCorriente();
    cuenta.setNombre(nombreCuenta);
    cuenta.setCantidad(100);

    Cliente cliente1 = new Cliente("Cliente 1");
    Cliente cliente2 = new Cliente("Cliente 2");

    cliente1.getCuentas().add(cuenta); // o cliente1.addCuenta(cuenta);
    cuenta.getClientes().add(cliente1); // o cuenta.addCliente(cliente);

    cliente2.getCuentas().add(cuenta);
    cuenta.getClientes().add(cliente2);

    this.cuentaCorrienteRepository.save(cuenta);
    this.clienteRepository.save(cliente1);
    this.clienteRepository.save(cliente2);
}

1
2
3
4
@Override
public void run(String... args) { 
    this.clienteService.crearCuentaConClientes("CuentaConMásDeUnCliente");
}