Perbedaan antara <context: annotation-config> dan <context: component-scan>

Saya sedang belajar Spring 3 dan sepertinya saya tidak memahami fungsi di belakang <context:annotation-config>dan <context:component-scan>.

Dari apa yang saya baca mereka tampaknya untuk menangani berbagai penjelasan ( @Required, @Autowireddll vs @Component, @Repository, @Servicedll), tetapi juga dari apa yang saya baca mereka mendaftar sama prosesor posting kacang kelas.

Yang lebih membingungkan saya, ada annotation-config atribut di <context:component-scan>.

Adakah yang bisa menjelaskan tag ini? Apa yang mirip, apa yang berbeda, apakah yang satu digantikan oleh yang lain, mereka saling melengkapi, apakah saya memerlukan salah satunya, keduanya?

<context:annotation-config> digunakan untuk mengaktifkan anotasi dalam kacang yang sudah terdaftar dalam konteks aplikasi (tidak peduli apakah itu didefinisikan dengan XML atau dengan pemindaian paket).

<context:component-scan>juga dapat melakukan apa yang <context:annotation-config>dilakukan tetapi <context:component-scan>juga memindai paket untuk menemukan dan mendaftarkan kacang dalam konteks aplikasi.

Saya akan menggunakan beberapa contoh untuk menunjukkan perbedaan / kesamaan.

Mari kita mulai dengan pengaturan dasar tiga jenis kacang A, Bdan C, dengan Bdan Cdisuntikkan A.

package com.xxx;
public class B {
  public B() {
    System.out.println("creating bean B: " + this);
  }
}

package com.xxx;
public class C {
  public C() {
    System.out.println("creating bean C: " + this);
  }
}

package com.yyy;
import com.xxx.B;
import com.xxx.C;
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc; 
  }
}

Dengan konfigurasi XML berikut:

<bean id="bBean" class="com.xxx.B" />
<bean id="cBean" class="com.xxx.C" />
<bean id="aBean" class="com.yyy.A">
  <property name="bbb" ref="bBean" />
  <property name="ccc" ref="cBean" />
</bean>

Memuat konteks menghasilkan output berikut:

creating bean B: com.xxx.B@c2ff5
creating bean C: com.xxx.C@1e8a1f6
creating bean A: com.yyy.A@1e152c5
setting A.bbb with com.xxx.B@c2ff5
setting A.ccc with com.xxx.C@1e8a1f6

OK, ini adalah output yang diharapkan. Tapi ini adalah "gaya lama" Musim Semi. Sekarang kita memiliki anotasi jadi mari kita gunakan itu untuk menyederhanakan XML.

Pertama, mari kita autowire bbbdan cccproperti pada kacang Aseperti:

package com.yyy;
import org.springframework.beans.factory.annotation.Autowired;
import com.xxx.B;
import com.xxx.C;
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  @Autowired
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  @Autowired
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc;
  }
}

Ini memungkinkan saya untuk menghapus baris berikut dari XML:

<property name="bbb" ref="bBean" />
<property name="ccc" ref="cBean" />

XML saya sekarang disederhanakan menjadi ini:

<bean id="bBean" class="com.xxx.B" />
<bean id="cBean" class="com.xxx.C" />
<bean id="aBean" class="com.yyy.A" />

Ketika saya memuat konteks saya mendapatkan output berikut:

creating bean B: com.xxx.B@5e5a50
creating bean C: com.xxx.C@54a328
creating bean A: com.yyy.A@a3d4cf

OK, ini salah! Apa yang terjadi? Mengapa properti saya tidak disiarkan otomatis?

Ya, anotasi adalah fitur yang bagus tetapi dengan sendirinya mereka tidak melakukan apa pun. Mereka hanya membubuhi keterangan hal. Anda memerlukan alat pemrosesan untuk menemukan anotasi dan melakukan sesuatu dengannya.

