VŠB Technická univerzita Ostrava. Fakulta elektrotechniky a informatiky. Katedra informatiky. Enterprise Java Beans historie, současnost a budoucnost

VŠB – Technická univerzita Ostrava Fakulta elektrotechniky a informatiky Katedra informatiky

Enterprise Java Beans – historie, současnost a budoucnost

2006

Roman Musialek

Prohlášení:

Prohlašuji, že jsem tuto bakalářskou práci vypracoval samostatně. Uvedl jsem všechny literární prameny a publikace, ze kterých jsem čerpal

Datum: ………………

Podpis:…………………

Abstrakt: Cílem tohoto projektu, je seznámit se v rozsáhlou strukturou tvorby komponent pomoci Enterprise Java Beans. Tato technologie je poměrně mladá, ale už dosáhla značného rozšíření, které jsem měl zhodnotit. Stručně jsem popsal každou ze tři uvedených verzi Enterprise Java Beans a naznačil nové prostředky v té nejnovější, která ještě nevyšla ve finální verzi.

Klíčová slova : Enterprise Java Beans, Session bean, Entity bean, Message-Drive bean, Kontejner, Deskriptor.

Abstrakt:

The aim of the project is familiarisation with the extensive structure of a procedure, for the creation of components by means of Enterprise Java beans. Although this technology is relatively recent it has already attained a considerable expansion, which I was to review. I described, in brief, each of the three presented versions Enterprise Java beans and suggested new resources in the latest version that has not yet been published in a final form.

Klíčová slova : Enterprise Java Beans, Session bean, Entity bean, Message-Drive bean, Conteiner, Descriptor.

Seznam zkratek EJB – Enterprise Java Beans – platforma pro kterou jsou tyto komponenty vyvíjeny HTTP - HyperText Transfer Protocol HTTPS - Hypertext Transfer Protocol over Secure Socket Layer JNDI – (Java Naming and Directory Interface) – využívá se pro umístění a následné vyhledání entit. Umožňuje vystavit komponentu na serveru neboli zpřístupnit klientům. POJO – Objekt Javovské třídy, který v sobě zapouzdřuje vlastnosti. QL - Query Language – dotazovací jazyk pro práci s tabulkami RMI - Remote Method Invocation SMTP - Simple Mail Transfer Protocol TCP - Transmission Control Protocol WSDL - Web Services Description Language

CMP - Container-Managed Persistence Entity Bean BMP - Bean-Managed Persistence Entity Bean

Obsah: Obsah:....................................................................................................................................1 1 Úvod ..............................................................................................................................2 2 Historie a požadavky na systémy ....................................................................................3 2.1 Historie vývoje techniky komunikace .....................................................................3 2.2 Enterprise Java Beans – popis technologie ..............................................................4 2.2.1 Enterprise Java Beans – vývoj technologie ......................................................5 2.2.2 Enterprise Java Beans – role............................................................................5 3 EJB – komponenty .........................................................................................................7 3.1 EJB - verze 1.0 a 1.1 ...............................................................................................7 3.2 EJB –verze 2.0 a 2.1 ...............................................................................................8 3.2.1 Důležitá rozhraní.............................................................................................8 3.2.2 Remote Interface .............................................................................................9 3.2.3 EJBObject .....................................................................................................10 3.2.4 Local Interface ..............................................................................................10 3.2.5 Home Interface..............................................................................................11 3.2.6 Local Home Interface....................................................................................12 3.2.7 Bean class .....................................................................................................12 3.2.8 Deployment Deskriptor .................................................................................13 4 Enterprise JavaBeans 3.0 ..............................................................................................14 4.1 Klienti v EJB 3.0...................................................................................................14 4.2 SESSION BEANY ...............................................................................................15 4.2.1 Session beany – Stateles................................................................................16 4.2.2 Session Beany – Stateful ...............................................................................18 4.3 Entitní beany.........................................................................................................20 4.3.1 Vazby v tabulkách.........................................................................................21 4.3.2 Entity manager ..............................................................................................22 4.3.3 Jazyk EJB QL ...............................................................................................23 4.4 Message-Driven bean............................................................................................23 5 Aplikační servery .........................................................................................................25 5.1 Aplikační server JBOSS........................................................................................25 5.2 Aplikační server SUN ...........................................................................................25 5.3 Aplikační server ORACLE ...................................................................................25 5.4 Aplikační server IBM ...........................................................................................25 6 Praktická část ...............................................................................................................26 6.1 Administrátorská část............................................................................................28 6.2 Uživatelská část ....................................................................................................28 7 Závěr ............................................................................................................................29 8 Přílohy:.........................................................................................................................31

1

1 Úvod Tématem této bakalářské práce je seznámení se s tématikou Enterprise Java Beans a jejími možnostmi. V kapitole 2 objasním historii a požadavky na systémy.V kapitole 3 budou vysvětleny Enterprise Java Bean komponenty.Enterprise Java Bean 3.0, hlavní téma mé práce, bude popsáno v kapitole 4 .V kapitole 5 budou popsány nejznámější aplikační servery a jejich podpora Enterprise Java Bean 3.0. Kapitola 6 obsahuje praktickou část práce. V závěrečné 7 kapitole zhodnotím možnosti tohoto nástroje při tvorbě informačních systému s vyhlídkou na možnosti využití v budoucnosti.

2

2

Historie a požadavky na systémy Rychlý rozvoj výpočetní technologie našel široké uplatnění ve všech odvětvích. Při tomto rozvoji výpočetní techniky se rozvíjely i informační technologie s vyššími požadavky na jejich skladbu. Rozvíjely se různé programovací jazyky, ve kterých se využívaly objektově orientované technologie. Vytvářely se různé informační systémy. Zároveň dochází k značnému rozvoji internetu a aplikací od něj se odvíjejících.

2.1 Historie vývoje techniky komunikace V tomto směru se stal asi nejrychleji se rozvíjející programovací jazyk JAVA vyvinut firmou SUN. Tento programovací jazyk neskrýval v sobě jen jednoduché programování, ale postupným vývojem zapouzdřoval čím dál větší komplexní vývojový balík. Uvedený programovací jazyk je přenositelný, tedy je možné jej provozovat na různých platformách. V současné době je nejvíce využívána technologie klient – server. Na straně klienta běží tzv. uživatelské rozhraní, které komunikuje s klientem. Toto rozhraní lze reprezentovat pomoci HTML stránek zobrazujících se ve webovém prohlížeči, nebo klientem na příkazovém řádku. Server zajišťuje uchovávání dat, které používá aplikace. Serverovou část lze rozdělit na dva podsystémy a to aplikační server a databázový server. Aplikační server – je stroj, na kterém jsou provozovány veškeré logické operace týkající se práce s daty. V současnosti je nutné, aby poskytoval víceuživatelský přístup zajištěný bezpečným provozem. Zajišťuje urychlení provozu pomoci ukládání dat v cache paměti a provoz pomoci paralelních akcí. Databázový server – nám poskytuje možnosti práce s daty. Stará se o jejich uchovávání, vyhledávání a předávání potřebných dat aplikaci. Technologie, které se dnes používají při tvorbě aplikací využívají již připravených komponent, mezi které patří i Enterprise Java Beans.

3

obrázek č.1. Databázový model. Zdroj[5]

2.2 Enterprise Java Beans – popis technologie Jednodušší definicí lze říct, že se jedná o technologii, která umožňuje vyvíjet znovu použitelné komponenty pro JAVU. Výhodou pro výrobce aplikací je, že se mohou zaměřit na psaní logiky aplikace, ve které budou využité vlastnosti jednotlivých komponent.

obrázek č.2. Model EJB Zdroj[5]

4

Výše uvedený obrázek nám znázorňuje nasazení této technologie do praxe. Toto spojení nám umožňuje vytváření velkého subsystému. Klient naváže spojení se zadaným EJB serverem, který sdílí komponentu a umožní klientům její využití. U tohoto EJB serveru je EJB kontejner, kde se všechny komponenty shromažďují a vykonávají svou činnost. Tato technologie umožňuje práci se všemi možnými způsoby komunikace.

2.2.1 Enterprise Java Beans – vývoj technologie Jako první provedla specifikaci koncem roku 1997 firma SUN. Definuje systém služeb aplikačního serveru a s tím spojeného umožňování přesouvání komponent mezi kontejnery. Komponenta představuje programovací model, který dovolí vývojáři soustředit se na konkrétní účel dané komponenty. Enterprise Java Beans server je zodpovědný za danou komponentu v něm distribuovanou a s ní spojené služby jako jsou transakce, perzistentnost, soudržnost a bezpečnost. Koncový výsledek je, že Enterprise Java Beans vytváří rozvíjení distribuovaných komponentních systému, jež jsou zařazené v robustním transakčním systému o mnoho jednodušší. V roce 1998 byl dokončen první produkt, který byl pojmenován Enterprise Java Beans 1.0, který se rychle stal standardem. Tato verze byla několikrát modifikovaná. V roce 1999 na verzi 1.1. Další modifikace proběhla v roce 2001 a to na verzi 2.0 a 2.1. V roce 2005 byla vypuštěna beta verze 3.0, která je zatím poslední.

2.2.2 Enterprise Java Beans – role Architektura EJB definuje šest základních rolí ve vývoji a distribuci komponent. Je možné, že každá z těchto rolí bude vykonávána jinou skupinou programátorů a tak architektura definuje scénáře jednotlivých rolí tak, aby výsledek byl kompatibilní.

Základní role jsou: a) Vývojář EJB komponent zodpovídá za vytvoření komponenty. Vytvoření EJB

komponenty zahrnuje tyto kroky: 1) 2) 3) 4) 5)

Vytvoření tříd implementujících obchodní logiku komponenty. Vytvoření třídy splňující požadavky na EJB komponenty Vytvoření domovského rozhraní (home interface) komponenty Vytvoření vzdáleného rozhraní (remote interface) komponenty Vytvoření popisného souboru komponenty (deployment descriptor)

6) Vytvoření JAR archívu, jenž obsahuje výsledky všech předcházejících kroků. b) Návrhář aplikace nemusí podrobně znát vnitřní strukturu EJB komponenty, ale

musí umět pracovat s popisnými soubory komponent. Existující EJB komponenty spojuje do větších logických celků, čímž vytváří jeden nebo více JAR archívů. Tyto archívy dohromady tvoří aplikaci nebo její logickou část a návod

5

k instalaci aplikace na libovolném EJB serveru. Návrhář aplikace může také spojovat EJB komponenty s jinými architekturami např. JSP, servlety apod. c) Deployer instaluje aplikace na specifickém operačním prostředí, jenž obsahuje EJB server a EJB kontejner. Deployer musí umět ošetřit a přiřadit aplikaci odkazů na všechny externí zdroje, které návrhář dané aplikace přiřadil. Musí také postupovat podle návodu k instalaci aplikace, kterou vytvořil návrhář. Výsledkem práce je instalovaná aplikace na specifickém kontejneru daného EJB serveru. d) Poskytovatel operačního prostředí (EJB server provider) je specialistou na oblas-

ti nízko úrovňových programovacích architektur. Jedná se o poskytovatele operačního nebo databázového systému. e) Poskytovatel EJB kontejneru (EJB container provider) je většinou součástí ope-

račního prostředí. Poskytuje pro EJB komponenty bezpečnostní a transakční služby, síťovou distribuci klientů apod. f) Systémový administrátor (System Administrator) je zodpovědný za konfiguraci a administraci operačních a síťových prostředků, ke kterým patří i EJB server a kontejner. Je taktéž zodpovědný za sledování správného běhu EJB komponent.

6

3 EJB – komponenty Nyní si představíme základní komponenty, které se využívají a projdeme si jejich postupný vývoj od nejstarší verze, až po nejnovější, kterou si popíšeme trochu podrobněji.

3.1 EJB - verze 1.0 a 1.1 EJB 1.0 – Session beany Chápeme to jako akce, které aplikace musí vykonávat. Implementuji rozhraní javax.ejb.SeesionBean, čímž je zajištěno zpětné volání potřebných metod. Existují dva typy beanu sezení. a) Stavový bean sezení, který je použit při požadavku na sledování chování klienta v časových intervalech. Např. nakupování v internetovém obchodě. Při změně stavu tohoto beanu se změna přenese i do dalších stavů, do kterých tento bean přejde. b) Bezestávový bean sezení – v tomto případě není nutné přenášet stav mezi klientem a beanem. Při volaní metody lze tedy aktuální stav beanu zapomenout neboli ztratit. Tento bean si může udržovat stav, který není závislý na klientovi. Příkladem může být komponenta pro vyhledávání. . Obě dvě sezení vyžadují metodu zpětného volání ejbRemove, která je volaná kontejnerem těsně před zrušením instance beanu. Pro využívání komponenty se postupuje podle následujícího scénáře. Je nutné získat počáteční kontext, poté se vyhledá třídní objekt. Pomoci tohoto objektu se založí lapač požadavku od klienta a volá se metoda create, posílání požadavku a nakonec odstranění handleru a instance.

