Pertanyaan Berapa banyak cara untuk mengkonfigurasi kerangka Spring? Apa perbedaannya secara teknis? (Bukan pro atau kontra ..)


saya sedang belajar ini buku (yang saya akan sangat menyarankan), dan saya bingung tentang bagaimana penulis menjelaskan cara kerangka Spring dapat dikonfigurasi.

Anda dapat melihat beberapa contoh kode yang digunakan dalam buku sini. (Mereka tersedia untuk siapa saja ..) Kode yang saya maksudkan adalah kode dari bab 2, jika Anda ingin melihatnya.

Bagaimanapun, buku itu menyatakan bahwa ada 3 cara mengkonfigurasi Spring Container.


Konfigurasi berbasis XML

Ini akan membutuhkan file xml yang menyerupai sesuatu seperti ini:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" ...>

    <bean id="accountService" class="com.wiley.beginningspring.ch2.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <bean id="accountDao" class="com.wiley.beginningspring.ch2.AccountDaoInMemoryImpl">
    </bean>

</beans>

Dan kemudian untuk bootstrap Spring, kode yang akan digunakan adalah:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/com/wiley/beginningspring/ch2/ch2-beans.xml");

Saya tidak memiliki kebingungan pada saat ini.


Konfigurasi Berbasis Java

Dalam metode Konfigurasi ini, akan ada kelas untuk konfigurasi sebagai berikut:

@Configuration
public class Ch2BeanConfiguration {

    @Bean
    public AccountService accountService() {
        AccountServiceImpl bean = new AccountServiceImpl();
        bean.setAccountDao(accountDao());
        return bean;
    }

    @Bean
    public AccountDao accountDao() {
        AccountDaoInMemoryImpl bean = new AccountDaoInMemoryImpl();
        return bean;
    }
}

dan kode yang bertanggung jawab untuk bootstrapping Spring terlihat seperti:

ApplicationContext applicationContext
            = new AnnotationConfigApplicationContext(Ch2BeanConfiguration.class);

Jadi sampai disini, semuanya jelas bagi saya. (Semacam ..) Saya juga ingin mencatat bahwa, di sini kita benar-benar memiliki Anotasi yang disebut @Configuration ...


Konfigurasi Berbasis Anotasi

Metode konfigurasi terakhir yang tersedia, yang dijelaskan dalam buku adalah Konfigurasi Berbasis Anotasi.

Ada file xml seperti yang kami miliki di Konfigurasi Berbasis XML, namun yang jauh lebih kecil:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" ...>
    <context:component-scan base-package="com.wiley.beginningspring.ch2"/>
</beans>

Semua biji memiliki Anotasi seperti:

@Component, @Service

dll ..

Dan semua dependensi memiliki anotasi:

@Autowired

agar kacang bisa disuntikkan.

Cara Spring framework bootstrapped dalam metode konfigurasi ini adalah sebagai berikut:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/ch2-beans.xml");

Inilah pertanyaan saya:

Mengapa (disebut) Konfigurasi Berbasis Anotasi sebenarnya menggunakan ClassPathXmlApplicationContext tapi tidak AnnotationConfigApplicationContext atas? Yang terakhir tampaknya lebih tepat untuk digunakan dalam Konfigurasi yang memiliki kata "Anotasi Berbasis" di dalamnya, bukan?

Itu Konfigurasi Berbasis Java yang dijelaskan di buku sepertinya seperti apa yang harus dipanggil Konfigurasi Berbasis Anotasi.?

Dan cara Konfigurasi Berbasis Anotasi yang dijelaskan dalam buku ini benar-benar bagi saya sesuatu seperti: Konfigurasi Berbasis XML dengan Kacang Autowired. Ia bahkan tidak memiliki penjelasan @Configuration, yang "Java Based Configuration" telah ..

Berapa banyak cara untuk mengkonfigurasi kerangka Spring?


27
2018-03-04 22:13


asal


Jawaban:


