|
Architecting and Designing J2EE Applications in SOA |
Course Overview
Geared for software architects and
designers using J2EE in developing
n-tiered systems, this course
provides students with knowledge
needed to set up a (SOA) based
architecture and design software
using the the Java 2 Platform,
Enterprise Edition (J2EE platform)
to create robust enterprise
applications that allow for rapid
change and growth and other
systematic qualities.
What will I learn?
Participants will gain an understanding of the
strategies needed to create application blueprints
that work well when implementing J2EE technologies.
These strategies include effective decision making through
the use of systemic qualities (such as scalability and
flexibility), J2EE technology blueprints and design
patterns, and iterative and incremental development.
Course Style
Throughout this course, students
will explore a practical case study using the HighView's "Borrow and Fly" System
example. Students will build the systems from the ground up, from requirements
gathering through architecturally correct implementation of a few selected use
cases.
Working within this environment, students will capture the requirements,
investigate systematic qualities and then establish the business Architecture in
terms of Business Components and the services. Students will also learn how to
(and will) define the technical architecture based in the non-functional
requirements (systematic qualities), map their Business Architecture to the
Technical Architecture, and design and build a few components based on that
architecture (this will include EJB 2.1 development).
Throughout the course, students will explore the overall software architecture
(including the presentation tier) and best practices for development. This will
give the students the possibility to design, implement and assemble a solution
for three use cases (using the components developed earlier)
Course Overview
This is an overview of the course. For a detailed description with objectives
per topic, we refer to the detailed workshop overview, listed further below in
this document.
Session: The Business Architecture: Service-Based Design/Development
* Lesson: Introduction to Service Orientation
* Lesson: Describing a Service Oriented Process (SOP)
Session: Applying sCBD's Component Modeling
* Lesson: The Requirements Capture Phase
* Lesson: Defining the Service Architecture
Session: Enterprise Architectures and a Justification for using J2EE
* Lesson: The Technical Enterprise Architecture
* Lesson: J2EE as a Candidate Framework for your Architecture
* Lesson: J2EE vendors and market
Session: Technical overview of J2EE
* Lesson: Overview of the Complete architecture
* Lesson: Presentation Tier
* Lesson: Application Tier
* Lesson: EIS Tier
* Lesson: Security
Session: Mapping to the Technical Architecture
* Lesson: (J2EE) Design Patterns summary
* Lesson: Mapping Components to a (distributed) J2EE Environment
* Lesson: The Internal Design Phase (Component Delivery)
* Lesson: Overall (Web-Based) J2EE Architectures
Appendix: Introduction to UML 2.0
* Lesson: Introduction
* Lesson: Use-Case Models in UML 2.0
* Lesson: Structural and Implementation models
* Lesson: Dynamic models
Appendix: Model Driven Architecture Overview
* Lesson: Overview of MDA
* Lesson: MDA Applied in an Actual Design
Detailed overview
The Business Architecture: Service-Based Design/Development
Lesson: Introduction to Service Orientation
* Understand the move in IT which leads us to Service Orientation and the direct
business value it can bring.
* Understand the possible effect of Components on IT budgets.
* Define a Component
* Define Component Based Development and Design.
* Understand the relationship between Enterprise Architecture and (the need for)
Components.
* Understand the relation between SOA and CBD
* Understand how the functional requirements find their way through the Business
Architecture.
* Describe the requirements of the Software Development Process that leads to
components.
* Understand the potential problem of a Waterfall approach.
* Define iterative and incremental development.
Lesson: Describing a Service Oriented Process (SOP)
* Examine the gap in Software Development between the model and the domain
experts (the source).
* Examine the gap in Software Development between the model and the developers
(the goal).
* Recognize the area of tension between these two gaps.
* Recap/Overview of UML (based on version UML2 including relation between UML,
MOF and XMI)
* Understand that (traditional) OO Development does not/might not leverage all
the possibilities of SOA.
* Understand the concept of "Design by Contract"
* Describe the requirements of the Software Development Process that leads to
services and components.
* Understand the potential problem of a Waterfall approach.
* Define iterative and incremental development.
Applying sCBD's Component Modeling
Lesson: The Requirements Capture Phase
* Use-Cases are covered to get a complete picture of a Software Development
process that delivers Components for your technical environment.
* Understand how to gather system requirements.
* Introduce Use-Cases for the other lessons on component and solution delivery.
* Describe a way of documenting non-functional requirements
Lesson: Defining the Service Architecture
* Understand the steps involved when specifying the component architecture.
* Illustrate a top-down approach for identifying components.
* Describe an informal process for identifying components.
* Describe a formal process for identifying components.
* Explain how you can guarantee that you have all services in place.
* Understand how to model document-oriented services
Enterprise Architectures and a Justification for using J2EE
Lesson: The Technical Enterprise Architecture
* Define the Enterprise (Technical) Architecture and its relationship to Project
Architectures.
* List the four technical characteristics/requirements of an Technical
Enterprise Architecture.
* Understand how the non-functional requirements find their way through the
Technical Architecture.
* For each of the four requirements list possible solutions.
* For each of these solutions, list possible technical approaches.
* Understand the challenges involved with these approaches.
* Understand the nature and reason for the technical challenges that were
created.
* Explain what Middleware can address and what other challenges it brings to the
table.
* Explain the need for a Framework.
* Introduce two Frameworks: .Net and J2EE
Lesson: J2EE as a Candidate Framework for your Architecture
* Get a brief introduction of the J2EE Framework within this context.
* Recap the J2EE Framework architecture.
* Recap the Technical Architecture challenges and recap the technical solutions.
* For each of the technical solutions previously described, understand how J2EE
can address these (or help you).
* Main goal of this part is to determine a foundation for choosing J2EE as the
technical framework for your project or EA.
* Overview of the complete architecture briefly touching all tiers and their
associated J2EE and J2SE technologies.
Lesson: J2EE vendors and market
* List some of the important players in the J2EE Application Server region
* Through the list of players, describe the different types of Servers
* Discuss criteria for choosing an Application Server
Technical overview of J2EE
Lesson: Overview of the Complete architecture
* Get a complete technical overview of the J2EE Platform
* Understand how each tier is addressed in J2EE
* Understand the architectural role of each of the technologies
* Understand the concept of the EAR and the deployment descriptors
* Understand / recap the relationship between J2EE and Web Services
* List the supporting technologies (JMX, JACC, JTA, etc.)
* List the different versions of J2EE and the related versions and APIs
Lesson: Presentation Tier
* List the architectural responsibilities of a Servlet and a JSP
* Understand the role of the Web Container
* Understand Servlet implementation
* Understand JSP implementation
* Understand the architectural role of Custom Tags
* Understand Custom Tag development and use
* Understand the architectural position of JSF
* Understand an Web Application and the web.xml
Lesson: Application Tier
* Understand the three different ways of implementing the application tier.
* Understand Enterprise JavaBeans
* Understand the way an EJB container works
* List the different types of EJBs
* Understand EJB development
* Understand different ways of exposing services as a Web Service
* List the contents of the deployment descriptor
* Understand the life cycle of a Session and an Entity Bean
* Understand Transactions within the context of a distributed environment
* Understand the importance of the transaction isolation level
* List criteria for choosing the transactional configuration for your
application(s)
* Understand the relationship between EJB, IIOP, SOAP and GIOP
Lesson: EIS Tier
* Understand the different technologies to connect with EIS
* Understand the difference between access and integration
* List requirements for integration
* Understand JDBC, JMS and the Connector Architecture
Lesson: Security
* Understand the security tasks and how they are addressed in J2EE
* Understand how to establish proof of identity in J2EE (web and desktop
clients)
* Understand how to restrict access to parts of the web application
* Understand how to restrict access to services
* Understand how to establish data integrity and privacy
* Understand that SSL might no be sufficient in B2B web services
* Explain the configuration of security and the power of indirection
* Discuss different security configurations (including propagation and
delegation)
* List the different authentication mechanisms in BEA Weblogic (security realms)
* Understand how to administer security in BEA (an overview)
* Understand BEA global security
* Understand Users, Groups & Roles
* Understand role based security
* Understand principal mapping strategies
Mapping to the Technical Architecture
Lesson: (J2EE) Design Patterns summary
* J2EE Business Tier Pattern: Business Delegate (Proxy)
* J2EE Business Tier Pattern: Value Objects (Holder).
* J2EE Business Tier Pattern: Service Locator.
* J2EE Integration Patterns: Data Access Objects.
* J2EE Integration Patterns: Service Activator.
* Understand how motivations of certain J2EE Patterns have been addressed by a
top-down approach of CBD.
Lesson: Mapping Components to a (distributed) J2EE Environment
* Understand how the Business Components map to J2SE Components
* Understand how the Business Components map to J2EE Components.
* Understand how this process maps to MDA
* Make a well-founded decision when to use EJBs (or not).
* Emphasize once more the importance of non-functional requirements.
* Understand the impact of a Distributed Architecture on the Business
Architecture (i.e., signatures of services)
* Appreciate the Value Object Pattern (including JavaBean, Structure and XML
strategies).
* Discuss how Technical Components (e.g., Data Access) might be separate
components or sub-components.
* Understand the difference of data transfer between local and a distributed
Component Model
* Choose a deployment topology based on QoS requirements
Lesson: The Internal Design Phase (Component Delivery)
* Understand the steps involved in the internal design of components
* Discuss patterns and best practices can be used inside the component design.
* Understand the role of the EJB local interface in component design.
* Understand how parts of XP can be used in this phase
Lesson: Overall (Web-Based) J2EE Architectures
* Discuss different J2EE Web Application Architectures.
* Understand the benefits and challenges for each of these architectures.
* (Re)establish the architectural role of JSPs, Servlets, Custom Tags, EJBs,
etc.
* Possible role in the Presentation tier of the XML/XSL combination in J2EE
Applications.
Appendences
Introduction to UML 2.0
Lesson: Introduction
* Position UML in Software Development
* Place UML 2.0 within a historical context
* Relation and combination of UML, MOF and XMI
* Understand the most important changes made in UML 2.0
Lesson: Use-Case Models in UML 2.0
* Understand the Use-Case Diagram
* Introduce the concept of a Use case, Actor and Relationships
* Appreciate the changes in UML 2.0
Lesson: Structural and Implementation models
* Understand the structural models in UML
* Appreciate the Ball-and-socket notation for interfaces
* Understand the concept of a Port
* Explain the UML2.0 diagram Composite Structural
* Understand how UML2.0 helps Service and Component Based development
Lesson: Dynamic models
* Understand the behavioral models in UML
* Appreciate the Sequence Diagram to model interaction between system components
* Appreciate the State Machine to model the life cycle of a system and its
components
* Appreciate the Communication Diagram (aka Collaboration Diagram)
* Appreciate the Activity Diagram
* Appreciate the Protocol State Machine
* Explain the UML2.0 Timing Diagram
* Explain the UML 2.0 Interaction overview Diagram
Model Driven Architecture Overview
Lesson: Overview of MDA
* Understand why MDA is a logical step in software development.
* Understand the basic concepts of MDA.
* Understand how UML and MDA relate.
* Understand how model transformations can be realized.
Lesson: MDA Applied in an Actual Design
* Demonstrate how a tool can support an MDA process
* Demonstrate creation of the CIM, PIM and PSM models
* Demonstrate round trip code generation
* Demonstrate how models stay synchronized
Hands-on lab exercises
1. Define the System Requirements (Creating the PIM)-The objective is not
so much the use-case modelling, but the use-case modelling exercise is added so
that you see all the steps. Furthermore, it will give you insight into the High
View system.
2. Identifying the Business Components (elaborate the PIM)-The objective is to
understand ways of identifying components and how to find their services.
3. Identify Services-Understand how to identify Component Services and verify
completeness using a formal approach.
4. Writing a Servlet and a JSP applying Model2 (Optional)-The objective of this
(optional) exercise is to develop JSP and Servlet using the Model2 architecture.
Depending on the group, time can be allocated for this exercise.
5. Writing a Session Bean (optional)-The objective of this (optional) exercise
is to develop and deploy an EJB. Depending on the group, time can be allocated
for this exercise.
6. Define high-level Technical Architecture for the business tier-Understand how
to model a high-level technical architecture in terms of layers, their
dependence, important patterns, frameworks and solutions.
7. Mapping the Component model to a J2EE (Creating the PSM)-The objective is to
create a J2EE Specific model. You will have to map components to the J2EE
Platforms respecting the non-technical (QoS) requirements.
8. Design Components ("Design by Contract")-The objective is to understand how a
component is further designed and developed once it has been mapped to the J2EE
platform
Prerequisites
Students should be able to describe
the different J2EE components.
Students should also have a working
knowledge of UML.
Recommended Follow-On Courses
.
Duration
5 days
Next Dates
Please call for dates
Cost
£1,500 plus VAT