In questo post ti ho parlato di entità. Ora, voglio farti vedere un modo semplice per trattare entità attraverso il progetto Lombok.

È possibile avvalersi dell’implementazione di Hibernate fornita da Spring e della proprietà spring.jpa.hibernate.ddl-auto, che creerà una tabella, nell’esempio visto nominata application_user, seguendo la strategia SpringPhysicalNamingStrategy di physical naming strategy. La stessa cosa vale per gli attributi e la loro rappresentazione in tabella.

Puoi trovare questa informazione, e eventualmente modificarla, nella documentazione di Spring Boot qui.

Per quanto detto, possiamo non preoccuparci della rappresentazione su database, dato che Hibernate fa il lavoro per noi.

Nel caso in cui vogliamo esplicitamente definire una rappresentazione dell’entità su database, si può utilizzare le annotazioni @Column, @Table, come nell’esempio seguente:

@Entity 
@Table(name = "application_user") 
public class ApplicationUser { 
    
    private Long id; 
    private String name; 
    private Integer age; 
    
    @Column(name = "age") 
    public Integer getAge() { 
        return age; 
    } 
    
    @Id 
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    @Column(name = "id") 
    public Long getId() { 
        return id; 
    }
    
    @Column(name = "name") 
    public String getName() { 
        return name; 
    } 
    
    ... setter methods 
}
 

Progetto Lombok

Il metodo descritto sopra è efficace e necessario quando vogliamo avere una rappresentazione chiara delle entità da mappare, oppure, nel caso in cui non vogliamo che Hibernate si preoccupi dell’aggiornamento per conto nostro.

Ricordati che per ogni attributo presente nell’entità devono esistere i corrispettivi metodi getter e setter.

Ma cosa succede alla leggibilità della classe se questa è composta da molti attributi?

Una soluzione semplice al problema è data dall’utilizzo della libreria Lombok, il quale semplifica non poco la scrittura della nostra classe Entity.

La chiave è nell’utilizzo dell’annotazione @Data della libreria.

@Entity 
@Data 
public class ApplicationUser { 
    
    @Id 
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private Long id; 
    
    private String name; 
    
    private Integer age; 
}

In questo caso, l’annotazione @Data rappresenta una scorciatoia per @ToString, @EqualsAndHashCode, @Getter su tutti i campi, @Setter su tutti i campi non dichiarati final e @RequiredArgsConstructor.

Bello vero?

Se vuoi conoscere meglio l’annotazione @Data di Lombok Project e scoprire tutte le sue potenzialità, dai un’occhiata alla pagina ufficiale del progetto ;).

Per utilizzare Lombok Project in un progetto Maven basta inserire la sua dipendenza nel file pom.xml.

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.8</version>
</dependency>
 

Chiave primaria composta da più campi

In alcuni casi, si ha la necessità di avere una primary key (pk) composta da più campi.

Nell’esempio, l’entità ApplicationUser ha come pk il campo id di tipo Long, riconosciuta dall’annotazione @Id posizionata subito sopra la dichiarazione dell’attributo o del suo metodo getter.

Per avere una primary key composta da più campi abbiamo 2 possibilità:

  1. utilizzare l’annotazione @IdClass
  2. utilizzare @EmbeddedId, @Embeddable

Se, ad esempio, vogliamo una chiave primaria della stessa entità ApplicationUser composta dagli attributi name e age, dobbiamo, per prima cosa, definire una nuova classe Java costituita da i soli attributi chiave name e age e operare secondo una delle due modalità sopra.

 

Utilizzare @IdClass

@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor
public class ApplicationUserId implements Serializable { 
    
    @Getter 
    @Setter
    private String name; 
    
    @Getter 
    @Setter
    private Integer age;
}
@Entity
@Table(name = "application_user")
@Data
@IdClass(ApplicationUserId.class)
public class ApplicationUser { 
    
    @Id
    @Column(name = "name")
    private String name; 
    
    @Id
    @Column(name = "age")
    private Integer age; 
}
 

Utilizzare @EmbeddedId e @Embeddable

@Embeddable
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor
public class ApplicationUserId implements Serializable { 
    
    @Getter 
    @Setter
    private String name; 
    
    @Getter 
    @Setter
    private Integer age;
}
@Entity
@Table(name = "application_user")
@Data
public class ApplicationUser { 
    
    @EmbeddedId
    private ApplicationUserId applicationUserId;
}
 

Specificare più campi con chiave Unique


@Table(name = "application_user", uniqueConstraints = @UniqueConstraint(columnNames = {"name", "age"}))
...
public class ApplicationUser ...
create table application_user (
    id NUMERIC NOT NULL,
    name VARCHAR,
    age NUMERIC,
    primary key(id),
    UNIQUE KEY unique_key (name, age)
)
ALTER TABLE application_user ADD UNIQUE unique_key (name, age)

No comment yet, add your voice below!


Add a Comment

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *