Docstoc

Web Bean

Document Sample
Web Bean Powered By Docstoc
					     Web Bean

JBoss Seam - Apache Shale
             EJB architektúra
• Komponens architektúra
• Komponens alapú üzleti alkalmazások
  fejlesztése
• Programozási modell
• Tranzakciókat használó erőforrások elosztása
                    Áttekintés
• Enterprise JavaBeans
  –   Stabil
  –   Skálázható
  –   Tranzakció menedzsment
  –   Sok-felhasználós
  –   Biztonságos
• EJB 3.0
  – Javított, egyszerűsített EJB modell
  – Könnyű használhatóság
  – Java annotációk!!!
                 Hiányosságok
• Az EJB komponensek nem látják a webes réteg request,
  session és application kontextus állapotait, így nem is
  férnek hozzá azokhoz
• EJB komponenseket nem lehet általánosan használni a
  megjelenítési rétegben
• Nincs komponens vagy függvény szintű
  biztonságkezelés
• JSF-ben nincs integrálva tranzakcióban használt
  erőforrások elérése
• A servlet specifikáció – amit a JSF használ – nem elég
  gazdag komplex alkalmazásokban való használathoz
• JSF még nem használható annotációkkal
                 Megoldás
• Web Beans
• JSR-299 specifikáció
• Egyesíti a JSF Managed Bean komponens modellt
  az EJB komponens modellel
• Egyszerűsített programozási modellt ad web
  alapú alkalmazások fejlesztéséhez
• Nincs szükség a Java EE környezet mély
  ismeretére
• Javított kontextus modell
                  Web Beans céljai
• EJB komponensek JSF Bean-ekként való használatának
  támogatása
• Annotációk használata a kontextusok változóinak
  manipulálására
• Javított kontextus modell + két új kontextus:
    – Conversation
    – Business Process
•   Interfész munkafolyamat-motorok könnyű integrálásához
•   JPA integrálása
•   Annotációk biztosítása JSF metaadatok számára
•   JSR-227 támogatás biztosítása
 Adaptálás meglévő rendszerekhez
• Létező EJB3 session bean-ekből Web Bean-ek
  készítése annotációkkal
• Létező JSF managed bean-ekből Web Bean-ek
  készítése annotációkkal
• Új Web Bean komponensekbe meglevő EJB3
  session bean-ek injektálása annotációval vagy
  JNDI-ből
• Új EJB-ben létező Web Bean komponensek
  használata injektálással vagy interceptorral
            Web Beans újdonságai
• A Web Beans lényege a laza csatolás
   – Szerver és kliens oldal elválasztása jól definiált API-k és kötési
     típusok alkalmazásával
       • Az implementáció felüldefiniálható telepítési időben
   – Az együttműködő komponensek életciklusainak elkülönítése
       • Komponensek életciklusának automatikus menedzsmentje
       • Stateful komponensek szolgáltatásokként való használata
   – Ortogonális nézetek leválasztása a programkódtól
       • Interceptorok használata (logging, security, transactions)
   – Az üzenetek küldőinek és fogadóinak szétválasztása
       • Event-ke használata
• A Web Beans egyesíti a web réteget és az üzleti réteget
   – Egy komponens elérheti a request scope adatait és használhat
     tranzakciós erőforrást is egyben
             Mi egy Web Bean?
• Komponens típusai:           • Alap építőelemek:
  – Bármilyen Java osztály       –   Telepítési típusok
  – EJB session és singleton     –   API típusok
    bean-ek                      –   Kötési típusok
  – Feloldó metódusok            –   Elnevezések
  – JMS komponensek              –   Implementálások
  – Távoli komponensek
Egy egyszerű példa: Komponens
                             @Component egy
                            beépített stereotípus


public
@Component
class Hello {
     public String hello(String name) {
           return "hello " + name;
     }
}
       Egy egyszerű példa: Kliens
                                     @Current egy beépített
                                          kötési típus


public
@Component
class Printer {
      @Current Hello hello;
      public void hello() {
            System.out.println(hello.hello("world"));
      }
}
     Egy egyszerű példa: Konstruktor
                injektálás
                                  A konstruktorok paraméterei
                                      default injektálódnak


public
@Component
class Printer {
      private Hello hello;
      public Printer(Hello hello) {this.hello=hello;}
      public void hello() {
            System.out.println(hello.hello("world"));
      }
}
        Egy egyszerű példa: Initializer
                 használata
                                  Példányosítás utáni callback a
                                   paraméterek injektálására


public
@Component
class Printer {
       private Hello hello;
       @Initializer
       void initPrinter(Hello hello) {this.hello=hello;}
       public void hello() {
             System.out.println(hello.hello("world"));
       }
}
       Komponensek nevei
                   Alapértelmezetten a komponensek nem
                    elérhetőek EL kifejezésekben. Ha nem
                      adunk meg nevet, egy default név
                              rendelődik hozzá

public
@Component
@Named("hello")
class Hello {
     public String hello(String name) {
           return "hello " + name;
     }
}
             JSF oldalak

                           Web Bean metódus
                           hívása EL kifejezéssel




<h:commandButton
     value="Say Hello"
     action="#{hello.hello}"
/>
              Kötési típusok
• A kötési típus egy annotáció, amely lehetővé
  teszi a kliens számára, hogy több
  implementáció közül választhasson egy API-
  ból futási időben
  – String alapú nevek használata feloldásnál
  – @Current az alapértelmezett kötési típus
  Kötési típus definiálása és használata
public
@BindingType                                      A @Casual kötési típus
@Retention(RUNTIME)
                                                       specifikálása
@Target({TYPE,METHOD,FIELD,PARAMETER})
@interface Casual {}

                              public
                              @Casual
                              @Component
     A Hello komponens
                              class Hi extends Hello {
   injektálása és a @Casual           public String hello(String name){
    implementáció elkérése                    return "hi " + name;
                                      }
                              }

public
@Component
class Printer {
       @Casual Hello hello;
       public void hello(){
                System.out.println( hello.hello("JBoss Compass") );
       }
}
             Telepítési típusok
• A telepítési típus egy annotáció, amely Web
  Bean-ként azonosít egy osztályt
  – Telepítési típusok engedélyezhetőek és tilthatóak,
    ezzel biztosítva komponensek egész csoportjainak
    engedélyezését és tiltását telepítési időben
  – Van egy precedencia sorrendje a telepítési típusoknak,
    így segítve a futtatási környezetet, hogy különböző
    implementációk között választhasson egy API-ból
  – A telepítési típusok lecserélik az XML alapú
    konfigurációkat
• Az alapértelmezett telepítési típus: Production
  Telepítési típus definiálása, használata
public
@DeploymentType
@Retention(RUNTIME)                                      Ugyanaz az API,
@Target({TYPE,METHOD})                              különböző implementáció
@interface Espanol {}

                                 public
                                 @Espanol
     A felsorolás sorrendje      @Component
  fontos! Csak az itt felsorol   class Hola extends Hello {
   telepítési típusok lesznek           public String hello(String name){
 elérhetőek az alkalmazásban                    return "hola " + name;
                                        }
                                 }

<web-beans>
         <component-types>
                  <component-type>javax.webbeans.Standard</component-type>
                  <component-type>javax.webbeans.Production</component-type>
                  <component-type>org.jboss.i18n.Espanol</component-type>
         </component-types>
</web-beans>
        Hatókörök és kontextusok
• A hatókörök meghatározzák egy Web Bean
  példányainak életciklusát
• Összekapcsolják a klienst, és az adott klienshez
  tartozó példányokat
• Bővíthető kontextus modell, új annotációk
  készítésével
• Beépített hatókörök:
   –   @RequestScoped
   –   @SessionScoped
   –   @ApplicationScoped
   –   @ConversationScoped
          A conversation hatókör
• Hasonló a session hatókörhöz, állapotokat tart és
  rendel felhasználókhoz a rendszerben több request-en
  keresztül a következő két különbséggel:
   – A életciklusának határait az alkalmazás kezeli
   – Az állapotot egy adott böngészőhöz rendeli
• Egy conversation egy feladatot reprezentál a
  felhasználó szemszögéből, több feladat esetén több
  conversation keletkezik
• A conversation hatókör minden JSF request esetén
  aktív és legtöbb esetben a request végén véget is ér.
  Több requesten keresztül tartó conversation-t hosszú
  futású (long-running) conversation-nek nevezzük.
           Függő pseudo-scope
• A négy beépített hatókör mellett a Web Bean specifikál
  egy default hatókört: @Dependent
• Minden Web Bean, amely nem definiálja a hatókörét,
  ebbe a hatókörbe sorolandó
• Egy függő Web Bean-re való hivatkozás (injektálás)
  esetén mindig létrejön egy példány a függő bean-ből,
  valahányszor az injektáló példányosítva van
• A függő Web Bean-ek példányai sosem lesznek
  megosztva komponensek között, egy ilyen példány a
  példányosító Web Bean-től „függ”
• Az életciklusa is tőle függ, akkor lesz megszüntetve,
  amikor a példányosító megszűnik
         Producer metódusok
• A Producer metódusok segítenek a
  komponensek példányosításának kezelésében:
  – Polimorfizmus futási időben
  – Példányosítás kezelése
  – Injektálás kezelése nem Web Bean
    komponensekre vonatkozóan
                Interceptor-ok
• Az EJB 3.0 interceptor arhitektúra felhasználása a
  következőkkel kibővítve:
   – Minden Web Bean-nek lehet interceptora, nem csak
     session bean-eknek
   – Kifinomultabb létrehozása a kötéseknek a Web Bean-
     ek és az interceptorok között annotációkkal
• Két típusa van:
   – Függvényhíváshoz rendelt interceptorok
   – Komponensek életciklusaihoz rendelt interceptorok
              Sztereotípusok
• Gyakran visszatérő, használandó arhitektúra
  minták, amelyek úgynevezett Web Bean
  szerepköröket definiálnak
• Magába foglalja a következőket vagy azok
  kombinációit:
  – alapértelmezett telepítési típus
  – alapértelmezett hatókör
  – megszorítások a hatókörre
  – követlemények, amiket a Web Bean-nek meg kell
    valósítania
  – Interceptorok megadása
                  Események
• Teljes elkülönül az eseményt generáló
  („producer”) és eseményt feldolgozó („observer”)
• Observer/observable minta felhasználása a
  következő különbségekkel:
  – Nem csak a producer van leválasztva az observer-től,
    hanem fordítva is függetlenek egymástól
  – Az observer-ek meghatározhatják az események egy
    jóldefiniált halmazát, amelyet kezelnek
  – Observer-ek azonnal feldolgozhatják az eseményt,
    vagy késleltethetik az épp aktív tranzakció végéig
JBoss Seam
                JBoss Seam
• Alkalmazás keretrendszer, amely összeköti az
  EJB3-at és a JSF-et
• További technológiák integrálása:
  – Ajax
  – BPM
  – PDF és MS Excel
  –…
• Egyszerűsített web alkalmazás fejlesztés
• Beépített komponensek
                JBoss háttér
• JBoss fejlesztés (Gavin King)
• Minden más JBoss termékkel jól együtt tud
  működni (jBPM, Drools, stb.)
• Nem csak JBoss alkalmazás szerveren fut ->
  beépített EJB konténert tartalmaz
• Jelenleg folyik a standardizálása: a Web Beans
  specifikáció alapja
• JBoss OS (LGPL)
J2EE container
                             Futtatási környezetek



                                   Java EE container




                                                                          Web container
                 • Use embedded                        • All Seam                         • Use embedded
                   EJB3                                  features                           EJB3
                                                         available
                   Or                                    • Security                         Or
                                                         • Pageflow
                 • sacrifice EJB                         • Exception                      • sacrifice EJB
                   support                                 handling                         support
                                                         • Enhanced JSF
                                                           Expression
                                                           Language
                                                           (JSF-EL)
Arhitektúra
                   Tulajdonságai
•   Alapja POJO osztályok annotációkkal
•   Facelet-ekre épül
•   Nincsen szükség JSF managed bean-ekre
•   Nem szeparálja teljesen külön a rétegeket
•   EJB metódusok hívása Ajax segítségével
•   Beépített munkafolyamat motor (jBMP)
•   Interceptorok és Események kezelése
•   Injection, Outjection
•   Kód és Projekt generálás
•   Két új kontextus: conversation, business process
               JSF vs. Seam
         JSF              POJO                          Session
        Page             Facade                           EJB

JSF
                          POJO                          Entity
        JSF
                         Facade                          EJB
       Page
                       Managed Bean



         JSF                                            Session
        Page                                              EJB
SEAM
        JSF                                              Entity
       Page                                               EJB
                Automatically wrapped in Managed Bean
