Can @Component, @Repositoryve @Serviceek açıklamalar ilkbaharda birbirinin yerine kullanılabilir veya bir gösterim aygıtı olarak hareket yanı sıra herhangi bir işlevsellik sağlar?

Başka bir deyişle, bir Service sınıfım varsa ve ek açıklamayı olarak @Servicedeğiştirirsem @Component, yine de aynı şekilde davranır mı?

Veya ek açıklama, sınıfın davranışını ve işlevselliğini de etkiler mi?

itibaren Bahar Belgeler :

@RepositoryEk açıklama (ayrıca veri erişim nesnesi veya DAO olarak da bilinir) bir depo rolü veya klişe yerine getirir herhangi bir sınıf için bir belirleyicidir. Bu işaretçinin kullanımları arasında, İstisna Tercümesi'nde açıklandığı gibi istisnaların otomatik çevirisi yer alır .

Yay ayrıca basmakalıp bir belirteç sağlar: @Component, @Serviceve @Controller. @Componentherhangi bir Spring tarafından yönetilen bileşen için genel bir klişedir. @Repository, @Serviceve daha özel kullanım durumları için @Controlleruzmanlık alanlarıdır @Component(sırasıyla kalıcılık, hizmet ve sunum katmanlarında). Bu nedenle, bileşen sınıflarınıza ek açıklama ekleyebilirsiniz @Component, ancak bunlara ek açıklama ekleyerek @Repository,@Service ya @Controller bunun yerine, dersleriniz daha düzgün araçları tarafından işlenmesi veya yönleriyle ilişkilendirerek için uygundur.

Örneğin, bu stereotip ek açıklamalar nokta kesimleri için ideal hedefler yapar. @Repository, @Serviceve @Controllerayrıca Spring Framework'ün gelecek sürümlerinde ek anlambilim taşıyabilir. Bu nedenle, hizmet katmanınızı kullanma @Componentveya kullanma arasında seçim yapıyorsanız , açıkça daha iyi bir seçimdir. Benzer şekilde, daha önce belirtildiği gibi, kalıcılık katmanınızdaki otomatik istisna çevirisi için bir işaretçi olarak zaten desteklenmektedir.@Service@Service@Repository

┌──────────────┬─────────────────────────────────────────────────────┐
│ 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)      │
└──────────────┴─────────────────────────────────────────────────────┘

Cevapların çoğu zaten bu ek açıklamaların ne için kullanıldığını belirttiğinden, burada aralarındaki bazı küçük farklılıklara odaklanacağız.

Önce Benzerlik

Tekrar vurgulamaya değer ilk nokta , BeanDefinition için tarama-otomatik algılama ve bağımlılık enjeksiyonu ile ilgili olarak tüm bu ek açıklamaların (viz., @Component, @Service, @Repository, @Controller) aynı olmasıdır. Birini diğerinin yerine kullanabiliriz ve yine de yolumuza devam edebiliriz.

@Component, @Repository, @Controller ve @Service arasındaki farklar

@Bileşen

Bu, sınıfın bir yay bileşeni olduğunu gösteren genel amaçlı bir stereotip ek açıklamadır.

@Component ne özelliği var
<context:component-scan> sadece tarar@Componentve aramaz@Controller,@Serviceve@Repositorygenel olarak. Taranırlar çünkü kendilerine açıklama eklenirler@Component.

Sadece bir bakmaktır @Controller, @Serviceve @Repositoryaçıklama tanımları:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Böylece, söylemek yanlış değil @Controller, @Serviceve @Repositoryözel türleri vardır @Componentaçıklama. <context:component-scan>Onları alır ve izledikleri gibi aşağıdaki sınıflarını fasulye olarak kaydeder @Component.

Özel tür ek açıklamaları da taranır, çünkü kendileri ek açıklama ile @Componentek açıklama eklenir, bu da aynı zamanda @Components oldukları anlamına gelir . Kendi özel ek açıklamamızı tanımlar ve ek açıklama @Componenteklersek,<context:component-scan>

@Repository

Bu, sınıfın bir veri havuzu tanımladığını gösterir.

@Repository hakkında özel olan nedir?

Bunun, Ek Açıklama tabanlı bir Yapılandırma olduğunu belirtmenin yanı sıra , @Repositoryişi platforma özel istisnaları yakalamak ve bunları Spring'in birleştirilmiş kontrolsüz istisnasından biri olarak yeniden atmaktır. Bunun için, PersistenceExceptionTranslationPostProcessorBahar uygulamamızın uygulama bağlamına şöyle eklememiz gerekiyor:

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

Bu fasulye sonrası işlemcisi, açıklamalı herhangi bir çekirdeğe bir danışman ekler, @Repositoryböylece platforma özgü istisnalar yakalanır ve daha sonra Spring'in kontrol edilmemiş veri erişimi istisnalarından biri olarak yeniden atılır.

@Controller

@ControllerAçıklama özel bir sınıf bir kontrol görevi görür göstermektedir. @ControllerAçıklama rolünü gösteren açıklamalı sınıf için bir klişe olarak hareket eder.

