Spring Data [Introdução ao Spring Data, Spring Data JPA, Spring Data JDB] (1) - Explicação abrangente e detalhada (resumo do aprendizado --- da entrada ao aprofundamento)

Índice

1. Introdução aos dados do Spring

O Spring Data é um subprojeto do Spring, que visa unificar e simplificar vários tipos de armazenamento e acesso persistente.

O Spring Data fornece muitos módulos para suportar várias operações de banco de dados. Como Spring Data JPA, Spring Data JDBC, Spring Data Redis, Spring Data MongoDB, Spring Data Elasticsearch, Spring Data Solr, etc. A seguir, explicaremos o uso desses módulos, respectivamente.

Nota: Todos os projetos neste conjunto de cursos são construídos com base no ambiente SpringBoot e os alunos precisam ter uma certa compreensão do conhecimento do SpringBoot.

2. Spring Data JPA

1. Conceito

O Spring Data JPA é um conjunto de frameworks de aplicação JPA encapsulados pelo Spring baseado na especificação JPA, possuindo mais métodos de operação que o JPA.

2. Revisão JPA

JPA é uma estrutura ORM (Mapeamento Relacional de Objeto) fornecida por JAVA. As estruturas ORM que aprendemos antes incluem Mybaits e assim por diante. JPA é um conjunto de interfaces padronizadas e não fornece implementação, que é implementada por provedores de estrutura terceirizados. As principais implementações do JPA incluem Hibernate, EclipseLink e OpenJPA. Os desenvolvedores só precisam usar o JPA da maneira definida na especificação. Não importa qual implementação seja usada, o método de desenvolvimento é o mesmo.

A maneira do JPA operar o banco de dados inclui o uso do método que vem com o EntityManage, o uso do JPQL e assim por diante. A consulta multitabela do JPA é diferente do Mybatis.Mybatis é orientado a SQL para consulta multitabela, enquanto o JPA configura relacionamentos de objetos por meio de anotações como @OneToMany e @ManyToMany para concluir a consulta multitabela.

3. Construção do projeto Spring Data JPA

1. Crie um projeto SpringBoot

2. Introduza a dependência Spring Data JPA

<dependencies>
   <!-- springData JPA 的起步依赖 -->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>
  <!-- MySQL 连接驱动 -->
   <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
   </dependency>
 <!--jdk9 需要导入如下坐标-->
  <dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
  </dependency>
</dependencies>

3. Configuração do arquivo de configuração Spring Data JPA

spring:
  # 配置数据源
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///数据库名?serverTimezone=GMT%2b8
    username: root
    password: root
    # 配置 spring data jpa
 jpa:
    database: MySQL
    show-sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: update
      naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
      # 解决属性使用驼峰命名法无法与数据库字段向匹配
      naming:
         physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

4. Crie uma classe de entidade: o método de escrita da classe de entidade é o mesmo do JPA.

5. Crie uma interface Repository, que precisa herdar as duas interfaces a seguir:

JpaRepository: Esta interface fornece operações CRUD básicas

JpaSpecificationExecutor: Esta interface fornece operações de consulta complexas

6. Teste, métodos comuns de repositório:

salvar: adicionar/modificar. Se a chave primária existe, ela é modificada, caso contrário, é adicionada.

excluir: excluir

findOne: consulta por id

findAll: consulta tudo

4 Princípios do Spring Data JPA

1. SpringDataJPA gera o objeto proxy da interface através do método invoke da classe JdkDynamicAopProxy, e o objeto é do tipo SimpleJpaRepository.

2. O objeto SimpleJpaRepository é um objeto que realmente implementa a interface de JpaRepository e JpaSpecificationExecutor e chama o método do objeto EntityManage do JPA quando ele é implementado.

3. O método JPA é implementado pelo Hibernate e, quando implementado, o Hibernate chama o JDBC subjacente para implementar as operações do banco de dados.

5 Método de consulta Spring Data JPA

5.1 Use o método query que vem com a interface JpaRepository

count: consulta o número total de registros

existsById: verifica se o registro existe

getOne/findById: consulta por id

findById: carrega imediatamente

getOne: Lazy loading, suporte a transação @Transcational precisa ser adicionado ao método de teste

5.2 Consultando com JPQL

Defina o método na interface do Repositório, adicione @Query("JPQL") ao método

JPQL usa o índice de parâmetro como um espaço reservado e o índice de parâmetro começa em 1

Ao usar JPQL com adições, exclusões e modificações, você precisa adicionar @Modifying ao método de interface

Observação: ao testar o método JPQL de adição, exclusão e modificação, você precisa adicionar o suporte de transação @Transactional ao método de teste e desativar a reversão automática @Rollback(false)

5.3 Consulta usando SQL nativo

Defina o método na interface dao, adicione @Query(value="SQL", nativeQuery=true) ao método