Untuk menghindari kebingungan, kita harus mengerti, itu definisi konfigurasi dan definisi kacang dua hal yang berbeda. Ada tiga cara untuk mendefinisikan konfigurasi, tersedia di Spring 4 secara default:

  • berbasis xml konfigurasi, ketika Anda menjelaskan konfigurasi dalam file xml;
  • berbasis java konfigurasi, ketika konfigurasi adalah kelas Java, ditandai dengan anotasi spesifik;
  • groovy-based konfigurasi, ketika konfigurasi file dengan kode Groovy;

Dan ada dua cara untuk menambahkan definisi kacang ke dalam aplikasi:

  • konfigurasi di dalam definisi kacang, ketika Anda menambahkan kacang secara manual dengan deklarasi tepat dalam konfigurasi.

    Dalam definisi kasus ini akan didasarkan pada jenis konfigurasi. Untuk xml-config itu akan menjadi <bean/> tag, untuk konfigurasi berbasis java dengan @Bean anotasi dan beans {...} konstruksi untuk Groovy.

  • berdasarkan anotasi definisi kacang, ketika Anda menandai kelas kacang dengan anotasi khusus (seperti @Component, @Service, @Controller dll). Jenis konfigurasi ini digunakan scanning classpath.

    Dalam hal ini Anda harus menentukan arahan untuk memindai classpath. Untuk xml-config itu akan menjadi <context:component-scan base-package="..."/>, untuk java-config - @ComponentScan anotasi, untuk Groovy ctx.'component-scan'(...) doa.

Seperti yang Anda lihat, Anda dapat menggunakan konfigurasi dan definisi kacang dalam kombinasi yang berbeda.

Perhatikan, bahwa jika Anda menggunakan konfigurasi berbasis xml, Anda dapat memilih pendekatan untuk mendorong ketergantungan injeksi: secara manual di xml, atau dengan menggunakan anotasi (@Autowire, @Required dll). Dalam kasus terakhir Anda harus mendefinisikan <context:annotation-config/>. Tapi jangan bingung definisi kacang dan kontrol injeksi ketergantungan.

Sekarang berdasarkan sudut pandang ini, cobalah menjawab pertanyaan Anda:

Mengapa (yang disebut) Anotasi Berbasis Konfigurasi benar-benar menggunakan   ClassPathXmlApplicationContext tetapi tidak   AnnotationConfigApplicationContext di atas?

Penulis buku mencampur konsep. Sebenarnya, ini adalah konfigurasi berbasis xml dengan definisi bean berbasis anotasi.

Konfigurasi Berbasis Java yang dijelaskan di buku sepertinya seperti apa   harus disebut Konfigurasi Berbasis Anotasi.?

Anda benar - konfigurasi berbasis Java benar-benar aktif menggunakan anotasi, dan bisa disebut Anotasi berbasis. Tetapi anotasi adalah bagian dari Java. Selain itu ini adalah istilah tradisional, ditentukan dalam dokumentasi.

Berapa banyak cara untuk mengkonfigurasi kerangka Spring?

Jadi, secara default, kami memiliki tiga cara untuk mendeskripsikan konfigurasi, dan dua cara untuk mendefinisikan kacang. Itu mengubah enam cara untuk mengonfigurasi framework Spring (secara default). Tetapi, tentu saja, semua cara ini dapat digunakan dalam kombinasi satu sama lain.


28
2018-03-13 04:54



