[Spring Boot] Consulta simple en Spring Boot

El artículo anterior presentó la integración del marco JPA en el proyecto Spring Boot para implementar funciones como agregar, eliminar, modificar y consultar datos. El uso de Spring Data JPA es muy simple: solo necesita heredar JpaRepository para implementar métodos completos de operación de datos sin ninguna capa de acceso a datos ni declaraciones SQL. Además de estas funciones y ventajas, JPA también tiene funciones de consulta de datos muy potentes. En el pasado, las consultas complejas requerían unir muchas condiciones de consulta, pero JPA tiene una forma muy conveniente y elegante de resolverlo. A continuación, hablemos de la función de consulta de JPA para experimentar el poder de Spring Data JPA.

1. Método de pregeneración

Anteriormente presentamos que la interfaz JpaRepository implementa todas las interfaces clave para acceder a la base de datos, como existe(), guardar(), findAll(), eliminar() y otros métodos. Cree una clase UserRepository que herede la clase JpaRepository y tenga todos los métodos generados previamente en la clase principal.

Llamar a estos métodos también es muy simple: todos los métodos propiedad de la clase principal JpaRepository anterior se pueden llamar directamente sin declaración. El código de muestra es el siguiente:

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

2. Personaliza consultas sencillas

Además de utilizar directamente las funciones básicas proporcionadas por la interfaz JpaRepository, JPA también admite operaciones de base de datos basadas en un determinado atributo de la entidad. Spring Data JPA puede generar SQL automáticamente según el nombre de su método. Las palabras clave admitidas incluyen buscar, consultar, obtener, leer, contar, eliminar, etc., la sintaxis principal es findByXX, queryByXX, getByXX, readByXX, countByXX, etc. Para aprovechar esta función, solo necesita agregar el nombre del método correspondiente al repositorio definido. No se requiere una implementación específica. Cuando se usa, Spring Data JPA generará automáticamente declaraciones SQL basadas en el nombre del método.

2.1 Consulta de atributos

Si desea consultar información del usuario según el atributo de nombre de la entidad, simplemente agregue una declaración de interfaz directamente al UserRepository:

User findByUserName(String userName);

Como puede ver en el ejemplo anterior, podemos declarar el método findByUserName en la interfaz UserRepository sin implementarlo. JPA generará automáticamente el método de implementación correspondiente y su declaración SQL.

2.2 consulta combinada

JPA no solo admite consultas de un solo atributo, sino que también admite consultas de múltiples atributos y consultas combinadas basadas en Y, O y otras palabras clave. El código de muestra es el siguiente:

User findByNameOrPassword (String name, String password);

En el ejemplo anterior, la consulta se basa en la combinación de dos atributos: nombre y contraseña. El nombre y el número de los atributos deben corresponder a la posición y el número de los parámetros uno a uno. Se puede agregar y unir continuamente de acuerdo con las condiciones de la consulta, y Spring Data JPA se puede analizar y ejecutar correctamente.

2.3 palabras clave JPA

Además de las palabras clave And y Or, la consulta personalizada de JPA básicamente admite todas las palabras clave en la sintaxis SQL, como me gusta, entre, etc.

Según las especificaciones de Spring Data, los métodos de consulta comienzan con buscar, leer y obtener. Cuando están involucradas condiciones de consulta, los atributos de las condiciones se conectan mediante palabras clave de condición. Cabe señalar que la primera letra de los atributos condicionales está en mayúscula.

3. Consulta SQL personalizada

Las funciones generales de consulta de datos se pueden implementar definiendo nombres de métodos. Sin embargo, algunos escenarios especiales pueden requerir SQL personalizado para implementar funciones de consulta de datos. Spring Data JPA también puede ser perfectamente compatible. Spring Data JPA proporciona la anotación @Query, a través de la cual HQL o SQL se pueden personalizar para implementar funciones complejas de consulta de datos. A continuación se utiliza un programa de muestra para demostrar la anotación @Query para implementar una consulta SQL personalizada.

