Bisa @Component,@Repository dan @Serviceanotasi digunakan secara bergantian di Spring atau apakah ia menyediakan fungsionalitas tertentu selain bertindak sebagai perangkat notasi?

Dengan kata lain, jika saya memiliki kelas Layanan dan saya mengubah anotasi dari @Servicemenjadi @Component, apakah masih akan berlaku seperti itu?

Atau apakah anotasi juga memengaruhi perilaku dan fungsi kelas?

Dari Dokumentasi Musim Semi :

The @Repositorypenjelasan merupakan penanda untuk setiap kelas yang memenuhi peran atau stereotip dari repositori (juga dikenal sebagai Data Access Object atau DAO). Di antara penggunaan penanda ini adalah terjemahan pengecualian secara otomatis, seperti yang dijelaskan dalam Terjemahan Pengecualian .

Spring menyediakan lanjut penjelasan stereotipe: @Component, @Service, dan @Controller. @Componentadalah stereotip umum untuk komponen apa pun yang dikelola oleh Pegas. @Repository,, @Servicedan @Controllermerupakan spesialisasi @Componentuntuk kasus penggunaan yang lebih spesifik (masing-masing, di lapisan persistensi, layanan, dan presentasi). Oleh karena itu, Anda dapat membubuhi keterangan kelas komponen Anda dengan @Component, tetapi, dengan annotating mereka dengan @Repository, @Serviceatau @Controller sebaliknya, kelas Anda lebih baik cocok untuk pengolahan oleh alat-alat atau berhubungan dengan aspek.

Misalnya, anotasi stereotip ini membuat target ideal untuk pemotongan titik. @Repository,, @Servicedan @Controllerjuga dapat membawa semantik tambahan dalam rilis Spring Framework mendatang. Jadi, jika Anda memilih antara menggunakan @Componentatau @Serviceuntuk lapisan layanan Anda, @Servicejelas merupakan pilihan yang lebih baik. Demikian pula, seperti yang dinyatakan sebelumnya, @Repositorysudah didukung sebagai penanda untuk terjemahan pengecualian otomatis di lapisan kegigihan Anda.

┌──────────────┬─────────────────────────────────────────────────────┐
│ 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 sudah menyatakan untuk apa anotasi ini digunakan, kami di sini akan fokus pada beberapa perbedaan kecil di antara mereka.

Pertama, Kesamaan

Poin pertama yang perlu disorot lagi adalah itu sehubungan dengan pemindaian-deteksi otomatis dan injeksi dependensi untuk BeanDefinition, semua anotasi ini (yaitu, @Component, @Service, @Repository, @Controller) adalah sama. Kita dapat menggunakan satu di tempat yang lain dan masih bisa mendapatkan jalan kita.

Perbedaan antara @Component, @Repository, @Controller dan @Service

@Komponen

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

Apa yang istimewa tentang pemindaian
<context:component-scan> hanya @Component@Component dan tidak mencari@Controller,@Service dan @Repositorysecara umum. Mereka dipindai karena mereka sendiri diberi penjelasan @Component.

Lihat saja @Controller, @Servicedan @Repositorydefinisi anotasi:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Jadi, tidak salah untuk mengatakan itu @Controller, @Servicedan @Repositorymerupakan tipe khusus@Component penjelasan khusus. <context:component-scan>jemput mereka dan daftarkan kelas-kelas berikut sebagai kacang, seolah-olah mereka diberi penjelasan @Component.

Anotasi jenis khusus juga dipindai, karena mereka sendiri dijelaskan dengan @Componentanotasi, yang berarti juga @Components. Jika kami menetapkan anotasi khusus kami sendiri dan memberikan anotasi dengannya @Component, ia juga akan dipindai<context:component-scan>

@Gudang

Ini untuk menunjukkan bahwa kelas mendefinisikan repositori data.

Apa yang spesial dari @Repository?

Selain menunjukkan, bahwa ini adalah Konfigurasi berbasis Annotation , @Repositorytugasnya adalah menangkap pengecualian spesifik platform dan melemparkannya kembali sebagai salah satu pengecualian Spring yang tidak dicentang dan tidak dicocokkan. Untuk ini, kami disediakan PersistenceExceptionTranslationPostProcessor, yang kami harus tambahkan dalam konteks aplikasi Spring kami seperti ini:

<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>

Pemroses posting kacang ini menambahkan penasihat untuk setiap kacang yang diberi keterangan @Repositorysehingga setiap pengecualian spesifik platform ditangkap dan kemudian dilemparkan kembali sebagai salah satu pengecualian akses data Spring yang tidak dicentang.

@ Kontrol

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

Apa yang spesial dari @Controller?

Kami tidak dapat mengganti anotasi ini dengan yang lain seperti @Serviceatau @Repository, meskipun mereka terlihat sama. Dispatcher memindai kelas yang dianotasi @Controllerdan mendeteksi metode yang dianotasi dengan @RequestMappinganotasi di dalamnya. Kita dapat menggunakan @RequestMappingon / hanya metode-metode yang kelas dijelaskan dengan @Controllerdan itu akan tidak bekerja dengan @Component, @Service, @Repositorydll ...

