O que é exatamente um JavaBean?

Eu entendi, eu acho, que um "Bean" é uma classe Java com propriedades e getters / setters. Tanto quanto eu entendo, é o equivalente a uma estrutura C. Isso é verdade?

Além disso, existe uma diferença sintática real entre um bean e uma classe regular? Existe alguma definição especial ou uma interface?

Basicamente, por que existe um termo para isso?

Além disso, o que significa a Serializableinterface?

Um JavaBean é apenas um padrão

1. Todas as propriedades privadas (use getters / setters )
2. Um construtor público sem argumentos
3. Implementos Serializable.

É isso aí. É apenas uma convenção. Muitas bibliotecas dependem disso.

Com relação à documentaçãoSerializable da API :

A serialização de uma classe é ativada pela classe que implementa a interface java.io.Serializable. Classes que não implementam essa interface não terão nenhum estado serializado ou desserializado. Todos os subtipos de uma classe serializável são eles próprios serializáveis. A interface de serialização não possui métodos ou campos e serve apenas para identificar a semântica de ser serializável.

Em outras palavras, objetos serializáveis ​​podem ser gravados em fluxos e, portanto, arquivos, bancos de dados de objetos, qualquer coisa realmente.

Além disso, não há diferença sintática entre um JavaBean e outra classe - uma classe é um JavaBean se seguir os padrões.

Existe um termo para isso, porque o padrão permite que as bibliotecas façam coisas programaticamente com as instâncias de classe definidas de uma maneira predefinida. Por exemplo, se uma biblioteca deseja transmitir qualquer objeto que você passar para ela, ela sabe que pode porque seu objeto é serializável (supondo que a lib exija que seus objetos sejam JavaBeans adequados).

Existe um prazo para que pareça especial. A realidade está longe de ser tão misteriosa.

Basicamente, um "Bean":

• é um objeto serializável (isto é, implementa java.io.Serializablee o faz corretamente), que
• possui "propriedades" cujos getters e setters são apenas métodos com determinados nomes (como, por exemplo, getFoo()o getter da propriedade "Foo") e
• possui um construtor público 0-arg (para que ele possa ser criado à vontade e configurado definindo suas propriedades).

Atualizar:

Quanto a Serializable: isso nada mais é do que uma "interface de marcador" (uma interface que não declara nenhuma função) que informa ao Java que a classe de implementação consente (e implica que é capaz de) "serialização" - um processo que converte uma instância em um fluxo de bytes. Esses bytes podem ser armazenados em arquivos, enviados por uma conexão de rede etc. e ter informações suficientes para permitir que uma JVM (pelo menos uma que conheça o tipo de objeto) reconstrua o objeto posteriormente - possivelmente em uma instância diferente do aplicação ou mesmo em outra máquina!

Obviamente, para fazer isso, a classe deve cumprir certas limitações. A principal delas é que todos os campos de instância devem ser tipos primitivos (int, bool, etc), instâncias de alguma classe que também seja serializável ou marcadas como transientpara que o Java não tente incluí-las. (É claro que isso significa que os transientcampos não sobreviverão à viagem ao longo de um fluxo. Uma classe que possui transientcampos deve estar preparada para reinicializá-los, se necessário.)

Uma classe que não pode respeitar essas limitações não deve implementar Serializable(e, IIRC, o compilador Java nem deixa fazê-lo.)

JavaBeans são classes Java que aderem a uma convenção de codificação extremamente simples. Tudo o que você precisa fazer é

1. implementar java.io.Serializableinterface - para salvar o estado de um objeto
2. use um construtor de argumento público vazio - para instanciar o objeto
3. forneça métodos públicos getter / setter - para obter e definir os valores de variáveis ​​privadas (propriedades).

Propriedades do JavaBeans

Um JavaBean é um objeto Java que satisfaz certas convenções de programação:

1. A classe JavaBean deve implementar Serializableou Externalizable

2. A classe JavaBean deve ter um construtor no-arg

3. Todas as propriedades JavaBean devem ter métodos públicos setter e getter

4. Todas as variáveis ​​de instância JavaBean devem ser privadas

Exemplo de 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;
   }
}

Explicação com um exemplo.

1. importar java.io.Serializable

Quanto à serialização, consulte a documentação .

2. campos particulares

Os campos devem ser privados para impedir que classes externas modifiquem facilmente esses campos. Em vez de acessar diretamente esses campos, geralmente são utilizados métodos getter / setter.

3. Construtor

Um construtor público sem nenhum argumento.

