Micronaut

https://micronaut-projects.github.io/micronaut-core/latest/guide/
Admin
Micronaut is a modern, JVM-based, full-stack framework for building modular, easily testable...
Tokens:455,590
Snippets:3,176
Trust Score:9.7
Update:1 day ago
Show doc for...
Tokens:
Raw
### Use Map Configuration (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Kotlin example that runs an ApplicationContext with a map of properties and prints the vehicle start message.

```kotlin
val subMap = mapOf(
    0 to "thermostat",
    1 to "fuel pressure"
)
val map = mapOf(
    "my.engine.cylinders" to "8",
    "my.engine.sensors" to subMap
)

val applicationContext = ApplicationContext.run(map, "test")

val vehicle = applicationContext.getBean(Vehicle::class.java)
println(vehicle.start())
```

--------------------------------

### Use Map Configuration (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Java example that builds a map of properties and runs an ApplicationContext, then prints the vehicle start message.

```java
Map<String, Object> map = new LinkedHashMap<>(2);
map.put("my.engine.cylinders", "8");

Map<Integer, String> map1 = new LinkedHashMap<>(2);
map1.put(0, "thermostat");
map1.put(1, "fuel pressure");

map.put("my.engine.sensors", map1);

ApplicationContext applicationContext = ApplicationContext.run(map, "test");

Vehicle vehicle = applicationContext.getBean(Vehicle.class);
System.out.println(vehicle.start());
```

--------------------------------

### Use Map Configuration (Groovy)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Groovy example that runs an ApplicationContext with a map of properties and prints the vehicle start message.

```groovy
ApplicationContext applicationContext = ApplicationContext.run(
        ['my.engine.cylinders': '8',
         'my.engine.sensors'  : [0: 'thermostat',
                                 1: 'fuel pressure']],
        "test"
)

def vehicle = applicationContext.getBean(Vehicle)
println(vehicle.start())
```

--------------------------------

### Supply Configuration in Java

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to supply configuration values to the ApplicationContext in Java using a Map of properties and the 'test' environment. The example then retrieves a Vehicle bean and prints its start() result.

```java
        Map<String, Object> properties = new HashMap<>();
        properties.put("my.engine.cylinders"             ,"4");
        properties.put("my.engine.manufacturer"          , "Subaru");
        properties.put("my.engine.crank-shaft.rod-length", 4);
        properties.put("my.engine.spark-plug.name"       , "6619 LFR6AIX");
        properties.put("my.engine.spark-plug.type"       , "Iridium");
        properties.put("my.engine.spark-plug.companyName", "NGK");
        ApplicationContext applicationContext = ApplicationContext.run(properties, "test");

        Vehicle vehicle = applicationContext.getBean(Vehicle.class);
        System.out.println(vehicle.start());
```

--------------------------------

### Run BeanContext and get Vehicle bean (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to start the BeanContext and retrieve the Vehicle bean using getBean(). The example prints the result of vehicle.start().

```java
final BeanContext context = BeanContext.run();
Vehicle vehicle = context.getBean(Vehicle.class);
System.out.println(vehicle.start());
```

--------------------------------

### Supply Configuration in Kotlin

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to supply configuration values to the ApplicationContext in Kotlin using a map and the 'test' environment. The example then retrieves a Vehicle bean and prints its start() result.

```kotlin
        val applicationContext = ApplicationContext.run(
                mapOf(
                        "my.engine.cylinders" to "4",
                        "my.engine.manufacturer" to "Subaru",
                        "my.engine.crank-shaft.rod-length" to 4,
                        "my.engine.spark-plug.name" to "6619 LFR6AIX",
                        "my.engine.spark-plug.type" to "Iridium",
                        "my.engine.spark-plug.company" to "NGK"
                ),
                "test"
        )

        val vehicle = applicationContext.getBean(Vehicle::class.java)
        println(vehicle.start())
```

--------------------------------

### Supply Configuration in Groovy

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to supply configuration values to the ApplicationContext in Groovy using a map literal and the 'test' environment. The example then retrieves a Vehicle bean and prints its start() result.

```groovy
        ApplicationContext applicationContext = ApplicationContext.run(
                ['my.engine.cylinders'             : '4',
                 'my.engine.manufacturer'          : 'Subaru',
                 'my.engine.crank-shaft.rod-length': 4,
                 'my.engine.spark-plug.name'       : '6619 LFR6AIX',
                 'my.engine.spark-plug.type'       : 'Iridium',
                 'my.engine.spark-plug.companyName': 'NGK'
                ],
                "test"
        )

        Vehicle vehicle = applicationContext.getBean(Vehicle)
        println(vehicle.start())
```