<context:annotation-config>untuk menyelamatkan. Ini mengaktifkan tindakan untuk anotasi yang ditemukan pada kacang yang didefinisikan dalam konteks aplikasi yang sama di mana itu sendiri didefinisikan.

Jika saya mengubah XML saya ke ini:

<context:annotation-config />
<bean id="bBean" class="com.xxx.B" />
<bean id="cBean" class="com.xxx.C" />
<bean id="aBean" class="com.yyy.A" />

ketika saya memuat konteks aplikasi saya mendapatkan hasil yang tepat:

creating bean B: com.xxx.B@15663a2
creating bean C: com.xxx.C@cd5f8b
creating bean A: com.yyy.A@157aa53
setting A.bbb with com.xxx.B@15663a2
setting A.ccc with com.xxx.C@cd5f8b

OK, ini bagus, tapi saya sudah menghapus dua baris dari XML dan menambahkan satu. Itu bukan perbedaan yang sangat besar. Gagasan dengan anotasi adalah bahwa seharusnya menghapus XML.

Jadi mari kita hapus definisi XML dan ganti semuanya dengan anotasi:

package com.xxx;
import org.springframework.stereotype.Component;
@Component
public class B {
  public B() {
    System.out.println("creating bean B: " + this);
  }
}

package com.xxx;
import org.springframework.stereotype.Component;
@Component
public class C {
  public C() {
    System.out.println("creating bean C: " + this);
  }
}

package com.yyy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.xxx.B;
import com.xxx.C;
@Component
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  @Autowired
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  @Autowired
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc;
  }
}

Sementara di XML kami hanya menyimpan ini:

<context:annotation-config />

Kami memuat konteks dan hasilnya adalah ... Tidak ada. Tidak ada kacang yang dibuat, tidak ada kacang yang diotomatiskan. Tidak ada!

Itu karena, seperti yang saya katakan di paragraf pertama, <context:annotation-config />hanya bekerja pada kacang yang terdaftar dalam konteks aplikasi. Karena saya menghapus konfigurasi XML untuk tiga kacang tidak ada kacang dibuat dan <context:annotation-config />tidak memiliki "target" untuk bekerja.

Tapi itu tidak akan menjadi masalah <context:component-scan>yang dapat memindai paket untuk "target" untuk dikerjakan. Mari kita ubah konten konfigurasi XML menjadi entri berikut:

<context:component-scan base-package="com.xxx" />

Ketika saya memuat konteks saya mendapatkan output berikut:

creating bean B: com.xxx.B@1be0f0a
creating bean C: com.xxx.C@80d1ff

Hmmmm ... ada yang hilang. Mengapa?

Jika Anda melihat tertutup di kelas, kelas Amemiliki paket com.yyytetapi saya telah menentukan dalam <context:component-scan>paket menggunakan com.xxxsehingga ini benar-benar merindukan Akelas saya dan hanya mengambil Bdan Cyang ada di com.xxxpaket.

Untuk memperbaikinya, saya menambahkan paket lain ini juga:

<context:component-scan base-package="com.xxx,com.yyy" />

dan sekarang kami mendapatkan hasil yang diharapkan:

creating bean B: com.xxx.B@cd5f8b
creating bean C: com.xxx.C@15ac3c9
creating bean A: com.yyy.A@ec4a87
setting A.bbb with com.xxx.B@cd5f8b
setting A.ccc with com.xxx.C@15ac3c9

Dan itu dia! Sekarang Anda tidak memiliki definisi XML lagi, Anda memiliki anotasi.

Sebagai contoh terakhir, menjaga kelas beranotasi A, Bdan Cdan menambahkan yang berikut ke XML, apa yang akan kita dapatkan setelah memuat konteks?

<context:component-scan base-package="com.xxx" />
<bean id="aBean" class="com.yyy.A" />

Kami masih mendapatkan hasil yang benar:

creating bean B: com.xxx.B@157aa53
creating bean C: com.xxx.C@ec4a87
creating bean A: com.yyy.A@1d64c37
setting A.bbb with com.xxx.B@157aa53
setting A.ccc with com.xxx.C@ec4a87

