- Doris Chen presented on JavaServer Pages/Servlets and web application frameworks.
- She discussed the JSP/Servlet technology foundation and how frameworks like Struts, JavaServer Faces, and Sun ONE Application Framework build upon it.
- Struts is an open source MVC framework that uses Java servlets as controllers and JSPs as views. It utilizes configuration files and custom tags to coordinate requests between components.
This document introduces Java Server Faces (JSF), a server-side user interface framework. It discusses JSF's architecture, which follows the MVC pattern. The UI component model in JSF includes components, events, validators, converters, and navigation support. Developing a JSF application involves creating managed beans, defining pages with JSF tags, configuring navigation in faces-config.xml, and setting up the web.xml file. JSF applications use a request processing lifecycle to handle requests and render responses.
Java Server Faces (JSF) is a component-based MVC framework for building user interfaces in Java web applications. JSF provides UI components that can be used in JSP or Facelets views. It follows a request response lifecycle where the controller handles gathering input, validating, updating models, and rendering responses. Popular JSF components include inputs, outputs, selects, forms, and commands. Facelets is the default view technology in JSF 2 and provides templating capabilities. Key differences between JSF and JSF 2 include replacing JSP with Facelets and adding Ajax and annotation support. Spring MVC has the highest demand and documentation quality while Struts 2 has the lowest learning curve and JSF is in
The document discusses different web frameworks for Java, focusing on Struts 1, Spring MVC, and JavaServer Faces. It provides an overview and examples of how Struts 1 implements the MVC pattern using components like ActionServlet, RequestProcessor, and ActionMappings. It also briefly compares Struts 1 and 2, and outlines key aspects of Spring MVC like flexible request mapping and support for different view technologies.
This document provides an overview of JavaServer Faces (JSF), including its architecture, components, lifecycle, and usage. JSF is a component-based user interface framework for building web applications using reusable UI components and a component-oriented approach. The key aspects covered include the MVC architecture of JSF with models, views, and controllers; the main JSF components and their roles; the request processing lifecycle; and best practices for code implementation.
JSF 2 life cycle consists of 6 phases: restore view, apply request values, process validations, update model values, invoke application, and render response. Managed beans are JavaBeans that can be accessed from JSF pages and are used to store data. Facelets is the templating language used by JSF 2 that replaced JSP. Navigation between pages can be done through configuration, implicit navigation based on action outcomes, or redirection. New features in JSF 2.2 include faces flows for page flows, HTML5 support, and a file upload component.
Java Web Programming [7/9] : Struts2 BasicsIMC Institute
This document provides an overview of the Apache Struts 2 framework. It discusses that Struts 2 is an open-source MVC framework built on top of Servlets and JSP technologies. It takes complexity out of building web applications and encourages good design practices. The document then outlines the basic steps to create a simple Struts 2 application, including writing JSP pages and action classes, configuring the struts.xml file, building and deploying the application.
This document introduces the Model-View-Controller (MVC) pattern and its evolution in web application design. It discusses the Model 1 architecture which is page-centric, and the Model 2 architecture which is servlet-centric. Model 2 architecture separates the application into three logical layers - the model, the view, and the controller. Web application frameworks like Struts are also introduced, which are based on MVC Model 2 architecture and provide common functionality to web applications.
This document introduces Java Server Faces (JSF), a server-side user interface framework. It discusses JSF's architecture, which follows the MVC pattern. The UI component model in JSF includes components, events, validators, converters, and navigation support. Developing a JSF application involves creating managed beans, defining pages with JSF tags, configuring navigation in faces-config.xml, and setting up the web.xml file. JSF applications use a request processing lifecycle to handle requests and render responses.
Java Server Faces (JSF) is a component-based MVC framework for building user interfaces in Java web applications. JSF provides UI components that can be used in JSP or Facelets views. It follows a request response lifecycle where the controller handles gathering input, validating, updating models, and rendering responses. Popular JSF components include inputs, outputs, selects, forms, and commands. Facelets is the default view technology in JSF 2 and provides templating capabilities. Key differences between JSF and JSF 2 include replacing JSP with Facelets and adding Ajax and annotation support. Spring MVC has the highest demand and documentation quality while Struts 2 has the lowest learning curve and JSF is in
The document discusses different web frameworks for Java, focusing on Struts 1, Spring MVC, and JavaServer Faces. It provides an overview and examples of how Struts 1 implements the MVC pattern using components like ActionServlet, RequestProcessor, and ActionMappings. It also briefly compares Struts 1 and 2, and outlines key aspects of Spring MVC like flexible request mapping and support for different view technologies.
This document provides an overview of JavaServer Faces (JSF), including its architecture, components, lifecycle, and usage. JSF is a component-based user interface framework for building web applications using reusable UI components and a component-oriented approach. The key aspects covered include the MVC architecture of JSF with models, views, and controllers; the main JSF components and their roles; the request processing lifecycle; and best practices for code implementation.
JSF 2 life cycle consists of 6 phases: restore view, apply request values, process validations, update model values, invoke application, and render response. Managed beans are JavaBeans that can be accessed from JSF pages and are used to store data. Facelets is the templating language used by JSF 2 that replaced JSP. Navigation between pages can be done through configuration, implicit navigation based on action outcomes, or redirection. New features in JSF 2.2 include faces flows for page flows, HTML5 support, and a file upload component.
Java Web Programming [7/9] : Struts2 BasicsIMC Institute
This document provides an overview of the Apache Struts 2 framework. It discusses that Struts 2 is an open-source MVC framework built on top of Servlets and JSP technologies. It takes complexity out of building web applications and encourages good design practices. The document then outlines the basic steps to create a simple Struts 2 application, including writing JSP pages and action classes, configuring the struts.xml file, building and deploying the application.
This document introduces the Model-View-Controller (MVC) pattern and its evolution in web application design. It discusses the Model 1 architecture which is page-centric, and the Model 2 architecture which is servlet-centric. Model 2 architecture separates the application into three logical layers - the model, the view, and the controller. Web application frameworks like Struts are also introduced, which are based on MVC Model 2 architecture and provide common functionality to web applications.
Vibrant Technologies is headquarted in Mumbai,India.We are the best Advanced java training provider in Navi Mumbai who provides Live Projects to students.We provide Corporate Training also.We are Best Advanced Java classes in Mumbai according to our students and corporators
Java Server Faces is a framework for building user interfaces for web applications that provides ease-of-use, standardization, and device independence through reusable UI components, easy data transfer between components, custom component implementation, and UI state management across requests. It is intended for use by developers, page authors, application developers, component writers, and tools vendors.
JSF is a Java specification and framework for building component-based user interfaces for web applications. It uses the MVC design pattern with reusable UI components, and handles tasks like data conversion, validation, event handling and navigation. The JSF architecture includes a component tree, request processing lifecycle and rendering model. New features in JSF 2 include Facelets as the default view declaration language, annotation-based configuration, standardized Ajax support, and improved error handling. Developing with JSF involves creating managed bean models, registering them, building pages with UI components, defining navigation, and configuring the web application in web.xml.
Java Server Faces (JSF) is a Java web development framework that provides reusable UI components and a component-based MVC architecture. Key aspects of JSF include:
- Clean separation of behavior and presentation using a component-based MVC model.
- Standard UI components and events tied to server-side code.
- Typical JSF applications include JavaBeans for state/behavior, event-driven development, and JSP view pages that reference a component tree.
The example JSF calculator application demonstrates:
1) Configuring the Faces servlet and managed beans.
2) Developing a model class and controller to mediate between the view and model.
3) Creating
Struts An Open-source Architecture for Web Applicationselliando dias
The document provides an overview of Struts, an open-source MVC framework for building web applications in Java, discussing how to install and configure Struts, its core concepts like the MVC pattern, and how to develop applications using Struts including creating forms, actions, and tag libraries.
This document provides a summary of the major new features in JavaServer Faces (JSF) 2.0, including Facelets as the preferred view declaration language, composite components, Ajax support, partial state saving, view parameters, system events, resources, behaviors, view traversal, annotations, navigation, exceptions, validation, EL improvements, and new scopes. It highlights contributions from the JSF expert group and community and provides resources for learning more about JSF 2.0.
This document provides an overview of the Struts framework and its key components. It covers the model-view-controller design pattern used in Struts, the model components including JavaBeans and ActionForm beans, view components like JSP tags and internationalization, controller components like Action classes and the configuration file, and finally the tag libraries used in Struts. The document is part of a training course on Struts and introduces each major concept across 9 units.
This document provides an overview of JavaServer Faces (JSF), including:
1. JSF is a server-side user interface framework that provides reusable UI components, event handling, validation and integration with backend data for Java web applications.
2. The document outlines key JSF concepts like UI components, events, validators, converters and renderers. It also describes the request processing lifecycle and developer roles.
3. Advanced topics like navigation, internationalization and custom components are listed for discussion in a later session.
Java Spring MVC Framework with AngularJS by Google and HTML5Tuna Tore
The document provides an introduction to the Spring MVC framework. It describes key concepts such as MVC architecture, dependency injection, configuration of the DispatcherServlet, mapping requests to controllers, and defining views. It also discusses configuring ORM/JPA with Hibernate, sending emails, security, exceptions handling, and accessing REST services with RestTemplate. The document aims to give developers an overview of building web applications with Spring MVC.
The document discusses JavaServer Faces (JSF), an MVC framework for building web interfaces. It provides:
- An overview of JSF concepts like managed beans, expression language, navigation rules, and components.
- Examples of using JSF for static and dynamic navigation between pages, including declaring beans and navigation rules in faces-config.xml.
- How JSF handles form submission and uses managed beans to represent request parameters and output data to results pages.
There is a growing demand to build increasingly complex mobile applications with HTML5, in part due to its cross-platform nature. However delivering these applications is still very challenging. The Montage framework was designed from the ground up to build complex HTML5 applications. This talk will explain how Montage’s reusable and encapsulated Components provides a natural and effective way to write modular, robust, applications by allowing team members to work on different part at the same time.
The document discusses the history and architecture of JSF component behaviors. It describes how behaviors allow adding functionality to components through attached objects. A behavior API was introduced to provide a loose coupling between components and behaviors. The API uses client behaviors and behavior holders. The document demonstrates a simple confirm behavior and more advanced auto-suggest behavior to showcase the capabilities of the behavior API.
The document discusses integrating Spring MVC on the server side with Backbone.js on the client side for building Model-View-Controller (MVC) applications. It provides an overview of MVC patterns and how they are implemented in Spring MVC using Java and in Backbone.js using JavaScript. Key aspects covered include using Backbone models and collections to represent and manipulate data, views to render templates and handle user interactions, and routers to manage client-side routing and application states. RESTful APIs are also discussed as a way to communicate between the client-side Backbone code and the server-side Spring MVC application.
This session will provide a complete tour of using the Spring MVC framework to build Java Portlets. It will include an in-depth review of a sample portlet application developed using the latest features of Spring MVC, including Annotation-based Controllers. If you are writing Portlets and using Spring, this session is for you.
We'll begin by discussing the unique differences and challenges when developing Portlets instead of traditional Servlet webapps. Then we'll talk about the unique approach that Spring MVC takes towards Portlets that fully leverages the Portlet lifecycle, instead of masking it like many other frameworks. We'll take an extensive tour of a sample application so we can see all the unique pieces of the framework in action. Finally we'll conclude with discussion of the upcoming support for the Portlet 2.0 (JSR 286) specification that will be part of Spring 3.0.
Mike Taulty MIX10 Silverlight 4 Patterns Frameworksukdpe
The document discusses various frameworks and patterns in Silverlight 4, including ASP.NET client application services, WCF data services, WCF RIA services, navigation, search, and extensibility with MEF. It provides an overview and demos of each technology. The presentation encourages attendees to check the schedule for additional in-depth sessions on topics like OData, WCF data services, WCF RIA services, navigation, search engine optimization, and MEF.
Java EE 8 Web Frameworks: A Look at JSF vs MVCJosh Juneau
This session provides an overview of both the JSF and MVC 1.0 frameworks. The frameworks are then compared to each other. Finally, JSF 2.3 upcoming features are previewed.
Java Server Faces + Spring MVC FrameworkGuo Albert
This document discusses the architecture of a Java Server Faces application integrated with the Spring MVC framework. It describes the presentation and business tiers, including the front controller, UI components, backing beans, views, service beans, and configuration files like web.xml, faces-config.xml, and applicationContext.xml. It also includes class diagrams and details the page flow and configuration of the demo application.
This document provides an overview of JavaServer Faces (JSF), including:
- An introduction to JSF and what it is
- A description of the JSF request lifecycle and faces servlet
- An explanation of JSF component models and commonly used tags
- A step-by-step guide for creating a basic "Hello World" JSF application
- Details about JSP architectures (Model 1 and Model 2) that provide context for JSF
The document discusses the architecture and lifecycle of Enterprise Java Beans (EJB). It explains that a bean runs inside a container that provides services like transactions and security. When a client calls a bean method, the call goes through a two-step process - first to a local proxy stub and then to the bean container. The container then performs any required services before delegating the call to the bean. It also describes the main EJB types - session beans, entity beans, and message-driven beans - and gives examples of each. Finally, it outlines the phases of the JavaServer Faces (JSF) lifecycle when processing a request, including restoring the view, applying values, validating, updating models, invoking the application
Vibrant Technologies is headquarted in Mumbai,India.We are the best Advanced java training provider in Navi Mumbai who provides Live Projects to students.We provide Corporate Training also.We are Best Advanced Java classes in Mumbai according to our students and corporators
Java Server Faces is a framework for building user interfaces for web applications that provides ease-of-use, standardization, and device independence through reusable UI components, easy data transfer between components, custom component implementation, and UI state management across requests. It is intended for use by developers, page authors, application developers, component writers, and tools vendors.
JSF is a Java specification and framework for building component-based user interfaces for web applications. It uses the MVC design pattern with reusable UI components, and handles tasks like data conversion, validation, event handling and navigation. The JSF architecture includes a component tree, request processing lifecycle and rendering model. New features in JSF 2 include Facelets as the default view declaration language, annotation-based configuration, standardized Ajax support, and improved error handling. Developing with JSF involves creating managed bean models, registering them, building pages with UI components, defining navigation, and configuring the web application in web.xml.
Java Server Faces (JSF) is a Java web development framework that provides reusable UI components and a component-based MVC architecture. Key aspects of JSF include:
- Clean separation of behavior and presentation using a component-based MVC model.
- Standard UI components and events tied to server-side code.
- Typical JSF applications include JavaBeans for state/behavior, event-driven development, and JSP view pages that reference a component tree.
The example JSF calculator application demonstrates:
1) Configuring the Faces servlet and managed beans.
2) Developing a model class and controller to mediate between the view and model.
3) Creating
Struts An Open-source Architecture for Web Applicationselliando dias
The document provides an overview of Struts, an open-source MVC framework for building web applications in Java, discussing how to install and configure Struts, its core concepts like the MVC pattern, and how to develop applications using Struts including creating forms, actions, and tag libraries.
This document provides a summary of the major new features in JavaServer Faces (JSF) 2.0, including Facelets as the preferred view declaration language, composite components, Ajax support, partial state saving, view parameters, system events, resources, behaviors, view traversal, annotations, navigation, exceptions, validation, EL improvements, and new scopes. It highlights contributions from the JSF expert group and community and provides resources for learning more about JSF 2.0.
This document provides an overview of the Struts framework and its key components. It covers the model-view-controller design pattern used in Struts, the model components including JavaBeans and ActionForm beans, view components like JSP tags and internationalization, controller components like Action classes and the configuration file, and finally the tag libraries used in Struts. The document is part of a training course on Struts and introduces each major concept across 9 units.
This document provides an overview of JavaServer Faces (JSF), including:
1. JSF is a server-side user interface framework that provides reusable UI components, event handling, validation and integration with backend data for Java web applications.
2. The document outlines key JSF concepts like UI components, events, validators, converters and renderers. It also describes the request processing lifecycle and developer roles.
3. Advanced topics like navigation, internationalization and custom components are listed for discussion in a later session.
Java Spring MVC Framework with AngularJS by Google and HTML5Tuna Tore
The document provides an introduction to the Spring MVC framework. It describes key concepts such as MVC architecture, dependency injection, configuration of the DispatcherServlet, mapping requests to controllers, and defining views. It also discusses configuring ORM/JPA with Hibernate, sending emails, security, exceptions handling, and accessing REST services with RestTemplate. The document aims to give developers an overview of building web applications with Spring MVC.
The document discusses JavaServer Faces (JSF), an MVC framework for building web interfaces. It provides:
- An overview of JSF concepts like managed beans, expression language, navigation rules, and components.
- Examples of using JSF for static and dynamic navigation between pages, including declaring beans and navigation rules in faces-config.xml.
- How JSF handles form submission and uses managed beans to represent request parameters and output data to results pages.
There is a growing demand to build increasingly complex mobile applications with HTML5, in part due to its cross-platform nature. However delivering these applications is still very challenging. The Montage framework was designed from the ground up to build complex HTML5 applications. This talk will explain how Montage’s reusable and encapsulated Components provides a natural and effective way to write modular, robust, applications by allowing team members to work on different part at the same time.
The document discusses the history and architecture of JSF component behaviors. It describes how behaviors allow adding functionality to components through attached objects. A behavior API was introduced to provide a loose coupling between components and behaviors. The API uses client behaviors and behavior holders. The document demonstrates a simple confirm behavior and more advanced auto-suggest behavior to showcase the capabilities of the behavior API.
The document discusses integrating Spring MVC on the server side with Backbone.js on the client side for building Model-View-Controller (MVC) applications. It provides an overview of MVC patterns and how they are implemented in Spring MVC using Java and in Backbone.js using JavaScript. Key aspects covered include using Backbone models and collections to represent and manipulate data, views to render templates and handle user interactions, and routers to manage client-side routing and application states. RESTful APIs are also discussed as a way to communicate between the client-side Backbone code and the server-side Spring MVC application.
This session will provide a complete tour of using the Spring MVC framework to build Java Portlets. It will include an in-depth review of a sample portlet application developed using the latest features of Spring MVC, including Annotation-based Controllers. If you are writing Portlets and using Spring, this session is for you.
We'll begin by discussing the unique differences and challenges when developing Portlets instead of traditional Servlet webapps. Then we'll talk about the unique approach that Spring MVC takes towards Portlets that fully leverages the Portlet lifecycle, instead of masking it like many other frameworks. We'll take an extensive tour of a sample application so we can see all the unique pieces of the framework in action. Finally we'll conclude with discussion of the upcoming support for the Portlet 2.0 (JSR 286) specification that will be part of Spring 3.0.
Mike Taulty MIX10 Silverlight 4 Patterns Frameworksukdpe
The document discusses various frameworks and patterns in Silverlight 4, including ASP.NET client application services, WCF data services, WCF RIA services, navigation, search, and extensibility with MEF. It provides an overview and demos of each technology. The presentation encourages attendees to check the schedule for additional in-depth sessions on topics like OData, WCF data services, WCF RIA services, navigation, search engine optimization, and MEF.
Java EE 8 Web Frameworks: A Look at JSF vs MVCJosh Juneau
This session provides an overview of both the JSF and MVC 1.0 frameworks. The frameworks are then compared to each other. Finally, JSF 2.3 upcoming features are previewed.
Java Server Faces + Spring MVC FrameworkGuo Albert
This document discusses the architecture of a Java Server Faces application integrated with the Spring MVC framework. It describes the presentation and business tiers, including the front controller, UI components, backing beans, views, service beans, and configuration files like web.xml, faces-config.xml, and applicationContext.xml. It also includes class diagrams and details the page flow and configuration of the demo application.
This document provides an overview of JavaServer Faces (JSF), including:
- An introduction to JSF and what it is
- A description of the JSF request lifecycle and faces servlet
- An explanation of JSF component models and commonly used tags
- A step-by-step guide for creating a basic "Hello World" JSF application
- Details about JSP architectures (Model 1 and Model 2) that provide context for JSF
The document discusses the architecture and lifecycle of Enterprise Java Beans (EJB). It explains that a bean runs inside a container that provides services like transactions and security. When a client calls a bean method, the call goes through a two-step process - first to a local proxy stub and then to the bean container. The container then performs any required services before delegating the call to the bean. It also describes the main EJB types - session beans, entity beans, and message-driven beans - and gives examples of each. Finally, it outlines the phases of the JavaServer Faces (JSF) lifecycle when processing a request, including restoring the view, applying values, validating, updating models, invoking the application
These thesis will focus on understanding and briefing introduction about Spring framework, superior properties, outstanding features in creative application that requires modularizing and capacity of reusing high. Beside that, further description of some technologies such as JMS, MongoDB, AngularJS and Bootstrap which are currently software companies use to create a web application enterprise with Spring framework
eTOM awareness presentation. Covers an introduction to NGOSS, TOM to ETOM, exploded view of eTOM 9.0, success steps to transitioning and road map to process management.
Mahmoud Hussien received a Certificate of Achievement for successfully passing the foundational level certification for the Business Process Framework (eTOM) on October 27, 2016. The certificate was issued by Peter Sany, the Chairman and CEO.
Introduction to Active Server Pages (ASP)
ASP.NET
Java Server Pages (JSP), JSP Processing
JSP Life Cycle, JSP Application Design
Tomcat Server, JSP Components: Scriptlets, Directives
JSP Actions
JSP Implicit Objects, Sharing Data between JSP Pages
Session Tracking
JSP Error Handling and Debugging
COM/DCOM
This document provides an overview of eTOM (enhanced Telecom Operations Map) and ITIL (Information Technology Infrastructure Library) frameworks and how they can be combined. It introduces eTOM as a business process framework that represents the processes and functions of a telecommunications enterprise. ITIL is introduced as a collection of best practices for managing IT services. The document explains that eTOM and ITIL have complementary strengths and are mutually supportive, with eTOM providing a business-focused view of processes and ITIL providing IT-focused best practices to support business needs. It outlines how the two frameworks can be viewed as orthogonal and combined by mapping ITIL practices into specific eTOM processes.
Lecture 4: JavaServer Pages (JSP) & Expression Language (EL)Fahad Golra
The document discusses JavaServer Pages (JSP) and the Expression Language (EL) in JEE. It covers key JSP concepts like scripting elements, directive elements, standard action elements, and implicit objects. It also explains the translation of JSP files to servlets, and provides examples of using scripting elements, directives like <jsp:include>, and standard actions.
Applying eTOM (enhanced Telecom Operations Map) Framework to Non-Telecommunic...Alan McSweeney
The document discusses applying the eTOM (enhanced Telecom Operations Map) framework to non-telecommunications companies for product/service/solution innovation. It describes eTOM's processes for product/solution/service lifecycle management from concept to delivery and operation. It also discusses the changes required for companies transitioning to a greater service orientation like utility-based services, including changes to business models, costs, services provided, and customer information and relationships.
Telecommunication Business Process - eTOM FlowsRobert Bratulic
For related eTOM Flows blog: https://modelitics.wordpress.com/2015/07/06/etom-process-flows-not-just-hierarchies
For related eTOM Flows lecture: https://www.youtube.com/watch?v=r62ZjpnjJI0
JSF provides advantages over traditional MVC frameworks like Struts, including custom GUI components, support for different display technologies, simpler configuration and bean definitions. However, JSF also has disadvantages like a steeper learning curve and less transparent operation compared to standard servlets and JSP. Between JSF and Struts, JSF offers more powerful custom components and easier configuration, but Struts has a larger existing user base and more online resources.
Boston 2011 OTN Developer Days - Java EE 6Arun Gupta
The document provides an overview of new features in Java EE 6, including lightweight profiles, annotation-driven programming, and ease of development enhancements like packaging EJBs in WAR files. It lists the Java EE 6 specifications, major changes to specifications like JSF 2.0 and EJB 3.1, and new specifications like CDI 1.0.
Java EE 6 & GlassFish 3: Light-weight, Extensible, and Powerful @ Silicon Val...Arun Gupta
Java EE 6 and GlassFish 3 provide a light-weight, extensible, and powerful platform. Key features include a web profile, pruning of unused specifications, support for open source frameworks, and easier development models with annotations and reduced configuration files. GlassFish 3 is the open source reference implementation of the Java EE 6 platform and includes new features like clustering and centralized administration.
The document provides an overview of Struts, an open source MVC framework for building web applications in Java. It discusses the key components of Struts, including the controller, request processor, actions, and action mappings. The controller acts as the central coordinator and uses action mappings configured in XML to route requests to the appropriate actions. Actions perform business logic and return a forwarding path. The framework handles request processing and forwarding the response to the corresponding view.
Java EE 6 & GlassFish = Less Code + More Power @ DevIgnitionArun Gupta
The document summarizes new features in Java EE 6 and GlassFish v3 that aim to provide developers with more powerful capabilities while requiring less code. Key highlights include annotations to simplify configuration and development, support for RESTful web services and dependency injection, and improvements to Java Server Faces, EJBs, and the Java Persistence API to enhance developer productivity.
The document is a presentation about Java EE 6 and GlassFish. It discusses how Java EE 6 and GlassFish aim to provide developers with less code and more power through features like annotations, simplified configurations, and support for newer Java technologies. It also summarizes some of the new Java EE 6 specifications and how they improve areas like web development, EJBs, JSF, JPA and more.
Development of web apps based on JSF (TU Vienna)blahap
This document discusses the development of web applications using JavaServer Faces (JSF). It provides an overview of JSF, including its architecture, key concepts, and developer roles. It also covers application configuration, backing beans for managing model objects, and page navigation defined through rules in the configuration file. The document demonstrates JSF's capabilities for building user interfaces with reusable components in a model-view-controller pattern.
Java EE 6 & GlassFish = Less Code + More Power at CEJUGArun Gupta
The document discusses Java EE 6 and GlassFish, which provide developers with more power and flexibility while requiring less code. Key features of Java EE 6 like EJB 3.1, CDI, and JSF 2.0 incorporate more annotations and reduce the need for deployment descriptors. GlassFish is the open source reference implementation of Java EE 6 and offers benefits like modularity, embeddability, and support for cloud computing. Future versions of Java EE and GlassFish will focus on continued standards-based innovation.
The document discusses Java Server Pages (JSP) technology which provides a simplified way to create dynamic web content. JSP pages are compiled into servlets, allowing developers to embed Java code directly into HTML pages to interact with databases and other applications. The document covers key aspects of JSP including its architecture, lifecycle, directives like include and taglib, and how it enables rapid development of web applications.
This document discusses the Model-View-Controller (MVC) architecture and how to implement it using servlets and JSP. It begins with an overview of MVC and the benefits of combining servlets and JSP. It then covers implementing MVC with RequestDispatcher to forward requests from servlets to JSP pages, and how to handle relative URLs and share data between the servlet and JSP using request, session, and application scopes. It provides examples of using beans to represent data and accessing bean properties in JSP.
This document provides an overview of Spring and Spring Boot frameworks. It discusses the history of Java and Spring, how Spring provides inversion of control and dependency injection. It also covers Spring MVC for web applications, Spring Data for data access, and how Spring Boot aims to simplify configuration. The document concludes with discussing some next steps including looking at Spring Security, Spring Cloud, and using Spring with other JVM languages.
The document discusses the Struts framework, including its advantages in solving software development challenges through reusable components. It describes the Model-View-Controller architecture that Struts uses, with the controller directing requests to models for data and views for presentation. Key aspects of Struts like configuration files, actions, forms, tags and internationalization are explained at a high level.
Arun Gupta: London Java Community: Java EE 6 and GlassFish 3 Skills Matter
This document discusses Java EE 6 and GlassFish 3. It outlines that Java EE 6 and GlassFish 3 aim to provide a light-weight, extensible, and powerful platform. Key goals for Java EE 6 include making it more flexible, extensible by embracing open source frameworks, and easier to use and develop on. GlassFish 3 is the open source reference implementation of Java EE 6 and includes new features like clustering and centralized administration.
Java EE 6 & GlassFish 3: Light-weight, Extensible, and Powerful @ JAX London ...Arun Gupta
This document discusses Java EE 6 and GlassFish 3. It notes that Java EE 6 and GlassFish 3 aim to provide a light-weight, extensible, and powerful platform. Key features of Java EE 6 include improved ease of development through annotations, updated specifications like JSF 2.0 and EJB 3.1, and a new web profile. GlassFish 3 is the open source reference implementation of Java EE 6 and provides modularity, embeddability, and extensibility. Oracle will continue to develop and support GlassFish going forward.
Java EE 6 - Deep Dive - Indic Threads, Pune - 2010Jagadish Prasath
The document provides an overview of the Java EE 6 platform specifications. Key points include:
- Java EE 6 was completed in 2009 with the reference implementation being GlassFish v3.
- New specifications include Contexts and Dependency Injection for Java EE, Bean Validation, JAX-RS, and Dependency Injection for Java.
- Major updates include JavaServer Faces 2.0, Java Servlets 3.0, Java Persistence 2.0, EJB 3.1 and Interceptors 1.1.
- Servlets 3.0 introduces annotations-based configuration using @WebServlet, @WebListener, and @WebFilter. Asynchronous processing is also supported.
Java EE 6 = Less Code + More Power (Tutorial) [5th IndicThreads Conference O...IndicThreads
Session Presented at 5th IndicThreads.com Conference On Java held on 10-11 December 2010 in Pune, India
WEB: http://J10.IndicThreads.com
------------
Java Platform, Enterprise Edition 6 (JavaEE 6) provides new capabilities that make it easier to develop and deploy enterprise and Web applications. It provides a simplified developer experience and improves on the developer productivity features introduced in JavaEE 5. It breaks the “one size fits all” approach in previous releases with Profiles and offers a comprehensive Web profile for lightweight, standards-based modern Web applications.The Web profile allows developers to build web applications quickly and prevents proliferation of custom web stacks for easier maintainability.
The platform enables extensibility by embracing open source libraries and frameworks such that they are treated as first class citizens of the platform. Several specifications like Contexts & Dependency Injection, Java Server Faces 2, Java API for RESTful Services, Java Persistence API 2, and Servlets 3 make the platform more powerful. All these specifications are implemented in GlassFish Open Source Edition 3 – a modular (OSGi based) light-weight, embeddable, extensible, and the open source reference implementation for Java EE 6. NetBeans, Eclipse, and IntelliJ provide extensive tooling for Java EE 6 and GlassFish Open Source Edition.
This tutorial session will help the attendees learn the latest APIs and develop a complete Java EE 6 application using NetBeans IDE. The attendees will understand the different tips & tricks such as code completion, templates, and wizards for a rapid application deployment. The techniques like session preservation and deploy-on-save are demonstrated to reduce the development lifecycle.
Spring Framework provides a comprehensive infrastructure to develop Java applications. It handles dependency injection and inversion of control so developers can focus on domain logic rather than plumbing. Spring promotes best practices like clean code, test-driven development, and design patterns. It includes aspects for cross-cutting concerns and supports web development through frameworks like Spring MVC. The document introduces Spring's lightweight and modular IoC container and AOP capabilities for separating concerns.
The document provides an overview of server-side scripting technologies including CGI, Java servlets, and JSP. CGI scripts are executed on the web server with disadvantages of high server load. Servlets are Java programs that provide platform independence, performance, extensibility, and safety. JSPs simplify server-side scripting by allowing Java code to be embedded within HTML pages and are translated to servlets. The life cycle of a servlet including initialization, processing requests, and destruction is also summarized.
Java EE 6 : Paving The Path For The FutureIndicThreads
“The Java EE platform is getting an extreme makeover with the upcoming version ? Java EE 6. It is developed as JSR 316 under the Java Community Process.
The Java EE 6 platform adds more power to the platform and yet make it more flexible so that it can be adopted to different flavors of an application. It breaks the ‘one size fits all’ approach with Profiles and improves on the Java EE 5 developer productivity features. It enables extensibility by embracing open source libraries and frameworks such that they are treated as first class citizens of the platform.
Several new specifications such as Java Server Faces 2.0, Servlet 3.0, Java Persistence API 2.0, and Java Context Dependency Injection 1.0 are included in the platform. All these specifications are implemented in GlassFish v3 that providesa light-weight, modular, and extensible platform for your Web applications.
This session provides an overview of Java EE 6 and GlassFish v3. Using multiple simple-to-understand samples it explains the value proposition provided by Java EE 6. “
This document provides an introduction to building web applications using the Jakarta Struts framework. It discusses some of the challenges of building web applications and how Struts addresses these challenges through its implementation of the MVC pattern. It provides an overview of Struts' controller, model, and view components and how they work together. It also presents a case study of building an online poll application with Struts to demonstrate these concepts. Key benefits of Struts like separation of components and reusability are highlighted. The document concludes with tips on getting started quickly with Struts.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
5th LF Energy Power Grid Model Meet-up SlidesDanBrown980551
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
Fueling AI with Great Data with Airbyte WebinarZilliz
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on integration of Salesforce with Bonterra Impact Management.
Interested in deploying an integration with Salesforce for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
OpenID AuthZEN Interop Read Out - AuthorizationDavid Brossard
During Identiverse 2024 and EIC 2024, members of the OpenID AuthZEN WG got together and demoed their authorization endpoints conforming to the AuthZEN API
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Digital Marketing Trends in 2024 | Guide for Staying AheadWask
https://www.wask.co/ebooks/digital-marketing-trends-in-2024
Feeling lost in the digital marketing whirlwind of 2024? Technology is changing, consumer habits are evolving, and staying ahead of the curve feels like a never-ending pursuit. This e-book is your compass. Dive into actionable insights to handle the complexities of modern marketing. From hyper-personalization to the power of user-generated content, learn how to build long-term relationships with your audience and unlock the secrets to success in the ever-shifting digital landscape.
Ocean lotus Threat actors project by John Sitima 2024 (1).pptxSitimaJohn
Ocean Lotus cyber threat actors represent a sophisticated, persistent, and politically motivated group that poses a significant risk to organizations and individuals in the Southeast Asian region. Their continuous evolution and adaptability underscore the need for robust cybersecurity measures and international cooperation to identify and mitigate the threats posed by such advanced persistent threat groups.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Main news related to the CCS TSI 2023 (2023/1695)Jakub Marek
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
Project Management Semester Long Project - Acuityjpupo2018
Acuity is an innovative learning app designed to transform the way you engage with knowledge. Powered by AI technology, Acuity takes complex topics and distills them into concise, interactive summaries that are easy to read & understand. Whether you're exploring the depths of quantum mechanics or seeking insight into historical events, Acuity provides the key information you need without the burden of lengthy texts.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
1. JavaServer Pages™ /Servlets
and Web Application Frameworks
Doris Chen, Ph.D
Staff Engineer This box provides
space for call to
Sun Microsystems, Inc action text, URLs,
or any relevant info
2. Speaker’s Qualifications
● Doris Chen
– Technology Evangelist at Sun Microsystems
– Develops and delivers Code Camps for
J2EE, Java performance tuning, J2ME and web
services technologies for Sun Microsystems
– Speaks around the world concerning
Sun™ technologies
4. How It Fits Together
JSF S1AF
JSTL
Struts
JSP™
java bean, expression
lang.,custom tag lib
Servlet
session tracking, filtering, listener
5. Web Foundation: JSP™/Servlets
● Java Servlet technology since ’96, JSP 1.0
specification in June ’99
● Servlets and JSP technologies:
• JSP 1.2 and Java Servlet 2.3 technologies in the J2EE
1.3 platform (now)
• JSP 2.0 and Java Servlet 2.4 technologies in the J2EE
1.4 platform (proposed final draft)
6. Java Servlet Technology
● Foundation for many technologies
• The JAX-RPC API
• Java portlet technology
• The JAXM API
• Struts, JavaServer Faces™, Sun™ ONE application
framework
● Well understood by industry
7. The JavaServer Pages™
(JSP™) Specification
● JavaServer Pages technology: Building
Block
● Mature spec
● Widely Used
● Many uses of Tag Libraries
● Very good community, look for the
JSP 2.0 release
11. Jakarta Struts
● Struts is an open source framework developed
by the Apache Jakarta project
http://jakarta.apache.org/struts/
– Struts 1.02 is available and Struts 1.1 is in beta
● Struts allows:
– JSP/Servlet developers to fashion their web applications
using the MVC design pattern
– Configure a lot of the default framework objects through
xml configuration files
– Run Servlet2.2/JSP1.1 container and above
12. Model-View-Control (model 2)
MVC Design Pattern
1
Request
(Controller)
Servlet
BROWSER
In
Redirect 3
st
2
an
tia
te
5 (View) (Model)
Java Bean
Response JSP 4
Servlet Container (EIS)
13. Struts: MVC Pattern Implemented
Controller
Model
Action Action
Mapping Action
Servlet
Request (xml)
Client
uses
Response
Action Action
JSP View
Forward Form Model Data
View
14. Struts Components and
Feature
● The View - a JSP or HTML page
● The Model - a Java object ( called a
ActionForm)
● Central controller – ActionServlet
• URI to ActionMapping(Action class) located in struts-
config.xml file
• Action classes
• Adaptors between business layer and web tier
● Validation, Internationalization, Custom
tags for creating HTML, presentation logic,
and templating
15. Model
● Model classes should be coded independent
of the Struts framework
– Maximum code reusability by other applications
● Struts provides default Model components,
most important one ActionForm
• Create model class by extending the Struts
ActionForm class
● Struts provides a org.apache.struts.util.PropertyUtils
has a static method called copyProperties()
– To copy all form properties to your original model
object when your controller receives a form
16. Controller
● The controller is the switch board of MVC
● Directs the user to the appropriate views by
providing the view with the correct model
● The task of directing users to appropriate views
is called “mapping”
● Struts framework provides a base object called
org.apache.struts.action.ActionServlet
17. Controller (Cont.)
Http://myhost/authorize.do
Server configured to pass *.do extensions to
org.apache.struts.action.ActionServlet via a web.xml configuration file
ActionServlet object inspects the URI and tries to match it
against an ActionMapping located in the struts-config.xml file
Instance of appropriate Action class is found and it’s perform() is called
Action object handles the request and returns control to a view
based where the user is within the flow of the application
19. View
● ActionForward object tells JSP page to dispatch
to
● The view in Struts is represented by JSP
● JSP can use ActionForm bean to get output
Model data to display
● Struts contains a series of tag libraries
– Facilitates communication between HTML designers
and developers
– Facilitates dynamic Web content
21. Struts Example
Page 1 Jsp 1 Jsp 2 Jsp 3
Web Browser
Web Server
Form Request/session View
Jsp Engine Bean Form
1 Bean Other
Layer
2 Bean
1
Controller
Struts-
config.
xml
Mappings
• path Action1 Action2 Action3 Action4
• action .java .java .java .java
• [form bean]
• [forwards]
Business
Business Business Business
Bean 1 Bean 2 Bean 3 Logic
Layer
CoreSession CoreSession Socket
Data
MarkVision Server Layer
29. Key JSF Concepts
● UIComponent – JavaBean like classes
─ Render-independent characteristics
─ Base class with standard behaviors
● Standard UIComponent Subclasses:
─ UICommand, UIForm, UIGraphic, UIInput, UIOutput, UIPanel,
UISelectBoolean, UISelectMany, UISelectOne
● FacesEvent – Base class for request and
application events
● Validator – Base class for standard and
application defined validators
30. Key JSF Concepts
● Converter – Plug-in for String-Object
conversion
● FacesContext – Per-Request State:
─ Servlet request, response, session
─ JSF request, response trees
─ Model reference expression evaluators
• Syntax similar to the expression language of the JSP
Standard Tag Library (JSTL) 1.0
• Primary interface between components and the data
provided by (or to) the application
31. Key JSF Concepts
● Renderer – Converts components to and
from a specific markup language
─ Supports render-dependent attributes on
components
─ May support more than one component type
● RenderKit – Library of Renderers
─ Extensible at runtime
─ Basic HTML RenderKit is part of the specification
33. Component Tree
HelloForm
Input Form
text UserName Submit event
Stored Queued
34. Steps in Development Process
● Author the pages using the UI component
tags
• useBean tag
• faces tags:
• faces:form, faces:textentry_input, faces:command_button
● Develop the model objects, which will hold
the data
● Develop navigation handlers
• Define the navigation for the application by
implementing ApplicationHandler class
35. Current Development Status
● Warning – everything above is subject to
change!
● Under development in JSR-127
─ Introduced at JavaOne US 2001
● Large expert group
─ Framework developers, Tools providers, ISVs
● Completed Community Draft status (07/2002)
● Working towards Public Draft release of
specification
36. Current Development Status
● Early Access of Reference Implementation
is also available
● Early Access (pre-Public Draft) Specification
available:
• http://java.sun.com/j2ee/javaserverfaces/
● JSF Public Forum:
• http://forum.java.sun.com/forum.jsp?forum=427
● JSF Comments: jsr-127-
comments@sun.com
● Intranet Site:
http://wspack.sfbay.sun.com/jsf
37. If You Only Remember One
Thing…
● JavaServer Faces is destined to become the
standard mechanism for creating user
interface components for J2EE based web
applications.
39. Sun™ ONE Application
Framework (JATO) Overview
● A J2EE application framework
• Primarily focused on web tier
• Leverage Sun Java Center J2EE Patterns
● Provide a robust, scalable application
foundation
• Application composition via reusable components
• Full-featured event model and high-level tag library
● SOAP & Web Services support / integration
● Leveraged through Sun ONE Studio Wizard-
based visual interfaces
40. Where can the Sun ONE
Application Framework be used?
● Enterprises or ISV's building large
enterprise web applications
● Large development team (10+) focused on
web applications
● Few really know Java APIs at the web tier
or enterprise tier
43. J2EE Design Pattern
● Leverage Sun Java Center J2EE Patterns
• Best practice design patterns for J2EE
development
• Fine grained patterns
• Can be combined into a complete MVC
● Use Model View Controller pattern
(MVC)
44. J2EE patterns used in S1AF
● Business delegate
● View helper
● Composite view
● Service to worker
● Front controller
46. Models
● Implements Business Delegate pattern
– Reduce coupling between presentation tier clients and business
services
– Hides the underlying implementation details of business service
(e.g. JDBC details)
● Provides developers a common interface for using any
Enterprise resource
– Web Service resources
– Database resources
– UIF (Enterprise Connectors) resources
– J2EE Connector Architecture resources
– AND 3rd party created
47. Views
● A union of JSP tags with S1AF view objects
– S1AF JSPs use S1AF tags and othe 3rd party tags
– S1AF views simply refer to model data
● Implements J2EE view helper pattern
– S1AF views allows JSPs to remain Java-free
– Presentation logic is placed in View class
– More than one JSP can use a View Helper
• Allows for variable content rendering
● Implements J2EE Composite View Pattern
– S1AF view may be arbitrarily nested
49. Controller
● Consistes of two patterns
– Front controller
– Service to workers
● Implements front controller pattern
– All requests pass through front controller
– Module servlet serves as front controller
– Single point of entry allows for centralization
of certain types of logic
50. Controller (Cont.)
● Implements ServiceToWorker pattern
– Single service dispatches to request specific
controllers(workers)
• All requests pass through the FrontController
• Controller logic can be partitioned into more fine
grained units for scalability and logical partitioning
– S1AF module servlet dispatches request to
the appropriate worker (controller)
• S1AF controller can be a Command interface
• Developers will implement the command interface
52. View Components
● “ Out of the box” Page components are available such
as Button, Check Box, Combo Box
● 3rd party (SI’s) components can be dynamically added
to the product
59. JSF, Struts and S1AF
● Focus is a bit different
– Struts: encapsulates user-interface more at form or page level
– JSF: UI components, component model for user-interface, Tools
focus
– S1AF: extends MVC and J2EE design pattern and comes with an
extendable but ready-to use base implementation, visual builder
tool
● Some overlap
– Use the parts that are helpful, ignore the parts that are not
– Pick solution best suited to expertise/task
– JSF/Struts integration
http://jakarta.apache.org/builds/jakarta-struts/nightly/struts-
faces/
60. JSF, S1AF, and Struts
● All three communities are represented on
JSR-127 expert group
– The lead developer of Struts, Craig McClanahan, now
works for Sun and is a member of JSF expert group
– S1AF Architect is already participating in expert group
meeting
– Long term strategy:
● S1AF and struts will co-exists/merge with S1af evolving to
use struts controller technology and JSF components
● Goal is to provide a single web-based framework also
monetizes struts technology
61. Where to look further
● JSF
http://java.sun.com/products/j2ee/javaserverfa
● Struts http://jakarta.apache.org/struts
● A good place to start is the S1AF-Tips group:
http://groups.yahoo.com/group/iPlanet-JATO-
Tips/
● FAQ of the larger community forum at:
http://groups.yahoo.com/group/iPlanet -JATO/
● The Whitepaper: http://ias.red.iPlanet.com/jato
● You can get more information at:
http://developer.iPlanet.com/tech/appserver/fr
amework/index.jsp