Meneroka Kacang Sintetik di Quarkus. Mekanisme Sambungan Yang Kuat

Dalam dunia Quarkus, alam suntikan pergantungan kaya dan serba boleh, menawarkan pembangun pelbagai alatan untuk mengurus dan mengawal kacang. Salah satu alat tersebut ialah konsep kacang sintetik. Kacang sintetik ialah mekanisme lanjutan yang berkuasa yang membolehkan anda mendaftarkan kacang yang atributnya tidak diperoleh daripada kelas, kaedah atau medan Java. Sebaliknya, semua sifat kacang sintetik ditakrifkan oleh sambungan.

Dalam artikel ini, kami akan menyelami dunia kacang sintetik di Quarkus. Kami akan meneroka keperluan untuk kacang sintetik, aplikasi praktikalnya dan cara mencipta serta menggunakannya dalam aplikasi Quarkus anda.

Memahami Kacang Sintetik

Dalam Quarkus, kacang ialah bahan binaan aplikasi anda, diuruskan oleh rangka kerja Suntikan Konteks dan Ketergantungan (CDI). Biasanya, kacang CDI ialah kelas Java yang diberi anotasi dengan pelbagai anotasi CDI seperti @ApplicationScoped, @RequestScoped atau @Inject. Anotasi ini
benarkan CDI mengurus kitaran hayat dan suntikan kacang secara automatik.

Walau bagaimanapun, terdapat situasi di mana anda mungkin perlu mendaftarkan kacang yang tidak sesuai dengan model CDI tradisional. Di sinilah kacang sintetik dimainkan. Kacang sintetik dicipta dengan sambungan dan mempunyai sifat-sifatnya ditakrifkan sepenuhnya oleh sambungan ini. Dalam dunia CDI biasa, anda akan mencapai ini menggunakan kaedah AfterBeanDiscovery.addBean() dan SyntheticComponents.addBean(). Dalam Quarkus, ini dicapai menggunakan SyntheticBeanBuildItem.

Bilakah Anda Memerlukan Kacang Sintetik?

Jadi, bilakah anda mungkin perlu menggunakan kacang sintetik di Quarkus? Kacang sintetik adalah alat yang berkuasa apabila:

1. Menyepadukan Perpustakaan Pihak Ketiga: Anda sedang bekerja dengan perpustakaan pihak ketiga yang tidak mempunyai anotasi CDI tetapi perlu disepadukan ke dalam aplikasi berasaskan CDI anda. Kacang sintetik membolehkan anda merapatkan jurang ini.

2. Pendaftaran Kacang Dinamik: Anda perlu mendaftarkan kacang secara dinamik pada masa larian, bergantung pada konfigurasi atau faktor lain. Kacang sintetik memberi anda fleksibiliti untuk mencipta dan mendaftarkan kacang dengan segera.

3. Pengurusan Kacang Tersuai: Anda memerlukan kawalan terperinci ke atas skop dan tingkah laku kacang yang tidak boleh dicapai dengan anotasi CDI standard.

4. Melaksanakan Kacang Khusus: Anda ingin mencipta kacang khusus dengan atribut unik yang tidak sepadan dengan kelas atau kaedah Java tradisional.

5. Ketergantungan Mengejek untuk Pengujian: Kacang sintetik menyediakan cara yang berguna untuk mengejek kebergantungan dan menyuntik pelaksanaan olok-olok untuk tujuan ujian.

SynthesisFinishedBuildItem

SynthesisFinishedBuildItem digunakan untuk menunjukkan bahawa penemuan kacang CDI dan proses pendaftaran telah selesai. Ini membolehkan sambungan mengetahui bila ia selamat untuk berinteraksi dengan kacang yang telah didaftarkan.

Contohnya:

@BuildStep  
void onSynthesisFinished(SynthesisFinishedBuildItem synthesisFinished){
    // CDI bean registration is complete, can now safely interact with beans
    }

SyntheticBeansRuntimeInitBuildItem

SyntheticBeansRuntimeInitBuildItem digunakan untuk mendaftarkan panggilan balik yang akan digunakan pada masa jalan selepas semua kacang sintetik telah dimulakan. Ini berguna jika anda perlu melakukan logik permulaan tambahan yang melibatkan kacang sintetik.