O uso restante é o mesmo que JPQL.

5.4 Consulta de acordo com o método de nomeação de regras

Basta nomear o método na interface dao de acordo com as regras do SpringDataJPA e o método pode concluir a consulta.

Regra: O método de consulta começa com findBy e, quando as condições de consulta estão envolvidas, os atributos das condições são conectados com palavras-chave de condição.

5.5 Consulta usando o método fornecido por JpaSpecificationExecutor

Método: findAll() O significado dos parâmetros do método:

 Especificação: objeto de condição de consulta

 Paginável: objeto de condição de paginação

 Classificar: objeto de condição de classificação

5.5.1 Especificação

A especificação é uma interface.Ao implementar essa interface e reescrever o método toPredicate, um objeto de condição de consulta pode ser construído.

toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb)

O objeto raiz pode obter o objeto de atributo de consulta Objeto Path

O objeto cb pode construir o objeto Path como um objeto de condição de consulta

5.5.2 Paginavel

Pageable é uma interface que possui uma classe de implementação PageRequest, que contém parâmetros de paginação. O objeto PageRequest pode ser obtido por meio do método PageRequest.of(pageNum, pageSize) e o objeto PageRequest pode ser obtido passando o objeto PageRequest para o método de consulta como um parâmetro para obter o objeto Page.

5.5.3 Classificar

Sort é uma classe, criar um objeto Sort pode criar uma condição de classificação e passar o objeto Sort como um parâmetro para o método de consulta classificará os resultados.

6 Domain Driven Design (DDD)

O Spring Data JPA está mais alinhado com o padrão de design de projeto de design orientado a domínio (DDD).

Anteriormente, usamos design orientado a dados ao criar o projeto. Por exemplo, agora temos uma classe de pedido (Order) e uma classe de detalhes do pedido (OrderItem). Existe uma relação um-para-muitos entre pedidos e detalhes do pedido, ou seja, um pedido pode comprar muitos produtos, e cada produto corresponde a um detalhe. O desenho é o seguinte:

public class Order {
    private Long id;
    private Date orderTime; //下单时间
    // ...省略属性
}

public class OrderItem {
    private Long id;
    private Long productId; // 产品 Id
    // ...省略属性
}

Em seguida, escrevemos a classe OrderDao e a classe OrderItemDao para serem responsáveis pela operação do banco de dados.

Se adicionarmos um novo pedido, precisamos chamar o método save de OrderDao e OrderItemDao respectivamente para salvar os registros de Order e OrderItem na tabela do banco de dados. Este é o design dos dados, sempre considere quais dados estão armazenados no banco de dados. Mas se o negócio for muito complexo, o design orientado a dados enfrentará o problema de manutenção complicada. Os programadores precisam entender outros códigos Dao ao operar os dados do pedido, o que é um desperdício de energia.

O modelo orientado a domínio é projetar um negócio inteiro como um domínio, como um novo pedido de negócios. O negócio requer dois tipos de objetos, Order e OrderItem, que chamamos de agregação. As operações na agregação são todas feitas por meio da raiz da agregação. Podemos operar todos os objetos na agregação operando Order, então Order é a raiz da agregação nessa agregação. código mostra como abaixo:

@Entity
@Table(name = "bz_order")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String mobile; //下单手机
    @OneToMany(cascade = CascadeType.PERSIST)
    @JoinColumn(name = "order_id", referencedColumnName = "id")
    private List<OrderItem> orderItemList = new ArrayList();
    // 省略其他属性和 getter/setter
}

@Entity
@Table(name = "bz_orderItem")
public class OrderItem {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        private Long productId; // 产品 Id
        @ManyToOne
        @JoinColumn(name = "order_id",referencedColumnName = "id")
        private Order order;
        // 省略其他属性和 getter/setter
}

Precisamos apenas preparar a classe Repository da raiz agregada

public interface OrderRepository extends JpaRepository<Order, Long>, JpaSpecificationExecutor<Order> {}

Use o Repositório da raiz agregada para concluir a operação de todo o agregado

Order order = new Order();
order.setMobile("13888888888");
OrderItem orderItem1 = new OrderItem();
OrderItem orderItem2 = new OrderItem();
orderItem1.setProductId(1001L);
orderItem2.setProductId(1002L);
order.getOrderItemList().add(orderItem1);
order.getOrderItemList().add(orderItem2);
orderRepository.save(order);

3. Spring Data JDB

1. Conceito

O Spring Data JDBC é um submódulo do Spring Data, semelhante ao Spring Data JPA, porém mais leve e simples. O Spring Data JDBC não fornece recursos JPA, como cache, carregamento lento, etc., o que torna o Spring Data JDBC uma estrutura ORM mais simples, limitada e flexível. E o Spring Data JDBC suporta a integração do Mybatis.

2. Construção do projeto Spring Data JDBC

