Ipinapakilala ang EJB

Sa artikulong ito titingnan natin ang EJB - Enterprise JavaBeans. Ang teknolohiyang ito ay bahagi ng pagtutukoy ng Java EE. Tatalakayin namin ang mga isyu tulad ng:

• ano ang EJB;
• ano ang kasaysayan ng EJB;
• anong mga uri ng EJB ang mayroon?

Magsusulat din kami ng maliit na HelloWorld application gamit ang EJB at mga servlet. Ang artikulong ito ay magiging kapaki-pakinabang sa mga mambabasa na naging komportable sa Java SE at nagsisimula nang matuto ng Java EE. Upang lubos na maunawaan ang praktikal na bahagi ng artikulong ito, inirerekomenda na basahin mo muna ang artikulong " Pag-set up ng lokal na kapaligiran ".

Isang Maikling Kasaysayan ng EJB

Noong 1996, noong 5 taong gulang ang may-akda ng artikulong ito, sikat na ang Java sa mga developer. Ang dahilan nito ay ang friendly na API, awtomatikong pagkolekta ng basura, atbp. Ang Java ay malawakang ginagamit sa mga system na responsable para sa backend. Gayunpaman, sa kabila ng lahat ng kasiyahan ng wika, ang mga programmer noong panahong iyon ay nangangailangan ng ilang pag-andar na hindi pa naipapatupad sa JDK. Ang mga pangangailangang ito ay:

• tinitiyak ang pagtitiyaga ng data;
• integridad ng transaksyon
• mapagkumpitensyang pag-access sa data (kontrol ng multi-threading);
• at malamang iba pa.

Ang lahat ng ito ay humantong sa isang natural na paglaki sa populasyon ng mga home-grown, self-written, closed library. Sa madaling salita, natugunan ng lahat ang kanilang mga pangangailangan sa abot ng kanilang makakaya. Iyon ay hanggang sa lumabas ang IBM na may slogan, "Dapat matugunan ng lahat ang kanilang mga pangangailangan sa parehong paraan," at inilabas ang detalye ng Enterprise Java Bean (EJB) noong 1997. Ito ang naging dahilan upang mapag-isa ang proseso ng pag-unlad at dalhin ang solusyon sa mga tipikal na problema (inilarawan sa itaas bilang mga pangangailangan) sa balangkas. Iniangkop ng Sun ang brainchild ng IBM sa loob ng 2 taon, at noong 1999 ay inilabas ang detalye ng EJB 1.0. Ito ay kung paano ipinanganak ang teknolohiya, na tatalakayin pa sa isang mas inilapat na ugat.

Ano ang EJB

Ang EJB sa isang kahulugan ay isang kolektibong termino na, depende sa konteksto, ay maaaring mangahulugan ng alinman sa Enterprise JavaBeans na teknolohiya mismo sa pangkalahatan, o ilang partikular na Enterprise JavaBean software component (bean) na bahagi ng teknolohiya ng EJB. Ang kahulugan ng EJB bilang isang teknolohiya ay ibinigay sa Wikipedia: Ang Enterprise JavaBeans (madalas ding ginagamit bilang pagdadaglat na EJB) ay isang detalye ng isang teknolohiya para sa pagsulat at pagsuporta sa mga bahagi ng server na naglalaman ng lohika ng negosyo. Ito ay bahagi ng Java EE. Karaniwang ginagamit ang teknolohiyang ito kapag ang lohika ng negosyo ay nangangailangan ng hindi bababa sa isa sa mga sumusunod na serbisyo, at kadalasan lahat ng mga ito:

• suporta para sa pagtitiyaga ng data: ang data ay dapat na ligtas kahit na matapos ihinto ang programa. Kadalasang nakakamit gamit ang isang database;
• suporta para sa mga ipinamamahaging transaksyon;
• suporta para sa parallel data modification at multithreading;
• suporta sa kaganapan;
• pagbibigay ng pangalan at suporta sa direktoryo (JNDI);
• seguridad at paghihigpit sa pag-access sa data;
• suporta para sa awtomatikong pag-install sa server ng application;
• malayuang pag-access.

