Spring Boot Data JPA 派生的查询

原文： http://zetcode.com/springboot/datajpaderivedqueries/

Spring Boot Data JPA 派生查询教程展示了如何从方法名称创建查询。

Spring 是用于创建企业应用的流行 Java 应用框架。 Spring Boot 是 Spring 框架的演进，可帮助您轻松创建独立的，生产级的基于 Spring 的应用。

Spring Data JPA

Spring Data JPA 有助于实现基于 JPA 的存储库。 它增强了对基于 JPA 的数据访问层的支持。 它使构建使用数据访问技术的 Spring 支持的应用变得更加容易。 Spring Data JPA 是较大的 Spring Data 系列的一部分。

Spring Data JPA 派生的查询

Spring Data JPA 可以从方法名称创建查询。 这是约定而不是配置的特定形式。 Spring Data JPA 从具有属性组合的特定关键字创建查询； 例如：findByAgeLessThan，findByFirstnameEndingWith或findByFirstnameEquals。 关键字列表在 Spring Data JPA 文档中提供。

Spring Boot Data JPA 派生查询示例

以下应用使用两个派生查询。

pom.xml
src
├───main
│   ├───java
│   │   └───com
│   │       └───zetcode
│   │           │   Application.java
│   │           │   MyRunner.java
│   │           ├───model
│   │           │       City.java
│   │           ├───repository
│   │           │       CityRepository.java
│   │           └───service
│   │                   CityService.java
│   │                   ICityService.java
│   └───resources
│           application.properties
│           data-h2.sql
│           schema-h2.sql
└───test
    └───java

这是项目结构。

pom.xml

<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zetcode</groupId>
    <artifactId>springbootderivedqueries</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Maven POM 文件包含 H2 数据库和 Spring Boot Data JPA 的依赖项。

resources/application.properties

spring.main.banner-mode=off
spring.datasource.platform=h2
spring.jpa.hibernate.ddl-auto=none

在application.properties文件中，我们编写了 Spring Boot 应用的各种配置设置。 使用spring.main.banner-mode属性，我们可以关闭 Spring 横幅。

spring.datasource.platform设置数据库的供应商名称。 在初始化脚本中使用它。 spring.jpa.hibernate.ddl-auto禁止从实体自动创建模式。

com/zetcode/model/City.java