_{Catatan: Jika kelas sudah terdaftar sebagai kacang melalui metode alternatif, seperti melalui @Beanatau melalui @Component, @Servicedll ... anotasi, maka @RequestMappingdapat dipilih jika kelas juga dijelaskan dengan @RequestMappinganotasi. Tapi itu skenario yang berbeda.}

@Layanan

@Service kacang memegang logika bisnis dan memanggil metode di lapisan repositori.

Apa yang spesial dari @Service?

Terlepas dari kenyataan bahwa itu digunakan untuk menunjukkan, bahwa itu memegang logika bisnis, tidak ada yang terlihat dalam anotasi ini; tapi siapa tahu, Spring dapat menambahkan beberapa tambahan luar biasa di masa depan.

Apa lagi?

Mirip dengan di atas, di musim semi yang akan datang dapat menambahkan fungsi khusus untuk @Service, @Controllerdan @Repositoryberdasarkan pada konvensi layering mereka. Oleh karena itu, itu selalu merupakan ide yang baik untuk menghormati konvensi dan menggunakannya sesuai dengan lapisan.

Mereka hampir sama - semuanya berarti bahwa kelas adalah kacang Spring. @Service, @Repositorydan @Controllerterspesialisasi @Component. Anda dapat memilih untuk melakukan tindakan tertentu dengannya. Sebagai contoh:

• @Controller kacang digunakan oleh musim semi-mvc
• @Repository kacang memenuhi syarat untuk terjemahan pengecualian kegigihan

Hal lain adalah Anda menetapkan komponen secara semantik ke berbagai lapisan.

Satu hal yang @Componentmenawarkan adalah Anda dapat membuat anotasi anotasi lain dengannya, lalu menggunakannya dengan cara yang sama @Service.

Misalnya baru-baru ini saya buat:

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

Jadi semua kelas yang dijelaskan dengan @ScheduledJobadalah kacang musim semi dan selain itu terdaftar sebagai pekerjaan kuarsa. Anda hanya perlu memberikan kode yang menangani anotasi spesifik.

@Component setara dengan

<bean>

@Service, @Controller, @Repository = {@Component + beberapa fungsi khusus}

Itu berarti Layanan, Pengontrol dan Repositori secara fungsional sama.

Tiga anotasi digunakan untuk memisahkan "Layers" di aplikasi Anda,

• Pengontrol hanya melakukan hal-hal seperti mengirim, meneruskan, memanggil metode layanan dll.
• Logika bisnis Hold Service, Perhitungan dll.
• Repositori adalah DAO (Objek Akses Data), mereka mengakses database secara langsung.

Sekarang Anda mungkin bertanya mengapa memisahkan mereka: (Saya berasumsi Anda tahu Pemrograman Berorientasi AOP-Aspect)

Katakanlah Anda hanya ingin Memantau Aktivitas Lapisan DAO. Anda akan menulis kelas Aspect (A class) yang melakukan logging sebelum dan setelah setiap metode DAO Anda dipanggil, Anda dapat melakukannya dengan menggunakan AOP karena Anda memiliki tiga Layers yang berbeda dan tidak dicampur.

Jadi Anda dapat melakukan pencatatan DAO "sekitar", "sebelum" atau "setelah" metode DAO. Anda bisa melakukan itu karena Anda memiliki DAO di tempat pertama. Apa yang baru saja Anda capai adalah Pemisahan masalah atau tugas.

Bayangkan jika hanya ada satu penjelasan @Controller, maka komponen ini akan memiliki pengiriman, logika bisnis dan mengakses basis data semua campuran, kode begitu kotor!

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

Di musim semi @Component, @Service, @Controller, dan @Repositoryyang Stereotype penjelasan yang digunakan untuk:

@Controller:di mana pemetaan permintaan Anda dari halaman presentasi dilakukan yaitu lapisan Presentasi tidak akan pergi ke file lain itu langsung ke @Controllerkelas dan memeriksa jalur yang diminta dalam @RequestMappinganotasi yang ditulis sebelum pemanggilan metode jika perlu.

@Service: Semua logika bisnis ada di sini, yaitu kalkulasi terkait data dan semuanya. Penjelasan lapisan bisnis ini di mana pengguna kami tidak secara langsung memanggil metode kegigihan sehingga akan memanggil metode ini menggunakan anotasi ini. Ini akan meminta @Repositori sesuai permintaan pengguna

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

@Component - Buat anotasi komponen Anda yang lain (misalnya kelas sumber daya REST) ​​dengan stereotip komponen.

Menunjukkan bahwa kelas beranotasi adalah " komponen ". Kelas semacam itu dianggap sebagai kandidat untuk deteksi otomatis ketika menggunakan konfigurasi berbasis anotasi dan pemindaian classpath.

