Miejsca, w których używane są JavaBeans?

Co to jest JavaBean i dlaczego go potrzebuję? Ponieważ mogę tworzyć wszystkie aplikacje z klasą i strukturą interfejsu? Dlaczego potrzebuję fasoli? Czy możesz podać kilka przykładów, w których fasola jest niezbędna zamiast klas i interfejsów?

Wyjaśnij istotę fasoli w poniższym kontekście:

• Aplikacje WEP
• Samodzielne aplikacje

Często przedstawiają tylko rzeczywiste dane. Oto prosty przykład 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);
    }
}

Implementacja Serializablenie jest sama w sobie obowiązkowa, ale bardzo przydatna, jeśli chcesz mieć możliwość utrwalania lub przenoszenia Javabean poza pamięć Javy, np. Na dysk twardy lub przez sieć.

Na przykład w klasie DAO możesz użyć jej do stworzenia listy użytkowników, w której przechowujesz dane usertabeli w bazie danych:

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;

Na przykład w klasie Servlet możesz użyć jej do przesyłania danych z bazy danych do interfejsu użytkownika:

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

Na przykład na stronie JSP można uzyskać do niej dostęp przez EL , zgodnie z konwencjami Javabean, w celu wyświetlenia danych:

<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>

Czy jest sens? Widzisz, to rodzaj konwencji, której możesz używać wszędzie do przechowywania , przesyłania i uzyskiwania dostępu do danych.

Zobacz też:

• Specyfikacja JavaBeans

Same fasole

JavaBeans są wszędzie, są konwencją i prawie każda nieco większa biblioteka używa tych konwencji do automatyzacji. Tylko kilka powodów, dla których warto używać JavaBeans:

• Ładnie serializują.
• Można utworzyć wystąpienie przy użyciu odbicia.
• W innym przypadku można go bardzo łatwo kontrolować za pomocą odbicia.
• Dobre do hermetyzacji rzeczywistych danych z kodu biznesowego.
• Wspólne konwencje oznaczają, że każdy może używać Twojej fasoli I MOŻESZ UŻYWAĆ ZIARNA KAŻDEGO INNEGO w łatwy i spójny sposób bez jakiejkolwiek dokumentacji / instrukcji.
• Bardzo blisko POJO, co w rzeczywistości oznacza jeszcze większą interoperacyjność między różnymi częściami systemu.

Jest też oczywiście Enterprise JavaBeans które są zupełnie inną sprawą i nie powinny być mieszane ze zwykłymi JavaBeans. Chciałem tylko wspomnieć o EJB: s, ponieważ nazwy są podobne i łatwo je pomylić.

Fasola w aplikacjach internetowych

Jeśli weźmiesz pod uwagę „normalne” JavaBeans w kontekście aplikacji internetowej, mają one większy sens niż noszenie butów w nogach. Ponieważ specyfikacja serwletu wymaga, aby sesje były serializowane, oznacza to, że powinieneś przechowywać dane w sesji jako coś, co można serializować - dlaczego więc nie uczynić z nich fasoli! Po prostu wrzuć swoje SomeBusinessDataBean do sesji i gotowe, śmiesznie łatwe, zgodne ze specyfikacją i wygodne.

Również przesyłanie tych danych w obrębie aplikacji jest łatwe, ponieważ JavaBeans pomaga całkowicie oddzielić części aplikacji. Pomyśl o JavaBeans jako o liście i różnych podsystemach aplikacji jako działach w bardzo dużej korporacji: Dział A wysyła pakiet danych do działu B, dział B nie wie - ani nawet nie obchodzi - skąd pochodzą dane. tak, jak powinno i może po prostu otworzyć list, przeczytać z niego rzeczy i zrobić swoje w oparciu o te dane.

Fasola w samodzielnych aplikacjach

