1st Edition

Component- Oriented Development and Assembly
Paradigm, Principles, and Practice using Java




ISBN 9781466580992
Published December 4, 2013 by Auerbach Publications
298 Pages 98 B/W Illustrations

USD $81.95

Prices & shipping based on shipping country


Preview

Book Description

Although industry has been leveraging the advancements of component-oriented development and assembly (CODA) technology for some time, there has long been a need for a book that provides a complete overview of the multiple technologies that support CODA. Filling this need, Component-Oriented Development and Assembly supplies comprehensive coverage of the principles, practice, and paradigm of component-oriented development and assembly.

The first part of the book provides the conceptual foundation for component-oriented software. Part II focuses on the various standard Java component models and describes how to develop a component-oriented system using these component models. Part III covers the various aspects of the component-oriented development paradigm.

Based on the authors’ research and teaching experience, the text focuses on the principles of component-oriented software development from a technical concepts perspective, designer’s perspective, programmer’s perspective, and manager’s perspective. Covering popular component development frameworks based on Java, it is suitable as a textbook for component-oriented software for undergraduate and postgraduate courses. It is also an ideal reference for anyone looking to adopt the component-oriented development paradigm.

The book provides readers with access to all the source code used in the book on a companion site (http://www.codabook.com). The source code for the CODA implementation of the case study presented in Chapter 11 is also hosted on the website. The website will also serve as a technical forum for further discussions on the topic and for any updates to the book.

Table of Contents

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

...
View More

Author(s)

Biography

Piram Manickam is an ardent technologist. During the past two decades he has worked with many software development teams and built a number of systems using various development platforms. He has a special interest in object-oriented design. He has authored many technical articles. Manickam has been practicing and teaching component-oriented development and assembly (CODA) for the last few years. He is a technical consultant and architect on many software component–based projects at Infosys. Manickam is a graduate of electronics and communication engineering from Regional Engineering College (currently NIT) in Tiruchirapalli, India.

S. Sangeetha has been in a senior technical architect role at Infosys. She has been working on Java, Java EE–related technologies, for more than 14 years. She is involved in the design and development of prototypes and POCs on several enterprise application solutions. She is also involved in grooming architects at Infosys through an Initiative called Connect Architecture. Her responsibilities include designing, developing, and delivering Java EE–related courses to various roles. She has been practicing and teaching component-oriented development and assembly (CODA) for the last few years. Sangeetha has authored many technical articles and coauthored a book titled J2EE Architecture. She has a bachelor’s degree in engineering (electronics communication engineering) from Madras University.

S. V. Subrahmanya (also known as SVS) has more than 25 years of experience in the information technology industry and academics. SVS is currently working at Infosys limited as vice president and is a research fellow at Infosys. He heads the E-Commerce Research Labs. He is also responsible for competency development of employees across the technical spectrum including new upcoming areas of technology at Infosys. SVS has published many papers in reputed journals and international conferences. He has coauthored books titled Discrete Structures, Web Services: An Introduction, J2EE Architecture, and Enterprise IT Architecture.

Reviews

The authors provide a carefully thought-out treatment of software components and component-oriented development. They do so in a manner that is, at the same time, rigorous and accessible to a spectrum of readers: from those who are generally knowledgeable in software engineering but do not have a background in component-oriented development, to those who have significant prior exposure but are looking to shore up their knowledge and develop expertise in the state of the art. ... a valuable addition to any software engineer’s bookshelf!
Professor Nenad Medvidović, Computer Science Department, University of Southern California