--------------------------------

### Configuring Versioning with Header and Parameter Strategies

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Full configuration example showing how to enable versioning, disable parameter-based versioning, specify parameter names, enable header-based versioning, and list header names.

```yaml
micronaut:
  router:
    versioning:
      enabled: true (1)
      parameter:
        enabled: false (2)
        names: 'v,api-version' (3)
      header:
        enabled: true (4)
        names: (5)
          - 'X-API-VERSION'
          - 'Accept-Version'
```

--------------------------------

### Using BeanProvider with @Any (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Example of injecting a BeanProvider with the @Any qualifier to get any available Engine instance. The ifPresent method is used to start the engine if present.

```java
import io.micronaut.context.BeanProvider;
import io.micronaut.context.annotation.Any;
import jakarta.inject.Singleton;

@Singleton
public class Vehicle {
    final BeanProvider<Engine> engineProvider;

    public Vehicle(@Any BeanProvider<Engine> engineProvider) { // (1)
        this.engineProvider = engineProvider;
    }
    void start() {
        engineProvider.ifPresent(Engine::start); // (2)
    }
}
```

--------------------------------

### Running the Native Application

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Run the built native image by its name. The output shows startup completes in milliseconds and the server runs at http://localhost:8080.

```bash
$ ./hello-world
15:15:15.153 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 14ms. Server Running: http://localhost:8080
```

--------------------------------

### @Read Method - Basic GET Endpoint

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Annotating a method with @Read causes it to respond to GET requests. The example shows a CurrentDateEndpoint that returns the current date as JSON.

```APIDOC
## [GET] /date

### Description
Annotating a method with @Read causes it to respond to GET requests. This example returns the current date.

### Method
GET

### Endpoint
/date

### Parameters
No parameters.

### Request Example
```bash
$ curl -X GET localhost:55838/date
```

### Response
#### Success Response (200)
- **currentDate** (Date) - The current date as a timestamp.

#### Response Example
```
1526085903689
```

```

--------------------------------

### Define immutable configuration with @ConfigurationProperties interface (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Kotlin version of the immutable configuration interface example. Uses Kotlin properties with @get:Bindable and @get:NotBlank annotations.

```kotlin
import io.micronaut.context.annotation.ConfigurationProperties
import io.micronaut.core.bind.annotation.Bindable
import javax.validation.constraints.Min
import javax.validation.constraints.NotBlank
import javax.validation.constraints.NotNull

@ConfigurationProperties("my.engine") // (1)
interface EngineConfig {

    @get:Bindable(defaultValue = "Ford") // (2)
    @get:NotBlank // (3)
    val manufacturer: String

    @get:Min(1L)
    val cylinders: Int

    @get:NotNull
    val crankShaft: CrankShaft // (4)

    @ConfigurationProperties("crank-shaft")
    interface CrankShaft { // (5)
        val rodLength: Double? // (6)
    }
}
```

--------------------------------

### Factory bean from field (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Kotlin version of the factory bean from field example. Uses @get:Bean and @get:Replaces annotations on a property, and JUnit 5 for testing.

```kotlin
@MicronautTest
class VehicleMockSpec {
    @get:Bean
    @get:Replaces(Engine::class)
    val mockEngine: Engine = object : Engine { // (1)
        override fun start(): String {
            return "Mock Started"
        }
    }

    @Inject
    lateinit var vehicle : Vehicle // (2)

    @Test
    fun testStartEngine() {
        val result = vehicle.start()
        Assertions.assertEquals("Mock Started", result) // (3)
    }
}
```

--------------------------------

### ResourceBundleMessageSource Example (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Retrieves messages using the messageSource bean. Uses MessageContext.of with a Locale to get localized messages. The example asserts that 'hello' returns 'Hola' for Spanish and 'Hello' for English.

```java
assertEquals("Hola", messageSource.getMessage("hello", MessageContext.of(new Locale("es"))).get());
assertEquals("Hello", messageSource.getMessage("hello", MessageContext.of(Locale.ENGLISH)).get());
```

--------------------------------

### @Value Example (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Java example of injecting a property with a default value using @Value. The placeholder ${my.engine.cylinders:6} injects 6 if the property is missing. The injected value is used in the start() method.

