脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Spring Data JPA 整合QueryDSL

Spring Data JPA 整合QueryDSL的使用案例

 更新时间：2023年08月16日 10:52:28   作者：宁漂打工仔  
QueryDSL 是一个用于构建类型安全的 SQL 查询的 Java 库,它的主要目标是简化在 Java 中构建和执行 SQL 查询的过程,同时提供类型安全性和更好的编码体验,对Spring Data JPA 整合QueryDSL使用案例感兴趣的朋友跟随小编一起看看吧

QueryDSL是什么?

QueryDSL 是一个用于构建类型安全的 SQL 查询的 Java 库。它的主要目标是简化在 Java 中构建和执行 SQL 查询的过程，同时提供类型安全性和更好的编码体验。QueryDSL 可以与许多关系型数据库一起使用，如 MySQL、PostgreSQL、Oracle 等。QueryDSL 提供了一种以编程方式构建查询的方式，它使用了 Fluent API 风格的链式调用，使得查询语句更易读、易写，并且能够在编译时捕获一些常见的错误。它还提供了代码生成工具，可以生成查询实体、属性和查询类型的元数据，从而增强了代码的类型安全性。

  • 类型安全性：通过使用 Java 编程语言，QueryDSL 提供了编译时的类型安全性，避免了运行时错误。
  • Fluent API：QueryDSL 的 API 设计使得查询可以使用链式调用，提高了代码的可读性。
  • 支持多种查询类型：QueryDSL 支持查询、更新和删除操作，并且提供了丰富的表达式操作符和函数。
  • 支持关联查询：可以在查询中轻松地处理实体之间的关联关系，包括一对一、一对多、多对一和多对多等。
  • 支持 JPA 和 SQL：QueryDSL 可以与 JPA（Java Persistence API）和 SQL 一起使用，适用于不同的持久化框架和数据库。
  • 代码生成工具：QueryDSL 提供了代码生成工具，可以生成查询实体和属性的元数据，帮助提高代码的可维护性。

maven配置

      <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-jpa</artifactId>
            <version>${querydsl.version}</version>
            <classifier>jakarta</classifier>
        </dependency>
        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-apt</artifactId>
            <version>${querydsl.version}</version>
            <scope>provided</scope>
            <classifier>jakarta</classifier>
        </dependency>
 <querydsl.version>5.0.0</querydsl.version>
<build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- query dsl build Q Entity -->
            <plugin>
                <groupId>com.mysema.maven</groupId>
                <artifactId>apt-maven-plugin</artifactId>
                <version>1.1.3</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>process</goal>
                        </goals>
                        <configuration>
                            <!--<outputDirectory>target/generated-sources/java</outputDirectory>-->
                            <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

需执行 maven clean install

配置类

import com.querydsl.jpa.impl.JPAQueryFactory;
import jakarta.persistence.EntityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @author Wang
 */
@Configuration
public class JpaQueryConfig {
    @Bean
    public JPAQueryFactory jpaQuery(EntityManager entityManager) {
        return new JPAQueryFactory(entityManager);
    }
}

使用案例

import com.querydsl.core.types.Projections;
import com.querydsl.jpa.impl.JPAQueryFactory;
import com.woodare.cdw.core.Cons;
import com.woodare.cdw.jpa.data.SecondaryInvitingData;
import com.woodare.cdw.jpa.entity.QAccountEntity;
import com.woodare.cdw.jpa.entity.QBoatEntity;
import com.woodare.cdw.jpa.entity.QSecondaryInvitingEntity;
import com.woodare.cdw.jpa.entity.SecondaryInvitingEntity;
import com.woodare.cdw.jpa.enumdata.DeleteStateEnum;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
 * @author Wang
 */