Contohnya:

@BuildStep
SyntheticBeansRuntimeInitBuildItem initSyntheticBeans(){

    return new SyntheticBeansRuntimeInitBuildItem(ids->{
    // Perform logic with initialized synthetic beans
    });

    }

Panggil balik yang dihantar kepada SyntheticBeansRuntimeInitBuildItem akan menerima Set mengandungi ID semua biji sintetik yang dimulakan.

Jadi secara ringkasnya, SynthesisFinishedBuildItem menunjukkan penemuan kacang telah dilakukan, manakala SyntheticBeansRuntimeInitBuildItem membenarkan permulaan logik bergantung pada kacang sintetik.

Mencipta Kacang Sintetik dengan SyntheticBeanBuildItem

Di Quarkus, mencipta kacang sintetik adalah proses yang mudah, terima kasih kepada kelas SyntheticBeanBuildItem. Mari ikuti langkah-langkah untuk mencipta dan menggunakan kacang sintetik:

1. Buat Kelas Kacang Sintetik: Mulakan dengan menentukan kelas kacang sintetik. Kelas ini akan menjadi asas untuk kacang sintetik anda.

package com.iqnev;

public class MySyntheticBean {

  // Define the behavior and attributes of your synthetic bean
  public void printMessage() {
    System.out.println("Hello from synthetic bean!");
  }
}

1. Buat Sambungan Quarkus: Anda perlu membuat sambungan Quarkus untuk mendaftarkan kacang sintetik anda. Kelas sambungan ini akan menggunakan SyntheticBeanBuildItem untuk mengkonfigurasi kacang anda.

Pendekatan Penjanaan Bytecode

package com.iqnev;

import io.quarkus.arc.deployment.SyntheticBeanBuildItem;

public class MySyntheticBeanExtension {

  @BuildStep
  SyntheticBeanBuildItem syntheticBean() {
    return SyntheticBeanBuildItem
        .configure(MySyntheticBean.class)
        .scope(ApplicationScoped.class)
        .creator(mc -> {
          mc.returnValue(new MySyntheticBean());
        })
        .done();
  }
}

Kaedah .creator() pada SyntheticBeanBuildItem digunakan untuk menjana bytecode yang akan mencipta tika kacang sintetik pada masa jalan.

Hujah yang diserahkan kepada .creator() ialah Consumer yang membolehkan menjana kod bait Java dalam kaedah.

Dalam contoh ini:

1. mc is the MethodCreator instance
2. mc.returnValue(new MySyntheticBean()) generates the bytecode to create a new instance of MySyntheticBean and return it from the method.

So essentially, we are telling Quarkus to generate a method that looks something like:

MySyntheticBean createSyntheticBean(){
    return new MySyntheticBean();
    }

This generated method will then be called to instantiate the MySyntheticBean when it needs to be injected or used.

The reason bytecode generation is used is that synthetic beans do not correspond to real Java classes/methods, so we have to explicitly generate a method to instantiate them

The output of SyntheticBeanBuildItem is bytecode recorded at build time. This limits how instances are created at runtime. Common options are:

1. Generate bytecode directly via .creator()
2. Use a BeanCreator subclass
3. Produce instance via @Recorder method

Recorder Approach

The @Record and .runtimeValue() approaches are alternate ways of providing instances for synthetic beans in Quarkus.

This allows you to instantiate the synthetic bean via a recorder class method annotated with @Record(STATIC_INIT).

For example:

@Recorder
public class MyRecorder {

  @Record(STATIC_INIT)
  public MySyntheticBean createBean() {
    return new MySyntheticBean();
  }

}

  @BuildStep
  SyntheticBeanBuildItem syntheticBean(MyRecorder recorder) {
    return SyntheticBeanBuildItem
        .configure(MySyntheticBean.class)
        .runtimeValue(recorder.createBean());
  }

Here the .runtimeValue() references the recorder method to instantiate the bean. This allows passing a RuntimeValue directly to provide the synthetic bean instance.

For example:

@BuildStep 
SyntheticBeanBuildItem syntheticBean(){

    RuntimeValue<MySyntheticBean> bean= //...

    return SyntheticBeanBuildItem
    .configure(MySyntheticBean.class)
    .runtimeValue(bean);

    }

