Consider the following example:

@Value Example

@Value Example

import javax.inject.Singleton
@Singleton
class EngineImpl implements Engine {
    @Value('${my.engine.cylinders:6}') (1)
    protected int cylinders
    @Override
    int getCylinders() {
        this.cylinders
    }
    String start() { (2)
        "Starting V${cylinders} Engine"
    }
}

@Value Example

import javax.inject.Singleton
@Singleton
class EngineImpl : Engine {
    @Value("\${my.engine.cylinders:6}") (1)
    override var cylinders: Int = 0
        protected set
    override fun start(): String {(2)
        return "Starting V$cylinders Engine"
    }
}

Note that @Value can also be used to inject a static value, for example the following will inject the number 10:

Static @Value Example

@Value("10")
int number;

However it is definitely more useful when used to compose injected values combining static content and placeholders. For example to setup a URL:

Placeholders with @Value

In the above example the URL is constructed from 2 placeholder properties that must be present in configuration: my.host and my.port.

Placeholders with @Value

@Value("${my.url:`http://foo.com`}")
URL url;

Note that there is nothing special about @Value itself regarding the resolution of property value placeholders.

Due to Micronaut’s extensive support for annotation metadata you can in fact use property placeholder expressions on any annotation. For example, to make the path of a @Controller configurable you can do:

    ...
}

In the above case if hello.controller.path is specified in configuration then the controller will be mapped to the path specified otherwise it will be mapped to /hello.

You can also make the target server for configurable (although service discovery approaches are often better), for example:

@Client("${my.server.url:`http://localhost:8080`}")
interface HelloClient {
    ...
}

In the above example the property my.server.url can be used to configure the client otherwise the client will fallback to a localhost address.

Using the @Property Annotation

Recall that the annotation receives a String value which is a mix of static content and placeholder expressions. This can lead to confusion if you attempt to do the following:

Incorrect usage of @Value

In the above case the value my.url will be injected and set to the url field and not the value of the my.url property from your application configuration, this is because @Value only resolves placeholders within the value specified to it.

Using @Property

import io.micronaut.context.annotation.Property;
import javax.inject.Inject;
import javax.inject.Singleton;
@Singleton
public class Engine {
    @Property(name = "my.engine.cylinders") (1)
    protected int cylinders; (2)
    private String manufacturer;
    public int getCylinders() {
        return cylinders;
    }
    public String getManufacturer() {
        return manufacturer;
    }
    @Inject
    public void setManufacturer(@Property(name = "my.engine.manufacturer") String manufacturer) { (3)
        this.manufacturer = manufacturer;
    }
}

Using @Property

import io.micronaut.context.annotation.Property
@Singleton
class Engine {
    @Property(name = "my.engine.cylinders") (1)
    protected int cylinders (2)
    @Property(name = "my.engine.manufacturer") (3)
    String manufacturer
    int getCylinders() {
        cylinders
    }
}

Using @Property

import io.micronaut.context.annotation.Property
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class Engine {
    @field:Property(name = "my.engine.cylinders") (1)
    protected var cylinders: Int = 0 (2)
    @set:Inject
    @setparam:Property(name = "my.engine.manufacturer") (3)
    var manufacturer: String? = null
    fun cylinders(): Int {
        return cylinders
    }
}

The above will instead inject the value of the my.url property resolved from application configuration. If the property can not be found in configuration, an exception will be thrown. As with other types of injection, the injection point can also be annotated with @Nullable to make the injection optional.

You can also use this feature to resolve sub maps. For example, consider the following configuration:

Example application.yml configuration

If you wish to resolve a flattened map containing only the properties starting with hibernate then you can do so with @Property, for example:

Using @Property

@Property(name = "jpa.default.properties")
Map<String, String> jpaProperties;

The injected map will contain the keys hibernate.hbm2ddl.auto and and their values.