EJB 1.1. – Entitní beany U této verze byly poprvé použity Entitní beany. Jde o beany, které slouží pro modelování dat. Tyto beany reprezentují data v databázi. Jsou to objekty, které se umí synchronizovat s obsahem databáze. Jedna instance beanu odpovídá jednomu řádku relační databáze. Při založení beanu vznikne nový řádek tabulky. Pokud chce více klientů přistupovat ke stejným datům databáze, musí existovat více instancí stejného entitního beanu.I zde existují dva typy Entitních beanu, které se od sebe liší způsobem synchronizace obsahu beanu. a) První způsob se nazývá perzistence spravovaná beanem (BMP). Tato synchronizace se provádí pomoci metod zpětného volání, které volá kontejner. Tyto metody musí realizovat programátor. b) Druhým možným způsobem je perzistence spravovaná kontejnerem (CMP). U tohoto způsobu nám provádí synchronizaci kontejner. Podle potřeby založí novou tabulku, nebo provede synchronizaci beanu a da-

7

tabáze. Všechny tyto operace spadají pouze na kontejner, kdy se rozhodne pro její provedení. Pro entitní beany a jejich třídní objekty je potřebné využití zachytávání požadavků na vyhledávání. Vyhledávání je náročný proces a je potřebné zajistit správné nalezení patřičného beanu, což může být v určitých okolnostech dosti náročné.

3.2 EJB –verze 2.0 a 2.1 Při dalším vývoji se objevily nové možnosti použití této technologie. Významnou novinkou byla možnost lokálního rozhraní pro Session beany, což velmi ulehčilo práci s danou komponentou. Nebylo nutné volat vzdálené rozhraní, ale bylo využíváno rozhraní pro lokální stranu, tedy pro dané umístění v konkrétním místě. Velkým přínosem bylo uvedení nového druhu komponenty, která se jmenuje Message – driven bean. Komponenta může přijmout a odeslat asynchronní zprávy. Enterprise Java Beans 2.1. rozšířil programový model tohoto beanu o možnost přiřazení systémových zpráv jiných systému. Vývojáři mohli využit tohoto beanu pro práci s protokoly, které byly podporovány. Je to například SMTP protokol pro posílání emailu, SNMP pro ovládání řízení systému, protokol TCP a mnoho dalších. Tato komponenta dovoluje posílání zpráv i jiným nezávislým aplikacím v daném systému.

3.2.1 Důležitá rozhraní •

Remote interface – definuje metody beanu, které musí specifikovat pro vzdálené volání aplikace v konkrétním EJB kontejneru. Rozšiřuje knihovnu javax.ejb.EJBObject, která rozšiřuje java.rmi.Remote. Je provozován entity and session beany spolu s remote home interface.

•

Remote home interface – definuje životní cyklus metod, který můžou uživatelské aplikace využívat v EJB kontejneru. Životnost metod znamená vytvoření beanu, hledání beanu a smazání beanu. Toto rozhraní rozšiřuje javax.ejb.EJBHome, které je rozšířením java.rmi.Remote. Je provozováno session and entity beany spolu s remote interface.

•

Local interface – definuje stejné metody, které mohou být používány jinými beany ve stejném EJB kontejneru. Toto ovlivňování jiných beanu je zajištěno pomoci nějakého distribuovaného objektového protokolu. Toto rozhraní je rozšířením javax.ejb.EJBLocalObject. Je provozováno session beany a entity beany spolu s local home interface.

•

Local home interface – definuje životní cyklus metod, které můžou využívat jiné beany ve stejném EJB kontejneru. Životnost metod daného beanu znamená přenesení na jiný bean ve stejném EJB kontej-

8

neru. Toto přenášení je opět zajištěno pomocí distribuovaného objektového protokolu. •

Message interface – Message driven beans implementující rozhraní pro práci se zprávami, které jsou definované pro zprávy systému jako je Java Message Services, který umí doručovat zprávy pro konkrétní beany.

•

Bean class – určuje class třídu session nebo entity bean, kde jsou definovaný životní entity. Obvykle v sobě neobsahuje implementaci remote nebo local komponentní rozhraní, ale implementuje v sobě koncové body.

Důležité soubory •

Deployment deskriptor – je XML soubor, kde je poskytnut seznam vlastností, které vývojář vytvořil pro daný bean. Tyto hodnoty jsou správně naplněny při instalaci do Enterprise Java Beans prostředí.

•

EJB-jar file – koncový zabalený soubor obsahující všechny soubory. Tento soubor se přenese na aplikační server. Aplikační server tento soubor rozbalí a načte všechny beany.

3.2.2 Remote Interface Toto rozhraní popisuje metody beanu, které chce výrobce komponenty zpřístupnit pro klientskou aplikaci. Volání těchto metod od klienta se děje přes třídu implementující EJBObject. Jména metod v tomto rozhraní musí souhlasit se jmény metod v beanu. V našem případě bude realizovaná jedná metoda hello(), která vrátí String a to Hello World.