2.1. Crie um projeto SpringBoot

2.2. Apresentando as dependências Spring Data JDBC

<dependencies>
   <!-- springData JDBC 的起步依赖 -->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jdbc</artifactId>
   </dependency>
   <!-- MySQL 连接驱动 -->
   <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
   </dependency>
</dependencies>

3. Escreva o arquivo de configuração

spring:
    # 配置数据源
    datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///数据库名?serverTimezone=GMT%2b8
    username: root
    password: root

4. Criar classes de entidade: As classes de entidade são gravadas de maneira semelhante ao Spring Data JPA, mas anotações como @Entity e @GeneratedValue não podem ser usadas.

5. Crie uma interface Repository, que precisa herdar as duas interfaces a seguir:

CrudRepository: Esta interface fornece operações CRUD básicas

PagingAndSortingRepository: esta interface fornece consultas de classificação de paginação

6. Teste os métodos da interface Repository

3 Método de consulta Spring Data JDBC

3.1 Utilizar o método query da interface Repository

 Consulta usando métodos herdados de interfaces

 Use @Query("sql") para personalizar o método de consulta

 Consulta de acordo com o método de nomenclatura da regra

3.2 Consulta usando o método JdbcTemplate

JdbcTemplate é uma classe de ferramenta para operação de banco de dados fornecida pelo Spring após encapsular o JDBC original. Seu uso é o seguinte:

1. Injete o objeto JdbcTemplate

2. Método de chamada

(1) update(instrução sql,...parâmetro do espaço reservado): Executar instrução DML

(2) queryForObject(sql, new BeanPropertyRowMapper<>(result type.class),...parameters): Executa a instrução DQL cujo resultado da consulta é uma única linha

(3) queryForObject(sql,resulttype.class,...parameters): Execute a instrução DQL cujo resultado da consulta é uma única linha e uma única coluna.

(4) query(sql,new BeanPropertyRowMapper<>(tipo genérico do conjunto de resultados.class),...parâmetro): Execute a instrução DQL de que o conjunto de resultados é multilinha

4 Comparação dos métodos Repository e Template

Ao aprender Spring Data JDBC, usamos dois métodos de consulta, Repository e Template, e Spring Data JPA também suporta o uso de JdbcTemplate. Na verdade, para Spring Data, a maioria dos módulos suporta esses dois métodos de consulta, então como devemos escolher?

Ao herdar diretamente a interface xxxRepository, você não precisa escrever a classe de implementação sozinho e pode facilmente implementar operações simples de adição, exclusão, modificação, consulta, paginação, classificação, etc., mas para consultas muito complexas, é mais trabalhoso de usar.

Para usar xxxTemplate diretamente, você precisa escrever instruções SQL sozinho, mas pode controlar a adição, exclusão, modificação e consulta sozinho. Para consultas complexas, é mais conveniente usar.

Geralmente, para operações simples, herde diretamente a interface do Repositório e, para operações complexas, use o Modelo para concluir.

5 Comparação entre Spring Data JDBC e Spring Data JPA

O Spring Data JDBC é semelhante ao Spring Data JPA, mas mais leve e simples. O uso de Spring Data JPA deve integrar JPA, Hibernates e outras estruturas, e Spring Data JDBC pode ser usado diretamente. O Spring Data JDBC não oferece suporte a funções JPA, como JPQL, cache e carregamento lento, mas o Spring Data JDBC pode ser integrado ao MyBatis.

6 Integração Spring Data JDBC com MyBatis

O Spring Data JDBC integra o MyBatis para usar o cache Mybatis, carregamento lento e outras funções. O código é o seguinte:

1. Introduza a dependência do iniciador mybatis:

<!-- mybatis-starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>

2. Criar interface de extensão Spring Data JDBC

public interface StudentRepositoryExtension {
    List<Student> list();
}

3. arquivo de configuração mybatis

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tong.springdata.jdbc.StudentRepositoryExtension">
    <!--查询列表-->
    <select id="list" resultType="com.tong.springdata.jdbc.Student">
        select * from bz_student
    </select>
</mapper>

4. XML de varredura de configuração do Springboot

mybatis:
    mapper-locations: classpath:mapper/*Mapper.xml

5. Use mybatis para implementar a interface de extensão Spring Data JDBC, aqui você pode usar sqlsession para cache e outras operações.

@Repository
public class StudentRepositoryExtensionImpl implements StudentRepositoryExtension {
    @Autowired
    private SqlSession sqlSession;
    @Override
    public List<Student> list() {
        return sqlSession.selectList(StudentRepositoryExtension.class.getName() + ".list");
    }
}

6. StudentRepository herda a interface estendida

public interface StudentRepository extends CrudRepository<Student, Integer>, PagingAndSortingRepository<Student,Integer>,StudentRepositoryExtension

7. Teste

List<Student> list = studentRepository.list();