Bahkan jika kacang untuk kelas Atidak diperoleh dengan pemindaian, alat pemrosesan masih diterapkan oleh <context:component-scan>semua kacang yang terdaftar dalam konteks aplikasi, bahkan Ayang kacang itu secara manual terdaftar dalam XML.

Tetapi bagaimana jika kita memiliki XML berikut, apakah kita akan mendapatkan duplikat kacang karena kita telah menentukan keduanya <context:annotation-config />dan <context:component-scan>?

<context:annotation-config />
<context:component-scan base-package="com.xxx" />
<bean id="aBean" class="com.yyy.A" />

Tidak, tidak ada duplikasi, Kami kembali mendapatkan hasil yang diharapkan:

creating bean B: com.xxx.B@157aa53
creating bean C: com.xxx.C@ec4a87
creating bean A: com.yyy.A@1d64c37
setting A.bbb with com.xxx.B@157aa53
setting A.ccc with com.xxx.C@ec4a87

Itu karena kedua tag mendaftarkan alat pemrosesan yang sama ( <context:annotation-config />dapat dihilangkan jika <context:component-scan>ditentukan) tetapi Spring hanya menjalankannya sekali.

Bahkan jika Anda mendaftarkan alat pemrosesan sendiri beberapa kali, Spring masih akan memastikan mereka melakukan sihir mereka hanya sekali; XML ini:

<context:annotation-config />
<context:component-scan base-package="com.xxx" />
<bean id="aBean" class="com.yyy.A" />
<bean id="bla" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
<bean id="bla1" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
<bean id="bla2" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
<bean id="bla3" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

akan tetap menghasilkan hasil sebagai berikut:

creating bean B: com.xxx.B@157aa53
creating bean C: com.xxx.C@ec4a87
creating bean A: com.yyy.A@25d2b2
setting A.bbb with com.xxx.B@157aa53
setting A.ccc with com.xxx.C@ec4a87

OK, itu tentang mengetuknya.

Saya harap informasi ini bersama dengan tanggapan dari @Tomasz Nurkiewicz dan @Sean Patrick Floyd adalah semua yang Anda butuhkan untuk memahami bagaimana <context:annotation-config>dan <context:component-scan>bekerja.

Saya menemukan ringkasan bagus ini yang mana anotasi diambil oleh deklarasi mana. Dengan mempelajarinya Anda akan menemukan bahwa <context:component-scan/>superset dari anotasi diakui oleh<context:annotation-config/> , yaitu:

• @Component, @Service, @Repository,@Controller ,@Endpoint
• @Configuration, @Bean, @Lazy, @Scope, @Order, @Primary, @Profile, @DependsOn,@Import ,@ImportResource

Seperti yang Anda lihat <context:component-scan/>secara logis diperluas <context:annotation-config/> dengan pemindaian komponen CLASSPATH dan fitur Java @Configuration.

Spring memungkinkan Anda melakukan dua hal:

1. Autowiring of beans
2. Autodiscovery of beans

1. Autowiring
Biasanya dalam applicationContext.xml Anda mendefinisikan kacang dan kacang lainnya ditransfer menggunakan metode konstruktor atau penyetel. Anda bisa mengirim kacang menggunakan XML atau anotasi. Jika Anda menggunakan anotasi, Anda harus mengaktifkan anotasi dan Anda harus menambahkan <context:annotation-config />di applicationContext.xml . Ini akan menyederhanakan struktur tag dari applicationContext.xml , karena Anda tidak harus secara manual memasang kacang (konstruktor atau setter). Anda dapat menggunakan @Autowireanotasi dan kacang akan ditransfer berdasarkan jenis.

Langkah maju untuk keluar dari konfigurasi XML manual adalah

