Querydsl：Java查询框架

最新推荐文章于 2025-07-22 11:43:27 发布

zzm_

最新推荐文章于 2025-07-22 11:43:27 发布

阅读量436

点赞数

CC 4.0 BY-SA版权

文章标签： java

原文链接：https://my.oschina.net/liuyuanyuangogo/blog/829626

本文介绍了Querydsl这一Java查询框架的基本概念与优势，并通过具体示例展示了如何在实际项目中运用Querydsl进行类型安全的SQL查询构建。

2019独角兽企业重金招聘Python工程师标准>>>

参考文章：http://xiexiejiao.cn/java/querydsl-1-9-5-release-download.html

Querydsl 4.1.0 API：http://www.querydsl.com/static/querydsl/4.1.0/reference/html_single/

Querydsl是什么？

与Hibernate等ORM工具不同的是： 1.Querydsl仅仅是一个通用的查询框架；

2.只专注于通过Java API构建类型安全的SQL查询。

3.Querydsl可以通过一组通用的查询api为用户构建出适合不同类型ORM框架或者是SQL的查询语句。也就是说 Querydsl是基于各种ORM框架以及SQL至上的一个通用的查询框架。

4.借助Querydsl可以在任何支持的ORM框架或者SQL平台上以一种通用的API方式来构建查询。目前Querydsl支持的平台包括JPA,JDO，SQL，Java Collections，RDF，Lucene，Hibernate Search。

注意：ORM框架是什么？待回答。

Querydsl的优势：

Querydsl支持代码自动完成（因为用纯Java API编写查询，因此主流Java IDE对它的代码自动完成功能支持几乎可以发挥到极致）；
Querydsl几乎可以避免所有的SQL语法错误（当然用错了Querydsl API除外，因为不直接写SQL了所以不会出现语法错误）；
Querydsl采用Domain类型的对象和属性来构建查询，因此查询绝对是类型安全的，不会因为条件类型而出现问题；
Querydsl采用纯Java API作为SQL构建的实现可以让代码重构发挥到另一个高度（这也是Criteria让笔者十分喜爱的主要原因之一）；
Querydsl的另一个优势就是可以更轻松的进行增量查询的定义；

应用开发调试过程中Querydsl生成的sql语句的查看和性能检测 1.可以通过在配置文件中配置JPA是否ShowSQL（如Spring是ApplicationContext），在程序运行过程中，可以查看生成的具体SQL语句，但语句不带参数。

@Bean
   public LocalContainerEntityManagerFactoryBean entityManagerFactory()
   {
       HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
       jpaVendorAdapter.setDatabase(Database.valueOf(env.getProperty("jpa.database")));
       jpaVendorAdapter.setGenerateDdl(env.getProperty("jpa.generateDdl", Boolean.class));
       jpaVendorAdapter.setShowSql(env.getProperty("jpa.showSql", Boolean.class));
       
       LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
       emf.setJpaVendorAdapter(jpaVendorAdapter);
       emf.setDataSource(dataSource());
       
       return emf;
   }

2.通过配置log4jdbc，在程序运行过程中，可以查看生成的sql（带参数），以及sql执行所使用的时间。如：postgresql数据库需要：postgresql的驱动jar包，log4jdbc.jar 在log4j.properties中配置：

# Log4Jdbc
log4j.logger.jdbc.sqlonly=ERROR, stdout
log4j.logger.jdbc.sqltiming=INFO
log4j.logger.jdbc.audit=ERROR, stdout
log4j.logger.jdbc.resultset=ERROR, stdout
log4j.logger.jdbc.connection=ERROR, stdout

示例：

package com.lyy.project.entity;

import java.io.Serializable;
import javax.persistence.*;
import java.sql.Timestamp;
import java.util.List;
/**
 * The persistent class for the "user_info" database table.
 */
@Entity
@Table(name="user_info")
@NamedQuery(name="UserInfo.findAll", query="SELECT u FROM UserInfo u")
public class UserInfo implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="id")
	private long id;

	@Column(name="create_time", insertable=false, updatable=false, 
			columnDefinition="timestamp without time zone DEFAULT now()")
	private Timestamp createTime;

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

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

	@Column(name="role", insertable=false)//, columnDefinition="integer default '0'"
	private int role;

	@GeneratedValue(strategy=GenerationType.TABLE)
	@Column(name="status", insertable=false)//, columnDefinition="integer default '0'"
	private int status;
	
	@OneToOne(mappedBy="userInfo",fetch=FetchType.LAZY, 
			cascade={CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.MERGE})
	private UserThreshold userThreshold;	
	
	public UserInfo() 
	{
		//define default value
		role = 0;
		status = 0;	
	}
	
	public long getId() {
		return this.id;
	}
	public void setId(long id) {
		this.id = id;
	}


	public Timestamp getCreateTime() {
		return this.createTime;
	}
	public void setCreateTime(Timestamp createTime) {
		this.createTime = createTime;
	}

        public String getUsername() {
		return this.username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	
	public String getPassword() {
		return this.password;
	}
	public void setPassword(String password) {
		this.password = password;
	}


	public int getRole() {
		return this.role;
	}
	public void setRole(int role) {
		this.role = role;
	}

	public int getStatus() {
		return this.status;
	}
	public void setStatus(int status) {
		this.status = status;
	}

	
	public List<DataGuard> getDgDataguards() {
		return this.dgDataguards;
	}
	public void setDgDataguards(List<DataGuard> dgDataguards) {
		this.dgDataguards = dgDataguards;
	}

	public UserThreshold getUserThreshold() {
		return userThreshold;
	}
	public void setUserThreshold(UserThreshold userThreshold) {
		this.userThreshold = userThreshold;
	}
}


