Locais onde o JavaBeans é usado?

O que é um JavaBean e por que eu preciso? Como posso criar todos os aplicativos com a estrutura de classe e interface? Por que eu preciso de feijão? E você pode me dar alguns exemplos em que os beans são essenciais em vez de classes e interfaces?

Por favor, explique a essencialidade de um bean no contexto abaixo:

• Aplicativos Wep
• Aplicativos independentes

Eles geralmente representam apenas dados do mundo real. Aqui está um exemplo simples de um Javabean:

public class User implements java.io.Serializable {

    // Properties.
    private Long id;
    private String name;
    private Date birthdate;

    // Getters.
    public Long getId() { return id; }
    public String getName() { return name; }
    public Date getBirthdate() { return birthdate; }

    // Setters.
    public void setId(Long id) { this.id = id; }
    public void setName(String name) { this.name = name; }
    public void setBirthdate(Date birthdate) { this.birthdate = birthdate; }

    // Important java.lang.Object overrides.
    public boolean equals(Object other) {
        return (other instanceof User) && (id != null) ? id.equals(((User) other).id) : (other == this);
    }
    public int hashCode() {
        return (id != null) ? (getClass().hashCode() + id.hashCode()) : super.hashCode();
    }
    public String toString() {
        return String.format("User[id=%d,name=%s,birthdate=%d]", id, name, birthdate);
    }
}

A implementação Serializablenão é, por si só, obrigatória, mas muito útil se você quiser persistir ou transferir Javabeans para fora da memória do Java, por exemplo, em disco rígido ou em rede.

Por exemplo, uma classe DAO, você pode usá-la para criar uma lista de usuários em que você armazena os dados da usertabela no banco de dados:

List<User> users = new ArrayList<User>();
while (resultSet.next()) {
    User user = new User();
    user.setId(resultSet.getLong("id"));
    user.setName(resultSet.getString("name"));
    user.setBirthdate(resultSet.getDate("birthdate"));
    users.add(user);
}
return users;

Por exemplo, uma classe Servlet, você pode usá-lo para transferir dados do banco de dados para a interface do usuário:

protected void doGet(HttpServletRequest request, HttpServletResponse response) {
    List<User> users = userDAO.list();
    request.setAttribute("users", users);
    request.getRequestDispatcher("users.jsp").forward(request, response);
}

Por exemplo, uma página JSP, você pode acessá- la por EL , que segue as convenções de Javabean, para exibir os dados:

<table>
    <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Birthdate</th>
    </tr>
    <c:forEach items="${users}" var="user">
        <tr>
            <td>${user.id}</td>
            <td><c:out value="${user.name}" /></td>
            <td><fmt:formatDate value="${user.birthdate}" pattern="yyyy-MM-dd" /></td>
        </tr>
    </c:forEach>
</table>

Isso faz sentido? Veja bem, é uma convenção que você pode usar em qualquer lugar para armazenar , transferir e acessar dados.

Veja também:

• Especificação JavaBeans

Os próprios feijões

O JavaBeans está em toda parte, é uma convenção e quase todas as bibliotecas um pouco maiores existentes no mercado usam essas convenções para automatizar as coisas. Apenas algumas razões pelas quais o JavaBeans deve ser usado:

• Eles serializam bem.
• Pode ser instanciado usando reflexão.
• Caso contrário, pode ser controlado usando a reflexão com muita facilidade.
• Bom para encapsular dados reais do código comercial.
• Convenções comuns significam que qualquer pessoa pode usar seus grãos E VOCÊ PODE USAR TODOS OS FEIJÕES, sem qualquer tipo de documentação / manual de maneira fácil e consistente.
• Muito perto dos POJOs, o que realmente significa ainda mais interoperabilidade entre partes distintas do sistema.

Também, é claro, o Enterprise JavaBeans, que é uma questão totalmente diferente e não deve ser misturada com o JavaBeans comum. Eu só queria mencionar o EJB: s porque os nomes são semelhantes e é fácil confundir os dois.

Beans em aplicativos da web

Se você considera o JavaBeans "normal" no contexto de aplicativos da Web, eles fazem mais sentido do que usar sapatos nas pernas. Como a especificação Servlet exige que as sessões sejam serializáveis, significa que você deve armazenar seus dados na sessão como algo que pode ser serializado - por que não torná-lo um bean então! Basta colocar seu SomeBusinessDataBean na sessão e você estará pronto para ir, risivelmente fácil, compatível com as especificações e conveniente.