The RuntimeValue could come from a recorder, supplier, proxy etc.

So in summary:

• @Record is one approach to generate the RuntimeValue
• .runtimeValue() sets the RuntimeValue on the SyntheticBeanBuildItem

They both achieve the same goal of providing a runtime instance, just in slightly different ways.

When it comes to providing runtime instances for synthetic beans in Quarkus, I would consider using recorders (via @Record) to be a more advanced approach compared to directly generating bytecode
with .creator() or supplying simple RuntimeValues.

Here are some reasons why using recorders can be more advanced:

• More encapsulation - The logic to instantiate beans is contained in a separate recorder class rather than directly in build steps. This keeps build steps lean.
• Reuse - Recorder methods can be reused across multiple synthetic beans rather than rewriting creator logic.
• Runtime data - Recorder methods execute at runtime so they can leverage runtime resources, configs, services etc. to construct beans.
• Dependency injection - Recorder methods can inject other services.
• Life cycle control - Recorder methods annotated with @Record(STATIC_INIT) or @Record(RUNTIME_INIT) give more control over bean instantiation life cycle.
• Managed beans - Beans instantiated inside recorders can themselves be CDI managed beans.

So in summary, recorder methods provide more encapsulation, flexibility and access to runtime data and services for instantiating synthetic beans. They allow for more advanced bean production logic compared to direct bytecode generation.

However, direct bytecode generation with .creator() can still be useful for simple cases where recorders may be overkill. But as synthetic bean needs grow, recorders are a more powerful and
advanced approach.

It is possible to configure a synthetic bean in Quarkus to be initialized during the RUNTIME_INIT phase instead of the default STATIC_INIT phase.

Here is an example:

@BuildStep
@Record(RUNTIME_INIT)
SyntheticBeanBuildItem lazyBean(BeanRecorder recorder){

    return SyntheticBeanBuildItem
    .configure(MyLazyBean.class)
    .setRuntimeInit() // initialize during RUNTIME_INIT
    .runtimeValue(recorder.createLazyBean());

    }

The key points are:

• Use setRuntimeInit() on the SyntheticBeanBuildItem to mark it for RUNTIME_INIT
• The recorder method must be annotated with @Record(RUNTIME_INIT)
• The runtime init synthetic beans cannot be accessed during STATIC_INIT

So in summary, synthetic beans can be initialized lazily during RUNTIME_INIT for cases where eager STATIC_INIT instantiation is not needed. This allows optimizing startup time.

Use the Synthetic Bean: Now that your synthetic bean is registered, you can inject and use it in your application.

package com.iqnev;

import javax.inject.Inject;

public class MyBeanUser {

  @Inject
  MySyntheticBean mySyntheticBean;

  public void useSyntheticBean() {
    // Use the synthetic bean in your code
    mySyntheticBean.printMessage();
  }
}

Running Your Application: Build and run your Quarkus application as usual, and the synthetic bean will be available for injection and use.

Conclusion

Synthetic beans in Quarkus provide a powerful mechanism for integrating external libraries, dynamically registering beans, and customizing bean behavior in your CDI-based applications. These beans, whose attributes are defined by extensions rather than Java classes, offer flexibility and versatility in managing dependencies.

Seperti yang telah kami terokai dalam artikel ini, mencipta dan menggunakan kacang sintetik dalam Quarkus adalah proses yang mudah. Dengan memanfaatkan sambungan SyntheticBeanBuildItem dan Quarkus, anda boleh merapatkan jurang antara CDI tradisional dan keperluan pendaftaran kacang yang lebih khusus atau dinamik.

Dalam landskap rangka kerja Java yang sentiasa berkembang, Quarkus terus menonjol dengan menawarkan penyelesaian inovatif seperti kacang sintetik, menjadikannya pilihan yang menarik untuk pembangunan aplikasi moden, cekap dan fleksibel. Hayati kuasa kacang sintetik di Quarkus, dan bawa suntikan kebergantungan anda ke peringkat seterusnya!

Atas ialah kandungan terperinci Meneroka Kacang Sintetik di Quarkus. Mekanisme Sambungan Yang Kuat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!