欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Spring Data JPA 整合QueryDSL的使用案例

 更新時間：2023年08月16日 10:52:28   作者：寧漂打工仔  
QueryDSL 是一個用于構(gòu)建類型安全的 SQL 查詢的 Java 庫,它的主要目標(biāo)是簡化在 Java 中構(gòu)建和執(zhí)行 SQL 查詢的過程,同時提供類型安全性和更好的編碼體驗,對Spring Data JPA 整合QueryDSL使用案例感興趣的朋友跟隨小編一起看看吧

QueryDSL是什么?

QueryDSL 是一個用于構(gòu)建類型安全的 SQL 查詢的 Java 庫。它的主要目標(biāo)是簡化在 Java 中構(gòu)建和執(zhí)行 SQL 查詢的過程，同時提供類型安全性和更好的編碼體驗。QueryDSL 可以與許多關(guān)系型數(shù)據(jù)庫一起使用，如 MySQL、PostgreSQL、Oracle 等。QueryDSL 提供了一種以編程方式構(gòu)建查詢的方式，它使用了 Fluent API 風(fēng)格的鏈?zhǔn)秸{(diào)用，使得查詢語句更易讀、易寫，并且能夠在編譯時捕獲一些常見的錯誤。它還提供了代碼生成工具，可以生成查詢實體、屬性和查詢類型的元數(shù)據(jù)，從而增強(qiáng)了代碼的類型安全性。

  • 類型安全性：通過使用 Java 編程語言，QueryDSL 提供了編譯時的類型安全性，避免了運(yùn)行時錯誤。
  • Fluent API：QueryDSL 的 API 設(shè)計使得查詢可以使用鏈?zhǔn)秸{(diào)用，提高了代碼的可讀性。
  • 支持多種查詢類型：QueryDSL 支持查詢、更新和刪除操作，并且提供了豐富的表達(dá)式操作符和函數(shù)。
  • 支持關(guān)聯(lián)查詢：可以在查詢中輕松地處理實體之間的關(guān)聯(lián)關(guān)系，包括一對一、一對多、多對一和多對多等。
  • 支持 JPA 和 SQL：QueryDSL 可以與 JPA（Java Persistence API）和 SQL 一起使用，適用于不同的持久化框架和數(shù)據(jù)庫。
  • 代碼生成工具：QueryDSL 提供了代碼生成工具，可以生成查詢實體和屬性的元數(shù)據(jù)，幫助提高代碼的可維護(hù)性。

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>

需執(zhí)行 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 根據(jù)被邀人郵箱查詢邀請記錄, 并關(guān)聯(lián)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 根據(jù)被邀人郵箱, 主邀人用戶id查詢邀請記錄, 排除expire狀態(tài)
     *
     * @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();
    }
}

到此這篇關(guān)于Spring Data JPA 整合QueryDSL的文章就介紹到這了,更多相關(guān)Spring Data JPA 整合QueryDSL內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

最新評論