JavaBean คืออะไร

ฉันเข้าใจว่าฉันคิดว่า "Bean" เป็นคลาส Java ที่มีคุณสมบัติและ getters / setters เท่าที่ฉันเข้าใจมันเทียบเท่ากับโครงสร้าง C มันเป็นเรื่องจริงเหรอ?

นอกจากนี้มีความแตกต่างทางวากยสัมพันธ์จริงระหว่างถั่วกับคลาสปกติหรือไม่? มีคำจำกัดความพิเศษหรืออินเทอร์เฟซหรือไม่?

โดยพื้นฐานแล้วทำไมถึงมีคำศัพท์สำหรับเรื่องนี้?

นอกจากนี้ยังมีสิ่งที่ไม่Serializableอินเตอร์เฟซหมายถึงอะไร?

JavaBean เป็นเพียงมาตรฐาน

1. คุณสมบัติทั้งหมดเป็นส่วนตัว (ใช้getters / setters )
2. ตัวสร้างแบบไม่มีอาร์กิวเมนต์สาธารณะ
3. นำSerializableไปปฏิบัติ

แค่นั้นแหละ. มันเป็นเพียงแค่การประชุม ห้องสมุดจำนวนมากขึ้นอยู่กับว่า

ด้วยความเคารพSerializableจากเอกสาร API :

Serializability ของคลาสนั้นเปิดใช้งานโดยคลาสที่ใช้อินเตอร์เฟส java.io.Serializable คลาสที่ไม่ได้ใช้อินเทอร์เฟซนี้จะไม่มีสถานะของพวกเขาต่อเนื่องหรือ deserialized ชนิดย่อยทั้งหมดของคลาสที่สามารถทำให้เป็นอนุกรมได้ อินเตอร์เฟสการทำให้เป็นอนุกรมไม่มีวิธีการหรือฟิลด์และทำหน้าที่เพียงเพื่อระบุความหมายของการเป็นอนุกรม

กล่าวอีกนัยหนึ่งวัตถุที่สามารถทำให้เป็นอนุกรมได้สามารถเขียนลงในสตรีมและด้วยเหตุนี้ไฟล์ฐานข้อมูลวัตถุจะเป็นอะไรก็ได้

นอกจากนี้ยังไม่มีความแตกต่างทางไวยากรณ์ระหว่าง JavaBean และคลาสอื่น - คลาสคือ JavaBean หากเป็นไปตามมาตรฐาน

มีคำศัพท์หนึ่งคำเพราะมาตรฐานอนุญาตให้ไลบรารีทำสิ่งต่าง ๆ ด้วยอินสแตนซ์ของคลาสที่คุณกำหนดในลักษณะที่กำหนดไว้ล่วงหน้า ตัวอย่างเช่นถ้าไลบรารีต้องการสตรีมวัตถุใด ๆ ที่คุณส่งเข้าไปมันจะรู้ได้เพราะวัตถุของคุณสามารถทำให้เป็นอนุกรม (สมมติว่า lib ต้องการวัตถุของคุณเป็น JavaBeans ที่เหมาะสม)

มันมีคำศัพท์ที่จะทำให้มันฟังดูพิเศษ ความจริงไม่มีที่ใดที่จะลึกลับ

โดยทั่วไป "ถั่ว":

• เป็นวัตถุที่ต่อเนื่องได้ (นั่นคือมันใช้java.io.Serializableและทำถูกต้อง)
• มี "คุณสมบัติ" ซึ่ง getters และ setters เป็นเพียงวิธีการที่มีชื่อบางชื่อ (เช่น, พูด, getFoo()คือ getter สำหรับคุณสมบัติ "Foo") และ
• มีคอนสตรัค 0-arg สาธารณะ (เพื่อให้สามารถสร้างได้ตามต้องการและกำหนดค่าโดยการตั้งค่าคุณสมบัติของมัน)

ปรับปรุง:

สำหรับSerializable: นั่นคือไม่มีอะไรนอกจาก "interface Interface" (อินเตอร์เฟสที่ไม่ได้ประกาศฟังก์ชั่นใด ๆ ) ที่บอก Java ว่าการใช้คลาสยินยอมให้ (และบอกเป็นนัยว่ามันมีความสามารถ) "serialization" - กระบวนการที่แปลง อินสแตนซ์เป็นสตรีมของไบต์ ไบต์เหล่านั้นสามารถเก็บไว้ในไฟล์ส่งผ่านการเชื่อมต่อเครือข่าย ฯลฯ และมีข้อมูลเพียงพอที่จะอนุญาตให้ JVM (อย่างน้อยหนึ่งที่รู้เกี่ยวกับประเภทของวัตถุ) เพื่อสร้างวัตถุในภายหลัง - อาจเป็นในกรณีที่แตกต่างกันของ แอปพลิเคชั่นหรือแม้แต่กับเครื่องอื่น!

