Micronaut Framework 소개

1. Micronaut 란?

Micronaut는 경량의 모듈 식 애플리케이션을 구축하기위한 JVM 기반 프레임 워크입니다. Grails를 만든 회사 인 OCI에서 개발 한 Micronaut는 마이크로 서비스를 빠르고 쉽게 만들 수 있도록 설계된 최신 프레임 워크입니다 .

Micronaut에는 Spring과 같은 기존 프레임 워크와 유사한 일부 기능이 포함되어 있지만이를 차별화하는 몇 가지 새로운 기능도 있습니다. 또한 Java, Groovy 및 Kotlin을 지원하여 애플리케이션을 만드는 다양한 방법을 제공합니다.

2. 주요 특징

Micronaut의 가장 흥미로운 기능 중 하나는 컴파일 시간 종속성 주입 메커니즘입니다. 대부분의 프레임 워크는 리플렉션과 프록시를 사용하여 런타임에 종속성 주입을 수행합니다. 그러나 Micronaut는 컴파일 타임에 종속성 주입 데이터를 빌드합니다. 그 결과 애플리케이션 시작 속도가 빨라지고 메모리 공간이 줄어 듭니다.

또 다른 기능은 클라이언트와 서버 모두에 대한 반응 형 프로그래밍에 대한 최고 수준의 지원입니다. RxJava와 Project Reactor가 모두 지원되므로 특정 리 액티브 구현의 선택은 개발자에게 맡겨집니다.

Micronaut에는 클라우드 네이티브 애플리케이션 개발을위한 훌륭한 프레임 워크가되는 몇 가지 기능도 있습니다. Eureka 및 Consul과 같은 여러 서비스 검색 도구를 지원하며 Zipkin 및 Jaeger와 같은 다양한 분산 추적 시스템에서도 작동합니다.

또한 AWS Lambda 함수 생성을 지원하므로 서버리스 애플리케이션을 쉽게 생성 할 수 있습니다.

3. 시작하기

시작하는 가장 쉬운 방법은 SDKMAN을 사용하는 것입니다.

> sdk install micronaut 1.0.0.RC2

이렇게하면 Micronaut 애플리케이션을 빌드, 테스트 및 배포하는 데 필요한 모든 바이너리 파일이 설치됩니다. 또한 새 프로젝트를 쉽게 시작할 수있는 Micronaut CLI 도구도 제공합니다.

바이너리 아티팩트는 Sonatype 및 GitHub에서도 사용할 수 있습니다.

다음 섹션에서는 프레임 워크의 몇 가지 기능을 살펴 보겠습니다.

4. 의존성 주입

앞서 언급했듯이 Micronaut는 대부분의 IoC 컨테이너와 다른 컴파일 타임에 종속성 주입을 처리합니다.

그러나 여전히 JSR-330 주석을 완전히 지원 하므로 빈 작업은 다른 IoC 프레임 워크와 유사합니다.

빈을 코드에 자동 연결하려면 @Inject 를 사용합니다 .

@Inject private EmployeeService service;

@Inject 주석처럼 작동 @Autowired 와 필드, 메소드, 생성자 및 매개 변수에 사용할 수 있습니다.

기본적으로 모든 Bean은 프로토 타입으로 범위가 지정됩니다. @Singleton을 사용하여 싱글 톤 빈을 빠르게 만들 수 있습니다 . 여러 클래스가 동일한 빈 인터페이스를 구현하는 경우 @Primary 를 사용하여 충돌을 해제 할 수 있습니다.

@Primary @Singleton public class BlueCar implements Car {}

@Requires 주석은 콩은 선택 할 때 사용하거나 특정 조건이 충족 될 때 autowiring에 수행 할 수 있습니다.

이와 관련하여 Spring Boot @Conditional 주석 과 매우 유사하게 작동합니다 .

@Singleton @Requires(beans = DataSource.class) @Requires(property = "enabled") @Requires(missingBeans = EmployeeService) @Requires(sdk = Sdk.JAVA, value = "1.8") public class JdbcEmployeeService implements EmployeeService {}

5. HTTP 서버 구축

이제 간단한 HTTP 서버 애플리케이션을 만드는 방법을 살펴 보겠습니다. 시작하려면 SDKMAN을 사용하여 프로젝트를 생성합니다.

> mn create-app hello-world-server -build maven

그러면 hello-world-server 라는 디렉토리에 Maven을 사용하여 새 Java 프로젝트가 생성됩니다 . 이 디렉토리 안에는 메인 애플리케이션 소스 코드, Maven POM 파일 및 프로젝트에 대한 기타 지원 파일이 있습니다.

매우 간단한 기본 애플리케이션 :

public class ServerApplication { public static void main(String[] args) { Micronaut.run(ServerApplication.class); } }

5.1. HTTP 차단

이 응용 프로그램은 그 자체로 많은 일을하지 않습니다. 두 개의 엔드 포인트가있는 컨트롤러를 추가해 보겠습니다. 둘 다 인사말을 반환하지만 하나는 GET HTTP 동사를 사용하고 다른 하나는 POST 를 사용 합니다.

