JavaBean이란 정확히 무엇입니까?
저는 "Bean"이 속성 및 getters/setters를 가진 Java 클래스라고 생각합니다.
제가 알기로는 C와 맞먹습니다.struct.진짜예요?
또한, 실제 구문적 차이가 있나요?JavaBean그리고 단골class?
어떤 특별한 정의나Interface?
기본적으로 왜 이런 용어가 있는 거죠?
또, 이 기능은Serializable인터페이스 평균?
JavaBean은 표준일 뿐입니다.
- 모든 속성은 비공개입니다(getter/setter 사용).
- 논쟁 없는 퍼블릭 컨스트럭터
- 를 실장합니다.
바로 그겁니다.그냥 관례일 뿐이야하지만 많은 도서관들이 그것에 의존하고 있다.
에 대해서SerializableAPI 매뉴얼에서 참조해 주세요.
클래스의 시리얼화는, java.io 를 실장하는 클래스에 의해서 유효하게 됩니다.시리얼 대응 인터페이스.이 인터페이스를 실장하지 않는 클래스에서는, 스테이트의 시리얼화 또는 시리얼화 해제는 행해지지 않습니다.직렬화 가능한 클래스의 모든 하위 유형은 그 자체로 직렬화 가능합니다.시리얼라이제이션인터페이스에는 메서드나 필드가 없으며 시리얼라이제이션이 가능한 의미만을 식별하기 위한 것입니다.
즉, 직렬화 가능한 오브젝트는 스트림에 쓸 수 있습니다.따라서 파일, 오브젝트 데이터베이스 등 모든 것에 쓸 수 있습니다.
또한 JavaBean과 다른 클래스 사이에는 구문적인 차이가 없습니다. 클래스는 표준을 따르는 경우 JavaBean입니다.
이 표준에서는 라이브러리가 미리 정의된 방식으로 사용자가 정의한 클래스 인스턴스를 사용하여 프로그래밍 방식으로 작업을 수행할 수 있기 때문에 이 용어를 사용할 수 있습니다.예를 들어, 라이브러리가 사용자가 전달한 개체를 스트리밍하려는 경우, 해당 개체는 직렬화 가능하기 때문에 스트리밍할 수 있습니다(라이브러리에서 개체가 적절한 JavaBeans여야 한다고 가정함).
특별하게 들리도록 하기 위한 용어가 있습니다.현실은 결코 그렇게 신비롭지 않다.
기본적으로 "Bean(Bean)"
- 는 시리얼 가능한 오브젝트(즉, 실장 및 올바르게 실행)입니다.
- 에는 getters와 setters가 특정 이름의 메서드인 "속성"이 있습니다(예를 들어,
getFoo()"Foo" 속성의 getter입니다. - 에는 퍼블릭 제로 레이스 컨스트럭터가 있습니다(따라서 자유롭게 작성하거나 속성을 설정하여 구성할 수 있습니다).
에 대해서는Serializable: 이는 "marker interface"(함수를 선언하지 않는 인터페이스)에 불과하며, 구현 클래스가 "serialization"(직렬화)에 동의함을 Java에 알립니다.이것은 인스턴스를 바이트 스트림으로 변환하는 프로세스입니다.이러한 바이트는 파일에 저장하거나 네트워크 연결 등을 통해 전송할 수 있으며, JVM(적어도 오브젝트의 유형을 아는 것)이 나중에 오브젝트를 재구성할 수 있는 충분한 정보를 가지고 있습니다.어플리케이션의 다른 인스턴스나 다른 머신에서도 마찬가지입니다.
물론, 그렇게 하기 위해서, 학급은 특정한 제한을 준수해야 한다.그 중 가장 중요한 것은 모든 인스턴스 필드가 기본 유형(int, bool 등), 직렬화 가능하거나 다음과 같이 표시된 일부 클래스의 인스턴스여야 한다는 것입니다.transient자바가 그것들을 포함시키려 하지 않도록 하기 위해서입니다.(물론 이것은transient들판은 강을 건너는 여정에서 살아남지 못할 것이다.의 클래스transient필요한 경우 필드를 다시 초기화할 수 있도록 준비해야 합니다.)
이러한 제한을 준수할 수 없는 클래스는 구현하지 않아야 합니다.Serializable(IIRC, Java 컴파일러는 이를 허용하지 않습니다.)
JavaBeans는 매우 단순한 코딩 규칙을 따르는 Java 클래스입니다.네가 해야 할 일은 하기만 하면 된다
- 를 실장하다
java.io.Serializableinterface - 오브젝트 상태를 저장합니다. - 공용 빈 인수 생성자 사용 - 개체를 인스턴스화합니다.
- public getter/setter 메서드 제공 - 개인 변수(속성)의 값을 가져오고 설정합니다.
JavaBeans 속성
JavaBean은 특정 프로그래밍 규칙을 충족하는 Java 객체입니다.
JavaBean 클래스는 다음 중 하나를 구현해야 합니다.
Serializable또는ExternalizableJavaBean 클래스에는 no-arg 생성자가 있어야 합니다.
모든 JavaBean 속성에는 퍼블릭세터 및 getter 메서드가 있어야 합니다.
모든 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 를 Import 합니다.시리얼화 가능
시리얼화에 대해서는, 메뉴얼을 참조해 주세요.
2. 개인 분야
외부 클래스가 이러한 필드를 쉽게 수정할 수 없도록 하려면 필드를 비공개로 해야 합니다.이러한 필드에 직접 액세스하는 대신 일반적으로 getter/setter 메서드가 사용됩니다.
(3) 시공자
논쟁 없는 공공 건설업자.
4. 게터/세터
개인 필드에 액세스 및 수정하기 위한 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 Bean은 코드와 작업 방식을 줄이기 위해 사용됩니다.
Java Bean은 Java EE 전체에서 런타임 검색 및 액세스를 위한 범용 계약으로 사용됩니다.예를 들어 JavaServer Pages(JSP)에서는 Java Bean을 페이지 간 또는 서블릿과 JSP 간의 데이터 전송 개체로 사용합니다.Java EE의 JavaBeans 활성화 프레임워크는 Java Bean을 사용하여 MIME 데이터 유형 지원을 Java EE에 통합합니다.Java EE Management API는 Java EE 환경에서 관리할 리소스 계장의 기반으로 JavaBeans를 사용합니다.
시리얼라이제이션에 대해서:
오브젝트 시리얼라이제이션에서 오브젝트는 오브젝트의 데이터뿐만 아니라 오브젝트의 유형과 오브젝트에 저장되어 있는 데이터 유형에 대한 정보를 포함하는 일련의 바이트로 표현될 수 있습니다.
시리얼화된 오브젝트는 파일에 쓴 후 파일에서 읽어들이고 시리얼화 해제할 수 있습니다.즉, 오브젝트와 그 데이터를 나타내는 타입 정보와 바이트를 사용하여 오브젝트를 메모리로 다시 만들 수 있습니다.
여러 서버 간에 프로젝트를 전개할 경우 콩이 유지되고 서버 간에 전송되기 때문에 시리얼라이제이션이 편리합니다.
JavaBeans는 표준이며 기본 구문 요건은 다른 답변에 의해 명확하게 설명되어 있습니다.
그러나 IMO는 단순한 구문 표준이 아닙니다.JavaBeans의 진정한 의미 또는 의도된 용도는 표준과 관련된 다양한 도구 지원과 함께 코드 재사용 및 컴포넌트 기반 소프트웨어 엔지니어링을 용이하게 하는 것입니다.즉, 개발자는 코드를 작성하지 않고도 기존 컴포넌트(클래스)를 조립하여 애플리케이션을 구축할 수 있습니다(또는 약간의 글루 코드만 작성하면 됩니다).안타깝게도 이 기술은 업계에서 충분히 평가되지 않고 활용도가 낮습니다. 이는 이 스레드의 답변에서 알 수 있습니다.
JavaBeans에 대한 Oracle의 튜토리얼을 읽으면 더 잘 이해할 수 있습니다.
콩 컨셉에 대한 약간의 배경/업데이트입니다.다른 많은 답변들은 실제로 무엇인지는 가지고 있지만 그 이유는 많지 않다.
이들은 일찍이 Java에서 GUI 구축의 일환으로 개발되었습니다.이들은 도구를 분리하기 쉬운 패턴을 따라 Bean의 속성을 편집할 수 있도록 속성 패널을 만듭니다.일반적으로 Bean 속성은 화면의 컨트롤을 나타냅니다(x,y,width,높이,텍스트 등).
또한 강력한 유형의 데이터 구조라고 생각할 수도 있습니다.
시간이 지남에 따라 동일한 유형의 액세스를 사용하는 많은 도구(데이터베이스에 데이터 구조를 유지하기 위한 휴지 상태 등)에 유용하게 쓰이게 되었습니다.
툴이 진화함에 따라 설정자/게터 이름을 분리하는 것에서 벗어나 주석으로 이동하게 되었습니다.현재 대부분의 시스템은 콩을 필요로 하지 않으며, 주석을 단 속성을 가진 임의의 오래된 Java 오브젝트를 사용하여 조작 방법을 지시할 수 있습니다.
이제 콩은 주석이 달린 속성 볼로 보입니다. 콩은 실제로 주석에만 유용합니다.
콩 자체는 건강에 좋지 않다.모든 속성을 외부 조작에 노출하기 때문에 캡슐화를 파괴합니다.또한 사용함에 따라 콩 내부에 코드를 작성하는 대신 외부에서 콩을 조작하는 코드를 작성하는 경향이 있습니다(절대 필요조건은 아닙니다). ('객체에 값을 묻지 말고 객체에 무언가를 요구하세요'를 위반합니다).u") 최소한의 게터(getter)와 함께 주석이 달린 POJO를 사용하면 캡슐화를 복원하고 불변의 가능성을 가진 훨씬 더 많은 OO를 사용할 수 있습니다.
그런데 이 모든 일들이 일어나고 있을 때 누군가가 이 개념을 Enterprise Java Beans라고 불리는 것으로 확장했습니다.이거는...그리고 너무 복잡해서 많은 사람들이 빈의 개념 전체를 이해하지 못하고 더 이상 사용하지 않게 되었다.이것이 POJO라고 불리는 콩을 일반적으로 듣는 이유라고 생각합니다(모든 Java 오브젝트가 POJO이기 때문에 이것은 기술적으로 문제가 없지만 POJO라고 하는 말을 들으면 콩 패턴을 따르는 것을 가장 많이 생각하고 있습니다).
Wikipedia에 따르면:
클래스에는 (인수가 없는) 공용 기본 생성자가 있어야 합니다.이를 통해 편집 및 활성화 프레임워크 내에서 쉽게 인스턴스화할 수 있습니다.
클래스 속성은 표준 명명 규칙에 따라 get, set, is(get 대신 boolean 속성에 사용할 수 있음) 및 기타 메서드(일명 접근자 메서드 및 뮤테이터 메서드)를 사용하여 액세스할 수 있어야 합니다.이를 통해 프레임워크 내에서 콩 상태를 쉽게 자동 검사하고 업데이트할 수 있습니다. 프레임워크의 대부분은 다양한 유형의 속성에 대한 커스텀 에디터를 포함합니다.설정자에는 인수를 하나 이상 지정할 수 있습니다.
클래스는 직렬화할 수 있어야 합니다.이를 통해 애플리케이션 및 프레임워크는 VM 및 플랫폼에 의존하지 않는 방식으로 Bean의 상태를 안정적으로 저장, 저장 및 복원할 수 있습니다.
상세한 것에 대하여는, 이 링크를 참조해 주세요.
질문의 두 번째 부분에 대해, 시리얼화는 객체를 부호 있는 바이트의 시퀀스로 저장하기 위해 사용되는 지속성 메커니즘입니다.격식을 차리지 않고 오브젝트 상태를 저장하기 때문에 나중에 역직렬화를 통해 취득할 수 있습니다.
Java Bean은 다음 규칙을 따라야 하는 Java 클래스(개념)입니다.
- 인수 없는 생성자가 있어야 합니다.
- 직렬로 만들 수 있어야 합니다.
- getter 및 setter 메서드로 알려진 속성 값을 설정하고 가져오는 메서드를 제공해야 합니다.
재사용 가능한 소프트웨어 컴포넌트입니다.여러 개체를 하나의 개체로 캡슐화할 수 있으므로 여러 위치에서 동일한 개체에 액세스할 수 있습니다. 이는 코드를 쉽게 유지 관리하기 위한 단계입니다.
bean은 속성, 메서드 및 이벤트에 대한 JavaBean 가이드라인(설계 패턴이라고도 함)을 따르는 메서드 이름을 가진 Java 클래스입니다.따라서 속성 정의에 포함되지 않은 빈 클래스의 퍼블릭 메서드는 모두 빈 메서드입니다.최소한 Java 클래스는 속성을 유일한 멤버(물론 public getter와 setter를 동반해야 함)로서도 public 메서드를 유일한 멤버로 하거나 하나의 public 이벤트청취자 등록 메서드를 Java bean으로 합니다.또한 속성은 읽기 전용 속성(getter 메서드는 있지만 setter는 없음) 또는 쓰기 전용 속성(setter 메서드만 있음) 중 하나입니다.Java bean은 beanbox 도구 또는 컨테이너에 표시하려면 퍼블릭클래스로 해야 합니다.컨테이너는 이를 인스턴스화할 수 있어야 하며, 따라서 공용 컨스트럭터도 있어야 합니다.JavaBeans 사양에서는 컨테이너가 이를 인스턴스화하기 위해 명시적이든 기본적이든 퍼블릭제로아그 컨스트럭터를 가질 필요가 없습니다.시리얼라이즈된 인스턴스를 포함하는 파일(확장자 .ser)을 제공할 수 있는 경우 beanbox 도구는 이 파일을 사용하여 bean 프로토타입을 인스턴스화할 수 있습니다.그렇지 않으면 콩에는 명시적 또는 기본값 중 하나의 퍼블릭제로아그 컨스트럭터가 필요합니다.
빈이 인스턴스화되면 JavaBean API(java.beans)가 생성됩니다.*)는, 그 내용을 재검토해, 거기에 관한 메서드를 호출할 수 있습니다.인터페이스 BeanInfo를 구현하거나 BeanInfo를 확장하는 클래스를 사용할 수 없는 경우 Introspection에서는 대상 bean에서 지원되는 메서드를 리플렉션(암묵적인 자기성찰)을 사용하여 학습한 후 이러한 메서드에서 단순한 설계 패턴(가이드라인)을 적용하여 속성, 이벤트, 이벤트를 추론합니다.및 퍼블릭 메서드가 지원됩니다.인터페이스 BeanInfo를 구현하는 클래스(빈 Foo의 경우 FooBeanInfo로 명명해야 함)를 사용할 수 있는 경우 API는 암묵적인 인스펙션을 무시하고 이 클래스의 퍼블릭메서드(getPropertyDescriptor(), getMethodDescriptors(), getEventSetDescriptors)를 사용하여 정보를 가져옵니다.SimpleBeanInfo 확장 클래스를 사용할 수 있는 경우, 오버라이드되는 SimpleBeanInfo 퍼블릭메서드(getPropertyDescriptor(), getMethodDescriptors())에 따라 오버라이드되지 않은 메서드를 사용하여 정보를 가져옵니다.오버라이드되지 않은 메서드에 대해서는 기본 사양이 지정됩니다.콩은 암묵적인 자기 성찰이 이루어지지 않더라도 인스턴스화 되어야 한다.따라서 퍼블릭 제로 아그 컨스트럭터의 요건은 다음과 같습니다.물론 시리얼 가능 인터페이스 또는 외부 지원 인터페이스를 인식할 필요는 없습니다.그러나 Java Bean 사양에는 '우리는 단순히 내부 상태를 저장하기를 원하며 그것에 대해 생각하고 싶지 않은 작은 Bean의 일반적인 경우에도 "사소한" 것을 원합니다'라고 쓰여 있습니다.따라서 모든 콩은 Serializable 또는 Externalizable 인터페이스를 구현해야 합니다.
전체적으로 JavaBeans 사양은 콩을 구성하는 것에 대해 딱딱하고 빠르지 않습니다."JavaBeans 컴포넌트를 쓰는 것은 놀라울 정도로 쉽습니다.특별한 툴이나 인터페이스를 실장할 필요는 없습니다.콩을 쓰는 것은 단순히 특정 코딩 규칙을 따르는 문제입니다.교실 전체를 콩처럼 보이게 하기만 하면 됩니다.콩을 사용하는 툴은 콩을 인식하고 사용할 수 있습니다."일반적으로 다음 클래스도 자바 빈입니다.
public class Trivial implements java.io.Serializable {}
콩은 아래 설명된 Java SE 버전(JavaBeans)의 Java EE 버전입니다.이러한 설명은 위에서 설명한 것과 같은 근본적인 아이디어를 더욱 잘 보여줍니다.
봄콩
예를 들어, 콩 건설업자는 몇 가지 매개변수를 가지고 있다.간단한 유형도 있다고 가정합니다.컨테이너는 할당해야 할 값을 모를 수 있습니다. 할당하더라도 결과 인스턴스를 재사용할 수 없습니다.사용자가 Spring beans와 같이 주석 또는 xml Configuration파일을 사용하여 설정(값 지정)할 수 있는 경우에만 의미가 있을 수 있습니다.또한 일부 파라미터가 클래스 또는 인터페이스 유형이라고 가정합니다.다시 말하지만 컨테이너는 자신에게 할당해야 할 값을 모를 수 있습니다.사용자가 주석 또는 xml 구성 파일을 사용하여 구성(특정 개체 지정)할 수 있는 경우에만 의미가 있을 수 있습니다.단, (xml 컨피규레이션파일을 통해) 스프링에서도 특정 오브젝트(문자열 이름 포함)를 컨스트럭터 인수(아트리뷰트 또는 컨스트럭터 인수의 요소)에 할당하는 것은 타이프세이프하지 않습니다.기본적으로는 리소스 주입과 같습니다.다른 스프링 콩(collaborator, constructor 인수 요소의 요소 경유)에 대한 참조는 기본적으로 의존성 주입이므로 쉽게 입력할 수 있습니다.종속성(콜라보레이터 빈)에는 매개 변수가 주입된 생성자가 있을 수 있으며, 종속성이 주입된 생성자에는 매개 변수가 포함된 생성자가 있을 수 있습니다.이 시나리오에서는 최종적으로 컨테이너가 컨스트럭터에 의존성 주입을 통해 다른 콜라보레이션빈을 구축하기 전에 단순히 새로운 MyBean()을 호출함으로써 인스턴스화할 수 있는 빈 클래스(예를 들어 MyBean.class)가 필요합니다.따라서 빈이 퍼블릭제로아그 컨스트럭터를 가져야 합니다.컨테이너가 종속성 주입을 지원하지 않거나 Spring과 같이 일부 주석 또는 xml 구성 파일을 통해 단순 유형 값을 컨스트럭터에 할당할 수 없는 경우 bean 컨스트럭터에는 매개 변수가 없어야 합니다.Spring beans 어플리케이션에서도 퍼블릭 제로 아그 컨스트럭터를 사용하기 위해서는 콩이 필요합니다(예를 들어 Spring 어플리케이션에 컨스트럭터 인수로서 단순한 타입의 콩이 없는 시나리오).
JSF 관리 콩
JSF 관리 대상 콩은 웹 컨테이너에서 실행됩니다.@ManagedBean 주석 또는 응용 프로그램 구성 리소스 파일 managed-bean.xml을 사용하여 구성할 수 있습니다.그러나 리소스 주입(typesafe가 아닌)을 통한 주입만 지원합니다. 컨스트럭터 주입에는 적합하지 않습니다.JSF 사양에서는 관리 대상 콩에 퍼블릭제로 인수 컨스트럭터가 있어야 합니다.또, 「이 사양의 버전 2.3에서는, 이 항에서 규정하는 관리 콩 설비의 사용은 강하게 권장되지 않습니다.JSR-365에 기재되어 있는 콘텍스트와 의존성 주입(CDI)을 사용하는 것이, 같은 문제를 해결하기 위한 보다 뛰어난 통합 솔루션입니다.즉, CDI는 봄콩과 같은 건설업자에게 타입 세이프한 의존성 주입을 제공하는 콩을 관리했다.CDI 사양은 Managed Beans 사양을 채택하고 있으며 이는 웹 계층뿐만 아니라 JEE 플랫폼의 모든 컨테이너에 적용됩니다.따라서 웹 컨테이너는 CDI 사양을 구현해야 합니다.
관리 대상 콩
Managed Bean 사양에서 발췌한 "Managed Beans는 최소한의 요건을 갖춘 컨테이너 관리 객체입니다.또한 "POJOs"(Plain Old Java Objects)라는 약자로 알려져 있습니다.이러한 객체는 Java SE 플랫폼에 있는 Java EE 플랫폼 확장 버전의 Java Beans 컴포넌트 모델로 볼 수 있습니다.Managed Bean은 Java Server Faces(JSF) 테크놀로지에 있는 동명의 설비에 선구자가 있다는 것을 독자는 쉽게 알 수 있습니다.이 사양에서 정의된 관리 빈은 JSF에서 발견된 관리 빈의 일반화를 나타냅니다. 특히 관리 빈은 웹 모듈뿐만 아니라 Java EE 응용 프로그램의 모든 위치에서 사용할 수 있습니다.예를 들어 기본 컴포넌트 모델에서는 Managed Beans가 인수 없는 컨스트럭터를 제공해야 하지만 CDI(JSR-299)와 같은 Managed Beans를 기반으로 하는 사양은 해당 요건을 완화하고 Managed Bean이 잘 정의된 규칙을 따르는 한 보다 복잡한 시그니처를 컨스트럭터에 제공할 수 있도록 합니다.Managed Bean은 최종 클래스, 추상 클래스, 비정적 내부 클래스일 수 없습니다.Managed Bean은 일반 JavaBean 컴포넌트와 달리 시리얼화할 수 없습니다.따라서 관리 대상 콩(POJO 또는 POJO 콩이라고도 함)의 사양에서는 CDI와 같이 확장이 가능합니다.
CDI 빈즈
CDI 사양에서는 관리 대상 콩을 다음과 같이 정의합니다.Java EE에서 실행할 때 최상위 Java 클래스는 다음 요구 사항을 충족하는 경우 관리되는 빈입니다.
• 내부 클래스가 아닙니다.• 비추상 클래스이거나 @Decorator에 주석이 붙어 있습니다.• javax.enterprise는 구현하지 않습니다.inject.spi를 선택합니다.내선번호• @Vetoed 또는 @Vetoed 패키지에 주석이 없습니다.• 적절한 생성자가 있습니다. 클래스에 매개 변수가 없는 생성자가 있거나 클래스에 주석이 달린 생성자를 선언합니다. @Inject
이러한 조건을 충족하는 Java 클래스는 모두 관리 대상 빈이므로 관리 대상 빈을 정의하기 위해 특별한 선언이 필요하지 않습니다.또는
다른 Java EE 규격에 의해 관리 대상 빈으로 정의되어 있는 경우 및
• EJB 구성 요소를 정의하는 주석을 달지 않거나 ejb-jar.xml에서 EJB bean 클래스로 선언하지 않는다.
Spring beans와 달리 단순 유형의 컨스트럭터를 지원하지 않습니다. 이는 Spring과 같은 xml 구성 파일이나 주석을 사용한 구성을 지원한다면 가능할 수 있습니다.
EJB
EJB는 EJB 컨테이너 내에서 실행됩니다.이 사양에는 "세션빈 컴포넌트는 관리 대상 빈입니다."라고 쓰여 있습니다. "클래스에는 인수를 사용하지 않는 퍼블릭컨스트럭터가 있어야 합니다."라고 되어 있습니다.세션빈과 메시지 구동 빈 모두입니다.또한 "SessionBean 인터페이스 또는 Serializable 인터페이스를 구현하기 위해 session bean 클래스는 필요하지 않습니다."라고 되어 있습니다.JSF 콩과 같은 이유로, EJB3 의존성 주입은 기본적으로 리소스 주입이기 때문에, JSF 콩은 인수가 있는, 즉 의존성 주입을 통한 생성자를 지원하지 않습니다.그러나 EJB 컨테이너가 CDI를 구현하는 경우, "선택 사항:클래스에는 Inject 주석이 달린 추가 컨스트럭터가 있을 수 있습니다.이는 세션 빈과 메시지 구동 빈 모두에 대해 "EJB가 CDI 빈 아카이브에 패키지되어 javax.enterprise에 주석을 달지 않기 때문입니다.주석은 CDI 사용 빈으로 간주됩니다."
이들은 직렬화 가능하며 인수 생성자가 0이며 getter 및 setter 메서드를 사용하여 속성에 액세스할 수 있습니다."Bean"이라는 이름은 Java용 재사용 가능한 소프트웨어 구성 요소를 만드는 것을 목표로 하는 이 표준을 포함하기 위해 붙여졌습니다.위키피디아에 따르면.
애플리케이션의 백본을 구성하고 Spring IoC 컨테이너에 의해 관리되는 개체를 bean이라고 합니다.빈은 Spring IOC 컨테이너에 의해 인스턴스화, 조립 및 관리되는 객체입니다.그렇지 않으면 응용 프로그램에서 빈은 여러 개체 중 하나에 불과합니다.Spring IOC에 따르면
Java Bean은 다음 3가지 기준을 충족하는 Java 클래스입니다.
- 시리얼 가능한 인터페이스(마커 인터페이스)를 실장할 필요가 있습니다.
- 생성자는 공개적이어야 하며 인수(다른 사람이 "no-arg 생성자"라고 부르는 것)가 없어야 합니다.
- getter와 setter가 있어야 합니다.
serialVersion 주의사항UID 필드는 오브젝트 상태를 유지하기 위해 중요합니다.
다음 코드는 bean으로 간주됩니다.
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;
}}
JavaBeans에 대한 인수 없는 생성자 요건이 있다는 것은 위에서 6번 또는 7번 반복되었습니다.
이는 잘못된 것이며, 특히 Java Spring과 관련하여 그러한 요구사항은 없습니다.
JavaBeans API(https://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/))를 기술하는 사양 버전(1.01)에서도 이 요건에 대한 언급은 없습니다.게다가 이 사양에서는, 「null constructor」에 대해서는, 「각 커스터마이저는 null constructor를 가질 필요가 있습니다.」 「각 Property Editor에는 null constructor를 가질 필요가 있습니다.」라고 하는 2회만 언급하고 있습니다.
따라서 스펙의 작성자가 "null constructor"라는 용어를 모르거나 사용하려 하지 않는 것처럼 보이지만 JavaBeans에 대해서는 이에 대한 언급이 없습니다.
JavaBean을 이해하려면 다음 사항에 유의해야 합니다.
JavaBean은 개념적인 것으로 특정 항목의 클래스를 나타낼 수 없습니다.
JavaBean은 재사용 가능한 소프트웨어 컴포넌트의 조작으로 시각화할 수 있는 개발 도구입니다.
JavaBean은 Sun JavaBeans 사양을 기반으로 하며 재사용 가능한 구성 요소가 될 수 있습니다.가장 큰 특징은 재사용성입니다.
POJO(일반 Java 객체): POJO는 Java 언어에 의해 강제된 것 이외에는 제한이 없는 일반적인 Java 객체입니다.
시리얼화:오브젝트 상태를 저장하고 네트워크를 통해 전송하기 위해 사용됩니다.오브젝트 상태를 바이트 스트림으로 변환합니다.바이트 스트림에서 Java 개체를 역직렬화라고 하는 프로세스를 통해 다시 만들 수 있습니다.
학급에 java.io을 구현합니다.시리얼 대응 인터페이스.또한 ObjectOutputStream 클래스의 writeObject() 메서드를 사용하여 Serialization을 실행합니다.
JavaBean 클래스:일부 제한(또는 관례)이 있는 특수 POJO입니다.
- 시리얼라이제이션의 실장
- 퍼블릭 no-arg 컨스트럭터 보유
- 모든 속성은 퍼블릭게터 및 세터 메서드로 비공개입니다.
Spring과 같은 많은 프레임워크는 JavaBean 개체를 사용합니다.
C/Golang을 잘 아시는 분들은 C빈이나 Go bean이 잘 안 들리실 거예요.struct복잡한 OOP 키워드를 작성하지 않고 구조 유형을 쉽게 정의할 수 있는 키워드입니다.
type User struct {
Name string
Age int
}
var user User
user.Name = "name"
user.Age = 18
var bytes, err = json.Marshal(user)
자바의 실수입니다.struct유형 및 개발자들은 이러한 심각한 부족을 발견합니다.
그리고 자바빈은 만들어야 할 또 다른 지루한 규칙으로 발명되었다.class척하는struct에디터나 컴파일러가 클래스 멤버에 대한 안전하지 않은 접근에 대해 울거나 소리를 지르지 않습니다.
빈 응용 프로그램의 백본을 구성하고 스프링 IOC 컨테이너에 의해 관리되는 개체를 빈이라고 합니다.빈은 Spring IOC 컨테이너에 의해 인스턴스화, 조립 및 관리되는 객체입니다.이러한 콩은 컨테이너에 제공하는 구성 메타데이터를 사용하여 생성됩니다.
Java-Beans를 이해하려면 먼저 소프트웨어 컴포넌트를 이해해야 합니다.
소프트웨어 컴포넌트
소프트웨어 컴포넌트는 특정 작업을 실행하는 응용 프로그램의 일부입니다.소프트웨어 컴포넌트는 서비스의 일부일 수도 있습니다.
컴포넌트는 다음과 같습니다.
- 결합(의존관계가 있음)
- Statefull(인스턴스 변수의 상태를 저장합니다)
- 표준 사양이 아닌 특정 사용 사례에 맞게 설계되어 있습니다(Java-EE Bean의 주요 차이점).
- 클라이언트 머신에서 실행
자바빈(엔터프라이즈빈)
- Java EE 서버에서 실행되는 독립 실행형 구성 요소
- 특정 서비스를 완료하기 위한 다양한 비즈니스 로직 포함
- 복잡한 다층 분산 시스템 개발 간소화
Java Bean은 큰 시스템을 관리하기 위한 개념에 가깝습니다.그것이 그들이 스탠드아라이즈가 필요한 이유다.
실제로 콩은 사용하기 쉬운 물건일 뿐이다.시리얼화란 쉽게 유지할 수 있는(쉽게 복구할 수 있는 형태로 저장) 것을 의미합니다).
Typical uses of Beans in real world:
- simple reusable objects POJO (Plain Old Java Objects)
- visual objects
- Spring uses Beans for objects to handle (for instance, User object that needs to be serialized in session)
- EJB (Enterprise Java Beans), more complex objects, like JSF Beans (JSF is old quite outdated technology) or JSP Beans
So in fact, Beans are just a convention / standard to expect something from a Java object that it would behave (serialization) and give some ways to change it (setters for properties) in a certain way.
How to use them, is just your invention, but most common cases I enlisted above.
A Java Bean is a component or the basic building block in the JavaBeans architecture. The JavaBeans architecture is a component architecture that benefits from reusability and interoperability of a component-based approach.
A valid component architecture should allow programs to be assembled from software building blocks (Beans in this case), perhaps provided by different vendors and also make it possible for an architect / developer to select a component (Bean), understand its capabilities, and incorporate it into an application.
Since classes/objects are the basic building blocks of an OOP language like Java, they are the natural contenders for being the Bean in the JavaBeans architecture.
The process of converting a plain Java class to a Java bean is actually nothing more than making it a reusable and interoperable component. This would translate into a Java class having abilities like:
- controlling the properties, events, and methods of a class that are exposed to another application. (You can have a BeanInfo class that reports only those properties, events and methods that the external application needs.)
- persistence (being serialisable or externizable - this would also imply having no-argument constructors, using transient for fields)
- ability to register for events and also to generate events (e.g., making use of bound and constraint properties)
- customizers (to customise the Bean via GUIs or by providing documentation)
Java 클래스를 Java bean이라고 부르기 위해서는 위의 모든 기능을 보유할 필요가 없습니다.대신 컨텍스트와 관련된 위의 서브셋을 구현해야 합니다(예를 들어 특정 프레임워크의 빈은 커스터마이저를 필요로 하지 않을 수 있으며 다른 빈은 구속 및 제약된 속성을 필요로 하지 않을 수 있습니다).
Java의 거의 모든 주요 프레임워크와 라이브러리는 위의 이점을 얻기 위해 암묵적으로 JavaBeans 아키텍처를 준수합니다.
Spring @Bean annotation은 Spring 컨테이너에 의해 관리되는 콩이 메서드에 의해 생성됨을 나타냅니다.
자세한 내용은 https://www.concretepage.com/spring-5/spring-bean-annotation를 참조해 주세요.
언급URL : https://stackoverflow.com/questions/3295496/what-is-a-javabean-exactly
'programing' 카테고리의 다른 글
| Java 8 스트림 역순서 (0) | 2022.07.14 |
|---|---|
| VueJs Propos에 여러 데이터 유형을 추가하는 방법 (0) | 2022.07.14 |
| 브라우저 닫기 시에만 함수를 호출하는 방법 (0) | 2022.07.14 |
| Maven이 의존관계를 타겟/립에 복사하도록 하다 (0) | 2022.07.14 |
| .vue 컴포넌트 분리/준비함수에서 vuex 액션을 명시적으로 호출합니다. (0) | 2022.07.14 |