tessl/maven-com-palantir-javapoet--javapoet

JavaPoet is a Java API for generating .java source files programmatically with support for modern Java features including records and sealed types

Overview

Eval results

Files

Class Names

Name: tessl/maven-com-palantir-javapoet--javapoet
Author: tessl

ClassName represents class and interface names in JavaPoet. It extends TypeName and implements Comparable, providing a type-safe way to reference declared types with support for nested classes, package names, and automatic import management.

Capabilities

Common Class Constants

Pre-defined constant for frequently used classes.

/**
 * Represents java.lang.Object
 */
public static final ClassName OBJECT;

Creating ClassName Instances

Factory methods for creating ClassName from various sources.

/**
 * Creates a ClassName from a Class object
 * @param clazz - The class to represent
 * @return ClassName for the class
 */
static ClassName get(Class<?> clazz);

/**
 * Creates a ClassName from package and class names
 * @param packageName - The package name
 * @param simpleName - The simple class name
 * @param simpleNames - Additional names for nested classes
 * @return ClassName for the specified class
 */
static ClassName get(String packageName, String simpleName, String... simpleNames);

/**
 * Creates a ClassName from a TypeElement (annotation processing)
 * @param element - The type element
 * @return ClassName for the type element
 */
static ClassName get(TypeElement element);

/**
 * Attempts to parse a class name from a string
 * @param classNameString - Fully qualified or simple class name
 * @return ClassName parsed from the string
 */
static ClassName bestGuess(String classNameString);

Usage Examples:

// From Class object
ClassName string = ClassName.get(String.class);
ClassName arrayList = ClassName.get(ArrayList.class);
ClassName map = ClassName.get(Map.class);

// From package and name
ClassName user = ClassName.get("com.example", "User");
ClassName userDto = ClassName.get("com.example.dto", "UserDto");

// Nested class
ClassName entry = ClassName.get("java.util", "Map", "Entry");

// From annotation processing
TypeElement element = ...;
ClassName className = ClassName.get(element);

// Best guess parsing
ClassName parsed = ClassName.bestGuess("java.util.List");
ClassName nested = ClassName.bestGuess("com.example.Outer.Inner");

Accessing Name Components

Get various parts of the class name.

/**
 * Returns the package name
 * @return The package name (e.g., "java.util")
 */
String packageName();

/**
 * Returns the enclosing class name for nested classes
 * @return ClassName of enclosing class, or null if top-level
 */
ClassName enclosingClassName();

/**
 * Returns the top-level class name
 * @return ClassName of the outermost class
 */
ClassName topLevelClassName();

/**
 * Returns the name suitable for Class.forName()
 * @return Reflection-style name (e.g., "java.util.Map$Entry")
 */
String reflectionName();

/**
 * Returns list of simple names from top-level to this class
 * @return List of simple names for nested hierarchy
 */
List<String> simpleNames();

/**
 * Returns the simple name of this class
 * @return The simple class name
 */
String simpleName();

/**
 * Returns the canonical name
 * @return Fully qualified canonical name
 */
String canonicalName();

Usage Examples:

ClassName mapEntry = ClassName.get("java.util", "Map", "Entry");

mapEntry.packageName();        // "java.util"
mapEntry.simpleName();         // "Entry"
mapEntry.simpleNames();        // ["Map", "Entry"]
mapEntry.canonicalName();      // "java.util.Map.Entry"
mapEntry.reflectionName();     // "java.util.Map$Entry"
mapEntry.enclosingClassName(); // ClassName for java.util.Map
mapEntry.topLevelClassName();  // ClassName for java.util.Map

Creating Related Classes

Create peer and nested class names.

/**
 * Creates a peer class in the same package
 * @param simpleName - Simple name of the peer class
 * @return ClassName for the peer class
 */
ClassName peerClass(String simpleName);

/**
 * Creates a nested class name
 * @param simpleName - Simple name of the nested class
 * @return ClassName for the nested class
 */
ClassName nestedClass(String simpleName);

Usage Examples:

ClassName user = ClassName.get("com.example", "User");

// Create peer class
ClassName userDto = user.peerClass("UserDto");
// Result: com.example.UserDto

// Create nested class
ClassName builder = user.nestedClass("Builder");
// Result: com.example.User.Builder

// Chain nested classes
ClassName deepNested = user.nestedClass("Nested").nestedClass("Deep");
// Result: com.example.User.Nested.Deep

Working with Annotations

Add or remove type annotations.