Cara termudah untuk memahami ini adalah dengan melihat ke dalam sejarah panjang dari kerangka bagaimana ini dikembangkan.

  • Konfigurasi berbasis XML - ini ada di sana dari awal - versi 1 - lihat javadoc untuk ClassPathXmlApplicationContext. Ini sekitar bulan Maret 2004, waktu J2EE 1.4, yang memiliki konfigurasi xml BESAR dan Spring adalah penyederhanaan besar (XML juga, tetapi lebih sederhana). Ini menggunakan XML untuk semuanya, termasuk menentukan autowiring, atau apa dependensi pergi ke mana secara langsung (Anda ref = "accoundDao" contoh).

  • Konfigurasi berdasarkan anotasi - di Spring 2.5 - ini datang sebagai reaksi terhadap Java EE 5, anotasi baru seperti @Austowired diperkenalkan, masih ada beberapa konfigurasi konteks dalam file XML - biasanya Anda akan menentukan paket mana yang harus dipindai dan sisanya dilakukan secara otomatis berdasarkan anotasi - maka namanya.

  • Konfigurasi berbasis Java datang dengan Spring 3, diperbaiki dalam versi yang lebih baru. Ini saatnya AnnotationConfigApplicationContext dan anotasi konfigurasi diperkenalkan - Anda berpotensi menjatuhkan keseluruhan XML -> konfigurasi berbasis java. Meskipun ini menjadi praktis hanya kemudian dengan versi 4+, karena sejumlah besar tag pembantu xml untuk aop, jdbc dll.

Di samping 3 ini (2 sebenarnya sebagai 1 dan 2 menggunakan kelas ApplicationContext yang sama), adalah cara lain untuk membuat konteks:


7
2018-03-07 11:12



Tidak persis. Hanya ada dua cara untuk mengkonfigurasi kerangka Spring. Dua alat konfigurasi dasar untuk kerangka Spring adalah:

  • File XML (di luar file java)
  • Anotasi berbasis Java (5 +) (di dalam file java)

Keduanya dapat digunakan untuk:

  • mengkonfigurasi konteks aplikasi (berarti menambahkan kacang) - konstruktor konteks aplikasi konkret menerima file xml, paket untuk dipindai, atau kelas yang bernama langsung untuk memuat
  • bootstrap konteks aplikasi dalam kasus aplikasi web - menggunakan web.xml vs menggunakan implementasi kelas WebApplicationInitializer

Dan last but not least:

  • Anda dapat memindai anotasi dari file konfigurasi xml dengan menggunakan <context:component-scan/>
  • Anda dapat memuat file xml dari kacang konfigurasi beranotasi dengan menggunakan @import

Cara kedua disebut Konfigurasi Berbasis Java dalam buku Anda, adalah anotasi tertentu @Configuration. Kelas yang dianotasikan dengan biasanya akan menjadi kacang dalam konteks aplikasi, tetapi juga dapat menyatakan kacang lainnya dengan @Bean penjelasan pada satu metode. Itulah alasan mengapa kelas-kelas itu umumnya dimuat langsung, bukan kacang yang dipindai.

Cara ketiga disebut Konfigurasi Berbasis Anotasi, hanyalah sebuah pencampuran dari dua mode, di mana Anda menggunakan konfigurasi xml pada tingkat yang lebih tinggi dan hanya memindai paket untuk kacang tambahan.


TL / DR: hanya ada 2 cara untuk mengonfigurasi konteks aplikasi dalam framework musim semi:

  • file konfigurasi xml
  • anotasi java

dan mereka bisa dicampur

tetapi setiap kacang tunggal dapat dideklarasikan dalam 3 cara:

  • dari file xml
  • dengan @Bean anotasi di dalam @Configuration kacang anotasi
  • langsung dengan @Component (atau salah satu dari anotasi khusus @Controller, @Service, dll.)

Sekarang untuk pertanyaan Anda yang tepat:

Mengapa Konfigurasi Berbasis Anotasi (yang disebut) sebenarnya menggunakan ClassPathXmlApplicationContext tetapi tidak AnnotationConfigApplicationContext di atas?

Karena ApplicationContext pertama kali diinisialisasi bentuk file konfigurasi xml. Pemindaian paket terjadi kemudian dengan bantuan <context:scan ...> tag. Anda menggunakan AnnotationConfigApplicationContext jika Anda langsung menginisialisasi dari kelas konfigurasi atau melalui pemindaian paket.