Também é fácil transferir esses dados pelo aplicativo, pois o JavaBeans ajuda a dissociar completamente partes do seu aplicativo. Pense no JavaBeans como uma carta e vários subsistemas do aplicativo como departamentos de uma corporação muito grande: o Departamento.A envia um monte de dados para o Departamento.B, o Departamento.B não sabe - nem se importa - de onde os dados vieram. como deveria ser e pode simplesmente abrir a carta, ler coisas dela e fazer suas coisas com base nesses dados.

Feijão em aplicações independentes

Na verdade, o que está descrito acima também se aplica a aplicativos independentes, a única diferença é que você pode mexer um pouco mais com a interface do usuário, pois os aplicativos independentes têm UI: s enquanto os aplicativos da Web têm statelss UI: s, que em alguns casos simulam apenas a UI com estado: s . Devido a essa diferença, é mais fácil bagunçar o aplicativo independente, mas isso vale outro tópico e não está diretamente relacionado ao JavaBeans.

Um feijão não é nada, realmente. Para uma classe ser um "bean", tudo o que é necessário é:

• ter um público, nenhum construtor de argumentos
• ser serializável (para implementar a interface serializável, diretamente ou através de uma de suas superclasses).

Para isso, você pode adicionar getters e setters para propriedades da classe que estejam em conformidade com uma convenção de nomenclatura específica, se desejar que os campos sejam descobertos em determinadas circunstâncias (por exemplo, tornar essa classe um objeto que você pode arrastar e soltar a partir de um editor visual em seu IDE, por exemplo).

Você pode encontrar mais diretamente da Sun aqui .

Um Java Bean é um componente de software que foi projetado para ser reutilizável em uma variedade de ambientes diferentes. Não há restrição na capacidade de um Bean. Pode executar uma função simples, como verificar a ortografia de um documento ou uma função complexa, como prever o desempenho de um portfólio de ações. Um Bean pode estar visível para um usuário final. Um exemplo disso é um botão em uma interface gráfica do usuário. Um Bean também pode ser invisível para um usuário. O software para decodificar um fluxo de informações multimídia em tempo real é um exemplo desse tipo de componente básico. Finalmente, um Bean pode ser projetado para funcionar autonomamente na estação de trabalho de um usuário ou em cooperação com um conjunto de outros componentes distribuídos. O software para gerar um gráfico de pizza a partir de um conjunto de pontos de dados é um exemplo de um Bean que pode ser executado localmente. Contudo,

Veremos em breve quais alterações específicas um desenvolvedor de software deve fazer em uma classe para que seja utilizável como um Java Bean. No entanto, um dos objetivos dos designers de Java era facilitar o uso dessa tecnologia. Portanto, as alterações de código são mínimas.

Vantagens do Java Beans

Uma arquitetura de componentes de software fornece mecanismos padrão para lidar com os componentes básicos do software. A lista a seguir enumera alguns dos benefícios específicos que a tecnologia Java oferece para um desenvolvedor de componentes:

• Um Bean obtém todos os benefícios do paradigma "escrever uma vez, executar em qualquer lugar" do Java.
• As propriedades, eventos e métodos de um Bean expostos a uma ferramenta do construtor de aplicativos podem ser controlados.
• Um Bean pode ser projetado para operar corretamente em diferentes locais, o que o torna útil nos mercados globais.
• Pode ser fornecido software auxiliar para ajudar uma pessoa a configurar um Bean. Este software é necessário apenas quando os parâmetros de tempo de design para esse componente estão sendo definidos. Ele não precisa ser incluído no ambiente de tempo de execução.
• As definições de configuração de um Bean podem ser salvas no armazenamento persistente e restauradas posteriormente.
• Um Bean pode se registrar para receber eventos de outros objetos e pode gerar eventos que são enviados para outros objetos.

Aqui está um exemplo simples de um Javabean:

public class MyBean implements java.io.Serializable
{

       protected  int theValue;

       public MyBean()
       {
       }

       public void setMyValue(int newValue)
       {
           theValue = newValue;
       }

      public int getMyValue()
      {
           return theValue;
      }

}

Este é um Bean real chamado MyBean que possui o estado (a variável theValue) que será automaticamente salvo e restaurado pelo mecanismo de persistência JavaBeans e possui uma propriedade chamada MyValue que pode ser usada por um ambiente de programação visual. Este Bean não tem nenhuma representação visual, mas isso não é um requisito para um componente JavaBean.