package com.lyy.project.entity.q;

import static com.querydsl.core.types.PathMetadataFactory.*;
import com.lyy.project.entity.UserInfo;
import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.PathMetadata;
import javax.annotation.Generated;
import com.querydsl.core.types.Path;
import com.querydsl.core.types.dsl.PathInits;
/**
 * QUserInfo is a Querydsl query type for UserInfo
 */
@Generated("com.querydsl.codegen.EntitySerializer")
public class QUserInfo extends EntityPathBase<UserInfo> {

    private static final long serialVersionUID = 1239090079L;

    private static final PathInits INITS = PathInits.DIRECT2;

    public static final QUserInfo userInfo = new QUserInfo("userInfo");

    public final DateTimePath<java.sql.Timestamp> createTime = createDateTime("createTime", java.sql.Timestamp.class);

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

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

    public final NumberPath<Integer> role = createNumber("role", Integer.class);

    public final NumberPath<Integer> status = createNumber("status", Integer.class);

    public final QUserThreshold userThreshold;
   
    public QUserInfo(String variable) {
        this(UserInfo.class, forVariable(variable), INITS);
    }

    public QUserInfo(Path<? extends UserInfo> path) {
        this(path.getType(), path.getMetadata(), path.getMetadata().isRoot() ? INITS : PathInits.DEFAULT);
    }

    public QUserInfo(PathMetadata metadata) {
        this(metadata, metadata.isRoot() ? INITS : PathInits.DEFAULT);
    }

    public QUserInfo(PathMetadata metadata, PathInits inits) {
        this(UserInfo.class, metadata, inits);
    }

    public QUserInfo(Class<? extends UserInfo> type, PathMetadata metadata, PathInits inits) {
        super(type, metadata, inits);
        this.userThreshold = inits.isInitialized("userThreshold") ? new QUserThreshold(forProperty("userThreshold"), inits.get("userThreshold")) : null;
    }

}

package com.lyy.project.dao;

import java.util.List;
import com.lyy.project.entity.UserInfo;
public interface UserInfoDAO
{
    UserInfo getUserInfoByName(String username);
	void addUserInfo(UserInfo user);	
	void removeUserInfo(UserInfo user);
	UserInfo getUserInfoByID(long userID);
	List<UserInfo> getAllUsers();
}



package com.lyy.project.dao.Impl;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import com.lyy.project.dao.UserInfoDAO;
import com.lyy.project.entity.UserInfo;
import com.lyy.project.entity.q.QUserInfo;
import com.querydsl.jpa.impl.JPAQuery;
@Repository
public class UserInfoDAOImpl implements UserInfoDAO
{
    private final Logger logger = LoggerFactory.getLogger(getClass());
    
    @PersistenceContext
    private EntityManager em;
    
    @Override
    public UserInfo getUserInfoByName(String username)
    {
        logger.debug("Enter, username = " + username);
        
        QUserInfo ui = QUserInfo.userInfo;
        JPAQuery<UserInfo> query = new JPAQuery<>(em);        
        query.from(ui).where(ui.username.eq(username));
        UserInfo user = query.fetch().get(0);//with threshold
        
        logger.debug("return");
        return user;
    }
    
    @Override
    public UserInfo getUserInfoByID(long userID)
    {
        logger.debug("Enter, userid = " + userID);
        
        QUserInfo ui = QUserInfo.userInfo;
        JPAQuery<UserInfo> query = new JPAQuery<>(em);        
        query.from(ui).where(ui.id.eq(userID));//注意，查询中引用的字段是QUserInfo中定义的public类型字段。
        UserInfo user = query.fetch().get(0);//with threshold
        
        logger.debug("return");
        return user;
    }
    
    @Override
    public void addUserInfo(UserInfo user)
    {
    	logger.debug("Enter:username="+user.getUsername());    	
		
    	em.persist(user);
    	
    	logger.debug("Return:userid="+user.getId());
    }
    
    @Override
    public void removeUserInfo(UserInfo user)
   {
		logger.debug("Enter:username=" + user.getUsername());		
		try 
		{
			em.remove(em.merge(user));
		} catch (Exception re) 
		{
			logger.error(re.getMessage());
		}
		
		logger.debug("Return");
	}
    
    
    @Override
    public  List<UserInfo> getAllUsers()
    {
        logger.debug("Enter");
        
        QUserInfo ui = QUserInfo.userInfo;
        JPAQuery<UserInfo> query = new JPAQuery<>(em);        
        query.from(ui);
        List<UserInfo> users = query.fetch();//with threshold
        
        logger.debug("return:size="+users.size());
        return users;
    }
    
}

转载于:https://my.oschina.net/liuyuanyuangogo/blog/829626