Ang mga serbisyong nakalista sa itaas ay isang walang alinlangan na bentahe ng teknolohiya ng EJB. Ang isa pang kalamangan ay ang lahat ng nakalista sa itaas ay gumagana sa labas ng kahon, kaagad. Yung. ang programmer ay hindi kailangang mag-isip tungkol sa pagsuporta sa mga ipinamamahaging transaksyon. Kailangan lang isipin ng programmer ang lohika ng negosyo na kasalukuyang sinusubukan niyang ipatupad. Ang EJB bilang isang partikular na bahagi ng software ay isang klase ng Java na may isa o higit pang mga anotasyon mula sa detalye ng EJB na naglalaman ng ilan sa lohika ng negosyo ng application. Ang mga anotasyon mula sa detalye ng EJB ay nagbibigay sa naka-tag na klase ng ilang kapangyarihan, kapangyarihan, at superpower. Magbasa pa tungkol dito sa ibaba.

Mga uri ng EJB

I-summarize natin. Ang EJB ay isang regular na klase ng Java na minarkahan ng isa sa mga espesyal na anotasyon. Ang ganitong mga klase ay tinatawag na beans. Depende sa kung anong anotasyon ang minarkahan ng klase, magiging kinatawan ito ng isa o ibang uri ng EJB (beans). Mayroong tatlong pangunahing uri ng beans:

• Message Driven Beans (message driven beans);
• Entity Beans - tinukoy sa detalye ng JPA (Java Persistence API) at ginagamit upang mag-imbak ng data;
• Session Beans.

Ang huli (session beans) ay nahahati sa ilang mga subtype:

• stateless (walang estado);
• stateful (na may suporta para sa kasalukuyang estado ng session);
• singleton (isang bagay para sa buong aplikasyon; simula sa EJB 3.1).

Sa ibaba ay titingnan natin ang bawat uri ng bean nang mas detalyado.

Session Beans

Ang Session Beans, o session beans, ay isang partikular na uri ng bean. Isinasama nila ang lohika ng negosyo na maaaring gamitin ng kliyente sa pamamagitan ng programa sa pamamagitan ng pagtawag sa mga pamamaraan ng bean. Maaaring gawin ng isang method call:

• lokal, ng isa pang klase sa parehong JVM bilang session bean;
• malayuan, sa network, mula sa isa pang JVM, gamit ang teknolohiyang Java RMI (Remote Method Invocation).

Ang salitang "session" ay nagpapahiwatig na ang bean ay magagamit lamang habang ang server ay nagsasagawa ng isang partikular na gawain at hindi na mababawi pa kung sakaling magkaroon ng pagkabigo o pagsasara ng server. Ang cycle ng buhay ng isang session bean instance ay kinokontrol ng isang EJB container (maaari kang magbasa nang higit pa tungkol sa mga EJB container sa unang lecture ng serye ). Ang stateless session beans ay hindi nag-iimbak ng impormasyon tungkol sa kanilang estado. Ang ganitong uri ng sangkap ay maaaring gamitin ng iba't ibang mga kliyente. Ang mga stateless bean ay ginagamit upang ipatupad ang mga proseso ng negosyo na maaaring kumpletuhin sa isang operasyon. Halimbawa, pagsuri sa kasaysayan ng kredito ng mga kliyente. Dahil ang isang solong bean instance ay maaaring gamitin ng maraming kliyente, ang developer ay dapat magbigay ng thread-safe na access sa data ng bean. Ang paglikha ng isang bean ng ganitong uri (pati na rin ang lahat ng iba pang session beans) ay medyo simple. Ito ay isang regular na klase ng Java na may anotasyon @Stateless. Magbigay tayo ng isang halimbawa sa ibaba:

import javax.ejb.Stateless;

@Stateless
public class StatelessEjbExample {
    public String sayHi() {
        return "Hi, I'm Stateless EJB!";
    }
}

Ang mga session bean na sumusuporta sa kasalukuyang estado ng session (Stateful) ay nagpapanatili ng impormasyon tungkol sa kanilang estado sa pagitan ng mga tawag dito mula sa parehong kliyente at winakasan ang kanilang pag-iral sa isang tahasang kahilingan mula sa kliyente. Ito ay nakamit dahil sa ang katunayan na ang stateful beans ay natatangi para sa bawat kliyente. Isang halimbawa ng isang gawain kung saan maaaring maging responsable ang ganitong uri ng bean ay ang pagpapanatiling napapanahon ang shopping cart sa isang online na tindahan para sa bawat user. Ang ikot ng buhay ng mga bean na ito ay pinamamahalaan ng lalagyan ng EJB. Ang mga beans na ito ay nasisira din kapag lumabas ang kliyente. Ang mga naturang beans ay medyo madali ring likhain. Ito ay isang klase ng Java na minarkahan ng anotasyon Stateful. Halimbawa sa ibaba:

import javax.ejb.Stateful;

@Stateful
public class StatefulEjbExample {
    public String sayHi() {
        return "Hi, I,m Stateful EJB";
    }
}

Ang singleton session beans ay sinisimulan nang isang beses sa buong buhay ng aplikasyon at umiiral para sa buong buhay ng aplikasyon. Ang mga naturang beans ay idinisenyo para sa mga sitwasyon kung saan ang isang estado ay dapat ibahagi sa lahat ng mga kliyente. Tulad ng stateless beans, sa standalone beans kailangan ng developer na tiyakin na ang bean ay may thread-safe na kapaligiran. Magbigay tayo ng isang halimbawa ng isang Singleton bean, na kasing daling gawin ng mga katapat nito, na tinalakay sa itaas. Madaling hulaan na ito ay isang Java class na may annotation @Singleton. Gayunpaman, sa kasong ito kailangan mong maging maingat. Mayroong dalawang anotasyon, magkapareho sa syntax, ngunit magkaiba sa layunin at matatagpuan sa magkakaibang mga pakete:

• javax.ejb.Singleton
• javax.inject.Singleton

Upang lumikha ng isang EJB, dapat mong gamitin ang anotasyon mula sa javax.ejb. Halimbawa sa ibaba:

import javax.ejb.Singleton;

@Singleton
public class SingletonEjbExample {
    public String sayHi() {
        return "Hi, I'm Singleton EJB!";
    }
}

Message Driven Beans

Ang Message Driven Beans, o MDBs, o message-driven beans, ay nagpapatupad ng ilang logic sa negosyo, tulad ng session beans. Ngunit hindi tulad ng mga kamag-anak nito, ang MDB ay may isang mahalagang pagkakaiba. Ang mga kliyente ay hindi kailanman direktang tumawag sa mga pamamaraan ng MDB. Ang ganitong mga bean ay kadalasang nagsisilbing mga tagapakinig para sa mga mensahe ng JMS (Java Message Service) at nagsisilbing ayusin ang asynchronous na pagpapalitan ng mensahe sa pagitan ng mga bahagi ng system. Ang isang halimbawa ng naturang mensahe ay isang kahilingan para sa paghahatid ng imbentaryo mula sa isang automated retail system patungo sa isang supply management system. Nasa ibaba ang isang halimbawa ng isang MDB bean. Hindi tulad ng session beans, ang paglikha nito ay medyo mas kawili-wili:

import javax.annotation.Resource;
import javax.ejb.MessageDriven;
import javax.ejb.MessageDrivenContext;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(mappedName = "jms/TestQueue")
public class MessageDrivenEjbExample implements MessageListener {

    @Resource
    private MessageDrivenContext messageDrivenContext;

    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage msg = (TextMessage) message;
                msg.getText();
            }
        } catch (JMSException e) {
            messageDrivenContext.setRollbackOnly();
        }
    }

}

MessageDrivenGinagawang bean ng anotasyon ang aming MDB class. Sa loob ng anotasyon, gamit ang JNDI (basahin ang tungkol sa JNDI dito ), ang pangalan ng pamamahagi ng JMS ay tinutukoy, kung saan ang aming klase ay nagiging tagapakinig. Bilang karagdagan, ipinapatupad ng aming klase ang interface MessageListenerat ang pamamaraan nito onMessage. Tatawagin ang paraang ito kapag dumating ang ilang mensahe mula sa pila/distribusyon na may tinukoy na pangalan sa loob ng anotasyon MessageDriven.

