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.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Querydsl APT

Name: tessl/maven-com-mysema-querydsl--querydsl-apt
Author: tessl

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: