Apa's perbedaan antara @Komponen, @Repository & @Layanan penjelasan di musim Semi?

Dari musim Semi Documentation:

Di musim Semi 2.0 dan kemudian, @Repositori anotasi adalah penanda untuk setiap kelas yang memenuhi peran atau stereotip (juga dikenal sebagai Data Akses Objek atau DAO) dari repositori. Di antara yang menggunakan penanda ini adalah terjemahan otomatis dari pengecualian.

musim Semi 2.5 memperkenalkan lebih jauh stereotip penjelasan: @Komponen, @Service, dan @Controller. @Komponen generik stereotip untuk setiap musim Semi-managed komponen. @Repositori, @Service, dan @Controller yang spesialisasi dari @Komponen untuk kasus-kasus penggunaan tertentu, untuk contoh, dalam ketekunan, layanan, dan presentasi lapisan, masing-masing.

oleh Karena itu, anda dapat memberikan keterangan komponen kelas dengan @Komponen, tetapi oleh annotating mereka dengan @Repositori, @Service, atau @Controller sebaliknya, anda kelas yang lebih benar cocok untuk diproses oleh alat-alat atau berhubungan dengan aspek-aspek. Misalnya, ini penjelasan stereotip membuat target ideal untuk pointcuts.

dengan Demikian, jika anda memilih antara menggunakan @Komponen atau @Service untuk your service layer, @Jasa adalah jelas pilihan yang lebih baik. Demikian pula, seperti yang dinyatakan di atas, @Repositori sudah didukung sebagai penanda untuk otomatis terkecuali terjemahan dalam persistence layer.

┌────────────┬─────────────────────────────────────────────────────┐
│ Annotation │ Meaning                                             │
├────────────┼─────────────────────────────────────────────────────┤
│ @Component │ generic stereotype for any Spring-managed component │
│ @Repository│ stereotype for persistence layer                    │
│ @Service   │ stereotype for service layer                        │
│ @Controller│ stereotype for presentation layer (spring-mvc)      │
└────────────┴─────────────────────────────────────────────────────┘

Karena banyak jawaban yang sudah menyatakan apa yang anotasi ini digunakan untuk, we'll di sini fokus pada beberapa perbedaan-perbedaan kecil di antara mereka.

Pertama Kesamaan

titik Pertama yang pantas digaris bawahi lagi adalah bahwa sehubungan dengan scan-auto-deteksi dan dependency injection untuk BeanDefinition semua ini penjelasan (viz., @Komponen, @Service, @Repository, @Controller) adalah sama. Kita dapat menggunakan salah satu di tempat yang lain dan masih bisa mendapatkan dengan cara kami main.

Perbedaan antara @Komponen, @Repository, @Controller dan @Layanan

@Komponen

Ini adalah tujuan umum stereotip penjelasan yang menunjukkan bahwa kelas adalah musim semi komponen.

Apa yang khusus tentang @Komponen <konteks:component-scan> hanya scan @Komponen dan tidak mencari @Controller, @Service dan @Repositori pada umumnya. Mereka dipindai karena mereka sendiri dijelaskan dengan @Komponen.

Hanya mengambil melihat @Controller, @Service dan @Repositori penjelasan definisi:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Dengan demikian, hal ini tidak salah untuk mengatakan bahwa @Controller, @Service dan @Repositori adalah jenis khusus dari @Komponen penjelasan. <konteks:component-scan> mengambil mereka dan mendaftarkan mereka mengikuti kelas-kelas seperti kacang-kacangan, sama seperti jika mereka dijelaskan dengan @Komponen.

Khusus jenis anotasi juga dipindai, karena mereka sendiri dijelaskan dengan @Komponen anotasi, yang berarti mereka juga @Komponen. Jika kita mendefinisikan kita sendiri kustom penjelasan dan keterangan itu dengan@Komponen, itu akan juga bisa dipindai dengan`

@Repositori

Ini adalah untuk menunjukkan bahwa kelas mendefinisikan data repository.

Apa yang khusus tentang @Repository?

Selain itu untuk menunjukkan, bahwa ini adalah Penjelasan berdasarkan Konfigurasi, @Repositoris tugasnya adalah untuk menangkap platform pengecualian tertentu dan kembali melemparkan mereka sebagai salah satu musim Semi terpadu dicentang terkecuali. Untuk ini, kita disediakan dengan PersistenceExceptionTranslationPostprocessor, bahwa kita diminta untuk menambahkan di musim Semi ini aplikasi konteks seperti ini:

Kacang ini posting prosesor menambah seorang pembimbing untuk setiap kacang yang dijelaskan dengan @Repositori sehingga setiap platform-spesifik pengecualian tertangkap dan kemudian kembali dilempar sebagai salah satu musim Semi ini dicentang akses data pengecualian.

@Controller

The @Controller penjelasan menunjukkan bahwa kelas tertentu menyajikan peran controller. The @Controller penjelasan bertindak sebagai stereotip untuk dijelaskan kelas, menunjukkan perannya.

Apa yang khusus tentang @Controller?

Kita tidak bisa beralih penjelasan ini dengan yang lainnya, seperti @Service atau @Repositori, meskipun mereka terlihat sama. Operator scan kelas dijelaskan dengan @Controller dan mendeteksi metode dijelaskan dengan @RequestMapping penjelasan dalam diri mereka. Kita dapat menggunakan @RequestMapping di/di-satunya metode-metode dan kelas yang dijelaskan dengan @Controller dan itu akan TIDAK **** bekerja dengan @Komponen, @Service, @Repositori dll...

Note: Jika kelas sudah terdaftar sebagai bean melalui cara lain, seperti melalui @Bean atau melalui @Komponen, @Jasa dll... anotasi, maka @RequestMapping dapat dipetik jika kelas ini juga dijelaskan dengan @RequestMapping penjelasan. Tapi yang's skenario yang berbeda.

@Service

@Jasa kacang memegang logika bisnis dan memanggil metode dalam repositori lapisan.

Apa yang khusus tentang @Service?

Terlepas dari kenyataan bahwa itu's digunakan untuk menunjukkan, bahwa hal itu's memegang logika bisnis, tidak ada lagi yang terlihat di penjelasan ini; tapi siapa yang tahu, musim Semi dapat menambahkan beberapa tambahan yang luar biasa di masa depan.

Apa lagi?

Mirip dengan di atas, di masa depan musim Semi dapat menambahkan fungsi-fungsi khusus untuk @Service, @Controller dan @Repositori berdasarkan layering konvensi. Oleh karena itu, it's selalu ide yang baik untuk menghormati konvensi dan menggunakannya sesuai dengan lapisan.

Mereka hampir sama - mereka semua berarti bahwa kelas adalah musim Semi bean. @Service, @Repositori dan @Controller khusus `@Komponen. Anda dapat memilih untuk melakukan tindakan tertentu dengan mereka. Misalnya:

• @Controller kacang yang digunakan oleh spring mvc
• @Repositori kacang yang memenuhi syarat untuk ketekunan terkecuali terjemahan

Hal lain adalah bahwa anda tentukan komponen semantik untuk lapisan yang berbeda.

Satu hal yang @Komponen ini adalah bahwa anda dapat membubuhi keterangan lainnya penjelasan dengan itu, dan kemudian menggunakan mereka dengan cara yang sama sebagai @Service.

Misalnya baru-baru ini saya buat:

@Component
@Scope("prototype")
public @interface ScheduledJob {..}

Jadi semua kelas dijelaskan dengan @ScheduledJob adalah musim semi kacang-kacangan dan selain yang terdaftar sebagai kuarsa pekerjaan. Anda hanya perlu memberikan kode yang menangani anotasi.

@Komponen setara dengan

@Service, @Controller, @Repositori = {@Komponen + beberapa fungsi khusus}

Itu berarti Layanan, Controller dan Repositori secara fungsional sama.

Tiga penjelasan digunakan untuk memisahkan "Lapisan" dalam aplikasi anda,

• Pengendali hanya melakukan hal-hal seperti pengiriman, ekspedisi, layanan panggilan metode dll. Layanan Tahan Logika bisnis, Perhitungan dll.
• Repository adalah DAOs (Data Access Objects), mereka mengakses database secara langsung.

Sekarang anda mungkin bertanya mengapa memisahkan mereka: (saya berasumsi anda tahu AOP-Aspek Pemrograman Berorientasi)

Let's mengatakan anda ingin Memantau Aktivitas DAO hanya Lapisan. Anda akan menulis sebuah Aspek (A class) kelas yang melakukan penebangan sebelum dan setelah setiap metode yang anda DAO dipanggil, anda dapat melakukannya menggunakan AOP anda memiliki tiga Lapisan yang berbeda dan tidak dicampur.

Sehingga anda dapat melakukan penebangan DAO "di", "sebelum" atau "setelah" DAO metode. Anda bisa melakukan itu karena anda memiliki DAO di tempat pertama. Apa yang anda hanya dicapai adalah Pemisahan masalah atau tugas.

Bayangkan jika hanya ada satu penjelasan @Controller, maka komponen ini akan memiliki pengiriman, logika bisnis, dan mengakses database semua dicampur, jadi kotor kode!

Disebutkan di atas adalah salah satu yang sangat umum skenario, ada banyak kasus penggunaan mengapa menggunakan tiga penjelasan.

Di musim Semi @Komponen, @Service, @Controller, dan @Repositori adalah Stereotip penjelasan yang digunakan untuk:

@Controller: di mana anda meminta ** pemetaan dari halaman presentasi** dilakukan yaitu lapisan Presentasi won't pergi ke file lain itu pergi langsung ke @Controller kelas dan pemeriksaan untuk diminta jalan di @RequestMapping penjelasan yang ditulis sebelum metode panggilan jika diperlukan.

@Service: Semua logika bisnis ini di sini yaitu Data yang berhubungan dengan perhitungan dan semua.Ini penjelasan bisnis lapisan di mana user tidak langsung call ketekunan metode sehingga akan memanggil metode ini menggunakan penjelasan ini. Ini akan meminta @Repository sebagai per permintaan pengguna

@Repositori: Ini adalah Persistence layer(Data Access Layer) dari aplikasi yang digunakan untuk mendapatkan data dari database. yaitu semua Database terkait operasi yang dilakukan oleh repositori.

@Komponen - memberikan Keterangan komponen lain (misalnya SISA sumber daya kelas) dengan komponen stereotip.

Menunjukkan bahwa beranotasi kelas adalah "komponen". Kelas tersebut dianggap sebagai kandidat untuk auto-deteksi ketika menggunakan penjelasan konfigurasi berbasis dan classpath pemindaian.

kelas Lainnya-tingkat anotasi dapat dianggap sebagai mengidentifikasi komponen dan juga, biasanya jenis khusus dari komponen: misalnya @Repository penjelasan atau AspectJ's @Aspek penjelasan.

musim Semi 2.5 memperkenalkan lebih jauh stereotip penjelasan: @Komponen, @Layanan dan @Controller. @Komponen yang berfungsi sebagai generic stereotip untuk musim Semi-managed komponen; sedangkan, @Repository, @Service, dan @Controller berfungsi sebagai spesialisasi dari @Komponen untuk kasus-kasus penggunaan tertentu (misalnya, dalam ketekunan, layanan, dan presentasi lapisan, masing-masing). Apa ini berarti adalah bahwa anda dapat memberikan keterangan komponen kelas dengan @Komponen, tetapi oleh annotating mereka dengan @Repository, @Layanan, atau @Controller sebaliknya, kelas yang lebih benar cocok untuk diproses oleh alat-alat atau berhubungan dengan aspek-aspek. Misalnya, ini stereotip anotasi membuat target ideal untuk pointcuts. Tentu saja, hal ini juga mungkin bahwa @Repository, @Service, dan @Controller dapat membawa tambahan semantik dalam rilis mendatang dari Spring Framework. Dengan demikian, jika anda membuat keputusan antara menggunakan @Komponen atau @Service untuk service layer, @Layanan adalah jelas pilihan yang lebih baik. Demikian pula, sebagaimana dinyatakan di atas, @Repository sudah didukung sebagai penanda otomatis terkecuali terjemahan dalam persistence layer.

@Komponen – Menunjukkan auto scan komponen. @Repository – Menunjukkan DAO komponen dalam persistence layer. @Service – Menunjukkan komponen Layanan dalam bisnis lapisan. @Controller – Menunjukkan controller komponen dalam lapisan presentasi.

referensi :- musim Semi Dokumentasi - Classpath pemindaian, berhasil komponen dan penulisan konfigurasi menggunakan Java

Penggunaan @Service dan @Repositori penjelasan penting dari koneksi database perspektif.

1. Menggunakan @Service untuk semua layanan web anda jenis koneksi DB
2. Menggunakan @Repositori untuk semua anda disimpan proc koneksi DB

Jika anda tidak menggunakan penjelasan yang tepat, anda mungkin menghadapi melakukan pengecualian diganti oleh rollback transaksi. Anda akan melihat pengecualian selama stres uji beban yang terkait untuk memutar kembali JDBC transaksi.

Secara teknis @Controller, @Service, @Repositori semua sama. Semua dari mereka meluas @Komponen.

Dari musim Semi source code:

Menunjukkan bahwa beranotasi kelas adalah "komponen". Kelas tersebut dianggap sebagai kandidat untuk auto-deteksi ketika menggunakan anotasi-berdasarkan konfigurasi dan classpath pemindaian.

Kita dapat langsung menggunakan @Komponen untuk masing-masing dan setiap bean, namun untuk pemahaman yang lebih baik dan pemeliharaan yang besar aplikasi, kami menggunakan @Controller, @Service, @Repositori.

Tujuan dari masing-masing penjelasan:

1. @Controller -> Kelas dijelaskan dengan ini, dimaksudkan untuk menerima permintaan dari client side. Permintaan pertama datang ke Operator Servlet, dari mana ia melewati permintaan tertentu controller menggunakan nilai @RequestMapping penjelasan.
2. @Service -> Kelas dijelaskan dengan ini, dimaksudkan untuk memanipulasi data, yang kami terima dari klien atau mengambil dari database. Semua manipulasi dengan data harus dilakukan di layer ini.
3. @Repositori -> Kelas dijelaskan dengan ini, dimaksudkan untuk menghubungkan dengan database. Hal ini juga dapat dianggap sebagai DAO(Data Access Object) lapisan. Lapisan ini harus dibatasi untuk CRUD (create, retrieve, update, delete) operasi saja. Jika ada manipulasi diperlukan, data harus dikirim akan mengirim kembali ke @Service layer.

Jika kita pertukaran tempat mereka(menggunakan @Repositori di tempat @Controller), aplikasi kita akan bekerja dengan baik.

Tujuan utama dari menggunakan tiga berbeda @anotasi adalah untuk memberikan yang lebih baik Modularitas untuk aplikasi Enterprise.

@Repositori @Service dan @Controller yang berfungsi sebagai spesialisasi dari @Komponen untuk penggunaan tertentu atas dasar itu anda dapat mengganti @Layanan @Komponen tetapi dalam kasus ini anda longgar spesialisasi.

1. **@Repository**   - Automatic exception translation in your persistence layer.
2. **@Service**      - It indicates that the annotated class is providing a business service to other layers within the application.

semua ini penjelasan jenis jenis stereo jenis penjelasan,perbedaan antara tiga anotasi

• Jika kita tambahkan @Komponen kemudian menceritakan peran kelas adalah kelas komponen itu berarti itu adalah sebuah kelas yang terdiri dari beberapa logika,tetapi tidak mengatakan apakah sebuah kelas yang berisi khusus bisnis atau ketekunan atau kontroler logika sehingga kita don't digunakan secara langsung ini @Komponen penjelasan
• Jika kita tambahkan @Layanan penjelasan kemudian ia memberitahu bahwa peran dari kelas yang terdiri logika bisnis
• Jika kita tambahkan @Repositori di atas kelas kemudian ia memberitahu bahwa kelas terdiri ketekunan logika
• Berikut @Komponen dasar penjelasan untuk @Service,@Repositori dan @Controller penjelasan

misalnya

package com.spring.anno;
@Service
public class TestBean
{
    public void m1()
    {
       //business code
    }
}

package com.spring.anno;
@Repository
public class TestBean
{
    public void update()
    {
       //persistence code
    }
}

• setiap kali kita menambahkan @Service atau @Repositroy atau @Controller penjelasan secara default @Komponen penjelasan akan keberadaan di atas kelas

Spring menyediakan empat jenis komponen otomotif scan penjelasan, mereka @Komponen, @Service, @Repositori dan @Controller. Secara teknis, tidak ada perbedaan di antara mereka, tapi setiap komponen otomotif scan penjelasan harus digunakan untuk tujuan khusus dan hanya didefinisikan lapisan.

@Komponen: ini adalah dasar komponen otomotif scan penjelasan, hal ini menunjukkan dijelaskan kelas adalah auto scan komponen.

@Controller: Beranotasi kelas menunjukkan bahwa itu adalah sebuah komponen controller, dan terutama digunakan pada lapisan presentasi.

@Service: Ini menunjukkan dijelaskan kelas adalah Layanan komponen dalam bisnis lapisan.

@Repositori: Anda perlu menggunakan penjelasan ini dalam ketekunan lapisan ini bertindak seperti database repositori.

Satu harus memilih yang lebih khusus berupa @Komponen sementara annotating kelas mereka sebagai penjelasan ini mungkin mengandung perilaku tertentu akan maju.

Kita dapat menjawab pertanyaan ini menurut jawa standar

Mengacu pada JSR-330, yang sekarang didukung oleh musim semi, anda hanya dapat menggunakan @Bernama untuk menentukan bean (Entah bagaimana @Bernama=@Komponen). Sehingga menurut standar ini, tampaknya bahwa tidak ada gunanya untuk menentukan stereotip (seperti @Repositori, @Service, @Controller) untuk kategori kacang-kacangan.

Tapi musim semi user ini berbeda dengan penjelasan yang berbeda untuk penggunaan tertentu, misalnya:

1. Membantu pengembang menentukan baik kategori kompeten. Ini mengkategorikan dapat menjadi sangat membantu dalam beberapa kasus. (Misalnya ketika anda menggunakan aspect-oriented, ini bisa menjadi kandidat yang baik untuk pointcuts)
2. @Repositori penjelasan akan menambahkan beberapa fungsi untuk anda bean (otomatis beberapa pengecualian terjemahan untuk bean persistence layer).
3. Jika anda menggunakan spring MVC, @RequestMapping hanya dapat ditambahkan ke kelas yang dijelaskan oleh @Controller.

Keterangan lain dengan komponen @Komponen, misalnya SISA Sumber daya kelas.

@Component
public class AdressComp{
    .......
    ...//some code here    
}

@Komponen generik stereotip untuk setiap musim Semi berhasil komponen.

@Controller, @Layanan dan @Repository adalah Spesialisasi dari @Komponen untuk kasus-kasus penggunaan tertentu.

@Komponen di musim Semi

Bahkan jika kita interchange @Komponen atau @Repositori atau @service

Ia akan berperilaku yang sama , tapi salah satu aspek adalah bahwa mereka tidak akan mampu menangkap beberapa pengecualian tertentu yang terkait dengan DAO bukan dari Repositori jika kita menggunakan komponen atau @ service

