JavaBean tam olarak nedir?

Bence, bir "Bean" özellikleri ve getters / setters bir Java sınıfı olduğunu anladım. Anladığım kadarıyla, bir C yapısına eşdeğerdir. Bu doğru mu?

Ayrıca, bir fasulye ve normal bir sınıf arasında gerçek bir sözdizimsel fark var mı? Herhangi bir özel tanım veya arayüz var mı?

Temel olarak, bunun için neden bir terim var?

Ayrıca Serializablearayüz ne anlama geliyor?

JavaBean sadece bir standarttır

1. Tüm mülkler özel ( alıcıları / ayarlayıcıları kullanın )
2. Herkese açık bir bağımsız değişken oluşturucu
3. Uygular Serializable.

Bu kadar. Bu sadece bir kongre. Ancak pek çok kütüphane buna bağlı.

İlgili olarak için Serializable, gelen API belgelerine :

Bir sınıfın serileştirilebilirliği, java.io.Serializable arabirimini uygulayan sınıf tarafından etkinleştirilir. Bu arabirimi uygulamayan sınıfların durumlarının hiçbiri serileştirilmiş veya serileştirilmiş olmayacaktır. Serileştirilebilir bir sınıfın tüm alt türlerinin kendileri serileştirilebilirdir. Serileştirme arayüzünde herhangi bir yöntem veya alan yoktur ve sadece serileştirilebilir olmanın anlambilimini tanımlamaya yarar.

Başka bir deyişle, serileştirilebilir nesneler akışlara ve dolayısıyla dosyalara, nesne veritabanlarına, gerçekten herhangi bir şeye yazılabilir.

Ayrıca, bir JavaBean ve başka bir sınıf arasında sözdizimsel bir fark yoktur - bir sınıf, standartları takip ederse bir JavaBean'dır.

