QueryDSL学习笔记

最新推荐文章于 2024-08-09 07:13:59 发布
最新推荐文章于 2024-08-09 07:13:59 发布
阅读量1.7k 收藏 8
点赞数 2
分类专栏： ORM

QueryDSL简介

  1. QueryDSL仅仅是一个通用的查询框架，专注于通过Java API构建类型安全的SQL查询。
  2. Querydsl可以通过一组通用的查询API为用户构建出适合不同类型ORM框架或者是SQL的查询语句，也就是说QueryDSL是基于各种ORM框架以及SQL之上的一个通用的查询框架。
  3. 借助QueryDSL可以在任何支持的ORM框架或者SQL平台上以一种通用的API方式来构建查询。目前QueryDSL支持的平台包括JPA,JDO,SQL,Java
    Collections,RDF,Lucene,Hibernate Search。
    使用QueryDSL需先通过Maven插件编译自动生成实体类型的结构查询实体。
    mvn clean complie
package com.ly.domain;

import static com.querydsl.core.types.PathMetadataFactory.*;
import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.PathMetadata;
import javax.annotation.Generated;
import com.querydsl.core.types.Path;

/**
 * QBank is a Querydsl query type for Bank
 */
@Generated("com.querydsl.codegen.EntitySerializer")
public class QBank extends EntityPathBase<Bank> {

    private static final long serialVersionUID = -1720494478L;

    public static final QBank bank = new QBank("bank");

    public final StringPath bankType = createString("bankType");

    public final DateTimePath<java.util.Date> gmtCreate = createDateTime("gmtCreate", java.util.Date.class);

    public final DateTimePath<java.util.Date> gmtModified = createDateTime("gmtModified", java.util.Date.class);

    public final NumberPath<Long> id = createNumber("id", Long.class);

    public final NumberPath<Long> isDeleted = createNumber("isDeleted", Long.class);

    public final StringPath name = createString("name");

    public final NumberPath<Long> ordernum = createNumber("ordernum", Long.class);

    public QBank(String variable) {
        super(Bank.class, forVariable(variable));
    }

    public QBank(Path<? extends Bank> path) {
        super(path.getType(), path.getMetadata());
    }

    public QBank(PathMetadata metadata) {
        super(Bank.class, metadata);
    }

}

使用范例
单表查询

       public User findUserByUserName(final String userName){
	 	/**
		 * 该例是使用spring data QueryDSL实现
		 */
		QUser quser = QUser.user;
		Predicate predicate = quser.name.eq(userName);
		return repository.findOne(predicate);
	}
	
	/**
	 * attention:
	 * Details：查询user表中的所有记录
	 */
	public List<User> findAll(){
		QUser quser = QUser.user;
		return queryFactory.selectFrom(quser)
					.fetch();
	}
	
	/**
	 * Details：单条件查询
	 */
	public User findOneByUserName(final String userName){
		QUser quser = QUser.user;
		return queryFactory.selectFrom(quser)
			.where(quser.name.eq(userName))
			.fetchOne();
	}
	
	/**
	 * Details：单表多条件查询
	 */
	public User findOneByUserNameAndAddress(final String userName, final String address){
		QUser quser = QUser.user;
		return queryFactory.select(quser)
			.from(quser) // 上面两句代码等价与selectFrom
			.where(quser.name.eq(userName).and(quser.address.eq(address)))// 这句代码等同于where(quser.name.eq(userName), quser.address.eq(address))
			.fetchOne();
	}
	
	/**
	 * Details：使用join查询
	 */
	public List<User> findUsersByJoin(){
		QUser quser = QUser.user;
		QUser userName = new QUser("name");
		return queryFactory.selectFrom(quser)
			.innerJoin(quser)
			.on(quser.id.intValue().eq(userName.id.intValue()))
			.fetch();
	}
	
	/**
	 * Details：将查询结果排序
	 */
	public List<User> findUserAndOrder(){
		QUser quser = QUser.user;
		return queryFactory.selectFrom(quser)
			.orderBy(quser.id.desc())
			.fetch();
	}
	
	/**
	 * Details：Group By使用
	 */
	public List<String> findUserByGroup(){
		QUser quser = QUser.user;
		return queryFactory.select(quser.name)
					.from(quser)
					.groupBy(quser.name)
					.fetch();
	}
	
	/**
	 * Details：删除用户
	 */
	public long deleteUser(String userName){
		QUser quser = QUser.user;
		return queryFactory.delete(quser).where(quser.name.eq(userName)).execute();
	}
	
	/**
	 * Details：更新记录
	 */
	public long updateUser(final User u, final String userName){
		QUser quser = QUser.user;
		return queryFactory.update(quser).where(quser.name.eq(userName))
			.set(quser.name, u.getName())
			.set(quser.age, u.getAge())
			.set(quser.address, u.getAddress())
			.execute();
	}
	
	/**
	 * Details：使用原生Query
	 */
	public User findOneUserByOriginalSql(final String userName){
		QUser quser = QUser.user;
		Query query = queryFactory.selectFrom(quser)
				.where(quser.name.eq(userName)).createQuery();
		return (User) query.getSingleResult();
	}
	
	/**
	 * Details：分页查询单表
	 */
	public Page<User> findAllAndPager(final int offset, final int pageSize){
		Predicate predicate = QUser.user.id.lt(10);
		Sort sort = new Sort(new Sort.Order(Sort.Direction.DESC, "id"));
		PageRequest pr = new PageRequest(offset, pageSize, sort);
		return repository.findAll(predicate, pr);
	}