@Controller hakkında özel olan nedir?

Bu ek açıklamayı , aynı görünseler bile @Serviceveya benzeri herhangi bir şeyle değiştiremeyiz @Repository. Dağıtıcı, açıklamalı sınıfları tarar ve açıklamalı açıklamalı açıklamaları @Controllertespit eder @RequestMapping. Biz kullanabilirsiniz @RequestMappingkimin sınıflar not eklenmiş sadece bu yöntemlerde / üzerinde @Controllerve onu edecektir DEĞİL çalışmak @Component, @Service, @Repositoryvs ...

_{Not: Bir sınıf zaten aracılığıyla gibi, herhangi bir alternatif yöntemle bir fasulye olarak kayıtlıysa @Beanveya içinden @Component, @Servicevb ... ek açıklamalar, daha sonra @RequestMappingsınıfı da ek not ise alınabilir @RequestMappingaçıklama. Ama bu farklı bir senaryo.}

@Hizmet

@Service çekirdekleri iş mantığını ve çağrı yöntemlerini depo katmanında tutar.

@Service hakkında özel olan nedir?

İş mantığına sahip olduğunu belirtmek için kullanıldığı gerçeğinin yanı sıra, bu ek açıklamada fark edilebilir başka bir şey yoktur; ama kim bilir, Bahar gelecekte ek istisnalar ekleyebilir.

Başka?

Yukarıda olduğu gibi, gelecekte Bahar için özel işlevleri ekleyebilir @Service, @Controllerve @Repositorybunların katman anlaşmalar esas. Bu nedenle, sözleşmeye saygı göstermek ve katmanlarla uyumlu olarak kullanmak her zaman iyi bir fikirdir.

Neredeyse aynılar - hepsi sınıfın bir Bahar fasulyesi olduğu anlamına geliyor. @Service, @Repositoryve @Controlleruzmanlaşmış @Components. Onlarla belirli eylemler gerçekleştirmeyi seçebilirsiniz. Örneğin:

• @Controller fasulye spring-mvc tarafından kullanılır
• @Repository fasulye kalıcılık istisna çevirisi için uygundur

Başka bir şey, bileşenleri semantik olarak farklı katmanlara atamanızdır.

Sunulan bir şey, @Componentdiğer ek açıklamalara ek açıklama ekleyebileceğiniz ve daha sonra bunları aynı şekilde kullanabilmenizdir @Service.

Örneğin son zamanlarda yaptım:

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

Böylece açıklamalı tüm sınıflar @ScheduledJobbahar fasulyesidir ve buna ek olarak kuvars işleri olarak kayıtlıdır. Sadece belirli ek açıklamayı işleyen bir kod sağlamanız gerekir.

@Component şuna eşdeğerdir:

<bean>

@Service, @Controller, @Repository = {@Component + daha özel işlevler}

Yani Hizmet, Denetleyici ve Depo işlevsel olarak aynıdır.

Üç ek açıklama uygulamanızdaki "Katmanları" ayırmak için kullanılır,

• Kontrolörler sadece gönderme, yönlendirme, servis yöntemlerini arama vb.
• Service Hold iş Mantığı, Hesaplamalar vb.
• Havuz DAO'lardır (Veri Erişim Nesneleri), veritabanına doğrudan erişirler.

Şimdi bunları neden ayırdığınızı sorabilirsiniz: (AOP-Unsur Odaklı Programlamayı bildiğinizi varsayıyorum)

Diyelim ki yalnızca DAO Katmanının Etkinliğini İzlemek istiyorsunuz. DAO'nuzun her yöntemi çağrılmadan önce ve sonra bazı günlüğe kaydetme yapan bir Aspect (A sınıfı) sınıfı yazacaksınız, bunu üç farklı Katmanınız olduğu ve karma olmadığından AOP kullanarak yapabilirsiniz.

Böylece DAO'nun günlük kaydını DAO yöntemlerini "etrafında", "önce" veya "sonra" yapabilirsiniz. Bunu yapabilirsiniz çünkü ilk etapta bir DAO'nuz vardı. Az önce başardığın şey , endişelerin veya görevlerin ayrılmasıdır.

Sadece bir ek açıklama @Controller varsa, o zaman bu bileşen gönderme, iş mantığı ve tüm karışık, çok kirli kod erişim veritabanına sahip olacak!

Yukarıda belirtilen çok yaygın bir senaryo, neden üç ek açıklama kullanıldığına dair çok daha fazla kullanım durumu var.

İlkbahar @Component, @Service, @Controllerve @Repositorystereotip ek açıklama için kullanılan olan:

@Controller:senin nerede isteği sunum sayfasından haritalama katmanı başka bir dosyaya gitmeyecek yani Sunumu yapılan bu doğrudan gider @Controllerolarak talep yolu için sınıf ve çekler@RequestMapping gerekirse yöntem çağrılmadan önce yazılı açıklama.