package com.zetcode.model;
import java.util.Objects;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "cities")
public class City {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private int population;
    public City() {
    }
    public City(String name, int population) {
        this.name = name;
        this.population = population;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPopulation() {
        return population;
    }
    public void setPopulation(int population) {
        this.population = population;
    }
    @Override
    public int hashCode() {
        int hash = 7;
        hash = 79 * hash + Objects.hashCode(this.id);
        hash = 79 * hash + Objects.hashCode(this.name);
        hash = 79 * hash + this.population;
        return hash;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final City other = (City) obj;
        if (this.population != other.population) {
            return false;
        }
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        return Objects.equals(this.id, other.id);
    }
    @Override
    public String toString() {
        var builder = new StringBuilder();
        builder.append("City{id=").append(id).append(", name=")
                .append(name).append(", population=")
                .append(population).append("}");
        return builder.toString();
    }
}

这是City实体。 每个实体必须至少定义两个注解：@Entity和@Id。

@Entity
@Table(name = "cities")
public class City {

@Entity注解指定该类是一个实体，并映射到数据库表。 @Table注解指定要用于映射的数据库表的名称。

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

@Id注解指定实体的主键，@GeneratedValue提供规范主键值的生成策略。

resources/schema-h2.sql

CREATE TABLE cities(id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255), population INT);

启动应用时，将执行schema-h2.sql脚本。 它创建一个新的数据库表。

resources/data-h2.sql

INSERT INTO cities(name, population) VALUES('Bratislava', 432000);
INSERT INTO cities(name, population) VALUES('Budapest', 1759000);
INSERT INTO cities(name, population) VALUES('Prague', 1280000);
INSERT INTO cities(name, population) VALUES('Warsaw', 1748000);
INSERT INTO cities(name, population) VALUES('Los Angeles', 3971000);
INSERT INTO cities(name, population) VALUES('New York', 8550000);
INSERT INTO cities(name, population) VALUES('Brest', 139163);
INSERT INTO cities(name, population) VALUES('Edinburgh', 464000);
INSERT INTO cities(name, population) VALUES('Suzhou', 4327066);
INSERT INTO cities(name, population) VALUES('Zhengzhou', 4122087);
INSERT INTO cities(name, population) VALUES('Berlin', 3671000);
INSERT INTO cities(name, population) VALUES('Bucharest', 1836000);

之后，执行data-h2.sql文件。 它用数据填充表。

com/zetcode/repository/CityRepository.java

package com.zetcode.repository;
import com.zetcode.model.City;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface CityRepository extends CrudRepository<City, Long> {
    List<City> findByNameEndingWith(String ending);
    List<City> findByPopulationLessThan(int population);
}

我们有两种方法可以从中生成派生查询。

List<City> findByNameEndingWith(String ending);

在这里，查询将查找以指定字符串结尾的表单城市名称。

List<City> findByPopulationLessThan(int population);

查询将在其中查找人口少于指定数量的城市。

com/zetcode/service/ICityService.java

package com.zetcode.service;
import com.zetcode.model.City;
import java.util.List;
public interface ICityService {
    List<City> findByNameEndingWith(String ending);
    List<City> findByPopulationLessThan(int population);
}

ICityService提供了两种签约方法。

com/zetcode/service/CityService.java

package com.zetcode.service;
import com.zetcode.model.City;
import com.zetcode.repository.CityRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class CityService implements ICityService {
    @Autowired
    private CityRepository cityRepository;
    @Override
    public List<City> findByNameEndingWith(String ending) {
        return cityRepository.findByNameEndingWith(ending);
    }
    @Override
    public List<City> findByPopulationLessThan(int population) {
        return cityRepository.findByPopulationLessThan(population);
    }
}

CityService包含服务方法实现。 派生的查询在cityRepository上调用。

com/zetcode/MyRunner.java

package com.zetcode;
import com.zetcode.service.ICityService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class MyRunner implements CommandLineRunner {
    private static final Logger logger = LoggerFactory.getLogger(MyRunner.class);
    @Autowired
    private ICityService cityService;
    @Override
    public void run(String... args) throws Exception {
        logger.info("Finding cities having population less than one million");
        var res1 = cityService.findByPopulationLessThan(1000000);
        logger.info("{}", res1);
        logger.info("Finding cities by name ending with 'est'");
        var res2 = cityService.findByNameEndingWith("est");
        logger.info("{}", res2);
    }
}

MyRunner获取所有人口少于一百万的城市以及所有名称以"est"结尾的城市。

com/zetcode/Application.java

package com.zetcode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Application设置 Spring Boot 应用。 @SpringBootApplication启用自动配置和组件扫描。

$ mvn spring-boot:run
...
19-05-21 Tue 14:53:39.892 INFO  MyRunner [City{id=1, name=Bratislava, population=432000}, 
City{id=7, name=Brest, population=139163}, City{id=8, name=Edinburgh, population=464000}]
19-05-21 Tue 14:53:39.894 INFO  MyRunner Finding cities by name ending with 'est'
19-05-21 Tue 14:53:39.903 INFO  MyRunner [City{id=2, name=Budapest, population=1759000}, 
City{id=7, name=Brest, population=139163}, City{id=12, name=Bucharest, population=1836000}]
...

我们运行该应用。

在本教程中，我们使用了 Spring Data JPA 派生的查询来获取数据。 您可能也对相关教程感兴趣：

• Spring Boot Data JPA @NamedQuery教程

• Spring Boot REST Data JPA 教程
  

• Spring Boot Data JPA 排序教程

• Spring Boot CrudRepository教程

列出所有 Spring Boot 教程。