Di musim Semi 4, versi terbaru:

@Repository anotasi adalah penanda untuk setiap kelas yang memenuhi peran atau stereotip dari repositori (juga dikenal sebagai Data Access Object atau DAO). Di antara yang menggunakan penanda ini adalah terjemahan otomatis dari pengecualian seperti yang dijelaskan dalam Bagian 20.2.2, "Pengecualian terjemahan".

Spring menyediakan lebih stereotip penjelasan: @Komponen, @Service, dan @Controller. @Komponen generik stereotip untuk setiap musim Semi-managed komponen. @Repository, @Service, dan @Controller spesialisasi dari @Komponen untuk lebih spesifik penggunaan kasus-kasus, untuk contoh, dalam ketekunan, layanan, dan presentasi lapisan, masing-masing. Oleh karena itu, anda dapat memberikan keterangan komponen kelas dengan @Komponen, tetapi oleh annotating mereka dengan @Repository, @Service, atau @Controller sebaliknya, kelas yang lebih benar cocok untuk pengolahan dengan alat-alat atau berhubungan dengan aspek-aspek. Misalnya, ini stereotip anotasi membuat target ideal untuk pointcuts. Hal ini juga mungkin bahwa @Repository, @Service, dan @Controller dapat membawa tambahan semantik dalam rilis mendatang dari Spring Framework. Dengan demikian, jika anda memilih antara menggunakan @Komponen atau @Layanan untuk anda service layer, @Layanan adalah jelas pilihan yang lebih baik. Demikian pula, sebagai dinyatakan di atas, @Repository sudah didukung sebagai penanda untuk otomatis terkecuali terjemahan dalam persistence layer.

@Komponen adalah tingkat atas generik penjelasan yang membuat annotated bean yang akan dipindai dan tersedia di DI wadah

@Repositori adalah berupa penjelasan dan membawa fitur mengkonversi semua dicentang pengecualian dari kelas DAO

@Jasa adalah berupa penjelasan. itu tidak membawa fitur baru seperti sekarang tapi itu menjelaskan maksud dari kacang

@Controller adalah berupa penjelasan yang membuat bean MVC sadar dan memungkinkan penggunaan lebih lanjut penjelasan seperti @RequestMapping dan semua seperti

Di sini lebih detail

Tidak ada perbedaan antara @Komponen,@Service,@Controller,@Repositori. @Komponen adalah penjelasan Generik untuk mewakili komponen MVC kami. Tapi akan ada beberapa komponen sebagai bagian dari MVC aplikasi seperti layanan lapisan komponen, ketekunan lapisan komponen dan lapisan presentasi komponen. Jadi untuk membedakan mereka musim Semi orang-orang yang telah diberikan tiga lainnya penjelasan juga.

Untuk mewakili kegigihan lapisan komponen : @Repository

Untuk mewakili service layer komponen : @Service

Untuk mewakili lapisan presentasi komponen : @Controller

atau anda dapat menggunakan @Komponen untuk mereka semua.

A @Service untuk mengutip semi dokumentasi,

Menunjukkan bahwa beranotasi kelas adalah "Layanan", awalnya didefinisikan oleh Domain-Driven Design (Evans, 2003) sebagai "operasi ditawarkan sebagai antarmuka yang berdiri sendiri dalam model, dengan tidak dikemas negara." juga Dapat menunjukkan bahwa kelas adalah "Bisnis Layanan Fasad" (di Inti J2EE pola akal), atau sesuatu yang serupa. Penjelasan ini adalah tujuan umum stereotip dan tim individu dapat mempersempit mereka semantik dan penggunaan yang sesuai.

Jika anda melihat domain driven design oleh eric evans,