```java
import io.micronaut.context.annotation.Value;

import jakarta.inject.Singleton;

@Singleton
public class EngineImpl implements Engine {

    @Value("${my.engine.cylinders:6}") // (1)
    protected int cylinders;

    @Override
    public int getCylinders() {
        return cylinders;
    }

    @Override
    public String start() {// (2)
        return "Starting V" + getCylinders() + " Engine";
    }

}
```

--------------------------------

### Supply configuration (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to run an ApplicationContext with configuration values for my.engine.cylinders and my.engine.crank-shaft.rod-length, then retrieve a Vehicle bean and print its start message.

```java
ApplicationContext applicationContext = ApplicationContext.run(CollectionUtils.mapOf(
        "my.engine.cylinders", "8",
        "my.engine.crank-shaft.rod-length", "7.0"
));

Vehicle vehicle = applicationContext.getBean(Vehicle.class);
System.out.println(vehicle.start());
```

--------------------------------

### Kotlin controller example

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

A simple Micronaut controller written in Kotlin that responds to GET requests with a greeting.

```kotlin
package example

import io.micronaut.http.annotation.*

@Controller("/")
class HelloController {

    @Get("/hello/{name}")
    fun hello(name: String): String {
        return "Hello $name"
    }
}
```

--------------------------------

### Create application my-demo-app with default package

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Running 'mn create-app my-demo-app' results in the default package 'my.demo.app'.

```bash
$ mn create-app my-demo-app
```

--------------------------------

### EnvironmentEndpointFilter with maskNone and exclude patterns

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/

Use this filter to allow all environment values in plain text except those matching specified patterns. The example masks names starting with 'sekrt', exactly matching 'exact-match', or starting with 'private.'.

```java
@Singleton
public class AllPlainExceptSecretOrMatchEnvFilter implements EnvironmentEndpointFilter {
    // Mask anything starting with `sekrt`
    private static final Pattern SECRET_PREFIX_PATTERN = Pattern.compile("sekrt.*", Pattern.CASE_INSENSITIVE);

    // Mask anything exactly matching `exact-match`
    private static final String EXACT_MATCH = "exact-match";

    // Mask anything that starts with `private.`
    private static final Predicate<String> PREDICATE_MATCH = name -> name.startsWith("private.");

    @Override
    public void specifyFiltering(@NotNull EnvironmentFilterSpecification specification) {
        specification
                .maskNone() // All values will be in plain-text apart from the supplied patterns
                .exclude(SECRET_PREFIX_PATTERN)
                .exclude(EXACT_MATCH)
                .exclude(PREDICATE_MATCH);
    }
}
```

--------------------------------

### Logback configuration example (logback.xml)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Example logback.xml configuration with a console appender and root level info.

```xml
<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <withJansi>true</withJansi>

        <encoder>
            <pattern>%cyan(%d{HH:mm:ss.SSS}) %gray([%thread]) %highlight(%-5level) %magenta(%logger{36}) - %msg%n
            </pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="STDOUT"/>
    </root>

</configuration>
```

--------------------------------

### List available features with --list-features

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/

Use `create-app --list-features` to display available features. The output shows a table of features with descriptions, and features included by default are marked with a plus sign.

```bash
mn> create-app --list-features
Available Features
(+) denotes the feature is included by default
  Name                             Description
  -------------------------------  ---------------
  Cache
  cache-caffeine                   Adds support for cache using Caffeine (https://github.com/ben-manes/caffeine)
  cache-ehcache                    Adds support for cache using EHCache (https://www.ehcache.org/)
  cache-hazelcast                  Adds support for cache using Hazelcast (https://hazelcast.org/)
  cache-infinispan                 Adds support for cache using Infinispan (https://infinispan.org/)
```

--------------------------------

### Defining a main entry point with Micronaut.run

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Place this call in the main method to start the Micronaut HTTP server. The passed arguments are transformed into a CommandLinePropertySource and available for dependency injection via @Value.

```java
public static void main(String[] args) {
    Micronaut.run(Application.class, args);
}
```

--------------------------------

### Using @Property to resolve sub-maps

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Example of using @Property to inject a flattened map containing only properties starting with 'hibernate' from the 'jpa.default.properties' configuration.

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

--------------------------------

### Create-Client Command Example

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Generates a Client interface following a *Client convention. Does not create an associated test.

```bash
$ mn create-client Book
| Rendered template Client.java to destination src/main/java/example/BookClient.java
```