3.1 consulta HQL

Utilice la anotación @Query en el método de consulta correspondiente y escriba HQL en la anotación para consultar el contenido:

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

En el ejemplo anterior, la anotación @Query se utiliza para definir una declaración HQL personalizada para implementar una consulta de declaración HQL personalizada. El uso de HQL es más legible que SQL nativo y permite la manipulación de datos orientada a objetos. Cosas a tener en cuenta al utilizar HQL:

1) De va seguido de la clase de entidad , no del nombre de la tabla de datos.

2) El campo de consulta utiliza los atributos de la clase de entidad en lugar de los campos de la tabla de datos.

3) La selección no puede ir seguida de "*" , debe ser un atributo en la clase de entidad.

3.2 consulta SQL

Además de admitir consultas de declaraciones HQL, JPA también puede usar declaraciones SQL directamente, lo cual es más intuitivo, simplemente agregue otro parámetro "nativeQuery = true":

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

"?1" en el ejemplo anterior representa el orden en los parámetros del método y "nativeQuery = true" representa la ejecución de la instrucción SQL nativa. Además de pasar parámetros de esta manera, también puedes usar @Param para pasar valores:

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

3.3 Modificación y eliminación

Además de las declaraciones de consulta personalizadas, la anotación @Query también se puede usar para definir declaraciones de modificación y eliminación, pero es necesario agregar la anotación @Modifying. El código de muestra es el siguiente:

@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);

En el ejemplo anterior, es necesario agregar la anotación @Modifying a las declaraciones personalizadas de eliminación y actualización. Cabe señalar que al usarlo, debe agregar la anotación @Transactional en el Repositorio o superior para garantizar que los datos se puedan escribir correctamente en la base de datos.

4. Consulta con nombre

Además de utilizar la anotación @Query, también puede utilizar anotaciones como @NamedQuery y @NameQueries para definir consultas con nombre. La consulta con nombre de JPA en realidad le da un nombre a la declaración de consulta SQL. Al ejecutar la consulta, el nombre se usa directamente para evitar escribir declaraciones JPQL repetidamente y permitir que el método de consulta se reutilice. A continuación se utiliza un programa de muestra para demostrar la consulta con nombre JPA.

4.1 Definir consultas con nombre

En la clase de entidad, la anotación @NamedQuery define una declaración de consulta con nombre. El código de muestra es el siguiente:

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

}

En el ejemplo anterior, el atributo de nombre en @NamedQuery especifica el nombre de la consulta nombrada y el atributo de consulta especifica la declaración de la consulta nombrada. Si desea definir varios métodos de consulta con nombre, debe utilizar la anotación @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 {
    
    

}

En el ejemplo anterior, se definen tres métodos findAllUser(), findUserWithId() y findUserWithName() en la clase de entidad Usuario.

4.2 Llamar a consultas con nombre

Después de definir una consulta con nombre, puede crear una consulta pasando el nombre de la consulta con nombre utilizando el método createNamedQuery() en la clase 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());
        }
    }

En el ejemplo anterior, use createNamedQuery para crear la consulta correspondiente. JPA primero encontrará la NamedQuery correspondiente según el nombre de la consulta entrante, luego ejecutará la consulta y devolverá los resultados llamando al método getResultList ().

Además de utilizar la anotación @NamedQuery, la consulta con nombre proporcionada por Spring Data JPA puede admitir la escritura de declaraciones SQL en archivos XML para lograr la separación del código SQL y Java. Cree el archivo orm.xml en el directorio resources/META-INF y defina el método de nomenclatura. La configuración de referencia es la siguiente:

<?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>

Utilice etiquetas en el archivo orm.xml para definir la consulta con nombre de queryByName. El efecto de utilizar XML es el mismo que utilizar la anotación @NamedQuery. Simplemente escriba la declaración SQL en el archivo XML para separar el código SQL y Java, haciendo que la clase de entidad Java definida parezca menos complicada e hinchada.