Anotasi tingkat kelas lainnya dapat dianggap sebagai pengidentifikasian komponen juga, biasanya jenis komponen khusus: misalnya anotasi @Repository atau anotasi @Aspect AspectJ.

Spring 2.5 memperkenalkan anotasi stereotip lebih lanjut: @Component, @Service dan @Controller. @Component berfungsi sebagai stereotip umum untuk komponen yang dikelola oleh Pegas; sedangkan @Repository, @Service, dan @Controller berfungsi sebagai spesialisasi dari @Component untuk kasus penggunaan yang lebih spesifik (misalnya, masing-masing, dalam lapisan persistensi, layanan, dan presentasi). Artinya, Anda dapat membuat anotasi kelas komponen Anda dengan @Component, tetapi dengan memberi anotasi dengan @Repository, @Service, atau @Controller sebagai gantinya, kelas Anda lebih cocok untuk diproses dengan alat atau bergaul dengan aspek. Misalnya, anotasi stereotip ini membuat target ideal untuk pemotongan titik. Tentu saja, dimungkinkan juga bahwa @Repository, @Service, dan @Controller dapat membawa semantik tambahan dalam rilis Spring Framework mendatang. Jadi, jika Anda membuat keputusan antara menggunakan @Component atau @Service untuk lapisan layanan Anda, @Service jelas merupakan pilihan yang lebih baik. Demikian pula, seperti yang dinyatakan di atas, @Repository sudah didukung sebagai penanda untuk terjemahan pengecualian otomatis di lapisan kegigihan Anda.

@Component – Indicates a auto scan component.
@Repository – Indicates DAO component in the persistence layer.
@Service – Indicates a Service component in the business layer.
@Controller – Indicates a controller component in the presentation layer.

referensi: - Dokumentasi Pegas - Pemindaian classpath, komponen terkelola, dan konfigurasi penulisan menggunakan Java

Secara teknis @Controller, @Service, @Repositorysemua sama. Semuanya meluas @Component.

Dari kode sumber Spring:

Menunjukkan bahwa kelas beranotasi adalah "komponen". Kelas semacam itu dianggap sebagai kandidat untuk deteksi otomatis ketika menggunakan konfigurasi berbasis anotasi dan pemindaian classpath.

Kami langsung dapat menggunakan @Componentuntuk setiap kacang, tapi untuk pemahaman yang lebih baik dan pemeliharaan dari aplikasi yang besar, kita gunakan @Controller, @Service,@Repository .

Tujuan dari setiap anotasi:

1. @Controller-> Kelas yang dijelaskan dengan ini, dimaksudkan untuk menerima permintaan dari sisi klien. Permintaan pertama datang ke Servlet Dispatcher, dari mana ia mengirimkan permintaan ke pengontrol tertentu menggunakan nilai @RequestMappinganotasi.
2. @Service-> Kelas yang dijelaskan dengan ini, dimaksudkan untuk memanipulasi data, yang kami terima dari klien atau mengambil dari database. Semua manipulasi dengan data harus dilakukan di lapisan ini.
3. @Repository-> Kelas yang dijelaskan dengan ini, dimaksudkan untuk terhubung dengan database. Itu juga dapat dianggap sebagai lapisan DAO (Data Access Object). Lapisan ini harus dibatasi hanya untuk operasi CRUD (buat, ambil, perbarui, hapus). Jika diperlukan manipulasi, data harus dikirim dikirim kembali ke lapisan @Service.

Jika kami menukar tempat mereka (digunakan @Repositorysebagai pengganti @Controller), aplikasi kami akan berfungsi dengan baik.

Tujuan utama menggunakan tiga berbeda @annotationsadalah untuk menyediakan Modularitas yang lebih baik untuk aplikasi Enterprise.

Penggunaan @Servicedan @Repositoryanotasi penting dari perspektif koneksi basis data.

1. Gunakan @Serviceuntuk semua jenis koneksi DB layanan web Anda
2. Gunakan @Repositoryuntuk semua koneksi DB proc tersimpan Anda

Jika Anda tidak menggunakan anotasi yang tepat, Anda dapat menghadapi pengecualian komit yang ditimpa oleh transaksi rollback. Anda akan melihat pengecualian selama stress load test yang terkait dengan memutar kembali transaksi JDBC.

@Repository @Service dan @Controller berfungsi sebagai spesialisasi @Component untuk penggunaan yang lebih spesifik atas dasar itu Anda dapat mengganti @Service ke @Component tetapi dalam kasus ini Anda kehilangan 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 anotasi ini adalah tipe tipe stereo anotasi, perbedaan antara ketiga anotasi tersebut