2. Autodiscovery
Autodiscovery menyederhanakan XML satu langkah lebih jauh, dalam arti Anda bahkan tidak perlu menambahkan <bean>tag di applicationContext.xml . Anda cukup menandai kacang spesifik dengan salah satu anotasi berikut dan Pegas akan secara otomatis memasukkan kacang yang ditandai dan ketergantungannya ke wadah Pegas. Anotasi adalah sebagai berikut: @Controller , @Service , @Component , @Repository . Dengan menggunakan <context:component-scan>dan mengarahkan paket dasar, Spring akan menemukan secara otomatis dan mengirimkan komponen ke wadah Spring.

Sebagai sebuah kesimpulan:

• <context:annotation-config />digunakan agar dapat menggunakan anotasi @Autowired
• <context:component-scan /> digunakan untuk menentukan pencarian kacang spesifik dan upaya autowiring.

<context:annotation-config> mengaktifkan banyak anotasi berbeda dalam buncis, baik didefinisikan dalam XML atau melalui pemindaian komponen.

<context:component-scan> adalah untuk mendefinisikan kacang tanpa menggunakan XML

Untuk informasi lebih lanjut, baca:

• 3.9. Konfigurasi wadah berbasis anotasi
• 3.10. Pemindaian classpath dan komponen yang dikelola

Perbedaan antara keduanya sangat sederhana !.

<context:annotation-config /> 

Memungkinkan Anda untuk menggunakan anotasi yang dibatasi hanya untuk mengabel properti dan konstruktor kacang !.

Dimana sebagai

<context:component-scan base-package="org.package"/> 

Memungkinkan segala sesuatu yang <context:annotation-config />dapat Anda lakukan, dengan penambahan menggunakan stereotip misalnya .. @Component, @Service, @Repository. Jadi, Anda dapat mentransfer seluruh kacang dan tidak hanya terbatas pada konstruktor atau properti !.

<context:annotation-config>: Memindai dan mengaktifkan anotasi untuk kacang yang sudah terdaftar di konfigurasi musim semi xml.

<context:component-scan>: Registrasi kacang +<context:annotation-config>

@Autowired dan @Required adalah target level properti sehingga bean harus mendaftar di IOC musim semi sebelum menggunakan anotasi ini. Untuk mengaktifkan anotasi ini, Anda harus mendaftarkan kacang masing-masing atau memasukkannya <context:annotation-config />. yaitu hanya <context:annotation-config />bekerja dengan kacang terdaftar.

@Required mengaktifkan RequiredAnnotationBeanPostProcessor alat pemrosesan
@Autowired memungkinkan AutowiredAnnotationBeanPostProcessoralat pemrosesan

Catatan: Anotasi itu sendiri tidak ada hubungannya, kita memerlukan Alat Pemrosesan , yang merupakan kelas di bawahnya, yang bertanggung jawab untuk proses inti.

@Repository, @Service dan @Controller adalah @Component , dan mereka menargetkan level kelas .

<context:component-scan>itu memindai paket dan menemukan dan mendaftarkan kacang, dan itu termasuk pekerjaan yang dilakukan oleh <context:annotation-config />.

Memigrasi XML ke Anotasi

The <context:annotation-config>tag memberitahu Spring ke memindai basis kode untuk secara otomatis menyelesaikan persyaratan ketergantungan dari kelas yang mengandung penjelasan @ Autowired.

Spring 2.5 juga menambahkan dukungan untuk anotasi JSR-250 seperti @Resource, @PostConstruct, dan @ PreDestroy. Penggunaan anotasi ini juga mengharuskan BeanPostProcessors tertentu didaftarkan dalam wadah Spring. Seperti biasa, ini dapat didaftarkan sebagai definisi kacang individu, tetapi mereka juga dapat didaftarkan secara implisit dengan memasukkan<context:annotation-config> tag dalam konfigurasi pegas.

Diambil dari dokumentasi Spring dari Annotation Based Configuration

Spring menyediakan kemampuan mendeteksi kelas 'stereotip' secara otomatis dan mendaftarkan BeanDefinitions yang sesuai dengan ApplicationContext.