@Service: Tüm iş mantığı burada Verilerle ilgili hesaplamalar ve hepsi buradadır.Kullanıcımızın kalıcılık yöntemini doğrudan çağırmadığı iş katmanının bu ek açıklaması, bu ek açıklamayı kullanarak bu yöntemi çağıracaktır. Kullanıcı isteğine göre @Repository isteyecektir

@Repository: Bu, veritabanından veri almak için kullanılan uygulamanın Kalıcılık katmanıdır (Veri Erişim Katmanı). yani Veritabanıyla ilgili tüm işlemler depo tarafından yapılır.

@Component - Diğer bileşenlerinize (örneğin, REST kaynak sınıfları) bileşen stereotipiyle açıklama ekleyin.

Açıklamalı bir sınıfın " bileşen " olduğunu belirtir . Bu sınıflar ek açıklama tabanlı yapılandırma ve sınıf yolu taraması kullanılırken otomatik algılama adayları olarak kabul edilir.

Diğer sınıf düzeyi ek açıklamaların bir bileşeni, tipik olarak özel bir tür bileşeni tanımlaması olarak düşünülebilir: örn. @Repository ek açıklaması veya AspectJ'nin @Aspect ek açıklaması.

Spring 2.5, diğer stereotip ek açıklamalarını sunar: @Component, @Service ve @Controller. @Bileşen, Spring tarafından yönetilen herhangi bir bileşen için genel bir klişe işlevi görür; oysa @Repository, @Service ve @Controller, daha spesifik kullanım durumları için (örneğin, kalıcılık, hizmet ve sunum katmanlarında) @Component uzmanlığı olarak hizmet eder. Bunun anlamı, bileşen sınıflarınıza @Component ile açıklama ekleyebilmenizdir, ancak bunun yerine @Repository, @Service veya @Controller ile açıklama ekleyerek sınıflarınız, araçlarla işlemek veya yönlerle ilişkilendirmek için daha uygundur. Örneğin, bu stereotip ek açıklamalar nokta kesimleri için ideal hedefler yapar. Tabii ki, @Repository, @Service ve @Controller'ın Spring Framework'ün gelecekteki sürümlerinde ek anlambilimi taşımaları da mümkündür. Böylece, hizmet katmanınız için @Component veya @Service kullanma arasında bir karar veriyorsanız, @Service açıkça daha iyi bir seçimdir. Benzer şekilde, yukarıda belirtildiği gibi, @Repository, kalıcılık katmanınızdaki otomatik özel durum çevirisi için zaten bir işaretleyici olarak desteklenmektedir.

@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.

başvuru: - Bahar Belgeleri - Java kullanarak sınıf yolu taraması, yönetilen bileşenler ve yazma yapılandırmaları

Teknik olarak @Controller, @Service, @Repositoryhepsi aynı. Hepsi uzanıyor @Component.

Bahar kaynak kodundan:

Açıklamalı bir sınıfın "bileşen" olduğunu belirtir. Bu sınıflar ek açıklama tabanlı yapılandırma ve sınıf yolu taraması kullanılırken otomatik algılama adayları olarak kabul edilir.

Biz doğrudan kullanabilir @Componentbüyük uygulamasının daha iyi anlaşılması ve Düzeltilebilirlik için değil, her fasülye, kullandığımız @Controller, @Service,@Repository .

Her ek açıklamanın amacı:

1. @Controller-> Buna açıklamalı sınıflar, müşteri tarafından bir istek almayı amaçlamaktadır. İlk istek, Dispatcher Servlet'e gelir; buradan isteği, belirli bir denetleyiciye@RequestMapping ek açıklama .
2. @Service-> Açıklamalı sınıflar, istemciden aldığımız veya veritabanından aldığımız verileri işlemek için tasarlanmıştır. Verilerle tüm manipülasyonlar bu katmanda yapılmalıdır.
3. @Repository-> Buna açıklamalı sınıflar, veritabanına bağlanmak için tasarlanmıştır. DAO (Veri Erişim Nesnesi) katmanı olarak da düşünülebilir. Bu katman yalnızca CRUD (oluşturma, alma, güncelleme, silme) işlemleriyle sınırlandırılmalıdır. Herhangi bir manipülasyon gerekiyorsa, veriler @Service katmanına geri gönderilmek üzere gönderilmelidir.

Biz (kullanım yerlerini kavşak durumunda @Repositoryyerine @Controller), bizim uygulama cezası çalışacaktır.

Üç farklı kullanmanın temel amacı @annotations, Enterprise uygulamasına daha iyi Modülerlik sağlamaktır.

Veritabanı bağlantısı açısından kullanımı @Serviceve @Repositoryek açıklamalar önemlidir.

1. Kullanım @ServiceDB bağlantılarının tüm web hizmeti türü için
2. @RepositoryKayıtlı tüm proc DB bağlantılarınız için kullanın