• Jika kita menambahkan @Component maka ia memberi tahu peran kelas adalah kelas komponen itu berarti itu adalah kelas yang terdiri dari beberapa logika, tetapi tidak memberi tahu apakah kelas yang berisi logika bisnis khusus atau ketekunan atau pengontrol sehingga kita tidak menggunakan langsung penjelasan anotasi @Component ini
• Jika kita menambahkan anotasi @Service maka ini memberi tahu bahwa peran kelas terdiri dari logika bisnis
• Jika kita menambahkan @Repository di atas kelas maka ia memberi tahu bahwa sebuah kelas terdiri dari logika persistensi
• Di sini @Component adalah penjelasan dasar untuk @ Service, @ Repository, dan penjelasan @Controller

sebagai contoh

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 @Serviceatau @Repositroyatau @Controlleranotasi secara default, @Componentanotasi akan ada di atas kelas

Spring menyediakan empat jenis komponen auto penjelasan scan, mereka @Component, @Service, @Repositorydan @Controller. Secara teknis, tidak ada perbedaan di antara mereka, tetapi setiap anotasi pemindaian komponen otomatis harus digunakan untuk tujuan khusus dan di dalam lapisan yang ditentukan.

@Component: Ini adalah anotasi pemindaian komponen otomatis dasar, ini menunjukkan kelas yang dianotasi adalah komponen pemindaian otomatis.

@Controller: Kelas beranotasi menunjukkan bahwa itu adalah komponen pengontrol, dan terutama digunakan pada lapisan presentasi.

@Service: Ini menunjukkan kelas beranotasi adalah komponen Layanan di lapisan bisnis.

@Repository: Anda perlu menggunakan anotasi ini di dalam lapisan persistensi, ini bertindak seperti repositori basis data.

Seseorang harus memilih bentuk yang lebih khusus @Componentketika menjelaskan kelas mereka karena penjelasan ini mungkin mengandung perilaku spesifik yang akan datang.

Kami dapat menjawab ini sesuai dengan standar java

Mengacu pada JSR-330, yang sekarang didukung oleh pegas, Anda hanya dapat menggunakan @Nameduntuk mendefinisikan kacang (Entah bagaimana @Named=@Component). Jadi menurut standar ini, tampaknya bahwa tidak ada gunanya untuk menentukan stereotip (seperti @Repository, @Service, @Controller) untuk kacang kategori.

Tetapi pegas pengguna anotasi yang berbeda ini dalam berbeda untuk penggunaan khusus, misalnya:

1. Bantu pengembang menentukan kategori yang lebih baik untuk yang kompeten. Pengelompokan ini dapat membantu dalam beberapa kasus. (Misalnya saat Anda menggunakan aspect-oriented, ini bisa menjadi kandidat yang bagus untuk pointcuts)
2. @Repository anotasi akan menambahkan beberapa fungsi ke kacang Anda (beberapa terjemahan pengecualian otomatis ke lapisan kegigihan kacang Anda).
3. Jika Anda menggunakan pegas MVC, @RequestMappinghanya bisa ditambahkan ke kelas yang dijelaskan oleh @Controller.

Buat anotasi komponen lain dengan @Component, misalnya kelas Sumberdaya REST.

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

@Component adalah stereotip umum untuk komponen yang dikelola Spring.

@Controller, @Service dan @Repository adalah Spesialisasi dari @Component untuk kasus penggunaan tertentu.

@Component di Musim Semi

Tidak ada perbedaan antara @Component, @Service, @Controller, @Repository. @Componentadalah anotasi Generik untuk mewakili komponen MVC kami. Tetapi akan ada beberapa komponen sebagai bagian dari aplikasi MVC kami seperti komponen lapisan layanan, komponen lapisan kegigihan dan komponen lapisan presentasi. Jadi untuk membedakan mereka, orang-orang musim semi telah memberikan tiga penjelasan lainnya juga.

• Untuk mewakili komponen lapisan kegigihan: @Repository
• Untuk mewakili komponen lapisan layanan: @Service
• Untuk mewakili komponen lapisan presentasi: @Controller
• atau Anda dapat menggunakannya @Componentuntuk semuanya.

Bahkan jika kita menukar @Component atau @Repository atau @service

Itu akan berperilaku sama, tetapi satu aspek adalah bahwa mereka tidak akan dapat menangkap beberapa pengecualian spesifik terkait dengan DAO daripada Repositori jika kita menggunakan komponen atau layanan @

Di Spring 4, versi terbaru:

Anotasi @Repository adalah penanda untuk setiap kelas yang memenuhi peran atau stereotip repositori (juga dikenal sebagai Obyek Akses Data atau DAO). Di antara penggunaan penanda ini adalah terjemahan otomatis pengecualian seperti yang dijelaskan dalam Bagian 20.2.2, “Terjemahan pengecualian”.