/**
 * Returns a copy with additional annotations
 * @param annotations - Annotations to add
 * @return New ClassName with annotations
 */
ClassName annotated(AnnotationSpec... annotations);

/**
 * Returns a copy with additional annotations from a list
 * @param annotations - List of annotations to add
 * @return New ClassName with annotations
 */
ClassName annotated(List<AnnotationSpec> annotations);

/**
 * Returns a copy without any annotations
 * @return New ClassName without annotations
 */
ClassName withoutAnnotations();

/**
 * Checks if this type has any annotations
 * @return true if annotated, false otherwise
 */
boolean isAnnotated();

Comparing ClassName

/**
 * Compares class names lexicographically
 * @param o - The ClassName to compare to
 * @return Negative, zero, or positive as this is less than, equal to, or greater than o
 */
int compareTo(ClassName o);

Common Patterns

Standard Library Classes

// Java primitives (boxed)
ClassName integer = ClassName.get(Integer.class);
ClassName longClass = ClassName.get(Long.class);
ClassName bool = ClassName.get(Boolean.class);

// Collections
ClassName list = ClassName.get(List.class);
ClassName arrayList = ClassName.get(ArrayList.class);
ClassName map = ClassName.get(Map.class);
ClassName hashMap = ClassName.get(HashMap.class);
ClassName set = ClassName.get(Set.class);

// Common classes
ClassName string = ClassName.get(String.class);
ClassName object = ClassName.OBJECT;
ClassName throwable = ClassName.get(Throwable.class);
ClassName exception = ClassName.get(Exception.class);

Package Organization

// Domain models
ClassName user = ClassName.get("com.example.model", "User");
ClassName product = ClassName.get("com.example.model", "Product");

// DTOs
ClassName userDto = ClassName.get("com.example.dto", "UserDto");

// Services
ClassName userService = ClassName.get("com.example.service", "UserService");

// Repositories
ClassName userRepo = ClassName.get("com.example.repository", "UserRepository");

Nested Classes

// Builder pattern
ClassName user = ClassName.get("com.example", "User");
ClassName userBuilder = user.nestedClass("Builder");

TypeSpec userClass = TypeSpec.classBuilder(user)
    .addType(TypeSpec.classBuilder("Builder")
        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
        .build())
    .build();

// Inner classes
ClassName node = ClassName.get("com.example", "LinkedList").nestedClass("Node");

// Multiple levels
ClassName deep = ClassName.get("com.example", "Outer")
    .nestedClass("Middle")
    .nestedClass("Inner");

Using in Type Specifications

ClassName myClass = ClassName.get("com.example", "MyClass");

// In fields
FieldSpec field = FieldSpec.builder(myClass, "instance")
    .addModifiers(Modifier.PRIVATE)
    .build();

// In methods
MethodSpec method = MethodSpec.methodBuilder("getInstance")
    .returns(myClass)
    .addStatement("return new $T()", myClass)
    .build();

// In parameters
ParameterSpec param = ParameterSpec.builder(myClass, "value")
    .build();

With Parameterized Types

ClassName list = ClassName.get(List.class);
ClassName string = ClassName.get(String.class);

// Create List<String>
TypeName listOfStrings = ParameterizedTypeName.get(list, string);

// Create Map<String, User>
ClassName map = ClassName.get(Map.class);
ClassName user = ClassName.get("com.example", "User");
TypeName mapType = ParameterizedTypeName.get(map, string, user);

Framework-Specific Classes

// Spring Framework
ClassName autowired = ClassName.get("org.springframework.beans.factory.annotation", "Autowired");
ClassName component = ClassName.get("org.springframework.stereotype", "Component");
ClassName service = ClassName.get("org.springframework.stereotype", "Service");
ClassName controller = ClassName.get("org.springframework.web.bind.annotation", "RestController");

// JPA
ClassName entity = ClassName.get("javax.persistence", "Entity");
ClassName table = ClassName.get("javax.persistence", "Table");
ClassName id = ClassName.get("javax.persistence", "Id");
ClassName column = ClassName.get("javax.persistence", "Column");

// Jackson
ClassName jsonProperty = ClassName.get("com.fasterxml.jackson.annotation", "JsonProperty");
ClassName jsonIgnore = ClassName.get("com.fasterxml.jackson.annotation", "JsonIgnore");

Best Guess Parsing

// Parse fully qualified names
ClassName list = ClassName.bestGuess("java.util.List");
ClassName string = ClassName.bestGuess("java.lang.String");

