Component- Oriented Development and Assembly : Paradigm, Principles, and Practice using Java (Hardcover)

Introduction to Component-Oriented Development and Assembly (CODA)
Introduction
Motivation for Software Components
Components?An Ice Breaker
Component Characteristics
     Part of a Whole
     Component Ecosystem
     Component Framework
     Component Model
     Component Interfaces 
     Provided and Required Interfaces
     Component Compatibility
     Implementation Independence
     Producer-Consumer Independence 
     Active and Passive Component
Historical Perspective of Software Components
Defining Software Components
     Function Libraries as Software Components 
     Object Libraries as Software Components
Elements of a Software Component 
     Component Specification 
     Component Interfaces
     Component Implementation
     Component Model
Component-Based Software Engineering
     Requirements 
     Component Specifications 
     Component Provisioning
     Component Assembly 
     Testing 
     Deployment 
     Component-Based Life Cycle
Advantages of Component-Based Software Engineering
     Reusability 
     Parallel Development 
     Easy Maintainability 
     System Evolution 
     Single Point of Maintenance 
     Increased Quality 
     Rapid Prototyping Support
Summary
Review Questions

Component Thinking in Java
Introduction
Component Constructs in Java SE
Java Software Components Using JAR and Package 
Java Interfaces to the Rescue of Build Time Tight Coupling
Runtime Dependencies While Using Interfaces
Manual Component Assembly Using Glue Code
Automated Component Assembly Using Component Framework
Example Component Model
Summary
Review Questions

Component Models in Java
Introduction
Understanding Components
Enterprise JavaBeans Component Model 
     Business Interface
     EJB Component
     EJB Container
     Component Reference 
     An Example to Understanding the EJB Component Model
Spring Component Model 
     Spring Container 
     Spring Beans 
     Spring Configuration 
     An Example to Understanding the Spring Component Model
OSGi Component Model 
     OSGi Bundle
     OSGi Service Registry 
     OSGi Component 
     An Example to Understanding the OSGi Component Model 
          Interface Bundle
          Implementation Bundle
          Client Bundle
Service Component Architecture Model 
     Services 
     Component 
     Composite 
     Domain 
     An Example to Understanding the SCA Component Model
Snapshot of Features of Component Models?EJB, Spring, OSGi, and SCA
Summary
Review Questions

PRACTICE

Component-Oriented App lication Design and Architecture
Introduction
Componentizing a Monolithic Application 
     Analysis of Monolithic Implementation of the Virtual Store
     Componentizing the Virtual Store 
     Analysis of Componentized Implementation of the Virtual Store 
     Accommodating Changes to the Virtual Store
Componentizing Applications with Multiple Layer Architecture 
     Existing Design of POS Layered Application 
          Objects in the Model 
          Design of Presentation Layer 
          Design of Business Layer 
          Design of the Persistence Layer 
     Analysis of Existing Design of POS Application 
     Componentizing the POS Application 
     Component Replacement in the POS Application 
Summary
Review Questions

Practicing CODA with OSGi
Introduction
What Is OSGi?
Necessity of OSGi
The OSGi Module Layer 
     Internal Bundle Class Path 
     Exported Internal Code 
     Imported External Code
OSGi Runtime Framework
OSGi Life Cycle Layer
OSGi Service Layer
OSGi Declarative Services Specification
Summary
Review Questions

Practicing CODA with SCA
Introduction
What Is SCA?
SCA Concepts 
     Component 
     Composite 
     Wiring
     SCA Runtime and Domain
Creating an SCA Component from Java Implementation
Creating SCA Components and Composites 
     Component Element of a Composite 
     Service Element of a Composite 
     Reference Element of a Composite
     Property Element of a Composite
PosGuest Composite
Deploying and Consuming SCA Composites
Summary
Review Questions

Enterprise Component-Oriented Development and Assembly Using Java Platform, Enterprise Edition
Introduction
Presentation Tier Components 
     Web Component Model?Java Servlet 
     Web Component Model?Java Server Pages 
     Web Component Model?Java Server Faces 
     Web Container 
     Packaging Web Components
Business Tier Components 
     Business Interface 
     EJB Container 
     Enterprise JavaBean Component Types
          Stateless Session Beans 
          Stateful Session Beans 
          Singleton Session Beans 
          Message-Driven Beans 
     Packaging Enterprise JavaBean Components 
     Accessing Enterprise JavaBean Components
Persistence Tier Components 
     Entity 
     Entity Manager 
     Persistence Provider 
     Packaging Entities 
     Accessing Entities
Enterprise CODA Using Java EE?An Example
Summary
Review Questions

Enterprise Component-Oriented Development and Assembly Using the Spring Component Model
Introduction
Spring Component Model
Spring Container
Spring Beans
Spring Configuration
Spring MVC Model
     DispatcherServlet 
     Web Configuration File 
     Controller 
     Views
Enterprise CODA Using the Spring MVC Model?An Example 
     View Components 
     Business Components 
     Persistence Components
Summary
Review Questions

Enterprise Component-Oriented Development and Assembly Using Enterprise OSGi
Introduction
Enterprise OSGi?An Introduction
Enterprise OSGi?Application Structure 
Web Application Service
Blueprint Container Specification
JPA Service
Enterprise CODA Using Enterprise OSGi?An Example 
     Persistence Bundle 
     Blueprint Bundle 
     Web Application Bundle
Summary
Review Questions

PARADIGM

Testing Component-Oriented Software
Introduction
Concepts in Software Testing
Concepts in Component-Oriented Software Testing
Validation of Component Interfaces 
     Example of White-Box Validation 
     Example of Black-Box Validation
Verification of Component Implementation?White-Box Testing
Verification of Component Functionality?Black-Box Testing 
     Test Case for Number of Tables 
     Test Case for Occupy Table Functionality
     Test Case for Empty Table Functionality
Summary
Review Questions

Implementing a Business Application Using CODA?A Case Study
Introduction
Case Study Problem?Point-of-Sale Application for Restaurants 
     Use Case 1?Configure Dining Tables 
     Use Case 2?Create New Menu Item 
     Use Case 3?Modify/Remove Existing Menu Item 
     Use Case 4?Check-In Guests 
     Use Case 5?Place Order 
     Use Case 6?Modify/Cancel Order
     Use Case 7?Print Receipt
     Use Case 8?Guests Checkout
POS-Component-Oriented Design 
     POS Architecture
     Domain Model Design 
     Presentation Tier Design 
          Realization of UC1?Configure Dining Tables 
          Realization of UC2?Create Menu Item and UC3?Modify/Remove Menu Item           
          Realization of UC4?Check-In Guests 
          Realization of UC5?Place Order 
          Realization of UC6?Modify/Cancel Order 
          Realization of UC7?Print Receipt
          Realization of UC8?Guest Checkout 
     Business Tier Design
     Design of TableBiz Component 
     Design of FoodBiz Component
     Design of OrderBiz Component 
     Design of BillBiz Component 
     Consolidated Design 
     Persistence Tier Design
Implementation of the POS Application Using the OSGi Component Framework
Implementation of the POS Application?Using Service Component Architecture
Implementation of the POS Application?Using the Enterprise OSGi Component Framework
Implementation of the POS Application?Using the Spring Component Framework
Implementation of the POS Application?Using the Java EE Framework
Summary

CODA Tools?Infy CODA Workbench
Introduction
Infy CODA Workbench?The Features
CODA Workbench?User Interface
Viewing Repository?Components Section and Properties Section
Assembling Components into Application?Assembly Area and Potential Components Sections
Test Execution of Assembled Application?Console Section 
     Summary