Operações CRUD
Depois de mapear uma classe para uma tabela de banco de dados e estabelecer sua chave primária, você tem tudo o que precisa para criar, recuperar, excluir e atualizar essa classe no banco de dados. Chamando entityManager.save() Criará ou atualizará a classe especificada, dependendo se o campo da chave primária é nula ou se aplicar a uma entidade existente. Chamando entityManager.remove() excluirá a classe especificada.
Relacionamentos de entidade
Simplesmente persistir em um objeto com um campo primitivo é apenas metade da equação. JPA também permite que você gerencie entidades em relação um para o outro. Quatro tipos de relacionamentos de entidade são possíveis em tabelas e objetos:
- Um para muitos
- Muitos para um
- Muitos para muitos
- Um para um
Cada tipo de relacionamento descreve como uma entidade se relaciona com outras entidades. Por exemplo, o Musician entidade poderia ter um relacionamento um para muitos com Performanceuma entidade representada por uma coleção como List ou Set.
Se o Musician incluído a Band campo, a relação entre essas entidades pode ser muitos para umimplicando uma coleção de Musicianestá no single Band aula. (Supondo que cada músico se apresente apenas em uma única banda.)
Se Musician incluído a BandMates campo, isso poderia representar um Relacionamento muitos para muitos com outro Musician entidades. (Nesse caso, as linhas/objetos de músicos são auto-referenciação, outro padrão comum.)
Finalmente, Musician pode ter um relacionamento individual com um Quote entidade, usada para representar uma citação famosa: Quote famousQuote = new Quote().
Definindo tipos de relacionamento
A JPA possui anotações para cada um de seus tipos de mapeamento de relacionamento. O código a seguir mostra como você pode anotar o relacionamento um para muitos entre Musician e Performances. Nesse caso, cada músico pode ter muitas performances, mas há apenas um músico para cada apresentação:
// Performance.java
@Entity
public class Performance {
@Id
@GeneratedValue
private Long id;
private String title; // e.g., "Live at Abbey Road"
// Many Performances belong to one Musician
// @JoinColumn specifies the foreign key column in the 'Performance' table
@ManyToOne
@JoinColumn(name = "musician_id") // This will be the FK column in the 'performance' table
private Musician musician;
// constructor and members...
}
public class Musician {
@OneToMany(mappedBy = "musician")
private List performances = new ArrayList();
//...
}
Observe que o @JoinColumn diz a Jpa que coluna no Performance A tabela mapeará para o Musician entidade. Cada Performance estará associado a um único Musicianque é rastreado por esta coluna. Quando o JPA carrega um Musician ou Performance Objeto no banco de dados, ele usará essas informações para reconstituir o gráfico do objeto.
Para Musiciano @OneToMany(mappedBy = 'musician') Anotação diz ao JPA para usar o Performance.musician campo para preencher as performances List no Musician objeto. (Isto é, o Performance.musician pontos de campo do Performance Tabela para o Musician mesa.)
Quando JPA carrega a chave estrangeira de Performancevai preencher o real Musician objeto encontrado nessa chave primária no Musician mesa e o vivo List de performances hidratadas pelas performances que mantêm essas chaves estrangeiras. Como resultado, as performances são carregadas com uma referência ao Musician objetos, e esses objetos são carregados segurando ListS das performances.
Há mais que podemos fazer para ajustar como esses relacionamentos funcionam. No momento, estamos apenas tocando no básico.
Veja também: Persistência de Java com JPA e Hibernate: Entidades e Relacionamentos.
Estratégias de busca de JPA
Além de saber onde Para colocar entidades relacionadas no banco de dados, a JPA precisa saber como você quer que eles sejam carregados. As estratégias de busca dizem à JPA como carregar entidades relacionadas. Ao carregar e salvar objetos, uma estrutura JPA deve fornecer a capacidade de definir como os gráficos de objetos são tratados. Por exemplo, se o Musician A classe tem um bandMate campo, carregamento GeorgeHarrison poderia causar o inteiro Musician Tabela a ser carregada no banco de dados!
Você pode usar anotações para personalizar suas estratégias de busca, mas a configuração padrão da JPA geralmente funciona fora da caixa:
- Um para muitos: preguiçoso
- Muitos para um: ansioso
- Muitos para muitos: preguiçosos
- Um para um: ansioso
Transações em JPA
Enquanto fora do escopo desta introdução, transações Permita que o desenvolvedor defina limites para grupos de operações no banco de dados. Podemos definir várias operações juntos e depois executá -las junto com entityManager.getTransaction().commit(). Se alguma das operações relacionadas falhar, toda a transação será revertida. Este é outro componente essencial do design de dados.
As transações podem ser definidas de várias maneiras, desde interações explícitas via API, até o uso de anotações para definir limites transacionais, até o uso da Spring AOP para definir os limites.
Instalação e configuração JPA
Concluiremos com uma rápida olhada na instalação e configuração de JPA para seus aplicativos Java. Para esta demonstração, usaremos o Eclipselink, a implementação de referência da JPA.
A maneira comum de instalar o JPA é incluir um provedor JPA em seu projeto:
org.eclipse.persistence
eclipselink
4.0.7
Também precisamos incluir um driver de banco de dados:
mysql
mysql-connector-java
8.0.33
Então, precisamos contar ao sistema sobre nosso banco de dados e provedor, o que fazemos em um persistence.xml arquivo:
http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
Existem outras maneiras de fornecer essas informações ao sistema, inclusive programaticamente. Eu recomendo usar o persistence.xml Arquive porque armazenar dependências dessa maneira facilita a atualização do seu aplicativo sem modificar nenhum código.
Configuração da primavera para JPA
O uso do Spring Data JPA facilitará bastante a integração do JPA em seu aplicativo. Como exemplo, colocando o @SpringBootApplication A anotação em seu cabeçalho de aplicativo instrui a Spring para digitalizar automaticamente as aulas e injetar o EntityManager conforme necessário, com base na configuração que você especificou.
Inclua as seguintes dependências em sua construção, se você quiser o suporte JPA da Spring para o seu aplicativo:
org.springframework.boot
spring-boot-starter-test
3.5.3
test
org.springframework.boot
spring-boot-starter-data-jpa
3.5.3
Quando usar o JPA
A questão de usar o JPA é uma fonte comum de paralisia de análise ao projetar um aplicativo Java. Especialmente ao tentar tomar decisões tecnológicas anteriores, você não deseja obter persistência de dados-um fator essencial e de longo prazo-.
Para quebrar esse tipo de paralisia, é útil lembrar que os aplicativos podem evoluir para o uso do JPA. Você pode criar código exploratório ou protótipo usando o JDBC e começar a adicionar JPA. Não há razão para que essas soluções não possam coexistir.
Depois de ficar paralisado pela indecisão, a próxima pior coisa é adotar o JPA quando o esforço adicional que ela implica impedirá que um projeto avance. O JPA pode ser uma vitória para a estabilidade e manutenção geral do sistema, mas às vezes mais simples é melhor, especialmente no início de um projeto. Se sua equipe não tiver a capacidade de adotar o JPA antecipadamente, considere colocá -lo em seu roteiro para o futuro.
Conclusão
Todo aplicativo que interface com um banco de dados deve definir uma camada de aplicativo cujo único objetivo é isolar o código de persistência. Como você viu neste artigo, a API de persistência de Jacarta (JPA) apresenta uma série de capacidades e apoio à persistência do objeto Java. Aplicações simples podem não exigir todas as capacidades JPA e, em alguns casos, a sobrecarga de configurar a estrutura pode não ser merecida. À medida que um aplicativo cresce, no entanto, a JPA realmente ganha sua fortaleza. O uso do JPA mantém o código do seu objeto simples e fornece uma estrutura convencional para acessar dados em aplicativos Java.