Konfigurasi Berbasis Java yang dijelaskan di buku sepertinya seperti apa yang disebut Konfigurasi Anotasi Berbasis.

Mereka menyebutnya Berbasis Javakarena tidak memerlukan xml jadi konfigurasi hanya menggunakan Java


3
2018-03-07 08:41



Pada awalnya, saya ingin berterima kasih Ken Bekov untuk jawabannya yang lebih banyak akal. Saya telah mencoba untuk mengimprovisasikan jawabannya sehingga siapa pun dapat belajar lebih banyak tentang bidang ini.

Definisi Konfigurasi:

Spring 4 berisi 3 cara untuk mendefinisikan konfigurasinya. Mereka

enter image description here

Keuntungan dari anotasi:

  1. Semua information is in a single file (tidak perlu membuka dua file untuk mengonfigurasi perilaku yang diberikan)

  2. Ketika kelas berubah, no need to modify the xml file

  3. Annoations sering kali dikatakan lebih intuitif dan kuat ketika melakukan re-factoring kode aplikasi. Juga mereka mendapat manfaat dari panduan IDE yang lebih baik seperti penyediaan kedok. Tetapi mereka mencampur kode aplikasi dengan kekhawatiran DI. Aplikasi bergantung pada kerangka kerja. Pemisahan yang jelas hampir tidak mungkin. Annotations are also limited when describing different injection behaviour at the same place (constructor, field) dependent on other circumstances (e.g. robot legs problem). Selain itu mereka tidak mengizinkan untuk memperlakukan kelas eksternal (kode perpustakaan) seperti sumber Anda sendiri. Oleh karena itu mereka dianggap berjalan lebih cepat daripada XML.

Keuntungan file xml:

  1. Perpisahan yang jelas antara POJO dan perilakunya

  2. Ketika Anda tidak tahu POJO mana yang bertanggung jawab atas perilaku, lebih mudah untuk menemukan POJO itu (mencari di subkumpulan file daripada semua kode sumber)

  3. XML memiliki satu-satunya manfaat dari gaya deklaratif yang didefinisikan dengan jelas dipisahkan dari kode aplikasi itu sendiri. Itu tetap independen dari kekhawatiran DI. Kelemahannya adalah verbosity, poor re-factoring  robustness dan a general runtime failure tingkah laku. Hanya ada dukungan alat umum (XML) dengan sedikit manfaat dibandingkan dengan dukungan IDE untuk mis. Jawa. Selain itu XML ini dilengkapi dengan overhead kinerja sehingga biasanya slower than code solutions.

Tautan Berbasis XML dan Anotasi:

  1. http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-annotation-config
  2. Anotasi vs XML, kelebihan dan kekurangan
  3. Injeksi Ketergantungan Java: XML atau anotasi
  4. Konfigurasi DI vs xml berdasarkan annotation musim semi?
  5. Konfigurasi Xml versus konfigurasi berbasis Anotasi

Link Berdasarkan Groovy:

  1. https://objectpartners.com/2016/01/12/using-groovy-based-spring-configuration/
  2. http://blog.andresteingress.com/2014/02/14/grails-java-based-spring-config/

Definisi Kacang:

Ada 2 cara untuk Definisi kacang: enter image description here

Memindai jalur kelas:

Untuk xml-config boleh jadi <context:component-scan base-package="..."/>, untuk java-config - @ComponentScan anotasi, untuk Groovy ctx.'component-scan'(...) doa.

Injeksi Ketergantungan:

Dalam konfigurasi berbasis xml, dependency injection dapat dilakukan secara manual di xml, atau dengan menggunakan annotations (@Autowire, @Required dll). Pada kasus itu perlu didefinisikan <context:annotation-config/> 

Pertanyaan & Jawaban:

Q1: Mengapa (yang disebut) Annotation Based Configuration sebenarnya menggunakan ClassPathXmlApplicationContext tetapi tidak   AnnotationConfigApplicationContext di atas?

