How to supply value to an annotation from a Constant java

java

immutable-constants

annotation-processing

compile-time-constants

byAlex Kataev·Feb 22, 2025

Answer lies in using public static final field as a constant and referencing it in an annotation as follows:

public interface SharedConstants {
    String VALUE = "ConstantValue";
}

@interface Configurable {
    String setting() default SharedConstants.VALUE;
}

@Configurable
public class Service {
    // Class implementation
}

This approach enforces that constants are embedded directly "at compile time" and are inline with annotation constraints. Stick to literal or final constant expressions.

Immutable vs Mutable Constants in Java

Immutable Constants: Primitive types and Strings

In Java, immutable constants, regardless of being primitives or Strings, are represented as public static final.

public class Constants {
    public static final int BUFFER_SIZE = 1024; // No Jedi mind tricks here. It is indeed 1024.
}

@interface BufferConfig {
    int size() default Constants.BUFFER_SIZE;
}

Mutable Constants: Array values

For mutable array values, things get a little tricky as they can't be directly assigned as compile-time constants. An alternate approach can be using single-element arrays or encapsulating the constants in an auxiliary annotation.

public class Settings {
    public static final String DEFAULT_PRIORITY = "HIGH"; // Because why start at the bottom!

    // Direct assignment won't work: public static final String[] PRIORITIES = new String[] {"LOW", "MEDIUM", "HIGH"};
}

@interface PriorityConfig {
    String value() default Settings.DEFAULT_PRIORITY; // Starting at HIGH as a singleton
}

Mastering Constant Usage

Clear-cut names

Combat ambiguity and enhance readability by referencing constants using qualified names (TypeName.Identifier).

public class ApplicationDetails {
    public static final String LATEST_VERSION = "1.0.3"; // Closer to perfection with each iteration
}

@interface VersionInformation {
    String version() default ApplicationDetails.LATEST_VERSION;
}

Guarding array elements

While it's not possible to create an immutable array constant, an alternate approach to safeguard array values is through the use of protected setters.

public class ArrayConfig {
    private static final List<String> LIST_OF_OPTIONS = Collections.unmodifiableList(Arrays.asList("Yes", "No", "Maybe"));

    protected static void setOptions(String... newOptions) {
        // We are not controlling you but making sure you are making the right choices 
    }
}

Centralization of repeated values

For cases where some values are used repeatedly in annotations, centralizing them in a single place aids in avoiding redundancy and simplifies updates.

public class RouteMappings {
    public static final String DEFAULT_PATH = "/start/*"; // All journeys start at '/start'
}

@interface WebServiceRoute {
    String path() default RouteMappings.DEFAULT_PATH;
}

Considering Alternatives and Advanced Usage

Alternative data storage

Sometimes an annotation isn't the best option. It's good to consider whether you could use alternative methods like configuration files or database entries for maximum flexibility.

Deploying frameworks for runtime resolution

Seam Solder from Seam 3 is helpful when runtime-resolved parameters are in play. This can add dynamic features to your classic constants.

Delving into Java's Annotation Processor

Custom annotation processors can provide more complex constant evaluations at compile-time, making it a reliable tool in your Java toolkit.

Security and Testing of Constants

Testing constancy

Make sure your constants stay "constant" throughout your application's lifecycle. Verification is key here to ensure your annotation constants don't throw a 404 error!