Příklad: Package examples; /** * This is the HelloBean remote interface * * This interface is what clients operate on when they

9

* interact with EJB objects. The container vendor will * implement this interface; the implemented object is * the EJB object, which delegates invocations to the actual bean. */ public interface Hello extends javax.ejb.EJBObject { /** * The one method – hello – returns a greeting to the client. /* public String hello() throws java.rmi.RemoteException; }

Text je použit z literatury: [3]

3.2.3 EJBObject Jde o třídu, která je základem komponent. Tato třída implementuje remote interface komponenty. Takto vypadá definice rozhraní:

package javax.ejb; public interface EJBObject extends Remote { public abstract EJBHome getEJBHome() throws RemoteException; public abstract Object getPrimaryKey() throws RemoteException; public abstract void remove() throws RemoteException, public abstract Handle getHandle() throws RemoteException; public abstract boolean isIdentical(EJBObject ejbobject) throws RemoteException; }

3.2.4 Local Interface Rozhraní pro využívání komponenty na lokální straně. Aplikace bude ve stejném EJB kontejneru jako daná komponenta. Příklad:

Package examples; /** * This is the HelloBean local interface

10

* * This interface is what local clients operate on when they * interact with EJB local objects. The container vendor will * implement this interface; the implemented object is the * EJB local object, which delegates invocations to the actual bean. */ public interface HelloLocal extends javax.ejb.EJBLocalObject { /** * The one method – hello – returns a greeting to the client. /* public String hello() ; }

Text je použit z literatury: [3]

3.2.5 Home Interface Představuje rozhraní, které používá klient k vytváření komponenty. Je zde minimálně jedna metoda create(), která zajišťuje inicializaci komponenty. Toto rozhraní je vygenerované EJB kontejnerem. Při požadavku na toto rozhraní, EJB server zpřístupní referenci. Součásti tohoto rozhraní můžou být také metody pro zrušení instance a metadata pro získání informací o komponentě. Příklad: Package examples; /** * This is the home interface for HelloBean. * This interface is implemented by the EJB Server’s tools – * the implemented object is call the Home Object, and server * as a factory for EJB Objects. * * One create() method is in this Home Interface, which * corresponds to the ejbCreate() method in HelloBean. */ public interface HelloHome extends javax.ejb.EJBHome { /** * This method create the EJB Object * *@return the newly created EJB Object /* Hello

create() throws java.rmi.RemoteException,

11

javax.ejb.CreateException; }

Text je použit z literatury: [3]

3.2.6 Local Home Interface Toto rozhraní může být využito v případě, že klienti nebo jiné enterprise beany budou v rámci jednoho JVM. Výhodou je větší rychlost, jelikož vytváření vzdáleného objektu vyžaduje vytvoření stubů a skeletonů a přenos většího množství dat přes síť. V případě použití local interface dostaneme referenci „opravdový“ java objekt. V prvním případě dostaneme stub vzdáleného objektu. Příklad: Package examples; /** * This interface is implemented by the EJB Server’s tools – * the implemented object is call the local Home Object, * and server as a factory for EJB local Objects. * */ public interface HelloLocalHome extends javax.ejb.EJBLocalHome { /** * This method create the EJB Object * *@return the newly created EJB Object /* HelloLocal }

create() throws javax.ejb.CreateException;

Text je použit z literatury: [3]

3.2.7 Bean class Je jednoduchá komponenta, která poskytuje obecné metody pro správu beanu. Ukázka je uvedena v příloze.

12

3.2.8 Deployment Deskriptor EJB kontejner nic neví o naších třídách. Z těchto důvodů musíme dodat informace, která třída jaké věci obsahuje a k čemu je určena. Dále EJB kontejner potřebuje vědět jaká bezpečnost a transakce má být použitá. Všechny tyto potřebné informace získá z Deployment deskriptoru. Třídy mohou být sbaleny do JAR souboru, což je ZIP soubor vytvořený z package JAVA tříd. V takovém případě deskriptor musí přesně určit, který z tohoto JAR souboru se má použít a jak se k němu lze dostat. V EJB 1.0 zajišťovala tento deskriptor jedná třída která byla z rozhraní serializable. Od verze 1.1 se začal používat kompaktnější nástroj a v dnešní době velice používaný nástroj a to je XML. Jde tedy o textový dokument, ve kterém se pomoci tagů určí všechny potřebné informace o struktuře aplikace. XML je standardizovány jazyk, což by mělo zajistit dostupnost. S verzemi 2.0 a pozdější 2.1. byl použit i DTD model zajišťující přesné informace pro deskriptor. Verze 2.1 se taky liší o různé specifikace tak jak se rozvíjel i XML standart.

Jednoduchá ukázka XML souboru pro EJB verzi 2.1 <ejb-jar xmlns=”http://java.sun com/xml/ns/j2ee” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://java.sun.com/xml/ns/j2ee” “http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd” version=”2.1”> <enterprise-beans> <entity> <ejb-name>CabinEJB com.titan.CabinHomeRemote com.titan.CabinRemote <ejb-class> com.titan.CabinBean Container <prim-key-class>java.lang.Integer False

Text je použit z literatury: [3]

13

4 Enterprise JavaBeans 3.0 Technologie psaní komponent, která byla uvolněna do provozu koncem roku 2005 a to zatím pouze v beta verzi. Firma SUN si uvědomila přílišnou složitost dřívější podoby této technologie a rozhodla se pro mnoho novinek inspirovaných v Hibernatu a Springu. Přišla ze snahou o ulehčení práce programátora a zjednodušení práce s třídami. Podle charakteristiky dokumentace by tato technologie oproti starší verzi měla mít tyto výhody. a) Definovat pro jazyk Java tzv. anotace, které by měly ulehčit práci při vytváření komponent a tříd. Tedy jejich spojování s patřičnými rozhraními pro deskriptor komponenty a eliminovat práci programátora pro psaní všech potřebných tříd. b) Specifikace programového standardu, aby bylo umožněno pro EJB kontejner pracovat s požadavky a odpověďmi na ně.

c) Eliminovat požadavky pro Enterprise Java Beans komponentní rozhraní session beanu. Požadovat veřejné rozhraní pro session bean než rozhraní Enterprise Java Bean Object, Enterprise Java Bean Local Object a Remote rozhraní.

d) Zajistit podporu pro ulehčení modelování domény entitního beanu a s tím spojené mnohotvárnosti a polymorfismu.

e)

Specifikace jazyka Java pro anotace a XML deskriptor rozmístění elementu pro relační mapování perzistentních entit.

f) Rozšíření Enterprise Java Bean QL jazyka pro základní operace s daty (mazání, hledání, vkládání) a dále pro třídění a tvorbu poddotazů spojených s co největší podpora pro jazyk SQL. Všechny výše uvedené novinky jsou rozebrané detailněji v následující části.

4.1 Klienti v EJB 3.0 Klient používá aplikační logiku, která je reprezentována na straně serveru. Klient nikdy nepřistupuje přímo k beanu, ale přistupuje k rozhraní tohoto beanu, kdy je tento bean připraven k inicializaci a poté k činnosti. Klienti mohou být:

14

1) Lokální 2) Vzdálený

Lokální klient – bude svázán se session beanem ve stejném virtuálním stroji. Lokální klientem může být i jiná komponenta, která je ve stejném Enterprise Java Beans kontejneru nebo webová komponenta. Přístup v této technologii je proveden pomocí local business rozhraní. Na rozdíl od technologie 2.1, kde toto bylo řešeno pomocí local home objektu beanu a lokálního rozhraní komponenty. V případě vytvoření objektu této komponenty v kontejneru, jedná se o normální JAVA objekt. Při volání metod komponenty jde o lokální volání. Výsledky a argumenty jsou předávány pomoci referencí neboli odkazů a to hlavně u jednoduchých datových typů. U ostatních se tyto reference mohou předávat jako objekty.

Vzdálený klient – může být reprezentován pomoci Enterprise java Beanu umístěného ve stejném nebo jiném kontejneru. Taktéž může být reprezentován pomoci klienta napsaného v JAVĚ. V EJB 3.0 vzdálený klient přistupuje k session beanu pomocí remote business rozhraní. Vzdálený klientský pohled na tuto komponentu je umístěn nezávisle. Klient poté běží ve stejném virtuálním Java stroji jako instance tohoto beanu. Pro přístup k metodám je použit stejný mechanismus, jako kdyby klient běžel v jiném virtuálním stroji než komponenta. Při volání metod komponenty jde o vzdálený přístup a proto výsledky a argumenty jsou předávány hodnotou.

4.2 SESSION BEANY Požadavky na Session Bean pro verzi 3.0

1) Třída musí být definovaná jako public nemusí se jednat o třídu, která by měla být final a nemusí se jednat o abstraktní třídu. 2) Třída musí mít public konstruktor, který je bez parametrů pro inicializaci. Programátor jej nemusí implementovat, je standardně vytvořen. Samozřejmě je jakýkoli další konstruktor povolený, ale konstruktor bez parametrů již nebude vytvořen. 3) Tato třída nemusí mít v sobě implementovanou funkci finalize (), protože ta je opět standardně vytvořená a o její zavolání se postará kontejner. 4) Třída musí implementovat business rozhraní nebo metody z toho rozhraní. 5) Třída musí být schopna implementovat business metody z EJB2.1, aby bylo možné spojení s touto verzí pro klienty.

15

Pro optimální vytvoření komponenty tohoto typu by měla být třída implementovaná z rozhraní javax.ejb.SeesionBean, měla by mít metodu na vytvoření komponenty a v případě stateful beanu by se mělo jednat o rozhraní javax.ejb. Toto ale záleží na mnoha faktorech a jedním z nich je, pro jaký účel se daná komponenta vyvíjí a tedy co všechno v sobě musí implementovat.

4.2.1 Session beany – Stateles Základem tohoto typu beanu je vytvoření určitého rozhraní, které bude spjato s danou komponentou a budou v něm definovaný všechny business metody, které bude daná komponenta využívat. Toto rozhraní je zcela podobné klasickým java rozhraním a je pak využíváno kontejnerem při klientském volaní dané komponenty. Pro toto rozhraní pak můžeme realizovat patřičnou komponentu. Uvedené rozhraní se tedy stane základem jednoduché POJO. Vytvořený objekt pak patřičný kontejner spravuje a na základě požadavků inicializuje a stará se o jeho obhospodařování. Zajištění, že se jedná o stateles bean se děje pomoci anotace @Stateless, která zaručí vytvoření patřičné třídy pro tuto komponentu a kontejner bude seznámen o jakou komponentu jde. Pro komponentu musíme nadefinovat multifunkční rozhraní, tedy rozhraní pro lokální instanci a samozřejmě i pro vzdálené volání. To vše záleží na tom, zda komponenta bude využívaná jen pro lokální potřeby a nebo se bude využívat i ve vzdálených voláních. Pro lokální volaní se považuje to, když komponenta je volaná ve stejném virtuálním stroji tedy ve stejném EJB kontejneru. Lokální volání je zajištěno rozhraním, ze kterého je daná komponenta tvořena. Takové volání může být realizováno například JSP stránkou, která s danou komponentou pracuje a tedy jak komponenta tak i JSP stránka běží ve stejném EJB kontejneru. Při volání požadavku na komponentu zachytí lapač požadavku snahu o inicializaci komponenty, vidí že se jedná o lokální volání a kontejner tedy vytvoří patřičnou instanci z lokálního rozhraní dané komponenty a vrátí normální java referenci na daný objekt. Toto volání je tedy realizováno přes tuto instanci. Proto můžeme o něm říct, že by mělo být velmi rychlé a velmi účinné, neboť se nikde a složitě nemusí přenášet. Druhou možností session beanu je již zmíněné vzdálené volaní komponenty, které se děje přes tzv. vzdálené rozhraní. Je určeno pro patřičně vzdáleného klienta. Tento klient zašle požadavek o vytvoření instance komponenty. Kontejner zjistí, že se jedná o vzdálené volání dané komponenty, proto zabalí tuto komponentu a pošle její instanci na stranu klienta. Tento objekt je taky realizován pomoci java reference, ke které pak vzdálený klient přistupuje a využívá její metody. Je tedy jasné, že by takto vytvořené spojení mělo mít delší časové úseky pro práci a pro volání jednotlivých metod, ale efektivita by měla být opět velmi dobrá.

16

Ukázka jednoduchého rozhraní: @Remote public interface Shop { /** * Creates order for user * * @param user * user * @param items * items in order */ public void createOrder(User user, Map items); /** * Gets all orders in HashMap. Keys are users and values are items * * @return all orders */ }

Celý soubor je vložen do sekce Příloha Klient na takovouto komponentu, může přistupovat jak z lokální, tak i vzdálené strany. Pro přístup využije klient rozmístění komponenty v daném kontejneru, zaregistruje si patřičné JNDI pod kterým je daná komponenta přístupná a může ji využívat pomocí EJB kontejneru, který je za správnou činnost zodpovědný.

Příklad jednoduchého Stateless beanu @Stateless public class ShopBean implements Shop { @PersistenceContext private EntityManager em; /* * (non-Javadoc) * * @see shop.Shop#createItem(shop.common.Item) */ public void createItem(Item item) { em.persist(item); } /* * (non-Javadoc) * * @see shop.Shop#deleteItem(shop.common.Item) */

17

public int deleteItem(int id) { return em.createNamedQuery("deleteItem").setParameter("id", id) .executeUpdate(); } /* * (non-Javadoc) * * @see shop.Shop#getAllItems() */ public ArrayList getAllItems() { List result = em.createNamedQuery("getItems").getResultList(); return (ArrayList) result; }

Celý soubor je vložen do sekce Příloha Při vytváření těchto komponent může využít i další anotační značky, které mají ulehčit práci jak programátora tak kontejneru a to například @Local a @Remote. Tyto značky slouží pro specifikaci tříd. S tím můžou být taktéž spojené značky @LocalBinding a @RemoteBinding. Uvedené značky slouží pro specifika JNDI adresy, kde bude komponenta dostupná pro případné lokální nebo vzdálené volání.

4.2.2 Session Beany – Stateful Je vytvořen klientem a existuje jen po dobu jedné klient-server session. Je to EJB komponenta, která implementuje rozhraní javax.ejb.SessionBean. Stateful bean si uchovává stav a hodnoty atributů, které můžou být změněny každým voláním metod. •

při práci se servlety nebo JSP stránkami a případném requestu dané stránky s možností uchování patřičných hodnot pro další použití.

•

Při rozsáhlých java aplikacích, kde je zapotřebí si uchovávat nějaké hodnoty, případně nějaké stavy aplikace.

Stateful session bean opět rozšiřuje business rozhraní dané komponenty. V tomto rozhraní jsou definované všechny proměnné, které daná komponenta bude v sobě mít a samozřejmě i metody, které se budou pomocí ní dát použít pro konkrétní účely.

Příklad rozhraní pro Stateful bean @Remote public interface ShoppingCart { /**

18

* Adds item into shopping cart * * @param item */ void addItem(Item item, int quantity); /** * Remove item from shopping cart * * @param id */ void deleteItem(int id); /** * Gets all items from shopping cart. * * @return items */ }

Celý soubor je vložen do sekce Příloha Pro takto vytvořené rozhraní můžeme bez jakýchkoli obav vytvořit komponentu, ve které budeme realizovat všechny potřebné operace. Tato komponenta se vytvoří pomocí anotační značky @Stateful, která definuje typ komponenty a charakterizuje ji pro kontejner. Důležitým aspektem je, že takto vytvořená komponenta musí realizovat rozhraní Serializable, které zajišťuje, že kontejner nám umožní pro tuto komponentu spojení a skladování v případě, že daná komponenta není v daném okamžiku využívána, tedy nejsou pro ni volány žádné metody.

Ukázka Stateful beanu @Stateful public class ShoppingCartBean implements ShoppingCart { /** Shop which owns this shopping cart */ @EJB Shop shop; /** Items in shopping cart */ private Map items = new Hashtable(); /* * (non-Javadoc) * * @see shop.ShoppingCart#addItem(shop.common.Item) */ public void addItem(Item item, int quantity) { if (items.containsKey(item)) { Integer i = items.get(item); items.put(item, new Integer(i.intValue() + quantity)); } else { items.put(item, quantity);

19

} }

Celý soubor je vložen do sekce Příloha

4.3 Entitní beany Entitní beany představují objektově orientovanou reprezentaci dat. To umožňuje jednoduše reprezentovat data v relační databázi jako objekt v javě. Perzistenci v Enterprise Java Bean 3.0 zaručuje anotace @Entity. Mapování tohoto objektu vzhledem k relační databázi se děje automaticky a průhledně za pomoci Enterprise Java Beans kontejneru. Toto je možné provést, protože deskriptor přesně charakterizuje relační schéma celé databáze.

Pro Entitní třídu platí tyto náležitosti: 1) Entitní třída musí být vytvořena pomoci anotačního argumentu nebo v deklaraci XML deskriptoru. 2) Entitní bean musí mít deklarovaný prázdný konstruktor a ten musí být public 3) Další jiné konstruktory pro tuto třídu jsou bezesporu povoleny 4) Entitní bean nemůže být typu final 5) Pokud entita charakterizuje hodnotu nějakého řádku tabulky je zapotřebí, aby bylo reprezentováno rozhraní Serializable pro zachování synchronizace dat.