Menurut javadoc dari org.springframework.stereotype :

Stereotip adalah Anotasi yang menunjukkan peran tipe atau metode dalam arsitektur keseluruhan (pada level konseptual, bukan implementasi,). Contoh: @Controller @Service @Repository, dll. Ini dimaksudkan untuk digunakan oleh alat dan aspek (membuat target ideal untuk pointcuts).

Untuk mendeteksi secara otomatis kelas 'stereotip' semacam itu, <context:component-scan>tag diperlukan.

The <context:component-scan>tag juga mengatakan musim semi untuk memindai kode untuk kacang suntik di bawah paket (dan semua subpackages nya) ditentukan.

<context:annotation-config>

Hanya menyelesaikan @Autowireddan @Qualiferanotasi, itu saja, tentang Injeksi Ketergantungan , Ada anotasi lain yang melakukan pekerjaan yang sama, saya pikir caranya@Inject , tetapi semua akan menyelesaikan DI melalui anotasi.

Sadarilah, bahkan ketika Anda telah mendeklarasikan <context:annotation-config>elemen, Anda harus mendeklarasikan kelas Anda bagaimana sebuah Bean, ingat kami memiliki tiga opsi yang tersedia

• XML: <bean>
• @Annotations: @Component, @Service, @Repository, @Controller
• JavaConfig: @Configuration, @Bean

Sekarang dengan

<context:component-scan>

Ia melakukan dua hal:

• Itu memindai semua kelas yang dijelaskan dengan @Component, @Service, @Repository, @Controller dan @Configuration dan membuat Bean
• Itu melakukan pekerjaan yang sama bagaimana <context:annotation-config>.

Karena itu jika Anda mendeklarasikan <context:component-scan>, tidak perlu lagi mendeklarasikan <context:annotation-config>juga.

Itu saja

Skenario yang umum misalnya menyatakan hanya kacang melalui XML dan menyelesaikan DI melalui penjelasan, misalnya

<bean id="serviceBeanA" class="com.something.CarServiceImpl" />
<bean id="serviceBeanB" class="com.something.PersonServiceImpl" />
<bean id="repositoryBeanA" class="com.something.CarRepository" />
<bean id="repositoryBeanB" class="com.something.PersonRepository" />

Kami hanya menyatakan kacang, tidak ada tentang <constructor-arg>dan <property>, DI dikonfigurasi di kelas mereka sendiri melalui @ Autowired. Ini berarti Layanan menggunakan @ Autowired untuk komponen Repositori mereka dan Repositori menggunakan @ Autowired untuk JdbcTemplate, DataSource dll. Komponen

<context:component-scan /> implicitly enables <context:annotation-config/>

coba dengan <context:component-scan base-package="..." annotation-config="false"/>, di konfigurasi @Service, @Repository, @Component berfungsi dengan baik, tetapi @ Autowired, @ Resource dan @Inject tidak berfungsi.

Ini berarti AutowiredAnnotationBeanPostProcessor tidak akan diaktifkan dan Spring container tidak akan memproses anotasi Autowiring.

<context:annotation-config/> <!-- is used to activate the annotation for beans -->
<context:component-scan base-package="x.y.MyClass" /> <!-- is for the Spring IOC container to look for the beans in the base package. -->

Poin penting lainnya yang perlu diperhatikan adalah bahwa context:component-scanpanggilan secara implisit context:annotation-configuntuk mengaktifkan anotasi pada kacang. Nah, jika Anda tidak ingin context:component-scansecara aktif mengaktifkan anotasi untuk Anda, Anda dapat mengatur elemen anotasi-konfigurasi dari context:component-scanto false.

Untuk meringkas:

<context:annotation-config/> <!-- activates the annotations --> 
<context:component-scan base-package="x.y.MyClass" /> <!-- activates the annotations + register the beans by looking inside the base-package -->

<context:component-scan base-package="package name" />:

Ini digunakan untuk memberi tahu kontainer bahwa ada kelas-kelas kacang dalam paket saya, memindai kelas-kelas kacang itu. Untuk memindai kelas kacang dengan wadah di atas kacang, kita harus menulis salah satu anotasi jenis stereo seperti berikut.

@Component, @Service, @Repository,@Controller

<context:annotation-config />:

Jika kita tidak ingin menulis tag kacang secara eksplisit dalam XML maka bagaimana wadah tahu jika ada kabel otomatis di kacang. Ini dimungkinkan dengan menggunakan @Autowiredanotasi. kita harus memberi tahu kontainer bahwa ada kabel otomatis di dalam kacangku context:annotation-config.

Sebuah <context:component-scan/>tag kustom register set yang sama definisi kacang seperti yang dilakukan oleh, selain dari tanggung jawab utamanya pemindaian paket java dan mendaftarkan definisi kacang dari classpath.

Jika karena alasan tertentu registrasi definisi kacang default ini harus dihindari, cara untuk melakukannya adalah menentukan atribut "annotation-config" tambahan dalam pemindaian komponen, dengan cara ini:

<context:component-scan basePackages="" annotation-config="false"/>

Referensi: http://www.java-allandsundry.com/2012/12/contextcomponent-scan-contextannotation.html

<context:annotation-config>:

Ini memberitahu Spring bahwa saya akan menggunakan kacang beranotasi sebagai kacang pegas dan yang akan ditransfer melalui @Autowiredpenjelasan, daripada mendeklarasikan dalam file xml konfigurasi musim semi.

<context:component-scan base-package="com.test..."> :

Ini memberitahu wadah Spring, di mana untuk mulai mencari kacang beranotasi. Di sini pegas akan mencari semua sub paket dari paket dasar.

Anda dapat menemukan informasi lebih lanjut dalam file skema konteks musim semi. berikut ini dalam konteks-musim semi-4.3.xsd

<conxtext:annotation-config />

Activates various annotations to be detected in bean classes: Spring's @Required and
@Autowired, as well as JSR 250's @PostConstruct, @PreDestroy and @Resource (if available),
JAX-WS's @WebServiceRef (if available), EJB 3's @EJB (if available), and JPA's
@PersistenceContext and @PersistenceUnit (if available). Alternatively, you may
choose to activate the individual BeanPostProcessors for those annotations.

Note: This tag does not activate processing of Spring's @Transactional or EJB 3's
@TransactionAttribute annotation. Consider the use of the <tx:annotation-driven>
tag for that purpose.

<context:component-scan>

Scans the classpath for annotated components that will be auto-registered as
Spring beans. By default, the Spring-provided @Component, @Repository, @Service, @Controller, @RestController, @ControllerAdvice, and @Configuration stereotypes    will be detected.

Note: This tag implies the effects of the 'annotation-config' tag, activating @Required,
@Autowired, @PostConstruct, @PreDestroy, @Resource, @PersistenceContext and @PersistenceUnit
annotations in the component classes, which is usually desired for autodetected components
(without external configuration). Turn off the 'annotation-config' attribute to deactivate
this default behavior, for example in order to use custom BeanPostProcessor definitions
for handling those annotations.

Note: You may use placeholders in package paths, but only resolved against system
properties (analogous to resource paths). A component scan results in new bean definitions
being registered; Spring's PropertySourcesPlaceholderConfigurer will apply to those bean
definitions just like to regular bean definitions, but it won't apply to the component
scan settings themselves.

Sebagai pelengkap, Anda dapat menggunakan @ComponentScanuntuk digunakan <context:component-scan>dalam cara anotasi.

Ini juga dijelaskan di spring.io

Mengkonfigurasi arahan pemindaian komponen untuk digunakan dengan kelas-kelas @Configuration. Memberikan dukungan paralel dengan elemen Spring XML.

Satu hal yang perlu diperhatikan, jika Anda menggunakan Spring Boot, @Configuration dan @ComponentScan dapat diimplikasikan dengan menggunakan anotasi @SpringBootApplication.