Doğru ek açıklamaları kullanmazsanız, geri alma işlemleriyle geçersiz kılınan kesinleştirme istisnalarıyla karşılaşabilirsiniz. Gerilme yükü testi sırasında JDBC işlemlerini geri alma ile ilgili istisnalar göreceksiniz.

@Repository @Service ve @Controller , @Component için daha özel bir kullanım için @Component uzmanlığı olarak hizmet vermektedir; @ Service'i @Component olarak değiştirebilirsiniz ancak bu durumda uzmanlığı kaybedersiniz.

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.

tüm bu ek açıklamalar stereo tipte ek açıklama türüdür, bu üç ek açıklama arasındaki fark

• @Component öğesini eklersek, sınıfın rolünün bir bileşen sınıfı olduğunu söyler, bunun bazı mantık içeren bir sınıf olduğu anlamına gelir, ancak belirli bir iş veya kalıcılık veya denetleyici mantığı içeren bir sınıfın kullanılıp kullanılmadığını söylemez. doğrudan bu @Bileşen ek açıklaması
• @Service ek açıklaması eklersek, sınıfın iş mantığından oluşan bir rol olduğunu söyler
• Sınıfın üstüne @Repository eklersek, kalıcılık mantığından oluşan bir sınıfın
• @Component, @ Service, @ Repository ve @Controller ek açıklamaları için temel ek açıklamadır

Örneğin

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
    }
}

• her ne zaman biz ekler @Serviceveya@Repositroy ya @Controllervarsayılan tarafından ek açıklama @Componentaçıklama sınıfının üstünde varlığı gidiyor

Yay, bunlar otomatik bileşen tarama ek açıklama dört farklı sağlar @Component, @Service, @Repositoryve@Controller . Teknik olarak, aralarında hiçbir fark yoktur, ancak her otomatik bileşen tarama ek açıklaması özel bir amaç için ve tanımlanan katman içinde kullanılmalıdır.

@Component: Temel bir otomatik bileşen tarama notudur, açıklamalı sınıfın bir otomatik tarama bileşeni olduğunu gösterir.

@Controller: Açıklamalı sınıf, bir denetleyici bileşeni olduğunu ve çoğunlukla sunum katmanında kullanıldığını gösterir.

@Service: Ek açıklamalı sınıfın iş katmanındaki bir Hizmet bileşeni olduğunu gösterir.

@Repository: Bu ek açıklamayı kalıcılık katmanı içinde kullanmanız gerekir, bu veritabanı deposu gibi davranır.

@ComponentBu açıklama, ileride belirli davranışlar içerebileceğinden, sınıflarına açıklama eklerken daha özel bir biçim seçilmelidir .

Java standardına göre cevap verebiliriz

Şimdi JSR-330bahar tarafından desteklenen, sadece @Namedbir fasulye tanımlamak için kullanabilirsiniz (Her nasılsa @Named=@Component). Bu standarda göre Yani, (gibi klişeleri tanımlamak için hiçbir faydası olmadığını görünüyor @Repository, @Service, @Controller) kategoriler fasulye.

Ancak bahar kullanıcısı bu farklı ek açıklamaları belirli kullanım için farklıdır, örneğin:

1. Geliştiricilerin uzmanlar için daha iyi bir kategori tanımlamasına yardımcı olun. Bu kategorileştirme bazı durumlarda yardımcı olabilir. (Örneğin, kullandığınız zaman aspect-orientedbunlar için iyi bir aday olabilir pointcuts)
2. @Repository ek açıklama çekirdeğinize bazı işlevler ekler (fasulye kalıcılığı katmanınıza bazı otomatik istisna çevirisi).
3. Spring MVC kullanıyorsanız @RequestMapping, yalnızca ek açıklama eklenmiş sınıflara eklenebilir @Controller.

@Component ile diğer bileşenlere açıklama ekleyin, örneğin REST Resource sınıfları.

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

@Component, herhangi bir Spring tarafından yönetilen bileşen için genel bir klişedir.

@Controller, @Service ve @Repository, belirli kullanım durumları için @Component'in Uzmanlık Alanlarıdır.

İlkbaharda Bileşen

Arasında hiçbir fark yoktur @Component, @Service, @Controller, @Repository. @ComponentMVC'mizin bileşenini temsil eden Genel ek açıklamadır. Ancak MVC uygulamamızın bir parçası olarak servis katmanı bileşenleri, kalıcı katman bileşenleri ve sunum katmanı bileşenleri gibi çeşitli bileşenler olacaktır. Bu yüzden onları ayırt etmek için Bahar insanları diğer üç ek açıklamayı da verdiler.

• Kalıcı katman bileşenlerini temsil etmek için: @Repository
• Hizmet katmanı bileşenlerini temsil etmek için: @Service
• Sunum katmanı bileşenlerini temsil etmek için: @Controller
• yoksa @Componenthepsi için kullanabilirsiniz .

@Component veya @Repository veya @service'i değiştirsek bile

Aynı şekilde davranacak, ancak bir unsur, bileşen veya @ hizmet kullanırsak, Depo yerine DAO ile ilgili belirli bir istisnayı yakalayamayacaklarıdır.

