扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >关于JpaRepository的关联查询和@Query查询
  • 688

0
分享到

关于JpaRepository的关联查询和@Query查询

2024-04-02 19:04:59 688人浏览 泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录一 pom二 启动类三 配置文件四 新建数据库五 实体类1 Clazz2 Student六 控制器七 Repository层1 ClazzRepository2 StudentR

一 pom


<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>org.fkit</groupId>
     <artifactId>springdatajpaquerytest</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <packaging>jar</packaging>
     <name>springdatajpaquerytest</name>
     <url>http://maven.apache.org</url>
     <!-- spring-boot-starter-parent是Spring Boot的核心启动器，  包含了自动配置、日志和YAML等大量默认的配置，大大简化了我们的开发。
           引入之后相关的starter引入就不需要添加version配置， spring  boot会自动选择最合适的版本进行添加。 -->
     <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.0.0.RELEASE</version>
           <relativePath />
     </parent>
     <properties>
           <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
           <java.version>1.8</java.version>
     </properties>
     <dependencies>
           <!-- 添加spring-boot-starter-WEB模块依赖 -->
           <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <!-- 添加spring-boot-starter-thymeleaf模块依赖 -->
           <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
           </dependency>
           <!-- 添加Mysql依赖 -->
           <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
           </dependency>
           <!-- 添加Spring Data JPA依赖 -->
           <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
           </dependency>
           <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <scope>test</scope>
           </dependency>
     </dependencies>
</project>

二 启动类


package org.fkit.springdatajpaquerytest; 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;  
@SpringBootApplication
public class App
{
    public static void main( String[] args )
    {
        // SpringApplication 用于从main方法启动Spring应用的类。
        SpringApplication.run(App.class, args);
    }
}

三 配置文件


########################################################
### \u6570\u636E\u6E90\u4FE1\u606F\u914D\u7F6E
########################################################
# \u6570\u636E\u5E93\u5730\u5740
spring.datasource.url=jdbc:mysql://localhost:3306/springdatajpaquery
# \u7528\u6237\u540D
spring.datasource.username=root
# \u5BC6\u7801
spring.datasource.passWord=
# \u6570\u636E\u5E93\u9A71\u52A8
spring.datasource.driverClassName=com.mysql.jdbc.Driver
#  \u6307\u5B9A\u8FDE\u63A5\u6C60\u4E2D\u6700\u5927\u7684\u6D3B\u8DC3\u8FDE\u63A5\u6570.
spring.datasource.max-active=20
#  \u6307\u5B9A\u8FDE\u63A5\u6C60\u6700\u5927\u7684\u7A7A\u95F2\u8FDE\u63A5\u6570\u91CF.
spring.datasource.max-idle=8
#  \u6307\u5B9A\u5FC5\u987B\u4FDD\u6301\u8FDE\u63A5\u7684\u6700\u5C0F\u503C
spring.datasource.min-idle=8
#  \u6307\u5B9A\u542F\u52A8\u8FDE\u63A5\u6C60\u65F6\uFF0C\u521D\u59CB\u5EFA\u7ACB\u7684\u8FDE\u63A5\u6570\u91CF
spring.datasource.initial-size=10
########################################################
### JPA\u6301\u4E45\u5316\u914D\u7F6E
########################################################
# \u6307\u5B9A\u6570\u636E\u5E93\u7684\u7C7B\u578B
spring.jpa.database=MySQL
#  \u6307\u5B9A\u662F\u5426\u9700\u8981\u5728\u65E5\u5FD7\u4E2D\u663E\u793Asql\u8BED\u53E5
spring.jpa.show-sql=true
#  \u6307\u5B9A\u81EA\u52A8\u521B\u5EFA|\u66F4\u65B0|\u9A8C\u8BC1\u6570\u636E\u5E93\u8868\u7ED3\u6784\u7B49\u914D\u7F6E\uFF0C\u914D\u7F6E\u6210update
#  \u8868\u793A\u5982\u679C\u6570\u636E\u5E93\u4E2D\u5B58\u5728\u6301\u4E45\u5316\u7C7B\u5BF9\u5E94\u7684\u8868\u5C31\u4E0D\u521B\u5EFA\uFF0C\u4E0D\u5B58\u5728\u5C31\u521B\u5EFA\u5BF9\u5E94\u7684\u8868
spring.jpa.hibernate.ddl-auto=update
# Naming strategy
# \u6307\u5B9A\u547D\u540D\u7B56\u7565
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.ImprovedNamingStrategy
# \u6307\u5B9A\u6570\u636E\u5E93\u65B9\u8A00
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