แน่นอนว่าในการทำเช่นนั้นนักเรียนจะต้องปฏิบัติตามข้อ จำกัด บางอย่าง หัวหน้าในหมู่พวกเขาคือฟิลด์ของอินสแตนซ์ทั้งหมดจะต้องเป็นชนิดดั้งเดิม (int, บูล, ฯลฯ ), อินสแตนซ์ของบางคลาสที่เป็นอนุกรมหรือทำเครื่องหมายtransientว่า Java จะไม่พยายามรวมไว้ (หลักสูตรนี้หมายความว่าtransientฟิลด์จะไม่รอดจากการเดินทางข้ามสตรีมคลาสที่มีtransientฟิลด์ควรเตรียมพร้อมเพื่อเตรียมข้อมูลเบื้องต้นใหม่หากจำเป็น)

คลาสที่ไม่สามารถปฏิบัติตามข้อ จำกัด เหล่านั้นไม่ควรนำไปใช้Serializable(และ, IIRC, คอมไพเลอร์ Java จะไม่ปล่อยให้ทำได้)

JavaBeans เป็นคลาส Java ซึ่งเป็นไปตามรูปแบบการเข้ารหัสที่ง่ายมาก สิ่งที่คุณต้องทำคือการ

1. ใช้java.io.Serializableอินเตอร์เฟส - เพื่อบันทึกสถานะของวัตถุ
2. ใช้ตัวสร้างอาร์กิวเมนต์ว่างเปล่าสาธารณะ - เพื่อยกตัวอย่างวัตถุ
3. จัดเตรียมเมธอด getter / setter สาธารณะ - เพื่อรับและตั้งค่าของตัวแปรไพรเวต (คุณสมบัติ)

คุณสมบัติของ JavaBeans

JavaBean เป็นวัตถุ Java ที่เป็นไปตามข้อกำหนดการเขียนโปรแกรมบางอย่าง:

1. คลาส JavaBean ต้องใช้อย่างใดอย่างหนึ่งSerializableหรือ Externalizable

2. คลาส JavaBean ต้องมี Constructor ที่ไม่มีอาร์กิวเมนต์

3. คุณสมบัติ JavaBean ทั้งหมดต้องมี setter สาธารณะและเมธอด getter

4. ตัวแปรอินสแตนซ์ JavaBean ทั้งหมดควรเป็นแบบส่วนตัว

ตัวอย่างของ JavaBeans

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

คำอธิบายพร้อมตัวอย่าง

1. อิมพอร์ต java.io.Serializable

สำหรับอันดับให้ดูที่เอกสาร

2. เขตข้อมูลส่วนตัว

ฟิลด์ควรเป็นแบบส่วนตัวเพื่อป้องกันไม่ให้คลาสภายนอกปรับเปลี่ยนฟิลด์เหล่านั้นได้อย่างง่ายดาย แทนที่จะใช้โดยตรงกับฟิลด์เหล่านั้นจะใช้เมธอด getter / setter แบบ usuagly

3. ตัวสร้าง

ตัวสร้างสาธารณะโดยไม่มีอาร์กิวเมนต์ใด ๆ

4. ทะเยอทะยาน / setter

วิธี Getter และ setter สำหรับการเข้าถึงและแก้ไขฟิลด์ส่วนตัว