JSF életciklus
Seam életciklus
                  Példa: Entity Bean
EJB Entity Bean                                 Seam komponens


        @Name("ProductCatalog")
        @Scope(ScopeType.SESSION)
        @Entity
        @Table(name="catalog")
        public class ProductCatalogBean {

                  @Id @NotNull
                  private long id;

                  private String name;

                  @DataModel(value="choiceProducts")
                  private List<ProductBean> products;
        ...
Példa: Felhasználói felületek csatolásai
                                           @Datamodel

 ...
 Pricelist #{ProductCatalog.name}

 <h:dataTable var="current" value="#{choiceProducts}">
 <h:column>
 <s:link
 action="#{ShopController.selectProduct(current)}"
 value="#{current.name}" />
 </h:column>
 </h:dataTable>
 ...


                                      Metódus hívása
                                       paraméterrel
             Példa: Session Bean
Seam komponens                              Injektálás




@Name("ShopController")
@Scope(ScopeType.SESSION)
public class ShopController {

       @In(create=true)
       private ShoppingCart shoppingCart;

       public String selectProduct(ProductBean prod){
              shoppingCart.setProduct(prod);
              return "success";
       }
...
                 Példa: Navigáció
     faces-config.xml vagy     pageflow
            pages.xml

• Navigációs szabályok
• Init akciók használata
  navigálás előtt
• Request paraméterek
  kezelése
• EL kifejezések használata
               JBoss Seam jövője
• Seam 3 a Web Beans-re fog épülni teljesen
  – Web Beans szolgáltatásai:
     • Összefüggő programozási modell és Esemény Bus
     • JSF és EJB3 integrációja
     • JPA, tranzakciók és validációk integrálása
  – Seam feladatai:
     •   Biztonság
     •   BPM és Rule integráció (munkafolyamatok)
     •   PDF és levelezés JSF könyvtárak
     •   Minden mást…
Apache Shale
                Apache Shale
•   Modern web alkalmazás keretrendszer
•   Alapja a Java Server Faces
•   Lazán csatolt szolgáltatáscsomag
•   Szabadon kombinálható elemek
•   Hatékony eseménykezelés
•   Új megjelenítési technológia: Clay
•   Annotációk használata
•   Több integrációs pontot biztosít
    – Spring
    – jMock
    –…
                View Controller
• Felhasználói felületek és a megjelenő adatok
  összerendelése, kezelése
• Backing Bean-ek alapján
• Implementálni kell a ViewController interfészt
  –   Postback property
  –   Setter Injection
  –   Init()
  –   Preprocess()
  –   Prerender()
  –   Destroy()
             Dialog Manager
• Navigációs szabályok, folyamatok definiálása
  magas szinten
  – Action – metódus hívása
  – Exit – folyamat vége
  – Subdialog – beágyazott folyamat
  – View – JSF oldal megjelenítése
• Felületek újrafelhasználhatósága célja
          Application Manager
• Request-ek kezelése
• JSF PhaseListener mintájára
• Elő és utófeldolgozás
  – AbstractReqExpFilter
• JSF életciklus menedzsmentje
  – ShaleApplicationFilter
                      Validáció
• Apache Commons Validator
• Kliens és szerver oldali validáció
• Beépített típusok:
   –   Dátum
   –   E-mail
   –   URL
   –   ...
• 3 JSP tag a validáláshoz:
   – val:commonsValidator
   – val:validatorVar
   – val:validatorScript
                Remoting
• Javascript és Bean metódusok URL-re kötése
                     Clay
• JSF esetén szerveroldalon fa alapú a
  felhasználói felület felépítése és tárolása
• Ezt kiegészíti a Clay, hogy teljes részfákat
  lehessen mozgatni, beszúrni, törölni a
  felületből, így három lehetőséget biztosítva
  – HTML Views
  – Meta-data öröklődés
  – Szimbólumok
                 Tesztelés
• JUnit tesztkeretrendszer
• Hogyan lehet tesztelni egy konténerfüggő
  alkalmazást, mint amilyen minden EE
  alkalmazás függetlenül?
• Mock object API-khoz, így kiküszöbölve a
  függőségeket:
  – Shale
  – Servlet
  – JSF
VÉGE

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:5
posted:1/4/2012
language:Hungarian
pages:50