Bunun için bir terim var çünkü standart kütüphanelerin önceden tanımladığınız şekilde sınıf örnekleriyle programlı olarak şeyler yapmasına izin veriyor. Örneğin, bir kütüphane, içine aktardığınız herhangi bir nesneyi akışa almak istiyorsa, nesnenizin serileştirilebildiğinden (lib'in nesnelerinizin uygun JavaBeans olmasını gerektirdiğini varsayarak) yapabileceğini bilir.

Kulağa özel gelmesi için bir terim var. Gerçek bu kadar gizemli bir yere yakın değil.

Temel olarak, bir "Fasulye":

• serileştirilebilir bir nesnedir (yani, java.io.Serializabledoğru bir şekilde uygular ve yapar),
• alıcıları ve ayarlayıcıları yalnızca belirli adlara sahip yöntemlerdir (örneğin, getFoo()"Foo" özelliği için alıcıdır) ve
• herkese açık bir 0 arg yapıcısına sahiptir (böylece istek üzerine oluşturulabilir ve özellikleri ayarlanarak yapılandırılabilir).

Güncelleme:

Gelince Serializable: Bu, Java'ya, uygulayıcı sınıfın "serileştirme" için izin verdiğini (ve yapabileceğini ima ettiğini) söyleyen bir "işaretleyici arabirimi" (herhangi bir işlev bildirmeyen bir arabirim) dışında bir şey değildir - dönüştüren bir işlem bayt akışına bir örnek. Bu baytlar dosyalarda saklanabilir, ağ bağlantısı üzerinden gönderilebilir, vb. Ve bir JVM'nin (en azından nesnenin türünü bilen) nesneyi daha sonra yeniden yapılandırmasına izin verecek kadar bilgiye sahip olabilir - muhtemelen farklı bir örnekte uygulama, hatta başka bir makinede!

Elbette, bunu yapmak için sınıfın belirli sınırlamalara uyması gerekir. Bunların başında, tüm örnek alanlarının ilkel türler (int, bool, vb.), Serileştirilebilen veya transientJava olarak dahil edilmeye çalışılmayacak şekilde işaretlenmiş bir sınıfın örnekleri olması gerekir. (Bu elbette transientalanların bir akarsu üzerinde yolculuktan kurtulamayacağı anlamına gelir . transientGerekirse alanları yeniden başlatmak için alanları olan bir sınıf hazırlanmalıdır.)

Bu sınırlamalara uymayan bir sınıf uygulanmamalıdır Serializable(ve IIRC, Java derleyicisi buna izin vermez .)

JavaBeans, son derece basit bir kodlama kuralına uyan Java sınıflarıdır. Tek yapman gereken

1. uygulamak java.io.Serializablearayüz - Bir nesnenin durumunu kurtarmak için
2. herkese açık bir bağımsız değişken yapıcı kullanın - nesneyi örneklemek için
3. genel alıcı / ayarlayıcı yöntemleri sağlar - özel değişkenlerin (özelliklerin) değerlerini almak ve ayarlamak.

JavaBeans Özellikleri

JavaBean, belirli programlama kurallarını karşılayan bir Java nesnesidir:

1. JavaBean sınıfı Serializableya Externalizable

2. JavaBean sınıfında arg olmayan bir yapıcı bulunmalıdır

3. Tüm JavaBean özellikleri genel ayarlayıcı ve alıcı yöntemlerine sahip olmalıdır

4. Tüm JavaBean örnek değişkenleri özel olmalıdır

JavaBeans Örneği

@Entity
public class Employee implements Serializable{

   @Id
   private int id;
   private String name;   
   private int salary;  

   public Employee() {}

   public Employee(String name, int salary) {
      this.name = name;
      this.salary = salary;
   }
   public int getId() {
      return id;
   }
   public void setId( int id ) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName( String name ) {
      this.name = name;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Bir örnekle açıklama.

1. içe aktar java.io.Serializable

Serileştirmeye gelince, belgelere bakın .

2. özel alanlar

Dış sınıfların bu alanları kolayca değiştirmesini önlemek için alanlar özel olmalıdır. Bu alanlara doğrudan erişim yerine, usaagly getter / setter yöntemleri kullanılır.

3. Oluşturucu

Tartışmasız bir kamu kurucusu.

4. alıcı / ayarlayıcı

Özel alanlara erişmek ve değiştirmek için alıcı ve ayarlayıcı yöntemleri.

/** 1. import java.io.Serializable */
public class User implements java.io.Serializable {
    /** 2. private fields */
    private int id;
    private String name;

    /** 3. Constructor */
    public User() {
    }
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    /** 4. getter/setter */
    // getter
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    // setter
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Java Beans daha az kod ve daha fazla iş yaklaşımı için kullanıyor ... Java Beans Java EE genelinde çalışma zamanı bulma ve erişim için evrensel bir sözleşme olarak kullanılır. Örneğin, JavaServer Pages (JSP), sayfalar arasında veya sunucu uygulamaları ve JSP'ler arasında veri aktarım nesneleri olarak Java Beans'i kullanır. Java EE'nin JavaBeans Aktivasyon Çerçevesi, MIME veri türleri için desteği Java EE'ye entegre etmek için Java Beans'i kullanır. Java EE Yönetim API'sı, Java EE ortamında yönetilecek kaynakların enstrümantasyonunun temeli olarak JavaBeans'i kullanır.

Serileştirme Hakkında:

Nesne serileştirmesinde bir nesne, nesnenin verilerini ve nesnenin türü ve nesnede saklanan veri türleri hakkında bilgi içeren bir bayt dizisi olarak temsil edilebilir.

Serileştirilmiş bir nesne bir dosyaya yazıldıktan sonra, dosyadan okunabilir ve serileştirilebilir, yani nesneyi ve verilerini temsil eden tür bilgisi ve baytlar, nesneyi bellekteki yeniden oluşturmak için kullanılabilir.

Fasulye kalıcı olacak ve bunlar arasında aktarılacağı için, projenizi birden fazla sunucuya dağıtırken Seri Hale Getirmeyi yararlı bulacaksınız.

Java Beans bir standarttır ve temel sözdizimi gereksinimleri diğer cevaplarla açıkça açıklanmıştır.

Ancak IMO, basit bir sözdizimi standardından daha fazlasıdır. Java Fasulye'nin gerçek anlamı veya amaçlanan kullanımı, standart etrafında çeşitli araç destekleriyle birlikte, kodun yeniden kullanılmasını ve bileşen tabanlı yazılım mühendisliğini kolaylaştırmak, yani geliştiricilerin mevcut bileşenleri (sınıfları) birleştirerek ve herhangi bir yazmak zorunda kalmadan uygulamalar geliştirmelerini sağlamaktır. (veya sadece küçük bir tutkal kodu yazmanız gerekir). Ne yazık ki bu teknoloji, sektör tarafından çok az tahmin ediliyor ve yetersiz kullanılıyor, bu da bu konudaki cevaplardan söylenebilir.

Oracle'ın Java Beans hakkındaki eğiticisini okursanız , daha iyi bir anlayış elde edebilirsiniz.

Wikipedia'ya göre:

1. Sınıfın genel bir varsayılan yapıcısı (bağımsız değişken olmadan) olmalıdır. Bu, düzenleme ve etkinleştirme çerçevelerinde kolay örneklemeye olanak tanır.

2. Sınıf özelliklerine standart bir adlandırma kuralına göre get, set, is (get yerine boolean özellikleri için kullanılabilir) ve diğer yöntemler (erişimci yöntemleri ve mutatör yöntemleri denir) kullanılarak erişilebilir olmalıdır. Bu, birçoğu çeşitli özellik türleri için özel editörler içeren, çerçeveler içinde fasulye durumunun kolay otomatik olarak denetlenmesine ve güncellenmesine olanak tanır. Ayarlayıcıların bir veya daha fazla argümanı olabilir.

3. Sınıf serileştirilebilir olmalıdır. [Bu, uygulamaların ve çerçevelerin, çekirdeğin durumunu sanal makineden ve platformdan bağımsız bir şekilde güvenilir bir şekilde kaydetmesini, depolamasını ve geri yüklemesini sağlar.]

Daha fazla bilgi için bu bağlantıyı takip edin .

Sorunuzun ikinci kısmı ile ilgili olarak, Serileştirme, nesneleri imzalı bayt dizisi olarak saklamak için kullanılan bir kalıcılık mekanizmasıdır. Daha az resmi olarak, bir nesnenin durumunu saklar, böylece serileştirme yoluyla daha sonra geri alabilirsiniz.

Java Bean, aşağıdaki kurallara uyması gereken bir java sınıfıdır [kavramsal]:

1. Arg olmayan bir kurucuya sahip olmalıdır.
2. Serileştirilebilir olmalıdır.
3. Alıcı ve ayarlayıcı yöntemleri olarak bilinen özelliklerin değerlerini ayarlamak ve almak için yöntemler sağlamalıdır.

Yeniden kullanılabilir bir yazılım bileşenidir. Birçok nesneyi tek bir nesnenin içine yerleştirebilir, böylece aynı nesneye birden fazla yerden erişilebilir ve kodun kolay bakımına yönelik bir adımdır.

Serileştirilebilir, sıfır değişkenli bir yapıcıya sahiptir ve alıcı ve ayarlayıcı yöntemlerini kullanarak özelliklere erişime izin verir. Java için yeniden kullanılabilir yazılım bileşenleri oluşturmayı amaçlayan bu standardı kapsayacak şekilde "Fasulye" adı verilmiştir. according to wiki

Uygulamanızın omurgasını oluşturan ve Spring IoC konteyneri tarafından yönetilen nesnelere fasulye denir. Fasulye, bir Spring IoC konteyneri tarafından başlatılan, bir araya getirilen ve başka şekilde yönetilen bir nesnedir. Aksi takdirde, bir fasulye sadece uygulamanızdaki birçok nesneden biridir. according to bahar io .

Fasulye kavramı üzerinde sadece küçük bir arka plan / güncelleme. Diğer pek çok cevap aslında neyin var ama çok değil.

GUI'lerin bir parçası olarak Java'da erken icat edildi. Bean'in özelliklerini düzenleyebilmeniz için bir özellik paneli oluşturmalarına izin veren araçların ayrılması kolay desenleri izlediler. Genel olarak, Bean özellikleri ekranda bir kontrolü temsil eder (Think x, y, width, height, text, ..)

Ayrıca, güçlü bir şekilde yazılan bir veri yapısı olarak da düşünebilirsiniz.

Zamanla bunlar, aynı türde erişim kullanan birçok araç için yararlı oldu (Örneğin, veri yapılarını veritabanına kalıcı hale getirmek için Hazırda Bekletme)

Araçlar geliştikçe daha fazla ek açıklamaya yöneldi ve ayarlayıcı / alıcı adlarını ayırmaktan uzaklaştılar. Şimdi çoğu sistem fasulye gerektirmez, onlara nasıl manipüle edileceğini söylemek için açıklamalı özelliklere sahip herhangi bir düz eski java nesnesini alabilirler.

Şimdi fasulyeleri açıklamalı mülkiyet topları olarak görüyorum - gerçekten sadece taşıdıkları ek açıklamalar için faydalılar.

Fasulye kendileri sağlıklı bir desen değildir. Tüm özelliklerini harici manipülasyona maruz bıraktıkları için doğası gereği kapsüllemeyi yok ederler ve kullanıldıklarında, fasulye içinde kod oluşturmak yerine fasulyeyi harici olarak manipüle etmek için kod oluşturma eğilimi vardır (hiçbir şekilde bir gereklilik yoktur) bir nesnenin değerlerini sorma, bir nesneden sizin için bir şey yapmasını isteyin "). En az alıcı ve ayarlayıcı olmayan açıklamalı pojos kullanmak, kapsülleme ve değişmezlik olasılığı ile çok daha fazla OO'dur.

Bu arada, tüm bu şeyler meydana geldiğinden biri kavramı Kurumsal Java Fasulyesi olarak adlandırılan bir şeye genişletti. Bunlar ... farklı. ve pek çok insan Bean kavramının tamamını anlamadıklarını ve terimi kullanmayı bıraktıklarını düşünecek kadar karmaşıktır. Bu, bence, neden genellikle POJO olarak adlandırılan fasulye duyuyorsunuz (her java nesnesi bir POJO olduğundan bu teknik olarak sorun değil, ancak birisinin POJO dediğini duyduğunuzda, çoğunlukla fasulye desenini takip eden bir şey düşünüyorlar)

Java Bean, aşağıdaki üç kriteri karşılayan herhangi bir java sınıfıdır:

1. Serileştirilebilir arayüz (Bir Marker arayüzü) uygulamalıdır.
2. Kurucu halka açık olmalı ve argüman içermemelidir (Başkalarının "arg-yapıcı" olarak adlandırdığı şey).
3. Alıcı ve ayarlayıcıları olmalıdır.

SerialVersionUID alanının nesne durumunu korumak için önemli olduğunu unutmayın. Aşağıdaki kod fasulye olarak nitelendirilir:

public class DataDog implements java.io.Serializable {

private static final long serialVersionUID = -3774654564564563L;

private int id;
private String nameOfDog;

//The constructor should NOT have arguments
public DataDog () {}


/** 4. getter/setter */

// getter(s)
public int getId() {
    return id;
}
public String getNameOfDog() {
    return nameOfDog;
}
// setter(s)
public void setId(int id) {
    this.id = id;
}
public void setNameOfDog(String nameOfDog) {
    this.nameOfDog = nameOfDog;
}}

JavaBean'ı anlamak için aşağıdakilere dikkat etmeniz gerekir: JavaBean kavramsal bir şeydir ve belirli bir şey sınıfını temsil edemez

JavaBean yeniden kullanılabilir yazılım bileşenlerinin çalışmasında görüntülenebilir bir geliştirme aracıdır

JavaBean, Sun JavaBeans spesifikasyonuna dayanır ve yeniden kullanılabilir bileşenler olabilir. En büyük özelliği yeniden kullanılabilirliktir.

Fasulye , özellikler , yöntemler ve etkinlikler için Java Bean yönergelerine (tasarım desenleri de denir) uyan yöntem adlarına sahip bir Java sınıfıdır. Dolayısıyla, fasulye sınıfının bir özellik tanımının parçası olmayan herhangi bir genel yöntemi bir fasulye yöntemidir. En azından, tek üye olarak bir özelliğe sahip bir Java sınıfı (elbette, ortak alıcı ve ayarlayıcıya eşlik etmek gerekir), tek üye olarak genel bir yöntem veya sadece bir genel olay dinleyicisi kayıt yöntemi bir Java fasulyesidir. Ayrıca, özellik salt okunur özellik (alıcı yöntemine sahip, ancak ayarlayıcı içermiyor) veya salt yazılır özellik (yalnızca ayarlayıcı yöntemine sahip olabilir) olabilir. Herhangi bir beanbox aracı veya kabı tarafından görülebilmesi için Java fasulyesinin genel bir sınıf olması gerekir. Kap, somutlaştırabilmelidir; bu yüzden de bir kamu kurucusu olması gerekir. JavaBeans şartnamebir kabın, bir kabın somutlaştırması için açık veya varsayılan bir genel sıfır değişkenli yapıcıya sahip olmasını gerektirmez. Serileştirilmiş bir örnek içeren bir dosya (.ser uzantılı) sağlayabilirseniz, bir beanbox aracı bu dosyayı bir prototip çekirdeği oluşturmak için kullanabilir. Aksi takdirde, çekirdeğin açık veya varsayılan bir genel sıfır değişken yapıcısı olmalıdır.

Fasulye somutlaştırıldıktan sonra, Java Bean API'sı (java.beans. *) İntrospect edebilir ve üzerindeki yöntemleri çağırabilir. BeanInfo arabirimini uygulayan veya bir BeanInfo uygulamasını genişleten bir sınıf yoksa, SimpleBeanInfo sınıfı, içgözlem, bir hedef çekirdeği tarafından desteklenen yöntemleri incelemek ve daha sonra çıkarmak için basit tasarım desenleri (yönergeler) uygulamak için yansıma (örtük içgözleme) kullanılmasını içerir. özellikleri, olayları ve genel yöntemleri destekleyen yöntemler. BeanInfo arabirimini uygulayan bir sınıf (bir fasulye Foo için FooBeanInfo olarak adlandırılmalıdır) varsa, API örtük içgözlemi atlar ve bu sınıfın genel yöntemlerini (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()) bilgi. SimpleBeanInfo'yu genişleten bir sınıf mevcutsa, SimpleBeanInfo genel yöntemlerinden hangisinin geçersiz kılındığına bağlı olarak (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()), bilgi almak için bu geçersiz kılınan yöntem (ler) i kullanır; geçersiz kılınmayan bir yöntem için, varsayılan olarak karşılık gelen örtük içgözlem için kullanılır. Fasulye, üzerinde örtük bir içgözlem olmasa bile, yine de somutlaştırılmalıdır. Böylece, bir kamu zeri-args yapıcısının gerekliliği. Ancak, elbette, Seri hale getirilebilir veya Dışsallaştırılabilir arayüz tanınması için gerekli değildir. Bununla birlikte, Java Bean spesifikasyonu, 'Sadece kendi iç durumunu kaydetmek isteyen ve bunu düşünmek istemeyen küçük bir Bean'in genel durumu için “önemsiz” olmasını isteriz. Bu nedenle, tüm fasulye Serileştirilebilir veya Dışsallaştırılabilir arabirim uygulamalıdır. Genel olarak, JavaBeans spesifikasyonu bir fasulyeyi neyin oluşturduğu konusunda zor ve hızlı değildir. "JavaBeans bileşenlerini yazmak şaşırtıcı derecede kolaydır. Özel bir araca ihtiyacınız yoktur ve herhangi bir arabirim uygulamak zorunda değilsiniz. Fasulye yazmak sadece belirli kodlama kurallarına uyma meselesidir. Tek yapmanız gereken sınıfınıza benzetmek bir fasulye - fasulye kullanan araçlar fasulyenizi tanıyabilecek ve kullanabilecektir. " Önemsiz olarak, aşağıdaki sınıf bile bir Java Bean,

public class Trivial implements java.io.Serializable {}

Diyelim ki, bir fasulye yapıcısının bazı parametreleri var. Bazılarının basit türler olduğunu varsayalım. Kapsayıcı onlara hangi değerlerin atanacağını bilemeyebilir; olsa bile, ortaya çıkan örnek yeniden kullanılamayabilir. Yalnızca kullanıcı, Bahar fasulyelerinde olduğu gibi söz açıklamaları veya xml yapılandırma dosyaları ile yapılandırabilirse (değerleri belirleyebilirse) mantıklı olabilir. Ve bazı parametrelerin sınıf veya arayüz tipleri olduğunu varsayalım. Yine, kap kendisine hangi değerlerin atanacağını bilemeyebilir. Yalnızca kullanıcı sözlü ek açıklamalar veya xml yapılandırma dosyalarıyla yapılandırabilirse (belirli nesneleri belirleyebilirse) mantıklı olabilir. Ancak, Spring'de bile (xml yapılandırma dosyaları aracılığıyla), yapıcı argümanlarına (yapıcı argümanlarının özniteliği veya öğesi) belirli nesneler (dize adları ile) atamak tipik değildir; temel olarak kaynak enjeksiyonu gibidir. Diğer Bahar çekirdeklerine (işbirlikçi denir; bir yapıcı argüman öğesindeki öğe yoluyla) atıfta bulunmak temel olarak bağımlılık enjeksiyonudur ve bu nedenle tipiktir. Açıkçası, bir bağımlılığın (ortak çalışan fasulye) enjekte edilmiş parametrelere sahip bir kurucu olabilir; enjekte edilen bağımlılık (lar) ın parametreleri ve benzerleri olan bir yapıcısı olabilir. Bu senaryoda, nihayetinde, diğer işbirlikçi çekirdekleri yapıcılara bağımlı enjeksiyon yoluyla inşa etmeden önce kabın sadece yeni MyBean () çağırarak başlatabileceği bazı fasulye sınıflarına (örneğin, MyBean.class) ihtiyacınız olacak - böylece, fasulye kamu sıfır-args yapıcı olması. Bir kapsayıcı bağımlılık enjeksiyonunu desteklemiyorsa ve / veya Spring'deki gibi bazı ek açıklamalar veya xml yapılandırma dosyaları aracılığıyla kurucuya basit tür değerlerin atanmasına izin vermiyorsa, fasulye yapıcılarının parametreleri olmamalıdır. Bir Bahar fasulyesi uygulaması bile, genel sıfır değişkenli kurucuya sahip olmak için bazı fasulyeye ihtiyaç duyacaktır (örneğin, Bahar uygulamanızın kurucu argümanları olarak sadece basit tipte fasulyeye sahip olmadığı bir senaryoda).

JSF yönetilen fasulye bir web kapsayıcısında çalıştırın. @ManagedBean ek açıklamasıyla veya yönetilen bean.xml uygulama yapılandırma kaynak dosyasıyla yapılandırılabilirler. Bununla birlikte, sadece kaynak enjeksiyonu yoluyla (tipik değil) enjeksiyonu destekler; yapıcılara enjeksiyon için uygun değildir. MTU specyönetilen çekirdeklerin genel sıfır argüman kurucularına sahip olmasını gerektirir. Ayrıca, “Bu tarifnamenin 2.3 sürümünden itibaren, bu bölümde belirtilen yönetilen fasulye tesisinin kullanılması kesinlikle önerilmez. Aynı sorunu çözmek için daha iyi ve daha uyumlu bir şekilde entegre edilmiş bir çözüm, JSR-365'te belirtildiği gibi Bağlamlar ve Bağımlılık Enjeksiyonu (CDI) kullanmaktır. "Başka bir deyişle, benzer yapıcılara tipesafe bağımlılık enjeksiyonu sunan CDI tarafından yönetilen fasulye kullanılacak. CDI şartnamesi, sadece web katmanı için değil, JEE platformunun tüm kapları için geçerli olan Yönetilen Fasulye şartnamesini benimser.Bu nedenle, web kapsayıcısının CDI şartnamesini uygulaması gerekir.

İşte Yönetilen Fasulye spesifikasyonundan bir alıntı “Yönetilen Fasulye, aksi takdirde“ POJO'lar ”(Düz Eski Java Nesneleri) kısaltması altında bilinen, minimum gereksinimleri olan kapsayıcı tarafından yönetilen nesnelerdir ... Java SE platformunda bulunan JavaBeans bileşen modelinin Java EE platformu gelişmiş bir sürümü olarak görülebilirler .... Managed Beans'ın JavaServer Faces (JSF) teknolojisinde bulunan homonymous tesisinde bir öncüye sahip olması okuyucu tarafından kaçırılmayacaktır… Bu spesifikasyonda tanımlanan Managed Beans, JSF'de bulunanların genellemesini temsil eder; özellikle, Yönetilen Fasulye, yalnızca web modüllerinde değil, bir Java EE uygulamasında herhangi bir yerde kullanılabilir. Örneğin, temel bileşen modelinde, Yönetilen Fasulye bağımsız değişken oluşturucu değil, ancak CDI (JSR-299) gibi Yönetilen Fasulye üzerine inşa edilen bir belirtim sağlamalıdır, bu gereksinimi gevşetebilir ve Yönetilen Fasulye'nin, iyi tanımlanmış bazı kurallara uydukları sürece inşaatçılara daha karmaşık imzalar sunmasına izin verebilir ... Yönetilen Fasulye olmamalıdır: bir son sınıf, soyut bir sınıf, statik olmayan bir iç sınıf . Yönetilen Fasulye, normal bir JavaBean bileşeninden farklı olarak serileştirilemeyebilir. ” Böylece, başka şekilde POJO veya POJO çekirdekleri olarak bilinen, Yönetilen Fasulye spesifikasyonu CDI'da olduğu gibi uzatmaya izin verir.

CDI özellikleri yönetilen çekirdekleri şu şekilde yeniden tanımlar: Java EE'de çalışırken, üst düzey bir Java sınıfı gereksinimleri karşıladığında yönetilen bir çekirdektir:

• Bir iç sınıf değildir. • Soyut olmayan bir sınıftır veya @Decorator'a not eklenmiştir. • javax.enterprise.inject.spi.Extension uygulamıyor. • @Vetoed veya açıklamalı @Vetoed paketinde açıklanmaz. • Uygun bir kurucuya sahiptir: sınıfta parametresiz bir kurucu vardır veya sınıf, @Inject ek açıklamalı bir kurucu bildirir.

Bu koşulları karşılayan tüm Java sınıfları yönetilen çekirdeklerdir ve bu nedenle yönetilen bir çekirdeği tanımlamak için özel bir bildirim gerekmez. Veya

herhangi bir Java EE spesifikasyonu tarafından yönetilen bir fasulye olarak tanımlanmışsa ve

• EJB bileşeni tanımlayan bir ek açıklama ile açıklanmaz veya ejb-jar.xml dosyasında EJB fasulye sınıfı olarak bildirilmez.

Bahar çekirdeklerinden farklı olarak, Spring gibi xml yapılandırma dosyaları veya herhangi bir ek açıklama ile yapılandırmayı destekliyorsa mümkün olabilecek basit türlere sahip yapıcıları desteklemez.

EJB'ler bir EJB kapsayıcısında çalışır. Onun şartnamediyor ki: “Bir oturum fasulyesi bileşeni bir Yönetilen Fasulye.” “Sınıfta argüman almayan bir kamu kurucusu olması gerekir” diyor hem oturum fasulyesi hem de mesaj odaklı fasulye için. Ayrıca, “Oturum fasulyesi sınıfı SessionBean arabirimini veya Serializable arabirimini uygulamak için gerekli değildir. ” JSF fasulyeleriyle aynı nedenden ötürü, EJB3 bağımlılık enjeksiyonunun temelde kaynak enjeksiyonu olması, JSF fasulyeleri argümanları olan yapıcıları, yani bağımlılık enjeksiyonu yoluyla desteklemez.Ancak, EJB kabı CDI uygularsa, “İsteğe bağlı olarak: Inject ek açıklaması ile açıklamalı ek kurucu, “hem oturum fasulyesi hem de mesaj güdümlü fasulye için diyor,” “CDI fasulye arşivine paketlenmiş ve javax.enterprise.inject.Vetoed ek açıklama ile paketlenmemiş bir EJB, CDI etkin fasulye."

Pratikte, Fasulye sadece kullanımı kolay nesnelerdir. Bunların seri hale getirilmesi, kolayca devam edebilmek anlamına gelir (kolayca geri kazanılabilecek bir formda saklayın).

Fasulyenin gerçek dünyada tipik kullanımları:

• basit yeniden kullanılabilir nesneler POJO (Düz Eski Java Nesneleri)
• görsel nesneler
• Spring, nesneleri işlemek için Fasulye kullanır (örneğin, oturumda serileştirilmesi gereken Kullanıcı nesnesi)
• EJB (Enterprise Java Beans), JSF Beans (JSF eski oldukça eski bir teknolojidir) veya JSP Beans gibi daha karmaşık nesneler

Aslında, Fasulye sadece bir kongre / standarttır Java nesnesinden bir şey davranmasını (serileştirmesini) beklemek ve onu (özellikler için ayarlayıcılar) belirli bir şekilde değiştirmek için bazı yollar vermek .

Bunları nasıl kullanacağınız sadece sizin buluşunuz, ancak yukarıda belirttiğim en yaygın durumlar.