Какво е EJB? Еволюцията на Enterprise JavaBeans

Enterprise JavaBeans (EJB) е спецификация за разработване на широкомащабни, разпределени бизнес приложения на платформата Java. EJB 1.0 е издаден през 1998 г. Най-актуалната версия, EJB 3.2.3, е приета за включване в Джакарта EE, където ще бъде преименувана на Jakarta Enterprise Beans.

EJB архитектура

Архитектурата EJB се състои от три основни компонента: корпоративни компоненти (EJB), контейнер EJB и сървър за приложения на Java. EJB се изпълняват в контейнер на EJB, а контейнерът EJB работи в сървър за приложения на Java.

Има два типа EJB - сесионни компоненти и управлявани от съобщения бобчета:

  • Сесия боб са изтъкнати от клиент и грим функционалността на предприятието, като например сделки и управление на ресурсите на разположение на клиента по програмен път.
  • Управляваните от съобщения зърна също капсулират и доставят корпоративна функционалност, но те са асинхронни и управлявани от събития. Управляваните от съобщения зърна слушат и отговарят на събития и не могат да бъдат извикани от клиента.

Веднъж използвани за осигуряване на устойчивост в системата EJB, компонентите на обекти са заменени от API за устойчивост на Java. Продължете да четете, за да научите повече за сесионните компоненти и управляваните от съобщения компоненти.

EJB срещу JavaBeans

Предприятието JavaBeans беше първият базиран на компоненти модел за развитие на Java EE. EJB е подобен на JavaBeans, тъй като е базиран на компоненти, но тук приликата завършва:

  • А JavaBean е Java клас, който капсулира множество обекти и отговаря на определени конвенции. JavaBeans се използват главно за разработка от страна на клиента.
  • Едно предприятие, боб (EJB) е Java клас пропити с конкретни страна на сървъра възможности. Предприятията се използват в мащабни бизнес приложения и системи.

Сесионни зърна

А боб сесия е най-родово вида на предприятието боб, което представлява парче бизнес функционалност, която може да се нарече от клиент. Клиентът в този случай може да бъде друг клас в локалната JVM или отдалечено повикване.

Контейнерът EJB управлява жизнения цикъл на сеанса, който се определя от състоянието на боб:

  • Сеансите без сесия без състояние са подобни на обхвата на заявката в Java Servlet API. Сеансите без гражданство съдържат част от извикваща се функционалност, но иначе са без гражданство.
  • Файловете за сесия с състояние са свързани само с един клиент и се прикачват към текущата сесия на този клиент. Файловете за сесия с държавни функции функционират подобно на обхвата на сесията в API на Servlet.
  • Единичните зърна са подобни на обхвата на приложение в API на Servlet. Сингъл сеанс бин съществува само веднъж за всеки клиент.

Безопасност на резбата със сесионни зърна

Достъп до сеанс боб с състояние на състояние може да има само един клиент наведнъж, така че безопасността на нишките е гарантирана, когато работите с този тип боб. Сесионните зърна без държава и единичните зърна са по-гъвкави, позволявайки едновременни връзки, които трябва да се управляват от разработчика. Вие носите отговорност за безопасността на нишките при работа с тези видове зърна.

Управляван от съобщения фасул

Управляваните от съобщения зърна (MDB) се извикват чрез JMS (Java Message Service) съобщения. JMS работи като разпределен шаблон на командата, където управляваният от съобщения боб действа като слушател на командата. Когато пристигне съобщение по тема или опашка, се извиква управлявания от съобщения боб, който слуша тази тема.

Управляваните от съобщения компоненти не са толкова често използвани като сесионните компоненти, но са мощни. Тъй като са асинхронни и управлявани от събития, те са особено полезни за продължителни работни места, където е важно да се спестят ресурси.

Най-простата архитектура ще се състои от приложението EJB и неговия контейнер и сървър, които се координират с услугата за съобщения, обработваща MDB. В производството вашата архитектура вероятно ще включва трети компонент, посветен на консумацията на зърната. В разработка всички тези компоненти могат да работят на една и съща локална машина.

Фигура 1 показва типична управлявана от събития архитектура с управлявани от съобщения зърна.

Матю Тайсън

Работата с управлявани от съобщения зърна е по-ангажирана от използването на сеанси. В среда, управлявана от събития, обикновено ще ви е необходим посредник за съобщения като ActiveMQ.

Докато сесионните компоненти са по-прости и по този начин по-често се използват в EJB, управляваните от събития архитектури стават популярни, особено с експлозията на микроуслуги. 

EJB анотации

Определянето и консумирането на корпоративни зърна беше пречка за много разработчици до EJB 3.0, което въведе анотации към спецификацията на EJB. Анотациите улесняват конфигурирането на корпоративни компоненти за широк спектър от функционалности, намерени в Java EE. Продължете да четете, за да започнете с EJB анотациите.

