[Spring Boot] Consulta simples no Spring Boot

O artigo anterior introduziu a integração da estrutura JPA no projeto Spring Boot para implementar funções como adicionar, excluir, modificar e consultar dados. O uso do Spring Data JPA é muito simples, você só precisa herdar o JpaRepository para implementar métodos completos de operação de dados sem qualquer camada de acesso a dados e instruções SQL. Além dessas funções e vantagens, o JPA também possui funções de consulta de dados muito poderosas. No passado, consultas complexas exigiam a combinação de muitas condições de consulta, mas o JPA tem uma maneira muito conveniente e elegante de resolver isso. A seguir, vamos falar sobre a função de consulta do JPA para experimentar o poder do Spring Data JPA.

1. Método de pré-geração

Apresentamos anteriormente que a interface JpaRepository implementa todas as interfaces principais para acessar o banco de dados, como exist(), save(), findAll(), delete() e outros métodos. Crie uma classe UserRepository que herde a classe JpaRepository e tenha todos os métodos pré-gerados na classe pai.

Chamar esses métodos também é muito simples. Todos os métodos pertencentes à classe pai JpaRepository acima podem ser chamados diretamente, sem declaração. O código de exemplo é o seguinte:

userRespository.existsByld((long) 1);
userRespository.save(user);
userRespository.findById((long) 1);
userRespository.findAll();
userRespository.delete(user);
userRespository.deleteById((long) 1);

2. Personalize consultas simples

Além de usar diretamente as funções básicas fornecidas pela interface JpaRepository, o JPA também oferece suporte a operações de banco de dados com base em um determinado atributo da entidade. Spring Data JPA pode gerar SQL automaticamente com base no nome do método. As palavras-chave suportadas incluem find, query, get, ler, contar, excluir, etc., a sintaxe principal é findByXX, queryByXX, getByXX, readByXX, countByXX, etc. Para aproveitar esta função, você só precisa adicionar o nome do método correspondente ao repositório definido. Nenhuma implementação específica é necessária. Quando usado, o Spring Data JPA gerará automaticamente instruções SQL com base no nome do método.

2.1 Consulta de atributos

Se você deseja consultar informações do usuário com base no atributo name da entidade, basta adicionar uma declaração de interface diretamente ao UserRepository:

User findByUserName(String userName);

Como você pode ver no exemplo acima, podemos declarar o método findByUserName na interface UserRepository sem implementá-lo. O JPA gerará automaticamente o método de implementação correspondente e sua instrução SQL.

2.2 Consulta combinada

JPA não apenas oferece suporte a consultas de atributos únicos, mas também a consultas de múltiplos atributos e consultas combinadas baseadas em And, Or e outras palavras-chave. O código de exemplo é o seguinte:

User findByNameOrPassword (String name, String password);

No exemplo acima, a consulta é baseada na combinação de dois atributos: nome e senha. O nome e o número dos atributos devem corresponder à posição e ao número dos parâmetros um a um. Ele pode ser adicionado e emendado continuamente de acordo com as condições da consulta, e o Spring Data JPA pode ser analisado e executado corretamente.

2.3 Palavras-chave JPA

Além das palavras-chave And e Or, a consulta personalizada do JPA basicamente suporta todas as palavras-chave na sintaxe SQL, como like, between, etc.

De acordo com as especificações do Spring Data, os métodos de consulta começam com find, read e get. Quando condições de consulta estão envolvidas, os atributos das condições são conectados usando palavras-chave de condição. Deve-se observar que a primeira letra dos atributos condicionais é maiúscula.

3. Consulta SQL personalizada

Funções gerais de consulta de dados podem ser implementadas definindo nomes de métodos. No entanto, alguns cenários especiais podem exigir SQL personalizado para implementar funções de consulta de dados. Spring Data JPA também pode ser perfeitamente suportado.Spring Data JPA fornece anotação @Query, por meio da qual HQL ou SQL podem ser personalizados para implementar funções complexas de consulta de dados. O exemplo a seguir usa um programa de exemplo para demonstrar a anotação @Query para implementar uma consulta SQL personalizada.

3.1 Consulta HQL

Use a anotação @Query no método de consulta correspondente e escreva HQL na anotação para consultar o conteúdo:

@Query("select u from User u")
List<User> findALL();

No exemplo acima, a anotação @Query é usada para definir uma instrução HQL personalizada para implementar uma consulta de instrução HQL personalizada. Usar HQL é mais legível que SQL nativo e permite a manipulação de dados de maneira orientada a objetos. Coisas a serem observadas ao usar HQL:

1) From é seguido pela classe da entidade , não pelo nome da tabela de dados.

2) O campo de consulta usa os atributos da classe de entidade em vez dos campos da tabela de dados.

3) Select não pode ser seguido por "*" , deve ser um atributo na classe da entidade.

3.2 Consulta SQL