Entity beans

Bahagi ng teknolohiya ng EJB ang detalye ng JPA. Ang JPA, o Java Persistence API, ay isang detalye na nagbibigay ng Object-Relational Mapping (ORM) ng mga Java object (Entity beans) at nagbibigay ng API para sa pag-iimbak, pagkuha, at pamamahala ng mga naturang bagay. Binibigyang-daan ka ng JPA na kumatawan sa data mula sa isang database bilang mga Java object, pati na rin ang pag-save ng mga object ng Java bilang mga tala sa database. Hindi lahat ng klase ay maaaring kumilos bilang isang bagay, ngunit Entity beans. Ang Entity Bean ay isang Java class na kumakatawan sa isang table sa isang database. Ang pagpapakita (mapping) ay nakakamit sa pamamagitan ng paggamit ng mga espesyal na anotasyon. Sa kanilang tulong, ang isang Java class ay inihambing sa isang table sa database, pati na rin ang mga field ng isang Java class ay inihambing sa mga field ng isang database table. Narito ang isang halimbawa ng isang Entity bean, na may mga komento sa code:

@Entity // Делает данный класс Entity бином
@Table(name = "employee") // "Связывает" данный класс с таблицей employee в БД
public class Employee implements Serializable {

    @Id // Говорит о том, что поле ниже является первичным ключом
    @GeneratedValue(strategy = GenerationType.AUTO) // Определяет тип генерации значений первичного ключа
    private int id;

    @Column(name="name") // "Связывает" поле ниже с полем name в таблице employee в БД
    private String name;

    @Column (name="age") // "Связывает" поле ниже с полем age в таблице employee в БД
    private int age;

    // getters and setters...
}

Kapansin-pansin na ang ganitong uri ng bean ay makatuwirang pag-aralan lamang sa konteksto ng pag-aaral ng detalye ng JPA.

Pagsusulat ng aplikasyon: EJB HelloWorld

Sa seksyong ito, magsusulat kami ng isang maliit na Java EE HelloWorld application, na aming i-deploy sa server ng GlassFish. Bago basahin ang artikulong ito, lubos na inirerekomenda na basahin mo ang artikulo sa pag-set up ng iyong lokal na kapaligiran .

1. Gumawa ng bagong proyekto ng Maven sa IntelliJ IDEA.

   File -> Bago -> Proyekto...

2. I-click ang Susunod .

3. Punan ang mga parameter ng proyekto ng Maven:

4. I-click ang Tapos na

5. Ang proyekto ay nilikha at may sumusunod na istraktura:

Ang pom.xml file ay ganito ang hitsura: Una sa lahat, kailangan naming magdagdag ng dependency sa Java EE API, at tukuyin din ang packaging ng aming proyekto sa anyo ng isang web application archive (digmaan). Upang gawin ito, kailangan mong baguhin ang pom.xml code sa sumusunod na form:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javarush.lectures</groupId>
    <artifactId>ejb_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
    </dependencies>

</project>

Susunod, maaari kang magpatuloy sa Java code. Ang aming aplikasyon ang magiging pinakasimpleng. Magkakaroon tayo ng 1 servlet at 1 EJB. Ito ay magiging isang stateless session bean. Sa loob ng EJB ay tutukuyin lamang namin ang 1 paraan na magbabalik ng string na "Hello World". Una sa lahat, gumawa tayo ng package com.javarush.lectures. Pagkatapos, sa loob ng package com.javarush.lectures, gagawa kami ng aming bean - DemoEJB. Ang bean code ay ibinigay sa ibaba:

import javax.ejb.Stateless;

@Stateless
public class DemoEJB {
    public String helloWorld() {
        return "Hello world!";
    }
}