// Parse nested classes
ClassName entry = ClassName.bestGuess("java.util.Map.Entry");
ClassName builder = ClassName.bestGuess("com.example.User.Builder");

// Parse simple names (assumes no package)
ClassName simple = ClassName.bestGuess("MyClass");
// Results in package "" and name "MyClass"

Peer and Nested Class Generation

ClassName user = ClassName.get("com.example.model", "User");

// Generate related classes
ClassName userDto = user.peerClass("UserDto");           // com.example.model.UserDto
ClassName userRequest = user.peerClass("UserRequest");   // com.example.model.UserRequest
ClassName userResponse = user.peerClass("UserResponse"); // com.example.model.UserResponse

// Generate nested classes
ClassName builder = user.nestedClass("Builder");         // com.example.model.User.Builder
ClassName validator = user.nestedClass("Validator");     // com.example.model.User.Validator

Sorting Classes

List<ClassName> classes = Arrays.asList(
    ClassName.get("com.example", "Zebra"),
    ClassName.get("com.example", "Apple"),
    ClassName.get("com.example", "Banana")
);

// Sort alphabetically
Collections.sort(classes);
// Result: [Apple, Banana, Zebra]

Advanced: Visitor Methods for javax.lang.model Integration

ClassName implements visitor methods for processing TypeElement and Element instances during annotation processing. These methods are used internally by the get(TypeElement) factory method and are rarely called directly by users.

/**
 * Visits a type element (class, interface, enum) from javax.lang.model
 * @param enclosingClass - The enclosing type element
 * @param _p - Unused parameter
 * @return ClassName for the enclosing class with nested class name
 */
ClassName visitType(TypeElement enclosingClass, Void _p);

/**
 * Visits an unknown element type from javax.lang.model
 * @param _unknown - The unknown element
 * @param _p - Unused parameter
 * @return ClassName with empty package
 */
ClassName visitUnknown(Element _unknown, Void _p);

/**
 * Default action for unhandled element types
 * @param _enclosingElement - The enclosing element
 * @param _p - Unused parameter
 * @return ClassName or throws exception
 */
ClassName defaultAction(Element _enclosingElement, Void _p);

Note: These methods are part of the ElementVisitor pattern used for javax.lang.model integration. Normal users should use the ClassName.get(TypeElement) factory method instead of calling these visitor methods directly.

Types

class ClassName extends TypeName implements Comparable<ClassName> {
    static final ClassName OBJECT;

    static ClassName get(Class<?> clazz);
    static ClassName get(String packageName, String simpleName, String... simpleNames);
    static ClassName get(TypeElement element);
    static ClassName bestGuess(String classNameString);

    String packageName();
    ClassName enclosingClassName();
    ClassName topLevelClassName();
    String reflectionName();
    List<String> simpleNames();
    String simpleName();
    String canonicalName();
    ClassName peerClass(String simpleName);
    ClassName nestedClass(String simpleName);
    ClassName annotated(AnnotationSpec... annotations);
    ClassName annotated(List<AnnotationSpec> annotations);
    ClassName withoutAnnotations();
    boolean isAnnotated();
    int compareTo(ClassName o);

    // Visitor methods for javax.lang.model integration (rarely used directly)
    ClassName visitType(TypeElement enclosingClass, Void _p);
    ClassName visitUnknown(Element _unknown, Void _p);
    ClassName defaultAction(Element _enclosingElement, Void _p);
}

Install with Tessl CLI

npx tessl i tessl/maven-com-palantir-javapoet--javapoet@0.11.0

docs

annotation-specifications.md

array-type-names.md

class-names.md

code-blocks.md

field-specifications.md

index.md

java-files.md

method-specifications.md

name-allocator.md

parameter-specifications.md

parameterized-type-names.md

type-names.md

type-specifications.md

type-variable-names.md

wildcard-type-names.md

tile.json

tessl/maven-com-palantir-javapoet--javapoet

class-names.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Class Names

Capabilities

Common Class Constants

Creating ClassName Instances

Accessing Name Components

Creating Related Classes

Working with Annotations

Comparing ClassName

Common Patterns

Standard Library Classes

Package Organization

Nested Classes

Using in Type Specifications

With Parameterized Types

Framework-Specific Classes

Best Guess Parsing

Peer and Nested Class Generation

Sorting Classes

Advanced: Visitor Methods for javax.lang.model Integration

Types

class-names.mddocs/