Além de suportar consultas de instruções HQL, o JPA também pode usar instruções SQL diretamente, o que é mais intuitivo. Basta adicionar outro parâmetro "nativeQuery = true":

@Query(value="select * from user u where u.name = ?1",nativeQuery = true)
List<User> findByName(String name);

"?1" no exemplo acima representa a ordem nos parâmetros do método e "nativeQuery = true" representa a execução da instrução SQL nativa. Além de passar parâmetros desta forma, você também pode usar @Param para passar valores:

@Query(value="select u from User u where u.password = :password")
List<User> findByPassword(@Param("password") String password);

3.3 Modificação e exclusão

Além das instruções de consulta personalizadas, a anotação @Query também pode ser usada para definir instruções de modificação e exclusão, mas a anotação @Modifying precisa ser adicionada. O código de exemplo é o seguinte:

@Modifying
@Query("update User set userName = ?1 where id = ?2")
int modifyById(String userName, Long id);

@Modifying
@Query("delete from User where id = ?1")
void deleteUserById(Long id);

No exemplo acima, a anotação @Modifying precisa ser adicionada às instruções personalizadas de exclusão e atualização. Deve-se observar que ao usá-lo, você precisa adicionar a anotação @Transactional no Repositório ou superior para garantir que os dados possam ser gravados com sucesso no banco de dados.

4. Consulta nomeada

Além de usar a anotação @Query, você também pode usar anotações como @NamedQuery e @NameQueries para definir consultas nomeadas. A consulta nomeada do JPA na verdade dá um nome à instrução de consulta SQL. Ao executar a consulta, o nome é usado diretamente para evitar escrever repetidamente instruções JPQL e permitir que o método de consulta seja reutilizado. A seguir, é usado um programa de amostra para demonstrar a consulta nomeada JPA.

4.1 Definir consultas nomeadas

Na classe de entidade, a anotação @NamedQuery define uma instrução de consulta nomeada. O código de exemplo é o seguinte:

@Entity
@Table(name="user")
@NamedQuery(name="findAllUser", query="SELECT U FROM User u")
public class User {
    
    

}

No exemplo acima, o atributo name em @NamedQuery especifica o nome da consulta nomeada e o atributo query especifica a instrução da consulta nomeada. Se quiser definir vários métodos de consulta nomeados, você precisará usar a anotação @NamedQueries:

@Entity
@Table(name="users")
@NamedQueries({
    
    
        @NamedQuery(name = "findAllUser", query = "SELECT U FROM User u"),
        @NamedQuery(name = "findUserWithId", query = "SELECT U FROM User u WHERE u.id = ?1"),
        @NamedQuery(name = "findUserWithName", query = "SELECT U FROM User u WHERE u.name = :name")
})
public class User {
    
    

}

No exemplo acima, três métodos findAllUser(), findUserWithId() e findUserWithName() são definidos na classe de entidade User.

4.2 Chamando consultas nomeadas

Depois de definir uma consulta nomeada, você pode criar uma consulta passando o nome da consulta nomeada usando o método createNamedQuery() na classe EntityManager:

    @Resource
    EntityManagerFactory emf;
    @Test
    public void testNamedQuery() {
    
    
        EntityManager em = emf.createEntityManager();
        // 根User实体中定义的命名查询
        Query query = em.createNamedQuery("findUserWithName");
        query.setParameter("name", "ysxq");
        List<User> users = query.getResultList();
        for (User u : users) {
    
    
            System.out.println("name:" + u.getName() + ",age:" + u.getAge());
        }
    }

No exemplo acima, use createNamedQuery para criar a consulta correspondente. JPA primeiro encontrará o NamedQuery correspondente com base no nome da consulta recebida e, em seguida, executará a consulta e retornará os resultados chamando o método getResultList().

Além de usar a anotação @NamedQuery, a consulta nomeada fornecida pelo Spring Data JPA pode suportar a gravação de instruções SQL em arquivos XML para obter a separação do código SQL e Java. Crie o arquivo orm.xml no diretório resources/META-INF e defina o método de nomenclatura. A configuração de referência é a seguinte:

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings version="2.0"
                 xmlns="http://java.sun.com/xml/ns/persistence/orm"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
                 http://www.oracle.com/webfolder/technetwork/jsc/xml/ns/persistence/orm_2_2.xsd">
    <named-native-query name="findUserWithName2" result-class="com.example.ysxq.model.User">
        <description>通过name查询用户数据</description>
        <query>select u.id , u.name , u.password , u.age from users u where u.name = :name</query>
    </named-native-query>
</entity-mappings>

Use tags no arquivo orm.xml para definir a consulta nomeada de queryByName. O efeito de usar XML é o mesmo que usar a anotação @NamedQuery. Basta escrever a instrução SQL no arquivo XML para separar o código SQL e Java, fazendo com que a classe de entidade Java definida pareça menos complicada e inchada.