通过自定义Repository整合SpringBoot 2.x和QueryDSL 4.3

1月18日，北京，聊聊2025如何加入技术开发？

QueryDSL可以通过JavaAPI来构建SQL语句，配合开发工具(IDEA、Eclipse)使用，非常便捷，即使新手上手也快。
Spring Data JPA提供了QueryDSL的支持，在1.x版本下，SimpleJpaRepository会自动切换成QuerydslJpaRepository的实现，2.x版本下，QuerydslJpaRepository已经过时，代替类为QuerydslJpaPredicateExecutor，另外也可继承QuerydslPredicateExecutor，直接调用querydsl自身的API。
本文没有使用Spring Data JPA自带的Repository，而是通过自定义Repository来整合SpringBoot和QueryDSL。
非spring框架下使用querydsl可以参考：https://my.oschina.net/penngo/blog/2998232
当前使用版本
spring boot 2.4.4
QueryDSL 4.3.1

1、maven工程文件
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.4</version>
        <relativePath/>
    </parent>
    <groupId>com.penngo.springquerydsl</groupId>
    <artifactId>springquerydsl</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springquerydsl</name>
    <description></description>
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <java.version>11</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <querydsl.version>4.3.1</querydsl.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-sql</artifactId>
            <version>${querydsl.version}</version>
        </dependency>
        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-apt</artifactId>
            <version>${querydsl.version}</version>
        </dependency>
        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-jpa</artifactId>
            <version>${querydsl.version}</version>
        </dependency>
        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-sql-codegen</artifactId>
            <version>${querydsl.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.0.Final</version>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>
    </dependencies>
    <repositories>
        <repository>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>https://maven.aliyun.com/repository/public/</url>
        </repository>
    </repositories>
    <build>
        <plugins>
            <!-- 实体生成querydsl的查询类 -->
            <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>
                <dependencies>
                    <dependency>
                        <groupId>com.querydsl</groupId>
                        <artifactId>querydsl-apt</artifactId>
                        <version>${querydsl.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.4.3</version>
            </plugin>
        </plugins>
    </build>
</project>

2、实体类对象
数据库表

CREATE TABLE `admin_log` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `controller_id` varchar(20) DEFAULT NULL COMMENT '控制器ID',
  `action_id` varchar(20) DEFAULT NULL COMMENT '方法ID',
  `url` varchar(200) DEFAULT NULL COMMENT '访问地址',
  `module_name` varchar(50) DEFAULT NULL COMMENT '模块',
  `func_name` varchar(50) DEFAULT NULL COMMENT '功能',
  `right_name` varchar(50) DEFAULT NULL COMMENT '方法',
  `client_ip` varchar(15) DEFAULT NULL COMMENT '客户端IP',
  `create_user` varchar(50) DEFAULT NULL COMMENT '用户',
  `create_date` datetime DEFAULT NULL COMMENT '时间',
  PRIMARY KEY (`id`),
  KEY `index_create_date` (`create_date`),
  KEY `index_create_index` (`create_user`),
  KEY `index_url` (`url`)
) ENGINE=InnoDB AUTO_INCREMENT=930 DEFAULT CHARSET=utf8

CREATE TABLE `admin_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `uname` varchar(100) NOT NULL COMMENT '用户名',
  `password` varchar(200) NOT NULL COMMENT '密码',
  `auth_key` varchar(50) DEFAULT NULL COMMENT '自动登录key',
  `last_ip` varchar(50) DEFAULT NULL COMMENT '最近一次登录ip',
  `is_online` char(1) DEFAULT 'n' COMMENT '是否在线',
  `last_login` datetime DEFAULT NULL COMMENT '最近登录时间',
  `domain_account` varchar(100) DEFAULT NULL COMMENT '域账号',
  `status` smallint(6) NOT NULL DEFAULT '10' COMMENT '状态',
  `create_user` varchar(100) NOT NULL COMMENT '创建人',
  `create_date` datetime NOT NULL COMMENT '创建时间',
  `update_user` varchar(101) NOT NULL COMMENT '更新人',
  `update_date` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=159 DEFAULT CHARSET=utf8

数据表对应的实体类，实体类可以使用IDEA或Eclipse开发工具生成

package com.penngo.springquerydsl.entity;
import javax.persistence.*;
import java.util.Date;

@Entity
@Table(name = "admin_log") 
public class AdminLog{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", columnDefinition="bigint(20) unsigned COMMENT ''")
    private Long id;
    @Column(name = "controller_id", columnDefinition="varchar(20) COMMENT '控制器ID'")
    private String controllerId;

    @Column(name = "action_id", columnDefinition="varchar(20) COMMENT '方法ID'")
    private String actionId;

    @Column(name = "url", columnDefinition="varchar(200) COMMENT '访问地址'")
    private String url;
    
    
    @Column(name = "module_name", columnDefinition="varchar(50) COMMENT '模块'")
    private String moduleName;
    
    
    @Column(name = "func_name", columnDefinition="varchar(50) COMMENT '功能'")
    private String funcName;
    
    
    @Column(name = "right_name", columnDefinition="varchar(50) COMMENT '方法'")
    private String rightName;
    
    
    @Column(name = "client_ip", columnDefinition="varchar(15) COMMENT '客户端IP'")
    private String clientIp;
    
    
    @Column(name = "create_user", columnDefinition="varchar(50) COMMENT '用户'")
    private String createUser;
    
    
    @Column(name = "create_date", columnDefinition="datetime COMMENT '时间'")
    private Date createDate;

    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getControllerId() {
        return controllerId;
    }
    public void setControllerId(String controllerId) {
        this.controllerId = controllerId;
    }
    public String getActionId() {
        return actionId;
    }
    public void setActionId(String actionId) {
        this.actionId = actionId;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getModuleName() {
        return moduleName;
    }
    public void setModuleName(String moduleName) {
        this.moduleName = moduleName;
    }
    public String getFuncName() {
        return funcName;
    }
    public void setFuncName(String funcName) {
        this.funcName = funcName;
    }
    public String getRightName() {
        return rightName;
    }
    public void setRightName(String rightName) {
        this.rightName = rightName;
    }
    public String getClientIp() {
        return clientIp;
    }
    public void setClientIp(String clientIp) {
        this.clientIp = clientIp;
    }
    public String getCreateUser() {
        return createUser;
    }
    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }
    public Date getCreateDate() {
        return createDate;
    }
    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
}

package com.penngo.springquerydsl.entity;
import java.io.Serializable;
import java.sql.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "admin_user") 
public class AdminUser implements Serializable{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id") 
    private Long id;
  
    @Column(name = "uname") 
    private String uname;
    
    @Column(name = "password") 
    private String password;
    
    @Column(name = "auth_key") 
    private String authKey;    
    
    @Column(name = "last_ip") 
    private String lastIp;   
    
    @Column(name = "is_online") 
    private String isOnline;
    
    @Column(name = "domain_account") 
    private String domainAccount;    
    
    @Column(name = "status") 
    private Integer status;    
    
    @Column(name = "create_user") 
    private String createUser;    
    
    @Column(name = "create_date") 
    private Date createDate;    
    
    @Column(name = "update_user") 
    private String updateUser;    
    
    @Column(name = "update_date") 
    private Date updateDate;

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getUname() {
		return uname;
	}

	public void setUname(String uname) {
		this.uname = uname;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getAuthKey() {
		return authKey;
	}

	public void setAuthKey(String authKey) {
		this.authKey = authKey;
	}

	public String getLastIp() {
		return lastIp;
	}

	public void setLastIp(String lastIp) {
		this.lastIp = lastIp;
	}

	public String getIsOnline() {
		return isOnline;
	}

	public void setIsOnline(String isOnline) {
		this.isOnline = isOnline;
	}

	public String getDomainAccount() {
		return domainAccount;
	}

	public void setDomainAccount(String domainAccount) {
		this.domainAccount = domainAccount;
	}

	public Integer getStatus() {
		return status;
	}

	public void setStatus(Integer status) {
		this.status = status;
	}

	public String getCreateUser() {
		return createUser;
	}

	public void setCreateUser(String createUser) {
		this.createUser = createUser;
	}

	public Date getCreateDate() {
		return createDate;
	}

	public void setCreateDate(Date createDate) {
		this.createDate = createDate;
	}

	public String getUpdateUser() {
		return updateUser;
	}

	public void setUpdateUser(String updateUser) {
		this.updateUser = updateUser;
	}

	public Date getUpdateDate() {
		return updateDate;
	}

	public void setUpdateDate(Date updateDate) {
		this.updateDate = updateDate;
	}   
}

QueryDSL查询对象，可通过QueryDSL的Maven插件querydsl-apt，命令行下执行mvn compile生成。

package com.penngo.springquerydsl.entity;
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;
/**
 * QAdminLog is a Querydsl query type for AdminLog
 */
@Generated("com.querydsl.codegen.EntitySerializer")
public class QAdminLog extends EntityPathBase<AdminLog> {
    private static final long serialVersionUID = 50582040L;
    public static final QAdminLog adminLog = new QAdminLog("adminLog");
    public final StringPath actionId = createString("actionId");
    public final StringPath clientIp = createString("clientIp");
    public final StringPath controllerId = createString("controllerId");
    public final DateTimePath<java.util.Date> createDate = createDateTime("createDate", java.util.Date.class);
    public final StringPath createUser = createString("createUser");
    public final StringPath funcName = createString("funcName");
    public final NumberPath<Long> id = createNumber("id", Long.class);
    public final StringPath moduleName = createString("moduleName");
    public final StringPath rightName = createString("rightName");
    public final StringPath url = createString("url");

    public QAdminLog(String variable) {
        super(AdminLog.class, forVariable(variable));
    }
    public QAdminLog(Path<? extends AdminLog> path) {
        super(path.getType(), path.getMetadata());
    }
    public QAdminLog(PathMetadata metadata) {
        super(AdminLog.class, metadata);
    }
}

package com.penngo.springquerydsl.entity;
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;
/**
 * QAdminUser is a Querydsl query type for AdminUser
 */
@Generated("com.querydsl.codegen.EntitySerializer")
public class QAdminUser extends EntityPathBase<AdminUser> {
    private static final long serialVersionUID = 1568315255L;
    public static final QAdminUser adminUser = new QAdminUser("adminUser");
    public final StringPath authKey = createString("authKey");
    public final DatePath<java.sql.Date> createDate = createDate("createDate", java.sql.Date.class);
    public final StringPath createUser = createString("createUser");
    public final StringPath domainAccount = createString("domainAccount");
    public final NumberPath<Long> id = createNumber("id", Long.class);
    public final StringPath isOnline = createString("isOnline");
    public final StringPath lastIp = createString("lastIp");
    public final StringPath password = createString("password");
    public final NumberPath<Integer> status = createNumber("status", Integer.class);
    public final StringPath uname = createString("uname");
    public final DatePath<java.sql.Date> updateDate = createDate("updateDate", java.sql.Date.class);
    public final StringPath updateUser = createString("updateUser");
    public QAdminUser(String variable) {
        super(AdminUser.class, forVariable(variable));
    }
    public QAdminUser(Path<? extends AdminUser> path) {
        super(path.getType(), path.getMetadata());
    }
    public QAdminUser(PathMetadata metadata) {
        super(AdminUser.class, metadata);
    }
}

3、实现自定义Repository，封装 QueryDSL数据库接口Repository，主要提供JPAQueryFactory类

package com.penngo.springquerydsl.repository;
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.Repository;
import javax.persistence.EntityManager;
import java.io.Serializable;
@NoRepositoryBean
public interface BaseRepository<T, ID extends Serializable>  extends Repository<T,ID> {
    public EntityManager getEntityManager();
    public JPAQueryFactory query();
}

package com.penngo.springquerydsl.repository.impl;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import com.querydsl.jpa.impl.JPAQueryFactory;
import com.penngo.springquerydsl.repository.BaseRepository;
import org.springframework.stereotype.Component;
import java.io.Serializable;

@Component
public class BaseRepositoryImpl<T, ID extends Serializable> implements BaseRepository<T, ID> {
    @PersistenceContext
    private EntityManager em;
    public EntityManager getEntityManager() {
        return em;
    }
    public JPAQueryFactory query(){
        JPAQueryFactory queryFactory = new JPAQueryFactory(getEntityManager());
        return queryFactory;
    }
}

4、服务层
通过BaseService，封装常用的数据库增删改查操作，通用的数据库操作方法都可以放在这个类中，后面的业务服务类都继承BaseService，获取通用的增删改查操作。

package com.penngo.springquerydsl.service;

import com.querydsl.core.Tuple;
import com.querydsl.core.types.*;
import com.querydsl.jpa.impl.JPAQueryFactory;
import java.io.Serializable;
import java.util.List;
public interface BaseService<T, ID extends Serializable>{
    public JPAQueryFactory query();
    public T save(T entity);
    public void save(List<T> entitys);
    public T update(T entity);
    public void update(List<T> entitys);
    public T findOne(Predicate where);
    public <E> E findOne(Expression<E> select, Predicate where);
    public Tuple findOne(List<Expression<?>> selects, Predicate where);
    public List<T> findAll(Predicate where);
    public <K> List<K> findAll(Expression<K> select,Predicate where);
    public List<T> findAll(Predicate where,long page, long pageSize);
    public List<T> findAll(Predicate where,long page, long pageSize, OrderSpecifier<?>... order);
    public List<T> findAll(long page, long pageSize);
    public List<T> findAll(long page, long pageSize, OrderSpecifier<?>... order);
    public List<Tuple> findAll(List<Expression<?>> selects, Predicate where, long page, long pageSize, OrderSpecifier<?>... order);
    public List<T> findAll(Expression<T> select,Predicate where,long page, long pageSize, OrderSpecifier<?>... order);
    public long count();
    public long count(Predicate where);
    public long count(Expression<Long> expr, Predicate where);
    public long delete(Predicate predicate);
    public abstract EntityPath<T> getEntityPath();
}

package com.penngo.springquerydsl.service.impl;

import com.querydsl.core.Tuple;
import com.querydsl.core.types.*;
import com.querydsl.core.types.dsl.Expressions;
import com.querydsl.jpa.impl.JPAQueryFactory;
import com.querydsl.jpa.impl.JPAUpdateClause;
import com.penngo.springquerydsl.repository.BaseRepository;
import com.penngo.springquerydsl.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import java.io.Serializable;
import java.util.List;
import java.util.Map;

@Service
public abstract class BaseServiceImpl<T, ID extends Serializable> implements BaseService<T, ID> {
    @Autowired
    protected BaseRepository baseRepository = null;
    protected EntityPath<T> entityPath = null;
    public JPAQueryFactory query(){
        return baseRepository.query();
    }

    @Transactional
    public T save(T entity){
        EntityManager em = baseRepository.getEntityManager();
        em.persist(entity);
        return entity;
    }
    @Transactional
    public void save(List<T> entitys){
        EntityManager em = baseRepository.getEntityManager();
        entitys.forEach(e->{
            em.persist(e);
        });
    }
    @Transactional
    public T update(T entity){
        EntityManager em = baseRepository.getEntityManager();
        em.merge(entity);
        em.flush();
        return entity;
    }
    @Transactional
    public void update(List<T> entitys){
        EntityManager em = baseRepository.getEntityManager();
        entitys.forEach(entity->{
            em.merge(entity);
        });
    }
    @Transactional
    public <T> long update(EntityPath<?> path, Map<Path<T>, T> setMap, Predicate where){
        JPAUpdateClause updateClause = baseRepository.query().update(path);
        setMap.forEach((k,v)->{
            updateClause.set(k,v);
        });
        if(where != null){
            updateClause.where(where);
        }
        long count = updateClause.execute();
        return count;
    }

    public T findOne(Predicate where){
        System.out.println("findOne=====" + entityPath);
        return query().selectFrom(getEntityPath())
                .where(where)
                .fetchOne();
    }
    public <E> E findOne(Expression<E> select, Predicate where){
        return query().select(select)
                .from(getEntityPath())
                .where(where)
                .fetchOne();
    }
    public Tuple findOne(List<Expression<?>> selects, Predicate where){
        return query().select(selects.toArray(Expression<?>[]::new))
                .from(getEntityPath())
                .where(where)
                .fetchOne();
    }

    public List<T> findAll(Predicate where){
        return query().selectFrom(getEntityPath())
                .where(where)
                .fetch();
    }
    public <K> List<K> findAll(Expression<K> select,Predicate where){
        return query().select(select)
                .from(getEntityPath())
                .where(where)
                .fetch();
    }
    /**
     *
     * @param where 条件
     * @param page  页码
     * @param pageSize 每页数量
     * @return
     */
    public List<T> findAll(Predicate where,long page, long pageSize){
        return query()
                .selectFrom(getEntityPath())
                .where(where)
                .offset((page - 1) * pageSize)
                .limit(pageSize)
                .fetch();
    }

    /**
     *
     * @param where 条件
     * @param page   页码
     * @param pageSize   每页数量
     * @param order
     * @return
     */
    public List<T> findAll(Predicate where,long page, long pageSize, OrderSpecifier<?>... order){
        return query()
                .selectFrom(getEntityPath())
                .where(where)
                .offset((page - 1) * pageSize)
                .limit(pageSize)
                .fetch();
    }
    /**
     *
     * @param page  页码
     * @param pageSize 每页数量
     * @return
     */
    public List<T> findAll(long page, long pageSize){
        return query()
                .selectFrom(getEntityPath())
                .offset((page - 1) * pageSize)
                .limit(pageSize)
                .fetch();
    }
    /**
     *
     * @param page  页码
     * @param pageSize 每页数量
     * @return
     */
    public List<T> findAll(long page, long pageSize, OrderSpecifier<?>... order){
        return query()
                .selectFrom(getEntityPath())
                .orderBy(order)
                .offset((page - 1) * pageSize)
                .limit(pageSize)
                .fetch();
    }

    /**
     *
     * @param selects
     * @param where
     * @param page
     * @param pageSize
     * @param order
     * @return
     */
    public List<Tuple> findAll(List<Expression<?>> selects, Predicate where, long page, long pageSize, OrderSpecifier<?>... order){
        return query().select(selects.toArray(Expression<?>[]::new))
                .from(getEntityPath())
                .where(where)
                .orderBy(order)
                .offset((page - 1) * pageSize)
                .limit(pageSize)
                .fetch();
    }
    /**
     *
     * @param select 字段
     * @param where 条件
     * @param page  页码
     * @param pageSize 每页数量
     * @param order  排序
     * @return
     */
    public List<T> findAll(Expression<T> select,Predicate where,long page, long pageSize, OrderSpecifier<?>... order){
        return query().select(select)
                .from(getEntityPath())
                .where(where)
                .orderBy(order)
                .offset((page - 1) * pageSize)
                .limit(pageSize)
                .fetch();
    }


    public long count(){
        return baseRepository.query().select(Expressions.numberTemplate(Long.class," count(1) "))
                .from(getEntityPath())
                .fetchOne();
    }
    public long count(Predicate where){
        return baseRepository.query().select(Expressions.stringTemplate(" 1 ")).from(entityPath)
                .where(where).fetchCount();
    }


    public long count(Expression<Long> expr, Predicate where){
        return baseRepository.query().select(expr).from(getEntityPath())
                .where(where).fetchCount();
    }
    @Transactional
    public long delete(Predicate predicate){
        long count = baseRepository.query().delete(entityPath).where(predicate).execute();
        return count;
    }
    public abstract EntityPath<T> getEntityPath();
}

业务服务类AdminLogService：继承BaseService对象，获得数据库的基本操作方法。

package com.penngo.springquerydsl.service;
import com.penngo.springquerydsl.entity.AdminLog;
public interface AdminLogService extends BaseService<AdminLog, Long> {
}

package com.penngo.springquerydsl.service.impl;

import com.querydsl.core.types.EntityPath;
import com.penngo.springquerydsl.entity.AdminLog;
import com.penngo.springquerydsl.entity.QAdminLog;
import com.penngo.springquerydsl.service.AdminLogService;
import org.springframework.stereotype.Service;

@Service("adminLogService")
public class AdminLogServiceImpl extends BaseServiceImpl<AdminLog, Long> implements AdminLogService{
    @Override
    public EntityPath<AdminLog> getEntityPath() {
        return QAdminLog.adminLog;
    }
}

5、路由

package com.penngo.springquerydsl.controller;

import com.penngo.springquerydsl.entity.AdminLog;
import com.penngo.springquerydsl.entity.QAdminLog;
import com.penngo.springquerydsl.entity.QAdminUser;
import com.penngo.springquerydsl.service.AdminLogService;
import com.querydsl.core.Tuple;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.Date;
@Controller
public class IndexController {
    @Autowired
    private AdminLogService adminLogService;
    @RequestMapping("/index")
    @ResponseBody
    public String index() {
        System.out.println("1====adminLogService.count():" + adminLogService.count());
        // 查询
        AdminLog log = adminLogService.findOne(QAdminLog.adminLog.id.eq((long)1));
        log.setCreateDate(new Date());
        // 更新
        adminLogService.update(log);
        AdminLog log2 = new AdminLog();
        log2.setControllerId("test");
        log2.setActionId("index");
        // 保存
        adminLogService.save(log2);
        System.out.println("2====adminLogService.count():" + adminLogService.count());

        // 联表查询 AdminLog和QAdminUser
        Tuple tuple = adminLogService.query().select(QAdminLog.adminLog.controllerId, QAdminLog.adminLog.actionId, QAdminUser.adminUser.uname, QAdminUser.adminUser.status)
                .from(QAdminLog.adminLog).leftJoin(QAdminUser.adminUser).on(QAdminLog.adminLog.createUser.eq(QAdminUser.adminUser.uname))
                .where(QAdminLog.adminLog.id.eq((long)1)).fetchOne();
        System.out.println("tuple====" + tuple);
        return "helloword!";
    }
}

6、启动

application.properties配置文件

spring.datasource.type: com.alibaba.druid.pool.DruidDataSource
spring.datasource.username: root
spring.datasource.password: penngo
spring.datasource.url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=true
spring.datasource.driver-class-name: com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.dialect: org.hibernate.dialect.MySQL8Dialect
spring.jpa.show-sql: true
spring.jpa.hibernate.ddl-auto: update
spring.datasource.default-auto-commit = true
spring.jpa.database-platform: mysql
spring.jpa.database: mysql
spring.jpa.open-in-view: false

启动类ServerApplication.java

package com.penngo.springquerydsl;
import com.penngo.springquerydsl.repository.impl.BaseRepositoryImpl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
@SpringBootApplication
@ServletComponentScan
@EnableJpaRepositories(repositoryBaseClass = BaseRepositoryImpl.class)
public class ServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);
    }
}

控制台输出

浏览器访问

源码下载