/** 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 ใช้รหัสน้อยลงและใช้วิธีการทำงานมากขึ้น ... Java Beans ถูกใช้ทั่ว Java EE เป็นสัญญาสากลสำหรับการค้นหาและเข้าถึงรันไทม์ ตัวอย่างเช่น JavaServer Pages (JSP) ใช้ Java Beans เป็นวัตถุถ่ายโอนข้อมูลระหว่างหน้าหรือระหว่าง servlets และ JSP JavaBeans Activation Framework ของ Java EE ใช้ Java Beans สำหรับการรวมการสนับสนุนชนิดข้อมูล MIME เข้ากับ Java EE Java EE Management API ใช้ JavaBeans เป็นพื้นฐานสำหรับเครื่องมือของทรัพยากรที่จะได้รับการจัดการในสภาพแวดล้อม Java EE

เกี่ยวกับการทำให้เป็นอันดับ:

ในการทำให้เป็นอันดับวัตถุวัตถุสามารถแสดงเป็นลำดับของไบต์ที่มีข้อมูลของวัตถุเช่นเดียวกับข้อมูลเกี่ยวกับประเภทของวัตถุและประเภทของข้อมูลที่เก็บไว้ในวัตถุ

หลังจากที่วัตถุที่เป็นอนุกรมได้รับการเขียนลงในไฟล์มันสามารถอ่านได้จากไฟล์และ deserialized นั่นคือข้อมูลประเภทและไบต์ที่เป็นตัวแทนของวัตถุและข้อมูลที่สามารถใช้ในการสร้างวัตถุในหน่วยความจำ

คุณจะพบว่าการซีเรียลไลซ์เซชั่นมีประโยชน์เมื่อปรับใช้โครงการของคุณในหลาย ๆ เซิร์ฟเวอร์เนื่องจากถั่วจะคงอยู่และถูกถ่ายโอนข้าม

Java Beans เป็นมาตรฐานและความต้องการด้านไวยากรณ์ขั้นพื้นฐานได้รับการอธิบายอย่างชัดเจนโดยคำตอบอื่น ๆ

อย่างไรก็ตาม IMO เป็นมากกว่ามาตรฐานไวยากรณ์แบบง่าย ความหมายที่แท้จริงหรือการใช้งานอย่างตั้งใจของ Java Beans คือพร้อมด้วยเครื่องมือต่าง ๆ ที่สนับสนุนรอบมาตรฐานเพื่ออำนวยความสะดวกในการนำรหัสกลับมาใช้และวิศวกรรมซอฟต์แวร์ที่อิงองค์ประกอบเช่นช่วยให้นักพัฒนาสามารถสร้างแอปพลิเคชันโดยการประกอบส่วนประกอบที่มีอยู่ รหัส (หรือจะต้องเขียนรหัสกาวเล็กน้อย) น่าเสียดายที่เทคโนโลยีนี้เป็นวิธีที่ใช้ในอุตสาหกรรมต่ำกว่าที่คาดการณ์และไม่ได้ใช้ประโยชน์ซึ่งสามารถบอกได้จากคำตอบในหัวข้อนี้

หากคุณอ่านบทช่วยสอนของ Oracle เกี่ยวกับ Java Beansคุณสามารถเข้าใจได้มากขึ้น

ตาม Wikipedia:

1. ชั้นต้องมีตัวสร้างเริ่มต้นสาธารณะ (ไม่มีข้อโต้แย้ง) สิ่งนี้ทำให้การอินสแตนซ์ง่ายภายในกรอบการแก้ไขและเปิดใช้

2. คุณสมบัติคลาสต้องสามารถเข้าถึงได้โดยใช้ get, set, คือ (สามารถใช้สำหรับคุณสมบัติบูลีนแทน get) และเมธอดอื่น ๆ (เรียกว่าเมธอด accessor และเมธอด mutator) ตามระเบียบการตั้งชื่อมาตรฐาน สิ่งนี้ช่วยให้การตรวจสอบอัตโนมัติและการอัปเดตสถานะถั่วง่ายขึ้นภายในเฟรมเวิร์กซึ่งส่วนใหญ่จะมีตัวแก้ไขที่กำหนดเองสำหรับคุณสมบัติประเภทต่างๆ Setters สามารถมีหนึ่งหรือมากกว่าหนึ่งข้อโต้แย้ง

3. คลาสควรเป็นแบบอนุกรม [สิ่งนี้ช่วยให้แอปพลิเคชันและเฟรมเวิร์กสามารถบันทึกจัดเก็บและกู้คืนสถานะถั่วในลักษณะที่ไม่ขึ้นกับ VM และแพลตฟอร์มได้อย่างน่าเชื่อถือ]

สำหรับข้อมูลเพิ่มเติมไปที่ลิงค์นี้

เกี่ยวกับส่วนที่สองของคำถามของคุณ Serialization เป็นกลไกการคงอยู่ที่ใช้ในการเก็บวัตถุเป็นลำดับไบต์ที่ลงนาม ใส่น้อยลงอย่างเป็นทางการมันเก็บสถานะของวัตถุเพื่อให้คุณสามารถดึงมันได้ในภายหลังโดยการทำให้เป็นอนุกรม

Java Bean เป็นคลาส Java [แนวคิด] ที่ควรปฏิบัติตามอนุสัญญาดังต่อไปนี้:

1. มันควรจะมีคอนสตรัคเตอร์ที่ไม่มีข้อโต้แย้ง
2. ควรเป็น Serializable
3. มันควรมีวิธีการตั้งค่าและรับค่าของคุณสมบัติที่รู้จักกันเป็นวิธีการ getter และ setter

มันเป็นองค์ประกอบซอฟต์แวร์ที่นำมาใช้ซ้ำได้ สามารถห่อหุ้มวัตถุจำนวนมากเป็นวัตถุเดียวเพื่อให้วัตถุเดียวกันสามารถเข้าถึงได้จากสถานที่หลายรายการและเป็นขั้นตอนต่อการบำรุงรักษาง่ายของรหัส

พวกมันสามารถทำให้เป็นอนุกรมมีตัวสร้าง zero-argument และอนุญาตให้เข้าถึงคุณสมบัติโดยใช้วิธี getter และ setter ชื่อ "Bean" ได้รับการรวมไว้ในมาตรฐานนี้ซึ่งมีวัตถุประสงค์เพื่อสร้างส่วนประกอบซอฟต์แวร์ที่สามารถใช้ซ้ำได้สำหรับ Javaaccording to วิกิพีเดีย

วัตถุที่เป็นกระดูกสันหลังของแอปพลิเคชันของคุณและได้รับการจัดการโดย Spring IoC container เรียกว่า beans bean เป็นวัตถุที่สร้างอินสแตนซ์ประกอบและจัดการโดยคอนเทนเนอร์ Spring IoC มิฉะนั้นถั่วเป็นเพียงหนึ่งในหลาย ๆ วัตถุในแอปพลิเคชันของคุณ according to ฤดูใบไม้ผลิ io

เพียงแค่พื้นหลัง / อัปเดตเล็กน้อยเกี่ยวกับแนวคิดของถั่ว คำตอบอื่น ๆ อีกมากมายมีจริง แต่ไม่มากทำไมพวกเขา

พวกเขาถูกประดิษฐ์ขึ้นในช่วงต้นของ Java เป็นส่วนหนึ่งของการสร้าง GUI พวกเขาติดตามรูปแบบที่ง่ายสำหรับเครื่องมือในการดึงแยกออกจากกันเพื่อให้พวกเขาสร้างแผงคุณสมบัติเพื่อให้คุณสามารถแก้ไขคุณลักษณะของ Bean ได้ โดยทั่วไปคุณสมบัติ Bean แสดงการควบคุมบนหน้าจอ (คิดว่า x, y, ความกว้าง, ความสูง, ข้อความ, .. )

คุณสามารถคิดว่ามันเป็นโครงสร้างข้อมูลที่พิมพ์ออกมาอย่างแรง

เมื่อเวลาผ่านไปสิ่งเหล่านี้มีประโยชน์สำหรับเครื่องมือจำนวนมากที่ใช้การเข้าถึงชนิดเดียวกัน (เช่นไฮเบอร์เนตเพื่อคงโครงสร้างข้อมูลไว้ในฐานข้อมูล)

เมื่อเครื่องมือพัฒนาขึ้นพวกเขาก็เคลื่อนไปสู่คำอธิบายประกอบมากขึ้นและห่างจากการแยกชื่อ setter / getter ออกจากกัน ตอนนี้ระบบส่วนใหญ่ไม่ต้องการถั่วพวกเขาสามารถนำวัตถุ java เก่า ๆ ที่มีคุณสมบัติกำกับประกอบเพื่อบอกวิธีจัดการพวกเขา

ตอนนี้ฉันเห็นว่าถั่วเป็นลูกบอลของคำอธิบายประกอบ - พวกเขามีประโยชน์จริง ๆ สำหรับคำอธิบายประกอบที่พวกเขาดำเนินการ

ถั่วเองไม่ได้เป็นรูปแบบที่ดีต่อสุขภาพ พวกเขาทำลาย encapsulation โดยธรรมชาติเนื่องจากพวกเขาเปิดเผยคุณสมบัติทั้งหมดของพวกเขาเพื่อการจัดการภายนอกและในขณะที่พวกเขาใช้มีแนวโน้ม (ไม่จำเป็นต้องมี) เพื่อสร้างรหัสเพื่อจัดการถั่วภายนอกแทนการสร้างรหัสภายในถั่ว (ละเมิด "don ไม่ต้องถามค่าวัตถุขอให้วัตถุทำอะไรเพื่อคุณ ") การใช้ pojos ที่มีคำอธิบายประกอบพร้อมกับ getters น้อยที่สุดและไม่มีตัวตั้งค่าเป็น OO ที่เรียกคืนการห่อหุ้มมากขึ้นและมีความเป็นไปได้ที่จะไม่เปลี่ยนรูป

โดยวิธีการที่เป็นสิ่งนี้เกิดขึ้นใครบางคนขยายแนวคิดไปยังสิ่งที่เรียกว่า Enterprise Java Beans เหล่านี้ ... แตกต่างกัน และพวกเขาก็ซับซ้อนพอที่คนจำนวนมากรู้สึกว่าพวกเขาไม่เข้าใจแนวคิดทั้งหมดของ Bean และหยุดใช้คำนั้น นี่คือฉันคิดว่าทำไมคุณมักจะได้ยินถั่วที่เรียกว่า POJOs (เนื่องจากวัตถุ Java ทุกตัวเป็น POJO ซึ่งเป็นเรื่องทางเทคนิคก็โอเค แต่เมื่อคุณได้ยินคนพูด POJO พวกเขามักจะคิดถึงบางสิ่งที่ตามรูปแบบของถั่ว)

Java Bean คือคลาส Java ใด ๆ ที่ตรงตามเกณฑ์สามข้อต่อไปนี้:

1. มันควรจะใช้อินเตอร์เฟซแบบอนุกรมได้
2. ตัวสร้างควรเป็นแบบสาธารณะและไม่มีข้อโต้แย้ง (สิ่งที่คนอื่นเรียกว่า "ตัวสร้างแบบไม่มีอาร์กิวเมนต์")
3. ควรมี getter และ setters

ดีที่จะทราบว่าฟิลด์ serialVersionUID เป็นสิ่งสำคัญสำหรับการรักษาสถานะของวัตถุ โค้ดด้านล่างมีคุณสมบัติเป็นถั่ว:

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 คุณต้องสังเกตสิ่งต่าง ๆ ดังต่อไปนี้: JavaBean เป็นสิ่งที่มีแนวคิดและไม่สามารถแสดงคลาสของสิ่งที่เฉพาะเจาะจงได้

JavaBean เป็นเครื่องมือในการพัฒนาที่สามารถมองเห็นได้ในการดำเนินงานของส่วนประกอบซอฟต์แวร์ที่นำมาใช้ใหม่

JavaBean ขึ้นอยู่กับข้อมูลจำเพาะของ Sun JavaBeans และสามารถเป็นส่วนประกอบที่ใช้ซ้ำได้ คุณสมบัติที่ใหญ่ที่สุดคือการใช้งานซ้ำได้

ถั่วเป็นชั้น Java ที่มีชื่อวิธีการที่เป็นไปตามหลักเกณฑ์ Java Bean (ที่เรียกว่ารูปแบบการออกแบบ) สำหรับคุณสมบัติ , วิธีการและเหตุการณ์ที่เกิดขึ้น. ดังนั้นเมธอดสาธารณะใด ๆ ของคลาส bean ที่ไม่ได้เป็นส่วนหนึ่งของนิยามคุณสมบัติคือเมธอด bean ขั้นต่ำคลาส Java แม้จะมีคุณสมบัติเป็นสมาชิก แต่เพียงผู้เดียว (แน่นอนพร้อมกับประชาชนทะเยอทะยานและ setter ที่จำเป็น) วิธีสาธารณะในฐานะสมาชิกคนเดียวหรือเพียงหนึ่งวิธีการลงทะเบียนฟังเหตุการณ์สาธารณะเป็น Java bean นอกจากนี้คุณสมบัติสามารถเป็นคุณสมบัติแบบอ่านอย่างเดียว (มีเมธอด getter แต่ไม่มีเซ็ตเตอร์) หรือคุณสมบัติแบบเขียนอย่างเดียว (มีเมธอด setter เท่านั้น) Java bean ต้องเป็นคลาสพับลิกเพื่อให้สามารถเห็นได้โดยเครื่องมือ beanbox หรือคอนเทนเนอร์ใด ๆ ภาชนะจะต้องสามารถยกตัวอย่างได้ ดังนั้นจะต้องมีตัวสร้างสาธารณะด้วย ข้อกำหนด JavaBeansไม่ต้องการให้ bean มีตัวสร้างศูนย์ zero-args ที่ชัดเจนหรือเป็นค่าเริ่มต้นสำหรับคอนเทนเนอร์เพื่อสร้างอินสแตนซ์ หากคุณสามารถจัดเตรียมไฟล์ (พร้อมนามสกุล .ser) ที่มีอินสแตนซ์แบบอนุกรมเครื่องมือ beanbox สามารถใช้ไฟล์นั้นเพื่อสร้างอินสแตนซ์ของ bean ต้นแบบ มิฉะนั้น bean ต้องมีตัวสร้าง zero-args สาธารณะไม่ว่าจะชัดเจนหรือเป็นค่าเริ่มต้น

เมื่อ bean ถูกสร้างอินสแตนซ์ Java Bean API (java.beans. *) จะสามารถหยั่งรู้และเรียกวิธีการนั้น ๆ หากไม่มีคลาสที่ใช้อินเทอร์เฟซ BeanInfo หรือขยายการใช้งาน BeanInfo คลาส SimpleBeanInfo จะพร้อมใช้งานการวิปัสสนาเกี่ยวข้องกับการใช้การสะท้อน (การวิปัสสนาโดยปริยาย) เพื่อศึกษาวิธีการที่สนับสนุนโดยเป้าหมายถั่วแล้วใช้รูปแบบการออกแบบที่เรียบง่าย เมธอดเหล่านั้นที่สนับสนุนคุณสมบัติเหตุการณ์และเมธอดสาธารณะ หากคลาสที่ใช้อินเทอร์เฟซ BeanInfo (สำหรับ bean Foo นั้นจะต้องมีชื่อว่า FooBeanInfo) พร้อมใช้งาน API จะข้ามการวิปัสสนาแบบปริยายและใช้เมธอดสาธารณะ (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors () ข้อมูล. หากคลาสที่ขยาย SimpleBeanInfo พร้อมใช้งาน ขึ้นอยู่กับวิธีการใดสาธารณะของ SimpleBeanInfo (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()) จะถูกแทนที่มันจะใช้วิธีการแทนที่เหล่านั้นเพื่อรับข้อมูล สำหรับวิธีการที่ไม่ถูกแทนที่มันจะใช้ค่าปริยายที่สอดคล้องกันโดยปริยาย ถั่วจะต้องมีอินสแตนซ์ต่อไปแม้ว่าจะไม่มีการวิปัสสนาโดยปริยาย ดังนั้นความต้องการของผู้สร้าง zeri-args สาธารณะ แต่แน่นอนอินเตอร์เฟซแบบอนุกรมหรือภายนอกไม่จำเป็นต้องได้รับการยอมรับ อย่างไรก็ตามข้อมูลจำเพาะของ Java Bean กล่าวว่า 'เราต้องการให้มัน“ เล็กน้อย” สำหรับกรณีทั่วไปของ Bean Bean ตัวจิ๋วที่ต้องการรักษาสถานะภายในไว้และไม่ต้องการคิด' ดังนั้น beans ทั้งหมดต้องใช้อินเตอร์เฟสที่สามารถทำให้เป็นอนุกรมหรือ Externalizable ได้ โดยรวม, ข้อกำหนด JavaBeans ไม่ยากและรวดเร็วเกี่ยวกับสิ่งที่ถือถั่ว "การเขียนส่วนประกอบ JavaBeans นั้นง่ายมากคุณไม่จำเป็นต้องใช้เครื่องมือพิเศษและคุณไม่ต้องใช้ส่วนต่อประสานใด ๆ การเขียน beans เป็นเพียงเรื่องของการปฏิบัติตามข้อกำหนดในการเข้ารหัสบางอย่างที่คุณต้องทำคือทำให้คลาสของคุณดูเหมือน ถั่ว - เครื่องมือที่ใช้ถั่วจะสามารถจดจำและใช้ถั่วของคุณได้ " แม้แต่คลาสต่อไปนี้คือ Java Bean

public class Trivial implements java.io.Serializable {}

สมมติว่าคอนสตรัคถั่วมีพารามิเตอร์บางอย่าง สมมติว่าบางประเภทเป็นแบบง่าย คอนเทนเนอร์อาจไม่รู้ค่าที่จะกำหนดให้กับมัน แม้ว่าจะเป็นเช่นนั้นอินสแตนซ์ที่เกิดขึ้นอาจไม่สามารถใช้ซ้ำได้ อาจเหมาะสมถ้าผู้ใช้สามารถกำหนดค่า (ระบุค่า) โดยพูดคำอธิบายประกอบหรือไฟล์กำหนดค่า xml เช่นเดียวกับใน Spring beans และสมมติว่าพารามิเตอร์บางตัวเป็นคลาสหรือประเภทอินเตอร์เฟส อีกครั้งคอนเทนเนอร์อาจไม่รู้ค่าที่จะกำหนดให้กับมัน มันอาจสมเหตุสมผลถ้าผู้ใช้สามารถกำหนดค่า (ระบุวัตถุเฉพาะ) โดยพูดคำอธิบายประกอบหรือไฟล์การกำหนดค่า xml อย่างไรก็ตามแม้จะอยู่ใน Spring (ผ่านไฟล์การกำหนดค่า xml) การกำหนดวัตถุเฉพาะ (ด้วยชื่อสตริง) ให้กับตัวสร้างคอนสตรัคเตอร์ (แอตทริบิวต์หรือองค์ประกอบของข้อโต้แย้งคอนสตรัคเตอร์) ไม่ได้เป็นประเภทที่ปลอดภัย การอ้างอิงถึงฤดูใบไม้ผลิถั่วอื่น ๆ (เรียกว่าทำงานร่วมกัน; ผ่านองค์ประกอบในองค์ประกอบอาร์กิวเมนต์คอนสตรัค) เป็นพื้นฉีดพึ่งพาและ typesafe จึง เห็นได้ชัดว่าการพึ่งพา (collaborator bean) อาจมีคอนสตรัคเตอร์ที่มีพารามิเตอร์แบบฉีด การพึ่งพาการฉีดเหล่านั้น (IES) อาจมีคอนสตรัคเตอร์ที่มีพารามิเตอร์และอื่น ๆ ในสถานการณ์สมมตินี้ในที่สุดคุณจะต้องมีคลาสถั่ว (เช่น MyBean.class) ที่คอนเทนเนอร์สามารถสร้างอินสแตนซ์ได้โดยเพียงแค่เรียก MyBean ใหม่ () ก่อนที่มันจะสามารถสร้างถั่วที่ทำงานร่วมกันอื่น ๆ ผ่านการฉีดพึ่งพาผู้สร้าง bean ที่จะมีตัวสร้าง zero-args สาธารณะ สมมติว่าถ้าคอนเทนเนอร์ไม่สนับสนุนการขึ้นต่อกันของการพึ่งพาและ / หรือไม่อนุญาตให้กำหนดค่าแบบง่ายให้กับคอนสตรัคเตอร์ผ่านหมายเหตุประกอบหรือไฟล์ปรับแต่ง xml เช่นเดียวกับใน Spring ตัวสร้าง bean ไม่ควรมีพารามิเตอร์ แม้แต่แอปพลิเคชัน Spring beans อาจต้องการบาง bean เพื่อให้ตัวสร้าง zero-args คอนสตรัคต์ (เช่นในสถานการณ์ที่ Spring application ของคุณไม่มี bean ที่มีเพียงแค่ชนิดที่เรียบง่ายเป็นอาร์กิวเมนต์ตัวสร้าง)

ถั่วที่มีการจัดการ JSF ทำงานในเว็บคอนเทนเนอร์ สามารถกำหนดค่าได้ด้วยคำอธิบายประกอบ @ManagedBean หรือด้วยไฟล์ทรัพยากรการกำหนดค่าแอปพลิเคชัน managed-bean.xml อย่างไรก็ตามมันรองรับการฉีดผ่านการฉีดทรัพยากร (ไม่ใช่ประเภทที่ปลอดภัย) เท่านั้น ไม่เหมาะสำหรับการฉีดบนตัวสร้าง ข้อมูลจำเพาะ JSFต้องการให้ beans ที่ถูกจัดการต้องมีตัวสร้างอาร์กิวเมนต์ zero-อาร์กิวเมนต์ นอกจากนี้ยังกล่าวอีกว่า“ ในเวอร์ชั่น 2.3 ของข้อกำหนดนี้การใช้สิ่งอำนวยความสะดวกของถั่วที่มีการจัดการตามที่ระบุไว้ในส่วนนี้นั้นไม่ได้รับการสนับสนุนอย่างมาก วิธีการแก้ปัญหาแบบบูรณาการที่ดีขึ้นและร่วมกันมากขึ้นสำหรับการแก้ปัญหาเดียวกันคือการใช้ Contexts และ Dependency Injection (CDI) ตามที่ระบุใน JSR-365 "กล่าวอีกนัยหนึ่งคือการใช้ถั่วจัดการ CDI ซึ่งให้การพึ่งพา typeafe กับ Spring beans ข้อมูลจำเพาะ CDI ใช้ข้อมูลจำเพาะ Managed Beans ซึ่งใช้กับคอนเทนเนอร์ทั้งหมดของแพลตฟอร์ม JEE ไม่ใช่เฉพาะเว็บเทียร์ดังนั้นเว็บคอนเทนเนอร์ต้องใช้ข้อกำหนด CDI

นี่คือสารสกัดจากข้อมูลจำเพาะของถั่วที่จัดการ “ Managed Beans เป็นวัตถุที่มีการจัดการตู้คอนเทนเนอร์โดยมีข้อกำหนดขั้นต่ำหรือที่รู้จักกันภายใต้ตัวย่อ“ POJOs” (วัตถุ Java เก่าธรรมดา) …พวกมันสามารถถูกมองว่าเป็นรุ่นที่ได้รับการพัฒนาแพลตฟอร์ม Java EE ของส่วนประกอบ JavaBeans รุ่นที่พบในแพลตฟอร์ม Java SE ... ผู้อ่านจะไม่พลาดว่า Managed Beans มีสิ่งอำนวยความสะดวกที่มีชื่อเหมือนกันที่พบในเทคโนโลยี JavaServer Faces (JSF) …ถั่วที่ได้รับการจัดการตามที่นิยามไว้ในข้อกำหนดนี้แสดงถึงลักษณะทั่วไปของ JSF; โดยเฉพาะ Managed Beans สามารถใช้ได้ทุกที่ในแอปพลิเคชัน Java EE ไม่ใช่เฉพาะในเว็บโมดูล ตัวอย่างเช่นในโมเดลคอมโพเนนต์พื้นฐาน Managed Beans ต้องระบุ constructor ที่ไม่มีอาร์กิวเมนต์ แต่เป็นข้อมูลจำเพาะที่สร้างบน Managed Beans เช่น CDI (JSR-299) สามารถผ่อนคลายความต้องการนั้นและอนุญาตให้ถั่วที่มีการจัดการเพื่อให้ตัวสร้างที่มีลายเซ็นที่ซับซ้อนมากขึ้นตราบใดที่พวกเขาปฏิบัติตามกฎบางอย่างที่กำหนดไว้ ... ถั่วที่ได้รับการจัดการจะต้องไม่: ชั้นสุดท้าย, นามธรรมระดับ . Managed Bean อาจไม่สามารถทำให้เป็นอนุกรมได้ซึ่งแตกต่างจากองค์ประกอบ JavaBean ทั่วไป” ดังนั้นข้อมูลจำเพาะสำหรับถั่วที่มีการจัดการหรือที่รู้จักกันในชื่อ POJOs หรือถั่ว POJO อนุญาตให้มีการขยายใน CDI

ข้อมูลจำเพาะ CDIกำหนดถั่วที่ถูกจัดการอีกครั้งเป็น: เมื่อรันใน Java EE คลาส Java ระดับบนสุดเป็นถั่วที่ถูกจัดการถ้าตรงตามข้อกำหนด:

•มันไม่ได้เป็นชั้นใน •เป็นคลาสที่ไม่เป็นนามธรรมหรือมีคำอธิบายประกอบ @Decorator •ไม่ใช้ javax.enterprise.inject.spi.Extension •ไม่ได้ใส่คำอธิบายประกอบ @Vetoed หรือในแพ็คเกจที่กำกับด้วย @Vetoed •มันมี Constructor ที่เหมาะสมเช่น: Class มี Constructor ที่ไม่มีพารามิเตอร์หรือคลาสประกาศ Constructor ที่ใส่คำอธิบายประกอบ @Inject

คลาส Java ทั้งหมดที่ตรงตามเงื่อนไขเหล่านี้คือ beans ที่ถูกจัดการดังนั้นจึงไม่จำเป็นต้องมีการประกาศพิเศษเพื่อกำหนด bean ที่ถูกจัดการ หรือ

หากถูกกำหนดให้เป็น bean ที่ถูกจัดการโดยข้อมูลจำเพาะ Java EE อื่นใดและหาก

•ไม่ได้ใส่คำอธิบายประกอบด้วยคำอธิบายประกอบที่กำหนดโดย EJB หรือประกาศเป็นคลาส EJB bean ใน ejb-jar.xml

ซึ่งแตกต่างจาก Spring beans ไม่สนับสนุนตัวสร้างที่มีประเภทง่าย ๆ ซึ่งอาจเป็นไปได้หากรองรับการกำหนดค่าด้วยไฟล์ xml config เช่นใน Spring หรือคำอธิบายประกอบใด ๆ

EJB รันในคอนเทนเนอร์ EJB ใช้สเปคพูดว่า:“ องค์ประกอบของเซสชั่นบีนคือ Managed Bean”“ คลาสจะต้องมีตัวสร้างสาธารณะที่ไม่มีอาร์กิวเมนต์” มันบอกว่าสำหรับทั้งเซสชั่นบีนและถั่วที่ขับเคลื่อนด้วยข้อความนอกจากนี้กล่าวว่า“ เซสชั่นบีนคลาสคือ ไม่จำเป็นต้องใช้อินเทอร์เฟซ SessionBean หรืออินเทอร์เฟซแบบอนุกรมได้” ด้วยเหตุผลเดียวกับถั่ว JSF การฉีดพึ่งพา EJB3 นั้นเป็นการฉีดทรัพยากรโดยทั่วไปถั่ว JSF ไม่สนับสนุนคอนสตรัคเตอร์ที่มีข้อโต้แย้งนั่นคือผ่านการฉีดพึ่งพาอย่างไรก็ตามถ้าคอนเทนเนอร์ EJB ใช้ CDI“ ทางเลือก: คลาสอาจมี คอนสตรัคเพิ่มเติมข้อเขียนที่มีคำอธิบายประกอบฉีด“ก็กล่าวว่าสำหรับทั้งถั่วครั้งและถั่วข้อความที่ขับเคลื่อนด้วยเพราะ“เป็น EJB บรรจุลงในที่เก็บ CDI ถั่วและไม่ได้มีคำอธิบายประกอบกับคำอธิบายประกอบ javax.enterprise.inject.Vetoed ถือเป็น CDI ที่เปิดใช้งาน ถั่ว."

ในทางปฏิบัติถั่วเป็นเพียงวัตถุที่สะดวกในการใช้ การจัดลำดับให้หมายถึงการคงอยู่ได้อย่างง่ายดาย (เก็บในรูปแบบที่กู้คืนได้ง่าย)

การใช้งานทั่วไปของถั่วในโลกแห่งความจริง:

• อ็อบเจ็กต์ที่นำกลับมาใช้ใหม่ได้ง่าย POJO (อ็อบเจ็กต์ Java เก่าธรรมดา)
• วัตถุที่มองเห็น
• ฤดูใบไม้ผลิใช้ถั่วสำหรับวัตถุที่จะจับ (เช่นผู้ใช้วัตถุที่จะต้องต่อเนื่องในเซสชั่น)
• EJB (ถั่วองค์กร Java) วัตถุที่ซับซ้อนมากขึ้นเช่นถั่ว JSF (JSF เป็นเทคโนโลยีที่ล้าสมัยเก่ามาก) หรือถั่ว JSP

ดังนั้นในความเป็นจริงถั่วเป็นเพียงการประชุม / มาตรฐานจะคาดหวังบางสิ่งจากวัตถุ Java ที่มันจะทำงาน (serialization) และให้วิธีการบางอย่างในการเปลี่ยนแปลง (setters สำหรับคุณสมบัติ) ในบางวิธี

วิธีใช้พวกเขาเป็นเพียงสิ่งประดิษฐ์ของคุณ แต่เป็นกรณีที่พบบ่อยที่สุดที่ฉันสมัครเป็นสมาชิกข้างต้น