Pengenalan Rangka Kerja Micronaut

1. Apa itu Mikronaut

Micronaut adalah kerangka kerja berbasis JVM untuk membangun aplikasi modular ringan. Dibangunkan oleh OCI, syarikat yang sama yang membuat Grails, Micronaut adalah kerangka terbaru yang dirancang untuk membuat pembuatan perkhidmatan mikro cepat dan mudah .

Walaupun Micronaut mengandungi beberapa ciri yang serupa dengan kerangka kerja yang ada seperti Spring, ia juga mempunyai beberapa ciri baru yang membezakannya. Dan dengan sokongan untuk Java, Groovy, dan Kotlin, ia menawarkan pelbagai cara untuk membuat aplikasi.

2. Ciri-ciri Utama

Salah satu ciri Micronaut yang paling menarik adalah mekanisme suntikan ketergantungan masa. Sebilangan besar kerangka menggunakan refleksi dan proksi untuk melakukan suntikan kebergantungan pada waktu berjalan. Micronaut, bagaimanapun, membina data suntikan kebergantungannya pada waktu kompilasi. Hasilnya adalah permulaan aplikasi yang lebih pantas dan jejak memori yang lebih kecil.

Ciri lain adalah sokongan kelas pertama untuk pengaturcaraan reaktif, untuk pelanggan dan pelayan. Pilihan pelaksanaan reaktif tertentu diserahkan kepada pembangun kerana kedua RxJava dan Project Reactor disokong.

Micronaut juga mempunyai beberapa ciri yang menjadikannya kerangka yang sangat baik untuk mengembangkan aplikasi asli cloud. Ia menyokong pelbagai alat penemuan perkhidmatan seperti Eureka dan Consul, dan juga berfungsi dengan sistem pengesanan yang diedarkan seperti Zipkin dan Jaeger.

Ini juga memberikan sokongan untuk membuat fungsi AWS lambda, menjadikannya mudah untuk membuat aplikasi tanpa server.

3. Bermula

Cara termudah untuk memulakan adalah menggunakan SDKMAN:

> sdk install micronaut 1.0.0.RC2

Ini memasang semua fail binari yang kita perlukan untuk membina, menguji, dan menggunakan aplikasi Micronaut. Ia juga menyediakan alat CLI Micronaut, yang memungkinkan kita dengan mudah memulakan projek baru.

Artifak binari juga terdapat di Sonatype dan GitHub.

Pada bahagian berikut kita akan melihat beberapa ciri kerangka.

4. Suntikan Ketergantungan

Seperti yang disebutkan sebelumnya, Micronaut menangani suntikan ketergantungan pada waktu kompilasi, yang berbeza daripada kebanyakan kontainer IoC.

Walau bagaimanapun, ia masih menyokong penjelasan JSR-330 sehingga bekerja dengan kacang sama dengan kerangka kerja IoC yang lain.

Untuk memasukkan kacang ke dalam kod kami, kami menggunakan @Inject:

@Inject private EmployeeService service;

The @Inject anotasi berfungsi seperti @Autowired dan boleh digunakan pada bidang, kaedah, pengeluar, dan parameter.

Secara lalai, semua kacang disertakan sebagai prototaip. Kita boleh membuat kacang singlet dengan cepat menggunakan @Singleton. Sekiranya beberapa kelas menerapkan antara muka kacang yang sama, @Primary boleh digunakan untuk membantahnya:

@Primary @Singleton public class BlueCar implements Car {}

The @Requires anotasi boleh digunakan apabila kacang adalah pilihan, atau hanya melakukan autowiring apabila keadaan tertentu dipenuhi.

Dalam hal ini, ia berperilaku seperti anotasi 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. Membina Pelayan HTTP

Sekarang mari kita lihat membuat aplikasi pelayan HTTP sederhana. Untuk memulakan, kami akan menggunakan SDKMAN untuk membuat projek:

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

Ini akan membuat projek Java baru menggunakan Maven dalam direktori bernama hello-world-server. Di dalam direktori ini, kami akan menemui kod sumber aplikasi utama kami, fail Maven POM, dan fail sokongan lain untuk projek tersebut.

Aplikasi lalai yang sangat mudah:

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

5.1. Menyekat HTTP

Dengan sendiri, aplikasi ini tidak akan banyak berlaku. Mari tambah pengawal yang mempunyai dua titik akhir. Kedua-duanya akan mengucapkan salam, tetapi yang satu akan menggunakan kata kerja GET HTTP, dan yang lain akan menggunakan 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. Reaktif IO

Secara lalai, Micronaut akan melaksanakan titik akhir ini menggunakan I / O sekatan tradisional. Walau bagaimanapun, kita dapat dengan cepat melaksanakan titik akhir yang tidak menyekat dengan hanya mengubah jenis pengembalian ke jenis yang tidak menyekat yang reaktif .

Sebagai contoh, dengan RxJava kita boleh menggunakan diperhatikan . Begitu juga, semasa menggunakan Reactor, kita dapat mengembalikan jenis data Mono atau Flux :

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

Untuk kedua-dua titik akhir yang menyekat dan tidak menyekat, Netty adalah pelayan asas yang digunakan untuk menangani permintaan HTTP.

Biasanya, permintaan ditangani pada kumpulan utas I / O utama yang dibuat semasa permulaan, menjadikannya tersekat.

Walau bagaimanapun, apabila jenis data yang tidak menyekat dikembalikan dari titik akhir pengawal, Micronaut menggunakan rangkaian gelung peristiwa Netty, menjadikan keseluruhan permintaan tidak menyekat.

6. Membina Pelanggan HTTP

Sekarang mari kita bina pelanggan untuk menggunakan titik akhir yang baru kita buat. Micronaut menyediakan dua cara untuk membuat klien HTTP:

  • Pelanggan HTTP deklaratif
  • Pelanggan HTTP terprogram

6.1 Pelanggan HTTP Deklaratif

Cara pertama dan tercepat untuk membuat adalah menggunakan pendekatan deklaratif:

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

Perhatikan bagaimana kita tidak menerapkan kod apa pun untuk memanggil perkhidmatan kami . Sebaliknya, Micronaut memahami bagaimana memanggil perkhidmatan dari kaedah tandatangan dan anotasi yang telah kami berikan.

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.

Seperti biasa, kita dapat mencari contoh kod di atas di repo GitHub kami.