--------------------------------

### Programmatically creating Secondary servers (Groovy)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Groovy version of the same Factory Bean example. It uses the same approach but with Groovy syntax, including 'def' for local variables and property access for configuration. The server is started and registered as a bean, and its URI is exposed via a ServiceInstanceList.

```groovy
import io.micronaut.context.annotation.Bean
import io.micronaut.context.annotation.Context
import io.micronaut.context.annotation.Factory
import io.micronaut.context.annotation.Requires
import io.micronaut.context.env.Environment
import io.micronaut.core.util.StringUtils
import io.micronaut.discovery.ServiceInstanceList
import io.micronaut.discovery.StaticServiceInstanceList
import io.micronaut.http.server.netty.NettyEmbeddedServer
import io.micronaut.http.server.netty.NettyEmbeddedServerFactory
import io.micronaut.http.server.netty.configuration.NettyHttpServerConfiguration
import io.micronaut.http.ssl.ServerSslConfiguration
import jakarta.inject.Named

@Factory
class SecondaryNettyServer {
    static final String SERVER_ID = "another" // (1)

    @Named(SERVER_ID)
    @Context
    @Bean(preDestroy = "stop") // (2)
    @Requires(beans = Environment.class)
    NettyEmbeddedServer nettyEmbeddedServer(NettyEmbeddedServerFactory serverFactory) { // (3)
        def configuration =
                new NettyHttpServerConfiguration() // (4)
        def sslConfiguration = new ServerSslConfiguration() // (5)
        sslConfiguration.setBuildSelfSigned(true)
        sslConfiguration.enabled = true
        sslConfiguration.port = -1 // random port
        // configure server programmatically
        final NettyEmbeddedServer embeddedServer = serverFactory.build(configuration, sslConfiguration) // (5)
        embeddedServer.start() // (6)
        return embeddedServer // (7)
    }

    @Bean
    ServiceInstanceList serviceInstanceList( // (8)
                                             @Named(SERVER_ID) NettyEmbeddedServer nettyEmbeddedServer) {
        return new StaticServiceInstanceList(
                SERVER_ID,
                [ nettyEmbeddedServer.URI ]
        )
    }
}
```

--------------------------------

### Micronaut Groovy controller with @Controller

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/

Example Groovy controller generated by the CLI. Uses `@Controller("/hello")` and `@Get` to return `HttpStatus.OK`.

```groovy
package hello.world

import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.HttpStatus

@Controller("/hello")
class HelloController {

    @Get
    HttpStatus index() {
        return HttpStatus.OK
    }
}

```

--------------------------------

### Create application with custom default package

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Prefix the application name with the desired package to set the default package. For example, 'example.my-demo-app' results in the default package 'example'.

```bash
$ mn create-app example.my-demo-app
```

--------------------------------

### Using retrieve to perform an HTTP GET (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to use the retrieve method to execute an HTTP GET and receive the response body as a String. The example builds a URI with UriBuilder and expands a template variable. It calls toBlocking() for illustration, but production code should avoid blocking.

```kotlin
val uri = UriBuilder.of("/hello/{name}")
                    .expand(Collections.singletonMap("name", "John"))
                    .toString()
uri shouldBe "/hello/John"

val result = client.toBlocking().retrieve(uri)

result shouldBe "Hello John"
```

--------------------------------

### Using retrieve to perform an HTTP GET (Groovy)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to use the retrieve method to execute an HTTP GET and receive the response body as a String. The example builds a URI with UriBuilder and expands a template variable. It calls toBlocking() for illustration, but production code should avoid blocking.

```groovy
when:
String uri = UriBuilder.of("/hello/{name}")
                       .expand(name: "John")
then:
"/hello/John" == uri

when:
String result = client.toBlocking().retrieve(uri)

then:
"Hello John" == result
```

--------------------------------

### Using retrieve to perform an HTTP GET (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Shows how to use the retrieve method to execute an HTTP GET and receive the response body as a String. The example builds a URI with UriBuilder and expands a template variable. It calls toBlocking() for illustration, but production code should avoid blocking.

```java
String uri = UriBuilder.of("/hello/{name}")
                       .expand(Collections.singletonMap("name", "John"))
                       .toString();
assertEquals("/hello/John", uri);

String result = client.toBlocking().retrieve(uri);

assertEquals("Hello John", result);
```

--------------------------------

