Downloaded 91 times
![Presenter’s Name [email_address] Carol McDonald Java Architect Tech Days 2009](https://image.slidesharecdn.com/td09javaeespringseam-12517450803901-phpapp02/75/JavaEE-Spring-Seam-108-2048.jpg)
Uploaded byCarol McDonald
JavaEE Spring Seam
The document discusses Java Enterprise Edition (Java EE) and how it can be used to build a sample catalog application in three different ways: using plain Java EE, Java EE with Spring, and Java EE with Seam. It provides an overview of key Java EE concepts like the Java Persistence API (JPA), entity relationships, and managed beans. It then describes how to implement the sample catalog application using JavaServer Faces (JSF) components and a managed bean to bind the user interface to a backing bean and entity data.
More Related Content
JavaEE Spring Seam
- 1. JavaEE with Springor Seam Carol McDonald, Java Architect
- 2. About the SpeakerCarol cDonald: Java Architect at Sun Microsystems Before Sun, worked on software development of: Application to manage car Loans for Toyota (>10 million loans) Pharmaceutical Intranet apps ( Roche Switzerland) Telecom Network Mgmt app ( Digital France) X.400 Email Server ( IBM Germany)
- 3. Agenda Look ata sample application built 3 ways: using Java EE, Java EE and Spring, Java EE and Seam all running on Glassfish
- 4.
- 5. Catalog Java EE Application Persistence – JPA Entities DB Registration Application Managed Bean JSF Components Session Bean Entity Class Catalog Item ManagedBean
- 6. JPA Unifying/Standardizing PersistenceBased on existing successful technologies: TopLink, Hibernate, Kodo, Java Data Object s, etc. One common API for all major ORM frameworks Standardized annotations @ and XML xml for mapping is optional Support for pluggable 3 rd party Persistence provider s
- 7. JPA: Simplifying/Unifying/Standardizing PersistencePOJO based programming/persistence model Simple Java classes – not EJB components Can be used in Java SE , web or EJB -based applications No need for D ata T ransfer O bjects Facilitates testability Simpler and easier: Most configuration is defaulted – configure by exception only (configure only to override default)
- 8. Entity Annotated as“Entity” @Id denotes primary key Getters/setters to access state @Entity public class Item implements Serializable { @Id protected Long id; private String name; private BigDecimal price; public Item() {} public Long getId() {return id;} public String getName() {return name;} public void setName(String name) {this.name = name;} public String getPrice() {return price;} public void setPrice( BigDecimal name){this.price=price;} … }
- 9. Simple Mapping Mappingdefaults to matching column name . Only configure if entity field and table column names are different public class Item { int id; String name; String description; String url ; } @Entity @Column(name=“DESC”) @Id Item ID NAME DESC URL
- 10. Relationships JPA Standardized O/R Mapping Standardized o bject/ r elational m apping annotations to specify how to map attributes to DB xml for mapping is optional Most configuration is defaulted Relationships
- 11. Relationship Mappings –OneToMany Bidirectional public class Product { int id; ... Collection<Item> items; } public class Item { int id; ... Product product; } @Entity @Entity @OneToMany( mappedBy =“ product ”) @ManyToOne @Id @Id 1 n has to say where the foreign key is using mappedBy Item ID PROD_ID PRODUCT ID . . .
- 12. Persistence ContextEntityManager persist() remove() refresh() merge() find() createQuery() createNamedQuery() contains() flush() EntityManager API to manipulate entities Set of managed entities Interface thru which applications interact with the entities and the persistence engine Servlets EJBs Java app
- 13. How Does itWork? Entity Manager EntityManager API to manipulate entities stores/retrieves entities in DB: Use EntityManager methods to persist, update, delete data em. persist (p); em. merge (p); em. find (p.class, id); ; em. remove (p); Query using EJB QL or SQL List<Passenger> listP = em. createQuery (“select p from Passenger p”) .getResultList ();
- 14. Persistence Context ~HashMapof Managed Entity objects first-level cache holds (at most) one in-memory Entity for each database row can do dirty checking of objects and write SQL as late as possible (automatic or manual flushing) The Persistence Context has a scope, for EJBs: default : same scope as the system transaction (JTA) extended : the PC is bound to a stateful session bean
- 15. Declarative Transaction ManagementExample TX_REQUIRED TX_REQUIRED TX_REQUIRED PC PC PC Session Facade Inventory Service Order Service Check Out 1. Update Inventory New Persistence Context Persistence Context Propagated Transaction Attributes 2. Create Order
- 16. Persistence Context- Transactionalvs. Extended @Stateless public class OrderSessionStateless implements OrderService { @PersistenceContext(unitName=”java_one”) EntityManager em; public void addLineItem (OrderLineItem li){ // First, look up the order. Order order = em.find(Order.class, orderID); order.lineItems.add(li); } @Stateful public class OrderSessionStateful implements OrderService { @PersistenceContext(type = PersistenceContextType. EXTENDED )) EntityManager em; // Order is a member variable Loaded from the db in lookupOrder Order order public void addLineItem (OrderLineItem li){ // No em.find invoked for the order object order.lineItems.add(li); }
- 17. Catalog Java EE Application Stateless Session EJB DB Registration Application Managed Bean JSF Components Session Bean Entity Class Catalog Item ManagedBean
- 18. Business Interface public interface CatalogService { public Item getItem(String itemID); public int getItemCount(); public List<Item> getItems (int firstItem, int batchSize ); } CatalogService Business Interface
- 19. Catalog Stateless SessionEJB, JPA Query @Stateless public class Catalog implements CatalogService { @PersistenceContext(unitName=”PetCatalogPu”) EntityManager em; @TransactionAttribute(NOT_SUPPORTED) public List<Item> getItems (int firstItem , int batchSize ) { Query q = em . createQuery (" select i from Item as i "); q. setMaxResults ( batchSize ); q. setFirstResult ( firstItem ); List<Item> items= q.getResultList(); return items; } }
- 20. Java EE: DependencyInjection Dependency Injection = Inversion of Control Don't call us, we'll call you (Hollywood Principle) Bean specifies what it needs through @ References to resources are injected when instance is constructed: @Resource : for connection factories, EJBContext, UserTransaction , etc. @EJB : For EJB References @PersistenceContext : For container-managed EntityManager @PersistenceUnit : For EntityManagerFactory
- 21. Agenda Catalog JavaEE Application JSF
- 22. JSF Component,Event Driven Web Framework Pages composed of server side components View Root Form id=guess Managed Bean getUserNumber() setUserNumber(..) guess() Business Service guess() Events call ManagedBean methods UIIput id=guessNum UICommand id=submit
- 23. What is aJSF UI Component? Some Standard Components
- 24. Some Open SourceUI Components
- 25. UI Components So...what is a UI component? To a page author – XML tag (JSP or Facelets) To a component author – component class and renderer maintains component state, processes input renders a user interface Component Class XML Tag Renderer
- 26. JSF Web Framework View Controller Model Request Service Interface Events
- 27. Catalog Java EE Application JSF components and Managed Bean DB Registration Application Managed Bean JSF Components Session Bean Entity Class Catalog Item ManagedBean
- 28. List Items page Data Table
- 29. list.jsp <h:dataTable value='#{ item.items }' var=' dataTableItem ' > <h:column> <f:facet name="header"> h: outputText value="Name"/> </f:facet> <h:commandLink action ="#{ item.detailSetup }" value ="#{ dataTableItem.name }"/> </h:column> <h:column> <f: facet name=" header "> h: outputText value =" Photo "/> </f:facet> < h: graphicImage url ="#{ dataTableItem.imagethumburl }"/> </h:column> <h:column> <f:facet name="header"> h: outputText value =" Price "/> </f:facet> <h: outputText value ="#{ dataTableItem . price }"/> </h:column> </h:dataTable>
- 30. Binding UI toManaged Bean list.jsp <h: dataTable value ="#{ itemController .items }" faces-config.xml <managed-bean> < managed-bean-name > itemController </managed-bean-class> < managed-bean-class > package. ItemController </managed-bean-class> <managed-bean-scope> session </managed-bean-scope> </managed-bean> ItemController.java public class ItemController ... public long getItems() { JSP, JSF Expression Language Managed Bean property
- 31. Managed Bean ValueBinding UI Output component value attribute : The property getter is invoked when the component is rendered <h: dataTable value ="#{ itemController .items }"/> The property setter is invoked when the component input is processed <h: input Text value ="#{ user .name }"/> GET SET
- 32. list.jsp Page< h:dataTable value='#{ itemController.items }' var=' dataTableItem '> <h:column> <f:facet name='header'> <h:outputText> value='Name'/> </f:facet> < h:commandLink action='#{item.detailSetup}' value='#{ dataTableItem .name}'/> </h:column> <h:column> ... < h:graphicImage url='#{ dataTableItem .imagethumburl}'/> ... < h:outputText value='#{ dataTableItem .price}'/> ... </h:dataTable>
- 33. UIComponents Binding to a Managed Bean public class ItemController { private DataModel model ; DataModel getItems(){ . . . return model; } . . . } <h: dataTable value ="#{ itemController .items }" Managed Bean property Managed Bean dataTable useful to show a Collection in a table binding to DataModel which wraps a collection of data objects Client Server A B C Backing Bean Form c1 A c2 B c3 C c1 c2 c3 A B C Page
- 34. Managed Bean: ItemControllerimport javax.faces.model.DataModel ; import javax.faces.model.ListDataModel; public class ItemController { private DataModel model; private int batchSize = 10; private int firstItem = 0; @EJB private CatalogService catalog ; public DataModel getItems() { model = new ListDataModel ( catalog.getItems( firstItem,batchSize) ; return model; } . . . dataTable binds to a DataModel which wraps Collection of data objects
- 35. Catalog Stateless SessionEJB @Stateless public class Catalog implements CatalogService { @PersistenceContext(unitName=”PetCatalogPu”) EntityManager entityManager; @TransactionAttribute(NOT_SUPPORTED) public List<Item> getItems (int firstItem, int batchSize) { Query q = em. createQuery (" select i from Item as i "); q. setMaxResults (batchSize); q. setFirstResult (firstItem); List<Item> items= q.getResultList(); return items; } }
- 36. Relationship Between ObjectsgetItems() via EntityBean 1 m #{itemController.items} Item Entity Product Entity Catalog StatelessSB Item Controller list.jsp
- 37. List Items page Link to see Item Details JSF is event-driven, listens for actions
- 38. list.jsp <h:dataTable value='#{ itemController.items }' var =' dataTableItem '> <h:column> <f:facet name="header"> h: outputText value=" Name "/> </f:facet> <h: commandLink action ="#{ itemController.detailSetup }" value ="#{ dataTableItem.name }"/> </h:column> <h:column> <f: facet name=" header "> h: outputText value =" Photo "/> </f:facet> < h: graphicImage url ="#{ dataTableItem.imagethumburl }"/> </h:column> <h:column> <f:facet name="header"> h: outputText value =" Price "/> </f:facet> <h: outputText value ="#{ dataTableItem.price }"/> </h:column> </h:dataTable> Click causes Action Event JSF is event-driven, listens for actions
- 39. JSF controller handles action events, such as submitting a form or linking to another page. JSF Standard request processing lifecycle Request Restore View Response Render Response Apply Request Values Invoke Application Update Model Values Process Validations action events JSF is event-driven, listens for actions
- 40. JSF Actions Command Action : Refers to a backing bean method that performs navigation processing and returns a logical outcome String <h: commandLink action ="#{ itemController.detailSetup } " ... /> public class ItemController { private Item item ; private DataModel model ; public Item getItem() { return item; } public String detailSetup() { item = (Item) model.getRowData(); return " item_detail "; }
- 41. Navigation Example from-viewto-view from-outcome list.jsp new_usr.jsp error.jsp error.jsp detail.jsp “ item_detail” new user error
- 42. Navigation <navigation-rule> <from-view -id> /list.jsp </from-tree-id> <navigation-case> < from-outcome > item_detail </from-outcome> < to-view -id> /detail.jsp </to-tree-id> </navigation-case> . . . </navigation-rule> < h: commandLink action ="#{ itemController.detailSetup } />
- 43. Standard request processinglifecycle JavaServer Faces Lifecycle Request Restore View Response Render Response Apply Request Values Invoke Application Update Model Values Process Validations
- 44.
- 45. detail.jsp . .. <h:panelGrid columns="2"> <h: outputText value=" Name: "/> <h: outputText value="#{ itemController.item.name }" title="Name" /> <h: outputText value="Description:"/> <h:outputText value="#{ itemController.item.description }" title="Description" /> <h:outputText value="Photo:"/> <h: graphicImage url="#{ itemController.item.imageurl }" title="Imageurl”/> <h:outputText value="Price:"/> <h:outputText value="#{ itemController.item.price }" title="Price" /> <h:outputText value="City:"/> <h:outputText value="#{ itemController.item.address.city }" title="Address" /> <h:outputText value="Seller email:"/> <h:outputText value="#{ itemController.item.contactinfo.email }" title="Address" </h:panelGrid> <h: commandLink action="item_list" value="List of Items"/> Calls itemController.getItem().getName()
- 46. UIOutput component valueattribute <h: outputText value="#{ itemController.item.name }" title="Name" /> public class ItemController { private Item item ; private DataModel model ; public Item getItem() { return item; } public String detailSetup() { item = (Item) model.getRowData(); return " item_detail "; } Calls itemController.getItem().getName()
- 47. Get Next Listof Items page
- 48. Invoke Application PhaseUICommand Action : Refers to a backing bean method that performs navigation processing and returns a logical outcome String <h: commandLink action ="#{ itemController.next } " ... /> public class ItemController { public String next() { if (firstItem + batchSize < itemCount) { firstItem += batchSize; } return " item_list "; }
- 49. Navigation <navigation-rule> <navigation-case>< from-outcome > item_list </from-outcome> < to-view -id> /list.jsp </to-tree-id> </navigation-case> . . . </navigation-rule> < h: commandLink action ="#{ itemController.next } />
- 50. Standard request processinglifecycle JavaServer Faces Lifecycle Request Restore View Response Render Response Apply Request Values Invoke Application Update Model Values Process Validations
- 51. <h:dataTable value='#{ itemController.items }' var =' dataTableItem ' border="1" > <h:column> <f:facet name="header"> h: outputText value=" Name "/> </f:facet> <h: commandLink action ="#{ item.detailSetup }" value ="#{ dataTableItem .name }"/> </h:column> <h:column> <f: facet name=" header "> h: outputText value =" Photo "/> </f:facet> < h: graphicImage url ="#{ dataTableItem .imagethumburl }"/> </h:column> <h:column> <f:facet name="header"> h: outputText value =" Price "/> </f:facet> <h: outputText value ="#{ dataTableItem .price }"/> </h:column> </h:dataTable> Render Will call getItems() which will display next items
- 52. GlassFish Application ServerJava EE 5 , Toplink JPA Enterprise Quality GlassFish Enterprise Open Source Dual-licensed with GPLv2/CPE Community at Java.Net Sources, bug DBs, discussions at Java.Net Roadmaps, Architecture Documents Sample application on Carol's blog : http://weblogs.java.net/blog/caroljmcdonald/
- 53. Timeline of ProjectGlassFish Tomcat Jasper Catalina JSTL Struts Crimson XSLTC Xalan Xerces JAXB JAX-RPC JSF June 2005 May 2006 GlassFish Launch v2 v1 v3 Mid-2009 UR1 v2.1 UR2 v3 Prelude Oct 2008 Dec 2008 Sept. 2007
- 54. Demo Demo Netbeans6.5 JPA entity JSF pages generation from DB tables
- 55. Agenda Catalog JavaEE Application Catalog Spring 2.5 JSF and JPA Application Catalog Java EE Seam Application Summary
- 56. Spring Framework GoalsInversion of control container for application components and lifecycle Wiring components through Dependency Injection Promotes de-coupling among the parts that make up an application Provide Java AOP implementation allowing the separation of cross-cutting concerns Logging ... Facilitate unit testing Allow effective TDD Allow POJO classes to be unit tested outside the container
- 57.
- 58. What Is SpringNot? Not Java EE Platform Container Spring typically runs within a Java EE platform or Web container Spring can run in Java SE or Java EE Spring leverages and prefers to use existing standards relies upon the services of the server in which it is deployed
- 59. Catalog JSF, JPA,Spring Application DB Registration Application Managed Bean JSF Components Spring Bean Entity Class Catalog Item ItemController Spring Framework
- 60. Bean Factory andDependency Injection Spring Bean Factory injects dependencies Application's POJOs Configuration file Dependencies in applicationContext.xml Fully configured and ready to use objects
- 61. Spring Dependency Injectionpublic class ItemController { private CatalogService catalogService ; public void setCatalogService (CatalogService catalogService) { this.catalogService = catalogService; } Inject Spring Bean <beans> <bean id=“ catalogService ” class=“ service.CatalogDAO ”/> <bean id=" itemController " class="controller.ItemController" scope="session"> < property name =" catalogService "> ref =" catalogService "/> </bean> </beans> applicationContext.xml
- 62. Spring 2.5 DependencyInjection public class ItemController { @Autowired public void setCatalogService (CatalogService catalogService) { this.catalogService = catalogService; } } @Repository ("catalogService") public class CatalogDAO implements CatalogService { } Inject Spring Bean CatalogService injected by type <beans> <context:component-scan base-package="service" /> </beans> applicationContext.xml
- 63. Spring 2.5 Stereotypesand Autowiring @Autowired takes care of wiring , enables DI without XML Default is match by type, @Qualifier match by bean name A component scan can discover beans @Component designates Spring component @Controller @Service @Repository extend @Component , designate a web controller, service, or DAO component <beans> <context:component-scan base-package="service" /> </beans> applicationContext.xml
- 64. Catalog JSF, JPA,Spring Application DB Registration Application Managed Bean JSF Components Spring Bean Entity Class Catalog Item ItemController Spring Framework
- 65. ItemController Bean andSpring Dependency Injection import service.CatalogService; @Component @Scope("session") public class ItemController { private CatalogService catalogService ; @Autowired public void setCatalogService (CatalogService catalogService) { this.catalogService = catalogService; } public int getItemCount() { return = catalogService ().getItemCount(); } . . . Inject Spring Bean Creates ItemController Spring bean no need to put in faces_config.xml CatalogService injected by type
- 66. Spring JSF Configurationin faces-config.xml Spring's Expression Language resolver <h: outputText value="#{ itemController.item.name }" title="Name" /> JSP Expression Language <beans> <context:component-scan base-package="controller" /> </beans> applicationContext.xml Will scan for components, don't have to configure managed beans in faces-config.xml <application> <variable-resolver> org.springframework.web.jsf.el.SpringBeanFacesELResolver </variable-resolver> </application>
- 67. Spring JSF Configurationin web.xml for intercepting request to JSF bootstrapping Spring's web application context <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/ applicationContext.xml </param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <listener> <listener-class> org.springframework.web.context.request.RequestContextListener </listener-class> </listener>
- 68. Rest of JSFstays the same Spring Web Flow can also be used with JSF, but not was used in this example
- 69. Catalog JSF, JPA,Spring Application DB Registration Application Managed Bean JSF Components Spring Bean Entity Class Catalog Item ItemController Spring Framework
- 70. Catalog Spring BeanUsing JPA @Repository @Transactional public class CatalogDAO implements CatalogService { @PersistenceContext (unitName="PetCatalogPu") private EntityManager em; @Transactional(readOnly=true) public List<Item> getItems (int firstItem,int batchSize) { Query q = em. createQuery("select object(o) from Item as o"); q.setMaxResults(batchSize); q.setFirstResult(firstItem); List<Item> items= q.getResultList(); return items; } Component Stereotype Spring transactions use aop
- 71. Configuration of catalogServiceSpring Bean in aplicationContext.xml <beans> <context:component-scan base-package="service" /> . . . </beans> Spring will scan for components in the service package Configuration is done with matching type Scan for components
- 72. Catalog JSF, JPA,Spring Application DB Registration Application Managed Bean JSF Components Spring Bean Entity Class Catalog Item ItemController Spring Framework
- 73. JPA Entity staysthe same @Entity public class Item implements Serializable { @Id protected Long id; private String name; private BigDecimal price; public Item() {} public Long getId() {return id;} public String getName() {return name;} public void setName(String name) {this.name = name;} public String getPrice() {return price;} public void setPrice( BigDecimal name){this.price=price;} … }
- 74. Configuring Persistence Provider<bean id=” entityManageFactory ” class=”... LocalContainerEntityManagerFactoryBean ”> <property name=”dataSource” ref=” dataSource ”/> <property name=”loadTimeWeaver”> <bean class=”... GlassFishLoadTimeWeaver ”/> </property> <property name=”jpaVendorAdapter”> <bean class=”... TopLinkJpaVendorAdapter ”/> </property> </bean> <bean id=” transactionManager ” class=”... JtaTransactionManager ”/> <tx: annotation-driven /> <context:annotation-config/> <aop:aspectj-autoproxy/> <bean class=".... PersistenceExceptionTranslationPostProcessor "/> <bean class=".... PersistenceAnnotationBeanPostProcessor "/> Container managed JPA Defined data source TopLink Classfile enhancer, for lazy loading
- 75. Spring JPA Configurationfor Derby JDBC driver <bean id=" dataSource " class="org. springframework .jdbc.datasource. DriverManagerDataSource "> <property name="driverClassName" value=" org.apache. derby .jdbc.ClientDriver " /> <property name="url" value="jdbc:derby://localhost:1527/pet-catalog" /> <property name="username" value="app" /> <property name="password" value="app" /> </bean>
- 76. Spring & GlassFishApplication Server To Run Spring on Glassfish: Add Spring 2.5 jar files to application War Configure .xml files Sample on Carol's blog : http://weblogs.java.net/blog/caroljmcdonald/
- 77. Get Spring (andthis sample) from the GlassFish Update Center
- 78. Or Get Springfrom from Netbeans Plugins catalog
- 79. Summary Spring Heavily AOP and POJO based Annotation and configuration centric, but easy to test Provides its own way for transaction management, data sources, etc Java EE Glassfish future: OSGI , faster startup , only load needed modules going into Glassfish V3
- 80. Agenda Catalog JavaEE Application Catalog Java EE Spring Application Catalog Java EE Seam Application Summary
- 81. What is Seam?Framework on top JavaEE 5 Seam unifies the “ web tier ” with the “ enterprise tier ” “ Glue ” for JSF and EJB3 components Enable EJB 3.0 components to used as JSF managed beans Prototype for JSR 299 WebBeans , will be in Java EE 6 Can also work with POJOs instead of EJBs
- 82. WebBeans JSR299 @Component @SessionScoped public class Credentials { private String username; private String password; ... } public class Login { @In Credentials credentials; ... } Component: Managed class can be injected Gavin King JSR 299 lead, Sun, Google , Oracle... members Component: Definition of Managed class when name is requested, instantiated Scope: Context Buckets where the component instances are stored
- 83. Bean Validation Framework JSR 303 Bean Validation Framework JSR 303 going into Java EE 6 @Entity public class Address { @Max(9) @NotNull private String zipcode; } Emmanuel Bernard (Red Hat) JSR 303 lead, Sun, Google, Oracle... members
- 84. Seam Catalog Application DB Session EJB Entity Seam Framework JSF Components CatalogBean Item
- 85. Seam Key ConceptsEliminate the ManagedBean – bind directly to any component: Entity, EJB.... Components are associated with context variables using @Name The @Name annotation binds the component to a contextual variable – it’s just like < managed-bean-name > in the JSF XML @Name = gives a name to reference a component Context ~= bucket
- 86. Seam Key ConceptsComponents are assigned a scope using the @Scope annotation EVENT scope -- Spans a server request , from restore view to render response SESSION scope –http session CONVERSATION scope --Spans multiple requests from the same browser window, demarcated by @Begin and @End methods. Others: PAGE, APPLICATION, BUSINESS_PROCESS Context=bucket Scope = how long stored in context bucket @Name = gives a name to reference a component
- 87. Seam Key Conceptsless xml – use annotations instead dependencies are injected and updated every time a component is accessed Bijection – of components @In private MyServiceOne service1; injection is applied before the method is invoked @Out private Item item; outjection is applied after the method is invoked
- 88. Seam Catalog Application DB Session EJB Entity Seam Framework JSF Components CatalogBean Item
- 89. JPA Entity &Seam @Entity @Name(" item ") @Scope(ScopeType.EVENT) public class Item implements Serializable { @Id protected Long id; private String name; private BigDecimal price; public Item() {} public Long getId() {return id;} public String getName() {return name;} public void setName(String name) {this.name = name;} public String getPrice() {return price;} public void setPrice( BigDecimal name){this.price=price;} … } The @Name annotation binds the component to a contextual variable – it’s just like <managed-bean-name> in the JSF XML
- 90. Seam Catalog Application DB Session EJB Entity Seam Framework JSF Components CatalogBean Item
- 91. Seam JSF Configurationin faces-config.xml <application> <el-resolver> org.jboss.seam.jsf.SeamELResolver </el-resolver> </application> <lifecycle> <phase-listener> org.jboss.seam.jsf.SeamPhaseListener </phase-listener> </lifecycle>
- 92. Component Bindings – List.jsp ... <h:dataTable value='#{ items }' var=' dataTableItem '> <h:column> <h:commandLink action="#{ catalog . select }" value="#{ dataTableItem .name}"/> </h:column> <h:column> <h:graphicImage url="#{ dataTableItem .imagethumburl}"/> </h:column> <h:column> <h:outputText value="#{ dataTableItem .price}"/> </h:column> </h:dataTable> ... A snippet from List.jsp
- 93. UIComponents Binding to a Session EJB public class CatalogBean { @DataModel List<Item> items @Factory ("items") public void getItems () { ... } . . . } <h: dataTable value ="#{ items }" var='dataTableItem' Session Bean @DataModel for exposing to page @Factory for initializing Client Server A B C Backing Bean Form c1 A c2 B c3 C c1 c2 c3 A B C Page
- 94. Catalog Session EJB @Stateful @Scope(SESSION) @Name(" catalog ") @Interceptors ({org.jboss.seam.ejb. SeamInterceptor .class}) public class CatalogBean implements Serializable, Catalog { @PersistenceContext(unitName=”PetCatalogPu”) EntityManager entityManager; @DataModel private List<Item> items=null; @Factory(" items ") public void getItems() { Query q = em.createQuery( "select object(o) from Item as o"); q.setMaxResults( batchSize ); q.setFirstResult( firstItem ); items= q.getResultList(); } Seam JSF DataModel component Seam Factory Method, called on initialization
- 95. EJB 3.0 Interceptors Interceptors intercept calls sit between caller and a bean basic AOP Invocation model: “ around ” methods Wrapped around invocation of business method Uses: Auditing, logging , exception handling, security interceptor dataTable value ="#{ items }" @Stateless public class CatalogBean { public void book(…) {} }
- 96. Component Bindings – List.jsp ... <h:dataTable value='#{ items }' var=' dataTableItem '> <h:column> <h:commandLink action ="#{ catalog . select }" value="#{ dataTableItem .name}"/> </h:column> <h:column> <h:graphicImage url="#{ dataTableItem .imagethumburl}"/> </h:column> <h:column> <h:outputText value="#{ dataTableItem .price}"/> </h:column> </h:dataTable> ... A snippet from List.jsp Action link @DataModelSelection holds the selected value
- 97. UIComponents Binding to a Session Bean <h: commandLink action ="#{ catalog.select }" value="#{dataTableItem.name}"/> Session Bean JSF positions DataModel.getRowData() to row of action before calling action listener public class CatalogBean { @DataModelSelection @Out private Item item; public String select() { return "item_detail"; } . . . } Client Server A B C Backing Bean Form c1 A c2 B c3 C c1 c2 c3 A B C Page
- 98. Invoke Application Phase<h: commandLink action ="#{ catalog.select } " @Stateful @Scope(SESSION) @Name(" catalog ") @Interceptors ({... SeamInterceptor .class}) public class CatalogBean implements Serializable, Catalog @DataModel private List< Item > items =null; @DataModelSelection @Out(required=false) private Item item; public String select() { return "item_detail"; } Action method Navigation response outject to the item context variable inject the DataModel row item corresponding to clicked Link Action method
- 99. Navigation (same asbefore) from-view to-view from-outcome Navigation rules in faces-config.xml, Or in Seam's pages.xml . list.jsp new_usr.jsp error.jsp error.jsp detail.jsp “ item_detail” new user error
- 100. Seam Catalog Application DB Session EJB Entity Seam Framework JSF Components CatalogBean Item
- 101. Standard request processinglifecycle Render Response Request Restore View Response Render Response Apply Request Values Invoke Application Update Model Values Process Validations outjected item event context variable, available to JSP
- 102. Component Bindings – Detail.jsp ... <h:outputText value="Name:"/> <h:outputText value="#{ item .name}" title="Name" /> <h:outputText value="Description:"/> <h:outputText value="#{ item .description}" title="Description" /> <h:outputText value="Photo:"/> <h:graphicImage url="#{ item .imageurl}" title="Imageurl" /> ... A snippet from Detail.jsp @Out exposes value to page outjected item event context variable, available to JSP
- 103. Seam & GlassFishApplication Server To Run Seam on Glassfish: Add Seam jar files to application: some in War some in EJB jar Configure .xml files Seam 2.0 example on Carol's blog : http://weblogs.java.net/blog/caroljmcdonald/ Seam 2.1 glassfish configuration : http://docs.jboss.com/seam/2.1.0.SP1/reference/en-US/html/glassfish.html
- 104. Agenda Catalog JavaEE Application Catalog Java EE Spring Application Catalog Java EE Seam Application Summary
- 105. Summary Each opensource project provides a different approach to how an application is built Spring Heavily AOP and POJO based Annotation and configuration centric, but easy to test Provides its own way for transaction management, data sources, etc Seam builds on JavaEE Simplification of EJB3 and JSF development Java EE Glassfish future: Web Beans and Bean Validation going into Java EE 6 OSGI , faster startup , only load needed modules going into Glassfish V3
- 106. Which one, don't ask me Best Tool for the Job? Better Framework depends on your application requirements Pick 2-3 frameworks for your type of application... ... and prototype! If prototype doesn't meet requirements, switch
- 107. For More InformationGlassfish https://glassfish.dev.java.net/ http://blogs.sun.com/theaquarium/ JavaEE http://java.sun.com/javaee/ Spring http://www.springframework.org/ Seam http://www.seamframework.org/ Seam in Action Book, by Dan Allen Carol's blog http://weblogs.java.net/blog/caroljmcdonald/
- 108. Presenter’s Name [email_address]Carol McDonald Java Architect Tech Days 2009
Editor's Notes
- #7 You can do o/r mapping using either java language annotations or xml descriptor or a combination of both. And the API is usable in both Java EE and Java SE environments it also supports pluggable persistence providers. So you can use the persistence provider of your choice in your app server environment, you are not locked into a persistence provider. The query language has been expanded considerably beyond the earlier EJB QL , so now its a rich full fledged query language over the object model. Object relational mapping has been standardized, which had long been requested.
- #8 The primary feature of the JPAis that is is a pojo based persistence model. Entities are simple java classes they are not components. They support rich modeling capabilities. They support inheritance, they support polymorphism, polymorphic relationships, polymorphic queries.
- #9 JPA Entities are plain old java object. You create an instance by means of new, they have no required interfaces.. An entity is a lightweight persistence domain object. Typically an entity represents a table in a relational database, and each entity instance corresponds to a row in that table. The primary programming artifact of an entity is the entity class, although entities can use helper classes. The persistent state of an entity is represented either through persistent fields or persistent properties. These fields or properties use object/relational mapping annotations to map the entities and entity relationships to the relational data in the underlying data store. Entities have a persistent identity, which corresponds to a primary key in a database. They may have both persistent and non-persistent state. And the persistent state can be either simple types such as java primitives, wrappers, enums, types that are serializable or the state can be complex it can be composite (dependent objects)
- #12 One-to-many and many-to-one bidirectional relationships . A one-to-many bidirectional relationship occurs when one entity bean maintains a collection-based relationship property with another entity bean, and each entity bean referenced in the collection maintains a single reference back to its aggregating bean. While the Order table contains a foreign key to the Customer table, the customer table doesn't maintain a foreign key back to the order table. This illustrates the separation between the entity bean's view of its persistence relationships and the database's actual implementation of those relationships. We need to add a collection-based relationship property to the customer class so that it can reference all the orders that were created for it. there must be one owning side of a relationship in a one-to-many bidirectional relationship. the many-to-one side is always the owner (the order).this requires you to call Order.setCustomer( ) whenever you add or remove a customers order. The one to many side is the non owning side and it has to say where the foreign key is and does this by using the mappedBy. The cust field in the order class is the one that maps the foreign key for this relationship, and the defaults to cust_id in the order table
- #14 An EntityManager instance is used to manage the state and life cycle of entities within a persistence context. The entity manager is responsible for creating and removing persistent entity instances and finding entities by the entity's primary key. It also allows queries to be run on entities.
- #15 An EntityManager instance is used to manage the state and life cycle of entities within a persistence context. The entity manager is responsible for creating and removing persistent entity instances and finding entities by the entity's primary key. It also allows queries to be run on entities.
- #16 In a transaction-scoped container managed entity manager (common case in a Java EE environment), the JTA transaction propagation is the same as the persistence context resource propagation. In other words, container-managed transaction-scoped entity managers retrieved within a given JTA transaction all share the same persistence context.
- #17 In this example the sb looks up an order, adds a line items. The stateless session bean does the workflow with a lookup and merge in each operation as needed, whereas the stateful session bean does the same by caching the references. Extended persistence context to keep and reuse managed entities that are the subject of the conversation workflow HTTPSession, stateful session bean Entities remain managed and cached over multiple transactions Become detached when EntityManager is closed or when Stateful session bean is removed
- #20 To obtain an container managed EntityManager instance, inject the entity manager into the application component: @PersistenceContext EntityManager em; you don't need any cm lifecycle methods With a container-managed entity manager, an EntityManager instance's persistence context is automatically propagated by the container to all application components that use the EntityManager instance within a single Java Transaction Architecture (JTA) transaction. JTA transactions usually involve calls across application components. To complete a JTA transaction, these components usually need access to a single persistence context. This occurs when an EntityManager is injected into the application components via the javax.persistence.PersistenceContext annotation. The persistence context is automatically propagated with the current JTA transaction, and EntityManager references that are mapped to the same persistence unit provide access to the persistence context within that transaction. By automatically propagating the persistence context, application components don't need to pass references to EntityManager instances to each other in order to make changes within a single transaction. The Java EE container manages the lifecycle of container-managed entity managers.
- #21 Dependency Injection With Java EE 5, invoking an EJB component is a snap with dependency injection. Dependency injection support in Java EE 5 was influenced by inversion of control (IoC) containers such as Spring. Dependency injection is essentially the opposite of the JNDI: the container is responsible for looking up and instantiating an instance of an EJB or a resource. The concept behind Inversion of Control is often expressed in the Hollywood Principle: &quot;Don't call me, I'll call you.&quot; IoC moves the responsibility for making things happen into the framework, and away from application code. Whereas your code calls a traditional class library, an IoC framework calls your code.
- #26 Components - A tag for a JSF custom component - A component class (UI class) that • maintains state, • renders a user interface, • and processes input • The tag is just needed for plumbing in the JSF page • The UI class does the important work - Render the user interface by encoding markup - Process user input by decoding the current HTTP request --------------------------------- The actual UIComponent class, which defines the behavior of the component, such as UISelectOne, which allows the user to &quot;select one from many.&quot; #An optional Renderer class, which provides specific renderings of the component. For example, a UISelectOne component could be rendered in HTML as either a group of radio buttons or a &quot;select&quot; menu. #A JSP tag, which associates a Renderer with a UIComponent and makes them usable in a JSP as a single tag, <h:selectOneMenu >. It's important to note that &quot;pluggable&quot; Renderer classes allow the UI component to not only be HTML tag-independent (radio or select), but client device—independent where the UI component can be rendered in any markup language, such as HTML, WML, and so on
- #30 note the taglib declaration. JSF comes with its own set of JSP custom tag libraries. Here we declare two JSF tag libraries, html and core. The html JSF tag library contains HTML rendering tags while the core JSF tag library contains JSF core tags. These libraries expose most of the JSF components, validators, event registers, and so on. Note that there are several UI components in this page. And they are <h:output_text>, <h:inputText>, <h:commandButton>. The <h:output_text>elements contains value attributes whose values come from the property values of a JavaBean called UserNumberBean. The names of these properties of this bean are called minimum and maximum. The <h:inputText> element displays the userNumber property of the UserNumberBean and also prompts the user to enter a new number in the textfield. The <h:commandButton> displays a button that can be pressed for submitting the form data. ·form tag represents an input form with which the user can submit data to the server.
- #31 This slide shows the relationship between JSP page and backing bean declaration in the application configuration file. Every backing bean needs to be declared in the application configuration file. Here in this guessNumber example, there is only one bean called UserNumberBean, which has two properties called minimum and maximum whose types and initial values are also defined. In the JSP page, you refer to these properties using JSF EL expression notation like #{UserNumberBean.minimum} or #{UserNumberBean.maximum}. to provide an event-based, JavaBean model way of interacting with application data, JavaServer Faces provides an easy-to-use mechanism by which Web-accessible user interface components are bound to server-side JavaBeans that are registered as &quot;Managed Beans&quot; in an XML file (faces-config.xml). Beans are bound to a user interface with a simple-to-use Expression Language, which is almost identical to JSTL's Expression Language syntax.
- #33 note the taglib declaration. JSF comes with its own set of JSP custom tag libraries. Here we declare two JSF tag libraries, html and core. The html JSF tag library contains HTML rendering tags while the core JSF tag library contains JSF core tags. These libraries expose most of the JSF components, validators, event registers, and so on. Note that there are several UI components in this page. And they are <h:output_text>, <h:inputText>, <h:commandButton>. The <h:output_text>elements contains value attributes whose values come from the property values of a JavaBean called UserNumberBean. The names of these properties of this bean are called minimum and maximum. The <h:inputText> element displays the userNumber property of the UserNumberBean and also prompts the user to enter a new number in the textfield. The <h:commandButton> displays a button that can be pressed for submitting the form data. ·form tag represents an input form with which the user can submit data to the server.
- #34 The value attribute of a dataTable tag references the data to be included in the table. The var attribute specifies a name that is used by the components within the dataTable tag as an alias to the data referenced in the value attribute of dataTable. In the dataTable tag from the List.jsp page, the value attribute points to a list of catalog items. The var attribute points to a single item in that list. As the UIData component iterates through the list, each reference to dataTableItem points to the current item in the list.
- #35 getItems() method wraps a List of items, returned from the CatalogFacade Stateless Session EJB, in a DataModel. dataTable, supports data binding to a collection of data objects represented by a DataModel instance, which is the current value of this component itself. The data collection underlying a DataModel instance is modeled as a collection of row objects that can be accessed by a row index. The APIs provide mechanisms to position to a specified row index, and to retrieve an object that represents the data that corresponds to the current row index.
- #36 To obtain an container managed EntityManager instance, inject the entity manager into the application component: @PersistenceContext EntityManager em; you don't need any cm lifecycle methods With a container-managed entity manager, an EntityManager instance's persistence context is automatically propagated by the container to all application components that use the EntityManager instance within a single Java Transaction Architecture (JTA) transaction. JTA transactions usually involve calls across application components. To complete a JTA transaction, these components usually need access to a single persistence context. This occurs when an EntityManager is injected into the application components via the javax.persistence.PersistenceContext annotation. The persistence context is automatically propagated with the current JTA transaction, and EntityManager references that are mapped to the same persistence unit provide access to the persistence context within that transaction. By automatically propagating the persistence context, application components don't need to pass references to EntityManager instances to each other in order to make changes within a single transaction. The Java EE container manages the lifecycle of container-managed entity managers.
- #39 note the taglib declaration. JSF comes with its own set of JSP custom tag libraries. Here we declare two JSF tag libraries, html and core. The html JSF tag library contains HTML rendering tags while the core JSF tag library contains JSF core tags. These libraries expose most of the JSF components, validators, event registers, and so on. Note that there are several UI components in this page. And they are <h:output_text>, <h:inputText>, <h:commandButton>. The <h:output_text>elements contains value attributes whose values come from the property values of a JavaBean called UserNumberBean. The names of these properties of this bean are called minimum and maximum. The <h:inputText> element displays the userNumber property of the UserNumberBean and also prompts the user to enter a new number in the textfield. The <h:commandButton> displays a button that can be pressed for submitting the form data. ·form tag represents an input form with which the user can submit data to the server.
- #41 At the invoke application phase– the JSF controller invokes the application to handle Form submissions. The component values will have been converted, validated, and applied to the model objects, so you can now use them to execute the application's business logic. At this phase, you also get to specify the next logical view for a given sequence or number of possible sequences. You do this by defining a specific outcome for a successful form submission and returning that outcome. For example: on successful outcome, move the user to the next page. For this navigation to work, you will have to create a mapping to the successful outcome as a navigation rule in the faces-config.xml file. Once the navigation occurs, you move to the final phase of the lifecycle.
- #46 note the taglib declaration. JSF comes with its own set of JSP custom tag libraries. Here we declare two JSF tag libraries, html and core. The html JSF tag library contains HTML rendering tags while the core JSF tag library contains JSF core tags. These libraries expose most of the JSF components, validators, event registers, and so on. Note that there are several UI components in this page. And they are <h:output_text>, <h:inputText>, <h:commandButton>. The <h:output_text>elements contains value attributes whose values come from the property values of a JavaBean called UserNumberBean. The names of these properties of this bean are called minimum and maximum. The <h:inputText> element displays the userNumber property of the UserNumberBean and also prompts the user to enter a new number in the textfield. The <h:commandButton> displays a button that can be pressed for submitting the form data. ·form tag represents an input form with which the user can submit data to the server.
- #47 At the invoke application phase– the JSF controller invokes the application to handle Form submissions. The component values will have been converted, validated, and applied to the model objects, so you can now use them to execute the application's business logic. At this phase, you also get to specify the next logical view for a given sequence or number of possible sequences. You do this by defining a specific outcome for a successful form submission and returning that outcome. For example: on successful outcome, move the user to the next page. For this navigation to work, you will have to create a mapping to the successful outcome as a navigation rule in the faces-config.xml file. Once the navigation occurs, you move to the final phase of the lifecycle.
- #49 At the invoke application phase– the JSF controller invokes the application to handle Form submissions. The component values will have been converted, validated, and applied to the model objects, so you can now use them to execute the application's business logic. At this phase, you also get to specify the next logical view for a given sequence or number of possible sequences. You do this by defining a specific outcome for a successful form submission and returning that outcome. For example: on successful outcome, move the user to the next page. For this navigation to work, you will have to create a mapping to the successful outcome as a navigation rule in the faces-config.xml file. Once the navigation occurs, you move to the final phase of the lifecycle.
- #52 note the taglib declaration. JSF comes with its own set of JSP custom tag libraries. Here we declare two JSF tag libraries, html and core. The html JSF tag library contains HTML rendering tags while the core JSF tag library contains JSF core tags. These libraries expose most of the JSF components, validators, event registers, and so on. Note that there are several UI components in this page. And they are <h:output_text>, <h:inputText>, <h:commandButton>. The <h:output_text>elements contains value attributes whose values come from the property values of a JavaBean called UserNumberBean. The names of these properties of this bean are called minimum and maximum. The <h:inputText> element displays the userNumber property of the UserNumberBean and also prompts the user to enter a new number in the textfield. The <h:commandButton> displays a button that can be pressed for submitting the form data. ·form tag represents an input form with which the user can submit data to the server.
- #53 Glass fish is an open source reference implementation of Java EE. All of the pieces like JSF , EJB are part of Glassfish. The Sun application server is based on Glassfish.
- #54 Mainly to show Open Source contributions from Sun. We're not rookies in server-side Open Source Java! :) Also interesting to show the progression: v1 was all about Java EE 5 v2 is all about enterprise features v3 is all about modularization and changing the game to leapfrog the competition in an even bigger way
- #57 Spring is one of the driving forces behind popularizing the POJO programming model and dependency injection. With Spring, you simply inject collaborating objects called dependencies using JavaBeans properties and configuration files. The ability to inject collaborating objects is often called IoC (inversion of control). Or dependency injection AOP allows developers to create non-domain concerns, called crosscutting concerns, and insert them in their application code. With AOP, common services like logging, persistence, transactions, and the like can be factored into aspects and applied to domain objects without complicating the object model of the domain objects. The IoC capabilities allowing injection of dependent objects is a great mechanism for testing your code. It is easy now to inject mock objects (object for testing), and test your classes in an isolated manner. Many developers want to choose a persistence, web, or messaging framework without having to do the integration work. The developers of the Spring framework realized that no matter which persistence, web, messaging, or &quot;whatever&quot; framework they selected to support, someone would want to use something else, and a better alternative would eventually come along. Also, this type of integration is typically expensive. By following the IoC and SoC principles, Spring was able to be both lightweight enough to let developers decide how much of the framework they needed, and flexible enough to support many permutations of competing component frameworks.
- #58 Spring provides several modules, such as the following: AOP module JDBC abstraction and DAO module ORM integration module Web module MVC framework provides a scaffolding for services you can pick and choose pieces of it Spring also includes patterns and recipes spring provides a simple programming model for using resources such as JDBC or JMS or using popular persistence frameworks like Hibernate or TopLink by abstracting low-level API and configuration from developers without limiting developers' choices. Spring AOP supports method interception. Key AOP concepts supported include: Interception: Custom behavior can be inserted before or after method invocations against any interface or class. This equates to “before”, “after” and &quot;around advice&quot; in AspectJ terminology. Introduction: Specifying that an advice should cause an object to implement additional interfaces. This can amount to mixin inheritance. Static and dynamic pointcuts: Specifying the points in program execution at which interception should take place. Static pointcuts concern method signatures; dynamic pointcuts may also consider method arguments at the point where they are evaluated. Pointcuts can be reused.
- #59 Spring does not reinvent the wheel. Thus you'll find no logging packages in Spring, no connection pools, no distributed transaction coordinator. All these things are provided by open source projects (such as Commons Logging, which we use for all our log output, or Commons DBCP), or by your application server or web container. For the same reason, we don't provide an O/R mapping layer. There are good solutions to this problem such as TopLink, Hibernate, JPA and JDO. Spring is not positioned as an alternative to Java EE but as a framework that facilitates the development of applications with Java EE. That's one of the primary reasons for Spring being successful as a framework. You can use the Spring framework on its own or inside a Java EE container.
- #61 The basic concept here is the BeanFactory , which provides a sophisticated implementation of the factory pattern which removes the need for programmatic singletons and allows you to decouple the configuration and specification of dependencies from your actual program logic A Spring bean factory is a generic factory that enables configured objects to be retrieved by name, and which can manage relationships between objects. Spring uses IoC as a basic concept throughout a full-featured framework. with Dependency Injection the container figures out that the component needs an X object, and provides it to it at runtime. The container does this figuring out based on method signatures (usually JavaBean properties or constructors) and, configuration data such as XML.
- #62 The two major flavors of Dependency Injection are Setter Injection (injection via JavaBean setters); and Constructor Injection (injection via constructor arguments). Spring provides sophisticated support for both, and even allows you to mix the two when configuring the one object. The root of a Spring XML bean definition document is a <beans> element. The <beans> element contains one or more <bean> definitions. normally specify the class and properties of each bean definition.and also specify the id, which will be the name that we'll use this bean with in our code. Relationships between beans are specified using a combination of the property and &quot;ref&quot; attribute
- #63 Spring also provides two kinds of what we call &quot;autowire&quot; support, where it figures out the dependencies between beans: autowire by type, and autowire by name Autowire support has the advantage of reducing the volume of configuration. Since Spring 2.5, you can use annotations to configure your beans. By simply including a <context:annotation-config/> element in your application context's configuration, you can use these annotations not only on your property setter methods, but also on constructors, fields, and arbitrary methods and method parameters. Here's an example using Spring's @Autowired annotation to configure the itemcontroller bean that depends on the catalogservice
- #64 Spring 2.5 allows autowiring by name to be used for constructors via the @Qualifier parameter annotation. you can make use of Spring's support for classpath scanning as a means to identify candidate beans. Spring provides @Component and @Repository &quot;stereotyping&quot; annotations that you can place on your candidate bean classes. By using the <context:component-scan base-package=&quot;…&quot;> configuration element, you tell Spring to automatically scan for and load as beans those classes in a given base package or its subpackages. This way, you won't have to declare each bean in your configuration – they will automatically be detected.
- #66 getItems() method wraps a List of items, returned from the CatalogFacade Stateless Session EJB, in a DataModel. dataTable, supports data binding to a collection of data objects represented by a DataModel instance, which is the current value of this component itself. The data collection underlying a DataModel instance is modeled as a collection of row objects that can be accessed by a row index. The APIs provide mechanisms to position to a specified row index, and to retrieve an object that represents the data that corresponds to the current row index.
- #67 The recommended way to integrate Spring with JSF is to configure the Spring DelegatingVariableResolver in the faces-context.xml. The <application> <variable-resolver> elements in a faces-config.xml file allows a Faces-based application to register a custom replacement class for the implementation of the standard Faces VariableResolver implementation. The Spring DelegatingVariableResolver first delegates to the original resolver of the underlying JSF implementation, then to the Spring root WebApplicationContext. This allows you to configure Spring Beans as managed properties of your JSF Managed Beans. For example, below the catalogService Spring Bean is configured as a managed property of the ItemController JSF ManagedBean:
- #68 The recommended way to integrate Spring with JSF is to configure the Spring DelegatingVariableResolver in the faces-context.xml. The <application> <variable-resolver> elements in a faces-config.xml file allows a Faces-based application to register a custom replacement class for the implementation of the standard Faces VariableResolver implementation. The Spring DelegatingVariableResolver first delegates to the original resolver of the underlying JSF implementation, then to the Spring root WebApplicationContext. This allows you to configure Spring Beans as managed properties of your JSF Managed Beans. For example, below the catalogService Spring Bean is configured as a managed property of the ItemController JSF ManagedBean:
- #69 IJavaServer Faces UI components are configurable, reusable elements that
- #71 @Repository – Indicates that a class functions as a repository or a data access object (DAO) @Transactional – Provides annotation driven demarcation for transactions
- #74 # The class must be annotated with the javax.persistence.Entity annotation. # The class must have a public no-argument constructor. .# If an entity instance is to be passed by value as a detached object, such as through a session bean's remote business interface, the class must implement the Serializable interface. # Entities may extend both entity and non-entity classes, and non-entity classes may extend entity classes.
- #75 TopLink JPA supports lazy loading using load-time weaving of the entity classes. When functioning within an EJB 3.0 container, weaving happens transparently. However, when using TopLink JPA outside of a container, it is up to you to enable this functionality <bean class=”... GlassFishLoadTimeWeaver ”/>
- #77 Glass fish is an open source reference implementation of Java EE. All of the pieces like JSF , EJB are part of Glassfish. The Sun application server is based on Glassfish.
- #80 Spring Pros: Inversion of Control makes it easy to test Cons: Configuration intensive - lots of XML, easier now even though EJB 3 is a specification and Spring is a framework, you can use them together successfully to build flexible, powerful applications. You can use parts of the EJB 3 implementation, or all of it, within your Spring applications. Spring can simplify the use of both EJB 3 and JPA, but at the price of foraging through Spring's XML configuration files. EJB 3 is a great framework for building enterprise Java applications, and it significantly improves developer productivity. It has some minor limitations, such as support for POJO injection, these limitations will be addressed in webbeans.
- #83 Web Beans has been submitted as JSR-299 with support from JBoss, The purpose of this specification is to unify the JSF managed bean component model with the EJB component model, resulting in a significantly simplified programming model for web-based applications.
- #86 The @Name annotation binds the component to a contextual variable its just like <manage-bean-name> in the JSF XML Every component has a name When name is first requested, instance is created Several ways to get access to a component by name Value expression - #{beerAction} Annotation - @In(&quot;beerAction&quot;) Context=Buckets where the component instances are stored Stored in request scope by default Request scope == event context Seam introduces the conversation context Supports a single use-case, which may span multiple pages and actions
- #87 The @Name annotation binds the component to a contextual variable its just like <manage-bean-name> in the JSF XML Every component has a name When name is first requested, instance is created Several ways to get access to a component by name Value expression - #{beerAction} Annotation - @In(&quot;beerAction&quot;) Context=Buckets where the component instances are stored Stored in request scope by default Request scope == event context Seam introduces the conversation context Supports a single use-case, which may span multiple pages and actions
- #88 Similar to dependency injection container satisfies the needs of components Bijection occurs on every method invocation Prefix &quot;bi&quot; implies that it occurs twice injection is applied before the method is invoked outjection is applied after the method is invoked Bijection = Injection + Outjection
- #90 The @Name seam annotation specifies the (application unique) component name item, which is used in the Detail.jsp to display the selected item's attributes. The @Scope Seam annotation binds the item instance to the org.jboss.seam.ScopeType.EVENT context. APPLICATION BUSINESS_PROCESS The business process context. CONVERSATION The conversation context. EVENT The event (request) context. METHOD The method context. PAGE The page context. SESSION
- #92 The recommended way to integrate Spring with JSF is to configure the Spring DelegatingVariableResolver in the faces-context.xml. The <application> <variable-resolver> elements in a faces-config.xml file allows a Faces-based application to register a custom replacement class for the implementation of the standard Faces VariableResolver implementation. The Spring DelegatingVariableResolver first delegates to the original resolver of the underlying JSF implementation, then to the Spring root WebApplicationContext. This allows you to configure Spring Beans as managed properties of your JSF Managed Beans. For example, below the catalogService Spring Bean is configured as a managed property of the ItemController JSF ManagedBean:
- #94 The value attribute of a dataTable tag references the data to be included in the table. The var attribute specifies a name that is used by the components within the dataTable tag as an alias to the data referenced in the value attribute of dataTable. In the dataTable tag from the List.jsp page, the value attribute points to a list of catalog items. The var attribute points to a single item in that list. As the UIData component iterates through the list, each reference to dataTableItem points to the current item in the list.
- #95 When the List.jsp page is diplayed it will try to resolve the items context variable. Since this context variable is not initialized, Seam will call the factory method getItems(), The @DataModel Seam annotation exposes an attribute of type java.util.List to a JSF page as an instance of javax.faces.model.DataModel. The <h:dataTable> supports data binding to a collection of data objects represented by a DataModel instance. The data collection underlying a DataModel instance is modeled as a collection of row objects that can be accessed by a row index. The APIs provide mechanisms to position to a specified row index, and to retrieve an object that represents the data that corresponds to the current row index. In this case, the DataModel is made available in a session context variable named items.
- #96 The @Interceptors EJB 3.0 annotation registers the SeamInterceptor.class as an EJB interceptor for this session bean component. The Seam framework uses EJB interceptors to perform bijection, context demarcation, validation, etc, (the interceptor could be defined in the ejb-jar.xml instead).
- #98 The value attribute of a dataTable tag references the data to be included in the table. The var attribute specifies a name that is used by the components within the dataTable tag as an alias to the data referenced in the value attribute of dataTable. In the dataTable tag from the List.jsp page, the value attribute points to a list of catalog items. The var attribute points to a single item in that list. As the UIData component iterates through the list, each reference to dataTableItem points to the current item in the list.
- #99 The @DataModelSelection Seam annotation tells Seam to inject the DataModel List element corresponding to the clicked link into the item attribute. @Out Seam annotation transfers the value of this attribute to the item event context variable, making it available to a JSP page
- #105 Seam Pros • Fully integrated Java EE 5 based web application framework • By means of Seam-Gen, very quick generation of applications • Simplification of an EJB3 and JSF development to the effect that no more glue code is required • Many cool features, which considerably simplify the development of applications (pre-actions, request parameters, conversation scope, ...) Now the cons: • No layers any more, good or bad • The abolition of the strict division into layers is a matter of opinion. • Mixture of GUI and persistence layer • Not yet standardized
- #106 Seam unifies JavaServer Faces, Enterprise JavaBeans 3, the Java Persistence API, under an accessible component-based model, empowering you to create stateful enterprise applications with tremendous agility. Still, Spring sports many features that you won't find in Seam. It's likely that these features -- such as lightweight remoting, advanced aspect-oriented programming (AOP) declarations, framework template classes, and emulated container resource injections, to mention a few -- simply aren't the passion of Seam.