@Controller("/greet") public class GreetController { @Inject private GreetingService greetingService; @Get("/{name}") public String greet(String name) { return greetingService.getGreeting() + name; } @Post(value = "/{name}", consumes = MediaType.TEXT_PLAIN) public String setGreeting(@Body String name) { return greetingService.getGreeting() + name; } }

5.2. 반응성 IO

기본적으로 Micronaut는 기존의 차단 I / O를 사용하여 이러한 엔드 포인트를 구현합니다. 그러나 반환 유형을 반응 형 비 차단 유형으로 변경하는 것만으로 비 차단 엔드 포인트를 신속하게 구현할 수 있습니다 .

예를 들어 RxJava에서는 Observable 을 사용할 수 있습니다 . 마찬가지로 Reactor를 사용할 때 Mono 또는 Flux 데이터 유형을 반환 할 수 있습니다.

@Get("/{name}") public Mono greet(String name) { return Mono.just(greetingService.getGreeting() + name); }

차단 및 비 차단 엔드 포인트 모두에 대해 Netty는 HTTP 요청을 처리하는 데 사용되는 기본 서버입니다.

Normally, the requests are handled on the main I/O thread pool that is created at startup, making them block.

However, when a non-blocking data type is returned from a controller endpoint, Micronaut uses the Netty event loop thread, making the whole request non-blocking.

6. Building an HTTP Client

Now let's build a client to consume the endpoints we just created. Micronaut provides two ways of creating HTTP clients:

  • A declarative HTTP Client
  • A programmatic HTTP Client

6.1 Declarative HTTP Client

The first and quickest way to create is using a declarative approach:

@Client("/greet") public interface GreetingClient { @Get("/{name}") String greet(String name); }

Notice how we don't implement any code to call our service. Instead, Micronaut understands how to call the service from the method signature and annotations we have provided.

To test this client, we can create a JUnit test that uses the embedded server API to run an embedded instance of our server:

public class GreetingClientTest { private EmbeddedServer server; private GreetingClient client; @Before public void setup() { server = ApplicationContext.run(EmbeddedServer.class); client = server.getApplicationContext().getBean(GreetingClient.class); } @After public void cleanup() { server.stop(); } @Test public void testGreeting() { assertEquals(client.greet("Mike"), "Hello Mike"); } }

6.2. Programmatic HTTP Client

We also have the option of writing a more traditional client if we need more control over its behavior and implementation:

@Singleton public class ConcreteGreetingClient { private RxHttpClient httpClient; public ConcreteGreetingClient(@Client("/") RxHttpClient httpClient) { this.httpClient = httpClient; } public String greet(String name) { HttpRequest req = HttpRequest.GET("/greet/" + name); return httpClient.retrieve(req).blockingFirst(); } public Single greetAsync(String name) { HttpRequest req = HttpRequest.GET("/async/greet/" + name); return httpClient.retrieve(req).first("An error as occurred"); } }

The default HTTP client uses RxJava, so can easily work with blocking or non-blocking calls.

7. Micronaut CLI

We've already seen the Micronaut CLI tool in action above when we used it to create our sample project.

In our case, we created a standalone application, but it has several other capabilities as well.

7.1. Federation Projects

In Micronaut, a federation is just a group of standalone applications that live under the same directory. By using federations, we can easily manage them together and ensure they get the same defaults and settings.

When we use the CLI tool to generate a federation, it takes all the same arguments as the create-app command. It will create a top-level project structure, and each standalone app will be created in its sub-directory from there.

7.2. Features

When creating a standalone application or federation, we can decide which features our app needs. This helps ensure the minimal set of dependencies is included in the project.

We specify features using the -features argument and supplying a comma-separated list of feature names.

We can find a list of available features by running the following command:

> mn profile-info service Provided Features: -------------------- * annotation-api - Adds Java annotation API * config-consul - Adds support for Distributed Configuration with Consul * discovery-consul - Adds support for Service Discovery with Consul * discovery-eureka - Adds support for Service Discovery with Eureka * groovy - Creates a Groovy application [...] More features available

7.3. Existing Projects

We can also use the CLI tool to modify existing projects. Enabling us to create beans, clients, controllers, and more. When we run the mn command from inside an existing project, we'll have a new set of commands available:

> mn help | Command Name Command Description ----------------------------------------------- create-bean Creates a singleton bean create-client Creates a client interface create-controller Creates a controller and associated test create-job Creates a job with scheduled method

8. Conclusion

In this brief introduction to Micronaut, we've seen how easy it is to build both blocking and non-blocking HTTP servers and clients. Also, we explored some features of its CLI.

But this is just a small taste of the features it offers. There is also full support for serverless functions, service discovery, distributed tracing, monitoring and metrics, a distributed configuration, and much more.

And while many of its features are derived from existing frameworks such as Grails and Spring, it also has plenty of unique features that help it stand out on its own.

항상 그렇듯이 위의 샘플 코드는 GitHub 저장소에서 찾을 수 있습니다.