@RequiredArgsConstructor
@Service
public class SecondaryInvitingDsl {
    final JPAQueryFactory queryFactory;
    public List<SecondaryInvitingData> findSecondaryInvitingByBoatId(String boatId) {
        QSecondaryInvitingEntity secondaryInvitingEntity = QSecondaryInvitingEntity.secondaryInvitingEntity;
        QAccountEntity accountEntity = QAccountEntity.accountEntity;
        return queryFactory.select(
                        Projections.bean(SecondaryInvitingData.class,
                                secondaryInvitingEntity.id,
                                secondaryInvitingEntity.accountId,
                                secondaryInvitingEntity.secondaryAccountId,
                                secondaryInvitingEntity.status,
                                secondaryInvitingEntity.inviteDate,
                                secondaryInvitingEntity.respondDate,
                                secondaryInvitingEntity.deleteDate,
                                secondaryInvitingEntity.permissions,
                                secondaryInvitingEntity.secondaryFirstName,
                                secondaryInvitingEntity.secondaryLastName,
                                secondaryInvitingEntity.secondaryEmail,
                                secondaryInvitingEntity.deleteBy,
                                accountEntity.avatar
                        ))
                .from(secondaryInvitingEntity)
                .leftJoin(accountEntity)
                .on(secondaryInvitingEntity.secondaryAccountId.eq(accountEntity.id))
                .where(
                        secondaryInvitingEntity.boatId.eq(boatId),
                        secondaryInvitingEntity.deleteState.eq(DeleteStateEnum.VALID.getValue())
                )
                .orderBy(secondaryInvitingEntity.createDate.desc())
                .fetch();
    }
    /**
     * CN 根据被邀人邮箱查询邀请记录, 并关联boatName
     *
     * @param secondaryEmail secondaryEmail
     * @param status         status
     * @return List<SecondaryInvitingData>
     */
    public List<SecondaryInvitingData> findListBySecondaryUser(String secondaryEmail, String status) {
        QSecondaryInvitingEntity secondaryInvitingEntity = QSecondaryInvitingEntity.secondaryInvitingEntity;
        QBoatEntity boatEntity = QBoatEntity.boatEntity;
        return queryFactory.select(
                        Projections.bean(SecondaryInvitingData.class,
                                secondaryInvitingEntity.id,
                                secondaryInvitingEntity.accountId,
                                secondaryInvitingEntity.secondaryAccountId,
                                secondaryInvitingEntity.status,
                                secondaryInvitingEntity.inviteDate,
                                secondaryInvitingEntity.respondDate,
                                secondaryInvitingEntity.deleteDate,
                                secondaryInvitingEntity.permissions,
                                secondaryInvitingEntity.secondaryFirstName,
                                secondaryInvitingEntity.secondaryLastName,
                                secondaryInvitingEntity.secondaryEmail,
                                secondaryInvitingEntity.deleteBy,
                                boatEntity.boatName
                        ))
                .from(secondaryInvitingEntity)
                .leftJoin(boatEntity)
                .on(secondaryInvitingEntity.boatId.eq(boatEntity.id))
                .where(
                        secondaryInvitingEntity.secondaryEmail.eq(secondaryEmail),
                        secondaryInvitingEntity.status.eq(status),
                        secondaryInvitingEntity.deleteState.eq(DeleteStateEnum.VALID.getValue()),
                        boatEntity.deleteState.eq(DeleteStateEnum.VALID.getValue())
                )
                .orderBy(secondaryInvitingEntity.createDate.desc())
                .fetch();
    }
    /**
     * CN 根据被邀人邮箱, 主邀人用户id查询邀请记录, 排除expire状态
     *
     * @param secondaryEmail secondaryEmail
     * @param accountId         accountId
     * @return List<SecondaryInvitingData>
     */
    public List<SecondaryInvitingEntity> findListBySecondaryEmailAndAccountId(String secondaryEmail, String accountId) {
        QSecondaryInvitingEntity secondaryInvitingEntity = QSecondaryInvitingEntity.secondaryInvitingEntity;
        return queryFactory.select(secondaryInvitingEntity)
                .from(secondaryInvitingEntity)
                .where(
                        secondaryInvitingEntity.secondaryEmail.eq(secondaryEmail),
                        secondaryInvitingEntity.accountId.eq(accountId),
                        secondaryInvitingEntity.status.ne(Cons.InvitingStatus.EXPIRED)
                )
                .orderBy(secondaryInvitingEntity.createDate.desc())
                .fetch();
    }
}
import cn.hutool.core.util.StrUtil;
import com.querydsl.core.BooleanBuilder;
import com.querydsl.jpa.impl.JPAQueryFactory;
import com.woodare.cdw.jpa.entity.QSensorSortEntity;
import com.woodare.cdw.jpa.entity.SensorSortEntity;
import com.woodare.cdw.jpa.enumdata.DeleteStateEnum;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
 * @author Wang
 */