### Create a Micronaut application using curl and unzip

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Alternative to the CLI: download the project zip from Micronaut Launch using curl, unzip it, and change into the project directory. Add ?build=maven to the URL to generate a Maven project.

```bash
curl https://launch.micronaut.io/hello-world.zip -o hello-world.zip
unzip hello-world.zip
cd hello-world
```

--------------------------------

### Supply configuration (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Kotlin version of supplying configuration values to ApplicationContext.run and printing the vehicle start message.

```kotlin
val map = mapOf(
        "my.engine.cylinders" to "8",
        "my.engine.crank-shaft.rod-length" to "7.0"
)
val applicationContext = ApplicationContext.run(map)

val vehicle = applicationContext.getBean(Vehicle::class.java)
println(vehicle.start())
```

--------------------------------

### Schedule with Initial Delay using @Scheduled(initialDelay)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Use the initialDelay member to run a task once after the server starts. The example runs once, one minute after startup.

```java
@Scheduled(initialDelay = "1m")
void onceOneMinuteAfterStartup() {
    System.out.println("Executing onceOneMinuteAfterStartup()");
}
```

```groovy
@Scheduled(initialDelay = "1m")
void onceOneMinuteAfterStartup() {
    println "Executing onceOneMinuteAfterStartup()"
}
```

```kotlin
@Scheduled(initialDelay = "1m")
internal fun onceOneMinuteAfterStartup() {
    println("Executing onceOneMinuteAfterStartup()")
}
```

--------------------------------

### ConfigurationInfoSource example in application.groovy

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Example configuration for the ConfigurationInfoSource. It sets properties under the 'info' key, including a string, an integer, and a map. The resulting JSON response from the info endpoint is shown.

```groovy
info.demo.string = "demo string"
info.demo.number = 123
info.demo.map = [key: 'value', other_key: 123]
```

```json
{
  "demo": {
    "string": "demo string",
    "number": 123,
    "map": {
      "key": "value",
      "other_key": 123
    }
  }
}
```

--------------------------------

### Programmatically creating Secondary servers (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Java example of a Factory Bean that starts an additional Netty server using NettyEmbeddedServerFactory. It configures the server programmatically with a self-signed SSL certificate and a random port, then starts it. The server is registered as a bean with the name 'another' and its URI is exposed via a ServiceInstanceList.

```java
import java.util.Collections;
import io.micronaut.context.annotation.Bean;
import io.micronaut.context.annotation.Context;
import io.micronaut.context.annotation.Factory;
import io.micronaut.context.annotation.Requires;
import io.micronaut.context.env.Environment;
import io.micronaut.core.util.StringUtils;
import io.micronaut.discovery.ServiceInstanceList;
import io.micronaut.discovery.StaticServiceInstanceList;
import io.micronaut.http.server.netty.NettyEmbeddedServer;
import io.micronaut.http.server.netty.NettyEmbeddedServerFactory;
import io.micronaut.http.server.netty.configuration.NettyHttpServerConfiguration;
import io.micronaut.http.ssl.ServerSslConfiguration;
import jakarta.inject.Named;

@Factory
public class SecondaryNettyServer {
    public static final String SERVER_ID = "another"; // (1)

    @Named(SERVER_ID)
    @Context
    @Bean(preDestroy = "close") // (2)
    @Requires(beans = Environment.class)
    NettyEmbeddedServer nettyEmbeddedServer(NettyEmbeddedServerFactory serverFactory) { // (3)
        // configure server programmatically
        final NettyHttpServerConfiguration configuration =
                new NettyHttpServerConfiguration(); // (4)
        final ServerSslConfiguration sslConfiguration = new ServerSslConfiguration(); // (5)
        sslConfiguration.setBuildSelfSigned(true);
        sslConfiguration.setEnabled(true);
        sslConfiguration.setPort(-1); // random port
        final NettyEmbeddedServer embeddedServer = serverFactory.build(configuration, sslConfiguration); // (6)
        embeddedServer.start(); // (7)
        return embeddedServer; // (8)
    }

    @Bean
    ServiceInstanceList serviceInstanceList( // (9)
            @Named(SERVER_ID) NettyEmbeddedServer nettyEmbeddedServer) {
        return new StaticServiceInstanceList(
                SERVER_ID,
                Collections.singleton(nettyEmbeddedServer.getURI())
        );
    }
}
```

--------------------------------

### Retrieving the AUTHORIZATION_INFO header (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Kotlin example showing how to retrieve the AUTHORIZATION_INFO header from the response of a GET request to /shopping/cart. The header is present in the response and the cart is not null.