Spring menyediakan penjelasan stereotip lebih lanjut: @Component, @Service, dan @Controller. @Component adalah stereotip umum untuk komponen yang dikelola oleh Pegas. @Repository, @Service, dan @Controller adalah spesialisasi @Component untuk kasus penggunaan yang lebih spesifik, misalnya, masing-masing di lapisan persistensi, layanan, dan presentasi. Oleh karena itu, Anda dapat membuat anotasi kelas komponen Anda dengan @Component, tetapi dengan memberi anotasi dengan @Repository, @Service, atau @Controller sebagai gantinya, kelas Anda lebih cocok untuk diproses dengan alat atau bergaul dengan aspek. Misalnya, anotasi stereotip ini membuat target ideal untuk pemotongan titik. Dimungkinkan juga bahwa @Repository, @Service, dan @Controller dapat membawa semantik tambahan di rilis berikutnya dari Framework Spring. Jadi, jika Anda memilih antara menggunakan @Component atau @Service untuk lapisan layanan Anda, @Service jelas merupakan pilihan yang lebih baik. Demikian pula, seperti yang dinyatakan di atas, @Repository sudah didukung sebagai penanda untuk terjemahan pengecualian otomatis di lapisan kegigihan Anda.

@Component : Anda memberi anotasi pada sebuah kelas @Component, ia memberi tahu hibernate bahwa itu adalah sebuah Bean.

@Repositori : Anda memberi anotasi pada sebuah kelas @Repository, ia memberi tahu hibernate bahwa itu adalah kelas DAO dan memperlakukannya sebagai kelas DAO. Berarti itu membuat pengecualian yang tidak dicentang (dilempar dari metode DAO) memenuhi syarat untuk diterjemahkan ke dalam Musim Semi DataAccessException.

@ Layanan : Ini memberitahu hibernate itu adalah kelas Layanan di mana Anda akan memiliki @Transactionaldll anotasi lapisan Layanan sehingga hibernate memperlakukannya sebagai komponen Layanan.

Plus @Serviceadalah uang muka @Component. Asumsikan nama kelas kacang adalah CustomerService, karena Anda tidak memilih cara konfigurasi kacang XML sehingga Anda menjelaskan kacang dengan@Component menunjukkannya sebagai Kacang. Jadi saat mendapatkan objek bean CustomerService cust = (CustomerService)context.getBean("customerService");Secara default, Spring akan menurunkan huruf pertama karakter komponen - dari 'Layanan Pelanggan' hingga 'Layanan Pelanggan'. Dan Anda dapat mengambil komponen ini dengan nama 'layanan pelanggan'. Tetapi jika Anda menggunakan @Serviceanotasi untuk kelas kacang Anda bisa memberikan nama kacang tertentu dengan

