SOA ile J2EE Uygulamaları Mimarisi ve Tasarımı

Kurs Dili: İngilizce

Süre: 4 gün

J2EE ile n-katmanlı sistem geliştirme üzerine çalışan yazılım mimarisi ve tasarımı uzmanları dikkate alınarak tasarlanmıştır. Bu kurs, katılımcılarının esnek, güvenilir "Enterprise" seviyesinde uygulamalar geliştirmek üzere Java 2 ve/veya J2EE kullanarak SOA (servis-odaklı-mimari) tabanlı mimari ve tasarım yazılımı geliştirme konusunda gereken birikim ve beceriyi oluşturmalarında yardımcı olur. Katılımcılar J2EE teknolojilerinin uygulamasında gereksinim duyacakları temel prensip ve tekniklerin oluşturulmasında gerekli stratejileri anlamış ve öğrenmiş olacaklardır. Bu stratejiler arasında sistem özelliklerini (ölçeklenebilirlik ve esneklik gibi) kullanarak etkin kararlar alabilme, J2EE teknolojileri tasarım modelleri (design patterns), artırmalı (incremental) ve yinelemeli (iterative) geliştirme sayılabilir. Kurs süresince "Highview's Borrow and Fly" sistem örneği üzerine pratik uygulamalarla vaka çalışmaları yapılmaktadır. Burada katılımcıların önceden belirlenmiş örnekler üzerinde isterlerin toplanmasından mimarinin doğru uygulanması fazlarına kadar sistemi başlangıçtan kurmaları beklenmektedir. Bu tür bir çalışma ile katılımcılar, isterleri tespit etmeyi, sistematik kalite ölçütlerini analiz etmeyi, iş bileşenleri ve servisleri terminolojisi ile mimariyi oluşturmayı öğrenmiş olacaklardır. Katılımcılar aynı zamanda fonksiyonel olmayan isterlere (sistematik kalite ölçütleri) bağlı olarak teknik mimariyi tanımlamayı, iş mimarisini teknik mimariyle ilişkilendirmeyi ve bu mimariye bağlı olarak bazı bileşenleri tasarlamayı ve inşa etmeyi de öğrenmiş olacaklardır (EJB 2.1 ile geliştirme gibi). Kursta ayrıca genel yazılım mimarisi (sunum katmanı ile birlikte) ve yazılım geliştirmede kullanılan temel pratik ve teknikler de kapsanmaktadır. Bu özelliği ile kurs, katılımcılara tasarım, uygulama, ve öncesinde geliştirilen bileşenleri kullanarak çözümü bir araya getirme konusunda bir çalışma olanağı sağlamaktadır.

Kimler katılabilir? J2EE mimarisi, sistem tasarım ve geliştirme üzerine çalışan profesyoneller. Katılımcıların J2EE bileşenleri ve UML konusunda temel bilgiye sahip oldukları varsayılmaktadır.

Kurs İçeriği

Session 1: 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.

• 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.

• 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

• 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

• 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

• 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.

• 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

• 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

• 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

• 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

• 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

• 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

• 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.

• 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

• 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

• 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.

• 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

• Understand the Use-Case Diagram
• Introduce the concept of a Use case, Actor and Relationships
• Appreciate the changes in UML 2.0

• 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

• 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

• 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.

• Demonstrate how a tool can support a MDA process
• Demonstrate creation of the CIM, PIM and PSM models
• Demonstrate round trip code generation
• Demonstrate how models stay synchronized

• Understand why we use Patterns
• Develop a crisp understanding of Patterns
• Discuss Design Patterns in particular
• Understand the sound design principles implemented by Patterns

• Introduce and Explain AbstractFactory in Details
• Write systems independent of how its objects are created
• Make design decisions based on the advantages and disadvantages of the AbstractFactory design pattern
• Introduce the Factory Method
• Demonstrate how to dynamically create objects without knowing their concrete classes

• Understand how to reduce dependency amongst objects
• Understand how the Observer pattern enables us to achieve this
• Understand how clients can traverse a set of any data elements or objects.
• Learn how to design classes independent of operations that apply to them
• Learn to concentrate the logic distributed over multiple classes in a single place
• Demonstrate how it would be possible to uncouple a sender of a request from a number of possible handlers.
• Understand the Command Pattern, and demonstrate how they allow us to treat requests like objects

• Understand the adapter pattern
• Write a common interface for a group of related classes
• Learn to recognize the situations where the Facade pattern can be effectively applied
• Understand the decorator pattern