四 新建数据库

springdatajpaquery

五 实体类

1 Clazz


package org.fkit.springdatajpaquerytest.bean;  
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
  
@Entity
@Table(name="tb_clazz")
public class Clazz implements Serializable{
    
    private static final long serialVersionUID = 1L;
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int code ;
    private String name ;
    // 班级与学生是一对多的关联
    @OneToMany(
               fetch=FetchType.LAZY,
               targetEntity=Student.class,
               mappedBy="clazz"
            )     
    private Set<Student> students = new HashSet<>();
    
    public Clazz() {
        
    }
    // 班级对象
    public Clazz(String name) {
        this.name = name;
    }
    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

2 Student


package org.fkit.springdatajpaquerytest.bean;  
import java.io.Serializable;  
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
  
@Entity
@Table(name="tb_student")
public class Student implements Serializable{    
    private static final long serialVersionUID = 1L;    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name ;
    private String address ;
    private int age ;
    private char sex;
    // 学生与班级是多对一的关系，这里配置的是双向关联
    @ManyToOne(fetch=FetchType.LAZY,
            targetEntity=Clazz.class
            )
    @JoinColumn(name="clazzId",referencedColumnName="code")
    private Clazz clazz ;
    public Student() {
  
    }
    public Student(String name, String address, int age, char sex,
            Clazz clazz) {
        super();
        this.name = name;
        this.address = address;
        this.age = age;
        this.sex = sex;
        this.clazz = clazz;
    }
    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 getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public Clazz getClazz() {
        return clazz;
    }
    public void setClazz(Clazz clazz) {
        this.clazz = clazz;
    }
}

六 控制器


package org.fkit.springdatajpaquerytest.controller;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.fkit.springdatajpaquerytest.bean.Clazz;
import org.fkit.springdatajpaquerytest.bean.Student;
import org.fkit.springdatajpaquerytest.service.SchoolService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
  
@RestController
@RequestMapping("/student")
public class StudentController {
    
    // 注入ShcoolService
    @Resource
    private SchoolService schoolService;
    @RequestMapping("/save")
    public String save() {
        
        Clazz clazz1 = new Clazz("疯狂java开发1班");
        Clazz clazz2 = new Clazz("疯狂java开发2班");
        // 保存班级对象数据
        List<Clazz> clazzs = new ArrayList<>();
        clazzs.add(clazz1);
        clazzs.add(clazz2);
        schoolService.saveClazzAll(clazzs);
        
        Student swk = new Student("孙悟空","广州",700,'男',clazz1);
        Student zzj = new Student("蜘蛛精","广州",700,'女',clazz1);
        Student nmw = new Student("牛魔王","广州",500,'男',clazz2);
        
        List<Student> students = new ArrayList<>();
        students.add(swk);
        students.add(zzj);
        students.add(nmw);
        schoolService.saveStudentAll(students);
        return "保存学生对象成功";
    }
    
    @RequestMapping("/getClazzStus")
    public List<Map<String, Object>> getClazzStus(String clazzName){
        return schoolService.getStusByClazzName(clazzName);
    }
    
    @RequestMapping("/findNameAndSexByClazzName")
    public List<Map<String, Object>> findNameAndSexByClazzName(String clazzName){
        return schoolService.findNameAndSexByClazzName(clazzName);
    }
    
    @RequestMapping("/findNameByClazzNameAndSex")
    public List<String> findNameByClazzNameAndSex(String clazzName ,Character sex){
        return schoolService.findNameByClazzNameAndSex(clazzName ,sex);
    }
    
    @RequestMapping("/findClazzNameByStuName")
    public String findClazzNameByStuName(String stuName){
        return schoolService.findClazzNameByStuName(stuName);
    }
    
    @RequestMapping("/deleteStuByStuName")
    public String deleteStuByStuName(String stuName){
        return "删除数据："+schoolService.deleteStuByStuName(stuName);
    }    
}

七 Repository层

1 ClazzRepository


package org.fkit.springdatajpaquerytest.repository;
import org.fkit.springdatajpaquerytest.bean.Clazz;
import org.springframework.data.jpa.repository.JpaRepository; 
public interface ClazzRepository extends JpaRepository<Clazz, Integer> {    
}

2 StudentRepository


package org.fkit.springdatajpaquerytest.repository;
import java.util.List;
import java.util.Map;  
import org.fkit.springdatajpaquerytest.bean.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;  
public interface StudentRepository extends JpaRepository<Student, Integer> {
    
    
    List<Student> findByClazz_name(String clazzName);
    
    
    @Query("select s from Student s where s.clazz.name = ?1")
    List<Student> findStudentsByClazzName(String clazzName);
    