@Service("AAA")
public class CustomerService{

dan Anda bisa mendapatkan objek bean dengan

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

@Component adalah anotasi umum tingkat atas yang membuat kacang beranotasi dipindai dan tersedia dalam wadah DI

@Repository adalah anotasi khusus dan fitur konversi semua pengecualian yang tidak dicentang dari kelas DAO

@Serviceadalah anotasi khusus. itu tidak membawa fitur baru seperti sekarang tetapi itu menjelaskan maksud kacang

@Controller adalah anotasi khusus yang membuat bean MVC sadar dan memungkinkan penggunaan anotasi lebih lanjut seperti @RequestMappingdan semua

Berikut ini rincian lebih lanjut

A @Servicemengutip dokumentasi musim semi,

Menunjukkan bahwa kelas beranotasi adalah "Layanan", awalnya didefinisikan oleh Domain-Driven Design (Evans, 2003) sebagai "operasi yang ditawarkan sebagai antarmuka yang berdiri sendiri dalam model, tanpa keadaan enkapsulasi." Mungkin juga menunjukkan bahwa kelas adalah "Fasad Layanan Bisnis" (dalam pengertian pola Core J2EE), atau yang serupa. Anotasi ini adalah stereotip tujuan umum dan tim individu dapat mempersempit semantik dan menggunakannya sebagaimana mestinya.

Jika Anda melihat desain yang digerakkan oleh domain oleh eric evans,

LAYANAN adalah operasi yang ditawarkan sebagai antarmuka yang berdiri sendiri dalam model, tanpa status enkapsulasi, seperti yang dilakukan ENTITIES dan VALUE OBJECTS. LAYANAN adalah pola umum dalam kerangka kerja teknis, tetapi mereka juga dapat berlaku di lapisan domain. Layanan nama menekankan hubungan dengan objek lain. Tidak seperti ENTITIES dan VALUE OBJECTS, itu didefinisikan murni dalam hal apa yang dapat dilakukan untuk klien. LAYANAN cenderung dinamai untuk suatu kegiatan, bukan suatu entitas — kata kerja dan bukan kata benda. LAYANAN masih dapat memiliki definisi abstrak dan disengaja; itu hanya memiliki rasa yang berbeda dari definisi suatu objek. LAYANAN harus tetap memiliki tanggung jawab yang ditentukan, dan tanggung jawab serta antarmuka yang memenuhinya harus didefinisikan sebagai bagian dari model domain. Nama-nama operasi harus berasal dari BAHASA YANG LUAR BIASA atau dimasukkan ke dalamnya. Parameter dan hasil harus berupa objek domain. LAYANAN harus digunakan dengan bijaksana dan tidak diizinkan untuk menghapus ENTITAS dan BENDA NILAI dari semua perilaku mereka. Tetapi ketika sebuah operasi sebenarnya merupakan konsep domain yang penting, SERVICE membentuk bagian alami dari MODEL-DRIVEN DESIGN. Dinyatakan dalam model sebagai LAYANAN, bukan sebagai objek palsu yang tidak benar-benar mewakili apa pun, operasi mandiri tidak akan menyesatkan siapa pun. LAYANAN membentuk bagian alami dari DESAIN MODEL-DRIVEN. Dinyatakan dalam model sebagai LAYANAN, bukan sebagai objek palsu yang tidak benar-benar mewakili apa pun, operasi mandiri tidak akan menyesatkan siapa pun. LAYANAN membentuk bagian alami dari DESAIN MODEL-DRIVEN. Dinyatakan dalam model sebagai LAYANAN, bukan sebagai objek palsu yang tidak benar-benar mewakili apa pun, operasi mandiri tidak akan menyesatkan siapa pun.

dan Repositorysesuai Eric Evans,

REPOSITORY mewakili semua objek dari jenis tertentu sebagai set konseptual (biasanya ditiru). Kerjanya seperti koleksi, kecuali dengan kemampuan query yang lebih rumit. Objek dengan tipe yang sesuai ditambahkan dan dihapus, dan mesin di belakang REPOSITORY memasukkannya atau menghapusnya dari database. Definisi ini mengumpulkan seperangkat tanggung jawab yang kohesif untuk menyediakan akses ke akar AGREGAT dari siklus kehidupan awal hingga akhir.

Di sini ada jawaban yang cukup baik untuk menjelaskan penjelasan whats-the-difference-between-repository-service-annotation. Saya ingin membagikan perbedaannya@Controller & @RestController

@Controller vs. RestController

@RestController:

• Anotasi ini adalah versi khusus @Controlleryang ditambahkan @Controllerdan @ResponseBodyanotasi secara otomatis. jadi kami tidak perlu menambahkan @ResponseBodymetode pemetaan kami. Itu berarti @ResponseBody default aktif.
• Jika Anda menggunakan, @RestControllerAnda tidak dapat mengembalikan tampilan (Dengan menggunakan Viewresolverdi Spring / Spring-Boot)
• @RestControllerjuga mengubah respons JSON/XML automaticallysebagai @ResponseBodymembuat objek yang dikembalikan ke sesuatu yang bisa di dalam tubuh,e.g. JSON or XML

@Controller

• @Controllerdigunakan untuk menandai kelas sebagai Spring MVC Controller. Anotasi ini hanya versi khusus @Componentdan memungkinkan kelas pengontrol dideteksi secara otomatis berdasarkan pemindaian classpath.
• @Controller Anda dapat mengembalikan tampilan di MVC web Spring.

Tampilan Lebih Detail

Repositori dan Layanan adalah anak-anak anotasi Komponen . Jadi, semuanya adalah Komponen . Repositori dan Layanan hanya perluas saja. Bagaimana sebenarnya? Layanan hanya memiliki perbedaan ideologis: kami menggunakannya untuk layanan. Repositori memiliki handler pengecualian khusus.

Penjelasan stereotip:

• @Service- Beri catatan semua kelas layanan Anda dengan @Service. Lapisan ini tahu satuan kerja. Semua logika bisnis Anda akan berada di kelas Layanan. Secara umum metode lapisan layanan dicakup dalam transaksi. Anda dapat membuat beberapa panggilan DAO dari metode layanan, jika satu transaksi gagal, semua transaksi harus dikembalikan.
• @Repository- Buat anotasi semua kelas DAO Anda dengan @Repository. Semua logika akses database Anda harus dalam kelas DAO.
• @Component - Buat anotasi komponen Anda yang lain (misalnya kelas sumber daya REST) ​​dengan stereotip komponen.
• @Autowired - Biarkan Spring auto-wire kacang lain ke dalam kelas Anda menggunakan penjelasan @Autowired.

@Componentadalah stereotip umum untuk komponen apa pun yang dikelola oleh Pegas. @Repository,, @Servicedan @Controllermerupakan spesialisasi dari@Component untuk kasus penggunaan yang lebih spesifik, misalnya, di lapisan persistensi, layanan, dan presentasi, masing-masing.

Awalnya dijawab di sini .

Perbedaan antara @Component, @Repository, @Controller & @Service annotations

@Component - generik dan dapat digunakan di seluruh aplikasi.
@Service - membubuhi keterangan kelas di tingkat lapisan layanan.
@Controller - membubuhi keterangan kelas di tingkat lapisan presentasi, terutama digunakan dalam Spring MVC.
@Repository - membubuhi keterangan kelas pada layer persistence, yang akan bertindak sebagai repositori basis data.

@Controller= @Komponen (Anotasi Internal) + Fitur-fitur lapisan Presentasi
@Service= @Komponen (Anotasi Internal) + Fitur-fitur lapisan Layanan
@Component= Komponen Aktual (Kacang)
@Repository= @Komponen (Anotasi Internal) + Fitur Lapisan Data (digunakan untuk menangani Domain Beans)

Dalam kerangka kerja pegas menyediakan beberapa jenis penjelasan khusus, yang disebut penjelasan stereotip. Ini adalah sebagai berikut: -

@RestController- Declare at controller level.
@Controller – Declare at controller level.
@Component – Declare at Bean/entity level.
@Repository – Declare at DAO level.
@Service – Declare at BO level.

penjelasan yang dinyatakan di atas adalah spesial karena ketika kita menambahkan <context:component-scan>ke file xxx-servlet.xml, spring akan secara otomatis membuat objek kelas-kelas yang dijelaskan dengan penjelasan di atas selama pembuatan konteks / fase pemuatan.

@Component, @ Repository, @ Service, @Controller:

@Componentadalah stereotip umum untuk komponen yang dikelola oleh musim semi @Repository, @Servicedan @Controlleryang @Componentspesialisasi untuk menggunakan lebih spesifik:

• @Repository untuk kegigihan
• @Service untuk layanan dan transaksi
• @Controller untuk pengontrol MVC

Mengapa menggunakan @Repository, @Service, @Controllerlebih@Component ? Kita dapat menandai kelas komponen kita dengan @Component, tetapi jika sebaliknya kita menggunakan alternatif yang menyesuaikan dengan fungsionalitas yang diharapkan. Kelas kami lebih cocok dengan fungsi yang diharapkan dalam setiap kasus tertentu.

Kelas yang diberi penjelasan dengan @Repositorymemiliki terjemahan yang lebih baik dan penanganan kesalahan yang dapat dibaca dengan org.springframework.dao.DataAccessException. Ideal untuk menerapkan komponen yang mengakses data (DataAccessObject atau DAO).

Kelas beranotasi dengan @Controllermemainkan peran pengontrol dalam aplikasi Spring Web MVC

Kelas beranotasi dengan @Servicememainkan peran dalam layanan logika bisnis, misalnya pola Fasad untuk Manajer DAO (Fasad) dan penanganan transaksi

Jawaban yang disajikan di sini sebagian besar benar secara teknis, tetapi meskipun daftar tanggapannya panjang dan ini akan ada di bagian bawah, saya pikir layak untuk menempatkan tanggapan yang benar-benar benar di sini juga, kalau-kalau ada orang yang menemukannya dan belajar sesuatu yang berharga dari Itu. Bukan karena sisa jawaban itu salah, hanya saja mereka tidak benar. Dan, untuk menghentikan gerombolan troll, ya, saya tahu bahwa secara teknis penjelasan ini adalah hal yang sama dan paling dapat dipertukarkan bahkan hingga musim semi 5. Sekarang, untuk jawaban yang tepat:

Ketiga penjelasan ini adalah hal yang sangat berbeda dan tidak dapat dipertukarkan. Anda bisa mengatakannya karena ada tiga, bukan hanya satu. Mereka tidak dimaksudkan untuk dipertukarkan, mereka hanya dilaksanakan dengan cara yang elegan dan nyaman.

Pemrograman modern adalah penemuan, seni, teknik, dan komunikasi, dalam proporsi yang berbeda-beda. Bit komunikasi biasanya sangat penting karena kode biasanya dibaca lebih sering daripada yang tertulis. Sebagai seorang programmer Anda tidak hanya mencoba untuk memecahkan masalah teknis, Anda juga mencoba untuk mengomunikasikan niat Anda kepada programmer masa depan yang membaca kode Anda. Pemrogram ini mungkin tidak membagikan bahasa asli Anda, atau lingkungan sosial Anda, dan ada kemungkinan bahwa mereka mungkin membaca kode Anda 50-tahun di masa depan (itu tidak mungkin seperti yang Anda bayangkan). Sulit untuk berkomunikasi secara efektif sejauh itu di masa depan. Karena itu, sangat penting bagi kita untuk menggunakan bahasa yang paling jelas, paling efisien, benar, dan komunikatif yang tersedia bagi kita.

Sebagai contoh, sangat penting untuk @Repositorydigunakan ketika kita sedang menulis repositori, bukan @Component. Yang terakhir adalah pilihan anotasi untuk repositori yang sangat buruk karena tidak mengindikasikan bahwa kita sedang melihat repositori. Kita dapat mengasumsikan bahwa repositori juga merupakan spring-bean, tetapi tidak berarti bahwa suatu komponen adalah repositori. Dengan @Repositorykami menjadi jelas dan spesifik dalam bahasa kami. Kami menyatakan dengan jelas bahwa ini adalah repositori. Dengan@Componentkami menyerahkannya kepada pembaca untuk memutuskan jenis komponen apa yang mereka baca, dan mereka harus membaca seluruh kelas (dan mungkin pohon subkelas dan antarmuka) untuk menyimpulkan makna. Kelas kemudian dapat disalahartikan oleh pembaca di masa depan yang jauh sebagai bukan repositori, dan kami akan bertanggung jawab atas kesalahan ini karena kami, yang tahu betul bahwa ini adalah repositori, gagal untuk lebih spesifik dalam bahasa kami. dan mengomunikasikan maksud kami secara efektif.

Saya tidak akan membahas contoh-contoh lain, tetapi akan menyatakan sejelas mungkin: penjelasan ini adalah hal yang sangat berbeda dan harus digunakan dengan tepat, sesuai dengan niat mereka. @Repositoryadalah untuk penyimpanan repositori dan tidak ada penjelasan lain yang benar. @Serviceuntuk layanan dan tidak ada penjelasan lain yang benar. @Componentadalah untuk komponen yang bukan repostories atau layanan, dan menggunakan salah satu dari ini di tempatnya juga akan salah. Mungkin dikompilasi, bahkan mungkin berjalan dan lulus tes Anda, tetapi itu akan salah dan saya akan kurang memikirkan Anda (secara profesional) jika Anda melakukan ini.

Ada contoh ini sepanjang musim semi (dan pemrograman pada umumnya). Anda tidak boleh menggunakan @Controllersaat menulis API REST, karena @RestControllertersedia. Anda tidak boleh menggunakan @RequestMappingkapan @GetMappingalternatif yang valid. Dll. Dll. Anda harus memilih bahasa yang tepat dan benar yang paling spesifik untuk mengomunikasikan maksud Anda kepada pembaca Anda, jika tidak, Anda memasukkan risiko ke dalam sistem Anda, dan risiko memiliki biaya.

Untuk menyederhanakan ilustrasi ini, mari kita pertimbangkan teknis dengan use case, Anotasi ini digunakan untuk disuntikkan dan seperti yang saya katakan secara harfiah " Dulu disuntikkan ", itu berarti, jika Anda tahu cara menggunakan Dependency Injection "DI" dan Anda seharusnya, maka Anda akan selalu mencari anotasi ini, dan dengan memberi anotasi pada kelas dengan Jenis Stereo ini , Anda memberi tahu wadah DI untuk memindai mereka agar siap untuk Injeksi di tempat lain, ini adalah target praktis.

Sekarang mari kita pindah ke masing-masing; pertama @Service , Jika Anda sedang membangun beberapa logika untuk kasus bisnis yang spesifik Anda perlu untuk memisahkan yang di tempat yang akan berisi logika bisnis Anda, layanan ini normal Kelas atau Anda dapat menggunakannya sebagai antarmuka jika Anda ingin, dan ditulis seperti ini

@Service
public class Doer {
   // Your logic 
}

// To use it in another class, suppose in Controller 
@Controller
public class XController {
 // You have to inject it like this 
 @Autowired 
 private Doer doer;
}

Semua adalah cara yang sama ketika Anda menyuntikkan mereka, @Repository itu adalah antarmuka yang menerapkan implementasi untuk pola desain Repositori Pola Repositori , umumnya digunakan ketika Anda berurusan dengan beberapa penyimpanan data atau database, dan Anda akan menemukan bahwa, itu berisi beberapa implementasi siap bagi Anda untuk menangani operasi basis data; dapat berupa CrudRepository , JpaRepository dll.

// For example
public interface DoerRepository implements JpaRepository<Long, XEntity> {}

Akhirnya @Component , ini adalah bentuk umum untuk kacang yang terdaftar di Musim Semi, musim semi itu selalu mencari kacang yang ditandai dengan @Component untuk didaftarkan, kemudian @Service dan @Repository adalah kasus khusus @Component, namun kasus penggunaan umum untuk komponen adalah ketika Anda membuat sesuatu yang murni teknis bukan untuk menutupi kasus bisnis langsung! seperti memformat tanggal atau menyerahkan mekanisme serialisasi permintaan khusus dan sebagainya.

@Component bertindak sebagai anotasi @Bean di kelas konfigurasi, register bean dalam konteks musim semi. Juga merupakan induk untuk penjelasan @Service, @Repository, dan @Controller.

@Service , memperluas anotasi @Component dan hanya memiliki perbedaan penamaan.

@Repository - memperluas anotasi @Component dan menerjemahkan semua pengecualian basis data ke dalam DataAccessException .

@Controller - bertindak sebagai pengontrol dalam pola MVC. Dispatcher akan memindai kelas beranotasi tersebut untuk metode yang dipetakan, mendeteksi anotasi @RequestMapping.

@Component
@Controller
@Repository
@Service
@RestController

Ini semua adalah anotasi StereoType. Ini berguna untuk membuat kelas kita sebagai spring bean dalam wadah ioc,