contenido
La relación entre SpringDataJpa, jpa, hibernate
1. Cree un proyecto Maven e importe las coordenadas
2. Escriba el archivo de configuración de Spring Data JPA (applicationContext.xml)
3. Crear clases de entidad, tablas de bases de datos.
4. SQL para tablas de bases de datos
Tres, cuatro métodos de consulta:
Métodos encapsulados de JpaRepository
Método encapsulado JpaSpecificationExecutor
Parte de la tabla de comparación
1. Datos de primavera JPa
Presentamos springDataJPa
Spring Data JPA es un conjunto de marco de aplicación JPA encapsulado por Spring basado en el marco ORM y la especificación JPA, que permite a los desarrolladores acceder y operar la base de datos con un código mínimo. Proporciona funciones comunes que incluyen CRUD, etc., ¡y es fácil de expandir! ¡Aprender y usar Spring Data JPA puede mejorar en gran medida la eficiencia del desarrollo!
Spring Data JPA es parte de la familia Spring Data más grande de repositorios basados en JPA de fácil implementación. Este módulo maneja soporte mejorado para la capa de acceso a datos basada en JPA. Facilita la creación de aplicaciones impulsadas por Spring que utilizan tecnologías de acceso a datos.
SpringDataJPA es en realidad una encapsulación y abstracción de la especificación JPA. La capa inferior todavía se implementa utilizando la tecnología JPA de Hibernate . Se refiere al lenguaje de consulta JPQL (Java Persistence Query Language), que es parte de todo el ecosistema Spring. Con la popularidad de Spring Boot y Spring Cloud en el mercado, Spring Data JPA ha entrado gradualmente en el campo de visión de todos. Forman un todo orgánico, que es más conveniente de usar y acelera la eficiencia del desarrollo, por lo que los desarrolladores no necesitan para preocuparse y configurar más Se puede sumergir completamente en la implementación estándar ecológica completa de Spring. JPA es fácil de usar, tiene una alta eficiencia de desarrollo, mejor soporte para objetos y tiene una gran flexibilidad, y el reconocimiento del mercado es cada vez mayor.
Dirección del sitio web oficial : Spring Data JPA
La relación entre SpringDataJpa, jpa, hibernate
El trabajo subyacente sigue siendo Hibernate Escuché que los fundadores de JPA e Hibernate son la misma persona.
2. Construye el entorno
1. Cree un proyecto Maven e importe las coordenadas
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>JPA</artifactId>
<groupId>com.dynamic</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>JPA-Day2</artifactId>
<properties>
<spring.version>5.0.2.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring对orm框架的支持包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!-- spring data jpa 的坐标-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<!-- el end -->
</dependencies>
</project>2. Escriba el archivo de configuración de Spring Data JPA (applicationContext.xml)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!-- 1.dataSource 配置数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver" />
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />
<property name="user" value="root" />
<property name="password" value="root" />
</bean>
<!-- 2.配置entityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="com.dynamic.domain" />
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
</property>
<!--jpa的供应商适配器 -->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--配置是否自动创建数据库表 -->
<property name="generateDdl" value="false" />
<!--指定数据库类型 -->
<property name="database" value="MYSQL" />
<!--数据库方言：支持的特有语法 -->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<!--是否显示sql -->
<property name="showSql" value="true" />
</bean>
</property>
<!--jpa的方言 ：高级的特性 -->
<property name="jpaDialect" >
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
</bean>
<!-- 3.事务管理器-->
<!-- JPA事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 整合spring data jpa-->
<jpa:repositories base-package="com.dynamic.dao"
transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!-- 4.txAdvice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 5.aop-->
<!-- <aop:config>-->
<!-- <aop:pointcut id="pointcut" expression="execution(* com.dynamic.service.*.*(..))" />-->
<!-- <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />-->
<!-- </aop:config>-->
<context:component-scan base-package="com.dynamic"></context:component-scan>
<!--组装其它 配置文件-->
</beans>3. Crear clases de entidad, tablas de bases de datos.
package com.dynamic.domain;
import javax.persistence.*;
/**
* @Author: Promsing(张有博)
* @Date: 2021/10/13 - 17:29
* @Description: 客户的实体类
* 配置映射关系
* 1.实体类和表的映射关系
* @Entity 声明是实体类
* @Table(name = "cst_customer") 实体类与表的映射关系，name配置表的名称
*
* 2.实体类中属性和表字段的映射关系
* @version： 1.0
*/
@Entity
@Table(name = "cst_customer")
public class Customer {
/**
* @Id：声明主键的配置
* @GeneratedValue:配置主键的生成策略
* strategy
* GenerationType.IDENTITY ：自增，mysql
* * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
* GenerationType.SEQUENCE : 序列，oracle
* * 底层数据库必须支持序列
* GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
* GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
* @Column:配置属性和字段的映射关系
* name：数据库表中字段的名称
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "cust_id")
private Long id;//主键
@Column(name="cust_name")
private String custName;
@Column(name="cust_source")
private String custSource;
@Column(name = "cust_industry")
private String custIndustry;//所属行业
@Column(name="cust_level")
private String custLevel;
@Column(name = "cust_address")
private String custAddress;
@Column(name = "cost_phone")
private String custPhone;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
@Override
public String toString() {
return "Customer{" +
"id=" + id +
", custName='" + custName + '\'' +
", custSource='" + custSource + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custAddress='" + custAddress + '\'' +
", custPhone='" + custPhone + '\'' +
'}';
}
}4. SQL para tablas de bases de datos
CREATE TABLE `cst_customer` (
`cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
`cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
`cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
`cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
`cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
`cust_address` varchar(128) DEFAULT NULL COMMENT '客户联系地址',
`cust_phone` varchar(64) DEFAULT NULL COMMENT '客户联系电话',
`cost_phone` varchar(255) DEFAULT NULL,
PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;5. Interfaz DAO
package com.dynamic.dao;
import com.dynamic.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
* @Author: Promsing(张有博)
* @Date: 2021/10/17 - 17:36
* @Description: 需要符合springDataJPA的dao层接口规范
* JpaRepository<操作的实体类型，实体类中主键属性的类型>
* *封装了基本的CRUD操作
* JpaSpecificationExecutor<操作的实体类型>
* *封装了复杂查询（分页）
* @version： 1.0
*/
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
}Tres, cuatro métodos de consulta:
1. CRUD básico
Herede JpaRepository, la interfaz JpaSpecificationExecutor y use métodos encapsulados en JPA.
Métodos encapsulados de JpaRepository
Método encapsulado JpaSpecificationExecutor
clase de prueba
/**
* findOne(id) :根据id查询
*
* save(customer):保存或更新 实体的id属性
*
* delete(id) :根据id删除
*
* findAll() :查询全部
*
* count() ：计数
*
* exists() :判断是否存在
*
*/
@Test
public void testFindOne(){
System.out.println("dfa");
Customer one = dao.findOne(1L);
System.out.println(one);
}
@Test
public void testSave(){
System.out.println("dfa");
Customer c=new Customer();
c.setCustAddress("廊坊");
c.setCustName("小小张");
c.setCustPhone("9999");
c.setCustLevel("vipp");
Customer save = dao.save(c);
System.out.println(save);
}
@Test
@Transactional
public void testUpdate(){
System.out.println("dfa");
Customer c=new Customer();
c.setCustAddress("廊坊");
c.setCustName("小小张");
c.setCustPhone("2800");
Customer save = dao.save(c);
System.out.println(save);
}
@Test
public void testDelete(){
dao.delete(2L);
System.out.println();
}
@Test
@Transactional
public void testFindAll(){
List<Customer> all = dao.findAll();
for (Customer customer : all) {
System.out.println(customer);
}
System.out.println();
}
@Test
@Transactional
public void testCount(){
long count = dao.count();
System.out.println(count);
}
@Test
public void testExists(){
boolean exists = dao.exists(2L);
System.out.println(exists);
}
@Test
@Transactional
public void testGetOne(){
// getOone方法是懒加载
Customer one = dao.getOne(2L);
System.out.println(one);
}2. consulta JPQL
lenguaje de consulta jpa (lenguaje de consulta jpq), similar a las sentencias SQL nativas y completamente orientado a objetos, al que se accede a través de nombres y atributos de clase, clases de consulta y atributos en clases
El blog anterior introdujo JPQL:
La instrucción JPQL debe configurarse en el método de interfaz
1. Consulta única: el método debe configurarse en la interfaz dao
2. En el método recién agregado, configure la declaración de consulta jpql en forma de anotaciones
3. Anotación: @Consulta
Interfaz DAO:
/**
* @Author: Promsing(张有博)
* @Date: 2021/10/17 - 17:36
* @Description: 需要符合springDataJPA的dao层接口规范
* JpaRepository<操作的实体类型，实体类中主键属性的类型>
* *封装了基本的CRUD操作
* JpaSpecificationExecutor<操作的实体类型>
* *封装了复杂查询（分页）
* @version： 1.0
*/
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
/**
* @Query：表示查询
*
* @Modifying 表示更新的操作
*/
@Query(value = "from Customer where custName = ? ")
public List<Customer> findJpql(String custName);
/**
* 对于多个占位符参数
* 赋值的时候，默认情况下，占位符的位置需要和方法参数中的位置保持一致
*
* 可以指定占位符参数的位置
* ? 索引的方式，指定此占位符的取值来源
*/
@Query(value = "from Customer where custName = ? and id = ?")
// @Query(value = "from Customer where custName = ?2 and id = ?1")
public Object findCustNameAndId(String name,Long id);
@Query(value = "update Customer set custName = ? where id = ? ")
@Modifying //表示是，更新的操作
public Integer updateName(String name,Long id);
}Clase de prueba:
@Test
public void testJpql(){
List<Customer> list = dao.findJpql("小小张");
System.out.println(list);
}
@Test
public void testFindCustNameAndId(){
Object one = dao.findCustNameAndId("小小张",1L);
System.out.println(one);
}
@Test
@Transactional //添加事务的支持
@Rollback(value = false)
/**
* springDataJpa中使用jpql完成更新/删除操作
* 需要手动添加事务的支持
* 默认会执行结束之后，回滚事务
* @Rollback: 设置是否自动回滚
* false(不) | true
*/
public void testUpdateName(){
Object one = dao.updateName("张自由",3L);
System.out.println(one);
}3. Consulta SQL
1. Consulta única: el método debe configurarse en la interfaz dao
2. En el método recién agregado, configure la instrucción de consulta sql en forma de anotaciones
3. Anotación: @Consulta
valor: sentencia jpql | sentencia sql
nativeQuery: falso (usar consulta jpql) | verdadero (usar consulta nativa: consulta sql)
interfaz DAO
package com.dynamic.dao;
import com.dynamic.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
* @Author: Promsing(张有博)
* @Date: 2021/10/17 - 17:36
* @Description: 需要符合springDataJPA的dao层接口规范
* JpaRepository<操作的实体类型，实体类中主键属性的类型>
* *封装了基本的CRUD操作
* JpaSpecificationExecutor<操作的实体类型>
* *封装了复杂查询（分页）
* @version： 1.0
*/
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
/**
* 使用sql的形式查询 查询全部用户
* SQL：select * from cst_customer
* @Query: 配置sql查询
* value：sqly语句
* nativeQuery:查询方式
* true：sql查询
* false:jpql查询
* @return
*/
@Query(value = "select * from cst_customer", nativeQuery = true)
public List<Customer> findSql();
@Query(value = "select * from cst_customer where cust_name like ?", nativeQuery = true)
public List<Customer> findLikeSql(String name );
}Clase de prueba:
@Test
public void testSQL(){
List<Customer> list = dao.findSql();
List<Customer> sql = dao.findLikeSql("小%");
for (Customer customer : sql) {
System.out.println(customer);
}
}4. Método llamado consulta
Es una encapsulación más profunda de la consulta jpql.
Solo necesitamos definir métodos de acuerdo con las reglas de nombre de método proporcionadas por SpringDataJpa, no es necesario configurar declaraciones jpql para completar la consulta
De acuerdo con las reglas definidas por Spring Data JPA, el método de consulta comienza con findBy. Cuando se trata de una consulta condicional, los atributos de la condición se conectan con la palabra clave condition. Cabe señalar que la primera letra del atributo condition debe ser en mayúscula Cuando el marco analiza el nombre del método, primero intercepta el prefijo redundante del nombre del método y luego analiza la parte restante.
Parte de la tabla de comparación
| Palabra clave |
Muestra |
JPQL |
||
| Y |
findByLastnameAndFirstname |
… donde x.apellido = ?1 y x.nombre = ?2 |
||
| O |
findByLastnameOrFirstname |
… donde x.apellido = ?1 o x.nombre = ?2 |
||
| es, igual |
encontrar por nombre es, findByFirstnameEquals |
… donde x.nombre = ?1 |
||
| Entre |
findByStartDateBetween |
… donde x.startDate entre ?1 y ?2 |
||
| Menos que |
findByAgeLessThan |
… donde x.edad < ?1 |
||
| menor que igual |
findByAgeLessThanEqual |
… donde x.edad ⇐ ?1 |
||
| Mas grande que |
findByAgeGreaterThan |
… donde x.edad > ?1 |
||
| mayor que igual |
findByAgeGreaterThanEqual |
… donde x.edad >= ?1 |
||
| Después |
findByStartDateAfter |
… donde x.startDate > ?1 |
||
| Antes |
findByStartDateBefore |
… donde x.startDate < ?1 |
||
| Es nulo |
findByAgeIsNull |
… donde x.edad es nulo |
||
| No es nulo, no es nulo |
findByAge(Is)NotNull |
… donde x.age no es nulo |
||
| Me gusta |
findByFirstnameLike |
… donde x.firstname como ?1 |
||
| Diferente a |
findByFirstnameNotLike |
… donde x.nombre no como ?1 |
||
| Empezando con |
findByFirstnameComenzando con |
… donde x.firstname como ?1 (parámetro enlazado con %) adjunto |
||
| terminando con |
findByFirstnameEndingWith |
… donde x.firstname como ?1 (parámetro enlazado con %) |
||
| que contiene |
findByFirstnameContaining |
… donde x.firstname como ?1 (límite de parámetro envuelto en %) |
||
| Ordenar por |
findByAgeOrderByLastnameDesc |
… donde x.edad = ?1 orden por x.apellido desc |
||
| No |
findByLastnameNot |
… donde x.apellido <> ?1 |
||
| En |
findByAgeIn(edades de la colección) |
… donde x.edad en ?1 |
||
| nadando |
findByAgeNotIn(Edad de la colección) |
… donde x.edad no está en ?1 |
||
| CIERTO |
encontrarPorActivoVerdadero() |
… donde x.activo = verdadero |
||
| FALSO |
findByActiveFalse () |
… donde x.activo = falso |
||
| Ignorar caso |
findByFirstnameIgnoreCase |
… donde SUPERIOR(x.nombre) = SUPERIOR(?1) |
Interfaz DAO:
package com.dynamic.dao;
import com.dynamic.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
* @Author: Promsing(张有博)
* @Date: 2021/10/17 - 17:36
* @Description: 需要符合springDataJPA的dao层接口规范
* JpaRepository<操作的实体类型，实体类中主键属性的类型>
* *封装了基本的CRUD操作
* JpaSpecificationExecutor<操作的实体类型>
* *封装了复杂查询（分页）
* @version： 1.0
*/
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
/**
* 方法名的约定
*
* findBy：查询
* 对象中的属性名（首字母大写），查询条件
*
* findByCustName 根据客户名称查询
*
* 会根据方法名称进行解析 findBy from XXX where custName
* @param name
* @return
*/
//1.findBy +属性名称（根据属性名称进行完成匹配的查询=）
public Customer findByCustName(String name );
//2.findBy +属性名称 +“查询方式”（Like | isNull）
public List<Customer> findByCustNameLike(String name );
//3.findBy +属性名称 +“查询方式” +“多条件的连接符（and|or）” +属性名 +“查询方式”
public Customer findByCustNameLikeAndCustIndustry(String name,String industry);
}Clase de prueba:
@Test
public void testFindNaming(){
Customer custName = dao.findByCustName("张自由");
System.out.println(custName);
System.out.println("______________");
List<Customer> byCustNameLike = dao.findByCustNameLike("小%");
for (Customer customer : byCustNameLike) {
System.out.println(customer);
}
System.out.println("______________");
Customer it = dao.findByCustNameLikeAndCustIndustry("小%", "IT教育");
System.out.println(it);
}