Jawab: Ini adalah konfigurasi berbasis xml dengan definisi bean berbasis anotasi.

Konteks Aplikasi:

  1. http://docs.spring.io/spring/docs/4.2.0.RELEASE/javadoc-api/org/springframework/context/ApplicationContext.html

AnnotationConfigApplicationContext:

1AnnotationConfigApplicationContext dan konteks induk

ClassPathXmlApplicationContext:

  1. http://www.tutorialspoint.com/spring/spring_applicationcontext_container.htm
  2. http://www.mkyong.com/spring3/spring-3-hello-world-example/

Q2: Konfigurasi Berbasis Java yang dijelaskan di buku sepertinya seperti apa yang disebut Konfigurasi Anotasi Berbasis.

Jawab: Anda benar pada kasus itu. Konfigurasi berbasis Java menggunakan anotasi, dan disebut konfigurasi berbasis anotasi. Tetapi anotasi adalah satu bagian dari Jawa, tidak ada yang lain.

Tetapi secara terperinci kita perlu memahami bagaimana hirarki ini berasal dari xml ke anotasi berdasarkan dan akhirnya groovy berdasarkan? 

Alternatif untuk pengaturan XML disediakan oleh konfigurasi berbasis anotasi yang bergantung pada metadata bytecode untuk komponen pengkabelan bukan deklarasi siku-siku. Alih-alih menggunakan XML untuk mendeskripsikan wiring kacang, pengembang memindahkan konfigurasi ke dalam kelas komponen itu sendiri dengan menggunakan anotasi pada kelas, metode, atau deklarasi lapangan yang relevan. Seperti yang disebutkan di bagian yang disebut "Contoh: The RequiredAnnotationBeanPostProcessor", menggunakan BeanPostProcessor bersama dengan anotasi adalah cara umum untuk memperpanjang wadah Spring IoC. Sebagai contoh, Spring 2.0 memperkenalkan kemungkinan menegakkan properti yang diperlukan dengan @Required anotasi.

Spring 2.5 memungkinkan untuk mengikuti pendekatan umum yang sama untuk mendorong injeksi ketergantungan Musim Semi. Pada dasarnya, itu@Autowired anotasi memberikan kemampuan yang sama seperti yang dijelaskan di Bagian 6.4.5, "kolaborator Autowiring" tetapi dengan kontrol yang lebih halus dan penerapan yang lebih luas.

Spring 2.5 juga menambahkan dukungan untuk penjelasan JSR-250 seperti @PostConstruct, dan @PreDestroy.

Spring 3.0 menambahkan dukungan untuk penjelasan JSR-330 (Dependency Injection untuk Java) yang terdapat dalam paket javax.inject seperti @Inject dan @Named. Detail tentang anotasi tersebut dapat ditemukan di bagian yang relevan.

Q3: Berapa banyak cara untuk mengkonfigurasi framework Spring?

Jawab: 

Theoretically, 3 cara untuk mendeskripsikan konfigurasi, dan 2 cara untuk mendefinisikan kacang. Ternyata 3 * 2 = 6 cara untuk mengkonfigurasi kerangka Spring (secara default). Semua cara ini dapat digunakan dalam kombinasi satu sama lain.

But Actually, dalam satu kata, kita dapat mengkonfigurasi framework musim semi dengan menggunakan XML atau annotations.


2
2018-03-13 19:54



Saya belum melihat buku itu, tetapi asumsi Anda sebenarnya benar.

Untuk memulai aplikasi Spring dan memiliki semua kacang yang dipakai oleh framework menggunakan XML dikonfigurasi kacang, Anda harus menggunakan ClassPathXmlApplicationContext.

Ada 2 cara untuk mengkonfigurasi kacang di Spring:

1) kacang XML 2) Pendekatan anotasi

Pada dasarnya, kacang XML digunakan dalam Spring 2.5-3 dan pendekatan Anotasi digunakan lebih banyak di Musim Semi 4.