Tulad ng sinabi kanina, ang lahat ay medyo simple. Ang aming susunod na hakbang ay lumikha ng isang servlet na magpapasa ng halaga mula sa EJB bilang tugon sa kahilingan ng HTTP. Mahalagang tandaan na ang mga servlet ay hindi ang paksa ng artikulong ito, ngunit kakailanganin mo pa ring gamitin ang mga ito upang ipakita ang EJB. Para magawa ito, gumawa tayo ng bagong servlet DemoServletsa parehong pakete ng EJB. Nasa ibaba ang code nito:

@WebServlet("/helloWorld")
public class DemoServlet extends HttpServlet {

    @EJB
    private DemoEJB ejb;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write(ejb.helloWorld());
    }
}

Narito ang ilang maikling komento sa code. Abstract @WebServlet("/helloWorld")- tumutukoy sa aming klase bilang isang servlet na magpoproseso ng mga kahilingan sa HTTP sa endpoint /helloWorld. May isang field ang klase namin - DemoEJB ejb. Ito ang aming bean na tinukoy nang mas maaga. Isang anotasyon sa isang field ng klase— @EJBnagsasagawa ng dependency injection (DI). Yung. Ang ejb variable ay awtomatikong sinisimulan sa isang bagong instance kapag kinakailangan. Ang aming klase ay isang inapo ng HttpServlet at nilalampasan ang isa sa mga superclass na pamamaraan - doGet. Pinoproseso ng pamamaraang ito ang mga kahilingan sa HTTP GET at tumatagal ng dalawang parameter - HttpServletRequestat HttpServletResponse. HttpServletRequestnagsisilbi upang makakuha ng impormasyon tungkol sa isang papasok na kahilingan sa HTTP. HttpServletResponsekinakailangan upang makabuo ng tugon sa isang kahilingan. Sa loob ng pamamaraan, nakukuha namin ang bagay PrintWritermula sa object ng tugon ( HttpServletResponse), gamit ang getWriter(). Susunod, maaari tayong magsulat ng ilang halaga sa nagresultang bagay gamit ang write. Na, sa katunayan, ang ginagamit namin sa pamamagitan ng pagsusulat sa PrintWriter-a object ng value na nakuha mula sa EJB na tinukoy namin (ang value ay ang string na "Hello World!"). Ang kliyente na nagpadala ng kahilingan sa HTTP ay makakatanggap ng halagang ito bilang tugon sa kahilingan nito. Ang susunod na hakbang ay ilunsad ang application sa GlassFish Java EE server. Upang gawin ito, gagawa kami ng bagong configuration, tulad ng inilarawan sa artikulo sa pag-set up ng lokal na kapaligiran . Nasa ibaba ang isang screenshot ng natapos na configuration para sa kasalukuyang proyekto. Tiyaking naka-install ang GlassFish server bago magsimula: Pagkatapos gawin ang configuration ng paglunsad, ilunsad ang application gamit ang Run -> Run 'ejb_demo' menu o gamit ang Shift+F10 hotkey . Pagkatapos ng paglunsad, makikita mo ang mga log nito: At gayundin ang browser na bubukas: Ang lahat ng ito ay nagpapahiwatig na ang application ay gumagana ayon sa nilalayon.

Konklusyon

Sa artikulong ito nakilala namin ang EJB - Enterprise JavaBeans. Isinaalang-alang namin ang mga tanong tulad ng:

• Ano ang EJB?
• Kasaysayan ng EJB
• Iba't ibang uri ng EJB

Tandaan na ang mga EJB ay nasa mga sumusunod na uri:

• Message Driven Beans (message driven beans);
• Entity Beans - tinukoy sa detalye ng mga entity ng JPA (Java Persistence API) at ginagamit upang mag-imbak ng data;
• Session Beans:
  • walang estado (walang estado)
  • stateful (na may suporta para sa kasalukuyang estado ng session)
  • singleton (isang bagay para sa buong aplikasyon; simula sa EJB 3.1)

Sumulat din kami ng isang maliit na HelloWorld application gamit ang EJB. Bilang isang PD, maaari mong ulitin ang praktikal na bahagi ng artikulong ito sa iyong sarili. At pagkatapos ay magdagdag ng dalawa pang servlet sa iyong application na gagamit ng stateful at singleton beans upang matanggap ang halaga.