    @Query("select new Map(s.name as name , s.sex as sex) "
            + "from Student s where s.clazz.name = ?1")
    List<Map<String, Object>> findNameAndSexByClazzName(String clazzName);
    
    
    @Query("select s.name from Student s "
            + "where s.clazz.name = :clazzName and s.sex = :sex ")
    List<String> findNameByClazzNameAndSex(@Param("clazzName")String clazzName , @Param("sex")char sex);
    
    @Query("select c.name from Clazz c inner join c.students s "
            + "where s.name = ?1 ")
    String findClazzNameByStuName(String stuName);
    
    @Modifying
    @Query("delete from Student s where s.name = ?1")
    int deleteStuByStuName(String stuName);
}

八 Service层


package org.fkit.springdatajpaquerytest.service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.fkit.springdatajpaquerytest.bean.Clazz;
import org.fkit.springdatajpaquerytest.bean.Student;
import org.fkit.springdatajpaquerytest.repository.ClazzRepository;
import org.fkit.springdatajpaquerytest.repository.StudentRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class SchoolService {
    
    // 注入数据访问层接口对象
    @Resource
    private StudentRepository studentRepository;
    @Resource
    private ClazzRepository clazzRepository;
    
    @Transactional
    public void saveClazzAll(List<Clazz> clazzs) {
        clazzRepository.saveAll(clazzs);
    }
    @Transactional
    public void saveStudentAll(List<Student> students) {
        studentRepository.saveAll(students);
    }
    
    public List<Map<String, Object>> getStusByClazzName(String clazzName) {
        // 使用"_" 和 @Query查询方式结果一致
        List<Student> students = studentRepository.findByClazz_name(clazzName);
//        List<Student> students = studentRepository.findStudentsByClazzName(clazzName);
        List<Map<String, Object>>  results = new ArrayList<>();
        // 遍历查询出的学生对象，提取姓名，年龄，性别信息
        for(Student student:students){
            Map<String , Object> stu = new HashMap<>();
            stu.put("name", student.getName());
            stu.put("age", student.getAge());
            stu.put("sex", student.getSex());
            results.add(stu);
        }
        return results;
    }
    public List<Map<String, Object>> findNameAndSexByClazzName(String clazzName) {
        return studentRepository.findNameAndSexByClazzName(clazzName);
    }
    public List<String> findNameByClazzNameAndSex(
            String clazzName, char sex) {
        return studentRepository.findNameByClazzNameAndSex(clazzName, sex);
    }
    public String findClazzNameByStuName(String stuName) {
        return studentRepository.findClazzNameByStuName(stuName);
    }
    @Transactional
    public int deleteStuByStuName(String stuName) {
        return studentRepository.deleteStuByStuName(stuName);
    }
}

九 测试

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。

您可能感兴趣的文档:

--结束END--

本文标题: 关于JpaRepository的关联查询和@Query查询

本文链接: https://lsjlt.com/news/158355.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 关于JpaRepository的关联查询和@Query查询
    目录一 pom二 启动类三 配置文件四 新建数据库五 实体类1 Clazz2 Student六 控制器七 Repository层1 ClazzRepository2 StudentR...
    99+
    2024-04-02
  • 如何理解JpaRepository的关联查询和@Query查询
    如何理解JpaRepository的关联查询和@Query查询，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。一 pom<project xmlns=&quo...
    99+
    2023-06-21
  • SQL 关联子查询
    目录一、普通的子查询和关联子查询的区别二、关联子查询也是用来对集合进行切分的三、结合条件一定要写在子查询中请参阅 学习重点 关联子查询会在细分的组内进行比较时使用。 关联子查询和 GROUP BY 子句一样，也可以对表中的数据进...
    99+
    2016-06-28
    SQL 关联子查询
  • SQL关联查询 直接join 和子查询的区别
    运营组的同事最近提出一个需求，希望可以统计出用系统用户及订单情况，于是乎我们很想当然的写出了一个统计SQL，用户表user和行程表直接join，并且针对行程做了group，但SQL执行速度出奇的慢。 exp...
    99+
    2024-04-02
  • 数据库中关联子查询和非关联子查询有什么区别
    本篇内容主要讲解“数据库中关联子查询和非关联子查询有什么区别”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“数据库中关联子查询和非关联子查询有什么区别”吧!子查询...
    99+
    2024-04-02
  • MySQL之自关联查询
    假设要设计两张表，一张省份表（provinces），一张城市表（citys） 省份表结构 id ptitle 城市表结构 id ctitle proid（表示城市所属的省，对应着省份表的id值） 观察两张表可以发现，城市表...
    99+
    2016-06-02
    MySQL之自关联查询
  • MyBatis 多表关联查询
    ✅作者简介：2022年博客新星 第八。热爱国学的Java后端开发者，修心和技术同步精进。 🍎个人主页：Java Fans的博客 🍊个人信条：不迁怒，不贰过。小知识...
    99+
    2023-09-01
    mybatis java mysql
  • Mysql 多表关联查询
    文章目录 1. Mysql中表之间的关系1.1 多表关系1.2 外键约束 2. 多表联合查询2.1 交叉连接查询：笛卡尔积2.2 内连接查询：inner join2.3 外连接查询2.3.1 左连接：2.3.2 右连接：2.3....
    99+
    2023-08-21
    mysql 数据库 sql
  • MySQL的多表关联查询
    一、多表关联查询 多表关联查询是使用一条SQL语句，将关联的多张表的数据查询出来。 1.1 交叉查询 交叉查询就是将多张表的数据没有条件地连接在一起进行展示。 1.1.1 语法 使用交叉查询类别和商品 -- 目标：查询所有分类，以及每个分类...
    99+
    2023-08-22
    mysql 数据库 java
  • 关于QueryWrapper,实现MybatisPlus多表关联查询方式
    目录QueryWrapper实现MybatisPlus多表关联查询1.dao层接口使用Select注解写SQL2.service层代码示例3.反射工具类4.判空工具类Myb...
    99+
    2024-04-02
  • sql三表关联查询怎么查
    sql 三表关联查询涉及以下步骤：选择表连接类型（inner join、left join、right join、full join）使用 on 关键字指定关联条件（左表字段 = 右表字...
    99+
    2024-06-04
  • mysql跨库关联查询（dblink）
    dblink 1、解决方案2、操作3、缺点 1、解决方案 mysql是不支持跨库连接的，如果我们实在要连接的话可以用dblink方式。 解释： dblink就是我们在创建表的时候连接到...
    99+
    2023-09-05
    mysql
  • Mybatis表的关联查询详情
    目录导语什么时候用＜resultMap＞标签映射什么时候用<association>＆<collection>Mybatis表的关联查询一对多查询多对一查询一...
    99+
    2024-04-02
  • laravel中join关联查询的案例
    这篇文章给大家分享的是有关laravel中join关联查询的案例的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。laravel join关联查询1、两表关联$fbaInventoryTb = (...
    99+
    2023-06-14
  • 如何实现JPQL的关联查询
    小编给大家分享一下如何实现JPQL的关联查询，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！从一关联到多的查询和从多关联到一的查询来简单说说关联查询。实体Team：...
    99+
    2023-06-17
  • mysql关联查询如何优化
    小编给大家分享一下mysql关联查询如何优化，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！ mysq...
    99+
    2024-04-02
  • Thinkphp 6.0多对多关联查询
    本节课我们来了解关联模型中，多对多的关联查询以及新增删除等操作。 一．多对多关联 1. 复习一下一对一，一个用户对应一个用户档案资料，是一对一关联； 2. 复习一下一对多，一篇文章对应多个评论，是一对多关联；...
    99+
    2023-09-05
    php 数据库 mysql
  • sql三表关联怎么查询
    三表关联是一种 sql 查询技术，通过指定连接条件将三个或更多表连接起来获取信息。主要有三种关联类型：内连接，左外连接和右外连接。使用 join 语句进行三表关联，指定连接表之间的列相等...
    99+
    2024-05-30
  • 关于MySQL8的WITH查询学习
    目录前言示例练习总结 前言 对于逻辑复杂的sql，with可以大大减少临时表的数量，提升代码的可读性、可维护性 MySQL 8.0终于开始支持with语句了，对于复杂查询，可以不用写那么多的临时表了。 可以查看官方文档【点击跳转】 示...
    99+
    2021-11-25
    关于MySQL8的WITH查询学习
  • 关于elasticsearch的match_phrase_prefix查询详解
    目录match_phrasematch_phrase_prefix需要注意的点总结match_phrase match_phrase_prefix可以认为是match_phrase的...
    99+
    2023-03-21
    关于elasticsearch match_phrase_prefix match_phrase_prefix查询 关于elasticsearc
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作