Pro tvorbu takové entity využijeme anotační značku @Entity, která nám zajistí vytvoření entitní třídy a pochopení pro kontejner, že se jedná o entitní třídu. Typicky se mapuje jedná entitní třída na jednu tabulku v databázi. Toto napojení se děje pomocí anotační značky @Table, která jako parametr obsahuje název tabulky. Je nutné vytvořit patřičné proměnné podle názvu sloupců v tabulce. Tedy pro nastavování hodnot se použije metoda set() a pro získání hodnoty z proměnné se používá get(). Tyto metody nám zajistí správné nastavování a získávání hodnot z tabulky. Při deklaraci se samozřejmě často hodí generování automatického klíče pro zadanou tabulku, což je možné pomoci @Id. Tento klíč nám zajišťuje jednoznačnost identifikace záznamů v tabulce. Pokud chceme, aby se klíč generoval automaticky, je možné použít anotaci @GeneratedValue, jenž generuje jednoduchý primární klíč dato-

20

vého typu integer. Dále je možné použít dalších anotačních značek pro propojování tabulek a určovaní vztahů mezi nimi a to pomoci :

4.3.1 Vazby v tabulkách @OneToOne Jedná se o spojení dvou tabulek, v nichž se jedná o vazbu jedinečnou a tedy jednoduchou asociaci dvou tabulek pomoci stejného klíče. Jelikož se jedná o jednoduché přidružení, není potřebné specifikovat druhou entitu z druhé tabulky, ta může být zmíněná již v prvním objektu třídy. Můžeme realizovat taktéž i další nastavení pomocí různých elementů a to nastavení posloupnosti, mapování, nastavení povinnosti (nemůže být NULL hodnota).

@OneToMany Jedná se o spojení dvou tabulek, v nichž v jedné z nich je daný klíč ve více řádcích. Jde tedy o mnohonásobnost. I zde je možné nastavení různých elementů pro upřesnění práce.

@ManyToMany Jedná se o spojení dvou tabulek, v nichž se může daný objekt vyskytovat mnohokrát a jde tedy o dvojitou mnohonásobnost hodnot. Je povinností definovat typ, nebo entitní třídu pro toto přiřazení. Tato specifika je nutná pro další práci na dvou stranách a to na straně vlastní, tedy aktuální tabulky a na straně nevlastní, tedy na straně cizí tabulky připojené pomoci anotace. I zde je možné použití dalších elementů pro upřesnění práce.

Příklad Entitního Beanu @Entity public class User implements Serializable { /** Serial version */ private static final long serialVersionUID = 4171164283773229789L; /** User id */ private long id; /** Name of user */ private String userName; /** Street of user */

21

private String street; /** City of user */ private String city; /** Post code of user */ private String postCode; /** * Constructor */ public User(String userName, String street, String city, String postCode) { super(); this.userName = userName; this.street = street; this.city = city; this.postCode = postCode; }

Celý soubor je v sekci Přílohy

4.3.2 Entity manager Slouží pro inicializovaní perzistentního kontextu entitního beanu. Jedná se o nastavení tohoto beanu na určité hodnoty a jejich uchovávání a pozdější zpracování. Lze tedy říct, že se jedná o životní cyklus této komponenty od jejího vytvoření, přes získávání a ukládání dat až po její zánik. Základem tohoto manageru je rozhraní EntityManager.Uvedený manager v sobě zapouzdřuje operace, které by se mohly s touto entitou provádět, tedy mohly by být po systému požadovány.

Životní cyklus entitního beanu: a) vytvoření nové instance, která ještě není perzistentní b) naplnění neboli spojení této instance s daty a získání perzistence c) oddělení této instance od dat d) zrušení této instance

Pro tuto entitu je důležité, aby byla zajištěna identita v databázi, tedy aby data byla aktuální a odpovídala skutečnosti. Nemělo by docházet k nekonzistenci dat, případně k porušení integrity dat. Při práci s databázi je nutné poukázat na provedení všech patřičných operací, aby byla data korektní. Toto je spojeno s transakcemi, které nám za-

22