@Stateless: Дефинирайте сеанс без гражданство

За да определите клас като сеанс без гражданство, използвате javax.ejb.Statelessанотацията, както е показано в Листинг 1.

Листинг 1. Пример за анотация на @Stateless

 import javax.ejb.Stateless; @Stateless public class MyStatelessBean { public String getGreeting() { return "Hello JavaWorld."; } } 

Този боб без гражданство съдържа прост подпис, който не взема аргументи и връща низ. Не позволявайте на простотата да ви заблуди: този боб може да направи всичко, от което се нуждаете, включително да взаимодейства с други компоненти, услуги или слоя данни на вашето приложение.

@EJB: Консумирайте сеанс без гражданство

След като дефинирате сеанс, използването му е толкова просто:

Листинг 2. @EJB пример за анотация

 public class MyServlet extends HttpServlet { @EJB MyStatelessBean myEjb; public void doGet(HttpServletRequest request, HttpServletResponse response) { response.getWriter().write("EJB Says " + testStatelessEjb.getGreeting()); } } 

Here, we inject the stateless bean into a servlet, and then it's available for use. Notice how the bean is identified under the @EJB annotation. The "stateless" designation tells us this bean will not track the client. Because it's stateless, we also know this bean is subject to threading if it does any work outside the invoked method.

@Remote: Define a remote EJB interface

In the above examples, I assumed the EJB and EJB client were running in the same JVM. If the enterprise bean and its client are running in separate JVMs, then the EJB must define a @Remote interface. In this case, it's up to you to define and implement the interface, as shown in Listing 3.

Listing 3. @Remote annotation example

 @Remote public interface MyStatelessEjbRemote { String sayHello(String name); } 

The remote interface is sent to the client to invoke. Calls to it will then be fulfilled by the EJB's server-side implementation. The MyStatelessBean example in Listing 4 implements the remote interface.

Listing 4. Implementing a remote interface

 public class MyStatelessBean implements MyStatelessEjbRemote{ ... } 

A remote interface is implemented just like a normal class implementing an interface. As the consumer of a remote EJB, the client application must be able to access the class definition for the remote interface. You can package the class definition for the remote interface as a dependency JAR.

Local vs remote interface

While it's important to know how to implement a remote interface, in practice it's more common to use a local interface. The local interface is used by default and works whenever the EJB is invoked within the same JVM context. Using the remote interface comes into play when the application is distributed across multiple JVMs.

Stateful sessions beans and singleton beans

The process for defining and consuming stateful @Session beans and @Singleton beans is the same as what you've seen for @Stateless beans. Remember the semantics:

  • Multiple session beans can be instantiated and used for the same client.
  • A singleton bean will exist only once for the entire application.

Thread safety and scheduling with singletons

Thread safety is built in when you're working with session beans, but both stateless and singleton beans can be accessed concurrently by multiple clients. Developers are responsible for thread safety when implementing these types of beans.

Singleton beans offer some support for thread safety via the @Lock annotation. You can use the @Lock annotation on singleton bean methods to set read/write privileges for each method. The two options are @Lock(LockType.READ) or @Lock(LockType.WRITE), which is the default.

Another useful feature of singleton beans is the ability to schedule tasks in a simple way, using the @Schedule annotation. Listing 5 shows how to schedule a task daily at noon.

Listing 5. @Schedule annotation example

 @Singleton public class MySchedulerBean { @Schedule(hour = "12") void doIt() { System.out.println("Hello at Noon!"); } } 

CDI vs EJB

CDI, or Context and Dependency Injection is a newer enterprise specification that some developers have proposed could replace EJB.

At a high level, CDI offers a general-purpose component framework, while EJB stands out for its richly featured, individual components. Whereas CDI uses dependency injection to define and reference any software component, EJB components are more formally defined, with each offering a specific set of capabilities out of the box. Both specs are planned for future development as part of Jakarta EE, where the question of whether CDI should replace EJB will eventually be resolved.

Conclusion

Enterprise JavaBeans е първата спецификация, която предлага лесен начин за капсулиране и повторно използване на бизнес логика в корпоративни Java приложения. Далеч от тежката тежест на старото, EJB днес е слаба, базирана на анотации рамка, която ви позволява да получите достъп до широк спектър от корпоративни функционалности, веднага. Помислете за EJB следващия път, когато бъдете помолени бързо да увеличите разпределено, мащабируемо бизнес приложение. Може да бъдете приятно изненадани.

Тази история „Какво е EJB? Еволюцията на Enterprise JavaBeans“ първоначално е публикувана от JavaWorld.