Spring Boot 中使用 JPA 实现 INNER JOIN 查询（查询.Boot.Spring.JOIN.JPA...）

本文旨在指导开发者如何在 Spring Boot 项目中使用 JPA（Java Persistence API）执行 INNER JOIN 查询，以获取关联实体的数据。我们将通过示例代码，详细讲解如何定义实体、配置 Repository，并使用自定义查询语句实现 INNER JOIN，最后展示如何通过 Projection 优化查询结果。

首先，我们需要定义两个实体类 Persona（人）和 Turno（班次），它们之间存在一对多的关系。一个人可以有多个班次。

@Entity
@Table(name = "persona")
public class Persona {

    @Id
    @Column
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column
    private String name;

    @Column
    private String apellidos;

    @OneToMany(mappedBy = "persona")
    private List<Turno> turnos;

    // Getters and setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public List<Turno> getTurnos() {
        return turnos;
    }

    public void setTurnos(List<Turno> turnos) {
        this.turnos = turnos;
    }
}

@Entity
@Table(name = "turnos")
public class Turno {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "idturno")
    private int idturno;

    @Column(name = "fechaturno")
    private String fechaturno;

    @Column(name = "medico")
    private String medico;

    @ManyToOne
    private Persona persona;

    public Turno() {
    }

    // Getters and setters
    public int getIdturno() {
        return idturno;
    }

    public void setIdturno(int idturno) {
        this.idturno = idturno;
    }

    public String getFechaturno() {
        return fechaturno;
    }

    public void setFechaturno(String fechaturno) {
        this.fechaturno = fechaturno;
    }

    public String getMedico() {
        return medico;
    }

    public void setMedico(String medico) {
        this.medico = medico;
    }

    public Persona getPersona() {
        return persona;
    }

    public void setPersona(Persona persona) {
        this.persona = persona;
    }
}

注意 Persona 实体类中的 @OneToMany 注解和 Turno 实体类中的 @ManyToOne 注解，它们定义了两个实体之间的关联关系。mappedBy = "persona" 指示 Persona 实体中的 turnos 字段通过 Turno 实体中的 persona 字段进行映射。

接下来，我们需要定义 JPA Repository 接口，用于执行数据库操作。

public interface PersonaRepositorio extends JpaRepository<Persona, Integer> {
    //list all person
    List<Persona> findAll();

    //list one person
    Persona findByid(int id);

    //save changes news or update
    Persona save(Persona p);

    //delete
    void delete(Persona p);
}

@Repository
public interface TurnoRepository extends JpaRepository<Turno, Integer> {

    Turno findById(int idturno);

}

最简单的方式是利用 JPA 的方法名约定。如果你想根据 Persona 的 ID 查找对应的 Turno 列表，可以在 TurnoRepository 中添加如下方法：

public interface TurnoRepository extends JpaRepository<Turno, Integer> {
    List<Turno> findAllByPersonaId(int personaId);

    Turno findById(int idturno);
}

JPA 会自动生成相应的 SQL 查询语句，实现 Persona 和 Turno 表的 INNER JOIN。

如果需要更复杂的查询，可以使用 @Query 注解自定义查询语句。例如，要查询所有 Turno，并同时获取关联的 Persona 的姓名和班次信息，可以定义一个 Projection 接口：

public interface TurnoPersonaProjection {
  String getName();
  String getApellidos();
  String getFechaturno();
  String getMedico();
}

然后，在 TurnoRepository 中使用 @Query 注解定义查询方法：

@Repository
public interface TurnoRepository extends JpaRepository<Turno, Integer> {

    @Query("SELECT p.name as name, p.apellidos as apellidos, t.fechaturno as fechaturno, t.medico as medico FROM Turno t INNER JOIN Persona p ON t.persona.id = p.id WHERE p.id = :personaId")
    List<TurnoPersonaProjection> findTurnoPersonaProjectionByPersonaId(int personaId);

    Turno findById(int idturno);
}

注意以下几点：

• 查询语句使用了 JPQL (Java Persistence Query Language)，它是一种面向对象的查询语言，操作的是实体类和实体类的属性，而不是数据库表和字段。
• t.persona.id 用于访问 Turno 实体关联的 Persona 实体的 ID。
• :personaId 是一个参数占位符，它会被方法参数 personaId 的值替换。
• 查询语句返回的是 TurnoPersonaProjection 接口的列表，JPA 会自动将查询结果映射到该接口的实现类。

在 Service 层，可以调用 Repository 的方法来执行查询：

@Service
public class TurnoService {

    @Autowired
    private TurnoRepository turnoRepository;

    public List<TurnoPersonaProjection> getTurnoPersonaProjectionsByPersonaId(int personaId) {
        return turnoRepository.findTurnoPersonaProjectionByPersonaId(personaId);
    }
}

• 确保实体类和数据库表的映射关系正确，包括表名、字段名、数据类型等。
• 使用 JPQL 时，要注意语法和语义的正确性。
• 合理使用 Projection 可以减少查询结果的数据量，提高查询性能。
• 在复杂的查询场景下，可以考虑使用 Spring Data JPA 的 Specification 功能，它可以动态构建查询条件。

本文介绍了如何在 Spring Boot 项目中使用 JPA 实现 INNER JOIN 查询。通过定义实体类、配置 Repository，并使用 JPA 方法名约定或 @Query 注解自定义查询语句，可以方便地获取关联实体的数据。同时，使用 Projection 可以优化查询结果，提高查询性能。希望本文能帮助你更好地理解和使用 Spring Data JPA。

以上就是Spring Boot 中使用 JPA 实现 INNER JOIN 查询的详细内容，更多请关注知识资源分享宝库其它相关文章！