ručují provedení celé posloupnosti kroků. Pokud by v nějakém kroku došlo k nesrovnalostem, výpadku systému, případně něčemu podobnému, dojde k zrušení celé akce. Tento manager je vybaven mechanismem proti takovým výpadkům

4.3.3 Jazyk EJB QL Jazyk, který se inspiroval více známým jazykem SQL a ze které byla implementována určitá podmnožina vybraných funkcí. V dřívějších verzích byla podpora pouze operace Select. V této nejnovější verzi se upřela snaha o rozšíření možnostech příkazu. Přidaly se příkazy Update a Delete, které musely být v dřívějších verzích využívaný přímo pomoci SQL v lepším případě HQL. V této verzi jsou použity následující možnosti práce s daty.

Podpora pro výběr z klauzule • select o from Order o left join o.lineItems li where li.amount > 100

Podpora pro vnořené výběry • swheelreec tl io. afmrooumn tO r>d e1r0 0o) where exists(select li from o.lineItems li

Podpora pro funkce • select o.id, sum(li.amount) from Order o join o.lineItems li group by o.id

Další EJB QL funkce • tabrsi(m)(,) , sqlrotc(a)t,e (m)o,d (c)o,n csaitz(e)(,) substring(), lower(), upper(), length(),

Update a Delete operace • delete from Customer cust where cust.id = 12345 • update OrderLine ol set ol.fulfilled = ‘Y’ where ol.order.id = 9876543

Podpora pro předpřipravené klauzule pomoci EntityManager APIs. @NamedQuery(name = "getItems", query = "SELECT i FROM Item i")

4.4 Message-Driven bean V této verzi se Message-Driven bean komponenta tvoří pomoci anotace @MessageDriven. Je také zapotřebí, aby tato komponenta měla implementované rozhraní MessageListener a z ní pouze jednu metodu a to onMessage(), čímž je zajištěno zachycování zpráv. Přidávání zpráv realizuje kontejner, který při požadavku

23

zajistí správné zařazení do patřičné fronty. Pokud tato fronta ještě nebyla vytvořena, kontejner ji automaticky vytvoří. Mezi charakteristiky tohoto beanu patří •

Message- Driven beany jsou anonymní. Nemají definovanou klientskou viditelnost.

•

Instance těchto beanu nemají nadefinovaný konverzační stav což znamená, že pokud nejsou klientem využívaný, tedy neodpovídají na žádné požadavky (zprávy), jsou si zcela ekvivalentní a tudíž shodné.

Instance tohoto beanu je vytvořená kontejnerem v důsledku přijetí požadavku nějaké zprávy ze strany klienta a tato instance se stává spotřebitelem neboli aktérem.

Příklad Message-Driven Beanu @MessageDriven {

public void handleNotification(User user) { System.out.println("New Shop Order from user: " + user); Session session = null; try { session = (Session) PortableRemoteObject.narrow( new InitialContext().lookup("java:Mail"), Session.class); } catch (javax.naming.NamingException e) { e.printStackTrace(); } try { MimeMessage m = new MimeMessage(session); m.setFrom(); Address[] to = new InternetAddress[] { new InternetAddress( properties.getProperty("recipient")) }; m.setRecipients(RecipientType.TO, to); m.setSubject("New Shop Order"); m.setSentDate(new Date()); m.setContent(user.toString(), "text/plain"); Transport.send(m); } catch (javax.mail.MessagingException e) { e.printStackTrace(); } } }

Celý soubor je v sekci Přílohy

24

5 Aplikační servery Během praktického zkoušení těchto technologii bylo nutné najit vhodný aplikační server a jeho podporu této technologie. Tato technologie je novinkou a proto jsou podpory velmi různorodé. Zhodnocení se budeme nyní věnovat.

5.1 Aplikační server JBOSS Tento aplikační server jsem využíval u své bakalářské práce. Daný server podporuje většinu možnosti z EJB 3.0 •

Určený prostor JNDI pro hledání patřičných komponent a jejich rozhraní.

•

Stateful,Stateless a Message Drive beany pro komunikaci s uživatelem

•

Entitní beany pro práci s databázi. Implementována je také perzistence těchto beanu a Manažer transakci. U manažera není naimplementována vazba s jiným serverem. Tyto beany samozřejmě mohou využívat standardní databázi (Hypersonic), kterou tento server nabízí ve spolupráci s integraci Hibernatu.

Server zatím neumožňuje využívání komponenty Timer pro časování.Pro určité anotační značky je implementována pouze možnost komunikace na lokální straně. Pracuje se na možnosti rozšíření již dříve zmíněného manažera pro komunikaci i s jinými servery a jeho využití při komunikaci.

5.2 Aplikační server SUN Tento aplikační server je z dílny autorů EJB 3.0 a podpora je zcela vyplývající.. Byla už uvolněna první záplata a dnes je podpora zcela všech možností EJB3.0 a to včetně na napojení k jiným databázovým serverům. Spolupráce je z Oracle 9i, 10g, MySQL 5, Microsoft SQL Server 2000, 2005.

5.3 Aplikační server ORACLE Poslední verze tohoto aplikačního serveru vychází ze specifikace EJB 3.0 a je zde implementována tato technologie v plné míře. Tento aplikační sever byl jedním z prvních, který v sobě zahrnuje implementaci celé specifikace EJB 3.0. Při této implementaci zde byla snaha i o spojení určitých vlastností z verze EJB 2.1, aby tyto komponenty byly v kompatibilní verzi. Podařilo se spojení pouze velmi mále skupiny vlastnosti.

5.4 Aplikační server IBM Nejnovější model podporuje programový model J2EE verze1.4 a s ním vložené JSP,Servelet, EJB,a Web Services. Model EJB 3.0 není podporován v tomto serveru.

25

6 Praktická část Ukázková aplikace demonstruje možnosti této technologie. Ukázka je postavená na jednoduchém internetovém obchodě s nějakou nabídkou zboží, které je k prodeji.

ER Diagram:

Obrázek č.3 ER diagram Aplikace pracuje nad těmito čtyřmi tabulkami, jejichž vazby mezi sebou jsou znázorněny na zmíněném obrázku.

Datový slovník: Pro tabulku Zboží:

Tabulka Item Item Item Item

Atribut id name description price

Datový typ Číslo Řetězec Řetězec Číslo

Klíč Ano Ne Ne Ne

Null Ne Ne Ano Ne

Popis Primární klíč Název popis zboží cena

Pro tabulku Uživatel: Tabulka User User User User User

Atribut id username city postcode street

Datový typ Číslo Řetězec Řetězec Řetězec Řetězec

Klíč Ano Ne Ne Ne Ne

Null Ne Ne Ne Ne Ne

Popis Primární klíč Jméno a příjmení Město PSČ Ulice

26

Pro tabulku Obsah Objednávky: Datový typ Číslo Řetězec Řetězec Číslo Číslo

Tabulka Atribut OrderItem id Orderitem name OrderItem description OrderItem price OrderItem quantity

Klíč Ano Ne Ne Ne Ne

Null Ne Ne Ano Ne Ne

Popis Primární klíč Název popis zboží cena počet ks

Pro tabulku Objednávky: Tabulka ShopOrder ShopIOrder ShopOrder ShopOrder

Datový typ Číslo Řetězec User Order

Atribut id name user items

Klíč Ano Ne Ne Ne

Null Ne Ne Ne Ne

Popis Primární klíč Název Uživatel seznam zboží

DFD Diagram

Obrázek č.4 DFD diagram Obrázek definuje práci celého navrženého systému a funkcemi, které jsou v něm implementované

27

6.1 Administrátorská část Slouží pro kontrolu nabídky zboží a kontrolu obsahu jednotlivých objednávek. Pro tuto část jsem zvolil přihlašovací povinnost, aby zde nemohl přistupovat kdokoli. Pro potřeby ukázky jsem zvolil přihlašovací jméno a heslo admin. Zboží lze z nabídky odebrat. Druhou možností, je zavedení zcela nového produktu do nabídky. U nového zboží jsou požadovány tři parametry, aby se mohlo zaevidovat. Každé zboží musí mít nějaký název,popis a cena. Administrátorovi se zde zobrazí obsah všech objednávek, který byly prozatím uskutečněny. Implementován je malý filtr pro vypsaní objednávek jen od konkrétního uživatele.

6.2 Uživatelská část Slouží pro vstupující uživatele,k výběrů a objednání zboží.

Minispecifikace :

•

V úvodu se objeví nabídka zboží, které je možné k objednání.

•

Uživatel má možnost si zapsat kolik kusů od každého zboží si chce objednat.

•

Uživateli se vypíše obsah jeho objednávky a je na uživateli jestli ji nechce ještě upravit nebo je s ním spokojen.V případě souhlasu z objednaným zbožím se zobrazí menu pro zadání adresy dodání.

•

Po úspěšném zadání kontaktních údajů dojde u ložení objednávky do databáze.

•

Odešle se zpráva na email administrátora ([email protected] ) o provedené nové objednávce. Heslo pro vstup na tuto schránku je admin.

Celý tento program byl realizován pomoci zmiňované technologie EJB 3.0 s využitím komptability této technologie s JSP stránkami. Byly implementovány všechny komponenty,které jsou zmíněny v textu. Při využívání komponenty MSB Bean jsem narazil u aplikačního serveru JBOSS na problém s využíváním autorizovaných SMTP serverů, kterou bohužel JBOSS nepodporuje a proto je zapotřebí tento aplikační server připojovat k SMTP serverům, které tuto autorizaci nevyžadují jako je například SMTP server naši školy a to pomoci certifikátu nebo VPN klienta.

.

28

7 Závěr Cílem této bakalářské práce bylo porovnat, jak se za poměrně krátkou dobu vyvinula a co umožňuje technologie Enterprise Java Beans. Tato technologie byla navržena na tvorbu opravdu velmi velkých a robustních informačních systému. Je tedy zřejmé, že tyto systémy budou pracovat na několika počítačích, ale klidně i na stovkách počítačů a samozřejmě můžou být od sebe vzdálený jakoukoli vzdálenost. Tato technologie zprvu umožňovala vytvářet komponenty, které musel programátor velice pečlivě vytvořit podle všech náležitostí a potřebných rozhraní a tříd. S postupem času se tvůrci této technologie snažili čím více usnadňovat práci programátora, aby vytvářel jen ty potřebné věci a aby zbytek podpůrné práce byl tvořen automaticky a zajišťovaly ho k tomu určené programy a obslužné systémy. S postupem času zde byla vložen i možnost webových služeb, které jsou v dnešní době na běžném standardu a bez nich si dnešní informační systémy a technologie nejde představit.

Poslední verze, která zatím byla uvolněna pouze v testovací verzi, přinesla úplné zjednodušení pro tvorbu komponenty, kdy programátor opravdu musí psát jen kód, který charakterizuje danou komponentu a její potřebné funkce, které by měla umožňovat a o zbytek se už postará ostatní aplikace. Hlavní novinkou této verze je určitě možnost využívání anotačních značek, které nesmírně ulehčují práci programátora a taky samozřejmě ulehčují práci dalším aplikacím, pro které je daná komponenta určena a aby ji specifikoval a mohl ji využívat. Bylo taky zjednodušeno vytváření všech potřebných rozhrání pro komponenty, kdy se nyní musí vytvořit jen to základní a z něho se daná komponenta vytvoří, kdežto v dřívějších verzích bylo zapotřebí vytvořit hned několik rozhraní a pak tříd pro přístup ze vzdálené nebo lokální strany. Bylo taky myšleno na zachytávaní výjimek, kdy dnešní komponenty jsou automaticky při lokaci vybavovány výjimkami a programátor už na to při vytváření komponenty nemusí myslet. Dospěl jsem tedy k závěru, že tato technologie je aktuální možnosti pro informační systémy, které by měly mít robustní charakter a programátorovi je velmi ulehčena práce při vytváření komponent pro navržený systém. Je to určitě velmi zajímavá technologie, která má budoucnost a určitě bude nacházet opodstatnění v mnoha nových vytvářených projektech.

29

Literatura [1] Originální dokumentace ze stránek http://java.sun.com/ejb

[2] Dokumentace ze stránek http://www.jboss.org [3] Richard Monson-Haefel kniha Enterprise Java Beans – 4 vydání ISBN 000530-X

596-

[4] Gerald Brose, Rima Patel Spriganes Kniha ve formě PDFka Mastering Enterprise Java Beans - 3 vydání [5] články http://www.interval.cz [6] články z http://www.oracle.com/technology/tech/java/oc4j/ejb3/fov_ejb3.html [7] články z http://www.ibm.com [8] články z http://docs.jboss.org/ejb3/embedded/embedded.html

30

8 Přílohy: Obsah CD:

Popis cesta Všechny soubory použité v bakalářce /soubory Session beany /Shop/src/shop/core Entitní beany /Shop/src/shop/common MD bean /Shop/src/shop/notification konzoloví klienti /Shop/src/shop/client webové stránky /Shop/src/wui Dokumentace /dokumentace Aplikační server Jboss.zip bakalářská práce bakalářka.pdf Uživatelská příručka /napoveda

31