Właściwie to, co opisano powyżej, dotyczy również samodzielnych aplikacji, jedyną różnicą jest to, że możesz zepsuć interfejs użytkownika nieco bardziej, ponieważ aplikacje autonomiczne mają stanowy interfejs użytkownika, podczas gdy aplikacje internetowe mają interfejs użytkownika statels, który w niektórych przypadkach tylko symuluje stanowy interfejs użytkownika: s . Z powodu tej różnicy łatwiej jest narobić bałaganu z samodzielną aplikacją, ale jest to warte zupełnie innego tematu i nie jest w ogóle związane bezpośrednio z JavaBeans.

Fasola to właściwie nic wielkiego. Aby klasa była „fasolą”, wystarczy:

• mieć publiczny, bez konstruktora argumentów
• być serializowalnym (aby zaimplementować interfejs Serializable, bezpośrednio lub przez jedną z jego superklas).

Do tego możesz dodać pobierające i ustawiające wartości właściwości klasy, które są zgodne z określoną konwencją nazewnictwa, jeśli chcesz, aby pola były wykrywalne w określonych okolicznościach (np. Tworząc z tej klasy obiekt, który możesz przeciągać i upuszczać z edytora wizualnego w Na przykład IDE).

Więcej informacji bezpośrednio od Sun znajdziesz tutaj .

Java Bean to składnik oprogramowania, który został zaprojektowany do wielokrotnego użytku w różnych środowiskach. Nie ma ograniczeń co do możliwości fasoli. Może pełnić prostą funkcję, taką jak sprawdzanie pisowni dokumentu, lub złożoną funkcję, taką jak prognozowanie wyników portfela akcji. Bean może być widoczny dla użytkownika końcowego. Jednym z przykładów jest przycisk w graficznym interfejsie użytkownika. Bean może być również niewidoczny dla użytkownika. Przykładem tego typu budulca jest oprogramowanie do dekodowania strumienia informacji multimedialnych w czasie rzeczywistym. Wreszcie, Bean może być zaprojektowany do pracy autonomicznej na stacji roboczej użytkownika lub do pracy we współpracy z zestawem innych rozproszonych komponentów. Oprogramowanie do generowania wykresu kołowego na podstawie zestawu punktów danych jest przykładem Bean, który może działać lokalnie. Jednak,

Wkrótce zobaczymy, jakie konkretne zmiany musi wprowadzić programista w klasie, aby można było z niej korzystać jako Java Bean. Jednak jednym z celów projektantów Javy było ułatwienie korzystania z tej technologii. Dlatego zmiany kodu są minimalne.

Zalety Java Beans

Architektura komponentów oprogramowania zapewnia standardowe mechanizmy radzenia sobie z blokami konstrukcyjnymi oprogramowania. Na poniższej liście wymieniono niektóre konkretne korzyści, jakie technologia Java zapewnia programiście komponentów:

• Bean uzyskuje wszystkie zalety paradygmatu Java „jednokrotnego zapisu, uruchom wszędzie”.
• Można kontrolować właściwości, zdarzenia i metody komponentu Bean, które są udostępniane narzędziu do tworzenia aplikacji.
• Fasola może być zaprojektowana do prawidłowego działania w różnych lokalizacjach, co czyni ją użyteczną na rynkach globalnych.
• Może być dostarczone oprogramowanie pomocnicze, które pomoże osobie skonfigurować Bean. To oprogramowanie jest potrzebne tylko wtedy, gdy ustawiane są parametry czasu projektowania dla tego komponentu. Nie trzeba go uwzględniać w środowisku wykonawczym.
• Ustawienia konfiguracyjne Bean można zapisać w trwałym magazynie i przywrócić w późniejszym czasie.
• Bean może zarejestrować się, aby otrzymywać zdarzenia z innych obiektów i może generować zdarzenia, które są wysyłane do innych obiektów.

Oto prosty przykład 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;
      }

}

To jest prawdziwy Bean o nazwie MyBean, który ma stan (zmienna theValue), który zostanie automatycznie zapisany i przywrócony przez mechanizm trwałości JavaBeans, i ma właściwość o nazwie MyValue, która jest używana przez wizualne środowisko programowania. Ten Bean nie ma żadnej wizualnej reprezentacji, ale nie jest to wymagane dla komponentu JavaBean.