```kotlin
var response = Flux.from(client.exchange(HttpRequest.GET<Cart>("/shopping/cart"), Cart::class.java)) // (1)
                     .blockFirst()
var cart = response.body()

assertNotNull(response.header(HttpHeaders.AUTHORIZATION_INFO)) // (2)
assertNotNull(cart)
cart.items.isEmpty()
```

--------------------------------

### Start a Maven project

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Command to run a generated Micronaut Maven project.

```bash
$ ./mvnw mn:run
```

--------------------------------

### Bind configuration from map (Kotlin)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Kotlin setup using @BeforeEach and @AfterEach to run and close the ApplicationContext with a map for 'myapp.updatedAt'.

```kotlin
lateinit var ctx: ApplicationContext

@BeforeEach
fun setup() {
    ctx = ApplicationContext.run(
        mapOf(
            "myapp.updatedAt" to mapOf( // (1)
                "day" to 28,
                "month" to 10,
                "year" to 1982
            )
        )
    )
}

@AfterEach
fun teardown() {
    ctx?.close()
}
```

--------------------------------

### Retrieving the AUTHORIZATION_INFO header (Groovy)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Groovy example showing how to retrieve the AUTHORIZATION_INFO header from the response of a GET request to /shopping/cart. The header is present in the response and the cart is not null.

```groovy
when: "The shopping cart is retrieved"
HttpResponse<Cart> response = client.exchange(HttpRequest.GET('/shopping/cart'), Cart) // (1)
                                        .blockFirst()
Cart cart = response.body()

then: "The shopping cart is present as well as a session id header"
response.header(HttpHeaders.AUTHORIZATION_INFO) != null // (2)
cart != null
cart.items.isEmpty()
```

--------------------------------

### Supply Configuration with Map (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Creates an ApplicationContext with a map containing 'my.engine.cylinders' and the 'test' environment, then retrieves a Vehicle bean and prints its start message.

```java
Map<String, Object> map = new LinkedHashMap<>(1);
map.put("my.engine.cylinders", "8");
ApplicationContext applicationContext = ApplicationContext.run(map, "test");

Vehicle vehicle = applicationContext.getBean(Vehicle.class);
System.out.println(vehicle.start());
```

--------------------------------

### Retrieving the AUTHORIZATION_INFO header (Java)

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Java example showing how to retrieve the AUTHORIZATION_INFO header from the response of a GET request to /shopping/cart. The header is present in the response and the cart is not null.

```java
HttpResponse<Cart> response = Flux.from(client.exchange(HttpRequest.GET("/shopping/cart"), Cart.class)) // (1)
                                    .blockFirst();
Cart cart = response.body();

assertNotNull(response.header(HttpHeaders.AUTHORIZATION_INFO)); // (2)
assertNotNull(cart);
assertTrue(cart.getItems().isEmpty());
```

--------------------------------

### Micronaut Groovy client with @Client

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/

Example Groovy client interface generated by the CLI. Uses `@Client("hello")` and `@Get` to define an HTTP client.

```groovy
package hello.world

import io.micronaut.http.client.annotation.Client
import io.micronaut.http.annotation.Get
import io.micronaut.http.HttpStatus

@Client("hello")
interface HelloClient {

    @Get
    HttpStatus index()
}

```

--------------------------------

### Create-Controller Command Example

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Generates a Controller class following a *Controller convention. Creates an associated test that runs the application and instantiates an HTTP client.

```bash
$ mn create-controller Book
| Rendered template Controller.java to destination src/main/java/example/BookController.java
| Rendered template ControllerTest.java to destination src/test/java/example/BookControllerTest.java
```

--------------------------------

### Set rebelAgent property in gradle.properties

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Add the path to the JRebel agent as the rebelAgent property in gradle.properties. The example assumes an installation path of ~/bin/jrebel/ and uses the macOS 64-bit agent.

```properties
#Assuming installation path of ~/bin/jrebel/
rebelAgent= -agentpath:~/bin/jrebel/lib/libjrebel64.dylib
```

--------------------------------

### Specifying environments with micronaut.environments

Source: https://micronaut-projects.github.io/micronaut-core/latest/guide/index.html

Command-line example that activates environments 'foo' and 'bar' using the micronaut.environments system property.

```bash
$ java -Dmicronaut.environments=foo,bar -jar myapp.jar
```
Tokens:
Raw