4. getter / setter

Métodos getter e setter para acessar e modificar campos particulares.

/** 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;
    }
}

O Java Beans está usando menos código e mais abordagem de trabalho ... O Java Beans é usado no Java EE como um contrato universal para descoberta e acesso em tempo de execução. Por exemplo, o JavaServer Pages (JSP) usa o Java Beans como objetos de transferência de dados entre páginas ou entre servlets e JSPs. O JavaBeans Activation Framework do Java EE usa o Java Beans para integrar o suporte aos tipos de dados MIME no Java EE. A API de gerenciamento Java EE usa o JavaBeans como base para a instrumentação de recursos a serem gerenciados em um ambiente Java EE.

Sobre serialização:

Na serialização de objetos, um objeto pode ser representado como uma sequência de bytes que inclui os dados do objeto, além de informações sobre o tipo do objeto e os tipos de dados armazenados no objeto.

Depois que um objeto serializado é gravado em um arquivo, ele pode ser lido e desserializado, ou seja, as informações de tipo e bytes que representam o objeto e seus dados podem ser usados ​​para recriar o objeto na memória.

Você encontrará a serialização útil ao implantar seu projeto em vários servidores, pois os beans serão persistidos e transferidos entre eles.

O Java Beans é um padrão, e seus requisitos básicos de sintaxe foram explicados claramente por outras respostas.

No entanto, IMO, é mais do que um simples padrão de sintaxe. O significado real ou o uso pretendido do Java Beans é, junto com vários suportes de ferramentas em todo o padrão, facilitar a reutilização de código e a engenharia de software baseada em componentes, ou seja, permitir que os desenvolvedores construam aplicativos montando componentes existentes (classes) e sem precisar escrever nenhum código (ou apenas tem que escrever um pequeno código de cola). Infelizmente, essa tecnologia é subestimada e subutilizada pela indústria, o que pode ser explicado pelas respostas neste tópico.

Se você ler o tutorial da Oracle sobre Java Beans , poderá entender melhor isso.

De acordo com a Wikipedia:

1. A classe deve ter um construtor público padrão (sem argumentos). Isso permite instanciação fácil nas estruturas de edição e ativação.

2. As propriedades da classe devem ser acessíveis usando get, set, is (pode ser usado para propriedades booleanas em vez de get) e outros métodos (os chamados métodos acessadores e métodos mutadores) de acordo com uma convenção de nomenclatura padrão. Isso permite inspeção e atualização automatizadas fáceis do estado do bean nas estruturas, muitas das quais incluem editores personalizados para vários tipos de propriedades. Os setters podem ter um ou mais de um argumento.

3. A classe deve ser serializável. [Isso permite que aplicativos e estruturas salvem, armazenem e restaurem com segurança o estado do bean de maneira independente da VM e da plataforma.]

Para mais informações, siga este link.

Em relação à segunda parte da sua pergunta, a serialização é um mecanismo de persistência usado para armazenar objetos como uma sequência de bytes assinados. Em termos menos formais, ele armazena o estado de um objeto para que você possa recuperá-lo mais tarde, por desserialização.

Um Java Bean é uma classe java [conceitual] que deve seguir as seguintes convenções:

1. Ele deve ter um construtor sem argumento.
2. Deve ser serializável.
3. Ele deve fornecer métodos para definir e obter os valores das propriedades, conhecidos como métodos getter e setter.

É um componente de software reutilizável. Ele pode encapsular muitos objetos em um objeto para que o mesmo objeto possa ser acessado de vários lugares e é um passo em direção à fácil manutenção do código.

Eles são serializáveis, têm um construtor de argumento zero e permitem acesso a propriedades usando os métodos getter e setter. O nome "Bean" foi atribuído para abranger esse padrão, que visa criar componentes de software reutilizáveis ​​para Java. according to wiki

Os objetos que formam a espinha dorsal do seu aplicativo e gerenciados pelo contêiner Spring IoC são chamados de beans. Um bean é um objeto que é instanciado, montado e gerenciado por um contêiner Spring IoC. Caso contrário, um bean é simplesmente um dos muitos objetos em seu aplicativo. according to primavera io .

Apenas um pouco de conhecimento / atualização sobre o conceito de bean. Muitas outras respostas realmente têm o quê, mas não tanto o porquê delas.

Eles foram inventados no início do Java como parte da criação de GUIs. Eles seguiram padrões fáceis de separar, permitindo a criação de um painel de propriedades para que você pudesse editar os atributos do Bean. Em geral, as propriedades do Bean representavam um controle na tela (Pense x, y, largura, altura, texto, etc.)

Você também pode pensar nisso como uma estrutura de dados fortemente tipada.

Com o tempo, elas se tornaram úteis para muitas ferramentas que usavam o mesmo tipo de acesso (por exemplo, o Hibernate para manter estruturas de dados no banco de dados)

À medida que as ferramentas evoluíam, elas se mudaram mais para anotações e afastaram os nomes dos levantadores / levantadores. Agora, a maioria dos sistemas não requer beans, eles podem usar qualquer objeto java antigo simples com propriedades anotadas para dizer como manipulá-los.

Agora vejo os grãos como bolas de propriedades anotadas - elas são realmente úteis apenas para as anotações que carregam.

O próprio feijão não é um padrão saudável. Eles destroem o encapsulamento por natureza, pois expõem todas as suas propriedades à manipulação externa e, à medida que são usadas, existe uma tendência (de maneira alguma um requisito) a criar código para manipular o bean externamente, em vez de criar código dentro do bean (viola "don pergunte a um objeto por seus valores, peça a um objeto que faça algo por você "). Usar pojos anotados com getters mínimos e sem setters é muito mais OO restaurando o encapsulamento e com a possibilidade de imutabilidade.

A propósito, enquanto tudo isso acontecia, alguém estendeu o conceito para algo chamado Enterprise Java Beans. Estes são ... diferentes. e eles são complicados o suficiente para que muitas pessoas achem que não entenderam o conceito inteiro do Bean e pararam de usar o termo. Acho que é por isso que você geralmente ouve beans chamados POJOs (já que todo objeto java é um POJO, isso é tecnicamente bom, mas quando você ouve alguém dizer POJO, geralmente pensa em algo que segue o padrão do bean)

Um Java Bean é qualquer classe java que atenda aos três critérios a seguir:

1. Ele deve implementar interface serializável (interface A Marker).
2. O construtor deve ser público e não ter argumentos (o que outras pessoas chamam de "construtor sem argumento").
3. Deve ter getter e setter.

É bom observar que o campo serialVersionUID é importante para manter o estado do objeto. O código abaixo é qualificado como um 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;
}}

Para entender o JavaBean, você precisa observar o seguinte: JavaBean é um material conceitual e não pode representar uma classe de coisas específicas

JavaBean é uma ferramenta de desenvolvimento que pode ser visualizada na operação de componentes de software reutilizáveis

O JavaBean é baseado na especificação Sun JavaBeans e pode ser componentes reutilizáveis. Sua maior característica é a reutilização.

Um bean é uma classe Java com nomes de métodos que seguem as diretrizes do Java Bean (também chamadas de padrões de design) para propriedades , métodos e eventos. Portanto, qualquer método público da classe de bean que não faça parte de uma definição de propriedade é um método de bean. No mínimo, uma classe Java, mesmo com uma propriedade como o único membro (é claro, é necessário acompanhar o getter e o setter públicos), um método público como o único membro ou apenas um método de registro de ouvinte de eventos públicos é um bean Java. Além disso, a propriedade pode ser propriedade somente leitura (possui um método getter, mas não setter) ou propriedade somente gravação (possui apenas um método setter). O Java bean precisa ser uma classe pública para estar visível a qualquer ferramenta ou contêiner do beanbox. O contêiner deve ser capaz de instanciar; portanto, também deve ter um construtor público. A especificação JavaBeansnão exige que um bean tenha um construtor público de zero argumentos, explícito ou padrão, para que um contêiner o instancie. Se você pudesse fornecer um arquivo (com extensão .ser) contendo uma instância serializada, uma ferramenta beanbox poderia usar esse arquivo para instanciar um bean protótipo. Caso contrário, o bean deve ter um construtor público de zero-args, explícito ou padrão.

Depois que o bean é instanciado, a API do Java Bean (java.beans. *) Pode examiná-lo e chamar métodos nele. Se nenhuma classe implementando a interface BeanInfo ou estendendo uma implementação BeanInfo, classe SimpleBeanInfo, estiver disponível, a introspecção envolve o uso de reflexão (introspecção implícita) para estudar os métodos suportados por um bean de destino e, em seguida, aplicar padrões de design simples (as diretrizes) para deduzir de a esses métodos, quais propriedades, eventos e métodos públicos são suportados. Se uma classe que implementa a interface BeanInfo (para um bean Foo, deve ser nomeado FooBeanInfo) está disponível, a API ignora a introspecção implícita e usa métodos públicos (getPropertyDescriptor (), getMethodDescriptors (), getMethodDescriptors (), getEventSetDescriptors ()) dessa classe para obter o em formação. Se uma classe estendendo SimpleBeanInfo estiver disponível, dependendo de qual dos métodos públicos SimpleBeanInfo (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()) são substituídos, ele usará esses métodos substituídos para obter informações; para um método que não seja substituído, o padrão será a introspecção implícita correspondente. Um bean precisa ser instanciado de qualquer maneira, mesmo que nenhuma introspecção implícita seja realizada nele. Assim, a exigência de um construtor público zeri-args. Mas, é claro, a interface Serializable ou Externalizable não é necessária para ser reconhecida. No entanto, a especificação do Java Bean diz: 'Também gostaríamos que fosse "trivial" para o caso comum de um Bean minúsculo que simplesmente quer ter seu estado interno salvo e não quer pensar nisso ". Portanto, todos os beans devem implementar a interface Serializable ou Externalizable. No geral, A especificação JavaBeans não é rígida e rápida sobre o que constitui um bean. "Escrever componentes JavaBeans é surpreendentemente fácil. Você não precisa de uma ferramenta especial e não precisa implementar nenhuma interface. Escrever beans é simplesmente uma questão de seguir certas convenções de codificação. Tudo o que você precisa fazer é fazer com que sua classe pareça um bean - ferramentas que usam beans poderão reconhecer e usar seu bean ". Trivialmente, até a classe a seguir é um Java Bean,

public class Trivial implements java.io.Serializable {}

Digamos, um construtor de bean possui alguns parâmetros. Suponha que alguns sejam tipos simples. O contêiner pode não saber quais valores atribuir a eles; mesmo que isso aconteça, a instância resultante pode não ser reutilizável. Pode fazer sentido apenas se o usuário puder configurar (especificar valores) digitando anotações ou arquivos de configuração xml como nos beans Spring. E suponha que alguns parâmetros sejam de classe ou de interface. Novamente, o contêiner pode não saber quais valores atribuir a ele. Pode fazer sentido apenas se o usuário puder configurar (especificar objetos específicos) digitando anotações ou arquivos de configuração xml. No entanto, mesmo no Spring (via arquivos de configuração xml), atribuir objetos específicos (com nomes de string) a argumentos do construtor (atributo ou elemento dos argumentos do construtor) não é tipicamente seguro; é basicamente como injeção de recurso. Fazer referências a outros beans Spring (chamados de colaboradores; via elemento em um elemento de argumento do construtor) é basicamente injeção de dependência e, portanto, tipicamente seguro. Obviamente, uma dependência (bean colaborador) pode ter um construtor com parâmetros injetados; essas dependências injetadas podem ter um construtor com parâmetros e assim por diante. Nesse cenário, em última análise, você precisaria de algumas classes de bean (por exemplo, MyBean.class) que o contêiner possa instanciar simplesmente chamando new MyBean () antes de poder construir os outros beans colaboradores via injeção de dependência nos construtores - portanto, o requisito para os beans para ter o construtor público zero-args. Suponha que, se um contêiner não suportar injeção de dependência e / ou não permitir atribuir valores de tipo simples ao construtor por meio de algumas anotações ou arquivos de configuração xml, como no Spring, construtores de bean não devem ter parâmetros. Mesmo um aplicativo Spring beans precisaria de alguns beans para ter um construtor público de zero-args (por exemplo, em um cenário em que seu aplicativo Spring não possui bean com apenas tipos simples como argumentos do construtor).

Os beans gerenciados JSF são executados em um contêiner da web. Eles podem ser configurados com a anotação @ManagedBean ou com um arquivo de recurso de configuração de aplicativo managed-bean.xml. No entanto, ele suporta injeção apenas por injeção de recursos (não tipesafe); não é adequado para injeção em construtores. A especificação JSFrequer que os beans gerenciados tenham um construtor público de argumento zero. Além disso, diz: “A partir da versão 2.3 desta especificação, o uso do recurso de bean gerenciado, conforme especificado nesta seção, é fortemente desencorajado. Uma solução melhor e mais coesa integrada para resolver o mesmo problema é usar CDI (Injeção de Dependência e Contexto), conforme especificado no JSR-365. "Em outras palavras, os beans gerenciados CDI a serem usados, que oferecem injeção de dependência segura em construtores semelhante Spring beans. A especificação CDI adota a especificação Managed Beans, que se aplica a todos os contêineres da plataforma JEE, não apenas à camada da Web. Portanto, o contêiner da Web precisa implementar a especificação CDI.

Aqui está um extrato da especificação do Managed Bean “Beans gerenciados são objetos gerenciados por contêineres com requisitos mínimos, também conhecidos sob o acrônimo“ POJOs ”(Plain Old Java Objects) ... eles podem ser vistos como uma versão aprimorada da plataforma Java EE do modelo de componente JavaBeans encontrado na plataforma Java SE ... O leitor não sentirá falta de que o Managed Beans tenha um precursor no recurso homônimo encontrado na tecnologia JavaServer Faces (JSF) ... O Managed Beans, conforme definido nesta especificação, representa uma generalização daqueles encontrados no JSF; em particular, o Managed Beans pode ser usado em qualquer lugar em um aplicativo Java EE, não apenas em módulos da web. Por exemplo, no modelo de componente básico, o Managed Beans deve fornecer um construtor sem argumento, mas uma especificação que se baseia no Managed Beans, como CDI (JSR-299), pode relaxar esse requisito e permitir que o Managed Beans forneça aos construtores assinaturas mais complexas, desde que sigam algumas regras bem definidas ... Um Bean Gerenciado não deve ser: uma classe final, uma classe abstrata, uma classe interna não estática . Um Managed Bean pode não ser serializável, diferentemente de um componente JavaBean comum. ” Portanto, a especificação para Managed Beans, também conhecida como POJOs ou POJO beans, permite a extensão como no CDI.

A especificação CDI redefine os beans gerenciados como: Ao executar no Java EE, uma classe Java de nível superior é um bean gerenciado se atender aos requisitos:

• Não é uma classe interna. • É uma classe não abstrata ou está anotada em @Decorator. • Não implementa javax.enterprise.inject.spi.Extension. • Não está anotado em @Vetoed ou em um pacote anotado em @Vetoed. • Possui um construtor apropriado: a classe possui um construtor sem parâmetros ou a classe declara um construtor anotado como @Inject.

Todas as classes Java que atendem a essas condições são beans gerenciados e, portanto, nenhuma declaração especial é necessária para definir um bean gerenciado. Ou

se for definido como um bean gerenciado por qualquer outra especificação Java EE e se

• Ele não é anotado com uma anotação de definição de componente EJB ou declarado como uma classe de bean EJB em ejb-jar.xml.

Ao contrário dos beans Spring, ele não suporta construtores com tipos simples, o que pode ser possível se oferecer suporte à configuração com arquivos de configuração xml, como no Spring ou em qualquer anotação.

Os EJBs são executados em um contêiner EJB. Sua especificaçãodiz: "Um componente do bean de sessão é um Bean Gerenciado". "A classe deve ter um construtor público que não aceita argumentos", diz o bean de sessão e o bean acionado por mensagens. Além disso, ele diz: "A classe do bean de sessão é não é necessário para implementar a interface SessionBean ou a interface serializável. " Pelo mesmo motivo que os beans JSF, como a injeção de dependência EJB3 é basicamente a injeção de recursos, os beans JSF não suportam construtores com argumentos, ou seja, via injeção de dependência.No entanto, se o contêiner EJB implementar CDI, “Opcionalmente: a classe pode ter um construtor adicional anotado com a anotação Inject ", diz para o bean de sessão e o bean acionado por mensagens porque:" Um EJB empacotado em um archive de bean CDI e não anotado com a anotação javax.enterprise.inject.Vetoed é considerado um CDI ativado feijão."

Na prática, o Beans são apenas objetos úteis para usar. Serializá-los significa poder persisti-los facilmente (armazene em um formato que seja facilmente recuperado).

Usos típicos do feijão no mundo real:

• objetos reutilizáveis ​​simples POJO (Plain Old Java Objects)
• objetos visuais
• O Spring usa o Beans para objetos manipular (por exemplo, objeto Usuário que precisa ser serializado em sessão)
• EJB (Enterprise Java Beans), objetos mais complexos, como JSF Beans (o JSF é uma tecnologia antiga bastante desatualizada) ou JSP Beans

Então, de fato, o Beans é apenas uma convenção / padrão que espera que algo de um objeto Java se comporte (serialização) e dê algumas maneiras de alterá-lo (setters de propriedades) de uma certa maneira.

Como usá-los, é apenas sua invenção, mas os casos mais comuns que eu me inscrevi acima.