or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration.mdcore-processing.mdframework-processors.mdindex.mdprocessing-options.md
tile.json

tessl/maven-com-mysema-querydsl--querydsl-apt

APT-based source code generation tool for Querydsl that generates type-safe query classes from annotated Java entity classes.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.mysema.querydsl/querydsl-apt@3.7.x

To install, run

npx @tessl/cli install tessl/maven-com-mysema-querydsl--querydsl-apt@3.7.0

index.mddocs/

Querydsl APT

Querydsl APT (Annotation Processing Tool) is a compile-time source code generation library that creates type-safe query classes (Q-classes) from annotated Java entity classes. It processes annotations from multiple persistence frameworks including JPA, Hibernate, JDO, Morphia (MongoDB), and Spring Roo to generate query domain models for the Querydsl type-safe query framework.

Package Information

  • Package Name: querydsl-apt
  • Package Type: maven
  • Language: Java
  • Installation: com.mysema.querydsl:querydsl-apt:3.7.4 (Maven dependency)
  • License: Apache License, Version 2.0

Core Imports

// For general Querydsl annotations
import com.mysema.query.apt.QuerydslAnnotationProcessor;

// For JPA entities
import com.mysema.query.apt.jpa.JPAAnnotationProcessor;

// For configuration
import com.mysema.query.apt.Configuration;
import com.mysema.query.apt.DefaultConfiguration;

Basic Usage

The annotation processors are automatically discovered through the Java service provider interface. Add the appropriate processor to your build configuration:

Maven Configuration:

<!-- Maven APT plugin configuration -->
<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</outputDirectory>
        <processors>
          <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor>
        </processors>
      </configuration>
    </execution>
  </executions>
</plugin>

Gradle Configuration:

dependencies {
    annotationProcessor 'com.mysema.querydsl:querydsl-apt:3.7.4'
    compileOnly 'com.mysema.querydsl:querydsl-apt:3.7.4'
    implementation 'com.mysema.querydsl:querydsl-core:3.7.4'
}

compileJava {
    options.annotationProcessorPath = configurations.annotationProcessor
}

For JPA entities:

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity  
public class User {
    @Id
    private Long id;
    private String name;
    private String email;
}

// APT generates QUser.java:
// public class QUser extends EntityPathBase<User> {
//     public static final QUser user = new QUser("user");
//     public final NumberPath<Long> id = createNumber("id", Long.class);
//     public final StringPath name = createString("name");  
//     public final StringPath email = createString("email");
// }

Architecture

Querydsl APT uses a multi-phase annotation processing architecture:

  • Annotation Processors: Framework-specific processors that discover annotated classes
  • Configuration System: Flexible configuration for customizing code generation behavior
  • Type Factory: Creates intermediate representations of entity types and properties
  • Serializers: Generate the final Q-class source code from entity models
  • Service Registration: Automatic processor discovery via META-INF/services

The processing flow: Annotation Discovery → Entity Model Creation → Property Analysis → Code Generation → Source File Writing

Capabilities

Core Annotation Processing

Central annotation processing functionality providing the base framework for generating type-safe query classes from annotated entities.

public abstract class AbstractQuerydslProcessor extends AbstractProcessor {
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv);
    protected abstract Configuration createConfiguration(RoundEnvironment roundEnv);
}

public class QuerydslAnnotationProcessor extends AbstractQuerydslProcessor {
    // Handles @QueryEntity, @QuerySupertype, @QueryEmbeddable, @QueryEmbedded, @QueryTransient
}

Core Processing

Framework-Specific Processors

Specialized annotation processors for different persistence frameworks, each handling framework-specific annotations and conventions.

public class JPAAnnotationProcessor extends AbstractQuerydslProcessor {
    // Handles @Entity, @MappedSuperclass, @Embeddable, @Embedded, @Transient
}

public class HibernateAnnotationProcessor extends JPAAnnotationProcessor {
    // Extends JPA support with Hibernate-specific annotations
}

public class JDOAnnotationProcessor extends AbstractQuerydslProcessor {
    // Handles @PersistenceCapable, @EmbeddedOnly, @NotPersistent
}

public class MorphiaAnnotationProcessor extends AbstractQuerydslProcessor {
    // Handles MongoDB Morphia annotations: @Entity, @Embedded, @Transient
}

public class RooAnnotationProcessor extends AbstractQuerydslProcessor {
    // Handles Spring Roo annotations: @RooJpaEntity, @RooJpaActiveRecord
}

Framework Processors

Configuration System

Comprehensive configuration system for customizing annotation processing behavior, code generation options, and framework-specific settings.

public interface Configuration {
    TypeMappings getTypeMappings();
    Class<? extends Annotation> getEntityAnnotation();
    boolean isUseFields();
    boolean isUseGetters();
    String getNamePrefix();
    String getNameSuffix();
    void addExcludedPackage(String packageName);
    void addExcludedClass(String className);
}

public class DefaultConfiguration implements Configuration {
    public DefaultConfiguration(RoundEnvironment roundEnv, Map<String,String> options, ...);
    public void setNamePrefix(String namePrefix);
    public void setNameSuffix(String nameSuffix);
    public <T> void addCustomType(Class<T> type, Class<? extends Expression<T>> queryType);
}

Configuration

Processing Options

APT compiler options for controlling code generation behavior, naming conventions, and processing rules.

public final class APTOptions {
    public static final String QUERYDSL_PREFIX = "querydsl.prefix";
    public static final String QUERYDSL_SUFFIX = "querydsl.suffix";
    public static final String QUERYDSL_PACKAGE_SUFFIX = "querydsl.packageSuffix";
    public static final String QUERYDSL_USE_FIELDS = "querydsl.useFields"; 
    public static final String QUERYDSL_USE_GETTERS = "querydsl.useGetters";
    public static final String QUERYDSL_EXCLUDED_PACKAGES = "querydsl.excludedPackages";
    public static final String QUERYDSL_EXCLUDED_CLASSES = "querydsl.excludedClasses";
}

Processing Options

Exception Handling

public class APTException extends RuntimeException {
    public APTException(String msg);
    public APTException(String msg, Throwable t);
    public APTException(Throwable t);
}

public class UnsupportedTypeException extends APTException {
    public UnsupportedTypeException(TypeMirror mirror);
}

Exception Hierarchy:

  • APTException extends RuntimeException - base exception for APT processing errors
  • UnsupportedTypeException extends APTException - thrown for unsupported type scenarios

Common processing errors include:

  • Missing required annotations on entity classes → APTException
  • Unsupported type mappings in entity properties → UnsupportedTypeException
  • Configuration validation failures → APTException
  • Source file generation conflicts → APTException
  • Illegal property initialization paths → Error messages to compiler