Spring 4'te en son sürüm:

@Repository ek açıklaması, bir havuzun rolünü veya stereotipini (Veri Erişim Nesnesi veya DAO olarak da bilinir) yerine getiren herhangi bir sınıf için bir işaretleyicidir. Bu işaretçinin kullanımları arasında Bölüm 20.2.2, “İstisna çevirisi” bölümünde açıklanan istisnaların otomatik çevirisi yer almaktadır.

Spring daha fazla klişe ek açıklama sağlar: @Component, @Service ve @Controller. @Component, herhangi bir Spring tarafından yönetilen bileşen için genel bir klişedir. @Repository, @Service ve @Controller, örneğin kalıcılık, hizmet ve sunum katmanlarında olmak üzere daha özel kullanım durumları için @Component uzmanlık alanlarıdır. Bu nedenle, bileşen sınıflarınıza @Component ile açıklama ekleyebilirsiniz, ancak bunun yerine @Repository, @Service veya @Controller ile açıklama ekleyerek sınıflarınız araçlarla işlemek veya yönlerle ilişkilendirmek için daha uygun olur. Örneğin, bu stereotip ek açıklamalar nokta kesimleri için ideal hedefler yapar. @Repository, @Service ve @Controller'ın Spring Framework'ün gelecekteki sürümlerinde ek anlambilimi taşımaları da mümkündür. Böylece, hizmet katmanınız için @Component veya @Service kullanmayı tercih ediyorsanız, @Service açıkça daha iyi bir seçimdir. Benzer şekilde, yukarıda belirtildiği gibi, @Repository, kalıcılık katmanınızdaki otomatik özel durum çevirisi için zaten bir işaretleyici olarak desteklenmektedir.

@Bileşen : bir sınıfa açıklama eklersiniz@Component , hazırda bekletme moduna bir Bean olduğunu söyler.

@ Repository : bir sınıfa açıklama eklersiniz@Repository , hazırda bekletme moduna bir DAO sınıfı olduğunu söyler ve DAO sınıfı olarak davranır. İşaretlenmemiş istisnaları (DAO yöntemlerinden atılan), Bahar'a çeviri için uygun hale getirir DataAccessException.

@Service : Bu, hazırda bekletme moduna, @Transactionalvb. Sahip olacağınız bir Hizmet sınıfı olduğunu belirtir .

Artı @Serviceileridir @Component. Fasulye sınıfı adının olduğunu varsayalım CustomerService, çünkü XML fasulyesi yapılandırma yolunu seçmediniz, böylece fasulyeyi Fasulye @Componentolarak belirtmek için açıklama eklediniz. Fasulye nesnesini alırken CustomerService cust = (CustomerService)context.getBean("customerService");, Spring varsayılan olarak, bileşenin ilk karakterini küçük harflerle gösterecektir - 'CustomerService'den' customerService'e. Ve bu bileşeni 'customerService' adıyla alabilirsiniz. Ancak @Service, fasulye sınıfı için ek açıklama kullanırsanız, belirli bir fasulye adı