@RequiredArgsConstructor
@Service
public class SensorSortDsl {
    final JPAQueryFactory queryFactory;
    public List<SensorSortEntity> findSensorSortList(String sirenDeviceId) {
        QSensorSortEntity sensorSortEntity = QSensorSortEntity.sensorSortEntity;
        return queryFactory.selectFrom(sensorSortEntity)
                .where(
                        sensorSortEntity.sirenDeviceId.eq(sirenDeviceId)
                )
                .orderBy(sensorSortEntity.parentType.asc(), sensorSortEntity.childrenType.desc())
                .fetch();
    }
    public void deleteByParam(String sirenDeviceId, String parentType, String childrenType) {
        QSensorSortEntity sensorSortEntity = QSensorSortEntity.sensorSortEntity;
        BooleanBuilder condition = new BooleanBuilder();
        if (StrUtil.isNotBlank(sirenDeviceId)) {
            condition.and(sensorSortEntity.sirenDeviceId.eq(sirenDeviceId));
        }
        if (StrUtil.isNotBlank(parentType)) {
            condition.and(sensorSortEntity.parentType.eq(parentType));
        }
        if (StrUtil.isNotBlank(childrenType)) {
            condition.and(sensorSortEntity.childrenType.eq(childrenType));
        }
        queryFactory.update(sensorSortEntity)
                .set(sensorSortEntity.deleteState, DeleteStateEnum.DELETE.getValue())
                .where(condition)
                .execute();
    }
}

到此这篇关于Spring Data JPA 整合QueryDSL的文章就介绍到这了,更多相关Spring Data JPA 整合QueryDSL内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Java中Arrays.sort自定义一维数组、二维数组的排序方式

    Java中Arrays.sort自定义一维数组、二维数组的排序方式

    这篇文章主要介绍了Java中Arrays.sort自定义一维数组、二维数组的排序方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-08-08
  • SpringBoot实现版本升级到2.7.18

    SpringBoot实现版本升级到2.7.18

    这篇文章主要介绍了SpringBoot实现版本升级到2.7.18全过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-08-08
  • Java多线程之多种锁和阻塞队列

    Java多线程之多种锁和阻塞队列

    今天带大家学习的是Java多线程的相关知识,文章围绕着java多种锁和阻塞队列展开,文中有非常详细的介绍,需要的朋友可以参考下
    2021-06-06
  • Java8 Lambda表达式详解及实例

    Java8 Lambda表达式详解及实例

    这篇文章主要介绍了Java8 Lambda表达式详解的相关资料,需要的朋友可以参考下
    2016-09-09
  • Spring Boot Actuator监控器配置及使用解析

    Spring Boot Actuator监控器配置及使用解析

    这篇文章主要介绍了Spring Boot Actuator监控器配置及使用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-07-07
  • 关于jdk环境变量的配置方式解读

    关于jdk环境变量的配置方式解读

    这篇文章主要介绍了关于jdk环境变量的配置方式解读，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2023-01-01
  • 解决springboot bean中大写的字段返回变成小写的问题

    解决springboot bean中大写的字段返回变成小写的问题

    这篇文章主要介绍了解决springboot bean中大写的字段返回变成小写的问题，具有很好的参考价值希望对大家有所帮助。一起跟随小编过来看看吧
    2021-01-01
  • Windows下java、javaw、javaws以及jvm.dll等进程的区别

    Windows下java、javaw、javaws以及jvm.dll等进程的区别

    这篇文章主要介绍了Windows下java、javaw、javaws以及jvm.dll等进程的区别,本文分别讲解了它们的作用并给出代码实例,最后做出了区别总结,需要的朋友可以参考下
    2015-03-03
  • Feign的原理及概念详解

    Feign的原理及概念详解

    文章介绍了Feign,一个声明式、模板化的HTTP客户端,以及其在Spring Cloud中的增强,Feign通过代理类简化HTTP请求的调用,并提供了详细的调用流程、优化配置和架构说明,帮助开发者更方便地进行服务调用和管理
    2025-11-11
  • Java显式锁详情

    Java显式锁详情

    这篇文章主要详细的介绍了shenJava显式锁常用的api及标准用法，感兴趣的朋友,需要的朋友可以参考下面文章里的内容
    2021-09-09

最新评论