@Bean // is a way to create a bean. It is the equalivant of the beans tag in XML.

@Configuration // is a way to tell the Spring container that this class is a list of configuration beans

Musim semi memiliki 2 wadah musim semi:

1) BeanFactory 2) ApplicationContext

BeanFactory adalah wadah paling sederhana dan hanya menerima satu file konfigurasi. ApplicationContext adalah Semi kontainer paling maju dan digunakan dalam aplikasi perusahaan karena ia menerima array file konfigurasi, memiliki integrasi JNDI, integrasi EJB dan mendukung internasionalisasi pesan.

Saya harap itu membantu.


1
2018-03-04 22:50



Biarkan saya pertama kali menunjukkan berbeda dalam pengkodean pertama:

  1. XML: Anda harus mendaftarkan kacang musim semi Anda di dalam file konteks xml menggunakan <bean/>
  2. Java Configuration: Anda harus menggunakan @Configuration dan @Bean untuk mendaftarkan kacang musim semi Anda dalam konteks.

  3. Anotasi: dengan menggunakan @Component dan teman-temannya sebenarnya umum dapat digunakan dengan 2 lainnya menggunakan:

    1. dalam xml menggunakan <context:component-scan/>
    2. di java config menggunakan @ComponentScan

Mengapa digunakan ClassPathXmlApplicationContextkarena dia menggunakan xml untuk mengkonfigurasi pemindaian komponen tetapi jika dia menggunakannya @ComponentScan Maka pasti akan digunakan AnnotationConfigApplicationContext

Jadi bagi saya, saya menganggapnya sebagai 2 cara untuk menginisialisasi konteks musim semi xml atau konfigurasi java dan Anotasi adalah opsi yang dapat digunakan oleh salah satu dari mereka atau tidak digunakan sama sekali.


1
2018-03-07 07:43



Tiga cara untuk mengkonfigurasi kerangka pegas sama sekali tidak dimaksudkan untuk saling eksklusif. Sebenarnya, tebakan saya adalah bahwa rata-rata Anda akan menemukan setidaknya dua dari mereka digunakan bersama.

Konfigurasi berbasis anotasi adalah yang paling tidak mungkin digunakan secara mandiri, hanya karena bergantung pada metadata yang secara inheren tersebar di seluruh kode sumber.

Itu AnnotationConfigApplicationContext  dapat digunakan untuk menjalankan a murni konteks berbasis anotasi, tetapi Anda harus melewatinya semua kelasmu dianotasi sebagai @Component atau turunan, alih-alih lewat dalam satu (atau beberapa) @Configurationkelas -anasi (es) - yang biasanya tidak praktis.

Meskipun ini hampir sama dengan daftar statis kacang di XML atau konfigurasi Java, fakta bahwa Anda harus melakukan ini dalam kode ketika Anda membangun konteks aplikasi itu sendiri membuatnya kurang bermanfaat, karena Anda tidak dapat memanfaatkan berbagai cara cerdas untuk secara otomatis mengaktifkan konteks aplikasi (dalam konteks web dan sebagainya).

Itulah mengapa Anda mungkin ingin dapat memiliki metadata grafik objek lengkap yang dikumpulkan sekaligus, dan yang hanya bisa dicapai dengan konfigurasi berbasis XML atau Java, yang bergantung pada metadata "terpusat" yang menggambarkan seluruh grafik objek.

Untuk kedua pendekatan berbasis XML dan Java, ini "metadata terpusat" (<beans> atau @Configuration) dapat didefinisikan secara statis (dengan eksplisit <bean> atau @Bean definisi) atau secara dinamis (menggunakan <component-scan> atau @ComponentScan). Jadi masuk akal untuk mengatakan bahwa kedua pendekatan ini hanya format yang berbeda dengan cukup banyak kemampuan yang sama yang dapat menguntungkan baik dari konfigurasi berbasis anotasi untuk mengumpulkan metadata "de-terpusat".


1
2018-03-14 07:29