@Service("AAA")
public class CustomerService{

ve fasulye nesnesini

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

@Component açıklamalı fasulyenin taranmasını ve DI kabında bulunmasını sağlayan en üst düzey genel açıklamadır

@Repository özel bir açıklamadır ve DAO sınıflarındaki tüm kontrolsüz istisnaları dönüştürme özelliğini getirir

@Serviceözel açıklamadır. şu andan itibaren yeni bir özellik getirmiyor, ancak çekirdeğin niyetini netleştiriyor

@ Kontrolör, fasulyenin MVC'sini bilinçli hale getiren ve daha fazla ek açıklama kullanılmasına izin veren özel ek açıklamadır. @RequestMapping ve tüm bu

İşte daha fazla ayrıntı

A @Servicebahar belgelerini teklif etmek,

Açıklamalı bir sınıfın, ilk olarak Etki Alanına Dayalı Tasarım (Evans, 2003) tarafından "kapsüllenmiş durumu olmayan modelde tek başına duran bir arabirim olarak sunulan bir işlem" olarak tanımlanan bir "Hizmet" olduğunu belirtir . Ayrıca, bir sınıfın "İş Hizmet Cephesi" (Core J2EE kalıpları anlamında) veya benzer bir şey olduğunu da gösterebilir. Bu açıklama genel amaçlı bir stereotiptir ve bireysel ekipler anlambilimlerini daraltabilir ve uygun şekilde kullanabilirler.

Eric Evans tarafından etki alanına dayalı tasarıma bakarsanız,

HİZMET, ENTITIES ve VALUE OBJECTS gibi, kapsülleme durumu olmadan modelde tek başına duran bir arayüz olarak sunulan bir işlemdir. HİZMETLER, teknik çerçevelerde yaygın bir örüntüdür, ancak etki alanı katmanında da uygulanabilir. Ad hizmeti diğer nesnelerle olan ilişkiyi vurgular. ENTITIES ve VALUE OBJECTS'ten farklı olarak, tamamen bir müşteri için yapabilecekleri açısından tanımlanır. HİZMET, bir varlıktan ziyade bir faaliyet için adlandırılır - bir isimden ziyade bir fiil. Bir HİZMET'in hala soyut, kasıtlı bir tanımı olabilir; sadece bir nesnenin tanımından farklı bir tada sahiptir. HİZMET hala tanımlanmış bir sorumluluğa sahip olmalı ve bu sorumluluk ve onu yerine getiren arayüz alan modelinin bir parçası olarak tanımlanmalıdır. İşlem isimleri YERLİ DİLDEN gelmeli veya içine yazılmalıdır. Parametreler ve sonuçlar etki alanı nesneleri olmalıdır. HİZMETLER, makul bir şekilde kullanılmalı ve tüm davranışlarının ENTITIES ve VALUE OBJECTS'inin soyulmasına izin verilmemelidir. Ancak bir işlem aslında önemli bir etki alanı kavramı olduğunda, HİZMET MODEL-SÜRÜCÜ TASARIMIN doğal bir parçasını oluşturur. Modelde, aslında hiçbir şeyi temsil etmeyen sahte bir nesne yerine bir HİZMET olarak ilan edilen bağımsız işlem kimseyi yanıltmayacaktır. HİZMET, MODEL TAHRİKLİ TASARIMIN doğal bir parçasını oluşturur. Modelde, aslında hiçbir şeyi temsil etmeyen sahte bir nesne yerine bir HİZMET olarak ilan edilen bağımsız işlem kimseyi yanıltmayacaktır. HİZMET, MODEL TAHRİKLİ TASARIMIN doğal bir parçasını oluşturur. Modelde, aslında hiçbir şeyi temsil etmeyen sahte bir nesne yerine bir HİZMET olarak ilan edilen bağımsız işlem kimseyi yanıltmayacaktır.

ve RepositoryEric Evans'a göre,

REPOSİTORY, belirli bir türdeki tüm nesneleri kavramsal küme (genellikle öykünme) olarak temsil eder. Daha ayrıntılı sorgulama yeteneği dışında bir koleksiyon gibi davranır. Uygun türdeki nesneler eklenir ve kaldırılır ve REPOSITORY'nin arkasındaki makineler bunları ekler veya veritabanından siler. Bu tanım, AGGREGATES'in köklerine erken yaşam döngüsünden sonuna kadar erişim sağlamak için tutarlı bir sorumluluk kümesi toplar.

Bileşen-depo-hizmet-ek açıklamaları arasındaki farkı açıklamak için yeterince iyi yanıtlar burada. Arasındaki farkı paylaşmak istiyorum@Controller & @RestController

@Controller vs RestController

@RestController:

• Bu ek açıklama, @Controllerekleyen @Controllerve@ResponseBody açıklama otomatik olarak ek açıklama . bu yüzden @ResponseBodyharitalama yöntemlerimize eklemek zorunda değiliz . Bu @ResponseBodyvarsayılan olarak aktif demektir .
• Eğer kullanırsan @RestController bir görünüm döndüremezsiniz ( Viewresolverİlkbahar / İlkbahar-Önyükleme'de kullanarak )
• @RestControllerAyrıca verilen yanıtı dönüştürür JSON/XML automaticallyolarak @ResponseBodyvücutta olabilecek bir şey döndü nesneleri yapar,e.g. JSON or XML

@Controller

• @Controllersınıfları Spring MVC Controller olarak işaretlemek için kullanılır. Bu ek açıklama, yalnızca@Component ve denetleyici sınıflarının sınıf yolu taramasına göre otomatik olarak algılanmasına olanak tanır.
• @Controller Spring web MVC'de bir görünüm döndürebilirsiniz.

Daha Ayrıntılı Görünüm

Depo ve Hizmet , Bileşen ek açıklamasının çocuklarıdır . Yani hepsi Bileşen . Depo ve Hizmet sadece genişletir. Tam olarak nasıl? Hizmetin sadece ideolojik farkı vardır: Hizmet için kullanırız. Havuzun özel bir istisna işleyicisi vardır.

Stereotiplerin açıklaması:

• @Service- @Service ile tüm servis sınıflarınıza açıklama ekleyin. Bu katman iş birimini bilir. Tüm iş mantığınız Hizmet sınıflarında olacaktır. Genellikle hizmet katmanı yöntemleri işlem kapsamındadır. Hizmet yönteminden birden çok DAO çağrısı yapabilirsiniz, bir işlem başarısız olursa tüm işlemlerin geri alınması gerekir.
• @Repository- Tüm DAO sınıflarına @Repository ile açıklama ekleyin. Tüm veritabanı erişim mantığınız DAO sınıflarında olmalıdır.
• @Component - Diğer bileşenlerinize (örneğin, REST kaynak sınıfları) bileşen stereotipiyle açıklama ekleyin.
• @Autowired - Spring'in @Outowired ek açıklamasını kullanarak diğer fasulyeleri sınıflarınıza otomatik olarak iletmesine izin verin.

@Componentherhangi bir Spring tarafından yönetilen bileşen için genel bir klişedir. @Repository, @ServiceVe @Controllerbir uzmanlık vardır@Component örneğin kalıcılık, hizmet ve sunum katmanları gibi daha spesifik kullanım durumlarının .

Aslında burada cevapladı .

@Component, @Repository, @Controller & @Service ek açıklamaları arasındaki fark

@Component - genel ve uygulama genelinde kullanılabilir.
@Service - hizmet katmanı düzeyinde sınıflara not ekleyin.
@Controller - çoğunlukla Spring MVC'de kullanılan sunum katmanları düzeyindeki sınıflara not ekleyin.
@Repository - kalıcılık katmanındaki sınıflara veritabanı deposu görevi görecek ek açıklama ekleyin.

@Controller= @Component (Dahili Ek Açıklama) + Sunum katmanı Özellikleri
@Service= @Component (Dahili Ek Açıklama) + Hizmet katmanı Özellikleri
@Component= Gerçek Bileşenler (Fasulye)
@Repository= @Component (Dahili Ek Açıklama) + Veri Katmanı Özellikleri (Domain Bean'leri işlemek için kullanın)

İlkbahar çerçevesinde, stereotip ek açıklamalar olarak adlandırılan bazı özel ek açıklamalar sağlar. Bunlar: -

@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.

Yukarıda bildirilen ek açıklamalar özeldir, çünkü <context:component-scan>xxx-servlet.xml dosyasına eklediğimizde , spring, içerik oluşturma / yükleme aşamasında yukarıdaki ek açıklama ile açıklanan bu sınıfların nesnesini otomatik olarak oluşturur.

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

@Componenttarafından yönetilen bileşenleri için genel bir klişe olduğunu Bahar @Repository, @Serviceve @Controllervardır @Componentdaha özel kullanımlar için uzmanlık:

• @Repository sebat için
• @Service hizmetler ve işlemler için
• @Controller MVC kontrolörleri için

Neden kullanılmalıdır @Repository, @Service, @Controllerüzerinde@Component ? Bileşen sınıflarımızı @Component ile işaretleyebiliriz, ancak bunun yerine beklenen işlevselliğe uyum sağlayan alternatifi kullanırsak. Sınıflarımız, her bir durumda beklenen işlevsellik için daha uygundur.

Açıklamalı bir sınıf @Repository, org.springframework.dao.DataAccessException ile daha iyi bir çeviri ve okunabilir hata işleme özelliğine sahiptir. Verilere erişen bileşenleri (DataAccessObject veya DAO) uygulamak için idealdir.

Açıklamalı sınıf, @ControllerSpring Web MVC uygulamasında denetleyici rolü oynar

@Serviceİş mantığı hizmetlerinde açıklamalı bir sınıf , örneğin DAO Yöneticisi (Cephe) için cephe deseni ve işlem yönetimi

Burada sunulan cevaplar büyük ölçüde teknik olarak doğrudur, ancak cevap listesi uzun olmasına rağmen ve bu altta olacak olsa da, birisinin üzerine tökezlemesi ve değerli bir şey öğrenmesi durumunda, buraya da gerçekten doğru bir yanıt koymaya değer olduğunu düşündüm. o. Cevapların geri kalanı yanlış değil, sadece doğru değiller. Ve trol ordularını durdurmak için, evet, teknik olarak bu ek açıklamaların etkili bir şekilde aynı olduğunu ve bahar 5'e kadar bile değiştirilebilir olduğunu biliyorum. Şimdi, doğru cevap için:

Bu üç ek açıklama tamamen farklı şeylerdir ve birbirinin yerine kullanılamaz. Bunu söyleyebilirsiniz çünkü bir değil üç tane var. Değiştirilebilir olmaları amaçlanmamıştır, sadece zarafet ve rahatlıktan bu şekilde uygulanırlar.

Modern programlama, değişen oranlarda buluş, sanat, teknik ve iletişimdir. İletişim biti genellikle çok önemlidir, çünkü kod genellikle yazıldığından çok daha sık okunur. Bir programcı olarak sadece teknik sorunu çözmeye çalışmıyorsunuz, aynı zamanda niyetinizi kodunuzu okuyan gelecekteki programcılara iletmeye çalışıyorsunuz. Bu programcılar anadilinizi ya da sosyal ortamınızı paylaşmayabilir ve gelecekte kodunuzu 50 yıl boyunca okuyor olabilirler (düşündüğünüz kadar olası değildir). Gelecekte bu kadar etkili bir şekilde iletişim kurmak zor. Bu nedenle, elimizdeki en açık, en verimli, doğru ve iletişimsel dili kullanmamız hayati önem taşımaktadır.

Örneğin, @Repositorybir depo yazarken değil, çok önemlidir @Component. İkincisi, bir depo için çok zayıf bir ek açıklama seçeneğidir, çünkü bir depoya baktığımızı göstermez. Bir havuzun aynı zamanda bir bahar fasulyesi olduğunu varsayabiliriz, ancak bir bileşenin bir havuz olduğunu değil. İle@Repository bizim dilde net ve spesifik ediliyor. Bunun bir depo olduğunu açıkça belirtiyoruz. İle@Componentne tür bir bileşen okuduklarına karar vermek için okuyucuya bırakıyoruz ve anlam çıkarmak için tüm sınıfı (ve muhtemelen bir alt sınıflar ve arayüzler ağacı) okumak zorunda kalacaklar. Sınıf daha sonra uzak gelecekte bir okuyucu tarafından bir depo olmadığı için yanlış yorumlanabilir ve bu hatadan kısmen sorumlu olurduk çünkü bunun bir depo olduğunu tam olarak bilen, dilimizde spesifik olamadık ve niyetimizi etkili bir şekilde iletmek.

Diğer örneklere girmeyeceğim, ancak olabildiğince açık bir şekilde ifade edeceğim: bu ek açıklamalar tamamen farklı şeylerdir ve niyetlerine göre uygun şekilde kullanılmalıdır. @Repositorydepolama havuzları içindir ve başka ek açıklama doğru değildir. @Servicehizmetler içindir ve başka ek açıklama doğru değildir. @Componentdepo veya hizmet olmayan bileşenler içindir ve bunların herhangi birinin yerinde kullanılması da yanlış olur. Derleyebilir, hatta testlerinizi yürütebilir ve geçebilir, ancak bu yanlış olur ve eğer bunu yapacak olsaydınız (profesyonel olarak) sizi daha az düşünürdüm.

Bunun ilkbahar boyunca örnekleri (ve genel olarak programlama) vardır. @ControllerBir REST API'sini yazarken kullanmamalısınız , çünkü @RestControllerkullanılabilir. Geçerli bir alternatif @RequestMappingolduğunda kullanmamalısınız @GetMapping. Vs vs vs Sen gerekir kesin çoğu özgü seçti ve mümkün doğru dil okuyucularınıza senin niyet iletişim kurmak, aksi takdirde sistem içine riskleri tanıtıyoruz, ve risk bir maliyeti vardır.

Bu resme basitleştirmek amacıyla, bize Kullanım örneğine göre technicality düşünelim, Bu ek açıklamalar enjekte edilmesi için kullanılır ve dediğim gibi tam anlamıyla " enjekte edilmesi için kullanılır kullanmak nasıl biliyorsanız, demek oluyor," Bağımlılık Enjeksiyon "DI" ve seni her zaman bu ek açıklamaları arayacaksınız ve bu Stereo Tipleri ile sınıflara açıklama ekleyerek DI kabını başka yerlere Enjeksiyona hazır olmaları için taramaları için bilgilendiriyorsunuz , bu pratik hedef.

Şimdi her birine geçelim; önce @Service , Belirli bir iş durumu için bazı mantık oluşturuyorsanız, bunu iş mantığınızı içerecek bir yerde ayırmanız gerekir, bu hizmet normal Sınıftır veya isterseniz arayüz olarak kullanabilirsiniz ve bu

@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;
}

Bunları enjekte ettiğinizde hepsi aynıdır, @ Repository, Depo Desen Deposu tasarım deseni için uygulamayı uygulayan bir arabirimdir , genellikle bazı veri deposu veya veritabanıyla uğraşırken kullanılır ve bunu göreceksiniz. veritabanı işlemlerini gerçekleştirmeniz için hazır uygulama; CrudRepository , JpaRepository vb. olabilir .

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

Sonunda @Component , bu baharda kayıtlı fasulye için genel form, bu bahar her zaman @Component ile işaretlenmiş fasulye arıyor, o zaman hem @Service hem de @Repository @Component'in özel durumlarıdır, ancak ortak kullanım durumu bileşen için doğrudan iş davasını kapsayan değil tamamen teknik bir şey yaptığınızda olduğunu! tarihleri ​​biçimlendirme veya özel istek serileştirme mekanizması vb.

@ Bileşen, yapılandırma sınıfında @Bean ek açıklaması gibi davranır, çekirdeği bahar bağlamında kaydeder. Ayrıca @Service, @Repository ve @Controller ek açıklaması için üst öğedir.

@Service , @Component ek açıklamasını genişletir ve yalnızca adlandırma farkı vardır.

@Repository - @Component ek açıklamasını genişletir ve tüm veritabanı istisnalarını DataAccessException özelliğine dönüştürür .

@Controller - MVC modelinde kontrolör görevi görür. Dağıtıcı, bu açıklamalı sınıfları @RequestMapping ek açıklamalarını algılayarak eşlenen yöntemler için tarar.

@Component
@Controller
@Repository
@Service
@RestController

Bunların hepsi StereoType ek açıklamalarıdır. Sınıflarımızı ioc kapta bahar fasulyesi yapmak için kullanışlıdır,