1st Edition

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

    298 Pages 98 B/W Illustrations
    by Auerbach Publications

    Continue Shopping

    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.

    Introduction to Component-Oriented Development and Assembly (CODA)
    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
         Component Specifications 
         Component Provisioning
         Component Assembly 
         Component-Based Life Cycle
    Advantages of Component-Based Software Engineering
         Parallel Development 
         Easy Maintainability 
         System Evolution 
         Single Point of Maintenance 
         Increased Quality 
         Rapid Prototyping Support
    Review Questions

    Component Thinking in Java
    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
    Review Questions

    Component Models in Java
    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 
         An Example to Understanding the SCA Component Model
    Snapshot of Features of Component Models—EJB, Spring, OSGi, and SCA
    Review Questions


    Component-Oriented App lication Design and Architecture
    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 
    Review Questions

    Practicing CODA with OSGi
    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
    Review Questions

    Practicing CODA with SCA
    What Is SCA?
    SCA Concepts 
         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
    Review Questions

    Enterprise Component-Oriented Development and Assembly Using Java Platform, Enterprise Edition
    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 Manager 
         Persistence Provider 
         Packaging Entities 
         Accessing Entities
    Enterprise CODA Using Java EE—An Example
    Review Questions

    Enterprise Component-Oriented Development and Assembly Using the Spring Component Model
    Spring Component Model
    Spring Container
    Spring Beans
    Spring Configuration
    Spring MVC Model
         Web Configuration File 
    Enterprise CODA Using the Spring MVC Model—An Example 
         View Components 
         Business Components 
         Persistence Components
    Review Questions

    Enterprise Component-Oriented Development and Assembly Using Enterprise OSGi
    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
    Review Questions


    Testing Component-Oriented Software
    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
    Review Questions

    Implementing a Business Application Using CODA—A Case Study
    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

    CODA Tools—Infy CODA Workbench
    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 


    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.

    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