多表操作示例(一对一)


    /**
     * Details：多表动态查询
     */
    public List<Tuple> findAllPersonAndIdCard(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate);
        return jpaQuery.fetch();
    }
    
    /**
     * Details：将查询结果以DTO的方式输出
     */
    public List<PersonIDCardDto> findByDTO(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate);
        List<Tuple> tuples = jpaQuery.fetch();
        List<PersonIDCardDto> dtos = new ArrayList<PersonIDCardDto>();
        if(null != tuples && !tuples.isEmpty()){
            for(Tuple tuple:tuples){
                String address = tuple.get(QPerson.person.address);
                String name = tuple.get(QPerson.person.name);
                String idCard = tuple.get(QIDCard.iDCard.idNo);
                PersonIDCardDto dto = new PersonIDCardDto();
                dto.setAddress(address);
                dto.setIdNo(idCard);
                dto.setName(name);
                dtos.add(dto);
            }
        }
        return dtos;
    }
    
    /**
     * Details：多表动态查询，并分页
     */
    public QueryResults<Tuple> findByDtoAndPager(int offset, int pageSize){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .offset(offset)
                .limit(pageSize)
                .fetchResults();
    }


/**
     * Details：方式一：使用Bean投影
     */
    public List<PersonIDCardDto> findByDTOUseBean(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(
                Projections.bean(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .fetch();
    }
    
    /**
     * Details：方式二：使用fields来代替setter
     */
    public List<PersonIDCardDto> findByDTOUseFields(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(
                Projections.fields(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .fetch();
    }
    
    /**
     * Details：方式三：使用构造方法，注意构造方法中属性的顺序必须和构造器中的顺序一致
     */
    public List<PersonIDCardDto> findByDTOUseConstructor(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(
                Projections.constructor(PersonIDCardDto.class, QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo))
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .fetch();
    }

更多方式详见

Tom4J
关注
专栏目录
Querydsl：强大且灵活的Java查询语言框架
gitblog_00034的博客
03-21 444
Querydsl：强大且灵活的Java查询语言框架 querydslUnified Queries for Java项目地址:https://gitcode.com/gh_mirrors/qu/querydsl 是一个开源的Java框架，用于生成类型安全的查询语句，它让你能够以一种结构化的方式处理SQL、JPA、JDO、Lucene等查询。本文将深入探讨Querydsl的功能，技术实现，应用场景...
querydsl中文文档
09-29
querydsl中文文档，旨在帮助使用QueryDSL的开发程序人员使用
Querydsl
xiaomin1991222的专栏
08-10 280
Querydsl是一个Java开源框架用于构建类型安全的SQL查询语句。它采用API代替拼凑字符串来构造查询语句。可跟 Hibernate 和 JPA 等框架结合使用。 基本查询： ? 1 2 3 4 5 6 JPAQuery query = new JPAQuery(entityManager); List&lt;Person&gt; per...
Querydsl 使用教程
最新发布
gitblog_00224的博客
08-09 569
Querydsl 使用教程 querydslUnified Queries for Java项目地址:https://gitcode.com/gh_mirrors/qu/querydsl 项目介绍 Querydsl 是一个框架，它使得在 Java 中构建类型安全的 SQL 类查询成为可能。它支持多种后端，包括 JPA、MongoDB 和 SQL。Querydsl 的主要优势在于其紧凑、安全和易于...
QueryDSL
qq_23204557的博客
06-02 234
QueryDSL介绍
qq_35491812的博客
10-22 5674
1，QueryDSL仅仅是一个通用的查询框架，专注于通过Java API构建类型安全的SQL查询。 2，Querydsl可以通过一组通用的查询API为用户构建出适合不同类型ORM框架或者是SQL的查询语句，也就是说QueryDSL是基于各种ORM框架以及SQL之上的一个通用的查询框架。 3，借助QueryDSL可以在任何支持的ORM框架或者SQL平台上以一种通用的API方式来构建查询。目前Qu...
Hibernate学习笔记
03-22
**Hibernate学习笔记** 在Java开发领域，Hibernate是一个非常重要的对象关系映射（ORM）框架，它简化了数据库操作，使得开发者可以使用面向对象的方式来处理数据。这篇笔记将深入探讨Hibernate的核心概念、工作原理...
hibernate学习笔记_北大青鸟课堂笔记全文
02-10
【hibernate学习笔记_北大青鸟课堂笔记全文】 Hibernate是一个强大的对象关系映射（ORM）框架，它为Java开发者提供了便捷的数据持久化方案。在Java应用中，尤其是在企业级开发中，它扮演着至关重要的角色，使得我们...
hibernate五天学习笔记（txt）
10-24
【hibernate五天学习笔记】是一份详细的Java ORM框架Hibernate的学习资料，旨在帮助开发者深入理解和掌握Hibernate的核心概念和技术。ORM(Object-Relational Mapping)是将数据库中的关系数据与Java对象进行映射的...
Hibernate学习笔记!
07-30
**Hibernate学习笔记** Hibernate是一个强大的Java对象关系映射（ORM）框架，它为开发者提供了在Java应用程序中操作数据库的强大工具。本笔记将深入探讨Hibernate的核心概念、配置、实体管理、查询语言以及最佳实践...
Querydsl_Reference.pdf
08-13
Querydsl是一个Java开源框架用于构建类型安全的SQL查询语句。它采用API代替拼凑字符串来构造查询语句。可跟 Hibernate 和 JPA 等框架结合使用。 Querydsl API文档，标准接口使用例
querydsl 官方文档
11-23
学习queryDsl最好的教材，掌握第一手资料，大家一起进步啊
Querydsl中文文档翻译.pdf
06-14
1. 介绍 1.1. 背景 Querydsl 能够诞生， 是因为需要在类型安全的方式下进行HQL查询。 构造的HQL查 询需要拼接字符串， 并且会导致代码难以阅读。 通过纯字符串对领域类型和属性的 不安全引用是基于字符串构建HQL的另一个问题。 随着类型安全的领域模型的不断的发展， 给软件开发带了巨大的好处。 领域最大的 改变直接反应在查询和自动查询的构建， 它使查询构建更快且安全。 Querydsl最先支持的是Hibernate的HQL语言， 现如今， Querydsl已经支持JPA， JDO， JDBC， Lucene， Hibernate Search， MangoDB， Collections 和 RDF(Relational Data Format) Bean作为后端。 1.2. 原则 类型安全是Querydsl的核心原则。 查询是基于与领域类型的属性映射生成的查询类 型构建的。 同时， 函数/方法的调用也是使用完全的类型安全的方式构建的。 保持一致是另一个重要的原则。 查询路径(Path)和操作在所有实现中都是相同的， 它们都具有一个公用的基本接口。 要想获得更多Querydsl查询和表达式的说明， 请查看javadoc中的 com.querydsl.core.Query ， com.querydsl.core.Fetchable 和 com.querydsl.core.types.Expression 类的文档。
querydsl-jpa-codegen-3.3.3.zip
10-12
JBugmenot.zip,Java Bugmenot库用于查找各种站点的帐户和密码。Java Bugmenot库用于查找各种站点的帐户和密码。
SpringBoot+Querydsl 框架，大大简化复杂查询操作
Moonxiyue的博客
06-01 295
本篇博客主要将介绍的是利用spring query dsl框架实现的服务端查询解析和实现介绍。 查询功能是在各种应用程序里面都有应用，且非常重要的功能。用户直接使用的查询功能往往是在我们做好的UI界面上进行查询，UI会将查询请求发给查询实现的服务器，或者专门负责实现查询的一个组件。市场上有专门做查询的框架，其中比较出名，应用也比较广泛的是elasticsearch。对于服务端来说，前端UI发送过来的查询请求必然是按一定规则组织起来的，这样的规则后端必须能够支持和解析。换一种说法就是服务调用者和服务发布者之间
Elasticsearch
weixin_42584958的博客
06-24 111
ElasticsearchElasticsearch简介安装启动 Elasticsearch简介 基于Lucene的开源分布式搜索引擎，大幅降低了PB级海量数据存储、检索、分析门槛 特点： 分布式实时文件存储、检索、分析 零配置、集群自动发现 索引自动分片、副本机制 RESTful风格接口 多数据源 自动搜索负载 安装启动 #切换至非root用户 #前台运行，停止方式CTRL+C ./opt/es/bin/elasticsearch #前台运行 #后台运行，停止方式 kill -9 pid 后
JPA 复杂查询 - Querydsl
weixin_34049032的博客
11-22 234
添加依赖 <!--query dsl --> <dependency> <groupId>com.querydsl</groupId> <artifactId>querydsl-jpa</artifactId&g...
开启您的类型安全查询之旅：Querydsl —— 构建者友好型 SQL 查询框架
gitblog_00017的博客
06-25 445
???? 开启您的类型安全查询之旅：Querydsl —— 构建者友好型 SQL 查询框架 querydslUnified Queries for Java项目地址:https://gitcode.com/gh_mirrors/que/querydsl 在当今快速发展的软件开发领域中，数据库查询的编写往往是复杂且容易出错的过程。但今天，我们向您介绍一款强大的开源工具——Querydsl，它不仅简化了J...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值