LAYANAN adalah SEBUAH operasi yang ditawarkan sebagai sebuah antarmuka yang berdiri sendiri di model, tanpa encapsulating negara, sebagai ENTITAS dan NILAI benda-BENDA lakukan. JASA adalah pola umum dalam kerangka kerja teknis, tapi mereka dapat juga berlaku dalam domain layer. Nama layanan ini menekankan hubungan dengan benda-benda lainnya. Tidak seperti ENTITAS dan NILAI benda-BENDA, itu didefinisikan murni dalam hal apa yang bisa lakukan untuk klien. LAYANAN cenderung bernama untuk suatu kegiatan, bukan sebuah entitas—kata kerja yang agak dari kata benda. LAYANAN ini masih dapat memiliki abstrak, disengaja definisi; itu hanya memiliki rasa yang berbeda dari definisi objek. LAYANAN yang masih harus didefinisikan tanggung jawab, dan yang tanggung jawab dan antarmuka memenuhi hal itu harus didefinisikan sebagai bagian dari domain model. Operasi nama harus datang dari di mana-MANA BAHASA atau akan diperkenalkan ke dalamnya. Parameter dan hasil harus domain benda-benda. PELAYANAN harus digunakan secara bijaksana dan tidak diizinkan untuk strip ENTITAS dan NILAI benda-BENDA dari semua perilaku mereka. Tetapi ketika operasi benar-benar penting domain konsep, bentuk-bentuk LAYANAN bagian alami dari MODEL-DRIVEN DESIGN. Dinyatakan dalam model sebagai LAYANAN, bukan sebagai palsu objek yang doesn't benar-benar mewakili apa-apa, operasi mandiri tidak akan menyesatkan siapa pun.

dan Repository sesuai Eric Evans,

REPOSITORI mewakili semua objek dari jenis tertentu seperti konseptual set (biasanya ditiru). Itu bertindak seperti sebuah koleksi, kecuali dengan lebih rumit query kemampuan. Objek dari jenis yang sesuai adalah ditambahkan dan dihapus, dan mesin belakang REPOSITORY sisipan mereka atau menghapus mereka dari database. Definisi ini mengumpulkan kohesif mengatur tanggung jawab untuk menyediakan akses ke akar AGREGAT dari awal siklus kehidupan sampai akhir.

@Komponen: anda membubuhi keterangan kelas @Komponen, ia memberitahu hibernate bahwa itu adalah Kacang.

@Repositori: anda membubuhi keterangan kelas @Repository, ia memberitahu hibernate ini adalah DAO kelas dan memperlakukannya sebagai DAO kelas. Berarti itu membuat dicentang pengecualian (dilempar dari DAO metode) yang memenuhi syarat untuk terjemahan ke Semi DataAccessException.

@Service: Ini memberitahu hibernate ini adalah kelas Layanan di mana anda akan memiliki @Transaksional dll Service layer anotasi jadi hibernate memperlakukan itu sebagai Layanan komponen.

Plus @Layanan muka @Komponen. Menganggap bean nama kelas adalah CustomerService, karena anda tidak memilih XML bean konfigurasi cara agar anda beranotasi bean dengan @Komponen untuk menunjukkan itu sebagai Kacang. Jadi sementara mendapatkan kacang objek CustomerService cust = (CustomerService)konteks.getBean("customerService"); secara default, musim Semi akan menurunkan kasus karakter pertama dari komponen – dari 'CustomerService' untuk 'customerService'. Dan anda dapat mengambil komponen ini dengan nama 'customerService'. Tetapi jika anda menggunakan @Layanan penjelasan untuk bean kelas anda dapat memberikan bean nama spesifik oleh

@Service("AAA")
public class CustomerService{

dan anda bisa mendapatkan kacang objek dengan

CustomerService cust = (CustomerService)context.getBean("AAA");

Gudang dan Layanan anak-anak Komponen penjelasan. Jadi, semua dari mereka adalah Komponen. Gudang dan Layanan hanya memperluas itu. Bagaimana sebenarnya? Layanan hanya memiliki perbedaan ideologi: kami menggunakan jasa. Gudang memiliki tertentu handler pengecualian.